diff --git a/.gitattributes b/.gitattributes index dfe0770424..0269fab9cb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,3 @@ # Auto detect text files and perform LF normalization * text=auto +*.sol linguist-language=Solidity diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 6076fe46a4..79c7a53014 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -5,5 +5,8 @@ accounts/usbwallet @karalabe consensus @karalabe core/ @karalabe @holiman eth/ @karalabe +les/ @zsfelfoldi +light/ @zsfelfoldi mobile/ @karalabe p2p/ @fjl @zsfelfoldi +whisper/ @gballet @gluk256 diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md index a332b815d0..9f2dbfcb80 100644 --- a/.github/CONTRIBUTING.md +++ b/.github/CONTRIBUTING.md @@ -2,7 +2,7 @@ Before you do a feature request please check and make sure that it isn't possible through some other means. The JavaScript enabled console is a powerful feature -in the right hands. Please check our [Bitchin' tricks](https://github.com/ethereum/go-ethereum/wiki/bitchin-tricks) wiki page for more info +in the right hands. Please check our [Wiki page](https://github.com/ethereum/go-ethereum/wiki) for more info and help. ## Contributing diff --git a/.github/no-response.yml b/.github/no-response.yml new file mode 100644 index 0000000000..a6227159d1 --- /dev/null +++ b/.github/no-response.yml @@ -0,0 +1,11 @@ +# Number of days of inactivity before an Issue is closed for lack of response +daysUntilClose: 30 +# Label requiring a response +responseRequiredLabel: more-information-needed +# Comment to post when closing an Issue for lack of response. Set to `false` to disable +closeComment: > + This issue has been automatically closed because there has been no response + to our request for more information from the original author. With only the + information that is currently in the issue, we don't have enough information + to take action. Please reach out if you have or find the answers we need so + that we can investigate further. diff --git a/.github/stale.yml b/.github/stale.yml new file mode 100644 index 0000000000..c621939c3f --- /dev/null +++ b/.github/stale.yml @@ -0,0 +1,17 @@ +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 366 +# Number of days of inactivity before a stale issue is closed +daysUntilClose: 42 +# Issues with these labels will never be considered stale +exemptLabels: + - pinned + - security +# Label to use when marking an issue as stale +staleLabel: stale +# Comment to post when marking an issue as stale. Set to `false` to disable +markComment: > + This issue has been automatically marked as stale because it has not had + recent activity. It will be closed if no further activity occurs. Thank you + for your contributions. +# Comment to post when closing a stale issue. Set to `false` to disable +closeComment: false diff --git a/.gitignore b/.gitignore index 3a5acef9f3..3e0009e167 100644 --- a/.gitignore +++ b/.gitignore @@ -34,7 +34,14 @@ profile.cov # IdeaIDE .idea +# VS Code +.vscode + # dashboard +/dashboard/assets/flow-typed /dashboard/assets/node_modules /dashboard/assets/stats.json -/dashboard/assets/public/bundle.js +/dashboard/assets/bundle.js +/dashboard/assets/package-lock.json + +**/yarn-error.log diff --git a/.mailmap b/.mailmap index d51c7b6093..cc4b871a3c 100644 --- a/.mailmap +++ b/.mailmap @@ -65,7 +65,8 @@ Enrique Fynn Vincent G -RJ Catalano +RJ Catalano +RJ Catalano Nchinda Nchinda @@ -109,3 +110,14 @@ Frank Wang Gary Rong Guillaume Nicolas + +Sorin Neacsu +Sorin Neacsu + +Valentin Wüstholz +Valentin Wüstholz + +Armin Braun + +Ernesto del Toro +Ernesto del Toro diff --git a/.travis.yml b/.travis.yml index cc1b185fce..bf25215602 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,50 +6,39 @@ matrix: - os: linux dist: trusty sudo: required - go: 1.7.x + go: 1.9.x script: - sudo modprobe fuse - sudo chmod 666 /dev/fuse - sudo chown root:$USER /etc/fuse.conf - go run build/ci.go install - - go run build/ci.go test -coverage - - - os: linux - dist: trusty - sudo: required - go: 1.8.x - script: - - sudo modprobe fuse - - sudo chmod 666 /dev/fuse - - sudo chown root:$USER /etc/fuse.conf - - go run build/ci.go install - - go run build/ci.go test -coverage + - go run build/ci.go test -coverage $TEST_PACKAGES # These are the latest Go versions. - os: linux dist: trusty sudo: required - go: 1.9.x + go: 1.10.x script: - sudo modprobe fuse - sudo chmod 666 /dev/fuse - sudo chown root:$USER /etc/fuse.conf - go run build/ci.go install - - go run build/ci.go test -coverage + - go run build/ci.go test -coverage $TEST_PACKAGES - os: osx - go: 1.9.x + go: 1.10.x script: + - unset -f cd # workaround for https://github.com/travis-ci/travis-ci/issues/8703 - brew update - - brew install caskroom/cask/brew-cask - brew cask install osxfuse - go run build/ci.go install - - go run build/ci.go test -coverage + - go run build/ci.go test -coverage $TEST_PACKAGES # This builder only tests code linters on latest version of Go - os: linux dist: trusty - go: 1.9.x + go: 1.10.x env: - lint git: @@ -57,14 +46,12 @@ matrix: script: - go run build/ci.go lint - # This builder does the Ubuntu PPA and Linux Azure uploads + # This builder does the Ubuntu PPA upload - os: linux dist: trusty - sudo: required - go: 1.9.x + go: 1.10.x env: - ubuntu-ppa - - azure-linux git: submodules: false # avoid cloning ethereum/tests addons: @@ -73,11 +60,25 @@ matrix: - devscripts - debhelper - dput - - gcc-multilib - fakeroot script: - # Build for the primary platforms that Trusty can manage - go run build/ci.go debsrc -signer "Go Ethereum Linux Builder " -upload ppa:ethereum/ethereum + + # This builder does the Linux Azure uploads + - os: linux + dist: trusty + sudo: required + go: 1.10.x + env: + - azure-linux + git: + submodules: false # avoid cloning ethereum/tests + addons: + apt: + packages: + - gcc-multilib + script: + # Build for the primary platforms that Trusty can manage - go run build/ci.go install - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - go run build/ci.go install -arch 386 @@ -87,13 +88,13 @@ matrix: - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-arm-linux-gnueabihf libc6-dev-armhf-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross - sudo ln -s /usr/include/asm-generic /usr/include/asm - - GOARM=5 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm + - GOARM=5 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - GOARM=6 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm + - GOARM=6 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - GOARM=7 CC=arm-linux-gnueabihf-gcc go run build/ci.go install -arch arm + - GOARM=7 go run build/ci.go install -arch arm -cc arm-linux-gnueabihf-gcc - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - CC=aarch64-linux-gnu-gcc go run build/ci.go install -arch arm64 + - go run build/ci.go install -arch arm64 -cc aarch64-linux-gnu-gcc - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds # This builder does the Linux Azure MIPS xgo uploads @@ -101,7 +102,7 @@ matrix: dist: trusty services: - docker - go: 1.9.x + go: 1.10.x env: - azure-linux-mips git: @@ -125,7 +126,7 @@ matrix: # This builder does the Android Maven and Azure uploads - os: linux - dist: precise # Needed for the android tools + dist: trusty addons: apt: packages: @@ -145,16 +146,16 @@ matrix: git: submodules: false # avoid cloning ethereum/tests before_install: - - curl https://storage.googleapis.com/golang/go1.9.2.linux-amd64.tar.gz | tar -xz + - curl https://storage.googleapis.com/golang/go1.10.3.linux-amd64.tar.gz | tar -xz - export PATH=`pwd`/go/bin:$PATH - export GOROOT=`pwd`/go - export GOPATH=$HOME/go script: # Build the Android archive and upload it to Maven Central and Azure - - curl https://dl.google.com/android/repository/android-ndk-r15c-linux-x86_64.zip -o android-ndk-r15c.zip - - unzip -q android-ndk-r15c.zip && rm android-ndk-r15c.zip - - mv android-ndk-r15c $HOME - - export ANDROID_NDK=$HOME/android-ndk-r15c + - curl https://dl.google.com/android/repository/android-ndk-r16b-linux-x86_64.zip -o android-ndk-r16b.zip + - unzip -q android-ndk-r16b.zip && rm android-ndk-r16b.zip + - mv android-ndk-r16b $HOME + - export ANDROID_NDK=$HOME/android-ndk-r16b - mkdir -p $GOPATH/src/github.com/ethereum - ln -s `pwd` $GOPATH/src/github.com/ethereum @@ -162,7 +163,7 @@ matrix: # This builder does the OSX Azure, iOS CocoaPods and iOS Azure uploads - os: osx - go: 1.9.x + go: 1.10.x env: - azure-osx - azure-ios @@ -184,13 +185,14 @@ matrix: - xctool -version - xcrun simctl list + # Workaround for https://github.com/golang/go/issues/23749 + - export CGO_CFLAGS_ALLOW='-fmodules|-fblocks|-fobjc-arc' - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds # This builder does the Azure archive purges to avoid accumulating junk - os: linux dist: trusty - sudo: required - go: 1.9.x + go: 1.10.x env: - azure-purge git: diff --git a/AUTHORS b/AUTHORS index faa19d281c..bd44a3de55 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,85 +1,173 @@ # This is the official list of go-ethereum authors for copyright purposes. +Afri Schoedon <5chdn@users.noreply.github.com> +Agustin Armellini Fischer +Airead +Alan Chen +Alejandro Isaza Ales Katona Alex Leverington +Alex Wu Alexandre Van de Sande +Ali Hajimirza +Anton Evangelatov +Arba Sasmoyo +Armani Ferrante +Armin Braun Aron Fischer Bas van Kervel Benjamin Brent +Benoit Verkindt +Bo +Bo Ye +Bob Glickstein Brian Schroeder Casey Detrio +Chase Wright Christoph Jentzsch Daniel A. Nagy +Daniel Sloof +Darrel Herbst +Dave Appleton Diego Siqueira +Dmitry Shulyak +Egon Elbre +Elias Naur Elliot Shepherd Enrique Fynn +Ernesto del Toro Ethan Buchman +Eugene Valeyev +Evangelos Pappas +Evgeny Danilenko <6655321@bk.ru> Fabian Vogelsteller +Fabio Barone Fabio Berger +FaceHo Felix Lange +Fiisio Frank Wang +Furkan KAMACI Gary Rong +George Ornbo Gregg Dourgarian +Guillaume Ballet Guillaume Nicolas Gustav Simonsson Hao Bryan Cheng Henning Diedrich Isidoro Ghezzi +Ivan Daniluk Jae Kwon Jamie Pitts +Janoš Guljaš Jason Carver +Jay Guo Jeff R. Allen Jeffrey Wilcke Jens Agerberg +Jia Chenhui +Jim McDonald +Joel Burget Jonathan Brown Joseph Chow Justin Clark-Casey Justin Drake Kenji Siu Kobi Gurkan +Konrad Feldmeier +Kurkó Mihály +Kyuntae Ethan Kim Lefteris Karapetsas Leif Jurvetson +Leo Shklovskii Lewis Marshall +Lio李欧 Louis Holbrook Luca Zeug +Magicking Maran Hidskes Marek Kotewicz +Mark Martin Holst Swende Matthew Di Ferrante Matthew Wampler-Doty +Maximilian Meister Micah Zoltu +Michael Ruminer +Miguel Mota +Miya Chen Nchinda Nchinda Nick Dodson Nick Johnson +Nicolas Guillaume +Noman +Oli Bye +Paul Litvak Paulo L F Casaretto +Paweł Bylica Peter Pratscher +Petr Mikusek Péter Szilágyi -RJ Catalano +RJ Catalano Ramesh Nair Ricardo Catalinas Jiménez +Ricardo Domingos +Richard Hart +Rob +Robert Zaremba +Russ Cox Rémy Roy +S. Matthew English Shintaro Kaneko +Sorin Neacsu Stein Dekker +Steve Waldman Steven Roose Taylor Gerring Thomas Bocek +Ti Zhou Tosh Camille -Valentin Wüstholz +Valentin Wüstholz Victor Farazdagi Victor Tran Viktor Trón Ville Sundell Vincent G Vitalik Buterin +Vitaly V Vivek Anand Vlad Gluhovsky Yohann Léon Yoichi Hirai +Yondon Fu +Zach Zahoor Mohamed +Zoe Nolan Zsolt Felföldi +am2rican5 +ayeowch +b00ris +bailantaotao +baizhenxuan +bloonfield +changhong +evgk +ferhat elmas holisticode +jtakalai ken10100147 ligi +mark.lin +necaremus +njupt-moon <1015041018@njupt.edu.cn> +nkbai +rhaps107 +slumber1122 +sunxiaojun2014 +terasum +tsarpaul xiekeyang +yoza ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com> Максим Чусовлянов diff --git a/Dockerfile b/Dockerfile index f4396fcf28..edf5a0602d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,5 +1,5 @@ # Build Geth in a stock Go builder container -FROM golang:1.9-alpine as builder +FROM golang:1.10-alpine as builder RUN apk add --no-cache make gcc musl-dev linux-headers @@ -12,5 +12,5 @@ FROM alpine:latest RUN apk add --no-cache ca-certificates COPY --from=builder /go-ethereum/build/bin/geth /usr/local/bin/ -EXPOSE 8545 8546 30303 30303/udp 30304/udp +EXPOSE 8545 8546 30303 30303/udp ENTRYPOINT ["geth"] diff --git a/Dockerfile.alltools b/Dockerfile.alltools index 79bf0f8d56..e54e107bf3 100644 --- a/Dockerfile.alltools +++ b/Dockerfile.alltools @@ -1,5 +1,5 @@ # Build Geth in a stock Go builder container -FROM golang:1.9-alpine as builder +FROM golang:1.10-alpine as builder RUN apk add --no-cache make gcc musl-dev linux-headers @@ -12,4 +12,4 @@ FROM alpine:latest RUN apk add --no-cache ca-certificates COPY --from=builder /go-ethereum/build/bin/* /usr/local/bin/ -EXPOSE 8545 8546 30303 30303/udp 30304/udp +EXPOSE 8545 8546 30303 30303/udp diff --git a/Makefile b/Makefile index 2cfd1110ec..5cb9231a18 100644 --- a/Makefile +++ b/Makefile @@ -37,6 +37,9 @@ ios: test: all build/env.sh go run build/ci.go test +lint: ## Run linters. + build/env.sh go run build/ci.go lint + clean: rm -fr build/_workspace/pkg/ $(GOBIN)/* @@ -45,9 +48,13 @@ clean: devtools: env GOBIN= go get -u golang.org/x/tools/cmd/stringer - env GOBIN= go get -u github.com/jteeuwen/go-bindata/go-bindata + env GOBIN= go get -u github.com/kevinburke/go-bindata/go-bindata env GOBIN= go get -u github.com/fjl/gencodec + env GOBIN= go get -u github.com/golang/protobuf/protoc-gen-go env GOBIN= go install ./cmd/abigen + @type "npm" 2> /dev/null || echo 'Please install node.js and npm' + @type "solc" 2> /dev/null || echo 'Please install solc' + @type "protoc" 2> /dev/null || echo 'Please install protoc' # Cross Compilation Targets (xgo) diff --git a/README.md b/README.md index 61e36afec4..b2e992a4ef 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,8 @@ Official golang implementation of the Ethereum protocol. [![API Reference]( https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667 )](https://godoc.org/github.com/ethereum/go-ethereum) +[![Go Report Card](https://goreportcard.com/badge/github.com/ethereum/go-ethereum)](https://goreportcard.com/report/github.com/ethereum/go-ethereum) +[![Travis](https://travis-ci.org/ethereum/go-ethereum.svg?branch=master)](https://travis-ci.org/ethereum/go-ethereum) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ethereum/go-ethereum?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) Automated builds are available for stable releases and the unstable master branch. @@ -56,16 +58,14 @@ the user doesn't care about years-old historical data, so we can fast-sync quick state of the network. To do so: ``` -$ geth --fast --cache=512 console +$ geth console ``` This command will: - * Start geth in fast sync mode (`--fast`), causing it to download more data in exchange for avoiding - processing the entire history of the Ethereum network, which is very CPU intensive. - * Bump the memory allowance of the database to 512MB (`--cache=512`), which can help significantly in - sync times especially for HDD users. This flag is optional and you can set it as high or as low as - you'd like, though we'd recommend the 512MB - 2GB range. + * Start geth in fast sync mode (default, can be changed with the `--syncmode` flag), causing it to + download more data in exchange for avoiding processing the entire history of the Ethereum network, + which is very CPU intensive. * Start up Geth's built-in interactive [JavaScript console](https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console), (via the trailing `console` subcommand) through which you can invoke all official [`web3` methods](https://github.com/ethereum/wiki/wiki/JavaScript-API) as well as Geth's own [management APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs). @@ -80,12 +80,11 @@ entire system. In other words, instead of attaching to the main network, you wan network with your node, which is fully equivalent to the main network, but with play-Ether only. ``` -$ geth --testnet --fast --cache=512 console +$ geth --testnet console ``` -The `--fast`, `--cache` flags and `console` subcommand have the exact same meaning as above and they -are equally useful on the testnet too. Please see above for their explanations if you've skipped to -here. +The `console` subcommand have the exact same meaning as above and they are equally useful on the +testnet too. Please see above for their explanations if you've skipped to here. Specifying the `--testnet` flag however will reconfigure your Geth instance a bit: @@ -102,6 +101,14 @@ over between the main network and test network, you should make sure to always u for play-money and real-money. Unless you manually move accounts, Geth will by default correctly separate the two networks and will not make any accounts available between them.* +### Full node on the Rinkeby test network + +The above test network is a cross client one based on the ethash proof-of-work consensus algorithm. As such, it has certain extra overhead and is more susceptible to reorganization attacks due to the network's low difficulty / security. Go Ethereum also supports connecting to a proof-of-authority based test network called [*Rinkeby*](https://www.rinkeby.io) (operated by members of the community). This network is lighter, more secure, but is only supported by go-ethereum. + +``` +$ geth --rinkeby console +``` + ### Configuration As an alternative to passing the numerous flags to the `geth` binary, you can also pass a configuration file via: @@ -125,17 +132,17 @@ One of the quickest ways to get Ethereum up and running on your machine is by us ``` docker run -d --name ethereum-node -v /Users/alice/ethereum:/root \ -p 8545:8545 -p 30303:30303 \ - ethereum/client-go --fast --cache=512 + ethereum/client-go ``` -This will start geth in fast sync mode with a DB memory allowance of 512MB just as the above command does. It will also create a persistent volume in your home directory for saving your blockchain as well as map the default ports. There is also an `alpine` tag available for a slim version of the image. +This will start geth in fast-sync mode with a DB memory allowance of 1GB just as the above command does. It will also create a persistent volume in your home directory for saving your blockchain as well as map the default ports. There is also an `alpine` tag available for a slim version of the image. Do not forget `--rpcaddr 0.0.0.0`, if you want to access RPC from other containers and/or hosts. By default, `geth` binds to the local interface and RPC endpoints is not accessible from the outside. ### Programatically interfacing Geth nodes As a developer, sooner rather than later you'll want to start interacting with Geth and the Ethereum -network via your own programs and not manually through the console. To aid this, Geth has built in +network via your own programs and not manually through the console. To aid this, Geth has built-in support for a JSON-RPC based APIs ([standard APIs](https://github.com/ethereum/wiki/wiki/JSON-RPC) and [Geth specific APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs)). These can be exposed via HTTP, WebSockets and IPC (unix sockets on unix based platforms, and named pipes on Windows). diff --git a/VERSION b/VERSION index 27f9cd322b..7d2424c90b 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.8.0 +1.8.12 diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 205dc300b0..254b1f7fb4 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -17,6 +17,7 @@ package abi import ( + "bytes" "encoding/json" "fmt" "io" @@ -50,57 +51,52 @@ func JSON(reader io.Reader) (ABI, error) { // methods string signature. (signature = baz(uint32,string32)) func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) { // Fetch the ABI of the requested method - var method Method - if name == "" { - method = abi.Constructor - } else { - m, exist := abi.Methods[name] - if !exist { - return nil, fmt.Errorf("method '%s' not found", name) + // constructor + arguments, err := abi.Constructor.Inputs.Pack(args...) + if err != nil { + return nil, err } - method = m + return arguments, nil + } - arguments, err := method.pack(args...) + method, exist := abi.Methods[name] + if !exist { + return nil, fmt.Errorf("method '%s' not found", name) + } + + arguments, err := method.Inputs.Pack(args...) if err != nil { return nil, err } // Pack up the method ID too if not a constructor and return - if name == "" { - return arguments, nil - } return append(method.Id(), arguments...), nil } // Unpack output in v according to the abi specification func (abi ABI) Unpack(v interface{}, name string, output []byte) (err error) { - if err = bytesAreProper(output); err != nil { - return err + if len(output) == 0 { + return fmt.Errorf("abi: unmarshalling empty output") } // since there can't be naming collisions with contracts and events, // we need to decide whether we're calling a method or an event - var unpack unpacker if method, ok := abi.Methods[name]; ok { - unpack = method + if len(output)%32 != 0 { + return fmt.Errorf("abi: improperly formatted output") + } + return method.Outputs.Unpack(v, output) } else if event, ok := abi.Events[name]; ok { - unpack = event - } else { - return fmt.Errorf("abi: could not locate named method or event.") + return event.Inputs.Unpack(v, output) } - - // requires a struct to unpack into for a tuple return... - if unpack.isTupleReturn() { - return unpack.tupleUnpack(v, output) - } - return unpack.singleUnpack(v, output) + return fmt.Errorf("abi: could not locate named method or event") } +// UnmarshalJSON implements json.Unmarshaler interface func (abi *ABI) UnmarshalJSON(data []byte) error { var fields []struct { Type string Name string Constant bool - Indexed bool Anonymous bool Inputs []Argument Outputs []Argument @@ -137,3 +133,14 @@ func (abi *ABI) UnmarshalJSON(data []byte) error { return nil } + +// MethodById looks up a method by the 4-byte id +// returns nil if none found +func (abi *ABI) MethodById(sigdata []byte) (*Method, error) { + for _, method := range abi.Methods { + if bytes.Equal(method.Id(), sigdata[:4]) { + return &method, nil + } + } + return nil, fmt.Errorf("no method with id: %#x", sigdata[:4]) +} diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index 79c4d4a163..8018df7756 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -18,13 +18,15 @@ package abi import ( "bytes" + "encoding/hex" "fmt" "log" "math/big" - "reflect" "strings" "testing" + "reflect" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" ) @@ -74,9 +76,24 @@ func TestReader(t *testing.T) { } // deep equal fails for some reason - t.Skip() - if !reflect.DeepEqual(abi, exp) { - t.Errorf("\nabi: %v\ndoes not match exp: %v", abi, exp) + for name, expM := range exp.Methods { + gotM, exist := abi.Methods[name] + if !exist { + t.Errorf("Missing expected method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } + } + + for name, gotM := range abi.Methods { + expM, exist := exp.Methods[name] + if !exist { + t.Errorf("Found extra method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } } } @@ -348,6 +365,188 @@ func TestInputVariableInputLength(t *testing.T) { } } +func TestInputFixedArrayAndVariableInputLength(t *testing.T) { + const definition = `[ + { "type" : "function", "name" : "fixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] }, + { "type" : "function", "name" : "fixedArrBytes", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] }, + { "type" : "function", "name" : "mixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type": "uint256[2]" }, { "name" : "dynArr", "type": "uint256[]" } ] }, + { "type" : "function", "name" : "doubleFixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "fixedArr2", "type": "uint256[3]" } ] }, + { "type" : "function", "name" : "multipleMixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] } + ]` + + abi, err := JSON(strings.NewReader(definition)) + if err != nil { + t.Error(err) + } + + // test string, fixed array uint256[2] + strin := "hello world" + arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedArrStrPack, err := abi.Pack("fixedArrStr", strin, arrin) + if err != nil { + t.Error(err) + } + + // generate expected output + offset := make([]byte, 32) + offset[31] = 96 + length := make([]byte, 32) + length[31] = byte(len(strin)) + strvalue := common.RightPadBytes([]byte(strin), 32) + arrinvalue1 := common.LeftPadBytes(arrin[0].Bytes(), 32) + arrinvalue2 := common.LeftPadBytes(arrin[1].Bytes(), 32) + exp := append(offset, arrinvalue1...) + exp = append(exp, arrinvalue2...) + exp = append(exp, append(length, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + fixedArrStrPack = fixedArrStrPack[4:] + if !bytes.Equal(fixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, fixedArrStrPack) + } + + // test byte array, fixed array uint256[2] + bytesin := []byte(strin) + arrin = [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedArrBytesPack, err := abi.Pack("fixedArrBytes", bytesin, arrin) + if err != nil { + t.Error(err) + } + + // generate expected output + offset = make([]byte, 32) + offset[31] = 96 + length = make([]byte, 32) + length[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + arrinvalue1 = common.LeftPadBytes(arrin[0].Bytes(), 32) + arrinvalue2 = common.LeftPadBytes(arrin[1].Bytes(), 32) + exp = append(offset, arrinvalue1...) + exp = append(exp, arrinvalue2...) + exp = append(exp, append(length, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + fixedArrBytesPack = fixedArrBytesPack[4:] + if !bytes.Equal(fixedArrBytesPack, exp) { + t.Errorf("expected %x, got %x\n", exp, fixedArrBytesPack) + } + + // test string, fixed array uint256[2], dynamic array uint256[] + strin = "hello world" + fixedarrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + dynarrin := []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + mixedArrStrPack, err := abi.Pack("mixedArrStr", strin, fixedarrin, dynarrin) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset := make([]byte, 32) + stroffset[31] = 128 + strlength := make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrinvalue1 := common.LeftPadBytes(fixedarrin[0].Bytes(), 32) + fixedarrinvalue2 := common.LeftPadBytes(fixedarrin[1].Bytes(), 32) + dynarroffset := make([]byte, 32) + dynarroffset[31] = byte(160 + ((len(strin)/32)+1)*32) + dynarrlength := make([]byte, 32) + dynarrlength[31] = byte(len(dynarrin)) + dynarrinvalue1 := common.LeftPadBytes(dynarrin[0].Bytes(), 32) + dynarrinvalue2 := common.LeftPadBytes(dynarrin[1].Bytes(), 32) + dynarrinvalue3 := common.LeftPadBytes(dynarrin[2].Bytes(), 32) + exp = append(stroffset, fixedarrinvalue1...) + exp = append(exp, fixedarrinvalue2...) + exp = append(exp, dynarroffset...) + exp = append(exp, append(strlength, strvalue...)...) + dynarrarg := append(dynarrlength, dynarrinvalue1...) + dynarrarg = append(dynarrarg, dynarrinvalue2...) + dynarrarg = append(dynarrarg, dynarrinvalue3...) + exp = append(exp, dynarrarg...) + + // ignore first 4 bytes of the output. This is the function identifier + mixedArrStrPack = mixedArrStrPack[4:] + if !bytes.Equal(mixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, mixedArrStrPack) + } + + // test string, fixed array uint256[2], fixed array uint256[3] + strin = "hello world" + fixedarrin1 := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedarrin2 := [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + doubleFixedArrStrPack, err := abi.Pack("doubleFixedArrStr", strin, fixedarrin1, fixedarrin2) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset = make([]byte, 32) + stroffset[31] = 192 + strlength = make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrin1value1 := common.LeftPadBytes(fixedarrin1[0].Bytes(), 32) + fixedarrin1value2 := common.LeftPadBytes(fixedarrin1[1].Bytes(), 32) + fixedarrin2value1 := common.LeftPadBytes(fixedarrin2[0].Bytes(), 32) + fixedarrin2value2 := common.LeftPadBytes(fixedarrin2[1].Bytes(), 32) + fixedarrin2value3 := common.LeftPadBytes(fixedarrin2[2].Bytes(), 32) + exp = append(stroffset, fixedarrin1value1...) + exp = append(exp, fixedarrin1value2...) + exp = append(exp, fixedarrin2value1...) + exp = append(exp, fixedarrin2value2...) + exp = append(exp, fixedarrin2value3...) + exp = append(exp, append(strlength, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + doubleFixedArrStrPack = doubleFixedArrStrPack[4:] + if !bytes.Equal(doubleFixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, doubleFixedArrStrPack) + } + + // test string, fixed array uint256[2], dynamic array uint256[], fixed array uint256[3] + strin = "hello world" + fixedarrin1 = [2]*big.Int{big.NewInt(1), big.NewInt(2)} + dynarrin = []*big.Int{big.NewInt(1), big.NewInt(2)} + fixedarrin2 = [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + multipleMixedArrStrPack, err := abi.Pack("multipleMixedArrStr", strin, fixedarrin1, dynarrin, fixedarrin2) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset = make([]byte, 32) + stroffset[31] = 224 + strlength = make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrin1value1 = common.LeftPadBytes(fixedarrin1[0].Bytes(), 32) + fixedarrin1value2 = common.LeftPadBytes(fixedarrin1[1].Bytes(), 32) + dynarroffset = U256(big.NewInt(int64(256 + ((len(strin)/32)+1)*32))) + dynarrlength = make([]byte, 32) + dynarrlength[31] = byte(len(dynarrin)) + dynarrinvalue1 = common.LeftPadBytes(dynarrin[0].Bytes(), 32) + dynarrinvalue2 = common.LeftPadBytes(dynarrin[1].Bytes(), 32) + fixedarrin2value1 = common.LeftPadBytes(fixedarrin2[0].Bytes(), 32) + fixedarrin2value2 = common.LeftPadBytes(fixedarrin2[1].Bytes(), 32) + fixedarrin2value3 = common.LeftPadBytes(fixedarrin2[2].Bytes(), 32) + exp = append(stroffset, fixedarrin1value1...) + exp = append(exp, fixedarrin1value2...) + exp = append(exp, dynarroffset...) + exp = append(exp, fixedarrin2value1...) + exp = append(exp, fixedarrin2value2...) + exp = append(exp, fixedarrin2value3...) + exp = append(exp, append(strlength, strvalue...)...) + dynarrarg = append(dynarrlength, dynarrinvalue1...) + dynarrarg = append(dynarrarg, dynarrinvalue2...) + exp = append(exp, dynarrarg...) + + // ignore first 4 bytes of the output. This is the function identifier + multipleMixedArrStrPack = multipleMixedArrStrPack[4:] + if !bytes.Equal(multipleMixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, multipleMixedArrStrPack) + } +} + func TestDefaultFunctionParsing(t *testing.T) { const definition = `[{ "name" : "balance" }]` @@ -418,3 +617,99 @@ func TestBareEvents(t *testing.T) { } } } + +// TestUnpackEvent is based on this contract: +// contract T { +// event received(address sender, uint amount, bytes memo); +// event receivedAddr(address sender); +// function receive(bytes memo) external payable { +// received(msg.sender, msg.value, memo); +// receivedAddr(msg.sender); +// } +// } +// When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt: +// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} +func TestUnpackEvent(t *testing.T) { + const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]` + abi, err := JSON(strings.NewReader(abiJSON)) + if err != nil { + t.Fatal(err) + } + + const hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158` + data, err := hex.DecodeString(hexdata) + if err != nil { + t.Fatal(err) + } + if len(data)%32 == 0 { + t.Errorf("len(data) is %d, want a non-multiple of 32", len(data)) + } + + type ReceivedEvent struct { + Address common.Address + Amount *big.Int + Memo []byte + } + var ev ReceivedEvent + + err = abi.Unpack(&ev, "received", data) + if err != nil { + t.Error(err) + } else { + t.Logf("len(data): %d; received event: %+v", len(data), ev) + } + + type ReceivedAddrEvent struct { + Address common.Address + } + var receivedAddrEv ReceivedAddrEvent + err = abi.Unpack(&receivedAddrEv, "receivedAddr", data) + if err != nil { + t.Error(err) + } else { + t.Logf("len(data): %d; received event: %+v", len(data), receivedAddrEv) + } +} + +func TestABI_MethodById(t *testing.T) { + const abiJSON = `[ + {"type":"function","name":"receive","constant":false,"inputs":[{"name":"memo","type":"bytes"}],"outputs":[],"payable":true,"stateMutability":"payable"}, + {"type":"event","name":"received","anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}]}, + {"type":"function","name":"fixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"fixedArrBytes","constant":true,"inputs":[{"name":"str","type":"bytes"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"mixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"}]}, + {"type":"function","name":"doubleFixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"multipleMixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"balance","constant":true}, + {"type":"function","name":"send","constant":false,"inputs":[{"name":"amount","type":"uint256"}]}, + {"type":"function","name":"test","constant":false,"inputs":[{"name":"number","type":"uint32"}]}, + {"type":"function","name":"string","constant":false,"inputs":[{"name":"inputs","type":"string"}]}, + {"type":"function","name":"bool","constant":false,"inputs":[{"name":"inputs","type":"bool"}]}, + {"type":"function","name":"address","constant":false,"inputs":[{"name":"inputs","type":"address"}]}, + {"type":"function","name":"uint64[2]","constant":false,"inputs":[{"name":"inputs","type":"uint64[2]"}]}, + {"type":"function","name":"uint64[]","constant":false,"inputs":[{"name":"inputs","type":"uint64[]"}]}, + {"type":"function","name":"foo","constant":false,"inputs":[{"name":"inputs","type":"uint32"}]}, + {"type":"function","name":"bar","constant":false,"inputs":[{"name":"inputs","type":"uint32"},{"name":"string","type":"uint16"}]}, + {"type":"function","name":"_slice","constant":false,"inputs":[{"name":"inputs","type":"uint32[2]"}]}, + {"type":"function","name":"__slice256","constant":false,"inputs":[{"name":"inputs","type":"uint256[2]"}]}, + {"type":"function","name":"sliceAddress","constant":false,"inputs":[{"name":"inputs","type":"address[]"}]}, + {"type":"function","name":"sliceMultiAddress","constant":false,"inputs":[{"name":"a","type":"address[]"},{"name":"b","type":"address[]"}]} + ] +` + abi, err := JSON(strings.NewReader(abiJSON)) + if err != nil { + t.Fatal(err) + } + for name, m := range abi.Methods { + a := fmt.Sprintf("%v", m) + m2, err := abi.MethodById(m.Id()) + if err != nil { + t.Fatalf("Failed to look up ABI method: %v", err) + } + b := fmt.Sprintf("%v", m2) + if a != b { + t.Errorf("Method %v (id %v) not 'findable' by id in ABI", name, common.ToHex(m.Id())) + } + } + +} diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go index 4691318ce7..93b513c346 100644 --- a/accounts/abi/argument.go +++ b/accounts/abi/argument.go @@ -19,6 +19,8 @@ package abi import ( "encoding/json" "fmt" + "reflect" + "strings" ) // Argument holds the name of the argument and the corresponding type. @@ -29,7 +31,10 @@ type Argument struct { Indexed bool // indexed is only used by events } -func (a *Argument) UnmarshalJSON(data []byte) error { +type Arguments []Argument + +// UnmarshalJSON implements json.Unmarshaler interface +func (argument *Argument) UnmarshalJSON(data []byte) error { var extarg struct { Name string Type string @@ -40,12 +45,246 @@ func (a *Argument) UnmarshalJSON(data []byte) error { return fmt.Errorf("argument json err: %v", err) } - a.Type, err = NewType(extarg.Type) + argument.Type, err = NewType(extarg.Type) if err != nil { return err } - a.Name = extarg.Name - a.Indexed = extarg.Indexed + argument.Name = extarg.Name + argument.Indexed = extarg.Indexed return nil } + +// LengthNonIndexed returns the number of arguments when not counting 'indexed' ones. Only events +// can ever have 'indexed' arguments, it should always be false on arguments for method input/output +func (arguments Arguments) LengthNonIndexed() int { + out := 0 + for _, arg := range arguments { + if !arg.Indexed { + out++ + } + } + return out +} + +// NonIndexed returns the arguments with indexed arguments filtered out +func (arguments Arguments) NonIndexed() Arguments { + var ret []Argument + for _, arg := range arguments { + if !arg.Indexed { + ret = append(ret, arg) + } + } + return ret +} + +// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[] +func (arguments Arguments) isTuple() bool { + return len(arguments) > 1 +} + +// Unpack performs the operation hexdata -> Go format +func (arguments Arguments) Unpack(v interface{}, data []byte) error { + + // make sure the passed value is arguments pointer + if reflect.Ptr != reflect.ValueOf(v).Kind() { + return fmt.Errorf("abi: Unpack(non-pointer %T)", v) + } + marshalledValues, err := arguments.UnpackValues(data) + if err != nil { + return err + } + if arguments.isTuple() { + return arguments.unpackTuple(v, marshalledValues) + } + return arguments.unpackAtomic(v, marshalledValues) +} + +func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interface{}) error { + + var ( + value = reflect.ValueOf(v).Elem() + typ = value.Type() + kind = value.Kind() + ) + + if err := requireUnpackKind(value, typ, kind, arguments); err != nil { + return err + } + + // If the interface is a struct, get of abi->struct_field mapping + + var abi2struct map[string]string + if kind == reflect.Struct { + var err error + abi2struct, err = mapAbiToStructFields(arguments, value) + if err != nil { + return err + } + } + for i, arg := range arguments.NonIndexed() { + + reflectValue := reflect.ValueOf(marshalledValues[i]) + + switch kind { + case reflect.Struct: + if structField, ok := abi2struct[arg.Name]; ok { + if err := set(value.FieldByName(structField), reflectValue, arg); err != nil { + return err + } + } + case reflect.Slice, reflect.Array: + if value.Len() < i { + return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len()) + } + v := value.Index(i) + if err := requireAssignable(v, reflectValue); err != nil { + return err + } + + if err := set(v.Elem(), reflectValue, arg); err != nil { + return err + } + default: + return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", typ) + } + } + return nil +} + +// unpackAtomic unpacks ( hexdata -> go ) a single value +func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues []interface{}) error { + if len(marshalledValues) != 1 { + return fmt.Errorf("abi: wrong length, expected single value, got %d", len(marshalledValues)) + } + + elem := reflect.ValueOf(v).Elem() + kind := elem.Kind() + reflectValue := reflect.ValueOf(marshalledValues[0]) + + var abi2struct map[string]string + if kind == reflect.Struct { + var err error + if abi2struct, err = mapAbiToStructFields(arguments, elem); err != nil { + return err + } + arg := arguments.NonIndexed()[0] + if structField, ok := abi2struct[arg.Name]; ok { + return set(elem.FieldByName(structField), reflectValue, arg) + } + return nil + } + + return set(elem, reflectValue, arguments.NonIndexed()[0]) + +} + +// Computes the full size of an array; +// i.e. counting nested arrays, which count towards size for unpacking. +func getArraySize(arr *Type) int { + size := arr.Size + // Arrays can be nested, with each element being the same size + arr = arr.Elem + for arr.T == ArrayTy { + // Keep multiplying by elem.Size while the elem is an array. + size *= arr.Size + arr = arr.Elem + } + // Now we have the full array size, including its children. + return size +} + +// UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification, +// without supplying a struct to unpack into. Instead, this method returns a list containing the +// values. An atomic argument will be a list with one element. +func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) { + retval := make([]interface{}, 0, arguments.LengthNonIndexed()) + virtualArgs := 0 + for index, arg := range arguments.NonIndexed() { + marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data) + if arg.Type.T == ArrayTy { + // If we have a static array, like [3]uint256, these are coded as + // just like uint256,uint256,uint256. + // This means that we need to add two 'virtual' arguments when + // we count the index from now on. + // + // Array values nested multiple levels deep are also encoded inline: + // [2][3]uint256: uint256,uint256,uint256,uint256,uint256,uint256 + // + // Calculate the full array size to get the correct offset for the next argument. + // Decrement it by 1, as the normal index increment is still applied. + virtualArgs += getArraySize(&arg.Type) - 1 + } + if err != nil { + return nil, err + } + retval = append(retval, marshalledValue) + } + return retval, nil +} + +// PackValues performs the operation Go format -> Hexdata +// It is the semantic opposite of UnpackValues +func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) { + return arguments.Pack(args...) +} + +// Pack performs the operation Go format -> Hexdata +func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) { + // Make sure arguments match up and pack them + abiArgs := arguments + if len(args) != len(abiArgs) { + return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs)) + } + // variable input is the output appended at the end of packed + // output. This is used for strings and bytes types input. + var variableInput []byte + + // input offset is the bytes offset for packed output + inputOffset := 0 + for _, abiArg := range abiArgs { + if abiArg.Type.T == ArrayTy { + inputOffset += 32 * abiArg.Type.Size + } else { + inputOffset += 32 + } + } + var ret []byte + for i, a := range args { + input := abiArgs[i] + // pack the input + packed, err := input.Type.pack(reflect.ValueOf(a)) + if err != nil { + return nil, err + } + // check for a slice type (string, bytes, slice) + if input.Type.requiresLengthPrefix() { + // calculate the offset + offset := inputOffset + len(variableInput) + // set the offset + ret = append(ret, packNum(reflect.ValueOf(offset))...) + // Append the packed output to the variable input. The variable input + // will be appended at the end of the input. + variableInput = append(variableInput, packed...) + } else { + // append the packed value to the input + ret = append(ret, packed...) + } + } + // append the variable input at the end of the packed input + ret = append(ret, variableInput...) + + return ret, nil +} + +// capitalise makes the first character of a string upper case, also removing any +// prefixing underscores from the variable names. +func capitalise(input string) string { + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } + return strings.ToUpper(input[:1]) + input[1:] +} diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go index 25b61928e1..ca60cc1b43 100644 --- a/accounts/abi/bind/backend.go +++ b/accounts/abi/bind/backend.go @@ -52,12 +52,6 @@ type ContractCaller interface { CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) } -// DeployBackend wraps the operations needed by WaitMined and WaitDeployed. -type DeployBackend interface { - TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) - CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) -} - // PendingContractCaller defines methods to perform contract calls on the pending state. // Call will try to discover this interface when access to the pending state is requested. // If the backend does not support the pending state, Call returns ErrNoPendingState. @@ -85,13 +79,34 @@ type ContractTransactor interface { // There is no guarantee that this is the true gas limit requirement as other // transactions may be added or removed by miners, but it should provide a basis // for setting a reasonable default. - EstimateGas(ctx context.Context, call ethereum.CallMsg) (usedGas *big.Int, err error) + EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) // SendTransaction injects the transaction into the pending pool for execution. SendTransaction(ctx context.Context, tx *types.Transaction) error } +// ContractFilterer defines the methods needed to access log events using one-off +// queries or continuous event subscriptions. +type ContractFilterer interface { + // FilterLogs executes a log filter operation, blocking during execution and + // returning all the results in one batch. + // + // TODO(karalabe): Deprecate when the subscription one can return past data too. + FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) + + // SubscribeFilterLogs creates a background log filtering operation, returning + // a subscription immediately, which can be used to stream the found events. + SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) +} + +// DeployBackend wraps the operations needed by WaitMined and WaitDeployed. +type DeployBackend interface { + TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) + CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error) +} + // ContractBackend defines the methods needed to work with contracts on a read-write basis. type ContractBackend interface { ContractCaller ContractTransactor + ContractFilterer } diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 09288d401e..fd69538d53 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -30,11 +30,16 @@ import ( "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/bloombits" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/eth/filters" "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" ) // This nil assignment ensures compile time that SimulatedBackend implements bind.ContractBackend. @@ -53,17 +58,25 @@ type SimulatedBackend struct { pendingBlock *types.Block // Currently pending block that will be imported on request pendingState *state.StateDB // Currently pending state that will be the active on on request + events *filters.EventSystem // Event system for filtering log events live + config *params.ChainConfig } // NewSimulatedBackend creates a new binding backend using a simulated blockchain // for testing purposes. func NewSimulatedBackend(alloc core.GenesisAlloc) *SimulatedBackend { - database, _ := ethdb.NewMemDatabase() + database := ethdb.NewMemDatabase() genesis := core.Genesis{Config: params.AllEthashProtocolChanges, Alloc: alloc} genesis.MustCommit(database) - blockchain, _ := core.NewBlockChain(database, genesis.Config, ethash.NewFaker(), vm.Config{}) - backend := &SimulatedBackend{database: database, blockchain: blockchain, config: genesis.Config} + blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}) + + backend := &SimulatedBackend{ + database: database, + blockchain: blockchain, + config: genesis.Config, + events: filters.NewEventSystem(new(event.TypeMux), &filterBackend{database, blockchain}, false), + } backend.rollback() return backend } @@ -89,9 +102,11 @@ func (b *SimulatedBackend) Rollback() { } func (b *SimulatedBackend) rollback() { - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {}) + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {}) + statedb, _ := b.blockchain.State() + b.pendingBlock = blocks[0] - b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) + b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database()) } // CodeAt returns the code associated with a certain account in the blockchain. @@ -145,7 +160,7 @@ func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Addres // TransactionReceipt returns the receipt of a transaction. func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) { - receipt, _, _, _ := core.GetReceipt(b.database, txHash) + receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash) return receipt, nil } @@ -200,7 +215,7 @@ func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error // EstimateGas executes the requested code against the currently pending block/state and // returns the used amount of gas. -func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (*big.Int, error) { +func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) { b.mu.Lock() defer b.mu.Unlock() @@ -210,16 +225,16 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs hi uint64 cap uint64 ) - if call.Gas != nil && call.Gas.Uint64() >= params.TxGas { - hi = call.Gas.Uint64() + if call.Gas >= params.TxGas { + hi = call.Gas } else { - hi = b.pendingBlock.GasLimit().Uint64() + hi = b.pendingBlock.GasLimit() } cap = hi // Create a helper to check if a gas allowance results in an executable transaction executable := func(gas uint64) bool { - call.Gas = new(big.Int).SetUint64(gas) + call.Gas = gas snapshot := b.pendingState.Snapshot() _, _, failed, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState) @@ -242,21 +257,21 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs // Reject the transaction as invalid if it still fails at the highest allowance if hi == cap { if !executable(hi) { - return nil, errGasEstimationFailed + return 0, errGasEstimationFailed } } - return new(big.Int).SetUint64(hi), nil + return hi, nil } -// callContract implemens common code between normal and pending contract calls. +// callContract implements common code between normal and pending contract calls. // state is modified during execution, make sure to copy it if necessary. -func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, statedb *state.StateDB) ([]byte, *big.Int, bool, error) { +func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, statedb *state.StateDB) ([]byte, uint64, bool, error) { // Ensure message is initialized properly. if call.GasPrice == nil { call.GasPrice = big.NewInt(1) } - if call.Gas == nil || call.Gas.Sign() == 0 { - call.Gas = big.NewInt(50000000) + if call.Gas == 0 { + call.Gas = 50000000 } if call.Value == nil { call.Value = new(big.Int) @@ -271,9 +286,9 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM // Create a new environment which holds all relevant information // about the transaction and calling mechanisms. vmenv := vm.NewEVM(evmContext, statedb, b.config, vm.Config{}) - gaspool := new(core.GasPool).AddGas(math.MaxBig256) - ret, gasUsed, _, failed, err := core.NewStateTransition(vmenv, msg, gaspool).TransitionDb() - return ret, gasUsed, failed, err + gaspool := new(core.GasPool).AddGas(math.MaxUint64) + + return core.NewStateTransition(vmenv, msg, gaspool).TransitionDb() } // SendTransaction updates the pending block to include the given transaction. @@ -291,29 +306,95 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa panic(fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)) } - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { - block.AddTx(tx) + block.AddTxWithChain(b.blockchain, tx) } - block.AddTx(tx) + block.AddTxWithChain(b.blockchain, tx) }) + statedb, _ := b.blockchain.State() + b.pendingBlock = blocks[0] - b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) + b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database()) return nil } -// JumpTimeInSeconds adds skip seconds to the clock +// FilterLogs executes a log filter operation, blocking during execution and +// returning all the results in one batch. +// +// TODO(karalabe): Deprecate when the subscription one can return past data too. +func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error) { + // Initialize unset filter boundaried to run from genesis to chain head + from := int64(0) + if query.FromBlock != nil { + from = query.FromBlock.Int64() + } + to := int64(-1) + if query.ToBlock != nil { + to = query.ToBlock.Int64() + } + // Construct and execute the filter + filter := filters.New(&filterBackend{b.database, b.blockchain}, from, to, query.Addresses, query.Topics) + + logs, err := filter.Logs(ctx) + if err != nil { + return nil, err + } + res := make([]types.Log, len(logs)) + for i, log := range logs { + res[i] = *log + } + return res, nil +} + +// SubscribeFilterLogs creates a background log filtering operation, returning a +// subscription immediately, which can be used to stream the found events. +func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) { + // Subscribe to contract events + sink := make(chan []*types.Log) + + sub, err := b.events.SubscribeLogs(query, sink) + if err != nil { + return nil, err + } + // Since we're getting logs in batches, we need to flatten them into a plain stream + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case logs := <-sink: + for _, log := range logs { + select { + case ch <- *log: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// AdjustTime adds a time shift to the simulated clock. func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error { b.mu.Lock() defer b.mu.Unlock() - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { block.AddTx(tx) } block.OffsetTime(int64(adjustment.Seconds())) }) + statedb, _ := b.blockchain.State() + b.pendingBlock = blocks[0] - b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) + b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database()) return nil } @@ -328,6 +409,68 @@ func (m callmsg) Nonce() uint64 { return 0 } func (m callmsg) CheckNonce() bool { return false } func (m callmsg) To() *common.Address { return m.CallMsg.To } func (m callmsg) GasPrice() *big.Int { return m.CallMsg.GasPrice } -func (m callmsg) Gas() *big.Int { return m.CallMsg.Gas } +func (m callmsg) Gas() uint64 { return m.CallMsg.Gas } func (m callmsg) Value() *big.Int { return m.CallMsg.Value } func (m callmsg) Data() []byte { return m.CallMsg.Data } + +// filterBackend implements filters.Backend to support filtering for logs without +// taking bloom-bits acceleration structures into account. +type filterBackend struct { + db ethdb.Database + bc *core.BlockChain +} + +func (fb *filterBackend) ChainDb() ethdb.Database { return fb.db } +func (fb *filterBackend) EventMux() *event.TypeMux { panic("not supported") } + +func (fb *filterBackend) HeaderByNumber(ctx context.Context, block rpc.BlockNumber) (*types.Header, error) { + if block == rpc.LatestBlockNumber { + return fb.bc.CurrentHeader(), nil + } + return fb.bc.GetHeaderByNumber(uint64(block.Int64())), nil +} + +func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error) { + number := rawdb.ReadHeaderNumber(fb.db, hash) + if number == nil { + return nil, nil + } + return rawdb.ReadReceipts(fb.db, hash, *number), nil +} + +func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) { + number := rawdb.ReadHeaderNumber(fb.db, hash) + if number == nil { + return nil, nil + } + receipts := rawdb.ReadReceipts(fb.db, hash, *number) + if receipts == nil { + return nil, nil + } + logs := make([][]*types.Log, len(receipts)) + for i, receipt := range receipts { + logs[i] = receipt.Logs + } + return logs, nil +} + +func (fb *filterBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription { + return event.NewSubscription(func(quit <-chan struct{}) error { + <-quit + return nil + }) +} +func (fb *filterBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription { + return fb.bc.SubscribeChainEvent(ch) +} +func (fb *filterBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription { + return fb.bc.SubscribeRemovedLogsEvent(ch) +} +func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription { + return fb.bc.SubscribeLogsEvent(ch) +} + +func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 } +func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) { + panic("not supported") +} diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index b40bd65e80..83ad1c8ae7 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -27,6 +27,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/event" ) // SignerFn is a signer function callback when a contract requires a method to @@ -50,11 +51,27 @@ type TransactOpts struct { Value *big.Int // Funds to transfer along along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) - GasLimit *big.Int // Gas limit to set for the transaction execution (nil = estimate + 10%) + GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) } +// FilterOpts is the collection of options to fine tune filtering for events +// within a bound contract. +type FilterOpts struct { + Start uint64 // Start of the queried range + End *uint64 // End of the range (nil = latest) + + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + +// WatchOpts is the collection of options to fine tune subscribing for events +// within a bound contract. +type WatchOpts struct { + Start *uint64 // Start of the queried range (nil = latest) + Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) +} + // BoundContract is the base wrapper object that reflects a contract on the // Ethereum network. It contains a collection of methods that are used by the // higher level contract bindings to operate. @@ -63,16 +80,18 @@ type BoundContract struct { abi abi.ABI // Reflect based ABI to access the correct Ethereum methods caller ContractCaller // Read interface to interact with the blockchain transactor ContractTransactor // Write interface to interact with the blockchain + filterer ContractFilterer // Event filtering to interact with the blockchain } // NewBoundContract creates a low level contract interface through which calls // and transactions may be made through. -func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor) *BoundContract { +func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor, filterer ContractFilterer) *BoundContract { return &BoundContract{ address: address, abi: abi, caller: caller, transactor: transactor, + filterer: filterer, } } @@ -80,7 +99,7 @@ func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller // deployment address with a Go wrapper. func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) { // Otherwise try to deploy the contract - c := NewBoundContract(common.Address{}, abi, backend, backend) + c := NewBoundContract(common.Address{}, abi, backend, backend, backend) input, err := c.abi.Pack("", params...) if err != nil { @@ -189,7 +208,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i } } gasLimit := opts.GasLimit - if gasLimit == nil { + if gasLimit == 0 { // Gas estimation cannot succeed without code for method invocations if contract != nil { if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil { @@ -225,6 +244,104 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i return signedTx, nil } +// FilterLogs filters contract logs for past blocks, returning the necessary +// channels to construct a strongly typed bound iterator on top of them. +func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(FilterOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].Id()}}, query...) + + topics, err := makeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + FromBlock: new(big.Int).SetUint64(opts.Start), + } + if opts.End != nil { + config.ToBlock = new(big.Int).SetUint64(*opts.End) + } + /* TODO(karalabe): Replace the rest of the method below with this when supported + sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + */ + buff, err := c.filterer.FilterLogs(ensureContext(opts.Context), config) + if err != nil { + return nil, nil, err + } + sub, err := event.NewSubscription(func(quit <-chan struct{}) error { + for _, log := range buff { + select { + case logs <- log: + case <-quit: + return nil + } + } + return nil + }), nil + + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// WatchLogs filters subscribes to contract logs for future blocks, returning a +// subscription object that can be used to tear down the watcher. +func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) { + // Don't crash on a lazy user + if opts == nil { + opts = new(WatchOpts) + } + // Append the event selector to the query parameters and construct the topic set + query = append([][]interface{}{{c.abi.Events[name].Id()}}, query...) + + topics, err := makeTopics(query...) + if err != nil { + return nil, nil, err + } + // Start the background filtering + logs := make(chan types.Log, 128) + + config := ethereum.FilterQuery{ + Addresses: []common.Address{c.address}, + Topics: topics, + } + if opts.Start != nil { + config.FromBlock = new(big.Int).SetUint64(*opts.Start) + } + sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs) + if err != nil { + return nil, nil, err + } + return logs, sub, nil +} + +// UnpackLog unpacks a retrieved log into the provided output structure. +func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error { + if len(log.Data) > 0 { + if err := c.abi.Unpack(out, event, log.Data); err != nil { + return err + } + } + var indexed abi.Arguments + for _, arg := range c.abi.Events[event].Inputs { + if arg.Indexed { + indexed = append(indexed, arg) + } + } + return parseTopics(out, indexed, log.Topics[1:]) +} + +// ensureContext is a helper method to ensure a context is not nil, even if the +// user specified it as such. func ensureContext(ctx context.Context) context.Context { if ctx == nil { return context.TODO() diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 4dce79b779..411177057b 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -63,10 +63,11 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La return r }, abis[i]) - // Extract the call and transact methods, and sort them alphabetically + // Extract the call and transact methods; events; and sort them alphabetically var ( calls = make(map[string]*tmplMethod) transacts = make(map[string]*tmplMethod) + events = make(map[string]*tmplEvent) ) for _, original := range evmABI.Methods { // Normalize the method for capital cases and non-anonymous inputs/outputs @@ -89,11 +90,33 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La } // Append the methods to the call or transact lists if original.Const { - calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original)} + calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} } else { - transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original)} + transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} } } + for _, original := range evmABI.Events { + // Skip anonymous events as they don't support explicit filtering + if original.Anonymous { + continue + } + // Normalize the event for capital cases and non-anonymous outputs + normalized := original + normalized.Name = methodNormalizer[lang](original.Name) + + normalized.Inputs = make([]abi.Argument, len(original.Inputs)) + copy(normalized.Inputs, original.Inputs) + for j, input := range normalized.Inputs { + // Indexed fields are input, non-indexed ones are outputs + if input.Indexed { + if input.Name == "" { + normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j) + } + } + } + // Append the event to the accumulator list + events[original.Name] = &tmplEvent{Original: original, Normalized: normalized} + } contracts[types[i]] = &tmplContract{ Type: capitalise(types[i]), InputABI: strings.Replace(strippedABI, "\"", "\\\"", -1), @@ -101,6 +124,7 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La Constructor: evmABI.Constructor, Calls: calls, Transacts: transacts, + Events: events, } } // Generate the contract template data content and render it @@ -111,10 +135,11 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La buffer := new(bytes.Buffer) funcs := map[string]interface{}{ - "bindtype": bindType[lang], - "namedtype": namedType[lang], - "capitalise": capitalise, - "decapitalise": decapitalise, + "bindtype": bindType[lang], + "bindtopictype": bindTopicType[lang], + "namedtype": namedType[lang], + "capitalise": capitalise, + "decapitalise": decapitalise, } tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang])) if err := tmpl.Execute(buffer, data); err != nil { @@ -133,127 +158,183 @@ func Bind(types []string, abis []string, bytecodes []string, pkg string, lang La } // bindType is a set of type binders that convert Solidity types to some supported -// programming language. +// programming language types. var bindType = map[Lang]func(kind abi.Type) string{ LangGo: bindTypeGo, LangJava: bindTypeJava, } +// Helper function for the binding generators. +// It reads the unmatched characters after the inner type-match, +// (since the inner type is a prefix of the total type declaration), +// looks for valid arrays (possibly a dynamic one) wrapping the inner type, +// and returns the sizes of these arrays. +// +// Returned array sizes are in the same order as solidity signatures; inner array size first. +// Array sizes may also be "", indicating a dynamic array. +func wrapArray(stringKind string, innerLen int, innerMapping string) (string, []string) { + remainder := stringKind[innerLen:] + //find all the sizes + matches := regexp.MustCompile(`\[(\d*)\]`).FindAllStringSubmatch(remainder, -1) + parts := make([]string, 0, len(matches)) + for _, match := range matches { + //get group 1 from the regex match + parts = append(parts, match[1]) + } + return innerMapping, parts +} + +// Translates the array sizes to a Go-lang declaration of a (nested) array of the inner type. +// Simply returns the inner type if arraySizes is empty. +func arrayBindingGo(inner string, arraySizes []string) string { + out := "" + //prepend all array sizes, from outer (end arraySizes) to inner (start arraySizes) + for i := len(arraySizes) - 1; i >= 0; i-- { + out += "[" + arraySizes[i] + "]" + } + out += inner + return out +} + // bindTypeGo converts a Solidity type to a Go one. Since there is no clear mapping // from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly // mapped will use an upscaled type (e.g. *big.Int). func bindTypeGo(kind abi.Type) string { stringKind := kind.String() + innerLen, innerMapping := bindUnnestedTypeGo(stringKind) + return arrayBindingGo(wrapArray(stringKind, innerLen, innerMapping)) +} + +// The inner function of bindTypeGo, this finds the inner type of stringKind. +// (Or just the type itself if it is not an array or slice) +// The length of the matched part is returned, with the the translated type. +func bindUnnestedTypeGo(stringKind string) (int, string) { switch { case strings.HasPrefix(stringKind, "address"): - parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 2 { - return stringKind - } - return fmt.Sprintf("%scommon.Address", parts[1]) + return len("address"), "common.Address" case strings.HasPrefix(stringKind, "bytes"): - parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 3 { - return stringKind - } - return fmt.Sprintf("%s[%s]byte", parts[2], parts[1]) + parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind) + return len(parts[0]), fmt.Sprintf("[%s]byte", parts[1]) case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"): - parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 4 { - return stringKind - } + parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(stringKind) switch parts[2] { case "8", "16", "32", "64": - return fmt.Sprintf("%s%sint%s", parts[3], parts[1], parts[2]) + return len(parts[0]), fmt.Sprintf("%sint%s", parts[1], parts[2]) } - return fmt.Sprintf("%s*big.Int", parts[3]) + return len(parts[0]), "*big.Int" - case strings.HasPrefix(stringKind, "bool") || strings.HasPrefix(stringKind, "string"): - parts := regexp.MustCompile(`([a-z]+)(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 3 { - return stringKind - } - return fmt.Sprintf("%s%s", parts[2], parts[1]) + case strings.HasPrefix(stringKind, "bool"): + return len("bool"), "bool" + + case strings.HasPrefix(stringKind, "string"): + return len("string"), "string" default: - return stringKind + return len(stringKind), stringKind } } +// Translates the array sizes to a Java declaration of a (nested) array of the inner type. +// Simply returns the inner type if arraySizes is empty. +func arrayBindingJava(inner string, arraySizes []string) string { + // Java array type declarations do not include the length. + return inner + strings.Repeat("[]", len(arraySizes)) +} + // bindTypeJava converts a Solidity type to a Java one. Since there is no clear mapping // from all Solidity types to Java ones (e.g. uint17), those that cannot be exactly // mapped will use an upscaled type (e.g. BigDecimal). func bindTypeJava(kind abi.Type) string { stringKind := kind.String() + innerLen, innerMapping := bindUnnestedTypeJava(stringKind) + return arrayBindingJava(wrapArray(stringKind, innerLen, innerMapping)) +} + +// The inner function of bindTypeJava, this finds the inner type of stringKind. +// (Or just the type itself if it is not an array or slice) +// The length of the matched part is returned, with the the translated type. +func bindUnnestedTypeJava(stringKind string) (int, string) { switch { case strings.HasPrefix(stringKind, "address"): parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind) if len(parts) != 2 { - return stringKind + return len(stringKind), stringKind } if parts[1] == "" { - return fmt.Sprintf("Address") + return len("address"), "Address" } - return fmt.Sprintf("Addresses") + return len(parts[0]), "Addresses" case strings.HasPrefix(stringKind, "bytes"): - parts := regexp.MustCompile(`bytes([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 3 { - return stringKind + parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind) + if len(parts) != 2 { + return len(stringKind), stringKind } - if parts[2] != "" { - return "byte[][]" - } - return "byte[]" + return len(parts[0]), "byte[]" case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"): - parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 4 { - return stringKind + //Note that uint and int (without digits) are also matched, + // these are size 256, and will translate to BigInt (the default). + parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(stringKind) + if len(parts) != 3 { + return len(stringKind), stringKind } - switch parts[2] { - case "8", "16", "32", "64": - if parts[1] == "" { - if parts[3] == "" { - return fmt.Sprintf("int%s", parts[2]) - } - return fmt.Sprintf("int%s[]", parts[2]) - } + + namedSize := map[string]string{ + "8": "byte", + "16": "short", + "32": "int", + "64": "long", + }[parts[2]] + + //default to BigInt + if namedSize == "" { + namedSize = "BigInt" } - if parts[3] == "" { - return fmt.Sprintf("BigInt") - } - return fmt.Sprintf("BigInts") + return len(parts[0]), namedSize case strings.HasPrefix(stringKind, "bool"): - parts := regexp.MustCompile(`bool(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 2 { - return stringKind - } - if parts[1] == "" { - return fmt.Sprintf("bool") - } - return fmt.Sprintf("bool[]") + return len("bool"), "boolean" case strings.HasPrefix(stringKind, "string"): - parts := regexp.MustCompile(`string(\[[0-9]*\])?`).FindStringSubmatch(stringKind) - if len(parts) != 2 { - return stringKind - } - if parts[1] == "" { - return fmt.Sprintf("String") - } - return fmt.Sprintf("String[]") + return len("string"), "String" default: - return stringKind + return len(stringKind), stringKind } } +// bindTopicType is a set of type binders that convert Solidity types to some +// supported programming language topic types. +var bindTopicType = map[Lang]func(kind abi.Type) string{ + LangGo: bindTopicTypeGo, + LangJava: bindTopicTypeJava, +} + +// bindTypeGo converts a Solidity topic type to a Go one. It is almost the same +// funcionality as for simple types, but dynamic types get converted to hashes. +func bindTopicTypeGo(kind abi.Type) string { + bound := bindTypeGo(kind) + if bound == "string" || bound == "[]byte" { + bound = "common.Hash" + } + return bound +} + +// bindTypeGo converts a Solidity topic type to a Java one. It is almost the same +// funcionality as for simple types, but dynamic types get converted to hashes. +func bindTopicTypeJava(kind abi.Type) string { + bound := bindTypeJava(kind) + if bound == "String" || bound == "Bytes" { + bound = "Hash" + } + return bound +} + // namedType is a set of functions that transform language specific types to // named versions that my be used inside method names. var namedType = map[Lang]func(string, abi.Type) string{ @@ -273,11 +354,13 @@ func namedTypeJava(javaKind string, solKind abi.Type) string { return "String" case "string[]": return "Strings" - case "bool": + case "boolean": return "Bool" - case "bool[]": + case "boolean[]": return "Bools" - case "BigInt": + case "BigInt[]": + return "BigInts" + default: parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String()) if len(parts) != 4 { return javaKind @@ -292,8 +375,6 @@ func namedTypeJava(javaKind string, solKind abi.Type) string { default: return javaKind } - default: - return javaKind } } @@ -304,26 +385,71 @@ var methodNormalizer = map[Lang]func(string) string{ LangJava: decapitalise, } -// capitalise makes the first character of a string upper case. +// capitalise makes a camel-case string which starts with an upper case character. func capitalise(input string) string { - return strings.ToUpper(input[:1]) + input[1:] + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } + return toCamelCase(strings.ToUpper(input[:1]) + input[1:]) } -// decapitalise makes the first character of a string lower case. +// decapitalise makes a camel-case string which starts with a lower case character. func decapitalise(input string) string { - return strings.ToLower(input[:1]) + input[1:] + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } + return toCamelCase(strings.ToLower(input[:1]) + input[1:]) } -// structured checks whether a method has enough information to return a proper -// Go struct ot if flat returns are needed. -func structured(method abi.Method) bool { - if len(method.Outputs) < 2 { +// toCamelCase converts an under-score string to a camel-case string +func toCamelCase(input string) string { + toupper := false + + result := "" + for k, v := range input { + switch { + case k == 0: + result = strings.ToUpper(string(input[0])) + + case toupper: + result += strings.ToUpper(string(v)) + toupper = false + + case v == '_': + toupper = true + + default: + result += string(v) + } + } + return result +} + +// structured checks whether a list of ABI data types has enough information to +// operate through a proper Go struct or if flat returns are needed. +func structured(args abi.Arguments) bool { + if len(args) < 2 { return false } - for _, out := range method.Outputs { + exists := make(map[string]bool) + for _, out := range args { + // If the name is anonymous, we can't organize into a struct if out.Name == "" { return false } + // If the field name is empty when normalized or collides (var, Var, _var, _Var), + // we can't organize into a struct + field := capitalise(out.Name) + if field == "" || exists[field] { + return false + } + exists[field] = true } return true } diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index 43ed53b922..2a5a886487 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -126,6 +126,7 @@ var bindTests = []struct { {"type":"function","name":"namedOutput","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"}]}, {"type":"function","name":"anonOutput","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"}]}, {"type":"function","name":"namedOutputs","constant":true,"inputs":[],"outputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}]}, + {"type":"function","name":"collidingOutputs","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"},{"name":"Str","type":"string"}]}, {"type":"function","name":"anonOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"","type":"string"}]}, {"type":"function","name":"mixedOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"str","type":"string"}]} ] @@ -140,12 +141,71 @@ var bindTests = []struct { str1, err = b.NamedOutput(nil) str1, err = b.AnonOutput(nil) res, _ := b.NamedOutputs(nil) + str1, str2, err = b.CollidingOutputs(nil) str1, str2, err = b.AnonOutputs(nil) str1, str2, err = b.MixedOutputs(nil) fmt.Println(str1, str2, res.Str1, res.Str2, err) }`, }, + // Tests that named, anonymous and indexed events are handled correctly + { + `EventChecker`, ``, ``, + ` + [ + {"type":"event","name":"empty","inputs":[]}, + {"type":"event","name":"indexed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256","indexed":true}]}, + {"type":"event","name":"mixed","inputs":[{"name":"addr","type":"address","indexed":true},{"name":"num","type":"int256"}]}, + {"type":"event","name":"anonymous","anonymous":true,"inputs":[]}, + {"type":"event","name":"dynamic","inputs":[{"name":"idxStr","type":"string","indexed":true},{"name":"idxDat","type":"bytes","indexed":true},{"name":"str","type":"string"},{"name":"dat","type":"bytes"}]} + ] + `, + `if e, err := NewEventChecker(common.Address{}, nil); e == nil || err != nil { + t.Fatalf("binding (%v) nil or error (%v) not nil", e, nil) + } else if false { // Don't run, just compile and test types + var ( + err error + res bool + str string + dat []byte + hash common.Hash + ) + _, err = e.FilterEmpty(nil) + _, err = e.FilterIndexed(nil, []common.Address{}, []*big.Int{}) + + mit, err := e.FilterMixed(nil, []common.Address{}) + + res = mit.Next() // Make sure the iterator has a Next method + err = mit.Error() // Make sure the iterator has an Error method + err = mit.Close() // Make sure the iterator has a Close method + + fmt.Println(mit.Event.Raw.BlockHash) // Make sure the raw log is contained within the results + fmt.Println(mit.Event.Num) // Make sure the unpacked non-indexed fields are present + fmt.Println(mit.Event.Addr) // Make sure the reconstructed indexed fields are present + + dit, err := e.FilterDynamic(nil, []string{}, [][]byte{}) + + str = dit.Event.Str // Make sure non-indexed strings retain their type + dat = dit.Event.Dat // Make sure non-indexed bytes retain their type + hash = dit.Event.IdxStr // Make sure indexed strings turn into hashes + hash = dit.Event.IdxDat // Make sure indexed bytes turn into hashes + + sink := make(chan *EventCheckerMixed) + sub, err := e.WatchMixed(nil, sink, []common.Address{}) + defer sub.Unsubscribe() + + event := <-sink + fmt.Println(event.Raw.BlockHash) // Make sure the raw log is contained within the results + fmt.Println(event.Num) // Make sure the unpacked non-indexed fields are present + fmt.Println(event.Addr) // Make sure the reconstructed indexed fields are present + + fmt.Println(res, str, dat, hash, err) + } + // Run a tiny reflection test to ensure disallowed methods don't appear + if _, ok := reflect.TypeOf(&EventChecker{}).MethodByName("FilterAnonymous"); ok { + t.Errorf("binding has disallowed method (FilterAnonymous)") + }`, + }, // Test that contract interactions (deploy, transact and call) generate working code { `Interactor`, @@ -365,7 +425,7 @@ var bindTests = []struct { } `, }, - // Tests that gas estimation works for contracts with weird gas mechanics too. + // Tests that gas estimation works for contracts with weird gas mechanics too. { `FunkyGasPattern`, ` @@ -397,7 +457,6 @@ var bindTests = []struct { sim.Commit() // Set the field with automatic estimation and check that it succeeds - auth.GasLimit = nil if _, err := limiter.SetField(auth, "automatic"); err != nil { t.Fatalf("Failed to call automatically gased transaction: %v", err) } @@ -447,6 +506,309 @@ var bindTests = []struct { } `, }, + // Tests that methods and returns with underscores inside work correctly. + { + `Underscorer`, + ` + contract Underscorer { + function UnderscoredOutput() constant returns (int _int, string _string) { + return (314, "pi"); + } + function LowerLowerCollision() constant returns (int _res, int res) { + return (1, 2); + } + function LowerUpperCollision() constant returns (int _res, int Res) { + return (1, 2); + } + function UpperLowerCollision() constant returns (int _Res, int res) { + return (1, 2); + } + function UpperUpperCollision() constant returns (int _Res, int Res) { + return (1, 2); + } + function PurelyUnderscoredOutput() constant returns (int _, int res) { + return (1, 2); + } + function AllPurelyUnderscoredOutput() constant returns (int _, int __) { + return (1, 2); + } + function _under_scored_func() constant returns (int _int) { + return 0; + } + } + `, `6060604052341561000f57600080fd5b6103858061001e6000396000f30060606040526004361061008e576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461009357806346546dbe146100c357806367e6633d146100ec5780639df4848514610181578063af7486ab146101b1578063b564b34d146101e1578063e02ab24d14610211578063e409ca4514610241575b600080fd5b341561009e57600080fd5b6100a6610271565b604051808381526020018281526020019250505060405180910390f35b34156100ce57600080fd5b6100d6610286565b6040518082815260200191505060405180910390f35b34156100f757600080fd5b6100ff61028e565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561014557808201518184015260208101905061012a565b50505050905090810190601f1680156101725780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561018c57600080fd5b6101946102dc565b604051808381526020018281526020019250505060405180910390f35b34156101bc57600080fd5b6101c46102f1565b604051808381526020018281526020019250505060405180910390f35b34156101ec57600080fd5b6101f4610306565b604051808381526020018281526020019250505060405180910390f35b341561021c57600080fd5b61022461031b565b604051808381526020018281526020019250505060405180910390f35b341561024c57600080fd5b610254610330565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600080905090565b6000610298610345565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820d1a53d9de9d1e3d55cb3dc591900b63c4f1ded79114f7b79b332684840e186a40029`, + `[{"constant":true,"inputs":[],"name":"LowerUpperCollision","outputs":[{"name":"_res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_under_scored_func","outputs":[{"name":"_int","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UnderscoredOutput","outputs":[{"name":"_int","type":"int256"},{"name":"_string","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperLowerCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"AllPurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"__","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperUpperCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"LowerLowerCollision","outputs":[{"name":"_res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"}]`, + ` + // Generate a new random account and a funded simulator + key, _ := crypto.GenerateKey() + auth := bind.NewKeyedTransactor(key) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000)}}) + + // Deploy a underscorer tester contract and execute a structured call on it + _, _, underscorer, err := DeployUnderscorer(auth, sim) + if err != nil { + t.Fatalf("Failed to deploy underscorer contract: %v", err) + } + sim.Commit() + + // Verify that underscored return values correctly parse into structs + if res, err := underscorer.UnderscoredOutput(nil); err != nil { + t.Errorf("Failed to call constant function: %v", err) + } else if res.Int.Cmp(big.NewInt(314)) != 0 || res.String != "pi" { + t.Errorf("Invalid result, want: {314, \"pi\"}, got: %+v", res) + } + // Verify that underscored and non-underscored name collisions force tuple outputs + var a, b *big.Int + + a, b, _ = underscorer.LowerLowerCollision(nil) + a, b, _ = underscorer.LowerUpperCollision(nil) + a, b, _ = underscorer.UpperLowerCollision(nil) + a, b, _ = underscorer.UpperUpperCollision(nil) + a, b, _ = underscorer.PurelyUnderscoredOutput(nil) + a, b, _ = underscorer.AllPurelyUnderscoredOutput(nil) + a, _ = underscorer.UnderScoredFunc(nil) + + fmt.Println(a, b, err) + `, + }, + // Tests that logs can be successfully filtered and decoded. + { + `Eventer`, + ` + contract Eventer { + event SimpleEvent ( + address indexed Addr, + bytes32 indexed Id, + bool indexed Flag, + uint Value + ); + function raiseSimpleEvent(address addr, bytes32 id, bool flag, uint value) { + SimpleEvent(addr, id, flag, value); + } + + event NodataEvent ( + uint indexed Number, + int16 indexed Short, + uint32 indexed Long + ); + function raiseNodataEvent(uint number, int16 short, uint32 long) { + NodataEvent(number, short, long); + } + + event DynamicEvent ( + string indexed IndexedString, + bytes indexed IndexedBytes, + string NonIndexedString, + bytes NonIndexedBytes + ); + function raiseDynamicEvent(string str, bytes blob) { + DynamicEvent(str, blob, str, blob); + } + } + `, + `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`, + `[{"constant":false,"inputs":[{"name":"str","type":"string"},{"name":"blob","type":"bytes"}],"name":"raiseDynamicEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"},{"name":"id","type":"bytes32"},{"name":"flag","type":"bool"},{"name":"value","type":"uint256"}],"name":"raiseSimpleEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"number","type":"uint256"},{"name":"short","type":"int16"},{"name":"long","type":"uint32"}],"name":"raiseNodataEvent","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Addr","type":"address"},{"indexed":true,"name":"Id","type":"bytes32"},{"indexed":true,"name":"Flag","type":"bool"},{"indexed":false,"name":"Value","type":"uint256"}],"name":"SimpleEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"Number","type":"uint256"},{"indexed":true,"name":"Short","type":"int16"},{"indexed":true,"name":"Long","type":"uint32"}],"name":"NodataEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IndexedString","type":"string"},{"indexed":true,"name":"IndexedBytes","type":"bytes"},{"indexed":false,"name":"NonIndexedString","type":"string"},{"indexed":false,"name":"NonIndexedBytes","type":"bytes"}],"name":"DynamicEvent","type":"event"}]`, + ` + // Generate a new random account and a funded simulator + key, _ := crypto.GenerateKey() + auth := bind.NewKeyedTransactor(key) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000)}}) + + // Deploy an eventer contract + _, _, eventer, err := DeployEventer(auth, sim) + if err != nil { + t.Fatalf("Failed to deploy eventer contract: %v", err) + } + sim.Commit() + + // Inject a few events into the contract, gradually more in each block + for i := 1; i <= 3; i++ { + for j := 1; j <= i; j++ { + if _, err := eventer.RaiseSimpleEvent(auth, common.Address{byte(j)}, [32]byte{byte(j)}, true, big.NewInt(int64(10*i+j))); err != nil { + t.Fatalf("block %d, event %d: raise failed: %v", i, j, err) + } + } + sim.Commit() + } + // Test filtering for certain events and ensure they can be found + sit, err := eventer.FilterSimpleEvent(nil, []common.Address{common.Address{1}, common.Address{3}}, [][32]byte{{byte(1)}, {byte(2)}, {byte(3)}}, []bool{true}) + if err != nil { + t.Fatalf("failed to filter for simple events: %v", err) + } + defer sit.Close() + + sit.Next() + if sit.Event.Value.Uint64() != 11 || !sit.Event.Flag { + t.Errorf("simple log content mismatch: have %v, want {11, true}", sit.Event) + } + sit.Next() + if sit.Event.Value.Uint64() != 21 || !sit.Event.Flag { + t.Errorf("simple log content mismatch: have %v, want {21, true}", sit.Event) + } + sit.Next() + if sit.Event.Value.Uint64() != 31 || !sit.Event.Flag { + t.Errorf("simple log content mismatch: have %v, want {31, true}", sit.Event) + } + sit.Next() + if sit.Event.Value.Uint64() != 33 || !sit.Event.Flag { + t.Errorf("simple log content mismatch: have %v, want {33, true}", sit.Event) + } + + if sit.Next() { + t.Errorf("unexpected simple event found: %+v", sit.Event) + } + if err = sit.Error(); err != nil { + t.Fatalf("simple event iteration failed: %v", err) + } + // Test raising and filtering for an event with no data component + if _, err := eventer.RaiseNodataEvent(auth, big.NewInt(314), 141, 271); err != nil { + t.Fatalf("failed to raise nodata event: %v", err) + } + sim.Commit() + + nit, err := eventer.FilterNodataEvent(nil, []*big.Int{big.NewInt(314)}, []int16{140, 141, 142}, []uint32{271}) + if err != nil { + t.Fatalf("failed to filter for nodata events: %v", err) + } + defer nit.Close() + + if !nit.Next() { + t.Fatalf("nodata log not found: %v", nit.Error()) + } + if nit.Event.Number.Uint64() != 314 { + t.Errorf("nodata log content mismatch: have %v, want 314", nit.Event.Number) + } + if nit.Next() { + t.Errorf("unexpected nodata event found: %+v", nit.Event) + } + if err = nit.Error(); err != nil { + t.Fatalf("nodata event iteration failed: %v", err) + } + // Test raising and filtering for events with dynamic indexed components + if _, err := eventer.RaiseDynamicEvent(auth, "Hello", []byte("World")); err != nil { + t.Fatalf("failed to raise dynamic event: %v", err) + } + sim.Commit() + + dit, err := eventer.FilterDynamicEvent(nil, []string{"Hi", "Hello", "Bye"}, [][]byte{[]byte("World")}) + if err != nil { + t.Fatalf("failed to filter for dynamic events: %v", err) + } + defer dit.Close() + + if !dit.Next() { + t.Fatalf("dynamic log not found: %v", dit.Error()) + } + if dit.Event.NonIndexedString != "Hello" || string(dit.Event.NonIndexedBytes) != "World" || dit.Event.IndexedString != common.HexToHash("0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2") || dit.Event.IndexedBytes != common.HexToHash("0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18") { + t.Errorf("dynamic log content mismatch: have %v, want {'0x06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2, '0xf2208c967df089f60420785795c0a9ba8896b0f6f1867fa7f1f12ad6f79c1a18', 'Hello', 'World'}", dit.Event) + } + if dit.Next() { + t.Errorf("unexpected dynamic event found: %+v", dit.Event) + } + if err = dit.Error(); err != nil { + t.Fatalf("dynamic event iteration failed: %v", err) + } + // Test subscribing to an event and raising it afterwards + ch := make(chan *EventerSimpleEvent, 16) + sub, err := eventer.WatchSimpleEvent(nil, ch, nil, nil, nil) + if err != nil { + t.Fatalf("failed to subscribe to simple events: %v", err) + } + if _, err := eventer.RaiseSimpleEvent(auth, common.Address{255}, [32]byte{255}, true, big.NewInt(255)); err != nil { + t.Fatalf("failed to raise subscribed simple event: %v", err) + } + sim.Commit() + + select { + case event := <-ch: + if event.Value.Uint64() != 255 { + t.Errorf("simple log content mismatch: have %v, want 255", event) + } + case <-time.After(250 * time.Millisecond): + t.Fatalf("subscribed simple event didn't arrive") + } + // Unsubscribe from the event and make sure we're not delivered more + sub.Unsubscribe() + + if _, err := eventer.RaiseSimpleEvent(auth, common.Address{254}, [32]byte{254}, true, big.NewInt(254)); err != nil { + t.Fatalf("failed to raise subscribed simple event: %v", err) + } + sim.Commit() + + select { + case event := <-ch: + t.Fatalf("unsubscribed simple event arrived: %v", event) + case <-time.After(250 * time.Millisecond): + } + `, + }, + { + `DeeplyNestedArray`, + ` + contract DeeplyNestedArray { + uint64[3][4][5] public deepUint64Array; + function storeDeepUintArray(uint64[3][4][5] arr) public { + deepUint64Array = arr; + } + function retrieveDeepArray() public view returns (uint64[3][4][5]) { + return deepUint64Array; + } + } + `, + `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`, + `[{"constant":false,"inputs":[{"name":"arr","type":"uint64[3][4][5]"}],"name":"storeDeepUintArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"retrieveDeepArray","outputs":[{"name":"","type":"uint64[3][4][5]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"name":"deepUint64Array","outputs":[{"name":"","type":"uint64"}],"payable":false,"stateMutability":"view","type":"function"}]`, + ` + // Generate a new random account and a funded simulator + key, _ := crypto.GenerateKey() + auth := bind.NewKeyedTransactor(key) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000)}}) + + //deploy the test contract + _, _, testContract, err := DeployDeeplyNestedArray(auth, sim) + if err != nil { + t.Fatalf("Failed to deploy test contract: %v", err) + } + + // Finish deploy. + sim.Commit() + + //Create coordinate-filled array, for testing purposes. + testArr := [5][4][3]uint64{} + for i := 0; i < 5; i++ { + testArr[i] = [4][3]uint64{} + for j := 0; j < 4; j++ { + testArr[i][j] = [3]uint64{} + for k := 0; k < 3; k++ { + //pack the coordinates, each array value will be unique, and can be validated easily. + testArr[i][j][k] = uint64(i) << 16 | uint64(j) << 8 | uint64(k) + } + } + } + + if _, err := testContract.StoreDeepUintArray(&bind.TransactOpts{ + From: auth.From, + Signer: auth.Signer, + }, testArr); err != nil { + t.Fatalf("Failed to store nested array in test contract: %v", err) + } + + sim.Commit() + + retrievedArr, err := testContract.RetrieveDeepArray(&bind.CallOpts{ + From: auth.From, + Pending: false, + }) + if err != nil { + t.Fatalf("Failed to retrieve nested array from test contract: %v", err) + } + + //quick check to see if contents were copied + // (See accounts/abi/unpack_test.go for more extensive testing) + if retrievedArr[4][3][2] != testArr[4][3][2] { + t.Fatalf("Retrieved value does not match expected value! got: %d, expected: %d. %v", retrievedArr[4][3][2], testArr[4][3][2], err) + } + `, + }, } // Tests that packages generated by the binder can be successfully compiled and @@ -498,7 +860,7 @@ func TestBindings(t *testing.T) { } } // Test the entire package and report any failures - cmd := exec.Command(gocmd, "test", "-v") + cmd := exec.Command(gocmd, "test", "-v", "-count", "1") cmd.Dir = pkg if out, err := cmd.CombinedOutput(); err != nil { t.Fatalf("failed to run binding test: %v\n%s", err, out) diff --git a/accounts/abi/bind/template.go b/accounts/abi/bind/template.go index d07610e7c2..7202ee67a1 100644 --- a/accounts/abi/bind/template.go +++ b/accounts/abi/bind/template.go @@ -32,6 +32,7 @@ type tmplContract struct { Constructor abi.Method // Contract constructor for deploy parametrization Calls map[string]*tmplMethod // Contract calls that only read state data Transacts map[string]*tmplMethod // Contract calls that write state data + Events map[string]*tmplEvent // Contract events accessors } // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed @@ -39,7 +40,13 @@ type tmplContract struct { type tmplMethod struct { Original abi.Method // Original method as parsed by the abi package Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns) - Structured bool // Whether the returns should be accumulated into a contract + Structured bool // Whether the returns should be accumulated into a struct +} + +// tmplEvent is a wrapper around an a +type tmplEvent struct { + Original abi.Event // Original event as parsed by the abi package + Normalized abi.Event // Normalized version of the parsed fields } // tmplSource is language to template mapping containing all the supported @@ -75,7 +82,7 @@ package {{.Package}} if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract} }, nil + return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil } {{end}} @@ -83,6 +90,7 @@ package {{.Package}} type {{.Type}} struct { {{.Type}}Caller // Read-only binding to the contract {{.Type}}Transactor // Write-only binding to the contract + {{.Type}}Filterer // Log filterer for contract events } // {{.Type}}Caller is an auto generated read-only Go binding around an Ethereum contract. @@ -95,6 +103,11 @@ package {{.Package}} contract *bind.BoundContract // Generic contract wrapper for the low level calls } + // {{.Type}}Filterer is an auto generated log filtering Go binding around an Ethereum contract events. + type {{.Type}}Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls + } + // {{.Type}}Session is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type {{.Type}}Session struct { @@ -134,16 +147,16 @@ package {{.Package}} // New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract. func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) { - contract, err := bind{{.Type}}(address, backend, backend) + contract, err := bind{{.Type}}(address, backend, backend, backend) if err != nil { return nil, err } - return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract} }, nil + return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil } // New{{.Type}}Caller creates a new read-only instance of {{.Type}}, bound to a specific deployed contract. func New{{.Type}}Caller(address common.Address, caller bind.ContractCaller) (*{{.Type}}Caller, error) { - contract, err := bind{{.Type}}(address, caller, nil) + contract, err := bind{{.Type}}(address, caller, nil, nil) if err != nil { return nil, err } @@ -152,20 +165,29 @@ package {{.Package}} // New{{.Type}}Transactor creates a new write-only instance of {{.Type}}, bound to a specific deployed contract. func New{{.Type}}Transactor(address common.Address, transactor bind.ContractTransactor) (*{{.Type}}Transactor, error) { - contract, err := bind{{.Type}}(address, nil, transactor) + contract, err := bind{{.Type}}(address, nil, transactor, nil) if err != nil { return nil, err } return &{{.Type}}Transactor{contract: contract}, nil } + // New{{.Type}}Filterer creates a new log filterer instance of {{.Type}}, bound to a specific deployed contract. + func New{{.Type}}Filterer(address common.Address, filterer bind.ContractFilterer) (*{{.Type}}Filterer, error) { + contract, err := bind{{.Type}}(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &{{.Type}}Filterer{contract: contract}, nil + } + // bind{{.Type}} binds a generic wrapper to an already deployed contract. - func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) { + func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI)) if err != nil { return nil, err } - return bind.NewBoundContract(address, parsed, caller, transactor), nil + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and @@ -263,6 +285,137 @@ package {{.Package}} return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}}) } {{end}} + + {{range .Events}} + // {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}}Iterator struct { + Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration + } + // Next advances the iterator to the subsequent event, returning whether there + // are any more events found. In case of a retrieval or parsing error, false is + // returned and Error() can be queried for the exact failure. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool { + // If the iterator failed, stop iterating + if (it.fail != nil) { + return false + } + // If the iterator completed, deliver directly whatever's available + if (it.done) { + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new({{$contract.Type}}{{.Normalized.Name}}) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } + } + // Error returns any retrieval or parsing error occurred during filtering. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error { + return it.fail + } + // Close terminates the iteration process, releasing any pending underlying + // resources. + func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error { + it.sub.Unsubscribe() + return nil + } + + // {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract. + type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}} + {{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type}}{{else}}{{bindtype .Type}}{{end}}; {{end}} + Raw types.Log // Blockchain specific contextual infos + } + + // Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.Id}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil + } + + // Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.Id}}. + // + // Solidity: {{.Original.String}} + func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type}}{{end}}{{end}}) (event.Subscription, error) { + {{range .Normalized.Inputs}} + {{if .Indexed}}var {{.Name}}Rule []interface{} + for _, {{.Name}}Item := range {{.Name}} { + {{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item) + }{{end}}{{end}} + + logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}}) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new({{$contract.Type}}{{.Normalized.Name}}) + if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil + } + {{end}} {{end}} ` diff --git a/accounts/abi/bind/topics.go b/accounts/abi/bind/topics.go new file mode 100644 index 0000000000..600dfcda97 --- /dev/null +++ b/accounts/abi/bind/topics.go @@ -0,0 +1,189 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package bind + +import ( + "errors" + "fmt" + "math/big" + "reflect" + + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +// makeTopics converts a filter query argument list into a filter topic set. +func makeTopics(query ...[]interface{}) ([][]common.Hash, error) { + topics := make([][]common.Hash, len(query)) + for i, filter := range query { + for _, rule := range filter { + var topic common.Hash + + // Try to generate the topic based on simple types + switch rule := rule.(type) { + case common.Hash: + copy(topic[:], rule[:]) + case common.Address: + copy(topic[common.HashLength-common.AddressLength:], rule[:]) + case *big.Int: + blob := rule.Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case bool: + if rule { + topic[common.HashLength-1] = 1 + } + case int8: + blob := big.NewInt(int64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case int16: + blob := big.NewInt(int64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case int32: + blob := big.NewInt(int64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case int64: + blob := big.NewInt(rule).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case uint8: + blob := new(big.Int).SetUint64(uint64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case uint16: + blob := new(big.Int).SetUint64(uint64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case uint32: + blob := new(big.Int).SetUint64(uint64(rule)).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case uint64: + blob := new(big.Int).SetUint64(rule).Bytes() + copy(topic[common.HashLength-len(blob):], blob) + case string: + hash := crypto.Keccak256Hash([]byte(rule)) + copy(topic[:], hash[:]) + case []byte: + hash := crypto.Keccak256Hash(rule) + copy(topic[:], hash[:]) + + default: + // Attempt to generate the topic from funky types + val := reflect.ValueOf(rule) + + switch { + case val.Kind() == reflect.Array && reflect.TypeOf(rule).Elem().Kind() == reflect.Uint8: + reflect.Copy(reflect.ValueOf(topic[common.HashLength-val.Len():]), val) + + default: + return nil, fmt.Errorf("unsupported indexed type: %T", rule) + } + } + topics[i] = append(topics[i], topic) + } + } + return topics, nil +} + +// Big batch of reflect types for topic reconstruction. +var ( + reflectHash = reflect.TypeOf(common.Hash{}) + reflectAddress = reflect.TypeOf(common.Address{}) + reflectBigInt = reflect.TypeOf(new(big.Int)) +) + +// parseTopics converts the indexed topic fields into actual log field values. +// +// Note, dynamic types cannot be reconstructed since they get mapped to Keccak256 +// hashes as the topic value! +func parseTopics(out interface{}, fields abi.Arguments, topics []common.Hash) error { + // Sanity check that the fields and topics match up + if len(fields) != len(topics) { + return errors.New("topic/field count mismatch") + } + // Iterate over all the fields and reconstruct them from topics + for _, arg := range fields { + if !arg.Indexed { + return errors.New("non-indexed field in topic reconstruction") + } + field := reflect.ValueOf(out).Elem().FieldByName(capitalise(arg.Name)) + + // Try to parse the topic back into the fields based on primitive types + switch field.Kind() { + case reflect.Bool: + if topics[0][common.HashLength-1] == 1 { + field.Set(reflect.ValueOf(true)) + } + case reflect.Int8: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(int8(num.Int64()))) + + case reflect.Int16: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(int16(num.Int64()))) + + case reflect.Int32: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(int32(num.Int64()))) + + case reflect.Int64: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(num.Int64())) + + case reflect.Uint8: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(uint8(num.Uint64()))) + + case reflect.Uint16: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(uint16(num.Uint64()))) + + case reflect.Uint32: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(uint32(num.Uint64()))) + + case reflect.Uint64: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(num.Uint64())) + + default: + // Ran out of plain primitive types, try custom types + switch field.Type() { + case reflectHash: // Also covers all dynamic types + field.Set(reflect.ValueOf(topics[0])) + + case reflectAddress: + var addr common.Address + copy(addr[:], topics[0][common.HashLength-common.AddressLength:]) + field.Set(reflect.ValueOf(addr)) + + case reflectBigInt: + num := new(big.Int).SetBytes(topics[0][:]) + field.Set(reflect.ValueOf(num)) + + default: + // Ran out of custom types, try the crazies + switch { + case arg.Type.T == abi.FixedBytesTy: + reflect.Copy(field, reflect.ValueOf(topics[0][common.HashLength-arg.Type.Size:])) + + default: + return fmt.Errorf("unsupported indexed type: %v", arg.Type) + } + } + } + topics = topics[1:] + } + return nil +} diff --git a/accounts/abi/bind/util_test.go b/accounts/abi/bind/util_test.go index d24aa721e5..49e6dc813a 100644 --- a/accounts/abi/bind/util_test.go +++ b/accounts/abi/bind/util_test.go @@ -34,18 +34,18 @@ var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d var waitDeployedTests = map[string]struct { code string - gas *big.Int + gas uint64 wantAddress common.Address wantErr error }{ "successful deploy": { code: `6060604052600a8060106000396000f360606040526008565b00`, - gas: big.NewInt(3000000), + gas: 3000000, wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), }, "empty code": { code: ``, - gas: big.NewInt(300000), + gas: 300000, wantErr: bind.ErrNoCodeAfterDeploy, wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), }, diff --git a/accounts/abi/event.go b/accounts/abi/event.go index 44ed7b8df2..a3f6be9732 100644 --- a/accounts/abi/event.go +++ b/accounts/abi/event.go @@ -18,7 +18,6 @@ package abi import ( "fmt" - "reflect" "strings" "github.com/ethereum/go-ethereum/common" @@ -31,7 +30,18 @@ import ( type Event struct { Name string Anonymous bool - Inputs []Argument + Inputs Arguments +} + +func (e Event) String() string { + inputs := make([]string, len(e.Inputs)) + for i, input := range e.Inputs { + inputs[i] = fmt.Sprintf("%v %v", input.Name, input.Type) + if input.Indexed { + inputs[i] = fmt.Sprintf("%v indexed %v", input.Name, input.Type) + } + } + return fmt.Sprintf("e %v(%v)", e.Name, strings.Join(inputs, ", ")) } // Id returns the canonical representation of the event's signature used by the @@ -45,93 +55,3 @@ func (e Event) Id() common.Hash { } return common.BytesToHash(crypto.Keccak256([]byte(fmt.Sprintf("%v(%v)", e.Name, strings.Join(types, ","))))) } - -// unpacks an event return tuple into a struct of corresponding go types -// -// Unpacking can be done into a struct or a slice/array. -func (e Event) tupleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - var ( - value = valueOf.Elem() - typ = value.Type() - ) - - if value.Kind() != reflect.Struct { - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - - j := 0 - for i := 0; i < len(e.Inputs); i++ { - input := e.Inputs[i] - if input.Indexed { - // can't read, continue - continue - } else if input.Type.T == ArrayTy { - // need to move this up because they read sequentially - j += input.Type.Size - } - marshalledValue, err := toGoType((i+j)*32, input.Type, output) - if err != nil { - return err - } - reflectValue := reflect.ValueOf(marshalledValue) - - switch value.Kind() { - case reflect.Struct: - for j := 0; j < typ.NumField(); j++ { - field := typ.Field(j) - // TODO read tags: `abi:"fieldName"` - if field.Name == strings.ToUpper(e.Inputs[i].Name[:1])+e.Inputs[i].Name[1:] { - if err := set(value.Field(j), reflectValue, e.Inputs[i]); err != nil { - return err - } - } - } - case reflect.Slice, reflect.Array: - if value.Len() < i { - return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(e.Inputs), value.Len()) - } - v := value.Index(i) - if v.Kind() != reflect.Ptr && v.Kind() != reflect.Interface { - return fmt.Errorf("abi: cannot unmarshal %v in to %v", v.Type(), reflectValue.Type()) - } - reflectValue := reflect.ValueOf(marshalledValue) - if err := set(v.Elem(), reflectValue, e.Inputs[i]); err != nil { - return err - } - default: - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - } - return nil -} - -func (e Event) isTupleReturn() bool { return len(e.Inputs) > 1 } - -func (e Event) singleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - if e.Inputs[0].Indexed { - return fmt.Errorf("abi: attempting to unpack indexed variable into element.") - } - - value := valueOf.Elem() - - marshalledValue, err := toGoType(0, e.Inputs[0].Type, output) - if err != nil { - return err - } - if err := set(value, reflect.ValueOf(marshalledValue), e.Inputs[0]); err != nil { - return err - } - return nil -} diff --git a/accounts/abi/event_test.go b/accounts/abi/event_test.go index 7e2f13f763..3bfdd7c0ab 100644 --- a/accounts/abi/event_test.go +++ b/accounts/abi/event_test.go @@ -17,13 +17,69 @@ package abi import ( + "bytes" + "encoding/hex" + "encoding/json" + "math/big" + "reflect" "strings" "testing" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +var jsonEventTransfer = []byte(`{ + "anonymous": false, + "inputs": [ + { + "indexed": true, "name": "from", "type": "address" + }, { + "indexed": true, "name": "to", "type": "address" + }, { + "indexed": false, "name": "value", "type": "uint256" + }], + "name": "Transfer", + "type": "event" +}`) + +var jsonEventPledge = []byte(`{ + "anonymous": false, + "inputs": [{ + "indexed": false, "name": "who", "type": "address" + }, { + "indexed": false, "name": "wad", "type": "uint128" + }, { + "indexed": false, "name": "currency", "type": "bytes3" + }], + "name": "Pledge", + "type": "event" +}`) + +var jsonEventMixedCase = []byte(`{ + "anonymous": false, + "inputs": [{ + "indexed": false, "name": "value", "type": "uint256" + }, { + "indexed": false, "name": "_value", "type": "uint256" + }, { + "indexed": false, "name": "Value", "type": "uint256" + }], + "name": "MixedCase", + "type": "event" + }`) + +// 1000000 +var transferData1 = "00000000000000000000000000000000000000000000000000000000000f4240" + +// "0x00Ce0d46d924CC8437c806721496599FC3FFA268", 2218516807680, "usd" +var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa2680000000000000000000000000000000000000000000000000000020489e800007573640000000000000000000000000000000000000000000000000000000000" + +// 1000000,2218516807680,1000001 +var mixedCaseData1 = "00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000000020489e8000000000000000000000000000000000000000000000000000000000000000f4241" + func TestEventId(t *testing.T) { var table = []struct { definition string @@ -54,3 +110,286 @@ func TestEventId(t *testing.T) { } } } + +// TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array. +func TestEventMultiValueWithArrayUnpack(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]` + type testStruct struct { + Value1 [2]uint8 + Value2 uint8 + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + var i uint8 = 1 + for ; i <= 3; i++ { + b.Write(packNum(reflect.ValueOf(i))) + } + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, [2]uint8{1, 2}, rst.Value1) + require.Equal(t, uint8(3), rst.Value2) +} + +func TestEventTupleUnpack(t *testing.T) { + + type EventTransfer struct { + Value *big.Int + } + + type EventTransferWithTag struct { + // this is valid because `value` is not exportable, + // so value is only unmarshalled into `Value1`. + value *big.Int + Value1 *big.Int `abi:"value"` + } + + type BadEventTransferWithSameFieldAndTag struct { + Value *big.Int + Value1 *big.Int `abi:"value"` + } + + type BadEventTransferWithDuplicatedTag struct { + Value1 *big.Int `abi:"value"` + Value2 *big.Int `abi:"value"` + } + + type BadEventTransferWithEmptyTag struct { + Value *big.Int `abi:""` + } + + type EventPledge struct { + Who common.Address + Wad *big.Int + Currency [3]byte + } + + type BadEventPledge struct { + Who string + Wad int + Currency [3]byte + } + + type EventMixedCase struct { + Value1 *big.Int `abi:"value"` + Value2 *big.Int `abi:"_value"` + Value3 *big.Int `abi:"Value"` + } + + bigint := new(big.Int) + bigintExpected := big.NewInt(1000000) + bigintExpected2 := big.NewInt(2218516807680) + bigintExpected3 := big.NewInt(1000001) + addr := common.HexToAddress("0x00Ce0d46d924CC8437c806721496599FC3FFA268") + var testCases = []struct { + data string + dest interface{} + expected interface{} + jsonLog []byte + error string + name string + }{{ + transferData1, + &EventTransfer{}, + &EventTransfer{Value: bigintExpected}, + jsonEventTransfer, + "", + "Can unpack ERC20 Transfer event into structure", + }, { + transferData1, + &[]interface{}{&bigint}, + &[]interface{}{&bigintExpected}, + jsonEventTransfer, + "", + "Can unpack ERC20 Transfer event into slice", + }, { + transferData1, + &EventTransferWithTag{}, + &EventTransferWithTag{Value1: bigintExpected}, + jsonEventTransfer, + "", + "Can unpack ERC20 Transfer event into structure with abi: tag", + }, { + transferData1, + &BadEventTransferWithDuplicatedTag{}, + &BadEventTransferWithDuplicatedTag{}, + jsonEventTransfer, + "struct: abi tag in 'Value2' already mapped", + "Can not unpack ERC20 Transfer event with duplicated abi tag", + }, { + transferData1, + &BadEventTransferWithSameFieldAndTag{}, + &BadEventTransferWithSameFieldAndTag{}, + jsonEventTransfer, + "abi: multiple variables maps to the same abi field 'value'", + "Can not unpack ERC20 Transfer event with a field and a tag mapping to the same abi variable", + }, { + transferData1, + &BadEventTransferWithEmptyTag{}, + &BadEventTransferWithEmptyTag{}, + jsonEventTransfer, + "struct: abi tag in 'Value' is empty", + "Can not unpack ERC20 Transfer event with an empty tag", + }, { + pledgeData1, + &EventPledge{}, + &EventPledge{ + addr, + bigintExpected2, + [3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into structure", + }, { + pledgeData1, + &[]interface{}{&common.Address{}, &bigint, &[3]byte{}}, + &[]interface{}{ + &addr, + &bigintExpected2, + &[3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into slice", + }, { + pledgeData1, + &[3]interface{}{&common.Address{}, &bigint, &[3]byte{}}, + &[3]interface{}{ + &addr, + &bigintExpected2, + &[3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into an array", + }, { + pledgeData1, + &[]interface{}{new(int), 0, 0}, + &[]interface{}{}, + jsonEventPledge, + "abi: cannot unmarshal common.Address in to int", + "Can not unpack Pledge event into slice with wrong types", + }, { + pledgeData1, + &BadEventPledge{}, + &BadEventPledge{}, + jsonEventPledge, + "abi: cannot unmarshal common.Address in to string", + "Can not unpack Pledge event into struct with wrong filed types", + }, { + pledgeData1, + &[]interface{}{common.Address{}, new(big.Int)}, + &[]interface{}{}, + jsonEventPledge, + "abi: insufficient number of elements in the list/array for unpack, want 3, got 2", + "Can not unpack Pledge event into too short slice", + }, { + pledgeData1, + new(map[string]interface{}), + &[]interface{}{}, + jsonEventPledge, + "abi: cannot unmarshal tuple into map[string]interface {}", + "Can not unpack Pledge event into map", + }, { + mixedCaseData1, + &EventMixedCase{}, + &EventMixedCase{Value1: bigintExpected, Value2: bigintExpected2, Value3: bigintExpected3}, + jsonEventMixedCase, + "", + "Can unpack abi variables with mixed case", + }} + + for _, tc := range testCases { + assert := assert.New(t) + tc := tc + t.Run(tc.name, func(t *testing.T) { + err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert) + if tc.error == "" { + assert.Nil(err, "Should be able to unpack event data.") + assert.Equal(tc.expected, tc.dest, tc.name) + } else { + assert.EqualError(err, tc.error, tc.name) + } + }) + } +} + +func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, assert *assert.Assertions) error { + data, err := hex.DecodeString(hexData) + assert.NoError(err, "Hex data should be a correct hex-string") + var e Event + assert.NoError(json.Unmarshal(jsonEvent, &e), "Should be able to unmarshal event ABI") + a := ABI{Events: map[string]Event{"e": e}} + return a.Unpack(dest, "e", data) +} + +/* +Taken from +https://github.com/ethereum/go-ethereum/pull/15568 +*/ + +type testResult struct { + Values [2]*big.Int + Value1 *big.Int + Value2 *big.Int +} + +type testCase struct { + definition string + want testResult +} + +func (tc testCase) encoded(intType, arrayType Type) []byte { + var b bytes.Buffer + if tc.want.Value1 != nil { + val, _ := intType.pack(reflect.ValueOf(tc.want.Value1)) + b.Write(val) + } + + if !reflect.DeepEqual(tc.want.Values, [2]*big.Int{nil, nil}) { + val, _ := arrayType.pack(reflect.ValueOf(tc.want.Values)) + b.Write(val) + } + if tc.want.Value2 != nil { + val, _ := intType.pack(reflect.ValueOf(tc.want.Value2)) + b.Write(val) + } + return b.Bytes() +} + +// TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder. +func TestEventUnpackIndexed(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]` + type testStruct struct { + Value1 uint8 + Value2 uint8 + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + b.Write(packNum(reflect.ValueOf(uint8(8)))) + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, uint8(0), rst.Value1) + require.Equal(t, uint8(8), rst.Value2) +} + +// TestEventIndexedWithArrayUnpack verifies that decoder will not overlow when static array is indexed input. +func TestEventIndexedWithArrayUnpack(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]` + type testStruct struct { + Value1 [2]uint8 + Value2 string + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + stringOut := "abc" + // number of fields that will be encoded * 32 + b.Write(packNum(reflect.ValueOf(32))) + b.Write(packNum(reflect.ValueOf(len(stringOut)))) + b.Write(common.RightPadBytes([]byte(stringOut), 32)) + + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, [2]uint8{0, 0}, rst.Value1) + require.Equal(t, stringOut, rst.Value2) +} diff --git a/accounts/abi/method.go b/accounts/abi/method.go index d8838e9ed6..f434ffdbef 100644 --- a/accounts/abi/method.go +++ b/accounts/abi/method.go @@ -18,13 +18,12 @@ package abi import ( "fmt" - "reflect" "strings" "github.com/ethereum/go-ethereum/crypto" ) -// Callable method given a `Name` and whether the method is a constant. +// Method represents a callable given a `Name` and whether the method is a constant. // If the method is `Const` no transaction needs to be created for this // particular Method call. It can easily be simulated using a local VM. // For example a `Balance()` method only needs to retrieve something @@ -35,125 +34,8 @@ import ( type Method struct { Name string Const bool - Inputs []Argument - Outputs []Argument -} - -func (method Method) pack(args ...interface{}) ([]byte, error) { - // Make sure arguments match up and pack them - if len(args) != len(method.Inputs) { - return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Inputs)) - } - // variable input is the output appended at the end of packed - // output. This is used for strings and bytes types input. - var variableInput []byte - - var ret []byte - for i, a := range args { - input := method.Inputs[i] - // pack the input - packed, err := input.Type.pack(reflect.ValueOf(a)) - if err != nil { - return nil, fmt.Errorf("`%s` %v", method.Name, err) - } - - // check for a slice type (string, bytes, slice) - if input.Type.requiresLengthPrefix() { - // calculate the offset - offset := len(method.Inputs)*32 + len(variableInput) - // set the offset - ret = append(ret, packNum(reflect.ValueOf(offset))...) - // Append the packed output to the variable input. The variable input - // will be appended at the end of the input. - variableInput = append(variableInput, packed...) - } else { - // append the packed value to the input - ret = append(ret, packed...) - } - } - // append the variable input at the end of the packed input - ret = append(ret, variableInput...) - - return ret, nil -} - -// unpacks a method return tuple into a struct of corresponding go types -// -// Unpacking can be done into a struct or a slice/array. -func (method Method) tupleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - var ( - value = valueOf.Elem() - typ = value.Type() - ) - - j := 0 - for i := 0; i < len(method.Outputs); i++ { - toUnpack := method.Outputs[i] - if toUnpack.Type.T == ArrayTy { - // need to move this up because they read sequentially - j += toUnpack.Type.Size - } - marshalledValue, err := toGoType((i+j)*32, toUnpack.Type, output) - if err != nil { - return err - } - reflectValue := reflect.ValueOf(marshalledValue) - - switch value.Kind() { - case reflect.Struct: - for j := 0; j < typ.NumField(); j++ { - field := typ.Field(j) - // TODO read tags: `abi:"fieldName"` - if field.Name == strings.ToUpper(method.Outputs[i].Name[:1])+method.Outputs[i].Name[1:] { - if err := set(value.Field(j), reflectValue, method.Outputs[i]); err != nil { - return err - } - } - } - case reflect.Slice, reflect.Array: - if value.Len() < i { - return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(method.Outputs), value.Len()) - } - v := value.Index(i) - if v.Kind() != reflect.Ptr && v.Kind() != reflect.Interface { - return fmt.Errorf("abi: cannot unmarshal %v in to %v", v.Type(), reflectValue.Type()) - } - reflectValue := reflect.ValueOf(marshalledValue) - if err := set(v.Elem(), reflectValue, method.Outputs[i]); err != nil { - return err - } - default: - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - } - return nil -} - -func (method Method) isTupleReturn() bool { return len(method.Outputs) > 1 } - -func (method Method) singleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - value := valueOf.Elem() - - marshalledValue, err := toGoType(0, method.Outputs[0].Type, output) - if err != nil { - return err - } - if err := set(value, reflect.ValueOf(marshalledValue), method.Outputs[0]); err != nil { - return err - } - return nil + Inputs Arguments + Outputs Arguments } // Sig returns the methods string signature according to the ABI spec. @@ -163,35 +45,35 @@ func (method Method) singleUnpack(v interface{}, output []byte) error { // function foo(uint32 a, int b) = "foo(uint32,int256)" // // Please note that "int" is substitute for its canonical representation "int256" -func (m Method) Sig() string { - types := make([]string, len(m.Inputs)) +func (method Method) Sig() string { + types := make([]string, len(method.Inputs)) i := 0 - for _, input := range m.Inputs { + for _, input := range method.Inputs { types[i] = input.Type.String() i++ } - return fmt.Sprintf("%v(%v)", m.Name, strings.Join(types, ",")) + return fmt.Sprintf("%v(%v)", method.Name, strings.Join(types, ",")) } -func (m Method) String() string { - inputs := make([]string, len(m.Inputs)) - for i, input := range m.Inputs { +func (method Method) String() string { + inputs := make([]string, len(method.Inputs)) + for i, input := range method.Inputs { inputs[i] = fmt.Sprintf("%v %v", input.Name, input.Type) } - outputs := make([]string, len(m.Outputs)) - for i, output := range m.Outputs { + outputs := make([]string, len(method.Outputs)) + for i, output := range method.Outputs { if len(output.Name) > 0 { outputs[i] = fmt.Sprintf("%v ", output.Name) } outputs[i] += output.Type.String() } constant := "" - if m.Const { + if method.Const { constant = "constant " } - return fmt.Sprintf("function %v(%v) %sreturns(%v)", m.Name, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", ")) + return fmt.Sprintf("function %v(%v) %sreturns(%v)", method.Name, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", ")) } -func (m Method) Id() []byte { - return crypto.Keccak256([]byte(m.Sig()))[:4] +func (method Method) Id() []byte { + return crypto.Keccak256([]byte(method.Sig()))[:4] } diff --git a/accounts/abi/numbers.go b/accounts/abi/numbers.go index 9ad99f90d2..0cd97cc66f 100644 --- a/accounts/abi/numbers.go +++ b/accounts/abi/numbers.go @@ -25,23 +25,23 @@ import ( ) var ( - big_t = reflect.TypeOf(&big.Int{}) - derefbig_t = reflect.TypeOf(big.Int{}) - uint8_t = reflect.TypeOf(uint8(0)) - uint16_t = reflect.TypeOf(uint16(0)) - uint32_t = reflect.TypeOf(uint32(0)) - uint64_t = reflect.TypeOf(uint64(0)) - int_t = reflect.TypeOf(int(0)) - int8_t = reflect.TypeOf(int8(0)) - int16_t = reflect.TypeOf(int16(0)) - int32_t = reflect.TypeOf(int32(0)) - int64_t = reflect.TypeOf(int64(0)) - address_t = reflect.TypeOf(common.Address{}) - int_ts = reflect.TypeOf([]int(nil)) - int8_ts = reflect.TypeOf([]int8(nil)) - int16_ts = reflect.TypeOf([]int16(nil)) - int32_ts = reflect.TypeOf([]int32(nil)) - int64_ts = reflect.TypeOf([]int64(nil)) + bigT = reflect.TypeOf(&big.Int{}) + derefbigT = reflect.TypeOf(big.Int{}) + uint8T = reflect.TypeOf(uint8(0)) + uint16T = reflect.TypeOf(uint16(0)) + uint32T = reflect.TypeOf(uint32(0)) + uint64T = reflect.TypeOf(uint64(0)) + intT = reflect.TypeOf(int(0)) + int8T = reflect.TypeOf(int8(0)) + int16T = reflect.TypeOf(int16(0)) + int32T = reflect.TypeOf(int32(0)) + int64T = reflect.TypeOf(int64(0)) + addressT = reflect.TypeOf(common.Address{}) + intTS = reflect.TypeOf([]int(nil)) + int8TS = reflect.TypeOf([]int8(nil)) + int16TS = reflect.TypeOf([]int16(nil)) + int32TS = reflect.TypeOf([]int32(nil)) + int64TS = reflect.TypeOf([]int64(nil)) ) // U256 converts a big Int into a 256bit EVM number. @@ -52,7 +52,7 @@ func U256(n *big.Int) []byte { // checks whether the given reflect value is signed. This also works for slices with a number type func isSigned(v reflect.Value) bool { switch v.Type() { - case int_ts, int8_ts, int16_ts, int32_ts, int64_ts, int_t, int8_t, int16_t, int32_t, int64_t: + case intTS, int8TS, int16TS, int32TS, int64TS, intT, int8T, int16T, int32T, int64T: return true } return false diff --git a/accounts/abi/pack.go b/accounts/abi/pack.go index 072e805368..36c58265bd 100644 --- a/accounts/abi/pack.go +++ b/accounts/abi/pack.go @@ -48,9 +48,8 @@ func packElement(t Type, reflectValue reflect.Value) []byte { case BoolTy: if reflectValue.Bool() { return math.PaddedBigBytes(common.Big1, 32) - } else { - return math.PaddedBigBytes(common.Big0, 32) } + return math.PaddedBigBytes(common.Big0, 32) case BytesTy: if reflectValue.Kind() == reflect.Array { reflectValue = mustArrayToByteSlice(reflectValue) diff --git a/accounts/abi/pack_test.go b/accounts/abi/pack_test.go index 36401ee677..58a5b7a581 100644 --- a/accounts/abi/pack_test.go +++ b/accounts/abi/pack_test.go @@ -1,4 +1,4 @@ -// Copyright 2015 The go-ethereum Authors +// Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -299,6 +299,11 @@ func TestPack(t *testing.T) { [32]byte{1}, common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"), }, + { + "uint32[2][3][4]", + [4][3][2]uint32{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}, {{13, 14}, {15, 16}, {17, 18}}, {{19, 20}, {21, 22}, {23, 24}}}, + common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000170000000000000000000000000000000000000000000000000000000000000018"), + }, { "address[]", []common.Address{{1}, {2}}, diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go index e953b77c18..0193517a42 100644 --- a/accounts/abi/reflect.go +++ b/accounts/abi/reflect.go @@ -19,12 +19,13 @@ package abi import ( "fmt" "reflect" + "strings" ) // indirect recursively dereferences the value until it either gets the value // or finds a big.Int func indirect(v reflect.Value) reflect.Value { - if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbig_t { + if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbigT { return indirect(v.Elem()) } return v @@ -36,26 +37,26 @@ func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) switch size { case 8: if unsigned { - return reflect.Uint8, uint8_t + return reflect.Uint8, uint8T } - return reflect.Int8, int8_t + return reflect.Int8, int8T case 16: if unsigned { - return reflect.Uint16, uint16_t + return reflect.Uint16, uint16T } - return reflect.Int16, int16_t + return reflect.Int16, int16T case 32: if unsigned { - return reflect.Uint32, uint32_t + return reflect.Uint32, uint32T } - return reflect.Int32, int32_t + return reflect.Int32, int32T case 64: if unsigned { - return reflect.Uint64, uint64_t + return reflect.Uint64, uint64T } - return reflect.Int64, int64_t + return reflect.Int64, int64T } - return reflect.Ptr, big_t + return reflect.Ptr, bigT } // mustArrayToBytesSlice creates a new byte slice with the exact same size as value @@ -85,3 +86,127 @@ func set(dst, src reflect.Value, output Argument) error { } return nil } + +// requireAssignable assures that `dest` is a pointer and it's not an interface. +func requireAssignable(dst, src reflect.Value) error { + if dst.Kind() != reflect.Ptr && dst.Kind() != reflect.Interface { + return fmt.Errorf("abi: cannot unmarshal %v into %v", src.Type(), dst.Type()) + } + return nil +} + +// requireUnpackKind verifies preconditions for unpacking `args` into `kind` +func requireUnpackKind(v reflect.Value, t reflect.Type, k reflect.Kind, + args Arguments) error { + + switch k { + case reflect.Struct: + case reflect.Slice, reflect.Array: + if minLen := args.LengthNonIndexed(); v.Len() < minLen { + return fmt.Errorf("abi: insufficient number of elements in the list/array for unpack, want %d, got %d", + minLen, v.Len()) + } + default: + return fmt.Errorf("abi: cannot unmarshal tuple into %v", t) + } + return nil +} + +// mapAbiToStringField maps abi to struct fields. +// first round: for each Exportable field that contains a `abi:""` tag +// and this field name exists in the arguments, pair them together. +// second round: for each argument field that has not been already linked, +// find what variable is expected to be mapped into, if it exists and has not been +// used, pair them. +func mapAbiToStructFields(args Arguments, value reflect.Value) (map[string]string, error) { + + typ := value.Type() + + abi2struct := make(map[string]string) + struct2abi := make(map[string]string) + + // first round ~~~ + for i := 0; i < typ.NumField(); i++ { + structFieldName := typ.Field(i).Name + + // skip private struct fields. + if structFieldName[:1] != strings.ToUpper(structFieldName[:1]) { + continue + } + + // skip fields that have no abi:"" tag. + var ok bool + var tagName string + if tagName, ok = typ.Field(i).Tag.Lookup("abi"); !ok { + continue + } + + // check if tag is empty. + if tagName == "" { + return nil, fmt.Errorf("struct: abi tag in '%s' is empty", structFieldName) + } + + // check which argument field matches with the abi tag. + found := false + for _, abiField := range args.NonIndexed() { + if abiField.Name == tagName { + if abi2struct[abiField.Name] != "" { + return nil, fmt.Errorf("struct: abi tag in '%s' already mapped", structFieldName) + } + // pair them + abi2struct[abiField.Name] = structFieldName + struct2abi[structFieldName] = abiField.Name + found = true + } + } + + // check if this tag has been mapped. + if !found { + return nil, fmt.Errorf("struct: abi tag '%s' defined but not found in abi", tagName) + } + + } + + // second round ~~~ + for _, arg := range args { + + abiFieldName := arg.Name + structFieldName := capitalise(abiFieldName) + + if structFieldName == "" { + return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct") + } + + // this abi has already been paired, skip it... unless there exists another, yet unassigned + // struct field with the same field name. If so, raise an error: + // abi: [ { "name": "value" } ] + // struct { Value *big.Int , Value1 *big.Int `abi:"value"`} + if abi2struct[abiFieldName] != "" { + if abi2struct[abiFieldName] != structFieldName && + struct2abi[structFieldName] == "" && + value.FieldByName(structFieldName).IsValid() { + return nil, fmt.Errorf("abi: multiple variables maps to the same abi field '%s'", abiFieldName) + } + continue + } + + // return an error if this struct field has already been paired. + if struct2abi[structFieldName] != "" { + return nil, fmt.Errorf("abi: multiple outputs mapping to the same struct field '%s'", structFieldName) + } + + if value.FieldByName(structFieldName).IsValid() { + // pair them + abi2struct[abiFieldName] = structFieldName + struct2abi[structFieldName] = abiFieldName + } else { + // not paired, but annotate as used, to detect cases like + // abi : [ { "name": "value" }, { "name": "_value" } ] + // struct { Value *big.Int } + struct2abi[structFieldName] = abiFieldName + } + + } + + return abi2struct, nil +} diff --git a/accounts/abi/type.go b/accounts/abi/type.go index fba10b96d2..9de36daffb 100644 --- a/accounts/abi/type.go +++ b/accounts/abi/type.go @@ -24,6 +24,7 @@ import ( "strings" ) +// Type enumerator const ( IntTy byte = iota UintTy @@ -100,69 +101,66 @@ func NewType(t string) (typ Type, err error) { return Type{}, fmt.Errorf("invalid formatting of array type") } return typ, err - } else { - // parse the type and size of the abi-type. - parsedType := typeRegex.FindAllStringSubmatch(t, -1)[0] - // varSize is the size of the variable - var varSize int - if len(parsedType[3]) > 0 { - var err error - varSize, err = strconv.Atoi(parsedType[2]) - if err != nil { - return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err) - } - } else { - if parsedType[0] == "uint" || parsedType[0] == "int" { - // this should fail because it means that there's something wrong with - // the abi type (the compiler should always format it to the size...always) - return Type{}, fmt.Errorf("unsupported arg type: %s", t) - } + } + // parse the type and size of the abi-type. + parsedType := typeRegex.FindAllStringSubmatch(t, -1)[0] + // varSize is the size of the variable + var varSize int + if len(parsedType[3]) > 0 { + var err error + varSize, err = strconv.Atoi(parsedType[2]) + if err != nil { + return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err) } - // varType is the parsed abi type - varType := parsedType[1] - - switch varType { - case "int": - typ.Kind, typ.Type = reflectIntKindAndType(false, varSize) - typ.Size = varSize - typ.T = IntTy - case "uint": - typ.Kind, typ.Type = reflectIntKindAndType(true, varSize) - typ.Size = varSize - typ.T = UintTy - case "bool": - typ.Kind = reflect.Bool - typ.T = BoolTy - typ.Type = reflect.TypeOf(bool(false)) - case "address": - typ.Kind = reflect.Array - typ.Type = address_t - typ.Size = 20 - typ.T = AddressTy - case "string": - typ.Kind = reflect.String - typ.Type = reflect.TypeOf("") - typ.T = StringTy - case "bytes": - if varSize == 0 { - typ.T = BytesTy - typ.Kind = reflect.Slice - typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0))) - } else { - typ.T = FixedBytesTy - typ.Kind = reflect.Array - typ.Size = varSize - typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0))) - } - case "function": - typ.Kind = reflect.Array - typ.T = FunctionTy - typ.Size = 24 - typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0))) - default: + } else { + if parsedType[0] == "uint" || parsedType[0] == "int" { + // this should fail because it means that there's something wrong with + // the abi type (the compiler should always format it to the size...always) return Type{}, fmt.Errorf("unsupported arg type: %s", t) } } + // varType is the parsed abi type + switch varType := parsedType[1]; varType { + case "int": + typ.Kind, typ.Type = reflectIntKindAndType(false, varSize) + typ.Size = varSize + typ.T = IntTy + case "uint": + typ.Kind, typ.Type = reflectIntKindAndType(true, varSize) + typ.Size = varSize + typ.T = UintTy + case "bool": + typ.Kind = reflect.Bool + typ.T = BoolTy + typ.Type = reflect.TypeOf(bool(false)) + case "address": + typ.Kind = reflect.Array + typ.Type = addressT + typ.Size = 20 + typ.T = AddressTy + case "string": + typ.Kind = reflect.String + typ.Type = reflect.TypeOf("") + typ.T = StringTy + case "bytes": + if varSize == 0 { + typ.T = BytesTy + typ.Kind = reflect.Slice + typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0))) + } else { + typ.T = FixedBytesTy + typ.Kind = reflect.Array + typ.Size = varSize + typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0))) + } + case "function": + typ.Kind = reflect.Array + typ.T = FunctionTy + typ.Size = 24 + typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0))) + default: + return Type{}, fmt.Errorf("unsupported arg type: %s", t) + } return } diff --git a/accounts/abi/type_test.go b/accounts/abi/type_test.go index e55af12939..f6b36f18fd 100644 --- a/accounts/abi/type_test.go +++ b/accounts/abi/type_test.go @@ -46,36 +46,36 @@ func TestTypeRegexp(t *testing.T) { {"bool[2][2][2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}, stringKind: "bool[2][2][2]"}}, {"bool[][][]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}, stringKind: "bool[][][]"}}, {"bool[][2][]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][2][]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}, stringKind: "bool[][2][]"}}, - {"int8", Type{Kind: reflect.Int8, Type: int8_t, Size: 8, T: IntTy, stringKind: "int8"}}, - {"int16", Type{Kind: reflect.Int16, Type: int16_t, Size: 16, T: IntTy, stringKind: "int16"}}, - {"int32", Type{Kind: reflect.Int32, Type: int32_t, Size: 32, T: IntTy, stringKind: "int32"}}, - {"int64", Type{Kind: reflect.Int64, Type: int64_t, Size: 64, T: IntTy, stringKind: "int64"}}, - {"int256", Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}}, - {"int8[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8_t, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}}, - {"int8[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8_t, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}}, - {"int16[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16_t, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}}, - {"int16[2]", Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16_t, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}}, - {"int32[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32_t, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}}, - {"int32[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32_t, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}}, - {"int64[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64_t, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}}, - {"int64[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64_t, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}}, - {"int256[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}}, - {"int256[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}}, - {"uint8", Type{Kind: reflect.Uint8, Type: uint8_t, Size: 8, T: UintTy, stringKind: "uint8"}}, - {"uint16", Type{Kind: reflect.Uint16, Type: uint16_t, Size: 16, T: UintTy, stringKind: "uint16"}}, - {"uint32", Type{Kind: reflect.Uint32, Type: uint32_t, Size: 32, T: UintTy, stringKind: "uint32"}}, - {"uint64", Type{Kind: reflect.Uint64, Type: uint64_t, Size: 64, T: UintTy, stringKind: "uint64"}}, - {"uint256", Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: UintTy, stringKind: "uint256"}}, - {"uint8[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8_t, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}}, - {"uint8[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8_t, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}}, - {"uint16[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16_t, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}}, - {"uint16[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16_t, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}}, - {"uint32[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32_t, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}}, - {"uint32[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32_t, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}}, - {"uint64[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64_t, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}}, - {"uint64[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64_t, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}}, - {"uint256[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}}, - {"uint256[2]", Type{Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]*big.Int{}), Size: 2, Elem: &Type{Kind: reflect.Ptr, Type: big_t, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}}, + {"int8", Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}}, + {"int16", Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}}, + {"int32", Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}}, + {"int64", Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}}, + {"int256", Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}}, + {"int8[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}}, + {"int8[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}}, + {"int16[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}}, + {"int16[2]", Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}}, + {"int32[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}}, + {"int32[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}}, + {"int64[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}}, + {"int64[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}}, + {"int256[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}}, + {"int256[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}}, + {"uint8", Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}}, + {"uint16", Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}}, + {"uint32", Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}}, + {"uint64", Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}}, + {"uint256", Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}}, + {"uint8[]", Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}}, + {"uint8[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}}, + {"uint16[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}}, + {"uint16[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}}, + {"uint32[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}}, + {"uint32[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}}, + {"uint64[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}}, + {"uint64[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}}, + {"uint256[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}}, + {"uint256[2]", Type{Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]*big.Int{}), Size: 2, Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}}, {"bytes32", Type{Kind: reflect.Array, T: FixedBytesTy, Size: 32, Type: reflect.TypeOf([32]byte{}), stringKind: "bytes32"}}, {"bytes[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]byte{}), Elem: &Type{Kind: reflect.Slice, Type: reflect.TypeOf([]byte{}), T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}}, {"bytes[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]byte{}), Elem: &Type{T: BytesTy, Type: reflect.TypeOf([]byte{}), Kind: reflect.Slice, stringKind: "bytes"}, stringKind: "bytes[2]"}}, @@ -84,9 +84,9 @@ func TestTypeRegexp(t *testing.T) { {"string", Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}}, {"string[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]string{}), Elem: &Type{Kind: reflect.String, Type: reflect.TypeOf(""), T: StringTy, stringKind: "string"}, stringKind: "string[]"}}, {"string[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]string{}), Elem: &Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}, stringKind: "string[2]"}}, - {"address", Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}}, - {"address[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}}, - {"address[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: address_t, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}}, + {"address", Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}}, + {"address[]", Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}}, + {"address[2]", Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}}, // TODO when fixed types are implemented properly // {"fixed", Type{}}, // {"fixed128x128", Type{}}, @@ -252,6 +252,9 @@ func TestTypeCheck(t *testing.T) { {"bytes20", common.Address{}, ""}, {"address", [20]byte{}, ""}, {"address", common.Address{}, ""}, + {"bytes32[]]", "", "invalid arg type in abi"}, + {"invalidType", "", "unsupported arg type: invalidType"}, + {"invalidSlice[]", "", "unsupported arg type: invalidSlice"}, } { typ, err := NewType(test.typ) if err != nil && len(test.err) == 0 { diff --git a/accounts/abi/unpack.go b/accounts/abi/unpack.go index 57732797b6..793d515adf 100644 --- a/accounts/abi/unpack.go +++ b/accounts/abi/unpack.go @@ -1,4 +1,4 @@ -// Copyright 2015 The go-ethereum Authors +// Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -25,15 +25,6 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// unpacker is a utility interface that enables us to have -// abstraction between events and methods and also to properly -// "unpack" them; e.g. events use Inputs, methods use Outputs. -type unpacker interface { - tupleUnpack(v interface{}, output []byte) error - singleUnpack(v interface{}, output []byte) error - isTupleReturn() bool -} - // reads the integer based on its kind func readInteger(kind reflect.Kind, b []byte) interface{} { switch kind { @@ -79,7 +70,7 @@ func readBool(word []byte) (bool, error) { // This enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes) func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) { if t.T != FunctionTy { - return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array.") + return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array") } if garbage := binary.BigEndian.Uint64(word[24:32]); garbage != 0 { err = fmt.Errorf("abi: got improperly encoded function type, got %v", word) @@ -92,7 +83,7 @@ func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) { // through reflection, creates a fixed array to be read from func readFixedBytes(t Type, word []byte) (interface{}, error) { if t.T != FixedBytesTy { - return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array.") + return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array") } // convert array := reflect.New(t.Type).Elem() @@ -102,15 +93,28 @@ func readFixedBytes(t Type, word []byte) (interface{}, error) { } +func getFullElemSize(elem *Type) int { + //all other should be counted as 32 (slices have pointers to respective elements) + size := 32 + //arrays wrap it, each element being the same size + for elem.T == ArrayTy { + size *= elem.Size + elem = elem.Elem + } + return size +} + // iteratively unpack elements func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) { + if size < 0 { + return nil, fmt.Errorf("cannot marshal input to array, size is negative (%d)", size) + } if start+32*size > len(output) { return nil, fmt.Errorf("abi: cannot marshal in to go array: offset %d would go over slice boundary (len=%d)", len(output), start+32*size) } // this value will become our slice or our array, depending on the type var refSlice reflect.Value - slice := output[start : start+size*32] if t.T == SliceTy { // declare our slice @@ -122,15 +126,20 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) return nil, fmt.Errorf("abi: invalid type in array/slice unpacking stage") } - for i, j := start, 0; j*32 < len(slice); i, j = i+32, j+1 { - // this corrects the arrangement so that we get all the underlying array values - if t.Elem.T == ArrayTy && j != 0 { - i = start + t.Elem.Size*32*j - } + // Arrays have packed elements, resulting in longer unpack steps. + // Slices have just 32 bytes per element (pointing to the contents). + elemSize := 32 + if t.T == ArrayTy { + elemSize = getFullElemSize(t.Elem) + } + + for i, j := start, 0; j < size; i, j = i+elemSize, j+1 { + inter, err := toGoType(i, *t.Elem, output) if err != nil { return nil, err } + // append the item to our reflect slice refSlice.Index(j).Set(reflect.ValueOf(inter)) } @@ -190,27 +199,32 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) { // interprets a 32 byte slice as an offset and then determines which indice to look to decode the type. func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) { - offset := int(binary.BigEndian.Uint64(output[index+24 : index+32])) - if offset+32 > len(output) { - return 0, 0, fmt.Errorf("abi: cannot marshal in to go slice: offset %d would go over slice boundary (len=%d)", len(output), offset+32) - } - length = int(binary.BigEndian.Uint64(output[offset+24 : offset+32])) - if offset+32+length > len(output) { - return 0, 0, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32+length) - } - start = offset + 32 + bigOffsetEnd := big.NewInt(0).SetBytes(output[index : index+32]) + bigOffsetEnd.Add(bigOffsetEnd, common.Big32) + outputLength := big.NewInt(int64(len(output))) - //fmt.Printf("LENGTH PREFIX INFO: \nsize: %v\noffset: %v\nstart: %v\n", length, offset, start) + if bigOffsetEnd.Cmp(outputLength) > 0 { + return 0, 0, fmt.Errorf("abi: cannot marshal in to go slice: offset %v would go over slice boundary (len=%v)", bigOffsetEnd, outputLength) + } + + if bigOffsetEnd.BitLen() > 63 { + return 0, 0, fmt.Errorf("abi offset larger than int64: %v", bigOffsetEnd) + } + + offsetEnd := int(bigOffsetEnd.Uint64()) + lengthBig := big.NewInt(0).SetBytes(output[offsetEnd-32 : offsetEnd]) + + totalSize := big.NewInt(0) + totalSize.Add(totalSize, bigOffsetEnd) + totalSize.Add(totalSize, lengthBig) + if totalSize.BitLen() > 63 { + return 0, 0, fmt.Errorf("abi length larger than int64: %v", totalSize) + } + + if totalSize.Cmp(outputLength) > 0 { + return 0, 0, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %v require %v", outputLength, totalSize) + } + start = int(bigOffsetEnd.Uint64()) + length = int(lengthBig.Uint64()) return } - -// checks for proper formatting of byte output -func bytesAreProper(output []byte) error { - if len(output) == 0 { - return fmt.Errorf("abi: unmarshalling empty output") - } else if len(output)%32 != 0 { - return fmt.Errorf("abi: improperly formatted output") - } else { - return nil - } -} diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go index 1e21aafc05..bdbab10b4f 100644 --- a/accounts/abi/unpack_test.go +++ b/accounts/abi/unpack_test.go @@ -1,4 +1,4 @@ -// Copyright 2015 The go-ethereum Authors +// Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify @@ -22,10 +22,12 @@ import ( "fmt" "math/big" "reflect" + "strconv" "strings" "testing" "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/require" ) type unpackTest struct { @@ -54,6 +56,23 @@ var unpackTests = []unpackTest{ enc: "0000000000000000000000000000000000000000000000000000000000000001", want: true, }, + { + def: `[{ "type": "bool" }]`, + enc: "0000000000000000000000000000000000000000000000000000000000000000", + want: false, + }, + { + def: `[{ "type": "bool" }]`, + enc: "0000000000000000000000000000000000000000000000000001000000000001", + want: false, + err: "abi: improperly encoded boolean value", + }, + { + def: `[{ "type": "bool" }]`, + enc: "0000000000000000000000000000000000000000000000000000000000000003", + want: false, + err: "abi: improperly encoded boolean value", + }, { def: `[{"type": "uint32"}]`, enc: "0000000000000000000000000000000000000000000000000000000000000001", @@ -128,7 +147,7 @@ var unpackTests = []unpackTest{ { def: `[{"type": "bytes32"}]`, enc: "0100000000000000000000000000000000000000000000000000000000000000", - want: common.HexToHash("0100000000000000000000000000000000000000000000000000000000000000"), + want: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, }, { def: `[{"type": "function"}]`, @@ -187,6 +206,11 @@ var unpackTests = []unpackTest{ enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", want: [2]uint32{1, 2}, }, + { + def: `[{"type": "uint32[2][3][4]"}]`, + enc: "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000170000000000000000000000000000000000000000000000000000000000000018", + want: [4][3][2]uint32{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}, {{13, 14}, {15, 16}, {17, 18}}, {{19, 20}, {21, 22}, {23, 24}}}, + }, { def: `[{"type": "uint64[]"}]`, enc: "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", @@ -257,82 +281,219 @@ var unpackTests = []unpackTest{ enc: "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", want: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}, }, + // struct outputs + { + def: `[{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{big.NewInt(1), big.NewInt(2)}, + }, + { + def: `[{"name":"int","type":"int256"},{"name":"Int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"int","type":"int256"},{"name":"_int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"Int","type":"int256"},{"name":"_int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"Int","type":"int256"},{"name":"_","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: purely underscored output cannot unpack to struct", + }, } func TestUnpack(t *testing.T) { for i, test := range unpackTests { - def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) - abi, err := JSON(strings.NewReader(def)) - if err != nil { - t.Fatalf("invalid ABI definition %s: %v", def, err) - } - encb, err := hex.DecodeString(test.enc) - if err != nil { - t.Fatalf("invalid hex: %s" + test.enc) - } - outptr := reflect.New(reflect.TypeOf(test.want)) - err = abi.Unpack(outptr.Interface(), "method", encb) - if err := test.checkError(err); err != nil { - t.Errorf("test %d (%v) failed: %v", i, test.def, err) - continue - } - out := outptr.Elem().Interface() - if !reflect.DeepEqual(test.want, out) { - t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out) - } + t.Run(strconv.Itoa(i), func(t *testing.T) { + def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) + abi, err := JSON(strings.NewReader(def)) + if err != nil { + t.Fatalf("invalid ABI definition %s: %v", def, err) + } + encb, err := hex.DecodeString(test.enc) + if err != nil { + t.Fatalf("invalid hex: %s" + test.enc) + } + outptr := reflect.New(reflect.TypeOf(test.want)) + err = abi.Unpack(outptr.Interface(), "method", encb) + if err := test.checkError(err); err != nil { + t.Errorf("test %d (%v) failed: %v", i, test.def, err) + return + } + out := outptr.Elem().Interface() + if !reflect.DeepEqual(test.want, out) { + t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out) + } + }) } } -func TestMultiReturnWithStruct(t *testing.T) { +type methodMultiOutput struct { + Int *big.Int + String string +} + +func methodMultiReturn(require *require.Assertions) (ABI, []byte, methodMultiOutput) { const definition = `[ { "name" : "multi", "constant" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` + var expected = methodMultiOutput{big.NewInt(1), "hello"} abi, err := JSON(strings.NewReader(definition)) - if err != nil { - t.Fatal(err) - } - + require.NoError(err) // using buff to make the code readable buff := new(bytes.Buffer) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005")) - stringOut := "hello" - buff.Write(common.RightPadBytes([]byte(stringOut), 32)) + buff.Write(common.RightPadBytes([]byte(expected.String), 32)) + return abi, buff.Bytes(), expected +} - var inter struct { - Int *big.Int - String string - } - err = abi.Unpack(&inter, "multi", buff.Bytes()) - if err != nil { - t.Error(err) - } - - if inter.Int == nil || inter.Int.Cmp(big.NewInt(1)) != 0 { - t.Error("expected Int to be 1 got", inter.Int) - } - - if inter.String != stringOut { - t.Error("expected String to be", stringOut, "got", inter.String) - } - - var reversed struct { +func TestMethodMultiReturn(t *testing.T) { + type reversed struct { String string Int *big.Int } - err = abi.Unpack(&reversed, "multi", buff.Bytes()) + abi, data, expected := methodMultiReturn(require.New(t)) + bigint := new(big.Int) + var testCases = []struct { + dest interface{} + expected interface{} + error string + name string + }{{ + &methodMultiOutput{}, + &expected, + "", + "Can unpack into structure", + }, { + &reversed{}, + &reversed{expected.String, expected.Int}, + "", + "Can unpack into reversed structure", + }, { + &[]interface{}{&bigint, new(string)}, + &[]interface{}{&expected.Int, &expected.String}, + "", + "Can unpack into a slice", + }, { + &[2]interface{}{&bigint, new(string)}, + &[2]interface{}{&expected.Int, &expected.String}, + "", + "Can unpack into an array", + }, { + &[]interface{}{new(int), new(int)}, + &[]interface{}{&expected.Int, &expected.String}, + "abi: cannot unmarshal *big.Int in to int", + "Can not unpack into a slice with wrong types", + }, { + &[]interface{}{new(int)}, + &[]interface{}{}, + "abi: insufficient number of elements in the list/array for unpack, want 2, got 1", + "Can not unpack into a slice with wrong types", + }} + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + require := require.New(t) + err := abi.Unpack(tc.dest, "multi", data) + if tc.error == "" { + require.Nil(err, "Should be able to unpack method outputs.") + require.Equal(tc.expected, tc.dest) + } else { + require.EqualError(err, tc.error) + } + }) + } +} + +func TestMultiReturnWithArray(t *testing.T) { + const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]` + abi, err := JSON(strings.NewReader(definition)) if err != nil { - t.Error(err) + t.Fatal(err) } + buff := new(bytes.Buffer) + buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000009")) + buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000008")) - if reversed.Int == nil || reversed.Int.Cmp(big.NewInt(1)) != 0 { - t.Error("expected Int to be 1 got", reversed.Int) + ret1, ret1Exp := new([3]uint64), [3]uint64{9, 9, 9} + ret2, ret2Exp := new(uint64), uint64(8) + if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil { + t.Fatal(err) } + if !reflect.DeepEqual(*ret1, ret1Exp) { + t.Error("array result", *ret1, "!= Expected", ret1Exp) + } + if *ret2 != ret2Exp { + t.Error("int result", *ret2, "!= Expected", ret2Exp) + } +} - if reversed.String != stringOut { - t.Error("expected String to be", stringOut, "got", reversed.String) +func TestMultiReturnWithDeeplyNestedArray(t *testing.T) { + // Similar to TestMultiReturnWithArray, but with a special case in mind: + // values of nested static arrays count towards the size as well, and any element following + // after such nested array argument should be read with the correct offset, + // so that it does not read content from the previous array argument. + const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3][2][4]"}, {"type": "uint64"}]}]` + abi, err := JSON(strings.NewReader(definition)) + if err != nil { + t.Fatal(err) + } + buff := new(bytes.Buffer) + // construct the test array, each 3 char element is joined with 61 '0' chars, + // to from the ((3 + 61) * 0.5) = 32 byte elements in the array. + buff.Write(common.Hex2Bytes(strings.Join([]string{ + "", //empty, to apply the 61-char separator to the first element as well. + "111", "112", "113", "121", "122", "123", + "211", "212", "213", "221", "222", "223", + "311", "312", "313", "321", "322", "323", + "411", "412", "413", "421", "422", "423", + }, "0000000000000000000000000000000000000000000000000000000000000"))) + buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000009876")) + + ret1, ret1Exp := new([4][2][3]uint64), [4][2][3]uint64{ + {{0x111, 0x112, 0x113}, {0x121, 0x122, 0x123}}, + {{0x211, 0x212, 0x213}, {0x221, 0x222, 0x223}}, + {{0x311, 0x312, 0x313}, {0x321, 0x322, 0x323}}, + {{0x411, 0x412, 0x413}, {0x421, 0x422, 0x423}}, + } + ret2, ret2Exp := new(uint64), uint64(0x9876) + if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(*ret1, ret1Exp) { + t.Error("array result", *ret1, "!= Expected", ret1Exp) + } + if *ret2 != ret2Exp { + t.Error("int result", *ret2, "!= Expected", ret2Exp) } } @@ -584,3 +745,73 @@ func TestUnmarshal(t *testing.T) { t.Fatal("expected error:", err) } } + +func TestOOMMaliciousInput(t *testing.T) { + oomTests := []unpackTest{ + { + def: `[{"type": "uint8[]"}]`, + enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset + "0000000000000000000000000000000000000000000000000000000000000003" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + { // Length larger than 64 bits + def: `[{"type": "uint8[]"}]`, + enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset + "00ffffffffffffffffffffffffffffffffffffffffffffff0000000000000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + { // Offset very large (over 64 bits) + def: `[{"type": "uint8[]"}]`, + enc: "00ffffffffffffffffffffffffffffffffffffffffffffff0000000000000020" + // offset + "0000000000000000000000000000000000000000000000000000000000000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + { // Offset very large (below 64 bits) + def: `[{"type": "uint8[]"}]`, + enc: "0000000000000000000000000000000000000000000000007ffffffffff00020" + // offset + "0000000000000000000000000000000000000000000000000000000000000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + { // Offset negative (as 64 bit) + def: `[{"type": "uint8[]"}]`, + enc: "000000000000000000000000000000000000000000000000f000000000000020" + // offset + "0000000000000000000000000000000000000000000000000000000000000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + + { // Negative length + def: `[{"type": "uint8[]"}]`, + enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset + "000000000000000000000000000000000000000000000000f000000000000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + { // Very large length + def: `[{"type": "uint8[]"}]`, + enc: "0000000000000000000000000000000000000000000000000000000000000020" + // offset + "0000000000000000000000000000000000000000000000007fffffffff000002" + // num elems + "0000000000000000000000000000000000000000000000000000000000000001" + // elem 1 + "0000000000000000000000000000000000000000000000000000000000000002", // elem 2 + }, + } + for i, test := range oomTests { + def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) + abi, err := JSON(strings.NewReader(def)) + if err != nil { + t.Fatalf("invalid ABI definition %s: %v", def, err) + } + encb, err := hex.DecodeString(test.enc) + if err != nil { + t.Fatalf("invalid hex: %s" + test.enc) + } + _, err = abi.Methods["method"].Outputs.UnpackValues(encb) + if err == nil { + t.Fatalf("Expected error on malicious input, test %d", i) + } + } +} diff --git a/accounts/errors.go b/accounts/errors.go index 64da8821c8..40b21ed179 100644 --- a/accounts/errors.go +++ b/accounts/errors.go @@ -62,7 +62,7 @@ func NewAuthNeededError(needed string) error { } } -// Error implements the standard error interfacel. +// Error implements the standard error interface. func (err *AuthNeededError) Error() string { return fmt.Sprintf("authentication needed: %s", err.Needed) } diff --git a/accounts/keystore/keystore.go b/accounts/keystore/keystore.go index 80ccd37419..6b04acd05f 100644 --- a/accounts/keystore/keystore.go +++ b/accounts/keystore/keystore.go @@ -50,7 +50,7 @@ var ( var KeyStoreType = reflect.TypeOf(&KeyStore{}) // KeyStoreScheme is the protocol scheme prefixing account and wallet URLs. -var KeyStoreScheme = "keystore" +const KeyStoreScheme = "keystore" // Maximum time between wallet refreshes (if filesystem notifications don't work). const walletRefreshCycle = 3 * time.Second diff --git a/accounts/keystore/keystore_passphrase.go b/accounts/keystore/keystore_passphrase.go index eaec39f7df..da632fe345 100644 --- a/accounts/keystore/keystore_passphrase.go +++ b/accounts/keystore/keystore_passphrase.go @@ -108,9 +108,8 @@ func (ks keyStorePassphrase) StoreKey(filename string, key *Key, auth string) er func (ks keyStorePassphrase) JoinPath(filename string) string { if filepath.IsAbs(filename) { return filename - } else { - return filepath.Join(ks.keysDirPath, filename) } + return filepath.Join(ks.keysDirPath, filename) } // EncryptKey encrypts a key using the specified scrypt parameters into a json diff --git a/accounts/keystore/keystore_plain.go b/accounts/keystore/keystore_plain.go index b490ca72b8..f62a133ce1 100644 --- a/accounts/keystore/keystore_plain.go +++ b/accounts/keystore/keystore_plain.go @@ -56,7 +56,6 @@ func (ks keyStorePlain) StoreKey(filename string, key *Key, auth string) error { func (ks keyStorePlain) JoinPath(filename string) string { if filepath.IsAbs(filename) { return filename - } else { - return filepath.Join(ks.keysDirPath, filename) } + return filepath.Join(ks.keysDirPath, filename) } diff --git a/accounts/url.go b/accounts/url.go index 47f9d8ee4b..21df668efd 100644 --- a/accounts/url.go +++ b/accounts/url.go @@ -74,6 +74,22 @@ func (u URL) MarshalJSON() ([]byte, error) { return json.Marshal(u.String()) } +// UnmarshalJSON parses url. +func (u *URL) UnmarshalJSON(input []byte) error { + var textUrl string + err := json.Unmarshal(input, &textUrl) + if err != nil { + return err + } + url, err := parseURL(textUrl) + if err != nil { + return err + } + u.Scheme = url.Scheme + u.Path = url.Path + return nil +} + // Cmp compares x and y and returns: // // -1 if x < y diff --git a/accounts/usbwallet/hub.go b/accounts/usbwallet/hub.go index 61fc98ccc8..640320bc91 100644 --- a/accounts/usbwallet/hub.go +++ b/accounts/usbwallet/hub.go @@ -127,7 +127,7 @@ func (hub *Hub) refreshWallets() { // breaking the Ledger protocol if that is waiting for user confirmation. This // is a bug acknowledged at Ledger, but it won't be fixed on old devices so we // need to prevent concurrent comms ourselves. The more elegant solution would - // be to ditch enumeration in favor of hutplug events, but that don't work yet + // be to ditch enumeration in favor of hotplug events, but that don't work yet // on Windows so if we need to hack it anyway, this is more elegant for now. hub.commsLock.Lock() if hub.commsPend > 0 { // A confirmation is pending, don't refresh diff --git a/accounts/usbwallet/internal/trezor/messages.proto b/accounts/usbwallet/internal/trezor/messages.proto index 178956457e..8cb9c8cc25 100644 --- a/accounts/usbwallet/internal/trezor/messages.proto +++ b/accounts/usbwallet/internal/trezor/messages.proto @@ -2,6 +2,8 @@ // https://github.com/trezor/trezor-common/blob/master/protob/messages.proto // dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b. +syntax = "proto2"; + /** * Messages for TREZOR communication */ diff --git a/accounts/usbwallet/internal/trezor/trezor.go b/accounts/usbwallet/internal/trezor/trezor.go index 487aeb5f81..80cc75efc4 100644 --- a/accounts/usbwallet/internal/trezor/trezor.go +++ b/accounts/usbwallet/internal/trezor/trezor.go @@ -18,7 +18,7 @@ // wallets. The wire protocol spec can be found on the SatoshiLabs website: // https://doc.satoshilabs.com/trezor-tech/api-protobuf.html -//go:generate protoc --go_out=Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor,import_path=trezor:. types.proto messages.proto +//go:generate protoc --go_out=import_path=trezor:. types.proto messages.proto // Package trezor contains the wire protocol wrapper in Go. package trezor @@ -36,7 +36,7 @@ func Type(msg proto.Message) uint16 { } // Name returns the friendly message type name of a specific protocol buffer -// type numbers. +// type number. func Name(kind uint16) string { name := MessageType_name[int32(kind)] if len(name) < 12 { diff --git a/accounts/usbwallet/internal/trezor/types.proto b/accounts/usbwallet/internal/trezor/types.proto index 3a358a584d..acbe79e3ff 100644 --- a/accounts/usbwallet/internal/trezor/types.proto +++ b/accounts/usbwallet/internal/trezor/types.proto @@ -2,6 +2,8 @@ // https://github.com/trezor/trezor-common/blob/master/protob/types.proto // dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b. +syntax = "proto2"; + /** * Types for TREZOR communication * diff --git a/accounts/usbwallet/ledger.go b/accounts/usbwallet/ledger.go index f5def61d23..2583fbc4da 100644 --- a/accounts/usbwallet/ledger.go +++ b/accounts/usbwallet/ledger.go @@ -53,11 +53,9 @@ const ( ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration ledgerP1DirectlyFetchAddress ledgerParam1 = 0x00 // Return address directly from the wallet - ledgerP1ConfirmFetchAddress ledgerParam1 = 0x01 // Require a user confirmation before returning the address ledgerP1InitTransactionData ledgerParam1 = 0x00 // First transaction data block for signing ledgerP1ContTransactionData ledgerParam1 = 0x80 // Subsequent transaction data block for signing ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address - ledgerP2ReturnAddressChainCode ledgerParam2 = 0x01 // Require a user confirmation before returning the address ) // errLedgerReplyInvalidHeader is the error message returned by a Ledger data exchange @@ -304,7 +302,7 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction for i, component := range derivationPath { binary.BigEndian.PutUint32(path[1+4*i:], component) } - // Create the transaction RLP based on whether legacy or EIP155 signing was requeste + // Create the transaction RLP based on whether legacy or EIP155 signing was requested var ( txrlp []byte err error diff --git a/accounts/usbwallet/trezor.go b/accounts/usbwallet/trezor.go index 159cb2ea97..b84a955992 100644 --- a/accounts/usbwallet/trezor.go +++ b/accounts/usbwallet/trezor.go @@ -180,7 +180,7 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction AddressN: derivationPath, Nonce: new(big.Int).SetUint64(tx.Nonce()).Bytes(), GasPrice: tx.GasPrice().Bytes(), - GasLimit: tx.Gas().Bytes(), + GasLimit: new(big.Int).SetUint64(tx.Gas()).Bytes(), Value: tx.Value().Bytes(), DataLength: &length, } diff --git a/accounts/usbwallet/wallet.go b/accounts/usbwallet/wallet.go index 8b3b5a5224..6cef6e0fb0 100644 --- a/accounts/usbwallet/wallet.go +++ b/accounts/usbwallet/wallet.go @@ -99,7 +99,7 @@ type wallet struct { // // As such, a hardware wallet needs two locks to function correctly. A state // lock can be used to protect the wallet's software-side internal state, which - // must not be held exlusively during hardware communication. A communication + // must not be held exclusively during hardware communication. A communication // lock can be used to achieve exclusive access to the device itself, this one // however should allow "skipping" waiting for operations that might want to // use the device, but can live without too (e.g. account self-derivation). diff --git a/appveyor.yml b/appveyor.yml index 78b11fa9d6..05ff92cf36 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -23,8 +23,8 @@ environment: install: - git submodule update --init - rmdir C:\go /s /q - - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.windows-%GETH_ARCH%.zip - - 7z x go1.9.windows-%GETH_ARCH%.zip -y -oC:\ > NUL + - appveyor DownloadFile https://storage.googleapis.com/golang/go1.10.3.windows-%GETH_ARCH%.zip + - 7z x go1.10.3.windows-%GETH_ARCH%.zip -y -oC:\ > NUL - go version - gcc --version diff --git a/bmt/bmt.go b/bmt/bmt.go index 4b65b1d94a..c290223452 100644 --- a/bmt/bmt.go +++ b/bmt/bmt.go @@ -75,7 +75,7 @@ type Hasher struct { blocksize int // segment size (size of hash) also for hash.Hash count int // segment count size int // for hash.Hash same as hashsize - cur int // cursor position for righmost currently open chunk + cur int // cursor position for rightmost currently open chunk segment []byte // the rightmost open segment (not complete) depth int // index of last level result chan []byte // result channel @@ -149,30 +149,30 @@ func NewTreePool(hasher BaseHasher, segmentCount, capacity int) *TreePool { } } -// Drain drains the pool uptil it has no more than n resources -func (self *TreePool) Drain(n int) { - self.lock.Lock() - defer self.lock.Unlock() - for len(self.c) > n { - <-self.c - self.count-- +// Drain drains the pool until it has no more than n resources +func (p *TreePool) Drain(n int) { + p.lock.Lock() + defer p.lock.Unlock() + for len(p.c) > n { + <-p.c + p.count-- } } // Reserve is blocking until it returns an available Tree // it reuses free Trees or creates a new one if size is not reached -func (self *TreePool) Reserve() *Tree { - self.lock.Lock() - defer self.lock.Unlock() +func (p *TreePool) Reserve() *Tree { + p.lock.Lock() + defer p.lock.Unlock() var t *Tree - if self.count == self.Capacity { - return <-self.c + if p.count == p.Capacity { + return <-p.c } select { - case t = <-self.c: + case t = <-p.c: default: - t = NewTree(self.hasher, self.SegmentSize, self.SegmentCount) - self.count++ + t = NewTree(p.hasher, p.SegmentSize, p.SegmentCount) + p.count++ } return t } @@ -180,8 +180,8 @@ func (self *TreePool) Reserve() *Tree { // Release gives back a Tree to the pool. // This Tree is guaranteed to be in reusable state // does not need locking -func (self *TreePool) Release(t *Tree) { - self.c <- t // can never fail but... +func (p *TreePool) Release(t *Tree) { + p.c <- t // can never fail but... } // Tree is a reusable control structure representing a BMT @@ -193,17 +193,17 @@ type Tree struct { } // Draw draws the BMT (badly) -func (self *Tree) Draw(hash []byte, d int) string { +func (t *Tree) Draw(hash []byte, d int) string { var left, right []string var anc []*Node - for i, n := range self.leaves { + for i, n := range t.leaves { left = append(left, fmt.Sprintf("%v", hashstr(n.left))) if i%2 == 0 { anc = append(anc, n.parent) } right = append(right, fmt.Sprintf("%v", hashstr(n.right))) } - anc = self.leaves + anc = t.leaves var hashes [][]string for l := 0; len(anc) > 0; l++ { var nodes []*Node @@ -277,42 +277,42 @@ func NewTree(hasher BaseHasher, segmentSize, segmentCount int) *Tree { // methods needed by hash.Hash // Size returns the size -func (self *Hasher) Size() int { - return self.size +func (h *Hasher) Size() int { + return h.size } // BlockSize returns the block size -func (self *Hasher) BlockSize() int { - return self.blocksize +func (h *Hasher) BlockSize() int { + return h.blocksize } // Sum returns the hash of the buffer // hash.Hash interface Sum method appends the byte slice to the underlying // data before it calculates and returns the hash of the chunk -func (self *Hasher) Sum(b []byte) (r []byte) { - t := self.bmt - i := self.cur +func (h *Hasher) Sum(b []byte) (r []byte) { + t := h.bmt + i := h.cur n := t.leaves[i] j := i // must run strictly before all nodes calculate // datanodes are guaranteed to have a parent - if len(self.segment) > self.size && i > 0 && n.parent != nil { + if len(h.segment) > h.size && i > 0 && n.parent != nil { n = n.parent } else { i *= 2 } - d := self.finalise(n, i) - self.writeSegment(j, self.segment, d) - c := <-self.result - self.releaseTree() + d := h.finalise(n, i) + h.writeSegment(j, h.segment, d) + c := <-h.result + h.releaseTree() // sha3(length + BMT(pure_chunk)) - if self.blockLength == nil { + if h.blockLength == nil { return c } - res := self.pool.hasher() + res := h.pool.hasher() res.Reset() - res.Write(self.blockLength) + res.Write(h.blockLength) res.Write(c) return res.Sum(nil) } @@ -321,8 +321,8 @@ func (self *Hasher) Sum(b []byte) (r []byte) { // Hash waits for the hasher result and returns it // caller must call this on a BMT Hasher being written to -func (self *Hasher) Hash() []byte { - return <-self.result +func (h *Hasher) Hash() []byte { + return <-h.result } // Hasher implements the io.Writer interface @@ -330,16 +330,16 @@ func (self *Hasher) Hash() []byte { // Write fills the buffer to hash // with every full segment complete launches a hasher go routine // that shoots up the BMT -func (self *Hasher) Write(b []byte) (int, error) { +func (h *Hasher) Write(b []byte) (int, error) { l := len(b) if l <= 0 { return 0, nil } - s := self.segment - i := self.cur - count := (self.count + 1) / 2 - need := self.count*self.size - self.cur*2*self.size - size := self.size + s := h.segment + i := h.cur + count := (h.count + 1) / 2 + need := h.count*h.size - h.cur*2*h.size + size := h.size if need > size { size *= 2 } @@ -356,7 +356,7 @@ func (self *Hasher) Write(b []byte) (int, error) { // read full segments and the last possibly partial segment for need > 0 && i < count-1 { // push all finished chunks we read - self.writeSegment(i, s, self.depth) + h.writeSegment(i, s, h.depth) need -= size if need < 0 { size += need @@ -365,8 +365,8 @@ func (self *Hasher) Write(b []byte) (int, error) { rest += size i++ } - self.segment = s - self.cur = i + h.segment = s + h.cur = i // otherwise, we can assume len(s) == 0, so all buffer is read and chunk is not yet full return l, nil } @@ -376,8 +376,8 @@ func (self *Hasher) Write(b []byte) (int, error) { // ReadFrom reads from io.Reader and appends to the data to hash using Write // it reads so that chunk to hash is maximum length or reader reaches EOF // caller must Reset the hasher prior to call -func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { - bufsize := self.size*self.count - self.size*self.cur - len(self.segment) +func (h *Hasher) ReadFrom(r io.Reader) (m int64, err error) { + bufsize := h.size*h.count - h.size*h.cur - len(h.segment) buf := make([]byte, bufsize) var read int for { @@ -385,7 +385,7 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { n, err = r.Read(buf) read += n if err == io.EOF || read == len(buf) { - hash := self.Sum(buf[:n]) + hash := h.Sum(buf[:n]) if read == len(buf) { err = NewEOC(hash) } @@ -394,7 +394,7 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { if err != nil { break } - n, err = self.Write(buf[:n]) + n, err = h.Write(buf[:n]) if err != nil { break } @@ -403,63 +403,62 @@ func (self *Hasher) ReadFrom(r io.Reader) (m int64, err error) { } // Reset needs to be called before writing to the hasher -func (self *Hasher) Reset() { - self.getTree() - self.blockLength = nil +func (h *Hasher) Reset() { + h.getTree() + h.blockLength = nil } // Hasher implements the SwarmHash interface // ResetWithLength needs to be called before writing to the hasher // the argument is supposed to be the byte slice binary representation of -// the legth of the data subsumed under the hash -func (self *Hasher) ResetWithLength(l []byte) { - self.Reset() - self.blockLength = l - +// the length of the data subsumed under the hash +func (h *Hasher) ResetWithLength(l []byte) { + h.Reset() + h.blockLength = l } // Release gives back the Tree to the pool whereby it unlocks // it resets tree, segment and index -func (self *Hasher) releaseTree() { - if self.bmt != nil { - n := self.bmt.leaves[self.cur] +func (h *Hasher) releaseTree() { + if h.bmt != nil { + n := h.bmt.leaves[h.cur] for ; n != nil; n = n.parent { n.unbalanced = false if n.parent != nil { n.root = false } } - self.pool.Release(self.bmt) - self.bmt = nil + h.pool.Release(h.bmt) + h.bmt = nil } - self.cur = 0 - self.segment = nil + h.cur = 0 + h.segment = nil } -func (self *Hasher) writeSegment(i int, s []byte, d int) { - h := self.pool.hasher() - n := self.bmt.leaves[i] +func (h *Hasher) writeSegment(i int, s []byte, d int) { + hash := h.pool.hasher() + n := h.bmt.leaves[i] - if len(s) > self.size && n.parent != nil { + if len(s) > h.size && n.parent != nil { go func() { - h.Reset() - h.Write(s) - s = h.Sum(nil) + hash.Reset() + hash.Write(s) + s = hash.Sum(nil) if n.root { - self.result <- s + h.result <- s return } - self.run(n.parent, h, d, n.index, s) + h.run(n.parent, hash, d, n.index, s) }() return } - go self.run(n, h, d, i*2, s) + go h.run(n, hash, d, i*2, s) } -func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { +func (h *Hasher) run(n *Node, hash hash.Hash, d int, i int, s []byte) { isLeft := i%2 == 0 for { if isLeft { @@ -471,18 +470,18 @@ func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { return } if !n.unbalanced || !isLeft || i == 0 && d == 0 { - h.Reset() - h.Write(n.left) - h.Write(n.right) - s = h.Sum(nil) + hash.Reset() + hash.Write(n.left) + hash.Write(n.right) + s = hash.Sum(nil) } else { s = append(n.left, n.right...) } - self.hash = s + h.hash = s if n.root { - self.result <- s + h.result <- s return } @@ -493,20 +492,20 @@ func (self *Hasher) run(n *Node, h hash.Hash, d int, i int, s []byte) { } // getTree obtains a BMT resource by reserving one from the pool -func (self *Hasher) getTree() *Tree { - if self.bmt != nil { - return self.bmt +func (h *Hasher) getTree() *Tree { + if h.bmt != nil { + return h.bmt } - t := self.pool.Reserve() - self.bmt = t + t := h.pool.Reserve() + h.bmt = t return t } // atomic bool toggle implementing a concurrent reusable 2-state object // atomic addint with %2 implements atomic bool toggle // it returns true if the toggler just put it in the active/waiting state -func (self *Node) toggle() bool { - return atomic.AddInt32(&self.state, 1)%2 == 1 +func (n *Node) toggle() bool { + return atomic.AddInt32(&n.state, 1)%2 == 1 } func hashstr(b []byte) string { @@ -526,12 +525,12 @@ func depth(n int) (d int) { // finalise is following the zigzags on the tree belonging // to the final datasegment -func (self *Hasher) finalise(n *Node, i int) (d int) { +func (h *Hasher) finalise(n *Node, i int) (d int) { isLeft := i%2 == 0 for { // when the final segment's path is going via left segments // the incoming data is pushed to the parent upon pulling the left - // we do not need toogle the state since this condition is + // we do not need toggle the state since this condition is // detectable n.unbalanced = isLeft n.right = nil @@ -551,8 +550,8 @@ type EOC struct { } // Error returns the error string -func (self *EOC) Error() string { - return fmt.Sprintf("hasher limit reached, chunk hash: %x", self.Hash) +func (e *EOC) Error() string { + return fmt.Sprintf("hasher limit reached, chunk hash: %x", e.Hash) } // NewEOC creates new end of chunk error with the hash diff --git a/bmt/bmt_r.go b/bmt/bmt_r.go index 649093ee3a..3cb337ab94 100644 --- a/bmt/bmt_r.go +++ b/bmt/bmt_r.go @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -// simple nonconcurrent reference implementation for hashsize segment based +// Package bmt is a simple nonconcurrent reference implementation for hashsize segment based // Binary Merkle tree hash on arbitrary but fixed maximum chunksize // // This implementation does not take advantage of any paralellisms and uses diff --git a/build/ci-notes.md b/build/ci-notes.md index 78e9575c01..f5b0e869d6 100644 --- a/build/ci-notes.md +++ b/build/ci-notes.md @@ -2,12 +2,7 @@ Tagged releases and develop branch commits are available as installable Debian packages for Ubuntu. Packages are built for the all Ubuntu versions which are supported by -Canonical: - -- Trusty Tahr (14.04 LTS) -- Xenial Xerus (16.04 LTS) -- Yakkety Yak (16.10) -- Zesty Zapus (17.04) +Canonical. Packages of develop branch commits have suffix -unstable and cannot be installed alongside the stable version. Switching between release streams requires user intervention. @@ -21,18 +16,18 @@ variable which Travis CI makes available to certain builds. We want to build go-ethereum with the most recent version of Go, irrespective of the Go version that is available in the main Ubuntu repository. In order to make this possible, our PPA depends on the ~gophers/ubuntu/archive PPA. Our source package build-depends on -golang-1.9, which is co-installable alongside the regular golang package. PPA dependencies +golang-1.10, which is co-installable alongside the regular golang package. PPA dependencies can be edited at https://launchpad.net/%7Eethereum/+archive/ubuntu/ethereum/+edit-dependencies ## Building Packages Locally (for testing) You need to run Ubuntu to do test packaging. -Add the gophers PPA and install Go 1.9 and Debian packaging tools: +Add the gophers PPA and install Go 1.10 and Debian packaging tools: $ sudo apt-add-repository ppa:gophers/ubuntu/archive $ sudo apt-get update - $ sudo apt-get install build-essential golang-1.9 devscripts debhelper + $ sudo apt-get install build-essential golang-1.10 devscripts debhelper Create the source packages: diff --git a/build/ci.go b/build/ci.go index 987f0bb18a..5939d91e96 100644 --- a/build/ci.go +++ b/build/ci.go @@ -23,7 +23,7 @@ Usage: go run build/ci.go Available commands are: - install [ -arch architecture ] [ packages... ] -- builds packages and executables + install [ -arch architecture ] [ -cc compiler ] [ packages... ] -- builds packages and executables test [ -coverage ] [ packages... ] -- runs the tests lint -- runs certain pre-selected linters archive [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -upload dest ] -- archives build artefacts @@ -121,7 +121,8 @@ var ( // Note: vivid is unsupported because there is no golang-1.6 package for it. // Note: wily is unsupported because it was officially deprecated on lanchpad. // Note: yakkety is unsupported because it was officially deprecated on lanchpad. - debDistros = []string{"trusty", "xenial", "zesty", "artful"} + // Note: zesty is unsupported because it was officially deprecated on lanchpad. + debDistros = []string{"trusty", "xenial", "artful", "bionic"} ) var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin")) @@ -173,17 +174,24 @@ func main() { func doInstall(cmdline []string) { var ( arch = flag.String("arch", "", "Architecture to cross build for") + cc = flag.String("cc", "", "C compiler to cross build with") ) flag.CommandLine.Parse(cmdline) env := build.Env() // Check Go version. People regularly open issues about compilation // failure with outdated Go. This should save them the trouble. - if runtime.Version() < "go1.7" && !strings.Contains(runtime.Version(), "devel") { - log.Println("You have Go version", runtime.Version()) - log.Println("go-ethereum requires at least Go version 1.7 and cannot") - log.Println("be compiled with an earlier version. Please upgrade your Go installation.") - os.Exit(1) + if !strings.Contains(runtime.Version(), "devel") { + // Figure out the minor version number since we can't textually compare (1.10 < 1.9) + var minor int + fmt.Sscanf(strings.TrimPrefix(runtime.Version(), "go1."), "%d", &minor) + + if minor < 9 { + log.Println("You have Go version", runtime.Version()) + log.Println("go-ethereum requires at least Go version 1.9 and cannot") + log.Println("be compiled with an earlier version. Please upgrade your Go installation.") + os.Exit(1) + } } // Compile packages given as arguments, or everything if there are no arguments. packages := []string{"./..."} @@ -207,7 +215,7 @@ func doInstall(cmdline []string) { } } // Seems we are cross compiling, work around forbidden GOBIN - goinstall := goToolArch(*arch, "install", buildFlags(env)...) + goinstall := goToolArch(*arch, *cc, "install", buildFlags(env)...) goinstall.Args = append(goinstall.Args, "-v") goinstall.Args = append(goinstall.Args, []string{"-buildmode", "archive"}...) goinstall.Args = append(goinstall.Args, packages...) @@ -221,7 +229,7 @@ func doInstall(cmdline []string) { } for name := range pkgs { if name == "main" { - gobuild := goToolArch(*arch, "build", buildFlags(env)...) + gobuild := goToolArch(*arch, *cc, "build", buildFlags(env)...) gobuild.Args = append(gobuild.Args, "-v") gobuild.Args = append(gobuild.Args, []string{"-o", executablePath(cmd.Name())}...) gobuild.Args = append(gobuild.Args, "."+string(filepath.Separator)+filepath.Join("cmd", cmd.Name())) @@ -249,18 +257,11 @@ func buildFlags(env build.Environment) (flags []string) { } func goTool(subcmd string, args ...string) *exec.Cmd { - return goToolArch(runtime.GOARCH, subcmd, args...) + return goToolArch(runtime.GOARCH, os.Getenv("CC"), subcmd, args...) } -func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd { +func goToolArch(arch string, cc string, subcmd string, args ...string) *exec.Cmd { cmd := build.GoTool(subcmd, args...) - if subcmd == "build" || subcmd == "install" || subcmd == "test" { - // Go CGO has a Windows linker error prior to 1.8 (https://github.com/golang/go/issues/8756). - // Work around issue by allowing multiple definitions for <1.8 builds. - if runtime.GOOS == "windows" && runtime.Version() < "go1.8" { - cmd.Args = append(cmd.Args, []string{"-ldflags", "-extldflags -Wl,--allow-multiple-definition"}...) - } - } cmd.Env = []string{"GOPATH=" + build.GOPATH()} if arch == "" || arch == runtime.GOARCH { cmd.Env = append(cmd.Env, "GOBIN="+GOBIN) @@ -268,6 +269,9 @@ func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd { cmd.Env = append(cmd.Env, "CGO_ENABLED=1") cmd.Env = append(cmd.Env, "GOARCH="+arch) } + if cc != "" { + cmd.Env = append(cmd.Env, "CC="+cc) + } for _, e := range os.Environ() { if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") { continue @@ -325,7 +329,11 @@ func doLint(cmdline []string) { // Run fast linters batched together configs := []string{ "--vendor", + "--tests", + "--deadline=2m", "--disable-all", + "--enable=goimports", + "--enable=varcheck", "--enable=vet", "--enable=gofmt", "--enable=misspell", @@ -336,7 +344,7 @@ func doLint(cmdline []string) { // Run slow linters one by one for _, linter := range []string{"unconvert", "gosimple"} { - configs = []string{"--vendor", "--deadline=10m", "--disable-all", "--enable=" + linter} + configs = []string{"--vendor", "--tests", "--deadline=10m", "--disable-all", "--enable=" + linter} build.MustRunCommand(filepath.Join(GOBIN, "gometalinter.v2"), append(configs, packages...)...) } } @@ -722,9 +730,9 @@ func doAndroidArchive(cmdline []string) { log.Fatal("Please ensure ANDROID_NDK points to your Android NDK") } // Build the Android archive and Maven resources - build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile")) + build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile", "golang.org/x/mobile/cmd/gobind")) build.MustRun(gomobileTool("init", "--ndk", os.Getenv("ANDROID_NDK"))) - build.MustRun(gomobileTool("bind", "--target", "android", "--javapkg", "org.ethereum", "-v", "github.com/ethereum/go-ethereum/mobile")) + build.MustRun(gomobileTool("bind", "-ldflags", "-s -w", "--target", "android", "--javapkg", "org.ethereum", "-v", "github.com/ethereum/go-ethereum/mobile")) if *local { // If we're building locally, copy bundle to build dir and skip Maven @@ -748,22 +756,27 @@ func doAndroidArchive(cmdline []string) { os.Rename(archive, meta.Package+".aar") if *signer != "" && *deploy != "" { // Import the signing key into the local GPG instance - if b64key := os.Getenv(*signer); b64key != "" { - key, err := base64.StdEncoding.DecodeString(b64key) - if err != nil { - log.Fatalf("invalid base64 %s", *signer) - } - gpg := exec.Command("gpg", "--import") - gpg.Stdin = bytes.NewReader(key) - build.MustRun(gpg) + b64key := os.Getenv(*signer) + key, err := base64.StdEncoding.DecodeString(b64key) + if err != nil { + log.Fatalf("invalid base64 %s", *signer) + } + gpg := exec.Command("gpg", "--import") + gpg.Stdin = bytes.NewReader(key) + build.MustRun(gpg) + + keyID, err := build.PGPKeyID(string(key)) + if err != nil { + log.Fatal(err) } // Upload the artifacts to Sonatype and/or Maven Central repo := *deploy + "/service/local/staging/deploy/maven2" if meta.Develop { repo = *deploy + "/content/repositories/snapshots" } - build.MustRunCommand("mvn", "gpg:sign-and-deploy-file", + build.MustRunCommand("mvn", "gpg:sign-and-deploy-file", "-e", "-X", "-settings=build/mvn.settings", "-Durl="+repo, "-DrepositoryId=ossrh", + "-Dgpg.keyname="+keyID, "-DpomFile="+meta.Package+".pom", "-Dfile="+meta.Package+".aar") } } @@ -773,9 +786,10 @@ func gomobileTool(subcmd string, args ...string) *exec.Cmd { cmd.Args = append(cmd.Args, args...) cmd.Env = []string{ "GOPATH=" + build.GOPATH(), + "PATH=" + GOBIN + string(os.PathListSeparator) + os.Getenv("PATH"), } for _, e := range os.Environ() { - if strings.HasPrefix(e, "GOPATH=") { + if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "PATH=") { continue } cmd.Env = append(cmd.Env, e) @@ -842,9 +856,9 @@ func doXCodeFramework(cmdline []string) { env := build.Env() // Build the iOS XCode framework - build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile")) + build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile", "golang.org/x/mobile/cmd/gobind")) build.MustRun(gomobileTool("init")) - bind := gomobileTool("bind", "--target", "ios", "--tags", "ios", "-v", "github.com/ethereum/go-ethereum/mobile") + bind := gomobileTool("bind", "-ldflags", "-s -w", "--target", "ios", "--tags", "ios", "-v", "github.com/ethereum/go-ethereum/mobile") if *local { // If we're building locally, use the build folder and stop afterwards diff --git a/build/deb.control b/build/deb.control index 5c9ce6705c..33c1a779f4 100644 --- a/build/deb.control +++ b/build/deb.control @@ -2,7 +2,7 @@ Source: {{.Name}} Section: science Priority: extra Maintainer: {{.Author}} -Build-Depends: debhelper (>= 8.0.0), golang-1.9 +Build-Depends: debhelper (>= 8.0.0), golang-1.10 Standards-Version: 3.9.5 Homepage: https://ethereum.org Vcs-Git: git://github.com/ethereum/go-ethereum.git diff --git a/build/deb.rules b/build/deb.rules index 7a78525139..7f286569ea 100644 --- a/build/deb.rules +++ b/build/deb.rules @@ -5,7 +5,7 @@ #export DH_VERBOSE=1 override_dh_auto_build: - build/env.sh /usr/lib/go-1.9/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}} + build/env.sh /usr/lib/go-1.10/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}} override_dh_auto_test: diff --git a/build/goimports.sh b/build/goimports.sh new file mode 100755 index 0000000000..6d67ef1f0f --- /dev/null +++ b/build/goimports.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash + +find_files() { + find . -not \( \ + \( \ + -wholename '.github' \ + -o -wholename './build/_workspace' \ + -o -wholename './build/bin' \ + -o -wholename './crypto/bn256' \ + -o -wholename '*/vendor/*' \ + \) -prune \ + \) -name '*.go' +} + +GOFMT="gofmt -s -w"; +GOIMPORTS="goimports -w"; +find_files | xargs $GOFMT; +find_files | xargs $GOIMPORTS; \ No newline at end of file diff --git a/build/update-license.go b/build/update-license.go index 3d69598b75..22e4033428 100644 --- a/build/update-license.go +++ b/build/update-license.go @@ -55,10 +55,9 @@ var ( "crypto/sha3/", "internal/jsre/deps", "log/", + "common/bitutil/bitutil", // don't license generated files - "contracts/chequebook/contract/", - "contracts/ens/contract/", - "contracts/release/contract.go", + "contracts/chequebook/contract/code.go", } // paths with this prefix are licensed as GPL. all other files are LGPL. diff --git a/cmd/abigen/main.go b/cmd/abigen/main.go index 3a1ae6f4c3..3ac37ba7ad 100644 --- a/cmd/abigen/main.go +++ b/cmd/abigen/main.go @@ -29,7 +29,7 @@ import ( ) var ( - abiFlag = flag.String("abi", "", "Path to the Ethereum contract ABI json to bind") + abiFlag = flag.String("abi", "", "Path to the Ethereum contract ABI json to bind, - for STDIN") binFlag = flag.String("bin", "", "Path to the Ethereum contract bytecode (generate deploy method)") typFlag = flag.String("type", "", "Struct name for the binding (default = package name)") @@ -75,16 +75,27 @@ func main() { bins []string types []string ) - if *solFlag != "" { + if *solFlag != "" || *abiFlag == "-" { // Generate the list of types to exclude from binding exclude := make(map[string]bool) for _, kind := range strings.Split(*excFlag, ",") { exclude[strings.ToLower(kind)] = true } - contracts, err := compiler.CompileSolidity(*solcFlag, *solFlag) - if err != nil { - fmt.Printf("Failed to build Solidity contract: %v\n", err) - os.Exit(-1) + + var contracts map[string]*compiler.Contract + var err error + if *solFlag != "" { + contracts, err = compiler.CompileSolidity(*solcFlag, *solFlag) + if err != nil { + fmt.Printf("Failed to build Solidity contract: %v\n", err) + os.Exit(-1) + } + } else { + contracts, err = contractsFromStdin() + if err != nil { + fmt.Printf("Failed to read input ABIs from STDIN: %v\n", err) + os.Exit(-1) + } } // Gather all non-excluded contract for binding for name, contract := range contracts { @@ -138,3 +149,12 @@ func main() { os.Exit(-1) } } + +func contractsFromStdin() (map[string]*compiler.Contract, error) { + bytes, err := ioutil.ReadAll(os.Stdin) + if err != nil { + return nil, err + } + + return compiler.ParseCombinedJSON(bytes, "", "", "", "") +} diff --git a/cmd/bootnode/main.go b/cmd/bootnode/main.go index e1734d89ac..2e93cc04d2 100644 --- a/cmd/bootnode/main.go +++ b/cmd/bootnode/main.go @@ -21,6 +21,7 @@ import ( "crypto/ecdsa" "flag" "fmt" + "net" "os" "github.com/ethereum/go-ethereum/cmd/utils" @@ -96,12 +97,37 @@ func main() { } } + addr, err := net.ResolveUDPAddr("udp", *listenAddr) + if err != nil { + utils.Fatalf("-ResolveUDPAddr: %v", err) + } + conn, err := net.ListenUDP("udp", addr) + if err != nil { + utils.Fatalf("-ListenUDP: %v", err) + } + + realaddr := conn.LocalAddr().(*net.UDPAddr) + if natm != nil { + if !realaddr.IP.IsLoopback() { + go nat.Map(natm, nil, "udp", realaddr.Port, realaddr.Port, "ethereum discovery") + } + // TODO: react to external IP changes over time. + if ext, err := natm.ExternalIP(); err == nil { + realaddr = &net.UDPAddr{IP: ext, Port: realaddr.Port} + } + } + if *runv5 { - if _, err := discv5.ListenUDP(nodeKey, *listenAddr, natm, "", restrictList); err != nil { + if _, err := discv5.ListenUDP(nodeKey, conn, realaddr, "", restrictList); err != nil { utils.Fatalf("%v", err) } } else { - if _, err := discover.ListenUDP(nodeKey, *listenAddr, natm, "", restrictList); err != nil { + cfg := discover.Config{ + PrivateKey: nodeKey, + AnnounceAddr: realaddr, + NetRestrict: restrictList, + } + if _, err := discover.ListenUDP(conn, cfg); err != nil { utils.Fatalf("%v", err) } } diff --git a/cmd/clef/4byte.json b/cmd/clef/4byte.json new file mode 100644 index 0000000000..5603d5931d --- /dev/null +++ b/cmd/clef/4byte.json @@ -0,0 +1 @@ +{"0x22ec1244": "shaBid(bytes32,address,uint256,bytes32)", "0xcae9ca51": "approveAndCall(address,uint256,bytes)", "0x4fb2e45d": "transferOwner(address)", "0x7741b4ec": "RandomNumberFromSeed(uint256)", "0x267127ec": "getTokenSettings()", "0xb7213bd4": "readLog(uint256)", "0x3018205f": "getController()", "0xc8edf65e": "GetAndReduceFeesByFraction(uint256)", "0xeec2b628": "beforeExecute(address)", "0xfc0c546a": "token()", "0x40a3d246": "toggle()", "0x70983e91": "startBoardProposal(uint256,address)", "0x6b5caec4": "setBot(address)", "0x78524b2e": "halveMinQuorum()", "0x2c60a055": "MapTest()", "0xc2fb8f36": "TinyHuman(address,address,address)", "0x6822abae": "getMinimumCallCost(uint256)", "0x6f9fb98a": "getContractBalance()", "0x5c17f9f4": "approve(address,uint256,bytes)", "0x504ac982": "transfer(string,string)", "0x06e53f47": "whichChainIsThis()", "0xf359671c": "withdrawWithReference(address,uint256,string)", "0xf97d0591": "parseTimestamp(uint256)", "0xd3c0715b": "vote(uint256,bool,string)", "0x6b069710": "scheduleCall(address,bytes,uint256,uint256,uint8)", "0x37ae43a3": "BetOnHashV81()", "0xab519020": "calcShare(uint256,uint256)", "0x6572ae13": "calculateWinner(uint256,uint256)", "0x6aaba012": "ErrorGenerator()", "0xfe05e8b1": "assertFact(uint256,string)", "0x6e940a29": "changeHost(address)", "0x669ee827": "RegisterDevice()", "0x6f4dd69c": "testSetBalanceUpdatesSupply()", "0x4401a6e4": "safeSend(address)", "0x27dc297e": "__callback(bytes32,string)", "0xe4dedc7f": "DeleteContract()", "0x7fef036e": "totalEntries()", "0x64325ddb": "currentClaimPrice()", "0x2fc0aad3": "isNumericString(string)", "0xbc45d789": "setConfigUint(int256,bytes32,uint256)", "0xee95feaf": "isSeller(address)", "0x358d5dc2": "getIsCashed(uint256,uint256)", "0x1397fdbd": "getShares(address,bytes,int256[])", "0x2d8c1c35": "level_up()", "0x24600fc3": "withdrawFunds()", "0x05f8b6f5": "_rewireIdentities(bytes32[],uint256,uint256,uint32)", "0x1840f0ca": "countVotes(uint256)", "0xd44aadf7": "initROS()", "0xca1d209d": "fund(uint256)", "0x5fa513d5": "findPtr(uint256,uint256,uint256,uint256)", "0x3c314a91": "playerGetPendingTxByAddress(address)", "0xd5582205": "getCertifiedStudentAtIndex(uint256)", "0xe45ebe93": "checkVoteStatus()", "0xcd9380d5": "testSetBalanceSetsSupplyCumulatively()", "0x637e86eb": "totBOTs()", "0x5bb47808": "setFactory(address)", "0x674cc1f5": "getMarketHashes(bytes32[])", "0x648bf774": "recover(address,address)", "0x0221038a": "payOut(address,uint256)", "0x4016535a": "parseBlock(bytes,uint256)", "0xa3908e1b": "convert(uint256)", "0xd9e7ee1c": "new_game(uint256,uint256)", "0x929e626e": "getShareDistribution(bytes32)", "0xa20495d3": "Managed()", "0xd409ddda": "EtherizationUtils()", "0xcb2b9031": "addressToBytes(address,address)", "0xfff3c457": "readMessages(uint256)", "0x043753ba": "makeDecision(uint256,bool)", "0x85b4bb53": "getSettings()", "0x60726abb": "copy()", "0xe50d0473": "SetRank(uint8,address,uint16)", "0x54ae8492": "CustodialForward()", "0xd6d02c51": "whois(string)", "0xcb712535": "_transferFrom(address,address,uint256)", "0xb152f19e": "getFirstSchedulableBlock()", "0x9334ab61": "Infos()", "0x88a49164": "testErrorUnauthorizedTransfer()", "0x17db59a4": "dEthereumlotteryNet(address,address,address)", "0xf85aefba": "testBitsSetFailIndexOOB()", "0xae99847b": "daylimit(uint256)", "0xd93e7573": "disown(bytes32)", "0xa5468081": "Pyramid(address)", "0x00e7d289": "registerListening(address)", "0x57ee24af": "getNum(bytes32,uint256)", "0xdaea85c5": "approve(address)", "0x36ffa905": "getMyProposals()", "0x7143059f": "getParticipant(address)", "0x55ff440a": "castStringToUInt(string)", "0x6a4a6b6e": "_myAddressHelper()", "0xb67fabdf": "scheduleTransaction(address,uint256,uint256,bytes)", "0xbcca1fd3": "changeVotingRules(uint256,uint256,int256)", "0x1d3390a1": "carefulSendWithFixedGas(address,uint256,uint256)", "0x45104b16": "EXECUTION_GAS_OVERHEAD()", "0xa26759cb": "addFunds()", "0x232523e8": "forceDivestOfAllInvestors()", "0x7e904a48": "getNumContents(uint256)", "0xb69c0896": "BaseScheduler(address,address,uint256)", "0xc6ed8e1b": "getApprovedProxys()", "0x4d1f8c31": "owner(uint64)", "0x17c65aa7": "getMaxLossAfterTrade(address,uint256,int256,int256)", "0x2c02d622": "precalculate()", "0xa035b1fe": "price()", "0x43b0e8df": "set(uint256,uint256,uint256)", "0x9b5fde7d": "payOut(uint256,string)", "0x89fcd099": "getApproval(address,address)", "0x4c0eceb5": "plusOnePonzi()", "0x880cdc31": "updateOwner(address)", "0xdab80d6f": "addSponsor(address)", "0x0fcda174": "getAccountTokenBalance(address,address)", "0xa55cab95": "getName(uint8,uint8)", "0x934db458": "Big()", "0xeb782d8c": "ContentSeries(address)", "0xdbfef710": "getDefaultRequiredGas()", "0x4f09eba7": "proxyApprove(address,uint256,bytes32)", "0xf4c5ab7c": "validateCallGas(uint256,uint256)", "0x376fe102": "userId(address)", "0x922dd59a": "icapTransfer(bytes,address,bytes,uint256)", "0x7318b453": "setVotetUntil(uint8)", "0xb8c86aa6": "getArraySettingResult()", "0x37bdc99b": "release(uint256)", "0x7cbcc254": "__reset__()", "0x37664643": "retractLatestRevision(bytes32)", "0x4b031d0f": "shortSellShares(bytes,uint8,uint256,uint256)", "0xad8d5f48": "exec(address,bytes,uint256)", "0x2f95b833": "requiredStackDepth()", "0xe3848e5b": "thing(string,string,string)", "0xaa272d4b": "getNodeIndexId(bytes)", "0xd7f746ce": "tickingBomb()", "0x3b84edbd": "setRNG(address)", "0x1fb2f2a0": "testUpdateLatestRevision()", "0xb7fba4d3": "getProxy(address)", "0x4b8e1ba8": "isMinter(int256,address)", "0xba4c206e": "removeCertificationDocumentInternal(address,bytes32)", "0x884b5dc2": "fill(uint256[])", "0x88017e05": "setContribution(uint256)", "0x1ff517ff": "totalDebt(address)", "0xd0315658": "getShareDistributionWithTimestamp(bytes)", "0x7d03f5f3": "newGame()", "0xb7538f3e": "ChangeClient(address)", "0xbf4d89b5": "parseInt(string,uint256)", "0x7b55c8b5": "scheduleCall(address,bytes4,bytes,uint8,uint256[4])", "0x350d141e": "getWasApprovedBeforeDeadline()", "0x27960c5f": "validateEndowment(uint256,uint256,uint256,uint256,uint256,uint256,uint256)", "0xb774d3d7": "BankOwner_GetDonationsBalance()", "0x267b6922": "entries(bytes32)", "0x08b7c13b": "getExists(bytes20)", "0x7e7a2fbf": "contribute_toTheGame()", "0x5b86914d": "bet_value()", "0x0e1087c3": "getMarketMakerFunds()", "0xf7149220": "RNG()", "0x345006b6": "getGenerationForCall(address)", "0xc4b14e0b": "getSignature(bytes32)", "0x419945f8": "ExpiringMarket(uint256)", "0x41868769": "CallAborted(address,bytes)", "0x29092d0e": "remove(address)", "0x746c9171": "m_required()", "0x5020dcf4": "convertToEach(uint256,string,uint256)", "0xa06db7dc": "gracePeriod()", "0xbf8fc670": "sendToAggregation(uint256)", "0xf14fcbc8": "commit(bytes32)", "0xa538d287": "getMinMax()", "0xcae523c1": "testOwnedTryAuthUnauthorized()", "0x04d10f1c": "isValidChainyJson(string)", "0x9ba5b4e9": "getEventHashes(bytes32[])", "0xfedfd535": "Config()", "0x42ce0f30": "testThrowUpdateLatestRevisionNotOwner()", "0x31be6985": "testBitXorSuccess()", "0x173cb7de": "getNumReleasesForNameHash(bytes32)", "0xd90a88cd": "getContentReplies(uint256,uint256)", "0x92eefe9b": "setController(address)", "0x052b81c7": "releaseBadges()", "0xb2855b4f": "setFeeAddr(address)", "0x19a9c2f1": "generateId(string)", "0xfa9acb05": "addressInArray(address,address)", "0x3da5c3ce": "puzzle(address,bytes32)", "0x7a427d98": "forceReturn()", "0x70e71ea3": "etherandomSeedWithGasLimit(uint256)", "0xd7a58658": "changeHouseedge(uint8)", "0x72b75585": "getOriginalClient()", "0xf802075f": "requiredEndowment()", "0x7997b997": "doMelt(uint256,uint256)", "0x6d5433e6": "max(uint256,uint256)", "0xb651cbaf": "add_level(address,bytes)", "0xb4d6d4c7": "getPackageData(bytes32)", "0x90e3c278": "getShares(uint256[128])", "0x179b73da": "killBoardProposal(uint256,address)", "0xc944a38e": "CharlyLifeLog(string,int256)", "0xe1c66292": "Create(uint32,address)", "0x69c8b344": "ownedToken(address)", "0xabcf1328": "InterestBank()", "0x532e7e6a": "calcEarningsSelling(bytes,uint256,uint256[],uint8,uint256)", "0x43d24a5e": "addUpdater(address)", "0xd1feca67": "addSpendingRequest(address)", "0x2d34ba79": "setup(address,address)", "0xcb14d93b": "getHash(bytes,address,uint256)", "0x309424fe": "get_all_names()", "0x96c52fc3": "____forward(address,uint256,uint256,bytes)", "0xde39acea": "get32(bytes,uint256)", "0xf3dd3d8a": "newCurrency(string,string,uint8)", "0x2432eb23": "testThrowRetractLatestRevisionNotUpdatable()", "0x7fcf3a2f": "throwFooBar()", "0xabe9f569": "oraclize_getPrice(string,uint256)", "0x41ee903e": "clear(uint256,uint256)", "0xd249a52e": "update(bytes,uint256[],uint256[])", "0xc3d014d6": "setContent(bytes32,bytes32)", "0x3ac5cb73": "GeometricPonzi()", "0x4a1aa767": "claim_victory(uint256,uint8,uint8,uint8)", "0xce592586": "setThresold(uint256,uint256)", "0x63deb2c5": "changeMemberAddress(address)", "0x2e6e504a": "trusteeWithdraw()", "0xcfed9199": "timePassed(uint256)", "0xb782fc9b": "getFirstActiveDuel2()", "0x35b28153": "addAuthorization(address)", "0x46f7a883": "BuyTicket(uint8,uint8,uint8)", "0x83c51a38": "thesimplegame()", "0xfa28ba0d": "validateReleaseLockfileURI(string)", "0xa7b2d4cb": "remove(int256,address)", "0x010731c0": "sendCryptedHand(bytes32)", "0xe9e99d81": "getChannelFeed(address,uint256,uint256,uint256)", "0x4e30a66c": "safeToAdd(uint256,uint256)", "0x2c4e591b": "totalGames()", "0xa3221c8e": "step8()", "0x783ce458": "expmod(uint256,uint256,uint256)", "0xe417291b": "undelegateDAOTokens(uint256)", "0x8e5d97a2": "releasePendingTransfer(uint256)", "0xbc5ff5e1": "oraclize_query(string,string[4],uint256)", "0x38f77d69": "getDistributeProfitsInfo()", "0xbb510a77": "createChannel(address,uint256)", "0x650955d4": "HashToken()", "0xa8484938": "doApprove(address,uint256)", "0x64ed31fe": "authVotes(address)", "0xf7ae9421": "checkInvestorBalance(address)", "0xba904eed": "removeRegistrar(address)", "0xdce4a447": "at(address)", "0xdb4cacec": "Other()", "0x3647b87a": "buildFactory()", "0xa51aea2d": "changeMaxMultiplier(uint256)", "0x4974bc27": "download()", "0xf8a8fd6d": "test()", "0xd8c90762": "addTrustedIssuer(address,string)", "0xdf6c13c3": "getMinFunding()", "0x867904b4": "issue(address,uint256)", "0x1531c267": "fipsRegisterMulti(uint256,address,bytes)", "0x40a49a96": "searchSmallestInvestor()", "0x61bffe01": "addIdentities(bytes32[],bytes32[])", "0xf77a0923": "BitcoinProcessor(address)", "0xd02528e6": "GetGameIndexesToProcess()", "0x9f927be7": "getNextCall(uint256)", "0xd8162db7": "lockedUntilBlock()", "0x36dfe260": "payOneTimeReward()", "0xc5b1a53c": "deposit(bytes16[],uint64)", "0xc2b6b58c": "isClosed()", "0xc88cc6ac": "getCertification(address)", "0x77ac3da5": "oraclize_query(uint256,string,string[1],uint256)", "0x70ab8ba8": "creditUpdate()", "0xd3ea3322": "testBuildTokenSystemCost()", "0x72388610": "paybackAll()", "0xca6d56dc": "addMember(address)", "0x0994a0a0": "DSTokenTest()", "0xe53e04a5": "refillGas()", "0xc1d5e84f": "addNewUser(address)", "0x89ed0b30": "setOraclizeGas(uint32)", "0x02ba8742": "sendCoins(address,uint256)", "0xb0de1cb7": "publish(uint64,bytes,uint64)", "0x0e13b9af": "getValue(uint8,uint8)", "0xb3dfcdc3": "Contribution(uint256)", "0xa9b35240": "packageExists(bytes32)", "0xd1d3bb92": "testSetPkg()", "0x97297467": "checkAndVerify(bytes)", "0xe31bfa00": "next_id()", "0x9948e493": "calcMarketFee(bytes,uint256)", "0xd148288f": "setHoldingPeriod(uint256)", "0xc032dc30": "execute(uint256,address)", "0xdad99989": "burnCoins(address)", "0xb1999937": "leapYearsBefore(uint256)", "0xa6cbcdd5": "numSignatures(bytes4)", "0xaca66aec": "DVIP()", "0x20bf0c52": "Derived(uint256)", "0x693ec85e": "get(string)", "0x0411bca8": "getChallengeAnswerResult(uint256)", "0x61584936": "sealedBids(bytes32)", "0x2f1927cb": "prepareRoll(uint256,uint256,uint256)", "0xeaa1f9fe": "reqisterListening(address)", "0xb623f5e5": "checkSetCosignerAddress(address)", "0xa88c5ef7": "NextPayout()", "0x66ad484c": "newfirst_player(address)", "0xb4022950": "collectFeesInEther(uint256)", "0xbff0fbb8": "calculateMeat(uint256)", "0xd62b255b": "setOwner(address,string)", "0x2fd6d40b": "getBetValueByGamble(uint8)", "0x3b0506f7": "getVoteByAddress(address,uint256)", "0xbddd3a6b": "step7()", "0x67fbd289": "destroyTokens(uint256)", "0x9844347b": "createCertificate(bytes,bytes,uint256,bytes)", "0x5e68ac2c": "Kingdom(string,address,address,address,uint256,uint256,uint256,uint256,uint256)", "0x8ba9f354": "testClearBitSuccess()", "0x48027610": "transferPaidOut(address,address,uint256)", "0x912de8de": "fixBalance()", "0x04509918": "scheduleCall(address)", "0x7cf0ffcb": "forceDivestAll()", "0x3b3b57de": "addr(bytes32)", "0xeb7c6f72": "step6()", "0xfe6f0d82": "testConstructorEvent()", "0x55b62dcf": "getThresold(uint256)", "0xfbae5e7d": "Investors(uint256)", "0x29e206bd": "forceDivestAll(bool)", "0x6a226a49": "addMessage(string)", "0x8e2a6470": "allocateShares(address,uint256)", "0xe6e7237f": "claim_time_victory(uint256)", "0x17a601b5": "MAX_STACK_DEPTH_REQUIREMENT()", "0x87fd0421": "TheEthereumLottery()", "0xc17e6817": "sendSafe(address,uint256)", "0xa5dfee67": "testThrowsCreateNewRevisionNotUpdatable()", "0xb35893f3": "setExporter()", "0x1ceea715": "GetMyInvestFee()", "0xb78bd4a5": "breakCookie(string)", "0x05215b2f": "createStandardToken(uint256)", "0x2632bf20": "unblockMe()", "0x5292af1f": "sendBalance(address)", "0xc2e9fab3": "SubUser()", "0x6493d7fc": "CircuitBreaker(address,address,uint256,uint256)", "0x4f896d4f": "resolve(uint256)", "0x16870257": "getTileDescription(uint8,uint8)", "0x3ef87414": "getRevisionCount(bytes20)", "0x747586b8": "setInt(int256)", "0x5714f6a1": "getTotalAvailableRelays()", "0x99154b49": "ARK()", "0x1efb17ee": "changeHouseAddress(address)", "0x354d7e40": "Payout()", "0x2da0d1ea": "etherSold()", "0xea46193e": "getEtherBalance()", "0x11fe773d": "memcpy(uint256,uint256,uint256)", "0x1e701780": "MICRODAO(address,uint256,uint256,uint256,address)", "0x1c31f710": "setBeneficiary(address)", "0x0a4caed0": "getChannelByRank(address,uint256)", "0xf3125a1f": "deposit(address,uint256,bytes,uint256)", "0x00e46700": "setMinimumPassPercentage(uint8)", "0x92d282c1": "Send()", "0x89d59ee5": "createPersonalDepositAddress()", "0xbe1c766b": "getLength()", "0x70a08231": "balanceOf(address)", "0xae0a6b28": "signature(string,bytes32)", "0xb3485dca": "UpdatePrice(uint8,uint32)", "0xf8ec4bf2": "setAllowTransactions(bool)", "0x53d97e65": "setPrizes(uint32[])", "0xd1b1a22b": "set(string,uint256[],uint256[],uint256[],bool[],uint256[])", "0x96286cc9": "isTokenOwner(address)", "0x154af6b1": "sendShares(uint256,uint8,uint256,address)", "0xbe2430fe": "sendValues()", "0x57a373a1": "uintInArray(uint256,uint256,int256,uint256[],uint256)", "0x8fd28bcf": "testFailAuthorityAuth()", "0x89ef40e7": "numberOfHealthyGenerations()", "0x23e9c216": "setBounty(address,string,uint256)", "0x71dd99fe": "BigRisk()", "0x1e9fcc77": "activateAllowance(address,address)", "0x561e91a1": "makeBet()", "0x32d2fb9f": "getRefRemainingTime(uint256)", "0x992c870d": "transferName(bytes,address)", "0x6b3fdc5a": "oraclize_setNetwork(uint8)", "0x2ea459b8": "claimThrone(bytes)", "0x33a99e04": "selectWinner()", "0x3b49a77b": "hasConfirmed(bytes,address)", "0xa352f1a8": "calcSHA3(bytes)", "0x4bb4b260": "cashAllOut()", "0xb89a73cb": "isShareholder(address)", "0xba5a2d33": "exitPool(address)", "0xddd41ef6": "transferDirector(address)", "0xa06cab79": "Registrar(address,bytes32)", "0x871113c3": "oraclize_query(string,string[1],uint256)", "0x1f0f711f": "discontinue()", "0x632f0ba6": "descriptionHashes(bytes)", "0x980e8c81": "FutureBlockCall(address,uint256,uint8,address,bytes,uint256,uint256,uint256)", "0x4ae8c55f": "getWwLength()", "0x82fc49b8": "setCosignerAddress(address)", "0xc4bd8ebc": "num_monsters()", "0x0381cb3b": "setRowcol(uint256,uint256[2])", "0x124eaee6": "Identity()", "0x3f4be889": "callContractAddress()", "0xef3a6031": "testBaseToken()", "0x954ab4b2": "say()", "0x1b855044": "getHash(uint256,uint256)", "0xd9d73887": "Diana()", "0x5103a5a3": "certify(address,bytes32)", "0x51560da9": "topDogInfo()", "0xf3ee6305": "removeCertificationDocument(address,bytes32)", "0x049ae734": "scheduleCall(address,bytes4,uint256,uint256,uint8)", "0xd8a8e03a": "move(uint256,address)", "0xc3c5a547": "isRegistered(address)", "0x06005754": "nameRegAddress()", "0xbe592488": "validateName(bytes)", "0x0eecae21": "draw()", "0xac3e7d24": "addChainyData(string)", "0xfd83f3e3": "QueueUserMayBeDeliveryDroneCotnrol()", "0x7772a380": "isInGeneration(address,uint256)", "0xeb1ff845": "changeId(uint256,uint256,uint256)", "0x9cc9299e": "killSwap()", "0x1e2ca0f3": "updateLeftLottery(address)", "0x998446a8": "acceptRequest(uint256,bytes)", "0x8e1ffb19": "testThrowsRetractLatestRevisionEnforceRevisions()", "0x9935935f": "setResolveHandler(bytes,address)", "0xcd4b6914": "getRandom(uint256)", "0xc08dd1dc": "IOU(string,string,uint8)", "0xbe4054b9": "commitReading(address,uint256,uint256,string)", "0xbc21ce9d": "Aggregation()", "0x6e173a7f": "storeBlockHeader(bytes,bytes)", "0x114d69b2": "setCRLaddr(address)", "0x3fa4f245": "value()", "0x69573648": "remove(bytes,bytes)", "0x7fee4ecb": "GAS_PER_DEPTH()", "0x591c515f": "append(string,string)", "0x727b1cd6": "next_draw(bytes32,uint256,uint256,uint256,uint256,uint256)", "0xc60ce271": "findNextMinute(uint256,bytes)", "0xd337616e": "resetLottery()", "0xdacaeb07": "pledge(bool,uint256)", "0xb29c2493": "token(uint256,string,uint8,string)", "0x61047ff4": "fibonacci(uint256)", "0x8f367001": "numTokensAbleToPurchase()", "0x12cc08f2": "getPackageReleaseHashes(string,uint256,uint256)", "0x67a59d91": "scheduleCall(address,bytes,bytes,uint256,uint256,uint8)", "0xe6c3b4ab": "testBalanceAuth()", "0xd526b9bd": "_allow()", "0x29de91db": "setMsg(address,uint256)", "0xd1cf113e": "multiAccessSetRecipient(address)", "0xc2412676": "Token()", "0x391f2e96": "InvestCancel()", "0xc0ae6a3a": "ultimateOutcomes(bytes)", "0x202d6eaf": "addInvestorsValue(uint256)", "0x30b9af98": "withdrawFunding()", "0xe80bd3e5": "addCertificationDocumentToSelf(bytes32)", "0xf4e36afd": "findThroneByNameHash(uint256)", "0x30677b83": "multiplierFactor()", "0x590528a9": "sellShares(uint256,uint8,uint256,uint256)", "0x01cceb38": "setExpiry(uint256)", "0x779beca0": "getNumOfSalesWithSameId(bytes)", "0xac940823": "betOnLowHigh(bool)", "0x06961560": "DAO(address,uint256,uint256,uint256,address)", "0xd42bf301": "doTriggerTryAuth()", "0xfa566ddd": "doAllowance(address,address)", "0x6677febe": "get_all_accepted()", "0xaa67c919": "depositFor(address)", "0xf28386bf": "Nexium()", "0x77e4fb04": "testFailNotEnoughValue()", "0x12b58349": "getTotalBalance()", "0xc0d2834b": "DataSource()", "0x3e82055a": "addSignature(uint256,bytes16,bytes)", "0xcff2fa42": "_returnFee(address,uint256)", "0xa056469a": "extractFeeLength()", "0xc98031be": "hintURL(int256,bytes32,string)", "0x6ebbe863": "updatePublishContract(address)", "0x08216c0f": "createHumanStandardToken(uint256,string,uint8,string)", "0xc36af460": "getLatest()", "0xdb5b4183": "oracleOutcomes(bytes,address)", "0x0b5ab3d5": "destroyDeed()", "0xe1c7392a": "init()", "0x4ca1fad8": "addRequest(uint256)", "0x305b73d9": "configure(address,address,uint256,uint8,bytes32,bytes32)", "0x9077dcfd": "submitCoding(string,uint256)", "0x38fff2d0": "getPoolId()", "0x07bc6fad": "withdraw(address,uint256,bytes32,uint256)", "0xfbf58b3e": "transfer(string,address)", "0x1d8b70da": "order_received(string)", "0x0b3ed536": "claimDonations(uint256)", "0x6f374a12": "setBool()", "0x0ca35682": "recover(uint256)", "0x3ae7cdfa": "fipsLegacyRegister(bytes20[],address)", "0xe6c1beb4": "prepend(address)", "0x776d62f6": "costs()", "0xe4690a0b": "popRequest()", "0x74eb9b68": "isAccountLocked(address)", "0x7d32e7bd": "transfer(address,bytes32)", "0xdf2f0a4a": "getDecisionBlockNumber(uint256,uint256)", "0xc494f71a": "LedgerFund(uint32,uint32,uint64,uint64)", "0x446d5aa4": "getAttributes(address)", "0x4cdc6a73": "Marriage()", "0x677cee54": "SafeConditionalHFTransfer()", "0x7b48ba20": "testThrowDisownNotOwner()", "0x1288c42a": "Prism()", "0xe8b13c44": "getChainyTimestamp(string)", "0xe4c2db06": "getPreviousFile(bytes)", "0xf0586f0d": "doThrow(bool)", "0xc1b06513": "registerEvent(bytes32[])", "0x521eb273": "wallet()", "0x32254992": "getPrevHash(int256)", "0x1fd96b69": "ManagedAccount(address,bool)", "0xabf74a93": "pitFee()", "0xa480ca79": "collectFees(address)", "0xa0bde7e8": "getShareDistributionWithTimestamp(bytes32)", "0xff27c476": "shiftBitsRight(bytes,uint256)", "0x172d8a30": "setDirectorLock(uint256,uint256)", "0xf262de8c": "add_staircase(uint16)", "0x990f3f53": "computeResponseSecondHalf(uint256,uint16)", "0x26745909": "PRNG_Challenge()", "0xcacc24eb": "transferFromViaProxy(address,address,address,uint256)", "0x94f3f81d": "removeAuthorization(address)", "0x3f0ec70b": "RequestFactory(address)", "0xa2a8336f": "claimEtherSigner(uint256)", "0xaa5d4719": "getTransferable(bytes20)", "0x23cd7cd5": "Model()", "0x3fb0b2c9": "CancelRoundAndRefundAll()", "0xd5fa2b00": "setAddr(bytes32,address)", "0xa0f61310": "FakeRelay(bytes)", "0x4ea66c38": "buyinInternal(address,uint256)", "0xbe040fb0": "redeem()", "0xb845c9a2": "WEI()", "0x26a7985a": "getMaximumCallGas()", "0x06661abd": "count()", "0xc89f8f08": "testGetController()", "0x81baf820": "BlockScheduler(address)", "0x9801cb8e": "ProofOfExistence()", "0xeb7492d1": "testTotalSupply()", "0x3dfb4843": "renewDeed(bytes32)", "0xc3fa5f93": "BlockScheduler(address,address)", "0x7958533a": "meta(uint256,bytes32)", "0xa1a66e56": "deductFunds(uint256)", "0xaf92a693": "addRegistrar(address)", "0xb2aac51f": "lookupUser(string)", "0xd70cf105": "moveBalance(address,address,uint256)", "0x2afb21bc": "InvestWithdraw()", "0x6d09e2ec": "commitCurrency(address,uint256,uint256)", "0x7b1a4909": "transferETH(address,uint256)", "0x96c824a8": "createAccountFundContract()", "0xe0a70811": "restart(bytes20,bytes)", "0x22057bc7": "getAllRevisionBlockNumbers(bytes20)", "0x6af2da2f": "testKeyedHash()", "0x7f6d8955": "RegisterOne(uint32,address,address)", "0x65f27bea": "testSubBalanceFailsBelowZero()", "0xa2f16d80": "dexWithdrawCollectedFees()", "0xc179520c": "ManageAccount()", "0x2672b3e2": "SplitterEtcToEth()", "0xe839e65e": "query2(string,string,string)", "0x39f64b52": "calcTokenPrice()", "0x4ef5710a": "WatchNumberOfPlayerInCurrentRound()", "0x3017fe24": "callAPIVersion()", "0x2977b1b1": "testAllowanceStartsAtZero()", "0x531c1b33": "getOperatingBudget()", "0xb7f2f33c": "transferRightIfApproved(address,bytes)", "0x00873367": "comparisonchr(string)", "0x2a0d79ef": "totalSupply(bytes)", "0xa715ff59": "EtherandomProxy()", "0xd6ca8ccb": "disown(bytes20)", "0x6ad2a0b3": "buildContract(address)", "0x45596e2e": "setFeeRate(uint256)", "0x0e97cfdf": "placeOrder(uint256,uint256,uint256)", "0x9549355e": "oracalizeReading(uint256)", "0x8d7af473": "numberOfProposals()", "0x728af7ec": "getInterest(uint256,uint256)", "0x11b9fee8": "ForkChecker(uint256,bytes32)", "0xd850288b": "etherlist_top()", "0xf4dc2d21": "Deed(uint256)", "0xf8b11853": "getGenerationStartAt(uint256)", "0x7c7a52bf": "newChallenge(uint256,address)", "0xd2d4bd72": "getCrossRate(bytes,bytes)", "0xe9b93569": "OwnerGetFee()", "0xfb72d24e": "shift_right(uint64,uint256)", "0x112e39a8": "scheduleCall(uint256)", "0x6c494843": "multiAccessChangeOwnerD(address,address,address)", "0x313ce567": "decimals()", "0x9bac8602": "testFailAddBalanceAboveOverflow()", "0xa70a9ad7": "switchDeity(address)", "0x6a61e5fc": "setTokenPrice(uint256)", "0x990c8f79": "returnValue()", "0xa4136862": "setGreeting(string)", "0x0af4626d": "testRetract()", "0x5e11544b": "newPeriod()", "0xdc206e5f": "oraclize_query(uint256,string,string[])", "0xcaa648b4": "getTotalValue()", "0x20bfec70": "WatchFees()", "0x62a0b56b": "testUnset()", "0x42f6e389": "isModule(address)", "0x769796fe": "resetAction(uint256)", "0x402e6230": "getTotalGambles()", "0xe8a1c08f": "nibbleToChar(uint256)", "0x1aa3a008": "register()", "0x96d02099": "rsplit()", "0x83324e8c": "numGroups()", "0x72c7c85a": "minority()", "0xb8d94b95": "buildDSNullMap()", "0xe039e4a1": "getOwner(uint8,uint8)", "0x625cc465": "baseDonation()", "0x77372213": "setName(bytes32,string)", "0xa7dfc874": "unregister(bytes,address,uint256,bytes)", "0x37f4c00e": "anchorGasPrice()", "0xb2bfd948": "checkNumbers(uint8[3])", "0x512f1e64": "orderBookLength()", "0xafed762b": "toSlice(string)", "0xbb6a1427": "testThrowRestartEnforceRevisions()", "0x734d8287": "unclaimedFees()", "0xf295206f": "_unsafeSend(address,uint256)", "0x69d01268": "concatUInt(uint256)", "0x0494630f": "oraclize_query(uint256,string,string[4],uint256)", "0x13fc6ac2": "getEventData(bytes32)", "0xbff974e8": "getContentReplies(uint256)", "0x18921de4": "addSignature(string,uint256[],uint256[],uint256[],bool[],uint256[])", "0xa87e7552": "isValid(bytes,bytes)", "0xb8d3bfe3": "MeatGrindersAssociation(address,address,uint256,uint256,uint256,address)", "0x61461954": "execute()", "0xecb0256b": "relayTx(bytes,int256,int256[],int256,int256,bytes,int256,int256[],int256,int256)", "0x7cdbae63": "addRegistryIntoTagsIndex(address)", "0x1f4e996b": "challenge(bool)", "0x0eb0afa6": "createDebt(address,address,uint256)", "0x5f6a1301": "clearPending()", "0x305a762a": "getTicketsCountByBuyer(uint256,address)", "0x724ae9d0": "getMinInvestment()", "0x1e39499d": "scheduleCall(address,bytes,uint256)", "0x4f197ee7": "transferPackageOwner(string,address)", "0x7e3faec1": "GoldTxFeePool(address,address,bytes)", "0x8d68cf59": "sendFunds()", "0x83eed3d5": "queryN(uint256,string,bytes)", "0x15c91115": "pbkdf2(bytes,bytes,uint256)", "0xeb121e2f": "update(uint256,uint256[101][])", "0x5e44daf3": "vote(uint256,int256)", "0xac562666": "freezeCoin()", "0xb0166b04": "testTransferringMkr()", "0x631de4d6": "replace(address,address)", "0x4bd70ea3": "testFailGetUnset()", "0xf738e5ca": "ownerTakeProfit()", "0xc6236a5c": "scheduleCall(bytes,uint256,uint256,uint8,uint256)", "0x119aa5c8": "checkForward(bytes)", "0x541aea0f": "put(uint256,uint256)", "0x6386c1c7": "getUserInfo(address)", "0x4e209678": "testFailBreach()", "0xe9fe799e": "registrantRemove(address)", "0x2aee19c7": "testCreateWithNonce()", "0xa0ec4e09": "getUltimateOutcomes(bytes32[])", "0x4d9e4e22": "Etheria()", "0xa6b513ee": "finalPrice()", "0x82f0d875": "makeHash()", "0x78ae88d1": "newDeal(uint256,uint256,uint256,uint256,uint256)", "0x177766e6": "getOptionChain(uint256)", "0xf1173928": "RemovedFromGeneration(address,uint256)", "0xea2ea847": "testChallengeFinalize()", "0xbd35d570": "GAS_TO_COMPLETE_EXECUTION()", "0x364ea9e7": "set(uint256,uint256,bool[],uint256[])", "0x17ff0caa": "WeatherBet(uint256,address,address,address)", "0x4e23a144": "fundUser(address,uint256)", "0x144267e0": "refundSecurity(address,uint256,uint256)", "0x31c6c4cf": "transferFromWithReference(address,address,uint256,bytes32,string)", "0x2eb5c61f": "testThrowsUpdateLatestRevisionEnforceRevisions()", "0xde640e19": "Investment(uint256)", "0x9cb8a26a": "selfDestruct()", "0x9c43d950": "registration(uint256,uint256,uint256)", "0xe2fdcc17": "escrow()", "0xc618d15f": "ConvertNumbers(bytes5)", "0x8c98117c": "getBill(uint256,uint256)", "0x2d7788db": "rejectRequest(uint256)", "0xfaab9d39": "setRegistrar(address)", "0xa289673b": "fipsChangeOwner(bytes20,address,address)", "0x54d9d6f8": "findNextDay(uint256,bytes)", "0x008a745d": "claimDividendShare(uint256)", "0x6f4812e2": "testFailControllerInsufficientFundsTransfer()", "0x5e983d08": "setPrices()", "0x798974dd": "getNumProposals()", "0x4ca168cf": "register(bytes,uint256,address,string,uint256)", "0xa1e4d3c2": "MembershipRoster()", "0xd4065763": "returnRemainingMoney()", "0x0c4326a0": "getMajorMinorPatch(bytes32)", "0xeece1e1f": "scheduleShuffling()", "0x226685ee": "Visit()", "0x323082d7": "Vote(string)", "0x0b15650b": "randInt(uint256,uint256)", "0xc9cfac55": "refundCurrency(address,uint256,uint256)", "0xfe4a3ac9": "setExecPrice(uint256)", "0x6a0e605f": "MyToken(uint256,string,uint8,string,address)", "0xb549793d": "scheduleCall(bytes4,bytes,uint256,uint256,uint8,uint256)", "0x85e68531": "revokeAccess(address)", "0x01991313": "scheduleCall(address,bytes4,uint256)", "0x0a6be0e7": "BalancedPonzi()", "0xf463edd1": "createDocument(uint256)", "0xa20c404f": "ModifySettings(uint256,uint256,uint256,uint256,uint256,uint256,uint256)", "0x560bb612": "SignatureValidator(address)", "0xf7654176": "split()", "0x48f05187": "scheduleCall(address,bytes4,bytes,uint256)", "0xf2b904c3": "checkBetColumn(uint8,address,bytes32,bytes32)", "0x7bc0ff20": "setupExportFee(address,uint256)", "0xeb06e65e": "allowanceFromProxy(address,address,address)", "0xfe757fb5": "lastClaimPrice()", "0xa5d0bab1": "buyPartial(uint256,uint256)", "0xda7d0082": "isCertification(address,bytes32)", "0xe570be18": "DVIPBackend(address,address)", "0x54738157": "OwnerCloseContract()", "0xc1e5304a": "CreateNewDraw(uint256,bytes)", "0x0c26e42e": "getReleaseHashForNameHash(bytes32,uint256)", "0x0f7d6673": "Channel()", "0x54ea4000": "identify(address[])", "0x69307c80": "rotateBits(bytes,int256)", "0x78f0161a": "setGreyGreenPrice(uint8)", "0x23b872dd": "transferFrom(address,address,uint256)", "0x578bcc20": "reduceDebt(address,address,uint256)", "0x59e148fc": "getLastOfferId()", "0xb5299ca6": "giveMeat()", "0xae30d35d": "ARK_TROGLOg_1_00()", "0x2d2c44f2": "Vault()", "0xce19419b": "testThrowsSetNotUpdatableNotOwner()", "0xffcf21a9": "eventOracles(bytes,uint256)", "0xf46c50dc": "doFail()", "0x73b55eaf": "registerData(address,int256,bytes32,address)", "0x53770f9a": "isStateless()", "0x4d47feaa": "ShareholderDB(uint256)", "0x40b31937": "pledgeDecline(uint256)", "0x01cb3b20": "checkGoalReached()", "0x62e05175": "setMotionDB(address)", "0xf362d78f": "testBitNotEqualSuccess()", "0xd2531590": "CANCEL_EXTRA_GAS()", "0x9a92b7e7": "EthVenturesFinal()", "0x79b0797c": "AmIPlayer1()", "0x6241bfd1": "Token(uint256)", "0x94a1710d": "testNonOwnerCantBreach()", "0xb466b76f": "fresh()", "0x4a5dddd2": "proxyPurchase(address)", "0xc0a1a949": "x15()", "0xc3b8bfe5": "transferIfNoHF(address)", "0x4a7e049e": "getFullCompany(address,uint256)", "0x481b659d": "permitPermanentApproval(address)", "0x16ce8a69": "setBuilding(uint256,uint256)", "0x1593a8c7": "endLottery()", "0x078c3fa4": "_transferToICAPWithReference(bytes32,uint256,string)", "0xfa3f1e99": "testBlobStoreRegistered()", "0x0b9e9817": "CanaryV7FastTestnet()", "0x6663bbec": "orderMatch(uint256,uint256,int256,uint256,uint256,address,uint8,bytes,bytes,int256)", "0x273bc3c9": "numberOfThrones()", "0x3c84f868": "set(int256,address,uint256)", "0x1ac61e8c": "testBlobCreate()", "0x5ccc3eaa": "roundMoneyUpToWholeFinney(uint256)", "0x0ccec396": "getNumReleases()", "0x6ac6205c": "addDataPoint(int256,uint256,bool,string)", "0x1d124fe4": "setUtils2(address)", "0x4c471cde": "scheduleCall(address,bytes4,bytes,uint256,uint256,uint8,uint256)", "0x52a554a1": "voteBoardProposal(uint256,address,bool)", "0x745a8be2": "flip32(bytes)", "0xbac1e2e0": "testBitsAndSuccess()", "0x25fda176": "notify(address,uint256)", "0x3b8e6f2e": "balanceAt(address,uint256)", "0x60585358": "getByte()", "0xc853c03d": "newDraw(uint256,uint8[3],uint256,uint256,uint256,uint256)", "0x741273d6": "testThrowRegisterContractAgain()", "0x8f2c44a2": "UnicornMilker()", "0x59d96db5": "terminate(uint256,string)", "0x483ba09e": "setBitcoinBridge(address)", "0x74fbbc86": "rate(uint256,uint256,string)", "0x83ea0620": "packageExists(string)", "0xd917deb5": "Donate()", "0x3fc6bc94": "payDAO()", "0x6558488a": "scheduleSetBool(address,uint256,bool)", "0x83e78b31": "bet(uint8,bool,uint8)", "0xeccb15bc": "SatPosition(int256,int256)", "0x7daa10ce": "getMyInfo()", "0x3e4565d2": "testErrorUnauthorizedNameRegister2()", "0x2143da91": "GameOfThrones()", "0xb29f0835": "doIt()", "0xdcc0ccf3": "Dao(address)", "0x70d53be5": "find()", "0x9a828a71": "oracalizeReading(uint256,string)", "0x6a6d31db": "externalEnter()", "0xf8b71c64": "rewardTo(address,uint256)", "0x0399c357": "assignFreeReadings(address,uint8)", "0x81ade307": "query(string,string)", "0xdb83694c": "getSaleInfo()", "0xa6bf3df0": "oraclize_query(string,string[2],uint256)", "0x29605e77": "transferOperator(address)", "0xf29d2f28": "setTokenHolder(address)", "0xa96f8668": "releaseTokens()", "0x8a3bc2bc": "iPropose(bytes,uint256,bool)", "0xd18611d6": "reactivate()", "0x7620a65b": "Publisher()", "0xa268b332": "testBitXorFailIndexOOB()", "0x6b1781b6": "Emergency()", "0x1003e2d2": "add(uint256)", "0x1209b1f6": "ticketPrice()", "0xe5a27038": "Pluton(uint256,string,uint8,string)", "0x22bc3b8e": "getArgument(uint256)", "0x47bdb7f4": "transferDisable(bytes20)", "0x13137731": "testThrowsUpdateLatestRevisionNotUpdatable()", "0x3f3935d1": "confirmReverse(string)", "0xecb4136e": "NotAnotherPonzi()", "0x49e347ae": "getContents(uint256[],uint256)", "0x669dafe8": "toWei(uint256)", "0xc233e870": "isLatestPatchTree(bytes32,bytes32)", "0x7b789b3d": "agreement(bytes,bytes,bytes)", "0x682d3bb0": "pdfCertificateProof(bytes)", "0x42346c5e": "parseInt(string)", "0x3177029f": "approveAndCall(address,uint256)", "0x71ffcb16": "changeFeeAccount(address)", "0xc971442c": "getDBs()", "0x362e2565": "returnDeposits()", "0xe10e274a": "CrazyEarning()", "0x6d705ebb": "register(address,uint256)", "0xbe9a6555": "start()", "0x1ce624d6": "Crypted_RPS()", "0x2c4cb4be": "removeRegistryFromNameIndex(address)", "0x68742da6": "withdrawFunds(address)", "0x18f3fae1": "setOversight(address)", "0x061ea8cc": "countByOwner(address)", "0xd6d22fa4": "MetaCoin()", "0x85654c9c": "setMembershipRoster(address)", "0x8aa33776": "setMsgPrice(uint256)", "0x4dd850fb": "UfoPonzi()", "0x07e00bcb": "kissBTCCallback(uint256,uint256)", "0xa1b7ae62": "setdirectorName(string)", "0xb4d9cc3a": "profitDisperser()", "0x0f24f5c8": "doTransfer(address,uint256)", "0x8d72a473": "deductFunds(address,uint256)", "0x28f03554": "ProcessDividend()", "0x98391c94": "muteMe(bool)", "0x346cabbc": "scheduleCall(address,bytes4,uint256,bytes,uint256)", "0xa42e36c6": "scheduleTransaction(address,bytes,uint8,uint256[5],uint256)", "0x21b36a08": "setFee(uint64,uint256)", "0xd94073d4": "PT()", "0xe8580dd4": "Survey(address,uint256,string,bytes32[])", "0x1f0c1e0c": "getEventTokenAddress(bytes32,uint256)", "0xce8b7151": "isHF()", "0x9bee757b": "requestExecution(bytes,uint256)", "0x775dec49": "keccak()", "0x6673ce2b": "Results_of_the_last_round()", "0x9f87acd0": "exec(bytes32,bytes32,uint256)", "0x02394872": "getLastBlockHeight()", "0x615664ba": "Market()", "0x0d7af726": "addGame(address,string,string)", "0xf4aa1291": "withdrawFundsAdvanced(address,uint256,uint256)", "0x8ed67a44": "setPrice(uint16)", "0x84ebde52": "Under_the_Hood()", "0x5a28340a": "accessOperatingBudget(uint256)", "0x9a89ad65": "within6Confirms(int256,int256)", "0xdfce8ac3": "fipsLegacyRegister(bytes20,address,bytes)", "0x73f310df": "multiAccessRemoveOwner(address)", "0x4cbee813": "logout(string)", "0xd992bd5b": "testResultNotZero()", "0x05b34410": "creationDate()", "0xfed4614b": "funeral(bytes,int256)", "0x58cb7323": "MainnetETCSurvey()", "0xbb504317": "divest(address,uint256)", "0x82381c96": "WatchCurrentMultiplier()", "0xcce81927": "EtherDice(address,address)", "0x70961774": "getBlockCreatedOn()", "0x84a7b223": "Canary(address)", "0x9378a9e2": "setUInt(uint256)", "0xe4360fc8": "getFileListElement(bytes)", "0xe597f402": "create(bytes1,bytes32,bytes)", "0x95d5a1be": "SignatureReg()", "0x33ce7787": "transferInvestorAccount(address,address)", "0x46c52b1a": "blockHexCoordsValid(int8,int8)", "0x3092afd5": "removeMinter(address)", "0x30945443": "update(address,string,string)", "0xc37ff3d9": "sha(uint256,uint256)", "0x29a6f31b": "oraclize_query(uint256,string,string[2],uint256)", "0x227f9633": "addOption(string,address,uint256)", "0x38eaf913": "setDirectorNode(string)", "0xab67aa58": "transferFrom(address,address,uint256,bytes)", "0x0ce3151c": "personUpdateRelation(uint256,string)", "0x216ef940": "proxyUpgrade(address,address,bytes)", "0x76bc21d9": "fireEventLog2Anonym()", "0xf004073a": "performAction(uint256)", "0xdba7ef7d": "Bookie(address,address)", "0xa0469b02": "inputToDigit(uint256)", "0x1d007f5f": "changeDAO(address)", "0x9dcb5c65": "resultsWeightedByEther()", "0x14ab9038": "setTTL(bytes32,uint64)", "0xf4d94699": "EndowmentRetriever()", "0xe74b9d11": "safeToSubtract(uint256,uint256)", "0xd7504385": "validateToAddress(address)", "0x57e2880d": "scheduleTransaction(uint256,uint256)", "0xe73a914c": "setDAO(address)", "0xc47bc007": "add_funds()", "0x37881810": "setCallbackAddress(address)", "0x686f2c90": "collectAllFees()", "0x278b8c0e": "cancelOrder(address,uint256,address,uint256,uint256,uint256,uint8,bytes32,bytes32)", "0xfac34ff6": "throwFoo()", "0x6d98e9fc": "totalWei()", "0xb0bcc610": "scheduleTransaction(address)", "0x665bcc32": "ProcessGames(uint256[],bool)", "0x3fd1f232": "LookAtAllTheseTastyFees()", "0xdd727ea6": "runJackpot()", "0x0acc4382": "getMinDailyWithdrawLimit()", "0x46b207b8": "checkExpiry()", "0xde5d953a": "logSingleIndex(bytes,bytes,uint256)", "0xf504e0da": "load_level(uint16)", "0x4b63e601": "scheduleCall(address,uint256,bytes)", "0x4a71d469": "collectRev()", "0x80db79d9": "StructAndFor()", "0x090637a1": "GetPart(bytes,uint256)", "0xc003b082": "getMyPlayerID()", "0x00a7d6b3": "checkTransferFromToICAP(address,bytes32,uint256)", "0xdcf8113e": "campaignEndedSuccessfully()", "0xd1af8a5a": "LinkerExample()", "0x01fd89a4": "getFlags(bytes20)", "0xa39a45b7": "replaceOwner(address)", "0x0a3b1cd2": "setHotwallet(address)", "0x075fe877": "scheduleCall(address,bytes,uint256,uint256)", "0x3e5fd9b5": "dEthereumlotteryNet(address,address,bool,address)", "0xa6403636": "resolve(uint8,bytes32,bytes32,bytes32)", "0x0b2acb3f": "add(address,bytes)", "0x6d522b19": "multiAccessChangeRequirementD(uint256,address)", "0x4311de8f": "ownerWithdraw()", "0xa99e7e29": "register(bytes,address)", "0x1ed6f423": "changeDescription(address,string)", "0xcd50d44f": "CheckRepresentment()", "0x4c0e207a": "__outputCallback(uint256)", "0xea8a1af0": "cancel()", "0x67387d6b": "testThrowCreateWithNonceExistingNonce()", "0xdc583801": "doubleyour5()", "0xb8077e28": "getTxOrigin()", "0xbfbc793c": "computeNameFuzzyHash(string)", "0x79baa8a9": "BasicIncome_CoFund()", "0xf4dbeb9d": "getCredRanksByContents(address,uint256[])", "0x227185d6": "Send1Get2()", "0x75c4aaa6": "addUnderDog(uint256)", "0xa7abc124": "activate(bool,bool)", "0x8df554b3": "Dividend()", "0x092b25e9": "setOwner(string,address)", "0x67af26fb": "transferOtherFrom(address,address,address,uint256)", "0x4bb278f3": "finalize()", "0xd1e15045": "sendBack()", "0xa4699cad": "resetWithdrawls()", "0xb61d27f6": "execute(address,uint256,bytes)", "0x9772c982": "scheduleCall(address,bytes4,bytes,uint256,uint256)", "0x1b3a8e6f": "directionCount(int256,int256,int256,int256)", "0xd499555b": "getFirstActiveDuel()", "0xb738169c": "betOnOddEven(bool,bool)", "0x411c4e72": "ModifyFeeFraction(uint256)", "0x06f36cc9": "helpBlue()", "0x9e65c7e5": "updateLatestRevision(bytes20,bytes)", "0xb47fa7e0": "DepositLimit(uint256)", "0xf1736d86": "m_dailyLimit()", "0x62ea82db": "bids(address)", "0x4166c1fd": "getElevation(uint8,uint8)", "0x8702735c": "setCapitol(uint256,uint256)", "0x3cc7790a": "GSI()", "0x83f6d9a4": "validateNameInternal(string)", "0x8d99b2eb": "endPoll()", "0x8bbda7e3": "setContent(string,bytes)", "0x52efea6e": "clear()", "0x2581c674": "testBitsOrFailIndexOOB()", "0x05d87fe2": "issueLetterOfCredit(uint256,uint256,uint256)", "0xcbf0b0c0": "kill(address)", "0xf83d96c1": "InsuranceAgent()", "0x8dd5e298": "canEnterPool(address)", "0x2d580ef6": "add(address,bytes32)", "0xeeda149c": "Register(address)", "0xcc25decd": "SampleOffer(address,bytes,uint256,uint256,uint256,uint256,uint256)", "0x428d64bd": "getShares(address,bytes32[])", "0x3c9a4baa": "requestOutput(bytes)", "0x8cae1374": "editBlock(uint8,uint8,uint256,int8[5])", "0x419db07b": "generousFee()", "0x202e3924": "getOperation(uint256)", "0x5ee345e4": "computeEndowment(uint256,uint256,uint256,uint256,uint256,uint256)", "0x7df23b6a": "ReleaseOracle(address[])", "0x9b2ea4bd": "setAddress(string,address)", "0x65093661": "newCommunity(address)", "0x33637d5a": "getPendingBlock(uint256)", "0x7910085d": "fipsIsRegistered(bytes20)", "0x730720b8": "testControllerValidTransfers()", "0xb0c80972": "setBalance(uint256,bool)", "0xdcf537b1": "multiply7(int256)", "0xdf5cc291": "get4(bytes,uint256)", "0x9ae4e388": "ChangeClientTokenAccount(address,bool)", "0x3121369d": "validateRequiredStackDepth(uint256)", "0x1747dfd4": "ContractPlay()", "0x598647f8": "bid(uint256,uint256)", "0xc368109c": "monster_hp(uint256)", "0x7fa22001": "assertEq0(bytes,bytes,bytes)", "0x8e280dce": "findNextYear(uint256,bytes)", "0x39d1f908": "actualBalance()", "0x8143f8a8": "totalGas(bytes)", "0xfe55932a": "setName(uint256,string)", "0x0fbf7151": "startsWith()", "0x4f20f35a": "payExpenses(address,uint256)", "0x705eeb90": "MultipleConstructorTest(bool)", "0x2df8e00d": "becomeMortal(uint256)", "0x645dce72": "updateRelease(uint32,uint32,uint32,bytes20,bool)", "0x1f6e5117": "getCallbackAddress()", "0xf51cbc72": "Level()", "0x64edfbf0": "purchase()", "0x35930e13": "setMinimalRewardedBalance(uint256)", "0x015e4f3a": "getConfigUint(int256,bytes)", "0x2c329e99": "Last_block_number_and_bloctime_used()", "0x6f3a7561": "SimpleAuction(address)", "0x6de00927": "GetUserRank(uint8,address)", "0xbe600276": "move(uint16)", "0x27d6c032": "unregister(bytes)", "0x4188d79c": "releaseExists(string,uint32,uint32,uint32,string,string)", "0x7ba38916": "changeAdminFromBoard(address)", "0x3369dace": "flipTheCoinAndWin()", "0xfa8dc33a": "checkRecordExists(bytes)", "0xebaf7f2f": "returnReward(uint256)", "0xc88961da": "createKingdom(string,address,address,address)", "0x21970c0c": "pay_royalty()", "0xb4a5ef58": "updateDefaultTimeoutPeriod(uint256)", "0x57bcccb6": "revokePermanentApproval(address)", "0xd1d1c8ae": "ConvertNumbers(bytes)", "0xc1c0e9c4": "exec()", "0xcc131be1": "CreateNewDraw(uint256)", "0x75f96ead": "Guess(uint256)", "0x8a5fb3ca": "currentFeePercentage()", "0x550bcd8d": "testThrowUpdateLatestRevisionEnforceRevisions()", "0xa6780857": "fireEventLog0Anonym()", "0x2d0104a5": "updateFirstDuel1(uint256)", "0xcbf1304d": "balances(address,uint256)", "0xdda9939c": "Store(address[])", "0xf41bfa9e": "mint(int256,uint256,string)", "0x044215c6": "token(uint256)", "0x1f903037": "getBytes32()", "0xa6f9dae1": "changeOwner(address)", "0xf9391d24": "AllPayAuction()", "0xabebb7f3": "MarketsContract()", "0x9e1e6528": "uncertify(address)", "0x81788e2b": "addAllowedAddress(address)", "0x4f44728d": "ownerChangeOwner(address)", "0x3da0ac79": "compare()", "0x96e438a1": "reclaimDeposit(uint256)", "0x5fe22c8b": "testFailTransferWithoutApproval()", "0x6835f32c": "build(bytes)", "0x5cac8b27": "amazing()", "0xad605729": "getParticipantCount()", "0xb6294bde": "AdminGetFee()", "0xec81e22e": "returnmoneycreator(uint8,uint256)", "0xc535165f": "revealAndPayout(bytes,bytes)", "0x6e0bd282": "destroy(bytes32)", "0xdda44b10": "buyRecipient(address,uint8,bytes32,bytes32)", "0xd4859dbc": "UniversalFunctionSecure(uint8,bytes32,bytes32,bytes32,bytes32,bytes32)", "0xd2602930": "RockPaperScissors()", "0xa08b3367": "EC()", "0x92d66313": "getYear(uint256)", "0xe49dcee9": "fixTokens()", "0x36555b85": "add(string,uint256)", "0x25010816": "get_length(uint256,uint256)", "0x610d5de8": "validateEndowment(uint256,uint256,uint256,uint256,uint256)", "0x79ce9fac": "transfer(bytes32,address)", "0x3ced516c": "descriptionHashes(bytes32)", "0xcf69df28": "getDataRequestLength()", "0x706dfe54": "getIssueState(uint256,bytes32)", "0x5af77fff": "Contract()", "0x66e5cb50": "stopTransfer(uint256)", "0x5f72f450": "check(uint256)", "0xf3b50c04": "rescind()", "0x57aee888": "_eraseNodeHierarchy(uint256,bytes32[],bytes32)", "0xaacc5a17": "getRandom()", "0x40275f85": "getPersonalDepositAddress(address)", "0x75700437": "query1_withGasLimit(uint256,string,string,uint256)", "0x6eb7b4c2": "underdogInfo(uint256)", "0x0f3eb785": "add(string,uint256,uint256,uint256)", "0xdc19266f": "Total_of_Players()", "0x9743dfc1": "jesterAutomaticCollectFee()", "0x6618b008": "cancelSellOrder(address)", "0x65538c73": "fireEventLog0()", "0xa4502cb8": "setExportFee(address,uint256)", "0x97bb2a63": "newvow(uint256,address)", "0xb400d149": "betOnNumber(uint8)", "0x030d406b": "entryPayout(uint256)", "0x1d71a1cd": "newIncome(string)", "0x85dd2148": "getSaleDate(bytes16)", "0x29917954": "exitPool()", "0xa25057de": "_transferToICAP(bytes32,uint256)", "0x24fc65ed": "getId(uint256,uint256)", "0x938199a5": "getDateOfLastPayment()", "0x04bb754c": "TradeFinancing()", "0xe37aa618": "distributeValue()", "0x547916ea": "finishRound()", "0xed01bf29": "budget()", "0x95ee1221": "isCancelled()", "0xfe777bcd": "etherForSale()", "0xffe302d1": "setPlz(string)", "0x891de9ed": "fromTLA(string)", "0x84734476": "copyBytes(bytes,uint256,uint256,bytes,uint256)", "0xfb114f57": "oraclize_query(uint256,string,string[3],uint256)", "0xceebe28d": "repoInterfaceVersion()", "0xb0ad38c4": "buildCity(string,uint256[2],uint256[2])", "0xefa7e56b": "GameEnds()", "0xcc3471af": "maxClaimBlock()", "0xa7c5052e": "buildDSTokenRegistry()", "0x6831c169": "totalPayedOut()", "0x98f3b81a": "getShares(address,bytes32[],int256[])", "0x2d077ad0": "Latch()", "0x0ac28725": "requestTradeDeal(uint256,uint256,string)", "0xb311ee0c": "refundClaimDeposit()", "0xadd82871": "strEqual(string,string)", "0x7879e19e": "CollectAllFees()", "0x5bd74490": "regProxy(address,address)", "0xd2b0d554": "getDisclaimer()", "0x0b74edc6": "testFinalHash()", "0x6cf761d4": "getMinConfirmationsByAddr(address)", "0x4cedf74e": "get_party1()", "0x4adcbd19": "isThisHardforkedVersion()", "0xefdecd9b": "check_withdrawdao()", "0x996a8046": "__callback(bytes32,string,bool)", "0x7c9cd7df": "changeDeveloper_only_Dev(address)", "0x3f77b560": "newDocument(bytes)", "0x06b5f02d": "calcWinnings(uint256,uint256)", "0x0a2282ae": "JackPot()", "0x378a2178": "tallyVotes()", "0xd8915fc5": "DCAssetBackend(bytes32,bytes32)", "0x0f590c36": "emergencyFixGameResult(uint64,uint256)", "0xea4af029": "ConferenceCertification()", "0x769dc523": "GetCategoryNumber(bytes4)", "0xd5df7559": "removeDocument(uint256)", "0x749aa2d9": "endRound()", "0xd8e5ae6a": "Etheramid()", "0xc0576b73": "monsters(uint256)", "0x32fefb4c": "add_account(address,address)", "0x7d619d9b": "holdCoin(address,address)", "0x5b067cce": "testCreateCostMain()", "0x384b1393": "follow(uint256)", "0x4162169f": "dao()", "0x5d8227e6": "FactoryBase(string,string,string)", "0x6bf52ffa": "Vote()", "0xeb5904c0": "setProfitDistributionContract(address)", "0x366a68dc": "setBlockLock(uint256)", "0x80d9eaa6": "refCount()", "0x89b8b492": "read(uint64)", "0x46b5e202": "set_num_levels(uint256,uint256)", "0xd96de4ce": "AdminDrawError()", "0x47b47102": "bakeCookie(string)", "0x1d7b5baf": "setUint(int256,bytes32,string,uint256)", "0x0699d07d": "updateMaxVal()", "0xfa544161": "getOwner(address)", "0x638560cf": "registerBool(address,bool)", "0x7c25f260": "Government()", "0x24a852c6": "unset(bytes)", "0xa32f0f41": "testFailControllerUnapprovedTransferFrom()", "0x0968f264": "withdraw(bytes)", "0x5f52e9fd": "WithdrawCashForHardwareReturn(uint256)", "0xc0f68859": "getMinimumGracePeriod()", "0x1bf6c21b": "USD()", "0x0fe234ed": "testSetController()", "0x05a17fc6": "getAccountFeed(address,uint256,uint256,uint256)", "0x673448dd": "isApproved(address)", "0x59dac714": "hashTo256(bytes)", "0x5a09f2f4": "setHouseFee(uint256)", "0x013cf08b": "proposals(uint256)", "0xeebf9808": "PiggyBank()", "0xadd43c59": "EtherTopDog()", "0xf909d60d": "getMinimumGasLimit()", "0xeb045789": "ChannelSeries(address)", "0x66d38203": "setup(address)", "0xe8641652": "strCompare(string,string)", "0x1959a002": "userInfo(address)", "0x737c8ea1": "_getRevisionBlockNumber(bytes32,uint256)", "0x127714c7": "getBudget()", "0x97daa043": "register(bytes,address,address,uint256,bytes)", "0xb5784f6f": "testMultiplePackages()", "0x0ce46c43": "scheduleCall(address,bytes4,bytes,uint16,uint8,uint256[5])", "0xe5782fd5": "setFeeStructure(uint256,uint256,uint256)", "0xa9f6def0": "HonestDice()", "0xeb7cdb56": "rankDown(uint256,uint256)", "0xb17b94c1": "testSystem()", "0xdd36e18b": "ContractStatus()", "0xee0dc478": "testSetEnforceRevisions()", "0x918359c6": "needsBirth()", "0xa5b1e13d": "settle(address,address,uint256,uint256)", "0x6b76484e": "swap(address,address)", "0x68402460": "scheduleCall(address,bytes4,uint256,uint256,uint8,uint256)", "0x733480b7": "transferToICAP(bytes32,uint256)", "0x567dbf18": "__forward(address,uint256,uint256,bytes)", "0x73e1743a": "buildDSBasicAuthority()", "0x482961e1": "updateReading(uint256,uint256)", "0x4e6ba0a9": "testCreateCostMultisig()", "0x8d7108e5": "isValidLocation(uint8,uint8,int8[5],int8[24])", "0x10142785": "assign(bytes,uint256,bytes1)", "0xfe97ee88": "hasPhone(address)", "0xe2861c8d": "cashOutProfit()", "0x0fa9ced4": "emergencyFuneral()", "0x8389f353": "setNumCities(uint256)", "0xdba1ac3d": "getEnforceRevisions(bytes20)", "0x1b4fa6ab": "getDefaultStackCheck()", "0x79be02af": "Read(address)", "0x70844f7a": "sendBadge(address,uint256)", "0x7bfaad96": "addNode(bytes,address)", "0x4d782cbc": "executeSellOrder()", "0xbe71248a": "payWinner()", "0x41304fac": "log(string)", "0x4f059a43": "getClaimAmountForBlock()", "0x6d2cb794": "airaTransfer(address,address,uint256)", "0x5a5383ac": "canExitPool()", "0xcabd27de": "Motion(address)", "0x433d4aab": "resolve(uint8,uint8)", "0x7d89ae63": "__findRef(string)", "0x4e1053cc": "RobinHoodPonzi()", "0x0220a5b4": "terminate(string)", "0x419ffa03": "fipsRegister(address)", "0x77a7e6be": "getRefTotal(uint256)", "0xed64bea4": "JamCoin()", "0x3cf885c4": "isBitSet(uint256,uint8)", "0xf2da67db": "setMany(uint256,int256,uint256,bytes20,address,bytes)", "0xe26c8434": "AdminStartDraw(string,bytes)", "0x13df7091": "mintAll(int256)", "0x8a46bf6d": "testFallback()", "0x29bed3bf": "EthereumRoulette()", "0xf869b11a": "declareVictor(uint256,uint256)", "0x45c41478": "getMarkets(bytes,address)", "0x90cf581c": "voteYes()", "0x9ec35352": "returnRandom()", "0x5025b9ae": "expire(uint256,uint256,uint8,bytes,bytes,bytes)", "0x338a1379": "_setPackedBlockNumber(bytes20,uint256)", "0xdb641ab4": "Game_balance_in_Ethers()", "0xbc0e7adb": "testThrowsDisownNotOwner()", "0x302d350e": "firstChainedCallback(uint256)", "0x5af73f3f": "getMinimalBalance(uint256,address)", "0x4c488dac": "getChannelValidUntil(bytes)", "0xa1616429": "testBitOrSuccess()", "0xaa64c43b": "transferPool(address,address,uint256)", "0x78e97925": "startTime()", "0xa0355f4e": "decline(uint256)", "0x02556de3": "updateMajorTree(bytes32)", "0x01984892": "name(address)", "0xfad4b99a": "updateChannelMinimum(address,uint256)", "0x4f39ca59": "drop(bytes32)", "0x61591a7c": "personUpdateDOB(uint256,int256)", "0x17b3a34b": "_addIdentities(uint256,bytes32[])", "0x91d8b14e": "BuyTickets()", "0x1aadcc34": "convertGreyGreen(uint8,uint8)", "0x9a863892": "NewProposal(uint256)", "0xc5487661": "proxyTransferToICAPWithReference(bytes32,uint256,string)", "0x85f8c16d": "claimHours(int256)", "0xa71f94c8": "scheduleSetUInt(address,uint256,uint256)", "0x7ef09476": "transfer(uint64,address)", "0x94bcdb4c": "Example2()", "0x37930615": "extend(bytes16[],uint64)", "0xfb09b1ac": "testBalanceOfReflectsTransfer()", "0x19a278b9": "getBAddress()", "0xc0a239e3": "valuePerShare()", "0xa039e3c7": "testSetNotTransferable()", "0x22593300": "Small(address)", "0xe21608be": "ReserveToken()", "0xc2985578": "foo()", "0xb463bcde": "testThrowsSetNotTransferableNotOwner()", "0x88d695b2": "batchTransfer(address[],uint256[])", "0x37b0574a": "isClassic()", "0x1da6822c": "testThrowsTransferEnableNotTransferable()", "0xdcfa9cc0": "testProxyCall()", "0x478aa69e": "unauthorizeUser(address)", "0x102accc1": "fireEventLog2()", "0xed62cf1f": "setCanCall(address,address,bytes,bool)", "0x15f73331": "invalidateName(string)", "0x73e30e49": "majorEventFunc(uint256,bytes,bytes)", "0x00c721ab": "setHand(uint256)", "0xf9e27106": "investmentEntryCost()", "0x4c7f74df": "EtherDelta(address,address,address,uint256,uint256,uint256)", "0xb74e452b": "today()", "0xd3118a5a": "addDoc(string,string)", "0xc204f9f1": "_transferFromToICAP(address,bytes32,uint256)", "0xf50d3914": "resetFoundationtList()", "0xe67cdfb7": "moveOldUser(uint256)", "0x98eaca94": "inKissBTC(uint256)", "0xc633084f": "sendGreeting(address,string)", "0xde10f04b": "eraseNode(bytes32[])", "0xd50495f4": "addTransaction(bytes)", "0x96cff3df": "getMinimumCallCost(uint256,uint256)", "0xce373b95": "heroOfThePit()", "0x39e525f9": "resolveCallback(uint256)", "0x942b90d3": "getRewardTable()", "0xedca914c": "buyTicket()", "0x5fcb568c": "release(string,uint32,uint32,uint32,string,string,string)", "0x6c9c2faf": "getSupply()", "0xf1448e10": "requestExecution(bytes)", "0x0c08bf88": "terminate()", "0x08aba5aa": "setAccountBalance(uint256)", "0x2c46d8d5": "EndRound(uint256)", "0x3d5db1c2": "incrUserOnholdBal(address,uint256,bool)", "0xf2f254c7": "getLatestMinorTree(bytes32,uint32)", "0x373a1bc3": "scheduleCall(address,bytes4)", "0x3a96fdd7": "compare(string,string)", "0x738ddabe": "getContentIndexedAccountCred(uint256,address,address)", "0x5acce36b": "getEndowmentBalance()", "0x1ca60aeb": "setMeltingContract(address)", "0x52375093": "m_lastDay()", "0x565a2e2c": "getBeneficiary()", "0x9d5c6061": "getMsgGas()", "0x41d31feb": "get_read_only_keys()", "0x796b89b9": "getBlockTimestamp()", "0x4a41e045": "getUint8(int8)", "0x38e48f06": "save(string)", "0x1cda37f2": "eraseRecords(bytes32)", "0xae978f08": "getLatestTweet()", "0x20909fa0": "communityCurrency()", "0xafbec8df": "TheGrid()", "0x1c14179a": "GavCoin()", "0x0b6142fc": "breach()", "0x3ab1e703": "roundMoneyDown3SF(uint256)", "0x414ceac0": "investorAddFee(uint256)", "0x82a62137": "activateAccount(address)", "0x4ca7fbd0": "updateTokenPriceWeekTwo()", "0x2551858e": "getFlags(bytes32)", "0x4ad07b0e": "oracleOutcomes(bytes32,address)", "0x60b431a4": "testGetSig()", "0xa5f8cdbb": "buyTicket(address)", "0x64aabe92": "tryExec(address,bytes,uint256)", "0xa6c01cfd": "isInGeneration(uint256)", "0x149c5066": "ChanceOfWinning(uint256)", "0xc068eae0": "player_collect_winnings(uint256)", "0x8129fc1c": "initialize()", "0xcf832ce2": "ownerRefundPlayer(bytes32,address,uint256,uint256)", "0x3517a740": "getNodeParent(bytes)", "0xec6afc22": "oraclize_query(uint256,string,string[3])", "0x50944a8f": "setMembership(address)", "0x85b1423e": "returnAll()", "0xd95a2d42": "lendGovernmentMoney(address)", "0x347632e8": "getShareholderAdressByID(uint256)", "0xbb39a960": "trade(address,uint256,address,uint256)", "0x8abadb6b": "setAccountLevel(address,uint256)", "0xa502aae8": "getNextGenerationId()", "0xb5bfdd73": "addDSource(string,bytes1,uint256)", "0x28d3ad3f": "getPot(uint256)", "0x08933d11": "getJoinBlock(address)", "0x8383bfc8": "EscrowFoundry()", "0x2ca15122": "sign()", "0xf340fa01": "deposit(address)", "0x9ed93318": "create(address)", "0xa1c0539d": "scheduleCall(address,bytes4,bytes)", "0xced92670": "changeMultiplier(uint256)", "0xb2c652f3": "getMarkets(uint256[128])", "0x69b144eb": "testThrowsCreateNewRevisionNotOwner()", "0x16c72721": "forked()", "0x712ca0f8": "getOrder(string)", "0x0cf45ba5": "updateFirstDuel2(uint256)", "0x4173b181": "setWeiPrice(uint256)", "0x689b3e2d": "Moonraker(address,address)", "0x8691162a": "TlcCoin()", "0x432ced04": "reserve(bytes32)", "0x38178fbe": "addString(string,string)", "0x8f1327c0": "getRound(uint256)", "0xa9eed530": "reduceOrderQty(uint256,uint256)", "0x408938d0": "testUpdatePackageDb()", "0x56105a08": "DgxSwap()", "0xc43d0575": "scheduleCall(bytes4,uint256)", "0xdba21657": "askForEther(uint256)", "0xca3b5c91": "hasRelation(bytes,bytes,address)", "0xc71cbcf3": "recoverAccount(address,address)", "0xb010d94a": "canExitPool(address)", "0x0a16697a": "targetBlock()", "0xff1f7046": "requiresAuction(string)", "0x0b811cb6": "executeProposal(uint256,bytes32)", "0xbb8be064": "HardwareToken()", "0xe2b05077": "getSaleDate(bytes,uint256)", "0x1e9a6950": "redeem(address,uint256)", "0xd21b84ac": "createNewDAO(address)", "0xd644e356": "index(uint256,address,uint256,uint256)", "0xea27a881": "getMinimumEndowment(uint256,uint256,uint256,uint256)", "0x99a88ec4": "upgrade(address,address)", "0xc8e4acef": "playerByAddress(address)", "0x0b7abf77": "TOTAL_TOKENS()", "0xfb5d7376": "step4()", "0xc0aa18e7": "History()", "0xe2233ada": "smartDoor(address[])", "0xd6006e88": "send(address[],uint256[],uint256)", "0x95671958": "getFileListTail()", "0x16bac350": "overthrow(string)", "0x5cb18a6d": "fipsLegacyRegisterMulti(bytes20[],address,bytes)", "0x60116397": "Registrar(address,bytes32,uint256)", "0x60fe47b1": "set(uint256)", "0x5f8f0483": "buyBankerAgreementFromImporterBank()", "0x4c8cc20b": "toContentID(address,string,string,address,uint256)", "0x45ca25ed": "changeName(address,string)", "0xb21bce4c": "vote(bytes,bool)", "0x334dc700": "CanaryV7Testnet()", "0xc31d0031": "CrowdFundDAO(string,uint8,string)", "0xf3d91708": "isEligibleForUpgrade(address)", "0x0ee07836": "adjustDifficulty(uint256)", "0xf6232556": "Security_GetNumberOfAttemptsToConnectBankAccountToANewOwnerAddress()", "0xb2d37e95": "remove_order(uint32)", "0x691d58e7": "_applyRefund(uint256)", "0x1c2353e1": "isCertifier(address)", "0xcf158fe9": "scheduleTransaction(uint256,uint256,uint256)", "0x5d96ec65": "setAdministrator(address,string,bool)", "0x0651844e": "activateBalance(address)", "0x217311ac": "getWords(uint64)", "0xc127c247": "addMember(address,string)", "0x40c0bcb9": "checkBetNumber(uint8,address,bytes32,bytes32)", "0xb633620c": "getTimestamp(uint256)", "0x5b764811": "_jMul(uint256,uint256,uint256,uint256)", "0xfe029156": "swap(address,address,uint256,uint256)", "0x31db4b95": "doTriggerAuth()", "0x203c03fa": "Coinflip()", "0x209a5b8a": "moneySumAtSettlement(address,uint256,int256,uint256)", "0xf10ae2ab": "__dig_then_proxy(uint256,address,bytes)", "0xd532e481": "activateFrozenAccount(address)", "0xe9a9c1b4": "get_party1_balance()", "0x8fcc9cfb": "setMinDeposit(uint256)", "0xe5c7e509": "testThrowTransferDisableNotEnabled()", "0x4e077f2a": "addGasEther()", "0xb7c93330": "ResourcePoolTester()", "0x82661dc4": "splitDAO(uint256,address)", "0x0e554bd8": "scheduleCall(bytes,uint256,uint256,uint8)", "0x49041903": "getGame(uint64)", "0x0e1da6c3": "claimTimeout()", "0xc53ad76f": "Kardashian()", "0x8b7bcc86": "numWinners()", "0x1043dcdf": "LastIsMe(uint256,uint256)", "0x6cd22eaf": "updateAuthority(address,bool)", "0xb796a339": "addRegistryIntoOwnerIndex(address,address)", "0x308d6613": "getSignData(uint256,uint8)", "0xed88c68e": "donate()", "0xb719d1d0": "getRegInfo(address)", "0xac8d6030": "removeRequest(address)", "0x46f0975a": "signers()", "0x434cb64c": "startNextGeneration()", "0x6cb3d30a": "triggerTryAuth()", "0x3c067945": "fundBalance()", "0x26c7edaa": "flip4(bytes)", "0xf76f950e": "uint2str(uint256)", "0x860e9960": "BetPriceLimit()", "0xb0ecca8f": "LookAtLastTimePerZone(uint256)", "0xa35cfa22": "make_move(uint256,uint8,uint8,uint8,uint8)", "0x3f74fecb": "DSTrueFallbackTest()", "0xdd2ad311": "scheduleCall(bytes,uint256)", "0x0ae5e739": "grantAccess(address)", "0x7d5fec5a": "setOwner(uint8,uint8,address)", "0x6a4b6aa5": "untrustedChildWithdraw()", "0x332f93a9": "nextPayoutGoal()", "0xc5ae6e0e": "Kernal()", "0x75438e49": "fillGas()", "0x51404cbe": "forceDivestOfOneInvestor(address)", "0xeacfc0ae": "Authorized()", "0xe59d843a": "Replicator(bytes,uint256,uint256,address)", "0xf00e8651": "createRequest(address[2],address,uint256[11],uint256,bytes)", "0x02acdb44": "setAnyoneCanCall(address,bytes4,bool)", "0x2a24f46c": "auctionEnd()", "0x7ef1925b": "getShareRange(uint256,uint8)", "0x2fac1a54": "newOrder(bool,uint256,uint256,uint256,uint256)", "0x56b8c724": "transfer(address,uint256,string)", "0x33fd066d": "doBalanceFor(address)", "0xf29617da": "registrationDeposit(address)", "0x2b297f9e": "registerDao(address)", "0x79cce1c5": "getReleaseHashes(uint256,uint256)", "0xbed1b8b9": "convertToInt(string)", "0xef5daf01": "_dumpToCompany()", "0x23dc42e7": "query1(uint256,string,string)", "0xa53b1c1e": "setInt256(int256)", "0xb8cf14e7": "updateStatusPlayer()", "0x61aa8d93": "processFee()", "0x10f41715": "updateMintingData(uint256,uint256)", "0x048e2e94": "getAccountSize(address,uint256)", "0x7c47965e": "isInCurrentGeneration()", "0x420a8ac8": "NanoPyramid()", "0xe56556a9": "getPlayerID(address)", "0x5cd2f4d3": "approve(address,bytes32)", "0x8da4d776": "newCommune(address)", "0x4d30b6be": "balanceOf(address,bytes32)", "0x4a606c53": "_db()", "0x4956eaf0": "deploy(address,uint256)", "0xf1fe42b8": "TransactionRequest(address[3],address,uint256[11],uint256,bytes)", "0x63e38ff3": "id_for_nym(uint256)", "0x0e757a2e": "testSetAndGet()", "0x3facd57c": "registerBill(uint256,address,address,uint256,uint256,uint256)", "0xe548cf13": "betOnColumn(bool,bool,bool)", "0x2f1e4968": "makeNewProposal(string,uint256)", "0x0b467b9b": "revoke(bytes)", "0x74bfb965": "addNewProxy(address)", "0x02de2cf3": "isLatestPreReleaseTree(bytes32,bytes32)", "0xfc1f7652": "_isBoardMember(address)", "0xefef39a1": "purchase(uint256)", "0x3ae9b510": "getLatestMajorTree(bytes32)", "0xc24924d6": "setQueryFee(uint256)", "0x839930ba": "getMinimumBet()", "0x8f5e9ca7": "acceptTOS(address,bool)", "0xd1100691": "BookCafe()", "0x839849c0": "changeBaseMultiplier(uint256)", "0x758971e8": "ownerTakeProfit(bool)", "0x2b785960": "testBitAndSuccess()", "0xd96a094a": "buy(uint256)", "0x379607f5": "claim(uint256)", "0x88e072b2": "checkTransfer(address,uint256)", "0x05fefda7": "setPrices(uint256,uint256)", "0xfc63d4fb": "order(bool,uint32,uint128)", "0x5718b994": "checkEvent(address,bytes,bytes,uint256)", "0x0c0662a8": "getLastWithdrawal()", "0xeb947f19": "ExampleResourcePool()", "0xb51c4f96": "getCodeSize(address)", "0x702fc7da": "ReviewModel()", "0xc6cb7a96": "orderMatchTest(uint256,uint256,int256,uint256,uint256,address,address,uint256,int256)", "0xb7760c8f": "transfer(uint256,address)", "0x32b12eac": "setFallback(address)", "0x0a4d564c": "TieUpLooseEnds()", "0xc3ad5ecb": "getTweet(uint256)", "0xe86afde0": "description(uint64)", "0xd0549602": "scheduleTransaction(address,uint256,uint256,uint256)", "0xbf2e694f": "getPreviousRequest(address,address)", "0x2525f5c1": "cancelBid(address,bytes32)", "0x19f02ceb": "set(address,address,uint256)", "0xf00acc47": "prepareRoll(uint256,uint256)", "0x29d28aad": "Broker(address)", "0x041d0c0b": "MyTokenLoad(uint256,string,uint8,string,address)", "0xd81ab0c1": "invoke(uint256,address,address,bytes)", "0xab09ee80": "respond(uint256,uint256,uint256,uint256)", "0xd985f122": "RelayToolsTest()", "0xbe0638e4": "WealthShare()", "0x5263ba87": "getLatestPatchTree(bytes32,uint32,uint32)", "0xb7bae9b7": "exists(bytes,bytes)", "0x0b80f8d3": "invmod(uint256,uint256)", "0xbb4d7cd1": "tag(uint256,string)", "0xadf54e0c": "betOnLowHigh(bool,bool)", "0xed54746e": "lastAuction()", "0xf158458c": "getMinimumEndowment(uint256,uint256)", "0x5fcc2edb": "IndividualityTokenRoot(address)", "0x7cc48875": "Slots()", "0x2885b593": "extractMasterKeyIndexLength()", "0x8940aebe": "publicKey(uint256)", "0x0aece23c": "getFeeAmount(int256)", "0x72c3015c": "mint(int256,address,string)", "0xd6a619e3": "transferIfPuritanical(address)", "0xe30443bc": "setBalance(address,uint256)", "0x1277e24f": "payOneTimeFee()", "0xb958a5e1": "getPhoneByAddress(address)", "0x4e71d92d": "claim()", "0x3e0d4f4a": "ApproveContractorProposal()", "0x18160ddd": "totalSupply()", "0x150ad2a8": "owner_transfer_ownership(address)", "0xa2b5591c": "oraclize_query(uint256,string,string[],uint256)", "0x8d227fc0": "getPeriodInfo()", "0x1c0b6367": "processTransaction(bytes,uint256)", "0xf245b9e4": "DVIP(address)", "0x392327b5": "owner_set_fraction(uint256)", "0xadaccd74": "getNickname(address)", "0x2e0ef395": "voteOnNewEntryFees_only_VIP(uint8)", "0x89c19ddb": "concat(string,string)", "0xcef8d343": "buyShare(uint256,bool)", "0xd224118f": "PrepareDraw()", "0x4269d8ef": "_safeSend(address,uint256)", "0xda1441cd": "KudosBank(uint256)", "0x7ccfd45a": "removeSubUser(address)", "0xcc70bb1a": "publish(string,string,string,address)", "0x708f29a6": "getTotalPayments()", "0x05459f42": "WeeklyLotteryB(address)", "0x452d44dc": "checkBothNotNull()", "0x659fb968": "getOracleOutcomes(bytes32[],address[])", "0x3570c2ee": "PosRewards()", "0xbca86986": "testSetup()", "0xff49b26e": "createEvent(uint256,uint256,uint8,uint32,address,uint256,uint8)", "0x541d920c": "commit(bytes,string)", "0xa6a20ff6": "DSEasyMultisig(uint256,uint256,uint256,uint256)", "0x0f5381f1": "testUserCanIncreaseVersionNumber()", "0xf8f46b5f": "getCurrentMinerAddress()", "0xfcfff16f": "open()", "0x5a9b0b89": "getInfo()", "0xb8017221": "get_party2_balance()", "0x514dcfe3": "seller_accept()", "0x2004dff6": "Basics()", "0x0b6d8d52": "createDAO(address,uint256,uint256)", "0xf18d20be": "adminWithdraw()", "0x8f9df278": "newEntry(int256,bool,uint256,int256,string,bytes32,address,uint256[])", "0x75949c13": "sendHalf(address)", "0x64ac2c4a": "WavesPresale()", "0x8946d33f": "SplitterEthToEtc()", "0x11400d8e": "priv_fastGetBlockHash__(int256,int256)", "0x7266f4a4": "X3()", "0xb189ad2a": "testErrorUnauthorizedAfterTransfer()", "0x31c2bd0b": "propose(address,bytes,uint256)", "0x100c8ada": "setCAmodulus(bytes)", "0x296ed88f": "testFailControllerInsufficientFundsTransferFrom()", "0xd5dbb1ad": "solveBet(address,uint8,bool,uint8,bytes32,bytes32)", "0x8a9ffb90": "transfer(string,string,bool)", "0x968908a3": "createMarketMaker(uint256,uint16,uint256)", "0x7b02b2c9": "sendMsg(address,string)", "0xa33dd801": "setTreasuryBalance(uint256)", "0x2f553d31": "isCreated(bytes32)", "0xf712d7ff": "testFailControllerTransferFromWithoutApproval()", "0xe51ff1fc": "iterateOverThings()", "0x60fd902c": "gnosisToken()", "0x2ef875fb": "div10(uint256,uint8)", "0x640f244b": "findSuitableGen()", "0x16cb9a01": "assertFalse(bool,bytes)", "0xe671f510": "onEtherandomExec(bytes32,bytes32,uint256)", "0x758b5172": "setPlayersPerRound(uint256)", "0x6423db34": "Reset()", "0x21958a50": "AddressSeries(address)", "0xfb87d5ea": "TransactionRequest(address[4],address,uint256[11],uint256,bytes)", "0xfb279ef3": "tip(uint256,address,uint256)", "0x338cdca1": "request()", "0x4e7ad367": "fireEventLog1Anonym()", "0xbd9335c0": "scheduleHangouts()", "0x4cb85356": "BranchSender(uint256,bytes32)", "0x1d7e1f68": "getContentRank(address,uint256)", "0x1a1df394": "Play(bool)", "0x468129a5": "setUnit(uint256,uint256,uint256)", "0xecb70fb7": "hasEnded()", "0x2d49ffcd": "getLocked()", "0x2e06c756": "post(string,string,string,uint256,uint256,address)", "0x73f93a48": "getAccountContentTip(address,uint256)", "0xf6a3d24e": "exists(address)", "0x5fbddcf3": "isLivingMonarch()", "0x6d568c43": "weiToCents(uint256)", "0xacf4280c": "buildDSApprovalDB()", "0xf3541901": "execute(address,bytes,uint256,uint256)", "0x88eb7af7": "_isHuman()", "0x48a490fb": "transferFromTreasury(address,uint256)", "0x5e03d393": "setAccountFrozenStatus(address,bool)", "0xfc687311": "betOn(int8)", "0x5bbfe9b6": "_myGroupHelper()", "0x5629c6d9": "doExecution(address)", "0xe3a9b508": "EnableDisableTokenProxy()", "0x9229c504": "new_mainPlayer(address)", "0x6f6c0244": "generateShortLink()", "0x33613cbe": "getBondBalance(address)", "0x4229616d": "collectPercentOfFees(uint256)", "0x4ed3885e": "set(string)", "0x043bb5e7": "getIdentities(address[])", "0xad2fea7c": "removeMinter(int256,address)", "0x0b7e9c44": "payout(address)", "0x17f5de95": "MAX_TOKENS_SOLD()", "0x50ea1932": "lookupISO3116_1_alpha_2(bytes)", "0x96f7807a": "getDuel2(uint256)", "0xa97ffd5e": "safeToSell(uint256)", "0x2f4ee5d4": "registerThrone(bytes,uint256,address,uint256,uint256)", "0x4c0bcfe5": "getTransferableBalance(address)", "0x0d17bc2e": "_disallow()", "0x0ca7395f": "returnFund(address,uint256)", "0x69fe0e2d": "setFee(uint256)", "0xfaf27bca": "greeter(string)", "0x0c7de59d": "edit(address,bytes,bool)", "0x16e27349": "getFeeRecipient(int256,int256)", "0x37751b35": "doTransfer(address,address,uint256)", "0x67fc1c6a": "validateProposedMonarchName(string)", "0xf59f99ee": "createNextGeneration()", "0x6be505f5": "selectWinner(bytes32)", "0xf6bd5893": "getGas(uint256)", "0x35b09a6e": "someFunction()", "0xb3aaa277": "validate(address[4],address,uint256[11],uint256,bytes,uint256)", "0x4f052648": "XaurumDataContract()", "0x117b4705": "retract(bytes32)", "0x2145e36c": "testBitSetFailIndexOOB()", "0x3d750b28": "found()", "0x1334a5e2": "eventCallback(uint8,address,address,uint256)", "0x3c2c21a0": "scheduleCall(address,uint256,bytes4)", "0x82996d9f": "rent()", "0xaf640d0f": "id()", "0xdaf22f4d": "identify(bytes32)", "0xfe4667e9": "getMaxLossAfterTrade(address,uint256,uint256,int256,int256)", "0xfc108f70": "GamblerPerAddress(address)", "0x89f4ed7a": "getLastTag(uint256)", "0xfcc11241": "addOrder(uint256,uint256,uint256,uint256,uint256,uint8)", "0x43243797": "fundsOf(address)", "0x892c0214": "NumberOfCurrentBlockMiners()", "0xb5a6c525": "extractFrozenAccountLength()", "0x1acb2719": "getNextRequest(address,address)", "0xa89a4f09": "creatorBalanceChecker()", "0x1e83409a": "claim(address)", "0x5e1d7ae4": "changeFeeRebate(uint256)", "0xb7482509": "deposit(address,string)", "0xfb47a067": "_getRevisionBlockNumber(bytes20,uint256)", "0x5dcdddd1": "testSafeToAddFix()", "0x9aa26f06": "registerBytes32(address,bytes)", "0xd085e66e": "GetPart(bytes32,uint256)", "0x2cd78450": "activateExportFeeChargeRecord(address)", "0x35d129f6": "untag(string)", "0x1a7a98e2": "getDomain(uint256)", "0x877653f0": "_storeBalanceRecord(address)", "0x446fbcd1": "CredSign()", "0xfae8f9a2": "setInitialParent(int256,int256,int256,int256,int256,int256)", "0xc1b056b0": "getNodeLeftChild(bytes)", "0x71f297cc": "XaurumToken(address)", "0xe3ffc9a3": "sendEtherToOwner()", "0xeccf1b29": "CrystalDoubler()", "0x57f4d5ec": "processDividends(address,uint256)", "0x75c589a0": "getMinimumCallCost()", "0x66772438": "computeResponse(uint16)", "0x7fefde53": "WillRegistry()", "0x8f4fb958": "calculateRandomNumberByBlockhash(uint256,address)", "0xed498fa8": "userTokens(address)", "0x5601eaea": "execute(uint256,uint256)", "0x8dd8596c": "sendDonation()", "0x15a0df43": "testThrowCreateNewRevisionNotOwner()", "0x0382c254": "CheckHash(uint8,uint8,uint8,uint8,bytes32)", "0x157f8f51": "feePaid(int256,int256,int256,int256)", "0xf00aac7f": "ArrayRR()", "0x7b7d7225": "_approve(address,uint256)", "0x54ed7b6e": "addHash(bytes)", "0x235c002d": "transferOther(address,address,uint256)", "0x7057c20d": "CFD(address)", "0xd5563f31": "createAuction(uint256)", "0x46c3166f": "testThrowRetractLatestRevisionNotOwner()", "0x4420e486": "register(address)", "0x9a969768": "distributeProfits(uint256)", "0x464f37c9": "trustedChildRefund()", "0x5d495aea": "pickWinner()", "0xdf55b41a": "owner(string)", "0x10e6e06c": "vote(bool,uint256)", "0xe7faecec": "testFailInsufficientFundsTransfers()", "0xea98e540": "proxyTransferFromToICAPWithReference(address,bytes32,uint256,string)", "0xfff78f9c": "doThrow()", "0x9bb01b5f": "ElcoinDb(address)", "0xdc6dd152": "playerRollDice(uint256)", "0x5d0be9de": "softWithdrawRevenueFor(address)", "0xcd591822": "CanaryV7Fast()", "0x36e6b92e": "taskProcessedWithCosting(uint256,uint256)", "0x7bb6a4c6": "uno(uint256)", "0x03427656": "getDefaultSoftResolutionBlocks()", "0xc1fd4339": "createMarket(bytes32,uint256,uint256,address)", "0xeb95b7d5": "Bounty(address,address)", "0x4dd49ab4": "get(bytes,uint256)", "0xfa6d373c": "LeaderHash()", "0x8c8d98a0": "toTimestamp(uint16,uint8,uint8)", "0x9a79f4a8": "testFailHeaderInsufficientFee()", "0xdd90c403": "getAccountFeed(address,uint256,uint256)", "0x58e59c32": "get_entry(uint256,uint256,uint256)", "0xfd747c0b": "rsaVerify(bytes,bytes,uint256,bytes)", "0x0f4cf692": "numMessages()", "0x18433bb7": "DrawPrepare()", "0x1dea0c57": "getRealBet(uint256)", "0x7d60e343": "getFileListSize()", "0xd24ddcfe": "buyKissBTC()", "0xa055fe64": "_projectCommitNew(address)", "0x5f17114e": "TimeDeposit()", "0x85fe0448": "testThrowRestartNotUpdatable()", "0x901717d1": "one()", "0x528fd7b0": "manualPayExpiredDuel()", "0x85952454": "newOwner(address)", "0xf34c7010": "commitSecurity(address,uint256,uint256)", "0x3bf2313d": "__transferToICAPWithReference(bytes32,uint256,string)", "0x67b830ad": "fillOrder(uint256)", "0x73fac6f0": "confirmReceived()", "0xf1b3f968": "getRaceEndBlock()", "0xf99fc046": "dEthereumlotteryNet()", "0xb409da05": "logDoubleIndex(bytes,bytes,bytes,uint256)", "0x9e920587": "testOwnedAuth()", "0x8e7cb6e1": "getIndex(uint256)", "0xe2f8a017": "payInstallment(uint256)", "0xac3e6b2f": "testSetNotRetractable()", "0x8fbc3ecd": "BUFFER()", "0x4b729aff": "buyNumber(uint256)", "0x166c4b85": "len(bytes32)", "0x6299f8cf": "stop(uint256)", "0xd767aee0": "bbb()", "0x29090202": "Resolver(address)", "0xcc2c2bcf": "MotionFactory(string,string,string)", "0xfd260dfc": "getCertificationDbStatus(address)", "0x30aceb89": "validateRequestParams(address[3],address,uint256[11],uint256,bytes,uint256)", "0xd11f13df": "numberOfParticipantsWaitingForPayout()", "0xd05c78da": "safeMul(uint256,uint256)", "0x69953501": "setUtils(address)", "0xff7f5f2a": "EtherizationUtils2()", "0xde4b3262": "setBasePrice(uint256)", "0x6cf9cc58": "registerResource(bytes,uint256,bytes,string)", "0x7ac37d58": "ownerTransferEther(address,uint256)", "0x0121b93f": "vote(uint256)", "0x07b6f631": "testTestHarnessAuth()", "0x869b3f6a": "testThrowsRetractNotOwner()", "0x18253234": "ticketsAvailable()", "0x5581004d": "createThrone(bytes,uint256,uint256,uint256,uint256)", "0x7102c138": "Standard_Token(uint256)", "0xce5566c5": "cash(uint256,uint256)", "0x16a25cbd": "ttl(bytes32)", "0x0c9fcec9": "setApproval(address,address,uint256)", "0xe6d95eb8": "DSAuthorized()", "0x34c0d654": "setPackageDb(address)", "0x0ee79fb3": "closeReferendums()", "0xe2cdd42a": "vote(uint256,address,bool)", "0xd3f297d6": "claimLiquidityReward()", "0xf37b437b": "scheduleCall(address,bytes,uint256,uint256,uint8,uint256,uint256)", "0x2090cf8b": "consultBalance(address)", "0xc9296d14": "scheduleTransaction(address,uint256,uint256,uint256,bytes)", "0x7993e5c2": "Devcon2TokenForTesting()", "0x268bb78e": "propose(address,bytes,uint256,uint256)", "0x2b16b56a": "setIndex(uint256,uint256)", "0x6d15f208": "reject(string,uint256,uint16,address,uint256)", "0xc4ff3614": "Wallet(address[],uint256,uint256)", "0xb47d89ad": "Details()", "0x0ae08793": "confirmAndCheck(bytes32)", "0x061e494f": "getBet(uint256)", "0x314e99a2": "abdicate()", "0xe487eb58": "getOwner(bytes20)", "0x7ee65635": "LookAtDepositsToPlay()", "0x9e9d3aa4": "FirstBloodToken(address,address,uint256,uint256)", "0x4dfd1b02": "setUint8(int8,uint8)", "0x82fbdc9c": "register(bytes)", "0xa8b60b93": "ackMsg(uint256,string)", "0x081e806d": "PayOut(uint256)", "0x8bab8791": "testPkgUpdate()", "0xc262df45": "isKnownRequest(address,address)", "0x4123cb6b": "m_numOwners()", "0x62be3172": "Message(address,address,address,string)", "0x0d368fee": "deverify(address)", "0x5f1231ea": "getMemberInfo(address)", "0xa07daa65": "newRequest(uint256)", "0xa4406bcd": "placeSellOrder(uint256,uint256)", "0x5b7d47a9": "betOnColor(bool,bool)", "0x9c6034a7": "sendIfNotForked()", "0x26a4861c": "CROWDFUNDING_PERIOD()", "0xbaac5300": "createTokenProxy(address)", "0xfc72c1ef": "ERC20Base(uint256)", "0x316b08a0": "scheduleTransaction(address,bytes,uint256[7],uint256)", "0x0b590c6b": "SingularDTVToken()", "0x750e443a": "voteAgainst(uint256)", "0xfc7b9c18": "totalDebt()", "0x7ff9b596": "tokenPrice()", "0xd67cbec9": "release(uint32,uint32,uint32,bytes20)", "0x553cc48d": "Player(string)", "0x579cdf17": "getAdminName(address)", "0x7e1c4205": "query2(uint256,string,string,string,uint256)", "0x54107401": "declareLove(string,string)", "0xea4ba8eb": "getOutcome(bytes)", "0x9b5adea2": "setMinter()", "0x185061da": "undoIt()", "0x90c3a370": "AuctionMaster()", "0xbd02e4f6": "calcRandomNumberAndGetPreliminaryGameResult(uint256,uint64)", "0xbc126ba1": "totalCents()", "0xa3747fef": "register(bytes,bytes)", "0x805210b7": "AmIPlayer2()", "0x4e05ded6": "ClassicCheck()", "0xec2ac54e": "deposit(address,uint256,bytes32,uint256)", "0x49c15bd9": "Purchase()", "0x87bb7ae0": "getTicketPrice()", "0xf2f03877": "commit(uint256,bytes32)", "0x167d3e9c": "SetOwner(address)", "0x5c634241": "CanaryV6()", "0xba15e52e": "getInfo(bytes20)", "0x06c1df7b": "checkBetColumn(uint8)", "0xf7bc39bf": "owns(address)", "0x27b752b8": "sha3HexAddress(address)", "0x5ac801fe": "setName(bytes32)", "0x1ae460e5": "isInPool()", "0x85c7a953": "WithdrawFullBalanceFromBankAccount()", "0x755b5b75": "setNumUnits(uint256,uint256)", "0xaefc8c72": "unsealBid(bytes32,address,uint256,bytes32)", "0xfab43cb1": "getPongAddress()", "0x9e997121": "getConfigAddress(bytes)", "0xda2b7416": "testBitsAndFailIndexOOB()", "0xd0e30db0": "deposit()", "0x4a0d89ba": "getSwap(uint256)", "0x63a9c3d7": "verify(address)", "0x337b1cf9": "setIpfsHash(bytes)", "0xbaf00f76": "removeAllSubUsers()", "0x1b370abb": "getPreviousNode(bytes)", "0x741e2345": "registerMany(address,uint256,int256,uint256,bytes20,address,bytes)", "0xb3760c80": "orderMatch(uint256,uint256,uint256,int256,uint256,uint256,address,uint8,bytes,bytes,int256)", "0x73ffd969": "setMap(uint256,uint256,uint256)", "0x50b44712": "tickets(uint256)", "0x6a9d2afd": "playToWinTest(uint256)", "0x644998ae": "maintain(int256,uint256,uint256)", "0x2203ab56": "ABI(bytes32,uint256)", "0x9c67f06f": "registryStarted()", "0x93423e9c": "getAccountBalance(address)", "0x524e4e61": "testDistribution()", "0xa17042cc": "getMsgValue()", "0x4f9d719e": "testEvent()", "0xcbcaacab": "checkTransferWithReference(address,uint256,string)", "0x1bcf5758": "getOccupies(uint8)", "0x1d4b0796": "updateTxStats()", "0xd173707d": "hasPhysicalAddress(address)", "0xa54a2b8b": "testBlockHashFetch()", "0xc51bf934": "CEILING()", "0x0e54b872": "registerUser(string,address)", "0xba51a6df": "changeRequirement(uint256)", "0x6bd92f7c": "activateAllowanceRecord(address,address)", "0x90daaf67": "getMinimalDeposit()", "0x85d5c971": "logTransfer(address,address,bytes32)", "0x8b9e5385": "MeterSlock(uint256,uint256,address)", "0x7bcd7fad": "getRecordAtIndex(uint256)", "0x8e035ac1": "BetOnHashV82()", "0x5dbe47e8": "contains(address)", "0x21bb79fe": "luckyDogInfo()", "0xdd467064": "lock(uint256)", "0xa4beffa7": "increaseInvestment()", "0x8400c307": "isRecipientAllowed(address)", "0x0965bf7d": "processProposals()", "0x4b5dc8cb": "roundMoneyDown3SFExt(uint256)", "0x777feff5": "getCertificationDbAtIndex(uint256)", "0x9462eae5": "ChangeContractor(address)", "0x4c6d1d9e": "checkOutTag(string)", "0x09a399a7": "personAdd(string,int256,int256,string)", "0x31380c89": "TokenSale()", "0xd0bff051": "testSetBalanceDb()", "0x4c738909": "getMyBalance()", "0xb2310cc5": "payRequstedSum(uint256,uint256)", "0xda3c300d": "currentFee()", "0x6ed7c013": "move_monsters()", "0x4f073130": "takeOrder(bool,uint256,uint256)", "0x6860fd58": "Fees(uint256)", "0x214c9d50": "WritedrawStatus()", "0xf314bf46": "setReleaseDb(address)", "0x561a4873": "buyAd(string,string,string,uint256,uint8,address)", "0xf249cf19": "get_all_challenges()", "0xbbed7177": "getContentTimestamp(uint256)", "0xc864e760": "recordCommissionEarned(uint256)", "0x1896f70a": "setResolver(bytes32,address)", "0xfd35e71b": "entryPayoutDue(uint256)", "0x5a58cd4c": "deleteContract()", "0xb29b5366": "setRentable(bool)", "0xad5c613d": "purchase(bytes)", "0x6949a058": "sendOwnerEther()", "0xc03e382f": "calculateShare()", "0xf5bade66": "setDeposit(uint256)", "0x384e5018": "etherandomCallbackAddress()", "0xf06186c7": "testReality()", "0x677342ce": "sqrt(uint256)", "0x10e89b22": "remove_deal(uint32)", "0xf2b445ad": "rowround(uint256,uint256)", "0xd7ed7453": "redeemWinnings(uint256)", "0x92b4bb50": "rps()", "0x089327de": "MyToken()", "0x87ebd76c": "initContract(string,string,uint256,uint256)", "0xdbc45228": "newProposal(address,uint256,bytes,bytes)", "0x6b1feeeb": "get_my_sig()", "0x6837ff1e": "newContract(address)", "0x9f181b5e": "tokenCount()", "0x92ba4ba6": "GridMember(string,uint256,bool,address,address)", "0x45755dd6": "returnFunds(uint256)", "0xb4b9d1f1": "lookup(uint256,uint256)", "0x98024f18": "testThrowsTransferDisableNotEnabled()", "0x9e7b8d61": "giveRightToVote(address)", "0x8112821f": "EthVentures()", "0xe65d6b49": "getCommission()", "0x068c966b": "DrawDetails(uint256)", "0x9bb5239a": "CheckPrize(address,uint256)", "0xff08d2b0": "PayMiners()", "0x9be1fcee": "BankOwner_DisableConnectBankAccountToNewOwnerAddress()", "0x5f972df8": "_jDiv(uint256,uint256,uint256,uint256)", "0xfe8b6642": "setEnforceRevisions(bytes32)", "0xe4cc1161": "seedWithGasLimit(uint256)", "0x5fd4b08a": "getName(address)", "0xaa51793c": "isLosingBet(uint256)", "0x31757f2e": "collisionCount()", "0xe1f5ebc5": "_projectAddNew(address,uint256)", "0x64228857": "getRevisionCount(bytes32)", "0x5ca3400c": "WithBeneficiary(address)", "0x39f4debc": "fillOrderAuto()", "0xcc2c5453": "add_sword(uint16)", "0x0a19b14a": "trade(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32,uint256)", "0x4d207d9a": "identify(address)", "0x3e83fe36": "getMyShares()", "0x8bb0faee": "setRef(string,string)", "0x38bbfa50": "__callback(bytes32,string,bytes)", "0xcee6f93c": "getResultOfLastFlip()", "0xbbba3333": "safer_ecrecover(bytes32,uint8,bytes32,bytes32)", "0x8e19899e": "withdraw(bytes32)", "0xd8389dc5": "hash(bytes32)", "0x8a4068dd": "transfer()", "0xea9e107a": "acceptRegistrarTransfer(bytes32,address,uint256)", "0x8f4ffcb1": "receiveApproval(address,uint256,address,bytes)", "0xf67abd87": "entryDetails(uint256)", "0x67acd805": "lowerMinWager(uint256)", "0xec035393": "_getAllRevisionBlockNumbers(bytes20)", "0xbd858288": "orderMatch(uint256,uint256,int256,uint256,uint256,address,uint8,bytes32,bytes32,int256)", "0x112c7075": "ManualDeposit()", "0xd81a91e9": "get_party2()", "0xc52bd836": "setDappOwner(bytes32,address)", "0xf84f420b": "getRandomNumber(address,uint256)", "0xcfe9a7b8": "getPackageName(uint256)", "0xe97dcb62": "enter()", "0x48db5f89": "player()", "0x6bdbf8e6": "concat()", "0x3c959aca": "CheckTickets()", "0x3aa5f4f7": "changeTokenSettings(uint16,uint256,uint256)", "0xac20902e": "NormalizeMoney()", "0x2fac1d36": "isReadyFor(address)", "0xdcaa5620": "findNextWeekday(uint256,bytes)", "0xf9909915": "bulkStoreHeader(bytes,int256,bytes,int256)", "0xcd2cdd5b": "claimOwnershi()", "0xcfae3217": "greet()", "0xf5c8d71b": "forceMove(address,address,uint256)", "0x9718b524": "newTreasury(address)", "0xd0679d34": "send(address,uint256)", "0x1301ee02": "transferringETC(address)", "0x60eb2826": "Badge()", "0x0d0c2008": "TwoAndAHalfPonzi()", "0x17e1bfb7": "addInstitution(address,string)", "0x06394c9b": "changeOperator(address)", "0x80c951bf": "currentClaimPriceInFinney()", "0xd063f55f": "toLittleEndian(uint64)", "0x53f818d6": "checkBetValue()", "0x9205fbc2": "testAuthorityAuth()", "0x3e4c0c82": "player_1(uint256)", "0xe571c35e": "ReverseRegistrar(address,bytes32)", "0x24804cef": "Deed()", "0x622e88cb": "testBitsXorSuccess()", "0xdfca2f53": "LookAtPrizes()", "0xafa293d4": "getSource()", "0x755f99c2": "AddNewSmallContract(address)", "0x7137ed47": "setProxyContract(address)", "0x835b42fc": "testThrowUpdateLatestRevisionNotUpdatable()", "0xdd34e129": "PriceTest()", "0xedb27f4e": "switchWizard(address)", "0x1c5d9faa": "setNickname(string)", "0x4746cef8": "_confirmAndCheck(address,bytes32)", "0x189c94ae": "testFallbackStaticSig()", "0x0cb749b6": "FutureBlockCall(address,uint256,uint8,address,bytes,bytes,uint256,uint256,uint16,uint256,uint256)", "0x2b25a7e4": "giveKudos(address,uint256)", "0x294f3d4d": "setUpLimit(uint256)", "0x2cce81aa": "getBlockHash(int256)", "0x4cd11943": "NewManualInvestor(address,uint256)", "0x7eaef50c": "over()", "0x8ac4e1d8": "TemperatureOracle()", "0xf108a7d2": "withdraw(uint256,address,string)", "0x00a676f9": "getExists(bytes32)", "0xb8d4efb5": "validate_percent(uint8)", "0xc7489441": "closeMarketMaker(uint256)", "0x3def449b": "FipsNotary()", "0x5687f2b8": "emitApproval(address,address,uint256)", "0xa9f8ec6c": "AlarmClockTipFaucet()", "0xd8e5c048": "scheduleCall(address,uint256,uint256)", "0x135217e7": "requires_depth()", "0x0aa46c12": "testClearBitFailIndexOOB()", "0x77d32e94": "ecrecovery(bytes32,bytes)", "0xace523c4": "createReferendum(string,string,uint256,uint256)", "0x5ca8bc52": "returnIt()", "0xdb318833": "_ecAdd(uint256,uint256,uint256,uint256,uint256,uint256)", "0x623195b0": "setABI(bytes32,uint256,bytes)", "0xd7bb99ba": "contribute()", "0x2880ebe7": "underdogPayoutMarkup()", "0x4ce01d86": "totalBetValue()", "0x837a7ba5": "testThrowTransferDisabled()", "0x386fcda8": "testCreateCostToken()", "0x0e850239": "scheduleCall(bytes4,bytes)", "0x163aba3c": "getQueryFee()", "0x9941e3d0": "setCallAddress(address)", "0x23637e60": "votePrice(uint256,bool)", "0xde78e78a": "tokenLaunched()", "0xe3579ea5": "publish(string,string,address,uint256)", "0x59a547b0": "recordCommission(uint256)", "0x1aa86370": "updateXIPFSPublicKey(string)", "0x97fcb54e": "transfer_eth(address,uint256)", "0x05d2f92a": "check_depth(address,uint256)", "0xdfcbb794": "TrustFund(address,uint256,address)", "0xb7dd1d17": "getAllRevisionBlockNumbers(bytes32)", "0x75862df4": "TokenWithEStop(address)", "0xd22057a9": "register(bytes32,address)", "0x29d017b5": "TestWithConstructor(address,uint256[])", "0xd216d55d": "etherandomExec(bytes32,bytes32,uint256)", "0xfba06849": "fipsPublishDataMulti(bytes20[],bytes)", "0xa37fd390": "setHomeAdv(uint256,string)", "0xcf2e3efc": "GetBankAccountBalance()", "0x423e7e79": "_dispatchEarnings()", "0x74087040": "testBitsNotEqualSuccess()", "0x61d585da": "state(bytes32)", "0xcfb3a493": "getMyBounty(uint256)", "0x5afeb106": "Sqrt()", "0xf9e84395": "unexempt(address)", "0x5669c94f": "issueToken(address,string)", "0x19b05f49": "accept(uint256)", "0x3ae01f84": "USDOracle()", "0x8c172fa2": "getEvent(bytes32)", "0x4671e65e": "proposeEmergencyWithdrawal(address)", "0xc27d7721": "create(uint256[101][])", "0x5c52e51e": "processPayout()", "0xf7a0fa0a": "getShareDistribution(bytes)", "0x31a3a506": "closeFunding()", "0x465e759b": "testRestart()", "0xb60d4288": "fund()", "0x52200a13": "getNumHolders(uint256)", "0xf2c298be": "register(string)", "0x7bc25372": "UserCheckBalance(address)", "0x104d5fdd": "getPriceProxy()", "0x447cd682": "scheduleTransaction(address,uint256)", "0xa045fdff": "scheduleCall(address,bytes)", "0x4757f1d2": "redeemAllOutcomes(uint256,uint256)", "0x5e855f14": "Dice(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)", "0x5d3c1d4c": "_getRequest(uint256)", "0x416c8701": "beyond()", "0x63aea3e0": "PlayerInfo(uint256)", "0xa163a624": "Test()", "0xedede601": "testBalance()", "0x13651124": "WithdrawAmountFromBankAccount(uint256)", "0x893d20e8": "getOwner()", "0x90b5561d": "insert(uint256)", "0xf9983a12": "GetMyInvestmentBalance()", "0xb71c47a2": "surrender()", "0xf2a75fe4": "empty()", "0x804ba97a": "tryGet(bytes)", "0x6506b623": "rotateBitsLeft(bytes,uint256)", "0x3ef8ec78": "announce_numbers(uint8,uint8,uint8,uint8,uint32,bytes32)", "0x73abecbb": "kill1()", "0xd5171523": "euroteambet()", "0x8e52cb51": "getRecordKey(bytes,bytes,bytes)", "0x7adbf973": "setOracle(address)", "0x4aa16737": "enter(uint8)", "0xf0cb556c": "updateLatestRevision(bytes32,bytes)", "0xbc8fbbf8": "nuke()", "0xc8e55708": "oraclize_query(string,string[1])", "0x7332b520": "getRewardsCount(uint256)", "0xf7c2b38c": "seconds_left()", "0xba344743": "_rawTransfer(address,address,uint256)", "0xcab5c0f1": "_incrementState()", "0xe044c2de": "newLoan(bytes,address,uint256,uint256,uint256,uint256,uint256,uint256)", "0x76abc03b": "getShareDistribution(uint256)", "0xf0da84f8": "getTransferable(bytes32)", "0xcde99727": "calculateROI()", "0x155dd5ee": "withdrawFunds(uint256)", "0x8b543b80": "maximumCredit(address)", "0x340ddda6": "MeatConversionCalculator(uint256,uint256)", "0x524f3889": "getPrice(string)", "0x84054d3d": "cashout()", "0x856f3080": "WhatWasMyHash(bytes32)", "0x0386a016": "closeProposal(uint256)", "0xcebce72d": "token(uint64)", "0x7f480f9d": "processDividends(address)", "0x11d12402": "testEasyPropose()", "0x2f695053": "getCertifierAtIndex(uint256)", "0xd9fcb31f": "comm_channel()", "0x141c4e60": "challenge(uint256,address)", "0x4ff13571": "x2()", "0xa01bc729": "monster_attack(uint256)", "0x2fe9541f": "addIssueBounty(string,uint256)", "0x5503a659": "smallponzi()", "0xdfc765dc": "getMatchers_by_index(uint256)", "0x0b7623ba": "abs(int8)", "0xcde0a4f8": "setRegulator(address)", "0xf95b5a58": "getInitialAnswer(uint256)", "0x66b42dcb": "register(address,string,uint256,string)", "0x9f2ce678": "vote(bytes32,bool)", "0xb3559460": "getGenerationSize(uint256)", "0x5ddae283": "transferRegistrars(bytes32)", "0x59dc735c": "getClient()", "0xc258ff74": "List()", "0x4fb4bcec": "step5()", "0xed684cc6": "trigger(uint256)", "0x09405164": "getOpenCandidates()", "0x5c5d625e": "getProof()", "0x9f5f7c7f": "tokenSplit(address,address,address,uint256)", "0x0e38901a": "unvault(uint256)", "0x75160a20": "pay_royalties()", "0x15398afe": "compareNumericStrings(string,string)", "0xbbd8b602": "getOracleOutcomes(bytes,address[])", "0xebae35a6": "DAOTokenCreationProxyTransferer(address,address)", "0x15abc160": "createValidatedRequest(address[3],address,uint256[11],uint256,bytes)", "0x830953ab": "claimAmount()", "0x26b916b4": "Set_Interest_Rate(uint256)", "0x1fb291cb": "registerInt(address,int256)", "0x505fb46c": "add(uint256,uint256,uint256)", "0xf00d4b5d": "changeOwner(address,address)", "0x034187fd": "setEthToCents(uint256)", "0x94d9cf8f": "CreateProxyWithControllerAndRecovery(address,address[],uint256,uint256)", "0xacbf98a7": "endsWith()", "0xfc2c3e08": "getIteration()", "0x6d7da0b1": "MyContract()", "0x1558ae4d": "Etheroll()", "0x42cbb15c": "getBlockNumber()", "0x29cd62ea": "setPubkey(bytes32,bytes32,bytes32)", "0x2030f721": "num_objects()", "0xbc08afd9": "WebOfTrustToken(address,uint256)", "0x8cdfb1e6": "transferIfHF(address)", "0xa0bd3c0f": "scheduleCall(address,bytes,bytes,uint256)", "0x4e71e0c8": "claimOwnership()", "0xc1cc0775": "calculateFeeDynamic(uint256,uint256)", "0x50c42921": "replicate()", "0x25495998": "getMinimumConsumerDeposit()", "0x3d8e2947": "getFileAddress(bytes)", "0x1f794436": "getBlockHeader(int256)", "0x7d380265": "addOptionChain(uint256,string,uint256,uint256,bytes32,address,int256[])", "0xec0b4153": "getMoneyness(int256,uint256,uint256)", "0x01775f23": "_closeBooks()", "0x9d063ed8": "FIFSRegistrar(address,bytes32)", "0x083b2732": "callback()", "0xa1920586": "offer(uint256,uint256)", "0x19c47214": "getBlockVersion(bytes)", "0xa293d1e8": "safeSub(uint256,uint256)", "0xfe73e3ec": "preliminaryGameResult(uint64)", "0xf004b12b": "CrowdFund(uint256,uint256,address)", "0x54d03b5c": "changeFeeMake(uint256)", "0x9dbc4f9b": "participantDetails(uint256)", "0xd002462b": "setDeploymentFee(uint256)", "0xed2b8e0b": "getPoolRotationDelay()", "0xf697a0ed": "ppb(uint256,uint256)", "0x964c836c": "receiveExecutionNotification()", "0x5e0e2957": "dumpOut()", "0x33232609": "blake2b(uint64[],uint64[],uint64)", "0x88f53db1": "getDataRequest(uint256)", "0x0caf9d39": "testFailTooManyMembers()", "0x1f2e886c": "testControllerTransferTriggersEvent()", "0x586a69fa": "getMaximumStackCheck()", "0xf64fca2e": "getNodeId(bytes)", "0x8b95ec0c": "testAddBalance()", "0x32e7c5bf": "B()", "0x57e6c2f4": "isAuthorized()", "0xb2f2588b": "sortNumbers(uint8[3])", "0xe95bee59": "checkFormat(string)", "0xcef887b0": "storeBlockWithFee(bytes,int256)", "0xbe26733c": "Kill()", "0xe82f7dd4": "testThrowsRetractLatestRevisionNotUpdatable()", "0xfd7ac203": "TestToken()", "0x6d052f56": "testBitsSetSuccess()", "0xf65c4d42": "Participate(uint256)", "0x432c685f": "trustClient(address)", "0xb0171fa4": "getCurrentGenerationId()", "0x03251a08": "setMin(uint256,uint256)", "0x58d3b617": "Notifier(string)", "0x15dacbea": "transferFrom(address,address,address,uint256)", "0x83f7b8e1": "getNumberOfPhotos()", "0xf1076703": "getVerificationId(address,bytes,bytes)", "0x752a3df6": "transferIfHardForked(address)", "0xaf93afdd": "Shipment(bytes,bytes,bytes,bytes,string,bytes,uint256,uint256,bytes,bytes,uint256,uint256,string,bytes,bytes,bytes)", "0x7fcf532c": "Withdrawal(address,uint256)", "0x72ea4b8c": "getNumInvestors()", "0x7df52ba8": "Arbitrate(uint32,uint32,bool)", "0xea25f24a": "TokenCreation(uint256,uint256,address)", "0xf74100e3": "getBits(bytes)", "0x63bfe3d8": "SkillBeatsLuck()", "0x80599e4b": "remove(string)", "0x6c050eae": "look()", "0xf9a794ad": "EtherLovers()", "0x501e8428": "getPart(bytes,uint256)", "0xf446c1d0": "A()", "0x2d67bb91": "World()", "0xeef547d7": "deal_details(uint32)", "0xa6cb9e64": "scheduleCall(address,bytes,bytes)", "0x659010e7": "m_spentToday()", "0x9b0b9c07": "acceptBankDraft()", "0x315e2f1b": "setTestString(string)", "0x69bcdb7d": "getCommitment(uint256)", "0xe1376da2": "updateFirstActiveGamble(uint256)", "0xc70d169d": "answerRequest(uint256,bytes)", "0xa094a031": "isReady()", "0x74e60a48": "cancelOrder(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32)", "0x1b5ee6ae": "mintToken(int256,address,uint256)", "0x7f791833": "toTimestamp(uint16,uint8,uint8,uint8)", "0x5e6ad49d": "_setCosignerAddress(address)", "0xb2e85b67": "getPlayerStatus(address,uint256)", "0x30a24abd": "create(bytes4,bytes)", "0x9f0e3107": "get_timestamp(bytes32)", "0x33397816": "withdrawAccountBalance(address)", "0x0da3e613": "EthFactory()", "0xa5f3c23b": "add(int256,int256)", "0xc1829a14": "testFailTooFewConfirms()", "0x5322f0c5": "getChannelOwner(bytes)", "0x0fd1f94e": "firstClaimBlock()", "0x639d57f2": "testGetBitSuccess()", "0xd3aa22c7": "transferTLA(string,address)", "0x86314af9": "BetOnHashV84()", "0x3059ac30": "Escrow(address,address)", "0x0efafd01": "getPlayerGainLossOnLastFlip()", "0x49bf66d3": "addRegistryIntoNameIndex(address)", "0x3af39c21": "undefined()", "0xb660d77c": "switchMPO(address,address)", "0x0fdb468f": "fee(uint64)", "0x72479140": "CreateTicket(address,uint8,uint8,uint8)", "0xe79a198f": "unregister()", "0x688dcfd7": "setProofType(bytes1)", "0xfb9a4595": "GitHubBounty()", "0xd02a9889": "getDateOfFirstPayment()", "0xca35271c": "numDebtors(address)", "0x08714bfa": "TestContract()", "0x16d960b5": "createThing(bytes32[],bytes32[],uint88)", "0x17961d0f": "ord()", "0x62ba9687": "toTimestamp(uint16,uint8,uint8,uint8,uint8)", "0xbba91ea7": "getHomeadvIndex(uint256)", "0xb45105b2": "post(string,address,string)", "0xa7e25683": "testShortOutput()", "0xa068e8d3": "convict(uint256,uint256,uint256,uint256)", "0x09a69f57": "getRewardAmount()", "0xe7334156": "processNextDeposit(address)", "0x62ee6d29": "changeHashtoLowOrHigh(uint256)", "0xa80d4e9a": "EtherAuction(uint256)", "0x18489f50": "thingExist(bytes32[])", "0x5323c6cf": "calcCostsBuying(bytes,uint256,uint256[],uint8,uint256)", "0x9a777d5d": "buyCoins()", "0x36344022": "testAuthorizedTransfer()", "0x8b863095": "setContractorProposal(uint256,bytes)", "0xd10e99fe": "mint(int256,bytes32)", "0x12c82bcc": "sendRobust(address,uint256)", "0x0bf75567": "voteSuperQuorum(uint256,bool)", "0xf5f6ea26": "EthOne()", "0x14918f5e": "performInitialWithdrawal()", "0xdf32754b": "owned()", "0x1632070c": "setRewardDivisor(uint256)", "0xe50a3bb1": "oraclize_query(string,string[],uint256)", "0x9b619d3b": "_deleteAllPackedRevisionBlockNumbers(bytes32)", "0x3b751f7f": "claimThroneRP(string)", "0xd55ec697": "upgrade()", "0x43703b0e": "getEventData(bytes)", "0xd1bf9aba": "nextRune()", "0x76849376": "addNode(bytes32,address)", "0xfd958695": "isAlphaNumeric(bytes1)", "0x9fa5e5d5": "setARKowner(address)", "0x6e2cde85": "drawPot(string,string)", "0x4d5b080c": "scheduleTransaction(uint256,address,uint256)", "0xf1e4a540": "unsetCoordinator()", "0x364f4896": "emission(address,address,uint256,uint16,uint16)", "0x9183fd01": "getSeedPrice()", "0x9832ee65": "resultsWeightedByTokens()", "0xdd5244b4": "testTryProxyCallWithValue()", "0xec2ec781": "testFailGetUnsetToken()", "0x7db9743b": "Registry()", "0x1adf2d1a": "Offer(address,address,bytes,uint256,uint256,uint128,uint256)", "0x1ba326c4": "calcShare(uint256,uint256,uint256)", "0x3ced842b": "make_offer()", "0xea295ec2": "calcRevenue(address)", "0x3c894475": "scheduleTransaction(address,bytes,uint8,uint256[6],uint256)", "0x477bddaa": "setContractAddress(address)", "0xed180443": "getUint256(int256)", "0xee725d44": "toChannelID(string)", "0xa4898fd5": "deployContract(address)", "0x75ee85bd": "salsa20_8(uint256,uint256)", "0xbe7c29c1": "getNewDAOAddress(uint256)", "0xfe01f1ff": "TokenTester()", "0x6103d915": "Winners(uint256)", "0xa30b5c69": "AttributeModel()", "0x81064e2d": "getCreditorAmounts()", "0x23584a21": "initStats(string,address,uint256)", "0xe2894a8a": "OwnerAnnounce(string)", "0xa84c5330": "createNewRevision(bytes20,bytes)", "0xb742398b": "trade(address,uint256,bytes,address,uint256,bytes)", "0x3211bb90": "OwnerAddFunds()", "0xa0befa94": "getStake(uint256,uint256)", "0x6dc3edcf": "executeExecutable(uint256,uint256)", "0x17e875e3": "Transparancy()", "0x6939864b": "lotteryState()", "0x3b107682": "DualIndex()", "0x51b3d7b9": "_transferWithReference(address,uint256,string)", "0xdf7cec28": "cancelBid(bytes32)", "0x1e74a2d3": "getMinimumEndowment()", "0x39b333d9": "Play(uint8,uint8,uint8,uint8)", "0xcbd08c8c": "config(uint256,uint256,uint256,uint256)", "0xca6ad1e4": "setCustomGasPrice(uint256)", "0x510f44cb": "TestFactoryUser()", "0xcee6ee38": "aEthereumlotteryNet()", "0x11610c25": "bet()", "0xb73405a9": "roundMoneyDownNicely(uint256)", "0xb8851fea": "endDateStart()", "0xa4325485": "getCreatorBalance()", "0x2c181929": "getChainWork()", "0xffb4c857": "_confirmAndCheck(bytes32)", "0x9e66cd38": "free(uint64)", "0x44e43cb8": "depositRevenue()", "0xa553a597": "configure(uint256,uint256,uint8,address)", "0xc47f0027": "setName(string)", "0x565a2ecf": "classicTransfer(address)", "0x1da0fb1b": "updateSettings(uint256,uint256,uint256,uint256,uint256,bool)", "0xa5ebf389": "getMoneyTotals()", "0x7f445c24": "subRegistrar(string)", "0x9ad4f98e": "BlocksureInfo()", "0xd6b4ec12": "getDailyWithdrawalLimit()", "0xe0886f90": "at(uint256)", "0x5dc77e26": "andThen(string,address)", "0xe7d50e5c": "FarmShare()", "0x3f2965f0": "registerSeller(address)", "0x85b73d3c": "testCreateNewRevision()", "0x49437210": "getUpdatable(bytes32)", "0xe1a9109d": "setSeedPrice(uint256)", "0x95978868": "strConcat(string,string,string,string,string)", "0x511b1df9": "addr(string)", "0xc5b1d9aa": "newRound()", "0xecf6eb22": "setConfigAddress(bytes,address)", "0x9a9c9c53": "DepositToBankAccount()", "0x27ea6f2b": "setLimit(uint256)", "0xd2dc0869": "add(string,uint256,string,string,address)", "0xc86a90fe": "sendCoin(uint256,address)", "0x5dfc2e4a": "noop()", "0xd81e8423": "get(address,address)", "0x4cad42d3": "testWager()", "0xd120a284": "getBytesFromNumbers(uint8[3])", "0x991ffd4e": "scheduleCall(address,bytes,bytes,uint256,uint256,uint8,uint256)", "0x60c311fd": "doBurnFromContract(address,uint256)", "0xbb6a0853": "GreedPit()", "0xc27b2c2d": "collectEarnings()", "0x446294ad": "multiAccessGetOwners()", "0x5bec9e67": "infinite()", "0x47e7ef24": "deposit(address,uint256)", "0x8d216186": "roll(uint256,bytes32)", "0xdf300b46": "getThing(bytes32[])", "0x5a6c787e": "updateWithMPO()", "0x1f2dc5ef": "divisor()", "0x421aeda6": "Set_your_game_number(string)", "0xba1162d7": "getFmLength()", "0x853255cc": "sum()", "0x20768ee8": "getProposalID()", "0xf5c57382": "nameOf(address)", "0x4e417a98": "callData()", "0xc90d080a": "registerEvent(bytes)", "0x0b1e400a": "_transferFromToICAPWithReference(address,bytes32,uint256,string)", "0xe420264a": "g(uint256)", "0x8a00a82f": "withdrawRewardFor(address)", "0x06638e92": "GetNumbersFromHash(bytes32)", "0xf63da25b": "Emailer()", "0xc01706dd": "getContentByRank(address,uint256,uint256)", "0xe1108706": "rfind()", "0xffd10e07": "enterPool(address)", "0xc4254c7b": "CoreWallet()", "0x30e0789e": "_transfer(address,address,uint256)", "0x992ae976": "isSafePunctuation(bytes1)", "0x4afce471": "test_requires_depth(uint16)", "0xda7fc24f": "setBackend(address)", "0xeb7402f5": "multiAccessHasConfirmed(bytes32,address)", "0x6c1a5b8c": "TOKEN_TARGET()", "0xb3a2a999": "nextWithdrawal(bytes16)", "0x4a420138": "scheduleHeartbeat()", "0xb1233451": "setTerm(uint256,string)", "0x266710ca": "manualUpdateBalances_only_Dev()", "0x98866c1a": "personUpdateDOD(uint256,int256)", "0xaa6be303": "debtors(address)", "0xda5c0a7c": "testDisown()", "0x8757a2cd": "test_depth(uint256,uint256)", "0xe1bedf2a": "AlarmTester(address)", "0x5dcbac7a": "registerBytes(address,bytes)", "0xa587da29": "setPackage(bytes,uint8,uint8,uint8,bytes)", "0xc3da42b8": "c()", "0x4b8772c1": "buyUnit(uint256,uint256)", "0x67f12ecf": "validate(address,uint256,uint256[101][])", "0x0bd089ab": "MyAdvancedToken(uint256,string,uint8,string,address)", "0x32829a23": "OpenBankAccount()", "0xdea06188": "NumberOfBlockAlreadyMined()", "0x61e539da": "testFailWrongAccountTransfers()", "0x8a3e44d4": "assetMoveInformation(address,address)", "0x1327d3d8": "setValidator(address)", "0x207c64fb": "validate(address)", "0x80acaafb": "profitDistribution()", "0x90b98a11": "sendCoin(address,uint256)", "0x8b147245": "update(bytes32)", "0x920c94df": "BuyTicketForOther(address,uint8,uint8,uint8)", "0x6f698fb5": "setMinimumQuorum(uint256)", "0xac5e81a9": "historyPayout(address)", "0x70d084c0": "SingularDTVCrowdfunding()", "0x67ce940d": "getOverhead()", "0x7a791524": "setNextFeePercentage(uint8)", "0xd6d902c4": "claimThroneFor(bytes,address)", "0xc71e48d6": "setOutcome(bytes32,bytes32[])", "0xef41e06f": "testThrowSetEnforceRevisionsNotOwner()", "0x70be4ffa": "testErrorUnauthorizedSetPackage()", "0x6d12301c": "getBetValue(bytes32,uint8)", "0x4e69d560": "getStatus()", "0x55234ec0": "remaining()", "0x5cfd8c24": "ResetPonzi()", "0xe29fb547": "scheduleCall(bytes4,uint256,uint256,uint8,uint256)", "0xbd119967": "add_rating(uint256,uint256)", "0x966acb38": "testThrowTransferNotTransferable()", "0x5c665f89": "getFunds(address,bool)", "0xa59d6986": "recoverLostFunds()", "0x403abbc7": "updateFirstActiveGamble()", "0x0230a07c": "releaseDeed(bytes32)", "0x2d116186": "deityBalance()", "0x602acca1": "InchainICO(address[],uint256)", "0xd393c871": "register(string,address,uint256)", "0xe0fe075e": "payoutReady()", "0xf3e3c629": "testBalanceOfStartsAtZero()", "0x48cd4cb1": "startBlock()", "0x669459a7": "removeRegistryFromOwnerIndex(address)", "0x74d89c47": "testUpdateNameDb()", "0x182db370": "getWhatHappened()", "0xf363441f": "getCreatorDotBalance()", "0x6896fabf": "getAccountBalance()", "0xb29a0308": "logAnonymous(bytes,bytes,bytes,uint256)", "0x3023d0c4": "Ethstick()", "0x1077f06c": "makeClaim(uint256)", "0x8a519fb9": "BlockChainEnterprise()", "0xbffbe61c": "node(address)", "0xe20bbd8d": "RecoveryWithTenant()", "0x03bda14e": "raiseMaxNumBets(uint256)", "0xe1041d86": "__throw()", "0x3d79d1c8": "bal()", "0xbd3f0965": "AiraEtherFunds(string,string)", "0xc388cca6": "testBitAndFailIndexOOB()", "0x921f98bb": "resolveFailVote()", "0x4bbb216c": "_target(address)", "0x10922cc1": "testTransferCost()", "0xeceb2945": "checkProposalCode(uint256,address,uint256,bytes)", "0x3df4ddf4": "first()", "0x21a49ec2": "LCoin()", "0x6d1f00a6": "ThroneMaker(uint256)", "0xcaed4f9f": "DataService()", "0x5cff876b": "carrotsCaught()", "0x3a7fb796": "mintGreen(int256,address,uint256)", "0x370b6939": "AdminSetDrawer(address)", "0x2d9a37d3": "getMaxPayout()", "0x739f888c": "setNewEstimate(int256,int256)", "0x04dd69fa": "getGenerationIdForCall(address)", "0xb764e273": "failSend()", "0xd4dfadbf": "getMarket(address)", "0xa0e67e2b": "getOwners()", "0x2d592a34": "sellKissBTC(uint256)", "0x8a341c83": "testErrorRootAuthorityChangeUnownedPackage()", "0xfcc6b5d5": "fillTheirOrder(address)", "0x61649472": "getPoolFreezePeriod()", "0x3dd297da": "safeMultiply(uint256,uint256)", "0x5d3278f0": "LooneyFifty()", "0x7399646a": "theRun()", "0x3e450fff": "adminDeleteAccount()", "0x93cc9162": "taskRejected(uint256,uint256)", "0xbc5d0f65": "beginExecution()", "0x1934d55a": "isPermanentlyApproved(address,address)", "0xf1cff4b5": "testBitsNotSetSuccess()", "0xf240f7c3": "dispute()", "0xf6d5959b": "getActionStatus(uint256)", "0x0f23cbaa": "recycle()", "0x74f8d96e": "getRevisionBlockNumber(bytes20,uint256)", "0x0bad342a": "EscrowContract(address,address,address,address,uint256,uint256,uint256,uint256)", "0xa6afd5fd": "getBets()", "0x84ad6ff3": "ReversibleDemo()", "0x62b3b833": "createCoupon(string)", "0x523ccfa8": "isKnownCall(address)", "0xacc8cb18": "pushTerm(string)", "0xa753d6f2": "CreateProposal(string,string,string,string,string,string,uint32,uint32)", "0xc5699d68": "_compare(int256,bytes,int256)", "0xe2faf044": "createDAO(address,uint256,uint256,uint256)", "0xa15afb48": "Replicator()", "0x352d2790": "UUID4()", "0x7dee2cad": "CancelMyInvestment()", "0xbeabacc8": "transfer(address,address,uint256)", "0x674f220f": "previousOwner()", "0x4b3b6168": "SetNewBigContract(address)", "0x54ba7daa": "enter(bytes,bytes)", "0x06fdde03": "name()", "0x5944427b": "getRequestResult(uint256)", "0x983ef725": "getDifficulty(uint256)", "0x9287c877": "getNavLength()", "0xa987d654": "restoreItem(uint256)", "0x05433a26": "GetNumbersFromHash(bytes)", "0xd04bfc9c": "buyer_pay()", "0x4a9b3f95": "personUpdateName(uint256,string)", "0xe6b972f5": "userName(address)", "0x88782386": "UnicornMilk()", "0x74580e2f": "changeCreator(address)", "0x1785f53c": "removeAdmin(address)", "0xad544dcb": "testSetNotUpdatable()", "0xafd09bab": "quadrupler()", "0x77bc222c": "_eraseSingleNode(bytes32)", "0x09957e69": "newSale(bytes,uint256,uint256)", "0xa21931ea": "CreateProposal(string,string,string,uint32,string,string,string,uint32,uint32)", "0xbb6b4619": "SendETC(address)", "0x3aa94b1d": "getCoinStats(uint256)", "0x9e2262f5": "testCreateCostData()", "0x2bf4e53d": "getCurrentShareholders()", "0x6111dd02": "calcCostsSelling(uint256,uint8,uint8,uint256)", "0x6b9b1006": "TransactionRecorder()", "0x83b23b40": "cEthereumlotteryNet()", "0x770c6cbb": "WithDrawPreForkChildDAO()", "0x67080f6e": "testThrowsSetEnforceRevisionsNotOwner()", "0xa10bee85": "_transferFromWithReference(address,address,uint256,string)", "0x49cc954b": "twoYearsPassed()", "0x88c3ba85": "ParallelGambling()", "0x03985426": "getMode(bytes32)", "0xad8ed335": "__proxy(address)", "0x306387a4": "dealStatus(uint256)", "0x0343dfa0": "checkInvariants()", "0x23df9df5": "_refund(uint256)", "0x837e7cc6": "rollDice()", "0x98b1e06a": "deposit(bytes)", "0xa0440426": "purchaseProduct(uint256,uint256)", "0x4cb71b9b": "getAllReleaseHashes()", "0x3a7d280c": "login(string)", "0xb9a904f9": "testUnauthorizedSetBetaPackage()", "0xe94a4db1": "isSuitableGen(uint256,uint256)", "0x60f8af90": "refundRound()", "0x43bf718e": "getHashOfTheProposalDocument()", "0x4a30f976": "censorship(uint256,bool,bool)", "0x47e46806": "toString()", "0x8d59cc02": "register(address,string,string)", "0xb3fb14ad": "getGameResult()", "0x4a23dc52": "FileStore()", "0x8da5cb5b": "owner()", "0x3cc8daf7": "setNameOwner(bytes,address)", "0x14cbdb54": "EspCoin()", "0xc47cf5de": "getAddress(bytes)", "0x71e11354": "updateRegistration(string,string)", "0x8b2e6dcf": "publish(bytes32)", "0x12d00c2e": "soloWithdraw(uint256)", "0xd68199dc": "gameStats()", "0xf0f967e8": "canCall(address,address,bytes)", "0xe0c7c117": "Randao()", "0xddeae033": "claimFor(address)", "0xcec7260b": "move_monster(uint16,uint16)", "0xe51ace16": "record(string)", "0x4f76cb02": "testGetBitFailIndexOOB()", "0x942385eb": "getPayroll()", "0x46d667db": "setBytes32(bytes)", "0x35a063b4": "abort()", "0xb1d51d31": "pay(uint64,address)", "0x7140bdf3": "get_all_best_offers()", "0x0380e2f3": "getHashOfTheSignedDocument()", "0x2feda2fa": "POI()", "0x3c0870ae": "challenge(uint256,uint256,uint256,bool)", "0x27a5c7c6": "voteDecline(uint256)", "0xafd8c8c4": "GasProxy(address,address)", "0x8de93222": "purchase(address,uint256)", "0x087e055a": "getConfigBool(bytes)", "0xbaccc92b": "RegulatorIfc(address)", "0x8c546f81": "GNT()", "0x57cb2fc4": "getInt8()", "0xe3083fb5": "removeFromContribution(uint256)", "0x1a092541": "getDescription()", "0x7486a8e3": "get_publisher(bytes32)", "0x089e0ad0": "buildDSMap()", "0x29161820": "Base(uint256)", "0xe2f8feb2": "internal_tester(int256)", "0x1d2dbb22": "CancelMyInvest()", "0x726ab4ef": "getParentHash(bytes)", "0x83d8a90f": "theDonkeyKing()", "0x9babdad6": "removeShareholder(address)", "0xdeb931a2": "getOwner(bytes32)", "0x90cb04e1": "buy(string,uint256,uint16)", "0x2ff92323": "oraclize_query(uint256,string,string[4])", "0xf91a792e": "decryptHand(string,uint256,uint256,uint256)", "0xebf6e91d": "hit(uint256)", "0xb085b9a5": "Example()", "0x07b2779f": "BasicRegulator(address,uint256,uint256)", "0xe10e5dce": "_build(bytes)", "0x3e239e1a": "getHour(uint256)", "0xacc5a0dc": "GetPrize()", "0xa79deb4f": "acceptTradeDeal()", "0xd7c26adb": "oraclize_setProof(bytes1)", "0xc6a17d2b": "pow10(uint256,uint8)", "0xa87d942c": "getCount()", "0xe706918c": "testToggleBitSuccess()", "0xc1812b15": "reorganizeOwners()", "0x7c7c7695": "getAccountID(address)", "0x1a26ed1c": "validateReservedWindowSize(uint256,uint256)", "0x87393bc6": "verifyFirstHalf(uint256[4],uint256[4])", "0x2e52d606": "n()", "0x2037fcbf": "withdrawInvestment(uint256)", "0x77228659": "query2(uint256,string,string,string)", "0xf67a1d37": "BlockChainChallenge()", "0xc67146a5": "check_bet(uint256,address,uint8)", "0xc89f2ce4": "funds()", "0x58e29e17": "initiateProof()", "0xf0e10c0d": "play(address,uint256)", "0x480b70bd": "scheduleCall(address,bytes4,uint256,uint256)", "0x5294157f": "sendWithAllOurGasExceptExt(address,uint256,uint256)", "0xad447a19": "getBalanceDB()", "0x41095b60": "voteForUltimateOutcome(bytes,uint16)", "0x5521d17b": "betOnColor(bool)", "0xc8f8d75d": "Config(uint8,address)", "0x10ae4ce2": "setReleaseValidator(address)", "0x9fd4f7d1": "replaceWizard(address)", "0x77c78df9": "getCurrentLevel()", "0x1dda5c7d": "testFailSubBalanceBelowZero()", "0x21e5383a": "addBalance(address,uint256)", "0xb0414a2d": "setMinimumGasLimit(uint256)", "0x919840ad": "check()", "0xf651bf44": "move_to(uint16)", "0x0b97bc86": "startDate()", "0x29f1bff4": "withdrawFromChildDAO(uint256)", "0x7a02dc06": "getInfo(bytes32)", "0xe5bf93b9": "balanceEther(uint256)", "0x288c6ed2": "getSeedCost(uint256)", "0x4db3da83": "scheduleCall(bytes4)", "0x270cfee1": "getTokenAccount()", "0xb5d03751": "YoutubeViews()", "0x27e056a5": "addMinter(int256,address)", "0xfa7d68f1": "getAccountInfo(uint256,uint256)", "0x09fc8f6d": "isTokenUpgraded(bytes32)", "0xa5b9e922": "getContentTimetamp(uint256)", "0x1f8947c1": "extractUint(int256,bytes,uint256,uint256)", "0xbcc941b6": "totalWinners()", "0x1db71ffb": "doLoops(uint256)", "0x35ae41c9": "godAutomaticCollectFee()", "0x42cf0e72": "searchByOwner(address)", "0x69f18967": "testSetBitFailIndexOOB()", "0x57b07cd9": "getReleaseHash(uint256)", "0x2baf4f22": "_safeFalse()", "0x3133f2a7": "outstandingBalance()", "0x773c84ee": "exec(address,bytes,uint256,uint256)", "0x9070b18d": "_getAllRevisionBlockNumbers(bytes32)", "0x476e04c7": "NewMessage(string)", "0x3b91ceef": "setMax(uint256,uint256)", "0xe6cb9013": "safeAdd(uint256,uint256)", "0xc2038560": "setOutcome(bytes,bytes)", "0xbed34bba": "compareStrings(string,string)", "0xba8661a2": "TimestampScheduler(address)", "0x4c4aea87": "getReleaseData(bytes32)", "0x1177892f": "getBalanceByAdress(address)", "0x126a710e": "dnsrr(bytes32)", "0x60913244": "botOnSale(uint256,uint256)", "0x5731f357": "oraclize_query(uint256,string,string,string)", "0x3e58c58c": "send(address)", "0x2187a833": "setGreenToken()", "0x5f09952e": "voteAllowTransactions(bool)", "0xf2b26d8f": "nextEtherForSale()", "0x1f201e39": "etherandomExecWithGasLimit(bytes32,bytes32,uint256,uint256)", "0x43d726d6": "close()", "0x6cdf4c90": "ownerSetMinBet(uint256)", "0xe6e8c692": "computeResponseFirstHalf(uint256,uint16)", "0xd1d80fdf": "setAddr(address)", "0x6da1833c": "getInstitutionByName(string)", "0x7682e6ff": "getTrustSetting(address)", "0x8f6f988c": "setUltimateOutcome(bytes)", "0xe299beb3": "SimpleIndex()", "0xa2bb5d48": "get_username(address)", "0x780900dc": "create(uint256)", "0x78710d37": "seven()", "0x2b20e397": "registrar()", "0x4094ef5e": "addDataRequest(string)", "0xc630f92b": "canEnterPool()", "0xdd114c22": "publish(address,uint256,address,uint256)", "0x57006864": "checkBetParity(uint8)", "0x45788ce2": "prev(address)", "0xee8ff562": "setMaxProfit()", "0xdc63a62c": "getFileListHead()", "0x9447fd0a": "until()", "0xb303dcbd": "Owned()", "0x0ecaea73": "create(address,uint256)", "0x20339891": "addGridMember(address)", "0xc8c01a55": "request(address,uint256)", "0x76f10ad0": "getSnapshot(uint256)", "0xc06c4474": "get_burned(bytes32)", "0x67cb61b6": "getChoice()", "0xca708230": "funnel()", "0x08b7fa31": "PriceFeed()", "0xac6bc853": "startSpin()", "0xf4bbfd6a": "scheduleCall(bytes,bytes)", "0xab73e316": "next(address)", "0xba0179b5": "confirm(uint256)", "0x1e62be25": "Bytes32Passer()", "0xb950556a": "setThingValid(bytes32[],bool)", "0xb61c0503": "fireEventLog1()", "0x79a85e6c": "getProductInfo(uint256)", "0x959ac484": "push(uint256)", "0x78e80b39": "UserGetPrize()", "0xff74927b": "strConcat(string,string)", "0xd207e757": "ownerSetOraclizeSafeGas(uint32)", "0x5819dde2": "getNumbersFromBytes(bytes3)", "0xf34ed4e6": "RanDAOPlus(address)", "0x3943807b": "insert(bytes,bytes,int256)", "0x38cc4831": "getAddress()", "0x12a7b914": "getBool()", "0xa4fd6f56": "isEnded()", "0x6c86888b": "testTrade(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32,uint256,address)", "0x0bebd0f9": "addAddressToGeneration(address,uint256)", "0x003074ff": "getFrontend()", "0x2776a859": "computeResponseSecondHalf(uint16)", "0xadfe6b80": "InvestAdd()", "0x6981b5f4": "getLength(string)", "0x4a994eef": "setDelegate(address,bool)", "0xbac1e9f6": "getChannelSize(address,uint256)", "0xbdfdb519": "accept(string,uint256,uint16)", "0x68f5aa0f": "setShareholderDB(address)", "0xafb95eed": "logApproval(address,address,bytes32)", "0xae152cf4": "oraclize_query(string,string,uint256)", "0xe3b26a8c": "SocialNetwork()", "0x54204ad4": "triple()", "0xbc8f3bcb": "ZeroDollarHomePage()", "0xf0350c04": "transfer_ownership(address)", "0xfde9ba41": "transfer(bytes,address,uint256)", "0xfa2acd87": "G(uint64[16],uint256,uint256,uint256,uint256,uint64,uint64)", "0x3a76abff": "_eraseNode(uint256,bytes32[],bytes32)", "0x0acf473b": "AdminCloseContract()", "0x299e7318": "resolveVoting()", "0xb414d4b6": "frozenAccount(address)", "0x8d375da2": "testMakeItFail()", "0x6e8dad74": "retrieveAccountBalance(bytes,bytes)", "0xd3aa831f": "testOwnedTryAuth()", "0x13220305": "doTransferOther(address,address,address,uint256)", "0xb0c7f709": "kingAutomaticCollectFee()", "0x2dabbeed": "reclaim(uint256)", "0x5c19a95c": "delegate(address)", "0xbc2a4dd6": "doBalanceOf(address)", "0x8e7ea5b2": "getWinner()", "0xdb37e42f": "multisetProofType(uint256[],address[])", "0xa6b197aa": "Order(address,uint256)", "0x8cf4dbfb": "collectBalance()", "0xd0821b0e": "bet(uint8)", "0xa02b161e": "unregister(uint256)", "0x09dd0e81": "getBlockchainHead()", "0x8a0807b7": "indexOf(string,string)", "0xe3914699": "dEthereumlotteryNetWinners(address)", "0x44d75fa9": "updateMinorTree(bytes32)", "0x3c21db0a": "theGames(uint256)", "0xf0e959f9": "TokenSales(address)", "0x696bda86": "submitProposal(uint256,bytes)", "0x3b343a13": "getNodeAddress(bytes)", "0x2812f8b8": "FutureCall(address,uint256,uint16,address,bytes4,bytes,uint256,uint256,uint256)", "0xbf32bf97": "FailGuyTax()", "0x89ced196": "setNotUpdatable(bytes32)", "0xb94e962a": "allocateTickets(uint256)", "0x7a479160": "getRequestArgs(uint256)", "0x5a825cbb": "getPayment(uint256,uint256)", "0x4ca8b0d0": "registerExistingThrone(bytes,address,uint256,uint256)", "0x82afd23b": "isActive(uint256)", "0x6ebf10fe": "storeHeader(bytes,address)", "0x1437f9a3": "Set_your_game_number(uint16)", "0xd98d011d": "getCandidateKey(bytes,bytes,bytes,bytes)", "0x8b676ae8": "scheduleCall(address,bytes4,uint256,uint256,uint8,uint256,uint256)", "0x90fd53ec": "farmTile(uint8,uint8,int8)", "0x46e44f63": "getCheckRecordTS(bytes)", "0x1de38038": "makercoin(uint256)", "0xc038a38e": "totals()", "0xfa80918b": "computeNodeId(bytes,bytes)", "0xc76a4bfb": "relayReceiveApproval(address,address,uint256,bytes)", "0x2406cedb": "setPackageOwner(bytes32,address)", "0xb7297cf3": "gameSettings()", "0xe94acf0e": "TinyRouter(address)", "0x4a2b0c38": "DividendProfit()", "0x0e3f732a": "TheGame()", "0xd62457f6": "callValue()", "0x4961b40c": "getReleaseValidator()", "0x540cafe0": "storeHeaderWithFee(bytes,int256,address)", "0x7ff729fc": "fillUpProject(uint256,uint256)", "0x253459e3": "feesSeperateFromBalanceApproximately()", "0x930a80b4": "testAuthorizedSetPackage()", "0xb3cb8885": "nextUnderdogPayout()", "0x62c7855b": "getConfigBytes(bytes32)", "0x4f28af6a": "handleBet(uint256)", "0x103f9251": "transferFrom(address,address)", "0x9b19251a": "whitelist(address)", "0x9928811b": "testBroken()", "0xb33a8a11": "setTokenReference(address)", "0x27f06fff": "requestFillUp(uint256)", "0x2f570a23": "test(bytes)", "0x96ef7aa0": "cash_transfered(string)", "0x3983d5c4": "calcBaseFee(uint256)", "0xec0f1025": "testBitsOrSuccess()", "0xd35f4a99": "mint(int256,address,uint256)", "0x09dfdc71": "currentPyramidBalanceApproximately()", "0xac4e73f9": "proposeReverse(string,address)", "0xac4bd53a": "currentLeader()", "0x5a2ee019": "m()", "0xeba36dbd": "setAddr(uint256,address)", "0x0358d965": "addPayout(uint256)", "0xd7206124": "setInvestorLock(bool)", "0xe916d0f0": "doBalance(address)", "0x67c2a360": "authorizeUser(address)", "0x828d671c": "dyn_sig()", "0xaf6fe8e2": "testGetToken()", "0x283a4576": "Tomeka()", "0x8ac0ca36": "buyViaJohan()", "0xcc872b66": "issue(uint256)", "0xd826f88f": "reset()", "0x2aa3177a": "self_store()", "0x53b7b2e9": "cEthereumlotteryNet(bytes)", "0xce88b145": "getAccount(uint256)", "0x1fa03a2b": "isApprovedFor(address,address)", "0xe42d5be0": "getPaymentOf(address)", "0xb722a9ef": "getPreviousShareholder(address)", "0xfadf87b1": "testGetBitsSuccess()", "0xd26c8a8a": "coinBalance()", "0x30ccebb5": "getStatus(address)", "0x47799da8": "last()", "0x4a5db3b5": "authorizeAddress(address)", "0x22686250": "index(int256,uint256)", "0x07ef99a0": "demintTokens(int256,address,uint8)", "0xea2d4cf8": "__DeployerFunctions(address,address,uint256)", "0x092a2e37": "multiAccessAddOwnerD(address,address)", "0x671fa0a0": "Inscription(string)", "0xa10edc55": "GeneralPurposeProfitSplitter()", "0xd9c67404": "getMerkleRoot(bytes)", "0xdc419fd8": "cancelOrder(bool,uint256)", "0xc9734ebd": "WatchLastPayout()", "0xc7d6faf1": "easyPropose(address,uint256)", "0xfe63300a": "registerExternalBill(uint256,address,address,uint256,uint256,uint256)", "0xd3437fe0": "assertFact(uint256,bytes)", "0x5fb3e119": "Auction()", "0x665beae7": "ExecutableBase(bytes)", "0xc8bb73ef": "testGetBitsFailIndexOOB()", "0xc1d4f708": "getMwLength()", "0x22b0f6ee": "getStatusOfPayout(uint256)", "0x21520c5f": "calculatePayout(uint8,bool,uint256)", "0x66e98c31": "createCoin(string,uint256,uint256,string,string,address)", "0x7b352962": "isFinished()", "0x48d9614d": "GetFee()", "0xfe0d94c1": "execute(uint256)", "0xe4547f98": "documentExists(bytes)", "0x4e10c3ee": "transferWithoutReward(address,uint256)", "0x58ae8bcf": "voteInMasterKey(address)", "0x1dcb304b": "fipsGenerate()", "0xb595181f": "ShapeshiftBot()", "0xe02426c1": "getSignatureHash(bytes4,uint256)", "0x67546967": "EthBtcEscrow()", "0x85b31d7b": "myInfo()", "0xaa677354": "register(address,address)", "0x1d2e2cc4": "ENS()", "0x1097e579": "Enter()", "0x13a396d8": "getRequiredDeposit(bytes)", "0x6df3edef": "getSavedBytes()", "0x09b30ed5": "afterExecute(address)", "0x718e6302": "play(string)", "0x8e46fbb2": "testBitsXorFailIndexOOB()", "0x0d87a7c0": "WLBDrawsDB()", "0xbbe42771": "closeDeed(uint256)", "0xedfbf7b6": "setVotingDeadline(uint256)", "0x299e6b07": "Wallet(address)", "0x5cbc85d0": "returnBounty(uint256)", "0xe5225381": "collect()", "0x94f60a63": "getKudosLeft(address)", "0xd6960697": "confirmPurchase()", "0x4a1f0bf6": "inheritToNextGeneration(address)", "0x244ded7a": "ChangeOwnership(address)", "0x39b35753": "authCancel(address)", "0x75cb2672": "configure(address)", "0x938ae4cc": "testThrowDisownNotTransferable()", "0x04fc11d5": "getActual()", "0xacab021c": "getTOS(address)", "0x812cddf2": "getSavedString()", "0x8ae475a9": "notorize(string)", "0xb1d05422": "SendEmail(string,string)", "0x0fffbb54": "changeRankingSize(uint256)", "0xb6ed9f15": "PFOffer(address,address,bytes,uint256,uint256,uint128)", "0xda333ca6": "payOut(uint256)", "0x652f1f16": "addSignature(string)", "0x983b2d56": "addMinter(address)", "0x5e1936d4": "testThrowSetNotTransferableNotOwner()", "0x4ac1ad78": "getWeekday(uint256)", "0x6ba0b4f2": "isKnownSelector(bytes4)", "0x7c4c27c8": "isThisPuritanicalVersion()", "0x7ae2b5c7": "min(uint256,uint256)", "0x63bd1d4a": "payout()", "0x3fd94686": "changeEligibleDonkeys(uint256)", "0x7fe0518a": "asyncSend(address,uint256)", "0x5a8dd79f": "getDesignatedCaller(address,uint256)", "0x2635f4de": "registerLibrary(bytes,address)", "0x1335ff36": "createEventAndMarketMaker(uint256,uint256,uint8,uint32,address,uint256,uint8,uint16,uint256)", "0x181be00d": "getValue(uint8)", "0x9c1500f0": "registerMany(address,uint256,int256,uint256,bytes,address,bytes)", "0x16f9ce49": "_slotCommitNew(address)", "0x8ca4eef6": "getBuild(bytes32)", "0x8ee21b8e": "get_default_keys()", "0xa66f7ad6": "signRelease(uint256)", "0x414053be": "best_adjustment_for(bool,uint128)", "0x83a51ad0": "oraclize_setConfig(bytes32)", "0x262c0b72": "getPayoutFreezePeriod()", "0x499af77c": "current_spin_number()", "0x4209fff1": "isUser(address)", "0x6e1b6bcc": "checkMyBet(address)", "0xb46300ec": "send()", "0x6b1cb549": "orderMatch(uint256,uint256,uint256,int256,uint256,uint256,address,uint8,bytes32,bytes32,int256)", "0x58d9fa04": "addUser(uint256,address)", "0x24c93343": "error(string)", "0xa95d017d": "getRevisionBlockNumber(bytes32,uint256)", "0x46af23f5": "InstantLottery(address,address,bool,address)", "0x29ef56b1": "getAskOrderBookStats()", "0xe97db66e": "setJackpot()", "0x4b59e880": "puzzle(address,bytes32,bytes32)", "0xc7f86c37": "withdrawFundsRP()", "0x57d4021b": "nextPayoutWhenPyramidBalanceTotalsApproximately()", "0xf1c760ae": "fixBalanceInternal(address)", "0x0908178f": "NoFeePonzi()", "0x22ebb3ac": "DieselPricePeg()", "0xb39a64cd": "getNumCalled()", "0x1c02708d": "killContract()", "0x65228934": "setOperationsCallGas(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256)", "0x3397ca17": "numBalanceRecords(address)", "0xe436bdf3": "Draws(uint256)", "0xaf55bba0": "removeRegistryFromTagsIndex(address)", "0x11103599": "Token_Offer(address,address,uint16)", "0xb3a2a6c0": "setOfficialWebsite(string)", "0xb06eb03f": "DSEasyMultisig(uint256,uint256,uint256)", "0x775c300c": "deploy()", "0xb1c6517a": "LookAtNumberOfPlayers()", "0xc19d93fb": "state()", "0xac9873c7": "CanaryV7()", "0x750cae6a": "enableBetting_only_Dev()", "0xdf3c8620": "num_challenges()", "0xbb00fc55": "bookEarnings()", "0x0bd2ae1c": "ERW()", "0x580bdf3c": "disableBetting_only_Dev()", "0x5c3f9765": "endDateClose()", "0xc4128b6d": "upgradeCount()", "0x140b4465": "executeSpendingRequests()", "0xfaa1a8ff": "getOwnedBot(address,uint256)", "0x40e58ee5": "cancel(uint256)", "0xf4ea95b9": "validateReleaseVersion(uint32[3])", "0x2ba0b09f": "AddNewCategory(bytes4,uint8,uint8,address)", "0x55db4092": "setTOS(address,bool)", "0xf9cc0605": "getAvailable()", "0x3f2f46b4": "revealRock(string)", "0x2af7ceff": "testPrice(uint256)", "0xcaaf2dd7": "getInitialAnswerResult(uint256)", "0x6f36ce79": "insert_deal(address,address,uint64,uint128,uint32)", "0xa18c751e": "set(bytes,bytes)", "0x4d536fe3": "doit()", "0x3197cbb6": "endTime()", "0xb83069c5": "getStemPrice()", "0x3f15457f": "ens()", "0x81ebdeea": "testThrowCreateWithNonceRetracted()", "0x249b4d0b": "removeTrustedIssuer(address,bytes)", "0xe7b48f74": "get(int256,address)", "0x089d5c4a": "repr()", "0x3a9e7433": "scheduleCall(bytes4,uint256,uint256,uint8)", "0x504f1671": "getSize(address)", "0xf3a44fe1": "withdrawForWorkshop()", "0x7a837213": "setAllowedAccount(address)", "0x4551b1d7": "ProxyPayment(address,address)", "0x5dac1601": "SimpleStablecoin()", "0x87914c6f": "prolongateContract()", "0xe3ceb06d": "YesNo(bytes32,address,string,address,uint256)", "0x42a745cb": "testBitEqualSuccess()", "0xaa8dea8c": "fipsAddToLedger(bytes20,address,bytes)", "0x986dcd4d": "setCycleLimit(uint256)", "0x1e44c112": "find_strike(uint64,uint32,uint32)", "0x1ecfe64d": "_jSub(uint256,uint256,uint256,uint256)", "0x4ae85627": "grindUnicorns(uint256)", "0x200ebe34": "addTokensToGive(address)", "0x7b632c41": "TimestampScheduler(address,address)", "0x979b6f6f": "RoundInfo()", "0xb3ea3924": "PointlessCoin(int256,uint256,string,uint8,string,address)", "0x1d834a1b": "insert(uint256,uint256)", "0x931df75f": "validateProposedThroneName(bytes)", "0x6189be15": "columnround(uint256,uint256)", "0xdf5dd1a5": "addOracle(address)", "0x22d8cf5b": "CheckUserVote(uint8,uint8)", "0xdd62ed3e": "allowance(address,address)", "0xc0eb2325": "scheduleTransaction(address,bytes,uint256)", "0x038461ea": "getCertifiedStudentsCount()", "0x9ee035c9": "lookupCanonicalFormat(bytes)", "0x0ab58ead": "SingularDTVFund()", "0x550ed1f0": "getMaxBetAmount()", "0x6e63015c": "getCertifiersCount()", "0xbbd4f854": "buyShares(bytes32,uint8,uint256,uint256)", "0x306b031d": "getGenerationEndAt(uint256)", "0x1bd9c46e": "setImporter()", "0xc80c28a2": "getNumberOfParticipants()", "0xcb553ac9": "sweepWizardCommission(uint256)", "0x6389654e": "changeDailyWithdrawalLimit(uint256)", "0xc0a963c9": "notifyWinner(address,uint256)", "0x3c335b0e": "getRetractable(bytes20)", "0x017972af": "getNumbersFromHash(bytes32)", "0x07da68f5": "stop()", "0x1e8c72b4": "incrUserAvailBal(address,uint256,bool)", "0x0df71602": "setWinner(uint256)", "0x85e5bb3a": "Security_AddPasswordSha3HashToBankAccount(bytes32)", "0x2ade6c36": "getNodeAddress(bytes32)", "0xb33926cb": "owner_withdraw(uint256)", "0x57764094": "getRate(uint256)", "0x13827950": "getShareholderDB()", "0x26826bf8": "setImage(bytes)", "0x76d438b0": "sendReward(uint256,uint256)", "0x51d6e547": "getNonce(bytes)", "0x4f24186a": "newProposal(string)", "0x1a695230": "transfer(address)", "0xe820a32f": "vetoPayout(uint256,uint256)", "0xfb3a1fb2": "getReleaseDb()", "0x6bae05cf": "preRegister(address)", "0xae2df7b3": "setImporterBank()", "0x56d73ad1": "getCertifierDb()", "0x8396392d": "add(string,string,string,address)", "0xeb08b304": "changeMeatProvider(address)", "0xb60e72cc": "log(string,uint256)", "0x76999896": "KingOfTheEtherThrone()", "0xea851885": "buyStake(bool)", "0xa5982885": "assertFalse(bool)", "0xfbf1f78a": "unapprove(address)", "0xc2ba5b40": "getPackageData(string)", "0x83d51a38": "concatString(string)", "0x68af4971": "registerListening()", "0x14ba5c09": "getDay()", "0xe4849b32": "sell(uint256)", "0x44dd4b3b": "lookupGeneration(uint256)", "0x3fda1281": "get_keys()", "0x09241200": "wasSuccessful()", "0xbc9147a4": "Foundation()", "0xe33734fd": "changeProposalDeposit(uint256)", "0x2cce4abe": "_finishNoCallback()", "0x45e965cd": "strConcat(string,string,string,string)", "0xd4245e5b": "transferringETH(address)", "0x10082bff": "getActorBillXdetail(address,uint256,bool)", "0xc831391d": "getPoolOverlapSize()", "0x15e33901": "digest(bytes,uint256)", "0x5f0edfb8": "create(bytes,bytes32,bytes1)", "0xadd4c784": "getResult(bytes32)", "0x3233c686": "claimerDeposit()", "0x187a62d5": "voteEmergencyWithdrawal(bool)", "0x5404bbf7": "getEntropy()", "0x3f5b7675": "periodTwo()", "0x7ec0f30d": "ack(string)", "0xd30a512e": "betOnColumnOrDozen(bool,bool,bool)", "0x9fcbc738": "setIntermediate(address)", "0x539e2bfb": "secondChainedCallback(uint256)", "0xe724529c": "freezeAccount(address,bool)", "0x5aa97eeb": "getMarkets(bytes32[],address)", "0xc51be90f": "query_withGasLimit(uint256,string,string,uint256)", "0x531b97d7": "oneCentOfWei()", "0xeace4827": "player_make_bet(uint8)", "0x9c851ebc": "new_entry()", "0x98c9cdf4": "getMinimumCallGas()", "0xd8f012c6": "StatelessFactory(string,string,string)", "0xceeafd9d": "withdrawFundsAdvancedRP(address,uint256,uint256)", "0xd6d7d525": "get(bytes)", "0xbf55486b": "Tanya()", "0xd35ada32": "addParticipant(address,address)", "0xa8239d0b": "getPrice(string,address)", "0x12514bba": "transfer(uint256)", "0xb00140aa": "getHash(bytes)", "0x36f66528": "EtherDelta(address,uint256,uint256)", "0x279e0912": "getDownloadPrice()", "0x8173b813": "setNumCities(uint256,uint256)", "0xb98fdc36": "IconomiToken(uint256,string,uint8,string,uint256)", "0x3c7a3aff": "commit()", "0xcac77df7": "__transferFromToICAPWithReference(address,bytes32,uint256,string)", "0xfbeaebc6": "murder()", "0x2fa7cbfb": "getExecCost(uint256)", "0xe44d3084": "testFailure()", "0xede8acdb": "startAuction(bytes32)", "0xd5544f94": "getFundsAndAvailable(address)", "0x3824d8ee": "buy100DaoFor1Eth()", "0xbe3945e4": "getFee(address,address,uint256)", "0x1917ab5c": "activate(string)", "0x23509e69": "donkeysEligibleForFees()", "0xf460590b": "updateSigner(address,bool)", "0xc55c1cb6": "queryN_withGasLimit(uint256,string,bytes,uint256)", "0xd96d7ea2": "PRE_EXECUTION_GAS()", "0x1f7b6d32": "length()", "0xacf8bf2a": "channelCount()", "0x18968a03": "finalize(uint256,address,address)", "0x5674a3ed": "runLottery()", "0xe3280126": "addOrder(string,bool)", "0x32afa2f9": "claimEtherOwner(uint256)", "0x355474d2": "commitReading(address)", "0x00601d6c": "board(uint256,uint8,uint8)", "0x2667f407": "__proxy(address,bytes)", "0x79716e43": "confirmTransaction(bytes32)", "0x272cda88": "EternalDB()", "0x76ca0c77": "scheduleCall(address,bytes,uint256,bytes,uint256)", "0x338b5dea": "depositToken(address,uint256)", "0xfa93f883": "getMinute(uint256)", "0xafc4a982": "PathCost(uint16,uint32)", "0xf7d97577": "setPrice(uint256,uint256)", "0x842bc37b": "GetSmallCotractIndex(address)", "0x75f40f40": "underdogPayoutFund()", "0x23a1c271": "setPongval(int8)", "0x02571be3": "owner(bytes32)", "0xf79b22e0": "betOnATeam(uint256)", "0x10cf5d47": "awaitingPayout()", "0x1b00fe51": "testHypothesis()", "0xd449ce7c": "Administered()", "0x455259cb": "getGasPrice()", "0x975057e7": "store()", "0xdfdb5f17": "doBurn(address,uint256)", "0xaa497b9d": "scheduleCall(address,uint256,bytes,uint256,uint256,uint8)", "0xcabfb934": "replace(address)", "0x1f1f5e76": "addValueToContribution(uint256)", "0xa0eda9f2": "_transferFee(address,uint256,string)", "0xa8d95fb2": "claim(address,string)", "0x03ee8f08": "getCoeff(uint16)", "0x9872a20a": "registerUInt(address,uint256)", "0xb20d30a9": "setDailyLimit(uint256)", "0xe116b17e": "getKudosLeftForProject(address,address)", "0xf7c9f74a": "insert_contribution(address,uint256)", "0xc7a1865b": "play(bytes32)", "0x356594ab": "EtherTransfer()", "0xe22b0c46": "verify(uint256,uint256,uint8,bytes,bytes)", "0x2fea7b81": "getIdentity(address)", "0x6fa8de90": "changeMeatParameters(uint256,uint256)", "0x37c390e3": "allow_move(uint16)", "0xd22c391a": "validateProposedThroneRules(uint256,uint256,uint256,uint256,uint256)", "0xf6d339e4": "setAddress(bytes32,string,address)", "0xd7cc8362": "isLatestMajorTree(bytes32,bytes32)", "0xdd012a15": "setIt(uint256)", "0x254c91b3": "testBitNotSetSuccess()", "0x47e40553": "nextRound()", "0xa6b206bf": "doSomething(uint256)", "0xac996e7e": "resolvePledging()", "0x71e2d919": "lol()", "0x07d5b826": "buyAllOutcomes(bytes32,uint256)", "0x5f68804e": "SimpleLotto()", "0xa510f776": "setCompany()", "0x0d48e8d0": "doBalance()", "0xd21d7950": "changeGasLimitOfSafeSend(uint256)", "0x3358d2d3": "buildDSTokenFrontend()", "0xec93cfae": "FountainOfWealth()", "0x65b1fdf4": "scheduleIssuePOIs()", "0xdc3080f2": "spentAllowance(address,address)", "0xd1f0bb2d": "populateAllowedFreeExchanges()", "0xd591221f": "testTransfer()", "0xf24b5779": "removeTrustedIssuer(address,string)", "0xed4b1d0d": "scheduleTransaction(uint256)", "0xa83627de": "updatePeriod()", "0xf597a499": "UserDatabase(uint256)", "0x21f8a721": "getAddress(bytes32)", "0x5548c837": "Deposit(address,address,uint256)", "0x55b775ea": "setFeed(address)", "0x01b869f1": "release(uint32,uint32,uint32,bytes)", "0x609ff1bd": "winningProposal()", "0xdf98ef33": "getResource(bytes,uint256,bytes)", "0xd39eb301": "getStatus(uint8,uint8)", "0x2cc0b254": "init(address,bytes32)", "0x4228974c": "Videos()", "0xc431f885": "addToContribution()", "0x00e43ee9": "setMigrationStatus(uint256,address)", "0xd9f8a4e2": "calcCurrentTokenPrice()", "0xb9e6f1d9": "get_amount()", "0x6b3a87d2": "WatchWinningPot()", "0xef4592fb": "getResult(bytes)", "0x41b9dc2b": "has(bytes32,bytes32)", "0x3b9901cc": "getChannelsByRanks(address,uint256,uint256)", "0x83876bc9": "newProposalInWei(address,uint256,string,bytes)", "0x50a3bd39": "enterPool()", "0xc976bbbb": "_compare(int256,bytes2,int256)", "0x0e47c76f": "rotate(uint64,uint256)", "0x6f85c7e4": "WAITING_PERIOD()", "0x7075b1d8": "latestMonarchInternal()", "0x9209b3c0": "getCrtDetails(bytes)", "0x305075db": "NormalizeRanks()", "0xb6b55f25": "deposit(uint256)", "0xf09ea2a6": "offer(uint256,address,uint256,address)", "0xf1320af2": "exempt(address)", "0xc813c30e": "testThrowSomething()", "0x4faa2d54": "getTimeElapsed()", "0x22017c5f": "DSTokenBase(uint256)", "0x6637b882": "setDao(address)", "0xd0b52156": "getIpfsHash(address,address)", "0x13bd4e2c": "_prepareAndSendReward()", "0xdb7ca38a": "XaurmProxyContract()", "0x1bad1d2e": "monitorWallet(address)", "0x691f3431": "name(bytes32)", "0x3169ff3e": "LooneyLottery()", "0x446a7974": "Fokitol()", "0xdc3ab866": "checkEarnings(address)", "0xfad9bf9e": "storeBlockWithFeeAndRecipient(bytes,int256,int256,bytes,int256,int256)", "0xaf408d89": "setStatus(bytes)", "0xd02bf162": "spinTheWheel()", "0x9a36f932": "feeDivisor()", "0xca77ab8a": "getNextFile(bytes)", "0xc8e49707": "activateExportFee(address)", "0x502414e4": "marketMaker(string)", "0x78ec81a0": "sendEarnings(address)", "0x14167bf0": "oraclize_query(string,string[])", "0xba13a572": "lottery()", "0x299ed37a": "emergencyCall()", "0x6ec3af26": "addTrustedIssuer(address,bytes)", "0x3d69b403": "isOutcomeSet(bytes)", "0x9a19a953": "setInt8(int8)", "0x7817a60f": "acceptMember(address,string)", "0x1e223143": "getFirst()", "0x5437b39b": "hasUnprocessedDividends(address)", "0x8f0c724c": "setOperationsCallGas(uint256)", "0x3c925f16": "getAccountHolder()", "0x477801b1": "getLastRoundResults_by_index(uint256)", "0x3d21aa42": "sendApproval(address,uint256,address)", "0xd2b8035a": "draw(uint256,uint256)", "0x19c32e0b": "hmacsha256(bytes,bytes)", "0x28f90e4b": "Etheramid2()", "0xe87df70e": "fivetimes()", "0xc028df06": "offer()", "0xacb6c69b": "setTrustedClient(address)", "0xac7ffae3": "updt(uint256,string,uint256,uint256,string,string,address)", "0x0e5ffb3c": "hashVersion(uint32,uint32,uint32,string,string)", "0x4ac6b2be": "getCheckRecordCreator(bytes)", "0x93dafba2": "getSubpot(uint256)", "0x592685d5": "getWindowStart(address,address)", "0xc24a0f8b": "endDate()", "0x3f9b250a": "getDocument(uint256)", "0xd845a4b3": "request(uint256)", "0xa5bfa9a9": "claimToken(bytes32)", "0x8e3957d9": "RandomNumber()", "0x62fb09b2": "getRefDescr(uint256)", "0x9f35d3b2": "start(string,string,uint256,uint256,uint256,uint256)", "0xea1bf386": "getNextSellerBOTdata(uint256)", "0xe27fe50f": "startAuctions(bytes32[])", "0x031d973e": "closeMarket(bytes32)", "0x754dea40": "setBackendOwner(address)", "0xd83a8d11": "testProposing()", "0xf24a534e": "Oracle()", "0xd08275f1": "WolframAlpha()", "0x932db761": "profitsFromBitnationDebitCard()", "0xd96aee49": "MultipleConstructorTest()", "0x4594d06a": "delMinter(int256,address)", "0xb9f256cd": "newProposalInEther(address,uint256,string,bytes)", "0x1d2bca17": "MyToken(uint256,string,uint8,string)", "0x6edbd134": "hasHash()", "0x847f8a10": "Refund(uint32)", "0xb0604a26": "schedule()", "0x6676871d": "reserved_funds()", "0x05888fcd": "tradeBalances(address,uint256,address,uint256,address,uint256)", "0xe771066f": "marriageProof(bytes)", "0x7e32a592": "repairTheCastle()", "0xbab2f552": "currentCycle()", "0x45a3b0bf": "resolveFailPledge()", "0x070a888f": "updateRewardDuration(uint256)", "0x20d9822e": "setAnyoneCanCall(address,string,bool)", "0x224993c2": "setTimeBlock(uint256)", "0x01bd4051": "disown(string)", "0x4bc2a657": "setVoter(address)", "0x522103fa": "changeUnicorn(uint256,address)", "0xc988d70f": "getDailyWithdrawLimit()", "0x2f7f3ecf": "findNextHour(uint256,bytes)", "0x1b769e74": "testThrowsRestartNotUpdatable()", "0x4d561721": "etherandomSetNetwork()", "0x92a781d8": "changeBaseValue(uint256)", "0xf0a78538": "scheduleTransaction(uint256,bytes)", "0x64ef212e": "proxyTransferWithReference(address,uint256,bytes32,string)", "0x97c3ccd8": "ban(address)", "0xdeb6930c": "PriceTicker()", "0x6cc5fdaa": "setBytes32(bytes,bytes)", "0x92c8eb96": "DSFalseFallbackTest()", "0x6534b4e2": "IsPayoutReady__InfoFunction(bytes32)", "0x15e812ad": "getBaseFee()", "0xf5b53e17": "getInt256()", "0x081bf263": "isOOB(uint8,uint8)", "0xd2fb8787": "recordExists(bytes)", "0x86c57fcc": "b32ToBytes(bytes)", "0xe3a199d6": "testThrowCreateNewRevisionNotUpdatable()", "0x57cfeeee": "transfer(address,uint256,bytes32)", "0xb72e717d": "fromAddress(address)", "0x61b20d8c": "retrieveFunds()", "0xf4b103d4": "SimpleStorage(uint256)", "0xe2056c46": "ExtraBalToken()", "0xc3ee6311": "lockAndCall(string)", "0x136af582": "next(bytes,bytes,bytes,bytes,bytes,bytes,bytes)", "0xc5d5997c": "changeSubUser(address,address)", "0xf8018a79": "prepend(address,address)", "0xf6b4dfb4": "contractAddress()", "0x9450b1c8": "addCharityFundation(string,string,string)", "0xd1a8d447": "get_all_bet_values()", "0x66d8c463": "reveal(bytes32,string)", "0xbb963c8a": "transferLibOwnership(bytes,address)", "0xd56b2889": "finish()", "0x9fb25d9e": "LeaderMessage()", "0x6ad50ed4": "investmentEntryInfos()", "0xa4d575ce": "_forward(address,bytes)", "0xa3ec5616": "next(bytes,bytes,bytes,bytes,bytes,bytes,bytes,uint256)", "0x0db73c72": "noevent()", "0xf449619e": "collectPrize(uint256)", "0x1afccfa5": "Proposal(address,address,address,bytes,bool)", "0x4788cabf": "getContractId()", "0x4112987c": "strConcat(string,string,string)", "0x928a00d2": "deleteCoin(uint256)", "0xd9ec0508": "testThrowTransferNotEnabled()", "0x9aaf442c": "applyCensorship(uint256)", "0x49407a44": "claimEther(uint256)", "0x4fcf8210": "eraseRecord(bytes32)", "0x5ed84aa6": "getNymCenterAPIURL()", "0xa3c2c462": "totalReceived()", "0x5938748e": "changeVotingRules(address,address,uint256,uint256,uint256)", "0x6fc9d5e4": "changeCompareTo(uint256)", "0xe2ee9941": "tap(bytes20)", "0x0ff4f160": "oraclize_query(uint256,string,string[1])", "0x43ec3f38": "toSliceB32(bytes32)", "0x3288eb0b": "ChineseCookies()", "0x373c98a2": "authCall(address,bytes32)", "0x6ea056a9": "sweep(address,uint256)", "0x8dc45377": "getDuel1(uint256)", "0xd4625a3a": "equals()", "0x616fca9b": "adopt(address)", "0x32cea83e": "birth(bytes)", "0x002a5cc9": "getTicketHolders(uint256)", "0x31119b4d": "changeDeveloper(address)", "0x69569a51": "setFrontend(address)", "0xb7e24979": "addThing(bytes)", "0x164e68de": "withdrawFees(address)", "0x42bf4431": "orderMatchTest(uint256,uint256,uint256,int256,uint256,uint256,address,address,int256)", "0x5dd672ec": "latestBid()", "0x45fe6e2a": "Scheduler()", "0x55cc4e57": "setIssuer(address)", "0x1df5e755": "Etherandom()", "0x8f70009d": "id_for_address(address,address)", "0x39b50688": "cancelSellOrder()", "0x40953102": "scheduleCall(address,uint256,bytes,uint256,uint256,uint8,uint256)", "0x677913e9": "setAmount(int32)", "0x66671c71": "BaseScheduler(address,address)", "0xfe71aec5": "LittleCactus()", "0x879d46fd": "DAOTrust(address,address,bytes,uint256,uint256,uint128)", "0x3b143184": "Congress(uint256,uint256,int256,address)", "0x7370a38d": "getNumPackages()", "0xfee35ff8": "newInvest(uint256,address,uint256)", "0x57dc9760": "DaoChallenge()", "0x8ac78c80": "Docsign()", "0x76d66f5d": "_Transfer(address,address,bytes32)", "0x9dc2c8f5": "fireEventLog4Anonym()", "0x43114842": "acceptChallenge(uint256,uint256,uint256)", "0x2043285d": "getMarketMakers()", "0xfb32f4f5": "ARK_FLAGGER_1_00()", "0x69431ab6": "TokenCreation(uint256,uint256,address,string,string,uint8)", "0x045c6ce0": "voteForProposal(uint256)", "0xa140e79c": "setMinimumDebatePeriod(uint256)", "0x331a72d1": "getRetractable(bytes32)", "0x87cc1e1c": "setExporterBank()", "0x7183616c": "notarize(string)", "0xce79add1": "givableBalanceOf(address)", "0x6f0cfab6": "DNSResolver()", "0x1c2f38ff": "paid(uint64)", "0xb7de47d3": "getIndex(uint256,uint256)", "0x04a2b2c2": "testOwnerCanBreach()", "0x65a4dfb3": "oraclize_query(uint256,string,string,string,uint256)", "0xf2ddc772": "confirm(bytes)", "0xa00ce377": "getIsContractValid()", "0xfe9fbb80": "isAuthorized(address)", "0xbbd39ac0": "coinBalanceOf(address)", "0xa4fde8bc": "player_declare_taking_too_long()", "0xd052fbf6": "getHistory(string,uint256)", "0xd205ad7d": "proposeDissolve(bytes)", "0x5a3b7e42": "standard()", "0xf27197ab": "getIsAvailable()", "0x00a94b6e": "oraclize_query(uint256,string,string[5],uint256)", "0x971c803f": "getMinimumStackCheck()", "0x5168afa4": "getPackageHash(bytes,uint8,uint8,uint8)", "0xaef99eef": "Game()", "0x7f924c4e": "testDeposit()", "0xb1adc241": "BalanceDB()", "0x6a704d7b": "AddedToGeneration(address,uint256)", "0xb9f37c86": "Registrar()", "0xc631b292": "closeVoting()", "0x19350aea": "nameFor(address)", "0x85dee34c": "query2_withGasLimit(uint256,string,string,string,uint256)", "0xbf187478": "shift_left(uint64,uint256)", "0x5b6b431d": "Withdraw(uint256)", "0xe5dd90a5": "HumanStandardToken(uint256,string,uint8,string)", "0xbf8c50ff": "scheduleTransaction()", "0x013d64bd": "setCanCall(address,address,string,bool)", "0xb870ecbb": "testNormalWhitelistAdd()", "0xbcd3d8ca": "Collector(address,address,uint256)", "0x4401ff5c": "sellShares(bytes,uint8,uint256,uint256)", "0x3e0dfbdf": "getInvestorByAddress(address)", "0xcb3e64fd": "unhalt()", "0xafc24e3d": "getChallengeAnswer(uint256)", "0xa36c8ec2": "UpdateContractorAddress(address)", "0xd5a4a3c6": "findRecentBet(address)", "0xb028ee13": "s2b(string)", "0x692ad3a9": "round(uint256,uint256,uint256,uint256)", "0x0a7493b4": "Etheropt(uint256,string,uint256,uint256,bytes,address,int256[])", "0x60689557": "Rock()", "0x717fedf0": "getFirstActiveDuel1()", "0xe837ab59": "getParticipantByAddress(address)", "0x32d5fe98": "revealCampaign(uint256,uint256)", "0x0178b8bf": "resolver(bytes32)", "0x44faa139": "Withdraw(uint32)", "0x418cf199": "setEstimateCost(uint256,uint256)", "0xae45850b": "schedulerAddress()", "0xd4871517": "BTCLotto(address,uint256)", "0xfbffb355": "testBitsEqualFailIndexOOB()", "0x2be6d43c": "ARKTagger_1_00()", "0x1df47aad": "ReplayProtection()", "0xb36a0b15": "getSignDetails(uint256,uint8)", "0x9c4baf27": "Skywalker(address,address)", "0xfb34fc6f": "WatchNextBlockReward()", "0xceba30b5": "scheduleTransaction(address,bytes,uint256[4],uint256)", "0xfc94dd18": "verifyHumanStandardToken(address)", "0x1ff13086": "size(int256)", "0xce92dced": "newBid(bytes32)", "0x231944e2": "moveUnits(uint256,uint256,uint256[])", "0x784813e0": "lookupBet(uint256,uint256)", "0xe0e3ba5a": "getLosesShare(address)", "0x5c1b3ca1": "getConfigUint(int256,bytes32)", "0x91060168": "fetchString(address,bytes4,bytes32)", "0x354b2735": "testDeploy()", "0xb88eef53": "registryCreated()", "0x8e3d4e5e": "Fibonacci(bytes)", "0x64bd87d6": "scheduleCall(address,bytes,bytes,uint256,uint256)", "0x5c3d005d": "demote(address)", "0xb6509c12": "Ethereum_twelve_bagger()", "0xe87508be": "investorDeposit()", "0xcb96012e": "hashTo256(bytes32)", "0x314e0fb6": "scheduleTransaction(address,bytes,uint256[3],uint256)", "0x5b6a54bc": "adjustTransactionFee(uint256)", "0x5f515226": "checkBalance(address)", "0x76cd7cbc": "sign(bytes)", "0xce220ecf": "testAddBalanceFailsAboveOverflow()", "0x922fc84b": "taskProcessedNoCosting(uint256)", "0xf8b2cb4f": "getBalance(address)", "0x7a29332d": "buyAllOutcomes(uint256,uint256)", "0x04106c8b": "startGeneration()", "0x8eaa1e29": "getContentByData(address,uint256,string,string)", "0x5a7a8850": "rollWithSeed(bytes32)", "0x2facc4e8": "depositGovernance(uint256,address)", "0xf2561a43": "voteSuicide(address)", "0xee1b4828": "closeBooks()", "0x18f303a1": "SetInternalValues(uint8,uint256)", "0xce60f78d": "createMarriage(bytes,bytes,uint256,bytes,bytes)", "0x18b749c4": "payEther(uint256)", "0xbbc6eb1f": "getDefaultDonation()", "0x0b1ca49a": "removeMember(address)", "0xccf4f413": "setSubRegistrar(string,address)", "0x4616caa9": "pushCoin(uint256,address,string)", "0xd69450d5": "setUUID4Bytes(bytes)", "0xc98165b6": "createTarget()", "0x8c79a24d": "refName(uint256)", "0x56d88e27": "len()", "0xbfc3d84b": "CT()", "0xc7f2e6af": "Contribute(bytes20)", "0xd7e11e9d": "AddTicket(bytes)", "0x2d06177a": "addManager(address)", "0xd588acc4": "claimMiningReward()", "0x2ffb9e64": "updateGasForXaurData(uint256,uint256)", "0xf896503a": "getConfigAddress(bytes32)", "0x9af8c4ba": "respond(uint256,address,bytes)", "0x82a5285d": "getMinBetAmount()", "0x3ead67b5": "changeContractOwner(address)", "0xb29d7914": "getRefResults(uint256)", "0x135128c2": "CounterPartyDeposit()", "0x795b9a6f": "scheduleCall(address,bytes4,uint256,bytes)", "0x83197ef0": "destroy()", "0x433836dc": "scheduleTransaction(address,bytes,uint8,uint256[3],uint256)", "0xf009347d": "KudosProxy(address)", "0xf2fde38b": "transferOwnership(address)", "0x62c99e84": "_Approval(address,address,bytes32)", "0x1b83b823": "notifyPlayer(uint256)", "0xe56c8552": "spinTheWheel(address)", "0x93eec1fb": "setName(uint8,uint8,string)", "0x11af3c68": "divest(address)", "0x8279c7db": "setReceiverAddress(address)", "0x44691f7e": "hasStarted()", "0x349501b7": "checkDepth(uint256)", "0xe8beef5b": "fireEventLog3Anonym()", "0x0870607b": "addSubUser(address)", "0x063925c8": "scheduleCall(bytes,uint256,uint256)", "0xa23744f0": "tryCreateCheckRecord(bytes)", "0x35d79fad": "CertificationDb(address,uint256,address)", "0x44691f2b": "Dispute()", "0xd7ccc2c3": "getLastPayment()", "0x152583de": "getAttributes()", "0x1a9360dd": "checkDate()", "0x420ef2b3": "TargetHash()", "0xf0caea2b": "SmartRoulette()", "0x5d268629": "Refund()", "0x23385089": "emitApprove(address,address,uint256)", "0x7648c929": "returnRemainingEther()", "0x5d5bc4cb": "BetOnRed()", "0xde8fa431": "getSize()", "0xda6b31b9": "testErrorTransferToNullAuthority()", "0x444dd6f3": "Elcoin()", "0xe1fa8e84": "register(bytes32)", "0x3e0a322d": "setStartTime(uint256)", "0x21bacf28": "getDefaultFee()", "0xb1662d58": "setModule(address,bool)", "0x5b0fc9c3": "setOwner(bytes32,address)", "0x40193d17": "getPongvalConstant()", "0xfb95adeb": "testFailBlockhashInsuffiecientFee()", "0x8ecc0950": "returnToOwner()", "0x34b7ac9b": "END_MINTING()", "0xeaa37394": "create(bytes,bytes32,bool,bool,bool,bool,bool)", "0xd7bc23af": "newParameters(int256,uint256,uint256,uint256)", "0x97709cde": "ARK_VOTER_1_00(uint256,uint256,uint256,uint256,uint256,uint256)", "0xcf4a1612": "scheduleTransaction(uint256,address,bytes,uint256)", "0x40695625": "testRetractLatestRevision()", "0x90c3f38f": "setDescription(string)", "0x5fdf05d7": "two()", "0xaaac50bd": "transferDisable(bytes32)", "0x206a44f3": "getNum(bytes,uint256)", "0x7ac26aeb": "getTag(string,uint256)", "0xdc3f65d3": "createdByMe()", "0xe99543aa": "Trash(uint256)", "0x1bcad37a": "getTotalCost()", "0xa7f43779": "remove()", "0x3416f9d4": "subtractSafely(uint256,uint256)", "0x3bcf7d22": "newBribedCitizen(address)", "0x918f1bb5": "ProjectKudos()", "0xcf09e6e1": "SetBigContract(address)", "0x23add736": "claim(uint256,uint256,uint8,bytes,bytes)", "0x8ac6a869": "isObsolete()", "0x2324c67c": "getAllSignatureHashes(bytes4)", "0x981a60f5": "extractNameFromData(bytes)", "0xc018d0e6": "getFeeAmount(int256,int256)", "0x50e06b57": "Etherization()", "0x49e65440": "setSymbol(bytes32)", "0xfaee13b9": "set(int8)", "0x01ffc9a7": "supportsInterface(bytes4)", "0xc0b92612": "changePig(address)", "0x3f9f5b68": "setPreviousID(uint256,int256)", "0x2e9c5e77": "doStackExtension(uint256)", "0xc83be888": "single_move(uint256,uint8,uint8)", "0xef19c332": "_checkSigned(bytes32,uint256,uint8,bytes32,bytes32)", "0x2f30c6f6": "set(uint256,address)", "0x62986e27": "Canary(address,uint16)", "0x44dfdce0": "getNameOwner(bytes)", "0x4b7fcee7": "ownerPausePayouts(bool)", "0x84dac46e": "Fucksign()", "0x0878bc51": "getAttachesto(uint8)", "0x42d16748": "getMinDailyWithdrawalLimit()", "0x4ecd73e2": "DistributeDividends(uint256)", "0x03750d94": "serverSeed(address,bytes32)", "0xea0a5237": "announce(string)", "0x611daa7e": "EmergencyBalanceReset(uint256)", "0x2ae87a70": "getNumContents(address,uint256)", "0x5ec01e4d": "random()", "0xfd735602": "executeN()", "0xfebefd61": "startAuctionsAndBid(bytes32[],bytes32)", "0x8b64d70e": "owner_set_time_limit(uint256)", "0x2839e928": "ackermann(uint256,uint256)", "0xaf29e720": "remainingGasFund(uint256)", "0x9eee85fe": "bookEarnings(address,uint256)", "0x3733ffca": "convertTo(uint256,string,string)", "0xdbde1988": "transferFromWithoutReward(address,address,uint256)", "0xd3edcb5b": "getCreditorAddresses()", "0x77fcb91d": "forward(address,bool)", "0xf062e26b": "check_darkdao()", "0xdef2489b": "convert(address)", "0xccbda1af": "getChannelByName(string)", "0x267c8507": "authorizeManager(address)", "0xf1c30ec0": "reclaim(bytes)", "0xe6470fbe": "updateDefaultPayment()", "0x8fe58eb9": "Triger()", "0xd6b44859": "scheduleUndoIt(uint256)", "0x0eb8ed07": "transferEnable(bytes32)", "0xfc1f2a70": "Add(uint256,string,string)", "0x058026d0": "checkTransferToICAPWithReference(bytes32,uint256,string)", "0xaf27c7b3": "Security_HasPasswordSha3HashBeenAddedToBankAccount()", "0x5b151fd2": "fifty_fifty()", "0x531d1974": "testThrowRetractLatestRevisionEnforceRevisions()", "0x60213b88": "getInitialWithdrawal()", "0x29e94503": "VersionedBlob()", "0x9c5d7030": "reimburseGas(uint256,address,uint256,uint256)", "0xcd9a3c98": "any(bool[7])", "0xb484e532": "getMyMsg()", "0xd1f59db9": "isLatestMinorTree(bytes32,bytes32)", "0xe0c6190d": "checkTime()", "0xaf5610dd": "isThisPreforkVersion()", "0xfa968eea": "minBetAmount()", "0x003538c5": "TestRegistrar(address,bytes32)", "0x71c59097": "MainnetSurvey(uint256,string,bytes32[])", "0xc82aac47": "searchByTag(bytes32)", "0xeca5c793": "testErrorUnauthorizedNameRegister()", "0xdc75f2db": "multiowned(address[],uint256)", "0x4c9ed763": "requestTokensBack()", "0xbd9a5673": "oraclize_query(string,string[5])", "0xb11e3b82": "createEvent(bytes32,bool,int256,int256,uint8,address,address,bytes32[])", "0x86e4e178": "CheckTickets(address,uint256,uint256)", "0x53c84526": "setSmartAffiliateContract(address)", "0x89029d8c": "get_all(uint256,uint256)", "0xc25e6908": "ultimateOutcomes(bytes32)", "0x6b1e564a": "challengeWinningOutcome(bytes32,uint16)", "0x1c895915": "getNumberOfPayments(uint256)", "0x244fcd03": "removeRelease(bytes32,string)", "0x2ca6d2c0": "getAccountSize(address)", "0xfe67a54b": "endAuction()", "0x756fb8c9": "getOptionChain()", "0x88102583": "safeCastSigned(uint256)", "0x60063887": "transferDebt(address,address,address,uint256)", "0x16216f39": "return13()", "0x8089d001": "getHashOfBlock(uint256)", "0x27bc39c0": "submitCanonicalCandidate(bytes,bytes,bytes,bytes)", "0xb29ae23f": "getDateOfSignature()", "0xdd729530": "add_shield(uint16)", "0x38557648": "executeSellOrder(address)", "0xe2a71f12": "accountDelete()", "0xce869a64": "fails()", "0x69bdfd3a": "toContractDie(bytes,bytes,uint256)", "0x99aeade3": "iterateTable(uint256,uint256)", "0x46bdca9a": "equal(string,string)", "0x5e07f240": "shiftBitsLeft(bytes,uint256)", "0x76285b5b": "_is360thDay()", "0x594151e0": "Dice()", "0x4dc43eaf": "setTreasury(uint256,uint256)", "0xec727000": "getApprovalDB()", "0xb144adfb": "balance_of(address)", "0x63052d82": "getOwnersIndex(address)", "0x833b4596": "testApproveSetsAllowance()", "0xc67d376d": "getClosedCandidates()", "0xcf03f5f4": "activateMasterKey(address)", "0x7ca55e00": "etherandomVerify(bytes32,bytes32,bytes32,uint256,uint256)", "0xd92ebe46": "createDAO(address,uint256,uint256,uint256,string,string,uint8)", "0x3773930e": "ConfigureFunction(address,uint256,uint16,uint16,uint16)", "0xfee6d28c": "addSnapshot(string)", "0xe71264fa": "addNewTokens(uint256)", "0xc4d9102f": "setNextID(uint256,int256)", "0xa6f0e577": "isLeapYear(uint16)", "0xc7102df7": "__stopBlock()", "0xfa93019c": "getBlocks(uint8,uint8)", "0xe9794dc1": "CreateHash(uint8,string)", "0x5460ef10": "sendWithExtraGas(address,uint256,uint256)", "0x2f62a6ff": "fipsRegister(uint256,address,bytes)", "0xd630bd53": "pledgeApprove(uint256)", "0x3448c7d6": "createHistory(bytes,address,address)", "0xdda3342b": "ReplicatorFactory()", "0x0cd865ec": "recover(address)", "0xb9f28076": "historyIdx(address)", "0x4dda1764": "CafeMaker()", "0x883ba26b": "getIsSettled()", "0x3f5e268f": "convictInitial(uint256,uint256)", "0x4a3b0eec": "authorizeOpen(uint256,bool,string)", "0xee6d2641": "sendWithExtraGasExt(address,uint256,uint256)", "0xde14bbf7": "randomGen(uint256,uint256)", "0x7f3bd56e": "disburse(address,uint256)", "0x20d8741f": "Feed()", "0x60c6b3a5": "claim(bytes,address,uint256,uint8,bytes,bytes)", "0xda4b5e29": "contains()", "0xb3c25835": "addUser(address,string,string,uint256)", "0xee2af3fb": "set_factory(address)", "0xb821f815": "pay_winner(uint256)", "0x138cc941": "testErrorTransferToRejectAuthority()", "0xc0b6f0c2": "NextRoundAndEvents()", "0xc7e67360": "GAS_BUFFER()", "0x058d7433": "setAlliesContract(address)", "0xd810f298": "computeSettlementAmount()", "0xa24d23eb": "ProcessGame(uint256,uint256)", "0x7ac91cc2": "testFailOwnedAuth()", "0x79c3ddc1": "isPackageOwner(string,address,address)", "0x478ae93c": "playToWin(uint256)", "0x6632a507": "testSetupPrecondition()", "0xb6013cef": "finalize(uint256,uint256)", "0x37b7bf11": "Tile(int256,int256)", "0xecfc7ecc": "placeBid()", "0x70b1d9d4": "requestCanonicalFormat(bytes)", "0x315fdea3": "TreasureChest()", "0xc5575ef0": "checkTransferFrom(address,address,uint256)", "0x65c72840": "getDay(uint256)", "0xd6eafd08": "scheduleCall(address,bytes,bytes,uint8,uint256[4])", "0x350fbe2e": "calcNextDrawTime()", "0x8af784dc": "expectEventsExact(address)", "0x2db89533": "Auth(uint8,address)", "0x9f203255": "setAuditor(address)", "0x2526d960": "clawback()", "0x3fbd40fd": "ProcessDraw()", "0xface030b": "SpinTheWheel(address)", "0x648621ec": "xnotify(string)", "0x22dc36e2": "processed(uint64)", "0x6f52167d": "payDuel(address,string,address,string)", "0x8f70bfa0": "processDeposit()", "0x25ea269e": "Scissors()", "0x93feb13b": "ForceSendHelper(address)", "0xb688a363": "join()", "0x89859b50": "updateLatestTree(bytes32)", "0xf83d08ba": "lock()", "0x7d287697": "testTryGetUnset()", "0x98d5fdca": "getPrice()", "0xfe72e717": "toDie(bytes)", "0xb3c06f50": "transferFrom(address,address,bytes32)", "0x1465aa97": "testingContract()", "0x069d6d1c": "closeOrder(uint256)", "0xa79f26dc": "force()", "0xf2371fb3": "grantGiveableKudos(address,uint256)", "0xaa7dcd84": "testUpdateAuthorityEvent()", "0x0d8b5fa2": "testControllerValidTransferFrom()", "0x0e0f55d0": "RewardOrder(uint256,uint256)", "0x9ea1b79d": "getContentChannel(uint256)", "0x4a67fa7d": "setLotteryFee(uint256)", "0xdb006a75": "redeem(uint256)", "0x8f4ed333": "step2()", "0x1a10cfc3": "delete_entry(uint256,uint256,uint256)", "0xd422e4e0": "takeFee(address,uint256,string)", "0x61a00f6d": "Ballot(bytes32[])", "0x9c30936f": "removeCertificationDocumentFromSelf(bytes32)", "0xa5f4af33": "playerWithdrawPendingTransactions()", "0x07ad9ecb": "safeSend(address,uint256)", "0x8f99ea43": "setDividendDB(address)", "0x1df473bc": "newContract(bytes)", "0xea5ea470": "payFunding(uint256)", "0x743e0c9b": "receiveTokens(uint256)", "0x21835af6": "__dig(uint256)", "0x47448e8a": "set(bytes32,string,bytes32)", "0x9b1ad792": "destroyToken(address,uint256)", "0xf765088f": "UpdateClientAddress(address)", "0xddbbc35c": "searchByName(string)", "0x5ed7ca5b": "halt()", "0x97950740": "roomForBirth()", "0xfc01abbe": "stringToBytes32(string,string)", "0xea3d508a": "selector()", "0x8c88752a": "ContributorList(uint256)", "0x5837e083": "move_history(uint256)", "0xf7c3ee7a": "immortality()", "0x1b9f9647": "accessMyWallet(address)", "0xc8691b2a": "getHistory(uint256)", "0x91e8d3dc": "testBitOrFailIndexOOB()", "0x5c89c10d": "setBannedCycles(uint256[])", "0x4500054f": "isCancellable()", "0x334ef224": "testThrowsUpdateLatestRevisionNotOwner()", "0x763a738c": "allNames()", "0x45590ec8": "addTag(uint256,string)", "0xe7740cf9": "revealPaper(string)", "0xd9d2d058": "Splitter()", "0xb412d4d6": "CafeDelivered()", "0x8365172c": "num_levels()", "0x41c0e1b5": "kill()", "0x3106fea0": "voteOnProposal(uint256,bool,uint256)", "0x82ab890a": "update(uint256)", "0x4636a159": "newPhoneToAddr(address,uint256)", "0x2f29d8c5": "elapsed()", "0x1bf20668": "testAdminTransfer()", "0xf709dd51": "getTrademark()", "0x8b859409": "setRelease(bytes32,bytes32,string)", "0x03959bb7": "setDataContract(address)", "0x4247f52d": "DoRoll()", "0x31ab4066": "testAuthorityTryAuth()", "0xac4b2bae": "newParameters(int256,uint256,int256,uint256)", "0x57eaeddf": "_isContract()", "0x4a3a87e2": "CreateProxyWithControllerAndRecoveryKey(address,address,uint256,uint256)", "0xd116c8c4": "releasePayment()", "0x6615dd83": "setSeedSourceB(address)", "0xb8aca90b": "CurrentGame()", "0xc124e2ea": "checkBetDozen(uint8)", "0x4b0bbf84": "addEntropy()", "0x452fbc41": "USN(address,address,bytes,uint256,uint256,uint128)", "0xcdb6753b": "setNav(uint32)", "0xbb5d40eb": "isValid()", "0xd6f42038": "PhoneToAddress()", "0x6bc3e0f0": "verifySecondHalf(uint256[4],uint256[4],uint256[4])", "0x33893071": "checkMyWithdraw(address)", "0xfb46d4c5": "tweet(string)", "0x248582b0": "receivePaymentForGoodsSoldEarly()", "0x766a3f2e": "Security_ConnectBankAccountToNewOwnerAddress(uint32,string)", "0x1c8d5d38": "allowance(address,address,bytes32)", "0x6b256f57": "DAOSecurity(address,address,bytes,uint256,uint256,uint128)", "0xe8d1e961": "lockAccount(uint256)", "0x152fb125": "SimpleMixer()", "0xf72457af": "CertifierDb()", "0xe8a5282d": "setConfig(bytes32)", "0xbeb92f55": "setCaller(address)", "0x9a571d9f": "isAlphaLower(bytes1)", "0x46a2679a": "getSubpotsCount(uint256)", "0xd62d3115": "testCreate()", "0xb6ed0632": "cancelOrder(uint256,uint256)", "0xc95e81cb": "MyBet(uint8,address)", "0x1d5a9f3f": "object_types(uint256)", "0xa49d53a1": "SmartRevshare()", "0x5b65b9ab": "setFee(uint256,uint256,uint256)", "0x116c6eab": "getProfitShare(address)", "0x8e46afa9": "getDefaultGracePeriod()", "0xdabc706e": "getProposalCost()", "0x3fbb539d": "scheduleCall(address,bytes,uint256,bytes)", "0x86269a88": "checkBetNumber(uint8)", "0xb6ac24df": "updatePatchTree(bytes32)", "0x4637d827": "trust(address)", "0x1c1b8772": "update(address)", "0x5a9f2def": "scheduleCall(bytes4,bytes,uint256,uint256)", "0x81a60c0d": "getResults(uint256)", "0xd1b4ff7e": "multiAccessRevokeD(bytes32,address)", "0x92b7d5b9": "getCurrentGaslimit()", "0x77ceded8": "mintGrey(int256,address,uint256)", "0x2a095fbe": "unlinkEID(bytes,bytes,address)", "0xa6e16ba2": "testThrowsRetractLatestRevisionNotOwner()", "0x4579268a": "getOffer(uint256)", "0xcabb3a3a": "isAlphaNumeric(string)", "0xfadc51cf": "isAlpha(bytes1)", "0xf2022905": "toldYouItWouldWork()", "0x686e8aaa": "GetMoney()", "0x07718a3b": "BankOwner_WithdrawDonations()", "0xc58343ef": "getRequest(uint256)", "0x7b1a547c": "registerAs(address,string,uint256,string,address)", "0x213b9eb8": "setAddr(string,address)", "0x75090ebf": "changeDomain(uint256,uint256,uint256,address)", "0xdbbdf083": "register(uint256,address)", "0xfa4e5e5a": "notify(uint8,string,string)", "0x86a5ff97": "changeStatus(string)", "0xb8f71f26": "scheduleTransaction(uint256,address)", "0xa2ec191a": "addDSource(string,uint256)", "0x18b31f94": "registerLengthFunction(string,string,address)", "0x7b395487": "voteForUltimateOutcome(bytes32,uint16)", "0x39246d75": "VersionModel()", "0xd500dd6a": "challengeTimeout(uint256,bool,address)", "0xd1da09ee": "extractImportFeeChargeLength()", "0xc74e907b": "commit(address,uint256,uint256)", "0x4b09ebb2": "e_exp(uint256)", "0xec3af4a9": "getProjectKudos(address)", "0x714064f3": "BreakableBond(address,address,uint256)", "0xc4bc5da5": "resumeContract()", "0xf7888aec": "balanceOf(address,address)", "0x2f597e71": "testLongInput()", "0x7212b67e": "add_potion(uint16)", "0x9a15f4f3": "getBlockHeader(int256,int256)", "0x6eacd48a": "ownerPauseGame(bool)", "0xf739ed4c": "id_for_user_version(uint256,uint256)", "0xfaf0952b": "testThrowRestartNotOwner()", "0x88a1e895": "test2Fails()", "0x237e9492": "executeProposal(uint256,bytes)", "0x7cb97b2b": "set_owner(address)", "0x2bb685bc": "kill2()", "0xdc52696f": "tokenSupplyChanged()", "0x83d852d9": "shutdownTransactions()", "0x525b25b1": "getDeploymentReward()", "0xeac116c4": "createKingdom(string,address,address,address,address)", "0x014e5fde": "ARKController_1_00()", "0xc6ae3b57": "dEthereumlotteryNet(address,address)", "0xcddbe729": "game(uint256)", "0x8823a9c0": "changeFeeTake(uint256)", "0x021991e7": "getBetsLocked()", "0x3015394c": "cancelRequest(uint256)", "0x9d118770": "destroy(uint256)", "0xe854dfb4": "Order(address,uint256,uint256)", "0x8435be4b": "getLastFarm(uint8,uint8)", "0x27fbcac5": "getChannelFeed(address,uint256,uint256)", "0xc1be4031": "XaurumProxyERC20()", "0x8e25071a": "setProxyCurrator(address)", "0x4f139314": "compensateLatestMonarch(uint256)", "0x85c78fac": "retryOraclizeRequest(uint256)", "0x478e25bf": "resetAction(bytes32)", "0xc74c251f": "addSafely(uint256,uint256)", "0x058aace1": "divest()", "0x6d1da953": "createWithNonce(bytes32,bytes)", "0x30c0f8d6": "scheduleTransaction(address,bytes)", "0x69a5e902": "multiAccessCall(address,uint256,bytes)", "0x6f8b44b0": "setMaxSupply(uint256)", "0x919edc7c": "getChainySender(string)", "0x0b7ad54c": "getContent(uint256)", "0x5bfdc700": "registerData(address,int256,bytes,address)", "0x0d1fce42": "getBankroll()", "0x739b47ca": "recordWin(address)", "0xa5ea11da": "getParameters()", "0xf8af9e6f": "setAdv(uint256,string,string)", "0xe32e9f22": "setDeploymentReward(uint256)", "0x0baaaed9": "setConfigBytes(bytes,bytes)", "0x99f4b251": "mine()", "0x362af076": "createRequest(address[3],address,uint256[11],uint256,bytes)", "0x7fd238ba": "doCoinage(address[],uint256[],uint256,uint256,uint256)", "0x3adb2de7": "bet_this_spin()", "0xa311dd70": "setArray(uint8[10])", "0xc5bf339c": "getLastNonPublished()", "0x9d1bbd7e": "CancelRoundAndRefundAll(uint256)", "0x89790192": "WithFee(address,uint256)", "0x1c879c47": "getMarketHashes(bytes)", "0xbb84d362": "splitProfitVIP_only_Dev()", "0xffb1a6cb": "getWins(address)", "0x3b355af6": "baseData()", "0xb181a8fc": "resetContract()", "0x7d3d6522": "goalReached()", "0xd4c2b6b1": "scheduleTransaction(address,bytes,uint256[5],uint256)", "0xd65ab5f2": "startGame()", "0x4c4766e8": "KittenRegistry()", "0x77e5bf84": "getTxGasprice()", "0xff981099": "getVotes(uint256)", "0x4a7b26ec": "join_game(uint256)", "0xcccf7a8e": "has(uint256)", "0xa525f42c": "transferFromToICAP(address,bytes32,uint256)", "0xeef8e35f": "setChainyURL(string)", "0x557ed1ba": "getTime()", "0x595da94d": "has_owners(uint256)", "0x12511c14": "transferEnable(bytes20)", "0x2b291eb6": "UserAddTicket(bytes)", "0x50baa622": "withdrawToken(uint256)", "0xc01a8c84": "confirmTransaction(uint256)", "0x671dacdc": "CalculateSqrt(uint256)", "0xe74ffbd5": "getPart(bytes32,uint256)", "0xdd54a62f": "content(string)", "0x4025b293": "redeemAllOutcomes(bytes32,uint256)", "0xa8659216": "setInitialLockinDays(uint256)", "0x00b5b223": "computeResponse(uint256,uint16)", "0x2ef761d3": "buyTile(uint8,uint8)", "0x0a874df6": "lookup(uint256)", "0x42c69566": "get_address(address,string)", "0x02dc2e1d": "queuePayment(bytes)", "0x86bb7121": "getBlocksPerRound()", "0xacfdfd1c": "deploy(uint256,string,string,address)", "0x7d298ee3": "beforeExecute(address,uint256)", "0x5023d124": "TestFactory()", "0x827ef325": "_parseMsgData(bytes)", "0xd35b9d83": "codeAt(address)", "0x26161670": "donkeyRanking(uint256)", "0xe0834ea4": "WatchBalanceInEther()", "0xd44f2d3d": "getInitialWithdrawalDone()", "0x4f223fe3": "StatefulFactory(string,string,string)", "0x91cd242d": "setMeta(bytes32,bytes32,bytes32)", "0x9a97043b": "depositIdx(address)", "0x85db2dda": "PayoutQueueSize()", "0x423e1298": "setDoNotAutoRefundTo(bool)", "0xb7a97a2b": "isValidChannel(uint256)", "0xc1441172": "setBlackFlagRequest(uint256,uint256)", "0x53d9d910": "create(address[],uint256,uint256)", "0x64d905c0": "awaitingParticipants()", "0x718bd6dd": "setRequestUntil(uint8)", "0x5a353193": "KrakenPriceTicker()", "0xfb099c84": "newInvestor()", "0xd264e05e": "forward()", "0xcd9f05b8": "balanceEtherAddress(address)", "0xa1da2fb9": "retrieveDAOReward(bool)", "0x60708ae3": "issueAndCommit(address,address,uint256,uint256)", "0x109df68e": "rotateBitsRight(bytes,uint256)", "0x793cd71e": "cashOut()", "0xd3017193": "addUser(address,uint256)", "0xaacf5328": "setVideoID(string,uint256)", "0xb56e1bca": "setExchangeToken()", "0x9341231c": "sendOrThrow(address,uint256)", "0xaed8f3da": "partsPerBillion(uint256,uint256)", "0xdcff5581": "NewFeeAddress(address)", "0xbbe4fd50": "getNow()", "0x3df16377": "make_move_and_claim_victory(uint256,uint8,uint8,uint8,uint8,uint8,uint8,uint8)", "0x5ae5df8f": "deleteRef(string)", "0x6d853ab6": "isSubUser(address)", "0x28472c6c": "claimComputation(bytes,bytes)", "0x2c215998": "updateStatus(string)", "0x7eff1465": "setAccountAllowance(address,address,uint256)", "0xd5089396": "Token(string,string,uint8,uint256)", "0xd1f7a4e4": "createCertificate(bytes)", "0x8c0e2a31": "regProxy(address)", "0xa819819b": "sweepDeityCommission(uint256)", "0x2b861629": "storeBlockHeader(bytes)", "0x25d4bdeb": "LookAtCollectedFees()", "0x5dddea66": "updateState(uint256,uint8,uint256)", "0x3ccfd60b": "withdraw()", "0x6795dbcd": "getAddress(bytes32,string)", "0x9b9ba572": "oraclize_query(string,string[3])", "0xa925d85e": "Exchange(address,address)", "0xbfe8c107": "betOnDozen(bool,bool,bool)", "0x1af716ba": "transferFrom(address,address,uint256,string)", "0x67eae672": "sendCoinFrom(address,uint256,address)", "0x311d5a2a": "recordBalance(address)", "0x7ca823d5": "getAverageChainWork()", "0x19483cd1": "checkHash()", "0xd366fbab": "startLottery(bytes32,uint256,uint256,uint256,uint256,bool)", "0x4d70d1d7": "generateId(uint256)", "0xe13dc28b": "testValidTransfers()", "0x12065fe0": "getBalance()", "0xdd67a360": "OrderLifeCycle()", "0xd7c23572": "historyTimesPlayed(address)", "0x2675c123": "CloseContract()", "0x1381e400": "cancel(uint32)", "0xa48a663c": "transferFromToICAPWithReference(address,bytes32,uint256,string)", "0xb03260be": "scheduleTransaction(uint256,address,bytes)", "0xb37217a4": "getRandomNumber(uint256)", "0x5c54305e": "InsufficientFunds(address,uint256,uint256)", "0x17e1b09b": "minimumDeposit(uint256)", "0x10c4e8b0": "all()", "0xa31d5580": "Registrar(address,bytes32,address)", "0xbe6307c8": "getDraw(uint256)", "0xc985c221": "get_all_levels()", "0x91b7f5ed": "setPrice(uint256)", "0xe42def21": "CryptoHill()", "0x738486bd": "BeerCoin(uint256)", "0xe422ebe9": "getBot()", "0x67dd74ca": "buyTicket(uint256)", "0x276b94e1": "copypaste()", "0x39aaba25": "get_status()", "0x7ed19af9": "multiAccessRevoke(bytes32)", "0x4c1b2446": "transmitInteger(address,bytes,bytes,uint256,uint16)", "0xd014c01f": "enter(address)", "0x1d49e081": "EXECUTE_EXTRA_GAS()", "0x9dafbc13": "initBlock(uint256)", "0xc7e22ac4": "setOracleGas(uint256)", "0xa3053236": "SafeInvestments()", "0xf42ac1de": "minQuorum(uint256)", "0x04d91c6a": "testFail()", "0x0e662cf0": "buyTokens(uint16)", "0x1ef0625b": "player_2(uint256)", "0xcec1365a": "ShortLimit(uint256)", "0x340f5e4e": "get_all_num_levels()", "0x3e2729bf": "isRevocated(bytes)", "0x5a1cc358": "getChannelRank(address,uint256)", "0x4d366398": "runPeerBalance()", "0xaf9a3f9b": "hashName(string)", "0x33298e25": "invoke(uint256,uint256)", "0x63def590": "untrustClient(address)", "0x836d6d66": "WeeklyLotteryB(address,uint256)", "0x7f497550": "scheduleTransfer(address,uint256,uint256)", "0xf9e05ed9": "sha(uint128)", "0xf6458c6a": "toZ1(uint256[3],uint256)", "0xf41017fc": "finalize(uint24)", "0xeeb57139": "CollectMoney(uint256)", "0xfdacd576": "setCompleted(uint256)", "0xb7266456": "StandardToken()", "0x6a8c2437": "totalRescues()", "0x1fdf6e0c": "protectKingdom()", "0xcf31e9fe": "getOutputHash()", "0xc8117b5b": "extractBalanceOfLength()", "0x0674763c": "assert(bool)", "0x87def081": "getFeeRecipient(int256)", "0xc63ff8dd": "claim(bytes)", "0x329bfc33": "getCurrentWinner()", "0x3d6a3664": "setNewOracle(address)", "0xdaa21e0e": "testBitSetSuccess()", "0xbf8783e0": "callAndGetReturn(address,bytes,uint256)", "0xb06df18e": "transfer(bytes20,address)", "0x00100a18": "NewPoll(string,string,uint256,uint256)", "0x2ffb8631": "getReleaseLockfileURI(bytes32)", "0x6716a692": "setDVIP(address)", "0xe8223468": "sha3clone(bytes)", "0x0aeacb5e": "getTotalRecords()", "0x29e30910": "testThrowCreateExistingNonce()", "0x240ecad5": "transferViaProxy(address,address,uint256)", "0xa33d4968": "Tripler()", "0x8caaaae6": "totalWeiPrice()", "0xf28a7912": "quick2()", "0xcbe9ef39": "BasicCoin(uint256,address)", "0xea3d2827": "selectWinner(string)", "0x92e9fd5e": "ColdWallet(address,address)", "0xcd5e3c5d": "roll()", "0x4a82534b": "create(address,address,address,uint256,uint8,uint8,uint256)", "0x5ccd2f9b": "_deleteAllPackedRevisionBlockNumbers(bytes20)", "0x9380b8e7": "testFailAddingMembers()", "0x31b0795c": "registerAddress(address,address)", "0xb76e4890": "Tester()", "0x29c08ba2": "payPremium()", "0xd7f31eb9": "forward(address,uint256,bytes)", "0xd7ef1356": "best_adjustment(bool)", "0x48d9a374": "blockTransfer(address,uint256)", "0x88b9e10e": "seizeTokens(address,uint256)", "0x8736fd16": "getRefStatus(uint256)", "0x2b30d2b8": "invoke(uint256)", "0xd4e78272": "Draw()", "0x0257c48c": "meta(bytes32,bytes32)", "0xc1246d39": "simulatePathwayFromBeneficiary()", "0x699b328a": "randomize()", "0xa200dc73": "getNextShareholder(address)", "0x9a7a7c11": "makeRoll(uint256)", "0x2bf1f9da": "restart(bytes32,bytes)", "0x943a32bc": "Relay(address)", "0x93503337": "isAllowed(bytes32,uint256)", "0xe97b2190": "add_wall(uint16)", "0x0448f79f": "addOptionChain(uint256,string,uint256,uint256,bytes,address,int256[])", "0xc0df77d0": "getRefName(uint256)", "0x27121069": "verify(bytes,uint8,bytes,bytes)", "0xb7009613": "canCall(address,address,bytes4)", "0x0295d71b": "currentDepositLimit()", "0x35ee2783": "Alarm()", "0x71b6663e": "play1(address,uint256)", "0x0178fe3f": "getData(uint256)", "0x489306eb": "oraclize_query(string,string)", "0xfce59d0c": "MangoRepo()", "0x8efc777f": "isBeta(bytes)", "0x1f7b8622": "getVotingDeadline()", "0x76da5667": "admin_kill()", "0x152cf9db": "getDataPoint(int256,uint256,uint256)", "0xd09de08a": "increment()", "0x64ee49fe": "scheduleCall(address,uint256,bytes4,uint256,uint256,uint8)", "0xd9fe60f3": "DTHPool(address,address,uint256,string,string,string)", "0x6b4dd158": "getPrice(bytes)", "0x0a80ef45": "getIsClosed()", "0x51fdaf92": "checkExpiredfunds()", "0x694e0d5b": "StringPasser(uint8[])", "0x0e1d88fc": "addTender(uint256,uint256,address,uint256)", "0x53850db3": "getParticipantById(uint256)", "0xb6cb405b": "getContractor()", "0x4c6b25b1": "results(bytes32)", "0x1c4e6cd0": "NameReg()", "0x53aab434": "buyIn()", "0x1ebe5c0f": "sendWithAllOurGasExcept(address,uint256,uint256)", "0xd98b9bb5": "placeBid(address,uint256)", "0x02e8d8c0": "scheduleTransaction(address,uint256,uint256)", "0x8a120dc9": "testBitEqualFailIndexOOB()", "0x33f707d1": "ownerWithdraw(uint256)", "0x98e00e54": "getCallWindowSize()", "0x4da74ee6": "setVoteIntention(uint256,bool,bool,string)", "0x6617e11a": "NiceGuyTax()", "0xfe13a823": "computeResponseFirstHalf(uint16)", "0xf7bd2361": "LookAtBalance()", "0xb09bc3bf": "try_to_get()", "0x0cee22e9": "testSetBalanceSetsSupply()", "0xae404996": "oraclize_query(string,string[3],uint256)", "0x2ad95786": "winner(address)", "0xe5fe4f31": "buy(uint8,bytes32,bytes32)", "0xe23941bc": "testDepositWithdraw()", "0xfc89aff6": "submitVerifiedUsers(address[])", "0xddf187b0": "dogFight()", "0xb5f5962a": "CALL_GAS_CEILING(uint256)", "0x92093dd6": "getLastResult()", "0xbfad16f4": "new_offer(uint256,uint256)", "0x01df7f30": "validateProposedThroneConfig(uint256,uint256,uint256,uint256)", "0x4054f5de": "EthVentures3()", "0x244c23ee": "Token(uint256,string,uint8,string)", "0xc3daab96": "withdrawBond(uint256)", "0x5fa21f1f": "enableBetting()", "0x3b591ea7": "AmountToForgeTheNextBlock()", "0x8c3c4b34": "getSaleStatus()", "0x7429f1eb": "multiAccessSetRecipientD(address,address)", "0xf99ff4df": "paged(uint256,uint256)", "0x2a64fb63": "getSaleDate(bytes)", "0x749f9889": "changeAllowedRecipients(address,bool)", "0x053c351b": "oraclize_getPrice(string)", "0x19663f7f": "TransferAmountFromBankAccountToAddress(uint256,address)", "0x5292c1a9": "testThrowsRestartEnforceRevisions()", "0x68f2ab8e": "Currency(string,string)", "0xd6e0bf29": "OwnerDeposit()", "0x94c3fa2e": "getLastBlockHashUsed()", "0x45362978": "query1(string,string)", "0xaff21c65": "getMinimumEndowment(uint256)", "0xe33c7ae2": "scheduleTransaction(uint256,uint256,bytes)", "0x9eb9dd3b": "getBetsProcessed()", "0x3807ba1b": "poi()", "0x7281854d": "GetCategoryValue(uint8)", "0x45ee49b9": "getUltimateOutcomes(bytes)", "0x0109f22e": "CrowdSale()", "0x98596726": "note(uint224)", "0x06900c41": "ZeroPonzi()", "0x3df76482": "fipsPublishData(bytes20,bytes)", "0xe0429b6c": "ShinySquirrels()", "0xa4a7cf5c": "redeemWinnings(bytes32)", "0x2e898ddc": "validateTemporalUnit(uint256)", "0x3af75ee1": "storeBlockWithFee(bytes,int256,bytes,int256)", "0x43e6125d": "Badge(address)", "0x75a6a332": "testThrowRetractNotRetractable()", "0xbed411a0": "CheckPrize(address)", "0x16f3cb5e": "__kill()", "0xe8efc1a0": "updatedValue(bytes32)", "0x9c7264d7": "fillOrder(address,uint256)", "0x9a0af2ec": "getStLength()", "0xf62cce34": "_clearRecordHierarchy(uint256,bytes32[],bytes32)", "0x940f851c": "Ballot(uint8)", "0xd96e5565": "testThrowsRetractNotRetractable()", "0x3a314b24": "SendETH(address)", "0xbd8c1d33": "checkTransferFromToICAPWithReference(address,bytes32,uint256,string)", "0x01da73ff": "isValidChannel(bytes)", "0x8f8bde82": "MicroDAO()", "0x2973e372": "isAlphaUpper(bytes1)", "0x1d2b7155": "activateImportFeeChargeRecord(address)", "0x06ab5923": "setSubnodeOwner(bytes32,bytes32,address)", "0x9d7d6667": "multipliers()", "0x8af49ab7": "maintain(uint256,uint256)", "0x1f3a3a53": "mint(int256,uint256)", "0x74389991": "breakit()", "0x64371977": "set(uint256,string)", "0x3fa6497f": "AdminAddFunds()", "0xba7dc45f": "_removeOperation(bytes32)", "0xf81d087d": "prepareLottery()", "0xd239ea8b": "getSchemasLenght()", "0xa2f3ede2": "computeNameHash(bytes)", "0xa28ecf0b": "sendCryptedHand(bytes)", "0x003b9d88": "setLowerFeePercentage(uint8)", "0x98ea5fca": "depositEther()", "0xb9a0a708": "testChargesAmountApproved()", "0x55291dbd": "claimEther()", "0x2d2800f1": "react()", "0xa9d2293d": "lastClaimBlock()", "0xc45aa04c": "queryShareholders(bytes,uint256)", "0x67af1c81": "getRoundIndex()", "0x50b7b7a2": "setRating(bytes32,uint256)", "0x0aa7881a": "MintableToken(int256,uint256)", "0x0eb3f5a0": "sweepCommission(uint256)", "0x97d47a60": "registerAccountant(bytes,address)", "0xe2c61114": "setImportFee(address,uint256)", "0x6dbe31eb": "testSubBalance()", "0xf5c98aff": "GreeterB(bytes)", "0x79216f5f": "add_monster(uint16,uint16,uint16)", "0x023c23db": "getSize(uint256)", "0x0e1ca8a5": "Oraclize()", "0xa05e822a": "howManyOwners()", "0x313b7b19": "finance()", "0x51a5f2f2": "ConsultingHalf(address,address)", "0x1fb6e99d": "paymentNeeded(uint64)", "0x2bffc7ed": "add(string,address)", "0x5c52c2f5": "resetSpentToday()", "0x39cdde32": "ecverify(bytes32,bytes,address)", "0x64e24f4b": "UpdateClientTokenAccount(address)", "0x0d2560ee": "addMe()", "0xd8589be3": "CoinFlipper()", "0x3b46a7df": "ivote(bool)", "0xa6823189": "parseAddr(string)", "0xd0c24e93": "setNotUpdatable(bytes20)", "0x1f13de92": "inEther(uint256)", "0xb6ce5581": "oraclize_query(string,string[5],uint256)", "0x31ae0019": "KissBTC()", "0xdabf7dc8": "PayoutDividendEarly(uint256,bool)", "0xe3da41b5": "sortWinningNumbers(uint8[5])", "0x8ea98117": "setCoordinator(address)", "0xeff6be2f": "changeBaseFee(uint256)", "0x483a83df": "setKYC(address)", "0xf98a4eca": "executeVote(uint256)", "0x776d1a01": "unvest(uint256,uint256,uint256,uint256,uint256,bool)", "0x1cf52f2b": "isActiveRegistrant(address)", "0x24c9bf5e": "Prizes()", "0xb3822da8": "getContents(uint256[])", "0x999a9965": "setMany(uint256,int256,uint256,bytes,address,bytes)", "0xbade6033": "propose(bytes,uint256)", "0xd38159b8": "testPass()", "0xdabf7ec4": "helper(uint256)", "0xf4993bbd": "executeEmergencyWithdrawal()", "0x46ddb7db": "setAccountBalance(address,uint256)", "0xc12af1ce": "fipsRegister(uint256,bytes)", "0x8f420866": "DEFAULT_SEND_GAS()", "0x62770252": "needsFuneral(uint256)", "0x32921690": "checkDepth(address,uint256)", "0xb3c1a588": "parseMsgData(bytes)", "0x29cd5777": "_tryEraseSingleNode(bytes32)", "0xc6e0c908": "checkTransferFromWithReference(address,address,uint256,string)", "0x9bd99195": "multiAccessChangeOwner(address,address)", "0xa360b26f": "Migrations()", "0x6c6f1d93": "getContractCreationValue()", "0x5445e38c": "_isCycleValid(uint256)", "0x2c85f8e0": "oraclize_query(string,string,string,uint256)", "0xcdda62ad": "FutureBlockCall(address,uint256,uint8,address,bytes4,bytes,uint256,uint256,uint16,uint256,uint256)", "0xc8fdc891": "numberOfMonarchs()", "0xf578fd85": "assertEq0(bytes,bytes)", "0xda311588": "getCoin(uint256)", "0x9a35f886": "__dig_then_proxy(uint256)", "0xfa14df6b": "getChangeRecipientFee()", "0x95f0684b": "getPackageNameHash(uint256)", "0x42909a9e": "create_game()", "0x51582ef3": "sendProxyTransaction(address,uint256,uint256,bytes)", "0xc4e41b22": "getTotalSupply()", "0x110df916": "getChannelID(uint256)", "0x4dc3141b": "CalcAll()", "0xb88a802f": "claimReward()", "0x82b2e257": "getTokenBalance()", "0x9bb0e4df": "getUint(int256,bytes32,string)", "0xc1ae4044": "checkBetColor(uint8)", "0x4a8b5389": "allocateBountyAndEcosystemTokens()", "0xdf06f906": "numBets()", "0xdeb80111": "transfer_asset(address,uint256)", "0x5216aeec": "totalInvested()", "0xe2deaa81": "set_reference(uint256,uint256,uint256)", "0x2ffda1e0": "setBlackflag(uint256,bool)", "0xba45b0b8": "transfer(address,address)", "0x7d7c2a1c": "rebalance()", "0xf32efd3c": "recoverUser(address,address,uint256,uint8,bytes32,bytes32)", "0x4571d4c4": "FutureCall(address,uint256,uint16,address,bytes,bytes,uint256,uint256,uint256)", "0x5fc5d48b": "burnUnsoldCoins(address)", "0x4da47ba0": "TokenSale(address,uint256)", "0x3d9ce89b": "scheduleCall(bytes4,bytes,uint256)", "0x6662e4be": "isWinningBet(uint256)", "0xa501e88d": "Content()", "0x4b70cec4": "getTime(address)", "0x12253a6c": "stopContract()", "0x173825d9": "removeOwner(address)", "0x26121ff0": "f()", "0x7b647652": "LittleEthereumDoubler()", "0x0c5c2ca3": "getIndexName(bytes)", "0x90f2c86d": "convertToWei(uint256,string)", "0x83f95f13": "openClaim(string)", "0xe8b5e51f": "invest()", "0xfdc4b338": "authorizeExtension(uint256,bool,string)", "0x4e116eb8": "unRegisterCertificationDb(address)", "0x5c8a1053": "extend(string)", "0xa932ed0d": "whitelistRemove(address)", "0xa1188e56": "getCurrentDifficulty()", "0xbf1fe420": "setGasPrice(uint256)", "0xead710c4": "greet(string)", "0x144fa6d7": "setToken(address)", "0x42402c2c": "fipsTransferMulti(bytes20[],address)", "0x93e84cd9": "play()", "0x741b3c39": "depositBond()", "0x23306ed6": "getMinimumBond()", "0x5f2e686d": "Ethereum_eight_bagger()", "0x9890220b": "drain()", "0x233120aa": "getChainyURL()", "0xe9dc0614": "vote(bytes)", "0x4df53a0f": "testSetApprovalDb()", "0x5fe27ab0": "createHKG(address)", "0xb56b2627": "add_owner(uint256,address)", "0x6f9a023c": "theultimatepyramid()", "0xc8796572": "collectFees()", "0xea3ebae6": "getConfigBool(bytes32)", "0x213ac932": "addUser(address,uint256,uint8,bytes32,bytes32)", "0xfae9d06d": "calculateTxFee(uint256,address)", "0x45d27edf": "forward_method(bytes,address,uint256,bytes)", "0x8e9ccd04": "computeIndexId(address,bytes)", "0x2f6ae467": "transferDocument(bytes,address)", "0x6e353a1d": "emergencyWithdrawal(address)", "0x7dd56411": "ownerOf(bytes32)", "0x9dc35799": "updateReading(uint256)", "0x246c02e6": "check_depth(uint16)", "0x03d22885": "scheduleCall(address,uint256,bytes4,uint256,uint256,uint8,uint256)", "0x881be8f7": "undo()", "0x953307d8": "revealScissors(string)", "0x7af30442": "testToggleBitFailIndexOOB()", "0x1e0c7ed4": "setConfigBool(bytes32,bool)", "0x2e3be78d": "setPrecisionDirect(uint8)", "0x95a078e8": "hasAccess(address)", "0x245a03ec": "scheduleSetIt(uint256,uint256)", "0xb863bd37": "random(uint256)", "0xa5e62f02": "fallbackRP()", "0x618fa9ce": "getBotBillingIndex(uint256,uint256)", "0x06909f69": "cancel(string,uint256)", "0x2b198366": "addCertifier(address)", "0x57e871e7": "blockNumber()", "0x2b98222e": "getInstitutionByAddress(address)", "0x89eedf00": "setPdfHash(bytes,bytes)", "0x7ac4b05e": "returnMyMoney(uint256)", "0x7fc90182": "Pool(uint256)", "0x291e6777": "sendVote(uint256,uint256)", "0x579badf6": "UniversalFunction(uint8,bytes32,bytes32,bytes32,bytes32,bytes32)", "0xe1f21c67": "approve(address,address,uint256)", "0xa1b9af31": "unlockBets()", "0x92d0d153": "t()", "0x095ea7b3": "approve(address,uint256)", "0x9cb31079": "setLowLimit(uint256)", "0xb971b4e5": "setNotTransferable(bytes20)", "0x2a745971": "BlockKing()", "0x582ca57b": "get_associations()", "0xa0d605c6": "addCertificationDocumentInternal(address,bytes32)", "0x85233869": "NumberOfMiners()", "0xb0349184": "clearRecords(bytes32[])", "0x3e8f5b90": "setConfig(string,uint256)", "0x7c73f846": "getMinimumEndowment(uint256,uint256,uint256)", "0xcc9ae3f6": "getMyReward()", "0xac900c2d": "unregisterSeller(address)", "0x306df22d": "GPSDestination(int256,int256,uint256)", "0x5e968a49": "ownerSetMaxProfitAsPercentOfHouse(uint256)", "0x80dcaf27": "getRefNumber()", "0x4245b0f7": "Lottery()", "0xe46164c5": "waitingForPayout()", "0xa8c3ec48": "oraclize_query(uint256,string,string[2])", "0x58ea80e5": "setThroneCreationPrice(uint256)", "0x8a4fb16a": "getWithdrawal(uint256)", "0x4464aec7": "testTryGet()", "0xf3c37bd5": "Verifier(address,uint256,uint8)", "0xb4c4e005": "testTransferToAcceptAuthority()", "0x346b306a": "oraclize_query(string,string,string)", "0x24032866": "checkExecutionAuthorization(address,uint256)", "0x509f8633": "create_account()", "0x26da8e17": "ownerUpdateCostToCallOraclize(uint256)", "0x74a93e6c": "setTokenHolder(address,address)", "0x1baaeb91": "getSignature(bytes4,uint256)", "0x337c1e28": "getIndexRoot(bytes)", "0xac92fdb5": "getSaleDate(bytes16,uint256)", "0x13b2663b": "cash_received(string)", "0x68e4bd99": "testSetBitSuccess()", "0x20620f37": "onAuctionEnd(string)", "0x85528394": "currentClaimPriceWei()", "0x1995333b": "burnFunds(uint256)", "0x5184ffc9": "setAmbiAddress(address,bytes)", "0x269975d0": "GameDetails(uint256)", "0x29274fe1": "buyBOTx(uint256,string,string,address,uint256)", "0x720c4798": "workshop()", "0x6f9a5eab": "createTx(uint256,address,uint256)", "0xb66a323c": "claimThrone(string)", "0x14cabddb": "joinProof(uint256)", "0x76e4ca0d": "voteQuorum(uint256,bool)", "0xbcb3b5d2": "getGamblesList(uint256)", "0xf2080ba6": "Pong(int8)", "0xab470f05": "getCaller()", "0xe0b1cccb": "updateBalance(address,uint256)", "0x4889ca88": "receiveApproval(address,uint256,address)", "0xbc4b3365": "addFunds(address,uint256)", "0x5d1a3b82": "getOutcome(bytes32)", "0x8204ecdd": "getFee(bytes)", "0x49aa4ee2": "removeVote()", "0x9131d803": "testSetFrontend()", "0x72929b56": "getKudosPerProject(address)", "0x287418e7": "query(uint256,uint16)", "0xbb7859b5": "periodThree()", "0x7dc5cd32": "_patternToNumber(bytes)", "0xf7ea7a3d": "setTotalSupply(uint256)", "0xb3f98adc": "vote(uint8)", "0x655388be": "walkTowardsBlock()", "0x856deacf": "findTag(string)", "0xcaab0acc": "testThrowCreateRetracted()", "0xede8ebf3": "checkApprove(address,uint256)", "0x4296a9cb": "getNodeRightChild(bytes)", "0x03cf4fd6": "expire(uint256,uint256,uint8,bytes32,bytes32,bytes32)", "0x87045369": "setCanCall(address,address,bytes4,bool)", "0x0ed21029": "getIssueAssignee(uint256,bytes32)", "0xc5958bda": "removeFile(bytes)", "0xa8026912": "setSource(address)", "0x05a5b8c6": "verifyTx(bytes,int256,int256[],int256,bytes,int256,int256[],int256)", "0xed3058e0": "transferRight(address,bytes)", "0xba487e62": "newCampaign(uint32,uint96,uint16,uint16)", "0xd6c19fe0": "build(bytes,uint256,uint256,address)", "0xebb741cb": "getChannelSize(uint256)", "0x3b996f40": "quarter(uint32,uint32,uint32,uint32)", "0x0b7373d6": "giveAllBack()", "0x3f887fad": "buyShares(uint256,uint8,uint256,uint256)", "0xb5deeca7": "BaseRegistry()", "0x6dd6e87b": "checkOut(int256)", "0x90a85119": "checkBetResult(uint8)", "0x724121ae": "contentExists(uint256)", "0x67bd69a6": "getLastDuel2()", "0x821e9169": "testFailControllerChargeMoreThanApproved()", "0x083ae1fe": "setPackage(string)", "0x8eaa6ac0": "get(bytes32)", "0xf42aa287": "getBlobStore(bytes12)", "0x32a2c5d0": "getContractAddress()", "0x69d89575": "releaseFunds()", "0x984ac378": "lotteryTitle()", "0x3baf4e1e": "newPayment(uint256,uint256)", "0x938c4307": "scheduleCall(bytes4,bytes,uint16,uint8,uint256,uint256,uint256,uint256,uint256)", "0x47372325": "getChannelSize(address)", "0xcb10e0c5": "getLastDuel1()", "0x1a0919dc": "unregister(bytes32)", "0x6a3c1198": "_projectCancelNew()", "0x976b01c0": "setNotRetractable(bytes20)", "0x44d03ac6": "BlockhashFetch(address)", "0xb0fd935b": "registerCertificationDb(address)", "0x2c7c4549": "PurchasableToken(uint256)", "0x3e0a51b4": "TweetAccount()", "0xc5f310c0": "register(bytes12)", "0xc10dd4c6": "getEvents(bytes32[],address)", "0x37a6b9f8": "recordCallback(address,uint256,bytes,bytes)", "0x1b9265b8": "pay()", "0xc91d7e9c": "getFee(bytes32[])", "0xf6c5c80d": "cleanUp()", "0x590e1ae3": "refund()", "0x9c709343": "split(bool,address)", "0xe68d3ae3": "escrow(uint256,string,address,uint256)", "0xa1cb31b7": "_state()", "0xfbac3951": "isBlocked(address)", "0x29dfdded": "addNewDonkey(address)", "0x7bc49a95": "play(uint256,uint256)", "0x5329c681": "checkTimeout(uint256)", "0x7c05caf3": "testCreateCostAuth()", "0x8606f905": "balanceOf(address,bytes)", "0xbe45fd62": "transfer(address,uint256,bytes)", "0xd7130651": "getCity(uint256)", "0xb2353d69": "updateRightLottery(address)", "0x01bb85a4": "__startBlock(string)", "0x4316abbb": "newJester(address)", "0x5c3e426c": "adminRetrieveDonations(address)", "0x293ffca3": "AddressReg()", "0x4156fdb7": "createSwap(uint256)", "0x2852b71c": "accept()", "0x027a5e3f": "getLastVersion(bytes)", "0x3d90d44d": "addPowerSource(address,uint256,uint256)", "0x1ab06ee5": "set(uint256,uint256)", "0x50f07cf9": "setReadingDelay(uint256)", "0x669e48aa": "get(uint256,uint256)", "0xdea9c72b": "getLatestPreReleaseTree(bytes32,uint32,uint32,uint32)", "0x60f66701": "useCoupon(string)", "0x2431f164": "process_payment()", "0x17623e5b": "unauthorizeManager(address)", "0x367bbd78": "strlen(string)", "0xbab86ea8": "test(string,string)", "0x25f3da52": "GetBankAccountNumber()", "0xebb045fa": "PublicResolver(address)", "0xdd57d5c5": "setTrust(address)", "0x22e803c2": "transferBounty()", "0x12c8052f": "won()", "0x3535cd52": "setDailyCosts(uint256)", "0x92d8c8cf": "setupImportFee(address,uint256)", "0x53caf582": "testThrowSetNotUpdatableNotOwner()", "0xb3ade772": "shipProducts(string,string)", "0x61472fd4": "CSGOBets()", "0x5c7c9aa4": "checkAccountState(address)", "0x6560a307": "suggestedGas()", "0xd0d552dd": "setAsset(address)", "0xc02f081a": "shiftBits(bytes,int256)", "0x9348cef7": "reveal(uint256,uint256)", "0x5ca1c5a0": "getNodeValue(bytes)", "0x34c1b4ba": "sha(bytes)", "0xe0117441": "setRegistrationPrice(uint256)", "0x92698814": "reserved(bytes32)", "0xaa1e84de": "hash(bytes)", "0x2125b65b": "transfer(uint32,address,uint224)", "0x9f9eac67": "ChangeName(string)", "0x7eb69ba1": "hint(int256,bytes32,string,bytes20)", "0xc6888fa1": "multiply(uint256)", "0xa9059cbb": "transfer(address,uint256)", "0x84c344fe": "_register(bytes4,string)", "0x744d8b4f": "recordWin(uint256,uint256)", "0xad1ef61e": "donkeyInvested(address)", "0xb4787dc5": "linkEID(bytes,bytes)", "0x7b1cbb13": "getChannelValue(bytes)", "0xd0febe4c": "buyTokens()", "0x74f519db": "setLastTimestamp(uint256,uint256)", "0xe30081a0": "setAddress(address)", "0x6fd902e1": "getCurrentBlockNumber()", "0x25d8dcf2": "betAndFlip()", "0xc062f578": "updateStage()", "0xe0cfc05c": "testThrowsRetractLatestRevisionDoesntHaveAdditionalRevisions()", "0x854f4817": "buyKissBTCWithCallback(address,uint256)", "0x58b1f29c": "refundBounty(uint256)", "0x0645b5d5": "getMyShareholderID()", "0xe9c63b9c": "requestPeerBalance()", "0x1b03316f": "getSecond()", "0xbcc6092a": "MyEtherBank()", "0x1cf43b63": "extractExportFeeChargeLength()", "0x5e58f141": "shares(address,bytes,int256)", "0x6103d70b": "withdrawPayments()", "0x3e0663e0": "AdminDrawProcess()", "0xa0f029fc": "ContractorInterface(address,address,address)", "0xe604cf9f": "get_all_squares()", "0xd13d1ace": "scheduleCall(bytes,bytes,uint16,uint8,uint256,uint256,uint256,uint256,uint256)", "0xb74bc710": "LuckyDoubler()", "0x611f69de": "__proxy_motion(address,uint256,uint256,bytes)", "0xbb814e9e": "versionExists(bytes32)", "0x545e7c61": "deploy(address,address)", "0x1b437d0c": "compareLastCalldata(bytes)", "0x845051d3": "testContractsNotNull()", "0x23de6651": "emitTransfer(address,address,uint256)", "0xd78c20ff": "voteApprove(uint256)", "0x6f13e01b": "EthVenturePlugin()", "0x1f6b0a9d": "getReleaseLockfileURI(string,uint32,uint32,uint32,string,string)", "0x13d4bc24": "buyTokenProxy(address)", "0xd509b16c": "testWithdraw()", "0x2f54bf6e": "isOwner(address)", "0xf60381a1": "stra2cbor(string[])", "0x34dbe44d": "getLastBlockNumberUsed()", "0x28dcfdac": "getSignsCount(uint256)", "0x2888f9d0": "updateMaxBet()", "0xc3b2556d": "lookup(bytes)", "0x6fbaaa1e": "currentMultiplier()", "0xe241c1d9": "deriveKey(uint256,uint256,uint256)", "0x5b37e150": "create(bytes32,bytes)", "0xa1c95ac2": "GSIToken(uint256,string,uint8,string,address)", "0xfc9e53df": "setNextRegistrar(address)", "0x34e8980f": "bootUpHangouts()", "0x457dd8b3": "setMasterKey(address)", "0xdb833e3a": "sellShares(bytes32,uint8,uint256,uint256)", "0x1e5330ca": "checkBetResult(uint8,address,bytes32,bytes32)", "0x4a00a522": "homebase(int256,int256)", "0xb938bf42": "sendBounty(bytes32)", "0x46be96c3": "amountFilled(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32)", "0x2fa00e58": "fipsTransfer(bytes20,address)", "0x95669952": "debtor(address,uint256)", "0x3f19d043": "getContributions(address)", "0xeb455dc6": "sendBitcoin(string,uint256)", "0x034cb28e": "addressOf(address,bytes)", "0x1e26fd33": "setBool(bool)", "0x1b55ba3a": "Start()", "0x6f3fe404": "updateBalances()", "0xc45b415e": "createRequest(address[4],address,uint256[11],uint256,bytes)", "0x180aadb7": "underLimit(uint256)", "0xb44bd51d": "getConfig(string)", "0x93d79105": "hashRelease(bytes32,bytes32)", "0x9f8a13d7": "isActive(address)", "0x257bcd6a": "placeBet(uint256,bytes32,bytes32)", "0xdd10d97e": "getPlayerWaiting()", "0x6d16f79c": "__transferWithReference(address,uint256,string)", "0x6ce1417e": "Fund()", "0x67beaccb": "scheduleCall(bytes)", "0x4b0697e4": "Manager(address)", "0x6a7fc8b7": "setDailyWithdrawLimit(uint128)", "0x7a6e9df7": "getTimestamp(bytes)", "0x797af627": "confirm(bytes32)", "0x81183633": "setStandard(bytes32)", "0x6a1db1bf": "changeFee(uint256)", "0x4e6ab570": "insert_order(address,bool,uint32,uint128)", "0xa4e2d634": "isLocked()", "0x7c79ebce": "expired(uint64)", "0x20965255": "getValue()", "0xfd408767": "fireEventLog4()", "0xcf6b3822": "WatchCollectedFeesInSzabo()", "0x8f7fe231": "ValidetherOracle()", "0xbf12165e": "fillUpSlot(uint256,uint256)", "0xdabdc1f2": "ChangeActiveDigger(address)", "0xe9e7a667": "get_stake(bytes32)", "0x0ad95b44": "bribery()", "0xdb6fcf01": "is_destroyed(uint256)", "0x4378a6e3": "getAttributes(uint256)", "0x71589d6b": "newponzi()", "0x47274dbe": "disableUser(address,address)", "0xb40a5627": "bidCount()", "0xf1eae25c": "mortal()", "0x13af4035": "setOwner(address)", "0xaf030d2c": "setResult(uint256,uint256,bytes32)", "0x098ab6a1": "snapshotCount()", "0x27cca148": "lastClaimedBlock()", "0x940c154b": "lockBet(uint256)", "0x378c0605": "buyTickets(address)", "0xbcfcb03e": "allocateFounderTokens()", "0x0138e31b": "_jAdd(uint256,uint256,uint256,uint256)", "0x0a7f4239": "getAccountFundContract(address)", "0xc96593a0": "The10ETHPyramid()", "0x22beb9b9": "scheduleDoIt(uint256)", "0xdb0e127a": "openDoor()", "0x3dc02266": "fipsRegister(uint256)", "0x7d242ae5": "setBasePrice(uint256,bytes)", "0xe82b7cb2": "proxySetCosignerAddress(address,bytes32)", "0xa60bbcd3": "ModelCoordinator()", "0xc26aa3c9": "lockUnicorn(uint256)", "0x96ff7e97": "requestIdentity()", "0x99753de7": "clear_level()", "0x69d79ad5": "moneySumAtSettlement(address,uint256,uint256,int256,uint256,uint256)", "0xda359dc8": "setBytes(bytes)", "0x6edb4cf6": "testThrowRetractLatestRevisionDoesntHaveAdditionalRevisions()", "0x9d170c5d": "getRef(string)", "0x11cd98ed": "convertToAllTable(uint256,string)", "0x67f809e9": "DynamicPyramid()", "0xd5f37f95": "sign(uint256,uint256,address)", "0xf5562753": "getClaimAmountForBlock(uint256)", "0xc9bbc8c0": "donkeyName(address)", "0x5858ef10": "testErrorNonOwnerCantBreach()", "0x74388347": "checkBetDozen(uint8,address,bytes32,bytes32)", "0xee564544": "_slotCancelNew()", "0xf3bb9741": "commitmentCampaign(uint256,bytes32)", "0x2b68b9c6": "destruct()", "0xa9b8f7b8": "ProtectTheCastle()", "0x16181bb7": "shortSellShares(bytes32,uint8,uint256,uint256)", "0xb524abcf": "totalSupply(bytes32)", "0x8006745b": "getPayout(address)", "0x137c638b": "getExtraGas()", "0x824d5603": "getIndex(uint16,uint16)", "0x245a6f74": "isProxyLegit(address)", "0x9eded57a": "paybackLast()", "0x7b1aa45f": "ownerDeposit()", "0x974654f4": "requiredGas()", "0x76d690bb": "BountyList()", "0xf4b2dfea": "Matching_Finneys()", "0xbd66528a": "claim(bytes32)", "0x85eac05f": "changeOwnerAddress(address)", "0xa69df4b5": "unlock()", "0xe6d9bb0f": "secondsUntilEnd()", "0xcd57a448": "SwapContract(address,uint256)", "0xb245fc92": "findNextMonth(uint256,bytes)", "0x7620f4bb": "fipsNotaryLegacy68b4()", "0x61886014": "combineDice(uint8,uint8)", "0xdf4ec249": "step3()", "0x2262cd94": "wroom()", "0x1099d3ec": "scheduleTransaction(uint256,uint256,uint256,bytes)", "0xd8c34127": "isKnownSignature(string)", "0x8afa08bd": "setDrawDate(uint256)", "0xdb18c972": "play4(address,uint256)", "0x2f30283e": "testSomething()", "0x8ca17995": "divest(uint256)", "0x1ef3755d": "restart()", "0x99bb875c": "funeralAndBirth(bytes,int256,bytes)", "0x157ad5a1": "canWithdrawBond(address,uint256)", "0xfd8055d2": "updateBOTBillingInfo(uint256,string,address,string,string,uint256)", "0xa10889fa": "setVersion(uint32,uint32,uint32,string,string)", "0x51cff8d9": "withdraw(address)", "0xbe999705": "addFunds(uint256)", "0x2e5d1042": "requestPayout(uint256,uint256,bytes32,uint256,uint256)", "0xb50954b6": "cancelWaitingForOpponent()", "0xc42cd8cf": "etherSplit(address,address)", "0x42ce1488": "upload(string)", "0xad04592e": "owner_deposit()", "0xc2cf7326": "hasConfirmed(bytes32,address)", "0x1dbf3bc7": "spend(uint256)", "0x36b81feb": "Deed(address)", "0xf47289e1": "_ecDouble(uint256,uint256,uint256)", "0x026993e0": "Midas(address,address)", "0x5e404de3": "setMaximumCredit(uint256)", "0x0194db8e": "sum(uint256[])", "0xa04a0908": "execute(address,bytes,uint256)", "0x2b4a3b31": "doTransferFrom(address,address,uint256)", "0x96ed10a4": "issuePOIs()", "0xb75c7dc6": "revoke(bytes32)", "0x6056969b": "announce(bytes32)", "0xd63547e6": "GetFreeCnt()", "0x788e26e7": "sponsorDeposit()", "0x550dd006": "calcCostsBuying(uint256,uint8,uint8,uint256)", "0xd4b1d19f": "testThrowsTransferDisabled()", "0x04706fdf": "giveContributionsBackProfitBugged()", "0x5d5483b3": "WatchAppliedFeePercentage()", "0x6bf8f85a": "forceFinish()", "0x3edd90e7": "NewOwner(address)", "0x7c69b5d1": "NewDeposit(uint256)", "0x866f6736": "trustedChildWithdraw()", "0xcdcb7c8f": "chase()", "0x60dccd89": "getContentAccount(uint256)", "0xbff1f9e1": "totalUsers()", "0x1aca00fd": "variable(uint256)", "0x6e658fbe": "myFundsExpireIn(uint256)", "0xddb1bdc8": "credit(address,uint256,uint256)", "0x934bc29d": "exampleFunction(uint256)", "0x113e6b66": "fipsAddToLedger(bytes20,address)", "0x1a88bc66": "slot()", "0xec97cff7": "addCertificationDocument(address,bytes32)", "0x0790e880": "setBlockappsAddr(address)", "0xe0ad411d": "assets(bytes)", "0x791b51f1": "Consulting(address,address)", "0xa26dbf26": "totalParticipants()", "0xb78b52df": "allocate(address,uint256)", "0xdb29fe12": "addShareholder(address)", "0x06459119": "testThrowsTransferNotTransferable()", "0xbadbaa3c": "setCallData()", "0x2c6b2c92": "checkProfitLossSinceInvestorChange()", "0x8aa6f1b1": "setUltimateOutcome(bytes32)", "0xecb98714": "random_damage(uint256)", "0x506e106c": "setToS(string)", "0xf0d474f9": "underdogCount()", "0x2212dbc3": "get_timestamp()", "0xd504ea1d": "getArray()", "0x9b29cb23": "getDailyPayment()", "0x9d3e069c": "StartDraw()", "0x12494160": "isHolder()", "0xbbd4e8c9": "numDeposits()", "0xfea2920e": "createNewDraw()", "0xff556ecb": "releaseUnicorn(uint256)", "0x3bed33ce": "withdrawEther(uint256)", "0xaa9669c1": "roll(uint256,bytes)", "0xa00aede9": "scheduleCall(uint256,address)", "0xc0819961": "Invest()", "0x1ed24195": "getPeriod()", "0x5babb758": "testSetUp()", "0xaaf9d13e": "buyTopDog(uint256,uint256)", "0x7c45ef6c": "stringToSig(string,string)", "0x7353f62b": "testGetApprovalDb()", "0xef7507c8": "testWinner(uint256)", "0x7ef95c6f": "extractAccountAllowanceRecordLength(address)", "0x66099706": "getChannelCred(address,uint256)", "0x5c242c59": "query1(uint256,string,string,uint256)", "0x299a7bcc": "setOwner(address,address)", "0xe1152343": "payout(uint256)", "0xd40a71fb": "step1()", "0xda9c6a46": "getReplyCount(uint256)", "0xffb7bfba": "watchProposal(uint256)", "0x2e1a7d4d": "withdraw(uint256)", "0x03da8902": "transfearDBOwner(address)", "0xc9bd2893": "fines()", "0xfdd3a879": "quick()", "0xda0774ad": "getCallFeeScalar(uint256,uint256)", "0x0f2c9329": "split(address,address)", "0xa3912ec8": "receiveEther()", "0xfd6f5430": "setContent(string,bytes32)", "0x99e0021f": "mergencyCall()", "0xb7aec6a5": "scheduleCall(address,bytes,uint256,uint256,uint8,uint256)", "0x23145ca0": "forceCheck()", "0xc7cf28fe": "canClaimTimeout()", "0x26db7648": "proposedVersion()", "0x60a60fd8": "testProxyCallWithValue()", "0x044d0b06": "oraclize_query(string,string[2])", "0x4f013184": "investInTheSystem()", "0x0c9fd581": "assertTrue(bool)", "0x09574810": "getOperationsNumber()", "0x6e2edf30": "ETCSurvey(address)", "0x3cc86b80": "GetMoney(uint256,address)", "0xf7b89a3e": "getTotalCosts()", "0xb18c6847": "manualUpdateBalances()", "0x8a65d874": "userStats(address)", "0xf80b3cfa": "checkBetLowhigh(uint8)", "0xc2def3b9": "getOrganizer()", "0x2dae9878": "BankOwner_EnableConnectBankAccountToNewOwnerAddress()", "0x1998aeef": "bid()", "0xc64e8bc0": "executeN(uint256)", "0xd4088e33": "setPrice(uint256,uint256,uint64)", "0xd263b7eb": "ownerkill()", "0xc478fc37": "EtherWheel(uint256,uint256,uint8)", "0x05b765ea": "getCertifierStatus(address)", "0x93c32e06": "changeFounder(address)", "0xf207564e": "register(uint256)", "0xae6c0b03": "canWithdrawBond(uint256)", "0x2b1071c9": "testTransferToNullAuthority()", "0xd9feeeb6": "fillMyOrder(uint256)", "0x9fb755d7": "setHotWallet(address)", "0x7f98444f": "randomEnd()", "0xf3fef3a3": "withdraw(address,uint256)", "0x48a0d754": "available()", "0x3af94817": "getPongvalRemote()", "0xec21a913": "setUint256(int256,uint256)", "0x6099af40": "setConfigBool(bytes,bool)", "0xf0cbe059": "proxyTransferFromWithReference(address,address,uint256,bytes32,string)", "0xf93589ce": "didWin(bytes)", "0x1eb5ea2e": "returnFunds()", "0xa6027d53": "IconomiTokenTest(uint256,string,uint8,string,uint256)", "0x8a323b38": "Contract(uint256,string,uint8,string)", "0xb0f07e44": "registerData()", "0xc9d27afe": "vote(uint256,bool)", "0x64265b1a": "share_transfered(string)", "0x78205f67": "testThrowTransferEnableNotTransferable()", "0x081780f4": "clearRecord(bytes32)", "0xdd137b5d": "toBase58(uint256,uint8)", "0x9483e91a": "withdraw(address,uint256,bytes,uint256)", "0xc6502da8": "basePayment()", "0xe17e1274": "testTransferToRejectAuthority()", "0x9af605cb": "__proxy(address,bytes,uint256)", "0x7a8df1b9": "getAffiliateInfo(address)", "0x46b305d6": "lockBetsForWithdraw()", "0x7d4cf602": "buildDSBalanceDB()", "0xce87f626": "replaceWizardRP(address)", "0x125b8f06": "isInNextGeneration()", "0xd0068f80": "getClient(uint256)", "0x7f0899f2": "AddTicket(bytes5[])", "0xb15dcc25": "query(address,bytes2,uint256)", "0x07a9574a": "changeLeaderMessage(string)", "0x16e55626": "getDogName(address)", "0xbc058968": "updateThingData(bytes32[],bytes32[],uint88)", "0x02aa274b": "setForward(bytes4,address)", "0x08f235ec": "getDefaultPayment()", "0x1dd4914b": "withdrawEtherOrThrow(uint256)", "0x7ca31724": "tokenId(address)", "0x0c4f65bd": "getOwnerAddress()", "0xeec3cb41": "placeBet(bool[],uint256,uint256)", "0x9054bdec": "toTimestamp(uint16,uint8,uint8,uint8,uint8,uint8)", "0x468f02d2": "getUnderlyingPrice()", "0x74331be7": "sete(address)", "0xb05e390a": "TokenEther(string,string)", "0x89cc5ea8": "bid(string,address,uint256)", "0xa8893a6e": "getNumOfSalesWithSameId(bytes16)", "0x3defb962": "heartbeat()", "0x15a03930": "TossMyCoin()", "0x1d8ae626": "Security(string,string)", "0xf1bca7a4": "doCall(uint256)", "0xae6215d8": "getBlockHeight(bytes)", "0x8124bb0f": "continueExecution()", "0xc1cbbca7": "contribute(uint256)", "0xa48566ba": "serverSeed(address,bytes)", "0xc0f5a9cb": "deleteThing(bytes32[])", "0x4136aa35": "isAlive()", "0x6fe665e9": "SlotMachine()", "0xfaff50a8": "rootNode()", "0xaf769eff": "Paper()", "0x77863b61": "CrossWhitehatWithdraw(uint256,address)", "0x2bed55b0": "buildDSEasyMultisig(uint256,uint256,uint256)", "0xd2ef7398": "challenge()", "0x96e4ee3d": "convert(uint256,uint256)", "0x2dff6941": "content(bytes32)", "0x4d536f9f": "validateNameExt(bytes)", "0xd4d5d32a": "collectFee()", "0x6620a935": "sendToOwner()", "0x5084da18": "fipsOwner(bytes20)", "0xe419f189": "multiAccessIsOwner(address)", "0xa9fbc614": "lookupTicketHolder(uint256)", "0x11f72496": "testT()", "0x7365870b": "bet(uint256)", "0x09861b81": "flooredSub(uint256,uint256)", "0xe28fed1e": "userRescues(address)", "0x28cc413a": "getProof(uint256,uint256,uint256)", "0x9a8f09bd": "newKing(address)", "0x5d068051": "sendFees(address)", "0x49cbe338": "tryRead(uint64)", "0x691bfc89": "goods(uint16,uint256)", "0xfc36e15b": "vote(string)", "0x48107843": "getNextCallSibling(address)", "0x6461fe39": "transferFromWithReference(address,address,uint256,string)", "0x804e11dc": "testThrowsDisownNotTransferable()", "0x76f30ca1": "toContentID(address,uint256,string,bytes)", "0xa77b2e37": "Coin()", "0x3f2f1596": "setupTreasury(address,uint256)", "0x3de9e4c6": "__transferFromWithReference(address,address,uint256,string)", "0x612e45a3": "newProposal(address,uint256,string,bytes,uint256,bool)", "0x4cdb48e4": "isValidNym(address)", "0x5afa5036": "isCertified(address)", "0x9a1b420b": "OraclizeAddrResolver()", "0xec5c9036": "Crowdsale(address,uint256,uint256)", "0x01095962": "oraclize_setCustomGasPrice(uint256)", "0xe7e2aa0e": "buyer_cancel()", "0x2da8f764": "submitVideo(string,string)", "0x3395dc70": "acceptTransfer(address,address,uint256)", "0xdf143fb7": "HackerGold(address)", "0x63334c58": "transferETC(address)", "0x6a5da6e5": "followCampaign(uint256)", "0x49fb2dc5": "add_to_association(uint256,uint256,uint256)", "0x953aa435": "GetPrice(uint8)", "0xc1257bad": "testPassingAProposal()", "0x3bc5de30": "getData()", "0x4abb9d39": "depletable()", "0x129484b6": "changeFeeRecipient(int256,int256,int256,int256,int256,int256)", "0x902e64e5": "Oath()", "0x8c4dd5cd": "Democracy()", "0xbea124a6": "query(bytes,bytes,int256)", "0x69347990": "ownerWithdrawl()", "0x606deecd": "requestData()", "0x6720ceb1": "sendPayment()", "0xb1050da5": "newProposal(address,uint256,string,bytes)", "0xfeaa29d8": "insertProfitHere()", "0x36f9f49c": "etherandomSeed()", "0xae815843": "query(uint256,string,string,uint256)", "0x752d349c": "depthCheck(int256,int256)", "0xa24835d1": "destroy(address,uint256)", "0x26070774": "Token(address)", "0x6e0d98fe": "setProbabilities(uint32[])", "0x0761a004": "step(uint256,bytes)", "0xad82dcac": "testBlockhashCorrectFee()", "0x0900f010": "upgrade(address)", "0xa288fb1f": "setConfigUint(int256,bytes,uint256)", "0xe88b8ac6": "confirmAndCheck(bytes)", "0xf1a00a53": "unregisterListening(address)", "0xb17acdcd": "collectFees(uint256)", "0xb5d0f16e": "getGasScalar(uint256,uint256)", "0xae999ece": "reserve(string)", "0x95ceb4b3": "winningProtocal()", "0x1a93fa4b": "reorganizeSubUsers()", "0x9243e088": "setEnforceRevisions(bytes20)", "0x342454c7": "isDigit(bytes1)", "0x8e2c6f4d": "initiateVerification(address,bytes,bytes)", "0xddb5b3ac": "SellTokens()", "0xd18dfdc9": "parrot(uint256)", "0xd3732642": "FastRealisticPyramid()", "0x37ab8f20": "notifyPlayer(uint256,uint256,uint256,uint256)", "0xfb6e155f": "availableVolume(address,uint256,address,uint256,uint256,uint256,address,uint8,bytes32,bytes32)", "0x50ab6f7f": "getMsgs()", "0x6b6a53fa": "testThrowsRestartNotOwner()", "0x4dc7cc55": "terminateAlt()", "0x8b9726c1": "multiAccessCallD(address,uint256,bytes,address)", "0x5a74dee5": "multiAccessRemoveOwnerD(address,address)", "0xfd339d18": "testAuthorityTryAuthUnauthorized()", "0xd3d6a975": "testThrowsTransferNotEnabled()", "0x8aa001fc": "getSecond(uint256)", "0x2ec2c246": "unregister(address)", "0xbbdb31cb": "challenge(uint256,address,bool)", "0x635cfda2": "Incrementer()", "0x704b6c02": "setAdmin(address)", "0xc1c723f4": "validateProposedMonarchName(bytes)", "0xadf5e565": "verify(bytes,address,uint256,uint8,bytes,bytes)", "0xbe7cddf8": "TwoD()", "0xc71b583b": "closeRequest()", "0x9cbf9e36": "createToken()", "0x69c4113d": "setNewBudget(uint256,uint256,uint256,uint256)", "0xd4649fde": "expire(uint256,uint8,bytes32,bytes32,bytes32)", "0xf9a7a2ef": "named(bytes)", "0xdbf45aa3": "EthBank()", "0xbb3ce7fe": "DepositHolder()", "0xfb5d5729": "getPongvalTransactional()", "0x2f0b15f6": "testGetUnset()", "0x62891b5d": "multiAccessChangeRequirement(uint256)", "0x538e0759": "refill()", "0x24c65f35": "updateRefundGas()", "0x62b24189": "DepositToBankAccountFromDifferentAddress(uint32)", "0xd81f53fd": "EtherId()", "0xcea943ee": "getSaleConfig()", "0x23647398": "testThrowRetractNotOwner()", "0xcdcd77c0": "baz(uint32,bool)", "0xa677fbd9": "example2Func()", "0xa02b9aac": "getPaymentDataByAddress(address)", "0x268eb055": "setDescription(uint64,bytes)", "0x09d2d0b9": "setServiceAccount(address,bool)", "0x5f70d9ac": "getBot(uint256)", "0x63f80de3": "issueCoin(address,uint256,uint256)", "0x8570153e": "publish(string,string,bytes,address[])", "0x7975c56e": "oraclize_query(uint256,string,string)", "0x7c3064f1": "refundStake()", "0xef4ffee2": "Honestgamble()", "0xfdc193a4": "test3Fails()", "0x0eb495c2": "pushCity()", "0x6a357465": "payHours(address,uint256)", "0x93f0bb51": "order(address,uint256,address,uint256,uint256,uint256,uint8,bytes32,bytes32)", "0x0a9254e4": "setUp()", "0xc490a266": "toUInt(bytes)", "0xf666323e": "UUIDProvider()", "0x857d4c07": "throwScraps(uint256)", "0x7fd8ee68": "computeNameHashExt(bytes)", "0x7bd703e8": "getBalanceInEth(address)", "0x68f65f02": "ChangeShownDenomination(bool,bool,bool,bool)", "0xc7f758a8": "getProposal(uint256)", "0x824dbc9a": "changeMembership(address,uint256,bool,string)", "0x2a228fc2": "processWithdrawals()", "0xe0457884": "betResolution(uint8,uint8,uint8,bool)", "0x550538f6": "getOneTimeCosts()", "0xf3e84cf3": "createNewRevision(bytes32,bytes)", "0x77fe38a4": "transferToICAPWithReference(bytes32,uint256,string)", "0xcc189d00": "Vault(address,uint256)", "0x9e281a98": "withdrawToken(address,uint256)", "0x7b12df39": "userProfits()", "0xa843c97f": "attack(uint256,uint256,uint256[])", "0x9da680f3": "adjustRegistrationFee(uint256)", "0x3ea3f6c5": "activateRegistrar()", "0xb36df681": "ExecutableBase()", "0x0f3a1412": "getArrlist(uint256,uint256)", "0x8b7f0ddd": "register(address,address,string,string,bytes32[],uint256,string)", "0xb5d3a379": "CanaryTestnet()", "0x9894221a": "SendCashForHardwareReturn()", "0xc2b12a73": "setBytes32(bytes32)", "0xff1b4341": "easyPropose(address,uint256,uint256)", "0x927ed13a": "newClient(uint256,address)", "0x9b9d0364": "_setFeeStructure(uint256,uint256,uint256)", "0x01518d76": "sendQuery(uint256)", "0x4112b7f1": "tryGetNameOwner(bytes)", "0xb759f954": "approve(uint256)", "0x810a882f": "setConfigBytes(bytes32,bytes32)", "0xea7a7184": "testGetBalanceDb()", "0xb0c8f9dc": "add(string)", "0xe59f611f": "InputLimit(uint256)", "0xdce293a7": "minLength(uint256)", "0xf509b627": "confirm(address,uint224,uint32,address)", "0xd48bfca7": "addToken(address)", "0x044f9ac8": "findThroneCalled(bytes)", "0x1d57bcf7": "ProofLibInterface()", "0x75830463": "checkBetLowhigh(uint8,address,bytes32,bytes32)", "0x2a45a39a": "Post(address)", "0x29cbdc86": "buyin(address,uint256)", "0x3cbfed74": "getBondBalance()", "0x80a23ddf": "mintBadge(int256,address,uint256)", "0x96b76c23": "stand(uint256)", "0xc392f5a0": "getAllPackageReleaseHashes(string)", "0x4847a79c": "_transfer(address,uint256)", "0x905e6e42": "JSON_Test()", "0x9f489e4e": "getDeposit(uint256,address)", "0x4f8e624e": "Greeter(string)", "0x96013c9c": "testLatestPkgGetter()", "0xe4fc6b6d": "distribute()", "0x423d4ef2": "createChannel()", "0x24d7806c": "isAdmin(address)", "0x691fb8ea": "jumpIn()", "0xd50f6bf0": "transferETH(address)", "0xd0e0813a": "promote(address)", "0x528eedcb": "sendSafe(address,address,uint256)", "0x00faf4dd": "getTokenDivisor()", "0x46a1d95f": "closeMarket(bytes)", "0x318a3fee": "relayTx(bytes,int256,int256[],int256,int256)", "0x49d55d9d": "receiveTransfer(uint256)", "0x4fa99dd0": "Matching_Ethers()", "0x99a5d747": "calculateFee(uint256)", "0x3c67c51e": "testLogs()", "0x12ab7242": "setupStackDepthLib(address)", "0xad9ec17e": "setGreyToken()", "0xc37e8cb2": "testExportAuthorized()", "0x43046844": "placeBet(uint8)", "0xc6e1c178": "TheLuckyOne(bytes)", "0x13d1aa2e": "f(uint256,uint256)", "0x64a4a5d7": "testBitsEqualSuccess()", "0xfb1669ca": "setBalance(uint256)", "0x40fdef80": "administration(uint256,string,uint256,uint256,address)", "0xcf7315c6": "retract(bytes20)", "0x76196c88": "setDnsrr(bytes32,bytes)", "0x08bf2d0d": "getOrderBook(uint256,uint256)", "0x021c309a": "solveBet(address,uint8,bool,uint8)", "0x4de162e4": "extractAccountLength()", "0x56fa47f0": "split(address)", "0xb3a0b1ef": "basicInfoGetter()", "0x26066ad5": "offer(uint256,bytes,uint256,bytes)", "0x99c724ef": "skipInLine(uint256,uint256)", "0x838445e8": "EtherAds(address,address,address)", "0xe06174e4": "settings()", "0xfac5bb92": "getPreRelease(bytes32)", "0x93c94acb": "calculateRewards(uint256[3][3])", "0xd7fa1007": "setHash(bytes32,bytes32)", "0x2a714078": "triggerAuth()", "0x4cd995da": "registerCompany(address,string)", "0xf6469342": "_setPackedBlockNumber(bytes32,uint256)", "0x8e7fd292": "trySetSubnodeOwner(bytes32,address)", "0x4f573cb2": "withdrawRevenue()", "0x924c28c1": "ContractInterface(address,address,address)", "0x4fc9c91a": "identityOf(bytes32)", "0x19901f1d": "TokenSale(uint256,uint256)", "0xaf8b7525": "CollectAndReduceFees(uint256)", "0x3ccb7dc9": "CrowdFund(uint256,uint256)", "0xaeeb96af": "Highlander()", "0xa126c5df": "GAS_TO_AUTHORIZE_EXECUTION()", "0x13c89a8f": "getAllowedTime(bytes32)", "0xf38b0600": "fireEventLog3()", "0xc7144269": "changeSettings_only_Dev(uint256,uint256,uint256,uint256,uint16,uint256,uint256,uint256,uint8,uint8)", "0xefc81a8c": "create()", "0x7429c086": "repeat()", "0x9c0a4bbc": "AlwaysFail()", "0xc3d23e10": "checkBet()", "0x28a45038": "testTryProxyCall()", "0xa668d7c9": "NiceGuyPonzi()", "0x06fe1fd7": "getPackageName(bytes32)", "0x29f27577": "InvestorList(uint256)", "0x57e25a79": "PullPaymentCapable()", "0x6d1669e1": "approveAndCall(address,address,uint256,bytes)", "0xa7e93e87": "retractLatestRevision(bytes20)", "0x9c7e8a03": "addParticipant(address,address,uint256)", "0xc6ab4514": "sendRobust(address,uint256,uint256)", "0xe8f6bc2e": "changeAccountLevelsAddr(address)", "0xb5d1990d": "numRecords()", "0x3e853128": "getGasForXau(address)", "0xa1add510": "hasRelation(bytes32,bytes32,address)", "0x31e3e2fe": "WithDraw()", "0x86723215": "createMarket(bytes,uint256,uint256,address)", "0xce845d1d": "currentBalance()", "0xc3a2c0c3": "scheduleCall()", "0xcf8eeb7e": "subBalance(address,uint256)", "0xaeb4f0d3": "RegisterTwo(address,address)", "0x3c716e08": "updateAuthority(address)", "0x9919b1cc": "getContentsByRanks(address,uint256,uint256,uint256)", "0x0f06670a": "didWin(bytes32)", "0x74e4435f": "getUserAddress(uint256,bytes32)", "0x4664b235": "bytes32_to_bytes(bytes,bytes,bytes)", "0x2ac9bf09": "bid(uint256,uint256,uint256)", "0xf11c4482": "approveFromProxy(address,address,uint256)", "0xfe992c98": "balanceOfAll(address)", "0x43e332c5": "Last_block_number_and_blockhash_used()", "0x0066753e": "removeCertifier(address)", "0xd299dac0": "blake2b(bytes,bytes,uint64)", "0x41395efa": "dgxBalance()", "0xac1b14ff": "proxyCall(uint256)", "0x7a6ce2e1": "getMsgSender()", "0x3855dcd6": "getContrarians_by_index(uint256)", "0xe6febc9b": "investorWithdraw(uint256)", "0xe6e91cfc": "voidFailedPayment(uint256)", "0x547eeac1": "acceptTransfer()", "0x9824425a": "takeOrder(uint256,uint256,uint256,uint256)", "0xdf25ee23": "getIndexId(address,bytes)", "0x0f3d7c3e": "release(string,uint32[3],string,string,string)", "0x15cff546": "isOperationBlocked()", "0x0b927666": "order(address,uint256,address,uint256,uint256,uint256)", "0x00ce2057": "triggerPayment()", "0x9a9c29f6": "settle(uint256,uint256)", "0x0f096163": "Chainy()", "0x2f5a5c5b": "timegame()", "0x900d85fa": "updatePreReleaseTree(bytes32)", "0x1cbd0519": "accountLevel(address)", "0x29a065bd": "getLOg(uint256)", "0xcec95aa1": "getReleaseHashForPackage(string,uint256)", "0x41524433": "sellKissBTCWithCallback(uint256,address,uint256)", "0x5e431709": "sealedBids(address,bytes32)", "0xf55b23c0": "externalLeave()", "0x31375242": "ownerSetTreasury(address)", "0x51b42b00": "deactivate()", "0x5af36e3e": "refund(uint256,uint256)", "0xc5096a69": "feeFor(address,address,uint256)", "0x059a500c": "makeDeposit(uint256)", "0x3c2e7d54": "priv_inMainChain__(int256,int256)", "0x9431f5f0": "withdrawFees(bytes)", "0x91b4a0e7": "Difficulty()", "0x268d50fe": "ownerSetHouseEdge(uint256)", "0x9644fcbd": "changeMembership(address,bool,string)", "0x66aa6f26": "payFee(bytes)", "0x353928d8": "helpRed()", "0x9c1193ea": "GreeterA(bytes)", "0xdd79e33e": "splitIdentifiers(string)", "0x4d268ddd": "payImporterBankForGoodsBought()", "0x656d2f63": "ManagedAccount(address)", "0x1216e771": "expiration(uint64)", "0x36f7cd70": "setPricePerStake(uint256)", "0x7842a3a4": "payReward()", "0x0ae50a39": "GetOwner()", "0xc81caae7": "acceptMember(address,string,string)", "0xe50dce71": "testControllerApproveSetsAllowance()", "0x4b64e492": "execute(address)", "0xd9e947f3": "kickOutMember(address)", "0x35cc59a9": "createSchema(bytes)", "0x2530c905": "rand(uint256)", "0x4894e37f": "__callback(bytes,string,bytes)", "0x70480275": "addAdmin(address)", "0x969cb7c3": "getPublisher(uint256)", "0x4ed4831a": "all(bool[7])", "0x2ef3accc": "getPrice(string,uint256)", "0x67854643": "getGenerationMemberLength(uint256)", "0xe6690fb1": "nextAuction(uint256)", "0x5829d310": "entries(int256)", "0x7fe1dc7e": "getToken(bytes)", "0xe7329e71": "scheduleCall(bytes,bytes,uint256,uint256,uint8,uint256)", "0x41c12a70": "voteNo()", "0x6a28db13": "getQrLength()", "0xdd93890b": "setMeta(uint256,bytes32,bytes32)", "0xa48bdb7c": "results()", "0x9d888e86": "currentVersion()", "0xff81fb91": "unhint(int256,bytes32)", "0x9ec32d45": "challengeWinningOutcome(bytes,uint16)", "0xa0a2f629": "setReferralId(uint256,address)", "0x76577eae": "distributeEarnings()", "0x3e5cee05": "issueIOU(string,uint256,address)", "0xf3c7d275": "prenup(string,string,string,string,string,address,address)", "0x7154ae61": "CheckNumbers(uint8[5])", "0x05de4f07": "getContentParent(uint256)", "0xb81e43fc": "getEventName()", "0xa7eeea37": "NewContributor(uint256)", "0xe816a515": "takeFlight()", "0x05b2b03a": "CertificationCentre(address)", "0x74d4ab27": "fipsRegister()", "0x65fa2f7f": "getLastPrice(uint256)", "0xcc8b34ab": "CrowdCoin()", "0xe2b178a0": "getAuthority()", "0x5fb64fd6": "checkMembership(address)", "0x7948f523": "setAmbiAddress(address,bytes32)", "0xebb71194": "withdrawFees(bytes32)", "0x6545bed3": "Dice(uint256,uint256,uint256,uint256,uint256,uint256,uint256)", "0x7065cb48": "addOwner(address)", "0x913f424c": "_ecMul(uint256,uint256,uint256,uint256)", "0xdbecc372": "Example(uint256)", "0x9f7f760c": "SimpleDice()", "0xca94692d": "abiSignature()", "0x61ba3377": "WatchLastTime()", "0x20e647e1": "checkBetColor(uint8,address,bytes32,bytes32)", "0x0a3b0a4f": "add(address)", "0xc51cf179": "calcBaseFeeForShares(uint256)", "0x8baced64": "isInPool(address)", "0x4dc415de": "reject()", "0x1555e337": "ConferenceCertificate()", "0x9555a942": "withdrawFrom(address,address,uint256)", "0xe1efda6d": "airaSend(address,address,uint256)", "0x8bfc2f33": "delegateDAOTokens(uint256)", "0xb964608d": "get_return_by_level(uint256)", "0x0c1fad51": "setSeedSourceA(address)", "0x98688a95": "Ai()", "0xd930a90b": "testFailMoveBalanceDueToInsufficientFunds()", "0x337b5988": "testSimpleNameRegister()", "0xf06d335e": "_recoverAccount(address,address)", "0x025bbbe5": "newSale(bytes16,uint256,uint256)", "0x984413b8": "_eraseNode(bytes32)", "0x5ea187c9": "BuildByteArray(bytes)", "0xc2a95cc9": "updateTrustSettings(address,uint256)", "0xde0ff7c5": "getEther()", "0x4ac7becf": "SimpleSign()", "0x252786e4": "WatchBlockSizeInEther()", "0xf2016a4f": "updateMinEthPerNotification(uint256)", "0xd743ca38": "newWinner(uint256,address,uint256,uint256,uint256)", "0x9eab5253": "getMembers()", "0x51d38d5f": "addDeveloper(address,string)", "0x930ed251": "getSavedVar()", "0x715ef4ff": "resendFailedPayment(uint256)", "0xb1418cf4": "payHouse()", "0xe1569f6b": "testThrowsSetNotRetractableNotOwner()", "0x4ae9af61": "getBotStats(uint256,uint256)", "0xbf8ecf9c": "authProposals()", "0xc00ca383": "getByOwner(address,uint256)", "0xc8e7ca2e": "getMsgData()", "0x711953ef": "setGameAddress(address)", "0x63a8dac2": "changeSettings(uint256,uint256,uint256,uint8,uint256,uint256,uint8,uint8)", "0x72c87075": "testBlockHeaderFetch()", "0x4c7a2254": "checkMyWithdraw()", "0xab91c7b0": "queueLength()", "0x25209260": "PrepareRoll(uint256)", "0x58150c8b": "GameRegistry()", "0x75608264": "get_hash(uint8,bytes32)", "0x6510ef4d": "oraclize_query(uint256,string,string[5])", "0xd57a12f5": "testCheckSigs()", "0x3f415772": "releaseExists(bytes32)", "0xda25c0cd": "ThisExternalAssembly()", "0xf239e528": "sendOneEtherHome()", "0xc4321adb": "investInTheSystem(uint256)", "0x4fab2ca4": "testGetFrontend()", "0x05261aea": "finalize(uint256)", "0x576eac66": "setFundingGoal(uint256)", "0xe75528cc": "buyBuilding(uint256,uint256)", "0x6ed43eb0": "getInvestorList(uint256)", "0xb38415f3": "getConfigBytes(bytes)", "0x771ad635": "getContentCred(address,uint256)", "0x93c166ec": "computeEndowment(uint256,uint256,uint256,uint256)", "0xac35caee": "transferWithReference(address,uint256,string)", "0xc6803622": "wasCalled()", "0x8cfd8901": "_incBlock()", "0xfcf0f55b": "eventOracles(bytes32,uint256)", "0x505ff574": "register(address,uint256,bool)", "0xf824384a": "addInvestorAtID(uint256)", "0x6b9f96ea": "flush()", "0xc3d0a564": "getAccountBalance(bytes)", "0x30fd300f": "registerBytes32(address,bytes32)", "0xc3169ef2": "respond(uint256,uint256[4])", "0xcf1cd249": "secureSend(address)", "0x62c335c1": "checkCallback(address,uint256,bytes,bytes)", "0xb599afc8": "totalBetCount()", "0x69433e12": "setExchange(uint256)", "0x899942b8": "Devcon2Token()", "0x4c2d71b3": "setConfigAddress(bytes32,address)", "0xb974b0a3": "allData()", "0x27e8c2d8": "burnUnicornShares()", "0xf639365d": "testSetGet()", "0x2f5d3916": "testControllerApproveTriggersEvent()", "0x938b5f32": "origin()", "0xd60dcb5d": "Switch()", "0xde629235": "getCertificationDocumentAtIndex(address,uint256)", "0x329ce29e": "buyTile(uint256)", "0x59e2d30e": "testThrowBlobStoreNotRegistered()", "0xa005b87b": "NullMapTest()", "0xc13afa91": "object_locations(uint256)", "0x4848b1a5": "setData(uint256,uint256)", "0x80ede329": "getDocumentDetails(uint256)", "0x35d13969": "SendAllMoney()", "0x8040cac4": "testOverflow()", "0x9507d39a": "get(uint256)", "0xc040e6b8": "stage()", "0x18178358": "poke()", "0xfd782de5": "Proxy()", "0xfd68a422": "returnmoneycreator(uint8,uint128)", "0x86a50535": "voteFor(uint256)", "0x44602a7d": "testFallbackReturn()", "0xa230c524": "isMember(address)", "0x3ffbd47f": "register(string,string)", "0x8cecf66e": "_inverse(uint256)", "0x51017702": "isOutcomeSet(bytes32)", "0xd408746a": "GetContractAddr()", "0x20130753": "testThrowSetNotRetractableNotOwner()", "0xa0e2abf7": "getFirstActiveGamble()", "0x7c582304": "updateInvestmentTotal(address,uint256)", "0x95d89b41": "symbol()", "0x1768b436": "ETCSurvey()", "0x6d4ce63c": "get()", "0xc41a360a": "getOwner(uint256)", "0x49942ccb": "scheduleCall(bytes,bytes,uint256,uint256)", "0x6b64c769": "startAuction()", "0x084d72f4": "getWinningOutcome(uint256)", "0xd379be23": "claimer()", "0x41fa4876": "multiBlockRandomGen(uint256,uint256)", "0x5bc7e259": "updateRelease(uint32,uint32,uint32,bytes,bool)", "0x47f3d794": "configure(uint256,uint8,uint256,uint256,uint256,uint256)", "0xe2bbb158": "deposit(uint256,uint256)", "0x953a7fab": "testMoveBalance()", "0xeacc5b3b": "safeSend(address,uint256,uint256)", "0x96f0aa8f": "findNextSecond(uint256,bytes)", "0xc8690233": "pubkey(bytes32)", "0x459f93f7": "getBuyers(uint256,address)", "0xf714de9c": "MultiAccess()", "0xf4a81d08": "getKudosGiven(address)", "0x5aa94a68": "computeResultVoteExtraInvestFeesRate()", "0xdb2a0cb7": "HumanStandardTokenFactory()", "0xdf3a6b10": "testMemberAddedEvent()", "0xce8d054e": "_setupNoCallback()", "0x8ea822d8": "createThings(bytes32[],uint16[],bytes32[],uint16[],uint88)", "0x24fb563f": "PlayerTickets(address,uint256,uint256)", "0x8c0e156d": "scheduleCall(bytes4,uint256,uint256)", "0xef04fdb7": "buyShares(bytes,uint8,uint256,uint256)", "0xa0afd731": "dividendBalance(address)", "0xc3c95c7b": "getMarket(bytes32)", "0x94ed9b77": "append(address,address)", "0xc87b36ed": "disableBetting()", "0x566735d8": "PreVNK(uint256,string,string,uint8)", "0x400aae08": "isInCurrentGeneration(address)", "0x44dd4b5e": "scheduleTransaction(address,uint256,bytes)", "0x48c54b9d": "claimTokens()", "0xe8930efd": "Investors(address)", "0xa6f2ae3a": "buy()", "0x12819817": "setXauForGasCurrator(address)", "0x056e1059": "oraclize_query(uint256,string,string,uint256)", "0x7824407f": "tokenSupply()", "0x7f0c949c": "setJurisdication(string)", "0x2e817963": "set_sdl(address)", "0xaee84f6b": "setTime(address,uint256)", "0x3c0dde1c": "_addPools(address,address)", "0xf8bd526e": "setCoinageContract(address)", "0x04b07a5e": "removeUpdater(address)", "0x11149ada": "getProof(uint256)", "0x4306cc3f": "queryEarnings(address)", "0x55241077": "setValue(uint256)", "0x492b67ea": "Etherdoc()", "0xadf59f99": "query(uint256,string,string)", "0x951b01c5": "setCertifierDb(address)", "0x8ae986cf": "registrantApprove(address)", "0xfa68b4ce": "lookupISO3116_1_alpha_3(bytes)", "0x7fdc8290": "isUnderscore(bytes1)", "0x89495172": "convictFinal(uint256,uint256)", "0x93e02d13": "FallenLeaders()", "0x3e476053": "moveFunds(address,uint256)", "0x8894dd2b": "addEther()", "0x8f03850b": "numContributors()", "0xbfc3cd2f": "testFailChargeMoreThanApproved()", "0x1d82e9c7": "EXTRA_GAS()", "0x278ecde1": "refund(uint256)", "0x0f825673": "deleteCoupon(string)", "0xa324ad24": "getMonth(uint256)", "0xd628e0a6": "WatchBalance()", "0xb238ad0e": "getDaysInMonth(uint8,uint16)", "0xd6febde8": "buy(uint256,uint256)", "0x370ec1c5": "_fillOrder(address,uint256)", "0x4c33fe94": "cancel(address)", "0xcdd13701": "getEventHashes(uint256[256])", "0xe1bc3003": "reveal(bytes,string)", "0xa2e62045": "update()", "0x75f45878": "scheduleCall(bytes,bytes,uint256)", "0xd2756e11": "finalizeNumber(uint256)", "0x48519189": "MonedaAlcala(string,string)", "0x009b9369": "getVoteNumber(uint256)", "0xdaa283c8": "__callback(bytes,string)", "0xfcce2622": "challengeAnswer(uint256,bytes)", "0xac18de43": "removeManager(address)", "0x16d9356f": "oraclize_query(string,string[4])", "0xd1734eac": "isInNextGeneration(address)", "0x524fa7b9": "whitelistAdd(address)", "0xa5eb7a4e": "operated()", "0xb0aab296": "getNextNode(bytes)", "0x1982ed58": "ChangeReuseCashInHarware(bool,uint16,uint16)", "0xdf811d7d": "numberOfPlayersInCurrentRound()", "0xca7dc5b1": "getNumberOfTweets()", "0x488b3538": "shares(address,bytes32,int256)", "0xebd83378": "get_blocks_for(uint256)", "0x399fdb86": "testFailNormalWhitelistReset()", "0xca0c1e62": "computeMerkle(int256,int256,int256[],int256,int256,int256[])", "0x8963dab4": "getNodeId(bytes,bytes)", "0x7d94792a": "seed()", "0xbcf175c8": "oraclize_cbAddress()", "0x38eee93e": "scheduleCall(address,bytes,bytes,uint16,uint8,uint256[5])", "0xa08d3f83": "Etheropt(uint256,string,uint256,uint256,bytes32,address,int256[])", "0xae47a290": "changeMaxBet(uint256)", "0xd12c1e28": "badgesOf(address)", "0x001f8d11": "removePackage(bytes32,string)", "0x54fd4d50": "version()", "0x89abeb19": "ProcessGameExt(uint256)", "0x3dd7c1b9": "newProduct(string,string,uint256,uint256)", "0xa396541e": "getPongvalTxRetrievalAttempted()", "0xcc8af0fe": "bytesToUInt(bytes,bytes)", "0x983b94fb": "finalizeAuction(bytes32)", "0x3df91162": "getUpdatable(bytes20)", "0x045236b4": "getChainyData(string)", "0x9c172f87": "EthVentures4()", "0x996a4be3": "uintToBytes(uint256,uint256)", "0x775a8f5e": "toBytes(uint256)", "0xb6db75a0": "isAdmin()", "0x0b6fcdb0": "getEnforceRevisions(bytes32)", "0x29d6f899": "BetOnBlue()", "0xe6cbcba9": "PlusOnePonzi()", "0xc9030ea0": "addMember(address,bool)", "0x8f283970": "changeAdmin(address)", "0x670c884e": "setup(address,uint256,uint256,uint256,address)", "0x808ab1d6": "getCertificationDbCount()", "0x018f5472": "isAUser(address)", "0x59c87d70": "request(bytes32)", "0x407cfe5e": "get_all_players()", "0x33f472b9": "MPO()", "0x662dbe96": "getNodeHeight(bytes)", "0x60b1e173": "getProof(uint256,address,address)", "0xf25eb5c1": "removeReverse()", "0x1d065dde": "_transferWithReward(address,address,uint256)", "0x65343fcb": "TrustEth()", "0xaa237e21": "set(bool,uint256)", "0x60e519c0": "computeMarginAmount()", "0xd9597016": "multisetCustomGasPrice(uint256[],address[])", "0x4f10acc1": "updateGoldFeeData(uint256)", "0x1e9ea66a": "balanceEther10000000(uint256)", "0xffe34512": "getNumChannels(address)", "0x71dd8862": "IndexOf()", "0xdd9dd688": "calcStopPrice()", "0x934354e7": "finishSpin()", "0x26881518": "setupFee(address)", "0x5eb3f639": "assertTrue(bool,bytes)", "0xe9540395": "getRewardDivisor()", "0x8e4afa51": "checkTransferToICAP(bytes32,uint256)", "0xb5b33eda": "scheduleCall(address,uint256)", "0x3d6a32bd": "createTradeContract(address,uint256,uint256,uint256,bool,bool)", "0x5fd9dff6": "allowance(address,address,bytes)", "0x0d244d68": "setNotRetractable(bytes32)", "0xe63697c8": "withdraw(uint256,address,uint256)", "0x3e5087cc": "testBasicThing()", "0xee77fe86": "scheduleCall(address,bytes4,bytes,uint256,uint256,uint8)", "0xb1cc4348": "placeWager()", "0xb95594e5": "lineOfPlayers(uint256)", "0xa9cc4718": "fail()", "0x54385526": "setStatus(uint8,uint8,string)", "0xb45c48dc": "Security_AddPasswordSha3HashToBankAccount(bytes)", "0xace51abc": "helperVerifyHash__(uint256,int256,int256[],int256,uint256,int256,int256[],int256)", "0x1f5d0b4c": "address(address,address,uint256)", "0x7acbfb65": "setOwner(uint256,uint256)", "0x3462f32d": "execWithGasLimit(bytes32,bytes32,uint256,uint256)", "0xac04f5a7": "append(address)", "0x2fcb6628": "_stringGas(string,string)", "0xe977992d": "Doubler()", "0xc57a050e": "fairandeasy()", "0x412664ae": "sendToken(address,uint256)", "0x0afa9fb9": "contains(int256,address)", "0xb69ef8a8": "balance()", "0x264c8e9a": "whatWasTheVal()", "0x255016c8": "checkIfExploded()", "0xd716222c": "is_owner(uint256,address)", "0xc398f030": "expire(uint256,uint8,bytes,bytes,bytes)", "0xb7d454a4": "setNotTransferable(bytes32)", "0x4789aaef": "EthereumDice()", "0xc0171112": "timestamp(uint64)", "0x4f60f334": "multiAccessAddOwner(address)", "0x80aed05f": "LooneyDice()", "0x55ba343f": "getMarket(bytes)", "0x943b0747": "RewardOffer(address,address,bytes,uint256,uint256,uint128,uint256)", "0xa27c672a": "owner_reveal_and_commit(uint8,bytes32,bytes32)", "0x8f731077": "extractAllowanceRecordLength(address)", "0xc3d345c4": "getHangoutAddress()", "0xa8978434": "softResolveAnswer(uint256)", "0x7cef6047": "getNavHistory(uint256)", "0xfae14192": "changeFeePercentage(uint256)", "0x2ddbc04a": "play2(address,uint256)", "0x3fb27b85": "seal()", "0xe8038e25": "TokenSale(uint256,uint256,address)", "0x8d92fdf3": "withdrawAsset(uint256)", "0x8579cbde": "getPrice(string,uint256,address)", "0x0d61b519": "executeProposal(uint256)", "0x63a599a4": "emergencyStop()", "0x661e3605": "ConstructorContract(uint256)", "0xfd7c460d": "ciberLottery()", "0x1f83f440": "getPaymentByAddress(address)", "0xdcf73856": "generateGroups()", "0x3c6e03d7": "thewhalegame()", "0x271cd760": "getPackageDb()", "0x53fefd7d": "changeMaxDeposit(uint256)", "0xae169a50": "claimReward(uint256)", "0x6da84ec0": "calcMarketFee(bytes32,uint256)", "0xb16562fe": "fipsRegister(address,bytes)", "0x041fe13d": "onEtherandomSeed(bytes32,bytes32)", "0x4a617faa": "shaBid(bytes32,uint256,bytes32)", "0x052b2aa7": "getRegistrants()", "0x0ff0a4df": "reFund()", "0xe56b9dce": "GetPrize(uint256)", "0x8eec99c8": "setNewAdmin(address)", "0xffcce369": "changeIPFSHash(string)", "0x40fdf515": "issuetender(address,uint256,uint256)", "0xef4bdfdd": "Set_your_game_number_between_1_15(string)", "0xa991cb0e": "respond(uint256)", "0x617fba04": "getRecord(address)", "0x475a9fa9": "issueTokens(address,uint256)", "0xd30fbd0d": "safeSubtract(uint256,uint256)", "0xe54d4051": "receiveInteger(bytes,uint256,uint16)", "0x8023ffbd": "getOverallSize()", "0x8390b02a": "rfindPtr(uint256,uint256,uint256,uint256)", "0x11e99c22": "arrival()", "0x10c1952f": "setLocked()", "0x039a21b8": "tryExecute(address,bytes,uint256)", "0x201dcd7a": "newChallenge(uint256,uint256)", "0x5aebfd14": "createFile(bytes)", "0xa6b1caa3": "gasScalar(uint256)", "0x200538c6": "DTE()", "0xd1738b72": "wroomWroom()", "0x22f607f6": "Escrow()", "0x7e81b6aa": "KingdomFactory()", "0x901d7775": "voteOutMasterKey(address)", "0xd6af9411": "Rouleth()", "0x7b0383b2": "initializeDispute(uint256)", "0x70c9edb7": "BTCRelayTools(address)", "0xe9c31315": "checkBetParity(uint8,address,bytes32,bytes32)", "0xee82ac5e": "getBlockHash(uint256)", "0x727089f1": "extractAllowanceLength()", "0x8bbb5af7": "test1Fails()", "0x47872b42": "unsealBid(bytes32,uint256,bytes32)", "0x46b04e53": "PlayerInfoPerZone(uint256,uint256)", "0x752bacce": "getExecPrice()", "0x89d8ca67": "drawPot(bytes32,bytes32)", "0xc23697a8": "check(address)", "0x0af658ca": "personUpdateActivity(uint256,bool)", "0x24d4e90a": "ln(uint256)", "0x09d33f1d": "addRequest(address,uint256)", "0xc913b552": "getVersions(bytes)", "0xbb3b8dca": "getCertificateHash(bytes)", "0x3809c0bf": "doInfinite()", "0x853552d7": "_slotAddNew(address)", "0xccf1ab9b": "usurpation()", "0xe7dafdb6": "transfer_token(address,address,uint256)", "0x0c77a697": "claimFounders()", "0xda82a035": "sweepCommission()"} \ No newline at end of file diff --git a/cmd/clef/README.md b/cmd/clef/README.md new file mode 100644 index 0000000000..027c22c98f --- /dev/null +++ b/cmd/clef/README.md @@ -0,0 +1,877 @@ +Clef +---- +Clef can be used to sign transactions and data and is meant as a replacement for geth's account management. +This allows DApps not to depend on geth's account management. When a DApp wants to sign data it can send the data to +the signer, the signer will then provide the user with context and asks the user for permission to sign the data. If +the users grants the signing request the signer will send the signature back to the DApp. + +This setup allows a DApp to connect to a remote Ethereum node and send transactions that are locally signed. This can +help in situations when a DApp is connected to a remote node because a local Ethereum node is not available, not +synchronised with the chain or a particular Ethereum node that has no built-in (or limited) account management. + +Clef can run as a daemon on the same machine, or off a usb-stick like [usb armory](https://inversepath.com/usbarmory), +or a separate VM in a [QubesOS](https://www.qubes-os.org/) type os setup. + +Check out + +* the [tutorial](tutorial.md) for some concrete examples on how the signer works. +* the [setup docs](docs/setup.md) for some information on how to configure it to work on QubesOS or USBArmory. + + +## Command line flags +Clef accepts the following command line options: +``` +COMMANDS: + init Initialize the signer, generate secret storage + attest Attest that a js-file is to be used + addpw Store a credential for a keystore file + help Shows a list of commands or help for one command + +GLOBAL OPTIONS: + --loglevel value log level to emit to the screen (default: 4) + --keystore value Directory for the keystore (default: "$HOME/.ethereum/keystore") + --configdir value Directory for clef configuration (default: "$HOME/.clef") + --networkid value Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby) (default: 1) + --lightkdf Reduce key-derivation RAM & CPU usage at some expense of KDF strength + --nousb Disables monitoring for and managing USB hardware wallets + --rpcaddr value HTTP-RPC server listening interface (default: "localhost") + --rpcport value HTTP-RPC server listening port (default: 8550) + --signersecret value A file containing the password used to encrypt signer credentials, e.g. keystore credentials and ruleset hash + --4bytedb value File containing 4byte-identifiers (default: "./4byte.json") + --4bytedb-custom value File used for writing new 4byte-identifiers submitted via API (default: "./4byte-custom.json") + --auditlog value File used to emit audit logs. Set to "" to disable (default: "audit.log") + --rules value Enable rule-engine (default: "rules.json") + --stdio-ui Use STDIN/STDOUT as a channel for an external UI. This means that an STDIN/STDOUT is used for RPC-communication with a e.g. a graphical user interface, and can be used when the signer is started by an external process. + --stdio-ui-test Mechanism to test interface between signer and UI. Requires 'stdio-ui'. + --help, -h show help + --version, -v print the version + +``` + + +Example: +``` +signer -keystore /my/keystore -chainid 4 +``` + + +## Security model + +The security model of the signer is as follows: + +* One critical component (the signer binary / daemon) is responsible for handling cryptographic operations: signing, private keys, encryption/decryption of keystore files. +* The signer binary has a well-defined 'external' API. +* The 'external' API is considered UNTRUSTED. +* The signer binary also communicates with whatever process that invoked the binary, via stdin/stdout. + * This channel is considered 'trusted'. Over this channel, approvals and passwords are communicated. + +The general flow for signing a transaction using e.g. geth is as follows: +![image](sign_flow.png) + +In this case, `geth` would be started with `--externalsigner=http://localhost:8550` and would relay requests to `eth.sendTransaction`. + +## TODOs + +Some snags and todos + +* [ ] The signer should take a startup param "--no-change", for UIs that do not contain the capability + to perform changes to things, only approve/deny. Such a UI should be able to start the signer in + a more secure mode by telling it that it only wants approve/deny capabilities. + +* [x] It would be nice if the signer could collect new 4byte-id:s/method selectors, and have a +secondary database for those (`4byte_custom.json`). Users could then (optionally) submit their collections for +inclusion upstream. + +* It should be possible to configure the signer to check if an account is indeed known to it, before +passing on to the UI. The reason it currently does not, is that it would make it possible to enumerate +accounts if it immediately returned "unknown account". +* [x] It should be possible to configure the signer to auto-allow listing (certain) accounts, instead of asking every time. +* [x] Done Upon startup, the signer should spit out some info to the caller (particularly important when executed in `stdio-ui`-mode), +invoking methods with the following info: + * [x] Version info about the signer + * [x] Address of API (http/ipc) + * [ ] List of known accounts +* [ ] Have a default timeout on signing operations, so that if the user has not answered withing e.g. 60 seconds, the request is rejected. +* [ ] `account_signRawTransaction` +* [ ] `account_bulkSignTransactions([] transactions)` should + * only exist if enabled via config/flag + * only allow non-data-sending transactions + * all txs must use the same `from`-account + * let the user confirm, showing + * the total amount + * the number of unique recipients + +* Geth todos + - The signer should pass the `Origin` header as call-info to the UI. As of right now, the way that info about the request is +put together is a bit of a hack into the http server. This could probably be greatly improved + - Relay: Geth should be started in `geth --external_signer localhost:8550`. + - Currently, the Geth APIs use `common.Address` in the arguments to transaction submission (e.g `to` field). This + type is 20 `bytes`, and is incapable of carrying checksum information. The signer uses `common.MixedcaseAddress`, which + retains the original input. + - The Geth api should switch to use the same type, and relay `to`-account verbatim to the external api. + +* [x] Storage + * [x] An encrypted key-value storage should be implemented + * See [rules.md](rules.md) for more info about this. + +* Another potential thing to introduce is pairing. + * To prevent spurious requests which users just accept, implement a way to "pair" the caller with the signer (external API). + * Thus geth/mist/cpp would cryptographically handshake and afterwards the caller would be allowed to make signing requests. + * This feature would make the addition of rules less dangerous. + +* Wallets / accounts. Add API methods for wallets. + +## Communication + +### External API + +The signer listens to HTTP requests on `rpcaddr`:`rpcport`, with the same JSONRPC standard as Geth. The messages are +expected to be JSON [jsonrpc 2.0 standard](http://www.jsonrpc.org/specification). + +Some of these call can require user interaction. Clients must be aware that responses +may be delayed significanlty or may never be received if a users decides to ignore the confirmation request. + +The External API is **untrusted** : it does not accept credentials over this api, nor does it expect +that requests have any authority. + +### UI API + +The signer has one native console-based UI, for operation without any standalone tools. +However, there is also an API to communicate with an external UI. To enable that UI, +the signer needs to be executed with the `--stdio-ui` option, which allocates the +`stdin`/`stdout` for the UI-api. + +An example (insecure) proof-of-concept of has been implemented in `pythonsigner.py`. + +The model is as follows: + +* The user starts the UI app (`pythonsigner.py`). +* The UI app starts the `signer` with `--stdio-ui`, and listens to the +process output for confirmation-requests. +* The `signer` opens the external http api. +* When the `signer` receives requests, it sends a `jsonrpc` request via `stdout`. +* The UI app prompts the user accordingly, and responds to the `signer` +* The `signer` signs (or not), and responds to the original request. + +## External API + +See the [external api changelog](extapi_changelog.md) for information about changes to this API. + +### Encoding +- number: positive integers that are hex encoded +- data: hex encoded data +- string: ASCII string + +All hex encoded values must be prefixed with `0x`. + +## Methods + +### account_new + +#### Create new password protected account + +The signer will generate a new private key, encrypts it according to [web3 keystore spec](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition) and stores it in the keystore directory. +The client is responsible for creating a backup of the keystore. If the keystore is lost there is no method of retrieving lost accounts. + +#### Arguments + +None + +#### Result + - address [string]: account address that is derived from the generated key + - url [string]: location of the keyfile + +#### Sample call +```json +{ + "id": 0, + "jsonrpc": "2.0", + "method": "account_new", + "params": [] +} + +{ + "id": 0, + "jsonrpc": "2.0", + "result": { + "address": "0xbea9183f8f4f03d427f6bcea17388bdff1cab133", + "url": "keystore:///my/keystore/UTC--2017-08-24T08-40-15.419655028Z--bea9183f8f4f03d427f6bcea17388bdff1cab133" + } +} +``` + +### account_list + +#### List available accounts + List all accounts that this signer currently manages + +#### Arguments + +None + +#### Result + - array with account records: + - account.address [string]: account address that is derived from the generated key + - account.type [string]: type of the + - account.url [string]: location of the account + +#### Sample call +```json +{ + "id": 1, + "jsonrpc": "2.0", + "method": "account_list" +} + +{ + "id": 1, + "jsonrpc": "2.0", + "result": [ + { + "address": "0xafb2f771f58513609765698f65d3f2f0224a956f", + "type": "account", + "url": "keystore:///tmp/keystore/UTC--2017-08-24T07-26-47.162109726Z--afb2f771f58513609765698f65d3f2f0224a956f" + }, + { + "address": "0xbea9183f8f4f03d427f6bcea17388bdff1cab133", + "type": "account", + "url": "keystore:///tmp/keystore/UTC--2017-08-24T08-40-15.419655028Z--bea9183f8f4f03d427f6bcea17388bdff1cab133" + } + ] +} +``` + +### account_signTransaction + +#### Sign transactions + Signs a transactions and responds with the signed transaction in RLP encoded form. + +#### Arguments + 2. transaction object: + - `from` [address]: account to send the transaction from + - `to` [address]: receiver account. If omitted or `0x`, will cause contract creation. + - `gas` [number]: maximum amount of gas to burn + - `gasPrice` [number]: gas price + - `value` [number:optional]: amount of Wei to send with the transaction + - `data` [data:optional]: input data + - `nonce` [number]: account nonce + 3. method signature [string:optional] + - The method signature, if present, is to aid decoding the calldata. Should consist of `methodname(paramtype,...)`, e.g. `transfer(uint256,address)`. The signer may use this data to parse the supplied calldata, and show the user. The data, however, is considered totally untrusted, and reliability is not expected. + + +#### Result + - signed transaction in RLP encoded form [data] + +#### Sample call +```json +{ + "id": 2, + "jsonrpc": "2.0", + "method": "account_signTransaction", + "params": [ + { + "from": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db", + "gas": "0x55555", + "gasPrice": "0x1234", + "input": "0xabcd", + "nonce": "0x0", + "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "value": "0x1234" + } + ] +} +``` +Response + +```json +{ + "jsonrpc": "2.0", + "id": 67, + "error": { + "code": -32000, + "message": "Request denied" + } +} +``` +#### Sample call with ABI-data + + +```json +{ + "jsonrpc": "2.0", + "method": "account_signTransaction", + "params": [ + { + "from": "0x694267f14675d7e1b9494fd8d72fefe1755710fa", + "gas": "0x333", + "gasPrice": "0x1", + "nonce": "0x0", + "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "value": "0x0", + "data": "0x4401a6e40000000000000000000000000000000000000000000000000000000000000012" + }, + "safeSend(address)" + ], + "id": 67 +} +``` +Response + +```json +{ + "jsonrpc": "2.0", + "id": 67, + "result": { + "raw": "0xf88380018203339407a565b7ed7d7a678680a4c162885bedbb695fe080a44401a6e4000000000000000000000000000000000000000000000000000000000000001226a0223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20ea02aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663", + "tx": { + "nonce": "0x0", + "gasPrice": "0x1", + "gas": "0x333", + "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "value": "0x0", + "input": "0x4401a6e40000000000000000000000000000000000000000000000000000000000000012", + "v": "0x26", + "r": "0x223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20e", + "s": "0x2aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663", + "hash": "0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e" + } + } +} +``` + +Bash example: +```bash +#curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_signTransaction","params":[{"from":"0x694267f14675d7e1b9494fd8d72fefe1755710fa","gas":"0x333","gasPrice":"0x1","nonce":"0x0","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", "value":"0x0", "data":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012"},"safeSend(address)"],"id":67}' http://localhost:8550/ + +{"jsonrpc":"2.0","id":67,"result":{"raw":"0xf88380018203339407a565b7ed7d7a678680a4c162885bedbb695fe080a44401a6e4000000000000000000000000000000000000000000000000000000000000001226a0223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20ea02aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663","tx":{"nonce":"0x0","gasPrice":"0x1","gas":"0x333","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0","value":"0x0","input":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012","v":"0x26","r":"0x223a7c9bcf5531c99be5ea7082183816eb20cfe0bbc322e97cc5c7f71ab8b20e","s":"0x2aadee6b34b45bb15bc42d9c09de4a6754e7000908da72d48cc7704971491663","hash":"0xeba2df809e7a612a0a0d444ccfa5c839624bdc00dd29e3340d46df3870f8a30e"}}} +``` + + +### account_sign + +#### Sign data + Signs a chunk of data and returns the calculated signature. + +#### Arguments + - account [address]: account to sign with + - data [data]: data to sign + +#### Result + - calculated signature [data] + +#### Sample call +```json +{ + "id": 3, + "jsonrpc": "2.0", + "method": "account_sign", + "params": [ + "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db", + "0xaabbccdd" + ] +} +``` +Response + +```json +{ + "id": 3, + "jsonrpc": "2.0", + "result": "0x5b6693f153b48ec1c706ba4169960386dbaa6903e249cc79a8e6ddc434451d417e1e57327872c7f538beeb323c300afa9999a3d4a5de6caf3be0d5ef832b67ef1c" +} +``` + +### account_ecRecover + +#### Recover address + Derive the address from the account that was used to sign data from the data and signature. + +#### Arguments + - data [data]: data that was signed + - signature [data]: the signature to verify + +#### Result + - derived account [address] + +#### Sample call +```json +{ + "id": 4, + "jsonrpc": "2.0", + "method": "account_ecRecover", + "params": [ + "0xaabbccdd", + "0x5b6693f153b48ec1c706ba4169960386dbaa6903e249cc79a8e6ddc434451d417e1e57327872c7f538beeb323c300afa9999a3d4a5de6caf3be0d5ef832b67ef1c" + ] +} +``` +Response + +```json +{ + "id": 4, + "jsonrpc": "2.0", + "result": "0x1923f626bb8dc025849e00f99c25fe2b2f7fb0db" +} + +``` + +### account_import + +#### Import account + Import a private key into the keystore. The imported key is expected to be encrypted according to the web3 keystore + format. + +#### Arguments + - account [object]: key in [web3 keystore format](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition) (retrieved with account_export) + +#### Result + - imported key [object]: + - key.address [address]: address of the imported key + - key.type [string]: type of the account + - key.url [string]: key URL + +#### Sample call +```json +{ + "id": 6, + "jsonrpc": "2.0", + "method": "account_import", + "params": [ + { + "address": "c7412fc59930fd90099c917a50e5f11d0934b2f5", + "crypto": { + "cipher": "aes-128-ctr", + "cipherparams": { + "iv": "401c39a7c7af0388491c3d3ecb39f532" + }, + "ciphertext": "eb045260b18dd35cd0e6d99ead52f8fa1e63a6b0af2d52a8de198e59ad783204", + "kdf": "scrypt", + "kdfparams": { + "dklen": 32, + "n": 262144, + "p": 1, + "r": 8, + "salt": "9a657e3618527c9b5580ded60c12092e5038922667b7b76b906496f021bb841a" + }, + "mac": "880dc10bc06e9cec78eb9830aeb1e7a4a26b4c2c19615c94acb632992b952806" + }, + "id": "09bccb61-b8d3-4e93-bf4f-205a8194f0b9", + "version": 3 + }, + ] +} +``` +Response + +```json +{ + "id": 6, + "jsonrpc": "2.0", + "result": { + "address": "0xc7412fc59930fd90099c917a50e5f11d0934b2f5", + "type": "account", + "url": "keystore:///tmp/keystore/UTC--2017-08-24T11-00-42.032024108Z--c7412fc59930fd90099c917a50e5f11d0934b2f5" + } +} +``` + +### account_export + +#### Export account from keystore + Export a private key from the keystore. The exported private key is encrypted with the original passphrase. When the + key is imported later this passphrase is required. + +#### Arguments + - account [address]: export private key that is associated with this account + +#### Result + - exported key, see [web3 keystore format](https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition) for + more information + +#### Sample call +```json +{ + "id": 5, + "jsonrpc": "2.0", + "method": "account_export", + "params": [ + "0xc7412fc59930fd90099c917a50e5f11d0934b2f5" + ] +} +``` +Response + +```json +{ + "id": 5, + "jsonrpc": "2.0", + "result": { + "address": "c7412fc59930fd90099c917a50e5f11d0934b2f5", + "crypto": { + "cipher": "aes-128-ctr", + "cipherparams": { + "iv": "401c39a7c7af0388491c3d3ecb39f532" + }, + "ciphertext": "eb045260b18dd35cd0e6d99ead52f8fa1e63a6b0af2d52a8de198e59ad783204", + "kdf": "scrypt", + "kdfparams": { + "dklen": 32, + "n": 262144, + "p": 1, + "r": 8, + "salt": "9a657e3618527c9b5580ded60c12092e5038922667b7b76b906496f021bb841a" + }, + "mac": "880dc10bc06e9cec78eb9830aeb1e7a4a26b4c2c19615c94acb632992b952806" + }, + "id": "09bccb61-b8d3-4e93-bf4f-205a8194f0b9", + "version": 3 + } +} +``` + + + +## UI API + +These methods needs to be implemented by a UI listener. + +By starting the signer with the switch `--stdio-ui-test`, the signer will invoke all known methods, and expect the UI to respond with +denials. This can be used during development to ensure that the API is (at least somewhat) correctly implemented. +See `pythonsigner`, which can be invoked via `python3 pythonsigner.py test` to perform the 'denial-handshake-test'. + +All methods in this API uses object-based parameters, so that there can be no mixups of parameters: each piece of data is accessed by key. + +See the [ui api changelog](intapi_changelog.md) for information about changes to this API. + +OBS! A slight deviation from `json` standard is in place: every request and response should be confined to a single line. +Whereas the `json` specification allows for linebreaks, linebreaks __should not__ be used in this communication channel, to make +things simpler for both parties. + +### ApproveTx + +Invoked when there's a transaction for approval. + + +#### Sample call + +Here's a method invocation: +```bash + +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_signTransaction","params":[{"from":"0x694267f14675d7e1b9494fd8d72fefe1755710fa","gas":"0x333","gasPrice":"0x1","nonce":"0x0","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", "value":"0x0", "data":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012"},"safeSend(address)"],"id":67}' http://localhost:8550/ +``` + +```json + +{ + "jsonrpc": "2.0", + "id": 1, + "method": "ApproveTx", + "params": [ + { + "transaction": { + "from": "0x0x694267f14675d7e1b9494fd8d72fefe1755710fa", + "to": "0x0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "gas": "0x333", + "gasPrice": "0x1", + "value": "0x0", + "nonce": "0x0", + "data": "0x4401a6e40000000000000000000000000000000000000000000000000000000000000012", + "input": null + }, + "call_info": [ + { + "type": "WARNING", + "message": "Invalid checksum on to-address" + }, + { + "type": "Info", + "message": "safeSend(address: 0x0000000000000000000000000000000000000012)" + } + ], + "meta": { + "remote": "127.0.0.1:48486", + "local": "localhost:8550", + "scheme": "HTTP/1.1" + } + } + ] +} + +``` + +The same method invocation, but with invalid data: +```bash + +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_signTransaction","params":[{"from":"0x694267f14675d7e1b9494fd8d72fefe1755710fa","gas":"0x333","gasPrice":"0x1","nonce":"0x0","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", "value":"0x0", "data":"0x4401a6e40000000000000002000000000000000000000000000000000000000000000012"},"safeSend(address)"],"id":67}' http://localhost:8550/ +``` + +```json + +{ + "jsonrpc": "2.0", + "id": 1, + "method": "ApproveTx", + "params": [ + { + "transaction": { + "from": "0x0x694267f14675d7e1b9494fd8d72fefe1755710fa", + "to": "0x0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "gas": "0x333", + "gasPrice": "0x1", + "value": "0x0", + "nonce": "0x0", + "data": "0x4401a6e40000000000000002000000000000000000000000000000000000000000000012", + "input": null + }, + "call_info": [ + { + "type": "WARNING", + "message": "Invalid checksum on to-address" + }, + { + "type": "WARNING", + "message": "Transaction data did not match ABI-interface: WARNING: Supplied data is stuffed with extra data. \nWant 0000000000000002000000000000000000000000000000000000000000000012\nHave 0000000000000000000000000000000000000000000000000000000000000012\nfor method safeSend(address)" + } + ], + "meta": { + "remote": "127.0.0.1:48492", + "local": "localhost:8550", + "scheme": "HTTP/1.1" + } + } + ] +} + + +``` + +One which has missing `to`, but with no `data`: + + +```json + +{ + "jsonrpc": "2.0", + "id": 3, + "method": "ApproveTx", + "params": [ + { + "transaction": { + "from": "", + "to": null, + "gas": "0x0", + "gasPrice": "0x0", + "value": "0x0", + "nonce": "0x0", + "data": null, + "input": null + }, + "call_info": [ + { + "type": "CRITICAL", + "message": "Tx will create contract with empty code!" + } + ], + "meta": { + "remote": "signer binary", + "local": "main", + "scheme": "in-proc" + } + } + ] +} +``` + +### ApproveExport + +Invoked when a request to export an account has been made. + +#### Sample call + +```json + +{ + "jsonrpc": "2.0", + "id": 7, + "method": "ApproveExport", + "params": [ + { + "address": "0x0000000000000000000000000000000000000000", + "meta": { + "remote": "signer binary", + "local": "main", + "scheme": "in-proc" + } + } + ] +} + +``` + +### ApproveListing + +Invoked when a request for account listing has been made. + +#### Sample call + +```json + +{ + "jsonrpc": "2.0", + "id": 5, + "method": "ApproveListing", + "params": [ + { + "accounts": [ + { + "type": "Account", + "url": "keystore:///home/bazonk/.ethereum/keystore/UTC--2017-11-20T14-44-54.089682944Z--123409812340981234098123409812deadbeef42", + "address": "0x123409812340981234098123409812deadbeef42" + }, + { + "type": "Account", + "url": "keystore:///home/bazonk/.ethereum/keystore/UTC--2017-11-23T21-59-03.199240693Z--cafebabedeadbeef34098123409812deadbeef42", + "address": "0xcafebabedeadbeef34098123409812deadbeef42" + } + ], + "meta": { + "remote": "signer binary", + "local": "main", + "scheme": "in-proc" + } + } + ] +} + +``` + + +### ApproveSignData + +#### Sample call + +```json +{ + "jsonrpc": "2.0", + "id": 4, + "method": "ApproveSignData", + "params": [ + { + "address": "0x123409812340981234098123409812deadbeef42", + "raw_data": "0x01020304", + "message": "\u0019Ethereum Signed Message:\n4\u0001\u0002\u0003\u0004", + "hash": "0x7e3a4e7a9d1744bc5c675c25e1234ca8ed9162bd17f78b9085e48047c15ac310", + "meta": { + "remote": "signer binary", + "local": "main", + "scheme": "in-proc" + } + } + ] +} + +``` + +### ShowInfo + +The UI should show the info to the user. Does not expect response. + +#### Sample call + +```json +{ + "jsonrpc": "2.0", + "id": 9, + "method": "ShowInfo", + "params": [ + { + "text": "Tests completed" + } + ] +} + +``` + +### ShowError + +The UI should show the info to the user. Does not expect response. + +```json + +{ + "jsonrpc": "2.0", + "id": 2, + "method": "ShowError", + "params": [ + { + "text": "Testing 'ShowError'" + } + ] +} + +``` + +### OnApproved + +`OnApprovedTx` is called when a transaction has been approved and signed. The call contains the return value that will be sent to the external caller. The return value from this method is ignored - the reason for having this callback is to allow the ruleset to keep track of approved transactions. + +When implementing rate-limited rules, this callback should be used. + +TLDR; Use this method to keep track of signed transactions, instead of using the data in `ApproveTx`. + +### OnSignerStartup + +This method provide the UI with information about what API version the signer uses (both internal and external) aswell as build-info and external api, +in k/v-form. + +Example call: +```json + +{ + "jsonrpc": "2.0", + "id": 1, + "method": "OnSignerStartup", + "params": [ + { + "info": { + "extapi_http": "http://localhost:8550", + "extapi_ipc": null, + "extapi_version": "2.0.0", + "intapi_version": "1.2.0" + } + } + ] +} + +``` + + +### Rules for UI apis + +A UI should conform to the following rules. + +* A UI MUST NOT load any external resources that were not embedded/part of the UI package. + * For example, not load icons, stylesheets from the internet + * Not load files from the filesystem, unless they reside in the same local directory (e.g. config files) +* A Graphical UI MUST show the blocky-identicon for ethereum addresses. +* A UI MUST warn display approproate warning if the destination-account is formatted with invalid checksum. +* A UI MUST NOT open any ports or services + * The signer opens the public port +* A UI SHOULD verify the permissions on the signer binary, and refuse to execute or warn if permissions allow non-user write. +* A UI SHOULD inform the user about the `SHA256` or `MD5` hash of the binary being executed +* A UI SHOULD NOT maintain a secondary storage of data, e.g. list of accounts + * The signer provides accounts +* A UI SHOULD, to the best extent possible, use static linking / bundling, so that requried libraries are bundled +along with the UI. + + +### UI Implementations + +There are a couple of implementation for a UI. We'll try to keep this list up to date. + +| Name | Repo | UI type| No external resources| Blocky support| Verifies permissions | Hash information | No secondary storage | Statically linked| Can modify parameters| +| ---- | ---- | -------| ---- | ---- | ---- |---- | ---- | ---- | ---- | +| QtSigner| https://github.com/holiman/qtsigner/| Python3/QT-based| :+1:| :+1:| :+1:| :+1:| :+1:| :x: | :+1: (partially)| +| GtkSigner| https://github.com/holiman/gtksigner| Python3/GTK-based| :+1:| :x:| :x:| :+1:| :+1:| :x: | :x: | +| Frame | https://github.com/floating/frame/commits/go-signer| Electron-based| :x:| :x:| :x:| :x:| ?| :x: | :x: | diff --git a/cmd/clef/docs/qubes/clef_qubes_http.png b/cmd/clef/docs/qubes/clef_qubes_http.png new file mode 100644 index 0000000000..a641e1987f Binary files /dev/null and b/cmd/clef/docs/qubes/clef_qubes_http.png differ diff --git a/cmd/clef/docs/qubes/clef_qubes_qrexec.png b/cmd/clef/docs/qubes/clef_qubes_qrexec.png new file mode 100644 index 0000000000..f57fc8933e Binary files /dev/null and b/cmd/clef/docs/qubes/clef_qubes_qrexec.png differ diff --git a/cmd/clef/docs/qubes/qrexec-example.png b/cmd/clef/docs/qubes/qrexec-example.png new file mode 100644 index 0000000000..0d86fde19d Binary files /dev/null and b/cmd/clef/docs/qubes/qrexec-example.png differ diff --git a/cmd/clef/docs/qubes/qubes-client.py b/cmd/clef/docs/qubes/qubes-client.py new file mode 100644 index 0000000000..93a74b899b --- /dev/null +++ b/cmd/clef/docs/qubes/qubes-client.py @@ -0,0 +1,23 @@ +""" +This implements a dispatcher which listens to localhost:8550, and proxies +requests via qrexec to the service qubes.EthSign on a target domain +""" + +import http.server +import socketserver,subprocess + +PORT=8550 +TARGET_DOMAIN= 'debian-work' + +class Dispatcher(http.server.BaseHTTPRequestHandler): + def do_POST(self): + post_data = self.rfile.read(int(self.headers['Content-Length'])) + p = subprocess.Popen(['/usr/bin/qrexec-client-vm',TARGET_DOMAIN,'qubes.Clefsign'],stdin=subprocess.PIPE, stdout=subprocess.PIPE) + output = p.communicate(post_data)[0] + self.wfile.write(output) + + +with socketserver.TCPServer(("",PORT), Dispatcher) as httpd: + print("Serving at port", PORT) + httpd.serve_forever() + diff --git a/cmd/clef/docs/qubes/qubes.Clefsign b/cmd/clef/docs/qubes/qubes.Clefsign new file mode 100644 index 0000000000..9b5af7b4fe --- /dev/null +++ b/cmd/clef/docs/qubes/qubes.Clefsign @@ -0,0 +1,16 @@ +#!/bin/bash + +SIGNER_BIN="/home/user/tools/clef/clef" +SIGNER_CMD="/home/user/tools/gtksigner/gtkui.py -s $SIGNER_BIN" + +# Start clef if not already started +if [ ! -S /home/user/.clef/clef.ipc ]; then + $SIGNER_CMD & + sleep 1 +fi + +# Should be started by now +if [ -S /home/user/.clef/clef.ipc ]; then + # Post incoming request to HTTP channel + curl -H "Content-Type: application/json" -X POST -d @- http://localhost:8550 2>/dev/null +fi diff --git a/cmd/clef/docs/qubes/qubes_newaccount-1.png b/cmd/clef/docs/qubes/qubes_newaccount-1.png new file mode 100644 index 0000000000..598dbbee7a Binary files /dev/null and b/cmd/clef/docs/qubes/qubes_newaccount-1.png differ diff --git a/cmd/clef/docs/qubes/qubes_newaccount-2.png b/cmd/clef/docs/qubes/qubes_newaccount-2.png new file mode 100644 index 0000000000..cd762a1934 Binary files /dev/null and b/cmd/clef/docs/qubes/qubes_newaccount-2.png differ diff --git a/cmd/clef/docs/setup.md b/cmd/clef/docs/setup.md new file mode 100644 index 0000000000..33d2b0381f --- /dev/null +++ b/cmd/clef/docs/setup.md @@ -0,0 +1,198 @@ +# Setting up Clef + +This document describes how Clef can be used in a more secure manner than executing it from your everyday laptop, +in order to ensure that the keys remain safe in the event that your computer should get compromised. + +## Qubes OS + + +### Background + +The Qubes operating system is based around virtual machines (qubes), where a set of virtual machines are configured, typically for +different purposes such as: + +- personal + - Your personal email, browsing etc +- work + - Work email etc +- vault + - a VM without network access, where gpg-keys and/or keepass credentials are stored. + +A couple of dedicated virtual machines handle externalities: + +- sys-net provides networking to all other (network-enabled) machines +- sys-firewall handles firewall rules +- sys-usb handles USB devices, and can map usb-devices to certain qubes. + +The goal of this document is to describe how we can set up clef to provide secure transaction +signing from a `vault` vm, to another networked qube which runs Dapps. + +### Setup + +There are two ways that this can be achieved: integrated via Qubes or integrated via networking. + + +#### 1. Qubes Integrated + +Qubes provdes a facility for inter-qubes communication via `qrexec`. A qube can request to make a cross-qube RPC request +to another qube. The OS then asks the user if the call is permitted. + +![Example](qubes/qrexec-example.png) + +A policy-file can be created to allow such interaction. On the `target` domain, a service is invoked which can read the +`stdin` from the `client` qube. + +This is how [Split GPG](https://www.qubes-os.org/doc/split-gpg/) is implemented. We can set up Clef the same way: + +##### Server + +![Clef via qrexec](qubes/clef_qubes_qrexec.png) + +On the `target` qubes, we need to define the rpc service. + +[qubes.Clefsign](qubes/qubes.Clefsign): + +```bash +#!/bin/bash + +SIGNER_BIN="/home/user/tools/clef/clef" +SIGNER_CMD="/home/user/tools/gtksigner/gtkui.py -s $SIGNER_BIN" + +# Start clef if not already started +if [ ! -S /home/user/.clef/clef.ipc ]; then + $SIGNER_CMD & + sleep 1 +fi + +# Should be started by now +if [ -S /home/user/.clef/clef.ipc ]; then + # Post incoming request to HTTP channel + curl -H "Content-Type: application/json" -X POST -d @- http://localhost:8550 2>/dev/null +fi + +``` +This RPC service is not complete (see notes about HTTP headers below), but works as a proof-of-concept. +It will forward the data received on `stdin` (forwarded by the OS) to Clef's HTTP channel. + +It would have been possible to send data directly to the `/home/user/.clef/.clef.ipc` +socket via e.g `nc -U /home/user/.clef/clef.ipc`, but the reason for sending the request +data over `HTTP` instead of `IPC` is that we want the ability to forward `HTTP` headers. + +To enable the service: + +``` bash +sudo cp qubes.Clefsign /etc/qubes-rpc/ +sudo chmod +x /etc/qubes-rpc/ qubes.Clefsign +``` + +This setup uses [gtksigner](https://github.com/holiman/gtksigner), which is a very minimal GTK-based UI that works well +with minimal requirements. + +##### Client + + +On the `client` qube, we need to create a listener which will receive the request from the Dapp, and proxy it. + + +[qubes-client.py](qubes/client/qubes-client.py): + +```python + +""" +This implements a dispatcher which listens to localhost:8550, and proxies +requests via qrexec to the service qubes.EthSign on a target domain +""" + +import http.server +import socketserver,subprocess + +PORT=8550 +TARGET_DOMAIN= 'debian-work' + +class Dispatcher(http.server.BaseHTTPRequestHandler): + def do_POST(self): + post_data = self.rfile.read(int(self.headers['Content-Length'])) + p = subprocess.Popen(['/usr/bin/qrexec-client-vm',TARGET_DOMAIN,'qubes.Clefsign'],stdin=subprocess.PIPE, stdout=subprocess.PIPE) + output = p.communicate(post_data)[0] + self.wfile.write(output) + + +with socketserver.TCPServer(("",PORT), Dispatcher) as httpd: + print("Serving at port", PORT) + httpd.serve_forever() + + +``` + +#### Testing + +To test the flow, if we have set up `debian-work` as the `target`, we can do + +```bash +$ cat newaccnt.json +{ "id": 0, "jsonrpc": "2.0","method": "account_new","params": []} + +$ cat newaccnt.json| qrexec-client-vm debian-work qubes.Clefsign +``` + +This should pop up first a dialog to allow the IPC call: + +![one](qubes/qubes_newaccount-1.png) + +Followed by a GTK-dialog to approve the operation + +![two](qubes/qubes_newaccount-2.png) + +To test the full flow, we use the client wrapper. Start it on the `client` qube: +``` +[user@work qubes]$ python3 qubes-client.py +``` + +Make the request over http (`client` qube): +``` +[user@work clef]$ cat newaccnt.json | curl -X POST -d @- http://localhost:8550 +``` +And it should show the same popups again. + +##### Pros and cons + +The benefits of this setup are: + +- This is the qubes-os intended model for inter-qube communication, +- and thus benefits from qubes-os dialogs and policies for user approval + +However, it comes with a couple of drawbacks: + +- The `qubes-gpg-client` must forward the http request via RPC to the `target` qube. When doing so, the proxy + will either drop important headers, or replace them. + - The `Host` header is most likely `localhost` + - The `Origin` header must be forwarded + - Information about the remote ip must be added as a `X-Forwarded-For`. However, Clef cannot always trust an `XFF` header, + since malicious clients may lie about `XFF` in order to fool the http server into believing it comes from another address. +- Even with a policy in place to allow rpc-calls between `caller` and `target`, there will be several popups: + - One qubes-specific where the user specifies the `target` vm + - One clef-specific to approve the transaction + + +#### 2. Network integrated + +The second way to set up Clef on a qubes system is to allow networking, and have Clef listen to a port which is accessible +form other qubes. + +![Clef via http](qubes/clef_qubes_http.png) + + + + +## USBArmory + +The [USB armory](https://inversepath.com/usbarmory) is an open source hardware design with an 800 Mhz ARM processor. It is a pocket-size +computer. When inserted into a laptop, it identifies itself as a USB network interface, basically adding another network +to your computer. Over this new network interface, you can SSH into the device. + +Running Clef off a USB armory means that you can use the armory as a very versatile offline computer, which only +ever connects to a local network between your computer and the device itself. + +Needless to say, the while this model should be fairly secure against remote attacks, an attacker with physical access +to the USB Armory would trivially be able to extract the contents of the device filesystem. + diff --git a/cmd/clef/extapi_changelog.md b/cmd/clef/extapi_changelog.md new file mode 100644 index 0000000000..2014e90ae4 --- /dev/null +++ b/cmd/clef/extapi_changelog.md @@ -0,0 +1,25 @@ +### Changelog for external API + + + +#### 2.0.0 + +* Commit `73abaf04b1372fa4c43201fb1b8019fe6b0a6f8d`, move `from` into `transaction` object in `signTransaction`. This +makes the `accounts_signTransaction` identical to the old `eth_signTransaction`. + + +#### 1.0.0 + +Initial release. + +### Versioning + +The API uses [semantic versioning](https://semver.org/). + +TLDR; Given a version number MAJOR.MINOR.PATCH, increment the: + +* MAJOR version when you make incompatible API changes, +* MINOR version when you add functionality in a backwards-compatible manner, and +* PATCH version when you make backwards-compatible bug fixes. + +Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format. diff --git a/cmd/clef/intapi_changelog.md b/cmd/clef/intapi_changelog.md new file mode 100644 index 0000000000..7d2a897ea2 --- /dev/null +++ b/cmd/clef/intapi_changelog.md @@ -0,0 +1,86 @@ +### Changelog for internal API (ui-api) + +### 2.0.0 + +* Modify how `call_info` on a transaction is conveyed. New format: + +``` +{ + "jsonrpc": "2.0", + "id": 2, + "method": "ApproveTx", + "params": [ + { + "transaction": { + "from": "0x82A2A876D39022B3019932D30Cd9c97ad5616813", + "to": "0x07a565b7ed7d7a678680a4c162885bedbb695fe0", + "gas": "0x333", + "gasPrice": "0x123", + "value": "0x10", + "nonce": "0x0", + "data": "0x4401a6e40000000000000000000000000000000000000000000000000000000000000012", + "input": null + }, + "call_info": [ + { + "type": "WARNING", + "message": "Invalid checksum on to-address" + }, + { + "type": "WARNING", + "message": "Tx contains data, but provided ABI signature could not be matched: Did not match: test (0 matches)" + } + ], + "meta": { + "remote": "127.0.0.1:54286", + "local": "localhost:8550", + "scheme": "HTTP/1.1" + } + } + ] +} +``` + +#### 1.2.0 + +* Add `OnStartup` method, to provide the UI with information about what API version +the signer uses (both internal and external) aswell as build-info and external api. + +Example call: +```json +{ + "jsonrpc": "2.0", + "id": 1, + "method": "OnSignerStartup", + "params": [ + { + "info": { + "extapi_http": "http://localhost:8550", + "extapi_ipc": null, + "extapi_version": "2.0.0", + "intapi_version": "1.2.0" + } + } + ] +} +``` + +#### 1.1.0 + +* Add `OnApproved` method + +#### 1.0.0 + +Initial release. + +### Versioning + +The API uses [semantic versioning](https://semver.org/). + +TLDR; Given a version number MAJOR.MINOR.PATCH, increment the: + +* MAJOR version when you make incompatible API changes, +* MINOR version when you add functionality in a backwards-compatible manner, and +* PATCH version when you make backwards-compatible bug fixes. + +Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format. diff --git a/cmd/clef/main.go b/cmd/clef/main.go new file mode 100644 index 0000000000..348bcb22f6 --- /dev/null +++ b/cmd/clef/main.go @@ -0,0 +1,640 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +// signer is a utility that can be used so sign transactions and +// arbitrary data. +package main + +import ( + "bufio" + "context" + "crypto/rand" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "io/ioutil" + "os" + "os/signal" + "os/user" + "path/filepath" + "runtime" + "strings" + + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/rpc" + "github.com/ethereum/go-ethereum/signer/core" + "github.com/ethereum/go-ethereum/signer/rules" + "github.com/ethereum/go-ethereum/signer/storage" + "gopkg.in/urfave/cli.v1" +) + +// ExternalAPIVersion -- see extapi_changelog.md +const ExternalAPIVersion = "2.0.0" + +// InternalAPIVersion -- see intapi_changelog.md +const InternalAPIVersion = "2.0.0" + +const legalWarning = ` +WARNING! + +Clef is alpha software, and not yet publically released. This software has _not_ been audited, and there +are no guarantees about the workings of this software. It may contain severe flaws. You should not use this software +unless you agree to take full responsibility for doing so, and know what you are doing. + +TLDR; THIS IS NOT PRODUCTION-READY SOFTWARE! + +` + +var ( + logLevelFlag = cli.IntFlag{ + Name: "loglevel", + Value: 4, + Usage: "log level to emit to the screen", + } + keystoreFlag = cli.StringFlag{ + Name: "keystore", + Value: filepath.Join(node.DefaultDataDir(), "keystore"), + Usage: "Directory for the keystore", + } + configdirFlag = cli.StringFlag{ + Name: "configdir", + Value: DefaultConfigDir(), + Usage: "Directory for Clef configuration", + } + rpcPortFlag = cli.IntFlag{ + Name: "rpcport", + Usage: "HTTP-RPC server listening port", + Value: node.DefaultHTTPPort + 5, + } + signerSecretFlag = cli.StringFlag{ + Name: "signersecret", + Usage: "A file containing the password used to encrypt Clef credentials, e.g. keystore credentials and ruleset hash", + } + dBFlag = cli.StringFlag{ + Name: "4bytedb", + Usage: "File containing 4byte-identifiers", + Value: "./4byte.json", + } + customDBFlag = cli.StringFlag{ + Name: "4bytedb-custom", + Usage: "File used for writing new 4byte-identifiers submitted via API", + Value: "./4byte-custom.json", + } + auditLogFlag = cli.StringFlag{ + Name: "auditlog", + Usage: "File used to emit audit logs. Set to \"\" to disable", + Value: "audit.log", + } + ruleFlag = cli.StringFlag{ + Name: "rules", + Usage: "Enable rule-engine", + Value: "rules.json", + } + stdiouiFlag = cli.BoolFlag{ + Name: "stdio-ui", + Usage: "Use STDIN/STDOUT as a channel for an external UI. " + + "This means that an STDIN/STDOUT is used for RPC-communication with a e.g. a graphical user " + + "interface, and can be used when Clef is started by an external process.", + } + testFlag = cli.BoolFlag{ + Name: "stdio-ui-test", + Usage: "Mechanism to test interface between Clef and UI. Requires 'stdio-ui'.", + } + app = cli.NewApp() + initCommand = cli.Command{ + Action: utils.MigrateFlags(initializeSecrets), + Name: "init", + Usage: "Initialize the signer, generate secret storage", + ArgsUsage: "", + Flags: []cli.Flag{ + logLevelFlag, + configdirFlag, + }, + Description: ` +The init command generates a master seed which Clef can use to store credentials and data needed for +the rule-engine to work.`, + } + attestCommand = cli.Command{ + Action: utils.MigrateFlags(attestFile), + Name: "attest", + Usage: "Attest that a js-file is to be used", + ArgsUsage: "", + Flags: []cli.Flag{ + logLevelFlag, + configdirFlag, + signerSecretFlag, + }, + Description: ` +The attest command stores the sha256 of the rule.js-file that you want to use for automatic processing of +incoming requests. + +Whenever you make an edit to the rule file, you need to use attestation to tell +Clef that the file is 'safe' to execute.`, + } + + addCredentialCommand = cli.Command{ + Action: utils.MigrateFlags(addCredential), + Name: "addpw", + Usage: "Store a credential for a keystore file", + ArgsUsage: "
", + Flags: []cli.Flag{ + logLevelFlag, + configdirFlag, + signerSecretFlag, + }, + Description: ` +The addpw command stores a password for a given address (keyfile). If you invoke it with only one parameter, it will +remove any stored credential for that address (keyfile) +`, + } +) + +func init() { + app.Name = "Clef" + app.Usage = "Manage Ethereum account operations" + app.Flags = []cli.Flag{ + logLevelFlag, + keystoreFlag, + configdirFlag, + utils.NetworkIdFlag, + utils.LightKDFFlag, + utils.NoUSBFlag, + utils.RPCListenAddrFlag, + utils.RPCVirtualHostsFlag, + utils.IPCDisabledFlag, + utils.IPCPathFlag, + utils.RPCEnabledFlag, + rpcPortFlag, + signerSecretFlag, + dBFlag, + customDBFlag, + auditLogFlag, + ruleFlag, + stdiouiFlag, + testFlag, + } + app.Action = signer + app.Commands = []cli.Command{initCommand, attestCommand, addCredentialCommand} + +} +func main() { + if err := app.Run(os.Args); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} + +func initializeSecrets(c *cli.Context) error { + if err := initialize(c); err != nil { + return err + } + configDir := c.String(configdirFlag.Name) + + masterSeed := make([]byte, 256) + n, err := io.ReadFull(rand.Reader, masterSeed) + if err != nil { + return err + } + if n != len(masterSeed) { + return fmt.Errorf("failed to read enough random") + } + err = os.Mkdir(configDir, 0700) + if err != nil && !os.IsExist(err) { + return err + } + location := filepath.Join(configDir, "secrets.dat") + if _, err := os.Stat(location); err == nil { + return fmt.Errorf("file %v already exists, will not overwrite", location) + } + err = ioutil.WriteFile(location, masterSeed, 0700) + if err != nil { + return err + } + fmt.Printf("A master seed has been generated into %s\n", location) + fmt.Printf(` +This is required to be able to store credentials, such as : +* Passwords for keystores (used by rule engine) +* Storage for javascript rules +* Hash of rule-file + +You should treat that file with utmost secrecy, and make a backup of it. +NOTE: This file does not contain your accounts. Those need to be backed up separately! + +`) + return nil +} +func attestFile(ctx *cli.Context) error { + if len(ctx.Args()) < 1 { + utils.Fatalf("This command requires an argument.") + } + if err := initialize(ctx); err != nil { + return err + } + + stretchedKey, err := readMasterKey(ctx) + if err != nil { + utils.Fatalf(err.Error()) + } + configDir := ctx.String(configdirFlag.Name) + vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10])) + confKey := crypto.Keccak256([]byte("config"), stretchedKey) + + // Initialize the encrypted storages + configStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "config.json"), confKey) + val := ctx.Args().First() + configStorage.Put("ruleset_sha256", val) + log.Info("Ruleset attestation updated", "sha256", val) + return nil +} + +func addCredential(ctx *cli.Context) error { + if len(ctx.Args()) < 1 { + utils.Fatalf("This command requires at leaste one argument.") + } + if err := initialize(ctx); err != nil { + return err + } + + stretchedKey, err := readMasterKey(ctx) + if err != nil { + utils.Fatalf(err.Error()) + } + configDir := ctx.String(configdirFlag.Name) + vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10])) + pwkey := crypto.Keccak256([]byte("credentials"), stretchedKey) + + // Initialize the encrypted storages + pwStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "credentials.json"), pwkey) + key := ctx.Args().First() + value := "" + if len(ctx.Args()) > 1 { + value = ctx.Args().Get(1) + } + pwStorage.Put(key, value) + log.Info("Credential store updated", "key", key) + return nil +} + +func initialize(c *cli.Context) error { + // Set up the logger to print everything + logOutput := os.Stdout + if c.Bool(stdiouiFlag.Name) { + logOutput = os.Stderr + // If using the stdioui, we can't do the 'confirm'-flow + fmt.Fprintf(logOutput, legalWarning) + } else { + if !confirm(legalWarning) { + return fmt.Errorf("aborted by user") + } + } + + log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(c.Int(logLevelFlag.Name)), log.StreamHandler(logOutput, log.TerminalFormat(true)))) + return nil +} + +func signer(c *cli.Context) error { + if err := initialize(c); err != nil { + return err + } + var ( + ui core.SignerUI + ) + if c.Bool(stdiouiFlag.Name) { + log.Info("Using stdin/stdout as UI-channel") + ui = core.NewStdIOUI() + } else { + log.Info("Using CLI as UI-channel") + ui = core.NewCommandlineUI() + } + db, err := core.NewAbiDBFromFiles(c.String(dBFlag.Name), c.String(customDBFlag.Name)) + if err != nil { + utils.Fatalf(err.Error()) + } + log.Info("Loaded 4byte db", "signatures", db.Size(), "file", c.String("4bytedb")) + + var ( + api core.ExternalAPI + ) + + configDir := c.String(configdirFlag.Name) + if stretchedKey, err := readMasterKey(c); err != nil { + log.Info("No master seed provided, rules disabled") + } else { + + if err != nil { + utils.Fatalf(err.Error()) + } + vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), stretchedKey)[:10])) + + // Generate domain specific keys + pwkey := crypto.Keccak256([]byte("credentials"), stretchedKey) + jskey := crypto.Keccak256([]byte("jsstorage"), stretchedKey) + confkey := crypto.Keccak256([]byte("config"), stretchedKey) + + // Initialize the encrypted storages + pwStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "credentials.json"), pwkey) + jsStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "jsstorage.json"), jskey) + configStorage := storage.NewAESEncryptedStorage(filepath.Join(vaultLocation, "config.json"), confkey) + + //Do we have a rule-file? + ruleJS, err := ioutil.ReadFile(c.String(ruleFlag.Name)) + if err != nil { + log.Info("Could not load rulefile, rules not enabled", "file", "rulefile") + } else { + hasher := sha256.New() + hasher.Write(ruleJS) + shasum := hasher.Sum(nil) + storedShasum := configStorage.Get("ruleset_sha256") + if storedShasum != hex.EncodeToString(shasum) { + log.Info("Could not validate ruleset hash, rules not enabled", "got", hex.EncodeToString(shasum), "expected", storedShasum) + } else { + // Initialize rules + ruleEngine, err := rules.NewRuleEvaluator(ui, jsStorage, pwStorage) + if err != nil { + utils.Fatalf(err.Error()) + } + ruleEngine.Init(string(ruleJS)) + ui = ruleEngine + log.Info("Rule engine configured", "file", c.String(ruleFlag.Name)) + } + } + } + + apiImpl := core.NewSignerAPI( + c.Int64(utils.NetworkIdFlag.Name), + c.String(keystoreFlag.Name), + c.Bool(utils.NoUSBFlag.Name), + ui, db, + c.Bool(utils.LightKDFFlag.Name)) + + api = apiImpl + + // Audit logging + if logfile := c.String(auditLogFlag.Name); logfile != "" { + api, err = core.NewAuditLogger(logfile, api) + if err != nil { + utils.Fatalf(err.Error()) + } + log.Info("Audit logs configured", "file", logfile) + } + // register signer API with server + var ( + extapiURL = "n/a" + ipcapiURL = "n/a" + ) + rpcAPI := []rpc.API{ + { + Namespace: "account", + Public: true, + Service: api, + Version: "1.0"}, + } + if c.Bool(utils.RPCEnabledFlag.Name) { + + vhosts := splitAndTrim(c.GlobalString(utils.RPCVirtualHostsFlag.Name)) + cors := splitAndTrim(c.GlobalString(utils.RPCCORSDomainFlag.Name)) + + // start http server + httpEndpoint := fmt.Sprintf("%s:%d", c.String(utils.RPCListenAddrFlag.Name), c.Int(rpcPortFlag.Name)) + listener, _, err := rpc.StartHTTPEndpoint(httpEndpoint, rpcAPI, []string{"account"}, cors, vhosts) + if err != nil { + utils.Fatalf("Could not start RPC api: %v", err) + } + extapiURL = fmt.Sprintf("http://%s", httpEndpoint) + log.Info("HTTP endpoint opened", "url", extapiURL) + + defer func() { + listener.Close() + log.Info("HTTP endpoint closed", "url", httpEndpoint) + }() + + } + if !c.Bool(utils.IPCDisabledFlag.Name) { + if c.IsSet(utils.IPCPathFlag.Name) { + ipcapiURL = c.String(utils.IPCPathFlag.Name) + } else { + ipcapiURL = filepath.Join(configDir, "clef.ipc") + } + + listener, _, err := rpc.StartIPCEndpoint(ipcapiURL, rpcAPI) + if err != nil { + utils.Fatalf("Could not start IPC api: %v", err) + } + log.Info("IPC endpoint opened", "url", ipcapiURL) + defer func() { + listener.Close() + log.Info("IPC endpoint closed", "url", ipcapiURL) + }() + + } + + if c.Bool(testFlag.Name) { + log.Info("Performing UI test") + go testExternalUI(apiImpl) + } + ui.OnSignerStartup(core.StartupInfo{ + Info: map[string]interface{}{ + "extapi_version": ExternalAPIVersion, + "intapi_version": InternalAPIVersion, + "extapi_http": extapiURL, + "extapi_ipc": ipcapiURL, + }, + }) + + abortChan := make(chan os.Signal) + signal.Notify(abortChan, os.Interrupt) + + sig := <-abortChan + log.Info("Exiting...", "signal", sig) + + return nil +} + +// splitAndTrim splits input separated by a comma +// and trims excessive white space from the substrings. +func splitAndTrim(input string) []string { + result := strings.Split(input, ",") + for i, r := range result { + result[i] = strings.TrimSpace(r) + } + return result +} + +// DefaultConfigDir is the default config directory to use for the vaults and other +// persistence requirements. +func DefaultConfigDir() string { + // Try to place the data folder in the user's home dir + home := homeDir() + if home != "" { + if runtime.GOOS == "darwin" { + return filepath.Join(home, "Library", "Signer") + } else if runtime.GOOS == "windows" { + return filepath.Join(home, "AppData", "Roaming", "Signer") + } else { + return filepath.Join(home, ".clef") + } + } + // As we cannot guess a stable location, return empty and handle later + return "" +} + +func homeDir() string { + if home := os.Getenv("HOME"); home != "" { + return home + } + if usr, err := user.Current(); err == nil { + return usr.HomeDir + } + return "" +} +func readMasterKey(ctx *cli.Context) ([]byte, error) { + var ( + file string + configDir = ctx.String(configdirFlag.Name) + ) + if ctx.IsSet(signerSecretFlag.Name) { + file = ctx.String(signerSecretFlag.Name) + } else { + file = filepath.Join(configDir, "secrets.dat") + } + if err := checkFile(file); err != nil { + return nil, err + } + masterKey, err := ioutil.ReadFile(file) + if err != nil { + return nil, err + } + if len(masterKey) < 256 { + return nil, fmt.Errorf("master key of insufficient length, expected >255 bytes, got %d", len(masterKey)) + } + // Create vault location + vaultLocation := filepath.Join(configDir, common.Bytes2Hex(crypto.Keccak256([]byte("vault"), masterKey)[:10])) + err = os.Mkdir(vaultLocation, 0700) + if err != nil && !os.IsExist(err) { + return nil, err + } + //!TODO, use KDF to stretch the master key + // stretched_key := stretch_key(master_key) + + return masterKey, nil +} + +// checkFile is a convenience function to check if a file +// * exists +// * is mode 0600 +func checkFile(filename string) error { + info, err := os.Stat(filename) + if err != nil { + return fmt.Errorf("failed stat on %s: %v", filename, err) + } + // Check the unix permission bits + if info.Mode().Perm()&077 != 0 { + return fmt.Errorf("file (%v) has insecure file permissions (%v)", filename, info.Mode().String()) + } + return nil +} + +// confirm displays a text and asks for user confirmation +func confirm(text string) bool { + fmt.Printf(text) + fmt.Printf("\nEnter 'ok' to proceed:\n>") + + text, err := bufio.NewReader(os.Stdin).ReadString('\n') + if err != nil { + log.Crit("Failed to read user input", "err", err) + } + + if text := strings.TrimSpace(text); text == "ok" { + return true + } + return false +} + +func testExternalUI(api *core.SignerAPI) { + + ctx := context.WithValue(context.Background(), "remote", "clef binary") + ctx = context.WithValue(ctx, "scheme", "in-proc") + ctx = context.WithValue(ctx, "local", "main") + + errs := make([]string, 0) + + api.UI.ShowInfo("Testing 'ShowInfo'") + api.UI.ShowError("Testing 'ShowError'") + + checkErr := func(method string, err error) { + if err != nil && err != core.ErrRequestDenied { + errs = append(errs, fmt.Sprintf("%v: %v", method, err.Error())) + } + } + var err error + + _, err = api.SignTransaction(ctx, core.SendTxArgs{From: common.MixedcaseAddress{}}, nil) + checkErr("SignTransaction", err) + _, err = api.Sign(ctx, common.MixedcaseAddress{}, common.Hex2Bytes("01020304")) + checkErr("Sign", err) + _, err = api.List(ctx) + checkErr("List", err) + _, err = api.New(ctx) + checkErr("New", err) + _, err = api.Export(ctx, common.Address{}) + checkErr("Export", err) + _, err = api.Import(ctx, json.RawMessage{}) + checkErr("Import", err) + + api.UI.ShowInfo("Tests completed") + + if len(errs) > 0 { + log.Error("Got errors") + for _, e := range errs { + log.Error(e) + } + } else { + log.Info("No errors") + } + +} + +/** +//Create Account + +curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_new","params":["test"],"id":67}' localhost:8550 + +// List accounts + +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_list","params":[""],"id":67}' http://localhost:8550/ + +// Make Transaction +// safeSend(0x12) +// 4401a6e40000000000000000000000000000000000000000000000000000000000000012 + +// supplied abi +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_signTransaction","params":[{"from":"0x82A2A876D39022B3019932D30Cd9c97ad5616813","gas":"0x333","gasPrice":"0x123","nonce":"0x0","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", "value":"0x10", "data":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012"},"test"],"id":67}' http://localhost:8550/ + +// Not supplied +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_signTransaction","params":[{"from":"0x82A2A876D39022B3019932D30Cd9c97ad5616813","gas":"0x333","gasPrice":"0x123","nonce":"0x0","to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", "value":"0x10", "data":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012"}],"id":67}' http://localhost:8550/ + +// Sign data + +curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0","method":"account_sign","params":["0x694267f14675d7e1b9494fd8d72fefe1755710fa","bazonk gaz baz"],"id":67}' http://localhost:8550/ + + +**/ diff --git a/cmd/clef/pythonsigner.py b/cmd/clef/pythonsigner.py new file mode 100644 index 0000000000..46fa23bd8c --- /dev/null +++ b/cmd/clef/pythonsigner.py @@ -0,0 +1,179 @@ +import os,sys, subprocess +from tinyrpc.transports import ServerTransport +from tinyrpc.protocols.jsonrpc import JSONRPCProtocol +from tinyrpc.dispatch import public,RPCDispatcher +from tinyrpc.server import RPCServer + +""" This is a POC example of how to write a custom UI for Clef. The UI starts the +clef process with the '--stdio-ui' option, and communicates with clef using standard input / output. + +The standard input/output is a relatively secure way to communicate, as it does not require opening any ports +or IPC files. Needless to say, it does not protect against memory inspection mechanisms where an attacker +can access process memory.""" + +try: + import urllib.parse as urlparse +except ImportError: + import urllib as urlparse + +class StdIOTransport(ServerTransport): + """ Uses std input/output for RPC """ + def receive_message(self): + return None, urlparse.unquote(sys.stdin.readline()) + + def send_reply(self, context, reply): + print(reply) + +class PipeTransport(ServerTransport): + """ Uses std a pipe for RPC """ + + def __init__(self,input, output): + self.input = input + self.output = output + + def receive_message(self): + data = self.input.readline() + print(">> {}".format( data)) + return None, urlparse.unquote(data) + + def send_reply(self, context, reply): + print("<< {}".format( reply)) + self.output.write(reply) + self.output.write("\n") + +class StdIOHandler(): + + def __init__(self): + pass + + @public + def ApproveTx(self,req): + """ + Example request: + { + "jsonrpc": "2.0", + "method": "ApproveTx", + "params": [{ + "transaction": { + "to": "0xae967917c465db8578ca9024c205720b1a3651A9", + "gas": "0x333", + "gasPrice": "0x123", + "value": "0x10", + "data": "0xd7a5865800000000000000000000000000000000000000000000000000000000000000ff", + "nonce": "0x0" + }, + "from": "0xAe967917c465db8578ca9024c205720b1a3651A9", + "call_info": "Warning! Could not validate ABI-data against calldata\nSupplied ABI spec does not contain method signature in data: 0xd7a58658", + "meta": { + "remote": "127.0.0.1:34572", + "local": "localhost:8550", + "scheme": "HTTP/1.1" + } + }], + "id": 1 + } + + :param transaction: transaction info + :param call_info: info abou the call, e.g. if ABI info could not be + :param meta: metadata about the request, e.g. where the call comes from + :return: + """ + transaction = req.get('transaction') + _from = req.get('from') + call_info = req.get('call_info') + meta = req.get('meta') + + return { + "approved" : False, + #"transaction" : transaction, + # "from" : _from, +# "password" : None, + } + + @public + def ApproveSignData(self, req): + """ Example request + + """ + return {"approved": False, "password" : None} + + @public + def ApproveExport(self, req): + """ Example request + + """ + return {"approved" : False} + + @public + def ApproveImport(self, req): + """ Example request + + """ + return { "approved" : False, "old_password": "", "new_password": ""} + + @public + def ApproveListing(self, req): + """ Example request + + """ + return {'accounts': []} + + @public + def ApproveNewAccount(self, req): + """ + Example request + + :return: + """ + return {"approved": False, + #"password": "" + } + + @public + def ShowError(self,message = {}): + """ + Example request: + + {"jsonrpc":"2.0","method":"ShowInfo","params":{"message":"Testing 'ShowError'"},"id":1} + + :param message: to show + :return: nothing + """ + if 'text' in message.keys(): + sys.stderr.write("Error: {}\n".format( message['text'])) + return + + @public + def ShowInfo(self,message = {}): + """ + Example request + {"jsonrpc":"2.0","method":"ShowInfo","params":{"message":"Testing 'ShowInfo'"},"id":0} + + :param message: to display + :return:nothing + """ + + if 'text' in message.keys(): + sys.stdout.write("Error: {}\n".format( message['text'])) + return + +def main(args): + + cmd = ["./clef", "--stdio-ui"] + if len(args) > 0 and args[0] == "test": + cmd.extend(["--stdio-ui-test"]) + print("cmd: {}".format(" ".join(cmd))) + dispatcher = RPCDispatcher() + dispatcher.register_instance(StdIOHandler(), '') + # line buffered + p = subprocess.Popen(cmd, bufsize=1, universal_newlines=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE) + + rpc_server = RPCServer( + PipeTransport(p.stdout, p.stdin), + JSONRPCProtocol(), + dispatcher + ) + rpc_server.serve_forever() + +if __name__ == '__main__': + main(sys.argv[1:]) diff --git a/cmd/clef/rules.md b/cmd/clef/rules.md new file mode 100644 index 0000000000..327ba765c5 --- /dev/null +++ b/cmd/clef/rules.md @@ -0,0 +1,236 @@ +# Rules + +The `signer` binary contains a ruleset engine, implemented with [OttoVM](https://github.com/robertkrimen/otto) + +It enables usecases like the following: + +* I want to auto-approve transactions with contract `CasinoDapp`, with up to `0.05 ether` in value to maximum `1 ether` per 24h period +* I want to auto-approve transaction to contract `EthAlarmClock` with `data`=`0xdeadbeef`, if `value=0`, `gas < 44k` and `gasPrice < 40Gwei` + +The two main features that are required for this to work well are; + +1. Rule Implementation: how to create, manage and interpret rules in a flexible but secure manner +2. Credential managements and credentials; how to provide auto-unlock without exposing keys unnecessarily. + +The section below deals with both of them + +## Rule Implementation + +A ruleset file is implemented as a `js` file. Under the hood, the ruleset-engine is a `SignerUI`, implementing the same methods as the `json-rpc` methods +defined in the UI protocol. Example: + +```javascript + +function asBig(str){ + if(str.slice(0,2) == "0x"){ return new BigNumber(str.slice(2),16)} + return new BigNumber(str) +} + +// Approve transactions to a certain contract if value is below a certain limit +function ApproveTx(req){ + + var limit = big.Newint("0xb1a2bc2ec50000") + var value = asBig(req.transaction.value); + + if(req.transaction.to.toLowerCase()=="0xae967917c465db8578ca9024c205720b1a3651a9") + && value.lt(limit) ){ + return "Approve" + } + // If we return "Reject", it will be rejected. + // By not returning anything, it will be passed to the next UI, for manual processing +} + +//Approve listings if request made from IPC +function ApproveListing(req){ + if (req.metadata.scheme == "ipc"){ return "Approve"} +} + +``` + +Whenever the external API is called (and the ruleset is enabled), the `signer` calls the UI, which is an instance of a ruleset-engine. The ruleset-engine +invokes the corresponding method. In doing so, there are three possible outcomes: + +1. JS returns "Approve" + * Auto-approve request +2. JS returns "Reject" + * Auto-reject request +3. Error occurs, or something else is returned + * Pass on to `next` ui: the regular UI channel. + +A more advanced example can be found below, "Example 1: ruleset for a rate-limited window", using `storage` to `Put` and `Get` `string`s by key. + +* At the time of writing, storage only exists as an ephemeral unencrypted implementation, to be used during testing. + +### Things to note + +The Otto vm has a few [caveats](https://github.com/robertkrimen/otto): + +* "use strict" will parse, but does nothing. +* The regular expression engine (re2/regexp) is not fully compatible with the ECMA5 specification. +* Otto targets ES5. ES6 features (eg: Typed Arrays) are not supported. + +Additionally, a few more have been added + +* The rule execution cannot load external javascript files. +* The only preloaded libary is [`bignumber.js`](https://github.com/MikeMcl/bignumber.js) version `2.0.3`. This one is fairly old, and is not aligned with the documentation at the github repository. +* Each invocation is made in a fresh virtual machine. This means that you cannot store data in global variables between invocations. This is a deliberate choice -- if you want to store data, use the disk-backed `storage`, since rules should not rely on ephemeral data. +* Javascript API parameters are _always_ an object. This is also a design choice, to ensure that parameters are accessed by _key_ and not by order. This is to prevent mistakes due to missing parameters or parameter changes. +* The JS engine has access to `storage` and `console`. + +#### Security considerations + +##### Security of ruleset + +Some security precautions can be made, such as: + +* Never load `ruleset.js` unless the file is `readonly` (`r-??-??-?`). If the user wishes to modify the ruleset, he must make it writeable and then set back to readonly. + * This is to prevent attacks where files are dropped on the users disk. +* Since we're going to have to have some form of secure storage (not defined in this section), we could also store the `sha3` of the `ruleset.js` file in there. + * If the user wishes to modify the ruleset, he'd then have to perform e.g. `signer --attest /path/to/ruleset --credential ` + +##### Security of implementation + +The drawbacks of this very flexible solution is that the `signer` needs to contain a javascript engine. This is pretty simple to implement, since it's already +implemented for `geth`. There are no known security vulnerabilities in, nor have we had any security-problems with it so far. + +The javascript engine would be an added attack surface; but if the validation of `rulesets` is made good (with hash-based attestation), the actual javascript cannot be considered +an attack surface -- if an attacker can control the ruleset, a much simpler attack would be to implement an "always-approve" rule instead of exploiting the js vm. The only benefit +to be gained from attacking the actual `signer` process from the `js` side would be if it could somehow extract cryptographic keys from memory. + +##### Security in usability + +Javascript is flexible, but also easy to get wrong, especially when users assume that `js` can handle large integers natively. Typical errors +include trying to multiply `gasCost` with `gas` without using `bigint`:s. + +It's unclear whether any other DSL could be more secure; since there's always the possibility of erroneously implementing a rule. + + +## Credential management + +The ability to auto-approve transaction means that the signer needs to have necessary credentials to decrypt keyfiles. These passwords are hereafter called `ksp` (keystore pass). + +### Example implementation + +Upon startup of the signer, the signer is given a switch: `--seed ` +The `seed` contains a blob of bytes, which is the master seed for the `signer`. + +The `signer` uses the `seed` to: + +* Generate the `path` where the settings are stored. + * `./settings/1df094eb-c2b1-4689-90dd-790046d38025/vault.dat` + * `./settings/1df094eb-c2b1-4689-90dd-790046d38025/rules.js` +* Generate the encryption password for `vault.dat`. + +The `vault.dat` would be an encrypted container storing the following information: + +* `ksp` entries +* `sha256` hash of `rules.js` +* Information about pair:ed callers (not yet specified) + +### Security considerations + +This would leave it up to the user to ensure that the `path/to/masterseed` is handled in a secure way. It's difficult to get around this, although one could +imagine leveraging OS-level keychains where supported. The setup is however in general similar to how ssh-keys are stored in `.ssh/`. + + +# Implementation status + +This is now implemented (with ephemeral non-encrypted storage for now, so not yet enabled). + +## Example 1: ruleset for a rate-limited window + + +```javascript + + function big(str){ + if(str.slice(0,2) == "0x"){ return new BigNumber(str.slice(2),16)} + return new BigNumber(str) + } + + // Time window: 1 week + var window = 1000* 3600*24*7; + + // Limit : 1 ether + var limit = new BigNumber("1e18"); + + function isLimitOk(transaction){ + var value = big(transaction.value) + // Start of our window function + var windowstart = new Date().getTime() - window; + + var txs = []; + var stored = storage.Get('txs'); + + if(stored != ""){ + txs = JSON.parse(stored) + } + // First, remove all that have passed out of the time-window + var newtxs = txs.filter(function(tx){return tx.tstamp > windowstart}); + console.log(txs, newtxs.length); + + // Secondly, aggregate the current sum + sum = new BigNumber(0) + + sum = newtxs.reduce(function(agg, tx){ return big(tx.value).plus(agg)}, sum); + console.log("ApproveTx > Sum so far", sum); + console.log("ApproveTx > Requested", value.toNumber()); + + // Would we exceed weekly limit ? + return sum.plus(value).lt(limit) + + } + function ApproveTx(r){ + if (isLimitOk(r.transaction)){ + return "Approve" + } + return "Nope" + } + + /** + * OnApprovedTx(str) is called when a transaction has been approved and signed. The parameter + * 'response_str' contains the return value that will be sent to the external caller. + * The return value from this method is ignore - the reason for having this callback is to allow the + * ruleset to keep track of approved transactions. + * + * When implementing rate-limited rules, this callback should be used. + * If a rule responds with neither 'Approve' nor 'Reject' - the tx goes to manual processing. If the user + * then accepts the transaction, this method will be called. + * + * TLDR; Use this method to keep track of signed transactions, instead of using the data in ApproveTx. + */ + function OnApprovedTx(resp){ + var value = big(resp.tx.value) + var txs = [] + // Load stored transactions + var stored = storage.Get('txs'); + if(stored != ""){ + txs = JSON.parse(stored) + } + // Add this to the storage + txs.push({tstamp: new Date().getTime(), value: value}); + storage.Put("txs", JSON.stringify(txs)); + } + +``` + +## Example 2: allow destination + +```javascript + + function ApproveTx(r){ + if(r.transaction.from.toLowerCase()=="0x0000000000000000000000000000000000001337"){ return "Approve"} + if(r.transaction.from.toLowerCase()=="0x000000000000000000000000000000000000dead"){ return "Reject"} + // Otherwise goes to manual processing + } + +``` + +## Example 3: Allow listing + +```javascript + + function ApproveListing(){ + return "Approve" + } + +``` \ No newline at end of file diff --git a/cmd/clef/sign_flow.png b/cmd/clef/sign_flow.png new file mode 100644 index 0000000000..9c0f3cc5d5 Binary files /dev/null and b/cmd/clef/sign_flow.png differ diff --git a/cmd/clef/tutorial.md b/cmd/clef/tutorial.md new file mode 100644 index 0000000000..d59e08ac7a --- /dev/null +++ b/cmd/clef/tutorial.md @@ -0,0 +1,198 @@ +## Initializing the signer + +First, initialize the master seed. + +```text +#./signer init + +WARNING! + +The signer is alpha software, and not yet publically released. This software has _not_ been audited, and there +are no guarantees about the workings of this software. It may contain severe flaws. You should not use this software +unless you agree to take full responsibility for doing so, and know what you are doing. + +TLDR; THIS IS NOT PRODUCTION-READY SOFTWARE! + + +Enter 'ok' to proceed: +>ok +A master seed has been generated into /home/martin/.signer/secrets.dat + +This is required to be able to store credentials, such as : +* Passwords for keystores (used by rule engine) +* Storage for javascript rules +* Hash of rule-file + +You should treat that file with utmost secrecy, and make a backup of it. +NOTE: This file does not contain your accounts. Those need to be backed up separately! +``` + +(for readability purposes, we'll remove the WARNING printout in the rest of this document) + +## Creating rules + +Now, you can create a rule-file. + +```javascript +function ApproveListing(){ + return "Approve" +} +``` +Get the `sha256` hash.... +```text +#sha256sum rules.js +6c21d1737429d6d4f2e55146da0797782f3c0a0355227f19d702df377c165d72 rules.js +``` +...And then `attest` the file: +```text +#./signer attest 6c21d1737429d6d4f2e55146da0797782f3c0a0355227f19d702df377c165d72 + +INFO [02-21|12:14:38] Ruleset attestation updated sha256=6c21d1737429d6d4f2e55146da0797782f3c0a0355227f19d702df377c165d72 +``` +At this point, we then start the signer with the rule-file: + +```text +#./signer --rules rules.json + +INFO [02-21|12:15:18] Using CLI as UI-channel +INFO [02-21|12:15:18] Loaded 4byte db signatures=5509 file=./4byte.json +INFO [02-21|12:15:18] Could not load rulefile, rules not enabled file=rulefile +DEBUG[02-21|12:15:18] FS scan times list=35.335µs set=5.536µs diff=5.073µs +DEBUG[02-21|12:15:18] Ledger support enabled +DEBUG[02-21|12:15:18] Trezor support enabled +INFO [02-21|12:15:18] Audit logs configured file=audit.log +INFO [02-21|12:15:18] HTTP endpoint opened url=http://localhost:8550 +------- Signer info ------- +* extapi_http : http://localhost:8550 +* extapi_ipc : +* extapi_version : 2.0.0 +* intapi_version : 1.2.0 + +``` + +Any list-requests will now be auto-approved by our rule-file. + +## Under the hood + +While doing the operations above, these files have been created: + +```text +#ls -laR ~/.signer/ +/home/martin/.signer/: +total 16 +drwx------ 3 martin martin 4096 feb 21 12:14 . +drwxr-xr-x 71 martin martin 4096 feb 21 12:12 .. +drwx------ 2 martin martin 4096 feb 21 12:14 43f73718397aa54d1b22 +-rwx------ 1 martin martin 256 feb 21 12:12 secrets.dat + +/home/martin/.signer/43f73718397aa54d1b22: +total 12 +drwx------ 2 martin martin 4096 feb 21 12:14 . +drwx------ 3 martin martin 4096 feb 21 12:14 .. +-rw------- 1 martin martin 159 feb 21 12:14 config.json + +#cat /home/martin/.signer/43f73718397aa54d1b22/config.json +{"ruleset_sha256":{"iv":"6v4W4tfJxj3zZFbl","c":"6dt5RTDiTq93yh1qDEjpsat/tsKG7cb+vr3sza26IPL2fvsQ6ZoqFx++CPUa8yy6fD9Bbq41L01ehkKHTG3pOAeqTW6zc/+t0wv3AB6xPmU="}} + +``` + +In `~/.signer`, the `secrets.dat` file was created, containing the `master_seed`. +The `master_seed` was then used to derive a few other things: + +- `vault_location` : in this case `43f73718397aa54d1b22` . + - Thus, if you use a different `master_seed`, another `vault_location` will be used that does not conflict with each other. + - Example: `signer --signersecret /path/to/afile ...` +- `config.json` which is the encrypted key/value storage for configuration data, containing the key `ruleset_sha256`. + + +## Adding credentials + +In order to make more useful rules; sign transactions, the signer needs access to the passwords needed to unlock keystores. + +```text +#./signer addpw 0x694267f14675d7e1b9494fd8d72fefe1755710fa test + +INFO [02-21|13:43:21] Credential store updated key=0x694267f14675d7e1b9494fd8d72fefe1755710fa +``` +## More advanced rules + +Now let's update the rules to make use of credentials + +```javascript +function ApproveListing(){ + return "Approve" +} +function ApproveSignData(r){ + if( r.address.toLowerCase() == "0x694267f14675d7e1b9494fd8d72fefe1755710fa") + { + if(r.message.indexOf("bazonk") >= 0){ + return "Approve" + } + return "Reject" + } + // Otherwise goes to manual processing +} + +``` +In this example, +* any requests to sign data with the account `0x694...` will be + * auto-approved if the message contains with `bazonk`, + * and auto-rejected if it does not. + * Any other signing-requests will be passed along for manual approve/reject. + +..attest the new file +```text +#sha256sum rules.js +2a0cb661dacfc804b6e95d935d813fd17c0997a7170e4092ffbc34ca976acd9f rules.js + +#./signer attest 2a0cb661dacfc804b6e95d935d813fd17c0997a7170e4092ffbc34ca976acd9f + +INFO [02-21|14:36:30] Ruleset attestation updated sha256=2a0cb661dacfc804b6e95d935d813fd17c0997a7170e4092ffbc34ca976acd9f +``` + +And start the signer: + +``` +#./signer --rules rules.js + +INFO [02-21|14:41:56] Using CLI as UI-channel +INFO [02-21|14:41:56] Loaded 4byte db signatures=5509 file=./4byte.json +INFO [02-21|14:41:56] Rule engine configured file=rules.js +DEBUG[02-21|14:41:56] FS scan times list=34.607µs set=4.509µs diff=4.87µs +DEBUG[02-21|14:41:56] Ledger support enabled +DEBUG[02-21|14:41:56] Trezor support enabled +INFO [02-21|14:41:56] Audit logs configured file=audit.log +INFO [02-21|14:41:56] HTTP endpoint opened url=http://localhost:8550 +------- Signer info ------- +* extapi_version : 2.0.0 +* intapi_version : 1.2.0 +* extapi_http : http://localhost:8550 +* extapi_ipc : +INFO [02-21|14:41:56] error occurred during execution error="ReferenceError: 'OnSignerStartup' is not defined" +``` +And then test signing, once with `bazonk` and once without: + +``` +#curl -H "Content-Type: application/json" -X POST --data "{\"jsonrpc\":\"2.0\",\"method\":\"account_sign\",\"params\":[\"0x694267f14675d7e1b9494fd8d72fefe1755710fa\",\"0x$(xxd -pu <<< ' bazonk baz gaz')\"],\"id\":67}" http://localhost:8550/ +{"jsonrpc":"2.0","id":67,"result":"0x93e6161840c3ae1efc26dc68dedab6e8fc233bb3fefa1b4645dbf6609b93dace160572ea4ab33240256bb6d3dadb60dcd9c515d6374d3cf614ee897408d41d541c"} + +#curl -H "Content-Type: application/json" -X POST --data "{\"jsonrpc\":\"2.0\",\"method\":\"account_sign\",\"params\":[\"0x694267f14675d7e1b9494fd8d72fefe1755710fa\",\"0x$(xxd -pu <<< ' bonk baz gaz')\"],\"id\":67}" http://localhost:8550/ +{"jsonrpc":"2.0","id":67,"error":{"code":-32000,"message":"Request denied"}} + +``` + +Meanwhile, in the signer output: +```text +INFO [02-21|14:42:41] Op approved +INFO [02-21|14:42:56] Op rejected +``` + +The signer also stores all traffic over the external API in a log file. The last 4 lines shows the two requests and their responses: + +```text +#tail audit.log -n 4 +t=2018-02-21T14:42:41+0100 lvl=info msg=Sign api=signer type=request metadata="{\"remote\":\"127.0.0.1:49706\",\"local\":\"localhost:8550\",\"scheme\":\"HTTP/1.1\"}" addr="0x694267f14675d7e1b9494fd8d72fefe1755710fa [chksum INVALID]" data=202062617a6f6e6b2062617a2067617a0a +t=2018-02-21T14:42:42+0100 lvl=info msg=Sign api=signer type=response data=93e6161840c3ae1efc26dc68dedab6e8fc233bb3fefa1b4645dbf6609b93dace160572ea4ab33240256bb6d3dadb60dcd9c515d6374d3cf614ee897408d41d541c error=nil +t=2018-02-21T14:42:56+0100 lvl=info msg=Sign api=signer type=request metadata="{\"remote\":\"127.0.0.1:49708\",\"local\":\"localhost:8550\",\"scheme\":\"HTTP/1.1\"}" addr="0x694267f14675d7e1b9494fd8d72fefe1755710fa [chksum INVALID]" data=2020626f6e6b2062617a2067617a0a +t=2018-02-21T14:42:56+0100 lvl=info msg=Sign api=signer type=response data= error="Request denied" +``` diff --git a/cmd/ethkey/README.md b/cmd/ethkey/README.md new file mode 100644 index 0000000000..cf72ba43d7 --- /dev/null +++ b/cmd/ethkey/README.md @@ -0,0 +1,41 @@ +ethkey +====== + +ethkey is a simple command-line tool for working with Ethereum keyfiles. + + +# Usage + +### `ethkey generate` + +Generate a new keyfile. +If you want to use an existing private key to use in the keyfile, it can be +specified by setting `--privatekey` with the location of the file containing the +private key. + + +### `ethkey inspect ` + +Print various information about the keyfile. +Private key information can be printed by using the `--private` flag; +make sure to use this feature with great caution! + + +### `ethkey sign ` + +Sign the message with a keyfile. +It is possible to refer to a file containing the message. + + +### `ethkey verify
` + +Verify the signature of the message. +It is possible to refer to a file containing the message. + + +## Passphrases + +For every command that uses a keyfile, you will be prompted to provide the +passphrase for decrypting the keyfile. To avoid this message, it is possible +to pass the passphrase by using the `--passphrase` flag pointing to a file that +contains the passphrase. diff --git a/cmd/ethkey/changepassphrase.go b/cmd/ethkey/changepassphrase.go new file mode 100644 index 0000000000..d1ae2ae0d8 --- /dev/null +++ b/cmd/ethkey/changepassphrase.go @@ -0,0 +1,72 @@ +package main + +import ( + "fmt" + "io/ioutil" + "strings" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "gopkg.in/urfave/cli.v1" +) + +var newPassphraseFlag = cli.StringFlag{ + Name: "newpasswordfile", + Usage: "the file that contains the new passphrase for the keyfile", +} + +var commandChangePassphrase = cli.Command{ + Name: "changepassphrase", + Usage: "change the passphrase on a keyfile", + ArgsUsage: "", + Description: ` +Change the passphrase of a keyfile.`, + Flags: []cli.Flag{ + passphraseFlag, + newPassphraseFlag, + }, + Action: func(ctx *cli.Context) error { + keyfilepath := ctx.Args().First() + + // Read key from file. + keyjson, err := ioutil.ReadFile(keyfilepath) + if err != nil { + utils.Fatalf("Failed to read the keyfile at '%s': %v", keyfilepath, err) + } + + // Decrypt key with passphrase. + passphrase := getPassphrase(ctx) + key, err := keystore.DecryptKey(keyjson, passphrase) + if err != nil { + utils.Fatalf("Error decrypting key: %v", err) + } + + // Get a new passphrase. + fmt.Println("Please provide a new passphrase") + var newPhrase string + if passFile := ctx.String(newPassphraseFlag.Name); passFile != "" { + content, err := ioutil.ReadFile(passFile) + if err != nil { + utils.Fatalf("Failed to read new passphrase file '%s': %v", passFile, err) + } + newPhrase = strings.TrimRight(string(content), "\r\n") + } else { + newPhrase = promptPassphrase(true) + } + + // Encrypt the key with the new passphrase. + newJson, err := keystore.EncryptKey(key, newPhrase, keystore.StandardScryptN, keystore.StandardScryptP) + if err != nil { + utils.Fatalf("Error encrypting with new passphrase: %v", err) + } + + // Then write the new keyfile in place of the old one. + if err := ioutil.WriteFile(keyfilepath, newJson, 600); err != nil { + utils.Fatalf("Error writing new keyfile to disk: %v", err) + } + + // Don't print anything. Just return successfully, + // producing a positive exit code. + return nil + }, +} diff --git a/cmd/ethkey/generate.go b/cmd/ethkey/generate.go new file mode 100644 index 0000000000..fe9a0c1519 --- /dev/null +++ b/cmd/ethkey/generate.go @@ -0,0 +1,118 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "crypto/ecdsa" + "fmt" + "io/ioutil" + "os" + "path/filepath" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/pborman/uuid" + "gopkg.in/urfave/cli.v1" +) + +type outputGenerate struct { + Address string + AddressEIP55 string +} + +var commandGenerate = cli.Command{ + Name: "generate", + Usage: "generate new keyfile", + ArgsUsage: "[ ]", + Description: ` +Generate a new keyfile. + +If you want to encrypt an existing private key, it can be specified by setting +--privatekey with the location of the file containing the private key. +`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + cli.StringFlag{ + Name: "privatekey", + Usage: "file containing a raw private key to encrypt", + }, + }, + Action: func(ctx *cli.Context) error { + // Check if keyfile path given and make sure it doesn't already exist. + keyfilepath := ctx.Args().First() + if keyfilepath == "" { + keyfilepath = defaultKeyfileName + } + if _, err := os.Stat(keyfilepath); err == nil { + utils.Fatalf("Keyfile already exists at %s.", keyfilepath) + } else if !os.IsNotExist(err) { + utils.Fatalf("Error checking if keyfile exists: %v", err) + } + + var privateKey *ecdsa.PrivateKey + var err error + if file := ctx.String("privatekey"); file != "" { + // Load private key from file. + privateKey, err = crypto.LoadECDSA(file) + if err != nil { + utils.Fatalf("Can't load private key: %v", err) + } + } else { + // If not loaded, generate random. + privateKey, err = crypto.GenerateKey() + if err != nil { + utils.Fatalf("Failed to generate random private key: %v", err) + } + } + + // Create the keyfile object with a random UUID. + id := uuid.NewRandom() + key := &keystore.Key{ + Id: id, + Address: crypto.PubkeyToAddress(privateKey.PublicKey), + PrivateKey: privateKey, + } + + // Encrypt key with passphrase. + passphrase := promptPassphrase(true) + keyjson, err := keystore.EncryptKey(key, passphrase, keystore.StandardScryptN, keystore.StandardScryptP) + if err != nil { + utils.Fatalf("Error encrypting key: %v", err) + } + + // Store the file to disk. + if err := os.MkdirAll(filepath.Dir(keyfilepath), 0700); err != nil { + utils.Fatalf("Could not create directory %s", filepath.Dir(keyfilepath)) + } + if err := ioutil.WriteFile(keyfilepath, keyjson, 0600); err != nil { + utils.Fatalf("Failed to write keyfile to %s: %v", keyfilepath, err) + } + + // Output some information. + out := outputGenerate{ + Address: key.Address.Hex(), + } + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Address:", out.Address) + } + return nil + }, +} diff --git a/cmd/ethkey/inspect.go b/cmd/ethkey/inspect.go new file mode 100644 index 0000000000..ba03d4d936 --- /dev/null +++ b/cmd/ethkey/inspect.go @@ -0,0 +1,91 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "encoding/hex" + "fmt" + "io/ioutil" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +type outputInspect struct { + Address string + PublicKey string + PrivateKey string +} + +var commandInspect = cli.Command{ + Name: "inspect", + Usage: "inspect a keyfile", + ArgsUsage: "", + Description: ` +Print various information about the keyfile. + +Private key information can be printed by using the --private flag; +make sure to use this feature with great caution!`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + cli.BoolFlag{ + Name: "private", + Usage: "include the private key in the output", + }, + }, + Action: func(ctx *cli.Context) error { + keyfilepath := ctx.Args().First() + + // Read key from file. + keyjson, err := ioutil.ReadFile(keyfilepath) + if err != nil { + utils.Fatalf("Failed to read the keyfile at '%s': %v", keyfilepath, err) + } + + // Decrypt key with passphrase. + passphrase := getPassphrase(ctx) + key, err := keystore.DecryptKey(keyjson, passphrase) + if err != nil { + utils.Fatalf("Error decrypting key: %v", err) + } + + // Output all relevant information we can retrieve. + showPrivate := ctx.Bool("private") + out := outputInspect{ + Address: key.Address.Hex(), + PublicKey: hex.EncodeToString( + crypto.FromECDSAPub(&key.PrivateKey.PublicKey)), + } + if showPrivate { + out.PrivateKey = hex.EncodeToString(crypto.FromECDSA(key.PrivateKey)) + } + + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Address: ", out.Address) + fmt.Println("Public key: ", out.PublicKey) + if showPrivate { + fmt.Println("Private key: ", out.PrivateKey) + } + } + return nil + }, +} diff --git a/cmd/ethkey/main.go b/cmd/ethkey/main.go new file mode 100644 index 0000000000..c434da0c05 --- /dev/null +++ b/cmd/ethkey/main.go @@ -0,0 +1,64 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "fmt" + "os" + + "github.com/ethereum/go-ethereum/cmd/utils" + "gopkg.in/urfave/cli.v1" +) + +const ( + defaultKeyfileName = "keyfile.json" +) + +// Git SHA1 commit hash of the release (set via linker flags) +var gitCommit = "" + +var app *cli.App + +func init() { + app = utils.NewApp(gitCommit, "an Ethereum key manager") + app.Commands = []cli.Command{ + commandGenerate, + commandInspect, + commandChangePassphrase, + commandSignMessage, + commandVerifyMessage, + } +} + +// Commonly used command line flags. +var ( + passphraseFlag = cli.StringFlag{ + Name: "passwordfile", + Usage: "the file that contains the passphrase for the keyfile", + } + jsonFlag = cli.BoolFlag{ + Name: "json", + Usage: "output JSON instead of human-readable format", + } +) + +func main() { + if err := app.Run(os.Args); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} diff --git a/cmd/ethkey/message.go b/cmd/ethkey/message.go new file mode 100644 index 0000000000..5caea69ff6 --- /dev/null +++ b/cmd/ethkey/message.go @@ -0,0 +1,159 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "encoding/hex" + "fmt" + "io/ioutil" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +type outputSign struct { + Signature string +} + +var msgfileFlag = cli.StringFlag{ + Name: "msgfile", + Usage: "file containing the message to sign/verify", +} + +var commandSignMessage = cli.Command{ + Name: "signmessage", + Usage: "sign a message", + ArgsUsage: " ", + Description: ` +Sign the message with a keyfile. + +To sign a message contained in a file, use the --msgfile flag. +`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + msgfileFlag, + }, + Action: func(ctx *cli.Context) error { + message := getMessage(ctx, 1) + + // Load the keyfile. + keyfilepath := ctx.Args().First() + keyjson, err := ioutil.ReadFile(keyfilepath) + if err != nil { + utils.Fatalf("Failed to read the keyfile at '%s': %v", keyfilepath, err) + } + + // Decrypt key with passphrase. + passphrase := getPassphrase(ctx) + key, err := keystore.DecryptKey(keyjson, passphrase) + if err != nil { + utils.Fatalf("Error decrypting key: %v", err) + } + + signature, err := crypto.Sign(signHash(message), key.PrivateKey) + if err != nil { + utils.Fatalf("Failed to sign message: %v", err) + } + out := outputSign{Signature: hex.EncodeToString(signature)} + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Signature:", out.Signature) + } + return nil + }, +} + +type outputVerify struct { + Success bool + RecoveredAddress string + RecoveredPublicKey string +} + +var commandVerifyMessage = cli.Command{ + Name: "verifymessage", + Usage: "verify the signature of a signed message", + ArgsUsage: "
", + Description: ` +Verify the signature of the message. +It is possible to refer to a file containing the message.`, + Flags: []cli.Flag{ + jsonFlag, + msgfileFlag, + }, + Action: func(ctx *cli.Context) error { + addressStr := ctx.Args().First() + signatureHex := ctx.Args().Get(1) + message := getMessage(ctx, 2) + + if !common.IsHexAddress(addressStr) { + utils.Fatalf("Invalid address: %s", addressStr) + } + address := common.HexToAddress(addressStr) + signature, err := hex.DecodeString(signatureHex) + if err != nil { + utils.Fatalf("Signature encoding is not hexadecimal: %v", err) + } + + recoveredPubkey, err := crypto.SigToPub(signHash(message), signature) + if err != nil || recoveredPubkey == nil { + utils.Fatalf("Signature verification failed: %v", err) + } + recoveredPubkeyBytes := crypto.FromECDSAPub(recoveredPubkey) + recoveredAddress := crypto.PubkeyToAddress(*recoveredPubkey) + success := address == recoveredAddress + + out := outputVerify{ + Success: success, + RecoveredPublicKey: hex.EncodeToString(recoveredPubkeyBytes), + RecoveredAddress: recoveredAddress.Hex(), + } + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + if out.Success { + fmt.Println("Signature verification successful!") + } else { + fmt.Println("Signature verification failed!") + } + fmt.Println("Recovered public key:", out.RecoveredPublicKey) + fmt.Println("Recovered address:", out.RecoveredAddress) + } + return nil + }, +} + +func getMessage(ctx *cli.Context, msgarg int) []byte { + if file := ctx.String("msgfile"); file != "" { + if len(ctx.Args()) > msgarg { + utils.Fatalf("Can't use --msgfile and message argument at the same time.") + } + msg, err := ioutil.ReadFile(file) + if err != nil { + utils.Fatalf("Can't read message file: %v", err) + } + return msg + } else if len(ctx.Args()) == msgarg+1 { + return []byte(ctx.Args().Get(msgarg)) + } + utils.Fatalf("Invalid number of arguments: want %d, got %d", msgarg+1, len(ctx.Args())) + return nil +} diff --git a/cmd/ethkey/message_test.go b/cmd/ethkey/message_test.go new file mode 100644 index 0000000000..39352b1d22 --- /dev/null +++ b/cmd/ethkey/message_test.go @@ -0,0 +1,70 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "io/ioutil" + "os" + "path/filepath" + "testing" +) + +func TestMessageSignVerify(t *testing.T) { + tmpdir, err := ioutil.TempDir("", "ethkey-test") + if err != nil { + t.Fatal("Can't create temporary directory:", err) + } + defer os.RemoveAll(tmpdir) + + keyfile := filepath.Join(tmpdir, "the-keyfile") + message := "test message" + + // Create the key. + generate := runEthkey(t, "generate", keyfile) + generate.Expect(` +!! Unsupported terminal, password will be echoed. +Passphrase: {{.InputLine "foobar"}} +Repeat passphrase: {{.InputLine "foobar"}} +`) + _, matches := generate.ExpectRegexp(`Address: (0x[0-9a-fA-F]{40})\n`) + address := matches[1] + generate.ExpectExit() + + // Sign a message. + sign := runEthkey(t, "signmessage", keyfile, message) + sign.Expect(` +!! Unsupported terminal, password will be echoed. +Passphrase: {{.InputLine "foobar"}} +`) + _, matches = sign.ExpectRegexp(`Signature: ([0-9a-f]+)\n`) + signature := matches[1] + sign.ExpectExit() + + // Verify the message. + verify := runEthkey(t, "verifymessage", address, signature, message) + _, matches = verify.ExpectRegexp(` +Signature verification successful! +Recovered public key: [0-9a-f]+ +Recovered address: (0x[0-9a-fA-F]{40}) +`) + recovered := matches[1] + verify.ExpectExit() + + if recovered != address { + t.Error("recovered address doesn't match generated key") + } +} diff --git a/cmd/ethkey/run_test.go b/cmd/ethkey/run_test.go new file mode 100644 index 0000000000..6006f6b5bb --- /dev/null +++ b/cmd/ethkey/run_test.go @@ -0,0 +1,54 @@ +// Copyright 2018 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "fmt" + "os" + "testing" + + "github.com/docker/docker/pkg/reexec" + "github.com/ethereum/go-ethereum/internal/cmdtest" +) + +type testEthkey struct { + *cmdtest.TestCmd +} + +// spawns ethkey with the given command line args. +func runEthkey(t *testing.T, args ...string) *testEthkey { + tt := new(testEthkey) + tt.TestCmd = cmdtest.NewTestCmd(t, tt) + tt.Run("ethkey-test", args...) + return tt +} + +func TestMain(m *testing.M) { + // Run the app if we've been exec'd as "ethkey-test" in runEthkey. + reexec.Register("ethkey-test", func() { + if err := app.Run(os.Args); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + os.Exit(0) + }) + // check if we have been reexec'd + if reexec.Init() { + return + } + os.Exit(m.Run()) +} diff --git a/cmd/ethkey/utils.go b/cmd/ethkey/utils.go new file mode 100644 index 0000000000..6f60ebaf1b --- /dev/null +++ b/cmd/ethkey/utils.go @@ -0,0 +1,91 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "strings" + + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/console" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +// promptPassphrase prompts the user for a passphrase. Set confirmation to true +// to require the user to confirm the passphrase. +func promptPassphrase(confirmation bool) string { + passphrase, err := console.Stdin.PromptPassword("Passphrase: ") + if err != nil { + utils.Fatalf("Failed to read passphrase: %v", err) + } + + if confirmation { + confirm, err := console.Stdin.PromptPassword("Repeat passphrase: ") + if err != nil { + utils.Fatalf("Failed to read passphrase confirmation: %v", err) + } + if passphrase != confirm { + utils.Fatalf("Passphrases do not match") + } + } + + return passphrase +} + +// getPassphrase obtains a passphrase given by the user. It first checks the +// --passfile command line flag and ultimately prompts the user for a +// passphrase. +func getPassphrase(ctx *cli.Context) string { + // Look for the --passwordfile flag. + passphraseFile := ctx.String(passphraseFlag.Name) + if passphraseFile != "" { + content, err := ioutil.ReadFile(passphraseFile) + if err != nil { + utils.Fatalf("Failed to read passphrase file '%s': %v", + passphraseFile, err) + } + return strings.TrimRight(string(content), "\r\n") + } + + // Otherwise prompt the user for the passphrase. + return promptPassphrase(false) +} + +// signHash is a helper function that calculates a hash for the given message +// that can be safely used to calculate a signature from. +// +// The hash is calulcated as +// keccak256("\x19Ethereum Signed Message:\n"${message length}${message}). +// +// This gives context to the signed message and prevents signing of transactions. +func signHash(data []byte) []byte { + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data) + return crypto.Keccak256([]byte(msg)) +} + +// mustPrintJSON prints the JSON encoding of the given object and +// exits the program with an error message when the marshaling fails. +func mustPrintJSON(jsonObject interface{}) { + str, err := json.MarshalIndent(jsonObject, "", " ") + if err != nil { + utils.Fatalf("Failed to marshal JSON object: %v", err) + } + fmt.Println(string(str)) +} diff --git a/cmd/evm/json_logger.go b/cmd/evm/json_logger.go index eb7b0c4660..f16424fbe6 100644 --- a/cmd/evm/json_logger.go +++ b/cmd/evm/json_logger.go @@ -1,24 +1,25 @@ // Copyright 2017 The go-ethereum Authors -// This file is part of the go-ethereum library. +// This file is part of go-ethereum. // -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // -// The go-ethereum library is distributed in the hope that it will be useful, +// go-ethereum is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. +// GNU General Public License for more details. // -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . package main import ( "encoding/json" "io" + "math/big" "time" "github.com/ethereum/go-ethereum/common" @@ -31,10 +32,16 @@ type JSONLogger struct { cfg *vm.LogConfig } +// NewJSONLogger creates a new EVM tracer that prints execution steps as JSON objects +// into the provided stream. func NewJSONLogger(cfg *vm.LogConfig, writer io.Writer) *JSONLogger { return &JSONLogger{json.NewEncoder(writer), cfg} } +func (l *JSONLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error { + return nil +} + // CaptureState outputs state information on the logger. func (l *JSONLogger) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { log := vm.StructLog{ @@ -56,6 +63,11 @@ func (l *JSONLogger) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cos return l.encoder.Encode(log) } +// CaptureFault outputs state information on the logger. +func (l *JSONLogger) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { + return nil +} + // CaptureEnd is triggered at end of execution. func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { type endLog struct { diff --git a/cmd/evm/main.go b/cmd/evm/main.go index 6c39cf8b88..a59cb1fb84 100644 --- a/cmd/evm/main.go +++ b/cmd/evm/main.go @@ -86,10 +86,6 @@ var ( Name: "create", Usage: "indicates the action should be create rather than call", } - DisableGasMeteringFlag = cli.BoolFlag{ - Name: "nogasmetering", - Usage: "disable gas metering", - } GenesisFlag = cli.StringFlag{ Name: "prestate", Usage: "JSON file with prestate (genesis) config", @@ -128,7 +124,6 @@ func init() { ValueFlag, DumpFlag, InputFlag, - DisableGasMeteringFlag, MemProfileFlag, CPUProfileFlag, StatDumpFlag, diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go index 96de0c76ac..7138a9ddd4 100644 --- a/cmd/evm/runner.go +++ b/cmd/evm/runner.go @@ -21,12 +21,12 @@ import ( "encoding/json" "fmt" "io/ioutil" + "math/big" "os" + goruntime "runtime" "runtime/pprof" "time" - goruntime "runtime" - "github.com/ethereum/go-ethereum/cmd/evm/internal/compiler" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" @@ -76,6 +76,7 @@ func runCmd(ctx *cli.Context) error { logconfig := &vm.LogConfig{ DisableMemory: ctx.GlobalBool(DisableMemoryFlag.Name), DisableStack: ctx.GlobalBool(DisableStackFlag.Name), + Debug: ctx.GlobalBool(DebugFlag.Name), } var ( @@ -83,8 +84,9 @@ func runCmd(ctx *cli.Context) error { debugLogger *vm.StructLogger statedb *state.StateDB chainConfig *params.ChainConfig - sender = common.StringToAddress("sender") - receiver = common.StringToAddress("receiver") + sender = common.BytesToAddress([]byte("sender")) + receiver = common.BytesToAddress([]byte("receiver")) + blockNumber uint64 ) if ctx.GlobalBool(MachineFlag.Name) { tracer = NewJSONLogger(logconfig, os.Stdout) @@ -96,11 +98,13 @@ func runCmd(ctx *cli.Context) error { } if ctx.GlobalString(GenesisFlag.Name) != "" { gen := readGenesis(ctx.GlobalString(GenesisFlag.Name)) - _, statedb = gen.ToBlock() + db := ethdb.NewMemDatabase() + genesis := gen.ToBlock(db) + statedb, _ = state.New(genesis.Root(), state.NewDatabase(db)) chainConfig = gen.Config + blockNumber = gen.Number } else { - db, _ := ethdb.NewMemDatabase() - statedb, _ = state.New(common.Hash{}, state.NewDatabase(db)) + statedb, _ = state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase())) } if ctx.GlobalString(SenderFlag.Name) != "" { sender = common.HexToAddress(ctx.GlobalString(SenderFlag.Name)) @@ -153,15 +157,15 @@ func runCmd(ctx *cli.Context) error { initialGas := ctx.GlobalUint64(GasFlag.Name) runtimeConfig := runtime.Config{ - Origin: sender, - State: statedb, - GasLimit: initialGas, - GasPrice: utils.GlobalBig(ctx, PriceFlag.Name), - Value: utils.GlobalBig(ctx, ValueFlag.Name), + Origin: sender, + State: statedb, + GasLimit: initialGas, + GasPrice: utils.GlobalBig(ctx, PriceFlag.Name), + Value: utils.GlobalBig(ctx, ValueFlag.Name), + BlockNumber: new(big.Int).SetUint64(blockNumber), EVMConfig: vm.Config{ - Tracer: tracer, - Debug: ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name), - DisableGasMetering: ctx.GlobalBool(DisableGasMeteringFlag.Name), + Tracer: tracer, + Debug: ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name), }, } @@ -233,9 +237,7 @@ Gas used: %d `, execTime, mem.HeapObjects, mem.Alloc, mem.TotalAlloc, mem.NumGC, initialGas-leftOverGas) } - if tracer != nil { - tracer.CaptureEnd(ret, initialGas-leftOverGas, execTime, err) - } else { + if tracer == nil { fmt.Printf("0x%x\n", ret) if err != nil { fmt.Printf(" error: %v\n", err) diff --git a/cmd/evm/staterunner.go b/cmd/evm/staterunner.go index 071ea94ad0..6d5ff069f6 100644 --- a/cmd/evm/staterunner.go +++ b/cmd/evm/staterunner.go @@ -38,6 +38,8 @@ var stateTestCommand = cli.Command{ ArgsUsage: "", } +// StatetestResult contains the execution status after running a state test, any +// error that might have occurred and a dump of the final state if requested. type StatetestResult struct { Name string `json:"name"` Pass bool `json:"pass"` diff --git a/cmd/faucet/faucet.go b/cmd/faucet/faucet.go index 5f16f2978e..70fd6d1ab6 100644 --- a/cmd/faucet/faucet.go +++ b/cmd/faucet/faucet.go @@ -18,10 +18,10 @@ package main //go:generate go-bindata -nometadata -o website.go faucet.html +//go:generate gofmt -w -s website.go import ( "bytes" - "compress/zlib" "context" "encoding/json" "errors" @@ -77,9 +77,6 @@ var ( accJSONFlag = flag.String("account.json", "", "Key json file to fund user requests with") accPassFlag = flag.String("account.pass", "", "Decryption password to access faucet funds") - githubUser = flag.String("github.user", "", "GitHub user to authenticate with for Gist access") - githubToken = flag.String("github.token", "", "GitHub personal token to access Gists with") - captchaToken = flag.String("captcha.token", "", "Recaptcha site key to authenticate client side") captchaSecret = flag.String("captcha.secret", "", "Recaptcha secret key to authenticate server side") @@ -223,7 +220,6 @@ func newFaucet(genesis *core.Genesis, port int, enodes []*discv5.Node, network u NoDiscovery: true, DiscoveryV5: true, ListenAddr: fmt.Sprintf(":%d", port), - DiscoveryV5Addr: fmt.Sprintf(":%d", port+1), MaxPeers: 25, BootstrapNodesV5: enodes, }, @@ -474,8 +470,8 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { amount = new(big.Int).Mul(amount, new(big.Int).Exp(big.NewInt(5), big.NewInt(int64(msg.Tier)), nil)) amount = new(big.Int).Div(amount, new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(msg.Tier)), nil)) - tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, big.NewInt(21000), f.price, nil) - signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainId) + tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, 21000, f.price, nil) + signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainID) if err != nil { f.lock.Unlock() if err = sendError(conn, err); err != nil { @@ -534,9 +530,11 @@ func (f *faucet) loop() { } defer sub.Unsubscribe() - for { - select { - case head := <-heads: + // Start a goroutine to update the state from head notifications in the background + update := make(chan *types.Header) + + go func() { + for head := range update { // New chain head arrived, query the current stats and stream to clients var ( balance *big.Int @@ -589,6 +587,17 @@ func (f *faucet) loop() { } } f.lock.RUnlock() + } + }() + // Wait for various events and assing to the appropriate background threads + for { + select { + case head := <-heads: + // New head arrived, send if for state update if there's none running + select { + case update <- head: + default: + } case <-f.update: // Pending requests updated, stream to clients @@ -626,59 +635,6 @@ func sendSuccess(conn *websocket.Conn, msg string) error { return send(conn, map[string]string{"success": msg}, time.Second) } -// authGitHub tries to authenticate a faucet request using GitHub gists, returning -// the username, avatar URL and Ethereum address to fund on success. -func authGitHub(url string) (string, string, common.Address, error) { - // Retrieve the gist from the GitHub Gist APIs - parts := strings.Split(url, "/") - req, _ := http.NewRequest("GET", "https://api.github.com/gists/"+parts[len(parts)-1], nil) - if *githubUser != "" { - req.SetBasicAuth(*githubUser, *githubToken) - } - res, err := http.DefaultClient.Do(req) - if err != nil { - return "", "", common.Address{}, err - } - var gist struct { - Owner struct { - Login string `json:"login"` - } `json:"owner"` - Files map[string]struct { - Content string `json:"content"` - } `json:"files"` - } - err = json.NewDecoder(res.Body).Decode(&gist) - res.Body.Close() - if err != nil { - return "", "", common.Address{}, err - } - if gist.Owner.Login == "" { - return "", "", common.Address{}, errors.New("Anonymous Gists not allowed") - } - // Iterate over all the files and look for Ethereum addresses - var address common.Address - for _, file := range gist.Files { - content := strings.TrimSpace(file.Content) - if len(content) == 2+common.AddressLength*2 { - address = common.HexToAddress(content) - } - } - if address == (common.Address{}) { - return "", "", common.Address{}, errors.New("No Ethereum address found to fund") - } - // Validate the user's existence since the API is unhelpful here - if res, err = http.Head("https://github.com/" + gist.Owner.Login); err != nil { - return "", "", common.Address{}, err - } - res.Body.Close() - - if res.StatusCode != 200 { - return "", "", common.Address{}, errors.New("Invalid user... boom!") - } - // Everything passed validation, return the gathered infos - return gist.Owner.Login + "@github", fmt.Sprintf("https://github.com/%s.png?size=64", gist.Owner.Login), address, nil -} - // authTwitter tries to authenticate a faucet request using Twitter posts, returning // the username, avatar URL and Ethereum address to fund on success. func authTwitter(url string) (string, string, common.Address, error) { @@ -687,8 +643,6 @@ func authTwitter(url string) (string, string, common.Address, error) { if len(parts) < 4 || parts[len(parts)-2] != "status" { return "", "", common.Address{}, errors.New("Invalid Twitter status URL") } - username := parts[len(parts)-3] - // Twitter's API isn't really friendly with direct links. Still, we don't // want to do ask read permissions from users, so just load the public posts and // scrape it for the Ethereum address and profile URL. @@ -698,11 +652,14 @@ func authTwitter(url string) (string, string, common.Address, error) { } defer res.Body.Close() - reader, err := zlib.NewReader(res.Body) - if err != nil { - return "", "", common.Address{}, err + // Resolve the username from the final redirect, no intermediate junk + parts = strings.Split(res.Request.URL.String(), "/") + if len(parts) < 4 || parts[len(parts)-2] != "status" { + return "", "", common.Address{}, errors.New("Invalid Twitter status URL") } - body, err := ioutil.ReadAll(reader) + username := parts[len(parts)-3] + + body, err := ioutil.ReadAll(res.Body) if err != nil { return "", "", common.Address{}, err } diff --git a/cmd/faucet/website.go b/cmd/faucet/website.go index 7936b158eb..fab1d43460 100644 --- a/cmd/faucet/website.go +++ b/cmd/faucet/website.go @@ -1,7 +1,6 @@ -// Code generated by go-bindata. +// Code generated by go-bindata. DO NOT EDIT. // sources: // faucet.html -// DO NOT EDIT! package main @@ -92,8 +91,8 @@ func faucetHtml() (*asset, error) { // 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 { + canonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[canonicalName]; ok { a, err := f() if err != nil { return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) @@ -118,8 +117,8 @@ func MustAsset(name string) []byte { // 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 { + canonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[canonicalName]; ok { a, err := f() if err != nil { return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) @@ -159,8 +158,8 @@ var _bindata = map[string]func() (*asset, error){ func AssetDir(name string) ([]string, error) { node := _bintree if len(name) != 0 { - cannonicalName := strings.Replace(name, "\\", "/", -1) - pathList := strings.Split(cannonicalName, "/") + canonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(canonicalName, "/") for _, p := range pathList { node = node.Children[p] if node == nil { @@ -205,11 +204,7 @@ func RestoreAsset(dir, name string) error { if err != nil { return err } - err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) - if err != nil { - return err - } - return nil + return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) } // RestoreAssets restores an asset under the given directory recursively @@ -230,6 +225,6 @@ func RestoreAssets(dir, name string) error { } func _filePath(dir, name string) string { - cannonicalName := strings.Replace(name, "\\", "/", -1) - return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) + canonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(canonicalName, "/")...)...) } diff --git a/cmd/geth/accountcmd.go b/cmd/geth/accountcmd.go index 0db5c4ce0f..071be85397 100644 --- a/cmd/geth/accountcmd.go +++ b/cmd/geth/accountcmd.go @@ -340,7 +340,7 @@ func importWallet(ctx *cli.Context) error { if len(keyfile) == 0 { utils.Fatalf("keyfile must be given as argument") } - keyJson, err := ioutil.ReadFile(keyfile) + keyJSON, err := ioutil.ReadFile(keyfile) if err != nil { utils.Fatalf("Could not read wallet file: %v", err) } @@ -349,7 +349,7 @@ func importWallet(ctx *cli.Context) error { passphrase := getPassPhrase("", false, 0, utils.MakePasswordList(ctx)) ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) - acct, err := ks.ImportPreSaleKey(keyJson, passphrase) + acct, err := ks.ImportPreSaleKey(keyJSON, passphrase) if err != nil { utils.Fatalf("%v", err) } diff --git a/cmd/geth/bugcmd.go b/cmd/geth/bugcmd.go index ce9dbe6c0a..7e9a8ccc70 100644 --- a/cmd/geth/bugcmd.go +++ b/cmd/geth/bugcmd.go @@ -41,7 +41,7 @@ var bugCommand = cli.Command{ Category: "MISCELLANEOUS COMMANDS", } -const issueUrl = "https://github.com/ethereum/go-ethereum/issues/new" +const issueURL = "https://github.com/ethereum/go-ethereum/issues/new" // reportBug reports a bug by opening a new URL to the go-ethereum GH issue // tracker and setting default values as the issue body. @@ -49,15 +49,17 @@ func reportBug(ctx *cli.Context) error { // execute template and write contents to buff var buff bytes.Buffer - fmt.Fprintln(&buff, header) + fmt.Fprintln(&buff, "#### System information") + fmt.Fprintln(&buff) fmt.Fprintln(&buff, "Version:", params.Version) fmt.Fprintln(&buff, "Go Version:", runtime.Version()) fmt.Fprintln(&buff, "OS:", runtime.GOOS) printOSDetails(&buff) + fmt.Fprintln(&buff, header) // open a new GH issue - if !browser.Open(issueUrl + "?body=" + url.QueryEscape(buff.String())) { - fmt.Printf("Please file a new issue at %s using this template:\n%s", issueUrl, buff.String()) + if !browser.Open(issueURL + "?body=" + url.QueryEscape(buff.String())) { + fmt.Printf("Please file a new issue at %s using this template:\n\n%s", issueURL, buff.String()) } return nil } @@ -97,13 +99,15 @@ func printCmdOut(w io.Writer, prefix, path string, args ...string) { fmt.Fprintf(w, "%s%s\n", prefix, bytes.TrimSpace(out)) } -const header = `Please answer these questions before submitting your issue. Thanks! +const header = ` +#### Expected behaviour -#### What did you do? - -#### What did you expect to see? - -#### What did you see instead? - -#### System details + +#### Actual behaviour + + +#### Steps to reproduce the behaviour + + +#### Backtrace ` diff --git a/cmd/geth/chaincmd.go b/cmd/geth/chaincmd.go index 4a9a7b11b5..d3086921b9 100644 --- a/cmd/geth/chaincmd.go +++ b/cmd/geth/chaincmd.go @@ -67,6 +67,9 @@ It expects the genesis file as argument.`, utils.DataDirFlag, utils.CacheFlag, utils.LightModeFlag, + utils.GCModeFlag, + utils.CacheDatabaseFlag, + utils.CacheGCFlag, }, Category: "BLOCKCHAIN COMMANDS", Description: ` @@ -92,6 +95,34 @@ Requires a first argument of the file to write to. Optional second and third arguments control the first and last block to write. In this mode, the file will be appended if already existing.`, + } + importPreimagesCommand = cli.Command{ + Action: utils.MigrateFlags(importPreimages), + Name: "import-preimages", + Usage: "Import the preimage database from an RLP stream", + ArgsUsage: "", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.CacheFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", + Description: ` + The import-preimages command imports hash preimages from an RLP encoded stream.`, + } + exportPreimagesCommand = cli.Command{ + Action: utils.MigrateFlags(exportPreimages), + Name: "export-preimages", + Usage: "Export the preimage database into an RLP stream", + ArgsUsage: "", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.CacheFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", + Description: ` +The export-preimages command export hash preimages to an RLP encoded stream`, } copydbCommand = cli.Command{ Action: utils.MigrateFlags(copyDb), @@ -202,7 +233,7 @@ func importChain(ctx *cli.Context) error { if len(ctx.Args()) == 1 { if err := utils.ImportChain(chain, ctx.Args().First()); err != nil { - utils.Fatalf("Import error: %v", err) + log.Error("Import error", "err", err) } } else { for _, arg := range ctx.Args() { @@ -211,7 +242,7 @@ func importChain(ctx *cli.Context) error { } } } - + chain.Stop() fmt.Printf("Import done in %v.\n\n", time.Since(start)) // Output pre-compaction stats mostly to see the import trashing @@ -222,6 +253,13 @@ func importChain(ctx *cli.Context) error { utils.Fatalf("Failed to read database stats: %v", err) } fmt.Println(stats) + + ioStats, err := db.LDB().GetProperty("leveldb.iostats") + if err != nil { + utils.Fatalf("Failed to read database iostats: %v", err) + } + fmt.Println(ioStats) + fmt.Printf("Trie cache misses: %d\n", trie.CacheMisses()) fmt.Printf("Trie cache unloads: %d\n\n", trie.CacheUnloads()) @@ -252,6 +290,12 @@ func importChain(ctx *cli.Context) error { } fmt.Println(stats) + ioStats, err = db.LDB().GetProperty("leveldb.iostats") + if err != nil { + utils.Fatalf("Failed to read database iostats: %v", err) + } + fmt.Println(ioStats) + return nil } @@ -283,7 +327,39 @@ func exportChain(ctx *cli.Context) error { if err != nil { utils.Fatalf("Export error: %v\n", err) } - fmt.Printf("Export done in %v", time.Since(start)) + fmt.Printf("Export done in %v\n", time.Since(start)) + return nil +} + +// importPreimages imports preimage data from the specified file. +func importPreimages(ctx *cli.Context) error { + if len(ctx.Args()) < 1 { + utils.Fatalf("This command requires an argument.") + } + stack := makeFullNode(ctx) + diskdb := utils.MakeChainDatabase(ctx, stack).(*ethdb.LDBDatabase) + + start := time.Now() + if err := utils.ImportPreimages(diskdb, ctx.Args().First()); err != nil { + utils.Fatalf("Export error: %v\n", err) + } + fmt.Printf("Export done in %v\n", time.Since(start)) + return nil +} + +// exportPreimages dumps the preimage data to specified json file in streaming way. +func exportPreimages(ctx *cli.Context) error { + if len(ctx.Args()) < 1 { + utils.Fatalf("This command requires an argument.") + } + stack := makeFullNode(ctx) + diskdb := utils.MakeChainDatabase(ctx, stack).(*ethdb.LDBDatabase) + + start := time.Now() + if err := utils.ExportPreimages(diskdb, ctx.Args().First()); err != nil { + utils.Fatalf("Export error: %v\n", err) + } + fmt.Printf("Export done in %v\n", time.Since(start)) return nil } diff --git a/cmd/geth/config.go b/cmd/geth/config.go index 27490c4048..e6bd4d5bef 100644 --- a/cmd/geth/config.go +++ b/cmd/geth/config.go @@ -18,7 +18,6 @@ package main import ( "bufio" - "encoding/hex" "errors" "fmt" "io" @@ -29,12 +28,11 @@ import ( cli "gopkg.in/urfave/cli.v1" "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/contracts/release" "github.com/ethereum/go-ethereum/dashboard" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" - whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" + whisper "github.com/ethereum/go-ethereum/whisper/whisperv6" "github.com/naoina/toml" ) @@ -158,7 +156,7 @@ func makeFullNode(ctx *cli.Context) *node.Node { utils.RegisterEthService(stack, &cfg.Eth) if ctx.GlobalBool(utils.DashboardEnabledFlag.Name) { - utils.RegisterDashboardService(stack, &cfg.Dashboard) + utils.RegisterDashboardService(stack, &cfg.Dashboard, gitCommit) } // Whisper must be explicitly enabled by specifying at least 1 whisper flag or in dev mode shhEnabled := enableWhisper(ctx) @@ -177,21 +175,6 @@ func makeFullNode(ctx *cli.Context) *node.Node { if cfg.Ethstats.URL != "" { utils.RegisterEthStatsService(stack, cfg.Ethstats.URL) } - - // Add the release oracle service so it boots along with node. - if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { - config := release.Config{ - Oracle: relOracle, - Major: uint32(params.VersionMajor), - Minor: uint32(params.VersionMinor), - Patch: uint32(params.VersionPatch), - } - commit, _ := hex.DecodeString(gitCommit) - copy(config.Commit[:], commit) - return release.NewReleaseService(ctx, config) - }); err != nil { - utils.Fatalf("Failed to register the Geth release oracle service: %v", err) - } return stack } diff --git a/cmd/geth/consolecmd.go b/cmd/geth/consolecmd.go index 9d5cc38a1b..2500a969cf 100644 --- a/cmd/geth/consolecmd.go +++ b/cmd/geth/consolecmd.go @@ -22,6 +22,7 @@ import ( "os/signal" "path/filepath" "strings" + "syscall" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/console" @@ -42,7 +43,7 @@ var ( Description: ` The Geth console is an interactive shell for the JavaScript runtime environment which exposes a node admin interface as well as the Ðapp JavaScript API. -See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.`, +See https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console.`, } attachCommand = cli.Command{ @@ -55,7 +56,7 @@ See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.`, Description: ` The Geth console is an interactive shell for the JavaScript runtime environment which exposes a node admin interface as well as the Ðapp JavaScript API. -See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console. +See https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console. This command allows to open a console on a running geth node.`, } @@ -68,7 +69,7 @@ This command allows to open a console on a running geth node.`, Category: "CONSOLE COMMANDS", Description: ` The JavaScript VM exposes a node admin interface as well as the Ðapp -JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console`, +JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console`, } ) @@ -207,7 +208,7 @@ func ephemeralConsole(ctx *cli.Context) error { } // Wait for pending callbacks, but stop for Ctrl-C. abort := make(chan os.Signal, 1) - signal.Notify(abort, os.Interrupt) + signal.Notify(abort, syscall.SIGINT, syscall.SIGTERM) go func() { <-abort diff --git a/cmd/geth/dao_test.go b/cmd/geth/dao_test.go index a8dbc51630..52983ff2af 100644 --- a/cmd/geth/dao_test.go +++ b/cmd/geth/dao_test.go @@ -24,7 +24,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" ) @@ -131,8 +131,8 @@ func testDAOForkBlockNewChain(t *testing.T, test int, genesis string, expectBloc if genesis != "" { genesisHash = daoGenesisHash } - config, err := core.GetChainConfig(db, genesisHash) - if err != nil { + config := rawdb.ReadChainConfig(db, genesisHash) + if config == nil { t.Errorf("test %d: failed to retrieve chain config: %v", test, err) return // we want to return here, the other checks can't make it past this point (nil panic). } diff --git a/cmd/geth/main.go b/cmd/geth/main.go index bdb7fad62a..edf2a557a7 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -19,16 +19,19 @@ package main import ( "fmt" + "math" "os" "runtime" + godebug "runtime/debug" "sort" + "strconv" "strings" "time" + "github.com/elastic/gosigar" "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/console" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/ethclient" @@ -46,8 +49,6 @@ const ( var ( // Git SHA1 commit hash of the release (set via linker flags) gitCommit = "" - // Ethereum address of the Geth release oracle. - relOracle = common.HexToAddress("0xfa7b9770ca4cb04296cac84f37736d4041251cdf") // The app that holds all commands and flags. app = utils.NewApp(gitCommit, "the go-ethereum command line interface") // flags that configure the node @@ -65,7 +66,6 @@ var ( utils.DashboardAddrFlag, utils.DashboardPortFlag, utils.DashboardRefreshFlag, - utils.DashboardAssetsFlag, utils.EthashCacheDirFlag, utils.EthashCachesInMemoryFlag, utils.EthashCachesOnDiskFlag, @@ -85,10 +85,13 @@ var ( utils.FastSyncFlag, utils.LightModeFlag, utils.SyncModeFlag, + utils.GCModeFlag, utils.LightServFlag, utils.LightPeersFlag, utils.LightKDFFlag, utils.CacheFlag, + utils.CacheDatabaseFlag, + utils.CacheGCFlag, utils.TrieCacheGenFlag, utils.ListenPortFlag, utils.MaxPeersFlag, @@ -111,6 +114,7 @@ var ( utils.VMEnableDebugFlag, utils.NetworkIdFlag, utils.RPCCORSDomainFlag, + utils.RPCVirtualHostsFlag, utils.EthStatsURLFlag, utils.MetricsEnabledFlag, utils.FakePoWFlag, @@ -146,12 +150,14 @@ func init() { // Initialize the CLI app and start Geth app.Action = geth app.HideVersion = true // we have a command to print the version - app.Copyright = "Copyright 2013-2017 The go-ethereum Authors" + app.Copyright = "Copyright 2013-2018 The go-ethereum Authors" app.Commands = []cli.Command{ // See chaincmd.go: initCommand, importCommand, exportCommand, + importPreimagesCommand, + exportPreimagesCommand, copydbCommand, removedbCommand, dumpCommand, @@ -186,6 +192,22 @@ func init() { if err := debug.Setup(ctx); err != nil { return err } + // Cap the cache allowance and tune the garbage colelctor + var mem gosigar.Mem + if err := mem.Get(); err == nil { + allowance := int(mem.Total / 1024 / 1024 / 3) + if cache := ctx.GlobalInt(utils.CacheFlag.Name); cache > allowance { + log.Warn("Sanitizing cache to Go's GC limits", "provided", cache, "updated", allowance) + ctx.GlobalSet(utils.CacheFlag.Name, strconv.Itoa(allowance)) + } + } + // Ensure Go's GC ignores the database cache for trigger percentage + cache := ctx.GlobalInt(utils.CacheFlag.Name) + gogc := math.Max(20, math.Min(100, 100/(float64(cache)/1024))) + + log.Debug("Sanitizing Go's GC trigger", "percent", int(gogc)) + godebug.SetGCPercent(int(gogc)) + // Start system runtime metrics collection go metrics.CollectProcessMetrics(3 * time.Second) @@ -221,6 +243,8 @@ func geth(ctx *cli.Context) error { // it unlocks any requested accounts, and starts the RPC/IPC interfaces and the // miner. func startNode(ctx *cli.Context, stack *node.Node) { + debug.Memsize.Add("node", stack) + // Start up the node itself utils.StartNode(stack) @@ -239,7 +263,7 @@ func startNode(ctx *cli.Context, stack *node.Node) { stack.AccountManager().Subscribe(events) go func() { - // Create an chain state reader for self-derivation + // Create a chain state reader for self-derivation rpcClient, err := stack.Attach() if err != nil { utils.Fatalf("Failed to attach to self: %v", err) @@ -278,9 +302,12 @@ func startNode(ctx *cli.Context, stack *node.Node) { // Start auxiliary services if enabled if ctx.GlobalBool(utils.MiningEnabledFlag.Name) || ctx.GlobalBool(utils.DeveloperFlag.Name) { // Mining only makes sense if a full Ethereum node is running + if ctx.GlobalBool(utils.LightModeFlag.Name) || ctx.GlobalString(utils.SyncModeFlag.Name) == "light" { + utils.Fatalf("Light clients do not support mining") + } var ethereum *eth.Ethereum if err := stack.Service(ðereum); err != nil { - utils.Fatalf("ethereum service not running: %v", err) + utils.Fatalf("Ethereum service not running: %v", err) } // Use a reduced number of threads if requested if threads := ctx.GlobalInt(utils.MinerThreadsFlag.Name); threads > 0 { diff --git a/cmd/geth/misccmd.go b/cmd/geth/misccmd.go index 2e68dcda32..aa9b1ee568 100644 --- a/cmd/geth/misccmd.go +++ b/cmd/geth/misccmd.go @@ -134,7 +134,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with geth. If not, see . -`) +along with geth. If not, see .`) return nil } diff --git a/cmd/geth/usage.go b/cmd/geth/usage.go index a834d5b7ae..d934c6b021 100644 --- a/cmd/geth/usage.go +++ b/cmd/geth/usage.go @@ -22,17 +22,18 @@ import ( "io" "sort" + "strings" + "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/internal/debug" "gopkg.in/urfave/cli.v1" - "strings" ) // AppHelpTemplate is the test template for the default, global app help topic. var AppHelpTemplate = `NAME: {{.App.Name}} - {{.App.Usage}} - Copyright 2013-2017 The go-ethereum Authors + Copyright 2013-2018 The go-ethereum Authors USAGE: {{.App.HelpName}} [options]{{if .App.Commands}} command [command options]{{end}} {{if .App.ArgsUsage}}{{.App.ArgsUsage}}{{else}}[arguments...]{{end}} @@ -74,6 +75,7 @@ var AppHelpFlagGroups = []flagGroup{ utils.TestnetFlag, utils.RinkebyFlag, utils.SyncModeFlag, + utils.GCModeFlag, utils.EthStatsURLFlag, utils.IdentityFlag, utils.LightServFlag, @@ -127,6 +129,8 @@ var AppHelpFlagGroups = []flagGroup{ Name: "PERFORMANCE TUNING", Flags: []cli.Flag{ utils.CacheFlag, + utils.CacheDatabaseFlag, + utils.CacheGCFlag, utils.TrieCacheGenFlag, }, }, @@ -152,6 +156,7 @@ var AppHelpFlagGroups = []flagGroup{ utils.IPCDisabledFlag, utils.IPCPathFlag, utils.RPCCORSDomainFlag, + utils.RPCVirtualHostsFlag, utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag, diff --git a/cmd/p2psim/main.go b/cmd/p2psim/main.go index 56b74d135b..0c8ed038d5 100644 --- a/cmd/p2psim/main.go +++ b/cmd/p2psim/main.go @@ -1,3 +1,19 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + // p2psim provides a command-line client for a simulation HTTP API. // // Here is an example of creating a 2 node network with the first node diff --git a/cmd/puppeth/genesis.go b/cmd/puppeth/genesis.go index 5e36f7fce5..5f39a889d1 100644 --- a/cmd/puppeth/genesis.go +++ b/cmd/puppeth/genesis.go @@ -44,7 +44,7 @@ type cppEthereumGenesisSpec struct { MaximumExtraDataSize hexutil.Uint64 `json:"maximumExtraDataSize"` MinGasLimit hexutil.Uint64 `json:"minGasLimit"` MaxGasLimit hexutil.Uint64 `json:"maxGasLimit"` - GasLimitBoundDivisor *hexutil.Big `json:"gasLimitBoundDivisor"` + GasLimitBoundDivisor hexutil.Uint64 `json:"gasLimitBoundDivisor"` MinimumDifficulty *hexutil.Big `json:"minimumDifficulty"` DifficultyBoundDivisor *hexutil.Big `json:"difficultyBoundDivisor"` DurationLimit *hexutil.Big `json:"durationLimit"` @@ -103,15 +103,15 @@ func newCppEthereumGenesisSpec(network string, genesis *core.Genesis) (*cppEther spec.Params.ByzantiumForkBlock = (hexutil.Uint64)(genesis.Config.ByzantiumBlock.Uint64()) spec.Params.ConstantinopleForkBlock = (hexutil.Uint64)(math.MaxUint64) - spec.Params.NetworkID = (hexutil.Uint64)(genesis.Config.ChainId.Uint64()) - spec.Params.ChainID = (hexutil.Uint64)(genesis.Config.ChainId.Uint64()) + spec.Params.NetworkID = (hexutil.Uint64)(genesis.Config.ChainID.Uint64()) + spec.Params.ChainID = (hexutil.Uint64)(genesis.Config.ChainID.Uint64()) spec.Params.MaximumExtraDataSize = (hexutil.Uint64)(params.MaximumExtraDataSize) - spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit.Uint64()) + spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit) spec.Params.MaxGasLimit = (hexutil.Uint64)(math.MaxUint64) spec.Params.MinimumDifficulty = (*hexutil.Big)(params.MinimumDifficulty) spec.Params.DifficultyBoundDivisor = (*hexutil.Big)(params.DifficultyBoundDivisor) - spec.Params.GasLimitBoundDivisor = (*hexutil.Big)(params.GasLimitBoundDivisor) + spec.Params.GasLimitBoundDivisor = (hexutil.Uint64)(params.GasLimitBoundDivisor) spec.Params.DurationLimit = (*hexutil.Big)(params.DurationLimit) spec.Params.BlockReward = (*hexutil.Big)(ethash.FrontierBlockReward) @@ -170,7 +170,6 @@ type parityChainSpec struct { Params struct { MinimumDifficulty *hexutil.Big `json:"minimumDifficulty"` DifficultyBoundDivisor *hexutil.Big `json:"difficultyBoundDivisor"` - GasLimitBoundDivisor *hexutil.Big `json:"gasLimitBoundDivisor"` DurationLimit *hexutil.Big `json:"durationLimit"` BlockReward *hexutil.Big `json:"blockReward"` HomesteadTransition uint64 `json:"homesteadTransition"` @@ -187,7 +186,8 @@ type parityChainSpec struct { Params struct { MaximumExtraDataSize hexutil.Uint64 `json:"maximumExtraDataSize"` - MinGasLimit *hexutil.Big `json:"minGasLimit"` + MinGasLimit hexutil.Uint64 `json:"minGasLimit"` + GasLimitBoundDivisor hexutil.Uint64 `json:"gasLimitBoundDivisor"` NetworkID hexutil.Uint64 `json:"networkID"` MaxCodeSize uint64 `json:"maxCodeSize"` EIP155Transition uint64 `json:"eip155Transition"` @@ -270,7 +270,6 @@ func newParityChainSpec(network string, genesis *core.Genesis, bootnodes []strin } spec.Engine.Ethash.Params.MinimumDifficulty = (*hexutil.Big)(params.MinimumDifficulty) spec.Engine.Ethash.Params.DifficultyBoundDivisor = (*hexutil.Big)(params.DifficultyBoundDivisor) - spec.Engine.Ethash.Params.GasLimitBoundDivisor = (*hexutil.Big)(params.GasLimitBoundDivisor) spec.Engine.Ethash.Params.DurationLimit = (*hexutil.Big)(params.DurationLimit) spec.Engine.Ethash.Params.BlockReward = (*hexutil.Big)(ethash.FrontierBlockReward) spec.Engine.Ethash.Params.HomesteadTransition = genesis.Config.HomesteadBlock.Uint64() @@ -283,8 +282,9 @@ func newParityChainSpec(network string, genesis *core.Genesis, bootnodes []strin spec.Engine.Ethash.Params.EIP649Transition = genesis.Config.ByzantiumBlock.Uint64() spec.Params.MaximumExtraDataSize = (hexutil.Uint64)(params.MaximumExtraDataSize) - spec.Params.MinGasLimit = (*hexutil.Big)(params.MinGasLimit) - spec.Params.NetworkID = (hexutil.Uint64)(genesis.Config.ChainId.Uint64()) + spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit) + spec.Params.GasLimitBoundDivisor = (hexutil.Uint64)(params.GasLimitBoundDivisor) + spec.Params.NetworkID = (hexutil.Uint64)(genesis.Config.ChainID.Uint64()) spec.Params.MaxCodeSize = params.MaxCodeSize spec.Params.EIP155Transition = genesis.Config.EIP155Block.Uint64() spec.Params.EIP98Transition = math.MaxUint64 diff --git a/cmd/puppeth/module_dashboard.go b/cmd/puppeth/module_dashboard.go index 1092c4c88e..a517623381 100644 --- a/cmd/puppeth/module_dashboard.go +++ b/cmd/puppeth/module_dashboard.go @@ -117,7 +117,7 @@ var dashboardContent = `

To run an archive node, download {{.GethGenesis}} and start Geth with: 

geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}
- 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=1024 --syncmode=full{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFullFlat}}
+ 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=1024 --syncmode=full{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFlat}}


You can download Geth from https://geth.ethereum.org/downloads/.

@@ -136,7 +136,7 @@ var dashboardContent = `

To run a full node, download {{.GethGenesis}} and start Geth with: 

geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}
- 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=512{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFullFlat}}
+ 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=512{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFlat}}


You can download Geth from https://geth.ethereum.org/downloads/.

@@ -158,7 +158,7 @@ var dashboardContent = `

To run a light node, download {{.GethGenesis}} and start Geth with: 

geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}
- 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --syncmode=light{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesLightFlat}}
+ 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --syncmode=light{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFlat}}


You can download Geth from https://geth.ethereum.org/downloads/.

@@ -177,7 +177,7 @@ var dashboardContent = `

To run an embedded node, download {{.GethGenesis}} and start Geth with: 

geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}
- 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=16 --ethash.cachesinmem=1 --syncmode=light{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesLightFlat}}
+ 
geth --networkid={{.NetworkID}} --datadir=$HOME/.{{.Network}} --cache=16 --ethash.cachesinmem=1 --syncmode=light{{if .Ethstats}} --ethstats='{{.Ethstats}}'{{end}} --bootnodes={{.BootnodesFlat}}


You can download Geth from https://geth.ethereum.org/downloads/.

@@ -208,7 +208,7 @@ var dashboardContent = ` 
geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}

With your local chain initialized, you can start the Ethereum Wallet: - 

ethereumwallet --rpc $HOME/.{{.Network}}/geth.ipc --node-networkid={{.NetworkID}} --node-datadir=$HOME/.{{.Network}}{{if .Ethstats}} --node-ethstats='{{.Ethstats}}'{{end}} --node-bootnodes={{.BootnodesFullFlat}}
+ 
ethereumwallet --rpc $HOME/.{{.Network}}/geth.ipc --node-networkid={{.NetworkID}} --node-datadir=$HOME/.{{.Network}}{{if .Ethstats}} --node-ethstats='{{.Ethstats}}'{{end}} --node-bootnodes={{.BootnodesFlat}}


You can download the Ethereum Wallet from https://github.com/ethereum/mist/releases.

@@ -229,7 +229,7 @@ var dashboardContent = ` 
geth --datadir=$HOME/.{{.Network}} init {{.GethGenesis}}

With your local chain initialized, you can start Mist: - 

mist --rpc $HOME/.{{.Network}}/geth.ipc --node-networkid={{.NetworkID}} --node-datadir=$HOME/.{{.Network}}{{if .Ethstats}} --node-ethstats='{{.Ethstats}}'{{end}} --node-bootnodes={{.BootnodesFullFlat}}
+ 
mist --rpc $HOME/.{{.Network}}/geth.ipc --node-networkid={{.NetworkID}} --node-datadir=$HOME/.{{.Network}}{{if .Ethstats}} --node-ethstats='{{.Ethstats}}'{{end}} --node-bootnodes={{.BootnodesFlat}}


You can download the Mist browser from https://github.com/ethereum/mist/releases.

@@ -261,7 +261,7 @@ var dashboardContent = `

Inside your Java code you can now import the geth archive and connect to Ethereum: 

import org.ethereum.geth.*;
-Enodes bootnodes = new Enodes();{{range .BootnodesLight}}
+Enodes bootnodes = new Enodes();{{range .Bootnodes}}
 bootnodes.append(new Enode("{{.}}"));{{end}}
 
 NodeConfig config = new NodeConfig();
@@ -294,7 +294,7 @@ node.start();
 
 var error: NSError?
 
-let bootnodes = GethNewEnodesEmpty(){{range .BootnodesLight}}
+let bootnodes = GethNewEnodesEmpty(){{range .Bootnodes}}
 bootnodes?.append(GethNewEnode("{{.}}", &error)){{end}}
 
 let config = GethNewNodeConfig()
@@ -595,44 +595,43 @@ func deployDashboard(client *sshClient, network string, conf *config, config *da
 		statsLogin = ""
 	}
 	indexfile := new(bytes.Buffer)
-	bootCpp := make([]string, len(conf.bootFull))
-	for i, boot := range conf.bootFull {
+	bootCpp := make([]string, len(conf.bootnodes))
+	for i, boot := range conf.bootnodes {
 		bootCpp[i] = "required:" + strings.TrimPrefix(boot, "enode://")
 	}
-	bootHarmony := make([]string, len(conf.bootFull))
-	for i, boot := range conf.bootFull {
+	bootHarmony := make([]string, len(conf.bootnodes))
+	for i, boot := range conf.bootnodes {
 		bootHarmony[i] = fmt.Sprintf("-Dpeer.active.%d.url=%s", i, boot)
 	}
-	bootPython := make([]string, len(conf.bootFull))
-	for i, boot := range conf.bootFull {
+	bootPython := make([]string, len(conf.bootnodes))
+	for i, boot := range conf.bootnodes {
 		bootPython[i] = "'" + boot + "'"
 	}
 	template.Must(template.New("").Parse(dashboardContent)).Execute(indexfile, map[string]interface{}{
-		"Network":            network,
-		"NetworkID":          conf.Genesis.Config.ChainId,
-		"NetworkTitle":       strings.Title(network),
-		"EthstatsPage":       config.ethstats,
-		"ExplorerPage":       config.explorer,
-		"WalletPage":         config.wallet,
-		"FaucetPage":         config.faucet,
-		"GethGenesis":        network + ".json",
-		"BootnodesFull":      conf.bootFull,
-		"BootnodesLight":     conf.bootLight,
-		"BootnodesFullFlat":  strings.Join(conf.bootFull, ","),
-		"BootnodesLightFlat": strings.Join(conf.bootLight, ","),
-		"Ethstats":           statsLogin,
-		"Ethash":             conf.Genesis.Config.Ethash != nil,
-		"CppGenesis":         network + "-cpp.json",
-		"CppBootnodes":       strings.Join(bootCpp, " "),
-		"HarmonyGenesis":     network + "-harmony.json",
-		"HarmonyBootnodes":   strings.Join(bootHarmony, " "),
-		"ParityGenesis":      network + "-parity.json",
-		"PythonGenesis":      network + "-python.json",
-		"PythonBootnodes":    strings.Join(bootPython, ","),
-		"Homestead":          conf.Genesis.Config.HomesteadBlock,
-		"Tangerine":          conf.Genesis.Config.EIP150Block,
-		"Spurious":           conf.Genesis.Config.EIP155Block,
-		"Byzantium":          conf.Genesis.Config.ByzantiumBlock,
+		"Network":          network,
+		"NetworkID":        conf.Genesis.Config.ChainID,
+		"NetworkTitle":     strings.Title(network),
+		"EthstatsPage":     config.ethstats,
+		"ExplorerPage":     config.explorer,
+		"WalletPage":       config.wallet,
+		"FaucetPage":       config.faucet,
+		"GethGenesis":      network + ".json",
+		"Bootnodes":        conf.bootnodes,
+		"BootnodesFlat":    strings.Join(conf.bootnodes, ","),
+		"Ethstats":         statsLogin,
+		"Ethash":           conf.Genesis.Config.Ethash != nil,
+		"CppGenesis":       network + "-cpp.json",
+		"CppBootnodes":     strings.Join(bootCpp, " "),
+		"HarmonyGenesis":   network + "-harmony.json",
+		"HarmonyBootnodes": strings.Join(bootHarmony, " "),
+		"ParityGenesis":    network + "-parity.json",
+		"PythonGenesis":    network + "-python.json",
+		"PythonBootnodes":  strings.Join(bootPython, ","),
+		"Homestead":        conf.Genesis.Config.HomesteadBlock,
+		"Tangerine":        conf.Genesis.Config.EIP150Block,
+		"Spurious":         conf.Genesis.Config.EIP155Block,
+		"Byzantium":        conf.Genesis.Config.ByzantiumBlock,
+		"Constantinople":   conf.Genesis.Config.ConstantinopleBlock,
 	})
 	files[filepath.Join(workdir, "index.html")] = indexfile.Bytes()
 
@@ -651,7 +650,7 @@ func deployDashboard(client *sshClient, network string, conf *config, config *da
 		harmonySpecJSON, _ := conf.Genesis.MarshalJSON()
 		files[filepath.Join(workdir, network+"-harmony.json")] = harmonySpecJSON
 
-		paritySpec, err := newParityChainSpec(network, conf.Genesis, conf.bootFull)
+		paritySpec, err := newParityChainSpec(network, conf.Genesis, conf.bootnodes)
 		if err != nil {
 			return nil, err
 		}
@@ -684,7 +683,7 @@ func deployDashboard(client *sshClient, network string, conf *config, config *da
 	return nil, client.Stream(fmt.Sprintf("cd %s && docker-compose -p %s up -d --build --force-recreate", workdir, network))
 }
 
-// dashboardInfos is returned from an dashboard status check to allow reporting
+// dashboardInfos is returned from a dashboard status check to allow reporting
 // various configuration parameters.
 type dashboardInfos struct {
 	host    string
diff --git a/cmd/puppeth/module_explorer.go b/cmd/puppeth/module_explorer.go
index 427134153b..bb43e5fe4e 100644
--- a/cmd/puppeth/module_explorer.go
+++ b/cmd/puppeth/module_explorer.go
@@ -168,7 +168,7 @@ func (info *explorerInfos) Report() map[string]string {
 	return report
 }
 
-// checkExplorer does a health-check against an block explorer server to verify
+// checkExplorer does a health-check against a block explorer server to verify
 // whether it's running, and if yes, whether it's responsive.
 func checkExplorer(client *sshClient, network string) (*explorerInfos, error) {
 	// Inspect a possible block explorer container on the host
diff --git a/cmd/puppeth/module_faucet.go b/cmd/puppeth/module_faucet.go
index 57b7a2dc07..8365bf47d0 100644
--- a/cmd/puppeth/module_faucet.go
+++ b/cmd/puppeth/module_faucet.go
@@ -30,7 +30,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-// faucetDockerfile is the Dockerfile required to build an faucet container to
+// faucetDockerfile is the Dockerfile required to build a faucet container to
 // grant crypto tokens based on GitHub authentications.
 var faucetDockerfile = `
 FROM ethereum/client-go:alltools-latest
@@ -39,6 +39,8 @@ ADD genesis.json /genesis.json
 ADD account.json /account.json
 ADD account.pass /account.pass
 
+EXPOSE 8080 30303 30303/udp
+
 ENTRYPOINT [ \
 	"faucet", "--genesis", "/genesis.json", "--network", "{{.NetworkID}}", "--bootnodes", "{{.Bootnodes}}", "--ethstats", "{{.Ethstats}}", "--ethport", "{{.EthPort}}",     \
 	"--faucet.name", "{{.FaucetName}}", "--faucet.amount", "{{.FaucetAmount}}", "--faucet.minutes", "{{.FaucetMinutes}}", "--faucet.tiers", "{{.FaucetTiers}}",             \
@@ -91,7 +93,7 @@ func deployFaucet(client *sshClient, network string, bootnodes []string, config
 		"NetworkID":     config.node.network,
 		"Bootnodes":     strings.Join(bootnodes, ","),
 		"Ethstats":      config.node.ethstats,
-		"EthPort":       config.node.portFull,
+		"EthPort":       config.node.port,
 		"CaptchaToken":  config.captchaToken,
 		"CaptchaSecret": config.captchaSecret,
 		"FaucetName":    strings.Title(network),
@@ -108,7 +110,7 @@ func deployFaucet(client *sshClient, network string, bootnodes []string, config
 		"Datadir":       config.node.datadir,
 		"VHost":         config.host,
 		"ApiPort":       config.port,
-		"EthPort":       config.node.portFull,
+		"EthPort":       config.node.port,
 		"EthName":       config.node.ethstats[:strings.Index(config.node.ethstats, ":")],
 		"CaptchaToken":  config.captchaToken,
 		"CaptchaSecret": config.captchaSecret,
@@ -136,7 +138,7 @@ func deployFaucet(client *sshClient, network string, bootnodes []string, config
 	return nil, client.Stream(fmt.Sprintf("cd %s && docker-compose -p %s up -d --build --force-recreate", workdir, network))
 }
 
-// faucetInfos is returned from an faucet status check to allow reporting various
+// faucetInfos is returned from a faucet status check to allow reporting various
 // configuration parameters.
 type faucetInfos struct {
 	node          *nodeInfos
@@ -156,7 +158,7 @@ func (info *faucetInfos) Report() map[string]string {
 	report := map[string]string{
 		"Website address":              info.host,
 		"Website listener port":        strconv.Itoa(info.port),
-		"Ethereum listener port":       strconv.Itoa(info.node.portFull),
+		"Ethereum listener port":       strconv.Itoa(info.node.port),
 		"Funding amount (base tier)":   fmt.Sprintf("%d Ethers", info.amount),
 		"Funding cooldown (base tier)": fmt.Sprintf("%d mins", info.minutes),
 		"Funding tiers":                strconv.Itoa(info.tiers),
@@ -179,7 +181,7 @@ func (info *faucetInfos) Report() map[string]string {
 	return report
 }
 
-// checkFaucet does a health-check against an faucet server to verify whether
+// checkFaucet does a health-check against a faucet server to verify whether
 // it's running, and if yes, gathering a collection of useful infos about it.
 func checkFaucet(client *sshClient, network string) (*faucetInfos, error) {
 	// Inspect a possible faucet container on the host
@@ -226,7 +228,7 @@ func checkFaucet(client *sshClient, network string) (*faucetInfos, error) {
 	return &faucetInfos{
 		node: &nodeInfos{
 			datadir:  infos.volumes["/root/.faucet"],
-			portFull: infos.portmap[infos.envvars["ETH_PORT"]+"/tcp"],
+			port:     infos.portmap[infos.envvars["ETH_PORT"]+"/tcp"],
 			ethstats: infos.envvars["ETH_NAME"],
 			keyJSON:  keyJSON,
 			keyPass:  keyPass,
diff --git a/cmd/puppeth/module_node.go b/cmd/puppeth/module_node.go
index 69cb19c349..1e1767c04b 100644
--- a/cmd/puppeth/module_node.go
+++ b/cmd/puppeth/module_node.go
@@ -42,7 +42,7 @@ ADD genesis.json /genesis.json
 RUN \
   echo 'geth --cache 512 init /genesis.json' > geth.sh && \{{if .Unlock}}
 	echo 'mkdir -p /root/.ethereum/keystore/ && cp /signer.json /root/.ethereum/keystore/' >> geth.sh && \{{end}}
-	echo $'geth --networkid {{.NetworkID}} --cache 512 --port {{.Port}} --maxpeers {{.Peers}} {{.LightFlag}} --ethstats \'{{.Ethstats}}\' {{if .BootV4}}--bootnodesv4 {{.BootV4}}{{end}} {{if .BootV5}}--bootnodesv5 {{.BootV5}}{{end}} {{if .Etherbase}}--etherbase {{.Etherbase}} --mine --minerthreads 1{{end}} {{if .Unlock}}--unlock 0 --password /signer.pass --mine{{end}} --targetgaslimit {{.GasTarget}} --gasprice {{.GasPrice}}' >> geth.sh
+	echo $'geth --networkid {{.NetworkID}} --cache 512 --port {{.Port}} --maxpeers {{.Peers}} {{.LightFlag}} --ethstats \'{{.Ethstats}}\' {{if .Bootnodes}}--bootnodes {{.Bootnodes}}{{end}} {{if .Etherbase}}--etherbase {{.Etherbase}} --mine --minerthreads 1{{end}} {{if .Unlock}}--unlock 0 --password /signer.pass --mine{{end}} --targetgaslimit {{.GasTarget}} --gasprice {{.GasPrice}}' >> geth.sh
 
 ENTRYPOINT ["/bin/sh", "geth.sh"]
 `
@@ -56,15 +56,13 @@ services:
     build: .
     image: {{.Network}}/{{.Type}}
     ports:
-      - "{{.FullPort}}:{{.FullPort}}"
-      - "{{.FullPort}}:{{.FullPort}}/udp"{{if .Light}}
-      - "{{.LightPort}}:{{.LightPort}}/udp"{{end}}
+      - "{{.Port}}:{{.Port}}"
+      - "{{.Port}}:{{.Port}}/udp"
     volumes:
       - {{.Datadir}}:/root/.ethereum{{if .Ethashdir}}
       - {{.Ethashdir}}:/root/.ethash{{end}}
     environment:
-      - FULL_PORT={{.FullPort}}/tcp
-      - LIGHT_PORT={{.LightPort}}/udp
+      - PORT={{.Port}}/tcp
       - TOTAL_PEERS={{.TotalPeers}}
       - LIGHT_PEERS={{.LightPeers}}
       - STATS_NAME={{.Ethstats}}
@@ -82,12 +80,11 @@ services:
 // deployNode deploys a new Ethereum node container to a remote machine via SSH,
 // docker and docker-compose. If an instance with the specified network name
 // already exists there, it will be overwritten!
-func deployNode(client *sshClient, network string, bootv4, bootv5 []string, config *nodeInfos, nocache bool) ([]byte, error) {
+func deployNode(client *sshClient, network string, bootnodes []string, config *nodeInfos, nocache bool) ([]byte, error) {
 	kind := "sealnode"
 	if config.keyJSON == "" && config.etherbase == "" {
 		kind = "bootnode"
-		bootv4 = make([]string, 0)
-		bootv5 = make([]string, 0)
+		bootnodes = make([]string, 0)
 	}
 	// Generate the content to upload to the server
 	workdir := fmt.Sprintf("%d", rand.Int63())
@@ -100,11 +97,10 @@ func deployNode(client *sshClient, network string, bootv4, bootv5 []string, conf
 	dockerfile := new(bytes.Buffer)
 	template.Must(template.New("").Parse(nodeDockerfile)).Execute(dockerfile, map[string]interface{}{
 		"NetworkID": config.network,
-		"Port":      config.portFull,
+		"Port":      config.port,
 		"Peers":     config.peersTotal,
 		"LightFlag": lightFlag,
-		"BootV4":    strings.Join(bootv4, ","),
-		"BootV5":    strings.Join(bootv5, ","),
+		"Bootnodes": strings.Join(bootnodes, ","),
 		"Ethstats":  config.ethstats,
 		"Etherbase": config.etherbase,
 		"GasTarget": uint64(1000000 * config.gasTarget),
@@ -119,10 +115,9 @@ func deployNode(client *sshClient, network string, bootv4, bootv5 []string, conf
 		"Datadir":    config.datadir,
 		"Ethashdir":  config.ethashdir,
 		"Network":    network,
-		"FullPort":   config.portFull,
+		"Port":       config.port,
 		"TotalPeers": config.peersTotal,
 		"Light":      config.peersLight > 0,
-		"LightPort":  config.portFull + 1,
 		"LightPeers": config.peersLight,
 		"Ethstats":   config.ethstats[:strings.Index(config.ethstats, ":")],
 		"Etherbase":  config.etherbase,
@@ -157,10 +152,8 @@ type nodeInfos struct {
 	datadir    string
 	ethashdir  string
 	ethstats   string
-	portFull   int
-	portLight  int
-	enodeFull  string
-	enodeLight string
+	port       int
+	enode      string
 	peersTotal int
 	peersLight int
 	etherbase  string
@@ -174,15 +167,11 @@ type nodeInfos struct {
 // most - but not all - fields for reporting to the user.
 func (info *nodeInfos) Report() map[string]string {
 	report := map[string]string{
-		"Data directory":             info.datadir,
-		"Listener port (full nodes)": strconv.Itoa(info.portFull),
-		"Peer count (all total)":     strconv.Itoa(info.peersTotal),
-		"Peer count (light nodes)":   strconv.Itoa(info.peersLight),
-		"Ethstats username":          info.ethstats,
-	}
-	if info.peersLight > 0 {
-		// Light server enabled
-		report["Listener port (light nodes)"] = strconv.Itoa(info.portLight)
+		"Data directory":           info.datadir,
+		"Listener port":            strconv.Itoa(info.port),
+		"Peer count (all total)":   strconv.Itoa(info.peersTotal),
+		"Peer count (light nodes)": strconv.Itoa(info.peersLight),
+		"Ethstats username":        info.ethstats,
 	}
 	if info.gasTarget > 0 {
 		// Miner or signer node
@@ -209,7 +198,7 @@ func (info *nodeInfos) Report() map[string]string {
 	return report
 }
 
-// checkNode does a health-check against an boot or seal node server to verify
+// checkNode does a health-check against a boot or seal node server to verify
 // whether it's running, and if yes, whether it's responsive.
 func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error) {
 	kind := "bootnode"
@@ -250,7 +239,7 @@ func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error)
 		keyPass = string(bytes.TrimSpace(out))
 	}
 	// Run a sanity check to see if the devp2p is reachable
-	port := infos.portmap[infos.envvars["FULL_PORT"]]
+	port := infos.portmap[infos.envvars["PORT"]]
 	if err = checkPort(client.server, port); err != nil {
 		log.Warn(fmt.Sprintf("%s devp2p port seems unreachable", strings.Title(kind)), "server", client.server, "port", port, "err", err)
 	}
@@ -259,8 +248,7 @@ func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error)
 		genesis:    genesis,
 		datadir:    infos.volumes["/root/.ethereum"],
 		ethashdir:  infos.volumes["/root/.ethash"],
-		portFull:   infos.portmap[infos.envvars["FULL_PORT"]],
-		portLight:  infos.portmap[infos.envvars["LIGHT_PORT"]],
+		port:       port,
 		peersTotal: totalPeers,
 		peersLight: lightPeers,
 		ethstats:   infos.envvars["STATS_NAME"],
@@ -270,9 +258,7 @@ func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error)
 		gasTarget:  gasTarget,
 		gasPrice:   gasPrice,
 	}
-	stats.enodeFull = fmt.Sprintf("enode://%s@%s:%d", id, client.address, stats.portFull)
-	if stats.portLight != 0 {
-		stats.enodeLight = fmt.Sprintf("enode://%s@%s:%d?discport=%d", id, client.address, stats.portFull, stats.portLight)
-	}
+	stats.enode = fmt.Sprintf("enode://%s@%s:%d", id, client.address, stats.port)
+
 	return stats, nil
 }
diff --git a/cmd/puppeth/module_wallet.go b/cmd/puppeth/module_wallet.go
index 67f47c70e8..5e5032bedf 100644
--- a/cmd/puppeth/module_wallet.go
+++ b/cmd/puppeth/module_wallet.go
@@ -37,7 +37,7 @@ ADD genesis.json /genesis.json
 RUN \
   echo 'node server.js &'                     > wallet.sh && \
 	echo 'geth --cache 512 init /genesis.json' >> wallet.sh && \
-	echo $'geth --networkid {{.NetworkID}} --port {{.NodePort}} --bootnodes {{.Bootnodes}} --ethstats \'{{.Ethstats}}\' --cache=512 --rpc --rpcaddr=0.0.0.0 --rpccorsdomain "*"' >> wallet.sh
+	echo $'geth --networkid {{.NetworkID}} --port {{.NodePort}} --bootnodes {{.Bootnodes}} --ethstats \'{{.Ethstats}}\' --cache=512 --rpc --rpcaddr=0.0.0.0 --rpccorsdomain "*" --rpcvhosts "*"' >> wallet.sh
 
 RUN \
 	sed -i 's/PuppethNetworkID/{{.NetworkID}}/g' dist/js/etherwallet-master.js && \
diff --git a/cmd/puppeth/puppeth.go b/cmd/puppeth/puppeth.go
index 26382dac13..f9b8fe4811 100644
--- a/cmd/puppeth/puppeth.go
+++ b/cmd/puppeth/puppeth.go
@@ -20,6 +20,7 @@ package main
 import (
 	"math/rand"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
@@ -34,7 +35,7 @@ func main() {
 	app.Flags = []cli.Flag{
 		cli.StringFlag{
 			Name:  "network",
-			Usage: "name of the network to administer",
+			Usage: "name of the network to administer (no spaces or hyphens, please)",
 		},
 		cli.IntFlag{
 			Name:  "loglevel",
@@ -47,6 +48,10 @@ func main() {
 		log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(c.Int("loglevel")), log.StreamHandler(os.Stdout, log.TerminalFormat(true))))
 		rand.Seed(time.Now().UnixNano())
 
+		network := c.String("network")
+		if strings.Contains(network, " ") || strings.Contains(network, "-") {
+			log.Crit("No spaces or hyphens allowed in network name")
+		}
 		// Start the wizard and relinquish control
 		makeWizard(c.String("network")).run()
 		return nil
diff --git a/cmd/puppeth/wizard.go b/cmd/puppeth/wizard.go
index 2e2b4644cf..b88a61de7d 100644
--- a/cmd/puppeth/wizard.go
+++ b/cmd/puppeth/wizard.go
@@ -40,8 +40,7 @@ import (
 // between sessions.
 type config struct {
 	path      string   // File containing the configuration values
-	bootFull  []string // Bootnodes to always connect to by full nodes
-	bootLight []string // Bootnodes to always connect to by light nodes
+	bootnodes []string // Bootnodes to always connect to by all nodes
 	ethstats  string   // Ethstats settings to cache for node deploys
 
 	Genesis *core.Genesis     `json:"genesis,omitempty"` // Genesis block to cache for node deploys
diff --git a/cmd/puppeth/wizard_explorer.go b/cmd/puppeth/wizard_explorer.go
index 10ef72f788..413511c1c3 100644
--- a/cmd/puppeth/wizard_explorer.go
+++ b/cmd/puppeth/wizard_explorer.go
@@ -55,7 +55,7 @@ func (w *wizard) deployExplorer() {
 	}
 	existed := err == nil
 
-	chainspec, err := newParityChainSpec(w.network, w.conf.Genesis, w.conf.bootFull)
+	chainspec, err := newParityChainSpec(w.network, w.conf.Genesis, w.conf.bootnodes)
 	if err != nil {
 		log.Error("Failed to create chain spec for explorer", "err", err)
 		return
diff --git a/cmd/puppeth/wizard_faucet.go b/cmd/puppeth/wizard_faucet.go
index 191575b168..6f08408947 100644
--- a/cmd/puppeth/wizard_faucet.go
+++ b/cmd/puppeth/wizard_faucet.go
@@ -38,7 +38,7 @@ func (w *wizard) deployFaucet() {
 	infos, err := checkFaucet(client, w.network)
 	if err != nil {
 		infos = &faucetInfos{
-			node:    &nodeInfos{portFull: 30303, peersTotal: 25},
+			node:    &nodeInfos{port: 30303, peersTotal: 25},
 			port:    80,
 			host:    client.server,
 			amount:  1,
@@ -49,7 +49,7 @@ func (w *wizard) deployFaucet() {
 	existed := err == nil
 
 	infos.node.genesis, _ = json.MarshalIndent(w.conf.Genesis, "", "  ")
-	infos.node.network = w.conf.Genesis.Config.ChainId.Int64()
+	infos.node.network = w.conf.Genesis.Config.ChainID.Int64()
 
 	// Figure out which port to listen on
 	fmt.Println()
@@ -113,8 +113,8 @@ func (w *wizard) deployFaucet() {
 	}
 	// Figure out which port to listen on
 	fmt.Println()
-	fmt.Printf("Which TCP/UDP port should the light client listen on? (default = %d)\n", infos.node.portFull)
-	infos.node.portFull = w.readDefaultInt(infos.node.portFull)
+	fmt.Printf("Which TCP/UDP port should the light client listen on? (default = %d)\n", infos.node.port)
+	infos.node.port = w.readDefaultInt(infos.node.port)
 
 	// Set a proper name to report on the stats page
 	fmt.Println()
@@ -168,7 +168,7 @@ func (w *wizard) deployFaucet() {
 		fmt.Printf("Should the faucet be built from scratch (y/n)? (default = no)\n")
 		nocache = w.readDefaultString("n") != "n"
 	}
-	if out, err := deployFaucet(client, w.network, w.conf.bootLight, infos, nocache); err != nil {
+	if out, err := deployFaucet(client, w.network, w.conf.bootnodes, infos, nocache); err != nil {
 		log.Error("Failed to deploy faucet container", "err", err)
 		if len(out) > 0 {
 			fmt.Printf("%s\n", out)
diff --git a/cmd/puppeth/wizard_genesis.go b/cmd/puppeth/wizard_genesis.go
index f255ef6e65..6c4cd571fb 100644
--- a/cmd/puppeth/wizard_genesis.go
+++ b/cmd/puppeth/wizard_genesis.go
@@ -121,7 +121,7 @@ func (w *wizard) makeGenesis() {
 	// Query the user for some custom extras
 	fmt.Println()
 	fmt.Println("Specify your chain/network ID if you want an explicit one (default = random)")
-	genesis.Config.ChainId = new(big.Int).SetUint64(uint64(w.readDefaultInt(rand.Intn(65536))))
+	genesis.Config.ChainID = new(big.Int).SetUint64(uint64(w.readDefaultInt(rand.Intn(65536))))
 
 	// All done, store the genesis and flush to disk
 	log.Info("Configured new genesis block")
diff --git a/cmd/puppeth/wizard_intro.go b/cmd/puppeth/wizard_intro.go
index 84998afc93..60aa0f7ffb 100644
--- a/cmd/puppeth/wizard_intro.go
+++ b/cmd/puppeth/wizard_intro.go
@@ -59,15 +59,16 @@ func (w *wizard) run() {
 	fmt.Println()
 
 	// Make sure we have a good network name to work with	fmt.Println()
+	// Docker accepts hyphens in image names, but doesn't like it for container names
 	if w.network == "" {
-		fmt.Println("Please specify a network name to administer (no spaces, please)")
+		fmt.Println("Please specify a network name to administer (no spaces or hyphens, please)")
 		for {
 			w.network = w.readString()
-			if !strings.Contains(w.network, " ") {
+			if !strings.Contains(w.network, " ") && !strings.Contains(w.network, "-") {
 				fmt.Printf("\nSweet, you can set this via --network=%s next time!\n\n", w.network)
 				break
 			}
-			log.Error("I also like to live dangerously, still no spaces")
+			log.Error("I also like to live dangerously, still no spaces or hyphens")
 		}
 	}
 	log.Info("Administering Ethereum network", "name", w.network)
diff --git a/cmd/puppeth/wizard_netstats.go b/cmd/puppeth/wizard_netstats.go
index e19180bb16..a307c5ee3a 100644
--- a/cmd/puppeth/wizard_netstats.go
+++ b/cmd/puppeth/wizard_netstats.go
@@ -37,8 +37,7 @@ func (w *wizard) networkStats() {
 	}
 	// Clear out some previous configs to refill from current scan
 	w.conf.ethstats = ""
-	w.conf.bootFull = w.conf.bootFull[:0]
-	w.conf.bootLight = w.conf.bootLight[:0]
+	w.conf.bootnodes = w.conf.bootnodes[:0]
 
 	// Iterate over all the specified hosts and check their status
 	var pend sync.WaitGroup
@@ -76,8 +75,7 @@ func (w *wizard) gatherStats(server string, pubkey []byte, client *sshClient) *s
 	var (
 		genesis   string
 		ethstats  string
-		bootFull  []string
-		bootLight []string
+		bootnodes []string
 	)
 	// Ensure a valid SSH connection to the remote server
 	logger := log.New("server", server)
@@ -123,10 +121,7 @@ func (w *wizard) gatherStats(server string, pubkey []byte, client *sshClient) *s
 		stat.services["bootnode"] = infos.Report()
 
 		genesis = string(infos.genesis)
-		bootFull = append(bootFull, infos.enodeFull)
-		if infos.enodeLight != "" {
-			bootLight = append(bootLight, infos.enodeLight)
-		}
+		bootnodes = append(bootnodes, infos.enode)
 	}
 	logger.Debug("Checking for sealnode availability")
 	if infos, err := checkNode(client, w.network, false); err != nil {
@@ -184,8 +179,7 @@ func (w *wizard) gatherStats(server string, pubkey []byte, client *sshClient) *s
 	if ethstats != "" {
 		w.conf.ethstats = ethstats
 	}
-	w.conf.bootFull = append(w.conf.bootFull, bootFull...)
-	w.conf.bootLight = append(w.conf.bootLight, bootLight...)
+	w.conf.bootnodes = append(w.conf.bootnodes, bootnodes...)
 
 	return stat
 }
@@ -282,13 +276,3 @@ func (stats serverStats) render() {
 	}
 	table.Render()
 }
-
-// protips contains a collection of network infos to report pro-tips
-// based on.
-type protips struct {
-	genesis   string
-	network   int64
-	bootFull  []string
-	bootLight []string
-	ethstats  string
-}
diff --git a/cmd/puppeth/wizard_node.go b/cmd/puppeth/wizard_node.go
index 097e2e41aa..9b22da4460 100644
--- a/cmd/puppeth/wizard_node.go
+++ b/cmd/puppeth/wizard_node.go
@@ -48,15 +48,15 @@ func (w *wizard) deployNode(boot bool) {
 	infos, err := checkNode(client, w.network, boot)
 	if err != nil {
 		if boot {
-			infos = &nodeInfos{portFull: 30303, peersTotal: 512, peersLight: 256}
+			infos = &nodeInfos{port: 30303, peersTotal: 512, peersLight: 256}
 		} else {
-			infos = &nodeInfos{portFull: 30303, peersTotal: 50, peersLight: 0, gasTarget: 4.7, gasPrice: 18}
+			infos = &nodeInfos{port: 30303, peersTotal: 50, peersLight: 0, gasTarget: 4.7, gasPrice: 18}
 		}
 	}
 	existed := err == nil
 
 	infos.genesis, _ = json.MarshalIndent(w.conf.Genesis, "", "  ")
-	infos.network = w.conf.Genesis.Config.ChainId.Int64()
+	infos.network = w.conf.Genesis.Config.ChainID.Int64()
 
 	// Figure out where the user wants to store the persistent data
 	fmt.Println()
@@ -79,8 +79,8 @@ func (w *wizard) deployNode(boot bool) {
 	}
 	// Figure out which port to listen on
 	fmt.Println()
-	fmt.Printf("Which TCP/UDP port to listen on? (default = %d)\n", infos.portFull)
-	infos.portFull = w.readDefaultInt(infos.portFull)
+	fmt.Printf("Which TCP/UDP port to listen on? (default = %d)\n", infos.port)
+	infos.port = w.readDefaultInt(infos.port)
 
 	// Figure out how many peers to allow (different based on node type)
 	fmt.Println()
@@ -107,7 +107,7 @@ func (w *wizard) deployNode(boot bool) {
 			// Ethash based miners only need an etherbase to mine against
 			fmt.Println()
 			if infos.etherbase == "" {
-				fmt.Printf("What address should the miner user?\n")
+				fmt.Printf("What address should the miner use?\n")
 				for {
 					if address := w.readAddress(); address != nil {
 						infos.etherbase = address.Hex()
@@ -115,7 +115,7 @@ func (w *wizard) deployNode(boot bool) {
 					}
 				}
 			} else {
-				fmt.Printf("What address should the miner user? (default = %s)\n", infos.etherbase)
+				fmt.Printf("What address should the miner use? (default = %s)\n", infos.etherbase)
 				infos.etherbase = w.readDefaultAddress(common.HexToAddress(infos.etherbase)).Hex()
 			}
 		} else if w.conf.Genesis.Config.Clique != nil {
@@ -163,7 +163,7 @@ func (w *wizard) deployNode(boot bool) {
 		fmt.Printf("Should the node be built from scratch (y/n)? (default = no)\n")
 		nocache = w.readDefaultString("n") != "n"
 	}
-	if out, err := deployNode(client, w.network, w.conf.bootFull, w.conf.bootLight, infos, nocache); err != nil {
+	if out, err := deployNode(client, w.network, w.conf.bootnodes, infos, nocache); err != nil {
 		log.Error("Failed to deploy Ethereum node container", "err", err)
 		if len(out) > 0 {
 			fmt.Printf("%s\n", out)
diff --git a/cmd/puppeth/wizard_wallet.go b/cmd/puppeth/wizard_wallet.go
index 7c3896a17c..7624d11e20 100644
--- a/cmd/puppeth/wizard_wallet.go
+++ b/cmd/puppeth/wizard_wallet.go
@@ -52,7 +52,7 @@ func (w *wizard) deployWallet() {
 	existed := err == nil
 
 	infos.genesis, _ = json.MarshalIndent(w.conf.Genesis, "", "  ")
-	infos.network = w.conf.Genesis.Config.ChainId.Int64()
+	infos.network = w.conf.Genesis.Config.ChainID.Int64()
 
 	// Figure out which port to listen on
 	fmt.Println()
@@ -98,7 +98,7 @@ func (w *wizard) deployWallet() {
 		fmt.Printf("Should the wallet be built from scratch (y/n)? (default = no)\n")
 		nocache = w.readDefaultString("n") != "n"
 	}
-	if out, err := deployWallet(client, w.network, w.conf.bootFull, infos, nocache); err != nil {
+	if out, err := deployWallet(client, w.network, w.conf.bootnodes, infos, nocache); err != nil {
 		log.Error("Failed to deploy wallet container", "err", err)
 		if len(out) > 0 {
 			fmt.Printf("%s\n", out)
diff --git a/cmd/swarm/config.go b/cmd/swarm/config.go
index 33235ca06e..adac772bab 100644
--- a/cmd/swarm/config.go
+++ b/cmd/swarm/config.go
@@ -23,6 +23,7 @@ import (
 	"os"
 	"reflect"
 	"strconv"
+	"strings"
 	"unicode"
 
 	cli "gopkg.in/urfave/cli.v1"
@@ -97,10 +98,15 @@ func buildConfig(ctx *cli.Context) (config *bzzapi.Config, err error) {
 	config = bzzapi.NewDefaultConfig()
 	//first load settings from config file (if provided)
 	config, err = configFileOverride(config, ctx)
+	if err != nil {
+		return nil, err
+	}
 	//override settings provided by environment variables
 	config = envVarsOverride(config)
 	//override settings provided by command line
 	config = cmdLineOverride(config, ctx)
+	//validate configuration parameters
+	err = validateConfig(config)
 
 	return
 }
@@ -194,12 +200,16 @@ func cmdLineOverride(currentConfig *bzzapi.Config, ctx *cli.Context) *bzzapi.Con
 		utils.Fatalf(SWARM_ERR_SWAP_SET_NO_API)
 	}
 
-	//EnsApi can be set to "", so can't check for empty string, as it is allowed!
 	if ctx.GlobalIsSet(EnsAPIFlag.Name) {
-		currentConfig.EnsApi = ctx.GlobalString(EnsAPIFlag.Name)
+		ensAPIs := ctx.GlobalStringSlice(EnsAPIFlag.Name)
+		// preserve backward compatibility to disable ENS with --ens-api=""
+		if len(ensAPIs) == 1 && ensAPIs[0] == "" {
+			ensAPIs = nil
+		}
+		currentConfig.EnsAPIs = ensAPIs
 	}
 
-	if ensaddr := ctx.GlobalString(EnsAddrFlag.Name); ensaddr != "" {
+	if ensaddr := ctx.GlobalString(DeprecatedEnsAddrFlag.Name); ensaddr != "" {
 		currentConfig.EnsRoot = common.HexToAddress(ensaddr)
 	}
 
@@ -266,9 +276,8 @@ func envVarsOverride(currentConfig *bzzapi.Config) (config *bzzapi.Config) {
 		utils.Fatalf(SWARM_ERR_SWAP_SET_NO_API)
 	}
 
-	//EnsApi can be set to "", so can't check for empty string, as it is allowed
-	if ensapi, exists := os.LookupEnv(SWARM_ENV_ENS_API); exists {
-		currentConfig.EnsApi = ensapi
+	if ensapi := os.Getenv(SWARM_ENV_ENS_API); ensapi != "" {
+		currentConfig.EnsAPIs = strings.Split(ensapi, ",")
 	}
 
 	if ensaddr := os.Getenv(SWARM_ENV_ENS_ADDR); ensaddr != "" {
@@ -309,13 +318,50 @@ func checkDeprecated(ctx *cli.Context) {
 	if ctx.GlobalString(DeprecatedEthAPIFlag.Name) != "" {
 		utils.Fatalf("--ethapi is no longer a valid command line flag, please use --ens-api and/or --swap-api.")
 	}
+	// warn if --ens-api flag is set
+	if ctx.GlobalString(DeprecatedEnsAddrFlag.Name) != "" {
+		log.Warn("--ens-addr is no longer a valid command line flag, please use --ens-api to specify contract address.")
+	}
+}
+
+//validate configuration parameters
+func validateConfig(cfg *bzzapi.Config) (err error) {
+	for _, ensAPI := range cfg.EnsAPIs {
+		if ensAPI != "" {
+			if err := validateEnsAPIs(ensAPI); err != nil {
+				return fmt.Errorf("invalid format [tld:][contract-addr@]url for ENS API endpoint configuration %q: %v", ensAPI, err)
+			}
+		}
+	}
+	return nil
+}
+
+//validate EnsAPIs configuration parameter
+func validateEnsAPIs(s string) (err error) {
+	// missing contract address
+	if strings.HasPrefix(s, "@") {
+		return errors.New("missing contract address")
+	}
+	// missing url
+	if strings.HasSuffix(s, "@") {
+		return errors.New("missing url")
+	}
+	// missing tld
+	if strings.HasPrefix(s, ":") {
+		return errors.New("missing tld")
+	}
+	// missing url
+	if strings.HasSuffix(s, ":") {
+		return errors.New("missing url")
+	}
+	return nil
 }
 
 //print a Config as string
 func printConfig(config *bzzapi.Config) string {
 	out, err := tomlSettings.Marshal(&config)
 	if err != nil {
-		return (fmt.Sprintf("Something is not right with the configuration: %v", err))
+		return fmt.Sprintf("Something is not right with the configuration: %v", err)
 	}
 	return string(out)
 }
diff --git a/cmd/swarm/config_test.go b/cmd/swarm/config_test.go
index 166980d148..9bf584f50c 100644
--- a/cmd/swarm/config_test.go
+++ b/cmd/swarm/config_test.go
@@ -457,3 +457,98 @@ func TestCmdLineOverridesFile(t *testing.T) {
 
 	node.Shutdown()
 }
+
+func TestValidateConfig(t *testing.T) {
+	for _, c := range []struct {
+		cfg *api.Config
+		err string
+	}{
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"/data/testnet/geth.ipc",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"http://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"ws://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"test:/data/testnet/geth.ipc",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"test:ws://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"test:314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"eth:314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"eth:314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:12344",
+			}},
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"eth:",
+			}},
+			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"eth:\": missing url",
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"314159265dD8dbb310642f98f50C066173C1259b@",
+			}},
+			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"314159265dD8dbb310642f98f50C066173C1259b@\": missing url",
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				":314159265dD8dbb310642f98f50C066173C1259",
+			}},
+			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \":314159265dD8dbb310642f98f50C066173C1259\": missing tld",
+		},
+		{
+			cfg: &api.Config{EnsAPIs: []string{
+				"@/data/testnet/geth.ipc",
+			}},
+			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"@/data/testnet/geth.ipc\": missing contract address",
+		},
+	} {
+		err := validateConfig(c.cfg)
+		if c.err != "" && err.Error() != c.err {
+			t.Errorf("expected error %q, got %q", c.err, err)
+		}
+		if c.err == "" && err != nil {
+			t.Errorf("unexpected error %q", err)
+		}
+	}
+}
diff --git a/cmd/swarm/main.go b/cmd/swarm/main.go
index 77315a4265..360020b77b 100644
--- a/cmd/swarm/main.go
+++ b/cmd/swarm/main.go
@@ -17,11 +17,9 @@
 package main
 
 import (
-	"context"
 	"crypto/ecdsa"
 	"fmt"
 	"io/ioutil"
-	"math/big"
 	"os"
 	"os/signal"
 	"runtime"
@@ -29,14 +27,12 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"time"
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/console"
-	"github.com/ethereum/go-ethereum/contracts/ens"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/internal/debug"
@@ -45,9 +41,9 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/swarm"
 	bzzapi "github.com/ethereum/go-ethereum/swarm/api"
+	swarmmetrics "github.com/ethereum/go-ethereum/swarm/metrics"
 
 	"gopkg.in/urfave/cli.v1"
 )
@@ -110,16 +106,11 @@ var (
 		Usage:  "Swarm Syncing enabled (default true)",
 		EnvVar: SWARM_ENV_SYNC_ENABLE,
 	}
-	EnsAPIFlag = cli.StringFlag{
+	EnsAPIFlag = cli.StringSliceFlag{
 		Name:   "ens-api",
-		Usage:  "URL of the Ethereum API provider to use for ENS record lookups",
+		Usage:  "ENS API endpoint for a TLD and with contract address, can be repeated, format [tld:][contract-addr@]url",
 		EnvVar: SWARM_ENV_ENS_API,
 	}
-	EnsAddrFlag = cli.StringFlag{
-		Name:   "ens-addr",
-		Usage:  "ENS contract address (default is detected as testnet or mainnet using --ens-api)",
-		EnvVar: SWARM_ENV_ENS_ADDR,
-	}
 	SwarmApiFlag = cli.StringFlag{
 		Name:  "bzzapi",
 		Usage: "Swarm HTTP endpoint",
@@ -156,6 +147,10 @@ var (
 		Name:  "ethapi",
 		Usage: "DEPRECATED: please use --ens-api and --swap-api",
 	}
+	DeprecatedEnsAddrFlag = cli.StringFlag{
+		Name:  "ens-addr",
+		Usage: "DEPRECATED: ENS contract address, please use --ens-api with contract address according to its format",
+	}
 )
 
 //declare a few constant error messages, useful for later error check comparisons in test
@@ -343,7 +338,6 @@ DEPRECATED: use 'swarm db clean'.
 		// bzzd-specific flags
 		CorsStringFlag,
 		EnsAPIFlag,
-		EnsAddrFlag,
 		SwarmTomlConfigPathFlag,
 		SwarmConfigPathFlag,
 		SwarmSwapEnabledFlag,
@@ -363,11 +357,17 @@ DEPRECATED: use 'swarm db clean'.
 		SwarmUploadMimeType,
 		//deprecated flags
 		DeprecatedEthAPIFlag,
+		DeprecatedEnsAddrFlag,
 	}
 	app.Flags = append(app.Flags, debug.Flags...)
+	app.Flags = append(app.Flags, swarmmetrics.Flags...)
 	app.Before = func(ctx *cli.Context) error {
 		runtime.GOMAXPROCS(runtime.NumCPU())
-		return debug.Setup(ctx)
+		if err := debug.Setup(ctx); err != nil {
+			return err
+		}
+		swarmmetrics.Setup(ctx)
+		return nil
 	}
 	app.After = func(ctx *cli.Context) error {
 		debug.Exit()
@@ -448,38 +448,6 @@ func bzzd(ctx *cli.Context) error {
 	return nil
 }
 
-// detectEnsAddr determines the ENS contract address by getting both the
-// version and genesis hash using the client and matching them to either
-// mainnet or testnet addresses
-func detectEnsAddr(client *rpc.Client) (common.Address, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	var version string
-	if err := client.CallContext(ctx, &version, "net_version"); err != nil {
-		return common.Address{}, err
-	}
-
-	block, err := ethclient.NewClient(client).BlockByNumber(ctx, big.NewInt(0))
-	if err != nil {
-		return common.Address{}, err
-	}
-
-	switch {
-
-	case version == "1" && block.Hash() == params.MainnetGenesisHash:
-		log.Info("using Mainnet ENS contract address", "addr", ens.MainNetAddress)
-		return ens.MainNetAddress, nil
-
-	case version == "3" && block.Hash() == params.TestnetGenesisHash:
-		log.Info("using Testnet ENS contract address", "addr", ens.TestNetAddress)
-		return ens.TestNetAddress, nil
-
-	default:
-		return common.Address{}, fmt.Errorf("unknown version and genesis hash: %s %s", version, block.Hash())
-	}
-}
-
 func registerBzzService(bzzconfig *bzzapi.Config, ctx *cli.Context, stack *node.Node) {
 
 	//define the swarm service boot function
@@ -494,27 +462,7 @@ func registerBzzService(bzzconfig *bzzapi.Config, ctx *cli.Context, stack *node.
 			}
 		}
 
-		var ensClient *ethclient.Client
-		if bzzconfig.EnsApi != "" {
-			log.Info("connecting to ENS API", "url", bzzconfig.EnsApi)
-			client, err := rpc.Dial(bzzconfig.EnsApi)
-			if err != nil {
-				return nil, fmt.Errorf("error connecting to ENS API %s: %s", bzzconfig.EnsApi, err)
-			}
-			ensClient = ethclient.NewClient(client)
-
-			//no ENS root address set yet
-			if bzzconfig.EnsRoot == (common.Address{}) {
-				ensAddr, err := detectEnsAddr(client)
-				if err == nil {
-					bzzconfig.EnsRoot = ensAddr
-				} else {
-					log.Warn(fmt.Sprintf("could not determine ENS contract address, using default %s", bzzconfig.EnsRoot), "err", err)
-				}
-			}
-		}
-
-		return swarm.NewSwarm(ctx, swapClient, ensClient, bzzconfig, bzzconfig.SwapEnabled, bzzconfig.SyncEnabled, bzzconfig.Cors)
+		return swarm.NewSwarm(ctx, swapClient, bzzconfig)
 	}
 	//register within the ethereum node
 	if err := stack.Register(boot); err != nil {
diff --git a/cmd/swarm/manifest.go b/cmd/swarm/manifest.go
index aa276e0f9b..41a69a5d05 100644
--- a/cmd/swarm/manifest.go
+++ b/cmd/swarm/manifest.go
@@ -35,7 +35,7 @@ const bzzManifestJSON = "application/bzz-manifest+json"
 func add(ctx *cli.Context) {
 	args := ctx.Args()
 	if len(args) < 3 {
-		utils.Fatalf("Need atleast three arguments    []")
+		utils.Fatalf("Need at least three arguments    []")
 	}
 
 	var (
@@ -69,7 +69,7 @@ func update(ctx *cli.Context) {
 
 	args := ctx.Args()
 	if len(args) < 3 {
-		utils.Fatalf("Need atleast three arguments   ")
+		utils.Fatalf("Need at least three arguments   ")
 	}
 
 	var (
@@ -101,7 +101,7 @@ func update(ctx *cli.Context) {
 func remove(ctx *cli.Context) {
 	args := ctx.Args()
 	if len(args) < 2 {
-		utils.Fatalf("Need atleast two arguments  ")
+		utils.Fatalf("Need at least two arguments  ")
 	}
 
 	var (
diff --git a/cmd/swarm/run_test.go b/cmd/swarm/run_test.go
index ed15028685..594cfa55cb 100644
--- a/cmd/swarm/run_test.go
+++ b/cmd/swarm/run_test.go
@@ -1,4 +1,4 @@
-// Copyright 2016 The go-ethereum Authors
+// Copyright 2017 The go-ethereum Authors
 // This file is part of go-ethereum.
 //
 // go-ethereum is free software: you can redistribute it and/or modify
diff --git a/cmd/swarm/upload_test.go b/cmd/swarm/upload_test.go
index 5656186e1c..df7fc216af 100644
--- a/cmd/swarm/upload_test.go
+++ b/cmd/swarm/upload_test.go
@@ -1,4 +1,4 @@
-// Copyright 2016 The go-ethereum Authors
+// Copyright 2017 The go-ethereum Authors
 // This file is part of go-ethereum.
 //
 // go-ethereum is free software: you can redistribute it and/or modify
diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
index 23b10c2d74..58d72f32ba 100644
--- a/cmd/utils/cmd.go
+++ b/cmd/utils/cmd.go
@@ -25,9 +25,14 @@ import (
 	"os/signal"
 	"runtime"
 	"strings"
+	"syscall"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/internal/debug"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -64,7 +69,7 @@ func StartNode(stack *node.Node) {
 	}
 	go func() {
 		sigc := make(chan os.Signal, 1)
-		signal.Notify(sigc, os.Interrupt)
+		signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)
 		defer signal.Stop(sigc)
 		<-sigc
 		log.Info("Got interrupt, shutting down...")
@@ -85,7 +90,7 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 	// If a signal is received, the import will stop at the next batch.
 	interrupt := make(chan os.Signal, 1)
 	stop := make(chan struct{})
-	signal.Notify(interrupt, os.Interrupt)
+	signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
 	defer signal.Stop(interrupt)
 	defer close(interrupt)
 	go func() {
@@ -104,6 +109,8 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 	}
 
 	log.Info("Importing blockchain", "file", fn)
+
+	// Open the file handle and potentially unwrap the gzip stream
 	fh, err := os.Open(fn)
 	if err != nil {
 		return err
@@ -116,7 +123,6 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 			return err
 		}
 	}
-
 	stream := rlp.NewStream(reader, 0)
 
 	// Run actual the import.
@@ -150,29 +156,42 @@ func ImportChain(chain *core.BlockChain, fn string) error {
 		if checkInterrupt() {
 			return fmt.Errorf("interrupted")
 		}
-		if hasAllBlocks(chain, blocks[:i]) {
+		missing := missingBlocks(chain, blocks[:i])
+		if len(missing) == 0 {
 			log.Info("Skipping batch as all blocks present", "batch", batch, "first", blocks[0].Hash(), "last", blocks[i-1].Hash())
 			continue
 		}
-
-		if _, err := chain.InsertChain(blocks[:i]); err != nil {
+		if _, err := chain.InsertChain(missing); err != nil {
 			return fmt.Errorf("invalid block %d: %v", n, err)
 		}
 	}
 	return nil
 }
 
-func hasAllBlocks(chain *core.BlockChain, bs []*types.Block) bool {
-	for _, b := range bs {
-		if !chain.HasBlock(b.Hash(), b.NumberU64()) {
-			return false
+func missingBlocks(chain *core.BlockChain, blocks []*types.Block) []*types.Block {
+	head := chain.CurrentBlock()
+	for i, block := range blocks {
+		// If we're behind the chain head, only check block, state is available at head
+		if head.NumberU64() > block.NumberU64() {
+			if !chain.HasBlock(block.Hash(), block.NumberU64()) {
+				return blocks[i:]
+			}
+			continue
+		}
+		// If we're above the chain head, state availability is a must
+		if !chain.HasBlockAndState(block.Hash(), block.NumberU64()) {
+			return blocks[i:]
 		}
 	}
-	return true
+	return nil
 }
 
+// ExportChain exports a blockchain into the specified file, truncating any data
+// already present in the file.
 func ExportChain(blockchain *core.BlockChain, fn string) error {
 	log.Info("Exporting blockchain", "file", fn)
+
+	// Open the file handle and potentially wrap with a gzip stream
 	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
 	if err != nil {
 		return err
@@ -184,7 +203,7 @@ func ExportChain(blockchain *core.BlockChain, fn string) error {
 		writer = gzip.NewWriter(writer)
 		defer writer.(*gzip.Writer).Close()
 	}
-
+	// Iterate over the blocks and export them
 	if err := blockchain.Export(writer); err != nil {
 		return err
 	}
@@ -193,9 +212,12 @@ func ExportChain(blockchain *core.BlockChain, fn string) error {
 	return nil
 }
 
+// ExportAppendChain exports a blockchain into the specified file, appending to
+// the file if data already exists in it.
 func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, last uint64) error {
 	log.Info("Exporting blockchain", "file", fn)
-	// TODO verify mode perms
+
+	// Open the file handle and potentially wrap with a gzip stream
 	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModePerm)
 	if err != nil {
 		return err
@@ -207,10 +229,84 @@ func ExportAppendChain(blockchain *core.BlockChain, fn string, first uint64, las
 		writer = gzip.NewWriter(writer)
 		defer writer.(*gzip.Writer).Close()
 	}
-
+	// Iterate over the blocks and export them
 	if err := blockchain.ExportN(writer, first, last); err != nil {
 		return err
 	}
 	log.Info("Exported blockchain to", "file", fn)
 	return nil
 }
+
+// ImportPreimages imports a batch of exported hash preimages into the database.
+func ImportPreimages(db *ethdb.LDBDatabase, fn string) error {
+	log.Info("Importing preimages", "file", fn)
+
+	// Open the file handle and potentially unwrap the gzip stream
+	fh, err := os.Open(fn)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+
+	var reader io.Reader = fh
+	if strings.HasSuffix(fn, ".gz") {
+		if reader, err = gzip.NewReader(reader); err != nil {
+			return err
+		}
+	}
+	stream := rlp.NewStream(reader, 0)
+
+	// Import the preimages in batches to prevent disk trashing
+	preimages := make(map[common.Hash][]byte)
+
+	for {
+		// Read the next entry and ensure it's not junk
+		var blob []byte
+
+		if err := stream.Decode(&blob); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		// Accumulate the preimages and flush when enough ws gathered
+		preimages[crypto.Keccak256Hash(blob)] = common.CopyBytes(blob)
+		if len(preimages) > 1024 {
+			rawdb.WritePreimages(db, 0, preimages)
+			preimages = make(map[common.Hash][]byte)
+		}
+	}
+	// Flush the last batch preimage data
+	if len(preimages) > 0 {
+		rawdb.WritePreimages(db, 0, preimages)
+	}
+	return nil
+}
+
+// ExportPreimages exports all known hash preimages into the specified file,
+// truncating any data already present in the file.
+func ExportPreimages(db *ethdb.LDBDatabase, fn string) error {
+	log.Info("Exporting preimages", "file", fn)
+
+	// Open the file handle and potentially wrap with a gzip stream
+	fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	defer fh.Close()
+
+	var writer io.Writer = fh
+	if strings.HasSuffix(fn, ".gz") {
+		writer = gzip.NewWriter(writer)
+		defer writer.(*gzip.Writer).Close()
+	}
+	// Iterate over the preimages and export them
+	it := db.NewIteratorWithPrefix([]byte("secure-key-"))
+	for it.Next() {
+		if err := rlp.Encode(writer, it.Value()); err != nil {
+			return err
+		}
+	}
+	log.Info("Exported preimages", "file", fn)
+	return nil
+}
diff --git a/cmd/utils/fdlimit_test.go b/cmd/utils/fdlimit_test.go
deleted file mode 100644
index 0a950a6c9d..0000000000
--- a/cmd/utils/fdlimit_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see .
-
-package utils
-
-import "testing"
-
-// TestFileDescriptorLimits simply tests whether the file descriptor allowance
-// per this process can be retrieved.
-func TestFileDescriptorLimits(t *testing.T) {
-	target := 4096
-
-	if limit, err := getFdLimit(); err != nil || limit <= 0 {
-		t.Fatalf("failed to retrieve file descriptor limit (%d): %v", limit, err)
-	}
-	if err := raiseFdLimit(uint64(target)); err != nil {
-		t.Fatalf("failed to raise file allowance")
-	}
-	if limit, err := getFdLimit(); err != nil || limit < target {
-		t.Fatalf("failed to retrieve raised descriptor limit (have %v, want %v): %v", limit, target, err)
-	}
-}
diff --git a/cmd/utils/fdlimit_unix.go b/cmd/utils/fdlimit_unix.go
deleted file mode 100644
index 08e153bbd4..0000000000
--- a/cmd/utils/fdlimit_unix.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see .
-
-// +build linux darwin netbsd openbsd solaris
-
-package utils
-
-import "syscall"
-
-// raiseFdLimit tries to maximize the file descriptor allowance of this process
-// to the maximum hard-limit allowed by the OS.
-func raiseFdLimit(max uint64) error {
-	// Get the current limit
-	var limit syscall.Rlimit
-	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
-		return err
-	}
-	// Try to update the limit to the max allowance
-	limit.Cur = limit.Max
-	if limit.Cur > max {
-		limit.Cur = max
-	}
-	if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
-		return err
-	}
-	return nil
-}
-
-// getFdLimit retrieves the number of file descriptors allowed to be opened by this
-// process.
-func getFdLimit() (int, error) {
-	var limit syscall.Rlimit
-	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
-		return 0, err
-	}
-	return int(limit.Cur), nil
-}
diff --git a/cmd/utils/fdlimit_windows.go b/cmd/utils/fdlimit_windows.go
deleted file mode 100644
index 53aad3d7a5..0000000000
--- a/cmd/utils/fdlimit_windows.go
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see .
-
-package utils
-
-import "errors"
-
-// raiseFdLimit tries to maximize the file descriptor allowance of this process
-// to the maximum hard-limit allowed by the OS.
-func raiseFdLimit(max uint64) error {
-	// This method is NOP by design:
-	//  * Linux/Darwin counterparts need to manually increase per process limits
-	//  * On Windows Go uses the CreateFile API, which is limited to 16K files, non
-	//    changeable from within a running process
-	// This way we can always "request" raising the limits, which will either have
-	// or not have effect based on the platform we're running on.
-	if max > 16384 {
-		return errors.New("file descriptor limit (16384) reached")
-	}
-	return nil
-}
-
-// getFdLimit retrieves the number of file descriptors allowed to be opened by this
-// process.
-func getFdLimit() (int, error) {
-	// Please see raiseFdLimit for the reason why we use hard coded 16K as the limit
-	return 16384, nil
-}
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index 30edf199c9..41a1ac35fe 100644
--- a/cmd/utils/flags.go
+++ b/cmd/utils/flags.go
@@ -31,6 +31,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/accounts/keystore"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/fdlimit"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/clique"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
@@ -54,7 +55,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/nat"
 	"github.com/ethereum/go-ethereum/p2p/netutil"
 	"github.com/ethereum/go-ethereum/params"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv5"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 	"gopkg.in/urfave/cli.v1"
 )
 
@@ -63,7 +64,7 @@ var (
 {{if .cmd.Description}}{{.cmd.Description}}
 {{end}}{{if .cmd.Subcommands}}
 SUBCOMMANDS:
-	{{range .cmd.Subcommands}}{{.cmd.Name}}{{with .cmd.ShortName}}, {{.cmd}}{{end}}{{ "\t" }}{{.cmd.Usage}}
+	{{range .cmd.Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}}
 	{{end}}{{end}}{{if .categorizedFlags}}
 {{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS:
 {{range $categorized.Flags}}{{"\t"}}{{.}}
@@ -96,7 +97,7 @@ func NewApp(gitCommit, usage string) *cli.App {
 	//app.Authors = nil
 	app.Email = ""
 	app.Version = params.Version
-	if gitCommit != "" {
+	if len(gitCommit) >= 8 {
 		app.Version += "-" + gitCommit[:8]
 	}
 	app.Usage = usage
@@ -157,11 +158,11 @@ var (
 	}
 	FastSyncFlag = cli.BoolFlag{
 		Name:  "fast",
-		Usage: "Enable fast syncing through state downloads",
+		Usage: "Enable fast syncing through state downloads (replaced by --syncmode)",
 	}
 	LightModeFlag = cli.BoolFlag{
 		Name:  "light",
-		Usage: "Enable light client mode",
+		Usage: "Enable light client mode (replaced by --syncmode)",
 	}
 	defaultSyncMode = eth.DefaultConfig.SyncMode
 	SyncModeFlag    = TextMarshalerFlag{
@@ -169,7 +170,11 @@ var (
 		Usage: `Blockchain sync mode ("fast", "full", or "light")`,
 		Value: &defaultSyncMode,
 	}
-
+	GCModeFlag = cli.StringFlag{
+		Name:  "gcmode",
+		Usage: `Blockchain garbage collection mode ("full", "archive")`,
+		Value: "full",
+	}
 	LightServFlag = cli.IntFlag{
 		Name:  "lightserv",
 		Usage: "Maximum percentage of time allowed for serving LES requests (0-90)",
@@ -178,7 +183,7 @@ var (
 	LightPeersFlag = cli.IntFlag{
 		Name:  "lightpeers",
 		Usage: "Maximum number of LES client peers",
-		Value: 20,
+		Value: eth.DefaultConfig.LightPeers,
 	}
 	LightKDFFlag = cli.BoolFlag{
 		Name:  "lightkdf",
@@ -204,11 +209,6 @@ var (
 		Usage: "Dashboard metrics collection refresh rate",
 		Value: dashboard.DefaultConfig.Refresh,
 	}
-	DashboardAssetsFlag = cli.StringFlag{
-		Name:  "dashboard.assets",
-		Usage: "Developer flag to serve the dashboard from the local file system",
-		Value: dashboard.DefaultConfig.Assets,
-	}
 	// Ethash settings
 	EthashCacheDirFlag = DirectoryFlag{
 		Name:  "ethash.cachedir",
@@ -292,8 +292,18 @@ var (
 	// Performance tuning settings
 	CacheFlag = cli.IntFlag{
 		Name:  "cache",
-		Usage: "Megabytes of memory allocated to internal caching (min 16MB / database forced)",
-		Value: 128,
+		Usage: "Megabytes of memory allocated to internal caching",
+		Value: 1024,
+	}
+	CacheDatabaseFlag = cli.IntFlag{
+		Name:  "cache.database",
+		Usage: "Percentage of cache memory allowance to use for database io",
+		Value: 75,
+	}
+	CacheGCFlag = cli.IntFlag{
+		Name:  "cache.gc",
+		Usage: "Percentage of cache memory allowance to use for trie pruning",
+		Value: 25,
 	}
 	TrieCacheGenFlag = cli.IntFlag{
 		Name:  "trie-cache-gens",
@@ -313,7 +323,7 @@ var (
 	TargetGasLimitFlag = cli.Uint64Flag{
 		Name:  "targetgaslimit",
 		Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine",
-		Value: params.GenesisGasLimit.Uint64(),
+		Value: params.GenesisGasLimit,
 	}
 	EtherbaseFlag = cli.StringFlag{
 		Name:  "etherbase",
@@ -382,6 +392,11 @@ var (
 		Usage: "Comma separated list of domains from which to accept cross origin requests (browser enforced)",
 		Value: "",
 	}
+	RPCVirtualHostsFlag = cli.StringFlag{
+		Name:  "rpcvhosts",
+		Usage: "Comma separated list of virtual hostnames from which to accept requests (server enforced). Accepts '*' wildcard.",
+		Value: strings.Join(node.DefaultConfig.HTTPVirtualHosts, ","),
+	}
 	RPCApiFlag = cli.StringFlag{
 		Name:  "rpcapi",
 		Usage: "API's offered over the HTTP-RPC interface",
@@ -611,7 +626,7 @@ func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) {
 			urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",")
 		}
 	case ctx.GlobalBool(RinkebyFlag.Name):
-		urls = params.RinkebyV5Bootnodes
+		urls = params.RinkebyBootnodes
 	case cfg.BootstrapNodesV5 != nil:
 		return // already set, don't apply defaults.
 	}
@@ -635,14 +650,6 @@ func setListenAddress(ctx *cli.Context, cfg *p2p.Config) {
 	}
 }
 
-// setDiscoveryV5Address creates a UDP listening address string from set command
-// line flags for the V5 discovery protocol.
-func setDiscoveryV5Address(ctx *cli.Context, cfg *p2p.Config) {
-	if ctx.GlobalIsSet(ListenPortFlag.Name) {
-		cfg.DiscoveryV5Addr = fmt.Sprintf(":%d", ctx.GlobalInt(ListenPortFlag.Name)+1)
-	}
-}
-
 // setNAT creates a port mapper from command line flags.
 func setNAT(ctx *cli.Context, cfg *p2p.Config) {
 	if ctx.GlobalIsSet(NATFlag.Name) {
@@ -683,6 +690,9 @@ func setHTTP(ctx *cli.Context, cfg *node.Config) {
 	if ctx.GlobalIsSet(RPCApiFlag.Name) {
 		cfg.HTTPModules = splitAndTrim(ctx.GlobalString(RPCApiFlag.Name))
 	}
+	if ctx.GlobalIsSet(RPCVirtualHostsFlag.Name) {
+		cfg.HTTPVirtualHosts = splitAndTrim(ctx.GlobalString(RPCVirtualHostsFlag.Name))
+	}
 }
 
 // setWS creates the WebSocket RPC listener interface string from the set
@@ -721,13 +731,15 @@ func setIPC(ctx *cli.Context, cfg *node.Config) {
 // makeDatabaseHandles raises out the number of allowed file handles per process
 // for Geth and returns half of the allowance to assign to the database.
 func makeDatabaseHandles() int {
-	if err := raiseFdLimit(2048); err != nil {
-		Fatalf("Failed to raise file descriptor allowance: %v", err)
-	}
-	limit, err := getFdLimit()
+	limit, err := fdlimit.Current()
 	if err != nil {
 		Fatalf("Failed to retrieve file descriptor allowance: %v", err)
 	}
+	if limit < 2048 {
+		if err := fdlimit.Raise(2048); err != nil {
+			Fatalf("Failed to raise file descriptor allowance: %v", err)
+		}
+	}
 	if limit > 2048 { // cap database file descriptors even if more is available
 		limit = 2048
 	}
@@ -793,24 +805,46 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 	setNodeKey(ctx, cfg)
 	setNAT(ctx, cfg)
 	setListenAddress(ctx, cfg)
-	setDiscoveryV5Address(ctx, cfg)
 	setBootstrapNodes(ctx, cfg)
 	setBootstrapNodesV5(ctx, cfg)
 
+	lightClient := ctx.GlobalBool(LightModeFlag.Name) || ctx.GlobalString(SyncModeFlag.Name) == "light"
+	lightServer := ctx.GlobalInt(LightServFlag.Name) != 0
+	lightPeers := ctx.GlobalInt(LightPeersFlag.Name)
+
 	if ctx.GlobalIsSet(MaxPeersFlag.Name) {
 		cfg.MaxPeers = ctx.GlobalInt(MaxPeersFlag.Name)
+		if lightServer && !ctx.GlobalIsSet(LightPeersFlag.Name) {
+			cfg.MaxPeers += lightPeers
+		}
+	} else {
+		if lightServer {
+			cfg.MaxPeers += lightPeers
+		}
+		if lightClient && ctx.GlobalIsSet(LightPeersFlag.Name) && cfg.MaxPeers < lightPeers {
+			cfg.MaxPeers = lightPeers
+		}
 	}
+	if !(lightClient || lightServer) {
+		lightPeers = 0
+	}
+	ethPeers := cfg.MaxPeers - lightPeers
+	if lightClient {
+		ethPeers = 0
+	}
+	log.Info("Maximum peer count", "ETH", ethPeers, "LES", lightPeers, "total", cfg.MaxPeers)
+
 	if ctx.GlobalIsSet(MaxPendingPeersFlag.Name) {
 		cfg.MaxPendingPeers = ctx.GlobalInt(MaxPendingPeersFlag.Name)
 	}
-	if ctx.GlobalIsSet(NoDiscoverFlag.Name) || ctx.GlobalBool(LightModeFlag.Name) {
+	if ctx.GlobalIsSet(NoDiscoverFlag.Name) || lightClient {
 		cfg.NoDiscovery = true
 	}
 
 	// if we're running a light client or server, force enable the v5 peer discovery
 	// unless it is explicitly disabled with --nodiscover note that explicitly specifying
 	// --v5disc overrides --nodiscover, in which case the later only disables v4 discovery
-	forceV5Discovery := (ctx.GlobalBool(LightModeFlag.Name) || ctx.GlobalInt(LightServFlag.Name) > 0) && !ctx.GlobalBool(NoDiscoverFlag.Name)
+	forceV5Discovery := (lightClient || lightServer) && !ctx.GlobalBool(NoDiscoverFlag.Name)
 	if ctx.GlobalIsSet(DiscoveryV5Flag.Name) {
 		cfg.DiscoveryV5 = ctx.GlobalBool(DiscoveryV5Flag.Name)
 	} else if forceV5Discovery {
@@ -829,7 +863,6 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 		// --dev mode can't use p2p networking.
 		cfg.MaxPeers = 0
 		cfg.ListenAddr = ":0"
-		cfg.DiscoveryV5Addr = ":0"
 		cfg.NoDiscovery = true
 		cfg.DiscoveryV5 = false
 	}
@@ -1008,11 +1041,19 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 		cfg.NetworkId = ctx.GlobalUint64(NetworkIdFlag.Name)
 	}
 
-	if ctx.GlobalIsSet(CacheFlag.Name) {
-		cfg.DatabaseCache = ctx.GlobalInt(CacheFlag.Name)
+	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheDatabaseFlag.Name) {
+		cfg.DatabaseCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
 	}
 	cfg.DatabaseHandles = makeDatabaseHandles()
 
+	if gcmode := ctx.GlobalString(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
+		Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
+	}
+	cfg.NoPruning = ctx.GlobalString(GCModeFlag.Name) == "archive"
+
+	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
+		cfg.TrieCache = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
+	}
 	if ctx.GlobalIsSet(MinerThreadsFlag.Name) {
 		cfg.MinerThreads = ctx.GlobalInt(MinerThreadsFlag.Name)
 	}
@@ -1043,6 +1084,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 		}
 		cfg.Genesis = core.DefaultRinkebyGenesisBlock()
 	case ctx.GlobalBool(DeveloperFlag.Name):
+		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
+			cfg.NetworkId = 1337
+		}
 		// Create new developer account or reuse existing one
 		var (
 			developer accounts.Account
@@ -1077,7 +1121,6 @@ func SetDashboardConfig(ctx *cli.Context, cfg *dashboard.Config) {
 	cfg.Host = ctx.GlobalString(DashboardAddrFlag.Name)
 	cfg.Port = ctx.GlobalInt(DashboardPortFlag.Name)
 	cfg.Refresh = ctx.GlobalDuration(DashboardRefreshFlag.Name)
-	cfg.Assets = ctx.GlobalString(DashboardAssetsFlag.Name)
 }
 
 // RegisterEthService adds an Ethereum client to the stack.
@@ -1103,9 +1146,9 @@ func RegisterEthService(stack *node.Node, cfg *eth.Config) {
 }
 
 // RegisterDashboardService adds a dashboard to the stack.
-func RegisterDashboardService(stack *node.Node, cfg *dashboard.Config) {
+func RegisterDashboardService(stack *node.Node, cfg *dashboard.Config, commit string) {
 	stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
-		return dashboard.New(cfg)
+		return dashboard.New(cfg, commit)
 	})
 }
 
@@ -1138,13 +1181,13 @@ func RegisterEthStatsService(stack *node.Node, url string) {
 // SetupNetwork configures the system for either the main net or some test network.
 func SetupNetwork(ctx *cli.Context) {
 	// TODO(fjl): move target gas limit into config
-	params.TargetGasLimit = new(big.Int).SetUint64(ctx.GlobalUint64(TargetGasLimitFlag.Name))
+	params.TargetGasLimit = ctx.GlobalUint64(TargetGasLimitFlag.Name)
 }
 
 // MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
 func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database {
 	var (
-		cache   = ctx.GlobalInt(CacheFlag.Name)
+		cache   = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheDatabaseFlag.Name) / 100
 		handles = makeDatabaseHandles()
 	)
 	name := "chaindata"
@@ -1196,8 +1239,19 @@ func MakeChain(ctx *cli.Context, stack *node.Node) (chain *core.BlockChain, chai
 			})
 		}
 	}
+	if gcmode := ctx.GlobalString(GCModeFlag.Name); gcmode != "full" && gcmode != "archive" {
+		Fatalf("--%s must be either 'full' or 'archive'", GCModeFlag.Name)
+	}
+	cache := &core.CacheConfig{
+		Disabled:      ctx.GlobalString(GCModeFlag.Name) == "archive",
+		TrieNodeLimit: eth.DefaultConfig.TrieCache,
+		TrieTimeLimit: eth.DefaultConfig.TrieTimeout,
+	}
+	if ctx.GlobalIsSet(CacheFlag.Name) || ctx.GlobalIsSet(CacheGCFlag.Name) {
+		cache.TrieNodeLimit = ctx.GlobalInt(CacheFlag.Name) * ctx.GlobalInt(CacheGCFlag.Name) / 100
+	}
 	vmcfg := vm.Config{EnablePreimageRecording: ctx.GlobalBool(VMEnableDebugFlag.Name)}
-	chain, err = core.NewBlockChain(chainDb, config, engine, vmcfg)
+	chain, err = core.NewBlockChain(chainDb, cache, config, engine, vmcfg)
 	if err != nil {
 		Fatalf("Can't create BlockChain: %v", err)
 	}
diff --git a/cmd/wnode/main.go b/cmd/wnode/main.go
index 05e6b29086..31b65c1da9 100644
--- a/cmd/wnode/main.go
+++ b/cmd/wnode/main.go
@@ -22,6 +22,7 @@ package main
 import (
 	"bufio"
 	"crypto/ecdsa"
+	crand "crypto/rand"
 	"crypto/sha512"
 	"encoding/binary"
 	"encoding/hex"
@@ -43,11 +44,12 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/nat"
 	"github.com/ethereum/go-ethereum/whisper/mailserver"
-	whisper "github.com/ethereum/go-ethereum/whisper/whisperv5"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 	"golang.org/x/crypto/pbkdf2"
 )
 
 const quitCommand = "~Q"
+const entropySize = 32
 
 // singletons
 var (
@@ -55,33 +57,37 @@ var (
 	shh        *whisper.Whisper
 	done       chan struct{}
 	mailServer mailserver.WMailServer
+	entropy    [entropySize]byte
 
 	input = bufio.NewReader(os.Stdin)
 )
 
 // encryption
 var (
-	symKey     []byte
-	pub        *ecdsa.PublicKey
-	asymKey    *ecdsa.PrivateKey
-	nodeid     *ecdsa.PrivateKey
-	topic      whisper.TopicType
-	asymKeyID  string
-	filterID   string
-	symPass    string
-	msPassword string
+	symKey  []byte
+	pub     *ecdsa.PublicKey
+	asymKey *ecdsa.PrivateKey
+	nodeid  *ecdsa.PrivateKey
+	topic   whisper.TopicType
+
+	asymKeyID    string
+	asymFilterID string
+	symFilterID  string
+	symPass      string
+	msPassword   string
 )
 
 // cmd arguments
 var (
-	bootstrapMode  = flag.Bool("standalone", false, "boostrap node: don't actively connect to peers, wait for incoming connections")
-	forwarderMode  = flag.Bool("forwarder", false, "forwarder mode: only forward messages, neither send nor decrypt messages")
+	bootstrapMode  = flag.Bool("standalone", false, "boostrap node: don't initiate connection to peers, just wait for incoming connections")
+	forwarderMode  = flag.Bool("forwarder", false, "forwarder mode: only forward messages, neither encrypt nor decrypt messages")
 	mailServerMode = flag.Bool("mailserver", false, "mail server mode: delivers expired messages on demand")
 	requestMail    = flag.Bool("mailclient", false, "request expired messages from the bootstrap server")
 	asymmetricMode = flag.Bool("asym", false, "use asymmetric encryption")
 	generateKey    = flag.Bool("generatekey", false, "generate and show the private key")
 	fileExMode     = flag.Bool("fileexchange", false, "file exchange mode")
-	testMode       = flag.Bool("test", false, "use of predefined parameters for diagnostics")
+	fileReader     = flag.Bool("filereader", false, "load and decrypt messages saved as files, display as plain text")
+	testMode       = flag.Bool("test", false, "use of predefined parameters for diagnostics (password, etc.)")
 	echoMode       = flag.Bool("echo", false, "echo mode: prints some arguments for diagnostics")
 
 	argVerbosity = flag.Int("verbosity", int(log.LvlError), "log verbosity level")
@@ -97,13 +103,14 @@ var (
 	argIDFile  = flag.String("idfile", "", "file name with node id (private key)")
 	argEnode   = flag.String("boot", "", "bootstrap node you want to connect to (e.g. enode://e454......08d50@52.176.211.200:16428)")
 	argTopic   = flag.String("topic", "", "topic in hexadecimal format (e.g. 70a4beef)")
-	argSaveDir = flag.String("savedir", "", "directory where incoming messages will be saved as files")
+	argSaveDir = flag.String("savedir", "", "directory where all incoming messages will be saved as files")
 )
 
 func main() {
 	processArgs()
 	initialize()
 	run()
+	shutdown()
 }
 
 func processArgs() {
@@ -133,8 +140,8 @@ func processArgs() {
 	}
 
 	if *asymmetricMode && len(*argPub) > 0 {
-		pub = crypto.ToECDSAPub(common.FromHex(*argPub))
-		if !isKeyValid(pub) {
+		var err error
+		if pub, err = crypto.UnmarshalPubkey(common.FromHex(*argPub)); err != nil {
 			utils.Fatalf("invalid public key")
 		}
 	}
@@ -190,6 +197,8 @@ func initialize() {
 		if len(*argIP) == 0 {
 			argIP = scanLineA("Please enter your IP and port (e.g. 127.0.0.1:30348): ")
 		}
+	} else if *fileReader {
+		*bootstrapMode = true
 	} else {
 		if len(*argEnode) == 0 {
 			argEnode = scanLineA("Please enter the peer's enode: ")
@@ -198,11 +207,6 @@ func initialize() {
 		peers = append(peers, peer)
 	}
 
-	cfg := &whisper.Config{
-		MaxMessageSize:     uint32(*argMaxSize),
-		MinimumAcceptedPOW: *argPoW,
-	}
-
 	if *mailServerMode {
 		if len(msPassword) == 0 {
 			msPassword, err = console.Stdin.PromptPassword("Please enter the Mail Server password: ")
@@ -210,14 +214,15 @@ func initialize() {
 				utils.Fatalf("Failed to read Mail Server password: %s", err)
 			}
 		}
-
-		shh = whisper.New(cfg)
-		shh.RegisterServer(&mailServer)
-		mailServer.Init(shh, *argDBPath, msPassword, *argServerPoW)
-	} else {
-		shh = whisper.New(cfg)
 	}
 
+	cfg := &whisper.Config{
+		MaxMessageSize:     uint32(*argMaxSize),
+		MinimumAcceptedPOW: *argPoW,
+	}
+
+	shh = whisper.New(cfg)
+
 	if *argPoW != whisper.DefaultMinimumPoW {
 		err := shh.SetMinimumPoW(*argPoW)
 		if err != nil {
@@ -259,11 +264,23 @@ func initialize() {
 		maxPeers = 800
 	}
 
+	_, err = crand.Read(entropy[:])
+	if err != nil {
+		utils.Fatalf("crypto/rand failed: %s", err)
+	}
+
+	if *mailServerMode {
+		shh.RegisterServer(&mailServer)
+		if err := mailServer.Init(shh, *argDBPath, msPassword, *argServerPoW); err != nil {
+			utils.Fatalf("Failed to init MailServer: %s", err)
+		}
+	}
+
 	server = &p2p.Server{
 		Config: p2p.Config{
 			PrivateKey:     nodeid,
 			MaxPeers:       maxPeers,
-			Name:           common.MakeName("wnode", "5.0"),
+			Name:           common.MakeName("wnode", "6.0"),
 			Protocols:      shh.Protocols(),
 			ListenAddr:     *argIP,
 			NAT:            nat.Any(),
@@ -274,10 +291,11 @@ func initialize() {
 	}
 }
 
-func startServer() {
+func startServer() error {
 	err := server.Start()
 	if err != nil {
-		utils.Fatalf("Failed to start Whisper peer: %s.", err)
+		fmt.Printf("Failed to start Whisper peer: %s.", err)
+		return err
 	}
 
 	fmt.Printf("my public key: %s \n", common.ToHex(crypto.FromECDSAPub(&asymKey.PublicKey)))
@@ -293,13 +311,14 @@ func startServer() {
 		configureNode()
 	}
 
-	if !*forwarderMode {
+	if *fileExMode {
+		fmt.Printf("Please type the file name to be send. To quit type: '%s'\n", quitCommand)
+	} else if *fileReader {
+		fmt.Printf("Please type the file name to be decrypted. To quit type: '%s'\n", quitCommand)
+	} else if !*forwarderMode {
 		fmt.Printf("Please type the message. To quit type: '%s'\n", quitCommand)
 	}
-}
-
-func isKeyValid(k *ecdsa.PublicKey) bool {
-	return k.X != nil && k.Y != nil
+	return nil
 }
 
 func configureNode() {
@@ -317,9 +336,8 @@ func configureNode() {
 			if b == nil {
 				utils.Fatalf("Error: can not convert hexadecimal string")
 			}
-			pub = crypto.ToECDSAPub(b)
-			if !isKeyValid(pub) {
-				utils.Fatalf("Error: invalid public key")
+			if pub, err = crypto.UnmarshalPubkey(b); err != nil {
+				utils.Fatalf("Error: invalid peer public key")
 			}
 		}
 	}
@@ -363,13 +381,22 @@ func configureNode() {
 		}
 	}
 
-	filter := whisper.Filter{
+	symFilter := whisper.Filter{
 		KeySym:   symKey,
+		Topics:   [][]byte{topic[:]},
+		AllowP2P: p2pAccept,
+	}
+	symFilterID, err = shh.Subscribe(&symFilter)
+	if err != nil {
+		utils.Fatalf("Failed to install filter: %s", err)
+	}
+
+	asymFilter := whisper.Filter{
 		KeyAsym:  asymKey,
 		Topics:   [][]byte{topic[:]},
 		AllowP2P: p2pAccept,
 	}
-	filterID, err = shh.Subscribe(&filter)
+	asymFilterID, err = shh.Subscribe(&asymFilter)
 	if err != nil {
 		utils.Fatalf("Failed to install filter: %s", err)
 	}
@@ -400,8 +427,10 @@ func waitForConnection(timeout bool) {
 }
 
 func run() {
-	defer mailServer.Close()
-	startServer()
+	err := startServer()
+	if err != nil {
+		return
+	}
 	defer server.Stop()
 	shh.Start(nil)
 	defer shh.Stop()
@@ -414,21 +443,26 @@ func run() {
 		requestExpiredMessagesLoop()
 	} else if *fileExMode {
 		sendFilesLoop()
+	} else if *fileReader {
+		fileReaderLoop()
 	} else {
 		sendLoop()
 	}
 }
 
+func shutdown() {
+	close(done)
+	mailServer.Close()
+}
+
 func sendLoop() {
 	for {
 		s := scanLine("")
 		if s == quitCommand {
 			fmt.Println("Quit command received")
-			close(done)
-			break
+			return
 		}
 		sendMsg([]byte(s))
-
 		if *asymmetricMode {
 			// print your own message for convenience,
 			// because in asymmetric mode it is impossible to decrypt it
@@ -444,13 +478,11 @@ func sendFilesLoop() {
 		s := scanLine("")
 		if s == quitCommand {
 			fmt.Println("Quit command received")
-			close(done)
-			break
+			return
 		}
 		b, err := ioutil.ReadFile(s)
 		if err != nil {
 			fmt.Printf(">>> Error: %s \n", err)
-			continue
 		} else {
 			h := sendMsg(b)
 			if (h == common.Hash{}) {
@@ -464,6 +496,38 @@ func sendFilesLoop() {
 	}
 }
 
+func fileReaderLoop() {
+	watcher1 := shh.GetFilter(symFilterID)
+	watcher2 := shh.GetFilter(asymFilterID)
+	if watcher1 == nil && watcher2 == nil {
+		fmt.Println("Error: neither symmetric nor asymmetric filter is installed")
+		return
+	}
+
+	for {
+		s := scanLine("")
+		if s == quitCommand {
+			fmt.Println("Quit command received")
+			return
+		}
+		raw, err := ioutil.ReadFile(s)
+		if err != nil {
+			fmt.Printf(">>> Error: %s \n", err)
+		} else {
+			env := whisper.Envelope{Data: raw} // the topic is zero
+			msg := env.Open(watcher1)          // force-open envelope regardless of the topic
+			if msg == nil {
+				msg = env.Open(watcher2)
+			}
+			if msg == nil {
+				fmt.Printf(">>> Error: failed to decrypt the message \n")
+			} else {
+				printMessageInfo(msg)
+			}
+		}
+	}
+}
+
 func scanLine(prompt string) string {
 	if len(prompt) > 0 {
 		fmt.Print(prompt)
@@ -506,6 +570,7 @@ func sendMsg(payload []byte) common.Hash {
 	if err != nil {
 		utils.Fatalf("failed to create new message: %s", err)
 	}
+
 	envelope, err := msg.Wrap(¶ms)
 	if err != nil {
 		fmt.Printf("failed to seal message: %v \n", err)
@@ -522,9 +587,14 @@ func sendMsg(payload []byte) common.Hash {
 }
 
 func messageLoop() {
-	f := shh.GetFilter(filterID)
-	if f == nil {
-		utils.Fatalf("filter is not installed")
+	sf := shh.GetFilter(symFilterID)
+	if sf == nil {
+		utils.Fatalf("symmetric filter is not installed")
+	}
+
+	af := shh.GetFilter(asymFilterID)
+	if af == nil {
+		utils.Fatalf("asymmetric filter is not installed")
 	}
 
 	ticker := time.NewTicker(time.Millisecond * 50)
@@ -532,12 +602,21 @@ func messageLoop() {
 	for {
 		select {
 		case <-ticker.C:
-			messages := f.Retrieve()
+			m1 := sf.Retrieve()
+			m2 := af.Retrieve()
+			messages := append(m1, m2...)
 			for _, msg := range messages {
-				if *fileExMode || len(msg.Payload) > 2048 {
-					writeMessageToFile(*argSaveDir, msg)
-				} else {
+				reportedOnce := false
+				if !*fileExMode && len(msg.Payload) <= 2048 {
 					printMessageInfo(msg)
+					reportedOnce = true
+				}
+
+				// All messages are saved upon specifying argSaveDir.
+				// fileExMode only specifies how messages are displayed on the console after they are saved.
+				// if fileExMode == true, only the hashes are displayed, since messages might be too big.
+				if len(*argSaveDir) > 0 {
+					writeMessageToFile(*argSaveDir, msg, !reportedOnce)
 				}
 			}
 		case <-done:
@@ -562,7 +641,11 @@ func printMessageInfo(msg *whisper.ReceivedMessage) {
 	}
 }
 
-func writeMessageToFile(dir string, msg *whisper.ReceivedMessage) {
+func writeMessageToFile(dir string, msg *whisper.ReceivedMessage, show bool) {
+	if len(dir) == 0 {
+		return
+	}
+
 	timestamp := fmt.Sprintf("%d", msg.Sent)
 	name := fmt.Sprintf("%x", msg.EnvelopeHash)
 
@@ -571,27 +654,32 @@ func writeMessageToFile(dir string, msg *whisper.ReceivedMessage) {
 		address = crypto.PubkeyToAddress(*msg.Src)
 	}
 
-	if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) {
-		// message from myself: don't save, only report
-		fmt.Printf("\n%s <%x>: message received: '%s'\n", timestamp, address, name)
-	} else if len(dir) > 0 {
-		fullpath := filepath.Join(dir, name)
-		err := ioutil.WriteFile(fullpath, msg.Payload, 0644)
-		if err != nil {
-			fmt.Printf("\n%s {%x}: message received but not saved: %s\n", timestamp, address, err)
-		} else {
-			fmt.Printf("\n%s {%x}: message received and saved as '%s' (%d bytes)\n", timestamp, address, name, len(msg.Payload))
-		}
-	} else {
-		fmt.Printf("\n%s {%x}: big message received (%d bytes), but not saved: %s\n", timestamp, address, len(msg.Payload), name)
+	env := shh.GetEnvelope(msg.EnvelopeHash)
+	if env == nil {
+		fmt.Printf("\nUnexpected error: envelope not found: %x\n", msg.EnvelopeHash)
+		return
+	}
+
+	// this is a sample code; uncomment if you don't want to save your own messages.
+	//if whisper.IsPubKeyEqual(msg.Src, &asymKey.PublicKey) {
+	//	fmt.Printf("\n%s <%x>: message from myself received, not saved: '%s'\n", timestamp, address, name)
+	//	return
+	//}
+
+	fullpath := filepath.Join(dir, name)
+	err := ioutil.WriteFile(fullpath, env.Data, 0644)
+	if err != nil {
+		fmt.Printf("\n%s {%x}: message received but not saved: %s\n", timestamp, address, err)
+	} else if show {
+		fmt.Printf("\n%s {%x}: message received and saved as '%s' (%d bytes)\n", timestamp, address, name, len(env.Data))
 	}
 }
 
 func requestExpiredMessagesLoop() {
-	var key, peerID []byte
+	var key, peerID, bloom []byte
 	var timeLow, timeUpp uint32
 	var t string
-	var xt, empty whisper.TopicType
+	var xt whisper.TopicType
 
 	keyID, err := shh.AddSymKeyFromPassword(msPassword)
 	if err != nil {
@@ -601,37 +689,43 @@ func requestExpiredMessagesLoop() {
 	if err != nil {
 		utils.Fatalf("Failed to save symmetric key for mail request: %s", err)
 	}
-	peerID = extractIdFromEnode(*argEnode)
+	peerID = extractIDFromEnode(*argEnode)
 	shh.AllowP2PMessagesFromPeer(peerID)
 
 	for {
 		timeLow = scanUint("Please enter the lower limit of the time range (unix timestamp): ")
 		timeUpp = scanUint("Please enter the upper limit of the time range (unix timestamp): ")
-		t = scanLine("Please enter the topic (hexadecimal): ")
-		if len(t) >= whisper.TopicLength*2 {
+		t = scanLine("Enter the topic (hex). Press enter to request all messages, regardless of the topic: ")
+		if len(t) == whisper.TopicLength*2 {
 			x, err := hex.DecodeString(t)
 			if err != nil {
-				utils.Fatalf("Failed to parse the topic: %s", err)
+				fmt.Printf("Failed to parse the topic: %s \n", err)
+				continue
 			}
 			xt = whisper.BytesToTopic(x)
+			bloom = whisper.TopicToBloom(xt)
+			obfuscateBloom(bloom)
+		} else if len(t) == 0 {
+			bloom = whisper.MakeFullNodeBloom()
+		} else {
+			fmt.Println("Error: topic is invalid, request aborted")
+			continue
 		}
+
 		if timeUpp == 0 {
 			timeUpp = 0xFFFFFFFF
 		}
 
-		data := make([]byte, 8+whisper.TopicLength)
+		data := make([]byte, 8, 8+whisper.BloomFilterSize)
 		binary.BigEndian.PutUint32(data, timeLow)
 		binary.BigEndian.PutUint32(data[4:], timeUpp)
-		copy(data[8:], xt[:])
-		if xt == empty {
-			data = data[:8]
-		}
+		data = append(data, bloom...)
 
 		var params whisper.MessageParams
 		params.PoW = *argServerPoW
 		params.Payload = data
 		params.KeySym = key
-		params.Src = nodeid
+		params.Src = asymKey
 		params.WorkTime = 5
 
 		msg, err := whisper.NewSentMessage(¶ms)
@@ -652,10 +746,27 @@ func requestExpiredMessagesLoop() {
 	}
 }
 
-func extractIdFromEnode(s string) []byte {
+func extractIDFromEnode(s string) []byte {
 	n, err := discover.ParseNode(s)
 	if err != nil {
 		utils.Fatalf("Failed to parse enode: %s", err)
 	}
 	return n.ID[:]
 }
+
+// obfuscateBloom adds 16 random bits to the the bloom
+// filter, in order to obfuscate the containing topics.
+// it does so deterministically within every session.
+// despite additional bits, it will match on average
+// 32000 times less messages than full node's bloom filter.
+func obfuscateBloom(bloom []byte) {
+	const half = entropySize / 2
+	for i := 0; i < half; i++ {
+		x := int(entropy[i])
+		if entropy[half+i] < 128 {
+			x += 256
+		}
+
+		bloom[x/8] = 1 << uint(x%8) // set the bit number X
+	}
+}
diff --git a/common/big.go b/common/big.go
index b552608bc7..65d4377bf7 100644
--- a/common/big.go
+++ b/common/big.go
@@ -25,6 +25,6 @@ var (
 	Big3   = big.NewInt(3)
 	Big0   = big.NewInt(0)
 	Big32  = big.NewInt(32)
-	Big256 = big.NewInt(0xff)
+	Big256 = big.NewInt(256)
 	Big257 = big.NewInt(257)
 )
diff --git a/common/bitutil/bitutil.go b/common/bitutil/bitutil.go
index 117616543d..cd3e72169f 100644
--- a/common/bitutil/bitutil.go
+++ b/common/bitutil/bitutil.go
@@ -40,7 +40,7 @@ func fastXORBytes(dst, a, b []byte) int {
 			dw[i] = aw[i] ^ bw[i]
 		}
 	}
-	for i := (n - n%wordSize); i < n; i++ {
+	for i := n - n%wordSize; i < n; i++ {
 		dst[i] = a[i] ^ b[i]
 	}
 	return n
@@ -84,7 +84,7 @@ func fastANDBytes(dst, a, b []byte) int {
 			dw[i] = aw[i] & bw[i]
 		}
 	}
-	for i := (n - n%wordSize); i < n; i++ {
+	for i := n - n%wordSize; i < n; i++ {
 		dst[i] = a[i] & b[i]
 	}
 	return n
@@ -128,7 +128,7 @@ func fastORBytes(dst, a, b []byte) int {
 			dw[i] = aw[i] | bw[i]
 		}
 	}
-	for i := (n - n%wordSize); i < n; i++ {
+	for i := n - n%wordSize; i < n; i++ {
 		dst[i] = a[i] | b[i]
 	}
 	return n
@@ -168,7 +168,7 @@ func fastTestBytes(p []byte) bool {
 			}
 		}
 	}
-	for i := (n - n%wordSize); i < n; i++ {
+	for i := n - n%wordSize; i < n; i++ {
 		if p[i] != 0 {
 			return true
 		}
diff --git a/common/bytes.go b/common/bytes.go
index ba00e8a4b2..cbab2c3fa9 100644
--- a/common/bytes.go
+++ b/common/bytes.go
@@ -19,15 +19,20 @@ package common
 
 import "encoding/hex"
 
+// ToHex returns the hex representation of b, prefixed with '0x'.
+// For empty slices, the return value is "0x0".
+//
+// Deprecated: use hexutil.Encode instead.
 func ToHex(b []byte) string {
 	hex := Bytes2Hex(b)
-	// Prefer output of "0x0" instead of "0x"
 	if len(hex) == 0 {
 		hex = "0"
 	}
 	return "0x" + hex
 }
 
+// FromHex returns the bytes represented by the hexadecimal string s.
+// s may be prefixed with "0x".
 func FromHex(s string) []byte {
 	if len(s) > 1 {
 		if s[0:2] == "0x" || s[0:2] == "0X" {
@@ -40,9 +45,7 @@ func FromHex(s string) []byte {
 	return Hex2Bytes(s)
 }
 
-// Copy bytes
-//
-// Returns an exact copy of the provided bytes
+// CopyBytes returns an exact copy of the provided bytes.
 func CopyBytes(b []byte) (copiedBytes []byte) {
 	if b == nil {
 		return nil
@@ -53,14 +56,17 @@ func CopyBytes(b []byte) (copiedBytes []byte) {
 	return
 }
 
+// hasHexPrefix validates str begins with '0x' or '0X'.
 func hasHexPrefix(str string) bool {
 	return len(str) >= 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')
 }
 
+// isHexCharacter returns bool of c being a valid hexadecimal.
 func isHexCharacter(c byte) bool {
 	return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')
 }
 
+// isHex validates whether each byte is valid hexadecimal string.
 func isHex(str string) bool {
 	if len(str)%2 != 0 {
 		return false
@@ -73,31 +79,32 @@ func isHex(str string) bool {
 	return true
 }
 
+// Bytes2Hex returns the hexadecimal encoding of d.
 func Bytes2Hex(d []byte) string {
 	return hex.EncodeToString(d)
 }
 
+// Hex2Bytes returns the bytes represented by the hexadecimal string str.
 func Hex2Bytes(str string) []byte {
 	h, _ := hex.DecodeString(str)
-
 	return h
 }
 
+// Hex2BytesFixed returns bytes of a specified fixed length flen.
 func Hex2BytesFixed(str string, flen int) []byte {
 	h, _ := hex.DecodeString(str)
 	if len(h) == flen {
 		return h
-	} else {
-		if len(h) > flen {
-			return h[len(h)-flen:]
-		} else {
-			hh := make([]byte, flen)
-			copy(hh[flen-len(h):flen], h[:])
-			return hh
-		}
 	}
+	if len(h) > flen {
+		return h[len(h)-flen:]
+	}
+	hh := make([]byte, flen)
+	copy(hh[flen-len(h):flen], h[:])
+	return hh
 }
 
+// RightPadBytes zero-pads slice to the right up to length l.
 func RightPadBytes(slice []byte, l int) []byte {
 	if l <= len(slice) {
 		return slice
@@ -109,6 +116,7 @@ func RightPadBytes(slice []byte, l int) []byte {
 	return padded
 }
 
+// LeftPadBytes zero-pads slice to the left up to length l.
 func LeftPadBytes(slice []byte, l int) []byte {
 	if l <= len(slice) {
 		return slice
diff --git a/common/compiler/solidity.go b/common/compiler/solidity.go
index abb8039896..f6e8d2e42a 100644
--- a/common/compiler/solidity.go
+++ b/common/compiler/solidity.go
@@ -31,11 +31,17 @@ import (
 
 var versionRegexp = regexp.MustCompile(`([0-9]+)\.([0-9]+)\.([0-9]+)`)
 
+// Contract contains information about a compiled contract, alongside its code.
 type Contract struct {
 	Code string       `json:"code"`
 	Info ContractInfo `json:"info"`
 }
 
+// ContractInfo contains information about a compiled contract, including access
+// to the ABI definition, user and developer docs, and metadata.
+//
+// Depending on the source, language version, compiler version, and compiler
+// options will provide information about how the contract was compiled.
 type ContractInfo struct {
 	Source          string      `json:"source"`
 	Language        string      `json:"language"`
@@ -65,7 +71,6 @@ type solcOutput struct {
 func (s *Solidity) makeArgs() []string {
 	p := []string{
 		"--combined-json", "bin,abi,userdoc,devdoc",
-		"--add-std",  // include standard lib contracts
 		"--optimize", // code optimizer switched on
 	}
 	if s.Major > 0 || s.Minor > 4 || s.Patch > 6 {
@@ -143,8 +148,22 @@ func (s *Solidity) run(cmd *exec.Cmd, source string) (map[string]*Contract, erro
 	if err := cmd.Run(); err != nil {
 		return nil, fmt.Errorf("solc: %v\n%s", err, stderr.Bytes())
 	}
+
+	return ParseCombinedJSON(stdout.Bytes(), source, s.Version, s.Version, strings.Join(s.makeArgs(), " "))
+}
+
+// ParseCombinedJSON takes the direct output of a solc --combined-output run and
+// parses it into a map of string contract name to Contract structs. The
+// provided source, language and compiler version, and compiler options are all
+// passed through into the Contract structs.
+//
+// The solc output is expected to contain ABI, user docs, and dev docs.
+//
+// Returns an error if the JSON is malformed or missing data, or if the JSON
+// embedded within the JSON is malformed.
+func ParseCombinedJSON(combinedJSON []byte, source string, languageVersion string, compilerVersion string, compilerOptions string) (map[string]*Contract, error) {
 	var output solcOutput
-	if err := json.Unmarshal(stdout.Bytes(), &output); err != nil {
+	if err := json.Unmarshal(combinedJSON, &output); err != nil {
 		return nil, err
 	}
 
@@ -169,9 +188,9 @@ func (s *Solidity) run(cmd *exec.Cmd, source string) (map[string]*Contract, erro
 			Info: ContractInfo{
 				Source:          source,
 				Language:        "Solidity",
-				LanguageVersion: s.Version,
-				CompilerVersion: s.Version,
-				CompilerOptions: strings.Join(s.makeArgs(), " "),
+				LanguageVersion: languageVersion,
+				CompilerVersion: compilerVersion,
+				CompilerOptions: compilerOptions,
 				AbiDefinition:   abi,
 				UserDoc:         userdoc,
 				DeveloperDoc:    devdoc,
diff --git a/cmd/utils/fdlimit_freebsd.go b/common/fdlimit/fdlimit_freebsd.go
similarity index 50%
rename from cmd/utils/fdlimit_freebsd.go
rename to common/fdlimit/fdlimit_freebsd.go
index 4cb5013c84..c126b0c265 100644
--- a/cmd/utils/fdlimit_freebsd.go
+++ b/common/fdlimit/fdlimit_freebsd.go
@@ -1,22 +1,22 @@
 // Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
 // the Free Software Foundation, either version 3 of the License, or
 // (at your option) any later version.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
+// GNU Lesser General Public License for more details.
 //
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see .
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
 
 // +build freebsd
 
-package utils
+package fdlimit
 
 import "syscall"
 
@@ -24,9 +24,9 @@ import "syscall"
 // but Rlimit fields have type int64 on FreeBSD so it needs
 // an extra conversion.
 
-// raiseFdLimit tries to maximize the file descriptor allowance of this process
+// Raise tries to maximize the file descriptor allowance of this process
 // to the maximum hard-limit allowed by the OS.
-func raiseFdLimit(max uint64) error {
+func Raise(max uint64) error {
 	// Get the current limit
 	var limit syscall.Rlimit
 	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
@@ -43,12 +43,22 @@ func raiseFdLimit(max uint64) error {
 	return nil
 }
 
-// getFdLimit retrieves the number of file descriptors allowed to be opened by this
+// Current retrieves the number of file descriptors allowed to be opened by this
 // process.
-func getFdLimit() (int, error) {
+func Current() (int, error) {
 	var limit syscall.Rlimit
 	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
 		return 0, err
 	}
 	return int(limit.Cur), nil
 }
+
+// Maximum retrieves the maximum number of file descriptors this process is
+// allowed to request for itself.
+func Maximum() (int, error) {
+	var limit syscall.Rlimit
+	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
+		return 0, err
+	}
+	return int(limit.Max), nil
+}
diff --git a/common/fdlimit/fdlimit_test.go b/common/fdlimit/fdlimit_test.go
new file mode 100644
index 0000000000..a9ee9ab36a
--- /dev/null
+++ b/common/fdlimit/fdlimit_test.go
@@ -0,0 +1,45 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package fdlimit
+
+import (
+	"fmt"
+	"testing"
+)
+
+// TestFileDescriptorLimits simply tests whether the file descriptor allowance
+// per this process can be retrieved.
+func TestFileDescriptorLimits(t *testing.T) {
+	target := 4096
+	hardlimit, err := Maximum()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hardlimit < target {
+		t.Skip(fmt.Sprintf("system limit is less than desired test target: %d < %d", hardlimit, target))
+	}
+
+	if limit, err := Current(); err != nil || limit <= 0 {
+		t.Fatalf("failed to retrieve file descriptor limit (%d): %v", limit, err)
+	}
+	if err := Raise(uint64(target)); err != nil {
+		t.Fatalf("failed to raise file allowance")
+	}
+	if limit, err := Current(); err != nil || limit < target {
+		t.Fatalf("failed to retrieve raised descriptor limit (have %v, want %v): %v", limit, target, err)
+	}
+}
diff --git a/common/fdlimit/fdlimit_unix.go b/common/fdlimit/fdlimit_unix.go
new file mode 100644
index 0000000000..a258132353
--- /dev/null
+++ b/common/fdlimit/fdlimit_unix.go
@@ -0,0 +1,60 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// +build linux darwin netbsd openbsd solaris
+
+package fdlimit
+
+import "syscall"
+
+// Raise tries to maximize the file descriptor allowance of this process
+// to the maximum hard-limit allowed by the OS.
+func Raise(max uint64) error {
+	// Get the current limit
+	var limit syscall.Rlimit
+	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
+		return err
+	}
+	// Try to update the limit to the max allowance
+	limit.Cur = limit.Max
+	if limit.Cur > max {
+		limit.Cur = max
+	}
+	if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Current retrieves the number of file descriptors allowed to be opened by this
+// process.
+func Current() (int, error) {
+	var limit syscall.Rlimit
+	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
+		return 0, err
+	}
+	return int(limit.Cur), nil
+}
+
+// Maximum retrieves the maximum number of file descriptors this process is
+// allowed to request for itself.
+func Maximum() (int, error) {
+	var limit syscall.Rlimit
+	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil {
+		return 0, err
+	}
+	return int(limit.Max), nil
+}
diff --git a/common/fdlimit/fdlimit_windows.go b/common/fdlimit/fdlimit_windows.go
new file mode 100644
index 0000000000..863c58bedf
--- /dev/null
+++ b/common/fdlimit/fdlimit_windows.go
@@ -0,0 +1,47 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package fdlimit
+
+import "errors"
+
+// Raise tries to maximize the file descriptor allowance of this process
+// to the maximum hard-limit allowed by the OS.
+func Raise(max uint64) error {
+	// This method is NOP by design:
+	//  * Linux/Darwin counterparts need to manually increase per process limits
+	//  * On Windows Go uses the CreateFile API, which is limited to 16K files, non
+	//    changeable from within a running process
+	// This way we can always "request" raising the limits, which will either have
+	// or not have effect based on the platform we're running on.
+	if max > 16384 {
+		return errors.New("file descriptor limit (16384) reached")
+	}
+	return nil
+}
+
+// Current retrieves the number of file descriptors allowed to be opened by this
+// process.
+func Current() (int, error) {
+	// Please see Raise for the reason why we use hard coded 16K as the limit
+	return 16384, nil
+}
+
+// Maximum retrieves the maximum number of file descriptors this process is
+// allowed to request for itself.
+func Maximum() (int, error) {
+	return Current()
+}
diff --git a/common/hexutil/hexutil.go b/common/hexutil/hexutil.go
index 02c488a3f1..46223a2815 100644
--- a/common/hexutil/hexutil.go
+++ b/common/hexutil/hexutil.go
@@ -39,6 +39,7 @@ import (
 
 const uintBits = 32 << (uint64(^uint(0)) >> 63)
 
+// Errors
 var (
 	ErrEmptyString   = &decError{"empty hex string"}
 	ErrSyntax        = &decError{"invalid hex string"}
diff --git a/common/math/big.go b/common/math/big.go
index 7872786503..9d2e7946d1 100644
--- a/common/math/big.go
+++ b/common/math/big.go
@@ -22,12 +22,13 @@ import (
 	"math/big"
 )
 
+// Various big integer limit values.
 var (
 	tt255     = BigPow(2, 255)
 	tt256     = BigPow(2, 256)
 	tt256m1   = new(big.Int).Sub(tt256, big.NewInt(1))
-	MaxBig256 = new(big.Int).Set(tt256m1)
 	tt63      = BigPow(2, 63)
+	MaxBig256 = new(big.Int).Set(tt256m1)
 	MaxBig63  = new(big.Int).Sub(tt63, big.NewInt(1))
 )
 
@@ -78,7 +79,7 @@ func ParseBig256(s string) (*big.Int, bool) {
 	return bigint, ok
 }
 
-// MustParseBig parses s as a 256 bit big integer and panics if the string is invalid.
+// MustParseBig256 parses s as a 256 bit big integer and panics if the string is invalid.
 func MustParseBig256(s string) *big.Int {
 	v, ok := ParseBig256(s)
 	if !ok {
@@ -186,9 +187,8 @@ func U256(x *big.Int) *big.Int {
 func S256(x *big.Int) *big.Int {
 	if x.Cmp(tt255) < 0 {
 		return x
-	} else {
-		return new(big.Int).Sub(x, tt256)
 	}
+	return new(big.Int).Sub(x, tt256)
 }
 
 // Exp implements exponentiation by squaring.
diff --git a/common/math/integer.go b/common/math/integer.go
index 7eff4d3b00..93b1d036dd 100644
--- a/common/math/integer.go
+++ b/common/math/integer.go
@@ -21,8 +21,8 @@ import (
 	"strconv"
 )
 
+// Integer limit values.
 const (
-	// Integer limit values.
 	MaxInt8   = 1<<7 - 1
 	MinInt8   = -1 << 7
 	MaxInt16  = 1<<15 - 1
diff --git a/common/mclock/mclock.go b/common/mclock/mclock.go
index 92005252eb..02608d17b0 100644
--- a/common/mclock/mclock.go
+++ b/common/mclock/mclock.go
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see .
 
-// package mclock is a wrapper for a monotonic clock source
+// Package mclock is a wrapper for a monotonic clock source
 package mclock
 
 import (
@@ -23,8 +23,10 @@ import (
 	"github.com/aristanetworks/goarista/monotime"
 )
 
-type AbsTime time.Duration // absolute monotonic time
+// AbsTime represents absolute monotonic time.
+type AbsTime time.Duration
 
+// Now returns the current absolute monotonic time.
 func Now() AbsTime {
 	return AbsTime(monotime.Now())
 }
diff --git a/common/number/int.go b/common/number/int.go
deleted file mode 100644
index 6dab2436de..0000000000
--- a/common/number/int.go
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package number
-
-import (
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-var tt256 = new(big.Int).Lsh(big.NewInt(1), 256)
-var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1))
-var tt255 = new(big.Int).Lsh(big.NewInt(1), 255)
-
-func limitUnsigned256(x *Number) *Number {
-	x.num.And(x.num, tt256m1)
-	return x
-}
-
-func limitSigned256(x *Number) *Number {
-	if x.num.Cmp(tt255) < 0 {
-		return x
-	} else {
-		x.num.Sub(x.num, tt256)
-		return x
-	}
-}
-
-// Number function
-type Initialiser func(n int64) *Number
-
-// A Number represents a generic integer with a bounding function limiter. Limit is called after each operations
-// to give "fake" bounded integers. New types of Number can be created through NewInitialiser returning a lambda
-// with the new Initialiser.
-type Number struct {
-	num   *big.Int
-	limit func(n *Number) *Number
-}
-
-// Returns a new initialiser for a new *Number without having to expose certain fields
-func NewInitialiser(limiter func(*Number) *Number) Initialiser {
-	return func(n int64) *Number {
-		return &Number{big.NewInt(n), limiter}
-	}
-}
-
-// Return a Number with a UNSIGNED limiter up to 256 bits
-func Uint256(n int64) *Number {
-	return &Number{big.NewInt(n), limitUnsigned256}
-}
-
-// Return a Number with a SIGNED limiter up to 256 bits
-func Int256(n int64) *Number {
-	return &Number{big.NewInt(n), limitSigned256}
-}
-
-// Returns a Number with a SIGNED unlimited size
-func Big(n int64) *Number {
-	return &Number{big.NewInt(n), func(x *Number) *Number { return x }}
-}
-
-// Sets i to sum of x+y
-func (i *Number) Add(x, y *Number) *Number {
-	i.num.Add(x.num, y.num)
-	return i.limit(i)
-}
-
-// Sets i to difference of x-y
-func (i *Number) Sub(x, y *Number) *Number {
-	i.num.Sub(x.num, y.num)
-	return i.limit(i)
-}
-
-// Sets i to product of x*y
-func (i *Number) Mul(x, y *Number) *Number {
-	i.num.Mul(x.num, y.num)
-	return i.limit(i)
-}
-
-// Sets i to the quotient prodject of x/y
-func (i *Number) Div(x, y *Number) *Number {
-	i.num.Div(x.num, y.num)
-	return i.limit(i)
-}
-
-// Sets i to x % y
-func (i *Number) Mod(x, y *Number) *Number {
-	i.num.Mod(x.num, y.num)
-	return i.limit(i)
-}
-
-// Sets i to x << s
-func (i *Number) Lsh(x *Number, s uint) *Number {
-	i.num.Lsh(x.num, s)
-	return i.limit(i)
-}
-
-// Sets i to x^y
-func (i *Number) Pow(x, y *Number) *Number {
-	i.num.Exp(x.num, y.num, big.NewInt(0))
-	return i.limit(i)
-}
-
-// Setters
-
-// Set x to i
-func (i *Number) Set(x *Number) *Number {
-	i.num.Set(x.num)
-	return i.limit(i)
-}
-
-// Set x bytes to i
-func (i *Number) SetBytes(x []byte) *Number {
-	i.num.SetBytes(x)
-	return i.limit(i)
-}
-
-// Cmp compares x and y and returns:
-//
-//     -1 if x <  y
-//     0 if x == y
-//     +1 if x >  y
-func (i *Number) Cmp(x *Number) int {
-	return i.num.Cmp(x.num)
-}
-
-// Getters
-
-// Returns the string representation of i
-func (i *Number) String() string {
-	return i.num.String()
-}
-
-// Returns the byte representation of i
-func (i *Number) Bytes() []byte {
-	return i.num.Bytes()
-}
-
-// Uint64 returns the Uint64 representation of x. If x cannot be represented in an int64, the result is undefined.
-func (i *Number) Uint64() uint64 {
-	return i.num.Uint64()
-}
-
-// Int64 returns the int64 representation of x. If x cannot be represented in an int64, the result is undefined.
-func (i *Number) Int64() int64 {
-	return i.num.Int64()
-}
-
-// Returns the signed version of i
-func (i *Number) Int256() *Number {
-	return Int(0).Set(i)
-}
-
-// Returns the unsigned version of i
-func (i *Number) Uint256() *Number {
-	return Uint(0).Set(i)
-}
-
-// Returns the index of the first bit that's set to 1
-func (i *Number) FirstBitSet() int {
-	for j := 0; j < i.num.BitLen(); j++ {
-		if i.num.Bit(j) > 0 {
-			return j
-		}
-	}
-
-	return i.num.BitLen()
-}
-
-// Variables
-
-var (
-	Zero       = Uint(0)
-	One        = Uint(1)
-	Two        = Uint(2)
-	MaxUint256 = Uint(0).SetBytes(common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
-
-	MinOne = Int(-1)
-
-	// "typedefs"
-	Uint = Uint256
-	Int  = Int256
-)
diff --git a/common/number/uint_test.go b/common/number/uint_test.go
deleted file mode 100644
index 3ab9e4c344..0000000000
--- a/common/number/uint_test.go
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package number
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestSet(t *testing.T) {
-	a := Uint(0)
-	b := Uint(10)
-	a.Set(b)
-	if a.num.Cmp(b.num) != 0 {
-		t.Error("didn't compare", a, b)
-	}
-
-	c := Uint(0).SetBytes(common.Hex2Bytes("0a"))
-	if c.num.Cmp(big.NewInt(10)) != 0 {
-		t.Error("c set bytes failed.")
-	}
-}
-
-func TestInitialiser(t *testing.T) {
-	check := false
-	init := NewInitialiser(func(x *Number) *Number {
-		check = true
-		return x
-	})
-	a := init(0).Add(init(1), init(2))
-	if a.Cmp(init(3)) != 0 {
-		t.Error("expected 3. got", a)
-	}
-	if !check {
-		t.Error("expected limiter to be called")
-	}
-}
-
-func TestGet(t *testing.T) {
-	a := Uint(10)
-	if a.Uint64() != 10 {
-		t.Error("expected to get 10. got", a.Uint64())
-	}
-
-	a = Uint(10)
-	if a.Int64() != 10 {
-		t.Error("expected to get 10. got", a.Int64())
-	}
-}
-
-func TestCmp(t *testing.T) {
-	a := Uint(10)
-	b := Uint(10)
-	c := Uint(11)
-
-	if a.Cmp(b) != 0 {
-		t.Error("a b == 0 failed", a, b)
-	}
-
-	if a.Cmp(c) >= 0 {
-		t.Error("a c < 0 failed", a, c)
-	}
-
-	if c.Cmp(b) <= 0 {
-		t.Error("c b > 0 failed", c, b)
-	}
-}
-
-func TestMaxArith(t *testing.T) {
-	a := Uint(0).Add(MaxUint256, One)
-	if a.Cmp(Zero) != 0 {
-		t.Error("expected max256 + 1 = 0 got", a)
-	}
-
-	a = Uint(0).Sub(Uint(0), One)
-	if a.Cmp(MaxUint256) != 0 {
-		t.Error("expected 0 - 1 = max256 got", a)
-	}
-
-	a = Int(0).Sub(Int(0), One)
-	if a.Cmp(MinOne) != 0 {
-		t.Error("expected 0 - 1 = -1 got", a)
-	}
-}
-
-func TestConversion(t *testing.T) {
-	a := Int(-1)
-	b := a.Uint256()
-	if b.Cmp(MaxUint256) != 0 {
-		t.Error("expected -1 => unsigned to return max. got", b)
-	}
-}
diff --git a/common/path.go b/common/path.go
index bd8da86e74..69820cfe5d 100644
--- a/common/path.go
+++ b/common/path.go
@@ -30,6 +30,7 @@ func MakeName(name, version string) string {
 	return fmt.Sprintf("%s/v%s/%s/%s", name, version, runtime.GOOS, runtime.Version())
 }
 
+// FileExist checks if a file exists at filePath.
 func FileExist(filePath string) bool {
 	_, err := os.Stat(filePath)
 	if err != nil && os.IsNotExist(err) {
@@ -39,9 +40,10 @@ func FileExist(filePath string) bool {
 	return true
 }
 
-func AbsolutePath(Datadir string, filename string) string {
+// AbsolutePath returns datadir + filename, or filename if it is absolute.
+func AbsolutePath(datadir string, filename string) string {
 	if filepath.IsAbs(filename) {
 		return filename
 	}
-	return filepath.Join(Datadir, filename)
+	return filepath.Join(datadir, filename)
 }
diff --git a/common/size.go b/common/size.go
index c5a0cb0f2d..bd0fc85c7d 100644
--- a/common/size.go
+++ b/common/size.go
@@ -20,18 +20,29 @@ import (
 	"fmt"
 )
 
+// StorageSize is a wrapper around a float value that supports user friendly
+// formatting.
 type StorageSize float64
 
-func (self StorageSize) String() string {
-	if self > 1000000 {
-		return fmt.Sprintf("%.2f mB", self/1000000)
-	} else if self > 1000 {
-		return fmt.Sprintf("%.2f kB", self/1000)
+// String implements the stringer interface.
+func (s StorageSize) String() string {
+	if s > 1000000 {
+		return fmt.Sprintf("%.2f mB", s/1000000)
+	} else if s > 1000 {
+		return fmt.Sprintf("%.2f kB", s/1000)
 	} else {
-		return fmt.Sprintf("%.2f B", self)
+		return fmt.Sprintf("%.2f B", s)
 	}
 }
 
-func (self StorageSize) Int64() int64 {
-	return int64(self)
+// TerminalString implements log.TerminalStringer, formatting a string for console
+// output during logging.
+func (s StorageSize) TerminalString() string {
+	if s > 1000000 {
+		return fmt.Sprintf("%.2fmB", s/1000000)
+	} else if s > 1000 {
+		return fmt.Sprintf("%.2fkB", s/1000)
+	} else {
+		return fmt.Sprintf("%.2fB", s)
+	}
 }
diff --git a/common/types.go b/common/types.go
index fdc67480c2..4d374ad246 100644
--- a/common/types.go
+++ b/common/types.go
@@ -18,15 +18,18 @@ package common
 
 import (
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
 	"math/big"
 	"math/rand"
 	"reflect"
+	"strings"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto/sha3"
 )
 
+// Lengths of hashes and addresses in bytes.
 const (
 	HashLength    = 32
 	AddressLength = 20
@@ -40,20 +43,30 @@ var (
 // Hash represents the 32 byte Keccak256 hash of arbitrary data.
 type Hash [HashLength]byte
 
+// BytesToHash sets b to hash.
+// If b is larger than len(h), b will be cropped from the left.
 func BytesToHash(b []byte) Hash {
 	var h Hash
 	h.SetBytes(b)
 	return h
 }
-func StringToHash(s string) Hash { return BytesToHash([]byte(s)) }
-func BigToHash(b *big.Int) Hash  { return BytesToHash(b.Bytes()) }
-func HexToHash(s string) Hash    { return BytesToHash(FromHex(s)) }
 
-// Get the string representation of the underlying hash
-func (h Hash) Str() string   { return string(h[:]) }
+// BigToHash sets byte representation of b to hash.
+// If b is larger than len(h), b will be cropped from the left.
+func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) }
+
+// HexToHash sets byte representation of s to hash.
+// If b is larger than len(h), b will be cropped from the left.
+func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) }
+
+// Bytes gets the byte representation of the underlying hash.
 func (h Hash) Bytes() []byte { return h[:] }
+
+// Big converts a hash to a big integer.
 func (h Hash) Big() *big.Int { return new(big.Int).SetBytes(h[:]) }
-func (h Hash) Hex() string   { return hexutil.Encode(h[:]) }
+
+// Hex converts a hash to a hex string.
+func (h Hash) Hex() string { return hexutil.Encode(h[:]) }
 
 // TerminalString implements log.TerminalStringer, formatting a string for console
 // output during logging.
@@ -88,7 +101,8 @@ func (h Hash) MarshalText() ([]byte, error) {
 	return hexutil.Bytes(h[:]).MarshalText()
 }
 
-// Sets the hash to the value of b. If b is larger than len(h), 'b' will be cropped (from the left).
+// SetBytes sets the hash to the value of b.
+// If b is larger than len(h), b will be cropped from the left.
 func (h *Hash) SetBytes(b []byte) {
 	if len(b) > len(h) {
 		b = b[len(b)-HashLength:]
@@ -97,16 +111,6 @@ func (h *Hash) SetBytes(b []byte) {
 	copy(h[HashLength-len(b):], b)
 }
 
-// Set string `s` to h. If s is larger than len(h) s will be cropped (from left) to fit.
-func (h *Hash) SetString(s string) { h.SetBytes([]byte(s)) }
-
-// Sets h to other
-func (h *Hash) Set(other Hash) {
-	for i, v := range other {
-		h[i] = v
-	}
-}
-
 // Generate implements testing/quick.Generator.
 func (h Hash) Generate(rand *rand.Rand, size int) reflect.Value {
 	m := rand.Intn(len(h))
@@ -116,10 +120,6 @@ func (h Hash) Generate(rand *rand.Rand, size int) reflect.Value {
 	return reflect.ValueOf(h)
 }
 
-func EmptyHash(h Hash) bool {
-	return h == Hash{}
-}
-
 // UnprefixedHash allows marshaling a Hash without 0x prefix.
 type UnprefixedHash Hash
 
@@ -138,14 +138,21 @@ func (h UnprefixedHash) MarshalText() ([]byte, error) {
 // Address represents the 20 byte address of an Ethereum account.
 type Address [AddressLength]byte
 
+// BytesToAddress returns Address with value b.
+// If b is larger than len(h), b will be cropped from the left.
 func BytesToAddress(b []byte) Address {
 	var a Address
 	a.SetBytes(b)
 	return a
 }
-func StringToAddress(s string) Address { return BytesToAddress([]byte(s)) }
-func BigToAddress(b *big.Int) Address  { return BytesToAddress(b.Bytes()) }
-func HexToAddress(s string) Address    { return BytesToAddress(FromHex(s)) }
+
+// BigToAddress returns Address with byte values of b.
+// If b is larger than len(h), b will be cropped from the left.
+func BigToAddress(b *big.Int) Address { return BytesToAddress(b.Bytes()) }
+
+// HexToAddress returns Address with byte values of s.
+// If s is larger than len(h), s will be cropped from the left.
+func HexToAddress(s string) Address { return BytesToAddress(FromHex(s)) }
 
 // IsHexAddress verifies whether a string can represent a valid hex-encoded
 // Ethereum address or not.
@@ -156,11 +163,14 @@ func IsHexAddress(s string) bool {
 	return len(s) == 2*AddressLength && isHex(s)
 }
 
-// Get the string representation of the underlying address
-func (a Address) Str() string   { return string(a[:]) }
+// Bytes gets the string representation of the underlying address.
 func (a Address) Bytes() []byte { return a[:] }
+
+// Big converts an address to a big integer.
 func (a Address) Big() *big.Int { return new(big.Int).SetBytes(a[:]) }
-func (a Address) Hash() Hash    { return BytesToHash(a[:]) }
+
+// Hash converts an address to a hash by left-padding it with zeros.
+func (a Address) Hash() Hash { return BytesToHash(a[:]) }
 
 // Hex returns an EIP55-compliant hex string representation of the address.
 func (a Address) Hex() string {
@@ -184,7 +194,7 @@ func (a Address) Hex() string {
 	return "0x" + string(result)
 }
 
-// String implements the stringer interface and is used also by the logger.
+// String implements fmt.Stringer.
 func (a Address) String() string {
 	return a.Hex()
 }
@@ -195,7 +205,8 @@ func (a Address) Format(s fmt.State, c rune) {
 	fmt.Fprintf(s, "%"+string(c), a[:])
 }
 
-// Sets the address to the value of b. If b is larger than len(a) it will panic
+// SetBytes sets the address to the value of b.
+// If b is larger than len(a) it will panic.
 func (a *Address) SetBytes(b []byte) {
 	if len(b) > len(a) {
 		b = b[len(b)-AddressLength:]
@@ -203,16 +214,6 @@ func (a *Address) SetBytes(b []byte) {
 	copy(a[AddressLength-len(b):], b)
 }
 
-// Set string `s` to a. If s is larger than len(a) it will panic
-func (a *Address) SetString(s string) { a.SetBytes([]byte(s)) }
-
-// Sets a to other
-func (a *Address) Set(other Address) {
-	for i, v := range other {
-		a[i] = v
-	}
-}
-
 // MarshalText returns the hex representation of a.
 func (a Address) MarshalText() ([]byte, error) {
 	return hexutil.Bytes(a[:]).MarshalText()
@@ -228,7 +229,7 @@ func (a *Address) UnmarshalJSON(input []byte) error {
 	return hexutil.UnmarshalFixedJSON(addressT, input, a[:])
 }
 
-// UnprefixedHash allows marshaling an Address without 0x prefix.
+// UnprefixedAddress allows marshaling an Address without 0x prefix.
 type UnprefixedAddress Address
 
 // UnmarshalText decodes the address from hex. The 0x prefix is optional.
@@ -240,3 +241,63 @@ func (a *UnprefixedAddress) UnmarshalText(input []byte) error {
 func (a UnprefixedAddress) MarshalText() ([]byte, error) {
 	return []byte(hex.EncodeToString(a[:])), nil
 }
+
+// MixedcaseAddress retains the original string, which may or may not be
+// correctly checksummed
+type MixedcaseAddress struct {
+	addr     Address
+	original string
+}
+
+// NewMixedcaseAddress constructor (mainly for testing)
+func NewMixedcaseAddress(addr Address) MixedcaseAddress {
+	return MixedcaseAddress{addr: addr, original: addr.Hex()}
+}
+
+// NewMixedcaseAddressFromString is mainly meant for unit-testing
+func NewMixedcaseAddressFromString(hexaddr string) (*MixedcaseAddress, error) {
+	if !IsHexAddress(hexaddr) {
+		return nil, fmt.Errorf("Invalid address")
+	}
+	a := FromHex(hexaddr)
+	return &MixedcaseAddress{addr: BytesToAddress(a), original: hexaddr}, nil
+}
+
+// UnmarshalJSON parses MixedcaseAddress
+func (ma *MixedcaseAddress) UnmarshalJSON(input []byte) error {
+	if err := hexutil.UnmarshalFixedJSON(addressT, input, ma.addr[:]); err != nil {
+		return err
+	}
+	return json.Unmarshal(input, &ma.original)
+}
+
+// MarshalJSON marshals the original value
+func (ma *MixedcaseAddress) MarshalJSON() ([]byte, error) {
+	if strings.HasPrefix(ma.original, "0x") || strings.HasPrefix(ma.original, "0X") {
+		return json.Marshal(fmt.Sprintf("0x%s", ma.original[2:]))
+	}
+	return json.Marshal(fmt.Sprintf("0x%s", ma.original))
+}
+
+// Address returns the address
+func (ma *MixedcaseAddress) Address() Address {
+	return ma.addr
+}
+
+// String implements fmt.Stringer
+func (ma *MixedcaseAddress) String() string {
+	if ma.ValidChecksum() {
+		return fmt.Sprintf("%s [chksum ok]", ma.original)
+	}
+	return fmt.Sprintf("%s [chksum INVALID]", ma.original)
+}
+
+// ValidChecksum returns true if the address has valid checksum
+func (ma *MixedcaseAddress) ValidChecksum() bool {
+	return ma.original == ma.addr.Hex()
+}
+
+// Original returns the mixed-case input string
+func (ma *MixedcaseAddress) Original() string {
+	return ma.original
+}
diff --git a/common/types_template.go b/common/types_template.go
deleted file mode 100644
index 9a8f29977b..0000000000
--- a/common/types_template.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// +build none
-//sed -e 's/_N_/Hash/g' -e 's/_S_/32/g' -e '1d' types_template.go | gofmt -w hash.go
-
-package common
-
-import "math/big"
-
-type _N_ [_S_]byte
-
-func BytesTo_N_(b []byte) _N_ {
-	var h _N_
-	h.SetBytes(b)
-	return h
-}
-func StringTo_N_(s string) _N_ { return BytesTo_N_([]byte(s)) }
-func BigTo_N_(b *big.Int) _N_  { return BytesTo_N_(b.Bytes()) }
-func HexTo_N_(s string) _N_    { return BytesTo_N_(FromHex(s)) }
-
-// Don't use the default 'String' method in case we want to overwrite
-
-// Get the string representation of the underlying hash
-func (h _N_) Str() string   { return string(h[:]) }
-func (h _N_) Bytes() []byte { return h[:] }
-func (h _N_) Big() *big.Int { return new(big.Int).SetBytes(h[:]) }
-func (h _N_) Hex() string   { return "0x" + Bytes2Hex(h[:]) }
-
-// Sets the hash to the value of b. If b is larger than len(h) it will panic
-func (h *_N_) SetBytes(b []byte) {
-	// Use the right most bytes
-	if len(b) > len(h) {
-		b = b[len(b)-_S_:]
-	}
-
-	// Reverse the loop
-	for i := len(b) - 1; i >= 0; i-- {
-		h[_S_-len(b)+i] = b[i]
-	}
-}
-
-// Set string `s` to h. If s is larger than len(h) it will panic
-func (h *_N_) SetString(s string) { h.SetBytes([]byte(s)) }
-
-// Sets h to other
-func (h *_N_) Set(other _N_) {
-	for i, v := range other {
-		h[i] = v
-	}
-}
diff --git a/common/types_test.go b/common/types_test.go
index db636812ce..9e0c5be3ad 100644
--- a/common/types_test.go
+++ b/common/types_test.go
@@ -18,6 +18,7 @@ package common
 
 import (
 	"encoding/json"
+
 	"math/big"
 	"strings"
 	"testing"
@@ -149,3 +150,46 @@ func BenchmarkAddressHex(b *testing.B) {
 		testAddr.Hex()
 	}
 }
+
+func TestMixedcaseAccount_Address(t *testing.T) {
+
+	// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md
+	// Note: 0X{checksum_addr} is not valid according to spec above
+
+	var res []struct {
+		A     MixedcaseAddress
+		Valid bool
+	}
+	if err := json.Unmarshal([]byte(`[
+		{"A" : "0xae967917c465db8578ca9024c205720b1a3651A9", "Valid": false},
+		{"A" : "0xAe967917c465db8578ca9024c205720b1a3651A9", "Valid": true},
+		{"A" : "0XAe967917c465db8578ca9024c205720b1a3651A9", "Valid": false},
+		{"A" : "0x1111111111111111111112222222222223333323", "Valid": true}
+		]`), &res); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, r := range res {
+		if got := r.A.ValidChecksum(); got != r.Valid {
+			t.Errorf("Expected checksum %v, got checksum %v, input %v", r.Valid, got, r.A.String())
+		}
+	}
+
+	//These should throw exceptions:
+	var r2 []MixedcaseAddress
+	for _, r := range []string{
+		`["0x11111111111111111111122222222222233333"]`,     // Too short
+		`["0x111111111111111111111222222222222333332"]`,    // Too short
+		`["0x11111111111111111111122222222222233333234"]`,  // Too long
+		`["0x111111111111111111111222222222222333332344"]`, // Too long
+		`["1111111111111111111112222222222223333323"]`,     // Missing 0x
+		`["x1111111111111111111112222222222223333323"]`,    // Missing 0
+		`["0xG111111111111111111112222222222223333323"]`,   //Non-hex
+	} {
+		if err := json.Unmarshal([]byte(r), &r2); err == nil {
+			t.Errorf("Expected failure, input %v", r)
+		}
+
+	}
+
+}
diff --git a/compression/rle/read_write.go b/compression/rle/read_write.go
deleted file mode 100644
index 0e7ad90aec..0000000000
--- a/compression/rle/read_write.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// Package rle implements the run-length encoding used for Ethereum data.
-package rle
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-const (
-	token             byte = 0xfe
-	emptyShaToken          = 0xfd
-	emptyListShaToken      = 0xfe
-	tokenToken             = 0xff
-)
-
-var empty = crypto.Keccak256([]byte(""))
-var emptyList = crypto.Keccak256([]byte{0x80})
-
-func Decompress(dat []byte) ([]byte, error) {
-	buf := new(bytes.Buffer)
-
-	for i := 0; i < len(dat); i++ {
-		if dat[i] == token {
-			if i+1 < len(dat) {
-				switch dat[i+1] {
-				case emptyShaToken:
-					buf.Write(empty)
-				case emptyListShaToken:
-					buf.Write(emptyList)
-				case tokenToken:
-					buf.WriteByte(token)
-				default:
-					buf.Write(make([]byte, int(dat[i+1]-2)))
-				}
-				i++
-			} else {
-				return nil, errors.New("error reading bytes. token encountered without proceeding bytes")
-			}
-		} else {
-			buf.WriteByte(dat[i])
-		}
-	}
-
-	return buf.Bytes(), nil
-}
-
-func compressChunk(dat []byte) (ret []byte, n int) {
-	switch {
-	case dat[0] == token:
-		return []byte{token, tokenToken}, 1
-	case len(dat) > 1 && dat[0] == 0x0 && dat[1] == 0x0:
-		j := 0
-		for j <= 254 && j < len(dat) {
-			if dat[j] != 0 {
-				break
-			}
-			j++
-		}
-		return []byte{token, byte(j + 2)}, j
-	case len(dat) >= 32:
-		if dat[0] == empty[0] && bytes.Equal(dat[:32], empty) {
-			return []byte{token, emptyShaToken}, 32
-		} else if dat[0] == emptyList[0] && bytes.Equal(dat[:32], emptyList) {
-			return []byte{token, emptyListShaToken}, 32
-		}
-		fallthrough
-	default:
-		return dat[:1], 1
-	}
-}
-
-func Compress(dat []byte) []byte {
-	buf := new(bytes.Buffer)
-
-	i := 0
-	for i < len(dat) {
-		b, n := compressChunk(dat[i:])
-		buf.Write(b)
-		i += n
-	}
-
-	return buf.Bytes()
-}
diff --git a/compression/rle/read_write_test.go b/compression/rle/read_write_test.go
deleted file mode 100644
index b36f7907bc..0000000000
--- a/compression/rle/read_write_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package rle
-
-import (
-	"testing"
-
-	checker "gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) { checker.TestingT(t) }
-
-type CompressionRleSuite struct{}
-
-var _ = checker.Suite(&CompressionRleSuite{})
-
-func (s *CompressionRleSuite) TestDecompressSimple(c *checker.C) {
-	exp := []byte{0xc5, 0xd2, 0x46, 0x1, 0x86, 0xf7, 0x23, 0x3c, 0x92, 0x7e, 0x7d, 0xb2, 0xdc, 0xc7, 0x3, 0xc0, 0xe5, 0x0, 0xb6, 0x53, 0xca, 0x82, 0x27, 0x3b, 0x7b, 0xfa, 0xd8, 0x4, 0x5d, 0x85, 0xa4, 0x70}
-	res, err := Decompress([]byte{token, 0xfd})
-	c.Assert(err, checker.IsNil)
-	c.Assert(res, checker.DeepEquals, exp)
-
-	exp = []byte{0x56, 0xe8, 0x1f, 0x17, 0x1b, 0xcc, 0x55, 0xa6, 0xff, 0x83, 0x45, 0xe6, 0x92, 0xc0, 0xf8, 0x6e, 0x5b, 0x48, 0xe0, 0x1b, 0x99, 0x6c, 0xad, 0xc0, 0x1, 0x62, 0x2f, 0xb5, 0xe3, 0x63, 0xb4, 0x21}
-	res, err = Decompress([]byte{token, 0xfe})
-	c.Assert(err, checker.IsNil)
-	c.Assert(res, checker.DeepEquals, exp)
-
-	res, err = Decompress([]byte{token, 0xff})
-	c.Assert(err, checker.IsNil)
-	c.Assert(res, checker.DeepEquals, []byte{token})
-
-	res, err = Decompress([]byte{token, 12})
-	c.Assert(err, checker.IsNil)
-	c.Assert(res, checker.DeepEquals, make([]byte, 10))
-
-}
diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go
index a980581417..01df4d5c78 100644
--- a/consensus/clique/clique.go
+++ b/consensus/clique/clique.go
@@ -383,7 +383,7 @@ func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash commo
 		// If an on-disk checkpoint snapshot can be found, use that
 		if number%checkpointInterval == 0 {
 			if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil {
-				log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash)
+				log.Trace("Loaded voting snapshot from disk", "number", number, "hash", hash)
 				snap = s
 				break
 			}
@@ -510,7 +510,6 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro
 	header.Nonce = types.BlockNonce{}
 
 	number := header.Number.Uint64()
-
 	// Assemble the voting snapshot to check which votes make sense
 	snap, err := c.snapshot(chain, number-1, header.ParentHash, nil)
 	if err != nil {
@@ -538,10 +537,8 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro
 		c.lock.RUnlock()
 	}
 	// Set the correct difficulty
-	header.Difficulty = diffNoTurn
-	if snap.inturn(header.Number.Uint64(), c.signer) {
-		header.Difficulty = diffInTurn
-	}
+	header.Difficulty = CalcDifficulty(snap, c.signer)
+
 	// Ensure the extra data has all it's components
 	if len(header.Extra) < extraVanity {
 		header.Extra = append(header.Extra, bytes.Repeat([]byte{0x00}, extraVanity-len(header.Extra))...)
@@ -655,6 +652,27 @@ func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop <-ch
 	return block.WithSeal(header), nil
 }
 
+// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty
+// that a new block should have based on the previous blocks in the chain and the
+// current signer.
+func (c *Clique) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int {
+	snap, err := c.snapshot(chain, parent.Number.Uint64(), parent.Hash(), nil)
+	if err != nil {
+		return nil
+	}
+	return CalcDifficulty(snap, c.signer)
+}
+
+// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty
+// that a new block should have based on the previous blocks in the chain and the
+// current signer.
+func CalcDifficulty(snap *Snapshot, signer common.Address) *big.Int {
+	if snap.inturn(snap.Number+1, signer) {
+		return new(big.Int).Set(diffInTurn)
+	}
+	return new(big.Int).Set(diffNoTurn)
+}
+
 // APIs implements consensus.Engine, returning the user facing RPC API to allow
 // controlling the signer voting.
 func (c *Clique) APIs(chain consensus.ChainReader) []rpc.API {
diff --git a/consensus/clique/snapshot_test.go b/consensus/clique/snapshot_test.go
index 8b51e6e094..29a8379832 100644
--- a/consensus/clique/snapshot_test.go
+++ b/consensus/clique/snapshot_test.go
@@ -24,6 +24,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -81,7 +82,7 @@ func (r *testerChainReader) GetBlock(common.Hash, uint64) *types.Block   { panic
 func (r *testerChainReader) GetHeaderByHash(common.Hash) *types.Header   { panic("not supported") }
 func (r *testerChainReader) GetHeaderByNumber(number uint64) *types.Header {
 	if number == 0 {
-		return core.GetHeader(r.db, core.GetCanonicalHash(r.db, 0), 0)
+		return rawdb.ReadHeader(r.db, rawdb.ReadCanonicalHash(r.db, 0), 0)
 	}
 	panic("not supported")
 }
@@ -351,7 +352,7 @@ func TestVoting(t *testing.T) {
 			copy(genesis.ExtraData[extraVanity+j*common.AddressLength:], signer[:])
 		}
 		// Create a pristine blockchain with the genesis injected
-		db, _ := ethdb.NewMemDatabase()
+		db := ethdb.NewMemDatabase()
 		genesis.Commit(db)
 
 		// Assemble a chain of headers from the cast votes
diff --git a/consensus/consensus.go b/consensus/consensus.go
index 865238cee0..5774af1a78 100644
--- a/consensus/consensus.go
+++ b/consensus/consensus.go
@@ -18,6 +18,8 @@
 package consensus
 
 import (
+	"math/big"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -88,6 +90,10 @@ type Engine interface {
 	// seal place on top.
 	Seal(chain ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error)
 
+	// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty
+	// that a new block should have.
+	CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int
+
 	// APIs returns the RPC APIs this consensus engine provides.
 	APIs(chain ChainReader) []rpc.API
 }
diff --git a/consensus/errors.go b/consensus/errors.go
index 3b136dbdd1..a005c5f63d 100644
--- a/consensus/errors.go
+++ b/consensus/errors.go
@@ -23,6 +23,10 @@ var (
 	// that is unknown.
 	ErrUnknownAncestor = errors.New("unknown ancestor")
 
+	// ErrPrunedAncestor is returned when validating a block requires an ancestor
+	// that is known, but the state of which is not available.
+	ErrPrunedAncestor = errors.New("pruned ancestor")
+
 	// ErrFutureBlock is returned when a block's timestamp is in the future according
 	// to the current node.
 	ErrFutureBlock = errors.New("block in the future")
diff --git a/consensus/ethash/algorithm.go b/consensus/ethash/algorithm.go
index 76f19252fa..fa1c2c8246 100644
--- a/consensus/ethash/algorithm.go
+++ b/consensus/ethash/algorithm.go
@@ -19,6 +19,7 @@ package ethash
 import (
 	"encoding/binary"
 	"hash"
+	"math/big"
 	"reflect"
 	"runtime"
 	"sync"
@@ -47,18 +48,71 @@ const (
 	loopAccesses       = 64      // Number of accesses in hashimoto loop
 )
 
+// cacheSize returns the size of the ethash verification cache that belongs to a certain
+// block number.
+func cacheSize(block uint64) uint64 {
+	epoch := int(block / epochLength)
+	if epoch < maxEpoch {
+		return cacheSizes[epoch]
+	}
+	return calcCacheSize(epoch)
+}
+
+// calcCacheSize calculates the cache size for epoch. The cache size grows linearly,
+// however, we always take the highest prime below the linearly growing threshold in order
+// to reduce the risk of accidental regularities leading to cyclic behavior.
+func calcCacheSize(epoch int) uint64 {
+	size := cacheInitBytes + cacheGrowthBytes*uint64(epoch) - hashBytes
+	for !new(big.Int).SetUint64(size / hashBytes).ProbablyPrime(1) { // Always accurate for n < 2^64
+		size -= 2 * hashBytes
+	}
+	return size
+}
+
+// datasetSize returns the size of the ethash mining dataset that belongs to a certain
+// block number.
+func datasetSize(block uint64) uint64 {
+	epoch := int(block / epochLength)
+	if epoch < maxEpoch {
+		return datasetSizes[epoch]
+	}
+	return calcDatasetSize(epoch)
+}
+
+// calcDatasetSize calculates the dataset size for epoch. The dataset size grows linearly,
+// however, we always take the highest prime below the linearly growing threshold in order
+// to reduce the risk of accidental regularities leading to cyclic behavior.
+func calcDatasetSize(epoch int) uint64 {
+	size := datasetInitBytes + datasetGrowthBytes*uint64(epoch) - mixBytes
+	for !new(big.Int).SetUint64(size / mixBytes).ProbablyPrime(1) { // Always accurate for n < 2^64
+		size -= 2 * mixBytes
+	}
+	return size
+}
+
 // hasher is a repetitive hasher allowing the same hash data structures to be
 // reused between hash runs instead of requiring new ones to be created.
 type hasher func(dest []byte, data []byte)
 
-// makeHasher creates a repetitive hasher, allowing the same hash data structures
-// to be reused between hash runs instead of requiring new ones to be created.
-// The returned function is not thread safe!
+// makeHasher creates a repetitive hasher, allowing the same hash data structures to
+// be reused between hash runs instead of requiring new ones to be created. The returned
+// function is not thread safe!
 func makeHasher(h hash.Hash) hasher {
+	// sha3.state supports Read to get the sum, use it to avoid the overhead of Sum.
+	// Read alters the state but we reset the hash before every operation.
+	type readerHash interface {
+		hash.Hash
+		Read([]byte) (int, error)
+	}
+	rh, ok := h.(readerHash)
+	if !ok {
+		panic("can't find Read method on hash")
+	}
+	outputLen := rh.Size()
 	return func(dest []byte, data []byte) {
-		h.Write(data)
-		h.Sum(dest[:0])
-		h.Reset()
+		rh.Reset()
+		rh.Write(data)
+		rh.Read(dest[:outputLen])
 	}
 }
 
@@ -355,9 +409,11 @@ func hashimotoFull(dataset []uint32, hash []byte, nonce uint64) ([]byte, []byte)
 	return hashimoto(hash, nonce, uint64(len(dataset))*4, lookup)
 }
 
+const maxEpoch = 2048
+
 // datasetSizes is a lookup table for the ethash dataset size for the first 2048
 // epochs (i.e. 61440000 blocks).
-var datasetSizes = []uint64{
+var datasetSizes = [maxEpoch]uint64{
 	1073739904, 1082130304, 1090514816, 1098906752, 1107293056,
 	1115684224, 1124070016, 1132461952, 1140849536, 1149232768,
 	1157627776, 1166013824, 1174404736, 1182786944, 1191180416,
@@ -771,7 +827,7 @@ var datasetSizes = []uint64{
 
 // cacheSizes is a lookup table for the ethash verification cache size for the
 // first 2048 epochs (i.e. 61440000 blocks).
-var cacheSizes = []uint64{
+var cacheSizes = [maxEpoch]uint64{
 	16776896, 16907456, 17039296, 17170112, 17301056, 17432512, 17563072,
 	17693888, 17824192, 17955904, 18087488, 18218176, 18349504, 18481088,
 	18611392, 18742336, 18874304, 19004224, 19135936, 19267264, 19398208,
diff --git a/consensus/ethash/algorithm_go1.7.go b/consensus/ethash/algorithm_go1.7.go
deleted file mode 100644
index c34d041c32..0000000000
--- a/consensus/ethash/algorithm_go1.7.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// +build !go1.8
-
-package ethash
-
-// cacheSize calculates and returns the size of the ethash verification cache that
-// belongs to a certain block number. The cache size grows linearly, however, we
-// always take the highest prime below the linearly growing threshold in order to
-// reduce the risk of accidental regularities leading to cyclic behavior.
-func cacheSize(block uint64) uint64 {
-	// If we have a pre-generated value, use that
-	epoch := int(block / epochLength)
-	if epoch < len(cacheSizes) {
-		return cacheSizes[epoch]
-	}
-	// We don't have a way to verify primes fast before Go 1.8
-	panic("fast prime testing unsupported in Go < 1.8")
-}
-
-// datasetSize calculates and returns the size of the ethash mining dataset that
-// belongs to a certain block number. The dataset size grows linearly, however, we
-// always take the highest prime below the linearly growing threshold in order to
-// reduce the risk of accidental regularities leading to cyclic behavior.
-func datasetSize(block uint64) uint64 {
-	// If we have a pre-generated value, use that
-	epoch := int(block / epochLength)
-	if epoch < len(datasetSizes) {
-		return datasetSizes[epoch]
-	}
-	// We don't have a way to verify primes fast before Go 1.8
-	panic("fast prime testing unsupported in Go < 1.8")
-}
diff --git a/consensus/ethash/algorithm_go1.8.go b/consensus/ethash/algorithm_go1.8.go
deleted file mode 100644
index d691b758f0..0000000000
--- a/consensus/ethash/algorithm_go1.8.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// +build go1.8
-
-package ethash
-
-import "math/big"
-
-// cacheSize calculates and returns the size of the ethash verification cache that
-// belongs to a certain block number. The cache size grows linearly, however, we
-// always take the highest prime below the linearly growing threshold in order to
-// reduce the risk of accidental regularities leading to cyclic behavior.
-func cacheSize(block uint64) uint64 {
-	// If we have a pre-generated value, use that
-	epoch := int(block / epochLength)
-	if epoch < len(cacheSizes) {
-		return cacheSizes[epoch]
-	}
-	// No known cache size, calculate manually (sanity branch only)
-	size := cacheInitBytes + cacheGrowthBytes*uint64(epoch) - hashBytes
-	for !new(big.Int).SetUint64(size / hashBytes).ProbablyPrime(1) { // Always accurate for n < 2^64
-		size -= 2 * hashBytes
-	}
-	return size
-}
-
-// datasetSize calculates and returns the size of the ethash mining dataset that
-// belongs to a certain block number. The dataset size grows linearly, however, we
-// always take the highest prime below the linearly growing threshold in order to
-// reduce the risk of accidental regularities leading to cyclic behavior.
-func datasetSize(block uint64) uint64 {
-	// If we have a pre-generated value, use that
-	epoch := int(block / epochLength)
-	if epoch < len(datasetSizes) {
-		return datasetSizes[epoch]
-	}
-	// No known dataset size, calculate manually (sanity branch only)
-	size := datasetInitBytes + datasetGrowthBytes*uint64(epoch) - mixBytes
-	for !new(big.Int).SetUint64(size / mixBytes).ProbablyPrime(1) { // Always accurate for n < 2^64
-		size -= 2 * mixBytes
-	}
-	return size
-}
diff --git a/consensus/ethash/algorithm_go1.8_test.go b/consensus/ethash/algorithm_go1.8_test.go
deleted file mode 100644
index a822944a60..0000000000
--- a/consensus/ethash/algorithm_go1.8_test.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// +build go1.8
-
-package ethash
-
-import "testing"
-
-// Tests whether the dataset size calculator works correctly by cross checking the
-// hard coded lookup table with the value generated by it.
-func TestSizeCalculations(t *testing.T) {
-	var tests []uint64
-
-	// Verify all the cache sizes from the lookup table
-	defer func(sizes []uint64) { cacheSizes = sizes }(cacheSizes)
-	tests, cacheSizes = cacheSizes, []uint64{}
-
-	for i, test := range tests {
-		if size := cacheSize(uint64(i*epochLength) + 1); size != test {
-			t.Errorf("cache %d: cache size mismatch: have %d, want %d", i, size, test)
-		}
-	}
-	// Verify all the dataset sizes from the lookup table
-	defer func(sizes []uint64) { datasetSizes = sizes }(datasetSizes)
-	tests, datasetSizes = datasetSizes, []uint64{}
-
-	for i, test := range tests {
-		if size := datasetSize(uint64(i*epochLength) + 1); size != test {
-			t.Errorf("dataset %d: dataset size mismatch: have %d, want %d", i, size, test)
-		}
-	}
-}
diff --git a/consensus/ethash/algorithm_test.go b/consensus/ethash/algorithm_test.go
index 7765ff9fe6..841e39233f 100644
--- a/consensus/ethash/algorithm_test.go
+++ b/consensus/ethash/algorithm_test.go
@@ -30,6 +30,22 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
+// Tests whether the dataset size calculator works correctly by cross checking the
+// hard coded lookup table with the value generated by it.
+func TestSizeCalculations(t *testing.T) {
+	// Verify all the cache and dataset sizes from the lookup table.
+	for epoch, want := range cacheSizes {
+		if size := calcCacheSize(epoch); size != want {
+			t.Errorf("cache %d: cache size mismatch: have %d, want %d", epoch, size, want)
+		}
+	}
+	for epoch, want := range datasetSizes {
+		if size := calcDatasetSize(epoch); size != want {
+			t.Errorf("dataset %d: dataset size mismatch: have %d, want %d", epoch, size, want)
+		}
+	}
+}
+
 // Tests that verification caches can be correctly generated.
 func TestCacheGeneration(t *testing.T) {
 	tests := []struct {
@@ -688,8 +704,8 @@ func TestConcurrentDiskCacheGeneration(t *testing.T) {
 		TxHash:      common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
 		ReceiptHash: common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
 		Difficulty:  big.NewInt(167925187834220),
-		GasLimit:    big.NewInt(4015682),
-		GasUsed:     big.NewInt(0),
+		GasLimit:    4015682,
+		GasUsed:     0,
 		Time:        big.NewInt(1488928920),
 		Extra:       []byte("www.bw.com"),
 		MixDigest:   common.HexToHash("0x3e140b0784516af5e5ec6730f2fb20cca22f32be399b9e4ad77d32541f798cd0"),
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index 2bdb18677e..99eec82211 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -53,7 +53,6 @@ var (
 	errDuplicateUncle    = errors.New("duplicate uncle")
 	errUncleIsAncestor   = errors.New("uncle is ancestor")
 	errDanglingUncle     = errors.New("uncle's parent is not ancestor")
-	errNonceOutOfRange   = errors.New("nonce out of range")
 	errInvalidDifficulty = errors.New("non-positive difficulty")
 	errInvalidMixDigest  = errors.New("invalid mix digest")
 	errInvalidPoW        = errors.New("invalid proof-of-work")
@@ -240,29 +239,30 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *
 		return errZeroBlockTime
 	}
 	// Verify the block's difficulty based in it's timestamp and parent's difficulty
-	expected := CalcDifficulty(chain.Config(), header.Time.Uint64(), parent)
+	expected := ethash.CalcDifficulty(chain, header.Time.Uint64(), parent)
+
 	if expected.Cmp(header.Difficulty) != 0 {
 		return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
 	}
 	// Verify that the gas limit is <= 2^63-1
-	if header.GasLimit.Cmp(math.MaxBig63) > 0 {
-		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, math.MaxBig63)
+	cap := uint64(0x7fffffffffffffff)
+	if header.GasLimit > cap {
+		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap)
 	}
 	// Verify that the gasUsed is <= gasLimit
-	if header.GasUsed.Cmp(header.GasLimit) > 0 {
-		return fmt.Errorf("invalid gasUsed: have %v, gasLimit %v", header.GasUsed, header.GasLimit)
+	if header.GasUsed > header.GasLimit {
+		return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
 	}
 
 	// Verify that the gas limit remains within allowed bounds
-	diff := new(big.Int).Set(parent.GasLimit)
-	diff = diff.Sub(diff, header.GasLimit)
-	diff.Abs(diff)
+	diff := int64(parent.GasLimit) - int64(header.GasLimit)
+	if diff < 0 {
+		diff *= -1
+	}
+	limit := parent.GasLimit / params.GasLimitBoundDivisor
 
-	limit := new(big.Int).Set(parent.GasLimit)
-	limit = limit.Div(limit, params.GasLimitBoundDivisor)
-
-	if diff.Cmp(limit) >= 0 || header.GasLimit.Cmp(params.MinGasLimit) < 0 {
-		return fmt.Errorf("invalid gas limit: have %v, want %v += %v", header.GasLimit, parent.GasLimit, limit)
+	if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit {
+		return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit)
 	}
 	// Verify that the block number is parent's +1
 	if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
@@ -287,7 +287,13 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *
 // CalcDifficulty is the difficulty adjustment algorithm. It returns
 // the difficulty that a new block should have when created at time
 // given the parent block's time and difficulty.
-// TODO (karalabe): Move the chain maker into this package and make this private!
+func (ethash *Ethash) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int {
+	return CalcDifficulty(chain.Config(), time, parent)
+}
+
+// CalcDifficulty is the difficulty adjustment algorithm. It returns
+// the difficulty that a new block should have when created at time
+// given the parent block's time and difficulty.
 func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
 	next := new(big.Int).Add(parent.Number, big1)
 	switch {
@@ -340,7 +346,7 @@ func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
 	if x.Cmp(bigMinus99) < 0 {
 		x.Set(bigMinus99)
 	}
-	// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
+	// parent_diff + (parent_diff / 2048 * max((2 if len(parent.uncles) else 1) - ((timestamp - parent.timestamp) // 9), -99))
 	y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
 	x.Mul(y, x)
 	x.Add(parent.Difficulty, x)
@@ -349,7 +355,7 @@ func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
 	if x.Cmp(params.MinimumDifficulty) < 0 {
 		x.Set(params.MinimumDifficulty)
 	}
-	// calculate a fake block numer for the ice-age delay:
+	// calculate a fake block number for the ice-age delay:
 	//   https://github.com/ethereum/EIPs/pull/669
 	//   fake_block_number = min(0, block.number - 3_000_000
 	fakeBlockNumber := new(big.Int)
@@ -374,7 +380,7 @@ func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int {
 // the difficulty that a new block should have when created at time given the
 // parent block's time and difficulty. The calculation uses the Homestead rules.
 func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
-	// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.mediawiki
+	// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md
 	// algorithm:
 	// diff = (parent_diff +
 	//         (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
@@ -467,24 +473,23 @@ func (ethash *Ethash) VerifySeal(chain consensus.ChainReader, header *types.Head
 	if ethash.shared != nil {
 		return ethash.shared.VerifySeal(chain, header)
 	}
-	// Sanity check that the block number is below the lookup table size (60M blocks)
-	number := header.Number.Uint64()
-	if number/epochLength >= uint64(len(cacheSizes)) {
-		// Go < 1.7 cannot calculate new cache/dataset sizes (no fast prime check)
-		return errNonceOutOfRange
-	}
 	// Ensure that we have a valid difficulty for the block
 	if header.Difficulty.Sign() <= 0 {
 		return errInvalidDifficulty
 	}
 	// Recompute the digest and PoW value and verify against the header
-	cache := ethash.cache(number)
+	number := header.Number.Uint64()
 
+	cache := ethash.cache(number)
 	size := datasetSize(number)
 	if ethash.config.PowMode == ModeTest {
 		size = 32 * 1024
 	}
-	digest, result := hashimotoLight(size, cache, header.HashNoNonce().Bytes(), header.Nonce.Uint64())
+	digest, result := hashimotoLight(size, cache.cache, header.HashNoNonce().Bytes(), header.Nonce.Uint64())
+	// Caches are unmapped in a finalizer. Ensure that the cache stays live
+	// until after the call to hashimotoLight so it's not unmapped while being used.
+	runtime.KeepAlive(cache)
+
 	if !bytes.Equal(header.MixDigest[:], digest) {
 		return errInvalidMixDigest
 	}
@@ -502,8 +507,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header)
 	if parent == nil {
 		return consensus.ErrUnknownAncestor
 	}
-	header.Difficulty = CalcDifficulty(chain.Config(), header.Time.Uint64(), parent)
-
+	header.Difficulty = ethash.CalcDifficulty(chain, header.Time.Uint64(), parent)
 	return nil
 }
 
@@ -511,7 +515,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header)
 // setting the final state and assembling the block.
 func (ethash *Ethash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
 	// Accumulate any block and uncle rewards and commit the final state root
-	AccumulateRewards(chain.Config(), state, header, uncles)
+	accumulateRewards(chain.Config(), state, header, uncles)
 	header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
 
 	// Header seems complete, assemble into a block and return
@@ -527,8 +531,7 @@ var (
 // AccumulateRewards credits the coinbase of the given block with the mining
 // reward. The total reward consists of the static block reward and rewards for
 // included uncles. The coinbase of each uncle block is also rewarded.
-// TODO (karalabe): Move the chain maker into this package and make this private!
-func AccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
+func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
 	// Select the correct block reward based on chain progression
 	blockReward := FrontierBlockReward
 	if config.IsByzantium(header.Number) {
diff --git a/consensus/ethash/consensus_test.go b/consensus/ethash/consensus_test.go
index a58d220efa..438a99dd66 100644
--- a/consensus/ethash/consensus_test.go
+++ b/consensus/ethash/consensus_test.go
@@ -71,6 +71,7 @@ func TestCalcDifficulty(t *testing.T) {
 	}
 
 	config := ¶ms.ChainConfig{HomesteadBlock: big.NewInt(1150000)}
+
 	for name, test := range tests {
 		number := new(big.Int).Sub(test.CurrentBlocknumber, big.NewInt(1))
 		diff := CalcDifficulty(config, test.CurrentTimestamp, &types.Header{
diff --git a/consensus/ethash/ethash.go b/consensus/ethash/ethash.go
index a78b3a895d..ac049f9c36 100644
--- a/consensus/ethash/ethash.go
+++ b/consensus/ethash/ethash.go
@@ -26,6 +26,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"strconv"
 	"sync"
 	"time"
@@ -34,8 +35,9 @@ import (
 	mmap "github.com/edsrzf/mmap-go"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/rpc"
-	metrics "github.com/rcrowley/go-metrics"
+	"github.com/hashicorp/golang-lru/simplelru"
 )
 
 var ErrInvalidDumpMagic = errors.New("invalid dump magic")
@@ -142,32 +144,82 @@ func memoryMapAndGenerate(path string, size uint64, generator func(buffer []uint
 	return memoryMap(path)
 }
 
+// lru tracks caches or datasets by their last use time, keeping at most N of them.
+type lru struct {
+	what string
+	new  func(epoch uint64) interface{}
+	mu   sync.Mutex
+	// Items are kept in a LRU cache, but there is a special case:
+	// We always keep an item for (highest seen epoch) + 1 as the 'future item'.
+	cache      *simplelru.LRU
+	future     uint64
+	futureItem interface{}
+}
+
+// newlru create a new least-recently-used cache for either the verification caches
+// or the mining datasets.
+func newlru(what string, maxItems int, new func(epoch uint64) interface{}) *lru {
+	if maxItems <= 0 {
+		maxItems = 1
+	}
+	cache, _ := simplelru.NewLRU(maxItems, func(key, value interface{}) {
+		log.Trace("Evicted ethash "+what, "epoch", key)
+	})
+	return &lru{what: what, new: new, cache: cache}
+}
+
+// get retrieves or creates an item for the given epoch. The first return value is always
+// non-nil. The second return value is non-nil if lru thinks that an item will be useful in
+// the near future.
+func (lru *lru) get(epoch uint64) (item, future interface{}) {
+	lru.mu.Lock()
+	defer lru.mu.Unlock()
+
+	// Get or create the item for the requested epoch.
+	item, ok := lru.cache.Get(epoch)
+	if !ok {
+		if lru.future > 0 && lru.future == epoch {
+			item = lru.futureItem
+		} else {
+			log.Trace("Requiring new ethash "+lru.what, "epoch", epoch)
+			item = lru.new(epoch)
+		}
+		lru.cache.Add(epoch, item)
+	}
+	// Update the 'future item' if epoch is larger than previously seen.
+	if epoch < maxEpoch-1 && lru.future < epoch+1 {
+		log.Trace("Requiring new future ethash "+lru.what, "epoch", epoch+1)
+		future = lru.new(epoch + 1)
+		lru.future = epoch + 1
+		lru.futureItem = future
+	}
+	return item, future
+}
+
 // cache wraps an ethash cache with some metadata to allow easier concurrent use.
 type cache struct {
-	epoch uint64 // Epoch for which this cache is relevant
+	epoch uint64    // Epoch for which this cache is relevant
+	dump  *os.File  // File descriptor of the memory mapped cache
+	mmap  mmap.MMap // Memory map itself to unmap before releasing
+	cache []uint32  // The actual cache data content (may be memory mapped)
+	once  sync.Once // Ensures the cache is generated only once
+}
 
-	dump *os.File  // File descriptor of the memory mapped cache
-	mmap mmap.MMap // Memory map itself to unmap before releasing
-
-	cache []uint32   // The actual cache data content (may be memory mapped)
-	used  time.Time  // Timestamp of the last use for smarter eviction
-	once  sync.Once  // Ensures the cache is generated only once
-	lock  sync.Mutex // Ensures thread safety for updating the usage time
+// newCache creates a new ethash verification cache and returns it as a plain Go
+// interface to be usable in an LRU cache.
+func newCache(epoch uint64) interface{} {
+	return &cache{epoch: epoch}
 }
 
 // generate ensures that the cache content is generated before use.
 func (c *cache) generate(dir string, limit int, test bool) {
 	c.once.Do(func() {
-		// If we have a testing cache, generate and return
-		if test {
-			c.cache = make([]uint32, 1024/4)
-			generateCache(c.cache, c.epoch, seedHash(c.epoch*epochLength+1))
-			return
-		}
-		// If we don't store anything on disk, generate and return
 		size := cacheSize(c.epoch*epochLength + 1)
 		seed := seedHash(c.epoch*epochLength + 1)
-
+		if test {
+			size = 1024
+		}
+		// If we don't store anything on disk, generate and return.
 		if dir == "" {
 			c.cache = make([]uint32, size/4)
 			generateCache(c.cache, c.epoch, seed)
@@ -181,6 +233,10 @@ func (c *cache) generate(dir string, limit int, test bool) {
 		path := filepath.Join(dir, fmt.Sprintf("cache-R%d-%x%s", algorithmRevision, seed[:8], endian))
 		logger := log.New("epoch", c.epoch)
 
+		// We're about to mmap the file, ensure that the mapping is cleaned up when the
+		// cache becomes unused.
+		runtime.SetFinalizer(c, (*cache).finalizer)
+
 		// Try to load the file from disk and memory map it
 		var err error
 		c.dump, c.mmap, c.cache, err = memoryMap(path)
@@ -207,49 +263,41 @@ func (c *cache) generate(dir string, limit int, test bool) {
 	})
 }
 
-// release closes any file handlers and memory maps open.
-func (c *cache) release() {
+// finalizer unmaps the memory and closes the file.
+func (c *cache) finalizer() {
 	if c.mmap != nil {
 		c.mmap.Unmap()
-		c.mmap = nil
-	}
-	if c.dump != nil {
 		c.dump.Close()
-		c.dump = nil
+		c.mmap, c.dump = nil, nil
 	}
 }
 
 // dataset wraps an ethash dataset with some metadata to allow easier concurrent use.
 type dataset struct {
-	epoch uint64 // Epoch for which this cache is relevant
+	epoch   uint64    // Epoch for which this cache is relevant
+	dump    *os.File  // File descriptor of the memory mapped cache
+	mmap    mmap.MMap // Memory map itself to unmap before releasing
+	dataset []uint32  // The actual cache data content
+	once    sync.Once // Ensures the cache is generated only once
+}
 
-	dump *os.File  // File descriptor of the memory mapped cache
-	mmap mmap.MMap // Memory map itself to unmap before releasing
-
-	dataset []uint32   // The actual cache data content
-	used    time.Time  // Timestamp of the last use for smarter eviction
-	once    sync.Once  // Ensures the cache is generated only once
-	lock    sync.Mutex // Ensures thread safety for updating the usage time
+// newDataset creates a new ethash mining dataset and returns it as a plain Go
+// interface to be usable in an LRU cache.
+func newDataset(epoch uint64) interface{} {
+	return &dataset{epoch: epoch}
 }
 
 // generate ensures that the dataset content is generated before use.
 func (d *dataset) generate(dir string, limit int, test bool) {
 	d.once.Do(func() {
-		// If we have a testing dataset, generate and return
-		if test {
-			cache := make([]uint32, 1024/4)
-			generateCache(cache, d.epoch, seedHash(d.epoch*epochLength+1))
-
-			d.dataset = make([]uint32, 32*1024/4)
-			generateDataset(d.dataset, d.epoch, cache)
-
-			return
-		}
-		// If we don't store anything on disk, generate and return
 		csize := cacheSize(d.epoch*epochLength + 1)
 		dsize := datasetSize(d.epoch*epochLength + 1)
 		seed := seedHash(d.epoch*epochLength + 1)
-
+		if test {
+			csize = 1024
+			dsize = 32 * 1024
+		}
+		// If we don't store anything on disk, generate and return
 		if dir == "" {
 			cache := make([]uint32, csize/4)
 			generateCache(cache, d.epoch, seed)
@@ -265,6 +313,10 @@ func (d *dataset) generate(dir string, limit int, test bool) {
 		path := filepath.Join(dir, fmt.Sprintf("full-R%d-%x%s", algorithmRevision, seed[:8], endian))
 		logger := log.New("epoch", d.epoch)
 
+		// We're about to mmap the file, ensure that the mapping is cleaned up when the
+		// cache becomes unused.
+		runtime.SetFinalizer(d, (*dataset).finalizer)
+
 		// Try to load the file from disk and memory map it
 		var err error
 		d.dump, d.mmap, d.dataset, err = memoryMap(path)
@@ -294,15 +346,12 @@ func (d *dataset) generate(dir string, limit int, test bool) {
 	})
 }
 
-// release closes any file handlers and memory maps open.
-func (d *dataset) release() {
+// finalizer closes any file handlers and memory maps open.
+func (d *dataset) finalizer() {
 	if d.mmap != nil {
 		d.mmap.Unmap()
-		d.mmap = nil
-	}
-	if d.dump != nil {
 		d.dump.Close()
-		d.dump = nil
+		d.mmap, d.dump = nil, nil
 	}
 }
 
@@ -310,14 +359,12 @@ func (d *dataset) release() {
 func MakeCache(block uint64, dir string) {
 	c := cache{epoch: block / epochLength}
 	c.generate(dir, math.MaxInt32, false)
-	c.release()
 }
 
 // MakeDataset generates a new ethash dataset and optionally stores it to disk.
 func MakeDataset(block uint64, dir string) {
 	d := dataset{epoch: block / epochLength}
 	d.generate(dir, math.MaxInt32, false)
-	d.release()
 }
 
 // Mode defines the type and amount of PoW verification an ethash engine makes.
@@ -347,10 +394,8 @@ type Config struct {
 type Ethash struct {
 	config Config
 
-	caches   map[uint64]*cache   // In memory caches to avoid regenerating too often
-	fcache   *cache              // Pre-generated cache for the estimated future epoch
-	datasets map[uint64]*dataset // In memory datasets to avoid regenerating too often
-	fdataset *dataset            // Pre-generated dataset for the estimated future epoch
+	caches   *lru // In memory caches to avoid regenerating too often
+	datasets *lru // In memory datasets to avoid regenerating too often
 
 	// Mining related fields
 	rand     *rand.Rand    // Properly seeded random source for nonces
@@ -380,8 +425,8 @@ func New(config Config) *Ethash {
 	}
 	return &Ethash{
 		config:   config,
-		caches:   make(map[uint64]*cache),
-		datasets: make(map[uint64]*dataset),
+		caches:   newlru("cache", config.CachesInMem, newCache),
+		datasets: newlru("dataset", config.DatasetsInMem, newDataset),
 		update:   make(chan struct{}),
 		hashrate: metrics.NewMeter(),
 	}
@@ -390,16 +435,7 @@ func New(config Config) *Ethash {
 // NewTester creates a small sized ethash PoW scheme useful only for testing
 // purposes.
 func NewTester() *Ethash {
-	return &Ethash{
-		config: Config{
-			CachesInMem: 1,
-			PowMode:     ModeTest,
-		},
-		caches:   make(map[uint64]*cache),
-		datasets: make(map[uint64]*dataset),
-		update:   make(chan struct{}),
-		hashrate: metrics.NewMeter(),
-	}
+	return New(Config{CachesInMem: 1, PowMode: ModeTest})
 }
 
 // NewFaker creates a ethash consensus engine with a fake PoW scheme that accepts
@@ -456,126 +492,40 @@ func NewShared() *Ethash {
 // cache tries to retrieve a verification cache for the specified block number
 // by first checking against a list of in-memory caches, then against caches
 // stored on disk, and finally generating one if none can be found.
-func (ethash *Ethash) cache(block uint64) []uint32 {
+func (ethash *Ethash) cache(block uint64) *cache {
 	epoch := block / epochLength
+	currentI, futureI := ethash.caches.get(epoch)
+	current := currentI.(*cache)
 
-	// If we have a PoW for that epoch, use that
-	ethash.lock.Lock()
-
-	current, future := ethash.caches[epoch], (*cache)(nil)
-	if current == nil {
-		// No in-memory cache, evict the oldest if the cache limit was reached
-		for len(ethash.caches) > 0 && len(ethash.caches) >= ethash.config.CachesInMem {
-			var evict *cache
-			for _, cache := range ethash.caches {
-				if evict == nil || evict.used.After(cache.used) {
-					evict = cache
-				}
-			}
-			delete(ethash.caches, evict.epoch)
-			evict.release()
-
-			log.Trace("Evicted ethash cache", "epoch", evict.epoch, "used", evict.used)
-		}
-		// If we have the new cache pre-generated, use that, otherwise create a new one
-		if ethash.fcache != nil && ethash.fcache.epoch == epoch {
-			log.Trace("Using pre-generated cache", "epoch", epoch)
-			current, ethash.fcache = ethash.fcache, nil
-		} else {
-			log.Trace("Requiring new ethash cache", "epoch", epoch)
-			current = &cache{epoch: epoch}
-		}
-		ethash.caches[epoch] = current
-
-		// If we just used up the future cache, or need a refresh, regenerate
-		if ethash.fcache == nil || ethash.fcache.epoch <= epoch {
-			if ethash.fcache != nil {
-				ethash.fcache.release()
-			}
-			log.Trace("Requiring new future ethash cache", "epoch", epoch+1)
-			future = &cache{epoch: epoch + 1}
-			ethash.fcache = future
-		}
-		// New current cache, set its initial timestamp
-		current.used = time.Now()
-	}
-	ethash.lock.Unlock()
-
-	// Wait for generation finish, bump the timestamp and finalize the cache
+	// Wait for generation finish.
 	current.generate(ethash.config.CacheDir, ethash.config.CachesOnDisk, ethash.config.PowMode == ModeTest)
 
-	current.lock.Lock()
-	current.used = time.Now()
-	current.lock.Unlock()
-
-	// If we exhausted the future cache, now's a good time to regenerate it
-	if future != nil {
+	// If we need a new future cache, now's a good time to regenerate it.
+	if futureI != nil {
+		future := futureI.(*cache)
 		go future.generate(ethash.config.CacheDir, ethash.config.CachesOnDisk, ethash.config.PowMode == ModeTest)
 	}
-	return current.cache
+	return current
 }
 
 // dataset tries to retrieve a mining dataset for the specified block number
 // by first checking against a list of in-memory datasets, then against DAGs
 // stored on disk, and finally generating one if none can be found.
-func (ethash *Ethash) dataset(block uint64) []uint32 {
+func (ethash *Ethash) dataset(block uint64) *dataset {
 	epoch := block / epochLength
+	currentI, futureI := ethash.datasets.get(epoch)
+	current := currentI.(*dataset)
 
-	// If we have a PoW for that epoch, use that
-	ethash.lock.Lock()
-
-	current, future := ethash.datasets[epoch], (*dataset)(nil)
-	if current == nil {
-		// No in-memory dataset, evict the oldest if the dataset limit was reached
-		for len(ethash.datasets) > 0 && len(ethash.datasets) >= ethash.config.DatasetsInMem {
-			var evict *dataset
-			for _, dataset := range ethash.datasets {
-				if evict == nil || evict.used.After(dataset.used) {
-					evict = dataset
-				}
-			}
-			delete(ethash.datasets, evict.epoch)
-			evict.release()
-
-			log.Trace("Evicted ethash dataset", "epoch", evict.epoch, "used", evict.used)
-		}
-		// If we have the new cache pre-generated, use that, otherwise create a new one
-		if ethash.fdataset != nil && ethash.fdataset.epoch == epoch {
-			log.Trace("Using pre-generated dataset", "epoch", epoch)
-			current = &dataset{epoch: ethash.fdataset.epoch} // Reload from disk
-			ethash.fdataset = nil
-		} else {
-			log.Trace("Requiring new ethash dataset", "epoch", epoch)
-			current = &dataset{epoch: epoch}
-		}
-		ethash.datasets[epoch] = current
-
-		// If we just used up the future dataset, or need a refresh, regenerate
-		if ethash.fdataset == nil || ethash.fdataset.epoch <= epoch {
-			if ethash.fdataset != nil {
-				ethash.fdataset.release()
-			}
-			log.Trace("Requiring new future ethash dataset", "epoch", epoch+1)
-			future = &dataset{epoch: epoch + 1}
-			ethash.fdataset = future
-		}
-		// New current dataset, set its initial timestamp
-		current.used = time.Now()
-	}
-	ethash.lock.Unlock()
-
-	// Wait for generation finish, bump the timestamp and finalize the cache
+	// Wait for generation finish.
 	current.generate(ethash.config.DatasetDir, ethash.config.DatasetsOnDisk, ethash.config.PowMode == ModeTest)
 
-	current.lock.Lock()
-	current.used = time.Now()
-	current.lock.Unlock()
-
-	// If we exhausted the future dataset, now's a good time to regenerate it
-	if future != nil {
+	// If we need a new future dataset, now's a good time to regenerate it.
+	if futureI != nil {
+		future := futureI.(*dataset)
 		go future.generate(ethash.config.DatasetDir, ethash.config.DatasetsOnDisk, ethash.config.PowMode == ModeTest)
 	}
-	return current.dataset
+
+	return current
 }
 
 // Threads returns the number of mining threads currently enabled. This doesn't
diff --git a/consensus/ethash/ethash_test.go b/consensus/ethash/ethash_test.go
index b3a2f32f70..31116da437 100644
--- a/consensus/ethash/ethash_test.go
+++ b/consensus/ethash/ethash_test.go
@@ -17,7 +17,11 @@
 package ethash
 
 import (
+	"io/ioutil"
 	"math/big"
+	"math/rand"
+	"os"
+	"sync"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/core/types"
@@ -38,3 +42,38 @@ func TestTestMode(t *testing.T) {
 		t.Fatalf("unexpected verification error: %v", err)
 	}
 }
+
+// This test checks that cache lru logic doesn't crash under load.
+// It reproduces https://github.com/ethereum/go-ethereum/issues/14943
+func TestCacheFileEvict(t *testing.T) {
+	tmpdir, err := ioutil.TempDir("", "ethash-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
+	e := New(Config{CachesInMem: 3, CachesOnDisk: 10, CacheDir: tmpdir, PowMode: ModeTest})
+
+	workers := 8
+	epochs := 100
+	var wg sync.WaitGroup
+	wg.Add(workers)
+	for i := 0; i < workers; i++ {
+		go verifyTest(&wg, e, i, epochs)
+	}
+	wg.Wait()
+}
+
+func verifyTest(wg *sync.WaitGroup, e *Ethash, workerIndex, epochs int) {
+	defer wg.Done()
+
+	const wiggle = 4 * epochLength
+	r := rand.New(rand.NewSource(int64(workerIndex)))
+	for epoch := 0; epoch < epochs; epoch++ {
+		block := int64(epoch)*epochLength - wiggle/2 + r.Int63n(wiggle)
+		if block < 0 {
+			block = 0
+		}
+		head := &types.Header{Number: big.NewInt(block), Difficulty: big.NewInt(100)}
+		e.VerifySeal(nil, head)
+	}
+}
diff --git a/consensus/ethash/sealer.go b/consensus/ethash/sealer.go
index c2447e4730..b5e742d8bb 100644
--- a/consensus/ethash/sealer.go
+++ b/consensus/ethash/sealer.go
@@ -97,10 +97,9 @@ func (ethash *Ethash) Seal(chain consensus.ChainReader, block *types.Block, stop
 func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan struct{}, found chan *types.Block) {
 	// Extract some data from the header
 	var (
-		header = block.Header()
-		hash   = header.HashNoNonce().Bytes()
-		target = new(big.Int).Div(maxUint256, header.Difficulty)
-
+		header  = block.Header()
+		hash    = header.HashNoNonce().Bytes()
+		target  = new(big.Int).Div(maxUint256, header.Difficulty)
 		number  = header.Number.Uint64()
 		dataset = ethash.dataset(number)
 	)
@@ -111,13 +110,14 @@ func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan s
 	)
 	logger := log.New("miner", id)
 	logger.Trace("Started ethash search for new nonces", "seed", seed)
+search:
 	for {
 		select {
 		case <-abort:
 			// Mining terminated, update stats and abort
 			logger.Trace("Ethash nonce search aborted", "attempts", nonce-seed)
 			ethash.hashrate.Mark(attempts)
-			return
+			break search
 
 		default:
 			// We don't have to update hash rate on every nonce, so update after after 2^X nonces
@@ -127,7 +127,7 @@ func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan s
 				attempts = 0
 			}
 			// Compute the PoW value of this nonce
-			digest, result := hashimotoFull(dataset, hash, nonce)
+			digest, result := hashimotoFull(dataset.dataset, hash, nonce)
 			if new(big.Int).SetBytes(result).Cmp(target) <= 0 {
 				// Correct nonce found, create a new header with it
 				header = types.CopyHeader(header)
@@ -141,9 +141,12 @@ func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan s
 				case <-abort:
 					logger.Trace("Ethash nonce found but discarded", "attempts", nonce-seed, "nonce", nonce)
 				}
-				return
+				break search
 			}
 			nonce++
 		}
 	}
+	// Datasets are unmapped in a finalizer. Ensure that the dataset stays live
+	// during sealing so it's not unmapped while being read.
+	runtime.KeepAlive(dataset)
 }
diff --git a/console/bridge.go b/console/bridge.go
index b28cc438e2..b0b4d37985 100644
--- a/console/bridge.go
+++ b/console/bridge.go
@@ -87,7 +87,7 @@ func (b *bridge) NewAccount(call otto.FunctionCall) (response otto.Value) {
 // OpenWallet is a wrapper around personal.openWallet which can interpret and
 // react to certain error messages, such as the Trezor PIN matrix request.
 func (b *bridge) OpenWallet(call otto.FunctionCall) (response otto.Value) {
-	// Make sure we have an wallet specified to open
+	// Make sure we have a wallet specified to open
 	if !call.Argument(0).IsString() {
 		throwJSException("first argument must be the wallet URL to open")
 	}
@@ -271,7 +271,7 @@ func (b *bridge) SleepBlocks(call otto.FunctionCall) (response otto.Value) {
 }
 
 type jsonrpcCall struct {
-	Id     int64
+	ID     int64
 	Method string
 	Params []interface{}
 }
@@ -304,7 +304,7 @@ func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) {
 	resps, _ := call.Otto.Object("new Array()")
 	for _, req := range reqs {
 		resp, _ := call.Otto.Object(`({"jsonrpc":"2.0"})`)
-		resp.Set("id", req.Id)
+		resp.Set("id", req.ID)
 		var result json.RawMessage
 		err = b.client.Call(&result, req.Method, req.Params...)
 		switch err := err.(type) {
diff --git a/console/console.go b/console/console.go
index 1ecbfd0b0f..56e03837ac 100644
--- a/console/console.go
+++ b/console/console.go
@@ -26,6 +26,7 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"syscall"
 
 	"github.com/ethereum/go-ethereum/internal/jsre"
 	"github.com/ethereum/go-ethereum/internal/web3ext"
@@ -59,7 +60,7 @@ type Config struct {
 	Preload  []string     // Absolute paths to JavaScript files to preload
 }
 
-// Console is a JavaScript interpreted runtime environment. It is a fully fleged
+// Console is a JavaScript interpreted runtime environment. It is a fully fledged
 // JavaScript console attached to a running node via an external or in-process RPC
 // client.
 type Console struct {
@@ -72,6 +73,8 @@ type Console struct {
 	printer  io.Writer    // Output writer to serialize any display strings to
 }
 
+// New initializes a JavaScript interpreted runtime environment and sets defaults
+// with the config struct.
 func New(config Config) (*Console, error) {
 	// Handle unset config values gracefully
 	if config.Prompter == nil {
@@ -92,6 +95,9 @@ func New(config Config) (*Console, error) {
 		printer:  config.Printer,
 		histPath: filepath.Join(config.DataDir, HistoryFile),
 	}
+	if err := os.MkdirAll(config.DataDir, 0700); err != nil {
+		return nil, err
+	}
 	if err := console.init(config.Preload); err != nil {
 		return nil, err
 	}
@@ -329,7 +335,7 @@ func (c *Console) Interactive() {
 	}()
 	// Monitor Ctrl-C too in case the input is empty and we need to bail
 	abort := make(chan os.Signal, 1)
-	signal.Notify(abort, os.Interrupt)
+	signal.Notify(abort, syscall.SIGINT, syscall.SIGTERM)
 
 	// Start sending prompts to the user and reading back inputs
 	for {
@@ -423,7 +429,7 @@ func (c *Console) Execute(path string) error {
 	return c.jsre.Exec(path)
 }
 
-// Stop cleans up the console and terminates the runtime envorinment.
+// Stop cleans up the console and terminates the runtime environment.
 func (c *Console) Stop(graceful bool) error {
 	if err := ioutil.WriteFile(c.histPath, []byte(strings.Join(c.history, "\n")), 0600); err != nil {
 		return err
diff --git a/console/prompter.go b/console/prompter.go
index ea03694d41..c477b48178 100644
--- a/console/prompter.go
+++ b/console/prompter.go
@@ -155,8 +155,7 @@ func (p *terminalPrompter) SetHistory(history []string) {
 	p.State.ReadHistory(strings.NewReader(strings.Join(history, "\n")))
 }
 
-// AppendHistory appends an entry to the scrollback history. It should be called
-// if and only if the prompt to append was a valid command.
+// AppendHistory appends an entry to the scrollback history.
 func (p *terminalPrompter) AppendHistory(command string) {
 	p.State.AppendHistory(command)
 }
diff --git a/containers/docker/develop-alpine/Dockerfile b/containers/docker/develop-alpine/Dockerfile
index d239129d53..1f3e1112ec 100644
--- a/containers/docker/develop-alpine/Dockerfile
+++ b/containers/docker/develop-alpine/Dockerfile
@@ -1,4 +1,4 @@
-FROM alpine:3.5
+FROM alpine:3.7
 
 RUN \
   apk add --update go git make gcc musl-dev linux-headers ca-certificates && \
diff --git a/containers/docker/develop-ubuntu/Dockerfile b/containers/docker/develop-ubuntu/Dockerfile
index c79becb55a..8c4fe9f595 100644
--- a/containers/docker/develop-ubuntu/Dockerfile
+++ b/containers/docker/develop-ubuntu/Dockerfile
@@ -1,12 +1,14 @@
 FROM ubuntu:xenial
 
+ENV PATH=/usr/lib/go-1.9/bin:$PATH
+
 RUN \
   apt-get update && apt-get upgrade -q -y && \
-  apt-get install -y --no-install-recommends golang git make gcc libc-dev ca-certificates && \
+  apt-get install -y --no-install-recommends golang-1.9 git make gcc libc-dev ca-certificates && \
   git clone --depth 1 https://github.com/ethereum/go-ethereum && \
   (cd go-ethereum && make geth) && \
   cp go-ethereum/build/bin/geth /geth && \
-  apt-get remove -y golang git make gcc libc-dev && apt autoremove -y && apt-get clean && \
+  apt-get remove -y golang-1.9 git make gcc libc-dev && apt autoremove -y && apt-get clean && \
   rm -rf /go-ethereum
 
 EXPOSE 8545
diff --git a/containers/docker/master-alpine/Dockerfile b/containers/docker/master-alpine/Dockerfile
index 44402361d7..8d4e7fe81a 100644
--- a/containers/docker/master-alpine/Dockerfile
+++ b/containers/docker/master-alpine/Dockerfile
@@ -1,8 +1,8 @@
-FROM alpine:3.5
+FROM alpine:3.7
 
 RUN \
   apk add --update go git make gcc musl-dev linux-headers ca-certificates && \
-  git clone --depth 1 --branch release/1.7 https://github.com/ethereum/go-ethereum && \
+  git clone --depth 1 --branch release/1.8 https://github.com/ethereum/go-ethereum && \
   (cd go-ethereum && make geth) && \
   cp go-ethereum/build/bin/geth /geth && \
   apk del go git make gcc musl-dev linux-headers && \
diff --git a/containers/docker/master-ubuntu/Dockerfile b/containers/docker/master-ubuntu/Dockerfile
index cc4fad10c4..4cfc4f58c0 100644
--- a/containers/docker/master-ubuntu/Dockerfile
+++ b/containers/docker/master-ubuntu/Dockerfile
@@ -1,12 +1,14 @@
 FROM ubuntu:xenial
 
+ENV PATH=/usr/lib/go-1.9/bin:$PATH
+
 RUN \
   apt-get update && apt-get upgrade -q -y && \
-  apt-get install -y --no-install-recommends golang git make gcc libc-dev ca-certificates && \
-  git clone --depth 1 --branch release/1.7 https://github.com/ethereum/go-ethereum && \
+  apt-get install -y --no-install-recommends golang-1.9 git make gcc libc-dev ca-certificates && \
+  git clone --depth 1 --branch release/1.8 https://github.com/ethereum/go-ethereum && \
   (cd go-ethereum && make geth) && \
   cp go-ethereum/build/bin/geth /geth && \
-  apt-get remove -y golang git make gcc libc-dev && apt autoremove -y && apt-get clean && \
+  apt-get remove -y golang-1.9 git make gcc libc-dev && apt autoremove -y && apt-get clean && \
   rm -rf /go-ethereum
 
 EXPOSE 8545
diff --git a/containers/vagrant/.gitignore b/containers/vagrant/.gitignore
deleted file mode 100644
index 8000dd9db4..0000000000
--- a/containers/vagrant/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-.vagrant
diff --git a/containers/vagrant/Vagrantfile b/containers/vagrant/Vagrantfile
deleted file mode 100644
index 72ec366e21..0000000000
--- a/containers/vagrant/Vagrantfile
+++ /dev/null
@@ -1,38 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-require 'yaml'
-
-VAGRANTFILE_API_VERSION = 2
-VM_RAM = 2048
-
-Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
-
-  config.vm.define "ubuntu", :primary => true do |ubuntu| 
-    ubuntu.vm.box = "ubuntu/trusty64"
-    ubuntu.vm.provision "shell", :path => "provisioners/shell/ubuntu.sh"
-  end
-
-  config.vm.define "debian", :primary => true do |debian|
-    debian.vm.box = "debian/jessie64"
-    debian.vm.provision "shell", :path => "provisioners/shell/debian.sh"
-  end
-  
-  config.vm.define "centos", :autostart => false do |centos| 
-    centos.vm.box = "centos/7"
-    centos.vm.provision "shell", :path => "provisioners/shell/centos.sh"
-  end
-  
-  config.vm.provider "virtualbox" do |vb|
-    vb.memory = VM_RAM
-  end
-
-  config.vm.provider "libvirt" do |lv|
-    lv.memory = VM_RAM
-
-    config.vm.synced_folder ".", "/home/vagrant/sync", :disabled => true
-  end
-  
-  config.vm.synced_folder ".", "/vagrant", :disabled => true
-  config.vm.synced_folder "../../", "/home/vagrant/go/src/github.com/ethereum/go-ethereum"
-end
diff --git a/containers/vagrant/provisioners/shell/centos.sh b/containers/vagrant/provisioners/shell/centos.sh
deleted file mode 100755
index 744da4bfd4..0000000000
--- a/containers/vagrant/provisioners/shell/centos.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-sudo yum install -y git wget
-sudo yum update -y
-
-wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz
-sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz
-
-GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/"
-
-echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc 
diff --git a/containers/vagrant/provisioners/shell/debian.sh b/containers/vagrant/provisioners/shell/debian.sh
deleted file mode 100755
index 1c1793336d..0000000000
--- a/containers/vagrant/provisioners/shell/debian.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-sudo apt-get install -y build-essential git-all wget
-sudo apt-get update
-
-wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz
-sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz
-
-GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/"
-
-echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc 
diff --git a/containers/vagrant/provisioners/shell/ubuntu.sh b/containers/vagrant/provisioners/shell/ubuntu.sh
deleted file mode 100755
index 1c1793336d..0000000000
--- a/containers/vagrant/provisioners/shell/ubuntu.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash
-
-sudo apt-get install -y build-essential git-all wget
-sudo apt-get update
-
-wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz
-sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz
-
-GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/"
-
-echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc 
diff --git a/contracts/chequebook/cheque.go b/contracts/chequebook/cheque.go
index 09daa92484..92bd896e0a 100644
--- a/contracts/chequebook/cheque.go
+++ b/contracts/chequebook/cheque.go
@@ -21,7 +21,7 @@
 // as well as (auto)depositing ether to the chequebook contract.
 package chequebook
 
-//go:generate abigen --sol contract/chequebook.sol --pkg contract --out contract/chequebook.go
+//go:generate abigen --sol contract/chequebook.sol --exc contract/mortal.sol:mortal,contract/owned.sol:owned --pkg contract --out contract/chequebook.go
 //go:generate go run ./gencode.go
 
 import (
@@ -56,8 +56,8 @@ import (
 // * watching incoming ether
 
 var (
-	gasToCash = big.NewInt(2000000) // gas cost of a cash transaction using chequebook
-	// gasToDeploy = big.NewInt(3000000)
+	gasToCash = uint64(2000000) // gas cost of a cash transaction using chequebook
+	// gasToDeploy = uint64(3000000)
 )
 
 // Backend wraps all methods required for chequebook operation.
diff --git a/contracts/chequebook/cheque_test.go b/contracts/chequebook/cheque_test.go
index b7555d0815..6b6b28e657 100644
--- a/contracts/chequebook/cheque_test.go
+++ b/contracts/chequebook/cheque_test.go
@@ -281,8 +281,8 @@ func TestDeposit(t *testing.T) {
 		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
 	}
 
-	// autodeposit every 30ms if new cheque issued
-	interval := 30 * time.Millisecond
+	// autodeposit every 200ms if new cheque issued
+	interval := 200 * time.Millisecond
 	chbook.AutoDeposit(interval, common.Big1, balance)
 	_, err = chbook.Issue(addr1, amount)
 	if err != nil {
diff --git a/contracts/chequebook/contract/chequebook.go b/contracts/chequebook/contract/chequebook.go
index 47090152cc..e275ac9b8d 100644
--- a/contracts/chequebook/contract/chequebook.go
+++ b/contracts/chequebook/contract/chequebook.go
@@ -1,5 +1,5 @@
-// This file is an automatically generated Go binding. Do not modify as any
-// change will likely be lost upon the next re-generation!
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
 
 package contract
 
@@ -7,17 +7,19 @@ import (
 	"math/big"
 	"strings"
 
+	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
 )
 
 // ChequebookABI is the input ABI used to generate the binding from.
-const ChequebookABI = `[{"constant":false,"inputs":[],"name":"kill","outputs":[],"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"sent","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"amount","type":"uint256"},{"name":"sig_v","type":"uint8"},{"name":"sig_r","type":"bytes32"},{"name":"sig_s","type":"bytes32"}],"name":"cash","outputs":[],"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"deadbeat","type":"address"}],"name":"Overdraft","type":"event"}]`
+const ChequebookABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"kill\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"sent\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"sig_v\",\"type\":\"uint8\"},{\"name\":\"sig_r\",\"type\":\"bytes32\"},{\"name\":\"sig_s\",\"type\":\"bytes32\"}],\"name\":\"cash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"deadbeat\",\"type\":\"address\"}],\"name\":\"Overdraft\",\"type\":\"event\"}]"
 
 // ChequebookBin is the compiled bytecode used for deploying new contracts.
-const ChequebookBin = `0x606060405260008054600160a060020a031916331790556101ff806100246000396000f3606060405260e060020a600035046341c0e1b581146100315780637bf786f814610059578063fbf788d614610071575b005b61002f60005433600160a060020a03908116911614156100bd57600054600160a060020a0316ff5b6100ab60043560016020526000908152604090205481565b61002f600435602435604435606435608435600160a060020a03851660009081526001602052604081205485116100bf575b505050505050565b60408051918252519081900360200190f35b565b50604080516c0100000000000000000000000030600160a060020a0390811682028352881602601482015260288101869052815190819003604801812080825260ff861660208381019190915282840186905260608301859052925190926001926080818101939182900301816000866161da5a03f11561000257505060405151600054600160a060020a0390811691161461015a576100a3565b600160a060020a038681166000908152600160205260409020543090911631908603106101b357604060008181208790559051600160a060020a0388169190819081818181818881f1935050505015156100a357610002565b60005460408051600160a060020a03929092168252517f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f9789181900360200190a185600160a060020a0316ff`
+const ChequebookBin = `0x606060405260008054600160a060020a033316600160a060020a03199091161790556102ec806100306000396000f3006060604052600436106100565763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166341c0e1b581146100585780637bf786f81461006b578063fbf788d61461009c575b005b341561006357600080fd5b6100566100ca565b341561007657600080fd5b61008a600160a060020a03600435166100f1565b60405190815260200160405180910390f35b34156100a757600080fd5b610056600160a060020a036004351660243560ff60443516606435608435610103565b60005433600160a060020a03908116911614156100ef57600054600160a060020a0316ff5b565b60016020526000908152604090205481565b600160a060020a0385166000908152600160205260408120548190861161012957600080fd5b3087876040516c01000000000000000000000000600160a060020a03948516810282529290931690910260148301526028820152604801604051809103902091506001828686866040516000815260200160405260006040516020015260405193845260ff90921660208085019190915260408085019290925260608401929092526080909201915160208103908084039060008661646e5a03f115156101cf57600080fd5b505060206040510351600054600160a060020a039081169116146101f257600080fd5b50600160a060020a03808716600090815260016020526040902054860390301631811161026257600160a060020a0387166000818152600160205260409081902088905582156108fc0290839051600060405180830381858888f19350505050151561025d57600080fd5b6102b7565b6000547f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f97890600160a060020a0316604051600160a060020a03909116815260200160405180910390a186600160a060020a0316ff5b505050505050505600a165627a7a72305820533e856fc37e3d64d1706bcc7dfb6b1d490c8d566ea498d9d01ec08965a896ca0029`
 
 // DeployChequebook deploys a new Ethereum contract, binding an instance of Chequebook to it.
 func DeployChequebook(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Chequebook, error) {
@@ -29,13 +31,14 @@ func DeployChequebook(auth *bind.TransactOpts, backend bind.ContractBackend) (co
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
-	return address, tx, &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}}, nil
+	return address, tx, &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}, ChequebookFilterer: ChequebookFilterer{contract: contract}}, nil
 }
 
 // Chequebook is an auto generated Go binding around an Ethereum contract.
 type Chequebook struct {
 	ChequebookCaller     // Read-only binding to the contract
 	ChequebookTransactor // Write-only binding to the contract
+	ChequebookFilterer   // Log filterer for contract events
 }
 
 // ChequebookCaller is an auto generated read-only Go binding around an Ethereum contract.
@@ -48,6 +51,11 @@ type ChequebookTransactor struct {
 	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 }
 
+// ChequebookFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ChequebookFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
 // ChequebookSession is an auto generated Go binding around an Ethereum contract,
 // with pre-set call and transact options.
 type ChequebookSession struct {
@@ -87,16 +95,16 @@ type ChequebookTransactorRaw struct {
 
 // NewChequebook creates a new instance of Chequebook, bound to a specific deployed contract.
 func NewChequebook(address common.Address, backend bind.ContractBackend) (*Chequebook, error) {
-	contract, err := bindChequebook(address, backend, backend)
+	contract, err := bindChequebook(address, backend, backend, backend)
 	if err != nil {
 		return nil, err
 	}
-	return &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}}, nil
+	return &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}, ChequebookFilterer: ChequebookFilterer{contract: contract}}, nil
 }
 
 // NewChequebookCaller creates a new read-only instance of Chequebook, bound to a specific deployed contract.
 func NewChequebookCaller(address common.Address, caller bind.ContractCaller) (*ChequebookCaller, error) {
-	contract, err := bindChequebook(address, caller, nil)
+	contract, err := bindChequebook(address, caller, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -105,20 +113,29 @@ func NewChequebookCaller(address common.Address, caller bind.ContractCaller) (*C
 
 // NewChequebookTransactor creates a new write-only instance of Chequebook, bound to a specific deployed contract.
 func NewChequebookTransactor(address common.Address, transactor bind.ContractTransactor) (*ChequebookTransactor, error) {
-	contract, err := bindChequebook(address, nil, transactor)
+	contract, err := bindChequebook(address, nil, transactor, nil)
 	if err != nil {
 		return nil, err
 	}
 	return &ChequebookTransactor{contract: contract}, nil
 }
 
+// NewChequebookFilterer creates a new log filterer instance of Chequebook, bound to a specific deployed contract.
+func NewChequebookFilterer(address common.Address, filterer bind.ContractFilterer) (*ChequebookFilterer, error) {
+	contract, err := bindChequebook(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ChequebookFilterer{contract: contract}, nil
+}
+
 // bindChequebook binds a generic wrapper to an already deployed contract.
-func bindChequebook(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+func bindChequebook(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(ChequebookABI))
 	if err != nil {
 		return nil, err
 	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
 
 // Call invokes the (constant) contract method with params as input values and
@@ -227,315 +244,124 @@ func (_Chequebook *ChequebookTransactorSession) Kill() (*types.Transaction, erro
 	return _Chequebook.Contract.Kill(&_Chequebook.TransactOpts)
 }
 
-// MortalABI is the input ABI used to generate the binding from.
-const MortalABI = `[{"constant":false,"inputs":[],"name":"kill","outputs":[],"type":"function"}]`
+// ChequebookOverdraftIterator is returned from FilterOverdraft and is used to iterate over the raw logs and unpacked data for Overdraft events raised by the Chequebook contract.
+type ChequebookOverdraftIterator struct {
+	Event *ChequebookOverdraft // Event containing the contract specifics and raw log
 
-// MortalBin is the compiled bytecode used for deploying new contracts.
-const MortalBin = `0x606060405260008054600160a060020a03191633179055605c8060226000396000f3606060405260e060020a600035046341c0e1b58114601a575b005b60186000543373ffffffffffffffffffffffffffffffffffffffff90811691161415605a5760005473ffffffffffffffffffffffffffffffffffffffff16ff5b56`
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
 
-// DeployMortal deploys a new Ethereum contract, binding an instance of Mortal to it.
-func DeployMortal(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Mortal, error) {
-	parsed, err := abi.JSON(strings.NewReader(MortalABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ChequebookOverdraftIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
 	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MortalBin), backend)
-	if err != nil {
-		return common.Address{}, nil, nil, err
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ChequebookOverdraft)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
 	}
-	return address, tx, &Mortal{MortalCaller: MortalCaller{contract: contract}, MortalTransactor: MortalTransactor{contract: contract}}, nil
-}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ChequebookOverdraft)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
 
-// Mortal is an auto generated Go binding around an Ethereum contract.
-type Mortal struct {
-	MortalCaller     // Read-only binding to the contract
-	MortalTransactor // Write-only binding to the contract
-}
-
-// MortalCaller is an auto generated read-only Go binding around an Ethereum contract.
-type MortalCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// MortalTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type MortalTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// MortalSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type MortalSession struct {
-	Contract     *Mortal           // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// MortalCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type MortalCallerSession struct {
-	Contract *MortalCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts // Call options to use throughout this session
-}
-
-// MortalTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type MortalTransactorSession struct {
-	Contract     *MortalTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// MortalRaw is an auto generated low-level Go binding around an Ethereum contract.
-type MortalRaw struct {
-	Contract *Mortal // Generic contract binding to access the raw methods on
-}
-
-// MortalCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type MortalCallerRaw struct {
-	Contract *MortalCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// MortalTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type MortalTransactorRaw struct {
-	Contract *MortalTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewMortal creates a new instance of Mortal, bound to a specific deployed contract.
-func NewMortal(address common.Address, backend bind.ContractBackend) (*Mortal, error) {
-	contract, err := bindMortal(address, backend, backend)
-	if err != nil {
-		return nil, err
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
 	}
-	return &Mortal{MortalCaller: MortalCaller{contract: contract}, MortalTransactor: MortalTransactor{contract: contract}}, nil
 }
 
-// NewMortalCaller creates a new read-only instance of Mortal, bound to a specific deployed contract.
-func NewMortalCaller(address common.Address, caller bind.ContractCaller) (*MortalCaller, error) {
-	contract, err := bindMortal(address, caller, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &MortalCaller{contract: contract}, nil
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *ChequebookOverdraftIterator) Error() error {
+	return it.fail
 }
 
-// NewMortalTransactor creates a new write-only instance of Mortal, bound to a specific deployed contract.
-func NewMortalTransactor(address common.Address, transactor bind.ContractTransactor) (*MortalTransactor, error) {
-	contract, err := bindMortal(address, nil, transactor)
-	if err != nil {
-		return nil, err
-	}
-	return &MortalTransactor{contract: contract}, nil
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ChequebookOverdraftIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
 }
 
-// bindMortal binds a generic wrapper to an already deployed contract.
-func bindMortal(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(MortalABI))
-	if err != nil {
-		return nil, err
-	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
+// ChequebookOverdraft represents a Overdraft event raised by the Chequebook contract.
+type ChequebookOverdraft struct {
+	Deadbeat common.Address
+	Raw      types.Log // Blockchain specific contextual infos
 }
 
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Mortal *MortalRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Mortal.Contract.MortalCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Mortal *MortalRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Mortal.Contract.MortalTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Mortal *MortalRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Mortal.Contract.MortalTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Mortal *MortalCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Mortal.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Mortal *MortalTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Mortal.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Mortal *MortalTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Mortal.Contract.contract.Transact(opts, method, params...)
-}
-
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
+// FilterOverdraft is a free log retrieval operation binding the contract event 0x2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f978.
 //
-// Solidity: function kill() returns()
-func (_Mortal *MortalTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Mortal.contract.Transact(opts, "kill")
+// Solidity: event Overdraft(deadbeat address)
+func (_Chequebook *ChequebookFilterer) FilterOverdraft(opts *bind.FilterOpts) (*ChequebookOverdraftIterator, error) {
+
+	logs, sub, err := _Chequebook.contract.FilterLogs(opts, "Overdraft")
+	if err != nil {
+		return nil, err
+	}
+	return &ChequebookOverdraftIterator{contract: _Chequebook.contract, event: "Overdraft", logs: logs, sub: sub}, nil
 }
 
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
+// WatchOverdraft is a free log subscription operation binding the contract event 0x2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f978.
 //
-// Solidity: function kill() returns()
-func (_Mortal *MortalSession) Kill() (*types.Transaction, error) {
-	return _Mortal.Contract.Kill(&_Mortal.TransactOpts)
-}
+// Solidity: event Overdraft(deadbeat address)
+func (_Chequebook *ChequebookFilterer) WatchOverdraft(opts *bind.WatchOpts, sink chan<- *ChequebookOverdraft) (event.Subscription, error) {
 
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
-//
-// Solidity: function kill() returns()
-func (_Mortal *MortalTransactorSession) Kill() (*types.Transaction, error) {
-	return _Mortal.Contract.Kill(&_Mortal.TransactOpts)
-}
-
-// OwnedABI is the input ABI used to generate the binding from.
-const OwnedABI = `[{"inputs":[],"type":"constructor"}]`
-
-// OwnedBin is the compiled bytecode used for deploying new contracts.
-const OwnedBin = `0x606060405260008054600160a060020a0319163317905560068060226000396000f3606060405200`
-
-// DeployOwned deploys a new Ethereum contract, binding an instance of Owned to it.
-func DeployOwned(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Owned, error) {
-	parsed, err := abi.JSON(strings.NewReader(OwnedABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OwnedBin), backend)
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	return address, tx, &Owned{OwnedCaller: OwnedCaller{contract: contract}, OwnedTransactor: OwnedTransactor{contract: contract}}, nil
-}
-
-// Owned is an auto generated Go binding around an Ethereum contract.
-type Owned struct {
-	OwnedCaller     // Read-only binding to the contract
-	OwnedTransactor // Write-only binding to the contract
-}
-
-// OwnedCaller is an auto generated read-only Go binding around an Ethereum contract.
-type OwnedCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// OwnedTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type OwnedTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// OwnedSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type OwnedSession struct {
-	Contract     *Owned            // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// OwnedCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type OwnedCallerSession struct {
-	Contract *OwnedCaller  // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts // Call options to use throughout this session
-}
-
-// OwnedTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type OwnedTransactorSession struct {
-	Contract     *OwnedTransactor  // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// OwnedRaw is an auto generated low-level Go binding around an Ethereum contract.
-type OwnedRaw struct {
-	Contract *Owned // Generic contract binding to access the raw methods on
-}
-
-// OwnedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type OwnedCallerRaw struct {
-	Contract *OwnedCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// OwnedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type OwnedTransactorRaw struct {
-	Contract *OwnedTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewOwned creates a new instance of Owned, bound to a specific deployed contract.
-func NewOwned(address common.Address, backend bind.ContractBackend) (*Owned, error) {
-	contract, err := bindOwned(address, backend, backend)
+	logs, sub, err := _Chequebook.contract.WatchLogs(opts, "Overdraft")
 	if err != nil {
 		return nil, err
 	}
-	return &Owned{OwnedCaller: OwnedCaller{contract: contract}, OwnedTransactor: OwnedTransactor{contract: contract}}, nil
-}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ChequebookOverdraft)
+				if err := _Chequebook.contract.UnpackLog(event, "Overdraft", log); err != nil {
+					return err
+				}
+				event.Raw = log
 
-// NewOwnedCaller creates a new read-only instance of Owned, bound to a specific deployed contract.
-func NewOwnedCaller(address common.Address, caller bind.ContractCaller) (*OwnedCaller, error) {
-	contract, err := bindOwned(address, caller, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &OwnedCaller{contract: contract}, nil
-}
-
-// NewOwnedTransactor creates a new write-only instance of Owned, bound to a specific deployed contract.
-func NewOwnedTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnedTransactor, error) {
-	contract, err := bindOwned(address, nil, transactor)
-	if err != nil {
-		return nil, err
-	}
-	return &OwnedTransactor{contract: contract}, nil
-}
-
-// bindOwned binds a generic wrapper to an already deployed contract.
-func bindOwned(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(OwnedABI))
-	if err != nil {
-		return nil, err
-	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Owned *OwnedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Owned.Contract.OwnedCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Owned *OwnedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Owned.Contract.OwnedTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Owned *OwnedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Owned.Contract.OwnedTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Owned *OwnedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Owned.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Owned *OwnedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Owned.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Owned *OwnedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Owned.Contract.contract.Transact(opts, method, params...)
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
 }
diff --git a/contracts/chequebook/contract/chequebook.sol b/contracts/chequebook/contract/chequebook.sol
index 8d6e85d119..c386cceed8 100644
--- a/contracts/chequebook/contract/chequebook.sol
+++ b/contracts/chequebook/contract/chequebook.sol
@@ -1,6 +1,6 @@
 pragma solidity ^0.4.18;
 
-import "https://github.com/ethereum/solidity/std/mortal.sol";
+import "./mortal.sol";
 
 /// @title Chequebook for Ethereum micropayments
 /// @author Daniel A. Nagy 
@@ -11,6 +11,9 @@ contract chequebook is mortal {
     /// @notice Overdraft event
     event Overdraft(address deadbeat);
 
+    // Allow sending ether to the chequebook.
+    function() public payable { }
+
     /// @notice Cash cheque
     ///
     /// @param beneficiary beneficiary address
@@ -19,8 +22,7 @@ contract chequebook is mortal {
     /// @param sig_r signature parameter r
     /// @param sig_s signature parameter s
     /// The digital signature is calculated on the concatenated triplet of contract address, beneficiary address and cumulative amount
-    function cash(address beneficiary, uint256 amount,
-        uint8 sig_v, bytes32 sig_r, bytes32 sig_s) {
+    function cash(address beneficiary, uint256 amount, uint8 sig_v, bytes32 sig_r, bytes32 sig_s) public {
         // Check if the cheque is old.
         // Only cheques that are more recent than the last cashed one are considered.
         require(amount > sent[beneficiary]);
@@ -31,7 +33,7 @@ contract chequebook is mortal {
         // and the cumulative amount on the last cashed cheque to beneficiary.
         uint256 diff = amount - sent[beneficiary];
         if (diff <= this.balance) {
-	    // update the cumulative amount before sending
+            // update the cumulative amount before sending
             sent[beneficiary] = amount;
             beneficiary.transfer(diff);
         } else {
diff --git a/contracts/chequebook/contract/code.go b/contracts/chequebook/contract/code.go
index b08e04e71a..d837a9d601 100644
--- a/contracts/chequebook/contract/code.go
+++ b/contracts/chequebook/contract/code.go
@@ -2,4 +2,4 @@ package contract
 
 // ContractDeployedCode is used to detect suicides. This constant needs to be
 // updated when the contract code is changed.
-const ContractDeployedCode = "0x606060405260e060020a600035046341c0e1b581146100315780637bf786f814610059578063fbf788d614610071575b005b61002f60005433600160a060020a03908116911614156100bd57600054600160a060020a0316ff5b6100ab60043560016020526000908152604090205481565b61002f600435602435604435606435608435600160a060020a03851660009081526001602052604081205485116100bf575b505050505050565b60408051918252519081900360200190f35b565b50604080516c0100000000000000000000000030600160a060020a0390811682028352881602601482015260288101869052815190819003604801812080825260ff861660208381019190915282840186905260608301859052925190926001926080818101939182900301816000866161da5a03f11561000257505060405151600054600160a060020a0390811691161461015a576100a3565b600160a060020a038681166000908152600160205260409020543090911631908603106101b357604060008181208790559051600160a060020a0388169190819081818181818881f1935050505015156100a357610002565b60005460408051600160a060020a03929092168252517f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f9789181900360200190a185600160a060020a0316ff"
+const ContractDeployedCode = "0x6060604052600436106100565763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166341c0e1b581146100585780637bf786f81461006b578063fbf788d61461009c575b005b341561006357600080fd5b6100566100ca565b341561007657600080fd5b61008a600160a060020a03600435166100f1565b60405190815260200160405180910390f35b34156100a757600080fd5b610056600160a060020a036004351660243560ff60443516606435608435610103565b60005433600160a060020a03908116911614156100ef57600054600160a060020a0316ff5b565b60016020526000908152604090205481565b600160a060020a0385166000908152600160205260408120548190861161012957600080fd5b3087876040516c01000000000000000000000000600160a060020a03948516810282529290931690910260148301526028820152604801604051809103902091506001828686866040516000815260200160405260006040516020015260405193845260ff90921660208085019190915260408085019290925260608401929092526080909201915160208103908084039060008661646e5a03f115156101cf57600080fd5b505060206040510351600054600160a060020a039081169116146101f257600080fd5b50600160a060020a03808716600090815260016020526040902054860390301631811161026257600160a060020a0387166000818152600160205260409081902088905582156108fc0290839051600060405180830381858888f19350505050151561025d57600080fd5b6102b7565b6000547f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f97890600160a060020a0316604051600160a060020a03909116815260200160405180910390a186600160a060020a0316ff5b505050505050505600a165627a7a72305820533e856fc37e3d64d1706bcc7dfb6b1d490c8d566ea498d9d01ec08965a896ca0029"
diff --git a/contracts/chequebook/contract/mortal.sol b/contracts/chequebook/contract/mortal.sol
new file mode 100644
index 0000000000..c43f1e4f79
--- /dev/null
+++ b/contracts/chequebook/contract/mortal.sol
@@ -0,0 +1,10 @@
+pragma solidity ^0.4.0;
+
+import "./owned.sol";
+
+contract mortal is owned {
+    function kill() public {
+        if (msg.sender == owner)
+            selfdestruct(owner);
+    }
+}
diff --git a/contracts/chequebook/contract/owned.sol b/contracts/chequebook/contract/owned.sol
new file mode 100644
index 0000000000..ee9860d343
--- /dev/null
+++ b/contracts/chequebook/contract/owned.sol
@@ -0,0 +1,15 @@
+pragma solidity ^0.4.0;
+
+contract owned {
+    address owner;
+
+    modifier onlyowner() {
+        if (msg.sender == owner) {
+            _;
+        }
+    }
+
+    function owned() public {
+        owner = msg.sender;
+    }
+}
diff --git a/contracts/chequebook/gencode.go b/contracts/chequebook/gencode.go
index faa927279d..45f6d68f3e 100644
--- a/contracts/chequebook/gencode.go
+++ b/contracts/chequebook/gencode.go
@@ -33,15 +33,14 @@ import (
 )
 
 var (
-	testKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-	testAccount = core.GenesisAccount{
-		Address: crypto.PubkeyToAddress(testKey.PublicKey),
-		Balance: big.NewInt(500000000000),
+	testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+	testAlloc  = core.GenesisAlloc{
+		crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(500000000000)},
 	}
 )
 
 func main() {
-	backend := backends.NewSimulatedBackend(testAccount)
+	backend := backends.NewSimulatedBackend(testAlloc)
 	auth := bind.NewKeyedTransactor(testKey)
 
 	// Deploy the contract, get the code.
diff --git a/contracts/ens/contract/AbstractENS.sol b/contracts/ens/contract/AbstractENS.sol
new file mode 100644
index 0000000000..b80a1b0e6b
--- /dev/null
+++ b/contracts/ens/contract/AbstractENS.sol
@@ -0,0 +1,23 @@
+pragma solidity ^0.4.0;
+
+contract AbstractENS {
+    function owner(bytes32 node) constant returns(address);
+    function resolver(bytes32 node) constant returns(address);
+    function ttl(bytes32 node) constant returns(uint64);
+    function setOwner(bytes32 node, address owner);
+    function setSubnodeOwner(bytes32 node, bytes32 label, address owner);
+    function setResolver(bytes32 node, address resolver);
+    function setTTL(bytes32 node, uint64 ttl);
+
+    // Logged when the owner of a node assigns a new owner to a subnode.
+    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
+
+    // Logged when the owner of a node transfers ownership to a new account.
+    event Transfer(bytes32 indexed node, address owner);
+
+    // Logged when the resolver for a node changes.
+    event NewResolver(bytes32 indexed node, address resolver);
+
+    // Logged when the TTL of a node changes
+    event NewTTL(bytes32 indexed node, uint64 ttl);
+}
diff --git a/contracts/ens/contract/ENS.sol b/contracts/ens/contract/ENS.sol
new file mode 100644
index 0000000000..47050c19da
--- /dev/null
+++ b/contracts/ens/contract/ENS.sol
@@ -0,0 +1,94 @@
+pragma solidity ^0.4.0;
+
+import './AbstractENS.sol';
+
+/**
+ * The ENS registry contract.
+ */
+contract ENS is AbstractENS {
+    struct Record {
+        address owner;
+        address resolver;
+        uint64 ttl;
+    }
+
+    mapping(bytes32=>Record) records;
+
+    // Permits modifications only by the owner of the specified node.
+    modifier only_owner(bytes32 node) {
+        if (records[node].owner != msg.sender) throw;
+        _;
+    }
+
+    /**
+     * Constructs a new ENS registrar.
+     */
+    function ENS() {
+        records[0].owner = msg.sender;
+    }
+
+    /**
+     * Returns the address that owns the specified node.
+     */
+    function owner(bytes32 node) constant returns (address) {
+        return records[node].owner;
+    }
+
+    /**
+     * Returns the address of the resolver for the specified node.
+     */
+    function resolver(bytes32 node) constant returns (address) {
+        return records[node].resolver;
+    }
+
+    /**
+     * Returns the TTL of a node, and any records associated with it.
+     */
+    function ttl(bytes32 node) constant returns (uint64) {
+        return records[node].ttl;
+    }
+
+    /**
+     * Transfers ownership of a node to a new address. May only be called by the current
+     * owner of the node.
+     * @param node The node to transfer ownership of.
+     * @param owner The address of the new owner.
+     */
+    function setOwner(bytes32 node, address owner) only_owner(node) {
+        Transfer(node, owner);
+        records[node].owner = owner;
+    }
+
+    /**
+     * Transfers ownership of a subnode sha3(node, label) to a new address. May only be
+     * called by the owner of the parent node.
+     * @param node The parent node.
+     * @param label The hash of the label specifying the subnode.
+     * @param owner The address of the new owner.
+     */
+    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) only_owner(node) {
+        var subnode = sha3(node, label);
+        NewOwner(node, label, owner);
+        records[subnode].owner = owner;
+    }
+
+    /**
+     * Sets the resolver address for the specified node.
+     * @param node The node to update.
+     * @param resolver The address of the resolver.
+     */
+    function setResolver(bytes32 node, address resolver) only_owner(node) {
+        NewResolver(node, resolver);
+        records[node].resolver = resolver;
+    }
+
+    /**
+     * Sets the TTL for the specified node.
+     * @param node The node to update.
+     * @param ttl The TTL in seconds.
+     */
+    function setTTL(bytes32 node, uint64 ttl) only_owner(node) {
+        NewTTL(node, ttl);
+        records[node].ttl = ttl;
+    }
+}
diff --git a/contracts/ens/contract/FIFSRegistrar.sol b/contracts/ens/contract/FIFSRegistrar.sol
new file mode 100644
index 0000000000..51629c2b65
--- /dev/null
+++ b/contracts/ens/contract/FIFSRegistrar.sol
@@ -0,0 +1,39 @@
+pragma solidity ^0.4.0;
+
+import './AbstractENS.sol';
+
+/**
+ * A registrar that allocates subdomains to the first person to claim them.
+ */
+contract FIFSRegistrar {
+    AbstractENS ens;
+    bytes32 rootNode;
+
+    modifier only_owner(bytes32 subnode) {
+        var node = sha3(rootNode, subnode);
+        var currentOwner = ens.owner(node);
+
+        if (currentOwner != 0 && currentOwner != msg.sender) throw;
+
+        _;
+    }
+
+    /**
+     * Constructor.
+     * @param ensAddr The address of the ENS registry.
+     * @param node The node that this registrar administers.
+     */
+    function FIFSRegistrar(AbstractENS ensAddr, bytes32 node) {
+        ens = ensAddr;
+        rootNode = node;
+    }
+
+    /**
+     * Register a name, or change the owner of an existing registration.
+     * @param subnode The hash of the label to register.
+     * @param owner The address of the new owner.
+     */
+    function register(bytes32 subnode, address owner) only_owner(subnode) {
+        ens.setSubnodeOwner(rootNode, subnode, owner);
+    }
+}
diff --git a/contracts/ens/contract/PublicResolver.sol b/contracts/ens/contract/PublicResolver.sol
new file mode 100644
index 0000000000..9dcc95689e
--- /dev/null
+++ b/contracts/ens/contract/PublicResolver.sol
@@ -0,0 +1,212 @@
+pragma solidity ^0.4.0;
+
+import './AbstractENS.sol';
+
+/**
+ * A simple resolver anyone can use; only allows the owner of a node to set its
+ * address.
+ */
+contract PublicResolver {
+    bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
+    bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;
+    bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5;
+    bytes4 constant NAME_INTERFACE_ID = 0x691f3431;
+    bytes4 constant ABI_INTERFACE_ID = 0x2203ab56;
+    bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233;
+    bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c;
+
+    event AddrChanged(bytes32 indexed node, address a);
+    event ContentChanged(bytes32 indexed node, bytes32 hash);
+    event NameChanged(bytes32 indexed node, string name);
+    event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
+    event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
+    event TextChanged(bytes32 indexed node, string indexed indexedKey, string key);
+
+    struct PublicKey {
+        bytes32 x;
+        bytes32 y;
+    }
+
+    struct Record {
+        address addr;
+        bytes32 content;
+        string name;
+        PublicKey pubkey;
+        mapping(string=>string) text;
+        mapping(uint256=>bytes) abis;
+    }
+
+    AbstractENS ens;
+    mapping(bytes32=>Record) records;
+
+    modifier only_owner(bytes32 node) {
+        if (ens.owner(node) != msg.sender) throw;
+        _;
+    }
+
+    /**
+     * Constructor.
+     * @param ensAddr The ENS registrar contract.
+     */
+    function PublicResolver(AbstractENS ensAddr) {
+        ens = ensAddr;
+    }
+
+    /**
+     * Returns true if the resolver implements the interface specified by the provided hash.
+     * @param interfaceID The ID of the interface to check for.
+     * @return True if the contract implements the requested interface.
+     */
+    function supportsInterface(bytes4 interfaceID) constant returns (bool) {
+        return interfaceID == ADDR_INTERFACE_ID ||
+               interfaceID == CONTENT_INTERFACE_ID ||
+               interfaceID == NAME_INTERFACE_ID ||
+               interfaceID == ABI_INTERFACE_ID ||
+               interfaceID == PUBKEY_INTERFACE_ID ||
+               interfaceID == TEXT_INTERFACE_ID ||
+               interfaceID == INTERFACE_META_ID;
+    }
+
+    /**
+     * Returns the address associated with an ENS node.
+     * @param node The ENS node to query.
+     * @return The associated address.
+     */
+    function addr(bytes32 node) constant returns (address ret) {
+        ret = records[node].addr;
+    }
+
+    /**
+     * Sets the address associated with an ENS node.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param addr The address to set.
+     */
+    function setAddr(bytes32 node, address addr) only_owner(node) {
+        records[node].addr = addr;
+        AddrChanged(node, addr);
+    }
+
+    /**
+     * Returns the content hash associated with an ENS node.
+     * Note that this resource type is not standardized, and will likely change
+     * in future to a resource type based on multihash.
+     * @param node The ENS node to query.
+     * @return The associated content hash.
+     */
+    function content(bytes32 node) constant returns (bytes32 ret) {
+        ret = records[node].content;
+    }
+
+    /**
+     * Sets the content hash associated with an ENS node.
+     * May only be called by the owner of that node in the ENS registry.
+     * Note that this resource type is not standardized, and will likely change
+     * in future to a resource type based on multihash.
+     * @param node The node to update.
+     * @param hash The content hash to set
+     */
+    function setContent(bytes32 node, bytes32 hash) only_owner(node) {
+        records[node].content = hash;
+        ContentChanged(node, hash);
+    }
+
+    /**
+     * Returns the name associated with an ENS node, for reverse records.
+     * Defined in EIP181.
+     * @param node The ENS node to query.
+     * @return The associated name.
+     */
+    function name(bytes32 node) constant returns (string ret) {
+        ret = records[node].name;
+    }
+
+    /**
+     * Sets the name associated with an ENS node, for reverse records.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param name The name to set.
+     */
+    function setName(bytes32 node, string name) only_owner(node) {
+        records[node].name = name;
+        NameChanged(node, name);
+    }
+
+    /**
+     * Returns the ABI associated with an ENS node.
+     * Defined in EIP205.
+     * @param node The ENS node to query
+     * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.
+     * @return contentType The content type of the return value
+     * @return data The ABI data
+     */
+    function ABI(bytes32 node, uint256 contentTypes) constant returns (uint256 contentType, bytes data) {
+        var record = records[node];
+        for(contentType = 1; contentType <= contentTypes; contentType <<= 1) {
+            if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) {
+                data = record.abis[contentType];
+                return;
+            }
+        }
+        contentType = 0;
+    }
+
+    /**
+     * Sets the ABI associated with an ENS node.
+     * Nodes may have one ABI of each content type. To remove an ABI, set it to
+     * the empty string.
+     * @param node The node to update.
+     * @param contentType The content type of the ABI
+     * @param data The ABI data.
+     */
+    function setABI(bytes32 node, uint256 contentType, bytes data) only_owner(node) {
+        // Content types must be powers of 2
+        if (((contentType - 1) & contentType) != 0) throw;
+
+        records[node].abis[contentType] = data;
+        ABIChanged(node, contentType);
+    }
+
+    /**
+     * Returns the SECP256k1 public key associated with an ENS node.
+     * Defined in EIP 619.
+     * @param node The ENS node to query
+     * @return x, y the X and Y coordinates of the curve point for the public key.
+     */
+    function pubkey(bytes32 node) constant returns (bytes32 x, bytes32 y) {
+        return (records[node].pubkey.x, records[node].pubkey.y);
+    }
+
+    /**
+     * Sets the SECP256k1 public key associated with an ENS node.
+     * @param node The ENS node to query
+     * @param x the X coordinate of the curve point for the public key.
+     * @param y the Y coordinate of the curve point for the public key.
+     */
+    function setPubkey(bytes32 node, bytes32 x, bytes32 y) only_owner(node) {
+        records[node].pubkey = PublicKey(x, y);
+        PubkeyChanged(node, x, y);
+    }
+
+    /**
+     * Returns the text data associated with an ENS node and key.
+     * @param node The ENS node to query.
+     * @param key The text data key to query.
+     * @return The associated text data.
+     */
+    function text(bytes32 node, string key) constant returns (string ret) {
+        ret = records[node].text[key];
+    }
+
+    /**
+     * Sets the text data associated with an ENS node and key.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param key The key to set.
+     * @param value The text data value to set.
+     */
+    function setText(bytes32 node, string key, string value) only_owner(node) {
+        records[node].text[key] = value;
+        TextChanged(node, key, key);
+    }
+}
diff --git a/contracts/ens/contract/ens.go b/contracts/ens/contract/ens.go
index aca16de508..cbf6cb05b3 100644
--- a/contracts/ens/contract/ens.go
+++ b/contracts/ens/contract/ens.go
@@ -1,40 +1,43 @@
-// This file is an automatically generated Go binding. Do not modify as any
-// change will likely be lost upon the next re-generation!
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
 
 package contract
 
 import (
 	"strings"
 
+	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
 )
 
 // ENSABI is the input ABI used to generate the binding from.
-const ENSABI = `[{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"resolver","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"owner","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"label","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setSubnodeOwner","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"resolver","type":"address"}],"name":"setResolver","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setOwner","outputs":[],"type":"function"},{"inputs":[{"name":"owner","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":true,"name":"label","type":"bytes32"},{"indexed":false,"name":"owner","type":"address"}],"name":"NewOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"owner","type":"address"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"resolver","type":"address"}],"name":"NewResolver","type":"event"}]`
+const ENSABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"}]"
 
 // ENSBin is the compiled bytecode used for deploying new contracts.
-const ENSBin = `0x606060405260405160208061032683395060806040525160008080526020527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb58054600160a060020a03191682179055506102c88061005e6000396000f3606060405260e060020a60003504630178b8bf811461004757806302571be31461006e57806306ab5923146100915780631896f70a146100c85780635b0fc9c3146100fc575b005b610130600435600081815260208190526040902060010154600160a060020a03165b919050565b610130600435600081815260208190526040902054600160a060020a0316610069565b6100456004356024356044356000838152602081905260408120548490600160a060020a0390811633919091161461014d57610002565b6100456004356024356000828152602081905260409020548290600160a060020a039081163391909116146101e757610002565b6100456004356024356000828152602081905260409020548290600160a060020a0390811633919091161461025957610002565b60408051600160a060020a03929092168252519081900360200190f35b60408051868152602081810187905282519182900383018220600160a060020a03871683529251929450869288927fce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e8292908290030190a382600060005060008460001916815260200190815260200160002060005060000160006101000a815481600160a060020a03021916908302179055505050505050565b60408051600160a060020a0384168152905184917f335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0919081900360200190a2506000828152602081905260409020600101805473ffffffffffffffffffffffffffffffffffffffff1916821790555050565b60408051600160a060020a0384168152905184917fd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266919081900360200190a2506000828152602081905260409020805473ffffffffffffffffffffffffffffffffffffffff191682179055505056`
+const ENSBin = `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`
 
 // DeployENS deploys a new Ethereum contract, binding an instance of ENS to it.
-func DeployENS(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address) (common.Address, *types.Transaction, *ENS, error) {
+func DeployENS(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ENS, error) {
 	parsed, err := abi.JSON(strings.NewReader(ENSABI))
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ENSBin), backend, owner)
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ENSBin), backend)
 	if err != nil {
 		return common.Address{}, nil, nil, err
 	}
-	return address, tx, &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}}, nil
+	return address, tx, &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}, ENSFilterer: ENSFilterer{contract: contract}}, nil
 }
 
 // ENS is an auto generated Go binding around an Ethereum contract.
 type ENS struct {
 	ENSCaller     // Read-only binding to the contract
 	ENSTransactor // Write-only binding to the contract
+	ENSFilterer   // Log filterer for contract events
 }
 
 // ENSCaller is an auto generated read-only Go binding around an Ethereum contract.
@@ -47,6 +50,11 @@ type ENSTransactor struct {
 	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 }
 
+// ENSFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ENSFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
 // ENSSession is an auto generated Go binding around an Ethereum contract,
 // with pre-set call and transact options.
 type ENSSession struct {
@@ -86,16 +94,16 @@ type ENSTransactorRaw struct {
 
 // NewENS creates a new instance of ENS, bound to a specific deployed contract.
 func NewENS(address common.Address, backend bind.ContractBackend) (*ENS, error) {
-	contract, err := bindENS(address, backend, backend)
+	contract, err := bindENS(address, backend, backend, backend)
 	if err != nil {
 		return nil, err
 	}
-	return &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}}, nil
+	return &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}, ENSFilterer: ENSFilterer{contract: contract}}, nil
 }
 
 // NewENSCaller creates a new read-only instance of ENS, bound to a specific deployed contract.
 func NewENSCaller(address common.Address, caller bind.ContractCaller) (*ENSCaller, error) {
-	contract, err := bindENS(address, caller, nil)
+	contract, err := bindENS(address, caller, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -104,20 +112,29 @@ func NewENSCaller(address common.Address, caller bind.ContractCaller) (*ENSCalle
 
 // NewENSTransactor creates a new write-only instance of ENS, bound to a specific deployed contract.
 func NewENSTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSTransactor, error) {
-	contract, err := bindENS(address, nil, transactor)
+	contract, err := bindENS(address, nil, transactor, nil)
 	if err != nil {
 		return nil, err
 	}
 	return &ENSTransactor{contract: contract}, nil
 }
 
+// NewENSFilterer creates a new log filterer instance of ENS, bound to a specific deployed contract.
+func NewENSFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSFilterer, error) {
+	contract, err := bindENS(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ENSFilterer{contract: contract}, nil
+}
+
 // bindENS binds a generic wrapper to an already deployed contract.
-func bindENS(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+func bindENS(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(ENSABI))
 	if err != nil {
 		return nil, err
 	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
 
 // Call invokes the (constant) contract method with params as input values and
@@ -210,6 +227,32 @@ func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error) {
 	return _ENS.Contract.Resolver(&_ENS.CallOpts, node)
 }
 
+// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
+//
+// Solidity: function ttl(node bytes32) constant returns(uint64)
+func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) {
+	var (
+		ret0 = new(uint64)
+	)
+	out := ret0
+	err := _ENS.contract.Call(opts, out, "ttl", node)
+	return *ret0, err
+}
+
+// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
+//
+// Solidity: function ttl(node bytes32) constant returns(uint64)
+func (_ENS *ENSSession) Ttl(node [32]byte) (uint64, error) {
+	return _ENS.Contract.Ttl(&_ENS.CallOpts, node)
+}
+
+// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
+//
+// Solidity: function ttl(node bytes32) constant returns(uint64)
+func (_ENS *ENSCallerSession) Ttl(node [32]byte) (uint64, error) {
+	return _ENS.Contract.Ttl(&_ENS.CallOpts, node)
+}
+
 // SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
 //
 // Solidity: function setOwner(node bytes32, owner address) returns()
@@ -273,649 +316,564 @@ func (_ENS *ENSTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte,
 	return _ENS.Contract.SetSubnodeOwner(&_ENS.TransactOpts, node, label, owner)
 }
 
-// FIFSRegistrarABI is the input ABI used to generate the binding from.
-const FIFSRegistrarABI = `[{"constant":false,"inputs":[{"name":"subnode","type":"bytes32"},{"name":"owner","type":"address"}],"name":"register","outputs":[],"type":"function"},{"inputs":[{"name":"ensAddr","type":"address"},{"name":"node","type":"bytes32"}],"type":"constructor"}]`
+// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
+//
+// Solidity: function setTTL(node bytes32, ttl uint64) returns()
+func (_ENS *ENSTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) {
+	return _ENS.contract.Transact(opts, "setTTL", node, ttl)
+}
 
-// FIFSRegistrarBin is the compiled bytecode used for deploying new contracts.
-const FIFSRegistrarBin = `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`
+// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
+//
+// Solidity: function setTTL(node bytes32, ttl uint64) returns()
+func (_ENS *ENSSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
+	return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl)
+}
 
-// DeployFIFSRegistrar deploys a new Ethereum contract, binding an instance of FIFSRegistrar to it.
-func DeployFIFSRegistrar(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address, node [32]byte) (common.Address, *types.Transaction, *FIFSRegistrar, error) {
-	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
+// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
+//
+// Solidity: function setTTL(node bytes32, ttl uint64) returns()
+func (_ENS *ENSTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
+	return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl)
+}
+
+// ENSNewOwnerIterator is returned from FilterNewOwner and is used to iterate over the raw logs and unpacked data for NewOwner events raised by the ENS contract.
+type ENSNewOwnerIterator struct {
+	Event *ENSNewOwner // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ENSNewOwnerIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
 	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(FIFSRegistrarBin), backend, ensAddr, node)
-	if err != nil {
-		return common.Address{}, nil, nil, err
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ENSNewOwner)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ENSNewOwner)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
 	}
-	return address, tx, &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}}, nil
 }
 
-// FIFSRegistrar is an auto generated Go binding around an Ethereum contract.
-type FIFSRegistrar struct {
-	FIFSRegistrarCaller     // Read-only binding to the contract
-	FIFSRegistrarTransactor // Write-only binding to the contract
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *ENSNewOwnerIterator) Error() error {
+	return it.fail
 }
 
-// FIFSRegistrarCaller is an auto generated read-only Go binding around an Ethereum contract.
-type FIFSRegistrarCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ENSNewOwnerIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
 }
 
-// FIFSRegistrarTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type FIFSRegistrarTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+// ENSNewOwner represents a NewOwner event raised by the ENS contract.
+type ENSNewOwner struct {
+	Node  [32]byte
+	Label [32]byte
+	Owner common.Address
+	Raw   types.Log // Blockchain specific contextual infos
 }
 
-// FIFSRegistrarSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type FIFSRegistrarSession struct {
-	Contract     *FIFSRegistrar    // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
+// FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
+//
+// Solidity: event NewOwner(node indexed bytes32, label indexed bytes32, owner address)
+func (_ENS *ENSFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSNewOwnerIterator, error) {
 
-// FIFSRegistrarCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type FIFSRegistrarCallerSession struct {
-	Contract *FIFSRegistrarCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts        // Call options to use throughout this session
-}
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var labelRule []interface{}
+	for _, labelItem := range label {
+		labelRule = append(labelRule, labelItem)
+	}
 
-// FIFSRegistrarTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type FIFSRegistrarTransactorSession struct {
-	Contract     *FIFSRegistrarTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
-}
-
-// FIFSRegistrarRaw is an auto generated low-level Go binding around an Ethereum contract.
-type FIFSRegistrarRaw struct {
-	Contract *FIFSRegistrar // Generic contract binding to access the raw methods on
-}
-
-// FIFSRegistrarCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type FIFSRegistrarCallerRaw struct {
-	Contract *FIFSRegistrarCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// FIFSRegistrarTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type FIFSRegistrarTransactorRaw struct {
-	Contract *FIFSRegistrarTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewFIFSRegistrar creates a new instance of FIFSRegistrar, bound to a specific deployed contract.
-func NewFIFSRegistrar(address common.Address, backend bind.ContractBackend) (*FIFSRegistrar, error) {
-	contract, err := bindFIFSRegistrar(address, backend, backend)
+	logs, sub, err := _ENS.contract.FilterLogs(opts, "NewOwner", nodeRule, labelRule)
 	if err != nil {
 		return nil, err
 	}
-	return &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}}, nil
+	return &ENSNewOwnerIterator{contract: _ENS.contract, event: "NewOwner", logs: logs, sub: sub}, nil
 }
 
-// NewFIFSRegistrarCaller creates a new read-only instance of FIFSRegistrar, bound to a specific deployed contract.
-func NewFIFSRegistrarCaller(address common.Address, caller bind.ContractCaller) (*FIFSRegistrarCaller, error) {
-	contract, err := bindFIFSRegistrar(address, caller, nil)
+// WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
+//
+// Solidity: event NewOwner(node indexed bytes32, label indexed bytes32, owner address)
+func (_ENS *ENSFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var labelRule []interface{}
+	for _, labelItem := range label {
+		labelRule = append(labelRule, labelItem)
+	}
+
+	logs, sub, err := _ENS.contract.WatchLogs(opts, "NewOwner", nodeRule, labelRule)
 	if err != nil {
 		return nil, err
 	}
-	return &FIFSRegistrarCaller{contract: contract}, nil
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ENSNewOwner)
+				if err := _ENS.contract.UnpackLog(event, "NewOwner", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
 }
 
-// NewFIFSRegistrarTransactor creates a new write-only instance of FIFSRegistrar, bound to a specific deployed contract.
-func NewFIFSRegistrarTransactor(address common.Address, transactor bind.ContractTransactor) (*FIFSRegistrarTransactor, error) {
-	contract, err := bindFIFSRegistrar(address, nil, transactor)
+// ENSNewResolverIterator is returned from FilterNewResolver and is used to iterate over the raw logs and unpacked data for NewResolver events raised by the ENS contract.
+type ENSNewResolverIterator struct {
+	Event *ENSNewResolver // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ENSNewResolverIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ENSNewResolver)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ENSNewResolver)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *ENSNewResolverIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ENSNewResolverIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// ENSNewResolver represents a NewResolver event raised by the ENS contract.
+type ENSNewResolver struct {
+	Node     [32]byte
+	Resolver common.Address
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
+//
+// Solidity: event NewResolver(node indexed bytes32, resolver address)
+func (_ENS *ENSFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSNewResolverIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _ENS.contract.FilterLogs(opts, "NewResolver", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return &FIFSRegistrarTransactor{contract: contract}, nil
+	return &ENSNewResolverIterator{contract: _ENS.contract, event: "NewResolver", logs: logs, sub: sub}, nil
 }
 
-// bindFIFSRegistrar binds a generic wrapper to an already deployed contract.
-func bindFIFSRegistrar(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
+// WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
+//
+// Solidity: event NewResolver(node indexed bytes32, resolver address)
+func (_ENS *ENSFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSNewResolver, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _ENS.contract.WatchLogs(opts, "NewResolver", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ENSNewResolver)
+				if err := _ENS.contract.UnpackLog(event, "NewResolver", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
 }
 
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_FIFSRegistrar *FIFSRegistrarRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _FIFSRegistrar.Contract.FIFSRegistrarCaller.contract.Call(opts, result, method, params...)
+// ENSNewTTLIterator is returned from FilterNewTTL and is used to iterate over the raw logs and unpacked data for NewTTL events raised by the ENS contract.
+type ENSNewTTLIterator struct {
+	Event *ENSNewTTL // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
 }
 
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_FIFSRegistrar *FIFSRegistrarRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_FIFSRegistrar *FIFSRegistrarRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_FIFSRegistrar *FIFSRegistrarCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _FIFSRegistrar.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.contract.Transact(opts, method, params...)
-}
-
-// Register is a paid mutator transaction binding the contract method 0xd22057a9.
-//
-// Solidity: function register(subnode bytes32, owner address) returns()
-func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, subnode [32]byte, owner common.Address) (*types.Transaction, error) {
-	return _FIFSRegistrar.contract.Transact(opts, "register", subnode, owner)
-}
-
-// Register is a paid mutator transaction binding the contract method 0xd22057a9.
-//
-// Solidity: function register(subnode bytes32, owner address) returns()
-func (_FIFSRegistrar *FIFSRegistrarSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
-}
-
-// Register is a paid mutator transaction binding the contract method 0xd22057a9.
-//
-// Solidity: function register(subnode bytes32, owner address) returns()
-func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
-	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
-}
-
-// PublicResolverABI is the input ABI used to generate the binding from.
-const PublicResolverABI = `[{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"content","outputs":[{"name":"ret","type":"bytes32"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"addr","outputs":[{"name":"ret","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"kind","type":"bytes32"}],"name":"has","outputs":[{"name":"","type":"bool"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"hash","type":"bytes32"}],"name":"setContent","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"addr","type":"address"}],"name":"setAddr","outputs":[],"type":"function"},{"inputs":[{"name":"ensAddr","type":"address"}],"type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"a","type":"address"}],"name":"AddrChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes32"}],"name":"ContentChanged","type":"event"}]`
-
-// PublicResolverBin is the compiled bytecode used for deploying new contracts.
-const PublicResolverBin = `0x606060405260405160208061036783395060806040525160008054600160a060020a0319168217905550610330806100376000396000f36060604052361561004b5760e060020a60003504632dff694181146100535780633b3b57de1461007557806341b9dc2b146100a0578063c3d014d614610139578063d5fa2b00146101b2575b61022b610002565b61022d6004356000818152600260205260408120549081141561027057610002565b61023f600435600081815260016020526040812054600160a060020a03169081141561027057610002565b61025c60043560243560007f6164647200000000000000000000000000000000000000000000000000000000821480156100f05750600083815260016020526040812054600160a060020a031614155b8061013257507f636f6e74656e740000000000000000000000000000000000000000000000000082148015610132575060008381526002602052604081205414155b9392505050565b61022b600435602435600080546040805160e060020a6302571be30281526004810186905290518593600160a060020a033381169416926302571be392602482810193602093839003909101908290876161da5a03f11561000257505060405151600160a060020a031691909114905061027557610002565b61022b600435602435600080546040805160e060020a6302571be30281526004810186905290518593600160a060020a033381169416926302571be392602482810193602093839003909101908290876161da5a03f11561000257505060405151600160a060020a03169190911490506102c157610002565b005b60408051918252519081900360200190f35b60408051600160a060020a03929092168252519081900360200190f35b604080519115158252519081900360200190f35b919050565b6000838152600260209081526040918290208490558151848152915185927f0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc92908290030190a2505050565b600083815260016020908152604091829020805473ffffffffffffffffffffffffffffffffffffffff1916851790558151600160a060020a0385168152915185927f52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd292908290030190a250505056`
-
-// DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it.
-func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error) {
-	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ENSNewTTLIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
 	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(PublicResolverBin), backend, ensAddr)
-	if err != nil {
-		return common.Address{}, nil, nil, err
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ENSNewTTL)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ENSNewTTL)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
 	}
-	return address, tx, &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}}, nil
 }
 
-// PublicResolver is an auto generated Go binding around an Ethereum contract.
-type PublicResolver struct {
-	PublicResolverCaller     // Read-only binding to the contract
-	PublicResolverTransactor // Write-only binding to the contract
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *ENSNewTTLIterator) Error() error {
+	return it.fail
 }
 
-// PublicResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
-type PublicResolverCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ENSNewTTLIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
 }
 
-// PublicResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type PublicResolverTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+// ENSNewTTL represents a NewTTL event raised by the ENS contract.
+type ENSNewTTL struct {
+	Node [32]byte
+	Ttl  uint64
+	Raw  types.Log // Blockchain specific contextual infos
 }
 
-// PublicResolverSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type PublicResolverSession struct {
-	Contract     *PublicResolver   // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
+// FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
+//
+// Solidity: event NewTTL(node indexed bytes32, ttl uint64)
+func (_ENS *ENSFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSNewTTLIterator, error) {
 
-// PublicResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type PublicResolverCallerSession struct {
-	Contract *PublicResolverCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts         // Call options to use throughout this session
-}
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
 
-// PublicResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type PublicResolverTransactorSession struct {
-	Contract     *PublicResolverTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
-}
-
-// PublicResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
-type PublicResolverRaw struct {
-	Contract *PublicResolver // Generic contract binding to access the raw methods on
-}
-
-// PublicResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type PublicResolverCallerRaw struct {
-	Contract *PublicResolverCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// PublicResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type PublicResolverTransactorRaw struct {
-	Contract *PublicResolverTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewPublicResolver creates a new instance of PublicResolver, bound to a specific deployed contract.
-func NewPublicResolver(address common.Address, backend bind.ContractBackend) (*PublicResolver, error) {
-	contract, err := bindPublicResolver(address, backend, backend)
+	logs, sub, err := _ENS.contract.FilterLogs(opts, "NewTTL", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}}, nil
+	return &ENSNewTTLIterator{contract: _ENS.contract, event: "NewTTL", logs: logs, sub: sub}, nil
 }
 
-// NewPublicResolverCaller creates a new read-only instance of PublicResolver, bound to a specific deployed contract.
-func NewPublicResolverCaller(address common.Address, caller bind.ContractCaller) (*PublicResolverCaller, error) {
-	contract, err := bindPublicResolver(address, caller, nil)
+// WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
+//
+// Solidity: event NewTTL(node indexed bytes32, ttl uint64)
+func (_ENS *ENSFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSNewTTL, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _ENS.contract.WatchLogs(opts, "NewTTL", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return &PublicResolverCaller{contract: contract}, nil
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ENSNewTTL)
+				if err := _ENS.contract.UnpackLog(event, "NewTTL", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
 }
 
-// NewPublicResolverTransactor creates a new write-only instance of PublicResolver, bound to a specific deployed contract.
-func NewPublicResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PublicResolverTransactor, error) {
-	contract, err := bindPublicResolver(address, nil, transactor)
+// ENSTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ENS contract.
+type ENSTransferIterator struct {
+	Event *ENSTransfer // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ENSTransferIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ENSTransfer)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ENSTransfer)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *ENSTransferIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ENSTransferIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// ENSTransfer represents a Transfer event raised by the ENS contract.
+type ENSTransfer struct {
+	Node  [32]byte
+	Owner common.Address
+	Raw   types.Log // Blockchain specific contextual infos
+}
+
+// FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
+//
+// Solidity: event Transfer(node indexed bytes32, owner address)
+func (_ENS *ENSFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSTransferIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _ENS.contract.FilterLogs(opts, "Transfer", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return &PublicResolverTransactor{contract: contract}, nil
+	return &ENSTransferIterator{contract: _ENS.contract, event: "Transfer", logs: logs, sub: sub}, nil
 }
 
-// bindPublicResolver binds a generic wrapper to an already deployed contract.
-func bindPublicResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
+// WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
+//
+// Solidity: event Transfer(node indexed bytes32, owner address)
+func (_ENS *ENSFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSTransfer, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _ENS.contract.WatchLogs(opts, "Transfer", nodeRule)
 	if err != nil {
 		return nil, err
 	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_PublicResolver *PublicResolverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _PublicResolver.Contract.PublicResolverCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_PublicResolver *PublicResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _PublicResolver.Contract.PublicResolverTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_PublicResolver *PublicResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _PublicResolver.Contract.PublicResolverTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_PublicResolver *PublicResolverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _PublicResolver.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_PublicResolver *PublicResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _PublicResolver.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_PublicResolver *PublicResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _PublicResolver.Contract.contract.Transact(opts, method, params...)
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
-	var (
-		ret0 = new(common.Address)
-	)
-	out := ret0
-	err := _PublicResolver.contract.Call(opts, out, "addr", node)
-	return *ret0, err
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error) {
-	return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
-	return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) {
-	var (
-		ret0 = new([32]byte)
-	)
-	out := ret0
-	err := _PublicResolver.contract.Call(opts, out, "content", node)
-	return *ret0, err
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error) {
-	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error) {
-	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_PublicResolver *PublicResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.contract.Transact(opts, "has", node, kind)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_PublicResolver *PublicResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.Contract.Has(&_PublicResolver.TransactOpts, node, kind)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_PublicResolver *PublicResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.Contract.Has(&_PublicResolver.TransactOpts, node, kind)
-}
-
-// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
-//
-// Solidity: function setAddr(node bytes32, addr address) returns()
-func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error) {
-	return _PublicResolver.contract.Transact(opts, "setAddr", node, addr)
-}
-
-// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
-//
-// Solidity: function setAddr(node bytes32, addr address) returns()
-func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
-	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
-}
-
-// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
-//
-// Solidity: function setAddr(node bytes32, addr address) returns()
-func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
-	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
-}
-
-// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
-//
-// Solidity: function setContent(node bytes32, hash bytes32) returns()
-func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.contract.Transact(opts, "setContent", node, hash)
-}
-
-// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
-//
-// Solidity: function setContent(node bytes32, hash bytes32) returns()
-func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
-}
-
-// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
-//
-// Solidity: function setContent(node bytes32, hash bytes32) returns()
-func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
-	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
-}
-
-// ResolverABI is the input ABI used to generate the binding from.
-const ResolverABI = `[{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"content","outputs":[{"name":"ret","type":"bytes32"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"addr","outputs":[{"name":"ret","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"kind","type":"bytes32"}],"name":"has","outputs":[{"name":"","type":"bool"}],"type":"function"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"a","type":"address"}],"name":"AddrChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"node","type":"bytes32"},{"indexed":false,"name":"hash","type":"bytes32"}],"name":"ContentChanged","type":"event"}]`
-
-// ResolverBin is the compiled bytecode used for deploying new contracts.
-const ResolverBin = `0x`
-
-// DeployResolver deploys a new Ethereum contract, binding an instance of Resolver to it.
-func DeployResolver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Resolver, error) {
-	parsed, err := abi.JSON(strings.NewReader(ResolverABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ResolverBin), backend)
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	return address, tx, &Resolver{ResolverCaller: ResolverCaller{contract: contract}, ResolverTransactor: ResolverTransactor{contract: contract}}, nil
-}
-
-// Resolver is an auto generated Go binding around an Ethereum contract.
-type Resolver struct {
-	ResolverCaller     // Read-only binding to the contract
-	ResolverTransactor // Write-only binding to the contract
-}
-
-// ResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
-type ResolverCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type ResolverTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ResolverSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type ResolverSession struct {
-	Contract     *Resolver         // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// ResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type ResolverCallerSession struct {
-	Contract *ResolverCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts   // Call options to use throughout this session
-}
-
-// ResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type ResolverTransactorSession struct {
-	Contract     *ResolverTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
-}
-
-// ResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
-type ResolverRaw struct {
-	Contract *Resolver // Generic contract binding to access the raw methods on
-}
-
-// ResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type ResolverCallerRaw struct {
-	Contract *ResolverCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// ResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type ResolverTransactorRaw struct {
-	Contract *ResolverTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewResolver creates a new instance of Resolver, bound to a specific deployed contract.
-func NewResolver(address common.Address, backend bind.ContractBackend) (*Resolver, error) {
-	contract, err := bindResolver(address, backend, backend)
-	if err != nil {
-		return nil, err
-	}
-	return &Resolver{ResolverCaller: ResolverCaller{contract: contract}, ResolverTransactor: ResolverTransactor{contract: contract}}, nil
-}
-
-// NewResolverCaller creates a new read-only instance of Resolver, bound to a specific deployed contract.
-func NewResolverCaller(address common.Address, caller bind.ContractCaller) (*ResolverCaller, error) {
-	contract, err := bindResolver(address, caller, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &ResolverCaller{contract: contract}, nil
-}
-
-// NewResolverTransactor creates a new write-only instance of Resolver, bound to a specific deployed contract.
-func NewResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ResolverTransactor, error) {
-	contract, err := bindResolver(address, nil, transactor)
-	if err != nil {
-		return nil, err
-	}
-	return &ResolverTransactor{contract: contract}, nil
-}
-
-// bindResolver binds a generic wrapper to an already deployed contract.
-func bindResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(ResolverABI))
-	if err != nil {
-		return nil, err
-	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Resolver *ResolverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Resolver.Contract.ResolverCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Resolver *ResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Resolver.Contract.ResolverTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Resolver *ResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Resolver.Contract.ResolverTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Resolver *ResolverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Resolver.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Resolver *ResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Resolver.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Resolver *ResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Resolver.Contract.contract.Transact(opts, method, params...)
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_Resolver *ResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
-	var (
-		ret0 = new(common.Address)
-	)
-	out := ret0
-	err := _Resolver.contract.Call(opts, out, "addr", node)
-	return *ret0, err
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_Resolver *ResolverSession) Addr(node [32]byte) (common.Address, error) {
-	return _Resolver.Contract.Addr(&_Resolver.CallOpts, node)
-}
-
-// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
-//
-// Solidity: function addr(node bytes32) constant returns(ret address)
-func (_Resolver *ResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
-	return _Resolver.Contract.Addr(&_Resolver.CallOpts, node)
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_Resolver *ResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) {
-	var (
-		ret0 = new([32]byte)
-	)
-	out := ret0
-	err := _Resolver.contract.Call(opts, out, "content", node)
-	return *ret0, err
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_Resolver *ResolverSession) Content(node [32]byte) ([32]byte, error) {
-	return _Resolver.Contract.Content(&_Resolver.CallOpts, node)
-}
-
-// Content is a free data retrieval call binding the contract method 0x2dff6941.
-//
-// Solidity: function content(node bytes32) constant returns(ret bytes32)
-func (_Resolver *ResolverCallerSession) Content(node [32]byte) ([32]byte, error) {
-	return _Resolver.Contract.Content(&_Resolver.CallOpts, node)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_Resolver *ResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _Resolver.contract.Transact(opts, "has", node, kind)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_Resolver *ResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _Resolver.Contract.Has(&_Resolver.TransactOpts, node, kind)
-}
-
-// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
-//
-// Solidity: function has(node bytes32, kind bytes32) returns(bool)
-func (_Resolver *ResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
-	return _Resolver.Contract.Has(&_Resolver.TransactOpts, node, kind)
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ENSTransfer)
+				if err := _ENS.contract.UnpackLog(event, "Transfer", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
 }
diff --git a/contracts/ens/contract/ens.sol b/contracts/ens/contract/ens.sol
deleted file mode 100644
index 114cd7319f..0000000000
--- a/contracts/ens/contract/ens.sol
+++ /dev/null
@@ -1,226 +0,0 @@
-// Ethereum Name Service contracts by Nick Johnson 
-// 
-// To the extent possible under law, the person who associated CC0 with
-// ENS contracts has waived all copyright and related or neighboring rights
-// to ENS.
-// 
-// You should have received a copy of the CC0 legalcode along with this
-// work.  If not, see .
-
-/**
- * The ENS registry contract.
- */
-contract ENS {
-    struct Record {
-        address owner;
-        address resolver;
-    }
-    
-    mapping(bytes32=>Record) records;
-    
-    // Logged when the owner of a node assigns a new owner to a subnode.
-    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
-
-    // Logged when the owner of a node transfers ownership to a new account.
-    event Transfer(bytes32 indexed node, address owner);
-
-    // Logged when the owner of a node changes the resolver for that node.
-    event NewResolver(bytes32 indexed node, address resolver);
-    
-    // Permits modifications only by the owner of the specified node.
-    modifier only_owner(bytes32 node) {
-        if(records[node].owner != msg.sender) throw;
-        _
-    }
-    
-    /**
-     * Constructs a new ENS registrar, with the provided address as the owner of the root node.
-     */
-    function ENS(address owner) {
-        records[0].owner = owner;
-    }
-    
-    /**
-     * Returns the address that owns the specified node.
-     */
-    function owner(bytes32 node) constant returns (address) {
-        return records[node].owner;
-    }
-    
-    /**
-     * Returns the address of the resolver for the specified node.
-     */
-    function resolver(bytes32 node) constant returns (address) {
-        return records[node].resolver;
-    }
-
-    /**
-     * Transfers ownership of a node to a new address. May only be called by the current
-     * owner of the node.
-     * @param node The node to transfer ownership of.
-     * @param owner The address of the new owner.
-     */
-    function setOwner(bytes32 node, address owner) only_owner(node) {
-        Transfer(node, owner);
-        records[node].owner = owner;
-    }
-
-    /**
-     * Transfers ownership of a subnode sha3(node, label) to a new address. May only be
-     * called by the owner of the parent node.
-     * @param node The parent node.
-     * @param label The hash of the label specifying the subnode.
-     * @param owner The address of the new owner.
-     */
-    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) only_owner(node) {
-        var subnode = sha3(node, label);
-        NewOwner(node, label, owner);
-        records[subnode].owner = owner;
-    }
-
-    /**
-     * Sets the resolver address for the specified node.
-     * @param node The node to update.
-     * @param resolver The address of the resolver.
-     */
-    function setResolver(bytes32 node, address resolver) only_owner(node) {
-        NewResolver(node, resolver);
-        records[node].resolver = resolver;
-    }
-}
-
-/**
- * A registrar that allocates subdomains to the first person to claim them. It also deploys
- * a simple resolver contract and sets that as the default resolver on new names for
- * convenience.
- */
-contract FIFSRegistrar {
-    ENS ens;
-    PublicResolver defaultResolver;
-    bytes32 rootNode;
-    
-    /**
-     * Constructor.
-     * @param ensAddr The address of the ENS registry.
-     * @param node The node that this registrar administers.
-     */
-    function FIFSRegistrar(address ensAddr, bytes32 node) {
-        ens = ENS(ensAddr);
-        defaultResolver = new PublicResolver(ensAddr);
-        rootNode = node;
-    }
-
-    /**
-     * Register a name, or change the owner of an existing registration.
-     * @param subnode The hash of the label to register.
-     * @param owner The address of the new owner.
-     */    
-    function register(bytes32 subnode, address owner) {
-        var node = sha3(rootNode, subnode);
-        var currentOwner = ens.owner(node);
-        if(currentOwner != 0 && currentOwner != msg.sender)
-            throw;
-
-        // Temporarily set ourselves as the owner
-        ens.setSubnodeOwner(rootNode, subnode, this);
-        // Set up the default resolver
-        ens.setResolver(node, defaultResolver);
-        // Set the owner to the real owner
-        ens.setOwner(node, owner);
-    }
-}
-
-contract Resolver {
-    event AddrChanged(bytes32 indexed node, address a);
-    event ContentChanged(bytes32 indexed node, bytes32 hash);
-
-    function has(bytes32 node, bytes32 kind) returns (bool);
-    function addr(bytes32 node) constant returns (address ret);
-    function content(bytes32 node) constant returns (bytes32 ret);
-}
-
-/**
- * A simple resolver anyone can use; only allows the owner of a node to set its
- * address.
- */
-contract PublicResolver is Resolver {
-    ENS ens;
-    mapping(bytes32=>address) addresses;
-    mapping(bytes32=>bytes32) contents;
-    
-    modifier only_owner(bytes32 node) {
-        if(ens.owner(node) != msg.sender) throw;
-        _
-    }
-
-    /**
-     * Constructor.
-     * @param ensAddr The ENS registrar contract.
-     */
-    function PublicResolver(address ensAddr) {
-        ens = ENS(ensAddr);
-    }
-
-    /**
-     * Fallback function.
-     */
-    function() {
-        throw;
-    }
-
-    /**
-     * Returns true if the specified node has the specified record type.
-     * @param node The ENS node to query.
-     * @param kind The record type name, as specified in EIP137.
-     * @return True if this resolver has a record of the provided type on the
-     *         provided node.
-     */
-    function has(bytes32 node, bytes32 kind) returns (bool) {
-        return (kind == "addr" && addresses[node] != 0) ||
-               (kind == "content" && contents[node] != 0);
-    }
-    
-    /**
-     * Returns the address associated with an ENS node.
-     * @param node The ENS node to query.
-     * @return The associated address.
-     */
-    function addr(bytes32 node) constant returns (address ret) {
-        ret = addresses[node];
-        if(ret == 0)
-            throw;
-    }
-    
-    /**
-     * Returns the content hash associated with an ENS node.
-     * @param node The ENS node to query.
-     * @return The associated content hash.
-     */
-    function content(bytes32 node) constant returns (bytes32 ret) {
-        ret = contents[node];
-        if(ret == 0)
-            throw;
-    }
-
-    /**
-     * Sets the address associated with an ENS node.
-     * May only be called by the owner of that node in the ENS registry.
-     * @param node The node to update.
-     * @param addr The address to set.
-     */
-    function setAddr(bytes32 node, address addr) only_owner(node) {
-        addresses[node] = addr;
-        AddrChanged(node, addr);
-    }
-    
-    /**
-     * Sets the content hash associated with an ENS node.
-     * May only be called by the owner of that node in the ENS registry.
-     * @param node The node to update.
-     * @param hash The content hash to set.
-     */
-    function setContent(bytes32 node, bytes32 hash) only_owner(node) {
-        contents[node] = hash;
-        ContentChanged(node, hash);
-    }
-}
diff --git a/contracts/ens/contract/fifsregistrar.go b/contracts/ens/contract/fifsregistrar.go
new file mode 100644
index 0000000000..a08380adfc
--- /dev/null
+++ b/contracts/ens/contract/fifsregistrar.go
@@ -0,0 +1,195 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package contract
+
+import (
+	"strings"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// FIFSRegistrarABI is the input ABI used to generate the binding from.
+const FIFSRegistrarABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"subnode\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"},{\"name\":\"node\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"
+
+// FIFSRegistrarBin is the compiled bytecode used for deploying new contracts.
+const FIFSRegistrarBin = `0x6060604052341561000f57600080fd5b604051604080610224833981016040528080519190602001805160008054600160a060020a03909516600160a060020a03199095169490941790935550506001556101c58061005f6000396000f3006060604052600436106100275763ffffffff60e060020a600035041663d22057a9811461002c575b600080fd5b341561003757600080fd5b61004e600435600160a060020a0360243516610050565b005b816000806001548360405191825260208201526040908101905190819003902060008054919350600160a060020a03909116906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b15156100c857600080fd5b6102c65a03f115156100d957600080fd5b5050506040518051915050600160a060020a0381161580159061010e575033600160a060020a031681600160a060020a031614155b1561011857600080fd5b600054600154600160a060020a03909116906306ab592390878760405160e060020a63ffffffff861602815260048101939093526024830191909152600160a060020a03166044820152606401600060405180830381600087803b151561017e57600080fd5b6102c65a03f1151561018f57600080fd5b50505050505050505600a165627a7a723058206fb963cb168d5e3a51af12cd6bb23e324dbd32dd4954f43653ba27e66b68ea650029`
+
+// DeployFIFSRegistrar deploys a new Ethereum contract, binding an instance of FIFSRegistrar to it.
+func DeployFIFSRegistrar(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address, node [32]byte) (common.Address, *types.Transaction, *FIFSRegistrar, error) {
+	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(FIFSRegistrarBin), backend, ensAddr, node)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}, FIFSRegistrarFilterer: FIFSRegistrarFilterer{contract: contract}}, nil
+}
+
+// FIFSRegistrar is an auto generated Go binding around an Ethereum contract.
+type FIFSRegistrar struct {
+	FIFSRegistrarCaller     // Read-only binding to the contract
+	FIFSRegistrarTransactor // Write-only binding to the contract
+	FIFSRegistrarFilterer   // Log filterer for contract events
+}
+
+// FIFSRegistrarCaller is an auto generated read-only Go binding around an Ethereum contract.
+type FIFSRegistrarCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FIFSRegistrarTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type FIFSRegistrarTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FIFSRegistrarFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type FIFSRegistrarFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FIFSRegistrarSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type FIFSRegistrarSession struct {
+	Contract     *FIFSRegistrar    // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// FIFSRegistrarCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type FIFSRegistrarCallerSession struct {
+	Contract *FIFSRegistrarCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// FIFSRegistrarTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type FIFSRegistrarTransactorSession struct {
+	Contract     *FIFSRegistrarTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// FIFSRegistrarRaw is an auto generated low-level Go binding around an Ethereum contract.
+type FIFSRegistrarRaw struct {
+	Contract *FIFSRegistrar // Generic contract binding to access the raw methods on
+}
+
+// FIFSRegistrarCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type FIFSRegistrarCallerRaw struct {
+	Contract *FIFSRegistrarCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// FIFSRegistrarTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type FIFSRegistrarTransactorRaw struct {
+	Contract *FIFSRegistrarTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewFIFSRegistrar creates a new instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrar(address common.Address, backend bind.ContractBackend) (*FIFSRegistrar, error) {
+	contract, err := bindFIFSRegistrar(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}, FIFSRegistrarFilterer: FIFSRegistrarFilterer{contract: contract}}, nil
+}
+
+// NewFIFSRegistrarCaller creates a new read-only instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrarCaller(address common.Address, caller bind.ContractCaller) (*FIFSRegistrarCaller, error) {
+	contract, err := bindFIFSRegistrar(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrarCaller{contract: contract}, nil
+}
+
+// NewFIFSRegistrarTransactor creates a new write-only instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrarTransactor(address common.Address, transactor bind.ContractTransactor) (*FIFSRegistrarTransactor, error) {
+	contract, err := bindFIFSRegistrar(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrarTransactor{contract: contract}, nil
+}
+
+// NewFIFSRegistrarFilterer creates a new log filterer instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrarFilterer(address common.Address, filterer bind.ContractFilterer) (*FIFSRegistrarFilterer, error) {
+	contract, err := bindFIFSRegistrar(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrarFilterer{contract: contract}, nil
+}
+
+// bindFIFSRegistrar binds a generic wrapper to an already deployed contract.
+func bindFIFSRegistrar(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_FIFSRegistrar *FIFSRegistrarRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _FIFSRegistrar.Contract.FIFSRegistrarCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_FIFSRegistrar *FIFSRegistrarRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FIFSRegistrar *FIFSRegistrarRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_FIFSRegistrar *FIFSRegistrarCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _FIFSRegistrar.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.contract.Transact(opts, method, params...)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.contract.Transact(opts, "register", subnode, owner)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
+}
diff --git a/contracts/ens/contract/publicresolver.go b/contracts/ens/contract/publicresolver.go
new file mode 100644
index 0000000000..c567d5884a
--- /dev/null
+++ b/contracts/ens/contract/publicresolver.go
@@ -0,0 +1,1321 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package contract
+
+import (
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// PublicResolverABI is the input ABI used to generate the binding from.
+const PublicResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"content\",\"outputs\":[{\"name\":\"ret\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"ret\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"ret\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"setContent\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"ensAddr\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes32\"}],\"name\":\"ContentChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"}]"
+
+// PublicResolverBin is the compiled bytecode used for deploying new contracts.
+const PublicResolverBin = `0x6060604052341561000f57600080fd5b6040516020806111b28339810160405280805160008054600160a060020a03909216600160a060020a0319909216919091179055505061115e806100546000396000f3006060604052600436106100ab5763ffffffff60e060020a60003504166301ffc9a781146100b057806310f13a8c146100e45780632203ab561461017e57806329cd62ea146102155780632dff6941146102315780633b3b57de1461025957806359d1d43c1461028b578063623195b014610358578063691f3431146103b457806377372213146103ca578063c3d014d614610420578063c869023314610439578063d5fa2b0014610467575b600080fd5b34156100bb57600080fd5b6100d0600160e060020a031960043516610489565b604051901515815260200160405180910390f35b34156100ef57600080fd5b61017c600480359060446024803590810190830135806020601f8201819004810201604051908101604052818152929190602084018383808284378201915050505050509190803590602001908201803590602001908080601f0160208091040260200160405190810160405281815292919060208401838380828437509496506105f695505050505050565b005b341561018957600080fd5b610197600435602435610807565b60405182815260406020820181815290820183818151815260200191508051906020019080838360005b838110156101d95780820151838201526020016101c1565b50505050905090810190601f1680156102065780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561022057600080fd5b61017c600435602435604435610931565b341561023c57600080fd5b610247600435610a30565b60405190815260200160405180910390f35b341561026457600080fd5b61026f600435610a46565b604051600160a060020a03909116815260200160405180910390f35b341561029657600080fd5b6102e1600480359060446024803590810190830135806020601f82018190048102016040519081016040528181529291906020840183838082843750949650610a6195505050505050565b60405160208082528190810183818151815260200191508051906020019080838360005b8381101561031d578082015183820152602001610305565b50505050905090810190601f16801561034a5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b341561036357600080fd5b61017c600480359060248035919060649060443590810190830135806020601f82018190048102016040519081016040528181529291906020840183838082843750949650610b8095505050505050565b34156103bf57600080fd5b6102e1600435610c7c565b34156103d557600080fd5b61017c600480359060446024803590810190830135806020601f82018190048102016040519081016040528181529291906020840183838082843750949650610d4295505050505050565b341561042b57600080fd5b61017c600435602435610e8c565b341561044457600080fd5b61044f600435610f65565b60405191825260208201526040908101905180910390f35b341561047257600080fd5b61017c600435600160a060020a0360243516610f82565b6000600160e060020a031982167f3b3b57de0000000000000000000000000000000000000000000000000000000014806104ec5750600160e060020a031982167fd8389dc500000000000000000000000000000000000000000000000000000000145b806105205750600160e060020a031982167f691f343100000000000000000000000000000000000000000000000000000000145b806105545750600160e060020a031982167f2203ab5600000000000000000000000000000000000000000000000000000000145b806105885750600160e060020a031982167fc869023300000000000000000000000000000000000000000000000000000000145b806105bc5750600160e060020a031982167f59d1d43c00000000000000000000000000000000000000000000000000000000145b806105f05750600160e060020a031982167f01ffc9a700000000000000000000000000000000000000000000000000000000145b92915050565b600080548491600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b151561064f57600080fd5b6102c65a03f1151561066057600080fd5b50505060405180519050600160a060020a031614151561067f57600080fd5b6000848152600160205260409081902083916005909101908590518082805190602001908083835b602083106106c65780518252601f1990920191602091820191016106a7565b6001836020036101000a038019825116818451168082178552505050505050905001915050908152602001604051809103902090805161070a929160200190611085565b50826040518082805190602001908083835b6020831061073b5780518252601f19909201916020918201910161071c565b6001836020036101000a0380198251168184511617909252505050919091019250604091505051908190039020847fd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a75508560405160208082528190810183818151815260200191508051906020019080838360005b838110156107c75780820151838201526020016107af565b50505050905090810190601f1680156107f45780820380516001836020036101000a031916815260200191505b509250505060405180910390a350505050565b6000610811611103565b60008481526001602081905260409091209092505b838311610924578284161580159061085f5750600083815260068201602052604081205460026000196101006001841615020190911604115b15610919578060060160008481526020019081526020016000208054600181600116156101000203166002900480601f01602080910402602001604051908101604052809291908181526020018280546001816001161561010002031660029004801561090d5780601f106108e25761010080835404028352916020019161090d565b820191906000526020600020905b8154815290600101906020018083116108f057829003601f168201915b50505050509150610929565b600290920291610826565b600092505b509250929050565b600080548491600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b151561098a57600080fd5b6102c65a03f1151561099b57600080fd5b50505060405180519050600160a060020a03161415156109ba57600080fd5b6040805190810160409081528482526020808301859052600087815260019091522060030181518155602082015160019091015550837f1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46848460405191825260208201526040908101905180910390a250505050565b6000908152600160208190526040909120015490565b600090815260016020526040902054600160a060020a031690565b610a69611103565b60008381526001602052604090819020600501908390518082805190602001908083835b60208310610aac5780518252601f199092019160209182019101610a8d565b6001836020036101000a03801982511681845116808217855250505050505090500191505090815260200160405180910390208054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610b735780601f10610b4857610100808354040283529160200191610b73565b820191906000526020600020905b815481529060010190602001808311610b5657829003601f168201915b5050505050905092915050565b600080548491600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b1515610bd957600080fd5b6102c65a03f11515610bea57600080fd5b50505060405180519050600160a060020a0316141515610c0957600080fd5b6000198301831615610c1a57600080fd5b60008481526001602090815260408083208684526006019091529020828051610c47929160200190611085565b5082847faa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe360405160405180910390a350505050565b610c84611103565b6001600083600019166000191681526020019081526020016000206002018054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610d365780601f10610d0b57610100808354040283529160200191610d36565b820191906000526020600020905b815481529060010190602001808311610d1957829003601f168201915b50505050509050919050565b600080548391600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b1515610d9b57600080fd5b6102c65a03f11515610dac57600080fd5b50505060405180519050600160a060020a0316141515610dcb57600080fd5b6000838152600160205260409020600201828051610ded929160200190611085565b50827fb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f78360405160208082528190810183818151815260200191508051906020019080838360005b83811015610e4d578082015183820152602001610e35565b50505050905090810190601f168015610e7a5780820380516001836020036101000a031916815260200191505b509250505060405180910390a2505050565b600080548391600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b1515610ee557600080fd5b6102c65a03f11515610ef657600080fd5b50505060405180519050600160a060020a0316141515610f1557600080fd5b6000838152600160208190526040918290200183905583907f0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc9084905190815260200160405180910390a2505050565b600090815260016020526040902060038101546004909101549091565b600080548391600160a060020a033381169216906302571be39084906040516020015260405160e060020a63ffffffff84160281526004810191909152602401602060405180830381600087803b1515610fdb57600080fd5b6102c65a03f11515610fec57600080fd5b50505060405180519050600160a060020a031614151561100b57600080fd5b60008381526001602052604090819020805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a03851617905583907f52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd290849051600160a060020a03909116815260200160405180910390a2505050565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106110c657805160ff19168380011785556110f3565b828001600101855582156110f3579182015b828111156110f35782518255916020019190600101906110d8565b506110ff929150611115565b5090565b60206040519081016040526000815290565b61112f91905b808211156110ff576000815560010161111b565b905600a165627a7a723058201ecacbc445b9fbcd91b0ab164389f69d7283b856883bc7437eeed1008345a4920029`
+
+// DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it.
+func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error) {
+	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(PublicResolverBin), backend, ensAddr)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}, PublicResolverFilterer: PublicResolverFilterer{contract: contract}}, nil
+}
+
+// PublicResolver is an auto generated Go binding around an Ethereum contract.
+type PublicResolver struct {
+	PublicResolverCaller     // Read-only binding to the contract
+	PublicResolverTransactor // Write-only binding to the contract
+	PublicResolverFilterer   // Log filterer for contract events
+}
+
+// PublicResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
+type PublicResolverCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PublicResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type PublicResolverTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PublicResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type PublicResolverFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// PublicResolverSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type PublicResolverSession struct {
+	Contract     *PublicResolver   // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// PublicResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type PublicResolverCallerSession struct {
+	Contract *PublicResolverCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// PublicResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type PublicResolverTransactorSession struct {
+	Contract     *PublicResolverTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// PublicResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
+type PublicResolverRaw struct {
+	Contract *PublicResolver // Generic contract binding to access the raw methods on
+}
+
+// PublicResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type PublicResolverCallerRaw struct {
+	Contract *PublicResolverCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// PublicResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type PublicResolverTransactorRaw struct {
+	Contract *PublicResolverTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewPublicResolver creates a new instance of PublicResolver, bound to a specific deployed contract.
+func NewPublicResolver(address common.Address, backend bind.ContractBackend) (*PublicResolver, error) {
+	contract, err := bindPublicResolver(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}, PublicResolverFilterer: PublicResolverFilterer{contract: contract}}, nil
+}
+
+// NewPublicResolverCaller creates a new read-only instance of PublicResolver, bound to a specific deployed contract.
+func NewPublicResolverCaller(address common.Address, caller bind.ContractCaller) (*PublicResolverCaller, error) {
+	contract, err := bindPublicResolver(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverCaller{contract: contract}, nil
+}
+
+// NewPublicResolverTransactor creates a new write-only instance of PublicResolver, bound to a specific deployed contract.
+func NewPublicResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PublicResolverTransactor, error) {
+	contract, err := bindPublicResolver(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverTransactor{contract: contract}, nil
+}
+
+// NewPublicResolverFilterer creates a new log filterer instance of PublicResolver, bound to a specific deployed contract.
+func NewPublicResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*PublicResolverFilterer, error) {
+	contract, err := bindPublicResolver(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverFilterer{contract: contract}, nil
+}
+
+// bindPublicResolver binds a generic wrapper to an already deployed contract.
+func bindPublicResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_PublicResolver *PublicResolverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _PublicResolver.Contract.PublicResolverCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_PublicResolver *PublicResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PublicResolver.Contract.PublicResolverTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PublicResolver *PublicResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PublicResolver.Contract.PublicResolverTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_PublicResolver *PublicResolverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _PublicResolver.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_PublicResolver *PublicResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _PublicResolver.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_PublicResolver *PublicResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _PublicResolver.Contract.contract.Transact(opts, method, params...)
+}
+
+// ABI is a free data retrieval call binding the contract method 0x2203ab56.
+//
+// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes)
+func (_PublicResolver *PublicResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (struct {
+	ContentType *big.Int
+	Data        []byte
+}, error) {
+	ret := new(struct {
+		ContentType *big.Int
+		Data        []byte
+	})
+	out := ret
+	err := _PublicResolver.contract.Call(opts, out, "ABI", node, contentTypes)
+	return *ret, err
+}
+
+// ABI is a free data retrieval call binding the contract method 0x2203ab56.
+//
+// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes)
+func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (struct {
+	ContentType *big.Int
+	Data        []byte
+}, error) {
+	return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes)
+}
+
+// ABI is a free data retrieval call binding the contract method 0x2203ab56.
+//
+// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes)
+func (_PublicResolver *PublicResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (struct {
+	ContentType *big.Int
+	Data        []byte
+}, error) {
+	return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes)
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
+	var (
+		ret0 = new(common.Address)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "addr", node)
+	return *ret0, err
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error) {
+	return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
+	return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) {
+	var (
+		ret0 = new([32]byte)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "content", node)
+	return *ret0, err
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error) {
+	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error) {
+	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
+}
+
+// Name is a free data retrieval call binding the contract method 0x691f3431.
+//
+// Solidity: function name(node bytes32) constant returns(ret string)
+func (_PublicResolver *PublicResolverCaller) Name(opts *bind.CallOpts, node [32]byte) (string, error) {
+	var (
+		ret0 = new(string)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "name", node)
+	return *ret0, err
+}
+
+// Name is a free data retrieval call binding the contract method 0x691f3431.
+//
+// Solidity: function name(node bytes32) constant returns(ret string)
+func (_PublicResolver *PublicResolverSession) Name(node [32]byte) (string, error) {
+	return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node)
+}
+
+// Name is a free data retrieval call binding the contract method 0x691f3431.
+//
+// Solidity: function name(node bytes32) constant returns(ret string)
+func (_PublicResolver *PublicResolverCallerSession) Name(node [32]byte) (string, error) {
+	return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node)
+}
+
+// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
+//
+// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32)
+func (_PublicResolver *PublicResolverCaller) Pubkey(opts *bind.CallOpts, node [32]byte) (struct {
+	X [32]byte
+	Y [32]byte
+}, error) {
+	ret := new(struct {
+		X [32]byte
+		Y [32]byte
+	})
+	out := ret
+	err := _PublicResolver.contract.Call(opts, out, "pubkey", node)
+	return *ret, err
+}
+
+// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
+//
+// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32)
+func (_PublicResolver *PublicResolverSession) Pubkey(node [32]byte) (struct {
+	X [32]byte
+	Y [32]byte
+}, error) {
+	return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node)
+}
+
+// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
+//
+// Solidity: function pubkey(node bytes32) constant returns(x bytes32, y bytes32)
+func (_PublicResolver *PublicResolverCallerSession) Pubkey(node [32]byte) (struct {
+	X [32]byte
+	Y [32]byte
+}, error) {
+	return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node)
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool)
+func (_PublicResolver *PublicResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
+	var (
+		ret0 = new(bool)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "supportsInterface", interfaceID)
+	return *ret0, err
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool)
+func (_PublicResolver *PublicResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
+	return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID)
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(interfaceID bytes4) constant returns(bool)
+func (_PublicResolver *PublicResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
+	return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID)
+}
+
+// Text is a free data retrieval call binding the contract method 0x59d1d43c.
+//
+// Solidity: function text(node bytes32, key string) constant returns(ret string)
+func (_PublicResolver *PublicResolverCaller) Text(opts *bind.CallOpts, node [32]byte, key string) (string, error) {
+	var (
+		ret0 = new(string)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "text", node, key)
+	return *ret0, err
+}
+
+// Text is a free data retrieval call binding the contract method 0x59d1d43c.
+//
+// Solidity: function text(node bytes32, key string) constant returns(ret string)
+func (_PublicResolver *PublicResolverSession) Text(node [32]byte, key string) (string, error) {
+	return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key)
+}
+
+// Text is a free data retrieval call binding the contract method 0x59d1d43c.
+//
+// Solidity: function text(node bytes32, key string) constant returns(ret string)
+func (_PublicResolver *PublicResolverCallerSession) Text(node [32]byte, key string) (string, error) {
+	return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key)
+}
+
+// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
+//
+// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns()
+func (_PublicResolver *PublicResolverTransactor) SetABI(opts *bind.TransactOpts, node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setABI", node, contentType, data)
+}
+
+// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
+//
+// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns()
+func (_PublicResolver *PublicResolverSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data)
+}
+
+// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
+//
+// Solidity: function setABI(node bytes32, contentType uint256, data bytes) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setAddr", node, addr)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setContent", node, hash)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
+}
+
+// SetName is a paid mutator transaction binding the contract method 0x77372213.
+//
+// Solidity: function setName(node bytes32, name string) returns()
+func (_PublicResolver *PublicResolverTransactor) SetName(opts *bind.TransactOpts, node [32]byte, name string) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setName", node, name)
+}
+
+// SetName is a paid mutator transaction binding the contract method 0x77372213.
+//
+// Solidity: function setName(node bytes32, name string) returns()
+func (_PublicResolver *PublicResolverSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name)
+}
+
+// SetName is a paid mutator transaction binding the contract method 0x77372213.
+//
+// Solidity: function setName(node bytes32, name string) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name)
+}
+
+// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
+//
+// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns()
+func (_PublicResolver *PublicResolverTransactor) SetPubkey(opts *bind.TransactOpts, node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setPubkey", node, x, y)
+}
+
+// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
+//
+// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns()
+func (_PublicResolver *PublicResolverSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y)
+}
+
+// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
+//
+// Solidity: function setPubkey(node bytes32, x bytes32, y bytes32) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y)
+}
+
+// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
+//
+// Solidity: function setText(node bytes32, key string, value string) returns()
+func (_PublicResolver *PublicResolverTransactor) SetText(opts *bind.TransactOpts, node [32]byte, key string, value string) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setText", node, key, value)
+}
+
+// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
+//
+// Solidity: function setText(node bytes32, key string, value string) returns()
+func (_PublicResolver *PublicResolverSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value)
+}
+
+// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
+//
+// Solidity: function setText(node bytes32, key string, value string) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value)
+}
+
+// PublicResolverABIChangedIterator is returned from FilterABIChanged and is used to iterate over the raw logs and unpacked data for ABIChanged events raised by the PublicResolver contract.
+type PublicResolverABIChangedIterator struct {
+	Event *PublicResolverABIChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverABIChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverABIChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverABIChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverABIChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverABIChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverABIChanged represents a ABIChanged event raised by the PublicResolver contract.
+type PublicResolverABIChanged struct {
+	Node        [32]byte
+	ContentType *big.Int
+	Raw         types.Log // Blockchain specific contextual infos
+}
+
+// FilterABIChanged is a free log retrieval operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
+//
+// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256)
+func (_PublicResolver *PublicResolverFilterer) FilterABIChanged(opts *bind.FilterOpts, node [][32]byte, contentType []*big.Int) (*PublicResolverABIChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var contentTypeRule []interface{}
+	for _, contentTypeItem := range contentType {
+		contentTypeRule = append(contentTypeRule, contentTypeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverABIChangedIterator{contract: _PublicResolver.contract, event: "ABIChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchABIChanged is a free log subscription operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
+//
+// Solidity: event ABIChanged(node indexed bytes32, contentType indexed uint256)
+func (_PublicResolver *PublicResolverFilterer) WatchABIChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverABIChanged, node [][32]byte, contentType []*big.Int) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var contentTypeRule []interface{}
+	for _, contentTypeItem := range contentType {
+		contentTypeRule = append(contentTypeRule, contentTypeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverABIChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// PublicResolverAddrChangedIterator is returned from FilterAddrChanged and is used to iterate over the raw logs and unpacked data for AddrChanged events raised by the PublicResolver contract.
+type PublicResolverAddrChangedIterator struct {
+	Event *PublicResolverAddrChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverAddrChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverAddrChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverAddrChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverAddrChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverAddrChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverAddrChanged represents a AddrChanged event raised by the PublicResolver contract.
+type PublicResolverAddrChanged struct {
+	Node [32]byte
+	A    common.Address
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
+//
+// Solidity: event AddrChanged(node indexed bytes32, a address)
+func (_PublicResolver *PublicResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverAddrChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "AddrChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverAddrChangedIterator{contract: _PublicResolver.contract, event: "AddrChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
+//
+// Solidity: event AddrChanged(node indexed bytes32, a address)
+func (_PublicResolver *PublicResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAddrChanged, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "AddrChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverAddrChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// PublicResolverContentChangedIterator is returned from FilterContentChanged and is used to iterate over the raw logs and unpacked data for ContentChanged events raised by the PublicResolver contract.
+type PublicResolverContentChangedIterator struct {
+	Event *PublicResolverContentChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverContentChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverContentChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverContentChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverContentChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverContentChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverContentChanged represents a ContentChanged event raised by the PublicResolver contract.
+type PublicResolverContentChanged struct {
+	Node [32]byte
+	Hash [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterContentChanged is a free log retrieval operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc.
+//
+// Solidity: event ContentChanged(node indexed bytes32, hash bytes32)
+func (_PublicResolver *PublicResolverFilterer) FilterContentChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverContentChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ContentChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverContentChangedIterator{contract: _PublicResolver.contract, event: "ContentChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchContentChanged is a free log subscription operation binding the contract event 0x0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc.
+//
+// Solidity: event ContentChanged(node indexed bytes32, hash bytes32)
+func (_PublicResolver *PublicResolverFilterer) WatchContentChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverContentChanged, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ContentChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverContentChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "ContentChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// PublicResolverNameChangedIterator is returned from FilterNameChanged and is used to iterate over the raw logs and unpacked data for NameChanged events raised by the PublicResolver contract.
+type PublicResolverNameChangedIterator struct {
+	Event *PublicResolverNameChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverNameChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverNameChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverNameChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverNameChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverNameChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverNameChanged represents a NameChanged event raised by the PublicResolver contract.
+type PublicResolverNameChanged struct {
+	Node [32]byte
+	Name string
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterNameChanged is a free log retrieval operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
+//
+// Solidity: event NameChanged(node indexed bytes32, name string)
+func (_PublicResolver *PublicResolverFilterer) FilterNameChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverNameChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "NameChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverNameChangedIterator{contract: _PublicResolver.contract, event: "NameChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchNameChanged is a free log subscription operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
+//
+// Solidity: event NameChanged(node indexed bytes32, name string)
+func (_PublicResolver *PublicResolverFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverNameChanged, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "NameChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverNameChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "NameChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// PublicResolverPubkeyChangedIterator is returned from FilterPubkeyChanged and is used to iterate over the raw logs and unpacked data for PubkeyChanged events raised by the PublicResolver contract.
+type PublicResolverPubkeyChangedIterator struct {
+	Event *PublicResolverPubkeyChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverPubkeyChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverPubkeyChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverPubkeyChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverPubkeyChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverPubkeyChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverPubkeyChanged represents a PubkeyChanged event raised by the PublicResolver contract.
+type PublicResolverPubkeyChanged struct {
+	Node [32]byte
+	X    [32]byte
+	Y    [32]byte
+	Raw  types.Log // Blockchain specific contextual infos
+}
+
+// FilterPubkeyChanged is a free log retrieval operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
+//
+// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32)
+func (_PublicResolver *PublicResolverFilterer) FilterPubkeyChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverPubkeyChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "PubkeyChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverPubkeyChangedIterator{contract: _PublicResolver.contract, event: "PubkeyChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchPubkeyChanged is a free log subscription operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
+//
+// Solidity: event PubkeyChanged(node indexed bytes32, x bytes32, y bytes32)
+func (_PublicResolver *PublicResolverFilterer) WatchPubkeyChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverPubkeyChanged, node [][32]byte) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "PubkeyChanged", nodeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverPubkeyChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// PublicResolverTextChangedIterator is returned from FilterTextChanged and is used to iterate over the raw logs and unpacked data for TextChanged events raised by the PublicResolver contract.
+type PublicResolverTextChangedIterator struct {
+	Event *PublicResolverTextChanged // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *PublicResolverTextChangedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(PublicResolverTextChanged)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(PublicResolverTextChanged)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error retruned any retrieval or parsing error occurred during filtering.
+func (it *PublicResolverTextChangedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *PublicResolverTextChangedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// PublicResolverTextChanged represents a TextChanged event raised by the PublicResolver contract.
+type PublicResolverTextChanged struct {
+	Node       [32]byte
+	IndexedKey common.Hash
+	Key        string
+	Raw        types.Log // Blockchain specific contextual infos
+}
+
+// FilterTextChanged is a free log retrieval operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
+//
+// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string)
+func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte, indexedKey []string) (*PublicResolverTextChangedIterator, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var indexedKeyRule []interface{}
+	for _, indexedKeyItem := range indexedKey {
+		indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverTextChangedIterator{contract: _PublicResolver.contract, event: "TextChanged", logs: logs, sub: sub}, nil
+}
+
+// WatchTextChanged is a free log subscription operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
+//
+// Solidity: event TextChanged(node indexed bytes32, indexedKey indexed string, key string)
+func (_PublicResolver *PublicResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverTextChanged, node [][32]byte, indexedKey []string) (event.Subscription, error) {
+
+	var nodeRule []interface{}
+	for _, nodeItem := range node {
+		nodeRule = append(nodeRule, nodeItem)
+	}
+	var indexedKeyRule []interface{}
+	for _, indexedKeyItem := range indexedKey {
+		indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
+	}
+
+	logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(PublicResolverTextChanged)
+				if err := _PublicResolver.contract.UnpackLog(event, "TextChanged", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
diff --git a/contracts/ens/ens.go b/contracts/ens/ens.go
index c292a1714a..75d9d0e4b1 100644
--- a/contracts/ens/ens.go
+++ b/contracts/ens/ens.go
@@ -16,10 +16,11 @@
 
 package ens
 
-//go:generate abigen --sol contract/ens.sol --pkg contract --out contract/ens.go
+//go:generate abigen --sol contract/ENS.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/ens.go
+//go:generate abigen --sol contract/FIFSRegistrar.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/fifsregistrar.go
+//go:generate abigen --sol contract/PublicResolver.sol --exc contract/AbstractENS.sol:AbstractENS --pkg contract --out contract/publicresolver.go
 
 import (
-	"math/big"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -58,31 +59,29 @@ func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contra
 }
 
 // DeployENS deploys an instance of the ENS nameservice, with a 'first-in, first-served' root registrar.
-func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (*ENS, error) {
-	// Deploy the ENS registry
-	ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend, transactOpts.From)
+func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (common.Address, *ENS, error) {
+	// Deploy the ENS registry.
+	ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend)
 	if err != nil {
-		return nil, err
+		return ensAddr, nil, err
 	}
 
 	ens, err := NewENS(transactOpts, ensAddr, contractBackend)
 	if err != nil {
-		return nil, err
+		return ensAddr, nil, err
 	}
 
-	// Deploy the registrar
+	// Deploy the registrar.
 	regAddr, _, _, err := contract.DeployFIFSRegistrar(transactOpts, contractBackend, ensAddr, [32]byte{})
 	if err != nil {
-		return nil, err
+		return ensAddr, nil, err
+	}
+	// Set the registrar as owner of the ENS root.
+	if _, err = ens.SetOwner([32]byte{}, regAddr); err != nil {
+		return ensAddr, nil, err
 	}
 
-	// Set the registrar as owner of the ENS root
-	_, err = ens.SetOwner([32]byte{}, regAddr)
-	if err != nil {
-		return nil, err
-	}
-
-	return ens, nil
+	return ensAddr, ens, nil
 }
 
 func ensParentNode(name string) (common.Hash, common.Hash) {
@@ -96,7 +95,7 @@ func ensParentNode(name string) (common.Hash, common.Hash) {
 	}
 }
 
-func ensNode(name string) common.Hash {
+func EnsNode(name string) common.Hash {
 	parentNode, parentLabel := ensParentNode(name)
 	return crypto.Keccak256Hash(parentNode[:], parentLabel[:])
 }
@@ -137,7 +136,7 @@ func (self *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, er
 
 // Resolve is a non-transactional call that returns the content hash associated with a name.
 func (self *ENS) Resolve(name string) (common.Hash, error) {
-	node := ensNode(name)
+	node := EnsNode(name)
 
 	resolver, err := self.getResolver(node)
 	if err != nil {
@@ -156,21 +155,17 @@ func (self *ENS) Resolve(name string) (common.Hash, error) {
 // Only works if the registrar for the parent domain implements the FIFS registrar protocol.
 func (self *ENS) Register(name string) (*types.Transaction, error) {
 	parentNode, label := ensParentNode(name)
-
 	registrar, err := self.getRegistrar(parentNode)
 	if err != nil {
 		return nil, err
 	}
-
-	opts := self.TransactOpts
-	opts.GasLimit = big.NewInt(200000)
-	return registrar.Contract.Register(&opts, label, self.TransactOpts.From)
+	return registrar.Contract.Register(&self.TransactOpts, label, self.TransactOpts.From)
 }
 
 // SetContentHash sets the content hash associated with a name. Only works if the caller
 // owns the name, and the associated resolver implements a `setContent` function.
 func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) {
-	node := ensNode(name)
+	node := EnsNode(name)
 
 	resolver, err := self.getResolver(node)
 	if err != nil {
@@ -178,6 +173,6 @@ func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transacti
 	}
 
 	opts := self.TransactOpts
-	opts.GasLimit = big.NewInt(200000)
+	opts.GasLimit = 200000
 	return resolver.Contract.SetContent(&opts, node, hash)
 }
diff --git a/contracts/ens/ens_test.go b/contracts/ens/ens_test.go
index 5faa9b1ad4..6ad8447082 100644
--- a/contracts/ens/ens_test.go
+++ b/contracts/ens/ens_test.go
@@ -22,6 +22,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/contracts/ens/contract"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/crypto"
 )
@@ -36,27 +37,36 @@ var (
 func TestENS(t *testing.T) {
 	contractBackend := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(1000000000)}})
 	transactOpts := bind.NewKeyedTransactor(key)
-	// Workaround for bug estimating gas in the call to Register
-	transactOpts.GasLimit = big.NewInt(1000000)
 
-	ens, err := DeployENS(transactOpts, contractBackend)
+	ensAddr, ens, err := DeployENS(transactOpts, contractBackend)
 	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
+		t.Fatalf("can't deploy root registry: %v", err)
 	}
 	contractBackend.Commit()
 
-	_, err = ens.Register(name)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
+	// Set ourself as the owner of the name.
+	if _, err := ens.Register(name); err != nil {
+		t.Fatalf("can't register: %v", err)
 	}
 	contractBackend.Commit()
 
-	_, err = ens.SetContentHash(name, hash)
+	// Deploy a resolver and make it responsible for the name.
+	resolverAddr, _, _, err := contract.DeployPublicResolver(transactOpts, contractBackend, ensAddr)
 	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
+		t.Fatalf("can't deploy resolver: %v", err)
+	}
+	if _, err := ens.SetResolver(EnsNode(name), resolverAddr); err != nil {
+		t.Fatalf("can't set resolver: %v", err)
 	}
 	contractBackend.Commit()
 
+	// Set the content hash for the name.
+	if _, err = ens.SetContentHash(name, hash); err != nil {
+		t.Fatalf("can't set content hash: %v", err)
+	}
+	contractBackend.Commit()
+
+	// Try to resolve the name.
 	vhost, err := ens.Resolve(name)
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
diff --git a/contracts/release/contract.go b/contracts/release/contract.go
deleted file mode 100644
index 6a0b099311..0000000000
--- a/contracts/release/contract.go
+++ /dev/null
@@ -1,432 +0,0 @@
-// This file is an automatically generated Go binding. Do not modify as any
-// change will likely be lost upon the next re-generation!
-
-package release
-
-import (
-	"math/big"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-)
-
-// ReleaseOracleABI is the input ABI used to generate the binding from.
-const ReleaseOracleABI = `[{"constant":true,"inputs":[],"name":"proposedVersion","outputs":[{"name":"major","type":"uint32"},{"name":"minor","type":"uint32"},{"name":"patch","type":"uint32"},{"name":"commit","type":"bytes20"},{"name":"pass","type":"address[]"},{"name":"fail","type":"address[]"}],"type":"function"},{"constant":true,"inputs":[],"name":"signers","outputs":[{"name":"","type":"address[]"}],"type":"function"},{"constant":false,"inputs":[{"name":"user","type":"address"}],"name":"demote","outputs":[],"type":"function"},{"constant":true,"inputs":[{"name":"user","type":"address"}],"name":"authVotes","outputs":[{"name":"promote","type":"address[]"},{"name":"demote","type":"address[]"}],"type":"function"},{"constant":true,"inputs":[],"name":"currentVersion","outputs":[{"name":"major","type":"uint32"},{"name":"minor","type":"uint32"},{"name":"patch","type":"uint32"},{"name":"commit","type":"bytes20"},{"name":"time","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[],"name":"nuke","outputs":[],"type":"function"},{"constant":true,"inputs":[],"name":"authProposals","outputs":[{"name":"","type":"address[]"}],"type":"function"},{"constant":false,"inputs":[{"name":"user","type":"address"}],"name":"promote","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"major","type":"uint32"},{"name":"minor","type":"uint32"},{"name":"patch","type":"uint32"},{"name":"commit","type":"bytes20"}],"name":"release","outputs":[],"type":"function"},{"inputs":[{"name":"signers","type":"address[]"}],"type":"constructor"}]`
-
-// ReleaseOracleBin is the compiled bytecode used for deploying new contracts.
-const ReleaseOracleBin = `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`
-
-// DeployReleaseOracle deploys a new Ethereum contract, binding an instance of ReleaseOracle to it.
-func DeployReleaseOracle(auth *bind.TransactOpts, backend bind.ContractBackend, signers []common.Address) (common.Address, *types.Transaction, *ReleaseOracle, error) {
-	parsed, err := abi.JSON(strings.NewReader(ReleaseOracleABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ReleaseOracleBin), backend, signers)
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	return address, tx, &ReleaseOracle{ReleaseOracleCaller: ReleaseOracleCaller{contract: contract}, ReleaseOracleTransactor: ReleaseOracleTransactor{contract: contract}}, nil
-}
-
-// ReleaseOracle is an auto generated Go binding around an Ethereum contract.
-type ReleaseOracle struct {
-	ReleaseOracleCaller     // Read-only binding to the contract
-	ReleaseOracleTransactor // Write-only binding to the contract
-}
-
-// ReleaseOracleCaller is an auto generated read-only Go binding around an Ethereum contract.
-type ReleaseOracleCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ReleaseOracleTransactor is an auto generated write-only Go binding around an Ethereum contract.
-type ReleaseOracleTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ReleaseOracleSession is an auto generated Go binding around an Ethereum contract,
-// with pre-set call and transact options.
-type ReleaseOracleSession struct {
-	Contract     *ReleaseOracle    // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// ReleaseOracleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
-// with pre-set call options.
-type ReleaseOracleCallerSession struct {
-	Contract *ReleaseOracleCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts        // Call options to use throughout this session
-}
-
-// ReleaseOracleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-// with pre-set transact options.
-type ReleaseOracleTransactorSession struct {
-	Contract     *ReleaseOracleTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
-}
-
-// ReleaseOracleRaw is an auto generated low-level Go binding around an Ethereum contract.
-type ReleaseOracleRaw struct {
-	Contract *ReleaseOracle // Generic contract binding to access the raw methods on
-}
-
-// ReleaseOracleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-type ReleaseOracleCallerRaw struct {
-	Contract *ReleaseOracleCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// ReleaseOracleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-type ReleaseOracleTransactorRaw struct {
-	Contract *ReleaseOracleTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewReleaseOracle creates a new instance of ReleaseOracle, bound to a specific deployed contract.
-func NewReleaseOracle(address common.Address, backend bind.ContractBackend) (*ReleaseOracle, error) {
-	contract, err := bindReleaseOracle(address, backend, backend)
-	if err != nil {
-		return nil, err
-	}
-	return &ReleaseOracle{ReleaseOracleCaller: ReleaseOracleCaller{contract: contract}, ReleaseOracleTransactor: ReleaseOracleTransactor{contract: contract}}, nil
-}
-
-// NewReleaseOracleCaller creates a new read-only instance of ReleaseOracle, bound to a specific deployed contract.
-func NewReleaseOracleCaller(address common.Address, caller bind.ContractCaller) (*ReleaseOracleCaller, error) {
-	contract, err := bindReleaseOracle(address, caller, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &ReleaseOracleCaller{contract: contract}, nil
-}
-
-// NewReleaseOracleTransactor creates a new write-only instance of ReleaseOracle, bound to a specific deployed contract.
-func NewReleaseOracleTransactor(address common.Address, transactor bind.ContractTransactor) (*ReleaseOracleTransactor, error) {
-	contract, err := bindReleaseOracle(address, nil, transactor)
-	if err != nil {
-		return nil, err
-	}
-	return &ReleaseOracleTransactor{contract: contract}, nil
-}
-
-// bindReleaseOracle binds a generic wrapper to an already deployed contract.
-func bindReleaseOracle(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(ReleaseOracleABI))
-	if err != nil {
-		return nil, err
-	}
-	return bind.NewBoundContract(address, parsed, caller, transactor), nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_ReleaseOracle *ReleaseOracleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _ReleaseOracle.Contract.ReleaseOracleCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_ReleaseOracle *ReleaseOracleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.ReleaseOracleTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_ReleaseOracle *ReleaseOracleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.ReleaseOracleTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_ReleaseOracle *ReleaseOracleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _ReleaseOracle.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_ReleaseOracle *ReleaseOracleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_ReleaseOracle *ReleaseOracleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.contract.Transact(opts, method, params...)
-}
-
-// AuthProposals is a free data retrieval call binding the contract method 0xbf8ecf9c.
-//
-// Solidity: function authProposals() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleCaller) AuthProposals(opts *bind.CallOpts) ([]common.Address, error) {
-	var (
-		ret0 = new([]common.Address)
-	)
-	out := ret0
-	err := _ReleaseOracle.contract.Call(opts, out, "authProposals")
-	return *ret0, err
-}
-
-// AuthProposals is a free data retrieval call binding the contract method 0xbf8ecf9c.
-//
-// Solidity: function authProposals() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleSession) AuthProposals() ([]common.Address, error) {
-	return _ReleaseOracle.Contract.AuthProposals(&_ReleaseOracle.CallOpts)
-}
-
-// AuthProposals is a free data retrieval call binding the contract method 0xbf8ecf9c.
-//
-// Solidity: function authProposals() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleCallerSession) AuthProposals() ([]common.Address, error) {
-	return _ReleaseOracle.Contract.AuthProposals(&_ReleaseOracle.CallOpts)
-}
-
-// AuthVotes is a free data retrieval call binding the contract method 0x64ed31fe.
-//
-// Solidity: function authVotes(user address) constant returns(promote address[], demote address[])
-func (_ReleaseOracle *ReleaseOracleCaller) AuthVotes(opts *bind.CallOpts, user common.Address) (struct {
-	Promote []common.Address
-	Demote  []common.Address
-}, error) {
-	ret := new(struct {
-		Promote []common.Address
-		Demote  []common.Address
-	})
-	out := ret
-	err := _ReleaseOracle.contract.Call(opts, out, "authVotes", user)
-	return *ret, err
-}
-
-// AuthVotes is a free data retrieval call binding the contract method 0x64ed31fe.
-//
-// Solidity: function authVotes(user address) constant returns(promote address[], demote address[])
-func (_ReleaseOracle *ReleaseOracleSession) AuthVotes(user common.Address) (struct {
-	Promote []common.Address
-	Demote  []common.Address
-}, error) {
-	return _ReleaseOracle.Contract.AuthVotes(&_ReleaseOracle.CallOpts, user)
-}
-
-// AuthVotes is a free data retrieval call binding the contract method 0x64ed31fe.
-//
-// Solidity: function authVotes(user address) constant returns(promote address[], demote address[])
-func (_ReleaseOracle *ReleaseOracleCallerSession) AuthVotes(user common.Address) (struct {
-	Promote []common.Address
-	Demote  []common.Address
-}, error) {
-	return _ReleaseOracle.Contract.AuthVotes(&_ReleaseOracle.CallOpts, user)
-}
-
-// CurrentVersion is a free data retrieval call binding the contract method 0x9d888e86.
-//
-// Solidity: function currentVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, time uint256)
-func (_ReleaseOracle *ReleaseOracleCaller) CurrentVersion(opts *bind.CallOpts) (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Time   *big.Int
-}, error) {
-	ret := new(struct {
-		Major  uint32
-		Minor  uint32
-		Patch  uint32
-		Commit [20]byte
-		Time   *big.Int
-	})
-	out := ret
-	err := _ReleaseOracle.contract.Call(opts, out, "currentVersion")
-	return *ret, err
-}
-
-// CurrentVersion is a free data retrieval call binding the contract method 0x9d888e86.
-//
-// Solidity: function currentVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, time uint256)
-func (_ReleaseOracle *ReleaseOracleSession) CurrentVersion() (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Time   *big.Int
-}, error) {
-	return _ReleaseOracle.Contract.CurrentVersion(&_ReleaseOracle.CallOpts)
-}
-
-// CurrentVersion is a free data retrieval call binding the contract method 0x9d888e86.
-//
-// Solidity: function currentVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, time uint256)
-func (_ReleaseOracle *ReleaseOracleCallerSession) CurrentVersion() (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Time   *big.Int
-}, error) {
-	return _ReleaseOracle.Contract.CurrentVersion(&_ReleaseOracle.CallOpts)
-}
-
-// ProposedVersion is a free data retrieval call binding the contract method 0x26db7648.
-//
-// Solidity: function proposedVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, pass address[], fail address[])
-func (_ReleaseOracle *ReleaseOracleCaller) ProposedVersion(opts *bind.CallOpts) (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Pass   []common.Address
-	Fail   []common.Address
-}, error) {
-	ret := new(struct {
-		Major  uint32
-		Minor  uint32
-		Patch  uint32
-		Commit [20]byte
-		Pass   []common.Address
-		Fail   []common.Address
-	})
-	out := ret
-	err := _ReleaseOracle.contract.Call(opts, out, "proposedVersion")
-	return *ret, err
-}
-
-// ProposedVersion is a free data retrieval call binding the contract method 0x26db7648.
-//
-// Solidity: function proposedVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, pass address[], fail address[])
-func (_ReleaseOracle *ReleaseOracleSession) ProposedVersion() (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Pass   []common.Address
-	Fail   []common.Address
-}, error) {
-	return _ReleaseOracle.Contract.ProposedVersion(&_ReleaseOracle.CallOpts)
-}
-
-// ProposedVersion is a free data retrieval call binding the contract method 0x26db7648.
-//
-// Solidity: function proposedVersion() constant returns(major uint32, minor uint32, patch uint32, commit bytes20, pass address[], fail address[])
-func (_ReleaseOracle *ReleaseOracleCallerSession) ProposedVersion() (struct {
-	Major  uint32
-	Minor  uint32
-	Patch  uint32
-	Commit [20]byte
-	Pass   []common.Address
-	Fail   []common.Address
-}, error) {
-	return _ReleaseOracle.Contract.ProposedVersion(&_ReleaseOracle.CallOpts)
-}
-
-// Signers is a free data retrieval call binding the contract method 0x46f0975a.
-//
-// Solidity: function signers() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleCaller) Signers(opts *bind.CallOpts) ([]common.Address, error) {
-	var (
-		ret0 = new([]common.Address)
-	)
-	out := ret0
-	err := _ReleaseOracle.contract.Call(opts, out, "signers")
-	return *ret0, err
-}
-
-// Signers is a free data retrieval call binding the contract method 0x46f0975a.
-//
-// Solidity: function signers() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleSession) Signers() ([]common.Address, error) {
-	return _ReleaseOracle.Contract.Signers(&_ReleaseOracle.CallOpts)
-}
-
-// Signers is a free data retrieval call binding the contract method 0x46f0975a.
-//
-// Solidity: function signers() constant returns(address[])
-func (_ReleaseOracle *ReleaseOracleCallerSession) Signers() ([]common.Address, error) {
-	return _ReleaseOracle.Contract.Signers(&_ReleaseOracle.CallOpts)
-}
-
-// Demote is a paid mutator transaction binding the contract method 0x5c3d005d.
-//
-// Solidity: function demote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleTransactor) Demote(opts *bind.TransactOpts, user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.contract.Transact(opts, "demote", user)
-}
-
-// Demote is a paid mutator transaction binding the contract method 0x5c3d005d.
-//
-// Solidity: function demote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleSession) Demote(user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Demote(&_ReleaseOracle.TransactOpts, user)
-}
-
-// Demote is a paid mutator transaction binding the contract method 0x5c3d005d.
-//
-// Solidity: function demote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleTransactorSession) Demote(user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Demote(&_ReleaseOracle.TransactOpts, user)
-}
-
-// Nuke is a paid mutator transaction binding the contract method 0xbc8fbbf8.
-//
-// Solidity: function nuke() returns()
-func (_ReleaseOracle *ReleaseOracleTransactor) Nuke(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _ReleaseOracle.contract.Transact(opts, "nuke")
-}
-
-// Nuke is a paid mutator transaction binding the contract method 0xbc8fbbf8.
-//
-// Solidity: function nuke() returns()
-func (_ReleaseOracle *ReleaseOracleSession) Nuke() (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Nuke(&_ReleaseOracle.TransactOpts)
-}
-
-// Nuke is a paid mutator transaction binding the contract method 0xbc8fbbf8.
-//
-// Solidity: function nuke() returns()
-func (_ReleaseOracle *ReleaseOracleTransactorSession) Nuke() (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Nuke(&_ReleaseOracle.TransactOpts)
-}
-
-// Promote is a paid mutator transaction binding the contract method 0xd0e0813a.
-//
-// Solidity: function promote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleTransactor) Promote(opts *bind.TransactOpts, user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.contract.Transact(opts, "promote", user)
-}
-
-// Promote is a paid mutator transaction binding the contract method 0xd0e0813a.
-//
-// Solidity: function promote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleSession) Promote(user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Promote(&_ReleaseOracle.TransactOpts, user)
-}
-
-// Promote is a paid mutator transaction binding the contract method 0xd0e0813a.
-//
-// Solidity: function promote(user address) returns()
-func (_ReleaseOracle *ReleaseOracleTransactorSession) Promote(user common.Address) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Promote(&_ReleaseOracle.TransactOpts, user)
-}
-
-// Release is a paid mutator transaction binding the contract method 0xd67cbec9.
-//
-// Solidity: function release(major uint32, minor uint32, patch uint32, commit bytes20) returns()
-func (_ReleaseOracle *ReleaseOracleTransactor) Release(opts *bind.TransactOpts, major uint32, minor uint32, patch uint32, commit [20]byte) (*types.Transaction, error) {
-	return _ReleaseOracle.contract.Transact(opts, "release", major, minor, patch, commit)
-}
-
-// Release is a paid mutator transaction binding the contract method 0xd67cbec9.
-//
-// Solidity: function release(major uint32, minor uint32, patch uint32, commit bytes20) returns()
-func (_ReleaseOracle *ReleaseOracleSession) Release(major uint32, minor uint32, patch uint32, commit [20]byte) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Release(&_ReleaseOracle.TransactOpts, major, minor, patch, commit)
-}
-
-// Release is a paid mutator transaction binding the contract method 0xd67cbec9.
-//
-// Solidity: function release(major uint32, minor uint32, patch uint32, commit bytes20) returns()
-func (_ReleaseOracle *ReleaseOracleTransactorSession) Release(major uint32, minor uint32, patch uint32, commit [20]byte) (*types.Transaction, error) {
-	return _ReleaseOracle.Contract.Release(&_ReleaseOracle.TransactOpts, major, minor, patch, commit)
-}
diff --git a/contracts/release/contract.sol b/contracts/release/contract.sol
deleted file mode 100644
index b9d94c7563..0000000000
--- a/contracts/release/contract.sol
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// ReleaseOracle is an Ethereum contract to store the current and previous
-// versions of the go-ethereum implementation. Its goal is to allow Geth to
-// check for new releases automatically without the need to consult a central
-// repository.
-//
-// The contract takes a vote based approach on both assigning authorised signers
-// as well as signing off on new Geth releases.
-//
-// Note, when a signer is demoted, the currently pending release is auto-nuked.
-// The reason is to prevent suprises where a demotion actually tilts the votes
-// in favor of one voter party and pushing out a new release as a consequence of
-// a simple demotion.
-contract ReleaseOracle {
-  // Votes is an internal data structure to count votes on a specific proposal
-  struct Votes {
-    address[] pass; // List of signers voting to pass a proposal
-    address[] fail; // List of signers voting to fail a proposal
-  }
-
-  // Version is the version details of a particular Geth release
-  struct Version {
-    uint32  major;  // Major version component of the release
-    uint32  minor;  // Minor version component of the release
-    uint32  patch;  // Patch version component of the release
-    bytes20 commit; // Git SHA1 commit hash of the release
-
-    uint64  time;  // Timestamp of the release approval
-    Votes   votes; // Votes that passed this release
-  }
-
-  // Oracle authorization details
-  mapping(address => bool) authorised; // Set of accounts allowed to vote on updating the contract
-  address[]                voters;     // List of addresses currently accepted as signers
-
-  // Various proposals being voted on
-  mapping(address => Votes) authProps; // Currently running user authorization proposals
-  address[]                 authPend;  // List of addresses being voted on (map indexes)
-
-  Version   verProp;  // Currently proposed release being voted on
-  Version[] releases; // All the positively voted releases
-
-  // isSigner is a modifier to authorize contract transactions.
-  modifier isSigner() {
-    if (authorised[msg.sender]) {
-      _
-    }
-  }
-
-  // Constructor to assign the initial set of signers.
-  function ReleaseOracle(address[] signers) {
-    // If no signers were specified, assign the creator as the sole signer
-    if (signers.length == 0) {
-      authorised[msg.sender] = true;
-      voters.push(msg.sender);
-      return;
-    }
-    // Otherwise assign the individual signers one by one
-    for (uint i = 0; i < signers.length; i++) {
-      authorised[signers[i]] = true;
-      voters.push(signers[i]);
-    }
-  }
-
-  // signers is an accessor method to retrieve all the signers (public accessor
-  // generates an indexed one, not a retrieve-all version).
-  function signers() constant returns(address[]) {
-    return voters;
-  }
-
-  // authProposals retrieves the list of addresses that authorization proposals
-  // are currently being voted on.
-  function authProposals() constant returns(address[]) {
-    return authPend;
-  }
-
-  // authVotes retrieves the current authorization votes for a particular user
-  // to promote him into the list of signers, or demote him from there.
-  function authVotes(address user) constant returns(address[] promote, address[] demote) {
-    return (authProps[user].pass, authProps[user].fail);
-  }
-
-  // currentVersion retrieves the semantic version, commit hash and release time
-  // of the currently votec active release.
-  function currentVersion() constant returns (uint32 major, uint32 minor, uint32 patch, bytes20 commit, uint time) {
-    if (releases.length == 0) {
-      return (0, 0, 0, 0, 0);
-    }
-    var release = releases[releases.length - 1];
-
-    return (release.major, release.minor, release.patch, release.commit, release.time);
-  }
-
-  // proposedVersion retrieves the semantic version, commit hash and the current
-  // votes for the next proposed release.
-  function proposedVersion() constant returns (uint32 major, uint32 minor, uint32 patch, bytes20 commit, address[] pass, address[] fail) {
-    return (verProp.major, verProp.minor, verProp.patch, verProp.commit, verProp.votes.pass, verProp.votes.fail);
-  }
-
-  // promote pitches in on a voting campaign to promote a new user to a signer
-  // position.
-  function promote(address user) {
-    updateSigner(user, true);
-  }
-
-  // demote pitches in on a voting campaign to demote an authorised user from
-  // its signer position.
-  function demote(address user) {
-    updateSigner(user, false);
-  }
-
-  // release votes for a particular version to be included as the next release.
-  function release(uint32 major, uint32 minor, uint32 patch, bytes20 commit) {
-    updateRelease(major, minor, patch, commit, true);
-  }
-
-  // nuke votes for the currently proposed version to not be included as the next
-  // release. Nuking doesn't require a specific version number for simplicity.
-  function nuke() {
-    updateRelease(0, 0, 0, 0, false);
-  }
-
-  // updateSigner marks a vote for changing the status of an Ethereum user, either
-  // for or against the user being an authorised signer.
-  function updateSigner(address user, bool authorize) internal isSigner {
-    // Gather the current votes and ensure we don't double vote
-    Votes votes = authProps[user];
-    for (uint i = 0; i < votes.pass.length; i++) {
-      if (votes.pass[i] == msg.sender) {
-        return;
-      }
-    }
-    for (i = 0; i < votes.fail.length; i++) {
-      if (votes.fail[i] == msg.sender) {
-        return;
-      }
-    }
-    // If no authorization proposal is open, add the user to the index for later lookups
-    if (votes.pass.length == 0 && votes.fail.length == 0) {
-      authPend.push(user);
-    }
-    // Cast the vote and return if the proposal cannot be resolved yet
-    if (authorize) {
-      votes.pass.push(msg.sender);
-      if (votes.pass.length <= voters.length / 2) {
-        return;
-      }
-    } else {
-      votes.fail.push(msg.sender);
-      if (votes.fail.length <= voters.length / 2) {
-        return;
-      }
-    }
-    // Proposal resolved in our favor, execute whatever we voted on
-    if (authorize && !authorised[user]) {
-      authorised[user] = true;
-      voters.push(user);
-    } else if (!authorize && authorised[user]) {
-      authorised[user] = false;
-
-      for (i = 0; i < voters.length; i++) {
-        if (voters[i] == user) {
-          voters[i] = voters[voters.length - 1];
-          voters.length--;
-
-          delete verProp; // Nuke any version proposal (no surprise releases!)
-          break;
-        }
-      }
-    }
-    // Finally delete the resolved proposal, index and garbage collect
-    delete authProps[user];
-
-    for (i = 0; i < authPend.length; i++) {
-      if (authPend[i] == user) {
-        authPend[i] = authPend[authPend.length - 1];
-        authPend.length--;
-        break;
-      }
-    }
-  }
-
-  // updateRelease votes for a particular version to be included as the next release,
-  // or for the currently proposed release to be nuked out.
-  function updateRelease(uint32 major, uint32 minor, uint32 patch, bytes20 commit, bool release) internal isSigner {
-    // Skip nuke votes if no proposal is pending
-    if (!release && verProp.votes.pass.length == 0) {
-      return;
-    }
-    // Mark a new release if no proposal is pending
-    if (verProp.votes.pass.length == 0) {
-      verProp.major  = major;
-      verProp.minor  = minor;
-      verProp.patch  = patch;
-      verProp.commit = commit;
-    }
-    // Make sure positive votes match the current proposal
-    if (release && (verProp.major != major || verProp.minor != minor || verProp.patch != patch || verProp.commit != commit)) {
-      return;
-    }
-    // Gather the current votes and ensure we don't double vote
-    Votes votes = verProp.votes;
-    for (uint i = 0; i < votes.pass.length; i++) {
-      if (votes.pass[i] == msg.sender) {
-        return;
-      }
-    }
-    for (i = 0; i < votes.fail.length; i++) {
-      if (votes.fail[i] == msg.sender) {
-        return;
-      }
-    }
-    // Cast the vote and return if the proposal cannot be resolved yet
-    if (release) {
-      votes.pass.push(msg.sender);
-      if (votes.pass.length <= voters.length / 2) {
-        return;
-      }
-    } else {
-      votes.fail.push(msg.sender);
-      if (votes.fail.length <= voters.length / 2) {
-        return;
-      }
-    }
-    // Proposal resolved in our favor, execute whatever we voted on
-    if (release) {
-      verProp.time = uint64(now);
-      releases.push(verProp);
-      delete verProp;
-    } else {
-      delete verProp;
-    }
-  }
-}
diff --git a/contracts/release/contract_test.go b/contracts/release/contract_test.go
deleted file mode 100644
index 0b2b2f0487..0000000000
--- a/contracts/release/contract_test.go
+++ /dev/null
@@ -1,374 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package release
-
-import (
-	"crypto/ecdsa"
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// setupReleaseTest creates a blockchain simulator and deploys a version oracle
-// contract for testing.
-func setupReleaseTest(t *testing.T, prefund ...*ecdsa.PrivateKey) (*ecdsa.PrivateKey, *ReleaseOracle, *backends.SimulatedBackend) {
-	// Generate a new random account and a funded simulator
-	key, _ := crypto.GenerateKey()
-	auth := bind.NewKeyedTransactor(key)
-
-	alloc := core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000)}}
-	for _, key := range prefund {
-		alloc[crypto.PubkeyToAddress(key.PublicKey)] = core.GenesisAccount{Balance: big.NewInt(10000000000)}
-	}
-	sim := backends.NewSimulatedBackend(alloc)
-
-	// Deploy a version oracle contract, commit and return
-	_, _, oracle, err := DeployReleaseOracle(auth, sim, []common.Address{auth.From})
-	if err != nil {
-		t.Fatalf("Failed to deploy version contract: %v", err)
-	}
-	sim.Commit()
-
-	return key, oracle, sim
-}
-
-// Tests that the version contract can be deployed and the creator is assigned
-// the sole authorized signer.
-func TestContractCreation(t *testing.T) {
-	key, oracle, _ := setupReleaseTest(t)
-
-	owner := crypto.PubkeyToAddress(key.PublicKey)
-	signers, err := oracle.Signers(nil)
-	if err != nil {
-		t.Fatalf("Failed to retrieve list of signers: %v", err)
-	}
-	if len(signers) != 1 || signers[0] != owner {
-		t.Fatalf("Initial signer mismatch: have %v, want %v", signers, owner)
-	}
-}
-
-// Tests that subsequent signers can be promoted, each requiring half plus one
-// votes for it to pass through.
-func TestSignerPromotion(t *testing.T) {
-	// Prefund a few accounts to authorize with and create the oracle
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-	}
-	key, oracle, sim := setupReleaseTest(t, keys...)
-
-	// Gradually promote the keys, until all are authorized
-	keys = append([]*ecdsa.PrivateKey{key}, keys...)
-	for i := 1; i < len(keys); i++ {
-		// Check that no votes are accepted from the not yet authorized user
-		if _, err := oracle.Promote(bind.NewKeyedTransactor(keys[i]), common.Address{}); err != nil {
-			t.Fatalf("Iter #%d: failed invalid promotion attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		pend, err := oracle.AuthProposals(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve active proposals: %v", i, err)
-		}
-		if len(pend) != 0 {
-			t.Fatalf("Iter #%d: proposal count mismatch: have %d, want 0", i, len(pend))
-		}
-		// Promote with half - 1 voters and check that the user's not yet authorized
-		for j := 0; j < i/2; j++ {
-			if _, err = oracle.Promote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid promotion attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-
-		signers, err := oracle.Signers(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve list of signers: %v", i, err)
-		}
-		if len(signers) != i {
-			t.Fatalf("Iter #%d: signer count mismatch: have %v, want %v", i, len(signers), i)
-		}
-		// Promote with the last one needed to pass the promotion
-		if _, err = oracle.Promote(bind.NewKeyedTransactor(keys[i/2]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-			t.Fatalf("Iter #%d: failed valid promotion completion attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		signers, err = oracle.Signers(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve list of signers: %v", i, err)
-		}
-		if len(signers) != i+1 {
-			t.Fatalf("Iter #%d: signer count mismatch: have %v, want %v", i, len(signers), i+1)
-		}
-	}
-}
-
-// Tests that subsequent signers can be demoted, each requiring half plus one
-// votes for it to pass through.
-func TestSignerDemotion(t *testing.T) {
-	// Prefund a few accounts to authorize with and create the oracle
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-	}
-	key, oracle, sim := setupReleaseTest(t, keys...)
-
-	// Authorize all the keys as valid signers and verify cardinality
-	keys = append([]*ecdsa.PrivateKey{key}, keys...)
-	for i := 1; i < len(keys); i++ {
-		for j := 0; j <= i/2; j++ {
-			if _, err := oracle.Promote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid promotion attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-	}
-	signers, err := oracle.Signers(nil)
-	if err != nil {
-		t.Fatalf("Failed to retrieve list of signers: %v", err)
-	}
-	if len(signers) != len(keys) {
-		t.Fatalf("Signer count mismatch: have %v, want %v", len(signers), len(keys))
-	}
-	// Gradually demote users until we run out of signers
-	for i := len(keys) - 1; i >= 0; i-- {
-		// Demote with half - 1 voters and check that the user's not yet dropped
-		for j := 0; j < (i+1)/2; j++ {
-			if _, err = oracle.Demote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid demotion attempt: %v", len(keys)-i, err)
-			}
-		}
-		sim.Commit()
-
-		signers, err := oracle.Signers(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve list of signers: %v", len(keys)-i, err)
-		}
-		if len(signers) != i+1 {
-			t.Fatalf("Iter #%d: signer count mismatch: have %v, want %v", len(keys)-i, len(signers), i+1)
-		}
-		// Demote with the last one needed to pass the demotion
-		if _, err = oracle.Demote(bind.NewKeyedTransactor(keys[(i+1)/2]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-			t.Fatalf("Iter #%d: failed valid demotion completion attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		signers, err = oracle.Signers(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve list of signers: %v", len(keys)-i, err)
-		}
-		if len(signers) != i {
-			t.Fatalf("Iter #%d: signer count mismatch: have %v, want %v", len(keys)-i, len(signers), i)
-		}
-		// Check that no votes are accepted from the already demoted users
-		if _, err = oracle.Promote(bind.NewKeyedTransactor(keys[i]), common.Address{}); err != nil {
-			t.Fatalf("Iter #%d: failed invalid promotion attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		pend, err := oracle.AuthProposals(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve active proposals: %v", i, err)
-		}
-		if len(pend) != 0 {
-			t.Fatalf("Iter #%d: proposal count mismatch: have %d, want 0", i, len(pend))
-		}
-	}
-}
-
-// Tests that new versions can be released, honouring both voting rights as well
-// as the minimum required vote count.
-func TestVersionRelease(t *testing.T) {
-	// Prefund a few accounts to authorize with and create the oracle
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-	}
-	key, oracle, sim := setupReleaseTest(t, keys...)
-
-	// Track the "current release"
-	var (
-		verMajor  = uint32(0)
-		verMinor  = uint32(0)
-		verPatch  = uint32(0)
-		verCommit = [20]byte{}
-	)
-	// Gradually push releases, always requiring more signers than previously
-	keys = append([]*ecdsa.PrivateKey{key}, keys...)
-	for i := 1; i < len(keys); i++ {
-		// Check that no votes are accepted from the not yet authorized user
-		if _, err := oracle.Release(bind.NewKeyedTransactor(keys[i]), 0, 0, 0, [20]byte{0}); err != nil {
-			t.Fatalf("Iter #%d: failed invalid release attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		prop, err := oracle.ProposedVersion(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve active proposal: %v", i, err)
-		}
-		if len(prop.Pass) != 0 {
-			t.Fatalf("Iter #%d: proposal vote count mismatch: have %d, want 0", i, len(prop.Pass))
-		}
-		// Authorize the user to make releases
-		for j := 0; j <= i/2; j++ {
-			if _, err = oracle.Promote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid promotion attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-
-		// Propose release with half voters and check that the release does not yet go through
-		for j := 0; j < (i+1)/2; j++ {
-			if _, err = oracle.Release(bind.NewKeyedTransactor(keys[j]), uint32(i), uint32(i+1), uint32(i+2), [20]byte{byte(i + 3)}); err != nil {
-				t.Fatalf("Iter #%d: failed valid release attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-
-		ver, err := oracle.CurrentVersion(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve current version: %v", i, err)
-		}
-		if ver.Major != verMajor || ver.Minor != verMinor || ver.Patch != verPatch || ver.Commit != verCommit {
-			t.Fatalf("Iter #%d: version mismatch: have %d.%d.%d-%x, want %d.%d.%d-%x", i, ver.Major, ver.Minor, ver.Patch, ver.Commit, verMajor, verMinor, verPatch, verCommit)
-		}
-
-		// Pass the release and check that it became the next version
-		verMajor, verMinor, verPatch, verCommit = uint32(i), uint32(i+1), uint32(i+2), [20]byte{byte(i + 3)}
-		if _, err = oracle.Release(bind.NewKeyedTransactor(keys[(i+1)/2]), uint32(i), uint32(i+1), uint32(i+2), [20]byte{byte(i + 3)}); err != nil {
-			t.Fatalf("Iter #%d: failed valid release completion attempt: %v", i, err)
-		}
-		sim.Commit()
-
-		ver, err = oracle.CurrentVersion(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve current version: %v", i, err)
-		}
-		if ver.Major != verMajor || ver.Minor != verMinor || ver.Patch != verPatch || ver.Commit != verCommit {
-			t.Fatalf("Iter #%d: version mismatch: have %d.%d.%d-%x, want %d.%d.%d-%x", i, ver.Major, ver.Minor, ver.Patch, ver.Commit, verMajor, verMinor, verPatch, verCommit)
-		}
-	}
-}
-
-// Tests that proposed versions can be nuked out of existence.
-func TestVersionNuking(t *testing.T) {
-	// Prefund a few accounts to authorize with and create the oracle
-	keys := make([]*ecdsa.PrivateKey, 9)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-	}
-	key, oracle, sim := setupReleaseTest(t, keys...)
-
-	// Authorize all the keys as valid signers
-	keys = append([]*ecdsa.PrivateKey{key}, keys...)
-	for i := 1; i < len(keys); i++ {
-		for j := 0; j <= i/2; j++ {
-			if _, err := oracle.Promote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid promotion attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-	}
-	// Propose releases with more and more keys, always retaining enough users to nuke the proposals
-	for i := 1; i < (len(keys)+1)/2; i++ {
-		// Propose release with an initial set of signers
-		for j := 0; j < i; j++ {
-			if _, err := oracle.Release(bind.NewKeyedTransactor(keys[j]), uint32(i), uint32(i+1), uint32(i+2), [20]byte{byte(i + 3)}); err != nil {
-				t.Fatalf("Iter #%d: failed valid proposal attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-
-		prop, err := oracle.ProposedVersion(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve active proposal: %v", i, err)
-		}
-		if len(prop.Pass) != i {
-			t.Fatalf("Iter #%d: proposal vote count mismatch: have %d, want %d", i, len(prop.Pass), i)
-		}
-		// Nuke the release with half+1 voters
-		for j := i; j <= i+(len(keys)+1)/2; j++ {
-			if _, err := oracle.Nuke(bind.NewKeyedTransactor(keys[j])); err != nil {
-				t.Fatalf("Iter #%d: failed valid nuke attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-
-		prop, err = oracle.ProposedVersion(nil)
-		if err != nil {
-			t.Fatalf("Iter #%d: failed to retrieve active proposal: %v", i, err)
-		}
-		if len(prop.Pass) != 0 || len(prop.Fail) != 0 {
-			t.Fatalf("Iter #%d: proposal vote count mismatch: have %d/%d pass/fail, want 0/0", i, len(prop.Pass), len(prop.Fail))
-		}
-	}
-}
-
-// Tests that demoting a signer will auto-nuke the currently pending release.
-func TestVersionAutoNuke(t *testing.T) {
-	// Prefund a few accounts to authorize with and create the oracle
-	keys := make([]*ecdsa.PrivateKey, 5)
-	for i := 0; i < len(keys); i++ {
-		keys[i], _ = crypto.GenerateKey()
-	}
-	key, oracle, sim := setupReleaseTest(t, keys...)
-
-	// Authorize all the keys as valid signers
-	keys = append([]*ecdsa.PrivateKey{key}, keys...)
-	for i := 1; i < len(keys); i++ {
-		for j := 0; j <= i/2; j++ {
-			if _, err := oracle.Promote(bind.NewKeyedTransactor(keys[j]), crypto.PubkeyToAddress(keys[i].PublicKey)); err != nil {
-				t.Fatalf("Iter #%d: failed valid promotion attempt: %v", i, err)
-			}
-		}
-		sim.Commit()
-	}
-	// Make a release proposal and check it's existence
-	if _, err := oracle.Release(bind.NewKeyedTransactor(keys[0]), 1, 2, 3, [20]byte{4}); err != nil {
-		t.Fatalf("Failed valid proposal attempt: %v", err)
-	}
-	sim.Commit()
-
-	prop, err := oracle.ProposedVersion(nil)
-	if err != nil {
-		t.Fatalf("Failed to retrieve active proposal: %v", err)
-	}
-	if len(prop.Pass) != 1 {
-		t.Fatalf("Proposal vote count mismatch: have %d, want 1", len(prop.Pass))
-	}
-	// Demote a signer and check release proposal deletion
-	for i := 0; i <= len(keys)/2; i++ {
-		if _, err := oracle.Demote(bind.NewKeyedTransactor(keys[i]), crypto.PubkeyToAddress(keys[len(keys)-1].PublicKey)); err != nil {
-			t.Fatalf("Iter #%d: failed valid demotion attempt: %v", i, err)
-		}
-	}
-	sim.Commit()
-
-	prop, err = oracle.ProposedVersion(nil)
-	if err != nil {
-		t.Fatalf("Failed to retrieve active proposal: %v", err)
-	}
-	if len(prop.Pass) != 0 {
-		t.Fatalf("Proposal vote count mismatch: have %d, want 0", len(prop.Pass))
-	}
-}
diff --git a/contracts/release/release.go b/contracts/release/release.go
deleted file mode 100644
index 4442ce3e0d..0000000000
--- a/contracts/release/release.go
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-// Package release contains the node service that tracks client releases.
-package release
-
-//go:generate abigen --sol ./contract.sol --pkg release --out ./contract.go
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/internal/ethapi"
-	"github.com/ethereum/go-ethereum/les"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/node"
-	"github.com/ethereum/go-ethereum/p2p"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-// Interval to check for new releases
-const releaseRecheckInterval = time.Hour
-
-// Config contains the configurations of the release service.
-type Config struct {
-	Oracle common.Address // Ethereum address of the release oracle
-	Major  uint32         // Major version component of the release
-	Minor  uint32         // Minor version component of the release
-	Patch  uint32         // Patch version component of the release
-	Commit [20]byte       // Git SHA1 commit hash of the release
-}
-
-// ReleaseService is a node service that periodically checks the blockchain for
-// newly released versions of the client being run and issues a warning to the
-// user about it.
-type ReleaseService struct {
-	config Config          // Current version to check releases against
-	oracle *ReleaseOracle  // Native binding to the release oracle contract
-	quit   chan chan error // Quit channel to terminate the version checker
-}
-
-// NewReleaseService creates a new service to periodically check for new client
-// releases and notify the user of such.
-func NewReleaseService(ctx *node.ServiceContext, config Config) (node.Service, error) {
-	// Retrieve the Ethereum service dependency to access the blockchain
-	var apiBackend ethapi.Backend
-	var ethereum *eth.Ethereum
-	if err := ctx.Service(ðereum); err == nil {
-		apiBackend = ethereum.ApiBackend
-	} else {
-		var ethereum *les.LightEthereum
-		if err := ctx.Service(ðereum); err == nil {
-			apiBackend = ethereum.ApiBackend
-		} else {
-			return nil, err
-		}
-	}
-	// Construct the release service
-	contract, err := NewReleaseOracle(config.Oracle, eth.NewContractBackend(apiBackend))
-	if err != nil {
-		return nil, err
-	}
-	return &ReleaseService{
-		config: config,
-		oracle: contract,
-		quit:   make(chan chan error),
-	}, nil
-}
-
-// Protocols returns an empty list of P2P protocols as the release service does
-// not have a networking component.
-func (r *ReleaseService) Protocols() []p2p.Protocol { return nil }
-
-// APIs returns an empty list of RPC descriptors as the release service does not
-// expose any functioanlity to the outside world.
-func (r *ReleaseService) APIs() []rpc.API { return nil }
-
-// Start spawns the periodic version checker goroutine
-func (r *ReleaseService) Start(server *p2p.Server) error {
-	go r.checker()
-	return nil
-}
-
-// Stop terminates all goroutines belonging to the service, blocking until they
-// are all terminated.
-func (r *ReleaseService) Stop() error {
-	errc := make(chan error)
-	r.quit <- errc
-	return <-errc
-}
-
-// checker runs indefinitely in the background, periodically checking for new
-// client releases.
-func (r *ReleaseService) checker() {
-	// Set up the timers to periodically check for releases
-	timer := time.NewTimer(0) // Immediately fire a version check
-	defer timer.Stop()
-
-	for {
-		select {
-		case <-timer.C:
-			// Rechedule the timer before continuing
-			timer.Reset(releaseRecheckInterval)
-			r.checkVersion()
-		case errc := <-r.quit:
-			errc <- nil
-			return
-		}
-	}
-}
-
-func (r *ReleaseService) checkVersion() {
-	// Retrieve the current version, and handle missing contracts gracefully
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
-	opts := &bind.CallOpts{Context: ctx}
-	defer cancel()
-
-	version, err := r.oracle.CurrentVersion(opts)
-	if err != nil {
-		if err == bind.ErrNoCode {
-			log.Debug("Release oracle not found", "contract", r.config.Oracle)
-		} else if err != les.ErrNoPeers {
-			log.Error("Failed to retrieve current release", "err", err)
-		}
-		return
-	}
-	// Version was successfully retrieved, notify if newer than ours
-	if version.Major > r.config.Major ||
-		(version.Major == r.config.Major && version.Minor > r.config.Minor) ||
-		(version.Major == r.config.Major && version.Minor == r.config.Minor && version.Patch > r.config.Patch) {
-
-		warning := fmt.Sprintf("Client v%d.%d.%d-%x seems older than the latest upstream release v%d.%d.%d-%x",
-			r.config.Major, r.config.Minor, r.config.Patch, r.config.Commit[:4], version.Major, version.Minor, version.Patch, version.Commit[:4])
-		howtofix := fmt.Sprintf("Please check https://github.com/ethereum/go-ethereum/releases for new releases")
-		separator := strings.Repeat("-", len(warning))
-
-		log.Warn(separator)
-		log.Warn(warning)
-		log.Warn(howtofix)
-		log.Warn(separator)
-	} else {
-		log.Debug("Client seems up to date with upstream",
-			"local", fmt.Sprintf("v%d.%d.%d-%x", r.config.Major, r.config.Minor, r.config.Patch, r.config.Commit[:4]),
-			"upstream", fmt.Sprintf("v%d.%d.%d-%x", version.Major, version.Minor, version.Patch, version.Commit[:4]))
-	}
-}
diff --git a/core/asm/compiler.go b/core/asm/compiler.go
index 318c4e4d80..c7a5440701 100644
--- a/core/asm/compiler.go
+++ b/core/asm/compiler.go
@@ -17,7 +17,6 @@
 package asm
 
 import (
-	"errors"
 	"fmt"
 	"math/big"
 	"os"
@@ -52,7 +51,7 @@ func NewCompiler(debug bool) *Compiler {
 // the compiler.
 //
 // feed is the first pass in the compile stage as it
-// collect the used labels in the program and keeps a
+// collects the used labels in the program and keeps a
 // program counter which is used to determine the locations
 // of the jump dests. The labels can than be used in the
 // second stage to push labels and determine the right
@@ -114,15 +113,15 @@ func (c *Compiler) Compile() (string, []error) {
 }
 
 // next returns the next token and increments the
-// posititon.
+// position.
 func (c *Compiler) next() token {
 	token := c.tokens[c.pos]
 	c.pos++
 	return token
 }
 
-// compile line compiles a single line instruction e.g.
-// "push 1", "jump @labal".
+// compileLine compiles a single line instruction e.g.
+// "push 1", "jump @label".
 func (c *Compiler) compileLine() error {
 	n := c.next()
 	if n.typ != lineStart {
@@ -237,19 +236,16 @@ func (c *Compiler) pushBin(v interface{}) {
 // isPush returns whether the string op is either any of
 // push(N).
 func isPush(op string) bool {
-	return op == "push"
+	return strings.ToUpper(op) == "PUSH"
 }
 
 // isJump returns whether the string op is jump(i)
 func isJump(op string) bool {
-	return op == "jumpi" || op == "jump"
+	return strings.ToUpper(op) == "JUMPI" || strings.ToUpper(op) == "JUMP"
 }
 
 // toBinary converts text to a vm.OpCode
 func toBinary(text string) vm.OpCode {
-	if isPush(text) {
-		text = "push1"
-	}
 	return vm.StringToOp(strings.ToUpper(text))
 }
 
@@ -264,11 +260,6 @@ func (err compileError) Error() string {
 	return fmt.Sprintf("%d syntax error: unexpected %v, expected %v", err.lineno, err.got, err.want)
 }
 
-var (
-	errExpBol            = errors.New("expected beginning of line")
-	errExpElementOrLabel = errors.New("expected beginning of line")
-)
-
 func compileErr(c token, got, want string) error {
 	return compileError{
 		got:    got,
diff --git a/core/asm/lexer.go b/core/asm/lexer.go
index a34b2cbd8f..91caeb27bc 100644
--- a/core/asm/lexer.go
+++ b/core/asm/lexer.go
@@ -48,7 +48,7 @@ const (
 	lineEnd                           // emitted when a line ends
 	invalidStatement                  // any invalid statement
 	element                           // any element during element parsing
-	label                             // label is emitted when a labal is found
+	label                             // label is emitted when a label is found
 	labelDef                          // label definition is emitted when a new label is found
 	number                            // number is emitted when a number is found
 	stringValue                       // stringValue is emitted when a string has been found
@@ -206,7 +206,7 @@ func lexLine(l *lexer) stateFn {
 			return lexComment
 		case isSpace(r):
 			l.ignore()
-		case isAlphaNumeric(r) || r == '_':
+		case isLetter(r) || r == '_':
 			return lexElement
 		case isNumber(r):
 			return lexNumber
@@ -242,7 +242,7 @@ func lexLabel(l *lexer) stateFn {
 }
 
 // lexInsideString lexes the inside of a string until
-// until the state function finds the closing quote.
+// the state function finds the closing quote.
 // It returns the lex text state function.
 func lexInsideString(l *lexer) stateFn {
 	if l.acceptRunUntil('"') {
@@ -278,7 +278,7 @@ func lexElement(l *lexer) stateFn {
 	return lexLine
 }
 
-func isAlphaNumeric(t rune) bool {
+func isLetter(t rune) bool {
 	return unicode.IsLetter(t)
 }
 
diff --git a/core/bench_test.go b/core/bench_test.go
index ab25c27d39..748aebe407 100644
--- a/core/bench_test.go
+++ b/core/bench_test.go
@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -84,7 +85,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 	return func(i int, gen *BlockGen) {
 		toaddr := common.Address{}
 		data := make([]byte, nbytes)
-		gas := IntrinsicGas(data, false, false)
+		gas, _ := IntrinsicGas(data, false, false)
 		tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data), types.HomesteadSigner{}, benchRootKey)
 		gen.AddTx(tx)
 	}
@@ -93,7 +94,6 @@ func genValueTx(nbytes int) func(int, *BlockGen) {
 var (
 	ringKeys  = make([]*ecdsa.PrivateKey, 1000)
 	ringAddrs = make([]common.Address, len(ringKeys))
-	bigTxGas  = new(big.Int).SetUint64(params.TxGas)
 )
 
 func init() {
@@ -113,8 +113,8 @@ func genTxRing(naccounts int) func(int, *BlockGen) {
 	return func(i int, gen *BlockGen) {
 		gas := CalcGasLimit(gen.PrevBlock(i - 1))
 		for {
-			gas.Sub(gas, bigTxGas)
-			if gas.Cmp(bigTxGas) < 0 {
+			gas -= params.TxGas
+			if gas < params.TxGas {
 				break
 			}
 			to := (from + 1) % naccounts
@@ -122,7 +122,7 @@ func genTxRing(naccounts int) func(int, *BlockGen) {
 				gen.TxNonce(ringAddrs[from]),
 				ringAddrs[to],
 				benchRootFunds,
-				bigTxGas,
+				params.TxGas,
 				nil,
 				nil,
 			)
@@ -149,7 +149,7 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 	// Create the database in memory or in a temporary directory.
 	var db ethdb.Database
 	if !disk {
-		db, _ = ethdb.NewMemDatabase()
+		db = ethdb.NewMemDatabase()
 	} else {
 		dir, err := ioutil.TempDir("", "eth-core-bench")
 		if err != nil {
@@ -170,11 +170,11 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) {
 		Alloc:  GenesisAlloc{benchRootAddr: {Balance: benchRootFunds}},
 	}
 	genesis := gspec.MustCommit(db)
-	chain, _ := GenerateChain(gspec.Config, genesis, db, b.N, gen)
+	chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, b.N, gen)
 
 	// Time the insertion of the new chain.
 	// State and blocks are stored in the same DB.
-	chainman, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	chainman, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer chainman.Stop()
 	b.ReportAllocs()
 	b.ResetTimer()
@@ -235,13 +235,15 @@ func makeChainForBench(db ethdb.Database, full bool, count uint64) {
 			ReceiptHash: types.EmptyRootHash,
 		}
 		hash = header.Hash()
-		WriteHeader(db, header)
-		WriteCanonicalHash(db, hash, n)
-		WriteTd(db, hash, n, big.NewInt(int64(n+1)))
+
+		rawdb.WriteHeader(db, header)
+		rawdb.WriteCanonicalHash(db, hash, n)
+		rawdb.WriteTd(db, hash, n, big.NewInt(int64(n+1)))
+
 		if full || n == 0 {
 			block := types.NewBlockWithHeader(header)
-			WriteBody(db, hash, n, block.Body())
-			WriteBlockReceipts(db, hash, n, nil)
+			rawdb.WriteBody(db, hash, n, block.Body())
+			rawdb.WriteReceipts(db, hash, n, nil)
 		}
 	}
 }
@@ -284,7 +286,7 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
 		if err != nil {
 			b.Fatalf("error opening database at %v: %v", dir, err)
 		}
-		chain, err := NewBlockChain(db, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
+		chain, err := NewBlockChain(db, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
 		if err != nil {
 			b.Fatalf("error creating chain: %v", err)
 		}
@@ -293,11 +295,10 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
 			header := chain.GetHeaderByNumber(n)
 			if full {
 				hash := header.Hash()
-				GetBody(db, hash, n)
-				GetBlockReceipts(db, hash, n)
+				rawdb.ReadBody(db, hash, n)
+				rawdb.ReadReceipts(db, hash, n)
 			}
 		}
-
 		chain.Stop()
 		db.Close()
 	}
diff --git a/core/block_validator.go b/core/block_validator.go
index e9cfd04827..98958809b7 100644
--- a/core/block_validator.go
+++ b/core/block_validator.go
@@ -18,9 +18,7 @@ package core
 
 import (
 	"fmt"
-	"math/big"
 
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -52,11 +50,14 @@ func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engin
 // validated at this point.
 func (v *BlockValidator) ValidateBody(block *types.Block) error {
 	// Check whether the block's known, and if not, that it's linkable
-	if v.bc.HasBlockAndState(block.Hash()) {
+	if v.bc.HasBlockAndState(block.Hash(), block.NumberU64()) {
 		return ErrKnownBlock
 	}
-	if !v.bc.HasBlockAndState(block.ParentHash()) {
-		return consensus.ErrUnknownAncestor
+	if !v.bc.HasBlockAndState(block.ParentHash(), block.NumberU64()-1) {
+		if !v.bc.HasBlock(block.ParentHash(), block.NumberU64()-1) {
+			return consensus.ErrUnknownAncestor
+		}
+		return consensus.ErrPrunedAncestor
 	}
 	// Header validity is known at this point, check the uncles and transactions
 	header := block.Header()
@@ -76,10 +77,10 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
 // transition, such as amount of used gas, the receipt roots and the state root
 // itself. ValidateState returns a database batch if the validation was a success
 // otherwise nil and an error is returned.
-func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) error {
+func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64) error {
 	header := block.Header()
-	if block.GasUsed().Cmp(usedGas) != 0 {
-		return fmt.Errorf("invalid gas used (remote: %v local: %v)", block.GasUsed(), usedGas)
+	if block.GasUsed() != usedGas {
+		return fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), usedGas)
 	}
 	// Validate the received block's bloom with the one derived from the generated receipts.
 	// For valid blocks this should always validate to true.
@@ -101,17 +102,13 @@ func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *stat
 }
 
 // CalcGasLimit computes the gas limit of the next block after parent.
-// The result may be modified by the caller.
 // This is miner strategy, not consensus protocol.
-func CalcGasLimit(parent *types.Block) *big.Int {
+func CalcGasLimit(parent *types.Block) uint64 {
 	// contrib = (parentGasUsed * 3 / 2) / 1024
-	contrib := new(big.Int).Mul(parent.GasUsed(), big.NewInt(3))
-	contrib = contrib.Div(contrib, big.NewInt(2))
-	contrib = contrib.Div(contrib, params.GasLimitBoundDivisor)
+	contrib := (parent.GasUsed() + parent.GasUsed()/2) / params.GasLimitBoundDivisor
 
 	// decay = parentGasLimit / 1024 -1
-	decay := new(big.Int).Div(parent.GasLimit(), params.GasLimitBoundDivisor)
-	decay.Sub(decay, big.NewInt(1))
+	decay := parent.GasLimit()/params.GasLimitBoundDivisor - 1
 
 	/*
 		strategy: gasLimit of block-to-mine is set based on parent's
@@ -120,15 +117,17 @@ func CalcGasLimit(parent *types.Block) *big.Int {
 		at that usage) the amount increased/decreased depends on how far away
 		from parentGasLimit * (2/3) parentGasUsed is.
 	*/
-	gl := new(big.Int).Sub(parent.GasLimit(), decay)
-	gl = gl.Add(gl, contrib)
-	gl.Set(math.BigMax(gl, params.MinGasLimit))
-
+	limit := parent.GasLimit() - decay + contrib
+	if limit < params.MinGasLimit {
+		limit = params.MinGasLimit
+	}
 	// however, if we're now below the target (TargetGasLimit) we increase the
 	// limit as much as we can (parentGasLimit / 1024 -1)
-	if gl.Cmp(params.TargetGasLimit) < 0 {
-		gl.Add(parent.GasLimit(), decay)
-		gl.Set(math.BigMin(gl, params.TargetGasLimit))
+	if limit < params.TargetGasLimit {
+		limit = parent.GasLimit() + decay
+		if limit > params.TargetGasLimit {
+			limit = params.TargetGasLimit
+		}
 	}
-	return gl
+	return limit
 }
diff --git a/core/block_validator_test.go b/core/block_validator_test.go
index 6d54c2b932..2a171218e3 100644
--- a/core/block_validator_test.go
+++ b/core/block_validator_test.go
@@ -32,17 +32,17 @@ import (
 func TestHeaderVerification(t *testing.T) {
 	// Create a simple chain to verify
 	var (
-		testdb, _ = ethdb.NewMemDatabase()
+		testdb    = ethdb.NewMemDatabase()
 		gspec     = &Genesis{Config: params.TestChainConfig}
 		genesis   = gspec.MustCommit(testdb)
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil)
+		blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 8, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	for i, block := range blocks {
 		headers[i] = block.Header()
 	}
 	// Run the header checker for blocks one-by-one, checking for both valid and invalid nonces
-	chain, _ := NewBlockChain(testdb, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
+	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
 	defer chain.Stop()
 
 	for i := 0; i < len(blocks); i++ {
@@ -84,10 +84,10 @@ func TestHeaderConcurrentVerification32(t *testing.T) { testHeaderConcurrentVeri
 func testHeaderConcurrentVerification(t *testing.T, threads int) {
 	// Create a simple chain to verify
 	var (
-		testdb, _ = ethdb.NewMemDatabase()
+		testdb    = ethdb.NewMemDatabase()
 		gspec     = &Genesis{Config: params.TestChainConfig}
 		genesis   = gspec.MustCommit(testdb)
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil)
+		blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 8, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	seals := make([]bool, len(blocks))
@@ -106,11 +106,11 @@ func testHeaderConcurrentVerification(t *testing.T, threads int) {
 		var results <-chan error
 
 		if valid {
-			chain, _ := NewBlockChain(testdb, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
+			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFaker(), vm.Config{})
 			_, results = chain.engine.VerifyHeaders(chain, headers, seals)
 			chain.Stop()
 		} else {
-			chain, _ := NewBlockChain(testdb, params.TestChainConfig, ethash.NewFakeFailer(uint64(len(headers)-1)), vm.Config{})
+			chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeFailer(uint64(len(headers)-1)), vm.Config{})
 			_, results = chain.engine.VerifyHeaders(chain, headers, seals)
 			chain.Stop()
 		}
@@ -156,10 +156,10 @@ func TestHeaderConcurrentAbortion32(t *testing.T) { testHeaderConcurrentAbortion
 func testHeaderConcurrentAbortion(t *testing.T, threads int) {
 	// Create a simple chain to verify
 	var (
-		testdb, _ = ethdb.NewMemDatabase()
+		testdb    = ethdb.NewMemDatabase()
 		gspec     = &Genesis{Config: params.TestChainConfig}
 		genesis   = gspec.MustCommit(testdb)
-		blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 1024, nil)
+		blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 1024, nil)
 	)
 	headers := make([]*types.Header, len(blocks))
 	seals := make([]bool, len(blocks))
@@ -173,7 +173,7 @@ func testHeaderConcurrentAbortion(t *testing.T, threads int) {
 	defer runtime.GOMAXPROCS(old)
 
 	// Start the verifications and immediately abort
-	chain, _ := NewBlockChain(testdb, params.TestChainConfig, ethash.NewFakeDelayer(time.Millisecond), vm.Config{})
+	chain, _ := NewBlockChain(testdb, nil, params.TestChainConfig, ethash.NewFakeDelayer(time.Millisecond), vm.Config{})
 	defer chain.Stop()
 
 	abort, results := chain.engine.VerifyHeaders(chain, headers, seals)
diff --git a/core/blockchain.go b/core/blockchain.go
index 325753c7a7..34832252a7 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -30,6 +30,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/mclock"
 	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -42,10 +43,11 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/hashicorp/golang-lru"
+	"gopkg.in/karalabe/cookiejar.v2/collections/prque"
 )
 
 var (
-	blockInsertTimer = metrics.NewTimer("chain/inserts")
+	blockInsertTimer = metrics.NewRegisteredTimer("chain/inserts", nil)
 
 	ErrNoGenesis = errors.New("Genesis not found in chain")
 )
@@ -56,11 +58,20 @@ const (
 	maxFutureBlocks     = 256
 	maxTimeFutureBlocks = 30
 	badBlockLimit       = 10
+	triesInMemory       = 128
 
 	// BlockChainVersion ensures that an incompatible database forces a resync from scratch.
 	BlockChainVersion = 3
 )
 
+// CacheConfig contains the configuration values for the trie caching/pruning
+// that's resident in a blockchain.
+type CacheConfig struct {
+	Disabled      bool          // Whether to disable trie write caching (archive node)
+	TrieNodeLimit int           // Memory limit (MB) at which to flush the current in-memory trie to disk
+	TrieTimeLimit time.Duration // Time limit after which to flush the current in-memory trie to disk
+}
+
 // BlockChain represents the canonical chain given a database with a genesis
 // block. The Blockchain manages chain imports, reverts, chain reorganisations.
 //
@@ -76,10 +87,14 @@ const (
 // included in the canonical one where as GetBlockByNumber always represents the
 // canonical chain.
 type BlockChain struct {
-	config *params.ChainConfig // chain & network configuration
+	chainConfig *params.ChainConfig // Chain & network configuration
+	cacheConfig *CacheConfig        // Cache configuration for pruning
+
+	db     ethdb.Database // Low level persistent database to store final content in
+	triegc *prque.Prque   // Priority queue mapping block numbers to tries to gc
+	gcproc time.Duration  // Accumulates canonical block processing for trie dumping
 
 	hc            *HeaderChain
-	chainDb       ethdb.Database
 	rmLogsFeed    event.Feed
 	chainFeed     event.Feed
 	chainSideFeed event.Feed
@@ -93,8 +108,8 @@ type BlockChain struct {
 	procmu  sync.RWMutex // block processor lock
 
 	checkpoint       int          // checkpoint counts towards the new checkpoint
-	currentBlock     *types.Block // Current head of the block chain
-	currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!)
+	currentBlock     atomic.Value // Current head of the block chain
+	currentFastBlock atomic.Value // Current head of the fast-sync chain (may be above the block chain!)
 
 	stateCache   state.Database // State database to reuse between imports (contains state cache)
 	bodyCache    *lru.Cache     // Cache for the most recent block bodies
@@ -119,7 +134,13 @@ type BlockChain struct {
 // NewBlockChain returns a fully initialised block chain using information
 // available in the database. It initialises the default Ethereum Validator and
 // Processor.
-func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config) (*BlockChain, error) {
+func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *params.ChainConfig, engine consensus.Engine, vmConfig vm.Config) (*BlockChain, error) {
+	if cacheConfig == nil {
+		cacheConfig = &CacheConfig{
+			TrieNodeLimit: 256 * 1024 * 1024,
+			TrieTimeLimit: 5 * time.Minute,
+		}
+	}
 	bodyCache, _ := lru.New(bodyCacheLimit)
 	bodyRLPCache, _ := lru.New(bodyCacheLimit)
 	blockCache, _ := lru.New(blockCacheLimit)
@@ -127,9 +148,11 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine co
 	badBlocks, _ := lru.New(badBlockLimit)
 
 	bc := &BlockChain{
-		config:       config,
-		chainDb:      chainDb,
-		stateCache:   state.NewDatabase(chainDb),
+		chainConfig:  chainConfig,
+		cacheConfig:  cacheConfig,
+		db:           db,
+		triegc:       prque.New(),
+		stateCache:   state.NewDatabase(db),
 		quit:         make(chan struct{}),
 		bodyCache:    bodyCache,
 		bodyRLPCache: bodyRLPCache,
@@ -139,11 +162,11 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine co
 		vmConfig:     vmConfig,
 		badBlocks:    badBlocks,
 	}
-	bc.SetValidator(NewBlockValidator(config, bc, engine))
-	bc.SetProcessor(NewStateProcessor(config, bc, engine))
+	bc.SetValidator(NewBlockValidator(chainConfig, bc, engine))
+	bc.SetProcessor(NewStateProcessor(chainConfig, bc, engine))
 
 	var err error
-	bc.hc, err = NewHeaderChain(chainDb, config, engine, bc.getProcInterrupt)
+	bc.hc, err = NewHeaderChain(db, chainConfig, engine, bc.getProcInterrupt)
 	if err != nil {
 		return nil, err
 	}
@@ -180,7 +203,7 @@ func (bc *BlockChain) getProcInterrupt() bool {
 // assumes that the chain manager mutex is held.
 func (bc *BlockChain) loadLastState() error {
 	// Restore the last known head block
-	head := GetHeadBlockHash(bc.chainDb)
+	head := rawdb.ReadHeadBlockHash(bc.db)
 	if head == (common.Hash{}) {
 		// Corrupt or empty database, init from scratch
 		log.Warn("Empty database, resetting chain")
@@ -196,15 +219,17 @@ func (bc *BlockChain) loadLastState() error {
 	// Make sure the state associated with the block is available
 	if _, err := state.New(currentBlock.Root(), bc.stateCache); err != nil {
 		// Dangling block without a state associated, init from scratch
-		log.Warn("Head state missing, resetting chain", "number", currentBlock.Number(), "hash", currentBlock.Hash())
-		return bc.Reset()
+		log.Warn("Head state missing, repairing chain", "number", currentBlock.Number(), "hash", currentBlock.Hash())
+		if err := bc.repair(¤tBlock); err != nil {
+			return err
+		}
 	}
 	// Everything seems to be fine, set as the head block
-	bc.currentBlock = currentBlock
+	bc.currentBlock.Store(currentBlock)
 
 	// Restore the last known head header
-	currentHeader := bc.currentBlock.Header()
-	if head := GetHeadHeaderHash(bc.chainDb); head != (common.Hash{}) {
+	currentHeader := currentBlock.Header()
+	if head := rawdb.ReadHeadHeaderHash(bc.db); head != (common.Hash{}) {
 		if header := bc.GetHeaderByHash(head); header != nil {
 			currentHeader = header
 		}
@@ -212,21 +237,23 @@ func (bc *BlockChain) loadLastState() error {
 	bc.hc.SetCurrentHeader(currentHeader)
 
 	// Restore the last known head fast block
-	bc.currentFastBlock = bc.currentBlock
-	if head := GetHeadFastBlockHash(bc.chainDb); head != (common.Hash{}) {
+	bc.currentFastBlock.Store(currentBlock)
+	if head := rawdb.ReadHeadFastBlockHash(bc.db); head != (common.Hash{}) {
 		if block := bc.GetBlockByHash(head); block != nil {
-			bc.currentFastBlock = block
+			bc.currentFastBlock.Store(block)
 		}
 	}
 
 	// Issue a status log for the user
+	currentFastBlock := bc.CurrentFastBlock()
+
 	headerTd := bc.GetTd(currentHeader.Hash(), currentHeader.Number.Uint64())
-	blockTd := bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64())
-	fastTd := bc.GetTd(bc.currentFastBlock.Hash(), bc.currentFastBlock.NumberU64())
+	blockTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
+	fastTd := bc.GetTd(currentFastBlock.Hash(), currentFastBlock.NumberU64())
 
 	log.Info("Loaded most recent local header", "number", currentHeader.Number, "hash", currentHeader.Hash(), "td", headerTd)
-	log.Info("Loaded most recent local full block", "number", bc.currentBlock.Number(), "hash", bc.currentBlock.Hash(), "td", blockTd)
-	log.Info("Loaded most recent local fast block", "number", bc.currentFastBlock.Number(), "hash", bc.currentFastBlock.Hash(), "td", fastTd)
+	log.Info("Loaded most recent local full block", "number", currentBlock.Number(), "hash", currentBlock.Hash(), "td", blockTd)
+	log.Info("Loaded most recent local fast block", "number", currentFastBlock.Number(), "hash", currentFastBlock.Hash(), "td", fastTd)
 
 	return nil
 }
@@ -243,7 +270,7 @@ func (bc *BlockChain) SetHead(head uint64) error {
 
 	// Rewind the header chain, deleting all block bodies until then
 	delFn := func(hash common.Hash, num uint64) {
-		DeleteBody(bc.chainDb, hash, num)
+		rawdb.DeleteBody(bc.db, hash, num)
 	}
 	bc.hc.SetHead(head, delFn)
 	currentHeader := bc.hc.CurrentHeader()
@@ -255,32 +282,32 @@ func (bc *BlockChain) SetHead(head uint64) error {
 	bc.futureBlocks.Purge()
 
 	// Rewind the block chain, ensuring we don't end up with a stateless head block
-	if bc.currentBlock != nil && currentHeader.Number.Uint64() < bc.currentBlock.NumberU64() {
-		bc.currentBlock = bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64())
+	if currentBlock := bc.CurrentBlock(); currentBlock != nil && currentHeader.Number.Uint64() < currentBlock.NumberU64() {
+		bc.currentBlock.Store(bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64()))
 	}
-	if bc.currentBlock != nil {
-		if _, err := state.New(bc.currentBlock.Root(), bc.stateCache); err != nil {
+	if currentBlock := bc.CurrentBlock(); currentBlock != nil {
+		if _, err := state.New(currentBlock.Root(), bc.stateCache); err != nil {
 			// Rewound state missing, rolled back to before pivot, reset to genesis
-			bc.currentBlock = nil
+			bc.currentBlock.Store(bc.genesisBlock)
 		}
 	}
 	// Rewind the fast block in a simpleton way to the target head
-	if bc.currentFastBlock != nil && currentHeader.Number.Uint64() < bc.currentFastBlock.NumberU64() {
-		bc.currentFastBlock = bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64())
+	if currentFastBlock := bc.CurrentFastBlock(); currentFastBlock != nil && currentHeader.Number.Uint64() < currentFastBlock.NumberU64() {
+		bc.currentFastBlock.Store(bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64()))
 	}
 	// If either blocks reached nil, reset to the genesis state
-	if bc.currentBlock == nil {
-		bc.currentBlock = bc.genesisBlock
+	if currentBlock := bc.CurrentBlock(); currentBlock == nil {
+		bc.currentBlock.Store(bc.genesisBlock)
 	}
-	if bc.currentFastBlock == nil {
-		bc.currentFastBlock = bc.genesisBlock
-	}
-	if err := WriteHeadBlockHash(bc.chainDb, bc.currentBlock.Hash()); err != nil {
-		log.Crit("Failed to reset head full block", "err", err)
-	}
-	if err := WriteHeadFastBlockHash(bc.chainDb, bc.currentFastBlock.Hash()); err != nil {
-		log.Crit("Failed to reset head fast block", "err", err)
+	if currentFastBlock := bc.CurrentFastBlock(); currentFastBlock == nil {
+		bc.currentFastBlock.Store(bc.genesisBlock)
 	}
+	currentBlock := bc.CurrentBlock()
+	currentFastBlock := bc.CurrentFastBlock()
+
+	rawdb.WriteHeadBlockHash(bc.db, currentBlock.Hash())
+	rawdb.WriteHeadFastBlockHash(bc.db, currentFastBlock.Hash())
+
 	return bc.loadLastState()
 }
 
@@ -292,12 +319,12 @@ func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error {
 	if block == nil {
 		return fmt.Errorf("non existent block [%x…]", hash[:4])
 	}
-	if _, err := trie.NewSecure(block.Root(), bc.chainDb, 0); err != nil {
+	if _, err := trie.NewSecure(block.Root(), bc.stateCache.TrieDB(), 0); err != nil {
 		return err
 	}
 	// If all checks out, manually set the head block
 	bc.mu.Lock()
-	bc.currentBlock = block
+	bc.currentBlock.Store(block)
 	bc.mu.Unlock()
 
 	log.Info("Committed new head block", "number", block.Number(), "hash", hash)
@@ -305,46 +332,20 @@ func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error {
 }
 
 // GasLimit returns the gas limit of the current HEAD block.
-func (bc *BlockChain) GasLimit() *big.Int {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
-	return bc.currentBlock.GasLimit()
-}
-
-// LastBlockHash return the hash of the HEAD block.
-func (bc *BlockChain) LastBlockHash() common.Hash {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
-	return bc.currentBlock.Hash()
+func (bc *BlockChain) GasLimit() uint64 {
+	return bc.CurrentBlock().GasLimit()
 }
 
 // CurrentBlock retrieves the current head block of the canonical chain. The
 // block is retrieved from the blockchain's internal cache.
 func (bc *BlockChain) CurrentBlock() *types.Block {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
-	return bc.currentBlock
+	return bc.currentBlock.Load().(*types.Block)
 }
 
 // CurrentFastBlock retrieves the current fast-sync head block of the canonical
 // chain. The block is retrieved from the blockchain's internal cache.
 func (bc *BlockChain) CurrentFastBlock() *types.Block {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
-	return bc.currentFastBlock
-}
-
-// Status returns status information about the current chain such as the HEAD Td,
-// the HEAD hash and the hash of the genesis block.
-func (bc *BlockChain) Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash) {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
-	return bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64()), bc.currentBlock.Hash(), bc.genesisBlock.Hash()
+	return bc.currentFastBlock.Load().(*types.Block)
 }
 
 // SetProcessor sets the processor required for making state modifications.
@@ -404,22 +405,39 @@ func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error {
 	if err := bc.hc.WriteTd(genesis.Hash(), genesis.NumberU64(), genesis.Difficulty()); err != nil {
 		log.Crit("Failed to write genesis block TD", "err", err)
 	}
-	if err := WriteBlock(bc.chainDb, genesis); err != nil {
-		log.Crit("Failed to write genesis block", "err", err)
-	}
+	rawdb.WriteBlock(bc.db, genesis)
+
 	bc.genesisBlock = genesis
 	bc.insert(bc.genesisBlock)
-	bc.currentBlock = bc.genesisBlock
+	bc.currentBlock.Store(bc.genesisBlock)
 	bc.hc.SetGenesis(bc.genesisBlock.Header())
 	bc.hc.SetCurrentHeader(bc.genesisBlock.Header())
-	bc.currentFastBlock = bc.genesisBlock
+	bc.currentFastBlock.Store(bc.genesisBlock)
 
 	return nil
 }
 
+// repair tries to repair the current blockchain by rolling back the current block
+// until one with associated state is found. This is needed to fix incomplete db
+// writes caused either by crashes/power outages, or simply non-committed tries.
+//
+// This method only rolls back the current block. The current header and current
+// fast block are left intact.
+func (bc *BlockChain) repair(head **types.Block) error {
+	for {
+		// Abort if we've rewound to a head block that does have associated state
+		if _, err := state.New((*head).Root(), bc.stateCache); err == nil {
+			log.Info("Rewound blockchain to past state", "number", (*head).Number(), "hash", (*head).Hash())
+			return nil
+		}
+		// Otherwise rewind one block and recheck state availability there
+		(*head) = bc.GetBlock((*head).ParentHash(), (*head).NumberU64()-1)
+	}
+}
+
 // Export writes the active chain to the given writer.
 func (bc *BlockChain) Export(w io.Writer) error {
-	return bc.ExportN(w, uint64(0), bc.currentBlock.NumberU64())
+	return bc.ExportN(w, uint64(0), bc.CurrentBlock().NumberU64())
 }
 
 // ExportN writes a subset of the active chain to the given writer.
@@ -454,25 +472,20 @@ func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error {
 // Note, this function assumes that the `mu` mutex is held!
 func (bc *BlockChain) insert(block *types.Block) {
 	// If the block is on a side chain or an unknown one, force other heads onto it too
-	updateHeads := GetCanonicalHash(bc.chainDb, block.NumberU64()) != block.Hash()
+	updateHeads := rawdb.ReadCanonicalHash(bc.db, block.NumberU64()) != block.Hash()
 
 	// Add the block to the canonical chain number scheme and mark as the head
-	if err := WriteCanonicalHash(bc.chainDb, block.Hash(), block.NumberU64()); err != nil {
-		log.Crit("Failed to insert block number", "err", err)
-	}
-	if err := WriteHeadBlockHash(bc.chainDb, block.Hash()); err != nil {
-		log.Crit("Failed to insert head block hash", "err", err)
-	}
-	bc.currentBlock = block
+	rawdb.WriteCanonicalHash(bc.db, block.Hash(), block.NumberU64())
+	rawdb.WriteHeadBlockHash(bc.db, block.Hash())
 
-	// If the block is better than out head or is on a different chain, force update heads
+	bc.currentBlock.Store(block)
+
+	// If the block is better than our head or is on a different chain, force update heads
 	if updateHeads {
 		bc.hc.SetCurrentHeader(block.Header())
+		rawdb.WriteHeadFastBlockHash(bc.db, block.Hash())
 
-		if err := WriteHeadFastBlockHash(bc.chainDb, block.Hash()); err != nil {
-			log.Crit("Failed to insert head fast block hash", "err", err)
-		}
-		bc.currentFastBlock = block
+		bc.currentFastBlock.Store(block)
 	}
 }
 
@@ -489,7 +502,11 @@ func (bc *BlockChain) GetBody(hash common.Hash) *types.Body {
 		body := cached.(*types.Body)
 		return body
 	}
-	body := GetBody(bc.chainDb, hash, bc.hc.GetBlockNumber(hash))
+	number := bc.hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
+	body := rawdb.ReadBody(bc.db, hash, *number)
 	if body == nil {
 		return nil
 	}
@@ -505,7 +522,11 @@ func (bc *BlockChain) GetBodyRLP(hash common.Hash) rlp.RawValue {
 	if cached, ok := bc.bodyRLPCache.Get(hash); ok {
 		return cached.(rlp.RawValue)
 	}
-	body := GetBodyRLP(bc.chainDb, hash, bc.hc.GetBlockNumber(hash))
+	number := bc.hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
+	body := rawdb.ReadBodyRLP(bc.db, hash, *number)
 	if len(body) == 0 {
 		return nil
 	}
@@ -519,21 +540,24 @@ func (bc *BlockChain) HasBlock(hash common.Hash, number uint64) bool {
 	if bc.blockCache.Contains(hash) {
 		return true
 	}
-	ok, _ := bc.chainDb.Has(blockBodyKey(hash, number))
-	return ok
+	return rawdb.HasBody(bc.db, hash, number)
+}
+
+// HasState checks if state trie is fully present in the database or not.
+func (bc *BlockChain) HasState(hash common.Hash) bool {
+	_, err := bc.stateCache.OpenTrie(hash)
+	return err == nil
 }
 
 // HasBlockAndState checks if a block and associated state trie is fully present
 // in the database or not, caching it if present.
-func (bc *BlockChain) HasBlockAndState(hash common.Hash) bool {
+func (bc *BlockChain) HasBlockAndState(hash common.Hash, number uint64) bool {
 	// Check first that the block itself is known
-	block := bc.GetBlockByHash(hash)
+	block := bc.GetBlock(hash, number)
 	if block == nil {
 		return false
 	}
-	// Ensure the associated state is also present
-	_, err := bc.stateCache.OpenTrie(block.Root())
-	return err == nil
+	return bc.HasState(block.Root())
 }
 
 // GetBlock retrieves a block from the database by hash and number,
@@ -543,7 +567,7 @@ func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block {
 	if block, ok := bc.blockCache.Get(hash); ok {
 		return block.(*types.Block)
 	}
-	block := GetBlock(bc.chainDb, hash, number)
+	block := rawdb.ReadBlock(bc.db, hash, number)
 	if block == nil {
 		return nil
 	}
@@ -554,31 +578,47 @@ func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block {
 
 // GetBlockByHash retrieves a block from the database by hash, caching it if found.
 func (bc *BlockChain) GetBlockByHash(hash common.Hash) *types.Block {
-	return bc.GetBlock(hash, bc.hc.GetBlockNumber(hash))
+	number := bc.hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
+	return bc.GetBlock(hash, *number)
 }
 
 // GetBlockByNumber retrieves a block from the database by number, caching it
 // (associated with its hash) if found.
 func (bc *BlockChain) GetBlockByNumber(number uint64) *types.Block {
-	hash := GetCanonicalHash(bc.chainDb, number)
+	hash := rawdb.ReadCanonicalHash(bc.db, number)
 	if hash == (common.Hash{}) {
 		return nil
 	}
 	return bc.GetBlock(hash, number)
 }
 
+// GetReceiptsByHash retrieves the receipts for all transactions in a given block.
+func (bc *BlockChain) GetReceiptsByHash(hash common.Hash) types.Receipts {
+	number := rawdb.ReadHeaderNumber(bc.db, hash)
+	if number == nil {
+		return nil
+	}
+	return rawdb.ReadReceipts(bc.db, hash, *number)
+}
+
 // GetBlocksFromHash returns the block corresponding to hash and up to n-1 ancestors.
 // [deprecated by eth/62]
 func (bc *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block) {
 	number := bc.hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
 	for i := 0; i < n; i++ {
-		block := bc.GetBlock(hash, number)
+		block := bc.GetBlock(hash, *number)
 		if block == nil {
 			break
 		}
 		blocks = append(blocks, block)
 		hash = block.ParentHash()
-		number--
+		*number--
 	}
 	return
 }
@@ -594,6 +634,12 @@ func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.
 	return uncles
 }
 
+// TrieNode retrieves a blob of data associated with a trie node (or code hash)
+// either from ephemeral in-memory cache, or from persistent storage.
+func (bc *BlockChain) TrieNode(hash common.Hash) ([]byte, error) {
+	return bc.stateCache.TrieDB().Node(hash)
+}
+
 // Stop stops the blockchain service. If any imports are currently in progress
 // it will abort them using the procInterrupt.
 func (bc *BlockChain) Stop() {
@@ -606,6 +652,32 @@ func (bc *BlockChain) Stop() {
 	atomic.StoreInt32(&bc.procInterrupt, 1)
 
 	bc.wg.Wait()
+
+	// Ensure the state of a recent block is also stored to disk before exiting.
+	// We're writing three different states to catch different restart scenarios:
+	//  - HEAD:     So we don't need to reprocess any blocks in the general case
+	//  - HEAD-1:   So we don't do large reorgs if our HEAD becomes an uncle
+	//  - HEAD-127: So we have a hard limit on the number of blocks reexecuted
+	if !bc.cacheConfig.Disabled {
+		triedb := bc.stateCache.TrieDB()
+
+		for _, offset := range []uint64{0, 1, triesInMemory - 1} {
+			if number := bc.CurrentBlock().NumberU64(); number > offset {
+				recent := bc.GetBlockByNumber(number - offset)
+
+				log.Info("Writing cached state to disk", "block", recent.Number(), "hash", recent.Hash(), "root", recent.Root())
+				if err := triedb.Commit(recent.Root(), true); err != nil {
+					log.Error("Failed to commit recent state trie", "err", err)
+				}
+			}
+		}
+		for !bc.triegc.Empty() {
+			triedb.Dereference(bc.triegc.PopItem().(common.Hash), common.Hash{})
+		}
+		if size, _ := triedb.Size(); size != 0 {
+			log.Error("Dangling trie nodes after full cleanup")
+		}
+	}
 	log.Info("Blockchain manager stopped")
 }
 
@@ -648,22 +720,27 @@ func (bc *BlockChain) Rollback(chain []common.Hash) {
 		if currentHeader.Hash() == hash {
 			bc.hc.SetCurrentHeader(bc.GetHeader(currentHeader.ParentHash, currentHeader.Number.Uint64()-1))
 		}
-		if bc.currentFastBlock.Hash() == hash {
-			bc.currentFastBlock = bc.GetBlock(bc.currentFastBlock.ParentHash(), bc.currentFastBlock.NumberU64()-1)
-			WriteHeadFastBlockHash(bc.chainDb, bc.currentFastBlock.Hash())
+		if currentFastBlock := bc.CurrentFastBlock(); currentFastBlock.Hash() == hash {
+			newFastBlock := bc.GetBlock(currentFastBlock.ParentHash(), currentFastBlock.NumberU64()-1)
+			bc.currentFastBlock.Store(newFastBlock)
+			rawdb.WriteHeadFastBlockHash(bc.db, newFastBlock.Hash())
 		}
-		if bc.currentBlock.Hash() == hash {
-			bc.currentBlock = bc.GetBlock(bc.currentBlock.ParentHash(), bc.currentBlock.NumberU64()-1)
-			WriteHeadBlockHash(bc.chainDb, bc.currentBlock.Hash())
+		if currentBlock := bc.CurrentBlock(); currentBlock.Hash() == hash {
+			newBlock := bc.GetBlock(currentBlock.ParentHash(), currentBlock.NumberU64()-1)
+			bc.currentBlock.Store(newBlock)
+			rawdb.WriteHeadBlockHash(bc.db, newBlock.Hash())
 		}
 	}
 }
 
 // SetReceiptsData computes all the non-consensus fields of the receipts
-func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts types.Receipts) {
+func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts types.Receipts) error {
 	signer := types.MakeSigner(config, block.Number())
 
 	transactions, logIndex := block.Transactions(), uint(0)
+	if len(transactions) != len(receipts) {
+		return errors.New("transaction and receipt count mismatch")
+	}
 
 	for j := 0; j < len(receipts); j++ {
 		// The transaction hash can be retrieved from the transaction itself
@@ -677,9 +754,9 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty
 		}
 		// The used gas can be calculated based on previous receipts
 		if j == 0 {
-			receipts[j].GasUsed = new(big.Int).Set(receipts[j].CumulativeGasUsed)
+			receipts[j].GasUsed = receipts[j].CumulativeGasUsed
 		} else {
-			receipts[j].GasUsed = new(big.Int).Sub(receipts[j].CumulativeGasUsed, receipts[j-1].CumulativeGasUsed)
+			receipts[j].GasUsed = receipts[j].CumulativeGasUsed - receipts[j-1].CumulativeGasUsed
 		}
 		// The derived log fields can simply be set from the block and transaction
 		for k := 0; k < len(receipts[j].Logs); k++ {
@@ -691,6 +768,7 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty
 			logIndex++
 		}
 	}
+	return nil
 }
 
 // InsertReceiptChain attempts to complete an already existing header chain with
@@ -713,7 +791,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 		stats = struct{ processed, ignored int32 }{}
 		start = time.Now()
 		bytes = 0
-		batch = bc.chainDb.NewBatch()
+		batch = bc.db.NewBatch()
 	)
 	for i, block := range blockChain {
 		receipts := receiptChain[i]
@@ -731,17 +809,14 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 			continue
 		}
 		// Compute all the non-consensus fields of the receipts
-		SetReceiptsData(bc.config, block, receipts)
+		if err := SetReceiptsData(bc.chainConfig, block, receipts); err != nil {
+			return i, fmt.Errorf("failed to set receipts data: %v", err)
+		}
 		// Write all the data out into the database
-		if err := WriteBody(batch, block.Hash(), block.NumberU64(), block.Body()); err != nil {
-			return i, fmt.Errorf("failed to write block body: %v", err)
-		}
-		if err := WriteBlockReceipts(batch, block.Hash(), block.NumberU64(), receipts); err != nil {
-			return i, fmt.Errorf("failed to write block receipts: %v", err)
-		}
-		if err := WriteTxLookupEntries(batch, block); err != nil {
-			return i, fmt.Errorf("failed to write lookup metadata: %v", err)
-		}
+		rawdb.WriteBody(batch, block.Hash(), block.NumberU64(), block.Body())
+		rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), receipts)
+		rawdb.WriteTxLookupEntries(batch, block)
+
 		stats.processed++
 
 		if batch.ValueSize() >= ethdb.IdealBatchSize {
@@ -749,7 +824,7 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 				return 0, err
 			}
 			bytes += batch.ValueSize()
-			batch = bc.chainDb.NewBatch()
+			batch.Reset()
 		}
 	}
 	if batch.ValueSize() > 0 {
@@ -763,11 +838,10 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 	bc.mu.Lock()
 	head := blockChain[len(blockChain)-1]
 	if td := bc.GetTd(head.Hash(), head.NumberU64()); td != nil { // Rewind may have occurred, skip in that case
-		if bc.GetTd(bc.currentFastBlock.Hash(), bc.currentFastBlock.NumberU64()).Cmp(td) < 0 {
-			if err := WriteHeadFastBlockHash(bc.chainDb, head.Hash()); err != nil {
-				log.Crit("Failed to update head fast block hash", "err", err)
-			}
-			bc.currentFastBlock = head
+		currentFastBlock := bc.CurrentFastBlock()
+		if bc.GetTd(currentFastBlock.Hash(), currentFastBlock.NumberU64()).Cmp(td) < 0 {
+			rawdb.WriteHeadFastBlockHash(bc.db, head.Hash())
+			bc.currentFastBlock.Store(head)
 		}
 	}
 	bc.mu.Unlock()
@@ -775,15 +849,32 @@ func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain [
 	log.Info("Imported new block receipts",
 		"count", stats.processed,
 		"elapsed", common.PrettyDuration(time.Since(start)),
-		"bytes", bytes,
 		"number", head.Number(),
 		"hash", head.Hash(),
+		"size", common.StorageSize(bytes),
 		"ignored", stats.ignored)
 	return 0, nil
 }
 
-// WriteBlock writes the block to the chain.
-func (bc *BlockChain) WriteBlockAndState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
+var lastWrite uint64
+
+// WriteBlockWithoutState writes only the block and its metadata to the database,
+// but does not write any state. This is used to construct competing side forks
+// up to the point where they exceed the canonical total difficulty.
+func (bc *BlockChain) WriteBlockWithoutState(block *types.Block, td *big.Int) (err error) {
+	bc.wg.Add(1)
+	defer bc.wg.Done()
+
+	if err := bc.hc.WriteTd(block.Hash(), block.NumberU64(), td); err != nil {
+		return err
+	}
+	rawdb.WriteBlock(bc.db, block)
+
+	return nil
+}
+
+// WriteBlockWithState writes the block and all associated state to the database.
+func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
 	bc.wg.Add(1)
 	defer bc.wg.Done()
 
@@ -796,7 +887,8 @@ func (bc *BlockChain) WriteBlockAndState(block *types.Block, receipts []*types.R
 	bc.mu.Lock()
 	defer bc.mu.Unlock()
 
-	localTd := bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64())
+	currentBlock := bc.CurrentBlock()
+	localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
 	externTd := new(big.Int).Add(block.Difficulty(), ptd)
 
 	// Irrelevant of the canonical status, write the block itself to the database
@@ -804,40 +896,83 @@ func (bc *BlockChain) WriteBlockAndState(block *types.Block, receipts []*types.R
 		return NonStatTy, err
 	}
 	// Write other block data using a batch.
-	batch := bc.chainDb.NewBatch()
-	if err := WriteBlock(batch, block); err != nil {
+	batch := bc.db.NewBatch()
+	rawdb.WriteBlock(batch, block)
+
+	root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
+	if err != nil {
 		return NonStatTy, err
 	}
-	if _, err := state.CommitTo(batch, bc.config.IsEIP158(block.Number())); err != nil {
-		return NonStatTy, err
-	}
-	if err := WriteBlockReceipts(batch, block.Hash(), block.NumberU64(), receipts); err != nil {
-		return NonStatTy, err
+	triedb := bc.stateCache.TrieDB()
+
+	// If we're running an archive node, always flush
+	if bc.cacheConfig.Disabled {
+		if err := triedb.Commit(root, false); err != nil {
+			return NonStatTy, err
+		}
+	} else {
+		// Full but not archive node, do proper garbage collection
+		triedb.Reference(root, common.Hash{}) // metadata reference to keep trie alive
+		bc.triegc.Push(root, -float32(block.NumberU64()))
+
+		if current := block.NumberU64(); current > triesInMemory {
+			// If we exceeded our memory allowance, flush matured singleton nodes to disk
+			var (
+				nodes, imgs = triedb.Size()
+				limit       = common.StorageSize(bc.cacheConfig.TrieNodeLimit) * 1024 * 1024
+			)
+			if nodes > limit || imgs > 4*1024*1024 {
+				triedb.Cap(limit - ethdb.IdealBatchSize)
+			}
+			// Find the next state trie we need to commit
+			header := bc.GetHeaderByNumber(current - triesInMemory)
+			chosen := header.Number.Uint64()
+
+			// If we exceeded out time allowance, flush an entire trie to disk
+			if bc.gcproc > bc.cacheConfig.TrieTimeLimit {
+				// If we're exceeding limits but haven't reached a large enough memory gap,
+				// warn the user that the system is becoming unstable.
+				if chosen < lastWrite+triesInMemory && bc.gcproc >= 2*bc.cacheConfig.TrieTimeLimit {
+					log.Info("State in memory for too long, committing", "time", bc.gcproc, "allowance", bc.cacheConfig.TrieTimeLimit, "optimum", float64(chosen-lastWrite)/triesInMemory)
+				}
+				// Flush an entire trie and restart the counters
+				triedb.Commit(header.Root, true)
+				lastWrite = chosen
+				bc.gcproc = 0
+			}
+			// Garbage collect anything below our required write retention
+			for !bc.triegc.Empty() {
+				root, number := bc.triegc.Pop()
+				if uint64(-number) > chosen {
+					bc.triegc.Push(root, number)
+					break
+				}
+				triedb.Dereference(root.(common.Hash), common.Hash{})
+			}
+		}
 	}
+	rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), receipts)
 
 	// If the total difficulty is higher than our known, add it to the canonical chain
 	// Second clause in the if statement reduces the vulnerability to selfish mining.
 	// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
 	reorg := externTd.Cmp(localTd) > 0
+	currentBlock = bc.CurrentBlock()
 	if !reorg && externTd.Cmp(localTd) == 0 {
 		// Split same-difficulty blocks by number, then at random
-		reorg = block.NumberU64() < bc.currentBlock.NumberU64() || (block.NumberU64() == bc.currentBlock.NumberU64() && mrand.Float64() < 0.5)
+		reorg = block.NumberU64() < currentBlock.NumberU64() || (block.NumberU64() == currentBlock.NumberU64() && mrand.Float64() < 0.5)
 	}
 	if reorg {
 		// Reorganise the chain if the parent is not the head block
-		if block.ParentHash() != bc.currentBlock.Hash() {
-			if err := bc.reorg(bc.currentBlock, block); err != nil {
+		if block.ParentHash() != currentBlock.Hash() {
+			if err := bc.reorg(currentBlock, block); err != nil {
 				return NonStatTy, err
 			}
 		}
-		// Write the positional metadata for transaction and receipt lookups
-		if err := WriteTxLookupEntries(batch, block); err != nil {
-			return NonStatTy, err
-		}
-		// Write hash preimages
-		if err := WritePreimages(bc.chainDb, block.NumberU64(), state.Preimages()); err != nil {
-			return NonStatTy, err
-		}
+		// Write the positional metadata for transaction/receipt lookups and preimages
+		rawdb.WriteTxLookupEntries(batch, block)
+		rawdb.WritePreimages(batch, block.NumberU64(), state.Preimages())
+
 		status = CanonStatTy
 	} else {
 		status = SideStatTy
@@ -870,6 +1005,10 @@ func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 // only reason this method exists as a separate one is to make locking cleaner
 // with deferred statements.
 func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*types.Log, error) {
+	// Sanity check that we have something meaningful to import
+	if len(chain) == 0 {
+		return 0, nil, nil, nil
+	}
 	// Do a sanity check that the provided chain is actually ordered and linked
 	for i := 1; i < len(chain); i++ {
 		if chain[i].NumberU64() != chain[i-1].NumberU64()+1 || chain[i].ParentHash() != chain[i-1].Hash() {
@@ -908,6 +1047,9 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
 	abort, results := bc.engine.VerifyHeaders(bc, headers, seals)
 	defer close(abort)
 
+	// Start a parallel signature recovery (signer will fluke on fork transition, minimal perf loss)
+	senderCacher.recoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number()), chain)
+
 	// Iterate over the blocks and insert when the verifier permits
 	for i, block := range chain {
 		// If the chain is terminating, stop processing blocks
@@ -927,31 +1069,65 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
 		if err == nil {
 			err = bc.Validator().ValidateBody(block)
 		}
-		if err != nil {
-			if err == ErrKnownBlock {
+		switch {
+		case err == ErrKnownBlock:
+			// Block and state both already known. However if the current block is below
+			// this number we did a rollback and we should reimport it nonetheless.
+			if bc.CurrentBlock().NumberU64() >= block.NumberU64() {
 				stats.ignored++
 				continue
 			}
 
-			if err == consensus.ErrFutureBlock {
-				// Allow up to MaxFuture second in the future blocks. If this limit
-				// is exceeded the chain is discarded and processed at a later time
-				// if given.
-				max := big.NewInt(time.Now().Unix() + maxTimeFutureBlocks)
-				if block.Time().Cmp(max) > 0 {
-					return i, events, coalescedLogs, fmt.Errorf("future block: %v > %v", block.Time(), max)
+		case err == consensus.ErrFutureBlock:
+			// Allow up to MaxFuture second in the future blocks. If this limit is exceeded
+			// the chain is discarded and processed at a later time if given.
+			max := big.NewInt(time.Now().Unix() + maxTimeFutureBlocks)
+			if block.Time().Cmp(max) > 0 {
+				return i, events, coalescedLogs, fmt.Errorf("future block: %v > %v", block.Time(), max)
+			}
+			bc.futureBlocks.Add(block.Hash(), block)
+			stats.queued++
+			continue
+
+		case err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(block.ParentHash()):
+			bc.futureBlocks.Add(block.Hash(), block)
+			stats.queued++
+			continue
+
+		case err == consensus.ErrPrunedAncestor:
+			// Block competing with the canonical chain, store in the db, but don't process
+			// until the competitor TD goes above the canonical TD
+			currentBlock := bc.CurrentBlock()
+			localTd := bc.GetTd(currentBlock.Hash(), currentBlock.NumberU64())
+			externTd := new(big.Int).Add(bc.GetTd(block.ParentHash(), block.NumberU64()-1), block.Difficulty())
+			if localTd.Cmp(externTd) > 0 {
+				if err = bc.WriteBlockWithoutState(block, externTd); err != nil {
+					return i, events, coalescedLogs, err
 				}
-				bc.futureBlocks.Add(block.Hash(), block)
-				stats.queued++
 				continue
 			}
+			// Competitor chain beat canonical, gather all blocks from the common ancestor
+			var winner []*types.Block
 
-			if err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(block.ParentHash()) {
-				bc.futureBlocks.Add(block.Hash(), block)
-				stats.queued++
-				continue
+			parent := bc.GetBlock(block.ParentHash(), block.NumberU64()-1)
+			for !bc.HasState(parent.Root()) {
+				winner = append(winner, parent)
+				parent = bc.GetBlock(parent.ParentHash(), parent.NumberU64()-1)
+			}
+			for j := 0; j < len(winner)/2; j++ {
+				winner[j], winner[len(winner)-1-j] = winner[len(winner)-1-j], winner[j]
+			}
+			// Import all the pruned blocks to make the state available
+			bc.chainmu.Unlock()
+			_, evs, logs, err := bc.insertChain(winner)
+			bc.chainmu.Lock()
+			events, coalescedLogs = evs, logs
+
+			if err != nil {
+				return i, events, coalescedLogs, err
 			}
 
+		case err != nil:
 			bc.reportBlock(block, nil, err)
 			return i, events, coalescedLogs, err
 		}
@@ -979,8 +1155,10 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
 			bc.reportBlock(block, receipts, err)
 			return i, events, coalescedLogs, err
 		}
+		proctime := time.Since(bstart)
+
 		// Write the block to the chain and get the status.
-		status, err := bc.WriteBlockAndState(block, receipts, state)
+		status, err := bc.WriteBlockWithState(block, receipts, state)
 		if err != nil {
 			return i, events, coalescedLogs, err
 		}
@@ -994,6 +1172,9 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
 			events = append(events, ChainEvent{block, block.Hash(), logs})
 			lastCanon = block
 
+			// Only count canonical blocks for GC processing time
+			bc.gcproc += proctime
+
 		case SideStatTy:
 			log.Debug("Inserted forked block", "number", block.Number(), "hash", block.Hash(), "diff", block.Difficulty(), "elapsed",
 				common.PrettyDuration(time.Since(bstart)), "txs", len(block.Transactions()), "gas", block.GasUsed(), "uncles", len(block.Uncles()))
@@ -1002,11 +1183,13 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty
 			events = append(events, ChainSideEvent{block})
 		}
 		stats.processed++
-		stats.usedGas += usedGas.Uint64()
-		stats.report(chain, i)
+		stats.usedGas += usedGas
+
+		cache, _ := bc.stateCache.TrieDB().Size()
+		stats.report(chain, i, cache)
 	}
 	// Append a single chain head event if we've progressed the chain
-	if lastCanon != nil && bc.LastBlockHash() == lastCanon.Hash() {
+	if lastCanon != nil && bc.CurrentBlock().Hash() == lastCanon.Hash() {
 		events = append(events, ChainHeadEvent{lastCanon})
 	}
 	return 0, events, coalescedLogs, nil
@@ -1026,7 +1209,7 @@ const statsReportLimit = 8 * time.Second
 
 // report prints statistics if some number of blocks have been processed
 // or more than a few seconds have passed since the last message.
-func (st *insertStats) report(chain []*types.Block, index int) {
+func (st *insertStats) report(chain []*types.Block, index int, cache common.StorageSize) {
 	// Fetch the timings for the batch
 	var (
 		now     = mclock.Now()
@@ -1041,7 +1224,7 @@ func (st *insertStats) report(chain []*types.Block, index int) {
 		context := []interface{}{
 			"blocks", st.processed, "txs", txs, "mgas", float64(st.usedGas) / 1000000,
 			"elapsed", common.PrettyDuration(elapsed), "mgasps", float64(st.usedGas) * 1000 / float64(elapsed),
-			"number", end.Number(), "hash", end.Hash(),
+			"number", end.Number(), "hash", end.Hash(), "cache", cache,
 		}
 		if st.queued > 0 {
 			context = append(context, []interface{}{"queued", st.queued}...)
@@ -1075,9 +1258,13 @@ func (bc *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
 		// collectLogs collects the logs that were generated during the
 		// processing of the block that corresponds with the given hash.
 		// These logs are later announced as deleted.
-		collectLogs = func(h common.Hash) {
+		collectLogs = func(hash common.Hash) {
 			// Coalesce logs and set 'Removed'.
-			receipts := GetBlockReceipts(bc.chainDb, h, bc.hc.GetBlockNumber(h))
+			number := bc.hc.GetBlockNumber(hash)
+			if number == nil {
+				return
+			}
+			receipts := rawdb.ReadReceipts(bc.db, hash, *number)
 			for _, receipt := range receipts {
 				for _, log := range receipt.Logs {
 					del := *log
@@ -1140,24 +1327,21 @@ func (bc *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
 	} else {
 		log.Error("Impossible reorg, please file an issue", "oldnum", oldBlock.Number(), "oldhash", oldBlock.Hash(), "newnum", newBlock.Number(), "newhash", newBlock.Hash())
 	}
+	// Insert the new chain, taking care of the proper incremental order
 	var addedTxs types.Transactions
-	// insert blocks. Order does not matter. Last block will be written in ImportChain itself which creates the new head properly
-	for _, block := range newChain {
+	for i := len(newChain) - 1; i >= 0; i-- {
 		// insert the block in the canonical way, re-writing history
-		bc.insert(block)
+		bc.insert(newChain[i])
 		// write lookup entries for hash based transaction/receipt searches
-		if err := WriteTxLookupEntries(bc.chainDb, block); err != nil {
-			return err
-		}
-		addedTxs = append(addedTxs, block.Transactions()...)
+		rawdb.WriteTxLookupEntries(bc.db, newChain[i])
+		addedTxs = append(addedTxs, newChain[i].Transactions()...)
 	}
-
 	// calculate the difference between deleted and added transactions
 	diff := types.TxDifference(deletedTxs, addedTxs)
 	// When transactions get deleted from the database that means the
 	// receipts that were created in the fork must also be deleted
 	for _, tx := range diff {
-		DeleteTxLookupEntry(bc.chainDb, tx.Hash())
+		rawdb.DeleteTxLookupEntry(bc.db, tx.Hash())
 	}
 	if len(deletedLogs) > 0 {
 		go bc.rmLogsFeed.Send(RemovedLogsEvent{deletedLogs})
@@ -1196,10 +1380,11 @@ func (bc *BlockChain) PostChainEvents(events []interface{}, logs []*types.Log) {
 }
 
 func (bc *BlockChain) update() {
-	futureTimer := time.Tick(5 * time.Second)
+	futureTimer := time.NewTicker(5 * time.Second)
+	defer futureTimer.Stop()
 	for {
 		select {
-		case <-futureTimer:
+		case <-futureTimer.C:
 			bc.procFutureBlocks()
 		case <-bc.quit:
 			return
@@ -1207,27 +1392,21 @@ func (bc *BlockChain) update() {
 	}
 }
 
-// BadBlockArgs represents the entries in the list returned when bad blocks are queried.
-type BadBlockArgs struct {
-	Hash   common.Hash   `json:"hash"`
-	Header *types.Header `json:"header"`
-}
-
 // BadBlocks returns a list of the last 'bad blocks' that the client has seen on the network
-func (bc *BlockChain) BadBlocks() ([]BadBlockArgs, error) {
-	headers := make([]BadBlockArgs, 0, bc.badBlocks.Len())
+func (bc *BlockChain) BadBlocks() []*types.Block {
+	blocks := make([]*types.Block, 0, bc.badBlocks.Len())
 	for _, hash := range bc.badBlocks.Keys() {
-		if hdr, exist := bc.badBlocks.Peek(hash); exist {
-			header := hdr.(*types.Header)
-			headers = append(headers, BadBlockArgs{header.Hash(), header})
+		if blk, exist := bc.badBlocks.Peek(hash); exist {
+			block := blk.(*types.Block)
+			blocks = append(blocks, block)
 		}
 	}
-	return headers, nil
+	return blocks
 }
 
 // addBadBlock adds a bad block to the bad-block LRU cache
 func (bc *BlockChain) addBadBlock(block *types.Block) {
-	bc.badBlocks.Add(block.Header().Hash(), block.Header())
+	bc.badBlocks.Add(block.Hash(), block)
 }
 
 // reportBlock logs a bad block error.
@@ -1248,7 +1427,7 @@ Hash: 0x%x
 
 Error: %v
 ##############################
-`, bc.config, block.Number(), block.Hash(), receiptString, err))
+`, bc.chainConfig, block.Number(), block.Hash(), receiptString, err))
 }
 
 // InsertHeaderChain attempts to insert the given header chain in to the local
@@ -1306,9 +1485,6 @@ func (bc *BlockChain) writeHeader(header *types.Header) error {
 // CurrentHeader retrieves the current head header of the canonical chain. The
 // header is retrieved from the HeaderChain's internal cache.
 func (bc *BlockChain) CurrentHeader() *types.Header {
-	bc.mu.RLock()
-	defer bc.mu.RUnlock()
-
 	return bc.hc.CurrentHeader()
 }
 
@@ -1348,6 +1524,18 @@ func (bc *BlockChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []com
 	return bc.hc.GetBlockHashesFromHash(hash, max)
 }
 
+// GetAncestor retrieves the Nth ancestor of a given block. It assumes that either the given block or
+// a close ancestor of it is canonical. maxNonCanonical points to a downwards counter limiting the
+// number of blocks to be individually checked before we reach the canonical chain.
+//
+// Note: ancestor == 0 returns the same block, 1 returns its parent and so on.
+func (bc *BlockChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64) {
+	bc.chainmu.Lock()
+	defer bc.chainmu.Unlock()
+
+	return bc.hc.GetAncestor(hash, number, ancestor, maxNonCanonical)
+}
+
 // GetHeaderByNumber retrieves a block header from the database by number,
 // caching it (associated with its hash) if found.
 func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header {
@@ -1355,7 +1543,7 @@ func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header {
 }
 
 // Config retrieves the blockchain's chain configuration.
-func (bc *BlockChain) Config() *params.ChainConfig { return bc.config }
+func (bc *BlockChain) Config() *params.ChainConfig { return bc.chainConfig }
 
 // Engine retrieves the blockchain's consensus engine.
 func (bc *BlockChain) Engine() consensus.Engine { return bc.engine }
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index cb1df8d4b0..f409bb7b08 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -25,7 +25,9 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -34,30 +36,43 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
-// newTestBlockChain creates a blockchain without validation.
-func newTestBlockChain(fake bool) *BlockChain {
-	db, _ := ethdb.NewMemDatabase()
-	gspec := &Genesis{
-		Config:     params.TestChainConfig,
-		Difficulty: big.NewInt(1),
+// So we can deterministically seed different blockchains
+var (
+	canonicalSeed = 1
+	forkSeed      = 2
+)
+
+// newCanonical creates a chain database, and injects a deterministic canonical
+// chain. Depending on the full flag, if creates either a full block chain or a
+// header only chain.
+func newCanonical(engine consensus.Engine, n int, full bool) (ethdb.Database, *BlockChain, error) {
+	var (
+		db      = ethdb.NewMemDatabase()
+		genesis = new(Genesis).MustCommit(db)
+	)
+
+	// Initialize a fresh chain with only a genesis block
+	blockchain, _ := NewBlockChain(db, nil, params.AllEthashProtocolChanges, engine, vm.Config{})
+	// Create and inject the requested chain
+	if n == 0 {
+		return db, blockchain, nil
 	}
-	gspec.MustCommit(db)
-	engine := ethash.NewFullFaker()
-	if !fake {
-		engine = ethash.NewTester()
+	if full {
+		// Full block-chain requested
+		blocks := makeBlockChain(genesis, n, engine, db, canonicalSeed)
+		_, err := blockchain.InsertChain(blocks)
+		return db, blockchain, err
 	}
-	blockchain, err := NewBlockChain(db, gspec.Config, engine, vm.Config{})
-	if err != nil {
-		panic(err)
-	}
-	blockchain.SetValidator(bproc{})
-	return blockchain
+	// Header-only chain requested
+	headers := makeHeaderChain(genesis.Header(), n, engine, db, canonicalSeed)
+	_, err := blockchain.InsertHeaderChain(headers, 1)
+	return db, blockchain, err
 }
 
 // Test fork of length N starting from block i
 func testFork(t *testing.T, blockchain *BlockChain, i, n int, full bool, comparator func(td1, td2 *big.Int)) {
 	// Copy old chain up to #i into a new db
-	db, blockchain2, err := newCanonical(i, full)
+	db, blockchain2, err := newCanonical(ethash.NewFaker(), i, full)
 	if err != nil {
 		t.Fatal("could not make new canonical in testFork", err)
 	}
@@ -81,12 +96,12 @@ func testFork(t *testing.T, blockchain *BlockChain, i, n int, full bool, compara
 		headerChainB []*types.Header
 	)
 	if full {
-		blockChainB = makeBlockChain(blockchain2.CurrentBlock(), n, db, forkSeed)
+		blockChainB = makeBlockChain(blockchain2.CurrentBlock(), n, ethash.NewFaker(), db, forkSeed)
 		if _, err := blockchain2.InsertChain(blockChainB); err != nil {
 			t.Fatalf("failed to insert forking chain: %v", err)
 		}
 	} else {
-		headerChainB = makeHeaderChain(blockchain2.CurrentHeader(), n, db, forkSeed)
+		headerChainB = makeHeaderChain(blockchain2.CurrentHeader(), n, ethash.NewFaker(), db, forkSeed)
 		if _, err := blockchain2.InsertHeaderChain(headerChainB, 1); err != nil {
 			t.Fatalf("failed to insert forking chain: %v", err)
 		}
@@ -148,9 +163,9 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
 			return err
 		}
 		blockchain.mu.Lock()
-		WriteTd(blockchain.chainDb, block.Hash(), block.NumberU64(), new(big.Int).Add(block.Difficulty(), blockchain.GetTdByHash(block.ParentHash())))
-		WriteBlock(blockchain.chainDb, block)
-		statedb.CommitTo(blockchain.chainDb, false)
+		rawdb.WriteTd(blockchain.db, block.Hash(), block.NumberU64(), new(big.Int).Add(block.Difficulty(), blockchain.GetTdByHash(block.ParentHash())))
+		rawdb.WriteBlock(blockchain.db, block)
+		statedb.Commit(false)
 		blockchain.mu.Unlock()
 	}
 	return nil
@@ -166,8 +181,8 @@ func testHeaderChainImport(chain []*types.Header, blockchain *BlockChain) error
 		}
 		// Manually insert the header into the database, but don't reorganise (allows subsequent testing)
 		blockchain.mu.Lock()
-		WriteTd(blockchain.chainDb, header.Hash(), header.Number.Uint64(), new(big.Int).Add(header.Difficulty, blockchain.GetTdByHash(header.ParentHash)))
-		WriteHeader(blockchain.chainDb, header)
+		rawdb.WriteTd(blockchain.db, header.Hash(), header.Number.Uint64(), new(big.Int).Add(header.Difficulty, blockchain.GetTdByHash(header.ParentHash)))
+		rawdb.WriteHeader(blockchain.db, header)
 		blockchain.mu.Unlock()
 	}
 	return nil
@@ -183,13 +198,18 @@ func insertChain(done chan bool, blockchain *BlockChain, chain types.Blocks, t *
 }
 
 func TestLastBlock(t *testing.T) {
-	bchain := newTestBlockChain(false)
-	defer bchain.Stop()
+	_, blockchain, err := newCanonical(ethash.NewFaker(), 0, true)
+	if err != nil {
+		t.Fatalf("failed to create pristine chain: %v", err)
+	}
+	defer blockchain.Stop()
 
-	block := makeBlockChain(bchain.CurrentBlock(), 1, bchain.chainDb, 0)[0]
-	bchain.insert(block)
-	if block.Hash() != GetHeadBlockHash(bchain.chainDb) {
-		t.Errorf("Write/Get HeadBlockHash failed")
+	blocks := makeBlockChain(blockchain.CurrentBlock(), 1, ethash.NewFullFaker(), blockchain.db, 0)
+	if _, err := blockchain.InsertChain(blocks); err != nil {
+		t.Fatalf("Failed to insert block: %v", err)
+	}
+	if blocks[len(blocks)-1].Hash() != rawdb.ReadHeadBlockHash(blockchain.db) {
+		t.Fatalf("Write/Get HeadBlockHash failed")
 	}
 }
 
@@ -202,7 +222,7 @@ func testExtendCanonical(t *testing.T, full bool) {
 	length := 5
 
 	// Make first chain starting from genesis
-	_, processor, err := newCanonical(length, full)
+	_, processor, err := newCanonical(ethash.NewFaker(), length, full)
 	if err != nil {
 		t.Fatalf("failed to make new canonical chain: %v", err)
 	}
@@ -230,7 +250,7 @@ func testShorterFork(t *testing.T, full bool) {
 	length := 10
 
 	// Make first chain starting from genesis
-	_, processor, err := newCanonical(length, full)
+	_, processor, err := newCanonical(ethash.NewFaker(), length, full)
 	if err != nil {
 		t.Fatalf("failed to make new canonical chain: %v", err)
 	}
@@ -260,7 +280,7 @@ func testLongerFork(t *testing.T, full bool) {
 	length := 10
 
 	// Make first chain starting from genesis
-	_, processor, err := newCanonical(length, full)
+	_, processor, err := newCanonical(ethash.NewFaker(), length, full)
 	if err != nil {
 		t.Fatalf("failed to make new canonical chain: %v", err)
 	}
@@ -290,7 +310,7 @@ func testEqualFork(t *testing.T, full bool) {
 	length := 10
 
 	// Make first chain starting from genesis
-	_, processor, err := newCanonical(length, full)
+	_, processor, err := newCanonical(ethash.NewFaker(), length, full)
 	if err != nil {
 		t.Fatalf("failed to make new canonical chain: %v", err)
 	}
@@ -317,7 +337,7 @@ func TestBrokenBlockChain(t *testing.T)  { testBrokenChain(t, true) }
 
 func testBrokenChain(t *testing.T, full bool) {
 	// Make chain starting from genesis
-	db, blockchain, err := newCanonical(10, full)
+	db, blockchain, err := newCanonical(ethash.NewFaker(), 10, full)
 	if err != nil {
 		t.Fatalf("failed to make new canonical chain: %v", err)
 	}
@@ -325,67 +345,25 @@ func testBrokenChain(t *testing.T, full bool) {
 
 	// Create a forked chain, and try to insert with a missing link
 	if full {
-		chain := makeBlockChain(blockchain.CurrentBlock(), 5, db, forkSeed)[1:]
+		chain := makeBlockChain(blockchain.CurrentBlock(), 5, ethash.NewFaker(), db, forkSeed)[1:]
 		if err := testBlockChainImport(chain, blockchain); err == nil {
 			t.Errorf("broken block chain not reported")
 		}
 	} else {
-		chain := makeHeaderChain(blockchain.CurrentHeader(), 5, db, forkSeed)[1:]
+		chain := makeHeaderChain(blockchain.CurrentHeader(), 5, ethash.NewFaker(), db, forkSeed)[1:]
 		if err := testHeaderChainImport(chain, blockchain); err == nil {
 			t.Errorf("broken header chain not reported")
 		}
 	}
 }
 
-type bproc struct{}
-
-func (bproc) ValidateBody(*types.Block) error { return nil }
-func (bproc) ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error {
-	return nil
-}
-func (bproc) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) {
-	return nil, nil, new(big.Int), nil
-}
-
-func makeHeaderChainWithDiff(genesis *types.Block, d []int, seed byte) []*types.Header {
-	blocks := makeBlockChainWithDiff(genesis, d, seed)
-	headers := make([]*types.Header, len(blocks))
-	for i, block := range blocks {
-		headers[i] = block.Header()
-	}
-	return headers
-}
-
-func makeBlockChainWithDiff(genesis *types.Block, d []int, seed byte) []*types.Block {
-	var chain []*types.Block
-	for i, difficulty := range d {
-		header := &types.Header{
-			Coinbase:    common.Address{seed},
-			Number:      big.NewInt(int64(i + 1)),
-			Difficulty:  big.NewInt(int64(difficulty)),
-			UncleHash:   types.EmptyUncleHash,
-			TxHash:      types.EmptyRootHash,
-			ReceiptHash: types.EmptyRootHash,
-			Time:        big.NewInt(int64(i) + 1),
-		}
-		if i == 0 {
-			header.ParentHash = genesis.Hash()
-		} else {
-			header.ParentHash = chain[i-1].Hash()
-		}
-		block := types.NewBlockWithHeader(header)
-		chain = append(chain, block)
-	}
-	return chain
-}
-
 // Tests that reorganising a long difficult chain after a short easy one
 // overwrites the canonical numbers and links in the database.
 func TestReorgLongHeaders(t *testing.T) { testReorgLong(t, false) }
 func TestReorgLongBlocks(t *testing.T)  { testReorgLong(t, true) }
 
 func testReorgLong(t *testing.T, full bool) {
-	testReorg(t, []int{1, 2, 4}, []int{1, 2, 3, 4}, 10, full)
+	testReorg(t, []int64{0, 0, -9}, []int64{0, 0, 0, -9}, 393280, full)
 }
 
 // Tests that reorganising a short difficult chain after a long easy one
@@ -394,45 +372,82 @@ func TestReorgShortHeaders(t *testing.T) { testReorgShort(t, false) }
 func TestReorgShortBlocks(t *testing.T)  { testReorgShort(t, true) }
 
 func testReorgShort(t *testing.T, full bool) {
-	testReorg(t, []int{1, 2, 3, 4}, []int{1, 10}, 11, full)
+	// Create a long easy chain vs. a short heavy one. Due to difficulty adjustment
+	// we need a fairly long chain of blocks with different difficulties for a short
+	// one to become heavyer than a long one. The 96 is an empirical value.
+	easy := make([]int64, 96)
+	for i := 0; i < len(easy); i++ {
+		easy[i] = 60
+	}
+	diff := make([]int64, len(easy)-1)
+	for i := 0; i < len(diff); i++ {
+		diff[i] = -9
+	}
+	testReorg(t, easy, diff, 12615120, full)
 }
 
-func testReorg(t *testing.T, first, second []int, td int64, full bool) {
-	bc := newTestBlockChain(true)
-	defer bc.Stop()
+func testReorg(t *testing.T, first, second []int64, td int64, full bool) {
+	// Create a pristine chain and database
+	db, blockchain, err := newCanonical(ethash.NewFaker(), 0, full)
+	if err != nil {
+		t.Fatalf("failed to create pristine chain: %v", err)
+	}
+	defer blockchain.Stop()
 
 	// Insert an easy and a difficult chain afterwards
+	easyBlocks, _ := GenerateChain(params.TestChainConfig, blockchain.CurrentBlock(), ethash.NewFaker(), db, len(first), func(i int, b *BlockGen) {
+		b.OffsetTime(first[i])
+	})
+	diffBlocks, _ := GenerateChain(params.TestChainConfig, blockchain.CurrentBlock(), ethash.NewFaker(), db, len(second), func(i int, b *BlockGen) {
+		b.OffsetTime(second[i])
+	})
 	if full {
-		bc.InsertChain(makeBlockChainWithDiff(bc.genesisBlock, first, 11))
-		bc.InsertChain(makeBlockChainWithDiff(bc.genesisBlock, second, 22))
+		if _, err := blockchain.InsertChain(easyBlocks); err != nil {
+			t.Fatalf("failed to insert easy chain: %v", err)
+		}
+		if _, err := blockchain.InsertChain(diffBlocks); err != nil {
+			t.Fatalf("failed to insert difficult chain: %v", err)
+		}
 	} else {
-		bc.InsertHeaderChain(makeHeaderChainWithDiff(bc.genesisBlock, first, 11), 1)
-		bc.InsertHeaderChain(makeHeaderChainWithDiff(bc.genesisBlock, second, 22), 1)
+		easyHeaders := make([]*types.Header, len(easyBlocks))
+		for i, block := range easyBlocks {
+			easyHeaders[i] = block.Header()
+		}
+		diffHeaders := make([]*types.Header, len(diffBlocks))
+		for i, block := range diffBlocks {
+			diffHeaders[i] = block.Header()
+		}
+		if _, err := blockchain.InsertHeaderChain(easyHeaders, 1); err != nil {
+			t.Fatalf("failed to insert easy chain: %v", err)
+		}
+		if _, err := blockchain.InsertHeaderChain(diffHeaders, 1); err != nil {
+			t.Fatalf("failed to insert difficult chain: %v", err)
+		}
 	}
 	// Check that the chain is valid number and link wise
 	if full {
-		prev := bc.CurrentBlock()
-		for block := bc.GetBlockByNumber(bc.CurrentBlock().NumberU64() - 1); block.NumberU64() != 0; prev, block = block, bc.GetBlockByNumber(block.NumberU64()-1) {
+		prev := blockchain.CurrentBlock()
+		for block := blockchain.GetBlockByNumber(blockchain.CurrentBlock().NumberU64() - 1); block.NumberU64() != 0; prev, block = block, blockchain.GetBlockByNumber(block.NumberU64()-1) {
 			if prev.ParentHash() != block.Hash() {
 				t.Errorf("parent block hash mismatch: have %x, want %x", prev.ParentHash(), block.Hash())
 			}
 		}
 	} else {
-		prev := bc.CurrentHeader()
-		for header := bc.GetHeaderByNumber(bc.CurrentHeader().Number.Uint64() - 1); header.Number.Uint64() != 0; prev, header = header, bc.GetHeaderByNumber(header.Number.Uint64()-1) {
+		prev := blockchain.CurrentHeader()
+		for header := blockchain.GetHeaderByNumber(blockchain.CurrentHeader().Number.Uint64() - 1); header.Number.Uint64() != 0; prev, header = header, blockchain.GetHeaderByNumber(header.Number.Uint64()-1) {
 			if prev.ParentHash != header.Hash() {
 				t.Errorf("parent header hash mismatch: have %x, want %x", prev.ParentHash, header.Hash())
 			}
 		}
 	}
 	// Make sure the chain total difficulty is the correct one
-	want := new(big.Int).Add(bc.genesisBlock.Difficulty(), big.NewInt(td))
+	want := new(big.Int).Add(blockchain.genesisBlock.Difficulty(), big.NewInt(td))
 	if full {
-		if have := bc.GetTdByHash(bc.CurrentBlock().Hash()); have.Cmp(want) != 0 {
+		if have := blockchain.GetTdByHash(blockchain.CurrentBlock().Hash()); have.Cmp(want) != 0 {
 			t.Errorf("total difficulty mismatch: have %v, want %v", have, want)
 		}
 	} else {
-		if have := bc.GetTdByHash(bc.CurrentHeader().Hash()); have.Cmp(want) != 0 {
+		if have := blockchain.GetTdByHash(blockchain.CurrentHeader().Hash()); have.Cmp(want) != 0 {
 			t.Errorf("total difficulty mismatch: have %v, want %v", have, want)
 		}
 	}
@@ -443,19 +458,28 @@ func TestBadHeaderHashes(t *testing.T) { testBadHashes(t, false) }
 func TestBadBlockHashes(t *testing.T)  { testBadHashes(t, true) }
 
 func testBadHashes(t *testing.T, full bool) {
-	bc := newTestBlockChain(true)
-	defer bc.Stop()
+	// Create a pristine chain and database
+	db, blockchain, err := newCanonical(ethash.NewFaker(), 0, full)
+	if err != nil {
+		t.Fatalf("failed to create pristine chain: %v", err)
+	}
+	defer blockchain.Stop()
 
 	// Create a chain, ban a hash and try to import
-	var err error
 	if full {
-		blocks := makeBlockChainWithDiff(bc.genesisBlock, []int{1, 2, 4}, 10)
+		blocks := makeBlockChain(blockchain.CurrentBlock(), 3, ethash.NewFaker(), db, 10)
+
 		BadHashes[blocks[2].Header().Hash()] = true
-		_, err = bc.InsertChain(blocks)
+		defer func() { delete(BadHashes, blocks[2].Header().Hash()) }()
+
+		_, err = blockchain.InsertChain(blocks)
 	} else {
-		headers := makeHeaderChainWithDiff(bc.genesisBlock, []int{1, 2, 4}, 10)
+		headers := makeHeaderChain(blockchain.CurrentHeader(), 3, ethash.NewFaker(), db, 10)
+
 		BadHashes[headers[2].Hash()] = true
-		_, err = bc.InsertHeaderChain(headers, 1)
+		defer func() { delete(BadHashes, headers[2].Hash()) }()
+
+		_, err = blockchain.InsertHeaderChain(headers, 1)
 	}
 	if err != ErrBlacklistedHash {
 		t.Errorf("error mismatch: have: %v, want: %v", err, ErrBlacklistedHash)
@@ -468,52 +492,54 @@ func TestReorgBadHeaderHashes(t *testing.T) { testReorgBadHashes(t, false) }
 func TestReorgBadBlockHashes(t *testing.T)  { testReorgBadHashes(t, true) }
 
 func testReorgBadHashes(t *testing.T, full bool) {
-	bc := newTestBlockChain(true)
-	defer bc.Stop()
-
+	// Create a pristine chain and database
+	db, blockchain, err := newCanonical(ethash.NewFaker(), 0, full)
+	if err != nil {
+		t.Fatalf("failed to create pristine chain: %v", err)
+	}
 	// Create a chain, import and ban afterwards
-	headers := makeHeaderChainWithDiff(bc.genesisBlock, []int{1, 2, 3, 4}, 10)
-	blocks := makeBlockChainWithDiff(bc.genesisBlock, []int{1, 2, 3, 4}, 10)
+	headers := makeHeaderChain(blockchain.CurrentHeader(), 4, ethash.NewFaker(), db, 10)
+	blocks := makeBlockChain(blockchain.CurrentBlock(), 4, ethash.NewFaker(), db, 10)
 
 	if full {
-		if _, err := bc.InsertChain(blocks); err != nil {
-			t.Fatalf("failed to import blocks: %v", err)
+		if _, err = blockchain.InsertChain(blocks); err != nil {
+			t.Errorf("failed to import blocks: %v", err)
 		}
-		if bc.CurrentBlock().Hash() != blocks[3].Hash() {
-			t.Errorf("last block hash mismatch: have: %x, want %x", bc.CurrentBlock().Hash(), blocks[3].Header().Hash())
+		if blockchain.CurrentBlock().Hash() != blocks[3].Hash() {
+			t.Errorf("last block hash mismatch: have: %x, want %x", blockchain.CurrentBlock().Hash(), blocks[3].Header().Hash())
 		}
 		BadHashes[blocks[3].Header().Hash()] = true
 		defer func() { delete(BadHashes, blocks[3].Header().Hash()) }()
 	} else {
-		if _, err := bc.InsertHeaderChain(headers, 1); err != nil {
-			t.Fatalf("failed to import headers: %v", err)
+		if _, err = blockchain.InsertHeaderChain(headers, 1); err != nil {
+			t.Errorf("failed to import headers: %v", err)
 		}
-		if bc.CurrentHeader().Hash() != headers[3].Hash() {
-			t.Errorf("last header hash mismatch: have: %x, want %x", bc.CurrentHeader().Hash(), headers[3].Hash())
+		if blockchain.CurrentHeader().Hash() != headers[3].Hash() {
+			t.Errorf("last header hash mismatch: have: %x, want %x", blockchain.CurrentHeader().Hash(), headers[3].Hash())
 		}
 		BadHashes[headers[3].Hash()] = true
 		defer func() { delete(BadHashes, headers[3].Hash()) }()
 	}
+	blockchain.Stop()
 
 	// Create a new BlockChain and check that it rolled back the state.
-	ncm, err := NewBlockChain(bc.chainDb, bc.config, ethash.NewFaker(), vm.Config{})
+	ncm, err := NewBlockChain(blockchain.db, nil, blockchain.chainConfig, ethash.NewFaker(), vm.Config{})
 	if err != nil {
 		t.Fatalf("failed to create new chain manager: %v", err)
 	}
-	defer ncm.Stop()
-
 	if full {
 		if ncm.CurrentBlock().Hash() != blocks[2].Header().Hash() {
 			t.Errorf("last block hash mismatch: have: %x, want %x", ncm.CurrentBlock().Hash(), blocks[2].Header().Hash())
 		}
-		if blocks[2].Header().GasLimit.Cmp(ncm.GasLimit()) != 0 {
-			t.Errorf("last  block gasLimit mismatch: have: %x, want %x", ncm.GasLimit(), blocks[2].Header().GasLimit)
+		if blocks[2].Header().GasLimit != ncm.GasLimit() {
+			t.Errorf("last  block gasLimit mismatch: have: %d, want %d", ncm.GasLimit(), blocks[2].Header().GasLimit)
 		}
 	} else {
 		if ncm.CurrentHeader().Hash() != headers[2].Hash() {
 			t.Errorf("last header hash mismatch: have: %x, want %x", ncm.CurrentHeader().Hash(), headers[2].Hash())
 		}
 	}
+	ncm.Stop()
 }
 
 // Tests chain insertions in the face of one entity containing an invalid nonce.
@@ -523,7 +549,7 @@ func TestBlocksInsertNonceError(t *testing.T)  { testInsertNonceError(t, true) }
 func testInsertNonceError(t *testing.T, full bool) {
 	for i := 1; i < 25 && !t.Failed(); i++ {
 		// Create a pristine chain and database
-		db, blockchain, err := newCanonical(0, full)
+		db, blockchain, err := newCanonical(ethash.NewFaker(), 0, full)
 		if err != nil {
 			t.Fatalf("failed to create pristine chain: %v", err)
 		}
@@ -536,7 +562,7 @@ func testInsertNonceError(t *testing.T, full bool) {
 			failNum uint64
 		)
 		if full {
-			blocks := makeBlockChain(blockchain.CurrentBlock(), i, db, 0)
+			blocks := makeBlockChain(blockchain.CurrentBlock(), i, ethash.NewFaker(), db, 0)
 
 			failAt = rand.Int() % len(blocks)
 			failNum = blocks[failAt].NumberU64()
@@ -544,7 +570,7 @@ func testInsertNonceError(t *testing.T, full bool) {
 			blockchain.engine = ethash.NewFakeFailer(failNum)
 			failRes, err = blockchain.InsertChain(blocks)
 		} else {
-			headers := makeHeaderChain(blockchain.CurrentHeader(), i, db, 0)
+			headers := makeHeaderChain(blockchain.CurrentHeader(), i, ethash.NewFaker(), db, 0)
 
 			failAt = rand.Int() % len(headers)
 			failNum = headers[failAt].Number.Uint64()
@@ -577,24 +603,24 @@ func testInsertNonceError(t *testing.T, full bool) {
 func TestFastVsFullChains(t *testing.T) {
 	// Configure and generate a sample block chain
 	var (
-		gendb, _ = ethdb.NewMemDatabase()
-		key, _   = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address  = crypto.PubkeyToAddress(key.PublicKey)
-		funds    = big.NewInt(1000000000)
-		gspec    = &Genesis{
+		gendb   = ethdb.NewMemDatabase()
+		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		address = crypto.PubkeyToAddress(key.PublicKey)
+		funds   = big.NewInt(1000000000)
+		gspec   = &Genesis{
 			Config: params.TestChainConfig,
 			Alloc:  GenesisAlloc{address: {Balance: funds}},
 		}
 		genesis = gspec.MustCommit(gendb)
-		signer  = types.NewEIP155Signer(gspec.Config.ChainId)
+		signer  = types.NewEIP155Signer(gspec.Config.ChainID)
 	)
-	blocks, receipts := GenerateChain(gspec.Config, genesis, gendb, 1024, func(i int, block *BlockGen) {
+	blocks, receipts := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, 1024, func(i int, block *BlockGen) {
 		block.SetCoinbase(common.Address{0x00})
 
 		// If the block number is multiple of 3, send a few bonus transactions to the miner
 		if i%3 == 2 {
 			for j := 0; j < i%4+1; j++ {
-				tx, err := types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), bigTxGas, nil, nil), signer, key)
+				tx, err := types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, nil, nil), signer, key)
 				if err != nil {
 					panic(err)
 				}
@@ -607,18 +633,18 @@ func TestFastVsFullChains(t *testing.T) {
 		}
 	})
 	// Import the chain as an archive node for the comparison baseline
-	archiveDb, _ := ethdb.NewMemDatabase()
+	archiveDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(archiveDb)
-	archive, _ := NewBlockChain(archiveDb, gspec.Config, ethash.NewFaker(), vm.Config{})
+	archive, _ := NewBlockChain(archiveDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer archive.Stop()
 
 	if n, err := archive.InsertChain(blocks); err != nil {
 		t.Fatalf("failed to process block %d: %v", n, err)
 	}
 	// Fast import the chain as a non-archive node to test
-	fastDb, _ := ethdb.NewMemDatabase()
+	fastDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(fastDb)
-	fast, _ := NewBlockChain(fastDb, gspec.Config, ethash.NewFaker(), vm.Config{})
+	fast, _ := NewBlockChain(fastDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer fast.Stop()
 
 	headers := make([]*types.Header, len(blocks))
@@ -648,13 +674,13 @@ func TestFastVsFullChains(t *testing.T) {
 		} else if types.CalcUncleHash(fblock.Uncles()) != types.CalcUncleHash(ablock.Uncles()) {
 			t.Errorf("block #%d [%x]: uncles mismatch: have %v, want %v", num, hash, fblock.Uncles(), ablock.Uncles())
 		}
-		if freceipts, areceipts := GetBlockReceipts(fastDb, hash, GetBlockNumber(fastDb, hash)), GetBlockReceipts(archiveDb, hash, GetBlockNumber(archiveDb, hash)); types.DeriveSha(freceipts) != types.DeriveSha(areceipts) {
+		if freceipts, areceipts := rawdb.ReadReceipts(fastDb, hash, *rawdb.ReadHeaderNumber(fastDb, hash)), rawdb.ReadReceipts(archiveDb, hash, *rawdb.ReadHeaderNumber(archiveDb, hash)); types.DeriveSha(freceipts) != types.DeriveSha(areceipts) {
 			t.Errorf("block #%d [%x]: receipts mismatch: have %v, want %v", num, hash, freceipts, areceipts)
 		}
 	}
 	// Check that the canonical chains are the same between the databases
 	for i := 0; i < len(blocks)+1; i++ {
-		if fhash, ahash := GetCanonicalHash(fastDb, uint64(i)), GetCanonicalHash(archiveDb, uint64(i)); fhash != ahash {
+		if fhash, ahash := rawdb.ReadCanonicalHash(fastDb, uint64(i)), rawdb.ReadCanonicalHash(archiveDb, uint64(i)); fhash != ahash {
 			t.Errorf("block #%d: canonical hash mismatch: have %v, want %v", i, fhash, ahash)
 		}
 	}
@@ -665,15 +691,15 @@ func TestFastVsFullChains(t *testing.T) {
 func TestLightVsFastVsFullChainHeads(t *testing.T) {
 	// Configure and generate a sample block chain
 	var (
-		gendb, _ = ethdb.NewMemDatabase()
-		key, _   = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-		address  = crypto.PubkeyToAddress(key.PublicKey)
-		funds    = big.NewInt(1000000000)
-		gspec    = &Genesis{Config: params.TestChainConfig, Alloc: GenesisAlloc{address: {Balance: funds}}}
-		genesis  = gspec.MustCommit(gendb)
+		gendb   = ethdb.NewMemDatabase()
+		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		address = crypto.PubkeyToAddress(key.PublicKey)
+		funds   = big.NewInt(1000000000)
+		gspec   = &Genesis{Config: params.TestChainConfig, Alloc: GenesisAlloc{address: {Balance: funds}}}
+		genesis = gspec.MustCommit(gendb)
 	)
 	height := uint64(1024)
-	blocks, receipts := GenerateChain(gspec.Config, genesis, gendb, int(height), nil)
+	blocks, receipts := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, int(height), nil)
 
 	// Configure a subchain to roll back
 	remove := []common.Hash{}
@@ -693,10 +719,10 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 		}
 	}
 	// Import the chain as an archive node and ensure all pointers are updated
-	archiveDb, _ := ethdb.NewMemDatabase()
+	archiveDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(archiveDb)
 
-	archive, _ := NewBlockChain(archiveDb, gspec.Config, ethash.NewFaker(), vm.Config{})
+	archive, _ := NewBlockChain(archiveDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	if n, err := archive.InsertChain(blocks); err != nil {
 		t.Fatalf("failed to process block %d: %v", n, err)
 	}
@@ -707,9 +733,9 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 	assert(t, "archive", archive, height/2, height/2, height/2)
 
 	// Import the chain as a non-archive node and ensure all pointers are updated
-	fastDb, _ := ethdb.NewMemDatabase()
+	fastDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(fastDb)
-	fast, _ := NewBlockChain(fastDb, gspec.Config, ethash.NewFaker(), vm.Config{})
+	fast, _ := NewBlockChain(fastDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer fast.Stop()
 
 	headers := make([]*types.Header, len(blocks))
@@ -727,10 +753,10 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) {
 	assert(t, "fast", fast, height/2, height/2, 0)
 
 	// Import the chain as a light node and ensure all pointers are updated
-	lightDb, _ := ethdb.NewMemDatabase()
+	lightDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(lightDb)
 
-	light, _ := NewBlockChain(lightDb, gspec.Config, ethash.NewFaker(), vm.Config{})
+	light, _ := NewBlockChain(lightDb, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	if n, err := light.InsertHeaderChain(headers, 1); err != nil {
 		t.Fatalf("failed to insert header %d: %v", n, err)
 	}
@@ -750,7 +776,7 @@ func TestChainTxReorgs(t *testing.T) {
 		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
 		addr2   = crypto.PubkeyToAddress(key2.PublicKey)
 		addr3   = crypto.PubkeyToAddress(key3.PublicKey)
-		db, _   = ethdb.NewMemDatabase()
+		db      = ethdb.NewMemDatabase()
 		gspec   = &Genesis{
 			Config:   params.TestChainConfig,
 			GasLimit: 3141592,
@@ -761,14 +787,14 @@ func TestChainTxReorgs(t *testing.T) {
 			},
 		}
 		genesis = gspec.MustCommit(db)
-		signer  = types.NewEIP155Signer(gspec.Config.ChainId)
+		signer  = types.NewEIP155Signer(gspec.Config.ChainID)
 	)
 
 	// Create two transactions shared between the chains:
 	//  - postponed: transaction included at a later block in the forked chain
 	//  - swapped: transaction included at the same block number in the forked chain
-	postponed, _ := types.SignTx(types.NewTransaction(0, addr1, big.NewInt(1000), bigTxGas, nil, nil), signer, key1)
-	swapped, _ := types.SignTx(types.NewTransaction(1, addr1, big.NewInt(1000), bigTxGas, nil, nil), signer, key1)
+	postponed, _ := types.SignTx(types.NewTransaction(0, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
+	swapped, _ := types.SignTx(types.NewTransaction(1, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
 
 	// Create two transactions that will be dropped by the forked chain:
 	//  - pastDrop: transaction dropped retroactively from a past block
@@ -781,16 +807,16 @@ func TestChainTxReorgs(t *testing.T) {
 	//  - futureAdd: transaction added after the reorg has already finished
 	var pastAdd, freshAdd, futureAdd *types.Transaction
 
-	chain, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
-			pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key2)
+			pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
 
 			gen.AddTx(pastDrop)  // This transaction will be dropped in the fork from below the split point
 			gen.AddTx(postponed) // This transaction will be postponed till block #3 in the fork
 
 		case 2:
-			freshDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key2)
+			freshDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
 
 			gen.AddTx(freshDrop) // This transaction will be dropped in the fork from exactly at the split point
 			gen.AddTx(swapped)   // This transaction will be swapped out at the exact height
@@ -799,28 +825,28 @@ func TestChainTxReorgs(t *testing.T) {
 		}
 	})
 	// Import the chain. This runs all block validation rules.
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	if i, err := blockchain.InsertChain(chain); err != nil {
 		t.Fatalf("failed to insert original chain[%d]: %v", i, err)
 	}
 	defer blockchain.Stop()
 
 	// overwrite the old chain
-	chain, _ = GenerateChain(gspec.Config, genesis, db, 5, func(i int, gen *BlockGen) {
+	chain, _ = GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 5, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
-			pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3)
+			pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
 			gen.AddTx(pastAdd) // This transaction needs to be injected during reorg
 
 		case 2:
 			gen.AddTx(postponed) // This transaction was postponed from block #1 in the original chain
 			gen.AddTx(swapped)   // This transaction was swapped from the exact current spot in the original chain
 
-			freshAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3)
+			freshAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
 			gen.AddTx(freshAdd) // This transaction will be added exactly at reorg time
 
 		case 3:
-			futureAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3)
+			futureAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3)
 			gen.AddTx(futureAdd) // This transaction will be added after a full reorg
 		}
 	})
@@ -830,28 +856,28 @@ func TestChainTxReorgs(t *testing.T) {
 
 	// removed tx
 	for i, tx := range (types.Transactions{pastDrop, freshDrop}) {
-		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn != nil {
+		if txn, _, _, _ := rawdb.ReadTransaction(db, tx.Hash()); txn != nil {
 			t.Errorf("drop %d: tx %v found while shouldn't have been", i, txn)
 		}
-		if rcpt, _, _, _ := GetReceipt(db, tx.Hash()); rcpt != nil {
+		if rcpt, _, _, _ := rawdb.ReadReceipt(db, tx.Hash()); rcpt != nil {
 			t.Errorf("drop %d: receipt %v found while shouldn't have been", i, rcpt)
 		}
 	}
 	// added tx
 	for i, tx := range (types.Transactions{pastAdd, freshAdd, futureAdd}) {
-		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn == nil {
+		if txn, _, _, _ := rawdb.ReadTransaction(db, tx.Hash()); txn == nil {
 			t.Errorf("add %d: expected tx to be found", i)
 		}
-		if rcpt, _, _, _ := GetReceipt(db, tx.Hash()); rcpt == nil {
+		if rcpt, _, _, _ := rawdb.ReadReceipt(db, tx.Hash()); rcpt == nil {
 			t.Errorf("add %d: expected receipt to be found", i)
 		}
 	}
 	// shared tx
 	for i, tx := range (types.Transactions{postponed, swapped}) {
-		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn == nil {
+		if txn, _, _, _ := rawdb.ReadTransaction(db, tx.Hash()); txn == nil {
 			t.Errorf("share %d: expected tx to be found", i)
 		}
-		if rcpt, _, _, _ := GetReceipt(db, tx.Hash()); rcpt == nil {
+		if rcpt, _, _, _ := rawdb.ReadReceipt(db, tx.Hash()); rcpt == nil {
 			t.Errorf("share %d: expected receipt to be found", i)
 		}
 	}
@@ -862,22 +888,22 @@ func TestLogReorgs(t *testing.T) {
 	var (
 		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
-		db, _   = ethdb.NewMemDatabase()
+		db      = ethdb.NewMemDatabase()
 		// this code generates a log
 		code    = common.Hex2Bytes("60606040525b7f24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b60405180905060405180910390a15b600a8060416000396000f360606040526008565b00")
 		gspec   = &Genesis{Config: params.TestChainConfig, Alloc: GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}}}
 		genesis = gspec.MustCommit(db)
-		signer  = types.NewEIP155Signer(gspec.Config.ChainId)
+		signer  = types.NewEIP155Signer(gspec.Config.ChainID)
 	)
 
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer blockchain.Stop()
 
 	rmLogsCh := make(chan RemovedLogsEvent)
 	blockchain.SubscribeRemovedLogsEvent(rmLogsCh)
-	chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 2, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 2, func(i int, gen *BlockGen) {
 		if i == 1 {
-			tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), code), signer, key1)
+			tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), 1000000, new(big.Int), code), signer, key1)
 			if err != nil {
 				t.Fatalf("failed to create tx: %v", err)
 			}
@@ -888,7 +914,7 @@ func TestLogReorgs(t *testing.T) {
 		t.Fatalf("failed to insert chain: %v", err)
 	}
 
-	chain, _ = GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {})
+	chain, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) {})
 	if _, err := blockchain.InsertChain(chain); err != nil {
 		t.Fatalf("failed to insert forked chain: %v", err)
 	}
@@ -906,7 +932,7 @@ func TestLogReorgs(t *testing.T) {
 
 func TestReorgSideEvent(t *testing.T) {
 	var (
-		db, _   = ethdb.NewMemDatabase()
+		db      = ethdb.NewMemDatabase()
 		key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
 		gspec   = &Genesis{
@@ -914,19 +940,19 @@ func TestReorgSideEvent(t *testing.T) {
 			Alloc:  GenesisAlloc{addr1: {Balance: big.NewInt(10000000000000)}},
 		}
 		genesis = gspec.MustCommit(db)
-		signer  = types.NewEIP155Signer(gspec.Config.ChainId)
+		signer  = types.NewEIP155Signer(gspec.Config.ChainID)
 	)
 
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer blockchain.Stop()
 
-	chain, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, gen *BlockGen) {})
+	chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) {})
 	if _, err := blockchain.InsertChain(chain); err != nil {
 		t.Fatalf("failed to insert chain: %v", err)
 	}
 
-	replacementBlocks, _ := GenerateChain(gspec.Config, genesis, db, 4, func(i int, gen *BlockGen) {
-		tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), nil), signer, key1)
+	replacementBlocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 4, func(i int, gen *BlockGen) {
+		tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), 1000000, new(big.Int), nil), signer, key1)
 		if i == 2 {
 			gen.OffsetTime(-9)
 		}
@@ -989,10 +1015,13 @@ done:
 
 // Tests if the canonical block can be fetched from the database during chain insertion.
 func TestCanonicalBlockRetrieval(t *testing.T) {
-	bc := newTestBlockChain(true)
-	defer bc.Stop()
+	_, blockchain, err := newCanonical(ethash.NewFaker(), 0, true)
+	if err != nil {
+		t.Fatalf("failed to create pristine chain: %v", err)
+	}
+	defer blockchain.Stop()
 
-	chain, _ := GenerateChain(bc.config, bc.genesisBlock, bc.chainDb, 10, func(i int, gen *BlockGen) {})
+	chain, _ := GenerateChain(blockchain.chainConfig, blockchain.genesisBlock, ethash.NewFaker(), blockchain.db, 10, func(i int, gen *BlockGen) {})
 
 	var pend sync.WaitGroup
 	pend.Add(len(chain))
@@ -1003,14 +1032,14 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
 
 			// try to retrieve a block by its canonical hash and see if the block data can be retrieved.
 			for {
-				ch := GetCanonicalHash(bc.chainDb, block.NumberU64())
+				ch := rawdb.ReadCanonicalHash(blockchain.db, block.NumberU64())
 				if ch == (common.Hash{}) {
 					continue // busy wait for canonical hash to be written
 				}
 				if ch != block.Hash() {
 					t.Fatalf("unknown canonical hash, want %s, got %s", block.Hash().Hex(), ch.Hex())
 				}
-				fb := GetBlock(bc.chainDb, ch, block.NumberU64())
+				fb := rawdb.ReadBlock(blockchain.db, ch, block.NumberU64())
 				if fb == nil {
 					t.Fatalf("unable to retrieve block %d for canonical hash: %s", block.NumberU64(), ch.Hex())
 				}
@@ -1021,7 +1050,7 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
 			}
 		}(chain[i])
 
-		if _, err := bc.InsertChain(types.Blocks{chain[i]}); err != nil {
+		if _, err := blockchain.InsertChain(types.Blocks{chain[i]}); err != nil {
 			t.Fatalf("failed to insert block %d: %v", i, err)
 		}
 	}
@@ -1031,27 +1060,27 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
 func TestEIP155Transition(t *testing.T) {
 	// Configure and generate a sample block chain
 	var (
-		db, _      = ethdb.NewMemDatabase()
+		db         = ethdb.NewMemDatabase()
 		key, _     = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		address    = crypto.PubkeyToAddress(key.PublicKey)
 		funds      = big.NewInt(1000000000)
 		deleteAddr = common.Address{1}
 		gspec      = &Genesis{
-			Config: ¶ms.ChainConfig{ChainId: big.NewInt(1), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)},
+			Config: ¶ms.ChainConfig{ChainID: big.NewInt(1), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)},
 			Alloc:  GenesisAlloc{address: {Balance: funds}, deleteAddr: {Balance: new(big.Int)}},
 		}
 		genesis = gspec.MustCommit(db)
 	)
 
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer blockchain.Stop()
 
-	blocks, _ := GenerateChain(gspec.Config, genesis, db, 4, func(i int, block *BlockGen) {
+	blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 4, func(i int, block *BlockGen) {
 		var (
 			tx      *types.Transaction
 			err     error
 			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), 21000, new(big.Int), nil), signer, key)
 			}
 		)
 		switch i {
@@ -1068,7 +1097,7 @@ func TestEIP155Transition(t *testing.T) {
 			}
 			block.AddTx(tx)
 
-			tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainId))
+			tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainID))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1080,7 +1109,7 @@ func TestEIP155Transition(t *testing.T) {
 			}
 			block.AddTx(tx)
 
-			tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainId))
+			tx, err = basicTx(types.NewEIP155Signer(gspec.Config.ChainID))
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1108,13 +1137,13 @@ func TestEIP155Transition(t *testing.T) {
 	}
 
 	// generate an invalid chain id transaction
-	config := ¶ms.ChainConfig{ChainId: big.NewInt(2), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)}
-	blocks, _ = GenerateChain(config, blocks[len(blocks)-1], db, 4, func(i int, block *BlockGen) {
+	config := ¶ms.ChainConfig{ChainID: big.NewInt(2), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)}
+	blocks, _ = GenerateChain(config, blocks[len(blocks)-1], ethash.NewFaker(), db, 4, func(i int, block *BlockGen) {
 		var (
 			tx      *types.Transaction
 			err     error
 			basicTx = func(signer types.Signer) (*types.Transaction, error) {
-				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+				return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), 21000, new(big.Int), nil), signer, key)
 			}
 		)
 		switch i {
@@ -1135,14 +1164,14 @@ func TestEIP155Transition(t *testing.T) {
 func TestEIP161AccountRemoval(t *testing.T) {
 	// Configure and generate a sample block chain
 	var (
-		db, _   = ethdb.NewMemDatabase()
+		db      = ethdb.NewMemDatabase()
 		key, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
 		address = crypto.PubkeyToAddress(key.PublicKey)
 		funds   = big.NewInt(1000000000)
 		theAddr = common.Address{1}
 		gspec   = &Genesis{
 			Config: ¶ms.ChainConfig{
-				ChainId:        big.NewInt(1),
+				ChainID:        big.NewInt(1),
 				HomesteadBlock: new(big.Int),
 				EIP155Block:    new(big.Int),
 				EIP158Block:    big.NewInt(2),
@@ -1151,22 +1180,22 @@ func TestEIP161AccountRemoval(t *testing.T) {
 		}
 		genesis = gspec.MustCommit(db)
 	)
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer blockchain.Stop()
 
-	blocks, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, block *BlockGen) {
+	blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, block *BlockGen) {
 		var (
 			tx     *types.Transaction
 			err    error
-			signer = types.NewEIP155Signer(gspec.Config.ChainId)
+			signer = types.NewEIP155Signer(gspec.Config.ChainID)
 		)
 		switch i {
 		case 0:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key)
 		case 1:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key)
 		case 2:
-			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key)
+			tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key)
 		}
 		if err != nil {
 			t.Fatal(err)
@@ -1197,3 +1226,261 @@ func TestEIP161AccountRemoval(t *testing.T) {
 		t.Error("account should not exist")
 	}
 }
+
+// This is a regression test (i.e. as weird as it is, don't delete it ever), which
+// tests that under weird reorg conditions the blockchain and its internal header-
+// chain return the same latest block/header.
+//
+// https://github.com/ethereum/go-ethereum/pull/15941
+func TestBlockchainHeaderchainReorgConsistency(t *testing.T) {
+	// Generate a canonical chain to act as the main dataset
+	engine := ethash.NewFaker()
+
+	db := ethdb.NewMemDatabase()
+	genesis := new(Genesis).MustCommit(db)
+	blocks, _ := GenerateChain(params.TestChainConfig, genesis, engine, db, 64, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) })
+
+	// Generate a bunch of fork blocks, each side forking from the canonical chain
+	forks := make([]*types.Block, len(blocks))
+	for i := 0; i < len(forks); i++ {
+		parent := genesis
+		if i > 0 {
+			parent = blocks[i-1]
+		}
+		fork, _ := GenerateChain(params.TestChainConfig, parent, engine, db, 1, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{2}) })
+		forks[i] = fork[0]
+	}
+	// Import the canonical and fork chain side by side, verifying the current block
+	// and current header consistency
+	diskdb := ethdb.NewMemDatabase()
+	new(Genesis).MustCommit(diskdb)
+
+	chain, err := NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{})
+	if err != nil {
+		t.Fatalf("failed to create tester chain: %v", err)
+	}
+	for i := 0; i < len(blocks); i++ {
+		if _, err := chain.InsertChain(blocks[i : i+1]); err != nil {
+			t.Fatalf("block %d: failed to insert into chain: %v", i, err)
+		}
+		if chain.CurrentBlock().Hash() != chain.CurrentHeader().Hash() {
+			t.Errorf("block %d: current block/header mismatch: block #%d [%x…], header #%d [%x…]", i, chain.CurrentBlock().Number(), chain.CurrentBlock().Hash().Bytes()[:4], chain.CurrentHeader().Number, chain.CurrentHeader().Hash().Bytes()[:4])
+		}
+		if _, err := chain.InsertChain(forks[i : i+1]); err != nil {
+			t.Fatalf(" fork %d: failed to insert into chain: %v", i, err)
+		}
+		if chain.CurrentBlock().Hash() != chain.CurrentHeader().Hash() {
+			t.Errorf(" fork %d: current block/header mismatch: block #%d [%x…], header #%d [%x…]", i, chain.CurrentBlock().Number(), chain.CurrentBlock().Hash().Bytes()[:4], chain.CurrentHeader().Number, chain.CurrentHeader().Hash().Bytes()[:4])
+		}
+	}
+}
+
+// Tests that importing small side forks doesn't leave junk in the trie database
+// cache (which would eventually cause memory issues).
+func TestTrieForkGC(t *testing.T) {
+	// Generate a canonical chain to act as the main dataset
+	engine := ethash.NewFaker()
+
+	db := ethdb.NewMemDatabase()
+	genesis := new(Genesis).MustCommit(db)
+	blocks, _ := GenerateChain(params.TestChainConfig, genesis, engine, db, 2*triesInMemory, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) })
+
+	// Generate a bunch of fork blocks, each side forking from the canonical chain
+	forks := make([]*types.Block, len(blocks))
+	for i := 0; i < len(forks); i++ {
+		parent := genesis
+		if i > 0 {
+			parent = blocks[i-1]
+		}
+		fork, _ := GenerateChain(params.TestChainConfig, parent, engine, db, 1, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{2}) })
+		forks[i] = fork[0]
+	}
+	// Import the canonical and fork chain side by side, forcing the trie cache to cache both
+	diskdb := ethdb.NewMemDatabase()
+	new(Genesis).MustCommit(diskdb)
+
+	chain, err := NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{})
+	if err != nil {
+		t.Fatalf("failed to create tester chain: %v", err)
+	}
+	for i := 0; i < len(blocks); i++ {
+		if _, err := chain.InsertChain(blocks[i : i+1]); err != nil {
+			t.Fatalf("block %d: failed to insert into chain: %v", i, err)
+		}
+		if _, err := chain.InsertChain(forks[i : i+1]); err != nil {
+			t.Fatalf("fork %d: failed to insert into chain: %v", i, err)
+		}
+	}
+	// Dereference all the recent tries and ensure no past trie is left in
+	for i := 0; i < triesInMemory; i++ {
+		chain.stateCache.TrieDB().Dereference(blocks[len(blocks)-1-i].Root(), common.Hash{})
+		chain.stateCache.TrieDB().Dereference(forks[len(blocks)-1-i].Root(), common.Hash{})
+	}
+	if len(chain.stateCache.TrieDB().Nodes()) > 0 {
+		t.Fatalf("stale tries still alive after garbase collection")
+	}
+}
+
+// Tests that doing large reorgs works even if the state associated with the
+// forking point is not available any more.
+func TestLargeReorgTrieGC(t *testing.T) {
+	// Generate the original common chain segment and the two competing forks
+	engine := ethash.NewFaker()
+
+	db := ethdb.NewMemDatabase()
+	genesis := new(Genesis).MustCommit(db)
+
+	shared, _ := GenerateChain(params.TestChainConfig, genesis, engine, db, 64, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{1}) })
+	original, _ := GenerateChain(params.TestChainConfig, shared[len(shared)-1], engine, db, 2*triesInMemory, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{2}) })
+	competitor, _ := GenerateChain(params.TestChainConfig, shared[len(shared)-1], engine, db, 2*triesInMemory+1, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{3}) })
+
+	// Import the shared chain and the original canonical one
+	diskdb := ethdb.NewMemDatabase()
+	new(Genesis).MustCommit(diskdb)
+
+	chain, err := NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{})
+	if err != nil {
+		t.Fatalf("failed to create tester chain: %v", err)
+	}
+	if _, err := chain.InsertChain(shared); err != nil {
+		t.Fatalf("failed to insert shared chain: %v", err)
+	}
+	if _, err := chain.InsertChain(original); err != nil {
+		t.Fatalf("failed to insert shared chain: %v", err)
+	}
+	// Ensure that the state associated with the forking point is pruned away
+	if node, _ := chain.stateCache.TrieDB().Node(shared[len(shared)-1].Root()); node != nil {
+		t.Fatalf("common-but-old ancestor still cache")
+	}
+	// Import the competitor chain without exceeding the canonical's TD and ensure
+	// we have not processed any of the blocks (protection against malicious blocks)
+	if _, err := chain.InsertChain(competitor[:len(competitor)-2]); err != nil {
+		t.Fatalf("failed to insert competitor chain: %v", err)
+	}
+	for i, block := range competitor[:len(competitor)-2] {
+		if node, _ := chain.stateCache.TrieDB().Node(block.Root()); node != nil {
+			t.Fatalf("competitor %d: low TD chain became processed", i)
+		}
+	}
+	// Import the head of the competitor chain, triggering the reorg and ensure we
+	// successfully reprocess all the stashed away blocks.
+	if _, err := chain.InsertChain(competitor[len(competitor)-2:]); err != nil {
+		t.Fatalf("failed to finalize competitor chain: %v", err)
+	}
+	for i, block := range competitor[:len(competitor)-triesInMemory] {
+		if node, _ := chain.stateCache.TrieDB().Node(block.Root()); node != nil {
+			t.Fatalf("competitor %d: competing chain state missing", i)
+		}
+	}
+}
+
+// Benchmarks large blocks with value transfers to non-existing accounts
+func benchmarkLargeNumberOfValueToNonexisting(b *testing.B, numTxs, numBlocks int, recipientFn func(uint64) common.Address, dataFn func(uint64) []byte) {
+	var (
+		signer          = types.HomesteadSigner{}
+		testBankKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+		testBankAddress = crypto.PubkeyToAddress(testBankKey.PublicKey)
+		bankFunds       = big.NewInt(100000000000000000)
+		gspec           = Genesis{
+			Config: params.TestChainConfig,
+			Alloc: GenesisAlloc{
+				testBankAddress: {Balance: bankFunds},
+				common.HexToAddress("0xc0de"): {
+					Code:    []byte{0x60, 0x01, 0x50},
+					Balance: big.NewInt(0),
+				}, // push 1, pop
+			},
+			GasLimit: 100e6, // 100 M
+		}
+	)
+	// Generate the original common chain segment and the two competing forks
+	engine := ethash.NewFaker()
+	db := ethdb.NewMemDatabase()
+	genesis := gspec.MustCommit(db)
+
+	blockGenerator := func(i int, block *BlockGen) {
+		block.SetCoinbase(common.Address{1})
+		for txi := 0; txi < numTxs; txi++ {
+			uniq := uint64(i*numTxs + txi)
+			recipient := recipientFn(uniq)
+			//recipient := common.BigToAddress(big.NewInt(0).SetUint64(1337 + uniq))
+			tx, err := types.SignTx(types.NewTransaction(uniq, recipient, big.NewInt(1), params.TxGas, big.NewInt(1), nil), signer, testBankKey)
+			if err != nil {
+				b.Error(err)
+			}
+			block.AddTx(tx)
+		}
+	}
+
+	shared, _ := GenerateChain(params.TestChainConfig, genesis, engine, db, numBlocks, blockGenerator)
+	b.StopTimer()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		// Import the shared chain and the original canonical one
+		diskdb := ethdb.NewMemDatabase()
+		gspec.MustCommit(diskdb)
+
+		chain, err := NewBlockChain(diskdb, nil, params.TestChainConfig, engine, vm.Config{})
+		if err != nil {
+			b.Fatalf("failed to create tester chain: %v", err)
+		}
+		b.StartTimer()
+		if _, err := chain.InsertChain(shared); err != nil {
+			b.Fatalf("failed to insert shared chain: %v", err)
+		}
+		b.StopTimer()
+		if got := chain.CurrentBlock().Transactions().Len(); got != numTxs*numBlocks {
+			b.Fatalf("Transactions were not included, expected %d, got %d", (numTxs * numBlocks), got)
+
+		}
+	}
+}
+func BenchmarkBlockChain_1x1000ValueTransferToNonexisting(b *testing.B) {
+	var (
+		numTxs    = 1000
+		numBlocks = 1
+	)
+
+	recipientFn := func(nonce uint64) common.Address {
+		return common.BigToAddress(big.NewInt(0).SetUint64(1337 + nonce))
+	}
+	dataFn := func(nonce uint64) []byte {
+		return nil
+	}
+
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+}
+func BenchmarkBlockChain_1x1000ValueTransferToExisting(b *testing.B) {
+	var (
+		numTxs    = 1000
+		numBlocks = 1
+	)
+	b.StopTimer()
+	b.ResetTimer()
+
+	recipientFn := func(nonce uint64) common.Address {
+		return common.BigToAddress(big.NewInt(0).SetUint64(1337))
+	}
+	dataFn := func(nonce uint64) []byte {
+		return nil
+	}
+
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+}
+func BenchmarkBlockChain_1x1000Executions(b *testing.B) {
+	var (
+		numTxs    = 1000
+		numBlocks = 1
+	)
+	b.StopTimer()
+	b.ResetTimer()
+
+	recipientFn := func(nonce uint64) common.Address {
+		return common.BigToAddress(big.NewInt(0).SetUint64(0xc0de))
+	}
+	dataFn := func(nonce uint64) []byte {
+		return nil
+	}
+
+	benchmarkLargeNumberOfValueToNonexisting(b, numTxs, numBlocks, recipientFn, dataFn)
+}
diff --git a/core/bloombits/matcher.go b/core/bloombits/matcher.go
index ce3031702f..8d78adb759 100644
--- a/core/bloombits/matcher.go
+++ b/core/bloombits/matcher.go
@@ -392,7 +392,7 @@ func (m *Matcher) distributor(dist chan *request, session *MatcherSession) {
 		shutdown = session.quit // Shutdown request channel, will gracefully wait for pending requests
 	)
 
-	// assign is a helper method fo try to assign a pending bit an an actively
+	// assign is a helper method fo try to assign a pending bit an actively
 	// listening servicer, or schedule it up for later when one arrives.
 	assign := func(bit uint) {
 		select {
diff --git a/core/chain_indexer.go b/core/chain_indexer.go
index 7fb184aaa7..0b927116d0 100644
--- a/core/chain_indexer.go
+++ b/core/chain_indexer.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
@@ -203,7 +204,10 @@ func (c *ChainIndexer) eventLoop(currentHeader *types.Header, events chan ChainE
 			if header.ParentHash != prevHash {
 				// Reorg to the common ancestor (might not exist in light sync mode, skip reorg then)
 				// TODO(karalabe, zsfelfoldi): This seems a bit brittle, can we detect this case explicitly?
-				if h := FindCommonAncestor(c.chainDb, prevHeader, header); h != nil {
+
+				// TODO(karalabe): This operation is expensive and might block, causing the event system to
+				// potentially also lock up. We need to do with on a different thread somehow.
+				if h := rawdb.FindCommonAncestor(c.chainDb, prevHeader, header); h != nil {
 					c.newHead(h.Number.Uint64(), true)
 				}
 			}
@@ -346,11 +350,11 @@ func (c *ChainIndexer) processSection(section uint64, lastHead common.Hash) (com
 	}
 
 	for number := section * c.sectionSize; number < (section+1)*c.sectionSize; number++ {
-		hash := GetCanonicalHash(c.chainDb, number)
+		hash := rawdb.ReadCanonicalHash(c.chainDb, number)
 		if hash == (common.Hash{}) {
 			return common.Hash{}, fmt.Errorf("canonical block #%d unknown", number)
 		}
-		header := GetHeader(c.chainDb, hash, number)
+		header := rawdb.ReadHeader(c.chainDb, hash, number)
 		if header == nil {
 			return common.Hash{}, fmt.Errorf("block #%d [%x…] not found", number, hash[:4])
 		} else if header.ParentHash != lastHead {
diff --git a/core/chain_indexer_test.go b/core/chain_indexer_test.go
index 9fc09eda51..550caf5567 100644
--- a/core/chain_indexer_test.go
+++ b/core/chain_indexer_test.go
@@ -24,6 +24,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
 )
@@ -47,7 +48,7 @@ func TestChainIndexerWithChildren(t *testing.T) {
 // multiple backends. The section size and required confirmation count parameters
 // are randomized.
 func testChainIndexer(t *testing.T, count int) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 	defer db.Close()
 
 	// Create a chain of indexers and ensure they all report empty
@@ -92,10 +93,10 @@ func testChainIndexer(t *testing.T, count int) {
 	inject := func(number uint64) {
 		header := &types.Header{Number: big.NewInt(int64(number)), Extra: big.NewInt(rand.Int63()).Bytes()}
 		if number > 0 {
-			header.ParentHash = GetCanonicalHash(db, number-1)
+			header.ParentHash = rawdb.ReadCanonicalHash(db, number-1)
 		}
-		WriteHeader(db, header)
-		WriteCanonicalHash(db, header.Hash(), number)
+		rawdb.WriteHeader(db, header)
+		rawdb.WriteCanonicalHash(db, header.Hash(), number)
 	}
 	// Start indexer with an already existing chain
 	for i := uint64(0); i <= 100; i++ {
diff --git a/core/chain_makers.go b/core/chain_makers.go
index 59af633dfd..c1e4b4264a 100644
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@@ -21,7 +21,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -30,20 +30,15 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
-// So we can deterministically seed different blockchains
-var (
-	canonicalSeed = 1
-	forkSeed      = 2
-)
-
 // BlockGen creates blocks for testing.
 // See GenerateChain for a detailed explanation.
 type BlockGen struct {
-	i       int
-	parent  *types.Block
-	chain   []*types.Block
-	header  *types.Header
-	statedb *state.StateDB
+	i           int
+	parent      *types.Block
+	chain       []*types.Block
+	chainReader consensus.ChainReader
+	header      *types.Header
+	statedb     *state.StateDB
 
 	gasPool  *GasPool
 	txs      []*types.Transaction
@@ -51,6 +46,7 @@ type BlockGen struct {
 	uncles   []*types.Header
 
 	config *params.ChainConfig
+	engine consensus.Engine
 }
 
 // SetCoinbase sets the coinbase of the generated block.
@@ -80,11 +76,23 @@ func (b *BlockGen) SetExtra(data []byte) {
 // added. Notably, contract code relying on the BLOCKHASH instruction
 // will panic during execution.
 func (b *BlockGen) AddTx(tx *types.Transaction) {
+	b.AddTxWithChain(nil, tx)
+}
+
+// AddTxWithChain adds a transaction to the generated block. If no coinbase has
+// been set, the block's coinbase is set to the zero address.
+//
+// AddTxWithChain panics if the transaction cannot be executed. In addition to
+// the protocol-imposed limitations (gas limit, etc.), there are some
+// further limitations on the content of transactions that can be
+// added. If contract code relies on the BLOCKHASH instruction,
+// the block in chain will be returned.
+func (b *BlockGen) AddTxWithChain(bc *BlockChain, tx *types.Transaction) {
 	if b.gasPool == nil {
 		b.SetCoinbase(common.Address{})
 	}
 	b.statedb.Prepare(tx.Hash(), common.Hash{}, len(b.txs))
-	receipt, _, err := ApplyTransaction(b.config, nil, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, b.header.GasUsed, vm.Config{})
+	receipt, _, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{})
 	if err != nil {
 		panic(err)
 	}
@@ -141,7 +149,7 @@ func (b *BlockGen) OffsetTime(seconds int64) {
 	if b.header.Time.Cmp(b.parent.Header().Time) <= 0 {
 		panic("block time out of range")
 	}
-	b.header.Difficulty = ethash.CalcDifficulty(b.config, b.header.Time.Uint64(), b.parent.Header())
+	b.header.Difficulty = b.engine.CalcDifficulty(b.chainReader, b.header.Time.Uint64(), b.parent.Header())
 }
 
 // GenerateChain creates a chain of n blocks. The first block's
@@ -156,44 +164,57 @@ func (b *BlockGen) OffsetTime(seconds int64) {
 // Blocks created by GenerateChain do not contain valid proof of work
 // values. Inserting them into BlockChain requires use of FakePow or
 // a similar non-validating proof of work implementation.
-func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) {
+func GenerateChain(config *params.ChainConfig, parent *types.Block, engine consensus.Engine, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) {
 	if config == nil {
 		config = params.TestChainConfig
 	}
 	blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n)
-	genblock := func(i int, h *types.Header, statedb *state.StateDB) (*types.Block, types.Receipts) {
-		b := &BlockGen{parent: parent, i: i, chain: blocks, header: h, statedb: statedb, config: config}
+	genblock := func(i int, parent *types.Block, statedb *state.StateDB) (*types.Block, types.Receipts) {
+		// TODO(karalabe): This is needed for clique, which depends on multiple blocks.
+		// It's nonetheless ugly to spin up a blockchain here. Get rid of this somehow.
+		blockchain, _ := NewBlockChain(db, nil, config, engine, vm.Config{})
+		defer blockchain.Stop()
+
+		b := &BlockGen{i: i, parent: parent, chain: blocks, chainReader: blockchain, statedb: statedb, config: config, engine: engine}
+		b.header = makeHeader(b.chainReader, parent, statedb, b.engine)
+
 		// Mutate the state and block according to any hard-fork specs
 		if daoBlock := config.DAOForkBlock; daoBlock != nil {
 			limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
-			if h.Number.Cmp(daoBlock) >= 0 && h.Number.Cmp(limit) < 0 {
+			if b.header.Number.Cmp(daoBlock) >= 0 && b.header.Number.Cmp(limit) < 0 {
 				if config.DAOForkSupport {
-					h.Extra = common.CopyBytes(params.DAOForkBlockExtra)
+					b.header.Extra = common.CopyBytes(params.DAOForkBlockExtra)
 				}
 			}
 		}
-		if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(h.Number) == 0 {
+		if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(b.header.Number) == 0 {
 			misc.ApplyDAOHardFork(statedb)
 		}
 		// Execute any user modifications to the block and finalize it
 		if gen != nil {
 			gen(i, b)
 		}
-		ethash.AccumulateRewards(config, statedb, h, b.uncles)
-		root, err := statedb.CommitTo(db, config.IsEIP158(h.Number))
-		if err != nil {
-			panic(fmt.Sprintf("state write error: %v", err))
+
+		if b.engine != nil {
+			block, _ := b.engine.Finalize(b.chainReader, b.header, statedb, b.txs, b.uncles, b.receipts)
+			// Write state changes to db
+			root, err := statedb.Commit(config.IsEIP158(b.header.Number))
+			if err != nil {
+				panic(fmt.Sprintf("state write error: %v", err))
+			}
+			if err := statedb.Database().TrieDB().Commit(root, false); err != nil {
+				panic(fmt.Sprintf("trie write error: %v", err))
+			}
+			return block, b.receipts
 		}
-		h.Root = root
-		return types.NewBlock(h, b.txs, b.uncles, b.receipts), b.receipts
+		return nil, nil
 	}
 	for i := 0; i < n; i++ {
 		statedb, err := state.New(parent.Root(), state.NewDatabase(db))
 		if err != nil {
 			panic(err)
 		}
-		header := makeHeader(config, parent, statedb)
-		block, receipt := genblock(i, header, statedb)
+		block, receipt := genblock(i, parent, statedb)
 		blocks[i] = block
 		receipts[i] = receipt
 		parent = block
@@ -201,7 +222,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat
 	return blocks, receipts
 }
 
-func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.StateDB) *types.Header {
+func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.StateDB, engine consensus.Engine) *types.Header {
 	var time *big.Int
 	if parent.Time() == nil {
 		time = big.NewInt(10)
@@ -210,51 +231,24 @@ func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.St
 	}
 
 	return &types.Header{
-		Root:       state.IntermediateRoot(config.IsEIP158(parent.Number())),
+		Root:       state.IntermediateRoot(chain.Config().IsEIP158(parent.Number())),
 		ParentHash: parent.Hash(),
 		Coinbase:   parent.Coinbase(),
-		Difficulty: ethash.CalcDifficulty(config, time.Uint64(), &types.Header{
+		Difficulty: engine.CalcDifficulty(chain, time.Uint64(), &types.Header{
 			Number:     parent.Number(),
 			Time:       new(big.Int).Sub(time, big.NewInt(10)),
 			Difficulty: parent.Difficulty(),
 			UncleHash:  parent.UncleHash(),
 		}),
 		GasLimit: CalcGasLimit(parent),
-		GasUsed:  new(big.Int),
 		Number:   new(big.Int).Add(parent.Number(), common.Big1),
 		Time:     time,
 	}
 }
 
-// newCanonical creates a chain database, and injects a deterministic canonical
-// chain. Depending on the full flag, if creates either a full block chain or a
-// header only chain.
-func newCanonical(n int, full bool) (ethdb.Database, *BlockChain, error) {
-	// Initialize a fresh chain with only a genesis block
-	gspec := new(Genesis)
-	db, _ := ethdb.NewMemDatabase()
-	genesis := gspec.MustCommit(db)
-
-	blockchain, _ := NewBlockChain(db, params.AllEthashProtocolChanges, ethash.NewFaker(), vm.Config{})
-	// Create and inject the requested chain
-	if n == 0 {
-		return db, blockchain, nil
-	}
-	if full {
-		// Full block-chain requested
-		blocks := makeBlockChain(genesis, n, db, canonicalSeed)
-		_, err := blockchain.InsertChain(blocks)
-		return db, blockchain, err
-	}
-	// Header-only chain requested
-	headers := makeHeaderChain(genesis.Header(), n, db, canonicalSeed)
-	_, err := blockchain.InsertHeaderChain(headers, 1)
-	return db, blockchain, err
-}
-
 // makeHeaderChain creates a deterministic chain of headers rooted at parent.
-func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) []*types.Header {
-	blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, db, seed)
+func makeHeaderChain(parent *types.Header, n int, engine consensus.Engine, db ethdb.Database, seed int) []*types.Header {
+	blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, engine, db, seed)
 	headers := make([]*types.Header, len(blocks))
 	for i, block := range blocks {
 		headers[i] = block.Header()
@@ -263,8 +257,8 @@ func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) [
 }
 
 // makeBlockChain creates a deterministic chain of blocks rooted at parent.
-func makeBlockChain(parent *types.Block, n int, db ethdb.Database, seed int) []*types.Block {
-	blocks, _ := GenerateChain(params.TestChainConfig, parent, db, n, func(i int, b *BlockGen) {
+func makeBlockChain(parent *types.Block, n int, engine consensus.Engine, db ethdb.Database, seed int) []*types.Block {
+	blocks, _ := GenerateChain(params.TestChainConfig, parent, engine, db, n, func(i int, b *BlockGen) {
 		b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)})
 	})
 	return blocks
diff --git a/core/chain_makers_test.go b/core/chain_makers_test.go
index 2260c62fbd..5015d1f48e 100644
--- a/core/chain_makers_test.go
+++ b/core/chain_makers_test.go
@@ -36,7 +36,7 @@ func ExampleGenerateChain() {
 		addr1   = crypto.PubkeyToAddress(key1.PublicKey)
 		addr2   = crypto.PubkeyToAddress(key2.PublicKey)
 		addr3   = crypto.PubkeyToAddress(key3.PublicKey)
-		db, _   = ethdb.NewMemDatabase()
+		db      = ethdb.NewMemDatabase()
 	)
 
 	// Ensure that key1 has some funds in the genesis block.
@@ -50,17 +50,17 @@ func ExampleGenerateChain() {
 	// each block and adds different features to gen based on the
 	// block index.
 	signer := types.HomesteadSigner{}
-	chain, _ := GenerateChain(gspec.Config, genesis, db, 5, func(i int, gen *BlockGen) {
+	chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 5, func(i int, gen *BlockGen) {
 		switch i {
 		case 0:
 			// In block 1, addr1 sends addr2 some ether.
-			tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), bigTxGas, nil, nil), signer, key1)
+			tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), params.TxGas, nil, nil), signer, key1)
 			gen.AddTx(tx)
 		case 1:
 			// In block 2, addr1 sends some more ether to addr2.
 			// addr2 passes it on to addr3.
-			tx1, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key1)
-			tx2, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key2)
+			tx1, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key1)
+			tx2, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key2)
 			gen.AddTx(tx1)
 			gen.AddTx(tx2)
 		case 2:
@@ -79,7 +79,7 @@ func ExampleGenerateChain() {
 	})
 
 	// Import the chain. This runs all block validation rules.
-	blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{})
+	blockchain, _ := NewBlockChain(db, nil, gspec.Config, ethash.NewFaker(), vm.Config{})
 	defer blockchain.Stop()
 
 	if i, err := blockchain.InsertChain(chain); err != nil {
diff --git a/core/dao_test.go b/core/dao_test.go
index b9898ff7c8..284b1d98bd 100644
--- a/core/dao_test.go
+++ b/core/dao_test.go
@@ -32,30 +32,30 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 	forkBlock := big.NewInt(32)
 
 	// Generate a common prefix for both pro-forkers and non-forkers
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 	gspec := new(Genesis)
 	genesis := gspec.MustCommit(db)
-	prefix, _ := GenerateChain(params.TestChainConfig, genesis, db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {})
+	prefix, _ := GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {})
 
 	// Create the concurrent, conflicting two nodes
-	proDb, _ := ethdb.NewMemDatabase()
+	proDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(proDb)
 
 	proConf := *params.TestChainConfig
 	proConf.DAOForkBlock = forkBlock
 	proConf.DAOForkSupport = true
 
-	proBc, _ := NewBlockChain(proDb, &proConf, ethash.NewFaker(), vm.Config{})
+	proBc, _ := NewBlockChain(proDb, nil, &proConf, ethash.NewFaker(), vm.Config{})
 	defer proBc.Stop()
 
-	conDb, _ := ethdb.NewMemDatabase()
+	conDb := ethdb.NewMemDatabase()
 	gspec.MustCommit(conDb)
 
 	conConf := *params.TestChainConfig
 	conConf.DAOForkBlock = forkBlock
 	conConf.DAOForkSupport = false
 
-	conBc, _ := NewBlockChain(conDb, &conConf, ethash.NewFaker(), vm.Config{})
+	conBc, _ := NewBlockChain(conDb, nil, &conConf, ethash.NewFaker(), vm.Config{})
 	defer conBc.Stop()
 
 	if _, err := proBc.InsertChain(prefix); err != nil {
@@ -67,9 +67,9 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 	// Try to expand both pro-fork and non-fork chains iteratively with other camp's blocks
 	for i := int64(0); i < params.DAOForkExtraRange.Int64(); i++ {
 		// Create a pro-fork block, and try to feed into the no-fork chain
-		db, _ = ethdb.NewMemDatabase()
+		db = ethdb.NewMemDatabase()
 		gspec.MustCommit(db)
-		bc, _ := NewBlockChain(db, &conConf, ethash.NewFaker(), vm.Config{})
+		bc, _ := NewBlockChain(db, nil, &conConf, ethash.NewFaker(), vm.Config{})
 		defer bc.Stop()
 
 		blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()))
@@ -79,19 +79,22 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 		if _, err := bc.InsertChain(blocks); err != nil {
 			t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
 		}
-		blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+		if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil {
+			t.Fatalf("failed to commit contra-fork head for expansion: %v", err)
+		}
+		blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 		if _, err := conBc.InsertChain(blocks); err == nil {
 			t.Fatalf("contra-fork chain accepted pro-fork block: %v", blocks[0])
 		}
 		// Create a proper no-fork block for the contra-forker
-		blocks, _ = GenerateChain(&conConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+		blocks, _ = GenerateChain(&conConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 		if _, err := conBc.InsertChain(blocks); err != nil {
 			t.Fatalf("contra-fork chain didn't accepted no-fork block: %v", err)
 		}
 		// Create a no-fork block, and try to feed into the pro-fork chain
-		db, _ = ethdb.NewMemDatabase()
+		db = ethdb.NewMemDatabase()
 		gspec.MustCommit(db)
-		bc, _ = NewBlockChain(db, &proConf, ethash.NewFaker(), vm.Config{})
+		bc, _ = NewBlockChain(db, nil, &proConf, ethash.NewFaker(), vm.Config{})
 		defer bc.Stop()
 
 		blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()))
@@ -101,20 +104,23 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 		if _, err := bc.InsertChain(blocks); err != nil {
 			t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
 		}
-		blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+		if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil {
+			t.Fatalf("failed to commit pro-fork head for expansion: %v", err)
+		}
+		blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 		if _, err := proBc.InsertChain(blocks); err == nil {
 			t.Fatalf("pro-fork chain accepted contra-fork block: %v", blocks[0])
 		}
 		// Create a proper pro-fork block for the pro-forker
-		blocks, _ = GenerateChain(&proConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+		blocks, _ = GenerateChain(&proConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 		if _, err := proBc.InsertChain(blocks); err != nil {
 			t.Fatalf("pro-fork chain didn't accepted pro-fork block: %v", err)
 		}
 	}
 	// Verify that contra-forkers accept pro-fork extra-datas after forking finishes
-	db, _ = ethdb.NewMemDatabase()
+	db = ethdb.NewMemDatabase()
 	gspec.MustCommit(db)
-	bc, _ := NewBlockChain(db, &conConf, ethash.NewFaker(), vm.Config{})
+	bc, _ := NewBlockChain(db, nil, &conConf, ethash.NewFaker(), vm.Config{})
 	defer bc.Stop()
 
 	blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()))
@@ -124,14 +130,17 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 	if _, err := bc.InsertChain(blocks); err != nil {
 		t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
 	}
-	blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+	if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil {
+		t.Fatalf("failed to commit contra-fork head for expansion: %v", err)
+	}
+	blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 	if _, err := conBc.InsertChain(blocks); err != nil {
 		t.Fatalf("contra-fork chain didn't accept pro-fork block post-fork: %v", err)
 	}
 	// Verify that pro-forkers accept contra-fork extra-datas after forking finishes
-	db, _ = ethdb.NewMemDatabase()
+	db = ethdb.NewMemDatabase()
 	gspec.MustCommit(db)
-	bc, _ = NewBlockChain(db, &proConf, ethash.NewFaker(), vm.Config{})
+	bc, _ = NewBlockChain(db, nil, &proConf, ethash.NewFaker(), vm.Config{})
 	defer bc.Stop()
 
 	blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()))
@@ -141,7 +150,10 @@ func TestDAOForkRangeExtradata(t *testing.T) {
 	if _, err := bc.InsertChain(blocks); err != nil {
 		t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
 	}
-	blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
+	if err := bc.stateCache.TrieDB().Commit(bc.CurrentHeader().Root, true); err != nil {
+		t.Fatalf("failed to commit pro-fork head for expansion: %v", err)
+	}
+	blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {})
 	if _, err := proBc.InsertChain(blocks); err != nil {
 		t.Fatalf("pro-fork chain didn't accept contra-fork block post-fork: %v", err)
 	}
diff --git a/core/database_util.go b/core/database_util.go
deleted file mode 100644
index c6b125dae9..0000000000
--- a/core/database_util.go
+++ /dev/null
@@ -1,632 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see .
-
-package core
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethdb"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-// DatabaseReader wraps the Get method of a backing data store.
-type DatabaseReader interface {
-	Get(key []byte) (value []byte, err error)
-}
-
-// DatabaseDeleter wraps the Delete method of a backing data store.
-type DatabaseDeleter interface {
-	Delete(key []byte) error
-}
-
-var (
-	headHeaderKey = []byte("LastHeader")
-	headBlockKey  = []byte("LastBlock")
-	headFastKey   = []byte("LastFast")
-
-	// Data item prefixes (use single byte to avoid mixing data types, avoid `i`).
-	headerPrefix        = []byte("h") // headerPrefix + num (uint64 big endian) + hash -> header
-	tdSuffix            = []byte("t") // headerPrefix + num (uint64 big endian) + hash + tdSuffix -> td
-	numSuffix           = []byte("n") // headerPrefix + num (uint64 big endian) + numSuffix -> hash
-	blockHashPrefix     = []byte("H") // blockHashPrefix + hash -> num (uint64 big endian)
-	bodyPrefix          = []byte("b") // bodyPrefix + num (uint64 big endian) + hash -> block body
-	blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts
-	lookupPrefix        = []byte("l") // lookupPrefix + hash -> transaction/receipt lookup metadata
-	bloomBitsPrefix     = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits
-
-	preimagePrefix = "secure-key-"              // preimagePrefix + hash -> preimage
-	configPrefix   = []byte("ethereum-config-") // config prefix for the db
-
-	// Chain index prefixes (use `i` + single byte to avoid mixing data types).
-	BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress
-
-	// used by old db, now only used for conversion
-	oldReceiptsPrefix = []byte("receipts-")
-	oldTxMetaSuffix   = []byte{0x01}
-
-	ErrChainConfigNotFound = errors.New("ChainConfig not found") // general config not found error
-
-	preimageCounter    = metrics.NewCounter("db/preimage/total")
-	preimageHitCounter = metrics.NewCounter("db/preimage/hits")
-)
-
-// TxLookupEntry is a positional metadata to help looking up the data content of
-// a transaction or receipt given only its hash.
-type TxLookupEntry struct {
-	BlockHash  common.Hash
-	BlockIndex uint64
-	Index      uint64
-}
-
-// encodeBlockNumber encodes a block number as big endian uint64
-func encodeBlockNumber(number uint64) []byte {
-	enc := make([]byte, 8)
-	binary.BigEndian.PutUint64(enc, number)
-	return enc
-}
-
-// GetCanonicalHash retrieves a hash assigned to a canonical block number.
-func GetCanonicalHash(db DatabaseReader, number uint64) common.Hash {
-	data, _ := db.Get(append(append(headerPrefix, encodeBlockNumber(number)...), numSuffix...))
-	if len(data) == 0 {
-		return common.Hash{}
-	}
-	return common.BytesToHash(data)
-}
-
-// missingNumber is returned by GetBlockNumber if no header with the
-// given block hash has been stored in the database
-const missingNumber = uint64(0xffffffffffffffff)
-
-// GetBlockNumber returns the block number assigned to a block hash
-// if the corresponding header is present in the database
-func GetBlockNumber(db DatabaseReader, hash common.Hash) uint64 {
-	data, _ := db.Get(append(blockHashPrefix, hash.Bytes()...))
-	if len(data) != 8 {
-		return missingNumber
-	}
-	return binary.BigEndian.Uint64(data)
-}
-
-// GetHeadHeaderHash retrieves the hash of the current canonical head block's
-// header. The difference between this and GetHeadBlockHash is that whereas the
-// last block hash is only updated upon a full block import, the last header
-// hash is updated already at header import, allowing head tracking for the
-// light synchronization mechanism.
-func GetHeadHeaderHash(db DatabaseReader) common.Hash {
-	data, _ := db.Get(headHeaderKey)
-	if len(data) == 0 {
-		return common.Hash{}
-	}
-	return common.BytesToHash(data)
-}
-
-// GetHeadBlockHash retrieves the hash of the current canonical head block.
-func GetHeadBlockHash(db DatabaseReader) common.Hash {
-	data, _ := db.Get(headBlockKey)
-	if len(data) == 0 {
-		return common.Hash{}
-	}
-	return common.BytesToHash(data)
-}
-
-// GetHeadFastBlockHash retrieves the hash of the current canonical head block during
-// fast synchronization. The difference between this and GetHeadBlockHash is that
-// whereas the last block hash is only updated upon a full block import, the last
-// fast hash is updated when importing pre-processed blocks.
-func GetHeadFastBlockHash(db DatabaseReader) common.Hash {
-	data, _ := db.Get(headFastKey)
-	if len(data) == 0 {
-		return common.Hash{}
-	}
-	return common.BytesToHash(data)
-}
-
-// GetHeaderRLP retrieves a block header in its raw RLP database encoding, or nil
-// if the header's not found.
-func GetHeaderRLP(db DatabaseReader, hash common.Hash, number uint64) rlp.RawValue {
-	data, _ := db.Get(headerKey(hash, number))
-	return data
-}
-
-// GetHeader retrieves the block header corresponding to the hash, nil if none
-// found.
-func GetHeader(db DatabaseReader, hash common.Hash, number uint64) *types.Header {
-	data := GetHeaderRLP(db, hash, number)
-	if len(data) == 0 {
-		return nil
-	}
-	header := new(types.Header)
-	if err := rlp.Decode(bytes.NewReader(data), header); err != nil {
-		log.Error("Invalid block header RLP", "hash", hash, "err", err)
-		return nil
-	}
-	return header
-}
-
-// GetBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.
-func GetBodyRLP(db DatabaseReader, hash common.Hash, number uint64) rlp.RawValue {
-	data, _ := db.Get(blockBodyKey(hash, number))
-	return data
-}
-
-func headerKey(hash common.Hash, number uint64) []byte {
-	return append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
-}
-
-func blockBodyKey(hash common.Hash, number uint64) []byte {
-	return append(append(bodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
-}
-
-// GetBody retrieves the block body (transactons, uncles) corresponding to the
-// hash, nil if none found.
-func GetBody(db DatabaseReader, hash common.Hash, number uint64) *types.Body {
-	data := GetBodyRLP(db, hash, number)
-	if len(data) == 0 {
-		return nil
-	}
-	body := new(types.Body)
-	if err := rlp.Decode(bytes.NewReader(data), body); err != nil {
-		log.Error("Invalid block body RLP", "hash", hash, "err", err)
-		return nil
-	}
-	return body
-}
-
-// GetTd retrieves a block's total difficulty corresponding to the hash, nil if
-// none found.
-func GetTd(db DatabaseReader, hash common.Hash, number uint64) *big.Int {
-	data, _ := db.Get(append(append(append(headerPrefix, encodeBlockNumber(number)...), hash[:]...), tdSuffix...))
-	if len(data) == 0 {
-		return nil
-	}
-	td := new(big.Int)
-	if err := rlp.Decode(bytes.NewReader(data), td); err != nil {
-		log.Error("Invalid block total difficulty RLP", "hash", hash, "err", err)
-		return nil
-	}
-	return td
-}
-
-// GetBlock retrieves an entire block corresponding to the hash, assembling it
-// back from the stored header and body. If either the header or body could not
-// be retrieved nil is returned.
-//
-// Note, due to concurrent download of header and block body the header and thus
-// canonical hash can be stored in the database but the body data not (yet).
-func GetBlock(db DatabaseReader, hash common.Hash, number uint64) *types.Block {
-	// Retrieve the block header and body contents
-	header := GetHeader(db, hash, number)
-	if header == nil {
-		return nil
-	}
-	body := GetBody(db, hash, number)
-	if body == nil {
-		return nil
-	}
-	// Reassemble the block and return
-	return types.NewBlockWithHeader(header).WithBody(body.Transactions, body.Uncles)
-}
-
-// GetBlockReceipts retrieves the receipts generated by the transactions included
-// in a block given by its hash.
-func GetBlockReceipts(db DatabaseReader, hash common.Hash, number uint64) types.Receipts {
-	data, _ := db.Get(append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash[:]...))
-	if len(data) == 0 {
-		return nil
-	}
-	storageReceipts := []*types.ReceiptForStorage{}
-	if err := rlp.DecodeBytes(data, &storageReceipts); err != nil {
-		log.Error("Invalid receipt array RLP", "hash", hash, "err", err)
-		return nil
-	}
-	receipts := make(types.Receipts, len(storageReceipts))
-	for i, receipt := range storageReceipts {
-		receipts[i] = (*types.Receipt)(receipt)
-	}
-	return receipts
-}
-
-// GetTxLookupEntry retrieves the positional metadata associated with a transaction
-// hash to allow retrieving the transaction or receipt by hash.
-func GetTxLookupEntry(db DatabaseReader, hash common.Hash) (common.Hash, uint64, uint64) {
-	// Load the positional metadata from disk and bail if it fails
-	data, _ := db.Get(append(lookupPrefix, hash.Bytes()...))
-	if len(data) == 0 {
-		return common.Hash{}, 0, 0
-	}
-	// Parse and return the contents of the lookup entry
-	var entry TxLookupEntry
-	if err := rlp.DecodeBytes(data, &entry); err != nil {
-		log.Error("Invalid lookup entry RLP", "hash", hash, "err", err)
-		return common.Hash{}, 0, 0
-	}
-	return entry.BlockHash, entry.BlockIndex, entry.Index
-}
-
-// GetTransaction retrieves a specific transaction from the database, along with
-// its added positional metadata.
-func GetTransaction(db DatabaseReader, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
-	// Retrieve the lookup metadata and resolve the transaction from the body
-	blockHash, blockNumber, txIndex := GetTxLookupEntry(db, hash)
-
-	if blockHash != (common.Hash{}) {
-		body := GetBody(db, blockHash, blockNumber)
-		if body == nil || len(body.Transactions) <= int(txIndex) {
-			log.Error("Transaction referenced missing", "number", blockNumber, "hash", blockHash, "index", txIndex)
-			return nil, common.Hash{}, 0, 0
-		}
-		return body.Transactions[txIndex], blockHash, blockNumber, txIndex
-	}
-	// Old transaction representation, load the transaction and it's metadata separately
-	data, _ := db.Get(hash.Bytes())
-	if len(data) == 0 {
-		return nil, common.Hash{}, 0, 0
-	}
-	var tx types.Transaction
-	if err := rlp.DecodeBytes(data, &tx); err != nil {
-		return nil, common.Hash{}, 0, 0
-	}
-	// Retrieve the blockchain positional metadata
-	data, _ = db.Get(append(hash.Bytes(), oldTxMetaSuffix...))
-	if len(data) == 0 {
-		return nil, common.Hash{}, 0, 0
-	}
-	var entry TxLookupEntry
-	if err := rlp.DecodeBytes(data, &entry); err != nil {
-		return nil, common.Hash{}, 0, 0
-	}
-	return &tx, entry.BlockHash, entry.BlockIndex, entry.Index
-}
-
-// GetReceipt retrieves a specific transaction receipt from the database, along with
-// its added positional metadata.
-func GetReceipt(db DatabaseReader, hash common.Hash) (*types.Receipt, common.Hash, uint64, uint64) {
-	// Retrieve the lookup metadata and resolve the receipt from the receipts
-	blockHash, blockNumber, receiptIndex := GetTxLookupEntry(db, hash)
-
-	if blockHash != (common.Hash{}) {
-		receipts := GetBlockReceipts(db, blockHash, blockNumber)
-		if len(receipts) <= int(receiptIndex) {
-			log.Error("Receipt refereced missing", "number", blockNumber, "hash", blockHash, "index", receiptIndex)
-			return nil, common.Hash{}, 0, 0
-		}
-		return receipts[receiptIndex], blockHash, blockNumber, receiptIndex
-	}
-	// Old receipt representation, load the receipt and set an unknown metadata
-	data, _ := db.Get(append(oldReceiptsPrefix, hash[:]...))
-	if len(data) == 0 {
-		return nil, common.Hash{}, 0, 0
-	}
-	var receipt types.ReceiptForStorage
-	err := rlp.DecodeBytes(data, &receipt)
-	if err != nil {
-		log.Error("Invalid receipt RLP", "hash", hash, "err", err)
-	}
-	return (*types.Receipt)(&receipt), common.Hash{}, 0, 0
-}
-
-// GetBloomBits retrieves the compressed bloom bit vector belonging to the given
-// section and bit index from the.
-func GetBloomBits(db DatabaseReader, bit uint, section uint64, head common.Hash) ([]byte, error) {
-	key := append(append(bloomBitsPrefix, make([]byte, 10)...), head.Bytes()...)
-
-	binary.BigEndian.PutUint16(key[1:], uint16(bit))
-	binary.BigEndian.PutUint64(key[3:], section)
-
-	return db.Get(key)
-}
-
-// WriteCanonicalHash stores the canonical hash for the given block number.
-func WriteCanonicalHash(db ethdb.Putter, hash common.Hash, number uint64) error {
-	key := append(append(headerPrefix, encodeBlockNumber(number)...), numSuffix...)
-	if err := db.Put(key, hash.Bytes()); err != nil {
-		log.Crit("Failed to store number to hash mapping", "err", err)
-	}
-	return nil
-}
-
-// WriteHeadHeaderHash stores the head header's hash.
-func WriteHeadHeaderHash(db ethdb.Putter, hash common.Hash) error {
-	if err := db.Put(headHeaderKey, hash.Bytes()); err != nil {
-		log.Crit("Failed to store last header's hash", "err", err)
-	}
-	return nil
-}
-
-// WriteHeadBlockHash stores the head block's hash.
-func WriteHeadBlockHash(db ethdb.Putter, hash common.Hash) error {
-	if err := db.Put(headBlockKey, hash.Bytes()); err != nil {
-		log.Crit("Failed to store last block's hash", "err", err)
-	}
-	return nil
-}
-
-// WriteHeadFastBlockHash stores the fast head block's hash.
-func WriteHeadFastBlockHash(db ethdb.Putter, hash common.Hash) error {
-	if err := db.Put(headFastKey, hash.Bytes()); err != nil {
-		log.Crit("Failed to store last fast block's hash", "err", err)
-	}
-	return nil
-}
-
-// WriteHeader serializes a block header into the database.
-func WriteHeader(db ethdb.Putter, header *types.Header) error {
-	data, err := rlp.EncodeToBytes(header)
-	if err != nil {
-		return err
-	}
-	hash := header.Hash().Bytes()
-	num := header.Number.Uint64()
-	encNum := encodeBlockNumber(num)
-	key := append(blockHashPrefix, hash...)
-	if err := db.Put(key, encNum); err != nil {
-		log.Crit("Failed to store hash to number mapping", "err", err)
-	}
-	key = append(append(headerPrefix, encNum...), hash...)
-	if err := db.Put(key, data); err != nil {
-		log.Crit("Failed to store header", "err", err)
-	}
-	return nil
-}
-
-// WriteBody serializes the body of a block into the database.
-func WriteBody(db ethdb.Putter, hash common.Hash, number uint64, body *types.Body) error {
-	data, err := rlp.EncodeToBytes(body)
-	if err != nil {
-		return err
-	}
-	return WriteBodyRLP(db, hash, number, data)
-}
-
-// WriteBodyRLP writes a serialized body of a block into the database.
-func WriteBodyRLP(db ethdb.Putter, hash common.Hash, number uint64, rlp rlp.RawValue) error {
-	key := append(append(bodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
-	if err := db.Put(key, rlp); err != nil {
-		log.Crit("Failed to store block body", "err", err)
-	}
-	return nil
-}
-
-// WriteTd serializes the total difficulty of a block into the database.
-func WriteTd(db ethdb.Putter, hash common.Hash, number uint64, td *big.Int) error {
-	data, err := rlp.EncodeToBytes(td)
-	if err != nil {
-		return err
-	}
-	key := append(append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...), tdSuffix...)
-	if err := db.Put(key, data); err != nil {
-		log.Crit("Failed to store block total difficulty", "err", err)
-	}
-	return nil
-}
-
-// WriteBlock serializes a block into the database, header and body separately.
-func WriteBlock(db ethdb.Putter, block *types.Block) error {
-	// Store the body first to retain database consistency
-	if err := WriteBody(db, block.Hash(), block.NumberU64(), block.Body()); err != nil {
-		return err
-	}
-	// Store the header too, signaling full block ownership
-	if err := WriteHeader(db, block.Header()); err != nil {
-		return err
-	}
-	return nil
-}
-
-// WriteBlockReceipts stores all the transaction receipts belonging to a block
-// as a single receipt slice. This is used during chain reorganisations for
-// rescheduling dropped transactions.
-func WriteBlockReceipts(db ethdb.Putter, hash common.Hash, number uint64, receipts types.Receipts) error {
-	// Convert the receipts into their storage form and serialize them
-	storageReceipts := make([]*types.ReceiptForStorage, len(receipts))
-	for i, receipt := range receipts {
-		storageReceipts[i] = (*types.ReceiptForStorage)(receipt)
-	}
-	bytes, err := rlp.EncodeToBytes(storageReceipts)
-	if err != nil {
-		return err
-	}
-	// Store the flattened receipt slice
-	key := append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
-	if err := db.Put(key, bytes); err != nil {
-		log.Crit("Failed to store block receipts", "err", err)
-	}
-	return nil
-}
-
-// WriteTxLookupEntries stores a positional metadata for every transaction from
-// a block, enabling hash based transaction and receipt lookups.
-func WriteTxLookupEntries(db ethdb.Putter, block *types.Block) error {
-	// Iterate over each transaction and encode its metadata
-	for i, tx := range block.Transactions() {
-		entry := TxLookupEntry{
-			BlockHash:  block.Hash(),
-			BlockIndex: block.NumberU64(),
-			Index:      uint64(i),
-		}
-		data, err := rlp.EncodeToBytes(entry)
-		if err != nil {
-			return err
-		}
-		if err := db.Put(append(lookupPrefix, tx.Hash().Bytes()...), data); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// WriteBloomBits writes the compressed bloom bits vector belonging to the given
-// section and bit index.
-func WriteBloomBits(db ethdb.Putter, bit uint, section uint64, head common.Hash, bits []byte) {
-	key := append(append(bloomBitsPrefix, make([]byte, 10)...), head.Bytes()...)
-
-	binary.BigEndian.PutUint16(key[1:], uint16(bit))
-	binary.BigEndian.PutUint64(key[3:], section)
-
-	if err := db.Put(key, bits); err != nil {
-		log.Crit("Failed to store bloom bits", "err", err)
-	}
-}
-
-// DeleteCanonicalHash removes the number to hash canonical mapping.
-func DeleteCanonicalHash(db DatabaseDeleter, number uint64) {
-	db.Delete(append(append(headerPrefix, encodeBlockNumber(number)...), numSuffix...))
-}
-
-// DeleteHeader removes all block header data associated with a hash.
-func DeleteHeader(db DatabaseDeleter, hash common.Hash, number uint64) {
-	db.Delete(append(blockHashPrefix, hash.Bytes()...))
-	db.Delete(append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...))
-}
-
-// DeleteBody removes all block body data associated with a hash.
-func DeleteBody(db DatabaseDeleter, hash common.Hash, number uint64) {
-	db.Delete(append(append(bodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...))
-}
-
-// DeleteTd removes all block total difficulty data associated with a hash.
-func DeleteTd(db DatabaseDeleter, hash common.Hash, number uint64) {
-	db.Delete(append(append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...), tdSuffix...))
-}
-
-// DeleteBlock removes all block data associated with a hash.
-func DeleteBlock(db DatabaseDeleter, hash common.Hash, number uint64) {
-	DeleteBlockReceipts(db, hash, number)
-	DeleteHeader(db, hash, number)
-	DeleteBody(db, hash, number)
-	DeleteTd(db, hash, number)
-}
-
-// DeleteBlockReceipts removes all receipt data associated with a block hash.
-func DeleteBlockReceipts(db DatabaseDeleter, hash common.Hash, number uint64) {
-	db.Delete(append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...))
-}
-
-// DeleteTxLookupEntry removes all transaction data associated with a hash.
-func DeleteTxLookupEntry(db DatabaseDeleter, hash common.Hash) {
-	db.Delete(append(lookupPrefix, hash.Bytes()...))
-}
-
-// PreimageTable returns a Database instance with the key prefix for preimage entries.
-func PreimageTable(db ethdb.Database) ethdb.Database {
-	return ethdb.NewTable(db, preimagePrefix)
-}
-
-// WritePreimages writes the provided set of preimages to the database. `number` is the
-// current block number, and is used for debug messages only.
-func WritePreimages(db ethdb.Database, number uint64, preimages map[common.Hash][]byte) error {
-	table := PreimageTable(db)
-	batch := table.NewBatch()
-	hitCount := 0
-	for hash, preimage := range preimages {
-		if _, err := table.Get(hash.Bytes()); err != nil {
-			batch.Put(hash.Bytes(), preimage)
-			hitCount++
-		}
-	}
-	preimageCounter.Inc(int64(len(preimages)))
-	preimageHitCounter.Inc(int64(hitCount))
-	if hitCount > 0 {
-		if err := batch.Write(); err != nil {
-			return fmt.Errorf("preimage write fail for block %d: %v", number, err)
-		}
-	}
-	return nil
-}
-
-// GetBlockChainVersion reads the version number from db.
-func GetBlockChainVersion(db DatabaseReader) int {
-	var vsn uint
-	enc, _ := db.Get([]byte("BlockchainVersion"))
-	rlp.DecodeBytes(enc, &vsn)
-	return int(vsn)
-}
-
-// WriteBlockChainVersion writes vsn as the version number to db.
-func WriteBlockChainVersion(db ethdb.Putter, vsn int) {
-	enc, _ := rlp.EncodeToBytes(uint(vsn))
-	db.Put([]byte("BlockchainVersion"), enc)
-}
-
-// WriteChainConfig writes the chain config settings to the database.
-func WriteChainConfig(db ethdb.Putter, hash common.Hash, cfg *params.ChainConfig) error {
-	// short circuit and ignore if nil config. GetChainConfig
-	// will return a default.
-	if cfg == nil {
-		return nil
-	}
-
-	jsonChainConfig, err := json.Marshal(cfg)
-	if err != nil {
-		return err
-	}
-
-	return db.Put(append(configPrefix, hash[:]...), jsonChainConfig)
-}
-
-// GetChainConfig will fetch the network settings based on the given hash.
-func GetChainConfig(db DatabaseReader, hash common.Hash) (*params.ChainConfig, error) {
-	jsonChainConfig, _ := db.Get(append(configPrefix, hash[:]...))
-	if len(jsonChainConfig) == 0 {
-		return nil, ErrChainConfigNotFound
-	}
-
-	var config params.ChainConfig
-	if err := json.Unmarshal(jsonChainConfig, &config); err != nil {
-		return nil, err
-	}
-
-	return &config, nil
-}
-
-// FindCommonAncestor returns the last common ancestor of two block headers
-func FindCommonAncestor(db DatabaseReader, a, b *types.Header) *types.Header {
-	for bn := b.Number.Uint64(); a.Number.Uint64() > bn; {
-		a = GetHeader(db, a.ParentHash, a.Number.Uint64()-1)
-		if a == nil {
-			return nil
-		}
-	}
-	for an := a.Number.Uint64(); an < b.Number.Uint64(); {
-		b = GetHeader(db, b.ParentHash, b.Number.Uint64()-1)
-		if b == nil {
-			return nil
-		}
-	}
-	for a.Hash() != b.Hash() {
-		a = GetHeader(db, a.ParentHash, a.Number.Uint64()-1)
-		if a == nil {
-			return nil
-		}
-		b = GetHeader(db, b.ParentHash, b.Number.Uint64()-1)
-		if b == nil {
-			return nil
-		}
-	}
-	return a
-}
diff --git a/core/events.go b/core/events.go
index 6f404f612b..8d200f2a29 100644
--- a/core/events.go
+++ b/core/events.go
@@ -21,8 +21,8 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
-// TxPreEvent is posted when a transaction enters the transaction pool.
-type TxPreEvent struct{ Tx *types.Transaction }
+// NewTxsEvent is posted when a batch of transactions enter the transaction pool.
+type NewTxsEvent struct{ Txs []*types.Transaction }
 
 // PendingLogsEvent is posted pre mining and notifies of pending logs.
 type PendingLogsEvent struct {
@@ -35,9 +35,6 @@ type PendingStateEvent struct{}
 // NewMinedBlockEvent is posted when a block has been imported.
 type NewMinedBlockEvent struct{ Block *types.Block }
 
-// RemovedTransactionEvent is posted when a reorg happens
-type RemovedTransactionEvent struct{ Txs types.Transactions }
-
 // RemovedLogsEvent is posted when a reorg happens
 type RemovedLogsEvent struct{ Logs []*types.Log }
 
diff --git a/core/evm.go b/core/evm.go
index 4912aa6505..596ea95fb7 100644
--- a/core/evm.go
+++ b/core/evm.go
@@ -53,20 +53,33 @@ func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author
 		BlockNumber: new(big.Int).Set(header.Number),
 		Time:        new(big.Int).Set(header.Time),
 		Difficulty:  new(big.Int).Set(header.Difficulty),
-		GasLimit:    new(big.Int).Set(header.GasLimit),
+		GasLimit:    header.GasLimit,
 		GasPrice:    new(big.Int).Set(msg.GasPrice()),
 	}
 }
 
 // GetHashFn returns a GetHashFunc which retrieves header hashes by number
 func GetHashFn(ref *types.Header, chain ChainContext) func(n uint64) common.Hash {
+	var cache map[uint64]common.Hash
+
 	return func(n uint64) common.Hash {
-		for header := chain.GetHeader(ref.ParentHash, ref.Number.Uint64()-1); header != nil; header = chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) {
-			if header.Number.Uint64() == n {
-				return header.Hash()
+		// If there's no hash cache yet, make one
+		if cache == nil {
+			cache = map[uint64]common.Hash{
+				ref.Number.Uint64() - 1: ref.ParentHash,
+			}
+		}
+		// Try to fulfill the request from the cache
+		if hash, ok := cache[n]; ok {
+			return hash
+		}
+		// Not cached, iterate the blocks and cache the hashes
+		for header := chain.GetHeader(ref.ParentHash, ref.Number.Uint64()-1); header != nil; header = chain.GetHeader(header.ParentHash, header.Number.Uint64()-1) {
+			cache[header.Number.Uint64()-1] = header.ParentHash
+			if n == header.Number.Uint64()-1 {
+				return header.ParentHash
 			}
 		}
-
 		return common.Hash{}
 	}
 }
diff --git a/core/gaspool.go b/core/gaspool.go
index ef99908cfe..e3795c1ee9 100644
--- a/core/gaspool.go
+++ b/core/gaspool.go
@@ -16,31 +16,39 @@
 
 package core
 
-import "math/big"
+import (
+	"fmt"
+	"math"
+)
 
-// GasPool tracks the amount of gas available during
-// execution of the transactions in a block.
-// The zero value is a pool with zero gas available.
-type GasPool big.Int
+// GasPool tracks the amount of gas available during execution of the transactions
+// in a block. The zero value is a pool with zero gas available.
+type GasPool uint64
 
 // AddGas makes gas available for execution.
-func (gp *GasPool) AddGas(amount *big.Int) *GasPool {
-	i := (*big.Int)(gp)
-	i.Add(i, amount)
+func (gp *GasPool) AddGas(amount uint64) *GasPool {
+	if uint64(*gp) > math.MaxUint64-amount {
+		panic("gas pool pushed above uint64")
+	}
+	*(*uint64)(gp) += amount
 	return gp
 }
 
 // SubGas deducts the given amount from the pool if enough gas is
 // available and returns an error otherwise.
-func (gp *GasPool) SubGas(amount *big.Int) error {
-	i := (*big.Int)(gp)
-	if i.Cmp(amount) < 0 {
+func (gp *GasPool) SubGas(amount uint64) error {
+	if uint64(*gp) < amount {
 		return ErrGasLimitReached
 	}
-	i.Sub(i, amount)
+	*(*uint64)(gp) -= amount
 	return nil
 }
 
-func (gp *GasPool) String() string {
-	return (*big.Int)(gp).String()
+// Gas returns the amount of gas remaining in the pool.
+func (gp *GasPool) Gas() uint64 {
+	return uint64(*gp)
+}
+
+func (gp *GasPool) String() string {
+	return fmt.Sprintf("%d", *gp)
 }
diff --git a/core/gen_genesis.go b/core/gen_genesis.go
index 4d75704a6d..bb8ea1d6a2 100644
--- a/core/gen_genesis.go
+++ b/core/gen_genesis.go
@@ -13,6 +13,8 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+var _ = (*genesisSpecMarshaling)(nil)
+
 func (g Genesis) MarshalJSON() ([]byte, error) {
 	type Genesis struct {
 		Config     *params.ChainConfig                         `json:"config"`
@@ -54,7 +56,7 @@ func (g *Genesis) UnmarshalJSON(input []byte) error {
 		Config     *params.ChainConfig                         `json:"config"`
 		Nonce      *math.HexOrDecimal64                        `json:"nonce"`
 		Timestamp  *math.HexOrDecimal64                        `json:"timestamp"`
-		ExtraData  hexutil.Bytes                               `json:"extraData"`
+		ExtraData  *hexutil.Bytes                              `json:"extraData"`
 		GasLimit   *math.HexOrDecimal64                        `json:"gasLimit"   gencodec:"required"`
 		Difficulty *math.HexOrDecimal256                       `json:"difficulty" gencodec:"required"`
 		Mixhash    *common.Hash                                `json:"mixHash"`
@@ -78,7 +80,7 @@ func (g *Genesis) UnmarshalJSON(input []byte) error {
 		g.Timestamp = uint64(*dec.Timestamp)
 	}
 	if dec.ExtraData != nil {
-		g.ExtraData = dec.ExtraData
+		g.ExtraData = *dec.ExtraData
 	}
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'gasLimit' for Genesis")
diff --git a/core/gen_genesis_account.go b/core/gen_genesis_account.go
index 15c9565a23..64fb9b9248 100644
--- a/core/gen_genesis_account.go
+++ b/core/gen_genesis_account.go
@@ -38,18 +38,18 @@ func (g GenesisAccount) MarshalJSON() ([]byte, error) {
 
 func (g *GenesisAccount) UnmarshalJSON(input []byte) error {
 	type GenesisAccount struct {
-		Code       hexutil.Bytes               `json:"code,omitempty"`
+		Code       *hexutil.Bytes              `json:"code,omitempty"`
 		Storage    map[storageJSON]storageJSON `json:"storage,omitempty"`
 		Balance    *math.HexOrDecimal256       `json:"balance" gencodec:"required"`
 		Nonce      *math.HexOrDecimal64        `json:"nonce,omitempty"`
-		PrivateKey hexutil.Bytes               `json:"secretKey,omitempty"`
+		PrivateKey *hexutil.Bytes              `json:"secretKey,omitempty"`
 	}
 	var dec GenesisAccount
 	if err := json.Unmarshal(input, &dec); err != nil {
 		return err
 	}
 	if dec.Code != nil {
-		g.Code = dec.Code
+		g.Code = *dec.Code
 	}
 	if dec.Storage != nil {
 		g.Storage = make(map[common.Hash]common.Hash, len(dec.Storage))
@@ -65,7 +65,7 @@ func (g *GenesisAccount) UnmarshalJSON(input []byte) error {
 		g.Nonce = uint64(*dec.Nonce)
 	}
 	if dec.PrivateKey != nil {
-		g.PrivateKey = dec.PrivateKey
+		g.PrivateKey = *dec.PrivateKey
 	}
 	return nil
 }
diff --git a/core/genesis.go b/core/genesis.go
index df491ce0f4..9190e2ba22 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -155,7 +156,7 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig
 	}
 
 	// Just commit the new block if there is no stored genesis block.
-	stored := GetCanonicalHash(db, 0)
+	stored := rawdb.ReadCanonicalHash(db, 0)
 	if (stored == common.Hash{}) {
 		if genesis == nil {
 			log.Info("Writing default main-net genesis block")
@@ -169,23 +170,19 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig
 
 	// Check whether the genesis block is already written.
 	if genesis != nil {
-		block, _ := genesis.ToBlock()
-		hash := block.Hash()
+		hash := genesis.ToBlock(nil).Hash()
 		if hash != stored {
-			return genesis.Config, block.Hash(), &GenesisMismatchError{stored, hash}
+			return genesis.Config, hash, &GenesisMismatchError{stored, hash}
 		}
 	}
 
 	// Get the existing chain configuration.
 	newcfg := genesis.configOrDefault(stored)
-	storedcfg, err := GetChainConfig(db, stored)
-	if err != nil {
-		if err == ErrChainConfigNotFound {
-			// This case happens if a genesis write was interrupted.
-			log.Warn("Found genesis block without chain config")
-			err = WriteChainConfig(db, stored, newcfg)
-		}
-		return newcfg, stored, err
+	storedcfg := rawdb.ReadChainConfig(db, stored)
+	if storedcfg == nil {
+		log.Warn("Found genesis block without chain config")
+		rawdb.WriteChainConfig(db, stored, newcfg)
+		return newcfg, stored, nil
 	}
 	// Special case: don't change the existing config of a non-mainnet chain if no new
 	// config is supplied. These chains would get AllProtocolChanges (and a compat error)
@@ -196,15 +193,16 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig
 
 	// Check config compatibility and write the config. Compatibility errors
 	// are returned to the caller unless we're already at block zero.
-	height := GetBlockNumber(db, GetHeadHeaderHash(db))
-	if height == missingNumber {
+	height := rawdb.ReadHeaderNumber(db, rawdb.ReadHeadHeaderHash(db))
+	if height == nil {
 		return newcfg, stored, fmt.Errorf("missing block number for head header hash")
 	}
-	compatErr := storedcfg.CheckCompatible(newcfg, height)
-	if compatErr != nil && height != 0 && compatErr.RewindTo != 0 {
+	compatErr := storedcfg.CheckCompatible(newcfg, *height)
+	if compatErr != nil && *height != 0 && compatErr.RewindTo != 0 {
 		return newcfg, stored, compatErr
 	}
-	return newcfg, stored, WriteChainConfig(db, stored, newcfg)
+	rawdb.WriteChainConfig(db, stored, newcfg)
+	return newcfg, stored, nil
 }
 
 func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
@@ -220,9 +218,12 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 	}
 }
 
-// ToBlock creates the block and state of a genesis specification.
-func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) {
-	db, _ := ethdb.NewMemDatabase()
+// ToBlock creates the genesis block and writes state of a genesis specification
+// to the given database (or discards it if nil).
+func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
+	if db == nil {
+		db = ethdb.NewMemDatabase()
+	}
 	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
 	for addr, account := range g.Alloc {
 		statedb.AddBalance(addr, account.Balance)
@@ -239,8 +240,8 @@ func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) {
 		Time:       new(big.Int).SetUint64(g.Timestamp),
 		ParentHash: g.ParentHash,
 		Extra:      g.ExtraData,
-		GasLimit:   new(big.Int).SetUint64(g.GasLimit),
-		GasUsed:    new(big.Int).SetUint64(g.GasUsed),
+		GasLimit:   g.GasLimit,
+		GasUsed:    g.GasUsed,
 		Difficulty: g.Difficulty,
 		MixDigest:  g.Mixhash,
 		Coinbase:   g.Coinbase,
@@ -252,42 +253,32 @@ func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) {
 	if g.Difficulty == nil {
 		head.Difficulty = params.GenesisDifficulty
 	}
-	return types.NewBlock(head, nil, nil, nil), statedb
+	statedb.Commit(false)
+	statedb.Database().TrieDB().Commit(root, true)
+
+	return types.NewBlock(head, nil, nil, nil)
 }
 
 // Commit writes the block and state of a genesis specification to the database.
 // The block is committed as the canonical head block.
 func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) {
-	block, statedb := g.ToBlock()
+	block := g.ToBlock(db)
 	if block.Number().Sign() != 0 {
 		return nil, fmt.Errorf("can't commit genesis block with number > 0")
 	}
-	if _, err := statedb.CommitTo(db, false); err != nil {
-		return nil, fmt.Errorf("cannot write state: %v", err)
-	}
-	if err := WriteTd(db, block.Hash(), block.NumberU64(), g.Difficulty); err != nil {
-		return nil, err
-	}
-	if err := WriteBlock(db, block); err != nil {
-		return nil, err
-	}
-	if err := WriteBlockReceipts(db, block.Hash(), block.NumberU64(), nil); err != nil {
-		return nil, err
-	}
-	if err := WriteCanonicalHash(db, block.Hash(), block.NumberU64()); err != nil {
-		return nil, err
-	}
-	if err := WriteHeadBlockHash(db, block.Hash()); err != nil {
-		return nil, err
-	}
-	if err := WriteHeadHeaderHash(db, block.Hash()); err != nil {
-		return nil, err
-	}
+	rawdb.WriteTd(db, block.Hash(), block.NumberU64(), g.Difficulty)
+	rawdb.WriteBlock(db, block)
+	rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)
+	rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64())
+	rawdb.WriteHeadBlockHash(db, block.Hash())
+	rawdb.WriteHeadHeaderHash(db, block.Hash())
+
 	config := g.Config
 	if config == nil {
 		config = params.AllEthashProtocolChanges
 	}
-	return block, WriteChainConfig(db, block.Hash(), config)
+	rawdb.WriteChainConfig(db, block.Hash(), config)
+	return block, nil
 }
 
 // MustCommit writes the genesis block and state to db, panicking on error.
diff --git a/core/genesis_test.go b/core/genesis_test.go
index 2fe931b244..2d7f94f8f8 100644
--- a/core/genesis_test.go
+++ b/core/genesis_test.go
@@ -24,17 +24,18 @@ import (
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/params"
 )
 
 func TestDefaultGenesisBlock(t *testing.T) {
-	block, _ := DefaultGenesisBlock().ToBlock()
+	block := DefaultGenesisBlock().ToBlock(nil)
 	if block.Hash() != params.MainnetGenesisHash {
 		t.Errorf("wrong mainnet genesis hash, got %v, want %v", block.Hash(), params.MainnetGenesisHash)
 	}
-	block, _ = DefaultTestnetGenesisBlock().ToBlock()
+	block = DefaultTestnetGenesisBlock().ToBlock(nil)
 	if block.Hash() != params.TestnetGenesisHash {
 		t.Errorf("wrong testnet genesis hash, got %v, want %v", block.Hash(), params.TestnetGenesisHash)
 	}
@@ -118,10 +119,12 @@ func TestSetupGenesis(t *testing.T) {
 				// Commit the 'old' genesis block with Homestead transition at #2.
 				// Advance to block #4, past the homestead transition block of customg.
 				genesis := oldcustomg.MustCommit(db)
-				bc, _ := NewBlockChain(db, oldcustomg.Config, ethash.NewFullFaker(), vm.Config{})
+
+				bc, _ := NewBlockChain(db, nil, oldcustomg.Config, ethash.NewFullFaker(), vm.Config{})
 				defer bc.Stop()
-				bc.SetValidator(bproc{})
-				bc.InsertChain(makeBlockChainWithDiff(genesis, []int{2, 3, 4, 5}, 0))
+
+				blocks, _ := GenerateChain(oldcustomg.Config, genesis, ethash.NewFaker(), db, 4, nil)
+				bc.InsertChain(blocks)
 				bc.CurrentBlock()
 				// This should return a compatibility error.
 				return SetupGenesisBlock(db, &customg)
@@ -138,7 +141,7 @@ func TestSetupGenesis(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		db, _ := ethdb.NewMemDatabase()
+		db := ethdb.NewMemDatabase()
 		config, hash, err := test.fn(db)
 		// Check the return values.
 		if !reflect.DeepEqual(err, test.wantErr) {
@@ -152,7 +155,7 @@ func TestSetupGenesis(t *testing.T) {
 			t.Errorf("%s: returned hash %s, want %s", test.name, hash.Hex(), test.wantHash.Hex())
 		} else if err == nil {
 			// Check database content.
-			stored := GetBlock(db, test.wantHash, 0)
+			stored := rawdb.ReadBlock(db, test.wantHash, 0)
 			if stored.Hash() != test.wantHash {
 				t.Errorf("%s: block in DB has hash %s, want %s", test.name, stored.Hash(), test.wantHash)
 			}
diff --git a/core/headerchain.go b/core/headerchain.go
index 0e5215293d..6e759ed1c1 100644
--- a/core/headerchain.go
+++ b/core/headerchain.go
@@ -23,10 +23,12 @@ import (
 	"math"
 	"math/big"
 	mrand "math/rand"
+	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
@@ -51,8 +53,8 @@ type HeaderChain struct {
 	chainDb       ethdb.Database
 	genesisHeader *types.Header
 
-	currentHeader     *types.Header // Current head of the header chain (may be above the block chain!)
-	currentHeaderHash common.Hash   // Hash of the current head of the header chain (prevent recomputing all the time)
+	currentHeader     atomic.Value // Current head of the header chain (may be above the block chain!)
+	currentHeaderHash common.Hash  // Hash of the current head of the header chain (prevent recomputing all the time)
 
 	headerCache *lru.Cache // Cache for the most recent block headers
 	tdCache     *lru.Cache // Cache for the most recent block total difficulties
@@ -95,26 +97,27 @@ func NewHeaderChain(chainDb ethdb.Database, config *params.ChainConfig, engine c
 		return nil, ErrNoGenesis
 	}
 
-	hc.currentHeader = hc.genesisHeader
-	if head := GetHeadBlockHash(chainDb); head != (common.Hash{}) {
+	hc.currentHeader.Store(hc.genesisHeader)
+	if head := rawdb.ReadHeadBlockHash(chainDb); head != (common.Hash{}) {
 		if chead := hc.GetHeaderByHash(head); chead != nil {
-			hc.currentHeader = chead
+			hc.currentHeader.Store(chead)
 		}
 	}
-	hc.currentHeaderHash = hc.currentHeader.Hash()
+	hc.currentHeaderHash = hc.CurrentHeader().Hash()
 
 	return hc, nil
 }
 
 // GetBlockNumber retrieves the block number belonging to the given hash
 // from the cache or database
-func (hc *HeaderChain) GetBlockNumber(hash common.Hash) uint64 {
+func (hc *HeaderChain) GetBlockNumber(hash common.Hash) *uint64 {
 	if cached, ok := hc.numberCache.Get(hash); ok {
-		return cached.(uint64)
+		number := cached.(uint64)
+		return &number
 	}
-	number := GetBlockNumber(hc.chainDb, hash)
-	if number != missingNumber {
-		hc.numberCache.Add(hash, number)
+	number := rawdb.ReadHeaderNumber(hc.chainDb, hash)
+	if number != nil {
+		hc.numberCache.Add(hash, *number)
 	}
 	return number
 }
@@ -139,27 +142,26 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 	if ptd == nil {
 		return NonStatTy, consensus.ErrUnknownAncestor
 	}
-	localTd := hc.GetTd(hc.currentHeaderHash, hc.currentHeader.Number.Uint64())
+	localTd := hc.GetTd(hc.currentHeaderHash, hc.CurrentHeader().Number.Uint64())
 	externTd := new(big.Int).Add(header.Difficulty, ptd)
 
 	// Irrelevant of the canonical status, write the td and header to the database
 	if err := hc.WriteTd(hash, number, externTd); err != nil {
 		log.Crit("Failed to write header total difficulty", "err", err)
 	}
-	if err := WriteHeader(hc.chainDb, header); err != nil {
-		log.Crit("Failed to write header content", "err", err)
-	}
+	rawdb.WriteHeader(hc.chainDb, header)
+
 	// If the total difficulty is higher than our known, add it to the canonical chain
 	// Second clause in the if statement reduces the vulnerability to selfish mining.
 	// Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf
 	if externTd.Cmp(localTd) > 0 || (externTd.Cmp(localTd) == 0 && mrand.Float64() < 0.5) {
 		// Delete any canonical number assignments above the new head
 		for i := number + 1; ; i++ {
-			hash := GetCanonicalHash(hc.chainDb, i)
+			hash := rawdb.ReadCanonicalHash(hc.chainDb, i)
 			if hash == (common.Hash{}) {
 				break
 			}
-			DeleteCanonicalHash(hc.chainDb, i)
+			rawdb.DeleteCanonicalHash(hc.chainDb, i)
 		}
 		// Overwrite any stale canonical number assignments
 		var (
@@ -167,21 +169,19 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
 			headNumber = header.Number.Uint64() - 1
 			headHeader = hc.GetHeader(headHash, headNumber)
 		)
-		for GetCanonicalHash(hc.chainDb, headNumber) != headHash {
-			WriteCanonicalHash(hc.chainDb, headHash, headNumber)
+		for rawdb.ReadCanonicalHash(hc.chainDb, headNumber) != headHash {
+			rawdb.WriteCanonicalHash(hc.chainDb, headHash, headNumber)
 
 			headHash = headHeader.ParentHash
 			headNumber = headHeader.Number.Uint64() - 1
 			headHeader = hc.GetHeader(headHash, headNumber)
 		}
 		// Extend the canonical chain with the new header
-		if err := WriteCanonicalHash(hc.chainDb, hash, number); err != nil {
-			log.Crit("Failed to insert header number", "err", err)
-		}
-		if err := WriteHeadHeaderHash(hc.chainDb, hash); err != nil {
-			log.Crit("Failed to insert head header hash", "err", err)
-		}
-		hc.currentHeaderHash, hc.currentHeader = hash, types.CopyHeader(header)
+		rawdb.WriteCanonicalHash(hc.chainDb, hash, number)
+		rawdb.WriteHeadHeaderHash(hc.chainDb, hash)
+
+		hc.currentHeaderHash = hash
+		hc.currentHeader.Store(types.CopyHeader(header))
 
 		status = CanonStatTy
 	} else {
@@ -307,6 +307,43 @@ func (hc *HeaderChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []co
 	return chain
 }
 
+// GetAncestor retrieves the Nth ancestor of a given block. It assumes that either the given block or
+// a close ancestor of it is canonical. maxNonCanonical points to a downwards counter limiting the
+// number of blocks to be individually checked before we reach the canonical chain.
+//
+// Note: ancestor == 0 returns the same block, 1 returns its parent and so on.
+func (hc *HeaderChain) GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64) {
+	if ancestor > number {
+		return common.Hash{}, 0
+	}
+	if ancestor == 1 {
+		// in this case it is cheaper to just read the header
+		if header := hc.GetHeader(hash, number); header != nil {
+			return header.ParentHash, number - 1
+		} else {
+			return common.Hash{}, 0
+		}
+	}
+	for ancestor != 0 {
+		if rawdb.ReadCanonicalHash(hc.chainDb, number) == hash {
+			number -= ancestor
+			return rawdb.ReadCanonicalHash(hc.chainDb, number), number
+		}
+		if *maxNonCanonical == 0 {
+			return common.Hash{}, 0
+		}
+		*maxNonCanonical--
+		ancestor--
+		header := hc.GetHeader(hash, number)
+		if header == nil {
+			return common.Hash{}, 0
+		}
+		hash = header.ParentHash
+		number--
+	}
+	return hash, number
+}
+
 // GetTd retrieves a block's total difficulty in the canonical chain from the
 // database by hash and number, caching it if found.
 func (hc *HeaderChain) GetTd(hash common.Hash, number uint64) *big.Int {
@@ -314,7 +351,7 @@ func (hc *HeaderChain) GetTd(hash common.Hash, number uint64) *big.Int {
 	if cached, ok := hc.tdCache.Get(hash); ok {
 		return cached.(*big.Int)
 	}
-	td := GetTd(hc.chainDb, hash, number)
+	td := rawdb.ReadTd(hc.chainDb, hash, number)
 	if td == nil {
 		return nil
 	}
@@ -326,15 +363,17 @@ func (hc *HeaderChain) GetTd(hash common.Hash, number uint64) *big.Int {
 // GetTdByHash retrieves a block's total difficulty in the canonical chain from the
 // database by hash, caching it if found.
 func (hc *HeaderChain) GetTdByHash(hash common.Hash) *big.Int {
-	return hc.GetTd(hash, hc.GetBlockNumber(hash))
+	number := hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
+	return hc.GetTd(hash, *number)
 }
 
 // WriteTd stores a block's total difficulty into the database, also caching it
 // along the way.
 func (hc *HeaderChain) WriteTd(hash common.Hash, number uint64, td *big.Int) error {
-	if err := WriteTd(hc.chainDb, hash, number, td); err != nil {
-		return err
-	}
+	rawdb.WriteTd(hc.chainDb, hash, number, td)
 	hc.tdCache.Add(hash, new(big.Int).Set(td))
 	return nil
 }
@@ -346,7 +385,7 @@ func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header
 	if header, ok := hc.headerCache.Get(hash); ok {
 		return header.(*types.Header)
 	}
-	header := GetHeader(hc.chainDb, hash, number)
+	header := rawdb.ReadHeader(hc.chainDb, hash, number)
 	if header == nil {
 		return nil
 	}
@@ -358,7 +397,11 @@ func (hc *HeaderChain) GetHeader(hash common.Hash, number uint64) *types.Header
 // GetHeaderByHash retrieves a block header from the database by hash, caching it if
 // found.
 func (hc *HeaderChain) GetHeaderByHash(hash common.Hash) *types.Header {
-	return hc.GetHeader(hash, hc.GetBlockNumber(hash))
+	number := hc.GetBlockNumber(hash)
+	if number == nil {
+		return nil
+	}
+	return hc.GetHeader(hash, *number)
 }
 
 // HasHeader checks if a block header is present in the database or not.
@@ -366,14 +409,13 @@ func (hc *HeaderChain) HasHeader(hash common.Hash, number uint64) bool {
 	if hc.numberCache.Contains(hash) || hc.headerCache.Contains(hash) {
 		return true
 	}
-	ok, _ := hc.chainDb.Has(headerKey(hash, number))
-	return ok
+	return rawdb.HasHeader(hc.chainDb, hash, number)
 }
 
 // GetHeaderByNumber retrieves a block header from the database by number,
 // caching it (associated with its hash) if found.
 func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header {
-	hash := GetCanonicalHash(hc.chainDb, number)
+	hash := rawdb.ReadCanonicalHash(hc.chainDb, number)
 	if hash == (common.Hash{}) {
 		return nil
 	}
@@ -383,15 +425,14 @@ func (hc *HeaderChain) GetHeaderByNumber(number uint64) *types.Header {
 // CurrentHeader retrieves the current head header of the canonical chain. The
 // header is retrieved from the HeaderChain's internal cache.
 func (hc *HeaderChain) CurrentHeader() *types.Header {
-	return hc.currentHeader
+	return hc.currentHeader.Load().(*types.Header)
 }
 
 // SetCurrentHeader sets the current head header of the canonical chain.
 func (hc *HeaderChain) SetCurrentHeader(head *types.Header) {
-	if err := WriteHeadHeaderHash(hc.chainDb, head.Hash()); err != nil {
-		log.Crit("Failed to insert head header hash", "err", err)
-	}
-	hc.currentHeader = head
+	rawdb.WriteHeadHeaderHash(hc.chainDb, head.Hash())
+
+	hc.currentHeader.Store(head)
 	hc.currentHeaderHash = head.Hash()
 }
 
@@ -403,37 +444,37 @@ type DeleteCallback func(common.Hash, uint64)
 // will be deleted and the new one set.
 func (hc *HeaderChain) SetHead(head uint64, delFn DeleteCallback) {
 	height := uint64(0)
-	if hc.currentHeader != nil {
-		height = hc.currentHeader.Number.Uint64()
+
+	if hdr := hc.CurrentHeader(); hdr != nil {
+		height = hdr.Number.Uint64()
 	}
 
-	for hc.currentHeader != nil && hc.currentHeader.Number.Uint64() > head {
-		hash := hc.currentHeader.Hash()
-		num := hc.currentHeader.Number.Uint64()
+	for hdr := hc.CurrentHeader(); hdr != nil && hdr.Number.Uint64() > head; hdr = hc.CurrentHeader() {
+		hash := hdr.Hash()
+		num := hdr.Number.Uint64()
 		if delFn != nil {
 			delFn(hash, num)
 		}
-		DeleteHeader(hc.chainDb, hash, num)
-		DeleteTd(hc.chainDb, hash, num)
-		hc.currentHeader = hc.GetHeader(hc.currentHeader.ParentHash, hc.currentHeader.Number.Uint64()-1)
+		rawdb.DeleteHeader(hc.chainDb, hash, num)
+		rawdb.DeleteTd(hc.chainDb, hash, num)
+
+		hc.currentHeader.Store(hc.GetHeader(hdr.ParentHash, hdr.Number.Uint64()-1))
 	}
 	// Roll back the canonical chain numbering
 	for i := height; i > head; i-- {
-		DeleteCanonicalHash(hc.chainDb, i)
+		rawdb.DeleteCanonicalHash(hc.chainDb, i)
 	}
 	// Clear out any stale content from the caches
 	hc.headerCache.Purge()
 	hc.tdCache.Purge()
 	hc.numberCache.Purge()
 
-	if hc.currentHeader == nil {
-		hc.currentHeader = hc.genesisHeader
+	if hc.CurrentHeader() == nil {
+		hc.currentHeader.Store(hc.genesisHeader)
 	}
-	hc.currentHeaderHash = hc.currentHeader.Hash()
+	hc.currentHeaderHash = hc.CurrentHeader().Hash()
 
-	if err := WriteHeadHeaderHash(hc.chainDb, hc.currentHeaderHash); err != nil {
-		log.Crit("Failed to reset head header hash", "err", err)
-	}
+	rawdb.WriteHeadHeaderHash(hc.chainDb, hc.currentHeaderHash)
 }
 
 // SetGenesis sets a new genesis block header for the chain
diff --git a/core/helper_test.go b/core/helper_test.go
index 698a2924cb..051384d854 100644
--- a/core/helper_test.go
+++ b/core/helper_test.go
@@ -18,7 +18,6 @@ package core
 
 import (
 	"container/list"
-	"fmt"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -77,18 +76,11 @@ func (tm *TestManager) Db() ethdb.Database {
 }
 
 func NewTestManager() *TestManager {
-	db, err := ethdb.NewMemDatabase()
-	if err != nil {
-		fmt.Println("Could not create mem-db, failing")
-		return nil
-	}
-
 	testManager := &TestManager{}
 	testManager.eventMux = new(event.TypeMux)
-	testManager.db = db
+	testManager.db = ethdb.NewMemDatabase()
 	// testManager.txPool = NewTxPool(testManager)
 	// testManager.blockChain = NewBlockChain(testManager)
 	// testManager.stateManager = NewStateManager(testManager)
-
 	return testManager
 }
diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go
new file mode 100644
index 0000000000..da54328326
--- /dev/null
+++ b/core/rawdb/accessors_chain.go
@@ -0,0 +1,375 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rawdb
+
+import (
+	"bytes"
+	"encoding/binary"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// ReadCanonicalHash retrieves the hash assigned to a canonical block number.
+func ReadCanonicalHash(db DatabaseReader, number uint64) common.Hash {
+	data, _ := db.Get(headerHashKey(number))
+	if len(data) == 0 {
+		return common.Hash{}
+	}
+	return common.BytesToHash(data)
+}
+
+// WriteCanonicalHash stores the hash assigned to a canonical block number.
+func WriteCanonicalHash(db DatabaseWriter, hash common.Hash, number uint64) {
+	if err := db.Put(headerHashKey(number), hash.Bytes()); err != nil {
+		log.Crit("Failed to store number to hash mapping", "err", err)
+	}
+}
+
+// DeleteCanonicalHash removes the number to hash canonical mapping.
+func DeleteCanonicalHash(db DatabaseDeleter, number uint64) {
+	if err := db.Delete(headerHashKey(number)); err != nil {
+		log.Crit("Failed to delete number to hash mapping", "err", err)
+	}
+}
+
+// ReadHeaderNumber returns the header number assigned to a hash.
+func ReadHeaderNumber(db DatabaseReader, hash common.Hash) *uint64 {
+	data, _ := db.Get(headerNumberKey(hash))
+	if len(data) != 8 {
+		return nil
+	}
+	number := binary.BigEndian.Uint64(data)
+	return &number
+}
+
+// ReadHeadHeaderHash retrieves the hash of the current canonical head header.
+func ReadHeadHeaderHash(db DatabaseReader) common.Hash {
+	data, _ := db.Get(headHeaderKey)
+	if len(data) == 0 {
+		return common.Hash{}
+	}
+	return common.BytesToHash(data)
+}
+
+// WriteHeadHeaderHash stores the hash of the current canonical head header.
+func WriteHeadHeaderHash(db DatabaseWriter, hash common.Hash) {
+	if err := db.Put(headHeaderKey, hash.Bytes()); err != nil {
+		log.Crit("Failed to store last header's hash", "err", err)
+	}
+}
+
+// ReadHeadBlockHash retrieves the hash of the current canonical head block.
+func ReadHeadBlockHash(db DatabaseReader) common.Hash {
+	data, _ := db.Get(headBlockKey)
+	if len(data) == 0 {
+		return common.Hash{}
+	}
+	return common.BytesToHash(data)
+}
+
+// WriteHeadBlockHash stores the head block's hash.
+func WriteHeadBlockHash(db DatabaseWriter, hash common.Hash) {
+	if err := db.Put(headBlockKey, hash.Bytes()); err != nil {
+		log.Crit("Failed to store last block's hash", "err", err)
+	}
+}
+
+// ReadHeadFastBlockHash retrieves the hash of the current fast-sync head block.
+func ReadHeadFastBlockHash(db DatabaseReader) common.Hash {
+	data, _ := db.Get(headFastBlockKey)
+	if len(data) == 0 {
+		return common.Hash{}
+	}
+	return common.BytesToHash(data)
+}
+
+// WriteHeadFastBlockHash stores the hash of the current fast-sync head block.
+func WriteHeadFastBlockHash(db DatabaseWriter, hash common.Hash) {
+	if err := db.Put(headFastBlockKey, hash.Bytes()); err != nil {
+		log.Crit("Failed to store last fast block's hash", "err", err)
+	}
+}
+
+// ReadFastTrieProgress retrieves the number of tries nodes fast synced to allow
+// reporting correct numbers across restarts.
+func ReadFastTrieProgress(db DatabaseReader) uint64 {
+	data, _ := db.Get(fastTrieProgressKey)
+	if len(data) == 0 {
+		return 0
+	}
+	return new(big.Int).SetBytes(data).Uint64()
+}
+
+// WriteFastTrieProgress stores the fast sync trie process counter to support
+// retrieving it across restarts.
+func WriteFastTrieProgress(db DatabaseWriter, count uint64) {
+	if err := db.Put(fastTrieProgressKey, new(big.Int).SetUint64(count).Bytes()); err != nil {
+		log.Crit("Failed to store fast sync trie progress", "err", err)
+	}
+}
+
+// ReadHeaderRLP retrieves a block header in its raw RLP database encoding.
+func ReadHeaderRLP(db DatabaseReader, hash common.Hash, number uint64) rlp.RawValue {
+	data, _ := db.Get(headerKey(number, hash))
+	return data
+}
+
+// HasHeader verifies the existence of a block header corresponding to the hash.
+func HasHeader(db DatabaseReader, hash common.Hash, number uint64) bool {
+	if has, err := db.Has(headerKey(number, hash)); !has || err != nil {
+		return false
+	}
+	return true
+}
+
+// ReadHeader retrieves the block header corresponding to the hash.
+func ReadHeader(db DatabaseReader, hash common.Hash, number uint64) *types.Header {
+	data := ReadHeaderRLP(db, hash, number)
+	if len(data) == 0 {
+		return nil
+	}
+	header := new(types.Header)
+	if err := rlp.Decode(bytes.NewReader(data), header); err != nil {
+		log.Error("Invalid block header RLP", "hash", hash, "err", err)
+		return nil
+	}
+	return header
+}
+
+// WriteHeader stores a block header into the database and also stores the hash-
+// to-number mapping.
+func WriteHeader(db DatabaseWriter, header *types.Header) {
+	// Write the hash -> number mapping
+	var (
+		hash    = header.Hash()
+		number  = header.Number.Uint64()
+		encoded = encodeBlockNumber(number)
+	)
+	key := headerNumberKey(hash)
+	if err := db.Put(key, encoded); err != nil {
+		log.Crit("Failed to store hash to number mapping", "err", err)
+	}
+	// Write the encoded header
+	data, err := rlp.EncodeToBytes(header)
+	if err != nil {
+		log.Crit("Failed to RLP encode header", "err", err)
+	}
+	key = headerKey(number, hash)
+	if err := db.Put(key, data); err != nil {
+		log.Crit("Failed to store header", "err", err)
+	}
+}
+
+// DeleteHeader removes all block header data associated with a hash.
+func DeleteHeader(db DatabaseDeleter, hash common.Hash, number uint64) {
+	if err := db.Delete(headerKey(number, hash)); err != nil {
+		log.Crit("Failed to delete header", "err", err)
+	}
+	if err := db.Delete(headerNumberKey(hash)); err != nil {
+		log.Crit("Failed to delete hash to number mapping", "err", err)
+	}
+}
+
+// ReadBodyRLP retrieves the block body (transactions and uncles) in RLP encoding.
+func ReadBodyRLP(db DatabaseReader, hash common.Hash, number uint64) rlp.RawValue {
+	data, _ := db.Get(blockBodyKey(number, hash))
+	return data
+}
+
+// WriteBodyRLP stores an RLP encoded block body into the database.
+func WriteBodyRLP(db DatabaseWriter, hash common.Hash, number uint64, rlp rlp.RawValue) {
+	if err := db.Put(blockBodyKey(number, hash), rlp); err != nil {
+		log.Crit("Failed to store block body", "err", err)
+	}
+}
+
+// HasBody verifies the existence of a block body corresponding to the hash.
+func HasBody(db DatabaseReader, hash common.Hash, number uint64) bool {
+	if has, err := db.Has(blockBodyKey(number, hash)); !has || err != nil {
+		return false
+	}
+	return true
+}
+
+// ReadBody retrieves the block body corresponding to the hash.
+func ReadBody(db DatabaseReader, hash common.Hash, number uint64) *types.Body {
+	data := ReadBodyRLP(db, hash, number)
+	if len(data) == 0 {
+		return nil
+	}
+	body := new(types.Body)
+	if err := rlp.Decode(bytes.NewReader(data), body); err != nil {
+		log.Error("Invalid block body RLP", "hash", hash, "err", err)
+		return nil
+	}
+	return body
+}
+
+// WriteBody storea a block body into the database.
+func WriteBody(db DatabaseWriter, hash common.Hash, number uint64, body *types.Body) {
+	data, err := rlp.EncodeToBytes(body)
+	if err != nil {
+		log.Crit("Failed to RLP encode body", "err", err)
+	}
+	WriteBodyRLP(db, hash, number, data)
+}
+
+// DeleteBody removes all block body data associated with a hash.
+func DeleteBody(db DatabaseDeleter, hash common.Hash, number uint64) {
+	if err := db.Delete(blockBodyKey(number, hash)); err != nil {
+		log.Crit("Failed to delete block body", "err", err)
+	}
+}
+
+// ReadTd retrieves a block's total difficulty corresponding to the hash.
+func ReadTd(db DatabaseReader, hash common.Hash, number uint64) *big.Int {
+	data, _ := db.Get(headerTDKey(number, hash))
+	if len(data) == 0 {
+		return nil
+	}
+	td := new(big.Int)
+	if err := rlp.Decode(bytes.NewReader(data), td); err != nil {
+		log.Error("Invalid block total difficulty RLP", "hash", hash, "err", err)
+		return nil
+	}
+	return td
+}
+
+// WriteTd stores the total difficulty of a block into the database.
+func WriteTd(db DatabaseWriter, hash common.Hash, number uint64, td *big.Int) {
+	data, err := rlp.EncodeToBytes(td)
+	if err != nil {
+		log.Crit("Failed to RLP encode block total difficulty", "err", err)
+	}
+	if err := db.Put(headerTDKey(number, hash), data); err != nil {
+		log.Crit("Failed to store block total difficulty", "err", err)
+	}
+}
+
+// DeleteTd removes all block total difficulty data associated with a hash.
+func DeleteTd(db DatabaseDeleter, hash common.Hash, number uint64) {
+	if err := db.Delete(headerTDKey(number, hash)); err != nil {
+		log.Crit("Failed to delete block total difficulty", "err", err)
+	}
+}
+
+// ReadReceipts retrieves all the transaction receipts belonging to a block.
+func ReadReceipts(db DatabaseReader, hash common.Hash, number uint64) types.Receipts {
+	// Retrieve the flattened receipt slice
+	data, _ := db.Get(blockReceiptsKey(number, hash))
+	if len(data) == 0 {
+		return nil
+	}
+	// Convert the revceipts from their storage form to their internal representation
+	storageReceipts := []*types.ReceiptForStorage{}
+	if err := rlp.DecodeBytes(data, &storageReceipts); err != nil {
+		log.Error("Invalid receipt array RLP", "hash", hash, "err", err)
+		return nil
+	}
+	receipts := make(types.Receipts, len(storageReceipts))
+	for i, receipt := range storageReceipts {
+		receipts[i] = (*types.Receipt)(receipt)
+	}
+	return receipts
+}
+
+// WriteReceipts stores all the transaction receipts belonging to a block.
+func WriteReceipts(db DatabaseWriter, hash common.Hash, number uint64, receipts types.Receipts) {
+	// Convert the receipts into their storage form and serialize them
+	storageReceipts := make([]*types.ReceiptForStorage, len(receipts))
+	for i, receipt := range receipts {
+		storageReceipts[i] = (*types.ReceiptForStorage)(receipt)
+	}
+	bytes, err := rlp.EncodeToBytes(storageReceipts)
+	if err != nil {
+		log.Crit("Failed to encode block receipts", "err", err)
+	}
+	// Store the flattened receipt slice
+	if err := db.Put(blockReceiptsKey(number, hash), bytes); err != nil {
+		log.Crit("Failed to store block receipts", "err", err)
+	}
+}
+
+// DeleteReceipts removes all receipt data associated with a block hash.
+func DeleteReceipts(db DatabaseDeleter, hash common.Hash, number uint64) {
+	if err := db.Delete(blockReceiptsKey(number, hash)); err != nil {
+		log.Crit("Failed to delete block receipts", "err", err)
+	}
+}
+
+// ReadBlock retrieves an entire block corresponding to the hash, assembling it
+// back from the stored header and body. If either the header or body could not
+// be retrieved nil is returned.
+//
+// Note, due to concurrent download of header and block body the header and thus
+// canonical hash can be stored in the database but the body data not (yet).
+func ReadBlock(db DatabaseReader, hash common.Hash, number uint64) *types.Block {
+	header := ReadHeader(db, hash, number)
+	if header == nil {
+		return nil
+	}
+	body := ReadBody(db, hash, number)
+	if body == nil {
+		return nil
+	}
+	return types.NewBlockWithHeader(header).WithBody(body.Transactions, body.Uncles)
+}
+
+// WriteBlock serializes a block into the database, header and body separately.
+func WriteBlock(db DatabaseWriter, block *types.Block) {
+	WriteBody(db, block.Hash(), block.NumberU64(), block.Body())
+	WriteHeader(db, block.Header())
+}
+
+// DeleteBlock removes all block data associated with a hash.
+func DeleteBlock(db DatabaseDeleter, hash common.Hash, number uint64) {
+	DeleteReceipts(db, hash, number)
+	DeleteHeader(db, hash, number)
+	DeleteBody(db, hash, number)
+	DeleteTd(db, hash, number)
+}
+
+// FindCommonAncestor returns the last common ancestor of two block headers
+func FindCommonAncestor(db DatabaseReader, a, b *types.Header) *types.Header {
+	for bn := b.Number.Uint64(); a.Number.Uint64() > bn; {
+		a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1)
+		if a == nil {
+			return nil
+		}
+	}
+	for an := a.Number.Uint64(); an < b.Number.Uint64(); {
+		b = ReadHeader(db, b.ParentHash, b.Number.Uint64()-1)
+		if b == nil {
+			return nil
+		}
+	}
+	for a.Hash() != b.Hash() {
+		a = ReadHeader(db, a.ParentHash, a.Number.Uint64()-1)
+		if a == nil {
+			return nil
+		}
+		b = ReadHeader(db, b.ParentHash, b.Number.Uint64()-1)
+		if b == nil {
+			return nil
+		}
+	}
+	return a
+}
diff --git a/core/database_util_test.go b/core/rawdb/accessors_chain_test.go
similarity index 58%
rename from core/database_util_test.go
rename to core/rawdb/accessors_chain_test.go
index 36f43cf50a..9ddae6e2b5 100644
--- a/core/database_util_test.go
+++ b/core/rawdb/accessors_chain_test.go
@@ -1,4 +1,4 @@
-// Copyright 2015 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see .
 
-package core
+package rawdb
 
 import (
 	"bytes"
@@ -30,23 +30,21 @@ import (
 
 // Tests block header storage and retrieval operations.
 func TestHeaderStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	// Create a test header to move around the database and make sure it's really new
 	header := &types.Header{Number: big.NewInt(42), Extra: []byte("test header")}
-	if entry := GetHeader(db, header.Hash(), header.Number.Uint64()); entry != nil {
+	if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil {
 		t.Fatalf("Non existent header returned: %v", entry)
 	}
 	// Write and verify the header in the database
-	if err := WriteHeader(db, header); err != nil {
-		t.Fatalf("Failed to write header into database: %v", err)
-	}
-	if entry := GetHeader(db, header.Hash(), header.Number.Uint64()); entry == nil {
+	WriteHeader(db, header)
+	if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry == nil {
 		t.Fatalf("Stored header not found")
 	} else if entry.Hash() != header.Hash() {
 		t.Fatalf("Retrieved header mismatch: have %v, want %v", entry, header)
 	}
-	if entry := GetHeaderRLP(db, header.Hash(), header.Number.Uint64()); entry == nil {
+	if entry := ReadHeaderRLP(db, header.Hash(), header.Number.Uint64()); entry == nil {
 		t.Fatalf("Stored header RLP not found")
 	} else {
 		hasher := sha3.NewKeccak256()
@@ -58,14 +56,14 @@ func TestHeaderStorage(t *testing.T) {
 	}
 	// Delete the header and verify the execution
 	DeleteHeader(db, header.Hash(), header.Number.Uint64())
-	if entry := GetHeader(db, header.Hash(), header.Number.Uint64()); entry != nil {
+	if entry := ReadHeader(db, header.Hash(), header.Number.Uint64()); entry != nil {
 		t.Fatalf("Deleted header returned: %v", entry)
 	}
 }
 
 // Tests block body storage and retrieval operations.
 func TestBodyStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	// Create a test body to move around the database and make sure it's really new
 	body := &types.Body{Uncles: []*types.Header{{Extra: []byte("test header")}}}
@@ -74,19 +72,17 @@ func TestBodyStorage(t *testing.T) {
 	rlp.Encode(hasher, body)
 	hash := common.BytesToHash(hasher.Sum(nil))
 
-	if entry := GetBody(db, hash, 0); entry != nil {
+	if entry := ReadBody(db, hash, 0); entry != nil {
 		t.Fatalf("Non existent body returned: %v", entry)
 	}
 	// Write and verify the body in the database
-	if err := WriteBody(db, hash, 0, body); err != nil {
-		t.Fatalf("Failed to write body into database: %v", err)
-	}
-	if entry := GetBody(db, hash, 0); entry == nil {
+	WriteBody(db, hash, 0, body)
+	if entry := ReadBody(db, hash, 0); entry == nil {
 		t.Fatalf("Stored body not found")
 	} else if types.DeriveSha(types.Transactions(entry.Transactions)) != types.DeriveSha(types.Transactions(body.Transactions)) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(body.Uncles) {
 		t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, body)
 	}
-	if entry := GetBodyRLP(db, hash, 0); entry == nil {
+	if entry := ReadBodyRLP(db, hash, 0); entry == nil {
 		t.Fatalf("Stored body RLP not found")
 	} else {
 		hasher := sha3.NewKeccak256()
@@ -98,14 +94,14 @@ func TestBodyStorage(t *testing.T) {
 	}
 	// Delete the body and verify the execution
 	DeleteBody(db, hash, 0)
-	if entry := GetBody(db, hash, 0); entry != nil {
+	if entry := ReadBody(db, hash, 0); entry != nil {
 		t.Fatalf("Deleted body returned: %v", entry)
 	}
 }
 
 // Tests block storage and retrieval operations.
 func TestBlockStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	// Create a test block to move around the database and make sure it's really new
 	block := types.NewBlockWithHeader(&types.Header{
@@ -114,50 +110,48 @@ func TestBlockStorage(t *testing.T) {
 		TxHash:      types.EmptyRootHash,
 		ReceiptHash: types.EmptyRootHash,
 	})
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Non existent block returned: %v", entry)
 	}
-	if entry := GetHeader(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Non existent header returned: %v", entry)
 	}
-	if entry := GetBody(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Non existent body returned: %v", entry)
 	}
 	// Write and verify the block in the database
-	if err := WriteBlock(db, block); err != nil {
-		t.Fatalf("Failed to write block into database: %v", err)
-	}
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry == nil {
+	WriteBlock(db, block)
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry == nil {
 		t.Fatalf("Stored block not found")
 	} else if entry.Hash() != block.Hash() {
 		t.Fatalf("Retrieved block mismatch: have %v, want %v", entry, block)
 	}
-	if entry := GetHeader(db, block.Hash(), block.NumberU64()); entry == nil {
+	if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry == nil {
 		t.Fatalf("Stored header not found")
 	} else if entry.Hash() != block.Header().Hash() {
 		t.Fatalf("Retrieved header mismatch: have %v, want %v", entry, block.Header())
 	}
-	if entry := GetBody(db, block.Hash(), block.NumberU64()); entry == nil {
+	if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry == nil {
 		t.Fatalf("Stored body not found")
 	} else if types.DeriveSha(types.Transactions(entry.Transactions)) != types.DeriveSha(block.Transactions()) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(block.Uncles()) {
 		t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, block.Body())
 	}
 	// Delete the block and verify the execution
 	DeleteBlock(db, block.Hash(), block.NumberU64())
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Deleted block returned: %v", entry)
 	}
-	if entry := GetHeader(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadHeader(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Deleted header returned: %v", entry)
 	}
-	if entry := GetBody(db, block.Hash(), block.NumberU64()); entry != nil {
+	if entry := ReadBody(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Deleted body returned: %v", entry)
 	}
 }
 
 // Tests that partial block contents don't get reassembled into full blocks.
 func TestPartialBlockStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 	block := types.NewBlockWithHeader(&types.Header{
 		Extra:       []byte("test block"),
 		UncleHash:   types.EmptyUncleHash,
@@ -165,31 +159,24 @@ func TestPartialBlockStorage(t *testing.T) {
 		ReceiptHash: types.EmptyRootHash,
 	})
 	// Store a header and check that it's not recognized as a block
-	if err := WriteHeader(db, block.Header()); err != nil {
-		t.Fatalf("Failed to write header into database: %v", err)
-	}
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry != nil {
+	WriteHeader(db, block.Header())
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Non existent block returned: %v", entry)
 	}
 	DeleteHeader(db, block.Hash(), block.NumberU64())
 
 	// Store a body and check that it's not recognized as a block
-	if err := WriteBody(db, block.Hash(), block.NumberU64(), block.Body()); err != nil {
-		t.Fatalf("Failed to write body into database: %v", err)
-	}
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry != nil {
+	WriteBody(db, block.Hash(), block.NumberU64(), block.Body())
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry != nil {
 		t.Fatalf("Non existent block returned: %v", entry)
 	}
 	DeleteBody(db, block.Hash(), block.NumberU64())
 
 	// Store a header and a body separately and check reassembly
-	if err := WriteHeader(db, block.Header()); err != nil {
-		t.Fatalf("Failed to write header into database: %v", err)
-	}
-	if err := WriteBody(db, block.Hash(), block.NumberU64(), block.Body()); err != nil {
-		t.Fatalf("Failed to write body into database: %v", err)
-	}
-	if entry := GetBlock(db, block.Hash(), block.NumberU64()); entry == nil {
+	WriteHeader(db, block.Header())
+	WriteBody(db, block.Hash(), block.NumberU64(), block.Body())
+
+	if entry := ReadBlock(db, block.Hash(), block.NumberU64()); entry == nil {
 		t.Fatalf("Stored block not found")
 	} else if entry.Hash() != block.Hash() {
 		t.Fatalf("Retrieved block mismatch: have %v, want %v", entry, block)
@@ -198,177 +185,121 @@ func TestPartialBlockStorage(t *testing.T) {
 
 // Tests block total difficulty storage and retrieval operations.
 func TestTdStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	// Create a test TD to move around the database and make sure it's really new
 	hash, td := common.Hash{}, big.NewInt(314)
-	if entry := GetTd(db, hash, 0); entry != nil {
+	if entry := ReadTd(db, hash, 0); entry != nil {
 		t.Fatalf("Non existent TD returned: %v", entry)
 	}
 	// Write and verify the TD in the database
-	if err := WriteTd(db, hash, 0, td); err != nil {
-		t.Fatalf("Failed to write TD into database: %v", err)
-	}
-	if entry := GetTd(db, hash, 0); entry == nil {
+	WriteTd(db, hash, 0, td)
+	if entry := ReadTd(db, hash, 0); entry == nil {
 		t.Fatalf("Stored TD not found")
 	} else if entry.Cmp(td) != 0 {
 		t.Fatalf("Retrieved TD mismatch: have %v, want %v", entry, td)
 	}
 	// Delete the TD and verify the execution
 	DeleteTd(db, hash, 0)
-	if entry := GetTd(db, hash, 0); entry != nil {
+	if entry := ReadTd(db, hash, 0); entry != nil {
 		t.Fatalf("Deleted TD returned: %v", entry)
 	}
 }
 
 // Tests that canonical numbers can be mapped to hashes and retrieved.
 func TestCanonicalMappingStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	// Create a test canonical number and assinged hash to move around
 	hash, number := common.Hash{0: 0xff}, uint64(314)
-	if entry := GetCanonicalHash(db, number); entry != (common.Hash{}) {
+	if entry := ReadCanonicalHash(db, number); entry != (common.Hash{}) {
 		t.Fatalf("Non existent canonical mapping returned: %v", entry)
 	}
 	// Write and verify the TD in the database
-	if err := WriteCanonicalHash(db, hash, number); err != nil {
-		t.Fatalf("Failed to write canonical mapping into database: %v", err)
-	}
-	if entry := GetCanonicalHash(db, number); entry == (common.Hash{}) {
+	WriteCanonicalHash(db, hash, number)
+	if entry := ReadCanonicalHash(db, number); entry == (common.Hash{}) {
 		t.Fatalf("Stored canonical mapping not found")
 	} else if entry != hash {
 		t.Fatalf("Retrieved canonical mapping mismatch: have %v, want %v", entry, hash)
 	}
 	// Delete the TD and verify the execution
 	DeleteCanonicalHash(db, number)
-	if entry := GetCanonicalHash(db, number); entry != (common.Hash{}) {
+	if entry := ReadCanonicalHash(db, number); entry != (common.Hash{}) {
 		t.Fatalf("Deleted canonical mapping returned: %v", entry)
 	}
 }
 
 // Tests that head headers and head blocks can be assigned, individually.
 func TestHeadStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	blockHead := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block header")})
 	blockFull := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block full")})
 	blockFast := types.NewBlockWithHeader(&types.Header{Extra: []byte("test block fast")})
 
 	// Check that no head entries are in a pristine database
-	if entry := GetHeadHeaderHash(db); entry != (common.Hash{}) {
+	if entry := ReadHeadHeaderHash(db); entry != (common.Hash{}) {
 		t.Fatalf("Non head header entry returned: %v", entry)
 	}
-	if entry := GetHeadBlockHash(db); entry != (common.Hash{}) {
+	if entry := ReadHeadBlockHash(db); entry != (common.Hash{}) {
 		t.Fatalf("Non head block entry returned: %v", entry)
 	}
-	if entry := GetHeadFastBlockHash(db); entry != (common.Hash{}) {
+	if entry := ReadHeadFastBlockHash(db); entry != (common.Hash{}) {
 		t.Fatalf("Non fast head block entry returned: %v", entry)
 	}
 	// Assign separate entries for the head header and block
-	if err := WriteHeadHeaderHash(db, blockHead.Hash()); err != nil {
-		t.Fatalf("Failed to write head header hash: %v", err)
-	}
-	if err := WriteHeadBlockHash(db, blockFull.Hash()); err != nil {
-		t.Fatalf("Failed to write head block hash: %v", err)
-	}
-	if err := WriteHeadFastBlockHash(db, blockFast.Hash()); err != nil {
-		t.Fatalf("Failed to write fast head block hash: %v", err)
-	}
+	WriteHeadHeaderHash(db, blockHead.Hash())
+	WriteHeadBlockHash(db, blockFull.Hash())
+	WriteHeadFastBlockHash(db, blockFast.Hash())
+
 	// Check that both heads are present, and different (i.e. two heads maintained)
-	if entry := GetHeadHeaderHash(db); entry != blockHead.Hash() {
+	if entry := ReadHeadHeaderHash(db); entry != blockHead.Hash() {
 		t.Fatalf("Head header hash mismatch: have %v, want %v", entry, blockHead.Hash())
 	}
-	if entry := GetHeadBlockHash(db); entry != blockFull.Hash() {
+	if entry := ReadHeadBlockHash(db); entry != blockFull.Hash() {
 		t.Fatalf("Head block hash mismatch: have %v, want %v", entry, blockFull.Hash())
 	}
-	if entry := GetHeadFastBlockHash(db); entry != blockFast.Hash() {
+	if entry := ReadHeadFastBlockHash(db); entry != blockFast.Hash() {
 		t.Fatalf("Fast head block hash mismatch: have %v, want %v", entry, blockFast.Hash())
 	}
 }
 
-// Tests that positional lookup metadata can be stored and retrieved.
-func TestLookupStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-
-	tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), big.NewInt(1111), big.NewInt(11111), []byte{0x11, 0x11, 0x11})
-	tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(222), big.NewInt(2222), big.NewInt(22222), []byte{0x22, 0x22, 0x22})
-	tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(333), big.NewInt(3333), big.NewInt(33333), []byte{0x33, 0x33, 0x33})
-	txs := []*types.Transaction{tx1, tx2, tx3}
-
-	block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil)
-
-	// Check that no transactions entries are in a pristine database
-	for i, tx := range txs {
-		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn != nil {
-			t.Fatalf("tx #%d [%x]: non existent transaction returned: %v", i, tx.Hash(), txn)
-		}
-	}
-	// Insert all the transactions into the database, and verify contents
-	if err := WriteBlock(db, block); err != nil {
-		t.Fatalf("failed to write block contents: %v", err)
-	}
-	if err := WriteTxLookupEntries(db, block); err != nil {
-		t.Fatalf("failed to write transactions: %v", err)
-	}
-	for i, tx := range txs {
-		if txn, hash, number, index := GetTransaction(db, tx.Hash()); txn == nil {
-			t.Fatalf("tx #%d [%x]: transaction not found", i, tx.Hash())
-		} else {
-			if hash != block.Hash() || number != block.NumberU64() || index != uint64(i) {
-				t.Fatalf("tx #%d [%x]: positional metadata mismatch: have %x/%d/%d, want %x/%v/%v", i, tx.Hash(), hash, number, index, block.Hash(), block.NumberU64(), i)
-			}
-			if tx.String() != txn.String() {
-				t.Fatalf("tx #%d [%x]: transaction mismatch: have %v, want %v", i, tx.Hash(), txn, tx)
-			}
-		}
-	}
-	// Delete the transactions and check purge
-	for i, tx := range txs {
-		DeleteTxLookupEntry(db, tx.Hash())
-		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn != nil {
-			t.Fatalf("tx #%d [%x]: deleted transaction returned: %v", i, tx.Hash(), txn)
-		}
-	}
-}
-
 // Tests that receipts associated with a single block can be stored and retrieved.
 func TestBlockReceiptStorage(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 
 	receipt1 := &types.Receipt{
 		Status:            types.ReceiptStatusFailed,
-		CumulativeGasUsed: big.NewInt(1),
+		CumulativeGasUsed: 1,
 		Logs: []*types.Log{
 			{Address: common.BytesToAddress([]byte{0x11})},
 			{Address: common.BytesToAddress([]byte{0x01, 0x11})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x11, 0x11}),
 		ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}),
-		GasUsed:         big.NewInt(111111),
+		GasUsed:         111111,
 	}
 	receipt2 := &types.Receipt{
 		PostState:         common.Hash{2}.Bytes(),
-		CumulativeGasUsed: big.NewInt(2),
+		CumulativeGasUsed: 2,
 		Logs: []*types.Log{
 			{Address: common.BytesToAddress([]byte{0x22})},
 			{Address: common.BytesToAddress([]byte{0x02, 0x22})},
 		},
 		TxHash:          common.BytesToHash([]byte{0x22, 0x22}),
 		ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}),
-		GasUsed:         big.NewInt(222222),
+		GasUsed:         222222,
 	}
 	receipts := []*types.Receipt{receipt1, receipt2}
 
 	// Check that no receipt entries are in a pristine database
 	hash := common.BytesToHash([]byte{0x03, 0x14})
-	if rs := GetBlockReceipts(db, hash, 0); len(rs) != 0 {
+	if rs := ReadReceipts(db, hash, 0); len(rs) != 0 {
 		t.Fatalf("non existent receipts returned: %v", rs)
 	}
 	// Insert the receipt slice into the database and check presence
-	if err := WriteBlockReceipts(db, hash, 0, receipts); err != nil {
-		t.Fatalf("failed to write block receipts: %v", err)
-	}
-	if rs := GetBlockReceipts(db, hash, 0); len(rs) == 0 {
+	WriteReceipts(db, hash, 0, receipts)
+	if rs := ReadReceipts(db, hash, 0); len(rs) == 0 {
 		t.Fatalf("no receipts returned")
 	} else {
 		for i := 0; i < len(receipts); i++ {
@@ -381,8 +312,8 @@ func TestBlockReceiptStorage(t *testing.T) {
 		}
 	}
 	// Delete the receipt slice and check purge
-	DeleteBlockReceipts(db, hash, 0)
-	if rs := GetBlockReceipts(db, hash, 0); len(rs) != 0 {
+	DeleteReceipts(db, hash, 0)
+	if rs := ReadReceipts(db, hash, 0); len(rs) != 0 {
 		t.Fatalf("deleted receipts returned: %v", rs)
 	}
 }
diff --git a/core/rawdb/accessors_indexes.go b/core/rawdb/accessors_indexes.go
new file mode 100644
index 0000000000..4ff7e5bd35
--- /dev/null
+++ b/core/rawdb/accessors_indexes.go
@@ -0,0 +1,107 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rawdb
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// ReadTxLookupEntry retrieves the positional metadata associated with a transaction
+// hash to allow retrieving the transaction or receipt by hash.
+func ReadTxLookupEntry(db DatabaseReader, hash common.Hash) (common.Hash, uint64, uint64) {
+	data, _ := db.Get(txLookupKey(hash))
+	if len(data) == 0 {
+		return common.Hash{}, 0, 0
+	}
+	var entry TxLookupEntry
+	if err := rlp.DecodeBytes(data, &entry); err != nil {
+		log.Error("Invalid transaction lookup entry RLP", "hash", hash, "err", err)
+		return common.Hash{}, 0, 0
+	}
+	return entry.BlockHash, entry.BlockIndex, entry.Index
+}
+
+// WriteTxLookupEntries stores a positional metadata for every transaction from
+// a block, enabling hash based transaction and receipt lookups.
+func WriteTxLookupEntries(db DatabaseWriter, block *types.Block) {
+	for i, tx := range block.Transactions() {
+		entry := TxLookupEntry{
+			BlockHash:  block.Hash(),
+			BlockIndex: block.NumberU64(),
+			Index:      uint64(i),
+		}
+		data, err := rlp.EncodeToBytes(entry)
+		if err != nil {
+			log.Crit("Failed to encode transaction lookup entry", "err", err)
+		}
+		if err := db.Put(txLookupKey(tx.Hash()), data); err != nil {
+			log.Crit("Failed to store transaction lookup entry", "err", err)
+		}
+	}
+}
+
+// DeleteTxLookupEntry removes all transaction data associated with a hash.
+func DeleteTxLookupEntry(db DatabaseDeleter, hash common.Hash) {
+	db.Delete(txLookupKey(hash))
+}
+
+// ReadTransaction retrieves a specific transaction from the database, along with
+// its added positional metadata.
+func ReadTransaction(db DatabaseReader, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
+	blockHash, blockNumber, txIndex := ReadTxLookupEntry(db, hash)
+	if blockHash == (common.Hash{}) {
+		return nil, common.Hash{}, 0, 0
+	}
+	body := ReadBody(db, blockHash, blockNumber)
+	if body == nil || len(body.Transactions) <= int(txIndex) {
+		log.Error("Transaction referenced missing", "number", blockNumber, "hash", blockHash, "index", txIndex)
+		return nil, common.Hash{}, 0, 0
+	}
+	return body.Transactions[txIndex], blockHash, blockNumber, txIndex
+}
+
+// ReadReceipt retrieves a specific transaction receipt from the database, along with
+// its added positional metadata.
+func ReadReceipt(db DatabaseReader, hash common.Hash) (*types.Receipt, common.Hash, uint64, uint64) {
+	blockHash, blockNumber, receiptIndex := ReadTxLookupEntry(db, hash)
+	if blockHash == (common.Hash{}) {
+		return nil, common.Hash{}, 0, 0
+	}
+	receipts := ReadReceipts(db, blockHash, blockNumber)
+	if len(receipts) <= int(receiptIndex) {
+		log.Error("Receipt refereced missing", "number", blockNumber, "hash", blockHash, "index", receiptIndex)
+		return nil, common.Hash{}, 0, 0
+	}
+	return receipts[receiptIndex], blockHash, blockNumber, receiptIndex
+}
+
+// ReadBloomBits retrieves the compressed bloom bit vector belonging to the given
+// section and bit index from the.
+func ReadBloomBits(db DatabaseReader, bit uint, section uint64, head common.Hash) ([]byte, error) {
+	return db.Get(bloomBitsKey(bit, section, head))
+}
+
+// WriteBloomBits stores the compressed bloom bits vector belonging to the given
+// section and bit index.
+func WriteBloomBits(db DatabaseWriter, bit uint, section uint64, head common.Hash, bits []byte) {
+	if err := db.Put(bloomBitsKey(bit, section, head), bits); err != nil {
+		log.Crit("Failed to store bloom bits", "err", err)
+	}
+}
diff --git a/core/rawdb/accessors_indexes_test.go b/core/rawdb/accessors_indexes_test.go
new file mode 100644
index 0000000000..d9c10e1490
--- /dev/null
+++ b/core/rawdb/accessors_indexes_test.go
@@ -0,0 +1,68 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rawdb
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
+)
+
+// Tests that positional lookup metadata can be stored and retrieved.
+func TestLookupStorage(t *testing.T) {
+	db := ethdb.NewMemDatabase()
+
+	tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11})
+	tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(222), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22})
+	tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33})
+	txs := []*types.Transaction{tx1, tx2, tx3}
+
+	block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil)
+
+	// Check that no transactions entries are in a pristine database
+	for i, tx := range txs {
+		if txn, _, _, _ := ReadTransaction(db, tx.Hash()); txn != nil {
+			t.Fatalf("tx #%d [%x]: non existent transaction returned: %v", i, tx.Hash(), txn)
+		}
+	}
+	// Insert all the transactions into the database, and verify contents
+	WriteBlock(db, block)
+	WriteTxLookupEntries(db, block)
+
+	for i, tx := range txs {
+		if txn, hash, number, index := ReadTransaction(db, tx.Hash()); txn == nil {
+			t.Fatalf("tx #%d [%x]: transaction not found", i, tx.Hash())
+		} else {
+			if hash != block.Hash() || number != block.NumberU64() || index != uint64(i) {
+				t.Fatalf("tx #%d [%x]: positional metadata mismatch: have %x/%d/%d, want %x/%v/%v", i, tx.Hash(), hash, number, index, block.Hash(), block.NumberU64(), i)
+			}
+			if tx.Hash() != txn.Hash() {
+				t.Fatalf("tx #%d [%x]: transaction mismatch: have %v, want %v", i, tx.Hash(), txn, tx)
+			}
+		}
+	}
+	// Delete the transactions and check purge
+	for i, tx := range txs {
+		DeleteTxLookupEntry(db, tx.Hash())
+		if txn, _, _, _ := ReadTransaction(db, tx.Hash()); txn != nil {
+			t.Fatalf("tx #%d [%x]: deleted transaction returned: %v", i, tx.Hash(), txn)
+		}
+	}
+}
diff --git a/core/rawdb/accessors_metadata.go b/core/rawdb/accessors_metadata.go
new file mode 100644
index 0000000000..514328e87b
--- /dev/null
+++ b/core/rawdb/accessors_metadata.go
@@ -0,0 +1,90 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package rawdb
+
+import (
+	"encoding/json"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// ReadDatabaseVersion retrieves the version number of the database.
+func ReadDatabaseVersion(db DatabaseReader) int {
+	var version int
+
+	enc, _ := db.Get(databaseVerisionKey)
+	rlp.DecodeBytes(enc, &version)
+
+	return version
+}
+
+// WriteDatabaseVersion stores the version number of the database
+func WriteDatabaseVersion(db DatabaseWriter, version int) {
+	enc, _ := rlp.EncodeToBytes(version)
+	if err := db.Put(databaseVerisionKey, enc); err != nil {
+		log.Crit("Failed to store the database version", "err", err)
+	}
+}
+
+// ReadChainConfig retrieves the consensus settings based on the given genesis hash.
+func ReadChainConfig(db DatabaseReader, hash common.Hash) *params.ChainConfig {
+	data, _ := db.Get(configKey(hash))
+	if len(data) == 0 {
+		return nil
+	}
+	var config params.ChainConfig
+	if err := json.Unmarshal(data, &config); err != nil {
+		log.Error("Invalid chain config JSON", "hash", hash, "err", err)
+		return nil
+	}
+	return &config
+}
+
+// WriteChainConfig writes the chain config settings to the database.
+func WriteChainConfig(db DatabaseWriter, hash common.Hash, cfg *params.ChainConfig) {
+	if cfg == nil {
+		return
+	}
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		log.Crit("Failed to JSON encode chain config", "err", err)
+	}
+	if err := db.Put(configKey(hash), data); err != nil {
+		log.Crit("Failed to store chain config", "err", err)
+	}
+}
+
+// ReadPreimage retrieves a single preimage of the provided hash.
+func ReadPreimage(db DatabaseReader, hash common.Hash) []byte {
+	data, _ := db.Get(preimageKey(hash))
+	return data
+}
+
+// WritePreimages writes the provided set of preimages to the database. `number` is the
+// current block number, and is used for debug messages only.
+func WritePreimages(db DatabaseWriter, number uint64, preimages map[common.Hash][]byte) {
+	for hash, preimage := range preimages {
+		if err := db.Put(preimageKey(hash), preimage); err != nil {
+			log.Crit("Failed to store trie preimage", "err", err)
+		}
+	}
+	preimageCounter.Inc(int64(len(preimages)))
+	preimageHitCounter.Inc(int64(len(preimages)))
+}
diff --git a/whisper/whisperv2/doc.go b/core/rawdb/interfaces.go
similarity index 50%
rename from whisper/whisperv2/doc.go
rename to core/rawdb/interfaces.go
index 7252f44b10..3bdf55124a 100644
--- a/whisper/whisperv2/doc.go
+++ b/core/rawdb/interfaces.go
@@ -1,4 +1,4 @@
-// Copyright 2014 The go-ethereum Authors
+// Copyright 2018 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -14,19 +14,20 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see .
 
-/*
-Package whisper implements the Whisper PoC-1.
+package rawdb
 
-(https://github.com/ethereum/wiki/wiki/Whisper-PoC-1-Protocol-Spec)
+// DatabaseReader wraps the Has and Get method of a backing data store.
+type DatabaseReader interface {
+	Has(key []byte) (bool, error)
+	Get(key []byte) ([]byte, error)
+}
 
-Whisper combines aspects of both DHTs and datagram messaging systems (e.g. UDP).
-As such it may be likened and compared to both, not dissimilar to the
-matter/energy duality (apologies to physicists for the blatant abuse of a
-fundamental and beautiful natural principle).
+// DatabaseWriter wraps the Put method of a backing data store.
+type DatabaseWriter interface {
+	Put(key []byte, value []byte) error
+}
 
-Whisper is a pure identity-based messaging system. Whisper provides a low-level
-(non-application-specific) but easily-accessible API without being based upon
-or prejudiced by the low-level hardware attributes and characteristics,
-particularly the notion of singular endpoints.
-*/
-package whisperv2
+// DatabaseDeleter wraps the Delete method of a backing data store.
+type DatabaseDeleter interface {
+	Delete(key []byte) error
+}
diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go
new file mode 100644
index 0000000000..ef597ef309
--- /dev/null
+++ b/core/rawdb/schema.go
@@ -0,0 +1,134 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// Package rawdb contains a collection of low level database accessors.
+package rawdb
+
+import (
+	"encoding/binary"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+// The fields below define the low level database schema prefixing.
+var (
+	// databaseVerisionKey tracks the current database version.
+	databaseVerisionKey = []byte("DatabaseVersion")
+
+	// headHeaderKey tracks the latest know header's hash.
+	headHeaderKey = []byte("LastHeader")
+
+	// headBlockKey tracks the latest know full block's hash.
+	headBlockKey = []byte("LastBlock")
+
+	// headFastBlockKey tracks the latest known incomplete block's hash duirng fast sync.
+	headFastBlockKey = []byte("LastFast")
+
+	// fastTrieProgressKey tracks the number of trie entries imported during fast sync.
+	fastTrieProgressKey = []byte("TrieSync")
+
+	// Data item prefixes (use single byte to avoid mixing data types, avoid `i`, used for indexes).
+	headerPrefix       = []byte("h") // headerPrefix + num (uint64 big endian) + hash -> header
+	headerTDSuffix     = []byte("t") // headerPrefix + num (uint64 big endian) + hash + headerTDSuffix -> td
+	headerHashSuffix   = []byte("n") // headerPrefix + num (uint64 big endian) + headerHashSuffix -> hash
+	headerNumberPrefix = []byte("H") // headerNumberPrefix + hash -> num (uint64 big endian)
+
+	blockBodyPrefix     = []byte("b") // blockBodyPrefix + num (uint64 big endian) + hash -> block body
+	blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts
+
+	txLookupPrefix  = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata
+	bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits
+
+	preimagePrefix = []byte("secure-key-")      // preimagePrefix + hash -> preimage
+	configPrefix   = []byte("ethereum-config-") // config prefix for the db
+
+	// Chain index prefixes (use `i` + single byte to avoid mixing data types).
+	BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress
+
+	preimageCounter    = metrics.NewRegisteredCounter("db/preimage/total", nil)
+	preimageHitCounter = metrics.NewRegisteredCounter("db/preimage/hits", nil)
+)
+
+// TxLookupEntry is a positional metadata to help looking up the data content of
+// a transaction or receipt given only its hash.
+type TxLookupEntry struct {
+	BlockHash  common.Hash
+	BlockIndex uint64
+	Index      uint64
+}
+
+// encodeBlockNumber encodes a block number as big endian uint64
+func encodeBlockNumber(number uint64) []byte {
+	enc := make([]byte, 8)
+	binary.BigEndian.PutUint64(enc, number)
+	return enc
+}
+
+// headerKey = headerPrefix + num (uint64 big endian) + hash
+func headerKey(number uint64, hash common.Hash) []byte {
+	return append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
+}
+
+// headerTDKey = headerPrefix + num (uint64 big endian) + hash + headerTDSuffix
+func headerTDKey(number uint64, hash common.Hash) []byte {
+	return append(headerKey(number, hash), headerTDSuffix...)
+}
+
+// headerHashKey = headerPrefix + num (uint64 big endian) + headerHashSuffix
+func headerHashKey(number uint64) []byte {
+	return append(append(headerPrefix, encodeBlockNumber(number)...), headerHashSuffix...)
+}
+
+// headerNumberKey = headerNumberPrefix + hash
+func headerNumberKey(hash common.Hash) []byte {
+	return append(headerNumberPrefix, hash.Bytes()...)
+}
+
+// blockBodyKey = blockBodyPrefix + num (uint64 big endian) + hash
+func blockBodyKey(number uint64, hash common.Hash) []byte {
+	return append(append(blockBodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
+}
+
+// blockReceiptsKey = blockReceiptsPrefix + num (uint64 big endian) + hash
+func blockReceiptsKey(number uint64, hash common.Hash) []byte {
+	return append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...)
+}
+
+// txLookupKey = txLookupPrefix + hash
+func txLookupKey(hash common.Hash) []byte {
+	return append(txLookupPrefix, hash.Bytes()...)
+}
+
+// bloomBitsKey = bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash
+func bloomBitsKey(bit uint, section uint64, hash common.Hash) []byte {
+	key := append(append(bloomBitsPrefix, make([]byte, 10)...), hash.Bytes()...)
+
+	binary.BigEndian.PutUint16(key[1:], uint16(bit))
+	binary.BigEndian.PutUint64(key[3:], section)
+
+	return key
+}
+
+// preimageKey = preimagePrefix + hash
+func preimageKey(hash common.Hash) []byte {
+	return append(preimagePrefix, hash.Bytes()...)
+}
+
+// configKey = configPrefix + hash
+func configKey(hash common.Hash) []byte {
+	return append(configPrefix, hash.Bytes()...)
+}
diff --git a/core/state/database.go b/core/state/database.go
index 946625e76e..c1b630991c 100644
--- a/core/state/database.go
+++ b/core/state/database.go
@@ -26,7 +26,7 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 )
 
-// Trie cache generation limit after which to evic trie nodes from memory.
+// Trie cache generation limit after which to evict trie nodes from memory.
 var MaxTrieCacheGen = uint16(120)
 
 const (
@@ -40,16 +40,23 @@ const (
 
 // Database wraps access to tries and contract code.
 type Database interface {
-	// Accessing tries:
 	// OpenTrie opens the main account trie.
-	// OpenStorageTrie opens the storage trie of an account.
 	OpenTrie(root common.Hash) (Trie, error)
+
+	// OpenStorageTrie opens the storage trie of an account.
 	OpenStorageTrie(addrHash, root common.Hash) (Trie, error)
-	// Accessing contract code:
-	ContractCode(addrHash, codeHash common.Hash) ([]byte, error)
-	ContractCodeSize(addrHash, codeHash common.Hash) (int, error)
+
 	// CopyTrie returns an independent copy of the given trie.
 	CopyTrie(Trie) Trie
+
+	// ContractCode retrieves a particular contract's code.
+	ContractCode(addrHash, codeHash common.Hash) ([]byte, error)
+
+	// ContractCodeSize retrieves a particular contracts code's size.
+	ContractCodeSize(addrHash, codeHash common.Hash) (int, error)
+
+	// TrieDB retrieves the low level trie database used for data storage.
+	TrieDB() *trie.Database
 }
 
 // Trie is a Ethereum Merkle Trie.
@@ -57,26 +64,33 @@ type Trie interface {
 	TryGet(key []byte) ([]byte, error)
 	TryUpdate(key, value []byte) error
 	TryDelete(key []byte) error
-	CommitTo(trie.DatabaseWriter) (common.Hash, error)
+	Commit(onleaf trie.LeafCallback) (common.Hash, error)
 	Hash() common.Hash
 	NodeIterator(startKey []byte) trie.NodeIterator
 	GetKey([]byte) []byte // TODO(fjl): remove this when SecureTrie is removed
+	Prove(key []byte, fromLevel uint, proofDb ethdb.Putter) error
 }
 
 // NewDatabase creates a backing store for state. The returned database is safe for
-// concurrent use and retains cached trie nodes in memory.
+// concurrent use and retains cached trie nodes in memory. The pool is an optional
+// intermediate trie-node memory pool between the low level storage layer and the
+// high level trie abstraction.
 func NewDatabase(db ethdb.Database) Database {
 	csc, _ := lru.New(codeSizeCacheSize)
-	return &cachingDB{db: db, codeSizeCache: csc}
+	return &cachingDB{
+		db:            trie.NewDatabase(db),
+		codeSizeCache: csc,
+	}
 }
 
 type cachingDB struct {
-	db            ethdb.Database
+	db            *trie.Database
 	mu            sync.Mutex
 	pastTries     []*trie.SecureTrie
 	codeSizeCache *lru.Cache
 }
 
+// OpenTrie opens the main account trie.
 func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {
 	db.mu.Lock()
 	defer db.mu.Unlock()
@@ -105,10 +119,12 @@ func (db *cachingDB) pushTrie(t *trie.SecureTrie) {
 	}
 }
 
+// OpenStorageTrie opens the storage trie of an account.
 func (db *cachingDB) OpenStorageTrie(addrHash, root common.Hash) (Trie, error) {
 	return trie.NewSecure(root, db.db, 0)
 }
 
+// CopyTrie returns an independent copy of the given trie.
 func (db *cachingDB) CopyTrie(t Trie) Trie {
 	switch t := t.(type) {
 	case cachedTrie:
@@ -120,35 +136,43 @@ func (db *cachingDB) CopyTrie(t Trie) Trie {
 	}
 }
 
+// ContractCode retrieves a particular contract's code.
 func (db *cachingDB) ContractCode(addrHash, codeHash common.Hash) ([]byte, error) {
-	code, err := db.db.Get(codeHash[:])
+	code, err := db.db.Node(codeHash)
 	if err == nil {
 		db.codeSizeCache.Add(codeHash, len(code))
 	}
 	return code, err
 }
 
+// ContractCodeSize retrieves a particular contracts code's size.
 func (db *cachingDB) ContractCodeSize(addrHash, codeHash common.Hash) (int, error) {
 	if cached, ok := db.codeSizeCache.Get(codeHash); ok {
 		return cached.(int), nil
 	}
 	code, err := db.ContractCode(addrHash, codeHash)
-	if err == nil {
-		db.codeSizeCache.Add(codeHash, len(code))
-	}
 	return len(code), err
 }
 
+// TrieDB retrieves any intermediate trie-node caching layer.
+func (db *cachingDB) TrieDB() *trie.Database {
+	return db.db
+}
+
 // cachedTrie inserts its trie into a cachingDB on commit.
 type cachedTrie struct {
 	*trie.SecureTrie
 	db *cachingDB
 }
 
-func (m cachedTrie) CommitTo(dbw trie.DatabaseWriter) (common.Hash, error) {
-	root, err := m.SecureTrie.CommitTo(dbw)
+func (m cachedTrie) Commit(onleaf trie.LeafCallback) (common.Hash, error) {
+	root, err := m.SecureTrie.Commit(onleaf)
 	if err == nil {
 		m.db.pushTrie(m.SecureTrie)
 	}
 	return root, err
 }
+
+func (m cachedTrie) Prove(key []byte, fromLevel uint, proofDb ethdb.Putter) error {
+	return m.SecureTrie.Prove(key, fromLevel, proofDb)
+}
diff --git a/core/state/dump.go b/core/state/dump.go
index 46e612850a..072dbbf053 100644
--- a/core/state/dump.go
+++ b/core/state/dump.go
@@ -53,7 +53,7 @@ func (self *StateDB) RawDump() Dump {
 			panic(err)
 		}
 
-		obj := newObject(nil, common.BytesToAddress(addr), data, nil)
+		obj := newObject(nil, common.BytesToAddress(addr), data)
 		account := DumpAccount{
 			Balance:  data.Balance.String(),
 			Nonce:    data.Nonce,
diff --git a/core/state/iterator_test.go b/core/state/iterator_test.go
index ff66ba7a94..9e46c851cd 100644
--- a/core/state/iterator_test.go
+++ b/core/state/iterator_test.go
@@ -21,12 +21,13 @@ import (
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 )
 
 // Tests that the node iterator indeed walks over the entire database contents.
 func TestNodeIteratorCoverage(t *testing.T) {
 	// Create some arbitrary test state to iterate
-	db, mem, root, _ := makeTestState()
+	db, root, _ := makeTestState()
 
 	state, err := New(root, db)
 	if err != nil {
@@ -39,14 +40,18 @@ func TestNodeIteratorCoverage(t *testing.T) {
 			hashes[it.Hash] = struct{}{}
 		}
 	}
-
-	// Cross check the hashes and the database itself
+	// Cross check the iterated hashes and the database/nodepool content
 	for hash := range hashes {
-		if _, err := mem.Get(hash.Bytes()); err != nil {
-			t.Errorf("failed to retrieve reported node %x: %v", hash, err)
+		if _, err := db.TrieDB().Node(hash); err != nil {
+			t.Errorf("failed to retrieve reported node %x", hash)
 		}
 	}
-	for _, key := range mem.Keys() {
+	for _, hash := range db.TrieDB().Nodes() {
+		if _, ok := hashes[hash]; !ok {
+			t.Errorf("state entry not reported %x", hash)
+		}
+	}
+	for _, key := range db.TrieDB().DiskDB().(*ethdb.MemDatabase).Keys() {
 		if bytes.HasPrefix(key, []byte("secure-key-")) {
 			continue
 		}
diff --git a/core/state/journal.go b/core/state/journal.go
index ddc819fe5f..a03ca57dbc 100644
--- a/core/state/journal.go
+++ b/core/state/journal.go
@@ -22,11 +22,67 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+// journalEntry is a modification entry in the state change journal that can be
+// reverted on demand.
 type journalEntry interface {
-	undo(*StateDB)
+	// revert undoes the changes introduced by this journal entry.
+	revert(*StateDB)
+
+	// dirtied returns the Ethereum address modified by this journal entry.
+	dirtied() *common.Address
 }
 
-type journal []journalEntry
+// journal contains the list of state modifications applied since the last state
+// commit. These are tracked to be able to be reverted in case of an execution
+// exception or revertal request.
+type journal struct {
+	entries []journalEntry         // Current changes tracked by the journal
+	dirties map[common.Address]int // Dirty accounts and the number of changes
+}
+
+// newJournal create a new initialized journal.
+func newJournal() *journal {
+	return &journal{
+		dirties: make(map[common.Address]int),
+	}
+}
+
+// append inserts a new modification entry to the end of the change journal.
+func (j *journal) append(entry journalEntry) {
+	j.entries = append(j.entries, entry)
+	if addr := entry.dirtied(); addr != nil {
+		j.dirties[*addr]++
+	}
+}
+
+// revert undoes a batch of journalled modifications along with any reverted
+// dirty handling too.
+func (j *journal) revert(statedb *StateDB, snapshot int) {
+	for i := len(j.entries) - 1; i >= snapshot; i-- {
+		// Undo the changes made by the operation
+		j.entries[i].revert(statedb)
+
+		// Drop any dirty tracking induced by the change
+		if addr := j.entries[i].dirtied(); addr != nil {
+			if j.dirties[*addr]--; j.dirties[*addr] == 0 {
+				delete(j.dirties, *addr)
+			}
+		}
+	}
+	j.entries = j.entries[:snapshot]
+}
+
+// dirty explicitly sets an address to dirty, even if the change entries would
+// otherwise suggest it as clean. This method is an ugly hack to handle the RIPEMD
+// precompile consensus exception.
+func (j *journal) dirty(addr common.Address) {
+	j.dirties[addr]++
+}
+
+// length returns the current number of entries in the journal.
+func (j *journal) length() int {
+	return len(j.entries)
+}
 
 type (
 	// Changes to the account trie.
@@ -62,7 +118,7 @@ type (
 
 	// Changes to other state values.
 	refundChange struct {
-		prev *big.Int
+		prev uint64
 	}
 	addLogChange struct {
 		txhash common.Hash
@@ -77,16 +133,24 @@ type (
 	}
 )
 
-func (ch createObjectChange) undo(s *StateDB) {
+func (ch createObjectChange) revert(s *StateDB) {
 	delete(s.stateObjects, *ch.account)
 	delete(s.stateObjectsDirty, *ch.account)
 }
 
-func (ch resetObjectChange) undo(s *StateDB) {
+func (ch createObjectChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch resetObjectChange) revert(s *StateDB) {
 	s.setStateObject(ch.prev)
 }
 
-func (ch suicideChange) undo(s *StateDB) {
+func (ch resetObjectChange) dirtied() *common.Address {
+	return nil
+}
+
+func (ch suicideChange) revert(s *StateDB) {
 	obj := s.getStateObject(*ch.account)
 	if obj != nil {
 		obj.suicided = ch.prev
@@ -94,38 +158,60 @@ func (ch suicideChange) undo(s *StateDB) {
 	}
 }
 
-var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")
-
-func (ch touchChange) undo(s *StateDB) {
-	if !ch.prev && *ch.account != ripemd {
-		s.getStateObject(*ch.account).touched = ch.prev
-		if !ch.prevDirty {
-			delete(s.stateObjectsDirty, *ch.account)
-		}
-	}
+func (ch suicideChange) dirtied() *common.Address {
+	return ch.account
 }
 
-func (ch balanceChange) undo(s *StateDB) {
+var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")
+
+func (ch touchChange) revert(s *StateDB) {
+}
+
+func (ch touchChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch balanceChange) revert(s *StateDB) {
 	s.getStateObject(*ch.account).setBalance(ch.prev)
 }
 
-func (ch nonceChange) undo(s *StateDB) {
+func (ch balanceChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch nonceChange) revert(s *StateDB) {
 	s.getStateObject(*ch.account).setNonce(ch.prev)
 }
 
-func (ch codeChange) undo(s *StateDB) {
+func (ch nonceChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch codeChange) revert(s *StateDB) {
 	s.getStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode)
 }
 
-func (ch storageChange) undo(s *StateDB) {
+func (ch codeChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch storageChange) revert(s *StateDB) {
 	s.getStateObject(*ch.account).setState(ch.key, ch.prevalue)
 }
 
-func (ch refundChange) undo(s *StateDB) {
+func (ch storageChange) dirtied() *common.Address {
+	return ch.account
+}
+
+func (ch refundChange) revert(s *StateDB) {
 	s.refund = ch.prev
 }
 
-func (ch addLogChange) undo(s *StateDB) {
+func (ch refundChange) dirtied() *common.Address {
+	return nil
+}
+
+func (ch addLogChange) revert(s *StateDB) {
 	logs := s.logs[ch.txhash]
 	if len(logs) == 1 {
 		delete(s.logs, ch.txhash)
@@ -135,6 +221,14 @@ func (ch addLogChange) undo(s *StateDB) {
 	s.logSize--
 }
 
-func (ch addPreimageChange) undo(s *StateDB) {
+func (ch addLogChange) dirtied() *common.Address {
+	return nil
+}
+
+func (ch addPreimageChange) revert(s *StateDB) {
 	delete(s.preimages, ch.hash)
 }
+
+func (ch addPreimageChange) dirtied() *common.Address {
+	return nil
+}
diff --git a/core/state/managed_state_test.go b/core/state/managed_state_test.go
index 1cfdd3a890..3d9c4e8676 100644
--- a/core/state/managed_state_test.go
+++ b/core/state/managed_state_test.go
@@ -26,8 +26,7 @@ import (
 var addr = common.BytesToAddress([]byte("test"))
 
 func create() (*ManagedState, *account) {
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := New(common.Hash{}, NewDatabase(db))
+	statedb, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
 	ms := ManageState(statedb)
 	ms.StateDB.SetNonce(addr, 100)
 	ms.accounts[addr] = newAccount(ms.StateDB.getStateObject(addr))
diff --git a/core/state/state_object.go b/core/state/state_object.go
index b2378c69c8..091d24184a 100644
--- a/core/state/state_object.go
+++ b/core/state/state_object.go
@@ -25,7 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/trie"
 )
 
 var emptyCodeHash = crypto.Keccak256(nil)
@@ -86,9 +85,7 @@ type stateObject struct {
 	// during the "update" phase of the state transition.
 	dirtyCode bool // true if the code was updated
 	suicided  bool
-	touched   bool
 	deleted   bool
-	onDirty   func(addr common.Address) // Callback method to mark a state object newly dirty
 }
 
 // empty returns whether the account is considered empty.
@@ -106,7 +103,7 @@ type Account struct {
 }
 
 // newObject creates a state object.
-func newObject(db *StateDB, address common.Address, data Account, onDirty func(addr common.Address)) *stateObject {
+func newObject(db *StateDB, address common.Address, data Account) *stateObject {
 	if data.Balance == nil {
 		data.Balance = new(big.Int)
 	}
@@ -120,7 +117,6 @@ func newObject(db *StateDB, address common.Address, data Account, onDirty func(a
 		data:          data,
 		cachedStorage: make(Storage),
 		dirtyStorage:  make(Storage),
-		onDirty:       onDirty,
 	}
 }
 
@@ -138,23 +134,17 @@ func (self *stateObject) setError(err error) {
 
 func (self *stateObject) markSuicided() {
 	self.suicided = true
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 }
 
 func (c *stateObject) touch() {
-	c.db.journal = append(c.db.journal, touchChange{
-		account:   &c.address,
-		prev:      c.touched,
-		prevDirty: c.onDirty == nil,
+	c.db.journal.append(touchChange{
+		account: &c.address,
 	})
-	if c.onDirty != nil {
-		c.onDirty(c.Address())
-		c.onDirty = nil
+	if c.address == ripemd {
+		// Explicitly put it in the dirty-cache, which is otherwise generated from
+		// flattened journals.
+		c.db.journal.dirty(c.address)
 	}
-	c.touched = true
 }
 
 func (c *stateObject) getTrie(db Database) Trie {
@@ -188,15 +178,13 @@ func (self *stateObject) GetState(db Database, key common.Hash) common.Hash {
 		}
 		value.SetBytes(content)
 	}
-	if (value != common.Hash{}) {
-		self.cachedStorage[key] = value
-	}
+	self.cachedStorage[key] = value
 	return value
 }
 
 // SetState updates a value in account storage.
 func (self *stateObject) SetState(db Database, key, value common.Hash) {
-	self.db.journal = append(self.db.journal, storageChange{
+	self.db.journal.append(storageChange{
 		account:  &self.address,
 		key:      key,
 		prevalue: self.GetState(db, key),
@@ -207,11 +195,6 @@ func (self *stateObject) SetState(db Database, key, value common.Hash) {
 func (self *stateObject) setState(key, value common.Hash) {
 	self.cachedStorage[key] = value
 	self.dirtyStorage[key] = value
-
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 }
 
 // updateTrie writes cached storage modifications into the object's storage trie.
@@ -236,14 +219,14 @@ func (self *stateObject) updateRoot(db Database) {
 	self.data.Root = self.trie.Hash()
 }
 
-// CommitTrie the storage trie of the object to dwb.
+// CommitTrie the storage trie of the object to db.
 // This updates the trie root.
-func (self *stateObject) CommitTrie(db Database, dbw trie.DatabaseWriter) error {
+func (self *stateObject) CommitTrie(db Database) error {
 	self.updateTrie(db)
 	if self.dbErr != nil {
 		return self.dbErr
 	}
-	root, err := self.trie.CommitTo(dbw)
+	root, err := self.trie.Commit(nil)
 	if err == nil {
 		self.data.Root = root
 	}
@@ -275,7 +258,7 @@ func (c *stateObject) SubBalance(amount *big.Int) {
 }
 
 func (self *stateObject) SetBalance(amount *big.Int) {
-	self.db.journal = append(self.db.journal, balanceChange{
+	self.db.journal.append(balanceChange{
 		account: &self.address,
 		prev:    new(big.Int).Set(self.data.Balance),
 	})
@@ -284,17 +267,13 @@ func (self *stateObject) SetBalance(amount *big.Int) {
 
 func (self *stateObject) setBalance(amount *big.Int) {
 	self.data.Balance = amount
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 }
 
 // Return the gas back to the origin. Used by the Virtual machine or Closures
 func (c *stateObject) ReturnGas(gas *big.Int) {}
 
-func (self *stateObject) deepCopy(db *StateDB, onDirty func(addr common.Address)) *stateObject {
-	stateObject := newObject(db, self.address, self.data, onDirty)
+func (self *stateObject) deepCopy(db *StateDB) *stateObject {
+	stateObject := newObject(db, self.address, self.data)
 	if self.trie != nil {
 		stateObject.trie = db.db.CopyTrie(self.trie)
 	}
@@ -334,7 +313,7 @@ func (self *stateObject) Code(db Database) []byte {
 
 func (self *stateObject) SetCode(codeHash common.Hash, code []byte) {
 	prevcode := self.Code(self.db.db)
-	self.db.journal = append(self.db.journal, codeChange{
+	self.db.journal.append(codeChange{
 		account:  &self.address,
 		prevhash: self.CodeHash(),
 		prevcode: prevcode,
@@ -346,14 +325,10 @@ func (self *stateObject) setCode(codeHash common.Hash, code []byte) {
 	self.code = code
 	self.data.CodeHash = codeHash[:]
 	self.dirtyCode = true
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 }
 
 func (self *stateObject) SetNonce(nonce uint64) {
-	self.db.journal = append(self.db.journal, nonceChange{
+	self.db.journal.append(nonceChange{
 		account: &self.address,
 		prev:    self.data.Nonce,
 	})
@@ -362,10 +337,6 @@ func (self *stateObject) SetNonce(nonce uint64) {
 
 func (self *stateObject) setNonce(nonce uint64) {
 	self.data.Nonce = nonce
-	if self.onDirty != nil {
-		self.onDirty(self.Address())
-		self.onDirty = nil
-	}
 }
 
 func (self *stateObject) CodeHash() []byte {
diff --git a/core/state/state_test.go b/core/state/state_test.go
index bbae3685bb..123559ea9b 100644
--- a/core/state/state_test.go
+++ b/core/state/state_test.go
@@ -48,7 +48,7 @@ func (s *StateSuite) TestDump(c *checker.C) {
 	// write some of them to the trie
 	s.state.updateStateObject(obj1)
 	s.state.updateStateObject(obj2)
-	s.state.CommitTo(s.db, false)
+	s.state.Commit(false)
 
 	// check that dump contains the state objects that are in trie
 	got := string(s.state.Dump())
@@ -87,7 +87,7 @@ func (s *StateSuite) TestDump(c *checker.C) {
 }
 
 func (s *StateSuite) SetUpTest(c *checker.C) {
-	s.db, _ = ethdb.NewMemDatabase()
+	s.db = ethdb.NewMemDatabase()
 	s.state, _ = New(common.Hash{}, NewDatabase(s.db))
 }
 
@@ -97,9 +97,9 @@ func (s *StateSuite) TestNull(c *checker.C) {
 	//value := common.FromHex("0x823140710bf13990e4500136726d8b55")
 	var value common.Hash
 	s.state.SetState(address, common.Hash{}, value)
-	s.state.CommitTo(s.db, false)
+	s.state.Commit(false)
 	value = s.state.GetState(address, common.Hash{})
-	if !common.EmptyHash(value) {
+	if value != (common.Hash{}) {
 		c.Errorf("expected empty hash. got %x", value)
 	}
 }
@@ -133,8 +133,7 @@ func (s *StateSuite) TestSnapshotEmpty(c *checker.C) {
 // use testing instead of checker because checker does not support
 // printing/logging in tests (-check.vv does not work)
 func TestSnapshot2(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	state, _ := New(common.Hash{}, NewDatabase(db))
+	state, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
 
 	stateobjaddr0 := toAddr([]byte("so0"))
 	stateobjaddr1 := toAddr([]byte("so1"))
@@ -155,7 +154,7 @@ func TestSnapshot2(t *testing.T) {
 	so0.deleted = false
 	state.setStateObject(so0)
 
-	root, _ := state.CommitTo(db, false)
+	root, _ := state.Commit(false)
 	state.Reset(root)
 
 	// and one with deleted == true
diff --git a/core/state/statedb.go b/core/state/statedb.go
index de9fb367d9..ffea761d9f 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -36,6 +36,14 @@ type revision struct {
 	journalIndex int
 }
 
+var (
+	// emptyState is the known hash of an empty state trie entry.
+	emptyState = crypto.Keccak256Hash(nil)
+
+	// emptyCode is the known hash of the empty EVM bytecode.
+	emptyCode = crypto.Keccak256Hash(nil)
+)
+
 // StateDBs within the ethereum protocol are used to store anything
 // within the merkle trie. StateDBs take care of caching and storing
 // nested states. It's the general query interface to retrieve:
@@ -57,7 +65,7 @@ type StateDB struct {
 	dbErr error
 
 	// The refund counter, also used by state transitioning.
-	refund *big.Int
+	refund uint64
 
 	thash, bhash common.Hash
 	txIndex      int
@@ -68,14 +76,14 @@ type StateDB struct {
 
 	// Journal of state modifications. This is the backbone of
 	// Snapshot and RevertToSnapshot.
-	journal        journal
+	journal        *journal
 	validRevisions []revision
 	nextRevisionId int
 
 	lock sync.Mutex
 }
 
-// Create a new state from a given trie
+// Create a new state from a given trie.
 func New(root common.Hash, db Database) (*StateDB, error) {
 	tr, err := db.OpenTrie(root)
 	if err != nil {
@@ -86,9 +94,9 @@ func New(root common.Hash, db Database) (*StateDB, error) {
 		trie:              tr,
 		stateObjects:      make(map[common.Address]*stateObject),
 		stateObjectsDirty: make(map[common.Address]struct{}),
-		refund:            new(big.Int),
 		logs:              make(map[common.Hash][]*types.Log),
 		preimages:         make(map[common.Hash][]byte),
+		journal:           newJournal(),
 	}, nil
 }
 
@@ -103,7 +111,7 @@ func (self *StateDB) Error() error {
 	return self.dbErr
 }
 
-// Reset clears out all emphemeral state objects from the state db, but keeps
+// Reset clears out all ephemeral state objects from the state db, but keeps
 // the underlying state trie to avoid reloading data for the next operations.
 func (self *StateDB) Reset(root common.Hash) error {
 	tr, err := self.db.OpenTrie(root)
@@ -124,7 +132,7 @@ func (self *StateDB) Reset(root common.Hash) error {
 }
 
 func (self *StateDB) AddLog(log *types.Log) {
-	self.journal = append(self.journal, addLogChange{txhash: self.thash})
+	self.journal.append(addLogChange{txhash: self.thash})
 
 	log.TxHash = self.thash
 	log.BlockHash = self.bhash
@@ -149,7 +157,7 @@ func (self *StateDB) Logs() []*types.Log {
 // AddPreimage records a SHA3 preimage seen by the VM.
 func (self *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
 	if _, ok := self.preimages[hash]; !ok {
-		self.journal = append(self.journal, addPreimageChange{hash: hash})
+		self.journal.append(addPreimageChange{hash: hash})
 		pi := make([]byte, len(preimage))
 		copy(pi, preimage)
 		self.preimages[hash] = pi
@@ -161,9 +169,9 @@ func (self *StateDB) Preimages() map[common.Hash][]byte {
 	return self.preimages
 }
 
-func (self *StateDB) AddRefund(gas *big.Int) {
-	self.journal = append(self.journal, refundChange{prev: new(big.Int).Set(self.refund)})
-	self.refund.Add(self.refund, gas)
+func (self *StateDB) AddRefund(gas uint64) {
+	self.journal.append(refundChange{prev: self.refund})
+	self.refund += gas
 }
 
 // Exist reports whether the given account address exists in the state.
@@ -228,22 +236,27 @@ func (self *StateDB) GetCodeHash(addr common.Address) common.Hash {
 	return common.BytesToHash(stateObject.CodeHash())
 }
 
-func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash {
-	stateObject := self.getStateObject(a)
+func (self *StateDB) GetState(addr common.Address, bhash common.Hash) common.Hash {
+	stateObject := self.getStateObject(addr)
 	if stateObject != nil {
-		return stateObject.GetState(self.db, b)
+		return stateObject.GetState(self.db, bhash)
 	}
 	return common.Hash{}
 }
 
+// Database retrieves the low level database supporting the lower level trie ops.
+func (self *StateDB) Database() Database {
+	return self.db
+}
+
 // StorageTrie returns the storage trie of an account.
 // The return value is a copy and is nil for non-existent accounts.
-func (self *StateDB) StorageTrie(a common.Address) Trie {
-	stateObject := self.getStateObject(a)
+func (self *StateDB) StorageTrie(addr common.Address) Trie {
+	stateObject := self.getStateObject(addr)
 	if stateObject == nil {
 		return nil
 	}
-	cpy := stateObject.deepCopy(self, nil)
+	cpy := stateObject.deepCopy(self)
 	return cpy.updateTrie(self.db)
 }
 
@@ -259,7 +272,7 @@ func (self *StateDB) HasSuicided(addr common.Address) bool {
  * SETTERS
  */
 
-// AddBalance adds amount to the account associated with addr
+// AddBalance adds amount to the account associated with addr.
 func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
@@ -267,7 +280,7 @@ func (self *StateDB) AddBalance(addr common.Address, amount *big.Int) {
 	}
 }
 
-// SubBalance subtracts amount from the account associated with addr
+// SubBalance subtracts amount from the account associated with addr.
 func (self *StateDB) SubBalance(addr common.Address, amount *big.Int) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
@@ -296,7 +309,7 @@ func (self *StateDB) SetCode(addr common.Address, code []byte) {
 	}
 }
 
-func (self *StateDB) SetState(addr common.Address, key common.Hash, value common.Hash) {
+func (self *StateDB) SetState(addr common.Address, key, value common.Hash) {
 	stateObject := self.GetOrNewStateObject(addr)
 	if stateObject != nil {
 		stateObject.SetState(self.db, key, value)
@@ -313,7 +326,7 @@ func (self *StateDB) Suicide(addr common.Address) bool {
 	if stateObject == nil {
 		return false
 	}
-	self.journal = append(self.journal, suicideChange{
+	self.journal.append(suicideChange{
 		account:     &addr,
 		prev:        stateObject.suicided,
 		prevbalance: new(big.Int).Set(stateObject.Balance()),
@@ -325,7 +338,7 @@ func (self *StateDB) Suicide(addr common.Address) bool {
 }
 
 //
-// Setting, updating & deleting state object methods
+// Setting, updating & deleting state object methods.
 //
 
 // updateStateObject writes the given object to the trie.
@@ -345,7 +358,7 @@ func (self *StateDB) deleteStateObject(stateObject *stateObject) {
 	self.setError(self.trie.TryDelete(addr[:]))
 }
 
-// Retrieve a state object given my the address. Returns nil if not found.
+// Retrieve a state object given by the address. Returns nil if not found.
 func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) {
 	// Prefer 'live' objects.
 	if obj := self.stateObjects[addr]; obj != nil {
@@ -367,7 +380,7 @@ func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObje
 		return nil
 	}
 	// Insert into the live set.
-	obj := newObject(self, addr, data, self.MarkStateObjectDirty)
+	obj := newObject(self, addr, data)
 	self.setStateObject(obj)
 	return obj
 }
@@ -376,7 +389,7 @@ func (self *StateDB) setStateObject(object *stateObject) {
 	self.stateObjects[object.Address()] = object
 }
 
-// Retrieve a state object or create a new state object if nil
+// Retrieve a state object or create a new state object if nil.
 func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
 	stateObject := self.getStateObject(addr)
 	if stateObject == nil || stateObject.deleted {
@@ -385,22 +398,16 @@ func (self *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
 	return stateObject
 }
 
-// MarkStateObjectDirty adds the specified object to the dirty map to avoid costly
-// state object cache iteration to find a handful of modified ones.
-func (self *StateDB) MarkStateObjectDirty(addr common.Address) {
-	self.stateObjectsDirty[addr] = struct{}{}
-}
-
 // createObject creates a new state object. If there is an existing account with
 // the given address, it is overwritten and returned as the second return value.
 func (self *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
 	prev = self.getStateObject(addr)
-	newobj = newObject(self, addr, Account{}, self.MarkStateObjectDirty)
+	newobj = newObject(self, addr, Account{})
 	newobj.setNonce(0) // sets the object to dirty
 	if prev == nil {
-		self.journal = append(self.journal, createObjectChange{account: &addr})
+		self.journal.append(createObjectChange{account: &addr})
 	} else {
-		self.journal = append(self.journal, resetObjectChange{prev: prev})
+		self.journal.append(resetObjectChange{prev: prev})
 	}
 	self.setStateObject(newobj)
 	return newobj, prev
@@ -454,18 +461,35 @@ func (self *StateDB) Copy() *StateDB {
 	state := &StateDB{
 		db:                self.db,
 		trie:              self.db.CopyTrie(self.trie),
-		stateObjects:      make(map[common.Address]*stateObject, len(self.stateObjectsDirty)),
-		stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)),
-		refund:            new(big.Int).Set(self.refund),
+		stateObjects:      make(map[common.Address]*stateObject, len(self.journal.dirties)),
+		stateObjectsDirty: make(map[common.Address]struct{}, len(self.journal.dirties)),
+		refund:            self.refund,
 		logs:              make(map[common.Hash][]*types.Log, len(self.logs)),
 		logSize:           self.logSize,
 		preimages:         make(map[common.Hash][]byte),
+		journal:           newJournal(),
 	}
 	// Copy the dirty states, logs, and preimages
-	for addr := range self.stateObjectsDirty {
-		state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty)
-		state.stateObjectsDirty[addr] = struct{}{}
+	for addr := range self.journal.dirties {
+		// As documented [here](https://github.com/ethereum/go-ethereum/pull/16485#issuecomment-380438527),
+		// and in the Finalise-method, there is a case where an object is in the journal but not
+		// in the stateObjects: OOG after touch on ripeMD prior to Byzantium. Thus, we need to check for
+		// nil
+		if object, exist := self.stateObjects[addr]; exist {
+			state.stateObjects[addr] = object.deepCopy(state)
+			state.stateObjectsDirty[addr] = struct{}{}
+		}
 	}
+	// Above, we don't copy the actual journal. This means that if the copy is copied, the
+	// loop above will be a no-op, since the copy's journal is empty.
+	// Thus, here we iterate over stateObjects, to enable copies of copies
+	for addr := range self.stateObjectsDirty {
+		if _, exist := state.stateObjects[addr]; !exist {
+			state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state)
+			state.stateObjectsDirty[addr] = struct{}{}
+		}
+	}
+
 	for hash, logs := range self.logs {
 		state.logs[hash] = make([]*types.Log, len(logs))
 		copy(state.logs[hash], logs)
@@ -480,7 +504,7 @@ func (self *StateDB) Copy() *StateDB {
 func (self *StateDB) Snapshot() int {
 	id := self.nextRevisionId
 	self.nextRevisionId++
-	self.validRevisions = append(self.validRevisions, revision{id, len(self.journal)})
+	self.validRevisions = append(self.validRevisions, revision{id, self.journal.length()})
 	return id
 }
 
@@ -495,34 +519,38 @@ func (self *StateDB) RevertToSnapshot(revid int) {
 	}
 	snapshot := self.validRevisions[idx].journalIndex
 
-	// Replay the journal to undo changes.
-	for i := len(self.journal) - 1; i >= snapshot; i-- {
-		self.journal[i].undo(self)
-	}
-	self.journal = self.journal[:snapshot]
-
-	// Remove invalidated snapshots from the stack.
+	// Replay the journal to undo changes and remove invalidated snapshots
+	self.journal.revert(self, snapshot)
 	self.validRevisions = self.validRevisions[:idx]
 }
 
 // GetRefund returns the current value of the refund counter.
-// The return value must not be modified by the caller and will become
-// invalid at the next call to AddRefund.
-func (self *StateDB) GetRefund() *big.Int {
+func (self *StateDB) GetRefund() uint64 {
 	return self.refund
 }
 
 // Finalise finalises the state by removing the self destructed objects
 // and clears the journal as well as the refunds.
 func (s *StateDB) Finalise(deleteEmptyObjects bool) {
-	for addr := range s.stateObjectsDirty {
-		stateObject := s.stateObjects[addr]
+	for addr := range s.journal.dirties {
+		stateObject, exist := s.stateObjects[addr]
+		if !exist {
+			// ripeMD is 'touched' at block 1714175, in tx 0x1237f737031e40bcde4a8b7e717b2d15e3ecadfe49bb1bbc71ee9deb09c6fcf2
+			// That tx goes out of gas, and although the notion of 'touched' does not exist there, the
+			// touch-event will still be recorded in the journal. Since ripeMD is a special snowflake,
+			// it will persist in the journal even though the journal is reverted. In this special circumstance,
+			// it may exist in `s.journal.dirties` but not in `s.stateObjects`.
+			// Thus, we can safely ignore it here
+			continue
+		}
+
 		if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {
 			s.deleteStateObject(stateObject)
 		} else {
 			stateObject.updateRoot(s.db)
 			s.updateStateObject(stateObject)
 		}
+		s.stateObjectsDirty[addr] = struct{}{}
 	}
 	// Invalidate journal because reverting across transactions is not allowed.
 	s.clearJournalAndRefund()
@@ -544,37 +572,19 @@ func (self *StateDB) Prepare(thash, bhash common.Hash, ti int) {
 	self.txIndex = ti
 }
 
-// DeleteSuicides flags the suicided objects for deletion so that it
-// won't be referenced again when called / queried up on.
-//
-// DeleteSuicides should not be used for consensus related updates
-// under any circumstances.
-func (s *StateDB) DeleteSuicides() {
-	// Reset refund so that any used-gas calculations can use this method.
-	s.clearJournalAndRefund()
-
-	for addr := range s.stateObjectsDirty {
-		stateObject := s.stateObjects[addr]
-
-		// If the object has been removed by a suicide
-		// flag the object as deleted.
-		if stateObject.suicided {
-			stateObject.deleted = true
-		}
-		delete(s.stateObjectsDirty, addr)
-	}
-}
-
 func (s *StateDB) clearJournalAndRefund() {
-	s.journal = nil
+	s.journal = newJournal()
 	s.validRevisions = s.validRevisions[:0]
-	s.refund = new(big.Int)
+	s.refund = 0
 }
 
-// CommitTo writes the state to the given database.
-func (s *StateDB) CommitTo(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (root common.Hash, err error) {
+// Commit writes the state to the underlying in-memory trie database.
+func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) {
 	defer s.clearJournalAndRefund()
 
+	for addr := range s.journal.dirties {
+		s.stateObjectsDirty[addr] = struct{}{}
+	}
 	// Commit objects to the trie.
 	for addr, stateObject := range s.stateObjects {
 		_, isDirty := s.stateObjectsDirty[addr]
@@ -586,13 +596,11 @@ func (s *StateDB) CommitTo(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (ro
 		case isDirty:
 			// Write any contract code associated with the state object
 			if stateObject.code != nil && stateObject.dirtyCode {
-				if err := dbw.Put(stateObject.CodeHash(), stateObject.code); err != nil {
-					return common.Hash{}, err
-				}
+				s.db.TrieDB().Insert(common.BytesToHash(stateObject.CodeHash()), stateObject.code)
 				stateObject.dirtyCode = false
 			}
 			// Write any storage changes in the state object to its storage trie.
-			if err := stateObject.CommitTrie(s.db, dbw); err != nil {
+			if err := stateObject.CommitTrie(s.db); err != nil {
 				return common.Hash{}, err
 			}
 			// Update the object in the main account trie.
@@ -601,7 +609,20 @@ func (s *StateDB) CommitTo(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (ro
 		delete(s.stateObjectsDirty, addr)
 	}
 	// Write trie changes.
-	root, err = s.trie.CommitTo(dbw)
+	root, err = s.trie.Commit(func(leaf []byte, parent common.Hash) error {
+		var account Account
+		if err := rlp.DecodeBytes(leaf, &account); err != nil {
+			return nil
+		}
+		if account.Root != emptyState {
+			s.db.TrieDB().Reference(account.Root, parent)
+		}
+		code := common.BytesToHash(account.CodeHash)
+		if code != emptyCode {
+			s.db.TrieDB().Reference(code, parent)
+		}
+		return nil
+	})
 	log.Debug("Trie cache stats after commit", "misses", trie.CacheMisses(), "unloads", trie.CacheUnloads())
 	return root, err
 }
diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go
index e9944cd745..e2b349de86 100644
--- a/core/state/statedb_test.go
+++ b/core/state/statedb_test.go
@@ -39,7 +39,7 @@ import (
 // actually committing the state.
 func TestUpdateLeaks(t *testing.T) {
 	// Create an empty state database
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 	state, _ := New(common.Hash{}, NewDatabase(db))
 
 	// Update it with some accounts
@@ -66,8 +66,8 @@ func TestUpdateLeaks(t *testing.T) {
 // only the one right before the commit.
 func TestIntermediateLeaks(t *testing.T) {
 	// Create two state databases, one transitioning to the final state, the other final from the beginning
-	transDb, _ := ethdb.NewMemDatabase()
-	finalDb, _ := ethdb.NewMemDatabase()
+	transDb := ethdb.NewMemDatabase()
+	finalDb := ethdb.NewMemDatabase()
 	transState, _ := New(common.Hash{}, NewDatabase(transDb))
 	finalState, _ := New(common.Hash{}, NewDatabase(finalDb))
 
@@ -97,10 +97,10 @@ func TestIntermediateLeaks(t *testing.T) {
 	}
 
 	// Commit and cross check the databases.
-	if _, err := transState.CommitTo(transDb, false); err != nil {
+	if _, err := transState.Commit(false); err != nil {
 		t.Fatalf("failed to commit transition state: %v", err)
 	}
-	if _, err := finalState.CommitTo(finalDb, false); err != nil {
+	if _, err := finalState.Commit(false); err != nil {
 		t.Fatalf("failed to commit final state: %v", err)
 	}
 	for _, key := range finalDb.Keys() {
@@ -122,8 +122,7 @@ func TestIntermediateLeaks(t *testing.T) {
 // https://github.com/ethereum/go-ethereum/pull/15549.
 func TestCopy(t *testing.T) {
 	// Create a random state test to copy and modify "independently"
-	mem, _ := ethdb.NewMemDatabase()
-	orig, _ := New(common.Hash{}, NewDatabase(mem))
+	orig, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
 
 	for i := byte(0); i < 255; i++ {
 		obj := orig.GetOrNewStateObject(common.BytesToAddress([]byte{i}))
@@ -263,7 +262,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
 		{
 			name: "AddRefund",
 			fn: func(a testAction, s *StateDB) {
-				s.AddRefund(big.NewInt(a.args[0]))
+				s.AddRefund(uint64(a.args[0]))
 			},
 			args:   make([]int64, 1),
 			noAddr: true,
@@ -334,8 +333,7 @@ func (test *snapshotTest) String() string {
 func (test *snapshotTest) run() bool {
 	// Run all actions and create snapshots.
 	var (
-		db, _        = ethdb.NewMemDatabase()
-		state, _     = New(common.Hash{}, NewDatabase(db))
+		state, _     = New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
 		snapshotRevs = make([]int, len(test.snapshots))
 		sindex       = 0
 	)
@@ -346,11 +344,10 @@ func (test *snapshotTest) run() bool {
 		}
 		action.fn(action, state)
 	}
-
 	// Revert all snapshots in reverse order. Each revert must yield a state
 	// that is equivalent to fresh state with all actions up the snapshot applied.
 	for sindex--; sindex >= 0; sindex-- {
-		checkstate, _ := New(common.Hash{}, NewDatabase(db))
+		checkstate, _ := New(common.Hash{}, state.Database())
 		for _, action := range test.actions[:test.snapshots[sindex]] {
 			action.fn(action, checkstate)
 		}
@@ -396,7 +393,7 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error {
 		}
 	}
 
-	if state.GetRefund().Cmp(checkstate.GetRefund()) != 0 {
+	if state.GetRefund() != checkstate.GetRefund() {
 		return fmt.Errorf("got GetRefund() == %d, want GetRefund() == %d",
 			state.GetRefund(), checkstate.GetRefund())
 	}
@@ -409,17 +406,32 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error {
 
 func (s *StateSuite) TestTouchDelete(c *check.C) {
 	s.state.GetOrNewStateObject(common.Address{})
-	root, _ := s.state.CommitTo(s.db, false)
+	root, _ := s.state.Commit(false)
 	s.state.Reset(root)
 
 	snapshot := s.state.Snapshot()
 	s.state.AddBalance(common.Address{}, new(big.Int))
-	if len(s.state.stateObjectsDirty) != 1 {
+
+	if len(s.state.journal.dirties) != 1 {
 		c.Fatal("expected one dirty state object")
 	}
-
 	s.state.RevertToSnapshot(snapshot)
-	if len(s.state.stateObjectsDirty) != 0 {
+	if len(s.state.journal.dirties) != 0 {
 		c.Fatal("expected no dirty state object")
 	}
 }
+
+// TestCopyOfCopy tests that modified objects are carried over to the copy, and the copy of the copy.
+// See https://github.com/ethereum/go-ethereum/pull/15225#issuecomment-380191512
+func TestCopyOfCopy(t *testing.T) {
+	sdb, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
+	addr := common.HexToAddress("aaaa")
+	sdb.SetBalance(addr, big.NewInt(42))
+
+	if got := sdb.Copy().GetBalance(addr).Uint64(); got != 42 {
+		t.Fatalf("1st copy fail, expected 42, got %v", got)
+	}
+	if got := sdb.Copy().Copy().GetBalance(addr).Uint64(); got != 42 {
+		t.Fatalf("2nd copy fail, expected 42, got %v", got)
+	}
+}
diff --git a/core/state/sync.go b/core/state/sync.go
index 28fcf6ae05..c566e79073 100644
--- a/core/state/sync.go
+++ b/core/state/sync.go
@@ -25,8 +25,8 @@ import (
 )
 
 // NewStateSync create a new state trie download scheduler.
-func NewStateSync(root common.Hash, database trie.DatabaseReader) *trie.TrieSync {
-	var syncer *trie.TrieSync
+func NewStateSync(root common.Hash, database trie.DatabaseReader) *trie.Sync {
+	var syncer *trie.Sync
 	callback := func(leaf []byte, parent common.Hash) error {
 		var obj Account
 		if err := rlp.Decode(bytes.NewReader(leaf), &obj); err != nil {
@@ -36,6 +36,6 @@ func NewStateSync(root common.Hash, database trie.DatabaseReader) *trie.TrieSync
 		syncer.AddRawEntry(common.BytesToHash(obj.CodeHash), 64, parent)
 		return nil
 	}
-	syncer = trie.NewTrieSync(root, database, callback)
+	syncer = trie.NewSync(root, database, callback)
 	return syncer
 }
diff --git a/core/state/sync_test.go b/core/state/sync_test.go
index 06c572ea62..3177401608 100644
--- a/core/state/sync_test.go
+++ b/core/state/sync_test.go
@@ -36,10 +36,9 @@ type testAccount struct {
 }
 
 // makeTestState create a sample test state to test node-wise reconstruction.
-func makeTestState() (Database, *ethdb.MemDatabase, common.Hash, []*testAccount) {
+func makeTestState() (Database, common.Hash, []*testAccount) {
 	// Create an empty state
-	mem, _ := ethdb.NewMemDatabase()
-	db := NewDatabase(mem)
+	db := NewDatabase(ethdb.NewMemDatabase())
 	state, _ := New(common.Hash{}, db)
 
 	// Fill it with some arbitrary data
@@ -61,10 +60,10 @@ func makeTestState() (Database, *ethdb.MemDatabase, common.Hash, []*testAccount)
 		state.updateStateObject(obj)
 		accounts = append(accounts, acc)
 	}
-	root, _ := state.CommitTo(mem, false)
+	root, _ := state.Commit(false)
 
 	// Return the generated state
-	return db, mem, root, accounts
+	return db, root, accounts
 }
 
 // checkStateAccounts cross references a reconstructed state with an expected
@@ -96,7 +95,7 @@ func checkTrieConsistency(db ethdb.Database, root common.Hash) error {
 	if v, _ := db.Get(root[:]); v == nil {
 		return nil // Consider a non existent state consistent.
 	}
-	trie, err := trie.New(root, db)
+	trie, err := trie.New(root, trie.NewDatabase(db))
 	if err != nil {
 		return err
 	}
@@ -125,8 +124,7 @@ func checkStateConsistency(db ethdb.Database, root common.Hash) error {
 // Tests that an empty state is not scheduled for syncing.
 func TestEmptyStateSync(t *testing.T) {
 	empty := common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
-	db, _ := ethdb.NewMemDatabase()
-	if req := NewStateSync(empty, db).Missing(1); len(req) != 0 {
+	if req := NewStateSync(empty, ethdb.NewMemDatabase()).Missing(1); len(req) != 0 {
 		t.Errorf("content requested for empty state: %v", req)
 	}
 }
@@ -138,19 +136,19 @@ func TestIterativeStateSyncBatched(t *testing.T)    { testIterativeStateSync(t,
 
 func testIterativeStateSync(t *testing.T, batch int) {
 	// Create a random state to copy
-	_, srcMem, srcRoot, srcAccounts := makeTestState()
+	srcDb, srcRoot, srcAccounts := makeTestState()
 
 	// Create a destination state and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
+	dstDb := ethdb.NewMemDatabase()
 	sched := NewStateSync(srcRoot, dstDb)
 
 	queue := append([]common.Hash{}, sched.Missing(batch)...)
 	for len(queue) > 0 {
 		results := make([]trie.SyncResult, len(queue))
 		for i, hash := range queue {
-			data, err := srcMem.Get(hash.Bytes())
+			data, err := srcDb.TrieDB().Node(hash)
 			if err != nil {
-				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
+				t.Fatalf("failed to retrieve node data for %x", hash)
 			}
 			results[i] = trie.SyncResult{Hash: hash, Data: data}
 		}
@@ -170,10 +168,10 @@ func testIterativeStateSync(t *testing.T, batch int) {
 // partial results are returned, and the others sent only later.
 func TestIterativeDelayedStateSync(t *testing.T) {
 	// Create a random state to copy
-	_, srcMem, srcRoot, srcAccounts := makeTestState()
+	srcDb, srcRoot, srcAccounts := makeTestState()
 
 	// Create a destination state and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
+	dstDb := ethdb.NewMemDatabase()
 	sched := NewStateSync(srcRoot, dstDb)
 
 	queue := append([]common.Hash{}, sched.Missing(0)...)
@@ -181,9 +179,9 @@ func TestIterativeDelayedStateSync(t *testing.T) {
 		// Sync only half of the scheduled nodes
 		results := make([]trie.SyncResult, len(queue)/2+1)
 		for i, hash := range queue[:len(results)] {
-			data, err := srcMem.Get(hash.Bytes())
+			data, err := srcDb.TrieDB().Node(hash)
 			if err != nil {
-				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
+				t.Fatalf("failed to retrieve node data for %x", hash)
 			}
 			results[i] = trie.SyncResult{Hash: hash, Data: data}
 		}
@@ -207,10 +205,10 @@ func TestIterativeRandomStateSyncBatched(t *testing.T)    { testIterativeRandomS
 
 func testIterativeRandomStateSync(t *testing.T, batch int) {
 	// Create a random state to copy
-	_, srcMem, srcRoot, srcAccounts := makeTestState()
+	srcDb, srcRoot, srcAccounts := makeTestState()
 
 	// Create a destination state and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
+	dstDb := ethdb.NewMemDatabase()
 	sched := NewStateSync(srcRoot, dstDb)
 
 	queue := make(map[common.Hash]struct{})
@@ -221,9 +219,9 @@ func testIterativeRandomStateSync(t *testing.T, batch int) {
 		// Fetch all the queued nodes in a random order
 		results := make([]trie.SyncResult, 0, len(queue))
 		for hash := range queue {
-			data, err := srcMem.Get(hash.Bytes())
+			data, err := srcDb.TrieDB().Node(hash)
 			if err != nil {
-				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
+				t.Fatalf("failed to retrieve node data for %x", hash)
 			}
 			results = append(results, trie.SyncResult{Hash: hash, Data: data})
 		}
@@ -247,10 +245,10 @@ func testIterativeRandomStateSync(t *testing.T, batch int) {
 // partial results are returned (Even those randomly), others sent only later.
 func TestIterativeRandomDelayedStateSync(t *testing.T) {
 	// Create a random state to copy
-	_, srcMem, srcRoot, srcAccounts := makeTestState()
+	srcDb, srcRoot, srcAccounts := makeTestState()
 
 	// Create a destination state and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
+	dstDb := ethdb.NewMemDatabase()
 	sched := NewStateSync(srcRoot, dstDb)
 
 	queue := make(map[common.Hash]struct{})
@@ -263,9 +261,9 @@ func TestIterativeRandomDelayedStateSync(t *testing.T) {
 		for hash := range queue {
 			delete(queue, hash)
 
-			data, err := srcMem.Get(hash.Bytes())
+			data, err := srcDb.TrieDB().Node(hash)
 			if err != nil {
-				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
+				t.Fatalf("failed to retrieve node data for %x", hash)
 			}
 			results = append(results, trie.SyncResult{Hash: hash, Data: data})
 
@@ -292,12 +290,12 @@ func TestIterativeRandomDelayedStateSync(t *testing.T) {
 // the database.
 func TestIncompleteStateSync(t *testing.T) {
 	// Create a random state to copy
-	_, srcMem, srcRoot, srcAccounts := makeTestState()
+	srcDb, srcRoot, srcAccounts := makeTestState()
 
-	checkTrieConsistency(srcMem, srcRoot)
+	checkTrieConsistency(srcDb.TrieDB().DiskDB().(ethdb.Database), srcRoot)
 
 	// Create a destination state and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
+	dstDb := ethdb.NewMemDatabase()
 	sched := NewStateSync(srcRoot, dstDb)
 
 	added := []common.Hash{}
@@ -306,9 +304,9 @@ func TestIncompleteStateSync(t *testing.T) {
 		// Fetch a batch of state nodes
 		results := make([]trie.SyncResult, len(queue))
 		for i, hash := range queue {
-			data, err := srcMem.Get(hash.Bytes())
+			data, err := srcDb.TrieDB().Node(hash)
 			if err != nil {
-				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
+				t.Fatalf("failed to retrieve node data for %x", hash)
 			}
 			results[i] = trie.SyncResult{Hash: hash, Data: data}
 		}
diff --git a/core/state_processor.go b/core/state_processor.go
index 689c83785f..8e238ce1f0 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -17,8 +17,6 @@
 package core
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/misc"
@@ -55,13 +53,13 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen
 // Process returns the receipts and logs accumulated during the process and
 // returns the amount of gas that was used in the process. If any of the
 // transactions failed to execute due to insufficient gas it will return an error.
-func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) {
+func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
 	var (
-		receipts     types.Receipts
-		totalUsedGas = big.NewInt(0)
-		header       = block.Header()
-		allLogs      []*types.Log
-		gp           = new(GasPool).AddGas(block.GasLimit())
+		receipts types.Receipts
+		usedGas  = new(uint64)
+		header   = block.Header()
+		allLogs  []*types.Log
+		gp       = new(GasPool).AddGas(block.GasLimit())
 	)
 	// Mutate the the block and state according to any hard-fork specs
 	if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 {
@@ -70,9 +68,9 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	// Iterate over and process the individual transactions
 	for i, tx := range block.Transactions() {
 		statedb.Prepare(tx.Hash(), block.Hash(), i)
-		receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, totalUsedGas, cfg)
+		receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, usedGas, cfg)
 		if err != nil {
-			return nil, nil, nil, err
+			return nil, nil, 0, err
 		}
 		receipts = append(receipts, receipt)
 		allLogs = append(allLogs, receipt.Logs...)
@@ -80,17 +78,17 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
 	p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts)
 
-	return receipts, allLogs, totalUsedGas, nil
+	return receipts, allLogs, *usedGas, nil
 }
 
 // ApplyTransaction attempts to apply a transaction to the given state database
 // and uses the input parameters for its environment. It returns the receipt
 // for the transaction, gas used and an error if the transaction failed,
 // indicating the block was invalid.
-func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, *big.Int, error) {
+func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) {
 	msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
 	if err != nil {
-		return nil, nil, err
+		return nil, 0, err
 	}
 	// Create a new context to be used in the EVM environment
 	context := NewEVMContext(msg, header, bc, author)
@@ -100,9 +98,8 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
 	// Apply the transaction to the current state (included in the env)
 	_, gas, failed, err := ApplyMessage(vmenv, msg, gp)
 	if err != nil {
-		return nil, nil, err
+		return nil, 0, err
 	}
-
 	// Update the state with pending changes
 	var root []byte
 	if config.IsByzantium(header.Number) {
@@ -110,18 +107,17 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
 	} else {
 		root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes()
 	}
-	usedGas.Add(usedGas, gas)
+	*usedGas += gas
 
 	// Create a new receipt for the transaction, storing the intermediate root and gas used by the tx
 	// based on the eip phase, we're passing wether the root touch-delete accounts.
-	receipt := types.NewReceipt(root, failed, usedGas)
+	receipt := types.NewReceipt(root, failed, *usedGas)
 	receipt.TxHash = tx.Hash()
-	receipt.GasUsed = new(big.Int).Set(gas)
+	receipt.GasUsed = gas
 	// if the transaction created a contract, store the creation address in the receipt.
 	if msg.To() == nil {
 		receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce())
 	}
-
 	// Set the receipt logs and create a bloom for filtering
 	receipt.Logs = statedb.GetLogs(tx.Hash())
 	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
diff --git a/core/state_transition.go b/core/state_transition.go
index e7a0685893..5654cd01ea 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -18,17 +18,16 @@ package core
 
 import (
 	"errors"
+	"math"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 )
 
 var (
-	Big0                         = big.NewInt(0)
 	errInsufficientBalanceForGas = errors.New("insufficient balance to pay for gas")
 )
 
@@ -54,7 +53,7 @@ type StateTransition struct {
 	msg        Message
 	gas        uint64
 	gasPrice   *big.Int
-	initialGas *big.Int
+	initialGas uint64
 	value      *big.Int
 	data       []byte
 	state      vm.StateDB
@@ -68,7 +67,7 @@ type Message interface {
 	To() *common.Address
 
 	GasPrice() *big.Int
-	Gas() *big.Int
+	Gas() uint64
 	Value() *big.Int
 
 	Nonce() uint64
@@ -76,45 +75,49 @@ type Message interface {
 	Data() []byte
 }
 
-// IntrinsicGas computes the 'intrinsic gas' for a message
-// with the given data.
-//
-// TODO convert to uint64
-func IntrinsicGas(data []byte, contractCreation, homestead bool) *big.Int {
-	igas := new(big.Int)
+// IntrinsicGas computes the 'intrinsic gas' for a message with the given data.
+func IntrinsicGas(data []byte, contractCreation, homestead bool) (uint64, error) {
+	// Set the starting gas for the raw transaction
+	var gas uint64
 	if contractCreation && homestead {
-		igas.SetUint64(params.TxGasContractCreation)
+		gas = params.TxGasContractCreation
 	} else {
-		igas.SetUint64(params.TxGas)
+		gas = params.TxGas
 	}
+	// Bump the required gas by the amount of transactional data
 	if len(data) > 0 {
-		var nz int64
+		// Zero and non-zero bytes are priced differently
+		var nz uint64
 		for _, byt := range data {
 			if byt != 0 {
 				nz++
 			}
 		}
-		m := big.NewInt(nz)
-		m.Mul(m, new(big.Int).SetUint64(params.TxDataNonZeroGas))
-		igas.Add(igas, m)
-		m.SetInt64(int64(len(data)) - nz)
-		m.Mul(m, new(big.Int).SetUint64(params.TxDataZeroGas))
-		igas.Add(igas, m)
+		// Make sure we don't exceed uint64 for all data combinations
+		if (math.MaxUint64-gas)/params.TxDataNonZeroGas < nz {
+			return 0, vm.ErrOutOfGas
+		}
+		gas += nz * params.TxDataNonZeroGas
+
+		z := uint64(len(data)) - nz
+		if (math.MaxUint64-gas)/params.TxDataZeroGas < z {
+			return 0, vm.ErrOutOfGas
+		}
+		gas += z * params.TxDataZeroGas
 	}
-	return igas
+	return gas, nil
 }
 
 // NewStateTransition initialises and returns a new state transition object.
 func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition {
 	return &StateTransition{
-		gp:         gp,
-		evm:        evm,
-		msg:        msg,
-		gasPrice:   msg.GasPrice(),
-		initialGas: new(big.Int),
-		value:      msg.Value(),
-		data:       msg.Data(),
-		state:      evm.StateDB,
+		gp:       gp,
+		evm:      evm,
+		msg:      msg,
+		gasPrice: msg.GasPrice(),
+		value:    msg.Value(),
+		data:     msg.Data(),
+		state:    evm.StateDB,
 	}
 }
 
@@ -125,35 +128,16 @@ func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition
 // the gas used (which includes gas refunds) and an error if it failed. An error always
 // indicates a core error meaning that the message would always fail for that particular
 // state and would never be accepted within a block.
-func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, *big.Int, bool, error) {
-	st := NewStateTransition(evm, msg, gp)
-
-	ret, _, gasUsed, failed, err := st.TransitionDb()
-	return ret, gasUsed, failed, err
+func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, uint64, bool, error) {
+	return NewStateTransition(evm, msg, gp).TransitionDb()
 }
 
-func (st *StateTransition) from() vm.AccountRef {
-	f := st.msg.From()
-	if !st.state.Exist(f) {
-		st.state.CreateAccount(f)
+// to returns the recipient of the message.
+func (st *StateTransition) to() common.Address {
+	if st.msg == nil || st.msg.To() == nil /* contract creation */ {
+		return common.Address{}
 	}
-	return vm.AccountRef(f)
-}
-
-func (st *StateTransition) to() vm.AccountRef {
-	if st.msg == nil {
-		return vm.AccountRef{}
-	}
-	to := st.msg.To()
-	if to == nil {
-		return vm.AccountRef{} // contract creation
-	}
-
-	reference := vm.AccountRef(*to)
-	if !st.state.Exist(*to) {
-		st.state.CreateAccount(*to)
-	}
-	return reference
+	return *st.msg.To()
 }
 
 func (st *StateTransition) useGas(amount uint64) error {
@@ -166,67 +150,52 @@ func (st *StateTransition) useGas(amount uint64) error {
 }
 
 func (st *StateTransition) buyGas() error {
-	mgas := st.msg.Gas()
-	if mgas.BitLen() > 64 {
-		return vm.ErrOutOfGas
-	}
-
-	mgval := new(big.Int).Mul(mgas, st.gasPrice)
-
-	var (
-		state  = st.state
-		sender = st.from()
-	)
-	if state.GetBalance(sender.Address()).Cmp(mgval) < 0 {
+	mgval := new(big.Int).Mul(new(big.Int).SetUint64(st.msg.Gas()), st.gasPrice)
+	if st.state.GetBalance(st.msg.From()).Cmp(mgval) < 0 {
 		return errInsufficientBalanceForGas
 	}
-	if err := st.gp.SubGas(mgas); err != nil {
+	if err := st.gp.SubGas(st.msg.Gas()); err != nil {
 		return err
 	}
-	st.gas += mgas.Uint64()
+	st.gas += st.msg.Gas()
 
-	st.initialGas.Set(mgas)
-	state.SubBalance(sender.Address(), mgval)
+	st.initialGas = st.msg.Gas()
+	st.state.SubBalance(st.msg.From(), mgval)
 	return nil
 }
 
 func (st *StateTransition) preCheck() error {
-	msg := st.msg
-	sender := st.from()
-
-	// Make sure this transaction's nonce is correct
-	if msg.CheckNonce() {
-		nonce := st.state.GetNonce(sender.Address())
-		if nonce < msg.Nonce() {
+	// Make sure this transaction's nonce is correct.
+	if st.msg.CheckNonce() {
+		nonce := st.state.GetNonce(st.msg.From())
+		if nonce < st.msg.Nonce() {
 			return ErrNonceTooHigh
-		} else if nonce > msg.Nonce() {
+		} else if nonce > st.msg.Nonce() {
 			return ErrNonceTooLow
 		}
 	}
 	return st.buyGas()
 }
 
-// TransitionDb will transition the state by applying the current message and returning the result
-// including the required gas for the operation as well as the used gas. It returns an error if it
+// TransitionDb will transition the state by applying the current message and
+// returning the result including the the used gas. It returns an error if it
 // failed. An error indicates a consensus issue.
-func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, failed bool, err error) {
+func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bool, err error) {
 	if err = st.preCheck(); err != nil {
 		return
 	}
 	msg := st.msg
-	sender := st.from() // err checked in preCheck
-
+	sender := vm.AccountRef(msg.From())
 	homestead := st.evm.ChainConfig().IsHomestead(st.evm.BlockNumber)
 	contractCreation := msg.To() == nil
 
 	// Pay intrinsic gas
-	// TODO convert to uint64
-	intrinsicGas := IntrinsicGas(st.data, contractCreation, homestead)
-	if intrinsicGas.BitLen() > 64 {
-		return nil, nil, nil, false, vm.ErrOutOfGas
+	gas, err := IntrinsicGas(st.data, contractCreation, homestead)
+	if err != nil {
+		return nil, 0, false, err
 	}
-	if err = st.useGas(intrinsicGas.Uint64()); err != nil {
-		return nil, nil, nil, false, err
+	if err = st.useGas(gas); err != nil {
+		return nil, 0, false, err
 	}
 
 	var (
@@ -240,8 +209,8 @@ func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big
 		ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)
 	} else {
 		// Increment the nonce for the next transaction
-		st.state.SetNonce(sender.Address(), st.state.GetNonce(sender.Address())+1)
-		ret, st.gas, vmerr = evm.Call(sender, st.to().Address(), st.data, st.gas, st.value)
+		st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
+		ret, st.gas, vmerr = evm.Call(sender, st.to(), st.data, st.gas, st.value)
 	}
 	if vmerr != nil {
 		log.Debug("VM returned with error", "err", vmerr)
@@ -249,36 +218,33 @@ func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big
 		// sufficient balance to make the transfer happen. The first
 		// balance transfer may never fail.
 		if vmerr == vm.ErrInsufficientBalance {
-			return nil, nil, nil, false, vmerr
+			return nil, 0, false, vmerr
 		}
 	}
-	requiredGas = new(big.Int).Set(st.gasUsed())
-
 	st.refundGas()
-	st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(st.gasUsed(), st.gasPrice))
+	st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice))
 
-	return ret, requiredGas, st.gasUsed(), vmerr != nil, err
+	return ret, st.gasUsed(), vmerr != nil, err
 }
 
 func (st *StateTransition) refundGas() {
-	// Return eth for remaining gas to the sender account,
-	// exchanged at the original rate.
-	sender := st.from() // err already checked
-	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
-	st.state.AddBalance(sender.Address(), remaining)
-
 	// Apply refund counter, capped to half of the used gas.
-	uhalf := remaining.Div(st.gasUsed(), common.Big2)
-	refund := math.BigMin(uhalf, st.state.GetRefund())
-	st.gas += refund.Uint64()
+	refund := st.gasUsed() / 2
+	if refund > st.state.GetRefund() {
+		refund = st.state.GetRefund()
+	}
+	st.gas += refund
 
-	st.state.AddBalance(sender.Address(), refund.Mul(refund, st.gasPrice))
+	// Return ETH for remaining gas, exchanged at the original rate.
+	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
+	st.state.AddBalance(st.msg.From(), remaining)
 
 	// Also return remaining gas to the block gas counter so it is
 	// available for the next transaction.
-	st.gp.AddGas(new(big.Int).SetUint64(st.gas))
+	st.gp.AddGas(st.gas)
 }
 
-func (st *StateTransition) gasUsed() *big.Int {
-	return new(big.Int).Sub(st.initialGas, new(big.Int).SetUint64(st.gas))
+// gasUsed returns the amount of gas used up by the state transition.
+func (st *StateTransition) gasUsed() uint64 {
+	return st.initialGas - st.gas
 }
diff --git a/core/tx_cacher.go b/core/tx_cacher.go
new file mode 100644
index 0000000000..6d989c83d9
--- /dev/null
+++ b/core/tx_cacher.go
@@ -0,0 +1,105 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package core
+
+import (
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+// senderCacher is a concurrent tranaction sender recoverer anc cacher.
+var senderCacher = newTxSenderCacher(runtime.NumCPU())
+
+// txSenderCacherRequest is a request for recovering transaction senders with a
+// specific signature scheme and caching it into the transactions themselves.
+//
+// The inc field defines the number of transactions to skip after each recovery,
+// which is used to feed the same underlying input array to different threads but
+// ensure they process the early transactions fast.
+type txSenderCacherRequest struct {
+	signer types.Signer
+	txs    []*types.Transaction
+	inc    int
+}
+
+// txSenderCacher is a helper structure to concurrently ecrecover transaction
+// senders from digital signatures on background threads.
+type txSenderCacher struct {
+	threads int
+	tasks   chan *txSenderCacherRequest
+}
+
+// newTxSenderCacher creates a new transaction sender background cacher and starts
+// as many procesing goroutines as allowed by the GOMAXPROCS on construction.
+func newTxSenderCacher(threads int) *txSenderCacher {
+	cacher := &txSenderCacher{
+		tasks:   make(chan *txSenderCacherRequest, threads),
+		threads: threads,
+	}
+	for i := 0; i < threads; i++ {
+		go cacher.cache()
+	}
+	return cacher
+}
+
+// cache is an infinite loop, caching transaction senders from various forms of
+// data structures.
+func (cacher *txSenderCacher) cache() {
+	for task := range cacher.tasks {
+		for i := 0; i < len(task.txs); i += task.inc {
+			types.Sender(task.signer, task.txs[i])
+		}
+	}
+}
+
+// recover recovers the senders from a batch of transactions and caches them
+// back into the same data structures. There is no validation being done, nor
+// any reaction to invalid signatures. That is up to calling code later.
+func (cacher *txSenderCacher) recover(signer types.Signer, txs []*types.Transaction) {
+	// If there's nothing to recover, abort
+	if len(txs) == 0 {
+		return
+	}
+	// Ensure we have meaningful task sizes and schedule the recoveries
+	tasks := cacher.threads
+	if len(txs) < tasks*4 {
+		tasks = (len(txs) + 3) / 4
+	}
+	for i := 0; i < tasks; i++ {
+		cacher.tasks <- &txSenderCacherRequest{
+			signer: signer,
+			txs:    txs[i:],
+			inc:    tasks,
+		}
+	}
+}
+
+// recoverFromBlocks recovers the senders from a batch of blocks and caches them
+// back into the same data structures. There is no validation being done, nor
+// any reaction to invalid signatures. That is up to calling code later.
+func (cacher *txSenderCacher) recoverFromBlocks(signer types.Signer, blocks []*types.Block) {
+	count := 0
+	for _, block := range blocks {
+		count += len(block.Transactions())
+	}
+	txs := make([]*types.Transaction, 0, count)
+	for _, block := range blocks {
+		txs = append(txs, block.Transactions()...)
+	}
+	cacher.recover(signer, txs)
+}
diff --git a/core/tx_journal.go b/core/tx_journal.go
index e872d7b530..1397e9fd34 100644
--- a/core/tx_journal.go
+++ b/core/tx_journal.go
@@ -56,7 +56,7 @@ func newTxJournal(path string) *txJournal {
 
 // load parses a transaction journal dump from disk, loading its contents into
 // the specified pool.
-func (journal *txJournal) load(add func(*types.Transaction) error) error {
+func (journal *txJournal) load(add func([]*types.Transaction) []error) error {
 	// Skip the parsing if the journal file doens't exist at all
 	if _, err := os.Stat(journal.path); os.IsNotExist(err) {
 		return nil
@@ -76,7 +76,21 @@ func (journal *txJournal) load(add func(*types.Transaction) error) error {
 	stream := rlp.NewStream(input, 0)
 	total, dropped := 0, 0
 
-	var failure error
+	// Create a method to load a limited batch of transactions and bump the
+	// appropriate progress counters. Then use this method to load all the
+	// journalled transactions in small-ish batches.
+	loadBatch := func(txs types.Transactions) {
+		for _, err := range add(txs) {
+			if err != nil {
+				log.Debug("Failed to add journaled transaction", "err", err)
+				dropped++
+			}
+		}
+	}
+	var (
+		failure error
+		batch   types.Transactions
+	)
 	for {
 		// Parse the next transaction and terminate on error
 		tx := new(types.Transaction)
@@ -84,14 +98,17 @@ func (journal *txJournal) load(add func(*types.Transaction) error) error {
 			if err != io.EOF {
 				failure = err
 			}
+			if batch.Len() > 0 {
+				loadBatch(batch)
+			}
 			break
 		}
-		// Import the transaction and bump the appropriate progress counters
+		// New transaction parsed, queue up for later, import if threnshold is reached
 		total++
-		if err = add(tx); err != nil {
-			log.Debug("Failed to add journaled transaction", "err", err)
-			dropped++
-			continue
+
+		if batch = append(batch, tx); batch.Len() > 1024 {
+			loadBatch(batch)
+			batch = batch[:0]
 		}
 	}
 	log.Info("Loaded local transaction journal", "transactions", total, "dropped", dropped)
diff --git a/core/tx_list.go b/core/tx_list.go
index 838433b897..287dda4c33 100644
--- a/core/tx_list.go
+++ b/core/tx_list.go
@@ -224,7 +224,7 @@ type txList struct {
 	txs    *txSortedMap // Heap indexed sorted hash map of the transactions
 
 	costcap *big.Int // Price of the highest costing transaction (reset only if exceeds balance)
-	gascap  *big.Int // Gas limit of the highest spending transaction (reset only if exceeds block limit)
+	gascap  uint64   // Gas limit of the highest spending transaction (reset only if exceeds block limit)
 }
 
 // newTxList create a new transaction list for maintaining nonce-indexable fast,
@@ -234,7 +234,6 @@ func newTxList(strict bool) *txList {
 		strict:  strict,
 		txs:     newTxSortedMap(),
 		costcap: new(big.Int),
-		gascap:  new(big.Int),
 	}
 }
 
@@ -266,7 +265,7 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran
 	if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 {
 		l.costcap = cost
 	}
-	if gas := tx.Gas(); l.gascap.Cmp(gas) < 0 {
+	if gas := tx.Gas(); l.gascap < gas {
 		l.gascap = gas
 	}
 	return true, old
@@ -288,16 +287,16 @@ func (l *txList) Forward(threshold uint64) types.Transactions {
 // a point in calculating all the costs or if the balance covers all. If the threshold
 // is lower than the costgas cap, the caps will be reset to a new high after removing
 // the newly invalidated transactions.
-func (l *txList) Filter(costLimit, gasLimit *big.Int) (types.Transactions, types.Transactions) {
+func (l *txList) Filter(costLimit *big.Int, gasLimit uint64) (types.Transactions, types.Transactions) {
 	// If all transactions are below the threshold, short circuit
-	if l.costcap.Cmp(costLimit) <= 0 && l.gascap.Cmp(gasLimit) <= 0 {
+	if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit {
 		return nil, nil
 	}
 	l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds
-	l.gascap = new(big.Int).Set(gasLimit)
+	l.gascap = gasLimit
 
 	// Filter out all the transactions above the account's funds
-	removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(costLimit) > 0 || tx.Gas().Cmp(gasLimit) > 0 })
+	removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(costLimit) > 0 || tx.Gas() > gasLimit })
 
 	// If the list was strict, filter anything above the lowest nonce
 	var invalids types.Transactions
@@ -368,9 +367,20 @@ func (l *txList) Flatten() types.Transactions {
 // price-sorted transactions to discard when the pool fills up.
 type priceHeap []*types.Transaction
 
-func (h priceHeap) Len() int           { return len(h) }
-func (h priceHeap) Less(i, j int) bool { return h[i].GasPrice().Cmp(h[j].GasPrice()) < 0 }
-func (h priceHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h priceHeap) Len() int      { return len(h) }
+func (h priceHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
+
+func (h priceHeap) Less(i, j int) bool {
+	// Sort primarily by price, returning the cheaper one
+	switch h[i].GasPrice().Cmp(h[j].GasPrice()) {
+	case -1:
+		return true
+	case 1:
+		return false
+	}
+	// If the prices match, stabilize via nonces (high nonce is worse)
+	return h[i].Nonce() > h[j].Nonce()
+}
 
 func (h *priceHeap) Push(x interface{}) {
 	*h = append(*h, x.(*types.Transaction))
@@ -387,13 +397,13 @@ func (h *priceHeap) Pop() interface{} {
 // txPricedList is a price-sorted heap to allow operating on transactions pool
 // contents in a price-incrementing way.
 type txPricedList struct {
-	all    *map[common.Hash]*types.Transaction // Pointer to the map of all transactions
-	items  *priceHeap                          // Heap of prices of all the stored transactions
-	stales int                                 // Number of stale price points to (re-heap trigger)
+	all    *txLookup  // Pointer to the map of all transactions
+	items  *priceHeap // Heap of prices of all the stored transactions
+	stales int        // Number of stale price points to (re-heap trigger)
 }
 
 // newTxPricedList creates a new price-sorted transaction heap.
-func newTxPricedList(all *map[common.Hash]*types.Transaction) *txPricedList {
+func newTxPricedList(all *txLookup) *txPricedList {
 	return &txPricedList{
 		all:   all,
 		items: new(priceHeap),
@@ -415,12 +425,13 @@ func (l *txPricedList) Removed() {
 		return
 	}
 	// Seems we've reached a critical number of stale transactions, reheap
-	reheap := make(priceHeap, 0, len(*l.all))
+	reheap := make(priceHeap, 0, l.all.Count())
 
 	l.stales, l.items = 0, &reheap
-	for _, tx := range *l.all {
+	l.all.Range(func(hash common.Hash, tx *types.Transaction) bool {
 		*l.items = append(*l.items, tx)
-	}
+		return true
+	})
 	heap.Init(l.items)
 }
 
@@ -433,7 +444,7 @@ func (l *txPricedList) Cap(threshold *big.Int, local *accountSet) types.Transact
 	for len(*l.items) > 0 {
 		// Discard stale transactions if found during cleanup
 		tx := heap.Pop(l.items).(*types.Transaction)
-		if _, ok := (*l.all)[tx.Hash()]; !ok {
+		if l.all.Get(tx.Hash()) == nil {
 			l.stales--
 			continue
 		}
@@ -465,7 +476,7 @@ func (l *txPricedList) Underpriced(tx *types.Transaction, local *accountSet) boo
 	// Discard stale price points if found at the heap start
 	for len(*l.items) > 0 {
 		head := []*types.Transaction(*l.items)[0]
-		if _, ok := (*l.all)[head.Hash()]; !ok {
+		if l.all.Get(head.Hash()) == nil {
 			l.stales--
 			heap.Pop(l.items)
 			continue
@@ -490,7 +501,7 @@ func (l *txPricedList) Discard(count int, local *accountSet) types.Transactions
 	for len(*l.items) > 0 && count > 0 {
 		// Discard stale transactions if found during cleanup
 		tx := heap.Pop(l.items).(*types.Transaction)
-		if _, ok := (*l.all)[tx.Hash()]; !ok {
+		if l.all.Get(tx.Hash()) == nil {
 			l.stales--
 			continue
 		}
diff --git a/core/tx_list_test.go b/core/tx_list_test.go
index b4f0b5228b..d579f501af 100644
--- a/core/tx_list_test.go
+++ b/core/tx_list_test.go
@@ -17,7 +17,6 @@
 package core
 
 import (
-	"math/big"
 	"math/rand"
 	"testing"
 
@@ -33,7 +32,7 @@ func TestStrictTxListAdd(t *testing.T) {
 
 	txs := make(types.Transactions, 1024)
 	for i := 0; i < len(txs); i++ {
-		txs[i] = transaction(uint64(i), new(big.Int), key)
+		txs[i] = transaction(uint64(i), 0, key)
 	}
 	// Insert the transactions in a random order
 	list := newTxList(true)
diff --git a/core/tx_pool.go b/core/tx_pool.go
index c3915575b0..9c958e3b6f 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -38,8 +38,6 @@ import (
 const (
 	// chainHeadChanSize is the size of channel listening to ChainHeadEvent.
 	chainHeadChanSize = 10
-	// rmTxChanSize is the size of channel listening to RemovedTransactionEvent.
-	rmTxChanSize = 10
 )
 
 var (
@@ -87,23 +85,23 @@ var (
 
 var (
 	// Metrics for the pending pool
-	pendingDiscardCounter   = metrics.NewCounter("txpool/pending/discard")
-	pendingReplaceCounter   = metrics.NewCounter("txpool/pending/replace")
-	pendingRateLimitCounter = metrics.NewCounter("txpool/pending/ratelimit") // Dropped due to rate limiting
-	pendingNofundsCounter   = metrics.NewCounter("txpool/pending/nofunds")   // Dropped due to out-of-funds
+	pendingDiscardCounter   = metrics.NewRegisteredCounter("txpool/pending/discard", nil)
+	pendingReplaceCounter   = metrics.NewRegisteredCounter("txpool/pending/replace", nil)
+	pendingRateLimitCounter = metrics.NewRegisteredCounter("txpool/pending/ratelimit", nil) // Dropped due to rate limiting
+	pendingNofundsCounter   = metrics.NewRegisteredCounter("txpool/pending/nofunds", nil)   // Dropped due to out-of-funds
 
 	// Metrics for the queued pool
-	queuedDiscardCounter   = metrics.NewCounter("txpool/queued/discard")
-	queuedReplaceCounter   = metrics.NewCounter("txpool/queued/replace")
-	queuedRateLimitCounter = metrics.NewCounter("txpool/queued/ratelimit") // Dropped due to rate limiting
-	queuedNofundsCounter   = metrics.NewCounter("txpool/queued/nofunds")   // Dropped due to out-of-funds
+	queuedDiscardCounter   = metrics.NewRegisteredCounter("txpool/queued/discard", nil)
+	queuedReplaceCounter   = metrics.NewRegisteredCounter("txpool/queued/replace", nil)
+	queuedRateLimitCounter = metrics.NewRegisteredCounter("txpool/queued/ratelimit", nil) // Dropped due to rate limiting
+	queuedNofundsCounter   = metrics.NewRegisteredCounter("txpool/queued/nofunds", nil)   // Dropped due to out-of-funds
 
 	// General tx metrics
-	invalidTxCounter     = metrics.NewCounter("txpool/invalid")
-	underpricedTxCounter = metrics.NewCounter("txpool/underpriced")
+	invalidTxCounter     = metrics.NewRegisteredCounter("txpool/invalid", nil)
+	underpricedTxCounter = metrics.NewRegisteredCounter("txpool/underpriced", nil)
 )
 
-// TxStatus is the current status of a transaction as seen py the pool.
+// TxStatus is the current status of a transaction as seen by the pool.
 type TxStatus uint
 
 const (
@@ -197,16 +195,16 @@ type TxPool struct {
 
 	currentState  *state.StateDB      // Current state in the blockchain head
 	pendingState  *state.ManagedState // Pending state tracking virtual nonces
-	currentMaxGas *big.Int            // Current gas limit for transaction caps
+	currentMaxGas uint64              // Current gas limit for transaction caps
 
-	locals  *accountSet // Set of local transaction to exepmt from evicion rules
+	locals  *accountSet // Set of local transaction to exempt from eviction rules
 	journal *txJournal  // Journal of local transaction to back up to disk
 
-	pending map[common.Address]*txList         // All currently processable transactions
-	queue   map[common.Address]*txList         // Queued but non-processable transactions
-	beats   map[common.Address]time.Time       // Last heartbeat from each known account
-	all     map[common.Hash]*types.Transaction // All transactions to allow lookups
-	priced  *txPricedList                      // All transactions sorted by price
+	pending map[common.Address]*txList   // All currently processable transactions
+	queue   map[common.Address]*txList   // Queued but non-processable transactions
+	beats   map[common.Address]time.Time // Last heartbeat from each known account
+	all     *txLookup                    // All transactions to allow lookups
+	priced  *txPricedList                // All transactions sorted by price
 
 	wg sync.WaitGroup // for shutdown sync
 
@@ -214,7 +212,7 @@ type TxPool struct {
 }
 
 // NewTxPool creates a new transaction pool to gather, sort and filter inbound
-// trnsactions from the network.
+// transactions from the network.
 func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain blockChain) *TxPool {
 	// Sanitize the input to ensure no vulnerable gas prices are set
 	config = (&config).sanitize()
@@ -224,23 +222,23 @@ func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain block
 		config:      config,
 		chainconfig: chainconfig,
 		chain:       chain,
-		signer:      types.NewEIP155Signer(chainconfig.ChainId),
+		signer:      types.NewEIP155Signer(chainconfig.ChainID),
 		pending:     make(map[common.Address]*txList),
 		queue:       make(map[common.Address]*txList),
 		beats:       make(map[common.Address]time.Time),
-		all:         make(map[common.Hash]*types.Transaction),
+		all:         newTxLookup(),
 		chainHeadCh: make(chan ChainHeadEvent, chainHeadChanSize),
 		gasPrice:    new(big.Int).SetUint64(config.PriceLimit),
 	}
 	pool.locals = newAccountSet(pool.signer)
-	pool.priced = newTxPricedList(&pool.all)
+	pool.priced = newTxPricedList(pool.all)
 	pool.reset(nil, chain.CurrentBlock().Header())
 
 	// If local transactions and journaling is enabled, load from disk
 	if !config.NoLocals && config.Journal != "" {
 		pool.journal = newTxJournal(config.Journal)
 
-		if err := pool.journal.load(pool.AddLocal); err != nil {
+		if err := pool.journal.load(pool.AddLocals); err != nil {
 			log.Warn("Failed to load transaction journal", "err", err)
 		}
 		if err := pool.journal.rotate(pool.local()); err != nil {
@@ -320,7 +318,7 @@ func (pool *TxPool) loop() {
 				// Any non-locals old enough should be removed
 				if time.Since(pool.beats[addr]) > pool.config.Lifetime {
 					for _, tx := range pool.queue[addr].Flatten() {
-						pool.removeTx(tx.Hash())
+						pool.removeTx(tx.Hash(), true)
 					}
 				}
 			}
@@ -360,7 +358,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 		newNum := newHead.Number.Uint64()
 
 		if depth := uint64(math.Abs(float64(oldNum) - float64(newNum))); depth > 64 {
-			log.Warn("Skipping deep transaction reorg", "depth", depth)
+			log.Debug("Skipping deep transaction reorg", "depth", depth)
 		} else {
 			// Reorg seems shallow enough to pull in all transactions into memory
 			var discarded, included types.Transactions
@@ -413,6 +411,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) {
 
 	// Inject any transactions discarded due to reorgs
 	log.Debug("Reinjecting stale transactions", "count", len(reinject))
+	senderCacher.recover(pool.signer, reinject)
 	pool.addTxsLocked(reinject, false)
 
 	// validate the pool of pending transactions, this will remove
@@ -446,9 +445,9 @@ func (pool *TxPool) Stop() {
 	log.Info("Transaction pool stopped")
 }
 
-// SubscribeTxPreEvent registers a subscription of TxPreEvent and
+// SubscribeNewTxsEvent registers a subscription of NewTxsEvent and
 // starts sending event to the given channel.
-func (pool *TxPool) SubscribeTxPreEvent(ch chan<- TxPreEvent) event.Subscription {
+func (pool *TxPool) SubscribeNewTxsEvent(ch chan<- NewTxsEvent) event.Subscription {
 	return pool.scope.Track(pool.txFeed.Subscribe(ch))
 }
 
@@ -468,7 +467,7 @@ func (pool *TxPool) SetGasPrice(price *big.Int) {
 
 	pool.gasPrice = price
 	for _, tx := range pool.priced.Cap(price, pool.locals) {
-		pool.removeTx(tx.Hash())
+		pool.removeTx(tx.Hash(), false)
 	}
 	log.Info("Transaction pool price threshold updated", "price", price)
 }
@@ -564,7 +563,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 		return ErrNegativeValue
 	}
 	// Ensure the transaction doesn't exceed the current block limit gas.
-	if pool.currentMaxGas.Cmp(tx.Gas()) < 0 {
+	if pool.currentMaxGas < tx.Gas() {
 		return ErrGasLimit
 	}
 	// Make sure the transaction is signed properly
@@ -586,8 +585,11 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 	if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
 		return ErrInsufficientFunds
 	}
-	intrGas := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead)
-	if tx.Gas().Cmp(intrGas) < 0 {
+	intrGas, err := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead)
+	if err != nil {
+		return err
+	}
+	if tx.Gas() < intrGas {
 		return ErrIntrinsicGas
 	}
 	return nil
@@ -604,7 +606,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
 	// If the transaction is already known, discard it
 	hash := tx.Hash()
-	if pool.all[hash] != nil {
+	if pool.all.Get(hash) != nil {
 		log.Trace("Discarding already known transaction", "hash", hash)
 		return false, fmt.Errorf("known transaction: %x", hash)
 	}
@@ -615,19 +617,19 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
 		return false, err
 	}
 	// If the transaction pool is full, discard underpriced transactions
-	if uint64(len(pool.all)) >= pool.config.GlobalSlots+pool.config.GlobalQueue {
+	if uint64(pool.all.Count()) >= pool.config.GlobalSlots+pool.config.GlobalQueue {
 		// If the new transaction is underpriced, don't accept it
-		if pool.priced.Underpriced(tx, pool.locals) {
+		if !local && pool.priced.Underpriced(tx, pool.locals) {
 			log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())
 			underpricedTxCounter.Inc(1)
 			return false, ErrUnderpriced
 		}
 		// New transaction is better than our worse ones, make room for it
-		drop := pool.priced.Discard(len(pool.all)-int(pool.config.GlobalSlots+pool.config.GlobalQueue-1), pool.locals)
+		drop := pool.priced.Discard(pool.all.Count()-int(pool.config.GlobalSlots+pool.config.GlobalQueue-1), pool.locals)
 		for _, tx := range drop {
 			log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice())
 			underpricedTxCounter.Inc(1)
-			pool.removeTx(tx.Hash())
+			pool.removeTx(tx.Hash(), false)
 		}
 	}
 	// If the transaction is replacing an already pending one, do directly
@@ -641,18 +643,18 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
 		}
 		// New transaction is better, replace old one
 		if old != nil {
-			delete(pool.all, old.Hash())
+			pool.all.Remove(old.Hash())
 			pool.priced.Removed()
 			pendingReplaceCounter.Inc(1)
 		}
-		pool.all[tx.Hash()] = tx
+		pool.all.Add(tx)
 		pool.priced.Put(tx)
 		pool.journalTx(from, tx)
 
 		log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())
 
 		// We've directly injected a replacement transaction, notify subsystems
-		go pool.txFeed.Send(TxPreEvent{tx})
+		go pool.txFeed.Send(NewTxsEvent{types.Transactions{tx}})
 
 		return old != nil, nil
 	}
@@ -688,12 +690,14 @@ func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction) (bool, er
 	}
 	// Discard any previous transaction and mark this
 	if old != nil {
-		delete(pool.all, old.Hash())
+		pool.all.Remove(old.Hash())
 		pool.priced.Removed()
 		queuedReplaceCounter.Inc(1)
 	}
-	pool.all[hash] = tx
-	pool.priced.Put(tx)
+	if pool.all.Get(hash) == nil {
+		pool.all.Add(tx)
+		pool.priced.Put(tx)
+	}
 	return old != nil, nil
 }
 
@@ -709,10 +713,11 @@ func (pool *TxPool) journalTx(from common.Address, tx *types.Transaction) {
 	}
 }
 
-// promoteTx adds a transaction to the pending (processable) list of transactions.
+// promoteTx adds a transaction to the pending (processable) list of transactions
+// and returns whether it was inserted or an older was better.
 //
 // Note, this method assumes the pool lock is held!
-func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.Transaction) {
+func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.Transaction) bool {
 	// Try to insert the transaction into the pending queue
 	if pool.pending[addr] == nil {
 		pool.pending[addr] = newTxList(true)
@@ -722,29 +727,29 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T
 	inserted, old := list.Add(tx, pool.config.PriceBump)
 	if !inserted {
 		// An older transaction was better, discard this
-		delete(pool.all, hash)
+		pool.all.Remove(hash)
 		pool.priced.Removed()
 
 		pendingDiscardCounter.Inc(1)
-		return
+		return false
 	}
 	// Otherwise discard any previous transaction and mark this
 	if old != nil {
-		delete(pool.all, old.Hash())
+		pool.all.Remove(old.Hash())
 		pool.priced.Removed()
 
 		pendingReplaceCounter.Inc(1)
 	}
 	// Failsafe to work around direct pending inserts (tests)
-	if pool.all[hash] == nil {
-		pool.all[hash] = tx
+	if pool.all.Get(hash) == nil {
+		pool.all.Add(tx)
 		pool.priced.Put(tx)
 	}
 	// Set the potentially new pending nonce and notify any subsystems of the new tx
 	pool.beats[addr] = time.Now()
 	pool.pendingState.SetNonce(addr, tx.Nonce()+1)
 
-	go pool.txFeed.Send(TxPreEvent{tx})
+	return true
 }
 
 // AddLocal enqueues a single transaction into the pool if it is valid, marking
@@ -810,11 +815,9 @@ func (pool *TxPool) addTxsLocked(txs []*types.Transaction, local bool) []error {
 
 	for i, tx := range txs {
 		var replace bool
-		if replace, errs[i] = pool.add(tx, local); errs[i] == nil {
-			if !replace {
-				from, _ := types.Sender(pool.signer, tx) // already validated
-				dirty[from] = struct{}{}
-			}
+		if replace, errs[i] = pool.add(tx, local); errs[i] == nil && !replace {
+			from, _ := types.Sender(pool.signer, tx) // already validated
+			dirty[from] = struct{}{}
 		}
 	}
 	// Only reprocess the internal state if something was actually added
@@ -836,9 +839,9 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 
 	status := make([]TxStatus, len(hashes))
 	for i, hash := range hashes {
-		if tx := pool.all[hash]; tx != nil {
+		if tx := pool.all.Get(hash); tx != nil {
 			from, _ := types.Sender(pool.signer, tx) // already validated
-			if pool.pending[from].txs.items[tx.Nonce()] != nil {
+			if pool.pending[from] != nil && pool.pending[from].txs.items[tx.Nonce()] != nil {
 				status[i] = TxStatusPending
 			} else {
 				status[i] = TxStatusQueued
@@ -851,38 +854,35 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus {
 // Get returns a transaction if it is contained in the pool
 // and nil otherwise.
 func (pool *TxPool) Get(hash common.Hash) *types.Transaction {
-	pool.mu.RLock()
-	defer pool.mu.RUnlock()
-
-	return pool.all[hash]
+	return pool.all.Get(hash)
 }
 
 // removeTx removes a single transaction from the queue, moving all subsequent
 // transactions back to the future queue.
-func (pool *TxPool) removeTx(hash common.Hash) {
+func (pool *TxPool) removeTx(hash common.Hash, outofbound bool) {
 	// Fetch the transaction we wish to delete
-	tx, ok := pool.all[hash]
-	if !ok {
+	tx := pool.all.Get(hash)
+	if tx == nil {
 		return
 	}
 	addr, _ := types.Sender(pool.signer, tx) // already validated during insertion
 
 	// Remove it from the list of known transactions
-	delete(pool.all, hash)
-	pool.priced.Removed()
-
+	pool.all.Remove(hash)
+	if outofbound {
+		pool.priced.Removed()
+	}
 	// Remove the transaction from the pending lists and reset the account nonce
 	if pending := pool.pending[addr]; pending != nil {
 		if removed, invalids := pending.Remove(tx); removed {
-			// If no more transactions are left, remove the list
+			// If no more pending transactions are left, remove the list
 			if pending.Empty() {
 				delete(pool.pending, addr)
 				delete(pool.beats, addr)
-			} else {
-				// Otherwise postpone any invalidated transactions
-				for _, tx := range invalids {
-					pool.enqueueTx(tx.Hash(), tx)
-				}
+			}
+			// Postpone any invalidated transactions
+			for _, tx := range invalids {
+				pool.enqueueTx(tx.Hash(), tx)
 			}
 			// Update the account nonce if needed
 			if nonce := tx.Nonce(); pool.pendingState.GetNonce(addr) > nonce {
@@ -904,6 +904,9 @@ func (pool *TxPool) removeTx(hash common.Hash) {
 // future queue to the set of pending transactions. During this process, all
 // invalidated transactions (low nonce, low balance) are deleted.
 func (pool *TxPool) promoteExecutables(accounts []common.Address) {
+	// Track the promoted transactions to broadcast them at once
+	var promoted []*types.Transaction
+
 	// Gather all the accounts potentially needing updates
 	if accounts == nil {
 		accounts = make([]common.Address, 0, len(pool.queue))
@@ -921,7 +924,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 		for _, tx := range list.Forward(pool.currentState.GetNonce(addr)) {
 			hash := tx.Hash()
 			log.Trace("Removed old queued transaction", "hash", hash)
-			delete(pool.all, hash)
+			pool.all.Remove(hash)
 			pool.priced.Removed()
 		}
 		// Drop all transactions that are too costly (low balance or out of gas)
@@ -929,21 +932,23 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 		for _, tx := range drops {
 			hash := tx.Hash()
 			log.Trace("Removed unpayable queued transaction", "hash", hash)
-			delete(pool.all, hash)
+			pool.all.Remove(hash)
 			pool.priced.Removed()
 			queuedNofundsCounter.Inc(1)
 		}
 		// Gather all executable transactions and promote them
 		for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) {
 			hash := tx.Hash()
-			log.Trace("Promoting queued transaction", "hash", hash)
-			pool.promoteTx(addr, hash, tx)
+			if pool.promoteTx(addr, hash, tx) {
+				log.Trace("Promoting queued transaction", "hash", hash)
+				promoted = append(promoted, tx)
+			}
 		}
 		// Drop all transactions over the allowed limit
 		if !pool.locals.contains(addr) {
 			for _, tx := range list.Cap(int(pool.config.AccountQueue)) {
 				hash := tx.Hash()
-				delete(pool.all, hash)
+				pool.all.Remove(hash)
 				pool.priced.Removed()
 				queuedRateLimitCounter.Inc(1)
 				log.Trace("Removed cap-exceeding queued transaction", "hash", hash)
@@ -954,6 +959,10 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 			delete(pool.queue, addr)
 		}
 	}
+	// Notify subsystem for new promoted transactions.
+	if len(promoted) > 0 {
+		go pool.txFeed.Send(NewTxsEvent{promoted})
+	}
 	// If the pending limit is overflown, start equalizing allowances
 	pending := uint64(0)
 	for _, list := range pool.pending {
@@ -988,7 +997,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 						for _, tx := range list.Cap(list.Len() - 1) {
 							// Drop the transaction from the global pools too
 							hash := tx.Hash()
-							delete(pool.all, hash)
+							pool.all.Remove(hash)
 							pool.priced.Removed()
 
 							// Update the account nonce to the dropped transaction
@@ -1010,7 +1019,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 					for _, tx := range list.Cap(list.Len() - 1) {
 						// Drop the transaction from the global pools too
 						hash := tx.Hash()
-						delete(pool.all, hash)
+						pool.all.Remove(hash)
 						pool.priced.Removed()
 
 						// Update the account nonce to the dropped transaction
@@ -1050,7 +1059,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 			// Drop all transactions if they are less than the overflow
 			if size := uint64(list.Len()); size <= drop {
 				for _, tx := range list.Flatten() {
-					pool.removeTx(tx.Hash())
+					pool.removeTx(tx.Hash(), true)
 				}
 				drop -= size
 				queuedRateLimitCounter.Inc(int64(size))
@@ -1059,7 +1068,7 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) {
 			// Otherwise drop only last few transactions
 			txs := list.Flatten()
 			for i := len(txs) - 1; i >= 0 && drop > 0; i-- {
-				pool.removeTx(txs[i].Hash())
+				pool.removeTx(txs[i].Hash(), true)
 				drop--
 				queuedRateLimitCounter.Inc(1)
 			}
@@ -1079,7 +1088,7 @@ func (pool *TxPool) demoteUnexecutables() {
 		for _, tx := range list.Forward(nonce) {
 			hash := tx.Hash()
 			log.Trace("Removed old pending transaction", "hash", hash)
-			delete(pool.all, hash)
+			pool.all.Remove(hash)
 			pool.priced.Removed()
 		}
 		// Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later
@@ -1087,7 +1096,7 @@ func (pool *TxPool) demoteUnexecutables() {
 		for _, tx := range drops {
 			hash := tx.Hash()
 			log.Trace("Removed unpayable pending transaction", "hash", hash)
-			delete(pool.all, hash)
+			pool.all.Remove(hash)
 			pool.priced.Removed()
 			pendingNofundsCounter.Inc(1)
 		}
@@ -1096,7 +1105,7 @@ func (pool *TxPool) demoteUnexecutables() {
 			log.Trace("Demoting pending transaction", "hash", hash)
 			pool.enqueueTx(hash, tx)
 		}
-		// If there's a gap in front, warn (should never happen) and postpone all transactions
+		// If there's a gap in front, alert (should never happen) and postpone all transactions
 		if list.Len() > 0 && list.txs.Get(nonce) == nil {
 			for _, tx := range list.Cap(0) {
 				hash := tx.Hash()
@@ -1159,3 +1168,68 @@ func (as *accountSet) containsTx(tx *types.Transaction) bool {
 func (as *accountSet) add(addr common.Address) {
 	as.accounts[addr] = struct{}{}
 }
+
+// txLookup is used internally by TxPool to track transactions while allowing lookup without
+// mutex contention.
+//
+// Note, although this type is properly protected against concurrent access, it
+// is **not** a type that should ever be mutated or even exposed outside of the
+// transaction pool, since its internal state is tightly coupled with the pools
+// internal mechanisms. The sole purpose of the type is to permit out-of-bound
+// peeking into the pool in TxPool.Get without having to acquire the widely scoped
+// TxPool.mu mutex.
+type txLookup struct {
+	all  map[common.Hash]*types.Transaction
+	lock sync.RWMutex
+}
+
+// newTxLookup returns a new txLookup structure.
+func newTxLookup() *txLookup {
+	return &txLookup{
+		all: make(map[common.Hash]*types.Transaction),
+	}
+}
+
+// Range calls f on each key and value present in the map.
+func (t *txLookup) Range(f func(hash common.Hash, tx *types.Transaction) bool) {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
+
+	for key, value := range t.all {
+		if !f(key, value) {
+			break
+		}
+	}
+}
+
+// Get returns a transaction if it exists in the lookup, or nil if not found.
+func (t *txLookup) Get(hash common.Hash) *types.Transaction {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
+
+	return t.all[hash]
+}
+
+// Count returns the current number of items in the lookup.
+func (t *txLookup) Count() int {
+	t.lock.RLock()
+	defer t.lock.RUnlock()
+
+	return len(t.all)
+}
+
+// Add adds a transaction to the lookup.
+func (t *txLookup) Add(tx *types.Transaction) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	t.all[tx.Hash()] = tx
+}
+
+// Remove removes a transaction from the lookup.
+func (t *txLookup) Remove(hash common.Hash) {
+	t.lock.Lock()
+	defer t.lock.Unlock()
+
+	delete(t.all, hash)
+}
diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go
index 21171a7379..5a59205442 100644
--- a/core/tx_pool_test.go
+++ b/core/tx_pool_test.go
@@ -46,7 +46,7 @@ func init() {
 
 type testBlockChain struct {
 	statedb       *state.StateDB
-	gasLimit      *big.Int
+	gasLimit      uint64
 	chainHeadFeed *event.Feed
 }
 
@@ -68,19 +68,18 @@ func (bc *testBlockChain) SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) even
 	return bc.chainHeadFeed.Subscribe(ch)
 }
 
-func transaction(nonce uint64, gaslimit *big.Int, key *ecdsa.PrivateKey) *types.Transaction {
+func transaction(nonce uint64, gaslimit uint64, key *ecdsa.PrivateKey) *types.Transaction {
 	return pricedTransaction(nonce, gaslimit, big.NewInt(1), key)
 }
 
-func pricedTransaction(nonce uint64, gaslimit, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction {
+func pricedTransaction(nonce uint64, gaslimit uint64, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction {
 	tx, _ := types.SignTx(types.NewTransaction(nonce, common.Address{}, big.NewInt(100), gaslimit, gasprice, nil), types.HomesteadSigner{}, key)
 	return tx
 }
 
 func setupTxPool() (*TxPool, *ecdsa.PrivateKey) {
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	key, _ := crypto.GenerateKey()
 	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
@@ -95,7 +94,7 @@ func validateTxPoolInternals(pool *TxPool) error {
 
 	// Ensure the total transaction set is consistent with pending + queued
 	pending, queued := pool.stats()
-	if total := len(pool.all); total != pending+queued {
+	if total := pool.all.Count(); total != pending+queued {
 		return fmt.Errorf("total transaction count %d != %d pending + %d queued", total, pending, queued)
 	}
 	if priced := pool.priced.items.Len() - pool.priced.stales; priced != pending+queued {
@@ -119,21 +118,27 @@ func validateTxPoolInternals(pool *TxPool) error {
 
 // validateEvents checks that the correct number of transaction addition events
 // were fired on the pool's event feed.
-func validateEvents(events chan TxPreEvent, count int) error {
-	for i := 0; i < count; i++ {
+func validateEvents(events chan NewTxsEvent, count int) error {
+	var received []*types.Transaction
+
+	for len(received) < count {
 		select {
-		case <-events:
+		case ev := <-events:
+			received = append(received, ev.Txs...)
 		case <-time.After(time.Second):
-			return fmt.Errorf("event #%d not fired", i)
+			return fmt.Errorf("event #%d not fired", received)
 		}
 	}
+	if len(received) > count {
+		return fmt.Errorf("more than %d events fired: %v", count, received[count:])
+	}
 	select {
-	case tx := <-events:
-		return fmt.Errorf("more than %d events fired: %v", count, tx.Tx)
+	case ev := <-events:
+		return fmt.Errorf("more than %d events fired: %v", count, ev.Txs)
 
 	case <-time.After(50 * time.Millisecond):
 		// This branch should be "default", but it's a data race between goroutines,
-		// reading the event channel and pushng into it, so better wait a bit ensuring
+		// reading the event channel and pushing into it, so better wait a bit ensuring
 		// really nothing gets injected.
 	}
 	return nil
@@ -158,8 +163,7 @@ func (c *testChain) State() (*state.StateDB, error) {
 	// a state change between those fetches.
 	stdb := c.statedb
 	if *c.trigger {
-		db, _ := ethdb.NewMemDatabase()
-		c.statedb, _ = state.New(common.Hash{}, state.NewDatabase(db))
+		c.statedb, _ = state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 		// simulate that the new head block included tx0 and tx1
 		c.statedb.SetNonce(c.address, 2)
 		c.statedb.SetBalance(c.address, new(big.Int).SetUint64(params.Ether))
@@ -175,19 +179,18 @@ func TestStateChangeDuringTransactionPoolReset(t *testing.T) {
 	t.Parallel()
 
 	var (
-		db, _      = ethdb.NewMemDatabase()
 		key, _     = crypto.GenerateKey()
 		address    = crypto.PubkeyToAddress(key.PublicKey)
-		statedb, _ = state.New(common.Hash{}, state.NewDatabase(db))
+		statedb, _ = state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 		trigger    = false
 	)
 
 	// setup pool with 2 transaction in it
 	statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether))
-	blockchain := &testChain{&testBlockChain{statedb, big.NewInt(1000000000), new(event.Feed)}, address, &trigger}
+	blockchain := &testChain{&testBlockChain{statedb, 1000000000, new(event.Feed)}, address, &trigger}
 
-	tx0 := transaction(0, big.NewInt(100000), key)
-	tx1 := transaction(1, big.NewInt(100000), key)
+	tx0 := transaction(0, 100000, key)
+	tx1 := transaction(1, 100000, key)
 
 	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
 	defer pool.Stop()
@@ -209,15 +212,10 @@ func TestStateChangeDuringTransactionPoolReset(t *testing.T) {
 
 	pool.lockedReset(nil, nil)
 
-	pendingTx, err := pool.Pending()
+	_, err := pool.Pending()
 	if err != nil {
 		t.Fatalf("Could not fetch pending transactions: %v", err)
 	}
-
-	for addr, txs := range pendingTx {
-		t.Logf("%0x: %d\n", addr, len(txs))
-	}
-
 	nonce = pool.State().GetNonce(address)
 	if nonce != 2 {
 		t.Fatalf("Invalid nonce, want 2, got %d", nonce)
@@ -230,7 +228,7 @@ func TestInvalidTransactions(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	tx := transaction(0, big.NewInt(100), key)
+	tx := transaction(0, 100, key)
 	from, _ := deriveSender(tx)
 
 	pool.currentState.AddBalance(from, big.NewInt(1))
@@ -238,7 +236,7 @@ func TestInvalidTransactions(t *testing.T) {
 		t.Error("expected", ErrInsufficientFunds)
 	}
 
-	balance := new(big.Int).Add(tx.Value(), new(big.Int).Mul(tx.Gas(), tx.GasPrice()))
+	balance := new(big.Int).Add(tx.Value(), new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice()))
 	pool.currentState.AddBalance(from, balance)
 	if err := pool.AddRemote(tx); err != ErrIntrinsicGas {
 		t.Error("expected", ErrIntrinsicGas, "got", err)
@@ -246,12 +244,12 @@ func TestInvalidTransactions(t *testing.T) {
 
 	pool.currentState.SetNonce(from, 1)
 	pool.currentState.AddBalance(from, big.NewInt(0xffffffffffffff))
-	tx = transaction(0, big.NewInt(100000), key)
+	tx = transaction(0, 100000, key)
 	if err := pool.AddRemote(tx); err != ErrNonceTooLow {
 		t.Error("expected", ErrNonceTooLow)
 	}
 
-	tx = transaction(1, big.NewInt(100000), key)
+	tx = transaction(1, 100000, key)
 	pool.gasPrice = big.NewInt(1000)
 	if err := pool.AddRemote(tx); err != ErrUnderpriced {
 		t.Error("expected", ErrUnderpriced, "got", err)
@@ -267,7 +265,7 @@ func TestTransactionQueue(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	tx := transaction(0, big.NewInt(100), key)
+	tx := transaction(0, 100, key)
 	from, _ := deriveSender(tx)
 	pool.currentState.AddBalance(from, big.NewInt(1000))
 	pool.lockedReset(nil, nil)
@@ -278,7 +276,7 @@ func TestTransactionQueue(t *testing.T) {
 		t.Error("expected valid txs to be 1 is", len(pool.pending))
 	}
 
-	tx = transaction(1, big.NewInt(100), key)
+	tx = transaction(1, 100, key)
 	from, _ = deriveSender(tx)
 	pool.currentState.SetNonce(from, 2)
 	pool.enqueueTx(tx.Hash(), tx)
@@ -294,9 +292,9 @@ func TestTransactionQueue(t *testing.T) {
 	pool, key = setupTxPool()
 	defer pool.Stop()
 
-	tx1 := transaction(0, big.NewInt(100), key)
-	tx2 := transaction(10, big.NewInt(100), key)
-	tx3 := transaction(11, big.NewInt(100), key)
+	tx1 := transaction(0, 100, key)
+	tx2 := transaction(10, 100, key)
+	tx3 := transaction(11, 100, key)
 	from, _ = deriveSender(tx1)
 	pool.currentState.AddBalance(from, big.NewInt(1000))
 	pool.lockedReset(nil, nil)
@@ -321,7 +319,7 @@ func TestTransactionNegativeValue(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), big.NewInt(100), big.NewInt(1), nil), types.HomesteadSigner{}, key)
+	tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), 100, big.NewInt(1), nil), types.HomesteadSigner{}, key)
 	from, _ := deriveSender(tx)
 	pool.currentState.AddBalance(from, big.NewInt(1))
 	if err := pool.AddRemote(tx); err != ErrNegativeValue {
@@ -337,20 +335,19 @@ func TestTransactionChainFork(t *testing.T) {
 
 	addr := crypto.PubkeyToAddress(key.PublicKey)
 	resetState := func() {
-		db, _ := ethdb.NewMemDatabase()
-		statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
+		statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 		statedb.AddBalance(addr, big.NewInt(100000000000000))
 
-		pool.chain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+		pool.chain = &testBlockChain{statedb, 1000000, new(event.Feed)}
 		pool.lockedReset(nil, nil)
 	}
 	resetState()
 
-	tx := transaction(0, big.NewInt(100000), key)
+	tx := transaction(0, 100000, key)
 	if _, err := pool.add(tx, false); err != nil {
 		t.Error("didn't expect error", err)
 	}
-	pool.removeTx(tx.Hash())
+	pool.removeTx(tx.Hash(), true)
 
 	// reset the pool's internal state
 	resetState()
@@ -367,19 +364,18 @@ func TestTransactionDoubleNonce(t *testing.T) {
 
 	addr := crypto.PubkeyToAddress(key.PublicKey)
 	resetState := func() {
-		db, _ := ethdb.NewMemDatabase()
-		statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
+		statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 		statedb.AddBalance(addr, big.NewInt(100000000000000))
 
-		pool.chain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+		pool.chain = &testBlockChain{statedb, 1000000, new(event.Feed)}
 		pool.lockedReset(nil, nil)
 	}
 	resetState()
 
 	signer := types.HomesteadSigner{}
-	tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(100000), big.NewInt(1), nil), signer, key)
-	tx2, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(2), nil), signer, key)
-	tx3, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(1), nil), signer, key)
+	tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 100000, big.NewInt(1), nil), signer, key)
+	tx2, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(2), nil), signer, key)
+	tx3, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(1), nil), signer, key)
 
 	// Add the first two transaction, ensure higher priced stays only
 	if replace, err := pool.add(tx1, false); err != nil || replace {
@@ -405,8 +401,8 @@ func TestTransactionDoubleNonce(t *testing.T) {
 		t.Errorf("transaction mismatch: have %x, want %x", tx.Hash(), tx2.Hash())
 	}
 	// Ensure the total transaction count is correct
-	if len(pool.all) != 1 {
-		t.Error("expected 1 total transactions, got", len(pool.all))
+	if pool.all.Count() != 1 {
+		t.Error("expected 1 total transactions, got", pool.all.Count())
 	}
 }
 
@@ -418,7 +414,7 @@ func TestTransactionMissingNonce(t *testing.T) {
 
 	addr := crypto.PubkeyToAddress(key.PublicKey)
 	pool.currentState.AddBalance(addr, big.NewInt(100000000000000))
-	tx := transaction(1, big.NewInt(100000), key)
+	tx := transaction(1, 100000, key)
 	if _, err := pool.add(tx, false); err != nil {
 		t.Error("didn't expect error", err)
 	}
@@ -428,8 +424,8 @@ func TestTransactionMissingNonce(t *testing.T) {
 	if pool.queue[addr].Len() != 1 {
 		t.Error("expected 1 queued transaction, got", pool.queue[addr].Len())
 	}
-	if len(pool.all) != 1 {
-		t.Error("expected 1 total transactions, got", len(pool.all))
+	if pool.all.Count() != 1 {
+		t.Error("expected 1 total transactions, got", pool.all.Count())
 	}
 }
 
@@ -445,7 +441,7 @@ func TestTransactionNonceRecovery(t *testing.T) {
 	pool.currentState.AddBalance(addr, big.NewInt(100000000000000))
 	pool.lockedReset(nil, nil)
 
-	tx := transaction(n, big.NewInt(100000), key)
+	tx := transaction(n, 100000, key)
 	if err := pool.AddRemote(tx); err != nil {
 		t.Error(err)
 	}
@@ -466,17 +462,17 @@ func TestTransactionDropping(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000))
 
 	// Add some pending and some queued transactions
 	var (
-		tx0  = transaction(0, big.NewInt(100), key)
-		tx1  = transaction(1, big.NewInt(200), key)
-		tx2  = transaction(2, big.NewInt(300), key)
-		tx10 = transaction(10, big.NewInt(100), key)
-		tx11 = transaction(11, big.NewInt(200), key)
-		tx12 = transaction(12, big.NewInt(300), key)
+		tx0  = transaction(0, 100, key)
+		tx1  = transaction(1, 200, key)
+		tx2  = transaction(2, 300, key)
+		tx10 = transaction(10, 100, key)
+		tx11 = transaction(11, 200, key)
+		tx12 = transaction(12, 300, key)
 	)
 	pool.promoteTx(account, tx0.Hash(), tx0)
 	pool.promoteTx(account, tx1.Hash(), tx1)
@@ -492,8 +488,8 @@ func TestTransactionDropping(t *testing.T) {
 	if pool.queue[account].Len() != 3 {
 		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 3)
 	}
-	if len(pool.all) != 6 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 6)
+	if pool.all.Count() != 6 {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 6)
 	}
 	pool.lockedReset(nil, nil)
 	if pool.pending[account].Len() != 3 {
@@ -502,8 +498,8 @@ func TestTransactionDropping(t *testing.T) {
 	if pool.queue[account].Len() != 3 {
 		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 3)
 	}
-	if len(pool.all) != 6 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 6)
+	if pool.all.Count() != 6 {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 6)
 	}
 	// Reduce the balance of the account, and check that invalidated transactions are dropped
 	pool.currentState.AddBalance(account, big.NewInt(-650))
@@ -527,11 +523,11 @@ func TestTransactionDropping(t *testing.T) {
 	if _, ok := pool.queue[account].txs.items[tx12.Nonce()]; ok {
 		t.Errorf("out-of-fund queued transaction present: %v", tx11)
 	}
-	if len(pool.all) != 4 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4)
+	if pool.all.Count() != 4 {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 4)
 	}
 	// Reduce the block gas limit, check that invalidated transactions are dropped
-	pool.chain.(*testBlockChain).gasLimit = big.NewInt(100)
+	pool.chain.(*testBlockChain).gasLimit = 100
 	pool.lockedReset(nil, nil)
 
 	if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok {
@@ -546,8 +542,8 @@ func TestTransactionDropping(t *testing.T) {
 	if _, ok := pool.queue[account].txs.items[tx11.Nonce()]; ok {
 		t.Errorf("over-gased queued transaction present: %v", tx11)
 	}
-	if len(pool.all) != 2 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 2)
+	if pool.all.Count() != 2 {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), 2)
 	}
 }
 
@@ -557,74 +553,111 @@ func TestTransactionDropping(t *testing.T) {
 func TestTransactionPostponing(t *testing.T) {
 	t.Parallel()
 
-	// Create a test account and fund it
-	pool, key := setupTxPool()
+	// Create the pool to test the postponing with
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
+
+	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
-	pool.currentState.AddBalance(account, big.NewInt(1000))
+	// Create two test accounts to produce different gap profiles with
+	keys := make([]*ecdsa.PrivateKey, 2)
+	accs := make([]common.Address, len(keys))
 
+	for i := 0; i < len(keys); i++ {
+		keys[i], _ = crypto.GenerateKey()
+		accs[i] = crypto.PubkeyToAddress(keys[i].PublicKey)
+
+		pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(50100))
+	}
 	// Add a batch consecutive pending transactions for validation
-	txns := []*types.Transaction{}
-	for i := 0; i < 100; i++ {
-		var tx *types.Transaction
-		if i%2 == 0 {
-			tx = transaction(uint64(i), big.NewInt(100), key)
-		} else {
-			tx = transaction(uint64(i), big.NewInt(500), key)
+	txs := []*types.Transaction{}
+	for i, key := range keys {
+
+		for j := 0; j < 100; j++ {
+			var tx *types.Transaction
+			if (i+j)%2 == 0 {
+				tx = transaction(uint64(j), 25000, key)
+			} else {
+				tx = transaction(uint64(j), 50000, key)
+			}
+			txs = append(txs, tx)
+		}
+	}
+	for i, err := range pool.AddRemotes(txs) {
+		if err != nil {
+			t.Fatalf("tx %d: failed to add transactions: %v", i, err)
 		}
-		pool.promoteTx(account, tx.Hash(), tx)
-		txns = append(txns, tx)
 	}
 	// Check that pre and post validations leave the pool as is
-	if pool.pending[account].Len() != len(txns) {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), len(txns))
+	if pending := pool.pending[accs[0]].Len() + pool.pending[accs[1]].Len(); pending != len(txs) {
+		t.Errorf("pending transaction mismatch: have %d, want %d", pending, len(txs))
 	}
 	if len(pool.queue) != 0 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 0)
+		t.Errorf("queued accounts mismatch: have %d, want %d", len(pool.queue), 0)
 	}
-	if len(pool.all) != len(txns) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns))
+	if pool.all.Count() != len(txs) {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), len(txs))
 	}
 	pool.lockedReset(nil, nil)
-	if pool.pending[account].Len() != len(txns) {
-		t.Errorf("pending transaction mismatch: have %d, want %d", pool.pending[account].Len(), len(txns))
+	if pending := pool.pending[accs[0]].Len() + pool.pending[accs[1]].Len(); pending != len(txs) {
+		t.Errorf("pending transaction mismatch: have %d, want %d", pending, len(txs))
 	}
 	if len(pool.queue) != 0 {
-		t.Errorf("queued transaction mismatch: have %d, want %d", pool.queue[account].Len(), 0)
+		t.Errorf("queued accounts mismatch: have %d, want %d", len(pool.queue), 0)
 	}
-	if len(pool.all) != len(txns) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns))
+	if pool.all.Count() != len(txs) {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), len(txs))
 	}
 	// Reduce the balance of the account, and check that transactions are reorganised
-	pool.currentState.AddBalance(account, big.NewInt(-750))
+	for _, addr := range accs {
+		pool.currentState.AddBalance(addr, big.NewInt(-1))
+	}
 	pool.lockedReset(nil, nil)
 
-	if _, ok := pool.pending[account].txs.items[txns[0].Nonce()]; !ok {
-		t.Errorf("tx %d: valid and funded transaction missing from pending pool: %v", 0, txns[0])
+	// The first account's first transaction remains valid, check that subsequent
+	// ones are either filtered out, or queued up for later.
+	if _, ok := pool.pending[accs[0]].txs.items[txs[0].Nonce()]; !ok {
+		t.Errorf("tx %d: valid and funded transaction missing from pending pool: %v", 0, txs[0])
 	}
-	if _, ok := pool.queue[account].txs.items[txns[0].Nonce()]; ok {
-		t.Errorf("tx %d: valid and funded transaction present in future queue: %v", 0, txns[0])
+	if _, ok := pool.queue[accs[0]].txs.items[txs[0].Nonce()]; ok {
+		t.Errorf("tx %d: valid and funded transaction present in future queue: %v", 0, txs[0])
 	}
-	for i, tx := range txns[1:] {
+	for i, tx := range txs[1:100] {
 		if i%2 == 1 {
-			if _, ok := pool.pending[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.pending[accs[0]].txs.items[tx.Nonce()]; ok {
 				t.Errorf("tx %d: valid but future transaction present in pending pool: %v", i+1, tx)
 			}
-			if _, ok := pool.queue[account].txs.items[tx.Nonce()]; !ok {
+			if _, ok := pool.queue[accs[0]].txs.items[tx.Nonce()]; !ok {
 				t.Errorf("tx %d: valid but future transaction missing from future queue: %v", i+1, tx)
 			}
 		} else {
-			if _, ok := pool.pending[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.pending[accs[0]].txs.items[tx.Nonce()]; ok {
 				t.Errorf("tx %d: out-of-fund transaction present in pending pool: %v", i+1, tx)
 			}
-			if _, ok := pool.queue[account].txs.items[tx.Nonce()]; ok {
+			if _, ok := pool.queue[accs[0]].txs.items[tx.Nonce()]; ok {
 				t.Errorf("tx %d: out-of-fund transaction present in future queue: %v", i+1, tx)
 			}
 		}
 	}
-	if len(pool.all) != len(txns)/2 {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), len(txns)/2)
+	// The second account's first transaction got invalid, check that all transactions
+	// are either filtered out, or queued up for later.
+	if pool.pending[accs[1]] != nil {
+		t.Errorf("invalidated account still has pending transactions")
+	}
+	for i, tx := range txs[100:] {
+		if i%2 == 1 {
+			if _, ok := pool.queue[accs[1]].txs.items[tx.Nonce()]; !ok {
+				t.Errorf("tx %d: valid but future transaction missing from future queue: %v", 100+i, tx)
+			}
+		} else {
+			if _, ok := pool.queue[accs[1]].txs.items[tx.Nonce()]; ok {
+				t.Errorf("tx %d: out-of-fund transaction present in future queue: %v", 100+i, tx)
+			}
+		}
+	}
+	if pool.all.Count() != len(txs)/2 {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), len(txs)/2)
 	}
 }
 
@@ -638,19 +671,19 @@ func TestTransactionGapFilling(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	// Keep track of transaction events to ensure all executables get announced
-	events := make(chan TxPreEvent, testTxPoolConfig.AccountQueue+5)
+	events := make(chan NewTxsEvent, testTxPoolConfig.AccountQueue+5)
 	sub := pool.txFeed.Subscribe(events)
 	defer sub.Unsubscribe()
 
 	// Create a pending and a queued transaction with a nonce-gap in between
-	if err := pool.AddRemote(transaction(0, big.NewInt(100000), key)); err != nil {
+	if err := pool.AddRemote(transaction(0, 100000, key)); err != nil {
 		t.Fatalf("failed to add pending transaction: %v", err)
 	}
-	if err := pool.AddRemote(transaction(2, big.NewInt(100000), key)); err != nil {
+	if err := pool.AddRemote(transaction(2, 100000, key)); err != nil {
 		t.Fatalf("failed to add queued transaction: %v", err)
 	}
 	pending, queued := pool.Stats()
@@ -667,7 +700,7 @@ func TestTransactionGapFilling(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// Fill the nonce gap and ensure all transactions become pending
-	if err := pool.AddRemote(transaction(1, big.NewInt(100000), key)); err != nil {
+	if err := pool.AddRemote(transaction(1, 100000, key)); err != nil {
 		t.Fatalf("failed to add gapped transaction: %v", err)
 	}
 	pending, queued = pool.Stats()
@@ -694,12 +727,12 @@ func TestTransactionQueueAccountLimiting(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	// Keep queuing up transactions and make sure all above a limit are dropped
 	for i := uint64(1); i <= testTxPoolConfig.AccountQueue+5; i++ {
-		if err := pool.AddRemote(transaction(i, big.NewInt(100000), key)); err != nil {
+		if err := pool.AddRemote(transaction(i, 100000, key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
 		if len(pool.pending) != 0 {
@@ -715,8 +748,8 @@ func TestTransactionQueueAccountLimiting(t *testing.T) {
 			}
 		}
 	}
-	if len(pool.all) != int(testTxPoolConfig.AccountQueue) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), testTxPoolConfig.AccountQueue)
+	if pool.all.Count() != int(testTxPoolConfig.AccountQueue) {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), testTxPoolConfig.AccountQueue)
 	}
 }
 
@@ -736,9 +769,8 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) {
 	t.Parallel()
 
 	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.NoLocals = nolocals
@@ -763,7 +795,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) {
 		key := keys[rand.Intn(len(keys)-1)] // skip adding transactions with the local account
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 
-		txs = append(txs, transaction(nonces[addr]+1, big.NewInt(100000), key))
+		txs = append(txs, transaction(nonces[addr]+1, 100000, key))
 		nonces[addr]++
 	}
 	// Import the batch and verify that limits have been enforced
@@ -782,7 +814,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) {
 	// Generate a batch of transactions from the local account and import them
 	txs = txs[:0]
 	for i := uint64(0); i < 3*config.GlobalQueue; i++ {
-		txs = append(txs, transaction(i+1, big.NewInt(100000), local))
+		txs = append(txs, transaction(i+1, 100000, local))
 	}
 	pool.AddLocals(txs)
 
@@ -825,9 +857,8 @@ func testTransactionQueueTimeLimiting(t *testing.T, nolocals bool) {
 	evictionInterval = time.Second
 
 	// Create the pool to test the non-expiration enforcement
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.Lifetime = time.Second
@@ -844,10 +875,10 @@ func testTransactionQueueTimeLimiting(t *testing.T, nolocals bool) {
 	pool.currentState.AddBalance(crypto.PubkeyToAddress(remote.PublicKey), big.NewInt(1000000000))
 
 	// Add the two transactions and ensure they both are queued up
-	if err := pool.AddLocal(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), local)); err != nil {
+	if err := pool.AddLocal(pricedTransaction(1, 100000, big.NewInt(1), local)); err != nil {
 		t.Fatalf("failed to add local transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), remote)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), remote)); err != nil {
 		t.Fatalf("failed to add remote transaction: %v", err)
 	}
 	pending, queued := pool.Stats()
@@ -891,17 +922,17 @@ func TestTransactionPendingLimiting(t *testing.T) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	// Keep track of transaction events to ensure all executables get announced
-	events := make(chan TxPreEvent, testTxPoolConfig.AccountQueue+5)
+	events := make(chan NewTxsEvent, testTxPoolConfig.AccountQueue+5)
 	sub := pool.txFeed.Subscribe(events)
 	defer sub.Unsubscribe()
 
 	// Keep queuing up transactions and make sure all above a limit are dropped
 	for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ {
-		if err := pool.AddRemote(transaction(i, big.NewInt(100000), key)); err != nil {
+		if err := pool.AddRemote(transaction(i, 100000, key)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
 		if pool.pending[account].Len() != int(i)+1 {
@@ -911,8 +942,8 @@ func TestTransactionPendingLimiting(t *testing.T) {
 			t.Errorf("tx %d: queue size mismatch: have %d, want %d", i, pool.queue[account].Len(), 0)
 		}
 	}
-	if len(pool.all) != int(testTxPoolConfig.AccountQueue+5) {
-		t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), testTxPoolConfig.AccountQueue+5)
+	if pool.all.Count() != int(testTxPoolConfig.AccountQueue+5) {
+		t.Errorf("total transaction mismatch: have %d, want %d", pool.all.Count(), testTxPoolConfig.AccountQueue+5)
 	}
 	if err := validateEvents(events, int(testTxPoolConfig.AccountQueue+5)); err != nil {
 		t.Fatalf("event firing failed: %v", err)
@@ -934,11 +965,11 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) {
 	pool1, key1 := setupTxPool()
 	defer pool1.Stop()
 
-	account1, _ := deriveSender(transaction(0, big.NewInt(0), key1))
+	account1, _ := deriveSender(transaction(0, 0, key1))
 	pool1.currentState.AddBalance(account1, big.NewInt(1000000))
 
 	for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ {
-		if err := pool1.AddRemote(transaction(origin+i, big.NewInt(100000), key1)); err != nil {
+		if err := pool1.AddRemote(transaction(origin+i, 100000, key1)); err != nil {
 			t.Fatalf("tx %d: failed to add transaction: %v", i, err)
 		}
 	}
@@ -946,14 +977,14 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) {
 	pool2, key2 := setupTxPool()
 	defer pool2.Stop()
 
-	account2, _ := deriveSender(transaction(0, big.NewInt(0), key2))
+	account2, _ := deriveSender(transaction(0, 0, key2))
 	pool2.currentState.AddBalance(account2, big.NewInt(1000000))
 
-	txns := []*types.Transaction{}
+	txs := []*types.Transaction{}
 	for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ {
-		txns = append(txns, transaction(origin+i, big.NewInt(100000), key2))
+		txs = append(txs, transaction(origin+i, 100000, key2))
 	}
-	pool2.AddRemotes(txns)
+	pool2.AddRemotes(txs)
 
 	// Ensure the batch optimization honors the same pool mechanics
 	if len(pool1.pending) != len(pool2.pending) {
@@ -962,8 +993,8 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) {
 	if len(pool1.queue) != len(pool2.queue) {
 		t.Errorf("queued transaction count mismatch: one-by-one algo: %d, batch algo: %d", len(pool1.queue), len(pool2.queue))
 	}
-	if len(pool1.all) != len(pool2.all) {
-		t.Errorf("total transaction count mismatch: one-by-one algo %d, batch algo %d", len(pool1.all), len(pool2.all))
+	if pool1.all.Count() != pool2.all.Count() {
+		t.Errorf("total transaction count mismatch: one-by-one algo %d, batch algo %d", pool1.all.Count(), pool2.all.Count())
 	}
 	if err := validateTxPoolInternals(pool1); err != nil {
 		t.Errorf("pool 1 internal state corrupted: %v", err)
@@ -980,9 +1011,8 @@ func TestTransactionPendingGlobalLimiting(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.GlobalSlots = config.AccountSlots * 10
@@ -1003,7 +1033,7 @@ func TestTransactionPendingGlobalLimiting(t *testing.T) {
 	for _, key := range keys {
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 		for j := 0; j < int(config.GlobalSlots)/len(keys)*2; j++ {
-			txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key))
+			txs = append(txs, transaction(nonces[addr], 100000, key))
 			nonces[addr]++
 		}
 	}
@@ -1027,9 +1057,8 @@ func TestTransactionCapClearsFromAll(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.AccountSlots = 2
@@ -1046,7 +1075,7 @@ func TestTransactionCapClearsFromAll(t *testing.T) {
 
 	txs := types.Transactions{}
 	for j := 0; j < int(config.GlobalSlots)*2; j++ {
-		txs = append(txs, transaction(uint64(j), big.NewInt(100000), key))
+		txs = append(txs, transaction(uint64(j), 100000, key))
 	}
 	// Import the batch and verify that limits have been enforced
 	pool.AddRemotes(txs)
@@ -1062,9 +1091,8 @@ func TestTransactionPendingMinimumAllowance(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the limit enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.GlobalSlots = 0
@@ -1085,7 +1113,7 @@ func TestTransactionPendingMinimumAllowance(t *testing.T) {
 	for _, key := range keys {
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 		for j := 0; j < int(config.AccountSlots)*2; j++ {
-			txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key))
+			txs = append(txs, transaction(nonces[addr], 100000, key))
 			nonces[addr]++
 		}
 	}
@@ -1111,20 +1139,19 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the pricing enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
 	defer pool.Stop()
 
 	// Keep track of transaction events to ensure all executables get announced
-	events := make(chan TxPreEvent, 32)
+	events := make(chan NewTxsEvent, 32)
 	sub := pool.txFeed.Subscribe(events)
 	defer sub.Unsubscribe()
 
 	// Create a number of test accounts and fund them
-	keys := make([]*ecdsa.PrivateKey, 3)
+	keys := make([]*ecdsa.PrivateKey, 4)
 	for i := 0; i < len(keys); i++ {
 		keys[i], _ = crypto.GenerateKey()
 		pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
@@ -1132,28 +1159,32 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	// Generate and queue a batch of transactions, both pending and queued
 	txs := types.Transactions{}
 
-	txs = append(txs, pricedTransaction(0, big.NewInt(100000), big.NewInt(2), keys[0]))
-	txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[0]))
-	txs = append(txs, pricedTransaction(2, big.NewInt(100000), big.NewInt(2), keys[0]))
+	txs = append(txs, pricedTransaction(0, 100000, big.NewInt(2), keys[0]))
+	txs = append(txs, pricedTransaction(1, 100000, big.NewInt(1), keys[0]))
+	txs = append(txs, pricedTransaction(2, 100000, big.NewInt(2), keys[0]))
 
-	txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(2), keys[1]))
-	txs = append(txs, pricedTransaction(2, big.NewInt(100000), big.NewInt(1), keys[1]))
-	txs = append(txs, pricedTransaction(3, big.NewInt(100000), big.NewInt(2), keys[1]))
+	txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[1]))
+	txs = append(txs, pricedTransaction(1, 100000, big.NewInt(2), keys[1]))
+	txs = append(txs, pricedTransaction(2, 100000, big.NewInt(2), keys[1]))
 
-	ltx := pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[2])
+	txs = append(txs, pricedTransaction(1, 100000, big.NewInt(2), keys[2]))
+	txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[2]))
+	txs = append(txs, pricedTransaction(3, 100000, big.NewInt(2), keys[2]))
+
+	ltx := pricedTransaction(0, 100000, big.NewInt(1), keys[3])
 
 	// Import the batch and that both pending and queued transactions match up
 	pool.AddRemotes(txs)
 	pool.AddLocal(ltx)
 
 	pending, queued := pool.Stats()
-	if pending != 4 {
-		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 4)
+	if pending != 7 {
+		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 7)
 	}
 	if queued != 3 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 3)
 	}
-	if err := validateEvents(events, 4); err != nil {
+	if err := validateEvents(events, 7); err != nil {
 		t.Fatalf("original event firing failed: %v", err)
 	}
 	if err := validateTxPoolInternals(pool); err != nil {
@@ -1166,8 +1197,8 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	if pending != 2 {
 		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
 	}
-	if queued != 3 {
-		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 3)
+	if queued != 5 {
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 5)
 	}
 	if err := validateEvents(events, 0); err != nil {
 		t.Fatalf("reprice event firing failed: %v", err)
@@ -1176,10 +1207,13 @@ func TestTransactionPoolRepricing(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// Check that we can't add the old transactions back
-	if err := pool.AddRemote(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[0])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), keys[0])); err != ErrUnderpriced {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), keys[1])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced {
+		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
+	}
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), keys[2])); err != ErrUnderpriced {
 		t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	if err := validateEvents(events, 0); err != nil {
@@ -1189,7 +1223,7 @@ func TestTransactionPoolRepricing(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// However we can add local underpriced transactions
-	tx := pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[2])
+	tx := pricedTransaction(1, 100000, big.NewInt(1), keys[3])
 	if err := pool.AddLocal(tx); err != nil {
 		t.Fatalf("failed to add underpriced local transaction: %v", err)
 	}
@@ -1202,6 +1236,22 @@ func TestTransactionPoolRepricing(t *testing.T) {
 	if err := validateTxPoolInternals(pool); err != nil {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
+	// And we can fill gaps with properly priced transactions
+	if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(2), keys[0])); err != nil {
+		t.Fatalf("failed to add pending transaction: %v", err)
+	}
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), keys[1])); err != nil {
+		t.Fatalf("failed to add pending transaction: %v", err)
+	}
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), keys[2])); err != nil {
+		t.Fatalf("failed to add queued transaction: %v", err)
+	}
+	if err := validateEvents(events, 5); err != nil {
+		t.Fatalf("post-reprice event firing failed: %v", err)
+	}
+	if err := validateTxPoolInternals(pool); err != nil {
+		t.Fatalf("pool internal state corrupted: %v", err)
+	}
 }
 
 // Tests that setting the transaction pool gas price to a higher value does not
@@ -1210,9 +1260,8 @@ func TestTransactionPoolRepricingKeepsLocals(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the pricing enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
 	defer pool.Stop()
@@ -1226,12 +1275,12 @@ func TestTransactionPoolRepricingKeepsLocals(t *testing.T) {
 	// Create transaction (both pending and queued) with a linearly growing gasprice
 	for i := uint64(0); i < 500; i++ {
 		// Add pending
-		p_tx := pricedTransaction(i, big.NewInt(100000), big.NewInt(int64(i)), keys[2])
+		p_tx := pricedTransaction(i, 100000, big.NewInt(int64(i)), keys[2])
 		if err := pool.AddLocal(p_tx); err != nil {
 			t.Fatal(err)
 		}
 		// Add queued
-		q_tx := pricedTransaction(i+501, big.NewInt(100000), big.NewInt(int64(i)), keys[2])
+		q_tx := pricedTransaction(i+501, 100000, big.NewInt(int64(i)), keys[2])
 		if err := pool.AddLocal(q_tx); err != nil {
 			t.Fatal(err)
 		}
@@ -1273,9 +1322,8 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the pricing enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.GlobalSlots = 2
@@ -1285,12 +1333,12 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 	defer pool.Stop()
 
 	// Keep track of transaction events to ensure all executables get announced
-	events := make(chan TxPreEvent, 32)
+	events := make(chan NewTxsEvent, 32)
 	sub := pool.txFeed.Subscribe(events)
 	defer sub.Unsubscribe()
 
 	// Create a number of test accounts and fund them
-	keys := make([]*ecdsa.PrivateKey, 3)
+	keys := make([]*ecdsa.PrivateKey, 4)
 	for i := 0; i < len(keys); i++ {
 		keys[i], _ = crypto.GenerateKey()
 		pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
@@ -1298,12 +1346,12 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 	// Generate and queue a batch of transactions, both pending and queued
 	txs := types.Transactions{}
 
-	txs = append(txs, pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[0]))
-	txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(2), keys[0]))
+	txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[0]))
+	txs = append(txs, pricedTransaction(1, 100000, big.NewInt(2), keys[0]))
 
-	txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[1]))
+	txs = append(txs, pricedTransaction(1, 100000, big.NewInt(1), keys[1]))
 
-	ltx := pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[2])
+	ltx := pricedTransaction(0, 100000, big.NewInt(1), keys[2])
 
 	// Import the batch and that both pending and queued transactions match up
 	pool.AddRemotes(txs)
@@ -1323,17 +1371,17 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 		t.Fatalf("pool internal state corrupted: %v", err)
 	}
 	// Ensure that adding an underpriced transaction on block limit fails
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[1])); err != ErrUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced {
 		t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced)
 	}
 	// Ensure that adding high priced transactions drops cheap ones, but not own
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(3), keys[1])); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(3), keys[1])); err != nil { // +K1:0 => -K1:1 => Pend K0:0, K0:1, K1:0, K2:0; Que -
 		t.Fatalf("failed to add well priced transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(4), keys[1])); err != nil {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(4), keys[1])); err != nil { // +K1:2 => -K0:0 => Pend K1:0, K2:0; Que K0:1 K1:2
 		t.Fatalf("failed to add well priced transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(3, big.NewInt(100000), big.NewInt(5), keys[1])); err != nil {
+	if err := pool.AddRemote(pricedTransaction(3, 100000, big.NewInt(5), keys[1])); err != nil { // +K1:3 => -K0:1 => Pend K1:0, K2:0; Que K1:2 K1:3
 		t.Fatalf("failed to add well priced transaction: %v", err)
 	}
 	pending, queued = pool.Stats()
@@ -1343,25 +1391,29 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 	if queued != 2 {
 		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 2)
 	}
-	if err := validateEvents(events, 2); err != nil {
-		t.Fatalf("additional event firing failed: %v", err)
-	}
-	if err := validateTxPoolInternals(pool); err != nil {
-		t.Fatalf("pool internal state corrupted: %v", err)
-	}
-	// Ensure that adding local transactions can push out even higher priced ones
-	tx := pricedTransaction(1, big.NewInt(100000), big.NewInt(0), keys[2])
-	if err := pool.AddLocal(tx); err != nil {
-		t.Fatalf("failed to add underpriced local transaction: %v", err)
-	}
-	pending, queued = pool.Stats()
-	if pending != 2 {
-		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
-	}
-	if queued != 2 {
-		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 2)
-	}
 	if err := validateEvents(events, 1); err != nil {
+		t.Fatalf("additional event firing failed: %v", err)
+	}
+	if err := validateTxPoolInternals(pool); err != nil {
+		t.Fatalf("pool internal state corrupted: %v", err)
+	}
+	// Ensure that adding local transactions can push out even higher priced ones
+	ltx = pricedTransaction(1, 100000, big.NewInt(0), keys[2])
+	if err := pool.AddLocal(ltx); err != nil {
+		t.Fatalf("failed to append underpriced local transaction: %v", err)
+	}
+	ltx = pricedTransaction(0, 100000, big.NewInt(0), keys[3])
+	if err := pool.AddLocal(ltx); err != nil {
+		t.Fatalf("failed to add new underpriced local transaction: %v", err)
+	}
+	pending, queued = pool.Stats()
+	if pending != 3 {
+		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 3)
+	}
+	if queued != 1 {
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 1)
+	}
+	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("local event firing failed: %v", err)
 	}
 	if err := validateTxPoolInternals(pool); err != nil {
@@ -1369,21 +1421,87 @@ func TestTransactionPoolUnderpricing(t *testing.T) {
 	}
 }
 
+// Tests that more expensive transactions push out cheap ones from the pool, but
+// without producing instability by creating gaps that start jumping transactions
+// back and forth between queued/pending.
+func TestTransactionPoolStableUnderpricing(t *testing.T) {
+	t.Parallel()
+
+	// Create the pool to test the pricing enforcement with
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
+
+	config := testTxPoolConfig
+	config.GlobalSlots = 128
+	config.GlobalQueue = 0
+
+	pool := NewTxPool(config, params.TestChainConfig, blockchain)
+	defer pool.Stop()
+
+	// Keep track of transaction events to ensure all executables get announced
+	events := make(chan NewTxsEvent, 32)
+	sub := pool.txFeed.Subscribe(events)
+	defer sub.Unsubscribe()
+
+	// Create a number of test accounts and fund them
+	keys := make([]*ecdsa.PrivateKey, 2)
+	for i := 0; i < len(keys); i++ {
+		keys[i], _ = crypto.GenerateKey()
+		pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
+	}
+	// Fill up the entire queue with the same transaction price points
+	txs := types.Transactions{}
+	for i := uint64(0); i < config.GlobalSlots; i++ {
+		txs = append(txs, pricedTransaction(i, 100000, big.NewInt(1), keys[0]))
+	}
+	pool.AddRemotes(txs)
+
+	pending, queued := pool.Stats()
+	if pending != int(config.GlobalSlots) {
+		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots)
+	}
+	if queued != 0 {
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
+	}
+	if err := validateEvents(events, int(config.GlobalSlots)); err != nil {
+		t.Fatalf("original event firing failed: %v", err)
+	}
+	if err := validateTxPoolInternals(pool); err != nil {
+		t.Fatalf("pool internal state corrupted: %v", err)
+	}
+	// Ensure that adding high priced transactions drops a cheap, but doesn't produce a gap
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(3), keys[1])); err != nil {
+		t.Fatalf("failed to add well priced transaction: %v", err)
+	}
+	pending, queued = pool.Stats()
+	if pending != int(config.GlobalSlots) {
+		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, config.GlobalSlots)
+	}
+	if queued != 0 {
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 0)
+	}
+	if err := validateEvents(events, 1); err != nil {
+		t.Fatalf("additional event firing failed: %v", err)
+	}
+	if err := validateTxPoolInternals(pool); err != nil {
+		t.Fatalf("pool internal state corrupted: %v", err)
+	}
+}
+
 // Tests that the pool rejects replacement transactions that don't meet the minimum
 // price bump required.
 func TestTransactionReplacement(t *testing.T) {
 	t.Parallel()
 
 	// Create the pool to test the pricing enforcement with
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
 	defer pool.Stop()
 
 	// Keep track of transaction events to ensure all executables get announced
-	events := make(chan TxPreEvent, 32)
+	events := make(chan NewTxsEvent, 32)
 	sub := pool.txFeed.Subscribe(events)
 	defer sub.Unsubscribe()
 
@@ -1395,49 +1513,49 @@ func TestTransactionReplacement(t *testing.T) {
 	price := int64(100)
 	threshold := (price * (100 + int64(testTxPoolConfig.PriceBump))) / 100
 
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap pending transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100001), big.NewInt(1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced {
 		t.Fatalf("original cheap pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(2), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), key)); err != nil {
 		t.Fatalf("failed to replace original cheap pending transaction: %v", err)
 	}
 	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("cheap replacement event firing failed: %v", err)
 	}
 
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(price), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper pending transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100001), big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
 		t.Fatalf("original proper pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(threshold), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(threshold), key)); err != nil {
 		t.Fatalf("failed to replace original proper pending transaction: %v", err)
 	}
 	if err := validateEvents(events, 2); err != nil {
 		t.Fatalf("proper replacement event firing failed: %v", err)
 	}
 	// Add queued transactions, ensuring the minimum price bump is enforced for replacement (for ultra low prices too)
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), key)); err != nil {
 		t.Fatalf("failed to add original cheap queued transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100001), big.NewInt(1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced {
 		t.Fatalf("original cheap queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(2), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), key)); err != nil {
 		t.Fatalf("failed to replace original cheap queued transaction: %v", err)
 	}
 
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(price), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(price), key)); err != nil {
 		t.Fatalf("failed to add original proper queued transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100001), big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
+	if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced {
 		t.Fatalf("original proper queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced)
 	}
-	if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(threshold), key)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(threshold), key)); err != nil {
 		t.Fatalf("failed to replace original proper queued transaction: %v", err)
 	}
 
@@ -1470,9 +1588,8 @@ func testTransactionJournaling(t *testing.T, nolocals bool) {
 	os.Remove(journal)
 
 	// Create the original pool to inject transaction into the journal
-	db, _ := ethdb.NewMemDatabase()
-	statedb, _ := state.New(common.Hash{}, state.NewDatabase(db))
-	blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	config := testTxPoolConfig
 	config.NoLocals = nolocals
@@ -1489,16 +1606,16 @@ func testTransactionJournaling(t *testing.T, nolocals bool) {
 	pool.currentState.AddBalance(crypto.PubkeyToAddress(remote.PublicKey), big.NewInt(1000000000))
 
 	// Add three local and a remote transactions and ensure they are queued up
-	if err := pool.AddLocal(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), local)); err != nil {
+	if err := pool.AddLocal(pricedTransaction(0, 100000, big.NewInt(1), local)); err != nil {
 		t.Fatalf("failed to add local transaction: %v", err)
 	}
-	if err := pool.AddLocal(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), local)); err != nil {
+	if err := pool.AddLocal(pricedTransaction(1, 100000, big.NewInt(1), local)); err != nil {
 		t.Fatalf("failed to add local transaction: %v", err)
 	}
-	if err := pool.AddLocal(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), local)); err != nil {
+	if err := pool.AddLocal(pricedTransaction(2, 100000, big.NewInt(1), local)); err != nil {
 		t.Fatalf("failed to add local transaction: %v", err)
 	}
-	if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), remote)); err != nil {
+	if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), remote)); err != nil {
 		t.Fatalf("failed to add remote transaction: %v", err)
 	}
 	pending, queued := pool.Stats()
@@ -1514,7 +1631,7 @@ func testTransactionJournaling(t *testing.T, nolocals bool) {
 	// Terminate the old pool, bump the local nonce, create a new pool and ensure relevant transaction survive
 	pool.Stop()
 	statedb.SetNonce(crypto.PubkeyToAddress(local.PublicKey), 1)
-	blockchain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	blockchain = &testBlockChain{statedb, 1000000, new(event.Feed)}
 
 	pool = NewTxPool(config, params.TestChainConfig, blockchain)
 
@@ -1541,7 +1658,7 @@ func testTransactionJournaling(t *testing.T, nolocals bool) {
 	pool.Stop()
 
 	statedb.SetNonce(crypto.PubkeyToAddress(local.PublicKey), 1)
-	blockchain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)}
+	blockchain = &testBlockChain{statedb, 1000000, new(event.Feed)}
 	pool = NewTxPool(config, params.TestChainConfig, blockchain)
 
 	pending, queued = pool.Stats()
@@ -1563,6 +1680,62 @@ func testTransactionJournaling(t *testing.T, nolocals bool) {
 	pool.Stop()
 }
 
+// TestTransactionStatusCheck tests that the pool can correctly retrieve the
+// pending status of individual transactions.
+func TestTransactionStatusCheck(t *testing.T) {
+	t.Parallel()
+
+	// Create the pool to test the status retrievals with
+	statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
+	blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)}
+
+	pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain)
+	defer pool.Stop()
+
+	// Create the test accounts to check various transaction statuses with
+	keys := make([]*ecdsa.PrivateKey, 3)
+	for i := 0; i < len(keys); i++ {
+		keys[i], _ = crypto.GenerateKey()
+		pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000))
+	}
+	// Generate and queue a batch of transactions, both pending and queued
+	txs := types.Transactions{}
+
+	txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[0])) // Pending only
+	txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[1])) // Pending and queued
+	txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[1]))
+	txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[2])) // Queued only
+
+	// Import the transaction and ensure they are correctly added
+	pool.AddRemotes(txs)
+
+	pending, queued := pool.Stats()
+	if pending != 2 {
+		t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2)
+	}
+	if queued != 2 {
+		t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 2)
+	}
+	if err := validateTxPoolInternals(pool); err != nil {
+		t.Fatalf("pool internal state corrupted: %v", err)
+	}
+	// Retrieve the status of each transaction and validate them
+	hashes := make([]common.Hash, len(txs))
+	for i, tx := range txs {
+		hashes[i] = tx.Hash()
+	}
+	hashes = append(hashes, common.Hash{})
+
+	statuses := pool.Status(hashes)
+	expect := []TxStatus{TxStatusPending, TxStatusPending, TxStatusQueued, TxStatusQueued, TxStatusUnknown}
+
+	for i := 0; i < len(statuses); i++ {
+		if statuses[i] != expect[i] {
+			t.Errorf("transaction %d: status mismatch: have %v, want %v", i, statuses[i], expect[i])
+		}
+	}
+}
+
 // Benchmarks the speed of validating the contents of the pending queue of the
 // transaction pool.
 func BenchmarkPendingDemotion100(b *testing.B)   { benchmarkPendingDemotion(b, 100) }
@@ -1574,11 +1747,11 @@ func benchmarkPendingDemotion(b *testing.B, size int) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	for i := 0; i < size; i++ {
-		tx := transaction(uint64(i), big.NewInt(100000), key)
+		tx := transaction(uint64(i), 100000, key)
 		pool.promoteTx(account, tx.Hash(), tx)
 	}
 	// Benchmark the speed of pool validation
@@ -1599,11 +1772,11 @@ func benchmarkFuturePromotion(b *testing.B, size int) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	for i := 0; i < size; i++ {
-		tx := transaction(uint64(1+i), big.NewInt(100000), key)
+		tx := transaction(uint64(1+i), 100000, key)
 		pool.enqueueTx(tx.Hash(), tx)
 	}
 	// Benchmark the speed of pool validation
@@ -1619,12 +1792,12 @@ func BenchmarkPoolInsert(b *testing.B) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	txs := make(types.Transactions, b.N)
 	for i := 0; i < b.N; i++ {
-		txs[i] = transaction(uint64(i), big.NewInt(100000), key)
+		txs[i] = transaction(uint64(i), 100000, key)
 	}
 	// Benchmark importing the transactions into the queue
 	b.ResetTimer()
@@ -1643,14 +1816,14 @@ func benchmarkPoolBatchInsert(b *testing.B, size int) {
 	pool, key := setupTxPool()
 	defer pool.Stop()
 
-	account, _ := deriveSender(transaction(0, big.NewInt(0), key))
+	account, _ := deriveSender(transaction(0, 0, key))
 	pool.currentState.AddBalance(account, big.NewInt(1000000))
 
 	batches := make([]types.Transactions, b.N)
 	for i := 0; i < b.N; i++ {
 		batches[i] = make(types.Transactions, size)
 		for j := 0; j < size; j++ {
-			batches[i][j] = transaction(uint64(size*i+j), big.NewInt(100000), key)
+			batches[i][j] = transaction(uint64(size*i+j), 100000, key)
 		}
 	}
 	// Benchmark importing the transactions into the queue
diff --git a/core/types.go b/core/types.go
index 1cfbbab29b..d0bbaf0aa7 100644
--- a/core/types.go
+++ b/core/types.go
@@ -17,8 +17,6 @@
 package core
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -34,7 +32,7 @@ type Validator interface {
 
 	// ValidateState validates the given statedb and optionally the receipts and
 	// gas used.
-	ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error
+	ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas uint64) error
 }
 
 // Processor is an interface for processing blocks using a given initial state.
@@ -44,5 +42,5 @@ type Validator interface {
 // of gas used in the process and return an error if any of the internal rules
 // failed.
 type Processor interface {
-	Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error)
+	Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error)
 }
diff --git a/core/types/block.go b/core/types/block.go
index 1d00d9f930..ae1b4299d3 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -19,12 +19,12 @@ package types
 
 import (
 	"encoding/binary"
-	"fmt"
 	"io"
 	"math/big"
 	"sort"
 	"sync/atomic"
 	"time"
+	"unsafe"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -77,8 +77,8 @@ type Header struct {
 	Bloom       Bloom          `json:"logsBloom"        gencodec:"required"`
 	Difficulty  *big.Int       `json:"difficulty"       gencodec:"required"`
 	Number      *big.Int       `json:"number"           gencodec:"required"`
-	GasLimit    *big.Int       `json:"gasLimit"         gencodec:"required"`
-	GasUsed     *big.Int       `json:"gasUsed"          gencodec:"required"`
+	GasLimit    uint64         `json:"gasLimit"         gencodec:"required"`
+	GasUsed     uint64         `json:"gasUsed"          gencodec:"required"`
 	Time        *big.Int       `json:"timestamp"        gencodec:"required"`
 	Extra       []byte         `json:"extraData"        gencodec:"required"`
 	MixDigest   common.Hash    `json:"mixHash"          gencodec:"required"`
@@ -89,8 +89,8 @@ type Header struct {
 type headerMarshaling struct {
 	Difficulty *hexutil.Big
 	Number     *hexutil.Big
-	GasLimit   *hexutil.Big
-	GasUsed    *hexutil.Big
+	GasLimit   hexutil.Uint64
+	GasUsed    hexutil.Uint64
 	Time       *hexutil.Big
 	Extra      hexutil.Bytes
 	Hash       common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON
@@ -121,6 +121,12 @@ func (h *Header) HashNoNonce() common.Hash {
 	})
 }
 
+// Size returns the approximate memory used by all internal contents. It is used
+// to approximate and limit the memory consumption of various caches.
+func (h *Header) Size() common.StorageSize {
+	return common.StorageSize(unsafe.Sizeof(*h)) + common.StorageSize(len(h.Extra)+(h.Difficulty.BitLen()+h.Number.BitLen()+h.Time.BitLen())/8)
+}
+
 func rlpHash(x interface{}) (h common.Hash) {
 	hw := sha3.NewKeccak256()
 	rlp.Encode(hw, x)
@@ -243,12 +249,6 @@ func CopyHeader(h *Header) *Header {
 	if cpy.Number = new(big.Int); h.Number != nil {
 		cpy.Number.Set(h.Number)
 	}
-	if cpy.GasLimit = new(big.Int); h.GasLimit != nil {
-		cpy.GasLimit.Set(h.GasLimit)
-	}
-	if cpy.GasUsed = new(big.Int); h.GasUsed != nil {
-		cpy.GasUsed.Set(h.GasUsed)
-	}
 	if len(h.Extra) > 0 {
 		cpy.Extra = make([]byte, len(h.Extra))
 		copy(cpy.Extra, h.Extra)
@@ -302,8 +302,8 @@ func (b *Block) Transaction(hash common.Hash) *Transaction {
 }
 
 func (b *Block) Number() *big.Int     { return new(big.Int).Set(b.header.Number) }
-func (b *Block) GasLimit() *big.Int   { return new(big.Int).Set(b.header.GasLimit) }
-func (b *Block) GasUsed() *big.Int    { return new(big.Int).Set(b.header.GasUsed) }
+func (b *Block) GasLimit() uint64     { return b.header.GasLimit }
+func (b *Block) GasUsed() uint64      { return b.header.GasUsed }
 func (b *Block) Difficulty() *big.Int { return new(big.Int).Set(b.header.Difficulty) }
 func (b *Block) Time() *big.Int       { return new(big.Int).Set(b.header.Time) }
 
@@ -328,6 +328,8 @@ func (b *Block) HashNoNonce() common.Hash {
 	return b.header.HashNoNonce()
 }
 
+// Size returns the true RLP encoded storage size of the block, either by encoding
+// and returning it, or returning a previsouly cached value.
 func (b *Block) Size() common.StorageSize {
 	if size := b.size.Load(); size != nil {
 		return size.(common.StorageSize)
@@ -386,40 +388,6 @@ func (b *Block) Hash() common.Hash {
 	return v
 }
 
-func (b *Block) String() string {
-	str := fmt.Sprintf(`Block(#%v): Size: %v {
-MinerHash: %x
-%v
-Transactions:
-%v
-Uncles:
-%v
-}
-`, b.Number(), b.Size(), b.header.HashNoNonce(), b.header, b.transactions, b.uncles)
-	return str
-}
-
-func (h *Header) String() string {
-	return fmt.Sprintf(`Header(%x):
-[
-	ParentHash:	    %x
-	UncleHash:	    %x
-	Coinbase:	    %x
-	Root:		    %x
-	TxSha		    %x
-	ReceiptSha:	    %x
-	Bloom:		    %x
-	Difficulty:	    %v
-	Number:		    %v
-	GasLimit:	    %v
-	GasUsed:	    %v
-	Time:		    %v
-	Extra:		    %s
-	MixDigest:      %x
-	Nonce:		    %x
-]`, h.Hash(), h.ParentHash, h.UncleHash, h.Coinbase, h.Root, h.TxHash, h.ReceiptHash, h.Bloom, h.Difficulty, h.Number, h.GasLimit, h.GasUsed, h.Time, h.Extra, h.MixDigest, h.Nonce)
-}
-
 type Blocks []*Block
 
 type BlockBy func(b1, b2 *Block) bool
diff --git a/core/types/block_test.go b/core/types/block_test.go
index 93435ca00c..a35fbc25b1 100644
--- a/core/types/block_test.go
+++ b/core/types/block_test.go
@@ -41,8 +41,8 @@ func TestBlockEncoding(t *testing.T) {
 		}
 	}
 	check("Difficulty", block.Difficulty(), big.NewInt(131072))
-	check("GasLimit", block.GasLimit(), big.NewInt(3141592))
-	check("GasUsed", block.GasUsed(), big.NewInt(21000))
+	check("GasLimit", block.GasLimit(), uint64(3141592))
+	check("GasUsed", block.GasUsed(), uint64(21000))
 	check("Coinbase", block.Coinbase(), common.HexToAddress("8888f1f195afa192cfee860698584c030f4c9db1"))
 	check("MixDigest", block.MixDigest(), common.HexToHash("bd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff498"))
 	check("Root", block.Root(), common.HexToHash("ef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017"))
@@ -51,7 +51,7 @@ func TestBlockEncoding(t *testing.T) {
 	check("Time", block.Time(), big.NewInt(1426516743))
 	check("Size", block.Size(), common.StorageSize(len(blockEnc)))
 
-	tx1 := NewTransaction(0, common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"), big.NewInt(10), big.NewInt(50000), big.NewInt(10), nil)
+	tx1 := NewTransaction(0, common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"), big.NewInt(10), 50000, big.NewInt(10), nil)
 
 	tx1, _ = tx1.WithSignature(HomesteadSigner{}, common.Hex2Bytes("9bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094f8a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b100"))
 	fmt.Println(block.Transactions()[0].Hash())
diff --git a/core/types/gen_header_json.go b/core/types/gen_header_json.go
index bcff7a940d..1b92cd9cf4 100644
--- a/core/types/gen_header_json.go
+++ b/core/types/gen_header_json.go
@@ -11,6 +11,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
+var _ = (*headerMarshaling)(nil)
+
 func (h Header) MarshalJSON() ([]byte, error) {
 	type Header struct {
 		ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"`
@@ -22,8 +24,8 @@ func (h Header) MarshalJSON() ([]byte, error) {
 		Bloom       Bloom          `json:"logsBloom"        gencodec:"required"`
 		Difficulty  *hexutil.Big   `json:"difficulty"       gencodec:"required"`
 		Number      *hexutil.Big   `json:"number"           gencodec:"required"`
-		GasLimit    *hexutil.Big   `json:"gasLimit"         gencodec:"required"`
-		GasUsed     *hexutil.Big   `json:"gasUsed"          gencodec:"required"`
+		GasLimit    hexutil.Uint64 `json:"gasLimit"         gencodec:"required"`
+		GasUsed     hexutil.Uint64 `json:"gasUsed"          gencodec:"required"`
 		Time        *hexutil.Big   `json:"timestamp"        gencodec:"required"`
 		Extra       hexutil.Bytes  `json:"extraData"        gencodec:"required"`
 		MixDigest   common.Hash    `json:"mixHash"          gencodec:"required"`
@@ -40,8 +42,8 @@ func (h Header) MarshalJSON() ([]byte, error) {
 	enc.Bloom = h.Bloom
 	enc.Difficulty = (*hexutil.Big)(h.Difficulty)
 	enc.Number = (*hexutil.Big)(h.Number)
-	enc.GasLimit = (*hexutil.Big)(h.GasLimit)
-	enc.GasUsed = (*hexutil.Big)(h.GasUsed)
+	enc.GasLimit = hexutil.Uint64(h.GasLimit)
+	enc.GasUsed = hexutil.Uint64(h.GasUsed)
 	enc.Time = (*hexutil.Big)(h.Time)
 	enc.Extra = h.Extra
 	enc.MixDigest = h.MixDigest
@@ -61,10 +63,10 @@ func (h *Header) UnmarshalJSON(input []byte) error {
 		Bloom       *Bloom          `json:"logsBloom"        gencodec:"required"`
 		Difficulty  *hexutil.Big    `json:"difficulty"       gencodec:"required"`
 		Number      *hexutil.Big    `json:"number"           gencodec:"required"`
-		GasLimit    *hexutil.Big    `json:"gasLimit"         gencodec:"required"`
-		GasUsed     *hexutil.Big    `json:"gasUsed"          gencodec:"required"`
+		GasLimit    *hexutil.Uint64 `json:"gasLimit"         gencodec:"required"`
+		GasUsed     *hexutil.Uint64 `json:"gasUsed"          gencodec:"required"`
 		Time        *hexutil.Big    `json:"timestamp"        gencodec:"required"`
-		Extra       hexutil.Bytes   `json:"extraData"        gencodec:"required"`
+		Extra       *hexutil.Bytes  `json:"extraData"        gencodec:"required"`
 		MixDigest   *common.Hash    `json:"mixHash"          gencodec:"required"`
 		Nonce       *BlockNonce     `json:"nonce"            gencodec:"required"`
 	}
@@ -111,11 +113,11 @@ func (h *Header) UnmarshalJSON(input []byte) error {
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'gasLimit' for Header")
 	}
-	h.GasLimit = (*big.Int)(dec.GasLimit)
+	h.GasLimit = uint64(*dec.GasLimit)
 	if dec.GasUsed == nil {
 		return errors.New("missing required field 'gasUsed' for Header")
 	}
-	h.GasUsed = (*big.Int)(dec.GasUsed)
+	h.GasUsed = uint64(*dec.GasUsed)
 	if dec.Time == nil {
 		return errors.New("missing required field 'timestamp' for Header")
 	}
@@ -123,7 +125,7 @@ func (h *Header) UnmarshalJSON(input []byte) error {
 	if dec.Extra == nil {
 		return errors.New("missing required field 'extraData' for Header")
 	}
-	h.Extra = dec.Extra
+	h.Extra = *dec.Extra
 	if dec.MixDigest == nil {
 		return errors.New("missing required field 'mixHash' for Header")
 	}
diff --git a/core/types/gen_log_json.go b/core/types/gen_log_json.go
index 92c699c2a7..1b5ae3c653 100644
--- a/core/types/gen_log_json.go
+++ b/core/types/gen_log_json.go
@@ -10,6 +10,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
+var _ = (*logMarshaling)(nil)
+
 func (l Log) MarshalJSON() ([]byte, error) {
 	type Log struct {
 		Address     common.Address `json:"address" gencodec:"required"`
@@ -39,7 +41,7 @@ func (l *Log) UnmarshalJSON(input []byte) error {
 	type Log struct {
 		Address     *common.Address `json:"address" gencodec:"required"`
 		Topics      []common.Hash   `json:"topics" gencodec:"required"`
-		Data        hexutil.Bytes   `json:"data" gencodec:"required"`
+		Data        *hexutil.Bytes  `json:"data" gencodec:"required"`
 		BlockNumber *hexutil.Uint64 `json:"blockNumber"`
 		TxHash      *common.Hash    `json:"transactionHash" gencodec:"required"`
 		TxIndex     *hexutil.Uint   `json:"transactionIndex" gencodec:"required"`
@@ -62,7 +64,7 @@ func (l *Log) UnmarshalJSON(input []byte) error {
 	if dec.Data == nil {
 		return errors.New("missing required field 'data' for Log")
 	}
-	l.Data = dec.Data
+	l.Data = *dec.Data
 	if dec.BlockNumber != nil {
 		l.BlockNumber = uint64(*dec.BlockNumber)
 	}
diff --git a/core/types/gen_receipt_json.go b/core/types/gen_receipt_json.go
index b95d99c951..5c807a4ccb 100644
--- a/core/types/gen_receipt_json.go
+++ b/core/types/gen_receipt_json.go
@@ -5,60 +5,63 @@ package types
 import (
 	"encoding/json"
 	"errors"
-	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
+var _ = (*receiptMarshaling)(nil)
+
+// MarshalJSON marshals as JSON.
 func (r Receipt) MarshalJSON() ([]byte, error) {
 	type Receipt struct {
 		PostState         hexutil.Bytes  `json:"root"`
-		Status            hexutil.Uint   `json:"status"`
-		CumulativeGasUsed *hexutil.Big   `json:"cumulativeGasUsed" gencodec:"required"`
+		Status            hexutil.Uint64 `json:"status"`
+		CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
 		Bloom             Bloom          `json:"logsBloom"         gencodec:"required"`
 		Logs              []*Log         `json:"logs"              gencodec:"required"`
 		TxHash            common.Hash    `json:"transactionHash" gencodec:"required"`
 		ContractAddress   common.Address `json:"contractAddress"`
-		GasUsed           *hexutil.Big   `json:"gasUsed" gencodec:"required"`
+		GasUsed           hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
 	}
 	var enc Receipt
 	enc.PostState = r.PostState
-	enc.Status = hexutil.Uint(r.Status)
-	enc.CumulativeGasUsed = (*hexutil.Big)(r.CumulativeGasUsed)
+	enc.Status = hexutil.Uint64(r.Status)
+	enc.CumulativeGasUsed = hexutil.Uint64(r.CumulativeGasUsed)
 	enc.Bloom = r.Bloom
 	enc.Logs = r.Logs
 	enc.TxHash = r.TxHash
 	enc.ContractAddress = r.ContractAddress
-	enc.GasUsed = (*hexutil.Big)(r.GasUsed)
+	enc.GasUsed = hexutil.Uint64(r.GasUsed)
 	return json.Marshal(&enc)
 }
 
+// UnmarshalJSON unmarshals from JSON.
 func (r *Receipt) UnmarshalJSON(input []byte) error {
 	type Receipt struct {
-		PostState         hexutil.Bytes   `json:"root"`
-		Status            *hexutil.Uint   `json:"status"`
-		CumulativeGasUsed *hexutil.Big    `json:"cumulativeGasUsed" gencodec:"required"`
+		PostState         *hexutil.Bytes  `json:"root"`
+		Status            *hexutil.Uint64 `json:"status"`
+		CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
 		Bloom             *Bloom          `json:"logsBloom"         gencodec:"required"`
 		Logs              []*Log          `json:"logs"              gencodec:"required"`
 		TxHash            *common.Hash    `json:"transactionHash" gencodec:"required"`
 		ContractAddress   *common.Address `json:"contractAddress"`
-		GasUsed           *hexutil.Big    `json:"gasUsed" gencodec:"required"`
+		GasUsed           *hexutil.Uint64 `json:"gasUsed" gencodec:"required"`
 	}
 	var dec Receipt
 	if err := json.Unmarshal(input, &dec); err != nil {
 		return err
 	}
 	if dec.PostState != nil {
-		r.PostState = dec.PostState
+		r.PostState = *dec.PostState
 	}
 	if dec.Status != nil {
-		r.Status = uint(*dec.Status)
+		r.Status = uint64(*dec.Status)
 	}
 	if dec.CumulativeGasUsed == nil {
 		return errors.New("missing required field 'cumulativeGasUsed' for Receipt")
 	}
-	r.CumulativeGasUsed = (*big.Int)(dec.CumulativeGasUsed)
+	r.CumulativeGasUsed = uint64(*dec.CumulativeGasUsed)
 	if dec.Bloom == nil {
 		return errors.New("missing required field 'logsBloom' for Receipt")
 	}
@@ -77,6 +80,6 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
 	if dec.GasUsed == nil {
 		return errors.New("missing required field 'gasUsed' for Receipt")
 	}
-	r.GasUsed = (*big.Int)(dec.GasUsed)
+	r.GasUsed = uint64(*dec.GasUsed)
 	return nil
 }
diff --git a/core/types/gen_tx_json.go b/core/types/gen_tx_json.go
index 4fb658e0d9..c27da67096 100644
--- a/core/types/gen_tx_json.go
+++ b/core/types/gen_tx_json.go
@@ -11,11 +11,13 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
+var _ = (*txdataMarshaling)(nil)
+
 func (t txdata) MarshalJSON() ([]byte, error) {
 	type txdata struct {
 		AccountNonce hexutil.Uint64  `json:"nonce"    gencodec:"required"`
 		Price        *hexutil.Big    `json:"gasPrice" gencodec:"required"`
-		GasLimit     *hexutil.Big    `json:"gas"      gencodec:"required"`
+		GasLimit     hexutil.Uint64  `json:"gas"      gencodec:"required"`
 		Recipient    *common.Address `json:"to"       rlp:"nil"`
 		Amount       *hexutil.Big    `json:"value"    gencodec:"required"`
 		Payload      hexutil.Bytes   `json:"input"    gencodec:"required"`
@@ -27,7 +29,7 @@ func (t txdata) MarshalJSON() ([]byte, error) {
 	var enc txdata
 	enc.AccountNonce = hexutil.Uint64(t.AccountNonce)
 	enc.Price = (*hexutil.Big)(t.Price)
-	enc.GasLimit = (*hexutil.Big)(t.GasLimit)
+	enc.GasLimit = hexutil.Uint64(t.GasLimit)
 	enc.Recipient = t.Recipient
 	enc.Amount = (*hexutil.Big)(t.Amount)
 	enc.Payload = t.Payload
@@ -42,10 +44,10 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
 	type txdata struct {
 		AccountNonce *hexutil.Uint64 `json:"nonce"    gencodec:"required"`
 		Price        *hexutil.Big    `json:"gasPrice" gencodec:"required"`
-		GasLimit     *hexutil.Big    `json:"gas"      gencodec:"required"`
+		GasLimit     *hexutil.Uint64 `json:"gas"      gencodec:"required"`
 		Recipient    *common.Address `json:"to"       rlp:"nil"`
 		Amount       *hexutil.Big    `json:"value"    gencodec:"required"`
-		Payload      hexutil.Bytes   `json:"input"    gencodec:"required"`
+		Payload      *hexutil.Bytes  `json:"input"    gencodec:"required"`
 		V            *hexutil.Big    `json:"v" gencodec:"required"`
 		R            *hexutil.Big    `json:"r" gencodec:"required"`
 		S            *hexutil.Big    `json:"s" gencodec:"required"`
@@ -66,7 +68,7 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'gas' for txdata")
 	}
-	t.GasLimit = (*big.Int)(dec.GasLimit)
+	t.GasLimit = uint64(*dec.GasLimit)
 	if dec.Recipient != nil {
 		t.Recipient = dec.Recipient
 	}
@@ -77,7 +79,7 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
 	if dec.Payload == nil {
 		return errors.New("missing required field 'input' for txdata")
 	}
-	t.Payload = dec.Payload
+	t.Payload = *dec.Payload
 	if dec.V == nil {
 		return errors.New("missing required field 'v' for txdata")
 	}
diff --git a/core/types/log.go b/core/types/log.go
index be5de38da7..b629b47ed5 100644
--- a/core/types/log.go
+++ b/core/types/log.go
@@ -17,7 +17,6 @@
 package types
 
 import (
-	"fmt"
 	"io"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -95,10 +94,6 @@ func (l *Log) DecodeRLP(s *rlp.Stream) error {
 	return err
 }
 
-func (l *Log) String() string {
-	return fmt.Sprintf(`log: %x %x %x %x %d %x %d`, l.Address, l.Topics, l.Data, l.TxHash, l.TxIndex, l.BlockHash, l.Index)
-}
-
 // LogForStorage is a wrapper around a Log that flattens and parses the entire content of
 // a log including non-consensus fields.
 type LogForStorage Log
diff --git a/core/types/receipt.go b/core/types/receipt.go
index bc3c996b4f..3d1fc95aab 100644
--- a/core/types/receipt.go
+++ b/core/types/receipt.go
@@ -20,7 +20,7 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"math/big"
+	"unsafe"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -36,55 +36,55 @@ var (
 
 const (
 	// ReceiptStatusFailed is the status code of a transaction if execution failed.
-	ReceiptStatusFailed = uint(0)
+	ReceiptStatusFailed = uint64(0)
 
 	// ReceiptStatusSuccessful is the status code of a transaction if execution succeeded.
-	ReceiptStatusSuccessful = uint(1)
+	ReceiptStatusSuccessful = uint64(1)
 )
 
 // Receipt represents the results of a transaction.
 type Receipt struct {
 	// Consensus fields
-	PostState         []byte   `json:"root"`
-	Status            uint     `json:"status"`
-	CumulativeGasUsed *big.Int `json:"cumulativeGasUsed" gencodec:"required"`
-	Bloom             Bloom    `json:"logsBloom"         gencodec:"required"`
-	Logs              []*Log   `json:"logs"              gencodec:"required"`
+	PostState         []byte `json:"root"`
+	Status            uint64 `json:"status"`
+	CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`
+	Bloom             Bloom  `json:"logsBloom"         gencodec:"required"`
+	Logs              []*Log `json:"logs"              gencodec:"required"`
 
 	// Implementation fields (don't reorder!)
 	TxHash          common.Hash    `json:"transactionHash" gencodec:"required"`
 	ContractAddress common.Address `json:"contractAddress"`
-	GasUsed         *big.Int       `json:"gasUsed" gencodec:"required"`
+	GasUsed         uint64         `json:"gasUsed" gencodec:"required"`
 }
 
 type receiptMarshaling struct {
 	PostState         hexutil.Bytes
-	Status            hexutil.Uint
-	CumulativeGasUsed *hexutil.Big
-	GasUsed           *hexutil.Big
+	Status            hexutil.Uint64
+	CumulativeGasUsed hexutil.Uint64
+	GasUsed           hexutil.Uint64
 }
 
 // receiptRLP is the consensus encoding of a receipt.
 type receiptRLP struct {
 	PostStateOrStatus []byte
-	CumulativeGasUsed *big.Int
+	CumulativeGasUsed uint64
 	Bloom             Bloom
 	Logs              []*Log
 }
 
 type receiptStorageRLP struct {
 	PostStateOrStatus []byte
-	CumulativeGasUsed *big.Int
+	CumulativeGasUsed uint64
 	Bloom             Bloom
 	TxHash            common.Hash
 	ContractAddress   common.Address
 	Logs              []*LogForStorage
-	GasUsed           *big.Int
+	GasUsed           uint64
 }
 
 // NewReceipt creates a barebone transaction receipt, copying the init fields.
-func NewReceipt(root []byte, failed bool, cumulativeGasUsed *big.Int) *Receipt {
-	r := &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumulativeGasUsed)}
+func NewReceipt(root []byte, failed bool, cumulativeGasUsed uint64) *Receipt {
+	r := &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: cumulativeGasUsed}
 	if failed {
 		r.Status = ReceiptStatusFailed
 	} else {
@@ -137,12 +137,16 @@ func (r *Receipt) statusEncoding() []byte {
 	return r.PostState
 }
 
-// String implements the Stringer interface.
-func (r *Receipt) String() string {
-	if len(r.PostState) == 0 {
-		return fmt.Sprintf("receipt{status=%d cgas=%v bloom=%x logs=%v}", r.Status, r.CumulativeGasUsed, r.Bloom, r.Logs)
+// Size returns the approximate memory used by all internal contents. It is used
+// to approximate and limit the memory consumption of various caches.
+func (r *Receipt) Size() common.StorageSize {
+	size := common.StorageSize(unsafe.Sizeof(*r)) + common.StorageSize(len(r.PostState))
+
+	size += common.StorageSize(len(r.Logs)) * common.StorageSize(unsafe.Sizeof(Log{}))
+	for _, log := range r.Logs {
+		size += common.StorageSize(len(log.Topics)*common.HashLength + len(log.Data))
 	}
-	return fmt.Sprintf("receipt{med=%x cgas=%v bloom=%x logs=%v}", r.PostState, r.CumulativeGasUsed, r.Bloom, r.Logs)
+	return size
 }
 
 // ReceiptForStorage is a wrapper around a Receipt that flattens and parses the
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 7e2933bb1a..b824a77f61 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -19,7 +19,6 @@ package types
 import (
 	"container/heap"
 	"errors"
-	"fmt"
 	"io"
 	"math/big"
 	"sync/atomic"
@@ -34,18 +33,8 @@ import (
 
 var (
 	ErrInvalidSig = errors.New("invalid transaction v, r, s values")
-	errNoSigner   = errors.New("missing signing methods")
 )
 
-// deriveSigner makes a *best* guess about which signer to use.
-func deriveSigner(V *big.Int) Signer {
-	if V.Sign() != 0 && isProtectedV(V) {
-		return NewEIP155Signer(deriveChainId(V))
-	} else {
-		return HomesteadSigner{}
-	}
-}
-
 type Transaction struct {
 	data txdata
 	// caches
@@ -57,7 +46,7 @@ type Transaction struct {
 type txdata struct {
 	AccountNonce uint64          `json:"nonce"    gencodec:"required"`
 	Price        *big.Int        `json:"gasPrice" gencodec:"required"`
-	GasLimit     *big.Int        `json:"gas"      gencodec:"required"`
+	GasLimit     uint64          `json:"gas"      gencodec:"required"`
 	Recipient    *common.Address `json:"to"       rlp:"nil"` // nil means contract creation
 	Amount       *big.Int        `json:"value"    gencodec:"required"`
 	Payload      []byte          `json:"input"    gencodec:"required"`
@@ -74,7 +63,7 @@ type txdata struct {
 type txdataMarshaling struct {
 	AccountNonce hexutil.Uint64
 	Price        *hexutil.Big
-	GasLimit     *hexutil.Big
+	GasLimit     hexutil.Uint64
 	Amount       *hexutil.Big
 	Payload      hexutil.Bytes
 	V            *hexutil.Big
@@ -82,15 +71,15 @@ type txdataMarshaling struct {
 	S            *hexutil.Big
 }
 
-func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction {
+func NewTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {
 	return newTransaction(nonce, &to, amount, gasLimit, gasPrice, data)
 }
 
-func NewContractCreation(nonce uint64, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction {
+func NewContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {
 	return newTransaction(nonce, nil, amount, gasLimit, gasPrice, data)
 }
 
-func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction {
+func newTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {
 	if len(data) > 0 {
 		data = common.CopyBytes(data)
 	}
@@ -99,7 +88,7 @@ func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice
 		Recipient:    to,
 		Payload:      data,
 		Amount:       new(big.Int),
-		GasLimit:     new(big.Int),
+		GasLimit:     gasLimit,
 		Price:        new(big.Int),
 		V:            new(big.Int),
 		R:            new(big.Int),
@@ -108,9 +97,6 @@ func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice
 	if amount != nil {
 		d.Amount.Set(amount)
 	}
-	if gasLimit != nil {
-		d.GasLimit.Set(gasLimit)
-	}
 	if gasPrice != nil {
 		d.Price.Set(gasPrice)
 	}
@@ -153,6 +139,7 @@ func (tx *Transaction) DecodeRLP(s *rlp.Stream) error {
 	return err
 }
 
+// MarshalJSON encodes the web3 RPC transaction format.
 func (tx *Transaction) MarshalJSON() ([]byte, error) {
 	hash := tx.Hash()
 	data := tx.data
@@ -168,8 +155,8 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 	}
 	var V byte
 	if isProtectedV(dec.V) {
-		chainId := deriveChainId(dec.V).Uint64()
-		V = byte(dec.V.Uint64() - 35 - 2*chainId)
+		chainID := deriveChainId(dec.V).Uint64()
+		V = byte(dec.V.Uint64() - 35 - 2*chainID)
 	} else {
 		V = byte(dec.V.Uint64() - 27)
 	}
@@ -181,7 +168,7 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 }
 
 func (tx *Transaction) Data() []byte       { return common.CopyBytes(tx.data.Payload) }
-func (tx *Transaction) Gas() *big.Int      { return new(big.Int).Set(tx.data.GasLimit) }
+func (tx *Transaction) Gas() uint64        { return tx.data.GasLimit }
 func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.data.Price) }
 func (tx *Transaction) Value() *big.Int    { return new(big.Int).Set(tx.data.Amount) }
 func (tx *Transaction) Nonce() uint64      { return tx.data.AccountNonce }
@@ -192,10 +179,9 @@ func (tx *Transaction) CheckNonce() bool   { return true }
 func (tx *Transaction) To() *common.Address {
 	if tx.data.Recipient == nil {
 		return nil
-	} else {
-		to := *tx.data.Recipient
-		return &to
 	}
+	to := *tx.data.Recipient
+	return &to
 }
 
 // Hash hashes the RLP encoding of tx.
@@ -209,6 +195,8 @@ func (tx *Transaction) Hash() common.Hash {
 	return v
 }
 
+// Size returns the true RLP encoded storage size of the transaction, either by
+// encoding and returning it, or returning a previsouly cached value.
 func (tx *Transaction) Size() common.StorageSize {
 	if size := tx.size.Load(); size != nil {
 		return size.(common.StorageSize)
@@ -227,8 +215,8 @@ func (tx *Transaction) Size() common.StorageSize {
 func (tx *Transaction) AsMessage(s Signer) (Message, error) {
 	msg := Message{
 		nonce:      tx.data.AccountNonce,
-		price:      new(big.Int).Set(tx.data.Price),
-		gasLimit:   new(big.Int).Set(tx.data.GasLimit),
+		gasLimit:   tx.data.GasLimit,
+		gasPrice:   new(big.Int).Set(tx.data.Price),
 		to:         tx.data.Recipient,
 		amount:     tx.data.Amount,
 		data:       tx.data.Payload,
@@ -254,7 +242,7 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e
 
 // Cost returns amount + gasprice * gaslimit.
 func (tx *Transaction) Cost() *big.Int {
-	total := new(big.Int).Mul(tx.data.Price, tx.data.GasLimit)
+	total := new(big.Int).Mul(tx.data.Price, new(big.Int).SetUint64(tx.data.GasLimit))
 	total.Add(total, tx.data.Amount)
 	return total
 }
@@ -263,74 +251,22 @@ func (tx *Transaction) RawSignatureValues() (*big.Int, *big.Int, *big.Int) {
 	return tx.data.V, tx.data.R, tx.data.S
 }
 
-func (tx *Transaction) String() string {
-	var from, to string
-	if tx.data.V != nil {
-		// make a best guess about the signer and use that to derive
-		// the sender.
-		signer := deriveSigner(tx.data.V)
-		if f, err := Sender(signer, tx); err != nil { // derive but don't cache
-			from = "[invalid sender: invalid sig]"
-		} else {
-			from = fmt.Sprintf("%x", f[:])
-		}
-	} else {
-		from = "[invalid sender: nil V field]"
-	}
-
-	if tx.data.Recipient == nil {
-		to = "[contract creation]"
-	} else {
-		to = fmt.Sprintf("%x", tx.data.Recipient[:])
-	}
-	enc, _ := rlp.EncodeToBytes(&tx.data)
-	return fmt.Sprintf(`
-	TX(%x)
-	Contract: %v
-	From:     %s
-	To:       %s
-	Nonce:    %v
-	GasPrice: %#x
-	GasLimit  %#x
-	Value:    %#x
-	Data:     0x%x
-	V:        %#x
-	R:        %#x
-	S:        %#x
-	Hex:      %x
-`,
-		tx.Hash(),
-		tx.data.Recipient == nil,
-		from,
-		to,
-		tx.data.AccountNonce,
-		tx.data.Price,
-		tx.data.GasLimit,
-		tx.data.Amount,
-		tx.data.Payload,
-		tx.data.V,
-		tx.data.R,
-		tx.data.S,
-		enc,
-	)
-}
-
-// Transaction slice type for basic sorting.
+// Transactions is a Transaction slice type for basic sorting.
 type Transactions []*Transaction
 
-// Len returns the length of s
+// Len returns the length of s.
 func (s Transactions) Len() int { return len(s) }
 
-// Swap swaps the i'th and the j'th element in s
+// Swap swaps the i'th and the j'th element in s.
 func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
 
-// GetRlp implements Rlpable and returns the i'th element of s in rlp
+// GetRlp implements Rlpable and returns the i'th element of s in rlp.
 func (s Transactions) GetRlp(i int) []byte {
 	enc, _ := rlp.EncodeToBytes(s[i])
 	return enc
 }
 
-// Returns a new set t which is the difference between a to b
+// TxDifference returns a new set t which is the difference between a to b.
 func TxDifference(a, b Transactions) (keep Transactions) {
 	keep = make(Transactions, 0, len(a))
 
@@ -378,7 +314,7 @@ func (s *TxByPrice) Pop() interface{} {
 }
 
 // TransactionsByPriceAndNonce represents a set of transactions that can return
-// transactions in a profit-maximising sorted order, while supporting removing
+// transactions in a profit-maximizing sorted order, while supporting removing
 // entire batches of transactions for non-executable accounts.
 type TransactionsByPriceAndNonce struct {
 	txs    map[common.Address]Transactions // Per account nonce-sorted list of transactions
@@ -394,11 +330,14 @@ type TransactionsByPriceAndNonce struct {
 func NewTransactionsByPriceAndNonce(signer Signer, txs map[common.Address]Transactions) *TransactionsByPriceAndNonce {
 	// Initialize a price based heap with the head transactions
 	heads := make(TxByPrice, 0, len(txs))
-	for _, accTxs := range txs {
+	for from, accTxs := range txs {
 		heads = append(heads, accTxs[0])
 		// Ensure the sender address is from the signer
 		acc, _ := Sender(signer, accTxs[0])
 		txs[acc] = accTxs[1:]
+		if from != acc {
+			delete(txs, from)
+		}
 	}
 	heap.Init(&heads)
 
@@ -440,22 +379,24 @@ func (t *TransactionsByPriceAndNonce) Pop() {
 //
 // NOTE: In a future PR this will be removed.
 type Message struct {
-	to                      *common.Address
-	from                    common.Address
-	nonce                   uint64
-	amount, price, gasLimit *big.Int
-	data                    []byte
-	checkNonce              bool
+	to         *common.Address
+	from       common.Address
+	nonce      uint64
+	amount     *big.Int
+	gasLimit   uint64
+	gasPrice   *big.Int
+	data       []byte
+	checkNonce bool
 }
 
-func NewMessage(from common.Address, to *common.Address, nonce uint64, amount, gasLimit, price *big.Int, data []byte, checkNonce bool) Message {
+func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, checkNonce bool) Message {
 	return Message{
 		from:       from,
 		to:         to,
 		nonce:      nonce,
 		amount:     amount,
-		price:      price,
 		gasLimit:   gasLimit,
+		gasPrice:   gasPrice,
 		data:       data,
 		checkNonce: checkNonce,
 	}
@@ -463,9 +404,9 @@ func NewMessage(from common.Address, to *common.Address, nonce uint64, amount, g
 
 func (m Message) From() common.Address { return m.from }
 func (m Message) To() *common.Address  { return m.to }
-func (m Message) GasPrice() *big.Int   { return m.price }
+func (m Message) GasPrice() *big.Int   { return m.gasPrice }
 func (m Message) Value() *big.Int      { return m.amount }
-func (m Message) Gas() *big.Int        { return m.gasLimit }
+func (m Message) Gas() uint64          { return m.gasLimit }
 func (m Message) Nonce() uint64        { return m.nonce }
 func (m Message) Data() []byte         { return m.data }
 func (m Message) CheckNonce() bool     { return m.checkNonce }
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index dfc84fdac7..c195d23a32 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -43,7 +43,7 @@ func MakeSigner(config *params.ChainConfig, blockNumber *big.Int) Signer {
 	var signer Signer
 	switch {
 	case config.IsEIP155(blockNumber):
-		signer = NewEIP155Signer(config.ChainId)
+		signer = NewEIP155Signer(config.ChainID)
 	case config.IsHomestead(blockNumber):
 		signer = HomesteadSigner{}
 	default:
diff --git a/core/types/transaction_signing_test.go b/core/types/transaction_signing_test.go
index 7f799fb101..689fc38a9b 100644
--- a/core/types/transaction_signing_test.go
+++ b/core/types/transaction_signing_test.go
@@ -30,7 +30,7 @@ func TestEIP155Signing(t *testing.T) {
 	addr := crypto.PubkeyToAddress(key.PublicKey)
 
 	signer := NewEIP155Signer(big.NewInt(18))
-	tx, err := SignTx(NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil), signer, key)
+	tx, err := SignTx(NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil), signer, key)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -49,7 +49,7 @@ func TestEIP155ChainId(t *testing.T) {
 	addr := crypto.PubkeyToAddress(key.PublicKey)
 
 	signer := NewEIP155Signer(big.NewInt(18))
-	tx, err := SignTx(NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil), signer, key)
+	tx, err := SignTx(NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil), signer, key)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -61,7 +61,7 @@ func TestEIP155ChainId(t *testing.T) {
 		t.Error("expected chainId to be", signer.chainId, "got", tx.ChainId())
 	}
 
-	tx = NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil)
+	tx = NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil)
 	tx, err = SignTx(tx, HomesteadSigner{}, key)
 	if err != nil {
 		t.Fatal(err)
@@ -118,7 +118,7 @@ func TestEIP155SigningVitalik(t *testing.T) {
 func TestChainId(t *testing.T) {
 	key, _ := defaultTestKey()
 
-	tx := NewTransaction(0, common.Address{}, new(big.Int), new(big.Int), new(big.Int), nil)
+	tx := NewTransaction(0, common.Address{}, new(big.Int), 0, new(big.Int), nil)
 
 	var err error
 	tx, err = SignTx(tx, NewEIP155Signer(big.NewInt(1)), key)
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index 82d74e3b34..b390f45c67 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -34,7 +34,7 @@ var (
 	emptyTx = NewTransaction(
 		0,
 		common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
-		big.NewInt(0), big.NewInt(0), big.NewInt(0),
+		big.NewInt(0), 0, big.NewInt(0),
 		nil,
 	)
 
@@ -42,7 +42,7 @@ var (
 		3,
 		common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b"),
 		big.NewInt(10),
-		big.NewInt(2000),
+		2000,
 		big.NewInt(1),
 		common.FromHex("5544"),
 	).WithSignature(
@@ -139,7 +139,7 @@ func TestTransactionPriceNonceSort(t *testing.T) {
 	for start, key := range keys {
 		addr := crypto.PubkeyToAddress(key.PublicKey)
 		for i := 0; i < 25; i++ {
-			tx, _ := SignTx(NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+i)), nil), signer, key)
+			tx, _ := SignTx(NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), 100, big.NewInt(int64(start+i)), nil), signer, key)
 			groups[addr] = append(groups[addr], tx)
 		}
 	}
@@ -165,28 +165,13 @@ func TestTransactionPriceNonceSort(t *testing.T) {
 				t.Errorf("invalid nonce ordering: tx #%d (A=%x N=%v) < tx #%d (A=%x N=%v)", i, fromi[:4], txi.Nonce(), i+j, fromj[:4], txj.Nonce())
 			}
 		}
-		// Find the previous and next nonce of this account
-		prev, next := i-1, i+1
-		for j := i - 1; j >= 0; j-- {
-			if fromj, _ := Sender(signer, txs[j]); fromi == fromj {
-				prev = j
-				break
-			}
-		}
-		for j := i + 1; j < len(txs); j++ {
-			if fromj, _ := Sender(signer, txs[j]); fromi == fromj {
-				next = j
-				break
-			}
-		}
-		// Make sure that in between the neighbor nonces, the transaction is correctly positioned price wise
-		for j := prev + 1; j < next; j++ {
-			fromj, _ := Sender(signer, txs[j])
-			if j < i && txs[j].GasPrice().Cmp(txi.GasPrice()) < 0 {
-				t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) < tx #%d (A=%x P=%v)", j, fromj[:4], txs[j].GasPrice(), i, fromi[:4], txi.GasPrice())
-			}
-			if j > i && txs[j].GasPrice().Cmp(txi.GasPrice()) > 0 {
-				t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) > tx #%d (A=%x P=%v)", j, fromj[:4], txs[j].GasPrice(), i, fromi[:4], txi.GasPrice())
+
+		// If the next tx has different from account, the price must be lower than the current one
+		if i+1 < len(txs) {
+			next := txs[i+1]
+			fromNext, _ := Sender(signer, next)
+			if fromi != fromNext && txi.GasPrice().Cmp(next.GasPrice()) < 0 {
+				t.Errorf("invalid gasprice ordering: tx #%d (A=%x P=%v) < tx #%d (A=%x P=%v)", i, fromi[:4], txi.GasPrice(), i+1, fromNext[:4], next.GasPrice())
 			}
 		}
 	}
@@ -204,9 +189,9 @@ func TestTransactionJSON(t *testing.T) {
 		var tx *Transaction
 		switch i % 2 {
 		case 0:
-			tx = NewTransaction(i, common.Address{1}, common.Big0, common.Big1, common.Big2, []byte("abcdef"))
+			tx = NewTransaction(i, common.Address{1}, common.Big0, 1, common.Big2, []byte("abcdef"))
 		case 1:
-			tx = NewContractCreation(i, common.Big0, common.Big1, common.Big2, []byte("abcdef"))
+			tx = NewContractCreation(i, common.Big0, 1, common.Big2, []byte("abcdef"))
 		}
 
 		tx, err := SignTx(tx, signer, key)
diff --git a/core/vm/contract.go b/core/vm/contract.go
index 66748e8215..b466681dbd 100644
--- a/core/vm/contract.go
+++ b/core/vm/contract.go
@@ -139,15 +139,15 @@ func (c *Contract) Value() *big.Int {
 }
 
 // SetCode sets the code to the contract
-func (self *Contract) SetCode(hash common.Hash, code []byte) {
-	self.Code = code
-	self.CodeHash = hash
+func (c *Contract) SetCode(hash common.Hash, code []byte) {
+	c.Code = code
+	c.CodeHash = hash
 }
 
 // SetCallCode sets the code of the contract and address of the backing data
 // object
-func (self *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte) {
-	self.Code = code
-	self.CodeHash = hash
-	self.CodeAddr = addr
+func (c *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte) {
+	c.Code = code
+	c.CodeHash = hash
+	c.CodeAddr = addr
 }
diff --git a/core/vm/contracts.go b/core/vm/contracts.go
index 7344b6043c..237450ea96 100644
--- a/core/vm/contracts.go
+++ b/core/vm/contracts.go
@@ -251,26 +251,12 @@ func (c *bigModExp) Run(input []byte) ([]byte, error) {
 	return common.LeftPadBytes(base.Exp(base, exp, mod).Bytes(), int(modLen)), nil
 }
 
-var (
-	// errNotOnCurve is returned if a point being unmarshalled as a bn256 elliptic
-	// curve point is not on the curve.
-	errNotOnCurve = errors.New("point not on elliptic curve")
-
-	// errInvalidCurvePoint is returned if a point being unmarshalled as a bn256
-	// elliptic curve point is invalid.
-	errInvalidCurvePoint = errors.New("invalid elliptic curve point")
-)
-
 // newCurvePoint unmarshals a binary blob into a bn256 elliptic curve point,
 // returning it, or an error if the point is invalid.
 func newCurvePoint(blob []byte) (*bn256.G1, error) {
-	p, onCurve := new(bn256.G1).Unmarshal(blob)
-	if !onCurve {
-		return nil, errNotOnCurve
-	}
-	gx, gy, _, _ := p.CurvePoints()
-	if gx.Cmp(bn256.P) >= 0 || gy.Cmp(bn256.P) >= 0 {
-		return nil, errInvalidCurvePoint
+	p := new(bn256.G1)
+	if _, err := p.Unmarshal(blob); err != nil {
+		return nil, err
 	}
 	return p, nil
 }
@@ -278,14 +264,9 @@ func newCurvePoint(blob []byte) (*bn256.G1, error) {
 // newTwistPoint unmarshals a binary blob into a bn256 elliptic curve point,
 // returning it, or an error if the point is invalid.
 func newTwistPoint(blob []byte) (*bn256.G2, error) {
-	p, onCurve := new(bn256.G2).Unmarshal(blob)
-	if !onCurve {
-		return nil, errNotOnCurve
-	}
-	x2, y2, _, _ := p.CurvePoints()
-	if x2.Real().Cmp(bn256.P) >= 0 || x2.Imag().Cmp(bn256.P) >= 0 ||
-		y2.Real().Cmp(bn256.P) >= 0 || y2.Imag().Cmp(bn256.P) >= 0 {
-		return nil, errInvalidCurvePoint
+	p := new(bn256.G2)
+	if _, err := p.Unmarshal(blob); err != nil {
+		return nil, err
 	}
 	return p, nil
 }
diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go
index 513651835a..96083337c9 100644
--- a/core/vm/contracts_test.go
+++ b/core/vm/contracts_test.go
@@ -1,3 +1,19 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
 package vm
 
 import (
diff --git a/core/vm/doc.go b/core/vm/doc.go
index 239be2cfec..5864d0cfa2 100644
--- a/core/vm/doc.go
+++ b/core/vm/doc.go
@@ -17,19 +17,8 @@
 /*
 Package vm implements the Ethereum Virtual Machine.
 
-The vm package implements two EVMs, a byte code VM and a JIT VM. The BC
-(Byte Code) VM loops over a set of bytes and executes them according to the set
-of rules defined in the Ethereum yellow paper. When the BC VM is invoked it
-invokes the JIT VM in a separate goroutine and compiles the byte code in JIT
-instructions.
-
-The JIT VM, when invoked, loops around a set of pre-defined instructions until
-it either runs of gas, causes an internal error, returns or stops.
-
-The JIT optimiser attempts to pre-compile instructions in to chunks or segments
-such as multiple PUSH operations and static JUMPs. It does this by analysing the
-opcodes and attempts to match certain regions to known sets. Whenever the
-optimiser finds said segments it creates a new instruction and replaces the
-first occurrence in the sequence.
+The vm package implements one EVM, a byte code VM. The BC (Byte Code) VM loops
+over a set of bytes and executes them according to the set of rules defined
+in the Ethereum yellow paper.
 */
 package vm
diff --git a/core/vm/evm.go b/core/vm/evm.go
index 80b3c51fb4..570bfc0a8d 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -19,6 +19,7 @@ package vm
 import (
 	"math/big"
 	"sync/atomic"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -68,7 +69,7 @@ type Context struct {
 
 	// Block information
 	Coinbase    common.Address // Provides information for COINBASE
-	GasLimit    *big.Int       // Provides information for GASLIMIT
+	GasLimit    uint64         // Provides information for GASLIMIT
 	BlockNumber *big.Int       // Provides information for NUMBER
 	Time        *big.Int       // Provides information for TIME
 	Difficulty  *big.Int       // Provides information for DIFFICULTY
@@ -110,7 +111,7 @@ type EVM struct {
 	callGasTemp uint64
 }
 
-// NewEVM retutrns a new EVM . The returned EVM is not thread safe and should
+// NewEVM returns a new EVM. The returned EVM is not thread safe and should
 // only ever be used *once*.
 func NewEVM(ctx Context, statedb StateDB, chainConfig *params.ChainConfig, vmConfig Config) *EVM {
 	evm := &EVM{
@@ -159,19 +160,34 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 			precompiles = PrecompiledContractsByzantium
 		}
 		if precompiles[addr] == nil && evm.ChainConfig().IsEIP158(evm.BlockNumber) && value.Sign() == 0 {
+			// Calling a non existing account, don't do antything, but ping the tracer
+			if evm.vmConfig.Debug && evm.depth == 0 {
+				evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
+				evm.vmConfig.Tracer.CaptureEnd(ret, 0, 0, nil)
+			}
 			return nil, gas, nil
 		}
 		evm.StateDB.CreateAccount(addr)
 	}
 	evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
 
-	// initialise a new contract and set the code that is to be used by the
-	// E The contract is a scoped environment for this execution context
-	// only.
+	// Initialise a new contract and set the code that is to be used by the EVM.
+	// The contract is a scoped environment for this execution context only.
 	contract := NewContract(caller, to, value, gas)
 	contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
 
+	start := time.Now()
+
+	// Capture the tracer start/end events in debug mode
+	if evm.vmConfig.Debug && evm.depth == 0 {
+		evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
+
+		defer func() { // Lazy evaluation of the parameters
+			evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
+		}()
+	}
 	ret, err = run(evm, contract, input)
+
 	// When an error was returned by the EVM or when setting the creation code
 	// above we revert to the snapshot and consume any gas remaining. Additionally
 	// when we're in homestead this also counts for code storage gas errors.
@@ -210,7 +226,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 		to       = AccountRef(caller.Address())
 	)
 	// initialise a new contract and set the code that is to be used by the
-	// E The contract is a scoped evmironment for this execution context
+	// EVM. The contract is a scoped environment for this execution context
 	// only.
 	contract := NewContract(caller, to, value, gas)
 	contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
@@ -330,7 +346,7 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I
 	evm.Transfer(evm.StateDB, caller.Address(), contractAddr, value)
 
 	// initialise a new contract and set the code that is to be used by the
-	// E The contract is a scoped evmironment for this execution context
+	// EVM. The contract is a scoped environment for this execution context
 	// only.
 	contract := NewContract(caller, AccountRef(contractAddr), value, gas)
 	contract.SetCallCode(&contractAddr, crypto.Keccak256Hash(code), code)
@@ -338,7 +354,14 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I
 	if evm.vmConfig.NoRecursion && evm.depth > 0 {
 		return nil, contractAddr, gas, nil
 	}
+
+	if evm.vmConfig.Debug && evm.depth == 0 {
+		evm.vmConfig.Tracer.CaptureStart(caller.Address(), contractAddr, true, code, gas, value)
+	}
+	start := time.Now()
+
 	ret, err = run(evm, contract, nil)
+
 	// check whether the max code size has been exceeded
 	maxCodeSizeExceeded := evm.ChainConfig().IsEIP158(evm.BlockNumber) && len(ret) > params.MaxCodeSize
 	// if the contract creation ran successfully and no errors were returned
@@ -367,10 +390,13 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I
 	if maxCodeSizeExceeded && err == nil {
 		err = errMaxCodeSizeExceeded
 	}
+	if evm.vmConfig.Debug && evm.depth == 0 {
+		evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
+	}
 	return ret, contractAddr, contract.Gas, err
 }
 
-// ChainConfig returns the evmironment's chain configuration
+// ChainConfig returns the environment's chain configuration
 func (evm *EVM) ChainConfig() *params.ChainConfig { return evm.chainConfig }
 
 // Interpreter returns the EVM interpreter
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index ff109af57b..0764c67a4d 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -17,8 +17,6 @@
 package vm
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/params"
@@ -126,12 +124,12 @@ func gasSStore(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, m
 	// 1. From a zero-value address to a non-zero value         (NEW VALUE)
 	// 2. From a non-zero value address to a zero-value address (DELETE)
 	// 3. From a non-zero to a non-zero                         (CHANGE)
-	if common.EmptyHash(val) && !common.EmptyHash(common.BigToHash(y)) {
+	if val == (common.Hash{}) && y.Sign() != 0 {
 		// 0 => non 0
 		return params.SstoreSetGas, nil
-	} else if !common.EmptyHash(val) && common.EmptyHash(common.BigToHash(y)) {
-		evm.StateDB.AddRefund(new(big.Int).SetUint64(params.SstoreRefundGas))
-
+	} else if val != (common.Hash{}) && y.Sign() == 0 {
+		// non 0 => 0
+		evm.StateDB.AddRefund(params.SstoreRefundGas)
 		return params.SstoreClearGas, nil
 	} else {
 		// non 0 => non 0 (or 0 => 0)
@@ -405,7 +403,7 @@ func gasSuicide(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack,
 	}
 
 	if !evm.StateDB.HasSuicided(contract.Address()) {
-		evm.StateDB.AddRefund(new(big.Int).SetUint64(params.SuicideRefundGas))
+		evm.StateDB.AddRefund(params.SuicideRefundGas)
 	}
 	return gas, nil
 }
diff --git a/core/vm/gen_structlog.go b/core/vm/gen_structlog.go
index 88df942dcf..ade3ca6318 100644
--- a/core/vm/gen_structlog.go
+++ b/core/vm/gen_structlog.go
@@ -11,19 +11,22 @@ import (
 	"github.com/ethereum/go-ethereum/common/math"
 )
 
+var _ = (*structLogMarshaling)(nil)
+
 func (s StructLog) MarshalJSON() ([]byte, error) {
 	type StructLog struct {
-		Pc         uint64                      `json:"pc"`
-		Op         OpCode                      `json:"op"`
-		Gas        math.HexOrDecimal64         `json:"gas"`
-		GasCost    math.HexOrDecimal64         `json:"gasCost"`
-		Memory     hexutil.Bytes               `json:"memory"`
-		MemorySize int                         `json:"memSize"`
-		Stack      []*math.HexOrDecimal256     `json:"stack"`
-		Storage    map[common.Hash]common.Hash `json:"-"`
-		Depth      int                         `json:"depth"`
-		Err        error                       `json:"error"`
-		OpName     string                      `json:"opName"`
+		Pc          uint64                      `json:"pc"`
+		Op          OpCode                      `json:"op"`
+		Gas         math.HexOrDecimal64         `json:"gas"`
+		GasCost     math.HexOrDecimal64         `json:"gasCost"`
+		Memory      hexutil.Bytes               `json:"memory"`
+		MemorySize  int                         `json:"memSize"`
+		Stack       []*math.HexOrDecimal256     `json:"stack"`
+		Storage     map[common.Hash]common.Hash `json:"-"`
+		Depth       int                         `json:"depth"`
+		Err         error                       `json:"-"`
+		OpName      string                      `json:"opName"`
+		ErrorString string                      `json:"error"`
 	}
 	var enc StructLog
 	enc.Pc = s.Pc
@@ -42,6 +45,7 @@ func (s StructLog) MarshalJSON() ([]byte, error) {
 	enc.Depth = s.Depth
 	enc.Err = s.Err
 	enc.OpName = s.OpName()
+	enc.ErrorString = s.ErrorString()
 	return json.Marshal(&enc)
 }
 
@@ -51,12 +55,12 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		Op         *OpCode                     `json:"op"`
 		Gas        *math.HexOrDecimal64        `json:"gas"`
 		GasCost    *math.HexOrDecimal64        `json:"gasCost"`
-		Memory     hexutil.Bytes               `json:"memory"`
+		Memory     *hexutil.Bytes              `json:"memory"`
 		MemorySize *int                        `json:"memSize"`
 		Stack      []*math.HexOrDecimal256     `json:"stack"`
 		Storage    map[common.Hash]common.Hash `json:"-"`
 		Depth      *int                        `json:"depth"`
-		Err        *error                      `json:"error"`
+		Err        error                       `json:"-"`
 	}
 	var dec StructLog
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -75,7 +79,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		s.GasCost = uint64(*dec.GasCost)
 	}
 	if dec.Memory != nil {
-		s.Memory = dec.Memory
+		s.Memory = *dec.Memory
 	}
 	if dec.MemorySize != nil {
 		s.MemorySize = *dec.MemorySize
@@ -93,7 +97,7 @@ func (s *StructLog) UnmarshalJSON(input []byte) error {
 		s.Depth = *dec.Depth
 	}
 	if dec.Err != nil {
-		s.Err = *dec.Err
+		s.Err = dec.Err
 	}
 	return nil
 }
diff --git a/core/vm/instructions.go b/core/vm/instructions.go
index 1d1585fcac..9475322cdf 100644
--- a/core/vm/instructions.go
+++ b/core/vm/instructions.go
@@ -30,6 +30,7 @@ import (
 
 var (
 	bigZero                  = new(big.Int)
+	tt255                    = math.BigPow(2, 255)
 	errWriteProtection       = errors.New("evm: write protection")
 	errReturnDataOutOfBounds = errors.New("evm: return data out of bounds")
 	errExecutionReverted     = errors.New("evm: execution reverted")
@@ -37,20 +38,18 @@ var (
 )
 
 func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
-	stack.push(math.U256(x.Add(x, y)))
-
-	evm.interpreter.intPool.put(y)
+	x, y := stack.pop(), stack.peek()
+	math.U256(y.Add(x, y))
 
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opSub(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
-	stack.push(math.U256(x.Sub(x, y)))
-
-	evm.interpreter.intPool.put(y)
+	x, y := stack.pop(), stack.peek()
+	math.U256(y.Sub(x, y))
 
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
@@ -64,44 +63,39 @@ func opMul(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac
 }
 
 func opDiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
+	x, y := stack.pop(), stack.peek()
 	if y.Sign() != 0 {
-		stack.push(math.U256(x.Div(x, y)))
+		math.U256(y.Div(x, y))
 	} else {
-		stack.push(new(big.Int))
+		y.SetUint64(0)
 	}
-
-	evm.interpreter.intPool.put(y)
-
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opSdiv(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	x, y := math.S256(stack.pop()), math.S256(stack.pop())
-	if y.Sign() == 0 {
-		stack.push(new(big.Int))
-		return nil, nil
+	res := evm.interpreter.intPool.getZero()
+
+	if y.Sign() == 0 || x.Sign() == 0 {
+		stack.push(res)
 	} else {
-		n := new(big.Int)
-		if evm.interpreter.intPool.get().Mul(x, y).Sign() < 0 {
-			n.SetInt64(-1)
+		if x.Sign() != y.Sign() {
+			res.Div(x.Abs(x), y.Abs(y))
+			res.Neg(res)
 		} else {
-			n.SetInt64(1)
+			res.Div(x.Abs(x), y.Abs(y))
 		}
-
-		res := x.Div(x.Abs(x), y.Abs(y))
-		res.Mul(res, n)
-
 		stack.push(math.U256(res))
 	}
-	evm.interpreter.intPool.put(y)
+	evm.interpreter.intPool.put(x, y)
 	return nil, nil
 }
 
 func opMod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	x, y := stack.pop(), stack.pop()
 	if y.Sign() == 0 {
-		stack.push(new(big.Int))
+		stack.push(x.SetUint64(0))
 	} else {
 		stack.push(math.U256(x.Mod(x, y)))
 	}
@@ -111,23 +105,20 @@ func opMod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac
 
 func opSmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	x, y := math.S256(stack.pop()), math.S256(stack.pop())
+	res := evm.interpreter.intPool.getZero()
 
 	if y.Sign() == 0 {
-		stack.push(new(big.Int))
+		stack.push(res)
 	} else {
-		n := new(big.Int)
 		if x.Sign() < 0 {
-			n.SetInt64(-1)
+			res.Mod(x.Abs(x), y.Abs(y))
+			res.Neg(res)
 		} else {
-			n.SetInt64(1)
+			res.Mod(x.Abs(x), y.Abs(y))
 		}
-
-		res := x.Mod(x.Abs(x), y.Abs(y))
-		res.Mul(res, n)
-
 		stack.push(math.U256(res))
 	}
-	evm.interpreter.intPool.put(y)
+	evm.interpreter.intPool.put(x, y)
 	return nil, nil
 }
 
@@ -161,80 +152,99 @@ func opSignExtend(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stac
 }
 
 func opNot(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x := stack.pop()
-	stack.push(math.U256(x.Not(x)))
+	x := stack.peek()
+	math.U256(x.Not(x))
 	return nil, nil
 }
 
 func opLt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
+	x, y := stack.pop(), stack.peek()
 	if x.Cmp(y) < 0 {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
+		y.SetUint64(1)
 	} else {
-		stack.push(new(big.Int))
+		y.SetUint64(0)
 	}
-
-	evm.interpreter.intPool.put(x, y)
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opGt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
+	x, y := stack.pop(), stack.peek()
 	if x.Cmp(y) > 0 {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
+		y.SetUint64(1)
 	} else {
-		stack.push(new(big.Int))
+		y.SetUint64(0)
 	}
-
-	evm.interpreter.intPool.put(x, y)
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opSlt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := math.S256(stack.pop()), math.S256(stack.pop())
-	if x.Cmp(math.S256(y)) < 0 {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
-	} else {
-		stack.push(new(big.Int))
-	}
+	x, y := stack.pop(), stack.peek()
 
-	evm.interpreter.intPool.put(x, y)
+	xSign := x.Cmp(tt255)
+	ySign := y.Cmp(tt255)
+
+	switch {
+	case xSign >= 0 && ySign < 0:
+		y.SetUint64(1)
+
+	case xSign < 0 && ySign >= 0:
+		y.SetUint64(0)
+
+	default:
+		if x.Cmp(y) < 0 {
+			y.SetUint64(1)
+		} else {
+			y.SetUint64(0)
+		}
+	}
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opSgt(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := math.S256(stack.pop()), math.S256(stack.pop())
-	if x.Cmp(y) > 0 {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
-	} else {
-		stack.push(new(big.Int))
-	}
+	x, y := stack.pop(), stack.peek()
 
-	evm.interpreter.intPool.put(x, y)
+	xSign := x.Cmp(tt255)
+	ySign := y.Cmp(tt255)
+
+	switch {
+	case xSign >= 0 && ySign < 0:
+		y.SetUint64(0)
+
+	case xSign < 0 && ySign >= 0:
+		y.SetUint64(1)
+
+	default:
+		if x.Cmp(y) > 0 {
+			y.SetUint64(1)
+		} else {
+			y.SetUint64(0)
+		}
+	}
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opEq(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
+	x, y := stack.pop(), stack.peek()
 	if x.Cmp(y) == 0 {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
+		y.SetUint64(1)
 	} else {
-		stack.push(new(big.Int))
+		y.SetUint64(0)
 	}
-
-	evm.interpreter.intPool.put(x, y)
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opIszero(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x := stack.pop()
+	x := stack.peek()
 	if x.Sign() > 0 {
-		stack.push(new(big.Int))
+		x.SetUint64(0)
 	} else {
-		stack.push(evm.interpreter.intPool.get().SetUint64(1))
+		x.SetUint64(1)
 	}
-
-	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
@@ -247,18 +257,18 @@ func opAnd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac
 }
 
 func opOr(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
-	stack.push(x.Or(x, y))
+	x, y := stack.pop(), stack.peek()
+	y.Or(x, y)
 
-	evm.interpreter.intPool.put(y)
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
 func opXor(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	x, y := stack.pop(), stack.pop()
-	stack.push(x.Xor(x, y))
+	x, y := stack.pop(), stack.peek()
+	y.Xor(x, y)
 
-	evm.interpreter.intPool.put(y)
+	evm.interpreter.intPool.put(x)
 	return nil, nil
 }
 
@@ -277,13 +287,12 @@ func opByte(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta
 func opAddmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	x, y, z := stack.pop(), stack.pop(), stack.pop()
 	if z.Cmp(bigZero) > 0 {
-		add := x.Add(x, y)
-		add.Mod(add, z)
-		stack.push(math.U256(add))
+		x.Add(x, y)
+		x.Mod(x, z)
+		stack.push(math.U256(x))
 	} else {
-		stack.push(new(big.Int))
+		stack.push(x.SetUint64(0))
 	}
-
 	evm.interpreter.intPool.put(y, z)
 	return nil, nil
 }
@@ -291,17 +300,76 @@ func opAddmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S
 func opMulmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	x, y, z := stack.pop(), stack.pop(), stack.pop()
 	if z.Cmp(bigZero) > 0 {
-		mul := x.Mul(x, y)
-		mul.Mod(mul, z)
-		stack.push(math.U256(mul))
+		x.Mul(x, y)
+		x.Mod(x, z)
+		stack.push(math.U256(x))
 	} else {
-		stack.push(new(big.Int))
+		stack.push(x.SetUint64(0))
 	}
-
 	evm.interpreter.intPool.put(y, z)
 	return nil, nil
 }
 
+// opSHL implements Shift Left
+// The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2,
+// and pushes on the stack arg2 shifted to the left by arg1 number of bits.
+func opSHL(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
+	shift, value := math.U256(stack.pop()), math.U256(stack.peek())
+	defer evm.interpreter.intPool.put(shift) // First operand back into the pool
+
+	if shift.Cmp(common.Big256) >= 0 {
+		value.SetUint64(0)
+		return nil, nil
+	}
+	n := uint(shift.Uint64())
+	math.U256(value.Lsh(value, n))
+
+	return nil, nil
+}
+
+// opSHR implements Logical Shift Right
+// The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2,
+// and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.
+func opSHR(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+	// Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
+	shift, value := math.U256(stack.pop()), math.U256(stack.peek())
+	defer evm.interpreter.intPool.put(shift) // First operand back into the pool
+
+	if shift.Cmp(common.Big256) >= 0 {
+		value.SetUint64(0)
+		return nil, nil
+	}
+	n := uint(shift.Uint64())
+	math.U256(value.Rsh(value, n))
+
+	return nil, nil
+}
+
+// opSAR implements Arithmetic Shift Right
+// The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2,
+// and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.
+func opSAR(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
+	// Note, S256 returns (potentially) a new bigint, so we're popping, not peeking this one
+	shift, value := math.U256(stack.pop()), math.S256(stack.pop())
+	defer evm.interpreter.intPool.put(shift) // First operand back into the pool
+
+	if shift.Cmp(common.Big256) >= 0 {
+		if value.Sign() > 0 {
+			value.SetUint64(0)
+		} else {
+			value.SetInt64(-1)
+		}
+		stack.push(math.U256(value))
+		return nil, nil
+	}
+	n := uint(shift.Uint64())
+	value.Rsh(value, n)
+	stack.push(math.U256(value))
+
+	return nil, nil
+}
+
 func opSha3(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	offset, size := stack.pop(), stack.pop()
 	data := memory.Get(offset.Int64(), size.Int64())
@@ -310,8 +378,7 @@ func opSha3(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta
 	if evm.vmConfig.EnablePreimageRecording {
 		evm.StateDB.AddPreimage(common.BytesToHash(hash), data)
 	}
-
-	stack.push(new(big.Int).SetBytes(hash))
+	stack.push(evm.interpreter.intPool.get().SetBytes(hash))
 
 	evm.interpreter.intPool.put(offset, size)
 	return nil, nil
@@ -323,10 +390,8 @@ func opAddress(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *
 }
 
 func opBalance(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	addr := common.BigToAddress(stack.pop())
-	balance := evm.StateDB.GetBalance(addr)
-
-	stack.push(new(big.Int).Set(balance))
+	slot := stack.peek()
+	slot.Set(evm.StateDB.GetBalance(common.BigToAddress(slot)))
 	return nil, nil
 }
 
@@ -346,7 +411,7 @@ func opCallValue(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack
 }
 
 func opCallDataLoad(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	stack.push(new(big.Int).SetBytes(getDataBig(contract.Input, stack.pop(), big32)))
+	stack.push(evm.interpreter.intPool.get().SetBytes(getDataBig(contract.Input, stack.pop(), big32)))
 	return nil, nil
 }
 
@@ -377,10 +442,11 @@ func opReturnDataCopy(pc *uint64, evm *EVM, contract *Contract, memory *Memory,
 		memOffset  = stack.pop()
 		dataOffset = stack.pop()
 		length     = stack.pop()
-	)
-	defer evm.interpreter.intPool.put(memOffset, dataOffset, length)
 
-	end := new(big.Int).Add(dataOffset, length)
+		end = evm.interpreter.intPool.get().Add(dataOffset, length)
+	)
+	defer evm.interpreter.intPool.put(memOffset, dataOffset, length, end)
+
 	if end.BitLen() > 64 || uint64(len(evm.interpreter.returnData)) < end.Uint64() {
 		return nil, errReturnDataOutOfBounds
 	}
@@ -390,11 +456,8 @@ func opReturnDataCopy(pc *uint64, evm *EVM, contract *Contract, memory *Memory,
 }
 
 func opExtCodeSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	a := stack.pop()
-
-	addr := common.BigToAddress(a)
-	a.SetInt64(int64(evm.StateDB.GetCodeSize(addr)))
-	stack.push(a)
+	slot := stack.peek()
+	slot.SetUint64(uint64(evm.StateDB.GetCodeSize(common.BigToAddress(slot))))
 
 	return nil, nil
 }
@@ -402,6 +465,7 @@ func opExtCodeSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, sta
 func opCodeSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	l := evm.interpreter.intPool.get().SetInt64(int64(len(contract.Code)))
 	stack.push(l)
+
 	return nil, nil
 }
 
@@ -444,9 +508,8 @@ func opBlockhash(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack
 	if num.Cmp(n) > 0 && num.Cmp(evm.BlockNumber) < 0 {
 		stack.push(evm.GetHash(num.Uint64()).Big())
 	} else {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	}
-
 	evm.interpreter.intPool.put(num, n)
 	return nil, nil
 }
@@ -457,22 +520,22 @@ func opCoinbase(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack
 }
 
 func opTimestamp(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	stack.push(math.U256(new(big.Int).Set(evm.Time)))
+	stack.push(math.U256(evm.interpreter.intPool.get().Set(evm.Time)))
 	return nil, nil
 }
 
 func opNumber(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	stack.push(math.U256(new(big.Int).Set(evm.BlockNumber)))
+	stack.push(math.U256(evm.interpreter.intPool.get().Set(evm.BlockNumber)))
 	return nil, nil
 }
 
 func opDifficulty(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	stack.push(math.U256(new(big.Int).Set(evm.Difficulty)))
+	stack.push(math.U256(evm.interpreter.intPool.get().Set(evm.Difficulty)))
 	return nil, nil
 }
 
 func opGasLimit(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	stack.push(math.U256(new(big.Int).Set(evm.GasLimit)))
+	stack.push(math.U256(evm.interpreter.intPool.get().SetUint64(evm.GasLimit)))
 	return nil, nil
 }
 
@@ -483,7 +546,7 @@ func opPop(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac
 
 func opMload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	offset := stack.pop()
-	val := new(big.Int).SetBytes(memory.Get(offset.Int64(), 32))
+	val := evm.interpreter.intPool.get().SetBytes(memory.Get(offset.Int64(), 32))
 	stack.push(val)
 
 	evm.interpreter.intPool.put(offset)
@@ -493,7 +556,7 @@ func opMload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *St
 func opMstore(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 	// pop value of the stack
 	mStart, val := stack.pop(), stack.pop()
-	memory.Set(mStart.Uint64(), 32, math.PaddedBigBytes(val, 32))
+	memory.Set32(mStart.Uint64(), val)
 
 	evm.interpreter.intPool.put(mStart, val)
 	return nil, nil
@@ -507,9 +570,9 @@ func opMstore8(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *
 }
 
 func opSload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
-	loc := common.BigToHash(stack.pop())
-	val := evm.StateDB.GetState(contract.Address(), loc).Big()
-	stack.push(val)
+	loc := stack.peek()
+	val := evm.StateDB.GetState(contract.Address(), common.BigToHash(loc))
+	loc.SetBytes(val.Bytes())
 	return nil, nil
 }
 
@@ -587,9 +650,9 @@ func opCreate(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S
 	// rule) and treat as an error, if the ruleset is frontier we must
 	// ignore this error and pretend the operation was successful.
 	if evm.ChainConfig().IsHomestead(evm.BlockNumber) && suberr == ErrCodeStoreOutOfGas {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else {
 		stack.push(addr.Big())
 	}
@@ -618,9 +681,9 @@ func opCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta
 	}
 	ret, returnGas, err := evm.Call(contract, toAddr, args, gas, value)
 	if err != nil {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else {
-		stack.push(big.NewInt(1))
+		stack.push(evm.interpreter.intPool.get().SetUint64(1))
 	}
 	if err == nil || err == errExecutionReverted {
 		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
@@ -647,9 +710,9 @@ func opCallCode(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack
 	}
 	ret, returnGas, err := evm.CallCode(contract, toAddr, args, gas, value)
 	if err != nil {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else {
-		stack.push(big.NewInt(1))
+		stack.push(evm.interpreter.intPool.get().SetUint64(1))
 	}
 	if err == nil || err == errExecutionReverted {
 		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
@@ -672,9 +735,9 @@ func opDelegateCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, st
 
 	ret, returnGas, err := evm.DelegateCall(contract, toAddr, args, gas)
 	if err != nil {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else {
-		stack.push(big.NewInt(1))
+		stack.push(evm.interpreter.intPool.get().SetUint64(1))
 	}
 	if err == nil || err == errExecutionReverted {
 		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
@@ -697,9 +760,9 @@ func opStaticCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stac
 
 	ret, returnGas, err := evm.StaticCall(contract, toAddr, args, gas)
 	if err != nil {
-		stack.push(new(big.Int))
+		stack.push(evm.interpreter.intPool.getZero())
 	} else {
-		stack.push(big.NewInt(1))
+		stack.push(evm.interpreter.intPool.get().SetUint64(1))
 	}
 	if err == nil || err == errExecutionReverted {
 		memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
@@ -787,7 +850,7 @@ func makePush(size uint64, pushByteSize int) executionFunc {
 	}
 }
 
-// make push instruction function
+// make dup instruction function
 func makeDup(size int64) executionFunc {
 	return func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
 		stack.dup(evm.interpreter.intPool, int(size))
diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go
index 18644989c1..f51e6363f6 100644
--- a/core/vm/instructions_test.go
+++ b/core/vm/instructions_test.go
@@ -1,3 +1,19 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
 package vm
 
 import (
@@ -8,9 +24,51 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+type twoOperandTest struct {
+	x        string
+	y        string
+	expected string
+}
+
+func testTwoOperandOp(t *testing.T, tests []twoOperandTest, opFn func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error)) {
+	var (
+		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
+		stack = newstack()
+		pc    = uint64(0)
+	)
+	for i, test := range tests {
+		x := new(big.Int).SetBytes(common.Hex2Bytes(test.x))
+		shift := new(big.Int).SetBytes(common.Hex2Bytes(test.y))
+		expected := new(big.Int).SetBytes(common.Hex2Bytes(test.expected))
+		stack.push(x)
+		stack.push(shift)
+		opFn(&pc, env, nil, nil, stack)
+		actual := stack.pop()
+		if actual.Cmp(expected) != 0 {
+			t.Errorf("Testcase %d, expected  %v, got %v", i, expected, actual)
+		}
+		// Check pool usage
+		// 1.pool is not allowed to contain anything on the stack
+		// 2.pool is not allowed to contain the same pointers twice
+		if env.interpreter.intPool.pool.len() > 0 {
+
+			poolvals := make(map[*big.Int]struct{})
+			poolvals[actual] = struct{}{}
+
+			for env.interpreter.intPool.pool.len() > 0 {
+				key := env.interpreter.intPool.get()
+				if _, exist := poolvals[key]; exist {
+					t.Errorf("Testcase %d, pool contains double-entry", i)
+				}
+				poolvals[key] = struct{}{}
+			}
+		}
+	}
+}
+
 func TestByteOp(t *testing.T) {
 	var (
-		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{EnableJit: false, ForceJit: false})
+		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
 		stack = newstack()
 	)
 	tests := []struct {
@@ -41,9 +99,106 @@ func TestByteOp(t *testing.T) {
 	}
 }
 
+func TestSHL(t *testing.T) {
+	// Testcases from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-145.md#shl-shift-left
+	tests := []twoOperandTest{
+		{"0000000000000000000000000000000000000000000000000000000000000001", "00", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "01", "0000000000000000000000000000000000000000000000000000000000000002"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "ff", "8000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "0100", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "0101", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "00", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "01", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ff", "8000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0100", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000000", "01", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "01", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"},
+	}
+	testTwoOperandOp(t, tests, opSHL)
+}
+
+func TestSHR(t *testing.T) {
+	// Testcases from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-145.md#shr-logical-shift-right
+	tests := []twoOperandTest{
+		{"0000000000000000000000000000000000000000000000000000000000000001", "00", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "01", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "01", "4000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "ff", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "0100", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "0101", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "00", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "01", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ff", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0100", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000000", "01", "0000000000000000000000000000000000000000000000000000000000000000"},
+	}
+	testTwoOperandOp(t, tests, opSHR)
+}
+
+func TestSAR(t *testing.T) {
+	// Testcases from https://github.com/ethereum/EIPs/blob/master/EIPS/eip-145.md#sar-arithmetic-shift-right
+	tests := []twoOperandTest{
+		{"0000000000000000000000000000000000000000000000000000000000000001", "00", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "01", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "01", "c000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "ff", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "0100", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"8000000000000000000000000000000000000000000000000000000000000000", "0101", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "00", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "01", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ff", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0100", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"},
+		{"0000000000000000000000000000000000000000000000000000000000000000", "01", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"4000000000000000000000000000000000000000000000000000000000000000", "fe", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "f8", "000000000000000000000000000000000000000000000000000000000000007f"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "fe", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0100", "0000000000000000000000000000000000000000000000000000000000000000"},
+	}
+
+	testTwoOperandOp(t, tests, opSAR)
+}
+
+func TestSGT(t *testing.T) {
+	tests := []twoOperandTest{
+
+		{"0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000001", "8000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000001", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "8000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb", "0000000000000000000000000000000000000000000000000000000000000000"},
+	}
+	testTwoOperandOp(t, tests, opSgt)
+}
+
+func TestSLT(t *testing.T) {
+	tests := []twoOperandTest{
+		{"0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"0000000000000000000000000000000000000000000000000000000000000001", "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"8000000000000000000000000000000000000000000000000000000000000001", "8000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"8000000000000000000000000000000000000000000000000000000000000001", "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", "8000000000000000000000000000000000000000000000000000000000000001", "0000000000000000000000000000000000000000000000000000000000000001"},
+		{"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd", "0000000000000000000000000000000000000000000000000000000000000000"},
+		{"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd", "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffb", "0000000000000000000000000000000000000000000000000000000000000001"},
+	}
+	testTwoOperandOp(t, tests, opSlt)
+}
+
 func opBenchmark(bench *testing.B, op func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error), args ...string) {
 	var (
-		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{EnableJit: false, ForceJit: false})
+		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
 		stack = newstack()
 	)
 	// convert args
@@ -199,7 +354,11 @@ func BenchmarkOpEq(b *testing.B) {
 
 	opBenchmark(b, opEq, x, y)
 }
-
+func BenchmarkOpEq2(b *testing.B) {
+	x := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201ffffffff"
+	y := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201fffffffe"
+	opBenchmark(b, opEq, x, y)
+}
 func BenchmarkOpAnd(b *testing.B) {
 	x := "ABCDEF090807060504030201ffffffffffffffffffffffffffffffffffffffff"
 	y := "ABCDEF090807060504030201ffffffffffffffffffffffffffffffffffffffff"
@@ -243,3 +402,65 @@ func BenchmarkOpMulmod(b *testing.B) {
 
 	opBenchmark(b, opMulmod, x, y, z)
 }
+
+func BenchmarkOpSHL(b *testing.B) {
+	x := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201ffffffff"
+	y := "ff"
+
+	opBenchmark(b, opSHL, x, y)
+}
+func BenchmarkOpSHR(b *testing.B) {
+	x := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201ffffffff"
+	y := "ff"
+
+	opBenchmark(b, opSHR, x, y)
+}
+func BenchmarkOpSAR(b *testing.B) {
+	x := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201ffffffff"
+	y := "ff"
+
+	opBenchmark(b, opSAR, x, y)
+}
+func BenchmarkOpIsZero(b *testing.B) {
+	x := "FBCDEF090807060504030201ffffffffFBCDEF090807060504030201ffffffff"
+	opBenchmark(b, opIszero, x)
+}
+
+func TestOpMstore(t *testing.T) {
+	var (
+		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
+		stack = newstack()
+		mem   = NewMemory()
+	)
+	mem.Resize(64)
+	pc := uint64(0)
+	v := "abcdef00000000000000abba000000000deaf000000c0de00100000000133700"
+	stack.pushN(new(big.Int).SetBytes(common.Hex2Bytes(v)), big.NewInt(0))
+	opMstore(&pc, env, nil, mem, stack)
+	if got := common.Bytes2Hex(mem.Get(0, 32)); got != v {
+		t.Fatalf("Mstore fail, got %v, expected %v", got, v)
+	}
+	stack.pushN(big.NewInt(0x1), big.NewInt(0))
+	opMstore(&pc, env, nil, mem, stack)
+	if common.Bytes2Hex(mem.Get(0, 32)) != "0000000000000000000000000000000000000000000000000000000000000001" {
+		t.Fatalf("Mstore failed to overwrite previous value")
+	}
+}
+
+func BenchmarkOpMstore(bench *testing.B) {
+	var (
+		env   = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
+		stack = newstack()
+		mem   = NewMemory()
+	)
+	mem.Resize(64)
+	pc := uint64(0)
+	memStart := big.NewInt(0)
+	value := big.NewInt(0x1337)
+
+	bench.ResetTimer()
+	for i := 0; i < bench.N; i++ {
+		stack.pushN(value, memStart)
+		opMstore(&pc, env, nil, mem, stack)
+	}
+}
diff --git a/core/vm/interface.go b/core/vm/interface.go
index c0c52732bb..1ef91cf1d6 100644
--- a/core/vm/interface.go
+++ b/core/vm/interface.go
@@ -39,8 +39,8 @@ type StateDB interface {
 	SetCode(common.Address, []byte)
 	GetCodeSize(common.Address) int
 
-	AddRefund(*big.Int)
-	GetRefund() *big.Int
+	AddRefund(uint64)
+	GetRefund() uint64
 
 	GetState(common.Address, common.Hash) common.Hash
 	SetState(common.Address, common.Hash, common.Hash)
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index 455f970ddb..7090e0261f 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -20,9 +20,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
 )
 
@@ -30,17 +28,11 @@ import (
 type Config struct {
 	// Debug enabled debugging Interpreter options
 	Debug bool
-	// EnableJit enabled the JIT VM
-	EnableJit bool
-	// ForceJit forces the JIT VM
-	ForceJit bool
 	// Tracer is the op code logger
 	Tracer Tracer
 	// NoRecursion disabled Interpreter call, callcode,
 	// delegate call and create.
 	NoRecursion bool
-	// Disable gas metering
-	DisableGasMetering bool
 	// Enable recording of SHA3/keccak preimages
 	EnablePreimageRecording bool
 	// JumpTable contains the EVM instruction table. This
@@ -50,8 +42,8 @@ type Config struct {
 }
 
 // Interpreter is used to run Ethereum based contracts and will utilise the
-// passed evmironment to query external sources for state information.
-// The Interpreter will run the byte code VM or JIT VM based on the passed
+// passed environment to query external sources for state information.
+// The Interpreter will run the byte code VM based on the passed
 // configuration.
 type Interpreter struct {
 	evm      *EVM
@@ -70,6 +62,8 @@ func NewInterpreter(evm *EVM, cfg Config) *Interpreter {
 	// we'll set the default jump table.
 	if !cfg.JumpTable[STOP].valid {
 		switch {
+		case evm.ChainConfig().IsConstantinople(evm.BlockNumber):
+			cfg.JumpTable = constantinopleInstructionSet
 		case evm.ChainConfig().IsByzantium(evm.BlockNumber):
 			cfg.JumpTable = byzantiumInstructionSet
 		case evm.ChainConfig().IsHomestead(evm.BlockNumber):
@@ -123,11 +117,6 @@ func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err er
 		return nil, nil
 	}
 
-	codehash := contract.CodeHash // codehash is used when doing jump dest caching
-	if codehash == (common.Hash{}) {
-		codehash = crypto.Keccak256Hash(contract.Code)
-	}
-
 	var (
 		op    OpCode        // current opcode
 		mem   = NewMemory() // bound memory
@@ -144,12 +133,17 @@ func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err er
 	)
 	contract.Input = input
 
-	defer func() {
-		if err != nil && !logged && in.cfg.Debug {
-			in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
-		}
-	}()
-
+	if in.cfg.Debug {
+		defer func() {
+			if err != nil {
+				if !logged {
+					in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
+				} else {
+					in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err)
+				}
+			}
+		}()
+	}
 	// The Interpreter main run loop (contextual). This loop runs until either an
 	// explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during
 	// the execution of one of the operations or until the done flag is set by the
@@ -189,14 +183,11 @@ func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err er
 				return nil, errGasUintOverflow
 			}
 		}
-
-		if !in.cfg.DisableGasMetering {
-			// consume the gas and return an error if not enough gas is available.
-			// cost is explicitly set so that the capture state defer method cas get the proper cost
-			cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize)
-			if err != nil || !contract.UseGas(cost) {
-				return nil, ErrOutOfGas
-			}
+		// consume the gas and return an error if not enough gas is available.
+		// cost is explicitly set so that the capture state defer method can get the proper cost
+		cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize)
+		if err != nil || !contract.UseGas(cost) {
+			return nil, ErrOutOfGas
 		}
 		if memorySize > 0 {
 			mem.Resize(memorySize)
diff --git a/core/vm/intpool.go b/core/vm/intpool.go
index 384f5df59b..5dbda18eee 100644
--- a/core/vm/intpool.go
+++ b/core/vm/intpool.go
@@ -32,24 +32,36 @@ func newIntPool() *intPool {
 	return &intPool{pool: newstack()}
 }
 
+// get retrieves a big int from the pool, allocating one if the pool is empty.
+// Note, the returned int's value is arbitrary and will not be zeroed!
 func (p *intPool) get() *big.Int {
 	if p.pool.len() > 0 {
 		return p.pool.pop()
 	}
 	return new(big.Int)
 }
+
+// getZero retrieves a big int from the pool, setting it to zero or allocating
+// a new one if the pool is empty.
+func (p *intPool) getZero() *big.Int {
+	if p.pool.len() > 0 {
+		return p.pool.pop().SetUint64(0)
+	}
+	return new(big.Int)
+}
+
+// put returns an allocated big int to the pool to be later reused by get calls.
+// Note, the values as saved as is; neither put nor get zeroes the ints out!
 func (p *intPool) put(is ...*big.Int) {
 	if len(p.pool.data) > poolLimit {
 		return
 	}
-
 	for _, i := range is {
 		// verifyPool is a build flag. Pool verification makes sure the integrity
 		// of the integer pool by comparing values to a default value.
 		if verifyPool {
 			i.Set(checkVal)
 		}
-
 		p.pool.push(i)
 	}
 }
diff --git a/core/vm/jump_table.go b/core/vm/jump_table.go
index a1c5ad9c67..49a94d9646 100644
--- a/core/vm/jump_table.go
+++ b/core/vm/jump_table.go
@@ -33,7 +33,7 @@ type (
 var errGasUintOverflow = errors.New("gas uint64 overflow")
 
 type operation struct {
-	// op is the operation function
+	// execute is the operation function
 	execute executionFunc
 	// gasCost is the gas function and returns the gas required for execution
 	gasCost gasFunc
@@ -51,11 +51,38 @@ type operation struct {
 }
 
 var (
-	frontierInstructionSet  = NewFrontierInstructionSet()
-	homesteadInstructionSet = NewHomesteadInstructionSet()
-	byzantiumInstructionSet = NewByzantiumInstructionSet()
+	frontierInstructionSet       = NewFrontierInstructionSet()
+	homesteadInstructionSet      = NewHomesteadInstructionSet()
+	byzantiumInstructionSet      = NewByzantiumInstructionSet()
+	constantinopleInstructionSet = NewConstantinopleInstructionSet()
 )
 
+// NewConstantinopleInstructionSet returns the frontier, homestead
+// byzantium and contantinople instructions.
+func NewConstantinopleInstructionSet() [256]operation {
+	// instructions that can be executed during the byzantium phase.
+	instructionSet := NewByzantiumInstructionSet()
+	instructionSet[SHL] = operation{
+		execute:       opSHL,
+		gasCost:       constGasFunc(GasFastestStep),
+		validateStack: makeStackFunc(2, 1),
+		valid:         true,
+	}
+	instructionSet[SHR] = operation{
+		execute:       opSHR,
+		gasCost:       constGasFunc(GasFastestStep),
+		validateStack: makeStackFunc(2, 1),
+		valid:         true,
+	}
+	instructionSet[SAR] = operation{
+		execute:       opSAR,
+		gasCost:       constGasFunc(GasFastestStep),
+		validateStack: makeStackFunc(2, 1),
+		valid:         true,
+	}
+	return instructionSet
+}
+
 // NewByzantiumInstructionSet returns the frontier, homestead and
 // byzantium instructions.
 func NewByzantiumInstructionSet() [256]operation {
diff --git a/core/vm/logger.go b/core/vm/logger.go
index 75309da921..c32a7b4044 100644
--- a/core/vm/logger.go
+++ b/core/vm/logger.go
@@ -31,9 +31,9 @@ import (
 
 type Storage map[common.Hash]common.Hash
 
-func (self Storage) Copy() Storage {
+func (s Storage) Copy() Storage {
 	cpy := make(Storage)
-	for key, value := range self {
+	for key, value := range s {
 		cpy[key] = value
 	}
 
@@ -45,6 +45,7 @@ type LogConfig struct {
 	DisableMemory  bool // disable memory capture
 	DisableStack   bool // disable stack capture
 	DisableStorage bool // disable storage capture
+	Debug          bool // print output during capture end
 	Limit          int  // maximum length of output, but zero means unlimited
 }
 
@@ -62,29 +63,39 @@ type StructLog struct {
 	Stack      []*big.Int                  `json:"stack"`
 	Storage    map[common.Hash]common.Hash `json:"-"`
 	Depth      int                         `json:"depth"`
-	Err        error                       `json:"error"`
+	Err        error                       `json:"-"`
 }
 
 // overrides for gencodec
 type structLogMarshaling struct {
-	Stack   []*math.HexOrDecimal256
-	Gas     math.HexOrDecimal64
-	GasCost math.HexOrDecimal64
-	Memory  hexutil.Bytes
-	OpName  string `json:"opName"`
+	Stack       []*math.HexOrDecimal256
+	Gas         math.HexOrDecimal64
+	GasCost     math.HexOrDecimal64
+	Memory      hexutil.Bytes
+	OpName      string `json:"opName"` // adds call to OpName() in MarshalJSON
+	ErrorString string `json:"error"`  // adds call to ErrorString() in MarshalJSON
 }
 
 func (s *StructLog) OpName() string {
 	return s.Op.String()
 }
 
+func (s *StructLog) ErrorString() string {
+	if s.Err != nil {
+		return s.Err.Error()
+	}
+	return ""
+}
+
 // Tracer is used to collect execution traces from an EVM transaction
 // execution. CaptureState is called for each step of the VM with the
 // current VM state.
 // Note that reference types are actual VM data structures; make copies
 // if you need to retain them beyond the current call.
 type Tracer interface {
+	CaptureStart(from common.Address, to common.Address, call bool, input []byte, gas uint64, value *big.Int) error
 	CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
+	CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error
 	CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error
 }
 
@@ -98,6 +109,8 @@ type StructLogger struct {
 
 	logs          []StructLog
 	changedValues map[common.Address]Storage
+	output        []byte
+	err           error
 }
 
 // NewStructLogger returns a new logger
@@ -111,6 +124,10 @@ func NewStructLogger(cfg *LogConfig) *StructLogger {
 	return logger
 }
 
+func (l *StructLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error {
+	return nil
+}
+
 // CaptureState logs a new structured log message and pushes it out to the environment
 //
 // CaptureState also tracks SSTORE ops to track dirty values.
@@ -161,18 +178,30 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui
 	return nil
 }
 
+func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error {
+	return nil
+}
+
 func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error {
-	fmt.Printf("0x%x", output)
-	if err != nil {
-		fmt.Printf(" error: %v\n", err)
+	l.output = output
+	l.err = err
+	if l.cfg.Debug {
+		fmt.Printf("0x%x\n", output)
+		if err != nil {
+			fmt.Printf(" error: %v\n", err)
+		}
 	}
 	return nil
 }
 
-// StructLogs returns a list of captured log entries
-func (l *StructLogger) StructLogs() []StructLog {
-	return l.logs
-}
+// StructLogs returns the captured log entries.
+func (l *StructLogger) StructLogs() []StructLog { return l.logs }
+
+// Error returns the VM error captured by the trace.
+func (l *StructLogger) Error() error { return l.err }
+
+// Output returns the VM return value captured by the trace.
+func (l *StructLogger) Output() []byte { return l.output }
 
 // WriteTrace writes a formatted trace to the given writer
 func WriteTrace(writer io.Writer, logs []StructLog) {
diff --git a/core/vm/logger_test.go b/core/vm/logger_test.go
index 915f7177e7..28830c445c 100644
--- a/core/vm/logger_test.go
+++ b/core/vm/logger_test.go
@@ -48,7 +48,7 @@ type dummyStateDB struct {
 
 func TestStoreCapture(t *testing.T) {
 	var (
-		env      = NewEVM(Context{}, nil, params.TestChainConfig, Config{EnableJit: false, ForceJit: false})
+		env      = NewEVM(Context{}, nil, params.TestChainConfig, Config{})
 		logger   = NewStructLogger(nil)
 		mem      = NewMemory()
 		stack    = newstack()
diff --git a/core/vm/memory.go b/core/vm/memory.go
index 99a84d2271..43f6ff5bff 100644
--- a/core/vm/memory.go
+++ b/core/vm/memory.go
@@ -16,7 +16,12 @@
 
 package vm
 
-import "fmt"
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common/math"
+)
 
 // Memory implements a simple memory model for the ethereum virtual machine.
 type Memory struct {
@@ -30,19 +35,32 @@ func NewMemory() *Memory {
 
 // Set sets offset + size to value
 func (m *Memory) Set(offset, size uint64, value []byte) {
-	// length of store may never be less than offset + size.
-	// The store should be resized PRIOR to setting the memory
-	if size > uint64(len(m.store)) {
-		panic("INVALID memory: store empty")
-	}
-
 	// It's possible the offset is greater than 0 and size equals 0. This is because
 	// the calcMemSize (common.go) could potentially return 0 when size is zero (NO-OP)
 	if size > 0 {
+		// length of store may never be less than offset + size.
+		// The store should be resized PRIOR to setting the memory
+		if offset+size > uint64(len(m.store)) {
+			panic("invalid memory: store empty")
+		}
 		copy(m.store[offset:offset+size], value)
 	}
 }
 
+// Set32 sets the 32 bytes starting at offset to the value of val, left-padded with zeroes to
+// 32 bytes.
+func (m *Memory) Set32(offset uint64, val *big.Int) {
+	// length of store may never be less than offset + size.
+	// The store should be resized PRIOR to setting the memory
+	if offset+32 > uint64(len(m.store)) {
+		panic("invalid memory: store empty")
+	}
+	// Zero the memory area
+	copy(m.store[offset:offset+32], []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
+	// Fill in relevant bits
+	math.ReadBits(val, m.store[offset:offset+32])
+}
+
 // Resize resizes the memory to size
 func (m *Memory) Resize(size uint64) {
 	if uint64(m.Len()) < size {
@@ -51,14 +69,14 @@ func (m *Memory) Resize(size uint64) {
 }
 
 // Get returns offset + size as a new slice
-func (self *Memory) Get(offset, size int64) (cpy []byte) {
+func (m *Memory) Get(offset, size int64) (cpy []byte) {
 	if size == 0 {
 		return nil
 	}
 
-	if len(self.store) > int(offset) {
+	if len(m.store) > int(offset) {
 		cpy = make([]byte, size)
-		copy(cpy, self.store[offset:offset+size])
+		copy(cpy, m.store[offset:offset+size])
 
 		return
 	}
@@ -67,13 +85,13 @@ func (self *Memory) Get(offset, size int64) (cpy []byte) {
 }
 
 // GetPtr returns the offset + size
-func (self *Memory) GetPtr(offset, size int64) []byte {
+func (m *Memory) GetPtr(offset, size int64) []byte {
 	if size == 0 {
 		return nil
 	}
 
-	if len(self.store) > int(offset) {
-		return self.store[offset : offset+size]
+	if len(m.store) > int(offset) {
+		return m.store[offset : offset+size]
 	}
 
 	return nil
diff --git a/core/vm/memory_table.go b/core/vm/memory_table.go
index bec0235bcc..ab49ebb38b 100644
--- a/core/vm/memory_table.go
+++ b/core/vm/memory_table.go
@@ -65,12 +65,6 @@ func memoryCall(stack *Stack) *big.Int {
 	return math.BigMax(x, y)
 }
 
-func memoryCallCode(stack *Stack) *big.Int {
-	x := calcMemSize(stack.Back(5), stack.Back(6))
-	y := calcMemSize(stack.Back(3), stack.Back(4))
-
-	return math.BigMax(x, y)
-}
 func memoryDelegateCall(stack *Stack) *big.Int {
 	x := calcMemSize(stack.Back(4), stack.Back(5))
 	y := calcMemSize(stack.Back(2), stack.Back(3))
diff --git a/core/vm/noop.go b/core/vm/noop.go
index 2a04a95654..b71ead0d77 100644
--- a/core/vm/noop.go
+++ b/core/vm/noop.go
@@ -55,8 +55,8 @@ func (NoopStateDB) GetCodeHash(common.Address) common.Hash
 func (NoopStateDB) GetCode(common.Address) []byte                                      { return nil }
 func (NoopStateDB) SetCode(common.Address, []byte)                                     {}
 func (NoopStateDB) GetCodeSize(common.Address) int                                     { return 0 }
-func (NoopStateDB) AddRefund(*big.Int)                                                 {}
-func (NoopStateDB) GetRefund() *big.Int                                                { return nil }
+func (NoopStateDB) AddRefund(uint64)                                                   {}
+func (NoopStateDB) GetRefund() uint64                                                  { return 0 }
 func (NoopStateDB) GetState(common.Address, common.Hash) common.Hash                   { return common.Hash{} }
 func (NoopStateDB) SetState(common.Address, common.Hash, common.Hash)                  {}
 func (NoopStateDB) Suicide(common.Address) bool                                        { return false }
diff --git a/core/vm/opcodes.go b/core/vm/opcodes.go
index 0c65507355..e3568eb000 100644
--- a/core/vm/opcodes.go
+++ b/core/vm/opcodes.go
@@ -63,6 +63,9 @@ const (
 	XOR
 	NOT
 	BYTE
+	SHL
+	SHR
+	SAR
 
 	SHA3 = 0x20
 )
@@ -234,6 +237,9 @@ var opCodeToString = map[OpCode]string{
 	OR:     "OR",
 	XOR:    "XOR",
 	BYTE:   "BYTE",
+	SHL:    "SHL",
+	SHR:    "SHR",
+	SAR:    "SAR",
 	ADDMOD: "ADDMOD",
 	MULMOD: "MULMOD",
 
@@ -369,10 +375,10 @@ var opCodeToString = map[OpCode]string{
 	SWAP: "SWAP",
 }
 
-func (o OpCode) String() string {
-	str := opCodeToString[o]
+func (op OpCode) String() string {
+	str := opCodeToString[op]
 	if len(str) == 0 {
-		return fmt.Sprintf("Missing opcode 0x%x", int(o))
+		return fmt.Sprintf("Missing opcode 0x%x", int(op))
 	}
 
 	return str
@@ -400,6 +406,9 @@ var stringToOp = map[string]OpCode{
 	"OR":             OR,
 	"XOR":            XOR,
 	"BYTE":           BYTE,
+	"SHL":            SHL,
+	"SHR":            SHR,
+	"SAR":            SAR,
 	"ADDMOD":         ADDMOD,
 	"MULMOD":         MULMOD,
 	"SHA3":           SHA3,
diff --git a/core/vm/runtime/env.go b/core/vm/runtime/env.go
index 818da1be26..31c9b9cf9d 100644
--- a/core/vm/runtime/env.go
+++ b/core/vm/runtime/env.go
@@ -17,8 +17,6 @@
 package runtime
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/vm"
@@ -35,7 +33,7 @@ func NewEnv(cfg *Config) *vm.EVM {
 		BlockNumber: cfg.BlockNumber,
 		Time:        cfg.Time,
 		Difficulty:  cfg.Difficulty,
-		GasLimit:    new(big.Int).SetUint64(cfg.GasLimit),
+		GasLimit:    cfg.GasLimit,
 		GasPrice:    cfg.GasPrice,
 	}
 
diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go
index edbf541766..cda49a34b4 100644
--- a/core/vm/runtime/runtime.go
+++ b/core/vm/runtime/runtime.go
@@ -41,7 +41,6 @@ type Config struct {
 	GasLimit    uint64
 	GasPrice    *big.Int
 	Value       *big.Int
-	DisableJit  bool // "disable" so it's enabled by default
 	Debug       bool
 	EVMConfig   vm.Config
 
@@ -53,7 +52,7 @@ type Config struct {
 func setDefaults(cfg *Config) {
 	if cfg.ChainConfig == nil {
 		cfg.ChainConfig = ¶ms.ChainConfig{
-			ChainId:        big.NewInt(1),
+			ChainID:        big.NewInt(1),
 			HomesteadBlock: new(big.Int),
 			DAOForkBlock:   new(big.Int),
 			DAOForkSupport: false,
@@ -92,8 +91,7 @@ func setDefaults(cfg *Config) {
 // It returns the EVM's return value, the new state and an error if it failed.
 //
 // Executes sets up a in memory, temporarily, environment for the execution of
-// the given code. It enabled the JIT by default and make sure that it's restored
-// to it's original state afterwards.
+// the given code. It makes sure that it's restored to it's original state afterwards.
 func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
 	if cfg == nil {
 		cfg = new(Config)
@@ -101,11 +99,10 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
 	setDefaults(cfg)
 
 	if cfg.State == nil {
-		db, _ := ethdb.NewMemDatabase()
-		cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db))
+		cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 	}
 	var (
-		address = common.StringToAddress("contract")
+		address = common.BytesToAddress([]byte("contract"))
 		vmenv   = NewEnv(cfg)
 		sender  = vm.AccountRef(cfg.Origin)
 	)
@@ -115,7 +112,7 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
 	// Call the code with the given configuration.
 	ret, _, err := vmenv.Call(
 		sender,
-		common.StringToAddress("contract"),
+		common.BytesToAddress([]byte("contract")),
 		input,
 		cfg.GasLimit,
 		cfg.Value,
@@ -132,8 +129,7 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) {
 	setDefaults(cfg)
 
 	if cfg.State == nil {
-		db, _ := ethdb.NewMemDatabase()
-		cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db))
+		cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 	}
 	var (
 		vmenv  = NewEnv(cfg)
diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go
index 2c4dc50265..ef664bda30 100644
--- a/core/vm/runtime/runtime_test.go
+++ b/core/vm/runtime/runtime_test.go
@@ -94,8 +94,7 @@ func TestExecute(t *testing.T) {
 }
 
 func TestCall(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	state, _ := state.New(common.Hash{}, state.NewDatabase(db))
+	state, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
 	address := common.HexToAddress("0x0a")
 	state.SetCode(address, []byte{
 		byte(vm.PUSH1), 10,
diff --git a/crypto/bn256/bn256_fast.go b/crypto/bn256/bn256_fast.go
new file mode 100644
index 0000000000..a8dfa8f67d
--- /dev/null
+++ b/crypto/bn256/bn256_fast.go
@@ -0,0 +1,35 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// +build amd64 arm64
+
+// Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
+package bn256
+
+import "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
+
+// G1 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G1 = bn256.G1
+
+// G2 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G2 = bn256.G2
+
+// PairingCheck calculates the Optimal Ate pairing for a set of points.
+func PairingCheck(a []*G1, b []*G2) bool {
+	return bn256.PairingCheck(a, b)
+}
diff --git a/crypto/bn256/bn256_fuzz.go b/crypto/bn256/bn256_fuzz.go
new file mode 100644
index 0000000000..f360b0541f
--- /dev/null
+++ b/crypto/bn256/bn256_fuzz.go
@@ -0,0 +1,138 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// +build gofuzz
+
+package bn256
+
+import (
+	"bytes"
+	"math/big"
+
+	cloudflare "github.com/ethereum/go-ethereum/crypto/bn256/cloudflare"
+	google "github.com/ethereum/go-ethereum/crypto/bn256/google"
+)
+
+// FuzzAdd fuzzez bn256 addition between the Google and Cloudflare libraries.
+func FuzzAdd(data []byte) int {
+	// Ensure we have enough data in the first place
+	if len(data) != 128 {
+		return 0
+	}
+	// Ensure both libs can parse the first curve point
+	xc := new(cloudflare.G1)
+	_, errc := xc.Unmarshal(data[:64])
+
+	xg := new(google.G1)
+	_, errg := xg.Unmarshal(data[:64])
+
+	if (errc == nil) != (errg == nil) {
+		panic("parse mismatch")
+	} else if errc != nil {
+		return 0
+	}
+	// Ensure both libs can parse the second curve point
+	yc := new(cloudflare.G1)
+	_, errc = yc.Unmarshal(data[64:])
+
+	yg := new(google.G1)
+	_, errg = yg.Unmarshal(data[64:])
+
+	if (errc == nil) != (errg == nil) {
+		panic("parse mismatch")
+	} else if errc != nil {
+		return 0
+	}
+	// Add the two points and ensure they result in the same output
+	rc := new(cloudflare.G1)
+	rc.Add(xc, yc)
+
+	rg := new(google.G1)
+	rg.Add(xg, yg)
+
+	if !bytes.Equal(rc.Marshal(), rg.Marshal()) {
+		panic("add mismatch")
+	}
+	return 0
+}
+
+// FuzzMul fuzzez bn256 scalar multiplication between the Google and Cloudflare
+// libraries.
+func FuzzMul(data []byte) int {
+	// Ensure we have enough data in the first place
+	if len(data) != 96 {
+		return 0
+	}
+	// Ensure both libs can parse the curve point
+	pc := new(cloudflare.G1)
+	_, errc := pc.Unmarshal(data[:64])
+
+	pg := new(google.G1)
+	_, errg := pg.Unmarshal(data[:64])
+
+	if (errc == nil) != (errg == nil) {
+		panic("parse mismatch")
+	} else if errc != nil {
+		return 0
+	}
+	// Add the two points and ensure they result in the same output
+	rc := new(cloudflare.G1)
+	rc.ScalarMult(pc, new(big.Int).SetBytes(data[64:]))
+
+	rg := new(google.G1)
+	rg.ScalarMult(pg, new(big.Int).SetBytes(data[64:]))
+
+	if !bytes.Equal(rc.Marshal(), rg.Marshal()) {
+		panic("scalar mul mismatch")
+	}
+	return 0
+}
+
+func FuzzPair(data []byte) int {
+	// Ensure we have enough data in the first place
+	if len(data) != 192 {
+		return 0
+	}
+	// Ensure both libs can parse the curve point
+	pc := new(cloudflare.G1)
+	_, errc := pc.Unmarshal(data[:64])
+
+	pg := new(google.G1)
+	_, errg := pg.Unmarshal(data[:64])
+
+	if (errc == nil) != (errg == nil) {
+		panic("parse mismatch")
+	} else if errc != nil {
+		return 0
+	}
+	// Ensure both libs can parse the twist point
+	tc := new(cloudflare.G2)
+	_, errc = tc.Unmarshal(data[64:])
+
+	tg := new(google.G2)
+	_, errg = tg.Unmarshal(data[64:])
+
+	if (errc == nil) != (errg == nil) {
+		panic("parse mismatch")
+	} else if errc != nil {
+		return 0
+	}
+	// Pair the two points and ensure thet result in the same output
+	if cloudflare.PairingCheck([]*cloudflare.G1{pc}, []*cloudflare.G2{tc}) != google.PairingCheck([]*google.G1{pg}, []*google.G2{tg}) {
+		panic("pair mismatch")
+	}
+	return 0
+}
diff --git a/crypto/bn256/bn256_slow.go b/crypto/bn256/bn256_slow.go
new file mode 100644
index 0000000000..61373763b8
--- /dev/null
+++ b/crypto/bn256/bn256_slow.go
@@ -0,0 +1,35 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+// +build !amd64,!arm64
+
+// Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
+package bn256
+
+import "github.com/ethereum/go-ethereum/crypto/bn256/google"
+
+// G1 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G1 = bn256.G1
+
+// G2 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G2 = bn256.G2
+
+// PairingCheck calculates the Optimal Ate pairing for a set of points.
+func PairingCheck(a []*G1, b []*G2) bool {
+	return bn256.PairingCheck(a, b)
+}
diff --git a/crypto/bn256/cloudflare/bn256.go b/crypto/bn256/cloudflare/bn256.go
new file mode 100644
index 0000000000..c6ea2d07e0
--- /dev/null
+++ b/crypto/bn256/cloudflare/bn256.go
@@ -0,0 +1,481 @@
+// Package bn256 implements a particular bilinear group at the 128-bit security
+// level.
+//
+// Bilinear groups are the basis of many of the new cryptographic protocols that
+// have been proposed over the past decade. They consist of a triplet of groups
+// (G₁, G₂ and GT) such that there exists a function e(g₁ˣ,g₂ʸ)=gTˣʸ (where gₓ
+// is a generator of the respective group). That function is called a pairing
+// function.
+//
+// This package specifically implements the Optimal Ate pairing over a 256-bit
+// Barreto-Naehrig curve as described in
+// http://cryptojedi.org/papers/dclxvi-20100714.pdf. Its output is compatible
+// with the implementation described in that paper.
+package bn256
+
+import (
+	"crypto/rand"
+	"errors"
+	"io"
+	"math/big"
+)
+
+func randomK(r io.Reader) (k *big.Int, err error) {
+	for {
+		k, err = rand.Int(r, Order)
+		if k.Sign() > 0 || err != nil {
+			return
+		}
+	}
+}
+
+// G1 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G1 struct {
+	p *curvePoint
+}
+
+// RandomG1 returns x and g₁ˣ where x is a random, non-zero number read from r.
+func RandomG1(r io.Reader) (*big.Int, *G1, error) {
+	k, err := randomK(r)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return k, new(G1).ScalarBaseMult(k), nil
+}
+
+func (g *G1) String() string {
+	return "bn256.G1" + g.p.String()
+}
+
+// ScalarBaseMult sets e to g*k where g is the generator of the group and then
+// returns e.
+func (e *G1) ScalarBaseMult(k *big.Int) *G1 {
+	if e.p == nil {
+		e.p = &curvePoint{}
+	}
+	e.p.Mul(curveGen, k)
+	return e
+}
+
+// ScalarMult sets e to a*k and then returns e.
+func (e *G1) ScalarMult(a *G1, k *big.Int) *G1 {
+	if e.p == nil {
+		e.p = &curvePoint{}
+	}
+	e.p.Mul(a.p, k)
+	return e
+}
+
+// Add sets e to a+b and then returns e.
+func (e *G1) Add(a, b *G1) *G1 {
+	if e.p == nil {
+		e.p = &curvePoint{}
+	}
+	e.p.Add(a.p, b.p)
+	return e
+}
+
+// Neg sets e to -a and then returns e.
+func (e *G1) Neg(a *G1) *G1 {
+	if e.p == nil {
+		e.p = &curvePoint{}
+	}
+	e.p.Neg(a.p)
+	return e
+}
+
+// Set sets e to a and then returns e.
+func (e *G1) Set(a *G1) *G1 {
+	if e.p == nil {
+		e.p = &curvePoint{}
+	}
+	e.p.Set(a.p)
+	return e
+}
+
+// Marshal converts e to a byte slice.
+func (e *G1) Marshal() []byte {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+
+	e.p.MakeAffine()
+	ret := make([]byte, numBytes*2)
+	if e.p.IsInfinity() {
+		return ret
+	}
+	temp := &gfP{}
+
+	montDecode(temp, &e.p.x)
+	temp.Marshal(ret)
+	montDecode(temp, &e.p.y)
+	temp.Marshal(ret[numBytes:])
+
+	return ret
+}
+
+// Unmarshal sets e to the result of converting the output of Marshal back into
+// a group element and then returns e.
+func (e *G1) Unmarshal(m []byte) ([]byte, error) {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+	if len(m) < 2*numBytes {
+		return nil, errors.New("bn256: not enough data")
+	}
+	// Unmarshal the points and check their caps
+	if e.p == nil {
+		e.p = &curvePoint{}
+	} else {
+		e.p.x, e.p.y = gfP{0}, gfP{0}
+	}
+	var err error
+	if err = e.p.x.Unmarshal(m); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.Unmarshal(m[numBytes:]); err != nil {
+		return nil, err
+	}
+	// Encode into Montgomery form and ensure it's on the curve
+	montEncode(&e.p.x, &e.p.x)
+	montEncode(&e.p.y, &e.p.y)
+
+	zero := gfP{0}
+	if e.p.x == zero && e.p.y == zero {
+		// This is the point at infinity.
+		e.p.y = *newGFp(1)
+		e.p.z = gfP{0}
+		e.p.t = gfP{0}
+	} else {
+		e.p.z = *newGFp(1)
+		e.p.t = *newGFp(1)
+
+		if !e.p.IsOnCurve() {
+			return nil, errors.New("bn256: malformed point")
+		}
+	}
+	return m[2*numBytes:], nil
+}
+
+// G2 is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type G2 struct {
+	p *twistPoint
+}
+
+// RandomG2 returns x and g₂ˣ where x is a random, non-zero number read from r.
+func RandomG2(r io.Reader) (*big.Int, *G2, error) {
+	k, err := randomK(r)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return k, new(G2).ScalarBaseMult(k), nil
+}
+
+func (e *G2) String() string {
+	return "bn256.G2" + e.p.String()
+}
+
+// ScalarBaseMult sets e to g*k where g is the generator of the group and then
+// returns out.
+func (e *G2) ScalarBaseMult(k *big.Int) *G2 {
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	e.p.Mul(twistGen, k)
+	return e
+}
+
+// ScalarMult sets e to a*k and then returns e.
+func (e *G2) ScalarMult(a *G2, k *big.Int) *G2 {
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	e.p.Mul(a.p, k)
+	return e
+}
+
+// Add sets e to a+b and then returns e.
+func (e *G2) Add(a, b *G2) *G2 {
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	e.p.Add(a.p, b.p)
+	return e
+}
+
+// Neg sets e to -a and then returns e.
+func (e *G2) Neg(a *G2) *G2 {
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	e.p.Neg(a.p)
+	return e
+}
+
+// Set sets e to a and then returns e.
+func (e *G2) Set(a *G2) *G2 {
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	e.p.Set(a.p)
+	return e
+}
+
+// Marshal converts e into a byte slice.
+func (e *G2) Marshal() []byte {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+
+	e.p.MakeAffine()
+	ret := make([]byte, numBytes*4)
+	if e.p.IsInfinity() {
+		return ret
+	}
+	temp := &gfP{}
+
+	montDecode(temp, &e.p.x.x)
+	temp.Marshal(ret)
+	montDecode(temp, &e.p.x.y)
+	temp.Marshal(ret[numBytes:])
+	montDecode(temp, &e.p.y.x)
+	temp.Marshal(ret[2*numBytes:])
+	montDecode(temp, &e.p.y.y)
+	temp.Marshal(ret[3*numBytes:])
+
+	return ret
+}
+
+// Unmarshal sets e to the result of converting the output of Marshal back into
+// a group element and then returns e.
+func (e *G2) Unmarshal(m []byte) ([]byte, error) {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+	if len(m) < 4*numBytes {
+		return nil, errors.New("bn256: not enough data")
+	}
+	// Unmarshal the points and check their caps
+	if e.p == nil {
+		e.p = &twistPoint{}
+	}
+	var err error
+	if err = e.p.x.x.Unmarshal(m); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.y.Unmarshal(m[numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.x.Unmarshal(m[2*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.y.Unmarshal(m[3*numBytes:]); err != nil {
+		return nil, err
+	}
+	// Encode into Montgomery form and ensure it's on the curve
+	montEncode(&e.p.x.x, &e.p.x.x)
+	montEncode(&e.p.x.y, &e.p.x.y)
+	montEncode(&e.p.y.x, &e.p.y.x)
+	montEncode(&e.p.y.y, &e.p.y.y)
+
+	if e.p.x.IsZero() && e.p.y.IsZero() {
+		// This is the point at infinity.
+		e.p.y.SetOne()
+		e.p.z.SetZero()
+		e.p.t.SetZero()
+	} else {
+		e.p.z.SetOne()
+		e.p.t.SetOne()
+
+		if !e.p.IsOnCurve() {
+			return nil, errors.New("bn256: malformed point")
+		}
+	}
+	return m[4*numBytes:], nil
+}
+
+// GT is an abstract cyclic group. The zero value is suitable for use as the
+// output of an operation, but cannot be used as an input.
+type GT struct {
+	p *gfP12
+}
+
+// Pair calculates an Optimal Ate pairing.
+func Pair(g1 *G1, g2 *G2) *GT {
+	return >{optimalAte(g2.p, g1.p)}
+}
+
+// PairingCheck calculates the Optimal Ate pairing for a set of points.
+func PairingCheck(a []*G1, b []*G2) bool {
+	acc := new(gfP12)
+	acc.SetOne()
+
+	for i := 0; i < len(a); i++ {
+		if a[i].p.IsInfinity() || b[i].p.IsInfinity() {
+			continue
+		}
+		acc.Mul(acc, miller(b[i].p, a[i].p))
+	}
+	return finalExponentiation(acc).IsOne()
+}
+
+// Miller applies Miller's algorithm, which is a bilinear function from the
+// source groups to F_p^12. Miller(g1, g2).Finalize() is equivalent to Pair(g1,
+// g2).
+func Miller(g1 *G1, g2 *G2) *GT {
+	return >{miller(g2.p, g1.p)}
+}
+
+func (g *GT) String() string {
+	return "bn256.GT" + g.p.String()
+}
+
+// ScalarMult sets e to a*k and then returns e.
+func (e *GT) ScalarMult(a *GT, k *big.Int) *GT {
+	if e.p == nil {
+		e.p = &gfP12{}
+	}
+	e.p.Exp(a.p, k)
+	return e
+}
+
+// Add sets e to a+b and then returns e.
+func (e *GT) Add(a, b *GT) *GT {
+	if e.p == nil {
+		e.p = &gfP12{}
+	}
+	e.p.Mul(a.p, b.p)
+	return e
+}
+
+// Neg sets e to -a and then returns e.
+func (e *GT) Neg(a *GT) *GT {
+	if e.p == nil {
+		e.p = &gfP12{}
+	}
+	e.p.Conjugate(a.p)
+	return e
+}
+
+// Set sets e to a and then returns e.
+func (e *GT) Set(a *GT) *GT {
+	if e.p == nil {
+		e.p = &gfP12{}
+	}
+	e.p.Set(a.p)
+	return e
+}
+
+// Finalize is a linear function from F_p^12 to GT.
+func (e *GT) Finalize() *GT {
+	ret := finalExponentiation(e.p)
+	e.p.Set(ret)
+	return e
+}
+
+// Marshal converts e into a byte slice.
+func (e *GT) Marshal() []byte {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+
+	ret := make([]byte, numBytes*12)
+	temp := &gfP{}
+
+	montDecode(temp, &e.p.x.x.x)
+	temp.Marshal(ret)
+	montDecode(temp, &e.p.x.x.y)
+	temp.Marshal(ret[numBytes:])
+	montDecode(temp, &e.p.x.y.x)
+	temp.Marshal(ret[2*numBytes:])
+	montDecode(temp, &e.p.x.y.y)
+	temp.Marshal(ret[3*numBytes:])
+	montDecode(temp, &e.p.x.z.x)
+	temp.Marshal(ret[4*numBytes:])
+	montDecode(temp, &e.p.x.z.y)
+	temp.Marshal(ret[5*numBytes:])
+	montDecode(temp, &e.p.y.x.x)
+	temp.Marshal(ret[6*numBytes:])
+	montDecode(temp, &e.p.y.x.y)
+	temp.Marshal(ret[7*numBytes:])
+	montDecode(temp, &e.p.y.y.x)
+	temp.Marshal(ret[8*numBytes:])
+	montDecode(temp, &e.p.y.y.y)
+	temp.Marshal(ret[9*numBytes:])
+	montDecode(temp, &e.p.y.z.x)
+	temp.Marshal(ret[10*numBytes:])
+	montDecode(temp, &e.p.y.z.y)
+	temp.Marshal(ret[11*numBytes:])
+
+	return ret
+}
+
+// Unmarshal sets e to the result of converting the output of Marshal back into
+// a group element and then returns e.
+func (e *GT) Unmarshal(m []byte) ([]byte, error) {
+	// Each value is a 256-bit number.
+	const numBytes = 256 / 8
+
+	if len(m) < 12*numBytes {
+		return nil, errors.New("bn256: not enough data")
+	}
+
+	if e.p == nil {
+		e.p = &gfP12{}
+	}
+
+	var err error
+	if err = e.p.x.x.x.Unmarshal(m); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.x.y.Unmarshal(m[numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.y.x.Unmarshal(m[2*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.y.y.Unmarshal(m[3*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.z.x.Unmarshal(m[4*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.x.z.y.Unmarshal(m[5*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.x.x.Unmarshal(m[6*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.x.y.Unmarshal(m[7*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.y.x.Unmarshal(m[8*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.y.y.Unmarshal(m[9*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.z.x.Unmarshal(m[10*numBytes:]); err != nil {
+		return nil, err
+	}
+	if err = e.p.y.z.y.Unmarshal(m[11*numBytes:]); err != nil {
+		return nil, err
+	}
+	montEncode(&e.p.x.x.x, &e.p.x.x.x)
+	montEncode(&e.p.x.x.y, &e.p.x.x.y)
+	montEncode(&e.p.x.y.x, &e.p.x.y.x)
+	montEncode(&e.p.x.y.y, &e.p.x.y.y)
+	montEncode(&e.p.x.z.x, &e.p.x.z.x)
+	montEncode(&e.p.x.z.y, &e.p.x.z.y)
+	montEncode(&e.p.y.x.x, &e.p.y.x.x)
+	montEncode(&e.p.y.x.y, &e.p.y.x.y)
+	montEncode(&e.p.y.y.x, &e.p.y.y.x)
+	montEncode(&e.p.y.y.y, &e.p.y.y.y)
+	montEncode(&e.p.y.z.x, &e.p.y.z.x)
+	montEncode(&e.p.y.z.y, &e.p.y.z.y)
+
+	return m[12*numBytes:], nil
+}
diff --git a/crypto/bn256/cloudflare/bn256_test.go b/crypto/bn256/cloudflare/bn256_test.go
new file mode 100644
index 0000000000..0c8016d86c
--- /dev/null
+++ b/crypto/bn256/cloudflare/bn256_test.go
@@ -0,0 +1,116 @@
+package bn256
+
+import (
+	"bytes"
+	"crypto/rand"
+	"testing"
+)
+
+func TestG1Marshal(t *testing.T) {
+	_, Ga, err := RandomG1(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ma := Ga.Marshal()
+
+	Gb := new(G1)
+	_, err = Gb.Unmarshal(ma)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mb := Gb.Marshal()
+
+	if !bytes.Equal(ma, mb) {
+		t.Fatal("bytes are different")
+	}
+}
+
+func TestG2Marshal(t *testing.T) {
+	_, Ga, err := RandomG2(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ma := Ga.Marshal()
+
+	Gb := new(G2)
+	_, err = Gb.Unmarshal(ma)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mb := Gb.Marshal()
+
+	if !bytes.Equal(ma, mb) {
+		t.Fatal("bytes are different")
+	}
+}
+
+func TestBilinearity(t *testing.T) {
+	for i := 0; i < 2; i++ {
+		a, p1, _ := RandomG1(rand.Reader)
+		b, p2, _ := RandomG2(rand.Reader)
+		e1 := Pair(p1, p2)
+
+		e2 := Pair(&G1{curveGen}, &G2{twistGen})
+		e2.ScalarMult(e2, a)
+		e2.ScalarMult(e2, b)
+
+		if *e1.p != *e2.p {
+			t.Fatalf("bad pairing result: %s", e1)
+		}
+	}
+}
+
+func TestTripartiteDiffieHellman(t *testing.T) {
+	a, _ := rand.Int(rand.Reader, Order)
+	b, _ := rand.Int(rand.Reader, Order)
+	c, _ := rand.Int(rand.Reader, Order)
+
+	pa, pb, pc := new(G1), new(G1), new(G1)
+	qa, qb, qc := new(G2), new(G2), new(G2)
+
+	pa.Unmarshal(new(G1).ScalarBaseMult(a).Marshal())
+	qa.Unmarshal(new(G2).ScalarBaseMult(a).Marshal())
+	pb.Unmarshal(new(G1).ScalarBaseMult(b).Marshal())
+	qb.Unmarshal(new(G2).ScalarBaseMult(b).Marshal())
+	pc.Unmarshal(new(G1).ScalarBaseMult(c).Marshal())
+	qc.Unmarshal(new(G2).ScalarBaseMult(c).Marshal())
+
+	k1 := Pair(pb, qc)
+	k1.ScalarMult(k1, a)
+	k1Bytes := k1.Marshal()
+
+	k2 := Pair(pc, qa)
+	k2.ScalarMult(k2, b)
+	k2Bytes := k2.Marshal()
+
+	k3 := Pair(pa, qb)
+	k3.ScalarMult(k3, c)
+	k3Bytes := k3.Marshal()
+
+	if !bytes.Equal(k1Bytes, k2Bytes) || !bytes.Equal(k2Bytes, k3Bytes) {
+		t.Errorf("keys didn't agree")
+	}
+}
+
+func BenchmarkG1(b *testing.B) {
+	x, _ := rand.Int(rand.Reader, Order)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		new(G1).ScalarBaseMult(x)
+	}
+}
+
+func BenchmarkG2(b *testing.B) {
+	x, _ := rand.Int(rand.Reader, Order)
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		new(G2).ScalarBaseMult(x)
+	}
+}
+func BenchmarkPairing(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Pair(&G1{curveGen}, &G2{twistGen})
+	}
+}
diff --git a/crypto/bn256/cloudflare/constants.go b/crypto/bn256/cloudflare/constants.go
new file mode 100644
index 0000000000..5122aae64f
--- /dev/null
+++ b/crypto/bn256/cloudflare/constants.go
@@ -0,0 +1,59 @@
+// Copyright 2012 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 bn256
+
+import (
+	"math/big"
+)
+
+func bigFromBase10(s string) *big.Int {
+	n, _ := new(big.Int).SetString(s, 10)
+	return n
+}
+
+// u is the BN parameter that determines the prime: 1868033³.
+var u = bigFromBase10("4965661367192848881")
+
+// Order is the number of elements in both G₁ and G₂: 36u⁴+36u³+18u²+6u+1.
+var Order = bigFromBase10("21888242871839275222246405745257275088548364400416034343698204186575808495617")
+
+// P is a prime over which we form a basic field: 36u⁴+36u³+24u²+6u+1.
+var P = bigFromBase10("21888242871839275222246405745257275088696311157297823662689037894645226208583")
+
+// p2 is p, represented as little-endian 64-bit words.
+var p2 = [4]uint64{0x3c208c16d87cfd47, 0x97816a916871ca8d, 0xb85045b68181585d, 0x30644e72e131a029}
+
+// np is the negative inverse of p, mod 2^256.
+var np = [4]uint64{0x87d20782e4866389, 0x9ede7d651eca6ac9, 0xd8afcbd01833da80, 0xf57a22b791888c6b}
+
+// rN1 is R^-1 where R = 2^256 mod p.
+var rN1 = &gfP{0xed84884a014afa37, 0xeb2022850278edf8, 0xcf63e9cfb74492d9, 0x2e67157159e5c639}
+
+// r2 is R^2 where R = 2^256 mod p.
+var r2 = &gfP{0xf32cfc5b538afa89, 0xb5e71911d44501fb, 0x47ab1eff0a417ff6, 0x06d89f71cab8351f}
+
+// r3 is R^3 where R = 2^256 mod p.
+var r3 = &gfP{0xb1cd6dafda1530df, 0x62f210e6a7283db6, 0xef7f0b0c0ada0afb, 0x20fd6e902d592544}
+
+// xiToPMinus1Over6 is ξ^((p-1)/6) where ξ = i+9.
+var xiToPMinus1Over6 = &gfP2{gfP{0xa222ae234c492d72, 0xd00f02a4565de15b, 0xdc2ff3a253dfc926, 0x10a75716b3899551}, gfP{0xaf9ba69633144907, 0xca6b1d7387afb78a, 0x11bded5ef08a2087, 0x02f34d751a1f3a7c}}
+
+// xiToPMinus1Over3 is ξ^((p-1)/3) where ξ = i+9.
+var xiToPMinus1Over3 = &gfP2{gfP{0x6e849f1ea0aa4757, 0xaa1c7b6d89f89141, 0xb6e713cdfae0ca3a, 0x26694fbb4e82ebc3}, gfP{0xb5773b104563ab30, 0x347f91c8a9aa6454, 0x7a007127242e0991, 0x1956bcd8118214ec}}
+
+// xiToPMinus1Over2 is ξ^((p-1)/2) where ξ = i+9.
+var xiToPMinus1Over2 = &gfP2{gfP{0xa1d77ce45ffe77c7, 0x07affd117826d1db, 0x6d16bd27bb7edc6b, 0x2c87200285defecc}, gfP{0xe4bbdd0c2936b629, 0xbb30f162e133bacb, 0x31a9d1b6f9645366, 0x253570bea500f8dd}}
+
+// xiToPSquaredMinus1Over3 is ξ^((p²-1)/3) where ξ = i+9.
+var xiToPSquaredMinus1Over3 = &gfP{0x3350c88e13e80b9c, 0x7dce557cdb5e56b9, 0x6001b4b8b615564a, 0x2682e617020217e0}
+
+// xiTo2PSquaredMinus2Over3 is ξ^((2p²-2)/3) where ξ = i+9 (a cubic root of unity, mod p).
+var xiTo2PSquaredMinus2Over3 = &gfP{0x71930c11d782e155, 0xa6bb947cffbe3323, 0xaa303344d4741444, 0x2c3b3f0d26594943}
+
+// xiToPSquaredMinus1Over6 is ξ^((1p²-1)/6) where ξ = i+9 (a cubic root of -1, mod p).
+var xiToPSquaredMinus1Over6 = &gfP{0xca8d800500fa1bf2, 0xf0c5d61468b39769, 0x0e201271ad0d4418, 0x04290f65bad856e6}
+
+// xiTo2PMinus2Over3 is ξ^((2p-2)/3) where ξ = i+9.
+var xiTo2PMinus2Over3 = &gfP2{gfP{0x5dddfd154bd8c949, 0x62cb29a5a4445b60, 0x37bc870a0c7dd2b9, 0x24830a9d3171f0fd}, gfP{0x7361d77f843abe92, 0xa5bb2bd3273411fb, 0x9c941f314b3e2399, 0x15df9cddbb9fd3ec}}
diff --git a/crypto/bn256/cloudflare/curve.go b/crypto/bn256/cloudflare/curve.go
new file mode 100644
index 0000000000..18e9b38f3f
--- /dev/null
+++ b/crypto/bn256/cloudflare/curve.go
@@ -0,0 +1,238 @@
+package bn256
+
+import (
+	"math/big"
+)
+
+// curvePoint implements the elliptic curve y²=x³+3. Points are kept in Jacobian
+// form and t=z² when valid. G₁ is the set of points of this curve on GF(p).
+type curvePoint struct {
+	x, y, z, t gfP
+}
+
+var curveB = newGFp(3)
+
+// curveGen is the generator of G₁.
+var curveGen = &curvePoint{
+	x: *newGFp(1),
+	y: *newGFp(2),
+	z: *newGFp(1),
+	t: *newGFp(1),
+}
+
+func (c *curvePoint) String() string {
+	c.MakeAffine()
+	x, y := &gfP{}, &gfP{}
+	montDecode(x, &c.x)
+	montDecode(y, &c.y)
+	return "(" + x.String() + ", " + y.String() + ")"
+}
+
+func (c *curvePoint) Set(a *curvePoint) {
+	c.x.Set(&a.x)
+	c.y.Set(&a.y)
+	c.z.Set(&a.z)
+	c.t.Set(&a.t)
+}
+
+// IsOnCurve returns true iff c is on the curve.
+func (c *curvePoint) IsOnCurve() bool {
+	c.MakeAffine()
+	if c.IsInfinity() {
+		return true
+	}
+
+	y2, x3 := &gfP{}, &gfP{}
+	gfpMul(y2, &c.y, &c.y)
+	gfpMul(x3, &c.x, &c.x)
+	gfpMul(x3, x3, &c.x)
+	gfpAdd(x3, x3, curveB)
+
+	return *y2 == *x3
+}
+
+func (c *curvePoint) SetInfinity() {
+	c.x = gfP{0}
+	c.y = *newGFp(1)
+	c.z = gfP{0}
+	c.t = gfP{0}
+}
+
+func (c *curvePoint) IsInfinity() bool {
+	return c.z == gfP{0}
+}
+
+func (c *curvePoint) Add(a, b *curvePoint) {
+	if a.IsInfinity() {
+		c.Set(b)
+		return
+	}
+	if b.IsInfinity() {
+		c.Set(a)
+		return
+	}
+
+	// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/addition/add-2007-bl.op3
+
+	// Normalize the points by replacing a = [x1:y1:z1] and b = [x2:y2:z2]
+	// by [u1:s1:z1·z2] and [u2:s2:z1·z2]
+	// where u1 = x1·z2², s1 = y1·z2³ and u1 = x2·z1², s2 = y2·z1³
+	z12, z22 := &gfP{}, &gfP{}
+	gfpMul(z12, &a.z, &a.z)
+	gfpMul(z22, &b.z, &b.z)
+
+	u1, u2 := &gfP{}, &gfP{}
+	gfpMul(u1, &a.x, z22)
+	gfpMul(u2, &b.x, z12)
+
+	t, s1 := &gfP{}, &gfP{}
+	gfpMul(t, &b.z, z22)
+	gfpMul(s1, &a.y, t)
+
+	s2 := &gfP{}
+	gfpMul(t, &a.z, z12)
+	gfpMul(s2, &b.y, t)
+
+	// Compute x = (2h)²(s²-u1-u2)
+	// where s = (s2-s1)/(u2-u1) is the slope of the line through
+	// (u1,s1) and (u2,s2). The extra factor 2h = 2(u2-u1) comes from the value of z below.
+	// This is also:
+	// 4(s2-s1)² - 4h²(u1+u2) = 4(s2-s1)² - 4h³ - 4h²(2u1)
+	//                        = r² - j - 2v
+	// with the notations below.
+	h := &gfP{}
+	gfpSub(h, u2, u1)
+	xEqual := *h == gfP{0}
+
+	gfpAdd(t, h, h)
+	// i = 4h²
+	i := &gfP{}
+	gfpMul(i, t, t)
+	// j = 4h³
+	j := &gfP{}
+	gfpMul(j, h, i)
+
+	gfpSub(t, s2, s1)
+	yEqual := *t == gfP{0}
+	if xEqual && yEqual {
+		c.Double(a)
+		return
+	}
+	r := &gfP{}
+	gfpAdd(r, t, t)
+
+	v := &gfP{}
+	gfpMul(v, u1, i)
+
+	// t4 = 4(s2-s1)²
+	t4, t6 := &gfP{}, &gfP{}
+	gfpMul(t4, r, r)
+	gfpAdd(t, v, v)
+	gfpSub(t6, t4, j)
+
+	gfpSub(&c.x, t6, t)
+
+	// Set y = -(2h)³(s1 + s*(x/4h²-u1))
+	// This is also
+	// y = - 2·s1·j - (s2-s1)(2x - 2i·u1) = r(v-x) - 2·s1·j
+	gfpSub(t, v, &c.x) // t7
+	gfpMul(t4, s1, j)  // t8
+	gfpAdd(t6, t4, t4) // t9
+	gfpMul(t4, r, t)   // t10
+	gfpSub(&c.y, t4, t6)
+
+	// Set z = 2(u2-u1)·z1·z2 = 2h·z1·z2
+	gfpAdd(t, &a.z, &b.z) // t11
+	gfpMul(t4, t, t)      // t12
+	gfpSub(t, t4, z12)    // t13
+	gfpSub(t4, t, z22)    // t14
+	gfpMul(&c.z, t4, h)
+}
+
+func (c *curvePoint) Double(a *curvePoint) {
+	// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/doubling/dbl-2009-l.op3
+	A, B, C := &gfP{}, &gfP{}, &gfP{}
+	gfpMul(A, &a.x, &a.x)
+	gfpMul(B, &a.y, &a.y)
+	gfpMul(C, B, B)
+
+	t, t2 := &gfP{}, &gfP{}
+	gfpAdd(t, &a.x, B)
+	gfpMul(t2, t, t)
+	gfpSub(t, t2, A)
+	gfpSub(t2, t, C)
+
+	d, e, f := &gfP{}, &gfP{}, &gfP{}
+	gfpAdd(d, t2, t2)
+	gfpAdd(t, A, A)
+	gfpAdd(e, t, A)
+	gfpMul(f, e, e)
+
+	gfpAdd(t, d, d)
+	gfpSub(&c.x, f, t)
+
+	gfpAdd(t, C, C)
+	gfpAdd(t2, t, t)
+	gfpAdd(t, t2, t2)
+	gfpSub(&c.y, d, &c.x)
+	gfpMul(t2, e, &c.y)
+	gfpSub(&c.y, t2, t)
+
+	gfpMul(t, &a.y, &a.z)
+	gfpAdd(&c.z, t, t)
+}
+
+func (c *curvePoint) Mul(a *curvePoint, scalar *big.Int) {
+	precomp := [1 << 2]*curvePoint{nil, {}, {}, {}}
+	precomp[1].Set(a)
+	precomp[2].Set(a)
+	gfpMul(&precomp[2].x, &precomp[2].x, xiTo2PSquaredMinus2Over3)
+	precomp[3].Add(precomp[1], precomp[2])
+
+	multiScalar := curveLattice.Multi(scalar)
+
+	sum := &curvePoint{}
+	sum.SetInfinity()
+	t := &curvePoint{}
+
+	for i := len(multiScalar) - 1; i >= 0; i-- {
+		t.Double(sum)
+		if multiScalar[i] == 0 {
+			sum.Set(t)
+		} else {
+			sum.Add(t, precomp[multiScalar[i]])
+		}
+	}
+	c.Set(sum)
+}
+
+func (c *curvePoint) MakeAffine() {
+	if c.z == *newGFp(1) {
+		return
+	} else if c.z == *newGFp(0) {
+		c.x = gfP{0}
+		c.y = *newGFp(1)
+		c.t = gfP{0}
+		return
+	}
+
+	zInv := &gfP{}
+	zInv.Invert(&c.z)
+
+	t, zInv2 := &gfP{}, &gfP{}
+	gfpMul(t, &c.y, zInv)
+	gfpMul(zInv2, zInv, zInv)
+
+	gfpMul(&c.x, &c.x, zInv2)
+	gfpMul(&c.y, t, zInv2)
+
+	c.z = *newGFp(1)
+	c.t = *newGFp(1)
+}
+
+func (c *curvePoint) Neg(a *curvePoint) {
+	c.x.Set(&a.x)
+	gfpNeg(&c.y, &a.y)
+	c.z.Set(&a.z)
+	c.t = gfP{0}
+}
diff --git a/crypto/bn256/cloudflare/example_test.go b/crypto/bn256/cloudflare/example_test.go
new file mode 100644
index 0000000000..6c285995cb
--- /dev/null
+++ b/crypto/bn256/cloudflare/example_test.go
@@ -0,0 +1,51 @@
+// Copyright 2012 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 bn256
+
+import (
+	"crypto/rand"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestExamplePair(t *testing.T) {
+	// This implements the tripartite Diffie-Hellman algorithm from "A One
+	// Round Protocol for Tripartite Diffie-Hellman", A. Joux.
+	// http://www.springerlink.com/content/cddc57yyva0hburb/fulltext.pdf
+
+	// Each of three parties, a, b and c, generate a private value.
+	a, _ := rand.Int(rand.Reader, Order)
+	b, _ := rand.Int(rand.Reader, Order)
+	c, _ := rand.Int(rand.Reader, Order)
+
+	// Then each party calculates g₁ and g₂ times their private value.
+	pa := new(G1).ScalarBaseMult(a)
+	qa := new(G2).ScalarBaseMult(a)
+
+	pb := new(G1).ScalarBaseMult(b)
+	qb := new(G2).ScalarBaseMult(b)
+
+	pc := new(G1).ScalarBaseMult(c)
+	qc := new(G2).ScalarBaseMult(c)
+
+	// Now each party exchanges its public values with the other two and
+	// all parties can calculate the shared key.
+	k1 := Pair(pb, qc)
+	k1.ScalarMult(k1, a)
+
+	k2 := Pair(pc, qa)
+	k2.ScalarMult(k2, b)
+
+	k3 := Pair(pa, qb)
+	k3.ScalarMult(k3, c)
+
+	// k1, k2 and k3 will all be equal.
+
+	require.Equal(t, k1, k2)
+	require.Equal(t, k1, k3)
+
+	require.Equal(t, len(np), 4) //Avoid gometalinter varcheck err on np
+}
diff --git a/crypto/bn256/cloudflare/gfp.go b/crypto/bn256/cloudflare/gfp.go
new file mode 100644
index 0000000000..e8e84e7b3b
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp.go
@@ -0,0 +1,81 @@
+package bn256
+
+import (
+	"errors"
+	"fmt"
+)
+
+type gfP [4]uint64
+
+func newGFp(x int64) (out *gfP) {
+	if x >= 0 {
+		out = &gfP{uint64(x)}
+	} else {
+		out = &gfP{uint64(-x)}
+		gfpNeg(out, out)
+	}
+
+	montEncode(out, out)
+	return out
+}
+
+func (e *gfP) String() string {
+	return fmt.Sprintf("%16.16x%16.16x%16.16x%16.16x", e[3], e[2], e[1], e[0])
+}
+
+func (e *gfP) Set(f *gfP) {
+	e[0] = f[0]
+	e[1] = f[1]
+	e[2] = f[2]
+	e[3] = f[3]
+}
+
+func (e *gfP) Invert(f *gfP) {
+	bits := [4]uint64{0x3c208c16d87cfd45, 0x97816a916871ca8d, 0xb85045b68181585d, 0x30644e72e131a029}
+
+	sum, power := &gfP{}, &gfP{}
+	sum.Set(rN1)
+	power.Set(f)
+
+	for word := 0; word < 4; word++ {
+		for bit := uint(0); bit < 64; bit++ {
+			if (bits[word]>>bit)&1 == 1 {
+				gfpMul(sum, sum, power)
+			}
+			gfpMul(power, power, power)
+		}
+	}
+
+	gfpMul(sum, sum, r3)
+	e.Set(sum)
+}
+
+func (e *gfP) Marshal(out []byte) {
+	for w := uint(0); w < 4; w++ {
+		for b := uint(0); b < 8; b++ {
+			out[8*w+b] = byte(e[3-w] >> (56 - 8*b))
+		}
+	}
+}
+
+func (e *gfP) Unmarshal(in []byte) error {
+	// Unmarshal the bytes into little endian form
+	for w := uint(0); w < 4; w++ {
+		for b := uint(0); b < 8; b++ {
+			e[3-w] += uint64(in[8*w+b]) << (56 - 8*b)
+		}
+	}
+	// Ensure the point respects the curve modulus
+	for i := 3; i >= 0; i-- {
+		if e[i] < p2[i] {
+			return nil
+		}
+		if e[i] > p2[i] {
+			return errors.New("bn256: coordinate exceeds modulus")
+		}
+	}
+	return errors.New("bn256: coordinate equals modulus")
+}
+
+func montEncode(c, a *gfP) { gfpMul(c, a, r2) }
+func montDecode(c, a *gfP) { gfpMul(c, a, &gfP{1}) }
diff --git a/crypto/bn256/cloudflare/gfp12.go b/crypto/bn256/cloudflare/gfp12.go
new file mode 100644
index 0000000000..93fb368a7b
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp12.go
@@ -0,0 +1,160 @@
+package bn256
+
+// For details of the algorithms used, see "Multiplication and Squaring on
+// Pairing-Friendly Fields, Devegili et al.
+// http://eprint.iacr.org/2006/471.pdf.
+
+import (
+	"math/big"
+)
+
+// gfP12 implements the field of size p¹² as a quadratic extension of gfP6
+// where ω²=τ.
+type gfP12 struct {
+	x, y gfP6 // value is xω + y
+}
+
+func (e *gfP12) String() string {
+	return "(" + e.x.String() + "," + e.y.String() + ")"
+}
+
+func (e *gfP12) Set(a *gfP12) *gfP12 {
+	e.x.Set(&a.x)
+	e.y.Set(&a.y)
+	return e
+}
+
+func (e *gfP12) SetZero() *gfP12 {
+	e.x.SetZero()
+	e.y.SetZero()
+	return e
+}
+
+func (e *gfP12) SetOne() *gfP12 {
+	e.x.SetZero()
+	e.y.SetOne()
+	return e
+}
+
+func (e *gfP12) IsZero() bool {
+	return e.x.IsZero() && e.y.IsZero()
+}
+
+func (e *gfP12) IsOne() bool {
+	return e.x.IsZero() && e.y.IsOne()
+}
+
+func (e *gfP12) Conjugate(a *gfP12) *gfP12 {
+	e.x.Neg(&a.x)
+	e.y.Set(&a.y)
+	return e
+}
+
+func (e *gfP12) Neg(a *gfP12) *gfP12 {
+	e.x.Neg(&a.x)
+	e.y.Neg(&a.y)
+	return e
+}
+
+// Frobenius computes (xω+y)^p = x^p ω·ξ^((p-1)/6) + y^p
+func (e *gfP12) Frobenius(a *gfP12) *gfP12 {
+	e.x.Frobenius(&a.x)
+	e.y.Frobenius(&a.y)
+	e.x.MulScalar(&e.x, xiToPMinus1Over6)
+	return e
+}
+
+// FrobeniusP2 computes (xω+y)^p² = x^p² ω·ξ^((p²-1)/6) + y^p²
+func (e *gfP12) FrobeniusP2(a *gfP12) *gfP12 {
+	e.x.FrobeniusP2(&a.x)
+	e.x.MulGFP(&e.x, xiToPSquaredMinus1Over6)
+	e.y.FrobeniusP2(&a.y)
+	return e
+}
+
+func (e *gfP12) FrobeniusP4(a *gfP12) *gfP12 {
+	e.x.FrobeniusP4(&a.x)
+	e.x.MulGFP(&e.x, xiToPSquaredMinus1Over3)
+	e.y.FrobeniusP4(&a.y)
+	return e
+}
+
+func (e *gfP12) Add(a, b *gfP12) *gfP12 {
+	e.x.Add(&a.x, &b.x)
+	e.y.Add(&a.y, &b.y)
+	return e
+}
+
+func (e *gfP12) Sub(a, b *gfP12) *gfP12 {
+	e.x.Sub(&a.x, &b.x)
+	e.y.Sub(&a.y, &b.y)
+	return e
+}
+
+func (e *gfP12) Mul(a, b *gfP12) *gfP12 {
+	tx := (&gfP6{}).Mul(&a.x, &b.y)
+	t := (&gfP6{}).Mul(&b.x, &a.y)
+	tx.Add(tx, t)
+
+	ty := (&gfP6{}).Mul(&a.y, &b.y)
+	t.Mul(&a.x, &b.x).MulTau(t)
+
+	e.x.Set(tx)
+	e.y.Add(ty, t)
+	return e
+}
+
+func (e *gfP12) MulScalar(a *gfP12, b *gfP6) *gfP12 {
+	e.x.Mul(&e.x, b)
+	e.y.Mul(&e.y, b)
+	return e
+}
+
+func (c *gfP12) Exp(a *gfP12, power *big.Int) *gfP12 {
+	sum := (&gfP12{}).SetOne()
+	t := &gfP12{}
+
+	for i := power.BitLen() - 1; i >= 0; i-- {
+		t.Square(sum)
+		if power.Bit(i) != 0 {
+			sum.Mul(t, a)
+		} else {
+			sum.Set(t)
+		}
+	}
+
+	c.Set(sum)
+	return c
+}
+
+func (e *gfP12) Square(a *gfP12) *gfP12 {
+	// Complex squaring algorithm
+	v0 := (&gfP6{}).Mul(&a.x, &a.y)
+
+	t := (&gfP6{}).MulTau(&a.x)
+	t.Add(&a.y, t)
+	ty := (&gfP6{}).Add(&a.x, &a.y)
+	ty.Mul(ty, t).Sub(ty, v0)
+	t.MulTau(v0)
+	ty.Sub(ty, t)
+
+	e.x.Add(v0, v0)
+	e.y.Set(ty)
+	return e
+}
+
+func (e *gfP12) Invert(a *gfP12) *gfP12 {
+	// See "Implementing cryptographic pairings", M. Scott, section 3.2.
+	// ftp://136.206.11.249/pub/crypto/pairings.pdf
+	t1, t2 := &gfP6{}, &gfP6{}
+
+	t1.Square(&a.x)
+	t2.Square(&a.y)
+	t1.MulTau(t1).Sub(t2, t1)
+	t2.Invert(t1)
+
+	e.x.Neg(&a.x)
+	e.y.Set(&a.y)
+	e.MulScalar(e, t2)
+	return e
+}
diff --git a/crypto/bn256/cloudflare/gfp2.go b/crypto/bn256/cloudflare/gfp2.go
new file mode 100644
index 0000000000..90a89e8b47
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp2.go
@@ -0,0 +1,156 @@
+package bn256
+
+// For details of the algorithms used, see "Multiplication and Squaring on
+// Pairing-Friendly Fields, Devegili et al.
+// http://eprint.iacr.org/2006/471.pdf.
+
+// gfP2 implements a field of size p² as a quadratic extension of the base field
+// where i²=-1.
+type gfP2 struct {
+	x, y gfP // value is xi+y.
+}
+
+func gfP2Decode(in *gfP2) *gfP2 {
+	out := &gfP2{}
+	montDecode(&out.x, &in.x)
+	montDecode(&out.y, &in.y)
+	return out
+}
+
+func (e *gfP2) String() string {
+	return "(" + e.x.String() + ", " + e.y.String() + ")"
+}
+
+func (e *gfP2) Set(a *gfP2) *gfP2 {
+	e.x.Set(&a.x)
+	e.y.Set(&a.y)
+	return e
+}
+
+func (e *gfP2) SetZero() *gfP2 {
+	e.x = gfP{0}
+	e.y = gfP{0}
+	return e
+}
+
+func (e *gfP2) SetOne() *gfP2 {
+	e.x = gfP{0}
+	e.y = *newGFp(1)
+	return e
+}
+
+func (e *gfP2) IsZero() bool {
+	zero := gfP{0}
+	return e.x == zero && e.y == zero
+}
+
+func (e *gfP2) IsOne() bool {
+	zero, one := gfP{0}, *newGFp(1)
+	return e.x == zero && e.y == one
+}
+
+func (e *gfP2) Conjugate(a *gfP2) *gfP2 {
+	e.y.Set(&a.y)
+	gfpNeg(&e.x, &a.x)
+	return e
+}
+
+func (e *gfP2) Neg(a *gfP2) *gfP2 {
+	gfpNeg(&e.x, &a.x)
+	gfpNeg(&e.y, &a.y)
+	return e
+}
+
+func (e *gfP2) Add(a, b *gfP2) *gfP2 {
+	gfpAdd(&e.x, &a.x, &b.x)
+	gfpAdd(&e.y, &a.y, &b.y)
+	return e
+}
+
+func (e *gfP2) Sub(a, b *gfP2) *gfP2 {
+	gfpSub(&e.x, &a.x, &b.x)
+	gfpSub(&e.y, &a.y, &b.y)
+	return e
+}
+
+// See "Multiplication and Squaring in Pairing-Friendly Fields",
+// http://eprint.iacr.org/2006/471.pdf
+func (e *gfP2) Mul(a, b *gfP2) *gfP2 {
+	tx, t := &gfP{}, &gfP{}
+	gfpMul(tx, &a.x, &b.y)
+	gfpMul(t, &b.x, &a.y)
+	gfpAdd(tx, tx, t)
+
+	ty := &gfP{}
+	gfpMul(ty, &a.y, &b.y)
+	gfpMul(t, &a.x, &b.x)
+	gfpSub(ty, ty, t)
+
+	e.x.Set(tx)
+	e.y.Set(ty)
+	return e
+}
+
+func (e *gfP2) MulScalar(a *gfP2, b *gfP) *gfP2 {
+	gfpMul(&e.x, &a.x, b)
+	gfpMul(&e.y, &a.y, b)
+	return e
+}
+
+// MulXi sets e=ξa where ξ=i+9 and then returns e.
+func (e *gfP2) MulXi(a *gfP2) *gfP2 {
+	// (xi+y)(i+9) = (9x+y)i+(9y-x)
+	tx := &gfP{}
+	gfpAdd(tx, &a.x, &a.x)
+	gfpAdd(tx, tx, tx)
+	gfpAdd(tx, tx, tx)
+	gfpAdd(tx, tx, &a.x)
+
+	gfpAdd(tx, tx, &a.y)
+
+	ty := &gfP{}
+	gfpAdd(ty, &a.y, &a.y)
+	gfpAdd(ty, ty, ty)
+	gfpAdd(ty, ty, ty)
+	gfpAdd(ty, ty, &a.y)
+
+	gfpSub(ty, ty, &a.x)
+
+	e.x.Set(tx)
+	e.y.Set(ty)
+	return e
+}
+
+func (e *gfP2) Square(a *gfP2) *gfP2 {
+	// Complex squaring algorithm:
+	// (xi+y)² = (x+y)(y-x) + 2*i*x*y
+	tx, ty := &gfP{}, &gfP{}
+	gfpSub(tx, &a.y, &a.x)
+	gfpAdd(ty, &a.x, &a.y)
+	gfpMul(ty, tx, ty)
+
+	gfpMul(tx, &a.x, &a.y)
+	gfpAdd(tx, tx, tx)
+
+	e.x.Set(tx)
+	e.y.Set(ty)
+	return e
+}
+
+func (e *gfP2) Invert(a *gfP2) *gfP2 {
+	// See "Implementing cryptographic pairings", M. Scott, section 3.2.
+	// ftp://136.206.11.249/pub/crypto/pairings.pdf
+	t1, t2 := &gfP{}, &gfP{}
+	gfpMul(t1, &a.x, &a.x)
+	gfpMul(t2, &a.y, &a.y)
+	gfpAdd(t1, t1, t2)
+
+	inv := &gfP{}
+	inv.Invert(t1)
+
+	gfpNeg(t1, &a.x)
+
+	gfpMul(&e.x, t1, inv)
+	gfpMul(&e.y, &a.y, inv)
+	return e
+}
diff --git a/crypto/bn256/cloudflare/gfp6.go b/crypto/bn256/cloudflare/gfp6.go
new file mode 100644
index 0000000000..83d61b781f
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp6.go
@@ -0,0 +1,213 @@
+package bn256
+
+// For details of the algorithms used, see "Multiplication and Squaring on
+// Pairing-Friendly Fields, Devegili et al.
+// http://eprint.iacr.org/2006/471.pdf.
+
+// gfP6 implements the field of size p⁶ as a cubic extension of gfP2 where τ³=ξ
+// and ξ=i+3.
+type gfP6 struct {
+	x, y, z gfP2 // value is xτ² + yτ + z
+}
+
+func (e *gfP6) String() string {
+	return "(" + e.x.String() + ", " + e.y.String() + ", " + e.z.String() + ")"
+}
+
+func (e *gfP6) Set(a *gfP6) *gfP6 {
+	e.x.Set(&a.x)
+	e.y.Set(&a.y)
+	e.z.Set(&a.z)
+	return e
+}
+
+func (e *gfP6) SetZero() *gfP6 {
+	e.x.SetZero()
+	e.y.SetZero()
+	e.z.SetZero()
+	return e
+}
+
+func (e *gfP6) SetOne() *gfP6 {
+	e.x.SetZero()
+	e.y.SetZero()
+	e.z.SetOne()
+	return e
+}
+
+func (e *gfP6) IsZero() bool {
+	return e.x.IsZero() && e.y.IsZero() && e.z.IsZero()
+}
+
+func (e *gfP6) IsOne() bool {
+	return e.x.IsZero() && e.y.IsZero() && e.z.IsOne()
+}
+
+func (e *gfP6) Neg(a *gfP6) *gfP6 {
+	e.x.Neg(&a.x)
+	e.y.Neg(&a.y)
+	e.z.Neg(&a.z)
+	return e
+}
+
+func (e *gfP6) Frobenius(a *gfP6) *gfP6 {
+	e.x.Conjugate(&a.x)
+	e.y.Conjugate(&a.y)
+	e.z.Conjugate(&a.z)
+
+	e.x.Mul(&e.x, xiTo2PMinus2Over3)
+	e.y.Mul(&e.y, xiToPMinus1Over3)
+	return e
+}
+
+// FrobeniusP2 computes (xτ²+yτ+z)^(p²) = xτ^(2p²) + yτ^(p²) + z
+func (e *gfP6) FrobeniusP2(a *gfP6) *gfP6 {
+	// τ^(2p²) = τ²τ^(2p²-2) = τ²ξ^((2p²-2)/3)
+	e.x.MulScalar(&a.x, xiTo2PSquaredMinus2Over3)
+	// τ^(p²) = ττ^(p²-1) = τξ^((p²-1)/3)
+	e.y.MulScalar(&a.y, xiToPSquaredMinus1Over3)
+	e.z.Set(&a.z)
+	return e
+}
+
+func (e *gfP6) FrobeniusP4(a *gfP6) *gfP6 {
+	e.x.MulScalar(&a.x, xiToPSquaredMinus1Over3)
+	e.y.MulScalar(&a.y, xiTo2PSquaredMinus2Over3)
+	e.z.Set(&a.z)
+	return e
+}
+
+func (e *gfP6) Add(a, b *gfP6) *gfP6 {
+	e.x.Add(&a.x, &b.x)
+	e.y.Add(&a.y, &b.y)
+	e.z.Add(&a.z, &b.z)
+	return e
+}
+
+func (e *gfP6) Sub(a, b *gfP6) *gfP6 {
+	e.x.Sub(&a.x, &b.x)
+	e.y.Sub(&a.y, &b.y)
+	e.z.Sub(&a.z, &b.z)
+	return e
+}
+
+func (e *gfP6) Mul(a, b *gfP6) *gfP6 {
+	// "Multiplication and Squaring on Pairing-Friendly Fields"
+	// Section 4, Karatsuba method.
+	// http://eprint.iacr.org/2006/471.pdf
+	v0 := (&gfP2{}).Mul(&a.z, &b.z)
+	v1 := (&gfP2{}).Mul(&a.y, &b.y)
+	v2 := (&gfP2{}).Mul(&a.x, &b.x)
+
+	t0 := (&gfP2{}).Add(&a.x, &a.y)
+	t1 := (&gfP2{}).Add(&b.x, &b.y)
+	tz := (&gfP2{}).Mul(t0, t1)
+	tz.Sub(tz, v1).Sub(tz, v2).MulXi(tz).Add(tz, v0)
+
+	t0.Add(&a.y, &a.z)
+	t1.Add(&b.y, &b.z)
+	ty := (&gfP2{}).Mul(t0, t1)
+	t0.MulXi(v2)
+	ty.Sub(ty, v0).Sub(ty, v1).Add(ty, t0)
+
+	t0.Add(&a.x, &a.z)
+	t1.Add(&b.x, &b.z)
+	tx := (&gfP2{}).Mul(t0, t1)
+	tx.Sub(tx, v0).Add(tx, v1).Sub(tx, v2)
+
+	e.x.Set(tx)
+	e.y.Set(ty)
+	e.z.Set(tz)
+	return e
+}
+
+func (e *gfP6) MulScalar(a *gfP6, b *gfP2) *gfP6 {
+	e.x.Mul(&a.x, b)
+	e.y.Mul(&a.y, b)
+	e.z.Mul(&a.z, b)
+	return e
+}
+
+func (e *gfP6) MulGFP(a *gfP6, b *gfP) *gfP6 {
+	e.x.MulScalar(&a.x, b)
+	e.y.MulScalar(&a.y, b)
+	e.z.MulScalar(&a.z, b)
+	return e
+}
+
+// MulTau computes τ·(aτ²+bτ+c) = bτ²+cτ+aξ
+func (e *gfP6) MulTau(a *gfP6) *gfP6 {
+	tz := (&gfP2{}).MulXi(&a.x)
+	ty := (&gfP2{}).Set(&a.y)
+
+	e.y.Set(&a.z)
+	e.x.Set(ty)
+	e.z.Set(tz)
+	return e
+}
+
+func (e *gfP6) Square(a *gfP6) *gfP6 {
+	v0 := (&gfP2{}).Square(&a.z)
+	v1 := (&gfP2{}).Square(&a.y)
+	v2 := (&gfP2{}).Square(&a.x)
+
+	c0 := (&gfP2{}).Add(&a.x, &a.y)
+	c0.Square(c0).Sub(c0, v1).Sub(c0, v2).MulXi(c0).Add(c0, v0)
+
+	c1 := (&gfP2{}).Add(&a.y, &a.z)
+	c1.Square(c1).Sub(c1, v0).Sub(c1, v1)
+	xiV2 := (&gfP2{}).MulXi(v2)
+	c1.Add(c1, xiV2)
+
+	c2 := (&gfP2{}).Add(&a.x, &a.z)
+	c2.Square(c2).Sub(c2, v0).Add(c2, v1).Sub(c2, v2)
+
+	e.x.Set(c2)
+	e.y.Set(c1)
+	e.z.Set(c0)
+	return e
+}
+
+func (e *gfP6) Invert(a *gfP6) *gfP6 {
+	// See "Implementing cryptographic pairings", M. Scott, section 3.2.
+	// ftp://136.206.11.249/pub/crypto/pairings.pdf
+
+	// Here we can give a short explanation of how it works: let j be a cubic root of
+	// unity in GF(p²) so that 1+j+j²=0.
+	// Then (xτ² + yτ + z)(xj²τ² + yjτ + z)(xjτ² + yj²τ + z)
+	// = (xτ² + yτ + z)(Cτ²+Bτ+A)
+	// = (x³ξ²+y³ξ+z³-3ξxyz) = F is an element of the base field (the norm).
+	//
+	// On the other hand (xj²τ² + yjτ + z)(xjτ² + yj²τ + z)
+	// = τ²(y²-ξxz) + τ(ξx²-yz) + (z²-ξxy)
+	//
+	// So that's why A = (z²-ξxy), B = (ξx²-yz), C = (y²-ξxz)
+	t1 := (&gfP2{}).Mul(&a.x, &a.y)
+	t1.MulXi(t1)
+
+	A := (&gfP2{}).Square(&a.z)
+	A.Sub(A, t1)
+
+	B := (&gfP2{}).Square(&a.x)
+	B.MulXi(B)
+	t1.Mul(&a.y, &a.z)
+	B.Sub(B, t1)
+
+	C := (&gfP2{}).Square(&a.y)
+	t1.Mul(&a.x, &a.z)
+	C.Sub(C, t1)
+
+	F := (&gfP2{}).Mul(C, &a.y)
+	F.MulXi(F)
+	t1.Mul(A, &a.z)
+	F.Add(F, t1)
+	t1.Mul(B, &a.x).MulXi(t1)
+	F.Add(F, t1)
+
+	F.Invert(F)
+
+	e.x.Mul(C, F)
+	e.y.Mul(B, F)
+	e.z.Mul(A, F)
+	return e
+}
diff --git a/crypto/bn256/cloudflare/gfp_amd64.s b/crypto/bn256/cloudflare/gfp_amd64.s
new file mode 100644
index 0000000000..3a785d200b
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp_amd64.s
@@ -0,0 +1,129 @@
+// +build amd64,!generic
+
+#define storeBlock(a0,a1,a2,a3, r) \
+	MOVQ a0,  0+r \
+	MOVQ a1,  8+r \
+	MOVQ a2, 16+r \
+	MOVQ a3, 24+r
+
+#define loadBlock(r, a0,a1,a2,a3) \
+	MOVQ  0+r, a0 \
+	MOVQ  8+r, a1 \
+	MOVQ 16+r, a2 \
+	MOVQ 24+r, a3
+
+#define gfpCarry(a0,a1,a2,a3,a4, b0,b1,b2,b3,b4) \
+	\ // b = a-p
+	MOVQ a0, b0 \
+	MOVQ a1, b1 \
+	MOVQ a2, b2 \
+	MOVQ a3, b3 \
+	MOVQ a4, b4 \
+	\
+	SUBQ ·p2+0(SB), b0 \
+	SBBQ ·p2+8(SB), b1 \
+	SBBQ ·p2+16(SB), b2 \
+	SBBQ ·p2+24(SB), b3 \
+	SBBQ $0, b4 \
+	\
+	\ // if b is negative then return a
+	\ // else return b
+	CMOVQCC b0, a0 \
+	CMOVQCC b1, a1 \
+	CMOVQCC b2, a2 \
+	CMOVQCC b3, a3
+
+#include "mul_amd64.h"
+#include "mul_bmi2_amd64.h"
+
+TEXT ·gfpNeg(SB),0,$0-16
+	MOVQ ·p2+0(SB), R8
+	MOVQ ·p2+8(SB), R9
+	MOVQ ·p2+16(SB), R10
+	MOVQ ·p2+24(SB), R11
+
+	MOVQ a+8(FP), DI
+	SUBQ 0(DI), R8
+	SBBQ 8(DI), R9
+	SBBQ 16(DI), R10
+	SBBQ 24(DI), R11
+
+	MOVQ $0, AX
+	gfpCarry(R8,R9,R10,R11,AX, R12,R13,R14,R15,BX)
+
+	MOVQ c+0(FP), DI
+	storeBlock(R8,R9,R10,R11, 0(DI))
+	RET
+
+TEXT ·gfpAdd(SB),0,$0-24
+	MOVQ a+8(FP), DI
+	MOVQ b+16(FP), SI
+
+	loadBlock(0(DI), R8,R9,R10,R11)
+	MOVQ $0, R12
+
+	ADDQ  0(SI), R8
+	ADCQ  8(SI), R9
+	ADCQ 16(SI), R10
+	ADCQ 24(SI), R11
+	ADCQ $0, R12
+
+	gfpCarry(R8,R9,R10,R11,R12, R13,R14,R15,AX,BX)
+
+	MOVQ c+0(FP), DI
+	storeBlock(R8,R9,R10,R11, 0(DI))
+	RET
+
+TEXT ·gfpSub(SB),0,$0-24
+	MOVQ a+8(FP), DI
+	MOVQ b+16(FP), SI
+
+	loadBlock(0(DI), R8,R9,R10,R11)
+
+	MOVQ ·p2+0(SB), R12
+	MOVQ ·p2+8(SB), R13
+	MOVQ ·p2+16(SB), R14
+	MOVQ ·p2+24(SB), R15
+	MOVQ $0, AX
+
+	SUBQ  0(SI), R8
+	SBBQ  8(SI), R9
+	SBBQ 16(SI), R10
+	SBBQ 24(SI), R11
+
+	CMOVQCC AX, R12
+	CMOVQCC AX, R13
+	CMOVQCC AX, R14
+	CMOVQCC AX, R15
+
+	ADDQ R12, R8
+	ADCQ R13, R9
+	ADCQ R14, R10
+	ADCQ R15, R11
+
+	MOVQ c+0(FP), DI
+	storeBlock(R8,R9,R10,R11, 0(DI))
+	RET
+
+TEXT ·gfpMul(SB),0,$160-24
+	MOVQ a+8(FP), DI
+	MOVQ b+16(FP), SI
+
+	// Jump to a slightly different implementation if MULX isn't supported.
+	CMPB runtime·support_bmi2(SB), $0
+	JE   nobmi2Mul
+
+	mulBMI2(0(DI),8(DI),16(DI),24(DI), 0(SI))
+	storeBlock( R8, R9,R10,R11,  0(SP))
+	storeBlock(R12,R13,R14,R15, 32(SP))
+	gfpReduceBMI2()
+	JMP end
+
+nobmi2Mul:
+	mul(0(DI),8(DI),16(DI),24(DI), 0(SI), 0(SP))
+	gfpReduce(0(SP))
+
+end:
+	MOVQ c+0(FP), DI
+	storeBlock(R12,R13,R14,R15, 0(DI))
+	RET
diff --git a/crypto/bn256/cloudflare/gfp_arm64.s b/crypto/bn256/cloudflare/gfp_arm64.s
new file mode 100644
index 0000000000..c65e80168c
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp_arm64.s
@@ -0,0 +1,113 @@
+// +build arm64,!generic
+
+#define storeBlock(a0,a1,a2,a3, r) \
+	MOVD a0,  0+r \
+	MOVD a1,  8+r \
+	MOVD a2, 16+r \
+	MOVD a3, 24+r
+
+#define loadBlock(r, a0,a1,a2,a3) \
+	MOVD  0+r, a0 \
+	MOVD  8+r, a1 \
+	MOVD 16+r, a2 \
+	MOVD 24+r, a3
+
+#define loadModulus(p0,p1,p2,p3) \
+	MOVD ·p2+0(SB), p0 \
+	MOVD ·p2+8(SB), p1 \
+	MOVD ·p2+16(SB), p2 \
+	MOVD ·p2+24(SB), p3
+
+#include "mul_arm64.h"
+
+TEXT ·gfpNeg(SB),0,$0-16
+	MOVD a+8(FP), R0
+	loadBlock(0(R0), R1,R2,R3,R4)
+	loadModulus(R5,R6,R7,R8)
+
+	SUBS R1, R5, R1
+	SBCS R2, R6, R2
+	SBCS R3, R7, R3
+	SBCS R4, R8, R4
+
+	SUBS R5, R1, R5
+	SBCS R6, R2, R6
+	SBCS R7, R3, R7
+	SBCS R8, R4, R8
+
+	CSEL CS, R5, R1, R1
+	CSEL CS, R6, R2, R2
+	CSEL CS, R7, R3, R3
+	CSEL CS, R8, R4, R4
+
+	MOVD c+0(FP), R0
+	storeBlock(R1,R2,R3,R4, 0(R0))
+	RET
+
+TEXT ·gfpAdd(SB),0,$0-24
+	MOVD a+8(FP), R0
+	loadBlock(0(R0), R1,R2,R3,R4)
+	MOVD b+16(FP), R0
+	loadBlock(0(R0), R5,R6,R7,R8)
+	loadModulus(R9,R10,R11,R12)
+	MOVD ZR, R0
+
+	ADDS R5, R1
+	ADCS R6, R2
+	ADCS R7, R3
+	ADCS R8, R4
+	ADCS ZR, R0
+
+	SUBS  R9, R1, R5
+	SBCS R10, R2, R6
+	SBCS R11, R3, R7
+	SBCS R12, R4, R8
+	SBCS  ZR, R0, R0
+
+	CSEL CS, R5, R1, R1
+	CSEL CS, R6, R2, R2
+	CSEL CS, R7, R3, R3
+	CSEL CS, R8, R4, R4
+
+	MOVD c+0(FP), R0
+	storeBlock(R1,R2,R3,R4, 0(R0))
+	RET
+
+TEXT ·gfpSub(SB),0,$0-24
+	MOVD a+8(FP), R0
+	loadBlock(0(R0), R1,R2,R3,R4)
+	MOVD b+16(FP), R0
+	loadBlock(0(R0), R5,R6,R7,R8)
+	loadModulus(R9,R10,R11,R12)
+
+	SUBS R5, R1
+	SBCS R6, R2
+	SBCS R7, R3
+	SBCS R8, R4
+
+	CSEL CS, ZR,  R9,  R9
+	CSEL CS, ZR, R10, R10
+	CSEL CS, ZR, R11, R11
+	CSEL CS, ZR, R12, R12
+
+	ADDS  R9, R1
+	ADCS R10, R2
+	ADCS R11, R3
+	ADCS R12, R4
+
+	MOVD c+0(FP), R0
+	storeBlock(R1,R2,R3,R4, 0(R0))
+	RET
+
+TEXT ·gfpMul(SB),0,$0-24
+	MOVD a+8(FP), R0
+	loadBlock(0(R0), R1,R2,R3,R4)
+	MOVD b+16(FP), R0
+	loadBlock(0(R0), R5,R6,R7,R8)
+
+	mul(R9,R10,R11,R12,R13,R14,R15,R16)
+	gfpReduce()
+
+	MOVD c+0(FP), R0
+	storeBlock(R1,R2,R3,R4, 0(R0))
+	RET
diff --git a/crypto/bn256/cloudflare/gfp_decl.go b/crypto/bn256/cloudflare/gfp_decl.go
new file mode 100644
index 0000000000..6a8a4fddb6
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp_decl.go
@@ -0,0 +1,18 @@
+// +build amd64,!generic arm64,!generic
+
+package bn256
+
+// This file contains forward declarations for the architecture-specific
+// assembly implementations of these functions, provided that they exist.
+
+// go:noescape
+func gfpNeg(c, a *gfP)
+
+//go:noescape
+func gfpAdd(c, a, b *gfP)
+
+//go:noescape
+func gfpSub(c, a, b *gfP)
+
+//go:noescape
+func gfpMul(c, a, b *gfP)
diff --git a/crypto/bn256/cloudflare/gfp_generic.go b/crypto/bn256/cloudflare/gfp_generic.go
new file mode 100644
index 0000000000..8e6be95961
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp_generic.go
@@ -0,0 +1,173 @@
+// +build !amd64,!arm64 generic
+
+package bn256
+
+func gfpCarry(a *gfP, head uint64) {
+	b := &gfP{}
+
+	var carry uint64
+	for i, pi := range p2 {
+		ai := a[i]
+		bi := ai - pi - carry
+		b[i] = bi
+		carry = (pi&^ai | (pi|^ai)&bi) >> 63
+	}
+	carry = carry &^ head
+
+	// If b is negative, then return a.
+	// Else return b.
+	carry = -carry
+	ncarry := ^carry
+	for i := 0; i < 4; i++ {
+		a[i] = (a[i] & carry) | (b[i] & ncarry)
+	}
+}
+
+func gfpNeg(c, a *gfP) {
+	var carry uint64
+	for i, pi := range p2 {
+		ai := a[i]
+		ci := pi - ai - carry
+		c[i] = ci
+		carry = (ai&^pi | (ai|^pi)&ci) >> 63
+	}
+	gfpCarry(c, 0)
+}
+
+func gfpAdd(c, a, b *gfP) {
+	var carry uint64
+	for i, ai := range a {
+		bi := b[i]
+		ci := ai + bi + carry
+		c[i] = ci
+		carry = (ai&bi | (ai|bi)&^ci) >> 63
+	}
+	gfpCarry(c, carry)
+}
+
+func gfpSub(c, a, b *gfP) {
+	t := &gfP{}
+
+	var carry uint64
+	for i, pi := range p2 {
+		bi := b[i]
+		ti := pi - bi - carry
+		t[i] = ti
+		carry = (bi&^pi | (bi|^pi)&ti) >> 63
+	}
+
+	carry = 0
+	for i, ai := range a {
+		ti := t[i]
+		ci := ai + ti + carry
+		c[i] = ci
+		carry = (ai&ti | (ai|ti)&^ci) >> 63
+	}
+	gfpCarry(c, carry)
+}
+
+func mul(a, b [4]uint64) [8]uint64 {
+	const (
+		mask16 uint64 = 0x0000ffff
+		mask32 uint64 = 0xffffffff
+	)
+
+	var buff [32]uint64
+	for i, ai := range a {
+		a0, a1, a2, a3 := ai&mask16, (ai>>16)&mask16, (ai>>32)&mask16, ai>>48
+
+		for j, bj := range b {
+			b0, b2 := bj&mask32, bj>>32
+
+			off := 4 * (i + j)
+			buff[off+0] += a0 * b0
+			buff[off+1] += a1 * b0
+			buff[off+2] += a2*b0 + a0*b2
+			buff[off+3] += a3*b0 + a1*b2
+			buff[off+4] += a2 * b2
+			buff[off+5] += a3 * b2
+		}
+	}
+
+	for i := uint(1); i < 4; i++ {
+		shift := 16 * i
+
+		var head, carry uint64
+		for j := uint(0); j < 8; j++ {
+			block := 4 * j
+
+			xi := buff[block]
+			yi := (buff[block+i] << shift) + head
+			zi := xi + yi + carry
+			buff[block] = zi
+			carry = (xi&yi | (xi|yi)&^zi) >> 63
+
+			head = buff[block+i] >> (64 - shift)
+		}
+	}
+
+	return [8]uint64{buff[0], buff[4], buff[8], buff[12], buff[16], buff[20], buff[24], buff[28]}
+}
+
+func halfMul(a, b [4]uint64) [4]uint64 {
+	const (
+		mask16 uint64 = 0x0000ffff
+		mask32 uint64 = 0xffffffff
+	)
+
+	var buff [18]uint64
+	for i, ai := range a {
+		a0, a1, a2, a3 := ai&mask16, (ai>>16)&mask16, (ai>>32)&mask16, ai>>48
+
+		for j, bj := range b {
+			if i+j > 3 {
+				break
+			}
+			b0, b2 := bj&mask32, bj>>32
+
+			off := 4 * (i + j)
+			buff[off+0] += a0 * b0
+			buff[off+1] += a1 * b0
+			buff[off+2] += a2*b0 + a0*b2
+			buff[off+3] += a3*b0 + a1*b2
+			buff[off+4] += a2 * b2
+			buff[off+5] += a3 * b2
+		}
+	}
+
+	for i := uint(1); i < 4; i++ {
+		shift := 16 * i
+
+		var head, carry uint64
+		for j := uint(0); j < 4; j++ {
+			block := 4 * j
+
+			xi := buff[block]
+			yi := (buff[block+i] << shift) + head
+			zi := xi + yi + carry
+			buff[block] = zi
+			carry = (xi&yi | (xi|yi)&^zi) >> 63
+
+			head = buff[block+i] >> (64 - shift)
+		}
+	}
+
+	return [4]uint64{buff[0], buff[4], buff[8], buff[12]}
+}
+
+func gfpMul(c, a, b *gfP) {
+	T := mul(*a, *b)
+	m := halfMul([4]uint64{T[0], T[1], T[2], T[3]}, np)
+	t := mul([4]uint64{m[0], m[1], m[2], m[3]}, p2)
+
+	var carry uint64
+	for i, Ti := range T {
+		ti := t[i]
+		zi := Ti + ti + carry
+		T[i] = zi
+		carry = (Ti&ti | (Ti|ti)&^zi) >> 63
+	}
+
+	*c = gfP{T[4], T[5], T[6], T[7]}
+	gfpCarry(c, carry)
+}
diff --git a/crypto/bn256/cloudflare/gfp_test.go b/crypto/bn256/cloudflare/gfp_test.go
new file mode 100644
index 0000000000..16ab2a8410
--- /dev/null
+++ b/crypto/bn256/cloudflare/gfp_test.go
@@ -0,0 +1,60 @@
+package bn256
+
+import (
+	"testing"
+)
+
+// Tests that negation works the same way on both assembly-optimized and pure Go
+// implementation.
+func TestGFpNeg(t *testing.T) {
+	n := &gfP{0x0123456789abcdef, 0xfedcba9876543210, 0xdeadbeefdeadbeef, 0xfeebdaedfeebdaed}
+	w := &gfP{0xfedcba9876543211, 0x0123456789abcdef, 0x2152411021524110, 0x0114251201142512}
+	h := &gfP{}
+
+	gfpNeg(h, n)
+	if *h != *w {
+		t.Errorf("negation mismatch: have %#x, want %#x", *h, *w)
+	}
+}
+
+// Tests that addition works the same way on both assembly-optimized and pure Go
+// implementation.
+func TestGFpAdd(t *testing.T) {
+	a := &gfP{0x0123456789abcdef, 0xfedcba9876543210, 0xdeadbeefdeadbeef, 0xfeebdaedfeebdaed}
+	b := &gfP{0xfedcba9876543210, 0x0123456789abcdef, 0xfeebdaedfeebdaed, 0xdeadbeefdeadbeef}
+	w := &gfP{0xc3df73e9278302b8, 0x687e956e978e3572, 0x254954275c18417f, 0xad354b6afc67f9b4}
+	h := &gfP{}
+
+	gfpAdd(h, a, b)
+	if *h != *w {
+		t.Errorf("addition mismatch: have %#x, want %#x", *h, *w)
+	}
+}
+
+// Tests that subtraction works the same way on both assembly-optimized and pure Go
+// implementation.
+func TestGFpSub(t *testing.T) {
+	a := &gfP{0x0123456789abcdef, 0xfedcba9876543210, 0xdeadbeefdeadbeef, 0xfeebdaedfeebdaed}
+	b := &gfP{0xfedcba9876543210, 0x0123456789abcdef, 0xfeebdaedfeebdaed, 0xdeadbeefdeadbeef}
+	w := &gfP{0x02468acf13579bdf, 0xfdb97530eca86420, 0xdfc1e401dfc1e402, 0x203e1bfe203e1bfd}
+	h := &gfP{}
+
+	gfpSub(h, a, b)
+	if *h != *w {
+		t.Errorf("subtraction mismatch: have %#x, want %#x", *h, *w)
+	}
+}
+
+// Tests that multiplication works the same way on both assembly-optimized and pure Go
+// implementation.
+func TestGFpMul(t *testing.T) {
+	a := &gfP{0x0123456789abcdef, 0xfedcba9876543210, 0xdeadbeefdeadbeef, 0xfeebdaedfeebdaed}
+	b := &gfP{0xfedcba9876543210, 0x0123456789abcdef, 0xfeebdaedfeebdaed, 0xdeadbeefdeadbeef}
+	w := &gfP{0xcbcbd377f7ad22d3, 0x3b89ba5d849379bf, 0x87b61627bd38b6d2, 0xc44052a2a0e654b2}
+	h := &gfP{}
+
+	gfpMul(h, a, b)
+	if *h != *w {
+		t.Errorf("multiplication mismatch: have %#x, want %#x", *h, *w)
+	}
+}
diff --git a/crypto/bn256/cloudflare/lattice.go b/crypto/bn256/cloudflare/lattice.go
new file mode 100644
index 0000000000..f9ace4d9fc
--- /dev/null
+++ b/crypto/bn256/cloudflare/lattice.go
@@ -0,0 +1,115 @@
+package bn256
+
+import (
+	"math/big"
+)
+
+var half = new(big.Int).Rsh(Order, 1)
+
+var curveLattice = &lattice{
+	vectors: [][]*big.Int{
+		{bigFromBase10("147946756881789319000765030803803410728"), bigFromBase10("147946756881789319010696353538189108491")},
+		{bigFromBase10("147946756881789319020627676272574806254"), bigFromBase10("-147946756881789318990833708069417712965")},
+	},
+	inverse: []*big.Int{
+		bigFromBase10("147946756881789318990833708069417712965"),
+		bigFromBase10("147946756881789319010696353538189108491"),
+	},
+	det: bigFromBase10("43776485743678550444492811490514550177096728800832068687396408373151616991234"),
+}
+
+var targetLattice = &lattice{
+	vectors: [][]*big.Int{
+		{bigFromBase10("9931322734385697761"), bigFromBase10("9931322734385697761"), bigFromBase10("9931322734385697763"), bigFromBase10("9931322734385697764")},
+		{bigFromBase10("4965661367192848881"), bigFromBase10("4965661367192848881"), bigFromBase10("4965661367192848882"), bigFromBase10("-9931322734385697762")},
+		{bigFromBase10("-9931322734385697762"), bigFromBase10("-4965661367192848881"), bigFromBase10("4965661367192848881"), bigFromBase10("-4965661367192848882")},
+		{bigFromBase10("9931322734385697763"), bigFromBase10("-4965661367192848881"), bigFromBase10("-4965661367192848881"), bigFromBase10("-4965661367192848881")},
+	},
+	inverse: []*big.Int{
+		bigFromBase10("734653495049373973658254490726798021314063399421879442165"),
+		bigFromBase10("147946756881789319000765030803803410728"),
+		bigFromBase10("-147946756881789319005730692170996259609"),
+		bigFromBase10("1469306990098747947464455738335385361643788813749140841702"),
+	},
+	det: new(big.Int).Set(Order),
+}
+
+type lattice struct {
+	vectors [][]*big.Int
+	inverse []*big.Int
+	det     *big.Int
+}
+
+// decompose takes a scalar mod Order as input and finds a short, positive decomposition of it wrt to the lattice basis.
+func (l *lattice) decompose(k *big.Int) []*big.Int {
+	n := len(l.inverse)
+
+	// Calculate closest vector in lattice to  with Babai's rounding.
+	c := make([]*big.Int, n)
+	for i := 0; i < n; i++ {
+		c[i] = new(big.Int).Mul(k, l.inverse[i])
+		round(c[i], l.det)
+	}
+
+	// Transform vectors according to c and subtract .
+	out := make([]*big.Int, n)
+	temp := new(big.Int)
+
+	for i := 0; i < n; i++ {
+		out[i] = new(big.Int)
+
+		for j := 0; j < n; j++ {
+			temp.Mul(c[j], l.vectors[j][i])
+			out[i].Add(out[i], temp)
+		}
+
+		out[i].Neg(out[i])
+		out[i].Add(out[i], l.vectors[0][i]).Add(out[i], l.vectors[0][i])
+	}
+	out[0].Add(out[0], k)
+
+	return out
+}
+
+func (l *lattice) Precompute(add func(i, j uint)) {
+	n := uint(len(l.vectors))
+	total := uint(1) << n
+
+	for i := uint(0); i < n; i++ {
+		for j := uint(0); j < total; j++ {
+			if (j>>i)&1 == 1 {
+				add(i, j)
+			}
+		}
+	}
+}
+
+func (l *lattice) Multi(scalar *big.Int) []uint8 {
+	decomp := l.decompose(scalar)
+
+	maxLen := 0
+	for _, x := range decomp {
+		if x.BitLen() > maxLen {
+			maxLen = x.BitLen()
+		}
+	}
+
+	out := make([]uint8, maxLen)
+	for j, x := range decomp {
+		for i := 0; i < maxLen; i++ {
+			out[i] += uint8(x.Bit(i)) << uint(j)
+		}
+	}
+
+	return out
+}
+
+// round sets num to num/denom rounded to the nearest integer.
+func round(num, denom *big.Int) {
+	r := new(big.Int)
+	num.DivMod(num, denom, r)
+
+	if r.Cmp(half) == 1 {
+		num.Add(num, big.NewInt(1))
+	}
+}
diff --git a/crypto/bn256/cloudflare/lattice_test.go b/crypto/bn256/cloudflare/lattice_test.go
new file mode 100644
index 0000000000..4d52ad9b27
--- /dev/null
+++ b/crypto/bn256/cloudflare/lattice_test.go
@@ -0,0 +1,29 @@
+package bn256
+
+import (
+	"crypto/rand"
+
+	"testing"
+)
+
+func TestLatticeReduceCurve(t *testing.T) {
+	k, _ := rand.Int(rand.Reader, Order)
+	ks := curveLattice.decompose(k)
+
+	if ks[0].BitLen() > 130 || ks[1].BitLen() > 130 {
+		t.Fatal("reduction too large")
+	} else if ks[0].Sign() < 0 || ks[1].Sign() < 0 {
+		t.Fatal("reduction must be positive")
+	}
+}
+
+func TestLatticeReduceTarget(t *testing.T) {
+	k, _ := rand.Int(rand.Reader, Order)
+	ks := targetLattice.decompose(k)
+
+	if ks[0].BitLen() > 66 || ks[1].BitLen() > 66 || ks[2].BitLen() > 66 || ks[3].BitLen() > 66 {
+		t.Fatal("reduction too large")
+	} else if ks[0].Sign() < 0 || ks[1].Sign() < 0 || ks[2].Sign() < 0 || ks[3].Sign() < 0 {
+		t.Fatal("reduction must be positive")
+	}
+}
diff --git a/crypto/bn256/main_test.go b/crypto/bn256/cloudflare/main_test.go
similarity index 100%
rename from crypto/bn256/main_test.go
rename to crypto/bn256/cloudflare/main_test.go
diff --git a/crypto/bn256/cloudflare/mul_amd64.h b/crypto/bn256/cloudflare/mul_amd64.h
new file mode 100644
index 0000000000..bab5da8313
--- /dev/null
+++ b/crypto/bn256/cloudflare/mul_amd64.h
@@ -0,0 +1,181 @@
+#define mul(a0,a1,a2,a3, rb, stack) \
+	MOVQ a0, AX \
+	MULQ 0+rb \
+	MOVQ AX, R8 \
+	MOVQ DX, R9 \
+	MOVQ a0, AX \
+	MULQ 8+rb \
+	ADDQ AX, R9 \
+	ADCQ $0, DX \
+	MOVQ DX, R10 \
+	MOVQ a0, AX \
+	MULQ 16+rb \
+	ADDQ AX, R10 \
+	ADCQ $0, DX \
+	MOVQ DX, R11 \
+	MOVQ a0, AX \
+	MULQ 24+rb \
+	ADDQ AX, R11 \
+	ADCQ $0, DX \
+	MOVQ DX, R12 \
+	\
+	storeBlock(R8,R9,R10,R11, 0+stack) \
+	MOVQ R12, 32+stack \
+	\
+	MOVQ a1, AX \
+	MULQ 0+rb \
+	MOVQ AX, R8 \
+	MOVQ DX, R9 \
+	MOVQ a1, AX \
+	MULQ 8+rb \
+	ADDQ AX, R9 \
+	ADCQ $0, DX \
+	MOVQ DX, R10 \
+	MOVQ a1, AX \
+	MULQ 16+rb \
+	ADDQ AX, R10 \
+	ADCQ $0, DX \
+	MOVQ DX, R11 \
+	MOVQ a1, AX \
+	MULQ 24+rb \
+	ADDQ AX, R11 \
+	ADCQ $0, DX \
+	MOVQ DX, R12 \
+	\
+	ADDQ 8+stack, R8 \
+	ADCQ 16+stack, R9 \
+	ADCQ 24+stack, R10 \
+	ADCQ 32+stack, R11 \
+	ADCQ $0, R12 \
+	storeBlock(R8,R9,R10,R11, 8+stack) \
+	MOVQ R12, 40+stack \
+	\
+	MOVQ a2, AX \
+	MULQ 0+rb \
+	MOVQ AX, R8 \
+	MOVQ DX, R9 \
+	MOVQ a2, AX \
+	MULQ 8+rb \
+	ADDQ AX, R9 \
+	ADCQ $0, DX \
+	MOVQ DX, R10 \
+	MOVQ a2, AX \
+	MULQ 16+rb \
+	ADDQ AX, R10 \
+	ADCQ $0, DX \
+	MOVQ DX, R11 \
+	MOVQ a2, AX \
+	MULQ 24+rb \
+	ADDQ AX, R11 \
+	ADCQ $0, DX \
+	MOVQ DX, R12 \
+	\
+	ADDQ 16+stack, R8 \
+	ADCQ 24+stack, R9 \
+	ADCQ 32+stack, R10 \
+	ADCQ 40+stack, R11 \
+	ADCQ $0, R12 \
+	storeBlock(R8,R9,R10,R11, 16+stack) \
+	MOVQ R12, 48+stack \
+	\
+	MOVQ a3, AX \
+	MULQ 0+rb \
+	MOVQ AX, R8 \
+	MOVQ DX, R9 \
+	MOVQ a3, AX \
+	MULQ 8+rb \
+	ADDQ AX, R9 \
+	ADCQ $0, DX \
+	MOVQ DX, R10 \
+	MOVQ a3, AX \
+	MULQ 16+rb \
+	ADDQ AX, R10 \
+	ADCQ $0, DX \
+	MOVQ DX, R11 \
+	MOVQ a3, AX \
+	MULQ 24+rb \
+	ADDQ AX, R11 \
+	ADCQ $0, DX \
+	MOVQ DX, R12 \
+	\
+	ADDQ 24+stack, R8 \
+	ADCQ 32+stack, R9 \
+	ADCQ 40+stack, R10 \
+	ADCQ 48+stack, R11 \
+	ADCQ $0, R12 \
+	storeBlock(R8,R9,R10,R11, 24+stack) \
+	MOVQ R12, 56+stack
+
+#define gfpReduce(stack) \
+	\ // m = (T * N') mod R, store m in R8:R9:R10:R11
+	MOVQ ·np+0(SB), AX \
+	MULQ 0+stack \
+	MOVQ AX, R8 \
+	MOVQ DX, R9 \
+	MOVQ ·np+0(SB), AX \
+	MULQ 8+stack \
+	ADDQ AX, R9 \
+	ADCQ $0, DX \
+	MOVQ DX, R10 \
+	MOVQ ·np+0(SB), AX \
+	MULQ 16+stack \
+	ADDQ AX, R10 \
+	ADCQ $0, DX \
+	MOVQ DX, R11 \
+	MOVQ ·np+0(SB), AX \
+	MULQ 24+stack \
+	ADDQ AX, R11 \
+	\
+	MOVQ ·np+8(SB), AX \
+	MULQ 0+stack \
+	MOVQ AX, R12 \
+	MOVQ DX, R13 \
+	MOVQ ·np+8(SB), AX \
+	MULQ 8+stack \
+	ADDQ AX, R13 \
+	ADCQ $0, DX \
+	MOVQ DX, R14 \
+	MOVQ ·np+8(SB), AX \
+	MULQ 16+stack \
+	ADDQ AX, R14 \
+	\
+	ADDQ R12, R9 \
+	ADCQ R13, R10 \
+	ADCQ R14, R11 \
+	\
+	MOVQ ·np+16(SB), AX \
+	MULQ 0+stack \
+	MOVQ AX, R12 \
+	MOVQ DX, R13 \
+	MOVQ ·np+16(SB), AX \
+	MULQ 8+stack \
+	ADDQ AX, R13 \
+	\
+	ADDQ R12, R10 \
+	ADCQ R13, R11 \
+	\
+	MOVQ ·np+24(SB), AX \
+	MULQ 0+stack \
+	ADDQ AX, R11 \
+	\
+	storeBlock(R8,R9,R10,R11, 64+stack) \
+	\
+	\ // m * N
+	mul(·p2+0(SB),·p2+8(SB),·p2+16(SB),·p2+24(SB), 64+stack, 96+stack) \
+	\
+	\ // Add the 512-bit intermediate to m*N
+	loadBlock(96+stack, R8,R9,R10,R11) \
+	loadBlock(128+stack, R12,R13,R14,R15) \
+	\
+	MOVQ $0, AX \
+	ADDQ 0+stack, R8 \
+	ADCQ 8+stack, R9 \
+	ADCQ 16+stack, R10 \
+	ADCQ 24+stack, R11 \
+	ADCQ 32+stack, R12 \
+	ADCQ 40+stack, R13 \
+	ADCQ 48+stack, R14 \
+	ADCQ 56+stack, R15 \
+	ADCQ $0, AX \
+	\
+	gfpCarry(R12,R13,R14,R15,AX, R8,R9,R10,R11,BX)
diff --git a/crypto/bn256/cloudflare/mul_arm64.h b/crypto/bn256/cloudflare/mul_arm64.h
new file mode 100644
index 0000000000..75d5221731
--- /dev/null
+++ b/crypto/bn256/cloudflare/mul_arm64.h
@@ -0,0 +1,133 @@
+#define mul(c0,c1,c2,c3,c4,c5,c6,c7) \
+	MUL R1, R5, c0 \
+	UMULH R1, R5, c1 \
+	MUL R1, R6, R0 \
+	ADDS R0, c1 \
+	UMULH R1, R6, c2 \
+	MUL R1, R7, R0 \
+	ADCS R0, c2 \
+	UMULH R1, R7, c3 \
+	MUL R1, R8, R0 \
+	ADCS R0, c3 \
+	UMULH R1, R8, c4 \
+	ADCS ZR, c4 \
+	\
+	MUL R2, R5, R25 \
+	UMULH R2, R5, R26 \
+	MUL R2, R6, R0 \
+	ADDS R0, R26 \
+	UMULH R2, R6, R27 \
+	MUL R2, R7, R0 \
+	ADCS R0, R27 \
+	UMULH R2, R7, R29 \
+	MUL R2, R8, R0 \
+	ADCS R0, R29 \
+	UMULH R2, R8, c5 \
+	ADCS ZR, c5 \
+	ADDS R25, c1 \
+	ADCS R26, c2 \
+	ADCS R27, c3 \
+	ADCS R29, c4 \
+	ADCS  ZR, c5 \
+	\
+	MUL R3, R5, R25 \
+	UMULH R3, R5, R26 \
+	MUL R3, R6, R0 \
+	ADDS R0, R26 \
+	UMULH R3, R6, R27 \
+	MUL R3, R7, R0 \
+	ADCS R0, R27 \
+	UMULH R3, R7, R29 \
+	MUL R3, R8, R0 \
+	ADCS R0, R29 \
+	UMULH R3, R8, c6 \
+	ADCS ZR, c6 \
+	ADDS R25, c2 \
+	ADCS R26, c3 \
+	ADCS R27, c4 \
+	ADCS R29, c5 \
+	ADCS  ZR, c6 \
+	\
+	MUL R4, R5, R25 \
+	UMULH R4, R5, R26 \
+	MUL R4, R6, R0 \
+	ADDS R0, R26 \
+	UMULH R4, R6, R27 \
+	MUL R4, R7, R0 \
+	ADCS R0, R27 \
+	UMULH R4, R7, R29 \
+	MUL R4, R8, R0 \
+	ADCS R0, R29 \
+	UMULH R4, R8, c7 \
+	ADCS ZR, c7 \
+	ADDS R25, c3 \
+	ADCS R26, c4 \
+	ADCS R27, c5 \
+	ADCS R29, c6 \
+	ADCS  ZR, c7
+
+#define gfpReduce() \
+	\ // m = (T * N') mod R, store m in R1:R2:R3:R4
+	MOVD ·np+0(SB), R17 \
+	MOVD ·np+8(SB), R18 \
+	MOVD ·np+16(SB), R19 \
+	MOVD ·np+24(SB), R20 \
+	\
+	MUL R9, R17, R1 \
+	UMULH R9, R17, R2 \
+	MUL R9, R18, R0 \
+	ADDS R0, R2 \
+	UMULH R9, R18, R3 \
+	MUL R9, R19, R0 \
+	ADCS R0, R3 \
+	UMULH R9, R19, R4 \
+	MUL R9, R20, R0 \
+	ADCS R0, R4 \
+	\
+	MUL R10, R17, R21 \
+	UMULH R10, R17, R22 \
+	MUL R10, R18, R0 \
+	ADDS R0, R22 \
+	UMULH R10, R18, R23 \
+	MUL R10, R19, R0 \
+	ADCS R0, R23 \
+	ADDS R21, R2 \
+	ADCS R22, R3 \
+	ADCS R23, R4 \
+	\
+	MUL R11, R17, R21 \
+	UMULH R11, R17, R22 \
+	MUL R11, R18, R0 \
+	ADDS R0, R22 \
+	ADDS R21, R3 \
+	ADCS R22, R4 \
+	\
+	MUL R12, R17, R21 \
+	ADDS R21, R4 \
+	\
+	\ // m * N
+	loadModulus(R5,R6,R7,R8) \
+	mul(R17,R18,R19,R20,R21,R22,R23,R24) \
+	\
+	\ // Add the 512-bit intermediate to m*N
+	MOVD  ZR, R25 \
+	ADDS  R9, R17 \
+	ADCS R10, R18 \
+	ADCS R11, R19 \
+	ADCS R12, R20 \
+	ADCS R13, R21 \
+	ADCS R14, R22 \
+	ADCS R15, R23 \
+	ADCS R16, R24 \
+	ADCS  ZR, R25 \
+	\
+	\ // Our output is R21:R22:R23:R24. Reduce mod p if necessary.
+	SUBS R5, R21, R10 \
+	SBCS R6, R22, R11 \
+	SBCS R7, R23, R12 \
+	SBCS R8, R24, R13 \
+	\
+	CSEL CS, R10, R21, R1 \
+	CSEL CS, R11, R22, R2 \
+	CSEL CS, R12, R23, R3 \
+	CSEL CS, R13, R24, R4
diff --git a/crypto/bn256/cloudflare/mul_bmi2_amd64.h b/crypto/bn256/cloudflare/mul_bmi2_amd64.h
new file mode 100644
index 0000000000..71ad0499af
--- /dev/null
+++ b/crypto/bn256/cloudflare/mul_bmi2_amd64.h
@@ -0,0 +1,112 @@
+#define mulBMI2(a0,a1,a2,a3, rb) \
+	MOVQ a0, DX \
+	MOVQ $0, R13 \
+	MULXQ 0+rb, R8, R9 \
+	MULXQ 8+rb, AX, R10 \
+	ADDQ AX, R9 \
+	MULXQ 16+rb, AX, R11 \
+	ADCQ AX, R10 \
+	MULXQ 24+rb, AX, R12 \
+	ADCQ AX, R11 \
+	ADCQ $0, R12 \
+	ADCQ $0, R13 \
+	\
+	MOVQ a1, DX \
+	MOVQ $0, R14 \
+	MULXQ 0+rb, AX, BX \
+	ADDQ AX, R9 \
+	ADCQ BX, R10 \
+	MULXQ 16+rb, AX, BX \
+	ADCQ AX, R11 \
+	ADCQ BX, R12 \
+	ADCQ $0, R13 \
+	MULXQ 8+rb, AX, BX \
+	ADDQ AX, R10 \
+	ADCQ BX, R11 \
+	MULXQ 24+rb, AX, BX \
+	ADCQ AX, R12 \
+	ADCQ BX, R13 \
+	ADCQ $0, R14 \
+	\
+	MOVQ a2, DX \
+	MOVQ $0, R15 \
+	MULXQ 0+rb, AX, BX \
+	ADDQ AX, R10 \
+	ADCQ BX, R11 \
+	MULXQ 16+rb, AX, BX \
+	ADCQ AX, R12 \
+	ADCQ BX, R13 \
+	ADCQ $0, R14 \
+	MULXQ 8+rb, AX, BX \
+	ADDQ AX, R11 \
+	ADCQ BX, R12 \
+	MULXQ 24+rb, AX, BX \
+	ADCQ AX, R13 \
+	ADCQ BX, R14 \
+	ADCQ $0, R15 \
+	\
+	MOVQ a3, DX \
+	MULXQ 0+rb, AX, BX \
+	ADDQ AX, R11 \
+	ADCQ BX, R12 \
+	MULXQ 16+rb, AX, BX \
+	ADCQ AX, R13 \
+	ADCQ BX, R14 \
+	ADCQ $0, R15 \
+	MULXQ 8+rb, AX, BX \
+	ADDQ AX, R12 \
+	ADCQ BX, R13 \
+	MULXQ 24+rb, AX, BX \
+	ADCQ AX, R14 \
+	ADCQ BX, R15
+
+#define gfpReduceBMI2() \
+	\ // m = (T * N') mod R, store m in R8:R9:R10:R11
+	MOVQ ·np+0(SB), DX \
+	MULXQ 0(SP), R8, R9 \
+	MULXQ 8(SP), AX, R10 \
+	ADDQ AX, R9 \
+	MULXQ 16(SP), AX, R11 \
+	ADCQ AX, R10 \
+	MULXQ 24(SP), AX, BX \
+	ADCQ AX, R11 \
+	\
+	MOVQ ·np+8(SB), DX \
+	MULXQ 0(SP), AX, BX \
+	ADDQ AX, R9 \
+	ADCQ BX, R10 \
+	MULXQ 16(SP), AX, BX \
+	ADCQ AX, R11 \
+	MULXQ 8(SP), AX, BX \
+	ADDQ AX, R10 \
+	ADCQ BX, R11 \
+	\
+	MOVQ ·np+16(SB), DX \
+	MULXQ 0(SP), AX, BX \
+	ADDQ AX, R10 \
+	ADCQ BX, R11 \
+	MULXQ 8(SP), AX, BX \
+	ADDQ AX, R11 \
+	\
+	MOVQ ·np+24(SB), DX \
+	MULXQ 0(SP), AX, BX \
+	ADDQ AX, R11 \
+	\
+	storeBlock(R8,R9,R10,R11, 64(SP)) \
+	\
+	\ // m * N
+	mulBMI2(·p2+0(SB),·p2+8(SB),·p2+16(SB),·p2+24(SB), 64(SP)) \
+	\
+	\ // Add the 512-bit intermediate to m*N
+	MOVQ $0, AX \
+	ADDQ 0(SP), R8 \
+	ADCQ 8(SP), R9 \
+	ADCQ 16(SP), R10 \
+	ADCQ 24(SP), R11 \
+	ADCQ 32(SP), R12 \
+	ADCQ 40(SP), R13 \
+	ADCQ 48(SP), R14 \
+	ADCQ 56(SP), R15 \
+	ADCQ $0, AX \
+	\
+	gfpCarry(R12,R13,R14,R15,AX, R8,R9,R10,R11,BX)
diff --git a/crypto/bn256/cloudflare/optate.go b/crypto/bn256/cloudflare/optate.go
new file mode 100644
index 0000000000..b71e50e3a2
--- /dev/null
+++ b/crypto/bn256/cloudflare/optate.go
@@ -0,0 +1,271 @@
+package bn256
+
+func lineFunctionAdd(r, p *twistPoint, q *curvePoint, r2 *gfP2) (a, b, c *gfP2, rOut *twistPoint) {
+	// See the mixed addition algorithm from "Faster Computation of the
+	// Tate Pairing", http://arxiv.org/pdf/0904.0854v3.pdf
+	B := (&gfP2{}).Mul(&p.x, &r.t)
+
+	D := (&gfP2{}).Add(&p.y, &r.z)
+	D.Square(D).Sub(D, r2).Sub(D, &r.t).Mul(D, &r.t)
+
+	H := (&gfP2{}).Sub(B, &r.x)
+	I := (&gfP2{}).Square(H)
+
+	E := (&gfP2{}).Add(I, I)
+	E.Add(E, E)
+
+	J := (&gfP2{}).Mul(H, E)
+
+	L1 := (&gfP2{}).Sub(D, &r.y)
+	L1.Sub(L1, &r.y)
+
+	V := (&gfP2{}).Mul(&r.x, E)
+
+	rOut = &twistPoint{}
+	rOut.x.Square(L1).Sub(&rOut.x, J).Sub(&rOut.x, V).Sub(&rOut.x, V)
+
+	rOut.z.Add(&r.z, H).Square(&rOut.z).Sub(&rOut.z, &r.t).Sub(&rOut.z, I)
+
+	t := (&gfP2{}).Sub(V, &rOut.x)
+	t.Mul(t, L1)
+	t2 := (&gfP2{}).Mul(&r.y, J)
+	t2.Add(t2, t2)
+	rOut.y.Sub(t, t2)
+
+	rOut.t.Square(&rOut.z)
+
+	t.Add(&p.y, &rOut.z).Square(t).Sub(t, r2).Sub(t, &rOut.t)
+
+	t2.Mul(L1, &p.x)
+	t2.Add(t2, t2)
+	a = (&gfP2{}).Sub(t2, t)
+
+	c = (&gfP2{}).MulScalar(&rOut.z, &q.y)
+	c.Add(c, c)
+
+	b = (&gfP2{}).Neg(L1)
+	b.MulScalar(b, &q.x).Add(b, b)
+
+	return
+}
+
+func lineFunctionDouble(r *twistPoint, q *curvePoint) (a, b, c *gfP2, rOut *twistPoint) {
+	// See the doubling algorithm for a=0 from "Faster Computation of the
+	// Tate Pairing", http://arxiv.org/pdf/0904.0854v3.pdf
+	A := (&gfP2{}).Square(&r.x)
+	B := (&gfP2{}).Square(&r.y)
+	C := (&gfP2{}).Square(B)
+
+	D := (&gfP2{}).Add(&r.x, B)
+	D.Square(D).Sub(D, A).Sub(D, C).Add(D, D)
+
+	E := (&gfP2{}).Add(A, A)
+	E.Add(E, A)
+
+	G := (&gfP2{}).Square(E)
+
+	rOut = &twistPoint{}
+	rOut.x.Sub(G, D).Sub(&rOut.x, D)
+
+	rOut.z.Add(&r.y, &r.z).Square(&rOut.z).Sub(&rOut.z, B).Sub(&rOut.z, &r.t)
+
+	rOut.y.Sub(D, &rOut.x).Mul(&rOut.y, E)
+	t := (&gfP2{}).Add(C, C)
+	t.Add(t, t).Add(t, t)
+	rOut.y.Sub(&rOut.y, t)
+
+	rOut.t.Square(&rOut.z)
+
+	t.Mul(E, &r.t).Add(t, t)
+	b = (&gfP2{}).Neg(t)
+	b.MulScalar(b, &q.x)
+
+	a = (&gfP2{}).Add(&r.x, E)
+	a.Square(a).Sub(a, A).Sub(a, G)
+	t.Add(B, B).Add(t, t)
+	a.Sub(a, t)
+
+	c = (&gfP2{}).Mul(&rOut.z, &r.t)
+	c.Add(c, c).MulScalar(c, &q.y)
+
+	return
+}
+
+func mulLine(ret *gfP12, a, b, c *gfP2) {
+	a2 := &gfP6{}
+	a2.y.Set(a)
+	a2.z.Set(b)
+	a2.Mul(a2, &ret.x)
+	t3 := (&gfP6{}).MulScalar(&ret.y, c)
+
+	t := (&gfP2{}).Add(b, c)
+	t2 := &gfP6{}
+	t2.y.Set(a)
+	t2.z.Set(t)
+	ret.x.Add(&ret.x, &ret.y)
+
+	ret.y.Set(t3)
+
+	ret.x.Mul(&ret.x, t2).Sub(&ret.x, a2).Sub(&ret.x, &ret.y)
+	a2.MulTau(a2)
+	ret.y.Add(&ret.y, a2)
+}
+
+// sixuPlus2NAF is 6u+2 in non-adjacent form.
+var sixuPlus2NAF = []int8{0, 0, 0, 1, 0, 1, 0, -1, 0, 0, 1, -1, 0, 0, 1, 0,
+	0, 1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 0, 0, 1, 1,
+	1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, -1, 0, 0, 1,
+	1, 0, 0, -1, 0, 0, 0, 1, 1, 0, -1, 0, 0, 1, 0, 1, 1}
+
+// miller implements the Miller loop for calculating the Optimal Ate pairing.
+// See algorithm 1 from http://cryptojedi.org/papers/dclxvi-20100714.pdf
+func miller(q *twistPoint, p *curvePoint) *gfP12 {
+	ret := (&gfP12{}).SetOne()
+
+	aAffine := &twistPoint{}
+	aAffine.Set(q)
+	aAffine.MakeAffine()
+
+	bAffine := &curvePoint{}
+	bAffine.Set(p)
+	bAffine.MakeAffine()
+
+	minusA := &twistPoint{}
+	minusA.Neg(aAffine)
+
+	r := &twistPoint{}
+	r.Set(aAffine)
+
+	r2 := (&gfP2{}).Square(&aAffine.y)
+
+	for i := len(sixuPlus2NAF) - 1; i > 0; i-- {
+		a, b, c, newR := lineFunctionDouble(r, bAffine)
+		if i != len(sixuPlus2NAF)-1 {
+			ret.Square(ret)
+		}
+
+		mulLine(ret, a, b, c)
+		r = newR
+
+		switch sixuPlus2NAF[i-1] {
+		case 1:
+			a, b, c, newR = lineFunctionAdd(r, aAffine, bAffine, r2)
+		case -1:
+			a, b, c, newR = lineFunctionAdd(r, minusA, bAffine, r2)
+		default:
+			continue
+		}
+
+		mulLine(ret, a, b, c)
+		r = newR
+	}
+
+	// In order to calculate Q1 we have to convert q from the sextic twist
+	// to the full GF(p^12) group, apply the Frobenius there, and convert
+	// back.
+	//
+	// The twist isomorphism is (x', y') -> (xω², yω³). If we consider just
+	// x for a moment, then after applying the Frobenius, we have x̄ω^(2p)
+	// where x̄ is the conjugate of x. If we are going to apply the inverse
+	// isomorphism we need a value with a single coefficient of ω² so we
+	// rewrite this as x̄ω^(2p-2)ω². ξ⁶ = ω and, due to the construction of
+	// p, 2p-2 is a multiple of six. Therefore we can rewrite as
+	// x̄ξ^((p-1)/3)ω² and applying the inverse isomorphism eliminates the
+	// ω².
+	//
+	// A similar argument can be made for the y value.
+
+	q1 := &twistPoint{}
+	q1.x.Conjugate(&aAffine.x).Mul(&q1.x, xiToPMinus1Over3)
+	q1.y.Conjugate(&aAffine.y).Mul(&q1.y, xiToPMinus1Over2)
+	q1.z.SetOne()
+	q1.t.SetOne()
+
+	// For Q2 we are applying the p² Frobenius. The two conjugations cancel
+	// out and we are left only with the factors from the isomorphism. In
+	// the case of x, we end up with a pure number which is why
+	// xiToPSquaredMinus1Over3 is ∈ GF(p). With y we get a factor of -1. We
+	// ignore this to end up with -Q2.
+
+	minusQ2 := &twistPoint{}
+	minusQ2.x.MulScalar(&aAffine.x, xiToPSquaredMinus1Over3)
+	minusQ2.y.Set(&aAffine.y)
+	minusQ2.z.SetOne()
+	minusQ2.t.SetOne()
+
+	r2.Square(&q1.y)
+	a, b, c, newR := lineFunctionAdd(r, q1, bAffine, r2)
+	mulLine(ret, a, b, c)
+	r = newR
+
+	r2.Square(&minusQ2.y)
+	a, b, c, newR = lineFunctionAdd(r, minusQ2, bAffine, r2)
+	mulLine(ret, a, b, c)
+	r = newR
+
+	return ret
+}
+
+// finalExponentiation computes the (p¹²-1)/Order-th power of an element of
+// GF(p¹²) to obtain an element of GT (steps 13-15 of algorithm 1 from
+// http://cryptojedi.org/papers/dclxvi-20100714.pdf)
+func finalExponentiation(in *gfP12) *gfP12 {
+	t1 := &gfP12{}
+
+	// This is the p^6-Frobenius
+	t1.x.Neg(&in.x)
+	t1.y.Set(&in.y)
+
+	inv := &gfP12{}
+	inv.Invert(in)
+	t1.Mul(t1, inv)
+
+	t2 := (&gfP12{}).FrobeniusP2(t1)
+	t1.Mul(t1, t2)
+
+	fp := (&gfP12{}).Frobenius(t1)
+	fp2 := (&gfP12{}).FrobeniusP2(t1)
+	fp3 := (&gfP12{}).Frobenius(fp2)
+
+	fu := (&gfP12{}).Exp(t1, u)
+	fu2 := (&gfP12{}).Exp(fu, u)
+	fu3 := (&gfP12{}).Exp(fu2, u)
+
+	y3 := (&gfP12{}).Frobenius(fu)
+	fu2p := (&gfP12{}).Frobenius(fu2)
+	fu3p := (&gfP12{}).Frobenius(fu3)
+	y2 := (&gfP12{}).FrobeniusP2(fu2)
+
+	y0 := &gfP12{}
+	y0.Mul(fp, fp2).Mul(y0, fp3)
+
+	y1 := (&gfP12{}).Conjugate(t1)
+	y5 := (&gfP12{}).Conjugate(fu2)
+	y3.Conjugate(y3)
+	y4 := (&gfP12{}).Mul(fu, fu2p)
+	y4.Conjugate(y4)
+
+	y6 := (&gfP12{}).Mul(fu3, fu3p)
+	y6.Conjugate(y6)
+
+	t0 := (&gfP12{}).Square(y6)
+	t0.Mul(t0, y4).Mul(t0, y5)
+	t1.Mul(y3, y5).Mul(t1, t0)
+	t0.Mul(t0, y2)
+	t1.Square(t1).Mul(t1, t0).Square(t1)
+	t0.Mul(t1, y1)
+	t1.Mul(t1, y0)
+	t0.Square(t0).Mul(t0, t1)
+
+	return t0
+}
+
+func optimalAte(a *twistPoint, b *curvePoint) *gfP12 {
+	e := miller(a, b)
+	ret := finalExponentiation(e)
+
+	if a.IsInfinity() || b.IsInfinity() {
+		ret.SetOne()
+	}
+	return ret
+}
diff --git a/crypto/bn256/cloudflare/twist.go b/crypto/bn256/cloudflare/twist.go
new file mode 100644
index 0000000000..0c2f80d4ed
--- /dev/null
+++ b/crypto/bn256/cloudflare/twist.go
@@ -0,0 +1,204 @@
+package bn256
+
+import (
+	"math/big"
+)
+
+// twistPoint implements the elliptic curve y²=x³+3/ξ over GF(p²). Points are
+// kept in Jacobian form and t=z² when valid. The group G₂ is the set of
+// n-torsion points of this curve over GF(p²) (where n = Order)
+type twistPoint struct {
+	x, y, z, t gfP2
+}
+
+var twistB = &gfP2{
+	gfP{0x38e7ecccd1dcff67, 0x65f0b37d93ce0d3e, 0xd749d0dd22ac00aa, 0x0141b9ce4a688d4d},
+	gfP{0x3bf938e377b802a8, 0x020b1b273633535d, 0x26b7edf049755260, 0x2514c6324384a86d},
+}
+
+// twistGen is the generator of group G₂.
+var twistGen = &twistPoint{
+	gfP2{
+		gfP{0xafb4737da84c6140, 0x6043dd5a5802d8c4, 0x09e950fc52a02f86, 0x14fef0833aea7b6b},
+		gfP{0x8e83b5d102bc2026, 0xdceb1935497b0172, 0xfbb8264797811adf, 0x19573841af96503b},
+	},
+	gfP2{
+		gfP{0x64095b56c71856ee, 0xdc57f922327d3cbb, 0x55f935be33351076, 0x0da4a0e693fd6482},
+		gfP{0x619dfa9d886be9f6, 0xfe7fd297f59e9b78, 0xff9e1a62231b7dfe, 0x28fd7eebae9e4206},
+	},
+	gfP2{*newGFp(0), *newGFp(1)},
+	gfP2{*newGFp(0), *newGFp(1)},
+}
+
+func (c *twistPoint) String() string {
+	c.MakeAffine()
+	x, y := gfP2Decode(&c.x), gfP2Decode(&c.y)
+	return "(" + x.String() + ", " + y.String() + ")"
+}
+
+func (c *twistPoint) Set(a *twistPoint) {
+	c.x.Set(&a.x)
+	c.y.Set(&a.y)
+	c.z.Set(&a.z)
+	c.t.Set(&a.t)
+}
+
+// IsOnCurve returns true iff c is on the curve.
+func (c *twistPoint) IsOnCurve() bool {
+	c.MakeAffine()
+	if c.IsInfinity() {
+		return true
+	}
+
+	y2, x3 := &gfP2{}, &gfP2{}
+	y2.Square(&c.y)
+	x3.Square(&c.x).Mul(x3, &c.x).Add(x3, twistB)
+
+	if *y2 != *x3 {
+		return false
+	}
+	cneg := &twistPoint{}
+	cneg.Mul(c, Order)
+	return cneg.z.IsZero()
+}
+
+func (c *twistPoint) SetInfinity() {
+	c.x.SetZero()
+	c.y.SetOne()
+	c.z.SetZero()
+	c.t.SetZero()
+}
+
+func (c *twistPoint) IsInfinity() bool {
+	return c.z.IsZero()
+}
+
+func (c *twistPoint) Add(a, b *twistPoint) {
+	// For additional comments, see the same function in curve.go.
+
+	if a.IsInfinity() {
+		c.Set(b)
+		return
+	}
+	if b.IsInfinity() {
+		c.Set(a)
+		return
+	}
+
+	// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/addition/add-2007-bl.op3
+	z12 := (&gfP2{}).Square(&a.z)
+	z22 := (&gfP2{}).Square(&b.z)
+	u1 := (&gfP2{}).Mul(&a.x, z22)
+	u2 := (&gfP2{}).Mul(&b.x, z12)
+
+	t := (&gfP2{}).Mul(&b.z, z22)
+	s1 := (&gfP2{}).Mul(&a.y, t)
+
+	t.Mul(&a.z, z12)
+	s2 := (&gfP2{}).Mul(&b.y, t)
+
+	h := (&gfP2{}).Sub(u2, u1)
+	xEqual := h.IsZero()
+
+	t.Add(h, h)
+	i := (&gfP2{}).Square(t)
+	j := (&gfP2{}).Mul(h, i)
+
+	t.Sub(s2, s1)
+	yEqual := t.IsZero()
+	if xEqual && yEqual {
+		c.Double(a)
+		return
+	}
+	r := (&gfP2{}).Add(t, t)
+
+	v := (&gfP2{}).Mul(u1, i)
+
+	t4 := (&gfP2{}).Square(r)
+	t.Add(v, v)
+	t6 := (&gfP2{}).Sub(t4, j)
+	c.x.Sub(t6, t)
+
+	t.Sub(v, &c.x) // t7
+	t4.Mul(s1, j)  // t8
+	t6.Add(t4, t4) // t9
+	t4.Mul(r, t)   // t10
+	c.y.Sub(t4, t6)
+
+	t.Add(&a.z, &b.z) // t11
+	t4.Square(t)      // t12
+	t.Sub(t4, z12)    // t13
+	t4.Sub(t, z22)    // t14
+	c.z.Mul(t4, h)
+}
+
+func (c *twistPoint) Double(a *twistPoint) {
+	// See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/doubling/dbl-2009-l.op3
+	A := (&gfP2{}).Square(&a.x)
+	B := (&gfP2{}).Square(&a.y)
+	C := (&gfP2{}).Square(B)
+
+	t := (&gfP2{}).Add(&a.x, B)
+	t2 := (&gfP2{}).Square(t)
+	t.Sub(t2, A)
+	t2.Sub(t, C)
+	d := (&gfP2{}).Add(t2, t2)
+	t.Add(A, A)
+	e := (&gfP2{}).Add(t, A)
+	f := (&gfP2{}).Square(e)
+
+	t.Add(d, d)
+	c.x.Sub(f, t)
+
+	t.Add(C, C)
+	t2.Add(t, t)
+	t.Add(t2, t2)
+	c.y.Sub(d, &c.x)
+	t2.Mul(e, &c.y)
+	c.y.Sub(t2, t)
+
+	t.Mul(&a.y, &a.z)
+	c.z.Add(t, t)
+}
+
+func (c *twistPoint) Mul(a *twistPoint, scalar *big.Int) {
+	sum, t := &twistPoint{}, &twistPoint{}
+
+	for i := scalar.BitLen(); i >= 0; i-- {
+		t.Double(sum)
+		if scalar.Bit(i) != 0 {
+			sum.Add(t, a)
+		} else {
+			sum.Set(t)
+		}
+	}
+
+	c.Set(sum)
+}
+
+func (c *twistPoint) MakeAffine() {
+	if c.z.IsOne() {
+		return
+	} else if c.z.IsZero() {
+		c.x.SetZero()
+		c.y.SetOne()
+		c.t.SetZero()
+		return
+	}
+
+	zInv := (&gfP2{}).Invert(&c.z)
+	t := (&gfP2{}).Mul(&c.y, zInv)
+	zInv2 := (&gfP2{}).Square(zInv)
+	c.y.Mul(t, zInv2)
+	t.Mul(&c.x, zInv2)
+	c.x.Set(t)
+	c.z.SetOne()
+	c.t.SetOne()
+}
+
+func (c *twistPoint) Neg(a *twistPoint) {
+	c.x.Set(&a.x)
+	c.y.Neg(&a.y)
+	c.z.Set(&a.z)
+	c.t.SetZero()
+}
diff --git a/crypto/bn256/bn256.go b/crypto/bn256/google/bn256.go
similarity index 90%
rename from crypto/bn256/bn256.go
rename to crypto/bn256/google/bn256.go
index 7144c31a8a..5da83e033a 100644
--- a/crypto/bn256/bn256.go
+++ b/crypto/bn256/google/bn256.go
@@ -18,6 +18,7 @@ package bn256
 
 import (
 	"crypto/rand"
+	"errors"
 	"io"
 	"math/big"
 )
@@ -115,21 +116,25 @@ func (n *G1) Marshal() []byte {
 
 // Unmarshal sets e to the result of converting the output of Marshal back into
 // a group element and then returns e.
-func (e *G1) Unmarshal(m []byte) (*G1, bool) {
+func (e *G1) Unmarshal(m []byte) ([]byte, error) {
 	// Each value is a 256-bit number.
 	const numBytes = 256 / 8
-
 	if len(m) != 2*numBytes {
-		return nil, false
+		return nil, errors.New("bn256: not enough data")
 	}
-
+	// Unmarshal the points and check their caps
 	if e.p == nil {
 		e.p = newCurvePoint(nil)
 	}
-
 	e.p.x.SetBytes(m[0*numBytes : 1*numBytes])
+	if e.p.x.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
 	e.p.y.SetBytes(m[1*numBytes : 2*numBytes])
-
+	if e.p.y.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
+	// Ensure the point is on the curve
 	if e.p.x.Sign() == 0 && e.p.y.Sign() == 0 {
 		// This is the point at infinity.
 		e.p.y.SetInt64(1)
@@ -140,11 +145,10 @@ func (e *G1) Unmarshal(m []byte) (*G1, bool) {
 		e.p.t.SetInt64(1)
 
 		if !e.p.IsOnCurve() {
-			return nil, false
+			return nil, errors.New("bn256: malformed point")
 		}
 	}
-
-	return e, true
+	return m[2*numBytes:], nil
 }
 
 // G2 is an abstract cyclic group. The zero value is suitable for use as the
@@ -233,23 +237,33 @@ func (n *G2) Marshal() []byte {
 
 // Unmarshal sets e to the result of converting the output of Marshal back into
 // a group element and then returns e.
-func (e *G2) Unmarshal(m []byte) (*G2, bool) {
+func (e *G2) Unmarshal(m []byte) ([]byte, error) {
 	// Each value is a 256-bit number.
 	const numBytes = 256 / 8
-
 	if len(m) != 4*numBytes {
-		return nil, false
+		return nil, errors.New("bn256: not enough data")
 	}
-
+	// Unmarshal the points and check their caps
 	if e.p == nil {
 		e.p = newTwistPoint(nil)
 	}
-
 	e.p.x.x.SetBytes(m[0*numBytes : 1*numBytes])
+	if e.p.x.x.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
 	e.p.x.y.SetBytes(m[1*numBytes : 2*numBytes])
+	if e.p.x.y.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
 	e.p.y.x.SetBytes(m[2*numBytes : 3*numBytes])
+	if e.p.y.x.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
 	e.p.y.y.SetBytes(m[3*numBytes : 4*numBytes])
-
+	if e.p.y.y.Cmp(P) >= 0 {
+		return nil, errors.New("bn256: coordinate exceeds modulus")
+	}
+	// Ensure the point is on the curve
 	if e.p.x.x.Sign() == 0 &&
 		e.p.x.y.Sign() == 0 &&
 		e.p.y.x.Sign() == 0 &&
@@ -263,11 +277,10 @@ func (e *G2) Unmarshal(m []byte) (*G2, bool) {
 		e.p.t.SetOne()
 
 		if !e.p.IsOnCurve() {
-			return nil, false
+			return nil, errors.New("bn256: malformed point")
 		}
 	}
-
-	return e, true
+	return m[4*numBytes:], nil
 }
 
 // GT is an abstract cyclic group. The zero value is suitable for use as the
diff --git a/crypto/bn256/bn256_test.go b/crypto/bn256/google/bn256_test.go
similarity index 90%
rename from crypto/bn256/bn256_test.go
rename to crypto/bn256/google/bn256_test.go
index 866065d0ca..a4497ada9b 100644
--- a/crypto/bn256/bn256_test.go
+++ b/crypto/bn256/google/bn256_test.go
@@ -219,15 +219,16 @@ func TestBilinearity(t *testing.T) {
 func TestG1Marshal(t *testing.T) {
 	g := new(G1).ScalarBaseMult(new(big.Int).SetInt64(1))
 	form := g.Marshal()
-	_, ok := new(G1).Unmarshal(form)
-	if !ok {
+	_, err := new(G1).Unmarshal(form)
+	if err != nil {
 		t.Fatalf("failed to unmarshal")
 	}
 
 	g.ScalarBaseMult(Order)
 	form = g.Marshal()
-	g2, ok := new(G1).Unmarshal(form)
-	if !ok {
+
+	g2 := new(G1)
+	if _, err = g2.Unmarshal(form); err != nil {
 		t.Fatalf("failed to unmarshal ∞")
 	}
 	if !g2.p.IsInfinity() {
@@ -238,15 +239,15 @@ func TestG1Marshal(t *testing.T) {
 func TestG2Marshal(t *testing.T) {
 	g := new(G2).ScalarBaseMult(new(big.Int).SetInt64(1))
 	form := g.Marshal()
-	_, ok := new(G2).Unmarshal(form)
-	if !ok {
+	_, err := new(G2).Unmarshal(form)
+	if err != nil {
 		t.Fatalf("failed to unmarshal")
 	}
 
 	g.ScalarBaseMult(Order)
 	form = g.Marshal()
-	g2, ok := new(G2).Unmarshal(form)
-	if !ok {
+	g2 := new(G2)
+	if _, err = g2.Unmarshal(form); err != nil {
 		t.Fatalf("failed to unmarshal ∞")
 	}
 	if !g2.p.IsInfinity() {
@@ -273,12 +274,18 @@ func TestTripartiteDiffieHellman(t *testing.T) {
 	b, _ := rand.Int(rand.Reader, Order)
 	c, _ := rand.Int(rand.Reader, Order)
 
-	pa, _ := new(G1).Unmarshal(new(G1).ScalarBaseMult(a).Marshal())
-	qa, _ := new(G2).Unmarshal(new(G2).ScalarBaseMult(a).Marshal())
-	pb, _ := new(G1).Unmarshal(new(G1).ScalarBaseMult(b).Marshal())
-	qb, _ := new(G2).Unmarshal(new(G2).ScalarBaseMult(b).Marshal())
-	pc, _ := new(G1).Unmarshal(new(G1).ScalarBaseMult(c).Marshal())
-	qc, _ := new(G2).Unmarshal(new(G2).ScalarBaseMult(c).Marshal())
+	pa := new(G1)
+	pa.Unmarshal(new(G1).ScalarBaseMult(a).Marshal())
+	qa := new(G2)
+	qa.Unmarshal(new(G2).ScalarBaseMult(a).Marshal())
+	pb := new(G1)
+	pb.Unmarshal(new(G1).ScalarBaseMult(b).Marshal())
+	qb := new(G2)
+	qb.Unmarshal(new(G2).ScalarBaseMult(b).Marshal())
+	pc := new(G1)
+	pc.Unmarshal(new(G1).ScalarBaseMult(c).Marshal())
+	qc := new(G2)
+	qc.Unmarshal(new(G2).ScalarBaseMult(c).Marshal())
 
 	k1 := Pair(pb, qc)
 	k1.ScalarMult(k1, a)
diff --git a/crypto/bn256/constants.go b/crypto/bn256/google/constants.go
similarity index 100%
rename from crypto/bn256/constants.go
rename to crypto/bn256/google/constants.go
diff --git a/crypto/bn256/curve.go b/crypto/bn256/google/curve.go
similarity index 100%
rename from crypto/bn256/curve.go
rename to crypto/bn256/google/curve.go
diff --git a/crypto/bn256/example_test.go b/crypto/bn256/google/example_test.go
similarity index 100%
rename from crypto/bn256/example_test.go
rename to crypto/bn256/google/example_test.go
diff --git a/crypto/bn256/gfp12.go b/crypto/bn256/google/gfp12.go
similarity index 100%
rename from crypto/bn256/gfp12.go
rename to crypto/bn256/google/gfp12.go
diff --git a/crypto/bn256/gfp2.go b/crypto/bn256/google/gfp2.go
similarity index 100%
rename from crypto/bn256/gfp2.go
rename to crypto/bn256/google/gfp2.go
diff --git a/crypto/bn256/gfp6.go b/crypto/bn256/google/gfp6.go
similarity index 100%
rename from crypto/bn256/gfp6.go
rename to crypto/bn256/google/gfp6.go
diff --git a/crypto/bn256/google/main_test.go b/crypto/bn256/google/main_test.go
new file mode 100644
index 0000000000..0230f1b199
--- /dev/null
+++ b/crypto/bn256/google/main_test.go
@@ -0,0 +1,71 @@
+package bn256
+
+import (
+	"testing"
+
+	"crypto/rand"
+)
+
+func TestRandomG2Marshal(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		n, g2, err := RandomG2(rand.Reader)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		t.Logf("%d: %x\n", n, g2.Marshal())
+	}
+}
+
+func TestPairings(t *testing.T) {
+	a1 := new(G1).ScalarBaseMult(bigFromBase10("1"))
+	a2 := new(G1).ScalarBaseMult(bigFromBase10("2"))
+	a37 := new(G1).ScalarBaseMult(bigFromBase10("37"))
+	an1 := new(G1).ScalarBaseMult(bigFromBase10("21888242871839275222246405745257275088548364400416034343698204186575808495616"))
+
+	b0 := new(G2).ScalarBaseMult(bigFromBase10("0"))
+	b1 := new(G2).ScalarBaseMult(bigFromBase10("1"))
+	b2 := new(G2).ScalarBaseMult(bigFromBase10("2"))
+	b27 := new(G2).ScalarBaseMult(bigFromBase10("27"))
+	b999 := new(G2).ScalarBaseMult(bigFromBase10("999"))
+	bn1 := new(G2).ScalarBaseMult(bigFromBase10("21888242871839275222246405745257275088548364400416034343698204186575808495616"))
+
+	p1 := Pair(a1, b1)
+	pn1 := Pair(a1, bn1)
+	np1 := Pair(an1, b1)
+	if pn1.String() != np1.String() {
+		t.Error("Pairing mismatch: e(a, -b) != e(-a, b)")
+	}
+	if !PairingCheck([]*G1{a1, an1}, []*G2{b1, b1}) {
+		t.Error("MultiAte check gave false negative!")
+	}
+	p0 := new(GT).Add(p1, pn1)
+	p0_2 := Pair(a1, b0)
+	if p0.String() != p0_2.String() {
+		t.Error("Pairing mismatch: e(a, b) * e(a, -b) != 1")
+	}
+	p0_3 := new(GT).ScalarMult(p1, bigFromBase10("21888242871839275222246405745257275088548364400416034343698204186575808495617"))
+	if p0.String() != p0_3.String() {
+		t.Error("Pairing mismatch: e(a, b) has wrong order")
+	}
+	p2 := Pair(a2, b1)
+	p2_2 := Pair(a1, b2)
+	p2_3 := new(GT).ScalarMult(p1, bigFromBase10("2"))
+	if p2.String() != p2_2.String() {
+		t.Error("Pairing mismatch: e(a, b * 2) != e(a * 2, b)")
+	}
+	if p2.String() != p2_3.String() {
+		t.Error("Pairing mismatch: e(a, b * 2) != e(a, b) ** 2")
+	}
+	if p2.String() == p1.String() {
+		t.Error("Pairing is degenerate!")
+	}
+	if PairingCheck([]*G1{a1, a1}, []*G2{b1, b1}) {
+		t.Error("MultiAte check gave false positive!")
+	}
+	p999 := Pair(a37, b27)
+	p999_2 := Pair(a1, b999)
+	if p999.String() != p999_2.String() {
+		t.Error("Pairing mismatch: e(a * 37, b * 27) != e(a, b * 999)")
+	}
+}
diff --git a/crypto/bn256/optate.go b/crypto/bn256/google/optate.go
similarity index 100%
rename from crypto/bn256/optate.go
rename to crypto/bn256/google/optate.go
diff --git a/crypto/bn256/twist.go b/crypto/bn256/google/twist.go
similarity index 97%
rename from crypto/bn256/twist.go
rename to crypto/bn256/google/twist.go
index 95b966e2ed..1f5a4d9deb 100644
--- a/crypto/bn256/twist.go
+++ b/crypto/bn256/google/twist.go
@@ -76,7 +76,13 @@ func (c *twistPoint) IsOnCurve() bool {
 	yy.Sub(yy, xxx)
 	yy.Sub(yy, twistB)
 	yy.Minimal()
-	return yy.x.Sign() == 0 && yy.y.Sign() == 0
+
+	if yy.x.Sign() != 0 || yy.y.Sign() != 0 {
+		return false
+	}
+	cneg := newTwistPoint(pool)
+	cneg.Mul(c, Order, pool)
+	return cneg.z.IsZero()
 }
 
 func (c *twistPoint) SetInfinity() {
diff --git a/crypto/crypto.go b/crypto/crypto.go
index e51726e624..619440e817 100644
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -35,10 +35,12 @@ import (
 )
 
 var (
-	secp256k1_N, _  = new(big.Int).SetString("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", 16)
-	secp256k1_halfN = new(big.Int).Div(secp256k1_N, big.NewInt(2))
+	secp256k1N, _  = new(big.Int).SetString("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", 16)
+	secp256k1halfN = new(big.Int).Div(secp256k1N, big.NewInt(2))
 )
 
+var errInvalidPubkey = errors.New("invalid secp256k1 public key")
+
 // Keccak256 calculates and returns the Keccak256 hash of the input data.
 func Keccak256(data ...[]byte) []byte {
 	d := sha3.NewKeccak256()
@@ -68,7 +70,7 @@ func Keccak512(data ...[]byte) []byte {
 	return d.Sum(nil)
 }
 
-// Creates an ethereum address given the bytes and the nonce
+// CreateAddress creates an ethereum address given the bytes and the nonce
 func CreateAddress(b common.Address, nonce uint64) common.Address {
 	data, _ := rlp.EncodeToBytes([]interface{}{b, nonce})
 	return common.BytesToAddress(Keccak256(data)[12:])
@@ -97,6 +99,16 @@ func toECDSA(d []byte, strict bool) (*ecdsa.PrivateKey, error) {
 		return nil, fmt.Errorf("invalid length, need %d bits", priv.Params().BitSize)
 	}
 	priv.D = new(big.Int).SetBytes(d)
+
+	// The priv.D must < N
+	if priv.D.Cmp(secp256k1N) >= 0 {
+		return nil, fmt.Errorf("invalid private key, >=N")
+	}
+	// The priv.D must not be zero or negative.
+	if priv.D.Sign() <= 0 {
+		return nil, fmt.Errorf("invalid private key, zero or negative")
+	}
+
 	priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(d)
 	if priv.PublicKey.X == nil {
 		return nil, errors.New("invalid private key")
@@ -112,12 +124,13 @@ func FromECDSA(priv *ecdsa.PrivateKey) []byte {
 	return math.PaddedBigBytes(priv.D, priv.Params().BitSize/8)
 }
 
-func ToECDSAPub(pub []byte) *ecdsa.PublicKey {
-	if len(pub) == 0 {
-		return nil
-	}
+// UnmarshalPubkey converts bytes to a secp256k1 public key.
+func UnmarshalPubkey(pub []byte) (*ecdsa.PublicKey, error) {
 	x, y := elliptic.Unmarshal(S256(), pub)
-	return &ecdsa.PublicKey{Curve: S256(), X: x, Y: y}
+	if x == nil {
+		return nil, errInvalidPubkey
+	}
+	return &ecdsa.PublicKey{Curve: S256(), X: x, Y: y}, nil
 }
 
 func FromECDSAPub(pub *ecdsa.PublicKey) []byte {
@@ -174,11 +187,11 @@ func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool {
 	}
 	// reject upper range of s values (ECDSA malleability)
 	// see discussion in secp256k1/libsecp256k1/include/secp256k1.h
-	if homestead && s.Cmp(secp256k1_halfN) > 0 {
+	if homestead && s.Cmp(secp256k1halfN) > 0 {
 		return false
 	}
 	// Frontier: allow s to be in full N range
-	return r.Cmp(secp256k1_N) < 0 && s.Cmp(secp256k1_N) < 0 && (v == 0 || v == 1)
+	return r.Cmp(secp256k1N) < 0 && s.Cmp(secp256k1N) < 0 && (v == 0 || v == 1)
 }
 
 func PubkeyToAddress(p ecdsa.PublicKey) common.Address {
diff --git a/crypto/crypto_test.go b/crypto/crypto_test.go
index 8350354623..177c19c0cf 100644
--- a/crypto/crypto_test.go
+++ b/crypto/crypto_test.go
@@ -23,9 +23,11 @@ import (
 	"io/ioutil"
 	"math/big"
 	"os"
+	"reflect"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 )
 
 var testAddrHex = "970e8128ab834e8eac17ab8e3812f010678cf791"
@@ -56,6 +58,33 @@ func BenchmarkSha3(b *testing.B) {
 	}
 }
 
+func TestUnmarshalPubkey(t *testing.T) {
+	key, err := UnmarshalPubkey(nil)
+	if err != errInvalidPubkey || key != nil {
+		t.Fatalf("expected error, got %v, %v", err, key)
+	}
+	key, err = UnmarshalPubkey([]byte{1, 2, 3})
+	if err != errInvalidPubkey || key != nil {
+		t.Fatalf("expected error, got %v, %v", err, key)
+	}
+
+	var (
+		enc, _ = hex.DecodeString("04760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1b01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d")
+		dec    = &ecdsa.PublicKey{
+			Curve: S256(),
+			X:     hexutil.MustDecodeBig("0x760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1"),
+			Y:     hexutil.MustDecodeBig("0xb01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d"),
+		}
+	)
+	key, err = UnmarshalPubkey(enc)
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if !reflect.DeepEqual(key, dec) {
+		t.Fatal("wrong result")
+	}
+}
+
 func TestSign(t *testing.T) {
 	key, _ := HexToECDSA(testPrivHex)
 	addr := common.HexToAddress(testAddrHex)
@@ -69,7 +98,7 @@ func TestSign(t *testing.T) {
 	if err != nil {
 		t.Errorf("ECRecover error: %s", err)
 	}
-	pubKey := ToECDSAPub(recoveredPub)
+	pubKey, _ := UnmarshalPubkey(recoveredPub)
 	recoveredAddr := PubkeyToAddress(*pubKey)
 	if addr != recoveredAddr {
 		t.Errorf("Address mismatch: want: %x have: %x", addr, recoveredAddr)
@@ -154,7 +183,7 @@ func TestValidateSignatureValues(t *testing.T) {
 	minusOne := big.NewInt(-1)
 	one := common.Big1
 	zero := common.Big0
-	secp256k1nMinus1 := new(big.Int).Sub(secp256k1_N, common.Big1)
+	secp256k1nMinus1 := new(big.Int).Sub(secp256k1N, common.Big1)
 
 	// correct v,r,s
 	check(true, 0, one, one)
@@ -181,9 +210,9 @@ func TestValidateSignatureValues(t *testing.T) {
 	// correct sig with max r,s
 	check(true, 0, secp256k1nMinus1, secp256k1nMinus1)
 	// correct v, combinations of incorrect r,s at upper limit
-	check(false, 0, secp256k1_N, secp256k1nMinus1)
-	check(false, 0, secp256k1nMinus1, secp256k1_N)
-	check(false, 0, secp256k1_N, secp256k1_N)
+	check(false, 0, secp256k1N, secp256k1nMinus1)
+	check(false, 0, secp256k1nMinus1, secp256k1N)
+	check(false, 0, secp256k1N, secp256k1N)
 
 	// current callers ensures r,s cannot be negative, but let's test for that too
 	// as crypto package could be used stand-alone
diff --git a/crypto/ecies/ecies.go b/crypto/ecies/ecies.go
index 1d5f96ed27..1474181482 100644
--- a/crypto/ecies/ecies.go
+++ b/crypto/ecies/ecies.go
@@ -230,7 +230,7 @@ func symEncrypt(rand io.Reader, params *ECIESParams, key, m []byte) (ct []byte,
 
 // symDecrypt carries out CTR decryption using the block cipher specified in
 // the parameters
-func symDecrypt(rand io.Reader, params *ECIESParams, key, ct []byte) (m []byte, err error) {
+func symDecrypt(params *ECIESParams, key, ct []byte) (m []byte, err error) {
 	c, err := params.Cipher(key)
 	if err != nil {
 		return
@@ -292,7 +292,7 @@ func Encrypt(rand io.Reader, pub *PublicKey, m, s1, s2 []byte) (ct []byte, err e
 }
 
 // Decrypt decrypts an ECIES ciphertext.
-func (prv *PrivateKey) Decrypt(rand io.Reader, c, s1, s2 []byte) (m []byte, err error) {
+func (prv *PrivateKey) Decrypt(c, s1, s2 []byte) (m []byte, err error) {
 	if len(c) == 0 {
 		return nil, ErrInvalidMessage
 	}
@@ -314,7 +314,7 @@ func (prv *PrivateKey) Decrypt(rand io.Reader, c, s1, s2 []byte) (m []byte, err
 
 	switch c[0] {
 	case 2, 3, 4:
-		rLen = ((prv.PublicKey.Curve.Params().BitSize + 7) / 4)
+		rLen = (prv.PublicKey.Curve.Params().BitSize + 7) / 4
 		if len(c) < (rLen + hLen + 1) {
 			err = ErrInvalidMessage
 			return
@@ -361,6 +361,6 @@ func (prv *PrivateKey) Decrypt(rand io.Reader, c, s1, s2 []byte) (m []byte, err
 		return
 	}
 
-	m, err = symDecrypt(rand, params, Ke, c[mStart:mEnd])
+	m, err = symDecrypt(params, Ke, c[mStart:mEnd])
 	return
 }
diff --git a/crypto/ecies/ecies_test.go b/crypto/ecies/ecies_test.go
index 9cd5c79f7e..f33f204d5b 100644
--- a/crypto/ecies/ecies_test.go
+++ b/crypto/ecies/ecies_test.go
@@ -270,7 +270,7 @@ func TestEncryptDecrypt(t *testing.T) {
 		t.FailNow()
 	}
 
-	pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil)
+	pt, err := prv2.Decrypt(ct, nil, nil)
 	if err != nil {
 		fmt.Println(err.Error())
 		t.FailNow()
@@ -281,7 +281,7 @@ func TestEncryptDecrypt(t *testing.T) {
 		t.FailNow()
 	}
 
-	_, err = prv1.Decrypt(rand.Reader, ct, nil, nil)
+	_, err = prv1.Decrypt(ct, nil, nil)
 	if err == nil {
 		fmt.Println("ecies: encryption should not have succeeded")
 		t.FailNow()
@@ -301,7 +301,7 @@ func TestDecryptShared2(t *testing.T) {
 	}
 
 	// Check that decrypting with correct shared data works.
-	pt, err := prv.Decrypt(rand.Reader, ct, nil, shared2)
+	pt, err := prv.Decrypt(ct, nil, shared2)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -310,10 +310,10 @@ func TestDecryptShared2(t *testing.T) {
 	}
 
 	// Decrypting without shared data or incorrect shared data fails.
-	if _, err = prv.Decrypt(rand.Reader, ct, nil, nil); err == nil {
+	if _, err = prv.Decrypt(ct, nil, nil); err == nil {
 		t.Fatal("ecies: decrypting without shared data didn't fail")
 	}
-	if _, err = prv.Decrypt(rand.Reader, ct, nil, []byte("garbage")); err == nil {
+	if _, err = prv.Decrypt(ct, nil, []byte("garbage")); err == nil {
 		t.Fatal("ecies: decrypting with incorrect shared data didn't fail")
 	}
 }
@@ -381,7 +381,7 @@ func testParamSelection(t *testing.T, c testCase) {
 		t.FailNow()
 	}
 
-	pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil)
+	pt, err := prv2.Decrypt(ct, nil, nil)
 	if err != nil {
 		fmt.Printf("%s (%s)\n", err.Error(), c.Name)
 		t.FailNow()
@@ -393,7 +393,7 @@ func testParamSelection(t *testing.T, c testCase) {
 		t.FailNow()
 	}
 
-	_, err = prv1.Decrypt(rand.Reader, ct, nil, nil)
+	_, err = prv1.Decrypt(ct, nil, nil)
 	if err == nil {
 		fmt.Printf("ecies: encryption should not have succeeded (%s)\n",
 			c.Name)
@@ -422,7 +422,7 @@ func TestBasicKeyValidation(t *testing.T) {
 
 	for _, b := range badBytes {
 		ct[0] = b
-		_, err := prv.Decrypt(rand.Reader, ct, nil, nil)
+		_, err := prv.Decrypt(ct, nil, nil)
 		if err != ErrInvalidPublicKey {
 			fmt.Println("ecies: validated an invalid key")
 			t.FailNow()
@@ -441,14 +441,14 @@ func TestBox(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	pt, err := prv2.Decrypt(rand.Reader, ct, nil, nil)
+	pt, err := prv2.Decrypt(ct, nil, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !bytes.Equal(pt, message) {
 		t.Fatal("ecies: plaintext doesn't match message")
 	}
-	if _, err = prv1.Decrypt(rand.Reader, ct, nil, nil); err == nil {
+	if _, err = prv1.Decrypt(ct, nil, nil); err == nil {
 		t.Fatal("ecies: encryption should not have succeeded")
 	}
 }
diff --git a/crypto/secp256k1/curve.go b/crypto/secp256k1/curve.go
index df80481857..6fdf2be6a4 100644
--- a/crypto/secp256k1/curve.go
+++ b/crypto/secp256k1/curve.go
@@ -77,7 +77,7 @@ func (BitCurve *BitCurve) Params() *elliptic.CurveParams {
 	}
 }
 
-// IsOnBitCurve returns true if the given (x,y) lies on the BitCurve.
+// IsOnCurve returns true if the given (x,y) lies on the BitCurve.
 func (BitCurve *BitCurve) IsOnCurve(x, y *big.Int) bool {
 	// y² = x³ + b
 	y2 := new(big.Int).Mul(y, y) //y²
@@ -290,11 +290,11 @@ func init() {
 	// See SEC 2 section 2.7.1
 	// curve parameters taken from:
 	// http://www.secg.org/collateral/sec2_final.pdf
-	theCurve.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16)
-	theCurve.N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16)
-	theCurve.B, _ = new(big.Int).SetString("0000000000000000000000000000000000000000000000000000000000000007", 16)
-	theCurve.Gx, _ = new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16)
-	theCurve.Gy, _ = new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16)
+	theCurve.P = math.MustParseBig256("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F")
+	theCurve.N = math.MustParseBig256("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")
+	theCurve.B = math.MustParseBig256("0x0000000000000000000000000000000000000000000000000000000000000007")
+	theCurve.Gx = math.MustParseBig256("0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798")
+	theCurve.Gy = math.MustParseBig256("0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8")
 	theCurve.BitSize = 256
 }
 
diff --git a/crypto/secp256k1/secp256_test.go b/crypto/secp256k1/secp256_test.go
index f6582ecd54..b608bcfcf1 100644
--- a/crypto/secp256k1/secp256_test.go
+++ b/crypto/secp256k1/secp256_test.go
@@ -49,7 +49,7 @@ func randSig() []byte {
 // tests for malleability
 // highest bit of signature ECDSA s value must be 0, in the 33th byte
 func compactSigCheck(t *testing.T, sig []byte) {
-	var b int = int(sig[32])
+	var b = int(sig[32])
 	if b < 0 {
 		t.Errorf("highest bit is negative: %d", b)
 	}
diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go
index 78b99c02b0..e8fa18ed47 100644
--- a/crypto/signature_nocgo.go
+++ b/crypto/signature_nocgo.go
@@ -87,6 +87,10 @@ func VerifySignature(pubkey, hash, signature []byte) bool {
 	if err != nil {
 		return false
 	}
+	// Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
+	if sig.S.Cmp(secp256k1halfN) > 0 {
+		return false
+	}
 	return sig.Verify(hash, key)
 }
 
diff --git a/crypto/signature_test.go b/crypto/signature_test.go
index 5e2efc7e05..aecff76bfb 100644
--- a/crypto/signature_test.go
+++ b/crypto/signature_test.go
@@ -75,6 +75,16 @@ func TestVerifySignature(t *testing.T) {
 	}
 }
 
+// This test checks that VerifySignature rejects malleable signatures with s > N/2.
+func TestVerifySignatureMalleable(t *testing.T) {
+	sig := hexutil.MustDecode("0x638a54215d80a6713c8d523a6adc4e6e73652d859103a36b700851cb0e61b66b8ebfc1a610c57d732ec6e0a8f06a9a7a28df5051ece514702ff9cdff0b11f454")
+	key := hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138")
+	msg := hexutil.MustDecode("0xd301ce462d3e639518f482c7f03821fec1e602018630ce621e1e7851c12343a6")
+	if VerifySignature(key, msg, sig) {
+		t.Error("VerifySignature returned true for malleable signature")
+	}
+}
+
 func TestDecompressPubkey(t *testing.T) {
 	key, err := DecompressPubkey(testpubkeyc)
 	if err != nil {
diff --git a/dashboard/README.md b/dashboard/README.md
index 84810f7173..641c5f44bc 100644
--- a/dashboard/README.md
+++ b/dashboard/README.md
@@ -9,31 +9,38 @@ The client's UI uses [React][React] with JSX syntax, which is validated by the [
 
 ### Development and bundling
 
-As the dashboard depends on certain NPM packages (which are not included in the go-ethereum repo), these need to be installed first:
+As the dashboard depends on certain NPM packages (which are not included in the `go-ethereum` repo), these need to be installed first:
 
 ```
-$ (cd dashboard/assets && npm install)
+$ (cd dashboard/assets && yarn install && yarn flow)
 ```
 
-Normally the dashboard assets are bundled into Geth via `go-bindata` to avoid external dependencies. Rebuilding Geth after each UI modification however is not feasible from a developer perspective. Instead, we can run `webpack` in watch mode to automatically rebundle the UI, and ask `geth` to use external assets to not rely on compiled resources:
+Normally the dashboard assets are bundled into Geth via `go-bindata` to avoid external dependencies. Rebuilding Geth after each UI modification however is not feasible from a developer perspective. Instead, we can run `yarn dev` to watch for file system changes and refresh the browser automatically.
 
 ```
-$ (cd dashboard/assets && ./node_modules/.bin/webpack --watch)
-$ geth --dashboard --dashboard.assets=dashboard/assets/public --vmodule=dashboard=5
+$ geth --dashboard --vmodule=dashboard=5
+$ (cd dashboard/assets && yarn dev)
 ```
 
-To bundle up the final UI into Geth, run `webpack` and `go generate`:
+To bundle up the final UI into Geth, run `go generate`:
 
 ```
-$ (cd dashboard/assets && ./node_modules/.bin/webpack)
-$ go generate ./dashboard
+$ (cd dashboard && go generate)
 ```
 
+### Static type checking
+
+Since JavaScript doesn't provide type safety, [Flow][Flow] is used to check types. These are only useful during development, so at the end of the process Babel will strip them.
+
+To take advantage of static type checking, your IDE needs to be prepared for it. In case of [Atom][Atom] a configuration guide can be found [here][Atom config]: Install the [Nuclide][Nuclide] package for Flow support, making sure it installs all of its support packages by enabling `Install Recommended Packages on Startup`, and set the path of the `flow-bin` which were installed previously by `yarn`.
+
+For more IDE support install the `linter-eslint` package too, which finds the `.eslintrc` file, and provides real-time linting. Atom warns, that these two packages are incompatible, but they seem to work well together. For third-party library errors and auto-completion [flow-typed][flow-typed] is used.
+
 ### Have fun
 
 [Webpack][Webpack] offers handy tools for visualizing the bundle's dependency tree and space usage.
 
-* Generate the bundle's profile running `webpack --profile --json > stats.json`
+* Generate the bundle's profile running `yarn stats`
 * For the _dependency tree_ go to [Webpack Analyze][WA], and import `stats.json`
 * For the _space usage_ go to [Webpack Visualizer][WV], and import `stats.json`
 
@@ -44,3 +51,8 @@ $ go generate ./dashboard
 [WA]: http://webpack.github.io/analyse/
 [WV]: http://chrisbateman.github.io/webpack-visualizer/
 [Node.js]: https://nodejs.org/en/
+[Flow]: https://flow.org/
+[Atom]: https://atom.io/
+[Atom config]: https://medium.com/@fastphrase/integrating-flow-into-a-react-project-fbbc2f130eed
+[Nuclide]: https://nuclide.io/docs/quick-start/getting-started/
+[flow-typed]: https://github.com/flowtype/flow-typed
diff --git a/dashboard/assets.go b/dashboard/assets.go
index ef2cf6ac9a..521d134a6a 100644
--- a/dashboard/assets.go
+++ b/dashboard/assets.go
@@ -1,16 +1,13 @@
-// Code generated by go-bindata.
+// Code generated by go-bindata. DO NOT EDIT.
 // sources:
-// assets/public/bundle.js
-// assets/public/dashboard.html
-// DO NOT EDIT!
+// assets/index.html
+// assets/bundle.js
 
 package dashboard
 
 import (
-	"bytes"
-	"compress/gzip"
+	"crypto/sha256"
 	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -18,29 +15,10 @@ import (
 	"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
+	bytes  []byte
+	info   os.FileInfo
+	digest [sha256.Size]byte
 }
 
 type bindataFileInfo struct {
@@ -69,43 +47,38395 @@ func (fi bindataFileInfo) Sys() interface{} {
 	return nil
 }
 
-var _publicBundleJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x7d\x57\x1b\xb9\x93\x28\xfc\xf7\xf0\x29\x94\xdc\x59\x6c\x27\xc6\x60\x92\xcc\x0b\x0c\x93\x25\x84\x64\xd9\x9b\x84\xdc\xc0\xcc\xdc\x3d\x2c\xd7\x91\xbb\x65\x5b\xa1\xdd\xf2\x74\xb7\x01\xff\x02\xdf\xfd\x39\xaa\xd2\x7b\x77\x1b\x63\x9c\xf9\xed\xec\xb3\xe4\x9c\xd8\x96\x4a\xa5\x52\xa9\x54\x7a\x2b\x55\x6d\x3e\x81\xbf\x4d\xd2\x1c\x4c\xd3\xa8\xe0\x22\x6d\x8e\x45\x3c\x4d\x58\xde\x22\x5f\xc9\xe6\x26\xb9\x62\xfd\x09\x8d\x2e\x5e\x09\x51\xe4\x45\x46\x27\x6b\xa6\xc4\x77\x9b\x9b\xe4\x74\xc4\x08\xc2\x93\x88\x46\x23\xe6\xe4\x5e\xd2\x8c\xf0\x34\x2f\x68\x92\xb0\xf8\x3d\xe2\x24\x7b\xe4\xeb\xed\xae\x01\x2a\xe3\xca\xd8\x9f\x53\x9e\x31\xa2\x89\x71\x20\x74\x12\xe9\xf5\x14\x4d\x3d\x05\xdd\xeb\x29\x9a\x8f\xe2\x16\xf9\x5a\x85\x5d\xa2\x3f\x18\xb1\xe8\x82\xf0\x81\xa6\x97\xe7\x84\xa7\x25\xaa\xbf\xe3\x83\x66\x48\xf5\x99\xc6\x7e\xee\xa2\x27\xdf\x7d\xf7\x5d\xc6\x8a\x69\x96\x96\x9a\x69\x0b\x74\xd8\xf5\x44\x64\x45\xbe\xeb\x16\xbb\x0d\x29\xcb\x18\x2d\x18\xa1\x24\x65\x57\x9a\xba\x26\x4d\x63\x32\x99\x16\x84\x17\x84\xa7\x85\x20\xc5\x48\xb1\xb8\xe5\x96\x96\x4c\x56\x25\xf6\xe6\x90\x21\xf9\xee\x11\xce\x77\x88\xce\x6c\x7b\x19\xc9\x0e\x19\xd0\x24\x67\x7e\xaa\x6a\xc5\x0e\xf9\xea\xd1\x5e\xdd\x95\xb2\x49\x87\xd7\x2c\x9a\x16\x0c\xa8\x56\xf4\x55\x74\xe9\x77\xe3\x12\xbf\x22\x9a\x24\xaa\x37\x35\xef\xda\x0a\x83\xfe\xb4\xe9\x15\x92\xd0\xaa\x25\xe9\x4d\x42\x87\x2e\x3d\x34\x27\x89\xa0\x31\x8b\xcb\x04\x75\x12\xb2\x47\x8a\x6c\xca\x6a\x91\x7d\xc2\x8e\x97\xe8\x14\x35\x44\x0c\x1c\xec\x2e\xb8\x12\x12\x9f\x78\x57\x20\x6e\xcb\xb5\xf8\x23\x43\x96\xc9\x5d\x66\xe6\x44\xf4\xbf\xb0\xa8\x20\x4d\xcb\x02\x95\xd3\xeb\xb9\x02\x52\xc1\xa1\xce\x98\xec\x69\x34\x75\x43\xb1\x54\x61\x69\x9c\x54\x21\x8e\x2a\x64\xb0\xae\x86\x98\x0d\x78\xca\xc8\x90\x15\x05\xcb\x8c\x6c\x90\x81\xc8\xc8\x88\x66\x63\x91\xce\x34\x63\xef\xa8\x34\x26\x7b\xa6\x78\xd3\x48\x46\x4a\xc7\xac\xad\xb0\x07\x83\x96\x0f\x9a\x8f\xaa\x10\x09\xbf\x74\x2b\x1c\xeb\xc7\xc0\xf1\x0e\x12\xfe\x31\x13\x13\x96\x15\xb3\xb0\x46\xbf\xc8\x77\x91\x48\x07\x7c\x38\xcd\x68\x3f\x61\x95\x03\xeb\x3b\x96\x4e\xc7\x4c\xe5\x4b\x89\x0b\xb2\x87\xac\xd8\x51\xcd\xf0\x32\x6e\x5b\xb5\x1a\xa5\x56\xbf\x0e\x59\xf1\x9a\x0d\xe8\x34\x29\x0e\x81\x68\x9f\xeb\x91\x18\x4f\x68\xc1\xfb\x3c\xe1\xc5\x8c\x5c\xf1\x62\x44\x52\x91\x6e\xe8\xce\x50\x02\x73\x47\x67\xa4\x6e\x67\x60\x91\x80\x8d\x52\x61\xa9\x4e\xd7\x52\x48\xd6\xd7\xf5\xe0\xe8\xf5\x58\x8e\x82\x43\x5e\x7a\xed\x35\xa4\xda\x46\x34\xe5\x04\xe5\x8d\xad\xb3\x46\x8c\x59\x8d\xf3\x5d\x72\x4b\x76\x6a\x31\x60\x15\xc8\x85\xbc\x8c\x67\x97\xdc\x7a\xdc\xad\x14\xbb\x26\xb6\xa2\x4d\x1a\xb4\x61\x24\x6d\xb7\x62\xdc\x63\xd6\xee\x22\x3d\xa4\x44\x6c\x92\x89\x42\x14\xb3\x09\xeb\x8c\x68\x7e\x7c\x95\x6a\x61\x03\xe5\x78\x47\x0f\x08\xb7\x07\x50\x49\xb4\xc9\x44\x21\x70\x5a\xba\x48\x55\xe5\xf2\x1e\x67\x7c\xda\x2d\x31\x93\x69\x3f\xe1\x51\x6f\x42\x8b\x51\xaf\x77\x07\xb9\x13\xb2\x47\x1e\x3f\xae\xc3\xf9\x4e\xd0\x98\xb0\xb4\xc8\x66\x46\x69\xa7\xb1\x6e\x41\x59\x3d\xa8\x8c\xaa\xf5\x41\x55\xdd\x72\x35\xf2\x7c\x6b\xdb\xed\xb4\x5b\xa3\x3b\x1f\xfe\xe7\xb4\xa5\x79\xb6\xb6\xf9\x84\x6c\x11\x95\x56\x5e\x6c\xb5\xc9\xdc\x39\x8d\x7c\x5d\x93\x08\xfe\x38\x7c\xf5\x71\xff\xe0\x7f\x93\xdf\xf7\x3f\x91\xa3\x0f\xff\x7e\x78\x70\x7a\x74\xfc\x81\x3c\xd9\xb4\xd8\x26\x99\x88\x58\x2e\x97\x6e\x9b\x4f\x9e\xac\x91\x27\xe4\x40\x4c\x66\x19\x1f\x8e\x0a\xd2\x8c\x5a\x64\x7b\xab\xfb\x6c\x63\x92\xb1\x9c\xa5\x45\x9b\xbc\xa1\x11\xeb\x0b\x71\xd1\x26\x47\x69\xd4\x59\x23\x50\xe0\x74\xc4\x73\x92\x8b\x69\x16\x31\x12\x89\x18\x96\x49\x09\x8f\x58\x9a\xb3\x98\x4c\xd3\x98\x65\x30\x2b\xbc\x3f\x3a\xd5\xc9\x64\x20\xa6\x69\x2c\xd7\x52\xc5\x88\x49\x14\xef\x8e\x0e\x0e\x3f\x9c\x1c\x92\x01\x97\xab\x2c\x9c\x24\x33\x21\x0a\x12\xf3\x8c\x45\x85\xc8\x66\x38\x57\xda\x8a\x8a\x8c\x31\x49\xc0\xe6\xda\x1a\x1f\x10\xdd\x8a\x0e\x4b\x2f\x3b\x1f\x8e\x5f\x1f\xf6\x0e\x3f\xfc\x4e\x1e\xed\xed\x91\xc6\x24\x13\xf1\x14\x9a\xda\x90\x4c\x21\x44\xaa\x93\x4f\x87\xfb\x07\xa7\xbd\xc3\x77\x87\xef\x0f\x3f\x9c\xf6\x4e\xff\xe3\xe3\x21\xd9\x23\x4d\x29\xd4\x62\x40\x4e\x66\xe3\xbe\x48\xc8\x9e\x2c\xad\xd9\xd4\x20\xeb\xeb\x6b\x84\x10\x95\xd9\x91\xea\xaf\x94\xd2\x6c\x64\x8c\x46\x45\x87\x25\x6c\xcc\xd2\xa2\xd1\x6a\x91\x9b\x1b\x80\xd9\xba\x66\x34\xfa\x71\x77\x4d\x55\xcf\xf3\xdf\x69\xc2\xe3\x43\x84\x2b\x0f\x3f\x24\x94\x68\xb1\x55\x74\xa9\xf9\x1b\xe8\xc2\xef\x86\x2a\xa2\x33\x65\x93\xd3\x69\x92\x84\x19\x9d\xef\xbf\x57\x58\x64\xf1\x72\xf3\x77\xd7\x88\x1c\xa7\x6b\x44\xae\xdf\x5f\xc1\x44\x9a\xf0\x88\x17\xc9\x8c\x4c\x73\x9e\x0e\xc9\x67\x39\xa0\x37\x24\x8e\xfc\x33\x99\x89\x29\xa1\x19\x23\x62\x52\xc8\x3c\x58\x6c\xca\x85\x68\xcc\x2e\x59\x22\x26\xd0\xa8\x3e\x1b\xd1\x4b\x2e\xb2\x0e\xe2\x1c\x15\xc5\x64\x67\x73\x73\xd0\xef\x8c\xd9\xa6\xc5\xb5\xc1\xd3\x0d\xd9\x43\x8a\x31\xc5\x28\x13\x57\xc7\xe9\x6b\xe8\xf5\xfd\x48\x76\xa9\x59\x56\x91\x60\x39\x44\xf6\x2a\x87\xed\xf3\xe7\x2f\x5a\x4d\x9f\xc1\xed\x2a\xbc\xad\xdd\xb5\x5b\xc2\x92\x9c\x01\xaf\x1f\xd2\x6a\x2b\x61\xf7\x6f\xf4\x82\x4d\xfa\xa1\xd5\x94\xf4\xce\x1d\xd2\xb7\xa8\x80\xe7\x69\x85\xe6\xb3\x56\xab\xb5\xa6\x14\xca\x6d\x4b\x2e\x1c\x48\xf7\x41\x2a\xe6\xf1\x34\x67\x24\x2f\x32\x1e\x15\xa0\x92\xef\xa5\x70\xe6\x0c\xdd\xbd\xca\xa1\xbb\x18\xb7\xb6\x9e\xf9\x7d\xbb\x60\xa9\xe7\xdf\x8a\xc3\xdb\x0f\xe2\xb0\x1c\x16\xbd\x9e\x22\xa9\xb7\xff\xfe\x75\xef\xf5\xe1\x9b\xa3\x0f\x87\xbd\xfd\x4f\x9f\xf6\xff\xa3\xd7\x6b\x57\xe7\x7e\x3a\x3c\xf9\xed\xdd\x69\xaf\xb7\xbb\xf9\xe4\xd1\x1a\x29\x2b\xf5\x1f\xc8\xbf\xb3\x98\xfc\x41\x8b\x5c\xa4\x52\x5a\xdf\x55\x2b\x6c\x95\x4c\x9a\xef\x8f\x4e\x5b\x6d\x92\x33\xb6\x46\xb4\x58\x7f\x61\xf1\x15\x96\x1f\xf2\x62\x34\xed\x77\xb8\xd8\x8c\x12\x9a\xe7\x72\x5d\x9b\xaf\x41\xa3\xc9\x30\x11\x7d\x9a\xe8\xb5\xbb\x54\xd7\x86\x07\x44\x2e\xa3\xd6\xbe\x6b\x58\x11\x6a\xec\xae\xad\xc1\x72\x0f\x57\x16\xb0\xf5\x0f\x56\x19\x12\xc2\x20\x80\xda\x3e\xc8\xda\x14\x2e\x28\x0c\xa9\x70\x70\x70\x76\x2e\xc1\xbf\x93\xca\xba\x09\x7a\x97\xec\x91\xad\x5d\xc2\xc9\x2f\x84\x66\xc3\xa9\xd4\x0d\x79\x27\x61\xe9\xb0\x18\xed\x12\xfe\xf4\x29\xe2\x00\x24\x34\x1b\x92\x3d\x0b\x75\xc6\xcf\x77\x65\x96\x14\xd8\x47\x34\x1b\xb6\x48\x24\xd2\x82\xa7\x52\x31\x39\x45\x4e\x67\x13\xb9\xab\x56\xaa\x96\x66\x43\xcc\x95\xa5\x4c\xae\x94\x6c\xd9\xdc\x74\xd8\x20\x37\x37\xc4\x4b\x4f\xa7\xe3\x3e\xcb\x1a\x8a\x8e\xef\x54\x4b\x3a\x93\x69\x3e\x92\x08\x5a\x40\x83\x12\x6d\x89\x74\x3f\xcb\xe8\xac\xc3\x73\xf8\x04\x88\xca\xa2\x96\x4f\x1d\x3a\x99\x24\xb3\xa6\x9c\x22\xda\x04\xe0\x43\x94\x1e\x3d\x6a\x9a\xd1\x48\x0d\x23\x2f\xd8\x4c\x4e\xd3\xc0\x08\xcc\x82\x36\x62\x57\xe1\x28\xa1\xd9\xb0\x2d\xe1\x5a\x72\xad\x4e\xb3\xe1\xd9\x05\x9b\x9d\x1b\x68\x9f\x3e\x09\xb6\x8b\x19\xb7\x6b\xe6\x7f\xf9\xdf\xad\xe4\x9f\x9a\x06\x75\x91\x2f\x82\xa7\xcd\x06\x69\xc8\x22\x32\x5f\xd6\xac\x38\xae\x96\x7c\x30\xf1\x4b\x41\x96\x42\x17\x37\x9c\xdd\x82\x1a\x6e\x48\x47\x49\x31\x58\x3e\x49\xd4\x96\x27\x72\x02\xc2\x22\x9b\x9b\x24\x63\x43\x9e\xcb\xcd\x08\xcd\x49\xc3\xca\x7b\xa3\x2d\x45\x22\x97\x59\x69\xa1\x36\x43\x93\x31\x91\x23\x9a\x0e\x19\xec\xf5\xd6\xbe\xfb\xee\x51\x73\xde\x58\x06\x91\xbd\x63\x40\x3b\xab\x05\x2d\xf4\x1e\x83\x34\xf9\xdf\xdd\xaa\xbe\x76\x34\x4c\x7d\xcd\xad\x36\xf0\x7d\x7e\xcd\x92\xad\x86\xab\x92\xa9\xcd\x0a\xd5\x3a\x07\x01\x08\x9b\x51\xcc\xdf\x7d\x77\xc5\xd3\x58\x5c\x75\x9c\x51\x1c\x76\xc1\xda\x6d\x53\x16\x0a\x14\xea\xb3\x05\x14\x2a\x2e\x80\x37\x49\x3e\xe2\x63\xd8\xac\xe2\x84\xae\x26\x1b\x29\xbc\xfd\x4c\x5c\xe5\x2c\x03\x05\xab\x93\xf7\xca\x93\xc5\x57\xb9\x2c\xda\xdc\xc4\xd3\x8c\x98\x0c\x32\x31\x26\x57\x23\x5a\xb0\x4b\x96\x69\xed\xc6\x73\xa2\x96\xc8\x24\x17\xa4\x18\xd1\x82\x14\x2c\x2f\x48\x36\x4d\x53\x96\xe5\x98\x92\x17\xd3\x3e\xe1\x85\xc4\x15\x8b\xb4\x51\x90\x7e\xc6\xe8\x85\x5c\xd4\xa6\xc3\xbc\x43\xc8\xab\x69\x41\xae\x18\x49\x19\x8b\x49\x21\xc8\x55\x46\x27\x78\x92\x47\x28\x91\xdb\x99\x88\x16\xd1\x08\xcf\x1f\xa5\x58\x16\x84\xe7\x12\x97\x84\x9b\x30\x58\x4c\xa3\x12\x95\x4d\x50\x0b\xf1\xab\x11\x8f\x46\x24\x16\x2c\x97\xf5\x29\x1d\x4c\xd3\x99\xa2\x5b\xd6\x7a\x54\x34\x24\x37\x72\x1e\x33\x42\x25\x3e\x23\x5c\x7d\x16\x51\xa9\x9a\x8b\x6c\xb6\x09\x75\xb3\x9c\xc4\x4c\x2e\x7e\xc6\xfc\x1f\xb0\x4a\x8f\x58\x56\x50\x9e\x12\x96\x0e\x79\xca\xf2\x0e\x4e\x56\xc8\xa8\x13\x56\x9c\xf2\x31\x13\xd3\x62\xd7\x49\x3d\x48\x18\xcd\x4c\xfa\x9a\xa9\x4b\x6d\xc2\xb1\x90\x98\xc2\x46\x1d\xd6\xaf\xb0\x70\x83\x55\xd6\x61\x96\xc9\x15\x76\x6e\xf0\xca\x49\x82\xa4\x42\xae\x34\x59\x4a\xf4\x58\x87\x49\x3c\xc4\xeb\x56\x4b\xea\x71\x47\x2e\x58\x3d\xf6\x60\x02\x03\x54\xd9\x4c\x7d\x93\x7f\x8e\x42\x72\xc8\xf5\xf7\x13\x2d\x07\x5e\xfe\x85\x5c\x23\x7b\x4e\xd9\x5d\x03\xea\x2c\x6b\xe6\x96\x0d\x19\xea\x60\x58\x43\x3c\x28\x4e\x4d\xe6\x12\xb2\x30\xa2\xdb\xf9\xad\xf6\x18\xb9\x48\xbb\xbd\x0e\xda\xf3\xca\x2f\xd4\xf6\xa0\x7c\x45\xb7\xdf\x87\x01\x8b\x62\xbb\x5d\xbb\x25\xcd\x56\xcb\x8a\x5b\x36\x4d\x15\x80\x94\x11\x8d\x58\x32\xa6\xcc\xd9\x3d\xb7\x83\x5d\x1a\x36\x37\x53\x91\x8d\x69\x42\x58\x7a\xc9\x33\x01\xcb\x0f\x18\xdd\x34\x65\x24\xe7\xc5\x94\xca\xba\x72\x03\xaf\x94\xbf\x45\x26\xeb\x6e\x93\xad\x96\xdb\x55\x9b\x9b\x92\x0c\x47\x1a\xaf\x28\xe8\x04\x7a\x49\x79\x42\xfb\x09\x23\x7d\x4c\x24\x09\x85\x93\x36\x25\xf1\xa6\x01\xd5\x2d\x08\xa5\x43\x2e\x68\x1e\x85\x90\xb0\x02\xa8\x6e\xeb\x82\x52\xbf\x50\x13\x7d\x69\x94\x9a\x71\xc4\x52\xfc\x2f\x17\x63\xd6\x17\xf1\x0c\x06\x75\x1e\x65\xec\x8a\xc5\x38\x45\x3b\x1c\x91\x0c\x48\x05\x39\xea\x1c\x76\xc8\x98\xc6\x71\xca\xf2\x12\x93\x43\x7a\x03\x3a\x50\xa6\x9a\xac\x65\xe9\xf0\xa9\x52\x94\xfd\x01\x94\x31\xd8\x4d\xf2\x14\xab\x94\xd5\xcb\x55\x77\x1e\x65\x7c\x82\xea\x07\x54\x0f\xbb\xa4\x09\x8b\xe5\xbc\x02\x60\x5a\x99\x17\xd9\x34\xc7\x02\x6a\x0e\x52\x07\x00\xd0\xde\x08\x8e\xd3\x09\xca\x51\x32\xf3\xaa\xaf\x69\x09\x2e\xda\x70\x5d\xe8\x35\xaa\xae\x61\xaa\x29\x39\x1d\xc3\xbd\x08\xed\x8b\x4b\x25\x44\x92\x02\x2e\xa7\x15\x4a\x2e\x59\x96\xcb\x81\x21\x06\x48\x3d\x4c\x84\x63\x49\xf9\x88\x5e\xb2\x0a\xf2\xe5\x4c\xdd\x28\x46\x5c\x2e\xa7\x46\x62\x32\x98\x26\xc9\x8c\x88\x69\x06\xcb\x6d\x76\x5d\x90\x48\x64\x72\x0f\x4f\x44\x31\x62\xd9\x15\xc7\x99\xf0\x8a\x27\x89\x52\xe7\x54\x23\x64\x52\xa7\x2f\xde\x72\x59\x67\x55\xcb\x95\x80\xad\xb9\xb3\x4a\x36\x4d\x5d\x65\xd0\x1c\xd3\xec\x02\xef\x0c\xfc\xe1\x7e\x10\xaa\x41\x57\xaf\xad\x60\xc8\x47\x15\x44\x94\x07\xbd\xa7\x8c\x97\x1c\xf6\xa5\x96\x54\x4d\xac\x76\xec\x1f\x78\xed\x5c\x5f\xaf\x6d\xf8\x3d\xb4\xff\x82\x6d\xfe\xeb\xb4\x40\x95\x08\xec\x86\x73\xcb\xb7\x57\x04\x2b\xd2\x04\x6e\x6b\x5c\x5d\xe0\x35\xac\xb6\x71\x7f\x0b\x65\xd0\x09\xc9\x3d\x11\x63\xa6\xa9\xca\x0d\x59\x40\x4c\xcc\x07\x03\x96\xc9\x05\x7d\x06\x77\xa7\x70\xdd\xe5\x8a\xe9\x65\xee\x48\xcd\x7d\xd8\x8a\x8a\xa6\xcc\x56\xa3\x68\xd6\x6e\x61\xc1\xfc\xe7\x94\x4d\x99\x3a\xc3\x90\xbf\xe3\x8c\xf2\x54\x6e\x61\xf6\xf0\x52\x50\x2d\xab\xa7\x99\xa4\xf2\xff\x48\xe0\x5d\x5b\xee\x28\x8d\xd9\x35\xd9\x23\x1b\x5d\x77\x95\x2d\x1b\x90\xfe\x36\xf9\xc0\xae\x8b\x53\x1e\x5d\x34\x5d\x8d\xf5\xc8\xe0\x87\x61\xec\xa0\x75\xc7\x2b\xb6\xcd\x1d\x6f\x65\xb2\x8c\x0e\x74\x70\xa8\x43\x16\x17\x95\x6e\x9f\x07\x16\x89\x34\xa2\x45\x13\xf2\xcc\x60\x0a\x56\x7d\xa5\x06\x5a\x62\x64\xb5\x7f\xd6\xd4\x07\x84\x42\x2d\x4d\xa3\x30\x6e\xdd\x2d\x88\x93\xef\xf0\x45\xb7\x6f\x3e\x17\xe0\xec\xda\x28\x30\x67\x19\x18\xb0\x5c\xd5\xec\x30\x0d\xcf\xb6\x0d\x92\x84\xa5\x64\x8f\xb8\x6d\xc0\x12\x57\x23\x9e\xb0\x66\xc2\x52\x4f\x7b\x3a\xac\xd3\xa5\x76\x4b\x0c\x96\x02\xa4\xd3\x00\x0d\x69\x3e\x7d\xea\x30\xf1\x17\x12\xa0\xad\xea\xc0\x30\x3f\xac\xfe\xcc\x22\x3c\xef\x64\xd3\xb4\xe9\x88\xb6\x65\x93\xff\xad\xb2\x23\xe5\x5f\x1d\x13\xb0\x68\xd0\x6a\xa9\xa6\x4a\x5c\x75\x44\x31\x9c\xac\x55\x37\xe1\x61\xaf\x3e\x7b\x4e\x55\xff\x78\x87\x2b\xce\x12\x5e\x1d\xef\xe5\xb2\x3e\x76\x45\xcc\x71\x9b\x77\x84\x48\x36\x48\xb7\x65\xe5\xbf\x94\xfd\x2b\xe9\xba\x6c\xf4\x4e\x25\xbb\x77\x9c\x4a\xba\xbc\x94\x84\x9c\x71\x59\xdb\x79\xe9\x88\x32\x54\x27\x86\xcf\x78\xd0\x26\x89\x3f\x2a\xd8\x18\xd7\xad\x12\x51\xcb\xa1\xd8\xe5\x38\xcc\xf2\x5d\x39\x77\x3f\xaa\x1c\x02\x56\xc4\xed\xc0\xb1\xe3\x0a\x8f\x4c\x2e\x7f\x22\x09\xbf\x60\x70\x38\x12\xf3\xa8\xe0\x72\xc1\x81\xba\x3d\xb7\x03\xcf\xa5\x27\xa3\x33\xbb\x3b\xe7\x79\x67\x30\x55\xe6\x01\xbb\x36\x0d\xa0\xa0\xe1\x19\x9d\xc9\x5e\x94\x08\x9c\x5b\xe9\x6c\x9a\x96\xce\xc8\x5c\x84\xde\x11\xa8\xc5\x28\x05\x62\xd7\x08\x44\xc1\x0b\xb0\x8f\x6a\xa8\x53\xa2\x86\xcd\x52\x29\x66\xec\x3a\xf7\x17\xea\xb8\x48\xa7\xd0\x6c\x78\xa9\x06\xa0\x4e\xd2\x73\xe0\x1e\x69\x34\x76\xe5\x1c\xc4\xc6\x93\x62\x46\xf0\x3c\x98\x14\x82\xd0\x4b\xc1\x63\x92\xb1\x21\xbb\x9e\x10\x9e\xe7\x53\x96\x87\x85\xcd\xa9\x94\x69\x63\x2a\xc4\x44\xb6\xd3\x91\x68\xa8\x43\xa6\x3b\xe4\xc4\xf1\x3b\x38\x9e\x04\xe2\xfd\x3c\x91\x46\xac\x9c\x38\x18\x94\xd2\x32\x36\x16\x97\xac\x16\x0f\x66\xef\x27\x89\x86\xc8\x4b\x20\x6c\xcc\x8b\x52\xe2\x24\x63\x13\x96\xd6\xd3\xa7\xf2\x8f\xd3\xa8\x5c\xb7\x01\x4a\x9c\x3a\x6d\xff\x83\x65\x8e\xb5\x62\x38\x3b\x27\x0e\x9b\xfa\x3c\x8d\x95\xca\x08\x0b\x54\x9f\x11\x85\x05\x39\x9e\x12\xe5\xd3\xc9\x44\x64\x85\x3a\x22\x72\x68\x8a\xae\xe2\x50\x1a\x35\x25\x8d\xcd\x06\x71\xa4\x25\x1a\xc5\x3c\xf3\x60\x63\x9e\xdd\x49\x07\x96\xaa\xa1\x42\x03\x4d\xc7\x34\x77\x75\x9b\x4b\xc5\x16\x18\x68\x04\x27\xac\xcf\x57\x78\x29\xb8\xb6\xa6\x0a\xb8\xa6\x3a\x66\xe2\x83\xeb\x2d\x9a\xe7\x7c\x98\xd6\xdc\xcc\x6d\x3f\x7b\xd1\xf2\x01\xb7\x25\x24\x4f\x0b\x96\x89\xc9\x27\x84\xd3\x06\x3e\x0a\xa2\xe5\x8e\x8e\x1a\x50\xd1\xff\xe2\xb0\x41\xf4\xbf\x48\x65\x27\xfa\x5f\x3c\x8b\x22\x48\xdf\x21\x5f\xf5\x86\x67\x07\x12\x6e\x77\xa5\x0c\xe9\x66\xa9\x2c\x49\x94\xa2\xcf\x24\xdd\xdc\x38\xdd\x59\xd0\x6c\xc8\xd4\xf6\xe7\xde\xca\x5f\xc2\x2a\xd3\x87\x50\xe7\xaf\x79\xb3\x89\xba\x9a\x41\x58\xab\xb2\xa5\x7e\x5f\xc8\x80\x07\x0b\xe2\xd5\x8d\xab\xf1\x91\x7a\xb8\xc5\x21\x7b\x0a\x3d\xfc\xd2\x93\x8e\x9d\x72\x6e\x25\x49\xda\x76\x01\x8a\xe1\x98\xf0\x44\xec\xc5\x5f\x26\x62\xe5\x7e\xb2\x7d\x22\xfa\x5f\xa0\xa9\xb9\xb5\x0d\x41\x8a\xb5\x8e\xf5\xba\x8a\x83\x9c\xb8\xcb\x43\x59\xb4\xc3\xe5\x1a\xe6\x78\xd0\xe4\x2d\xf2\xeb\x1e\xd9\x72\xef\x06\x35\xdc\xa3\x45\x8d\xa7\xda\x84\xb7\x42\x04\x8a\xf5\x5c\x32\x5e\xf4\xbf\xa8\x89\x7e\x21\x2e\xff\xf0\xcf\xbc\xdd\xbf\xc3\xfc\xf1\xb1\xed\xac\xc7\x6d\xc5\xfe\x64\xaa\x8c\x1a\xd7\x6e\x5b\xbb\xa6\xe7\xf2\x11\x63\x45\xfe\x9e\xa6\x74\x08\x7a\xdf\x5c\x42\x69\xbd\x20\xbb\xa1\x46\x7d\x3c\x7b\xd6\x72\xa1\xe6\xe9\x0e\x90\x03\x0d\xcc\xae\x0b\x96\xc6\x08\x5f\x65\x2f\x10\x02\x3e\x9b\x83\x58\xe3\x32\x65\x86\xac\xf8\xa8\x25\xe1\x78\x50\x53\xc5\x4f\x35\xe0\xf3\x9a\xe0\x43\x1a\x04\x70\xab\x76\x40\x93\x04\x2c\xda\xeb\xda\xf4\x73\x0d\xfc\xbc\xa6\x05\x98\x2d\x06\x30\x50\x3f\x90\xb9\x75\xd5\x75\xb7\xaa\xa0\xe7\x56\xe6\x20\x35\x65\x27\x22\xcf\xe5\xca\xf2\x40\xa4\x79\x91\x4d\xa3\x42\x64\x68\x6a\x5d\x5b\x6f\xf7\xee\xb2\xf3\xa8\xa8\xaf\xd0\xe0\xe5\xe9\x88\x65\xbc\xa8\x6f\x7a\x19\x74\x5e\x8d\x06\x9d\x29\x85\xab\xe8\x3f\x78\x31\x12\xd3\x42\x0d\x2d\xce\x6a\xeb\x7b\x71\x57\xc1\x79\xb5\xd7\xd5\x65\x70\x8e\xe9\xa4\x6e\x94\xbc\xe8\xba\x50\xf3\x24\x77\x4c\x27\x16\x94\xa7\x27\x74\xc0\x8e\xd2\x82\xe1\x80\xaf\xc4\xfd\xc3\x8f\x35\x05\xe6\x56\xe3\x41\x1a\x04\x60\xb8\x57\xd7\x59\x3e\xd4\x3c\xec\x00\x60\xa5\x2b\x13\x93\xd3\xd9\x84\xd5\xa9\xa6\xad\x32\xe4\x3c\xe4\x06\xc8\x14\xbb\xa2\x99\xda\xf0\x56\xd2\xfd\x3c\x04\x9c\x87\x5d\x81\x98\x22\x23\xc1\xf3\xe2\x83\x48\x3f\xc9\x26\x9d\x14\xb4\xe0\x51\xad\xed\xd4\x8f\x5b\x73\x8b\xcd\xab\xb6\x0a\xde\x92\x9d\xd1\xc9\x6b\x9e\x4f\x12\x3a\xfb\x40\xc7\xac\xa6\xfa\x1f\x9f\xd7\x15\x98\xdb\x5e\x1f\xd4\xd5\xb5\x77\x57\xb9\xfd\xe2\x87\x9a\x02\x77\x28\xe7\xaa\x1a\xd5\x69\xe6\x3c\x49\x79\xfe\x63\xb7\x12\x7c\x5e\x6d\x2e\x9c\x29\xfc\x25\xaf\xab\x62\xfb\xc5\x4f\x2e\xd4\xc7\x8c\xe5\xc6\x6e\xbe\x8e\xaa\x9f\x7e\xac\x2d\x32\x8f\xb2\x10\xd6\x20\x49\xeb\x89\x33\x35\x21\x8c\x8f\xf9\x0f\x9e\xc4\x11\xcd\xe2\x66\x2f\xcd\x83\x39\xe5\xfd\x94\x9f\x8e\x58\x6d\x47\x76\x7f\xfc\xb9\xa6\xc0\x5c\xd6\x7a\x90\x06\x41\x21\x7f\x39\xdb\xd3\xea\x0a\xb7\xab\xe1\xe7\xd5\xe7\x01\x06\xf4\xbe\x95\x69\x7a\x56\x9c\x23\xb2\x2f\xba\x2f\xee\x2a\x79\x77\x93\x4b\x45\xdc\x51\x70\x52\xcc\x12\x96\xc3\xcb\x34\x51\xd7\xfc\x17\xdd\x1f\x6a\x8b\xdc\x31\x74\x3c\xd8\x79\x1b\x3c\x23\x0d\x6a\x87\x27\xd7\xdf\x95\xdb\x3b\x7f\xfb\xb7\x6b\x8e\x9a\x61\x1b\x90\xb2\xab\xe3\xfe\x17\xdc\x06\x18\x14\x8f\xf0\xbc\x51\x16\x0c\x37\x5c\x4e\x65\x8b\xaf\xf5\x71\x93\x85\x55\xe9\xad\x95\x50\x5f\x25\x3d\xb7\x2a\xcf\xd9\xbb\x00\xa5\x8a\x6a\xcc\x04\xc0\xbf\x60\xbf\x2b\x1b\xdb\xa7\x7d\x96\x7c\x4c\xa6\x43\x9e\xbe\x49\xc4\x15\x68\xed\x8f\x7a\x5e\x82\x19\x4a\x36\xb8\xf7\x6f\x7c\x38\x62\xd9\x71\x16\xb3\xec\x40\x8c\x27\x22\x45\x33\xf7\xea\xa5\xd0\x0f\xad\xce\x43\xd0\xde\xdc\xd4\x4c\xae\x1d\x9a\xce\xe0\x8c\x8d\x5c\x31\x7a\x01\x27\x92\x1f\xd8\x15\xf9\xf7\x93\x13\x7c\x72\x96\x46\xac\x03\x8d\x42\xa5\xd8\xdc\x6a\x83\x1a\xeb\xa0\xa8\xb7\x9a\x3a\xc1\xd7\x6b\xba\x2b\x5a\x68\x99\xb6\xb9\x49\x7e\xcb\x19\xa1\x24\xe7\xe9\x30\x61\x85\x48\x89\x40\xf3\xd9\x49\x26\x2e\x79\xcc\x62\x22\x52\x46\xfa\x33\x7c\x8d\x89\x3a\x19\xab\x1d\x56\x8c\x5c\xa8\xb3\x6e\x78\x3a\x55\x63\xcd\x6f\x95\xf9\x19\x9c\xa1\x47\x62\x2a\xfb\x9d\x14\x02\x8d\xd1\xb2\x4b\xa6\x4f\x0c\x84\xe4\x58\x47\x96\xd8\xcf\xc9\x15\x23\x58\x01\xde\x32\xca\x51\x45\x60\x83\x45\xe2\x29\x9c\x42\x46\x9a\xb5\x7f\xf0\x24\x79\x2f\xb1\x92\x84\x0f\x58\x34\x8b\x12\xd6\x06\x53\xb8\x11\x4f\xe2\x8c\xa5\x70\x6d\x39\xa2\x69\x9c\xb0\x98\xd0\x41\xa1\xec\x86\x27\x34\x63\xa9\xdc\xe0\xe5\xf8\x04\x15\x6a\x27\x62\xa0\xea\x52\xaf\x23\x72\x72\x25\xa6\x49\x2c\xf1\xf5\x75\x99\x8d\x5f\x01\x75\x87\x1c\x15\x84\xe7\x84\x4a\x1e\xf6\x13\x36\x26\x72\xe9\x39\x1c\xe1\x6d\x22\x55\xc0\x64\x82\x66\xbe\xd4\xda\x0c\x82\x3d\x1c\xd8\xbc\xa5\x8c\xc5\xb9\x64\x85\xb8\x64\x59\x06\xc6\x6d\xe9\x0c\x09\xcf\x91\x8e\xbc\x43\x40\xa3\x9c\x40\xd3\xd5\x4b\x4c\x00\x80\x2b\x57\x4a\x46\x20\x6c\x60\x43\x38\x61\x11\x1f\xf0\x88\x17\xb3\xb6\x31\x8b\x53\x25\x4a\x1c\x3e\x11\x70\x45\x99\x8b\x64\x0a\xa3\x91\x03\x19\x19\x03\xb3\x6a\xdc\xc8\xca\x82\x63\xf3\xcc\x85\x5d\xb2\x2c\xd7\x5c\x02\x02\x36\x7e\x05\x38\xc9\x40\x89\x11\xee\x49\x55\x9b\x5d\xd2\x5c\xba\x50\xa2\x40\x10\x0e\x94\x1c\xec\x95\x96\xc5\x5a\x7e\x94\x02\x0e\x77\xd5\x75\xbb\xed\x94\x5d\xe1\xea\x5d\x97\xd7\xe2\xf7\x07\x23\x53\xf5\xe4\x13\x6e\x7e\xf1\x2c\x5b\x5d\xde\x42\xa3\x07\x28\x95\x56\xd2\x94\x2d\x24\x1a\x40\x82\xa9\x23\x05\x6e\xe8\x7b\x01\x6c\x47\x2a\xc4\x44\xcf\xda\xda\xfe\xf2\x28\x55\x2c\x2a\x04\x5e\xd1\xe6\x2c\x19\x6c\xa8\x13\x4f\x4f\x6c\xf3\xb6\x94\xf1\x8c\x25\x33\x62\x4d\x00\x55\x2d\x20\x41\xa9\x28\xcc\xe8\xc4\x0a\x15\x90\xae\x13\xce\xe0\xb7\xdc\x29\xc6\xbe\x21\x04\x18\x75\xa9\x00\x17\x84\x4e\x72\xf0\x6e\xc7\xcd\x32\x27\x36\x41\x55\xce\x80\x37\x2b\x0f\x6f\x9c\xd7\x60\xbb\x9f\x3e\x56\x53\x41\x2c\xb3\xe0\xfa\x60\x8d\x10\x78\xee\x45\xc8\x13\xa9\xbf\x06\xd3\x44\xf2\x15\xcf\x29\x1c\xbd\x40\x27\x93\x84\xa3\x3d\xaa\x65\x2f\xdc\xa3\x3f\xd9\x5c\x23\xda\x22\x7b\xa7\x4e\x01\xab\xc7\x80\x6b\x41\x6d\x4a\xa2\xd5\x74\x08\x0a\x8b\xe6\x52\xae\x41\x60\x68\x92\xf4\x69\x74\x41\xd4\x03\xf6\x98\x45\x42\xaa\xc1\xd8\x52\x60\x09\xe0\x69\xca\xb2\x4f\x6c\x50\x4b\x81\xec\xc0\xb5\xdb\xdd\xfb\xf0\xea\x28\x95\x44\xfb\xbc\x5a\xac\xa1\x1d\x9e\x6b\x46\xb7\xd7\x08\x4a\xdc\xe2\x45\xf4\xad\xd9\x07\x51\xb0\xb6\x12\x57\x9e\xcb\x29\x23\xe6\x52\x06\x69\x92\xc8\x85\x06\x12\xd7\x06\xeb\x8a\x41\x22\xae\x24\x4c\x0e\xfb\x26\x42\x53\x9a\xcc\x72\x78\x23\xe7\x5a\x12\xf3\x34\x4a\xa6\x31\x23\xbc\xe8\x40\x05\xef\x78\x7a\x21\x27\x2c\x47\xf3\x83\x15\x0c\x75\x39\x2c\x47\x5c\x01\x46\x26\x30\x5c\xc6\x22\xe6\x03\x3d\x87\xe9\x99\x17\x14\x30\x56\x51\xec\xca\x12\x72\x5a\x65\x34\x6e\x13\x5e\x28\xa9\xcd\x95\x8b\x02\x53\xa8\xad\xeb\xfa\xac\x78\xfa\xd9\x08\x02\x0e\x45\x99\x8d\x4b\x3d\xf7\xa0\xd6\xa6\x36\x51\x8f\x1c\x67\x7a\x25\x68\x0e\x6e\xc5\xa4\x50\xb7\x63\x55\x57\xaf\xea\x19\x82\x3a\x37\xef\x9e\x07\xd6\xec\x2f\xfd\xcc\x1d\xd0\x3b\x66\xec\xd9\x03\x63\xb3\xee\x70\x0f\xe6\x7b\xaa\xea\xef\x25\x99\x7a\x64\xab\xb4\x8e\x49\x6b\xdb\x6b\x78\x07\xac\xaa\x6c\x40\x19\xdc\x66\x93\x9d\x0a\x50\x8b\x72\x90\xf0\x89\x53\xa9\xfc\x69\x33\x53\xea\x51\x04\xef\xce\x4d\x66\x6e\x66\xc1\x63\xc3\x40\xd0\x4a\x75\x47\x45\x56\x3d\x29\x84\x6d\x72\xd6\x30\x24\x35\xda\xa4\x21\x6b\x97\x9f\xb2\xa2\xc6\x79\xcb\xb1\x6f\xc8\x83\x3d\x02\x54\x54\xda\x08\xd8\x1a\xc2\xce\xde\xb5\x96\x12\xb0\x1d\x3a\x15\x9a\x8f\x1e\xe6\x8e\x1c\x3e\x3c\x1d\x1e\xa6\xb4\x2f\x17\x27\x37\x37\x0e\xcf\x6f\x6e\xf4\x03\x1d\xe4\x8b\xf3\x20\x47\x51\x2a\xf5\xba\x8f\x4f\xb3\x0e\x97\x5a\x5e\x07\x39\x77\x2c\xee\xf4\xfb\x74\x8f\x18\x93\x86\xb9\xb8\xbc\x62\xfa\x06\x1d\x3e\x6a\x1f\xb5\x3e\xb6\x2f\xe3\x1e\x93\x97\xc8\x44\x7d\xc4\x63\x79\xe7\x91\xf3\x0b\xd9\x92\xdd\xf4\x9e\x16\x2c\xe3\x34\xd9\xf8\xed\x68\x07\x1e\x34\x8e\xe1\x51\x18\x4c\xa8\x94\x8c\xd9\x58\x64\x33\x92\x30\x7a\xd1\x91\xfd\x77\x3a\x62\x7e\xa3\xdc\x7b\x46\x35\xf4\x87\x99\xb8\xd2\xa6\x5c\xd1\xa8\xd3\x38\xb7\xef\x73\x5a\x64\xc7\x4e\xa5\xba\xdf\xa0\xa7\xbd\x3b\x98\x1e\x68\xe2\xef\x4b\x23\x8b\x60\xc3\xcc\x01\xa9\x6d\x19\xe0\x68\x93\x52\x41\x55\x0d\xb1\xc8\x01\xb2\x29\x35\x4c\xde\xd6\xab\x6f\xf7\x56\x0b\xa7\x5f\xff\xb4\xdb\xd6\x83\xb6\x5a\x80\xc3\xe2\x56\x43\x1e\x1e\x23\x2b\x01\xae\x3f\x46\x0e\x71\x21\xe9\x9d\x5e\x0f\x36\x87\xbd\x9e\x14\x46\x3d\x06\xdc\x23\xfe\xa0\xad\xad\x96\x6b\x3c\x16\x34\xc7\x25\x0d\xc8\xea\xc8\xf9\x40\xaf\x9d\xfc\x9c\x69\x9a\x4f\xfb\x79\x94\xf1\x3e\x3b\x8a\x3d\xeb\x19\x0b\x83\xdb\xa1\xaa\x9c\x70\x65\xe8\xfd\x0e\x81\x63\x9e\xcb\xc1\x87\x23\x5b\x6d\x66\xd0\xf4\xc1\xb1\xce\x71\x69\x76\xc6\xc8\x09\xbd\x64\x75\xe4\x15\x6a\xc0\xd7\x12\x68\xd5\xd8\xe2\xc5\xc1\x29\x8e\x5a\x7f\x7d\xc4\xa5\x61\x66\xf1\x60\x49\xbd\x79\xab\x81\xdb\x5d\x0b\xbb\x41\x1d\xb6\xb9\x85\xcf\x52\x48\x3e\x97\xfd\xfe\x25\xcf\x9d\x9e\x93\x3a\xa7\x06\xb3\x6f\x00\x34\x07\xd0\xef\xa0\xd0\x6e\xa8\xba\x0f\x17\x42\xe5\x1a\x73\xdd\xae\xad\x85\x38\xeb\xbb\xba\x0e\x7b\x4d\x09\xd7\x80\xc9\x35\xe2\xdd\x2f\x0a\x1a\x8d\x9c\x6d\x84\x9e\x41\xd4\x22\x51\xef\xe7\xcd\x3e\xce\xac\x51\x68\xae\x37\x5a\xaa\x07\x5c\xb4\x62\x40\xe0\xc4\x7e\x63\x24\x8a\x0d\xf0\xec\x83\x3b\xd8\x91\x10\x17\x39\x89\x68\x2a\xb7\xa6\x0c\xfd\x12\xc5\xf8\x12\xcb\x1a\x86\x46\x89\xc8\xa7\x99\xc1\xbb\xe3\x22\x1e\x15\xc5\x24\xdf\xd9\xdc\x54\x0f\x63\x23\x31\xde\x1c\x52\x46\x33\x91\x6e\x86\x15\x6e\xf6\x13\xd1\xdf\x1c\xd3\xbc\x60\xd9\x66\x9e\x45\x9b\x13\x5a\x44\xa3\x4e\xcc\x2e\x3b\x5f\xf2\xff\xf5\xae\xbb\xf5\xe3\x22\x03\xc5\x4b\xbc\x63\x54\x80\xbe\xd1\xb7\x96\x56\xd1\xb8\xc2\x52\x3a\x9a\xd8\x29\x27\xd9\xae\x6a\x97\x65\xdc\xad\xf2\xdc\xb1\x05\xb4\xbb\xc6\x9b\x1b\xe8\x9b\xa2\x91\x93\x84\xfe\x63\x06\xe6\xcd\x53\xb9\xce\xef\xd4\x0c\x58\x7f\xc2\x7f\x19\x1e\x9f\xea\x86\x74\x78\xca\x0b\x4e\x93\xa6\xd1\xf6\x37\x37\x15\xdb\xb7\x1d\xbb\xc9\x2c\xd9\x98\x43\xbd\xd6\xac\x61\xcd\x90\x7e\x78\x8d\xd3\xde\x40\x4a\x1e\xcb\x0b\x32\x99\x66\x32\x25\xef\xac\xcd\x81\xca\x0d\x98\x81\x72\x76\x7d\x78\xe9\x59\x9a\xdb\xce\x6c\x77\x5c\xb0\xd9\x0e\x69\x94\x4f\x65\x1a\x6d\x47\x7d\xc1\xc5\xb9\xb5\xf4\x2d\x01\x37\x7d\x6d\x80\x76\x6f\x30\xaa\x9a\x96\xcb\x25\x7b\x64\xe8\xdc\x5a\x4a\x5e\xf3\x78\x61\x42\x34\x6c\x40\x87\x99\x4a\xb7\xc9\x1e\x41\xb6\x07\xaa\xee\x91\xd7\xef\xa1\x4e\x73\x4d\x71\x83\xfe\x32\xcd\x0c\xe7\xbc\x3a\xc1\x31\x50\x4d\x57\x9a\xdb\xae\x05\x4f\x15\x09\xb0\xf5\x48\x62\xb3\x9e\x87\xd6\x20\x3f\x77\xcb\xfa\x77\xdb\xc8\x73\x3d\x84\xea\x17\x17\xbe\xe5\xf1\x05\xc4\xec\x13\x53\x87\x4a\xbe\xc2\x53\x87\x6e\xf0\x8c\x3f\x99\x79\x07\x23\x72\x18\xc0\xe1\x93\xda\x5d\x4e\x27\x31\x2d\x58\xc9\x2c\xfe\xd5\xcc\xcb\x97\x5b\xc9\x31\xa3\x29\xc9\x58\xc4\xf8\xa5\xc4\x48\xd3\x18\x8e\x06\x00\xbd\xc4\x07\x5b\x3c\x29\xc8\xb0\xa4\xce\x3b\x55\xad\xca\x19\xdc\xef\xb1\xe6\xd7\xdb\x76\x85\x79\x66\x09\x3e\x66\xc0\x05\xcd\xda\xd0\xa0\xd8\xfb\x7d\x7b\x4f\xc9\x95\xc3\xe2\x13\x34\x07\xec\x52\xf2\x45\x87\x92\x5b\x26\xa0\x1c\x5e\x86\x07\x73\x89\x3e\xa0\x23\x89\x18\xf2\x28\x10\xec\x5a\x65\xbe\x17\xa8\x73\xa9\xc0\xee\xe1\x24\xc3\xfe\x2d\x32\x38\x14\x97\x2b\x75\x80\x02\xb9\xcf\x84\xb3\x22\xcd\x22\x79\xfd\x5b\x3a\xbe\x8f\x96\x53\xe0\x55\x7a\xae\xaa\x8d\x55\x9d\xe1\x2b\x0a\xed\x4a\xa7\x62\x19\x55\xa9\x3e\x9c\xd2\x81\x02\x29\x23\xf7\x85\x77\x11\xd6\x20\x47\xe7\x30\xc3\xb0\xbc\xa4\xa2\x4c\xfb\x6a\x16\x5d\xf7\x14\x9b\xd2\x36\x5e\x8b\x44\x8d\xb0\xec\x86\x65\xe5\xd2\xc0\xae\x3f\xcb\x8b\xd2\xce\x90\x15\xcd\x32\x9e\x72\xa7\x3d\x72\x51\x85\xad\x08\xaa\xa9\x3c\xc4\x76\xe1\x2b\xe8\xc8\x2b\xe9\x68\x7b\xa8\x5b\xf3\xf9\xe4\x40\x9a\x83\x0a\x27\x0d\x9a\x5a\x23\x92\x8f\x4a\x85\xe7\x35\xd1\x1c\x97\x07\xca\x34\x63\x83\x7c\x87\x6c\xb5\x83\x64\x28\xba\x03\xf2\xed\xab\xd5\xdd\xda\x1a\x80\x1d\x40\x6b\xbb\x5c\x73\x3d\x1b\xe0\x2c\x25\x04\xef\x48\xb2\x40\x7f\x6d\x55\x4d\xa7\xb9\x3e\xff\x2b\x73\x5f\xdd\xce\x69\x42\x52\x5a\x9a\x19\xd0\x20\x88\x15\xd4\x3d\xc8\x77\x01\xee\xe9\x2f\xcc\xfd\xd3\x78\xe1\xe0\xc8\xd9\xba\xbb\x06\x20\x76\x29\xe7\x1e\x4c\x78\x4c\x5e\x2b\xb7\x18\x8e\x61\xd5\x68\xb0\x97\x90\xf6\x86\x4a\x09\x62\x7b\x91\xd5\xbb\xfc\x93\x84\xee\x20\xbd\x61\xdf\x0f\x12\x3e\xd9\xd1\x47\x60\x78\x6e\x28\x1b\xde\x17\x22\x61\x34\x6d\x90\x97\x98\xb8\x83\xab\x80\x0e\xba\x60\x83\xed\x9c\x04\xcb\x8a\xa4\x11\x62\x4c\x78\x7a\xa1\x7c\x55\xfa\x0d\x6d\x93\xd2\x06\xa4\x5d\xd5\xa9\xe6\x20\x31\x6c\x46\x0a\x7b\x8f\xd4\xdd\x6e\x28\xc4\xa5\x63\xcb\x56\xb8\x46\x2a\x4b\x9d\xe6\x32\x7c\x56\x48\xba\x9e\xb7\x42\x4c\xf6\xb6\xec\x13\x38\x7f\xc9\x66\xba\xab\xc2\x2d\x8f\x01\x38\xdf\x2d\xc9\x9c\x0f\x50\x16\x2e\x3f\xbf\x43\xe3\x18\x8b\xd4\x3e\xa5\x0a\x24\xa9\x66\x94\xb9\x07\x91\x73\xa7\x18\x9c\x26\xe7\x4c\x31\x66\x1e\xfd\x6f\x3c\xc5\xd4\x23\xba\x8f\xfe\xae\xe9\x8a\x0d\xe8\x8a\x07\x28\x47\xaf\xee\x98\x25\x4c\x6b\xc2\xaa\xc9\xec\x8b\x79\x8f\xe3\xaa\x91\xea\x41\x51\xa1\x43\xff\x72\x81\x47\x5a\x17\xa4\xf0\xf6\xbe\x0b\x28\xdc\x2c\xcd\x91\x6e\x04\xa8\xdb\x9f\x3e\xab\xda\x9f\x1a\xdb\xcd\x5c\xb3\x07\x8f\x66\x83\x76\xaa\x9b\x2e\xb9\x6b\x90\x1b\x44\x80\xe9\xa8\xc4\x10\x56\xdf\x68\x5a\x40\x9d\x12\x42\xc2\xa3\xe7\xc5\xef\x6a\x7a\xea\xd4\xf8\xac\xa1\x6a\x6e\xb4\x49\x43\xe3\xc6\x4b\x9a\xa0\x65\xd6\x8f\x9a\x9e\x46\xfd\x7c\x64\x18\x8b\x0f\x0c\x9c\x7a\x31\xe1\xca\xc0\xa3\xfb\xa8\x85\xc5\xc7\x6e\x8d\x22\xa8\x15\xe3\xbb\xc7\x70\xe5\xfe\x87\x54\x34\xb2\x8c\x10\xe9\xd3\x3d\x3a\x77\x25\xe4\x88\x42\xc9\x13\x8e\xa9\xa1\x6e\x8a\xbf\x6d\x87\xe4\xa8\xe5\x00\x3c\x6c\xb0\x80\x6e\x25\x9d\x8c\xc5\xd3\x88\x39\x3e\x8b\x68\x14\x4d\xc7\xd3\x44\xf2\x4c\x39\x68\x0b\xc7\xe5\x03\xef\x9d\x02\x1a\xd1\xae\xed\xe6\x46\x8d\xa3\x3a\x59\x28\xdd\x4e\x15\x23\x06\xb6\x75\x9f\x1b\xe4\x29\x7c\x79\x4a\x1a\x9f\x89\xfc\x01\xaf\xdf\xd0\xb6\x4a\x7b\xb9\x57\xbc\x33\x36\x05\xea\xa2\x8a\x8f\x27\x68\x6d\x84\xc7\xb7\x50\x78\xc1\x25\x9b\xac\xae\xd3\x68\xb5\x49\xe3\x3f\xc4\x14\xce\x82\x45\x9a\xcc\xac\x3d\x91\x48\xcd\x69\xf3\x40\x24\x89\xb8\xe2\xe9\x70\xc7\xd6\x10\x74\x49\xc0\x93\x96\xba\x24\x6b\x37\x5a\xfa\xbe\xec\x3f\xd3\x8a\x0b\xb3\x95\xf5\xc9\x23\x47\x26\x4c\x87\x18\x6f\x4d\x41\x96\x7b\x23\xfa\x4d\xba\xe5\x92\x26\x1c\xcf\x47\x97\xef\x11\x6d\xdd\xa0\xea\x24\x94\xa4\x22\xf5\x9f\xd3\x2a\x73\x04\x22\x06\xd8\x31\xa5\x86\x02\xc2\x05\x3b\x20\x18\xbd\xc6\x9d\x21\x09\xfe\x9c\xe1\xa5\x2d\x3a\x2b\x07\xc4\x53\xd2\xa8\x24\x6a\x37\xc0\x78\x1b\x12\xa2\x0e\xa9\x9d\x7a\x76\xc3\xb5\xf1\xd7\xdb\x96\xbf\x21\xab\xf4\x9c\x65\xf4\x4d\x40\xdf\xdc\x65\xd9\x58\x64\xac\xac\xe9\x37\x37\x89\xba\xe1\x71\x8e\x17\x95\x10\x68\x07\x75\xbe\xf9\x8e\x2d\x78\x02\xc6\x2a\x68\x11\x86\x8e\x40\x84\x31\x2b\xfb\x6c\x6e\xed\x9b\xad\xcf\x04\xcd\x3f\x37\xd0\x0c\xec\xa0\x0a\x9d\xec\x24\x53\x24\xec\x1d\x49\xba\x73\xfa\xaa\x15\x7e\x6d\x73\xf5\x6d\x00\xbe\xfa\x30\xe7\x3c\xb8\x33\x53\xae\x85\xad\x78\xd6\xef\xcc\xac\xf5\x90\x66\xf9\x6d\x1b\x88\x69\xe3\x1c\xde\x06\xab\xdc\xc1\x8e\x9d\xfb\xbd\xee\x33\x6b\x1a\x7b\x8f\xa2\x28\x03\x15\xaa\x2c\x06\x9a\x21\x99\xa5\x5b\x71\xbc\x79\x0e\x1e\x1b\xdc\xb1\x9b\xac\xb9\xbe\xdb\x71\x5f\xac\x98\x1a\x71\x0d\xb2\xa6\x64\xd0\x7f\xa7\xa0\x81\xda\x0b\x5f\xe3\x78\x84\xee\x48\x91\xde\x75\x9a\xf1\x81\x5e\xc0\x86\xc0\xb4\xd2\xcd\x74\xdf\xdd\x2c\xaa\x37\x75\x8b\x17\x35\x69\x53\xf2\xb6\x90\xfd\x19\x0e\x41\x34\x29\xc2\xbe\x00\xb6\x57\x3e\x95\x29\x5d\x04\x95\xfa\x71\x73\x53\x0d\x04\xd7\xfe\xd3\x69\xbd\x35\x83\x12\xe6\x62\x9a\x2c\x77\xec\x81\x08\x63\xef\x39\x0c\x4e\x30\xc1\x3b\x9b\x0a\x75\xdd\x26\x0d\x6b\xb4\xd5\x68\x79\x86\x2d\xa1\xfc\xde\xe2\xcb\xd5\xf2\x43\x5d\x8b\x61\xee\xf3\xd3\x25\x1d\x33\xff\xf8\xd7\xbe\x72\xf7\xdf\xc1\xd6\x99\xc3\xff\x60\x9f\x69\xf8\x05\xe6\x3d\x8f\xf0\x21\xff\x49\xaf\xdf\xcb\xaf\xaa\xdb\xb8\xc9\xb2\xc6\xb2\xde\x5b\x09\x3b\x12\x82\x86\x3a\x06\x66\x06\x91\x16\x49\xb5\x6b\x83\x0f\x3d\x0a\xcb\x01\x51\xd4\x58\xf6\x42\xa9\xb8\x39\x57\x19\x2f\x6c\x2a\x8a\x26\x88\xa8\x37\x53\x0a\xfb\x28\x03\xea\x0b\x5f\x5d\x8b\xfe\x97\x8a\x27\xd7\x3f\x3d\x48\xaa\xca\xfe\x67\xc9\x63\xc5\x8e\xc7\xd5\x5a\xe6\xf9\x76\xb7\x25\xf1\xe9\x6e\xc3\x36\x91\x12\x5d\x3f\xff\x97\x78\x70\xaf\x2d\x35\xa4\x62\x33\xc6\x52\x56\x40\x1e\x19\x00\x63\xd3\x21\x06\x1e\x68\xd9\x23\x86\x54\xf5\xe8\x15\xe3\xf1\x01\x4d\xe5\xfa\x52\x6a\x03\xfd\x2e\x00\xfc\x91\x19\x02\x1e\x63\x2f\x97\x7b\xad\xfb\xb0\x50\x1b\xff\xa3\x0c\x6a\x7b\x5c\x39\xbc\x70\x5c\xf2\x5a\xea\x38\xcb\x95\x5b\x0c\x65\xd5\xa6\x7b\xb7\xca\x65\x3b\x1e\x87\x54\x3a\x46\x42\x1b\x7e\xf4\x98\x07\x76\xa5\x00\xeb\x78\x44\xb2\x99\x1d\xab\x2d\xc0\xb7\x6b\x55\xfa\xcd\x8d\x6f\xa3\xe6\x40\xb9\x3a\xc5\x09\x4d\xa1\x27\xd8\xc7\xa0\x28\x1e\x4b\x25\x67\x0b\xb5\x5c\x04\x5a\xf5\x04\x85\xe7\xeb\x41\xcd\x23\x07\x0f\x68\x45\xa7\x0e\xeb\x22\xcb\x55\x51\xae\xe1\xb2\x19\x43\xc0\xeb\x42\x7c\xc4\x03\x21\x34\x1e\xff\xe8\x72\x5f\x2d\x15\x14\x48\xab\xdc\x67\x0e\x32\xfb\xcc\xcd\x45\xeb\x78\x95\xf2\xf0\xcf\xc3\xe4\x93\xb2\xeb\xae\x14\x1c\x28\xbd\x5e\xc0\x47\x28\xde\x10\x5e\x65\x28\x8b\x05\x86\x30\x6e\x9f\xeb\xbd\x0c\xd8\xc7\xb1\x08\x39\xef\x8d\xbd\xc2\xf5\x4f\x1f\xac\x39\x4b\x06\x6d\xd0\x9f\x8e\x4e\x96\x89\x65\xb5\xfb\x89\x81\x21\x5c\xa4\x75\x2f\x18\xc4\x8e\xd0\xbf\x28\x38\xac\x54\x86\x58\x3c\x67\x31\xd9\x20\xf9\x74\x02\xa7\xab\x2e\x04\x7a\xa7\xd4\x3a\x79\xcd\xf1\x9d\x08\x11\x6c\x48\xd3\x38\x94\x96\x09\x7b\x72\xd5\x6e\xcc\xae\xe5\xa2\xdd\xfd\xb5\x83\x43\x48\xb1\xda\x39\x0c\x93\x6d\x69\x61\x61\x5c\xbc\x3f\x76\xcf\x3e\x0c\x62\x3b\x43\x90\x97\x98\xbc\x03\x4f\x8c\x2a\x66\xf8\xee\xc3\x22\x7a\xdc\x5b\xd0\xf2\x45\xbc\x85\x3c\x7f\x66\xdf\x6f\xe7\x0b\xfb\x0b\xc9\x6b\xfc\x85\xe0\x03\xc1\xba\x70\x34\xa1\x9b\x8f\xbb\x1f\x0e\xb7\xfe\x5b\x0f\x9a\x69\x1f\x8e\x4e\xda\x28\xe4\xf0\xdd\x0e\x1f\xed\x09\xde\x64\xe1\xf6\xd3\xc8\x1b\x78\xc7\xf6\x33\x5d\xb3\x93\xca\x75\xce\x89\x84\x97\x92\x96\xb1\x1c\xfc\xc9\x81\x1b\x55\xc6\xe1\x4a\xa0\xcf\x30\x04\x94\xc8\x9c\x85\x4f\x1b\x0e\xde\x1e\x93\xa7\x55\x04\x2d\x37\xb2\x9c\xc6\xb6\xec\x10\xd6\xcc\xb0\xf3\x82\xff\xca\x6d\xbb\x0a\x81\xcf\x03\x77\x4a\x41\x26\x44\x56\xff\xef\x84\x5b\x01\xc3\xfd\x8a\xdd\x80\x0a\x9f\x58\xb5\xe8\xaf\xdf\x24\xd8\x89\x14\x5a\x05\x73\x98\xd3\xaf\xe1\xe8\x32\x22\xa1\x0e\x5f\x6b\xb2\x5b\x35\x62\x62\x1b\xe0\xbc\x0a\xd8\x73\x40\xaa\x14\xd0\xdc\x08\x18\x76\x60\x29\xa1\xc5\x20\x41\x0b\xba\x78\xf2\x43\x69\x92\xa6\x72\x74\xd7\x22\x4f\x36\xab\x90\x74\xe2\x66\x65\x7d\x8f\xa3\xc7\xed\x4a\x7f\x73\x1f\x3f\x1d\x9e\x1c\x7e\x38\xdd\x97\x5b\xf7\xde\xfe\xe9\xe9\xa7\xa3\x57\xbf\x9d\x1e\x9e\xec\x12\x8c\x4f\xb9\xb2\xfa\x69\x4d\xfd\x87\xbf\x1f\x7e\x38\xfd\x96\x15\xc7\x35\x15\x9f\x1c\xec\xbf\x3b\x84\x60\x6b\xab\xaf\xb3\x5f\x53\xe7\xbb\xc3\xb7\x87\x1f\x5e\x7f\xa3\x4a\xbf\xd4\x54\xea\x1f\xe5\xaf\xbc\xda\x51\x4d\xb5\x03\x9e\xc6\xfb\x49\xf2\x6a\x26\xf5\xe4\xca\x6b\xe5\x73\x6a\x3d\x18\xf1\x24\x0e\xea\x9d\xa6\x53\xb9\xee\x09\xaa\xbf\xc2\x0b\x5a\x08\xb0\x84\xf1\xb1\x56\x45\xdf\x45\x7d\x67\x7c\xc4\xd0\x34\x70\xcb\xb6\x5f\x14\x19\xef\x4f\x0b\x96\xaf\x9c\x43\xac\x96\x43\x49\xc1\xb2\xc3\x4b\x96\x16\xdf\xb0\xf6\xc1\xdd\xb5\xe7\xc7\x03\xe8\xa9\x95\xd7\xfd\x67\x4d\xdd\x70\xcd\x45\x0b\xf6\x07\x8f\x8b\xd1\xbf\x31\x3e\x1c\x15\x2b\xaf\x3b\xad\xa9\x9b\xe7\x27\x79\xb6\xf2\xda\x86\x73\xb9\x7c\x72\x39\x54\xd7\x22\xf9\x1d\xe3\x80\xe7\x27\xe0\x2e\x03\xfa\xe3\xf0\xcf\x29\x4d\x56\x3c\x1c\xc6\xb5\x6c\x39\x50\xce\x2b\xa0\xd6\x95\x33\x68\x52\x53\x2f\x5e\xb1\xbd\x9a\x81\xef\x92\x95\xd7\x9a\xd4\x0f\x7e\xb8\x5c\x00\xf1\xff\x46\x8a\x51\xd4\xd4\x3d\xa1\x59\x8e\xfd\x0b\x2e\xbe\x4b\xf5\xf2\x31\xd4\xfb\x64\x13\xad\x68\x4c\xdc\xb0\xa3\xf7\x1f\x8f\x3f\x9d\x1e\xbe\xee\xbd\x3f\x7e\xfd\xdb\xbb\xc3\xde\x56\x2f\x11\x31\xcd\x47\x3d\x9e\x7f\xe0\x09\xac\x8d\x2a\x8f\xf7\xbb\xab\x41\xdf\x8b\xe7\xb9\xbc\xea\xa4\xcd\xc5\x51\x2d\x47\x50\xd7\x62\x39\x81\x6b\xec\xda\x26\x77\x7f\x7e\xb1\xb2\x2a\x1e\xd0\xec\x0a\x6c\xcb\x91\xb5\x6d\x11\xa1\x07\xa5\xfa\xce\xfe\x69\x65\x35\x3c\xa0\xe1\x15\xd8\x96\x23\xeb\x99\x45\xf4\x46\x8d\xa4\xfa\x4e\xff\x61\x85\x75\x3c\xa0\xf1\x95\xf8\x96\x23\xed\xb9\x45\x05\x8e\xf5\xeb\xdb\xbe\x64\xb7\x97\x2b\x78\x40\xc3\xcb\xc8\x96\x23\xea\x05\x5e\xd8\xd7\x37\xf6\x81\x68\x1f\xd0\x44\x83\x63\x39\x12\x7e\x00\xe3\x00\x38\x2f\xc8\x6b\x9b\xb7\xb5\x0a\xdc\x0f\x68\xa3\x8f\x68\x39\x62\x7e\xec\xf5\x5e\xd3\x82\xfe\x56\xf0\xa4\xbe\xa1\x70\xa2\xb5\x04\xf2\x9f\x7a\xbd\x8f\xd3\x8c\x7d\x82\x85\x43\x3d\x76\xb8\x20\x82\x3f\x7b\x04\x56\x88\x03\x91\xe6\xd3\x31\xed\x27\x4c\x87\xaa\xc8\xb4\x73\xba\x30\x64\x2c\xdc\xa8\x05\xf7\x2d\x10\x8a\x61\x9b\xec\x99\x40\x17\x99\x0e\xa8\xa2\x3d\x95\x67\xc1\x3d\x0c\x14\x40\x0f\xd5\x34\xcb\xce\x38\x78\xaf\xd3\x96\x4a\x59\xb6\xed\x38\xd7\x53\xa9\x48\xc7\x20\x13\x63\x20\x42\x39\xb1\xc3\x3f\x49\x48\xcd\x39\x81\x7a\xe2\x42\x13\x3e\x4c\xe5\x4a\xf3\x15\xcd\x59\xc2\x53\xf0\xb3\x73\x3f\xa1\xe9\xd0\x0e\xda\x89\xb5\x25\x3e\xb9\x1a\x5d\x0a\x07\x86\xec\x95\x38\xfa\x8a\x94\x93\x11\x1f\x14\x0f\xa4\x27\x82\x37\x1a\x0f\x46\xf1\x91\x16\xa3\x15\xa0\xf9\x34\x5d\x92\x39\x0e\x1a\x91\x88\x6c\x15\x38\x8e\xd2\x82\x65\x13\x91\xc0\x76\x76\xe5\x08\xdf\xc0\x46\x26\x5f\x05\xde\x8f\x99\x18\xf0\xd5\xf0\x0d\x95\x00\x18\x98\x3e\x0c\xd9\x34\xcb\x1f\xdc\x0b\xe6\x3d\xd0\x52\x78\x44\xca\x8e\x07\xcd\xb3\x46\x52\x64\x8d\xb6\x7a\x4d\x44\x1a\xca\xc7\x4b\xe3\xbc\x85\x35\xc0\xe9\xd1\x43\xe9\x14\x63\x9e\xd2\x95\x69\x08\x06\xae\x84\x5e\xd1\xe8\x62\x98\x89\x69\x1a\x3f\x10\xdd\x80\x27\xc9\x0a\x50\x1c\x4f\x68\xc4\x8b\xe5\x58\x05\x5d\x21\xf7\x84\xcd\xb3\xe5\xe9\x58\x5e\x65\x62\x5f\xcb\x46\x2c\xad\x5e\xb4\x30\xa5\x22\xfd\x07\xcb\x84\x94\x24\x76\xc9\x52\x11\xc7\x65\xa1\xc2\x23\x8a\x87\xb2\x3c\x11\x22\x3e\x58\x81\x2a\x03\x44\x7f\xff\xce\x13\xe9\x43\x27\x3a\x89\xe2\x0d\x1d\xf3\xe4\xa1\xc3\x5d\x22\x3a\xe1\xff\x78\x80\x20\x2d\xcd\x4d\xb5\x04\x58\x9e\x7e\xcb\x4d\xd9\x82\xfd\xf8\xcb\x34\x5f\x8e\xaf\xff\x75\xda\x51\x64\xac\x88\x96\x5b\x7b\xd8\x51\x9d\x8d\x29\x4c\x0f\x57\x1c\x9e\x6e\x91\x46\x4a\xb3\x4c\x5c\xe1\xf7\x69\x52\x64\x74\x23\x12\x69\xcc\xd2\x9c\xc1\x88\x67\xd7\xa5\x24\xef\x47\xce\xc6\x7c\xa3\x9c\xc2\xae\x27\x34\x8d\x35\x0a\xf7\xbb\x44\xe7\xa6\x60\x9d\x6e\x4a\xa0\x64\xa0\xe9\xb3\x07\xab\x33\xdd\x70\x5e\xd0\x84\x47\xf2\x9b\xe8\x27\xfc\xcf\x29\xab\xae\xf2\x77\x9a\x71\xba\xe4\x50\x2c\x57\x9a\x8f\x69\x92\x6c\x44\x74\x92\x57\xd7\xf6\x07\x9c\x64\xaf\xa8\xb2\xbe\x48\x62\xfd\x89\xfd\x9a\x48\xec\xf0\xb5\xbb\xb5\xd5\x26\xdb\xf2\xbf\x67\xf2\xbf\xe7\xf2\xbf\x17\xf2\xbf\x1f\xe4\x7f\x3f\xca\xff\x7e\x92\xff\xfd\x2c\xff\x0b\x08\x1d\x26\xb3\xc9\xe8\x38\xe3\xfa\xe2\xe3\xdf\x44\xc6\xff\x21\xd2\x82\x3e\x74\xd6\x0d\x11\xff\xce\xb2\x82\x47\x0f\x46\xcb\xc7\x74\xc8\x1e\xb6\xce\xd3\xcc\xa5\xd3\x02\xa6\x42\x1d\xaa\xff\x64\xc2\x50\x56\x75\xc2\xff\x99\xd2\x84\x17\xb3\x72\xef\x5e\x30\x78\x37\xf4\xf7\x55\x3d\x09\x2b\x0a\x96\x9d\xc8\x79\xf5\x6f\xdd\x0c\x39\x04\x78\x3a\x5c\xc5\x4a\x03\x23\xcd\x1e\x3e\x78\xc1\x8a\x78\xde\xf3\xd5\xe0\x39\x29\x68\xf6\xd0\xa5\xc3\x98\xe6\x17\x0f\x44\x21\xfe\x69\x2b\xb0\x15\x49\x8a\xb8\x64\xd9\x20\x11\x57\x0f\x52\x18\x97\x1c\xbc\x57\x4a\x7d\x30\xe2\x71\xcc\x52\x98\x05\xa2\x4c\x24\xa0\xa2\xb5\x3e\xf1\x75\xc5\x44\x80\xa5\x15\xde\xac\xae\xa2\xfa\x8f\x54\x22\x04\x45\xa5\x52\xde\x70\x24\x40\xfd\x3c\x29\x32\x71\xc1\x9c\x04\xf9\x75\x62\x4b\x0d\x14\x78\x6e\xe0\x28\x26\xa4\x22\xad\x98\x38\xf3\x11\x9d\x7c\x6b\x8d\x1b\x65\x3c\x9f\x1c\xc6\x43\x7c\x6d\x3d\x64\x62\xcc\x8a\x8c\x47\x1f\x33\x16\xf1\x9c\x8b\xb4\x82\xaa\x42\x4c\x56\x31\xec\x25\x9e\x7f\xde\xfe\x62\x45\xd2\x8d\x3d\xf9\x77\xa7\xff\x35\xcd\x47\x10\x62\xf6\xc1\x5d\xaa\xb1\x89\xc1\x20\x67\x7f\xe3\x1d\x02\xb6\xe4\x1d\x4f\x59\x44\x97\x3b\xe6\xd4\x23\xaf\x3f\x2d\x0a\x38\x47\x12\xd3\x14\x17\xf4\x7f\x4e\x69\x56\x35\xda\x4d\x95\x5f\x04\x7f\xd8\xd1\xd5\x98\xe3\xf2\xd4\x56\xda\x67\x97\xac\xe2\x1c\x0b\xeb\x7c\x2f\xc1\x13\x3e\xe6\x7f\xfb\x0e\xfb\x6f\xa2\x4f\xc0\x1c\xe7\xef\xdb\x88\x82\x5d\x17\xfb\x69\x34\x5a\x72\x8a\xd0\x52\x9c\xcb\x15\x98\x94\xd9\x31\x8f\x63\x9c\x4b\x59\x5a\xb1\xa5\x95\xd5\xbd\xc6\x18\x0c\x0f\x3d\xf3\xd5\xf3\x30\xfa\xa6\xe4\xf8\x43\xae\x60\xf4\x77\xf9\xb9\x51\x8c\x32\x31\x1d\x8e\x60\x5c\x25\x3c\xbd\xa8\x26\xe9\x2f\xda\x2a\xbd\x63\x43\xde\xe7\x7a\xb7\xb4\xc8\x04\x3e\x4d\x79\x24\x62\xf6\x8a\xc7\x7c\x45\x5b\x64\x36\xee\x23\x51\x7d\x1e\xf3\x0d\xed\x80\xa2\x5c\x33\xac\x8a\x80\xd6\xd5\xaf\x06\x23\x91\x24\x74\x92\x57\xd4\x7a\x25\xb2\xf8\x6f\xbf\xe1\xba\xca\xb8\xdc\x6f\xbd\x17\xf1\xc3\x4e\x6e\x92\x6c\xa3\xe8\xc3\xd4\x90\xa8\x2f\x45\x7f\x23\x83\x5e\x4c\x70\xca\x48\x30\xb1\x42\xa8\x33\x9a\xe6\x03\x91\x8d\x1f\xbc\x4a\x58\xfa\xf8\xc9\x46\x6b\xb9\x5a\x5a\x45\xda\xeb\xd0\xd1\xf2\xc7\x44\x16\x49\x7c\xfd\x50\x04\xcb\x0d\x06\x8b\xe0\xa1\x04\x3c\xb4\xfe\xe5\xb4\x3c\x96\x87\x97\x03\x97\x34\x2b\x19\xbd\xab\x5b\x74\x91\x1e\x24\x3c\x5a\x6e\x13\x3d\x98\xa6\x11\xec\x40\xd3\xf7\x62\x9a\xb3\xd7\xe2\x6a\xb9\xc9\x21\xc0\xf3\xdb\x72\xeb\xc1\x00\xcb\xf1\xe5\x92\x57\x3d\x01\x9e\xf7\xe2\x72\xb9\xb1\x14\xd2\x33\x5d\x6e\x20\x04\x68\x0e\xd3\x65\xaf\xb0\x02\x44\xef\x18\x7d\x70\xc3\x4e\xc5\x34\x1a\x2d\x7b\xae\x14\xa0\x59\x01\x9f\x01\xcf\xf2\xc7\x4a\x01\xa2\x03\x9a\x46\x6c\xb9\x33\x5d\x1d\x72\x0a\x06\xde\xa7\xc3\xfd\x83\xd3\xde\xab\x4f\xc7\x7f\x9c\x1c\x7e\xea\xe1\x30\x7c\xbf\xff\xd1\x84\x95\x82\xd1\xd7\x50\xe3\x10\x9c\xd3\x8d\x65\xff\xc4\x30\x9a\x1a\xce\xd8\xb2\x79\xd3\x89\xcd\xf9\x6d\x62\xd3\x05\xc8\x7c\xc3\x19\x01\x36\x6f\x0c\xfc\x6d\x38\x52\xed\x94\x93\xb2\xd9\xb0\x82\x6a\x73\x18\x8a\x5b\xc3\x95\x3e\x9b\x9b\xa0\x0c\x35\x5c\x91\x82\xdc\x42\x32\x30\x52\x0c\x6c\x78\x0c\xb5\xf9\x4c\x0a\x4e\xc3\x4a\x91\xcd\x31\xb4\x1a\xc9\xb0\x79\x39\xf6\x6f\xc3\xed\xee\x86\x61\xb6\xf3\xc2\x86\xec\x11\xbb\xba\x93\xcb\x4a\x0a\xd3\xef\x44\x5c\xe1\x26\x11\x97\xbe\x89\x18\xc2\x44\x1c\xb3\xb4\x50\x4b\xbc\x82\x63\x08\xa3\x3e\xc5\xc5\x30\x1c\x73\xc1\x8a\x30\x8b\x79\x8a\x0b\xb2\x3f\xa7\x34\x2d\x38\x2e\x91\xf0\xfb\x3f\x70\x5d\x5b\x44\xa7\xaa\x78\xce\xfe\x9c\x4a\xa4\x58\xa0\x18\x65\x2c\x1f\x89\x24\x6e\x9c\x2b\x52\xdd\x87\x39\x40\xab\x5e\x02\xdb\xfd\x6b\xc6\x22\xa8\x38\xe2\x59\x84\x75\x45\x99\xc8\xe1\x20\x29\xe6\x74\x2c\xd4\x7e\xb7\xc0\x96\x15\x19\x07\x1b\x26\xb8\x2e\x9b\x31\x73\xec\x75\x8e\x6f\xc7\xd6\xc8\x13\xf2\x96\x61\x20\x3e\x65\x5e\x81\x4e\x6c\xc5\xc0\x8d\xfb\x25\xc1\xfe\x75\x42\x33\x3a\x26\xe4\x2b\x1a\xb5\xde\x82\x07\x1a\x72\x82\xbe\x66\x58\x6c\x1d\xd2\x00\xb0\xb2\xe6\xfa\x8a\xa6\xbf\xb7\xf8\xa6\xee\x75\x50\x83\x5b\x64\x53\xc5\xbe\x0c\xa2\x2c\x7b\x91\xf6\x6c\x0e\xf8\x93\x71\x9e\x22\xdb\x9f\xe6\xb1\x70\xa3\x81\x6f\x0f\xbd\xd7\x96\x40\xb3\xeb\xc7\x2c\x28\x24\xf3\x75\x31\x27\xc9\xf3\x75\x73\x73\x83\x69\xda\xd9\x6f\xc3\x34\xa3\xa1\xdf\xe4\x49\x16\xbc\xe1\x69\x0c\x1e\xf1\xb5\xb9\x5b\x92\x90\x31\x2d\xa2\x11\x8b\x6d\xa4\xcc\xfe\x0c\x5e\x1c\x77\xc8\x67\xf9\xf1\x59\xc7\x16\xa1\x04\xec\xf3\x75\x4c\x4c\xe5\xb1\x42\x64\x12\x2f\x12\x6e\x38\xe6\x3d\x6f\x72\x19\xe6\x65\x34\x75\x8d\x6d\xa8\xcf\x06\x47\xcb\x58\x8e\x86\x92\x67\xe0\x13\x41\x26\x15\xca\x45\x92\x4c\x51\xdc\x5b\xc6\x86\xb6\xd9\x02\xa6\x5b\xc7\x1c\x0a\x2d\xb4\x77\x4c\x27\x8e\xeb\x41\x27\xf4\x52\xe5\x5b\xb1\xa6\xf6\xf2\x59\xe1\x8c\xc5\x50\x1b\x16\x91\x75\x9f\x9b\xe7\xa7\xf7\xb0\x8c\xed\xd0\x8e\x7e\x0c\xd2\x19\x88\xec\x90\x46\x23\x87\x7d\x96\x6a\x48\x73\xc3\xbd\x41\x82\xea\x06\x8c\x18\xba\xbe\x8e\x5f\x3a\xf0\xde\x75\x7d\x5d\x15\x82\x9f\xa1\x4c\x39\x39\x8e\xf7\x6a\x2d\xbb\x2a\x2c\xd8\xf1\xa0\x69\x6a\x69\xc1\x9b\xe0\x8d\xae\xcb\x3c\xd9\x99\x9d\xc9\x34\x57\x14\xbb\xde\x1f\xd0\x4f\x94\x79\x77\x92\x43\xc0\xcf\xdb\x5d\x25\xad\x18\x97\x0a\xdd\x16\xf2\x2c\x2f\x7c\x51\xd5\x72\xda\x36\x11\x86\xe1\x21\x71\x31\x62\xd9\x15\xcf\x59\x47\x62\x58\x4c\x82\x95\xf8\x76\x3c\xf9\x75\x1e\xca\x85\x12\xec\x64\xdd\x2d\xc3\x73\x45\xbe\xdc\x7c\xd9\x21\xf8\xed\x6c\xeb\xdc\x1d\xba\x07\xf8\xcc\x1d\x43\x14\xc2\x11\xad\xd4\x56\x66\xd0\xb2\xeb\x28\x99\xc6\x3a\xc6\x85\x48\x59\x6e\xb8\x05\x5e\xee\x66\x13\x66\x9a\xe7\xbe\xec\x0b\xe2\x16\xaa\xe4\xda\x66\xa5\xec\x4a\xcb\x61\xe5\xf8\x74\x1c\x12\xfe\xcf\x18\x5d\x64\x8c\x82\xab\xc6\xea\x71\x59\x33\x2c\xd7\xd7\x49\xc5\xe0\x2b\xc1\x55\x8d\x44\xeb\xc8\x1a\x1d\xf5\x39\xbd\x19\x0e\x50\x7f\x68\x3a\x80\xe6\x89\xb7\x14\xca\x21\x2b\x60\x0e\xc1\x18\xd2\xf6\xe9\x26\xa1\xfa\xf5\x24\xc4\x52\xbe\x1c\xea\x31\x57\x39\x69\xb3\x84\xec\x63\x40\x12\x33\x34\x6d\x5c\xea\x49\x8e\xf3\xbe\x97\xef\x4d\xe7\x1a\x0d\x21\xb6\x5a\x18\xd6\x18\x31\xc0\xce\xe2\xd5\x8f\x4b\x83\x09\xbd\x1a\xa8\xc9\x5c\x27\x23\x2c\xc1\x48\xde\x4b\x3d\x60\x69\xb6\x24\xb2\x60\x8e\xd7\x11\xde\x40\xe6\x24\xb9\xda\x53\xf3\xfd\xe4\x8f\xe7\xbf\xd3\x84\xc7\xda\xe1\xa3\x24\xfa\x25\x61\x09\xba\x7a\x26\x3b\x84\x25\x66\x68\x3e\xaa\xc7\x3c\xe7\xe9\x51\xb3\x85\x01\x0a\xef\xa4\x5f\x4c\x0b\x27\x70\xdd\xe6\x26\x61\x79\xc2\xd3\x62\x43\x79\xd4\xdd\x48\xd9\x75\xb1\x21\x17\x92\x24\x15\x1b\x19\xc3\x57\xfd\x2c\xde\xc8\x67\x69\x41\xaf\xd7\x3c\xaf\x4a\x3c\xf5\x1d\x2e\x49\xf2\xbf\xde\x56\x46\xaa\x57\x8e\xa3\x79\x4b\x0e\x93\x1a\xb3\xfc\x33\xee\x38\x43\x05\x56\x88\x69\xd1\x52\x14\xdb\x30\x84\x62\x5a\xe0\x23\x01\xdf\x3f\xd3\xad\xbf\x12\x13\xd3\xa2\x76\x44\xb0\x4b\x88\xea\x76\x9f\xa1\x40\xe4\x60\xd0\x7f\xcb\x0c\x0a\x8d\x50\xcb\x1d\x44\xe5\xff\x37\x88\x7b\x9e\x41\x48\xf9\x91\xfa\x2e\x06\x48\x5f\xdd\x50\xb2\x7f\x73\x06\x55\xe5\x7b\x69\x7f\xba\xac\x00\x68\xb2\xa4\xed\x90\xf5\x3f\x03\xeb\xef\x36\xb0\xc2\x23\xba\xfb\x8e\x28\x47\x24\x31\x5e\xd4\x02\xe3\x4b\xe9\x70\x10\x25\x5d\xd8\xd7\xdc\x6e\x56\x53\x64\x7c\x28\xf7\xc0\xea\x77\x9b\xc4\xb4\xa0\x6d\x8c\x10\x8b\xb4\x96\xbc\x8e\x19\x27\xbc\x41\xd9\xa6\x53\xb4\x4d\x4c\xf4\x84\xb0\x83\x2c\x99\x15\xef\xf8\x6b\xc6\x84\xce\xd6\xec\x2d\x11\xf9\xff\x5f\x81\x92\xc9\xcb\x2b\x02\x2d\x53\xad\x7b\xc9\x65\x28\x44\x1a\x8b\xdf\x31\x0b\xcd\x03\xda\x9f\x02\xba\x95\xe6\x71\x31\x82\x7d\x37\x5e\x34\xb8\x2a\x3c\x1a\xd1\xac\x5a\x85\x7b\xcb\xa3\x32\x98\xd6\xd9\xaf\x30\x16\x8e\x54\xda\xe0\x4c\xf3\x68\xe0\xcc\x12\xa5\x9a\x69\xc6\x88\xbe\x88\x92\xc9\x43\xd8\x56\xc8\x89\x85\xa6\x64\xcb\x28\xf6\x0a\x77\x10\xae\x08\x57\x64\x57\xad\x90\x1e\x69\x0d\x19\xc8\xa0\x71\x58\x78\xab\x64\xb0\xc7\x92\xef\xb5\x62\xd6\x65\x8c\x2b\x24\x68\xc2\x9e\x85\xe9\x40\x8a\xce\x1e\x69\xe2\x6c\x3e\x26\xa1\xff\x62\xa0\x06\x39\x39\x67\x37\xe2\xbf\x8e\x3c\x7b\x3c\x78\x4c\x36\x9f\x10\x9e\x7f\x00\x4e\x91\x27\x9b\xe7\xad\x26\xd4\xda\xc2\xf0\xdc\x92\xa2\x5f\xf6\xc8\x16\x34\x72\x25\xd8\x91\x66\x40\xaf\x5a\xf4\x8b\x13\x53\xa5\xcc\x37\x2b\x79\xe8\x7d\x4d\xeb\x1e\xf0\xa5\xe1\x76\x15\x24\x34\x3d\x95\xf7\x48\x9f\x3c\x5d\xf1\x34\x16\x57\xe8\x54\xd9\x38\xd1\x6a\xc8\x91\x87\x39\x9d\x58\x44\x10\x67\xbe\x22\xc9\xf7\x2d\xee\x00\xe4\xac\x38\xe5\x63\x26\x47\x9a\x25\xeb\xe4\xf7\xb7\xbd\xd3\xfd\xb7\xea\xac\x13\xed\xdd\x8a\xb7\xc9\x6c\x32\x72\xbf\xbf\x66\x03\xf7\xe7\x51\xc1\xc6\xf0\x3b\xe5\x63\x5a\x30\xe7\x2b\x58\x9d\x39\xbf\xdf\x8b\x42\x5d\x70\xab\x84\x53\x7d\x43\x19\x9c\x4a\xaa\x77\x86\xea\x9a\x58\x64\x1b\x13\x7c\xf9\x06\x09\xf0\xe2\x0c\xce\x2c\xd9\x00\xcf\x2e\x59\x0e\x06\xed\x2c\x49\xb8\xba\x50\x1e\xb0\x57\x89\xb2\x3d\x18\x20\x19\x63\x5a\x64\xfc\x5a\x27\xa8\x53\x37\xac\x1f\x4d\x6f\x54\x72\xce\x0b\xa6\x7f\xa6\x97\x22\xb9\x64\xef\x9d\x92\xaf\xf9\x60\x30\xcd\xd9\x3b\x65\x4d\xab\x13\xe5\x76\x2e\x02\x0e\xbf\xa7\x13\x93\x58\xd0\xb4\x00\x48\x4c\x79\x93\x08\xa1\x28\x92\xca\x70\xdf\x7e\x7d\x65\xbf\xbe\xb5\x5f\x3f\xe1\xd7\xb7\x74\x9a\xe7\x9c\xa6\xaf\x92\xa9\xa2\xf3\x68\x4c\x87\x8a\xc6\xf7\x2c\xf3\xbe\x7e\x10\xb1\xfe\x29\xb2\xc9\x48\x24\x62\x38\xc3\xdf\xc7\x60\xe0\x85\xdf\x3f\x0a\xee\x51\x76\x32\x61\xd1\x34\xa1\x99\xdf\xac\x93\x89\x70\x81\x4e\x15\xff\x07\xec\x74\x9a\xf5\xa7\x09\x4b\x23\xa6\x6c\x24\x95\xf1\xd2\x40\xe0\xb9\xb6\xfc\xdc\x18\x50\x95\xad\x7f\x6c\x0c\xa0\x13\xfc\x34\x08\xe7\xef\xa5\x4c\xf1\x3e\x7b\x20\x32\xc6\x87\x29\x0e\x5a\x30\x94\x80\xff\xb4\x28\xc2\x97\x4f\x28\x87\xa3\x0b\x96\xa1\xd5\x84\xe6\x8b\x6b\xfc\xf1\x36\xa3\x31\x67\x48\x18\x1a\x0a\xe3\xb7\x1c\xac\x40\xc6\xac\xa0\x72\xd2\x40\xab\x95\x3c\xe7\xe9\x70\xc3\x54\x32\x9e\x28\x19\x74\x3e\x0b\x55\xd7\x44\x24\xb3\xa1\x30\x5f\x75\x8d\xb2\x32\x9a\xb8\x75\xea\x33\x77\xf4\xaa\x8a\x07\xf9\xf8\x51\x88\x09\x7e\xce\x90\xb1\xf9\x25\xb4\x31\xbf\xe2\x45\x04\xd5\xe5\xb3\x71\x5f\xe0\x69\x3f\xbb\x2e\xf4\xa7\x1e\x18\x05\x2f\xb0\x5c\x91\x21\x1f\x8a\x7c\x42\x81\xa0\x69\xae\x4c\x5a\x19\x5c\x4d\x5c\x02\x7f\xce\xad\xe6\x31\x3e\x75\x02\x05\x64\xd2\xdd\xb3\x0f\xed\x3f\xb3\xfa\xf0\xa3\x5e\x9b\xce\xf1\x08\xd2\x6c\x39\x87\x21\xb0\xb0\xd0\x7a\xa7\xe2\xb0\xa4\x45\x7e\xdd\x23\x5b\xde\xa4\x8d\x2f\x6a\xcd\xfe\xcd\xd9\xac\xe5\xee\x61\x9b\x37\x4b\xc3\xe9\xd5\xad\x3d\x88\x3b\x1d\x31\xfb\xe3\x8e\x93\x0b\x55\xd6\x6e\xf8\x2a\x2a\x0e\xf6\x5a\x8e\xdf\xa2\xf2\x9a\xd2\xc9\x34\x27\x4f\xf6\xec\x2e\xf7\x8a\xaa\x93\xf4\x6f\x70\xbe\xc5\x52\x27\x82\x96\x9c\x7f\x21\x41\xf6\x06\x7c\x79\x70\x17\x5b\x2c\xd5\x5d\xec\xe6\xff\xea\x05\x26\x73\x38\x80\xe7\x5d\x48\x6a\xdd\x81\xb4\x03\xee\x4d\xb0\xa1\x3b\x28\x5f\xd8\x83\xdc\xa6\x5c\x3f\xc3\xcf\x36\x99\x64\xec\xf2\xc0\x8e\x80\xf9\x27\xa4\x75\xde\x7e\x9a\x2d\x8b\xb2\x35\x9f\x8f\x73\x50\x58\x52\x82\x35\x86\x76\xf4\xac\x0e\x4b\xef\xd8\x80\x2c\x4c\xe4\x72\x38\x6a\xa9\xbc\x73\xcd\x15\xb8\xa4\x38\x7b\xdc\x87\x45\x57\x3e\xa2\x49\x22\xae\xb4\x1b\xaf\x73\x87\x4c\xb5\xea\xb4\x9d\xa4\x96\xae\xe1\x7a\x4b\x2d\xc2\xe0\x96\x02\xb4\xc6\x1f\x0c\x5c\x99\x9a\x35\xbd\x19\xfd\xd1\x88\xa6\x43\x16\x57\x2e\xea\x4d\xb5\x5a\x67\x24\x14\xa2\xb4\x57\xea\x18\x5d\xc8\x90\xa6\x0b\xc9\x04\xbf\x48\xc5\xae\xc0\xfe\x31\x68\xb6\xc8\x48\x2a\xec\xf5\x66\xe0\x66\xcc\x97\x66\x2f\xab\xe9\x12\xdd\xf6\xa8\xb1\x02\xed\x35\x6c\x6f\x6f\xaf\x02\xac\x2c\x6b\x77\xdf\x17\x18\x6d\x74\xf6\x58\x23\x7b\x7c\xde\x89\x20\x8c\xb2\x5b\x25\x1e\x7b\x2f\x87\xc7\xa3\xf4\xae\x2d\x0b\x14\x59\xec\x1c\xe9\x2e\x92\xcd\xd1\x91\xc2\xb9\x57\x5e\xf9\x5b\x4e\x85\x90\xdd\x00\xb2\x42\x03\xdd\x97\x44\x91\x26\x33\x9f\xc2\x79\x46\x8b\x73\x70\xf8\x0c\x35\x3d\x5d\xe5\x30\x1f\x1a\xe4\x79\xca\xc7\xeb\x26\x45\x04\x1c\x1a\x59\x82\xcc\x69\x11\x9e\xe8\xa9\x5a\x88\x2f\x6c\x00\x64\x26\xa1\x25\xaf\xa2\x1c\x2d\x36\xf7\x64\x72\x2e\x92\xb2\x1a\x53\x1b\xd3\xda\x01\xe6\xce\x15\x6e\x6c\xa8\x50\x1a\xed\x5d\x8e\xab\xaf\x17\x9d\x85\x4a\xd7\x67\x0e\xde\xd0\x3b\xbf\xbf\xcd\xf4\x7c\x04\xba\x2a\xc3\xcb\x70\x96\x07\x98\xfe\x9e\x4e\xec\x7a\x84\xf9\x8b\x11\x7d\x6f\x1a\x89\x2c\xb6\x51\xbb\xee\x2b\x77\x77\x5e\xbc\x79\xc7\x6b\xc1\xfd\x5b\xc5\x52\xd5\xb2\x88\x79\x2b\x07\xef\x2a\xdb\xb2\xde\xa0\x32\xed\x0d\xef\x17\x9d\x05\xe8\x79\x10\x14\xc2\x33\x32\xa9\x2f\xb6\xeb\x94\xe9\x99\x7a\xbe\xb7\xc5\x4d\x98\x34\x59\xbd\x83\xf5\xdc\x0d\xcb\x39\x32\x67\xa8\x95\x38\x3a\x2a\xdf\x2d\x22\xd2\x88\xd5\xc2\xcb\x4c\x1b\x97\x53\xf2\x02\xc0\xe5\xd4\x8f\x7d\xea\x51\x02\x07\x27\x12\xc0\x15\x6e\x7b\x6f\x2e\x65\x42\x11\xa0\x7b\xcd\x29\x6d\x0f\xe2\x4c\xd1\x07\x8c\x70\x55\x63\xcb\x0f\xc1\xe6\x0a\xa7\xfe\x2e\x95\x77\x1a\xd1\xa2\x59\xe1\xb5\xca\x60\x71\x82\xa1\x95\x23\xd9\xf9\x32\xa4\xcb\xb8\xf1\xd3\x9c\x91\x5e\x66\x9a\x1f\x86\xe3\xb6\x66\xd9\xca\x4a\x6b\xd6\x0a\xdf\x9a\xc1\xd9\x79\x98\xdd\x74\xee\xfc\x0b\x04\x87\xbe\x64\x20\x82\x66\xc2\xd2\x4b\xf9\x1a\xd3\xc1\x33\x99\x7f\x1e\x4c\x50\x73\x61\xc3\xc5\x16\x1e\x4b\xeb\x76\x04\x7e\x3a\xdd\x36\x04\x59\x5a\x6a\xca\xbb\x20\x63\x98\xb1\x01\x91\xa6\x57\xa9\x5f\x60\x37\x51\xa1\x5f\x70\xff\x23\x27\x6b\xef\xea\x9f\x58\x5a\xa0\xc8\x02\x76\x31\x81\x6b\xf5\xe7\x2b\x8c\xed\x30\x27\x64\x99\xc5\xad\x62\xb2\xb5\xc8\x57\xb5\xf6\x3d\x10\x93\x59\x06\xc7\x95\xdb\x5b\xdd\xe7\x1b\xdb\x5b\xdd\x17\x6d\xf2\x86\x46\xac\x2f\xc4\x45\x9b\x1c\xa5\x11\xd8\xe1\xc8\x8d\x2d\x80\xe5\xb2\x35\x2c\xbb\x64\xb1\x4c\x97\x59\xa7\x23\x9e\x93\x5c\x4c\xb3\x88\x91\x48\xc4\x8c\xf0\x9c\x24\x3c\x02\xaf\x17\x04\x5e\xdf\xc0\x96\xf8\xd5\xc9\xeb\x0d\x38\xd0\xd0\x99\x64\x20\xa6\x29\x44\x4a\x2d\x46\x4c\x22\x7a\x77\x74\x70\xf8\xe1\xe4\x50\x6e\x85\x99\x4a\x26\x99\x10\x85\x72\x02\x25\xb2\x19\xc6\x40\xb5\xd5\x15\x19\x63\x1d\xb2\x9f\x12\x1a\xc7\x5c\xb6\x8f\x26\x64\x98\x51\xdc\xa4\x8b\x01\x99\xd0\x82\xa5\x85\x26\x5c\x19\x11\xb9\xd5\x92\x8f\xfb\xa7\x87\x1f\x4e\x4f\xbc\x3a\x73\xa9\xbf\x4d\x9d\x68\x54\xb4\x66\x8e\x18\x4e\xf8\x98\x27\x72\x50\x09\xc2\xd3\x4b\xf4\x85\x41\xfa\xd3\x02\x23\xb6\x26\x62\x98\x13\x4a\x54\x4c\x54\x29\x3c\x10\x9a\x54\xa4\x48\x9f\x8e\x49\x3a\x66\x45\xc7\xf0\x4e\xd1\x05\xae\x8b\x0b\x21\x51\x10\x9e\xe7\x53\x96\x63\x60\x9f\x4b\x96\x88\x09\x9c\xc9\xb0\xf4\x92\x67\x22\x45\xb5\xc6\x53\x12\x65\x1c\xbc\x41\x48\x4c\x13\x5a\x8c\xf2\x0e\xf9\xc4\xc6\xe2\x52\x1b\x11\x25\x62\x38\x94\xdf\xa1\x57\xe4\x9a\xcd\xc6\xdd\xf3\x71\x5d\xf1\x24\x21\x17\x8c\x4d\x74\x57\x00\x0b\x12\x31\xe4\x11\xdc\x31\x60\xcc\x59\xcb\x1c\x40\x88\x35\x22\x77\xc0\x28\x49\xb5\x79\xcf\xf3\xd0\x2b\x65\xfe\x9e\xc1\x00\x2b\x10\x19\x06\xb6\x09\x9e\x15\xb6\x09\xcd\x86\xb9\xbb\xd2\x4c\xc0\xa0\x89\x66\xc3\x29\x2a\x68\xe5\x32\x10\xf2\x25\x2c\xde\x5a\x2a\x27\x83\x12\xf8\x57\xb2\x4d\x5e\x42\xb1\x0d\xb2\x4d\x76\xc8\x96\x52\xe3\x66\x71\x7b\xc1\x66\x64\x8f\x6c\xef\xc2\x97\x5f\x24\x24\x7c\x75\x43\x41\x49\xc4\x67\x32\x7b\x83\x6c\x9f\xbb\xd5\x3b\xd1\x55\x6f\x8d\x1a\x41\xd2\x41\x8f\x98\xc3\x7a\x8b\xcb\xc6\xde\xc0\xb8\x1b\x66\x22\x69\x7c\x56\x1c\xa9\x62\x43\xa7\xd3\x01\x4e\x7c\x26\x4a\x37\xb8\xe2\xd7\x20\x4f\x2d\x96\x31\xcb\x73\x3a\x64\x86\xc6\x86\xca\xf2\xa3\x25\x5a\x3a\x15\x07\xc9\x2f\xa4\x0b\xd7\x24\xcd\xcd\xff\x77\x96\xff\xe7\x1f\xe7\x4f\xbe\xdf\x6c\x75\xe4\x56\x57\xc1\xb5\x16\x69\x82\xdc\xeb\x6a\xaa\x14\x1b\xf2\x91\x98\x26\x31\x98\xf5\xf5\x13\x0c\xc4\x9a\xf2\x3f\xa7\x2c\x99\x11\xb4\x91\x1e\xcc\x70\xb0\x7b\xad\x50\x48\x3a\xe4\x63\xc2\x68\xce\xda\x10\xbd\x95\x62\xa4\x58\x1d\xa0\x8a\x5f\x32\x5d\x49\x31\xa2\x29\xc6\xe3\xc5\x84\xda\x36\x3f\x32\xbc\xf5\xd7\x74\x34\x1b\xea\xa9\x6a\xcb\x5d\xb7\x69\x6e\xee\x91\xc6\x1f\x54\x39\x32\x71\x09\x55\x3c\xcc\x18\x9c\xff\x37\x37\xff\x25\xdf\x1c\xfa\xbe\xab\x9d\x55\x85\xf1\x5d\x39\xcc\xcf\x74\x85\x4f\x9f\x3a\xd1\x79\x6f\x5b\x6e\xdc\x2f\x75\xf9\x13\x89\x34\x17\x09\x0b\x6f\x7f\x5c\xd4\x0a\xa4\xc3\xa0\x3b\x14\xcd\x2d\x7f\xfd\x41\x88\x9c\xdc\x6c\x99\xcd\x4d\x54\x4b\x50\x86\x5c\xd1\x1c\xbb\x35\xc5\xd8\x76\x91\x48\x2f\x59\xca\x99\x5c\x1a\xe6\x42\xf2\xb7\x20\x33\x15\xb3\x1a\x03\xe9\x4a\xf5\x5c\xd0\xe8\xc2\x45\x58\x08\x30\xa3\x44\x65\x48\x93\x24\xe7\x70\xb1\x4a\x0b\x12\x51\xd4\x7b\xb2\x98\x16\x10\x80\xce\x98\x8d\xb5\x1b\xca\x55\xa9\x21\x24\xa2\x45\x34\x6a\xca\x49\xdb\x59\x54\xed\xae\xdd\x56\xc4\x38\x54\xb5\xc0\x5c\xbc\xea\x20\x9f\xdd\x17\x7f\x5d\xac\x14\x3e\x1e\x4f\x21\xc4\x4c\xe0\x45\xdd\xe0\x3e\x7b\xdc\x7f\x7c\x0e\x31\xe4\xed\x91\xd9\xb2\x98\x28\x60\x9a\x98\x03\x39\xf5\x48\x57\x64\xbb\xd6\x15\xac\x5b\x4f\x93\xb6\x49\x1f\x25\x71\xf3\x49\x60\x90\x50\x69\x86\x20\xf9\x16\xe8\x5e\x9e\x12\xba\x80\x1d\x02\x55\x81\xe5\xd7\xd7\x49\xf3\x51\x0d\x4c\x5f\xc1\xdc\xdc\x10\x8a\x51\x36\xe5\xa0\xe9\x63\x5c\xed\xbb\x37\xd1\x0e\x61\x3d\x45\x59\x7f\x01\xca\xfa\x18\x9a\x1d\x8f\x4f\xeb\xa9\x07\x98\x45\x88\xf0\x37\xf2\x6b\x2e\xe7\xa5\x2a\x35\x77\x97\xbf\x4d\x62\x5a\x30\x6d\xa0\x91\x17\xb4\x60\xfe\xf5\xb1\xd7\x53\x0a\x0c\x62\x54\xab\xbb\x7e\xb9\xb7\xf3\x60\x00\x87\x82\x41\x7c\x3e\x01\x15\x82\xd1\x8c\x6c\x2c\xf5\xaf\x77\xdb\xa5\xc0\x49\xe9\x46\xc6\x68\x9e\xf3\x61\x0a\xbe\x48\x75\xc8\x6d\x13\xa0\xa9\x53\xd9\x4e\x90\xf0\x8a\x74\xa0\xd0\x1f\x9d\x3f\x3c\x68\xb9\x2d\xbb\xbf\x4f\x73\xf6\x96\x15\xa7\x74\x58\xe3\x23\xf9\xc5\xb3\x16\xee\xb8\xb5\x41\xcf\x3c\xaf\xf2\x92\x16\xf2\x19\xe1\xfe\x57\x21\xf0\xaa\xe4\xb3\xde\x55\x64\x3a\xe6\x5d\xde\xd1\x47\xbd\x34\x9f\xa5\x11\x56\xde\x38\xc3\x27\xb4\x64\x5f\xa6\x69\x1b\x9a\xf3\x06\xd6\x2e\x5b\x17\xc0\x85\x20\x43\x96\x06\x10\x6f\x59\xca\xa0\xef\x42\xd0\x49\x26\xae\x67\x01\xf0\x47\x99\x76\xde\xb0\x77\x6f\x07\x23\x16\x5d\xe4\x72\x3c\x7c\x86\x60\x59\x9f\xe5\x62\x17\x2c\xf4\xf1\x29\x0f\x4c\x1f\x9f\x35\xea\xcf\x04\xf1\xe8\x5d\xc4\xbf\x62\x38\x46\xf8\x3a\x66\xe3\x3e\xcb\x8e\x07\xa4\x87\x39\x5c\x4e\x36\x5b\x9d\x6e\x67\x0b\x7e\x47\xb4\x60\x43\xb9\x1b\x78\x47\xe1\xc9\x8a\x3e\x66\xff\xfa\xe4\x16\xc3\x74\xc1\xc9\x3a\x7e\x2b\x04\x89\x24\x5d\x1d\xe7\x6c\x3d\x27\x5f\xfb\xfa\x70\xfd\x93\x4a\xf9\x2c\x07\xd5\xe7\x80\x78\x37\xa0\x19\x9c\x04\x7c\x86\x41\xf9\x19\x91\xb1\x6b\x3a\x9e\x24\x4c\xd1\xdf\xeb\x58\x43\xa6\x66\x4f\xce\x4c\x4f\xa4\xc8\xef\xfd\xaa\xa2\x7c\x95\x81\x36\x69\x3f\xda\x74\x01\x01\x39\xac\xa7\x9d\xf3\x7b\x03\x1e\x04\x37\x7e\xa4\xe5\x4b\x65\xcc\x3b\xed\x86\x19\x1d\x36\x18\x72\x53\x54\x96\x37\x7a\x29\x78\x9c\xeb\x4d\xc7\x15\x2f\x46\x18\x0f\x1f\xd7\x19\x9f\x89\xd4\x57\x52\x2c\x10\x15\x4f\xc9\x09\x1d\xd0\x8c\x93\x9f\xc9\xd5\x88\x47\x23\xa2\xd9\xda\xc0\x2e\x6d\x80\xb6\x94\x85\x63\x7c\xe7\x90\xc3\x26\x02\x1e\x76\xb8\xc1\xd5\xe4\xe6\x01\xcf\x27\x40\xb2\xec\xd0\x52\x4d\xda\x75\x54\x9e\x84\xd8\x33\x52\x7d\x73\xa3\x53\x94\x10\xdb\x04\x33\x42\x6c\x92\x96\xde\xea\xe5\x80\x65\xf1\xee\x5a\xa8\x2f\xe6\xc6\xec\xfe\xaf\x11\xf9\xac\x2e\x40\xd5\x98\x16\xa3\x13\x3e\x4c\xff\xb2\xa8\x3c\x3c\xff\xc8\xb2\x88\xa5\xab\x8f\x3a\x54\x17\x6d\x49\xdb\x5f\xfd\x65\xc1\xa5\xa0\xc2\xe3\xec\xa4\x58\x7d\x95\x75\x11\xbf\x70\x4b\x74\xb4\xfa\x30\x52\x75\x41\xdc\x86\xac\x50\xfd\xf8\x3b\x44\x21\xff\xab\x22\xe5\x0d\x59\xb1\x9f\xce\xd4\xd1\xfd\xf1\x00\x75\xd4\xca\x6b\xaf\x8b\x13\x38\xa2\xf9\xeb\xe9\x24\xe1\x72\x6a\xf9\xcb\x62\xf4\x71\xe3\x0b\x9e\xd5\x08\xf2\x12\x71\x85\xbe\x4d\x50\x93\x72\x05\xfa\xfc\xfd\x61\xa1\x8b\x1e\x14\xd4\xc4\x31\x32\xf9\x40\x3f\xd4\xb6\xf9\xc7\xee\x92\xe1\x3f\x42\xfc\x0f\x68\x72\x88\xea\xc1\x11\x85\x50\x60\xe6\x44\x6b\x5a\x32\x72\x4f\x45\x15\x0f\x68\x76\x05\xb6\x07\x07\x14\xfa\x56\x71\xaa\x2a\xaa\x78\x40\xcb\x2b\xb0\x99\xd8\x29\x70\x7c\xa4\xa6\x67\xf7\x06\x44\xa7\x85\x4b\x3d\x5c\xc9\x56\x19\x15\x6c\xb9\x16\x05\x08\xf6\x6b\x09\xa8\x1b\x5e\xc9\x6c\x74\x5d\x63\x28\xa5\xed\x7d\xab\x11\x95\xe8\x52\xa2\x0a\x2f\xc5\xc0\x66\x4b\x63\x5a\x5f\xc7\x85\xb9\xb1\xf5\x6a\xfc\x4b\x03\xe3\x65\x63\xb2\x3a\x73\xdc\x20\x1e\x8d\xca\xce\xda\x23\x11\xd3\xee\x45\xe1\x1c\xe1\xf6\x28\x9c\x63\xea\x54\xa7\x13\x4c\xf9\x80\x6c\x58\x2d\x94\x08\x87\xd4\x0a\xd2\xc3\x56\x2d\xfa\x94\xaa\x96\xdf\x0e\x35\xf1\x81\x98\xca\x09\x07\x0f\x32\x65\x92\x5e\x5b\xb8\xe4\xe9\xb4\xe6\x24\x63\x03\x7e\x6d\x6f\xdd\xb8\x04\x7b\xfa\xd4\xa0\x71\xef\xb7\x1a\x0d\xf2\x94\xa8\x12\xe0\xbb\xa0\xd1\x22\x4f\x09\x8f\x5d\x1b\xab\xb7\xac\x20\x13\x25\x6a\x28\xa9\x60\x5a\x59\x88\x82\x26\x98\xe0\xee\xe4\x90\x0d\x37\xda\xcf\x83\x2e\xb8\xaf\xbf\x95\x61\x6f\x11\x15\x2c\x5a\xe0\x18\xe5\xb4\x06\xf3\x6f\x08\xad\x38\xa5\xe1\xed\x8e\x11\xdb\xc4\x62\x72\x35\x62\xa9\xa9\x99\xe7\xf6\xc8\x9e\x88\x0c\xae\x7e\x12\xee\x5a\x86\x59\x83\x2d\xf3\x72\x04\xfe\x8e\x06\x24\x67\x85\xdc\x88\xf6\x19\xc6\x82\xc6\x8b\x2d\xdc\xe3\xc3\xcd\x4b\x9f\x99\x32\xb1\x67\x03\xa6\x9b\xa6\x5b\x61\x1f\xc2\x3a\x4b\xb4\xf0\xf9\xab\x93\xd5\x54\xe4\xb7\x1d\xe6\xd8\x2e\xf5\x58\x50\xbe\x3a\x81\x0b\x92\xf5\x75\xe7\x4e\x63\x1b\x8f\xcd\x2c\x23\x5e\xfa\x99\x3b\xa8\x90\xdc\xe7\x27\xd5\x78\x9f\xf9\x78\x9f\xcd\xc3\xfb\x4c\xe2\x55\xdb\x59\xbb\xf7\x55\xe3\x44\xb5\xef\xae\x51\x3b\x7f\xa8\x68\x24\x81\xde\x74\xd9\xe3\xbd\xb7\x52\xfa\x38\x7c\x2a\x6f\xb5\x66\x88\x10\xc6\x8f\xba\x44\x50\x79\x9e\xfe\xd3\x96\x50\x88\xd6\x91\xe3\x27\x78\x2b\xfe\x26\x11\xd4\x60\xed\xe4\x09\x8f\x58\x73\x4b\x5f\x53\xb7\xc8\x26\xe9\x6e\x6d\x95\x9e\xc7\x6b\x74\x4f\x55\x39\xcf\x4c\x0f\xb4\x57\x70\x72\xa0\x0b\x54\xb6\x5b\x4d\x30\xd8\xa7\x5a\x89\x93\x5f\x4b\x72\x55\xd5\x8c\x70\xfe\xb9\xc4\x44\xc7\xb6\xa1\xbc\xf2\x0f\x84\xba\x0c\xa0\x82\xec\x6b\x89\x30\xbf\xea\x9f\xc9\x5d\xb0\x99\xdc\xef\x63\xf1\x8e\xfc\x05\x38\x4c\xff\x41\xfe\xfa\x3a\xc0\xe9\x08\x64\x3e\x4a\xd1\xff\x72\x26\x73\xcf\xb6\xce\xef\xb0\x73\x70\xf7\x13\x6e\x53\xdc\xf4\x26\xd5\x46\xd6\x8b\x9b\xe8\x96\x8d\x5f\x24\x92\xb9\x8f\x8c\xdc\xbb\xd1\x99\x73\x2b\x0a\x26\x90\x34\x1a\x31\x6b\xaa\x55\x65\xd6\x07\xb7\x9e\x8e\x51\x1f\xde\x95\xc9\x72\x67\x34\x9b\x9d\xf1\x73\xc7\x06\xca\x4b\xf6\x6c\x5d\x02\x4b\x9a\xc0\x26\xb2\x6c\xab\x66\x4d\x74\x71\xf2\x0a\x77\x4a\xde\x8c\x1a\x66\x36\xf1\x79\xdc\x7e\x5b\xbd\x93\x7b\x65\xb9\x6c\x14\x87\x02\x69\xa1\xd1\x98\x97\xf8\xaa\xc4\xcf\x39\xee\x2a\x14\x1e\xf2\x94\x14\xe4\x09\xd1\x18\xc8\x86\xce\xd0\x17\x8d\x25\x1b\x64\x83\xb3\x24\xb6\x80\xc1\x79\x90\xea\x1f\x49\xfd\xb4\xc0\x11\x36\x9c\x38\xdd\xe3\x54\x36\x25\x9f\x41\xb0\xfe\x16\x67\xb2\x29\x9e\x29\x2e\x76\x22\x8b\xb7\xfd\x67\xdd\x36\xd9\x6e\x93\x67\xe7\x73\x8e\x65\x11\xd2\xbc\x8d\xeb\x8b\x78\xd6\x89\xac\x7d\x6f\xe9\x90\xd6\x2f\xd7\xa0\xfd\xa8\x71\x37\x58\xaf\x93\x0a\x31\xa9\x3e\xf3\xc5\x25\x23\xc0\xe9\x58\x88\xba\xdc\x6e\xe5\xb1\xa5\xce\x0a\x04\xe4\xe7\x6f\x7f\x66\xb9\xf8\xa9\xc1\x37\x89\x3a\xba\xb5\x82\xa8\xa3\x5b\x0f\x8b\x3a\xda\xfd\x86\x51\x47\xbb\xab\x8a\x3a\xda\x5d\x41\xd4\xd1\xed\x1e\xe8\x8a\x94\x8e\xe7\x34\x74\x7b\x15\xb8\x1f\x74\xcc\xe0\x22\x6a\xe1\xee\xa6\xc7\xae\x0b\x96\xc6\xce\x94\x8f\x57\x8b\x72\x83\xe2\x68\x74\x9a\x0d\x59\x51\x0a\x4a\xda\xd5\xa1\x47\x03\x6b\x22\x1d\x80\x14\x5e\x63\xa1\x0d\x9a\x6b\xf4\xc3\xcf\x77\x4b\x57\xd8\x08\xa6\x03\xa2\x2a\x52\xec\x95\x66\xd5\x9d\x30\x16\xc1\x2b\x6b\x59\x10\x89\xc4\x7b\xeb\x3d\x85\x10\x0d\x8c\xc8\x2d\xfc\x33\xb7\x24\x12\x6e\x57\x4e\x1c\x4e\x80\x56\xd4\xe9\x7f\xa0\x6f\x28\x55\x11\x67\xb0\xf8\x81\x2a\x72\xdd\x20\x2c\x8e\xcb\x81\xc0\x27\x00\x2e\xaf\xcc\x32\xc9\xac\x5e\xb9\x7e\xa0\x15\x89\xb4\xe0\xe9\x94\xed\xba\xef\xb5\xef\x68\x26\x10\xc0\x5b\x6e\x61\xd5\x52\x78\xcb\x2f\x57\x5b\x5e\x68\x57\xd3\x3c\x33\xb9\xfd\xeb\x80\x27\xe0\x7c\xf2\x92\xb3\x2b\xf2\x8e\xce\x58\xa6\xad\xf5\xd6\xb4\xab\x90\x53\xe5\x26\x0a\x5d\x60\xd2\x3c\xff\x40\xc7\x73\xdd\x7f\x56\x8f\x3f\x3f\xb4\xa5\x9a\x18\x96\x42\xb3\x90\x0f\xea\xda\xd2\x30\xf9\x1d\x0f\x16\x1e\xf6\xae\x9b\x5e\x11\xb3\xb9\x0f\x41\xe6\x96\x3c\x6f\xad\x79\x72\x05\xdc\x6e\x3a\xce\x01\x8c\xb3\x3a\x74\x2d\x86\x2f\xf9\x8d\x95\xad\x5e\x22\xea\x1e\xb0\x10\x3a\x45\x83\xc0\x3d\x21\x38\x78\xa9\x93\x5c\x65\xb1\x70\xd6\xd0\xd8\xf1\x65\xb8\xc2\xd3\x38\xc7\x35\x3d\x2c\x7c\x25\x91\x07\xe0\x25\x6e\xde\x43\x9f\x6a\x4d\xd4\x6c\x35\x1b\x19\x03\xbf\x0d\xf9\x06\x60\x6a\xb4\x6d\x03\x3c\x0b\xdf\x7b\x4c\x56\x1d\xea\x3f\xbc\x47\x23\xb9\xc6\x50\x5d\xb5\x6b\xb5\xd5\xfc\xea\x4a\xab\xd3\x8e\xdb\xb6\xe2\x90\xb2\x33\xb0\x8f\xc7\x08\x1a\x65\x40\xc7\x74\x5c\xd1\x37\xdf\xd1\xe6\x49\xeb\x69\xad\x70\xd5\xfd\xc6\x7c\xd3\x9f\x26\xa0\x6d\x85\xeb\xd1\xed\xad\x15\x5a\x30\x6b\x13\x8b\x3e\x4b\x3e\x26\xd3\x21\x4f\xdf\x24\xe2\x0a\x0c\xdb\x3f\xea\x16\x80\x84\x4a\x01\xed\xc1\x03\x7d\x30\xd8\x7b\x3d\xc5\x70\x01\xb5\xd3\xb0\x3f\xe4\x2a\x21\xac\x6b\xf7\xca\x6c\x08\xdf\xd3\xfc\x0a\x91\x59\x95\x57\xe4\x39\x68\x3a\x3c\xff\x84\xa9\x31\x04\x73\xbd\xc6\x68\x1c\x8b\x95\x58\xbb\x6d\x81\x00\x2f\xc5\x8a\x03\x9a\x24\x7d\x1a\x5d\xd4\xb3\x42\xf6\xd1\xd2\xd8\xa5\x00\x1a\x65\x4a\x27\x13\x46\xeb\x59\xe1\x84\xbb\x06\xc0\xfd\xa8\xe0\xe8\x77\xf9\x0e\xf0\xf9\x1c\x0e\xe0\x16\xc7\x3a\xaf\x13\x7c\xb0\x85\x70\x96\xb7\x66\xdb\xdd\x07\x5b\x17\x0d\x13\xd1\x87\x07\x9c\xd5\x77\x77\x3f\xab\xa5\x4d\x24\x32\x56\x7b\xfd\xb1\xa5\x80\x46\x3c\xae\x03\x7a\xd6\x7d\xae\x80\x32\x86\x47\x6e\x35\x80\x3f\xfc\xf4\x93\xae\xb2\xb8\xae\x83\xf9\xb9\xab\x60\x3e\x7e\x3a\x3e\x3d\x3e\xfd\x8f\x8f\x87\x04\xad\xba\x71\xea\x6f\x28\x69\xfb\x5e\xa9\x99\x3d\x77\xf5\x05\xde\x3f\x53\x78\x11\x64\xd6\x49\x4a\x75\x1f\x9d\xf4\xde\x1c\x7f\x3a\x38\x7c\xad\x3c\x47\x92\x75\x8d\xa2\xf3\x66\xd7\xc2\xbc\x7d\x77\xfc\x6a\xff\x5d\x19\xe6\xad\x03\x73\x72\xba\x7f\x7a\x74\x50\x86\x39\x71\x60\x80\xf8\x32\xc8\x47\x07\xe4\xd5\xd1\x87\x0a\x62\x5e\x19\x0f\x9a\x7a\xf9\x64\xa9\x7a\xa9\x7b\x74\xc7\x21\x43\x27\x9e\xa5\xfa\x1d\x55\xd3\x4b\x90\xeb\xaf\x16\xd9\x09\x52\x6f\x6e\x64\xf2\x99\xe1\xb1\x79\x6f\x67\xb7\x84\x6e\xbd\x20\x22\x3b\xf0\xe1\xd4\xe3\xfc\x84\x5a\x1c\x1c\x1f\x65\x7f\x91\x3d\x8d\xce\xa9\x08\x4a\x56\x24\x7b\x18\x2e\xd8\xac\x4d\xc4\x55\xda\x26\x62\x5a\x80\xb4\xef\xaa\x23\x17\x43\x55\xcb\xae\x98\x25\x09\xbb\xfa\xc0\x29\x5c\x27\xaf\x29\x9b\x61\xb9\x2a\xa4\x3c\x85\x97\x0e\x29\x95\x43\x12\x7d\x7b\x5d\x49\x45\xff\xc8\x8a\xc7\xfa\xba\x66\xbd\xf9\x66\x4d\x3c\xcd\x99\xf2\xae\x46\xab\xc4\x10\x31\x12\x91\x91\x89\x54\x6a\x31\xe2\x06\xbf\x52\x4d\x59\xc5\x4b\x8d\x74\x47\x53\xe6\x98\xf4\x6f\x6e\x92\x3e\x98\x33\xf3\xb1\x5c\xaa\x14\x42\xf7\xb3\x6c\x90\x5c\xdb\x92\x41\x26\xc6\xba\x2a\xd9\x10\x76\x8d\xa6\xe7\xec\x7a\x82\x3d\x05\xc2\xb4\xbe\x4e\xb0\xae\xa8\xb8\x6e\x02\xe3\x10\x4f\x0b\x05\x06\x65\x52\xb9\x0b\x15\x03\x24\x6f\x8f\x34\xf4\x00\x6a\xa8\x92\xda\x80\x09\x96\xd5\xd0\x03\x12\x01\x38\xb4\x32\x8d\x96\x8b\x0a\x85\xdd\x9c\xe3\xe9\xcd\x8f\xd6\x02\x2a\xa1\xad\x7a\x53\xd2\x13\x08\xfb\x6f\xad\x80\x8f\xf6\x89\x94\x12\x10\xc5\x79\x24\x42\xea\x20\x6b\x43\x0d\x58\xd9\xf5\xc4\x71\x42\xec\x36\x52\x0b\xa1\x8f\xc2\x4f\xdd\xd3\xad\xba\x95\xfa\x17\x9b\xd3\x51\xea\x50\x7e\xec\xae\x6d\x6e\x22\xcd\x7d\x5e\x8c\xe9\x64\xcd\xa8\x0c\xdc\xd4\x01\xe5\x03\x91\x45\x2c\x36\x59\x6f\xf1\x91\x07\x64\x29\x06\x19\x05\x41\xf6\xc8\x73\x95\xa5\xce\xc2\x8c\x62\x20\x7b\xe4\x27\x95\x05\xba\xce\xe4\xbc\x92\x55\xfd\xb0\x6b\xa4\xc4\x64\xfc\x41\xf6\xc8\xb3\x6d\xcc\xb8\xca\x1c\xe2\x7e\x23\x7b\xe4\x87\xe7\x98\x91\xd3\x01\x33\x19\x9f\x24\xaa\xed\x9f\x76\x65\x46\xc6\x68\x82\x35\x91\x31\x2b\x46\x22\x06\x61\xfb\x9c\xf0\x7e\x46\xb3\xd9\xe7\xf2\x09\x91\x42\x52\x3a\x21\xda\xde\xfe\xaf\x6f\xd5\x76\x55\x6f\x25\x04\x57\x0a\xaf\x66\xaf\x69\x41\xff\x37\x9b\xad\xdc\x58\x27\xad\xaf\xf9\xb5\x18\x53\x9e\x1e\x0f\x64\xd5\xaf\x66\xdf\xa2\xf2\x3a\xa3\xac\x88\x26\xd1\x34\xa1\x05\xc3\xa5\xc9\x29\x8f\x2e\xe0\x8d\xc8\xca\x09\xc8\xea\x5b\xff\x9e\xf2\x14\xdc\x65\x1d\x0f\xde\x66\x74\x32\xe2\xd1\x51\xc1\xc6\x2b\xa7\xe0\xcf\x7a\x0a\xde\xb1\x21\x4b\x63\xb9\x42\xcd\xff\x32\xfb\xbb\x21\x2b\x5e\xd1\xec\x84\xff\x83\xbd\xe3\xf9\xea\xed\xd1\xea\xac\x37\xb1\xda\x8f\x02\xd7\xdd\x7f\x99\x11\x9e\x5c\xa9\xa7\x31\xfa\x03\x3b\x1e\x20\xbf\x4d\xe5\xd3\x14\x5e\xea\x04\x34\x38\xe3\x02\xde\xe6\xbc\xa2\x59\x8e\xfa\x65\x65\xd4\xce\x6a\xa8\x85\xbb\x51\x53\xe9\xf1\x60\xff\x9a\xaf\x5e\x30\xc4\xdd\xfa\x40\x8e\x83\xfc\x0f\x5e\x8c\x4e\xe8\x98\x7d\x13\x22\xae\x6b\x0d\x52\x0f\xf0\xde\x85\xd3\xe4\x9b\x54\x3c\xae\x6f\xfd\x81\xc0\x20\x25\x05\xcb\xa5\x46\xe0\xab\x37\x51\x9d\xd6\x57\x2e\x35\xe0\xb7\xea\xf1\x3a\x73\xcd\x48\x8c\xfb\x3c\x65\xae\x7f\xd1\xd5\x57\xfe\x8f\x79\xb2\x7e\x12\xd1\x64\xf5\xe6\xa9\x75\x36\xb1\x70\x47\xa7\x65\xfc\xdb\x54\x5d\x67\xd9\x3d\xe0\x69\xac\x95\xdf\xf1\xe0\x15\x5d\xbd\xbd\xf5\xab\x9a\x9a\x8b\x6c\x9a\x46\xb4\x90\x0b\x0c\x68\xf9\x1d\xda\x0f\x63\xe3\x82\x21\x1f\xea\xbc\x5a\x25\x79\x52\xd0\xe8\x82\xc5\x72\xed\xb0\x62\xf5\x98\xd7\x0f\x13\xa8\xf4\x6d\x26\xa6\x93\xfc\xd5\x4c\x0e\x96\xa3\xbb\xd4\xb9\x59\x69\xe8\x8e\x87\x91\xb6\x62\x8a\x2f\xef\x1c\xd8\xdf\x46\xdc\x92\x39\xda\x0c\x7c\x92\x6a\x8d\x76\x3c\x78\xc7\xd3\xd5\xd7\x7f\xb1\x78\xfd\xdf\x42\xe6\xbf\xcc\x5b\x6c\xe4\x0c\x16\xd6\xdf\xa6\xe6\xba\x07\x15\x31\x2b\x58\x54\x7c\xd2\xef\xdc\xb4\xaf\xbe\x60\xe8\xad\x8a\x8a\xe2\x8e\x81\x82\xa3\x13\xe7\xf3\x95\x57\x3e\xb9\x7b\x1d\xe1\x8c\xd6\x3b\x46\xe9\xfb\xa3\x0f\xbd\xdf\xf7\xdf\xfd\x76\xd8\xfb\x74\xf8\x76\xae\xe6\x79\xbf\xff\x7f\x4b\x90\xab\x6a\xd2\xfe\xdc\xb9\x4a\x87\xf0\xfa\x46\x9d\x79\x50\x53\xb9\x36\x52\xb3\x83\xe9\x28\xfd\x44\xd3\xe1\xea\x47\x73\xdd\x43\x28\x18\x4e\x69\x2c\xf7\x0c\x35\x2b\x94\x7b\xbf\xba\xc8\x45\x56\xbc\xaa\x7f\xd5\xf1\xec\xc5\x92\x37\xf0\xa5\x0a\x56\xf1\xaa\x43\xe3\x7a\xf0\xa3\x8b\x6f\x65\xe9\x3f\xc7\x39\xe9\xc3\x9e\x76\x38\x96\xfe\x0f\x79\x7a\x31\xa6\xd7\xb5\x8d\xfe\xe9\xc5\x8f\xab\xc0\xbe\x8a\x37\x1d\x80\xe8\x81\x6f\x2d\xc6\x3c\x9d\x23\xd5\x0f\x7d\xc9\x01\xd8\x57\xf1\x88\x03\x10\x2d\x47\x4c\xd9\x73\xd9\x8a\x9f\x66\xd5\xbb\x46\x5b\xa2\xc5\x65\x64\xcb\x11\xf5\xa2\x2a\xba\x43\x5d\xc3\x97\x7c\xaa\x54\x59\xc7\x03\xda\x5e\x89\x6f\x39\xd2\x7e\xd0\xa8\x86\xac\xde\xfa\xed\xd9\xf3\x25\x7b\xdc\xc7\xfe\x80\x16\xfb\x88\x96\x23\xe6\xc7\xc0\xf7\x6f\xed\x95\xe3\x6a\xd0\x3f\xa0\xb5\x21\xaa\xe5\x08\xfa\xa9\xa7\x4d\x42\x7a\xb9\xdc\xa4\xcc\xd1\xd4\x4b\x76\x6f\xb9\x86\x07\x34\xba\x8c\x6c\x39\xa2\x7e\xee\xc5\xcf\xee\x68\xf0\xb3\x65\x1b\xdc\xdd\x02\xe4\x23\x3a\xa9\x47\xde\xfd\xf9\xe7\x25\x91\x77\xbd\xd8\x1d\x75\xe8\x97\x9c\x55\xbb\xdb\xbd\x5e\x44\xb3\x82\xe5\x9c\xa6\x3d\xb3\x91\x79\x2d\xe6\x0c\xfb\x9f\x97\x1c\x0a\xdd\x67\x95\x75\xc9\x9d\xea\x9c\xca\x96\x5c\x19\x76\x9f\x57\x56\xb6\x9f\x31\x3a\xa7\xb2\x67\x4b\x56\xf6\xc2\xad\x4c\x9f\xe8\xd6\x77\xd6\xd6\xb2\xb2\xf0\x43\xaf\x67\xdc\xca\xf4\xf0\x78\x7b\x8e\xc4\x2d\x2b\x13\x3f\xf6\x7a\x60\x4b\x73\x87\xc8\x3d\x33\x0f\x42\x95\xe1\xd3\xff\x58\xac\x2a\x8b\x55\xbc\x8d\xd6\x35\x18\x43\xd5\x36\xd1\x2f\x26\xb5\x21\xaa\x63\x9a\xaa\xc8\xac\x2d\xfa\x15\x0b\xef\xe0\x47\x9b\xb0\x74\x3a\x66\x19\xed\x27\x6c\x47\xbd\xca\x8b\x44\x3a\xe0\xc3\xa9\x97\x76\x95\xf1\xc2\xfe\x96\xfb\x38\xf3\x94\x45\xbf\x06\x92\x0d\xbc\x54\xae\x12\x9c\x87\x42\x60\xa6\x6a\x9b\x54\xf6\x37\x4b\xb3\x4c\xb7\xc4\x33\xf6\x87\x8c\x52\xf7\x6e\xb5\x09\xcd\xb2\x6d\xfd\x32\x40\x02\xe9\x37\x4a\xba\xe3\xb3\xb0\xcb\x65\x01\x34\xa5\xa5\x59\xe6\x9b\xd2\xca\x2c\xa7\x29\x2a\x15\xe9\x18\x64\x62\x0c\x44\x40\x5f\xad\xb9\x7f\xea\xb9\x96\x7f\x05\x1b\x3c\xd5\xf2\x33\xb1\x07\x62\xfc\xd1\xf6\xde\x96\x2d\x12\x42\xa1\x6e\xfa\x6f\xb6\xf0\xfd\xd7\xdc\x07\xb2\x73\x0a\x2b\x82\x16\x7a\xf2\x67\x07\xc1\xbc\x5d\x60\x37\x08\x11\xc5\x6c\x88\x28\x7c\x03\x0c\xb1\x0a\x6a\xea\xbd\xef\x5a\x0f\x9b\x5f\xc7\xd7\x85\x1d\xf2\xcf\x8f\xc0\x56\xc7\x23\xdb\xb1\xa5\xc8\x0a\x3e\xff\xfc\xc7\xbf\x31\x9c\x03\x11\x31\x00\x0c\xa4\x3f\x93\xe3\xb2\x2a\x10\x0b\x41\x00\x7c\xc4\x3b\x62\xf8\x4b\x79\x51\x66\xc6\x71\x2b\x2c\x6a\xbc\xe2\x26\x28\xbc\x54\x0c\xb6\x38\xbe\x68\x86\x44\x78\x71\x3c\xcc\xc4\x74\xa2\xc9\xa8\x46\x00\x06\x24\x06\x01\xfc\x92\x45\xaf\x79\xee\xc1\x9b\x07\xbf\x18\xbb\xe5\x03\x4f\xc8\x1f\x23\x0c\x25\x81\x11\x1a\x54\x06\x49\xb9\x7a\x88\x9c\x57\x05\x8f\x79\xed\x31\xc6\x0b\x5a\x1f\x1a\x1c\x84\xa1\xeb\xc3\x7c\x15\xe8\x10\x14\x1e\xda\xd6\x19\xd2\xac\x61\xdd\x20\xa1\x45\xc1\x52\xb8\x89\xd8\x83\x3a\x3b\x19\x8b\xa7\x11\x73\xe2\x32\xe3\xeb\xe4\x36\xf1\x22\xc1\xb8\x6f\x5f\xcb\x03\x5d\xf9\x4e\x96\x33\xc0\xc3\x9d\xf6\xfb\x2f\x53\x8d\x7c\x9d\xdd\xed\xc0\xbb\xd5\xae\x52\xb6\x0a\x9f\xe7\xf5\xf3\x5e\x38\xcf\x00\xc3\x39\x4a\x7c\x9b\x9c\x9d\xb7\x7c\x17\xda\x10\xfd\x1f\x6d\x79\x1b\x2e\xbf\x94\xd4\xef\xb9\x5c\xef\x60\xa7\xdc\x47\x9b\x54\x04\x9c\xf3\x83\x58\x9e\xbd\xa7\xc5\xa8\x33\xe6\x69\x87\x4e\x26\xc9\xac\x99\x4e\x93\xa4\xad\x6a\x6f\xb5\x09\xe6\xd2\xeb\xaa\xdc\xf3\xf0\x71\x33\x9c\x9f\x2a\xf1\xb0\xa2\xfd\xb2\xaa\x09\x35\x31\x83\xb4\x9f\xc1\xa5\x74\xb3\x0d\xe9\x03\x66\x90\x4e\xad\xbb\xfe\x23\x62\x43\x67\x10\x54\xbc\x8a\x94\x55\x29\x70\x85\xfb\x25\x8e\x0c\xb2\x43\x1a\x0d\x1d\x6c\x5b\x3f\x56\xad\x33\xd6\x71\x07\x6f\x1d\x4c\x33\x32\xc7\xd6\x6d\x52\xf0\xe8\xc2\x79\x5b\xa1\x5f\x90\xa3\xdb\x73\xfb\xac\x17\xc0\xcc\xc3\x5e\x25\x94\xe8\xe0\xd8\x84\x16\x59\xe4\x65\xaf\x7a\x21\x8b\x8e\x46\x20\x9e\x97\xa1\x85\xfc\xb2\x47\x9a\x50\xcf\x19\x97\xc3\xc5\xa4\x3f\x25\x2a\x95\x3c\x25\x5d\x37\xa7\x45\x36\xc9\xb6\x9c\x9e\x39\xf9\x15\xb1\xa9\x2a\xc9\x06\xe9\x06\xc8\x7f\xbd\x0b\xf7\x46\x15\xee\xd5\x11\x28\x1b\xbc\x42\xca\x5c\xff\xbb\xba\xcf\x0c\x16\xc7\x4f\xbc\xfc\xeb\x67\x8c\x5e\x54\x84\x03\x70\x9f\x4b\x73\xd7\xfd\xb0\x3b\xdb\x2a\x5c\x4e\xf8\x33\x39\xcf\xca\xc9\x11\x74\x0e\x84\x47\x84\x28\xd1\x34\x1a\x91\x21\xda\x6c\x11\x5e\xb0\xb1\x37\x8b\x61\xe0\x00\xbc\x79\xbb\x85\x6c\xb2\x5f\x86\xd6\x73\x96\x99\x23\xed\x1f\x18\x85\xb9\xd3\x56\xb5\xa5\x58\x30\x77\x55\x03\x35\x65\x85\x8e\x87\x0a\x2f\xa0\x86\xcc\x2b\x45\xc9\xdf\x0d\xa3\x02\x38\x5e\x19\x30\x5e\x1e\x69\x7a\x41\xf5\x91\xa9\x11\xcd\x19\x69\xc8\xbd\x73\x63\xc7\x49\x90\xfb\x5b\x2f\xe1\x13\x8d\x69\xa6\x52\x5c\x77\xff\x92\x14\x7c\xbf\x94\x17\x99\xb8\x30\x21\x1d\x9c\x0e\x55\x1a\x6d\x5e\xd9\x01\x47\x1f\x05\x5e\xc9\xdb\x9a\xc8\x01\x8a\xbb\x8e\x15\x5c\xc0\x52\x27\xa7\xd9\xcb\xd8\xa0\xf2\x59\x96\xcc\x28\xbd\xca\x42\x67\xd5\x2c\x56\x3d\x41\x13\x30\x69\xd2\xd0\xd5\xb9\xba\x6c\x02\xb5\xfe\xa1\x63\xbc\xca\x02\x4e\x92\x0f\x65\xe2\xd0\x3a\x60\x98\xe6\xc3\x1d\x88\xb4\x40\x9f\x44\x0e\xa0\x4a\xb4\x6f\xbb\x20\x55\x89\xd6\xdd\xfa\x3d\xd8\x95\x9f\x3d\xe6\xa0\xe0\x07\x3c\x8d\x21\x3a\x84\x8a\xaa\x01\x5a\xde\xc6\x86\xb8\xef\x61\xc2\xd9\x63\x0a\x68\xf5\x89\x1d\xce\xd4\xca\x6d\x82\xa5\xf8\x2e\x5f\x15\x08\xa9\xe6\x60\x2d\xd1\x5a\xb3\x6b\x24\x2a\x76\xf9\xfa\x3a\x09\xd3\x3a\x13\x3a\x4b\x04\x35\xce\xe5\x3d\x74\xf7\x41\x10\xc4\x91\x0b\x7a\x47\xae\x79\xcc\x13\xbc\xca\xba\x9a\x35\x92\x75\x73\x23\x97\x50\xf5\xeb\x4e\xd9\xed\xdb\x10\x5b\xda\xf5\xc5\xce\xb1\xaf\x21\xb3\x23\x7f\xb8\xb1\x6d\x4c\x58\x78\xc8\x85\x5f\xae\xbf\xf6\x94\x8e\x19\xae\xa0\x9d\xf1\xa7\x12\x4d\x18\x1a\xd0\x39\x48\xb9\x1a\xdc\x10\x03\x22\x37\x41\xce\x3b\x90\x0b\xd4\x9b\x42\xde\x50\xd5\x6b\xc9\xf8\x8e\x65\x89\x53\xd0\x75\x04\x2f\xb5\xdb\x4e\xb9\x37\x78\x24\x52\x90\x4e\x39\x5f\xd9\x64\x84\x93\x19\x2e\x23\xd4\x39\x07\x06\x51\x4c\x9d\x87\x95\xa0\xd5\xa4\xca\xd5\x99\x52\xfd\x78\x2c\xc4\x4e\x57\xd9\xd6\xf9\xbc\x99\xa0\xcc\x0a\x5a\xad\x80\x83\x99\xea\x3e\x5d\xef\xf3\x46\x76\xda\xb3\xda\xce\x7e\x36\xb7\xb3\x9f\x95\x3b\xbb\x27\xe1\x4d\x3c\x6a\xcb\x31\x17\x45\x6c\x4e\x2f\x1c\xe8\x8e\xde\x51\x3b\x80\x29\xce\x3e\x2e\x54\xc8\x55\xdb\x11\x01\x60\x75\x0f\xe9\xa7\x59\x0e\xa0\x4c\xb2\xc1\x97\x4a\x92\xc1\x53\xaa\x1e\xa5\x49\x40\x8b\x4b\x91\xbb\x43\x4a\x74\x2f\x20\x49\x0e\xd5\x37\x37\xa4\x91\xff\x39\xa5\x19\x6b\xb4\xd7\x02\x59\xb9\x63\xb2\xb6\xf0\x4a\xf0\x80\x5f\x37\x37\x65\x92\x8c\x78\xd9\x0e\x59\xf3\x24\xec\xb6\x74\xa0\x60\x5f\xc3\xde\xb6\x4b\x8d\x59\x89\x76\xee\x0c\x19\xbc\x30\x56\x31\xd0\x6d\x1d\x6d\x77\x66\x6b\xb5\x55\x67\x98\x36\x58\x59\xb7\xcb\x7f\xed\x72\x45\x2f\xee\x31\x60\x0a\xff\x07\x1e\x1f\x24\x09\x9e\x3d\xe4\xb0\x1a\xcf\xd1\xe2\x88\xf4\xe5\xac\x2e\x79\x5a\x19\x2f\x32\xb7\x26\x41\x70\x16\xc1\x61\x08\x01\x1a\x59\x76\x06\x87\x12\x47\x31\xf8\x57\x06\xd8\x23\xdf\x81\x98\xc6\x73\x5a\x49\x88\xbb\x68\x73\xac\xdc\x83\x65\x85\x93\x03\xe3\xf4\xb9\x5d\x57\xe0\x73\x19\x99\xab\xc6\xe2\xf3\x4e\x1f\xa1\x75\xaf\x43\xe2\xf7\x6e\x33\x34\xa0\x93\xa6\x81\x2b\xc0\xfc\xa2\x81\x93\xb0\xaf\xb7\x64\xa7\x0c\x66\xdd\x84\x39\x89\xc1\x84\xfb\xf5\xd6\x9b\x6e\xcd\xda\x0c\xd3\x61\xbe\x98\x8e\x59\xc6\x23\x34\x9a\x0c\xfd\x46\xb9\x88\x2b\x3c\x27\xb5\xd5\xce\xcc\xc7\x61\x8f\x67\x2b\x36\x5f\x70\x3c\x0f\x41\x6a\x1c\xdc\x67\x3e\x82\x33\x7e\x7e\xde\xf1\x1a\x6a\x4a\x62\xd7\x97\xc8\x1c\xe6\xfa\x98\xc0\x10\xf8\x05\x09\xcc\xdf\x01\x85\xba\xa0\xa1\xed\x0b\xf9\x05\xf2\x76\xc9\x17\x77\x67\x08\x4a\x35\x1f\xe6\xdf\xeb\x02\xdf\x4b\x3c\xf9\x30\x3f\xd3\x09\x67\x5f\xce\xbd\xe8\x74\x5c\xaf\x20\xfd\x52\xa0\xc9\x3d\x3d\x1c\xc9\x5d\x30\x4a\x71\x19\xda\x66\x5a\xe5\x88\x4f\x97\x33\xbd\x44\x05\x84\xe5\xf3\x08\xee\xac\xb2\xc8\x7d\xce\x01\x4a\xeb\xc4\x2f\xa0\x32\xfc\x68\x7e\xb8\x4c\x34\x1b\x92\x96\x75\xe7\xf6\x8a\x66\x0d\x1d\x98\x5a\xcf\x9a\xbb\x6e\x50\x3d\x43\xfa\xfa\xba\x69\x46\xe0\x6e\xcc\x74\x2b\x4b\x06\x6a\x70\x69\xc8\xb3\xad\x73\xa5\xc9\xd5\x40\x73\x42\xe8\xe1\xe1\x43\x81\x1e\x1d\x4b\x05\xce\x2c\x2f\xcf\x83\xb8\x7b\x8f\x50\xfe\xcf\xb0\xf0\x79\x18\x9b\xc6\xcd\x33\xa1\x1e\x55\xdb\xdc\x70\x77\x2e\x1c\xc6\xc7\xfb\x1a\x08\xc4\x8e\x4b\x96\x2b\x04\xd0\xe5\x52\xc3\x58\x08\xe5\xe7\xae\xdb\x72\xe1\x54\xa3\xe7\xf9\xdd\x98\x73\xb2\xa4\xf9\xd9\x32\x6f\x70\x81\xbb\x3b\x86\xd1\xb6\x5d\xad\x8a\x4d\x79\x7d\x44\x37\x09\x53\xa7\xf7\x61\xf7\x2d\xb5\x3c\x55\xf1\x6f\x86\x74\x42\xfa\xac\xb8\x62\x2c\x25\xc5\x95\x90\x79\x39\x22\x30\xea\x5f\xfb\x7d\xec\x2b\x3b\x42\xe2\x29\x70\xc0\xa8\x1d\x6e\x05\x25\x73\xa5\xa9\x6f\x89\xfe\x46\x6a\x95\xbf\x57\x70\x4c\xaf\x95\xa2\xbf\x25\xf6\x3b\x94\x1d\xd3\x6b\x3e\x9e\x8e\x0d\x8e\x3e\xcd\x54\xe1\xd0\x4f\x65\x89\xca\x85\xda\xed\xce\x41\xda\xea\xbf\x3c\x07\xe9\x1c\x98\x83\x5e\xd8\x39\xa8\x4f\xb3\xb7\x74\xa2\xe6\x8b\x17\x1d\xfc\xa9\x65\xa6\x4f\x33\xf5\x42\x66\x16\x00\x39\xc9\x16\x58\x71\xdb\x82\x61\x82\x3b\x99\xbd\xf8\x3e\xb7\xd3\x24\x82\xe9\x04\x33\x8d\x05\x00\x4e\x89\x60\x02\x3b\x3b\x57\x13\x98\x85\xd1\x48\x9c\x3e\xd0\xf5\xd8\xa4\x5d\xdf\xb1\x9f\x2e\xeb\x78\xf7\xd3\x67\x80\xbf\x90\x6e\xcb\xdf\x65\x9a\x29\x8f\x26\xaf\x34\xeb\xee\x7f\x3a\xda\xd7\x4a\xd1\xf3\x44\x0a\x5a\x51\xf5\x80\x61\x67\x5b\xce\x37\x45\xa6\x2e\xa6\xea\xce\x6a\x36\x37\xc9\x95\x7f\x79\xc2\x73\x3d\xdc\x49\xce\x8a\x02\xd7\x3b\xd3\x9c\x65\xaa\x79\xba\xd5\x52\xc3\x69\x40\xc9\xe0\xa7\x15\x19\xee\x34\x3b\xcd\xd9\x9b\x69\x02\x61\xb2\x6d\x88\x1d\xb8\x18\x99\x26\x89\xe5\xb9\x91\x86\x4d\x98\xac\xed\x5c\x3b\x1d\xbb\x2c\xaf\xda\xc2\x06\xf7\x26\xae\xd6\x20\x4f\xd5\xde\x4b\x53\x7c\x73\xa3\x67\x8a\xdb\xb6\x09\x41\x27\xeb\x78\xba\x87\x3d\xb8\x21\x7b\xf0\x89\xd3\x5f\xce\xed\x8a\x84\xfb\xd5\x92\xea\xc4\xc9\x9f\x8e\xc9\x46\x3d\x02\x4d\x95\x23\x02\x5b\x61\xb0\xba\x00\xb7\x9c\xae\x5c\x06\xfd\xea\x86\xe5\xb7\x2c\x75\xc3\x9b\xba\xe0\x4f\xf6\xc8\x56\xe7\xe7\x5d\x87\x3c\x3c\x73\x7d\xe2\x42\x79\xd7\x33\x92\xd7\xf8\xbc\x46\x6e\x26\x0d\x19\x1b\xb2\x30\x1e\xde\xfe\xfa\xab\xa6\xfa\x52\x05\x91\x96\x2b\x38\x55\x68\x47\x17\xde\x70\xda\xd9\x86\x7e\xdb\x21\x5b\xe4\xd6\x5c\x9f\x28\x51\xbc\x5f\x87\xc2\x0a\x91\x5d\x7d\x62\x18\xfb\x78\xfe\x0d\x52\xab\x4d\xce\x9c\xad\x1c\xcc\x83\x28\x04\xfe\xb6\x76\xa2\x34\xdc\x8e\x37\xff\xea\xe6\xc8\xf6\x75\x54\x9b\x9e\xe2\x2f\x50\xb5\x4f\xdd\xf6\xb9\x53\x2a\xb4\x54\xf7\xcc\x4b\xaf\x37\x76\x7c\x21\x74\xa6\x73\xf5\x79\x6e\xd7\x2c\x8a\xaf\xd8\xda\x33\xfc\x70\xdc\x74\x9f\x77\x34\xd9\xde\x2a\x07\xf1\x9b\x69\x1d\xde\xf7\xfb\x49\x15\x6b\x9e\x10\x42\x87\x6a\xad\x5f\xd5\x11\x45\x97\x5a\x6e\x28\xe6\x02\x5b\x1d\x76\x42\x13\x6e\x5b\x55\xe1\xf4\x6e\xfd\x11\x8a\xd8\xe6\x1e\x72\xc0\x52\xd8\x08\xe6\xaa\x35\xa7\x3b\x2d\x55\x6a\x50\x33\x3e\x9d\x11\xb1\x4d\x9e\x18\x92\x36\x6a\x06\x3d\xf9\x65\xcf\x1d\xb1\xd5\x63\xdf\x0e\xbc\x8c\x0f\x79\x6a\xb6\x76\xf7\xad\xac\xe5\x2a\x4d\x88\x24\xed\xe2\x73\xee\xa5\x88\x5f\xd3\xaf\xbf\x06\x8a\x08\x14\x2e\xd2\xe0\x4e\x88\x52\xcb\x3b\xbf\x5f\x12\x7d\xfb\xe9\x55\xd4\x76\xca\x80\x43\x0c\x27\x6f\x99\xe1\x5f\x3a\x8f\xfc\x8b\x35\x40\xcf\x8c\x7e\x9f\x9f\x4f\x3d\xce\x3f\x21\xbc\x04\xb1\x01\xed\x03\xad\x59\x56\x11\xf9\x5d\x1a\xe0\xbf\xdc\x78\xbe\x5b\x17\x3d\x68\xb4\xcf\xb9\x7f\xa9\x7a\x20\xef\x2e\x55\xab\xf2\x9b\xd8\x6d\x6d\xdc\xa9\xb6\x89\x3a\xbb\xc2\x03\xa4\x57\xe2\xfa\x1e\xde\xf3\xae\xd4\x2d\x0b\xe6\x5e\xb9\x17\x2c\x23\x7d\xb5\xa2\xce\x13\xbd\x5b\x95\x31\xcd\x86\xdc\xa2\xc5\x9f\xc1\x45\x8a\xbe\xc1\xc1\x3a\x36\x48\x13\xa1\x3a\x09\x1b\x14\xb0\x4a\x69\x39\x89\x18\x31\x1a\x52\x77\x3d\x2c\xe6\x86\x47\xd1\x63\x8b\x14\x62\x52\x42\xd3\x17\x45\x21\xc6\x55\x78\xf4\xfd\x56\x70\xad\xf5\xd5\x71\xbd\x68\x2f\x69\x80\xb1\x3b\x9a\xbf\x4e\x73\x76\xdc\x1f\x6d\x8f\xc4\x1d\x9f\x60\xeb\xc9\x28\x65\x57\xc7\x5a\xbb\x63\xcf\x39\x97\xea\x86\x12\x77\x41\xd9\x17\xd7\xe6\x5a\xe5\x95\xb8\x46\x57\x4d\x76\x61\x42\x13\x8c\xf3\xe1\x94\xee\x40\x9a\x73\x72\xca\x32\x08\xe4\xbc\x5f\x01\xea\xe5\xd9\x22\x09\x9d\xa1\xb7\x22\x17\x16\x13\xf5\x51\x89\x24\xb9\xa9\xe1\xf6\xf6\x48\x43\xa3\x6a\xc0\xe9\xaf\x93\x31\x12\x19\xff\x87\x48\x0b\x99\xb5\xbe\x1e\x92\x03\xd7\x3c\xe0\x6d\xad\x01\xfe\xb2\xef\x3f\xe7\x55\x98\xaf\xa8\x51\x71\x06\x9c\x70\x63\x70\xba\xfc\xf7\x8e\x7f\xf5\x30\x0a\xcd\x43\x65\x1e\xf2\xd3\x96\x55\x68\xa5\x22\xec\x8b\x6b\x1c\x29\x28\x66\xad\x72\xe8\xdf\x66\x1d\x2b\x02\x2e\x59\xf6\xad\xaf\xeb\x5e\xfd\xa6\xbc\xf1\xfa\xe1\xc1\x3c\xf2\x05\xc9\xe1\x95\x5f\x8d\xe6\x99\x1a\xc0\x01\xd3\x02\xa7\xf7\x1a\x87\x77\x43\x5d\xf6\x07\x52\x6d\xb6\x66\xf2\x95\xd9\x1a\xaa\x79\x63\xd3\x48\xaf\x79\x7e\x3a\x9b\xb0\x4a\xfd\xe8\xdc\x82\xe9\x54\xa3\xcf\x98\x53\xef\x12\xe7\x7d\x23\x73\x2f\xbc\x9f\x24\xf7\xbe\x15\xae\x31\x65\xaf\xba\x17\xae\x30\xa2\x52\xf0\x70\x21\xed\x99\x91\x41\x34\x7a\x3c\x17\xf1\x80\x14\x0f\x4c\xbe\x1e\xfb\x77\x1a\x96\xce\x33\x8e\xd5\xc8\x96\xb7\xaf\xb5\x7d\xf7\x12\x2d\xa7\x77\x4c\x77\x9a\xa3\x52\xa7\x1a\xbd\xec\xbb\xb5\x56\x75\xb6\x13\xe5\x52\x43\xff\x08\x16\x19\x97\x36\xac\x83\x05\x09\x6e\x5d\xab\x58\x6a\xf8\x53\xc9\x4b\xe5\x59\xca\x5c\x49\xb9\x0c\xbd\x87\xb9\xa4\x12\x46\x99\xf4\xfb\x5d\x56\x93\x46\xe8\xb7\x5a\x5e\x90\x71\xca\x53\x5d\x76\x49\x4b\x4a\x5b\xbf\xec\x8b\x39\x1e\x87\xab\x5f\x4d\xfa\x18\xe6\x49\x7e\xf5\x03\x53\xbf\xfc\x39\xd9\x21\x67\xf6\x77\xdb\xe1\xce\xb9\xdb\x6e\xe8\x96\xd7\xda\x74\x12\x3c\x4e\x97\x78\x2e\x37\x75\x30\xbe\xf6\xb3\xac\x4d\x2e\xc2\xb3\x73\x40\x71\x27\xdf\x2f\x5c\x8e\xab\xf5\x87\xb8\x62\xa6\xa0\xe9\x80\xb3\xad\x73\xb2\x81\xdb\x0c\xda\xcf\x97\x35\x6b\xb5\x44\x81\x09\xa1\xf9\x25\xb1\xef\x38\xbf\x03\x92\xa6\x93\x49\x15\x49\x5d\xa9\xab\xbf\x19\x49\xdd\x12\x49\xe1\x5d\x8a\xb1\x39\x6d\x5a\x9e\xb5\x89\xdb\x2f\x67\x5b\xe7\x8e\xf1\x69\xd3\xb6\x23\x00\xeb\x9e\xb7\x4c\xff\xcb\x85\xf8\x51\x3a\xe0\x29\x2f\x66\x6d\xb2\xa1\xbf\x3a\xfb\x91\x52\xf5\x8e\xb8\x9c\x6d\x9d\xb7\xf5\x55\x84\x5f\xb9\x0b\xd4\xb5\x40\xb6\xea\x39\x15\xd7\x84\x7a\x81\x63\xa7\x0a\x27\x54\xee\x7c\x57\x95\xef\xcc\x77\xf9\xdc\x09\x0f\x2d\x74\xed\x2d\x97\xaf\xda\x78\xd9\x90\x68\x89\xd9\x15\xf5\xee\x5f\x65\xd0\x6b\xf4\xbb\x6e\xda\xfa\xba\x6e\x65\x75\xcc\x1d\x9d\xb9\xa8\xce\x2d\x09\x87\x11\x06\x05\x1a\x88\x85\x11\x03\x9d\xfd\x10\x81\x98\xfb\xdc\x01\x5e\x2d\xe8\x37\x46\xd0\x06\x31\x40\x2b\x17\x86\xd6\x97\xab\x7c\x0c\x61\x8a\xe3\x3d\xac\x2e\xce\xd3\xbc\xa0\x69\xc4\x72\x5d\xf7\x7d\x1f\x40\xe8\x98\x3a\x64\x83\xa8\x05\xeb\x3e\xa4\x9a\xf8\x2f\x1b\x44\x1f\x61\x41\xce\xb7\x78\x30\xa1\xfe\x50\xd0\xab\xde\x4b\x94\x1c\xb2\xd5\x2c\x40\x4b\x70\xfe\xc0\xac\x7d\x41\xb1\xf8\xb0\x0c\x8c\x91\xb6\x6b\xac\x91\x5c\xfb\x4c\x07\xba\xb4\xff\xaf\xb1\x5a\xda\xb6\x6b\x16\xbb\xab\x29\x3d\x4b\x80\xa1\xa6\xde\xf4\x84\xc3\x65\x51\xbd\x01\x2b\xc2\x39\x2f\x4f\x8c\x7a\x09\x79\xe7\x1e\xea\xcd\xf1\xa8\xb9\x08\x9a\xdb\x05\x9e\x5e\x6c\x6e\x06\xb7\xb1\x76\x38\x2a\xf9\xc5\xd7\x3c\x7f\x13\x3d\x73\x69\x82\xa4\xe3\xc1\xc2\xe6\xa6\x31\xf5\x9e\xa6\x92\x4a\xb9\x15\x14\x03\x3b\x0a\x55\xeb\x96\x6a\x5b\xb5\x2d\x0b\x9e\xe5\xcd\x33\x61\x51\xb6\x04\x05\x1d\xe2\x12\xcf\x8f\x0d\x46\x88\x97\x61\xae\x8a\x02\xfb\x01\x3c\xf8\xd3\x60\x15\xb7\xf0\xa5\xa3\x39\x7b\x74\x67\x03\x6f\xfa\x5e\x11\xfd\xf0\x9b\x7e\x9e\xda\xfb\x87\x93\xaf\xaa\x63\xce\x19\x89\x86\xc7\xcc\x6b\x89\xeb\x8e\x03\x03\xaf\xc0\xac\xb2\x40\x24\x1b\xce\xa3\x0a\x78\x9a\x0e\x13\x56\x59\x26\xa3\x31\xaf\xac\x42\x66\x4c\x73\x28\x63\x26\xa7\xd0\x48\xc1\x71\xe2\x28\xe5\x67\x98\xf1\x78\xad\x3c\x8b\xc0\xeb\x05\x9c\x0a\xe0\x1b\x4f\x51\xc0\xca\x31\x38\xc7\x3c\x55\x93\xc6\x98\xa7\x7c\x3c\x4d\x9d\x58\x9f\x35\x25\xe8\xb5\x2e\x01\x66\x06\x15\x25\x2a\xd5\xbf\x43\xf9\x9a\x9d\x01\x4a\x4e\x29\x03\xcd\x5f\xca\xc7\xf7\x1d\x6d\x49\x2e\x5c\x17\x58\x25\x3f\xa2\xf9\x7b\xd8\x7e\xe0\x25\xb5\x39\x67\xa5\xf9\x7b\x7a\xed\xdf\x5d\x9b\x87\x71\xb9\x79\x8e\x33\xc7\xf4\xd7\x1e\xa7\x3b\x4f\x4a\x64\x8f\x8d\x79\x6a\xc7\x8b\xa9\xde\x0f\x92\x37\xaf\xb8\xa6\xde\x23\xd3\x2d\xee\x0e\x9f\x10\x45\xa0\x59\x1f\x61\xfd\x5e\x50\x47\x75\x2a\x2f\xc9\x74\xe3\x0e\x3f\xc2\xba\x2a\x41\xe9\x75\x69\xb1\x84\xf9\x95\xcf\x56\x50\xba\x64\xcf\xa7\xe5\xd7\x96\xda\x94\x11\x72\x40\x60\x4a\x8b\xa9\x72\x31\xbb\xe4\xe0\x39\x88\x43\xb0\xde\xa0\x19\x73\x6a\xe6\x29\x8e\x80\xea\xf2\xfb\x49\xa2\x42\xd3\x05\xc4\x26\x09\x24\x4c\x04\x4f\x8b\x5c\x61\xae\x5c\xb7\x80\x73\x43\x77\xc1\xe2\xb8\x31\x0d\x04\xd5\xc9\x69\xe2\xba\x0b\x1b\xd0\x46\x42\x9c\xb8\x91\x32\xb7\x15\x3e\x24\x80\x7b\xb3\x88\x26\xf0\xd8\xff\x9a\xe7\x1d\xf8\xa1\x73\x62\x1d\x82\xd2\x6c\xb1\x01\x26\x48\xd6\x12\x8f\x93\x2c\x82\xc8\xef\x46\xe4\xed\xed\xbc\x62\xee\xcd\x8d\xa6\x4e\xf9\xac\x57\x5a\x4d\xcd\x4a\xa0\xa3\x80\x10\xb0\xac\xc1\x43\x59\xa5\xb6\x3a\x46\x77\x3d\x0a\xd4\xdd\xcb\xb0\x48\x13\x6f\xff\x77\xac\xe1\x88\xd5\x4c\xbe\xa1\x08\xc9\x47\x62\x9a\xc4\x44\xa4\xc9\x8c\xd0\xc1\x80\x45\xae\x9c\xd1\xf8\x0b\x85\xd8\xbe\x85\x40\x99\x4a\x78\xca\x4c\x9c\x48\x68\xd0\xfa\x3a\x69\x62\xbb\xa1\xc4\xcd\x0d\xd2\x9a\xf2\x08\x9e\xec\xe5\xe1\xdb\xe8\xf9\xc0\xf3\xdf\x03\x98\x2e\xb3\x8f\x5f\xc2\x7e\x7a\x19\xa6\x98\xb3\x34\x85\x4b\xdd\x2a\x86\x3b\x65\x3b\x07\xdb\xf1\xbe\x83\x95\x35\xdd\x2a\x5b\xe4\xa9\x3e\x41\x76\xce\x1f\xec\x6b\x02\x9b\xea\xdb\x58\xe8\x49\xba\x64\xc5\x2d\x59\x09\x4c\x70\xa7\x5d\xd3\xe5\x4a\x2e\xe4\x0c\x89\xcd\x09\xb8\x59\x0d\x54\xc5\x45\x1d\x0b\x37\x5c\x9d\xcd\x6b\x38\xb2\xec\xae\x86\x02\xde\x1d\xfc\x58\xaa\xf9\x28\xbc\x28\x12\xeb\xeb\xe4\x91\x33\x7c\x0d\x99\x0e\x8c\x95\x20\x88\xb3\x7d\x87\xcc\xe8\x66\xd6\x36\xcf\x76\xa8\xdf\xbe\xd0\x48\xa6\x4c\xfb\xe6\xa6\xd4\x95\xd8\x09\x72\x36\xb1\xa2\x17\x93\x82\x5d\x17\x6d\x92\x33\xe8\x4d\x5c\x4f\xe7\xa0\x4a\xc1\x03\x65\x21\xc8\x90\xa5\x2c\x93\xf3\x12\xd0\xb2\x16\x34\x14\x97\xa3\xcd\xca\xb6\x05\x3d\x19\xf4\xe3\xdd\xcd\x5c\xf3\x3a\xf3\xce\x01\x84\x0b\xd2\x73\x12\xf4\x7b\x55\xaf\x57\xf4\xf9\xad\xfb\xf4\x57\xcd\x65\xca\x4b\x34\xe8\x99\x91\xf2\x12\xed\xcd\x63\xda\xd7\x82\x09\x41\xae\x7c\x49\x93\xa3\xb4\x60\x59\x0a\x41\x1e\xf8\xa5\x64\x9e\x2a\x5e\x53\x7a\x42\x33\xeb\x88\x9a\x10\xfd\xc5\xf0\x33\xd7\x0e\x38\xe5\xb4\x86\xc0\xc4\xbc\x88\xa8\xc1\x09\xfb\x4d\x83\xf2\x0e\x9c\x00\x1c\xa0\xd4\xfd\x65\x51\x06\x7f\x38\x6f\x03\x8b\x62\xa7\x81\x9b\x2a\xae\x51\xd9\xc3\xb6\xf7\x6a\xba\x22\xbf\xe9\x73\xb1\xed\xf3\xa5\xed\x35\xc9\xb9\x49\x9a\xe6\x85\x18\xf3\x7f\x30\xd3\xda\x52\x38\xef\xe5\x1d\x67\x78\x55\x9a\x07\xa7\x15\x35\xba\x80\xc1\x4b\xbb\xe5\x6b\xf7\xda\x3f\xb7\x7a\x0f\x72\x55\x4e\x43\xbc\xde\x80\xe3\x82\x52\xd5\xb5\xe1\x95\x69\x36\xec\xb6\x09\xcd\x86\xdb\xf0\xff\x33\xf8\xff\xb9\xbf\xbf\x5c\x19\x69\xee\xd6\xd4\xcf\xaa\xa3\xc3\x6e\x46\x57\x42\x4f\x99\x2f\x2e\x49\xa5\xdc\xbb\xa9\x22\x55\x81\xa6\xc3\xb3\xc9\x8f\x34\xcb\x95\x81\x3a\xac\x0f\x0d\xf7\xab\x3c\x9c\x98\x35\x37\x4e\x03\xde\x28\x16\x93\xda\x62\xf6\x91\x38\x1c\x4c\x9e\xea\xd3\x44\x38\xc0\x74\x1e\x51\x88\x81\x73\x72\x79\x97\xea\x38\xf5\x48\xe6\xc2\x9e\xfc\x59\xdf\xf8\xa5\x83\x77\x48\x55\x0b\x68\x43\x8b\x55\x03\xe5\x25\x72\xdd\xa2\xd7\xbc\x4f\xd6\x66\x17\x90\xa3\x0e\x0f\x54\x9e\xdd\x7e\xfb\x4b\xda\x5d\x6f\x2d\xa0\xf6\xf3\xd3\x42\x34\xdc\x1d\xe1\x7d\xb7\xf4\x15\x8b\x00\x40\x3f\xef\x69\x84\xeb\xc4\xef\xec\x31\x7c\x79\x45\xd3\xf8\xf1\x79\xb3\xd5\x06\x1b\x32\x60\xd7\x29\xbc\x1c\x6c\xc8\xf5\x76\xc3\x2c\x0c\x9c\x37\xc0\x8b\x10\x6a\xd7\xef\x2b\xa2\xf3\x1d\x4f\x19\xcd\xaa\x29\x4d\x20\xcf\xd2\x5a\x75\x06\xea\xed\x41\xac\x54\xca\x05\xbe\xf9\x65\x1f\xf1\xc8\xda\x0e\x64\xb2\x7a\xca\x03\x6a\xac\x0c\xb6\x9f\x31\xea\x82\x95\x1d\xd6\x2c\xd7\xd8\x8f\x72\x27\x59\xdd\x56\xd8\x64\x56\x75\x4b\x45\x53\xff\x62\x11\xf1\x8e\x17\xbe\x71\x2f\x2f\x34\x53\xce\xf1\xf3\xdc\x6c\xe1\x60\x6c\xb9\x07\xf5\xea\xa1\x6f\x03\x72\x1a\xe4\xa9\x5a\xae\xe2\x3b\xa4\xad\x36\xe9\xb6\x3a\x85\xf8\x6d\x32\x61\xd9\x01\xcd\x59\xb3\x15\x40\x74\x03\x53\x01\x63\x8b\x8f\x8c\x98\x43\xa8\xc7\x09\x13\xad\x6f\x19\x91\x69\x35\xcd\x8e\x26\xe0\xdf\xbd\x6a\x7f\x89\xbc\x30\xf2\x56\x3d\xb5\x2c\x3f\xf5\x21\xef\xc9\x4b\x2b\x26\xa8\x1a\x6f\xc9\xce\xb7\x1c\x32\xea\xca\xf6\xf0\xe3\x09\xd9\x23\x5d\xb6\xf1\x5c\xc5\xb6\x2c\x05\x3a\xf1\x16\x9d\xa5\x5c\x4d\xbe\x7f\x1d\x44\xf6\x82\xed\x8d\x3d\x4b\x53\x00\x37\x37\x0a\x54\x9b\xac\xfe\xb2\x67\xbd\xc5\x20\x4f\x03\x27\x10\x12\xa9\x57\xc4\xbc\xa0\xa1\xe9\x90\x99\x1a\xe1\x57\xd3\x58\x30\x8e\x81\x18\x7b\x31\x21\x73\xf1\x5e\x1c\xbe\x75\xcf\x5b\x64\x43\x32\xc1\xc0\xc3\x41\xa1\xbd\xa9\xa8\x80\x7f\xea\xc2\x0f\x78\x06\x8f\x9b\x70\x07\x16\xeb\x7b\x77\x6b\xc1\x49\xcb\xd9\xca\x4c\xdc\x71\x9b\x85\x58\x7e\x01\x6a\x6f\x6e\x14\xd2\x5f\x81\x18\x38\xe1\x76\x33\xe1\xd7\xaf\xee\x09\xa7\xc7\xea\xb3\xd8\xde\xfd\x07\xf5\xe9\x4b\x14\x7d\x37\x50\x8a\x2c\xe3\x76\x75\x29\xb3\xd9\xb7\xef\xce\xd4\x56\xc2\x39\x79\x73\x32\xe7\xf9\xf3\xa8\xbe\x4f\x71\x0a\xcf\xbd\x55\x51\x4f\x46\x35\x2c\xf8\x10\x02\xcf\x08\x7b\x7b\x2e\x41\x4e\xe5\x01\xb4\x7d\x9e\x41\xaa\x2c\xf8\xf4\xf2\x10\xb8\x13\x46\xbf\x71\x99\x13\xe6\x35\x95\x23\xcd\xd8\x39\xba\x99\x2b\xed\x8f\xf6\xf6\xd0\xe3\xd2\xa3\xd5\x18\x49\x5a\xc1\x5b\x3d\xd2\xee\x79\x78\xb4\x77\xe9\xf9\x84\xac\x18\x66\x65\x19\xec\xda\x21\x11\x0c\xb1\x1a\xd8\xf0\x79\x1c\x3a\x9d\x03\xb0\x4b\x65\x93\x73\x6e\x9c\xc9\xac\xa6\xbd\xba\x06\xe0\xa1\xfe\x81\x03\xcf\x32\x40\x5d\x6c\x12\xb8\xa2\xf0\x36\x8a\x2b\xa5\xa2\xeb\x52\xd1\x3d\xf7\x07\xbc\xb9\x3f\xc5\xa7\x20\x1e\x15\x96\xc2\xaa\x22\x5b\x73\x8a\x74\xab\xdb\xda\x0d\xdb\x5a\xf9\xec\x97\xb0\x3c\xe1\x69\x41\x52\xb1\x01\x3b\x9f\x8d\x8c\xa1\xc3\xde\x1d\xb2\xa5\xf7\x26\x4e\x80\xa8\x3d\x77\xaf\xa5\x53\x9b\x39\xcb\x38\x73\xbc\xbc\xc1\x3c\x02\x69\xc1\x6b\xce\xd4\x7b\xc1\x13\x4c\x17\xe1\xf3\xfe\xb1\xc1\x72\xb6\x75\xee\x3d\xee\x1f\xef\x92\xa7\x4f\xbf\xb8\xcb\x1e\x54\x10\x97\xcc\x3e\x04\x42\x33\xf8\x21\xb5\xa9\x15\x17\xc3\xa8\xae\x52\x89\x2e\x78\x16\xa3\x7d\x44\xf2\xfc\x03\xfd\xa0\x1a\x78\xc6\xcf\xcf\xbe\x9c\x43\x17\xbf\x24\x5e\x12\x98\xbe\x05\x40\xde\xd3\x13\x44\xf7\xab\xf7\x7c\x89\x94\x70\xec\x99\x76\xec\x56\xc3\x74\x5d\x18\xf2\xd4\x0e\x68\xfc\x73\xb8\x50\x22\x46\x6d\xb0\xdd\x57\x60\xd5\x24\x68\xa6\xcd\x23\xc1\x30\xb6\x44\x82\xc3\xf2\x3a\x12\x1c\x1d\xae\x75\xf6\xc9\xa9\x1c\x76\xc7\x6f\xde\x9c\x1c\x9e\xf6\xde\xef\x7f\x54\xd1\xd9\x51\x0e\xad\xa0\x61\x70\xf3\x09\x4d\xe3\x79\x2b\x2b\xcf\x15\xfb\xd9\x63\x01\x63\x15\x1e\xf0\xa0\x9d\xf7\x21\x60\x90\x83\x56\xe2\x4b\x45\x3a\x77\x9d\x16\x60\x9b\x84\xd8\x3e\x88\x94\x69\x5c\x39\x4f\x46\x62\xca\x8a\xe2\x3e\x18\xff\x0c\x31\x9e\x18\x2c\x1a\xef\x15\x1f\x0e\xe7\xaf\x26\x03\x9c\x59\x88\xf3\x0f\xc0\x20\xf1\xb9\x46\xee\x6e\x3c\x37\xff\xea\xce\xc9\x51\xe6\x2c\xe8\xd0\x02\x8d\x8a\xb0\x47\x02\x33\x3f\x34\x77\x31\xde\x3f\x8e\x16\x33\xf6\x73\x6c\xe0\x1d\x9b\x65\xfb\x92\x05\x70\x2d\x64\x03\xef\x73\x20\xb5\x1c\x40\xf5\xdc\x42\x77\x22\x9a\xcc\x56\x07\x04\xd7\x21\x2e\x46\xbf\xaf\x3e\x79\x4f\xcb\x56\xb7\xb1\xf2\x4d\xbb\xa5\xad\x0e\x45\x16\xcf\x77\x84\xea\x53\x96\x3b\x7d\x23\x4b\x6a\x01\x6a\xa9\x87\xb1\xcd\x70\x30\x9c\x59\x76\xab\x09\x56\xdf\x44\x48\x1c\xd0\xa2\xd6\x6e\xa9\x5b\xfd\x88\x79\x55\xdd\xeb\x43\xa8\x6e\xee\x29\xbb\x31\xcf\x6b\x4b\xdb\x71\x70\xe2\xf6\xbe\xdc\xa7\x5c\xb2\x2c\x67\x27\xa6\x35\xee\x1a\x4a\x12\x36\x67\x4d\x09\xf1\xa0\x65\x71\x9e\x0e\x95\x89\x5f\x21\xf4\x15\x67\xc6\xd2\x18\xae\xb8\xe5\xff\x4d\xa9\xb5\x13\x3a\x63\x72\x03\xdc\x5a\xb3\xbe\xb5\xa4\xb4\x95\x48\x20\x2f\x55\x2b\x3a\x2a\xab\xd9\x22\x3b\x2a\xc9\xac\x4f\x7c\x37\x3d\x1a\xbc\xc6\xb4\x68\x8e\x35\xdc\xb3\x1a\x6b\x38\xe5\xff\xc5\xb7\x71\x7b\xd6\x51\xc9\x16\xae\xec\x46\xeb\x99\xe7\x47\x4b\x72\x52\xfe\xae\x7a\x87\xaf\x4c\x87\xbc\x47\xaf\x54\x77\xb7\x25\xca\xf7\xc0\x73\xee\xbc\x36\x87\xb3\x73\x60\x02\xf0\x11\x96\x0d\x88\x00\x63\xf5\x93\x11\xcd\x81\xaf\x3b\xe8\x66\xa0\xed\xb2\x6d\x87\x7c\xbd\x35\x4f\xd0\x57\xe9\x5f\x5c\xf1\xa8\xe5\x4f\xc8\xb0\x4f\xd0\xb4\x3a\x94\xbb\xce\x84\xb4\x23\x1f\xa4\xde\xce\x49\x6e\xfb\x77\xea\x45\x7b\xc7\x13\x73\xf5\x20\xef\xec\xdc\x5e\x8d\xea\x1b\x3c\x43\x0a\x7a\x02\x42\x3b\x11\x10\x12\xfb\xe2\xdc\xa1\x50\x73\x31\xb4\x17\xbb\xb3\x15\x7b\x4e\x55\xde\x61\xd9\xd7\x3b\x30\xdc\xbf\x2b\xd0\x91\x24\xfa\x19\x3f\x8a\xb1\x23\x1a\x3d\x45\x49\xaf\xd1\x3a\x57\x53\xf2\x2a\x38\x2a\x3f\xcf\x83\x0b\x67\xff\xc5\x8f\xfb\x1c\xcc\xb8\x53\xac\x7a\x32\xa7\x30\x3b\x7c\x68\x69\xf7\xd6\x5f\x6f\x3d\x65\x59\xe7\xfa\xaa\x7e\xd4\x23\x72\x77\xdc\x0f\x95\xf8\xb9\xac\xa6\x9e\x37\x22\x39\x0e\x86\x5e\xa7\x5b\x29\x1e\x86\xdd\x14\x78\xba\x2a\xe5\x57\xd3\xa6\xa7\xe2\x38\x7c\x2d\x32\x24\x7b\xe5\x3a\x8c\x30\x95\x9f\x3e\x84\x5c\xae\x66\xb1\xd6\x58\xfe\x03\xe7\x79\xfd\xef\xc0\xd5\x48\x82\x03\xa1\x64\x62\x58\xf6\xa9\x95\xdb\x25\xc8\x4e\xf5\x92\x44\x17\x72\xd7\x23\x06\x81\xf1\xf3\x68\x85\x61\x05\x82\x36\x2c\x8b\x98\x73\x6f\x3e\xf4\x6c\xe6\x0b\x65\x29\x55\x67\x8a\x68\x6c\xaf\xea\xae\x9e\xd0\x82\xbd\xd2\x7d\x7f\x60\x95\x15\xfb\x66\xe4\x35\x01\x70\xab\x7c\x77\x7b\x10\xda\x90\xb0\x30\x2b\xbb\xb9\x06\xca\x73\xdd\xb6\xa3\xe3\xef\x1a\xaf\xed\x98\x79\x1e\x6e\x4d\x21\xd9\xe3\xe8\x81\x32\x8f\x5b\xf0\xb6\xcf\xfa\x1c\x04\xc8\xd3\x52\x99\x2a\x58\x31\x29\x72\x52\x63\x8c\x17\xf2\xdb\x5e\x26\xc2\x28\x48\x92\x0a\x4b\xb8\xd2\xe9\x6b\x90\x85\x47\xaf\x6d\xa8\xd7\xae\x9f\xbd\x13\x5f\xb2\x07\xb9\x1d\x2f\x31\xb8\xd6\x03\x00\xf7\x5a\xcf\x18\xdc\x98\x4c\x9d\x60\xcc\x3f\x94\x3f\x05\x73\x30\x06\x60\x7e\xaa\xb9\x08\x4c\x12\x71\xf5\x9a\x45\x7c\x4c\x93\x5c\x83\x7a\x89\x76\x2d\xe5\x90\xed\x37\xe3\xe6\x06\xcb\x29\xcb\x3d\xf7\x0a\xd1\xb1\x93\x9b\x16\xc2\x9a\xd5\xd9\x74\x75\x59\x32\x6f\x09\x09\xe2\x69\x9a\xed\x19\xec\x39\x0f\x06\x82\x66\xaf\xaf\x5b\xcf\x12\xe6\xc1\x95\x73\xa3\x09\x54\xfb\xf9\x5d\x37\xbf\x55\x6b\xa0\x8f\x03\x5b\x3d\x93\x51\x36\xfa\xca\x22\x99\x5c\x8d\x18\xda\x5c\xc2\x2d\x34\xcf\x09\x2d\x59\xf1\xcf\x3d\x87\xd7\x00\xb2\x8e\xdf\xb5\x9d\xee\x9d\xf3\x7c\x39\x74\xda\xd9\xe3\x21\x2b\x3e\x28\x7b\x3e\x44\xf4\xd8\x9c\x19\xb6\xad\x10\xb5\x7d\x09\xd0\x2b\x1b\x8f\xac\x39\x5a\x04\x31\x2b\x55\x12\x5e\x2a\x11\x63\x4f\xb8\xe3\xb6\x27\xbc\x15\x9b\xdf\xb3\xde\x82\xfc\x4e\xb6\xf5\x56\xc2\x37\xcb\xb3\x37\xfc\x5a\x87\x05\x96\xec\xeb\x2d\xca\xbf\x2a\x16\xf4\x4a\x3c\xa8\x3d\xdc\xae\x89\xf2\x1d\x5a\x88\x57\x80\x80\xcb\xb9\x1f\xac\xbe\xa1\x68\xaf\x0b\xa9\x70\xcb\xef\xaa\x11\x9b\x83\x33\x82\xca\x0a\x9c\xcb\xfd\x50\x72\x2e\x87\x01\x25\x74\x6e\xd9\x1c\xcd\x64\x29\xb7\xff\xae\x79\xe5\x9c\xcb\x5f\x77\x7a\x38\x83\xa2\xe7\xe4\xa5\xf7\xd3\x8f\x6c\xe0\xb8\x3d\xdb\x26\x3b\x65\xcf\xe4\x77\x06\x80\x41\x53\x62\xf5\x5c\xc8\x5d\x45\x2e\xf7\x78\xf0\x52\x3f\x4d\xb5\x36\x1a\x3a\x6d\xe7\xee\x0e\x0e\x2e\x78\xaa\x21\xa0\x7b\x7f\xac\xec\xde\x1f\x6b\xbb\xf7\x47\xbf\x7b\x8d\x2d\x34\xe6\xf9\xd6\x88\x41\xdf\xff\x38\xb7\xef\x7f\xac\xef\xfb\x1f\xbf\x71\xdf\xab\x46\xb8\xbd\xbe\x44\xa7\xeb\x5f\xa8\xfe\xb1\x9e\x6f\x2b\x08\x1b\xbe\xd4\x96\x1a\xe2\x08\x88\x1f\xe8\xbe\xe4\x65\xd2\xcd\x04\xb1\xf8\xc9\x39\x99\xb7\x2b\x75\xd5\x1f\x3f\x75\x9c\x34\x33\xa5\x1b\x7d\xea\x64\x76\x6a\xae\x86\x5d\x90\xb9\x5a\x7a\xd1\xcb\xa6\x7b\x5e\x37\x21\x15\x12\xf9\x2f\x2a\xe8\x8b\x2c\xfa\x6b\xe0\x2a\x0c\x7a\xad\xe4\x20\x50\x42\xfe\x52\x01\xa8\xae\x5a\xc2\xfd\x42\xc5\x75\x8a\xa1\xcb\x76\x51\xcc\x0a\x16\x15\x26\xde\xa4\x8a\x4b\x92\x97\xaf\x23\xe7\x02\x3a\xae\x3a\xf4\xe4\xa2\x77\x21\xe5\x47\xd6\x72\xad\xf4\x4f\x71\x15\x32\x2f\x9e\x67\x5d\x1c\x09\x14\xb0\xe2\x9f\x42\xef\x9c\x58\xa7\xf3\xc8\x55\xaf\x9b\x25\xc9\xc0\x6a\x13\x22\x41\x14\xb9\x01\xa2\x19\xa3\xff\x94\x46\xcd\x8b\x73\x3a\xaf\x55\x3c\xc6\x67\xb8\xc6\xee\xed\x29\x69\x1c\xc5\x8d\x5d\x57\x63\xfa\x10\x20\xe7\xda\x82\xc2\xdd\x49\xa0\x88\x5a\xcf\x27\x8a\x5f\xc1\x7b\x78\xbf\x8c\x01\xaa\x7f\xd3\x99\xf8\x86\xb3\x2c\x51\x47\x9a\x40\x39\x2e\xca\xd5\x89\xe7\xfa\x3a\xd1\xb9\x1d\x9a\x5c\xd1\x59\x7e\x32\x12\x57\xab\x73\x67\x64\xaa\xd6\x5c\x39\x6f\x85\x07\x30\x7a\x86\x29\x83\xce\xf3\x3b\xe1\xbc\xb9\xbd\x54\x0e\x4a\xaa\x1e\xdc\x62\xde\x79\x8d\x17\x38\xef\x34\xb8\xed\xf2\x39\x78\xc8\x22\x45\xb4\xda\x01\x4d\x57\xc7\x00\x95\x3d\xfe\x94\x34\xba\x8d\x5d\x37\x7b\x3b\xc8\xde\x6e\xe8\x1b\x55\xaf\x4f\xb1\x82\xbf\x55\x87\xca\xb6\x9f\xaf\xd0\xf1\x95\x8b\x78\xbb\x46\x4a\xba\xae\x98\x00\x01\xbb\x65\xa0\xed\x00\x68\xfb\x5e\x72\xd4\x55\x9f\xdb\xf3\x04\xca\x02\x3d\x44\xb2\xb4\x11\xbc\xcd\x2b\xdf\x47\xe1\xc9\x1d\xfa\x2b\xa8\xbf\x6c\xc4\xfc\x26\xbe\xd7\x2f\x85\x3e\xb8\xb4\x61\x02\xc2\xf8\x55\x90\x88\x97\x26\xdf\xf2\x2e\xa2\xee\x14\x38\x38\x65\x35\xc7\xc0\x52\xaa\x86\xce\x4d\x41\xe8\x5f\x52\x5f\x64\x1d\x39\x71\xf1\x54\x56\xb5\xc9\x55\x19\x59\xdd\x43\x76\xf7\x30\x1a\xe0\x21\x8c\xee\xde\x1e\x29\xfb\xab\x74\x29\xe0\xbb\x4e\x86\x17\xda\xcd\x71\xac\xe9\x8b\x88\x2d\x0e\x76\xc6\x2f\xdd\x53\x68\xec\xd6\x33\x03\x72\xee\xac\xcc\xef\xb2\xe4\x72\x9c\x2b\x9c\xf0\x74\x58\x3a\x54\xf3\x33\x9b\xf6\xbe\xf1\xfe\x7e\xae\xe6\x1e\x65\xea\x67\xc6\x30\xe3\x9f\x99\x71\x66\x9d\x9f\x3d\x4c\x61\xd4\x1d\x92\x56\x56\xdb\x5d\x5d\xb5\xe7\xda\xef\x40\x8d\xdf\x86\xaa\x6e\xf0\x2e\x2f\x2a\xfb\xc2\x42\xb8\xd7\x2c\x30\x98\xb3\x02\x44\x40\xb6\x2c\x3e\xb2\x2f\xe4\x96\xbe\xa0\x09\xee\x41\xee\x1e\x9b\xc4\x0d\x35\x62\xec\x1e\x4a\xd2\xba\xbb\x56\x71\x1c\x67\xb3\x17\xf7\xae\xad\x9c\x7f\x06\x72\xaa\x3c\xca\x82\xbd\x75\x15\x57\xc8\x53\xd2\x6d\xcd\xf1\x14\x95\x81\x41\x54\x9b\xe4\x65\xef\x1c\xa0\xd8\xf3\xc5\xdc\x72\x54\xca\xbd\xbb\xcd\xaa\xf4\x40\x15\xd7\x3a\x9f\xaa\xad\x2a\x30\x02\x51\xe1\x68\xfd\x81\xa7\xcd\x05\xf7\xf6\x88\x2e\x48\x6e\x6e\xdc\x64\x83\x90\xbc\x24\x5b\x64\xc7\x75\x9d\xe1\xc8\xea\xfb\xa3\x0f\xbd\xdf\xf7\xdf\xfd\x76\xd8\xfb\x74\xf8\x96\xec\x91\xcd\xff\x27\x95\xc0\x7b\x9e\x9e\xfd\x67\x7e\xfe\x64\x03\xfe\x6f\x9e\x6d\x6d\xfc\x7c\xfe\xb4\x79\xd6\x39\xff\xda\xbd\xc5\x1f\xad\xaf\x5b\xed\xee\x6d\xeb\xfb\x4d\xb4\xa6\x7e\xbf\xff\x7f\xab\xd0\xd0\x6b\x40\xf0\x9f\x4f\x17\xc1\xe3\x3c\xeb\xd1\x2f\x0e\xcb\x3b\xc0\xaa\xfc\x66\xee\xff\x46\x57\x32\xfa\x3b\x9e\x2a\xca\xa9\xf2\x92\x65\x83\x44\x5c\x39\x16\x17\x4b\xba\x4f\x0b\xea\xab\x0a\x96\xad\x67\x75\xe7\x10\xcd\x0c\x0d\x15\x46\x6e\xb9\x69\xb7\x6a\x01\x15\xd0\x23\x25\x50\x93\x14\xdb\xf3\xfa\x32\x27\xc8\x4b\x52\x2e\x4a\x76\xec\x89\x43\x39\xd7\xe5\xad\x36\xff\x76\x4e\xa0\x3d\x71\xea\x14\x2c\x2f\xe6\x11\xe7\xee\x01\x9e\xfa\x45\xd9\x35\x8b\xaa\x8a\x5a\x3b\x41\xb7\x65\x1e\x4d\x64\xc3\xb1\xdb\x5d\xc5\xe3\xca\x05\xd9\x5b\x06\x6b\xd6\xf2\xaa\x5c\xda\x03\xdd\x7d\x58\x18\xfa\x45\x64\xa4\x5b\x6a\x44\x77\x51\x19\xe9\x5a\x19\xa1\xd7\x15\x88\x3d\x19\xe9\x96\x65\xc4\xd5\x15\xd5\x32\xd2\xf5\x65\xa4\x67\x85\xc4\x2b\x5b\x29\x24\xdd\x0a\x21\xe9\x06\x1c\x06\x27\x8a\xbd\x6f\x2b\x25\x35\x0c\x2e\x83\x35\x6b\xb9\x55\x2e\xed\x81\x56\x9f\xac\x59\xdd\xae\xa3\x65\xdb\x93\xef\xa3\xf4\x93\x7a\x43\x62\x14\x6a\x2d\x90\x17\x95\xda\x79\xfc\x82\x41\xd6\xec\x6f\xbb\x9b\xd1\x81\x55\x6c\x84\xb5\x79\x0f\x56\xf4\x83\x12\xfd\xf2\x24\x78\x48\x82\xc9\xf0\xbf\xeb\xec\xdd\x9c\xc4\xe4\xbf\x2b\xc2\x21\x5e\x39\xbc\x2a\xd9\xc3\xb2\x2f\xbd\x60\xce\x3a\xb7\x14\x39\x1a\x60\x77\x02\x58\x48\x2c\x81\x02\x06\xf7\x30\xdb\xd6\xee\x5f\xbe\x97\x63\x41\xb9\xb1\x8f\x6c\xf4\xa6\x8a\xd7\xb6\xf8\xd6\xd6\xbe\xb1\xad\xb6\x74\xd0\x4e\x65\x42\xe7\x4c\x55\x57\xef\xda\xd9\x12\x06\xfb\x70\x03\x2e\xe1\xb1\x79\xa5\x0b\x1a\x3f\x53\x3d\xa2\x75\x62\x92\xeb\x1b\x08\xe3\xcf\x03\xcd\x05\xbc\x5f\xd6\x6b\x4b\x95\x6f\x8f\x92\x63\x97\x92\xe3\x10\xb8\xbd\xd4\xbe\x33\xdc\x40\xe7\xb2\x87\xb6\x5d\xc5\x00\xd6\x8e\x2c\xd6\xd6\x1a\xf5\x83\x77\x4b\x0f\xde\x5c\x64\xc5\x2b\x7f\x36\x57\x36\x1c\x76\xc1\x25\x4a\xa7\xdb\x22\xf0\x99\x64\xc3\x0b\x80\x2b\x78\x7b\xd3\xa3\xd7\x5c\x55\xc6\xf3\x5d\xbd\x25\x75\xa9\xbe\x63\x4f\x8a\x6e\x0b\xb2\xa0\xd0\x19\xf7\x1c\xe7\xaa\x60\x2d\x3e\x84\x1a\x2d\xe5\xcb\x28\x33\xb9\x37\xa3\x69\xe6\x5e\x05\x19\x3f\xfd\x10\x66\x26\xcc\xb0\x81\x49\x2a\x0d\x83\x6c\x05\xee\x8a\x14\x57\x9e\x3a\x2f\xd4\x57\x5b\x66\xf0\x3c\xd9\x24\xb7\xad\xf6\xda\xe6\x13\xb2\xfd\x4c\x4a\x2a\x26\x99\x35\x70\x73\x2c\xe2\x69\xc2\xda\x84\x5d\x4f\x44\x86\x46\x20\xca\x77\x44\x06\xde\x71\x21\xbb\xa3\x72\x21\x1e\x10\x98\xc9\x8a\x74\x87\x34\xb6\x3b\x2f\x3a\x5d\x78\x09\xa8\x6d\x73\xc4\x80\xf4\x7a\x92\x52\xe7\xd2\x05\x12\x00\xdf\x2e\xd9\xdc\x54\x8f\x3c\x36\x62\x9e\xd3\x7e\xc2\x36\x12\x9e\x32\x92\x8a\x0d\x08\xe3\xb5\x16\x92\xfc\x7c\x01\x92\xdb\xa4\xd7\xbb\x62\xfd\x09\x8d\x2e\x7a\x19\xfb\x73\xca\x33\xd6\xeb\x41\x3b\x1e\x4f\x73\x46\xf2\x22\xe3\x51\xf1\x78\x57\xe2\x53\x32\x4c\x7e\xdf\xff\x44\x8e\x3e\xfc\xfb\xe1\xc1\xe9\xd1\xf1\x07\xf2\x64\xd3\xe2\x9e\x64\x22\x62\x39\xb2\x41\xed\x02\x03\x13\x2c\x53\xeb\xe3\x5e\x8f\xe5\xef\x81\x96\xc7\x6d\x75\x26\x04\x5e\x52\x8a\x6c\xca\xd6\xc0\xe2\x0f\x6f\xfb\x81\x2f\xdb\x30\x88\x4a\x74\x36\xbb\xdd\x1f\x03\xc8\x67\x60\x83\x9b\x16\x2c\x13\x93\x4f\x08\xf7\x5a\x8d\x28\x8d\xcb\x94\x50\xce\xba\xab\x10\x3f\x7b\xe6\x41\x6d\xcf\xc1\x2a\xf3\x25\xb0\x6a\x5a\x27\xa2\x13\x5e\xd0\x84\xff\x83\xbd\x91\xea\xf9\x1d\x2b\x0a\xf4\xaf\x51\x95\xbe\x6b\x8b\x89\xb4\x50\x7e\x3c\xf5\x57\x9b\x39\xe0\x7a\x4b\xb9\x47\xcc\x77\x3f\x5b\xe5\x38\x08\x33\x26\xa7\xcf\x11\xe5\x29\x8b\xf5\xca\x40\x62\xaf\x4a\xd7\x8d\xbd\xa2\x59\xca\xd3\x61\x1d\xbb\x9f\xb7\x02\xc0\x79\x8c\x51\x20\xb2\x88\xd1\x61\x35\xb0\xa2\xff\xa5\x45\xbe\x1a\xad\xd6\xff\x02\xd6\x3e\xfd\x2f\x1d\x2b\x25\xe4\x25\xa4\xef\x90\xaf\x26\x96\x3d\x24\xdc\xee\xca\xb1\xeb\xd8\xc3\x55\x70\xb9\x99\x83\x21\x1e\xaa\x2f\x25\xa4\x1d\x96\x5e\x76\x3e\x1c\xbf\x3e\xec\x1d\x7e\xf8\x1d\xec\x94\x1e\x4f\x32\x11\x4f\x01\xcd\x63\xf2\x92\x34\xb7\xda\xb6\x99\x1d\x55\x67\x4b\x0f\x54\xc4\x88\x37\xa4\xf8\xbd\xd1\x26\x8d\xf7\xb4\x00\x3f\x44\x1b\xbf\x1d\xed\xdc\x41\x0a\xbb\x9e\xb0\xa8\xc8\x09\xd5\xa8\x68\x36\x9c\x8e\x59\x5a\x74\x1a\x2d\xb2\xe3\xfa\x7f\x31\x8f\x04\x24\x58\x27\x1a\xd1\x6c\xbf\x68\x6e\x55\x3c\xff\x46\x00\xfb\xfe\xfb\x56\x6a\x0c\x72\xc5\xe8\x85\xcb\x20\x25\x5c\x92\xe7\xe0\xf8\x3a\xf6\x0e\x6f\xa0\xd5\x20\xf2\xb6\xc9\x00\xd4\x61\x97\x2c\x9b\x39\xdb\xff\xf2\x1b\x0b\xd9\x61\x23\x9a\x1f\x5f\xa5\x66\xbc\x03\x10\xf6\xe5\xd9\x85\xbe\x17\x90\xf8\xe0\x97\xd9\xf4\x3b\xf4\x19\xf1\x6e\xd2\x2c\x73\x09\x54\x33\x8a\x0e\x6c\xad\xfa\x41\xa6\x60\x2f\x98\x50\x86\x0d\xf2\xd2\xfb\xb5\x83\x8d\x52\xfa\x21\x68\xd6\x6e\xe9\x4d\x2c\x4e\x79\x34\xcb\x9c\x29\xf0\xe9\x9e\x8d\x12\x25\xb5\xb5\xa5\x43\xd6\xac\x69\x07\x1b\xb5\x47\x8f\x64\xa6\x24\xfe\x8c\x9f\xb7\x09\x6f\x4b\x54\x2d\x00\x84\xa0\x59\xe1\x14\xce\xc3\x9b\x6c\x1f\xb7\x00\x35\x8a\x8e\x22\x74\xcf\x69\xdc\xd0\x80\xbb\x11\x9e\x39\x02\xaa\xe6\x95\x36\x69\xf4\xd1\x97\x60\xe3\xdc\x78\x90\xd0\x15\xb7\x60\x34\x6c\x74\x4b\x98\x25\x4f\x5c\x60\x2f\x0e\x87\x81\xda\xe8\x96\x3b\xb4\xaa\x2f\x79\xa8\xcf\x1c\xa0\x5d\x67\x49\x8b\xe7\xd1\x64\xa3\x4b\x5e\x12\x68\xb9\x3e\x7d\x36\x5d\x0c\xf5\xa9\xa5\xee\x09\x1d\x80\x07\x6a\x70\xe9\xe4\x18\x8b\xca\xbc\x3f\x78\x92\xa0\xfb\x3d\xd4\x81\x84\x92\x94\x5d\x39\xee\x58\x07\x24\x65\x2c\x66\x71\x5b\x42\x8b\x62\xc4\xb2\x2b\x9e\x33\x72\x25\xcb\x4d\x68\x9e\x93\x3e\x8d\x2e\x08\xbb\xe6\x79\x21\x47\xac\x2e\x88\x6e\x16\xa7\x49\xd2\x51\x15\x69\xc3\xd4\x81\xf1\x1e\x63\x41\x0b\x81\xe4\x39\x4b\xe2\xdc\x42\xde\x48\x34\xb7\xb0\x2a\xb6\x23\xb6\x4a\x61\x37\x91\x91\x46\x74\x7b\xb8\x84\xd3\x4a\x44\xaf\xdf\x70\xf9\x28\x27\x15\x0c\xff\x25\xc1\x5a\x38\xc2\x51\xd6\xe1\xdb\x2f\x50\x1c\x7f\xd8\x55\x1e\x94\x3c\xeb\xe1\xb0\xb5\x98\x31\xa5\x74\x65\x24\x81\xcb\x7e\xdb\xe5\xb7\x0a\x0f\x4b\xe4\xd1\x9e\x35\xeb\xa9\x38\x18\xa6\x51\x84\x94\xeb\xb2\xab\x51\xda\x50\xb5\x3f\x64\x43\xa5\xcd\x53\xd8\x78\x92\x7d\xd5\x5c\x82\xcf\xa3\xc6\xd3\xbc\x40\xd1\x99\x64\xe2\x92\xc7\xd6\x10\x39\x6f\x5b\x41\x6c\x1b\x41\x08\x75\x78\xd9\xbf\x54\x54\xd9\x9f\xde\xe2\x5c\x76\xca\x76\x65\xa7\xd2\x6c\xe8\xf7\xe9\xb6\xea\xd4\x6d\xdb\xab\xdb\xaa\x5b\xb7\xd5\x4f\xff\x4a\x49\x62\x80\x9e\xdc\x2e\x77\xee\xf6\x79\xc9\xb9\x14\x8d\x22\x75\xa5\x51\x8c\xe4\xce\x4b\x16\x37\x66\xf9\xb2\x4d\x75\xb9\xb7\xea\x44\xd9\xf6\x6d\x4b\x59\xdb\xcf\x5b\x52\xde\x76\x22\x9a\x24\xcd\x79\x6b\xd4\xe6\xb3\x56\xab\x15\xae\x78\x5f\xac\x70\xc5\xbb\xb2\x25\xec\xc9\xe5\xf0\x28\x82\xa5\x57\x55\x33\x5e\xfc\x00\x8b\xaa\x3b\xea\x6a\x28\x51\x6e\x60\x45\x0c\x4c\xb5\xe4\x16\x00\x6b\x6b\xaf\x11\xb9\x49\xde\xf1\xb6\xcc\xcd\x60\xe0\xd5\xad\xd3\x14\x7d\x2d\x3d\x5c\x94\x8f\x8a\xbf\x64\xdd\xe6\x77\xdf\x0f\xf3\xba\xcf\x32\x4f\x71\xa5\xd7\xbb\xc7\xe6\x65\x44\xb3\xb1\x48\x67\x4a\x08\x48\x93\x8f\xc7\xd3\x42\x32\xb0\x45\x9e\x6c\x56\xe1\x3e\x7b\x4c\x1f\xe3\x0b\xe9\x2b\xf0\x85\x78\x49\x13\xbc\x52\x28\xb6\x30\x95\xbc\xa6\x85\xb2\x99\x2c\xba\x4e\x92\xcb\x36\xa7\x70\x73\x90\x08\x91\x71\xfd\xc6\x85\xb7\x49\x84\xd6\xc5\x03\xce\xd0\x6f\xc6\x1a\x71\xa6\x22\x5d\x2a\xa6\x45\xe9\x3c\x0b\x10\x35\xd5\x19\x93\xae\xb6\xf9\x14\x40\x5b\x70\xc8\x69\xb7\xb4\x1a\x51\x07\x4a\x91\x3d\x93\xb0\xeb\xe5\x46\x8c\x27\xce\x89\xcb\x3d\xaa\x85\xdf\x1b\xa4\x2b\x6b\x56\x4d\x83\xb4\x36\xe9\xb6\xda\x6e\x21\x97\x32\xbf\xf2\x4c\x4c\xbd\xc0\x85\x5e\xed\x70\x43\xb1\xe5\x10\xae\x90\x19\x4d\x16\x77\x9d\x4c\x68\x08\x42\xec\x06\x57\x1f\x92\xca\x78\x8b\xfc\x22\x0b\x6c\x60\xc2\x4b\x99\xb0\x43\xe2\x6e\x05\x51\xc6\x86\xd6\xa3\xaa\x4d\xf2\x82\x4d\xc2\x75\xaf\xd3\xec\x72\x8f\x60\x11\xb9\xab\x4f\x31\xf6\x6d\x57\x9f\x52\x03\x73\x9a\x80\x70\x0e\x73\x82\x83\x51\xbc\x69\x94\x48\xc5\xc4\xa7\xc6\x3d\xd9\xd4\x61\xf1\x01\xb8\xc4\x1f\x48\xd5\xd1\x9d\x81\xb8\x45\x68\xdc\x35\x2b\xca\x47\x88\x81\xfc\x02\x54\xa0\xc7\x13\x80\x81\x40\xcc\xc6\xff\x33\x10\x03\xc7\x16\x34\xc9\x85\x72\xb0\x99\x93\x23\x35\xc5\x4a\x1e\xa9\x83\x64\x04\xc5\xe7\x97\x96\x7d\x48\x66\x6b\x97\x5c\x8d\x78\xc2\x48\x53\xf3\xd9\x70\x80\x4d\xac\x88\x21\xb0\xba\x9e\xd6\x94\x79\x37\x93\x40\x4d\x99\xc1\x2a\xca\x87\xc3\xe1\x82\xe5\xe1\xb5\xa6\x37\x90\xab\xc4\x54\xc5\x91\x51\xc7\xb5\x98\xa3\xc8\xf6\xc7\xc0\x23\xb8\x58\xc0\xb1\x0a\x70\x9d\x9c\x15\xa7\x7c\xec\x8c\x24\x6b\xa3\x53\x2f\x7a\x55\xf5\xf9\x06\x23\xd0\x1f\x60\x12\xab\xe8\x78\xfa\x14\x93\x02\xdf\x15\x24\x64\x2f\x56\xb6\xd1\x0d\x89\xfd\x7a\x3b\xe7\x04\x8a\x8d\x27\xc5\xcc\xda\x97\xe0\x3d\x81\x42\xbc\xb1\x81\xb2\xb1\x58\xc5\x4f\x1f\x54\xb1\x67\xd8\xa2\x3c\x08\x9b\x5b\x4d\xd0\xb8\x66\x1f\x67\x86\x84\x7a\x6a\x15\x8e\x30\x96\x3a\x2f\x33\x8b\x2d\xd3\x4f\x4f\xb5\xa8\x15\x5d\x9b\x26\x81\xcd\x7a\x08\x3b\xbc\xd8\xb2\xd2\x59\x74\x4d\xae\x92\x28\x67\x74\x01\x01\xcd\x62\x4b\x62\x6c\xd9\x75\x93\x4f\x25\x6c\xbf\x7d\x2a\x5d\x69\x50\xc3\xb8\x7a\xcc\x5a\x63\x77\x9e\xbf\xe1\x29\x2f\x98\x2a\xed\x0f\x5c\xf2\x52\xbd\x84\x33\x7f\x3b\x36\xbb\x2b\xb3\x35\x35\x1e\x48\x30\x92\x9a\x30\xa1\x39\x10\xf2\xef\xa5\x23\xcb\xce\x8a\x01\x40\x65\xca\xbf\x68\x05\x04\xcb\xd7\xdb\xa0\xf4\x4e\x75\x69\xbf\x07\xe5\xd2\xbf\x8c\xc9\x5b\x86\xba\x37\x25\x66\x1a\xbc\x2d\x9d\x9b\xfe\xf8\xa0\x55\x24\xdc\x66\x24\xa2\x4f\x93\xba\xb3\xc5\x1f\x5a\xbb\xee\x29\x71\x15\xcc\xf6\x33\x0d\x53\x5c\xd7\x2d\x1c\x7f\x56\x20\xda\xf3\x40\x15\xcc\x96\x82\xf9\xf8\xe9\xf8\xf4\xf8\xf4\x3f\x3e\x1e\x92\x3d\xd2\x98\x64\xa2\x10\x72\x4b\xd4\x50\x4b\xd4\xef\xd5\xaa\xc8\xb9\x72\x69\x62\xb0\x9b\x94\x8e\xa5\xe2\x11\xd3\x2c\x72\x8c\xd4\x8f\x4e\x7a\x6f\x8e\x3f\x1d\x1c\xbe\x56\xe7\x30\x64\x5d\xa3\xe8\xbc\xd9\xb5\x30\x6f\xdf\x1d\xbf\xda\x7f\x57\x86\x79\xeb\xc0\x9c\x9c\xee\x9f\x1e\x1d\x94\x61\x4e\x1c\x18\x20\xbe\x0c\xf2\xd1\x01\x79\x75\xf4\xa1\x82\x98\x57\x0e\xc4\x1f\x9f\xc0\x1b\x4d\x00\xf1\x87\xb1\x0b\x37\x67\xf4\x96\xf0\x97\xd8\x43\x3b\xf0\x61\x5d\x21\x36\x9d\x9f\x7b\xfa\x41\xb2\xc2\xf1\x51\xb2\x96\xec\x69\x74\x67\x86\xef\xe6\x82\xb0\xa0\xd9\x10\xd6\x15\x6e\x3d\x4a\x5e\x76\x1c\x8e\xe8\x44\x55\xd1\x0e\x69\x7a\xbf\x21\xac\x6f\xab\x02\x3f\xb8\x34\x11\x57\x69\x9b\x40\xf0\x5d\x54\x7c\xa6\xae\x96\xea\x4b\xb9\x4c\xa1\x63\x66\x4e\xbf\x2e\xd8\x8c\xf0\xd4\xeb\x68\x78\x16\x69\x4e\xa5\x79\x4a\x52\xf0\x07\x04\x39\xe2\x4a\x6e\x67\x1e\x59\x39\x58\x5f\xd7\x0d\x33\xdf\xf0\xbc\x4f\xee\xd1\x9d\x83\x1a\x3d\x39\x49\x04\xeb\xeb\x44\x55\x6b\xae\x4f\x64\x75\x3c\xd5\x6e\x88\xa4\xd2\x47\xc1\xc4\xaa\xe5\xee\x7a\x42\xf3\x9c\xa1\x76\x41\xd7\xb7\x12\xd3\x4b\xaf\xca\x1d\xd5\x0c\x73\xc4\x08\x98\x26\x19\xbb\x94\xfb\x79\xc5\xea\x89\x48\x92\x29\x9e\x4f\x09\x74\xb6\x99\x4f\x68\xc4\xf0\xfd\xa6\xee\x3d\x75\xf4\x61\x7b\x4a\x3d\x5f\x14\x83\xa0\x8d\xee\x19\xe0\x4b\xb7\x7a\x5d\x7b\x9f\xa7\x31\x29\xf8\x98\x65\x70\x02\xa4\x88\x90\x55\xcb\x8d\x2e\x19\x64\x62\xac\xdb\x2a\x79\xc0\xae\xd1\xa7\xfb\x8e\x91\x6d\xb9\xaf\x82\x96\x46\xc5\x75\x13\x62\x04\x21\x8e\x96\xae\xe1\x2a\xa3\x13\x8d\x37\x12\x69\x5e\x64\xd3\xe8\xff\x63\xef\xed\xbb\xdb\xb6\x91\xc5\xe1\xbf\x6f\x3e\x05\x9a\x7b\xd7\x92\x12\x59\x7e\x89\x9d\xa4\xf2\xba\x39\x89\x93\x76\xf3\xdc\xa4\xce\x13\xbb\xdb\xdb\xe3\xc7\x3f\x85\x26\x21\x8b\x0d\x45\x6a\x49\x2a\x96\x36\xf6\x77\x7f\x0e\x66\xf0\x32\x00\x41\x4a\x96\xec\xb4\x7b\x7f\xeb\x9e\xd3\x88\x78\x1d\x0c\x06\x83\xc1\x60\x30\x53\x66\x79\x01\x9d\xa8\xc1\x87\x23\x90\x0f\xcb\x11\x1f\x0b\xbc\x27\xf1\x45\x1e\xe4\x73\xd3\x15\x2c\x12\x67\x06\x0f\x0f\x01\xd3\x2f\x18\xd1\xcf\x1c\xd9\x37\x81\x3f\x5a\x9c\x23\xe8\xb2\x8b\x2e\x0b\x5d\x79\xa4\x1c\xc5\x85\x0e\xf9\x96\x0d\xd9\x91\x2d\x0b\x14\x57\x71\x19\x8e\xc0\xed\xf6\xd4\xf7\xe2\x40\xfd\x85\x41\xc1\xd9\x76\x9f\x08\x66\xec\xa8\xdd\x39\xa8\x96\xd9\x71\xca\x04\xbe\x42\xbb\x6e\xa1\x2e\xbb\xb0\xca\xdd\x54\xf3\xc5\xd8\x88\x29\xad\x2a\x70\xe4\xaa\x40\x70\x18\xc6\x79\x81\xfa\xf1\x23\x59\xb5\xec\x90\x1d\x39\x8b\x98\x6c\xd7\x3f\x6a\xea\x1d\x07\x9f\xc5\x79\x36\x28\xe3\x50\x5d\x21\xaa\x99\x95\xbc\x9c\x8d\x79\x39\xca\xa2\x42\x0a\x3e\x82\x46\x3a\x38\xa9\xc8\x3e\x0d\xe9\xa2\xc3\x64\x9b\x64\x05\x55\x29\x55\x14\xe8\x5e\x80\x7d\x88\x06\x24\x17\xa1\xab\x11\xfa\x54\xfd\x81\x42\x33\xcb\x79\xef\x2f\x47\xc7\x3f\x9f\x9c\x7e\xfc\xe5\xe8\xf4\xf8\xe3\x5f\x7a\x32\xb7\xf7\x97\x9f\x5f\xbe\x7f\xf3\x17\xbd\xee\x15\x38\x66\x56\x95\x8e\xa3\xf7\x25\xce\xcb\x69\x90\x00\x87\x75\xd3\x80\xcd\x76\xd4\x7a\xd4\x20\xdd\x16\x28\x8d\x2c\x0a\x16\xf1\x8d\x60\xf6\x85\x8f\xf0\x6a\x41\xf1\xf3\x8d\x0d\xf6\x9d\xfa\x00\x20\x3a\xb0\xe9\xb6\x55\x9a\x74\x24\x25\x30\x46\x55\xe2\x37\x07\x0f\xb6\xb6\x70\xc7\xb9\x88\xcb\x71\x30\x79\xa0\x77\x49\x76\xc8\x76\x0e\x10\xfe\x61\x96\x87\x3c\xd2\x59\x3f\xb1\x43\xb6\x2b\xb3\x70\x39\xeb\xac\x13\x76\xc8\xf6\x64\x16\xd2\x82\xce\x12\x5b\xdb\xf3\x03\xc5\xe9\xb2\x32\xd3\x39\xaf\x44\x57\x4f\x0f\x34\x17\xd2\x19\xbf\xb2\x43\xf6\x64\xf7\x40\x33\x0f\x9d\xf1\x0b\x3b\x64\x4f\xf7\x30\xa3\x08\x86\xfc\x81\x41\xca\x21\xdb\xd9\x7d\x7e\x80\x0e\x9f\x20\x36\x84\xc1\x39\x50\xe3\x27\xc9\x51\x3e\x3d\xa8\x5c\x7d\xcb\x46\x0e\x2a\xd2\xd6\xf3\x3f\xf2\x96\x5a\x11\x1a\xd1\x57\x69\xdf\x3e\xa0\xbc\xc3\xa0\x3d\xbf\x4c\xe4\xd9\xde\xaf\xc1\x7b\xda\xf1\x15\x6f\xba\x1b\xa5\xe5\x48\x65\xb0\x72\x7b\xf3\x8f\x69\xad\xec\xb8\xff\xf4\xb9\xb7\x78\x73\x5f\xa6\x9c\xa9\xcc\xcb\xd7\xc4\xf9\x7d\x8d\x14\xfa\xfc\xfb\x9a\x0a\x8d\xfd\x59\x25\xcd\x8d\x71\x1e\x4c\x16\x77\xf9\x6c\xaf\xae\x42\xe3\x55\xb3\x5d\xf4\x9b\xa8\x2e\xe1\x3e\x72\x9a\xdb\x6e\xfe\xa7\x39\x6f\xbf\x0a\x0a\x7e\xa4\x02\x91\x18\xa1\x79\x94\x85\xec\x10\x2f\x28\x2c\x2a\x31\xb7\x14\x34\x9c\x74\x36\x29\xba\x2c\xe5\xb3\xf2\x83\xf8\xe9\x68\x23\xbe\x93\xad\x90\xf9\xa7\xd7\x9a\x4e\xdd\x03\x3b\x98\x5a\xed\x55\x4a\xcb\x5c\xa5\xb8\x8f\xb6\xb1\x3f\x9b\x02\x4c\x8f\x78\xe9\xe2\xcc\x96\xc9\xb6\xf0\xd1\x65\x2d\x81\xa4\x56\xa7\xd3\x1e\x65\xa1\x83\xab\xca\x43\xa4\x6a\x11\x34\xcd\x51\xcb\x56\xbd\x85\x3c\x04\xcc\x37\xae\xff\x55\xaf\x14\xbe\xff\x23\xd9\x93\xe3\xf7\xfb\xe8\x8d\xd4\xe9\x6f\x3d\x52\xa2\xde\x60\xf0\xf1\xcd\xcb\xa3\xd3\xc1\xeb\x37\x7f\x3f\x3d\x3e\x7e\xa7\x24\xd5\xc1\xdf\x8e\x8f\xff\x7b\x30\x10\xb0\xe3\xac\xa3\x9e\x5a\x19\x19\x35\xd6\x71\x6f\xd3\xaf\xaf\x97\xaf\xdc\x53\x80\x22\x45\x69\x11\xe3\x01\x63\x3e\x67\xb1\x2b\x50\x24\x44\x58\x8b\x0b\x76\x91\x07\x69\x38\x62\x71\xc1\xa6\x69\xce\x83\x70\x14\x5c\x24\x9c\x5d\xf0\x30\x98\x42\x48\x91\xb8\xa0\x71\x36\xe5\xb5\x6f\x90\x24\xf2\xf0\xb0\xb5\x05\x91\x88\x74\xfb\x5d\x76\x31\x2d\x55\x54\xe4\x28\x56\xd5\xc4\x56\x80\x75\xe3\x94\x45\xfc\x0b\x4f\xb2\x09\x18\x69\x18\x58\x78\xce\x87\xe2\x98\x18\x0f\xa1\xba\x81\xab\x28\xe3\x24\x61\x22\xbf\xcb\x22\x1e\x44\x2c\xcc\x22\xce\x78\x12\x8f\xe3\x14\x1d\x13\x5d\x05\x45\xda\x2a\xcd\x09\x25\x9b\xf0\x3c\x99\x33\x21\x47\xc6\x3c\xd2\x7d\xbc\xce\xd2\x16\x95\xdd\xd9\x98\x17\x45\x70\xc9\x7b\x0c\xde\x1e\xb3\xd7\xfc\xcb\x69\x96\x25\x05\xcb\x79\x12\x73\x31\x56\x16\x97\x3d\xf6\x32\x29\x32\x29\x38\x4e\x73\xae\x1a\x03\xcc\xc8\x06\x58\x94\x71\x01\x01\xcb\xc2\x70\x9a\x83\xce\xee\x4a\xc0\x8b\x91\x9c\x09\x06\xe1\x62\x33\x2e\xf1\x26\x1c\x30\xac\x9a\x0b\xd0\xbc\x56\x7b\xac\x45\xa0\xcb\x51\x9e\x5d\x81\xc8\x0c\x01\x7c\xdb\xad\xff\x33\xf8\x3f\x2d\x1d\xa7\xb1\xcc\xe7\x66\x32\xff\xce\xf3\x78\x38\x67\xe5\x28\x50\xe8\x8f\x38\x0b\x2e\xb2\x2f\x1c\x02\x7d\x5d\x70\x9e\x7a\xb0\xc7\x23\xd6\x7e\x7d\xf4\xa6\x15\x75\xb0\xc3\x25\xa9\xb2\xad\x7e\x48\x6b\xe6\x30\x80\x33\x07\xcf\x73\x42\x5e\x1a\x9d\xc8\xa6\x01\xf7\x79\x50\x8c\x10\xdb\x5d\x96\x0a\xac\x82\x51\xd7\xd5\x28\x30\x94\xf0\x2b\x57\x11\xfe\x70\xe2\x73\x0e\x72\x69\x9c\xe2\x49\xe3\x8a\xe3\x23\x3c\x44\xac\x18\x0c\xd6\x14\x67\xb5\x4c\x48\x4a\x80\x28\x01\x89\xbc\x7f\x7b\xf0\xa0\x76\x6d\x1c\x7a\xd7\x86\x00\xfd\xe8\x0d\xb2\x0a\x05\xca\x28\x98\x4c\x78\xca\x2e\x90\x44\x61\x00\xaf\x8f\xdf\xb3\x8b\x69\x1a\x25\x9c\xf1\x19\x0f\xa7\x25\x2f\x58\x91\xc1\x04\x3c\xb0\xc7\x1f\x06\xa9\x1a\xc5\x45\x10\x41\x10\xd5\x61\x1c\x22\xe9\x46\x53\x30\x5a\x8a\xd3\xdf\x39\x1e\x1a\x1e\x30\xc2\xa4\xc4\x10\x2a\x12\xa0\x8f\xe3\xee\x6d\xef\x83\xa1\x92\x36\x2b\x5f\xb2\xd6\xf3\x8e\x34\xfa\xb8\x6b\x7e\xff\x64\x7b\x6d\xe5\x5f\x51\xd6\xeb\xf5\x76\x9e\xee\x76\xda\xad\xab\xcf\x45\x4b\x2a\xe6\xa6\x10\x15\xd6\x6f\xdb\xb8\x2f\xcb\x9c\xcc\xc7\x17\x59\x83\x36\xb1\x87\x05\xb0\xf0\x2f\x27\x6f\x06\x27\xbf\xbd\x7f\x75\xfc\xce\x18\x49\xa9\x06\x28\x47\xb6\x55\x7f\x85\xcf\x5a\xd5\xc8\x23\xa9\x10\xaa\xa8\x99\x18\x8c\x91\xa8\xc4\xe8\xf7\x21\xd0\x35\x81\x63\x63\x43\x42\x40\x2a\x90\xec\x17\x0a\xbe\xbe\xc0\x46\xa7\xdd\xc2\xcf\x5e\x8b\x3d\x06\xc5\x4c\x47\x6e\xfa\x0a\xd4\x9e\x42\x30\xfc\x5b\x39\x50\x3c\xd9\x59\xd6\x52\x57\x59\xc7\x0b\xb2\x2d\x04\xff\xfe\x04\x17\xf8\x9f\x04\xf3\xfe\x94\x4e\x93\xe4\x93\x60\x7b\x9f\xf4\x56\xf8\x49\xdb\xf7\xc8\xd3\x97\xf8\x39\xe6\xe3\x0b\x9e\x1f\x0f\xd9\x00\x73\xe2\x34\xe4\x6c\xaf\xb7\xdd\xdb\x86\x6f\x1d\x04\xfb\x5d\x90\x5e\x52\xdb\xa0\x47\x37\xf2\x89\xd1\xe9\x88\xcb\x5f\x60\x1a\xc4\xc3\xcf\x3d\xdb\x36\xe8\x42\x45\x7d\xfd\x28\x53\x3e\x89\x5d\xe9\x93\x03\xb0\x80\x37\x2e\x46\x5d\x5c\x4a\x9f\x80\x2b\x7f\xc2\x96\xf8\x2c\x18\x4f\x12\x2e\x81\x1f\xf4\xc0\x9d\x0d\xbc\x4d\x15\x0b\xf5\x91\x58\xf3\x87\x3f\xa0\xd5\x82\x5d\x04\x0d\x58\x16\x14\xfa\x39\xf8\x99\x96\x80\x8e\x6d\x03\x26\xd9\x18\xba\xc7\xf9\xea\x04\xdf\x55\x97\x8e\xb0\x9e\x2b\x24\x08\x55\xab\x53\xbc\xbb\xf6\x22\x0d\x52\xb4\xb8\xa8\x59\x55\x4f\x95\xe2\xfc\xed\x9b\xe7\x83\xd7\xc7\xef\x07\xaf\xdf\xfc\xf8\xf6\xe7\x37\xb5\xda\xfa\x67\xb2\x78\x99\x7d\xc8\xe3\xb1\xf2\xdd\xee\x5d\xd6\xfb\x4a\xfd\x1f\x7d\x30\x7e\x43\x6d\xbb\x0f\x22\xe1\x0e\xeb\x96\xfd\xb3\x0e\x7b\xe1\xaf\x4d\xae\x4b\x98\x63\x4f\x72\xdc\x65\x1f\xba\xec\x65\x59\xe6\xf1\x85\x60\xfc\x38\x1d\x0a\x17\xed\x63\x60\xdc\xa0\x26\x37\xe3\x68\x7f\xe8\xa2\xe5\xe2\x01\x2d\x4a\xda\xd0\x4a\x66\x0b\x55\x1d\xb2\xcd\xab\x4b\xf8\x0f\x55\x00\xec\x7d\x58\x9c\xc8\xb6\x1e\x31\xb8\xd3\x63\x62\xbe\x65\xd3\xad\x4b\x5e\xb6\xc4\x56\x6a\x6a\x0a\x2e\xd2\x2a\x2a\xc9\x1d\x29\x7b\x9c\xce\x27\x5c\xca\x1e\x2f\x43\xb1\x83\x66\x79\x01\x41\x96\x8b\xe9\x44\x60\x96\x47\xdf\xb5\x34\xe4\x2d\xa0\xc4\x4a\x4b\xc7\x67\x1f\xce\xd9\x21\x49\xea\xe9\x97\x59\xea\xa9\x33\x72\x26\x87\x3a\x97\x79\x2a\x50\x4f\x9d\x9e\x47\x03\x0f\xe5\x39\xe7\x61\xdf\xbf\x1d\xee\x7d\xdf\x11\xed\xa9\x73\x2b\xda\x04\xb1\xca\x1b\x86\x27\x77\xf9\x20\xe0\x0e\xcc\xa3\x14\x8d\x97\x79\x90\x16\x49\x50\xf2\x93\x72\x0e\x0a\x18\x95\xf1\x32\x8d\xc7\x41\xc9\x95\xb3\x68\x62\x2a\x3f\x8c\x2f\x5f\xf1\x7f\xc6\x70\x6f\x6f\x27\x9f\x4c\xd0\x30\x9b\xde\x3a\xa0\x3e\x41\xb6\x56\x6b\xf1\xbf\xdd\x71\x4a\x36\x69\x1c\x64\x11\x5d\x85\x07\x45\xbd\xdd\xfc\x93\x3d\xf3\x9c\x60\x5a\xc6\x75\x5b\xf9\x0e\x29\xe6\x0c\xdd\x57\xfc\xf9\x93\x3d\x6f\xf1\x25\xc0\x46\x07\xcb\xdf\x42\x4b\x52\x33\x39\x12\x5f\x56\xf2\xc1\x83\x9a\x09\xb6\x0b\x63\xb2\x29\xec\x62\xca\x42\x85\xb1\x69\xab\x25\x36\x98\x11\x27\xf9\xc0\xa3\x61\xd0\x54\x61\xda\x74\x96\x57\xa3\xf5\xe1\xdd\x9a\xaf\x5d\xc4\x69\x04\xcf\x08\x2c\xe3\x35\xdd\x48\x2f\x6a\x7b\xfb\x7b\x18\x3c\x24\x56\x25\x64\x66\x3f\xbe\x7c\xfd\xf6\xe5\xcf\x78\x5f\x0e\xee\xc3\x21\x78\xb2\xd3\x6b\xc4\x2f\x73\xce\x4f\xb3\x8f\x41\x14\x07\x29\x0e\xb6\xa6\x28\xc4\x62\x4c\x4f\xb3\xd7\x50\x45\x16\xbd\xab\x41\xf0\x9a\x41\x4c\xb2\x24\xc8\x4f\xb3\x23\xe5\x41\x4b\x0f\xe7\xae\x3a\x0e\x6b\x3a\xbe\xe4\xe5\xfb\x60\xf6\x11\xe2\x61\xde\x79\xa7\x17\x35\x9d\x0e\xb3\x7c\x1c\x94\x2f\x67\x71\xf1\x3e\x98\x2c\x9a\xb9\x18\xaf\xdd\x5e\xe1\xab\x4f\x88\x4f\x57\x34\x4e\xe0\x25\x2f\x5f\xa6\x97\x09\x3f\x1e\x42\xe1\xc6\xb2\x12\x12\x2c\x7e\xc2\xc3\x32\xcb\xef\x78\xc6\xa3\x1a\x1c\xc4\xf8\x24\x58\xf5\x5a\xc1\x7d\x3c\x86\x7e\x1f\x6d\xe1\x73\xed\xc5\xcf\x30\xa5\xa7\xc7\x3a\x3e\xbe\x73\x37\xcd\x0f\x08\x57\xf1\x60\x21\x6d\x78\xed\xed\x36\xb5\x1a\x40\xf6\xc3\xfc\xba\xed\xe8\xd9\x6a\x8d\xef\x0e\x06\x10\x87\xb4\xb9\xf5\x5d\x78\x87\x27\x37\x4f\x74\xde\x6e\xc4\x61\x8c\x5c\x05\x91\xf8\x8c\x41\x0a\xdc\x49\x8b\xc9\xb7\x5f\xaf\xaa\xf7\x3a\xf6\xb5\xb1\x7a\xaf\x8a\xee\x5b\x94\xcd\x83\xb1\x73\x8f\xcf\x0f\x4c\x3b\xae\xf5\x03\x71\x6f\x40\xee\x0c\xed\xa7\x4d\xa8\x5e\xc0\x2a\x18\x70\x46\x54\xb4\x2e\xce\x2d\x3b\x04\x76\x03\xff\x29\x2f\xa8\x50\xee\x00\x64\x34\xb3\x07\x3b\xa2\x14\xbc\xd0\x82\x9b\x45\x75\x76\x02\xc0\x24\xb4\x72\x6b\xf6\x4b\x61\xa6\xea\x57\x25\x76\xc9\x08\x79\x15\xd3\x71\xe3\x2c\x9d\xa4\x5d\xe5\x71\x69\xbe\xc5\xb2\xd2\x6f\xff\xc9\x5b\x2e\xe9\xcf\xc2\x0c\x2b\xbb\xf8\x1d\x76\x7d\x39\xb1\xb8\xab\x28\xb3\xb4\x0f\x6f\xd9\x16\xdb\x79\xbe\xad\x9d\x6b\x5a\xbb\x89\xe5\x4d\x93\xe6\xb4\x21\x7c\xaf\x75\x70\x84\x14\xf6\xc8\x6d\x56\xf9\x17\x70\x36\x1f\xd2\xb2\x9d\x83\x2d\xbf\x4d\xb1\x9f\x6a\x0f\x2a\x87\x3d\x12\xed\xb3\x2d\xd5\x9f\xe9\xc9\xdd\x71\xac\xbb\x20\x27\xaf\x1d\xce\xba\x2c\x9c\x77\x19\xc6\x4d\xee\xb2\xea\xb8\xf0\xb4\x34\xeb\xb3\x70\xc6\x1e\x63\x6f\x61\x56\xb4\x37\x25\x1e\x1f\xa9\x2a\x8f\x54\x1b\x50\x7e\xde\x67\xe1\x5c\x95\x2f\xe2\xb4\xbe\x3c\x1a\x43\x12\x77\x50\x7a\xd7\x72\x5e\xdb\xeb\xf4\x36\xbc\x85\xef\xb2\x11\x8f\x2f\x47\xe4\x32\x4b\x5b\x47\xbb\xeb\x8e\xfd\xc0\x76\xe1\xd5\xbd\x5e\x69\xbb\x8e\x11\x10\x3c\xe3\x22\x99\x7d\x39\xec\x32\x9b\xf4\xd9\x76\x97\xe5\xa2\x27\xf8\x75\x91\x95\x65\x36\xee\xa3\xcf\xb4\xa1\x48\x7b\x20\xcd\x28\xa8\x0d\xe5\x38\x4e\xdb\xf0\x23\xb8\x90\xe0\xb2\x4d\x65\x53\xda\x13\xf5\xcc\x03\x72\x99\x08\x3d\x60\xaa\xf2\x88\x24\xea\xe2\x18\x49\xb9\x32\x9b\x54\xea\x22\x4c\xb2\x72\x87\x6d\xb1\xdd\x26\x4f\x0b\x56\xc8\x82\x2e\x9b\xe8\xe8\x9d\x16\x5a\xd1\x4b\x02\xf7\x47\x3b\x87\xeb\x3c\x30\x53\x78\x17\x94\xbc\x28\x31\xa1\xd6\x55\xc3\xfb\x60\xc2\x6a\x63\x20\xd4\x74\x21\x27\x53\x85\x52\xc7\xaf\x6c\xc8\xc0\x2d\xd0\x24\x40\x25\x36\x8c\xe7\xcb\xa5\xf2\xf5\x59\x0b\xc0\xa9\x27\xd6\x05\x2f\x14\xd5\x6f\x82\x1f\x85\x2c\x47\xca\xdc\xac\x8d\x98\x01\x2e\xdb\xe1\x9a\x58\xb4\x94\xd6\xc6\x67\x57\x3d\x1f\xd1\xc1\x6a\xa7\x12\x96\x88\x64\xc5\x56\xa5\x19\xea\xc6\x54\xa2\x4f\x3d\x63\x30\xde\x79\xbb\x06\x1c\xb3\x02\x90\xd2\x0e\x71\x3a\x7a\x38\x9f\xd2\x9e\x44\xce\xaa\xca\xc3\xcf\xae\x36\xd4\x0d\x72\x94\x95\x74\x01\x93\x64\x5c\x70\x47\x76\x11\x95\xa0\xfd\x3a\x87\xb3\xa5\xfc\xd3\x3a\x0e\x78\x2e\xc0\x01\xcf\x25\x2f\x3f\xf0\x3c\xe4\x29\xfa\xcf\x46\x3f\x3c\xd8\x8f\xe0\x51\x92\x36\x71\x80\x5b\x6c\x57\xdb\x37\x86\xf3\xfb\xe9\x73\xae\x16\x82\x5e\x10\xb4\xd7\x31\xe1\x51\xf5\xac\x49\xcd\x9a\x71\x89\x9b\xa6\x3c\xd7\x15\xef\x1e\x6a\xd2\x7e\xd7\xc0\xa8\xa2\xc9\x01\x8f\x9c\x96\xf7\x0a\x01\x69\xdf\x82\xc0\x20\xec\x11\xdb\xee\x3d\x27\x4e\x82\xdd\x40\x45\x92\xe2\x2d\x7f\xe8\x71\xd4\x14\x3f\xcd\xf2\xd1\x27\x5d\xd3\xcb\x56\xce\x62\xea\x99\x4f\x3b\x15\x23\xee\xd7\xcd\x9b\x1d\x19\xcf\x2d\x52\xf9\xea\x9b\x38\xec\x53\x2f\x59\xac\x47\x94\xcd\x9e\x90\xea\xc4\xec\x76\x07\xc3\x48\x4b\x5f\xf0\xf0\xbb\x63\x3f\xa4\xd0\x9c\x0b\xa3\x83\x88\xa5\x26\xb8\x43\x8b\x5a\x1f\xea\xb7\x35\x64\xbd\xea\x95\xea\x06\xe6\xac\x36\x8a\x0c\xb0\xbe\x55\x8b\xa0\xc8\xdc\x56\x1f\x63\x62\xc8\x58\xc4\x98\xb7\x29\x15\x2a\xbb\xab\x9d\x18\xb9\x41\x3b\xed\xe8\x63\xaa\xa2\x41\x8f\xe5\x4a\x05\x64\x74\x74\x70\x27\x23\xe2\x2c\x24\x66\xe7\x0c\x70\xf6\xf0\x9f\x40\xcd\xa4\x11\x20\x64\x74\xe3\x63\xb8\x2b\xa5\x10\x3b\x8a\x0e\xe9\xdf\x1f\x4c\x47\x46\x34\x71\x8a\x9a\x78\x35\x4e\xc4\x13\x19\x28\x5a\x3a\x7f\x42\x92\xc0\x41\xdf\x7e\x6c\x21\x8c\xcd\x13\xb8\x1d\x1d\x9c\x81\x4b\x2a\xb3\x32\x54\xdc\x86\xdb\xf7\xf3\x45\x71\x04\x2b\x3e\x91\xe9\xa4\x6b\x87\xc1\x42\xe4\x7e\x75\x43\xd0\xdb\x98\xbd\xd1\x0e\x2a\xb5\x2b\x70\x15\x53\xa0\xda\x96\xf4\x48\x64\xc8\x46\xd0\x67\x9f\x12\x6b\x4d\xbc\x7f\x7b\xc6\xac\x30\xfb\x5d\x16\x82\xc0\x2b\x64\xe3\x3e\xc8\xc7\x64\x21\xf4\x59\xdd\xaa\xb0\x7b\x25\xbb\x6a\x9f\xf9\x96\x67\x5f\xff\xd2\x0f\x83\xac\xa7\xb1\xcb\x86\x0f\x8b\xa3\xae\x41\x52\x35\x7c\x18\x70\x3e\xaf\xae\x85\x1e\x6f\x7c\x05\xda\x13\xf1\x8f\x38\x14\x80\xdf\x01\x48\x34\xc2\xc6\x6c\x07\xc2\x05\xc7\x69\xd9\x9b\x29\x14\xcf\x4d\xda\x5c\xb1\xf8\x19\x3c\x17\x27\x4d\x90\xe2\x95\xac\x39\x7a\x59\xa6\xb2\x74\xf1\x8f\xbc\x44\x61\x7a\x92\x5d\xb5\x67\x3b\x6c\x93\xcd\x76\xbb\x6c\xb7\xa3\x8e\x17\x22\x79\x2e\x92\xe7\x90\x6c\x3b\x97\xb5\x14\x46\xf6\x81\x82\x66\x41\x28\x8b\x2e\xc4\xac\xd8\x25\x43\x94\x61\x2c\x08\xc4\x2a\x45\x0f\x2f\x54\x85\x76\x85\xa0\x22\x8b\x85\x73\x93\x38\x37\x61\xcb\xd5\xbe\xeb\xc7\xf6\x57\x71\xca\x9a\x75\xc5\xd9\x69\x0e\x33\xc8\x24\x11\xe2\x61\x8a\x98\xcb\xc9\x86\xaa\xe1\xae\xc5\xca\x92\xa4\x28\xcb\xdc\x58\x4e\xe6\xc2\x4c\x74\xdf\x9e\xb1\x4d\x16\xce\xc4\x49\x01\x4b\xe9\x18\x03\xd6\x09\x53\x1e\x91\x03\x71\xdc\x0b\xb3\xc2\x74\x3f\x67\x3f\xb0\x50\x3b\x5a\x71\x2b\xed\x92\x43\xf0\xa6\x9d\xeb\x9a\xd2\xb9\xd0\xca\xf3\x67\xbf\xf9\x4c\xdc\xb5\x1b\xed\x3b\x10\x90\xd3\xa4\x4f\x09\x58\x95\xb8\x69\x36\xd0\xc1\x13\xcb\x21\xb8\x91\x8c\x21\xaf\x59\x32\xc6\x22\x15\xc9\x18\xea\x1c\x01\x05\x5a\xaf\xe1\x74\xe3\x5b\xec\xc9\x53\x23\xa5\xf1\x34\xaa\x14\xd6\x9d\xd8\x45\x9d\xb0\x27\xaa\xa3\xae\x6c\xc3\x12\xa3\xbe\x3e\xb0\x85\x7d\xca\x96\xd8\x26\x34\xf5\x48\x34\x8e\xe3\xaa\xb2\x29\x5a\xc6\x3e\xb6\x3b\x3a\x4f\x8a\x64\x27\x0b\x10\xbc\xd7\x65\x05\x7c\x55\x97\xda\x5e\x75\xad\xed\xf5\xcc\x12\x1a\x54\x97\xb4\xbb\x92\xdd\x65\x24\x7b\xea\x5a\x1b\x84\x68\xda\xa9\xd8\xcb\xad\xdd\x22\x50\x33\xea\x16\x0b\xac\x99\xb5\x45\x7a\xec\xcb\x92\xc3\x65\x73\xb6\xe0\x2d\xcb\x91\x44\xe3\x5d\x5e\x2d\x6e\xab\xe9\xeb\x6b\x05\xf8\x0f\xb4\xa9\x46\xaf\x92\xa4\x31\x78\x79\xe8\x06\x3d\xca\xa7\xb6\x07\xca\x41\xcd\x72\xf1\xac\x12\x07\xa7\xf6\x2a\xf1\x54\x58\xb0\x68\x7c\x35\x2a\x6b\x88\x14\x82\x5d\x43\xe5\xa9\x17\xcd\x24\xfb\x07\xdd\xba\xf6\x1b\x43\x72\x37\x0f\x05\x01\xeb\xa1\x7b\xea\xff\x95\x8c\xc8\xd7\xc2\x63\xbb\x05\xb2\x02\x6c\x7c\xb1\x1f\x0e\x29\x6e\x36\x36\xac\xcc\xbf\x1e\x32\x6b\x90\x62\xbe\x64\x33\xae\x97\x0c\x2a\x0a\x20\xee\xbb\xf5\xcc\x93\xf6\x71\x53\x31\x5f\x36\x5e\xf0\xed\x8b\xc2\x46\x3f\x17\x96\x85\xd2\x16\x1b\x95\xe5\xa4\xe8\x6f\x6d\x5d\xc6\xe5\x68\x7a\xd1\x0b\xb3\xf1\xd6\x3f\x93\x2c\xce\xb3\xf0\xf3\x56\x98\xe5\x7c\xf3\xf7\x62\x2b\x2e\x8a\x29\x2f\xb6\x9e\x3f\xfd\x4f\xf8\x15\x66\xe3\x31\x4f\xcb\xcd\x9d\x9d\xfd\x67\xfb\xdf\x6f\xef\x3e\xb7\xdf\xa4\x56\x0c\x0c\xa4\x95\xd8\x55\x9c\x46\xd9\x15\xbc\x66\x23\xd6\xbf\x1b\x1b\x32\xa3\x27\x18\x1f\x3b\x44\x06\xf8\x80\xb1\x17\xaa\x42\x5f\x35\x50\xf0\x64\xe8\xa9\x2e\x92\xad\xca\xec\x05\xa4\xa1\xb5\xa1\xf3\xac\x3b\xe5\xb3\x52\xbf\xed\x4e\xf9\xd5\xa6\xc0\xcf\x03\xc6\xfa\x4c\x7b\xca\x69\xa9\x45\x35\x12\x47\xa9\x76\xc7\x71\xa0\x78\xe9\x3a\x50\x84\x70\xba\x30\xf8\x5b\xbb\x50\x7c\xb2\xde\x53\x60\xb0\x0f\x0e\xd2\xcf\xad\x82\xbd\x7d\xf3\x1c\xee\x1b\xa4\x55\x6d\x3a\x77\x4c\x73\xaa\x66\x1f\xdf\x79\xed\x92\x76\xe8\x33\x01\x9f\xdb\x7d\x8f\xd0\xda\x0a\x5a\x82\x84\x6d\x07\x31\xf4\x1a\xed\x19\xdc\x4e\x74\x7a\x81\x98\xbd\x67\x07\xe8\xfb\xc5\xc1\xc4\x32\xcf\x74\x16\x5a\xd5\x95\x23\x2e\xf2\xce\x92\x20\xbd\x9c\x06\x97\xa8\x23\x3c\x6f\x0b\x1a\xef\x6f\x6d\x5d\x5d\x5d\xf5\x78\x38\x0e\x36\xc1\x16\x01\x6d\xa4\x83\xa4\x97\xe5\x97\x5b\x90\xbc\xfb\x74\x77\xeb\x59\x6f\x7b\xeb\x3f\x0b\x1e\x6e\x8a\x94\x22\xcc\xe3\x49\xb9\xa9\x5a\xdb\x14\xad\x15\x1d\x70\xde\x35\x64\x9f\x10\x21\x9f\x7a\xac\xcd\x7b\x97\x3d\x16\xe4\x79\x30\x27\xfe\x54\xc5\x79\x02\x4a\x14\x42\xe4\xbf\xe4\xa0\xa5\xfc\x94\xf2\x2b\x86\x0e\x6a\xdb\xdb\x9d\x4f\x62\x9d\x47\x98\x88\x9a\xc9\x76\xab\xd5\xf9\xd4\x59\xd6\x0c\x70\xbb\xb7\xf3\xad\xcd\x00\x83\x54\x8e\x6a\x39\x43\x40\x79\x08\xc5\x47\xcc\x35\x46\x7e\xb2\xcc\xd9\x4e\x97\xed\x76\xd9\x93\xf3\xc5\x45\x07\xbd\x34\xcb\x26\x8b\xcb\xb9\x26\x88\x5e\xdb\x41\x59\x96\x98\x0f\xc2\x29\xda\xf2\x02\xe8\xda\x65\x21\x22\xa5\x93\x31\x88\x13\x2b\xe3\xd9\x19\x87\x7a\xd7\xd7\x4c\xa7\x69\xa3\xd8\x4e\x9d\x15\x22\x02\x51\x5d\x15\xeb\xbd\x0e\x81\xad\x36\xe7\xfc\xa7\x26\x77\x01\xbb\xcf\xe1\xa6\x74\xeb\xd1\x23\xf6\x1a\xc2\xcc\x41\x15\x81\x84\x18\x9e\x3c\x7c\x12\xbc\xf4\x53\x4f\xeb\xbc\x73\xce\x4f\x04\x23\x3e\xb4\xd8\xb2\xe3\x4b\x10\xd2\x14\x6f\x56\x96\x90\x87\x4a\x29\xa1\x72\x64\xb7\xbf\x14\x3c\x62\x41\xc1\x02\x96\xab\x90\x64\x82\x48\xcb\x11\x57\x9b\x0a\xb6\xac\x61\xc8\xb3\x0c\x0e\x80\x66\x68\xd7\xd7\x06\xb0\xeb\xeb\x26\x5e\x5e\xc5\xbe\x68\xad\x82\xf9\xbd\xf5\xec\xb4\xef\xc9\xd5\xd7\xe9\x7c\x92\x5d\xe6\xc1\x64\x34\xaf\x7d\xbf\xb7\xfd\x07\x7b\xfb\x32\x20\xfe\xf1\x0e\xbf\xf6\x96\x36\xd5\x06\x01\xe6\x40\xee\xa8\x71\xc1\xae\xb2\xfc\x33\x3a\x25\xc8\xd2\x4d\x9c\x47\x21\xd7\xf0\x07\x62\xb3\x6f\x53\x53\x91\x07\xff\x41\x48\x4c\x6c\x6d\x40\x64\x68\x9b\xfa\x1f\x4e\x73\x43\xc6\xbf\x04\x09\xb0\xd1\x24\xc9\xae\x78\xc4\xda\x05\xe7\xec\xe8\xe4\x43\xe7\xc1\x7f\x80\x18\x61\x11\xef\x43\xd2\xf2\xc3\x4e\x1b\xdc\xa9\xb4\x77\xba\xa2\x8d\x4e\xfb\x21\xa6\x1e\x3c\x90\xd6\xad\x60\xdc\xea\xe9\x51\xac\x22\x29\x48\x99\xd5\x25\x20\xf8\x12\xc4\x89\x98\xf3\x07\xff\x11\x0f\xdb\xb6\x88\x26\x56\xea\x43\x5c\x73\x0f\x3b\x0f\xfe\x03\x40\xc3\x2c\x7c\x15\xb1\xc5\x2e\xe1\xf1\x06\x3e\x44\xb9\xe0\xd4\x43\xe1\xc5\xb4\x64\x69\x56\x8e\xe2\xf4\x52\x2c\xe2\x28\x63\xc1\x45\x36\x2d\x59\x5c\xf6\x7a\xbd\x07\xf8\x8e\x45\x8e\x8b\xd4\x8a\xd3\xa2\xe4\x41\x24\xf6\x55\x55\x19\x1f\x36\x15\x19\x8b\xcb\x56\x21\x2a\xf2\xa0\x88\x79\x2e\x1a\x45\x4f\x4f\xf2\xa5\x4b\x50\xf0\x1e\x8b\x87\xed\xef\xa4\xc3\x02\xf6\x95\xf5\x7a\x3d\x1f\x9b\xbd\xac\xae\xf2\xf5\x0c\xbd\xef\xcd\x62\x55\x7a\x8e\xae\x98\x98\xca\xb3\x43\x9d\xbb\x6a\x63\xaf\x29\x0b\x36\x79\xab\x56\x6d\xe9\x3a\x38\xe1\xbf\xc6\xe5\x28\x9b\x96\x12\xfa\x98\xd7\x76\xb6\xbf\xa8\x62\x53\xe7\x75\x7d\x75\xbc\x8f\x2f\xd1\x43\xe9\xab\x9c\x07\x9f\x41\x21\x59\x7c\xab\xf7\xb7\x17\xc1\x05\x4f\x3e\x24\xd3\xcb\x38\xfd\x31\xc9\xae\xe0\x7d\x93\x80\xf6\x54\x08\x82\x83\x49\x9e\x4d\xc4\xc2\x19\x18\xc8\x6a\x70\xb5\xdd\xe9\x65\x29\x3f\x1e\xb6\xcf\x5a\xb3\xa2\xd5\x65\xad\x62\x2c\xfe\x3f\x8e\xc4\xff\x13\xf0\x9c\x3b\x4b\x5a\x10\x6c\x69\x6b\x8b\x9d\x80\xfd\x38\x7b\x79\x72\xc4\x2e\xe6\x10\x4e\xa1\x27\xe4\xfc\xb2\x55\x48\x1b\xa9\x20\x2d\x61\x29\xbd\x2d\xc5\x32\x6c\x95\x62\x09\xaa\xeb\x78\xdc\x4a\xc5\x9a\x61\x60\x4b\x87\x32\x64\x90\x24\x73\xe5\xcf\x01\xa1\xef\x3d\x90\x96\x49\x05\x31\x71\x96\x9f\xcd\x50\x22\x90\xff\xcd\xf9\x44\x30\xc8\x31\x78\x1e\x19\x05\xa5\x90\x51\xa3\x38\x60\xe0\x85\x23\x4c\xa6\x45\xfc\x85\xab\x10\xf7\x47\x27\x27\x2a\x00\x08\xbe\xef\xea\xb9\xee\x67\xc9\xe4\xb6\x2f\xcc\x6f\x23\x90\x0d\x48\xea\x7f\x7d\x51\xf1\xd9\x49\x22\x1a\xcf\x6b\x25\x8d\x2e\xe2\xad\xe8\x18\x8c\x48\xc3\x98\xa2\xcf\x76\xb0\x7e\x31\xee\xb3\xa7\xdb\x52\x7b\x36\x8e\xfa\xec\x7b\xa5\x4a\x4b\x2e\xfb\x6c\x67\xf7\xb9\xfc\x9a\x25\x7d\xb6\xf3\xfd\x2e\xa8\xd0\x58\xdf\xd7\x97\x82\xc7\xca\x9a\xa6\x71\xe9\x40\x2f\x92\x54\x59\x99\xed\xa9\xe2\xc0\xdd\x9a\xcc\x5a\x6e\xb7\xb4\x21\x2b\x43\xba\xf0\xa2\x9d\x8a\xa4\xae\xed\xe1\xcb\x53\xc5\xe9\x74\xdf\xed\x91\xb6\x02\xfa\x7f\xf5\x0e\xbd\x8e\x31\x98\xb7\xdb\xa4\x99\x2e\x3b\xc3\x77\x12\x40\x7a\x62\x14\x40\x82\x25\x9f\xe0\xc2\xa0\xee\x2b\xa7\x13\xea\x1e\xfc\x0b\x09\xa7\x84\x2d\xa0\xfd\xd8\xf5\xb5\xa0\x6f\xcb\x4f\x63\x4b\x12\x69\x7b\x1c\xa7\x9b\x70\xc1\xdf\x6f\xb1\xc7\xb2\xf6\x63\x44\xfc\x63\xd6\xea\xb4\xb4\xaa\xc5\x5c\xab\x64\x57\xe9\xda\xbd\x06\x33\xd2\x2b\x9e\x39\xd8\x26\xa2\x7e\x8b\xed\x6c\x6f\x77\x16\x00\x21\xc3\xaa\x78\x5c\xc8\x69\xd5\xb4\xf2\xe3\x2f\xd6\xb2\x76\xa7\x4d\x3d\x32\x4a\xad\xb4\xb7\x9c\x71\x33\xb7\x04\xc2\x60\xc0\xc5\x99\xe9\xf5\xfc\x9c\x82\x0f\x67\x5b\x18\x67\xcb\x3b\x70\x59\x9d\x46\xb3\x3b\x3f\x6f\xc0\x46\xa7\x8a\x8e\x2c\x4d\xe6\xee\x9c\x7c\xe6\x73\xef\xd0\x3e\x43\x84\x7e\x75\xbf\x6d\x4a\x1d\xca\x72\x26\xd8\x4e\xc5\x31\xb9\x24\x37\xea\xf8\x5c\x85\xff\x90\xf3\x01\xa6\x90\xaa\x8c\x0d\x23\x46\x7b\xa9\x7a\xb3\x27\x34\xe3\xea\xf5\x60\xf1\xa8\x2d\xdc\x2c\x16\xac\x2e\x80\xed\xc3\xff\xbb\x0f\x0c\xa3\x93\xf6\x97\x32\x6d\x3a\xe9\xb3\xa9\x5c\x93\x82\x6e\xfb\xf0\x7f\xfc\x96\x20\xf7\xd5\x0f\x4c\x15\x98\xec\xc3\xff\xf1\x1b\x27\x0b\xff\xc1\x4b\x48\x58\xd9\xea\x59\x2c\x95\xa1\xd6\x7b\x8e\xf4\xe7\x08\x03\x72\xc9\xcb\x0f\xca\x10\xf7\xb8\xee\x4d\xdc\xf3\x9a\xe2\x4d\x0f\x62\xec\x92\xba\x81\x30\x09\x8a\xe2\x28\x48\x12\x50\x63\xd5\x89\x58\xdf\xd7\x94\x6f\x92\xac\x9c\x96\x4d\x0b\xe8\xe5\x5d\xe4\xd6\x46\x3b\xd9\xf6\x95\x6e\xec\x8c\x34\xaa\xeb\x4e\xb2\xa2\x88\x2f\x12\x7e\x64\xbc\x84\xa1\x4a\xa9\x3e\xca\xca\xe2\xba\x4d\x50\xd4\x77\xa8\xdb\x8d\xd3\x11\xcf\xe3\xb2\x7e\xe8\xd5\xa2\x4d\x3d\xea\xe6\xfe\x05\xe3\xc8\xfc\xa9\x64\x7d\x68\x53\x5a\xe3\xd7\xbd\x7d\xdd\x77\x0a\x36\x0d\x12\x4b\xd0\x53\xc4\x55\x5c\x8e\x8e\x65\x64\x31\x71\x8a\xd5\x5f\xaa\xd1\x1c\x7c\x5c\xd4\xcc\x9b\x21\x4c\x25\x37\xd7\x4a\xf8\x95\x92\x4d\x70\xea\x42\xb7\x71\xce\xb4\xb3\xf3\xe4\x6e\x9c\x33\xdd\x53\x14\x1e\x04\x0c\xdf\xbf\xd6\xe1\x69\x7f\x57\x73\x51\x5a\xd2\x6e\xfc\xd7\x38\x89\xc2\x20\x8f\xda\xba\xb5\x26\xdd\x91\x2e\x2d\x8f\x7c\xe0\xff\xd1\x77\xde\xb3\xcf\x83\xe4\xc5\x81\x80\x26\xe5\x57\xc7\x17\xbf\x83\x27\xb8\x03\xdd\x84\xd4\xf0\x5a\x8f\x42\xec\xe7\x11\x4b\xbf\xe4\x50\x2f\x26\x3a\x1d\xd9\x95\xf6\x36\x27\x7f\xe2\x0b\x0e\xcc\x23\x67\x5f\x80\xd4\xf8\x08\x3c\x46\xc0\x6f\xbe\xd1\x01\x58\x26\xbf\xf9\xc2\xd3\xd2\xac\x22\xb1\x8f\x86\xc1\xa4\x9c\xe6\xbc\x8f\x4a\x75\x21\x34\x4c\xc4\xe2\xfb\xa2\x52\xc0\x3b\xdd\x23\xe7\x36\x8c\x4d\x40\x07\xb5\x59\x4c\x72\x1e\x44\x42\x6e\x30\xc3\x18\xf3\xfc\x52\x01\x4f\xfb\x6b\xcb\xb8\x80\xd5\x30\x42\x92\x1d\x10\x01\xe9\xa6\xeb\x83\xb8\xab\x42\x0b\x3a\xa1\x80\x2e\x39\x16\x7b\x17\x17\x25\x4f\x79\xfe\x32\xbf\x2c\xda\xe0\xc8\xf2\x67\x70\x4b\x2b\xe6\xed\x22\x08\x3f\x9b\xfa\xfa\x34\x2a\x03\x64\x9c\x79\x4a\x83\x34\x27\xf2\xd1\xdd\xb8\xa2\xe0\x9e\x44\x0f\xc2\x24\x30\x2f\xd1\xd9\x57\xbf\x7a\x12\xa5\x34\x3a\x8d\x68\xc7\x06\x3a\x4b\xe5\x4b\xa5\x2e\x5b\x0c\x2a\xf8\xe9\x56\x00\x04\x51\x64\x0d\x57\xc9\xa3\xd8\x5c\x25\x5b\xb9\x9b\x94\x9d\xdd\x1e\x59\x6e\xfc\x53\x03\x48\x59\x06\xe1\x08\x5a\x23\x6e\x71\xde\xbe\x79\xfe\x98\x9d\x60\x19\x0b\x2e\x53\xba\xdd\xca\x52\x71\x7e\x20\xdd\xba\x97\x95\x60\xb1\x25\x41\xc1\x85\x27\xdf\x75\xd1\xf0\x85\x37\x36\x46\x87\xc3\x55\x51\x9a\xf3\x71\xf6\x85\x37\x61\xd5\x53\xe2\xfe\x10\x1b\xf1\xdb\x20\x96\x94\xf6\x20\x56\x75\xeb\x41\xd8\x30\xcb\xdf\x04\xe1\x48\x01\xac\xde\x37\xc4\x25\xcf\x83\x92\x93\x4b\xb4\x70\x14\x27\x51\x0e\x81\x83\xa4\x29\xbe\x4c\x50\xda\x02\xed\xac\x18\xb3\x25\x4a\x94\x55\x89\x00\x06\x5c\xcc\x2d\xaf\x4f\x90\xa0\x9c\xb5\x54\x4f\xad\x2e\x6b\x61\xb3\x5a\x8b\xe0\x0b\x41\x66\xfa\xea\xf4\xe4\xf0\xda\x3e\xf7\x34\x38\xff\xe2\xbb\x57\x4c\x2f\x30\xee\x95\x68\x6f\x17\x83\x5a\xb5\x88\x23\x31\xea\x89\xcc\x32\x75\x16\x30\xb2\x43\x32\x3c\x74\x5b\x43\x2c\x78\x9d\x08\x64\xd9\x64\xe5\x08\x64\xd9\x84\x1c\xfa\xd5\x35\xa3\x72\x53\x4d\x03\x80\xd1\x52\x24\x98\x5f\x59\x0d\x42\x46\x4c\xe5\xbf\xd3\x2d\x6e\x6c\x80\xef\x77\x59\x66\x21\x0a\x24\xa7\x93\x5e\xa2\x25\x2a\xdb\x9b\xcf\x3a\xbd\x32\x7b\x97\x5d\xe9\xa0\x73\xd0\xb3\x2c\x4c\x40\xd4\x64\x6a\x37\x20\xe6\x62\xd7\x69\x02\x2b\xd1\x0a\xaa\xef\x17\x26\xd5\x9e\x4b\x93\xac\x55\x02\xcf\x3a\xac\x6f\xd2\x09\x06\x14\x02\x88\xb5\xbf\x5c\x05\x74\x09\x8b\x79\xe8\xe1\xa5\x45\x2e\xbf\xcc\x8e\xc4\xaa\xf6\xf2\x75\x6d\x74\xeb\x37\xc9\xaf\x66\x43\x56\x03\xbc\xe9\x50\x6f\xb1\xce\xde\x47\x04\xe1\xb6\x86\xcc\x62\x74\x6b\x86\xc4\xca\xd4\xde\xdb\x02\x01\x7b\x13\x86\xb2\x99\x48\x9e\xd1\x67\x27\xe8\x40\xec\x82\x9b\xc8\xd0\x7a\x4b\x8c\x2d\xf8\xea\x02\x16\x22\xb6\x24\xf0\x7d\xf5\x43\xaa\x33\xb0\x6a\x7f\xb1\x54\x21\x8d\x1f\x51\xdc\xb1\x18\xb1\xe5\xa1\x6a\xe0\x78\xdc\x84\x51\xeb\xa3\xa2\x19\xb6\xd5\x42\x97\x0d\xa8\x67\x49\xaa\x15\xb2\xca\xe9\xbd\x0b\x5a\x75\xce\xfa\x24\xca\x18\x78\x7e\xb6\x77\x1b\x4b\x59\x07\xd5\xeb\x8f\xd0\x6e\x4b\x36\xb0\xbd\xc1\x00\x24\xd8\xc1\x00\xee\x19\x45\x53\x8e\x9a\xa3\x66\x94\x9d\x4e\x8d\x67\x6a\xa3\x0c\xc3\x71\x11\x9d\x42\x2d\xc2\xce\xb4\x92\xab\xcf\x5a\xa1\x42\xde\xeb\x38\x7a\x9f\x4d\xd3\xb2\x45\x54\x5e\xe4\x7a\xba\x52\x8e\x08\x03\x02\x28\x21\xdb\xa8\x2e\x8a\x36\x5d\x15\xea\xb1\x01\xf6\x87\x4e\xed\xf4\x94\xa1\x03\xd5\x9a\x3e\xbd\x65\xdb\x15\x8f\xaa\xcb\xf9\x54\x05\x20\xbd\x8e\x55\xbd\x70\xea\xf1\xfe\x1a\x27\x49\x23\x94\x9e\x92\x2e\x6e\x50\x42\x59\x06\x3d\x14\xcd\xcb\xf5\xaa\x0b\xae\x38\x21\x36\xf8\xe9\x78\x19\x1a\x20\x45\x57\x1f\x2a\x85\xaf\xa6\x43\x7b\x08\xce\xf0\xc4\x7a\x30\xb9\x59\x5a\xdf\x93\x03\x53\x4d\x67\x15\xc8\x9b\xfb\x1b\x0e\x1b\x86\x66\x95\xad\x1b\x9c\x3b\x80\xe3\xfc\x78\x38\xb4\xbd\xf2\x6b\xe1\xcd\x50\xaf\x94\xe0\x50\xce\x52\x7b\xa4\x76\xac\xa0\x5f\x52\xc1\x1e\x8e\xef\x7c\x45\x75\x55\x47\x65\x13\x73\x4b\xd5\x07\x09\x83\x6b\x3b\xec\x37\xcd\xa0\x81\xc2\x19\xd6\x38\x27\x0e\xf4\x4d\xc3\xae\xe0\x4a\x97\x9d\x1c\x62\xef\x22\x4e\x23\x30\x1c\xeb\xaa\xb6\x3b\x1d\xe7\x71\x9b\x6f\x12\xd3\x88\xe7\xb5\x73\x27\x32\xdb\x15\x8e\x40\xd0\xa6\x05\xe5\xeb\x6b\x1d\xb7\x52\x76\x74\x4e\x8f\x83\x16\xb3\x3c\x78\x70\xd3\x46\xed\x55\xcf\xda\x65\x6c\xae\x4e\x15\x57\xcb\x6e\xe9\xe8\x02\xf8\x91\x00\xe2\x11\xfb\x2d\x9b\x82\xb1\x87\x0a\x4c\x19\xb0\x22\x06\x7b\x64\x00\x9a\x95\x59\x06\x8e\x46\xc1\x13\xb0\x1a\x47\x9f\xaa\xc1\x14\x9b\xeb\x49\x7c\x76\x69\xeb\xa7\x23\xce\x5e\x1f\xbf\x57\x13\x5d\x66\x0c\x45\x04\x56\x92\x66\x31\xd3\xdf\x28\xdc\xab\x8b\xb4\xf6\x99\x37\x5b\x1a\x2b\xfa\xf2\x90\xa0\xce\x3b\xbd\xb8\x90\xba\x93\xe8\xc1\x0d\xeb\xb3\xaf\x37\x3e\xff\x4c\x0e\xee\xef\xde\x35\xe8\xde\x32\xee\xd3\x16\x9a\xc0\xe2\x80\x37\x93\xf8\x33\xef\xb1\x97\xf2\x86\xd2\x4e\x17\x35\xc0\x40\x20\xcd\x4a\xe9\x88\xf2\x01\x38\x73\x88\xc0\x25\x6e\xc0\x3e\xe1\xea\xfb\x24\x9f\xaa\xb1\x6c\xa8\xcd\x81\xfe\xcc\x2e\x2a\xc9\x10\x6f\x63\x9d\xfa\x2e\xfe\xcc\x97\xb1\x50\x85\x72\xcb\x5b\xa9\x42\xf1\xaa\xa5\xaa\xb2\x41\xf5\x14\xbe\x85\xb9\x2a\x94\xaf\xf3\x78\x49\xec\x52\xa9\xfd\x2a\xb3\x8e\x7b\x4d\x76\xa8\xa2\xf5\xaa\xad\xd4\x9f\x32\xf8\xe9\xab\x69\x59\x66\xe9\xab\xa0\xa8\x8d\x9e\xb0\xb7\xfb\x07\x5b\x44\x1a\x10\xff\x04\x16\x91\xcb\x3c\x0d\x69\x36\x28\xbe\x08\x0a\xfe\xb6\x68\xba\xa7\xd8\xdd\xde\xeb\x18\x97\x25\x1f\x78\x3e\xcc\xf2\xb1\xe0\x2b\x11\xe7\x13\x10\xd4\x82\x3c\x2e\x8c\x35\x03\x2b\xaf\x32\x65\xaf\x53\x66\x2c\xe2\x25\xcf\xc7\x71\xaa\x5c\x9e\xcf\x59\x90\x83\x59\xbf\xe8\xe0\x4b\x90\xa0\x7b\x74\x68\xfb\xd1\xa3\x9f\xb3\x92\xf7\x1f\x3d\x42\xa3\x47\x19\x29\x44\x5f\x2c\xc8\xae\x20\xf8\x3d\x1a\xe7\xc3\xbf\xec\x62\x3a\x1c\xf2\xbc\xe8\x32\xc9\x57\x0a\x08\xc8\x0d\x21\x38\xb4\xc9\x3e\xf8\xcb\x36\x9f\xe3\x00\x64\x73\xb0\xdc\x2f\xba\xda\xf8\xbf\x6a\xe2\x2f\x5a\x2a\x78\x09\x6f\x86\x45\xd7\xe2\x07\xf8\x1b\x2e\xd0\xd8\x5f\xac\xc8\x48\xc2\xd3\xab\xb4\x23\x86\x2a\xc1\xe6\x91\x68\x0a\x0d\xa8\xe2\x1c\x43\x6e\x09\x86\x2d\x0f\x9d\x3c\xa2\xbe\x96\xa4\x73\xf7\x32\xe6\x45\x4f\x1b\x90\x16\xd0\xe1\xeb\xe3\xf7\xa2\xa1\x34\x8b\xb8\xdd\x3c\x18\x97\xa1\x69\x2b\x17\xb3\x19\x97\xf3\x2e\x8b\x7b\xbc\xc7\x3e\x1d\x1e\x1e\x2e\xef\x8c\x78\xf5\x57\x08\x08\x48\xcf\x29\x89\x26\x44\xe0\x2a\x06\x7e\xf9\xcb\x2f\xb3\x37\x94\xaa\x37\x1c\xb8\xa1\x9f\xc5\xdb\x03\x38\xd8\x50\xda\xb2\xaf\xac\x15\xb4\xfa\x6c\x07\x5e\xe0\xca\x3c\x69\xe7\x64\x67\x29\xa6\x0e\xab\xa3\xad\x64\x0f\x65\x39\xe1\xdb\x2f\x32\x63\x1b\x0f\xc5\x16\xb1\x7f\x6c\x59\xfa\xda\xc2\x86\xe9\x06\x40\x16\xa7\x5d\xa8\x8e\xe1\x43\xd1\x2a\xaf\x6f\x7c\x97\x74\x37\xae\x26\x97\x77\x6e\x37\x28\xf2\x70\x70\x11\x17\x3c\x2c\xeb\x5d\xe7\x41\xb8\x42\xd2\x7c\xce\xef\xcb\x31\xe2\xd2\xa0\x42\x88\xe7\x3a\xcf\x89\x1a\x3e\x2c\xfd\x11\xfc\xd2\x78\xbd\x20\x3a\x25\xdf\xf1\x61\xe9\xb8\x3f\xbc\x85\x5b\x3e\x01\x5f\x50\x84\x1c\x50\x52\x8b\xcd\xe7\x3b\x77\x8d\xcc\x3a\xc7\xa0\xb7\x01\xd6\xc6\xe7\x0a\x6e\x03\xcd\xe4\x64\x79\x3d\x25\xc1\x13\x8a\x3b\x1d\x7c\x9d\x5f\xcf\x5b\x00\xbb\xde\xd8\x9f\x60\x73\x61\x9e\x15\xf5\x1e\x13\x9f\x3f\xdd\x6d\xa6\x54\xa8\xbe\x22\xe9\xed\x21\x04\x11\x5f\x4c\x7b\x4f\x9f\x34\x83\x61\xda\x58\x11\x96\x7d\x05\xcb\x97\x18\x8c\x91\x1b\x48\x61\x01\x46\x74\x13\x2b\x42\xf2\x14\x21\x01\x53\xbf\x06\xde\x06\x21\xfc\x1b\xc0\xc0\xfa\x2b\xc2\xf0\x0c\x61\x18\xc5\x45\x99\x5d\xe6\xc1\xb8\x61\x62\x16\x80\xa1\x9b\x58\x11\x92\xe7\x08\x49\x39\xca\x79\x31\xca\x92\x68\x30\xcc\x39\x8f\xc6\x41\xfa\x3a\x0e\xc2\x2c\x8d\x9b\x48\xf7\x59\x33\x68\xba\xcd\x1f\x9d\x26\x57\x04\xf5\x7b\x17\xd4\x22\xcc\xca\xfa\x19\x7c\x0e\x61\xd5\x96\x81\xef\x44\xb4\xb3\x2a\x7b\xdf\xae\x40\x55\x4e\xf3\x4b\x5e\x8f\xb7\x27\xcb\xc3\x85\x2d\xad\x0a\x99\x64\xe6\xe3\x60\xd6\x80\xa3\xef\x9b\x61\x19\x07\xb3\x55\xbb\x97\xec\x74\xcc\x83\xfa\xc5\xfe\xfc\xd9\xf6\x82\xfe\x79\xb0\xea\x3a\xdf\x79\xa2\x00\x88\xe2\x46\x10\x76\x16\x81\x40\x3c\x63\xdf\x1a\x88\x3d\x05\x44\x7e\xc9\x1b\x60\x58\xc0\xf3\xa0\xfa\xaa\x20\x48\xd6\x3b\x8e\x9b\x98\xee\x22\x3a\x88\x57\xc6\x80\xe4\xb7\x93\x20\xce\x9b\x16\xc5\x82\x59\x80\xea\xab\x82\x20\xd9\xed\x84\xe7\xe3\x69\xd9\x34\x0d\x0b\x76\x41\xd9\xc0\xaa\x60\x48\x5e\xfb\x8f\x69\x90\x96\x71\x52\x0f\xc7\x2e\x44\x09\xba\x53\x69\xa8\xce\xd9\xf6\x6d\xa0\x5d\x4f\x1c\xda\x91\xec\x1b\xdc\xb2\x35\xd0\xc1\xd3\xbb\x1e\x7a\x9d\x67\xf9\xa5\x41\x5d\x53\x04\x96\x1b\x44\x11\x36\x32\xa1\x05\xdb\xbc\xa8\xbd\x22\xd9\xed\xca\x7d\xa0\x18\x4d\x87\xc3\x06\xaa\x7b\xfe\x6c\x7f\x01\x0c\xd8\xc0\xaa\x60\xc8\xfd\xa0\x98\x36\x48\x3b\xcf\x9e\x2e\x00\x61\xba\xaa\x9c\xb3\x2b\x77\x03\x70\x77\xd7\x40\x7e\xcf\xee\x9a\xfc\x46\xb7\x3f\x87\xd8\xa0\xfa\xc9\x6f\x7d\xc0\x86\xeb\x03\x76\x71\x2f\x80\x5d\xae\x0f\x58\xb8\xce\x82\x95\x5b\x36\x44\x0f\x99\x64\x45\x03\xb3\x5a\x24\xbd\xe8\x26\x56\x25\x5a\xb9\x75\x83\x5f\x88\x34\x6c\x62\x9b\x0b\x76\x2e\xd5\xc2\xaa\x80\xc8\x4d\xfc\x9f\xf1\xa4\x61\xf1\x2e\x38\x0f\xfc\x33\x9e\x80\xf5\x71\xd3\x9f\xad\x11\x6b\xf4\x4f\xf3\xe7\x08\xbe\x52\xb7\xb1\x46\xd2\x6f\xf5\x09\x0f\xb3\x34\xfa\x66\x51\x4b\x54\xb7\xef\xe3\x74\x5a\xf2\x6f\x16\xb7\x44\x75\xfb\xb7\x6c\x5a\x0d\xd8\x71\x5f\x6a\x2c\xd5\xe9\xeb\x60\x7e\xe7\x7d\xd6\x09\x0d\xaa\xcf\x5f\x39\xff\x8c\x9d\x82\xc5\xbe\x35\xd9\xec\x90\xed\xf0\x27\x76\x0e\xce\x07\x3b\x64\x4f\xf9\x9e\x9d\x23\x50\xc6\x0e\xd9\x93\xa7\x7c\xdf\xce\x78\x1d\xcc\xd9\x21\x7b\xfe\x74\xcf\xcd\x10\x7d\x8b\x96\xb6\xf7\x9e\x8b\x2c\x77\xd1\xdc\x65\x70\x63\x73\xed\x9d\x4d\xe6\xe8\x62\xbf\x1d\x76\xd8\xee\xf6\xce\x93\xcd\x49\xce\x0b\x50\xeb\xff\x18\x84\xfc\x22\xcb\x3e\x77\xd9\xdb\x34\x54\x37\x18\x70\x37\x24\x63\x74\x40\x94\xd7\xb8\x60\x49\x1c\xf2\x54\xb0\x86\x69\x1a\xf1\x1c\x6e\x0a\xde\xbf\x3d\x55\xc9\x6c\x98\x4d\xd3\x48\xba\xa5\x17\x4d\xbc\x7b\x7b\xf4\xe6\xe7\x93\x37\x6c\x18\x27\x5c\x79\xab\x07\x2f\x34\x51\x9c\x83\x86\x6e\xce\xb2\x21\x3a\xa4\x90\x1d\x95\x39\xe7\x0a\x80\x07\xce\x4b\x87\xe0\x33\x7f\x33\x9e\x94\x73\xed\xe9\x23\xc8\x2f\x2d\x35\x7e\xd5\xaa\xdd\xbc\x07\x38\xd0\x16\x8b\x12\x1f\xa7\x56\x2c\xe2\x20\x0c\xf9\xa4\xc4\xab\x9f\x28\x2e\xc2\x20\x8f\x0a\x16\xa7\x93\x69\x59\x1c\xb0\xb8\x84\x1b\xfe\x34\x63\x45\x1c\x71\xc6\x87\x43\x1e\x96\x45\x0f\x9b\x40\x57\xf9\x93\x3c\x1e\x07\x79\x9c\xcc\xd9\xb4\xe0\xc3\x69\xc2\xe2\x28\xce\xc6\x96\x0f\x81\xec\x0b\xcf\xf3\x38\x82\x7b\x27\xdd\x2f\x4f\x23\x7c\xc7\xcd\xae\x46\x71\x38\x02\x83\x82\xe4\x2a\x98\x17\x2c\xe5\x3c\x62\x65\x06\x4e\x0a\x82\x04\x7c\x8e\x74\x19\x5e\x1d\xfd\x3f\x27\x2c\x09\xc2\xcf\x05\x0b\xe0\xc6\x7a\x53\xe4\x63\x87\x2c\x48\x02\x76\x94\x85\x59\xd0\xd3\xee\xf6\x39\xc5\x19\xb5\xce\xb4\x32\x04\xca\x20\x86\x37\x4d\xec\x95\xa3\xa0\x54\x17\x44\x87\xd5\x19\x38\xa8\x2f\xfe\x23\xc4\x1f\xf6\xd4\x69\xc3\x05\x4d\xa7\xa1\xea\x69\x3e\xf5\xd7\x94\xf1\x0e\x6b\x2b\xfe\x3c\x4d\x12\x6f\x45\x69\x22\x50\xdf\xe3\x28\xb6\x23\xab\x5a\x64\x25\x5d\xd4\x34\xd4\x7f\x29\x8d\x37\xad\x36\x5c\xea\x04\x22\xbc\xf1\xb9\x52\xe2\x36\x4e\x6d\x6e\xb0\xbf\x7e\xe8\x5b\x08\x69\xe9\x15\x3a\x76\x25\xfb\x43\x23\xd3\xd7\xbc\x08\xeb\x44\x83\xe7\x9d\x83\x2a\xe0\xf5\x21\x30\x0d\x1a\xd4\x75\x9e\x15\x31\xe7\x01\x89\x3e\xd9\x1b\xda\x65\x0c\x2c\xed\x1d\x55\x03\x1c\xf6\xf4\x97\x68\x15\xd3\xed\x40\x38\xa6\xb3\x4c\xfa\x0b\xab\x46\x87\xdc\x5f\xda\xe7\x51\x43\x3c\xde\xb8\xb4\xe9\x06\xad\x48\xa4\x03\x0a\xed\xe7\xeb\x85\x48\xf9\x4e\xc6\x57\x35\x6e\x1a\x55\x31\xf2\x62\xc0\x03\xe6\xfa\x21\x56\xc9\x73\x06\xef\xf4\x3d\x97\x3e\x4d\xd3\xec\xaa\xce\x36\xe4\xc9\xb6\x2c\x53\x66\xe8\x94\xaf\xd6\x47\xda\x13\xe5\x23\x0d\x82\x7e\xea\x00\xe7\x61\x96\x16\x65\x90\x0a\x1e\x2a\x99\xd4\x8f\xbf\xfc\x7c\x34\x78\xf3\xf1\xe3\xf1\xc7\xc1\xe9\x9b\xff\x39\x65\x87\xac\xf5\x66\x36\xe1\x61\xc9\x23\x16\x30\xfa\x8a\x62\xeb\x11\x7b\x35\x8d\x93\x72\x33\x4e\x95\xe5\x82\xf6\xd0\x54\x00\xa3\x2d\x47\x42\x5e\xbf\x8a\xcb\x11\x86\x47\x09\xc6\x32\x56\x49\x50\xc8\x0b\xe8\x4f\x18\x91\xe0\x93\x6c\xc0\x80\x91\x06\x65\xfc\x85\xbf\x0f\x66\xda\xa3\x70\x20\x9d\xf1\xca\x1c\xcb\xd7\x30\x09\x30\x03\x34\x8b\xc6\x1a\x17\xd9\x34\x0d\x79\x64\xe8\x02\xdc\xbc\x44\x3c\x11\x5c\x3d\x4e\xbf\x64\x9f\xe3\xf4\x92\x7d\x12\xd9\x9f\xd8\x34\x2d\xe3\x84\x05\xc3\x52\x40\x75\x15\xc4\x25\xd8\x94\x8d\xe3\x24\x89\x0b\x10\x45\x0a\x36\x0a\xbe\x70\xc6\x93\x60\x02\x7e\x69\x60\x03\x10\xc3\x4a\x82\xa2\x64\x65\x3c\xc6\x2f\x4f\xb7\x57\x01\xec\x4c\xd0\x23\x8f\x7a\x60\x1a\xe0\x29\x16\x66\x63\x5e\x20\xb6\x02\xf6\x29\x14\x47\x8c\x44\x21\x06\xcc\x07\x20\x05\x2c\x3d\xc4\x10\x78\xa4\x40\x17\x0d\xa3\x5b\x1a\xdc\x36\x03\xf6\x69\x98\x4c\x0d\x56\x45\xe5\x78\x0c\xba\xd7\x92\x43\xa8\x7e\x01\x88\x80\x76\x0c\xa6\x03\x1f\xa4\x65\xe4\x27\xf9\xa6\xe0\x13\x54\x48\xa3\x38\x0c\x4a\xce\xae\x46\x1c\xa7\x0a\x3b\x2b\xf4\xbb\x07\x39\x1e\x96\x69\x29\x23\xe1\x01\x5c\x6b\x05\x69\xb4\x25\xa6\x3f\x0f\xe2\x44\x7c\xf3\xe8\x92\xa3\x7c\xc1\x25\x6e\x01\x5f\xd9\xb4\x44\x64\xa8\x71\x14\xaa\x4d\xd1\x98\x26\x1b\xc0\xaf\xb6\xca\x57\x76\x9c\x91\x72\xb1\x57\xc5\x64\x8f\x9d\x4c\x2f\x0a\xfe\x8f\xa9\x8c\xc3\x23\x76\xe5\xa2\xbe\xb8\xd9\x5d\x38\x31\x18\xd4\x3d\x23\x70\x6a\x02\x95\xfb\x1f\xd7\x7e\xe7\xed\x90\x7d\x92\xc3\xff\x84\x4e\x31\xd5\xe8\x3f\xe9\x67\x21\x41\xce\xa5\x71\x47\xd7\x0c\x99\x50\x86\xc4\xa4\x1f\x6f\x12\x61\xe0\xe2\x42\xd9\x86\x54\xc7\x02\xad\x69\x34\xb2\x71\x96\x8b\x79\x0e\x52\x96\x09\x6a\x95\x41\xe9\x3d\xd3\x20\xc7\x23\x46\x81\x19\x71\xc1\x3e\x6d\xcb\x91\xe8\x71\x89\x44\x34\x39\xe9\x56\x69\x4f\xe4\x46\x62\xfd\x4b\xcb\x1f\x5c\x50\x12\xeb\x29\x9f\x95\x10\x1e\x41\x48\x4e\xe3\x38\x81\x50\xd0\xec\x53\xc1\xcb\x53\x84\xe0\x93\x22\x7c\x3d\xce\xa1\x00\x40\x01\x76\xc2\x39\x3b\x7b\x1d\x7c\x89\x23\x76\x94\xe5\x17\x41\x38\xca\x5a\x02\xa1\x65\x1c\x26\xd2\x41\x6a\xd1\xdf\xda\x0a\x8b\x62\x53\xc8\xdb\x9f\x0b\x70\x04\x2c\xf1\x13\xa7\x97\x9b\xe5\x28\xcf\xca\x52\x60\x75\x93\xcf\x26\x49\x10\xa7\x3c\xda\x94\x26\x33\xc5\x16\xf8\x44\x15\x1c\x2b\xe2\x65\x10\x27\x05\x88\x88\x88\xe2\x78\xa8\x59\x9a\x32\xf7\xfa\x34\xe8\x29\xcc\x4b\x0c\x0d\x7a\xb2\x7d\xbe\x96\xd9\xd1\x8f\x64\x16\x95\x41\x91\x4a\xbb\x81\x39\x86\xe5\x62\xf8\x59\xa6\x49\xc0\x32\x42\x42\x33\xaf\x1b\x76\x26\xe6\xf2\x70\xfb\x1c\x83\x44\xe1\x06\x91\x0d\x6d\xa6\x06\x6d\x24\xc1\xdc\x6a\x40\x85\x8d\x3a\x93\xa4\x7b\xf8\xf5\x06\x1b\x51\xa4\x2c\x1d\x5a\xd2\x3a\xda\x8e\x49\x55\xea\x49\xba\x39\x04\x92\x39\x17\x65\xd9\x09\xbc\x95\x9a\x1b\xee\x2b\x49\x5e\x71\x0e\x0f\xc5\xfb\x47\xa6\xfa\x18\x07\xb3\x5f\x83\xb8\xc4\xd6\x05\x84\xe3\x60\x16\x8f\xa7\x63\x64\xc8\x86\xb1\x28\x87\x85\x28\xc7\x2b\x06\x7a\xc1\x87\x62\x85\x80\x31\xb1\x62\xcf\xcd\x63\x52\x6b\xf3\x50\xac\xe3\xe6\x31\x35\x2d\x63\xc7\x06\xcc\x4c\xb2\x92\xf1\x71\xd1\x5c\xf9\xb8\x9b\xc7\xda\x6b\x6b\x8b\xbd\x84\x07\x66\x61\x56\x94\xc9\x5c\x70\x3c\x08\xb3\x06\x73\x85\x4e\xc5\x89\x1f\xc5\x22\xfe\x27\x47\x2e\xc1\x86\xc9\x74\x06\x0d\xfe\xfe\xff\x4e\x79\x3e\x6f\x63\x89\x4e\x0f\x5d\x8f\x8a\x82\xad\x2e\x33\xe4\xde\x56\x0d\xf3\x77\xc1\x3c\x9b\x96\x5d\xb6\xb3\xbf\x0d\xef\x0b\x14\x18\x6f\x71\x6f\xf9\x54\xf0\x34\x7a\x1f\xc4\xc9\x27\xb1\x7f\xa4\x2c\x4c\xe2\xf0\x33\x8f\xba\xcc\x2c\x49\x56\x68\x26\x8d\x1c\x9a\xc2\xa1\x9e\x2e\x00\x20\x50\xd9\x86\x43\x35\xdf\x65\x4f\xb6\xb7\xc1\xe6\xf5\x11\x63\xac\x25\xc9\xa8\xa5\xad\x5e\x21\x55\x4d\x44\xab\xaf\x6d\xd2\xe4\xe3\x42\x05\xf5\x9b\xb4\x98\x0a\xe6\x7c\x11\x94\xe1\xe8\x5d\x76\x49\xf7\x22\x64\x9d\x28\x18\xec\x30\x5c\x36\x62\x36\xcd\xcc\x18\xe8\xd1\xe5\x80\x4a\x3f\xa4\x10\xab\xa6\xbb\x6c\x77\x5f\x40\xcc\x5a\x92\x74\x5b\x7d\xb6\xb3\xbd\xbd\xcd\xa4\x01\xf7\x17\x1a\x8f\x53\x50\x00\xd8\xed\x9f\x40\x4a\xbb\xb5\x55\x94\x39\x0f\xc6\x2d\x2c\x2b\x91\x25\xe3\x72\x02\xae\xa4\x60\xd7\xea\x1a\x38\xe8\x40\x8f\x40\x86\xb0\xc9\xd3\x00\x6c\x6f\x70\x3e\x9a\x98\x64\x13\xc1\xd7\xac\xf6\x7b\x28\x98\x40\x37\xc4\xd6\x4f\x8f\x5c\xa4\x74\x99\x60\x45\x1e\x47\x04\x62\x8b\x7d\x99\x5f\x6a\x37\x73\xe2\x5b\x1c\x02\xd5\xb7\x44\x92\x89\x9b\x03\xb1\x67\xd4\xdb\xa1\x78\xcc\xf3\xb7\x11\xad\x7b\x14\x24\x89\xd8\x52\x68\x1a\xd2\xa4\x48\x65\x87\x6c\x5b\xe7\x48\x96\x73\x68\x3c\x40\xc8\x0e\x3d\xa9\x1a\x59\x87\x32\x56\xc1\x03\xeb\x99\x0f\xb0\xe6\xef\x2c\x4f\xc9\xea\x19\x3d\x44\xdb\x17\xf3\x68\x22\xee\x3b\x22\xb6\x7c\x66\xc8\x00\x45\xa2\x03\x29\xcb\xb7\xc5\x37\x38\x4d\xdd\x56\x81\xf8\xb5\xb7\x67\xfd\x94\x5e\x76\x63\x06\xf3\xdd\x77\x0e\xfb\xc5\xb7\x38\x7a\x58\x9a\xec\xc0\x09\x88\x72\x25\x43\x50\x0d\xe7\x76\x28\xfc\xc2\x48\xe1\x6d\x0d\x94\xc3\x78\x11\x3e\x9c\xde\x0e\xeb\xab\x46\xb0\x45\x82\x35\xb3\x08\x49\xbf\xec\x05\x01\x57\x17\xee\xeb\x7a\x55\x67\x64\xb8\x26\x05\xbb\x6c\x8b\xc9\xb7\xa2\xad\xa1\x4b\x0b\x97\xa0\xf0\x85\xd9\xcb\xfc\x52\xe6\x9d\x82\x0e\xe1\x81\xa2\x8d\x97\xa6\x96\xd4\x3d\x10\xa7\xa5\x5e\x02\x12\xfd\xaa\x57\xab\x05\x3e\xad\x11\xe0\x91\x37\xa4\x2f\xf3\x4b\x78\x46\x5a\xd8\xaf\x5b\xb1\x78\x75\x4c\x72\x9e\xde\x44\x97\xdc\x1a\xd4\xd6\x16\xfb\xc8\x0b\x5e\xb2\x20\x9d\xb3\x4f\x12\xb1\x28\xb2\xe5\xbd\x45\xb0\x6d\x6d\xb1\x93\x32\x00\x0b\x18\xdc\x74\x72\x79\x22\x73\xf6\x25\x6c\x48\x2e\x24\x88\x06\xa2\x24\x32\x80\x25\x7f\x33\x9b\xc4\xb9\x60\xdc\x30\xc1\xba\xed\xb7\xfa\x08\x61\x6d\xdd\x3d\x3a\x5e\x95\xf1\xa2\x3a\x6b\xfd\x5a\x64\xe4\x7c\x1c\xc4\x69\x9c\x5e\x8a\xc1\x56\xe6\x58\x7c\x9f\x08\xe9\xe9\x9d\x5c\xea\x72\xcc\x6c\xd3\xbb\xf8\x99\x5d\x41\x02\x6d\x55\x31\xe8\xa3\xb1\xd5\xe4\xbc\xc2\x82\xdc\xac\xf6\x6a\x07\xc7\x72\x57\x4b\x9c\xea\x78\x80\x6a\x49\x6d\xfa\x00\x69\x42\x03\x9e\xb2\xb0\xdc\x37\xc5\x82\x1c\x9a\xd8\x13\x63\x38\xf6\x95\xa8\x5a\x85\xa9\x1e\xc6\x79\x81\x9b\x75\x97\x05\x61\x19\x7f\x89\xcb\x39\x28\x64\x8b\x32\x9b\xc0\xb3\x80\x34\x62\x57\xbc\x95\x73\x16\x94\x78\x28\xc4\xb6\x2c\x92\xeb\xa2\x32\x60\x5e\x94\x5c\x8a\x69\xa2\x89\xcb\x2c\xe5\xec\x22\x08\x3f\x5f\x81\xc6\xd7\xb4\x24\x36\xbc\x32\x4e\x2f\x55\x5b\x71\xc9\x82\xa2\x4a\xc8\x5d\x96\xe5\xa2\xc6\x17\xce\x46\x31\x92\xbd\x59\x33\x49\x3c\x8e\x4b\x8b\x38\xdb\x14\x53\x8e\x8b\xd0\xeb\x6b\xd6\xae\xe2\xf8\x87\x43\xa6\x18\xb2\x44\xac\xa7\xd0\x5f\xd9\x36\xba\xb9\x96\x44\xb1\xb1\xe1\x45\xfe\x0f\x87\x8a\x34\x3a\x1e\x8f\x8b\x74\xe1\xb5\xdd\x89\x17\x52\x41\x76\xd5\x26\xae\x20\xab\xb4\x52\x7d\xaa\x29\x31\x65\x78\x0c\xf5\x05\x89\x8c\xc6\xe6\x16\x4b\xf3\x05\xcf\x82\xf5\x0d\xa9\x02\x80\xda\x1f\x75\x0f\xd4\x59\xb4\x84\xea\x38\x35\xda\x8a\x78\xc8\xae\x38\xaa\x60\x3e\x29\xc6\xfd\x09\x75\xf5\x60\xd9\x56\x28\x61\x5f\x10\xd3\x05\xe7\xa9\x6a\xc4\x88\x37\x41\x29\x78\x52\x51\x82\x44\xd7\xd3\xf8\xd3\x64\xb4\xb1\xa1\xb7\x84\x0a\x06\x5d\x16\x46\xf1\xb7\xd4\x3e\xb2\x60\x13\x40\x19\xaa\x4d\xbd\xb4\x28\xd4\x58\xd1\xa1\x89\x97\xa0\x84\x07\xb9\x35\x27\x6f\xa3\x0a\x58\xb6\xe8\x73\xe0\x03\xd7\x2c\x02\x0a\xbd\x77\x5e\x5c\xa0\x41\xcb\xe4\x5e\xf1\xe8\x9a\x8e\xdb\x5d\xc9\x55\xfb\x36\x2d\x00\x2d\x7b\x08\x46\xcf\x5a\xed\x02\x30\xec\x2d\x2e\xde\xaa\xa3\xd7\xa1\x87\x73\x56\x77\x7b\xad\x4c\x32\x08\x51\xc3\x06\xe9\xc0\x15\x26\xf5\xce\x4a\xfc\xa6\xa8\x2e\xed\x38\xa9\xde\xc1\x5b\x31\x48\xad\xbd\x11\x50\x40\x7b\x72\x9e\x6a\x63\xa3\xc8\x4b\x68\x2b\x5b\x5b\xec\x6f\xe8\x43\x9e\xea\xfe\xe2\x14\xf4\x27\x97\xa3\x92\x25\x59\x36\xe9\x59\xfc\x7f\xf9\xed\xdd\x4f\xf5\x0d\x50\xde\x54\x48\xb6\x66\xf8\xb7\x83\xe3\xa6\x6e\xdd\xb0\xca\xd9\x03\xdc\xe2\x88\x1f\x07\x56\x26\xd0\xa7\x90\xcf\xc4\xbf\xe4\xf6\x41\x97\xf0\xbf\x2a\x52\xd9\x55\xa5\xff\x7a\xae\x62\x05\x05\x9f\xc0\x5b\xba\x3a\x7f\xa9\x4f\x24\x55\x5f\xf2\xf2\x63\x70\x75\x1a\xd4\xb9\x38\xdc\x7f\xb2\x23\x4b\xa2\x22\xe6\x34\xc3\xf0\x3b\xb5\xc5\x75\x88\x14\xf9\x60\xef\x3f\x4b\x59\x43\xbf\x91\x36\xaa\x7b\xa3\x83\x9f\x26\x09\xc2\xd0\x3a\x93\xef\xbc\x7e\x9e\x26\xc9\xb9\xf4\x13\xa0\x27\xd8\x29\xf3\x8b\x4a\x3f\x6f\xc9\x4e\xf5\x35\x01\x3e\x85\xf3\x74\x55\xcc\xc7\x6a\x0c\xd8\x9a\xc4\xd3\x0b\xf9\xa3\x57\x92\xdc\xbe\xb5\x57\xe8\x5b\x64\x0e\xaf\xc7\x58\x3c\x9e\xa0\xf2\x40\x07\x76\xff\x74\xc9\xcb\xd3\xe0\x12\x55\x8c\xd9\xb4\x14\x47\x3b\xf0\x0d\x86\xb7\x14\x17\xd3\xcb\xcb\x39\xe3\xe9\x97\x38\xcf\x52\x8c\xd5\xaf\x74\x78\x93\x3c\xfe\x12\x94\x7c\xf1\x53\xc0\x7f\x88\x93\xb2\xa3\xd4\x29\x64\xac\x76\xaa\xd2\xf9\x44\xc6\xf1\xa9\x67\x1f\x98\x05\xf4\x3f\x01\xa4\xf4\x65\xb4\x58\x56\xfa\xf9\xb3\x74\xe6\x48\x17\x86\xca\xb3\x99\xad\x35\x37\x7d\x35\x93\x6a\xf9\x28\x19\xc8\xc1\xfa\xc6\x86\x3b\x0f\xb1\x0a\x9b\x25\x21\xea\x40\xcf\x2f\x0c\x7d\xca\x74\x48\xee\x3b\xc4\x28\xf3\xfc\x6b\xcc\x0c\xb6\xba\xca\x96\xf1\x23\xf0\xcd\x1f\x6a\x7f\x08\x26\xb5\xd7\x6b\xfb\xe8\xc6\xf6\x0f\x7c\xa3\x0d\xd0\xfd\xf1\xcf\xb3\xf7\x1b\xdf\xd8\x7f\xeb\x77\x97\x3a\xda\x39\x4e\x4c\xbd\xc5\xdf\xf3\xd5\xac\x1b\x3d\x3d\x0c\x8c\xbf\x0d\x9f\x89\x54\xba\x5c\x74\x76\xd5\xda\x8a\xd6\xe1\xa6\x21\xa5\x57\xae\x1d\xfa\xce\xd3\x3b\xec\x63\x8d\xc1\x7b\xdb\x5b\xf5\x9d\xa4\x1d\xe5\xbe\x6e\xd2\x77\xee\xa6\xf9\x35\x06\xed\x36\xb5\xea\xdb\x48\xf0\xa1\x53\x3f\xc5\x6b\x36\xbb\xc6\x00\x75\x1b\xab\x81\xb0\x07\x4e\x6f\xc0\x2d\x64\xbd\x99\xf9\xf6\x5d\xb4\xbd\xc6\x18\xed\x86\x56\x03\x66\x1f\x7d\xe6\xa5\xc1\xb8\x61\xa0\xbb\x77\xd1\xf6\x1a\x03\xb5\x1b\x5a\x0d\x98\xa7\x83\xc1\x29\x9f\xd5\xd3\xea\xd3\x15\x39\xf1\xb3\xc1\x60\x5a\xc6\xc9\x00\x02\x1c\xfd\x52\xc6\x49\x3d\x1a\x77\x9e\xac\xd6\xc5\x73\xd9\xc5\xeb\xa0\x0c\x16\xf4\xf0\x6c\xb5\x1e\xbe\x97\x3d\x7c\xc8\x92\x20\x6f\xee\x02\x7d\xca\x3f\xb0\x83\x65\x31\x15\x9e\xb0\x27\x1d\xd2\x5f\x5f\x13\x93\x28\xed\xc5\xcc\x78\x02\x8f\xd9\x21\xdb\x39\x60\x31\xfb\xab\x39\x11\x4b\x9f\xa1\x07\x2c\x7e\xfc\xb8\x23\x5d\x8b\xeb\xeb\x28\x5d\xea\x2c\x3e\x3f\xa8\x78\x14\x97\xd7\x50\xb7\x71\x2a\x8e\x55\x94\x5f\xf1\xaf\xd2\x51\x96\x32\x1a\xc3\x5c\xe2\x5c\xfc\x46\xeb\x18\xd0\xe5\x1a\xbb\xb1\x24\x9c\x32\x3b\xca\xd2\x62\x3a\x16\x32\xd5\xcb\x3c\x0f\xe6\xed\x20\xcf\x15\x3c\x90\xd0\x8b\x0b\x93\x51\xc1\xc5\x36\xf8\x57\xd9\x65\x87\x4c\x17\x92\xe8\xe8\x28\x2c\xe5\x2e\x7e\x44\x85\xb3\xf8\x1c\x90\x93\x03\x5a\x6e\x8c\x99\x61\xbe\x4b\x9c\xb4\xcb\x54\x84\x63\x98\x67\x63\x00\x42\x3a\x43\xd7\x7f\xe8\x5d\x36\x2f\x79\x11\x07\xe9\xdf\x63\x7e\xf5\x2a\x9b\x9d\x8c\x82\x09\xba\x07\xba\x1d\x37\xeb\x05\xbd\x42\x54\x85\xc0\x2b\xb3\xfe\x2a\xf5\xf1\xbe\x5d\x88\xa6\xf3\x35\xeb\xcb\x80\x2c\x6b\xb5\x31\xe2\xf1\xe5\xa8\x5c\xa3\x91\x07\xca\xca\x7c\x22\xd6\xd8\x5d\xa2\x37\x5c\x17\xbf\xe1\xba\x08\x26\x21\xda\xd7\x6c\x89\x04\x75\x5f\xb3\x25\x1a\xdf\x7f\xad\x86\x54\x70\xf2\x75\xe7\xfe\x81\x72\x60\xad\x5c\x0a\xc2\x81\x0f\xe9\x60\xa5\xb6\x89\xfb\x3e\xef\xb2\xed\x56\x49\xed\x1c\x54\x37\x18\x19\xbd\xe4\xf9\x4a\xdd\xc2\x9d\xba\x39\xab\xae\x07\xf8\xea\x33\xb3\xd2\x9a\x91\x5e\x0b\x81\xd2\x86\xc3\x82\xaf\xb3\xa0\x21\x6e\x43\x56\xc4\x62\x03\x58\x1d\x0d\xed\xb3\x56\x99\x4d\x20\x4a\x20\x1f\x42\xd8\x36\x78\x9f\x21\x7e\x5c\x64\x65\x99\x41\x18\xc1\x38\x2d\xe2\x88\x8b\x5f\xd9\xb4\x54\x3f\x31\xf1\x9d\xac\x85\x5f\x1f\x55\x5d\xfc\x3c\xc5\x96\xf1\xe3\x95\xd3\xdc\x69\x36\xb1\x2b\x63\x01\x3b\xed\x34\x9b\x38\x6d\x62\x29\x27\x11\xee\x7b\xcd\xe7\x9b\x14\xe2\x1e\x72\xfc\x27\xe4\xe2\xf8\xdf\x42\xb4\x13\x37\x97\xdf\x9a\x70\xc0\x71\xd8\xf1\x70\x69\x81\x9a\xce\x78\x16\xf1\xce\x4a\x24\x27\x6a\xca\x91\x0b\x11\xf6\xe7\x60\xbc\xda\x9a\x41\xd2\x85\x76\xb2\xb4\xe4\xe9\x6a\x94\xbb\x1e\x02\x95\x13\xd2\x55\xb9\xc6\x79\x07\xac\xd9\x49\x70\x14\x15\xa2\xe0\x2b\x59\x90\xfb\xba\xd0\x25\x2f\xdf\x05\x17\xa0\x62\xa7\x8a\x29\x48\xc3\x70\x05\xc6\x98\x47\x85\x13\x44\xa7\xb0\xe8\xbf\x4b\xaa\xfe\x35\xbb\xd3\xd9\x3a\x05\xae\x55\xd0\x16\x08\xfb\xb9\xfd\xe1\xbb\x2d\x23\x27\x68\x47\xb4\x1d\xf6\x42\x42\xd3\x77\x42\x37\x68\xd3\x9d\x15\x95\x1b\xed\x4e\x5b\x43\xde\x71\xb4\x73\x3a\xa3\x0d\x43\xe9\xb8\x71\xf1\x20\xf5\x80\xa2\xf6\x35\x4f\xca\x00\x76\x36\x07\xbf\x26\xa3\x6d\x36\xd1\xae\xde\x07\x0d\xce\x65\xe8\x29\x15\x59\xfe\x36\xe7\x97\xb3\x87\xa3\x87\x6c\xeb\x11\x1b\x07\xe5\xe8\x44\x34\xf3\x68\xeb\xbc\xd3\x56\x5d\x40\x24\x43\xd5\x33\x0c\x05\x69\x86\x00\xac\xcc\xef\xdb\xf0\x23\xb8\x28\x6a\x2a\x77\x19\x3a\xa5\x32\x98\x00\xa8\x1f\x91\xd6\x0c\x56\xd0\xdd\xb0\x10\x3f\x82\xa4\x42\x79\x95\x4c\xc4\xf4\x07\xf4\x81\x0c\xbf\xbb\x2c\x28\xcb\x9c\x50\xa5\xda\x1f\xe0\x82\x53\x15\xee\xa9\x54\x1d\x6f\x15\x77\x68\xbb\x90\x4c\xd4\xc1\x41\x61\x75\xd8\x45\x30\xad\xab\x2f\x65\x25\x7f\xb1\x0b\xe9\x64\x85\xc6\x50\x74\x24\x5b\xef\x85\xba\x83\x70\x4e\x93\xe7\x2a\x99\x88\x76\x24\x9f\xa4\x6a\x00\x8d\xe4\x46\x0a\x92\x54\x13\x2c\x55\x4d\x0e\x29\x47\x08\x4d\x16\xd3\xd3\x69\x0a\xa9\x24\x33\xe2\x2c\xfc\xfc\x6b\x5c\xd0\x32\x3a\x4d\x2f\xed\x5c\xc1\xd4\xa6\x63\x79\x4c\x01\xee\xb0\x2d\xb6\xeb\x25\xb3\x25\x96\xc3\x81\xbd\x1a\x48\xf5\x1f\x0e\xd9\x36\x7b\xc1\x76\x58\x9f\x6d\xee\x1c\x50\x4e\xa3\x47\x06\x91\x19\xd4\x78\xf0\x41\x24\x92\x0b\x89\xd9\x20\x38\x86\x21\xa4\xc3\x43\x7b\xd3\xd5\x66\x78\xb4\x5d\x82\xe3\xc7\x8a\xe0\x91\x5a\xf0\x7e\x93\xf6\x44\x30\x66\x85\xc6\xf1\x75\x29\x36\x76\x6f\x87\x74\xf1\x35\x77\xf7\xdd\x72\xfd\xf1\x85\x3d\xdd\x72\x60\x02\x93\x34\x97\xcc\xd3\x5f\x71\x9e\x4c\x6e\x9f\x7d\xa7\x3f\x34\x1d\x01\x4e\x3f\xc8\x48\xd5\x0b\x79\x9e\x4f\xa3\x72\xf6\x90\x03\xd3\x03\xb1\xfc\x34\x3b\x52\x42\x3b\x32\xbf\x70\xd6\x65\xe1\xbc\x2b\xe9\xb5\x4b\x46\xad\x49\x8c\xa7\xd1\x1f\x02\x00\x7b\xcc\xda\x06\x3b\x8a\xa2\x3b\xec\x11\x43\xdf\x91\x92\xd9\x05\xe5\x88\x1d\xb2\xd6\xfb\x96\x98\x1b\x8d\xad\xde\x8c\x3d\x66\xad\xae\x93\x38\x17\x89\xff\x5f\x2a\xe6\xec\xa5\xc8\xca\xd5\xb2\xc4\x92\xe4\x73\xbb\xbb\x03\x49\x16\x04\xdb\xac\xcf\x76\x3a\x90\x8f\x8d\x40\x08\x26\x89\x1e\xd2\xa3\x4e\x9a\x2b\x28\xe3\x68\xe5\x2d\x2b\x06\xe4\x4d\xd3\xf8\x1f\x53\xfe\x36\x42\xa4\xb5\x72\x1e\x8e\x82\xbc\x2c\x36\x73\xd8\x19\x36\x93\x38\xe5\x9b\x2d\x6b\xc7\xb9\x85\xa6\xbb\x17\xf4\xf0\xe9\xe3\x1b\x94\xb5\xda\x40\xd5\xad\x92\xcf\x54\xf0\x06\xa5\x72\x83\x88\x6d\xb0\xdd\x74\xb5\x91\x43\x94\x8d\xe3\x34\x48\xcb\x57\x41\xc1\x05\x1c\x7d\x14\xbe\xf3\x20\x69\x55\x76\x89\x26\xf9\xd1\xaf\xb8\x6d\x7b\x46\x7b\x11\xe4\x9b\x40\x27\xad\xae\x69\x1a\xef\x64\x6f\xa4\x99\xc0\xda\xa3\x67\x70\x7d\x59\xe8\x21\x40\x84\x01\xf9\x7b\x9d\xc6\x5b\x82\x60\x5b\x5d\xf6\x95\xc5\x51\x9f\xc5\x51\x97\x45\x7d\x24\xe2\x1b\x1c\xc1\x1d\x0e\x40\x4c\xe0\x07\xe8\x4e\xa6\x7c\x65\xb3\x24\x4e\x3f\xff\x2d\xe7\xc3\x3e\x6b\xfd\xa7\xa0\xd5\x38\x62\x37\xc6\x76\xfc\x82\x27\x08\xc4\x03\xc6\x3a\x96\xe0\xf6\x52\x4c\xfa\xf1\x10\x16\xb6\x4f\x3e\xae\xe4\x57\x64\x65\x2d\x6f\x4c\x1a\x45\x8d\x89\x47\xca\x20\x12\xcd\xc4\x12\x66\xfe\xf7\x88\x17\x9a\xe3\x8f\x63\x5d\xa6\x6d\xed\xa8\x46\x14\x06\xb9\xc1\xbb\x47\xab\x93\x3a\xb5\x21\x1b\x54\x18\xef\xbd\x32\x72\x8a\xb3\xc7\x72\x5a\xbb\x7a\x54\xc4\x8a\x6d\x20\xe6\xac\x02\x5c\x6f\x46\x4a\xcc\xbd\x25\xe6\xb6\x39\xb2\xe2\x43\xb3\x3e\x1b\xe8\xca\xf3\x3e\x1b\xe8\xf9\x16\xeb\xe0\x65\x1a\x8e\xb2\x5c\x14\x11\x12\x52\x38\x63\x2f\x58\x0b\xd0\xdb\x62\x7d\xa9\x34\x50\x82\x31\xcf\xc1\x79\x82\xaa\xd1\x1a\xc7\x51\x94\xf0\x16\xf2\x17\xbd\xad\x57\x91\x2f\x55\x0e\xce\x19\x89\x80\x17\x52\xf0\x42\x2f\x78\xaa\xb3\x5b\x02\x03\x22\xe7\x32\xd2\xe6\x83\x1a\x9a\xd8\xbd\xe7\xdd\xdd\x43\x01\xde\xe9\xdf\x35\xf3\xef\x9d\xfc\x5d\x39\xfb\x16\x72\x67\x7d\x26\x6b\xcd\xfb\x4c\xa2\xb5\x1e\xa9\x0d\x28\xbd\xf1\xb1\x3c\xdd\x77\x03\xdb\xb3\xcb\x7c\x53\xd6\x47\x39\x9f\x85\x3b\x95\xa8\xe9\x0c\x6e\x24\x48\x06\x7c\xab\x4c\xbc\x6a\x20\xb9\x98\x60\x04\x51\x3c\x68\xc8\x62\xce\x21\xc3\xbb\x1c\xca\x6c\xd2\xb0\x16\x84\xb4\x84\x00\x6d\xb1\x5d\xb2\x2c\xe6\xae\x30\xbf\xd2\x2a\x11\xeb\x79\xe1\x7a\x95\xaa\xce\x55\x60\x7c\xac\x10\xf1\xf8\x0e\x80\x45\x36\xb4\x10\x5c\x50\xd5\x36\x01\xbb\xe9\x00\x61\x43\x4a\x86\x60\x41\x77\x27\xac\x0f\xd5\xc7\xcb\x60\xf2\xf1\x4a\x40\x22\x8a\xd6\x06\x93\x68\xaf\x9b\x61\xfd\xc3\x61\xfc\xb8\x34\x42\xff\xc0\x59\x37\xfa\xfe\xd5\xd6\xd0\x37\x5b\x3a\xd6\x5d\xc4\x5a\xeb\xfd\x9b\x31\x27\xfb\xba\x64\x05\x6a\x5d\x0c\xe7\x02\x82\xbd\x15\x6e\xf5\x95\xcd\x1a\x24\xbb\x18\xe2\x46\xaa\x5d\x81\x16\xd6\xe4\x04\xcb\x10\xc3\x02\x24\xdf\x82\x16\xe8\x1d\xd8\xfa\x8c\x61\x19\xd8\x1b\xd1\x5d\x03\xf9\x4a\xd6\xa3\xed\x8e\x1e\x71\x87\x6d\x6c\x28\x63\x9a\xdb\xaa\x4a\x86\x20\x89\xc6\x85\x74\x0d\x04\x12\xa8\x6a\xb7\x37\x83\x77\x6a\xab\x35\x7c\x29\x1b\xfe\xc0\xf3\x10\x1d\xf7\xdb\x2d\xdf\x1b\xd0\xf3\x7b\x03\x7a\xde\x71\x2f\x73\x1c\x22\x5a\xad\xd3\x0b\xe8\xf4\x92\x97\xb2\xd7\xbf\xc3\x9d\x94\x83\xaf\x2e\x52\x68\xc7\xa1\xcc\xfb\xeb\x71\xde\x95\x64\xdf\xb9\x13\x3a\xaf\x1c\x3e\xaa\xfb\x46\xcd\x2e\xbc\xee\xa9\x24\x2e\xe0\xec\x45\x0f\x21\x32\xa9\x2d\xe5\x76\xcb\x0f\xd8\xdd\x51\xa4\xd1\xad\x48\xb5\x90\xee\x7f\x95\x13\x4f\xed\xa1\x46\xcf\x42\xfd\xc5\xea\xc2\x18\xf5\xf2\xaa\xda\xe4\xe3\xb7\x56\xde\x41\xea\x7f\xd1\x8b\xab\x89\x7d\x67\xe5\xbb\xdb\xaa\xd6\x72\x1e\xa0\xb4\x5a\xac\x5f\x29\x85\x71\x55\x21\xf2\xba\xc2\xc8\xf5\xf5\x6a\xd7\xbd\xf2\x85\xcc\xc6\xc6\x6a\xd5\xcd\x3d\xf1\xc6\x06\xfb\x6e\x21\x5d\x68\x1d\xe3\xd9\xc3\xb8\xf8\x7b\x90\xc4\x91\xd4\x2d\x3e\x14\x87\x7a\x44\x28\x36\xb5\xfa\xad\xb2\x6a\xc6\x61\x43\x2a\x9c\xaa\xde\x51\xee\x06\x58\xa7\x97\xdb\x34\x1a\x26\x59\xca\xab\x4d\x62\x88\xf7\x42\x7b\xb3\x58\xef\x8e\xbd\x06\x4e\x99\xdc\xa6\x5d\xa9\x3b\x85\xc2\x52\xc6\xba\x7c\xe0\xc0\x31\x32\x70\x6c\x18\x54\x36\x28\xf3\x97\x51\xfe\xf8\x4c\x8e\xcf\x1e\x7e\xd6\xdc\x17\x3d\xba\xc2\x1b\xb4\x97\x65\x99\xc7\x17\xd3\x12\xc2\x8f\x9c\x77\x74\x8f\xda\xa9\x07\x01\x5c\x6c\x9c\xf5\xf7\x8c\x62\xb9\xd4\x5d\x09\x56\xf3\xe0\xfa\xce\x41\x60\xf5\x02\x7d\xe2\xb9\x3b\xb7\x10\xab\x1a\x7d\x29\x51\x63\xc1\xfb\xa2\x51\xd9\xdd\x5f\xa4\x13\xba\xd3\x1b\x9a\x25\xec\xce\xcf\x1e\x06\x30\x43\xca\x0c\xfe\xd1\xd6\xb9\x7b\xa3\xe3\x72\xbb\x35\xef\x68\xea\x2e\x66\xf4\xbd\x91\x85\x5e\xb9\x21\xab\x9b\x07\x7c\x3c\x07\x08\xeb\x45\x71\x31\x49\x82\xb9\x64\xc0\x2d\x48\x6c\x1d\xa8\x4c\xdb\x94\x87\x7e\xaa\x22\x4e\x20\x65\xfc\xad\x2c\x22\x83\xbc\xe0\x7f\xd7\x9b\x94\xde\xcc\x68\xba\xbb\xa7\x85\x66\x3b\x73\x6e\x18\x64\xa2\x56\xb4\x05\x52\x7f\x8f\xe9\x01\xbd\x01\xb0\x2e\x0a\x30\xbf\xf1\x9a\x00\x8b\xb8\x36\x08\xc6\xa8\x28\xd7\x49\xea\x96\x42\xa6\x5b\xd7\x13\xf6\x85\x07\x96\x58\x78\xdd\x21\xb5\x91\xd5\xcb\x0e\x83\x07\x4b\xdf\x88\x49\x46\xab\x9d\x4d\x74\x62\x99\x4d\xf4\x1d\x13\x1f\x9a\xad\x59\x7c\xb8\xda\x49\xcc\xf1\xeb\x26\x31\x0f\x3f\x7d\xf6\x18\x6a\x23\x37\xd6\x18\xcb\xee\x21\x4b\x0b\x42\x28\xb9\x0a\xb6\x75\x77\x6d\x4a\xd9\x94\xfa\x42\xb8\xbb\xc6\x67\x77\x0c\xec\xbc\xea\x6d\xe3\x2b\x6a\xe0\x51\xfb\xae\x0c\xdf\x71\x06\xb5\x09\xbb\x9c\xc3\x1b\xf9\xd4\xdd\x58\x60\xdc\x1d\x64\x65\x36\xb9\xe3\xb1\x0a\xfa\xac\x19\xae\x20\x69\x31\x60\x20\xe1\xe5\xc6\x7c\x2b\xa1\xe6\x4f\x30\xbf\x4d\xb3\xbb\x6d\x46\xb9\xed\x68\x00\xee\x0e\x94\xf0\xae\xc7\x16\x56\x07\xa7\xb8\x08\x5e\xcf\xc1\xab\x04\xc3\xc8\xa9\x39\x3f\xe1\xdc\xd7\xd7\x92\xc5\x83\x2b\x30\x87\x69\xf7\x0d\xfb\xf6\x96\xb3\x9e\x2d\x50\xc6\x4c\x0b\x59\x2f\x12\x28\x5b\xbe\xbe\x56\x9c\x5e\xfc\xb2\xea\x68\xb6\xd7\x37\x3f\x7d\xaa\x25\x7a\x20\x73\xb0\x61\xe5\x55\x8e\xbb\xe4\x1c\x0a\xfb\x64\xe5\x3e\xcc\xa4\xb6\xa5\x74\x65\x75\x03\xe7\x20\x34\x14\x5d\x20\xf2\x4b\x99\xf5\x10\x9d\xcf\xb9\x4f\xc2\xd7\x10\x9b\xde\x21\x58\x5f\xd9\x67\x3e\xef\xb3\x16\xf4\xb3\x19\x8f\x27\x49\x1c\xc6\x65\xab\x6b\x5e\x46\xa8\xe3\xda\x4d\xe7\x0e\x68\x9b\x1b\x52\x3c\xce\x4f\x4a\xc5\x5c\x00\x13\x7f\xe0\xe0\xba\xea\x35\x05\xa2\xfb\xb6\x43\x6d\x3c\x76\xc9\x69\x6e\x3c\xed\x2e\x3a\x12\x7d\x73\x04\x69\x23\x77\x9b\x7a\x6b\xa9\x61\x55\x5d\xe7\x7d\x0d\xcc\xc8\xf4\x1e\xd0\xf5\x89\xa7\x66\xf8\xd2\x43\xa8\xb5\xe4\x71\x61\xda\x86\xca\x47\x41\x92\xbc\x9a\x7f\x08\x72\x27\xea\x40\x35\xb7\x3d\x81\x7f\xa4\xad\xb2\xc5\x0a\x40\x9e\xfe\xcc\xc3\xcf\x90\xa9\x18\x89\xfb\x28\x93\xfd\xc0\x76\xc5\x06\x60\x9e\x61\xee\x9e\xdb\xde\xa1\xd8\x0b\x3b\xb3\x6f\x7b\xab\xfc\x8e\x40\x20\x68\x91\x7e\x6b\xbd\x91\xe8\xc1\x85\x65\x63\xc3\x2e\xdb\xcc\xb5\xe4\x78\x88\x62\xca\xd3\x8d\xbe\x49\xc7\x4c\x73\xf8\xb0\xcf\x1c\xa6\x66\x47\xd7\xe0\x33\x9c\xa3\xa3\x51\x9c\x60\x07\x2b\x9e\xd6\xd1\xfc\x7d\x18\xa7\xd1\x4b\x31\x4d\xe2\x44\x24\x37\x46\xa5\x43\x43\x75\x5e\xa7\x37\x0e\x26\x6d\xf3\x96\x16\xb2\xbb\x2c\x4e\x23\xee\x6e\x19\x6b\x29\x52\xb0\x59\xb5\x07\x57\x68\x56\x1c\xf0\x29\xb2\xd4\x4e\x47\xe9\x17\x6c\xd8\x04\x5c\xb8\xd5\x21\x09\x1b\x5d\xc3\x77\xce\xcc\x3a\xd0\x3b\x98\xa5\xd3\xa9\x16\x86\x22\x4e\xb2\xb9\x55\x28\xa3\x5b\x0b\xb2\x75\xe0\x3f\xb3\xda\x3c\xef\x85\x59\x1a\x06\x65\xdb\xf3\x8e\xd7\x81\xab\x23\x95\xae\xf2\x60\x6b\x1f\x5e\xe9\xa7\x3a\xfb\x7a\x97\x6a\x35\x11\x83\x1a\xa8\x77\xdb\x4a\x47\x20\xe3\x1f\x59\x51\x8f\xb4\x03\x13\x88\x28\xc7\x0e\x19\xf2\x9c\x4e\x25\x66\xc8\xd3\x3f\x93\x43\x14\x0c\xa2\x9d\x25\x0d\xd1\xc3\x77\x77\x9e\xff\xf1\xa1\xd3\x6d\x48\x85\xc0\xf0\xe7\x08\xda\xe7\xc2\x75\x79\x2f\x70\xdd\x3e\xbe\xa8\x0b\xd7\x70\x9d\xd8\xa2\xd8\x56\x12\x5c\xd4\x47\xa7\x7b\x7e\xe7\x31\x55\x57\x08\x2c\x4a\xe0\xbc\xaf\xb0\x8e\xb7\x8f\x7b\x6f\x43\xe5\x8b\xe9\x78\xcb\x70\xff\xe1\xf4\x82\x8f\x78\x12\x37\xc4\x9d\x7e\x7e\xe7\x61\x5e\xeb\x42\xd3\xdd\x06\x5a\x32\x27\xd5\x68\x84\xfb\xcf\xfe\x4c\x6c\x51\xca\xa6\x45\x96\x97\xaf\xe6\x0d\x3e\x37\x56\xf4\xc0\x52\xe9\xe0\x2e\x9c\x44\xa9\xb6\xfe\xed\x22\x6a\x1d\x1f\x4e\xcd\x01\x94\xf7\xb6\x57\x74\x2e\xe4\xb6\x7f\x17\x3e\xa2\x64\x53\xab\x3a\x73\xba\x57\x9f\x58\x6e\xf3\x6b\xb9\x8c\xba\x0b\x9f\x58\x7b\xaa\x15\x15\x96\xa5\x61\xc8\x2b\xae\x6a\x4f\x17\x6b\x79\x91\xaa\xb4\xb6\xaa\xbb\xa7\x7b\xf1\x06\xb6\x7f\x07\xde\xc0\xf6\xd7\xf3\x06\xf6\xf4\x1e\xbd\x81\x3d\xbd\x2b\x6f\x60\x4f\xef\xc0\x1b\xd8\xb3\x7b\xf4\x06\xf6\xec\xae\xbc\x81\x3d\xbb\x03\x6f\x60\xcf\x25\x41\x14\xe3\x2c\x2b\x47\xf5\x4b\x74\xef\x6e\x9a\x5f\x63\xb4\x6e\x53\x2b\x3b\xf8\x0a\xb3\xb4\x0c\xe2\x94\xe7\x83\x93\x69\x3e\x0c\x1a\xc2\x50\x7f\xbf\xea\xb6\xbb\x4d\x7b\x79\x17\xcc\x79\xfd\x61\x6f\xe7\xfb\x15\xfb\xd8\x11\x7d\x8c\x27\x59\xca\xd3\x72\x70\x9a\x65\x49\xd9\x10\xcc\x7a\x67\x55\xff\x9a\x3b\xbb\xb4\x9b\x77\xfc\x92\xa7\x51\xc3\x58\x56\x74\xbb\xb6\xf3\x64\x30\x00\x3f\x4e\x83\xa3\x69\xfe\xa5\x21\xa6\xff\x8a\x8e\xe3\x76\xf6\x74\xfb\x79\x56\x34\xf8\x74\xfb\x7e\x45\x3a\xdf\xd9\x57\x1d\x9c\x40\x28\xdf\x7a\x14\xed\xaf\xc8\x1e\x77\x9e\xaa\x1e\x5e\x67\xf5\x5b\xcb\xb3\x55\x5b\x7f\xa6\x5a\xff\xc8\xc3\x12\x6e\x88\xea\x27\x61\x45\xbe\xb7\xf3\xfc\xfe\x3d\x04\xee\x88\xf5\xad\x8c\x5c\x06\xda\xdc\xe5\xe5\x2c\xae\xef\x6b\x6f\x7b\x55\x37\xa4\xdb\xb4\xb3\x57\xf9\xb4\x68\x60\xa0\xdf\xaf\xb8\xce\x77\x77\xd4\xf5\xcd\xf1\xfb\x66\x9c\xed\xee\xac\x48\xbc\xbb\xbb\xf7\xee\x57\x71\xf7\x89\xec\xe2\x68\x14\xe4\x0b\xe6\x7e\x77\x45\xfa\xda\xdd\xbb\xa5\xf3\xc6\x55\xfa\xd8\x57\x7d\x4c\x73\xfe\x11\x94\x97\x0d\x4b\x7d\xc5\x3e\x9e\xca\x3e\x20\xea\x58\xfd\x18\xbe\xdf\xdb\x53\x07\xfb\x7f\xfb\xa0\x94\x28\xc0\x3b\xa8\x23\x21\x16\xb9\x21\xac\x69\x5c\x0b\xe2\x1c\x3c\xe6\x85\xc4\x89\x32\x9e\xac\xb8\xa4\x44\xd4\x28\xf3\xa0\x0a\x5a\x22\x5e\x84\x79\x3c\x29\x33\x6d\x02\x05\x68\x31\xc9\x3d\xe3\x66\x1c\xec\xc2\x7c\xe9\x62\x8e\x82\xa4\xe0\x56\xbd\x30\x4b\x87\xf1\xe5\x54\xd5\x84\x7b\x24\x40\xea\x43\xb8\x25\x7d\x28\xb0\x6d\x8a\x77\x68\xd5\xab\x3c\x2e\xad\x6a\x7e\xc7\xe8\x6a\xe4\xa4\x26\x04\x91\x26\xad\x1e\x50\x84\x1b\x8c\x1e\x65\x69\x51\xe6\x53\xb1\xd9\x01\xe2\xca\x4c\x5e\xaa\x61\xcc\xcd\x0f\x0a\x95\xf2\x7e\x5f\x66\x77\xaa\xc8\x27\x0d\x19\x2a\xa1\x4d\x76\x70\xcc\x56\xbb\x4d\xad\xd8\x20\x1c\x28\xd0\x49\x89\x03\xf0\x9b\xde\xb6\x7d\xb3\xa3\xe3\xfc\x5f\x31\x3c\x01\x69\x39\xbb\xf8\x1d\x08\xb3\x50\xf3\x8d\x38\x63\x87\xec\xeb\xcd\x01\xa5\x94\x18\x7c\xb7\xab\x31\x8b\x1a\x3d\xb8\x05\x3a\x1e\xb6\xe3\x0e\x3c\x4f\xed\xc0\x75\x6e\x9c\xaa\x69\xfc\x6e\xa9\xc5\x01\x00\xc4\x1d\x5a\x59\xae\x0f\xf0\x79\x9a\x5d\xfc\x6e\xfb\x3c\xd5\x8b\xe2\x7f\x89\x5f\x56\x33\x08\x87\x78\xd5\xcc\x98\x98\xe7\x0a\xf3\x64\x2e\xfc\x74\x6f\xaa\x7e\x55\x16\x07\x68\xd1\x5f\x0d\x09\xc0\xe8\x2a\x54\x69\x6a\x79\xe1\x37\xbb\xe9\x90\xc1\x88\x09\xb1\x42\xae\x9b\x61\x67\x17\xbf\x3b\xf3\x02\x27\xb8\xa3\x20\x49\x8e\x46\x3c\xfc\xdc\x8e\x21\x14\xb8\x60\x85\x84\x5c\xd5\xc0\xbe\xd3\xd9\x4c\xfd\xc8\x86\x56\x41\xe0\x9d\x9e\x68\x87\x0f\x8f\x82\x34\xcd\x30\x6c\x18\x0b\xd0\x0e\x96\x05\x05\x09\x26\xfe\xb0\x8a\xed\x49\x56\x14\xf1\x45\xc2\x49\x07\x18\x46\xa3\x5d\xf0\x64\xd8\x85\xc6\x34\x68\x22\xc9\xee\xfd\xa3\x8a\x30\x22\x41\x80\x20\x66\xa3\xa0\x48\x5b\x25\xc4\x86\x62\x71\x1a\x97\x71\x90\xc4\x05\x8f\xd8\x26\x2b\xa6\x13\x9e\xb7\x3b\x56\x09\xd1\x03\x8f\x10\x34\x65\x7c\x2e\x46\xb0\xb1\xa1\xa3\x3e\xc2\xf7\xe1\xe1\x21\x7b\x88\xeb\xf7\xa1\xe0\xa4\x95\x3c\x33\x4a\xf6\x02\x93\xfb\x4c\x40\xec\x4c\x46\x9c\x8e\x78\x1e\x97\x45\xbb\x98\x5e\xc0\x1e\xd2\x45\xb0\xe0\xb7\x1a\xaa\x6c\xdc\x64\xc0\xf5\xbf\xe9\x02\x42\x78\xd8\x99\x32\x64\x88\x7f\x6a\x4e\x44\x59\xc6\x67\x93\x9c\x17\x85\x00\x63\x3c\x2d\x4a\xc6\x31\xf2\xdb\x05\xc7\xc0\xf8\x59\x4e\xe6\xaa\xcb\xc4\x5c\x3e\x64\x8f\x59\x05\x16\x40\x95\x82\xde\xf0\x15\x23\x12\xe0\x06\xd9\x26\x00\x5a\xe0\x52\x0e\xfc\x15\x23\xd3\xe3\xcc\xf7\xcd\x42\x31\xc8\xa1\x6b\x05\x43\x75\x3a\x0b\xc3\xb7\x78\x04\x99\x29\x96\x4e\x90\x2b\xe1\x2b\xb8\xe0\xbd\x08\xc2\xf1\x90\xbd\xf0\xa7\xd7\x4c\x90\x81\xad\x37\x18\xc0\x48\x40\x78\x32\x45\x0e\x2c\x3f\xcf\x95\x3f\xc1\xec\x8e\x3f\xbe\x7d\xf3\xf3\xe9\xe0\xfd\xcb\x0f\xd2\x1d\xe3\x4c\x1c\x1e\xfa\xec\x8c\xb8\x21\x2d\xb3\x49\x0b\x6c\xd6\xe7\x2a\xcf\xf6\x59\x7a\xae\xed\x53\xb2\x3c\xbe\x8c\xd3\xa3\x2c\xcb\xa3\x38\x0d\x4a\x31\x11\x60\xbb\xb8\x0d\xb6\x8b\xdb\xcc\xb8\x76\x48\x79\x2e\x24\x17\x0c\x43\x1d\x87\x41\x02\x92\xb2\xed\xda\xc1\x5f\xa6\x3d\xc8\xf9\xd0\xd8\xb0\x20\x4b\xe9\xb2\x41\xc9\xc7\x93\xae\x20\x6a\xb5\xcc\xa4\x29\xba\xb6\x0d\x09\xf2\x52\x3d\x25\xca\xf9\xb0\xa7\x13\x94\x4d\xc3\x4f\x79\x30\x19\x61\x37\x71\x12\xa9\x62\x76\xaa\x7e\xc2\x94\xf3\xe1\x7f\x71\x21\xb0\x9e\x22\xbd\x41\x59\x9d\xa0\x2d\x12\x9d\x12\xb4\x8a\xfb\x7a\x29\x98\xc5\x05\xbc\x60\xb2\xca\x69\x83\xf6\x59\x5c\x1c\x29\xc5\x44\xa1\x3a\xb4\x53\x8d\x81\xf7\x25\x4f\xa3\x23\xfd\x08\x0b\x8a\x5a\x89\xb6\x8b\x4c\x31\xab\xef\x83\x89\x2a\x69\x25\x6a\x1f\x75\xb6\xb5\x3f\x14\xa4\x69\xfa\x5d\x19\x31\xf9\x87\x42\xc4\xee\x1f\x27\xc2\x9d\xcf\x5f\xf3\x60\x82\x71\x6e\xda\x30\x87\xa2\x62\x58\x91\x68\x07\x7a\x98\xca\x7e\xc4\xb0\xaf\x9a\x16\xbb\x8c\x54\x92\x0e\x6b\x74\x83\x35\x75\xe8\x8b\x03\xe8\xc4\xd9\xb0\x04\x57\xef\xd6\x55\x56\x9d\x48\xc2\x2c\x31\xbe\x5b\xc3\xc6\x82\xad\xd5\xc1\x4f\x16\xb5\x7e\x81\xda\xbb\xb4\x19\x43\x1d\x24\x1d\x94\xa5\xb0\x03\x1c\x93\x81\xce\x5d\x23\x58\x16\xe0\xb5\x87\x20\x27\xf8\xa4\xc4\xa5\x0c\x25\x7a\x84\x4b\x4a\xf6\xfa\x9a\x14\x23\x6f\x9b\x54\x2b\xd3\x49\x14\x94\x1c\x62\xb0\x6d\xab\x74\x6c\xaa\x50\x0d\x53\xdf\x66\xb4\x53\xc1\x95\x55\xf5\x3e\xdb\x96\x95\x6f\xba\xb2\x3e\x66\x41\xc9\xe3\xa1\x24\xd8\xe2\x18\x5e\x53\xbf\x4c\xa3\x93\x32\x08\x3f\xff\x94\x67\xd3\x49\xd1\x26\x76\x79\x00\xa0\x74\xd1\xca\x1a\xfb\xd3\x80\xdf\x74\x28\xf6\xb0\x6b\xf0\x06\x07\x38\x7f\xbb\x94\x67\x39\x9f\xd6\x61\x81\x6b\xb9\x96\xe9\xd4\x98\x0d\xab\xdb\x9a\xd7\x3c\x09\xe6\x34\x40\x1f\xc2\x55\xe6\xf1\xe5\x25\xcf\x79\xf4\x72\x58\xf2\xfc\x7d\x36\x2d\xf8\xfb\xec\xcb\x22\x5f\xf3\xb5\xf7\x4a\xed\x4e\xbb\xb1\xdd\x2e\xf3\x41\xe5\x46\x14\x54\x77\xf9\x26\xd4\xe1\x8d\x0c\xb8\xf9\x88\xf1\x22\x89\xd3\x72\x33\x8a\x0b\x38\xbf\x31\xd0\x7a\x6f\xa5\xd9\x66\x14\x47\x9b\xe3\x6c\x9a\x96\x9b\x05\x2f\x37\x91\x54\x1e\x6d\x3d\x50\x15\x1f\xc1\xbf\x8f\x74\xa8\x33\x09\x70\x97\xe5\x10\xc0\x18\xcb\xab\xf8\xc3\xa1\x59\x26\xb8\x11\xf4\x64\x6d\x15\x62\x0d\xa7\xef\x46\x52\x05\x72\x39\x19\x5b\xae\xcc\xd8\xb4\xe0\x32\xa6\xbc\x0c\x0c\x0b\x8d\x2a\xdd\x3e\x74\xa5\xda\x53\x96\xda\xaa\xc1\x5f\x47\x59\x82\x61\xf5\x49\x31\x35\x0a\x7a\x7e\xaf\xe7\x62\x67\x5f\x2d\xa3\x3b\xad\x9e\x7e\x1d\x47\xef\x05\x7e\x5a\xd6\x93\x5d\x12\xcc\xab\x52\xb2\x4d\xe9\x05\xe4\xd8\xdb\x5f\xb0\xb6\x3b\xc0\x55\x7a\xf2\xe5\xd4\x3c\x0d\xdf\x46\x1d\xda\x2e\x46\xbf\xee\x05\x51\xf4\x2e\x2e\x4a\xb1\x89\xb7\x49\x94\xc7\x1b\x8b\x34\x6e\x8c\xe9\xa1\x33\xb8\x5f\xe3\x24\xf9\xc8\x43\x1e\x7f\x41\x1e\xb5\x78\x90\x6e\x8d\x76\xca\x67\xe5\x07\x9b\x9d\x2b\xd7\x5b\x72\x17\x33\x03\xe9\x12\xf0\x19\x8b\x82\x32\xd0\x2f\x8e\x7b\xe2\xcb\xce\x27\x76\xa6\x03\xff\x0b\x68\xfc\x53\x0f\xaa\x06\x9e\x17\x55\xf8\xa7\xdf\x55\x0d\x7c\x0f\xab\xf0\x2f\x09\xe6\xd9\x94\x94\xc1\x6f\xbb\x4c\x21\x78\xdd\xb1\xf2\x62\x35\xd0\xcf\xda\x54\xa2\x5d\x7a\x1c\xe4\x97\x31\x81\x1e\xbf\x0f\x2c\x24\x11\xae\x6d\x78\x75\x4f\xa5\x1e\x3c\x78\x60\x11\x92\xc6\x35\x60\x0b\x4e\x01\xf0\xe3\xfa\x9a\x99\x2c\x44\x87\xc8\xc3\x5f\x56\xa6\xc4\x84\xc8\x95\x3f\xad\x6c\x89\x04\x91\x2d\x7f\x5a\xd9\x74\xfc\xa2\x0c\xfd\xbe\xbe\x5e\xe2\xb9\xb5\x57\xd3\xa9\x5c\x1b\x14\xa3\x20\x49\xb2\xab\x37\xff\x98\x06\x09\xf2\x68\xd3\x33\xe2\xae\x2b\x71\xea\xac\x04\xcf\x26\xba\xcc\x1e\x6a\x28\xf7\xc0\x5d\x56\x05\x97\x65\x96\xdc\x33\xf5\x34\x3e\x66\x3b\xa4\xad\x9b\x2e\x5b\x7b\x07\xd5\x50\x2e\xb9\x8b\x3e\x66\x3b\xb0\x93\x52\x6e\x60\x1e\xa1\x2d\x9e\x22\xef\x85\xca\xd9\xc3\xb1\x7c\xda\x71\x24\x97\xa0\x77\x96\x8c\x75\xb5\x7e\x86\x5f\x9d\xa9\x51\x50\xfc\x94\x64\x17\x41\xf2\x1a\xd7\xff\x6a\xdc\xd1\x5e\x0a\xd6\x0c\x8a\x4e\x52\x7e\xf5\x8b\x59\x5a\x76\x97\x2f\x0c\xb2\x6c\xbc\xb9\x8d\x0c\x0a\x4a\x4d\xf0\x61\xaf\x70\xe4\x61\xf0\x82\xfb\x6d\x1a\x71\x70\xf4\x87\x2b\xd8\x4e\xf7\xd5\x7a\x93\x46\x9e\x3a\x2a\x95\x82\xb2\xb5\xc5\x5e\x67\x69\xab\x94\xb0\xb2\x8b\x7c\x5a\x8c\x1e\xb8\xb0\xba\x52\x24\x25\xdc\xdb\xad\x06\x41\x58\x14\x96\xbe\xf5\xd5\x75\xc6\xdc\x77\xbe\x29\xf9\x2f\xbb\xb0\x06\x0e\x5d\x5b\xe8\x32\x34\x4e\x26\xf5\x8e\x16\x99\xd5\x91\xbb\xe0\xec\x3e\xd6\x83\xd1\x59\x90\x0f\xc8\xdc\x06\x51\xc4\x70\x83\xb7\x78\xfd\x1d\xc9\x0c\x0b\x7c\x57\x2c\xb5\xc2\x56\x16\x3f\x60\x7c\x39\x1f\x0b\xd1\xd8\x33\xc4\xbb\x92\x8b\x9a\x9d\x85\xac\x39\x44\x04\x7f\x5d\x21\xeb\x97\x74\xbc\x9c\x10\x49\x0a\x7f\x4b\x39\x72\xf1\x28\x19\xd5\x53\x36\x1d\x56\x74\xe4\xee\xc3\x43\xd6\x52\x03\x6c\x79\xfa\x6c\xae\x5f\x8f\x69\x73\x2e\x11\x67\x81\x9f\x78\x89\x87\x0f\xa5\x13\x54\xc1\xa1\x83\x24\x61\xb3\xcd\x60\x16\x17\x2c\xcb\xd9\x1c\x7e\xe9\x5a\xf2\x44\xe2\x1e\x49\xf4\xdf\xbb\xa0\xe4\x45\x89\xa9\xd5\x4a\x27\x32\x00\xb4\x68\x12\xd4\x4c\xf8\x77\x3a\xe2\xa0\x3c\x85\xde\xbd\xbd\xc1\x5d\xc4\x0d\x63\x97\x4a\xdd\xf5\xb6\xe4\xe3\x02\x2a\x2a\xe5\x7b\x21\x6a\xc7\x25\x1f\xd7\xc3\x5a\x18\x5e\xa6\xba\x8d\xa1\x9d\x4b\x91\xc6\x23\x76\x31\x87\xfe\xdf\x46\x2c\x48\x23\x2c\xae\x97\x9e\x39\x8d\xe1\x83\xe1\x1b\x77\x0f\x83\xf6\xe0\x11\x30\xbe\x37\x62\x30\xdf\x1c\x25\xcd\x82\xe7\x31\x2f\xf0\x98\x16\xe0\x4e\xc4\xe2\x82\x05\x93\x49\x12\xf3\xe6\x2e\xf4\x86\x27\x41\xe6\x69\xb4\x46\x07\xee\x09\x50\xff\x1d\x51\x3a\x50\xe5\xb7\x1e\xf8\xd7\xe8\x25\x57\x1a\xb8\xda\x95\x69\x8a\x28\x87\x2a\x83\x9c\x0f\x77\x2b\xa7\x1d\x91\xf8\x5f\x9a\x20\x50\x2d\xb7\xdb\x53\x09\xb6\x04\xe0\x16\x23\xf5\x5c\x7d\x25\x28\x8a\x95\xc2\xd2\x14\xb4\xdb\x7b\x29\x15\x94\xba\x5b\x95\x60\x17\x73\xa8\x4e\x15\xb6\x93\x3d\x27\x1e\x49\x6a\xaa\x3c\x49\xab\x1e\xe8\x6c\x61\x08\xca\x37\xc9\x42\xae\x24\xa4\x2b\x54\x05\x21\xf7\xe9\x61\xf5\xd1\xa1\x29\x87\xd4\xff\xdf\x7c\xce\x0e\x0d\xb2\x1f\xb3\xd6\xdb\xa8\x75\x40\xf7\x26\xc1\x3c\x04\x9f\x28\xc9\x02\x14\xe4\xf8\xd2\xac\x5e\xd5\x20\x5f\xca\x79\x50\x8d\xf4\xbc\xc4\x7b\x44\x35\x65\x1d\xcf\x50\x50\x6d\xfc\xf5\xe6\xc0\x3e\x0e\x02\x50\x1b\x1b\x00\x9c\xba\x37\xb5\xd8\xac\xa9\x0b\x0c\xd7\x90\xf2\xab\xf9\xcb\x19\x2f\x14\x41\x7f\x85\x16\xfa\xf0\xff\xae\x43\x25\x7d\xe7\xbb\xab\xf1\xd9\xd7\xbf\xba\x06\xdf\x7d\xf3\xb3\x96\x90\xfa\xf4\x63\x91\x38\xd9\x6d\x10\x45\x2d\x01\x93\x1c\x72\x1c\x3a\xdf\xd8\x70\xc6\x70\x5b\x5c\x41\x25\x8d\xac\xca\xca\xeb\xb3\x65\x96\xdb\x1a\x88\xfc\x06\xc8\x33\x84\xa5\xee\xd2\x71\xf0\xae\x8e\xd1\xec\xbc\x8d\x5b\xaf\xd8\x74\x2f\xe6\x90\x99\x4d\x44\x6a\xa1\x93\xd5\x32\x33\xcd\x2c\xd8\x8b\x3d\x5b\x31\xd9\x61\xd4\x8e\x0a\x6b\xc1\xfc\x9d\x3a\x0b\x5a\x64\x7b\x7a\x94\xb5\x6f\xb1\x1d\x2f\x16\x03\x5c\x29\xa0\x8b\x97\x7d\x6c\x53\x4a\x23\x5d\xbc\xe0\x63\x9b\xb6\x4c\x52\xd7\x30\xb2\x31\xd5\x30\xea\xb0\x59\x1c\x41\xeb\x29\xab\x69\xc0\x2f\x29\xdc\x4e\x50\x58\x2c\x29\xac\x2d\x28\x2c\x96\x14\xd6\x14\x14\x6a\x25\x05\x9f\x94\xb0\x8c\x98\x80\x8c\x73\x09\x61\xc1\xe6\xb0\x62\x5f\x7b\x52\x11\x19\x04\xa3\xd9\x95\x0c\xa7\xc2\xf5\xf5\xdd\xde\x93\x1e\xf0\xe5\xc5\x3b\xf9\x93\xc6\x9d\xdc\x91\x39\x9e\x34\x88\x26\x6a\xe7\x34\xe5\x9a\x19\xba\x2e\x7a\x3b\xc9\xe0\xc9\x6d\x25\x83\x27\x0d\x92\x81\x56\xdf\xd6\x6b\x6f\x17\x3a\xd4\x24\x03\x3b\xb6\x43\x15\x90\x34\x67\xa2\xe2\x42\xdd\x28\x04\xc9\x52\x17\x54\x3e\x9b\xd5\xb3\x87\x33\xa5\x5e\xd3\x8d\x01\x8f\x90\xfe\x53\x60\x2c\x7a\x06\xa9\x84\xb0\xb5\xc5\xde\x24\xf1\x18\xcd\x00\xa2\xe9\x24\x89\xc3\xa0\xe4\x91\xc5\xef\x1c\x31\x02\xa4\x85\x9c\x47\xd3\x90\x13\xcf\x07\x39\x2f\xe0\x5e\x07\x70\x52\x55\xda\x0d\x20\xfd\xbf\x94\x4a\x1f\xbe\x7c\x3a\x7d\xc6\xa4\x65\x08\xad\xd0\x2b\x2b\x64\x86\xf3\x2b\xc9\x8c\x16\x95\xc9\x6e\x69\xd0\x0c\xbf\x0e\xca\xe0\xf8\x0b\xcf\x87\x49\x76\xe5\xd6\xab\x14\x70\x5b\x28\xc2\x20\xa9\x00\x06\x89\x07\xae\x2e\x4d\xb2\x44\x6b\x98\x67\x7a\x19\x9c\xbb\x6a\x42\xe9\xbf\x8f\x47\x52\xa1\x89\xeb\xda\xd2\xb7\x5d\xf2\xf2\x35\x2d\xe5\x17\x26\x9a\x05\x86\xde\x30\x4e\x4a\x9e\x93\x39\x13\xbc\xbc\xe3\xb4\xa1\x37\x70\x91\x59\x01\x1d\xce\x17\xf8\x79\x60\x55\xbb\xe9\x34\x2d\xd8\x8a\x5c\x51\xbb\x52\x6d\x19\xa3\x56\x17\x08\x2b\x16\x56\xa2\x85\x3c\x65\xeb\x47\x27\x04\x14\x1f\x48\x9d\x72\x20\xe7\xee\x98\x61\x12\xb2\x71\x10\xa7\x95\xa0\x7f\x04\x4a\xb5\x38\x5e\x2f\x2a\x49\xae\x31\x9d\xb2\x16\x60\x08\x9a\xa4\xd7\xea\x34\x68\x80\x56\x65\x09\xa9\xf2\x38\x8a\x40\x1c\x0f\x05\x86\x5e\xcd\xc5\x9a\x01\xb6\x60\x61\xae\xab\xd6\x53\x17\x16\x60\xc7\x81\xd4\x28\x6f\x64\x04\x1f\x1c\xe2\xbc\x25\x84\x63\xca\x75\xaa\xe3\x90\xe8\x55\xd8\x5b\xfd\x12\x3e\x84\xf1\x8c\x82\xe2\xb5\x6e\x0b\xc7\x01\xc3\xeb\x1c\x2c\x31\x63\x06\x8a\x17\x0a\xbf\x7d\xe9\x9e\xa6\x52\x7b\x6b\x8b\xfd\x0a\x97\xc9\x72\xa8\x28\x7d\x8e\x82\x82\xb2\xc9\x92\xcf\xca\x2e\x88\x12\x41\xc2\x30\xf0\x74\xc1\x82\x9c\xb3\x69\x21\x72\x33\x6d\x1e\x85\xec\xa3\x0a\xa2\x0f\xb2\xdb\x3f\x1f\x6e\x77\xda\xdb\x5d\xb1\x20\x3a\xac\x2f\xdb\x74\xd1\x41\x8e\x37\x9e\x69\xf4\x4d\xdb\xd6\x16\xe3\x7a\x6b\x30\x3a\x85\x2c\xd7\xc6\x7f\x7c\x3c\x29\xe7\x0c\x63\x1f\x37\x0c\x0d\x7e\x54\xb9\x0f\x4f\xcb\xdc\x43\xf7\x8c\x38\x9d\x11\x25\xe0\xa2\xb0\xd5\x5a\x5d\x0f\x8d\xfd\x54\xc9\xe3\xa6\x92\xe6\xc5\x11\xce\xaa\x17\x43\xe0\x72\x28\xcf\xb3\xfc\x55\x90\x17\xaf\xd7\x5d\xaf\x73\x0c\x0f\x15\xe4\x05\x1a\x61\x8a\x46\xf1\x22\xc2\xbb\x5e\x57\x63\xee\x6c\x79\x06\x0f\x18\x37\x85\x7a\xa3\x38\xe2\x3e\x2c\x12\xd6\xe1\x93\x30\xd4\x9f\xc0\xaa\x83\x2c\x3f\x78\x9a\x70\x9c\xd2\x9e\xbe\xdd\xf9\xf3\x31\x2d\x4b\xc0\x52\x36\xba\xd6\xd4\xb2\xeb\x6b\xb9\xbb\x03\xa9\x05\xd3\x32\x6b\x75\x7c\xb0\xf9\x18\xfb\xb7\xe6\xce\x64\xcd\x56\xc8\xd7\xde\x91\x0d\x31\x37\x33\x68\x8d\xef\x75\xf8\xce\x41\x5d\xdf\x54\xcc\xdf\xd8\xa0\x52\xbf\xda\x8d\x6b\x92\x7b\xa3\xa0\x80\x4b\x37\x91\xbf\xc4\x72\xdc\xda\xc2\xb3\x1c\x15\xbf\xe3\x82\xb5\xf8\x6c\x12\x40\xa4\x7b\x38\xf9\xe1\x58\xc7\xc1\x9c\x5d\x70\x16\x06\x49\x38\x4d\x50\xde\x2d\xd8\xd9\x76\x97\xed\xf4\xb6\xcd\xdf\xee\x79\x1d\xa6\x2c\x11\x1f\x1c\x6a\x63\x27\xec\x05\xb6\x72\xce\xfa\x2b\x13\xc6\xc4\x25\x0c\x72\xf3\x88\xa4\xe1\x43\x56\x83\x52\xc7\x56\xe2\xf8\x67\xea\xce\x85\x8f\xcc\x1d\x05\x70\xa9\x5f\xe3\x72\x74\x12\x8c\xf9\x9d\x33\xb5\x3b\x64\x69\x82\xa1\xa1\xa9\x39\xb8\xd4\x74\xd0\x55\x91\xdf\x96\xa3\xcc\xd3\x8c\x45\xbc\xe4\x61\xc9\xae\x38\x98\xd0\x8b\xff\x71\xd0\x37\x80\x5f\x1e\xf9\x28\x81\x25\x71\x0a\x3a\x89\xac\xe0\x52\x8b\x15\x24\x57\xc1\xbc\x38\x19\x65\x57\xa2\xb4\x00\xe9\xae\xa7\x8a\x4b\xbf\xe7\x02\x3c\xf3\x3c\x02\x9d\xcf\xa9\x5d\xcd\xd1\x35\x63\x9f\x4a\xdb\xd8\xc4\xf7\x05\x8a\xc8\x29\xa8\x17\xd5\x32\xfe\xb5\xc7\xf1\xd2\xec\x9f\x27\x13\x1e\xc6\xc3\x98\x47\x15\xf0\x2d\x30\xc8\x40\xdc\xd3\xdf\x22\xe6\x6a\x8f\x53\x59\x4e\x52\x9b\x04\x75\x20\x76\xdf\x07\x41\x60\x60\x89\x37\xab\x02\x3d\x13\x57\xf0\xe3\xd1\xf5\x7a\xe9\x40\x89\x7f\x6e\x6e\x65\xeb\xea\x57\x93\x2a\x2d\xda\xf2\x73\xdf\x4d\x70\xcb\xe3\xb3\x02\xd2\x41\x15\xe1\x2e\x75\x90\x8d\xa9\x6f\x7d\xb9\x25\x51\x87\xd1\x97\xff\x3a\x47\xcf\x8e\x35\x5b\xd6\xdc\xe8\xe0\x06\x62\x32\x88\xbe\xba\xcb\xbe\x52\xf9\xef\x1e\x95\xd6\x82\xdd\x74\x4d\x75\x30\x37\xff\x1c\xa7\x91\xae\x12\x65\xbc\x80\xb7\x33\x92\x17\xb2\x38\x45\xeb\xd7\xbb\xd1\x70\xaf\xab\xa4\x86\x8b\x28\xc9\x0e\x6e\xe0\xa6\x82\xc9\x7b\x0b\xa6\xed\xf6\xff\xad\xdb\xfe\xdf\xa4\xdb\xd6\x7f\xab\x2b\xb9\x81\xc4\x96\xd2\x72\x5b\x77\x63\x83\x9c\x0f\xf7\x5c\x35\xb7\x57\x57\xbd\xd7\xa8\xab\x06\x1a\x52\x05\xc5\x47\xa3\x2a\x7b\x6f\x49\x55\xf6\xde\xf2\xaa\xec\xbd\x5b\xaa\xb2\xf7\x6e\xab\xca\xde\xbb\x27\x55\xb6\xa3\x9d\x76\x55\x93\x15\x43\xc0\x65\x14\x93\x8b\xee\x31\x57\xbf\x83\x34\xfc\xbc\xe3\xa0\xa0\x41\x37\x48\xcb\xfd\x31\xda\x77\x0b\x02\x39\xa9\x32\x3a\x30\xfe\x09\x89\x91\x3c\x5d\x50\x1c\x53\x5a\x23\xc5\x85\xad\x94\xea\xd6\xd5\x93\x6e\xba\x0b\xbb\xae\xe0\x12\x8e\xc6\x2a\x1b\x02\x5a\x17\xf5\x3f\xd7\x6d\x60\x45\x8b\xc3\x36\x75\x3e\xb7\x3a\x97\x92\x9e\xdb\xa9\x7d\xcb\xe0\x9c\x04\x6e\x7b\xdf\xb0\x50\x05\x7f\x3b\x0d\x31\xcc\xd2\xe3\xc7\x07\x8b\xd4\xc6\x1e\x05\xef\xbf\xf6\xe1\xfb\x1e\xf4\xd2\xdf\xf6\x80\xfb\xa7\x3b\x20\x79\xa6\xea\xce\x51\xbc\xe8\x28\x24\xb8\x93\xf5\x2e\x54\x1f\x88\xfe\xef\x3c\xef\xeb\xb3\x3b\x9a\x51\xd9\xa8\x59\x7c\x36\xfc\x33\x53\xd8\x5d\x1f\x54\x17\x9e\x4b\xed\xee\x3d\x08\xad\x1e\x6e\xc5\xb4\xc8\xa7\xf9\xd5\x23\xa5\x8a\x95\xd7\x27\x8f\xe0\xcf\x54\x67\xc0\xbf\x7c\xe9\x67\xb8\xaf\xfe\x85\xed\x9e\xdf\xee\xa0\xec\x1e\x62\x6b\x97\xca\x7d\x1c\x65\x61\x13\x2d\x60\xc5\xce\xa5\x4a\x1a\x64\xf8\x34\xb3\x2d\x0a\x4d\x59\x51\xc6\xee\x8e\xbd\x60\xad\x0b\x50\x46\xf6\x59\x2b\x89\x53\x1e\xe4\xad\xee\x9d\x1d\x98\x97\x3a\x31\x7b\x8f\x06\x61\x19\x7f\xe1\xc6\xe7\x40\xe3\xe1\xc0\x29\xdb\x2e\xd1\x91\xe0\x69\x1c\x7e\x2e\xba\x2c\x80\x6c\xc9\xfa\x61\x53\x3c\x06\xaf\x2a\x7e\x21\x98\x98\xaf\x63\x9a\x23\xe2\xe2\x25\xd3\x21\xa3\x7d\x9c\x91\x2e\xce\x1d\xa3\x49\xcf\xb5\x15\x46\xe2\xc1\xfe\x0e\x0f\x59\x6b\x94\xe5\xf1\x3f\xb3\xb4\x0c\x92\x8a\x36\x90\x86\x8a\x82\x96\x7a\xa1\x1e\x26\x78\x5f\x50\xe3\xe9\xcd\x55\x38\x2c\x89\x59\xb3\xab\xd3\xae\x54\x34\xdc\xc6\x8e\x74\x9b\x18\x9c\xca\xed\x77\xa9\x8e\x42\x51\x2b\x0e\x2b\xfd\x80\x71\x87\x8a\xe3\xe7\xb6\x5c\x95\x97\x06\x3a\xfc\x9e\x06\x0a\x53\x0e\x96\x60\x54\xb2\xc6\x32\xbb\x94\xcf\xeb\x9a\xe2\xb3\x13\x91\x76\x9a\x69\x3f\x7c\xc8\x5a\x35\x3c\x21\xa1\xaa\x5e\x38\xef\x2a\x98\xbb\x72\x9c\x1d\x8f\x76\x0e\xe3\x59\x61\x7e\x57\x06\x9e\xea\xab\x8a\xce\xe2\xab\x5d\x7a\x10\x3a\x46\xa1\xa7\x09\x95\x20\xe0\x4a\x94\x6b\x48\x21\xe1\xc0\xb3\x94\xff\x14\x38\x54\x28\xf4\x63\x50\xe2\xcf\x41\x5f\x05\x7b\xcd\x16\xa7\xae\x57\x93\xa5\xb4\x78\x71\x8a\x7e\x34\xa4\x0e\x6f\x9c\x4d\x05\xed\x4b\x05\x5c\x97\x46\xb0\x41\x4e\x2c\xea\xc8\x42\xa8\xb4\x8b\x31\x6d\x91\xc2\x0e\x3c\x85\x30\xa5\xb4\x81\x0f\x7c\xb8\xbe\x8c\x32\x06\x9e\xb6\x58\x87\xa5\x26\x25\x0c\x94\x7e\x9b\x0e\xb3\x26\x16\xab\x0b\xb5\x01\x98\xca\x4b\x21\x75\xd0\x47\x6f\xb1\xf6\xa2\x77\xc2\xfa\x54\xe6\x03\x0c\xed\x55\x55\x6d\x08\xb7\x98\xde\xaa\x3e\x25\x49\xd0\x72\xd9\x0e\xc6\x2f\xb4\x81\xb3\x0f\xd4\xcb\x59\x98\xf8\xfa\xc2\x00\xb0\xfa\x52\x10\x44\x34\xe2\x24\x07\xba\x06\x6c\x75\xdd\xe1\x39\x20\x28\xca\x57\xbb\x4f\x9c\x7e\x14\x29\x6d\x8e\xde\x6c\xfe\xa7\xcb\xe4\xaf\xdf\x48\x45\x3c\x85\x7a\x76\xb3\xe5\x10\x8e\x6f\x40\x77\x1b\x1e\x9b\xce\x88\x03\x19\x2c\xdc\x9b\x39\xee\x63\xf0\x6f\x5e\x2d\xa8\x92\xdc\x07\xe5\xc6\x51\x0e\x5e\x9d\xc3\x5b\x93\x8d\x0d\xd3\xd7\xc6\x86\x6e\xae\x7a\x48\x9f\x9d\x48\x9b\xba\x15\x2d\x82\x02\x45\x1c\x2f\xd3\xb9\x94\x96\x8f\x87\xd8\x96\x0c\xf9\xa8\xba\x56\x86\x7a\x76\xff\xf3\xfb\xee\x7f\xde\xdc\xff\xec\xef\x32\x7a\xbb\x44\x84\x40\x1c\xfc\xea\xc5\xa9\xd8\xd8\xd9\x0b\xfb\x5b\x13\x50\x47\x9b\x2d\x39\x03\x52\x0d\xce\x75\x83\x73\xa7\xc1\xb9\xaf\xc1\xdf\x3a\x3e\x3b\x28\xdf\xfe\x01\xaf\xc6\x11\xee\xbe\xfc\xb7\x2b\xbb\xed\xab\xee\x6b\xd8\xb4\xa1\xd2\x27\x0d\x54\x5a\x0a\xf9\x4b\x53\xde\x93\x5e\x96\x47\x3c\xe7\xd1\x29\x95\x00\x2b\x5a\x5a\x52\x5e\x8a\x71\x55\xa5\x2f\x95\xef\xaa\xe5\x21\xd9\x91\x0c\x27\x99\xf6\x3e\xa1\x99\x82\x84\xe3\x43\x56\xe8\xcd\xce\x59\xfc\x44\x74\x5c\xe3\x44\x78\x61\xf3\x22\x94\x88\x05\x90\xd8\x30\x46\x0b\xcf\x8a\x2e\xe2\x0b\x0f\x6a\x1d\xf7\x79\x0f\x81\xe4\x87\x43\xb6\x0d\x86\x14\x64\xb8\x1e\xad\x19\xd4\x50\x81\xbc\x6a\x25\x62\xb7\x21\x2b\xb3\x87\xee\x05\xbd\x2d\x7f\x08\xe6\x49\x16\x44\xe4\x8d\x8c\xc4\xa7\x74\x78\x45\x41\xae\xd8\x7b\x06\xce\xa9\x80\xbe\xb4\xa9\x1c\x18\x9a\x4e\x0a\x4b\x11\xb9\x4d\x63\x88\x7e\x84\x55\xea\xa1\x69\xdb\x9e\xc2\x80\xc4\x3e\xfd\xe8\xda\x48\xe8\xdb\x9f\xdd\xca\xf8\xfa\x95\x94\xa5\x45\x21\xca\x1b\x16\x5d\x62\x82\xf7\xb1\x32\x63\x17\xdc\xe8\xcb\x95\x54\x23\x27\xd9\x23\xd7\xa8\x2b\x29\x4a\x63\x8c\x31\x9c\x08\x73\x23\x65\xc9\x2c\x46\xc2\x51\x8f\x6e\x9c\xbf\x53\x02\x51\x36\xac\xf4\xde\x20\xf3\xd8\x64\xd4\x24\xf8\x34\x10\xdc\xa2\x7b\x27\xe2\x60\xc5\xce\x5b\xfb\xd2\x84\x78\xb8\x21\xbd\x34\xad\xe7\xbf\xb2\x6d\xf0\x98\xe2\x00\x59\x4d\x52\x11\x22\xaf\xaf\x99\xc3\x0f\x7c\xb7\x23\xb7\x93\x3b\x64\xfe\x9a\xaa\xfa\x51\x1c\x71\x5b\x51\x2f\xf5\x74\xce\x09\x5b\x24\xd6\x9c\x72\x5d\x6d\x85\xe7\x60\x45\xcd\xf6\x77\x9b\x5f\x20\xf8\x5f\x16\xec\xd6\x3d\x2d\x48\xa5\xb7\x42\xab\x6c\x4a\x3c\x16\xaa\xbf\x69\x1a\x97\x95\x82\x22\xd1\x2d\x88\x47\x92\x12\xbc\xed\xd9\xa5\x75\x0e\x15\xc4\x4c\xd8\xc4\xa6\x48\x89\x88\xa3\x4e\x97\x9d\x59\xbc\x6e\xd5\x17\xa9\x9f\x95\xec\xf3\x21\xe7\x85\xd2\xd1\xbd\x2c\xcb\x3c\xbe\x98\x96\xbc\x20\xea\xca\xca\x69\x4f\xe2\xb1\x6f\x8c\x1a\x05\x12\xfa\xf0\xff\xae\x19\x7c\xdf\xfc\xb4\x11\x24\x70\xdb\x47\xb4\x5f\x5f\x33\xef\xac\x40\xc0\xbb\xd5\x6d\xf0\x72\x35\xb8\xf7\x81\x38\x51\x26\x59\x7e\x3c\x94\x1e\x26\x05\x8d\x5b\x83\x73\x54\x1c\xc0\x70\x56\xed\xf7\x4a\xf5\x0b\x82\xd4\xab\xf9\x6b\x49\x89\x55\xd5\xb9\xb5\xe5\x6a\xf3\x50\x07\x9a\x89\xda\x69\xea\xab\x5a\x5b\xca\x79\xc7\x52\xf8\x9d\x9d\x77\x16\xeb\xf5\x7e\x84\x39\x5a\x78\xdf\x4f\x8a\xa9\x2b\xe2\x70\x9a\xe7\x3c\x45\x7f\x28\xde\xa7\x6d\x4f\xfc\x4f\xdb\x2a\x7c\x99\x36\x74\x8b\xc7\xe8\x56\xb5\xda\xeb\xfa\x4c\x9d\x5f\xad\xe2\x99\xc7\x5d\x17\x71\xc5\x65\x95\x55\xe9\x0b\xcc\x00\xac\x3a\xb7\xb0\x06\xa8\xd4\xf3\x1b\x05\x5c\x04\xf9\x49\xfc\x4f\xae\x2f\xfc\xe5\x77\x8d\x0f\xb3\x7a\xcb\x81\x8b\x20\xff\x09\x8e\x86\xba\x99\x9f\xdc\xf3\xe3\x45\x90\x4b\x75\xf4\xdc\x29\x4a\x92\x9d\xf7\x88\xe0\x5d\xe9\x7d\x30\x7b\xe5\x80\x39\xd6\x49\x0e\x15\x0c\xa4\x11\xc9\xcf\xc1\x98\xbf\x9a\xbf\xb3\xb4\xbd\x9e\x2c\xa9\xcb\x74\x16\x08\x78\x0a\x8e\x43\x55\x58\xb0\x5b\x4f\xdd\x9e\x53\xcc\x61\x35\x42\x3c\x5f\xd0\x00\x2d\xe3\x8c\x63\x14\x14\xaf\x82\xdc\x27\x25\x60\x8e\xf3\x18\xdd\x39\x6c\x14\xf1\x3f\xc1\xe9\x0a\xfa\xa8\x12\x0d\x6d\x6c\xac\xcc\x7d\x62\xc5\x7d\x24\xc6\xa1\x61\x60\x3d\x5f\x15\xf9\xf4\xd5\x8f\xfa\x37\xe5\x15\x5b\x0c\xe4\xe2\x3c\x52\xcb\xf5\x8c\x6a\xd4\xdd\x0b\xc0\x2c\x7f\x13\x84\x23\xe7\x06\xd0\x09\xa8\x6c\x9a\xf6\xbe\x9c\x7b\xb2\x9c\x81\xca\x5a\x4f\xdf\xbb\x70\xf5\x58\x39\xa2\x0c\x44\xaa\x7e\xe4\x68\x2e\x1e\x1b\x24\x0c\x53\xa3\x4e\xbe\x80\x7d\xc6\x5a\x1a\xb4\x92\x77\x81\x48\x1f\x66\x86\x6c\x81\x2b\x91\xdb\x52\x97\xf0\xd1\xb5\x45\xe5\x65\xa2\xa2\x5b\xb7\xba\x45\xf3\x35\x75\xc5\x89\x14\x75\x60\xb6\xfb\xe3\x7a\xf9\xd0\xfb\x20\x88\xc6\x10\xd9\x73\x2e\x09\x6c\x8b\x11\xca\x08\xcf\x50\x7d\x4e\x5d\x77\xbc\x0f\x26\x36\x90\xd2\xfe\xc6\x19\x5a\xb5\xa2\x3b\x38\xd3\xaf\x1c\x9b\xd4\x73\xc9\x9f\x67\x71\x74\xbe\xcc\x65\x86\x1c\xb4\x76\x26\xb6\x07\x1e\x3a\xaa\xd7\xb0\x3a\x5f\x22\xa8\x67\x3b\x7b\xe8\xdc\xa2\x86\x18\x0d\x1c\xd8\x5b\xab\x5f\xf4\x4f\x15\x93\x80\x86\xe8\xfb\x24\x80\xa6\x63\xee\x8a\xf7\x9c\x5b\x46\xc7\xe4\xd6\xa6\x30\x89\xca\xe3\x8b\xdf\x2d\xe2\xf2\x52\xa4\x52\xe1\xf8\x2a\x98\x21\x56\xaa\x02\x8f\xd2\xac\xa2\xc1\x34\xc6\x5a\x37\x15\x0b\x19\x3b\xd7\x7a\xa5\xb2\x2a\x4e\x4b\x85\xd3\x13\x03\x22\x5a\x50\x20\x66\x91\x07\x36\x00\x41\xb2\x2a\x18\xbe\x08\xd2\x48\xf2\x8d\x55\xe1\xbb\x34\x1b\x03\xb6\x45\xa7\x5d\x61\xbf\x6b\xe6\xa6\x02\xc3\xd8\xe2\x5e\xab\x3c\xe2\x73\x98\x60\x87\xbd\xa8\xca\x0c\x7d\x97\x55\x56\x51\x91\x7f\xc8\x8a\x18\xb8\xce\x5d\x6c\x98\x23\xb2\x61\xea\x86\x71\xc3\xf4\xc8\x4c\x7d\xf9\x6f\xd7\x11\x90\xfa\xce\x77\x57\x4f\x59\x5f\xff\xea\xea\x9d\xbe\xaf\x7f\x9d\x19\xee\x7c\xde\x25\x28\xee\x93\xdf\x35\x1a\x23\x75\x47\x23\x78\x72\xc1\xa3\x1f\x53\xc9\x03\xe1\x35\xaf\xe0\x85\x60\xf1\x47\x3f\xc4\x3e\x0a\x3c\xbc\x40\xf2\xac\x9c\xce\x49\x63\x4d\x2c\x7c\xdf\x61\x8d\x96\x70\xd0\x9b\x4c\x8b\x51\xc5\xc4\x44\xba\x55\xb4\xdf\x4a\x98\xde\x6c\x4f\x90\x92\x27\xc0\xfe\x4e\xb7\x7d\xe7\x0c\xd4\xb5\xfc\x8b\x77\x3d\x47\x52\x31\xf2\x3e\x1a\xef\xfb\xe6\xc3\x81\x91\x51\xda\xea\xd3\x8f\xae\x3c\x41\xf4\xe5\xbf\x5d\xca\x87\xfa\xf4\xa3\xeb\x58\x86\xac\x63\x18\x5b\x85\x2f\x4b\x05\x8a\xe1\xda\xef\x1d\x0f\xbe\xac\x71\x48\x8d\x50\x35\x9d\x8d\x2f\xe2\x94\x43\x34\xb0\xbf\x05\x69\x94\xf0\x5c\x32\x04\x29\x84\x8d\x20\xd1\xee\xb4\x0b\xba\xa4\x2e\xd9\x6f\x7b\x59\x6a\xb2\x3b\x8d\x60\xbf\x49\x41\x29\xf0\x6d\xc1\x86\x4e\xeb\xc1\x86\xec\x8e\x03\xf5\x8d\xd8\x05\x35\x59\xee\xcb\x88\x1d\xf6\x1f\x9c\x9f\xa1\xbd\xcf\x7c\xce\xae\xaf\x59\x4b\x7c\x6c\xb6\xd8\x63\x94\x75\xdd\x26\xeb\x77\xf9\xfd\xae\x7b\x8c\xd1\xab\xc0\x15\xf3\xce\x1b\x84\x85\xfd\xae\x75\x92\xe9\xfa\xb7\xe3\xe6\x06\x5a\x41\x1a\xe3\x5d\xfa\xdb\xa8\xd5\xd5\x07\x62\x22\x13\xec\x77\x2a\x73\x0c\x3c\x5b\x92\xf0\xaa\xca\xa8\xcc\xd8\x3b\x1e\xe9\xe6\xe8\xde\x69\x1b\xb9\x57\x60\x30\x8b\xfd\x81\x3d\x91\xb6\x4a\x91\xa6\xbb\x4a\x50\x8b\x91\x2d\x56\x9b\x1c\x4d\xf3\x22\xcb\x75\x58\xcb\x26\xd5\x89\x53\xb4\x7d\x1b\x4b\x27\x5a\x0e\x6f\xbc\xf6\x1a\xee\xde\x3c\x37\x2c\xb2\x52\xcf\xcd\xaa\x51\x92\xa8\xe2\x3e\xfd\x08\xb9\x99\x7b\x65\x64\x12\x55\xc3\x93\x5b\x39\x29\x27\x43\x59\xc9\xd7\xd4\x16\xdb\xad\xce\x0a\x5d\x78\x45\x99\x67\x9f\x79\x9f\xb5\xd2\x2c\xe5\x96\x49\xdc\x30\x4e\x92\x3e\x6b\xfd\x67\x18\x86\x56\xfa\xac\xcf\x6a\xcc\xba\xd8\x8b\x0a\xb2\x7a\x33\xb6\x69\x60\x54\xec\xbe\x97\xf0\x61\xc9\x1e\xb3\xed\xde\x3e\x6d\x79\xde\xd4\xb2\xac\x59\x66\x13\xac\xc8\xaa\x37\x41\xbd\x39\xe9\x8c\x36\x0c\x2e\xdb\x9b\x1a\xf7\xa1\x4e\x03\x8b\x0e\xdf\x37\xd9\x0e\x6d\x12\xfd\xbc\x2f\x01\xb0\x74\x08\xbf\xc9\x76\x58\xdf\xd7\x8f\x59\x3f\xcb\xae\x8f\x0f\x59\x9c\x96\x8d\x7a\x45\x5a\x6e\xcd\x95\xb1\xbf\xca\xca\xd8\xbf\xdd\xca\xd8\x97\x2b\xc3\x21\xed\xd9\x4e\x8d\x3b\x99\x79\x5d\xc6\x6c\xb7\xae\xc6\xae\xef\x31\xc2\xd2\x16\x8a\x00\x49\x95\xb4\x29\x1f\x84\xae\x67\x96\xb3\x73\x00\xd3\x90\xad\x95\xb5\x6b\x65\xb1\xc7\x36\xb5\x78\xfd\x2f\x2e\x61\xe0\x38\xf7\xc2\x39\xaf\xf4\x3c\xb7\xe0\x9c\x11\x38\xc5\xc2\xac\x0c\xcb\x5e\xb4\x74\x55\xf8\xbd\xe1\xaf\x74\x96\xa9\x80\x1d\xce\x3a\x70\x73\x77\x47\xad\xcd\x3b\xcd\xe6\xa9\x4d\xa6\x9c\xe1\xcc\x87\xd7\xd0\x23\x50\x86\x73\x6f\xc9\x8a\xfa\x8a\xb1\x38\x4d\x79\xfe\x51\x19\x36\x56\xaa\x90\x6c\x8f\xfc\x37\x2d\x9b\xea\x92\xec\x6a\x5d\x65\x22\x59\xa9\x55\x35\x95\x54\x6f\xb1\x52\x8e\xbc\x64\xa9\xc3\xf2\xed\xed\x23\xc3\x59\x97\x85\xe2\x70\x41\x86\x2c\x4d\x22\xab\x1a\x26\x18\xdb\xb7\x80\x86\x22\xd1\x0b\x0d\x2c\x1b\x83\x1c\x9b\x1d\xc8\xb5\x48\xb2\xe7\x07\x55\x56\x65\x06\x53\xa9\xed\x64\xcf\x3d\xc6\xc8\x9e\xf3\xe4\xf2\x84\x3a\x58\x9e\x52\xf3\x5a\x42\xcb\x6b\x68\x0c\x9e\xf8\xbe\xac\x23\x34\x93\x5b\xad\xc9\xd3\xa8\xb6\x9e\xca\xf3\xd0\x28\x34\x79\x9f\x54\x31\x10\x64\x31\xa0\x36\xbb\x66\x14\x1e\x2a\xe5\x69\xf4\x6d\xa1\x51\xb8\x71\x7d\x4d\x78\x24\x3e\xf1\x37\x01\xd1\xa0\xcf\xce\x0c\xe2\xba\x1a\xe8\xca\xdb\x90\x70\xd6\x67\x03\x5c\x17\x7d\xda\x6d\xdf\x83\x8c\x3e\xf9\x6d\xc0\xea\xeb\x5f\xf6\x51\xa2\xe6\x24\x51\x91\x58\xcf\xc0\x62\x7f\xb6\x03\x96\xfa\xf3\x1d\x10\x8e\x20\x65\x17\x53\x76\xd9\xcd\xf9\x12\xaf\x2d\x9c\x1b\xa8\x45\x4f\xb1\x7d\x57\x65\x8e\x49\xf0\x52\xe2\x83\x7e\x75\xe0\x9c\x3c\xfb\xac\x05\xb6\x90\x2d\xfb\x94\xd9\xd7\xfe\xc9\x6f\x56\x15\x04\x1a\x7a\x9c\xf9\x7b\x9c\x2f\xdb\xa3\x7f\x9f\x6c\xe8\x10\x69\xc4\xdf\x2b\xf0\xd5\x6a\xcf\xd5\x13\x8b\xa7\x5d\x53\xb7\xd2\x2c\xe9\x72\xa1\x58\xed\x31\x62\xac\x8f\x27\xd1\x64\xf0\x78\x9b\xa7\x36\x2b\xd3\x90\x79\xb4\x52\x17\x4b\x62\x79\xea\x30\x8f\x6a\x96\x69\xab\x71\xde\xdd\xf7\x16\xf5\x33\x59\x79\xe0\xd2\x38\x39\xd2\x46\xbc\x76\x42\x94\x0d\xf9\xac\xcb\xe6\x77\x3e\x01\x42\xfa\x5c\x02\x9b\x20\x95\xa8\x03\x0d\xb1\x86\xab\x9c\x69\xd4\xe3\xfa\xb7\x08\xb4\x38\x2f\xb0\x1f\x6c\xe9\x7a\x63\x83\xcd\xd8\x5f\x9b\x24\x6e\xb0\x5e\x26\xd5\xc4\xe9\x01\x92\xfe\xda\x7c\xa0\xa8\xce\x99\x01\xe4\x85\x64\xa6\xc8\x4b\xd9\x4d\xc5\x8e\xda\x6b\xaf\xfc\xb4\xe9\x64\xa8\xd6\x26\x35\x98\x7f\xda\xa3\xc9\x76\x05\xb3\x62\xed\x1a\x56\xba\x3b\x6f\x56\x2f\x1b\x1b\x76\x23\x1e\x3b\x5e\x55\xfc\x1e\x6d\xdb\x29\x48\x5e\x93\xda\x55\xc5\x01\x54\xd4\x4a\x7a\x3f\x1e\x9e\xf0\xb0\xcc\x72\x65\x87\x40\x27\xaf\x6b\xc6\x79\x4b\x6b\xd8\xca\xea\x43\xaf\x8b\x5f\x78\x5a\x16\xc7\x43\x19\xd2\xb1\x76\x29\xfa\x0a\x57\x74\x0f\xc4\xc3\x06\x59\x95\x35\x6e\x36\xa4\xb2\x04\x6e\xfc\x56\x0f\x12\x11\xeb\x20\x11\xa0\x04\xf5\x87\x89\x68\x68\x75\x67\x30\xd0\x61\x84\x06\x92\xef\x1b\x52\x50\x7e\x1d\x44\x7b\x07\x3e\xe8\x11\x23\x46\x3b\xf7\x56\x5e\x28\xd9\xc1\x94\xe5\x1b\x91\x17\x16\xcd\x52\x6d\x7a\x1f\xf1\x85\x7a\x78\xa2\x83\xaf\x16\x7f\x9f\x7d\xe1\xd5\xd2\x10\xef\xb4\x5a\x58\x5e\x7a\xb8\xa5\xf1\x5a\xc2\x2a\x7e\x9a\x4d\xc3\x51\xa5\x6d\x9d\x4a\xa4\x86\x3e\x84\xd4\xa0\xa8\x80\x73\x8c\x46\xc4\xaa\x13\xc9\xe5\x44\x26\xaa\x31\xd7\xae\xb2\x62\x2f\x8c\x30\x1e\xeb\xde\x3d\x0a\x6a\xeb\x9a\x8c\xc0\xd9\xb5\xe7\xaf\x12\x15\xd6\xb2\x1b\x3f\x1d\x71\xa6\x42\xa3\x81\x9f\x5b\x3e\x9b\xf0\xb4\x88\xbf\x70\x56\x66\x2c\x87\x80\x8c\x2c\x4b\x59\x12\xe4\x97\xda\x17\x51\x49\xbc\x30\x15\x19\x9b\xe4\xd9\x97\x38\xe2\x60\x60\x1e\x5c\xc4\x49\x5c\xce\x45\xe5\xa2\xcc\x72\x48\x1c\xb3\x38\x95\x81\x61\x83\x34\x62\x59\x9a\xcc\x55\xe4\x3a\xc8\xc5\x17\xd1\x3c\xe4\x45\x11\xe4\x73\xd3\x74\x39\xe2\x73\x80\x29\xe2\x13\x01\x48\x5a\xb2\xe9\x24\x43\x43\x76\xf4\xc4\x24\x9a\xa3\x0e\x93\xac\xba\xd2\x4d\x52\x91\xb1\xb8\x6c\x15\x2c\x1e\x4f\xb2\xbc\x0c\xd2\x92\x95\xa3\xa0\x44\xb7\x5d\x63\x5e\x8e\xb2\x08\xfd\xaf\x24\x09\x8f\xd8\x20\x18\x96\x3c\x1f\xd8\xed\x20\xe8\x71\x21\x81\x8e\xd8\x55\x5c\x8e\xc0\xcf\x9f\x8c\x2f\x9b\x97\x5b\x12\x8a\x38\x24\x51\x25\x4c\x2b\xfe\x70\xb7\xfa\x4f\x4c\xc2\xc4\x89\x7d\x7b\x21\x5d\x0e\x0f\x33\x19\x13\x54\x85\xbf\x15\xcb\x6d\x1c\xf8\x22\x5f\xfc\x4b\x3b\xae\x72\x3a\xd0\xb6\x97\x06\x43\x92\x64\xe2\x26\x77\x57\x38\x55\x3f\xab\xb0\xbf\x40\x86\xdc\x3c\xc9\xac\x7b\x70\xb0\x74\xa4\xc0\xda\x2d\xe4\x16\xb1\x06\x73\x3e\xdc\xf7\x9a\xc7\xee\xf9\xcd\x63\x27\x24\xf6\xfb\x7e\x5d\xd8\xdc\x8a\x03\xaa\xfd\xdb\x3a\xa0\xda\xef\xd5\xdf\x37\x13\x4b\x58\x2c\x4a\xe2\xd1\xaa\x32\x6b\x05\x13\xfd\x07\x30\xc8\x2f\x41\x12\x8b\x76\x7f\x15\xd2\xe2\xdf\xf0\xf2\x41\x8a\x09\x76\xf4\xf0\xce\x0a\xef\x57\x97\x8b\xf5\xb0\x84\xc1\xec\x82\x70\x10\x55\x44\xeb\x52\xd5\x88\xc6\x39\xff\xc2\xf3\x82\x03\x7d\x1c\xe7\x11\x3c\x10\xc0\xb2\x95\x9c\x25\xcc\x65\x77\xef\xc9\x5e\x76\x77\x6d\x83\xd9\xdd\x26\x8b\xd9\x8a\xfd\xf7\x3d\x06\xd5\xfa\x49\xf5\x05\x12\x95\x6b\x7c\x6b\x99\x93\xaf\x6a\x97\x50\x58\xc6\x5f\xd8\xdc\xab\xb9\xb4\xba\x44\xc3\x7f\x8f\xab\x9c\xca\xa5\xbf\xb4\x54\xb4\x15\x04\x3a\x91\x12\x5c\x95\x8a\xdc\x17\x8c\x77\x61\xb9\x09\x06\xa8\x38\xc3\x7e\x5b\xcc\xc5\xae\x0a\x1a\xfc\xd2\xc0\xf3\x1a\xc9\x06\x7b\x9e\x08\x7b\xd6\x6b\x3e\xd1\xfd\xed\x42\x65\x34\x84\x1e\x73\x06\x23\x44\x5a\x77\x26\x6c\x83\xc1\x7b\x8f\x8b\x61\x47\x86\x75\xfd\xb4\x54\xcf\xec\x5a\xb5\x83\xf4\x50\x6b\x3f\x65\x5b\x48\x35\x23\x4c\x80\x41\x3a\xc5\xb5\xd0\xfb\xcc\xe7\x45\x5b\xb6\xd8\xf1\xd8\x76\x7f\x76\xe3\x5e\x28\x9b\x93\xcf\xe0\xc6\x49\xda\x54\x38\x73\x4b\xcb\x74\xb5\x51\xd5\x67\x3e\xef\xe5\x7c\x92\x04\x21\x6f\x03\x79\x75\x59\xab\xd5\xe9\xa2\x5f\x06\x31\x2b\x14\x47\x0e\xbd\xab\x15\xa3\xc2\xdb\xf8\xad\x4a\x1d\xfb\x61\x38\xf8\x80\x09\xac\x79\xe7\x4f\xdf\xc4\xfe\x84\x81\x1f\xb2\xbc\x4d\x9a\x77\x27\x46\x19\x8d\xfc\xe4\x7d\x6a\xe8\x7f\x36\x53\x6b\xee\xb6\xba\xb1\x98\x27\x0c\x38\xa5\xc4\x45\xfe\x1b\xeb\xa3\xcb\xd9\xa6\x6f\x64\x02\x1a\xcf\x27\xa4\x6b\x3f\x82\xfa\x35\xe9\x8b\x63\x0f\x7a\x6d\xf1\x3c\xa0\xd3\xf5\xa4\x66\x59\x63\x9b\x1c\x91\xf4\x19\x89\xf1\x22\x89\xd3\x72\x33\x8a\x8b\xe0\x22\xe1\x8c\xa5\xd9\xe6\x54\x9c\x86\x8a\x30\xcb\xf9\x66\x84\x77\x91\xb5\x12\x25\x89\x83\x5c\x2b\x33\x5a\xb1\x92\xc9\xb2\x69\xd8\x71\x9e\xca\x1d\x07\x8f\x76\xe6\x5d\x39\x1c\xc9\x8f\xb8\x38\x57\x8b\x2d\xa6\x97\xa5\x4d\xfb\x56\xb5\x15\xd4\x08\x9c\xfc\xf6\xf3\xd1\xe0\xcd\xdf\xdf\xfc\x7c\x2a\x1a\xb1\x4e\xa2\x1f\x79\xc8\xe3\x2f\xfc\x64\x9e\x86\x95\xf3\x68\x73\x70\xea\xa5\x61\x2e\x78\xf9\x3e\x98\x29\x8c\x14\xcd\x31\x9c\x97\x6e\x75\x30\x26\x6d\xda\xcc\xe9\xee\x61\xbe\x0b\x34\x58\x00\xb3\xc7\x6c\x67\xf9\x00\xd3\x76\xcc\xe6\x5a\xba\x73\x43\x3b\xdf\x2d\xe9\x39\xad\xff\x9b\x0c\xff\x37\x90\xe1\x66\x03\x19\x3a\x1a\xa5\x23\x25\x8d\xa0\xdf\x74\x94\x54\xb2\x21\x03\x9f\x87\x13\x54\x43\xa0\x5a\xe5\xcb\x25\xe3\xa8\x88\xae\xe8\x01\x6e\x13\x86\x7b\xcd\x70\xda\xbe\x4e\xb5\xb7\x1b\xfc\x3b\xf5\x79\x87\x9f\xd5\xf9\x33\x57\x8d\xcc\x97\x68\xa4\xe2\x14\xdd\x55\x68\x9c\xde\x1e\x87\x75\x5b\x92\x23\x26\x2e\xbe\x29\x54\xe2\x64\xce\x87\x4f\x5d\x85\x05\x55\x4a\x3c\xf5\x29\x25\xbc\x4e\xbe\x9f\x36\xbe\xe6\x85\x12\xff\x45\xbd\x1a\x41\x15\xbf\x4f\x23\xb7\x18\xa9\xe7\x44\xcc\xfe\x7a\x23\x83\x65\x9b\x32\xbe\x7e\xe7\x6e\xbf\xf3\x85\xbe\x94\x9c\x7a\xf5\xfd\x1a\x6f\x4b\x14\x87\x78\x29\xa6\x0e\xfc\xf0\x65\xf7\x25\xed\x2f\x55\x09\xfc\x5c\xcd\xef\xf7\x38\xc8\x2f\xe3\x94\xbc\xc2\x85\xcf\xeb\xeb\x8a\xc2\x1b\x54\x74\x7f\xec\xbd\xc5\xee\xf6\x60\x10\x2a\xab\x91\xc1\x2b\x01\xd0\x32\xb7\x16\x09\xbf\xe4\x69\xf4\x07\x5f\xb9\xec\xd2\x2b\x97\x77\x00\x51\x1d\xec\x9e\x13\xdd\xdf\x34\xe4\x78\xd4\x32\xee\xa6\x6a\x4f\xea\xb1\xc7\x01\x87\xf2\x80\xa9\xaa\xe3\x0b\x46\xbb\x0c\x71\xc4\xaa\x4f\xf4\x24\xad\xea\x4f\x1b\x8b\x8c\xe3\x3c\xcf\xe0\x8d\x95\x4c\x68\x70\xe2\xb1\xf4\xe1\x9f\xf4\xab\x0a\x9e\x91\xb4\x73\xf6\x58\x02\x08\x6b\x64\x35\x5f\xa7\x2c\xe1\xc3\xb2\x2f\xd7\x01\xde\x4e\x5f\x5f\xb3\xed\x2e\xcb\xd1\x18\x5a\x66\xc0\x17\xe4\xb0\x9a\x53\xf7\xdf\x9d\x39\x9a\xad\x37\x47\xb3\xff\x6d\x73\x84\x5c\x6a\xc5\x49\x2a\xb3\x89\x9e\x8a\x32\x9b\xc8\x29\xba\xc8\xca\x32\x1b\xeb\x0c\xfc\x6c\x9c\x24\xc1\x9d\xad\xeb\x31\x9c\x3a\xf5\xe3\x6f\x6e\x2d\xe0\x7a\xaf\xb0\x5d\x6d\x8c\x80\xfd\x38\x12\xa6\xe6\x8f\x36\x42\xad\x2a\xec\xf1\xa1\xe1\xa3\x3d\xca\xbc\x05\xd0\xeb\x33\x3e\xdb\x7d\x71\xc5\xee\xda\xb1\x10\x31\x6c\x71\x63\x03\x65\x69\x99\x24\x05\xa2\x2a\x6d\x62\xfe\xab\x6c\xa6\x14\x17\x76\x85\xde\x25\x2f\x5f\xbd\xca\x66\x6d\xdb\x4a\x20\x5b\xde\x31\xa4\x5f\x71\x8a\xe3\x0c\x26\x13\x9e\x46\x28\x7b\x1c\x0f\x91\x85\x22\x03\x56\x67\x7c\x57\x07\x20\xf5\x28\x1a\xea\x46\xdb\x01\xaf\x56\x82\x4c\x7f\x9f\x7e\x50\xe2\x54\xbd\xd3\x7a\xf2\x71\x86\x7a\x65\x41\x4d\x5f\xf4\x57\xee\x6e\xda\xea\xf9\x85\x7e\x5d\x41\x6c\x5f\x36\x6d\x42\xf2\x68\xb8\x6a\x6f\x71\xf1\x80\x94\x1b\xa7\xa7\x20\xcb\xc7\xe9\xe5\x62\x57\xa6\xcc\xfa\x7b\xd3\xec\xcc\xf4\xe7\x69\x92\x54\x3d\x7d\xc1\xe5\x8b\x2b\x82\xde\x0a\xca\x80\x15\x21\xf8\x06\xaa\xbf\x36\xe5\x09\x64\x88\x76\xd0\xc2\xd6\x53\xc5\x15\xa0\xd3\x4c\xce\xfc\x2a\xc0\x25\x3c\xf8\x52\x07\xdb\x9d\x76\x34\xce\xa0\x9f\x25\x02\x45\xf1\x5b\x4d\xd3\x2a\x40\xc5\xee\xe8\xfd\x20\x11\x88\xd6\x03\xa5\x72\x50\x29\xf3\xf8\xf2\x92\xe7\xfa\x90\x5f\x7b\x52\x71\x0b\xc2\xc5\x8a\x7b\x52\x29\xe6\x69\xf8\x36\xb2\xad\x76\x30\xcd\xb5\xc9\x5a\xed\xb9\x06\xb6\xd5\xb9\xf3\x33\x3d\x1f\xc7\x8d\x3c\x74\x59\xed\x09\xc2\x27\xb5\x28\x18\x51\x0b\xd8\xae\x48\x03\x7c\x2d\xad\x5e\x42\xfb\x15\xa3\xc1\xae\x9d\x17\xb7\xa0\x7c\xb3\x29\x1f\x6c\xe3\x6b\x54\xf3\x4a\xd4\x9d\xb0\x66\x1d\x3a\x1a\x28\xfa\xcb\xd0\x09\x1d\x66\x39\x6b\x83\xd1\x22\x3b\x64\x18\x56\x45\x5f\x40\xb8\xf5\x54\x24\x21\x16\xb3\xbf\x8a\x82\x07\x2c\x7e\xfc\xb8\x5e\x64\xf3\x37\x72\x16\x57\x83\xd0\xa0\x44\x04\x0f\xf1\xc5\xe9\x10\x7e\x5c\x5f\x4b\x41\x09\x49\xf1\x33\x9f\xeb\x3c\xf5\x74\x98\x20\x0a\xf2\x56\x3d\xcc\xfc\xae\x63\x78\x90\x06\xd1\xeb\xb1\x06\x0c\x9c\x01\x74\x84\x68\x60\x66\x04\x3a\x95\xfe\xca\xbd\xd3\xc4\x9c\x90\xce\xcb\xda\xc2\x2f\x61\xb8\x87\x26\x47\x68\x1b\xed\x65\x55\xaf\xf3\xe0\xca\x1f\x09\x4e\x73\x24\x50\xeb\xcb\x80\x7d\xa7\x76\xf0\xbe\xe6\x8a\x52\x95\x82\xd9\xa7\xd2\xd8\xa6\x56\x49\xa5\x23\xd7\xd1\xf9\xc2\x90\x49\x32\xf0\x1f\xdc\x97\xd6\xf6\xaa\x6c\x5d\x62\xe5\x6c\x53\xf5\xaa\xcd\x68\xaa\x3d\x2b\x9e\x6a\x07\xf1\xa3\x55\x51\x46\x53\x1a\x2a\x62\x8e\xb4\x55\xab\x0e\x56\x18\x6f\x13\xc4\x75\x55\xe7\xce\xba\xad\x38\x6e\x02\x63\x04\xed\x85\x91\x18\xb2\x59\xd4\xa2\x74\x1d\xb2\x64\xa3\xb6\x43\x95\xd1\xf6\xbf\x15\x19\xae\x76\x21\xec\x0f\x72\x81\x18\xc3\xa0\x7b\x41\x2f\xcc\x79\x50\xaa\xe0\x2b\x4d\x8b\xe8\x7b\x2a\x7d\xeb\x67\x2b\x02\x31\x5e\x29\xdc\x77\x73\xa7\x70\x47\x97\x4a\x98\x04\x85\xb6\xee\xe7\xb0\x99\x16\xe0\x17\x80\xd4\xb0\x2e\xd3\x59\x5d\x26\xc5\x17\xac\x16\x39\x45\x3e\xbe\xf1\x98\xb5\x8c\xf3\x01\x5a\xf1\x4b\xcc\xaf\x5e\x65\xb3\x3e\x1a\x4e\x6f\x83\xed\xed\x76\xd7\x12\x65\xbb\xae\x8c\x7a\x43\x1b\x28\xad\xdb\x50\x69\x53\x29\x28\xcd\xbe\x26\x25\xb2\x6b\xb3\xf0\x0a\x0b\xfa\x32\x8f\xab\xd6\x60\x2e\x99\xab\xe5\x59\x8e\x38\x54\x70\xd5\xb8\xfe\xc5\xe1\x2e\x0b\xab\xab\x3a\x19\x04\x17\x05\x9e\x3e\x9a\x18\x11\x1e\x3a\x96\x5c\xa0\xde\x55\xfa\xce\x6e\xa1\x79\x95\x62\xe1\x8a\x6d\x32\xd8\x4d\xec\xfb\xcd\xc7\xd6\xd9\x4e\xab\x6b\xfc\x49\xc3\x1a\x27\xba\x48\x59\xb8\xc6\xc8\xca\x66\x06\x4f\x96\x60\x06\x4f\xaa\x8f\x01\x2c\xad\x26\x91\xed\xea\x55\x9b\x38\x57\xbf\xca\xce\xd5\xa1\xad\xed\xaa\x84\x3a\x24\xd1\xa8\x83\xbc\xca\xc6\xbf\x29\x28\xf5\x59\xae\xed\x28\x2f\x68\x63\x44\x6f\xe1\xb4\xa6\xb4\xe9\xab\x9e\x9c\xff\xa1\x36\x7a\xa4\x0f\xd0\x0b\x54\xfd\x16\xa9\xc9\xe8\x33\xa3\xca\xbc\xed\x7d\x3c\xc1\x61\x9f\x7e\x74\x2d\x8c\xf4\xad\x2f\x95\x27\x5d\x34\xf7\xed\x4f\xeb\x8c\x6b\xcb\xe3\x80\x96\x95\x3c\x18\x2f\x44\xa4\xde\x28\xce\x1e\x5a\xfb\xc3\xc3\xf3\x4e\xd3\x16\xb1\xac\x7a\xd7\xd9\x1b\x3c\x31\x34\x61\x1f\xf8\x95\x32\x5d\x37\xf3\x6f\x16\x0f\xa6\xd9\x48\x4f\x4a\x1f\xd6\xb5\xd0\x33\xb4\x78\xc6\x50\xaa\x7f\x5c\xe1\x0d\x19\x86\xa3\xd7\x61\x87\x72\x66\x6c\x2f\x6f\x54\xc5\x93\xbe\x7a\x95\xcd\x7e\x01\x93\x12\xcb\x98\x1e\x51\x61\x32\x6f\xc7\xfc\x4f\x2b\x5e\xc9\x6b\xb8\xa8\xcb\x3b\xdd\x8a\xcd\xdc\x5c\x96\x6e\xb8\x17\x27\xa5\xfe\x6f\x7b\xff\x61\xaf\x3c\x02\xff\xaa\x91\x4b\x9e\x35\xbc\xb1\x8a\x0b\x09\x8d\x74\x2f\xaf\x1e\x4d\x3d\xeb\x39\x39\x4b\x3a\xed\x78\xb6\xc0\x69\x87\x1b\xac\xc0\xae\xa5\x1c\xf6\x7b\xaa\xa8\xc8\x09\x76\x05\xf4\xfe\x6f\x15\x77\xdc\x82\x3c\x33\x4f\xe8\xd6\x62\x4d\x49\x96\x52\xce\x44\xa6\xc5\xe6\x26\x5a\xa8\xf3\x68\xbd\xe5\x7b\x63\xa2\x9c\x04\x99\x8f\x68\x1d\x6f\x2c\xab\x60\x1c\x63\xdf\x9d\x24\x5a\x24\xa9\xc6\x42\x20\xb9\xda\x4b\xb5\x3b\xcd\x2f\x9c\x89\xe8\xb3\x33\xeb\xc1\x76\xb8\x4c\xa8\x04\x57\x15\x5a\x77\x82\x84\xfa\xaf\xb3\x7a\xed\x91\x53\xae\x8d\xa7\x44\xc9\xac\xdd\xd5\x1f\x65\x65\x9d\x1b\x96\xdb\x4c\x68\x5c\xfc\x3d\x48\xe2\x88\x4c\x29\xf6\xea\xa8\x8f\xb0\xb7\x75\x28\xc5\x1e\x8c\xf7\x65\x74\x03\xe3\x30\xda\xae\x1f\x25\xb6\x2c\x95\x57\x03\xcc\x98\xd5\xae\xe9\xb6\x5a\xfe\x9e\x8e\x72\x4f\x07\x83\x62\x14\x4c\xf8\xe0\x75\x56\xd6\x6c\xd0\x15\x10\xef\xf4\x98\xb9\x94\x2e\x70\x67\x5b\x30\x68\x19\x78\x6a\xf0\x2e\x98\xf3\xdc\x0f\x2c\x69\xed\xab\xff\x3c\x89\xcb\x65\x33\x12\xf4\x8e\xeb\xc0\xa8\x97\xac\x2d\x3c\xca\x8c\xc4\x75\x9b\x95\xb4\xc0\x73\x53\xb5\x28\xd8\x8d\x3c\x73\xd7\x11\xea\xc2\xc0\x2c\xe2\x19\xe8\x9f\xbc\x8c\x5a\xfa\x9f\xc0\x52\x24\xcd\x75\x4b\x5e\x38\x45\x75\x8a\xe7\x60\x42\xdf\xba\x3c\x23\x7a\x2d\x77\x67\x52\x0f\x9c\x25\x88\xf8\xed\x6c\xef\x78\x77\x29\x5d\x5f\xd3\x0c\xd0\xe6\x51\xb7\x82\x9f\xf9\xdc\x39\x46\x81\xab\xe7\xaa\x5b\xe9\x3a\xdf\xd2\x81\xe2\x4f\xda\x4d\x34\xf1\x15\xad\x33\xab\x76\xe6\xd4\x1b\x75\xd5\x25\xb5\x1b\xe0\x24\xc3\xbb\x44\xeb\xda\x94\xea\x32\xd1\xc6\xd8\x8f\xb4\x8a\xab\x4d\xca\xd1\x75\x5c\x1d\xe9\x2a\xc6\xca\x9c\xdb\x99\x56\xcd\xbc\xcf\xf6\xaa\x2e\xdd\xee\x35\xfe\x83\x9e\x07\x6b\x3b\x44\x2f\x73\x52\x52\xdf\xad\xe6\xf4\x59\xeb\x3f\x87\xc3\x61\xcb\xbb\x03\xd2\xe1\x4d\xaa\x62\x86\x5c\x45\xb4\x14\x24\x55\x14\x3d\x82\xae\x1e\xb3\xd6\x26\x29\x09\xda\x1d\x33\x23\x86\x8f\xdd\x73\x08\x10\x4d\x73\x8e\xcd\xb7\x58\x11\xe8\xef\x15\xa4\x3e\x77\x77\x35\xa4\xaa\xa9\xcd\xba\x04\x70\x45\x50\xbd\x94\x5d\xf9\x73\xf9\x7e\x2c\x59\xc8\x74\x6a\x9f\x84\x04\x85\xea\xbe\x7a\x0e\x37\x10\x14\x6a\x32\x1d\xff\x42\xd6\xc4\xe8\x52\x75\xd3\x82\x71\xa9\xed\x01\xeb\x1c\xb3\x29\x4b\x7e\x53\x3f\x68\x21\x79\x37\xee\x5a\xb6\x5d\x45\x23\x67\x5f\xc0\xcd\xfd\x6a\xa6\xa7\x55\x35\xd3\x7d\x3e\xfd\x13\x5d\xad\xf0\xdc\x0f\xd5\x46\x7b\xb7\xd1\x56\xed\xd5\x68\xab\xf4\x7e\x4b\x4b\xaa\xb4\x26\xc5\xd6\xde\x12\x8a\xad\x3d\xaf\x55\x5f\x51\xce\x13\xda\x1d\x7c\x3b\x50\x65\xe3\x49\x10\xd2\x86\x64\x8a\x73\x2e\x29\x47\x3c\x07\xbe\x8e\xd7\xb3\xbf\xc6\xe5\x28\x9b\x96\xd2\xb4\x27\xe6\x45\x5b\x56\xef\xb2\xb3\x96\x1a\x7f\xab\xcb\x5a\x7a\x84\xe2\x03\xc6\x21\x7e\x20\xb0\xe2\x17\x80\x04\x05\xb1\xdb\x56\xc5\xa4\x2d\x28\xcb\x7c\x9d\xd7\x7c\x4b\x71\x23\x1c\x9f\xa3\x4e\x1b\x83\x79\x26\x25\x19\xad\xcd\xff\x29\x8f\xa3\x3e\xfb\xaa\x2e\xbb\xa5\x12\x03\xe9\x5d\xe4\x75\x59\x96\x86\x32\x76\xb9\x2d\x38\xe9\x30\xee\x2f\x73\x1e\xd4\x35\xe1\xc6\x7a\xaf\x69\xe2\x5d\x9c\xf2\x35\x9b\x78\x9d\x95\xab\xb5\xf0\x3f\x2f\x67\x71\x51\x57\x15\x32\xed\xf2\xbf\x35\x95\xff\xad\x5a\x1e\xcc\x96\xea\xca\x43\x66\x3d\x8e\x5f\x05\x79\xfd\xe4\xc0\x6e\x0d\x8a\x10\xbb\x52\x13\x32\xeb\x6b\x35\xcd\x62\x7d\xad\x8f\x41\xb4\x0a\x88\x1f\x83\x28\x0e\x92\x95\x46\x77\x12\xca\xd8\x59\xb7\xad\xf8\x21\x5e\x01\x2b\xf2\xbc\x5e\x57\x11\x9d\xb3\xd6\xcf\x1f\xf8\x7d\x69\x5a\x62\xba\xc0\x82\x36\x5e\x2a\x3f\x30\x8d\x0d\x55\x89\x0f\x92\x3f\x6a\x5f\x3a\x4b\xd4\x36\x1b\x08\x61\x5f\x5b\x5b\xa0\x6a\x7c\x28\x79\xdb\x43\x36\xce\x22\xf0\x00\x31\x0e\x62\xf0\x5e\x51\xf0\x88\x05\x05\x5c\x44\x4d\x82\x34\xcb\x83\x71\x00\x5e\x21\xe2\x14\xe9\xdf\xda\x1a\x65\x2b\xde\x4d\xec\x8e\xce\x98\x4d\xa7\xcc\xef\xe9\x21\xf3\x64\x9a\x0f\x83\x90\x2f\x3c\x66\x32\xe7\x72\x53\xf0\xf2\x2e\xfb\xba\xe0\x9a\xd0\x79\x5d\xbe\x2a\xe7\x9f\x00\x64\x92\x63\xcc\xf1\x5d\xbc\xa3\xf5\x1c\x07\x13\xea\xa5\xbd\x3e\x40\x2d\xd7\x4e\x6c\x40\x0e\xf0\x7a\xfa\x39\xb8\xa7\x93\x7f\x2b\x8a\xbf\x58\xe7\x02\xef\xe1\xca\xba\x21\xae\xef\xf9\xd9\x00\x8a\xa5\xc1\x98\x17\x96\x36\xc6\x28\x01\xae\x94\x9f\x23\xd3\x62\xc7\x23\x58\x38\x5a\x42\x14\x2e\xd8\x57\x36\xd1\xe1\x0e\x5a\x39\x4f\x02\x21\x47\xb7\x20\xaa\x5b\x91\xe5\x7d\xd6\x92\x3d\xb6\x16\xdd\x15\xd3\x79\xb9\xe9\xca\x09\x70\xc5\xee\xea\x45\x45\x9a\x55\x8d\x94\xe5\x45\xc5\x53\x13\x1b\x9c\x1d\x32\x51\xd0\x76\x5b\x79\x63\x4b\xd9\x4b\xe9\x5e\xfe\xbd\xbc\x6e\xb3\xbc\xac\xfb\x7f\xc3\x47\xd5\x75\x74\x4d\xb6\xbe\x4a\xa9\xd5\x38\x69\xa1\x51\x2e\x3c\x19\x35\x05\x1d\x34\x04\x79\x29\x97\xa8\xa8\x75\xb3\x9c\x22\x54\x7b\x37\x78\x08\xb1\x0d\x60\x21\xf4\x2c\x83\x2a\xf3\x84\x5c\xe7\x0b\x11\xf8\x74\x3e\xe1\x1e\x05\x08\x9a\xcf\x35\x2d\xcc\xa7\x20\x41\x0f\x4a\x51\xdf\x22\xa7\x2c\xe5\xc7\x43\xd1\x6c\xfb\x6c\x85\xda\x05\x18\x17\x35\xdd\xef\xd4\x56\x4d\xc1\xb0\xe8\x5c\x4e\x8b\xdc\x7e\x56\x1a\xc2\x45\x96\x49\xd5\xbe\xa4\xcc\x95\xa1\xc1\x56\x14\x45\xaf\xd9\x4c\x04\xa1\x56\x56\x68\x24\xc8\xf3\x60\x7e\x3c\x6c\x20\xa5\xfa\xd9\x84\xd5\x26\x71\xaa\x02\xbb\xac\x4a\x15\xed\x33\xea\xad\xb1\x4b\x1c\x34\xaa\x59\x23\x0e\x3e\xd6\xea\xa6\x88\x2f\xe1\x3c\xc7\x67\x93\x20\x8d\xc4\x2f\x8c\x96\x20\x0e\x75\x97\x97\x78\x84\x2b\xe2\x64\x94\x4d\x79\x59\x72\xdd\x7d\x39\xca\xb3\xb2\x4c\xf8\x6b\x9e\x04\xf3\xb5\xe7\x4b\x5d\x58\xaf\xb2\x0c\x46\xc1\x84\xeb\xfd\x12\xde\x87\xac\x09\x0c\x53\x4f\x7e\xd6\x6e\x47\xbd\x4b\x59\xbb\x21\x7c\x9b\xb4\x72\x33\x0f\xe8\xc6\xe7\xc6\xa2\xfa\xe6\x8c\x4b\x0e\x6d\xa5\xc9\x06\x9e\x77\x6e\x46\xf2\xaf\x3f\x02\x0c\x33\xf5\xaf\x3b\x04\x1a\x86\x6c\x4d\x3a\x57\xc2\xe7\xaa\xbc\x57\x6e\x67\xcb\x08\xcb\x8b\x76\x55\x6c\x49\xdb\x43\x7d\xf3\xe9\x59\x63\x1f\x02\x39\x79\x35\xb1\x20\x8b\xb8\x9a\xd6\x2c\x3d\x4a\xe2\xf0\xf3\x4a\x43\x17\x62\xbb\x6a\x85\xba\xe2\xbc\x8b\xa6\xa4\xc7\xd0\xbb\x68\x0a\x3d\x7e\xde\x45\x4b\xaf\xb3\xab\xd5\x88\xa4\xd2\xd2\x2f\xab\xb1\x33\xd3\x4e\xc5\xd5\xd7\xca\x62\xdd\x03\x38\x9d\x69\xc9\x97\x08\xcb\xe4\x71\x61\x55\x1e\x56\x92\x8f\x25\xbf\x54\x25\x16\x1a\x93\xc9\xdd\x91\x5a\x3b\xdb\x7f\x69\xd9\x2c\x7e\xcf\x96\x13\xe4\x43\xd0\x7d\xfd\x3a\x77\xdf\x3c\x02\xdd\xef\xca\xed\x72\x5f\xa9\x7e\x3c\x38\x19\x06\x49\xc1\x71\x84\x74\x38\x66\x90\x78\xd4\x7b\x8d\x79\xe0\xb6\x91\x1d\x9a\xf3\x68\xdb\xb2\x01\x69\x74\x1f\x28\xcf\x2f\xff\x9a\x4f\xe7\x75\xfc\x09\x75\x39\x6e\x86\xb0\xb1\xe1\x3e\x61\xf5\x24\xf5\x48\xe5\xeb\x6b\xb6\x6d\x5a\xe5\xc6\xb9\xe4\x6d\xdb\xd4\x55\xaf\xaf\x89\xdf\x44\x51\xd2\x7c\xc9\x17\x3b\x10\x9a\xca\x74\xec\x44\x8c\x80\x73\xde\xff\xf4\x4d\x40\x25\x48\xf8\x8d\x24\xb8\x2e\xb6\x8a\x8a\xe3\x36\xdb\xc9\x16\x77\xbc\x63\xe2\x65\xa3\x3c\xe6\xca\x32\x9b\x3a\xd6\x96\x63\xfe\x64\xa8\x52\x46\x8f\xb8\xd1\xd4\xa8\x63\x86\x1b\x0a\x74\xa2\x84\xcb\x41\xc1\x4d\x9b\xe3\x5a\xe3\xfa\x9a\x39\x49\x12\x3b\x46\x9b\xa2\x42\xda\x89\xfe\x11\x55\x37\xd6\xb1\xdb\xa9\x5e\x64\x63\xee\x44\xec\x36\x6d\x11\x3f\x80\x77\xff\x2e\xa9\x12\xb3\xd4\x5c\x2a\xa9\x5b\x3f\xe9\x90\x4f\xfc\xdb\x03\xbb\x84\xe3\x61\xbb\xf5\x2a\xc8\x5b\x1d\xf6\xc3\xa1\xa2\x04\x34\x12\x33\x08\x76\x83\x86\x57\x17\x7b\x17\x0c\x3e\x9e\xcb\x38\xe0\x64\xe5\x7b\x1d\x99\x3c\xaf\x75\x64\xe2\x75\xc6\xfa\xbc\xd6\x19\xab\xc7\x11\xeb\x73\x27\xe8\xbf\x86\x44\x40\x56\x48\xe8\xdb\x55\x22\x38\x3b\x6f\x70\x41\x00\xcc\xc3\x9e\x44\xd1\x9c\x6c\x0d\x72\x7b\x66\x79\x69\xa4\xc3\x95\xb4\x2a\x27\xe7\xe5\xb5\x59\x7f\x54\x5f\xa7\xc2\x9d\x9c\xf7\xc2\x2c\x0d\x83\xb2\x3d\x28\xb3\xa3\x2c\x2d\xa6\xe3\xe0\x22\xe1\xe0\x98\x47\x42\x23\xb8\x70\x35\x4f\x35\xdd\xa9\x7a\x63\xf3\xdc\x6c\xdf\x74\xc5\x78\x0f\x1e\x50\x20\x0b\x0a\x65\x41\xc0\x64\x3f\xb0\xed\xca\x62\xd0\x85\xac\x05\xa1\xda\xd2\x44\xa8\xd9\x14\x31\xea\x89\x48\x3f\xbd\x2a\x53\xaa\xeb\xcd\x42\x30\xe9\x13\x2c\x70\x5c\x3f\xb1\xca\x72\x54\x00\xa4\xfa\xa3\x9d\x2c\x15\xe5\xd8\x1b\x08\x60\x88\xee\xf8\x0b\x7c\x7e\x66\x3c\x92\x1a\xf2\xec\xdc\x43\xeb\x8a\x9e\x3b\x15\xd4\xc0\xa8\x8a\x24\x0e\x79\xbb\xc9\xc5\x21\x71\x85\x66\x33\x2f\xb4\xc1\x12\x6b\x3d\x4e\xe3\x32\x0e\x92\xb8\xe0\x4a\x78\xd1\x0b\xc1\xcd\x6b\xd3\x25\x0e\x4a\xe6\x67\xb6\x5d\x43\x83\x71\xbb\xc5\x3c\x2e\x32\xf2\x1a\x0e\x0c\x57\xb2\x19\xf8\x0c\x83\x36\x1b\x5c\x2d\x18\x4b\xe9\xe7\x62\xe1\x63\x71\x8f\xad\x74\x95\xa1\x60\xa5\x5b\xf9\x77\x26\x55\x16\x7b\x78\x96\x85\x89\x8f\x67\x5d\x54\x81\xc9\x51\x66\x6a\xcb\xef\xe5\xbd\x5f\x53\xfd\xbe\xf4\x47\x2a\xdb\x20\x81\x9b\xef\xce\xeb\xa5\xb9\x15\x72\xdf\x21\xdc\x54\xe7\xd9\x75\x2e\x67\xcd\x33\xbc\xa1\x0e\xad\x87\xd3\x16\x37\x45\x33\x8a\x7d\x33\x95\x15\x93\x13\xfd\x10\x5d\x16\x95\xaf\xd0\x6d\xbb\x6a\xe9\x7d\x5a\x15\xb1\x83\x5b\x8a\x7e\xe8\x44\x11\x9a\xf1\xcc\x96\x20\x46\xd5\xe7\xe1\x21\x13\xff\xc2\x2b\x5f\x18\x02\xfb\xee\x50\x37\x60\x3d\x0a\xaf\x18\x3e\xbb\xe4\x07\xcb\xf5\x16\xb4\xa7\xcb\x93\x1d\xcd\xba\x1e\x5d\xed\xd9\xbd\x07\x8c\x35\x62\x2e\x56\x80\x74\xdf\xf3\xbb\x74\xef\xbf\xc8\xbb\x7b\x67\xc0\x5d\x76\xfb\x25\xf6\x2d\x16\x16\xb8\x29\xbe\xc3\x10\x9a\x30\x01\x55\x71\xba\x53\x7d\x85\x8f\x52\xbd\x22\x2c\xfc\xea\x3a\xb7\x86\x28\xe8\x5b\x65\x7e\x73\xcb\x54\x3b\x53\xe5\xab\x39\xae\x63\x26\x64\x91\xdf\x37\xf2\xed\xca\x9b\x90\xef\xbd\x41\x94\x75\x18\x65\x78\x3d\x4b\x0a\xd3\xe4\xaa\xa7\x27\x6c\xca\xff\x26\xdf\xff\x1a\x1f\x21\x97\x0f\x45\xfc\xfe\x91\x96\x79\x29\x42\x1b\xdf\xda\x62\xbf\x62\x60\x87\x10\xce\xf7\x70\x83\x81\xc8\x87\x98\x1a\x18\x9a\x5d\xc7\xcb\x00\x5b\x2d\xcc\xee\x82\xe9\x04\x98\x1d\xb2\x6c\x28\xe7\xd4\x6e\x39\x48\x23\x35\x8f\xe3\x60\xce\x2e\xf8\x3c\x4b\x23\x8c\xeb\x91\x4d\xd3\x28\xc8\x63\x5e\xf4\xdc\xd1\x49\x2b\xc2\x23\x45\x23\xef\x83\x72\xd4\x1b\xc7\x69\x5b\xd2\x89\x1a\x7f\x4f\x88\x13\xea\x37\x7a\x15\x73\xe7\xd8\x6a\xeb\xb7\x4a\x5b\xbf\x99\xb6\xe6\xa4\x2d\xe9\xfd\xca\x6d\xcc\x7e\x4d\x44\xa7\xf6\xac\x4a\x6d\xe7\xe0\xa8\x69\x41\x19\x34\x14\xf6\xf7\x43\x1e\x3a\x21\x79\x5e\xf2\x52\x56\x96\x8f\x2e\xdb\x9e\xa5\xe6\x6f\xcb\x7a\x6d\xb5\x10\xf0\x17\x0e\x41\x36\x06\xdc\x5e\x38\x44\xf3\x1e\x88\xf5\x9d\xb9\xb5\x17\x51\x63\xf4\x6d\x67\x22\xfb\xb7\xe9\x97\xae\x24\xd6\x67\x59\x1e\x5f\xc6\xa9\x41\x89\xb5\x2e\xeb\xf7\x88\x1b\xe4\xae\x62\x79\x11\x42\xb0\xdf\x4f\x55\xd0\x5d\x7d\x02\xd5\xb5\xa7\xb7\xef\xcc\xf6\x8d\x87\x21\x37\xed\x61\xcd\xce\x5f\xaa\xe2\x11\x68\x93\x8e\x46\xf2\x79\x84\x91\x8c\xc4\x99\xf5\x7b\x5b\x18\x2a\xdc\x03\xf0\xf7\xbd\xaa\x6a\x85\x61\xcc\x54\xbb\x18\xb7\x8f\xbd\xc0\x09\x8e\xd3\x64\xae\x7c\xfd\x08\x96\x90\x5e\xf2\x42\x70\x41\xc1\x0b\x00\xc7\x65\xa1\x62\xce\x60\x80\x99\x51\xf0\x05\x3c\x44\x4d\x83\x24\x99\xcb\x1a\x11\x95\x8a\x0c\x78\x44\x0c\x42\x39\xca\x91\x77\xc0\x5b\x4b\xd4\x50\x56\x0b\x0c\x8e\xdc\xb4\xbc\x9c\xb6\xa4\x74\xb1\x58\x57\xc5\x6a\xf5\x55\x66\x92\xef\x4f\x9e\x28\x6a\x65\x09\xbe\x58\x8e\x70\x51\x51\xf1\xec\x74\xf7\x98\x58\x7c\x1e\x30\x17\x12\x16\xbd\x73\x9b\xd6\xe9\xc5\x85\x23\xfd\xf7\x68\x9e\x1e\x24\x58\x28\x83\x83\x2d\xca\x9f\xa1\xe0\xdb\x74\x98\xb5\x89\xce\x4b\x10\x2b\x14\x75\xa9\x2b\xe5\x33\xad\xb5\xb6\xf8\x0c\x94\x16\x8c\xa6\xa2\x7c\x44\x4b\x4b\xb2\xe0\x5d\xaa\xd3\x6d\x56\xcb\x54\xa6\x83\x96\xb5\x84\xf9\x35\x1e\x15\x12\x5c\x39\x62\x1f\xcd\x32\x5d\x77\x19\x5f\x8e\x7d\x49\xe8\x79\xf4\x72\x58\xf2\x5c\xdf\x0d\x2d\x31\xa9\xb2\x98\x6f\x4e\x45\xd6\xad\xa6\xd4\x3f\x79\x58\xeb\xc5\x2d\x27\x91\xf5\x7d\x99\xa0\xde\x25\x76\xac\x8b\x27\xf8\x16\xd3\x7b\x27\x93\x2b\x90\x66\xcd\x2d\x49\xf7\x4f\x6c\xed\xe2\x7c\x5b\xf2\x71\xdd\x02\x4d\x4c\x17\x2e\x0e\x48\x08\x64\x1f\x6e\x0d\x03\xc1\xbd\x55\xf4\xd2\x67\xf4\x79\xb3\xb3\x05\xf3\x44\x09\xea\x95\x57\xe4\xd5\x0d\x9d\x14\x96\xa6\x96\xe0\xa6\x44\x48\x49\x3c\xe9\x85\x18\x07\x53\xfc\x9a\x1b\x72\x56\x2a\xaf\x06\x0c\xc0\xf5\xab\x85\x81\x95\xc6\x6f\x6e\x27\x1a\xbb\x5d\xb8\x7e\xc0\xf1\x59\xb3\xdb\xfc\x45\xe4\xc2\x7b\x13\x9e\x17\x71\x51\x5a\xc4\xa2\x53\xdb\x15\x9f\x12\x36\x21\xbb\x2b\x5d\xaf\xbf\xba\xe1\x54\x31\xe8\xe7\x07\xaa\x9c\x8f\x21\x40\x9e\xc5\x11\xe8\x3a\xff\x97\x5c\xae\x30\x24\xdf\x7a\x85\x8c\x5b\x2e\x58\x13\xcb\xb2\x09\xd1\x60\x2d\xfc\xf3\x7a\xd7\x4b\x89\xba\x5e\x42\xef\x21\xa2\x45\x7a\x8f\xea\x60\xc9\xf4\xb8\x16\xc9\x52\x92\x38\xd3\x6d\x9e\x77\xdc\x9d\x7b\xb9\x6d\x02\xcb\x2a\x8f\x9c\x36\xc1\x91\xd6\xc9\xe6\x2b\xcb\xb6\xe5\xde\xb1\xc4\x84\x80\x01\x48\x33\xd1\xab\x22\x0e\xbd\x43\xb2\xad\x68\x5c\x87\xd6\xa0\xb9\x5b\x23\x8a\xd0\x24\x34\x70\x8b\x91\x6b\xa3\x8e\x25\x96\xbc\x2c\xe6\x5b\xf1\x22\xeb\xee\xb0\xa0\x9b\x5c\x07\x13\xba\x91\xdb\x62\xe3\x97\xc9\x12\xb8\x80\x42\x3e\x4c\xfc\x32\xb9\x63\x3c\xfc\x32\x59\x1b\x0b\xbf\x4c\x6e\x81\x03\x1d\x0c\xb8\x71\x53\xeb\xc9\xa3\x24\x94\xe6\x05\xfb\xee\x10\x1e\xa1\x42\x4c\x64\x27\xcf\x7b\x17\xa8\x39\xb8\xb3\x93\x56\x5a\x3e\xdb\x3e\x6f\x82\x59\x19\x0b\x1b\xd9\xc2\xb8\xdd\xab\x1c\xcd\x77\xb6\xed\xb9\x9c\xc9\x30\xe2\x98\x87\xd1\x35\xe8\xb9\x49\xbf\x61\xc5\xfc\xca\x13\x56\xf3\x80\x15\x0b\x54\xdf\xaf\x1a\xbd\x27\x96\x50\xae\x70\x30\x77\xe9\x60\xe2\xfe\x97\xfc\x63\xc5\xdc\xc9\xe0\x8f\x87\x3f\xe5\xb1\x74\x12\x7e\x77\xfe\x1d\x41\x6b\x16\x87\x9f\x0b\x5b\x93\x73\x87\x1d\x50\xd3\xa4\x2e\x4e\x0c\x7d\x27\x03\x8e\x16\x57\xf7\x79\x30\x55\x98\x82\x41\xe0\x21\x1f\x71\x24\x7b\x12\x02\x2f\x79\xba\xb1\x92\x63\x48\x2d\x2f\x76\xba\xb6\xde\x98\xfa\x42\xd7\x11\xfd\xa9\xa6\xd5\x5e\x85\x5a\x63\xb7\x1c\x4d\xef\xd8\x34\x3d\xa7\x34\xbd\x83\x91\x5b\x6a\x69\x7a\x67\x11\x4d\xef\x2c\xa4\xe9\x9d\x7f\xd3\xf4\x72\x34\x3d\xff\x66\x34\x3d\xbf\x57\x9a\x2e\xb3\x09\xfd\x6d\x28\xda\xd2\xf7\x5b\x24\x5d\xf5\x88\x6a\x91\x71\x30\x8b\x8b\x8a\x29\xc4\xdd\xa3\x25\x30\x58\xf1\xc0\xe8\x8d\x6f\x59\x01\xf3\x7d\x30\xb1\x97\x5b\x80\xab\x6d\x45\x0b\x91\x40\x01\xfb\x32\x9d\xcb\xb7\x76\xc7\x43\x6c\xcb\xc0\x8c\xb1\x35\x4d\x97\xce\x25\xd9\x7d\x21\x0a\xce\x64\x1a\x5f\xf6\xe4\x10\x22\x26\xc0\xd8\xd7\x09\x86\xf2\xb2\x3c\x12\x07\xd1\x53\xab\x68\x3d\xbc\xdb\x4a\x2e\x2a\xb2\xbc\x7c\x35\xb7\x64\x22\xab\x03\x32\x37\x99\xf7\x45\x71\x46\xae\x2f\x68\x88\xd4\xae\x0b\x3e\x3e\x90\x0e\x2c\x56\x49\xb2\x5e\x05\x69\x84\x66\xff\xab\x22\xfb\x52\x21\x5b\x35\xe5\xe2\x5b\xbd\x0b\xbc\xf1\x90\x26\x7d\x70\xee\x68\x77\x80\x64\x1c\xeb\x0b\x50\xae\xef\x6c\x37\xdc\xc8\xd6\xf9\x1c\xdc\xd9\x6e\x72\x3a\x58\xeb\x72\x70\x67\xbb\xd1\xe7\xa0\xdf\xe3\xa0\xae\xe4\x71\x39\xe8\xdc\x16\x13\xb9\x89\x4a\xd6\xdf\x29\x1f\xc8\xd7\xd7\x4c\xfd\x56\xae\x28\x11\x57\x22\xc3\x1d\xab\x48\x73\xa1\xf5\xd8\xee\x55\xdd\xb3\x4b\x67\xb7\xda\x2c\x85\xca\xfe\xca\x36\x85\x14\xcc\x79\xa1\xed\xc6\x95\xaf\x3c\x93\x8b\x00\x1e\x65\xe3\x49\xa3\xe3\xb7\x9d\x27\xca\x79\xdb\xd1\x34\xff\xe2\x7f\x4b\x6b\x9d\xe0\xf5\x7b\x4e\xbc\xfd\x93\x1e\x13\x80\x16\x5b\xf6\x28\x0d\x74\x2e\x36\xcc\x4a\x59\x16\xca\x3d\x0d\x65\x9e\x15\xfe\xcd\x50\xe3\xd2\x58\x47\x38\xb0\xbe\x0a\x16\xc0\x69\x4e\x3b\xb8\x14\x3e\xf2\xb0\x84\xd0\xb3\xf4\xd5\xfa\xb2\x20\x3f\x53\x20\xeb\x56\x96\x05\x9b\xde\xae\xe6\xe0\xcc\xa2\x55\xb1\x65\xd3\x30\xa2\xff\x37\x0f\xf0\xd2\x31\x9c\xf3\x8c\x39\x9c\xc9\xa0\xf1\xb4\x50\x2f\xac\xb8\x62\xf2\x96\x72\x7c\x32\xe5\xe0\xfa\xc1\x57\x12\x73\xdc\xd7\xf0\x41\x5e\x82\xab\x09\x5f\x0d\x93\x6b\xd7\xe2\x69\x54\x5b\x47\xe5\xd9\x35\x26\x1a\x21\x6e\x79\xcc\x71\xbd\xb1\xf1\x04\x8c\x41\x75\x47\x9b\x04\xd2\x03\x2f\x99\x58\x9e\x85\x67\x7d\x16\xce\xba\xe0\xbc\x2a\x9c\x77\x49\xdd\x3e\xf9\xdd\xd5\xcd\xf7\xf5\xaf\x2e\x8b\xd3\x94\x4b\xff\x19\x7d\x89\xcc\x2e\xcb\xa6\xa5\x9b\x68\xf6\x95\xdb\x53\xe1\xbe\xa2\xc2\x13\x1e\x96\x99\xdf\xe3\xa1\x43\x82\xfe\xb5\xf1\x55\x22\xb6\x5f\x4b\x68\xab\x80\xb7\x14\xf7\x91\xd0\x11\xe6\x86\x9e\xff\x1c\x87\xfc\xad\x81\xf6\xcd\x80\xdd\xb7\xaa\xfc\xb0\xc1\xf1\x9e\x71\x30\x17\x86\x61\x4b\x75\x6a\xac\x75\x34\x32\xee\xd9\xe5\x9b\x6f\x9f\xe9\x50\xa9\xde\xf5\x77\xe7\xee\x6e\xca\x55\x9a\x49\xf1\x3a\xb1\x94\xd2\x87\xc2\x15\xb9\x8b\xb8\xa5\x98\xdc\xe8\x71\xd5\x3b\x1a\xf6\x62\x2d\x77\xab\xbe\x36\xbb\x74\x82\x3b\x6c\x09\x39\xaa\xc9\x29\xb9\x21\x5f\xbb\xdd\x5a\xd1\xc9\xf8\xb8\xf1\x48\x4f\xcd\x41\x3d\x94\x8c\x0f\x3a\x73\x43\xd4\xe5\x7c\xc2\x75\x2c\x8a\x03\xa7\xac\x0c\x89\x4a\x84\xaf\x33\x1a\xd3\xc2\x0a\xb6\xaf\xea\x60\x7c\x0b\x19\xa2\xff\x7d\x30\x39\xb3\xd0\x68\xd5\x7f\x1b\xb5\xce\xcf\xd7\xa1\x83\x9a\x19\xab\x0d\xe2\x41\xc9\x9b\x10\x6b\x35\x14\xc7\x8a\x81\x38\xee\xed\x20\x4c\x87\x00\xe7\x98\xde\x38\x98\x90\x17\x21\x10\xb0\xc7\xef\x8b\x88\x62\x02\x8a\x55\x9c\x25\xd2\xcb\x4c\x8c\x0f\x64\x24\xe3\x4d\x15\xa1\x12\xb8\x13\xa9\x47\x8d\x0e\xb4\x77\x18\x6d\xad\xe4\x21\xdd\xff\x59\x9d\x6c\x69\x58\x60\x6a\x76\x33\xd3\x11\x78\x5d\x1a\xbc\xf8\x9d\x46\xe1\xb4\x17\x32\x24\xbf\x8d\x2a\x84\x27\x9b\x76\x23\xe7\x5c\xfc\xde\x1c\x35\xa7\x76\xc0\xbf\xad\x3e\xe0\x79\xcd\x80\xe7\xcd\x03\x9e\xfb\x07\x3c\xff\x46\x03\x06\xdd\xd6\xb2\xa7\xba\x9d\x86\x53\x1d\x9d\x6f\x59\xda\x1b\x30\x7a\xee\x29\xe7\x0b\xf0\xec\x9e\xc2\x5c\x4d\x9f\x31\xf5\x7f\xda\x60\xea\x6f\xfb\x81\x7c\xda\xa4\x70\x94\x25\x9c\xf0\x26\x54\x51\x7f\x5f\x6a\x16\x1d\xb8\xf6\xc0\xa3\x49\xbd\xaf\x4e\xe7\xa6\xd3\x7b\xe0\xe5\x5f\x1b\xb9\x72\xeb\x32\x8f\x23\xe2\x8f\xcb\x31\x75\xd6\xe9\x96\xc9\xb3\x49\x96\x4a\x43\xaa\xca\x36\x99\x4a\x87\x68\xa9\x05\x49\x57\xa8\x6c\x71\x2e\x5b\xe6\x98\xea\xa8\xab\x33\xf9\x84\xda\xb5\x16\x6f\x88\x18\xd2\x18\x2f\xa4\xe9\xb6\x48\x8b\xce\x4d\x85\xc8\x28\x1b\xd5\xf4\xba\xb1\xe6\x62\x44\xac\xab\xe1\x0e\xda\x4b\xe0\xd2\x2c\x62\xb7\x81\x45\xe4\xda\x1d\xa0\xb5\xfe\x77\x7b\x56\x86\xa5\xbc\x51\xde\x07\x9d\x0a\x34\xdd\xd6\x7b\xe8\x96\xee\x71\xe9\x58\xe0\x5a\x8b\x56\xc3\x75\x9f\x4a\x59\x32\x76\xab\x73\x38\xbe\xeb\x5c\xe7\xdc\x0e\xa7\x76\x92\x69\x1d\xd7\xc9\x61\xd3\x2a\x45\xd2\x2d\xd6\x6c\x8e\xa1\x56\x71\x92\x6e\x74\x65\xf7\xc3\x55\x26\xda\x37\xe5\xfd\x88\x6e\x6a\x4c\xb7\x95\xdc\x5c\x59\xcc\xaf\xf7\x9d\x18\xe7\x98\xf7\x01\xbd\xa1\xcf\xfb\x01\xdf\xd5\x6b\x58\xba\x0a\x4a\x33\xb6\xc2\x82\x7c\x34\x0b\xed\x2d\xc0\xcf\x26\x6c\x12\x8b\x79\x14\x58\xc3\x2f\xc1\x9f\x60\x7f\x7f\xd6\x20\x2b\xe8\x18\x66\xb2\x68\xaf\x1a\xd5\x49\x3e\x0e\x56\x05\xcc\x03\x62\x8b\x07\x3e\x69\xe0\x81\xae\x58\xf3\xc4\xf3\x16\xa9\xe6\xa1\xe9\xce\x93\x86\xd7\x7e\xde\x77\xa6\xb2\x86\xef\xa1\x69\xe5\x99\xe9\xce\x13\x6a\x11\x8f\x85\xb6\xb6\xd8\xe9\xf1\xeb\x63\x65\x24\x2e\x8d\xfa\xaf\x46\x3c\x35\x6e\x38\x30\xeb\x0f\x90\x21\x8c\x46\x07\xc0\x22\xe2\x44\x96\xe2\xe3\x88\xd5\xd7\x56\x04\x6b\x4b\x3e\x9b\x02\xbb\xb5\xbf\xa1\x55\x97\x5c\x61\x96\xf5\x08\x79\x8e\xd1\x05\xcd\xbd\x16\xc5\x8d\x9d\x16\xe4\x76\x6c\x6f\x03\xf8\xb6\xef\x96\x52\x90\x7b\xe1\x69\xbe\x69\xe4\x7c\x7f\xa8\xbb\x8a\x04\x75\x87\x2f\xcb\xed\x11\xa3\x79\x01\x98\xe3\x54\xd3\xd9\x0b\x6f\x6a\x9d\x40\x57\x2c\xf1\x8c\x93\xfb\x9f\x4b\x3e\x70\xa9\xbd\xcf\x5a\x80\x26\xd0\x03\x38\x4f\x93\x1b\x58\x4c\xc5\x8f\xf7\xad\x0f\x88\xf4\xc6\xe8\x16\xf7\x3d\x72\x69\xee\xdd\xea\xdc\xb5\xb7\xe4\xb9\x6b\x6f\xa9\x73\xd7\x9e\xef\xdc\x25\x47\xa2\x03\xa7\x58\xf3\x59\x81\x0e\xb9\x8c\x55\x47\x1d\xe8\x2b\x10\xfa\xca\xca\x8c\xfb\x96\x29\x56\xd4\x1f\xd1\x13\x85\x38\xc7\x2b\x55\x85\xff\x74\x21\x4a\xcc\x2b\x25\x8c\x75\x04\xc5\x5d\x0d\x3f\xa8\x3d\x17\x2d\x38\x19\xd5\x9c\x8d\xcc\x16\xbf\x78\x21\x58\xfe\xca\x57\xd2\x92\xa8\xb0\x43\x48\xcd\x95\xf8\xe4\x8b\x75\x18\x72\x2d\xc5\x4e\x40\x3c\xef\x42\x22\xfd\x5a\x5e\x5a\xd6\x0c\xe9\xa5\x81\x34\xbe\x44\x3a\x1e\x31\x60\x7f\x95\x3b\xf0\xfd\xc5\x77\xe0\xce\x4b\x69\x5d\xb1\xfe\xb5\xb4\xe3\x37\xcb\xba\x3c\xae\xc4\x4d\xfc\xd7\x8c\x9a\x48\xb0\x6f\x82\x2c\xed\x5a\x21\xa0\x28\x26\xcd\x45\x20\x29\x2d\x2f\x01\xed\x79\xd2\x51\xa8\x68\x41\x99\x4c\x4b\x5e\x04\x05\x44\x93\x70\x8b\xaa\xf4\x2a\x88\x1e\x38\xfd\xc0\x36\x45\x9e\xda\xf5\x87\x9e\x1a\xc5\x11\xf7\x96\x16\x19\xd6\x54\x8f\x82\x42\xd3\xe0\x77\x50\x6d\x63\xa3\x42\x9e\xe6\x19\xb4\x72\x1f\x66\x60\xd2\x1f\x16\x5d\xfe\x70\xc8\xb6\xc1\x53\x18\xa0\xd4\xf7\xb8\xd7\xb2\x1c\xd0\x50\xb8\x97\xd9\x76\x1c\xb2\xa6\xd6\x68\x2d\x1a\x90\x4c\x4d\xe1\xc6\x86\x99\x23\xf2\xbb\x11\x34\xe3\xda\xc6\xe2\x1f\x4d\x9e\x95\x6c\x05\x2d\x0d\xc3\x66\xc5\xf1\x82\xe7\x4c\x10\x76\x8d\x0e\xd1\x8a\x40\xd5\x35\xc3\x20\xc1\x8f\x68\xe8\xa2\xbe\x07\xf3\x1e\xea\xed\xab\x1f\xe4\x34\xe7\x71\xee\x54\x13\xf5\xc8\x8b\x01\x25\xe8\x8a\xff\x9f\xd7\xb9\x89\xf2\x55\x39\xd7\x7b\x8b\x7c\x03\xcb\xc7\xa0\x82\x7c\xb0\xd8\xf3\xb8\xd8\x8f\xb6\x1e\xb1\x51\x90\x8f\xb3\x74\xae\xd7\x3f\x9f\x4d\xb2\x5c\xb0\x01\x36\x18\x5c\xf1\x8b\x49\x10\x7e\xfe\xff\xd9\x7b\xd7\xb5\x36\x72\xa5\x61\xf4\xf7\xe2\x2a\x14\xbe\xf5\xc6\x36\x18\x1f\x38\xe4\x60\x86\xc9\x72\x80\x24\x24\x01\x92\x40\x26\x93\x61\xf1\x40\xd3\x2d\xdb\x1d\xda\xdd\x9e\x56\x1b\xe3\x21\xfc\xda\x3f\xf6\x9f\xef\x02\xf6\x0d\xec\x67\xdf\xd7\x7b\x25\xfb\x51\x95\x8e\x7d\x30\xc6\x90\x99\x79\xd7\x47\xe6\x79\x06\xb7\x0e\x25\xa9\x54\x2a\x95\x4a\xa5\xaa\x13\x4c\x13\xfa\x94\x63\xf0\xd2\x85\x4a\x2f\x9a\x86\x5e\x01\xa0\x0b\x0b\x75\x38\xe1\xd6\x17\xc8\xda\x33\xb2\x50\x17\x49\xea\xcc\x5c\xee\x47\xde\x10\xae\xea\x11\x70\xd5\x68\x2b\xa6\xbf\x0f\xfd\x98\x9e\x9c\x70\xa4\xcd\xcd\x0f\x19\x25\x2c\x89\x7d\x37\x99\xe7\xc3\x42\xde\x59\xf3\x68\xc7\x0f\xa9\x08\xf6\x33\x2e\x2b\x30\xf3\x27\x27\x94\xed\x02\xf0\x79\x94\x45\x44\x04\x28\x7e\x6e\x9f\x83\x0b\x57\x60\x18\xbb\x43\xff\xb0\x47\xfb\x1c\xc2\x85\xef\xe1\x4b\x94\x6c\x0f\xca\xab\xcd\x15\x5e\xe5\x86\x46\x4b\x69\x68\x25\x6c\x9a\x86\xc3\x3e\x8d\x39\x29\xeb\x37\x78\x5d\x9a\x18\xe1\x01\xba\x34\x51\x4f\xda\xe4\x85\x84\x1f\x26\x34\x8e\x06\x9f\xb0\x13\xc2\x91\x63\x39\xd3\xe3\x8a\x34\x48\x85\x99\x37\x86\x36\xf2\x93\xde\x41\x32\x0e\xd0\xe7\x7b\xce\xa0\x9e\x4c\x33\x24\x0d\xe5\x47\x0c\x46\x43\x9f\x38\x0c\x18\x70\xc1\x28\x9e\x2f\x4f\x3b\x0c\x80\xf2\xa3\x46\x01\xc0\x0b\x07\x81\x97\xdd\x72\xea\x0a\x46\xd2\x7c\xfa\x7c\x9a\xa1\xd8\xb0\x7e\xc4\x78\xec\x16\xf2\x06\x65\x7a\x1d\xcb\x03\x11\x9d\x7d\xab\x90\x2b\x65\xb0\x79\xf6\x8d\xef\x0c\xd1\xd9\xb7\x9a\x5e\x96\xe4\x05\xa4\xb7\xc8\x95\xe4\x38\x2d\x48\xb8\x5e\xe7\xfc\xce\x66\x1d\xcf\xef\xc4\x3a\xea\x75\x11\xb4\xd5\x09\x48\x9d\x30\xbf\x3f\x08\x28\x71\xa3\x30\xa1\x97\x09\x39\xf3\x43\xcf\x0f\xbb\x30\x4d\x8e\x7c\xb0\x53\x30\x41\xcb\x2b\x7c\xc9\x60\xbb\x35\xd1\xac\x25\xad\x77\xc2\x2a\x49\x7a\x0e\xc4\x83\xd7\xde\x03\x15\xd8\x72\x27\x84\xdd\x81\x6f\x08\xbc\x18\x58\x9b\x0d\x43\x9c\x69\xaf\xa2\x9c\x58\x82\x7f\x1b\x36\xf2\x13\xb7\x47\xca\xb6\x1f\x42\xd7\x61\x94\x34\x5b\xaa\xa8\x36\x63\xce\xfa\xc2\x0c\x6b\xae\x13\x04\x65\xec\x90\x53\x31\x36\x08\x01\x67\x39\x0f\x4e\x95\x9c\xdd\x04\x8a\x17\xc9\x42\x5b\x29\x80\x56\x25\xee\x14\x00\x79\x29\x73\x0b\xd3\xfb\x96\x86\x56\x5f\x20\xb5\x5a\xcd\x89\xbb\x8c\x2c\xd4\x53\xb4\xdc\x09\x6b\xce\x60\x10\x8c\x25\xc8\xb8\x3b\xe4\x67\x09\x3c\x40\x5c\xe3\x26\x67\x53\xd5\x93\xc6\x9d\xa8\x0a\x0e\x5d\x4c\x5c\x20\xe4\xd3\xcb\x5a\x73\x32\xb9\xf8\x42\x65\x81\x07\x2f\x01\x8b\xa7\x56\x20\x3a\xc1\x88\x70\xb9\x7e\x3b\x8e\xa3\xb8\xec\x27\xfc\x98\x4c\x7c\x46\xc2\x28\x21\x0e\xac\x29\xea\x26\x8f\x4a\x30\x3e\xe5\x82\x31\x77\x9c\xcd\x29\xc6\x09\x43\x9a\xd0\x55\x7a\x49\xc5\x2c\x26\xf1\xd8\xc6\xfc\xa3\x47\x3c\x13\xad\x35\xaf\x89\xeb\x00\xd5\xd2\xd4\xf4\x70\x9e\x24\xf8\x47\xb6\x83\xcb\xd3\x76\x50\xc8\xd5\xfb\xa3\x50\xf2\x45\xb2\x41\xae\xae\x6b\x76\xda\x0d\x38\x87\xe8\xc1\xd8\x3d\xd1\x39\xbb\x3a\x52\xa6\x2c\x97\x8b\xd1\x95\xbf\xa3\x28\x23\x6c\x5b\xd4\xb9\xb2\xe6\x30\xe6\x77\xe1\x01\xbe\x1e\x7e\xe2\xc4\x5d\xf0\xaa\x45\x3a\x51\x4c\xca\x40\xc4\x64\x83\x34\xd7\x89\x4f\x7e\xd2\xab\x46\x3c\xee\x5b\x27\xfe\xe2\x22\x2f\x0c\x2e\x6f\xa2\x61\xec\xf2\xbd\x4b\x95\x3a\xf2\x8f\xd7\x35\x9c\x73\x3a\x26\x7e\x28\x8a\xf1\x4a\x3a\x74\x38\x3f\x7a\x25\x11\x58\x57\xe5\xe1\x1a\xab\x20\xbe\x79\x45\xec\xe4\xd1\x39\x1d\x73\x11\x13\x73\xe1\x6b\x9d\x5c\xc3\x7f\x92\xa8\xa0\xdc\x3a\x28\x54\xd0\xcb\xe5\x78\x40\xa3\x0e\xd9\x20\xe2\xc7\xc1\xb8\x7f\x16\x05\xc0\x66\xe7\x25\x0e\xe6\xe1\xd0\x65\xe6\xf3\xd3\xa1\x78\x17\xc2\x0b\x32\x48\x9c\x27\x2f\xcc\x87\x08\xd6\x7e\x26\x6a\x47\x67\xdf\xd6\xc1\x69\x52\x51\x39\xb1\xef\xdd\xd4\x19\xbe\x2f\xba\x51\xc8\x92\x78\xe8\xca\x5e\x88\xc2\x98\x0b\x7e\x79\x44\x5f\x15\x26\xc9\x0b\xdd\xd5\x96\xdd\x25\x5b\xea\xd8\x0c\x1c\xc6\xd2\xce\x13\xf4\x97\x45\x76\x3e\x65\x82\x44\x74\x94\x78\x9b\x52\x1a\x48\x29\xc2\x40\x3e\x4b\x25\x1e\x65\x6e\xec\x0f\xf0\x95\x0d\x5a\xb9\x71\x2a\xd1\xc9\x35\x2d\xaa\x90\x8d\x82\x74\x4e\xb2\xe0\xc9\xd9\xcc\x77\xa3\xb0\xe3\x77\x87\xb2\x26\x70\x14\xa0\xb1\x79\x58\x0f\xf3\x9c\xf8\x74\xf1\x8a\x59\x75\x14\xfb\x89\x55\x2d\x7f\xc9\xc9\x91\x1b\x35\xcf\xe9\xd8\xfc\xae\xac\x9b\xf4\xa7\x31\xba\xa9\xa7\x0f\x10\x97\x44\xc2\x6a\x95\x25\x4e\xe2\xbb\x1f\x24\x2a\x79\x77\x75\x76\x25\x8b\x7c\x03\x90\x9e\x6a\x13\x64\x65\x5d\x3a\x78\xd2\x70\x27\x41\xb1\xbb\xb0\xae\x0e\x83\xba\xc4\x3a\x88\x5c\x65\x2d\x70\x3b\x71\xe8\x87\xdd\x22\x21\x75\x35\x5d\x10\x2c\x13\x8a\x24\x63\x2c\xa2\xaa\x24\xd1\x26\x2b\x3a\x8e\x34\x9f\xae\xd8\xe5\x26\x01\x86\x02\x76\xf1\x5f\xc0\xd7\x5e\x81\xe4\xf6\xa4\x91\x53\xf8\xc6\x06\xa0\xd4\xfd\xcb\xbb\x2a\xd0\x9c\x29\xf1\xea\x26\xc0\x18\x73\xd3\x09\x82\xcd\x1e\x75\xcf\xcb\xbe\x70\xad\x5b\x35\x27\x4d\x12\xd3\x23\x95\x4d\xe4\x8f\xa8\x63\x15\x04\x86\x0a\xd2\x44\x48\x4d\x89\x62\x7e\xd3\x09\xb9\x2c\xc1\x39\x30\x71\xd0\x02\x94\x38\x8c\x38\x8a\xac\xe7\x91\xda\x11\x6d\x70\x4a\xfb\x34\x0c\xf2\xdc\xb0\xa8\x6f\x55\xa8\x0c\xeb\x46\xc4\xdd\x43\xe1\x5b\xbd\x05\x4c\x8f\x2f\xe9\xf9\xac\xaa\xab\x56\xac\xe7\x7b\x68\x9f\x2b\x62\xf1\xae\xeb\x0c\x9f\x7d\x88\x23\x97\x32\x46\x41\x5f\xae\xdd\xbe\xc3\x4e\xd5\xa3\x70\xd3\x22\x1a\xae\xc1\xb7\xd6\xdf\x7c\x02\x15\x12\x9c\xf5\x65\x09\x99\x64\xdc\x8e\xd1\x80\x22\x37\xd6\x60\x44\x92\xd9\x41\x34\x8a\x57\x31\xf0\x21\x4d\x94\xd7\x35\x8d\x3c\x19\xf7\x18\xfe\x6a\xe7\xde\x12\x74\x45\x94\x12\x9f\x87\xfc\x84\xb2\x41\x74\xc3\xc4\xbe\x36\x80\x31\xe0\x68\x5f\xe0\x5f\x9d\xd1\x82\xf9\x96\x03\x13\xe2\x19\xef\x79\x7d\x61\x81\xc3\x59\x20\x07\x34\xd1\xc3\xc4\xb0\x31\x35\xcc\x69\x27\x09\x0d\x31\x50\x22\x97\x55\x78\x8b\xe8\xe2\xd2\x75\x86\x3c\xb9\x46\x76\x23\x96\x90\xb3\x38\x1a\x31\x1a\x33\xe2\xf9\x5e\x58\x4a\x08\x9c\xac\xb8\x64\x80\x50\xac\x51\x30\x9a\x24\x94\x73\xa3\x08\xc1\xf5\x9d\xb1\x70\x77\xce\xf9\x76\x4c\xb1\xdf\x9c\xef\x44\x1d\xc2\x1b\x8f\x29\xd2\x04\x39\x80\x71\x01\xc8\x3a\xe8\xb3\xcc\x7d\xad\xac\xe8\xa6\x4a\x8e\x90\xbe\x30\xfe\x37\xdf\x7a\x4a\x55\x71\xb3\x25\x86\xcc\x3b\xf5\x9a\x26\x84\x0f\x97\x26\xc4\x11\x51\xa8\x07\x52\x18\x11\x65\xea\x82\x90\xec\x88\xe1\xbc\x54\x39\x84\x6b\x93\x90\x5e\x26\xc8\x1a\xd4\xb9\xa6\x5e\x27\x3b\x49\x89\xaf\x1e\x1c\x68\xcd\xd0\xfd\xa9\xe2\xd2\x9d\x82\xa9\x05\xac\xd7\xc9\x56\xc4\x91\xe7\x45\xc4\x09\xc7\x49\x8f\xa3\x40\xb8\xfe\x43\xef\xa1\x3d\x07\x85\x7e\xe1\x40\x41\x7b\x04\xc5\x63\xa4\x24\xaa\x23\xde\xb7\x63\x10\x15\x72\xfa\xc7\xff\xe9\x7e\x6c\x58\x84\x5a\xfb\xc6\x58\x6d\x10\x0c\xbb\x7e\xa8\xef\xd4\xa1\xa0\xee\x7a\x95\xe0\xd0\x79\x3d\xcb\x8f\x66\xa6\x03\x46\xf3\x96\xf3\xc8\x7a\x5d\x10\x23\x6c\xc4\x3e\x13\xbb\x96\xc7\x87\x01\x93\x08\xf3\x2c\x96\x0c\x39\x0d\xfc\xf0\xfc\x94\x17\xe3\x1b\xb6\xe9\x05\x55\x8d\x3a\x56\xd0\x2a\xf6\x9a\x40\x07\x43\xe3\x80\xa6\xcb\xc9\x41\x68\xfc\xac\x67\x7c\x48\xda\x1c\xc4\x42\x13\x24\x5a\x63\x12\x8b\x17\x0a\x3f\x7e\x2c\x56\xa0\x93\x24\x8e\xdb\xa3\x5e\x36\xd4\x67\xb9\x51\xd5\xbb\xe6\x91\xda\x05\x8e\x2b\x65\xf1\x2a\xb7\x04\x0c\x56\x1c\xf2\x38\x06\xa8\x57\x23\xbb\x3e\x63\x9c\x28\x98\x89\x9f\x79\x9e\x8b\x47\x80\xf9\x5a\xa9\x32\x21\x5a\x68\xe6\x1a\x52\x9f\xc9\xc0\x17\xbc\xcc\x9c\xcb\xe4\x99\xd3\x6a\xb9\xa5\x37\x96\x53\x9b\x9f\xb9\x49\xcc\xbb\x9d\x70\x02\x96\xf7\xbc\xc4\x0f\x03\x3f\xa4\x7a\x49\xcd\x19\x31\xfa\x71\x85\xc2\x71\xfd\x30\x12\xf6\x25\xe9\xe5\x26\x72\xcb\xe6\x2c\x9b\xf7\x9d\xdf\x18\xa8\x69\xc4\x23\xef\xb7\x07\xfb\x7b\xfa\xbd\xa0\x12\x58\xf9\x9a\xe5\xec\x85\x17\x36\xa7\xa3\x80\x5c\x4c\x4a\xe1\x55\xab\x50\xf1\x88\xff\x34\xbc\x95\x64\xb0\x97\xc5\xca\x27\x28\xc2\x08\xef\x16\x89\xe9\xc0\x78\x79\x24\xfd\x78\x72\x94\x49\xec\x90\x57\x4e\x10\x9c\x39\xee\x39\x23\x4e\x4c\x61\xf2\xd9\x70\xc0\x8f\x7f\x6a\xb9\x2f\x90\xcf\x8c\x76\x86\x01\x8c\x0d\x71\x8b\xdc\x8b\x4d\x42\x31\x22\xa6\x00\xc3\x12\x6b\x79\x68\xbd\xba\x2e\xc4\xa5\xa6\x8c\xf4\x95\xd2\x85\xc9\x5b\x90\x76\x00\x75\xeb\x16\xc7\x2a\x8b\xa3\x8a\x28\xbd\xb1\x41\x4a\x4a\x05\x56\x22\x2f\xac\xaf\x96\x3c\xd2\x95\xa1\x74\xa5\x02\xec\xad\x84\xba\x8f\x52\xc5\x98\x1e\xb2\x81\x00\xd7\xd5\x83\x4e\xb8\x35\xaa\xf9\x0c\x6f\x8f\x64\x7d\xab\x06\xac\x47\x43\x1c\xb4\x96\xe4\x85\x90\xfd\xec\xc5\x23\x26\x9f\x83\x29\x9a\x7c\x61\x06\x4c\xf9\x66\xb0\x79\x70\x60\xee\xac\x85\xd3\x74\x00\x65\x0a\x27\x0a\xb3\xcb\x29\x41\x6a\x6a\x56\x05\x2f\x9c\xfd\xf0\x3c\x23\x2c\xc8\xe2\x90\xd9\x32\xc5\x28\xe1\x15\x69\x00\xda\x13\xc8\x4e\x79\x70\x14\x55\xc1\xe3\x6f\x10\x44\xa3\xed\xfe\x20\x19\x9b\xee\x1b\x2d\xd9\x47\x21\x4e\xa3\xdc\xc6\xb6\x25\xf6\x54\x0d\x12\x82\x96\xd4\x23\xb0\x2c\xee\x64\x1d\x19\xa2\xcb\xd2\x79\x33\x9a\x18\xa2\x95\x69\x33\xa4\xc5\xbb\x8d\x8d\xac\xcc\x55\x51\x7e\xc6\xe7\x0c\x86\x51\x28\x95\x19\x70\x33\x3b\x93\xbd\x44\x7a\x0e\xc3\xed\xd5\x93\x33\x66\x71\x21\x01\x31\xbb\x6f\xa9\x41\xd8\x21\xdc\x77\x3a\x86\x00\x07\x72\x87\xdc\x3c\x94\x28\x46\xbd\xaa\x92\xae\xd2\x8c\x47\xda\x7c\x18\xbd\x7a\xfc\x98\x4c\x18\x82\x7c\x03\xaf\xb6\xf1\xf4\x20\x62\x3a\x08\x1c\x17\x8f\x00\x99\x41\x64\x64\x07\xde\x78\xc1\x2e\x2e\xa0\xeb\x8f\x42\x3f\xa8\xb9\x12\x5e\x9e\x58\xab\x24\x3b\xa4\x94\xe2\xdb\x91\xd4\x26\x68\xcc\xba\x41\x85\x22\xae\xb3\x28\xa9\xa4\xd0\xf5\x39\x3c\x49\x0b\xed\x9d\x41\xe3\x64\xc3\x2c\x95\x52\x28\xae\xde\xa3\x42\xb1\xbe\x40\x84\xe5\x07\xf9\xa5\xfd\x89\xec\xec\xbd\xdd\xde\x3c\xdc\xd9\xdf\x23\x0b\x75\x0d\x7b\x80\xa7\x27\xa8\x7e\x67\xfd\xa3\x28\x5a\x53\x96\x8b\x1b\x44\x27\x21\xef\x32\x92\x3a\x60\x95\xb4\xcb\x8c\x24\x6f\x18\x3b\xe2\xde\x45\x26\x51\x87\x61\x35\xb5\x1d\xc8\xf3\xfb\x39\x1d\x17\xa9\x10\x56\xb4\x06\x81\x97\x9a\x74\xbe\xe7\xf9\xaa\x30\x6e\x28\x5f\xfc\xa4\x17\x0d\x13\xad\x47\x59\x2e\xd2\xeb\xdf\x54\x71\x65\x42\xc3\x45\x6d\x29\x98\x3e\xdb\x73\x0a\x6f\xa0\x0c\x1d\x09\x94\x9b\x34\x44\x28\xf0\xa3\xd5\x3a\x3f\xfe\x26\xb0\x4e\x5e\x45\x7c\x87\x21\xbd\x24\x19\xb0\x56\xbd\xde\x77\x12\x1a\xfb\x4e\x50\xeb\x46\x51\x37\xa0\x35\x37\xea\xd7\xfb\x11\xef\x44\x5d\x12\xd2\x12\x92\x4f\xad\x97\xf4\x83\xff\x95\x4a\x5c\x0a\x9d\x64\x18\x3b\x81\xfc\x74\x87\xf1\x05\x65\xbc\x9d\x24\x22\x01\x75\x60\xe1\xeb\x0b\x42\x3f\x24\xa3\x9e\xef\xf6\x08\x75\xe0\x7f\x42\x16\x8f\x86\x81\x47\xce\x28\x3f\x1f\x7b\x35\x40\x9c\xa2\xd8\x0c\x09\xf3\x35\x53\xaf\x93\x43\x7e\xee\xe5\x27\x9a\x1e\x25\x7d\x7e\x7e\x76\xa3\x7e\x3f\x0a\x65\x45\xe8\x07\xe7\x54\xd4\x61\x74\x27\xdc\x87\x18\x94\xee\xf0\xcc\x77\x97\xce\xe8\x1f\x3e\x8d\xcb\x8d\xda\x6a\x95\x34\xaa\xa4\x51\x5b\xae\x92\x66\x05\xb6\xbc\x7a\x5d\x28\x33\x19\x3f\x35\x0b\x1e\xcf\xdc\x98\xd2\x90\x38\x09\xe9\x0c\x83\x80\x5c\xd0\x20\x72\xfd\x64\x4c\x3a\x71\xd4\x27\x51\xa7\xb3\x24\x0b\x84\x1e\x82\x60\x41\x34\x0a\xc6\xc4\xa3\x2e\x0d\x40\x78\x01\x69\x1e\x9e\xdf\xf3\xae\x81\x79\x90\xec\x5a\x6e\xc7\x1a\x93\x3a\x16\x80\x53\xd9\x09\x1d\xab\x91\xc3\x1e\x1d\xf3\x23\x30\xdf\xbb\x8c\x5e\x80\x49\xbc\xee\xb0\xc6\x4e\x11\x6a\x9a\x66\xfb\x87\xbc\xc5\x9e\x13\x0f\x10\xb7\x1c\xf7\x7c\xba\xc8\xd9\x58\x5c\x9f\x31\xb8\xad\x15\xba\x08\x64\xf9\x51\xaa\x9f\x4e\x38\x26\x89\xdf\x87\x89\x01\x58\xc5\x93\xf2\x04\xda\x46\x73\x9a\x62\xa2\xf5\xa3\x7a\x77\xe8\x7b\x94\x8b\xf0\xec\x56\x74\x8b\xe4\xb2\x24\x93\x6d\x92\x05\x4c\xf1\x7d\x60\xc4\x47\x94\xf8\x7d\x3f\xec\x82\x59\x0f\x65\x81\x1f\x26\x4b\x9e\xcf\x60\x4f\x0d\xa3\xa5\x81\x13\x3b\xfd\xa5\x98\x8a\xfb\x21\x2e\x92\x82\xe6\x3e\xcb\x84\x8d\xa4\x2b\x18\x3f\x3f\x92\xb0\xa4\x45\x9a\x6b\x10\x61\x12\x13\xe2\x16\x59\x6e\xe8\xef\x16\x59\xc6\xdc\x7a\x1d\xc9\xfc\xcc\x61\xbe\x4b\x62\xca\xfb\xcf\xf7\x73\x4f\x76\x0f\x6c\xd0\x43\xcf\x89\xbd\x16\x59\x69\xc8\x3a\x89\x5c\x26\x91\x5c\x5f\x7c\x0d\xba\x11\x97\x68\x2e\x89\x13\xfa\x7d\x31\x7c\x22\x13\x5b\x64\xe5\xe9\x9a\xa8\x6d\x36\x03\x38\x61\x51\x9f\x0a\xad\x8a\x58\x22\xb0\x80\x61\x82\xc1\x70\x02\x53\x0e\x20\xa1\x45\x96\x97\xa7\x83\xc4\x69\xda\x02\x24\x12\x24\x9c\xe6\xf3\xb5\x39\x79\x11\x93\xb3\xe3\x19\x49\x8a\x83\xca\xb4\x72\xdf\x0f\x02\x9f\x51\x37\x0a\x3d\x66\x5d\x54\x42\x80\x96\x38\x1a\x86\x5e\xaa\xcc\x22\x29\xf5\x59\x09\xee\x2a\xf1\x5e\x3a\xb3\xeb\x1a\x49\xaa\x41\x99\x26\xce\x3a\x66\x4b\xd9\x43\x1a\x4a\x52\x66\x1b\x39\x9b\xbd\x4a\x32\xda\xc0\xb4\x9c\x36\x1e\xc1\x61\x00\xb7\x31\x69\x63\x52\x29\x0f\x9c\x98\xd1\x57\x41\xe4\x24\xf2\xd0\x26\x2d\xd4\x16\xe6\xc8\x02\xf9\x17\x50\x2f\xb9\xc2\xee\x7c\x87\xd3\xdd\x35\x5e\x34\x99\xd9\xb8\xbe\xaf\x09\x7c\x66\xeb\x89\x0c\x30\x09\x35\x73\x31\x98\xb7\xcc\x95\xe4\x5f\x5c\x1f\x57\xe6\x04\x08\x34\x70\xc6\x73\x7c\x89\xa9\x25\x25\xac\xeb\x70\x45\x61\xfd\x96\xf8\xcb\x09\x4f\xb6\xd9\x52\xbf\x78\x2a\x6a\x3c\x0d\x79\x15\x13\xac\x18\x7f\xf2\xcd\x40\xfa\x12\x97\xfc\x8c\x16\xa3\xfa\xda\xb6\x81\x6a\x42\x25\x59\x91\x17\x76\x66\x8b\x1c\x95\x9c\x20\x90\xee\x2c\xc4\x49\x50\xe8\xb4\x73\xc0\x37\x6d\xf0\xcd\x49\xe0\x9b\x1c\xbc\x54\x2f\xa0\x0c\x85\xa0\xff\x69\x30\x1b\x79\x2e\x35\x51\x80\xff\x64\x8a\x72\xac\x91\x53\x3d\xd5\xb6\xcc\xa8\x49\x66\x43\x5a\xd9\x5a\xba\x05\x95\xa5\xb6\x6f\xd9\x1b\x3d\x49\xf8\x0f\xbf\xb3\x3d\x91\x15\x53\xfd\x10\xac\x5d\xed\xee\x66\x37\xd2\xa0\x75\xff\x38\x01\x99\x18\xe1\xdf\x06\x3a\x44\x76\xba\x7c\xaa\xe9\x86\x35\x64\x1b\x04\xc6\xac\x12\xca\x90\x22\x79\x56\x2f\x4f\x75\xee\x3f\x2a\x49\xdc\x95\xaa\xa4\x84\x03\xe0\xbf\x00\x7c\xe9\xb8\x22\x5f\x95\x88\x93\x46\x8d\x86\x17\xb5\xbd\xfd\xad\xed\x93\xed\xbd\x5f\x80\x3e\xe6\x07\x71\xe4\x0d\xc5\x35\xf8\x0b\x5b\x39\xaa\xdb\x53\x3c\x4a\x5c\x47\x7f\xff\x4e\x6c\xcd\xce\x40\x84\xbd\x2e\xed\x8a\x1d\x76\xe9\xf3\x4e\x4b\x11\x1c\xb4\x32\x60\xf3\xa4\x3f\xe4\x3b\x11\x05\xa5\x3f\x5e\x33\xc4\x08\xa8\x54\x21\x2d\xcb\x95\xdb\x9d\x3b\x2c\x18\x9e\x4d\xaa\x13\x7a\x28\x0b\x9a\x9d\x44\x36\x42\xce\x86\x09\xe9\x70\x7e\x4f\x4a\x64\x31\x45\xfc\xf7\xde\x6f\x81\x68\x93\xac\x27\xf4\x1a\x8b\x65\x11\xfb\xe3\xf0\xc9\x09\x6b\x12\x1a\x79\xfe\x8f\xef\x0f\x24\xc3\xe9\xd2\x58\x14\x7c\x0d\x55\x24\x43\xe4\xab\xaf\x91\xee\xe7\x30\xe4\xf2\x44\x37\xf4\xff\xa0\x9e\xea\x74\x99\x55\xc8\x11\x9f\xd9\x09\x40\xbf\x45\x7e\x58\x2e\x55\x4b\xb0\xc9\x1f\x5b\xa3\x31\x0d\xac\xca\x79\xab\x82\xbc\x10\xbb\x42\x8b\x80\xd2\x93\x1d\xa7\x9f\x2c\xa3\x38\x45\x3d\xbe\xd6\x33\xfa\x0f\x33\x13\xcc\xcf\x78\x57\x95\x94\x92\xa6\x46\x59\xc0\x62\x8b\xd9\x5a\x30\x8b\x42\x91\x62\x8c\x0e\xed\xd6\xd1\x6a\xb5\x3d\x4c\x22\xf4\xf5\xb0\xa5\x76\x43\x53\x53\x93\xcd\x2f\x0b\x2f\xb5\x62\x04\xa8\xd5\xb2\x92\xd4\xa0\x1a\x96\xde\x16\x5e\xf0\x44\x70\x73\xce\xf7\x64\xf1\xf6\xb3\x4e\x56\x9e\x08\xf4\xd6\xeb\x4a\x84\x1f\x8d\x46\xb5\x51\x14\x74\x62\xa7\xef\x04\x83\x9e\x03\x07\x4f\x3f\x1c\x0c\x93\xfa\x0b\x7f\xa3\xbc\xba\xf8\x5f\xcb\x2f\x17\x9b\x6b\x8b\x0b\x8b\xe5\xcb\xc5\xff\x5a\x7e\xb5\xb8\xf2\x64\xb1\xb2\xb8\xb0\xb0\xd8\xa8\x2d\xaf\x41\xa6\x4a\xaf\xc0\xdf\xb5\xca\xe2\xc2\x62\xb3\x61\x4e\xa3\x21\xe1\x95\x57\xc9\x22\x69\xae\x91\x05\x4c\x1c\x44\xa3\xb2\xec\x29\x9c\xb4\xd6\x38\xca\x55\xdf\xeb\x64\xad\x42\x16\x48\xb3\x51\x51\x66\x76\x13\x14\x41\xd7\x68\x78\x35\x49\xb3\x54\x5e\xa9\x54\x2a\x69\x3d\xd5\xda\xdf\xcb\xf0\x2d\x2b\x54\x3d\x7a\x24\xef\x17\x46\x7e\xe8\x45\x23\xbc\x30\x30\xae\x14\x1e\x3f\x16\x39\x35\x2f\x72\x91\x73\x64\x93\x6a\x96\x73\xb2\x3c\x23\xce\xac\x7e\x2f\xa3\xd3\x7b\x32\x09\x57\x39\x4f\x2a\x6e\xa1\xdf\x9b\xed\xa9\x86\xea\xc4\xa5\x25\x86\x6b\x99\x52\xd0\x52\xda\x4c\xfc\x52\x9a\xd0\x56\xb2\x96\x90\x4f\xef\x6c\x43\x7b\xc6\xe5\x21\xb6\xe7\xc8\xe7\x7a\x39\x94\xf8\x74\xf5\x59\x45\x29\x6d\x27\x99\xf9\x3c\x05\x8b\x5b\x79\x54\x78\x4d\x13\x54\xb6\x84\x08\x5c\xdf\x2d\x26\xe4\xf4\x9c\x8e\x4f\x49\xd4\x21\xa7\x28\xf2\x9c\xd6\xe6\x88\x38\x5f\xc4\xfe\x05\xc4\x45\xd4\x32\xfd\xbe\x38\x4c\x60\x51\x50\x2b\x88\x9f\x49\x44\x7e\x1f\xd2\x78\x5c\xcb\x3b\x22\x9c\xd3\x31\x94\xe5\x7f\xc5\xad\x1f\x3f\x40\x46\x1e\xaf\xd6\x05\x9b\x86\x05\xf2\xaf\x58\xdc\x15\x5e\x2d\x5c\xab\x7b\x43\x5e\x54\x9f\xa0\x3a\xc4\x4f\x4a\x4c\x8c\xa2\x8a\xfe\x22\x4f\x15\x49\x43\xcf\xeb\x73\x26\x7f\x44\x64\x96\xb1\x8f\x86\xb9\xab\x79\x49\x27\x31\x69\x95\x32\x6c\x89\xcd\x69\x91\x67\xb7\x17\xa2\x76\xcb\x54\xca\x5e\xe7\xd8\x0d\xab\x3e\x64\x09\x66\xe2\x2b\xa0\xfb\x59\x15\x7e\x5f\xae\x06\x38\x5f\xdc\xec\x91\x5a\x04\xeb\x2d\x52\x2a\x73\x9a\xba\x07\xf0\x27\x9a\x4b\xe5\x34\x53\x0b\x27\xbc\x03\x4d\x83\x9a\xad\x43\x4d\xf9\xf2\xb6\x48\x07\x7c\x47\xb0\x77\x18\xa0\x82\x31\x5b\x17\x96\xc1\x71\x08\xdc\x15\xb3\xc2\xe1\x35\xee\x03\xf6\x1d\xc6\x68\x03\x9a\xad\x33\x2b\x27\x31\xf5\x86\x2e\x3d\x71\x19\x3b\x71\x9d\xc0\x2d\x1c\xed\xb3\xd5\x19\xa7\x33\xa7\x89\x3b\x0c\x3a\x07\xda\x6c\xdd\x5a\x45\xb3\xc1\xd0\xe9\x4f\x98\xe2\xe5\xfb\x80\x7d\x87\xd1\xda\x80\x66\xeb\xcc\x5a\xd6\x33\x48\xa1\xc1\xec\x6c\x2d\x3c\xc9\x79\x54\x5e\xd4\xc4\xca\x6c\x4d\x3c\x95\x83\xd8\xdf\x9d\xdc\xc0\x32\x5e\x3c\x3d\xbc\x60\x78\x30\xd9\x7f\x30\xd9\x9f\xd9\x64\x1f\xb8\x8e\x78\xf4\xbd\x6c\x5d\xca\x16\x28\xf4\xb8\xd4\x07\xd4\xca\x24\x11\x20\x22\xd1\xf4\xcb\x24\x1f\x1f\x2e\x6d\x25\x22\x78\x8d\x1a\x78\x0d\xd9\xef\x94\xfd\x0a\x78\x23\xa8\xc0\x55\xa9\x1f\xca\xb9\x7d\x34\xd5\x8a\x81\x0e\xf8\x15\xb3\xb2\x58\x34\x3e\x5f\x32\xd1\xd9\x37\x20\xc2\xec\x4a\xf9\x5b\x5b\xca\xeb\xae\x0d\x22\xc6\xfc\xb3\x80\x1a\x0d\xa0\x74\x5f\x66\x34\xe8\x54\x01\x98\xea\x1a\x4f\xb2\x5b\xd7\x9e\x91\xb0\x0b\x70\x29\xd6\x73\x58\x58\x4a\xc8\x19\xa5\x21\xf1\x43\x3f\xf1\x9d\xc0\x67\xd4\x23\x4b\x84\x0d\x07\x34\x2e\x57\xac\x12\xbc\x05\xea\x61\xd7\x04\x12\x61\x04\x8f\x1f\x13\x79\x46\x86\x6f\x78\x90\x84\x74\x32\xcf\x97\x71\x26\x4f\x8f\x92\xbc\xc0\xe4\x16\xe1\x3d\x4e\x4d\x86\x1f\xf6\x68\xec\x27\xac\xcc\x86\x67\x9b\x48\x90\xd0\x2d\xf8\x2d\x87\x2a\x80\xeb\x0c\xd4\xbc\x59\xef\xa1\x52\x99\xc2\x62\x3a\x7f\x6a\x0e\x78\x59\x7e\xd0\x8c\x29\x63\xbc\x1b\xa0\xfe\xa3\x3e\x28\xb5\xcf\x28\x46\xaf\x8b\x62\x63\xae\xaa\x70\xc7\x3c\x4f\x16\x49\xa6\x2f\x80\x2a\xd9\x7b\xe3\xa5\x95\xda\x8f\xc4\xad\x8b\xd1\x41\xab\xbb\xe6\xf2\xbf\x22\xc6\x93\xae\x16\x2c\x32\xd0\x5d\x68\xe4\x98\x4f\xb6\x85\xfd\xaf\x64\x7a\xe2\x0d\x37\x31\xf9\xa7\xb4\xad\x23\xd7\x92\x9f\x18\xc8\x15\xfd\x63\x94\xaf\x71\xec\xc2\x7e\x47\x79\x7c\x4f\xa5\x17\x4c\x90\xee\x5b\xed\xe4\x04\x46\x02\xbb\xb6\x2e\x02\xf3\xad\xfe\x81\xe6\xcc\x09\xdc\x61\xe0\x24\xf4\x4b\x14\x7b\xe0\xb8\xd5\xda\xb5\x72\xb2\xa5\x62\xd2\x7e\x49\xca\x61\x8d\xa2\x18\xb6\xfe\x47\xb7\x3f\x51\x95\x2b\x65\xdb\xe7\x8e\x52\x7c\xaa\x94\x9a\x32\xa2\xac\xd4\xd8\x20\xf0\x93\x72\xfd\xdf\x6c\xb1\xce\x47\x7d\x64\x5c\x73\x41\x27\x38\xb7\xdc\x8c\xfa\x83\x61\x42\xb1\xd7\x64\x03\x33\x52\xba\x53\x9e\x96\x51\x2f\x5e\x41\xd1\x16\xfc\xbf\x3a\xb5\x3f\xb8\xac\xbc\x74\x34\xef\x4a\x3f\x94\xd8\xf1\x03\xff\x0f\xe1\xe3\x07\x41\xe3\xf8\xd0\x10\x57\x78\x7a\x93\x51\x86\xa4\x95\x20\xc8\x3c\x03\xc7\xa5\x72\x14\xf7\xdb\x8f\xd2\xbf\x2f\xdb\x8d\x52\x5e\x4f\x6c\xd5\xf4\x55\x01\x5a\x5b\x05\xe9\x55\xa3\xd3\x2d\x73\x00\xd7\x13\x9f\x18\x4b\x17\x55\xd7\xea\xde\x5d\x18\x6a\x96\x71\x5f\xe4\x12\xa8\x9b\x11\xac\x4e\x36\xa5\x27\x24\x04\xa7\xd9\x18\xaf\x5d\x25\x46\x3e\x8c\x4a\xd5\xe4\xd9\xd6\xfd\xeb\x49\x4c\x3b\x06\xe2\xa1\xd1\x2a\xfa\x84\xaa\xf2\x4c\x69\x8f\x9b\xff\xfe\x09\xcc\x4e\x45\x09\xb5\xfd\x9e\x04\xe0\x57\x2a\x2d\xd4\xc2\xf3\x76\x3e\x0c\xe1\x19\x27\xa0\x61\x05\xef\x0f\x50\xda\x83\x5f\x3f\x41\x6d\xfc\x00\x59\x4f\xd0\x29\xaf\x7a\x74\x22\x24\x53\x2d\x08\x43\x8a\xa5\x1a\x97\x4e\x22\x62\xaa\x91\x88\x3f\x7a\x18\x8a\xb0\x78\x8b\xc3\x21\x41\x20\x43\xb2\x01\x43\x33\x58\xca\xf7\xef\x92\x2d\x75\x6d\xb6\x04\x28\xa8\x80\x78\x20\xde\xf2\x73\x00\x55\x72\xc4\xc1\x29\xd7\x40\xbc\xff\x95\x4a\x45\x60\x56\xfe\x45\x4f\x60\x46\x9c\x18\x20\xad\x97\xe3\xf7\x7e\x48\x19\x5f\xe3\x38\x32\xe9\x18\xa7\x3a\xa9\xf7\xc6\x94\xe9\x57\x53\xd6\xa3\x23\x24\x0d\xeb\xbd\x91\x72\xa8\xf5\xc5\x0f\x82\xdd\x68\x18\x26\x05\xd6\xdc\xd9\x82\x86\xe1\x29\x0c\x05\xfd\x27\x7e\x31\x06\x80\xb6\xb4\xe8\xbf\xca\x0a\x75\x97\xb5\x87\xb6\xc0\x7f\xa2\x2e\xf5\x2f\x40\xcc\x64\xd3\x74\xc7\x2c\x0f\x6f\x7f\x3e\x68\x6e\x4d\x54\xcc\x6f\xea\x6d\x4a\xc6\x2e\x0d\x80\x6d\x66\xab\x1e\x21\x7d\xb0\x93\xb9\x70\xa1\x4b\xe3\xe3\x2b\xbb\xa8\xf1\x2c\xae\x18\x19\xaa\x78\xd5\xee\x4c\x31\x52\xb2\x40\x0a\xb0\x91\xd3\xda\x20\xaf\x25\xf3\xdd\xd7\x7e\x18\x8c\xc9\x80\xc6\x9d\x28\xee\xab\x2d\x0f\x8c\x25\xfc\x0e\x19\x82\x29\x40\x87\x3a\xc9\x30\xa6\xc2\xdc\x4c\x9c\x7e\x49\xd2\xa3\x7d\x52\xee\x0f\x83\xc4\x0f\xfc\x90\x56\x09\x73\x9d\x80\x1e\x46\xaf\xfc\xa4\x62\x98\x94\x97\x4d\x67\x9e\xdf\xbf\x4b\x76\xab\xcb\x72\x21\xe4\xd1\x8d\xac\x3d\xef\xd4\x7f\x34\x1f\x0a\x97\xa3\x07\x4c\xf8\x1b\xb5\xa2\x12\xe3\xeb\xb5\xdc\x81\x9b\x3b\xa6\xda\xf9\x8b\x37\x7c\xeb\xd9\x14\x07\xab\xeb\xa5\xdf\x49\xdd\xb8\x0f\x63\xb5\x5a\xc1\xe6\x91\x7a\x73\x45\xec\x1d\xd0\xa8\xaf\xd3\xb5\x03\x4c\x83\xf0\x26\x8b\x02\x99\x8c\xf5\x2c\x04\xab\x61\xb3\x35\x5d\x2e\x13\xfd\x29\x8f\xee\xc5\xe9\x4d\x4d\x42\x1e\x4a\x89\x7a\xb1\x60\x00\x37\x4c\xe6\xe7\x32\xd8\x15\xf4\x2d\x57\xb0\x35\x75\x36\xdf\x29\xda\xa5\x53\x83\x94\x82\x80\x19\x02\x57\xe3\x42\xc6\xfc\xbf\x4a\x71\x66\xab\x2f\x3a\x8e\x4a\x06\x31\x53\x23\xc5\x1c\xfb\x64\x56\x90\x06\x71\x33\x4f\x28\x68\xd4\xe2\x8f\x7f\xb9\x1c\x7b\x13\xc6\x8f\x44\x82\xc0\x3d\xb9\x3e\xd6\x9e\x49\x73\xf6\x93\x3c\xba\x28\xda\x4b\x72\x69\xe8\x66\x21\xaf\x4a\x38\xff\xfb\x82\xbe\x8d\xad\xb7\x4d\x8a\xc9\xd9\x1b\x8d\x4e\x4f\x07\xd9\xc8\x6f\xac\x86\x4a\x68\x43\x76\xc7\xa7\xc7\xb0\xc9\x77\x96\xd3\xaf\x74\x38\x10\x11\x08\x79\x19\xa8\xdf\x66\x2a\x66\xac\xe5\x65\x4b\xe0\x25\x3a\xee\x59\x4c\xc3\x44\xb8\xad\xc4\xb6\x8e\xf0\x8f\x34\x12\x59\x22\x4d\xd3\x1d\x22\x44\x4e\x34\x6a\xf1\x43\xba\x42\x0a\x11\xa7\x60\xce\xfd\x0d\x94\x7c\xff\x6e\x36\x24\x36\x88\x45\x22\xff\x1a\xec\xe7\x27\x03\xc1\x36\xbb\xad\xd7\x09\x9f\x2c\xe2\x3a\x21\x18\xcd\x78\x60\x9e\x8b\x2f\x39\x2f\x7d\xb4\xfe\xe6\x75\x8d\x2a\x56\x9b\x70\x2c\x1a\x0c\x59\x0f\x4f\x43\xeb\x45\xe5\xb0\x4f\x1b\x39\x9d\x33\x1e\xf6\x64\x99\x61\xbd\x4e\xda\x9e\x47\x3a\x7e\xcc\x12\x9c\x96\x24\x82\xfe\xf0\x33\x3d\x7c\x83\xa1\x70\x44\x82\x28\xec\xf2\x3c\x03\x3d\x51\xf1\x10\x50\x8e\x19\x89\xf9\x51\xeb\xe1\x88\xff\x3d\xb6\x83\x27\x9b\x01\xf6\x88\x98\x4a\x1c\xb0\x00\x60\x86\x7e\xca\xb8\xb7\xc4\xf2\x8a\x29\x55\xc9\xd1\x71\xf1\x52\xc3\xc7\x4e\x05\x6b\x0b\x33\xcb\x79\xbe\xf7\xad\xb5\x61\xf9\xae\xbf\x54\x3e\xf5\x6b\x9e\xed\xd5\x7e\x6c\xe4\x58\x21\x2b\x12\x7a\x99\xb4\x43\xb7\x07\xca\x60\x51\x42\xa7\x99\x25\x65\x40\x95\x74\x69\x3b\xdd\xac\x61\x2d\xe7\x93\xf4\x52\xce\xc4\x27\xd1\x85\x9c\x74\xc4\x49\x3e\x9f\x6f\xec\x08\x43\x35\x9d\x66\xc5\xe7\x70\x06\xe9\x82\x2a\xc9\x2a\x27\x23\xa0\x19\xe5\x64\x52\x1a\x3f\x2a\xa0\x61\x91\x76\xf5\x44\x08\x8d\x47\x25\xef\x12\x6c\x22\xc7\xfc\xff\x1a\x8d\xfc\xcb\x46\x13\x4f\xd1\xa8\xe0\x5f\x30\x66\xfe\x43\x8f\x8b\x7f\xa9\xce\xc3\x87\xec\x61\xe9\xb8\x62\xbd\xf6\xcc\xdb\xe1\x31\x6a\x96\x99\x93\x0a\xbc\x3b\x85\xeb\xe6\x1c\xa7\xf5\x54\x3b\xad\xdf\x8f\x0f\x12\x21\x46\x2a\x34\xd5\x2e\xc1\x66\xf3\x07\x01\x1f\x57\x6e\xe1\xf4\x9d\xaf\x06\xa3\x5f\x64\x51\x5e\xee\xdc\xb6\x57\x79\x7e\xfa\xbd\x4b\xbe\x59\x7b\x97\xa4\x45\x1a\x76\xbc\x29\xab\xd5\xf1\x3d\xb7\x3a\x86\x56\xc7\xa2\x55\x73\xeb\x4c\x9c\x38\xd9\x1a\x67\xc2\x14\x4b\xb7\x82\x36\xf9\x99\x58\x04\x67\x7e\x25\xa8\x5f\x6a\x99\xab\x57\x41\x9c\xe9\xf2\xb8\x5c\x29\x83\x30\x51\x2e\x91\x45\x63\x55\x2e\x92\x52\xc5\xf6\x5f\x70\x16\x53\xe7\x7c\x3d\xd5\x9d\xbe\xef\x79\x01\xfd\x61\xfd\x29\x9b\xcb\xc2\xd8\xa2\x2b\xa4\x4e\x96\xc1\x88\x71\x81\x80\x8f\x7a\x83\xf1\x2c\x82\x61\x63\x76\x38\xbc\x4a\x65\xf2\x98\xe4\x33\xb7\x3f\x7d\x34\x85\x23\x99\xd4\x5f\xcb\xdf\x7b\x12\x3b\x21\xe3\x47\x5d\xce\x57\xb4\xc8\x09\x0a\x69\xe3\x48\x6a\x0b\x54\x86\x24\x63\xb1\xa6\xa3\xc6\xb1\x94\x9f\x14\x7f\x55\xf0\x71\x97\x45\xae\x08\xc3\x32\x04\x40\xdc\x9a\xeb\x06\x60\x7b\x0c\xd7\x46\xb7\x80\x91\x5a\xde\x1f\xd2\x4d\xc4\x11\x08\xca\xbc\x0d\xdc\x78\x16\x09\xe7\xae\x64\x91\x5c\xea\x9f\xe3\x09\x4d\x18\x10\x6d\x77\x9d\xd6\x8e\x51\x53\xc5\xe0\x52\x53\x55\x41\x1b\x58\x52\xca\x7a\x8e\x96\x2a\xb8\xe9\x6d\x6f\x6a\x8e\x6d\xbb\x58\x56\xdd\x80\xed\xc7\x08\xe6\x62\xbd\xe6\x9f\x51\x7b\x30\x55\x6c\x5d\x35\xfe\x4a\x35\x1d\x86\xe1\x32\x15\x7c\x61\x9c\xbb\x23\xb7\x6e\x6d\xba\xc1\x57\x83\x8e\xb9\x0b\xe3\xd6\xe0\x2a\xf9\xe2\x4e\xcb\xf8\xad\x25\x3a\x33\xb6\x8b\xb9\xa8\xec\x9b\x00\x54\xdf\xa4\xa2\x32\xdc\xf7\x04\xe2\x24\xb2\x81\x13\x96\xec\xf3\xc8\x15\xa2\x92\x78\xe3\x16\xf6\x01\x2d\xd0\xc9\x0b\xc5\x54\x5a\xc6\x6a\xaf\xa2\xb4\x89\x05\xaf\x6d\x48\x81\x96\xe9\x15\x51\x1a\x05\xf2\xa2\x9c\x56\x0a\xdf\xc4\xe3\x83\xf9\xeb\x69\xac\xbe\x8e\xe6\x95\x96\x7d\xfe\xb8\x52\x15\x2a\x72\x58\xeb\x87\xe3\x01\xb5\x83\x47\x5f\x4f\x8a\x6d\x90\x4f\xa7\x78\x85\xf1\xe1\xd3\xf6\xc1\xf6\xde\x61\xfb\x70\x67\x7f\xef\xa4\x7d\x78\xf8\x69\xe7\xe5\xe7\xc3\xed\x03\x4e\xa5\x48\x99\x9a\x81\x4d\x22\xb9\x7c\x83\xb0\x9a\x53\x3b\x8b\xa2\x80\xe3\xd3\xc1\x98\xe3\x33\x40\xc0\x57\x1f\x1c\x86\x49\x97\x33\x00\x8a\x42\xba\xdf\x29\x1f\x89\x5d\xbc\xaa\xf6\xcf\x2a\x29\xd1\xd0\xe3\x7f\xc4\x35\x47\xe9\x18\x28\xdc\x96\x06\x7e\x44\x93\xd8\x0e\xe8\x77\x67\x03\x0f\x1c\x6a\xee\x5a\x53\x87\xc8\x33\x03\xc4\x5f\xb6\x08\xbc\x22\x1d\x8b\xbf\x9a\xea\x5b\xa4\xd4\xa4\x7d\x58\x38\x6a\xb3\x6e\x91\x52\xa3\xf6\x14\x92\xf9\x41\x73\xd7\xe9\xfa\xae\x7c\x78\x03\x2f\xa5\xbd\x95\x14\x51\xe0\x35\x6d\x6a\x7a\xe4\x88\x73\xd0\x08\x23\x47\xd8\x7e\x98\x38\xe2\x19\xab\x93\xa0\x33\x35\x75\x3a\x45\x46\x45\xea\xca\x9e\xfb\xe0\x97\xd7\xe4\x8c\xf6\x9c\x0b\x3f\x8a\xe7\xe4\xa5\xc5\xb2\x30\xbf\x9e\xd1\xfa\x5b\x5e\x30\xd9\xe6\xb8\x13\x3d\x6b\xdf\x8f\x39\xae\xe8\x5e\x59\x78\xda\xae\xd8\x1d\xd5\x86\x75\x5e\x39\xb7\xbd\x79\x67\xbe\xaa\x8e\xc1\x65\xc3\x97\x40\xdf\x19\xac\x83\xe6\xea\x1e\xdb\x3a\x2b\x68\x8b\x05\xbe\x4b\xb1\x35\x70\x14\x1e\xc7\xf0\xec\x0e\xdf\xdc\xa8\x5b\x7f\x71\xed\xd8\x87\x60\x50\x50\x86\xef\x13\x58\x05\x20\xa8\x64\x84\x97\x36\x8e\x7e\x3a\xd1\x23\xf5\x9f\x6d\x1c\xfd\x43\x8c\x85\x1b\xf7\x60\x2c\xdc\xb8\x9b\xb1\x70\xf3\x07\x1a\x0b\x37\xef\xcb\x58\xb8\x79\x0f\xc6\xc2\xcb\x3f\xd0\x64\x76\xf9\xbe\x4c\x66\x97\xef\xc1\x64\x56\xc6\x1a\xfc\x30\x8c\x29\xfa\x18\x2c\x26\xdb\xb5\x59\x4d\x84\x6f\x67\x33\xfb\x60\xcf\xfa\x60\xcf\xfa\x60\xcf\x7a\x57\x7b\x56\xf8\xbb\x2c\xe4\x9f\xf5\x07\xcb\xcf\x07\xcb\xcf\x07\xcb\xcf\xbf\xcc\xf2\x53\x3a\x60\xe9\xf8\x01\xdd\xbf\xa0\xf1\x85\x4f\x47\x64\x2b\x4a\xe6\xd0\x2f\xb3\xb4\x09\xc5\x70\x7a\x37\x2a\x94\xf2\xf6\xec\xbc\x08\x84\x65\x65\xb3\xa7\x2c\xd0\x04\x5b\x98\xd2\x8c\x6f\x2b\x9a\x64\xc5\xb7\x15\x69\xf3\xab\x7c\xc3\xbc\xad\x48\xd9\xe5\x49\x6d\xce\x8d\x86\x6f\x5b\xd1\x54\x06\x6f\x1c\x74\x45\x85\xad\xe1\x35\x75\xd8\x9a\x02\xcb\x33\x18\xcd\xd1\x0f\xbd\x35\x74\x8d\x5b\xc3\x9c\x58\xf7\x32\xc7\xd2\xd5\x19\xd7\x7f\xf1\xb4\xb7\x6a\xb6\x7b\x52\x67\x2c\x17\xd6\x24\x0d\x78\xbe\xd8\x69\xa9\xfb\xbc\xc8\xd6\xf6\x59\xee\x39\x5d\xd4\x8d\x2d\xba\x97\x7c\xfd\xba\x63\xf1\x35\xe6\x5f\xe8\x0b\x74\x31\xce\xb9\x51\xba\xc5\x79\x26\xa3\xbf\x2b\xb9\x7e\xec\x82\x1e\xe4\x76\x1a\xd7\x3c\x89\x73\x5a\x8d\xab\x9a\xd7\xca\xcc\x0d\x51\x11\x63\x34\x48\x68\x0c\x81\xba\x27\x36\x72\x95\xaf\xb7\xd5\xb3\x6a\x13\x18\x84\xb9\xb7\x08\x0b\x02\xde\x9b\x04\xd5\x22\xa6\x16\xb6\x50\x35\xae\xef\xfa\x72\x34\x90\x5b\xd1\x0d\x0a\xc8\xc6\x64\x05\xe4\x72\xcd\x0c\x53\xbc\x41\x4a\x5b\x40\x5b\x32\xd3\x54\x4f\x72\x04\x4c\xa5\xb0\xce\x3f\x21\xd6\x9c\x1a\xbe\x1a\x07\x05\xd5\xe5\x4c\x00\xb4\xf2\x90\xa3\xf3\x4e\x00\x26\x6a\x00\x6f\xa8\xaf\xf4\x55\x15\xb8\xf8\x45\x64\xdd\x25\xc2\xa4\x60\xc0\xb6\xa6\x64\x62\x4c\xab\xbf\xec\x19\x39\xae\xb5\xe2\x97\xe4\xcf\xee\xfc\x92\x5c\xb6\x70\x3f\x8f\xc9\x25\xb4\x59\x95\x1d\x0a\x90\x8c\x70\x57\x7c\x28\x7e\x72\x8f\x6d\xdc\x49\xaf\x92\x03\x6f\x56\x15\xc8\x0f\x75\x1f\x90\x06\x7f\x27\x1d\xcb\x7d\xb8\x0f\x58\x91\x50\x02\x87\x15\xd3\xf8\xf3\x95\x19\x67\x3a\x05\xfe\x4e\x6f\xce\x2d\x48\xb3\x2a\x7c\x14\xce\x40\xcb\x5b\x4c\xd9\x33\x2e\xea\x6c\x03\x77\x7a\x78\x9e\x06\x36\xeb\xe3\xf3\x1f\xa2\xf5\x5d\xbb\x07\xad\xef\xda\xdd\xb4\xbe\x4f\x7e\xa0\xd6\xf7\xc9\x7d\x69\x7d\x9f\xdc\x83\xd6\xf7\xe9\xc9\xc9\x7b\xe7\x8c\x16\x33\xa4\xb5\x19\x55\xa0\xcf\x4e\x4e\xdc\x08\x6e\xb1\x68\x7c\xf2\x9e\x4b\x76\xc5\x64\xf2\x7c\xb6\x26\x9e\xff\x78\xcf\x04\xcd\x86\x68\x03\xa2\x54\xdf\xe0\x9c\x00\xaf\xdc\xe6\x1e\xfc\x13\x5c\x5b\xca\xb7\x6c\x70\x76\x27\x56\xda\x36\xdb\x0f\x1d\xcf\xc8\x2a\x70\xf9\x41\x37\x5e\x56\x0f\xd8\x9c\x38\x96\x76\x33\x12\x4b\x71\x1a\x3f\xbc\x02\x3e\x0d\x77\xe2\xd8\x7e\x1a\xce\xb3\xd6\x95\xf5\xb0\x4c\xc5\x7e\x74\xe2\xa8\x0f\x9d\xc8\xa8\xe9\xfe\x13\x5f\xc6\x9b\x6f\x73\xd3\xa7\x13\xcf\x49\x9c\x49\x62\x7d\x3e\x13\xab\x39\x35\xb8\xb1\xdc\xef\x4c\xcd\xb6\x32\x97\xf6\x68\x61\xe0\x04\x43\xda\x76\x5d\xca\xd8\x64\x03\x83\x42\x60\x7c\xea\xe0\x74\x13\x44\xee\xf9\x17\x9f\x4d\x3c\x66\x15\x42\x91\x46\x1a\x1c\x1d\xef\xe8\xc4\x83\x52\xf1\xb0\x42\xba\xdf\xe1\xb8\x2d\x1f\xcd\x50\x5b\x1c\xf4\x66\x69\x58\x9c\xd0\x66\xc5\xde\x71\x45\x3d\x8d\xcd\x31\x9e\x48\xcd\x90\x5a\x29\x56\x7a\x99\x86\x49\x3c\x4e\xc7\x11\x9f\x41\xc8\x29\x57\x10\x54\x4d\xf9\x16\xbb\xb5\x68\x98\x06\xd1\x22\xc6\xa7\x7e\x09\xac\x06\x02\xdb\xe2\x7b\x9f\x25\xe6\xb3\x1d\x40\x86\x93\x38\xf2\xaa\xa8\xc6\x3f\xaa\x4a\x33\x65\x0c\x5d\x95\xb0\x52\x65\x51\x41\x4f\x16\x98\x77\x54\xe9\x34\x14\xd1\xaa\x02\x2a\x45\x16\x01\x7f\x9f\x13\xcd\xca\xb5\x55\xb9\x93\x38\x60\x43\x6e\xf6\x04\x0c\xcd\xb1\x55\xb4\x0d\x17\xf0\xa5\x6d\x38\x70\x20\x18\xea\xf7\xef\x04\x7e\xa4\x8c\x15\x33\xef\xa8\xe7\xa6\x98\xe1\x8c\x68\x97\x6f\xc0\x76\x3b\xb1\x22\x47\x11\x8c\x58\xba\x32\x95\x2c\x5a\xe7\x17\xf0\x99\x5d\x0a\x7c\x96\x94\xa4\x49\x1b\x8c\xcf\xb6\xd2\x03\xea\xc8\x98\xe9\x99\x4e\xf1\x6e\x7f\x1a\x2b\x57\xca\x02\xe7\xca\x3d\x9e\xbd\x54\x54\x7b\x53\x78\x01\xc8\x95\x4d\x8e\xe6\x47\x52\xe7\x07\x0e\xfb\x5e\x8e\xb7\x04\xa9\x81\x1a\x0e\x1a\x21\x8f\x1f\x0b\xda\x1f\x38\xe3\x20\x72\xbc\xaa\xa4\xc7\x4a\xfa\x81\xd4\x5d\x66\x72\x1a\xa1\x33\x6f\xea\x6e\xa9\xf9\xcc\x93\x02\xa7\xd4\x7c\x22\x77\xaa\x8a\xb5\x64\xea\x25\x61\x16\x84\xd9\x63\xd5\x30\x4e\x06\x7d\x39\xfc\x31\x52\x7d\x3a\x7a\x19\x4d\xd4\xc2\x4d\x1c\x70\x0d\x7c\xd8\xff\x82\x50\x6e\x71\x2e\x37\x88\x4a\xad\x5e\x4e\x56\x38\xc7\x2d\x1b\x8d\x82\xba\xae\xcc\xfd\x50\x73\x99\xeb\x8a\x61\xb9\x8a\x17\x05\xb8\x48\x4a\x64\x11\x91\x30\x97\xd2\xad\x82\x45\x67\x05\xfc\x39\x2a\x46\x69\xa9\x38\xd5\xef\x75\xa3\x40\x4a\x41\xaa\x32\x4a\x62\x9f\x01\x4c\xa8\x54\xf3\xca\xc6\xce\x29\x43\xef\x90\x6c\x8d\xa0\xf8\x90\x3a\x89\x3f\xf1\x52\x50\x08\x03\x79\xc5\xc3\xb4\x57\x88\xbb\xd0\xbb\xea\x1d\x47\xb3\x81\x44\x9e\xb4\xe4\xf7\x07\x81\xef\xc2\x5b\x1d\x14\xad\x80\xb5\x5e\x57\xac\xae\xdd\xae\x75\x9f\xfd\xe2\x04\xbe\x27\x9b\x17\x83\xff\xfe\x7d\x56\xfd\x58\xb9\x22\x60\xfc\xa5\x38\xa9\x62\x28\x9d\x30\x69\x11\x9c\xa9\xa9\x71\x34\x41\xef\xf9\x83\x87\xa6\x57\x9a\x35\xb9\x55\x22\xc8\x74\xc2\xd0\xe5\x8a\x32\xb7\x4f\x24\x59\x29\x7b\xe1\xa5\xdc\xa6\x13\x04\x2f\xc7\x1f\x9c\x98\x86\xd6\xba\xc8\xe6\x96\x07\xf0\x47\x98\x73\xe8\x15\x02\x2f\x4d\xcf\xa9\x7b\x0e\x39\xef\x71\x15\xe4\xc5\x67\x58\xb6\xe3\x33\x2c\x4f\x8a\xcf\xb0\x7c\x4c\xf0\xbe\x59\xcb\x0c\x46\xf3\x20\x3a\x18\xdf\xda\xb7\xc3\xe3\xc7\x99\xbe\x3c\x7e\x6c\x97\x9d\xbc\x98\xc5\x78\x24\xbc\x0d\x92\xd7\x0c\xbe\x58\x83\x68\x4b\x97\x88\xef\xcd\x9e\x1f\x60\xf9\x19\xf7\x95\x9e\xb8\xe8\x0a\xbd\x36\x47\x39\xe7\x70\xb8\x97\xc8\x36\xab\x5a\x70\x4c\x7b\x4f\x87\x22\x29\x89\x42\x0c\x6c\x8a\x37\x5e\xea\xee\xc9\x0d\xa2\x50\x52\xe1\xbc\x6c\x59\x6f\x5e\xc6\x52\x9a\xcb\x30\x74\x20\x3e\x9b\xa9\x8b\xf5\x05\xff\x87\x09\x4c\x4d\x4c\xaa\xa7\x29\x4c\x2a\xda\x85\x53\xae\xa0\x6a\x93\x83\xa7\x18\x77\x66\x86\x05\x89\x9a\x17\x71\x47\x19\x38\xca\x9d\x4b\x8e\x32\x21\xd5\x21\x19\x00\x46\x6f\x3a\xb9\x0b\x28\x9b\x68\xed\x53\xf6\x79\xc7\xfc\xbc\xcb\xdd\x94\xa6\x8c\xcc\x0d\xd5\xf2\x9d\x3c\x63\x63\x68\x27\x98\x53\xea\x11\xe9\xa3\x39\x89\x90\xac\xd0\x7e\xbc\x23\xa2\xc6\x82\x52\x22\x8c\xc2\x25\x38\xa9\x2f\x05\xfe\x39\x25\xdb\x07\x2b\x22\xfe\x01\x03\x9e\xb3\x23\x2a\x16\x59\x45\x3e\x15\x36\x8b\x92\x25\x14\x95\x7b\x9e\xe7\x0c\x5d\x2f\x08\xf9\xf4\x4b\xcc\xbb\x68\xb5\x2c\xa0\xf2\x6c\x31\x99\x29\x64\xad\xdc\x15\x59\x4f\x6b\xcd\x5a\x73\x85\x1c\x0a\x04\x95\x25\x43\xab\xfc\x80\x51\x4d\x3b\xa8\xfb\x0c\xea\xa8\x22\x4a\x9a\x71\xf3\x36\x24\xa3\x06\xed\x64\x97\x26\x5b\x96\x34\x96\xab\xd2\x5c\x7b\x52\xc9\xaf\x30\x29\xde\x9f\x5d\xf2\x4f\x09\xfb\x07\xaf\x98\x63\x67\x60\x0f\x49\x35\x9b\xca\x2a\xbf\x74\x18\x55\x57\xf8\x55\xd2\x8b\x5c\xe8\xa9\x39\x6d\x22\x8d\x2c\x92\x52\x59\xc5\xdc\x48\xe1\x40\x47\xdf\xb0\x00\x56\xf0\xed\x1f\xce\x72\x36\xe8\x40\xaa\x33\x19\x56\x30\x4d\xd4\x04\x49\xc8\x07\xa0\x8b\x6d\x41\xd0\x89\x56\xbd\xfe\x8d\x75\xe0\x19\x4d\x2d\xa4\x49\xfd\xe2\xcb\xe5\xb3\x5f\xea\x73\x22\x24\x45\xab\x5e\x67\x89\xe3\x9e\x47\x17\x34\xee\x04\xd1\x08\xc2\x51\xfc\x3e\xa4\x0c\x9c\x0f\xd5\xd7\x9e\x34\x56\x9a\xcf\xd7\xea\x9d\x61\x80\x47\xe3\xa5\xa8\xb3\xf4\xcd\xb9\x70\xd0\x90\x74\xe9\x9c\x8e\xdd\xc8\xa3\x4c\x19\x76\x6d\xf2\xa1\xfa\x34\x74\x95\x9b\x7a\xe9\x9a\xde\x8d\xe2\x98\xb2\x41\x04\x6f\x2a\xc4\x61\x99\xf3\x9c\xae\x7f\x41\x43\xbe\x19\x01\x5e\x23\x50\x50\x6f\x46\x1e\xd5\xbe\xf4\xd1\x21\xfe\xae\x7f\x49\xbd\x6b\x99\x4b\xae\xf6\x44\x8c\x2c\xac\x01\x95\xaf\xd0\xab\xc9\xb5\xe1\x12\x5f\xd6\x83\x24\x67\xe0\x93\xc1\xf0\x2c\xf0\x5d\x34\x37\xd3\xcb\xb4\x70\xdd\x96\x19\x75\x62\xb7\xb7\x13\x0e\x86\x62\xfd\xd6\xeb\xe4\x1d\x1d\x9f\x45\x4e\xec\x11\xb0\x69\x61\x73\x32\x1a\xb0\x2a\xc9\xe9\x54\x06\x98\xc6\x33\x85\xb0\x15\x4c\x03\x53\x01\x7d\xdf\x89\x61\x6d\x98\x65\x6a\x18\x33\xf2\xfb\x77\x2b\x51\x62\x20\x95\xec\xf6\x9c\x98\xa7\xcf\x49\x33\x25\x0d\xb5\x62\x16\x24\x1b\x46\x7b\x72\x9b\xae\xd7\x09\xe2\x53\x0e\xa6\x84\x5a\xc2\xe2\xde\x4b\xd1\xcb\xe9\x53\x76\x64\xe4\x1c\x0b\x70\xdb\x17\x34\x1e\x63\xa0\x3b\x50\xa9\x97\x5d\x87\x41\xa8\x03\xdc\x50\x2a\x42\x36\xc0\x9a\x10\xd6\x16\x1c\xd2\x98\x6d\x08\x48\x6e\x8f\xba\xe7\x04\xc9\x0c\x2b\x41\x30\x23\x3e\xe3\x1e\x2a\xcb\x20\x4f\x74\xa2\x96\x44\xef\xa3\x11\xdf\xc3\x19\x2d\x57\x8e\xc5\x70\xac\x1a\xaa\xf3\x56\xaa\xd5\x9a\x13\xf8\x0e\x2b\x6c\x4f\xe4\xde\x53\x8b\x23\xea\xc7\x1e\x3c\xdf\x72\xdc\x84\xc6\x2f\x2c\x72\x32\xc3\x01\x35\x15\x18\x91\x27\xa7\xbc\x9d\x94\x1b\x15\x43\x52\x52\x42\xf9\xdc\xb5\x19\xc7\x82\x9c\x8d\x61\xbe\xc4\xc2\x22\x2a\xe4\x1e\xc7\xdf\x51\x09\x82\x18\x96\x8e\x79\x97\x36\x7e\x26\xcd\x95\x39\x15\xd4\x11\xf0\x6b\x84\xe8\x73\x91\x52\xcd\x4f\xa9\xff\x2d\x41\x04\xfa\x81\xe3\xd2\x52\x8b\x3c\xe3\xa2\x66\x29\x71\xce\x4a\x2d\xf2\x1c\x7e\x63\x1b\x2d\xd2\x5c\x81\x4f\xd6\xf3\x3b\x09\xff\x7c\x02\x9f\x6e\x12\x07\xfc\xeb\x29\x7c\x39\x01\x64\x21\x90\x81\x33\x64\xb4\x0e\x2f\xca\x79\x22\x42\x73\x9d\x01\x23\x41\xe4\xf2\xa4\xe5\x06\x36\xc0\x5c\xfe\x81\x10\x64\x3f\x56\x96\x05\x8c\x2e\x25\xc3\x01\x4f\x58\xd1\x09\x5e\x34\x0a\x79\xd2\xaa\xe8\xa0\xc7\x3f\x20\x7c\x63\xa9\x17\xf5\xa1\x3a\xf6\x2e\xa0\xd0\xd7\x15\x84\x8d\x70\xb0\x73\x31\xb8\xd2\x68\x91\x15\xec\x96\x80\xb8\x8a\x3d\xf2\x43\x46\x63\x9e\xbb\x8a\x40\x3d\x1a\xd0\x84\x83\x5d\x15\x83\x8e\xfa\x7d\x07\x5a\x7d\xde\x54\xed\x90\x4c\x2a\xb4\x61\x26\xe3\x10\xc2\x61\x7f\xe0\x78\x64\x81\x23\xa5\xf1\xc4\x4c\x5a\x84\xa4\xa7\x66\xd2\x12\x24\x3d\x37\x93\x6a\x3c\xa9\xd9\x30\x93\xea\x90\xd4\x94\x49\x12\xc1\xcd\x55\xc4\x10\x73\xe3\x28\x08\x74\x2a\x8e\xaa\x3f\x86\x57\x89\x43\x31\xbd\xcf\x96\x55\xaa\x70\xe7\x14\x61\x3a\xf6\x7a\x1d\x7e\x63\x77\x37\xe0\x37\xf6\xb3\x0a\xbf\x11\xa9\xd0\xd9\x67\xd8\x59\xe8\xe5\x73\xec\x25\x74\x4f\x20\xe5\x14\x7e\x63\x5b\x47\x7c\xde\x05\x61\xfc\xfb\xdf\xfc\x43\x90\xc4\x31\xfc\x86\x0a\xf3\xa5\x79\xfe\x7b\x79\x0e\x43\x02\xbf\xa1\xc1\x80\xc6\x6a\xb1\xe3\xab\x3c\xfc\x30\xc8\x5b\xa7\x00\x81\x63\x94\x1f\xa6\x67\xe6\xbf\xff\xef\xff\x4f\x93\xf0\x7f\xff\xef\xff\x57\x13\xed\x7f\xff\xef\xff\x4b\x93\xf3\x7f\xff\xef\xff\x47\xd7\x71\x13\x83\xd0\xdd\x28\x4c\xe2\xc8\x48\xc0\xf0\x78\x29\xe2\xd7\x64\x9f\xb3\x0a\xf4\x02\x40\x16\xa0\x97\x18\x65\xae\x33\xa0\xe6\x9a\x70\x8d\x15\xd1\xb5\x96\x43\xd7\x33\x56\x82\x1f\x32\x8b\x68\x0d\x8a\xed\x23\x5d\x72\x2c\xce\xd5\x17\x1e\x71\x66\xf2\x21\x8e\xba\xb1\xd3\x77\xe0\xe5\x6a\x30\x26\x8e\xe7\x61\x00\x1a\x08\x60\x8b\xe1\x2d\xeb\x80\xf4\x80\xf3\x4a\x74\xc8\xc1\xf9\x17\x9b\x83\xdb\x50\x9f\x6c\x90\xe7\x4f\xf1\xe2\xb6\xb9\xbc\x22\x6e\x6c\x91\xb1\xe3\xd6\x00\xb7\xb0\x9b\x82\xe3\x95\xfd\x0a\x3f\x3a\xf9\x64\x89\xac\x2c\x03\xd8\x50\x6c\x5f\xd6\x1d\xf1\xea\x33\x84\xb8\xf6\xcc\x02\xc8\xab\xad\x3e\x03\x00\x50\x57\x09\x84\xe7\x74\x6c\xf4\x47\xdc\xb6\x37\xed\xde\x94\x3a\xa5\x45\x1f\x1b\x5f\xe4\xeb\x44\xb6\xce\x97\x8e\x5d\x5f\x3c\x31\x6a\x36\xec\xfa\xa2\xac\x01\xe5\xf9\x93\x34\x9b\x76\x61\x6f\x4e\xb1\x69\xce\xbb\x8f\x9a\x2b\x92\x43\x97\xb6\x81\x99\x6a\x36\x0d\x7b\xb1\x41\xb8\xe9\xef\xc4\x4f\x40\xde\xbf\xba\x86\x08\xb9\xf0\xc5\x3b\xcb\x59\xf6\x88\x8b\x33\xf8\xae\x18\x06\xb4\x09\x4a\x2d\x12\xd3\x0b\x1a\x33\x4a\xfa\xce\x60\xc0\x27\x51\x8c\x0d\xde\x20\x7b\x94\x55\xc4\xfe\x2f\xd0\x7a\xac\x51\xda\xf6\x3c\xb5\xae\xd4\x94\x40\x02\xaf\x2c\x72\x50\x06\xc2\xca\x90\x74\x6c\x6c\xae\x98\x20\x68\xcc\x14\x84\x27\x86\xc4\xfa\xd1\x61\xee\x27\x1c\xa0\x64\xd6\xf6\xaf\x3b\x87\x3b\x7b\xaf\x0d\xc4\x6f\xef\x1d\x6e\x7f\xda\xde\x4a\xa7\xa4\x0a\xfd\xba\x73\x68\x95\xf9\xbc\xb7\xbb\xff\x79\x0f\xd3\x32\xf1\xeb\x2d\xaf\x06\x05\x46\x48\x50\xf2\x83\x59\xd0\x3e\x66\x7d\xf1\x03\xcf\x75\x62\xaf\xac\xa1\xa9\x63\x1d\xa8\x95\x26\xd8\x6f\x19\xa5\x26\x9d\xf9\xa0\x80\x5d\x7c\x2b\xea\x17\x1d\x2b\x9f\x67\x4a\xde\x08\x7b\x2b\xea\xab\x4a\x1f\x6e\xc0\xc9\xf2\xd3\xe7\x7f\xca\xa9\xb3\xa8\x01\x85\x6f\xc3\xe2\x23\x17\xbc\xdd\xbc\x61\x95\x22\x5c\xce\xed\x9f\x7d\x13\x96\x24\x12\xc4\x23\xfd\xce\x29\x6d\xe8\x63\x34\x36\xbd\xe5\x08\x9a\xf8\x60\x53\xd2\xc0\x27\x12\x3f\xd1\xba\x07\xf3\x8c\xf3\x2b\xf4\x54\x9e\x0a\x20\xf3\xff\x08\x6b\x99\x87\xd7\x84\x0f\xaf\x09\x1f\x5e\x13\xfe\x45\xaf\x09\x39\x57\x30\xb7\xc9\xbc\xad\xb3\x34\x0c\xfb\xd1\x30\x4c\xa8\x57\x42\xed\x74\x66\xa3\x55\x09\x25\x7a\xe9\x1b\xe5\x72\xf6\x68\x9d\x54\x92\x31\xff\xcd\xd2\xd9\x3d\x5e\xc0\xe5\x65\xad\x0e\x64\xf7\x7e\x09\xf6\xd2\x4f\x10\xaa\x14\x09\x0f\x7b\x94\x1c\xc6\x4e\xc8\x7c\xdb\xd7\x3a\x09\x68\xc2\xc8\x38\x1a\x8a\x77\xdd\x10\xae\x38\xd1\x05\xc1\xfb\x4c\x14\x52\x5d\x83\x43\x43\x17\xf7\xe0\x9c\x15\x83\x76\x9f\x44\x17\x34\x26\x89\xdf\xa7\x27\x78\x23\xe0\x10\xe6\xf7\x07\x01\x25\x1e\x75\x03\x27\xc6\xb0\x97\xed\x0f\x3b\x35\xb2\x1b\x31\x3c\x82\x46\x61\x30\xe6\xc0\x20\xa4\xe4\x90\x49\x6f\xaf\x10\xe8\x17\x43\x54\x72\x8c\xfb\x61\x97\x38\xa1\x47\xc4\x04\x40\xbc\xec\x0e\xe7\x59\x5a\xc5\x7a\x36\x4c\xc0\x6b\xac\x13\xb0\x88\x03\x3c\xa3\x0a\x9c\x1a\x94\x1f\x2e\x0d\x02\xc7\xa5\xe6\xd8\x60\x14\xc0\xf7\x46\x34\x08\xa4\xaa\xf0\xa5\xbe\x79\xe1\x9d\x38\xd5\x58\x3b\x35\xd0\xe6\x45\x94\xc1\xb2\x73\x82\x84\x8f\xbc\x47\x95\x9b\x1c\x11\x61\x93\xc3\xd2\xe5\xfd\x44\x5c\x0b\xb1\x2a\x01\x8f\xb0\xc1\x98\x77\xc5\x3d\x67\x64\x1e\x26\x76\x1e\x46\x39\xcf\x67\x6e\x5e\xf6\x8c\x6f\x5a\x1c\xb2\x02\xc3\x20\x50\xe7\x0e\x20\x6c\xc0\xc7\xc7\x27\x2e\x89\x40\xfd\x49\xfa\xd4\x09\x25\xb6\x68\xa7\x23\x82\x82\x26\xbd\x08\x64\x55\x0e\xb0\x46\x5e\x45\x9c\xb5\x38\x30\x33\x23\xca\xb1\xc6\x01\xf2\x73\x16\xf8\x43\x62\x30\x05\x46\xb7\x47\x3d\xce\x98\x13\x02\x5d\x64\x04\x6a\xfb\x09\x6b\x09\x5c\x9d\x9e\x9e\x7e\x63\x97\x30\x89\x68\xf4\x7c\x98\xa2\x9c\x12\xc8\x57\x4b\x1a\xe9\x4b\xdd\x38\x1a\x0e\xea\xba\x5c\x69\x5d\xc0\x02\xe6\x42\x8c\xd0\xfb\x2b\x8d\x46\x2a\x0f\xa7\xe5\x00\xbc\xf5\xc3\x41\x7a\x41\xfa\xd0\xf3\x31\x34\xf3\x69\x34\x70\x5c\x3f\x19\x93\x7f\x5e\x49\x40\xd7\x7d\x46\xa8\xc3\xe8\x92\x1f\x2e\x45\xc3\xe4\xb4\x8a\xb5\x44\x41\xf4\xce\xb4\x40\xae\xad\x86\x34\xc8\x03\xc4\x8a\x6a\x4c\xae\x57\xce\xfe\x34\x08\xb0\xf4\x52\xd9\xd4\x6b\x11\x33\xbb\x29\xb2\xaf\xed\xd1\xbc\x72\x40\xff\x55\xbe\x22\x7e\xd8\x22\x3e\x08\x13\xe4\xba\xc2\x0f\x65\x65\x84\xf6\x93\x81\x4d\x3f\xdc\xb8\xc2\x32\xd7\xb0\xcc\xa2\x61\xb2\xa1\xc7\xf8\x33\x56\x20\xe4\x0a\x7c\x21\x50\x13\x0a\xff\xf7\x93\xe7\x5f\xe0\x0c\x6f\x5c\x5d\xe9\x64\x42\x6a\xb5\x9a\x89\xd5\x6a\x2a\x2f\x8d\x88\x23\x80\x7e\xac\x4b\x5d\xeb\xa6\xf9\xbf\x9d\x52\x9f\xb4\x49\x87\x8f\x4c\xf7\xfd\x91\xd1\x8f\xba\xe7\x5f\xa8\x1a\x95\x6b\x31\x4e\x83\x1c\x20\xb3\xb2\x2e\x88\x4b\x20\xac\x0d\x4b\x8d\x7a\x37\x2d\x48\x2e\x28\x9c\x78\xd1\x09\x71\x42\xa1\x35\x3e\x1b\x13\x3f\xe1\x3b\x3b\xdc\x61\x26\x0c\x6f\xf5\x75\x35\x58\x4f\x5f\x7a\x0e\x2c\x50\x58\xd3\x5e\x04\x8e\x9c\xf9\xd2\xcc\xe1\x15\x8a\xcd\x11\x86\x8b\x8f\xf3\x1d\x74\xcb\x9e\x5d\xf3\x65\x36\x74\x7b\x9c\xbd\x9c\x81\x2a\x83\xf7\x47\xac\xb2\x28\x46\x99\x8b\x9f\x5e\xe5\x12\x73\x7b\x4e\xd8\xa5\x4c\x2e\x55\x31\xf4\xc3\x1e\x8d\x29\x71\x62\x4a\x56\x49\xdf\xf1\x35\xd3\xb2\xb8\x39\xba\xcc\xf6\xc3\x16\x20\x74\x89\x9c\xca\x3d\xe6\xd4\x4a\xd8\xde\xd2\xdf\xb8\x59\x58\xdf\x98\x0d\xad\xa6\x06\x8e\xbe\xad\xbb\xdd\x80\x7a\xe4\xc2\x77\x70\x1e\xfc\xf0\x14\x2c\xb1\x6a\xe4\x0b\x1f\xc2\x29\xdf\xcc\x4f\x6d\x7e\x45\xce\x68\xd7\xc7\x28\xc2\x1c\xec\xfc\x36\x72\x3a\x96\x38\x5d\x5a\x23\x5b\x43\xbe\x94\xe0\xed\x37\x26\x55\x53\xb5\x47\x7e\x10\x10\x50\xef\x22\x37\x81\x09\x44\x5f\xde\x99\xb9\x01\xd2\x4d\x22\x72\xaa\xf7\xd4\x53\xc5\x40\x15\x57\x11\xc1\x8f\x8d\xca\x9c\x5b\x26\xbc\xff\xc0\x2b\xa9\xac\x4f\xbd\xd2\x29\x76\x8a\x44\xa1\x4b\xd5\x3e\xc5\x3b\x17\xd0\x84\xd6\xc8\x7b\xca\xbf\x13\xe7\x9c\xda\x3a\x2a\xc9\x5f\xb3\x3c\x12\xfa\xb9\x41\x70\xc1\x83\x7c\xa4\x79\x02\x62\x17\xf0\x73\x20\xe2\xc7\x94\x61\x15\x4b\x2e\x97\x72\xa4\xcf\x41\xa0\xf4\x84\x8b\x45\x32\x30\xf3\x99\xfd\x82\x11\x93\x5f\xae\xb9\x9f\xcc\x05\x98\x65\x31\x86\x7b\x66\x3f\x34\x38\xcd\x5a\xa3\x71\x4d\xea\x66\xc5\xb3\x61\x92\x70\x84\x86\x9b\x81\xef\x9e\x8b\x9a\xe9\x51\x5c\xff\x0c\xb9\x1c\xb7\x90\xf8\x53\x1d\xab\x29\x40\x26\x43\xd0\x03\x31\x96\x3e\x90\x16\xec\xae\xd8\x9e\xcf\x88\xcb\x41\x0a\x66\x90\x4b\x2b\xf6\x4c\x22\x25\x20\x19\x3b\xa1\x27\x26\x62\xcc\x8b\xc4\xa8\xba\x5a\x6b\x34\xfa\x8c\x94\x79\x1d\xbc\x51\x8c\x3a\xe4\x54\x0c\xfd\x54\x2c\xd0\x8e\x1f\x82\x4a\x12\x9d\x16\xe3\x46\x69\x90\x4a\xcd\xec\x2e\xac\x0c\x9f\x91\x53\x98\x63\x5c\x12\xcc\xe9\x73\x3a\xe1\xf4\xd1\x73\x06\x03\x1a\x32\x42\x2f\x5d\x3a\x40\x21\x03\x7b\xd7\x8f\x2e\xf8\xa6\xcf\x29\xfd\x54\x89\x70\xa7\xa2\x25\x14\x2a\x45\x88\x6d\x8c\x29\xa5\xa7\xce\xf2\x3f\x01\x46\x45\xff\x2c\x0e\x26\xa5\xaa\x55\x49\xa6\x6c\x2a\xb0\x94\x2a\x2a\x0d\xbe\xc1\x7e\xee\x32\x99\xec\xa7\x42\x57\xab\x58\x51\xa8\xa6\x0c\xd6\x94\xee\x14\x9e\xae\x31\x2f\xd5\x0d\x13\x3e\x5a\xff\xbc\xe6\xe2\x05\xdc\xe6\x41\x09\x63\x07\x83\x1c\x34\x30\xad\xd7\xc9\x4e\x28\xe8\x07\x8a\xa1\x48\x79\x68\x97\x25\xfc\x5c\x28\x04\x1f\xce\x80\x63\x8a\x4a\xe9\xc1\x80\x3a\x70\xc5\x89\xed\xe2\xb7\xb2\x12\xc3\xaa\xda\xe0\x0c\xbe\x6b\x3e\xdb\x95\xd2\xab\x8c\xa3\x01\x90\x49\x4b\x7c\x21\x14\x63\x38\xe2\x34\xcc\x97\xd1\x90\xa5\x7c\x67\x63\x9c\xa9\x90\x5e\x26\x2a\x1b\xad\xd7\xd4\xb5\x2d\x02\xf5\x43\x6d\x5c\x0e\xfe\x87\xa1\x11\x2b\xac\x4e\xaa\x15\xdc\x06\xb4\x73\xd5\x9c\x96\xe4\xd6\x52\x18\x1f\x25\x03\x13\xb7\x9e\x54\x3c\x14\xbb\x96\xee\xb3\x90\xf3\xf7\xc3\xed\x4b\x0c\x2c\x81\xc9\x32\x91\x23\x6d\xd2\x00\xd4\xa1\x6d\xfa\xee\x59\x43\x96\xd1\x5a\x0c\x3c\xab\x78\x5e\xb0\x4c\x87\xac\x95\x02\x71\xbd\x3e\x97\x9a\x95\x4d\x69\x0e\xb5\x61\x78\x85\x90\x66\xa1\xbc\x94\xb2\x6c\xd3\x24\x67\x28\x97\xba\x14\x0c\xce\xbc\x4d\x41\x9c\xc6\xea\x4e\x65\x95\x53\x06\x74\x57\x24\x45\xef\x2d\x54\x17\x5c\xaf\x73\x9a\x77\xf8\x0e\x85\xa7\x8a\x90\x32\x2e\x4f\xe9\xe6\x39\x3d\xe3\x40\x72\xbb\xa4\xf8\xec\x96\xef\x01\x25\x5b\xc1\x15\xd3\x99\xaa\x5b\x46\xa8\x1c\x44\x56\x59\x85\x0c\x9b\xa6\xb1\x74\x20\xb0\xdc\x46\x6f\x8e\x16\x26\x43\xe2\x29\x3f\x33\x14\xcc\x47\x70\x9f\x95\x91\xc0\xa4\x10\x21\xfe\x31\x49\x1e\xbc\x62\x0d\xbf\x8c\xf5\xa5\xe3\x84\xa5\xd7\x98\xac\xb8\x61\xd0\x62\x25\x1d\x3d\xc8\xd8\xc8\x25\x4d\x09\xfd\xc1\x75\xae\x57\x6f\x01\xf4\xd1\x86\x5e\x7e\xa0\xa7\x49\x25\xe7\xb4\x34\x79\xe9\x16\x2d\x45\x63\x10\xaa\xbd\xef\xdf\x49\x3a\xf9\xc6\xf6\x50\xc8\xcc\x89\x84\x34\x1d\xa5\x7d\x46\xc1\xba\x80\xd4\x30\x77\x02\xad\xdd\x8a\xce\x3e\x23\xdf\x29\x24\x31\x91\x6f\x37\xe7\x3a\xa1\x4b\x83\x3d\x63\xc9\xdf\xd8\x68\x97\x26\x87\x28\x5a\xb0\xd4\xc2\x96\xc9\x56\x28\x47\x21\x86\xd8\x41\x87\x44\xa2\xb1\x5b\x70\xf1\x40\x6d\x12\x9a\x8a\x71\x8f\xc9\xa6\xab\x3d\x4b\xee\x2a\x90\x23\x80\xc8\x4a\xaa\x90\xdd\x1c\xe8\x3c\x45\xaf\xc4\x8d\x01\xa7\x45\xa1\x7a\xd4\x39\x1b\x44\x9a\xff\x68\x22\x11\x2d\x88\x42\x35\xfe\x29\x89\x43\xb6\xaa\xf2\xf8\xb7\xcc\x4c\x77\x45\x6d\x97\x9a\xac\x14\x07\xe4\x40\x5b\xf0\xff\x2a\x02\x6d\xe1\x9f\xaa\x80\xd2\x92\xd0\xae\x6f\x98\x29\x93\x96\xcc\xa9\xb2\x69\xcc\x98\x2b\xa5\xa0\xca\x35\x7d\x6f\xd8\xa6\xef\x8d\x49\xa6\xef\x8d\x63\x22\x4e\x08\xc6\x1c\x5b\x4b\x2b\xb5\xd8\x52\xac\xe9\x40\x33\x06\xa1\x6b\x9e\x2b\x5a\xa3\x66\x88\x92\x7a\xdd\x6c\x04\x24\x6a\x27\x18\x39\x63\xc6\x4f\x97\x8a\x11\x44\x4a\xf9\x58\x33\xa1\x16\xad\x05\xd5\x7d\xb4\xf7\xd1\xb7\x72\x52\xf3\x50\xeb\xf8\xa1\xb7\xb5\xbf\xbb\x17\x79\x14\xc4\x3c\xdb\x51\x96\xd9\x5b\x83\x1f\x65\x38\x8f\x88\x7b\x08\x12\x42\x99\x37\x56\x55\x13\x72\x43\x2c\x37\x59\xf3\xd2\x4f\xa0\x62\x3a\x74\x1b\x56\x02\xba\xd7\x6b\xd0\x96\x53\xf8\x02\xd0\x47\x27\x93\x4f\x02\x5b\x4f\x4d\x40\x0e\xfb\xd7\xca\x66\x2b\x02\x5a\x31\x75\x9a\xc3\xb5\x1e\x33\x4d\x40\x83\xb9\x1f\xf2\x8e\x2c\x0b\x42\x32\x19\x89\x5c\x86\x7a\xa4\x62\x25\xa6\x04\x5e\xa4\x73\x9c\xf9\x7c\x59\x9b\xbc\x98\x98\x6d\xca\xc4\x2d\xd5\x47\xa3\x9d\x44\xb3\x49\x80\x63\xb1\x48\x51\x8e\x53\x6c\x24\x3a\x8d\xaa\x63\x50\x08\x9c\xfb\x03\x82\xb6\x4e\xfc\xe4\x89\x5b\x95\x2c\xef\x77\xc8\x08\x35\x2a\x96\x7e\x39\x1e\x86\xa1\xd2\x46\xf8\x09\x68\x53\x99\x64\x15\x27\xfd\x21\x4b\x4e\xf8\x2a\x60\x34\x51\x2b\xed\x91\x02\xc0\xc5\x7d\x6a\x8b\xa6\x38\xd1\x4e\x87\x1e\xe4\xec\xf5\x42\xa9\x7f\x5d\xb5\xfd\xd0\xda\x62\xf7\xb2\xc0\x7f\x84\x52\x2f\xf5\x52\xc4\xa9\x7e\x99\xf1\x16\x85\xe4\x6a\x4c\x9f\xa8\x2e\x68\x41\x4d\x9e\xc4\xe0\x8d\xfd\xe4\x4b\xbe\xa0\xa3\x79\xdd\xf4\xc3\x6e\x51\x53\x80\xfe\x57\x3b\xbf\xee\x6e\x2b\x1e\x2c\xe6\xf8\x85\x0d\x30\x0a\x35\xc9\x6f\x87\x9e\x80\x27\xe9\xa1\x26\xd8\xf9\x44\xd4\xcd\x8a\xf9\x89\xb8\xb7\xc7\x24\x2b\x5c\x67\xa6\xe4\xfa\x26\x21\xc0\xe0\x38\x79\x6b\x57\x31\xa2\xf4\x82\x5d\xc9\x59\xb0\x97\xe9\x90\x84\xb8\xab\xce\xb2\x8c\x38\xa8\xc2\x55\x04\x8c\x4c\xd3\x3e\x2f\x3c\x25\xb5\x0b\xc9\x76\xe2\x8c\xad\x68\x84\x83\xa6\x63\x3a\x5a\xcf\x92\xba\xc1\xc3\x6f\x26\x6f\x71\x61\x36\x89\xba\xed\x7e\x49\xe2\xd6\x14\x2d\x0a\xdd\x44\xb1\x20\x8d\x4c\x1c\xfe\x8c\xc8\x9b\x0a\x7d\x33\xd1\x68\x76\x3f\xb7\x03\xea\x67\x77\x7b\xd1\x2d\xb5\x51\x5a\x47\xe1\x09\xb2\x88\x2c\x23\x9a\xd4\x62\xc3\xe4\x03\xf5\x0d\x1b\xa4\x89\x50\xb3\xe7\x16\xa2\xa5\x70\x41\xd1\x7c\x81\xb7\x91\x59\x74\xab\xf6\xa2\xab\xd7\xc9\x17\x0a\x41\x98\x41\xd1\x08\x17\x05\xe2\x44\x29\x44\x43\x3c\x62\x4b\x93\x0c\x46\x46\xa8\xc3\x27\xee\x97\x4f\x1f\x48\xc7\x8f\x29\x23\xbf\x0f\x7d\xf7\x3c\x18\x4b\x80\x4e\x87\x6f\x60\xee\xd6\x2e\x6c\x45\x67\xb4\x13\x61\x50\x66\xa1\x18\xec\x04\x43\xd6\xa3\xac\x4a\xd0\x94\x7f\x14\x0d\x03\x8f\x78\xd1\xf0\x2c\xa0\x24\x89\xfd\x6e\x97\xef\x7e\x12\x96\xde\x66\x8d\xe5\x61\x9e\x78\x37\x94\x90\x47\xf5\x90\x0e\x41\x09\xdf\xe3\x90\xd1\xdc\x82\x84\xd4\xa5\x8c\x39\xf1\x18\x2f\x58\x13\x75\x11\x81\xa6\xe6\xb1\xe3\x82\xfa\xcc\x43\xf5\x01\xdc\xfa\x4a\x60\x52\xbe\x51\x38\x65\xe9\x2b\x5c\x3f\x24\x09\x85\x90\x23\x55\xc2\x22\x29\x65\xf6\x9d\x73\x4a\xd8\x10\xc6\xee\x24\x12\x1a\xde\x53\x0a\x8a\x23\x4e\x38\x56\xe8\xce\x6b\x07\x30\x39\xa2\xb2\x31\x14\x51\x5d\x4d\x3f\x52\x00\xb3\x48\x57\xcd\xfd\xfa\x5c\x56\x48\x33\x68\xa4\x90\x4d\xac\x66\x50\x6c\x88\xd5\x6e\x4a\x1e\xbe\x71\xe9\xa5\xba\x67\x51\x6f\x51\xcf\xd3\x54\xbb\x96\xdd\x2a\x1c\x17\x6e\xe1\x37\xf4\xa3\xda\xfc\x25\x66\xf8\xa9\xb8\x50\x0a\x64\xb9\xb2\x11\x88\xc9\x82\x14\x58\x71\x60\xb1\x18\xd3\x5a\xfe\xfa\x55\x85\x14\x6e\xb0\xa9\x94\xe4\x5d\xd4\x49\xc1\x29\xd2\x7e\xfc\xe7\x8a\x3b\x74\x6d\x3b\x4e\xce\x40\xbc\x61\x46\x52\xfc\xdd\x6c\x78\x22\xeb\xaf\x92\x9e\x13\x7a\x81\x16\x0c\x73\xc9\x4f\x96\x31\x4f\x71\xc6\xf6\x4f\xd2\x67\x0f\xc7\xf3\xb6\x43\xef\xbd\xcf\x12\x1a\xda\xea\xd0\xc2\x42\xb2\x5b\xe9\x71\xe7\x07\x91\xb3\x8f\xf7\x66\x03\x4c\x49\x0f\x59\x1e\xaf\x46\x9d\x7f\x80\x92\x40\x26\x83\x68\x4c\x77\xfc\xc1\x7b\xae\xec\x6b\x75\xeb\x40\xce\xac\xd3\xb2\x79\x36\x5b\x57\x88\x9e\xac\xaf\xcb\xf1\xed\xab\x97\xd9\x24\xe7\xd5\xc6\xeb\xf1\x13\x3b\x6e\x76\xaa\xcc\x2d\x22\xb8\x4a\x08\x25\x19\xb9\xb7\x5e\x17\x6e\x91\x51\x49\x0e\xdb\x0e\x60\x2b\x41\xfe\x8f\x7d\xc5\xb7\x22\x46\x6b\x35\x5f\x08\x50\xd9\x1c\x53\xcd\x5e\x54\xc6\x3a\xf9\x16\x15\x32\x15\x34\xd9\x5c\x3a\x09\x3e\x9d\x00\x56\xa9\xa2\x0a\x5a\xb5\x68\xbe\xa8\x54\x34\x79\x7c\xfa\x20\x73\x43\x09\xea\x4d\x28\x30\x61\x10\x4a\x96\x9c\x5c\x00\xec\xb4\xd5\x92\x14\x26\x8c\x8a\xac\x36\x36\x48\x49\xd2\x7e\x29\x43\xb0\xb2\x9c\x20\xef\xaa\x01\xbd\x92\x21\x64\xb4\x89\x90\xaa\x19\xad\x97\xd9\x94\x91\xde\xa3\x30\x18\x2b\x27\x04\x15\xfb\x3a\x23\x55\xc7\x74\x20\x20\xbd\x07\xa4\xda\xbe\xb6\x42\xf3\xa9\xc5\x0d\xfe\xb1\xd3\x3d\x30\x2f\x26\x0d\x3e\x20\x54\x0a\xa6\x53\xb9\xcc\xc5\x87\x32\xe4\x56\x01\xdb\xd6\x2d\x10\xc6\x35\xca\x44\x38\x8a\xc1\xa4\x72\x38\xa7\x41\xb7\x5e\x73\x36\x87\x32\xdd\xd4\x70\x11\xaa\x46\xc3\x8b\xda\xde\xfe\xd6\xf6\xc9\xf6\xde\x2f\x68\x1c\x3a\x88\x23\x6f\x28\xcc\x43\x5f\xe0\x83\xd0\x85\x05\x8e\xd6\x05\xd2\x26\xa7\xb2\xc5\x53\x69\xad\x82\xe6\x1d\x60\xd3\xc6\xa5\x4a\xea\x78\x78\x61\x09\x17\xa5\x84\x22\xb6\x6b\x58\x1f\x04\x39\xd5\x67\x9f\x09\xa3\x59\xb4\xca\x83\x2b\xcf\x7c\x03\x8a\x21\xc3\xfa\x65\x7d\x6b\x5e\xd5\x36\x87\x55\x6d\x53\x58\x55\x16\x8e\x55\xd3\x2c\xb2\x22\xa5\x53\xb0\x88\x61\xd4\x43\x70\x49\x44\x20\xaa\x80\xba\x69\x65\x03\xea\xfa\x1d\xdf\x15\x2c\xcb\xb6\x37\xc3\x31\x60\x4d\x69\x37\xc1\x7f\x9b\x66\x0a\xca\x26\xa1\xb9\xd6\xb8\xfe\x19\xf3\xa5\xe1\xd3\x90\x49\xcb\x27\x22\x0d\x0c\x76\xc7\x8a\x88\xb4\xc7\xae\x8d\xab\x53\x30\x52\xe2\xff\x5b\xfa\xe7\x15\x56\xbd\x3e\x45\x13\x07\xac\x5a\xb9\x16\x4d\xdb\xc6\x49\x44\x5a\x27\x10\xb2\x50\x9f\xd3\x7c\xde\xa2\x37\xed\x94\x4f\x27\xf2\x29\xa9\xf9\x4c\x58\xf1\x7b\x55\xa3\xbc\x9c\x40\x9d\x7b\x5c\x31\x8b\xce\x99\xf4\x71\xd0\x8b\x46\xb6\xe9\xc3\xba\x3c\x03\x80\x9d\x8d\x50\x86\x09\x4b\x3d\x61\x2e\xa4\xba\xeb\x5b\x1d\x45\x0f\x84\x26\xf4\x94\xf1\x63\xca\x5a\x8a\x93\x93\x98\x6f\xe2\xf7\xfb\xd4\xf3\x9d\x84\x06\x63\xe2\x40\xcc\x7b\x79\x02\x58\x80\xaa\x78\xfb\x5d\x60\xad\x55\x23\x3b\x1d\x30\x9f\x1a\x39\x21\x68\x17\xe6\x03\xe7\x8f\x31\xc2\x9e\x4f\x19\x76\x44\x21\x9a\x0f\x71\xc0\x18\x7d\xff\x14\x2c\x55\xe2\x21\xbd\x3e\x55\x36\x58\x8c\x26\xe4\xd4\xdc\xbd\x4e\x6b\xa4\xdd\x91\xa6\x99\x58\x0f\x31\x63\xd0\x7d\x9e\x05\x49\xe2\x8c\xb1\x2d\x31\xd0\x2a\xe1\x92\x29\xef\xc5\x3c\x92\xfd\x7c\x95\x0c\xc3\x80\x32\xb4\x9a\x75\x02\x16\x09\x9a\x1e\x93\x53\x6b\x6b\x3c\xad\x29\xb4\x9b\x1d\xbb\xd3\x04\xf0\xee\xe9\x39\xc0\xc3\x0e\x98\x96\x3a\x68\x94\x82\x66\x2f\xc2\x56\x04\x27\x5f\xf0\x85\x03\x8e\x20\xbb\x7f\x7c\x63\x19\x47\xc3\x92\x47\x06\x31\xed\x70\xd4\x44\xf2\xd8\x94\x42\x8d\x6a\xa8\xe3\x87\x3e\x3f\x8a\x12\xc1\x0d\xf4\x10\x2d\xd0\x93\xc7\xb8\x17\xc5\x7d\x34\xa5\xb0\x49\x2b\x8c\x4c\xae\xc4\x69\xac\xc3\xdb\xc4\x83\xe9\x28\x44\x43\x1c\x18\xa2\xc1\x0f\x7e\x36\x8d\x00\xa1\x0b\x4c\x8c\x38\x45\x62\xc6\xbc\x8b\xa9\x47\xaa\xc0\xf1\x02\xfd\xa0\xd0\x82\x16\x37\x60\xcd\x56\x95\xe6\x61\x08\x31\x45\x2b\x89\x69\x3b\x45\x1c\x46\x58\x14\xc1\xdf\x9c\x3e\x9a\x3d\x43\x60\x3f\x93\xbd\x28\xa1\x2d\xe3\x60\x1d\x46\x9a\x3b\xce\x63\x5f\xe6\x95\xe5\xae\xea\x1c\x98\x0e\x3b\x9e\xc7\xcf\xd4\x60\x56\xc8\x5b\x70\x02\x72\x0a\xe4\x7d\x6a\xf4\x4a\x4f\x8e\xbc\xf9\x9a\x34\x2b\xdb\x21\x04\x05\x8b\x62\xe2\xf9\x0c\x7e\xa6\xd7\x0b\xd3\x00\xe9\xcd\x94\x9c\x03\x8f\x33\xa4\x7c\x70\x37\xd2\xcc\xe1\x44\x2b\xbe\x2a\x9f\x80\xbe\x1f\x04\x3e\xa3\x6e\x14\x7a\x92\x04\x24\x0b\x95\x2b\xf6\x94\x0b\x88\xfc\xa0\x29\x45\x44\xb0\xd3\x1a\xc4\xd1\x85\xef\x89\x1d\x0b\x2b\x7e\x8d\x86\xa4\xef\x8c\xd5\xca\x76\x08\xf3\x21\x1e\xb7\x3c\x1a\x71\x51\xdb\xb1\x68\x80\x91\xc0\x3f\xa7\x2d\x65\x39\x86\x46\x73\xa7\x55\x04\x08\x0a\x21\xcf\xbf\xf0\xbd\x21\x90\x3e\x94\x2d\xd8\xed\x14\x80\x2b\xb1\x19\x09\x6c\xaf\x34\x1a\x55\x99\x02\x08\x5b\x53\x09\xd7\xd7\xf6\xd6\x84\x5f\xff\x82\xb7\x1e\x57\x22\x90\xec\x77\x72\x85\x90\x5e\xb4\x88\x74\xdf\xca\xe1\xa8\x4f\x09\x85\xcf\x88\xe8\x83\x29\xfe\x88\x33\xdb\xc0\x34\xad\x50\xcf\xaa\x4e\x02\x38\xeb\xa4\xef\x3d\x21\x8e\x10\x53\xee\x95\xa1\xd4\xcf\xa4\x49\x5e\x60\x85\x25\xd2\x24\x2d\xd2\xa8\x54\xc9\xc9\x39\x38\x45\x68\xae\xe3\xaf\x9f\x20\x1f\x3f\xc0\xeb\xb2\x3c\xda\xc7\x5d\x76\x04\x25\x96\x48\xf3\xd8\xf2\x4f\x7d\x02\xcf\xca\xd2\xb2\xed\x00\xde\x1f\x6a\xca\x92\x2a\xd9\x83\x9e\x33\xa0\xfa\x14\xf8\x28\xff\x60\x0d\xb5\x07\xe6\xce\x6c\x09\xbf\x83\x44\x84\x4c\x52\xb7\xb8\x55\x72\x04\x90\x94\x53\x29\xde\x61\xe1\x85\xcd\x26\x68\x78\xdb\x4a\xdc\x21\x4b\xa2\xbe\xc9\x49\x28\x67\x38\xb8\x9f\xd7\xc8\x66\x4a\x76\xd3\xe5\xe0\x31\x34\x87\xb3\xb5\xbf\x8b\x57\xab\x9c\x53\x39\xe4\xd4\x8b\x42\x7a\xaa\xd4\x2a\x35\xd2\xd6\x46\x3f\xfd\x28\xe6\x4c\x2f\xa4\xa4\x1b\x3b\x70\xe7\x6c\xb7\x8b\x00\x83\xa8\xeb\xbb\x35\xb2\xb0\x00\xec\x69\x61\x81\x28\x73\x05\xce\xa3\x58\xc2\x39\x1f\x88\xa2\xf8\x5e\x4c\x6a\x76\xfc\x8e\x5a\x47\x45\x52\x9c\x8d\xdd\x8d\x2b\xa1\x93\xe0\x3d\x96\xa6\xae\x28\x7b\xd5\xeb\xbc\x05\xdc\x83\x18\x33\xf7\x84\xd0\x83\xed\x18\x18\x7a\xdf\x89\xcf\x05\x1f\xe7\x9b\x12\x8a\xc4\xb6\xf6\x93\x03\xe3\x8d\xd4\xd2\xeb\xbe\x5c\xb2\x80\x96\xb0\x17\x55\xd4\x18\xe1\x09\x27\xbb\xa8\x80\x93\x5a\x63\x30\x79\x16\x3a\x85\x36\xa7\x58\x69\xbd\x3a\xc0\x83\x0c\xb5\xee\xbc\x94\xb1\xe7\xa5\x8e\xc2\x87\xbb\xc6\xc0\xa7\x5e\x8d\xb4\x43\x42\x2f\x93\xd8\x21\xe0\xb4\x86\x26\x34\x16\xfd\xf0\x59\x5b\xde\x3f\x01\xe3\x62\x43\xac\x22\x1c\x74\xf9\x2e\x98\x6a\x77\x0c\x31\x10\x2d\x98\x7d\x46\x22\x97\xcb\xfd\xf0\x7a\x06\x37\x3f\x61\xc3\x86\x1b\x53\x86\x67\x48\x0f\x8e\x30\x45\x2d\xf2\x26\xe9\x07\xe2\x50\x57\x25\x46\x2f\x5a\x84\x73\xea\x0a\x59\xfa\x19\x2c\x49\x14\x96\xa2\xac\xa8\x73\x23\x7a\x1c\x25\xad\xfd\x87\x61\x27\x8d\x15\xc8\xb9\x03\x62\xa8\xf7\x9f\x81\x97\x22\xaa\xa1\xde\xec\xcb\x0a\xa5\xd2\x3c\xfc\xdc\xa2\xb3\xb9\x3d\x4b\x49\x28\xb7\x9a\xb5\x1f\xda\xab\xbb\x90\x13\x1e\x68\x7e\x4c\xbf\xb2\xd3\x38\x77\x4d\x5a\xe4\xea\x7a\x1d\x7c\x3b\xec\xa1\x41\x3c\x35\xae\x36\x22\x21\xed\xbb\x01\x75\x62\x7e\xde\x40\x9a\xf3\x22\x17\xb6\x78\x90\xfd\xf4\xeb\xdc\x30\x8a\x84\x0e\xc6\xd4\xbf\xe4\x78\x93\x57\xaf\x2d\xaa\x99\x93\x98\x4a\x4e\x9d\x5e\x54\xba\x14\x9c\x55\x82\x10\xc5\xe0\x31\xab\x12\x5c\xf1\xcb\xe4\x7b\xbc\x73\xd5\xd4\x92\x4f\xa5\x71\xfc\x60\x92\x41\x60\x46\x19\x39\xb5\x76\x92\xac\x05\x8a\x27\x63\xdc\xe6\x63\xd5\x86\xa5\xe8\x52\x0f\x53\x9b\x76\xb2\x7e\x85\xba\x9c\xcd\x80\x0a\x2b\x19\x38\x58\x7e\x35\xd7\xf5\x9c\xa9\xc9\x9b\xe0\x11\xe3\x1a\xcd\xf9\x27\xb9\xd8\x28\xaf\x54\x2a\x95\xb4\xc3\x8e\xa7\x77\x72\xd8\xc1\x45\xc1\x33\x87\xd1\xd7\x34\x39\x74\xba\x45\xe1\x68\x56\x84\xa7\x6a\xe9\xe4\xf7\xbd\x7f\x5e\xe4\xbd\x70\x75\x55\xf8\xd9\x24\xa7\x58\xf6\x7f\x25\x11\xba\x98\x39\x25\x31\x65\x1c\x25\xb1\x7c\xf0\xce\x6a\xbc\xef\x70\x21\x31\xee\x9f\x45\x01\xf6\xa0\x74\x84\x7a\x49\x72\x00\x89\xc7\xc6\x63\x5d\x78\x4c\xc1\x38\x4f\x3e\x85\x07\x29\xa7\xb8\x2a\x1c\xc6\xfc\x8e\x2f\x25\xaf\x53\xac\x77\x4a\x06\xb1\xdf\xf7\xe1\xc6\x2b\x8a\x85\x7f\x4e\xe5\xf6\x0e\xc3\x1d\xc3\xcf\x3e\xe5\x32\xfe\x7e\x87\x9c\x60\x8e\x1f\xba\x94\xac\xd6\x1a\xb5\x06\x7c\xf3\x5d\xa0\x1b\xc5\x63\xf2\xde\x01\x3f\x3b\xca\x65\xde\xc2\xb5\x78\x15\x73\xa8\xde\xc7\x24\x11\x7a\x38\xab\x19\x3e\xf2\x18\xb9\xe2\x5c\x9d\x3a\xe1\x35\xf9\x24\x52\xc4\x93\x30\x7b\x1c\x8e\xc0\x42\x15\x6f\x85\xc4\x23\x19\x04\x25\x9e\x4e\x89\xde\x9f\xd4\x7c\x86\x83\x2c\xe3\x9f\x9a\x9f\xd0\xd8\x81\xc8\xd3\x3c\x1f\x3d\xd8\xf0\x36\xb2\x15\x4a\xce\x99\x5b\x32\x8b\x41\x33\xf0\x78\xc6\x50\x8e\x8a\xc2\x22\x6a\x83\xe1\xa1\x51\xa8\xdb\x85\x37\xfe\x0d\x52\xc2\x3e\x97\xc8\xf7\xef\x40\x21\x65\x93\x44\x64\xfd\xc7\x8f\x0d\x1a\x93\x89\x1b\x1b\x7a\xd6\xd1\xa7\x79\xc6\x4d\xa0\xec\x47\xd6\x6f\xe7\xb3\x7b\xf5\xdb\x99\x1f\xe7\x5b\x81\x99\xd7\xbe\x43\xe6\xab\x3a\x0e\x07\xb2\xb7\xb9\xeb\x8a\x76\x4e\x03\x4a\x7e\x79\x3b\xf0\xc5\x4f\x7a\x9b\x46\x70\xd5\xe2\x4c\x0d\xc0\x67\xbb\x43\x5f\xec\x1f\x80\x00\xfd\x99\x2a\xa4\x95\xb7\xa2\x98\x4a\xb8\x95\x93\x99\x33\xe7\x8c\x06\x1f\x82\x61\xd7\x0f\x5f\x05\xd1\x08\x14\xe7\x6a\x73\x82\x1b\x36\x3e\xe3\x27\x7b\xc2\x46\x35\x17\x54\xed\x36\x40\xc0\x55\x7a\x9e\x47\x9d\x9a\x13\x8e\x81\x41\x52\x16\xf8\x61\xb2\x24\x95\x23\xf8\x80\xba\x8e\x9a\xb8\x25\xc1\x56\x97\x94\xef\x5f\xc3\x2d\x45\x31\x82\x0d\x47\xd1\x3a\xea\xac\x49\xd6\x88\x2c\x7d\xb1\xd3\x77\x06\x46\x9d\x94\x37\xe9\xd4\xdb\x12\x70\x52\x8a\xf5\x6d\xef\xf0\x15\x59\xfc\xf1\x63\xb3\x90\x79\x13\x94\x71\x24\x6d\xc4\xce\x80\x1c\x71\x67\x6d\xbb\x55\x29\x97\x54\xb1\x12\x38\xea\x30\x4a\xea\x70\xbe\x8b\xa4\x44\x4a\x64\xd1\x08\xf0\xdb\xd2\xbf\xe7\x88\xe5\x85\xda\xf4\xee\x61\x12\x5d\x99\x4a\x31\xb5\x3f\xf4\x79\x3d\x66\xa1\x6d\xc2\xd0\xa9\x14\x82\x1e\x3f\x56\x75\x95\x3b\x19\xa9\xd8\x87\x1b\x6b\x91\x5b\x81\x1b\xa0\xa5\x66\x4e\x67\x14\x69\xdf\xd0\x9d\xc2\x76\xf2\x9a\xb0\x19\xca\xf3\xbf\xd2\xed\xd5\xbd\xf1\x1f\x26\x5f\xe5\x67\x3c\x5a\xd9\xb0\x97\x0b\xd6\xf2\xd3\x4a\x7e\xf9\x95\x09\x8e\xa2\x52\x90\x15\x04\xe1\x9e\xbf\xa8\xa9\xd5\x74\xc1\x49\x6d\x48\x58\xaa\x4e\x81\x4d\x40\x51\x63\x6b\x37\x55\x9c\xd4\x78\x51\x5b\x86\x3b\xad\xce\x3a\x97\xdc\xff\x25\x9e\x92\x52\x4f\x33\xe7\x0f\xce\x80\xc6\x3f\xd2\xeb\x97\x0e\xb6\x5d\xe4\x97\x2b\xa7\xe8\x24\xf0\xba\x94\xaa\x38\xf2\x93\x9e\x72\xf8\x90\xd7\xc6\x93\x9c\xa2\x93\xda\xd0\xa5\xb4\x7b\x31\x8e\xa8\xa2\xe9\x5b\xb5\x8b\x4d\x02\x0d\x05\x54\xf1\x83\x84\x0e\x36\xa3\x30\xa4\x6e\x12\x15\x41\x7f\xb2\xdc\xc8\x2f\x3f\xa9\x19\xab\xa0\x55\xbd\x28\xc6\x6c\xe3\x89\x55\xec\x26\xe0\x7f\x9a\x07\xef\x29\x37\x6f\xb9\x35\x82\xbe\xfa\xce\xa2\x80\x0d\xed\x06\x99\xe0\x6f\x29\xa8\xdc\xa6\x53\x5a\xa0\xbb\x5b\xbf\x24\x9c\x69\xba\xa6\xb6\x82\xcc\xde\xa0\xf5\x0a\x90\x52\x4e\x7a\x34\x25\x0d\x09\xf1\x26\x8a\x92\x96\x8e\x70\x81\xce\xd3\x5b\xa4\xd4\x09\xe8\x65\x49\x1a\x6b\x0d\xd0\x7f\x07\xdc\xd6\xf5\x69\x8d\x0d\x1c\xd7\x0f\xbb\xb5\x61\xe8\x27\x64\x81\xac\xa0\x98\x81\x85\x7b\x51\xec\xff\x11\x85\x89\x13\x68\xa8\x1c\xd6\x96\x1f\x53\xe8\x50\x8b\x94\xe2\x68\xa4\x40\x3b\x81\xdf\x0d\x77\x12\xda\x67\x2d\x52\x72\xa9\x70\xc7\xa9\xe1\x5d\x70\x3e\xec\x4e\x82\xe6\x46\xc1\xb0\x1f\x8a\x4a\x68\x60\x73\x7d\xbb\x99\xdb\x8f\x7d\xa9\x60\x29\x74\x05\x89\x66\x0d\xe5\xa3\x92\x1e\x20\x04\x7e\x13\xdd\xc3\xd8\x6e\xb7\x68\xd3\x54\xd1\x68\xeb\x06\x8a\x57\xcf\xc2\x84\x93\x71\x46\x53\xfe\x83\xc6\x11\x9c\xac\x3c\x11\xdf\xc4\xb8\xd8\x84\x72\x9c\x91\xb4\x8a\xba\x2d\x63\xc9\x9b\xcd\xec\x74\xe0\xc2\x37\x89\x48\x89\x0b\x17\x25\xb8\x3c\x89\x0c\x24\xf8\xcc\x98\xc7\xaa\xb2\x6a\x08\x85\x51\x36\x1d\x88\x00\x42\x70\x0f\x7c\x46\xc9\x20\x52\x97\xd6\x43\x30\x4c\x04\x65\xa9\x6b\xdd\xc1\x06\x09\x8d\x43\x70\x84\x05\xb1\x3a\x0a\x3b\x9c\x73\xf9\x39\x8a\x88\xbc\xbf\x39\xfd\x09\xb8\x6f\xdd\xbc\xf7\x36\x6e\x52\xb5\x3d\x8a\x38\xc2\xce\xc6\xf7\x2c\xeb\x32\xf2\x62\x26\x28\xc6\xad\xd9\x3d\x40\x68\xcd\x36\x92\x42\x2c\xb3\x9e\x33\xa0\xe5\x59\x60\x16\xdb\xe6\x7c\x66\xb4\x33\x0c\x38\x59\xa1\x24\x27\xa8\x65\x1c\x50\xa9\x58\x05\xd5\x49\xde\xb4\xa1\x37\xa0\xc2\xde\x8a\xb0\x2b\x56\x6b\xff\xf2\xbb\x61\x14\x53\x1b\x06\x9e\xa9\x8a\xc6\x8c\xf1\x3e\xed\x7b\x48\xc3\xaa\x21\x89\x80\x96\x03\xc7\x05\xbd\x7a\x32\xa2\x34\x24\xd4\x71\x7b\x40\xf2\x46\x6f\xa5\x44\x50\xdc\x5f\x6d\x02\x75\x3b\x3a\x54\x7b\xc8\x8c\x14\x28\xeb\xdf\xcf\xbc\xcb\x63\x5e\xf5\x96\xab\x09\xb7\xe7\x19\x87\x00\x95\xef\xa7\xff\x1c\x54\xe5\xb8\x92\xcf\xfc\x7a\x94\x9c\x72\x5e\x32\xa0\xf1\x29\x32\x32\xf0\x67\xc7\x98\xcf\x12\x74\xce\x0c\x1e\xc5\x03\xf4\x5b\x45\x85\x7d\x71\xe0\x87\xd4\x89\x09\x84\xf9\x50\x04\x11\x46\xe1\x7b\x48\xbf\x0d\x53\x13\x9c\x74\x00\xd6\x6a\x9a\xf5\x96\x03\x67\x0c\x16\x16\x41\x34\x22\x9e\xdc\xe6\x0c\x9e\x6f\x14\x9e\x4c\x7f\x93\xf6\x2a\x34\xdc\x54\x32\x82\xc0\x43\x3a\x1c\xab\xde\x5e\x54\xb0\x54\x9d\xa4\x37\x70\x9b\xb1\xeb\xa2\xa9\x8c\xaa\xa9\xfc\x50\x81\x0c\x85\x2e\x83\xb2\x6a\x5a\x37\x02\x1e\xe1\xac\x42\x3c\x55\x15\x33\xe2\x93\xe5\x1a\x98\xab\x55\x6a\xc3\x91\xa9\xb2\x98\x9a\x3b\x55\x44\xa5\xa8\x78\xb0\x96\x78\x20\x5e\x9a\xe9\x34\x2b\x6c\x2c\xd9\x40\x75\x49\xd1\x09\x54\xc7\xb5\x51\x76\xed\x1a\xa5\x7c\x92\xd2\x58\xc3\x08\xb2\x80\x21\xf5\x13\x54\x42\xfc\x43\x5a\xc4\x57\xc1\x01\x3e\x0e\x8c\x7f\xa8\x21\xf0\x0f\xa3\xab\x28\xa5\xc8\x08\x6f\x86\xd6\x12\xfa\x6c\x9c\x1c\x75\x37\x45\xdb\x35\x2e\x27\x56\xed\xc9\xa9\x66\xe7\xfe\x05\x3a\x44\x68\xc9\x49\x3e\x32\x1a\x17\xd1\x6f\x31\x18\x86\x3e\xac\xd9\xf3\xf4\xe2\x06\x93\x6a\xb3\x70\x95\x5c\xd9\xab\xc1\x9c\xa8\xeb\x0a\x69\xa9\x87\x0b\x66\x40\x3b\x75\xb4\x49\x29\x03\x93\x08\x8d\x74\x2c\x43\x6f\x94\xb1\x29\x48\x6a\x16\x80\x54\xfc\x39\x5e\x26\x15\x7e\x4e\x8c\x93\xf3\x10\x53\xd6\x23\x05\x21\x50\x8b\x06\xa2\x96\x19\x50\x89\x71\x15\x87\x34\x8e\xee\xd8\xbc\x54\xba\xd0\xaa\xa6\x93\x03\x87\x25\xa2\x59\xb2\x48\x9a\xc0\xa2\xed\x51\x09\xb3\xa5\x82\xa5\xdd\xca\xa4\x64\x16\x5b\xcb\x9e\x4f\x14\xca\x0d\x43\x7e\x93\xa5\x6c\x6c\xa4\x43\x00\x9b\xf8\xaa\xa5\xde\x6b\x11\xdb\x17\xc1\x23\xbd\x70\x1f\x3f\x36\x39\xd5\xcf\x13\x81\x2a\x8c\xdd\x1a\xee\x4f\x13\xe1\x4a\x8c\xdb\x60\xad\x47\x57\x47\x8f\x32\xcb\xe5\xf1\x63\x63\x29\x3c\x7e\x2c\xa6\x46\x38\xcb\x98\x6e\x21\x68\xa5\x32\xc6\x22\x14\x19\x10\x89\xb0\x8c\xf0\x96\x48\x13\xe2\x66\x2d\x25\x91\x0e\x50\x48\xea\xf5\x94\x0e\x7e\x89\xef\x6d\x60\x4b\x9b\xd4\xc3\x48\xc4\xb0\x83\xb2\x4b\xe7\x74\x2c\x54\xc9\xd5\xc9\xdd\xc2\x75\x00\xdc\x44\x2a\xfc\x34\x2b\xb9\xba\xae\x5a\x48\xab\xa2\x5c\x85\x9b\x4e\xe5\x58\x6a\xa9\xd3\xfa\x7a\xa3\xa9\x9c\x70\xd6\xa8\x2a\x92\x45\x90\x1e\x8b\xda\x27\xec\xf7\xa1\x13\x2b\x67\xcc\x34\xa0\x17\x62\xc1\x35\xaa\x96\x4e\x5e\x71\xc6\x6b\x11\xc1\x58\xdc\x8c\x02\x2b\x50\xd1\x79\xc5\xae\x39\xd3\xa3\x87\xb2\xf0\xc8\x74\x75\x9b\x53\x9c\x25\x79\xdf\xf2\x48\x95\xaa\x3b\x9d\xc4\x9d\xae\xa4\x57\xf9\x5f\x22\xd6\xce\x74\xa4\xca\xa9\x3b\xf5\x61\xea\xc7\x88\xd3\x29\xac\x4e\x27\x3d\xa6\x2a\xdd\x8b\x14\x68\xc0\x9c\xbb\x16\xcb\x36\x75\x25\xa0\x57\x0f\x27\x58\x2e\x9f\x98\xd2\xca\x44\x6a\xad\x4c\x0b\x31\x2b\xf1\x4c\xc0\xc3\xb4\x50\x0d\xd9\xe8\x41\x15\xf0\x27\xa8\x02\xa6\x9e\x17\x25\xcb\x4e\xe4\x3c\xb7\x02\x27\xe4\xe1\x89\xc7\xfe\xa9\x01\x1a\x72\xf4\xc3\xe9\xfe\x7f\xc0\xe9\x7e\xda\x89\x35\xcf\x44\xf7\xc0\x5f\xcc\x53\xd5\x64\x4a\x99\xc4\x81\x51\x9e\xea\x54\x84\x65\xa0\x94\x28\x72\xcc\xf8\x4c\x21\xa1\x91\xbf\xfb\x2b\x59\xdf\x54\x50\x4d\x14\xa1\x52\x37\x61\x4a\x8a\xc2\x77\xef\xa9\xcd\x49\x81\xb7\xf6\x1e\x73\x6c\xa0\x55\x90\x63\x10\xb7\xf1\x64\x83\x94\x44\x52\x29\xd7\x70\x0e\xb0\x6d\x5c\x28\x6a\x4c\xe3\xcd\x45\xa5\x2c\xaa\x57\x7e\x84\x61\xdd\xb3\xc6\xd4\x21\x61\x65\x24\x09\x9f\xa5\xc3\xb2\xea\xd7\x54\xf2\x3d\x06\xbe\x4a\x03\xaf\x9c\x2c\xcf\x1a\x0d\xcd\xcf\x1a\xb5\xa6\x30\x3f\x4b\x59\xa7\x29\x6b\xb4\xcf\x89\x1f\xe4\x5a\xa3\xb5\xc3\x31\xfe\x4a\x19\xa1\x2d\x18\xe6\x67\x68\x74\x96\x67\x5a\xc6\xcf\xa6\x91\x8c\x43\x7d\x45\x4a\x4e\x09\xfc\xf4\x9b\x1e\xfa\xa3\x80\xd6\x82\xa8\x5b\x3e\xa9\xf9\x1e\x0d\x13\x3f\x19\x97\x05\x67\x86\xb5\x2f\x7e\x67\x0d\xd1\x4c\x03\x33\x59\x31\x6b\x60\x06\x29\x05\xe6\x60\xa2\x56\xc6\x1c\xec\x59\x73\xd2\x54\xe5\x04\x07\xbf\x85\x25\xc7\x6c\x41\xc7\x55\x27\x9c\x2a\x39\xb3\xc6\xe7\x90\x9f\xc8\x19\x79\x41\x96\x9a\xa4\x45\x1c\xf2\x33\x7c\x88\xdf\x1b\xf0\xd1\x20\x2d\xb2\xe7\xec\xad\x83\x65\x47\x7a\xa4\x13\x43\x96\xdf\xcf\x48\x45\xc4\x8a\x85\x3a\x3a\x73\x28\x8c\x8e\xdf\x90\xd1\xf1\x27\x98\x34\xdc\x05\xec\x89\xe6\x04\x39\xe0\x6b\xe1\x84\xc0\xfd\x0a\xc6\x6c\x5d\x68\xc2\x56\x72\x92\xc0\xae\x52\x34\xbc\xc6\x7d\xc0\xbe\xc3\x18\x6d\x40\xb3\x75\x66\xd9\xd0\xec\x15\x0e\x74\xf9\x3e\x60\xdf\x61\xa0\x36\xa0\xd9\x3a\xb3\x22\x08\x82\xf5\xa3\x28\xe9\x15\x0e\x75\x65\xf5\x7e\xc0\xdf\x61\xb4\x69\x50\xb3\x75\x68\xf5\xe4\x64\x98\xf8\xc1\xc9\x87\x61\x4c\x3f\x81\xff\x97\xe2\x65\xba\x36\x5b\x13\x6b\xa2\x09\x10\xc2\xf8\x6e\x54\x4c\x41\xcd\x95\xca\xba\x65\xeb\xa5\xc3\x6c\x39\x8c\xf9\xdd\x90\x7c\xff\x6e\x18\x59\x62\xfc\x37\x2b\xda\x9e\x11\x30\x34\xfd\x92\x52\x84\xff\xc4\xd0\x76\x0c\x42\xb3\x5b\xcf\x1f\xfd\xe3\xf5\x4c\xd4\x3e\x2c\x76\xab\xc0\x7d\x58\x45\xc6\xee\xbb\x92\x11\xec\x44\xf4\x3e\xcc\x35\x02\xf8\x65\x83\xd9\x29\x2b\x2c\x90\xb3\x30\xa4\x58\xca\x4d\x93\xfe\xb2\x64\x4c\x9f\x32\x81\x13\xe1\xe7\x3f\x83\x1a\x11\x0b\x15\x2f\x20\x72\xd0\x82\xd1\x9e\x06\xa8\x56\x87\x52\x80\x16\x9d\x5c\xd3\x11\xca\xc8\x46\x41\x3a\x9f\x23\xf0\x1b\x65\xe6\x9b\x61\xcb\xa4\x86\x13\x90\x3a\x0f\x1b\xf9\x3c\xc7\xb6\x2e\x5e\x31\xab\xca\x08\x68\xaa\x5a\xbe\x19\xa4\x1c\xb9\x51\xf3\x9c\x8e\xcd\x6f\x8c\xc8\xa7\x82\x80\x2b\x8c\x1a\x71\x14\x00\x71\x49\xa4\x94\x8b\x5c\xdc\x92\xae\xd0\xa5\x8f\x7d\x91\x5d\xc9\x22\xdf\x00\x64\xc6\x7d\x33\xea\xac\x2b\x97\x49\x0a\xee\x24\x28\x76\x17\x54\x60\x47\xa3\xc4\x3a\x58\x68\x95\x6d\xdb\x3d\x79\x13\xb3\x5c\x25\x27\x09\xed\x0f\x96\xd7\x1f\x22\x24\x3e\x44\x48\x7c\x88\x90\xf8\x97\x45\x48\x14\x27\xbf\x7f\x75\xfc\x80\xee\x5f\xd0\xf8\xc2\x07\x6a\x75\x13\x27\xec\x06\x78\xe6\x11\xff\xf8\x22\xee\xd2\x44\xe4\xd1\x0f\x4e\xd2\x4b\x79\xb9\x37\xb3\xca\x97\x55\x32\xae\x92\x91\xef\x25\xbd\x2a\xe9\x51\xbf\xdb\x4b\xaa\x24\x76\x3c\x7f\x68\x5c\xc2\xf7\x9d\xcb\x4f\x90\x44\x36\xc8\xae\x93\xf4\x6a\x7d\x3f\x2c\xc3\x0f\xe7\x8c\x95\xa1\x72\x85\xd4\xc9\x72\x95\xa8\x44\x04\x05\xa9\xfa\x16\x93\x6f\xc0\x1b\xa2\x15\x08\xf3\x2a\x4e\x24\x4b\x4d\x75\x43\x1a\x44\xee\xf9\x17\x9f\xd1\xdc\x72\x0d\x59\x6c\x80\xa3\x32\x7c\xe7\xf3\xa9\xd1\xdd\x14\xd7\x57\x38\x0e\x93\xf1\xa0\xce\xd0\xb8\x1e\x0d\xe9\x48\x0d\xed\x48\x38\x2f\xb0\x77\xbc\x2a\x41\xc7\x0a\xab\xb8\xf5\x81\x53\x04\xdf\xf4\x88\xa0\x40\x60\x94\xd9\x58\xfd\xfe\xd9\x40\xdc\x0b\xe3\x77\x4b\x97\xb1\x2e\xe9\xc4\xa8\x4a\xbb\x25\xb2\x48\x2e\xc9\x22\x29\x55\xe1\x0a\x6d\x4c\x16\x11\x77\x0b\x46\x5b\x8d\x63\xcb\x59\xa1\x91\xce\x47\xaf\x7b\x07\x40\x17\x37\x48\xa9\x0d\x6f\x34\xac\x82\xb2\x85\x4c\x62\xa3\xda\xa8\xe2\x8b\x0e\x39\x1d\xaa\x33\x97\xa9\xf2\x15\x95\x35\xce\x0e\x86\xb7\xfb\x9e\xa8\x7a\x40\x29\x64\xc9\xa8\xdf\xb4\xeb\xe7\x8c\xa7\x39\xed\x78\x9a\x79\xe3\x69\x4e\x1a\xcf\xbf\x43\x22\xfe\xd9\x3d\xac\xdc\x80\xfa\xe6\x71\xc5\x74\x7f\x5c\x38\xd2\x14\x1c\x41\xcf\x4b\x59\x80\xcb\x05\x73\xb9\x3c\xed\xd8\x97\xf3\xc6\xbe\x3c\xcb\xd8\xad\xd9\x59\x3e\xce\x1d\xc2\x8d\xa3\xd7\x10\x56\x0a\x21\xe4\x0c\x77\x65\xda\xe1\xae\xe4\x0d\x77\x65\xfa\xe1\x5e\x4e\x3b\x31\x2b\x05\x33\xfd\x5b\x09\x6e\x8a\xf5\x95\x7d\x11\xeb\xe1\x3b\xf9\xa2\xf8\xad\x53\x8d\x51\x82\xcc\x65\x32\x21\xc5\x5f\x15\x48\xc5\x8f\xd7\x53\x6c\x22\x6f\x2c\x62\x08\x1a\x24\xe0\x5f\x0f\x9f\xff\x43\x74\x1a\xad\x4a\x08\xa9\xa4\x1b\xb8\x40\xaa\x0d\x5c\xc3\xd9\xd6\x72\xd6\xff\x94\x35\xef\xa9\x9f\x13\xd6\xf4\x44\x34\xdd\x72\x39\xff\x19\x28\x9f\x84\x40\x73\x79\x4d\x1c\xcc\xed\x2b\xdf\xbd\xf7\x37\xac\xb8\x54\x97\x88\xb5\xbe\xae\x26\x52\x3d\xd0\x0d\xe9\x41\x2a\xa2\x87\x7f\x5f\xc0\xb7\x68\x46\x17\x58\xd2\x25\x44\x13\x86\xa9\x07\x6f\x41\xdb\xed\x2b\xe1\x4a\xc9\xa1\x13\x74\x29\x79\x5a\x90\xa3\x79\x67\x9e\xd4\x17\x94\x3e\x77\xa1\x7e\x5c\x11\x8f\x9e\xc8\x06\x29\xe3\xb9\x8a\x6c\xc8\x93\x96\x1d\x41\xb0\x30\x76\xa0\xea\x56\x95\x9c\x14\x05\x0d\x54\x65\xca\xe9\xf8\x5b\x56\x30\x40\xda\x1f\x54\xd1\x45\x34\xdc\x00\xc9\x88\x05\xf9\x11\x05\x15\x4c\xc9\x85\x66\xf0\x3b\xa5\x9d\x4c\x35\xa6\x75\x32\x75\x93\x83\x29\x6d\xa5\x93\x28\xa4\xe2\x8f\x29\x43\x1d\x4a\x23\x18\x35\x3e\x43\x0a\xff\xfe\x5d\x4a\xf2\x5d\x5b\x92\xd7\xc8\xa8\x80\xce\x46\xf8\xa0\xc2\x6b\xb9\x23\x0e\x38\xe5\x7d\xaa\x22\x10\x2d\xff\xea\x88\x76\x62\xc0\x49\x94\x38\xc1\x7b\x40\x1c\x17\x87\xc5\xeb\x13\x9c\x24\x5e\xa9\x78\x18\xc6\x04\x56\x14\x45\x9b\xba\x1f\x93\x64\x8e\xb0\x3d\x69\xa6\x95\x0a\x1a\x57\xaa\x0a\x7f\xc5\xd9\xb7\xd1\xda\x26\xcb\xf3\xbd\x25\xf0\xd4\xb1\xc4\x68\xb2\x84\xe3\x00\xa3\x60\xf5\x58\x74\x8a\xa8\x74\x66\x88\x82\xc8\xa3\x2a\x78\x0f\x78\x8a\xea\xd2\xe4\x50\xa3\xc3\x74\x7d\x0d\xc1\x34\x74\x96\x0a\xc2\x94\xad\x55\xae\x18\x1e\xce\xa1\xad\x7c\x88\x99\x70\x40\x73\x26\xdf\xb3\x66\xc5\xf8\x30\x0a\x5d\x9b\x21\x1e\xe6\xcc\xbf\xf0\x0e\x48\x9a\xc6\x21\xc6\xd1\x41\xb6\x78\x77\x94\xc6\x56\xca\x7b\x76\x71\x90\xa0\x29\x7c\x5f\x13\x72\xa9\xdd\x5e\x5f\x9a\xe9\x63\x9d\x3e\x36\xd3\x91\x31\xaa\x3c\x3c\x10\x1a\xf9\x82\x95\xaa\x02\xe2\xa8\x68\x94\x90\x12\x8f\x2c\x81\xdf\x66\x09\xd3\xda\xf7\x24\x65\x53\x6d\xc6\xa9\xca\x99\x62\xf4\xa3\x69\x64\xac\x67\x50\xb1\x5c\x88\x0b\x15\x50\x65\xdb\x61\x18\x34\x49\xd4\xa8\xa5\x72\x72\x2b\x6d\xe9\x78\xe8\x99\x6a\x32\x2f\xb7\xe2\x4b\xda\xf5\x73\x6b\x41\x86\x59\xc5\x67\x6d\x99\xd7\x96\x16\xa7\xb2\x56\x26\xcf\xae\x88\x21\xf8\x26\x55\xcf\x2d\xb1\x3e\x67\x06\xf8\xba\x04\x8d\xcf\xe2\x25\xe7\x78\x63\xfc\x0d\x6f\x25\x91\x28\xe0\x1b\x7f\x7e\xff\x2e\x09\x01\x12\xc5\x6f\x55\x92\x4b\xbb\x0d\xa3\x10\x7c\x9b\xcb\x2d\xe3\xcc\x5d\x31\x72\x9c\xc9\xc0\x19\x4b\x15\xcf\xc6\xad\x6f\x7c\xca\x95\x72\x29\xa6\x6e\xcf\x89\x13\xb6\x14\x4b\xa6\x57\x32\x3d\x31\x58\x61\xcd\x1e\x15\xe0\x26\xa7\xc3\xb7\xb8\x44\xac\x39\x29\x03\x87\x12\x97\x2b\x4a\xda\x1a\x14\x6c\x50\x6f\x94\x28\xf2\x2e\x3d\x8e\xe6\xcf\x41\xa2\x80\xdd\x88\x32\x69\x00\xd1\x4e\x92\xd8\x3f\x1b\x26\x94\xa1\x8c\xa1\x17\x41\x65\xe6\x86\x28\x34\x84\xae\xed\xc1\x6d\xdf\xc4\x46\xae\xf2\x16\x79\xcb\x98\x4d\x93\x66\xbd\xd6\xad\x94\x50\x9a\xbb\x56\x2a\x19\x9a\xb9\x87\xe9\x51\xf0\x6f\x7f\xe9\x56\x73\xf4\xb8\x2c\x14\x38\xb8\xc4\xad\x3d\x83\x1f\xfa\x4c\x34\x74\xe2\xa8\xdf\x22\x57\x38\xea\x96\x3d\xf8\x96\x42\xc2\x65\x8b\x70\xe4\xb4\xc8\x58\x3e\x46\xc5\x7f\x49\x34\x7b\x5d\xe9\xc4\xb5\x95\xe5\x71\x13\xb8\x66\x2b\x9d\x90\x62\x60\xe2\x6d\x40\xc1\x9a\xd2\xb3\xa8\xab\x19\xe2\x6e\x4c\x3b\xcb\xf6\xb6\x0c\xca\xc0\x61\x1c\x7f\x91\xfb\x12\x2f\x92\xdd\x96\x00\xdd\xc3\x38\x7e\xa3\xb6\x27\x28\x97\xdd\x9d\x64\xc1\x5f\x55\x99\xcb\xbc\xec\xaf\x2a\x7b\xbc\x6e\xee\x6d\xf7\x48\x67\x77\xa7\xb5\x34\xbd\x4d\x4d\x73\x9a\xee\x4a\x8d\xc1\x25\x9e\x08\xad\xcd\x16\x9c\x96\x08\x65\xab\x25\x31\x2d\x92\xd2\x40\xbf\xc5\x96\xff\x38\x15\x9a\xf5\xa1\x14\x69\xe4\x94\x74\x24\xfb\x40\xce\x50\x62\x49\x1c\x9d\xd3\x2d\x87\xf5\xc0\xc6\x3f\x53\xfe\x0c\xc7\x52\xbc\x65\x92\xe9\x09\x99\xa4\x08\x74\xc2\x7e\xca\xff\xd1\x7c\x72\xb7\x4a\x5d\x57\xa7\x9c\xce\xbf\xe1\xf6\x60\x46\xd7\xfb\x81\x1b\x44\xaa\x99\x0c\xbd\xde\xb4\x4d\x90\xfc\xad\x02\xd6\x70\x15\xd7\x6a\x55\x73\x88\xaa\xc1\x05\xd4\xd6\x91\x06\x17\xd3\x8e\x25\x6f\x77\x52\x31\x7e\x8c\x09\xc5\xce\x8b\x80\xa9\xfc\xcf\x7a\xaa\xcc\xb5\x4d\x0f\x95\x8a\xf1\x9d\x73\x24\x30\x43\xea\x1c\x5b\x0f\x4c\xd4\xe9\x0c\xa2\x6f\xdc\x4c\x48\x47\xf3\xea\xd8\x3f\x7f\x5c\x51\x17\xb5\x35\xe1\x36\x41\xda\x3b\x7e\x32\xe4\x1f\x59\xc4\x7c\x24\x62\x91\xdb\x6d\x27\xdf\x85\xc9\xff\xf0\x69\xfb\x60\x7b\xef\xb0\x7d\xb8\xb3\xbf\x77\xd2\x3e\x3c\xfc\xb4\xf3\xf2\xf3\xe1\xf6\x01\x9f\xfe\xdb\x83\x44\x5d\xc9\xf6\x2f\xdb\x7b\x87\x19\x58\x57\xe9\xa7\xd5\xb7\x33\x79\xaa\x39\xea\xd9\x35\xe1\x9b\xe2\x0c\xf5\xa5\x07\x03\xc2\xb7\xd3\x3b\xd5\x17\x5b\xf6\x9d\x60\xc8\x8d\xfe\x4e\x40\x70\x8d\xcc\x04\xc4\x30\x3e\x9f\xbd\x0b\xb3\x34\x0c\x7b\xc5\x31\xac\xeb\x0c\x1b\x9f\x69\x24\xf8\x26\xba\xf0\x1c\x75\x27\x98\xf6\xde\x75\xc7\xd9\xca\x6c\x70\xf7\x05\x4f\x0a\x77\xb3\x92\x41\xf9\xa8\x44\x1d\x06\x4f\x81\xf9\xdf\x25\x3f\x54\x3f\xa3\x61\x62\x24\xcb\x4f\x7c\xbd\x0e\xef\xbf\x4d\xee\x95\xb5\x36\xbf\x14\x46\xe6\x63\xf1\x57\xac\x9c\x86\xb9\x02\xe0\x03\x62\x27\x52\xa9\x7f\x88\x3a\xe4\x2c\x8a\x3d\xf0\xbd\x9c\xc9\xe9\x44\xc3\x98\xb8\x51\x1c\xd2\x98\x61\x30\x0b\x79\x45\xcc\x88\x23\x7c\xf0\xe7\xd5\x0b\x68\x27\x59\x4a\xa2\x41\x15\xa3\xb1\x9a\x3f\xcf\xa2\x24\x89\xfa\x55\x2c\x82\x1f\x19\xc8\x21\x01\xca\x35\x56\x5d\xa3\x80\x86\x95\x81\x7b\x21\x45\x6a\xc7\xb8\x29\xfa\x6a\x14\xd0\x49\x53\xc4\x28\xc8\x4c\x39\x4e\xdc\x9c\x54\x33\x2e\x57\x2a\xe0\xef\x07\x66\x04\x3c\xa1\xce\x68\x92\x6c\xa9\x8a\x6d\xa3\xe2\x95\xbf\x93\x51\x71\x10\x79\x0e\xeb\x9d\xf8\x0c\x34\xd4\xc5\x36\x85\xcf\x66\x35\x2f\x4e\x37\x70\x27\x3b\xe3\x34\xb0\x59\x8d\x82\x15\x1c\xe9\x4f\xba\x78\xe0\x4f\xee\xb1\x8d\x3b\xd9\x1f\xe7\xc0\x9b\xd5\x54\xf8\x87\x58\x92\x2f\xdf\x83\x25\xf9\xf2\xdd\x2c\xc9\x57\x7e\xa0\x25\xf9\xca\x7d\x59\x92\xaf\xdc\x83\x25\xf9\xea\x89\xb7\x72\x02\x8f\xb4\x8a\x67\xf1\xf9\xf3\x59\x2d\x8d\x7f\x9c\x95\xfa\xda\x7d\x59\xa9\xaf\xdd\x83\x95\xfa\x93\x1f\x6f\xb5\xfd\xf4\x96\x56\xdb\x33\x34\xf1\x4c\x34\xb1\xe5\x24\xce\x0d\x2d\x80\xbf\xd1\xb9\x07\xd3\xf0\x07\xd3\xf0\x07\xd3\xf0\xfb\x35\x0d\x7f\xb0\x0c\x7f\xb0\x0c\x7f\xb0\x0c\xff\x9b\x59\x86\x6f\x0e\xe3\x0b\xcb\x2a\x1c\x57\xf0\xe6\xe7\x4f\xbf\x6c\x9f\xbc\x6a\x6f\x1e\xee\x7f\xda\xd9\x3e\x10\x07\x6d\x97\x17\x7e\xe9\x30\x9f\x6d\x06\x11\xa3\xde\x24\x65\x80\x29\x7d\x49\x3d\x60\xba\x3e\x2a\xed\x74\xea\xfe\x80\x4e\x54\x57\xd8\x30\xbd\x14\x4c\x5e\x3b\x0d\x71\x7a\x68\x67\x29\x68\x06\x24\x7c\x53\x7e\xdb\x21\x77\x34\x40\x13\x40\x06\xee\xf4\x10\x69\x1a\x22\xc0\x92\xf3\xb2\x1b\x85\x51\x12\x85\xf4\xd7\xe9\x01\x76\x35\x40\x55\xdb\xe8\x9f\x4c\xfb\x3a\x3d\xc4\x5e\x16\xe2\x57\x03\xe2\x9e\x93\x0c\x63\x27\x98\x1e\x9e\xaf\xe1\x89\xba\x06\x34\xe9\x84\x68\x3a\x50\xdf\x34\x28\x70\x91\x65\xc3\x81\xf8\xb3\xd3\x03\x3b\xb7\x81\x61\xf4\x5a\x73\x36\x78\xea\x4b\x88\x76\x35\x3d\xd0\xc0\x06\x8a\xd5\x39\x54\x65\x6a\x28\x3c\xe8\x9b\x92\x98\x48\x2a\x0f\xac\x27\xdd\x83\xda\x25\x5a\x14\xf3\x1f\x8f\x1f\x93\x41\x6d\x2c\xbf\xc7\x60\xb9\x28\x1e\x7f\xfc\x9a\x7a\xf1\xf1\x6b\x16\x8e\x59\xfc\x6b\xaa\xf8\xd7\x4c\xf1\xb1\xb6\x8b\xec\xd2\x04\xb8\xcb\x2b\x87\x33\xd2\x71\xaa\xaa\x99\x55\x46\xc6\x8b\xce\x24\x11\x20\x67\x93\x33\x2a\x0e\xca\x15\x80\x57\x49\xc5\xc4\xe0\x69\xca\xec\x0d\x1e\x74\x88\x0b\x10\x40\x78\x49\xec\x2a\x35\x16\xf8\x2e\x2d\x37\xaa\xa4\x59\xa9\x25\xd1\xe7\x01\x67\xa1\x0e\xa3\xe5\x8a\x5d\xa0\x59\x51\x8f\x49\x10\xce\x86\x84\x24\xe9\xbe\xc4\xf1\x6e\x0e\x49\xf5\x24\xc5\x5c\x8f\x4a\x60\x9e\x8e\xf1\x31\xa4\x47\x4d\x80\xa7\x7c\x6f\x90\x17\xa4\xf4\xb5\x44\x5a\xa4\xf4\x6b\x49\xf8\x1e\x9b\x2b\x04\xc7\x21\x1d\xa3\x43\xee\x3b\xf0\x15\x3d\x8f\x30\x53\xd3\xd8\xb6\xe6\x9d\x15\xa7\xb1\x6d\xbd\xb5\x69\x2b\xf4\x68\x82\x59\x2b\xe4\x2b\xfb\xb8\x7c\x33\x55\x28\x23\xcd\x7c\xe4\xad\xfd\x8d\x36\xa0\x50\x6b\x1a\xc3\x4f\x04\x5f\x11\xf6\x9e\x58\x5b\x9d\xf2\x2a\x05\xf6\x97\x62\x5c\x96\xed\x25\x87\x0b\xf7\xbe\xd2\xe0\x72\x01\x2f\x0a\x21\x56\x9c\x3b\x0c\x9c\x84\x8a\x18\xde\x09\x84\xd5\x74\x71\x43\xc7\x22\xff\x92\xde\xd3\x31\xdc\xd5\x35\x94\x12\x99\xf9\x96\x98\xa2\xb9\xb4\x71\xe1\x64\x13\x42\x21\x6a\x09\x4b\x3d\x58\xcc\x46\xee\x20\xf2\xc3\xc4\x30\xf7\xc3\x6f\xb3\xc4\x99\xc3\x80\xf2\x74\x19\x99\x62\x96\x92\x2b\x43\x96\xc1\x6f\xcb\x6c\x10\x9d\xc3\xec\x0d\x83\xc0\x68\xcf\x4c\xb5\x0c\x23\x5d\x9b\x3b\x4d\x64\x4a\xa6\x15\x61\x27\x8a\xfb\x4e\xf2\x41\x0e\xcb\x6a\xf5\x85\x18\x6e\x0d\x2f\xbc\x0d\xaf\x9b\x34\x4c\xe2\x71\x8e\xc5\x98\x64\xe0\x98\xaf\x0c\x97\xb8\x54\x87\xa0\xcc\xa6\x03\x3f\xa4\x92\xe3\xd9\xcf\xda\x08\xb9\x89\x69\x16\xab\x99\xcb\x95\xb2\x44\x78\x25\x6d\x45\xeb\xc4\xd4\x51\x43\x35\x47\x9e\x72\x2a\x0a\xdd\xaf\xa6\xdd\x4e\x9a\x8b\xcb\xbc\x47\x16\xa5\xaf\x60\xea\x5b\x8a\x00\x8e\xa0\xfa\xb1\x6d\x2b\x6b\xfc\xe6\x03\xcc\x65\x90\x76\x8b\x29\x2c\x4d\x61\x94\x6f\xb2\x43\x64\x58\x7c\xdc\xc8\xad\x2a\xb5\x71\x99\xef\x75\x95\xda\x65\x93\xff\xf8\xb5\x52\xbb\x6c\x18\x23\xf7\xd2\x76\x01\x72\x62\x81\x8a\xf9\x06\xaa\xb3\xac\x81\x99\x8f\x16\x7e\x4c\xc7\x2f\x45\x7f\xc7\x4d\x31\x82\xf1\x2d\x3a\x3e\x2e\xec\xf8\x5c\x5e\x7f\x6b\x92\x90\xc5\xdf\x4a\x0d\xd6\x57\xd9\x5c\x65\xa6\xad\xb5\x68\xcc\x04\x51\xd6\xc4\xa6\x17\x82\x7e\x3a\x95\xbf\x35\x3e\x7e\x7c\x33\x9e\x72\xf4\x7f\x52\x40\xf7\xd9\x1e\x06\xd4\x06\x94\xe5\x2e\x83\x3f\x83\x9c\x54\xc3\x39\xe3\xfe\x1f\x36\xbc\x3c\xa2\x2b\x1a\xde\x7d\xf5\xa2\x0f\xbd\x00\x9f\xb0\xe9\x5e\x60\x27\x32\x06\xa1\xb3\x93\x6e\x1e\xe1\x9a\x8c\xd1\xb4\xe0\xb9\xb3\x55\xff\x0d\x06\xeb\x59\x43\xf9\xe5\xac\xf7\x71\x92\xdd\x84\x97\x73\x76\x61\xf1\x6e\x4a\x15\x70\x6c\x03\x4a\xfe\xfd\x09\x5e\xc0\x98\x25\x3e\xc1\x53\x21\x63\xff\x29\x3f\x12\x4d\x7d\xff\x4e\xc4\x4f\xa1\xe3\x85\xb8\x6b\x8f\x78\xa5\xdb\x18\x7a\xc7\xd4\x09\xc4\xd3\x74\x01\x98\x1f\x67\x4c\xb8\xe4\x05\x22\x47\x8b\x2e\x2d\xf1\x42\x6b\x5a\xdb\xdf\xcc\xad\xdc\x3d\xd9\xde\xe5\xdd\x6c\xfc\x10\xd3\xec\xfc\x86\x66\x35\xcd\x9e\xca\x82\x2a\xff\x96\xca\xb2\xac\xc7\x83\x95\x69\x55\xaf\xe9\xc9\x6b\xa9\x99\xad\x1a\xb4\xd0\x69\x49\x3a\x53\x72\x50\xb1\x41\x1c\x48\x6b\x93\x8d\xe1\x96\x6f\x69\x0c\xb7\x29\xba\x7c\x07\x43\xb8\xfc\xb9\x98\xc2\x10\x6e\x6a\xe3\xb5\xfc\x5b\x56\xcb\x78\x8d\xe7\xcd\x04\x62\x2a\x8b\xad\xc9\xb5\xcb\x47\xa5\x33\x87\xf9\x10\x01\xe0\x4c\x2b\xfb\xd4\xe7\xfe\x00\x83\x00\x04\xca\xe9\x7f\x60\xe8\xc7\x20\x22\x00\xaa\x7a\xf8\xcf\xbe\xd4\x4b\x99\x1f\x5f\xcd\x0f\xfe\x9b\x89\x78\x04\x4c\xa9\x4d\xe4\x17\x68\x66\x4a\x30\xe3\xb7\x1f\x0e\xe7\xcd\x68\x44\x86\xa2\xc7\xec\x18\x9d\xe4\x56\x93\xc3\x97\xfb\xe3\x5f\x30\x67\x37\x5b\xd9\x15\x56\x35\xac\xec\x90\x23\xcf\xd4\x7d\x80\xb2\xdf\x99\xda\x1a\xc0\x1c\xb9\x70\xbf\x3b\x67\x9f\xfd\x66\xea\x86\xb4\xc6\xe3\xfc\xe7\x8e\xab\x4f\xb0\xb0\x99\xa0\x60\xf0\xf5\xc9\x06\x6f\xb8\xba\xd5\x02\x32\xd0\x7f\x74\x9c\xc5\x05\x46\x53\x56\x6f\x44\xef\xc9\x76\x4b\xe9\x4f\x6c\xbb\xad\xd5\xbf\x93\xdd\xd6\x83\x33\xc8\xff\xf1\xce\x20\x7f\xb8\xf5\xc9\xca\x2c\x3e\x03\x1f\xac\x22\x1e\xac\x22\x1e\xac\x22\x1e\xac\x22\x1e\xac\x22\xfe\x33\xad\x22\x7e\x25\xed\x4b\x9f\x69\xb3\x08\xbe\x7c\x7f\xe5\x49\xd3\x68\xa6\xf2\x36\xad\x1f\x72\x0d\x06\x3d\x9a\x70\x0d\x06\xf9\x37\x5c\x83\x41\x99\x5b\x5f\x83\x41\xad\x69\xae\xc1\x10\xfc\x2d\xaf\xc1\xc4\xb8\x8e\x66\x57\x9d\x65\x94\x4a\x39\xda\x03\x68\xe5\x7e\x9f\xd2\x01\xc8\x02\xed\x01\x84\x45\x08\x82\x68\xb4\x45\x5d\xbf\xef\x4c\x3e\xa4\xdc\xf8\x64\xa8\xe7\x7b\x77\x7b\x73\x24\x1e\xae\xc0\xad\x73\xd4\x21\x9e\x93\x38\x32\x9e\x32\x84\xee\xc5\xc8\xbe\xb0\x08\xa0\xd0\x5f\xf0\xfc\x4b\x9c\xa7\x66\x7f\xbe\x84\x27\x53\x31\x52\x08\xff\x7c\xd3\x48\x79\xa1\xff\x84\x91\xfe\x3e\xa4\xc4\xf7\xf8\x70\x2f\x97\xc4\xd0\x2e\x39\x6d\xee\x4c\xb4\x5f\xfa\x7b\x8f\xce\x8b\xfa\xce\x8c\xaf\xe3\x6e\xd6\x30\xfc\x5d\x87\x3e\x53\x55\xce\x17\x67\xaa\x28\x55\x55\xce\x30\x89\x4a\x55\x52\xe2\x6b\x65\x17\xdf\xe9\xc1\x4f\xe7\xb2\x74\x0c\x41\x6c\x34\xb1\x9d\xd3\xf1\x8d\xab\x8a\x67\xbe\xa3\xb3\xbd\x87\xfd\x9f\x8a\x7f\x6b\x45\xa2\xcf\x9b\xa8\x03\x08\x21\xa3\x9e\xef\xf6\x88\xcf\xc8\x90\x0d\x9d\x20\x18\x73\x11\x14\x0d\x39\x38\xe2\x20\x4e\x4e\x10\x8c\xef\xe9\x05\xb0\xe8\x81\x70\xb3\x23\xba\x50\x15\x7d\x08\x29\x46\xb9\x3e\xa3\x84\xd1\x84\xb7\x7f\x36\x26\x43\x06\x2f\x1b\xef\xe5\xe9\x70\xdf\xe7\x52\xed\x7d\x6c\x54\x66\xb4\x54\x31\x8a\x6c\x60\xb9\x99\x09\x3e\x89\x40\x7d\x8c\x8f\x32\x85\x4a\xf6\x26\x15\xfa\x8d\x40\x11\x0d\x10\xee\x56\x44\xc8\x29\x69\xaa\xf0\xdd\x73\x46\x5c\x27\xe4\xb8\x77\xc2\x31\x9a\xd0\x8c\x64\xd4\x7a\xa0\x13\x1f\x63\xf5\x40\x0e\x9c\x5f\x10\x88\x09\x00\x0e\x07\x70\x2a\xe0\x4d\xb1\xc9\x00\xd4\xa3\xd5\x84\xd7\x9d\x9d\x91\x1a\xb3\xe2\x46\xc3\x10\xa8\x0a\x40\x0a\xd0\x9b\x3c\xf1\x7e\xc8\x16\xaf\x55\x13\x1a\x6b\x59\x4f\x34\x26\xda\x7a\x25\x0b\xcc\xd4\x1e\x30\x4a\xd0\xd7\x7a\xde\xac\x6f\x9b\x31\x0a\x18\x0a\x9e\x01\xed\xdc\x75\xe0\x04\x1f\x0b\xdf\x01\x0a\x04\x26\xad\x2a\x69\xd3\x49\x1c\x7e\xac\xe9\x04\xd1\xe8\x4e\xeb\x90\xb9\x4e\xf0\x57\x48\x81\xb8\x9a\x6e\xa7\xbf\x93\xb6\xe1\x07\x9b\xed\xf7\xdb\x27\x87\x5f\x3f\xe0\x15\xdb\xc4\x4b\xa0\x29\xb8\x39\x27\xb8\xbf\x00\x03\x30\x03\x7f\xae\x1c\x00\x67\xb9\x99\xaa\x52\xbc\x30\x47\x84\x71\x2e\x74\xd3\xad\xd6\xdf\x0d\x69\x38\x76\x3d\xe1\xff\x93\xfb\xdf\xf7\x43\xbe\x4f\xbc\x76\x26\x9a\xc9\x4f\xc1\x95\x38\x22\x0e\xfc\x3f\x66\x43\x84\x06\x03\xd2\xcd\xc5\x64\xfb\xff\xbf\x9f\x2f\x11\xb9\x9f\x0f\x62\xca\x28\xd8\xe6\x3b\x31\x38\xa8\x90\x09\xdb\xa1\x67\x7e\x42\x3e\x4f\xe3\xb2\x32\x38\x50\xa1\x17\x34\xbe\xe1\xed\xc8\x44\x42\x80\xcb\xbb\xe2\xeb\xc0\x94\x5a\x01\x54\x6d\x4a\x47\x50\x10\x08\x51\x88\x3a\x45\xee\x32\x56\x1a\xa6\xf8\xa6\x60\xa8\x43\x64\xa3\x6a\x6f\xf6\x6b\x5a\x62\xd2\xd2\x8e\x79\x6a\x3b\x6a\x54\x09\x9e\x2b\x8e\xad\x1d\xf7\x4a\x6c\x9a\x8d\xaa\xdc\xf8\x1a\xe8\x33\x2b\x67\xf7\x52\xdd\x10\x7b\x91\x38\xa7\x58\x18\xfe\x31\x97\x9d\x4a\x4b\x66\x5f\x76\xae\x3d\x5c\x76\x3e\x5c\x76\xfe\x65\x97\x9d\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\xff\xc1\x37\x91\x5f\xed\x9b\x48\xbe\x7a\xbf\xfe\xed\x2e\x22\xbf\xde\x70\x11\xf9\x75\x8a\x8b\xc8\xaf\x33\x5d\x44\x7e\x9d\xf6\x22\xf2\xeb\x2c\x17\x91\x5f\xff\x94\x8b\xc8\xaf\xf7\x7f\x11\xf9\xf5\xe1\x22\xf2\xef\x74\x8b\xf0\x70\x11\xd9\x21\x63\x79\x11\x39\x7e\xb8\x88\x7c\xb8\x88\x7c\xb8\x88\xfc\xf3\x2f\x22\x1f\xae\x9c\xfe\x46\x57\x4e\x79\x37\xc3\xd3\x5c\xcb\xfe\xb0\x3b\xe1\x1b\xae\xa5\xc9\x66\xcf\x89\x93\xff\xd3\xee\x85\x03\xda\x01\x4d\x2f\xa8\x26\x7f\xf8\xbd\xf0\x7d\x5d\x43\x26\xd1\x5d\xf5\xfd\x84\xa0\x7e\xf8\xe1\x1a\xb2\x68\x47\xd2\x8f\xd7\x06\xd1\x08\x1e\x9b\xfd\x8e\x97\x02\x41\xd4\xe5\x7f\x7c\x8f\x86\x89\x9f\x8c\xf9\xef\xc4\xef\x53\x7c\xfd\x26\x2e\x0a\x22\x3f\x84\xb2\x51\xec\xf9\x21\xbe\x07\xfb\x7d\xe8\x84\x89\x0f\x4e\xf8\xc5\xef\x3f\xe0\xf7\x30\x71\x0f\x45\x75\x46\x7f\x1f\x72\xa0\x58\x21\xe9\xc5\x94\xf5\xa2\xc0\xbb\xe1\x71\xdb\xc3\xbd\xe6\xc3\xbd\xe6\xc3\xbd\xe6\xc3\xbd\xe6\xff\x21\xf7\x9a\xb8\x63\x6b\x41\xe9\x49\x36\x0a\x40\xe6\x56\x73\x3c\xcd\xad\xa6\xdc\xb5\xa7\xba\xd3\x84\x1d\xb8\x51\x55\xbb\xe8\xdf\xf1\x4e\xf3\x6b\xfe\x9d\xe6\x93\x49\x77\x9a\x02\xca\xf4\xf7\x98\x73\xb8\x6c\x97\xd0\x71\xf2\x5c\xd9\xad\x90\x03\x3f\xf4\x62\x4a\x0e\xa2\xb8\x37\x64\x73\xff\x0a\x7c\x97\x86\x8c\x92\xdd\x9d\xc3\x39\x50\x72\x66\x43\x8a\x86\xd1\xd2\x30\x1c\x32\xea\x2d\x5d\x38\x31\xe3\xfd\x13\xee\xe5\x0c\xb7\xc7\x07\xe3\xfe\x59\x14\x18\xae\x9a\x73\xb3\xf1\xd2\xcc\x76\x98\xac\xab\x14\xb9\x54\xc6\x5a\x9c\x8e\x77\xd8\xb6\x79\xb3\x95\xa9\x37\x10\x35\xcc\x72\xe6\xb5\x4a\x12\x09\xa5\xed\x85\x13\x70\x7c\xfd\xc3\xef\x10\xfe\x1b\x6e\x03\x40\xa1\xfe\xfd\x3b\x91\xdf\xc3\x50\xba\x23\xe1\x25\xff\x91\xa7\xa4\x2f\xd9\x7e\xa9\x5d\xbc\x4d\x39\xa3\xe2\x86\x82\x8c\xfc\xa4\xa7\x14\xf5\x0a\x5e\xa9\xb2\x3e\xf7\x8f\xeb\xb9\xb9\x7f\x08\x05\xa4\xd1\xa7\xf5\x39\xf3\xe2\x81\xf5\xa2\x61\xe0\x7d\x66\x74\xcf\x49\x7c\xe1\x51\xed\x1f\x49\x3c\x86\xfe\xc0\xf5\x8a\xd5\x3e\xf6\x53\x42\xc5\xdb\xbd\xb9\x7f\x40\x4b\xff\xa8\xd7\xc9\x16\x4d\xa8\x9b\x90\xb3\x61\xb7\x3b\x26\x12\x53\x52\x57\x8f\x02\x7c\xec\xd1\x98\x1f\x36\xa2\x80\xff\xf8\xe5\x19\xe1\x4b\xc0\x8f\x42\x56\x13\x30\x7a\x49\x32\x60\xad\x7a\xfd\x6c\xd8\x65\x35\xb7\x17\x47\x7d\x7f\xd8\xaf\x45\x71\xb7\x3e\xa8\x5f\x3c\xab\xfb\x8c\x0d\x29\xab\x7b\x34\x71\xfc\xe0\x85\xef\x6d\xac\x36\x9b\xcf\xe6\xfe\xf1\x0f\x88\x15\x4a\x59\xd2\x24\x1b\x80\x41\x74\x87\x56\x2e\x39\x67\x6e\xa9\xb2\x0e\x87\x09\x9b\xe6\x96\xc0\x95\x4c\x18\x2d\x85\x74\xb4\x34\x8a\x9d\xc1\x80\xc6\x8c\x4f\x02\x07\x72\xb4\xc6\x17\x50\xc9\xa3\xa5\x75\x81\x87\x5c\x9a\xdb\x73\xfa\x94\x95\xa1\x46\xe5\xa8\x71\x8c\x7e\x8b\xd6\x4a\x37\x60\xe9\xb6\x23\x5c\x69\xac\x3d\x31\x46\xb8\xcc\x79\xe7\x35\x07\x98\x77\xa5\xdb\x6c\xc8\x8b\x5c\xde\x05\x28\x7f\x54\x3a\x29\x91\x45\x81\x91\x5a\x27\x8e\xfa\xfc\xa4\xb7\x19\x79\xb4\xec\x57\xf8\x38\x7d\xec\x1d\x36\x01\x33\xb4\x5c\xb4\xca\xf4\x88\x97\x2b\x29\xf7\x60\x29\xe2\xc0\xa6\xc3\x63\x80\x5d\x91\x68\x44\xe8\xb5\x6f\x91\x1f\x96\x4b\xa5\x0a\xdc\x51\x95\x1a\xcd\xe5\x95\xd5\xb5\x27\x4f\x9f\x3d\xff\xc1\xa8\x5b\x51\xa8\xe3\x74\xe1\xd1\x4e\xb7\xe7\x7f\x3b\x0f\xfa\x61\x34\xf8\x3d\x66\x49\xa9\xc6\x06\x81\x9f\xf0\x8e\xd5\x3a\x51\xbc\xed\xb8\x3d\x63\x7c\x01\x3f\xa8\xc7\x06\x62\x57\x8e\x30\x89\xa3\x10\x7f\xd9\x63\x15\x08\x3c\xa7\x63\x56\xb6\x56\x11\xb8\x17\x01\x08\x95\x8a\x85\x0a\x0e\xb9\xa0\x6b\x93\x10\x23\x31\x1e\x0f\x79\xda\x35\x71\x9d\xc4\xed\x91\x32\x8d\x45\x6f\xeb\x75\xf2\x85\x12\x2f\x0a\x4b\xb0\x73\xf0\x25\xea\x84\xa0\x4b\x03\xad\xce\x59\x74\x41\x49\x12\xe1\x1d\x61\x95\x9c\x0d\x39\x7f\x01\xfd\x88\xd0\x50\x38\x1d\x5a\x9b\xcb\xb4\x7d\xcd\x19\x09\x6e\x1b\x35\xb1\x6b\x90\x8d\x1c\x86\xf2\x22\xe5\x5a\xbf\x95\xf1\xac\x5f\xd5\xfe\xef\xe7\x60\xae\x38\x8d\xae\xe3\xcf\x24\x22\x1b\x9a\xa9\x0a\x4f\xfc\x22\x8f\x49\x96\x3f\xa7\x97\x02\x43\xc7\xfc\x2c\xd7\x31\x3f\x93\x0b\x83\x37\xa0\xef\xd7\xb4\x6f\x7e\x06\xf7\x36\xc6\xca\x12\xfe\xf9\x79\x79\x31\x03\x7c\x66\xf3\xfc\xf1\xf3\x22\xca\x1b\x3f\x4c\x64\x12\x49\x6f\xfc\x3c\x0f\x7d\xf1\xf3\x8c\x6b\x39\x6f\x1c\x54\xee\x26\x26\x20\x30\xb5\xe3\xe5\x96\x82\x26\x81\xda\x72\x39\x81\xa8\x9d\x32\xef\x80\x9e\x09\x03\x06\x6b\xb3\x33\x47\x21\xaa\x1e\xf9\xc7\x6a\x30\x7c\x34\x3a\x59\x0d\xca\x48\x82\x8e\xc0\xe0\xc4\x08\xcd\x0d\x28\x89\xd0\xdb\x68\x4a\x14\x79\x7a\xaf\xa2\x08\x11\x22\x2a\xf9\xa5\xfd\x89\xec\xec\xbd\xdd\xde\x3c\xdc\xd9\xdf\x23\x0b\x75\x0d\x7b\x10\x47\x2e\x85\x1b\x75\x71\x17\xbb\x19\x0d\xc6\xa0\xfb\x21\x5c\x72\x59\x6e\x34\x57\x96\x06\xe8\xb4\xa9\x4a\x5e\x39\x2e\x3d\x8b\xa2\xf3\x2a\xd9\x09\xdd\xda\x1c\x81\x0a\x87\x3d\x9f\xc9\xb0\x0e\x6e\xe4\x51\xe2\x33\x22\x24\x1c\x0f\x36\xe0\x18\x56\xd5\xee\xce\xa1\x4c\x26\x9d\x68\x18\x4a\x45\x35\x07\xf1\x7e\x67\x73\x7b\xef\x60\x9b\x74\xfc\x80\x4a\xfd\x75\x1c\x45\x09\xf1\xfc\x98\xa2\xaf\x4a\x58\x9b\xba\xa1\x24\xa6\x54\x74\x00\x6e\x89\x45\xe7\x3f\x33\x5e\xff\xc2\x89\x7d\x07\x02\xaa\x27\x11\x71\x18\xa3\x71\x42\x30\x16\x3b\x2a\xfc\xc6\xd1\x10\x64\x9b\x6e\xec\xf4\x79\xfe\xb0\x4f\x99\x58\xda\x9c\x65\xc8\x81\x7d\x88\xa3\x0b\xdf\xa3\x84\x0d\x62\x3f\x4c\x3a\x4b\x2c\x19\x07\x52\x59\x4a\xca\x51\x18\x8c\xc9\x7f\x81\xfa\x97\x0d\x07\x7c\x62\xb8\xd4\xe2\x84\x9e\x5e\x66\x1c\x48\x12\xf1\x96\x00\x8e\x1f\x62\x5d\xbe\xd0\x9d\xb3\x68\x98\x90\x51\xcf\x49\xc8\x59\x1c\x9d\x53\xa8\x08\x9f\xe3\x68\x48\x46\x34\x06\xbc\x20\x6f\xe2\x9b\x94\xc2\xb5\x31\x3e\xd2\xa7\x8c\x39\x5d\x4a\x46\x7e\x10\x00\x5f\x4a\x62\x7f\x30\x40\xdd\xe5\x20\x8e\xbc\xa1\x30\x51\xe0\x0c\x2c\x31\x6b\x72\x50\x50\x29\xa6\x5c\xac\xe7\x9d\xa4\x21\x1b\xc6\x94\x04\x51\xd7\x77\x89\x17\x51\x06\x86\x0d\x9e\xdf\xe9\xa0\x78\xa2\xe1\xd5\x10\xe7\x7c\x71\x5d\x38\x81\xef\x39\x09\x45\xfd\xb0\x79\x73\x6e\xe7\x08\x5f\x71\x15\xd8\x6b\xe6\xc4\x62\xe3\x64\x57\xa3\xe1\x45\x6d\x6f\x7f\x6b\xfb\x64\x7b\xef\x17\xdc\xfb\x74\x43\xc2\xc3\xe5\xed\x1b\x99\x93\x8e\xd9\xc4\x5c\x65\x24\x4b\xbc\xa8\xd6\xd2\xa5\x90\x2c\x35\x66\xc5\xb2\x82\xe8\x64\x94\x67\x2a\x5c\xcb\xc9\x2d\x99\x3e\xba\x6c\x11\x52\x13\xa0\x1b\x85\x9e\x8f\x73\x80\x5d\xa9\x12\xa7\x4a\xce\xaa\xc4\xad\x12\xaf\x4a\x68\x95\x74\xf2\xc6\x28\x47\xa2\xdc\x2d\x3f\x52\x80\x64\xef\x39\xf6\xa1\x63\xeb\x53\x0e\x16\x47\xb1\x61\x0e\x77\xd7\x0f\xfd\x8e\x4f\x3d\x42\x2f\x5d\x3a\x40\x69\xd4\x75\x87\x71\x4c\xbd\x75\xc2\x39\x09\xa7\x99\x30\x0a\x97\xfa\xb2\xa0\x47\x2f\x08\x0d\x2f\xfc\x38\x0a\x39\x0e\x20\x46\x6e\x89\xb3\x5a\x5e\xb2\xc3\x65\xee\x14\xb2\xf8\x6a\xf0\xb0\xe7\x4e\x40\x7a\x34\x18\x74\x86\x01\x19\x39\x71\xe8\x87\x5d\x56\x53\x48\xb4\x3d\x23\xa2\x0f\xd6\x2e\xe7\xf3\x47\x69\x7c\x1d\xaf\xdb\x85\x76\x42\x8f\x5e\x02\x8f\x2f\x1c\x28\x22\xa6\x16\xd3\x41\xe0\xb8\xb4\x5c\xff\x2f\x56\xef\x56\x6d\xbb\xc1\xb4\x6b\x3e\xde\xfa\x91\x84\xbe\xb8\x78\xbc\x9e\x76\xcd\x26\xda\xa9\x49\x87\xda\x3b\x8a\x74\x7e\xf1\xa3\x00\xd6\x78\x49\x12\xc8\x9c\x2e\xde\x89\xb9\xb8\x78\x18\x7d\x88\x06\xb8\x2d\xd7\xeb\x64\x24\x25\x11\xd7\x89\xa9\x60\x0c\x8a\x84\x4a\x8c\x44\x23\xbe\xdd\x3a\x7d\xf4\x70\x8c\x44\xab\xa6\x3e\x5f\xe6\x50\xd5\x27\x6e\x02\xd7\xb8\xc3\x4d\xda\x55\xca\x2b\x95\x4a\x25\xbd\x47\x3d\x9b\x62\x8f\x82\xed\x28\xd3\x2f\x8d\xf3\x33\x3f\xe9\x3b\x83\x2a\x5a\x93\x58\xfe\xd4\x71\x2e\x4c\x73\xa6\x47\xa2\x34\x79\x4c\x9a\xc2\x9d\x9e\x6d\xca\x64\x14\x58\x16\x05\xb4\xed\x93\x91\xb9\x5a\xb1\x4c\x58\xe0\x8f\x58\xbe\xd9\x9d\xf8\xf9\x9d\x76\xe2\x7a\x9d\x34\x9f\xd7\x9a\xb5\xe5\x5a\x73\x95\xd4\x49\x73\xad\xb6\x5c\x5b\xe1\xbf\x2d\x19\xb8\x02\x5c\xf4\x9f\xfc\xa3\x28\x9e\xd6\xca\x73\x61\xf6\xca\x31\xf2\x72\xd8\x7d\x57\x5c\xb6\xf9\x64\x85\xb3\x8c\x0c\xd6\x8d\x26\xad\x30\x4e\xa2\x0f\x26\xf2\xff\x89\x69\x55\xb3\xb5\x4a\x1e\x7a\x9e\x37\x66\x26\x82\xab\x1c\x68\xcd\x7b\x14\x7b\xe6\xe6\xf2\xcd\x60\x15\x98\xf9\x93\x13\xca\x76\x01\xf8\x7c\x55\xb2\xdf\xa1\x30\x89\x9b\xbb\x56\x16\xa3\x0f\xa1\xb0\x1e\x4c\xad\x1f\x4c\xad\x67\x31\xb5\x06\xaa\xf9\x34\x04\x74\xe5\x72\xaa\xe5\x66\x4e\xe1\x65\x5e\x1a\xee\x15\xa2\xc1\x27\x2c\xbb\x85\xea\xdd\xb2\x51\x4a\x55\x0c\xfc\xf0\x7c\x42\x1b\xcb\x4f\x96\x33\x45\x27\xb5\x20\xcb\xa8\x4a\x07\x5c\xdc\x9f\xd0\x00\x72\x5b\xbb\xe8\xa4\x06\x54\x21\xcd\x60\x98\xeb\x0c\x8a\xc0\xaf\x3e\x7d\x9e\x2a\x38\x09\x38\x96\xa8\xac\xdb\x26\xd4\x79\x45\xa3\xb3\x6f\x9c\x8e\xc4\x2c\x46\x67\xdf\xc8\xe3\xc7\xfc\x4f\x4d\x73\x45\xf2\x02\xd2\x5b\xe4\x8a\x94\x84\x82\xbd\xd4\x82\xa4\xeb\x94\x95\xf6\xdf\xce\x64\x5e\x1d\x62\xc3\xc4\xf1\x43\x46\xe2\x61\x40\x19\x41\x8d\x3c\x43\x79\x34\x08\xa2\x11\x23\x78\x71\x51\x8f\x69\x3f\xba\xf0\xc3\x2e\xa1\x09\x1c\x68\xc9\x0e\xe3\xa2\xaf\x07\x2c\x8b\xd6\xba\x35\x72\x36\x26\xa7\x30\x75\x07\x3d\x4a\x93\x53\x12\xc5\xe4\x74\x53\x8a\xe3\x4e\xc0\x27\xf4\x14\x8f\x44\x7c\xaa\xf8\xe7\x7b\x9f\x25\x69\x6e\x39\x87\xe6\x1b\xfb\xb1\xdf\xf5\xb9\x28\x0c\x67\x49\xd9\xb1\x9a\x69\x38\x2c\x21\x94\x23\x10\xc9\xd9\x64\x13\x62\x59\x5a\x5a\x11\x83\x7b\x63\x2e\xed\xe0\x3e\xab\x92\x62\x67\x94\x4e\xf2\x85\xe4\x7c\x74\x6c\xd6\x15\xad\x92\x0d\x22\x7e\x19\x35\xa0\x07\xd4\xc8\x93\x29\xca\x94\x58\x84\xea\x58\x20\x9b\xb0\x5e\x01\xe1\x31\xed\xfa\x2c\xa1\x31\xcc\x45\x0d\xb2\xb1\xcc\x17\x7e\x02\xe5\xf3\x8a\x26\xc4\xc4\x81\x88\x42\x80\x6b\x02\xc8\x26\x23\x87\x89\x4c\xea\xe1\x19\xc3\x8f\x59\x42\x12\xbf\x2f\x00\xd5\xe7\x04\x62\x3f\x33\xb4\x1f\x12\xc7\x58\x37\x8a\x63\xea\x26\x72\xfa\x63\x8f\xc6\x35\x51\xf2\x13\x24\x61\xa7\xe2\x31\xcc\xb3\xe3\xf2\xb3\x28\x9f\xe9\x5a\x97\x26\xe5\x0a\xe9\xd3\xa4\x17\x79\x35\xac\xb0\x93\x70\x71\x13\xc9\x89\xf7\x81\x71\x91\x9f\x03\x56\x23\x43\x6b\x25\x38\x0a\xf0\x01\x9f\x8d\x09\xa3\x01\xe8\x2d\x6a\x73\x19\x03\x6b\x39\x63\x29\x1b\x6b\xc7\xf3\x0a\x0c\xac\x1d\xcf\x83\x78\x3b\x7c\x17\x71\x83\x2a\x49\xd1\x85\x70\x9a\xae\xe7\xcd\x9c\x46\xdb\x99\x79\xcc\xcf\x6c\x1b\xaa\x6c\x0d\x53\xcc\x32\x0c\xd0\x6e\x14\x81\x04\xb3\xc4\x37\x90\x04\x54\xfe\x37\x66\xb5\x81\x26\xf7\x34\x36\x8b\xc8\x34\xb3\x5c\x97\x86\x34\x96\x28\x91\xbe\xdc\x65\x85\x4c\xa6\xf6\xb6\xae\x47\xa9\x3d\x53\xdb\x3e\xbc\x29\x6b\x59\xc4\xaa\x5b\xc5\xd1\xb6\x48\x7a\xd4\x30\xc4\x16\x49\x8d\xf4\x1b\x63\x2d\x62\x8d\x4e\x8e\xa3\x45\xb2\x23\xca\x74\xb9\x95\x4d\x92\x47\x48\x3d\x83\x56\x10\x93\x47\x0a\xe5\x82\x76\x38\x5f\x36\x47\x82\x41\x8e\xcc\xc3\x6a\xa6\xc6\x06\x29\xd5\xf8\x99\xbc\xdc\xa8\xaa\x4d\xe3\x48\xb1\x70\xe9\xfd\xdc\x86\x97\xf1\x40\x2f\xf9\x85\x08\xaa\xb4\x01\x64\x67\x05\x91\x89\x71\x53\x84\x56\x8c\xed\xdb\x6a\x29\x8f\x62\xed\x48\x34\xc6\xd4\xe7\xc4\x74\xc9\x45\x07\x34\x6c\x6c\x1e\xc6\xc6\x6b\x36\x9e\xe7\xd7\x1d\x74\xc6\xa9\x19\x29\xc7\x70\xbe\x80\x99\x37\x62\x7d\x00\x9f\x9a\x1e\xa7\xda\xd5\x7b\x01\x2a\x05\x97\x10\xad\x99\xc5\x0d\x74\x48\x6e\x2c\x87\x2d\xbe\x4d\x65\x8e\x74\xfa\x0f\x59\x32\x10\x40\xcb\xae\xb1\x6e\xb6\x8c\x05\xd9\x00\xa2\x77\xc1\x47\x15\x1e\x1d\x0b\x19\x44\x8c\x16\x05\x01\x9e\x68\x29\x2c\x8c\xa8\x4b\xaf\x69\x42\x1c\xcd\xbe\x91\xef\x66\x22\x3d\x74\x69\x52\xc0\xc1\x38\x53\xe5\xf4\x90\x79\x23\x22\x77\x2b\x24\xb5\xa2\xe6\xb7\x68\x40\xf9\x5e\x72\x63\x0f\x60\x33\xa7\x85\xef\x54\x78\x26\x4c\x82\xa9\x02\xf4\x59\x6d\x18\x5a\x53\x54\x29\xc6\xa1\x4e\xd9\xef\x60\xd9\x2a\x69\x56\x26\xa1\x0d\xa7\x31\xea\x4c\xd1\x7b\x01\xb7\xa0\xfb\x56\xab\xb9\x78\xc4\x9e\x5a\xe5\x8a\x7a\xf6\x69\x18\x92\xd3\x88\x1f\x1a\xf9\xc6\xc7\xd7\x4f\xb9\x72\x4a\x06\xc1\xb0\xcb\x37\xb9\x28\x24\xf4\x82\xc6\xe3\x1b\x7b\x2c\x94\xb8\x05\x3d\x16\xb9\xa9\xe8\x1e\xb2\x11\x7b\x9f\xe2\xfb\x48\x4d\x64\x49\xf4\xe3\x25\x9d\x34\x0c\x76\x83\x28\xa4\x04\x2c\xa3\xc9\x19\x75\x9d\x21\x06\x8a\x19\x51\xd2\x8f\x3c\xbf\x33\x16\x0a\x6e\x8e\x6d\x16\xf5\xe9\xa8\x47\x63\x8a\x5a\x45\x6f\x18\x73\x01\xcf\x21\x41\x14\x0d\x34\xec\x11\x25\x34\xf4\xc8\x70\x80\x16\x03\x30\xe0\x9e\x13\x7b\x4b\x49\xb4\x94\xc4\x8e\x7b\xbe\xe4\x45\xa3\x90\x30\xdf\xa3\x84\x76\x3a\x5c\x7e\xac\xcd\xe5\x50\x06\xc6\xce\xd3\xf7\xa3\x62\x14\x35\x0b\xbd\x55\x39\xee\xe2\x29\x91\x52\x92\x23\xb9\x1c\x39\xe5\x4b\xe3\x14\x44\x8a\x53\xc9\xb4\x4f\x49\xdf\x19\xb0\xc9\x8b\x00\x01\x15\x2e\x83\x02\x6e\x64\xaf\x09\xbe\x28\x61\xfa\x85\xce\x40\xb3\x07\x64\xcf\xb7\xe7\xc4\x36\x58\xc9\x5e\xd3\xb0\x11\xba\xd1\x2b\x6b\xc7\x32\x7b\xe4\x6a\xe9\x40\x72\xdd\x7c\xcc\x7e\x56\xcb\x7b\x8a\x45\xa8\x79\x41\x01\xfe\xd2\xcc\x42\x8d\xd0\x43\x2e\x95\xc5\xde\xdd\xd0\x96\x0b\x56\x61\x6f\x3d\xb7\x5c\x06\x5d\x37\xa2\x68\xe0\xc9\x98\x7a\xe6\xe5\xca\x90\x32\x5c\x1c\x0e\x1c\xc8\x3c\x27\x71\x26\xe2\x0e\xa0\x14\xe1\x0d\x32\xa5\x58\xe0\x24\x4e\xbe\xfc\xba\x3c\x49\x80\x55\xac\x43\x95\x36\xf9\xc6\x24\x39\x76\x19\x05\x59\x4b\xc2\x10\x0f\x76\x75\x28\x4b\x7c\xb0\x62\xc5\x55\xd3\x8b\x19\x51\x54\xe6\x3d\xaf\xaa\xd8\x3b\xb8\xab\xe5\x48\x10\xc0\x96\x33\xe2\x80\x56\x83\xa9\x4b\x0b\xf1\xf3\xa7\xec\xce\x2e\xb2\xf0\x8e\xba\xb0\x3f\x88\x4f\x5d\x59\x44\x93\x4b\x77\xa9\x68\xe2\xdf\xfb\xe1\xb9\x38\x61\x81\x76\x0b\xcf\x4b\x30\xe7\x9b\x07\x07\xf2\xa8\x32\x69\xd2\x03\x3f\x3c\x2f\x98\x72\x9e\x55\x76\x91\x01\xa6\x8e\x2b\x78\x42\xb5\x76\x00\xe8\x70\x4d\x9c\xf6\x62\x8e\xdd\xcf\x21\x8a\x5b\xde\x3b\x3a\x66\xbb\xce\xc0\xd8\x7e\xb5\xf8\x92\xa7\x5a\x94\x6d\xa6\x6f\xfa\x25\x16\x41\xfc\xc4\x32\x9c\x91\x88\xd2\x47\xbe\xb1\x9c\x80\x26\xcf\xe9\xf8\xe6\x5e\xbe\xa3\x63\x39\xc8\x54\xd4\x3e\xbe\x5c\x39\x8c\xe3\x8a\x04\xa5\x52\xec\x86\x84\x3c\xad\xd6\x78\xaa\x88\x64\x1c\x15\x94\x41\x95\x32\xcb\x92\x42\x05\x3b\x4f\x75\xa4\x68\xde\x37\xa3\xf0\x82\xc6\xf2\x7c\x9c\x44\xc4\xe1\xf3\x4d\x70\x05\x4c\x9a\xee\x24\x42\xab\xa9\x82\x29\x97\xd9\x69\xe5\x05\x8e\x93\x25\x20\x4e\x97\xcc\x2b\x3c\xb9\x52\xb3\x58\xb6\xc4\x63\x3e\x68\x30\xa6\xe1\xa5\x5f\xe0\x5f\x55\x1c\x32\x5b\xd2\x0e\xe7\xde\x16\x5b\x7a\x6a\xcc\x05\xb6\x9e\x26\x26\xb1\x8f\xd5\x32\x18\x30\xc2\xff\xd5\xeb\x64\x2f\x52\x12\x8d\xd4\x7a\x84\x84\xf6\x07\x89\x25\x6d\xc9\x33\x90\x8b\x3e\x01\x1e\xf1\x01\x56\x40\x0b\xe1\x87\x43\x6a\x40\x44\x45\x6e\x5c\x01\xd4\x2e\x6e\x90\xd2\xbf\xc3\x92\xee\x9a\x48\x74\x19\xcb\xb0\x22\x21\x38\xb2\x24\x2e\x7c\xa3\x2d\x57\xff\xfa\x1c\xaa\x76\xc5\xfd\x89\x41\x75\x64\xc3\x28\x94\xba\xd1\x59\xfe\x1b\xdf\xe8\x2c\x17\xa9\x5c\xd3\x05\x57\x26\x69\x5c\x05\x2c\x55\xc7\x7e\x7d\x5f\xd0\xc4\xb3\x82\xe2\x93\x74\xbb\x76\x49\xdb\xa1\x89\xd2\x07\x16\x8d\xe9\x79\x41\xf9\x49\x43\x4b\x41\xae\xe4\xdc\x06\x15\x35\xd7\x6c\xe4\x95\x9e\xd8\x98\x01\x54\xd5\x2d\x74\x82\x50\xd8\x6e\xf3\xe6\xba\x93\x7a\x51\xdc\xa0\x82\x2b\x5d\x3f\x14\x76\x21\x5b\x74\x52\x8b\x0a\x9c\xaa\x05\xfe\x0e\x26\xf8\xb2\x32\x4a\x4d\x22\x17\x28\xa0\x8a\x8f\x62\x67\xb0\x65\x79\x4a\xc8\x03\xff\x74\xb5\xa8\xc2\xa4\x96\x52\x45\x53\x33\xbf\x3b\xf4\x0f\x7b\xb4\xb0\xc9\xa6\x71\xbf\x61\x57\xb8\xf9\x1e\x48\x96\x54\x00\x12\xfe\xc5\xf9\x10\x0d\x51\xf9\x98\xdb\xe0\x72\x7e\xf9\x49\xed\x59\x05\xef\xff\x7a\x45\xb0\x52\xf3\x72\xa5\x5e\x27\x64\x44\x9d\x73\xf8\xd5\x09\xa2\x11\x61\x4e\xe8\x27\x63\xe2\xf2\xc5\x48\xca\x5b\xfb\x64\x6f\xff\x90\x6c\x6d\xbf\xdf\x3e\xdc\xae\x28\x03\x60\x5e\x12\xec\x7e\x93\x78\x5c\xff\x5f\x8d\xb7\x5f\xbf\x8c\xb6\xba\xcf\xbb\x87\xdd\xf7\xdd\x97\xed\xb7\x1f\xdf\x7d\xdd\xde\xdd\x7a\xfd\xec\x65\xff\xf3\xce\xb7\xae\xeb\x07\x1f\x57\x46\xaf\x57\xdb\xd1\xe7\x83\x2f\xfb\xaf\xdb\x87\x7f\x6c\x1e\x76\x5f\x3f\x5b\x7d\xd9\xfb\xf5\xa0\xbd\x3f\x3e\x58\xeb\xbe\xfc\xfc\xfa\xb0\xfd\x7e\xed\x92\x0d\xdb\xe7\xbf\x7e\x1c\x8d\xd7\xf6\x3f\xbe\x19\xac\xb9\xed\xf7\x07\xbf\x37\x9f\x7c\xfb\x6d\xf8\xcb\xc8\x73\xdd\x28\xee\xbe\x5c\xf9\xba\xd5\x6e\x7f\x59\xfa\xdc\xe8\xbd\xdc\x6d\x6f\x77\xdf\x9c\x2f\xaf\xbd\x6d\xb7\x9f\xff\xfe\xa5\xfd\x6e\xcd\xdd\x1d\x6d\xbe\x1a\xef\x86\x7f\x1c\x2c\xb3\xf6\x9b\x6e\xfb\xd5\x9b\xad\x76\xfb\xb7\x51\x7b\xf8\xaa\xbf\xdd\xfe\xd0\x6d\xbf\x73\x83\xe6\xf2\x61\xf0\x9c\xbe\x7e\xe5\xef\xbb\xed\xf1\xe2\xc7\xcf\xbf\x75\x9b\xdf\x76\xe3\xb7\xaf\xfc\xa7\xed\xcd\xdd\xf6\xbb\xf1\xc7\xdd\xfd\x57\xdb\xed\xdd\x6f\xbd\x91\xbf\xf9\x6d\xb5\xfb\x72\x30\x6e\x6f\x0f\xd8\xf3\xb7\x6b\xcf\xa2\xc3\xcd\x9d\xf1\x07\xff\xcb\xfe\xa7\x46\xa3\xfd\x92\x7d\x3e\xd8\xf5\x57\xdb\x6f\x3e\xb7\xfd\xe6\xbb\xd5\x57\x97\x3d\xda\x7e\xb9\xbb\xb6\xf6\xfa\xbc\xbd\xdf\xfb\x63\x78\xf8\xee\xcd\x97\xf1\x07\xe7\xcb\x17\x7f\x73\x3c\xdc\xfe\xdd\x19\x46\x07\x97\xcd\x77\x3b\xc3\x2d\xe7\x63\xf4\xe9\xdd\x93\x37\xcd\xf7\x5d\xff\xf5\x1b\x37\xfa\xb0\xbc\xf9\xf2\x8f\xf1\xb3\xd7\x5f\x87\x7f\xbc\xfc\xad\xdf\x3e\xff\x65\xf9\xeb\xeb\xd7\x51\xef\x5d\xb3\xdb\xbe\xd8\x1d\xed\xfc\xb2\xb5\xf3\xad\xfd\x79\x3f\xf1\x2e\x36\xcf\xdf\xbd\x5d\xfb\xb0\xfd\xee\x5d\xd0\x6b\x1f\x3e\xf1\x83\x8b\xf3\x5e\xe7\xe2\xd9\xab\xf3\xe4\xfd\xf0\x53\xaf\x1d\x05\xaf\x06\xaf\x3f\x8f\x9b\x1f\xa2\x60\xf7\xeb\x1f\xbb\x49\xfc\xa6\xdd\x7e\xf7\xfb\xa7\x57\xed\xb6\x3b\xfe\xb8\xb6\xd9\xdf\xfd\xa3\xdf\xde\x7e\xf5\x0b\x5b\x6b\xb2\xe7\x09\xfb\xf8\xf5\x03\x5b\x3c\xf7\xfc\x81\x37\x4e\x7e\x71\x2e\x5e\xbe\xf6\x47\x9f\xdf\x6f\x0f\xf7\x57\x3f\xbe\xfc\xe5\xd7\xbe\xfb\xee\xdb\xef\xcf\x3f\x3a\xd1\x07\xaf\xff\xe6\xa0\xf1\x7e\xb5\xf1\xeb\xcb\xfd\xcf\xdd\xbd\xf3\xad\xc5\x8b\xf6\x76\x67\x75\xff\x37\x6f\xbb\xff\x6e\xd8\xfb\xb8\xf5\x61\xb7\xff\x32\xe9\x7c\xe8\xad\x6e\x8d\xde\x9c\x7d\xdc\x79\xd3\x1e\xbd\x7b\xb7\xba\xdb\x5e\x6a\xb7\xb7\xce\x5e\x5f\x36\xbf\xb6\xf7\x9a\xab\xaf\x46\xdd\xa7\xe1\xda\xe0\x5b\x97\x7d\x6d\xb3\xf0\x63\xf8\x5b\xb0\xdd\xf8\xd8\xde\x79\x3a\xfc\xfa\x72\x7b\xff\x6b\xff\xd7\xb3\xf3\xaf\xef\x97\x2f\x97\xdf\x5d\xf4\x46\xaf\x5e\xee\x74\x37\x77\xa3\xee\xef\x07\x3b\xed\xc3\xf7\xdf\x56\x2f\x0e\x7e\xd9\x1d\xbf\x7c\x12\x7c\xf9\xf2\xf4\x70\x87\xed\xf5\xbf\xae\x7e\xf8\xed\xcd\xe6\xea\xca\xfb\x8f\xbd\x37\xed\xf6\xf6\xdb\x83\xf6\xd6\x97\xf3\x97\xdf\xde\x47\x3b\x7f\x9c\xfb\x8b\x5b\xdd\xf6\xcb\x67\x9b\x6f\xb7\x3f\x6e\x5d\x3c\x5f\xea\x7e\x7c\x99\x7c\x1b\x7d\x7a\x7b\x31\x7e\xbf\xd4\x0b\xdf\xee\xfd\xb6\xff\xe9\xc9\xce\xe8\x77\xfa\xe1\x70\xb3\x11\x85\x2f\x7f\x75\x2f\x0f\x0e\x5f\x1f\xee\xb6\x3f\xbf\xdd\xfd\xba\xd6\x6f\xb7\x97\xde\x6f\x1f\x3c\x89\xde\x0d\xb7\xb7\xe2\x41\x63\xff\xdb\xeb\x77\x8b\xd1\xeb\xf7\xfe\xd0\x59\x7b\xf6\xb6\xe1\xbd\xdd\x7f\xb7\xda\x68\xd3\x57\xab\xbb\xed\xc5\x37\xab\x4f\xdf\x7d\x63\xed\xf8\xe9\xc5\xdb\x67\xfd\x4d\xba\xb7\x7a\xe1\xc7\xaf\x46\x83\x6e\xf4\x6a\xf5\x60\xeb\xcd\xab\x6d\xf6\xa9\xfd\x65\x71\x74\xf9\xf6\xdd\xc1\xef\x1f\x5f\x85\xa3\x8b\x83\xb5\xdd\x27\x2f\x3f\x35\xdc\x91\xfb\xaa\xff\xfa\xe5\xc1\xab\x8f\x07\x3d\xf7\x65\x37\x66\x4f\x9f\x7c\x6a\x9f\xef\xbe\x1a\x6d\x35\x9c\x43\xf7\xb7\xf3\x8b\x37\x8d\x83\xdd\xaf\x97\xec\xd7\xf6\xce\xef\x7f\xbc\x3a\xf8\xad\xb7\xfb\xdb\xbb\xc6\xe0\x6c\xa7\xeb\x46\xef\xba\x83\xce\xd6\x3b\x67\x77\x65\xad\xf3\xfa\xe0\x8f\xf1\xc5\xee\xa7\xb5\xf3\x2f\x74\xb0\x17\x75\xe3\xc5\xfd\xed\xf6\xe7\xcb\xdf\x46\x9b\xce\xd7\xc8\x1f\xfa\x7e\xe3\xfd\xd6\xeb\xc1\xb7\x3f\xce\xc3\x67\xed\x1d\xf7\x60\x73\x35\xa4\x87\x9b\x6f\xc7\xfe\xfe\xda\xc1\xfb\xd5\x1d\xba\xd8\x7e\xce\x0e\x7a\x3b\x6f\x0f\x0e\x9c\xf3\xa5\x9d\x57\x5f\xce\xb7\x9d\xc5\xcb\xb7\xdb\xc3\xdd\xdf\x76\x3e\x87\xab\x17\x5b\x9f\xcf\x3e\xbd\x7a\x19\x7d\xfc\xda\x5e\x0b\x68\x34\x7a\x3a\x7c\x33\xee\xc6\x9b\xc9\x6e\xff\xfc\x7d\x3c\xe8\x8f\xc7\x21\x1b\xfd\xf2\x6a\x7f\xed\xe3\xf9\x47\xb7\xb7\xfb\x32\xdc\xfb\xdd\xdd\x7c\x72\xf1\x7b\x2f\x7e\x1d\x36\x07\xbf\x5f\xbc\x74\x06\x6f\x3f\x6c\x3e\x3b\x1b\x75\xde\xff\xb6\x3d\xda\x3f\x18\x3d\xed\xd3\x4f\xee\xf9\xce\xe2\x81\xfb\xee\xf3\xcb\xdf\x0e\x46\x1f\xcf\x76\xdb\x07\xbf\x8d\xde\xf8\x83\xb7\x8d\xc0\x71\x9b\xbb\x1f\x9f\x8c\xbe\x74\xfc\xfd\xc3\x37\x17\x3b\xe7\x9b\x4f\x29\xdb\xef\x0c\x46\xed\xd7\xbf\xbe\x7c\x19\x36\x0f\x36\x7b\xdf\xda\xab\xce\xa7\xc1\x60\xf7\xec\xb7\xe1\x9a\xff\xdb\xce\x66\xbf\xd3\xeb\xef\xf7\xfb\x67\xbf\x85\xfd\xd1\x2f\xaf\xce\xbb\x83\xb3\xe0\xbc\x1b\x9c\x8d\xbf\x7d\xb9\x5c\x69\xb2\xdf\x9e\x6d\xed\xb1\xd1\xd9\x6f\xa3\x97\xcb\x7f\x6c\x79\x71\xb2\xf8\xb6\xdd\x06\xa6\x7b\xe6\x9c\xd1\xe0\x03\x1c\x60\x5f\x05\xd1\x08\x9c\x17\x7f\x90\x4e\x7a\xe0\xc9\x1c\x17\x70\x4e\xde\xf8\xdd\x1e\x8d\xf7\x63\x8f\xc6\xca\xef\x4f\xe1\x8e\xfb\xa4\x52\xbb\x0b\xd8\xef\xdf\x0b\x3c\x2b\xd6\x9c\x70\x2c\xf6\x0a\xc1\xa2\xe5\x56\xa6\xae\x2a\x4c\xed\xf6\x96\x51\x46\xe8\x3b\xb9\x64\x6e\x56\x95\x07\x0b\x1d\x01\x5f\x65\xa9\xdb\xd3\x54\x53\xc6\xfd\x8a\xda\x1a\xe5\x9b\xc1\x4a\x19\xce\x78\xb9\xd0\xae\xe7\x6e\x83\xef\x9d\x90\x8b\xd6\xd4\xb3\x82\x2d\x72\x40\xad\x22\xdc\x88\x4b\x6b\x9f\x89\xad\xcf\x13\xf6\x61\x75\x65\x31\x0d\xfe\x30\x60\x14\x58\x16\x2f\xeb\xd5\xfb\x27\x78\x5a\x41\x89\x1f\x0e\x86\x09\x71\xe5\x6c\xd4\xa0\xd7\x23\x3f\xe9\x49\x04\x28\x14\xab\xc4\xb2\x65\xad\x66\x5a\xcf\x58\x6e\xba\xf0\x54\xf6\x25\x0f\x54\x19\xbd\x66\xff\x33\x53\x83\x20\xbe\x95\xe8\xa6\x31\xad\xe0\x54\x49\xa6\xb2\x3e\x6e\xca\x06\x54\x69\x78\x50\xc0\xc0\xed\x5a\x42\x2f\x13\xf3\x64\x89\x33\x6b\xcb\xe3\xba\x3d\xbc\xd9\x57\x70\xcc\x13\xa4\x10\x5e\xc0\x17\x1a\x00\x29\x16\x76\xd3\xf0\xf4\x30\x6c\xdf\x61\x00\x26\x75\x18\xc9\x19\x7b\xa5\x82\xa6\x65\x08\x2c\x35\x34\xb3\x8b\xd0\xbd\x1a\x9a\xdb\x6b\x8b\x03\x9d\x33\x0c\xd9\xf0\x8c\xb9\xb1\x7f\x46\x77\x3c\xb2\x21\xfc\x84\x15\x55\x37\x74\x7a\x78\x1f\xc0\x0f\x86\xdf\xbf\x73\x82\xf2\x93\x12\x23\x81\xf3\xc7\x98\x50\x7e\xda\x73\x12\xea\xd5\x8c\xe2\x92\x86\x6d\x51\x4f\x8e\xac\x26\x3c\x1e\x96\xd5\xec\x7c\xff\x9e\x5d\xc9\x0a\xdc\x75\x5a\xb7\x87\xfd\xcc\x1c\xab\xeb\x75\xb2\x7d\x39\x88\xa4\x01\x49\x42\x59\x42\x06\xc3\x98\xa7\xb0\x9a\xba\xc5\x36\x16\x36\x1e\x8f\x72\x69\xed\x48\x0f\x1e\x75\x2f\x6a\xa5\x6c\xf9\xde\x6e\x34\x0c\xe5\x75\x5b\x9e\x22\x26\x53\xd6\xb2\x72\x36\x08\x49\x2a\x5c\x8d\x29\x50\xd7\x62\xf6\x44\x15\x61\x52\x95\x12\xb7\xcb\x88\x50\xd3\xc0\x3a\x31\x19\xa0\x35\xd1\xcb\x35\x46\x93\x03\x3e\xd9\xe5\x2b\x39\x63\xc8\x38\xae\x0d\x65\x1a\xb1\xbe\xae\x25\xd2\xcd\xf8\xdd\x29\x0c\x7d\xf1\x83\xe0\x73\xd8\x9f\x16\x49\x46\xf1\x14\x9e\x40\x51\x9c\xc5\x86\xe1\x49\x32\x3d\xa8\x5c\x1c\x19\xb5\x53\x58\xca\x02\xb7\x07\x3e\xcd\xb0\x2d\xff\x7c\x79\x03\xcd\xf8\xe8\x33\x09\x19\x0f\x94\xaa\xab\x76\x10\x78\xc5\xe9\xaa\xe2\x02\x5c\x28\x46\x34\xc5\x1a\xf3\x26\x17\x6e\x4d\x4c\x61\xd5\x88\xe0\x5f\xc9\x9b\x41\x6d\x7d\x20\x3a\xa3\xc8\x5f\x68\xa5\xca\xe9\xde\x65\x38\xaf\xe6\x6a\x02\xa5\x2a\x74\x79\xc1\x54\x98\xc5\xd6\x53\x20\x6c\x97\x82\x30\xe0\xf4\x71\x58\x0f\xdc\x40\x4d\x49\x6d\x50\xf2\x45\x83\x86\xb9\xe7\x9c\x53\xbe\x7c\x54\x71\x69\xcd\x92\x37\x64\x61\x8a\x2e\x14\x5b\x35\xed\x9c\x79\xa4\x4b\xa5\x14\x6d\x2b\x77\x52\xb4\x81\x8e\x33\x8a\x8a\x24\x2c\xb0\x3e\xe7\xd0\xc9\xcb\xa1\x1f\x24\x4b\xbe\xb8\x17\x22\xb1\xf4\x28\xcb\x6a\xd2\xf4\x0d\x1f\xe1\x91\x0d\x80\x57\xc3\xaf\x3c\x73\x74\x95\x93\x1a\xc8\xc4\x30\xca\x7f\x95\xc6\x70\xc7\x8d\xc2\x02\xdc\xac\xad\x81\x01\xe8\x0d\x0d\x29\x6d\x29\xb6\x62\xbe\x6b\x90\xce\x1d\xba\x34\x49\x19\x4b\xa4\x84\xc5\x22\xe5\x04\xef\x5c\x45\x12\x89\x78\x0d\xf2\xe7\xe8\x28\xac\x89\x9b\xe8\x12\xfe\xc7\x4f\x5c\x76\xea\xea\x75\xe3\x15\xe3\x72\xa3\xf9\x14\xde\xcd\x75\xa3\x25\x9a\xf4\x68\x4c\x87\x7d\xd2\x1e\x26\xbd\x28\x66\x73\xe0\x51\xcb\x67\xe2\xe1\x21\x23\x03\x27\x4e\xe4\x33\x60\xb3\x7c\xe0\x9f\xc5\x4e\x3c\xae\xcd\xd5\xeb\x73\xc2\x0b\x57\x4e\x36\x87\xd0\xf9\xff\xd9\x7b\xf7\xee\xb6\x71\x5d\x51\xfc\xef\xc9\xa7\x40\x7b\xce\xa9\xa5\x46\x76\x6c\xa7\x4f\x67\xd2\xec\xb4\xcd\xcc\xce\xd9\x7d\xad\x26\x33\x73\xf7\xc9\x2f\xcb\x95\x2d\x3a\x56\x23\x4b\xde\x92\x9c\xd8\xd3\xe6\xbb\xff\x16\x01\x3e\xf5\x70\x1c\x27\xed\x9e\x73\x6f\x3b\x6b\x4d\x2c\x3e\x40\x10\x04\x41\x90\x04\x81\x94\x31\xc8\x92\x51\x7e\xe9\xa7\xac\x87\xaf\xf9\x86\x3e\x97\xc0\x41\xc8\x3b\x39\x98\xe5\x0c\xc2\x1c\xfc\x38\xd8\x4a\x52\x61\xbb\xc0\x41\x86\xb9\xf1\x56\x32\x67\xe9\x24\x93\x78\xfc\xfa\xee\x37\x78\xc3\xb2\x8c\xa5\xf0\x2b\x5a\x30\x45\xf0\x61\x36\x88\xc2\x21\xbc\x11\xcf\x29\xfd\x0c\xa6\x3c\x25\x1b\xa3\x25\x22\x07\xc7\x2b\xfe\xc2\x51\x39\x12\xa8\xc0\x2f\xc9\x2c\x0e\x7c\x7a\x8c\x26\x3c\x1a\x0b\x4f\x03\xb0\x2d\x9b\x12\x00\x3d\x48\x52\x0e\xc4\xa1\xe7\x88\xa9\x30\x31\x72\xf1\x91\x74\xe4\xe7\xba\xea\x0a\x04\xd1\xfd\x56\xae\x09\xc7\xc9\x94\xef\x0f\xfc\x9c\xf7\x5a\x3e\x5e\x9c\x65\x6c\x34\x8b\x3c\x0e\x6d\x30\xcb\xe1\x8f\xc3\xe3\xbf\xbf\xff\xed\x18\xf6\xdf\xfd\x13\xfe\xd8\xff\xf8\x71\xff\xdd\xf1\x3f\x77\x50\x0c\x26\xb3\x1c\xd8\x85\xf0\xc0\x17\x4e\xa6\x51\xc8\x02\xb8\xf4\xd3\xd4\x8f\xf3\x05\x24\x23\x0e\xe1\xed\xc1\xc7\x57\x7f\xdf\x7f\x77\xbc\xff\xf2\xf0\xcd\xe1\xf1\x3f\x21\x49\xe1\x97\xc3\xe3\x77\x07\x47\x47\xf0\xcb\xfb\x8f\xb0\x0f\x1f\xf6\x3f\x1e\x1f\xbe\xfa\xed\xcd\xfe\x47\xf8\xf0\xdb\xc7\x0f\xef\x8f\x0e\x5a\x70\xc4\x70\xd7\xc2\xeb\x5f\x4f\xf3\x11\x8e\x5e\xca\x80\xde\xd6\x67\x92\x12\xff\x4c\x66\xe2\xc9\x37\x8c\xfd\x0b\x2e\x28\x87\x2c\xbc\x60\x01\xf8\x30\x4c\xa6\x8b\x95\x07\x95\xc3\xf2\xa3\x24\x3e\xa3\xdb\xd8\x3a\x86\x84\xc3\x11\xc4\x49\xee\x41\xc6\x18\xfc\x3c\xce\xf3\x69\x6f\x6b\xeb\xf2\xf2\xb2\x75\x16\xcf\xf0\x38\x50\x3c\xb9\xcd\xb6\x5e\xb4\x70\x8b\x16\x66\xef\x66\x51\xf4\x3e\xfd\x4d\x59\x95\x91\x18\xc8\xc8\x21\x74\x28\x78\x3f\xe4\x04\xc6\x47\x64\x03\x9a\x19\x25\x8f\x1a\xb4\x5d\x2b\x83\xdb\x95\x53\xbe\x55\x95\xa7\xed\x99\x8a\x99\x8e\x6c\xad\x20\xfc\x14\x12\xa6\xbf\x10\x71\x77\x6f\xe5\x35\xb4\xb3\x0f\x5a\x45\x39\x7e\x6f\x0e\xdf\x1e\x1e\x1b\x38\xc9\x6f\x6a\x62\xc2\x26\x49\xba\xe8\x41\xb7\xdd\xf6\xb8\xee\xfe\xd6\x9f\x87\x93\xd9\x44\xf8\x70\xe4\x63\x45\x25\xc8\xc5\x66\xe6\x4f\xa6\x11\x13\xc6\x37\x79\xea\x8f\x46\xe1\x70\x59\x5d\x51\xa4\xa2\x72\x94\x9c\x61\xc5\xea\x7a\x51\x72\x96\xb5\x78\x0f\xc4\xc4\xca\xc2\x80\x0d\xfc\x14\x26\x2c\x9e\xa1\x35\x10\x1f\x21\x7c\xb7\x8b\xba\x4c\x9c\x03\x9f\xdf\xca\x4e\x7a\xe0\xf3\xed\x47\x82\xf3\x23\x63\x20\xbc\x78\x65\x34\x5e\xc7\xfb\xbf\x1e\x19\xe4\x10\x9f\xe5\xb7\x90\x58\xd6\xda\x80\x8d\x13\xae\xe4\x7d\x81\x3c\xcc\xf9\xe2\x75\xff\xef\xc9\x84\xdd\x27\x1f\x3f\xf4\x6f\x38\x46\x0f\x41\xba\xc4\x2b\x9e\x60\x15\xc9\x53\x3f\xce\x7c\x6c\x2a\x33\x4b\x1e\x1b\xe9\x56\x85\x98\xe5\x97\x49\x7a\x6e\x96\x7d\x47\x49\x56\xb1\x6c\x91\xe5\x6c\x62\x96\x3a\xc2\x14\xab\x10\x27\xab\x59\xe4\x4d\x72\xc6\x1b\x23\x45\x93\xb4\x36\x34\x24\x0f\xe3\x33\xa4\x30\x3e\xbf\xca\x60\x18\xa6\xc3\xd9\x24\xcb\x7d\x74\x43\x47\x0f\xb2\x26\x0c\x86\x7e\xc6\x32\x0f\xb2\x84\xcb\xb0\x30\x33\x1c\x44\x84\x31\x3e\x38\xe7\x42\x3e\xca\x12\x3a\xfa\xc0\x15\xaa\x25\xdb\xc0\x25\xe7\xd2\x27\x9b\xb5\x49\x98\xe5\x8b\x29\x6f\x94\xaf\x3f\x29\x97\x6c\x6a\x27\x5b\x7c\x0a\x76\x6c\x6a\xf0\xc7\xf8\x82\xeb\xa4\x11\x06\x78\x13\x7b\xce\x16\xfa\x2a\x57\xcd\x9e\x63\x79\x7b\xcb\xa1\xbc\xde\x3f\xde\xef\xff\xe3\xe0\x9f\x26\x07\x98\x69\xd5\x6c\xf0\xfa\x1f\xc6\x3e\xfe\xe4\x3e\xcd\x88\xfb\x1e\xdc\x17\xfc\xcd\x7f\x72\xda\xde\x3f\x2d\xf8\x3f\x39\x67\x0b\x13\xdf\xd7\xff\x90\x0f\xd0\x34\xaa\x42\x5b\x16\xc8\xbe\xfe\x87\xc4\x96\x13\x89\x4d\xa6\x09\x2e\x22\x4d\xc8\xfd\x73\x46\x3e\x27\xe0\x2d\x5f\x7e\x42\x3f\x6a\xfe\x76\x48\x7d\xfa\xb8\xff\xc7\xc1\xc7\xfe\x1f\x87\xaf\x8f\xff\x6e\x76\xcb\x4e\xee\x3e\x6a\x97\x14\xe7\xa5\x5e\x9f\x7e\x44\xb2\xf9\x11\xc9\xe6\x86\x91\x6c\xf0\x3c\x2f\xf6\x27\x4b\x3a\xda\xbd\x0b\xd8\xb7\xe8\xa8\x0d\x68\x3d\x64\xaa\x82\x0f\xd6\xb1\xed\xb6\x0c\xd9\xf3\xff\xf6\x53\x5a\xbd\x1f\xa3\xe3\xf0\x3f\x48\x8b\x35\x9e\x5b\x26\x83\xcf\xd8\x44\x26\x3b\x44\xd5\x49\xf0\x9a\xe4\x08\x71\xbf\x26\x7b\xc0\x6b\x28\x8b\xef\xd0\x85\x17\xbb\xd0\x36\xec\x84\xc0\xf4\x57\xb6\xbc\x9b\x88\x40\xe8\x9a\x95\x45\x4f\x43\xde\xcf\x64\xf0\x19\x09\x5a\xee\x5e\x4d\x0c\x8f\xa3\x59\x3a\xf2\x87\x4c\x05\xf1\x50\xee\xe4\xcc\x90\x0c\xb7\x75\xec\x6c\x5c\x41\x78\x77\xe1\xa6\xb9\x00\x8f\x77\xe4\x65\x32\xbf\xb5\x6f\xe2\xf5\x20\x98\x9e\x89\xd7\x73\xdf\x6e\x42\xb8\x0b\x1f\xda\x77\x40\x61\xe5\x21\x79\xa8\x1f\x4a\xad\xef\x5a\x7e\x03\xe8\x1d\xe5\x7a\x3e\x48\xc9\x31\x2e\xc7\x65\x1c\x46\x41\xca\x6e\xe1\x36\x7b\x6d\x57\xa6\xb7\x08\x8e\x10\x27\x01\x5b\xcf\x0b\x32\xaf\x79\xea\xf2\x0d\x86\x12\x4c\x62\xba\x3a\xf2\xc5\xfe\x86\xb0\x6b\x14\x94\x91\x0f\xf1\x5b\x32\x41\x6a\xd5\xe4\xcb\x5d\xe6\xe2\x97\xcc\x12\xae\xd6\x65\x1e\x7d\xca\x4c\x31\xb5\x54\xae\xf8\x96\xd9\xe6\xab\x2d\xd1\xb0\x4c\x91\x45\xc8\x19\x93\xcc\xc6\x2f\x99\x95\xf0\x4d\x32\x99\x89\xd7\x88\x5b\x71\x7d\x75\xd2\x90\xfd\x69\xe0\x19\x6e\x90\x8f\xf9\x0f\x42\x95\xff\x12\x68\xa1\xdf\x72\x89\x00\xba\xa5\xe6\xcd\x35\x84\xb9\x24\xae\x3f\x17\x67\xbf\x73\xb1\xb7\xab\x7a\xf6\xf5\x2b\x7c\x91\xb3\x8e\xe8\xa2\x66\x8f\x20\x05\x97\x0b\x6d\x8f\xcf\xed\x36\xed\x3f\xd0\xce\xd5\x5f\xc8\x60\x50\xbb\x37\xd6\x08\x1c\xd7\x69\xa4\x6c\x38\xf6\xd3\x3c\x6b\x66\x34\xa4\x0d\xfb\xc5\x99\xf0\x9b\x93\xe7\xe9\x4a\xe1\x94\xaa\x23\x0d\x9f\x63\x38\x25\xbc\x33\x44\xc7\x60\x78\xaa\xb4\x9f\x8b\x63\x9e\x8c\x02\x2c\xd1\x28\x58\x16\xa5\x37\xd0\x54\x5b\x7e\xe1\x22\x02\xc7\xb6\x91\x5d\x48\xcb\x63\xfd\xfe\xf3\xca\xa3\xfe\xe8\x7b\x11\x43\xb8\x68\x7a\x5a\x2c\x2b\xc7\xc4\xe2\x55\x35\x32\x26\x8b\xf5\xc0\xe2\x2d\xb5\x26\x88\x11\x6f\xcd\x61\x13\x1a\xe8\x08\x49\xa6\x2c\x4a\x29\x34\x4b\x8a\xa9\x85\x19\x41\x07\x6a\x3d\x68\x74\x5a\x9d\x86\xd8\x1d\x09\x67\x37\x82\x49\x37\x00\xc8\x59\xa9\x98\xad\x56\x88\x23\xf5\xfb\x36\xfe\x71\x05\xe0\x92\x87\xdc\xe7\x4b\xdd\xd2\x7d\xef\xbd\x52\x3f\x4b\x87\xfd\xa9\x9f\x8f\x6b\x15\xcf\xa7\xa8\x79\x1a\xc0\x53\x26\x08\xe0\x0c\xc2\x38\x08\xe3\x33\xd7\x26\x85\x56\x9f\x03\xa7\xb2\x3b\xf7\xfd\xfb\xfa\x46\xd3\x31\x4e\xcf\x57\x44\x14\x49\xbc\x83\x1b\xde\xd2\xc5\xc7\x52\x7f\x4a\x77\x43\xdc\x6f\xd5\x7b\x7f\x90\x51\xa7\xee\xb0\xad\xa0\xae\xad\xdc\x8f\xbb\x77\xde\x1a\xab\x69\x6d\x98\xdc\x7d\xcf\xc6\x35\x6d\x4d\xfc\xf9\x9d\xb7\x15\xd6\xb5\x15\xc6\x77\xde\xd6\x79\x4d\x5b\xd9\x37\x68\x2b\xaa\x6b\xeb\x5f\x69\x7e\xe7\x8d\x8d\x6a\x1a\x63\xd3\x2c\x8c\x92\xbb\xef\xdc\xe7\x9a\xf6\xa6\xe1\x9d\x37\x75\x56\xd3\xd4\xd8\x8f\x46\x1f\xee\xbe\xb9\x49\x4d\x73\xb9\x3f\xab\x6d\x2b\x9c\x4c\x66\x39\xdd\x08\xd4\xad\x5b\x03\x5c\xb7\x7c\x3e\x59\xd7\x84\x30\x24\x08\x9c\x55\x71\x8f\xea\x0f\xf8\x6a\xfa\xd6\xcf\xc7\x2d\x2e\xdc\x28\x8d\x4b\x1e\x95\x8a\x62\x08\xd3\x87\x89\x2a\x8b\x18\xd0\xcb\xb6\xb9\x4c\xe3\xd3\x9a\xd2\xc2\x58\xa5\xc9\x76\x32\x9d\xa6\xda\xe6\x3c\xac\x12\x39\x3f\xd3\xb6\x59\x70\x1b\xec\x42\x87\x35\x3b\xa2\xed\x69\x28\x4b\x7e\x38\x94\x2e\xde\xf9\xc8\x71\x55\x20\x84\x2d\x10\xc5\x72\x7f\x06\xbb\xd0\x85\x87\x9c\x87\x8c\x93\x08\x4e\x32\x67\x6e\x59\xd3\xcd\xe1\x05\x74\x60\x0f\xda\xd0\x83\x39\xfc\x0c\x4d\xfe\x31\x0d\xa1\x27\xfa\x4d\x35\x6c\x57\x97\x9c\x6e\x65\x30\xbb\x08\x47\xe0\x83\xc0\x76\x09\x5a\x53\xa5\x11\x48\xaa\x8d\x20\x0b\x6b\xe2\x52\xef\x7b\x77\xb3\x26\xde\x4c\x35\x52\x48\x64\x2c\x0d\x59\xe6\x91\x53\x19\x6d\xeb\x79\xcf\x71\xf8\x08\x51\xae\x38\xa2\x72\x39\x45\x5d\xd7\x78\x0e\x6a\x1f\x6c\x79\xf0\xd9\x83\xac\xed\x41\xd6\x51\x55\x4f\x10\xee\x49\xfb\xf4\xd4\x83\xd8\x83\x09\xcf\xe8\xe8\x23\x2f\xf8\x19\xe2\x1d\xd8\xdc\x0c\xe5\xc9\x7a\xd6\xc6\x12\x55\x30\xd0\x05\xb1\xba\x46\xf8\x4c\x4f\xe0\x3e\xc3\xcf\x30\xe1\x10\x3e\xeb\xb3\xf9\xac\x73\xf2\xf9\xf4\xa4\x73\x0a\x9b\xbb\xe2\x77\x1b\xbd\xa0\x67\xef\xfc\x77\x4e\xd6\xa6\x4c\x17\xf6\x80\x7e\xb7\x4f\xa1\x07\x32\xd9\x78\x3e\x46\xc6\x07\xf6\x40\x76\xda\x4b\x1d\x05\xfe\x05\x46\x52\xef\x76\x4b\xe3\xe7\x41\x22\x1c\x89\xee\xf3\x7d\xba\x13\xe3\x06\xea\x72\x1c\x46\x0c\x9c\x66\x33\x16\xe7\x6d\xc9\x49\xcc\x01\xc7\x86\x41\x6e\xb2\x53\x4d\x8c\xdb\xf9\x39\xa4\x0b\xd7\x5f\xe4\xe4\xab\xf3\x02\x29\xb6\x0d\x61\xf6\x86\x5c\x84\xd4\x9c\x45\xd3\x93\x29\xe9\x30\x6b\xcc\x86\xe7\x19\xe7\xe4\x4f\x78\x57\xf5\x09\xc2\x8c\xbc\x2d\x34\xa3\xf0\x9c\xb5\x60\x5f\x18\xfe\x84\x19\x86\x22\x0e\xe9\xae\x51\x97\xe0\x55\xc3\xbc\x81\x3e\x8f\xe3\x24\x37\x7c\x73\xe1\x95\xe5\x18\xaf\xc1\x08\xb6\xa0\xee\x27\x34\x01\x68\xa0\x8f\xdd\x30\xce\xd9\x19\x4b\xe1\x0c\xf7\x7c\x29\xcf\x89\x21\x49\xd1\x07\xf2\xbf\x66\x7e\x04\x79\x02\x9f\xda\xe4\x0b\x21\x62\x59\x26\x0b\x18\xb9\xef\xe8\x08\xef\xed\xfe\xff\xe9\x1f\xed\xff\x72\xd0\x3f\x7c\x77\x7c\xf0\xeb\xc1\xc7\x4f\xd2\x75\xf2\xdf\xc8\x8b\x1d\xfe\x9c\x30\x5e\xf6\xfd\x08\xfa\x94\x13\xc6\x43\x06\x8f\x5a\xed\x56\x1b\xbf\x65\x8c\x32\x78\xe3\xc7\x67\x98\x32\xf5\x53\x7f\x02\x5f\x1e\x5e\x09\x2a\x1c\x8f\x99\xf8\x95\x27\xf4\x30\x07\x9d\x87\xfd\x4d\xde\xa5\x7f\x19\x24\x49\xc4\xfc\xf8\x0a\x3e\x8a\x94\x4f\x79\x8a\x54\xad\x21\xb0\x47\xbe\x2a\x3e\xe1\x1b\xd6\x4f\x04\x8c\xcd\xf1\xce\x58\xe0\xdf\x6f\x85\x19\xb2\xe1\x9b\xf0\x9c\x39\x27\x1d\x0f\xba\x1e\x6c\xa3\x05\xdd\x43\xd8\xda\x82\xdd\x17\x64\x00\x53\x55\x3a\x48\x86\x78\x2a\xde\x1a\x24\xc1\x42\x1d\xe2\xac\x54\x55\xc4\x8b\x58\xa1\x64\xbf\x15\x27\xc9\xd4\x2c\x4a\x41\x5c\x38\xcb\x1b\xd7\xfe\xba\x42\xd9\xf7\x2b\x91\xf4\x9e\xb8\xe7\x7f\xf0\x40\xf1\xb0\x63\x32\x8e\x8b\x6f\x62\xf5\x44\x10\x80\x76\xaa\x5d\xe1\xea\x06\x2b\xe6\xe3\xed\x5e\xa9\x92\x95\x7d\xc6\xde\xfa\xf9\x70\xcc\xea\xdc\xb2\x3e\xeb\x3c\x17\x33\xd2\x28\x6b\x44\x62\xa9\xac\xd3\x95\x8e\x6c\x65\x50\xb5\xba\x82\x6d\x35\xdb\xb1\x9f\x75\x42\xe1\x99\x28\x36\xbd\xa6\xdd\x6d\x53\x28\x70\x2e\xe7\x38\xa3\x95\x0d\x1e\xc3\xa8\xa0\x83\x9f\xfa\xad\x30\x47\x6f\x4a\x4c\xcf\xb0\x69\x1a\x5e\xf8\x39\x2b\xcc\x98\x13\x1c\x9e\xdd\x7e\x4b\x76\xe5\xb4\x30\x7d\xc4\x5b\xf4\x3c\x41\x49\x20\xa0\x16\xe6\x93\x1c\x6b\x3d\xa1\xd0\xfa\xc7\x28\x6c\x30\x19\xc7\xf9\x50\x64\x99\x5c\xb6\xb5\x05\xaf\xd1\xd3\x72\x96\x27\x29\xbd\x52\xf8\x44\x96\x24\x9f\x20\x65\x19\x5f\x42\xc2\x18\x6f\xeb\x85\x59\x09\x47\x09\x1f\x7c\xf8\xf0\xdf\x87\xc7\x30\x98\x9d\xf1\x02\x47\xfe\xc8\x4f\x43\x78\x2e\xfc\xc3\x1d\x31\x66\x87\xe1\xb8\x64\x83\xf3\x30\x47\xeb\x9b\x6c\x9c\x5c\xf6\x07\xb3\xb3\xd6\xf0\x2c\xdc\x0b\x83\xdd\xce\xe3\x27\xed\xed\x47\x15\xc6\x43\x96\x4b\x0a\x22\xcd\xee\x2e\x34\x64\x97\x1a\x25\xa3\x98\x68\x26\xde\x8d\x50\x4d\x55\xc5\xb4\x4a\x16\x85\x25\xdd\xcd\xf2\xa5\x96\xe8\xa8\xb4\xd8\x8e\xe0\x2a\x41\x44\xa1\x2e\xec\x55\x31\x32\x15\x39\x69\x9f\x0a\x9f\xce\x5c\x63\x10\xe5\x7b\x66\x79\x35\x59\x09\x17\xb9\xc1\xb1\xa0\xd4\x4c\x65\x73\x58\x2b\xe6\xf2\x52\x43\xd8\x1f\xf7\xf9\x77\x75\x9f\xff\xe3\xf6\xf7\x87\x23\xe5\x1f\x8e\x94\xbf\x93\x23\x65\xbc\xb8\xa0\x18\x78\x3b\x7f\x69\xbf\xbb\x1a\xb5\xda\x17\x69\x4e\xc6\xa2\x91\x87\xc0\x14\x6a\x3c\xc9\x6e\xfd\xa3\x7c\x58\x20\x50\xc0\xc7\x6e\x63\x3f\xe3\xcb\xf6\x80\x31\xbe\x55\xc0\x87\x5b\x61\xc6\x02\x68\x42\x36\x9b\xe2\xc3\x16\xb3\x04\x05\x82\x23\xd4\xe4\x69\xae\x4f\xfa\xa4\x5c\xf7\xf0\x7b\x77\x77\x17\xee\xd3\xba\x77\xdf\x30\x2a\xd5\x79\xba\x97\xb0\x47\xc9\x3d\xe0\x18\x17\x9c\x20\xcb\x27\x83\x4e\x36\x1b\xd0\x55\x13\xa1\x85\xbf\x65\x57\x05\x70\x9d\x81\x6f\x88\x74\x13\x1c\xbb\x42\xa6\x58\xca\xab\x87\xe6\x88\x97\xe5\x2a\x6a\xca\x32\x34\xe2\xc6\x20\xe5\xc2\xb0\x1b\x63\x95\x93\xbd\xae\x1e\x2b\x0f\xf7\x65\xf7\x61\x13\x4a\xb8\x20\xa9\x24\xf6\x9a\xd9\xb5\xc0\x26\xf1\xe5\x18\x08\x5a\xe8\x9a\xf3\xe3\x0b\xee\x0f\xc5\xc8\xf7\x50\x14\xa1\x75\xbe\x26\x8e\xf9\x06\x82\x62\x41\x1a\xe1\x1a\xf0\x51\x44\x21\xbe\x03\x5a\x26\x5f\xc1\x95\x9c\x70\x06\x71\x05\x7e\x99\xed\x7b\x65\xaf\x3a\xbd\x66\x80\x34\x6e\xc6\xcb\xc8\x5d\xa3\x48\xbd\x99\xcb\xab\x34\xc9\x32\x65\xe4\xc2\xe7\xec\x2b\xc6\xb9\x07\x1c\x9c\xb3\x7c\x65\x1c\x96\x64\x7e\xbf\xf0\xf6\x54\x33\x10\xaf\xec\x41\xbf\xf0\xc8\x49\xd5\xe4\xd9\xce\x72\x7f\xd0\xbc\x88\x7c\x1a\x25\x6f\xa8\xea\x67\xa4\x78\x19\xca\x2b\xd9\x8f\x42\x75\xa8\x3b\x93\x7c\x08\xdc\x6d\xf9\xd3\x69\xb4\x10\x75\xd5\x8a\xeb\xba\xea\x19\xb3\xe5\xee\x98\xba\x74\x62\x7b\x28\x34\x9e\xab\x5d\xfb\x54\x4d\xf4\x82\x9e\x89\x42\xb5\xab\x22\xde\xc8\xce\xc6\xd5\x2a\x6a\xcf\xc9\x7d\x45\xdd\xfb\x18\x45\x1a\xc9\x58\x78\xf9\xd5\xe0\x00\x1b\x2a\xd3\xbc\x67\xb5\xee\x9d\x6f\xa6\x27\x9d\xdc\x1f\xe2\xc5\xf9\x87\x8f\x07\x47\x07\xef\x8e\xf7\x8f\x0f\xdf\xbf\xeb\xef\x1f\x1f\x7f\x3c\x7c\xf9\xdb\xf1\xc1\x11\x5e\x9b\xcb\x80\xa7\xa4\xdf\xae\x79\xc2\x25\x99\xa0\xa0\x20\x2f\x7d\x60\xf5\x6f\x3d\x89\x2b\x9e\x20\x2b\x53\xff\x3d\x78\xe7\xbf\x83\x1e\x6c\xce\x6b\x0e\xd4\x96\xbe\x3d\xba\xdb\xbb\xd3\x95\xaf\x23\x28\x4e\x7a\x98\x8d\xd7\x05\xe3\x1b\x60\xd6\xdc\x28\x04\xdb\x7d\x3c\x5c\xaa\xd5\xce\x1f\x3d\x5d\x77\x03\x10\x6c\xd3\xb3\xb2\x69\x12\xf9\x39\xab\x57\xff\xdb\x4f\xd6\xb5\x76\xed\x0b\x23\xc4\x64\xb6\x64\x77\xf1\xe8\xd9\xda\xf6\xab\x79\x38\x3c\xa7\x48\x5b\xb5\xe0\x9f\x3d\x7f\x4a\x57\xf5\xc6\x42\xaf\xc6\xd5\xc1\xc0\xc5\xfa\xe0\x98\x82\x23\xf3\x25\x83\xa7\xb7\xe8\x13\xe5\x13\x25\xf0\xf6\xcc\x25\xc0\x19\x26\x33\xdb\x55\x41\xc0\xf5\x6f\xac\xe6\xd8\x26\xf1\xd7\x5a\xe8\x98\x43\x7d\x72\x7f\x8c\x02\x86\xda\x43\x2b\x9c\x00\x77\xe4\xc1\x49\x20\xfd\x45\x37\xa1\x73\xca\xd7\xd7\x59\x9c\x83\x9e\x65\x9d\x36\xf4\x28\xd1\x15\xcf\x50\x2d\xe4\x4b\xa1\xd7\xa8\x07\x1e\x64\x53\x36\x0c\x47\xa1\xbc\x08\x59\x1d\xed\xc2\x28\x70\x9e\xe7\x98\x4b\xf9\x41\xb8\x0b\x82\x08\x74\xcd\xd6\x8a\x48\xc6\xe1\x90\xd5\x12\x18\x3d\xca\x9a\x1d\x76\x65\xff\xa1\x23\x9d\x8e\x17\x07\x41\x3f\x1b\x09\xdb\x7c\xab\x65\x7c\x77\x78\x31\x83\x9c\xc6\x33\x94\xdc\xc7\x0b\xbc\xe0\x24\x6c\x9f\x9a\xc9\x18\xed\x2b\x38\x09\x3b\x56\x2a\x9b\x8a\xc6\x69\x17\x91\x4c\xe1\x67\x02\x61\xdc\xcc\xe4\x8c\x57\xc5\x54\x4f\xc1\xe7\x65\x3d\x09\x96\xe0\x58\xc5\xc3\xb6\x47\x68\x87\x1d\x8f\xf0\xd5\x85\x84\xab\x02\x51\xf2\x86\xec\x35\x52\xec\x75\x18\x0f\x53\x3c\x11\xa4\xa1\x52\x08\x72\xc4\x24\x1f\x19\x7d\x63\x53\x78\x01\x6d\xb3\x5f\xbe\xbe\xea\x1c\x45\x49\x92\x12\x08\xd8\x42\xcc\x5c\x78\x58\xe8\x17\x76\x95\x6e\x5a\x59\x18\x11\xb5\xea\xca\x7e\xfb\x9e\x81\x8e\x59\xa7\xfa\xf7\x73\x6d\xff\x04\xc6\x3c\xe5\xa1\x40\x79\xab\xb6\x7b\x92\x18\xc9\xb4\xb6\xf0\x77\xea\xdf\xb2\xf1\x43\x0e\x5f\x7d\xfc\x90\xf5\x57\x1d\x40\x31\x05\x83\x55\xe8\x6c\xe1\x71\x2d\x9d\x2d\x34\xae\x25\x74\x11\x0f\x4b\xa9\x46\xb1\xa3\xa5\x90\x9d\x7a\x55\x5a\x34\x1c\xbd\x58\x60\x99\x55\x06\xb0\xb0\x0e\x72\xed\xa2\x24\x22\x6f\x50\x7b\x28\x6a\x1b\x6b\xf7\x1b\xc4\x8d\x43\x5a\xae\xca\x16\x57\x7c\x09\xcc\x48\xa4\xdb\x37\x44\xca\x10\xcb\xf8\xe2\x75\xd7\x32\xfc\xb8\xd1\x2a\x51\xea\x04\xad\x12\x08\x96\xb8\x97\x37\xe3\x29\x22\xbb\xa5\x11\x29\xae\xd9\x15\xb6\x06\x9d\xf6\x5f\xea\x25\x18\x1a\x0d\xe2\xae\xa8\xfe\x19\x51\xe7\xe9\x5f\xc6\xbc\x51\x60\x6a\xd8\x37\xae\x77\xaa\xcc\x61\x2d\xd7\x58\xb7\x9f\x0a\x85\x72\x16\x63\x84\xa6\x52\xe7\x0d\x76\xa4\xbb\x30\x1c\xd5\x75\xf4\x4f\x8e\xcc\xc0\xcf\xc2\x25\x2f\xb9\xba\xed\x95\x91\x79\xc9\x21\xad\x89\xcc\xb6\x81\xcc\xab\x28\xc9\x58\xb0\x84\x3e\x8f\x6e\x86\x12\xc1\x5b\x13\xb1\x47\x84\x58\xb0\x6c\x0b\xb0\xfd\xf4\xe9\xca\x18\xbd\xf6\x73\xb6\x26\x2a\x8f\x09\x15\x7a\x61\xb2\x64\xc3\x70\xe7\x93\x66\x78\xe3\x49\x53\x40\xf5\x76\xb3\xe6\x09\x01\xa3\x13\xcc\x25\x83\xf0\x6c\xe5\x41\x20\x81\xbc\xe6\x30\x3c\x25\x74\xd2\x64\x16\xd7\x33\xe9\xb3\x67\x77\x3e\x0a\x75\xf6\xc2\xab\x62\x7a\xbb\x41\x78\x46\xb0\xe8\x45\xd2\x92\x41\x78\xbe\xf2\x20\x90\xff\xf0\x35\x07\xe1\x39\xa1\x83\x0f\xed\x47\x49\x3a\xe9\xe3\xeb\xc0\x25\xc3\xb1\x3a\x73\x1c\x4b\x98\xaf\x32\x29\xcd\x6e\x52\xeb\xe8\x62\xdd\x3e\x75\xc4\x52\xf3\x67\x92\x4c\x96\x6c\xd8\x3b\x2b\xf7\xe4\x7f\x92\x64\xb2\x2e\x2e\x62\xa9\x4a\xcf\x06\x4b\x06\x7b\x7b\x65\x54\x3e\x9e\x0d\x56\xa7\xe5\xc7\xb3\x81\xb9\x96\xdc\xa0\xc6\xad\x44\x7d\x47\xac\x88\xe3\x2c\x5a\x42\xfe\xee\xca\x7d\xfe\x7b\x16\xad\xde\x83\xbf\x67\xd1\x9b\x64\xed\xe9\xd0\x11\xeb\x67\xe4\xd7\x0f\xd7\xb3\xe7\xab\x0f\xd7\x1b\x7f\xb0\x2e\x26\x62\xc1\x1c\x0f\x97\x11\x71\xf5\x15\xfc\xef\xc3\x9b\x10\x71\x78\x2b\x22\x8a\x55\x6b\x38\x1b\xb0\x31\x8b\xc2\x25\xe2\xe4\xf9\xe3\x95\x3b\xf0\x4a\x42\x2b\x60\x75\xfb\x05\x61\x70\xe3\x05\xa1\xa2\x87\xb7\x54\x68\xc5\xda\xfc\xaf\x99\x1f\xe7\xe1\x9f\xf5\x2a\xd2\xb3\xe7\xd7\x28\xb5\x12\x82\x7a\x48\x6d\xff\x2b\xec\x64\xbe\xc3\x3b\xad\x1b\xdb\xd6\x8f\x67\xec\x76\xe7\xe9\x67\xfe\x64\xe2\xdf\xee\x2c\x3d\x4e\xca\x40\x6e\xb0\x25\xc3\x1b\x4d\x3f\x5e\xa6\x64\x3d\xc6\xe3\xe2\xe2\xb6\xdf\xf7\x20\xa8\x74\x59\xeb\xe4\x85\xbd\xb0\x0f\x9b\x90\xc3\x43\x08\xa4\x1b\x40\x03\x18\xef\x4e\xcc\xd0\xff\x0c\x87\x38\xf0\x60\x61\x01\xf5\xe5\x99\xc6\x34\xb9\xe4\x05\x16\xae\x07\x03\x33\x8d\x6a\x34\x81\xe7\xc1\x2e\x74\x60\x0b\x16\x5e\x3d\x2e\x1a\x96\x40\x0a\xeb\x57\x20\x36\x9e\x31\x44\xc8\x38\x0a\x87\x5d\x18\xf0\x96\x4c\xef\xc4\xb0\x67\xd2\x03\x5e\x40\xe7\x59\x1b\xbe\x7e\x85\x00\x5f\x19\x3c\x6b\xc3\x1e\x04\xd0\x84\xed\x27\x6d\x78\x48\x8d\xa3\x6a\xe6\x04\xb0\xc5\x13\x5d\xe8\x71\x2a\xf6\x56\x39\xf3\x32\x86\xaa\xf2\x4c\x99\x6c\xda\x7d\x17\xf6\x60\x00\x3d\xf0\x0b\xef\x19\x90\x4b\x1c\x9b\xba\x0e\x27\xd9\xe6\xc2\xc5\x5b\xa9\x0e\xec\x49\x66\x02\x7d\x6b\x69\x10\x41\x55\x43\x2a\xc0\x5e\xf5\xe0\x7d\xab\xbe\x94\x46\x48\xe0\x7a\xf3\x51\xfa\xa6\xf4\x2e\x8a\xad\xef\xf0\x02\x72\xdd\x37\x02\x16\x2b\x64\xad\x89\x9f\x0f\xc7\xce\x56\xeb\xcb\x93\xab\xad\x33\xd7\x72\x78\x24\x6f\x31\x55\xe9\xfb\xff\x71\x1f\x36\x01\x43\x72\xf2\x65\xa4\xf2\xfe\xf2\x3b\xbc\x73\xf9\x61\xb4\xf8\xff\x90\x13\xa2\xbe\x08\x55\xcd\xd2\xfe\x1b\x7f\xb1\xec\x38\xe4\xf9\x0f\xf7\x3f\x3f\x0c\x40\x7f\x18\x80\xfe\x2f\x35\x00\xfd\xbf\xd1\x91\xd4\x0f\xf3\xd6\x1f\xe6\xad\x3f\xcc\x5b\xff\x4a\xe6\xad\x1f\x45\x88\x4a\x38\x4b\x93\xd9\x14\x92\x11\x30\x3e\x3c\x30\xf0\xd3\x0d\xd3\xb1\x1b\x0e\xda\x4b\x3f\x5d\xdb\xf0\x55\x02\x58\x62\xfc\x2a\x8b\x5c\x63\x00\x2b\x8b\xdd\xd8\x08\x56\x56\x5c\xc5\x10\x56\x35\x72\x43\x63\x58\xdd\xcd\x0a\x83\x58\x99\x59\x17\x4f\xbd\x50\xaa\x10\x57\x1d\xb5\x47\x15\x56\x9d\x1c\x5c\x19\xc1\x1e\x92\xd1\x28\xa3\x88\xc8\xa4\x2d\xd0\xb7\x59\x22\xf2\x17\xc9\xcc\x28\x41\xdf\x66\x09\xe9\xec\xab\x5f\xe1\xed\x0b\x0d\x26\xfc\xdc\xff\x07\xc6\xb9\x15\x25\x44\x42\xb1\x8c\x5d\xa0\x98\xfb\x21\x09\xe3\x9c\xec\xc2\x72\x8a\xe5\xa7\xcb\xda\x79\x66\xcd\xf9\xfe\x1c\x83\xe2\x88\xc2\xf8\x69\xe6\x2f\xec\xfc\x45\x31\xff\x7a\x9f\x61\x7d\xe5\x34\x8c\x68\xd7\xf0\xa0\x41\x34\xb2\x9c\x87\x89\x3e\xcb\x9f\xf2\xaf\x8d\x39\x4f\x45\x14\xf9\x0f\xc4\x45\x3a\x13\x93\xc3\x29\x47\xf3\x7b\x79\xe8\x32\xa6\x0a\x86\xf9\xb6\x3d\xf9\xb2\x38\x4f\x17\x7c\x59\x2f\x44\xc7\xed\x57\x0e\x58\x39\x51\x02\x10\xc4\x71\x4d\xca\x03\xcc\x39\xd9\xcb\x95\x5a\x73\xbb\xd8\xa2\xa6\xd8\xc2\x2e\x26\x9e\x34\x56\x16\xc5\x3c\xbb\x38\x0a\xb4\xdf\xfd\xa8\xa6\x86\xcc\x2e\xc4\xdc\xbd\x27\xd3\x2b\x43\xaa\x68\x5b\x75\x30\x83\x03\x11\xcd\xe6\x6f\xc3\x40\xc5\x11\x2b\xf4\xb0\x3e\x6b\xfe\x16\x0d\x4c\x6b\x6a\xd5\x65\xcd\xdf\xa2\x37\x92\xea\x5a\xb5\x59\xd2\x42\xa9\x2a\x6f\x98\x24\x69\x90\x1d\xa3\xbd\x5a\x7d\x7e\x7d\x3f\x28\xff\x25\x06\x1c\xa9\xca\x8f\x92\xcb\x97\xc9\x2c\xae\xab\x3e\x0e\xcf\xc6\x76\x7e\x61\x60\xd0\xf0\x43\x3e\x4b\x77\xd4\x28\xd9\xc3\x64\x34\x22\x4b\x9c\xb4\x4f\xcd\xb0\x3b\x66\x3b\xaa\x48\xc7\x28\x22\xac\xd2\xae\x81\x7a\x1d\xc8\x4a\x26\xe1\xdd\x90\xc2\x78\x77\x17\x1a\x17\x5c\x00\x0d\xfd\xa8\x61\x77\x42\x8e\x12\xca\x91\x96\xb2\x47\xd3\x43\x4f\x63\x20\x1f\x0a\xeb\x71\xc7\xf4\x05\x6c\x8a\x35\xa1\x50\x49\x99\x31\x3b\x08\xa1\xa9\xba\xe5\x16\xa0\xf0\x82\x08\x6c\x93\x16\x06\x1b\x0e\x32\x97\x01\x67\x53\xf7\xbf\x00\x08\x4b\x2e\xa8\xad\x12\x20\x93\xdd\xbe\xc0\xbc\xd3\x43\xd0\x1e\x2c\x3a\x3d\xc4\xc1\x83\x79\x57\xa5\x75\x7b\x04\xee\xaa\x0c\x81\x3a\x2d\x21\xf0\x7a\x02\x42\x50\x86\x10\x06\x55\x10\x88\x65\x2b\x20\x28\x1c\x30\xad\x02\x07\xc3\x80\xd1\x1c\xd6\x71\x92\x86\x7f\x26\x71\x5e\x3b\xb0\x8b\xa5\x03\x3b\xaf\x1c\xc0\x45\xcd\xa8\x8b\x81\x9d\xd7\x90\x59\x8c\xd7\xbc\x66\x38\x17\x26\x5b\x2c\x96\xb2\x85\x31\xee\x8b\x65\xe3\x5e\x35\xb0\x9a\xa8\x7c\x30\xd6\x1a\xd8\xa0\x62\x58\x82\xe5\x10\xae\x1f\x58\x83\x35\x62\x6b\x60\xf5\x9c\xbd\x2b\x07\x97\xf4\xef\x66\x07\x7c\x15\xe7\xee\xa6\xd0\xd4\x0f\x96\x4c\xbf\x98\xda\x4f\x28\x13\x0a\x65\xc3\x23\x6d\x34\x84\x2b\x79\xde\xe4\xad\x84\xd3\xf5\x5d\x6b\x44\x61\x8c\x8e\x48\xe5\xa0\x7f\x23\xc8\x6f\xc3\xe0\x1b\x41\x7e\x99\xe4\x3a\x18\xa0\x62\xe4\x2b\xd7\x78\x91\x26\xdd\x8f\xde\xe2\x8d\xdb\x9d\xb0\xcf\x1d\x32\xcf\x35\x1c\x93\x35\xac\xd8\x1e\x7c\xdf\x51\xda\xa3\x6c\x58\x24\xab\x78\xba\x27\xcb\xde\xee\xf9\x5e\xd1\xb3\xb8\x50\x34\xff\x0d\x1e\x9d\x85\x6b\xea\x5b\x78\xda\x5e\xa7\x2a\x67\xad\x53\xb7\xe0\xbf\x9c\x13\x61\x2d\x0a\xa0\x1d\x2e\x87\x80\xba\xc5\x2d\xbd\x6b\x2f\xee\x00\x06\xad\x9b\xb7\x74\x15\x5e\xd6\xee\xd7\x02\xc8\x49\x4d\x9e\xc7\xd3\xe4\xfc\xf6\xee\xcb\x39\x90\x3f\xee\xc0\x39\xfb\x5d\x38\x78\x27\x7d\xe2\x36\xee\xdd\xaf\xf4\x83\x5a\xca\x32\xa3\x0a\x4b\x8a\x35\x06\x91\x3f\x3c\x6f\x94\xfa\xdf\x69\x3d\x36\x7a\xf2\xd8\xc4\xa8\x6d\x72\x81\xa9\x3a\x61\x8b\xb7\x7f\x31\x6b\x9e\x1a\xd9\x37\xb4\x9d\xef\xe0\xbf\xee\x5b\x19\xef\x8f\x90\xd1\xf9\xfc\x7b\xeb\x4f\xd7\xb6\x65\x6a\xf7\xfb\xaf\xfd\xdc\xbf\xe6\xae\x6f\xed\xe7\xa4\xfd\x57\x7c\x55\x59\x0e\xbd\xdb\xfd\x71\x93\x68\x07\x12\x29\xdc\x96\xc9\x6b\x1f\xe1\x7c\xc9\xb8\xd6\x31\x2e\x7a\xaa\x2f\xda\x74\x55\x75\x96\x4d\xc7\x24\xe5\x58\x95\x15\xe7\xd6\xc5\xb3\x6d\x3c\xc5\x96\x9b\x63\xbc\xed\x11\x1d\xa4\x2d\x89\xee\x56\x32\xf8\x8c\xe7\xce\x1b\xda\x05\xa1\x1f\x0d\x67\x91\x9f\x93\x63\x2e\xda\x05\xe9\xc3\xfd\x69\x92\x85\xf4\xcb\xf2\xa6\x0f\xc9\x08\xfc\x39\xcb\x0c\x9f\x63\xf0\x85\x3a\x7a\x25\x0e\xd1\xf8\xbf\x37\x3e\x85\x62\xe6\x09\x95\x45\x7d\x9a\x24\x00\xe8\x9b\x4c\xf5\x53\xba\x3b\xab\x6d\x42\x9c\xab\x8a\x7a\xe2\x2b\x19\x51\x78\x36\x8c\x26\x29\x62\x1e\x66\x17\x67\x32\x14\x9b\x05\x88\xac\xbd\x09\x01\xae\x74\x10\x20\xbc\x9e\x10\xed\x7a\x30\x6f\xf2\x5c\x48\x52\x58\xe0\xaf\x4a\x00\xa8\x9c\xa1\xff\x02\x0e\x20\xe6\x3f\x92\x11\xa5\x1a\xae\xd4\x34\xe6\xaf\xcc\x3e\x6e\xc8\x20\xae\x96\xc8\x30\x0f\xef\xad\x0c\x19\x40\x41\x50\xcd\x13\x1d\xf7\x54\x2f\x3c\x8d\x8e\xb6\x3a\x5a\x37\x58\x84\x3a\x99\x36\x0f\xa6\x55\xe8\x85\xd0\x94\x06\xe7\x6c\x91\x39\x02\x2b\x15\xed\x20\xcb\x99\x5a\x83\x00\x22\x36\xca\x7b\x02\xe1\x16\xff\xf0\x54\xf2\xdb\x90\x2f\x03\x15\x99\x29\x85\x07\xa0\x0e\x34\x65\x7e\xaa\x91\xc4\x9f\xb2\x7a\x7d\xb1\x3c\x99\x2a\xe8\x79\x32\x55\x89\x85\x86\x55\xd6\x20\xc9\xf3\x64\x22\xe3\x12\x68\x90\x94\x6e\x96\x91\x10\xaa\x4b\x16\x5f\xc5\x85\x01\x57\xd5\x83\xd9\x90\x19\x87\xbc\xe4\x01\xcf\x83\x30\x30\x5f\xa6\xfb\x74\x6e\x2e\x68\x7a\x12\x06\xe2\x10\x8c\xe7\x25\x69\xa8\x7c\x02\x52\x91\x96\x91\xa4\xb7\x06\xea\x7d\x3c\x16\xa1\x2f\x9d\xdb\xe7\xa9\xff\x39\xf5\x03\xbe\xf6\xc9\x42\xe2\x53\x97\xd2\xf9\x85\xf2\xbb\xbb\x3a\x26\x25\xec\xc1\x97\x2b\xe8\xd9\x45\x34\x8c\x09\x12\x49\x36\x41\x5f\x9e\xb1\x87\xbf\x60\x69\x86\x51\x2a\x31\x5f\x7e\x1b\x2f\xc4\x89\xa8\x74\xc7\xd1\x68\xc0\xa6\x45\x81\x4d\x70\x44\x03\x7b\xd0\xa0\xf1\x68\x40\x0f\x1a\x0d\xd7\x80\x90\xfa\xf1\x59\xd5\xd9\x6a\xd5\x59\xec\xa2\x22\x2d\x66\x2c\x38\x9a\xfa\x43\x56\x3c\x00\xe5\xe2\x5e\xc9\x10\x3c\x60\xa2\x0b\x06\x63\x93\x29\x9a\x3e\x31\xd8\x9b\x23\x2d\xc8\x44\xdf\x5f\xbf\x42\xdb\xf5\xc0\x2e\x22\xbe\x24\x5f\xab\x1a\x14\x60\x17\xab\x9c\x96\x1e\xeb\xda\xc8\x2c\x6a\x90\xa9\x39\x11\x83\x3d\x85\x66\x9e\x4c\x35\x0a\x8a\xbd\x15\x0e\xc4\xe0\x05\xbc\xa9\x8e\x2a\xc3\x3f\x09\x4b\xe8\x15\xe0\x96\xcb\x14\x80\xac\xd4\xb0\xdd\xfb\x62\x1f\x89\x9b\xf8\x47\xe9\x65\xb5\xe4\xb1\x8a\x51\xc2\x1f\x27\x9d\x53\x8f\x92\x4e\xda\xa7\xa7\x56\x75\xba\xf4\xf3\xd3\x8c\x1d\xad\xfa\xa2\xb8\xa0\x6c\x9d\xdc\xff\x13\xf7\xfe\x06\x10\xbc\x17\xe2\xf8\x9a\x02\xdc\xf0\x59\x20\x5a\x32\xda\xa5\x03\x4a\x73\x16\xf9\x11\x66\xd0\xd8\x5b\x45\xad\x3c\xc1\xb7\xa6\xcb\x0c\xe1\xf1\xc1\x25\x62\x39\xf8\x7f\x71\x72\x70\xf3\xbe\xd1\x13\x65\xf4\xcd\xfb\x1a\xc1\xbe\x1f\x19\x7d\x94\xaf\x81\x25\x25\xa5\x8b\x8e\x9b\xb7\x73\x21\xaf\xda\x8e\x39\x88\x72\x23\x5e\x21\x54\x0d\x12\xf7\x8b\x4d\xa7\x5e\x81\x6c\x57\xae\xbb\xf2\xb4\x36\x25\x82\x25\x90\x79\xe1\x3c\x99\x36\xd0\x5b\xae\x90\x4c\x5f\xbf\x96\xcb\x10\x23\x63\x31\x2a\x25\x8f\xb7\xb8\x4c\x32\x04\x81\x4c\x5e\x08\x7f\x12\xd9\x89\x12\x87\xa7\xd0\x34\xf0\x78\x48\x1c\x4f\x53\xe6\x86\x72\x61\x69\x6f\x38\x16\xd7\x76\x07\x85\x52\x4d\x6f\x56\x41\xdb\x3a\xfd\x5e\x68\x12\xe4\xc9\xb4\x34\xff\x46\x61\xec\x47\xf2\x66\xb9\x3c\xca\xc8\x54\x9e\x71\xca\x57\x3f\xe4\x18\x0d\x6a\x8e\xd1\xa0\x16\x1e\x4d\x8a\x1e\x58\x53\x4b\x6c\x8b\xab\x98\x01\xf6\x6c\x11\xdd\x33\x7a\x52\x0c\x71\x54\x45\x7e\x5d\x5f\x88\xb9\x9e\x39\x82\xd4\x69\x31\x57\xf0\xf2\x93\x32\xc3\x80\x71\x2a\x2f\xe7\xce\x12\xc5\x37\x77\xc1\xd1\x34\xdf\x83\x66\x07\x7a\xd0\x71\xe1\xa1\x26\x66\x1d\xe7\xe8\x76\x6f\x09\xdf\x18\x62\xdb\xab\x83\x35\x86\x52\x1f\x2a\xee\xb5\x78\x5e\x18\x78\x1a\x9e\xb0\xf6\xf0\xe0\x0b\x9a\x79\x97\x8f\x10\x6e\xe7\xf5\xbd\x74\x6c\x20\x44\x13\xfc\xbe\xff\x11\x0e\xdf\xfd\xf7\xc1\xab\xe3\xc3\xf7\xef\xe0\xe1\x96\x86\x3d\x4d\x93\x21\x43\xe3\x2c\xb9\xb7\x52\xe1\xf0\x9d\xa1\x0b\xdd\x76\x67\xbb\x39\x25\xcb\x00\x0f\x7e\xf1\x87\x6c\x90\x24\xe7\x1e\x1c\xc6\x43\xe9\xcb\x19\x43\x14\x8b\xcd\xf0\x30\x09\xd0\xef\xbb\x08\x25\x1e\x18\x81\xea\xdf\x1e\x1e\xcb\x64\x18\xe1\xe5\x26\x6d\x77\x38\x88\x37\x87\xaf\x0e\xde\x1d\x1d\x88\xd8\xfa\xb4\x0b\x4a\x93\x24\x87\x20\x4c\xd9\x30\x4f\x52\x11\x0c\x5d\x37\x94\xa7\xe4\xca\x59\x3a\xd4\xc3\xe0\x17\x93\x69\xbe\x10\xef\x92\x29\x0c\xf1\x86\x30\xdc\xe4\x3d\x6c\xb1\xf8\xa2\xf5\xee\xfd\xeb\x83\xfe\xc1\xbb\xdf\xd1\xaa\xac\x31\x4d\x93\x60\x66\x3a\x4d\x16\x5b\x83\x51\xca\xd8\x9f\xcc\x31\xe0\xd5\xb8\x19\x36\x4a\x2c\x25\xf7\x15\xed\xeb\x97\x8d\x9f\xb3\xed\xba\x6e\x89\x1d\x6e\xe7\x74\xfc\x9b\xb0\xc3\xa3\xff\x55\xec\x70\x4d\x04\x84\x47\xcf\x0d\x1f\xe6\x47\xe1\x24\x8c\x7c\x11\x98\x1b\x1d\x7b\xc7\x39\x0c\x66\x39\x24\x71\xb4\xc0\x98\xe0\xe0\xc3\xa5\x9f\xc6\x18\x81\x9b\xa2\xdf\x0f\x93\x38\x08\x85\xbb\x7a\xb4\x2a\x9c\xb0\xbc\xa5\xc8\x30\xf4\x63\x18\x30\xc0\xe7\x7a\x79\xc2\x41\x40\x98\x65\x33\x96\x91\xd1\xf3\x05\x8b\x92\x29\xfa\xd7\x61\xf1\x45\x98\x26\x31\x9e\x22\xf1\xbc\x61\x1a\xe2\x45\x3e\x87\x34\xf5\xf3\x71\xd6\x82\x8f\x6c\x92\x5c\xc8\x80\xe3\x51\x72\x76\xc6\x7f\x23\x81\x47\x09\x1a\x01\x09\x56\xb6\x61\x5d\x86\x51\x04\xe7\x8c\x4d\x25\x6d\x33\xbe\xdb\x8f\x92\xb3\x70\x88\x11\x12\x46\x49\x14\x25\x97\x74\xec\xc0\x73\x10\x20\xb5\x48\xb4\xc4\xdd\xb8\xe8\xf3\xae\x4d\xd3\x9b\xcf\x2f\x32\x57\x0a\xe3\xfc\x0f\x05\x51\x6d\x2a\xcd\x74\x87\x8e\x10\xa4\xec\x56\x47\x6a\xfd\x08\x03\x4c\x16\x8f\xe5\xd0\x9c\x8e\xcf\x47\x32\xe5\xc0\x52\x14\xa0\x06\x7f\x36\x81\x0b\x76\xae\xae\xf7\xcf\x71\x3f\xd6\xd9\xa1\x5f\x3f\x63\x3e\x7d\xe0\xb9\x9e\x58\x29\x38\xb4\x13\x2c\xd1\x04\xf4\x02\xa4\x4f\xf8\xfa\x78\xec\x56\x5c\xdc\xfd\xf4\xec\x30\x0e\xd8\x1c\x0d\xed\x55\xea\x84\x65\x99\x8f\x1a\x7a\x43\xf4\xab\x87\x51\xfd\xa8\x73\xad\x94\x4d\x23\x7f\xc8\x9c\xad\xff\xca\xb6\xce\xbc\x8a\x88\xea\xfa\xd1\x1e\xc7\x47\xb6\xb1\xb9\x79\xba\x53\x5a\x67\xa5\xc1\x6e\x12\x67\x49\xc4\x88\xfa\x6a\xab\x6b\xac\xb1\xa2\x00\xd9\x2a\x39\x02\x41\xd7\x0c\x06\x9f\xa7\x0b\x55\x7a\x6b\x0b\x9a\xcd\x26\xfc\xc1\xa2\x61\x32\x41\x17\xf7\x01\x1b\xcc\x88\xf3\xd0\x88\x8c\x67\xeb\xb2\xc8\xf2\x64\xf5\x79\xe9\x67\x64\xac\x1b\x93\x95\x34\x3a\xee\x8f\x43\x16\x0f\x19\x64\x09\x46\xf3\x80\x45\x32\xc3\x09\xc2\x85\x14\xcd\xe5\xdc\x1f\x9e\x6b\x70\x79\xc2\xd7\xcd\x80\xa6\x99\x1f\x45\x59\x88\xe7\x7d\x7e\x0e\x43\x9f\x66\x14\xc5\xc6\x27\x4e\xc2\xd2\xa9\x08\x9c\x0f\x86\xa5\xf0\x41\x55\x57\x61\xe8\xe7\xc3\x31\xe0\x3b\xac\x2b\x75\xe4\x71\x59\xe6\x4a\x91\xe4\xa8\x79\xee\x81\xcd\x9b\x9c\xfa\x23\xe1\xf3\xce\x3c\x5f\xd0\x34\x2f\xa2\xd2\xf8\x54\x0b\xd4\x83\x56\xab\xc5\x47\xdb\xfd\x04\x42\x48\x99\x32\x87\x33\x4f\x43\x72\x95\xe4\xc9\x46\xd9\x09\x97\x60\x30\x69\xa4\xdf\xf8\xc5\x0f\x23\x16\x00\x5e\x87\x22\x15\xe5\x1d\x68\x0f\x1a\xf4\x56\xb1\x5d\xe4\xb9\x1d\x3e\x02\x87\x67\x71\x92\x32\x5d\x4f\xdd\xa7\x22\x00\x3c\x78\x94\x01\x4d\x6c\x04\xee\xa9\x9e\x69\xb8\xd6\x24\xee\xae\x36\x8b\xbb\xf0\x02\xba\x62\x1a\x77\xa1\x09\x5d\x63\x1e\x73\x10\xdd\x1d\xf1\x93\x66\xb2\xfc\x34\xe7\xb2\x31\x9b\x11\x42\x79\x3a\x77\x95\xad\x96\xb2\xd2\x30\x65\x91\x30\xdb\x55\x03\xeb\xc1\x09\xd1\xf7\xb4\x35\x4c\xe2\xa1\x9f\x3b\x38\x60\xe6\xb5\x75\xb5\xb2\x20\x46\xf1\xdb\x28\x0a\x4b\x23\x1a\xdc\x58\x51\xf8\xdf\xa9\x08\xc2\xdf\x38\x4b\x22\x47\xe2\xb9\x37\x2d\x60\x5b\x0f\x59\x16\x85\x71\xde\x0c\xc2\x0c\x1f\x13\xc5\x49\x33\x63\xd1\xa8\x39\x4c\x26\x53\x3f\x65\x86\xc6\x60\xdf\xc5\xe8\xa3\xe2\xba\xdb\x1a\xad\x3a\x84\x71\x84\x87\x8a\xa2\x42\x98\xc1\x34\x89\x16\x23\xbe\xf8\xaa\xc0\x20\x44\x72\x5a\xb5\xe3\x6c\x36\x61\x69\x06\xd9\x38\xc4\x95\x39\x4c\x21\xb9\x8c\x39\x24\x19\x1e\x44\x68\x07\x2c\x6d\x4d\x92\x3f\xc3\x28\xf2\x31\x48\x08\x8b\x9b\xbf\x1d\x6d\x05\xc9\x30\xdb\xfa\x83\x0d\xb6\xfe\xdb\xbf\xf0\x8f\xf0\x8d\xd3\x96\x7a\x2d\xb2\xf5\x6b\x94\x0c\xfc\xa8\x4f\xa8\x64\x5b\xf4\x77\x2b\xcc\x8a\xd1\x75\x9c\xb9\x7a\x1c\xbe\xb5\x05\x47\xfe\x84\xfd\x8e\xf6\xb0\x7e\x74\x96\xa4\x61\x3e\x9e\x88\xf8\x1f\xe4\x63\x77\x21\xa7\x14\x2f\x8b\xa7\xe4\x9d\xe6\x63\x0f\x9e\x36\x3b\x6d\x3b\xf9\x49\x6b\xd0\x7c\xd2\x62\x3d\xd8\x6c\xc3\xbd\x5d\x68\xaa\xec\xfd\x20\x60\x24\xcd\xe3\x24\xfe\x93\xa5\x09\x2c\x48\x7c\x70\x12\x4d\xfc\x73\x06\xbf\x70\x55\x64\xec\x4f\xa7\x0b\x0f\xf5\xae\x30\xe7\x2c\x94\xb2\x60\x16\x07\x7e\x9c\x9b\xdb\xaf\x39\xae\x71\xf8\x34\x7c\xa1\x7f\x76\x60\x4b\xb8\x04\xc6\x77\xeb\xb8\xd7\x32\x0f\xda\x04\x92\xf0\xa4\xe5\xf7\xd0\x5d\xf0\xee\x2e\xff\x53\x06\x3c\xe7\xdb\x55\x02\x2c\x62\xa1\xe8\x77\x0f\x1f\x58\xca\x05\x40\x46\x01\xa5\xc2\x7c\x01\x83\x85\x08\x2f\x43\xea\x59\x9a\xcc\xce\xc6\xf8\xb2\x0a\x30\xa4\x15\x90\x75\x02\xea\x5b\xd4\x0a\x2f\x27\x23\x1e\xc1\xe5\x98\xf1\x52\x0b\xbc\x30\x1c\xfb\x19\xdd\x7f\x65\x70\x39\x0e\x87\x63\xe0\x1c\xca\xf5\x4a\x9a\x9d\xd1\x42\x84\xb1\x1a\xb0\xfc\x92\x31\x9a\x20\x5a\x90\x72\x70\x2a\xe8\x4d\x3a\x63\x04\x3b\x97\x21\x74\x32\xbc\x27\x42\x85\x70\x91\x21\x64\x1b\x6a\x21\x36\x4e\x36\xf6\xb9\x72\x78\xc0\xb3\x9c\x64\xf0\x79\xdf\xe3\x3d\x79\xa9\x03\xd9\x85\x99\x99\x5c\x78\xd2\x8c\x2f\xf6\xe4\xd3\x06\x43\x47\xe1\x35\x48\x41\x11\x71\x64\xf0\x68\x86\x27\x2a\x57\xce\xfa\x05\x12\x07\x5c\x55\xf8\xa5\x2a\x5c\x68\x95\xde\x1f\xca\x66\xc5\x35\x6c\xb6\x5f\xb8\xf6\xe1\xcd\xa9\x3b\x1f\x9e\xf2\xb2\x5c\xe0\x25\x9d\xab\xc9\x27\x6f\xfb\xd2\x8d\x2b\xc7\x06\xab\xa8\x10\x53\x4b\x10\xe0\x5a\x11\xcb\x72\x5c\xfc\xf6\x1b\x19\x11\x3e\x08\x47\x38\x57\x73\x18\xa5\xc9\x04\x5e\xb6\x8a\xd1\xfe\xc4\x63\x4d\xb3\x59\x79\xf3\xac\x97\xd8\x9a\x17\x75\x2f\xe9\x4d\xdf\xfe\x49\x78\xea\x72\x62\xdd\x13\x83\x74\x22\x53\x4f\x69\xb8\xf4\xb7\x5b\xd2\x37\x55\x1f\x64\xb4\xbe\x8d\xc2\xa8\x56\x2d\x6f\x26\xb7\x94\xcf\x35\x96\x3a\x14\xbf\x76\x7d\xda\xda\x82\xa7\xad\x4e\xab\xf3\x18\x8e\x13\x8a\xf2\x45\x11\x2b\x93\x43\x11\x0c\xae\x2e\xbe\x5d\xdb\xad\x0e\xab\x59\xc2\x5e\x6b\xdf\x61\x6e\xbd\xe3\x0f\x73\x78\x01\x6d\xd8\xe3\x20\x1c\xd5\x20\x2f\xe5\x41\x7b\xde\x19\x99\xff\x5c\xae\x9e\xa0\xe6\x34\x4d\x2e\x9d\xae\x07\x8f\xb7\x5d\xdc\x7d\xec\xee\xc2\xf3\x76\xfb\x69\xe7\xf9\xf3\xee\xe3\x47\x4f\x1f\xb5\x9f\x3f\xef\xe0\xe1\x4f\x91\x4a\x4b\x5d\x94\x0b\x64\x75\x78\xbf\x80\xb6\x1b\xb8\xa9\x52\x91\x44\x53\x3f\x0e\x92\x89\xe3\x2e\xed\xe3\x39\xb3\xfd\x56\x34\x8e\x16\x93\x41\x12\x39\x0d\xa9\xd2\xe0\x3e\xa9\x70\x5d\xd6\x68\x40\x8f\x6e\xff\x1b\x6e\xbf\xe1\x81\xb3\xb9\x89\x56\xbb\xd3\xb9\xdb\xca\x13\xba\x5b\x76\xb6\x9f\xb8\xe2\x60\xab\xd8\xb7\xa5\x9e\x33\xcd\xbe\x89\xdf\xad\x11\x1e\xe2\xb4\x64\xbc\xa7\xc3\xec\x40\x19\x19\x54\x80\x5f\xea\xce\xe6\x86\x0a\x90\xc6\xa1\xdf\x67\xd9\x5b\x04\x22\xdf\x20\x8b\xd7\xb6\x24\xef\x93\x3a\xce\x7b\xd4\xdd\x76\x8b\x45\xb9\xc2\x4a\xce\x51\x93\xa9\xb0\xbd\x7b\x2d\x82\xf1\xab\x32\xaa\x52\x86\x03\x52\x07\x9d\x42\xaf\x19\x05\x97\xc1\xa6\x12\xaa\x82\x90\xac\xbb\x52\xc4\x4a\x08\x2d\xe5\x8f\xa0\xf4\x1a\x53\x96\x54\x3d\xb1\xcb\x12\x80\xfb\xb0\x67\x70\x98\xb0\x23\x91\x52\x43\x49\xf3\x1d\xb8\x32\x9c\xa1\x14\xcb\x25\x83\xcf\x66\x7b\xd7\x63\x96\x0c\x3e\xb7\x8c\x47\x96\x58\xa2\x54\x8d\xca\xa1\xe0\x2e\xe6\x19\x2f\x3c\xf7\x74\x47\x7a\x36\xc2\x3b\xf6\x13\xd7\x2a\x22\x57\x76\x83\x23\x67\x30\xd0\x1e\xa6\xf7\xe0\x8b\x34\x38\xeb\x61\xc2\x15\xda\xb6\x48\x86\xd3\x4e\x21\x56\x27\x82\x18\x52\xa7\x3c\x3e\xee\x75\x03\x64\x08\x76\xd5\x63\xaa\xa3\x66\x3e\xaf\x66\x7e\xf5\x54\x7b\x1c\xc4\xce\x46\xd5\x78\x1a\xd1\x4d\xff\x7a\x23\x7a\xd3\xfe\x95\x17\xb3\xa5\x3e\x68\x56\x59\xcc\x3a\xcf\x5b\x9d\x56\xb7\xd5\x85\x2d\xe8\x3c\x6e\x75\x5b\xdb\xad\xc7\x85\xf7\xc5\xef\xe1\xc4\x03\xfd\xa4\xf0\xd4\xa5\xe8\xd2\xb1\x3a\xde\xae\x92\x0b\x6a\xb9\x0b\x3e\xd4\x45\x98\x7c\xd4\x7d\x2a\xca\xb0\x78\x36\x79\x39\x3b\xfb\x07\xd7\x48\xea\x96\x4f\xe9\x95\xe3\xf0\xa0\xff\xe1\xe3\xfb\xe3\xf7\xb5\x05\x3b\xae\xd3\x90\x85\x1a\xa2\xd2\xc1\x64\x9a\x2f\x4a\x0e\x2c\xb6\x1e\xd2\x21\x22\x70\x82\x52\x41\xac\x75\xfc\xcf\x0f\x07\x40\x67\x86\x34\x7c\x8d\x1d\x24\xd5\x2b\xa4\x87\x54\xa1\x2f\xc3\x7c\x0c\x23\xbe\x57\xf8\xc4\x95\xbf\x4f\xa0\x8a\xf7\xf0\x1c\x29\x1c\xa5\xfe\x84\x09\x5a\x52\xe9\x61\xc4\xfc\x94\x05\xba\x24\xc5\xe3\x46\xb0\xaf\xc3\x61\x5e\xc4\x50\x68\x6d\xe3\xd4\xcf\xc6\x1e\x5c\xfa\x59\xce\x50\x73\xcf\x92\x20\x99\x2c\x7a\x70\x78\x00\xbf\xbe\x82\xc1\xec\x4c\x1a\x15\x51\x93\x35\xd6\x88\xdb\xcf\x5c\xa7\x41\x45\x1a\x4a\xe3\xe4\x3a\x9e\x41\x7e\xa9\xe2\x89\x5c\x9c\xfd\x8d\x9f\x1b\xf2\xfb\x0c\xbf\x5f\xa8\x6f\x82\xf6\x5a\xc4\x69\xdd\x41\x1d\x95\xa7\xb4\xb2\x7c\x11\x31\x19\x9e\x86\xd7\x89\x93\x98\x61\xb5\x6a\x4e\x78\x86\x4f\x92\x59\x1c\xbc\x1a\x87\x51\xe0\x10\x14\xd7\x04\x98\x0e\x39\x98\xcf\xfe\x85\x4f\x9e\x34\x7a\x0d\xd4\x6e\xec\x0d\x75\x93\x6f\x7d\x71\x57\x8d\x65\x9a\xb3\x34\x22\x1a\x5a\x34\x16\x20\x87\x49\x9c\xb3\x38\xff\x23\x8c\x83\xe4\xb2\x25\xaf\x4e\xb0\xf8\x38\x9f\x44\xad\x94\x4d\x92\x0b\x56\x83\x90\xec\x73\x1d\xb8\xa0\x44\x13\x59\xa3\x95\x4c\x99\x88\x97\x51\xc8\xb8\x4c\xc3\x9c\x39\x51\x0e\x9b\xd0\xa0\x0e\x34\x60\x93\xd3\x7c\x13\x1a\x2a\x16\xee\x2f\xbb\xef\xc5\xf6\x63\x13\xa8\xe8\x96\x59\xb6\x0a\xee\x30\x4a\x32\x46\x2d\x56\xd0\x41\x15\xfb\xc5\x08\x13\x1d\x36\x9b\x2e\x04\x2c\x62\x39\x33\xea\x9c\xa8\xe9\x71\x7a\x62\x30\x8d\x0c\xd9\x2d\xdd\x3a\xa8\xf2\x8e\x90\x59\x25\xf5\xcf\x12\x30\x96\x15\xac\x94\x39\xa6\xc4\xd1\x07\xf6\x74\xb9\xb9\x23\xf6\x42\xef\x4d\x87\x0c\xb8\x45\xc0\x79\x6e\x60\x09\xbb\x4a\x4e\x39\xef\x55\x88\x92\x8c\x56\x35\x3c\x06\xe5\x15\x64\xf0\x92\x8a\xda\xfa\x4d\xec\xd6\x16\xf8\x41\x00\xf7\xd5\x3b\xfb\xfb\xb8\x51\xaa\x7c\x69\xaf\x4e\x5c\x8c\x06\x4f\xa4\x4c\xe2\x60\xdf\x1b\xc7\x01\x0a\x1f\x9b\x6e\x8a\x9c\x9a\x0e\x25\x35\x58\x54\xed\x71\x21\xab\x0c\xe1\x0c\xba\x55\x6b\xbf\x4b\x9d\x77\xad\x14\x3d\x38\x60\xa3\x3a\x8f\x82\x5d\xb7\x35\x92\x81\xfd\xeb\x84\xf9\x13\x69\x17\x7d\xbc\xff\x6b\x1d\x9c\xb6\xeb\x34\xa4\x26\x7f\xec\x9f\xa1\x35\xda\xd2\x9d\x92\x07\xb9\x7f\x46\xae\x6a\x8c\x53\x01\x5c\x9f\xf9\xfe\x94\xff\xc4\x88\x24\x39\xec\xf1\x8d\x54\x0f\xc2\xdc\x74\x90\x71\xbc\xff\xab\x8b\x6e\x70\x10\xd4\xf1\xfe\xaf\xc2\x67\x46\xc9\x70\x58\x18\x1b\xe7\xfe\x19\x5c\x55\x13\xb8\xbb\xd4\xf6\x7e\x25\x02\x0f\xf3\x79\x0d\x61\x1e\x3f\x17\xb4\x23\x87\x28\xd5\x92\xfe\x71\x47\x14\x12\x2f\x8a\x0f\xf3\xda\x7d\x69\xf7\xb1\x1c\x8c\x55\x17\xf4\x3c\x59\x1a\xa0\xbd\xd3\x79\x24\x0a\x9e\xb1\x9c\x37\xfc\x4b\xdd\x85\x67\xf7\xb1\x5c\xd3\x5f\x7e\x3c\xd8\xff\x87\xb8\x27\xe7\xdf\x1f\x0f\x8e\x7f\xfb\xf8\xce\x48\xd0\x43\xbe\x94\x07\x68\x47\xe6\x01\x8b\xf3\x34\x64\x99\x07\xa3\xd8\xc3\x6b\x1a\x0f\x0e\x8f\x0f\x3e\xee\x1f\xbf\xff\xa8\x65\x49\x28\x71\x93\x59\x96\x4e\x6a\xa8\xd0\x12\x2e\xed\x17\x54\xaf\x54\x7b\x6a\x2d\xe5\x93\x62\x98\xcf\x1d\xdd\xaa\x40\x04\xf6\xf0\xba\xa0\xa3\x57\x5d\xf3\x86\x0e\x17\x5a\x71\xed\x90\xe5\x6c\xea\x81\x54\x9e\xbd\x82\xc0\x13\x8a\xa3\xc0\xfc\x9e\x1d\x69\x99\xee\x76\xb4\x33\x1a\x89\x1e\x5f\x22\xe4\x8d\xb0\x4c\xbb\x47\x0a\xc0\xd6\x16\x8c\xfc\x2c\x87\xa1\x9f\xd1\xd5\x2d\x3e\xa1\xca\x48\x59\x91\x0a\xae\x44\x46\x1d\xb4\x29\x96\x72\x08\x11\xd7\xa5\x23\xa3\x48\xb2\x85\xe4\x10\x85\x82\x3c\x9e\xda\x11\xfd\x84\x17\x44\x81\x1d\xfa\xa3\x4f\x93\x94\x2c\xd4\x84\x1b\x39\x4a\x82\xcb\x38\x41\x02\xea\x09\x56\x3e\x75\x31\x56\x14\xcf\x3b\xe9\x9c\xba\x7c\x07\xe0\x14\x4b\xec\x18\x96\x8b\x99\xd4\xf5\x89\xe9\xbe\x7e\x05\x23\x8d\x18\xcf\x95\x23\xaf\xa9\x2f\x64\x35\xf6\xd3\xd8\x6f\x13\x01\xe8\xc0\x4b\xb3\x03\xdc\xb3\x50\xcd\x93\xb4\x15\xb3\x79\xee\xb8\x6e\x2b\x48\x62\xb6\x53\xea\xad\xae\x8f\x83\x3e\xa2\xee\xb4\xd4\x83\x06\xa4\xc5\x5d\xf4\x82\x8b\x2b\xb9\xbd\x93\x93\x0e\xff\xea\x64\x35\xf7\xe8\x47\x85\x78\xbb\x4b\xbb\xa0\x8d\x8d\xea\xe7\x1d\x0a\xcc\x7d\xbd\x6b\xbd\xef\x89\xb9\x4b\x02\x38\x9d\x31\x74\x4e\x29\x8a\x9e\x34\x04\xc3\x36\x4e\xd5\x5a\xfa\x71\x16\xa9\x53\x12\x7d\xa1\x5a\x1d\x66\xc1\x2d\x14\x5c\x76\x8c\x21\x8a\xa8\x2a\x47\x5c\xdb\xfd\x48\x27\x33\x95\xb2\x73\xbb\x5c\x74\x19\x7c\x55\xc8\xf0\xa8\x96\xc4\x0c\x93\x6b\x03\xe3\x3d\xae\x28\xbc\xac\x11\x5d\xca\xbd\xf3\x53\x05\x35\x16\xe6\xb9\x82\xbc\xcb\x23\xa5\xcf\x87\x74\x16\x69\xe7\x67\x85\xf3\x7e\x3d\x7e\x46\x0c\xa2\x98\x36\x37\xc5\xcb\x5a\x3c\x14\x7d\xf0\xc0\xb8\x4a\x6d\x9f\xa2\x66\x68\xaa\x4a\x56\x66\x0f\x1a\xb3\x98\x43\x0b\xd4\x4e\x26\x60\xc3\xc8\xba\x8e\x25\xb7\x19\x68\x3e\x3f\xe5\x28\x65\x56\x6e\x57\xe5\x7e\x46\x6f\x51\xa2\x4c\xeb\x73\x96\xa9\x27\x1e\x1c\xe4\x2b\x0a\x25\xe4\xb4\x3d\x6b\x58\x0c\x66\x75\x1d\x5e\xce\x55\xb5\x52\x62\xa3\xcf\x59\xd6\x9a\x46\xb3\xb3\x30\xce\x5a\x49\xfc\x4a\x93\x83\xa3\xed\x29\xd8\x9e\x6c\xd9\x95\x6b\x04\xaf\xaf\xa7\x3e\x4d\x00\x94\xf4\x87\x78\x83\xe5\xc7\xe0\xe7\x4d\x6c\x84\xef\x24\xc3\x1c\xf5\xb4\x38\x31\x07\x02\xe1\xf0\x76\x38\xad\xd0\x3e\xf2\x6f\xca\x6e\x03\x7b\x22\xa7\x88\xd5\x0d\xe1\x34\xac\x71\xf2\xdf\x47\x47\xa7\xf0\x5b\x7c\x1e\xa3\xc9\x85\x68\xec\xbf\xb2\x86\x87\x03\xa8\x7d\x4c\x49\xb7\x33\xec\xd2\x9c\x16\x06\xcc\x25\x7d\xbd\x2a\x49\xa5\xbb\x34\x4f\xbb\x03\xa9\xf4\xe3\xdd\xdf\x0f\x0f\xa2\x3f\x3c\x88\xae\xed\x41\x34\x0a\xe3\xf3\x25\x0b\x6a\x17\xb7\x90\x76\xd1\x65\x6b\x9d\x2c\xa3\x2a\xf1\x8f\x37\x61\x56\xb7\xd9\x79\xde\x29\x95\x5c\x06\x5e\x96\xf9\x4e\x0b\xe9\x5f\xd8\xe3\x28\x27\x19\xca\xf2\xa3\x31\x63\x55\xe7\x99\xea\x5b\x97\x72\xf0\xb0\x30\xd3\xe2\x7d\xa9\xa7\x44\x5d\x4f\x3e\x36\x41\x17\x1e\x7e\x9e\xfb\xc3\x31\x3e\x83\x33\xae\x8c\x31\x2b\x60\xd3\x28\x59\x54\x66\x71\xbe\xa8\xcc\xc0\xa6\xc9\x2f\xc7\x95\x91\xac\x55\x01\xcb\xe6\x5e\x24\xeb\x37\x13\x19\xc7\xaf\x87\x75\xe4\x4b\x86\xa9\x9f\xb2\xb8\x90\x26\x5a\xe9\x59\x6d\x5a\x06\x95\x86\x7b\x12\xdc\xc2\xf3\x81\x91\xba\xc6\x47\x91\x8c\x84\xb1\xca\xcf\x22\x44\x1d\x57\x56\xc5\xbf\xe6\xc2\x6a\x76\x46\x92\x51\x49\x58\x54\xb3\xf8\xaa\x81\xc3\x62\x1a\x0f\x4a\xd8\x2d\x3f\x08\xc4\xe2\x4c\x85\x4e\xf8\xc7\xa9\x6d\xfd\x67\x14\x17\x66\xb9\x8e\x5e\xfb\x51\x17\x04\x78\x08\xfb\x38\x6e\xc2\xb7\x0c\x8a\xc7\x3c\x21\x53\x2b\x72\xe2\x29\x6c\xaa\x80\x4c\xa3\x0a\x8e\x29\x35\x2f\x14\x5c\x53\x12\x37\xd4\xf8\xb1\xa1\x4c\xc3\xb4\x15\xb7\xd6\x26\x13\x29\xfd\x89\xa7\xee\x18\xa5\xee\x59\x0c\xe5\x9a\xfc\xe5\x28\xff\x3a\xd6\x98\xb5\x64\x6b\x65\x30\x82\xf9\x1e\x3c\xb0\x78\x0b\x93\x5d\xcd\x9e\x05\xb8\x06\x9f\x4b\xab\x16\xd3\xd0\x45\xe1\x2b\x06\x41\xd0\x19\xd0\x18\x67\x92\x5c\x30\x93\xd2\x68\xf2\x51\xa4\x33\x51\xba\xe4\x19\x28\x60\x4b\x28\x4a\x99\x05\x8a\xde\xbb\x9e\xa4\x36\xa5\x24\x94\xba\xfe\x1a\x73\x74\xa5\x0e\xef\x07\x81\xdc\x65\x08\x9e\x1a\xce\x52\xb4\x75\x21\xa6\xe5\x7c\x23\xbb\x0c\x7f\x84\x51\xc4\xe5\x22\x4b\x73\x59\xc9\x8f\xb2\x04\xfc\x51\x2e\x6c\x05\x75\x25\x54\x99\xd1\xa9\xb1\xc0\x3d\x80\x51\x98\x66\x39\xe4\xe1\x64\x29\x11\xfd\x20\xe0\xd3\xb1\x8e\x2f\x29\xd7\xd0\x7a\x4b\x22\x91\xb6\x08\xff\x9a\x31\xf4\x15\x89\x04\xc2\x0f\xe5\x4e\x70\x6b\x0b\x3e\xd0\xae\x01\xed\x99\xc5\x01\x3b\xcd\x42\x5d\xe4\x30\x86\x24\xc5\x51\x4f\x00\xed\x28\xd3\x0b\x72\x5f\x40\x36\x96\x98\xe7\xc1\x25\xc3\x67\x66\xbc\x10\xb5\xc8\xc5\xff\xa7\x96\x40\xf3\x13\x19\x42\x7b\x1a\x2a\x19\x89\x8d\xf1\x1e\xc7\xa0\x1b\x91\xe6\x93\x16\x1c\x2e\x55\x6d\x6d\xd4\x4d\x3f\x3c\xb3\xc5\x26\x5d\xa3\x8f\xb0\x0b\x27\xa7\x96\xb7\x51\xb1\x55\xaa\x94\x4b\x36\xf9\x2c\x96\x32\xf6\x6a\xc6\x16\xeb\x03\xc9\x28\x1c\x81\x54\xa8\x0a\xb5\xe2\x41\x5b\xf4\x56\x49\x05\x6b\xf3\x25\x0b\x6e\x6d\xc1\xeb\x24\x6e\xe4\x92\xc9\x10\x79\x32\x25\x8d\x16\xe2\x09\x47\xca\xe8\xa0\x0e\xc8\xd5\x4e\x38\x0a\x59\x00\x17\x2c\x45\x57\xd2\x0b\xc5\xad\x20\xf7\x73\xf8\xa2\x62\xc0\x04\x48\x16\xe0\x08\xe5\xc9\x19\x43\x7f\xd3\x68\x70\x27\x90\x06\x7c\x01\x12\x45\x2c\x68\x59\xa8\x0b\x2a\xe3\x9f\xd6\x74\x96\x8d\x45\xdf\x4b\x6e\x22\xb1\x8b\xd4\x8e\x49\x22\x5d\x40\x51\x49\x80\x34\x2b\x83\x31\x8c\xad\x51\x92\x1e\xf0\x79\x5e\x80\xe8\x81\xb1\x8c\x95\xab\x81\xb1\x9d\x37\xcb\x5c\x6d\x94\x7f\x55\xd0\xff\xca\x98\x20\x7f\x30\x3e\x37\x1a\x39\xde\xe7\xd0\x5a\x99\x27\xe0\x0b\x29\xc6\x02\x9a\xe9\x10\x27\x01\x6b\x59\xb5\x90\xdc\x29\xa3\x81\x26\x99\x80\xe2\x20\xe1\x3a\xd5\x2c\xe3\x24\xe7\x25\x24\xc5\xf3\x96\xc9\x75\x65\x2d\x64\xa3\x06\xdb\xb2\x24\x3b\x34\x58\x26\x8c\x85\x30\xd3\x8b\xdf\x12\x89\xa3\xe9\x5b\x23\x74\x8a\x43\x6a\x09\x1a\x63\xad\xd8\x2d\x08\xeb\x3a\x56\xa0\xe3\x49\x55\xad\x7a\x71\xc3\x43\x04\xa5\xb7\x5b\xa7\x08\x29\xb2\x82\x86\xe0\xd6\xd1\x44\x1e\x23\xc5\x81\x1e\x47\x5b\x9a\x8b\x95\xcd\x10\xe3\x74\x80\x46\xaa\xe9\xa5\x9f\x69\xf1\xad\xe5\xd4\x8a\x22\xbc\xce\xdb\xb5\xcc\xae\xd3\x69\xc5\x1b\x1d\x34\x3f\x26\x79\x46\xa9\xd7\x2a\x5f\x40\x95\x68\x8e\x92\x34\xb2\x96\x0b\x53\x0f\xd3\xad\x6a\x9f\x7f\x36\xb3\x21\xac\x3a\xca\xfe\xca\xd4\x12\x38\x58\x20\x42\xcb\x08\x72\xc6\x96\xb1\x97\xc8\x45\x24\x4b\xb6\x9d\x86\xe0\x3e\x63\xb9\xa3\x4e\x87\xaa\x90\x7a\x4d\x77\xd1\xd5\x78\x29\x43\xe3\x4f\x5c\x27\xfa\xd4\xe3\x5c\x88\xe5\xd4\x42\x4d\x57\xd9\x01\xa9\x3c\x7c\xb4\x5f\xbf\x7f\xbb\x5c\xdd\xe1\xe5\x97\x74\x4c\x17\x28\xf4\xad\x7a\x61\x32\xfa\x67\xaa\x48\xd6\x61\x9d\x2d\x16\x8c\xca\x64\x88\x70\xdd\xaa\xc4\xe7\x1a\x2f\xd2\x32\x26\x8f\xc1\x3e\x16\xcd\xb5\xca\xa5\x7a\x51\xac\x5a\x92\x9c\x05\x5b\xea\x3a\xce\xa1\xab\xad\x64\x24\x86\x6a\x19\x91\xc5\xa3\xa0\x5a\xc9\x44\x4f\x86\x6c\xb1\x54\x66\x1d\xab\x5c\x3d\xfb\xa0\xcc\x9e\xce\x52\x06\xaf\x8e\x8e\xc4\x02\x4b\x72\x5f\x77\x7a\x39\x47\x70\x08\xb5\xdc\x40\x5b\x80\xc2\x5e\x49\x93\xb9\x62\x87\x60\x2c\x08\x37\xd4\xe4\xdf\x84\xf1\xb9\x29\x9b\x79\x87\x68\x1d\x43\xf6\xa6\x45\x09\xef\xf0\xe8\x39\xc7\x30\x49\x53\x96\x4d\x13\x74\xd3\x06\x93\x24\x60\x51\xb6\xac\xab\x5c\x32\xd7\x74\x94\x76\x24\x16\xb3\x0f\x49\x69\xca\x4a\x4b\x84\x98\xfb\xb8\xed\x33\x74\xcf\xcc\x38\x97\x47\x15\xe5\xf7\x30\xcd\x67\x7e\x24\xb7\xb3\x5c\x55\x99\x65\x5a\x51\xe1\x8c\x2e\xdb\x70\xcd\x81\x47\x5c\x54\x8e\x45\x5b\xb5\xaf\xbf\x21\x65\x7f\x9b\x06\xd2\x93\x97\xea\xb2\x7c\x02\xc1\xe9\xe9\xe3\x9e\x1a\x5d\xcd\x2f\xa1\xdf\x0c\xa1\xd4\x50\x90\x32\xa5\x96\xea\xe7\x7e\xe5\x06\xbb\x5c\xea\x06\xbd\x78\x95\xc4\x17\x52\x5f\x10\xba\x8d\xe6\xf9\x65\x88\x4b\x83\x8b\x1a\xd4\x95\x65\x75\x69\x51\x2b\xcf\xca\x52\xd9\x5a\x57\xaa\x5a\x8f\xd9\xd9\xa0\x13\xc0\xca\x1b\x3d\xb3\x58\xf1\xec\x7f\xe9\x8b\xb3\x5b\x38\x3b\xac\x3e\xa1\xad\xf6\x66\x68\xdf\x08\x98\xf7\x01\x45\x0f\x86\xb7\xf5\x9b\x18\x66\x2f\xd3\xe4\x32\x63\x69\x8d\xff\x44\x95\x4f\xbe\x13\x2b\x2d\xad\x8f\x84\x4d\x77\x9d\x7d\x35\xe5\xb7\xf4\x55\xf7\xb7\x34\xae\xae\x45\xa6\xca\x00\x57\x14\x36\xcc\x6e\x05\xae\x2b\x9a\x4f\x93\x59\x8c\xa0\x10\xec\x2a\xa3\x8a\x4b\xb4\xdb\x5b\xd9\x20\x97\x8a\xbb\xae\x1d\xaf\xc8\x08\x66\x14\x28\x03\xc1\x15\x21\xca\x0a\x02\xa6\x7a\x65\xf4\xe0\x81\x82\xd5\xe2\x7b\x12\xe5\xb5\xe4\xf9\xce\x3a\xae\x43\x45\x31\x72\x20\xaa\x08\x51\x11\xe4\xb1\xbb\xf4\x9d\xcc\x5f\x63\x56\xd1\x60\xbe\x65\xe9\x19\xe3\x2b\xa1\x32\x60\x32\x9e\x16\x16\x32\x1d\xe9\x69\x72\xe3\x27\x35\x5d\xde\x25\xf1\xbb\x59\x14\x59\x05\x36\x7e\xfa\xe9\xc1\x03\xb8\x17\x66\x47\x53\x36\x0c\xfd\x48\x26\x5b\x16\xf8\xd5\x55\x0d\xd8\xf7\xee\x51\x5c\x0f\xcd\xeb\x22\xce\x87\x31\xc0\x56\xe0\xd3\x62\x7b\x1c\x16\x39\x03\xe4\xc2\xf4\x77\x11\x24\xa4\x74\x83\x27\xa5\x2d\xdd\xdd\x51\xd5\x9d\x0d\x85\x86\x55\x9b\x37\x7d\x22\x6c\x98\x3f\xb2\xb3\x83\xf9\xf4\xb4\xb1\xf1\xd3\x4f\x5f\xbf\xd6\x17\x7b\xed\xe7\x4c\x16\x0a\x33\x7c\x6e\x2f\x1d\x78\x4b\xb2\xa0\x81\x74\xc6\x98\x7a\x34\x7a\x16\xe6\xe3\xd9\xa0\x35\x4c\x26\x5b\x23\xf1\x42\x77\x0b\xbd\x61\x6f\x0d\xa2\x64\xb0\x35\x78\xec\x0f\x9f\x3f\xd9\x1e\x0d\x9e\x3e\xef\x04\x9d\xee\xf3\x67\xec\xe9\x68\xfb\xf9\x93\xee\xf6\x93\xed\x67\xdb\x83\xe1\xf3\xc7\x8f\x47\xcf\x3b\x4f\x86\x9d\xad\x2c\x1d\x6e\x85\x59\x32\x49\xd2\xe9\x38\x1c\x6e\xe1\x21\x79\x38\xdc\x12\x4e\x29\xb7\x4c\x64\x5a\x9f\xb3\xff\x78\xd3\xed\x34\xdf\x74\x1f\x0b\x13\xb9\xf8\xb7\x8c\x49\xe9\x52\x21\x6d\xb4\xf9\x14\x1f\x21\x21\x47\x46\x49\x2a\xad\xd0\xf6\x5f\x1d\xf7\x0f\xde\x1c\xbc\x3d\x78\x77\xdc\x17\x46\xe1\x16\xcc\x3d\xa3\x8e\xd3\xc0\xde\xb5\x04\x62\x0d\x7c\x80\x35\x67\xfe\xf0\xa9\xcd\x31\x15\xd4\x33\x18\x06\x13\x5a\xff\xf9\x9f\x52\x5e\xa3\x35\x4f\x11\x0d\x3b\xca\xf2\x64\x9a\x2f\x8e\xf1\xd2\x90\x83\x33\x81\xd9\x51\x45\x30\x73\x0f\x4e\x4e\xa1\x07\x5f\xae\x2c\x18\x68\x99\xf0\x5b\x1c\xb1\x2c\x7b\x9f\x8f\x59\x7a\x19\x66\x0c\xf9\x70\x14\xb2\xc0\x11\x66\x48\x62\x21\xdf\x17\x37\xcd\x8a\x35\xb1\x32\xec\xc2\xbd\x42\x01\x7c\x1e\x69\x27\xb5\xa8\x2c\x17\xda\x72\xb3\x23\x71\x75\x28\xeb\xc1\x83\xda\x29\xcb\xa7\xe4\x1e\x04\x8c\x4d\x27\x3c\xdf\x29\x74\x7c\xc6\x5c\x0f\x6a\x50\xdd\xf8\xe9\x27\xe1\x1e\xd6\xea\xb6\x10\x85\x48\x1e\x6c\x53\x5d\xbe\xca\xdb\xef\xaa\x3e\x5b\x17\xdd\xf2\x91\x9a\xb8\x61\xb7\x23\xeb\x0a\x56\xc0\x5a\xb2\xda\x72\x52\x8b\x1a\x55\x3d\xb8\x72\x2d\xdc\x91\x06\x82\x3e\xab\x60\x2d\xae\xc5\xf3\x30\x96\x8e\x2f\xbf\x5c\xed\x6c\xfc\x44\x16\x7d\x45\x82\x0b\x8b\x04\x42\xdc\x7c\x8b\x2a\x32\xd4\x19\x9e\xea\xaa\x78\xc5\xf7\xd3\x4f\x3f\x19\x8d\x48\x6b\x81\xe5\x7d\x36\x2c\x0b\xca\xa8\xef\x6c\xfc\xf4\x13\x17\xf4\x3f\x5d\x6d\x58\x88\x48\x7a\xd7\x23\x82\xfb\xeb\x72\xd7\x0c\xcb\x05\x7a\x93\x6a\x34\xbf\x6e\x0f\x0c\x98\x35\x3d\x90\x0f\xbf\xab\xa1\x6b\x9e\xb6\x68\x71\x3d\xd8\x0d\xa2\x8d\x8c\x80\xa5\x21\x17\xd8\xdc\x06\x7f\x3d\xa3\x50\xfe\x21\x09\x0e\xe9\x05\x43\x09\x12\x41\xfb\x1d\x2a\x4b\x30\xeb\xca\x0a\x86\x11\x65\xf5\xf5\x69\x85\xac\xf8\x42\xd6\xa7\x38\x60\xbd\xf2\xdc\xe4\xca\x9b\x81\xdc\x7e\x1c\xd0\xdc\xc7\xf8\x09\x6f\xd1\x85\xca\x6e\x11\xf1\xdd\x5d\x1b\x3d\x2e\x6f\x28\xc2\x65\x1d\x8c\x1b\xcc\xd5\x3a\x22\x6e\xfc\x64\x38\x7f\xb3\x10\x22\xe0\xe4\xa4\x47\x75\x4b\xdb\x8e\x19\x89\x5f\xbf\x96\x09\xb0\xa3\x11\xf3\x57\x97\x58\x1b\x26\xf3\x89\xea\x37\x91\x1d\x7c\xe6\x5d\x6d\x6c\x28\x1e\x6a\x91\xd9\x79\x99\xb9\xf6\xa3\xc8\xa1\x08\x0c\x95\x6c\x85\x64\xb7\x79\x03\x4b\x0b\x21\x53\x72\x4c\x43\xa7\xb1\xd2\xac\x09\xb2\x71\x32\x8b\x02\x18\x30\x34\x60\xe3\x15\x1b\x88\xda\x86\x45\x92\xa2\x77\x60\x67\x9a\xb2\x0b\x0f\x62\x36\xb7\x85\xb0\x9e\x11\xba\x40\x65\xd7\xd1\x39\xde\x86\xdc\x36\xa8\x6a\xfd\x8e\x39\x6b\x6f\xaf\x86\x1b\x80\xab\x14\xf1\x55\x9e\x62\x7f\x7f\x83\xdb\xd6\x90\x8e\x19\x5e\x25\x51\x92\x1e\x0b\x05\x94\xcb\xca\x8a\xe4\x52\xa5\xbf\xb3\xf9\x71\xf2\xf1\xd7\x97\xba\xbc\x4c\xd9\x31\xde\x9f\x0e\xd1\xdb\x0f\x43\x50\x48\x71\x33\x41\x17\x3c\x63\xf9\xab\x24\xce\x53\x3f\xcb\x3f\x72\xf1\x07\xbb\x50\x4c\xb2\x0a\xbf\x99\x4d\xc2\x18\x0d\x61\xb0\xa0\xfa\xd4\x85\xd8\x64\x3a\xf6\xb3\xf0\x4f\x46\x7e\xc6\xe8\xb7\xce\x1e\xf9\x01\xc3\x7b\x9c\xc0\x48\x0c\xfc\xf4\x1c\x5d\x82\xd1\x0f\x9d\x11\x85\x67\xe3\x1c\x73\xc4\xaf\x1d\xae\x2b\xc3\x25\xf3\xcf\xf9\xf8\x96\x5d\xc2\xcc\x32\xd6\x1c\xb0\x51\x92\xb2\x26\x8d\x92\x70\x1e\xf3\xd0\xf4\xa9\xe1\x03\x05\xaf\x80\xcb\x71\x92\x09\xa7\x1a\xe4\xe5\x66\x12\xe6\x74\x6b\x9b\x8f\x19\x9c\x85\x17\x2c\x26\x5f\xbc\xca\x35\x0d\xf9\x60\xff\x42\xf5\xaf\x44\xd5\x63\xe9\x99\x83\xd7\x1c\x30\x18\x46\xfe\x64\xca\x82\xaa\x0a\x93\x30\xc6\xe2\x51\x72\xc9\x52\x18\x24\xb3\x38\xf0\xa5\x37\x1c\x06\xc9\x2c\x9f\xce\x72\x6a\xb2\xb2\xb6\x3f\xc7\xda\xb3\xe9\x74\x95\xda\xa9\xe8\xaf\xaa\xbf\x2f\x3b\x2e\x7d\xf2\xa0\xeb\xe1\x93\x49\x18\x7b\x1c\xf6\x69\xc1\x90\x98\x77\x43\xaa\xb0\xb2\x8c\x7e\x20\x44\x3d\xfe\x99\xe7\x14\x9c\x67\xa0\x6f\x06\x3a\xb0\xd2\x05\x5f\xe8\xda\xba\xa0\x3f\x97\x05\x4d\x25\x7e\xc7\x70\xd3\x22\x0e\xe4\xc8\xfb\x18\xe7\x65\xf3\x09\x29\x1e\x59\xf8\x71\x20\x0f\x1a\xf1\xbc\x4e\x9d\xd5\x59\x23\x96\x08\x27\xf8\x04\xa4\x09\xaf\xe5\x84\x08\x28\xc9\x2c\x9b\x49\x07\xfb\x3c\xa3\x85\x8d\x34\xe1\x7d\xcc\x20\x19\x79\xd0\x48\xcf\x06\x0d\xfa\x83\xb1\x3e\xc7\x59\x24\xfe\xf8\x0d\x13\x08\x4a\x55\x09\x43\xe0\xd7\x84\x93\xd8\x8b\xbd\xf8\x14\x92\x54\xfc\xf4\xe2\x53\x7b\xac\x64\xe3\xfb\x78\xf0\x48\xe8\x52\x5a\x61\x74\x2a\x64\x85\x83\xc5\xb5\xd5\xb7\x88\x79\xac\xfb\xe1\xa9\xc3\x67\xc4\x67\xd7\x42\x6f\x67\xc3\xf4\xf1\xa2\xfd\x8e\xf1\x0e\xbb\xf0\x02\x9a\x1d\xc3\x79\xd0\xfb\x38\x5a\x48\x1c\x8c\x3b\xc0\x6d\x63\x28\xc2\x38\x07\x27\x6c\xb1\x16\xbe\x9f\xf1\xa3\xe9\xd8\xa7\xe8\x50\x55\x06\xa9\xdb\xfc\xcf\xe6\x2e\x74\xcc\x13\x72\x0e\x89\xa2\x88\xa3\x4f\xe9\x43\xb9\xed\xe3\x89\x1e\x74\xda\x6e\xc1\xbb\x09\xee\xa9\x78\x8f\x94\x44\x35\x3c\xa6\x97\x3b\xc6\x87\xce\xee\x98\x5d\xd9\x18\xff\x4d\x68\x38\x0d\xd8\x94\x38\xb5\x4f\x79\x8a\x07\x46\x52\x07\x93\xfe\xcb\x4a\xeb\x52\x5a\xa3\xe4\xc1\xe8\xd6\xed\x14\x9a\xb1\x3c\xf4\x50\xaa\xb4\xf0\xe7\x9a\xdc\xa3\xaa\xfe\x6d\xee\x4a\x30\x26\x13\x9c\x6c\x23\x7c\x77\x39\xce\xbc\xae\x28\x62\x1c\x47\x1b\x25\x96\x4e\x61\xbc\x6a\xe1\xdc\x3d\x66\x73\xe1\x32\x8f\xf3\x0b\xde\xc5\x9c\x0d\xa4\x63\x45\x31\x81\xab\x67\x25\x34\xe1\xef\x6c\x4e\xbf\x3d\x40\x26\xfb\x8f\x38\x8e\xf9\xbc\xe2\x7f\xe3\x38\xa6\xba\x35\xd3\x8a\x37\x73\xed\xd4\x92\xcb\xaa\x39\xab\xf0\x46\x05\xc9\x55\x45\x5e\x7a\x6f\x97\xb3\x38\x60\x81\x5c\x79\x1b\xff\xd1\xd8\x29\x73\xbd\xb0\x50\x37\x41\x95\x27\x80\x0d\x6a\x53\x32\xca\x70\xec\xa7\xfb\xb9\x13\xba\x6a\xe8\x54\x8a\xe9\x02\x72\x28\x10\xb0\xa0\x58\x3e\x95\x94\x14\x10\x42\xb9\xa7\xa7\x19\xc1\xcd\x66\x83\x2c\x4f\x9d\x8e\x07\x5d\xd7\x83\xce\x13\xe1\x18\xfe\xac\xae\xe0\x76\xa1\xe0\xa0\xae\xe0\x63\x55\xb0\x18\xa8\x82\x4b\x1b\x63\x06\xb4\xd2\x22\xb7\xb7\xce\x4a\x29\x03\xc9\xb1\x57\xe5\xa5\x3e\xb6\x17\x0c\x19\x69\xc5\x58\x34\xf0\xbe\x95\xb0\x13\x2c\xf7\x2e\xc9\x59\x0f\x5e\x27\x8c\x5e\xfe\x65\xb3\x29\xea\xa3\x9c\x69\xfe\x4b\xb6\x59\x58\x5e\x8a\xcc\xa9\x64\xb7\x60\xce\x04\x57\x8f\x1e\x32\xa7\x27\x59\xd4\xe3\x20\x1d\x17\xff\xf8\xfc\xef\x38\x8b\xc4\x1f\xdf\x71\xed\x65\xe1\x0b\x79\x47\x90\xc1\xe6\x08\x8b\x9e\x58\xcf\x4f\x4e\xaf\x38\x67\xbf\xfd\xed\xd0\x5a\x24\x6d\xae\xb6\x55\xc0\x6a\xa6\x16\x8c\xd4\x16\xe7\xe8\xff\xd1\x28\x2c\xd8\x25\x18\x55\x13\xc5\xb5\x98\x6c\xc2\x55\xba\x54\x49\x39\x25\x7c\x1d\xed\x48\xc1\x5a\xa6\x88\x43\xf8\x62\xd6\xf6\x44\x65\x55\xb0\xb0\x6c\xe9\xa2\xa2\x91\x4d\xe8\x78\xd6\x9c\x82\x26\x74\xdc\x56\x36\x8d\xc2\xdc\x69\x78\xb2\x45\x01\x44\x8c\xa4\x1d\xf8\x5a\x1d\x2b\x1a\xbd\x46\x1e\xfe\x25\x4a\xfc\x5c\x9d\x0f\x93\x99\xb1\x66\xdb\x2f\x40\xe3\x43\xe6\xfe\x72\x74\x44\x53\x57\x96\x34\x94\x41\x8f\x32\xe9\x79\x18\x55\x6d\xc0\xb0\x3c\xda\x21\xdc\x65\x42\x1d\x51\x9c\xf6\x4b\x92\x4e\x66\x91\xdf\xc3\x53\xe2\xde\xd6\xd6\xe5\xe5\x65\xeb\x72\x1b\xdd\x09\x1e\x7f\xdc\xea\xb6\xdb\xcf\xb6\x3e\x1e\xbc\x6a\xfe\xf1\x6a\xff\xd7\x6e\xbb\xc9\xbf\x3b\xdd\x4e\x67\xeb\x3f\x64\x03\x4d\x6c\x20\x60\xa3\x1a\xce\xe5\x3a\xf3\x59\x8a\x8e\x1c\xef\x8e\x7d\x0b\x6d\x0c\xfc\xe1\xf9\x9d\xb7\x51\xa1\xe5\x16\x88\x2a\x14\x7c\x53\xe7\x6d\x43\x13\xba\x1d\x12\x0a\x5d\x08\xc2\xb3\x30\x87\x69\xca\x86\x61\x16\x26\x71\xe1\x41\x5d\x71\x43\xe4\x68\x52\x79\x46\x97\xb4\xda\x15\xcd\x26\xfb\x85\xfd\x91\x51\x47\x71\x73\x34\x9b\xbc\x2c\x16\x33\xc0\xed\x28\x85\xc6\xde\x9f\x39\xe4\xff\xcc\x9f\x3b\xbc\x1d\x0f\xc1\xf0\xa5\xa0\xdd\x6a\x3f\x76\x61\x4b\xe6\x87\x71\x55\xbe\xc9\xb3\xef\x90\x5e\x8e\x05\xbf\x95\x27\xbf\x84\x73\x16\x38\x5d\xd7\x45\x27\x21\xc7\xe9\x2c\x1e\xa2\xb5\x58\x8e\x4c\x89\xa4\xca\x0c\x7e\x3e\x46\x83\xf3\xc8\xcf\xc3\x0b\x06\x03\xb4\x82\x8d\x59\x46\x62\x35\x5e\xc0\x34\xe1\x6a\x60\x18\xab\xc5\x3f\x9b\xfa\x43\xae\x87\x3e\x84\x98\xaf\xf3\x51\xf8\x27\xed\xb8\xda\xb8\x40\xe2\x06\x30\xcb\x01\x03\x06\xa2\x94\xee\x60\x3a\x6d\xff\xb2\x1c\x2e\xc7\x61\xce\x2a\xe7\x44\x66\x4f\x8a\x3f\xf6\x0f\xb7\x7e\x7d\xb3\x75\x19\x9e\x87\x5b\x1f\x05\x7e\xfd\x48\x12\xfa\x7b\x8b\x6f\xc9\x9b\x4b\xa8\x45\xd2\x80\xb7\x5f\xe2\xd4\x4e\x89\x21\x35\xc7\x14\x54\x7e\x25\xa1\x83\xea\xad\xbf\x28\xaf\x34\xe2\x42\xf9\xd6\x75\xaa\x3f\xda\x68\x9d\x0d\x4c\xb8\xa2\x66\x9d\x38\xb5\x14\x7a\xd8\xda\x85\xee\xe3\xc7\xc8\x5a\x7a\xfc\x6d\x53\x08\x5e\xec\xe7\x5d\xce\xaf\xdb\xcf\xbb\xcf\x60\x8f\xea\x41\xa7\xdb\x7a\xde\x85\x1e\xf9\xc7\x9b\x26\x97\x0e\x07\x2e\xf8\x1a\x19\xbf\xc3\x7f\x78\xd0\x6d\x3d\x72\x6d\xd7\xda\x05\x36\xde\x96\x4c\x6c\xb4\x29\xe6\x82\xd3\x6e\x75\x3b\xdd\x27\xf0\x90\xf7\x91\xb4\xef\x76\xeb\x69\xe7\x71\x57\xa4\x74\x28\xa5\xfd\xb4\x2b\x53\xba\xa7\xae\x9a\x33\xdb\x62\xe9\xd3\x67\x98\xcb\xa9\x5b\xde\x7f\x14\x97\x59\x8b\xb4\x7c\x3b\xb1\x05\x9d\x76\x5b\xad\xaf\xa5\xa3\xbf\xb7\x7e\xce\xd2\xd0\x8f\x9a\xbf\x1d\xf6\x60\x16\x0b\xcd\x85\x05\xf0\x49\xe9\xf9\x5c\x57\xfa\x24\x16\xc9\x86\x6b\xae\x4c\xaf\xe9\x14\x46\xcd\x36\x39\x67\x67\xa9\x07\x01\x9b\x32\xb2\x81\x4a\x62\x08\xf3\x0c\xd4\x4c\x42\x6f\xa5\x6f\xd0\xf8\x9d\x16\x2c\xf4\x48\x4a\x07\x39\x2c\xf0\xf0\x97\x99\x23\x60\xa3\x91\xd2\x77\x99\x83\x85\x33\x94\x61\xc2\x46\xa3\x70\x18\xb2\x38\xdf\x6d\xb7\x3a\x8f\xa1\x09\x93\x59\x94\x87\xd3\x28\x2c\x1e\x8c\xc8\xa9\xb7\xd2\xee\xbc\x85\x1b\x92\x30\x9e\xce\x72\xb9\xee\xf3\xee\x52\x4d\x16\x80\x9f\x71\x1c\xed\x89\xac\xce\xc7\x8a\xb3\xd8\x40\xb2\xfa\xd5\x76\xc7\x7e\xb5\xdd\x59\xf6\x6a\xbb\x73\x0a\x3d\xe0\x5d\x35\x85\x7f\x95\x0c\x79\x01\xed\xd6\x63\xd8\x13\x83\xe7\x08\xe2\x1b\xb8\xb8\xd0\x93\xe3\x57\x95\x6b\x32\xd3\x11\xa3\x63\x01\x7f\x90\x25\xd1\x2c\x67\x90\xa7\x7e\x9c\xe1\x4b\xae\xe1\xa2\xa0\x73\xc3\x3e\x9a\xf6\x84\x19\x7a\xde\xc5\x83\x02\x93\x84\xc9\x05\x4b\x2f\xd3\x30\xcf\x59\xfc\x6f\xe2\x19\x52\x20\x9a\xfa\x90\x2f\x93\xbd\x43\x5c\x87\x63\x3f\x8e\x59\x44\x67\x1e\x36\xff\x7c\x53\xf6\x19\xf9\x01\x93\xe3\x60\xe8\xad\xc3\xe5\x82\x1f\xa4\x21\x85\x7d\xc0\xd7\xf6\xd0\xc9\x8a\xb5\x1d\xc8\x55\x94\x1f\xbe\x10\xc0\xd7\xaf\x50\x4c\x27\x11\x66\x1c\x10\x88\x63\x8c\x5d\x68\xf8\x0d\x79\xb6\x57\x3c\x5f\x90\xb1\x41\xad\xa3\x83\xda\xd3\xac\xb2\x88\xca\x8a\x1b\xb6\x7f\x9f\x08\xf9\x77\x4a\x8f\x25\xd3\x74\x25\x36\xb0\x85\x0c\x31\x83\x91\x56\xcf\x12\xd7\x9e\xa0\x19\x0b\xd6\xc3\x5d\xe8\x40\xd3\x6c\xab\xb0\x44\x56\x81\x2d\xab\x1d\x2b\x1e\x19\x5a\xad\x87\x75\xad\xcb\x13\xc3\x9b\x72\xdf\x1b\x12\x7d\x3f\xd8\x4f\xd8\x33\xd7\x2e\x04\x7f\x21\xfe\xdb\xdc\x05\xa7\xd3\x6e\x23\x13\x58\x39\x2e\x3c\xfc\x77\x71\x25\xc7\xa9\xfb\xf8\x71\x11\xa7\xb0\x0a\xa7\xb2\xef\xee\x15\x98\xd5\xbc\x01\x5d\xd9\x61\x73\xa9\xe6\xdd\xfa\x62\xbe\x23\xb7\x20\x6f\x93\xc0\xaf\x73\xde\xf6\xb8\xdb\xe6\xe5\xae\x69\x49\x99\x46\x53\x33\xa5\x98\xd7\x1b\xc0\x95\x23\xfb\x21\x8e\x53\x50\xd0\xeb\xbc\x19\x20\x76\xae\x74\x62\x2b\xfc\x46\xdd\xbd\x6b\x83\x0a\xcf\xc3\x85\xb1\xbb\x9d\x6f\xdb\x6f\x34\x76\x61\xfc\xfa\xfd\xdb\x3a\x3f\x4f\x8f\xed\x62\x4b\xdd\x6c\xf3\x02\xdf\x85\xaa\x65\x7f\xce\x15\x4e\x66\xff\x7e\xfc\xf6\x0d\xf0\x9e\xf9\x71\x00\x47\xbf\xff\x8a\xbf\x27\xfe\x02\xc6\xfe\x05\x33\xc2\x04\xc8\x73\xe4\x88\x5d\x30\x7a\xfd\xbb\xb5\x05\x59\x62\x3e\x16\xa6\x40\x1a\x74\x05\x91\xb3\x39\xbe\x78\xcd\x99\x1f\x90\xc2\xac\xec\xa2\x31\x96\x8a\x30\x78\x6b\x6d\x98\x5c\xc9\x29\xa7\xb0\x35\x8d\xcd\x05\x40\x0f\xdf\x66\x9a\x11\x08\x44\x06\xfa\x60\xf5\xc3\x8a\x97\x09\xc5\x02\x0e\x42\x28\xc5\x6a\xd4\xc5\x30\x1e\x8b\x74\x8d\xfa\x41\x44\x71\xaf\x03\x4b\x11\x20\x92\x00\x0d\x77\xee\xdd\xbb\x0e\x0c\x35\x0e\x0f\xa0\xf3\xc4\x46\xa1\x1c\xfb\x20\x1a\xf8\xc3\xf3\x42\xbf\x0d\x89\x0a\x3d\x55\x48\x3e\x9e\x30\x14\xeb\xca\xda\xea\xb0\x9c\xbe\x82\xc4\x20\x23\x76\x81\xf7\x45\x54\x71\x4b\x01\x34\xa4\x7f\x58\x2a\x49\x6f\x64\xc9\xb3\xc5\x3b\x42\x6d\xa3\x18\xb9\xe1\xaa\x22\x54\x61\xe9\x7d\x47\xf9\x49\xc7\xed\x9c\x94\x7e\x33\x9b\x17\x3d\x87\x92\xcb\x98\xa5\xda\xf3\xb1\x22\xbb\x95\xee\x68\x92\x4b\x6f\x57\x09\xc5\x1f\x45\xca\x59\x65\xd1\xe8\x4b\xc1\x5b\x42\x36\x6d\x3b\x54\x22\xdb\xf6\xed\x5c\x8f\x7e\x23\x91\x79\x38\x4c\xe2\x97\xb3\x3c\xaf\x0d\x7d\xf8\x98\x1c\xe4\xfd\x1b\xd7\x3c\x8d\xe2\x5f\x60\xe1\xdb\xfe\x8b\x79\x58\x14\xa3\x88\x8a\x75\x8d\xfb\xc4\x67\x8f\xff\xdd\x03\xc8\xb1\xab\x1a\x3b\x8d\xfb\x7e\x90\xa4\xb1\xf0\xd9\x5d\xed\x5a\x77\x25\xcd\xcb\x86\xf5\xcd\xfa\xa2\x5a\x58\xde\xa9\x37\xfe\x80\xd5\xaa\x92\xe4\xc6\x6a\xa5\x0e\x21\x9c\x6f\xd6\x19\x84\xfe\x57\x98\x59\xff\xc6\x20\xb6\x77\xb8\x0a\xd1\x63\x7f\xdb\x25\x86\xe5\x70\xb0\x5b\xe7\x25\xb4\xe8\x99\x70\x7b\x89\x86\x2a\x61\xa9\x3a\x36\xe2\x75\x6d\x3c\xad\x29\xbf\xac\xa9\x02\x64\x05\x81\x4c\x00\xfe\x08\xf3\x71\x32\xcb\xb5\x6f\xb9\xba\xa6\x1f\x5f\x57\x71\x19\x0e\x75\x6d\x29\x98\x29\x1b\xa1\xe5\xe6\xdf\xc2\x78\xcc\xd2\x30\x67\x81\x0e\x42\x49\x6b\xc7\x4b\x3f\x63\xaa\xb0\x5f\xeb\x4a\xbb\x63\x80\xf4\x87\x4b\x3d\xcb\x61\x01\xc3\xb1\xab\x9f\x65\xb1\x3f\x61\x75\x9e\xd5\xbb\x15\x45\x97\xfb\x80\x95\xa5\xb4\xfb\xdb\x30\x1f\x1f\x49\xfe\xaa\xdc\xe4\x54\x14\x5d\xea\x2c\x57\x95\x52\x15\x35\xb5\xea\xf8\xf4\x71\x45\xd9\x65\x8d\xe8\x52\x86\xa7\x5d\x36\x5d\x26\x1d\xb7\xdb\x4f\xcb\x65\x97\x7b\xe5\x15\x85\xbe\x8b\xe0\xe2\x78\x0d\x78\x6b\xe4\xcf\xe9\x97\x28\xb9\xc4\xa7\x63\x1f\x44\xbc\xd4\xac\x2f\x03\x9f\xf6\xc5\x6b\xb2\x5a\x6e\x6b\xdd\x10\xce\xd7\xaf\x95\x80\xda\x6e\xcb\x8f\x17\x3b\x37\x42\xed\x7d\x1a\xb2\x38\x97\x4f\x8e\x2a\xc5\xc5\xf3\x95\xf1\x33\x81\xad\x82\x63\x98\xc9\xf1\x37\xde\xdf\x61\x92\x33\x1c\x87\x51\x60\x29\xe6\x98\x82\x21\x8c\xe8\x1d\x1f\xc6\xfd\x48\x59\xdc\x1a\x26\xb3\x38\x97\x15\x28\x9e\xe3\x83\x07\x54\x9c\xee\x09\xac\xaf\xd6\x64\x16\xbe\xf3\x27\x75\xa9\x78\xdf\xa0\x18\xa9\xb1\xa3\xde\x16\x28\x91\x5e\x92\xf1\x3a\x06\x22\xa6\x38\x16\xd6\x62\x09\x4e\x92\xbc\xa7\x76\x8f\x22\xea\x4a\x0f\x1a\xa3\x88\xcd\x1b\xd2\x5c\xd6\x8f\xc2\xb3\xf8\x30\x67\x93\xac\x07\x8d\x21\xe3\x5c\xdb\xd0\xce\x09\x83\x20\x8c\xcf\xde\xb0\x51\xde\x83\x76\x21\xf5\x63\x78\x36\x36\x93\xb5\x79\x47\x4f\xc4\x75\xa1\x0d\x29\xe5\xfb\x51\xce\xd2\x18\x6d\x03\xb0\x8f\x1a\xaf\x89\x9f\x9e\x85\x71\x0f\x1a\x6d\xf0\x67\x79\xd2\xd0\xdb\x58\x4d\x86\x15\x39\x81\xab\xeb\x35\xfc\xd4\x76\x5b\x49\xcc\xde\x8f\x78\x0d\xe7\x44\xbc\xa3\xbc\xe9\x44\xb2\xdf\x86\xee\xdd\xb4\x7e\xaf\x0e\xb3\x6c\xec\x4f\x99\x73\x33\x68\x6e\x75\xe8\x5d\x0e\x4d\xd8\xd1\xd5\x64\xd3\x51\xfb\xa9\x7b\x33\xd2\xa2\x8f\x56\x61\x4e\xa9\xbc\x34\xfe\x2d\xc4\xf0\xcb\xf4\xf1\xc1\xcf\x32\x86\x91\x72\x2f\x42\x1f\x3e\x71\x6e\xfe\x04\x4d\x98\x52\xb2\x8c\x39\x9a\x27\x94\x85\x4c\xf0\x49\xba\x70\x04\xf0\x87\x9c\x35\x6a\x29\x34\x48\x92\xc8\xdb\xa8\x6d\xfb\x08\x3d\xcc\x20\x87\x45\x11\x46\x3b\xe5\x6d\x4c\xa5\xb7\xb3\x30\x6f\x64\x78\x44\x15\x85\x2c\xd0\xd6\x92\x45\x9e\x04\x19\xc8\xcf\x40\xab\xc4\xb6\x2b\x23\xf8\x8a\x22\xeb\xfb\x66\x7f\x21\x49\xc1\xa7\xcd\x7e\x9e\x00\x06\x57\x87\x30\xce\xc2\x80\x59\xa5\xfc\x8c\x84\x44\x8a\xb7\xc2\x02\x15\x99\xa2\x7c\x17\x7c\x5f\xee\x6d\x85\x99\x58\xcb\x82\x5b\xd5\xed\xfd\x7b\x67\x8d\x81\x4a\x3d\x3f\x21\xb9\xa5\x13\xd6\x3a\x69\x82\x7a\xe1\x0a\x30\xb8\x80\xaf\xef\x03\xcd\xd5\xa5\x9c\x9d\xc1\x30\x99\x4c\xc9\x51\x15\x17\xf6\x78\xa7\x75\x98\xa9\x99\x95\x80\x62\x1d\x83\x5b\x64\x95\x75\xa7\xd4\x6b\x7a\x78\x44\x96\x9c\x03\x3a\xa6\xc1\x20\x63\x1c\x21\xf1\x2a\xe9\x06\xf8\xc8\x1a\x37\x40\xe7\x78\xcc\x20\xe4\x12\x5d\xac\x5c\x2c\xe0\x13\x9b\x7c\x6e\xb2\x29\x44\x76\x03\xbc\x64\xfd\x60\xfd\x10\xfd\xa6\xe8\x5f\xce\xb5\x91\x9f\xe5\x6b\x72\x0d\xaf\x4e\xef\x25\xfd\x9b\x88\xca\x12\x08\xad\xd1\xdd\x54\xda\x59\x9a\xe5\x9a\x83\x66\xc0\x58\x4b\xea\xd5\xd4\x5f\x59\xf2\x99\x7d\xb8\x1b\xc6\x31\x20\x9a\x12\x90\xc2\x54\x19\xbe\xb7\xd9\x94\x76\x4c\x8e\x74\xb0\x2f\x6c\xb6\x68\x75\x96\x5e\xf3\x5b\xf4\xa9\x35\xc8\xc2\x32\xaa\x8a\x15\x32\x94\x7f\x6b\xb1\x92\xa9\x82\x32\xc1\x72\x80\xcd\xe5\x26\xef\x8a\x2e\x25\x53\x55\x31\x25\x16\x55\x11\x99\x52\x70\xa5\x6d\xc3\x60\xca\x3d\xad\x92\x63\x32\x5f\x26\xc8\x02\x21\x69\x94\x94\xc9\x3f\x64\x06\x9f\x24\x2a\x83\x7f\xc8\x0c\xc9\xfe\x2a\x53\x26\xa8\x02\xd6\xde\x47\x94\xd1\x69\xaa\x18\x3a\x6b\x15\x31\x42\xea\xce\x2d\x54\x14\x55\x1a\x30\x0f\x4e\x1a\x34\x36\x0d\x0f\x1a\x45\xf2\xf3\x34\x49\x69\xfc\x2d\xe9\x89\x1f\x92\x72\x2a\x87\x65\xfc\xa7\x24\x08\xff\xcd\xfb\xcf\xff\xf2\xee\xf2\xbf\xb2\x67\xf8\x5b\xf7\xa0\x81\xba\xa5\xb4\xf6\x93\x8d\xe8\x70\x27\xea\x04\x42\x63\x2f\x1a\x6c\xf1\x1d\x8b\x47\xe5\x0a\xa7\x44\xba\xec\x97\x2b\x4f\x0e\x6b\x99\xc3\x4a\xcc\xe8\x7a\x36\x37\x69\xd3\x73\x4e\x09\x53\xab\xd5\x3a\xa8\xc9\xde\x65\x05\xb0\x9a\xab\x8d\xf5\xb6\xc0\x84\x7a\xe5\xb3\x99\x8b\x16\x2c\xcd\x53\x5a\x6e\xda\x1c\x63\x09\x43\xe3\x83\x76\x48\x46\x67\x60\xd7\xde\xc7\xa6\x2c\x76\x61\x4f\x9e\x26\xa9\xe8\xb3\xe8\xbe\x40\x7a\x9a\x51\x33\xcf\xa0\x87\xcb\x85\x4e\xb1\x12\xba\x55\x95\xb5\x10\x2f\xe3\x74\x44\x16\x13\xa4\x50\x90\x8c\xef\x94\x71\x84\xad\x9b\xc0\x55\xda\x30\x8e\x79\xec\x46\x90\x47\xe4\x69\xa5\xc1\x1c\x55\xe4\x36\xf5\x30\xcd\x8f\x57\x1e\xcd\x31\xd7\xc0\x92\x50\xbc\xda\xd8\xd0\xa2\x10\xa3\x7b\xa3\x38\xa5\xd9\x3a\x64\x59\xd6\x62\xf1\x45\xeb\xdd\xfb\xd7\x07\xfd\x83\x77\xbf\xa3\x75\xea\xfd\x69\x9a\x04\x33\xe1\xa2\x6c\x0f\x9c\x7e\x8a\xb1\x10\xbf\xac\xac\x48\x5a\x7a\xe9\x8a\xdb\xa1\x1b\x6f\x4f\x7e\x6c\x22\xee\x7c\x13\xb1\x71\x75\x9d\xbc\xe2\xac\x60\xc9\xd4\xa5\x7c\xe0\xde\x04\x9c\x10\xde\x4b\x95\xc1\x95\x01\x1a\x0b\xc0\x12\x26\x5a\x15\x9c\xb1\x6e\xdc\x01\x34\xb1\xf2\xfc\xd0\xee\x57\xd1\xee\x57\x25\xaa\x58\xc6\xef\x60\x78\x0c\x45\xe0\x2e\xa0\x19\xaa\x84\xf7\x43\xfd\xff\x76\xea\x3f\xe7\xb4\x94\x8d\x5c\xf4\xfc\x56\x65\xcc\x42\x51\xdd\xf4\x75\x8e\x1e\x2a\xe1\x87\xdc\xd1\xeb\xa4\xbb\xf4\xe6\xf3\x8a\x5c\x10\x2e\xbb\x4a\x75\xb6\x5d\xd7\x2d\xdd\xcc\x2e\xf5\xe1\x6a\x9a\x78\x2e\x89\x00\xcb\xe6\x6c\x48\x7b\x99\x3c\x5d\xd8\xd7\xd3\xf7\xee\xf1\x4c\x11\x81\x06\x86\xe8\x2f\xca\x29\xbe\x91\x55\x66\x4e\x55\x61\x7d\xb7\xbf\x95\x3f\x4c\x85\xff\x9b\x30\x66\x7e\xea\x28\xe3\x2b\xec\xc8\x38\xcc\x5a\x7d\x65\x67\x26\x2d\xb3\x50\x77\xa1\xf2\x86\xe3\x53\xd2\x43\xfc\x94\xf9\x47\xb9\x9f\x1a\x17\xf6\xea\xb2\x9e\xc0\x61\x94\x74\x11\x7d\x16\x8f\xed\x79\x95\x83\x38\xb8\xae\xc2\x3b\xff\x9d\xaa\xc2\x93\x96\xb7\x42\xaf\x26\xcd\x66\x78\x9d\xea\x66\x94\x37\x73\x6a\xea\xeb\x57\xeb\x93\x2b\x5e\x6d\x15\x4b\x40\x02\xde\xdd\x85\x8e\xeb\xda\x14\xa2\x58\xe7\x1f\xfc\x5c\xc5\x91\xb1\x3a\xd0\x81\xa6\x91\xa0\xf0\x42\x80\x06\x56\x73\x0f\x16\x12\xb3\x39\xec\xc2\x26\x4f\xe0\x7f\x17\x04\x33\xbb\x0c\x91\x7f\x0c\x74\x0c\x43\x69\x3f\x63\xd0\xee\x15\x88\xd0\xd9\x31\x31\xd9\x2b\x60\xcd\x13\x8f\x13\xd1\x6e\xaf\x90\x39\x49\x2e\x54\xe6\x0e\x0c\x52\xe6\x9f\xef\x98\x6d\x75\x8a\x6d\x75\xf1\x65\x22\xaa\xb0\xea\x59\xa2\xba\x61\xac\x6f\xd8\x82\x7d\xa5\xa6\xc1\xcd\x7d\x5b\xf9\xe4\xd5\x4a\x91\xd3\x62\x68\x23\xea\x63\x81\xdf\x77\xc8\x24\xa4\x38\xed\x96\x7a\xbf\xba\xc5\xb4\xbb\x7d\xbf\x5c\xf8\x52\x89\xf1\x52\x6b\xf5\xbb\xc1\x58\xfa\x90\x0e\x27\x93\x59\x4e\xae\xfe\xeb\xb0\x1e\x22\xd6\xc8\x1b\xeb\x82\xa0\x8e\xbf\xf4\xb3\x30\x33\xc4\x15\x82\x74\x28\xd0\xb5\x9e\x31\xfc\x5b\xf3\xd7\x80\xfd\x19\xb2\xf4\xd5\x2c\x45\x16\xa6\x0d\x5d\x17\x1e\x8a\x52\xf3\x36\x6c\xca\x9f\x1d\x17\xb6\x60\xdb\x2b\x16\x59\xe8\x22\x0b\xab\x88\x01\xc1\x00\x58\x51\x64\x61\x17\xa9\x85\xf2\xc8\x80\x02\x9b\x30\xe7\xc5\x9e\x94\x21\x3d\x32\x20\xc1\x26\xef\xf5\x16\x3c\x51\xdb\x49\x45\x1c\x24\xd6\xea\xa2\x1c\x8b\xff\x65\x25\xf9\xbc\x2d\x9d\xfb\x73\xda\xec\x1a\x39\x0b\x9d\xb3\xe8\x68\xb8\xeb\x2c\x01\xd7\x0b\xd5\xed\x9e\xe2\xb9\x30\xf3\x14\x42\x9e\x42\xc0\xad\x10\x7c\x58\xb3\x5b\x23\xf7\x2a\x41\x14\xa4\xe0\x8f\xc5\xe9\xae\x17\xa7\x72\xa9\x6e\xb1\xd4\xf6\x4e\x35\x12\xce\x63\x9c\x7e\x82\x29\x37\x15\x0f\xd0\x64\x05\x23\x7b\xa1\xb3\x69\xca\x3f\xa9\xe2\x0e\xb5\x2c\x9a\x8c\x55\xbd\x1a\x56\x4e\x06\xcf\x98\x16\x30\xdf\xa9\x9b\x19\x9e\x39\x47\x16\x3b\xb7\x58\x5b\x07\x2b\xae\xad\xb6\xfc\xa9\x59\x5a\x97\x3e\x8e\xfa\xee\x0b\xd5\xe0\xae\x16\xaa\x57\x7e\x1a\x84\xb1\x1f\xdd\x7e\xad\x32\xd6\x03\xfa\x79\x0e\x0f\xd5\xa2\xd1\xc5\xf9\x4a\xeb\x87\x38\x5b\x34\x16\x86\x52\xf9\x85\x2e\xbf\xb0\xcb\xcf\xbb\x95\xf0\xb9\x3c\x98\xdb\x80\x2b\x0b\x2e\x78\xc1\x45\x01\xa2\x5d\xad\xbc\x3e\x49\x1a\xe9\xd7\x21\x39\x8b\x33\xf5\xc6\xa5\x76\xad\x92\x59\xe7\x9c\x0b\x51\x62\xc9\x6a\x5b\xf0\x04\x9b\x90\x90\xff\xb7\xac\x66\xf2\x67\x77\xe9\xc2\x26\x7e\x76\xbf\xf5\x1a\x77\xcd\x4a\xd5\x55\x92\xa4\x5b\x29\x6e\x57\x59\x22\x7f\xac\x6f\xdf\x78\x7d\x33\x97\x84\x82\xe4\x5f\x71\xed\xfb\xb6\xeb\x54\x91\x97\x38\xeb\xaf\xba\x78\x49\xee\xf3\xcc\x19\x61\xaf\x68\xb3\x78\x96\xb1\x60\xc9\xc2\x86\x26\xb7\x54\x4a\x09\x71\x51\x4a\x08\x73\x2e\x5c\xb4\x03\x9e\xe1\x2c\xcb\x93\x89\x63\x08\x28\x33\x90\xf4\xb0\x20\xc9\x0a\x67\x3a\x7c\x31\xac\x17\x76\xca\x0b\x8d\x84\xd2\x12\x39\xc6\xb9\x92\x63\x49\x46\x6d\x30\x4a\x58\x6d\x5a\xa0\x2c\x77\x10\x6a\x19\xba\x72\x9d\xb6\x5b\xb5\x00\x2f\x7d\xe1\x7a\x37\x0b\x70\x38\xb1\xc8\xde\x17\x07\x77\xfd\xc3\xb7\x1f\xde\x7f\x3c\x3e\x78\xdd\x7f\xfb\xfe\xf5\x6f\x6f\x0e\xfa\xed\x7e\x94\x04\x7e\x36\xee\x87\xd9\xbb\x30\xea\xf7\xeb\xac\xa6\x3b\xee\x9d\x80\xef\xeb\xc3\xc7\xaa\xd8\x47\xb1\xb3\x3a\xa8\xf5\x10\xea\x68\x28\xbf\x08\xca\xd7\x76\x1a\xdf\x69\xde\x55\x1b\xb7\xe8\x79\x25\xbc\xf5\x50\xeb\xd2\xa5\x6c\x7d\x97\x6f\x09\xf6\x16\xbd\x54\x30\xd6\x43\x61\x1b\x8f\xc3\x31\xaa\x52\x56\xdb\xbd\xf6\x5d\xc0\xbe\x45\x1f\x6d\x40\xeb\x21\xf3\x48\xd0\x29\x9b\x24\x49\x3e\xae\x9f\xb1\x8f\xee\x06\xfc\x2d\x7a\x5b\x04\xb5\x1e\x42\x8f\xfb\x7d\xf1\xba\xe2\x38\x49\xa2\x3c\x9c\xbe\xe2\xd2\x3c\xae\xe7\xe1\x67\xdb\x6b\xce\xdb\x27\xfd\xfe\x2c\x0f\xa3\x3e\x5e\xb3\xfc\x96\x87\x51\x3d\x23\x75\xb6\xd7\x6b\xe2\xa9\x68\xe2\xb5\x9f\xfb\xd7\xb4\xf0\x74\xbd\x16\x9e\x89\x16\x3e\xcc\x52\x46\xb1\x15\xeb\x9b\xc0\xe7\x36\xf6\xcb\x30\x1d\x66\xca\xcf\xb2\xf0\x0c\x5f\x5c\xe8\x9b\x16\x11\xd7\x03\xbe\x54\x7a\x04\x2e\xfa\xfa\xda\x81\x70\x73\xd3\xc5\xf8\x5d\x32\x7e\x87\xe9\x11\xec\x24\x3c\xdd\xd1\x70\xce\xd9\x02\x03\xe0\x52\x94\x11\xf8\x82\xea\x69\x29\xe2\xd5\xd8\xcf\xde\x5f\xc6\xf2\x6e\x91\x2e\x9d\x64\x0c\x8b\x73\x86\x61\x25\xc0\x88\xa6\xa2\x62\x83\xe0\xd7\x0e\x5c\xe1\x7f\x56\x28\x1f\x1d\x1e\xae\x4f\x06\x2a\xaf\x22\x3f\xcb\x8a\xde\x12\xcc\xc8\x17\xc6\xed\x66\xc8\x32\x15\x4a\x43\x9a\xd4\x55\x7a\x56\x11\x76\x64\x65\xb2\x04\x2c\x1b\xa6\xe1\x14\xc3\xdc\x51\x29\x24\x8b\x4e\x6e\xe9\x67\x99\xe8\x90\xa6\x2a\x9d\x8f\x11\x3e\xbb\x37\xf3\x87\x49\x3c\x0a\xcf\x66\x2a\x8e\x73\x3a\x63\x3b\x48\xd4\xfb\xf8\xbe\xf0\x3e\xa7\xb6\x2e\xee\x9a\x55\x2f\xd3\x30\xb7\xaa\x55\x3f\x61\x94\x3d\x37\x6a\x9e\xb3\x85\xf9\xed\xee\x98\x04\xd7\x14\x7d\xa5\xa3\xfb\x21\xe1\xf2\x84\xec\x89\x20\xcb\xfd\x3c\x1c\x7e\x90\xa4\xe4\xe8\xea\x6c\xb7\x4c\x7c\x03\x90\xe6\x12\x13\xa4\x4b\x7d\xb6\xe0\x2e\x83\x62\xa3\xb0\x23\x51\x37\x4a\xec\xe0\x4b\x2d\xc7\x7e\x72\x27\x0d\xdf\xba\x1e\xf4\x73\x36\x99\x76\xad\xb7\x62\x98\xf5\xca\x8f\xa2\x57\x63\x36\x3c\x77\xc2\x38\xcb\xfd\x98\xb3\xac\x01\x56\x76\xf7\x9e\xca\x06\xf9\x23\x19\x59\x05\x91\xc7\x95\xf7\xc4\xe3\xc5\x94\x91\x07\xc5\xfb\xaf\xfc\x38\x4e\x72\x0c\xf8\x0e\x3e\xd9\x25\x81\x9f\x81\xaf\x08\x7f\x9f\xc6\xc3\x44\x6d\x9a\x64\x59\x38\x88\x98\xd1\x00\xf9\x9f\x76\x32\x16\x8d\x3c\x04\xa6\x50\xe3\x49\x76\xeb\x1f\x19\x3a\x08\x19\x4a\x14\xf8\xee\x00\xc6\x7e\x16\x37\x72\x8a\xc0\x1c\xc6\x61\x1e\xfa\x51\xc8\xb7\x06\x4d\xc8\x66\x53\x96\x3a\xae\x55\x82\xe2\xd3\x13\x6a\x4a\x85\x8e\x22\x33\xa8\x22\x7e\x5b\x11\x17\xbf\x7e\x85\x52\x9e\xee\x25\xec\x51\x72\x0f\x38\xc6\x3b\x76\x8f\xc5\x33\xce\xcc\xc9\x66\x83\x57\x34\x76\x88\x16\xfe\x96\x5d\x15\xc0\x75\x06\x59\x81\x59\x61\x2a\x0b\x99\xf1\x8c\x28\x55\x39\x34\x47\xbc\x2c\xdf\x0b\xa5\x2c\xc3\x7d\xc6\x64\x96\xe5\xc0\x42\x34\x02\x1d\x30\xac\x4c\x8f\x47\x64\x13\x1e\xfa\xef\xbe\x0f\x9b\x50\xc2\x05\x49\x25\xb1\xb7\xce\x5b\xc4\x3c\x25\x41\xe6\x18\x08\x5a\xe8\x9a\x33\xe5\x0b\x18\x91\x36\x7b\x3a\xd6\xa2\x26\x8e\xf9\x2c\x1c\xa5\x8c\x07\x52\x3e\x88\x77\xe2\x60\x8a\x1a\x19\xa6\x11\xae\xe4\xd4\x33\x88\x2b\xf0\xcb\x58\xfe\x41\xa2\xf0\x7e\x04\x7b\xd5\xe9\x35\x03\xa4\x71\x6b\xf5\xfb\xd8\x13\x5c\xe0\x74\x11\xf9\x00\x1c\x1d\x88\x8d\xc2\x88\xbd\xbf\x60\xe9\x45\xc8\x07\x84\x14\x08\xf4\x05\xa6\xfe\xf1\x49\x7c\xf0\xe1\x08\x97\x31\xfa\x32\x2d\x02\xc9\x1b\x18\x2a\x1c\xbd\x1b\x6b\x88\x2d\xdf\xb4\x5d\x5a\xa3\xb6\x0a\x0c\xb7\x46\x5d\xce\x48\xa7\x78\x3c\xc8\xfb\xfe\x32\x99\xaf\x85\x3f\xd9\xa1\x88\x63\x99\xb5\x20\x90\xd9\x12\x1d\x4c\x2e\x6e\x0d\xe1\x32\x0c\xf2\xf1\xad\xa1\x8c\x19\x3d\x6e\x5c\x1b\x0c\x3a\x51\xc7\x47\x0e\xda\x92\xf3\xc6\xa0\xa4\xd1\x66\xc6\xa6\x3e\xc6\xdb\x5d\x6f\x84\xc4\x13\x23\x10\xc1\x27\x72\xb6\x1e\x1c\xce\x2f\x1c\x4a\x32\x1a\x65\xec\x36\xb4\x41\xb2\x84\x39\x9b\xa0\x55\xd1\x7a\xb3\x46\x3c\xbe\x02\x7a\x05\x74\x17\x80\x2e\x53\x7f\x3a\x65\xe9\x5d\x80\x1a\xce\xd2\x6c\xcd\xc1\xba\x9d\x38\x40\x86\x59\xa7\xd9\xdb\xc8\x11\xea\xb7\x78\x54\x34\x4c\x12\x3c\xdd\xca\xd7\xa3\xe1\x5f\x47\x9a\x88\x09\x0c\x30\x15\xde\xb9\xfe\xef\xe8\x8f\x9c\x31\x6b\x41\xf2\xe3\x05\x52\xc4\x5f\x44\x89\x1f\xac\x07\x22\x4d\xfd\xc5\xfb\xd1\xca\x47\x20\x35\xb4\x8c\xc5\x9b\xca\x75\xbb\xa0\x7c\xa8\x7c\xf7\x29\x2a\xc6\xf3\x16\x82\x7c\x6d\xb2\x9f\x8a\xbb\xc0\x59\x1c\xae\x27\xbe\xfd\x78\x81\x6c\x44\x7c\x14\x66\xfb\x71\x38\x41\xa3\xd2\xfd\xdb\xaf\x71\xbe\x84\xf5\x7a\x96\xfa\x6b\xcf\x37\x3d\x5b\x14\xbc\x03\x3f\x0b\xe3\xb3\xf5\x47\xda\x39\x69\x30\x3f\xc3\x37\x52\xfc\x6f\x33\x8c\xd5\xcf\x64\x96\x1b\xc9\xf2\x33\x42\xf3\xb5\x06\x51\x1b\x97\xb9\x24\xbd\xed\x9a\x3b\x0a\xa3\x9c\xa5\xef\x66\xd1\x7a\x13\x97\x13\xd9\x08\x57\x89\xc9\xe6\xd3\x27\xa9\xa3\x90\xfa\x6e\xac\xf1\x9d\xb6\xa5\x1f\x7e\x81\x79\xa7\x07\x6d\x0f\xe6\x5d\xfc\xb3\xa0\xaf\x05\xff\xa2\x5b\x3b\x53\xfe\x7f\xe1\x22\x8f\x67\xeb\x5c\x5c\x18\xc5\x12\xfb\xe5\xaa\xa0\xdb\x34\xa0\x07\x8d\xf2\x52\x4c\xe5\x0c\x7d\x81\x12\xcc\x85\xff\xcb\x95\xb9\xec\x4a\xdf\x54\x15\x0c\x7a\x4f\x84\x37\xbd\xd9\x19\xdf\xc9\xfd\xf8\x3e\x6c\x3d\x84\x30\x3b\xca\x52\x78\xb8\x75\xea\x3a\x6e\x25\x8f\x09\x4e\xa9\x66\xe7\x47\xed\x76\x91\x23\xb4\xff\x11\x95\x58\xf4\x9f\xd5\xec\xa8\x1b\x51\x93\x09\xc8\xf7\x93\x18\xd1\x14\x8f\xf1\xc4\xb1\xa7\x79\x32\x65\x65\x38\x62\x9b\xa2\x4f\xa2\x84\xc7\xc7\x1b\x1c\xdb\xb7\xfc\x56\x98\xfd\xee\x47\x61\xa0\x1e\x90\x11\x50\xb7\xe8\xf6\xeb\x46\x30\xed\x27\x69\x36\x9a\x05\xe7\xc5\x6b\xde\xaa\x38\x6e\x1d\xa6\x22\xd9\x31\x5a\x33\xdf\xa8\xdd\xac\x1f\xd6\x0b\xb6\x75\x8e\xac\x4f\xee\xfb\xc8\x6a\xf2\x50\xfd\xe1\xd6\xa9\x26\x84\x1c\x6f\x51\x49\xed\xe7\x97\xb4\x54\x75\xda\x5b\xd1\x86\x2b\x7c\x3e\xc1\x2e\x38\x74\x3e\x05\xbb\xf2\xc4\xca\x3a\xea\xec\x2b\xdf\x56\x44\x46\x7d\x5a\x22\x90\xf2\xc0\x28\xb2\x63\xdd\xc8\x8a\x12\x8e\x19\x6e\x85\xbc\x67\xe9\x4f\xde\xb6\x07\x7d\xba\xc8\xee\xa7\x2c\x17\x99\xc5\x23\x32\x2a\x20\x20\xba\xa2\x90\x3a\x58\xed\x47\xf8\xb8\xb8\x78\xde\xec\xf1\x94\x4c\x06\xa3\x76\x78\x29\xd7\x83\xfe\x39\x5b\xd0\x41\x2c\xfe\xfa\x19\x6b\xd3\x07\x1e\xc3\xca\x57\xce\xe9\x59\x76\xd2\x17\x87\xc6\xfa\x8c\x1a\x53\xe4\x2d\xbb\x35\x03\x52\x96\x2b\x72\xd2\x8f\x71\x88\xce\xb3\xea\x8f\xd4\xa8\x57\xf2\xf1\xa0\xe8\x9d\x71\x8a\xf1\xf5\xab\x3c\x09\x39\xb3\x4f\x42\x24\x21\x5c\x3c\xf1\x6e\xf9\xd3\x69\xb4\x10\xcf\x69\x4e\x38\xd0\x53\x19\x90\x9e\xf7\xc2\x75\x5d\x41\x62\xf9\xb7\x95\xe5\x7e\xce\xd4\x3b\x58\x80\x41\x32\xff\x83\x36\xd2\xcd\x8e\xa7\xd3\xfe\x2e\xb6\xc5\xcd\x0e\x75\x58\x1c\x66\x72\x30\xf5\x9d\x32\x06\x53\x4f\x2f\xf3\x2c\x5d\xb3\xce\x09\xb5\x7f\xce\x16\x3d\x7a\x90\x86\x6c\xf4\x3a\x0c\xde\x26\xb3\x38\x6f\x58\x9a\x9b\x11\xd1\xb0\x50\xce\xd1\x83\x86\x9d\x9b\x4d\x03\x3f\x67\x2f\x5f\x26\x73\xc7\x74\x92\xeb\x41\x5d\x6b\xbf\x61\x85\x15\x9a\xa3\x82\x6b\xb5\xa7\x0b\xd5\xb4\x63\x42\x31\xa2\x0c\xa5\xd0\x97\x83\xa5\x47\x4e\x0e\x91\x39\x74\x9c\xd3\x30\xb3\x25\x53\x0a\xa5\x68\x30\xad\x62\x94\x44\x8f\xb7\x2d\x0b\x20\xb1\x22\xbf\x13\x5e\x6a\x8b\x69\x9c\x1d\x5f\x26\x33\x0c\xa2\xf3\x2a\x0a\x59\x9c\x7f\x64\x43\xc3\xfc\x86\x10\x1f\x24\x73\x89\xf5\xb5\x75\x1d\x39\xa7\x25\x1a\x18\x19\xc9\x1f\x64\xce\x20\x99\xb7\xf0\x90\x07\x9a\xaa\xaf\x2e\xbc\xc0\x23\xba\xaf\x5f\xc1\x2a\x47\xc7\x38\x54\x90\xfa\x26\x4a\x9a\xa8\x89\x51\xcb\x58\x7e\xc4\xe9\xe0\x98\x39\xe6\x4c\x50\x0d\x7b\xc5\x02\x72\x5a\xe8\x26\x8d\x12\x32\x50\x93\xb6\xc3\xb1\xd6\x33\x35\x5c\xf7\x76\x77\xa1\xd9\xe1\x5d\xd0\x63\x43\x69\x26\xb2\xf5\xa8\x56\x4d\xd9\xea\x69\x6b\x63\x75\x55\xc7\xa1\xa4\x3c\xd4\x70\x27\x65\x16\x39\x93\x63\xd7\x15\x63\xac\xc6\x0f\x73\xa6\x42\xdb\x44\xfc\xa7\xfa\x6d\x38\xfd\x13\x3b\x4a\x14\x8e\x78\x11\x26\x12\xcc\x32\x25\x6d\x4e\x97\x2e\x65\x99\xf5\x4a\x9a\x98\xae\x57\xca\xaa\xac\x47\xca\x5d\x45\x2d\xca\x30\xeb\x68\x0d\x4d\x17\xd7\x69\x16\x45\x46\x61\xec\x47\x1f\x54\xbf\x8d\x9a\x0f\x1e\x28\x7a\xe8\x9f\x32\x3a\xd2\x9e\x4a\xa0\x1a\x46\x38\x32\x16\xe7\xe9\xc2\xe4\x15\xf9\xc4\xed\xe6\xd6\x37\x8e\x4b\xd0\x5a\x3a\x24\x24\x31\x0d\xf4\x64\xfb\x3b\x46\x5f\xc6\x7e\x66\xf6\xc4\xe8\xd8\x83\x07\xd6\xb7\xbc\xe0\x2c\x71\x46\xb7\x96\x35\x86\x4a\xab\x15\x25\x5b\x52\x3f\x34\x0a\x89\x0d\x8a\x51\x48\xa4\xd8\x90\xe4\xd6\xc4\x02\x26\x13\x2d\x7e\x14\x67\x3e\x46\x41\x99\x64\xb1\x88\xcd\x87\xdd\x82\x5f\x14\xfe\x8f\x36\x52\x46\x11\x4a\x30\x8b\x98\xbb\x1d\xa3\xa0\x99\x6c\x71\x4e\x32\xcb\x8d\xd2\xe2\x5a\xde\x10\x05\x68\x0a\xc8\xd2\x83\x0b\xae\x9f\x48\x57\x7c\xba\xc1\x8b\x30\x0b\x07\x61\x14\xe6\x0b\xe9\xe8\x82\x8f\x92\x31\x84\x7b\xd0\xc0\x32\x11\xc3\x0d\xd9\x38\x0c\x02\x16\x1b\x00\xf4\x81\x58\x43\x06\xc0\x32\x72\xf3\x64\xda\x83\xb6\x64\x18\xcf\xea\x9d\x6b\x0e\x3c\xc6\xcc\x8a\xfc\x9c\xfd\x1f\x15\xca\xda\xa4\x8a\xca\xfe\xa7\x1d\xe9\x1a\xc4\x7a\xa0\x86\xe8\xc1\x83\xeb\xb5\xe0\x0a\xab\x8a\x93\xfb\x23\xb1\xa7\xa3\xf0\x78\xa4\x05\x4b\xa8\xad\xb9\xfb\x8d\x00\x2f\x5c\x4b\x9c\x9b\x44\xd0\x8d\xef\x94\x0b\xfc\xd3\x2c\xb0\xd8\xb1\x17\x12\x7b\x9d\xa5\xf5\xbc\x5b\xab\x21\x54\xe8\x08\xdd\x4a\x25\xa1\x4a\x4d\xe8\x56\xe9\x09\x60\x2f\x65\x2f\xc8\x30\x58\x57\x16\x09\x7a\xb2\x15\xd6\xdf\x2a\x2a\x7c\xbb\x81\xdd\x33\x28\x2d\x63\x2e\x4e\xfc\xb9\xa3\xd1\x6b\xcd\x61\x53\x13\x69\x53\xce\xe2\x17\x52\xd0\x60\xbe\xfc\x4d\xca\xc8\x1e\x58\xd5\xb5\x6e\x02\x4d\x59\xbd\x07\x85\x16\x84\x2c\xd0\x50\x4d\xa5\xa7\x66\xec\xbf\x19\x5b\x9a\x64\x59\xd4\x90\x65\x41\x64\x11\xa3\x5a\x41\x97\x85\x41\x17\xa1\x7c\x59\x84\x59\x98\xba\x58\x0d\x65\x16\x15\x94\x59\x98\x4a\x54\x91\xe7\xc1\x10\x89\x2d\x2d\xde\x60\x57\x09\xaf\x0a\x0d\x4c\x12\xba\x46\x9a\x5e\x79\x46\x8e\x77\x3d\xc5\x8b\xa6\x6c\x27\xf7\xd5\xe8\x21\x88\xfb\xa7\xae\x53\x98\xf6\xa3\x24\x9d\xf4\xa0\xa1\xca\x61\x64\x70\x63\x2a\x6c\x42\x63\x3a\xa7\x58\xe0\x06\x27\x60\xaa\xdb\x50\x2b\xb2\x6b\x49\xc5\xb2\x92\xf4\xe0\x81\x90\xf2\xe6\x94\xfb\xb7\x74\x5a\x74\x5b\xae\x1d\x8a\x06\xd8\xc3\xb2\x96\xb6\x09\x8d\x49\x66\xe7\x91\xc2\x65\xe8\xb0\x86\x12\x2b\x7e\xdc\xc1\xb1\x8d\x82\xdf\x08\xc2\x0b\x63\x65\x33\x7b\x62\x38\x14\x6a\xa4\x6c\x38\xf6\xd3\x3c\x6b\xe6\xb4\x8d\x6d\x8a\x25\xaf\x61\x8a\xd2\x8c\x0e\x2a\x0d\xf2\x1a\x99\x29\x1b\x59\xaa\xf5\xc8\x31\x03\xd9\xc8\x7f\xa4\x5d\x5b\x5b\x31\x8a\xb4\xb2\x63\xee\x36\x34\x75\x3c\x43\x11\xac\x3c\x06\xb4\x06\xde\xd0\xbe\xe0\x8b\xbe\xe2\xb1\xb4\xb9\x2b\xd7\x15\x30\xcd\x7d\xed\xa9\xe5\xd4\x49\xec\xe5\x77\x36\xae\x56\x39\x57\x3c\xb9\xaf\x0e\x8b\xee\x9f\xba\xca\x48\xaa\x25\x3c\x3e\x0a\xbf\x61\x0d\x01\xb4\xa1\x0b\x14\x9c\x32\xd1\x6f\xa3\xbe\x7d\xc6\x6d\x7e\x4a\x03\x2c\xd7\x45\x67\xd1\x58\xe1\x36\xcf\xd9\x8d\x33\xa8\x82\x15\xff\xed\x62\xd5\x60\x14\xed\x30\xcb\x5f\xf9\xc3\x31\x7b\x15\x31\x3f\xad\xf3\x94\xbd\xfd\x4c\x5c\xec\xa8\xe2\xaf\x59\xc4\xf2\x3a\x27\xea\x4f\xb7\x9f\x17\xcb\xff\xca\xea\xbc\x84\x3f\x7d\xd4\x2e\x16\xfe\xbb\x5f\xe7\x02\xfe\xe9\xa3\x4e\xb1\xf0\xd1\x12\xc8\x5d\x41\x33\x8c\x1c\x8f\x53\x30\x03\x3f\xc6\xba\x30\xe4\x95\x45\xa8\x7f\x1d\x8a\x30\x0d\x2f\xfc\x9c\xe1\x6f\xc3\x2a\xc9\x8c\x23\x88\x27\x7b\x57\x70\xc2\xb7\x2f\x21\xcb\x4e\xd1\x89\xe8\x39\x5b\x34\x29\x2e\xe8\xd4\x0f\xd3\x0c\x83\x51\x71\xf8\x85\x58\xe8\x6f\x24\xd2\x8e\xa8\xad\xfd\x1f\x62\x9c\x3c\xd8\x35\xb6\xd6\x62\x3f\xb6\x0b\xa2\x2c\x08\x0b\x2f\xd8\x83\x36\xf4\x64\xaa\xda\xf0\xc8\x07\x72\x43\x3e\x90\x74\x2c\x24\x42\x26\x6d\x6e\x12\xf0\x9f\x05\x48\xf3\x74\x14\x37\x61\xba\x8d\x13\x2c\x79\x6a\xbc\xc8\xc9\x58\x4e\x3b\xb5\x93\xf6\xa9\x47\xc5\x4f\x3a\xa7\xe2\x98\xed\x6a\x63\x63\x6b\x0b\xf6\x83\x00\x26\x2c\x1f\x27\x01\x76\xfc\x93\xea\xe5\xa7\xd6\x86\xfa\x6d\x58\xd0\x0e\x05\xab\xd9\xbc\xb7\x53\x55\xf6\xa4\x11\x20\xa3\x35\x4e\xcd\xf2\xc4\x7c\x95\x15\x5a\x67\xc8\x0e\x26\xdf\x55\x97\x1b\x23\x8f\x99\x2c\x57\x5d\x2e\xb3\xe1\x1d\xe1\x79\x71\xc9\x13\x8c\xaa\x59\x7e\x6a\xf3\xe8\x76\x91\x91\x70\x90\xfe\x55\x17\x75\x81\x62\xd2\x0b\x0e\xff\x95\xe5\xe4\x4b\x97\x86\xdb\xc7\x70\xef\x43\x72\x44\xfd\xe9\x9c\x2d\x3e\x41\x98\xc1\x28\x99\xc5\xe8\x42\xfb\x13\xde\xd8\x7e\x82\x64\x54\xe4\xde\xca\xd9\x60\x73\x3f\xd6\x45\xce\xa7\x5f\x18\xbb\x37\x9b\x8a\xa9\xa4\x4a\x3f\xbc\x42\xa3\x6a\x31\x43\x28\xf4\xaf\x9f\x0e\xc7\x30\x12\xa1\x8b\xcb\x21\xde\x3f\x8a\x04\xdd\x0f\x11\xdc\x7d\xe2\xe7\xc3\x31\x0b\x40\x04\xdc\x45\x0d\xed\x53\xb3\xf3\xa9\x30\xc5\xfc\x2c\x4b\x86\x87\x22\xe8\x24\x22\x47\x66\xd9\x6a\xa2\xa9\x69\x85\x99\xc6\x79\x81\x98\x2d\x94\xd0\x6c\x9a\x0e\x62\xd8\xbf\x08\xd4\x09\x65\x9e\xe2\x5c\x10\xc6\xde\xb6\x5a\x60\x1e\x3f\x14\xc2\xa4\x36\x3b\xf8\x4a\xb5\xc4\x3b\x26\xc6\x15\xec\x73\xbb\x90\x4c\xbc\xc7\x67\x2c\x7f\xe7\xcb\x73\x84\xaa\xb8\x1a\x4f\x89\x89\xe0\xe5\x2c\x8c\xf2\x66\x18\x8b\xd9\xcc\xf5\x04\x32\xad\xcd\xf0\x3d\x2f\x06\x35\xbd\x60\x69\x38\x0a\xc9\x09\xf3\x80\x01\x79\x06\x6c\x71\x1c\x79\x53\xf4\x49\xa2\x16\x76\x75\xcb\xc2\x8c\xde\x83\x06\x69\x42\x0d\xb7\x6a\x16\x99\xb5\x2b\x28\x71\xbb\x10\x3a\x14\x97\xe1\x1f\x6c\x21\xcc\xca\x2b\x57\x8c\x27\xed\xaa\xf9\x14\xf8\xb9\x8f\x57\x3f\x9f\x26\xfe\xf4\xd3\xb2\xe9\x41\xdd\xbc\x82\x89\x3f\x45\xae\xe7\x7f\xf3\x04\xfe\x35\x63\xe9\xa2\x55\x15\xec\x56\x4e\x0f\x45\x6a\x9e\x52\x98\x1a\x0f\xed\x59\xc1\x61\x72\x8c\x0a\x8c\x7f\xc6\xf2\xb7\xfe\x94\xef\xc7\x9c\x89\x3f\x2d\x30\x3d\xf6\x60\x97\x57\x6d\xf5\xfb\xfc\xa3\xdf\xdf\xd1\x9c\xa9\xc8\xe2\xf0\x4a\xc8\xbb\x7b\x58\x45\x3a\xbb\xc3\xfb\xab\x5d\x68\x10\xd6\x0d\xd8\xd3\x3f\x7b\xd0\x18\xfb\xd9\xb8\x71\x8a\xd5\x7a\x84\xd9\xc4\x9f\x56\xf3\xba\x46\xb2\x62\x7c\x57\x71\xc4\xf5\xd7\x0f\x91\x74\xe9\xa7\xb1\x11\x4d\xe3\x8c\xe5\xc7\x6a\x53\xf2\x3b\x3a\xed\x95\x59\x22\xb0\xaf\x91\x62\x6f\x6e\x8c\x8c\x89\x3f\x25\x04\x8d\xb4\x80\x0d\x66\x67\xa3\x62\x82\xf1\x1d\x25\x67\x16\x22\x31\x4b\xfd\x9c\x7d\x48\xd9\x28\x9c\x17\x1b\x38\x63\xf9\x6b\x3f\x1b\xbf\xf2\x2d\x7c\xc2\x80\xc5\x39\x6d\x74\x8d\x82\x87\x71\xce\xd2\x8c\x21\x0d\xff\xc1\x16\x95\xe1\xa0\x42\xa3\x4c\x6d\xbc\xa6\xe7\x66\xd4\x52\x5d\x7e\x59\xac\x24\x0b\x6e\x31\xa6\xd4\xff\xa3\x2f\x87\xbe\x79\x44\x20\xdd\x40\x61\x7a\x24\x83\xcf\x88\xba\x0e\xa0\x8f\x3d\x17\xe4\x10\xed\x56\xcf\x2c\x5d\x55\x19\xfc\xcb\x95\xbd\x18\x04\xae\xc2\xb8\xbf\xf8\x00\x00\x4d\xfd\xe5\xb1\x0d\x6f\x58\x52\x90\x42\xe5\x6b\xba\x25\x83\xcf\xc2\x38\x1f\x58\x16\x85\x71\x0e\x71\xd2\xe4\x9a\x7e\xc2\x41\xb5\xe5\x3a\xf6\xe1\xe3\xc1\x2f\x87\xff\xa7\xff\xe6\xf0\xe8\x18\x76\xe1\xa4\xf1\x07\x1b\x9c\x87\x68\x7b\xf5\x36\xf9\x93\xff\x79\xcf\xff\x37\xc9\x1a\xa7\x3b\x58\xfe\xf0\x5d\xff\xcd\xe1\xbb\x83\x7e\xb1\x5e\xf3\x12\x2b\x36\x79\xe9\xe6\x24\xf9\x93\x7e\x24\xe2\x3b\x6b\x1a\xf5\x5f\xbd\x7f\xfb\x61\xff\xf8\xf0\xe5\x1b\x0e\xe5\xfd\x87\x83\x8f\xc7\xff\x44\x10\xea\x14\x83\xd7\x51\x1f\xef\xd3\xf0\x8c\xec\xc4\xf4\x91\x07\x46\x33\x15\x0b\x7e\xc5\x1c\x5d\x3e\x83\xcd\x75\xa4\x98\xed\x4c\x53\xf6\x9e\x8f\x57\xcc\xe6\xf9\x7b\x1c\x55\xbd\x78\xa0\x07\x47\x6b\xfa\x6a\x1f\x8e\x62\xe8\xcf\x35\x0c\x57\x1e\xfa\x50\xa2\x04\x68\x98\x9e\x54\xc8\x1c\x23\x49\xdb\x33\x89\x34\x07\x17\x54\x0b\x23\x4c\xd9\x11\x4e\x01\x70\x29\x95\xcf\xc1\xf0\x5c\x48\x44\x00\x87\xa1\x3f\x61\x11\x79\x42\xc8\x13\x08\xfc\x6c\x8c\x1f\xbc\x02\x2d\x6e\xb0\xfb\x42\xfc\xda\x90\x7c\x51\x2d\x26\xed\x54\x93\x92\x32\xd9\x89\xfd\x49\x21\x1c\xab\x3f\x61\xad\x94\x61\x80\x16\x67\xcb\x39\xd9\x6f\xfe\xcf\xa9\xbb\x75\xe6\x19\x02\xeb\xa2\x60\x47\xd4\x68\x36\x60\x13\x2e\x5a\x79\xf2\x26\xb9\x64\x29\xc2\xa5\x8d\x98\x5b\xdf\x5b\x3f\x08\xd0\xa0\xc0\xcf\x43\xae\xf7\xe0\x29\x11\x4c\x71\x0d\xe0\x85\x1d\x69\xf2\x29\x5c\xf9\xf2\x3e\xd3\x9e\xd8\xe8\xf3\xf2\x85\xa3\x2a\xd7\xa0\x41\x29\x1b\x69\xa1\x25\x86\x30\x11\xab\x9e\x01\x2a\x7c\x3c\xd1\x6f\xd7\xba\xad\x96\x27\x71\x05\xc9\xf2\xe5\xca\x03\xb3\x09\x65\x11\x42\x1a\xa0\x5e\x8d\x51\xe3\x94\xa1\xb1\x8c\x69\xa4\x5c\x9e\x73\x06\x11\x07\x44\x85\xe1\xfa\xff\x2e\xdd\xad\x65\x43\xc5\x07\xe9\xb7\xe9\xb4\x38\x48\x04\x17\xc7\x80\x54\x01\x12\x4f\xc6\xe1\x96\x21\x40\x5a\x29\x0b\x66\x43\x66\xdc\xbf\xa6\x2c\x9b\x45\xc2\x6c\x8d\x77\xd5\x83\xd0\xdc\xa5\x98\x7d\xd3\x1b\x93\x62\x6b\x46\x2f\x94\x34\xf9\xaa\x7e\x35\x13\x14\x2c\xee\xd6\x59\x38\xf1\xaa\xc4\x1a\x46\xe0\x87\xc6\x7f\x76\x1a\x6e\xa5\x4d\x92\x79\xe2\x27\xf1\xad\x1a\x21\xd9\x07\xd8\xd4\x74\xf6\x14\xb2\x74\xee\x7a\xe5\x91\x9f\x43\x29\x1a\x6c\x85\x86\xbe\x14\x75\xa2\xe4\xcc\xd1\x0a\x6f\x5f\xc8\x74\xa4\xad\x23\xbf\xc8\x9f\x10\xff\xe5\xf2\xea\xd2\x8a\x49\xa4\x79\x7a\x79\x5f\x32\xa1\x78\xb3\x5c\x0d\xa7\x0d\x33\x46\x16\xbf\xf0\x53\x3e\xb9\x6c\xc9\xe1\xc7\x0b\xf1\x47\xcd\xa4\xa2\x82\x26\xbf\x8d\x97\xbd\x83\xd9\x59\x59\x56\x68\x0e\x08\x73\x36\x91\x43\xcb\x3b\x4c\x7c\x8e\xa9\x3b\xd6\x38\xf0\xa4\x1d\x1d\xe1\xac\xae\x23\x54\xdf\x4f\xcf\x32\x4f\xb1\xae\xee\x97\x6c\x97\xd7\x55\x38\xec\xbe\x30\xd3\x8d\x8e\x95\x54\xd1\x51\xa9\x6b\x23\x27\xf7\xb9\x88\xab\xe9\x9d\xec\xd9\x5f\xc3\xca\x8e\xec\x5e\x71\x6d\x14\x8c\xa2\xb4\x5c\x42\x40\x4c\x00\xda\xf7\xa2\x94\xc8\xfd\x33\xd4\x39\x5b\xf8\xfd\xf5\x2b\x34\xfc\x38\x89\x17\x93\x64\x96\xa9\x6e\x36\x74\x2d\x3f\x3d\x7b\x27\x62\x6a\x36\xf0\x6e\x86\x43\xe5\xba\xbe\xf3\xdf\x47\xef\xdf\x09\x6b\xfc\x70\xb4\x70\x5b\x9f\x93\x30\x76\xf8\x6a\xef\xf2\xc9\xe7\x36\xc4\x60\x4b\x16\xe0\x89\x3d\x10\x10\x08\xe4\x26\x34\xf8\x50\xf1\x34\x1b\x18\x97\x22\x6e\x81\x5b\x52\x96\x5d\xc3\x2c\x7c\xd3\x49\xeb\x02\x24\x31\xb0\x0b\x96\x2e\x64\x08\x7d\xae\xea\xa1\xe1\xa1\x3e\x4b\xd5\xfb\x37\x4f\xa4\x56\x2d\x2c\x55\x9b\x1a\x33\x4d\x31\x86\x4a\x74\x46\x04\xd0\xe2\x1f\x53\x9f\xe0\x79\x95\x72\xd3\xd8\x0f\xd7\xca\xaa\x6a\x41\x85\x3a\xea\x28\x76\xf0\xaf\xd4\x2c\xdd\xb2\x80\x5a\x61\xf1\xa5\x65\x17\x8f\xc1\xb8\x9c\xe3\xe5\x05\x4d\xcb\xc4\xa9\xdd\x0a\x96\x32\x54\x3f\xed\x1c\x72\xa0\x5d\x4b\x29\xca\xbd\x05\xad\xaa\x56\x76\xa4\x51\xca\x32\x41\x23\x41\xa2\x4c\x58\x66\x48\x31\x5e\xde\xf7\xea\x14\xdb\x08\x32\x93\x96\x8f\x96\x44\xe8\xae\x26\x12\xba\x42\x26\x74\xb5\x50\xe8\x0a\xa9\xd0\x15\x9f\x5a\x2e\x28\xa9\xd0\x2d\x8b\x85\xee\xa9\x52\x21\xf0\x0d\x3a\xce\x52\xfb\x28\x5d\x4a\x5d\xa1\x94\x5a\x2a\xc7\x28\xce\x08\x64\xd6\x4a\xf9\xc4\x91\x0a\xc1\xd6\x16\x8c\xc2\x34\xcb\x4d\x87\x52\x7c\x2a\x0e\x59\x78\xc1\x60\x32\x8b\xf2\x70\x1a\x2d\x34\x2e\x12\x1c\xaf\xf3\x0b\xba\x89\x8a\xb3\x93\xf6\xa9\xd4\x2a\x72\x3f\x8c\x32\x99\xde\xca\xa2\x70\xc8\x28\xde\xef\x12\x41\xab\x36\x93\x58\xb5\x86\x19\x46\x71\xe9\x94\x73\x14\xa3\x14\xd9\x91\x36\xba\x02\xa7\x4a\x31\x29\x16\x54\x77\xc7\x8e\xb7\xb9\xe4\x5c\xa4\x22\xcb\xd4\xa9\xad\x3c\x19\x95\x28\x90\xf6\x75\xc0\xf0\x0a\xd7\xde\x10\xa0\x99\x1c\x97\xab\xba\x6b\x3c\xad\x40\x06\x53\x5f\xa7\x6c\x2e\x44\xb9\x04\x0d\xca\x57\xc6\xd4\x0c\x29\x76\x52\x3c\x37\xcc\x6d\x4c\xf6\x9a\x5d\x2c\x8b\xe7\xd2\xd0\xf1\x5c\x1a\xa2\x4e\xe1\xe8\x48\x7c\x2a\x9c\xf9\xb7\x33\x4c\xe2\x80\xcc\xc4\xc4\x63\x5b\x0f\x7c\x0f\x06\x1e\x0c\x3d\x08\x3c\x60\x6a\x75\x25\x8d\x90\x23\xf1\xe0\x81\xf2\x54\x20\xd4\x20\x6c\x5f\x0d\x53\x83\x2c\x67\x30\x0b\x1b\x35\x95\x4a\x6a\x04\x75\x64\x55\xc1\xf0\x7a\x67\xd4\x72\x1a\x6f\x92\x33\xb4\x05\x01\x71\xc6\x83\x97\x6d\x2c\x4d\x93\x14\x26\x2c\xcb\xfc\x33\xa6\x18\xa2\xa0\x3d\xe2\xbc\x52\x5d\xd3\xf0\xaf\xc7\xa0\x88\xc3\xdb\x30\xa6\xf3\x69\x36\x1f\x32\x14\xc3\x90\x0c\x87\xb3\x34\x65\xc1\x0e\xcc\xf8\x5e\x6f\xcc\x20\x4e\xe2\xe6\x44\x16\x0c\xd8\x05\xb0\xf8\x22\x4c\x13\x8a\xd1\xcf\x47\xb7\xc1\x05\x0e\x2f\x39\x9a\x45\x51\xb1\x0b\x71\xc0\x05\x3b\x62\xea\x47\x30\x66\xd1\x74\x34\x8b\x70\x74\xc2\xf8\x2c\x6b\x35\xdc\xa5\xb6\x53\x42\x4e\x9d\x14\x47\xed\x74\xa7\x58\xec\x50\x5c\x09\xb6\x0d\x9b\x1d\xab\xb3\x44\x19\xad\xd0\xff\x57\x66\x6f\x20\xed\xfb\x7d\xc1\xe5\x28\xe9\x24\xf4\xcd\x4d\xa3\x59\xcb\xda\x01\x4c\x57\xec\xdf\x20\xec\xc2\xa3\xa5\x41\x0d\xcc\xb0\x0b\xe2\x34\x7e\x1f\xb2\x29\x1b\x86\x7e\x14\xfe\xc9\x02\xe0\x72\x14\xc7\x76\x04\x9f\xfa\x7c\x6a\x7f\xc2\x35\x02\x6f\x69\x32\x8c\xbf\x9a\xcc\x72\x0c\xc8\x9a\xa4\x39\x66\x85\x39\x2e\x57\xa4\xa5\x8f\x93\x34\x1f\xfb\x71\xb0\xca\x5d\xd7\x09\x3d\x6d\x2c\xdc\x76\x11\x34\x48\x2e\x58\x6a\x1d\xec\xcb\x87\x41\x57\xaa\x41\xac\xa8\xcf\x2d\xe2\x8b\xe4\x9c\x05\x30\x65\x12\xa5\x30\x89\x0b\x07\xfe\xa2\x61\xf3\xd0\x3f\x66\x97\x5c\x0d\x9a\xb2\x40\xdc\x5b\x15\x6e\xbd\x78\xda\x5b\x7f\x2a\x6f\xbc\x64\xdb\x2b\xdd\x2f\x53\xa7\xec\xdb\x65\xf3\x72\xcc\x53\xc2\x3f\x23\x2f\x5c\xb4\xc6\x8a\x15\x10\x99\xf3\x9a\x9b\x66\xaa\x29\x2e\x97\x61\x57\xa1\x27\x6e\xd5\x28\xdd\x23\x1c\x3d\x6a\x5b\x6c\xdb\x4d\x15\x75\x16\xe5\x35\x37\x68\xa2\xf7\x15\x77\x0a\x4b\x7d\xf8\xaf\x78\x67\x74\xb4\x98\x0c\x92\xba\x60\xee\x4f\xc5\xe5\xd9\x43\xf8\x2d\xe3\x83\x93\x99\xb7\x66\x9c\xef\xf8\xe6\x90\xeb\xff\x9f\xc8\x2a\xee\x13\x79\x3b\xf1\xb9\xea\x22\x75\xbd\xc3\x77\xbf\x1c\xbe\x3b\xc4\xf3\xbe\x0e\x6c\xe1\x7c\x97\x46\x0b\x74\x56\x95\xc1\x27\xdc\x96\x7d\xe2\xac\xe7\xcb\x4d\x26\x1e\xb3\x8e\x28\xf4\x70\x9c\xe4\x3a\x23\x49\x21\x43\x9c\x97\x71\xf7\xc3\x2b\xb1\xd5\x3b\x56\x9b\xd9\xe2\x2d\xae\x62\x48\x82\xfb\x95\x80\xda\x8c\x29\xae\xab\x0c\x5e\xcc\x93\x7f\xb0\x85\x53\x38\xde\x11\x0b\x10\xb5\x63\x5e\x25\x7d\xfd\xaa\x28\x2c\xea\x14\x8f\x52\xe8\x88\x84\x98\x41\xec\xc9\x44\xec\x18\x82\xb6\x09\x0d\x12\xb9\xf2\x40\x52\x16\xd8\x85\x46\x1b\xd7\x36\x87\x53\x55\x20\xb4\xbb\x0b\x4d\x49\x6f\x17\xf6\xa0\xd1\x6c\x37\xa0\xb7\x94\xbd\xb0\x43\x15\xbc\xb5\x34\xda\xc2\x9d\xf2\xd6\x86\x88\x55\x3b\xf0\x33\x06\xe1\x64\x4a\x1b\x2f\x52\x49\x92\x91\x32\xbe\x88\xc2\x73\x46\xe2\x70\xfe\x09\x97\x29\xfe\x3b\x8c\x3f\x09\x3b\x00\x7f\xc8\x57\xc4\x0c\x7c\x0e\xee\x13\xee\x4b\xf0\x5d\x2c\x72\x55\xc0\x72\x96\x4e\xc2\x98\x16\x48\x36\xcf\x53\x36\x99\x4d\xc4\x91\xd1\x7a\x06\x01\x37\x14\x91\xea\x63\x89\x88\x2c\x41\xd0\xbd\x40\x18\xc6\xe7\x4c\x44\x0a\xa6\x24\xc1\xe2\xd9\xf2\xab\xd5\x72\xb7\x0d\xbe\xe6\xc4\x3f\x10\x05\x8a\x72\xd6\x33\x5a\x5e\x5d\xe6\x9a\xb6\x3b\x2b\xd8\xea\x88\xc9\x03\x96\xd0\xd4\x9a\x01\xd7\x71\xf0\x19\x83\x92\xae\xf2\xfc\x53\xa9\x58\xb2\xcc\x3d\x21\xeb\xf9\xdc\xe0\x88\xcf\x30\xc2\xa9\xa9\x60\x19\x7a\xc3\x9e\xae\xc7\x8b\xc8\xdf\x0f\x1e\xc0\x3d\x35\x73\x45\xa2\xb2\xde\xa3\xbb\x60\x4d\x13\x59\x80\xe8\xc4\x9b\xd3\x25\x5d\xfb\x89\x8f\xc6\x47\x36\x65\x1b\x32\x8a\xc9\xaf\xc4\x42\xc9\xce\x62\xd9\x54\x36\xc7\xb0\x62\x46\x7f\x07\xb7\xf4\x6b\x46\x7c\xe1\xda\xa2\xb5\xa7\xf1\x61\x17\x36\x79\x2a\x34\x77\xf9\x0e\x40\xfb\x0c\x2e\xc8\x4f\x1f\x36\x61\x00\x0f\x21\x97\x1b\xb0\x0a\x77\xc0\x8f\xbe\x83\x3b\xe0\x1b\x07\x8e\x09\x18\xde\x2a\x4d\x93\xc8\xcf\x19\x45\xec\xb9\x9d\x77\xfe\x61\x32\x5d\xdc\x2e\x44\xc0\x30\x89\xf3\x30\x9e\x25\xb3\x6c\x4d\x57\xc4\xc1\x76\x1f\x67\x6f\xad\x43\xcc\x47\x6b\xfa\xdc\xec\x70\xd0\x06\xbd\xea\x3d\x6e\xb6\xd7\x74\x4d\xda\xed\x5f\x83\xfa\x93\xe7\xeb\xba\xb6\xed\x4b\x95\xa8\x16\x76\xb7\xbb\xa6\x5b\xe0\x47\xfd\x3e\x59\x96\xd5\x7b\xa9\x7d\xd6\x26\x1f\xa4\xc2\x11\xdb\x2c\x0e\xb9\x7c\x39\x69\x7b\xd0\x39\x35\x6f\xd7\x2b\xf8\xb1\x3c\x2d\x1d\x9c\x8f\x0e\xcd\x4e\x25\x0e\xf7\x0c\x27\xf3\xc6\x55\xbc\x33\x87\x26\xf8\x2e\x6c\xc1\x60\x47\xd9\x55\xf7\xae\xb7\x8a\xb7\x28\x56\xf9\xd6\x7e\x50\x08\xba\x60\xe1\xfe\x2a\xf2\x27\x53\xc7\x4a\xaa\x3c\x90\x37\x7a\x27\xac\x88\x8a\xb3\xd2\xd1\x52\x68\x17\x36\x07\x62\xfb\x58\x04\x63\x76\x79\x0e\x3f\xef\x82\x2f\x36\x19\x73\x78\xb1\x0b\x03\xd8\x83\x0e\xf4\x20\x70\xe6\xee\x0e\xc5\x1b\xbe\xb2\x91\x4f\xcb\xc8\xa7\x37\x47\x3e\x85\x5d\x1b\xd2\x6a\xc8\xe7\x06\xf2\x39\x47\xbe\x0d\x7b\xe0\x43\x0f\x72\x8e\x7c\x07\xf6\x60\xc0\xd5\x47\x27\xaf\x41\x7e\x10\x4e\xfc\xa9\x13\x24\x13\x3f\x8c\x3d\x48\xfd\xf8\x8c\x79\x36\x11\x3d\xa8\xe8\x0d\x92\xbb\xcd\xe9\x8d\x35\xd1\xe0\x30\xe8\xe8\xef\xce\xa9\x07\x29\xcf\x47\x88\x98\x9d\x76\xd4\x67\x07\x77\xf5\x7c\xc5\x0f\x3a\xf0\x33\x04\x6d\x57\x00\xb3\xfa\x1f\x74\x3c\x9e\x25\x01\x59\x79\x69\x87\x27\x23\x4d\xf0\x0c\xa3\xaa\x7a\x9b\xa3\x54\x53\xbd\xcd\xf1\x31\xb5\xf2\x4a\x6e\x48\xdb\x4e\xd0\x76\xe6\x2e\xd1\xce\x24\xdb\x34\x89\x16\x6b\x13\xee\x33\xec\x8a\xc7\x45\x61\x2c\x20\xa8\x63\x62\x04\xa4\x4e\x6f\x9b\xa0\x54\x33\xce\xdc\x7c\x97\x4d\x9b\xdb\xcf\xae\xda\xf5\xd6\xa4\x87\xa8\xd8\xa1\x72\xb5\xb5\x05\x1f\xe9\x64\x17\x1d\xcf\x32\x7c\x69\x2e\x46\x8a\x6b\x9c\x34\x12\x34\x70\x9f\x4f\xf9\x80\xc8\x41\x95\x0c\x4a\x09\x6a\x78\xc5\xf1\xad\x6b\x1f\x18\x03\x21\x2f\x47\xb9\xba\xd0\x95\xad\x4c\xc2\xcf\xf0\x59\x35\x72\x12\x96\xd6\x55\x89\x56\xc8\xf9\x4b\xfc\x84\x4d\x10\x16\xde\x00\x29\xd5\x29\x8c\x2e\x32\x19\xaf\x22\x7e\xe9\x1a\x57\x15\xe7\xcd\x38\xe4\x6a\x1e\x86\xab\x38\x15\x31\x57\x4a\xbe\xf8\x72\x01\x37\x08\x33\x36\x14\xf2\x4d\xb2\xc5\xdc\x83\x8e\xc7\x7b\xd8\x84\x8e\x35\x7f\x39\xde\x0e\xef\x30\x72\x57\x79\x5a\x72\x5d\x40\x19\x5f\x29\xcb\xb0\x0d\xb0\xed\xab\xc4\x50\xb7\xa8\x39\x51\x5e\x7e\x29\xe9\xde\x42\x2a\xc8\x5c\xfa\xd0\x99\x26\xe1\x44\x11\x33\x49\x17\x1c\xa2\x64\x13\x45\xe8\xc3\x25\x31\xbe\xb5\x55\x14\xbb\x5c\xb6\x71\xb2\xe6\xfe\x39\xcb\xc0\x97\xfc\x43\x3b\x84\x39\x84\x31\x9c\xf8\xde\xe0\x14\x37\x81\xa9\xb1\xc1\x19\x26\x69\xca\xb2\x69\x42\x1c\x8a\xbb\x29\xbe\xef\x03\xbc\xc4\x3b\x69\x7b\x9d\xd3\x16\x6f\x2d\xad\x68\x2d\xd7\xad\x55\xd5\xbb\xa6\xa9\x1a\x04\x5b\xe6\x88\x48\xdd\xca\x59\x51\x3c\xca\x39\xc3\x57\x6c\x35\x5b\xc5\x0c\x31\xd3\x8c\xda\xa8\x03\xac\xae\x43\xc9\xb5\xd5\x84\xf0\x70\x4b\x6d\xba\x70\x90\x60\x57\x3b\xb5\xe2\xff\xa6\x21\x1b\xb2\xcb\x50\x27\x24\xb3\x7c\x3a\x33\x90\x99\xce\x72\xdb\x6b\x4d\xca\xb2\xa1\x1f\x69\x27\x1f\x0a\xc2\xca\x62\xec\x05\x74\xf1\x71\x25\xca\x4c\xe8\xd1\xa2\x43\xf3\x81\x5a\xe7\xbb\xc2\x98\xfe\xc6\xe8\x27\xc0\x98\x2a\xd8\xb8\x9a\xbb\x0a\x2b\xc2\x69\x5e\xd8\x4d\x38\x02\xde\xd7\xaf\xea\xe7\xae\x46\xb8\x28\xae\x89\x40\x7b\x2b\xa8\x1f\xbd\xa2\x68\x37\x73\x5d\xd7\xd9\x9c\x6b\xf1\x82\x98\xb5\x42\xb2\xe2\x32\xa2\xa5\x14\xef\x2c\x1d\xea\x32\x47\x55\x76\x5e\x63\x2a\x17\x14\x81\x70\x85\x72\xa7\xd1\xbf\x5e\x01\xe9\x15\x98\x94\x63\xbc\x30\x02\xb3\x10\xca\x8a\x63\x15\xca\xfd\xe2\x66\xad\x70\xad\xc9\x37\xdf\xaa\xd6\x2a\xba\xb9\xe4\x58\xce\x07\x0f\xb7\x4e\xe9\x70\xbe\xbf\xcc\xa3\x9f\xa1\x21\x57\xa9\x92\x9e\x66\x4f\x1c\x25\x6b\x7d\x2a\x76\x50\xce\xbe\x1b\xf5\x4f\x56\x5a\xad\x7b\xb4\x16\x60\xfb\x46\x07\x8b\x68\x5a\x0b\x64\x25\x96\x1f\xf1\x1d\xcc\x12\x54\xef\x08\xad\xdb\x08\x9f\xa0\x28\x7c\x08\x69\xf4\xd8\xa5\xba\x5b\xec\x9d\x12\x4a\x37\x19\x03\x59\xe9\xde\xbd\x7e\x81\x92\x98\x53\x6c\xc3\xee\xd4\x8d\x5a\x2a\xd0\xa3\xd0\x9a\x91\x5b\x8a\x6a\x64\xf4\xf8\xaa\x7c\x82\xb1\xf4\x29\xe4\xf7\x0e\x68\xd4\xa7\x9b\xb9\xd7\x6c\x18\x4e\xfc\xfa\x90\x46\xdd\x6e\x57\x1c\xc6\xdc\xf6\x78\x68\x6e\x29\x2f\xf3\xd5\x54\xac\x22\x96\x95\x3b\x49\xe5\xed\x68\xee\xba\x1e\xcc\x61\x0f\xe6\x27\x9d\x53\xe8\x51\x30\xba\xaa\xc3\xa4\xc7\x4b\x1f\xbc\x7d\xef\xa1\xf8\x26\xc1\x86\xda\x77\x10\x6c\xa8\x7d\xbb\x60\x43\x9d\x6f\x18\x6c\xa8\x73\x57\xc1\x86\x3a\x77\x10\x6c\xa8\x4b\x0f\xa8\x63\x7f\xb2\xa4\xa3\xdd\xbb\x80\x7d\xab\xc8\x51\x26\xa0\xb5\xcf\xc1\x6e\x14\x36\x67\xbd\xd3\xb0\x6f\x1d\x5e\xe8\xb1\xec\x45\x12\xf9\xe9\xf2\x26\xb6\xd7\xec\xc5\x93\x9b\x45\x30\xfa\xf1\x42\xe8\x47\x6c\xa1\x1f\xb1\x85\xee\x34\xb6\xd0\x8f\xd0\x42\x3f\x42\x0b\xfd\x08\x2d\xf4\x17\x0b\x2d\x74\xc4\x84\xab\x92\x2d\x2b\xb0\xd0\x19\xcb\x5f\xb3\x28\xf7\xf7\xe3\xb3\xe2\xd3\x2c\x23\x83\x8b\x90\x34\xc7\x9f\x9c\x28\x01\xfe\xd2\x67\x6d\xb8\x56\xae\xb0\xa9\xa8\x58\x9a\x4f\xee\x8f\xc5\x89\x44\x3e\x3e\xe2\x60\x70\x5b\x21\x9b\xe0\xd3\x46\xb5\xac\x5e\x48\x05\x26\xc2\xea\x08\x4c\x6d\x45\xaa\x2b\x7b\xb0\xfd\xf8\x79\xeb\xf9\xf3\xe7\x96\xd1\x33\x62\xfe\xd0\x80\x68\x9b\x20\xf3\x4d\x7e\x9c\xbf\x0a\xd3\x61\x89\x38\x56\x1e\xba\x3a\xd6\xf4\x18\xa2\x27\xc8\x94\x8d\x5a\x43\xe5\x01\x72\xb8\x50\x69\x0b\x7d\x1c\x19\x84\xb3\x4c\xa6\xd3\x97\xcc\xf3\x45\xff\x30\x0b\x3f\x64\x8e\xa0\x36\x66\xf0\xdf\xea\xec\x30\x3b\x98\xe7\x2c\x8d\xd1\x24\x1a\x73\x75\x8a\xc2\x22\x49\x63\x96\x7e\xb4\xda\x35\xd3\x76\xa4\x59\xfa\x90\xf1\xbd\xb6\x2a\x68\xd5\x7b\x08\x8e\xd1\x16\xdd\xcf\x35\x3b\x2e\x6c\x8a\x0e\x29\x9b\xf3\x31\x43\xbf\x02\x34\x32\x59\x18\x3b\x16\x98\x2d\xab\x11\x17\xb6\x6e\xa8\x37\xca\x0d\xe9\xc7\xfd\xd7\x87\xfb\xef\x38\xe3\xec\x58\xc8\x4b\x0e\x21\x4a\x6e\xca\xb1\x46\xac\xec\x92\xab\xf0\x6e\x35\x06\x0c\x31\x98\xf2\xb4\xe3\xe4\x95\x9f\xe6\x2c\x0b\x7d\xc1\xc4\xc3\xb9\x07\xc3\x85\x67\xf5\xd2\x33\x71\x93\x76\xfe\x64\x9a\xa4\x9c\x83\x26\x23\x72\xa1\x29\xec\xb2\xc2\x0c\x72\xe2\x35\xc8\x13\x3a\x3b\x47\x9e\x93\x3d\xc0\x0f\xe2\x46\xe4\xb1\x6f\xd8\x93\xf4\xee\xfa\x20\x58\x3f\x0a\x63\xd9\x11\x0c\x77\xfe\x5d\xba\x61\xf1\xf6\x43\x62\xcf\x61\x92\x39\xc4\xaf\x0f\x6f\xcd\x86\xae\x47\x3c\x67\x49\x9a\x2f\xa2\xd9\x9e\xf8\xeb\x15\x46\xae\x57\xf8\xf6\x2c\x82\xf4\xac\x2f\x8f\x98\xb8\x27\x66\x98\xfd\x6e\x82\x04\xfd\x07\x1f\x0d\xc9\x4c\x89\xa5\x33\x50\x5c\x75\x2b\xe4\x55\xb7\x4a\x60\x75\x0d\x89\x15\xc6\x45\xf1\xd1\x6d\x19\x69\xc6\xa5\x46\xa9\x98\x91\xa6\x24\x99\x12\xcf\xaa\x94\xb1\xd0\x88\x42\x4a\x9c\xcb\x22\x32\x41\xc9\x2a\x29\x2a\x57\x58\xb2\xe4\x85\xec\x1f\x63\x16\x23\x1f\x52\x5d\xae\x62\x20\x75\x80\xfd\x6b\xe6\x47\xe8\xa8\x6a\xfb\x49\x1b\xf5\xe1\x54\x70\xb2\x1f\x07\x1c\x8e\xf8\x1a\x26\x61\x3c\x0c\x03\xc9\xbc\x5c\xed\x3d\xd0\x88\x1a\x1d\xdb\xa4\x26\xa4\xc0\x11\x0e\xf8\xfc\x34\xff\x20\xc2\xea\x7f\x43\x46\x37\x49\x5e\xb5\x90\x62\xfe\x41\x1c\x7c\x6f\x54\x4c\x6a\xb9\x6a\x18\xa7\xc4\xb2\x8d\xb7\xf8\xc6\xa2\x40\x28\xf4\x57\xda\xf0\xaa\x72\x16\x3c\xe7\xff\x8b\x39\xaf\xec\xeb\xaa\x82\xfb\xac\x4a\x46\x5a\xdb\xa3\x1a\x3c\x6f\x53\xeb\x0e\x34\x6f\xe1\x05\x74\x9e\xb5\x5d\x55\x79\xd3\x60\x26\x78\x61\xa3\x8f\x85\x34\x2c\x8b\xa4\x45\xa4\x55\xba\x42\x99\x9e\x6a\xe2\x63\x1c\x63\x66\xbd\x80\xb6\x75\x27\xce\xb3\xbe\x17\xcf\x98\xb3\xb9\xc8\x33\x06\x3a\xdf\x87\x6b\x2c\x64\x0a\x5c\x83\x77\xa1\x9c\x65\x36\x77\xa1\xf1\x06\x89\x6f\x61\x66\x10\xdf\x4e\x37\xf8\x45\xfe\xdb\xd7\xd5\x0b\x7c\x53\x4c\x93\x7c\x23\xff\xdd\x9c\x7f\x7e\xde\xad\x65\x20\x13\x68\x61\xd0\x8b\xbd\x29\xf2\x3f\xfc\x4f\xc3\x08\x54\xf3\xa5\x8a\x3a\x43\x0d\x62\x68\xd5\xd9\x30\x9d\x63\xe4\xe3\x8a\xd5\xe4\x8f\x30\x1f\xbf\x42\xdd\xad\x72\x4d\xd1\xd9\xb8\xb2\x6c\x57\xac\x2c\xdb\x55\x2b\xcb\xf6\xd2\x95\x65\x7b\xb5\x95\x65\xbb\x6a\x65\xa9\xd0\x73\xb7\x2d\x45\xb7\x76\x09\xda\xbe\x7e\x09\xda\x2e\x2f\x41\xdf\x6d\x07\x24\x1d\x18\x54\xec\x4e\x4a\x9b\x12\xe2\x82\xe1\xbc\x07\x34\x9f\x7a\x86\x12\xd7\xb3\x25\x32\xf2\x6d\x0f\xcc\x35\x93\x77\xa9\x87\xff\xf7\x2c\x72\xf6\xac\x2f\x15\xa6\x10\x89\x99\xe0\xcb\xec\x12\x72\xad\x82\x6a\xa3\x8a\x47\xd5\xc5\x2d\x5d\x47\x15\xae\x2e\x2b\xd4\xf9\x3a\xba\x74\xef\x86\x30\x72\x38\x24\x59\x9a\x37\xa2\x0b\xab\xa1\x4b\xb7\x86\x30\xac\x86\x30\xdd\x4a\xca\xb0\x6a\xca\x74\x0b\xa4\xc1\x6e\xed\xa7\x43\x6b\xe3\xcc\x65\x96\x31\x05\x9a\xc6\xe6\xbe\x89\x24\x6f\x72\xf0\x6a\x91\xb2\x61\xfc\xac\x97\x29\xfd\x46\xd6\xd0\x32\xd5\x33\xd0\x02\xa1\x8d\x69\xdd\xb3\x45\xbc\x41\xfa\x5e\x9d\xf6\x62\x73\xa9\xc4\x57\x0f\x11\x19\xfd\xdb\x7e\x5d\x6c\xd5\x82\xf3\x9d\x21\x4f\xf1\xd3\x54\x22\x50\x42\x9a\x02\x44\x89\xcd\x62\x62\xdb\x6b\x4b\x01\xcf\x67\x2e\x12\x44\x83\x1d\xda\xad\x0c\xcb\xad\xac\xa6\xa9\x50\x0b\x36\xed\xcb\x2b\x4c\x09\x01\x66\x23\xc0\xaa\x10\xb8\x7d\x37\x99\x4d\x4c\x66\x11\x73\x25\xf5\xa6\xc4\xb9\xdb\xf5\x73\xb6\x7e\xd6\x5a\x7c\x74\x8d\x38\xd3\xa7\x17\xfa\x14\x6f\xc9\x44\x36\xa7\x32\x40\x16\x56\x4f\xe6\xed\x9a\xc9\xcc\x6b\x54\x4f\xe7\xed\xca\xe9\xcc\xcb\xd7\x14\xd7\x13\xba\x86\x72\x8f\xee\x8a\x72\x35\xf2\xee\x56\x84\x63\x35\x84\x7b\x54\x4b\x38\x56\x43\xb8\x47\x35\x84\x63\xd5\x84\x7b\x54\x22\x1c\x76\xf9\x66\xb2\x30\x44\x59\x18\xe6\xc6\x7b\x29\x1b\x8a\x21\x0d\x2d\x75\x8a\xcf\x85\x37\x95\xfa\xd7\xff\x34\xac\x57\xee\x5a\x5d\xc3\x89\x14\xda\xf3\x2a\x8c\x0a\x9a\xeb\x5d\xcd\xdf\xd0\x96\x12\xe1\xb0\xaa\x9d\xd5\x54\x63\x6a\xc3\x26\x4b\xb5\xa0\x7a\x61\x49\x4a\x1b\x85\xac\x1a\x85\x3b\x90\xc8\x36\x49\x33\x45\xd2\xa5\xba\xf3\x92\xa1\xab\xd7\x9c\x69\x15\x5c\x45\x23\xac\xba\xd7\x5f\x25\x40\xe2\x8d\xe3\x23\x12\x4a\x4b\xc2\x23\x52\x01\x65\x67\x5a\x1d\xf1\x90\x0a\x15\x1c\x04\x5d\x1f\x51\x90\xaa\xad\x12\x49\x50\x34\xe0\x0a\x6f\x21\x54\xbf\xe8\x28\xa4\x14\xc1\x4f\x76\xee\xe4\x96\x01\xc4\x96\x87\x09\x1b\xea\x08\x4f\xc6\x76\x46\x6f\x69\x44\xce\xc2\x0a\x1b\x66\xef\x6b\x44\xc0\xb0\xf2\xc6\x06\xca\x9b\x1b\x2a\x5b\xb1\xbb\x81\x8a\x1d\x8e\x68\xbb\x62\x8b\x03\xa5\x6d\x0e\x95\x2d\xef\x73\xa0\xb0\xd7\xa1\x72\x6a\x2d\x30\x5b\x97\xf1\x27\x8c\xa6\x65\x92\x1d\xbe\xcf\xec\xd3\xcf\x16\x35\xbe\x7e\xb5\xd0\xda\xdd\x2d\xdc\x2c\x59\x92\x54\xdb\x25\x1b\xc1\x36\xf0\xd8\xd8\x5f\xc8\x8b\xbe\xe5\xd6\x98\x55\xb6\x3c\x8e\xeb\xe8\xf0\x19\x74\x02\xd8\xf0\x74\xe7\xac\x78\x51\x78\x47\xa4\xe8\x6d\x76\xab\x69\x76\xcb\xac\x32\x5c\x49\x02\x54\xee\x09\xc9\x62\x94\xcf\x0d\x96\x0e\x59\x9c\xff\x8e\xa6\xf1\x74\x38\x62\x8e\xb1\x89\x96\x07\x6d\x0f\x97\x65\x0b\x6f\xa1\xfb\x56\x84\xb0\x1a\xa6\x32\x30\xd2\x75\xeb\xdf\xcf\xb0\xfd\xa4\x6d\x8e\x8a\x00\x5a\x75\x02\x60\x85\x29\xb9\xbd\xe6\x5f\xc3\xf2\x3d\x7d\xf1\x37\x4c\x2d\x2a\xc0\x16\x74\xdd\x6a\xde\x5f\x69\xeb\x00\x76\x74\xc2\xa2\x93\x96\x62\xcf\x69\xa7\xf3\x9d\xf7\x38\x56\xf8\x44\x5b\xe5\xb8\x81\x59\x62\x29\xf2\x4c\x83\x77\xae\x51\x08\xcc\xb2\x42\x14\x9e\xaa\x88\xd5\xe7\x8a\x81\x53\x96\x49\x77\x04\xfb\x79\x9e\x86\x83\x59\xce\x32\x62\x65\x2d\x66\xdd\xb5\x1b\xa2\x73\x44\x8a\x46\x88\x31\xe7\x96\x36\x62\x38\x06\xd2\x21\x74\xb4\x0c\xd1\x7c\x13\xf4\x70\xa8\x25\x95\xdd\xfa\x88\x33\xc4\x07\xcb\x03\xce\xb4\x6f\x18\x70\xe6\x48\xca\xa2\xaa\x78\x33\xd6\xf0\xdc\x94\x5c\x43\x24\xd7\x87\x8f\x07\x47\x07\xef\x8e\xf7\x8f\x0f\xdf\xbf\xeb\xef\x1f\x1f\x7f\x3c\x7c\xf9\xdb\xf1\xc1\x11\x19\x8f\x73\x1a\x19\xd4\xb9\xa9\x25\x68\xcb\x17\xee\x04\x31\x26\xfa\x7c\x2d\x00\x3a\x8e\x3e\x9f\x50\xb7\x02\x60\xcd\xc4\x5b\x41\xb2\x66\xee\xad\x20\x99\x33\xfd\x56\x80\xb4\x68\xb8\x1d\x91\x2d\xc9\xba\x06\xa8\x24\x66\xef\x47\x9c\x3f\x9d\x93\xf5\x11\x59\x9f\xd3\x4e\xdd\x8d\x2b\xb7\x36\xfa\xd2\x17\xc1\x87\x6d\xc9\x4f\xed\x12\x5f\xb4\x4b\xe3\xdb\x2e\x8e\x53\xdb\xa6\x77\xbb\x4c\xb7\xf6\x86\x0a\x48\x7d\x47\xb1\x9d\xb4\xb6\x5d\x30\xa2\x5f\x1a\xf6\xe3\x7b\x1b\xd1\x57\x84\xbd\xaf\xb3\xb8\x5d\xd3\xbb\x40\x65\x1b\xb7\xb2\xae\xaf\x80\xb7\xae\x35\xbc\x00\x35\x09\xe3\x97\xf5\xee\x0f\x9e\x6f\x3f\xbb\x1b\xf8\xb7\xb2\xb7\xb7\x41\xad\x6b\x15\x2f\xa1\xf8\xf3\x25\x1d\xde\x7e\xbe\xa6\xfd\x76\x11\xfe\xad\xec\xee\x6d\x50\xeb\x5a\xde\x7f\x93\x57\x22\xdb\x77\xf0\x4a\x64\xfb\x76\xaf\x44\x1e\x7d\xc3\x57\x22\x8f\xee\xea\x95\xc8\xa3\x3b\x78\x25\xf2\xf8\xdb\x3f\x9e\x78\xd2\xef\xab\xc8\xfc\xfd\x63\x36\xaf\xe7\x97\x27\x6b\x4a\x82\xa7\x66\x0b\x6f\xfc\x01\xab\x7f\x3a\xf6\x78\xcd\x4e\x3c\x43\xd7\x21\xb9\x1f\xc6\x2c\xed\xbf\xe1\x5a\x71\x3d\x9d\xd6\xf4\xe7\xf2\xfc\xdb\x3f\x32\xe9\xb4\x6f\xf8\xca\x44\x1a\xc3\xfe\x78\x07\xf2\xe3\x1d\xc8\x8f\x77\x20\xdf\xe6\x1d\x08\xbd\x5e\xf8\x83\x5c\xaf\x1a\xcd\xca\x48\x3f\x99\x64\x06\x22\x28\x57\xdb\xaf\x76\x4c\x36\xd2\x21\x83\x44\x10\xa1\x4c\x85\xff\x08\x5d\x78\xb1\x0b\x6d\x57\x7a\x89\x10\x63\x7c\x6f\xa5\x99\x83\x08\x84\xae\x59\x59\x4c\x1e\xf4\x6d\x92\x0c\x3e\x23\x33\x96\x67\xcc\x8f\x57\x2e\x3f\x5e\xb9\xfc\x78\xe5\xf2\xd7\x7a\xe5\x82\x2e\x46\xe7\x61\x46\x06\xe8\x11\x3a\x8c\x54\x46\xe9\xd9\x22\xcb\xd9\xc4\x7a\x02\x43\xe2\x0b\xf5\x04\xda\xc5\xef\xf3\xca\x37\xb1\x69\xfc\xd6\xd7\x76\x05\xdc\x96\xdc\xdf\x15\x4a\x5e\x73\x91\x57\x28\x7d\xe3\x1b\xbd\x42\xfd\x55\xae\xf6\x8a\x4d\xde\xf0\x8e\xaf\x44\x09\xeb\xb2\xef\x8c\xe5\xc7\xe1\xf0\x1c\xef\x49\x5e\xf1\x31\x6f\x78\xe2\x1e\x0a\x19\x85\xff\x7b\x08\xaf\xfc\x68\x38\x43\xe7\x12\x79\xe9\xbd\x42\x1e\x0e\xcf\x65\x39\xe1\x49\x16\xbe\xbc\x13\x71\x67\x8d\xa2\xc7\xfa\xf5\x42\xb1\x96\x34\xf5\x97\x71\x3e\x9d\xb9\x07\x22\x62\x26\x67\x3a\xa8\xb8\x86\x2c\xa1\x6d\x3c\x25\x52\xd7\x48\xba\x71\xf5\x64\x47\xa6\xec\xac\x7e\x7b\xe9\xdb\xd7\x7a\x7e\xe9\x4e\x6f\xc5\xdb\x4d\x7d\xbf\x67\x05\x0e\x59\x76\xf0\x50\xa5\x90\xaf\xf8\x56\x43\xf5\x54\x3f\xaa\x50\xe7\xf0\xf2\x38\xdf\xe2\x00\xbe\xf7\xda\x8f\x87\xe3\xa4\xee\xe6\xb7\x54\xae\x70\x09\x9c\xa4\xa1\x72\x9f\x6c\xd2\xb2\x65\x64\xec\x98\x57\x90\xb9\x82\x54\xbe\x67\xcb\x2e\xc3\x7c\x38\x06\xc7\xa8\x6b\x45\x27\xf0\x33\x06\x8d\x88\x8d\xf2\x46\xcf\x20\xb8\x05\xb1\xc1\xe2\xa0\x61\xc6\xd8\x1f\xa4\xcc\x3f\xdf\x29\xc0\x48\xc3\xb3\xf1\x32\x20\x78\x94\xb9\x0c\x8c\x8c\xec\x58\x0b\x61\x12\x06\x41\xc4\xea\x41\x14\x6f\xa2\x74\xed\x65\x43\xf6\x7b\xc8\x2e\x5f\x26\xf3\xfa\xb1\x12\x05\x2a\x6f\xea\xbb\xab\x5c\xd5\x77\xeb\xb9\xb9\x5b\xb8\xac\xb7\xa7\x48\xb7\x3c\x47\xf8\x74\xcf\x8c\x02\xf8\x6d\x31\xc3\xc4\x9f\x93\x8c\xe2\x3c\x76\xcd\x95\x74\xf5\x41\x97\xe3\x3a\x08\xd6\x8c\xd5\x80\x91\xd5\x2b\xae\xc5\x31\xdd\x10\x07\x5c\xf8\xb6\xd5\x80\x58\xf7\xc0\x93\x30\x5e\x11\xb1\xba\x23\xc7\x3b\x45\xcc\xe6\x15\x63\x46\xd8\x17\xa9\xda\x28\xce\x38\x8a\x2f\x0c\x8b\x3e\x94\x2f\x64\x58\x47\xfc\x56\xff\x8b\x98\xe9\x3a\xd6\x25\x80\x35\x98\xc5\x3a\xb2\x33\xb5\xdc\x4d\x26\x26\x7c\xad\x7a\x13\xc6\x6c\xa9\x1d\x8a\x2c\x54\xc9\xe5\xdb\xab\x70\xf9\x76\x3d\x97\x6f\x2f\xe5\xf2\xed\xeb\xb8\x7c\x9b\xb8\xdc\x82\x20\xd0\x35\x81\x88\x24\xcb\x9e\x85\x2b\xbf\x08\xa8\x6e\xf7\x27\x6a\x7b\x70\xd2\x18\xce\x1b\x1e\x34\x86\x0b\xfe\x7f\xc4\x08\xc3\x97\xf2\x96\x31\x45\x52\xf1\xd4\xb5\xa6\x1b\x9e\xd8\xf0\xdd\x22\x96\xac\x0f\x8a\x58\xc7\xa7\x27\xca\x8c\x40\x44\xa1\x68\x9f\x7a\x25\xe6\x75\x3d\x61\x6d\xe0\xcf\x65\xb1\x4e\x55\x31\x15\x2d\xe5\xca\x83\x93\xc3\x78\xc4\xb7\x46\x0b\x0f\x9a\xf2\xe7\xa9\x6d\x98\x91\x84\x71\xde\x5e\x45\xd9\xbc\xc5\xfa\x49\xf4\xc1\x5e\x99\xcb\xa7\x81\x41\xe7\xfb\x60\xd0\x39\xb5\x5e\x45\x2a\x14\x84\xca\x72\x33\x93\x83\xaa\x43\xc4\x15\x4d\x0e\x88\x27\x2d\x4b\x80\x51\x18\x45\x3d\x68\xc4\x49\xcc\x1a\x7a\x00\xbf\x25\x12\x92\x9b\x2d\x34\xe6\x9d\x9e\xe0\x89\x96\x31\x93\x17\x3a\xd5\x98\xc4\xf3\xae\x48\xed\x58\x65\x75\xea\xa2\x56\xd4\xde\xe0\x46\xa2\x6c\x20\x12\xa1\x20\x33\x46\xcb\x34\x14\xd0\xa6\x54\xc8\x11\x4d\xd2\x92\x9b\xbc\xb3\x4d\xac\x08\x57\xf2\x84\xb0\x5e\x8b\x23\x79\xc8\xe5\xed\x61\xce\x26\x4b\x85\xa6\x2c\xe4\x24\x53\xda\x4f\x8b\x68\x5f\x46\x70\x11\xc9\x66\xb9\x28\x5a\x6d\x08\x75\x33\x92\x84\xd9\xef\x7e\x14\x06\x92\x26\xd4\xb8\x6b\xca\x16\xa3\xb5\x1b\x52\x3b\x4a\x62\x66\x03\x96\x14\x2b\x18\x24\x2d\x47\x7b\xe9\x7d\xa9\xe3\x5e\x83\x33\xe5\x3a\x95\xed\xde\x45\x27\x2d\x96\x32\x96\x8b\x1b\x5d\xae\x54\x6c\xb6\xcd\xa5\xc7\x92\x27\x82\x2f\x4c\xcb\x34\x58\x95\x71\x79\x37\x9b\xc8\x51\x0d\xa3\xfa\x95\x65\x61\x86\xd9\xea\xbb\xd6\x34\x4b\x52\x6c\x05\xde\xcf\xae\x65\xfc\xac\xa8\x2a\x70\x0d\x41\xea\xc3\x96\x88\xa5\x35\xf6\x51\xad\x12\x61\xaf\xf6\x8f\xca\xab\x7d\x2e\x14\x46\x23\xbf\x5e\x9d\x78\x54\xad\x4e\xfc\x82\xce\x04\xc9\xd7\x82\x09\x48\xa5\xdb\x16\x7b\x69\x72\x6e\x82\xa4\x84\x75\x54\x8b\x47\x5c\xb5\x50\x5a\x04\xff\x51\xd2\x2f\x14\x0a\x3c\x81\x5a\x2a\x6a\x19\xd6\x46\x08\xa9\x58\xb1\x89\x34\x57\x56\xce\x3a\xd2\xfc\xe4\x3b\xac\x66\x96\xd1\xe9\x2c\xcb\x93\x09\x47\xee\x7b\x20\xc0\x09\x68\xd3\x2a\xcc\xd9\x24\x53\x0a\x99\x1d\x56\x11\x35\x26\x23\x2e\x35\x98\x27\x1c\x7c\x30\x91\x89\x5b\xe5\x43\x11\x52\xdf\xec\x18\x78\xb9\xd1\x45\x3d\xdd\x2b\xb7\xaf\x3d\xe3\xb7\xc5\x99\x32\xb0\x35\x9f\x7c\x49\xee\xe7\x0c\x03\xed\x3a\xcf\xdb\xd0\x14\xda\x0a\x1a\xfe\xd3\xfb\x59\x8e\x89\x78\x3f\x60\x24\x2c\x28\xe6\xae\xb6\x1d\xf5\xf4\xe8\xdb\x32\x87\x78\x4b\x6a\x1a\x9e\xd0\x3b\x28\xd5\xac\x5e\x18\x41\x1b\x08\xde\x79\xf4\x20\xb4\x2a\x70\x44\xec\x62\x53\x7f\x11\x25\x7e\xd0\x23\x25\x55\x17\x76\x8d\x68\x81\x77\xa0\x10\xac\x24\xbd\xab\x6e\x95\x57\x16\xdf\xeb\xca\xec\x86\x67\xd5\x24\x01\x8b\xc2\x1c\xdf\xae\x98\xb2\x7c\x6d\x5d\x6f\x54\x34\x3d\xcd\xde\x8f\x5e\x8d\xc3\x28\x10\x47\xbf\xc4\xcd\x62\xf5\x51\xbc\x6f\x2d\x1d\xa2\x4c\x41\xa1\x41\x11\xab\x19\xdc\x2b\x88\xd0\x3d\xfb\x9b\x66\x47\x4b\xa8\x3d\x62\xc8\xc5\x67\xc5\xaa\x74\xa7\x1a\xe1\xc6\x37\x18\xfe\x95\x95\x4a\x92\xeb\x70\x65\xec\xf8\xb9\xf0\xd9\xb0\x7a\x5c\xbb\xce\xde\xfc\x61\xc8\xe3\x15\xd7\xd0\xff\x9f\xbd\x77\xed\x6a\x23\x47\x1e\x87\x5f\x0f\x9f\x42\xc9\xce\xc6\x76\x30\xc6\x36\x10\x88\x59\x26\x6b\x6e\x09\x93\x10\x12\x20\x93\x4d\x78\x38\x4e\xdb\x96\xed\x0e\xed\x6e\x4f\x77\x1b\xe3\x04\xbe\xfb\x73\x54\xa5\x6b\xdf\x7c\x83\xfc\x66\xe6\x1f\x66\xcf\xc6\xdd\x2d\x95\x4a\xa5\x52\xa9\x24\xd5\x65\x63\x8a\x1d\xf3\x46\xe2\x8e\xd9\x58\x6a\x11\x8c\xe9\x4e\xf1\x08\x5b\xba\xbd\x25\xf8\x2b\x92\x69\x98\x4c\xf0\x98\xf8\x9b\x8f\xb8\x31\xd6\x92\xa4\x4f\x9e\xe0\xa8\x44\x8f\x52\x8a\x86\xae\x1a\x29\xc6\x75\xa8\xe2\x14\xdd\x49\x32\xbc\x49\xe8\x0e\x07\xbc\x67\x39\xce\xee\xf8\x9d\xe5\x33\x62\x69\xdc\x22\xf5\x06\x79\xa0\x59\x48\x60\x54\xd3\xb4\x3c\x72\xe5\x91\x6d\x63\xbe\x36\xa3\x8d\x79\x04\xb8\x66\x6c\xce\x28\x7b\x8e\xf7\x8d\x39\x3f\xa9\xc0\x1c\xd6\xe8\xc9\x12\x74\x0a\x6b\xf4\x59\x41\xe2\xb8\x1c\xfc\x71\xf0\xf6\x3c\xd1\xb2\x3d\x1c\x0f\x32\xcd\xa5\x93\x0d\xd7\x84\x8d\x73\xfe\x22\x87\xd6\xca\x70\x58\x65\x85\xb4\xeb\xf9\xe3\xdc\x65\x61\xb2\xad\x7b\x2a\xdc\x69\x6d\xdd\xa7\x00\xd0\xb3\xdb\xf3\xf5\xad\xe9\x79\x10\x23\x4e\x8d\xf6\x51\x7b\x7e\x22\x4d\x32\x04\x4f\xad\xcd\xfd\x06\xe6\x27\x02\x1b\x88\x25\x22\xbc\x98\x17\xa2\x25\x93\x19\x7b\xde\xd0\x0d\xef\x01\x4e\xa6\x51\x7d\x2a\x0c\x48\x1f\x70\xd2\x99\xda\x36\x52\x27\x64\xcf\x1a\x08\xcf\x6f\xbe\xc0\xcd\x83\x80\xcb\x8f\x9c\xd4\x19\xe7\x02\xc4\x80\x90\x18\x30\x51\xb4\xcb\xb0\x85\x66\x22\xdc\x9b\x15\xc5\xdd\x57\x51\x5e\x51\xe1\x74\x14\xeb\xc3\xff\x01\x1f\xc3\x74\x9a\xab\x59\x50\x44\x11\x7f\xc6\x38\x7f\x3f\xdc\xe7\xaa\x4a\x51\xb7\x98\xab\x2e\x53\xdc\x90\x60\x62\x7f\x35\xbf\xe0\x59\x8a\x1c\x56\xcc\x05\x8b\x21\xc4\x20\x61\x32\x94\x1f\x3d\xf3\x17\x1b\xfc\xc9\x9e\x38\x13\x27\xa5\x35\x0c\x3d\x36\x17\xdb\x56\x68\x1d\xdb\xae\xfc\x69\xdd\xe4\x2e\x0b\x97\x28\x00\x20\x55\xc7\xff\x01\x6f\x47\x71\x74\x20\x95\x0f\xfb\x35\xf0\x46\x70\xfc\xf3\xa7\x0f\x82\xc4\xf1\xba\xec\x1f\xbb\x4d\xdd\xd0\x0e\xc7\x78\x54\xd4\x87\x23\xa3\xa6\xe5\xb6\xb1\x86\xed\x42\x59\x14\x8d\x0e\xfb\xf9\xe7\xd0\x72\x43\x1b\x8f\x96\xf0\xf7\x37\xf8\x3d\x0c\x5b\xe7\xbc\x7a\x40\xff\x1c\x32\xa0\x58\x21\xec\xf9\x34\xe8\x79\x4e\x3b\x07\x8a\xda\x22\xdc\x6f\x39\x8e\x37\xda\xb7\x42\xeb\xe4\x9a\xfa\x1d\xc7\x1b\xcd\xad\x08\x4c\xf2\xa5\x42\x0d\x4a\xea\x41\x31\xb5\xa1\x5c\x4c\x74\xb8\xb2\x34\xc7\x29\x63\x05\x10\xf2\x5b\x9b\xc2\xb9\x7f\xb5\x5a\xad\x9c\x29\xc5\xc1\x12\x4d\xca\x45\xfd\x89\x2f\xd3\x1b\xfa\xac\xbb\x28\x17\x09\x8e\xf3\x65\x0a\x75\x64\x5e\x2e\xce\x8d\x58\xfa\xde\x7d\xb8\x12\x0c\xad\x22\xce\x5c\xd5\x9f\xce\x5c\x7f\x19\x67\xae\x07\x71\xf5\xa9\xdc\x83\xab\x4f\x65\x31\x57\x9f\xea\x03\xba\xfa\x54\xef\xcb\xd5\xa7\x7a\x0f\xae\x3e\x3f\x26\x4f\xca\x43\x7b\xc9\x6c\x3c\xbc\x97\xcc\xb3\x46\x03\x76\x09\x8d\x7d\x2f\x9d\xe1\x37\xe7\x64\x89\x4d\x01\xfc\x9d\xe7\x8c\xbb\x19\x42\xa4\x5a\x5d\xc4\x55\xe9\x41\xfd\xad\x9e\xcf\xec\x45\xf4\xd3\x87\xe8\xa7\x0f\xd1\x4f\x1f\xa2\x9f\xb9\x64\x7e\x7a\xd9\xfc\xf4\xb2\xf9\x27\x7b\xd9\xd4\xb9\x87\x0d\xdb\xf6\x59\x0e\x69\xdb\x3e\x05\x5a\x47\x5c\x6b\x60\x5a\xf3\xb4\x08\x3c\xc6\xe2\xbb\x23\xb2\x4a\x2a\x5b\x65\xcc\xbb\x46\x61\x4b\x59\xa1\x2b\x1b\xdb\x9a\x23\x0e\xd8\xf2\x4e\xeb\x87\xf3\xc3\xc2\xe7\x99\xa8\x4d\x72\xc3\x91\x05\xa7\xf1\xc2\x91\x85\xe7\x73\xc2\x91\xd5\xa7\xf6\xc1\x51\x0d\xce\xe3\x82\xa3\x11\x21\xc9\x03\x87\x6d\xd6\xe7\x72\xc0\x71\x6c\x97\x12\xea\xb6\xe1\x60\x45\x54\x90\x9e\x38\xc2\xa7\xa6\x6d\x85\x16\xf8\xe0\xb0\xcd\x3c\x9b\x18\x70\xbe\x2e\x8b\xc7\x5d\x70\xca\x45\x32\x2e\x17\x6a\x50\x07\x8c\xc8\x79\x06\x07\xaf\x03\x46\x21\x45\x51\x35\xf6\x97\xbf\xa9\x14\xc9\xb8\xc2\xab\x6a\xa9\x1f\x1c\x2f\xa0\x90\xc7\x64\x42\xf5\x6a\x91\x8c\xab\xe9\xd5\xad\x1b\x5b\xe0\x9d\xe9\x1b\x24\x09\x9a\x67\x7d\x7f\xf0\x80\x85\x7e\x24\xa4\xa0\x1f\x0f\x53\x68\x38\xc8\x34\x62\xce\x31\xd1\x0b\x6d\xe3\xde\xbb\x24\xde\x98\x06\x56\xfc\xe5\x99\xfd\x8d\x72\xdb\x21\x79\xb5\xcb\x7f\x97\x02\xf6\xed\xf6\x96\x6c\x19\x26\xcc\x53\x99\x2f\x27\xa9\xf2\xb3\xa5\xbc\x61\xa4\xd7\x4d\xbd\x0d\x1c\xaa\x3f\x02\x07\xb2\x6c\x78\x11\xc1\x5a\x9d\x03\x0f\x87\x1c\x79\x41\x56\x2a\xa4\x46\x2a\x05\xf2\xd4\x20\x65\x12\xde\xa6\x25\xc0\x77\x34\x3b\xae\x94\x6e\x8a\x68\x6a\x5c\x29\x8d\x8b\x68\x5e\x5c\x85\x77\xf8\x6b\xac\xbb\x39\x18\x33\xfa\x25\x0d\x61\x2e\xb3\xc9\xb0\x62\xa1\x8d\x9c\xd7\x21\xd4\x6a\xf5\x92\x5d\xea\x8c\x89\x0c\x93\xd8\x4b\x9b\xc4\x67\x70\x2a\x7f\xa7\xc3\x96\x13\xe6\x3e\xfd\xbf\xe2\xf3\x6a\x66\x1f\xb0\x96\x17\x88\x35\xae\xe5\x05\xf9\x95\x08\xdd\x89\xc8\x0f\x64\x30\x4e\x96\xe3\x18\x04\x68\xf4\x02\xf2\x1b\x5b\x25\x0d\x43\x5d\xbd\x52\x8c\x21\xc0\x7d\x85\x31\x04\x77\xf8\x22\x35\xd3\x7f\x4c\x33\x1f\x66\xd0\xff\x43\x56\xe6\x04\xcf\x80\x32\xe0\xa6\x5f\x59\xdc\x4a\x38\xcb\x85\x6c\x0e\x8f\xb1\xfb\xf2\xa9\xb9\x6f\xcf\xb1\x88\xd4\xac\x26\x88\xcd\x98\x09\x50\x35\xd1\x04\x48\xbc\xe3\x06\x18\xd1\xa2\xec\xf5\x3d\x78\x50\x24\x1d\x30\xcd\x13\xb4\x71\x61\x2f\x8a\x05\x10\x91\x5e\x14\x05\x63\xd6\x98\x04\x64\x5c\x8b\xf1\xc5\x73\x09\x46\x52\x33\x9c\xd9\xc6\x0c\xa1\xa6\x3d\x5a\x4b\xb2\x7c\x4a\x36\x70\xcc\x30\x82\x82\xcb\x13\xcd\x95\x42\x37\xff\x4c\x30\x6f\xe7\x5e\x74\x06\xef\x9a\xfe\x74\x84\xf8\x35\xce\xb5\x9a\x75\xa8\x66\xbb\xae\x38\x4c\x18\xb7\x69\x62\x30\xee\xf7\x08\xca\x4d\xa6\xdd\x6f\x02\xf9\x7f\xc0\xc2\x1d\x73\xd2\x9a\xc7\x0e\x72\x11\x66\x88\x1f\x85\x4e\x60\x88\x59\xd8\x40\x1f\x7e\x3e\x04\x35\x31\x14\x77\x7f\x1b\x2f\x9b\x24\xf2\xde\x93\x97\x4d\xe2\xc8\xfd\xd3\xbc\x6c\x26\xb3\xe7\xf4\x76\xda\x3f\xce\xcb\x46\xe3\xe5\x7f\x8a\x93\x4d\xba\xa7\xee\x44\x97\x5a\xc3\xf2\x77\x2d\xe6\x64\x13\xdb\x47\xad\xc9\x8d\xd4\x64\x57\x9b\xb5\xa9\x5d\x6d\xd6\xb8\xab\x8d\xd1\xb7\x99\x9c\x59\xee\x47\xb1\x58\xd0\xa1\x65\x11\x24\xd0\xa1\xc5\x14\x6a\x6f\xf8\x31\x77\x4c\xcf\xd2\x3d\x3d\x0c\x0d\xe8\xa1\x75\x1f\x81\x55\x61\x71\xe7\x1b\x47\x9c\x2f\xc4\x1c\x70\xd4\xc9\x43\xa2\xff\x8d\xae\xda\x9b\x15\xb5\xbd\xd5\x3d\x7a\xee\xe8\x3a\xcf\x8f\x70\xb1\x29\x46\xbc\x68\xf4\x79\x73\x53\x53\x74\x2b\xc1\x49\x8f\xfe\x62\x5c\xd5\x74\xaa\x59\x3c\x6e\xee\x49\x92\x27\xdd\x50\xdf\xbb\xc7\x4d\x44\x7e\xdf\xaf\xc3\x4d\xf2\xd4\xb8\x07\x87\x1b\xfd\x68\x69\x91\x71\x88\xbb\x42\xcf\xbb\xee\x99\xfa\x3c\x90\xc7\x90\x39\x45\xc5\x58\xf1\xae\x40\x37\xfe\xd2\x3e\x44\x33\xb0\xf4\x3d\x32\xf4\xb4\x5a\xf4\x8f\x76\x21\x5a\xc0\x0d\x37\x72\xc4\xb0\x3e\xcd\x11\xc3\xba\x3c\x37\x30\xdd\x88\x38\xac\xff\xec\x90\xb2\xf2\x25\x7a\x38\xaf\xa2\xbf\x34\x0f\xcc\xed\x54\x14\x73\x26\x4a\xe0\x9a\x04\x7f\x1e\x79\x7f\x92\xed\xce\x53\x99\xc7\x9d\x47\xc2\x4e\xf1\xe6\xb1\x12\xbe\xcf\xe1\xcc\x93\x2c\x9d\x17\x72\xe6\x49\x06\xb9\xa8\x33\x4f\xb2\x69\xda\x34\xce\x3c\x92\x52\xd9\x8e\x30\xd9\x0d\x4c\x32\x54\x4e\xad\x3d\xd9\x11\x26\xb5\xaa\x72\x84\x21\x70\xc6\xfe\x9a\x66\x7a\x15\x3d\x50\x07\x26\x1b\x92\x3f\x44\xdf\x95\x35\x74\xb6\x2f\xd6\x24\xb4\x27\xfa\x62\x4d\x01\xc0\x9f\x98\x4d\xe3\xaf\x4a\x7a\xa4\xe0\x24\x5f\xb2\x54\x20\xc2\x97\x6c\xa2\x91\xff\x03\xf5\x1f\xa7\xf6\xac\x92\xa6\x0d\x92\xe6\x6c\xaf\xfe\xe6\xa0\x71\xfe\xe9\x1d\x0a\x99\x4c\x9b\xfc\x89\x5c\x38\xa5\x0f\xd2\x03\x91\x61\x92\x1f\x4f\x7a\xb3\x9a\x0f\x92\x7e\x96\xbe\x90\x9c\x1d\xe0\xe1\x27\x08\x5a\x3c\x8d\x57\x4e\x4e\x7f\x67\x02\x4d\x72\xd2\xfa\xab\xe1\x0e\xce\x49\xf3\x77\x7a\xae\xaa\xdc\xbb\x8b\x4f\x89\x89\xfe\x90\xa9\x70\x26\x7b\x45\xa5\x0b\xb6\x59\xfc\x21\xd3\x11\x98\xcd\x1f\x72\x82\x84\x56\xfe\x90\x93\x1d\xd7\x26\x2d\x96\xd3\x3b\x55\x4e\x9c\xa9\x68\x52\x50\x14\x77\xbd\x8a\xcd\xa7\xf2\x8a\xcb\x64\xbc\x29\x1d\x8b\xa4\x26\x16\xd3\xc3\xca\x31\x77\x9d\x64\x57\xa3\x14\x27\x20\xd3\xeb\x08\xfb\x97\xee\x63\x94\xe5\x75\x84\x8b\x23\x98\xf1\x3d\x8c\xc3\x90\x61\x13\x16\xf1\x17\x5a\xfb\x2b\xf9\x0b\x3d\x88\xc3\x4c\x2c\x55\xe1\x5c\x6e\x41\x0b\x39\xcc\x54\x1e\xd0\x61\x26\x39\x9b\xd9\x5c\x4e\x41\x8b\x3b\xcc\x54\x67\x74\x98\xf9\x69\xe1\xff\xd3\xc2\xff\xa7\x85\xff\x4f\x0b\xff\x9f\x16\xfe\xff\x60\x0b\xff\xcf\x60\xe3\x2f\xed\xf9\xd9\xec\xfd\x3c\xad\x49\x7e\xd2\x82\xf2\x20\x26\xf9\x9f\x27\x58\xe2\x7f\x9e\xc2\x00\xff\xf3\x5c\x76\xf7\x9f\xa7\x35\xb7\xff\x3c\x8f\x95\xfd\xe7\x04\xe3\xfa\xd9\xee\x1b\x62\x87\xf5\x09\x67\xd1\x9f\x27\x1f\x41\xcf\x9a\xb5\xf8\x73\xc6\xc9\xf2\x34\xa7\xb5\xd9\xe9\x65\xb3\x4e\x6b\x57\x57\xc1\xca\xde\x65\x88\x78\x1d\xb4\x2d\xe6\xc8\xd1\x36\x5b\xbe\x43\x9e\x18\x66\x89\x40\xa1\xff\x83\x24\xb7\x93\x8f\x35\x27\xe4\xc7\x35\x7a\x3a\x74\xed\x70\x62\x4f\x59\xa1\x7f\x42\x4f\xff\x1c\x52\x62\xb7\x59\x77\xbf\xad\xf0\xae\x7d\x9b\x7c\x34\xff\xb7\xe8\xdd\x15\x1d\x4f\x1c\xc6\x29\x4e\xf1\xff\xaa\x7d\x9d\xab\xaa\x3a\xc5\xe7\x44\xf2\x2d\xb7\x0b\xf3\x9a\x13\x04\x9e\xe7\x22\xc7\xe4\x23\xa4\x09\x1d\x9a\x2e\x7c\xcd\x03\x0d\xc7\xdf\x36\x7c\xcd\x84\xa1\x86\x23\x94\xf4\x63\xa1\x6f\xc6\xf1\x0f\x1f\xfc\x8b\x67\xeb\x45\xf2\x6c\xfd\x32\xf1\x44\xc8\x8c\x50\x73\xef\x27\x34\x9f\x53\x0e\x66\xd6\xb3\x0e\x66\x38\x98\x19\x0e\x63\x38\x35\xc9\x1f\xf5\x53\x72\xf4\xf6\xf7\x83\xbd\xf3\xa3\x93\xb7\xe4\xe9\xaa\x82\x3d\xf0\xbd\x16\x05\x5d\x9c\x6b\x71\x7b\xde\x60\x0c\xd1\x74\x48\xbe\x55\x20\xd5\x72\x65\x6d\x65\x80\x56\x64\x45\x72\x68\xb5\x68\xd3\xf3\xae\x8a\xe4\xc8\x6d\x95\x96\x08\x54\x38\x67\xdb\x10\x1e\x52\xa0\xe5\xb5\x29\xb1\x03\xe2\xd8\x2d\xea\xb2\x6d\xc8\x90\xa9\x15\x20\x89\x8e\x8f\xce\xc5\x6b\xd2\xf1\x86\xae\x10\x51\x0c\xc4\x9b\xa3\xbd\x83\xb7\x67\x07\x84\x29\x90\x42\x72\xf9\x9e\x17\x72\xbf\x50\xcf\x07\x09\x17\x6a\x0d\x85\x3e\xa5\x25\xa1\x5c\xf2\x8d\x2b\xeb\x47\x89\xba\xd7\xa5\xb7\x27\xfb\x07\x8d\x83\xb7\x7f\xc0\x56\x21\x37\xf0\xbd\xf6\x10\x3a\xcb\xcd\xf7\xe1\xb4\xc0\xbd\xb6\x7c\xdb\x72\x53\x8e\x4c\xf2\x5b\x9b\xa0\x59\xb1\xa2\x23\xcb\x77\x6d\xb7\x9b\x76\xa0\x51\xa9\xca\x92\x70\x1d\xf4\x4e\x68\x2c\x67\xb4\xe5\xd3\x34\xf8\x15\xc8\xaf\xcb\xad\xe7\xbc\x6e\x97\xb6\x59\x9d\x43\xcb\x76\x86\x3e\x2a\x3b\x77\xdb\x4b\x4a\xb5\xae\x07\x01\xf5\x43\x12\xf6\x2c\x74\x95\x02\xf5\x2d\x20\x7d\x2b\x6c\xf5\xc8\xc8\x0e\x7b\xe8\x40\xc5\x36\x26\xc1\x80\xb6\x02\x46\x1a\x02\xdb\x21\xd2\xa7\x41\x60\x75\x69\x40\x2c\x9f\x92\x3e\xed\x7b\xbe\xfd\x8d\xb6\x89\xe5\xb6\xc9\xc8\x66\x1b\x21\xd7\x19\xb3\x5d\x51\xd0\xf3\x46\x2e\xf1\xdc\x16\x15\x03\xcb\xfd\xad\xbe\x7b\xdc\xdd\x8a\x81\x3f\x63\xd0\xc9\xb1\x35\x60\x03\x02\xba\x52\xe8\x11\xcb\xec\x79\x52\x5d\x8e\xf0\xe9\xd0\x65\x52\x44\x3c\x42\x7f\x5c\x4a\xdb\x0c\x4a\x13\x3b\xb0\xd2\x62\xba\x35\x6d\xeb\x50\x02\xee\xc5\xe5\x78\x2d\xf4\x24\xa2\xa5\x6e\x89\x3c\x66\x12\xe1\x71\x91\x3c\x6e\x79\x6e\x48\x6f\x42\xf8\x09\xa6\x5c\xe2\x45\x12\x0c\x69\x9f\x0c\x2a\xe7\x5b\xae\xee\xa1\x2f\x29\xff\x02\x87\x4a\xd4\xa0\x5e\x49\x07\xf5\x42\xd8\x6a\xdf\x91\x2e\x0d\xcf\x42\xab\x75\x45\x50\xbb\x0f\x22\x80\x02\xf6\x8d\xd7\xf5\xed\x6b\x2b\xa4\xc0\xb3\x52\xed\x86\xbe\x4a\x8e\xc9\x4b\x0a\x73\xdb\xf8\xa0\x28\xbb\x5c\x34\x11\x2f\xca\x96\x91\xa7\x67\x9c\x02\x44\x9d\x9b\x89\x36\x81\x12\x6c\xee\x09\x1c\xd4\x5e\x40\x6c\xd2\xe1\x75\x24\xee\x47\x5e\xaf\x5f\x88\x1a\x86\x02\x11\x95\xe5\xe6\xea\x2a\x61\xf5\x90\x51\xaf\x2d\xc7\x6e\xe3\x70\xf6\xad\x31\x6e\xe5\x4b\xe4\xc8\xc5\x6c\x64\x61\x8f\x8e\x49\xdb\x2b\x92\x11\x25\x6d\xcf\xcd\x85\x64\xc4\x66\x6b\xe8\xe9\xc0\x3a\x96\xed\xa0\xb0\x80\xed\x0b\x19\xf4\x58\xd5\x51\x8f\xfa\x94\xd8\x4c\x7a\xb4\x59\x45\x28\xd5\xa4\x1d\xcf\xa7\x25\x72\xe6\x31\x88\x8e\xd7\x25\x76\x58\xd2\x61\xd5\x3b\x21\x4a\xaa\x80\x92\x9e\x75\x4d\xf9\x81\x89\x43\x2d\x97\xc9\xb1\x01\xc3\x24\xe7\x38\xc4\x41\x6f\xc5\x3e\x47\x58\xd9\xf2\xf8\x63\xc3\x04\x14\x14\x0f\x3b\x60\xd2\xd0\x76\x43\xb6\xe0\x79\xae\xe5\x38\x63\x62\xb9\x9a\xf4\x81\x19\xd0\xa5\x61\x40\x5a\xd6\xb0\xdb\x0b\x4b\xe4\x28\xcc\x21\x17\x05\x56\x9f\x9a\xf0\x9a\xb4\x67\x5d\xdb\x9e\x4f\xac\x00\x26\xbd\x37\x0c\xb9\x50\x0c\xad\x10\x2e\xc8\x08\xbd\x69\xd1\x41\x88\x22\xc1\x22\x4d\x0a\x86\x7a\x9c\x89\x4b\x86\x81\x2a\xc7\x40\x9c\xbe\xc8\xf1\xbd\xd0\x07\xf4\x12\xbd\x9f\x04\xbf\xb2\x05\xfb\xdf\x41\x8d\xfc\x3b\xc0\x21\xfc\xf2\xef\xe0\x0b\x76\x10\x06\x73\x9b\x11\x1d\x0e\x5b\x9a\xd4\x38\x5d\x19\x06\x43\xe8\x7a\xc7\xf7\xfa\x10\xf7\x3e\xc7\x3a\xf8\x85\xcd\xdf\x15\x58\xd1\xbf\x10\x26\x1f\xad\x2e\x2d\x92\xe6\x30\x24\x3e\x6d\x51\xfb\x9a\xb6\xa1\x81\x52\x2e\xc2\xfb\x6c\x05\xce\x81\xc4\xc1\x73\xb7\x9c\x3e\x4b\x74\xec\x8b\x24\xbb\x73\x05\x3d\x11\x1d\xce\xf7\x9d\xb4\xb2\x79\x31\x21\xcd\x06\x22\x93\x52\xe1\xc1\x36\xce\xc5\xc4\x15\x41\x6b\xf5\x8e\xb4\x40\x82\xe7\xe9\x4d\xc1\x60\x1e\x81\x0c\xbd\xd1\x0a\xcb\x5f\x7c\x45\xca\x3f\xc2\x62\xb7\xb7\xbc\xbc\x76\x86\x09\xb2\x9f\x8f\x96\x5c\x16\xec\x8e\xcd\xe5\xa7\xd7\x61\x63\x18\x1b\x3e\xb9\x88\xa0\x0c\xf6\x71\xac\xa4\xb4\x82\xa1\xe5\x7b\xff\x2f\xac\x83\x5f\xe0\x18\xcd\x25\x5f\xa0\xb9\x2f\x7c\xec\xd8\x77\xb6\xc2\x90\x7f\x07\x25\x84\xf0\xc9\x1b\xc2\x1c\x87\x79\xd5\xf1\xfc\xae\x17\x86\xd4\x65\x42\x7f\x00\xe7\xa6\xae\x3c\xd1\x00\xa7\xf8\x44\x2c\xe0\x78\x83\x09\x2d\xae\x80\x17\x65\x77\xd9\x6f\x5c\x67\xe0\x97\x4b\xe5\x3f\xe7\x70\xec\xc6\x96\x3a\x00\x01\x57\xb8\xc4\x72\x1c\xc2\x17\x62\xbd\xe5\xc2\x3d\xf0\x19\x0c\x83\x36\xbe\x4c\x70\x26\x0f\x0d\x79\xf2\x84\x3c\xc2\x6f\x25\x3e\x3d\x99\xf0\x8d\xab\x02\x85\x42\x54\xaa\x9c\xb0\x05\xbb\xef\xb9\x36\xa3\x06\x4c\xff\x0e\x96\x85\xc5\x9b\x34\x69\xcb\x1a\xa2\x00\xf5\x29\xc1\x40\x52\xb8\xba\x5a\xc4\xf1\x42\xbe\xd8\x99\x20\x99\xa8\x41\xe4\x75\x19\x11\x47\xe6\xc2\x40\xf8\x52\xdc\x58\x2c\x19\x3e\x36\x3e\xae\x7a\x64\x47\x2d\x8e\x2f\xe4\xcf\x7c\x81\xd4\x48\x2e\x67\x54\x11\xec\xcc\x0f\x3c\x73\xac\x35\xda\x16\x42\x86\x49\x9b\x7f\x9b\xb4\x37\xb0\x28\xf2\xe6\x1e\xe1\xa9\x30\x79\xc1\x9f\x59\x33\x85\xf8\xec\xb9\x53\x87\x59\x4c\xbf\x42\xd5\xba\xc4\x35\x6b\xb2\x13\x59\x91\x51\xc5\x4f\xd3\xa2\xef\x30\xe8\x55\x96\x5a\x9e\x5f\x2b\x14\x0a\x31\x2d\x7f\xe3\x5e\xb5\xfc\xbf\xab\xda\x9e\xa1\x32\xe7\xce\x0e\xf6\x4e\x0f\xce\x1b\xfb\x27\x8d\xb7\x27\xe7\x8d\x77\xf5\xb3\xb3\xc6\xf9\xab\xa3\xb3\xc6\xc9\x69\xe3\xd3\xc9\x87\xc6\xc7\xa3\x37\x6f\x1a\xbb\x07\x8d\xc3\xa3\xd3\x83\x7d\xc6\x4d\xb1\x71\x4c\x02\xbc\xbd\x14\x1b\x89\x67\x0b\x8d\xc4\xea\x2a\xd9\x2c\x55\x4a\x15\x72\xee\xbd\xf3\xed\xbe\x1d\xda\xd7\x34\x6f\xbb\x83\x61\x48\x2e\x8a\xe4\x9d\x4f\x3b\xd4\xf7\x71\x0a\x5d\x16\xa0\xbf\x76\x80\xa7\xbc\x29\xdb\x82\x0d\xb8\xed\x5e\x05\x71\x41\xad\xb6\xd0\x4c\x0f\xce\x9e\x81\x00\x27\xd7\xd4\x0f\x60\x0a\x30\xad\x08\xb5\x1b\xbb\x3f\x40\xe3\x18\xf2\xdf\xff\x86\x0a\x0d\xd0\xa2\x18\x28\x26\xfd\x40\x9d\xa0\x2d\xcf\x6d\x2b\x41\xbb\x42\x3a\x8e\xd5\x25\x2b\x64\x20\xd0\x44\xa1\x6b\x07\xc4\x22\xa8\x2c\xc7\xa9\xaa\xce\xd4\xed\xb0\x48\xce\x94\xee\xf9\x48\x74\x2c\x6f\x87\x85\x82\x58\x24\xec\x50\xec\x71\x3a\x2e\xa8\xb4\xdb\xbc\xf8\x19\x18\x47\xa3\xd0\xcc\x77\x5c\xb2\xc3\xb4\xb1\xd0\xc3\x68\x0d\x05\x62\xe8\x1c\x20\x2a\x25\xf8\x6b\xcb\x61\x78\xb8\x38\xf5\x58\x63\xb2\x35\x0d\x7e\x14\x34\x2c\xde\x27\x9d\x7b\x80\xfc\xe8\x21\x51\xc7\xeb\x2c\xf3\x96\x31\x17\xb2\xed\xcc\x35\xdb\xfe\xe1\x22\x07\xcb\xa6\x1c\x66\xbc\x5e\x2e\x6c\x2f\xdd\x25\x70\xf7\xe6\xa2\xdc\xdd\xb1\x1c\xa7\xc9\xa4\x29\xdb\x2e\xb8\x9e\xbb\x02\x8b\xef\x8a\x63\x5f\x31\xa6\x5c\x03\xe6\x62\xaf\xb5\xeb\x71\xcf\x69\x93\x3f\xb6\x38\x07\x05\x4b\x18\xd9\xa2\x93\xba\x0d\xde\x42\x86\xa7\x81\x63\xbb\xe1\x4a\xdb\x0e\x18\x90\x15\x97\xde\x84\xe0\xd5\x42\x5c\x6f\x45\xde\xa0\xad\x34\x87\xb6\x13\xda\x6e\x10\x67\x4c\x4e\xe2\xdc\xb7\x5c\x01\xee\x0c\xd8\xd6\xe4\x28\x38\x90\x68\xe5\xcb\x05\x79\xf5\x45\x6a\x06\x1f\x23\x13\x8b\xdb\x50\xaf\x03\xaf\xd8\x30\xe2\x90\xe6\xc8\x0b\x36\xc2\xc1\xc0\xb1\xc3\x7c\x2e\xc7\xd6\x2f\xc5\xe9\xc9\x64\xdf\x9a\x82\xec\x40\x61\xd8\x7f\x71\xd6\x81\x3d\xbf\x64\xa4\x24\x91\x96\x8a\xb4\xa8\x24\x19\xab\x14\x30\x91\x9d\xdf\x2a\x92\x95\x4a\x0a\x8e\xcf\xa7\xc5\x11\x64\x5c\xb5\x54\x21\xa7\x38\x6a\xd8\xf9\x3d\x8f\xfa\x2d\x9b\x11\x56\xea\x4f\xd3\x20\xcc\x66\x90\x1d\x32\xea\xb2\x15\xa6\x63\xbb\xb4\x5d\x48\xe5\x7a\xa6\xa8\xf5\x69\xd8\xf3\xda\xc4\x73\x09\x5c\xcf\xda\xa8\x3d\x6b\xe2\x25\xa1\x6f\xcf\xca\x33\xf5\xad\x52\x5a\x27\xe7\xde\x91\x1b\xd2\x2e\xf5\x91\x5f\xa9\xed\xc8\x50\x2c\xd4\x76\xd0\x62\xa5\xe3\x78\xa0\x93\xc3\x6b\x78\xd8\x9e\x61\x8c\xec\xe0\xad\xf5\x16\xfa\x4e\x96\xd9\xa7\x17\xa4\x4c\x6a\x40\x8c\xdf\x48\x99\xbc\xe0\xd0\x6b\xd0\x76\x21\x95\xb5\x9e\x55\x16\x9a\xd1\xa0\x9c\xf5\x2c\x26\xeb\xd3\x02\x32\x57\x0b\xf9\xdc\x15\x1d\x07\x39\x6e\xa7\x33\xb4\x53\xcb\x82\x2d\x4f\x06\x05\xae\xe8\xd8\x20\x01\xb6\x8c\xc1\x40\x6f\x6f\x49\x5e\x7f\xde\x61\x0d\x41\x8d\x94\x8e\x67\x46\xb8\x9e\xaa\xe3\x5d\xc7\x6b\x82\x04\x4e\x54\xd3\x9e\xf1\xfe\x9e\xbd\xaa\x9f\x1e\xec\x33\x15\xa4\xd1\x68\x79\x3e\x5d\xf9\x1a\x34\x10\xd1\x46\x23\x87\x45\x82\xd0\xf3\x29\x53\x6f\x01\xe0\x05\xd6\xc0\x2e\x45\x5e\xb1\x29\x3d\x23\x8d\x18\x6c\x8d\x44\xea\x91\xc3\x4a\xa2\x4d\xa6\x35\x5f\x84\xdf\x8f\x0e\xc8\xd6\x0a\x3f\x51\x61\x52\x9b\x34\x87\x5d\xc2\x06\x3c\x8e\x65\x7e\x89\x90\x9c\x66\xb1\x50\x34\x4f\x7e\x8a\xe0\x3e\x2b\xee\xa9\x8b\x49\x52\xb7\x18\x7a\x6f\xbc\x96\xe5\x50\x94\x4f\x45\x21\xa8\x8a\x7c\x3d\xce\x2d\x15\x84\x60\x2d\xe6\x0a\x09\x3d\x9b\xe6\x38\x1c\x7a\xc6\x7f\x97\x3a\xca\x30\xa3\x4b\x43\x0d\xdb\xb3\x71\xbf\xe9\x39\x41\x42\x1b\x8b\x29\xe3\x31\xaa\x7d\x27\x8f\xf9\x55\xc0\xe3\x5a\x22\xab\xad\x57\x9e\xc3\x4d\x07\x0d\x8e\xa1\xae\x30\xe2\x88\x5d\x06\x3c\x5b\x4c\x39\x35\xb7\x09\xc0\xb9\xbf\x5a\x69\x8a\xe7\x7a\x75\xa3\x90\x67\x78\xc0\x9d\xc4\x2a\xa9\x56\x4a\x95\xd2\x5a\xa9\xba\x49\xf8\xd2\x22\x17\xe1\x8b\xff\xfe\xd7\x0e\xa9\xcf\xf6\xe2\x97\xf9\xc2\x52\xb2\x14\xd9\x2c\xe4\xf9\x48\xcb\x65\xb4\x68\xc8\x46\x06\x80\xc9\x7e\xb8\xd3\xef\xd9\x41\xa9\xc1\x30\xc3\xa2\xea\xf3\x36\xdb\x9c\xa2\xe1\x9b\x2c\xc7\xed\xfc\x22\x7f\xab\xab\x84\xe9\x0c\xe8\x78\x2d\x3b\xb0\x01\x0b\xd7\xbf\x11\xec\x11\xc7\x5a\x32\xed\xbf\x4b\xac\x4a\x1e\xee\x8e\x0c\xfb\x43\xae\xb3\x9e\x08\x47\xcb\x86\x54\x63\x01\xbc\x7c\x6d\x8b\xd7\x70\x13\x26\x34\x44\x2c\xf3\xdb\x0e\x39\x91\x3e\x90\x32\x52\x1a\x37\xbb\x90\x8b\x5f\x91\xcd\x44\x8d\x03\x08\x8f\xf0\xb7\xc3\x86\x2a\x7f\x52\xc4\x06\x0b\xdb\x5a\xef\x97\x77\xb0\x8c\xb0\x6f\x5c\x22\x31\xf0\xf0\x5d\x80\x86\x5d\x35\x83\x7d\x97\x34\xc1\x16\xd3\x10\x13\x58\xec\xcd\xd1\xee\x69\xfd\xf4\x53\xea\xfa\xb2\xc5\xe5\xec\xaf\xfc\x9e\x2c\x25\xa6\xf7\x26\x2f\xe6\x53\xa4\x54\x5a\xb9\xf5\x2a\x2f\xd8\xb3\xdb\x69\x85\x36\xca\xa2\x8c\x15\xa4\x05\xf8\x16\x60\x04\x93\xa4\x15\x7c\x2e\x60\xfd\xca\x98\x74\x0f\x4c\x6e\x52\xa7\x94\x58\x53\x02\x1a\x9e\x73\xc9\x77\x6e\xa5\x5f\x24\x3d\xe7\xc5\x4d\x03\xa0\xd4\x9e\x0b\x4c\x8e\xce\x0f\x4e\xeb\xe7\x27\xa7\x69\x2b\x5b\xb9\x90\xcf\x89\x19\x2b\x56\xf5\xdd\x0f\x2f\x5f\xb2\x31\x7a\x94\xbf\xb8\x2c\x31\xe9\xcf\x76\x2a\x39\x36\x1d\x72\x6c\x23\xcf\x5f\xe6\x0b\x38\x03\xcf\xac\x8e\xe5\xdb\x40\xbe\xe6\xb0\xdb\x1d\x13\x5b\x52\x69\xb4\xea\x91\x2f\xac\xde\x17\x80\x7b\x78\xd8\xd0\xd0\xc9\x29\x51\xc1\x97\xce\xd7\x07\x9f\xce\xd8\x07\xd0\x30\xf0\xd5\x1f\xf5\x37\x1f\x0e\xe0\x25\x9e\xb0\xe6\x38\x23\x21\x53\xc3\x29\x45\xd4\x3c\x58\xa8\xbd\x3d\x3b\xc0\x90\xe1\x19\x0b\xec\xae\x15\xd0\x22\x79\x5b\x3f\x3e\x30\x2c\x40\x8b\x20\x2e\x8a\x64\xff\xe0\xb0\xfe\xe1\xcd\x79\x91\x1c\x9d\x35\xce\x0e\xce\x8b\xe4\xf0\xe4\x74\xef\x60\x1f\x85\x80\x36\xc6\xa6\xd5\x2a\x82\x63\x10\xe4\x25\x5e\x97\x86\xc7\xa8\xab\x1a\xcb\xbb\xed\xb6\xc5\x01\x1e\xec\x1e\x91\xf0\x4f\x9e\x10\xf6\x85\x91\x1a\xe4\xaa\x94\x10\xf0\x74\xc1\xbe\x5d\xe2\xd1\x55\x30\xb2\xe1\x80\x58\x07\x44\xf0\x86\x84\xd1\xb2\x16\xb3\xf6\xc5\x71\x53\x44\x72\xe9\x48\xef\x37\x37\x20\x03\x70\xdb\x22\x22\x23\x07\x88\x23\x11\x07\x89\xe3\x32\x2b\xd0\xb8\x21\x32\x75\x43\xdf\x9e\x15\xd0\x9d\x20\xf0\x79\xfd\x25\xd9\x01\xca\x93\x65\x92\x93\x13\x35\x27\xbe\xef\x1f\x1c\x36\x24\x2f\xf1\x61\x65\x1b\x0d\x7c\x27\x4a\xe1\x53\x63\xf7\x03\x03\x86\x66\xdc\x4b\x32\x08\x5e\xe8\x91\x1d\xc2\x18\x46\xad\x76\xe2\xeb\xaf\xae\x05\xdb\xed\x1d\x3e\x44\x82\xcb\x41\x4d\xc3\x57\x1a\xef\xc3\x5b\x81\xc3\x93\x27\xbc\x00\x7f\x71\x29\x61\x2a\xab\x7d\x01\xfe\xf6\x56\x31\x52\x9e\x97\x97\x2c\xf6\x2b\x27\xa0\xd6\xbf\x17\xe4\x91\xd6\xef\x17\x0a\x64\x4d\x83\x93\xe3\xf5\x60\xef\x2a\x97\x1e\x09\xd5\x72\xc7\x6f\x45\xe7\x80\xbc\x6c\xef\x5b\x67\xfb\x7c\xb6\xf5\x05\xd4\x4b\xa2\xe5\xdb\x5b\x89\x6a\x4d\xfc\x12\x80\x70\xab\x16\x40\xf0\xff\x22\x89\xad\xb6\xdb\x68\x8c\x73\x68\xdf\x10\xac\xc7\x97\x4b\xd5\xbe\xe0\xef\x58\x55\x3c\x4a\xd6\x8d\x22\x55\x25\xdc\xf3\x32\x3e\x62\x03\x97\x2f\x88\x88\x65\x0c\x74\x1c\xd0\xa3\x1d\xa9\x1e\x2a\x53\xde\x27\x4f\xe2\x4d\x82\x6a\xa0\x26\x1c\x13\x82\x14\x4f\xd8\x94\x1c\x0f\x3d\xde\x13\x25\x0f\x79\x71\x53\xe0\xc7\xf1\x28\x32\x6e\x2e\x12\xae\x6f\xc9\x26\x3a\xf6\x0d\x1c\xb4\x04\x5e\x1f\xcf\x51\xa8\xdb\xb5\x5d\x1a\x68\xd7\xb0\x8f\xc4\xfa\xfa\xe4\x09\x79\xd4\xb3\x82\x24\xd8\x82\x0b\x0b\x05\x58\x15\xb3\x8a\x14\x35\x31\xab\xc7\x1c\x58\x92\xf8\x00\x23\xfc\xeb\xbb\xb8\xfd\x52\x12\xfd\xae\xe4\xf2\x1b\xe3\x3f\xb6\xc8\x2a\x39\x3c\xe4\xe3\xa9\xf1\xe3\x93\x27\x92\x5b\xd4\x4f\xac\xf6\x48\xce\x4c\x41\x64\x63\x66\xe2\xb5\x02\x7b\xad\x4d\x92\x0c\x81\x24\x60\x03\x33\x84\xd0\x19\x2e\x3e\xb0\x27\xfb\xa8\x44\x08\xdc\x39\xaa\x8a\x9a\xb7\xb7\x52\xf0\x3f\x79\x42\xf2\x28\xa5\x6f\x6f\x75\xa4\x6e\x6f\xc9\xa3\xc8\xdc\x97\x77\x33\x40\x66\xf8\xa8\x93\x56\xa0\x5e\xd0\x10\x79\xe7\x0c\xbb\x30\xc6\x8e\xdd\xf4\x2d\x48\xab\x2d\x55\x8e\x0b\x36\xfb\xd8\x46\x4f\x54\xdc\x36\xbe\x9e\xd7\x5f\xb2\x8f\x6a\xc0\xb6\x15\xc5\x41\x4e\x70\x64\xf8\x3c\xe4\x96\x4f\x44\x18\xfb\x06\x35\x32\x59\x54\xf0\x21\x11\x11\x2a\xd8\x62\x52\xe3\x4b\x63\x5a\x15\xb6\x0c\xc9\x0a\x5c\x4e\xd4\xa4\xac\x42\x96\x52\x53\x52\x50\x19\xcc\x0f\x78\x9e\x11\x8e\xb0\x69\x6f\xf0\x48\x7c\xc5\x05\xb2\x20\x35\x41\x41\x67\x90\x32\xbc\x2a\xec\x90\x05\xff\x62\xfc\x3b\xae\x5f\xe6\xf9\xbf\xa5\x77\x64\x59\xbc\x2b\x1d\x92\xa7\x89\x63\x5c\x10\x2b\xbb\xc0\x48\x0c\x1c\xe7\x32\xfe\x3a\x79\x13\x3e\xf5\xa1\x5f\x4c\x59\xe1\x77\x68\x51\x80\xd3\x9c\xd0\xa5\xab\xe6\xfa\x86\x38\x45\x2d\x8c\xb7\xb9\x39\xcd\xc9\x59\xf6\x29\xcb\xf1\xc1\x79\x3d\xe3\xc0\x28\x9f\xeb\xd3\xd0\x12\x6a\xe8\x34\xb7\x21\x53\x2a\xee\x01\x0d\xf7\x69\xd0\x4a\xeb\x6d\xb5\x50\xea\xf0\x36\xdb\xb0\x81\xe4\xed\x1f\xdc\x84\xd4\x05\x4b\x7d\x75\x70\x60\xbc\x35\x72\xee\x98\xa7\xae\x30\x6c\x77\x08\xe9\xf0\xf4\xe0\xe0\xf3\x01\xd3\xa8\x13\xb1\xac\x14\xf2\x29\x50\xf4\xc6\x54\x8e\x1d\x7a\x4d\xdd\x90\x7f\xf0\xdc\x20\xff\x1d\x22\x71\xde\xa9\xbe\x1e\xd3\xd0\x4a\x3c\x6e\xe4\x74\x80\xfb\x19\x36\x16\x45\xb5\x2d\xe4\x6a\x68\x8d\xe4\x4e\x72\x64\x99\x2c\x2f\xdb\xed\x22\x93\x49\xfc\x5a\xe1\x68\x1f\xbe\x8f\x6a\xe4\xfb\x9d\xb1\xb1\x1e\x51\xeb\x8a\xb4\x3c\xc7\xc1\x14\x0d\x01\x39\xda\x67\xf3\x1a\xbc\x4e\x44\xff\x3b\x56\x10\xbe\xa6\xe3\xd8\x15\x11\x3a\x25\x20\x6a\xab\xab\x4a\xcd\x15\xd7\x17\x60\xa8\x32\xf0\x69\xc7\xbe\xc9\xbc\x49\xe2\x17\x2e\x78\x76\x9c\x0b\xe0\x30\x07\x4f\xe6\x49\x4d\x5e\xf7\x88\xaf\xf2\xdc\x3e\x77\x06\x01\xa6\xdf\xe5\x0a\x70\x76\x2c\xef\x70\xd8\xc2\x29\x08\x24\x85\xf8\xea\x2a\x69\xc1\xc1\x73\x40\x43\x36\xd5\x2d\xb0\xa8\x0e\x3d\x32\x74\xd1\x36\x87\x74\x7c\xef\x1b\x75\x39\xbd\x94\x4e\x6f\x0c\xa1\x8e\x74\xee\x90\xc7\xa9\x5e\x5d\x05\x07\x23\x97\xb6\x68\x10\x58\xfe\x18\x8c\xe6\xda\x6d\xd9\x8a\x82\x25\xe8\x25\x20\x1c\x28\x08\x50\xc1\x0e\x02\xdb\xed\x9a\x15\x39\x3b\xe4\xf9\xe1\xb8\x22\xb3\x3e\xb0\x77\xea\xd0\xfc\x82\x75\xfb\xb2\x64\xcb\xc1\xeb\xd2\xf0\x23\x1b\xe3\xac\xc1\xfb\x91\x74\x53\xab\xff\xdc\x84\x93\xaa\xfd\x9c\xa4\xeb\x59\x41\x2f\x9d\xf1\xa3\xa4\x1c\x01\x29\x45\x43\x82\x04\x9e\x4b\x3a\x3e\xa5\xdf\xe8\x4a\xc7\xea\xdb\xce\x58\xae\xcc\x4c\x4b\xb1\xdd\x2e\xd0\xde\x73\x0f\xa1\x4c\xea\x75\x09\x97\x2c\x4f\x9e\x00\xe0\xd2\xdb\x83\x83\x7d\xf6\x10\x25\x9e\x54\x08\xb5\xf1\x89\xf4\xce\xbc\x35\xe1\x2a\x3b\x93\x22\xf1\x33\xcc\x25\xc2\xb6\x97\x35\x94\x20\x4b\x84\xb0\x56\xb5\x74\x97\x7c\xb6\xd7\xc4\x0f\xf6\x8e\x33\x51\x4d\xfc\x00\x6f\x79\xde\xb9\x9a\xfc\x95\xb4\x74\x6e\x2e\x7e\xa9\x31\xdd\xd9\x7e\x0b\xcf\xed\x13\x8f\x53\xd6\x78\x99\x69\xcf\xaf\x46\x57\x6c\x00\x52\x8b\x89\xb3\x1c\xd3\x89\x37\x7b\x75\xca\x38\xc5\x60\x3a\xb3\x3a\x98\xfc\x15\x0f\xb3\xc9\x0e\xf4\xa8\xc4\x9f\x6e\x6f\x49\x5e\x7f\xde\x91\x7d\x79\xc1\x24\x7a\x8d\x13\x49\x2b\x0e\x17\x0a\xc8\x65\xac\x81\x52\xab\x67\xf9\xf5\x30\x5f\x2e\x90\x47\x3b\x24\xd7\xc0\xeb\xeb\xbc\x50\xf3\x79\xab\x85\x88\x4b\xef\x38\xcf\x3f\x14\xc1\x1e\x58\x5b\x6f\x90\x44\xa5\x0e\xc7\x3e\xe5\xf6\x62\x73\xb1\x9b\x9d\xc8\x11\xe4\x52\xb2\xf3\xb4\x04\xf3\x58\x9d\xbb\x3f\x2e\x72\x82\x02\xb2\x4c\xe6\xc0\x02\x2b\x14\xa7\xbd\x57\xf5\xb7\x6f\x0f\xde\x90\x1d\x7d\xcb\x8c\x4e\xc8\x26\xf0\x6a\x5a\xe2\xc3\x42\x72\xf9\x35\x56\xde\x76\x43\xea\x7b\x03\x7e\xa7\xba\xcf\x03\x3e\x47\x21\x4b\x08\x46\x80\xb5\x94\x28\x02\x91\x92\xd5\x8c\x66\x64\xa1\xc2\xb6\xe9\xad\x9b\x54\xda\x6b\x7e\xd5\x76\x5a\x5e\xf3\x2b\x63\x0b\xaf\xf9\xb5\xa4\x48\x49\x5e\xc0\xfb\x1a\xf9\x2e\xdc\x20\x6a\xf0\xe2\x0e\xdd\x43\x57\xc9\x99\x25\x8c\xbe\xc9\x30\xa0\x6d\xd2\x1c\x13\xf0\x0b\x5c\xf9\x1a\xa0\x89\x80\xa2\x76\x9c\xfe\xb9\x46\xe3\xfc\xd5\xc1\xf1\xd1\xdb\x97\x70\x05\x87\xb7\xe6\x3d\xda\xa7\x6f\xec\x20\xa4\x2e\x44\x29\x66\x23\xc9\xad\xbe\xa1\x63\x35\x92\x2f\x17\x63\x94\x17\xae\x21\x05\x08\x4e\xc7\x5b\x28\xea\x44\x13\x25\x78\xb0\x1a\xd8\xd8\x70\xb7\x6a\xcd\x6a\x80\xbf\xc9\xf3\x16\x8d\x13\x3e\xfe\xee\x82\x43\xbf\xcc\x74\xa9\xd4\x7d\x46\xa3\x15\x4b\x68\x33\x17\xd2\x3c\xee\x43\xc0\x4d\x65\xd8\x0c\x5a\xbe\xdd\xd4\x5d\x37\xe5\x3b\x81\x4e\x91\xb4\x9a\x0f\x84\x92\xd6\x56\x53\x61\x35\x74\x93\xf0\xd2\xde\x2a\xcc\xf8\x2b\x08\x5c\x7e\x64\x1c\x8d\xa6\x23\x19\xc3\x42\x87\x1c\x01\xa8\x9f\x61\x30\x61\x23\xb8\x49\x9d\x22\x18\x9c\x13\xbb\x73\xdb\x9c\xe6\x2e\xf5\xc7\x4b\xa3\x8b\x1c\xef\x40\x0e\x8c\x2e\xbd\x3d\xf0\x3e\xc2\x78\xe2\xec\xe1\x0f\x98\x5a\x29\x4b\xdb\x33\x25\x1d\x54\xe1\x2c\xf1\xa0\x4a\xdd\xbf\x7c\x90\x1d\x31\x24\x04\xda\x30\x1e\xb9\x6d\xea\x86\xd2\xfc\x0c\xfc\x26\x7a\x61\x38\xa8\xad\xae\x7e\x0d\x06\xd4\xef\x94\x5a\x5e\x7f\x15\x4d\x90\xbe\x7a\xb6\xbb\x72\x1d\xac\x74\x3c\xdf\x74\xa9\xb0\x01\xc8\x59\xe8\xe7\x83\xd0\x2f\xf2\x47\xb5\x76\xfa\x34\x40\x3e\xc8\x81\x66\xad\xc2\x87\xf0\x9b\xbd\xf2\x36\xff\xf9\x1f\x5e\x95\x3f\x43\x10\x11\x3e\x37\x00\xc2\xf2\x0e\xc9\x11\x02\x40\xee\x78\xdf\xc5\x17\x86\xbf\xee\xbd\xb3\x87\xf6\x5b\x01\xb1\xc8\x29\xa3\x46\xe8\x91\xbd\xb3\x33\xad\x97\xab\x1a\x95\x81\xf8\xf9\x80\x3a\x54\x44\xc8\x18\x3b\xda\xda\x8f\x31\xff\x03\x3d\x79\x2b\xbf\x09\x24\xbf\x91\x2a\x23\xbd\x4a\xea\x5a\xbd\x84\x73\x36\xb9\x7e\x91\x17\xe6\xc7\x1a\x78\x19\x25\x11\x46\x28\xfc\xbc\x71\xa3\x7f\xb2\x46\x83\xe3\xf2\x2b\x12\x4a\x26\x24\x08\x4a\xf8\x42\x1c\x0a\xc9\xcf\xb1\x0a\x11\xe4\xca\xa4\x16\x2d\x23\xed\x07\xb9\x21\x1a\xeb\x38\x20\x55\x92\x6f\x30\x2c\x2d\x16\x5f\x5e\x06\xec\x56\x57\x49\x7d\x30\x70\xc6\x5a\xb5\x8e\xed\x07\xe0\xf0\xc1\xfa\x25\x5f\x6b\x7b\x18\x38\xe8\x24\xc1\xd8\x0d\xad\x1b\xf2\x5d\x96\xa8\x91\x8b\xef\x6c\x79\xa8\xe1\xd4\xbc\xbb\xbc\x93\x12\x0b\x6a\x94\xec\x00\xfe\xd5\x60\x2a\xc9\x95\xc5\x5d\xb2\xbc\x0a\x54\x63\xf2\x99\xb0\xa6\x96\x36\x78\x3b\xaa\xce\x05\x94\xbd\x54\xe6\xcd\xb2\x25\x86\x2b\xd3\xd6\x44\x51\xd3\x7c\x9c\x95\xb8\xe6\xb2\x42\x94\xb8\x60\x55\x2e\x75\x57\x08\xd6\x39\x2c\xf5\x48\x86\xda\x30\x42\x53\x6b\x53\xe0\xff\x73\x21\x36\xb7\x9c\x74\xd0\xfe\x32\xc9\xd5\xc0\xe4\x1e\x16\x61\x4d\xe8\x68\x72\xac\x90\xe7\x91\xa2\x97\x49\x6e\x3b\x27\x27\xaa\x8e\xc7\x5d\x86\xf5\x36\x9a\xc2\xe3\x06\x37\x61\xd0\x8c\x31\xc3\xf2\x91\xb4\x18\x92\x62\x8d\x28\xc9\x82\x38\xcd\x1a\x51\xa2\x05\x17\x8d\x44\xb2\x35\xe6\xa5\x5b\x63\x06\xc2\x35\xe6\xa4\x1c\x2c\xee\x66\xbf\xab\x90\xe8\x59\x89\x18\xbd\xbb\x55\x31\xd7\xb0\xaf\xd5\x4b\x75\x8c\x2b\x0a\x08\xa3\xfb\x27\x4f\x04\x38\xf0\x37\x93\x54\xca\xe9\xaa\x46\x76\xdf\xab\x33\x75\xbe\x9a\xdc\x7b\xd9\x4b\x36\xa1\x1d\xc7\x1b\x11\xda\x1f\x84\x63\xec\x06\x9a\xa8\xdb\x01\xdc\x76\x16\xa5\xa3\xc4\x40\x86\x26\x42\x87\xc8\x26\x65\xdb\x78\xda\x26\xed\xb1\x6b\xf5\x6d\xb6\x59\x1f\x0b\xc1\xf1\x88\xf7\x82\x6d\x8c\x84\xb0\xb3\x58\x3b\x07\xac\x99\x24\x41\x89\xe8\xad\xac\xe0\x06\x9c\x8b\x58\x6d\x8d\xe2\x72\x1e\xee\x34\xbf\xb3\xce\xcb\x45\x84\x91\x49\xad\x5f\x3a\xbd\x72\x77\x7a\xbf\xd5\xce\x5e\x34\x7b\x17\xd3\x6a\xa6\xb6\xa3\x4a\xdd\x83\xf2\xd2\xac\xd0\x2f\x76\x27\xff\x88\x17\xe4\xea\xc6\x3b\xcf\x19\x77\x6c\x64\xf8\x5f\x7e\xe1\xdf\xda\x74\xe0\xd3\x16\x1a\x48\x48\x30\x05\x58\x73\x64\x99\x81\x15\xf6\x58\x33\x17\x97\xec\xe5\xea\x2a\x91\xef\x7d\x5c\x33\xd4\xfa\xd0\x94\x3e\xd6\x4b\xbf\xe8\x28\x80\xcb\xa7\x4f\xdd\x02\x89\xbc\x90\x60\x93\xb5\x30\xd1\xfd\xc7\x8e\x67\xb5\x69\x1b\x14\xb0\x5f\x7e\xf9\x45\x0f\xc1\x83\xb1\xfa\x7e\xf9\xe5\x97\x2e\x0d\x6b\x46\x1f\xd8\xcb\x5f\xc4\xb5\x00\x36\xeb\xb0\xa6\x7e\xb9\x5b\xfa\xe5\x17\xa6\xb8\x4d\x6c\xd5\x5e\xbc\x45\x3b\xd2\x62\xf2\x98\x40\x52\xf8\x25\x56\xcc\xa8\x9d\xbc\x19\xbf\x5f\xcf\x94\x29\xfc\xcf\xf1\x50\x02\x6a\x3f\x90\xb2\x8c\x67\xc3\x23\xdb\x6d\x7b\x23\x74\x67\x94\x3c\x95\x23\x2f\xc4\xd1\x51\x8d\x97\xc8\x44\x7b\x1a\x87\x9f\xf5\x4a\x82\xc7\xcf\xe6\xbd\x9a\xf2\x2d\x4e\x29\xdc\x0d\x9c\xf5\x28\x0d\x83\x53\xda\xb5\x83\xd0\x4f\x3b\x9c\xaa\x6e\x3c\x4f\xa9\x90\xb5\x85\x30\x4b\xfe\xd8\x6d\x84\x70\xbb\xb5\xc4\xd8\x06\x80\x0c\xf1\x39\x36\x25\x74\xa1\xdb\xf7\xfa\x18\x5b\x8a\xfa\x28\xf8\xad\x76\x5b\x14\x0d\x3d\x74\x0f\x7e\x4a\x4e\x5c\xee\x3d\xe3\x5f\x53\x9f\x78\x2e\x38\xca\x0f\x9d\x36\x61\x43\x62\xb9\xc4\x1b\xb9\x24\x42\x47\x19\x53\xce\x72\xdb\x00\x94\xbb\x4b\xe9\xb0\xd5\xf2\x33\xf6\x86\xd2\x05\xbe\x6f\x5d\x51\x12\x0c\x7d\xd8\x22\xe0\x89\x36\xb1\xc0\x48\x46\xe0\x4e\x70\xbf\x83\xc9\x51\xd9\x20\xd1\x20\x64\xeb\x9a\xe7\x83\xc3\x96\x07\xc7\xe5\x0e\xb5\xae\x44\x6b\x56\xcb\xf7\x82\x40\x14\x0d\x70\xb7\x91\x38\x51\x58\x33\xd1\x11\xd6\x4a\xe4\xe3\xd1\x2a\x36\xef\xdd\x7a\x10\x2f\x76\x4e\x9a\x8c\xdc\x3c\x26\x62\xe2\x1c\x7b\x0e\x47\x63\x19\x07\xa6\x1d\x17\x44\x26\xe7\xa6\x5d\xcf\x73\xa8\xe5\xe6\x3b\x2e\x63\xaa\x8e\x7b\x11\x6d\xe7\x32\xe5\x6c\x72\x9a\x4b\xdd\x1f\x3e\x6d\xed\xe0\xc8\xdd\xf5\xbd\x51\x80\xf9\xb9\x92\xce\x9f\xe1\x38\x3b\x56\x3a\x6b\xc2\x6a\xc5\x7e\xd0\x6c\x65\xd8\x7d\x0d\x70\xc3\xa9\xd2\x01\xcb\xbf\xa7\xe4\x00\x2d\x44\xbf\x5a\xd7\x16\x1e\xf1\x70\x35\x8e\x4d\xab\x56\x10\xf0\xa7\x6b\xea\xb6\x3d\x9f\xdf\x21\x42\xa0\x86\x08\x98\x5d\x2b\xa0\xe0\x41\xf2\x38\xf4\x2d\x37\xe8\x78\x7e\xff\x31\x09\x86\x03\x00\x1e\xd2\x20\x8c\x55\x59\x45\xe4\x5a\x41\x20\xb6\xc3\xab\xab\xe4\xa3\x9c\xf9\x6c\x8a\xb5\x3d\x62\xb9\xe3\xb0\x67\xbb\x5d\xa6\x18\x72\xd2\xb7\xb9\x9c\x08\xec\x36\x2d\x41\x58\x12\x83\xfc\xba\x1e\x2b\x6e\x44\x4f\x60\xe2\x62\x54\xe4\xa0\xc4\x5a\x11\xc2\x00\x3c\x51\xc9\x47\xda\xbc\xb2\x31\xe8\x87\x63\x05\x21\x48\x20\x2e\x3a\x10\x80\x07\x61\x0d\x91\x0a\x01\x48\x25\x7e\x47\xc6\x6b\x0a\xc2\xb0\xd7\x60\x58\xa4\xf4\x5d\xbe\xb7\xfe\x1a\xec\x05\xc1\xb1\x35\x90\x16\x23\xc7\xde\xb7\x1a\xc9\xad\xf4\xbd\x6f\x2b\x3c\x5c\x1c\x3a\x0e\xb4\xed\x36\xb1\x43\x32\xf2\x3d\xb7\x4b\xac\xae\x65\xbb\xa4\x54\x42\xea\xf5\x03\xa8\x11\x88\x0a\x27\xec\xd1\x13\x4f\x88\x0a\x7b\x35\x82\x5f\x2b\x39\xdd\xb2\x0f\xc7\x71\x87\xb4\xbd\x16\x9c\x4d\x44\xd3\x24\x0d\x72\x85\x12\x94\x11\x15\xd8\xa0\x41\x1c\x89\x1d\x92\x3b\x17\x63\x8a\xa7\x16\x72\x77\xc3\xad\x47\x44\xdf\xf4\x93\x46\xf6\x69\x59\x01\x89\x6e\x80\x08\x72\xe5\x15\x1d\x4b\xeb\x48\x60\x04\x01\x0a\x8c\x4d\xc4\xa7\xa6\x4f\xad\xab\x6d\xd3\xa7\x98\x2f\x43\x7f\xe8\x8c\xc9\x0f\x7b\x00\x3f\x08\x11\x32\xf4\x41\xc1\x6d\x22\x6b\xc8\x90\x2b\x60\x90\xf6\xfd\xfb\xd7\xa0\x46\x84\x01\x7d\x2b\x90\x0f\x6c\x27\xfb\x94\xfc\xd7\x1a\xd8\x64\x30\x6c\x3a\x76\x2b\x5d\x9a\x7f\x27\x0c\xc6\xd7\x80\xd7\x67\x5d\x88\x7b\x18\x6c\x2e\x66\x63\xb2\x50\xb8\xa1\x7b\x13\x87\x3c\xdf\x4c\xda\x35\xcc\x7a\xb4\x60\xd6\xfd\x8b\x80\x25\xeb\xe0\x35\xc0\x47\x0c\xb6\xa1\x82\xd8\xa6\x35\xb6\x31\xa9\x62\x56\xe3\x69\x6d\x69\xf7\x48\x74\xd0\xa7\x7e\x37\x6d\x59\xac\x54\xd7\xe3\x65\xb3\x84\xbe\x2c\x24\xab\x4d\x08\x76\xb4\x1e\x2d\x98\x05\x9d\x17\x51\xb1\x7b\x61\x5a\x9f\x8f\x07\x5e\xd7\xb7\x06\xbd\x34\x85\x73\xa3\xbc\x99\x5a\x25\xab\xb9\x68\xd9\x08\x90\x5d\x36\x53\x65\x8a\xe1\x64\x83\xfd\xf4\x2a\x93\x1b\xd6\x0a\x47\xc0\xbc\xb3\x1c\x1a\xa6\xba\x09\x6c\x94\xb7\x92\xcb\x4f\x6e\x92\x17\x8c\x54\x3f\xb6\x6f\x6c\x37\xad\x8f\x1b\xe5\xe7\x89\xc5\x27\x37\x86\xe5\x64\xe5\xa0\x67\xb5\xbd\x51\x6a\x33\x95\x72\xb4\x64\x56\x0b\xbc\x88\xba\xa6\x60\x42\xdd\x16\x07\xdd\x89\x16\x55\xeb\x49\x85\x33\x2f\x35\x54\x31\x59\xf5\xdb\x11\x3f\x97\x4d\xee\xc3\x5a\xa4\x60\x16\x78\x2c\xa1\x3a\x3d\xb0\x5a\xe9\xf3\x68\x43\x9b\x48\xbc\x64\x26\x79\xb0\xc8\x0f\xb9\xac\x55\xa1\xa9\x70\xd4\x87\xf6\x79\x8f\xf6\x69\x7e\xca\x1b\x88\xb2\x79\x03\x51\xce\xba\x81\x28\x8b\x1b\x88\xc8\x75\xc2\x40\xce\x17\x71\xc4\xc6\xdf\x88\x0b\x05\xfe\x78\x04\x81\x16\x76\x12\x2a\x46\x9a\x04\xeb\x87\x68\x29\x01\x4c\xbe\x6f\x1a\x02\x42\x34\xad\xbd\x2d\xea\x6b\x3e\xbe\x8a\xa1\x60\x00\xc9\x44\x23\x01\xb0\xfc\xd6\x17\x53\x58\x60\x81\x2f\x44\x39\x7c\x8a\xb5\x2d\x6a\x65\x36\x6b\x42\x92\xaf\x43\x5d\x2a\x8b\x56\xd5\x4b\x51\x5e\xbd\x89\xb5\xae\x43\xc8\xc4\x20\x0e\x95\x4f\x7f\x01\x52\x34\xcf\x5f\x8b\x52\xa8\xe8\xee\xe0\xe9\x70\xda\xf2\xaa\x6e\xf8\x39\x94\x22\xb9\xc8\xf1\x11\x87\xd8\x95\x8a\xea\xec\x11\xa9\x01\x71\x28\x25\x56\x10\xa3\x12\x9b\xce\x41\xbc\x63\xe1\x20\x22\xd9\x12\x30\x30\x65\xb5\x6a\x57\x67\x4e\xe9\xba\x61\xf2\x96\x56\x5f\x5f\x62\x14\x8c\x28\x87\x15\xe4\x9d\x5b\x9f\xcf\x47\x01\x45\xe8\x34\x9a\x65\x03\x90\x0b\x23\xb0\x60\x96\x12\x27\x14\x51\x9f\x39\x6e\x35\x62\xcc\x01\xd5\xf5\x9a\x8e\x9a\xb6\xea\xc6\x7a\x57\x8c\x72\x02\xb7\x00\x47\x7a\x1a\x60\xf8\xfa\x92\xd8\xb9\xa2\x12\x7f\xe2\x7b\x51\xe7\x6e\x0e\x55\xab\x51\x23\xb1\x79\xc3\xc7\xaa\x66\xb2\xd1\xed\xad\x5a\x79\x04\x6c\xcc\xc1\xc9\x0d\x43\x84\x7a\x14\xa5\x9c\xb6\x4e\xd4\xcc\xc5\x45\xa2\x88\xcd\x22\xe2\xb5\x84\x2e\xc0\x77\x5c\x10\x6a\x72\xed\x30\x91\x00\x66\xe6\x99\x97\x53\xe3\xf6\x3d\x56\x71\xfb\x1e\x93\x17\x88\xb8\xd0\xbb\x14\xda\x82\x25\xc4\x7c\x11\xc2\x98\xcd\xc2\xea\x46\x91\xe4\x8e\xad\x90\xfa\xb6\xe5\xac\x7c\x38\xaa\xe1\x61\x16\x5f\xbb\xe1\x26\x9d\x35\x7f\x6d\xb7\xf9\x9e\xd3\x10\xfa\x62\xc3\x2b\x36\xcb\xd5\x0d\x42\x1d\x7a\x6d\xe1\xf4\x04\x77\x22\x2d\x49\xbf\x38\x5d\xe6\x95\xb7\x97\xee\xd8\xb6\xf1\x3f\xa4\x72\xd5\x14\x59\x90\x89\x77\x4d\xfd\x1e\xb5\xda\x64\xd4\xa3\x2e\xc1\xdc\xf7\xab\xa8\xd2\xda\x01\xf9\x8d\xac\x5d\x35\x4b\x09\x36\x1b\x26\x5a\x0b\x1f\xd1\x26\xc5\x64\xda\x5a\xcc\xf4\xfd\xde\x8f\x7a\x56\x57\xc9\x47\xcb\x0e\xc1\xfe\x21\xa8\xad\xae\x76\xed\xb0\x37\x6c\x82\x01\x44\x87\x87\x73\x5a\xed\x38\xde\x68\xd5\x0e\x82\x21\x0d\x56\xd7\xb6\xca\x3c\xcc\x17\xdb\xed\xb7\x59\x9f\xcc\x98\x2a\x84\x95\x66\xdb\xcb\x55\x8e\xf9\x0a\x04\x7d\x5b\xe9\xd8\x0e\x5d\x81\x64\x16\x18\x1a\x4e\x9c\x7e\x74\x7d\x30\xe7\x66\xb8\x6d\x94\x6b\x24\xf7\xaf\x8e\xc5\xfe\x03\x49\x52\x29\xe3\x9b\x0d\xf6\x1f\xbc\xa9\xe2\x1b\x0a\x7f\xf0\x66\x8d\xbf\x29\xb3\xff\xe0\xcd\x3a\xbe\x69\xb6\xd9\x7f\xf0\x66\x03\xdf\x3c\xa7\xec\x3f\x78\xf3\x0c\xdf\x6c\x6e\xb0\xff\xe0\xcd\x26\xbe\x79\x56\x61\xff\xc1\x9b\x2d\x7c\xb3\x5e\x65\xff\xc1\x9b\xe7\xf8\xa6\x5a\x61\xff\xc1\x9b\x3a\x47\xb1\xbd\xc1\xfe\xc3\x57\x1c\x47\x0b\xfe\xf0\x15\x47\x69\xad\xcc\xfe\xc3\x57\xf1\xf6\x5a\x9e\x1b\xfa\x56\x10\x72\x1d\x6b\xcf\x73\x3c\xbf\x46\x72\x6d\xcb\xbf\xca\xa5\x18\x19\x31\xe2\xc5\x76\xdb\x5b\x8b\xd9\xb9\xde\x3b\x8b\xa1\x49\x6c\xbf\xef\xb9\x7c\x9c\x9b\x8e\xd5\xba\x62\x9d\x2f\x97\x91\x18\xa3\x9e\xcd\x56\x8b\xdc\xbf\x3a\x9d\x0e\x46\x45\x66\xe2\x10\xef\xe6\x6a\x24\xe7\x77\x9b\x16\x13\x4a\xfc\x7f\x05\x28\xd2\x19\x3a\xce\x2e\x07\x64\x16\xa8\x60\x01\x46\xb7\xe4\x02\xe5\xd2\xd6\x26\x96\x71\xec\x6e\x2f\x4c\x2b\xb4\xb1\x8e\x85\xfa\xb6\x9b\x56\xa4\xfa\x8c\x23\x63\xd9\x6e\x2a\x9c\x4a\x55\x61\xfc\x91\xf7\x14\xca\x54\x37\x36\x8a\x44\xfd\x9f\x86\x77\x56\xb1\x08\xf6\xd9\x45\x59\x1f\x52\x78\x07\x87\x24\xce\x3d\xf7\x6b\x27\x2b\xda\xd5\xf6\x05\xd2\x13\x09\xb4\x71\x88\xd5\x99\xb2\x7d\x59\x57\xe7\x1c\xac\x58\xd6\xde\x85\x7d\xff\x21\x1b\x97\x38\x21\xd5\x6d\x80\xe5\xfb\xca\xa0\xde\x34\xdb\x61\x9f\x62\x31\x71\x21\xc6\x44\x91\xad\x8f\xac\x6b\xb2\xa0\x88\xe7\x80\x59\xa6\xd4\x0b\x91\x63\x8a\x2b\xaa\xac\xda\x85\x7d\x09\x1b\x24\xff\xc2\xbe\x4c\xb2\xac\x64\x65\xc0\x74\x4c\x37\x4b\xe1\xdf\x60\x9d\x07\xba\xaa\x45\x9e\xa1\xb9\x2d\xad\x1a\x23\x9c\xf1\xd7\xb4\x59\xc4\x33\xdb\x20\xc9\x80\xfa\x41\x8f\xec\x7e\xbc\x75\xf6\x5f\xea\x90\x70\xaa\xe8\x11\x5b\x29\xc5\xb3\x66\xb2\x59\xd2\xcc\xc8\x25\x73\xe2\xa4\xf5\xf9\x79\x4a\xf9\xac\xae\x46\x20\x47\xce\xad\xf6\x44\x9e\x9f\xc4\x83\xca\x72\x52\xe9\xcc\xc6\x34\xa0\xca\x98\x3e\x2d\x8b\x4f\x6a\xbb\x95\xc9\x75\xb3\xb0\x48\x6f\x50\xdd\xe7\xf1\xdc\x45\xa9\x28\xc4\x8b\x66\xb5\x28\xc1\x15\x92\x17\x23\x20\xcb\x19\x44\xa1\x10\x60\xc1\x72\x3f\x23\x5b\xa3\x56\x2a\x8b\x9f\xa0\xc0\x0f\xf1\x70\x50\x7c\xe7\x5a\xfd\xd4\x16\xaa\x09\x45\x33\x8f\x45\x65\x29\x75\x28\x6e\x87\xbd\x33\x21\xf5\x12\x8f\x2d\x13\x8a\x66\x1e\xa1\xcb\x52\xb2\xe2\x51\xcb\x73\x77\x87\x61\x08\x5a\x5b\xe2\x10\xac\x95\x13\x0a\x67\xb5\xa2\x4a\xc9\x8a\x30\xe5\x76\xbd\x9b\x93\x61\xe8\xd8\x2e\xdd\x75\x2c\xf7\x2a\x4d\x9c\x3d\xdb\xc8\xac\x96\xd5\x72\x52\xf9\x18\xb0\xd4\x76\x9f\xc7\x8a\x4e\xd3\x96\x41\x9c\x34\x71\xb5\x6e\x94\x9a\x44\xbc\x1f\xa2\xe0\xc0\x39\x92\xd5\xa4\xce\x3b\x67\xd8\xb5\xdd\x43\xc7\x1b\x99\x41\x6e\x81\xe9\x99\x74\x6e\xf0\xab\xd3\xd4\x39\x5a\x9a\x11\xce\xed\x6d\xca\x9c\x2c\x59\xee\x78\x7b\x26\xd4\xde\x7a\xa9\x71\x9a\xa6\xc7\x0b\x80\x4c\x83\x94\x54\x41\x62\x3a\x09\xb8\x60\x7b\x5e\x28\xdc\xa2\x79\xe6\xa4\x1a\xc9\xd9\x2e\x63\xc5\x95\x8e\x43\x6f\xf8\xb1\x99\xe5\xd8\x5d\xf7\x28\xa4\x70\xc9\xdd\xa2\x6e\x28\xd3\xa8\xa9\xe3\xa1\x1a\xc9\xb9\x9e\x4b\x73\xc2\x27\x06\xa2\x00\x0b\xe0\xad\xa1\x1f\xc0\x9e\x91\x4b\x5b\x71\x1c\xe7\xc9\xba\x56\x33\xf0\x9c\x61\x48\xf9\x17\x6f\x60\xb5\xec\x50\xe4\x22\x26\x64\x64\xb7\xc3\x5e\x8d\xe4\x2a\xe5\xf2\xbf\x79\x91\x1e\x65\xbb\x0c\xf3\x5d\xe8\x0d\x64\x15\x87\x76\x42\xf9\xd0\xb7\xfc\xae\xed\xca\xc7\x81\xd5\x6e\xc3\xd9\x55\x59\xa0\x2b\xf9\xed\x3b\x3c\xf2\x1c\x1c\xe2\x91\x1f\x21\xc0\x33\x28\xa0\x33\x0c\xb8\x9e\x86\x87\x5b\x79\x3c\x25\x47\x1d\xf2\x85\xe9\x8b\x5f\x8a\x91\x84\x19\x76\x20\xda\x06\xbb\x82\xa7\xab\x3a\x32\x29\xc3\x6d\x64\x44\x4a\x2c\x21\x72\x9d\x27\x7e\xc4\x9b\x79\x9e\x5a\x5c\x62\x78\xde\xa3\xc4\x6e\x81\x3f\x86\xe0\x0d\x3c\xb4\xca\xc6\x97\xf5\x4c\xf8\xaf\xb0\x8f\xe2\x70\xad\x08\x86\x13\xdc\xbc\x18\x5c\xe0\x30\x59\xa8\xe7\x86\x6c\xbb\x68\x85\x43\x9f\xc6\x7a\xcc\x44\x4b\x4d\x18\x30\xce\x34\xbf\xcc\x28\xc4\x2f\x66\xaa\x9c\x4a\x67\xcc\x80\x3e\x03\xa8\x08\x49\x3f\x04\xb4\x33\x74\x18\x41\x51\x67\xc7\xb3\x48\x34\xe9\x19\x0c\x1c\x9b\x1f\x41\x0a\xda\x06\x1a\x3d\xd8\x52\x4b\x83\x74\x0e\xc0\xcc\xf2\x46\x6b\xff\xb5\xbb\xae\xe7\x53\x13\xc6\x5b\x9e\xb8\x2f\x83\x11\xb2\xa1\xf0\x79\xb2\x37\x81\x25\x81\xe1\x96\x32\x38\x9e\xc7\xf5\x12\x1c\x21\x26\x98\xea\xb2\x9a\x72\xf3\x36\xe1\xdb\x83\x81\x43\x09\xed\x74\x68\x2b\x9c\xdc\xd2\x29\x14\x9f\xa1\xb9\xe9\x67\xc8\xd0\x7d\x80\x39\x62\xff\xb3\x26\x47\xaa\x44\xb4\x06\x03\x6a\xf9\x01\xd8\xfb\x87\xd4\xef\xdb\xae\x15\xea\x64\xd0\x5f\x3f\xc8\xe8\x25\x34\x7c\x4f\x23\xa8\x03\xfe\x87\xc9\x3a\xb5\x33\xd7\x65\x1b\x64\xbd\x01\xcd\xe0\x0b\xa1\xa8\x5b\xe9\xe4\x18\xe0\x8e\x7e\x36\x39\xf7\x01\x72\x7d\x58\xa1\xb0\xeb\x1b\xab\xb4\x2a\xc4\xa7\x98\xb3\x19\xdc\xc7\x78\xfb\x22\x64\x19\xdc\x92\xc9\x81\x8e\xa0\x71\x4a\x3b\xa9\x48\x30\x5a\x73\x14\x92\x65\xa4\x3b\xab\x90\xdd\x93\x51\xe6\xc1\x86\x52\xb2\x21\xa4\x35\xc2\x25\xd6\x72\xbb\x42\x7c\xf0\x46\x23\x09\xc6\x20\x62\x0e\x70\x35\xfe\xe2\x09\x27\x44\x6a\x2f\xde\x82\x59\xb7\x89\x66\xc1\x77\x62\xbd\x85\xea\x5f\xf8\xc3\x17\xee\x28\xc7\x21\xa0\xc0\x96\x7d\xf4\xdc\xbd\x9e\x48\x21\x39\x89\x4a\x29\x64\x0a\xad\xa6\xb8\x22\x9c\x57\xaf\x51\x19\x32\x67\xd4\x6c\x8c\xae\x25\x30\x01\x3f\xd2\xcb\x84\x8b\x27\x91\xab\xe4\xed\x6e\x8d\xc9\x03\x3e\x46\x45\x32\x70\xa8\x15\x50\x32\x1c\xb4\xd9\xe8\xc1\x4a\xd9\xf4\x6e\x8a\x04\x0f\x11\xc0\x7a\xf7\xd4\x6a\xdb\x1e\xab\x1b\x78\x2a\xa7\x5d\xfd\xdd\x91\x34\x01\xc5\xab\x28\xb6\x74\x00\x94\x76\x69\x26\x95\xf3\x44\x5a\xa8\x7c\x57\x4b\xf6\x3c\x02\x46\xee\xa3\xe6\x94\x31\xbc\x7e\xc9\x0e\x4e\x85\x81\xf0\x22\x75\x6b\xb3\xe2\x7d\x3f\xe2\x8d\x43\x2b\x68\xa8\x14\x63\xaa\xd0\x4f\xf2\xde\x33\x79\x41\x0e\x9f\xf3\x74\xd7\x93\xa6\x21\x3f\x71\xc3\xf3\x5b\x3c\x79\x93\x91\x2c\x4c\x6b\xea\xe4\x23\x1a\x65\x7d\x01\x6e\xab\x1a\xc4\xb5\xe9\x21\x26\x40\x89\x58\x93\xa1\x08\xd0\x6c\xc9\x58\x0b\xf7\x66\x48\x26\x8d\x9a\x7c\xda\xf9\x55\x9b\xf5\xd8\x83\x4e\x49\x7b\x25\x8a\xc6\x4b\x99\x15\x23\x4d\x22\x89\x6b\xb1\x82\x49\x2d\xcb\x79\x11\x69\x5e\x9b\x2f\x11\x2c\xb4\x2f\x11\x64\x34\x58\x09\x18\xad\x45\x30\x92\xa5\x0d\xb4\x24\x3f\x09\x7c\xe4\x0b\xe5\xa7\x6f\x96\xd0\xab\x44\x9a\xcd\xb5\xb8\x58\xcf\x89\xb6\x65\xd9\xed\xa4\x45\x8f\xac\x40\x12\x44\xdf\xb5\x9c\xe4\xe5\xc6\xe7\xcb\xc3\x2e\x5b\x3a\x8c\xdc\xfd\x30\x6d\x7e\x8d\x64\xf0\x27\x78\x49\x26\x0f\xb8\xd5\x45\x99\x02\x53\x24\xb1\xba\x3c\xed\x98\x84\xae\x0a\x6b\x99\xef\x05\x5f\xae\xcb\x24\x65\x68\x66\x4a\xfb\x83\x22\x69\x60\x84\xe2\x06\x66\x93\xc2\xcf\x68\xec\x64\x5e\x6b\x28\x84\xb0\x82\x6a\xa9\x20\xeb\x29\x4f\x6c\x07\x9c\x55\xa3\xb3\x00\xf2\xfc\x07\xf2\x02\x92\x95\x2a\x14\x49\xe3\x0a\xec\x32\xca\xdb\xf8\xeb\x3f\x50\x1b\x1f\xcc\xd8\x01\xac\xf2\x45\x83\xe7\x8e\x50\x93\xa5\xa1\xbb\x2f\xdc\x2d\x49\xef\x6c\x38\x96\x6c\x60\xfa\xad\x3c\xf4\x16\x7f\x60\x00\x6e\xe8\x63\xfa\x95\x46\xb4\xbb\x79\x20\x20\xd9\xd1\xfa\x5d\x6a\x34\x20\x72\x67\xa3\x01\x91\xaa\x18\xbc\xc8\xdd\x53\xd2\x20\x16\x0a\x60\xcf\x53\x62\x4a\xf4\x18\xa1\x16\xc9\x05\x6b\xe4\xb2\xd4\xf2\xdc\x96\x15\xe6\x59\x3f\x0b\x85\x02\x1f\x1b\xf1\x6f\x09\x95\xc7\x1d\x26\x17\xf8\x1b\x9b\xdb\x17\x62\x6a\x46\x7c\xd7\x14\x27\xe9\xfa\x4b\x3b\xd8\xf3\xdc\xd0\xf7\x1c\x07\x12\xa5\xe8\x9f\x7a\x96\xdb\x76\xd0\xb8\x0f\x15\x40\x83\x59\x41\xf5\x8c\xc6\x6f\x10\xca\xe5\x0e\x6a\xa6\x25\xcc\x67\x50\xe2\xaf\xb5\x4c\x78\xe0\x60\x1e\xc7\xc0\x0c\x22\xc0\x3b\x27\x42\x03\x7d\x57\xa7\x63\xa2\x9d\x3b\x23\xeb\x9d\x01\x1d\x2b\xb3\x95\x27\x28\x09\x0d\x36\x09\xbc\x59\x02\xbb\x55\x14\x0d\x24\x25\xd5\x13\xd9\xb1\x8b\xd3\x33\x8a\x36\x93\x0a\xc6\x0d\xb9\x66\x3b\x88\xb7\x76\xc9\x93\xfb\x42\xa0\x7d\x45\xc7\x35\x92\x93\x52\xe5\xa3\xed\x38\xc7\xde\xd0\x15\x87\xac\x52\x99\x55\x6b\x51\xac\x68\x3e\x3a\x66\x03\x7e\x68\xa9\xa8\x81\x76\xa0\xf8\x97\xc4\x24\x48\x32\x31\x06\xc6\x5a\x15\x1d\xe2\x09\x23\xcc\x63\x1e\xb6\xe4\xe7\x22\x78\x75\x49\xf9\x09\x8c\xad\x95\x8f\x30\x84\xe1\xcc\x26\x99\x03\xd1\x33\x17\x88\xd8\x8a\x9a\x58\x88\x87\xfd\xd3\x83\x4b\xa4\xa7\x55\x2c\x12\x73\x54\x30\x2f\x6f\xea\x48\xe0\xe7\x18\xf5\x1b\xf2\xac\x4e\x1a\xff\x6a\xdc\x59\xe5\xe3\xa2\x91\x55\xde\x0b\x9a\x63\x56\x4c\xa2\x05\x77\x1c\x6b\x18\x03\x16\x29\x89\xc7\x8d\x5a\x29\x7c\x91\x50\x8a\x21\x19\x81\x28\x5e\x27\xb6\x2e\x16\x77\xa3\x75\x5d\x17\xc0\x3f\x71\x4a\x67\x82\x16\x6f\xcd\xb2\x76\xcb\x73\xcd\x72\x76\x0c\x9e\x3a\x5b\xd0\x4a\xc9\x77\x09\x65\x4f\x41\x2f\xd3\x4b\x9e\xd2\x8e\x59\x0e\xe2\x02\xca\x32\x6e\xac\xc7\x42\x7c\xa8\x32\xe2\x8d\x59\x4e\xec\x83\x55\x39\xf1\xc6\x2c\x27\x42\xb0\xf0\x42\xf0\x18\x69\x71\x36\x0b\x71\x04\x54\x24\x17\x39\x3e\x0e\xb9\x22\xc9\xf1\xa1\x96\x3f\xd9\x48\xc2\x83\x1a\x2a\xf6\x28\x86\x82\xfd\xb6\xf9\x3b\x45\x50\xf9\x74\x4a\x3b\xec\xb7\xcb\x81\x08\x02\x80\xc1\x39\xef\x24\xfb\x0d\x7d\xc9\xe9\xf9\x88\xb9\xad\xf7\xa1\xe7\xf7\xb9\x9c\x10\x9c\xcd\xa3\xa1\x95\xcc\xaf\x91\xc9\x20\xd0\x23\x3b\x06\x2b\x45\x24\x91\x09\xc2\x94\x42\x5a\x16\x45\x05\xcc\x0c\x9e\x10\x8d\x6e\xa3\x35\x6a\x42\x96\x8c\x9b\x16\xa2\x26\x65\xbd\x8c\xcb\xd9\x17\xc6\x2c\xae\x11\xb5\xd2\xab\xf5\xd4\x80\x25\x86\x50\x5a\xdd\xab\xab\x7d\xc5\x08\x7c\xcc\x4b\xbe\xe7\xb1\x65\x8e\x3f\xc9\xcd\x8c\x31\xd1\x99\x6e\xa3\xc4\x13\xd7\x2f\xb2\x63\x0d\xea\xe2\x4c\x42\x17\x82\x47\xae\xaa\x73\x41\x91\x12\x41\x12\xbf\x50\xd4\xc5\x67\xa1\x10\x61\x0c\x1b\xe5\x8f\xa0\xf1\x0b\x43\x2e\xd5\xa4\x2c\x89\x30\x8a\x88\xaf\x2c\xf6\x44\x22\xc4\x72\x84\x65\xe4\xc6\x25\x63\xb7\x68\xca\x73\xb8\x5c\x37\xed\xe6\xa5\x78\x61\x5a\x57\x4c\xd0\x69\x2f\x92\xd5\x1c\xa5\xc8\x4e\x87\x84\x6e\x22\x91\x84\x48\xa6\x97\x85\xf8\x93\x1a\x45\x8d\xe4\x82\x81\xe5\xe6\x52\x56\x8a\x1a\x49\x59\x1d\xd4\x6d\x4f\xb2\x8c\x57\x67\x85\x71\xb2\xf8\x9e\x63\xa4\x94\x8a\x7c\xf4\xf0\x30\x57\xad\xb9\xf8\x26\xef\x7a\x6d\x1a\x9d\xc1\x62\x85\xd5\xd4\x62\xaf\x4d\xb7\x8d\x32\x77\xfa\x1c\x16\x8e\x0c\xc5\x08\x1b\xe8\xcf\xd9\x43\x81\x72\x32\x57\x9c\x8e\xd0\x98\x10\x3a\xb6\x73\xc5\x3f\x3c\x77\x8e\x2f\x44\x52\x09\x9a\x2c\x4f\x52\xa8\xa8\x4e\x7b\x93\x37\x01\xd9\xc3\x4d\xf9\x0a\x3a\xef\x90\x67\x2c\x87\x3c\xc2\x99\x39\x24\xda\xc2\x1e\x8b\x3f\x66\x70\xc2\x24\x2e\x90\x1b\xa6\x18\x13\x88\x4c\x67\xb8\xc4\xc5\x01\x28\x2d\x02\x5b\x88\xd6\xbe\x4b\x67\xa9\x42\x41\x3e\x15\xb6\x4d\xed\x52\x2c\x90\x7c\x8e\xab\xdd\x00\x58\xc6\xe6\xa3\x8c\x16\xd9\xf7\x6b\x5b\x51\x5e\x42\x37\x4d\x88\x5c\xba\xa7\x1d\xd6\x44\x2e\x4b\x65\x44\x6c\x71\x1f\xa9\x1d\x0a\x89\x10\x07\x5a\xbb\x7a\x84\x5a\xd9\xae\xb9\x56\xd6\x32\xa2\xd1\x22\x44\xcd\xd7\x06\x3d\x82\x94\x25\x99\x9a\x36\x68\xe7\x52\x24\xdf\xf9\xac\xc8\x1d\x0f\x6d\x85\x48\x8e\xdc\x19\x9b\xec\x84\x90\x61\x5b\xd3\x84\x0c\xfb\xeb\x86\x06\x10\xf6\x3e\x76\xf0\xd1\x6e\x87\xbd\x7d\x6f\xe4\x6a\x56\x40\xfc\xed\x87\xc1\x0f\x37\x4e\xfe\x69\x2a\xfc\xd3\x54\xf8\x1f\x61\x2a\xfc\x70\x96\xc0\xf0\x74\x70\x4d\xdd\x50\x8b\xef\x9d\x38\x13\xd7\x32\xea\x4c\x6c\xcf\x28\xad\x39\x03\x34\xbd\xa1\xdb\x4a\x0d\xd6\x50\x8d\x95\xcc\x8e\xaf\x81\x65\x94\xd5\xaf\x6f\x0d\xf6\xd1\xda\x82\xef\x4a\x12\x7d\x13\xd6\xd3\x2a\x64\xda\x0a\x9b\x45\x0d\x4b\x63\xe1\x33\x9c\x38\xdf\xaa\xf1\xa2\x93\x6c\x92\xa1\xd0\x9c\x01\x36\xfe\x4a\x86\xb2\xaf\xec\x6e\x8f\xfa\x10\x83\x49\x6a\x0b\xa9\x93\xe5\xd9\xd4\xf6\xa9\x89\x60\xb3\xed\x55\xc9\xea\x2a\x81\x84\x23\x98\x77\xdf\xf1\x46\x24\xb0\x5c\x3b\x1c\xf3\x38\x50\xf9\xfd\x13\xf2\xf6\xe4\x9c\xec\x1f\xbc\x39\x38\x3f\x28\x48\xbf\x50\x56\xb2\xe4\xf9\xdd\xd5\xd0\x1f\xaf\xfe\xab\xfc\xfb\xa7\x8f\xa3\xfd\xee\xf3\xee\x79\xf7\x4d\x77\xb7\xfe\xfb\xfb\xd7\x9f\x0e\x8e\xf7\x5f\x6e\xed\xf6\x3f\x1c\x7d\xed\xb6\x6c\xe7\xfd\xda\xe8\xe5\x7a\xdd\xfb\x70\xf6\xf1\xe4\x65\xfd\xfc\xdb\xde\x79\xf7\xe5\xd6\xfa\x6e\xef\x7f\x67\xf5\x93\xf1\xd9\x46\x77\xf7\xc3\xcb\xf3\xfa\x9b\x8d\x9b\x60\x58\xbf\xfa\xdf\xfb\xd1\x78\xe3\xe4\xfd\xab\xc1\x46\xab\xfe\xe6\xec\xcf\xca\xb3\xaf\x9f\x87\x7f\x8c\xda\xad\x96\xe7\x77\x77\xd7\x3e\xed\xd7\xeb\x1f\x57\x3e\x94\x7b\xbb\xc7\xf5\x83\xee\xab\xab\xea\xc6\xef\xf5\xfa\xf3\x3f\x3f\xd6\x5f\x6f\xb4\x8e\x47\x7b\x87\xe3\x63\xf7\xdb\x59\x35\xa8\xbf\xea\xd6\x0f\x5f\xed\xd7\xeb\x9f\x47\xf5\xe1\x61\xff\xa0\xfe\xae\x5b\x7f\xdd\x72\x2a\xd5\x73\xe7\x39\x7d\x79\x68\x9f\xb4\xea\xe3\xe5\xf7\x1f\x3e\x77\x2b\x5f\x8f\xfd\xdf\x0f\xed\xcd\xfa\xde\x71\xfd\xf5\xf8\xfd\xf1\xc9\xe1\x41\xfd\xf8\x6b\x6f\x64\xef\x7d\x5d\xef\xee\x0e\xc6\xf5\x83\x41\xf0\xfc\xf7\x8d\x2d\xef\x7c\xef\x68\xfc\xce\xfe\x78\x72\x5a\x2e\xd7\x77\x83\x0f\x67\xc7\xf6\x7a\xfd\xd5\x87\xba\x5d\x79\xbd\x7e\x78\xd3\xa3\xf5\xdd\xe3\x8d\x8d\x97\x57\xf5\x93\xde\xb7\xe1\xf9\xeb\x57\x1f\xc7\xef\xac\x8f\x1f\xed\xbd\xf1\xf0\xe0\x4f\x6b\xe8\x9d\xdd\x54\x5e\x1f\x0d\xf7\xad\xf7\xde\xe9\xeb\x67\xaf\x2a\x6f\xba\xf6\xcb\x57\x2d\xef\x5d\x75\x6f\xf7\xdb\x78\xeb\xe5\xa7\xe1\xb7\xdd\xcf\xfd\xfa\xd5\x1f\xd5\x4f\x2f\x5f\x7a\xbd\xd7\x95\x6e\xfd\xfa\x78\x74\xf4\xc7\xfe\xd1\xd7\xfa\x87\x93\xb0\x7d\xbd\x77\xf5\xfa\xf7\x8d\x77\x07\xaf\x5f\x3b\xbd\xfa\xf9\x33\xdb\xb9\xbe\xea\x75\xae\xb7\x0e\xaf\xc2\x37\xc3\xd3\x5e\xdd\x73\x0e\x07\x2f\x3f\x8c\x2b\xef\x3c\xe7\xf8\xd3\xb7\xe3\xd0\x7f\x55\xaf\xbf\xfe\xf3\xf4\xb0\x5e\x6f\x8d\xdf\x6f\xec\xf5\x8f\xbf\xf5\xeb\x07\x87\x7f\x04\x1b\x95\xe0\x79\x18\xbc\xff\xf4\x2e\x58\xbe\x6a\xdb\x83\xf6\x38\xfc\xc3\xba\xde\x7d\x69\x8f\x3e\xbc\x39\x18\x9e\xac\xbf\xdf\xfd\xe3\x7f\xfd\xd6\xeb\xaf\x7f\x3e\x7f\x6f\x79\xef\xda\xfd\x57\x67\xe5\x37\xeb\xe5\xff\xed\x9e\x7c\xe8\xbe\xbd\xda\x5f\xbe\xae\x1f\x74\xd6\x4f\x3e\xb7\x0f\xfa\xaf\x87\xbd\xf7\xfb\xef\x8e\xfb\xbb\x61\xe7\x5d\x6f\x7d\x7f\xf4\xaa\xf9\xfe\xe8\x55\x7d\xf4\xfa\xf5\xfa\x71\x7d\xa5\x5e\xdf\x6f\xbe\xbc\xa9\x7c\xaa\xbf\xad\xac\x1f\x8e\xba\x9b\xee\xc6\xe0\x6b\x37\xf8\x54\x0f\xdc\xf7\xee\x67\xe7\xa0\xfc\xbe\x7e\xb4\x39\xfc\xb4\x7b\x70\xf2\xa9\xff\xbf\xe6\xd5\xa7\x37\xd5\x9b\xea\xeb\xeb\xde\xe8\x70\xf7\xa8\xbb\x77\xec\x75\xff\x3c\x3b\xaa\x9f\xbf\xf9\xba\x7e\x7d\xf6\xc7\xf1\x78\xf7\x99\xf3\xf1\xe3\xe6\xf9\x51\xf0\xb6\xff\x69\xfd\xdd\xe7\x57\x7b\xeb\x6b\x6f\xde\xf7\x5e\xd5\xeb\x07\xbf\x9f\xd5\xf7\x3f\x5e\xed\x7e\x7d\xe3\x1d\x7d\xbb\xb2\x97\xf7\xbb\xf5\xdd\xad\xbd\xdf\x0f\xde\xef\x5f\x3f\x5f\xe9\xbe\xdf\x0d\xbf\x8e\x4e\x7f\xbf\x1e\xbf\x59\xe9\xb9\xbf\xbf\xfd\x7c\x72\xfa\xec\x68\xf4\x27\x7d\x77\xbe\x57\xf6\xdc\xdd\xff\xb5\x6e\xce\xce\x5f\x9e\x1f\xd7\x3f\xfc\x7e\xfc\x69\xa3\x5f\xaf\xaf\xbc\x39\x38\x7b\xe6\xbd\x1e\x1e\xec\xfb\x83\xf2\xc9\xd7\x97\xaf\x97\xbd\x97\x6f\xec\xa1\xb5\xb1\xf5\x7b\xb9\xfd\xfb\xc9\xeb\xf5\x72\x9d\x1e\xae\x1f\xd7\x97\x5f\xad\x6f\xbe\xfe\x1a\xd4\xfd\xcd\xeb\xdf\xb7\xfa\x7b\xf4\xed\xfa\xb5\xed\x1f\x8e\x06\x5d\xef\x70\xfd\x6c\xff\xd5\xe1\x41\x70\x5a\xff\xb8\x3c\xba\xf9\xfd\xf5\xd9\x9f\xef\x0f\xdd\xd1\xf5\xd9\xc6\xf1\xb3\xdd\xd3\x72\x6b\xd4\x3a\xec\xbf\xdc\x3d\x3b\x7c\x7f\xd6\x6b\xed\x76\xfd\x60\xf3\xd9\x69\xfd\xea\xf8\x70\xb4\x5f\xb6\xce\x5b\x9f\xaf\xae\x5f\x95\xcf\x8e\x3f\xdd\x04\xff\xab\x1f\xfd\xf9\xed\xf0\xec\x73\xef\xf8\xf3\xeb\xf2\xa0\x79\xd4\x6d\x79\xaf\xbb\x83\xce\xfe\x6b\xeb\x78\x6d\xa3\xf3\xf2\xec\xdb\xf8\xfa\xf8\x74\xe3\xea\x23\x1d\xbc\xf5\xba\xfe\xf2\xc9\x41\xfd\xc3\xcd\xe7\xd1\x9e\xf5\xc9\xb3\x87\xb6\x5d\x7e\xb3\xff\x72\xf0\xf5\xdb\x95\xbb\x55\x3f\x6a\x9d\xed\xad\xbb\xf4\x7c\xef\xf7\xb1\x7d\xb2\x71\xf6\x66\xfd\x88\x2e\xd7\x9f\x07\x67\xbd\xa3\xdf\xcf\xce\xac\xab\x95\xa3\xc3\x8f\x57\x07\xd6\xf2\xcd\xef\x07\xc3\xe3\xcf\x47\x1f\xdc\xf5\xeb\xfd\x0f\xcd\xd3\xc3\x5d\xef\xfd\xa7\xfa\x86\x43\xbd\xd1\xe6\xf0\xd5\xb8\xeb\xef\x85\xc7\xfd\xab\x37\xfe\xa0\x3f\x1e\xbb\xc1\xe8\x8f\xc3\x93\x8d\xf7\x57\xef\x5b\xbd\xe3\x5d\xf7\xed\x9f\xad\xbd\x67\xd7\x7f\xf6\xfc\x97\x6e\x65\xf0\xe7\xf5\xae\x35\xf8\xfd\xdd\xde\x56\x73\xd4\x79\xf3\xf9\x60\x74\x72\x36\xda\xec\xd3\xd3\xd6\xd5\xd1\xf2\x59\xeb\xf5\x87\xdd\xcf\x67\xa3\xf7\xcd\xe3\xfa\xd9\xe7\xd1\x2b\x7b\xf0\x7b\xd9\xb1\x5a\x95\xe3\xf7\xcf\x46\x1f\x3b\xf6\xc9\xf9\xab\xeb\xa3\xab\xbd\x4d\x1a\x9c\x74\x06\xa3\xfa\xcb\xff\xed\xee\xba\x95\xb3\xbd\xde\xd7\xfa\xba\x75\x3a\x18\x1c\x37\x3f\x0f\x37\xec\xcf\x47\x7b\xfd\x4e\xaf\x7f\xd2\xef\x37\x3f\xbb\xfd\xd1\x1f\x87\x57\xdd\x41\xd3\xb9\xea\x3a\xcd\xf1\xd7\x8f\x37\x6b\x95\xe0\xf3\xd6\xfe\xdb\x60\xd4\xfc\x3c\xda\xad\x7e\xdb\x6f\xfb\xe1\xf2\xef\xf5\xfa\x92\x0c\x86\xb6\x2b\x83\xf7\x8a\x94\x93\x01\x26\xbd\xb6\x3b\x24\x68\xf9\x94\xba\x68\xe3\x4e\xec\x00\xcd\xad\xd8\xea\xe8\x81\x17\xba\x15\x52\x9f\x84\x3d\x0b\x6d\xc2\xba\xf6\x35\x75\xb5\x20\x10\x32\x72\x1a\xda\x74\x21\x2c\xd0\xee\xb5\xb7\xaa\xb8\xf6\xd2\x76\x5b\xce\x30\xb0\xaf\x29\x59\x11\xb8\x41\x90\x3c\xd8\x43\xb0\xcd\xcf\x0c\xeb\x88\x5a\xfb\xd2\x97\xbe\x69\x17\x0f\x0d\xd6\x34\x2e\x0e\xfa\x5e\x26\x69\x7f\xa3\x12\x23\x88\x97\x5a\x04\x8e\xa2\x4e\x30\x65\x96\xa1\x48\x73\x3f\x69\x06\xb8\x5f\xb1\x38\x35\xe0\xc0\x0b\xa6\xdb\x6b\x5c\x8d\x80\x24\xd4\x90\x4c\xe0\xe6\xa4\xa3\x61\x5d\x20\xff\xd9\x99\x58\x5c\xef\x58\x24\x8f\xe3\x4c\x2d\xcd\xd8\x10\x77\xcf\x5d\x84\xe7\x1d\x1a\x04\xff\x67\x0c\x9f\xb9\x61\xe6\x6f\xa3\x2c\xc5\x5e\xff\x4d\x99\xca\xc0\x74\x0a\xae\xd2\x58\x63\x46\xa6\x32\x5b\x9a\xad\x21\x6e\x69\x89\x21\x8d\x2c\x87\x5f\x4f\xdb\x6e\x08\xf1\x61\x30\x36\x3a\x18\x6a\xbc\x3a\xd9\x9b\x49\xfd\x3d\xd9\x4b\x74\xcf\xa9\x07\xe4\x0b\x86\xc3\x2e\xd9\xae\x4b\x7d\xc0\xfa\x0b\x9a\xf2\x5b\xd7\x96\xed\x40\x40\x11\x4f\x0f\x8d\x5c\xc4\x9a\x23\x2a\x58\x8b\x71\x16\xde\xef\xda\x6e\x97\x58\x2e\x8f\xc4\x2f\x8e\xca\x99\x46\xdc\x1e\xc2\x37\x06\x04\xd2\x73\x90\xbe\x37\x14\x66\x41\xe4\xc8\xc5\x70\xa5\x81\x1d\x0e\xd1\x1c\x74\xec\x0d\x49\xdf\xee\xf6\x42\x32\xb2\x5c\x80\xcf\x63\x30\xb3\x6d\x69\x10\xda\x2d\x88\x7c\x3a\x18\xf8\xde\x8d\xdd\xe7\x77\xe4\x4f\x11\x45\x7d\xb6\x09\xab\x57\xc7\xd6\x02\x70\x1a\x45\x74\x3b\xe3\x43\xcf\x97\x01\x9d\x8b\x80\x42\x0b\x62\xe2\x80\x81\xbb\xc0\x7e\x18\x50\x7f\xc5\xea\x32\x78\x22\xbe\x27\x40\x5f\xe9\xd9\xd2\x8f\x45\x64\xb2\x69\x59\xae\x3d\x84\xb3\xc0\xfe\xea\xbf\x02\x6a\xf9\xad\xde\x0e\x96\xfe\x77\xb5\xdc\x83\x19\x2b\x2d\xb1\x21\xcb\xd4\x47\xf4\xfd\x9a\xcd\xb4\x52\x5f\x90\xe6\xb4\xae\xd4\x40\xdc\x8f\xa1\xa3\x02\x18\xb1\x48\xde\x1d\x83\xbd\x3a\xa3\x1b\x0e\x51\xcb\x72\x5a\x43\x07\x47\xdd\xf1\xba\x76\x4b\x99\x8a\x8d\xfe\x81\xd4\x10\xe9\x18\xa7\xac\x79\xe4\x7e\xa5\xad\x10\xef\x2c\xc4\xd4\xfd\xbf\x27\xcb\x5c\x56\xb8\xc9\xd5\xa7\x36\xc4\x7d\xc8\x41\xd1\x10\xc2\xd0\xe0\x6c\x84\x46\x76\xd8\x83\xf9\xa8\xaf\x82\xf2\xe5\x03\x07\x49\x14\xa9\x4d\xa5\xb9\x59\xcc\x28\xd2\x08\xa3\xe8\xd3\xc0\xfe\x46\x8f\xdc\x90\xfa\xd7\x5a\x54\x3d\xfd\xb5\xa5\x5d\x25\x9a\xef\xf5\xc8\x7e\x26\xa0\x08\xa6\x95\x67\xcf\xf4\xe0\x7e\x7a\x59\x7e\x89\xbc\xba\x4a\xbe\x40\xd2\xb5\x2f\xe8\x4d\x84\xcc\x4b\x9a\xd4\xf1\x46\x6c\xe1\x92\xe7\x49\x4b\xb2\x0f\x31\x12\xa7\x9a\x81\xa6\x1b\x82\x02\x8c\x74\x1b\x50\xcd\x0a\x54\x1f\x3b\x71\xb7\x86\x26\xa0\x51\x13\xa3\x74\x1b\xd0\xe9\xac\x40\x85\x92\x28\x2b\x3d\xb0\x09\xe8\x74\x46\xa0\x29\xf7\xe7\xf7\x67\x08\x4a\x76\xb0\xe7\xb3\x98\x80\x22\xa9\x62\xd6\x9f\xb3\x1a\x7f\x6a\xa4\xe0\x22\x52\x32\xaf\xea\xbd\x69\xdc\x79\x0a\x2c\x2c\xba\x2a\x8f\x79\x15\x6a\xd1\x4c\xde\xe2\x0f\x81\xa0\xc7\x0a\xf2\x54\x4c\x87\xd2\x6d\x16\x8a\x91\x29\x57\xb8\x17\x23\x4a\x6d\x30\x33\x0c\x29\xf9\xe4\xb8\x50\xe8\x47\xac\x28\xf7\xed\xb6\x69\x44\x99\x61\x46\x29\xca\x46\xc8\x31\x1b\x35\x94\x25\x69\x2a\x4e\x1f\x6d\xc7\xf9\xe0\xf6\xa7\x45\x4b\x2b\x9e\x84\x99\x3e\xd8\xa5\x16\x53\xef\x9c\xfc\x74\x08\x69\x7d\xca\xc0\x43\xef\xb9\xd6\xe5\xb8\x91\x95\x32\xb8\x05\x29\x19\xbd\x4c\x8f\x87\x0f\x8d\xd6\xd0\x63\xd4\x6e\xc7\xea\x36\x46\x5c\x98\x62\x92\x4f\xe3\x7b\x2c\xeb\xc2\x53\x72\x16\x5a\x7e\x88\x69\xd9\x41\x73\x76\xbc\x11\x0d\x42\x6e\x7c\x67\x05\x04\x72\x6a\xb9\x6d\xd2\xa6\xd7\x76\x8b\x06\xc4\xeb\x84\xd4\x25\x3d\xeb\x9a\x12\x8b\x04\x7d\xcb\x71\xb8\x2a\x1d\xc9\xaa\x10\x6b\x48\xd1\x84\xdc\x96\xf1\xe5\x4d\x80\xff\x06\x7d\xfc\xb7\xdf\xc6\x7f\x9d\x2e\xff\xee\x44\x81\x68\x7f\xb7\x2b\xf8\x37\xe5\xbf\xbf\x45\x41\x21\x99\x10\x14\x47\x45\xfb\x17\x50\xba\xe5\x28\xdd\x72\x94\x6e\x13\x50\x5a\x8d\x0d\x80\xc8\xfd\x57\x31\xc7\x66\xd4\xb3\x1d\x4a\xf2\x62\x78\x76\x54\x26\x35\x91\x21\x30\x6d\x8b\xc8\xa3\x90\xc5\x8c\x2e\xc0\xe0\x0d\xf3\x0a\x88\x05\x34\x05\x84\x4c\x1f\x18\x81\xb0\xba\x4a\xfe\xdb\xa7\x6d\xdb\x22\x96\x4f\xd5\x86\xbd\x48\x02\xb6\x97\xc3\x68\xa4\x14\xf8\xa2\x49\x7b\xd6\xb5\xed\xf9\x6c\xef\x45\xa3\x09\x34\x70\x43\x2e\x87\xf7\x3f\x3a\xff\xa2\xdd\x66\x70\xa1\x23\x7a\x99\x64\x40\x22\xf9\x36\xb3\x0f\x64\x85\x54\x2e\xa3\xd6\x25\x46\x5a\x06\xf5\x77\x17\xed\x2e\x42\x58\x8e\x0d\x4d\xa4\xa0\xc2\x04\x7f\xdc\xde\x92\xdc\x8d\x93\x8b\x50\x0f\xec\xeb\xb1\x00\xd3\xe6\x34\xcb\xc4\x51\x7c\xe2\x93\x09\x76\xdb\x44\xad\x57\x08\x33\xda\x95\x42\x86\x51\xd6\x34\x32\x2c\x62\x98\x3d\x95\x69\xf6\x94\x76\xd6\xe6\xc6\x55\xb7\x22\x56\x6f\xa3\x35\x42\x71\x3f\xa9\x89\xb5\x68\x99\x91\x09\x6e\x94\x04\x67\x6e\x0b\x60\x1d\x39\xb0\xce\x65\x18\xb0\x1f\xd0\x0c\xc6\x81\x36\xe9\x20\xc8\x30\x95\xdd\x1a\x1f\x4b\xc9\x3f\x51\xee\x60\xef\x74\x14\x92\x6c\xec\x0c\x0c\x56\x57\xc9\xc7\x1e\x75\xb5\x13\x16\xd3\x6f\x3f\x7e\x36\xa3\x2a\x8e\x28\xca\x6b\xd7\x23\x76\x9b\x5a\xc4\x6a\x7a\xc3\x70\xaa\x33\x11\x05\xe3\x48\x4b\x39\x35\xf0\xd1\xe5\xba\xe9\xd8\xee\x55\x00\x0e\xbe\x3d\xea\x0c\x30\x08\x05\x65\x8a\x9a\xed\xd8\xb8\x99\xe7\x67\x2f\xa0\x93\x93\xd0\xa7\x34\x86\x19\x13\x3c\xae\x17\x46\x3b\xd6\xb3\x9d\x76\xc4\x73\x4c\x56\x33\x61\xd4\x5d\x62\x39\xe0\x2a\x81\x7e\xee\x81\x38\x28\xe2\xce\xf7\x8a\xc8\x5f\xa4\xcb\x7c\x29\xb2\x26\x6b\x1c\x66\x6e\x78\xe2\x09\x3d\x23\xf9\xb3\xf9\x98\xe9\x43\x35\xab\x45\x2a\x49\x34\x67\x48\x36\x92\xfd\x4e\xd0\x9b\xa8\xc6\x18\x95\x69\x57\xb9\x22\xf1\x5c\x54\x6a\x6a\x71\x3d\x87\xdc\x15\x13\x1a\x4a\xc3\x49\xee\x99\x8a\xc8\xec\x05\xad\x6e\x92\xa6\xa4\xec\xd7\x79\x97\x81\xca\xdc\xb7\x67\x92\x75\x9e\x24\x7c\x72\x28\xec\x9c\x0a\x85\xad\x59\x1d\xe3\xae\xa2\x6d\x18\x54\xa0\x4d\x5c\xc4\x6c\x42\xcd\x4b\xad\x53\x39\xb9\x71\xcf\x15\x92\x62\x74\x4a\xeb\x3a\x34\x89\x50\x30\xc4\xee\x64\x1b\x0d\xf2\x92\xc3\xb8\x4a\xe0\x0f\x13\xae\xfa\x3e\x13\x35\xfe\x8c\xf9\xf9\x33\xe6\xe7\x4f\x43\xbe\xff\x47\x0d\xf9\xc4\xcc\xed\x59\x98\x6d\x99\xec\x10\xf1\x53\x37\xa3\xdd\xb7\xfd\x70\x4c\x76\x08\xff\xa5\x7f\xaa\xb7\x3d\xdf\xa5\x6d\xdc\x39\xb2\x12\xfa\x8b\x9f\x41\x43\xff\x0a\x41\x43\x81\x6c\xaf\xa8\x33\xa0\x7e\x5a\x2b\x9b\x4a\x3e\x9c\xd3\x9b\xd0\xf2\xa9\x95\x26\xcb\xb6\xd6\x63\x45\xb3\xf0\x11\x65\xfe\x6a\xc6\x7f\x52\x15\x10\x31\x0f\xd2\x23\xf9\xe8\xe6\x79\x7f\xc9\x60\x97\xab\xab\xe4\x0c\xb3\x74\x04\x44\x45\xd5\xe2\x2a\xb7\xee\xf2\x92\x2f\x94\x58\x61\xcd\x07\x06\xbd\x3c\xac\x56\x8b\x0e\xc2\x80\xd8\x61\x20\x93\x13\xca\x43\x1f\x0b\x14\x40\x56\x91\xd5\xfd\x6f\x40\xa9\xb2\x3f\xe4\xc9\x28\x4a\x3c\x41\x85\xed\xad\x02\xb3\xad\xb6\xbd\x56\xb0\xda\xf1\xfc\x7e\x50\xea\x85\x7d\xe7\x5f\xca\x9f\x79\x45\x85\xf8\x03\x70\x68\x9d\x80\x8e\x2c\xec\x59\xd8\x4a\xa8\xf8\x4c\xd2\x6a\x02\x23\x8e\xe1\x6d\x7f\x9b\xfd\xcc\xe5\x0a\xc4\xf3\x09\x06\x42\xd2\x3f\x7c\xa3\xbe\x57\x50\xec\x26\x44\x5a\x9e\xa7\xce\xff\xae\xee\x53\x44\xc6\x7e\xfd\x5e\xe3\xc9\x13\xed\xb5\x38\x97\x79\x14\x09\x1d\xcf\x41\x89\xb2\x7a\xde\x95\x32\x77\xa9\x58\x25\xfb\x7c\x30\x00\xff\x8e\x4d\x9d\x36\xdb\x92\xb4\x41\x9a\xe6\xad\xd2\x55\xc9\x2a\x91\x8e\x0d\x5e\xe0\x82\xbe\xa7\x34\x18\x78\x6e\x40\xe5\x40\xd2\x80\x55\x76\x18\xbb\x60\xb4\x35\x1a\x50\x37\xa4\x6d\xb6\x73\xbb\xa6\x1c\xaa\xe7\xb3\x91\x1a\x38\x56\x8b\xf6\x3c\xa7\x4d\x7d\x39\x5c\x48\x5f\xaf\xf9\x55\x7b\x3a\x3b\x3b\x4d\xa1\xf5\xa1\xe5\x04\x14\x63\x70\xb1\x7d\x18\x6f\x8c\x81\x17\xa9\xf4\xd9\x18\x00\x13\x25\xfc\x9d\xb3\x91\x82\xca\x96\x3b\x16\xc3\xe2\xf9\x62\xe4\xe0\x5c\x11\xe9\x54\x5a\xd2\xcc\x48\x60\x4d\xe1\x93\x5f\xc4\x03\x39\x3b\x4d\xbe\x3d\xab\x98\xb7\x67\x95\xac\xdb\xb3\xca\xa5\xf0\x5f\xd7\x53\xd4\x70\xb1\x92\x97\x4c\xc1\x04\x8c\x1a\x4d\xf9\x84\x3b\x8f\x1c\x9b\x7c\x0c\x9b\x27\x4f\x88\x51\x83\x4b\x9f\x3f\x8c\x8a\xfa\x4b\x5e\x3f\x99\x17\x2c\x97\x60\xa6\x22\x3b\x20\x16\x2e\x98\x6c\xd7\x1e\xb0\x45\x13\xa8\x7b\x14\xe6\x02\xd2\xf2\x7c\x1f\xd8\x01\x98\x9a\x87\x70\x73\x68\x87\x1f\xd1\xbe\x39\x3f\x4d\x19\xe6\x09\x03\x8b\x4d\x22\x65\x27\x0f\x25\x47\x8f\x07\xea\xe2\x28\x6a\xc3\xa7\x2f\xf8\x6a\x14\x15\xb5\x4b\x50\xa5\x2e\x9a\x04\x7a\x64\x87\xe7\x95\xc0\xf1\x4d\x5e\x3b\x1a\x87\xc3\x17\xc5\xe6\xca\x7f\x8b\xe7\x65\xe1\xd2\x0b\xd2\xb4\x44\xc3\xe9\xe2\x79\x39\x4f\x62\x55\x0a\x45\x68\x9b\x1c\x64\xec\xc8\x91\x17\xa4\x5c\x5a\xaf\x92\x1a\x29\x97\x36\xe2\x01\x7e\xb1\xb2\x96\x11\x8a\xef\x97\xf3\x39\x0e\x3f\xa7\xce\xd9\xda\x43\xdf\x4a\xab\x25\xbe\x95\x82\x9e\xe7\x87\xea\x78\x86\x5a\x01\x04\xe5\x8d\xd7\xc0\x2f\xec\x1f\x3c\x30\xb9\x2b\xe8\xf9\x73\x35\x62\xbc\xb2\xdb\x6d\xea\x4a\x92\xa8\x30\xc2\x29\xe5\xff\xb0\x41\xf5\x8c\x57\x98\x81\x50\xdc\x2b\x4d\x8e\x37\xb7\xbf\xd2\x62\x2b\xc3\xb9\xcc\xb1\xdd\xb7\x5b\x68\xe4\x21\x36\xc9\xb8\xf2\x88\xe8\x93\x32\x7e\x21\x04\x8e\x6c\x8e\xc5\x31\x54\x00\xb7\xa4\x96\x8b\xc5\xc5\x51\x4d\x56\xbc\xe6\x48\xc4\xe6\xa6\x15\x50\x56\x44\x7e\xd5\xe2\x2e\xfb\xd4\x81\x73\x22\xf9\xad\xe3\xb9\xe1\xa1\xd5\xb7\x1d\x49\x04\x95\xe9\xac\xa4\x3e\x8a\xe2\x9c\xe9\x4c\x72\x21\xa2\xe8\xa5\x4a\x6f\x42\x1d\xf4\x19\x3f\x98\x89\x00\x1e\xdc\x9c\x7b\xa7\xb4\x9f\xaf\x3c\xc3\x43\x16\x7e\x4e\xd3\xd1\xfd\x02\x05\x2d\x73\xb8\x10\x2c\x93\x27\xb9\x9a\x76\x1c\x85\x21\x9e\xcf\xbd\x81\x00\xcf\xd3\x92\x95\x86\xae\x1d\x92\xa7\xa4\xba\xa4\x1f\xd7\xf0\x06\x6c\xf7\xaa\x69\xf9\x1a\xec\x27\x35\xab\x13\x52\xdf\x80\xdc\xb4\x5a\x57\x5d\xdf\x1b\xba\xed\xbd\xa4\xde\x0e\x7c\xbb\x6f\xf9\xe3\x8b\x89\x2c\x93\xab\x6f\x96\xcb\x39\x52\x23\xb9\x7a\xb5\x5c\xce\x5d\xaa\xb3\x28\x23\x56\x35\x34\xe9\x85\xa1\xd7\x37\x5e\x31\xf9\xe9\x89\xf3\x40\x3c\xe7\x1d\x59\x63\x62\x01\x62\xa4\xe5\x5b\x41\x8f\xc9\xcf\xa3\x83\x4a\x85\x3c\xce\xe5\x1e\x27\x65\xce\x6a\x05\x81\xed\x7e\x0d\x56\xbf\x06\x81\xc8\x9b\x55\x5d\xaf\xca\x26\xc0\x3d\x13\x9c\xb8\x1f\x3f\xd6\x8e\xc6\x45\xa4\xed\xaa\x7a\x95\x1e\xb9\x1b\x78\x1f\xcb\x6b\xc8\xcb\xcc\xe3\x35\x92\x0b\x5a\x96\x43\xff\x97\xe7\xe9\x92\xb4\xef\x13\xc5\x8c\x84\x92\x33\x1d\x7b\xe7\x11\x36\x53\x0b\x9c\x93\x61\xa8\x8e\xfa\x0a\x3a\x09\x40\x83\x87\x53\xca\x40\x44\x3f\x67\xa3\x74\xae\x72\x44\x89\x05\xab\xe7\x5d\x53\x2e\xed\x4b\xf2\x4e\x42\xb2\xdc\xaf\x1d\xaf\xc5\xe6\x7c\x02\xeb\x25\xd0\xad\x52\xc8\x25\x71\x32\xf5\x7d\x6f\x41\x46\x06\x10\xa5\xfa\x7a\x39\x7b\xe0\x2a\x05\xe8\x26\x94\x86\xc5\xdb\x19\x59\xe3\x00\x14\x10\xdf\x01\x0d\xc4\x76\x89\x2f\xed\x0b\x22\xf3\x4d\x8b\x0a\x8f\x12\x21\x16\x15\x3e\x73\x25\x83\x79\x10\xc0\x94\xc2\x63\x6e\x54\xf2\x43\x8f\x04\x03\xda\x12\x49\x09\xd9\x73\xdf\x0a\x5b\x3d\x72\x6d\x07\x43\xcb\xc1\x8f\x3e\x0d\x30\xff\x20\xd1\x43\xc0\x27\x08\x8b\x15\x52\x21\xcb\x24\x37\xb8\x21\x65\x92\x23\xcb\x24\x9f\x50\x66\x99\x54\x0a\x58\x48\x62\xd6\x84\x1b\x01\x8d\xef\x9b\xde\xcd\x99\xfd\x0d\x5a\xc9\xf1\xb9\xb5\xd2\xf4\x54\x85\x6b\xea\x87\x76\xcb\x72\xea\x4c\x5a\xd7\x48\xae\x6f\xb7\xdb\x8e\x9a\x48\x6a\xb8\x04\x7b\x89\x2f\x2a\x9c\x3d\x41\x7d\x99\x86\xb0\x48\x9c\x59\x1d\xcb\xb7\x15\xa1\x4e\x69\x9f\x29\xc8\x90\xca\xae\x67\x77\x7b\x40\x37\x71\x76\x0c\x99\xe8\xcf\xad\xc1\x2b\xf1\x21\x91\x29\x30\x1b\x57\x49\x4b\x7c\x56\x8c\xad\x40\x4d\xc7\x6b\x5d\x49\xe4\x12\x62\xf5\x03\x3f\xd6\x44\xf2\x7b\x60\x82\x15\x6d\x15\xce\xd5\xf4\x35\xd9\xa8\xd2\xf7\xbe\x65\x94\x64\x7d\x3c\xb4\x7d\xda\xf1\x6e\x48\xe5\xf9\xb2\xaa\xb8\xd2\x0f\x26\x36\xc3\x93\xfa\x57\x2a\x46\x7b\xd3\xd5\x3b\x68\x77\xa9\xaa\x06\xf3\xd7\x98\x69\x1e\x06\x97\x44\xc5\xc3\x98\xee\x72\xbc\x04\xde\xb6\x0b\x79\x08\x89\x2f\xac\xff\x50\x2b\x00\x61\xa1\x9a\xe0\xa5\xcc\xe9\xec\xdd\x9c\x41\x26\x4b\x2d\xf7\x42\x44\xb4\x28\xa2\xa3\xa5\xed\x4a\x9b\xb6\x3c\x9c\x33\x06\x28\xc5\x2b\x4c\x5c\xf1\xb9\xc1\x03\x11\x8f\x07\x74\x07\x6b\xab\x6b\x22\x0c\xca\x6d\xb9\x2d\x9a\xd6\x36\xdb\x90\xf7\xbc\x11\xde\x86\xd9\x6d\x0e\x58\x53\x5b\xc1\xae\xd5\x58\xd2\x2f\xda\x56\x68\xad\x04\x3d\xdf\x76\xaf\x76\x60\xd3\x72\x49\x96\xc9\xaf\x9a\x12\x10\x59\xf2\x67\x60\x2a\x54\x0c\x8b\x66\xd5\x4c\xe6\xe2\x35\x92\x59\x6c\x5a\x26\xd3\x80\xe8\xac\x36\x35\xb3\x69\xf5\x35\x96\x53\x4c\x37\x75\xff\xb9\xa2\x5b\x4c\x82\x90\x49\x06\x51\x31\x83\x0e\x08\x67\x8a\xde\xe8\xb0\x62\xe4\x90\xd8\x4c\x0b\x26\x42\x94\xf8\x3a\xb3\x4f\xdd\x80\x2a\x7e\xe1\x5c\x9d\xa6\x21\xae\x72\x0d\xf1\xce\x08\x74\xd1\x56\xf5\x13\x55\x5d\x08\x45\x25\xca\x9a\xaa\x2b\xae\xe9\x32\x2e\xab\x5c\x1f\x8d\x45\xba\x49\x3b\x9e\x4f\x67\x59\xa5\x51\xb9\x46\x05\xf1\x8d\xed\xd2\xbf\x9b\x16\x59\x59\x50\x8b\x9c\xa8\x25\x2a\xfa\xad\xb4\x50\x73\xf8\x71\xca\xe2\x03\x6b\x8a\x35\xf8\x5c\x73\xbd\x30\xff\xab\x0c\x78\x35\x07\x0f\x01\xd7\xf2\x7d\x4b\x82\x9e\x9f\xa0\xa2\xca\xe9\x90\xd9\x58\x8d\xe4\x34\x45\x41\x1b\x4b\x55\xe4\xa8\x6f\x75\xd9\xa2\xc1\x66\x82\xe5\xaf\x74\x7d\xab\x6d\x53\x37\xcc\x87\x1e\x0e\x78\x11\x34\xae\x6c\x96\x67\x7a\x17\x59\x5b\xfb\x77\x51\xcf\xc7\x4a\xca\xff\x2e\x24\xb6\xf8\x4e\x71\x19\x1c\x1c\x85\xde\x20\xb1\xdc\x29\x1d\x50\x0b\xd2\xba\xc2\x8f\x95\x9b\xc4\x52\xb8\x81\xcd\x6d\x0c\x6e\x48\x65\x70\x93\xa8\x8a\xf7\x87\x4e\x68\x9b\x33\x3d\x5b\xdb\xac\x4e\xd4\x36\x57\x94\xb6\x19\x17\x73\x31\x49\x25\x4f\x31\x2a\x4a\xdd\xb0\x4f\xce\xc4\xfb\x18\x84\x33\xdb\xed\x3a\xd4\xc4\x58\xa5\x57\xa2\xfd\x78\x9b\x67\xa0\x0f\xa8\xd2\x86\x3e\xc0\xb8\x0b\xce\x64\x81\xc9\x8f\xfa\x03\x1f\x14\x0b\xb6\x21\x46\x3d\x42\xe7\x6f\x1d\xea\x71\x9c\x70\x3e\x37\xe5\x30\xf5\x5f\x23\x7f\x93\x12\xb9\x43\x47\x38\x0b\x7d\x4f\xd2\x45\x97\xc4\x48\x71\x9b\x85\x45\x93\x38\x9d\xf7\x30\xf5\x07\x9e\xda\xf4\xa8\x33\x08\xc0\x13\x0a\x2c\x6e\x3a\xb6\xe3\xc0\xf9\x45\x40\x3a\x56\xc0\x64\x09\xa1\x6c\x17\x62\x5b\x8e\x33\x66\x22\xb6\xef\x35\x6d\x87\x0a\x3b\xd2\xd2\x92\xcc\x4d\x00\x71\x25\x5b\x96\x4b\x9a\x94\xc9\xd2\x0e\xb8\x59\x15\x89\x1d\xe6\x02\xd2\xf7\x7c\x4a\x1c\xfb\x0a\xdc\xbe\xac\x61\xe8\xb1\x66\x78\xdd\x4f\xde\x10\xaa\x39\xd4\xf2\x5d\x2c\x89\x96\x4d\x76\xc8\x76\x64\x60\xbf\x6e\xb1\x0d\x87\xc3\x3d\xc3\x84\x68\x6f\xd3\x6b\xea\xb0\x5e\x04\xa5\xae\xe7\x75\x1d\xf4\xcd\x1a\xd1\xe6\x2a\xda\xf0\x06\xab\xd5\x72\x65\x63\xb5\xfc\x6c\x15\x42\x31\x78\xc3\x70\x05\xbb\xb4\x32\xb2\xc3\xde\x8a\x40\x63\x49\x98\x7f\xb2\x17\x7b\x5e\x7f\xe0\xd0\x8c\x8c\x2c\x49\x79\x30\x22\x39\x60\x50\x11\x16\xe9\x54\xf8\x82\x9a\xe9\x34\x27\x5a\x3f\x04\x5d\x62\xfa\x64\x30\x3f\x36\x33\x13\x1b\xe4\xbd\xb3\x33\xac\x8b\xc3\xcd\xed\xc2\x46\x3e\x9b\x48\x7e\x3c\x37\xca\x7c\xc9\x9b\xce\x63\x67\x8d\x18\x34\x94\x71\x29\xeb\xaf\xbc\xe4\x10\x77\x53\x31\x3b\x3a\x2d\x4b\x92\x76\xae\xbf\x40\xc6\x0e\x8e\x66\x1a\x00\xbc\x30\x89\x66\xec\xc8\xe4\x8b\x87\x48\x1d\xa5\xb5\xc0\xc8\x83\xd6\xdd\xae\x52\xe1\x62\x6d\x7d\x50\xca\xdd\xd4\x6d\x1e\xb8\x6d\xf2\x05\xae\x40\xe4\xc5\xc0\x17\xd8\xc5\xc3\x4c\x4d\x18\x02\xea\xb6\x65\xc9\x7f\x50\xaa\xa0\x74\xda\xdb\x6e\xdb\x6e\x59\x21\xd0\x1e\x0f\xa7\x50\xe6\xda\x01\x71\x3d\xbf\x8f\x92\xb4\x19\x5a\x70\xe8\x74\x6d\x5b\x84\xc7\x97\x23\x1d\xdf\xeb\x2f\x09\xf7\x55\x19\x85\x55\x11\x12\xcf\xca\xee\x81\x3b\x42\xeb\x8a\x92\x21\x9a\x7a\xb2\xe5\x47\xb9\xd8\xc2\x3d\xb2\xe7\x02\x72\xbe\x6a\x5a\x5b\xa3\x66\x4b\x55\xd5\x16\x32\x22\x3d\x7f\x52\x3a\xc3\xa7\x09\x07\x65\x2f\x0b\xa2\xb5\xc3\x9d\x77\xb1\x83\xae\xd7\x16\xe9\xae\x0e\x6c\xd8\x29\xc8\x94\x57\xc2\xf5\x98\xec\x9f\x1c\x0b\x44\xe0\x02\x36\xca\xb6\x78\x89\x67\xb9\x12\xeb\xa6\x8c\x09\x10\xc9\xb8\xb4\xa7\x42\x88\x2e\x2c\x5c\x66\x9b\x1a\x11\x33\x88\x39\xe7\x88\x09\xe5\x7e\x26\x8b\x01\xb3\x10\x95\x8a\xff\x6f\xa4\xd8\xd2\xa6\x60\x9b\xed\xe7\xbf\x14\x71\xe6\x59\xed\xaf\xc3\x20\x94\x47\xa8\xe2\xe4\xf7\x9e\x24\x84\x38\x60\xcd\x62\xc5\xfc\x45\x0e\x30\x82\x00\xd7\x4c\x3b\xcd\x58\xb6\x2c\x12\x0a\x9b\x22\x31\x5d\xc4\xfa\x85\x86\xde\xfa\xfa\xa5\xed\x1f\xa6\x96\x11\x60\xfc\x6b\x85\xa1\x6f\x37\x87\x21\x9d\x28\x2b\x66\x4e\x51\x16\x4d\xde\xe5\x53\xab\x7d\xe2\x3a\xe3\x19\x50\x8c\x82\xf0\xdc\x5d\x67\x98\x2e\x86\xe3\x3c\x90\x96\x26\x0d\x6d\x15\xee\x3d\x4d\xda\x9c\x69\xce\xce\x4f\xf6\x4f\xf4\xfa\x0e\xb5\xd2\x19\x69\x62\x75\x30\x0c\x59\x20\xc9\x9a\xe7\x66\xeb\xc2\xd3\x40\x78\x4d\xc7\xfb\xde\x68\x96\x4e\x24\xc2\xf8\x30\x98\x85\x0c\x4c\x01\xef\x79\x7e\x48\x7a\xb6\x2b\xef\xc8\xf1\x6e\x49\x2d\x51\x78\x18\x21\x43\x50\x10\x48\x4d\xcc\xa4\x12\x1a\x24\xc9\xf6\xb5\xc3\xc3\x99\xb8\xfe\x2d\xb7\xdf\xe9\x10\xdf\x1b\x05\xb1\x54\x91\x72\xa2\x72\xe7\x72\xc6\x83\x6c\xaf\xcd\x63\xca\xa8\xf6\x59\xed\x1f\xad\x34\x1f\x5b\x37\x76\x7f\xd8\x97\x36\x48\xf7\xd1\x87\x63\x6b\x91\x6c\x7d\x73\x75\x03\xad\x6a\x67\xd2\x93\x4d\x63\x9b\x7f\x90\xa6\x0c\xaa\x05\x17\x55\x38\x01\x84\x60\x27\x47\x21\x9b\x2e\x3c\x30\x0b\xf0\xbf\xdd\x26\xaf\xce\x8f\xdf\x6c\xf0\x92\x0c\xa6\x22\x51\x38\x39\xaf\x5a\x82\x0e\xaa\x6f\x21\xe5\x75\x55\x87\xeb\x7d\xd2\x9e\x72\xe6\x74\x8a\xf7\xc4\x39\xa9\x9f\x2d\xdf\xb7\xc6\x27\x9d\xfc\x43\x33\x6e\xe1\xb2\x20\xcf\x95\x8e\x78\xe8\xf0\x49\x11\x1c\xd2\xa2\x37\x40\xfd\xb4\xe8\x0d\x12\x28\x94\xca\x1b\xd1\x2f\x54\xd4\x86\xcc\x88\x0d\xd3\x44\x6b\x00\xe8\x32\x67\xd8\x43\x46\x6a\x98\x1c\xa5\xc1\xf4\x4c\xba\xef\xe8\x0c\xd0\xd3\x59\xa2\x33\x20\x69\xee\x2b\x3a\x83\xbc\x2b\x52\x99\x86\x32\x93\x76\xa1\x4b\x1b\x2c\xec\x59\xe9\xb7\x62\xa9\xb2\x64\x3b\x60\x4f\xac\x7c\x68\xe3\xa9\xb1\x00\xb6\xee\xec\x97\xf0\x99\x37\x17\x89\x51\x6f\xe2\xc8\x34\xbc\xf9\x50\x04\x52\x64\xe2\xc8\x60\xa7\xa3\xc8\xbe\x4e\x83\xe1\xe4\x2c\x66\x29\x69\xc9\xf2\x85\x78\xe3\x70\x3e\x8a\xb6\xbc\xda\xe8\xc5\x23\x53\xac\xae\x92\x77\xd4\xef\x78\x7e\x5f\xe8\x33\x6c\x37\xf0\x01\x4e\x5b\x53\xfb\x1b\x4f\x57\x96\x9e\xac\x2c\xbb\xcf\xa7\xb4\x13\x97\x4f\x66\x26\x84\x08\xf3\x69\x09\x10\xa2\x88\x25\x25\x41\x48\xfa\x6e\x26\x42\xb8\x23\x94\x8d\x6f\x22\x30\x3c\x6c\x7f\xf2\x24\x0e\x06\xbe\x94\xfc\x09\x8d\xc9\x52\x91\x26\x15\x29\x16\x8c\x32\x02\xe3\x98\x11\x5d\x84\x0b\x6f\x1e\x5d\x64\x42\x7e\xb6\x99\xb2\xb3\xc9\x80\x19\xe9\x9c\x18\x65\x44\x45\x9d\x28\x25\x96\x34\xcf\xf8\xec\xf0\x27\xb3\x84\x3e\x49\x4e\xf1\x36\x05\x8e\xd1\xb9\x32\x09\x47\x46\x9f\x53\xda\xa2\xf6\x35\xe5\x49\xa7\x26\xd3\x53\x2f\x9f\x77\xe9\x0d\xf2\x4a\x41\xb7\xd3\x65\x9a\x4e\x93\x89\xad\x91\xe7\xe6\x42\xd8\x6b\xaa\xad\xa6\x4c\xf1\x24\x53\x73\x33\x5d\xd9\x73\x21\xc9\x3b\xde\x4f\x18\x56\xba\xab\xab\xe4\x23\x25\x2e\xc5\xb3\x99\xa6\xe7\x5d\x91\x2b\x4a\xf9\x79\x21\xaf\x80\xa0\xfa\x96\x3b\xb4\x1c\x47\xba\x62\x2b\x32\x9a\xb9\xcf\xd8\xbc\x90\x88\xcb\xb7\x31\xe2\x26\xc6\x55\x48\x58\x67\x88\x11\x4c\x61\x3a\xa2\xa3\x9c\x9a\x86\xdc\x58\x32\x89\xd0\xc9\x8c\xac\x0a\x66\x71\x8b\x2a\xa5\xa4\xc9\xea\x2a\x0a\x94\x01\x8a\x55\xb5\x51\x14\x72\x51\x13\xbd\xbb\xe9\xc3\xb0\x38\xf5\x17\x48\x5c\x16\x4f\x49\xc6\x9a\x8b\xa4\x12\x8b\xaf\x7b\xd1\x0c\x2a\x62\xf1\x4b\xcf\x52\x28\xe3\x92\xbd\xf2\x9c\x76\xa0\x6d\x27\x7c\xda\xa1\x3e\x75\x5b\x40\xad\x08\x0b\xe8\x03\x95\x2b\x2e\x49\x18\x75\x5d\xf7\x9f\xc1\x97\x8a\xa8\xd8\x05\xf7\xec\x53\x25\x40\xde\xa3\x1f\x55\x12\xa7\x9b\xe2\xcd\x48\x9f\x2b\x62\x63\xdc\x47\xec\x3b\x23\x05\x27\x36\xc1\xb5\x60\xe9\x8c\xa3\x25\x04\x94\x8e\xfc\xf1\x29\x2c\x27\x50\xda\xcc\x55\x33\x4c\xba\xb0\xcc\xc9\xd1\xda\x2c\xd2\x7d\x9b\x74\xae\x9d\x92\xd9\xa1\xf2\x04\x6e\xc7\x06\x12\xd8\x3d\x16\x60\x2a\x11\x5e\xfc\x7b\x32\x2c\xa4\x7a\x4c\x97\x9b\xb2\x23\x70\x0e\xa8\x37\x9c\x5c\x22\x1f\x91\xc5\x09\x5d\x88\x41\x8a\x7f\x8d\x42\x49\x60\x07\x23\x00\xce\xc4\xe0\x37\xd1\xac\xa4\xfa\x43\xd5\xcc\x13\x9d\x1d\x1e\x47\xb7\x0d\x50\xb1\x6c\xf4\xb7\xd1\xd2\x62\x9b\xa3\x15\x85\x57\x7a\xb9\x69\x12\x96\xce\x92\xae\xd4\x70\x62\x53\xe9\x47\xb5\xb7\x46\xe9\xa9\x93\x95\x46\x6f\x8b\x63\xa5\xe5\x17\xc3\xf2\x4c\xbb\xf7\x55\x35\xf4\xb7\x46\x69\xdf\xf7\x7c\x13\x15\x78\xa5\x97\x91\xb7\x90\xaa\x8c\x7c\x65\xa4\xb2\x6b\x6b\xe1\x8b\x8c\x9e\x98\x77\x76\x91\x54\xa9\x2a\xc6\x88\x56\x03\x0b\xfc\x9a\x9d\x89\x55\xb0\x6d\x7a\x61\xe3\x5d\x44\x72\x7e\xbf\x23\xb5\x78\xb1\x6d\x8d\x3b\xd5\xdb\x3d\x2d\x33\x66\xac\x4a\x32\x57\xa8\xef\x9c\xbc\x33\x45\x59\xfa\x55\x4f\x4b\x77\xa1\x25\x57\xbd\x2c\xc4\x1a\x99\x98\x7d\x16\xef\xa7\xcc\x51\xc6\x77\x46\x29\x79\xb6\xab\x0a\x89\x57\x7a\x39\x54\x18\xf4\x3c\xb5\xec\xd9\x2c\x11\x99\x86\xfc\x85\x59\x66\x9a\x7c\xb7\x5c\x42\x19\x85\xd8\x0b\xb3\x8c\x88\xb6\xd0\x30\xe4\xb2\x59\x86\x5f\x4b\xe8\xa5\xf8\xab\x58\xb9\x0f\x83\x48\xa9\x0f\x03\xbd\x8c\xe9\x4d\xc9\xcb\x25\x78\x24\x90\x89\x59\x7f\xc5\xb5\x98\x2a\x21\xde\x18\xa5\xbc\x91\x46\x4a\xf6\x14\xfd\x7a\x6c\xdd\x98\x05\x8e\x2d\x23\xfd\xa1\x79\xc4\xad\x8a\x9a\xef\xf5\x1a\x21\xf7\xf1\xe7\x01\xc6\x22\xc9\x23\x27\xe5\x16\x9e\x3b\xae\x98\x2e\xd9\x73\x45\x92\x93\xe2\x3b\x2b\xd7\xb0\x2e\x68\xa3\xc9\x86\xa3\x82\x92\xbd\xd3\x45\x21\x3c\x33\x79\xc7\x7e\x48\xa1\x06\x09\x89\xdb\x32\x2d\xb1\x14\x50\xd9\x69\x8b\x71\x46\xc1\x2f\x31\x6d\x30\x8b\x31\x9b\x1e\xf8\x4b\xf6\x45\x4f\x6d\xcc\x59\x1a\x7f\x72\x95\x8b\xfd\xe4\xec\x29\x1f\x3e\x0c\xd8\x4f\xdd\xce\x5d\xcb\x95\x2c\x18\x07\x7e\x7b\xa3\x40\xfc\x7b\x6c\x41\xca\x64\x73\xa4\x21\x64\xdb\x78\x40\x93\x92\x29\xcf\xbd\x23\xc9\x4c\xa4\xac\x8a\xa0\x23\xd8\x8e\x5a\x78\x8c\x86\x81\x84\x64\x47\x93\x58\xdb\xe9\x9a\x53\x54\x41\x9c\x29\x01\xf3\x2c\xe9\x97\xef\x12\xf3\xfb\xf2\x9e\x64\x35\x22\x3a\x1b\x69\x01\x5e\x4f\x02\x2f\x68\x91\x05\x5f\xd1\xcb\x6c\x00\xdf\x27\xed\xe8\x34\x62\xcf\x93\xed\xf9\x7e\xb2\x39\x27\xe6\x61\x9e\x03\x0e\x6a\x2a\x48\xe5\xf9\x20\x28\x3d\x46\x69\x39\x73\x42\xc2\x83\x81\xa2\x1e\xac\x90\xbf\x9b\x17\xa0\x1c\xcf\x62\x64\x7c\xe7\x03\x88\xde\xcb\x45\xf2\x28\x2a\x14\xe7\x03\xa7\x74\x03\xa5\x39\xcc\x07\x49\x1a\x4a\x26\xe3\xa6\x27\xe8\x8e\xa4\x17\x2f\x18\xd2\x07\x85\xf5\x4c\x5c\x8d\x99\x86\x0d\xb6\xae\xce\xca\xd7\xd5\xa2\x99\xb8\x78\x7f\x21\xee\x8e\x42\x53\xd6\xf6\x45\xf2\x68\x2e\x42\xc7\x20\x82\x55\x7d\x91\x28\x9f\x73\xb4\xb3\xcf\x2d\x02\xf4\x78\x41\x6e\x88\x11\x91\xba\x01\x83\xa5\x09\x41\x34\x9f\x32\x19\xa2\x5a\x28\x26\x69\xe9\x26\x5f\xc8\xcb\xe7\xa8\x9c\x4c\xd8\x7a\xab\xb2\x3b\x3b\x2a\x67\x8e\x80\x74\x14\xdd\xc7\xf0\x7c\xdc\xc9\x9b\x86\x8c\x70\xa7\x46\xde\x69\x4c\x94\xff\x5d\x3b\x3a\xe8\x44\xa2\x51\xe2\x05\x8c\x10\xe2\x05\x63\x4d\x34\x55\x14\x7d\x7d\x88\x61\x6b\x16\x8d\x9c\x25\x02\xaa\x7a\xe4\xab\x92\x1d\x1c\x0f\x6d\x05\x39\x6f\xc2\x63\xfa\xda\x19\x75\x68\x2b\x84\xf7\xb9\xcb\x42\x24\x5a\xf7\x34\x74\xd0\xca\x13\x12\x00\xb4\xd3\xec\xde\x93\xa9\xb2\x76\xbb\x43\x47\x0f\x35\x7d\x97\x74\xba\xa9\xee\x94\x14\xc7\x46\x34\x0a\x50\xbd\x9f\x3c\x21\x8f\xb8\x2a\x65\xf6\x30\xce\x0d\xc2\x6c\x2f\xa7\x35\x87\xcd\x2c\x46\x19\x69\x4d\x93\xa0\xdc\x13\x69\x2c\xf8\xd0\x94\x4b\xe8\xb1\x8a\x68\x26\x50\xcf\x50\x3a\x66\x0b\xed\x9a\x6b\xdb\xd7\x9a\x4f\x55\x1a\x9d\xa4\x61\x60\xe4\x1e\xb9\xa8\x8c\xd9\xa2\xb7\xe0\xc5\x58\xce\x79\x58\x2f\x12\xd2\xf3\xa7\x6d\x90\xb2\xbb\x10\x9d\x27\x53\x0c\xb1\xe9\x04\x33\xf1\x80\xab\x46\xd2\x0f\xb6\xb0\x5b\xe6\x5a\x98\xb4\xf1\x36\xe8\x92\xb4\xf3\xe6\x46\x78\x09\x3b\x60\xcd\xc8\x2f\x71\x17\x9d\x9d\xac\x5f\x88\xd8\x9a\x12\xcc\x2f\xf0\xac\x5d\x4b\x37\x11\xdb\x6e\xf2\xdc\xfd\xe6\x79\x53\x8d\x98\xe7\x4c\x68\xa8\x1a\xdd\x66\x9b\xce\x28\x69\xe7\x72\x86\xd5\x5f\xca\x76\x1e\x0d\xa1\xa2\xdb\x61\x65\xdd\x9a\xb6\x7d\xc7\x89\xab\x66\x86\x3e\x0b\x0b\x1a\xbf\xe9\x5b\x53\xfe\x52\x3f\xa2\xc7\x5d\x1a\x9f\x46\xc0\x65\xdb\x4b\x13\x42\x05\xa3\xad\x4a\x7f\x68\x73\x95\x28\x77\xc4\x17\x2c\xfc\x90\x90\xda\x3f\xee\xa3\x22\xd3\xf6\x6b\xee\x08\xf2\x9d\x66\x7e\x2c\xdf\x21\x99\x40\x1a\xe6\x30\x1b\x10\xb6\x96\x90\xd0\x7f\x86\x74\xfe\xc9\x81\x83\x67\x4b\xea\x8f\xbd\x27\x77\xc2\x26\x67\x3b\x16\x29\xf8\xd9\xbd\x46\x0a\x5e\x5d\x25\x47\xc7\xef\x4e\x4e\xcf\xeb\x6f\xcf\x71\xc2\x91\xfe\x30\x08\x49\x93\x12\xbb\x4d\x5d\x34\x46\x0f\x3d\x82\x9e\xfb\xa5\xaf\x01\xc1\x13\xc5\x25\xb8\x5a\x46\xd3\xf4\x1e\xf5\x29\x69\xd2\x96\xc5\x60\xb7\xbd\x56\x97\xba\xa4\x65\xb9\xb9\x90\x8c\x69\x48\xec\x3e\x43\x09\x95\x39\x98\x3b\xe8\x66\x4c\xac\x96\xef\x05\x01\xe9\xd8\x0e\x0d\x4a\x7f\x93\xe4\x9c\x53\xe7\x8b\x66\xc4\x4a\x74\xb2\x8c\x9a\x12\xcf\xe7\x09\xf7\x4a\x44\xa0\x88\x66\x93\xcc\x07\x05\x65\xa6\xe8\x65\x19\xb4\x6b\x66\x82\xff\xa8\xe4\x6b\x13\xcd\x26\xff\x51\xbd\x8d\x79\xd1\x1c\x75\x60\xa5\x12\x39\x3b\x03\x9c\xd2\x10\x2c\xde\x72\xdb\x64\x38\x90\x8e\x1a\x3d\x9c\xd1\x92\x5b\x6e\x82\x0c\x8b\xf6\x44\x27\xb2\x39\x1b\x0a\xfa\x3f\xa8\xa1\x7e\xfb\x07\x35\xe4\x74\x7f\x50\x43\x37\xce\x7d\x36\xd4\xf6\x46\x6e\x06\x3b\x64\x3a\x49\xdc\x6f\x63\x41\xff\x07\x36\xd6\x6f\xff\xc0\xc6\x9c\xee\x0f\x6c\xec\xc6\x99\xd8\x98\x48\x68\xac\x6b\x14\x9b\x7f\xad\xdc\x03\x18\x89\xfa\x8d\x1d\xa4\xad\xef\x1b\xcf\x21\x60\xf5\x84\x86\xc4\xb5\x0b\x8f\x97\x42\xdd\x61\x9f\xfa\x4c\x71\xc4\xa6\x98\x1a\x08\x99\x36\xa4\x95\x40\x97\x2a\xbb\x3f\xb1\x13\x4c\x09\x81\xcd\x90\x2b\xe8\x1b\xca\xbb\x08\xe6\x47\x21\xed\xa7\x85\x18\x7f\xbe\x35\x0d\xf6\x02\xca\x43\xa1\xcf\x60\x4f\xec\x42\xfd\xda\x0a\x2d\x3f\x75\x18\x36\x66\xe9\x08\xc2\x7a\xc8\xee\x60\x0b\x13\x3b\x75\x4e\x6f\xd2\x39\xeb\xd9\x2c\x5d\x62\x90\x1e\xb2\x43\x0c\xfe\xc4\xee\x1c\xb5\x3c\x37\xb5\x3b\x9b\xb3\x74\x87\x41\x7a\xc8\xee\x30\xf8\x13\xbb\x73\x46\x5b\x9e\xdb\xb6\xfc\x71\x1d\xdb\x49\xeb\xd9\x4c\x93\x28\x02\xf4\x21\x3b\x19\x69\x2a\xb3\xbf\x67\xc3\x66\x8f\x5a\xfc\x9a\x3e\xb1\x97\xcf\xa7\xed\xa5\x04\xf5\x50\x7d\x93\x0d\x24\xf5\xe8\xc1\xd3\x00\x44\x56\xac\xad\xbf\xe2\x8a\x75\xee\x79\x4e\x33\x55\x5a\x3e\x5b\x9f\x6a\x2c\x1f\x70\xd1\xe2\xf8\xfd\x15\xc6\xef\xf9\x14\xe3\x07\x43\xb5\xba\x9a\x14\xb1\xed\x9b\xe3\xd9\xbe\xd7\xba\x5a\x6d\x79\x3e\x5d\xf9\x2a\xc3\xb6\x6d\x3d\xfb\x17\xfc\x6a\x79\xfd\x3e\x75\xc3\x95\x4a\x65\x63\x73\xe3\x79\xb9\xba\x05\x03\xd4\x75\xbc\x26\x64\x42\xc6\x86\x4a\xbc\x1d\xb2\x23\x3c\x2a\x31\xe5\x16\x79\x64\xdc\x67\xb3\x9e\xf2\x4c\xa7\xc7\x16\xa4\x03\x20\xec\xdf\x25\x42\x5e\x88\x0a\xd2\x25\x33\xa0\x4e\x27\xa1\x3a\x7b\x6d\x54\x26\x2f\xe0\xdd\x12\xd8\xf5\xd2\xc0\xb1\xdd\x70\x85\x9f\x6a\xad\xb8\xf4\x26\x5c\x01\x23\x27\xd7\x5b\x71\xe9\x68\x85\xd1\x67\x89\x90\x1a\x39\x14\x84\xca\xf1\x71\x60\x9a\x61\xae\x90\x2f\x6c\x2f\x69\xb7\xf2\x8d\x46\x97\x35\x93\x43\xd3\xdf\x5c\x01\x5f\xf0\xce\x6f\x27\x34\x28\xda\x02\x9c\x97\xa2\x43\xf5\xbc\x3c\xed\x50\xc1\x8d\xbd\xe7\xd3\x24\x02\x7f\x27\xd7\xd4\x0f\x30\x68\x59\xb5\xb4\x51\xaa\xe4\xc8\x5d\x04\x6b\x1a\xc5\x9a\x01\x62\xf0\xe6\xc0\xb9\x32\x2d\xce\x31\x44\x95\xff\x90\x1d\x1a\x51\xef\x39\x9e\x36\x3f\x06\xc0\x13\xbf\x1c\x79\xc1\xde\xc8\xa4\x12\xb5\x68\x31\x79\x5a\x80\x11\xba\xa2\x78\x56\x17\x12\x63\x70\x02\x67\xb9\x57\xb9\x80\x1c\x1d\x6c\x81\x47\x23\xdb\x2a\x74\x86\xae\x3b\x26\xa6\x80\x89\x77\xf4\x51\x62\x12\x93\xb5\xb5\x78\x3a\x64\x4e\x80\x64\xc1\xf5\xfd\xae\x48\x72\x16\x93\x56\x11\xb9\x94\xd7\xe4\xc5\xe6\x36\xb9\x23\x77\x85\x92\xc5\xe6\xc6\xe6\x36\x8a\x9c\x28\x2d\xd6\x66\x10\x09\xd5\x72\xa9\xca\xfe\xdb\x82\xd9\x54\x0a\xec\xae\x9b\xbf\x29\xc4\x3b\x29\xbf\x92\xdb\x5b\x2d\x05\x01\x16\xc7\x73\xb9\xec\xf9\xc7\x66\x29\x98\xe2\x5b\x70\x64\x27\x12\xc9\xdd\x90\x1d\xb2\x7c\x53\x60\x1c\x5b\x66\xa0\x6f\x58\xc7\x6e\xc8\x0b\x72\x43\x6a\xe4\x86\xfc\x87\x94\xc9\x0b\xb2\x52\x21\x35\x52\x49\x1e\xf8\xf5\xd9\x3b\x5b\x59\xc7\xee\xd0\x9b\x41\xbf\xc2\x7a\xcb\xe6\xdb\xaf\xf0\x24\x7a\x0a\x0f\xdb\x71\x32\xe4\x1f\x61\x39\xec\xef\x89\xd3\x26\x87\x87\xa4\x39\xec\x2e\x11\x86\x3c\x7e\xcb\x57\xca\x05\xf2\x1b\xa9\x56\xcb\xd5\x8d\xd2\xfa\xb3\x8d\xcd\xe7\xeb\x5b\xe5\x67\x9b\x95\xe7\x91\x22\xff\x89\x17\x79\xb6\x51\x79\xb6\x85\xb0\xcf\x3d\x9f\xec\xf2\x6c\x93\xd1\x06\x56\xaa\x74\xa5\xb2\x59\x60\xa4\xc2\x9f\x4b\x05\xf2\x42\x8d\x8a\xe8\x97\xce\x73\x26\xa1\x05\x79\x7f\x23\x2b\x15\xba\xf2\x8c\x49\x56\x46\x6b\xf8\xcd\xbe\x2d\x93\x1b\xf2\x94\xdc\x90\x55\x52\x25\x35\x49\x11\x06\x72\x05\xc6\x81\xd4\x38\x2a\x09\x03\xb2\x58\xfa\x3d\x3c\x1a\x0e\xe8\x4b\x1a\x9e\x5b\xdd\x34\x65\x6e\x8d\xdf\xa3\xf0\x7c\x33\x69\x89\x84\xb6\x64\x31\x9c\x72\x6f\xec\xab\xb4\xa4\x43\xeb\xeb\xfc\x7e\x80\x7c\xc1\xb2\xff\x0a\xbd\x33\x38\x2e\xfe\xc2\xa3\x83\x2b\x17\x98\xa0\xc4\xba\x88\x59\x3a\x58\x09\x44\x34\x77\x81\x92\x8c\x60\xb5\xcb\x1c\xc2\x5b\x22\x4f\x09\x38\x51\x43\xa6\x9a\x2f\xa0\xef\x40\xba\x7f\x38\xae\xb6\x3b\x36\x6d\xa3\xef\xcb\x17\xd1\xdc\xc0\xb7\xfb\x36\x84\xc9\xf1\x7c\x82\x30\x4b\x4b\x04\x00\xfd\x37\x08\xad\xd0\x6e\xe1\x4f\xdb\x6d\x51\x52\x2e\x55\x4a\x65\x78\xee\x53\x26\xef\x4f\x3a\xa4\x01\x8f\x2d\x2b\xa4\x5d\xcf\x1f\x93\x37\x96\xdb\x5d\xd2\xe2\x9d\x3c\xbd\xe3\x36\x9d\xe7\x32\x40\x4a\xe8\xa1\x8b\x47\x09\xca\xc5\x9d\x63\x4e\xf9\x1b\x8c\x59\x13\xe9\x87\x08\xfd\x54\xc4\xcb\xef\x2f\x70\x33\xf4\x05\x41\xd1\x1b\xab\x3f\x70\x28\xc7\xbe\x51\xb2\x03\xec\x64\x3e\x67\x35\x5b\x90\x5a\xf2\x29\xe3\xf5\x9d\xdf\x50\x01\x8c\x15\xab\xe8\x45\xb8\x6b\xda\xd3\x55\x3d\xbf\x0a\x2f\x18\xcf\x5d\xc4\x97\x0f\x6e\xbe\xba\x43\x72\x88\x65\x8e\xdc\xde\x02\x4f\xe4\x1f\xc5\x93\x15\xe9\x7c\xa2\xbd\x56\xfc\x28\x5e\xee\xec\xa8\xa1\xc7\x1c\x36\x31\x49\x21\x50\x4b\x98\x21\x8b\x5d\x3b\xcd\x3a\x43\x1e\x88\xf5\x51\xbd\x88\xb0\x3e\x46\x45\x99\x9d\xf5\xb1\x5e\x26\xeb\x3f\x7d\xfa\xd6\x0b\x69\xed\xe9\x53\x72\xee\x11\x7a\xd3\x72\x86\x6d\x4a\xbe\x1c\xb9\x70\x0b\x36\xfe\x52\x24\x5f\x56\xb4\x07\xcb\x6d\x93\x2f\x6f\xad\xb7\x5f\x8a\x64\xd4\xb3\x5b\x3d\x02\xab\xce\xd3\x48\xcb\xd8\x87\xa0\xa8\x92\xe0\x32\xde\x3b\x64\x40\xe8\x17\xd2\xa7\x61\xcf\x6b\x27\x4d\xbd\xc8\x54\x8b\xce\xc4\x1f\x38\xf5\x44\x7c\x8b\x69\xa6\x1e\x12\x39\xbf\x96\x31\xed\x78\x11\xfc\xa7\x74\x7c\xf4\xb6\xf1\x47\xfd\xcd\x87\x83\xc9\x35\x04\xe9\x27\x97\xcc\xad\xe5\x26\x4e\x6a\x5e\x74\x8a\x49\xcd\x95\x5c\x39\xa9\x67\x99\xc1\x92\x83\x53\x67\x30\xe2\x91\x30\x83\x33\x8f\x79\xd5\x1c\xe3\xb0\x1a\x8d\x69\x37\xd0\xab\x4f\x49\xcf\xf2\xfb\x9e\x3b\x16\x77\xbd\x4f\x57\xd1\x77\xaa\xc1\xd3\xe4\x36\xf0\x8a\xf9\x60\xbf\x71\x7c\xb2\xff\xe1\xcd\x41\xa3\xdc\x70\xbc\xb6\x15\xf4\x1a\x76\x20\x76\x35\x8d\x46\xda\x82\xf8\xac\x70\x7f\x6d\x34\xd4\xbd\x7c\x42\x5b\x25\x37\x3f\x23\xbc\xf9\x50\xab\xa0\x45\x44\x7a\x97\x17\x04\xbb\x40\x2f\x25\x8c\xf9\x50\xa8\xc2\x2d\x65\x23\x84\x0b\xcb\xb4\xee\x95\xef\x03\xf6\x02\x7d\x34\x01\xcd\x87\xcc\x5a\xa3\x31\x0c\x6d\xa7\xf1\x6e\xe8\xd3\x53\x70\x2f\x4c\x1f\xcd\x8d\xf9\x9a\x58\x6f\x34\xf8\xf9\xcb\x1b\xda\xa5\x6e\x7b\x0f\x03\xd1\xa7\xb6\xb3\x59\x99\x93\x6f\x36\x78\x5f\xf6\xad\xd0\xfa\x10\xda\x4e\xfa\xc8\x55\x36\xe7\x6b\xe1\x19\x6f\x01\x6e\xb4\x27\x34\xb1\x06\xbb\x43\x3d\x75\x34\xd9\x11\xbb\x4f\xb6\x0e\x46\x76\x73\x79\xcc\x98\xce\xb6\x9b\x32\xa6\x8f\x4d\x76\x48\x65\x9b\xd8\xe4\x3f\x31\x97\xe5\x6d\x62\x43\xa4\x1e\x40\x98\x47\xcb\xd3\x63\xf4\xd8\x97\xdb\x0a\xce\x15\x1d\x13\xdb\xe5\xc5\x58\x25\xbb\x43\xf2\x1c\x95\x81\x08\xa4\x53\xea\x59\xc1\xc9\xc8\x15\x5b\x62\x4c\x00\x8e\x55\x8a\x0c\x42\xa1\x20\xd3\xba\x5f\xf0\x90\x40\xf8\x15\x9e\x60\x6b\x4c\xee\xe4\x5a\x01\xe5\xb6\xc9\x5d\x42\xea\x63\xe3\x78\x02\xfa\x2b\x9e\x8c\x4d\xb9\x4d\x03\x4e\x13\x91\xe7\x3d\x4a\x9a\x32\x92\x06\x7d\xa3\x12\xc8\xd2\xa6\x41\xcb\xb7\x07\x21\x78\x86\x40\x29\x20\x8b\x7a\x5d\x52\xe7\x92\x64\x27\xe5\x3d\x1b\x23\x48\xd4\xa8\x7f\x6f\x79\x6e\xc7\xee\x0e\x45\x4d\x30\x5f\x06\xa2\x3e\x86\x15\xee\x31\xa3\xb6\x2a\x5e\xd0\xab\x8e\x7c\x3b\x34\xaa\x25\x1f\x48\x88\x9e\x6b\x35\xaf\xe8\x58\x7f\x2e\x6c\xeb\x04\x57\x14\xd5\x22\xa6\x00\xe1\x42\x8f\xdb\xa0\xa2\x0e\x25\x02\x3e\x88\xbc\xf6\xfc\x73\x21\x4e\x7c\x0d\x90\xe2\x12\x1d\x64\x01\xfb\x6c\xc0\xcd\x82\x62\xa2\xb0\x2d\x50\xd7\x4a\x6c\xc3\x31\x6b\xde\x4c\x5e\x2c\xec\xd0\xab\x3c\x44\x4c\xd5\x38\xe8\x35\x83\x65\xe5\x6d\x37\x08\x2d\x97\xb1\xac\x06\x56\x74\xf7\x91\xfc\x4c\xc4\x0f\xaf\x63\x14\x04\x1e\xef\xf9\xde\x88\xb8\x74\x04\x81\xdd\x0e\x7c\xdf\xf3\xf3\x8f\xf7\x2c\x17\x22\x72\x5b\x8e\x43\x2c\x1e\x22\x1c\xd4\x67\x81\xc9\x63\x1c\x0f\x1d\xb5\xd4\x18\x36\xf9\x80\x3a\x9d\x22\x00\x93\xa8\xb1\x57\x66\xeb\xa7\x42\xef\xe7\x28\xc0\x05\x7a\xcf\x0a\xdc\x5c\x48\x9a\x94\xba\x04\x4c\xd0\x2c\xc7\x0e\x68\x9b\xac\x90\x60\x38\x00\xdf\x70\xbd\x04\x6b\x81\xb6\x11\x35\x4e\x6d\xe8\xc1\x93\x27\xf2\xc4\x12\x9e\x77\x76\x76\xc8\x63\x54\xf9\x1f\x33\x8e\x8f\x7d\x53\xbd\x24\x2f\xf0\x75\x0d\x8e\x7e\xb7\xcd\x1e\x8b\x88\x69\xf9\x60\xd8\xdc\xc3\xb1\x03\xb4\xe0\xb7\xe8\xaa\x38\x64\x96\x1f\xe0\xe0\x51\x35\x01\x47\xcd\xe6\x47\x77\x88\x94\x4a\x1c\x9a\xb3\x21\xc4\x66\xbf\x19\xf8\x34\x08\x18\x1a\x60\xf8\x47\x31\x36\x72\x93\xe2\x91\x26\x44\xc3\x13\x4d\x14\x21\x7c\xf8\x63\xb2\x4c\x62\xb8\x00\xa9\x04\xf6\x8a\xed\x95\xe8\xe6\xe9\x4c\x34\x04\x0d\x74\xf5\x99\xf2\x9d\xb4\xd4\xc8\xd7\x40\x28\xc1\x7d\x8b\x22\x8e\x7e\x2f\x82\x46\x9d\x44\xc8\x07\x7e\x51\x42\x74\x51\x23\x22\x84\x91\x3b\x31\xf5\x34\xe2\x72\xfc\x02\x33\xe7\xfe\x8b\xe4\xf7\x29\x03\xa4\x70\xd3\xa2\xae\xed\x68\x45\xc4\x25\x08\xec\x72\x3a\xb6\x43\x4f\xae\xa9\x7f\x6d\xd3\x11\xc1\xb5\x1d\x36\x13\xe2\x0f\x5d\x42\x98\x4e\xc1\x97\x7c\x5d\xf2\x1b\x1f\xf2\x3c\x39\x8d\x92\xf4\x4b\x3c\xa2\xd5\xf4\x4a\x62\xc9\x2a\xd9\xc1\x1f\x96\x63\xb7\x85\x79\x38\x07\x5a\x88\xde\x2b\xcd\x04\xb3\xe5\x78\x2e\x8d\x40\x14\x68\xc2\xcd\x93\x16\x31\x6b\x3e\x1d\x3e\x5f\x48\xc3\x94\xbf\xce\x6b\xad\x69\x09\x4d\x67\xec\x87\x61\x39\x3f\x87\xb6\x76\xf1\xd8\x7a\x4c\x56\x9f\xca\xcc\x05\x4f\x57\x2f\x15\x1d\xc4\x3a\x7f\xf0\xee\x0c\x74\x16\x0c\xb6\xb8\x77\xf2\xb6\x71\xfe\xe9\xdd\xc1\x19\xe8\x48\xb3\x28\x55\x17\x8f\x9b\xd0\xd8\x9b\x83\x97\x07\x6f\xf7\x39\x90\xa7\xab\x97\xa5\x8e\xed\x84\xd4\xd7\x0e\xf7\x19\x3f\xc7\xb6\xa9\x98\xe1\x18\xa2\x3f\x6f\xab\x9b\x4d\xec\x90\x9c\xca\x19\x44\x48\xd2\x8a\x13\xfa\x2f\x1c\xab\x64\xcc\x43\x48\x37\x8f\x8b\x95\x19\x64\x32\xe2\x36\xa4\x04\x25\xe2\x54\x24\x8d\xb4\x58\x92\x58\x60\xae\x60\x92\xd1\xb5\x11\x0b\x20\xc0\xbf\x57\xfc\xc8\x8c\xa5\xd4\x8c\x18\x89\x9d\x33\x43\x46\x72\x01\x68\x06\x8d\xe4\x84\xbf\xb7\x58\x91\x4d\xef\x86\x1b\xec\xaf\x54\xb4\x3c\x93\xaf\x78\xba\x9e\x15\xcc\xa9\xa6\x45\xb9\xcb\xe8\x52\x62\x5c\x3b\x5d\x83\x96\x5c\x93\x1c\xca\x6e\x81\x28\x71\xd0\x37\x4c\x2f\xb3\xbb\xeb\xdd\xe4\x33\xe2\x16\x69\x50\xa6\x8b\x3c\x26\x0b\xce\xd5\x5e\x97\x86\xac\x44\x4a\x23\xfc\x6b\x34\x34\x8e\x18\x25\x35\x64\xba\xc3\x88\x18\x33\xc6\x60\xe8\x47\x2c\xde\x44\x4a\xe1\x28\x1a\xc5\xf0\x95\x19\x53\x49\xc2\xfb\x6d\x07\xe3\x49\xa9\xaa\xec\x4d\xc1\xf0\x3c\xc4\x9c\xd4\x22\x13\x92\x6c\x58\x26\x78\x52\x75\xef\x62\xb1\x8d\x78\x6d\xa6\xd8\x64\xd1\x8b\xcb\x71\x91\x68\x2b\x9d\x74\x91\x82\xe8\xd0\x11\x21\x65\x76\xfc\x20\xc7\x1a\x7b\x43\x2d\xe0\x05\x3e\x1b\x2e\x55\x0e\xdb\xf1\xaa\x78\x41\xec\xd1\xf0\x3d\xd2\x93\xae\x6a\x21\x2f\xf4\xd7\xf1\x50\x2b\x59\x61\x56\x5a\x3d\xcb\x0f\x23\xe1\x74\xd4\xbb\x58\x49\x35\xc8\x5a\x51\x39\xcc\x8a\x12\xbd\x77\x1e\xa3\xc3\xb5\x67\xb7\xf5\x24\x78\x84\x5c\xeb\x1f\x0c\xcf\xd1\x47\x98\xb3\xe8\xf6\x96\x20\x69\x4b\x90\xf0\xcc\x0c\x93\x73\x7b\x4b\x22\xdf\x50\xe9\x65\xaa\x3a\x7e\xf0\x11\xbf\xe4\x5a\xea\x23\x54\x8b\xfa\x57\x72\xea\xb3\x55\xb1\x05\xd1\xd8\xc1\xa0\x43\x8c\x1a\x7b\x2d\x08\x1d\x09\x7c\x00\x17\x1e\xde\x8d\x18\x78\x35\xcf\x6e\x6f\x15\xf7\x96\x15\x8f\xb2\x3f\x4e\xa1\xef\x3c\xf3\x61\x3e\xaf\x8d\xc4\xed\x2d\x9b\x08\x2b\x0c\x66\x09\x6a\x17\xe0\x9e\xf3\x2e\xd3\x8f\x93\x03\xd4\x3a\xe1\x8b\xe4\xdd\xdf\x45\x3e\x42\xce\x0f\x4f\x9e\xf0\x5f\x9c\x22\xac\x3d\x72\x07\xe6\x3c\x88\x4d\xac\x1c\xd0\x1b\x8b\x65\xb8\x54\x26\x0e\x63\xe8\x0d\xd2\xc6\x43\x7c\x8a\x0e\x22\x66\xcb\x4b\xab\xa5\x7d\x4d\x1c\xc6\xc8\x24\x61\x94\xe0\xc9\x89\xe3\xa3\xd6\x48\x1f\x36\x21\x63\x22\xe3\x76\x2d\xc6\x2d\xf4\x06\x72\xd8\xf8\xb4\x10\xe3\xc6\xa0\x96\xb0\xfe\x34\x23\x27\xe6\x44\x1c\x6f\xec\x2a\x0e\xa1\x48\x88\x19\x1b\x1b\x4e\x0f\x6d\x10\x01\xb5\x58\x39\x46\xed\x89\x43\x28\x94\x0c\x7e\x1a\x07\x36\x1f\x8c\xb3\x8a\x80\x65\xfa\xca\xa3\x96\xa7\x14\x09\xaa\xaf\x5f\x09\xeb\x4f\x75\xfa\x05\xa8\x3a\xe5\x0a\x54\xd5\x97\x20\xd5\x9e\xe7\x32\x24\x70\x91\x35\x44\x75\x49\xff\x62\x2e\x5a\x50\x88\x27\x38\x83\x30\xf9\x4f\x9e\x90\xe8\x3b\xe0\x1f\x6f\xe8\xb6\x6d\xb7\xbb\xe7\xd8\xd4\x0d\x4f\x69\x2b\x8c\x86\xd7\xd4\xf8\x6d\x62\xdd\x7c\x21\xe2\x14\x0f\x66\x0e\x56\x33\xc8\x4b\xc1\x80\x42\x02\x03\x85\x90\xdf\x60\x67\x71\x7b\x4b\x8c\x72\xc8\x87\x58\xf0\x15\xe7\x49\x28\x99\x10\x49\x30\x31\xf2\xaa\xae\xb7\xc9\x86\x8b\xd1\x02\xaf\xd4\x92\xcc\x9b\xd4\x4a\xdc\x15\x49\xd4\xd2\x48\xfd\xb1\x9e\xe9\xa4\x8f\x7e\x27\xc6\x90\xb1\x3e\x19\x5e\xe0\x7a\x98\xc3\x89\xbe\xf5\x92\x99\xd8\xde\x67\xa5\xc2\x88\xa5\x18\x07\xdf\x4d\x17\x8e\x36\x49\x95\x25\x89\xea\xec\x84\xfe\x4f\xea\xbd\xd1\x77\x90\x77\x7a\xe7\x55\xd7\xa7\x08\x84\x3b\x47\xd8\x44\x46\x00\x31\x35\x13\x42\x25\x56\x53\x75\x9d\x96\x3c\xcc\xe0\x25\x4b\xe2\x58\x40\x2b\x34\x32\xf4\x8e\x6a\x9c\xb3\x7a\xa6\xba\x51\xe5\x9c\x65\xc0\xc0\x59\x04\xfe\xb6\x3a\x28\xed\xb5\x81\xb8\x37\x0c\xb5\xd2\x52\xcc\x49\x88\xd9\x79\x7d\xf9\x5a\x3e\x12\xcb\x34\xc4\x04\x4b\x48\x14\xdc\x93\x0b\x02\x96\x58\x92\x7c\x20\x96\x9a\xa8\x3a\xa9\x23\x5c\x28\x1a\xdd\x2a\x44\x83\xa7\x2e\x72\xa8\x21\x51\x8d\x44\x34\xd0\xb9\x4e\xf3\x53\xcd\xf9\x14\x56\xb8\x60\xc5\x81\xed\xd4\x0a\x47\x2c\x67\x46\x74\x1b\x3b\xb4\xa6\x91\xd6\xf4\x47\xef\x18\x6c\xd6\x89\x44\x6b\xc7\x3f\xe4\x34\x43\xc6\x9a\xa1\xdb\x23\xdc\xae\xa5\x5a\x4e\x3e\x23\xd3\x42\x87\xf3\xa2\x86\xef\x7a\x64\x5b\xd8\xa5\x10\x13\x0e\xa7\x6e\xfa\x1e\x40\x95\xc9\xdb\x21\xed\x17\x35\xf5\xd9\x9c\x38\x52\xd5\x67\xc5\x4a\xba\xba\x6f\x2e\x2c\x89\xca\x25\x5b\x5d\x26\x9e\xbe\x24\xdc\xe3\x5d\x3c\xee\xc0\xe1\x8b\x30\x0b\xc0\xd3\x17\x0d\x03\xae\x92\x24\xed\xb1\x62\x93\xae\x46\x62\x15\x15\xf5\x13\x22\xe1\xeb\x3d\xe9\x79\xbe\xfd\xcd\x73\xc3\x88\xa2\x9c\xd0\x16\x9f\x4f\x5a\x53\x72\x6a\x29\xd2\x26\xb4\x9b\xbd\xc9\xbb\xc4\x19\xc3\x3f\xe2\x39\x00\xc4\x26\x98\x3c\x6f\x2e\x1e\xcb\x33\xa6\xc7\x97\x32\xba\x4f\xb5\xc4\xf3\x0e\x89\xb8\x05\x08\x33\xa7\xbe\xcb\x40\x01\xfc\xb8\x43\x26\x12\x9f\xf5\x8a\xbb\x64\x99\x49\x5d\x66\xae\xcd\xd3\xea\x14\xe7\x69\x99\xf1\x3a\x86\xf4\xd4\xe5\xcf\x7c\x9d\xe0\xb9\xf8\xf4\x2d\xe6\x5c\x80\xb8\x01\xd1\x92\xb1\x03\x5d\x10\xd2\xe8\x1e\xb0\xe9\xdd\x07\x22\x76\xcb\x73\x31\x2b\xf7\xc2\x60\xce\x79\x5a\xa4\xf9\xd8\x2d\xaf\xce\xa1\x61\xfc\x71\x3a\x2f\x00\xef\x42\x97\x02\x45\x4d\xba\x21\x7f\xc1\x36\x75\x21\xf0\x7c\x8b\x5e\xc4\xcc\xe8\x10\x61\x12\x84\x37\xc2\x37\x36\x53\x0b\xb5\x03\x29\xd7\xe5\x56\xac\x28\x37\x93\xd8\x8e\x4a\xb6\x38\x73\x03\x18\x06\x00\xa5\x21\xec\xd8\x16\x62\x01\xc2\xb7\xee\x0b\x02\x11\xbb\xcc\x05\xc1\xf8\x0b\xce\x0d\x26\xc5\x81\xbe\x03\x6b\xec\x78\x56\x7b\x2e\x50\x2a\x77\xd6\x42\x63\x23\x13\x80\xcd\x8e\x80\xcb\x63\xef\xd8\x73\x76\x40\xd4\x0f\x17\x9b\xdb\xf7\x73\xad\x54\x80\x41\x81\x51\xe9\x78\x7e\xdf\x0a\x43\xcc\x48\x38\xd7\x2a\x53\x84\x90\x25\xc7\xde\x30\xa0\x07\xee\x3d\x01\x7a\x43\xad\xeb\xf9\xc8\xa4\x00\xed\x39\x76\xeb\x6a\x41\x18\x6a\xc3\x36\x37\xa0\xa5\x3b\x4d\xf5\x88\x47\x45\x52\xcb\x46\x65\x5d\x97\xd6\x86\xcc\x55\x52\x56\xca\xca\xb8\x60\x14\x72\x6d\x49\xdc\xba\x54\x0b\x70\xfe\x85\x8d\x83\x95\xb4\x34\x00\x13\x97\x7a\x68\x34\x4a\x9e\xae\x26\x19\x92\x5e\x3c\xb6\x1e\x5f\x92\x1d\x92\x57\x57\x68\x11\xd3\xd4\x4c\x7f\xce\x1f\x6d\x9a\xfa\x20\xb6\x99\xe5\x7b\xb0\xcd\x2c\x2f\x66\x9b\x59\x79\x40\xdb\xcc\xca\x7d\xd9\x66\x56\xee\xc1\x36\xb3\xda\x68\xaf\x35\x40\x5c\xa7\x8f\x22\x78\x56\xcf\x65\xf7\xa9\xc2\xb5\xa6\x42\xaf\xde\x07\xec\x05\x88\x68\x02\x9a\xdb\xfa\xf4\xa1\x0d\x5c\x37\x66\xb4\x0a\xfd\x69\x13\xfa\xd3\x26\xf4\xa7\x4d\xe8\xbd\xda\x84\xfe\x34\x09\xfd\x69\x12\xfa\xd3\x24\xf4\x2f\x66\x12\xba\x37\xf4\xaf\xa9\x6e\x11\xca\xe6\xef\xd9\xa7\xe3\xdd\x93\x37\x8d\xc3\xfa\xde\xf9\xc9\xe9\x11\x98\x06\x32\xb5\x3f\x18\xf7\x9b\x9e\xb3\x67\xfb\xad\x49\x87\x72\x4a\x27\xba\x78\x3c\x84\xdd\x9c\x5e\x17\xcd\x12\xf9\x1b\xdf\x0b\x82\xe9\x81\x5d\xeb\xc0\x20\xa6\xa7\x06\x6b\xdf\xb6\xfa\x9e\x3b\x61\xaf\xab\x43\x1b\x69\xd0\x78\x65\x80\x27\xfb\x7a\xf6\xe7\xd0\xf2\x67\xe8\xeb\x8d\x06\x10\xeb\xea\xf8\x9d\x85\xd6\x84\x8d\xa6\x0e\x6b\xac\xc3\x0a\x2d\x5f\x87\x74\xee\xdb\x96\xdb\x9d\x65\x14\xbe\x69\xd0\x44\x6d\x1d\xe2\xc7\xf1\x0c\xc0\xea\x1a\xb0\x8f\x63\x80\xb3\x74\x87\x3a\xd3\x69\x7d\xff\xa8\xfe\x56\x44\x09\x78\x77\x44\x56\x49\x65\xab\xcc\xd7\x85\x2e\x0d\xcf\xa0\xd2\xa1\xc5\xe6\xd6\x58\xd7\x28\xa2\xdf\x34\xa3\x51\xf0\xa6\xe5\x27\xdf\xd8\x68\x8e\xcb\x80\x52\xe0\xd8\x2d\x9a\x2f\x17\x49\xa5\x50\x0a\xbd\x0f\x03\xc6\xf0\x56\x40\xf3\x05\xb3\x40\xc5\x38\x91\x8f\xb2\xf7\x05\x03\x7e\x89\x41\x59\x17\xe1\x69\x65\x62\xdb\xb2\x9c\xd6\xd0\xb1\x42\x5a\xf7\xa9\xc5\x76\xca\x7a\x4f\x63\x1f\xf3\x81\xfd\x8d\x16\x21\xee\xde\x39\x48\x20\xd5\x75\x90\x16\xfc\x3d\x5e\x6e\x40\x44\xf5\x88\x0d\x32\x2b\x21\x8d\x10\x83\x91\x1d\xb6\x7a\xba\xd1\x2d\x21\x2d\x2b\xa0\x24\x07\x41\x70\x73\x35\xf3\xee\x62\x83\x3c\xc5\x88\x7f\xfc\x9f\x55\xf2\x7c\x5b\xab\xd3\xc6\x69\x11\xad\x55\x2e\xc5\xeb\x61\x04\x8c\x3f\xfd\x10\x3d\x68\x25\x88\x00\x26\x42\x14\x82\x56\xd7\x28\x1c\x5a\xbe\x2c\x6a\xda\x2e\x20\xcf\xee\x90\xca\x16\x79\xca\xf9\x4c\x33\x50\xe0\x60\x2b\xa5\x6a\x14\xb3\xa7\xdc\x72\x21\xb4\xdc\x3c\xc0\x28\x90\x15\x62\xbe\x21\x4f\x49\xb5\x40\x9e\xe2\xdb\x81\x37\x8a\x56\x28\x92\x6a\x21\x72\xc1\x8d\xe8\x86\x7c\x2a\x45\x7b\xa7\xd3\x22\x46\xa8\x75\xbd\xc3\xa3\x71\xac\x72\xbe\x5a\x21\x2b\xa4\x52\x16\x08\x71\x38\x71\x40\x5b\x08\x48\xc4\x40\x4a\x40\xe1\xdd\x51\x72\xeb\x77\x92\x55\x71\xd2\x05\xd3\x58\x5c\x27\x6d\xd3\xa6\xb1\xb8\x9e\xd9\xe0\x9a\xe3\x94\x61\x71\xcd\x4b\x48\x7b\x81\x64\x33\x6a\x5e\x4a\x5c\x60\x8b\xeb\xeb\x89\x86\xca\xbc\xde\x34\x26\xca\xa2\x89\x02\x37\x4f\x46\x08\x72\x3f\x57\x48\x31\x0e\x96\x3d\x8c\x5e\x03\xbf\xb3\xc2\x9e\x4a\x11\x8b\x81\x3a\x09\x79\x4a\xf6\x84\xd0\x00\x37\xfc\x81\x15\xf6\x08\xd3\xf4\x70\xf5\xc6\x22\xff\x15\x17\x9c\x18\x9b\xe0\x0e\x4a\xf1\x8f\xab\x69\x57\xca\xac\xbd\xa8\xd5\x45\xb6\x19\x69\x80\xe2\x4c\x64\x4d\x63\xa2\x2b\xf2\xf5\xdc\xc8\x97\x26\xc5\x9a\x6e\xed\x13\xcb\xa8\x66\x18\x49\x04\x91\x45\x22\x79\x6d\xd8\x8e\xd5\x98\x86\x89\x4d\x41\x1e\x6a\x82\x1c\x79\xb7\x00\xe8\xe4\x0d\x14\x0a\xd0\x89\xfc\x94\x82\x3b\x66\x2f\x81\xb0\x32\xec\xa6\xe7\xb0\x8c\x99\x64\xff\x12\x4b\xd1\x58\x4d\x4e\xcc\xd8\xba\xd1\x4b\x18\xb9\x34\x5a\x63\xfd\xd3\x38\x95\x07\xaa\x25\x14\xe2\xba\x61\x01\x03\xbb\xb3\x43\x96\x5b\x37\x4c\xcf\x66\x90\xe0\x69\x0c\x5a\x37\x54\x66\xcf\xec\x17\x9c\xa4\x46\x84\xf8\x0c\x47\x9b\x31\x03\x93\xdc\x00\x66\x90\x69\x42\x38\xb5\x39\x83\x79\x11\x71\x05\xdc\x01\x33\x9e\x06\xd4\x65\x9b\x60\xcf\xad\x87\xa1\x6f\x37\x87\x21\x0d\x90\x61\x34\x4b\x8f\xb9\x1b\xa2\xd0\x10\xfa\xcd\x1c\x5c\x53\x37\xcc\x6c\x24\xc5\x56\x66\xd6\xc3\xbe\x7c\x21\xaf\xcc\x6b\x90\x47\x83\x9c\x96\x0e\xc4\xc8\xad\x19\xfa\x96\x1b\x74\x3c\xbf\x5f\x63\x8b\x9e\xe5\x06\x6c\x1e\xe4\x99\x1e\xd6\xba\x21\xcb\x24\x57\x24\xf0\x7b\xcc\x7e\x17\x0c\xeb\x9c\x76\x4d\x1a\x1d\xa1\xb0\xd1\x6c\xc6\x0a\x73\x59\x54\x70\xe1\x99\x6d\x52\x51\x9e\xd1\xa4\xe2\x4c\x12\x20\xc9\xa6\xc2\xe0\xa6\x59\x47\xb7\x05\xa3\xfb\xee\xf4\xe0\xec\xe0\xed\x79\xfd\xfc\xe8\xe4\x6d\xa3\x7e\x7e\x7e\x7a\xb4\xfb\xe1\x1c\xaf\xb6\x70\x48\xa7\x1a\xca\xe4\xc3\xef\x92\x25\x43\xf7\x4f\xbe\xad\x4b\x05\x21\xaf\xb6\x41\xa3\x85\xd4\x92\xa0\x31\x16\x95\x1a\x58\x94\xea\x1c\xcf\xa3\x08\xd9\x13\x85\x12\x54\x44\x75\x06\xaf\xa6\x5b\x37\x73\x21\xa1\xd9\x5b\x8c\x17\x04\x10\x4c\xb0\x6c\x98\x12\xc4\x24\xcb\x86\x89\xf4\x04\x95\x9d\x13\x91\x86\xd4\xcf\x5d\x16\x96\xee\x0a\x99\x37\x6c\x3c\x69\x88\x18\x09\xd9\x99\x67\xeb\x26\x56\x08\x5b\xde\x9e\xdd\xd7\xe5\x99\xa6\x38\x45\x6e\xcf\x32\xa3\x69\xfe\xe8\xdb\xb3\x46\xe0\xb7\x1a\x96\xdf\xca\x08\x53\xc1\xaf\x47\x86\xee\x30\xa0\x6d\xd9\x84\x4f\x39\x1d\x2c\xbf\x85\x1d\x9a\xe3\x16\x8a\xb7\x4e\xad\xd4\xe6\xd7\xa2\xf1\x64\x64\xbb\xf9\xa6\x0d\xd6\xd6\x05\x73\x24\xd4\x95\x4b\x3b\x9f\x48\xcc\xc7\xd6\x63\x65\xcb\xab\xc7\x3d\x9c\x12\x51\x18\xe1\x6d\xb0\xd6\x9d\xeb\xb2\x0b\x40\x39\xb6\x9b\x7e\xdb\x55\x2d\x97\xef\xbb\xcf\xfd\x99\xfb\x6c\x20\xba\x58\x9f\xd7\x10\xd4\xc0\x4e\xef\xf2\x66\x65\x3d\x9b\xcb\x06\x36\x9d\x93\xcb\xd6\xd5\xe0\x9d\x5a\x6d\xdb\x72\x32\x90\xd8\x9c\xc4\xea\x02\x06\xc7\x25\xad\xa0\x0f\x85\x98\x8e\x3b\x27\xd2\x1b\x8a\xfa\x13\x90\x5e\xab\x6c\x65\x23\xad\x60\x4c\x85\xf4\x1b\xdb\x9d\x97\xd2\xcf\xf8\x38\x7b\xb6\x1b\x4e\xc4\xfa\xf9\x84\xf1\x56\x40\xe6\xc4\x66\x53\x92\xf0\xaa\x61\xbb\x6d\x7a\x93\x31\xee\x93\x49\x78\xf5\x4a\xda\x65\x4c\x20\x23\x2b\xfc\x07\x37\xd1\x98\xa2\xe8\x42\x7d\xdc\xc2\x3e\xa2\xe6\x99\xd1\xbf\xe7\xf7\x2d\x4f\xc2\x99\xe5\x49\x04\x55\x53\xa2\xa4\x11\x88\xab\xd4\x73\x52\xe7\xb9\xd1\x24\x2a\x02\xe9\x1c\x59\xad\xdc\x37\x91\x86\x33\x13\x29\x19\xe3\xc5\xa4\x6f\xa5\x6c\x02\x65\xfa\x68\x06\x15\xaa\xf7\x4d\x85\xeb\xd9\x97\xdb\x44\x8c\x17\xa4\x42\xc5\x80\xc9\x95\xf1\x0c\x3a\xac\xdd\x37\x1d\x46\xb3\xd3\x21\x05\xe7\x05\x29\x51\x35\xa0\xe2\x5e\x24\x83\x10\x1b\xf7\x4d\x88\x9b\xd9\x09\x91\x8c\xf2\x82\x74\x58\x33\x81\x86\x56\xba\xc9\xcc\x5a\x75\xfd\xbe\xa9\x30\x9e\x9d\x0a\x49\x08\x2f\x48\x83\x75\x03\xa4\xd8\x85\x66\xd0\xe1\xde\xb5\xf1\x6f\xb3\xd3\x21\x0d\xe9\x05\x69\xb1\x61\x80\x1d\x8d\xb3\xc8\xb0\x79\xdf\x64\xa8\xcf\x4e\x86\x04\x7c\x17\xa4\x00\x57\xe0\xe0\x48\xbc\xd1\xb4\x02\x3b\xd8\x73\xbc\x80\xa6\x8b\xc9\xcd\xea\xbd\xef\x54\x5a\xb3\x13\x22\x1d\xed\x05\xe9\xb1\x19\x03\x7c\x32\xa0\xe9\xa1\x4f\x37\xef\x5f\x85\x68\xcf\x4e\x8d\x34\xa4\x17\xa4\xc5\x56\x0c\x6c\x86\xf5\xdf\xbd\x4b\x89\xe6\xec\x74\x48\x42\xf8\xe2\x71\x73\x11\x1a\x3c\x37\x40\x0e\xdd\x76\x86\xa8\xdc\xac\x4e\x38\x37\x01\x28\xbb\x00\x64\x4e\xfd\xb6\x5a\xd6\xf1\x69\x59\x7e\xdb\x76\x2d\x67\xc2\x94\x5d\xab\x4e\xd8\xec\x00\xb4\x3d\x03\xd8\xbc\xf8\x55\x92\xf0\xcb\x9c\x42\x6b\xd5\x09\xfb\x42\x03\x3b\x06\x6a\x5e\xdc\xaa\x49\xb8\x65\xb0\xf4\x84\xa3\x01\x03\xaf\x79\x71\x5a\x33\x71\x0a\xfb\x43\xc7\x39\xf5\xfa\x13\x85\xf0\xda\x54\xb8\x99\xe0\xe6\xc5\x71\x3d\x19\xc7\x09\x82\x71\xc2\xe9\x4e\x04\xc3\x45\xc6\x75\x23\x19\xbf\x8c\xc3\xb6\x69\xe6\xa9\xc2\x6d\x5e\xbc\x8c\x45\xca\xb1\x5d\x6a\xf9\x13\xc7\xf5\xde\x55\xef\xce\xec\xc7\x80\x19\x78\x2f\x78\x12\xba\x19\x87\x9c\x31\xff\xee\x5d\x01\xa7\xb3\xd3\x22\x11\xe3\x05\xa9\x60\x2c\x53\x7d\xcf\xf5\x42\x2f\xe3\x68\x78\xf3\xfe\x15\xf0\xee\xec\x74\x48\xc1\x39\x99\x12\x8b\x63\xd8\xbb\x47\x0c\x17\x59\xff\xab\xc6\xfa\xef\x5a\xe1\xd0\xcf\x3a\x4d\xbe\xff\x4d\x82\x3d\x3b\x21\x92\x51\x5e\xf0\x3c\xdf\xd0\x3b\x82\x90\x0e\x32\x88\xb0\x75\xdf\x44\xf8\x3a\x33\x11\x92\xf0\x7d\x28\x5e\xbd\xba\x27\xec\x92\xf8\x74\x71\xec\x9c\x7b\xc2\xae\xb5\x08\xf7\x88\x53\xad\x90\x61\x97\xce\x38\xf7\x7e\x66\xed\xce\xde\x79\x13\xd5\x05\x67\x0d\xd7\x38\xbd\x4e\x27\xa0\x21\xc3\xcc\xca\x38\x80\xdc\x5c\xbb\xf7\x9d\xb5\x37\x7b\xff\x93\x51\x5e\x90\x0e\x6b\x06\xd0\xb6\x7d\x4d\xfd\xae\xed\x76\x33\x48\x51\x99\x70\x4b\xc0\x86\xe7\x04\xc0\xed\x0b\x68\x73\xaa\x69\x6b\xeb\x06\x72\x6e\xd6\x5a\x1c\xf5\x49\x5c\x7c\x84\x06\xb3\x8f\x50\x12\xbe\x0b\x8e\xcf\x86\x01\x32\xb0\x9d\x9e\x37\xa4\x61\x98\xa1\x94\xac\xdd\xfb\xa5\xc1\x9f\xb3\x53\x22\x1d\xed\x05\xe9\xf1\xcc\x00\x3c\xb2\xbb\x59\x27\xa4\x9b\x6b\xf7\x7e\x71\xe0\xcf\x4e\x8b\x64\x94\x17\xa4\x03\xd7\x7e\x3d\xbf\x4d\xfd\x86\x15\xb4\x28\x74\x27\x63\x63\x35\x61\x5b\x8a\xd3\x96\x41\xab\x0b\x60\xf3\xce\xda\x2d\x1d\xb5\x36\x9d\x88\xdb\xe6\xda\x84\x0d\xa9\xc2\x6d\x9f\x2e\x8a\xdc\x73\x1d\x39\xdb\x0d\xec\x36\x3d\x19\x66\xe4\x85\x59\xdb\x98\x16\xb7\x23\x01\x6c\x5e\xd3\x88\xb2\x8e\x5a\xa6\xb0\xab\xdc\xbf\x4d\x4a\x30\x33\x5f\x27\xe1\xbb\x18\x53\xaf\x57\x74\x88\x3e\xbd\xa6\x7e\x90\x35\xb9\x9f\x4d\x3b\x34\xa7\x08\x4a\x78\x85\x91\xd5\x55\x02\xb9\xe5\x74\xd3\x10\x3b\x20\x6d\x3a\xf0\x69\xcb\x0a\x69\xfb\x51\xac\x0c\x58\x62\x44\xca\x4c\xfd\x67\xd8\x9c\x55\xcb\x99\x69\x81\x7f\xb4\xcd\x59\x7b\xad\x31\xb0\xc2\x5e\xfa\xc2\x3a\x67\xda\xa2\x4a\xa3\x01\x6e\x87\x56\x46\xd6\xa5\x67\x73\xa6\x27\xab\x36\xe6\x3c\xa8\x98\xc1\x48\x0a\x6c\x5e\x32\xe4\x29\xb8\x60\xe1\xe0\xce\x69\x94\xa8\x4f\x37\xee\x15\x76\x93\x99\xb4\x40\x61\x25\xbc\x54\x6e\x84\x7b\x1f\xfb\x1b\x4f\x5d\x19\x03\xd2\x8c\xf5\xca\x22\x2c\xf0\x14\x1e\x07\xc6\xc8\x26\xfa\xcb\x84\xfe\x50\x59\x5b\x43\xe8\xb6\x9b\x90\xa0\xfb\xac\x7c\xcb\xc6\x2f\x13\xe1\xd8\x20\x27\x25\x83\xe0\xd0\xbc\x61\x38\x18\x8a\x26\x4c\xcf\x1a\x56\x3b\xdf\xb6\x42\x4b\xcf\x66\x60\x2b\x83\x6e\x97\xec\x10\xf6\x59\xe4\x1e\x90\x1f\xda\xda\x4f\x24\x4e\x99\xec\x70\xf7\x58\xf9\xa5\x39\xec\x74\x20\x61\xa0\x74\x14\x10\xbd\x15\xde\xc2\x12\x35\xe8\x4c\x1e\x2b\x4c\x43\x66\x6d\x6a\x8a\x9e\x83\x9b\x0c\x7a\x75\x18\xb9\x14\x54\x10\x82\x1d\xe2\x6e\x93\xe5\x65\x5b\x79\x57\x70\x87\x73\xf2\x1f\x02\xc1\x8b\x79\x57\xf2\x6d\xde\xed\x0b\xfb\xb2\x48\xec\x22\xfc\x2e\x14\xc0\x8d\x41\xf4\x36\x1a\x08\x5a\xa3\xc2\x23\x55\x06\xfb\x57\x62\x64\x3e\x0b\x2d\x3f\xcc\x6b\x01\x55\x21\x9a\xa1\x56\xe0\xc0\x6d\xe7\x23\x6e\x67\x26\x68\x09\x0e\x58\x35\xbf\x7c\x93\x6f\x2b\xec\x8a\x64\x79\xac\x3f\x17\x8c\x74\x0e\x10\x8e\x16\x88\x5b\x90\xb9\xf6\x75\xae\x28\xf2\xb1\x22\xcb\xe4\x31\x38\x97\x0b\x93\x7c\xa8\xcf\xb0\x2b\xdd\x68\xee\x5c\xf9\x46\xc4\x27\x31\x1a\xf8\x82\xbc\xc0\x14\xcb\x22\x09\x7b\xc4\x41\x9d\xbc\x20\x0d\x52\xbb\x8f\xc9\xb4\xdc\x28\x14\x01\xbf\x02\xa9\x91\x1b\xc0\x78\x5b\xa2\x3c\x9e\x15\xe5\xf1\x0f\x47\x79\x1c\x41\x59\x49\x9a\x99\x10\x57\xd5\x1e\x1c\xfd\x47\x8f\x74\xfc\x79\xc3\x91\x5e\x08\xf9\x35\x53\x1f\xa4\xd0\x2b\x4a\xa9\xf8\x88\xa7\xbf\x7f\xf2\x84\xe4\x23\xa2\x82\x17\x29\x68\xb8\xc0\x87\x28\x26\x52\xbe\xce\x84\x4b\x43\x88\x28\xf2\x42\x13\xd1\xc6\x94\x21\xb5\xa8\xf4\x52\x05\x75\x0a\xf1\xb7\x0a\x2f\xde\x2c\xfb\x9e\x98\xb1\xbe\x5a\xae\x3c\xbc\x0a\x24\x34\x62\xbb\xdf\x1f\x42\x28\x83\xc2\x84\x05\xf9\x66\xde\xea\x4d\xa8\x3e\xde\x56\x11\x28\x6e\xf2\x03\x23\x3f\xd0\xe0\xa2\x7c\x09\x39\x67\x65\x89\x71\xac\x44\x05\x4b\x44\x29\x55\xfd\x0b\x52\x0a\xa4\xf3\xbc\x3e\x0e\xfd\x4c\x6d\x73\x6b\x7e\x6d\x73\xba\x6b\xe3\x25\x6d\x10\x70\x95\x09\x7b\x56\x58\x24\x37\x45\x32\xd6\x14\xb1\x0a\xb8\x22\x5a\x61\xa9\x71\x23\x03\x92\x8f\xd5\xcb\xb1\x7c\x79\x53\x55\x25\xab\xb2\xa4\x7a\x39\xae\xc2\x94\xc0\xb0\xf7\xec\x85\x53\xae\x34\x2c\xf2\xdb\x34\x44\x12\x11\x88\xe9\x20\xb0\x1d\xcf\x05\xe9\xa4\x69\x31\x16\xd9\x21\x55\xf2\x94\x28\xb8\x55\x8b\x2c\x93\x35\xe3\x95\xa5\x9e\x2a\xd5\x06\xfb\xae\x9e\xaa\x96\xa9\x07\xc5\x6b\x1a\x38\xeb\x55\x2d\xbe\xfa\x02\xa1\xf2\x37\x15\xf2\x94\x58\x64\x45\x10\xa2\x6c\x34\x5a\x55\x55\x6f\xa2\xf8\x16\xc8\x2a\x71\x11\x14\x90\x37\x3f\x36\x41\x8d\x53\x41\x8d\x53\x41\xdd\x45\x08\x5e\x5d\xbb\x27\x82\x37\x4d\x82\x57\xd7\x62\x04\x87\xa6\xa6\x23\x78\xdf\x24\x38\xaf\x69\xe0\x9c\x48\xf0\x2a\x10\x9c\xa1\xd1\x54\x64\xad\x44\xb1\x5a\x61\x7b\x03\xa3\x65\x46\x9e\x3e\xa7\x34\xc0\x18\x9b\x30\xc6\x09\x30\xc6\x69\x30\x80\xc4\xf8\x85\x4b\xff\x52\x93\x7e\xb3\xa9\x0f\xf1\x57\xce\xbd\xfc\x4d\xa5\x48\xc6\x95\x22\xb9\xa9\x16\xc9\xb8\x5a\x54\x33\x44\x8e\x5e\xc1\x14\x88\xea\x52\x5f\xac\x32\x45\x62\x39\x83\x1e\xd7\xdb\xc1\xe5\xb2\xa1\xd6\x1f\x6d\xcd\xc1\x4f\x50\x16\x12\xb6\x0c\x7a\x16\x80\x56\x10\x8d\x00\x3a\x0c\x9a\xe5\x53\x0b\xb4\xd5\x1a\x89\xec\xc2\x04\x38\xb6\x76\x81\x56\xbd\xc4\xa3\xa3\xb3\x2a\x07\x6e\x7b\x52\x85\xb7\xd6\x5b\x59\x45\xea\xc4\xa9\x95\x6e\xca\xc2\xe3\xb9\xc1\x25\x0e\xfc\xac\x92\x1d\xad\xd0\x58\x15\x1a\xab\x42\x30\x86\xbc\x35\x89\x03\x4c\x53\x51\x02\xd9\x4f\x3e\x01\x47\xed\x44\x4a\x57\xcd\xe2\x55\xb3\x7c\xd5\xac\x00\xe2\xd2\x20\x0a\x57\xea\x13\xfa\x27\xa3\x76\xa8\x9a\x6a\x3f\x01\x91\x22\xaa\x35\x73\x50\x61\x87\x70\xee\xe5\x05\x0d\x8a\xb2\xa3\x85\x6d\xd2\xf4\xa9\x75\xb5\xad\x57\x5f\xe3\xd5\x85\x0c\xcf\xae\x74\x27\xf7\x08\xda\x68\xdd\xde\x1a\x8f\x8f\x76\x78\x0a\x2d\xa3\xb7\x3b\x3b\xa4\x52\x28\x44\x50\x6d\x39\x5e\x40\xd1\xfb\x77\x3b\xce\x03\x15\x90\x5e\xe2\x85\x24\x16\x00\xd4\x48\xa5\x56\x1c\x02\x1b\xff\x65\xf6\x82\xfd\x3b\xd6\xf6\x93\x89\xf4\x83\x15\xaa\xba\xa6\x33\xcc\x0a\x31\x7c\xdd\xc7\xda\xd7\x31\xfb\x3a\x16\xc4\x33\xb8\x41\x8b\xc7\x61\x8e\xba\x8a\x1c\xc2\xda\x79\x0a\xad\x2d\x03\xd4\xa7\xec\xff\x8b\xfa\xa4\x8b\x6c\xc4\x26\x8f\x7c\xb9\x16\x61\xa8\xca\xb6\x4e\xc0\x17\xc9\x7c\x81\xe4\x8a\x32\x4d\xdf\xbb\x96\x1f\x93\xd8\xa4\x12\x6d\xab\x9a\x54\xaa\x1a\x2d\xb5\xb6\x4d\x56\x57\xc9\xc0\xf7\x5a\x94\xb6\xd5\x11\x09\x84\x25\x21\x8a\xe5\xb8\xda\x10\x61\xb5\xec\x19\x59\x4c\x9f\x9e\xd1\xb9\x1c\x9b\x9d\xc5\xac\xb9\xba\x9d\x26\x58\x8a\x49\x22\xa6\xa8\x09\x1b\xdc\x56\x26\xca\x9b\x62\x92\xe4\x29\xea\x32\x68\xac\xe2\xaf\xc4\x0f\x63\xe3\x27\x62\xa0\xc7\x61\x29\xa9\xa3\xf1\x52\x5c\xd1\x64\x6b\x93\x4a\xb6\xd9\x1a\x06\xa1\xd7\xcf\xcb\xa5\x40\x3f\xdb\x69\xc5\xd6\x8c\xe8\xc6\x07\x16\x85\x17\x10\xaa\x2d\x63\x81\xa9\x41\x81\x29\xb5\x4b\xb1\x65\xd4\xec\x0b\x2f\x15\xc4\xb2\x0a\x90\xa2\xb0\x2b\x89\xc5\x49\xce\x7d\x6d\x65\x53\x99\x57\xb1\xa7\xcb\xf8\x2d\xb6\x9b\x52\xe0\xd8\x9e\x2a\x5f\x2e\x6d\x14\x92\x76\x56\x6b\x7f\xa9\xfd\x02\x6e\x8d\x82\x61\x7f\xde\xdd\xc2\x14\xf7\x20\xf7\x71\x04\x1b\x50\xdf\xa6\x81\xd2\xff\x83\x61\x3f\x60\x88\xc3\xeb\x52\xdf\x1a\xe4\x83\x61\x1f\xc6\x84\x8f\xc6\x14\xc7\x77\xda\x9d\x48\xec\x88\x81\xb7\x57\x0a\x3c\x3f\x54\x58\x58\x45\xd2\xd4\xee\x5e\x18\x12\x17\xd6\x25\x04\x55\xec\x07\x17\x4d\x7e\xb3\x02\x1b\x6a\x39\x07\x82\x61\x3f\x8e\x3d\x5b\xa4\x8b\x10\x9b\x74\xa5\x52\x04\xd5\x9e\xf7\x44\x24\x58\xbd\x66\x5d\x19\xf5\x6c\x87\x92\xfc\xf2\x32\x9c\x0e\x16\x30\xdb\x1b\x5b\x80\xb0\xf0\x85\x7d\x79\x51\xb9\x2c\x90\x80\x2c\xef\x60\x05\x81\x57\xe2\x46\x75\x3d\x8b\xf1\x38\xe9\xd3\x99\x0d\xd4\x6b\x2b\xa0\x47\xc1\xc1\x9f\x43\xcb\xd9\xa7\x74\x90\x7a\xef\xb3\xc9\xcf\x96\xed\x00\x47\xe1\x8d\x7d\x45\x53\x0a\xaf\xaf\x73\x9f\xff\x25\xf2\x94\x9c\xf7\x28\xb4\xc1\xf8\x0f\xa3\xab\x40\x00\x14\xe2\x75\xc8\x97\x46\xc9\xc6\x96\xbf\x30\xb2\xb4\x7a\x24\x18\x0e\x00\x65\x32\xb0\xfc\xd0\xb6\x1c\xc8\x29\x6a\xf9\x76\xe0\xb9\x01\x03\x66\xb9\x6d\x12\xfa\x56\xeb\x2a\x60\xff\xc0\xfd\x52\x9b\x60\xec\xca\xa0\xb4\x44\x30\x34\xe1\xc0\xb7\xaf\xad\x90\xe2\x6f\xcb\xb7\xfa\xe4\xfb\xd3\x3b\x8c\x88\x03\xd8\xe0\xaf\xd0\xe3\xc0\x69\x29\x52\xd2\x83\xe0\x91\xac\x24\xfe\xca\x2c\xdf\xf4\x3c\x87\x5a\xee\x1d\x69\xda\x61\xdf\x0a\xae\xb0\xbf\xfc\x77\xc7\xb1\xba\x80\x17\x01\xf5\xe4\x83\x0b\x97\x6c\xb4\xad\x75\x0b\x3e\x32\x5d\xe1\x5d\xac\xc7\x7a\x33\x22\x99\xf4\x1d\xb9\x40\x89\x65\x7f\xa3\xfe\x25\x34\x26\x99\x92\x61\x28\xbe\xe9\x84\x33\xf0\xc5\xc1\xbb\x23\x17\x70\x51\x77\x49\xce\xa3\xd4\xfc\x02\xdd\xfd\x02\xa4\xfe\x02\x04\xf8\xa2\x53\x58\x04\x88\x0a\xb4\xae\x9f\xf2\x37\x5f\x42\x9f\xd5\xb4\x3b\x10\x5e\x0a\xe0\x04\x4c\x85\x27\x8c\x33\xfe\x7f\xf6\xde\x7d\xbd\x6d\x1b\xe9\x03\xfe\xdf\x57\x81\x78\xb7\x91\x14\xd3\xb2\x0e\x96\x0f\x72\xdd\x6c\xe2\xb8\xad\x77\x93\x38\x4f\xec\x76\x9b\xd7\xf1\xeb\x42\x24\x24\xb1\xa1\x48\x95\xa4\x6c\x2b\x89\xbf\x7b\xfa\x6e\xe1\xbb\xb2\xef\xc1\xe0\x40\x80\x04\x29\xea\xe0\x24\xed\xeb\xee\xb3\xb1\x88\xc3\x60\x30\x18\x00\x83\xd3\x6f\xae\xb1\x07\x1e\x5d\x60\x7b\xfa\x77\xd8\xd1\xff\xbd\x0e\x98\x91\xb2\x02\x8a\x2a\x56\x21\xb7\xc5\x5a\xc0\x12\x02\xb5\x92\x0a\x32\x3c\x59\xfb\x43\x82\x70\xc7\x9a\x89\x9a\x8e\x90\x29\x35\xce\x03\xdc\xee\x1a\xb3\x49\xd5\xd4\x6c\xcf\xed\xf3\x67\xde\xd6\x4a\x40\xf5\x91\xaa\xea\x2c\x03\x38\x78\xd4\xc3\x59\x61\x69\x87\xde\x8c\x3c\x35\x6e\xd9\xaf\xc7\x8f\x79\x01\x8f\x04\x7f\x82\x19\x9e\x21\xd5\x0d\xcb\xd4\x5f\xc9\x22\x84\x01\x63\x04\xeb\xfe\x75\xde\xfb\xd1\xa1\x9a\xd0\x30\x77\x75\x4a\x0c\x21\x30\x5a\xf0\x0e\xfd\x86\x84\xfd\x20\x1c\x45\x08\xd3\xaf\x8b\xdf\xcf\xf0\x88\xfc\x4a\xb9\xfd\x1f\x12\x06\xbf\x5f\x56\x87\x71\x3c\xee\x6e\x6d\x11\x7b\x84\x37\x5d\x3f\x26\xa1\x0f\x1d\x1e\x7b\xf5\x20\x1c\xb0\xe0\xd6\x4e\x6b\x6b\xb7\xde\xd8\xfa\x47\x44\xec\xcd\x08\x8f\x08\xd4\xf6\x23\x09\x83\x1a\xa5\x99\xe8\x2e\xea\x91\xf8\x86\x10\x1f\xc5\x37\x81\x50\xa8\x38\x40\x0e\x89\x49\x38\x82\xc3\x61\xd0\xb5\x69\x4a\xcb\xe4\x50\xc0\x20\x87\xe1\xe7\x88\x8c\x7a\x24\x3c\xed\xa3\x2b\x16\xe3\xfa\x36\x41\xdb\xf5\x46\xbd\x01\xdf\x36\x8e\xc9\x20\x08\xa7\xe8\x25\xf6\x07\xf7\x3c\x74\xac\xb8\x07\xa1\x7f\x91\x5b\x4c\x07\x57\x5e\x6b\xf0\x10\x07\x0a\x0a\x3e\x3e\x2b\xb8\xd2\x45\x4d\xf0\x3b\xc5\xe3\x98\xa6\xa7\xa2\x68\xec\x55\x9d\xfc\x59\xe5\x4e\x8f\x38\x89\x1a\x64\xdb\xda\x42\x87\x3f\x40\x1f\x32\xa6\x84\x2e\xa0\x24\x04\xde\xd4\x94\x15\x80\xae\xc1\x95\x22\x6a\x90\x86\xcf\xf0\x34\x69\x21\xc1\xd7\xf8\xb5\x45\x17\xe2\x06\x82\xca\x80\x42\xfe\xd4\xfa\x91\xb6\xf7\x9b\x1a\x2e\xa0\xc7\xcf\xee\xb5\x39\x3d\x8c\xfc\x69\xe8\x58\x3b\x4b\xcf\xcd\x03\x12\xbf\xc6\xb1\x7b\x9d\x37\xd1\xee\x88\x49\x39\x0c\x82\x1c\xd8\xfd\x6a\x7b\x9f\x4d\xc6\xe8\xf9\xc4\xf5\xe2\x4d\xd7\x47\x23\x12\x0f\x03\x07\x85\x02\x62\x3a\x82\xdd\x21\x50\xb3\x6b\x12\xba\x7d\x97\x38\x54\x65\x7b\x04\xf9\x50\x78\x9d\xd6\x83\xb2\xf3\x0a\x8f\x19\x8e\x1e\x63\xaa\x4a\x4b\xb5\x50\xe5\x15\x1e\xd3\x86\xcd\x4a\xe5\x15\x1e\x1b\xc4\xb2\xbb\xb4\x58\x46\x78\x7c\x84\xed\x21\x39\xf2\x08\x0e\xf3\x0c\x96\x4e\x8b\xcb\x46\xa4\x7e\x41\x3c\x12\xe7\x49\x72\xb7\xb3\x9f\x4a\xfe\x13\xc9\x93\xe8\xee\x4e\x33\x95\xf6\x67\x1c\xe5\xa6\x4d\xb3\x71\x56\x40\xb7\xad\xd8\x4d\x47\x00\x48\x17\x21\x4c\x73\x22\x9b\x66\x15\xbd\x3a\x0e\x50\x14\x07\x21\x41\x1f\xc8\x74\x93\x69\xea\x18\xbb\xa1\xd9\x02\x52\x60\xa8\xd5\xc1\x0a\xbc\xfc\xdf\xa1\x0b\xe2\xc7\xd4\xec\x64\xa6\x44\x8a\x1e\x0c\x5c\xb4\xe0\xd4\x3c\xfd\x8a\x57\xa5\xca\x33\x27\x36\x30\xa0\x8c\x30\x03\x98\xaf\xdf\xf9\xd9\xd7\x21\xe2\x69\x95\x03\xb0\x06\xea\x8a\x50\x01\xe0\xbf\x26\x76\x16\x6d\xda\xb4\x6c\x9f\x27\x31\x98\x81\xf8\xf7\x9c\xa4\xba\x45\x4c\xa9\x4c\x93\x32\x2e\x20\xe5\xa5\xb2\xbc\x8e\x48\x0c\xcc\x4e\x2f\x1a\x97\x16\x4b\x4e\xad\x6c\xbe\x88\x5e\x5b\xdb\xda\x42\xcf\x1c\x87\xf7\x0c\xa8\xf7\xef\xa2\x92\xbf\xd7\xd7\xc4\x4f\xc5\x5d\x82\xcd\x55\x4f\x53\xc5\x03\x43\xca\x8b\x8a\x03\x7a\x57\xb9\x54\x52\x33\x55\x34\x25\xaf\x0f\x40\x3d\x14\x25\x34\xa6\x1a\x82\xc2\x29\xea\x67\x4c\x15\x69\xb4\xce\x28\x2d\x63\x27\x85\x68\x43\x4f\x2d\x74\x72\x53\xaa\xa7\x82\xf7\x2a\x6a\x26\xfd\x87\x4c\x73\xbb\xc8\xee\x0e\xef\x22\xd4\x4e\x29\x4a\xb8\xd7\x92\x6b\x90\x67\x82\x70\xee\x22\xb5\x69\xea\x4b\x3e\xe3\x88\x2e\x3e\xe8\x04\x1b\xdc\xf8\x0a\x0c\x3b\x78\x89\x20\x61\x3c\x05\x9c\xe8\x08\x56\x28\xac\xc7\xfd\x2e\x7a\xd6\x93\x27\x70\x3d\xed\xc9\x13\xf4\x3a\xf0\x37\x79\x77\x54\xa6\x69\x3b\x20\xa1\xcd\x86\x4f\x61\x33\xa3\x33\x02\x70\xab\x60\x2c\x1d\x9f\xa1\x68\x4c\xec\xf9\x8d\x24\x46\xad\xfe\x81\x4c\x23\x30\x91\xfa\x41\x88\x46\x74\x08\x70\x48\x8c\x5d\x2f\x32\x59\x3c\xcc\xc4\x69\xd4\x9b\xdc\xc4\x49\x59\x40\xd2\xe2\x61\x73\xae\x69\x91\xc0\x2b\x78\xae\x0d\x3d\x7f\x4e\x48\x38\x4d\x19\x32\x7c\x34\x11\x66\x0c\x95\xad\x14\xb4\x2e\x55\x93\xc1\x22\x07\x96\x1f\x83\x80\xed\x65\x3f\x11\x1d\x17\xc3\x46\xa5\x12\x00\xa7\x41\x10\x70\xc7\x73\xff\x18\x04\x6a\xc7\x84\x7d\x44\x69\x2a\x50\x81\x55\x7d\x72\x43\x53\xa9\xb6\xc2\x05\xb3\x48\x7a\x95\x4b\x54\x75\x63\x12\xf2\x35\x29\x5d\x9e\x21\x37\x02\x17\x01\x83\x09\x0e\xb1\x1f\x13\xe2\xd4\x74\x72\x95\xa1\x5b\xd1\x69\x35\x28\xad\x66\xe5\x52\x1f\x26\x21\x31\xb7\xa2\x54\xcb\x43\xd1\x5e\x19\xfd\x54\xef\x2a\x32\xbc\x2b\x3b\x45\x55\xda\x63\x26\x03\x84\x96\x65\xe8\xc1\x85\x40\x7b\x73\x6c\x0f\x3c\x13\x77\x19\x72\xfb\xf0\xde\x02\xdb\x03\xe8\x17\xba\xe0\xa4\xaa\xdc\xcb\xb5\x4d\xa4\xf1\xc1\xaa\x0f\xa8\xc9\x89\x43\x06\xd9\xee\x2a\x41\x3a\x6b\x0d\x89\xfd\x41\x74\x41\x28\x81\x76\xf5\xb1\x74\x4c\x22\xa9\xea\x6e\x6f\xd0\xa1\x5a\x4c\xca\x27\x0e\x2f\x42\x9a\x51\x6c\xa2\x34\x70\x2a\x14\xfe\x24\x3a\x56\x3d\xcc\xa8\x94\x4d\x49\x94\xe1\x8a\x72\x1f\xd1\x55\x80\x58\x8c\xbb\x11\xf2\xdc\x0f\xc4\x9b\xd2\x21\xec\x77\x79\xb3\x44\xac\xcc\x4b\xaf\x77\x92\xc1\x60\xde\xf5\x0e\x65\xa9\xfc\xea\x45\xe1\xdb\xc8\xb0\x05\x3d\x7a\xd6\x42\xe6\xaa\xee\x26\x9a\x57\x35\x5d\x94\x96\x84\xc1\x71\x4c\xee\xea\x42\x25\x73\xd1\xb4\x50\xcb\x42\xed\x4b\xd3\xfa\x82\x35\xa0\xab\xe9\x7b\xaa\x07\x94\xe1\x03\x3d\xcd\xf4\x1b\xe5\x08\x8a\xef\x24\x68\x23\x82\x71\xa3\xc1\xe4\x93\x89\xaf\x67\x2a\xe0\xdd\x85\x54\x68\x3a\xe8\x77\x8f\x4c\x2a\x65\xce\xc2\x3c\x0c\x64\x86\x10\xa5\xd6\xd9\x91\xa4\x59\x78\x7d\x3a\xb5\x4b\xc0\xba\x21\x8e\xd4\x25\x06\xed\x83\xd7\x38\x74\x83\x49\x84\x7e\x67\xae\x9d\x7f\x47\xe2\x4a\x58\xd2\x77\x5e\x3d\xfb\xed\xea\xec\xd9\x8f\xc7\x57\x27\xaf\xcf\x8f\x7f\x3a\x7e\x8b\x0e\xd1\x7e\xa3\xb1\xdb\xdc\xdf\x6f\x75\xb6\x77\xb7\x1b\xfb\xfb\xcd\x54\x57\x77\x48\x4c\x27\xa6\x89\x1f\xb9\x03\x9f\x38\x88\xce\xa6\x03\xb1\xf4\x4e\x08\x87\xe4\x24\xfa\x85\x1d\x33\x6d\xfd\x6f\xf5\x69\xb7\xf1\xf9\xa2\xb9\xb9\x7f\xf9\xde\x79\x52\xfb\xe7\xd6\x8c\xae\x87\x29\x31\xd7\x61\x43\xf4\x26\xed\x88\xcc\xd0\x5d\x60\xc7\x31\xe9\x46\x3c\x1d\x43\x89\xbd\x43\x17\xcc\xaa\x3d\x4c\x0b\x80\x19\xe6\x93\xf1\x98\x84\xa8\x17\x4c\x7c\x07\xec\x12\xc1\x91\x64\x63\xfe\x6e\xa9\x52\x28\xdc\x95\x73\xa3\x13\x9a\x46\xa8\x91\x6a\x7d\x4b\xe3\x5e\xfc\x90\xb6\x7d\xa6\x1d\xbb\x48\x98\xf8\x52\xeb\x1f\x3d\xe2\xd9\xb8\x0a\x0b\xe7\x40\x72\x6b\xae\xc2\x84\x53\xa1\x6b\x73\xd1\x7e\xf5\x98\x44\x31\xef\x23\x52\xf9\xf9\xc2\xfd\x07\xb4\xd9\xa4\xfd\x86\x7d\x7d\x87\x9a\x48\x1c\x2e\xb3\x10\xb9\x74\x30\xcf\xa1\xbc\xa2\x06\xe5\x2f\xbc\x38\xf7\x15\x94\x7f\x1e\x4d\x65\x55\xce\x1a\xb0\xe7\x43\x37\x12\xd3\x2d\x9d\x5e\x82\x20\xa2\xf3\x0b\x1d\xb7\x1c\xc4\x36\x9f\x2f\x7e\x3f\x0f\x5e\x42\xf6\x05\xb6\xf5\xe2\x80\x0b\xfb\x0b\x6c\xc6\x2d\x3e\x39\x71\x79\x89\x13\x9a\x32\x33\x12\x93\x08\x73\x4f\x92\x33\xdb\xf0\x24\xac\xa5\xeb\xaf\x4e\x5e\x5f\xfd\xfa\xec\xe5\x2f\xc7\xf9\x3b\x5a\x32\xcb\x89\xdf\x77\x7d\x37\x9e\x96\x48\x5a\x69\x57\xcc\x53\x98\xd2\x73\x79\xd2\xec\x8c\x93\xdb\xd5\x78\x8f\x2a\xd9\xa1\x0e\x33\x3a\x9b\xd7\xb5\x5e\x8a\x05\x7e\xba\x6f\x15\x5e\xb5\x34\x6c\x3f\x17\x9f\x27\x4d\x7c\x1c\x4e\x7f\x47\x37\x6e\x3c\x0c\x26\xb1\x38\x4f\x82\x0e\x18\xc5\x41\xe8\xfa\x03\xaa\xf3\x18\xde\x1e\x14\x8c\xde\xc9\x71\x0b\x65\x29\x7b\xcc\x82\xc7\xc9\x94\x4f\x89\xa7\x94\x2f\xc9\xae\xae\x88\xe8\x32\xc4\xc6\xe3\x31\xb5\x79\x79\x02\xc3\x01\xc8\x2f\xb4\x06\x20\x09\xad\xc1\x4c\xd6\x83\x16\xc9\x23\xf8\x09\x76\xde\x31\x00\x50\x37\xb4\x42\xe1\x01\x76\xa9\x85\x02\x5f\xd5\xe4\xad\xc7\x93\xf5\xc1\x99\xf0\xb2\x61\x5e\x48\xd4\x52\xf3\xfb\x08\xc7\xf6\x30\xbd\x34\xa7\xed\xeb\xfa\x49\xe8\x18\xc7\x43\x7d\xae\x7f\x41\xc8\x98\x5a\x4e\x74\xbe\x7f\x5f\xff\xfc\xfe\xa2\xfa\xb4\x7b\xf1\xbf\x17\xef\x2f\x2f\x9f\x7c\xae\x5e\xac\x57\x2e\x6b\xd5\xa7\xdd\xea\xd3\x47\xef\x9b\xb5\x8b\xff\x7d\xff\xfe\xf2\xf3\xfb\xf7\xf5\xda\x93\xa7\xef\x9b\xb5\xf7\x97\x5b\x7c\x53\x95\x9c\x44\x6f\x3c\xec\xfa\x82\xce\xff\xbe\xbf\x79\x52\xc2\x58\xd0\x78\x85\x73\x34\xba\x9c\xc4\x3a\xb7\xab\xb0\x1d\xe4\x59\x1e\x33\xaa\x2f\x4d\x0b\x75\x58\x19\x22\xa6\x69\x0b\x0c\x8f\x5a\x5d\x66\x98\x09\xff\x21\x53\xb9\xdd\xae\xac\x7a\xdd\x3e\xaa\x72\xe5\x90\xf3\xb6\xae\xbd\xe0\x61\x93\x1f\x87\xd1\xf6\xe3\x77\x06\xd5\x31\xea\x40\x5c\x2e\x65\x2e\xac\x34\xd3\x40\x86\x09\xb7\x5e\x6a\x18\xaf\x28\x0d\x94\xf7\xb8\x52\x27\x7f\x42\x25\xcd\xdc\xa9\x07\x87\x3c\x48\x53\x0c\xd5\x20\xa1\xd4\x1e\xa9\xda\x97\x8a\x64\xc6\x0a\x6f\x21\xe5\x11\x02\x63\xc9\x95\x17\x1c\xb8\xf8\x72\xed\x94\xff\x10\x53\x1f\x2e\xbc\x0b\xb0\xdc\x25\x94\xd4\x05\x23\x7e\xcf\x63\x40\xe2\xb3\x78\xea\x11\xe6\x2a\x28\xf5\x02\xf7\xbe\x50\x10\xa1\x50\x5a\xde\x99\xfb\x91\x64\x5e\xbd\xde\x17\xca\xde\x80\xc4\x0c\x5e\x61\xe5\x25\xe6\x61\xf1\x4b\x3f\x41\x47\x43\x1c\xc6\x47\x41\x00\x17\x9f\xe2\x6c\x95\xe7\xb8\xd7\xf3\xe0\xb7\xb8\xb4\xdf\xe2\xc4\xaf\x69\x1c\x1c\x05\x7e\x34\x19\xd1\x05\x35\x1b\xc5\x70\x28\xbd\xca\x42\x40\x5d\x0c\x6f\x34\x22\xeb\xa8\xd8\xa2\xe6\x78\x0b\x1d\x22\x99\xa8\x2e\xd6\x21\x5c\x4a\x61\x5a\x3e\x34\xc3\x85\x7b\x09\xc2\x09\x41\x2c\x77\xc9\x56\x43\xd8\xa2\x9f\x30\x14\x4b\x6d\x61\x7c\xf4\xc3\x60\x04\x4c\x70\x77\xb4\x6c\x66\x66\x4e\x5d\x60\x93\x9f\xdf\xc4\xbe\x71\x9d\x78\x08\x01\x5d\xf4\x09\xae\xc9\xc2\x31\xcf\x51\x30\xf1\xe3\x2e\x6a\x08\x37\x8c\xd4\xb6\x3b\x7a\x76\xf4\xf3\xf1\xd5\xeb\x5f\x5e\xa1\x43\xd4\x6a\x34\x1a\x2c\xe6\xec\xcd\xb3\xd7\x57\x67\xe7\xef\x5e\x1e\x73\x8a\xe3\x20\x72\xa9\xb8\xba\xa8\x82\x7b\x51\xe0\x4d\x62\xe6\x70\x24\x0e\xc6\x5d\x54\xd9\xa4\x39\x1b\xe3\x5b\x08\xf2\x48\x9f\x16\x02\x97\x73\xb1\x43\xfb\x0c\xff\x1a\xe1\x70\xe0\xfa\xfc\xa3\x07\x7b\xb1\x5d\x54\xf1\x03\x9f\x91\xba\x19\xba\x31\x39\x1b\x63\x9b\x74\x51\x65\x1c\x92\x8a\x60\x13\xf8\xb8\x7a\x79\x72\x76\x8e\x0e\xd1\x45\x65\xe4\xfa\xff\xa5\xf5\xab\x58\xa8\x32\xc2\xb7\xf2\xf7\x8d\x0c\x74\xfd\x9f\x89\x3b\x18\xc6\x3c\x45\xf2\x31\x94\xbf\xe2\x60\x4c\xff\x50\x5e\xe9\xdf\x7e\xe0\xc7\x74\xbc\x81\x30\xd7\x27\x49\x16\x5e\x05\x46\x8a\xf2\xaf\x04\xbe\xe4\xb9\xf9\xe7\xdb\x54\x9e\x73\x56\x06\xff\x7a\x1e\xc4\x71\x30\x4a\xe8\x88\xcc\xec\xeb\x6d\xc2\x2f\xfd\xe4\x59\xd9\x07\xcf\x79\xc9\x1b\xed\xf8\xd9\xd9\x2f\x6f\x8f\x5f\x1d\xbf\x3e\xbf\x82\x66\x3a\x79\x81\x0e\x91\xf4\xd1\x74\x35\x22\x38\x9a\x84\x60\x38\x5f\x45\x63\xec\x57\x54\x65\xc7\x13\xaa\xed\xd4\xb0\x8e\x09\x0c\xed\x55\x36\xef\x2b\x46\x27\xd5\xfa\x44\xe2\x75\xd8\x3f\x38\xed\x43\xba\x1a\xfa\x41\x5b\x1e\x80\x7b\x2e\x93\xbd\xca\xa2\x37\x50\x65\x7c\x5b\x91\x37\x37\xd5\x38\xfd\x95\x82\x8d\x47\xc4\x3b\x0f\x5e\xb9\x8e\xe3\x91\x97\xae\x4f\xaa\xc9\xad\x53\xae\xe0\xe0\x69\x8e\xdc\xc6\xf5\x68\xec\xb9\x71\xb5\x52\x61\x4f\x75\x69\x6c\x3f\x08\x47\x98\xce\x19\x70\xb7\x30\x0e\xa3\x7a\x48\x9c\x89\x4d\x92\xdb\xae\xd5\x90\x44\x13\x2f\xe6\x07\x83\x82\x57\x5a\x51\x7e\xb0\x78\xc8\x8e\x16\xa7\xba\x77\xd0\xe4\x82\x35\x67\xfd\xe2\xb2\x6e\x07\xbe\x8d\xe3\xaa\x61\xd0\x60\x65\xd4\x2c\x74\x51\xd9\xac\x58\x92\xde\xcb\xe0\x46\xd0\xbb\xd4\xaf\x74\xcf\x47\x14\xe8\xf1\x13\x4d\x0b\x5d\xe8\xbe\xae\x12\x11\xd4\xff\x08\x5c\x9f\x89\xe7\x2e\x71\xa7\xaa\x4c\xe2\x29\x67\xaa\x49\x4c\x35\xa2\xbf\xb5\x35\xc9\x69\x72\x28\xc5\x63\xf3\x45\x1b\xa5\x54\xa0\x52\x41\x1b\x88\x45\xa2\x0d\x43\x0b\x47\x35\xaa\x1f\x5d\x9a\x2a\xab\x94\xe0\xcf\x7c\xea\x91\x8b\xe8\x12\x92\x1d\x54\x78\xbd\x2b\x62\x77\x53\xd6\x4c\x58\x0a\x99\x8a\x89\x88\x8c\x2e\x4d\x3d\x6d\x52\x12\xaf\x37\x7f\x40\xb0\x14\x4e\x26\xab\xe6\x25\x5c\x0b\x99\xf8\xe2\x91\xec\x53\x3d\x92\x0e\xad\xc9\x2b\x34\xf6\x3c\x5d\x4d\x4e\xad\x54\x11\x2a\x4c\xd1\x32\x17\x5c\x75\xb7\x60\x3e\x5c\x73\x75\xa3\xb3\x28\x14\x8f\xd4\x75\x41\x7f\x62\xa3\x3d\x1d\x56\x11\x1b\xdf\xba\xa8\x01\x57\x7e\x98\xa2\xf1\x0e\x44\xc7\x08\x70\x88\xcb\xdf\xf7\x48\x59\x48\xbd\x30\xaa\x83\x48\x0a\xf3\xc7\x7f\xc8\x94\x75\x31\xda\x26\x9b\x94\x9a\x42\x41\x8a\x42\x99\x8e\xea\xc9\x44\x74\x21\x28\x5c\xa6\xdd\xd2\xce\x48\x9e\x3c\x8c\x0a\xa7\xca\x95\x00\x65\x98\x3b\x1b\x63\xc0\x1b\x08\x6c\x68\x9c\xfa\x80\xc4\xdc\xcf\xdf\xf3\xe9\x89\x53\x35\x0c\x98\xbc\x23\xc2\x2b\xfe\x14\xa1\xa4\xd3\x17\x94\x90\x72\x26\x08\xc3\xac\x7c\x82\x9f\xca\x57\x8f\x48\xe2\xa8\xaf\x5a\x71\x9d\x8a\x65\x1a\xc3\x65\x76\x59\x48\x2f\x70\xa6\x75\x3c\x1e\x13\xdf\x39\x1a\xba\x9e\x53\x4d\x73\xaa\x8d\x26\xc5\xa5\x42\x3b\x55\xac\x74\x1b\x6b\x0e\xeb\x92\x39\x9f\xf7\xbe\x9a\x78\x83\x92\xa6\x4d\x75\xe8\x28\xf0\x63\x02\xdb\xed\x51\x2c\xa0\x1a\xd8\xda\x1c\xae\xa5\xa5\xb3\x0c\x48\xfc\x3c\x98\x80\x05\x7d\xe4\xb9\xc4\x8f\xdf\xd2\x7e\xc0\xe9\xb3\x7c\x30\x54\x1c\x26\xfa\x4c\x29\x31\x8d\x48\x14\x1b\xc2\xd8\x07\xbf\xc7\x8f\x66\x2a\x10\x3a\xe4\xc4\x95\x07\x40\x1b\x1b\x6a\xae\xc4\x38\x42\x3f\xe8\x46\x51\xa2\x0d\x39\xe9\xf9\xbb\xad\x7c\x3e\x68\x8d\xee\x4c\xe3\xbe\xe0\x09\xa1\x3b\x64\xc3\x1e\x48\x35\x3d\x8d\x16\x76\x6d\x65\x14\x64\x2b\x97\xd4\x08\xc8\x02\xab\xc4\x4b\xc6\xbe\x61\x3c\xf2\xd0\x21\x22\x5e\x3d\xb8\xf1\x49\xf8\x42\x68\x9a\x50\x39\xae\xd0\xa2\xcf\xf7\x82\x5b\x68\x0f\xb0\xf1\x1a\x96\x30\xec\xb8\xe0\xb7\xb6\xd0\x49\x1f\xdd\x10\xe4\x04\x7e\x25\x46\x43\x7c\x4d\xd0\xe0\xf9\xd1\x5b\x0b\xfd\x31\x89\x62\x44\x57\x98\x0d\xab\x81\x42\x0c\x17\xec\xe2\x21\xf6\x11\x09\xc3\x20\x64\x59\x9f\x7b\xd8\xfe\xf0\x9c\x84\xe1\x14\x75\x2c\xe4\x9e\x9e\xa1\x36\xaa\x06\xa1\x3b\x80\xc7\x1f\xee\x9b\x61\xe0\x93\x9a\xb2\x27\x10\xf4\x29\xdb\x46\x2d\x82\x51\xba\x22\xc7\x5d\xe9\xf6\x9a\xb1\x9f\x97\xab\x5a\x4b\x1b\x26\xfc\x09\x21\xad\x6c\x2f\xb8\xad\xc7\xc1\x18\x6d\xa0\x1b\xd7\x77\x82\x9b\xfa\x18\x0f\xc8\x3b\x2e\xe6\x4d\x90\x63\xdd\x06\x52\xe7\xc1\x98\x6d\x26\x31\xe1\xd0\x8c\xf4\x97\x9e\xf3\x37\x53\x4e\x6a\xff\xf1\xbd\x3c\x65\xc7\x49\x3a\xf0\xb5\xe5\x82\x90\xbb\xf0\x8d\x82\x90\x2e\x97\xc0\xca\x53\x36\x89\x92\x5d\x22\x72\x4d\xfb\x23\x02\xcf\xa0\x7c\x83\xc6\x98\x8e\x41\xa6\xb1\xbd\x24\xf6\x33\xe8\xa3\x11\x76\x7d\xb8\x94\x4f\xcb\x88\x87\x04\x45\xd7\x03\x44\x98\x3e\xac\xa9\x6e\x83\x05\x15\xfe\xdf\x27\xe0\xe7\x37\x8b\xf1\xf5\xee\x4e\x9e\xb1\xe6\x2d\x6f\x8d\x3e\xce\x53\x69\xaa\x50\x15\x8b\xb3\xa7\x99\x24\xdc\x53\x39\x14\xda\x65\xef\xe9\x42\xda\xb6\x2c\x0b\x93\x36\xda\xe4\x39\xa1\x29\xf8\xbe\x24\xe3\x2f\x27\xcb\xbb\x24\x4b\x1c\x8c\x6b\x5a\xb3\xa8\x3b\x30\x85\x57\xa9\xbf\x34\xc6\xd4\x15\xdb\x22\x2b\x78\xc7\xb3\xbd\xa2\x77\x3c\xec\xa8\xd5\x42\x63\xbe\x50\x08\xfa\xa9\x5b\xf9\x41\x3f\x81\xe6\x91\x01\xe5\x98\x37\x3c\xe4\x11\x7b\x81\x8f\xaa\x74\xd2\xe5\xe7\xbc\x7c\x45\x2d\x60\x68\x44\x9a\xea\x18\x1d\xa2\x8d\x71\x0d\x7d\x4f\x57\x26\x9f\x3f\x23\x1f\x7d\x8f\x5a\x12\xac\x66\x83\x73\xc3\xab\x00\xb7\x03\x1b\xbc\x16\x51\x4d\x10\x19\xd3\x75\x4d\x33\x37\x93\x8f\x36\x51\xf3\xd2\x42\xf0\x57\xcb\x4c\x9b\xc8\x17\x37\x21\x5d\x2a\x33\x48\x53\x43\x4f\xd0\x58\x06\x37\xc4\xc3\xcf\xbe\x17\x04\x61\xd5\x95\x18\x4e\x40\x88\xc6\xa6\x0b\x74\x29\x9b\x6e\xc2\xa7\x96\xa1\x69\xcc\x80\x36\x80\x45\xf6\x43\xe3\x51\x5d\x76\xd1\xd8\x2a\xa7\xb2\xc9\x83\x28\xb3\x55\x17\x6d\x22\xb7\x51\x33\xe3\x8a\x34\x0b\x2f\x3a\xaf\xf6\xf5\xdb\xaa\xf7\xf5\xc6\x21\xe9\xbb\xb7\x6c\x4f\x8d\xdd\xdd\xa1\xdf\xe8\x10\xad\xff\x73\x5d\x5d\x18\xbf\xc2\x63\x9a\xed\x6e\x6d\xed\x15\x1e\x6b\x2f\xdb\x47\xa9\x6f\x70\xc2\x9b\xdc\xb9\xa5\x23\x0a\xb4\xf5\x10\x47\xca\x1d\x90\x0f\x64\x9a\x9a\xcc\xab\xbc\xe8\x0d\xd8\xb6\x62\xc3\xac\x1b\xc9\x77\xcc\x03\x12\x17\x66\xa7\x89\x2f\x54\x12\x97\x32\x6b\x94\xce\xaa\xad\xe7\x91\x21\xab\xe8\x56\x07\xe9\x12\x24\xcd\x90\x8c\x82\x6b\x62\xe6\x48\xbd\x03\x85\x0e\x91\x4a\x59\x23\x28\xd3\xf0\xba\x32\xa4\x2c\xb8\xa4\xcd\x59\x62\xf1\x49\x4d\xe0\xd6\xad\xe1\xdd\xbb\xdc\x6f\x4b\x93\x64\xcf\xeb\x44\xe8\x45\xe3\x12\x56\x5b\x8c\xa3\xda\x8c\xc2\xe8\xb2\xd6\x50\x16\xdf\x9a\x8c\xd0\x21\xba\xe0\x57\x8c\x17\x2c\x9e\x52\xa9\x8f\x27\xd1\x50\xa6\xa8\x47\x9e\x6b\x93\x6a\x53\x18\xd6\x5c\x50\xec\x72\x1f\x67\x8b\x75\xdd\x1c\xc6\xf8\x55\xd4\xa5\x59\xe3\x83\x2a\x30\xa7\x8b\x47\xe7\x8c\xa5\x93\xbc\xf1\xfb\xd7\x39\xcc\xc9\x1b\xe0\xcb\x72\x27\x2e\x8d\x03\x7b\x9f\xc0\xfb\x7d\x46\x82\x96\x70\x81\xaf\xb3\x7f\xa7\xf3\xcf\x29\x25\x5d\x05\xfc\x23\x1b\xb9\xe7\xde\xea\x1b\x4b\x71\xbe\xb1\xc1\xbc\xdc\xab\xeb\x5b\x1e\xc0\x04\x38\x1a\xc7\xd3\xd5\x29\x78\xfa\x80\x2d\x7b\xa8\x05\x85\x62\x7b\xa8\x94\xd9\x5f\xb2\xd0\x7e\x4a\x63\x2c\x53\xe3\x00\x99\x64\xa1\x22\xc7\xd9\x11\x1e\xcb\x67\x45\xfd\x64\x65\x32\x82\x97\x27\x3e\xb9\xe1\x6f\x4a\x60\x8d\x70\x14\x8c\xa7\xea\x50\x5b\xe7\xd3\x35\x3f\x5f\x73\xe1\x7a\x8d\x4d\x6d\x8d\x57\x78\x5c\x13\x57\x25\x69\x6d\x53\xa6\x0b\x3b\x29\x40\x9f\x60\x2c\xa7\x8b\x22\x65\x8c\x64\x53\x03\x5f\xcf\xc0\x03\x04\x76\xb1\xb9\x37\x45\x70\xcd\xce\xb5\xf9\xa3\x87\x20\x84\xab\xdd\xec\xf9\xcc\x07\x32\x55\xcf\xf8\xd9\x66\x7d\xf6\xbc\x40\x9c\xf3\xa9\x20\x89\xda\xeb\x09\x86\x10\xc4\x39\x4f\x63\x25\x06\xca\x82\x55\x31\xb0\xd2\x0f\x8c\x45\xa5\x5c\x71\x2c\x7b\xe1\x8a\x5e\x0c\x6c\xe5\xa5\xef\x57\x03\x59\xb6\x00\x2c\xe4\x0c\x5b\x28\x48\x96\x47\xd0\x12\xfe\x35\x09\x63\xe5\xec\x99\x12\x51\xeb\x2d\x0e\x84\xd3\xa7\x3b\x22\x5c\x93\x3c\x2f\x93\xce\x44\xda\x36\xe6\x88\xb6\xfd\xdd\x12\x16\xeb\x08\x8f\x4d\xf6\x4b\xe1\x8b\xa4\xaf\x00\x0d\x6b\x07\x5e\x90\x6f\xb7\x77\x16\xc4\x6f\x6d\x5e\x5d\x85\x83\x5e\xbe\xdf\xa9\xdd\xf6\xc2\xb8\xb0\xd0\x25\x0a\x28\x2f\xc8\x71\xfb\xea\xca\xc1\x05\xa8\xeb\xed\xdd\x05\x61\x72\xb7\x67\x2f\x8e\xb6\x17\x24\xdd\xb9\xba\x62\xea\x5b\xc0\xf5\x82\x70\x6b\x3b\x57\x57\x6c\x0f\xa9\x80\xf4\xfe\x62\xa4\x77\x4b\xe0\x06\xb7\x77\x3b\x02\x7d\x77\x35\x08\xbc\x1c\x78\x41\x5c\xfa\x48\x6e\x7c\xf4\x2c\x64\x2b\x4b\x93\x9e\x7a\x59\x83\xed\x97\xaf\xf3\x6b\x1d\xeb\xe8\xe9\xec\x3d\xf3\xdd\x99\xd8\x93\xbd\x1a\x1f\x54\xbb\xa8\xca\x0b\x60\xfa\x01\xf8\x96\x65\xd4\xc8\x40\x56\x92\xe4\x14\x59\xdb\x51\x8a\xd5\xaa\x5d\x1a\x8b\x96\x8f\x05\x82\x3e\x7c\x0a\xa6\x6b\x94\x56\x0f\x1d\x22\xdb\x2a\xd1\xef\x4d\x35\x47\xdd\x72\xfa\x66\xca\x2b\xeb\xd7\x53\xa7\xda\x05\xab\x53\x28\xe7\x82\x1a\x98\x99\x78\x81\x63\x52\x48\x51\x8e\x2c\x45\x24\xf5\xb9\xba\x57\x2b\xa4\x98\x8c\x82\x85\xaa\xc0\x15\xbc\x0e\xc6\xc5\x69\x1f\xf6\x26\x15\x34\xd5\xc7\x8f\x93\x24\x71\xc0\x8f\x5e\x52\x69\xe0\xc6\xd2\x6b\xfc\x7a\x16\x47\xca\x48\x54\xc4\xd2\xa2\xea\x5d\x63\xfd\x37\x67\x4b\xa0\xf0\xe9\xe0\x57\x02\xd0\x3c\xa2\xca\xb6\xd2\x5d\x85\x3c\xdf\xa4\x0e\x0e\x3f\x90\x70\xe5\x57\x85\xf2\xae\x44\xf5\x42\x77\x30\x8c\x0b\x0a\x2c\x21\x22\x02\x22\xb2\x73\x45\x54\x82\xc4\x10\x48\x84\x83\x1e\x37\x07\x17\xa5\x33\x10\x74\x96\xc3\x3f\x7a\xcb\x09\x98\xef\xae\x0d\x23\x4f\x58\xad\xe6\x7b\x6b\x25\xca\xe9\x43\x39\xc3\xc8\x5b\x74\x87\x96\x1d\x49\xe4\xe3\xdd\x37\xe1\xed\xbe\x02\xd7\x48\x9b\x87\xef\x43\x51\xe2\x4c\xcf\xe8\xaa\xb4\xbe\xcb\xf6\xaf\x84\x2a\x00\x20\xde\x96\x50\xc4\x35\x71\x2d\x16\x1d\xa2\xf5\xf7\xef\xa3\x27\xd5\x8b\x8d\xcd\xcb\xa7\xef\xdf\x3b\x1b\x35\xfa\xb9\x2e\x2e\xbc\xbe\xce\x24\x78\xf2\xfe\x7d\x1d\x12\x56\x9f\x76\x2f\xc8\xf1\x65\x92\xf1\xa9\x9e\xf5\xcd\x5c\x59\xbf\xd3\xf2\xfe\x4c\x6e\xdb\x70\xc1\xf6\x1f\xd5\x8b\xc6\xe6\x3e\xde\xec\x5f\x7e\x6a\xdf\xd5\xfe\xb9\xa5\x24\xd8\x49\x27\xd8\x51\x13\xbc\x1d\xf4\x4e\xf8\xc3\x1f\xb6\x4e\x7c\x4b\x06\xc7\xb7\xe3\xea\xfa\xff\x86\x83\xde\xfb\xf7\xd5\x75\xb4\x81\x2e\x42\x72\x62\x21\xf1\xcf\x25\xda\xa0\xfc\xd6\xfe\xb9\x5e\x53\x88\xbc\x21\xa1\xcd\x8e\x2d\xf3\x89\xbc\xa1\xf9\xd9\x3f\x66\x22\x38\x9f\x15\x6c\xe4\x85\xfe\xf3\x3a\x87\x56\x3e\x47\xd8\xc8\x52\x1e\xad\x9f\x23\x2f\x87\xd4\x30\xf2\x12\x4a\xaf\x0b\x2b\xf7\x73\xe4\xe5\x31\x34\x8c\x3c\x6c\x24\x93\x66\x88\x6b\xa3\x8f\x47\x00\x2c\x0e\xc8\xa0\x9e\x6b\x93\x1e\x6c\xd7\x34\x6e\xfb\x8d\xfe\x5e\xbf\x0f\xe8\x9f\x7e\xec\xfe\x39\x21\x70\xf1\x0b\x62\x30\xe9\x39\xbb\x10\xf3\xe7\x04\xd3\x90\x46\xa3\xdf\xe7\x69\xff\x9c\xe0\x11\x0e\x5d\x1f\x52\xee\xf6\xfb\x7d\x67\x1b\xc2\x3f\x4e\x42\x41\x96\x27\xed\x11\x77\xc0\x82\x3a\xfd\x8e\x63\x43\x90\x1b\xfd\xc9\x4b\xef\x93\x6d\x1b\x72\xf6\x3c\x6c\x7f\x60\x85\xd0\xff\x78\x90\x6f\x0f\x89\x83\xbd\x51\xe0\x3b\x3c\x79\xcf\x76\x58\x1c\x23\x40\xd3\xf2\x72\xbc\x09\xb9\x76\x03\x8f\xc4\x34\x7c\x0f\xb7\x7a\x04\xb0\x8a\x7b\x61\x70\xe3\xd3\x20\xdc\x69\x61\x06\x4e\xdb\x9b\x84\xde\xf4\x26\x08\x80\xa6\x43\x7a\x7b\x7b\xbb\xec\x56\x9e\x43\x62\x41\xb8\xd3\xdf\x27\x18\xd8\x80\xb3\xaa\x90\x4c\x22\x59\xd7\x06\x0f\x0f\xec\xc0\xc3\x4c\x58\x4e\x6b\x67\xbf\x09\x4e\x13\xec\x20\xc4\x1e\x63\x76\xb7\xdf\x69\xf0\x20\xbf\xef\x05\x37\x24\x14\xd4\x77\xb6\xf7\x3b\xc4\x11\x71\x91\xeb\x7d\x60\x39\xfa\x7b\x4c\x42\x76\xe8\x8e\xa2\x00\xd8\x76\xec\xe6\x76\x9b\x05\x4e\xb1\xaf\x37\x03\x1d\x70\x54\x49\xec\xf5\x44\x68\x92\x76\xaf\x97\x84\x0e\x02\xcf\x21\x7e\xc8\x2a\xde\xdb\xdb\xdb\x69\x24\x51\x21\x9e\x82\x94\xf6\xe9\xff\x92\x50\x42\x38\x9d\x9d\x6d\x56\x6d\x1e\x6c\x48\xfc\x61\x88\x3f\xb8\x40\xd9\xe9\xed\xee\x48\xca\x23\x3c\x20\x7e\x0c\x0a\xb4\xd7\x53\x79\x0c\x3c\xf7\x9a\xc8\x12\x3a\x9d\x9d\x5e\x4b\xd6\x2a\x08\xb1\xcf\xd5\xa6\xbf\x67\x27\x25\x07\xa1\x3d\x74\x81\xfd\xfd\xfd\x76\xcb\xb6\x45\x78\x48\x1c\x51\x40\x92\x38\x02\xcd\xa1\xe1\x64\x7f\x7f\x67\x17\xcb\x70\x82\x65\xb1\x7b\xfd\x9e\xbd\x27\x8b\x8d\x68\x7b\x0a\x89\x6e\xef\xb5\x9d\x84\x5b\x88\x12\x52\x6a\xf5\xb7\xfb\xdb\xfd\x54\x14\x31\x44\xc5\x93\xf0\xcf\x49\xe0\x46\xbc\x89\x6c\xe2\x34\x45\x54\xa2\xac\xfb\xdb\x8d\x86\xd3\x86\x70\x42\xc6\x63\xd7\xe7\xda\xd0\xdc\xde\x97\xa1\xd1\x87\x69\xd2\xd2\x3d\xd1\xfe\xee\x48\x70\xb4\xb3\x4f\xff\x27\x03\x49\x3a\x30\x70\x06\x89\xfa\x35\xc9\x3e\xef\x35\x7d\x37\x24\xbd\xd0\x65\x5d\xaf\xd7\xa2\xff\x41\xb0\x47\xb5\x38\x19\x0a\xfa\x7d\xdc\x07\xb1\xf6\x83\x90\x44\xb1\x94\x5e\xab\xb5\xd7\xe3\x39\x26\xf6\x30\x72\x31\x4b\x2d\xfa\xe4\x00\xbb\x7e\xd4\x0b\xc2\x80\x29\x32\xfd\x1f\x04\x0f\x83\x28\x4e\x88\xef\x89\x11\x88\xaa\x27\x23\xe0\xec\xb2\x56\xd4\x14\xd6\xc1\xb8\xd3\x62\xc1\xbc\xd2\x7b\x0d\xfa\x3f\x16\x22\x15\x75\x8f\x6b\x00\x04\x4d\x89\xe7\x05\x37\xa0\xab\x4e\xbf\xcf\xf4\x4b\x48\x27\xc9\x3d\x0c\x7c\x32\x75\xc8\x8d\x1c\xb9\x78\x68\x9c\xb4\xc5\xce\x7e\x0f\xc6\x29\x6a\x4c\x62\x9f\xab\x9b\xed\x74\xec\x8e\x2d\x82\x07\x50\xcd\x6d\xaa\xe3\x20\x12\xf7\x3a\x08\xa7\x5c\x7c\x9c\xa4\xec\x22\xfd\x06\xd9\xd9\x83\x9c\x1e\xbe\x26\x3e\x5c\xbe\x6d\xdc\x92\x1d\xb2\xd3\xc7\x6a\x68\xcf\x9b\x44\x43\x4e\xa3\xd1\xef\xb0\xa8\x1b\x5f\x56\x77\xd7\xee\xf3\xde\xe1\x91\x51\xe0\xdb\x43\xb7\xdf\x67\x2a\x4f\xdb\x8c\x8d\x95\x1e\x35\x52\x44\xd3\x63\xc7\xd9\x23\x3b\x32\x38\x19\xad\xa4\x30\x58\x38\x1f\x3f\x88\x1c\x6b\x20\x58\xb6\x47\x22\xd7\x3e\xee\x63\xa7\x95\xa4\xe0\x4d\xe3\xb4\xe9\xff\x94\x60\xce\xf0\x7e\x83\x90\xfd\x86\x1a\x6e\x4a\x9e\xc8\xbd\xb7\x63\x37\x65\x70\xd2\xa1\xfb\x7d\xdc\x60\x1d\x9a\x45\x28\x3d\xba\xd5\xe8\xb5\xb0\x12\x95\x74\x9c\xbd\x5d\x9b\xf4\x95\x18\xb5\x47\xef\xee\xee\xed\xed\xef\xa7\xe3\x88\x31\x2e\x26\xc4\x13\x34\x7b\x0d\x7b\xdb\x21\x32\x4e\x91\x4b\xbf\xdf\x27\xbc\xa2\x23\x22\xc6\xed\x86\x0c\x91\xfc\xb6\x5b\xb6\xd3\xe6\x02\xf4\x59\x10\xed\x6d\xac\x91\x94\xc1\x33\xe9\x56\x23\x1c\x06\x4c\x0c\x7b\x72\xb2\x1c\x11\xc7\x9d\x8c\xf4\x79\x79\x67\xc7\x76\x98\x24\x58\xac\x3a\x55\x30\xd5\x60\xe1\xc9\xa0\xda\xc3\x9d\x0e\x6b\x06\x16\x33\x9e\x84\x63\x0f\xf2\xec\xb7\x77\x1b\x4e\x2f\x89\x51\x25\xde\xb6\x7b\xed\xdd\xa6\x12\xa7\x8e\xa2\xbb\xbd\x9d\x3d\x42\x94\xc8\x31\x5d\x66\x2b\xfd\xb5\x8f\xf7\x15\x1e\xb5\x01\x73\x7b\xcf\x69\xb2\x31\x9e\x45\xb2\x21\x53\x74\xbe\xdd\x66\x67\x0f\x7a\xc4\xc8\x75\x7c\x55\xc7\x9b\xfb\xcd\xfd\x5d\x26\x15\xd7\x8f\xed\x90\xe0\x11\x37\x40\xfa\xac\xf9\x47\x6e\x14\x4f\xc3\x20\x92\x36\x08\x61\xdc\x07\xb6\x8d\x23\xd7\x17\xa1\x3d\xa0\xee\xe3\x6b\xfc\x47\xa0\x8c\x85\x0e\xc1\x0e\x8f\x98\xca\x99\x17\x8a\x0b\x3c\xc7\x83\x1b\xf3\x8d\xdb\xbe\xd3\xef\xb0\x26\x84\x69\x4e\x8c\x37\x8d\x86\x0c\x72\x42\xdc\x83\x56\xea\xed\x91\x16\xc8\x5c\x9d\xf4\x70\x87\x27\x85\x30\x5e\xe5\x7e\x7f\x5b\x06\x8b\x26\x73\xf0\x6e\xc3\x81\x82\xc6\xd8\x23\xda\x80\x49\x08\xd9\x63\xed\x0f\x51\xb2\x0b\xee\xf5\x7b\xfb\x7b\x22\x58\x13\x38\xee\x13\xc2\x1a\x8b\x46\x69\xe2\x76\x7a\xbb\x0d\x36\x1d\x8d\xf1\x18\x4f\xf1\xcd\xd0\x1d\x73\x41\xf5\x1d\x10\xd4\x98\x60\x7b\x38\x9e\xf4\xfb\x5c\x4c\xb8\xb7\xcf\x82\xc3\x09\x1b\x2c\xf7\x3a\x6d\xd0\xdf\xa4\x77\xdb\x0d\x1b\x74\x6a\xec\x4d\xa0\x89\x1c\x07\x37\x1c\x10\xee\x38\xb8\x71\x92\x09\xab\xd7\x20\xbc\x43\x24\x1a\xb9\x27\xc5\x1e\x92\x1e\xb1\x6d\x9c\x44\xed\xec\xb4\xdb\xac\xc3\x4a\xc1\x89\x7e\x12\x06\xd1\x54\x9a\x84\x74\xea\x67\x93\x7f\x18\x4c\xb1\xec\xd3\xdb\xcd\x9d\x7d\xa6\x11\x11\x76\x1c\x8f\xc8\xf4\x7b\xbd\xed\x4e\xb3\xcd\x22\xe4\x48\x84\xf7\x1a\xbb\x2d\x16\xe6\x3b\x09\xed\xfe\x36\xde\xde\x81\x22\xb5\xc1\x89\xec\xf5\x3a\xbb\x3c\x34\x1a\x12\x8f\x9b\x8a\xfd\x0e\x13\x7b\xe4\x12\xdf\x87\xee\x8e\x1b\x9d\x56\xcb\x61\x61\xde\x35\x9b\x1f\xec\x06\xfd\x1f\x84\xe9\xa3\x1a\x01\x29\x6a\xfd\x6e\x07\x77\xf8\xf8\xaf\x8f\x73\x8d\xbd\x06\x1b\x7f\xf5\x21\x2e\x09\xf6\xe5\xf8\x85\x59\x6f\xc9\xf6\xd8\xfe\x2e\x08\x4d\x1b\x08\xb7\x77\xf6\x5a\x6c\x8a\x8c\xd9\xd4\xe1\xb4\x7a\xdb\x6c\x8a\x8b\x09\x9b\x63\x1a\x72\x8e\x89\x87\x6e\x14\xb3\xb6\x72\xf6\x7a\x7d\x07\xb4\x31\x0e\x46\x38\x0e\xf8\x74\xdb\xde\x06\x29\xe9\xc3\x41\x83\x34\x1c\xc8\x9f\xd8\x4e\x84\xec\xb5\x98\xe8\x6e\x86\x04\xc7\xac\x9f\x3b\xa4\xd7\xb6\xc4\x23\x16\x39\x03\xf7\x65\x50\x34\x0a\x3e\xc8\x35\x09\x9b\x55\xf5\x81\x9b\xe9\x0a\x0b\x4b\xfa\x0d\xa6\x03\x35\x9c\xa0\x96\xb9\x39\x2e\xb6\x1b\x8c\xbb\x79\xb0\xb7\x60\xb1\x1d\x20\x0b\x56\x65\x8e\x1b\x8d\x3d\x3c\xc5\x3d\xcf\x74\x26\xae\xdc\x0a\xa9\x87\x83\x5e\xb5\x56\x57\xd2\xf3\xdb\x93\x4c\x86\x6c\x1b\xb3\x0c\x09\x70\x13\xc6\x4f\x85\x35\xbc\x65\xe0\xaa\xca\x9e\x31\x28\xa7\xc2\x07\xcc\xfe\x1b\x61\x80\x2f\xe7\xbf\x28\x8d\x5a\x3d\x0e\xdd\x51\xb5\xa6\x3f\xb0\x50\xce\x14\xaa\x23\xb8\xf6\xfb\x33\xb9\x6d\xd7\xc9\x2d\xb1\x05\x6d\xd8\x52\xa7\x71\x63\x1c\x46\xe4\xc4\x8f\xab\xa3\x8b\xe6\xa5\x85\x9a\x3b\x35\x8b\xad\x77\x07\xbd\x6a\x75\x84\x7e\xf8\x01\xed\xa1\xc7\xb4\x6d\x6a\xe8\x33\x62\x01\xdb\x10\xd0\xe8\x37\x6a\x96\x16\x22\x92\xc0\x6f\x88\x14\x1f\x35\xf4\xfd\xf7\x68\x5b\x8d\xae\x59\xe0\xf8\x60\x6b\x0b\xfd\xa3\xdf\x68\x24\xa7\x12\x92\xdd\x9d\x0c\xbb\xe1\xa0\xe7\x57\xb3\xec\x72\x22\x30\xcc\xa4\xe9\x24\xbb\x25\x19\x6a\xa2\x8e\x8c\xce\xe8\xa2\x05\xff\xb6\x29\x4d\xa0\x48\xdb\xa9\xd5\xe9\xc0\x35\xb9\x46\xcd\x40\x98\x6f\x0f\x14\x12\x46\x4f\x50\xab\xd3\x41\x5b\xa8\xd9\x68\xb0\x42\xd2\x21\xed\x54\x48\x52\x78\xb3\xd1\xf8\xce\x42\xec\xff\xa6\xf2\x71\x5e\xcd\xc2\x41\x0f\x1b\xaa\x35\xba\xd8\xbe\x14\xc4\x71\x52\x35\x5a\xa4\x89\x7a\x5e\xf5\x24\xf5\xf9\xeb\xa6\x72\xa0\x55\xcf\xc4\x43\xb2\x8d\x93\x61\x61\x18\x79\x6a\x05\xb5\x02\x35\x31\x0e\x23\xaf\xda\x6c\x35\x2c\xd4\xa1\x65\x74\x0c\x72\x54\xf6\x79\x16\x29\x46\xd6\x08\xd2\x6a\x45\x69\x75\x82\x3d\xa0\xd4\x13\x4e\xd9\xcb\xb9\x66\x43\x9a\x0b\x16\xa8\x1c\x3a\x89\x6e\x7f\x78\x88\xd6\xe3\x10\xfb\xd1\x18\x87\xc4\x8f\xd7\x15\x4d\x13\x18\xb1\xfc\x1f\x45\x5b\x99\x17\x42\xf5\x89\x19\x2b\x4a\xbb\x4a\x2c\xc8\xf8\xb4\x27\x37\x77\x58\xff\xec\x5b\xc8\x57\x3a\x3f\x7c\x8a\x5f\xcd\x5a\x86\x26\xae\x86\x16\x1a\x58\xa8\x67\x21\x9c\xdc\x89\xc5\x70\x1b\xb5\x86\x42\x74\x88\x06\xe8\x10\x3c\x1c\x71\xa7\x32\xa9\xb2\x95\xdc\x19\xda\x7c\xfb\xba\x1a\x24\x84\x1f\x55\x03\xf5\x18\x0c\x86\xf4\x5a\x0d\x05\x62\x67\xbf\x1a\xc8\x3b\xad\x8f\x82\x5a\xaa\x30\x1a\x03\x37\x3e\xd8\x58\x6c\xe0\x26\xa8\x87\x16\x0a\xea\x03\xfa\x4f\x8f\xfe\x13\x8c\xb1\xcd\xc0\x4a\x52\xbc\x25\x8c\x8b\x24\xaa\x64\x33\x6f\xab\xc0\xdf\x0b\x6b\x70\x51\xab\x50\x38\x88\x78\x6b\xa0\xa6\x00\x0d\x35\x51\x17\x99\xd9\x30\x65\x54\xdc\x1a\x51\xe1\x6f\x84\xd2\x95\x11\x6d\x87\x8d\x81\xfc\xa4\x4d\xb2\xd1\x93\x9f\xb2\x5c\xb4\xc1\x7f\x42\x59\x4b\x4f\xba\x6f\x07\x3d\x8b\xd6\xda\x2a\xf5\xf2\x2b\x21\xc5\x7c\xc9\xb2\xd7\x39\xda\xf4\xfd\x09\xf6\x17\xd9\x19\x80\x7a\x3b\x53\x4c\xb9\x1f\xd0\x21\xfd\xbf\x14\x9f\x3c\x2f\xe8\x26\xce\x67\x44\x98\x85\x3e\xe8\xb7\xe5\x44\x73\x70\xf9\x3d\x41\x1f\x2c\x21\xbc\xe4\x77\x4f\xf9\x9d\x34\x0c\x37\x06\xd8\x79\x44\x19\xc6\xf8\xd1\x86\xc2\x16\x0b\xb9\x07\xa6\xc2\x41\xaf\xd8\x38\x49\xd8\x2f\x63\x11\x55\x1b\xb4\x7b\x73\x76\x84\x63\xa3\x90\x86\xb5\x3a\x9d\x9a\xbc\xbd\xf5\xf8\xb1\x9a\x72\x20\x53\x0e\x66\xa4\xec\xc9\x94\xbd\x19\x29\x85\xd2\x8a\xf4\xe2\xfb\xfb\x43\x18\xaa\x66\xdb\x67\xc2\xdd\x9d\x9a\xfb\x00\x42\xd8\x01\x34\xae\xf1\x0e\x08\x6d\x34\xc2\xb7\xd5\x86\xc5\x7f\xbb\x7e\xb5\x49\x47\x2d\xbd\xad\xaa\x58\x76\xf5\x75\x3a\x4a\xac\xa3\x2e\xfc\xc0\xd5\xf5\xa4\x12\x1b\x66\x72\x30\x33\x2b\xaf\x33\x98\x58\x01\x72\xa3\x51\x03\xcb\xd1\x42\xeb\x0b\x11\x19\xac\x82\x48\x4f\x10\x51\x72\xab\xd5\xad\x41\x5d\x2d\xb4\x8e\x36\x10\xa6\x05\xd5\xd6\xc5\xfd\xc7\x9a\x66\xea\xc2\x94\x39\xb4\x50\x64\x21\xcf\x38\x6b\x0c\xd1\x21\xf8\x1a\xf1\x92\x59\x43\x5e\xb3\xf3\xe4\x3b\x07\x8f\xbf\x59\x10\xa9\xd3\x29\x23\x85\x5a\x76\xee\xf9\x39\xf2\x54\x1e\xf4\x81\x35\x39\x3a\x55\xe7\x1e\x6d\xe6\xf9\x39\xf2\x6a\x69\x7a\x41\x7d\x48\xe7\x8c\x88\xfe\xe3\xe9\xb3\xc7\xb2\xb3\xd7\xcf\x91\x77\x30\x8b\x8d\xc0\x30\xbf\xc1\xa9\x28\x0b\x42\x5b\xb4\x2b\x59\xbc\xf5\x06\x10\x38\xd0\x03\x7b\x10\xd8\xd3\x03\x47\xae\x2f\xde\x6f\x50\xdd\xe0\x13\x8e\x7c\x92\x31\xc2\xb7\x32\x1a\xdf\x66\xa2\xb9\xf4\xc5\x27\x03\x75\xbe\x45\x9b\x94\xac\x08\xf4\xd8\xcd\xc5\x5b\xb4\x41\x43\x6b\xb4\x78\x51\xd9\x48\x7d\xab\x1e\x82\xb2\x8d\xf0\x2d\x6b\xd4\xea\x00\x6d\xa2\x1e\x4d\x1e\x51\x55\x1c\xa0\xef\xe9\xd7\x13\xb4\xa3\x5c\xfd\xa4\xd9\x06\xa9\x6c\x3d\xb4\x89\x42\x91\xad\xa5\x24\x86\xd8\x10\x6d\xa2\x81\x88\xdd\x66\xb1\x11\xda\xa2\xda\xf8\x3d\x6a\xd4\x3b\xe8\x29\x92\xac\xa2\x2e\x38\x36\x91\x15\x62\xa9\x87\xe8\xc9\x21\xda\x61\xde\xec\x38\x88\xc5\x9a\xa8\xbb\x87\x7e\x60\xf8\x01\x94\x5a\x93\x43\x84\x0f\x53\xe8\x3b\x19\xfd\xcc\xb3\x43\x86\x5a\xa2\x79\xec\x10\x45\xc3\x87\xc2\x0e\xf9\xd9\x40\xad\x94\x1d\x62\xca\xa8\xd8\x21\x54\xac\x1b\x43\x69\x69\x44\xe0\x0a\x48\x7e\xd2\xc6\xdf\xf0\xee\xdd\x0e\xf9\x39\xf2\x2c\x5a\xeb\xbf\x8e\x1d\x42\xa5\xca\xe4\xc7\xa7\xf5\xc8\x12\x12\xfb\xf2\xf6\xc7\x62\xcc\x98\xed\x0e\x78\x88\x2b\x26\xdd\x21\xfa\x0e\xb5\x77\xe0\x59\x16\xff\xfe\x1e\xc1\x8b\xac\x36\xdb\xc8\x4b\x86\x0d\x36\x23\x0f\x6b\xc9\xf5\x30\xc6\x48\x8d\xf7\x22\xce\x96\xcc\xe3\x89\x22\xbc\x24\x6c\xd4\x82\x3e\xb8\x01\xf3\x08\xef\xcd\x1e\xea\x82\xef\x22\x8f\x96\xaa\xe4\x1f\x35\xb9\x5b\x56\x8f\x76\xee\x96\xd1\x24\x13\x83\x5c\xe4\xb5\xe8\x90\x3b\xa4\x53\x52\x6b\xbb\x41\x3b\x18\xda\x84\x5f\x5d\x34\x44\x1b\x08\x16\x88\xa3\xa6\x85\x46\xad\x64\x64\x14\x99\xf2\x63\xe8\x18\xd1\x62\xd4\x36\x24\xb5\x4d\x23\x35\xb5\x01\x20\xa8\xb6\xb0\x4d\x17\x49\x7b\x0a\xa6\xd0\x66\x46\xe0\x79\xe6\x98\x27\x33\x7a\xcc\x04\x5b\xd8\x6c\xe3\x26\xc3\xd6\x13\xf4\x63\x18\x8c\xd0\x8f\xd7\x2f\x50\xb3\x5d\x6f\xef\x5a\xe8\xe8\xec\x8c\xcd\x9b\xe8\x15\xdc\xb5\x43\x2f\xc9\x35\xf1\x50\x5b\x43\x6a\xcb\x8a\x56\x1d\x14\x41\xae\x3b\x54\xac\xa3\x26\x55\x85\x11\x8c\xe1\xf0\x66\x71\x88\xb6\xd0\x4e\xb2\x99\x04\x0d\xb0\x07\x29\x5b\x5a\x20\x6b\xe3\x4c\xf6\x2a\x0d\xdf\x44\xc3\x9a\x4e\x86\x45\xb6\x3a\x1d\x93\x83\xb3\x66\x21\x82\xf9\x57\xf2\xac\xc7\xc6\xbb\x83\x15\x5c\x81\x56\x5e\xaf\x58\xa8\x8f\xe9\xdf\x29\xbc\x97\x61\xcf\x09\x6b\xe9\xd7\x84\xda\x4b\x43\x9e\x5e\x0b\x53\x00\xd1\x11\x52\x50\xf1\x13\x12\xcc\x8d\xaf\xf8\x4a\x3b\xb6\x63\x55\xab\xb2\xcd\x14\x8b\xb9\xe1\x07\x60\xa7\x64\xd7\x55\x2d\x8e\x23\xc0\x30\xbc\x0b\x9e\x2b\xe1\xa7\xc6\xf7\x67\xb5\x17\x1f\x2a\xc9\xc4\x4b\x06\x7f\x75\x98\x44\x5e\x88\x27\x8c\xc9\x63\x41\x51\xb1\xac\x96\xb4\x0a\xd1\xa9\xbf\xd2\x75\xd3\x1e\x8e\xe8\xd2\x51\x05\xf7\x74\xa3\x6a\xdc\xb4\xd0\x75\xc3\x42\xd7\xf4\x6f\xcb\x42\xd7\x6d\xe5\x0a\x3c\x38\x30\x07\x8f\xd0\x4d\x0b\xc5\xe0\x4c\x16\x3c\x5f\x37\xd5\x9d\xeb\x2a\x1d\x8e\xc1\x87\x75\x53\xb8\xc1\xa6\x7d\x2c\x6e\xd3\x6e\x74\x2d\xfa\xd5\x06\xaa\x6e\xa3\x4d\xb4\xc3\xa2\x79\x3a\x96\xa4\x99\x24\x91\x14\x34\x52\x4a\xda\x96\x4c\x1b\xd3\x50\xca\xed\x16\x35\x21\x17\x7a\x85\xd3\x33\xbe\x1b\x4f\xea\x9f\x79\xce\x4d\x47\xf3\x03\x03\x06\x6a\x9c\x7e\x31\x15\xb3\x75\xcf\x53\xb8\xbe\x4f\x67\xc8\x2e\x8a\x61\x01\x24\x82\x9a\xfc\x79\x76\x4d\xcc\xe8\xec\xb1\x75\x8c\x9e\x20\xbf\x96\xcc\x6a\xd7\x4d\xc9\xc2\x85\x7b\xa9\x84\xb7\x94\x70\xf6\x96\x3a\x89\x6b\xd0\xe9\x17\x2c\xd7\xa7\x49\x9a\x4d\x04\x10\x40\x2d\x10\x38\xda\xa4\x6d\x9d\xe4\x68\x43\x8e\xef\x19\x4b\x6a\xae\x0d\xd4\x92\xb9\x68\x4b\x5c\x37\xb5\x89\x95\xa9\x50\x35\x46\x9b\xc8\x45\x5b\xc8\xa7\x4d\xe4\x67\xf4\x49\x40\xc0\x1a\xee\x65\xb7\x0a\x91\xac\x57\xd3\x51\x16\x1c\x0a\x6f\xcd\x70\xb7\xa9\x89\xf8\xb6\xa8\x72\x85\x50\xc2\xcb\x54\x6e\x0b\x1d\x05\xa3\xf1\x24\x26\x0c\xc8\xd7\x21\xb6\x3b\x02\x57\x8d\xa4\xdf\x77\x6d\x97\xf8\x31\xc0\xbc\x52\xc2\x3e\xa0\x6b\x30\xf7\x32\xc9\x7b\x40\x76\x8f\x1e\xdd\x02\x70\x2d\xa5\x17\xb9\x03\xdf\xed\xbb\x36\xf6\x63\xe4\xb8\x03\x37\x8e\xd0\xd8\x42\x37\x43\x12\x12\x74\x8b\xdc\x88\x03\xea\x5d\x33\xfc\xd8\x31\x0d\x71\x7d\x04\xbe\x0b\x9a\x97\x28\x08\x13\x1c\xa9\x3a\x25\xf7\x63\x10\x22\x8e\x54\x6d\xf1\xad\xf1\x17\x8c\xc9\x6a\xb3\xde\x6a\x8b\x45\x70\x84\x2e\xd6\x9b\xad\xf6\xba\x85\x1a\x97\xf5\x55\xb4\x99\x85\xc6\xc9\x0e\x40\x15\x10\x0e\xe8\x7a\x77\x8c\x9e\xa2\xdb\x7a\x1c\x1c\x73\x81\xb8\xd8\xab\x8e\x45\xf7\x4b\x47\xd4\x6a\x12\x44\x6e\x9d\xac\xd7\x6a\xcc\xc4\x15\xa6\xe4\xc4\xf3\xc0\x2b\x34\x6c\xe1\xff\x7f\xff\xaf\xc0\xc7\x16\xfe\xa6\x2c\xad\x11\x0e\xd1\x2d\x7f\x63\xda\xb0\x90\x2b\xdf\x6d\x9e\x0f\x09\x47\xdf\xe1\x64\x89\x83\x7a\x53\xa4\xb1\x81\x88\x0b\x40\x34\x43\xcc\xda\x98\x0a\x11\xbd\x77\xde\xd7\xdf\x3b\x1b\xe4\x62\x73\xe3\xf2\xbd\xb3\xc1\xa8\x55\x49\x7d\x50\xb7\x50\xb3\xde\x22\x1b\xed\x1a\x6d\x0b\x25\xbd\x48\x2a\x53\xd1\x34\xf5\x44\xaf\x2f\x18\xd8\x48\xc2\xb3\x0a\x2f\xf6\x54\x8d\xb8\x68\x5c\xa2\x0d\x2d\x25\xab\x59\x8b\xca\x50\x09\x66\xc3\xca\x86\xa8\x38\x8c\x4e\xd4\xb4\xbc\xcc\xe9\x24\x5f\xc0\x55\xf1\x1c\x37\xe0\xa3\xd0\xbe\x02\x34\xf9\x6b\xec\xe5\xdf\x83\xe7\xef\x07\x53\x37\xf9\x43\xc2\xd5\x35\x76\x47\xe4\x84\x13\x49\xdd\xe6\x9f\xe3\x71\x24\x65\x65\xe4\x7a\x9e\x1b\x11\x3b\xf0\x9d\x5c\x6e\xf6\x9b\x2d\xfd\x95\x85\xe4\x63\xe5\x0f\x3b\xe6\xe3\x17\xfa\xa7\x7c\x03\x52\x24\xac\x57\x49\xb6\x28\x25\xb0\xe5\x2b\xe3\x7f\xc1\xca\x4c\x62\xbb\xa0\x2e\x73\xbc\x60\xa5\xe5\xcf\x6c\xf7\xf6\xaa\xdb\x7d\x30\xb7\xa8\x52\xac\x96\x6f\xf2\xb3\x7b\x6a\xed\xf0\xcb\x54\x61\x12\xdb\xe6\x1a\xcc\xf1\x96\x98\xe9\x98\x3f\x29\x78\x51\xbc\xdf\xdc\x5e\x75\x1b\xe7\xbd\x11\x2b\xcd\xea\x3c\xdd\xda\x07\x1b\x65\x31\x09\x6d\xb3\x62\x87\xc1\x24\xff\x59\xf4\x7e\xb3\xb3\x6a\xf9\xe4\x21\xf3\x94\x64\xb4\xbc\x74\x7e\x0e\x26\xe1\xa2\xb2\xe9\xb0\x22\x9d\x82\x57\xee\xfb\xcd\x9d\x55\x8b\x26\x0f\x1a\xbc\x1c\x9f\xe5\x25\xf3\x02\x4f\x17\x15\xcc\x0e\x2b\xf0\x86\x90\x0f\x05\x92\xd9\x5d\xb5\x64\xfe\x98\x5b\x32\x1a\xa3\xb0\x14\x2d\x25\x9a\xff\x12\xf2\x61\xf5\x83\xe6\xf0\x4b\xb1\x7f\x36\xf1\x9d\x6c\xe3\x2e\x5f\x01\xb2\x6c\x05\x4a\x0f\x69\x81\x5a\x81\xa2\x94\xe7\x13\x12\x39\x78\x5a\x3e\x65\x19\xa2\xff\x25\x8e\x5f\x96\xac\x4c\xbb\x7a\x71\xbb\xcb\x8a\xdb\x2e\x29\xee\xf3\xe1\x24\x2c\x2b\x9b\x1f\x43\xb7\x9c\x60\x58\xc2\x32\x24\xcf\x70\x3c\x09\xcb\x11\x15\x49\x17\x1d\xb8\x76\xf9\x24\x1b\xf8\xf1\xb0\x60\xe4\xda\x5b\xf5\xc8\xd5\x9f\xbb\x29\x75\x4e\xe7\xea\x3a\xf1\x70\x51\xf1\xec\xb1\x42\xa7\x04\x17\x19\x03\xfb\xab\x96\xce\x87\xb9\xa5\xa3\x31\x5a\x5e\x38\xef\x08\x5e\xd8\x18\xd8\x67\x45\xc2\xda\xa3\xd8\x9a\x6c\x35\x56\x2d\xa0\x60\x6e\x01\x65\xb9\x9d\x63\x69\xb5\x8c\x3d\xd9\x6c\xc8\x92\x7f\x2e\xb4\x29\x5b\xcd\x55\x4b\x69\x34\xff\x12\x34\xcd\x6c\x69\x21\x2d\x63\x56\x36\x9b\xb2\xd4\x17\x45\xa6\x65\x6b\xe5\x3b\x0e\xde\xfc\x12\x4a\xf1\x5a\x5a\x40\x4b\x58\x97\xcd\x96\x2c\xf3\xbf\x85\x16\x66\x6b\xe5\x4b\xf3\xc9\xfc\x02\x4a\x33\x5b\xce\x4c\xe3\xc9\x57\x6f\x34\x44\x5f\xb0\x06\xf7\x65\x67\x8e\x57\x51\x87\xb2\xa3\x5d\x29\x53\x73\x12\xdb\xe5\x2c\xcd\x24\x61\x09\x92\x65\xed\x4c\x35\xe9\xea\xa5\x1d\xaf\x42\xda\x65\x4c\x4d\x2a\x9b\x92\x96\xe6\x24\xb6\x4b\x19\x9a\x32\x5d\x09\x82\x25\xcd\x4c\x25\xe5\xc2\x03\x58\x3b\x99\x7d\x8b\x2d\xcd\xd6\xca\x37\x9e\xfe\x9c\xbf\x35\x33\xdc\xce\xd3\x79\x16\x37\x36\x9b\xdb\xb2\xdc\x77\x85\x06\x67\x6b\xe5\xbb\x4f\xd7\xf3\x0b\x29\xcd\x6c\x69\x19\x49\x9b\x73\xc6\x7f\xa9\x03\x9b\x7b\x74\xeb\x77\xdf\x3e\xec\x60\xf5\x07\xa7\x91\x79\xf2\x51\x4c\xf2\x37\x38\x8c\xc8\x8a\x9d\x08\xe6\x6d\x2e\xd2\xd1\x42\xe7\xeb\xbe\x31\xba\x26\xb1\x0d\x15\x9c\x21\x88\xe4\x56\xe6\x82\x07\x6a\x5e\x60\x63\xaf\x00\x32\x73\x8f\x41\x4a\x51\x3a\x2c\x29\xc3\x8d\x52\x5a\x4a\x7e\x33\x7e\xe1\x33\x91\x97\xf8\xe4\x91\x6b\x9c\xe1\x97\x40\xab\x0a\xcf\x46\x71\x4c\xce\x01\x60\x60\xfd\xbb\x5b\x0b\x7d\xf7\xdb\xba\xc5\x43\x69\xc8\xe6\x68\xeb\xbb\x4d\x67\xeb\xbb\x77\x10\x1a\xf3\x74\x9b\x27\xdd\xef\x5e\x75\xbf\x3b\x43\xdf\x8d\xd7\xf9\x0b\x6d\x37\x70\xa2\x2e\xba\x58\x7f\xf6\x6a\xdd\x42\xeb\x6f\x5e\xad\x5f\x32\x32\x53\x08\x65\x06\x07\x8d\x61\xd3\x36\xfd\xc5\xa7\x5b\xfa\x53\x4e\x92\x10\xce\xa7\x1a\xfa\x9b\xcd\x11\xf4\x97\x18\xda\x19\xdd\x68\x18\x84\xf1\x8b\x84\x38\xa7\xcc\xc9\x72\x92\x9c\x18\xa7\xc3\x89\xb0\xfc\xb0\x3a\x87\xcc\xff\xc6\xfe\x04\x87\xac\x30\xd2\x0b\xc5\xef\x57\x38\xb4\x87\xf4\xc7\xb3\x71\xe8\x7a\x2c\x04\x22\xfe\x3d\xf1\x09\xfb\xeb\xc1\xf7\xb3\xc9\x60\x12\xc5\x40\x9c\x8c\x63\xf0\x93\x4d\x3f\x4e\xed\x38\xe0\x3f\x5f\x07\xd7\x32\xf8\x05\xb1\xd9\xef\xa4\x16\xaf\x54\x56\x38\x1b\x9c\x03\x5e\xbe\x5e\x3a\x2f\x9c\x97\xcd\x0b\xe6\x45\xf2\xe2\x78\x49\xeb\x97\xa9\xdb\x62\x7a\xe3\xa7\x2f\x8b\x31\xfd\x2a\x87\x74\x29\xf5\xd6\x78\x3d\x59\xa1\x7c\xc0\xb5\xe6\x47\xf1\xec\x97\x65\xac\xf7\xb9\x7a\x22\x65\x2c\x91\x91\x63\xa6\xac\x28\xd1\xe3\x24\x4e\x51\x6d\x24\x15\x5b\x8b\x7e\x23\x72\xf3\xae\x2c\xfa\x8d\xe1\x1e\xda\x37\xe5\x00\x24\x24\xb8\x00\x86\xb6\xb9\xa8\x17\x51\x4e\xf6\x4a\xb4\x90\x91\x7c\xdd\x2f\x6c\x6e\x4e\x63\x51\x20\xe3\x71\x18\x8c\xaf\xe2\xe9\x98\xe4\xfb\x31\x6d\xac\x82\xf6\x12\x75\xd4\x09\x2d\x8a\xac\x6c\x7b\x38\x8a\xc0\xe5\x75\xfe\xe5\x88\x55\xd0\x5e\xa2\xa2\x3a\xa1\x85\x81\x9e\x27\xb1\xeb\x5d\xbd\x99\x84\xe4\x2d\xa0\x0c\xe5\xab\x6d\x67\x61\xc8\x67\x28\xe2\xc1\x05\x6e\x69\x17\xb8\x20\x02\x76\xb5\xf7\x88\x36\xb1\xea\x9a\x09\x4c\x1b\x75\x1e\x70\x7d\xc2\x39\x70\x49\xc4\x65\xc2\x90\xff\xa3\xac\x47\x5c\x26\x1a\x88\x34\x89\xc5\x21\x91\x1d\xba\x63\x76\x59\x19\x52\x81\x58\x92\xe0\x3a\x01\xec\x7d\xdc\x83\xe9\xc5\x1c\x4e\xdb\x08\xfc\x1e\xa8\xf1\x76\xe0\xf7\xdd\xc1\x44\xe4\x04\x37\x08\x20\xd4\x75\xb8\x82\xb9\xce\x2e\x28\x8b\xe4\x35\x35\xeb\x4d\xe8\xc6\x5a\x36\xde\x0e\x5a\xdd\xa7\xb2\xe6\x4a\x4e\xc0\xb4\x57\xa8\x1e\xa8\x02\x4f\x24\x7a\xa4\xde\x05\x87\xd6\xa5\x44\xc1\xd5\x25\x8e\x5d\xfb\x8d\x10\x25\xf7\xbd\xc0\xa3\x6b\x59\xe1\x1f\x99\xee\x8b\xab\x24\x6b\x07\xdc\x11\xa3\x42\xb7\x88\x8a\xce\xc2\x81\x60\x5d\x49\x41\x15\x06\xdd\x55\x6b\x52\x6b\xa8\xbe\x58\xfc\x6f\xcb\x42\x57\x31\x19\x8d\x35\xaf\xca\x10\x73\x84\x3d\x0f\x9c\xe8\x57\xc5\xa3\x3d\x4b\xa5\x2a\x6a\xfb\x48\x46\xeb\xef\x03\x93\x84\xa0\xe2\xc3\x30\xb8\x81\xb7\x27\xe7\xd3\x31\x39\x0e\xc3\x20\xac\xae\x1f\x61\xdf\x0f\x62\x44\xfb\x04\xc2\x08\x0a\x45\x38\x42\x58\xca\x7d\x5d\xf8\x4a\x4e\x58\x1b\x07\x51\xe4\xf6\x3c\xa2\x14\xc0\xbc\xe4\x57\x23\xe2\xf5\x2d\x20\x26\x59\xa3\x41\x7a\xe9\x6f\x49\x9f\x84\xc4\xb7\x05\x0b\xe0\xda\x66\x88\x23\xbf\x12\xa3\x1e\x21\x3e\x02\x53\x06\x7b\x2e\x35\xff\x37\x51\x34\x19\x93\xb0\x5a\xd3\x52\xd0\x12\x88\xc3\x58\x4b\xdc\x81\xc3\x03\x12\xe1\xed\x0e\xbe\x01\xfd\x80\x81\x3c\xaf\x0b\xaf\xf7\x5a\x5c\x52\x4b\xf4\x94\x05\x77\x11\xe5\xf8\x40\xaf\xb1\xeb\x0f\x49\xe8\xc6\x51\x35\x9a\xf4\x8e\x58\xd3\x01\x5b\xf0\x5b\x54\x95\x13\x4f\x22\x0c\xe0\xd5\xa9\x48\xe6\x90\x22\xa7\x69\xce\x68\x5a\xba\xee\x09\x49\x14\x81\xef\x8f\x49\x14\x8b\x6b\x98\x3d\xc2\x1e\x62\x05\xa1\xd2\x56\x16\xa2\x6d\xb9\x8e\x36\x50\x86\x17\x10\x95\xe0\xbe\x9e\xff\x44\x41\x61\x50\x63\x57\xed\x28\x9f\x74\xff\x4d\x9f\x84\x27\x99\x44\x38\xc9\x30\xd3\x65\x83\x8c\x85\xc4\xf0\xd0\x85\xd1\xc1\x42\xea\x48\xc3\xc2\xa8\x9a\x89\x9e\xa7\x08\x97\xf3\x17\x91\xf8\x8d\x60\xe1\xb4\x2f\x61\xed\x53\xe1\x39\x0d\x94\xf0\x56\xbf\xba\x82\x9a\xc0\xe4\x96\x24\x81\xf6\xe6\x3e\x04\xff\xd5\x77\x3d\x72\x7a\x4d\xc2\x6b\x97\xdc\xa0\x37\x81\x37\x1d\x04\xfe\x5a\xb2\x2f\xc1\x9d\x46\xf2\x88\x37\x81\xeb\xc7\x51\xca\x77\xa4\x16\x57\x1d\xc3\x1f\xed\xfa\x36\x0b\x9a\xd7\xd1\x72\xfd\x96\xb9\x8c\x16\x1f\x8f\x1f\x73\x37\xc9\x53\x35\x7c\xaa\xfa\x5d\xa6\xe4\x98\x1f\xa0\x0b\x9e\x4b\xb8\x56\x9e\x9a\xdd\x29\x2b\x6e\x35\xc1\x4d\x32\x77\x88\x8c\x54\xc7\xc1\xbc\x7a\x65\x56\x2e\x26\xcb\xc5\xb8\x84\x61\x03\x1e\x3a\x44\x55\x18\x0b\xa9\xe9\xc1\x06\x47\x6d\x56\xbd\x3a\x0a\x46\xec\x4a\x32\xab\x64\xd2\x33\x39\x4f\x16\x52\x92\xc0\xfd\x66\x99\x99\xa7\x90\x37\xe6\xd3\x43\x2c\x1d\x87\x2c\x91\xaa\x76\xa0\x49\xa5\x60\xcc\x63\xd9\x44\xf9\x8a\x7e\x49\x77\xc5\xf5\x81\xae\xa3\xa2\x88\x5a\x1d\x8f\xc7\xde\x94\x53\x90\x26\x4e\x2d\x71\x1d\xa3\x5a\x17\x49\x0d\x2f\xf8\x8b\x4c\x32\xed\xa2\x4a\x08\x42\xad\x58\xfc\xb9\x07\x74\xc4\x04\x69\x04\x22\xab\x89\x42\xc0\xe4\x03\x16\x83\x78\xde\x08\x1f\xc9\xd3\x0b\xc4\x55\x93\xca\x9f\xd9\x1f\xec\x5b\x4d\x01\x72\x7b\x8d\x47\x24\x49\x24\x83\x0e\xd6\xd6\x78\x4a\x18\xfd\x39\xb1\xcf\x9f\x11\xff\x29\xfc\x10\x4a\x8e\x90\x76\x93\x9d\x07\xde\xad\x29\xfc\x7a\x78\x2a\x86\xa4\x22\x9f\x88\x66\x83\xbd\x5a\xab\x4a\xd7\xee\x9b\x63\x26\xc1\x8a\x95\x54\x41\xb4\x33\x9a\xbd\xb1\x99\x59\xd9\xd5\x71\xda\x91\x71\x52\x80\xe6\x19\x78\x66\x2f\x31\x19\xdf\x17\xeb\x1f\xa0\x97\x80\xf2\x90\x88\xf8\xd4\xc4\x08\x7c\xe9\x94\x38\x62\xfd\x26\x69\xc4\xda\xc2\x05\x11\x28\xa8\xef\x7a\x31\x09\xc1\xfd\x69\x61\x21\x49\xcb\x49\x29\x76\x95\x46\x4a\x34\x85\xb5\x78\x37\x77\x40\x14\x8d\x5d\x93\x03\x11\x42\x77\xba\x47\x23\x9e\xef\x60\xed\xae\xcc\x72\xf9\x62\x5d\xf6\xfd\xf5\xcb\x9a\x34\xaf\x04\xf0\x1a\x57\xd9\xca\x9b\xa4\x95\x78\x02\x5a\x35\x3a\xf3\x82\x86\xa9\x2d\x37\xaf\x24\x6d\x90\xe4\x9b\xb7\xc7\x67\xc7\xaf\xcf\x9f\x9d\x9f\x9c\xbe\xbe\x7a\x76\x7e\xfe\xf6\xe4\xf9\x2f\xe7\xc7\x67\x54\x96\x4c\x7c\x8a\xe0\xe6\x5d\x6a\xd7\x71\x9d\x3d\xd5\x60\x90\x8b\x4c\xc2\x0b\x10\x01\x67\x1c\xa7\xfd\xd2\x2b\x74\xb5\xfc\x21\x1e\xb3\xad\x4c\x84\x6e\x17\x2a\x9c\x3d\xf7\x61\x9a\x32\x5d\x82\xc2\x1a\x68\xcf\xda\x5d\x8d\x5b\xd0\x35\x78\xde\xcd\x5a\xf5\x60\x09\x17\x3c\xca\x24\x90\xda\xc0\xfa\x02\xae\x3c\xcb\xef\x34\x79\x81\x83\xa3\xe1\x95\x1b\x1d\xff\x39\x29\x78\x1e\xb2\xbd\xa0\x7b\xa9\x6c\x01\x4b\xed\x69\xa5\x89\x2d\xba\x01\x25\xe9\xfc\xc8\xe5\x9f\xbf\x51\xb1\xb0\x27\x30\x43\x19\x4b\xed\x75\x19\xe8\x2d\xba\x2d\x25\x49\xbd\x76\xf3\x9b\xbc\xbd\xe0\xee\x65\x9a\xfc\x52\xfb\x5e\x3a\xa9\x45\x77\xbe\xee\x65\x97\xb6\xbd\x82\x5d\xda\xf6\x72\xbb\xb4\xdb\xf7\xb8\x4b\xbb\xbd\xaa\x5d\xda\xed\x15\xec\xd2\x76\xb8\x9c\xa2\x51\x10\x14\x9c\xf0\xb7\xb7\x57\x43\x7e\x89\xda\xa6\x49\x2d\xea\x86\xee\xfe\x76\xa5\x77\x56\xb5\x2b\xbd\xb3\x82\x5d\xe9\xdd\xfb\xdf\x95\xde\xbb\xba\x02\x6b\xe3\xea\x68\x12\x5e\xe7\x9f\xda\xee\x2d\xe8\x9a\x71\x5f\x90\x7f\x11\xe4\x0f\x31\xbb\x8b\x1e\x95\x34\xc0\xaf\x5e\x8c\x5d\x9f\x84\x57\x2f\xa9\x81\x9c\x2f\x9f\x05\xfd\x12\x36\x9b\xb4\x0c\x6e\xf3\x5e\xbd\xc4\x3d\xe2\xbd\x74\xa3\x82\xba\x2c\x38\x5e\x36\x5b\x57\x57\xb0\x2d\xf5\xbc\xe0\xfa\x49\xb3\xb1\x68\x2d\xc4\x2e\xc1\x0b\x1c\xe3\x19\x67\x0f\x0b\xba\x9d\x6c\xce\x7b\xbe\xb1\x48\x19\x1d\x5e\xc6\x11\x5d\x6e\x16\x97\x01\x37\x56\xc5\x6e\xd2\xc3\x39\xca\xc3\x39\xca\xc3\x39\xca\xca\xce\x51\x5a\xda\x41\x0a\xdb\xfe\xff\xaf\x1b\x0f\x83\x49\xac\x94\x1b\xf4\xfe\x00\xb5\x8d\x84\x36\x30\x89\xa2\x43\xf4\xe9\xee\x40\xd5\x23\xe6\x85\x59\x48\x04\x9c\xd2\x0b\x3c\x06\xb7\x86\x7e\x00\x38\x15\x3a\xce\xbb\xbe\x68\xe4\x47\xa5\xba\x0e\x30\xe0\xd6\xd4\xcc\xbc\xf7\xb8\x97\xcc\xb1\x34\x68\x63\xb6\xcb\xa8\xb5\x8b\x03\x2a\x9d\xc9\x88\x6a\x0c\xf3\xc3\x89\x43\x79\x2e\xa4\x3b\xe8\xa4\x11\xd9\x2e\x62\x21\x1c\x86\x2d\x74\x88\x64\x22\xb1\x45\x27\xc6\x95\x30\xdd\x75\x68\x06\xc6\x23\x0e\x43\x9d\x47\x1a\x75\x20\x71\x0b\x45\x28\xe3\xa3\x1f\x06\x23\x60\x22\x73\xa0\xf4\x70\xd6\xf5\x70\xd6\xf5\x70\xd6\xf5\xf5\xcf\xba\x5e\xba\x3e\x59\x33\x5c\xc0\xa5\x83\xc5\x8f\xcf\x8e\xce\x4f\xdf\x52\x7b\xa3\xce\xfc\xfd\x35\xf9\x18\x4c\x33\x95\x39\x09\x32\xad\x16\xca\x9c\x04\xb5\xe6\x3e\x0a\xa2\x1c\x15\x9c\x03\xd1\x68\x0d\x4d\xf2\x2a\x24\x7d\x7e\x0c\x00\x9f\xb4\x54\x3a\x95\xc0\xb1\xcc\x55\x48\x62\x1e\x69\x3e\x30\xa2\xe4\xc4\x29\x82\x1c\x5a\xaf\x3c\xe2\xab\xe6\x16\x1f\x42\xe1\x94\x27\x92\x83\x2d\x4d\x55\xb3\xd0\x15\x35\xbf\xc0\x5a\x81\x5f\xdf\x43\x6e\xf6\x01\x03\x2e\xdf\x27\xa7\x59\x2f\xae\xb8\x65\x95\x18\x72\x57\x02\x08\x2e\x7d\x92\x47\x39\x57\xcf\xd3\xaa\x50\x23\x38\xb3\x99\x75\x98\x45\x25\x82\x0e\xa1\x6a\x65\x0e\xb4\x40\x04\x35\x98\xd5\xf8\x91\x16\x25\x60\xa1\x0b\x4a\xee\x92\x1a\x43\x36\x8e\xab\x94\xff\x5a\xad\xc6\x25\x2b\xfe\xd6\xe9\x94\x4f\xb8\x9f\x4b\x38\x37\x8a\x9e\xf9\xee\x08\xce\x3a\x7e\x74\x7d\x37\x1a\x12\x87\xf7\x23\x81\x55\x19\xc4\xd8\x7b\x09\xf2\xec\x22\x06\xe7\x76\x27\x88\xb9\x4e\x19\x55\x34\xad\x37\x2e\xd6\x5d\x50\xc5\x89\xef\xfe\x39\x21\x27\x1c\xad\x35\x39\x3b\xf2\x5c\x9f\x6c\x56\x24\xd7\x36\xb6\x87\xe4\x4d\x48\xae\x29\x09\x4d\x2f\xd5\xd3\x5e\xd0\x1a\x56\x4b\x12\x9f\xd1\x8a\x56\x3f\xa1\x71\x48\xae\xdf\xf0\x8d\x7b\x7e\x3e\x76\x27\x4e\x40\x04\xf9\x31\x8e\x87\x6f\xa1\x0d\x12\xc2\x7e\xe0\x90\x34\xd9\x11\x76\x7d\x58\x1a\xa3\x43\x44\xe3\x53\x64\x86\xd8\x77\x3c\x22\xe5\x79\xec\x3b\x69\xdb\x3a\x8f\xc9\xdc\x56\x90\xbc\x8a\x4c\xcc\xba\x0e\x7c\xb5\x94\x6a\xba\x3e\x29\x46\xce\x62\x1c\xc6\x4b\xb1\x02\x23\xed\x6c\x5e\xa0\x20\x8d\x1b\x32\x1a\xd3\x46\xcc\xef\x02\x4a\xbf\x4f\x0e\x62\x61\xb8\x44\xe8\x09\xe0\x9c\x05\x11\x61\x30\x67\xb4\xe9\x83\x3e\x22\xd8\x1e\xa2\x41\x18\x4c\xc6\x2c\xcd\xbf\xc6\x38\xc4\x23\xf4\x89\xe9\xe1\x1d\x5b\x59\x00\xc8\x16\xfb\x45\x0d\x21\x20\x20\x57\xee\x5a\xbe\x24\xe3\xed\xb3\x5b\x37\x42\x08\xb2\xca\x39\x04\xe4\x15\xf4\xd1\xed\x26\xbe\x75\xa3\x9c\x9c\xd3\xa2\x9c\x53\x53\x4e\x06\x72\x7f\x07\x95\xfa\x0f\x99\x42\x4e\xd6\x17\x60\x75\x18\xf4\x11\xd6\xea\xc8\x07\x99\x4f\x30\x92\xdd\x21\x21\x18\x07\x08\x40\x9a\xad\xb5\xcc\x11\x36\x1b\x99\xb5\xf3\x6b\x29\x83\x17\xae\xf3\x2a\x98\xf8\x71\xc5\xe2\x47\xc8\x5b\x4f\x10\x89\x3c\xd7\x8f\x37\x1d\x37\x82\x15\x11\x82\xed\xb9\x2d\x3f\xd8\x74\x5c\x67\x73\x44\x53\x6f\x46\x24\xde\x64\x43\xc8\x93\x2d\xe3\x19\x78\xa6\x00\x45\xd7\xc0\x6a\x53\x34\x47\x51\xb5\x67\x76\xec\x5e\x93\xec\x39\xb5\xf1\x88\x5a\x19\x92\xc4\xb9\xfa\x80\xc4\xe7\x49\x68\x55\x2a\x6a\x5a\xbb\xb5\xd1\x4c\xa5\x73\xa7\x9e\x8a\x8a\x53\xd7\x94\xcc\xfe\xeb\x7a\xde\x5b\x62\x13\xf7\x1a\x56\x54\x51\xce\x35\x80\xdc\xf4\x55\x9f\xdc\xc6\x62\xc1\x57\xfe\x8a\x00\x16\x42\x3a\x71\x92\x2b\x00\x4a\xe0\xec\xeb\x04\xfa\x35\x01\xc9\x85\x4a\x04\x8c\x46\xe5\x5b\x6d\x8a\xec\x10\x2c\x86\xdd\xa4\x79\x72\x64\xa7\xb7\x4b\x8e\xc0\xd2\x8d\xa7\x09\xc7\xa6\xe3\xed\x8b\x60\x24\xc4\x23\xc7\xe0\x83\x5c\x8d\x90\x59\x1e\x3f\x96\xbf\x53\x1a\x52\x10\x55\x65\xae\x13\xd2\x37\x15\x94\x22\x72\x35\x65\x40\x15\x2d\x0c\x3e\x90\x17\x38\x1a\xc2\x91\x6f\x7e\x8d\x53\x09\xab\xc2\x64\x51\xca\xb1\xc0\xe1\x65\x4a\x59\x68\x90\xac\x29\xc4\x67\xef\x35\x8d\x43\x62\x21\xda\xcc\x86\x8b\x1f\xe3\x90\xa0\x0d\x88\x94\x8d\x97\xdc\xca\x00\x81\xd3\x5e\xab\xba\x1c\xe3\x90\x80\x5b\x4a\xd1\x16\x6a\x36\x6a\x6a\x03\x84\x84\xb6\x4b\xc2\x17\xfb\xf1\x9d\x92\x45\x4f\x1d\xc5\x49\xff\x55\x5a\x65\x93\xe7\xd4\x18\xe2\xb4\x69\x55\xd1\x21\xba\xb8\x14\x94\xd2\x2b\xeb\x68\x32\x02\xbb\xee\x00\x7e\x6d\x70\xe9\x5c\xb8\x97\x16\xda\xd8\x70\x55\x51\xb0\x85\xc0\x08\x6d\xc8\x24\xe8\x07\xad\x0a\x6a\x62\x94\x61\x40\x98\x58\x86\xed\x00\xd6\x20\x0a\xe8\x63\xcd\x42\x17\x9a\x70\xe8\xb2\x73\x74\x29\x85\x47\xff\xeb\x85\x04\x7f\x48\x02\xee\x4c\x63\x1e\x19\x8d\xe3\xa9\x60\x41\x61\xa8\x2e\x45\xdd\x82\x75\x67\x03\x3d\x45\x17\x0d\x4b\x11\xf1\x25\xea\x52\x16\xe4\x67\x5a\xb1\x0b\xeb\xc3\xdc\x9a\x90\x31\xc1\x31\xab\x9b\xc5\xf4\x83\x19\x96\x99\xe4\x0a\x63\x35\x4b\xe1\xb9\x56\x1f\xe1\xb1\xa2\xa0\x94\x94\x41\x37\x69\x30\xda\x40\x95\xf1\x6d\x25\x51\x4e\x7e\x25\xce\x82\x3b\x71\x39\x1d\x8f\x71\x98\x7b\x2d\x2b\xcb\x7e\xa6\x4b\x45\xbf\xf8\x6e\x2c\x7b\x94\x22\xd4\x47\x42\xa8\x33\x9b\x9d\x36\x75\xe3\x92\x2e\x09\xe1\x33\xa5\xf0\xec\xe0\xe8\x22\x11\xbf\x69\xef\x14\x98\x3b\x48\xab\xab\x92\xbb\x80\x07\x96\xca\xdc\x2e\xb2\x86\xb5\x5a\x66\x46\xcd\xdc\x44\xcc\x91\x30\x5d\x43\x8a\x43\x89\xc2\x0b\x70\x22\x51\x6a\xe6\x2f\x9a\xf8\xe9\x70\xfc\x28\x59\x9f\xd4\x0d\x46\xe8\x3c\x77\xd8\xd8\xe4\xd7\x2a\x7b\xe9\xae\x65\xb8\x75\xc7\x8c\xc1\x24\x05\x7c\xab\x09\xa6\xa9\x04\xd3\x74\x02\x0f\x4f\x83\x49\xac\xa4\x60\x01\xda\xd5\xbe\xa1\xeb\x39\x21\xac\x5d\x45\x22\x11\xa4\x8d\x80\x84\x4b\xf4\x24\x26\xa3\x52\x2b\x2e\xf3\x75\x29\x97\x5f\x3c\xf3\x9d\x23\x5a\xca\xf3\xe9\xf9\x74\x4c\xd8\xca\x4b\x14\x5b\x74\x07\x4b\x3f\x95\x32\x6d\x26\x1c\x68\xb7\x11\x55\xae\xcb\xb6\x5e\x72\xf6\x80\x63\x0c\xcb\x36\xf6\x1a\x2e\x26\x61\x55\x06\x59\xc2\x6c\x36\x50\x55\xc7\xed\xdb\x6e\x42\xa6\x7e\xab\x35\x9e\x1a\x33\x55\x63\xb8\x4a\x27\xb1\x10\xa0\xa6\x80\x6a\xfd\x8a\xbd\x6e\x89\x76\x30\x1d\x51\x5d\xac\xdf\x88\x9b\x86\xbf\x52\xda\xcf\xa7\x2f\xf8\x22\x80\x3d\x2e\x94\x25\x8f\xf1\xd4\x0b\xb0\x93\xd4\x36\x99\x21\xf2\x3a\xf1\x1c\x57\x30\xea\xb8\x6e\x7b\x81\x2f\x6f\x53\xaa\xad\xa5\xde\x3a\xa4\x85\x8b\x95\x73\x22\x06\xe8\x0e\x5d\x94\xea\x15\x53\x16\x9a\xea\x0a\x4c\xef\xbb\x28\xad\xff\xd9\x26\xee\x1a\xc2\x14\x23\x05\x15\x0d\x4d\x2f\x82\x98\xb2\x5e\x38\x32\xf1\x34\xd5\x60\xcc\xf6\x34\xc7\x59\x5b\xdc\x61\x49\xd0\x21\xba\x0e\x5c\x47\x31\x03\xa9\x4a\xcf\x27\x5e\x37\xfa\x15\x7b\xae\x23\x04\xcc\x0a\xad\xa9\x3a\x9b\x14\xb6\x44\xc3\xe9\x95\x91\x9a\x91\xb8\x54\x5a\xf0\xe6\x55\xb5\x56\xcc\x32\x8b\xac\x1a\x8b\x4d\xd2\x83\x45\xa9\xde\x60\x9e\xf3\xb2\x45\x35\xb3\x2b\xe4\x04\x71\xc5\xe2\xa5\xd7\xd5\x9b\xc5\x4b\x4b\x55\xbb\x5d\x5c\xf6\x1a\x83\x61\x1c\x4c\xdd\x47\x66\xd3\x0f\xfa\xa4\xde\x43\x4d\x44\x72\x97\x3f\x25\xf3\x8a\xcc\x56\xfc\xbc\x95\x68\x92\x20\x7d\x29\x9d\xce\x8b\x62\x7e\xd4\xa6\x9a\xec\xd4\xac\x4e\xa2\xd9\x99\x5b\x5f\x5a\xde\xcb\xc4\xae\xb0\x0d\x4c\xb4\x73\xe7\x75\x27\x48\xe6\xdb\x76\xdd\x09\xe2\x82\x49\xbf\x9d\xac\x8d\x93\x02\x3c\x7e\x58\x1a\x2d\x31\xcb\xce\x7b\x8f\xfc\x40\x5b\xec\x46\x71\x30\x7a\x11\xc4\x5f\x84\x09\x27\x88\xb5\xd2\x9d\x00\xe4\xc3\x9f\x0e\xe8\x16\x3b\xbc\x62\xa1\x0b\x9a\x54\xdf\x76\x12\x5e\x13\xa5\x57\xa4\xce\x34\xd5\x09\xe2\xcd\x0a\xda\x40\xae\xda\x20\x61\x17\xb5\x93\x29\xcd\x4a\x84\x6f\xa5\xe4\x60\x69\xb3\x3a\x57\x72\xf6\xac\x26\x33\x3b\xdb\xb7\x22\xea\xd6\x42\xf6\x54\x7c\x50\xd6\x7d\x87\xdc\x76\x91\x6b\x21\x3e\xb1\x8a\x38\xfe\x99\xb0\x92\xd8\x31\xc9\xc4\x0a\x1d\xa6\xae\x4f\x23\x54\xc1\xa4\x00\x6a\x86\xe5\xf4\x62\xb3\xb2\x36\x0c\x49\x46\xe6\xbc\xf9\x64\x1a\x96\x24\x2d\x6d\x28\xca\x0e\xaf\x51\xc5\x4a\xda\x2d\xaa\x30\xc7\x54\xb2\x87\x45\xfc\x63\xd6\x84\x0c\x9b\x34\x67\x70\xc3\x00\x7b\x5e\xde\x4e\x88\x31\x2d\xdf\x5e\xb2\x90\x4f\x88\x73\xe4\xb9\x63\xe3\x54\xcd\xfa\xf1\x76\xee\x68\xc0\x4f\x21\x79\xb2\x3a\x9c\x30\xe6\xdb\xe7\xdb\x26\xfb\x3c\xf0\x7d\x62\xc7\xaf\x27\x9e\x17\x29\x09\xd5\x60\x7d\xeb\x84\x56\x23\xdb\x1d\xca\xbc\x49\x59\xd1\x60\xb2\x78\x49\x8b\xbe\x4a\xe9\xbb\x9e\xd7\x45\x15\x3f\xf0\x49\x25\x91\x5d\xbe\x7e\x81\x8c\xb4\x94\xee\xf8\x0d\x8e\x87\x5d\xd9\xd8\xe8\x29\xaa\x4c\x42\xaf\xfa\x0f\x11\x05\x43\x87\x38\x70\xda\x40\x95\x5a\x85\x3b\xcd\xce\x3e\x7e\x61\x7f\xd7\xe4\x98\x32\x4e\x8f\x1f\x54\x0b\xba\x88\x9d\x36\xa7\x0c\x53\xad\xb9\xbb\xda\xd7\xbd\x74\xed\xf2\xf7\x30\x67\xdb\x18\x89\xe6\x51\x43\x83\x9f\x67\x71\x37\x7b\xe2\x74\x4b\x7f\xf9\x93\xdb\x65\xff\xeb\xc6\x43\x39\x49\xcf\xee\xb5\x5a\xf2\xaa\x68\x43\x83\xb9\xd1\x36\x99\x1b\xac\x4b\x75\xca\xae\xd4\x3b\x86\x95\x7a\xa4\x6f\xa4\x2a\x69\x53\x31\x6a\x26\x93\x99\x23\xb2\x65\xe2\x8c\x9b\xf1\xcf\xc9\xc0\xf5\x95\x5c\x7a\x84\x31\xcb\x0b\x71\x2a\x64\xc8\x25\xe2\x8c\x19\x8f\x71\xe4\xfa\x03\x53\x36\x16\x33\xeb\xb4\xa0\x93\x77\x5c\x10\xc0\x8d\x8f\xc3\xfc\x6b\x5b\x3c\xbf\x85\x2e\x2a\x4c\xf2\x15\x0b\x55\xa2\xf4\x1e\x37\xaa\x64\x64\x46\x03\x75\x91\x68\x21\xa2\xba\x5a\x20\xab\x8c\x16\x74\xe2\x54\x2e\xf5\xed\xe9\x2b\x71\x82\x9d\x58\x95\x9a\xc2\xc8\xe3\x5e\x5a\x2d\x66\x74\x26\x61\xda\xf4\xa0\x9d\x19\xf0\xa4\xda\x2e\xff\x97\x9d\xc6\xf3\x6e\xd6\xd7\xb1\x32\x71\xab\xbb\xc6\x54\xa8\x5d\x94\xaf\x77\x0e\x97\x71\x37\xab\x81\xa9\xae\x00\x2d\xd6\xcd\x76\x0a\x6d\xdb\x03\x1a\xa7\x9b\x56\x4a\x35\x49\x3f\x0c\x46\x5d\xf4\x09\xc5\x5d\xd4\x50\x8d\x06\x2a\x6b\x1e\xde\xd4\xc3\xd9\xe0\xc3\x0e\xfb\xd1\x06\xca\xd3\x52\xed\xb4\x9b\x8f\x6a\xd9\xc3\xf6\x9c\x2c\x70\x28\x6d\xce\x04\x51\x8a\x09\x9a\x4c\x6a\xc9\xbd\x97\x90\xf4\x5b\xb5\x94\x01\x1a\x22\xb0\x1b\x68\x54\x3d\x56\x8c\x45\xc4\x6f\x71\x0a\x75\xd3\xf3\xb1\x9c\x51\x4c\xc6\xfc\x16\x43\xa1\xa1\x4d\xad\xd5\x74\xfe\x34\xfd\x0b\x48\x75\x99\x4d\x26\x5c\x23\x92\x6b\xb8\x6a\x9b\x4a\x7f\x60\x4c\x0d\x7e\x8f\xc6\x81\x87\xe3\x20\xfc\x6d\xf1\x7b\x1d\x0e\xcc\x54\x09\x31\xf2\x9a\x39\x1b\x03\x1b\x82\xb2\x92\xbc\x89\xbf\xad\xcd\xe6\xe4\xdd\x7d\x72\x32\x95\xaf\xf3\x6b\x5a\x2b\xb2\xff\x44\xb7\x57\xe7\x59\xde\x3a\x9f\x10\x5d\x49\xa8\x02\xab\xc6\x35\x0b\x4d\xf5\xc0\x77\xd5\xb8\xa6\x5c\x9a\x90\x7a\x96\x2e\x8a\x17\x04\xb4\xf5\xc4\xe9\xcc\xea\x6a\xa4\x5d\x37\xdb\xce\x42\xc1\x12\xeb\x59\x23\x72\xb7\x96\x2f\xec\x7b\x92\x75\x43\x3b\xd5\xd4\xb8\xe1\x56\xb3\x1c\x86\x55\x6e\xaa\xb1\x29\x69\x48\xfc\xf4\xd9\x69\x76\xb3\x4e\x74\x95\xd4\x4c\x65\xea\x8f\x1e\x3f\x53\x4b\x25\xad\x47\x63\xcf\x8d\xab\x5b\x17\xd6\xfb\xe8\x72\x63\x6b\xe0\x8e\xd2\x67\x58\xfe\x64\x94\xed\x78\xe2\x90\x15\x87\x11\xf9\xd1\x0b\x70\x0c\xc9\x8a\x1b\x35\xb7\x52\xbc\x99\x0d\x87\xc5\x52\x64\xc6\xf3\x62\xad\xb9\xd3\x1b\x72\x85\x25\x26\x4d\x01\xa7\x70\xa8\x02\xae\x9e\xb5\x03\x5a\x99\xa4\x96\x3a\xa9\xcb\xa8\x76\x19\x65\xcd\x2e\xf4\x74\x4e\x53\xad\xd2\xcd\x61\x7d\xcd\x2c\xdd\xbb\x79\x96\xaa\xb3\x4d\xdd\x3c\xeb\x16\x6c\xa4\x9d\xb2\x36\xec\x8e\xc1\x86\xcd\x37\x47\x77\x4c\x5b\x6e\x4a\xd9\x60\xb6\xb4\xe6\x31\x87\x5a\x73\xd8\x43\x2d\xb3\x41\x94\xbb\xd5\xc7\xab\x2a\x7f\x89\x83\xd4\xc7\x8f\x51\xf5\x91\xc2\xcb\xe3\xc7\x5a\x71\x3f\xa0\x06\x80\x56\x2c\xf2\x38\xba\x5a\x53\x26\x44\x8b\x97\x5b\xab\x19\x76\x15\xf9\x59\xf6\xac\x95\x4b\xde\x6e\x6c\x3a\x7b\x81\x16\xcf\xd2\xb7\xf9\xf1\x43\x76\x73\xb5\x6b\xe8\x3a\x89\xb6\xec\xd6\xe9\x67\xde\x96\xe8\xee\x8c\x2d\xd1\xdd\x52\xe8\x23\xbb\xc9\xa6\x7b\xfe\x81\xe9\xee\xac\x03\xd3\xdd\xec\x81\x69\x1c\x8c\x95\xe8\x38\x18\x6b\xbb\x35\xa4\xaf\x56\x84\x7e\xaa\xd1\x37\xae\xc3\xd4\x96\xc7\xc3\xb7\x26\x26\xe2\x0e\x86\x2a\x05\x16\x50\xae\x13\xee\xce\xda\xf7\x86\x46\x48\x60\x57\x96\x43\x60\x31\xec\x91\x6b\xfd\xdb\xb4\x89\xae\x2d\x91\x86\x38\x3a\x73\xfd\x81\x47\xa0\x53\x24\x86\x26\xef\x8c\x87\x87\x87\xa8\xa9\x0e\x22\x25\x21\x5f\x4a\x1e\xd0\xa4\xf0\x5e\x92\x62\xe4\xfe\xce\x21\x57\x96\xc7\x8f\xd9\x8f\x3a\xf6\xbc\xe0\x86\xda\x13\xa7\xd7\x24\xec\x7b\xc1\x0d\x15\xe0\x54\xa4\x99\x9a\xd3\xfc\xb5\x76\x59\x15\x19\x2b\xeb\x0c\x65\xcb\x6b\x25\xec\x23\x54\x71\x48\x3f\xaa\xa8\x6a\xad\x6f\x94\x15\x55\x71\xae\x82\x10\xaa\x88\xfd\x39\xad\x38\x5a\x6f\xd7\xe9\x26\xb1\xda\xee\xdd\x9d\x9e\x74\x19\x5e\xa8\xd6\xc5\x15\x6e\x8b\xc3\x78\x40\xed\x6f\x3a\x6c\xb0\xd1\xa0\xcb\xfe\x58\xbc\xeb\x77\xc5\x10\x70\x57\x53\x58\x48\x7e\xd7\x32\x7b\x8a\x8f\x52\xfd\x88\x4e\x5a\xa9\x39\x20\x99\x35\x92\x6c\x4a\x9a\xe4\x26\x4c\x12\x5d\x4d\x51\xfd\xfc\x99\x8e\xd1\xb5\x14\x75\x76\x66\xa7\xe4\x7a\x94\x1d\x9d\x3e\x7f\x36\x0d\x15\x40\x69\x81\x27\xcc\x06\x55\x16\x35\xc5\x9e\xf7\x7c\xfa\x06\xbc\xe9\x2b\xbb\xc0\x72\xae\x35\x18\x59\x3a\xac\xd0\x4b\xd7\x27\xc5\x98\x42\xed\x39\x31\x85\x5e\xb2\x71\x66\x09\x40\xa1\x9c\x5d\xf0\x12\x88\x42\x73\xd3\x64\x72\x3d\xfe\xf5\xf8\xf5\xf9\xe2\xf0\x44\x66\x8c\x09\x0d\x9e\x88\x6d\x6d\x2f\x40\x22\xf0\xc9\x69\x9f\xca\xaf\x7a\xb1\x68\xee\xea\x45\x05\xbc\xc1\x57\x2c\xc4\x7e\x1c\x79\x41\x44\x1c\xf9\x79\x3a\x26\xb0\xd7\x47\x27\x08\x1c\x26\xbf\x92\x64\x3e\x8e\x27\x21\xf6\xe8\xcf\x51\xe0\x07\x71\xe0\x93\xdf\xd4\x8f\x77\xea\x07\xdb\x85\x24\x63\xf1\xf7\x39\xe9\x07\xa1\x0c\x7d\xd6\x8f\x49\x58\x01\xf5\x99\xbf\x3a\xd4\x1a\xbb\x84\x9e\x37\xf1\xdd\xf8\x2b\xc8\x93\x37\xe8\x22\x05\x33\x98\x26\xc6\xbd\xbf\xa8\x42\x7d\x13\xdc\xc3\x9c\x7f\xe2\xfc\x75\x2b\x70\xfb\x57\xaf\x00\xbf\xcb\xb5\x08\xfb\xb0\x85\x24\x85\xb0\x24\x0d\x8f\x0c\x88\xef\x9c\x2f\x35\xb6\xcd\x7f\x1a\xda\x83\x31\xfb\xe5\xf1\x4f\xc7\xaf\x5f\x5c\x9d\xbf\x7b\xc3\xc6\x6b\x10\x8c\x38\x35\x5c\x62\xa8\x1c\x06\xa1\xfb\x91\xda\x92\x30\xdc\x5d\x93\x10\x16\x92\x15\x46\x5f\x3f\x85\x5c\xa0\x94\x5e\x10\x80\x15\x43\x17\x25\x4b\x10\x58\x43\x68\x6b\x0b\xdd\x0c\x09\x9c\x11\x0d\xf1\x35\x81\xc5\xa4\xcb\xae\x69\xaf\x21\x84\xc1\x0c\x79\x11\x7c\x8d\x41\x92\xeb\xc7\x22\x05\x13\x66\x3f\x2e\x3c\x39\x2c\x94\x91\x8a\x94\x35\xaf\xf3\x20\xaf\x39\xe4\xb5\x06\xdb\x02\x0b\x09\x2c\x41\x3d\xa4\x8b\x83\x25\x49\xf0\x15\xc5\x52\x34\xc4\x3a\x64\x29\x22\xb3\x31\x28\x73\x89\xcc\xc6\xa0\xcc\x9f\x53\xca\x62\x50\x96\xa8\xc1\x0c\x0c\xca\x52\x14\xf8\xce\xd9\x02\x54\x20\x27\x03\xb2\xa4\xa4\xb2\xe7\x84\x8b\x6a\xf9\x5a\xf6\x9c\x72\x61\x52\x6b\x86\xcd\xa8\xa5\xa6\x02\xfd\x90\x78\x49\xf1\x67\x4e\x93\x57\x45\xef\x98\x1f\x31\x2f\x31\xb3\x12\x1c\xc1\x32\x80\xfe\xdd\x64\x77\x0e\xe0\x67\x30\x89\x95\x60\xf1\xc9\x57\x23\x6c\x60\x56\x0e\x9f\x97\xa8\x10\x43\x47\x15\xab\x56\x16\x29\x6e\x84\x7d\x52\xed\xc2\x86\x66\xe6\x36\xb2\x33\x3f\x43\xb7\xd0\xe7\x59\xf1\x30\xdf\x51\x3f\x54\x0b\xa9\xc2\x76\xe0\xd6\xc4\xc9\x49\x17\x55\xfe\xd1\x6e\xee\xb5\x7a\x8e\x12\xf8\x5f\x36\x98\x35\x69\x08\xbf\xbe\xf5\x8f\x7e\xbf\x5f\x51\xc7\x97\x0b\xd8\xc8\x32\x68\xe1\xa3\x45\x2f\x98\xf9\xec\x88\x30\x3a\x8b\xf8\xb1\x60\xcd\xa4\x99\x8d\x1c\x0d\x6b\x76\x1a\x0d\xa3\xb2\xf0\x26\x97\xf6\x0e\x17\x9b\xb1\x6f\xcb\x9d\xf6\xec\x9b\x75\xf4\xe9\xce\xd4\x85\x4d\x39\xe0\xc5\x3d\xfa\x74\xb7\x76\x97\xb4\xf4\x80\xc4\xe2\x49\x76\x06\xa2\xe0\x2a\x24\xfd\x36\xdb\x00\x66\xa7\xf2\xfc\x7e\x20\x0d\xd6\xf7\xf3\xe5\x1e\x3a\x44\x69\x3b\xe8\x53\x2d\x4a\xdb\x3b\x87\x74\xe7\xae\xfd\x21\x95\x15\x82\xb4\xfc\x7a\xa2\x69\x26\x91\x78\x8d\x2e\x52\xf0\x6f\x11\xdd\xc3\xbe\x73\xe6\x7e\x24\x32\x5e\x04\xc8\xfc\x6c\x97\x46\xca\x80\x53\x51\x43\x45\xd2\xa0\xdf\x8f\x48\x2c\xd3\xb0\xcf\x83\x35\xb9\x21\xcd\xae\x66\x72\x2c\x31\xf8\x64\x3b\xee\x20\x41\x71\x6c\xa1\x51\x2e\x71\x8f\x82\x66\x86\x09\xa0\xd4\x41\xf7\x02\x8f\x77\x78\xa1\xe2\xc1\x0e\xdf\xa2\x76\xfb\xa8\x2a\xaa\x74\x78\x88\x54\xf3\x5f\x75\x1e\x90\x7a\xbf\x74\xbb\xf8\x03\x23\x4f\xf0\x78\x84\x63\x72\x14\x04\xa1\xe3\xfa\x38\x26\xa7\x7d\x40\x8f\x01\x4e\x3f\x21\xac\xbc\xe0\x41\x31\x55\x83\xae\xa2\x4a\x96\x6c\xed\xae\xfc\xc5\xaf\x3f\x74\x91\x2a\xdb\x2e\xfb\x03\x98\xcd\x82\xf5\xc2\x09\x3e\x0f\xf4\xb6\x5a\xab\x42\xdb\xd4\xd0\x53\x06\x40\xc4\x1f\x12\xd5\x23\x70\xe7\xc6\xe2\x92\x32\xb8\x09\x90\xba\x00\xae\x5f\xed\x16\xa7\x2b\x26\xbc\x16\x21\xe8\x42\x73\x66\x0e\x5e\x6f\x73\x79\x9d\x7e\x91\x86\x9c\x6a\x0d\x39\x5d\x45\x43\x9a\x44\x6c\x10\x30\x88\xf7\x4e\xdb\xf1\x4d\x36\x61\x53\x37\x73\xd3\x97\x6e\xd1\x9d\xc5\x87\x82\xda\xc1\x9a\x40\x0c\x69\xad\x0a\x58\x5c\x80\x05\xa5\x50\xc5\x77\x1f\x50\xc5\x1f\x50\xc5\x1f\x50\xc5\xbf\x20\xaa\xb8\xa4\x02\xcf\xd1\xf3\xdb\x7a\x6f\x55\x05\x2c\x05\x34\x9e\x26\xb6\x28\x2a\xf8\xbd\x60\xa9\x6f\xaf\x00\x4b\x7d\x7b\x39\x2c\xf5\xce\x3d\x62\xa9\x77\x56\x85\xa5\xde\x59\x01\x96\xfa\xff\x21\x6c\xf1\x7b\x05\x8d\x4f\x93\x5f\xa2\xb6\x69\x52\x0f\x40\xe7\x7f\x75\xa0\xf3\xfb\x06\xb5\x97\x17\x96\xef\x13\x8b\x7c\xfb\xfe\x21\xd5\x17\x81\x3b\x7f\xc0\x3b\x7f\xc0\x3b\x7f\xc0\x3b\xbf\x4f\xbc\xf3\x07\x30\xed\x07\x30\xed\x07\x30\xed\xaf\x0f\xa6\xfd\x2c\x24\xd8\x00\xa6\x4d\xbb\x31\x8d\x2a\xb5\xe1\x6b\x32\x46\xee\x07\x33\x9b\xb2\x54\x80\x99\x4d\xa3\x57\x88\x99\x4d\xc9\xfd\x4d\x31\xb3\x69\xd5\xca\x60\x66\x83\x08\x96\xc6\xcc\x2e\xc2\x69\x9e\x13\x13\xdb\x60\x30\xce\xc2\xc4\xc6\x21\xc1\x73\x60\x62\x5b\xa8\x87\x23\xf2\x52\x43\x5a\x4c\xa3\x3d\x27\xfb\xe6\x19\x94\x6c\x4b\x8b\x7b\xce\x49\x75\x25\x51\xb1\xb7\x3e\x03\x7b\x3a\x1f\x04\x9b\x2a\xa1\x7e\xaa\x26\x9e\xbc\x19\x41\xae\x93\x07\x17\x73\xa2\x67\x2b\xcf\x34\x96\x40\xc2\xd2\x78\xd1\x5e\x17\x99\xb1\xb8\x25\x26\xee\x02\x98\xdc\x29\xc9\x88\xa4\x45\xa0\xdb\x07\xf3\x09\x27\xc1\xf3\x5e\xb5\x74\x80\x9b\x3c\xf9\x68\xf8\xe0\x9a\x84\x16\xc3\x09\xd7\xd0\xae\xd9\x98\x6a\x46\xbb\xfe\xcb\x22\x37\xab\x29\x44\xcf\x4b\xd2\x88\x90\xfb\xc2\x77\x56\x86\x90\x99\x48\xcf\xff\x47\xc0\xc8\x32\x8d\x9f\x8f\x32\xaa\x3e\xbd\x6b\xcd\x78\x7a\xd7\x32\xa1\x91\xd1\x01\xbf\x3c\x10\x98\x69\x9b\xe3\x8b\xa3\x91\x2d\xc1\x04\x43\x23\x53\x8a\xff\xca\x70\x64\x52\xfa\xc5\x70\x64\x2a\xe0\x98\x1a\xac\x40\x8f\xa9\x6f\x0c\x05\x08\x99\x12\x56\x0c\x68\xb6\x38\x58\x99\x62\xfd\xaf\x1c\xb8\x2c\x73\x0a\xf1\x55\x81\xcb\xc0\x32\x5a\x06\xab\xec\x67\x79\x23\xe3\x2d\x3c\x2a\x2b\x18\xc0\xf4\xa4\x55\xec\x8d\x87\xd8\x34\x29\xe4\xa3\x14\x66\xc6\xf1\xb6\x1c\xc8\x0b\x46\x88\x76\x2e\xf4\xd1\x7f\xb5\xb7\xaf\xed\xba\x12\xaa\xf5\xa7\x88\xce\xbe\xbf\xc9\x1e\x75\xd1\xb8\xac\xdf\xaa\xdd\x9d\xf8\x8e\x12\xab\xbf\x19\xdd\x44\xcd\x54\x6a\xf1\xe2\x16\x04\x80\x9e\xa0\x57\x38\x1e\xd6\x71\x2f\xaa\xf2\x62\x36\x81\x9e\x36\x9e\x8c\xf0\xed\x3b\x74\xc8\x52\x8e\xf0\x2d\x37\xc4\xe1\xd1\x5d\x41\x2f\x37\x0c\xc9\xbc\x63\x71\x9c\x7e\xa1\xbd\xba\x35\xb3\xa0\x09\xde\xe7\xb7\xd4\x54\xfc\x0a\x39\x09\xaa\xac\xa4\x2a\x23\x13\x59\x10\x93\x0f\x88\x9a\xce\x67\x94\x86\x20\x36\x4b\x1e\x85\x12\x61\x97\x5c\x53\xec\xac\xb0\x87\xcb\x07\x98\xea\x95\x25\xde\xfa\xdf\x33\x6d\x7a\x2a\xbe\x65\xc4\x26\x4a\x3d\xcd\x9e\xf2\x3b\x7f\xec\x3f\xed\xe5\xa6\x0c\x15\x37\xa7\x41\x76\x1b\x02\xd6\x83\xe9\xfd\xe7\xcf\xa8\x59\x4b\x2f\x46\xf2\xfa\xf9\xaf\xfc\xa9\xc5\xcc\x5e\xae\x26\xcc\xef\xe3\xf9\xd8\x83\x99\x3e\xbe\x5d\xa6\x8f\x6f\x97\xec\xe3\xdb\xc5\x7d\xfc\x9d\xd6\xc7\xa7\xa9\x3e\xfe\xae\xb0\x8f\x6b\xa9\xe5\xa3\x79\x73\x27\x7f\xc7\x3a\xf9\xbb\x74\x27\xff\x6d\x85\x9d\xfc\xf6\x6b\x77\xf2\xdf\x72\x3b\xf9\x6f\x85\x9d\xfc\xb7\xfb\xea\xe4\xb7\x39\x9d\xfc\xb7\x2f\xd7\xc9\x1b\x5a\xf7\xe5\xba\xf0\x3d\x53\xae\xa7\xe2\x5b\x46\x6c\xa2\x34\xd6\x02\xef\xe5\x20\x25\x53\x77\xce\xf6\x7c\xf6\xb7\x6c\x37\x3f\xf2\xdc\xf1\xcc\x2e\x2e\x12\x99\xba\xb7\xbc\x80\xaa\xac\x36\xd4\x5b\xa8\xc8\x70\xab\x53\x3e\xe3\x2a\x86\x1e\x31\x8c\x2c\x25\x10\x47\x8c\x56\xc7\x0c\x29\xd0\x05\x71\x49\xfc\x55\x3d\x69\x66\xf5\xa7\x20\x9b\x18\x46\xc1\x7c\xf4\xc6\x14\xc4\x6a\xc7\x00\xb1\xaa\x81\xb4\x76\x32\x20\xad\x4c\x35\x32\x98\x8e\x9a\xa5\x6d\x02\x69\xed\x68\x20\xad\x3a\xca\xc7\x5b\xec\x0f\x74\xbc\x47\x08\x99\x03\xef\xef\x2b\x5a\xbf\x8b\x83\xa5\xaa\xa6\xf1\x32\x55\x5b\x25\x6c\xa9\x8a\x26\xf0\x29\x33\x2f\x66\xb7\x22\x93\x89\x35\xd9\x88\xcc\xaa\x4b\x16\x8e\x36\x07\x90\x16\xd6\x0d\xf4\x9f\x8a\x36\x9a\xae\xa5\xb4\xef\x11\xed\xde\x40\xb1\x18\x5b\xe1\xcb\xca\xee\x4b\xed\x08\xa4\x96\xbb\xb9\x72\x4c\x03\xfb\xe6\x3b\x7e\xd0\x50\x78\x73\x7a\xb2\x8e\xbf\xab\xa6\x32\x03\x0e\xe7\x40\x00\x97\x69\x50\x31\x22\x3c\xb4\xed\x37\xdf\xb6\xa9\xc3\x07\x68\xdd\x92\x4b\x7c\x3a\xc5\x95\x87\x36\xce\xa4\x5e\x10\xd9\x78\x29\x54\xb8\xcc\x22\x62\xc7\xb8\x88\x98\x0b\x3c\xce\xb8\x3d\xad\x63\x19\xef\x2c\x84\x65\xbc\xb3\x18\x96\xf1\xce\xbc\x58\xc6\x3b\xea\xae\x76\x16\x0a\x6f\x05\xc0\xc0\xea\x79\x97\x9e\xf6\x79\x66\xbf\xfd\xcb\x98\x0a\x79\xf7\x27\xff\xfe\xd0\xc0\xec\xcc\xf3\xff\x00\x34\xf0\xd6\x16\x9a\x8c\x1d\xaa\xc0\xb4\xa6\x31\x76\x03\x5f\x8b\x17\xd0\xc1\x52\x85\xff\xea\xe0\xc1\xc6\x85\xf9\x57\x01\x0f\x5e\x90\x93\xbf\x1c\x78\xb0\x50\x21\x65\x6c\x33\xc0\xe6\x7e\x99\x8d\x15\x73\x7b\xdd\x63\x73\x3d\x97\x4b\xd9\xcc\x91\xa6\xf8\x2f\x25\x9b\x02\x28\xe2\x1c\x58\xdd\x0c\x89\xa2\x1d\x9e\xdc\x5e\x9a\xf4\x53\x41\xa9\xa0\xa7\x66\xfa\x6a\x2a\x4f\xb6\x8f\x7c\x4b\xfd\xf5\x9b\xea\xb1\xf7\xd7\x67\x0d\xbd\xb6\xa8\xdf\x66\x7b\x6e\x2a\xbb\x09\x58\x39\xb5\x83\x93\x4c\x15\x96\xa6\x94\xb9\xa0\xe0\xd9\xdd\xc6\x95\xd8\x34\x68\xc5\x5b\x20\xc8\x00\x68\xb9\xdc\x76\x46\x4a\xf4\x59\xfc\x4c\x73\x91\x2b\x2d\x34\x1f\x4b\x13\x25\x78\x9a\xd2\x02\x3a\x52\x77\x7a\xb8\x12\x64\xa1\x35\x91\xb8\x0c\x24\xa1\xb7\xc5\x7e\x67\x5c\x4b\x25\xd4\xbf\x6b\xf7\x26\xdb\x55\x2b\x82\xbe\x23\xc6\xb6\xc1\x66\x49\x89\xed\x88\x65\x64\x55\xd4\x97\x0a\x76\x43\xd7\xf2\xc4\xb8\x00\x08\x39\x2d\x75\xe6\x9a\xb4\x10\x82\x3c\x1f\x24\xba\x04\xd0\x73\x66\xb1\xb9\x3b\xe7\x62\xd3\x08\x92\xac\xb0\xb8\x3a\xa4\x72\xe3\x02\xad\xa5\xad\xd0\xf4\x15\xc6\xdf\x08\xd8\x7c\x59\x72\x06\x3b\x68\x06\x56\x7a\xc1\x56\x48\x89\x83\x8b\xf2\x7d\x69\xe5\x98\xe9\x7b\xe5\x30\xd3\xf7\x0a\x31\xd3\xf7\x66\x5c\xdc\xda\x2b\x85\x99\xbe\x67\xc6\x4c\x57\x11\xcf\xf7\x0a\x11\xcf\xf7\x32\x88\xe7\x3a\xde\xfa\xde\x2c\xbc\xf5\xbd\x2c\xde\xba\x8e\x99\xbe\x37\x13\x33\x7d\x6f\x2e\xcc\xf4\xbd\x07\xcc\xf4\x72\x98\xe9\x70\xfe\xf0\xcd\x61\xa6\x7f\x0b\x17\xbc\x96\xc0\x4c\x9f\xcb\x36\x59\x06\x33\x7d\x4e\x23\xe8\x5e\x31\xd3\xe7\x38\xcd\xff\x52\x98\xe9\x4f\xd3\x73\x81\x62\xc0\xa4\xf3\x56\xe9\xb8\xfb\xf9\x73\xaa\x2b\xfe\xad\x91\xd1\xa9\x44\x8a\x91\xd1\xb7\xe7\x44\x46\x67\x56\xe4\x52\xc8\xe8\xe6\xa3\xa5\xe5\x90\xd1\xcd\x34\x57\x82\x8c\x6e\x46\x8c\xd0\x90\xd1\x39\x1e\xd7\x42\x54\x4a\xe1\xae\xce\xe2\x61\x91\x82\x39\x40\xe2\x22\x59\x19\x86\x79\xdd\x8d\xde\xb2\x27\xe1\xb0\xff\x3d\x0b\x1e\xfe\x9e\x24\xf0\xd7\x84\x87\x9f\x21\x5a\xab\x04\x3c\xfc\xb7\xaa\x51\xe5\xe0\xe1\xbf\x6d\xee\x4b\xc0\xc3\x7f\xdb\x15\x28\x01\x0f\xff\x6d\x57\x60\x26\x3c\x7c\x3e\xfb\xe5\xe1\xe1\x4b\xd0\x88\x62\x6c\x7f\xf8\x2a\x82\x5c\x62\x7c\x66\x6d\xc0\xe1\xe4\x4b\xe1\xdb\xcf\x18\x5e\xe7\x9e\x79\x0b\xf0\xed\xcb\xe2\xcf\xe7\xb2\x24\xe1\xe3\x4b\x01\xc4\xdf\xd7\xb4\x33\x13\xf0\x3c\x37\x6b\x09\xc0\xf3\xc2\xe9\x61\xa1\x8c\x09\x40\xfc\xd6\x16\x6c\x40\xc8\x87\xf7\x31\x3b\x0a\x9e\x81\x1b\x7f\x4f\x62\x5c\xb8\x3e\xcb\x08\x71\x89\xb6\x4b\xc4\xe8\x51\x03\xfe\x41\x62\x73\x48\x6c\x96\xbf\x88\x19\x1d\x1e\x34\x17\xdc\x44\xc0\x6d\xb1\x8c\x02\xcf\xf6\x9b\x31\xd3\x86\x2c\xf4\x9b\x91\xdc\x0c\xfd\x2b\x4d\x05\x00\xca\xcf\x2a\xc0\xef\x21\x2e\xd5\x04\xb3\xdd\x03\x14\x73\x52\x38\x97\xe4\xcf\x67\x65\xdd\x03\xcc\x92\x20\x50\x58\x6c\x9d\x36\x97\x7b\x80\x6f\x56\x0f\x16\xf3\x4c\x50\x3c\x18\xcd\xe5\x99\x60\x06\xa9\xf2\x38\xf9\x25\x1a\x6a\x2e\x1f\x07\x33\x55\xbf\xbc\x8f\x83\x12\xac\xcd\xe5\xe3\x60\x1e\x7a\xb3\x7d\x1c\xcc\x1c\x05\x17\xf4\x71\x30\xcb\x33\x81\xd1\x61\x80\x70\x0f\x90\x0a\x3a\x1d\x63\xdb\x8d\xa7\x5d\xd4\xa8\xef\x58\x33\xbc\x1a\x98\xdd\x13\xe4\xf8\x3a\xd8\xda\x12\x07\x2c\x41\x1f\x5e\x60\x67\x5c\x12\x80\x1d\x54\xe4\x1b\x21\xed\x06\x60\x31\x1f\x06\x66\xb3\xf9\x5e\x7d\x18\xa4\xfc\x09\x3c\xc7\x11\xf9\x95\x83\xd5\x2b\xd8\x2e\x6c\x83\x91\xc3\xb6\x83\xa4\x13\xd7\x02\x46\xdc\x7c\xb1\x55\xda\x53\xe8\x25\xf0\x11\x10\xc2\x0e\x66\xee\xe1\xde\x17\x50\x97\xe7\x8b\x7c\xd3\x53\x29\x96\x9f\xe2\xc0\x49\xc7\x64\x44\x42\xd7\xe6\x87\x56\x39\x70\xf9\xe8\x29\x3f\xe2\xe0\x78\xeb\xc2\x61\x80\x13\x8c\x30\xdc\x60\x56\xa8\x30\x2c\xf6\x3a\x8b\xaa\xb2\x6d\x57\x80\xc7\x50\x92\xb0\xd7\x47\xf0\x1a\x00\x38\xaf\xa8\xa0\x4b\x23\x7c\xab\xbe\xe1\x63\x84\x2e\x1a\x97\x16\x2f\xee\xa2\x79\xc9\x77\x76\x21\x35\x94\xcf\x52\xbb\x7e\x5e\xea\x35\x71\xfa\xa5\xb4\x06\x2d\xde\xc1\x31\x7e\xe5\xfa\x59\x7f\x00\x23\xd7\x4f\x76\x8f\xf3\xb3\xe2\x5b\x43\x56\x7c\x6b\x02\x5d\xa2\xd5\xfa\x1e\x35\xd0\x53\xf8\xd5\x4d\x3f\x52\xcc\xe3\xdd\x42\x8d\x04\x78\xa5\x44\x0d\x78\x69\x92\x16\xcb\x5b\xaa\x06\x7a\xd6\xe6\xa5\x2c\x36\x4b\xf3\x6f\xe7\x82\x63\xb6\x8f\x8d\x62\x1f\x1d\xb0\x1f\x92\x72\xc0\xa1\x84\xa9\x54\xc0\xac\x38\x01\xcc\x7f\x95\x58\x12\x2c\x13\xdf\xb3\x5b\x8f\xe4\x04\x96\x32\x8a\x0e\xb5\x4a\x3c\x7e\xac\x7e\x0a\x9c\x4d\x9e\x47\x1d\xd3\x00\x0a\x4c\x1d\x37\x8d\x63\xa5\xc8\x99\x3c\x03\x64\xf0\x9a\x2b\xf5\x2d\xa2\x5d\xab\x85\xb3\x6e\x5e\x37\xf5\x9a\x02\x4b\xaa\xd4\xed\x22\xd5\x28\x1b\x48\xbd\xc3\x99\xba\x71\xfa\x15\xdc\x98\xb0\xaa\x14\x5c\x3e\xc9\x87\x61\x97\xfe\x32\x74\xbc\x16\x56\x85\x0b\xd9\x8a\x16\x0b\xbb\xcc\x7d\x57\x9d\xb4\x1a\x80\x97\xca\x9b\x00\xca\x28\xf7\xe0\x6c\x45\xe5\x79\x96\x03\x13\x3a\xb2\x17\xf8\x5b\x81\x81\x5f\x6f\xb0\xaf\xed\x72\x45\xe7\x38\xe3\x75\x45\xe5\xf8\xff\x92\xe3\x15\x31\x1a\xa6\x2e\xf6\xeb\xc3\x0f\x3b\x18\x87\x2e\x24\xfa\x82\x92\xa7\x0c\x3a\x83\xa9\xe3\xe4\xdb\x6a\x02\xb0\x40\x6f\x27\x08\xa5\xe3\xba\x82\x78\x74\xd1\xb8\xd4\x55\x7a\x86\x01\x38\x83\x14\x92\xe0\x4b\x29\x7d\x64\x26\x0c\x1b\x56\x4a\x8c\x14\x8a\x74\xd4\x62\x13\xd3\x56\x21\x97\xc9\x71\x9b\x9f\xa3\x9c\xab\x1c\xc3\x5b\xe7\xf4\xbb\xcb\x64\xd3\x48\x0c\x8d\x69\x87\x3a\xdc\x3a\xd2\x00\xa0\x34\xdb\x28\x18\x33\x4c\xda\x71\x02\x6f\xc7\x91\xb4\x78\x52\x65\x36\x2b\x86\x09\x34\xdd\x3f\x71\xa3\x5f\xb1\xe7\x3a\xe2\x02\x0a\x2b\x4c\x4e\x03\x49\x21\x73\xde\x6a\xf1\x02\x9f\xe8\x34\x45\x05\x52\x0d\xbc\x04\xa8\x61\x1e\xab\x2c\xa2\x9a\x29\x6e\xc9\x2a\x95\x7c\x4c\xac\xfb\x16\x98\xfd\x94\x58\xbc\xae\x2f\x46\xce\xaa\x30\x68\x95\xb4\x9d\x0d\x55\xb9\x07\xc7\x4c\x02\x91\x36\xe5\x98\x69\xef\xc1\x31\xd3\x83\x63\xa6\x6f\xc3\x31\xd3\xfd\x38\x2a\xca\x16\xb0\x1a\xe7\x4c\x4b\x39\x2a\x6a\xdf\x8f\xa3\xa2\xf6\x0a\x1c\x15\xb5\x97\x73\x54\xb4\x7d\x8f\x8e\x8a\xcc\x7e\x60\x17\x72\xc6\x34\x5e\xda\x51\x51\xe7\x1e\x1d\x15\x75\x56\xe5\xa8\xa8\xb3\x02\x47\x45\x3b\xf7\xeb\xa8\x28\x4d\x7e\x29\xb7\x4c\xab\x70\x54\xb4\x2b\x66\xfb\xb7\xc4\x8e\xb1\x3f\xf0\x0a\x9c\x15\x2d\xd8\xbe\x7b\xf7\xef\x4e\x68\xff\xea\x0a\x9c\x25\x3c\xc7\x05\xb4\x1b\x8b\xfa\x2a\x6a\xa8\xf7\x76\x8f\x88\x97\x3f\x57\x37\x1b\x8b\xfa\xf7\xf9\x3b\xfa\x43\xba\x47\x5f\x45\x26\x0f\xd0\xab\x76\xb9\xb4\x88\x3f\xa4\x07\x77\x48\x0f\xee\x90\x1e\xdc\x21\x3d\xb8\x43\x7a\x70\x87\xf4\xe0\x0e\xe9\x6f\xed\x0e\x89\xd9\x0e\x08\xa3\x41\x18\x4c\xc6\x28\xe8\xa3\x1e\x0e\x0d\xfe\x91\xa0\x63\x3f\xc7\xe5\x90\x57\xbe\x9c\x7f\xa4\xe7\x38\x2c\x70\x8f\xf4\x1c\x87\x2b\xf4\x8e\xf4\x1c\x87\x7f\x53\xe7\x48\xcf\x71\x58\xc6\x37\x12\x15\xc0\x3d\xb9\x46\xe2\x7e\x66\xe6\xf4\x8d\x64\x30\x50\x67\xf9\x46\xea\xe1\xb0\x94\x6b\x24\x07\xc7\x38\xdf\x1d\x12\x20\x0b\xd0\x3c\x5d\x38\xfb\x5c\xc2\xb9\xd1\x9c\x3e\x8a\xd4\x4c\x63\x83\xf3\xa3\xea\x0c\x46\x8a\xbc\x09\xcd\xeb\x11\xa8\x90\x17\xcd\x83\xcf\x12\x9e\x7b\x60\xd0\x42\xe8\x09\xe2\x57\x36\x50\x3c\x24\x4c\xe6\x41\x1f\x11\x6c\x0f\xd9\xc0\xc5\xd2\xfc\x6b\x8c\x43\x3c\x42\x9f\x98\xe6\xdc\xf1\xeb\x1b\xec\xee\x1a\xed\xb2\x34\xaf\x5c\x9d\x99\xb3\xb8\x31\x19\x89\xd3\xa5\x67\xbe\xb4\x37\x68\x69\xcf\xe9\xc0\xa8\xe6\x81\xce\x7d\x47\x07\xcc\x37\x41\xe4\x82\x38\xd1\xf9\x90\x88\xbb\x0d\xd8\x77\x50\xe4\x7e\x24\x92\xd3\x5e\x9a\x80\x28\x94\xdd\x25\x61\xff\x9d\x0f\x53\x37\xa2\x69\xf6\xdb\x4d\x7c\xeb\x46\xe6\xcc\xd3\x59\x99\xa7\x86\xcc\x9c\x75\xf5\xfe\x04\x64\xe6\x01\x52\xc2\x98\x32\x0d\x42\xe1\xf9\xd9\x98\x23\xf2\x8b\x7b\x34\x90\x1e\x52\x6c\xad\x65\xfc\x2d\xc1\x18\xfd\x97\x75\xb7\xe4\xf0\xab\x2c\x2c\x11\xfd\x5a\xbd\x13\x25\x18\x6c\x4a\x3a\x4e\x92\xfb\x3b\x85\x38\x17\x32\x95\xe9\xd4\x4e\x48\x29\x14\x89\xb2\x00\x6f\xc5\x27\x62\x99\x1d\xdb\x99\xe7\x77\x6c\xba\x4a\x8a\x9b\x8f\xf6\x8c\x53\x3c\x84\xee\xe7\x24\x2f\xcd\x74\xe6\x3c\x0f\x99\xae\x9e\x2c\x51\xcd\x92\x27\x7b\xa6\xbd\x3e\xe3\xf9\x5e\x8a\xd3\x14\xa6\x83\x64\x74\x06\xa0\x8a\x2c\x25\x2a\x09\x12\x6f\xca\x90\x9a\x50\x8b\xdd\x79\x41\xed\x74\x50\x7d\x08\xd2\x12\xf5\x70\x44\xca\xfb\x9b\x32\x6d\x34\x2d\xe2\xf4\x4a\x17\xa1\xc3\x2f\x9e\x39\xf9\x57\xbf\xd2\x8e\xa7\xc6\x19\xaf\x53\x77\x56\x52\x17\x05\x47\x4e\x5c\xf9\x30\x7b\x6e\x5a\x42\xb1\x4a\xc1\x55\x98\x36\x7b\x67\xe0\x6c\x19\xfd\x68\xe5\x80\x45\x53\x33\x4c\xea\x5f\x45\x49\x5f\x0a\xd3\xda\xdc\x98\xec\x6e\x71\xdf\xf5\x62\x12\x1e\x5f\x53\x9b\xf9\xb4\x7f\x34\x74\x3d\x6e\x03\x72\x67\x57\x63\x4d\xcc\x6e\x0a\xd9\x3a\xd1\x7c\xce\x1b\x73\xff\xa5\x32\xa8\xc1\x9e\x71\xa2\xe9\x41\x17\xb4\x55\xf4\xbf\x04\x05\x43\x75\xa0\x55\xb2\xcb\x95\x47\xa2\xce\xc9\x63\xf2\xa1\x57\x80\x43\x5d\xe0\xa5\x4e\x9d\x08\x5b\x30\x13\x66\x71\xbe\x95\x04\x59\xc0\xef\x7c\x0c\xa0\xd6\x42\xf8\xd3\xad\x85\xf0\xa7\x5b\x8b\xe1\x4f\xb7\xe6\xc5\x9f\x6e\xe5\xe1\x4f\x8f\x93\xf5\x86\x82\x3b\x24\x42\xe7\x80\x8c\x9e\xa3\xab\xcf\x7f\x92\xf5\xf7\x87\x8c\x86\xa5\xe0\xdf\x02\x31\x5a\x00\xf6\x72\xad\x2a\x98\x8d\x4c\x48\xb2\x29\x60\x58\x71\x99\x5a\xfc\x96\x00\xb1\x5a\x26\x01\x3d\x3b\x1b\xab\xb7\x1c\x6a\xac\x71\x29\xbf\x14\x6a\xec\x62\x88\xb1\x0b\xf2\xa1\x21\xc6\x16\xf3\x21\x3c\x74\xdd\x1b\x2f\x1c\x99\x89\xf1\x03\x1f\x33\x79\xfa\x59\x00\xb8\xdd\x1b\x53\x1c\x11\x8e\x73\xc5\xbe\xb2\xe0\xba\x45\xc0\xba\xa9\xa4\xc8\x08\xb4\x9b\x49\x64\x00\xde\xcd\x26\xe2\x90\x56\x99\x56\x32\x26\x16\x88\x57\x59\xf9\x65\x01\x53\x67\xe0\xf3\x96\xba\x82\xae\xb6\xd9\xd5\xdc\x20\xd8\xf3\x37\x57\x23\xd3\x48\x59\x3e\x00\x0d\x30\x83\x7b\x3d\x47\x63\xa2\xc4\xeb\x29\xda\xd0\xca\x43\x9b\x48\x85\x15\x9b\x25\xc2\x85\x90\xc1\x97\x10\x8a\xa9\x3f\x81\x97\x4b\x13\x10\xf8\x5a\x69\x71\x08\x50\xb5\x54\x75\xef\x74\x22\xab\x35\xfe\x57\x6c\xfe\x1b\xf1\x96\x55\xb4\x5c\xe3\xb2\x50\x4c\x5b\x4b\x62\xe2\x26\xb4\x4b\xda\xc8\x46\x20\xd0\x7c\x57\xac\x9a\xf1\xdb\xce\x18\xbf\xf9\x96\x6d\xbb\x18\xec\xb6\xac\x2d\x98\x8b\x37\xab\xad\x40\xd3\x58\xb3\x40\x79\x49\x1c\x58\x78\xb4\x05\xe4\x67\xe1\xbf\xe6\x2e\x40\x4a\xa0\xbf\xe6\x6f\x19\xcc\x68\x78\x71\x5d\xa8\xb0\xd9\x45\x22\xa5\xd1\xe1\x44\xb3\xc0\x43\xf8\xbd\xb8\x00\xcf\x77\x03\xaa\xe9\xd7\x76\x46\xbf\x74\x0c\xd7\xed\x59\x18\xae\xdb\x59\x0c\xd7\xd4\xf2\x6c\xdb\xb0\x3c\xb3\xe9\x5a\x39\x24\xbe\x92\x48\x04\x69\x0b\x45\xc2\xa5\xc9\x6f\xaf\x2f\xba\x5c\x77\xf9\x72\xdd\x77\x60\x91\xfe\x7c\x7a\x3e\x1d\xf3\x17\x33\xa2\xd8\x22\x80\x04\xed\xaa\x98\xe9\x70\x51\x7f\x8c\xa6\x32\x3d\x4f\xc3\xc9\x77\x8a\x46\x0f\x8e\xe8\x29\xb4\xdc\x45\xe3\x52\xcc\x5e\x5b\xa8\x85\xba\x32\x90\x21\xe7\x6e\xa1\x96\x64\x26\xb9\x34\x83\x63\x0c\xb8\x95\x3f\x06\xe1\x08\xc7\x31\x09\xab\x32\x28\x79\x51\x97\xe5\x54\x35\x0b\x6e\xbb\x09\x19\xdd\xab\xf8\x54\x8d\xd1\x1c\x8b\xf3\x1e\x92\xc4\x66\x1c\x89\x83\xa8\x7e\xc5\xde\xe2\x8f\xa2\x0a\xdf\x0c\x1a\x6a\x99\x0c\xf7\xf3\x7b\x26\x9d\xb9\x5f\xac\xb6\xbc\x6a\x46\x3a\xf2\xf8\x2e\xa9\x3c\x07\x1a\x4b\x75\x2f\x0e\x61\x96\xea\x53\x79\x8e\xcd\x98\xc6\x74\xf9\x5f\x4b\x2b\x4f\x6f\xf0\xae\x21\xac\xec\x0e\xd1\xfc\x28\xd7\xf9\xde\x37\x35\x94\xeb\x4e\x16\xe5\x5a\x1d\x9b\x3a\x99\xb1\x29\x0b\x62\xdd\x31\x83\x58\xeb\x83\x58\x67\xd6\x20\xd6\x31\x0c\x62\x2a\xd2\x75\x27\x83\x74\xad\xa2\x64\x77\xd2\x28\xd9\x3a\x88\x75\x67\x26\x88\x75\x67\x2e\x10\xeb\x8e\x11\xc4\x9a\xe7\x52\x31\xac\x1d\x31\x25\x2b\x13\xf6\x17\xc5\xaf\x2e\x89\x47\x6d\xbe\xcc\x5d\x4d\x1d\xa5\x7f\x7b\x70\xd4\x2b\xd9\x13\x9b\xdb\xfa\x5d\x15\x1a\xf5\x5c\xf6\xfb\x32\x68\xd4\x73\x2e\x14\xee\x15\x8d\x7a\x36\x2f\xf7\x8e\x46\xfd\x2d\x1e\xa7\xcc\x7b\x8a\x92\x76\x46\xb3\x8c\x0b\x60\x75\x09\xaa\x8d\xb0\x26\x8b\xbd\xaa\x48\x36\x49\xac\x24\x4d\xcc\xef\x6f\x1c\x8d\xdb\x51\x16\xa2\xf9\x58\xdc\xcf\x71\x58\x0c\xc5\xdd\x9e\x13\x8a\x1b\x96\x2f\x4b\x21\x71\x9b\x2d\xec\xe5\x90\xb8\xcd\x34\x57\x82\xc4\x6d\x7e\x12\xa5\x21\x71\xcf\x06\x01\xcc\x25\x22\xe0\xaf\xa4\x95\x6e\x69\x3b\x6b\xa5\x71\x75\x8b\x0b\x98\x85\xfd\x96\x9b\x7b\x36\xf6\xdb\x0c\xf1\x94\x46\x36\xfe\x0b\x54\x60\x31\xf6\xcb\x03\x03\x97\xa0\x51\x02\x18\xf8\xdb\x16\x64\x0f\x87\x0c\x3c\x62\x71\x16\x4a\xa0\x94\xdf\x93\x0c\x66\xa3\x4c\xcf\xe0\xbd\x1c\x4a\xf9\xb7\xcd\x7d\x09\xb7\x03\xdf\x6a\x05\x16\xca\x6a\x74\x3b\x50\x0e\xdf\x7a\xc6\xa8\x3f\xf7\x7c\x56\x80\x6f\x3d\x72\x7d\x58\x9b\xaf\xa0\x73\x8d\xf0\xed\xf3\x95\xf4\xd2\x59\xd0\xbb\xb9\x24\x24\xd6\x36\x5c\x4d\xf9\x0a\x9a\x36\x0b\xee\x38\x37\x23\x87\x3b\x4e\x7a\xca\x42\xcc\xcf\x06\xad\xcd\xef\x23\x65\x41\x6b\x4b\xb4\xdf\x0c\x14\xa6\x52\x14\xf8\x92\x67\x49\x2a\x62\xa9\xb4\x24\x99\x10\x3b\xee\x64\xc1\x29\xf8\x6b\x4d\x9e\x0a\x94\x72\x09\x08\xe0\x6f\x8f\xff\x25\x06\xed\xa5\xd0\x83\x8b\xfb\xf6\x5c\xe8\xc1\x33\x48\x95\x47\x0f\x2e\xa1\xa4\x73\xa1\x07\xcf\x18\x40\xe7\x41\x0f\x2e\xc1\xda\x5c\xe8\xc1\xf3\xd0\x9b\x8d\x1e\x3c\x73\xf9\x74\x4f\xe8\xc1\xa5\x11\x80\xd9\x9e\x4f\x66\x1e\x6e\x64\xa0\x7b\x99\x27\x04\xfe\x60\x81\xbd\xb1\x60\xd3\x04\xc3\x01\x16\x2b\x49\x65\x3d\xb8\x30\xd8\xaf\xd9\x86\x58\x0e\xec\x77\xbb\x10\xeb\x17\xfa\x42\xb6\x93\xca\x0d\xff\xec\x93\x1b\xf4\xe9\xce\xd4\x17\x4d\x39\xe0\xc1\x10\xfa\x74\xb7\x7a\x74\x54\x97\x23\x5b\x41\x0c\xfd\x48\x60\x4b\x93\xc7\x32\x09\x72\xa9\x0c\x2b\x8d\x6e\xfa\xb5\xe1\x57\xbf\x4d\xf8\x54\x89\x4d\x5a\xee\x52\xbc\xf9\xf4\xae\x2f\x0f\x66\x45\xab\x9c\xf6\x9f\x63\x09\xd6\x9c\xb4\x15\xb4\x72\x4d\x60\x07\x3e\x1a\x07\x51\x0a\x98\xf7\xe2\x52\x43\x6e\xce\x81\x75\x15\x57\x9b\x62\x32\xfa\xa7\x50\x29\xfa\xa1\x6b\x94\x02\x67\x9b\xa4\x4c\x83\xda\xaa\x47\xd8\x4a\x2a\x79\x9e\xcc\x93\xa9\x23\x4a\x2a\xa9\x1a\x75\xb0\x12\xc8\x69\xa1\x15\x02\x79\x5a\xd5\x9c\xa7\x05\x38\xd4\x7c\x2b\xd6\x84\x60\xbb\x68\xcb\xfe\x21\xce\x65\x25\xf4\xad\xd2\xb2\x9f\x58\xb3\x74\x05\x10\x9c\xc2\x59\x57\x93\xc0\x9d\xc4\xc6\xb5\x89\xe7\x2d\xf3\xfc\x62\x28\x35\xed\x99\xe7\xcd\x7b\x01\xc0\x04\xe7\x92\x7b\x0f\x40\x3c\x77\x5a\x0d\x60\xaf\x72\x60\x6c\x08\x9b\x1a\xc2\xc4\xe9\x63\x3a\x5c\x1e\x3a\x66\x90\x80\x15\x35\xc9\x82\x01\x2f\xaa\x00\xcf\x41\x3a\x71\x38\xf1\x6d\x1c\x93\xe7\x53\xae\x94\x20\xf3\x12\x00\xc3\x96\xae\xcc\xb5\xbf\x0c\xe0\x70\x3e\x9c\xda\xa2\x80\xc3\xfc\x70\x40\x36\xd7\xcc\x6b\x9c\xb7\x4b\x88\xe4\x43\x1e\xc8\x6c\xd2\x79\x25\xef\xd8\x74\x83\x21\x0b\x24\x2c\xa3\x0c\xd8\xb3\x99\xab\x0c\xe3\x20\xaa\xa7\xaf\x33\x68\xf8\xb4\x32\x54\xc5\xa9\x4d\x5d\x65\x60\x1d\xc3\x88\x1c\x2c\x12\x88\x5e\x42\xcb\x8b\x60\x00\x4e\xf5\x92\x6c\xee\xc6\x65\x0d\x6d\xe6\x51\x55\x94\x03\x30\xeb\x71\x2f\xaa\xaa\x03\x7c\x0d\xfc\xae\x3f\x7e\x8c\x64\x2c\xbf\xf3\x8a\xbe\x47\xe6\x0c\xe9\xd7\x5c\x0e\xf1\x60\xaa\x5e\xf0\xce\x29\x1b\x00\x47\x38\x1e\x9e\xb9\x03\xde\x0f\x79\x65\x3f\x7f\x46\x3a\xab\x4f\x72\x2b\xb1\x99\xe1\x5f\xbd\x36\x3a\x45\x9b\x87\x8c\xcf\x83\xf4\xb0\xb3\x91\x8a\xb8\x33\xf5\xe7\xdb\x14\x42\xad\x94\xbb\xda\xac\x5f\x4e\xb3\xa7\x46\xcd\xce\x1a\x68\x5f\x54\xb3\x85\xe2\x1a\x51\xa6\xd1\x66\xb1\xfc\xa4\x76\x27\x6a\x3f\xbf\xe2\xb2\x7b\xc9\xa5\xf5\xf6\xea\x1e\x14\x97\x09\x61\x31\xbd\x65\xec\x2b\x17\x7f\x19\xb1\x8d\x43\xce\xa9\x71\xdc\x2d\xf1\x5a\xe0\xb6\x8b\x6e\xe1\xb2\xc0\xb4\xf8\xaa\x80\x25\x41\x5e\x34\xeb\x8c\x4d\x04\x1c\x60\xfb\xa2\x29\xcf\xe7\x4d\x18\xdb\x16\x37\x87\x1e\x3f\x66\x3f\xf8\xbb\x99\xf4\x77\x5d\x81\x03\xd6\x8e\x95\x15\x7c\x67\xb6\x7c\x05\x7b\x25\x0d\xe4\x9c\x81\x6d\x5e\x29\xdc\x2e\x87\x38\x49\xa1\xed\xee\x3f\xa0\xed\x3e\xa0\xed\x7e\x1b\x68\xbb\x80\xf4\x9f\x87\xe5\xb9\x20\x96\x62\x9e\x23\x81\xe5\x90\x76\x81\xd4\x03\xce\x6e\xd1\xa6\xe3\xdf\x1a\x67\xf7\x5e\xe1\x67\xd3\xe4\x97\x02\xdb\x5d\x05\xfc\xec\xce\x3d\xe2\x0a\xef\xac\x0a\x57\x78\x67\x05\xb8\xc2\xbb\xf7\x8f\xbb\xfa\x65\x70\x76\xef\x1d\x76\xb5\x71\x75\xf5\x3f\xd4\xec\x2d\x90\xcf\x12\x20\xbb\x0c\x00\xe5\x68\x12\x5e\x17\x00\x1d\x2f\x4a\xbf\x25\xe8\x9f\x4d\x47\xbd\xa0\x48\x38\xfb\x0b\xe2\xbb\x53\xab\xfa\x1e\x91\x8e\xb7\xbf\x00\xd2\x71\xe7\xfe\xd1\x81\x77\x1e\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x67\x21\xf7\x46\x36\x3c\x21\x8c\x4c\xf0\xbd\xd0\xbd\xcf\x58\x82\x32\xdb\x7e\x26\x3b\xf7\x7e\x20\x7c\x39\x53\x05\x30\xbe\x3c\xc5\x0a\xa1\x7c\x39\xc5\xbf\x29\x9c\x2f\xaf\x5d\x19\x48\x5f\x21\x88\xe5\x61\x7d\x99\x83\xed\x13\xb6\x4b\xbe\xd9\xb4\x4a\xe1\xfc\x4a\x18\xcc\x37\xc2\x9b\xaa\xe2\xc0\x1a\x82\x66\x60\xf0\xbe\xd1\x3c\xe1\x7d\x59\x1c\xde\x2f\x85\xb1\x3b\x2f\x2a\xb2\xc1\x30\x9f\x85\x8a\xcc\x47\x0e\x8e\x8c\xfc\xe5\x90\x7a\xb3\x10\xb8\x65\xe1\x6f\xb3\xf8\xb7\x65\xb1\x6f\xd1\xa7\x33\xb8\x3f\x79\x27\xaf\x94\xd0\x9c\x4c\x32\x60\xb8\x03\xec\xad\xca\xab\x78\x79\xcf\x41\x6f\xcb\xa1\xde\xca\x61\xed\x2f\x8b\x7c\x2b\x3d\x1c\xf3\x64\xec\x7b\xa5\xe8\xb7\xac\xfb\x8a\xae\x5e\x12\x01\x97\x2d\xca\x4f\x62\x32\x2a\x7c\x04\x9f\x24\x2b\xc2\xc0\x8d\x20\xd5\x97\x01\xc0\x95\x65\x2d\x81\x66\xf0\x65\xd1\x6f\x25\xc7\xe5\xa0\x6f\x17\xad\x60\x49\xdc\x5b\xc3\xbe\xcc\x1c\x6e\x2d\x63\xb8\x56\xca\x2a\x22\x9c\x58\x22\x03\xd4\x04\xab\xc4\x0c\xf8\x05\xce\x40\x49\x40\xdc\x4c\xea\xcc\xe4\x56\x8c\x87\x3b\x0b\x9a\x53\xe0\xe5\x0a\xe0\x49\x06\x3f\xaa\x76\x7b\x98\x9c\xcf\x52\xc9\x94\xd0\x6c\x62\x79\x61\x51\x4b\x0c\xa1\x8b\xc3\xf0\x9a\xf6\x1d\x97\x47\xe1\xcd\xf7\x47\x5c\x0a\x7f\x97\x37\x2c\x6b\x77\x86\xf7\x8a\x0c\x98\xbc\x7f\x43\x14\x5e\x31\xed\xb3\xaa\xcf\x0b\xc3\x6b\x6e\xcc\x55\xa2\xf0\xaa\x4d\xa2\x32\x97\x0f\xc1\xab\x0c\xfa\x9a\x1a\x1f\x1e\x22\x17\x3d\xd5\xfa\x41\x17\x2d\x8b\xd2\xcb\xbb\x75\x79\x88\x5e\x53\x86\x39\xf1\x79\xf3\x21\xca\x52\xd3\x75\x9b\xcf\xd7\x0b\xc3\x94\x19\xcd\x06\x1d\x80\xb7\xbd\x10\x00\x6f\x7b\x31\x00\xde\xf6\xbc\x00\xbc\xed\x22\x00\x5e\xb9\xe0\x48\xc1\xae\xbd\x49\x19\x39\x5f\x06\x70\x24\xef\x3c\xef\xef\x0f\xc2\x3b\x76\xc9\xdf\x13\x84\xb7\x70\x52\x2a\x01\xc3\xcb\x15\x94\x03\xf1\xb2\xaf\x65\xa1\x78\x8f\xe6\xbb\x84\x3a\x27\xc4\xab\x2d\xc1\x78\xed\xd9\x68\xbc\x47\xf3\xdd\x1a\x9c\x97\x15\x89\xc7\x6b\xcf\x06\xe4\xe5\xaf\x00\xee\x8d\x99\xc8\xfd\x48\x04\x3b\xf4\xf7\x92\xb0\xb7\x76\x0a\xf7\xf6\xe8\xd6\x08\x53\x6b\xa7\x90\x6f\x8f\xa6\xc6\x64\x11\x5c\x90\x4c\x8b\x63\x6e\x24\xdb\x85\x60\x58\xe7\x97\x67\xa3\x48\x8e\x85\x00\xab\xd9\x7a\x56\xe3\xda\xdf\x19\x6d\x35\xbb\xe6\x58\x11\xd4\x2a\x27\x5c\xc6\xd0\x31\xe2\xd0\xe5\x83\x60\xa6\x2c\x98\xed\xb9\x2c\x98\xed\xd9\x40\xab\x65\xe7\xfc\x5c\xb0\xd5\x71\x32\x26\xb3\xd1\x3d\x0d\xb8\xca\x4b\x58\x12\x72\x95\x51\xb1\x78\x21\xb3\x60\x57\xcd\x46\x65\x09\xcc\xd5\xdc\x55\xe9\x3d\x41\xae\xa6\xe0\xeb\x64\xfb\x15\xc1\xb0\x1e\xcc\x6c\x93\x95\x83\xb4\xe6\xe3\x24\xa6\xf4\xb3\x63\xd0\xcf\xe5\x31\x0e\x33\x28\xac\x9d\xd9\x28\xac\x4b\xac\xbd\x97\x7b\x82\xd5\x5e\x1c\x84\x35\x2a\xdb\x32\x05\x88\xa9\xef\x96\x84\x4c\xb5\xf3\x31\x53\xed\x62\xd0\x54\x2d\x76\x1e\xc0\x54\xd3\x95\x96\x95\x02\xa6\x16\x88\xeb\xb7\xaf\x26\xae\xdb\x6f\x56\x5c\xbc\xce\x9a\x66\xa6\x8c\x76\x78\xbe\x9c\xdd\x48\x72\xdc\x90\xd8\x7c\x61\x9b\x3c\x57\xad\xcb\xe0\x64\x3e\x59\x05\x8a\xad\x9b\x42\xaf\xe5\x43\xb2\xab\x2d\xfa\xe0\xd9\x40\xce\xa0\x94\x79\x13\x96\x87\x6b\x9b\xbc\x98\x57\x6a\x78\x78\x88\x2a\xb7\x15\xf4\x54\xc5\x3e\xee\x6a\x2f\xdd\xd2\x8c\x64\xa0\x6e\x0d\xc4\x0c\x2a\x8a\x4c\xa0\xb8\xef\x92\x06\x2c\xbf\x3b\xf3\xd2\xf5\x8b\x7d\xe4\xd1\x04\x46\x0b\x65\xa7\xec\x0c\xb0\x63\x98\x01\x3c\xd7\x27\x4a\x02\xfa\x99\x8e\x3e\x9f\x8e\xd3\x49\x68\x50\x3a\xd9\xbf\x29\x6d\x43\x5a\x19\xae\xfb\x4c\x63\x7b\x79\x5f\x7c\x2b\x36\xe1\xc0\x9e\x44\x71\x30\x7a\xc9\x6f\x23\xdd\x37\x13\x54\x12\x5a\xf1\x34\x40\x5a\x78\xe9\x77\xb6\x4c\xa2\x1c\xb1\xdc\x70\xd4\x93\x34\x0b\x55\xce\x3f\x28\x19\xcd\x05\x87\x46\x3c\x7f\x69\xaf\x2f\xc1\xc5\x78\x4a\x47\x51\xb1\x30\xb6\x12\xcf\x17\xf6\x34\x19\x8f\x34\xcd\x4e\x57\xca\xe4\x31\x4e\x6d\x6e\x75\x5c\xe8\xbb\x9e\xd7\x45\x15\x3f\x90\xca\x8f\x00\xad\x20\x0c\x3e\x90\xae\xae\x24\x8f\x1f\x6b\xdf\x75\x9a\x55\xb0\x60\xa5\x5b\x53\x2d\x63\xcc\x0f\xdd\x13\xa1\x28\x7d\x52\x11\xea\x52\xe7\x67\xd0\xbe\xe9\x26\xe0\x0d\xb8\xc4\x38\x0a\xfd\x31\x11\xeb\x6a\x4f\xd0\x8a\x78\xa6\x3f\xab\xb9\xe5\xae\xa2\x9a\x65\x4f\xd1\xd2\xb7\xa7\x67\x9f\xa1\x79\x8a\x16\xf0\x73\x34\x7d\x80\x2a\x38\x4e\xbb\xe7\x9d\xd3\xe5\xa0\x9a\xb3\x47\x21\x1e\xcc\x1a\x89\x17\x40\x43\xac\xba\x5b\x28\x5a\xab\xe4\xda\x79\x7e\xd4\xf6\xdd\x72\xa8\xed\xbb\x19\xd4\xf6\xd4\x54\xb5\x3b\x6b\xaa\xda\xcd\x4c\x55\x59\x60\xf7\xdd\x32\xc0\xee\xbb\xb3\x16\x3d\xbb\x33\x80\xdd\x77\x0b\x81\xdd\x77\x8b\x81\xdd\x77\x67\x02\xbb\xef\x72\x60\x77\x33\x3e\xfb\x38\x59\xc1\x6b\x6b\xfc\x79\xd6\x91\x25\x21\xd6\xcd\xef\x5a\xaa\x86\x7b\x39\x0f\x30\xeb\xbc\xef\x9a\xb4\x53\x05\x5c\xd7\xd5\x77\x05\xf8\xd7\x0f\x00\xee\x2b\xe1\xe5\xde\x01\xdc\x61\x28\x7b\xfc\x58\xdd\xde\x62\xe6\xbd\x82\x14\x50\x0c\x48\xfe\x2d\x9e\xe5\x7f\xca\x9b\x87\x22\xbe\x07\x9b\x8b\xce\x2e\x37\x60\xd7\xd2\xd2\xcb\xc7\x35\xe7\x37\xd6\x56\x8b\x6d\x7e\x26\x47\xb0\x25\xf0\xcd\xcd\xcb\x84\x22\x28\xf2\x79\x69\x95\x80\x4a\xff\xb4\xf6\x55\x61\xc3\x57\x04\x35\xfc\xf5\x60\xc3\x57\x54\x81\x8f\x7f\xf5\x0a\xd0\xa1\xea\x2b\x70\x0f\xf8\x95\x4b\x20\xa5\x2f\x0c\xe6\xb9\x34\xe6\xaf\x58\x9b\x2f\x85\x66\xd9\x77\xe3\xd8\xf5\x07\x15\x4b\xac\xee\x13\xda\x72\x19\xf3\x15\x5a\x45\xb0\xd7\xc3\x91\x1b\x51\xe6\xe0\xc7\x91\x17\x44\xc4\x91\x9f\xa7\x63\xe2\x2b\x18\x9b\xf2\x57\x92\xcc\xc7\xf1\x24\x64\x9e\x0e\x46\x81\x1f\xc4\x81\x4f\x7e\x53\x3f\xde\xa9\x1f\xf4\x77\x14\x93\xb1\xf8\xfb\x9c\xf4\x83\x50\x86\x3e\xeb\xd3\xe1\x1a\x46\xf4\xc5\x1a\x9c\x0b\xf6\x7e\xd1\xbc\xcd\xa3\x78\x01\x98\xf7\x6a\xfc\x52\xac\x21\xfd\x9d\xc3\x72\x60\xad\xc9\x65\xb4\xaf\xa1\x79\x5f\xbb\x5b\x7f\x2d\x20\x72\xd1\xe5\x6c\x37\xb4\x3d\x50\x7b\x3b\x0c\x22\xe8\x7c\x8e\x8b\x47\x81\x0f\x3d\x2a\xfa\x73\x82\x45\xa7\x60\x7d\x2e\x0e\x5d\xf0\x77\x43\x7f\xdf\x4c\xc9\xa2\x5d\x84\xcb\x60\xc9\xee\x25\xb6\xe0\x16\x85\x80\x5e\x1e\x09\xdd\x5e\x1e\x0a\xdd\x5e\x1e\x0b\x3d\x5a\x1e\x52\x1f\x21\x3f\x58\x10\x54\x5f\x95\xc7\xa2\xd8\xf0\xdf\x84\x0b\x11\xb4\x30\x30\xfd\x37\xc3\xfe\xc7\xbf\x26\xfb\x6c\x31\xc6\x6b\x21\x61\xc5\x16\xe9\xd6\xfe\x34\x41\x75\x5f\xde\x4d\xc4\x3d\x81\xa6\x2f\x0d\xe6\xfe\x00\xbf\x7e\x7f\xf0\xeb\x1f\xf3\xc1\xd8\xc5\x64\xa9\x99\xe3\xdc\x92\x36\xd8\xd1\xd2\x54\x4d\x61\xb1\xf3\x39\x5f\x25\xa7\x41\xb9\x2f\x0a\xcc\x6e\x36\x07\xef\x09\x97\x9d\xd7\x6d\x41\xd0\xf4\xc5\x80\xcb\x3f\x6a\x51\x1f\xd5\xa8\x5c\xa8\xf5\x79\xe0\xc4\xfd\x93\x98\x8c\x5e\x05\x93\x88\xbc\x24\xf8\x3a\x81\x5d\x4f\x47\x18\x32\x1c\xfb\xec\x49\x79\x26\x03\x44\xc8\x0c\x26\xc0\x72\x11\xb9\x3c\x2c\xbb\x04\x79\x2e\x0d\x49\x3d\xe7\x75\x28\xe5\x86\x47\xa9\x9b\x51\x06\x04\x1e\xf3\xfd\x28\x45\x2b\x5e\x24\x10\xe7\x73\x83\xd5\x55\x6b\x55\xb6\xf1\x2f\xef\xf5\x3c\xd5\x6e\xa5\x70\xd2\xfc\x16\x88\xf8\x16\xc5\x4f\x57\x50\xfc\xb4\x54\xf1\x53\x53\xf1\x1f\xf5\xe2\x3f\x8a\x63\x8a\x8f\xa6\xc4\xbc\xc4\xb7\xd8\x1f\x90\xff\x91\xa9\x9f\xf2\xc4\x21\x0d\x46\x45\x23\xaf\x02\x4c\x65\x72\x11\xa9\x8e\x99\x8c\x5a\xaa\xe0\xff\x01\xe4\x1a\x95\x87\xc7\x8f\xf5\x80\x8b\xc6\xa5\x6c\xd7\xe7\x89\x23\x03\x05\x04\x16\xdc\x19\xb0\x83\xab\xa7\xe6\x70\xc0\x7f\x6f\xc8\xf6\x51\xc8\x4c\x73\xc8\x18\xc3\x75\x32\xf2\x4c\x70\x11\x08\xf4\x5b\x74\xc8\x2e\x2e\x5c\xa8\xca\xca\x21\x0c\x80\x49\x99\x60\x6a\x4e\xf0\x11\x1d\x16\xdd\x8b\x2d\xd0\x2d\x55\x41\xc0\x1f\x28\x2b\x47\x0d\xbe\x44\x9f\x3f\xa3\xca\x66\x25\x29\x2e\x0e\x02\x2f\x76\xc7\x6f\x98\x51\x85\x0e\xd1\xc5\x27\xee\x27\x8e\x49\x9c\xfe\xa6\x99\xb4\x1e\x61\x71\x47\x78\x2c\x90\xfe\x06\xba\x15\x09\x10\x7b\x6b\xa5\xd0\x5f\xe1\xa4\x97\x13\x9e\x6a\x84\xa7\x26\xc2\xd3\x3c\xc2\xd3\x2c\xe1\x4b\x05\x0f\xfe\x23\xbc\xaa\xae\x6c\x2a\xd7\x52\xf4\x0a\xd6\xc7\x93\x68\xa8\xbc\xfa\x63\x1c\x7d\xd4\x38\xfa\x68\xe2\xe8\x63\x1e\x47\x1f\xd3\x1c\x19\xae\x5e\xf1\x51\xb7\xdc\xc3\x12\xf3\x6d\x3e\x2f\x0f\x03\xfa\xa5\xeb\x13\x1d\x04\x5a\x05\x37\x37\x80\x9a\x2b\x90\xcf\xb2\xe3\x59\x3a\x9e\x73\x16\xc7\x59\xd4\x06\xea\x51\xee\x55\xca\x8a\xea\x31\x2d\x51\x8f\xe9\xdc\xf5\x28\x7c\x06\x41\x57\xed\xf6\xad\x05\x4b\xef\xe4\xce\x26\x5b\x45\x4b\x0d\x93\x83\x29\x03\xac\xfe\x48\xc7\x10\x31\xf8\x89\x2c\x6c\xcd\xfc\x49\x03\x58\xfe\x48\x69\xc8\x13\x29\x5d\x3b\xbb\xa9\xef\x74\x2a\xee\x53\x84\x93\xe4\xf7\xa4\xec\x69\x42\xee\x7e\x21\x97\xd7\x98\x51\x93\x18\x3a\xdd\x8c\x4d\x64\xa9\x69\xc0\xb6\xe9\x66\xcc\x20\xbe\x8c\xd3\x40\x49\xd8\x5d\x90\xfb\xc3\x6c\x56\xb0\x6c\x74\xdc\xe6\x76\xa3\x08\xb7\x99\x13\x2a\x8f\xd5\x0c\x10\x44\x47\xc1\x78\x1a\xc2\xd1\x6c\xd5\xae\xa1\x56\xa3\xd9\xde\x1c\xb3\x4b\x7a\x16\xfa\x11\xdb\xa4\x17\x04\x1f\x2c\x74\xe2\xdb\xf5\x35\x04\x19\xce\x87\x6e\x24\xe0\xf2\xec\xc0\x21\xc8\x8d\x90\xe7\xda\xc4\x8f\x88\x83\x26\x80\x60\x14\x0f\x09\x7a\x75\x72\x2e\x82\x51\x3f\x98\xf8\x0e\x72\x7d\x1a\x41\x49\xbc\x3c\x39\x3a\x7e\x7d\x76\x8c\xfa\xae\x47\x78\x30\x0a\x83\x20\xe6\x57\x4a\x83\x10\x20\x3b\x62\xa5\xa0\x38\x24\x84\x33\xb0\x25\xb0\x8f\x6c\xec\xff\x12\x91\x17\xa7\xaf\xe8\x24\xf4\x48\x60\x62\xdd\xb8\xbe\x13\xdc\x30\xc5\xa7\xdc\xf4\x5d\x9f\x38\x15\xaa\x40\x2c\xa6\xee\x04\x36\x00\xf6\x18\x82\xf4\x43\x60\x2e\x7f\xca\xf0\x99\x3b\x1a\x7b\x70\xcb\x6c\x30\x8c\x6f\xd8\x49\x36\x13\x3b\xc2\x51\xe4\x46\xb1\xeb\x0f\xd0\x8d\x1b\x0f\x19\x44\x0a\x89\xf9\xc5\x58\xec\x3b\xc8\x0e\xfc\x98\xdc\xc6\x28\xe8\x53\x4a\xff\x0d\xc2\x0f\x24\xac\xa3\x9f\x89\x37\x8e\x10\x86\x8b\x8b\x74\xed\x34\xf1\xc0\x1e\x19\x13\xdf\x21\xbe\xed\x92\x08\xf2\xc2\x7d\x8e\x88\x89\x39\x0e\x50\x48\x70\x44\xa9\xf6\x82\x49\x4c\x89\xdd\x0c\x09\x20\x74\x05\x21\xa0\x71\xc5\x43\x32\x45\x38\x04\x91\x62\x5e\x92\x85\xc8\x35\xf1\xe9\x7c\x03\xb1\x3e\xb9\x26\x21\x72\x7d\xdb\x9b\x38\x0c\xcf\x65\x84\x5d\x9f\xd2\xfa\x1d\xcc\x66\x96\xe9\xf7\x84\x93\x69\x1d\x44\x4e\xe5\x7d\x7c\x4b\xec\x09\x7b\x9e\x79\xed\x86\x81\x0f\x42\x3c\x64\xa7\xa8\xb2\x2d\xba\xc9\x4f\x2b\x89\x60\x64\xa3\xae\x00\x0b\x63\xdf\xe9\x46\x52\x32\xc0\x3b\xf3\x97\x6e\x14\x13\x1f\xf2\x25\x6d\xfd\xf8\x31\x6d\x6c\xde\x70\xd8\x71\xb4\x94\xb4\xff\x89\xa8\x38\xc6\xf6\x10\x62\x6b\x0a\xe1\x5f\x5d\x72\x43\xbb\x49\x86\x24\xcf\x16\xd9\x21\x21\x3e\x5f\xb7\x9e\xf8\x8c\xd1\x2e\x7a\x94\xa4\xde\xda\x42\x3f\x82\xc0\x6f\x2c\xa6\xa2\x6e\xc4\x50\x84\x36\xd1\x08\x14\xc3\x1e\x82\xc5\xca\xf5\xba\x3f\x89\x27\x21\xa9\xaf\xad\xdd\x1d\xac\xad\x31\x9d\xa9\xf3\x9e\x8a\x0e\x8d\x32\xcd\x76\xfb\xe6\x4a\xbb\x3d\xe2\xb3\x20\xfa\xf5\xd9\x5b\x74\xf2\xfa\xdf\xc7\x47\xe7\x27\xa7\xaf\xd1\x93\xad\x84\xf6\x38\x0c\x6c\x02\x70\x73\x6b\x7f\xd9\x71\x02\xfd\x8b\x2a\x9b\x3d\x24\xf6\x07\x8e\x9f\x06\x8f\x6c\x46\xe3\x78\x2a\xae\x7a\xe6\x21\xcd\xef\x2b\x5d\xff\x97\x71\x14\x87\x04\x8f\xd0\x35\x09\x23\x8e\x41\x44\xbb\x54\x8c\x3c\xae\x74\x75\xf4\x22\x20\x11\xeb\x81\xf8\x03\x65\x34\x0e\x10\xb6\xed\x60\xe2\xc7\x28\x1a\x13\xdb\xed\xbb\x36\x25\x05\x67\x7a\x84\x12\x18\x7b\x38\xee\x07\xe1\x48\xe9\x5c\x9a\x1a\xb3\x9d\x1d\x89\xbf\xc4\xc2\xe9\x08\x40\x15\x10\x4a\x8f\x90\x33\x09\xe9\xa8\x43\x65\xd2\x9b\xf4\x7a\x1e\x41\xe3\x21\x8e\x68\xed\x11\xe2\xf9\x38\x3e\xd2\xa7\x17\xa7\xaf\x80\xfe\x39\x20\x62\xde\x71\x68\x51\x46\x8c\x8d\x75\x6c\x74\x19\xd0\x72\x42\x59\x31\x14\xf8\x75\x9d\x50\xc4\x71\x96\x80\x05\x58\x4a\x03\x5d\xc4\xc0\xfa\x48\x7d\x50\x87\x9b\x47\xf6\x87\x0a\x1d\x93\x2a\x23\x3a\x8d\x06\xd7\x24\xac\xa4\xe8\x08\x45\xbb\x03\x20\xc4\x1e\xb6\x3f\xa0\x23\xf1\x43\xc4\x89\x2c\xe2\xce\x75\xc0\xd1\xa1\x98\x31\xc7\x46\x5b\x8c\x7e\x0f\xc9\x28\xb8\x26\xbf\xa3\x11\x89\x87\x81\xc3\x32\x6d\xc1\xfe\x15\xad\x84\x72\x25\x93\x05\x48\x54\x50\x59\x05\x4b\xf2\x20\xec\x70\x40\x58\x84\x64\x99\x01\x46\x31\xd5\xcd\x09\xaa\x06\xba\x16\xdb\x0c\x93\xf7\xfc\x32\xaf\x72\x58\x1d\xb4\xeb\xa3\x34\xa0\xaa\x5f\x3e\xe7\x25\xb2\xb8\xb9\x0b\x4d\x6e\xa1\xdf\x69\x4e\x9e\xd4\xca\x2a\x43\x66\xa6\x9e\x49\x5c\xb5\x12\xf8\x15\xb4\x61\x94\xe0\x6a\xaa\xe8\x90\xb9\x0a\xcb\x56\x0d\x2c\xb4\xb5\x79\xba\x90\x8d\xc7\xd0\x39\x1f\xfa\x90\xd2\x87\xb8\x50\x54\xf4\x32\x16\xf2\x75\x7a\x11\x9d\x65\xbf\x74\x27\xd2\xca\xcc\xeb\x43\x9f\x94\x7b\xc7\x7c\xea\xac\x13\xff\xba\xfe\xfa\xf4\xc5\xf1\xd5\xf1\xeb\x5f\x99\xa1\x33\x0e\x03\x67\x02\xac\x69\x0f\x51\xec\xc0\x8f\x02\x6a\x14\x00\x14\x6b\xe5\x59\x4c\xd7\x12\x31\x71\xa8\x3a\x79\x52\x6b\x67\x68\x2c\xa2\x66\x21\xa2\x1d\xa5\xd2\x0b\x83\x9b\x08\x26\x57\x1c\x23\x47\xcc\x4c\xd1\x64\x0c\x4b\x8f\xac\xae\xa3\x77\xc1\x24\x44\x78\x3c\xf6\x5c\x9b\xc1\xba\x00\x99\x1b\xd7\xf3\x20\x67\xc8\x30\xea\x50\x14\x8c\x08\x67\xa3\x5e\xc9\x3c\x6d\xc9\x6d\x0e\x6d\xc2\xcd\xeb\xa6\xa2\xdb\xbc\x60\xeb\x24\xad\x11\xb5\x18\xee\xdc\xd4\x68\x4a\xa9\x8d\x59\x68\xe7\xdc\x31\x60\xee\x22\xc3\xa9\xda\xae\xd5\x6a\x19\x3b\xac\xb5\x42\x3b\xec\xef\x64\x58\x6d\x3d\x41\x24\xf2\x5c\x3f\xde\x74\xdc\x08\x90\xb9\xfb\xbd\xcd\x9b\x9b\x9b\x2d\x66\xee\x6f\x4a\x13\x9f\xa7\x66\x6b\x2a\x3c\xa2\xab\x27\x24\x17\x5f\xec\xf6\x0c\x5f\x7c\xa1\xde\x24\x46\x37\x21\x1e\x47\x6c\x35\x13\x87\xd3\x4d\x1b\xc7\xf6\x10\xf5\xbc\xc0\xfe\x50\x47\x27\x3e\x3a\x39\x46\x6e\x8c\xdc\x08\x6c\x2b\xaa\xe3\xb8\x0f\xcb\x24\x00\x57\xce\x21\xcb\x16\x42\x21\x08\xcd\x0f\xe2\x21\xed\x4d\xfd\xc0\x9e\x44\xc4\x49\xe4\x4b\x90\x9e\x09\xfa\x82\x84\x41\xf6\xbd\x29\x27\x23\x0b\xa1\x23\xb5\xfc\xdd\x0b\x9c\x29\x27\x4f\xc9\x4d\x49\xcc\x21\xbd\x65\x09\x62\x08\x7f\xfa\xe2\xf4\xd5\x0b\x9e\xed\x8e\x12\x40\x5c\xcd\x23\xa8\xc6\x24\x0c\x29\x3d\x59\x93\x35\x75\x28\xa7\x79\x39\x7f\x77\xd0\x0a\xb2\xcb\x0c\x48\xfc\x4c\x65\xbf\xea\x04\x76\x0d\x6d\x3d\x51\x72\x3c\xd9\xa2\x1d\x95\x16\x78\x08\xff\x7e\xfe\x2c\x31\xa5\x65\x35\xd2\x2b\xe8\xa7\x49\x54\x17\xc9\x70\xe9\x2c\x36\xc9\xce\x5e\xdc\x25\x39\x53\x2e\x64\xc5\x23\x0b\xda\xfb\xe3\x70\xaa\x47\x3a\x81\x9d\x6a\xb0\xcf\x9f\x21\x90\x0a\x15\x72\x21\xa6\x05\x55\x52\xcb\xe6\x94\x89\xd6\xee\x0c\x03\x44\x5a\x2e\xd9\x75\x56\xfb\xa1\x7f\xd3\xdc\xc9\x6a\xc9\x8d\xce\xc9\x6d\xfc\x3a\x60\xef\x92\x4c\x4b\xa5\xc6\x0e\x5b\x2b\xa5\xfa\xbf\x1f\x6c\xf6\xdc\xf8\xc6\x8d\x88\xda\xe5\x01\xb0\x39\xa2\xea\x82\xd1\xc0\xbd\x26\x3e\x98\x4f\x3e\x25\xcf\x2f\xd2\x47\xb4\x27\xb9\x11\xc2\xb4\x6f\x92\x50\xc6\xd7\x75\x15\x17\xa9\x29\x67\xd5\x60\x12\x93\x90\xfe\xb2\x90\xeb\xfb\xec\x27\x53\x0e\x80\x28\x90\xd1\xf0\x04\x28\x95\x42\xaa\x0f\x73\x50\xb0\xa6\x99\xc5\x49\x4e\x40\x9b\xcb\xc9\x09\x2e\x08\xf4\x8c\x89\xd8\x12\x1a\xb5\x12\x05\x2a\xf9\x92\xd2\x52\xf9\x66\x56\xbd\x3e\xc6\x74\xd8\x80\xbc\x29\xfa\x15\x91\xb9\x42\x95\x22\x61\x4d\x2f\x41\x86\xd7\x45\x72\x85\x9b\x3c\x11\xd5\xed\x60\x44\x0b\x16\xc3\x99\xd8\xfe\x4d\xd1\x7e\xf4\x68\x76\x16\xa5\x34\xf4\x18\x81\xf7\xb3\x94\xa5\x95\x11\xa1\xb1\xbf\xab\x92\xca\xf6\xf5\xed\x87\xad\x54\xb6\x95\x2a\xa0\xe8\x95\x75\x0e\x9f\x56\x58\xcf\x74\xfd\xf1\x24\xde\x8a\xc9\x6d\x8c\x43\x82\xe9\xc4\x04\xf3\x25\xcb\x2e\x7b\x24\x84\x81\x4e\xfa\x52\xa3\xb6\xb6\xd0\xc9\xf1\x1e\xb2\xb1\xcf\xbd\x0e\xac\x1f\x61\xbf\x12\x23\x6a\x18\xb2\x0c\x94\x5a\xcc\x50\x9e\xe3\x30\xa0\x73\xac\x8d\xa9\x64\x61\x5a\x47\xae\x7f\xed\x02\x5e\xb5\xc5\x88\xd1\x39\x9e\xf8\x74\x7c\x71\x2c\x3a\x4e\x00\xac\x33\xb8\x16\xd0\x6d\x5d\x6c\xdb\x64\xcc\x4c\x5d\x28\xa5\xbe\x0e\x78\xf0\xd4\x2a\xf8\xe0\xfa\x4e\x04\x5b\xb1\x94\x20\xdb\x4f\x8d\x58\x76\x1c\x52\xe3\x21\xa0\x6d\x4f\xfc\x88\x5a\xbc\xd8\x77\x50\x3f\xc4\x03\x2a\x5a\xca\x28\x89\xe8\x1c\xac\x4c\x5a\x30\x32\x41\x11\xd5\x5a\x66\x72\x32\x2b\xa5\x94\x53\x56\x23\x3b\x4b\x69\x64\xa6\xa4\x4f\x68\x9d\x1f\x3b\xac\x77\xcd\x63\x77\x73\x1b\x2e\xbc\x92\xe8\x15\xe4\x15\x60\xe8\x59\xce\x76\x4a\x70\x66\x66\x42\xc5\xdc\x48\xc6\x64\x6e\x2b\xb8\xd4\xc8\x40\x15\x91\xa6\x52\xe3\x6a\x92\x38\xa6\x70\x63\xba\x14\xe1\xc6\x94\xe2\x7d\xe2\x11\x5b\x80\xf0\x71\xc0\x8d\x0f\x60\x49\x90\x66\x7b\x77\xb5\x02\x7d\x64\x5c\x27\xec\xc2\xe9\xb5\x31\x6e\xa7\x59\xab\xa6\x21\xe3\x39\xcb\x66\x8f\x35\x46\x37\x48\xed\xbd\x5a\xb5\xe2\xb8\xd7\x95\x9a\x85\x2a\x18\x9e\xdc\x0d\x88\xba\x44\x02\x07\x40\x9c\xee\x2e\x78\x50\xa9\xd5\x31\x95\xec\xee\xc1\x1a\x9c\x8e\xa5\xe5\xb2\xb7\x94\x5c\x98\x5d\xc0\x77\x10\xcc\x56\x41\xa7\x59\x3b\x80\x74\xd2\x62\xcc\x71\x96\xb7\x53\x93\x67\x2f\x07\x6b\x5b\x5b\x28\x65\x83\xea\xe7\x31\x54\x0d\x2a\x6c\x07\x83\xcd\x5f\x9e\x83\x4e\x8e\x39\x3f\xe8\x50\x32\x55\x15\xd9\xa1\x65\x32\xa1\x99\x43\x9e\x12\x4a\x2b\x14\x2d\x52\xac\xe0\xd4\x8b\x41\x9a\xb4\x8b\x3e\xdd\x99\x55\xb1\xd0\xe1\x6a\x29\x91\x0f\x71\x94\x23\xc5\x9d\x16\x97\x76\x1c\x9c\x14\x36\xcb\xae\x48\x08\x17\xc6\xe1\xc1\xc3\x69\x3f\xcf\xb0\x6b\xee\xd6\xaa\x62\x07\x91\xe6\x39\x39\xbe\x7a\xf3\xf6\xf4\xfc\x34\xd7\x49\x69\xb3\x56\xad\x88\x44\xb4\x7b\x16\xc9\x55\x3c\x55\x80\x97\xd2\xc9\x4d\x3a\x4a\x5c\x56\x82\x27\x92\x17\xaa\x98\xbb\x2a\xe9\xf9\x3f\x62\x1e\x03\x2f\xe4\xc5\x9c\x0f\xec\x42\x11\x78\xfe\xe0\xde\xba\x4e\x6b\x30\xdc\xd0\xaf\x47\x87\xb2\x06\xe0\xdf\xa7\x7a\xca\x3c\x72\x51\x15\x61\xc4\xd8\x6d\x8b\x0f\x84\xc1\x4b\x6e\x6d\xa1\x17\x01\x9d\xac\x88\x3f\x19\xa1\xde\x64\x80\x1e\xa3\xa1\xeb\x38\xc4\xa7\xd9\xa2\x35\x84\x6e\x86\x74\x5e\xa8\x42\x15\x04\x6c\xdc\x0f\xc8\x65\x45\x26\x25\xa0\x43\x56\xcb\x0b\x77\x63\xe3\x52\x1a\x73\xff\x8f\xda\x04\x55\xc6\x00\x67\xe8\xf3\x67\x23\x43\x77\x89\x1a\xb2\x68\xa3\xa2\x6d\x2f\x77\x42\xbc\xb5\x85\x9a\xfb\xf5\x66\xbd\x55\xdf\x47\x5b\xa8\xd9\xa9\xb7\xea\xed\x7a\x2b\xc7\xd3\xc8\x69\xad\xbc\x62\x16\xeb\x65\x7b\x51\x1d\x03\xa5\x01\xd2\xc0\x58\xe2\x62\x48\xba\x10\x32\xe9\xa1\xb1\x3a\xba\x27\xb9\x53\xd6\x50\x4c\x21\xb9\x3e\x9e\xca\xb5\x2e\x6f\x5d\xa9\x50\x35\x39\xac\x5f\x88\xb0\xcb\xd4\xba\xf8\xb4\xae\x38\x32\x42\x87\xea\xb4\x47\x55\xf0\x54\xf5\xa6\xa5\xa5\x4d\x19\xd0\x5a\x9c\x5a\x4d\x94\xf8\xa7\xd2\x89\x31\xc9\x3f\xd5\xe4\xd4\xe5\xab\x70\x93\x06\x2d\x77\xd8\xb8\xb5\x85\x46\x41\x14\x8b\x62\xd9\x8e\x72\x84\x7a\x53\x74\x7c\xb6\x83\xa2\x61\x30\xf1\x1c\x61\xa0\x8d\x43\x77\xe4\xd2\x05\x79\x04\x0d\xf9\x4f\x7e\x3b\x22\xc7\x1d\xe0\x2e\x6f\x6f\x3b\x08\xf3\x56\xa3\x2d\xa1\x48\x7d\xec\x7a\xb9\x5a\xd9\x2c\x1e\xf3\xff\x73\xfc\x8e\xd6\x93\xd8\xc9\xb8\xd4\xf7\xd1\x21\xaa\xd2\x82\xeb\xbc\x5e\x9f\x3f\xa3\x4f\x77\xb5\x8b\xff\x1c\xbf\xbb\x4c\x5c\xf1\xc0\xa7\x18\x8e\xc8\xed\x98\x1a\x61\xb0\xd5\x49\x6e\xc7\x2c\xe9\x21\x10\xae\xf6\x7d\x50\x25\x5e\xe1\x2a\xff\x5b\x3f\x43\x1b\x22\xac\xfe\x23\x7a\xc2\x6a\x51\x4d\x39\xfa\xf3\xab\xcd\xda\x01\x6d\x2d\x54\x61\xa5\x56\xa0\x55\x6a\xe6\xc6\x5c\x6e\xc7\x32\x23\x25\xe3\x64\xdf\x30\xd8\x18\xdb\xcb\x6d\xa5\x18\x67\xa4\xd6\x3e\x6f\xdd\x81\x17\xf4\xb0\x97\x6f\x53\xb0\x54\x02\x4d\x25\x8f\x65\x18\x70\x62\x12\xe2\x38\x08\xf3\xea\xb6\x2f\x12\x9e\x9f\x5e\x9d\x9d\xbf\x3d\x79\xfd\xd3\xd5\xf9\xb3\x9f\xf2\x4a\x6e\xd4\xaa\x95\x38\x60\xbe\x68\xce\xf1\xa0\x22\x7c\xf0\xbd\x38\x7d\x05\x05\xf5\x3c\x78\x22\x5f\xad\x1c\x9d\x9d\xbd\x9d\x78\xe4\xa5\x1b\xc5\xd6\xd1\xd9\xd9\x59\x3c\xf5\xc8\x0b\x62\x7b\x98\xe3\x79\x1f\x9d\x9d\x01\x0e\x1e\x4b\xe0\xb9\xc4\x8f\xdf\x12\x1b\x36\xb7\xad\x17\xa7\xaf\xd4\xdf\xac\x34\xf8\xaa\xa0\x8d\x35\x84\x2a\x2f\x4e\x5f\x9d\x07\x1f\x88\xcf\x52\xe0\x18\x9f\x87\xd8\x8f\xfa\x04\x90\xf0\x20\xf0\x47\x97\x97\xfd\xf3\xf9\xab\x97\xcf\x3c\xef\x28\xf0\x3c\x76\x61\x05\x42\x52\x9f\x3f\x06\xe1\x88\x1b\x39\xf0\x7d\x46\x68\xac\x08\xe1\x85\xbe\x22\x8e\x8b\x81\xe6\x2b\x77\x04\x8f\x09\xc0\xb5\x8e\xf5\x1a\x8f\x88\x43\x97\x3b\xaf\xf0\xd8\xa2\x7f\x21\xcd\x1b\xec\xd2\x1a\xfd\x39\x21\x11\xab\xc8\x1b\x6f\x32\x70\x7d\xfe\x87\xe5\x3c\xfb\xf5\xa7\x97\x30\xa9\x42\x82\xb3\x5f\x7f\x62\xa8\xc1\x6a\x4d\xcf\x7e\xfd\xe9\x0d\x8e\x87\x67\x64\x20\xd2\x00\x76\x95\xf8\x50\x44\x73\xf6\xeb\x4f\x4c\x0a\x41\xc8\x44\x70\x06\x6b\xe1\xe7\x93\x7e\x9f\x93\x84\x36\x38\x1b\x12\xc2\xb2\x9f\x93\xdb\xf8\x3c\xc4\xf6\x87\x23\xde\x0a\xbc\x48\x19\xce\x52\x05\x13\x1b\xf8\xab\xd4\xea\xd1\xd8\x73\xe3\x6a\xc5\x82\x56\x37\xf9\xd8\x54\xb5\x20\xe5\x6a\x93\x0f\x19\xaf\x9f\xbd\x3a\x46\x87\x5a\xc2\x0b\x57\x0e\x28\x49\xb3\xa0\x43\xde\x05\x2e\x68\x0e\x99\x60\xcc\xa7\x40\x25\xe1\xe3\xc7\xca\x97\x3e\x5b\x48\xdf\x95\xb0\x7c\x81\x5f\x17\x9a\x96\x5f\xd6\xa0\x0b\xb1\x44\x96\xde\x03\x2c\xe0\x15\x06\x31\xd9\x85\x18\x33\xe8\x30\x09\xa9\x43\x4b\x1e\xd0\x75\x70\x7a\x78\x28\xb3\xfb\x32\x6b\x45\xe9\x04\x3e\xe1\x37\x5b\x35\x2b\x5d\x3a\x09\x84\x3f\x16\xa2\xe9\xba\xe8\xd1\x23\xfa\x17\x99\xed\xf3\xed\xe5\xd6\xde\x5b\x5b\x68\xb7\xde\xaa\xb7\xd0\x49\xc4\xfc\xc9\x09\xa7\x70\x35\x3e\x63\xe5\x59\xd9\xcd\xce\x9e\x69\x32\x02\x22\x75\x97\x11\xd3\x0c\x13\x37\x29\x40\xab\xb3\x1d\xf4\x59\x18\xb5\x2c\x20\x49\xc5\x5c\xd1\x32\x4b\xf9\x32\xf6\xe1\x6e\x62\x1f\x6e\x2b\x06\x95\xe2\xfd\x96\x76\xfd\x48\x18\x89\xff\xa4\x46\x73\xee\xac\xbd\x9f\x0c\xd9\x0e\xf1\xff\x93\x9f\xb4\xb9\xd3\xae\x09\xff\x75\x15\xd6\x87\x2a\x16\x9c\xac\x32\xc5\x86\xce\xc7\x6b\x51\xef\x6b\xa6\x5e\x9a\x33\x4d\xac\x66\xce\x55\x01\x43\x05\xa8\xd1\x97\xf0\x98\x33\xe5\x2e\xb7\xeb\x00\x1d\xf9\xe4\x38\xaf\xfe\x4d\x31\xbb\xb1\xc5\xe7\x0b\x12\xd9\x79\xae\xb2\xf7\xe6\x5d\x15\xc6\xc1\x1b\x61\x90\xe5\xaa\xab\x9c\x5c\x67\x1b\xfd\x27\xc7\x7b\x57\x2f\x4e\x5f\x5d\xbd\x38\xfe\xf1\xe4\x75\x5e\x85\x5a\x6d\x61\xd6\x0d\x4e\xdf\xbc\xc8\x6b\xb0\x17\xd2\x63\x6f\xaa\x79\xf3\x76\x64\x9e\x32\x72\xdd\xbc\x16\x4e\x08\xd2\x26\x7d\xa3\x1a\xfb\x27\x9a\xb5\xff\x06\xc2\xa4\x5c\xaa\x6f\x94\x1b\x01\x74\x04\xd5\x2b\x59\xcb\x1e\x68\x51\x3e\x58\x19\x99\x0d\x42\xb4\xf5\x84\x9d\x8e\x23\xaa\x3e\xfa\xd2\xe2\x4d\xb2\xa6\x48\x5a\xba\xfa\x68\x7c\x72\x5c\xef\xb3\xd3\x6b\x48\x64\xa1\xd3\x8b\x37\x97\x39\x8a\x58\x66\x9b\x07\x74\x2e\x93\x73\x05\xbb\x15\x33\x8c\xaf\x82\x61\x5d\x5c\x2d\x89\x42\xdb\x82\x23\x5d\xd6\x3a\x19\x4f\xdc\xa1\xad\xde\x34\x81\xb3\xdf\xc7\x8f\x55\xef\xda\xb5\xb4\xab\xed\xd0\xbe\x48\x5c\x74\xc2\x71\x02\x4c\x70\xa2\x40\x70\x0e\x2d\x12\xd5\xb4\x15\x15\xf7\xc5\x6d\x12\x73\xa7\xcc\x8a\x7b\xf6\xe6\xa8\xe6\x6c\x99\x6d\x8c\x58\xb4\xce\x3d\x18\x6e\x7e\x74\x89\xe7\x28\x67\x5a\x55\x37\xce\x73\xbf\x0c\x67\xb9\x7a\x46\x38\xca\x4d\xce\xe0\x1f\x3f\x4e\x11\xa6\xe2\x74\x63\xb9\x37\x91\xde\x84\x85\xa7\x26\x1b\xa8\xd2\x45\xae\x6f\x07\x61\x48\x87\x12\xd7\xbf\x0e\xd8\x6d\x11\xbe\x15\x7b\x37\x63\x33\xb6\xb3\xf4\xb2\x12\x4e\xf5\xa3\x80\xae\x28\x5d\x7f\x80\xe8\x64\xc8\x0d\x0d\x70\xd2\xc2\x2e\x33\x81\x1a\xd8\x5e\x10\xf1\x24\x70\xa9\x86\xed\x79\xf9\x85\xa3\xe0\xce\x0c\xad\x14\x65\x59\xa8\xef\x5b\xc2\xb2\x20\x7e\x1c\xba\x62\x03\x2b\xd3\xf5\x79\x2c\x7a\x4a\x17\x6d\xa2\xf8\x2a\xb3\x57\x2e\x1a\x97\x9c\xca\x45\xf3\xb2\x46\x07\x2a\x9f\xc7\xf0\xcd\xa7\xdd\xfa\x76\x7d\x47\x9a\x52\x80\x0b\xa3\xf0\x60\x07\xa3\xb1\x47\xe0\x7c\xcd\x78\x26\xce\xb6\xc8\x62\x86\x63\x0d\x79\x2e\x2a\x8c\xab\x0a\x57\x7f\xaa\x46\x34\x85\xa6\x1a\x35\x29\x25\x1a\xc7\xc6\x19\x41\x40\xe0\x81\x32\xed\x10\xc7\x6e\x86\x86\x5e\x6e\xc9\x49\x1b\x7a\x48\xec\x0f\x88\xf9\xb2\x87\x57\x13\xcc\x0c\x12\x8c\xcc\xb7\x70\x3b\x39\x3f\x7e\xfb\xec\xfc\xf4\x6d\xd1\x9a\x4d\x50\x16\x3b\x4a\x50\x9e\xd8\x50\x62\xb6\x58\xe1\x7e\x52\xfe\x7e\x71\x9c\xed\x7a\xd5\x94\x79\xcc\xce\x96\x61\x47\x21\x29\xf7\x42\xb0\x7d\xc9\xa3\xcd\x43\x7c\x67\xb9\x55\x36\xd8\x11\x1e\x8e\xa2\x5c\xfb\xb4\xd5\xd9\x5e\x42\x8e\xa5\x1a\xa9\xd4\x1e\x43\xab\x5d\xa3\x26\x81\x20\xf8\x0a\x76\x95\x72\x8f\x97\xd8\xb9\x92\xa2\xd5\xb2\x39\x12\xb9\x82\x2e\x7f\xfe\x4c\xc3\x2a\xff\xfa\x97\xe4\x5c\x86\x27\xcb\x1a\x2e\x21\x5a\xc2\xa5\xb9\x15\x96\x3b\x4a\xde\xda\xa2\xc6\x09\xbc\x20\x89\xf1\x00\xdc\x6e\x31\x23\xbb\x5d\xdf\xc9\x6c\x67\xd6\xc5\xfe\x42\xb5\xdc\xd2\x02\xf6\x2e\xe6\xda\xb1\xd8\xda\x42\xc7\x67\x6d\x74\x13\x06\xfe\x00\x0d\x49\x48\x58\x97\x78\xfb\x13\x9c\xa8\xf7\xab\xc6\x63\x27\xe9\x04\xfb\x00\xdd\x55\x6b\x62\x15\xc2\xc3\x2a\x07\x50\xc9\xbe\xbc\x9c\x1a\x50\xe3\xb0\xd9\x44\x67\x60\x83\xa1\x67\xb6\x4d\xa2\x08\xbd\x20\xbe\x4b\x1c\x65\xc4\x8e\xc3\xe9\x4f\x24\xce\xcc\x93\x1f\x84\x8b\x83\xcc\x80\xeb\xc6\x72\x7e\x2f\x32\xb4\x8c\xb7\x07\xb3\x9a\x04\x7b\xcb\x16\x3a\xb7\xd0\x73\xed\xac\x11\x7a\x64\xd2\xa5\x9f\xa2\xca\x2f\xc9\x25\xa9\xae\x48\x00\x57\xc5\x9e\xa2\xca\xeb\x89\xc7\xdd\x30\x6e\x6d\xa1\x7f\xfd\x4b\x11\x36\xb2\x71\x44\x20\x46\x3e\x8b\xa9\x9e\x53\x73\x13\xaa\x5d\x3d\x4d\xde\x2d\xba\x71\xcd\xa2\xad\xc8\x05\xcb\x2e\x10\x57\xd0\x53\x74\x2e\x08\xf7\x26\xae\x17\xbb\x7e\x8a\x2a\x6d\xb4\xa7\xd0\x68\xa7\x35\x91\x92\xb6\xad\x6c\x2d\xd9\x26\x3c\x43\xf5\x39\x6f\xe4\x53\x5e\x14\xdf\x61\x04\xc3\x4a\xee\x63\x63\xcf\x23\x24\xb5\x85\xfd\x54\x6d\x6f\xd4\xa5\x22\x33\xf5\x94\xe5\x96\xd9\x65\x4f\x1e\x67\x18\x5a\xe7\xef\xde\x1c\x2b\xb6\x94\x3c\x20\xa4\x0d\x0f\x23\x42\xfd\x8a\x8d\xdb\x2c\x61\xda\x1c\xaa\x9c\xf8\x70\x71\x25\x76\x7b\x1e\x11\xb7\x63\x43\x0b\x6e\xcd\xd2\x1c\x70\x62\xcd\x39\x72\x4a\x1d\x54\x77\x96\x5b\x94\xa7\xef\x9d\x89\x05\x52\x72\xb2\x0f\x5a\x35\x21\x7c\xa1\x45\xe2\x17\x1a\xa2\xa7\xba\x46\x52\x62\xaa\x29\xff\xfe\xca\x61\x86\x8c\x61\x57\xfd\xb8\x42\xa6\x4e\x2a\x64\x22\xe9\x4f\x1c\xc4\x9d\xa2\x2a\x93\xcb\x1e\x25\x93\xa7\xe9\x68\x40\xa4\x9f\x3f\x2b\x11\xe2\x31\x74\x45\x06\xf1\xdd\x0f\x21\x0a\x61\x49\x1c\xa6\xea\x98\xb9\xea\xd0\x59\x6e\xf5\x9e\x6e\x0a\xf3\x31\xbf\x24\xb3\x9e\x34\xd1\xba\xc5\x07\x1d\xd8\xb9\xa2\xad\x05\x67\xf7\xfc\x72\x0e\xec\x48\x8c\xb1\x4d\xe0\xc6\x0c\x7f\x35\x18\xf8\x7d\xcf\xb5\xe3\x88\x9a\x4a\xe2\x12\x0d\xb9\x8d\x93\x37\x45\x7f\x00\x5c\xb5\x90\x01\xfb\xaa\xec\x6c\xe3\x4e\xc7\xe9\xec\xee\xf5\xf7\x3a\x3b\x4e\xab\xb3\xe7\xd8\xed\xed\x4e\xaf\xb1\xbf\x8d\x5b\xb8\xd5\x6b\x57\x98\x96\x44\x43\x42\xe2\xe8\x2d\xdc\xbe\x0e\xa7\x0a\x99\x4c\x44\xc5\xd9\xee\x39\x8d\x1e\xc6\x76\xcf\xee\xb4\x7a\x3d\x67\x7b\xaf\xd7\xeb\xed\x93\x5e\x6b\xbb\xbd\xbd\x4d\x6c\x87\x53\x1c\x61\x1f\x0f\x48\xa8\xb2\xa4\x04\x55\x7a\xbb\x3b\x7b\xbd\xdd\xbd\xfd\xe6\x7e\xa7\xb1\xdd\xef\xe1\x7d\x87\xb4\xec\x46\xbb\xb3\xdd\xb1\x3b\xb6\xd3\xc6\x2a\x5f\xa7\xe0\xf2\x39\x4a\x73\x95\x04\x57\x76\xfa\x76\x67\xb7\xe1\xec\xf4\x9c\x9d\x66\x7b\xaf\xbd\xd7\xdc\x77\x1a\xfd\x7d\xb2\xbb\xdd\xd8\xb5\xb7\x3b\x2d\xa7\x92\x6d\xf9\xe5\x6e\x45\xac\xbc\xe5\x45\xcd\xd8\xf2\x5f\xa9\x2a\x0b\xf8\x89\xf8\xd4\x40\x61\xae\xe9\x79\x47\xd6\x9b\x48\x09\x10\x87\x0d\x4a\x10\x6c\x75\x47\xaf\x58\x03\x64\xc2\x0d\xed\x4e\x3b\xce\xd4\xc7\x23\xd7\x86\xad\x72\x4a\x5e\xe9\xb2\xd0\x36\x57\x86\x34\xc6\x93\x1c\x38\xf0\x9d\x25\xa2\x4a\x9a\x5a\x85\x09\x8a\xf8\x93\x11\xdb\x1d\x67\xd2\xb2\xd6\x50\xea\x42\xcc\x80\xc4\xd5\xd4\xe8\x72\x05\x7e\x02\x83\xf1\x5b\xc6\x84\x78\x4d\x90\xe1\xb8\x76\x51\xe1\x63\x05\x5b\x28\xdd\xb1\x1b\x34\x50\xbb\x8c\x68\xcc\x16\xf3\x7e\x99\xba\xe9\xb4\xee\xa3\x66\x7a\x09\xb3\xeb\x95\xa8\x82\xb9\xc9\xb6\xcb\x57\x8b\x93\xba\xbf\x5a\xf1\x02\x8a\x2a\xa5\xa8\xbc\x71\xe9\xd1\x2c\x53\x1d\x41\xe4\x3e\x6a\x22\x68\x17\x55\x42\x76\x64\xa3\x81\xbf\xbb\x53\xa6\x0e\x8c\xc6\x7d\xd4\x80\x51\x2e\xe2\x3f\x7f\xa8\x32\x76\x9d\x9d\x52\xc3\x42\x0e\xd1\xfb\xa8\x61\x4e\x51\x45\x55\xfe\x77\x94\xbb\x86\xdd\xd9\x56\x53\xb5\x68\xb2\x9c\x72\xff\x1d\x81\x4b\x7c\xc9\x72\x4e\xba\xa0\xf7\x87\xb2\x06\x0b\x7a\x7f\x50\x3b\x3d\xe8\xfd\xa1\x5a\x7e\x4f\x21\xbc\x8b\x3e\x21\xc9\x73\x17\x82\xee\x0e\xa8\x95\x25\x6e\x2e\x43\x45\x23\x84\x91\x4f\x6e\xe4\xce\x22\x0a\xfa\xe8\xdf\x51\x94\x18\x14\x39\x73\x91\x6a\x43\xb2\x90\x6a\xc0\xa6\x62\x6d\x37\x84\x92\x86\x9a\x2b\xe2\x93\x09\x99\xbd\xc6\xd9\x79\x26\x8e\xf8\xa9\x34\x05\x37\x8c\x0d\x5e\xb2\x42\x82\x2e\x59\x58\xa1\x59\xc0\x8c\xce\x72\x3b\xd9\x2b\x9f\xd4\xd5\x6e\x21\xdc\x89\xa4\xee\x77\x48\x67\x7f\x6a\x21\x2e\x89\xe4\x36\x35\x83\x3e\xa1\x49\x0d\x87\xcc\x0c\x9c\x4b\x3f\x5d\xe6\x50\x57\xe2\xc4\x03\xbc\x51\x07\x63\x38\x5a\x56\x82\xeb\x49\xcf\x01\x38\x2c\x53\xf8\xe7\xcf\xfc\xce\xbd\x1a\x4f\xed\x50\x77\x30\x11\x39\x61\xa1\x01\xa6\xfe\x3a\xd4\x7e\x1d\xb9\xbe\x92\xbc\xa6\x66\xbd\x09\xdd\x58\xcb\x66\x16\xb0\xa8\xb9\x92\x13\xf6\xea\x15\xaa\x70\xed\x55\xbe\x0b\x90\x12\xd5\xf6\xd4\x61\x13\x85\x3b\x3d\x8a\xc0\x45\xea\x1b\x21\x4a\x79\x18\xce\x43\x32\xc2\x3f\x32\x5d\xba\x52\x49\xd6\x58\x9d\x35\xba\x45\x54\x74\x16\x0e\x92\xc5\x8e\x4c\x71\x00\x5d\xb4\xaa\x0f\x04\xb0\x19\x75\x84\x3d\x0f\x9e\xd2\x54\x45\xdf\xb0\xf4\x23\x80\x4f\xe2\x94\x40\x74\xe4\x9c\xb3\x02\x9a\x92\x2d\x6f\x69\xdf\x4c\x96\xb8\xeb\x47\xd8\xf7\x83\x98\x6d\xb9\x63\xb6\x47\x88\x70\xa4\x5c\xc0\x5e\x67\x12\x4f\x1e\xf3\xb1\x99\x2a\x14\xc6\x11\x43\x40\x20\x51\x44\x57\x26\x23\xb8\x7a\x8f\x63\x14\xf8\x04\x8d\x3d\x2c\xfa\x32\xd5\xcb\x8c\x51\x95\xbe\x30\x2d\xbf\xf5\x94\x72\x08\x4f\x8b\x24\x1e\xba\x91\x95\x4a\x2c\x9c\x98\x71\x77\x1a\xb2\xac\x8b\x4b\xb9\xd8\x54\x3b\x65\x55\xcf\x6d\xa1\x0b\xd5\xef\x13\x76\x00\xa9\x84\x6d\xa8\xb0\xe7\xe5\x08\x3d\x41\x6f\xc5\xcb\x6f\x8c\xc0\x94\x64\x2c\xd4\x79\xf4\x16\xdf\x96\xd7\xbd\x44\x61\xc7\xa9\xc2\x2c\xaa\xfb\x89\x52\x38\xd4\x38\x56\xfd\x04\x01\x0e\x12\x3a\x64\xeb\xa1\x3a\x1f\x45\xeb\x10\xaa\xbb\x3d\x16\x99\x59\xdc\x69\x5f\x14\xf8\xe8\xf0\x10\x6d\x36\xc5\xde\xe8\x81\x31\x0b\xbf\xd5\x4a\x17\xf9\x0d\xd8\x1a\x81\x42\x7f\xe0\x6c\x65\x7c\xde\xcb\x7c\x70\x71\x95\x95\x73\xa0\xc4\xb2\x82\xc4\xbb\x61\xfe\x63\x6b\x0b\xfd\xe8\xfa\x0e\xc2\x68\xcc\xdf\xff\x70\x99\x19\xc7\xb7\x14\x6b\xca\x05\x9a\x2c\xfb\x17\xee\xa5\x2e\x18\xf4\x83\xc9\x4f\xbf\x24\x19\x8d\x3d\xd7\x26\x55\xd7\xfa\xff\xd9\x7b\xf7\xb6\x36\x8e\xa4\x51\xfc\x7f\x3e\x45\x67\xcf\xbe\x1e\x29\x16\x42\x80\xb1\xb1\x08\xf1\x3a\xd8\xd9\xf5\x9e\x38\xce\x63\x9c\xcd\xd9\x1f\xeb\x03\xa3\x99\x16\xea\x30\x9a\xd6\x99\x19\x71\x59\x87\xef\xfe\x7b\xba\xaa\xef\x73\xd1\x05\x61\x93\x44\x79\xdf\x67\x8d\x7a\xaa\xef\xd5\xd5\xd5\x75\x25\xbd\x0e\xf1\x47\xef\x8f\xdf\x72\x05\xdf\xb0\xe6\xe3\x20\x44\x4e\xd1\x09\x45\xf7\xa0\x91\xa1\x2a\x9b\x58\x4e\x8b\xda\x64\x62\xb9\xc5\xb3\xd4\xa1\x71\xf5\x18\xc0\xd7\xa6\x06\x25\xab\x46\x21\xe0\x6b\x87\x01\xfe\xf4\x15\x08\xab\x90\xd1\x19\x98\x87\x70\x07\x55\x83\xd7\x6b\x2e\x40\x3b\x64\xbb\x5d\x37\x91\x23\x9e\x5e\xd2\xac\x90\x84\xa4\x08\xa3\x11\x8d\xa5\x8c\x02\x68\x0d\x39\x3a\x3e\x26\x28\x87\x6a\x9a\x9f\x12\xbf\xd6\xcc\x50\x0b\xd7\x1d\xf6\x85\x94\x72\x6d\xcb\xc1\x0f\x59\x52\xd0\xcc\x92\x88\x7b\x4b\xa3\xab\xe1\x21\x55\xe3\x36\xf9\x4e\xbd\x38\x8d\xcd\xd5\x4b\x83\xb3\xda\xf9\x95\xb3\xb4\x15\xfc\x27\x0d\xea\xd3\xd5\xc1\x12\x57\x11\xae\x23\xe9\x66\x3c\x62\xe7\x23\x9a\x17\x72\x33\x31\x04\xb2\x4b\xbe\xea\xf9\xe8\x9a\x05\x72\xe8\xc7\x0b\xd2\x23\x7d\x17\xe0\xa4\x12\x7c\x93\x6c\x7f\xf4\x29\x1a\xa9\x49\x70\xe4\x10\xea\x83\x0d\xbc\x2e\x2b\x79\x44\x1f\xd4\xe3\x14\x9f\xae\x32\xb4\xda\xea\xc4\x3f\xee\x1c\x0a\x7e\x94\xe7\x60\x19\x8a\xc2\x30\xb1\xed\xbf\xb0\x62\x74\x3c\x09\x23\x87\x0b\x77\x3e\xb4\xca\x26\x72\x50\x22\xb1\x86\x04\x2e\xf3\x2d\x8f\x5a\x8e\x5e\x22\x08\x0a\x87\x4c\x1f\x2f\x00\x3b\x1b\x87\x19\x44\x5b\x3e\x39\x09\xf6\x26\xd7\x41\x87\x04\xdb\xbd\xc9\x75\xf0\xf1\xe3\x19\xf9\xd6\x7c\xdd\x9b\x5c\x13\x51\x7e\x70\x06\x95\x06\x3c\x8b\x69\xd6\x27\x27\xc1\x36\xd6\xd9\x11\x55\xa0\x86\xfa\xb4\x3d\xb9\xee\x90\x1d\x59\xc3\xf2\xf9\x35\x93\xb7\x27\x04\x8c\x8e\x63\x2f\x27\xbf\xb6\x9d\xb9\x02\xd2\x6c\x6d\x91\x63\x19\x06\x03\x84\xa9\x24\xa7\x93\x50\xbc\xec\x62\x39\xcb\xae\x6c\xb0\xa2\xbd\x93\xde\x47\xdf\x13\xd7\x1f\x10\x9c\x66\x67\xe5\xdb\x6d\x5f\x98\x6d\x2f\x7c\x07\x57\xbe\x84\x89\xab\x8c\xf6\xb5\xb2\x37\x0b\xe6\x27\x7b\x37\xc8\x69\x76\x29\x59\xf6\x6a\x39\xd1\xd3\xda\x2a\x4d\x2f\x5e\x1f\xf6\x33\x3d\x7f\x2b\x4f\x99\x21\xc8\x35\x07\x47\xf4\x83\x48\x51\x9e\xa3\xd5\xd4\x47\x0d\x07\x14\x70\x9e\x1a\x2d\x73\x14\x6d\x8c\x58\x6d\xdc\x91\x95\xd1\x26\xed\x5f\xfa\x11\xb3\xe1\x5e\xbc\x9f\x26\x54\xeb\x2c\x7e\x60\xe9\x05\xc9\xc4\x26\x80\x65\x8e\xb2\x73\x7f\x0f\x41\x13\xd3\x98\xa4\x34\x17\x27\x4f\x40\xe4\x08\x02\xc6\x45\xf9\x84\xa7\x31\x4b\xcf\xd5\xf7\x28\xcf\xdf\x03\x08\x1b\x92\x01\x2f\x46\x84\x5e\xb3\xbc\xc8\xbd\x80\x00\xaa\xf7\x56\x06\x6b\x22\x2b\xc9\xad\x9b\x26\x54\x26\xd1\x93\x98\x2b\x3f\x2b\x23\x3e\x04\x80\x4e\x1e\x3d\x52\x1f\xbb\xaa\xe3\x36\x31\xdf\xbb\xa2\x9f\x56\x09\xa2\xea\x14\xaf\x32\x96\xc4\xc2\x31\xfb\x56\x74\xe8\xaf\xc2\x2c\x15\x5b\x51\x23\x80\x7c\xe2\x03\x36\x9d\x70\x09\x62\xa4\xce\xda\xe0\xbe\xae\xf9\x9d\x9d\x0a\xe0\xa6\x2e\x0c\x94\xae\xd8\xe8\x2a\xb2\xfd\x6c\xcf\x03\x6c\x6a\x1d\x21\x3e\x13\x61\x82\x54\xb0\xa0\xc9\xda\x19\x6e\x87\x51\xf4\x34\xda\x0d\x9f\xf6\x9e\x0e\x7a\xfb\x3b\x74\x8f\xd2\xe1\x1e\xdd\x7b\xf2\x64\xfb\xc9\x70\x38\x08\x0e\x36\x36\x20\xc7\xb5\x9c\x81\x45\x4e\x4e\xd2\xfc\x23\x91\xb6\x08\x6d\x52\x0b\x40\x7a\x60\xf5\xf1\x26\x05\xdb\x01\x72\x45\xc9\x28\xbc\xa4\x64\xcc\x33\x70\xac\x4f\xe1\xd9\xfe\xcf\xe3\x63\x15\x01\xb1\xab\x94\x8b\x47\x7c\xaa\x32\x05\x54\xb7\xfd\xf8\xb1\x5c\xde\x71\x78\x8d\x87\xf8\x90\x6c\xd3\xed\x9e\x2c\xa5\xe9\x25\x0a\xa3\x4a\x01\xb3\x0c\x37\xf2\x1e\x16\xd1\x16\x3d\x90\xab\x11\x8b\x46\xe4\x5c\x4a\x65\x73\x32\x4d\xd9\xff\x9b\x52\x29\xa5\x00\x5f\x4b\x32\x08\x73\x1a\x13\x08\x14\x02\x43\x04\x72\x41\x7e\x19\x51\x94\x42\xca\xba\x3c\xb3\x0d\xeb\xa5\x14\x31\xee\x20\xd1\x92\x35\xc5\x07\x78\x7f\x61\xf4\x1e\xf2\x0b\x85\xb4\xb1\x18\xeb\x4d\x3f\xf0\xec\x0a\xe2\xd9\x7a\x7c\xfc\x1e\xfe\xa5\x61\x34\x02\x5b\x00\x0c\x1d\x20\xde\x24\x33\xae\x1c\x63\x7b\x22\x1a\x35\x2b\xdc\xb3\xd9\x5e\x03\x8e\xe4\xce\x79\x38\xd8\xf5\x1e\x1f\x92\x6d\x2b\xe2\xb8\xfd\xe9\x5b\xbd\x29\x86\x89\x6f\xf5\x3a\xe6\x2c\x5b\x23\x94\x9e\xc0\x1d\x12\x9c\xfc\xf3\xf8\xf8\x23\xf9\x37\x9f\xca\x58\xa7\x80\x29\x21\x19\xd3\x31\xcf\x6e\x48\x42\xc3\x8b\x2e\x79\xef\x2d\x5f\x58\x90\xff\xc9\xbb\x41\xc7\x1e\x99\xfb\xd0\x13\x63\x03\x64\xa8\x0d\x93\x26\x27\x1e\x44\x01\x79\x6c\xa3\xde\x63\xbb\x51\xa7\x4d\xf4\x88\xa1\x43\xa6\xa5\x24\xe4\x85\x27\x2d\xd1\x19\xe4\x7e\x42\x38\x88\x95\x4e\xfa\x24\x08\x9c\xb8\xdb\xb2\x15\xec\xaa\x7b\x41\x6f\xc8\x63\x88\xa9\xed\x0d\x04\x8b\xbc\xe1\xa0\xbb\xc9\x3d\xc4\x22\x7b\xba\xca\xf8\x25\x2b\xbb\x30\xa4\x7d\xc8\xa1\xb2\x16\xc2\xa4\xb5\xb0\xaf\x7f\xd1\xa2\x43\xcb\x9a\x08\xbf\x77\xb5\x21\x2f\x00\x22\x87\xf4\x17\xf2\xc2\x75\x18\xb7\x48\xaa\xac\xcd\x07\xbf\x1e\x90\x5b\xdb\xca\xbf\x9a\xf4\xce\x1a\x8c\x20\xcd\xae\x77\xee\xa1\x02\xc6\xaf\x20\x2c\x93\x63\xd5\xd2\x5f\xf2\xc2\x0c\xb5\xef\x0e\x49\x2d\x87\x0c\x46\x6e\xdc\x1a\xc2\x3c\x67\xe7\xa9\xeb\x6a\x8c\xd2\xed\x92\x40\x7f\x1b\x05\x5e\xda\x56\xab\x4a\xa8\x2f\x23\xba\x1c\x1a\x28\x10\xea\x97\x4c\xe5\x01\x4c\x89\x85\x4b\x26\x85\xa3\x30\xb7\x5c\x23\x10\x1f\xb1\x0a\x1a\xdb\x81\x94\xd8\xb5\xa4\x87\xaf\x68\x6c\x07\x82\x77\xdf\x50\xde\x2c\xc1\x5a\xd7\xb1\xd6\x75\x2c\xa4\xeb\x00\xac\x61\xf9\x9b\xf4\x3b\x19\xc7\xb2\x8e\x3b\xdc\xad\x82\x6e\x62\xe0\x2c\xb0\xcf\xcc\x85\xa2\x5f\xeb\x2c\xd3\x91\x27\xfb\xbd\xba\x1a\x4d\xfd\x79\xa0\xba\x89\x6c\xda\x60\x81\xb3\xbf\xed\xc2\x35\x75\x90\xc9\x37\x0e\x82\x73\xfd\x72\xad\x6f\x7c\xa7\x0a\xba\xa9\x0b\x0b\x4c\x57\x55\x98\x5d\xdf\xcd\x6e\x19\xb6\xa9\x13\x0d\xb4\x90\x7d\x85\x05\xd8\x28\xc0\x40\x63\x08\x07\x55\xde\x4f\x6b\xe5\x24\x4f\x77\xcb\xa0\x33\x91\x0a\x9e\xb4\x77\xb2\xad\x68\xaa\xd9\xd4\x7d\x9d\x21\x84\xdb\xa4\x9e\x44\xe5\x39\xda\xae\x80\xde\x9d\xd9\x27\xb4\xa9\x6b\xbe\xe2\xe3\xf7\xf0\x90\xaf\x37\x54\xda\xdf\xab\x82\x6e\x9a\x9c\x05\xa6\xab\xfe\x8b\x65\xc5\x34\x4c\x66\x76\xf6\xb4\xae\x46\x53\x87\x1e\xe8\x67\x7a\x52\x3e\x60\x25\xf2\xa5\xc9\xc5\x25\xa9\x19\x24\x84\x03\xc2\x64\x3d\x43\x94\xe7\xef\x89\x43\x56\x2c\x80\x8e\x4d\x09\x6c\xb9\x9a\xda\xa5\x7f\x96\xb9\x10\x5b\xc5\xfc\xcf\x3c\xf7\x55\x3f\xd5\xea\x65\x69\xa0\xa3\xf5\x59\x2a\x37\xc0\x21\xf9\xcb\xf3\xee\x6e\x77\xe7\x2f\x07\xe6\xdb\x44\xcf\x08\x0c\x60\x7c\xca\x6e\x1b\xc3\xb4\xad\x6a\x5c\x1b\xb3\xaa\x37\x50\xcd\x21\xec\xd7\x9f\x68\x7b\x69\x64\x23\x0a\xe9\xfa\xee\xb5\x69\x3f\x47\x5f\xb8\x27\xc7\xfe\xd4\x2f\xe3\x79\x45\x1f\x72\xc6\x7d\x72\x82\xee\x34\xb7\xd6\xb4\xce\x2b\x08\x16\x3c\x3b\xe7\x98\x43\xbb\xa5\x16\x7d\x6b\xcb\x0b\x38\xbc\x99\xd2\xeb\x62\x33\x61\x29\x85\xe7\x1a\xcd\x36\xf3\x49\x46\xc3\xd8\x74\x3c\xcd\x69\x37\x9c\x4c\x92\x1b\xb9\x85\x2e\xbe\xd9\x2b\x9f\xd3\x62\x3a\x71\xb4\x6c\x65\x0b\x81\x7f\xe6\xb9\x67\x16\x00\xb5\x6a\xf4\x8a\xd8\xa2\xab\x33\x35\xfb\xeb\xb3\xf8\xe4\x5b\xd2\x13\xc7\xdb\x30\xf5\xbd\x8f\x9e\x1f\xd9\x0b\xf7\x23\xc6\x1d\xb3\x34\xf8\xfa\x85\x5b\x43\xb7\x2d\x1d\xa3\x8d\x6c\x0d\xb6\xc5\x33\x20\x8c\x5a\x7c\x6b\x8b\xfc\xf5\xfb\x84\x5f\x7d\xcf\xae\xdf\x52\xb7\x97\xaa\xbd\x9f\xd1\x6e\xab\x5d\x32\x18\xb0\xe7\xc7\xd2\x5c\xb0\x9b\x3c\x85\xc0\x1f\xe4\x2b\x25\xeb\x72\x26\xe5\x01\x99\x3e\xdd\x0f\x07\x15\xed\x5f\x22\xb2\x8b\xc7\x80\x2a\xd2\x54\xbb\x6e\x0d\xad\x3b\xa3\x54\xf4\xdb\x6f\xe5\xb6\x5f\x34\x9e\x29\x71\xe4\x6a\x4e\x63\x79\x69\x16\x3b\x16\xee\x54\xe5\xa1\x6d\x57\x9f\x16\x1f\x4a\x63\x9b\xa5\xf7\xad\xd5\xdd\xa3\x91\xe0\xdc\x46\x08\x88\x0a\x86\x8d\xae\x39\x54\x3e\x58\x2b\x47\x0b\xee\xf9\x4f\xd9\xb6\x7b\xca\xb6\x9b\x4e\xd9\xb6\x77\xca\x6c\xb3\x87\x0a\x5d\xb5\x1b\xe7\x12\xe0\x20\x9e\x36\xaa\xd5\x9d\xf8\xff\xaa\x15\xc5\x64\xda\x17\x9e\xfc\x66\xe9\xcf\xeb\xa1\x1e\x93\x6d\x3f\x28\xbf\x76\x98\x50\x97\x8f\xf5\x82\xb1\xef\x1d\x5c\xb9\x8e\x9b\x61\x4e\xce\xaa\x63\x0d\xf5\xd7\x3c\x47\x0d\x7e\x47\x17\x95\xce\x74\x5f\x2f\x47\xf9\xb8\xff\xf6\x5b\x0d\x21\xe8\x58\xab\x61\x9f\xc9\x7e\xd3\x49\x36\x95\xcc\xa5\x56\x79\x12\x3b\xee\x5a\xdb\x29\xf6\x20\xbf\xb6\x63\x9a\x22\x31\xbc\xcb\xd3\x9f\x50\x30\x2d\x91\x4b\x3d\xe8\x1c\xb4\x87\xd2\x3a\xbc\x7f\x05\x59\x4c\x40\x40\x6c\x61\x3e\xe8\xbe\xd0\x94\x86\xb0\x02\xdd\x3d\xe7\x37\x12\x12\xd5\x66\x9e\x0c\x1f\xcc\x37\x2c\x41\x29\x28\x26\x59\x31\x04\xb6\x0a\xb3\x1c\x93\x9f\x83\x25\x8e\xbc\xd6\xff\xf1\x69\xb1\x28\x05\x10\xac\x7f\xe3\xd9\x07\x85\x5f\xea\xdc\x67\x80\xf1\xd0\xc9\xea\x4e\xfc\x9c\xd4\x64\xc7\x6d\x7b\xa7\xa9\xed\x1d\x8f\x9a\x6c\x6d\x91\xd7\x10\xd8\xd8\x5d\x30\xf0\x6b\x1b\x72\x41\x69\x80\x86\xe3\x39\xed\x5a\x14\x46\x91\x18\x80\x3c\x2c\x45\xec\xb7\x7f\xf5\x95\x78\x16\x97\xac\x8d\xe0\x32\x9e\xaa\x4d\x90\xcc\x2c\xa1\x3f\x73\xb5\xab\x85\x4d\x9d\x0b\x1f\xbb\x76\xfd\xf7\xfc\x5b\xe9\x28\xcc\x25\xaa\x8b\x3d\xfb\x3e\x84\xc0\xd4\xca\x5d\xab\xe0\x50\x2a\x7f\x9a\x4a\xa3\xa2\x98\xe4\xfd\xad\xad\xbc\x08\xa3\x0b\x7e\x49\xb3\x61\xc2\xaf\xba\x11\x1f\x6f\x81\x3e\x45\x00\x6f\x3d\xd9\xde\xdd\xd9\x7f\xb6\xb3\xbf\x35\xe4\x59\x44\x37\xa3\x10\x52\xf1\x6d\xb2\x74\x53\x00\x5b\x5b\x97\x99\x1e\x0c\xc5\x36\xc7\xd9\x7c\x95\x7e\x72\x06\xbb\xdd\xaf\xd6\xed\x5e\x49\x6b\x6c\xf2\xff\x95\x5d\xb1\x44\xf3\xda\xa4\xf1\xb3\xea\xa0\xf4\xa1\xb6\x07\x78\xa9\x28\x7d\xb5\x57\xa8\x43\x11\xda\xeb\xe1\xb2\xde\xf0\x1e\x77\xb8\x6d\x0c\x42\x02\xbb\xde\xb1\x1b\x6d\x3b\xbc\xa6\x33\x86\x1c\x82\xc3\xf1\x0c\xc2\xaa\x4e\x13\xe7\xd1\x68\x49\x3a\xec\x6e\x6c\x7b\xb7\x69\x42\x4d\x13\x87\x24\xe8\x2a\x95\x4a\xed\x32\x81\x4e\xab\xcc\x09\x55\x93\x72\x6d\x21\x50\x22\xe4\xd9\x54\x21\x7a\x95\x11\xa5\xb4\xec\xc5\xf6\xba\xe4\x27\xb1\xa4\xb1\xa5\x90\x94\xe9\x41\x58\x7a\xc9\x2f\x68\xac\xd2\x2a\x39\xf3\x6f\x22\x77\xd3\xbc\x8e\xce\x4d\x73\xea\x3d\x1b\x4e\x21\x94\xbb\xc2\x4f\xf9\x41\x4b\xc7\x4f\x13\x9a\x56\x50\xa7\x0e\x31\x8f\x50\xb4\x69\x12\x80\xed\x0e\x39\xc5\x00\xb5\xbd\x03\xfc\xeb\x1b\x68\x00\x7f\xb8\x76\xb5\xb2\xfe\xc9\xa9\xd4\x00\x18\x52\x76\x6a\x42\xea\x58\xeb\xaf\x96\x7e\xc8\xb3\xd7\xe2\x96\x31\x4f\x6e\xfc\x62\xb7\xbd\xb5\x45\x5e\x5e\x72\x16\xe7\x90\x84\xe8\x86\xa5\xe7\x24\x17\x07\x00\x21\x49\x71\xc5\x22\xda\x21\x61\x41\x12\x2a\xc8\x88\xd6\xed\x66\x74\xd8\x35\x37\xfb\x90\xb4\x4e\x9d\x13\xa9\x86\xa0\xcc\x50\x55\xc7\x87\xd2\xf0\xd9\xb6\x01\xae\xae\x09\x66\xcc\xb2\xda\x41\x09\x5a\x41\x89\x3d\x2a\x01\x69\xe3\xe0\x46\x4e\xb9\x64\xcf\xf8\xcf\x3c\x6f\x34\x62\xfc\xa7\x4c\x2c\xeb\x68\x02\xef\xe6\x54\xbf\xf6\x71\x59\xeb\x7d\x1e\x82\xde\xe7\x81\x8b\x27\x31\x03\xb0\x94\xe8\xd7\xfb\xa8\x68\xa8\x16\xec\x9e\x8c\x13\x35\x97\x4c\xd1\xd4\x75\x44\x8b\xa0\x6a\x3e\x24\x41\x0e\x9f\x03\x4b\x4e\xc5\x72\x79\xad\x51\x08\x85\x83\xc9\x50\xcc\x67\x24\xed\x32\x2a\xba\x92\x53\xa2\x35\xa2\xb2\x89\x25\x65\x61\xa3\xe6\x8c\x24\x31\xd7\x09\x14\xff\xae\xed\x6d\x4a\xc6\xf6\x60\x1e\xde\x24\x7b\x48\xf9\xe6\x34\x9d\xe6\x34\xde\xbc\x0c\xb3\x7c\xa3\xec\x6f\xa3\xa7\xee\x09\xd5\x96\xb6\xd7\x2f\x5b\xf1\x9a\xf9\xb7\x6d\xda\x8f\x0f\x06\x60\x36\x02\x43\xbe\x0d\xd9\x91\x8f\x73\x41\x7a\xe0\xcf\x6f\xac\x85\x34\x34\x48\x7c\x72\x2f\x4c\x02\xad\x3e\x3e\x34\x7b\xf1\x98\x04\x10\x23\xc4\xd4\x57\xc9\xcd\x1f\x93\xe0\x20\xb0\x2f\x18\x90\x1d\x78\x60\xe2\x7d\xff\xb1\xad\x5a\x0d\xfe\x93\x06\xe5\xdb\xc6\xbc\x4b\x8b\xac\x74\x25\xdb\x16\xfa\xd5\xe3\xb1\x07\x52\x65\x6c\xaf\x77\xa9\xd9\xd0\xde\x02\xf3\xaf\xaa\xd5\x06\x3a\x59\xd1\x55\xb5\xb6\xd2\x58\xdf\xd6\xeb\xdb\x7a\x09\x2b\x8d\xb9\x62\x2c\x38\x90\x4d\x5a\x51\x1d\x10\xe1\x4f\xaf\x0e\x55\xa6\xaf\x62\x16\xe2\x48\xfd\xed\x82\xde\x0c\xb3\x70\x4c\x73\xed\x36\xfb\xbf\x55\xc9\x2c\x8e\xc4\x01\x44\xa6\x04\x7f\xcf\xc9\x95\x38\xf5\x2b\x19\x13\x3d\xb8\x3b\xf2\x26\x95\x3c\x88\xf2\x17\x94\xb6\x2c\x20\xc4\xd6\xc8\x64\x8b\xb0\x6b\x44\xd7\x04\x93\xe1\xa1\x60\x18\x65\xbd\x1b\xce\x05\x0f\xd2\x2b\x96\xca\x45\xf1\x7d\x2c\xc1\xe6\x3f\x8c\x63\x29\x0a\x41\xa0\x13\xf1\xe3\xa3\x27\x2d\xb7\xa7\x60\x8b\xcc\xed\xfe\x8d\x1c\x5a\xc9\x38\xfa\xd0\xbf\x2f\x89\xbe\xdd\xf0\x66\xde\x95\x36\xd2\xad\xf6\xa2\x7c\x59\x89\xd5\x72\xf6\x73\x49\x6e\xeb\x5e\x15\x99\xc0\x4c\x89\x15\xdb\x26\xbe\xb6\x25\x35\x62\x37\x5c\x96\x5a\x97\x48\x88\x02\x99\x42\xa6\x69\xac\xe6\xb1\x4c\x55\xbc\xd0\xa7\xff\x40\xa2\x71\x09\x4f\x82\xdb\x7a\x4e\xc8\x59\xc4\x46\x66\xc8\x83\xf4\xf9\xa1\x07\x16\x6d\x6c\xcd\x0f\xad\xf9\xa1\x35\x3f\xb4\xe6\x87\x1e\x26\x3f\x74\xc4\xd3\x18\x02\x44\x84\x09\xca\xd6\x81\x37\x1a\xd3\x98\x85\x1d\xf2\x37\x99\xe0\xde\xb0\x48\x16\xf8\x2c\x26\xc9\x03\x45\x36\x49\x29\xc5\xe7\x62\x93\xbc\x16\x2a\x19\xa5\xc8\xc0\xfc\xae\x59\x25\xdf\xce\xa2\x92\x55\x42\x20\x64\x95\x96\x63\x6b\x0a\xa9\x42\xa9\x65\x65\xbc\x35\xf7\x98\x99\x73\x5a\x34\x28\x90\xe5\x57\x4f\x7b\xec\x04\x31\x80\x11\x9e\xd3\x02\x61\xea\x94\x43\x62\x9c\x28\x9f\x81\x6c\xb4\x7a\xc0\x35\xaa\x1e\xa9\x8c\xa8\x19\x95\x52\x55\x64\xda\x77\xb5\x7a\x54\x0e\xdc\x2c\x1d\x3c\x98\x1b\x48\x0d\x16\xba\x8b\x65\xd3\x54\x2b\x68\x1a\xc6\x1a\xc6\x71\xc3\x0a\xca\xaf\xae\x92\xb0\x24\x87\xb3\x54\x8d\xf5\x68\x62\xea\x39\x96\x18\xdc\x28\x64\x9b\x55\x79\xce\x32\x35\x69\xf2\x1a\x78\xe5\x3b\x06\x0c\x79\xf8\x2c\xb1\x0a\x41\x0c\x55\x5e\x34\xb3\xbe\xff\x49\x6f\x6d\x3f\xb8\x0a\x0e\xd8\x3b\x7b\x8d\x3c\x70\x09\xd6\xe7\x82\x1f\x58\xe4\xd5\x35\x0b\xb8\x66\x01\x97\x65\x01\x21\x26\x48\xad\x43\xc9\xae\x0b\xd7\xc4\xfd\x01\xc0\x9a\xf5\x13\x8b\xf5\x3d\x4f\x8b\xef\xc3\x68\xa6\xf2\xcd\x86\xb3\x58\xb8\x39\x39\x38\xbb\x76\x25\xfb\x36\xe4\x69\xb1\x39\x0c\xa3\xbb\xea\xe0\x94\x15\x95\x65\x5c\xb5\x1a\x1d\x5c\x89\x41\xb2\xa7\x74\xcf\x8a\x35\x98\xcc\x2a\x14\x6b\xd0\xd0\x5c\x8a\x35\x30\x5d\xc2\x73\xe4\x58\x2d\xa9\x85\xef\x58\x0d\x4a\x4d\x5b\xbb\x52\xc9\x66\x41\xac\x4a\xc9\xb6\xc8\xd8\x7c\xee\xa7\xe2\xb6\xb5\x37\xb2\xf1\xaa\x75\x01\xfd\x7b\x76\x1d\x0c\x75\x7d\xcf\xae\xef\xd9\xf5\x3d\x5b\x73\xcf\xfe\x8b\xd1\x2b\x71\x78\x67\xdd\xb3\x36\xdc\xe2\xf7\xac\x5d\xbb\xf2\x9e\xbd\x94\x00\xbf\x9b\x6b\xd6\x9e\xd1\xaa\xae\xd9\xfb\xb9\x47\xec\x91\x36\xde\x23\x2e\xa0\x77\x8f\x3c\x7b\x60\xa1\x12\xb7\xb6\xc8\x2f\x21\x2b\xb4\xbd\xf8\x39\x2b\x46\xd3\x01\x18\x8a\x0b\x76\x6d\xc0\xf9\xc5\xd6\x30\xe1\x57\x5b\x2c\xcf\xa7\x34\xdf\xda\xdd\xef\x91\x82\x93\x01\x25\x43\x76\x4d\x63\x31\x27\xd7\x72\x89\x08\x68\x81\x8e\x5b\x72\xe4\x9b\x97\x61\xc2\xe2\xcd\x21\x4b\xe8\x26\x1c\x29\xc8\x7c\x08\xc8\x20\x79\x19\x76\xce\xa5\xa7\xe6\x5e\xaf\x4f\x82\xff\x45\xf7\x69\x38\x7c\x0a\xdb\xbe\xdd\x83\x92\x68\x2f\x0a\xe9\x73\x28\xd9\xc1\x92\xe7\xc3\x70\x3f\x0e\xa1\x64\x17\x4b\x9e\x3d\xdf\x7f\x1a\x0d\xa0\xe4\x09\x96\xec\x45\x4f\x07\x51\x0f\x4a\xf6\xb0\x64\x77\xb8\xb7\x3d\xd8\x83\x92\xa7\xb2\xe4\xf9\x93\xe7\x21\xd6\x7a\x26\x4b\x7a\xbb\xc3\xe7\x28\x64\xda\xc7\x92\x9d\xfd\xdd\xbd\xe7\xbb\x50\xf2\x1c\x4b\xb6\xc3\x9d\xdd\x67\x28\xdc\x79\x29\x87\xb8\x1f\x3d\xa7\x43\xac\xf6\x52\x8e\x71\x6f\xf7\x69\x3c\x94\x50\x72\x48\xbb\xf1\x5e\xa8\x8a\x74\x7f\x4f\x86\xb2\x28\xe2\x69\x91\x85\x79\x21\xc9\xe6\x11\x4f\x78\xd6\x27\x41\xc2\xce\x47\x45\x50\x93\x93\x07\xd7\xaf\x8c\x67\x0f\x2c\x10\xe2\x17\xc7\xb3\x09\x4b\x2f\x1c\x2c\x1b\x46\xf4\x09\x8d\x6c\x2c\x1b\xee\x0f\x06\x71\xcf\xc6\xb2\xe1\x93\xfd\xe1\x60\xdb\xc6\xb2\x61\xef\xe9\xce\xf3\x1d\x1b\xcb\x68\xf4\xa4\xf7\x2c\xb4\xb1\x8c\x3e\xdf\xa6\x4f\x77\x6d\x2c\x8b\xf7\xb7\x07\x4f\x7b\x36\x96\x45\x3b\xdb\xfb\x7b\x03\x1b\xcb\xc2\x78\xfb\xc9\xde\x33\x1b\xcb\xf6\xf7\x7b\xf4\xc9\xd0\xc1\xb2\xe1\x70\xbf\x27\xd1\x55\x61\xd9\x70\xf8\xa4\xb7\xbf\xed\x60\xd9\x70\xaf\xd7\x93\x4d\x29\x2c\x8b\xf6\xb6\xb7\x9f\xee\x2c\x8d\x65\x62\xf5\xca\x38\xf6\xc0\x42\x2b\x7e\x71\x1c\xcb\xe0\x86\xb5\x50\x6c\x48\x07\x94\x3a\x28\x36\x8c\xe2\x78\xc7\x46\x31\x3a\x7c\x1e\x3e\x77\x08\x19\xdd\x7b\xb6\xfb\x6c\xd7\x41\xb1\xe1\xde\xee\x9e\x43\xc8\x86\x4f\x9e\xec\xee\x3e\xb5\x51\x8c\xee\xed\x3e\xdf\xdd\xb3\x51\x2c\xde\xdd\x19\xee\x38\x84\x2c\x7a\xba\xb3\xbf\xb3\x6f\xa3\xd8\xe0\xd9\x76\xb4\x1d\xf9\x28\x16\xee\xf7\x3c\x14\xdb\xdb\xd9\xdb\x71\x51\x6c\xb8\xfd\xec\xc9\x13\x07\xc5\xe2\xbd\x5e\xaf\xd7\x5b\x1a\xc5\x32\x48\x85\xe4\x61\xd8\xdd\x02\x41\x96\x72\xd9\x7d\x22\x3a\xec\x66\xbf\x26\x05\xde\x76\x5b\xb4\xa7\x30\x0d\xb1\x8b\x94\xc3\x8a\x3e\x5b\x6d\x08\xb1\xcb\x55\xa7\x3f\xf9\x8c\x01\x7a\xca\xba\xc2\xea\x29\x3c\xab\xab\xd1\xd4\x5f\x85\x6e\x10\x9a\xf0\x6d\xb8\xaa\xbb\x7c\x5a\x0d\xdf\xd4\x61\xc9\x66\xeb\x33\x85\xa4\xf1\x1e\x10\xd5\xf3\x79\x5e\x09\xde\x1c\x2e\xc5\x7d\x31\xe0\x10\x6d\x7b\xfc\xea\x9e\xf6\x2a\x80\x1b\x27\xe4\x18\xe0\x43\x45\x4f\xf4\x58\xdd\xcf\x7e\x25\x78\x53\x4f\xbe\xac\xf1\xf3\x24\xfa\xb1\x8f\xfe\x83\xf4\x19\x7a\x95\x85\x57\xb5\xb1\x76\xf6\xb6\xe7\x4a\xac\xa6\xe6\x7e\x0f\xd9\xa0\x70\x78\x6d\x45\xef\xad\xcc\x4f\xab\xdd\x3f\xd9\x7e\xc3\xee\x3d\x30\x33\xfa\xf2\x45\x18\x46\x05\xbb\xa4\xaf\x13\x3a\x86\xfc\x9f\x32\x16\xd8\x55\x4a\xb3\x57\x3c\x02\xdd\x66\x2d\x35\x37\xf4\xc1\x81\x6f\x8c\x1e\x66\x03\x7e\x96\xfd\x30\x5a\x70\x7b\xa2\x56\xf0\xd6\x98\x47\x2b\xd2\xfe\x82\x08\xc0\x5d\x0a\xb5\xd0\x2a\x1e\x4e\x29\x11\x72\xcc\xa3\xae\xb7\x05\x5e\x4a\xe4\xad\xaf\x09\xa3\x28\x34\x82\xc8\xda\x29\x97\x53\x21\x14\x6b\x90\xaf\xb7\x6e\x37\x6e\xcb\xec\x47\x59\x5c\x50\xe6\x2b\x1e\x9a\x55\x63\x19\x3f\x8d\x6c\x2b\xe5\xb1\x18\xd4\x25\x4d\x8b\x0e\x19\x85\x69\x9c\xd0\xac\x43\xa2\x70\x52\x4c\x33\x69\x83\x81\x3b\x90\x5a\xcb\xde\x5c\xc9\x4a\xf8\xab\x76\x65\xcc\x2f\x2b\x32\xa9\x78\x81\x77\xf9\x70\xb8\x50\x1f\x52\xc4\x83\x11\xe3\xf1\xc4\xa4\x75\xc4\xd3\x8a\xbe\xc6\xd3\xc6\xb3\x94\x1a\xc0\x61\x5d\x6e\xf1\x3d\x8b\xe7\x12\xa3\x6e\x6a\x6f\x38\xfc\x12\x14\xf2\x41\x9a\x14\x48\xbb\xab\xba\x10\x79\x4f\x7c\xc0\xa6\xe8\x78\xaa\x2d\x2b\xd2\xa2\x18\xe3\x2f\x18\x39\xc2\x88\xd9\xeb\x3a\xdb\x9b\x55\xb1\xa9\xf3\xba\xbe\xda\x56\x22\xd8\x9f\x94\x62\xe0\x5d\x1d\x16\xed\xd7\x80\x37\x06\x61\x77\x20\x8d\x12\xc9\x91\x34\xd7\xcd\xf9\x79\x0d\x7c\x63\x14\x42\xb7\xe5\x2a\xb5\x55\x6d\xc8\xc3\x5e\x15\xf4\xec\x90\x87\xd8\xa8\xae\x3b\xe1\x79\xce\x06\x09\xb5\x24\xfe\x18\x14\xbd\xb6\xdf\xed\xd9\x75\x9b\x46\x51\xdf\xa1\x89\xb8\x9a\x8e\x68\xc6\x8a\xfa\xa9\x97\x41\x9b\x7a\xd4\xcd\x99\xa0\xa4\x34\xac\xcd\xf1\xbe\xed\x42\x35\x86\x2e\x15\x00\x1a\xfc\x43\x16\xa6\x98\x62\xac\xa6\x65\x2b\xe2\xa7\x81\x6d\x6a\xdf\x40\x19\x8d\x93\x2e\xaa\x7b\x09\x5b\x0f\xe1\x2b\x56\x8c\x3e\x8c\x68\x6d\xd8\xce\xe7\x3b\x65\xd0\xc6\x24\x0b\x0a\xe8\xb3\xd0\x5c\x31\xae\x41\x38\xa0\x09\x06\xd1\xfb\x3e\xe1\x57\xef\xc5\x82\x0b\x8a\xf0\xe1\x66\x42\xf3\xd3\x49\xc6\x27\xe2\xa8\x9e\x4a\x3e\xa4\x76\x47\xbb\x0b\xb6\xf3\xdb\x6f\x95\x0d\xf5\xda\xdd\x30\xbd\x01\x31\xda\xdf\x24\x52\xd1\xd8\x64\xab\x37\xdb\xb5\xd0\xe0\x4d\x35\x41\x08\x06\x61\x74\x51\xf7\x16\xec\xcd\x3d\x91\x8a\x36\x67\xcc\x69\xb9\x11\xbf\x9a\x66\x61\x03\xc6\x2f\x35\x62\xdd\xe6\x0a\x47\x0c\xaa\x5f\x29\x79\xd4\x8a\xb8\xbf\xb1\xf3\x94\x67\x54\xfb\x98\x87\x93\x09\x0d\xb3\x6a\xb1\x97\x98\x08\xe7\x49\xc7\xd1\xe4\xbd\x24\x39\x4b\xcf\x13\x4a\xa2\x11\x4b\x62\xcc\x90\x9f\x16\x8a\xc7\x35\xce\xeb\xf0\x39\xa3\xa9\x8e\xe3\xbe\x28\x5a\x1f\x1e\x92\x40\x9d\xb7\x80\xbc\x58\xb0\x7e\x97\xe5\xf2\x6c\xc6\x77\xaa\xdb\x5f\x74\xdc\xb5\x4b\x99\x8f\xc2\x09\x6d\x2d\xd6\x5a\xdb\x1a\x8a\xbb\x0d\x6f\x86\xe4\x4c\xf0\x42\x67\x1d\x08\x75\x16\xe9\x03\x09\x91\x73\x0c\xc5\x24\x2c\x35\x7b\xc2\xd2\xc6\x8d\xae\xed\xcc\x47\x1a\x9e\xbe\x16\xe4\x6f\xd1\xad\xad\x3a\xf4\x4b\xee\x72\x45\x53\xab\x59\xf8\x72\xc3\xed\xb9\xd6\x82\xa5\xe7\xeb\xe5\xc0\xe5\xb8\x66\xc5\x7a\x29\x36\x08\xa4\xe9\xa5\xb5\x7d\x23\xc3\xdf\xdc\x02\x18\x21\x2c\xd4\xc2\x87\x11\x25\xb1\xba\x4b\x86\x3c\x03\xe2\x60\xa8\x41\x87\xb0\x94\x8c\x59\x92\xb0\x9c\x46\x3c\x8d\xd1\x59\xe1\x6b\xcc\x3e\x13\xde\x90\x7c\x42\x23\x36\xbc\x21\xa1\x22\xf2\x05\x1b\x53\x3e\x2d\xa0\xa9\xd0\x21\x2c\x79\x87\x70\xd4\xd3\x5f\xb2\x78\x1a\x26\xc9\x8d\x0c\xd2\x05\x7c\x8f\x78\xdb\x99\x85\xc0\x46\x96\x47\x0a\x73\xe3\xde\x19\x29\x74\x53\xab\x46\x0a\xd5\x70\x1b\x64\x07\x52\xf1\x37\x4c\xf8\x95\x2d\x1b\xc1\x12\x10\x44\xb8\x79\xdc\x79\x4c\xbb\x79\x94\xf1\x24\xf9\xc0\x27\x4e\xee\x48\xb1\xa3\xdf\x87\x31\x75\x68\x7a\x4e\xa6\x39\x8d\xc9\xe0\x06\xf6\xf7\x2d\x8f\xc3\xc4\x5c\x01\x90\x54\xe9\x4d\x11\x08\x20\x96\x9e\x93\x13\x60\xd9\x37\x4d\xfd\xcd\xf3\x8c\x4f\x27\x1f\x5b\x15\x1a\x51\x00\xfd\x35\xdf\xaa\xae\xd2\x26\xc0\xf6\xa6\x62\xb7\x65\xee\x25\xb0\x26\x16\xc3\xb3\x25\x40\xa7\xb0\x5c\x7f\xd5\x5c\xa2\x25\xf4\xd1\x6f\x17\x23\x96\x11\xd5\x3b\xa4\x54\x07\xe4\x70\xc6\x12\x39\x8c\x8d\x74\x47\xbe\x54\x86\x07\x26\x2f\xd1\x69\x41\xc7\x93\x0e\xc6\x11\xeb\x88\x8f\x85\xfc\x88\xe1\xf8\xdc\xc7\xa9\xe9\x5b\x1a\x2a\x87\x31\x2d\xf9\x66\xd5\x06\x7e\x0b\xb3\xf3\x65\xa3\xbe\x89\xaa\xcd\x01\xdf\xa4\xd9\xab\x92\x9b\x67\xa0\xa4\x6b\xc1\xec\xf0\x0f\x8c\x55\x07\xb3\xaa\x7f\x8a\xfa\x13\x14\xcf\xb6\x21\x39\x84\x89\x76\x4f\x4f\xc1\xac\xf0\xf4\x14\x62\x27\x8b\x86\x3c\x61\x81\xbb\x35\xed\x36\x78\x02\xcb\xd8\xc5\xa2\xa1\x0e\x81\x2c\xb3\x3a\x78\xbc\x98\x55\xbb\xdd\x96\xab\xaf\xfe\xed\xa2\x84\xed\xb5\xcc\xb6\xe5\xca\x07\xcd\x92\x20\xea\x83\x89\x32\x9f\x84\x11\x2b\xc4\x3a\x06\x3d\xcb\xaf\xdc\x1c\x19\x27\x48\xa2\x0c\x19\x07\x06\xa9\xf2\x12\xb6\x8d\x9a\x2b\x3e\xab\x46\x6c\xe3\xe3\xdb\x8a\xd1\x62\x7e\xbe\xba\x01\xeb\x90\x81\x7f\x9d\x48\x06\xdb\xea\xaa\x63\x59\x43\x17\xea\x15\x6a\x80\xbb\x50\xe6\x00\x49\x02\xeb\x81\x61\xa9\x9e\xaf\xb5\x48\x85\xfd\xe2\x86\xe6\xac\x22\x15\xf4\xbb\x15\xc8\xb5\x0c\xec\xc0\x09\xea\x62\xd0\x84\x58\x77\x6e\xc5\x51\x26\x2f\x74\x71\x5f\xfd\xd5\xa5\x62\x59\x74\x4c\x05\xb5\x82\x4e\x5c\x72\xb2\x39\xdb\xc2\x62\x32\x4d\x92\xad\xbd\xed\xa7\xdb\xe5\x69\x5d\xd1\xc1\x05\x2b\x3e\x3c\x9c\xc9\x55\xe3\xe5\x76\x30\x0b\x07\x59\x7a\x3e\x03\x0d\x59\x7a\x3e\x0f\x26\x5e\xb3\xb2\x58\xbd\x16\x0b\x77\x16\x42\xc3\x9d\x39\xf1\x70\xe7\xe1\x21\xe2\x35\x2b\xfe\xb0\x78\x58\x35\xb7\x7a\xf2\x58\x8f\x86\xd7\xac\x68\x40\xc1\x6b\x56\xd4\xa2\x1f\x1d\x4f\xda\x9d\xf9\x2f\x17\xeb\xb6\x35\xfe\xc6\x56\xfc\x5b\x94\xce\xfa\x37\xfd\x89\x1b\x7f\x3b\x8d\x69\x56\x1b\x75\x5b\x7c\xf4\xc3\xb5\x2a\xb2\x5b\x8d\xee\x28\xd0\x10\x78\x8c\x33\xc6\xdf\x36\x84\x92\x4c\x18\x18\x55\x62\x43\xc9\xc3\x6a\x80\x64\x41\x05\x8c\xcc\xe7\xea\x1f\x72\x0f\x12\xcf\xf3\xa9\xbd\x0f\x1d\xc7\x05\xe7\x26\x01\x45\x88\x01\x42\x1b\xe4\xaa\xa3\x5c\x73\x99\xf0\x62\x04\x23\x46\xdd\x57\x8d\x12\xc2\xda\x3e\x5c\x3c\x72\x12\xe0\x22\x05\x1d\x12\xa8\xa5\x10\x7f\xcb\xa9\x58\x7f\x82\xdd\x35\xfc\xba\x66\x85\xf8\x0b\x86\x28\xfe\x80\xb1\x40\x02\x05\xdb\x9b\x56\x59\x8c\xc3\x80\x94\x0a\xc6\x0c\xe0\xd3\x6d\xc7\xcc\xbb\x6d\x87\xee\xfe\x9e\x67\x24\xa7\xd9\x25\xcd\x48\xce\x62\x2a\x31\xc1\x78\x16\xa3\x19\xbf\x85\xd8\x0c\x44\x67\x38\x0f\x1b\xf9\x1b\x38\x0b\xdf\xc3\x48\xca\xbe\xd5\xf0\xe4\x29\x57\x8a\x68\x73\x9c\x2c\x39\xb6\x82\x35\x9b\x50\x37\xd3\x12\x86\xf6\x49\x19\x33\xe5\x7b\xaf\xb4\xef\x46\xde\xe2\x71\x2a\xd5\xc8\x58\x86\xab\xc4\x46\x17\xcc\x10\x1f\xa0\x05\x80\x4a\x6d\x53\x49\xe1\x85\x2c\xf0\x0d\xe2\x8d\x5f\x55\x18\x83\x1d\xbc\xbf\x98\x0e\x5f\x0f\x6c\xa8\xca\x16\x63\x49\x29\xd5\xca\x28\xbb\x12\xfd\x70\xc4\xe5\xa3\xb8\x08\xb6\x3e\xa0\xab\xc8\x2d\xde\xe2\x2c\x3d\x3f\x8e\x32\xaa\x4e\x32\x85\x59\x56\xc3\x27\x34\xbc\xd4\xe0\x68\x77\x52\x65\x76\x81\xf9\x5b\xb5\xa2\xc0\xb2\x13\x68\xa9\x57\x83\xa7\x27\x5d\xad\x4b\x98\x1a\x91\xa5\x40\x90\xce\x4c\xfa\x93\xce\xb9\x9a\x1f\x8b\xa7\xab\xb1\x28\x50\xb7\xb7\x2e\xb7\x02\xca\x6b\x10\xbd\x36\x1f\x34\x07\x50\x2a\xd3\xba\x2f\xf5\x00\xae\x11\x7d\x1b\xed\x9c\x86\x6c\x52\xad\x68\xa0\xcf\x6b\x60\x52\x9a\x5e\xcb\x2a\xb9\x99\x50\x63\x72\x22\xd7\x4f\xa0\xa8\x8c\x1f\x1f\x18\x50\x08\xf4\xe9\x54\x24\x8f\x49\x20\x9b\x04\x22\x73\x09\x09\x99\xc3\x41\x42\xe3\x79\x9b\xa8\x4e\x49\xac\x5c\xf2\x36\x24\x75\x7c\x33\xf4\xe4\x3a\x84\xe5\xaa\xa7\x0d\x45\x1d\xd1\x09\xcf\xeb\xdf\x8a\x0d\x8f\xed\xa4\x5c\x73\x22\x5a\x6e\xc4\x72\x32\xc9\xf8\x25\x8b\xa9\x9d\xd5\x06\xdb\xf3\x96\xc4\x4a\x86\xfd\xc9\x77\xe6\x4c\xe9\x15\x41\xaf\x29\x7f\x1d\x1f\x93\x80\x5c\x85\x79\xfa\x9f\xa0\x20\xf9\x74\x32\x49\x18\xa6\x7f\x3e\x3a\x3e\x36\xc4\xf5\xef\x19\x9f\x4e\xfa\x10\x4f\x35\x80\x57\x6f\x14\xa6\x24\x0a\xc5\xf9\x98\xa6\x19\x4d\x18\xd8\x62\x87\x29\x1b\x87\xa8\x1a\x0c\xd3\x98\x5c\x71\x68\x74\x40\x89\x0c\x5e\x43\x63\xc2\x52\x6c\x24\x24\xc3\x69\x31\xcd\xa8\x4a\xba\x4d\xf8\x90\x80\xd0\xa1\x4b\x8e\x29\x45\x18\xc5\x3a\x0e\x07\xdd\x31\x95\x52\x10\xdd\x45\x49\x1e\xb2\x69\x8b\xc7\x20\xb9\x37\x34\xc2\xd2\x21\xcf\xb0\x4a\x37\x30\xd7\x9a\xbd\x75\xd6\x5a\xa7\x41\x41\x42\x82\x8c\xa1\xba\x99\x08\x4d\x72\x6a\xe7\xbb\xa9\x59\xfc\xba\x04\x38\x73\xed\xc0\x78\x9a\xc3\x4a\xa9\xce\x49\xcb\x13\x0e\xb6\x03\x9f\x47\x74\x84\x13\x62\xdb\x55\x42\x66\x3c\xf6\x3e\xbd\xa9\xa3\x43\x16\x79\xd0\x17\x04\x4f\xe9\xbb\xa1\x28\x6b\x9d\x54\x7d\xc6\x21\x76\x2a\xab\xa2\xc4\x0e\x8d\x13\xf1\x86\xa8\x6f\x60\x43\xdf\x0a\xb5\x30\x1b\xb7\xb6\xda\x45\x27\xba\xab\x27\xb3\xe5\x2f\x4b\x4c\x10\x3d\xe2\xee\x30\x41\xd9\x40\xe3\x04\x0d\x0c\x9a\xa6\x35\x41\x6d\xdc\xb6\x57\x33\x1a\x01\xf4\x72\x66\x77\xf3\x0e\x5c\xc0\xcc\x6e\x6d\xe3\xb6\xfd\xb1\x7c\x37\xef\x3f\x30\x37\xbb\x46\x33\xba\x8c\x46\x61\x12\xe1\xa9\x06\x6e\x37\x67\xff\x05\x17\x69\xfb\x83\x7c\xff\xb1\xf4\xd5\xbb\xb7\x86\x39\x71\x73\xf7\x80\x58\xf9\x15\xbb\x24\x87\x24\x96\xf6\x8e\x1e\x6f\x1b\xc4\xec\xd2\x22\x54\xba\x86\x7c\x78\x4e\xb8\x7e\x0b\x07\xe1\x20\xe7\xc9\xb4\xa0\x9a\x8b\xf6\x81\x0b\x78\xc1\x04\x9b\xcf\x9f\x3f\x7f\x3e\xb9\xae\x05\xbb\x62\x71\x31\x12\x80\x7b\xbd\x06\xa8\x11\x85\x94\xf8\xb3\xc0\x54\x26\x1b\x08\xea\x0e\xdf\xcc\xfb\x58\x4f\x79\xc0\xe3\x1b\x78\x0d\xa6\xf1\x91\x60\x66\x5b\xba\x15\x4d\xe5\x60\x85\x0f\xad\xe6\xf9\x70\x98\xd3\xe2\x17\x18\xeb\xa6\x55\x1e\x25\x8c\xa6\x58\x7e\x50\xd9\x0f\x9a\x23\x56\xf7\x73\xab\x5e\xca\x2a\xe8\x01\xfb\x2f\xb5\x2c\x0e\x61\x2f\xeb\xec\x5c\xf6\xda\x0e\x58\x63\x6e\x66\x01\xf0\xd9\x8c\x56\xe4\xd2\x5d\x72\x16\x93\xde\x41\x85\x93\xcd\x1c\x56\xae\xfb\x0f\xcc\x3b\x71\x6d\x62\xb8\x36\x31\x5c\x9b\x18\xce\x67\x62\xa8\x6e\xb2\x9c\xa2\xf0\x34\x09\x0b\xfa\x2f\x99\x1a\xa3\x54\x76\xaf\x26\x89\xf0\xeb\x15\x1f\xd7\x99\x67\x3d\x77\x21\x5f\x5f\xd2\xb4\xf8\x81\xe5\x05\x4d\xeb\x93\x52\xef\x36\xd4\x99\x39\x32\x07\x5a\x37\x14\xd3\x01\x9f\xa6\x51\x9d\x99\xe2\xde\x4e\x09\xb2\xa9\x23\x05\xf3\x79\x0d\x33\xef\xd5\xd6\x72\x21\xd3\xcf\xb5\x61\xe6\xda\x30\xf3\xcb\x1b\x66\xfe\xfd\xe7\x0f\x1f\x5e\xbf\x27\x87\x64\xe7\x89\x60\x6e\xb6\x88\x26\x7b\xf0\xe8\x4f\x79\x4c\x49\xce\xc9\x88\x92\x28\x4c\xa5\x98\x82\xd2\x94\xf0\x14\xbe\xe7\x20\x8b\xec\x8a\x8a\x3f\x84\x85\x78\xed\x5e\x51\x72\xce\xd3\x34\x44\x51\x0f\x34\x04\xcb\xa7\x5b\x2b\x38\x19\xb1\x9c\xf0\x8c\x9d\xb3\x34\x4c\x48\xc2\x23\x18\xae\x68\x03\xcc\x71\xce\x74\xcd\xdd\xb8\xd5\xeb\x10\xf1\xff\xed\xb3\xee\xd9\x86\xed\xae\xe7\x52\xe7\x96\x54\x0b\x18\x85\x23\xb8\x5f\xb1\x8c\x46\x72\x75\x51\xe4\xae\x4b\x80\xd7\x46\x83\x17\x20\xe7\xa0\xb3\x3a\xa7\xc5\x77\x7c\x9a\xc6\x2c\x3d\x3f\x02\x6e\xf9\x3d\x8d\x0a\xe9\x5d\x05\xb2\x02\xd1\xe7\x90\x67\x63\x9b\x6b\xc4\xe7\x0c\xd4\x1f\x86\x17\xf4\x83\x82\x51\x2f\x1a\xbb\x52\x19\x0a\x5d\xb2\x40\x74\x62\xec\x44\x22\x3e\x9e\x4c\x0b\x1a\x1f\x4b\x55\xc4\x15\x4b\x63\x7e\x25\x86\x77\x64\x7f\xb1\x55\x62\x76\x2f\x4e\xf5\x2e\x32\x32\xc0\x48\xe2\x52\x05\x9b\xa8\x30\xdc\xd4\x75\x82\xb6\x40\x95\x59\xd5\x2c\x70\xad\x38\x13\xa3\xc5\x07\xc7\xff\x01\x53\x12\xa7\xe8\xdf\x58\x24\x57\xc8\x8c\xf0\xd1\x23\x6b\xb8\x28\x0e\xe2\x29\x0d\xa0\x5c\xea\x1f\xcd\x6c\xc4\x67\x7c\x1f\x07\xb6\x29\x8d\x86\x80\xc1\xe5\x4a\x02\x2c\x4a\xba\xf9\x24\x61\x45\x2b\x68\x05\xed\x93\xed\x8f\xea\x57\x3b\x68\x9f\xf4\xf4\xaf\x8e\x12\x13\x99\xc1\x4f\xc2\x2c\xa7\x6f\xd2\xa2\xe5\x35\x7d\xf2\xe4\x63\x87\x00\x87\x65\xe0\xff\xdd\x04\xbf\x67\xe0\x6f\xd5\xe4\x2d\x4c\x14\x13\x4a\xe8\xd0\x24\x5b\x95\x04\x3e\xd0\x58\xff\x7f\x5a\xdb\xbd\xde\xe5\x55\x9b\x58\x25\x9b\x01\x79\x0c\xef\xeb\xa2\x2b\x2a\x93\x4d\x35\xf2\x36\x79\x4c\x82\xc9\x75\x3b\xb0\x30\xa9\xa2\xc7\x0c\x02\x16\x34\x74\xe9\x77\xf0\x18\x4e\x86\x7c\xf3\x3e\x56\x64\x62\xd1\x6e\xa7\x93\xfa\x3e\xff\x0d\xd3\x1c\x59\xd3\xfc\xb7\x3d\x0a\xf1\x28\x57\xdd\xfd\xdb\xed\x6e\x03\x13\x8d\x79\x7d\xc5\xfc\x2a\xdd\xa8\xe8\x07\x89\x08\x34\xdc\x23\x9b\x56\xeb\x72\x8a\xf8\x60\x6f\xcb\x2e\x04\xad\x09\x40\x3a\x68\xe7\xed\x9f\x87\xda\xd8\x47\xb0\x99\x40\x95\xcf\x84\x5a\x24\xdf\x56\x41\x36\x57\xd8\xe4\xa2\x4e\xf7\x5f\x05\x7b\xbb\xb1\x18\x1f\xf0\xca\xa2\x98\x75\x26\x9c\x29\x7d\x37\x6c\x9d\x20\x0e\x77\x14\x66\x75\x60\xaf\x3b\xb8\x0b\x81\x16\x40\xde\xc5\xec\x7f\x6d\xb5\xff\x20\xac\xf6\x0d\x4a\x80\xd1\x3e\xec\x05\xdc\xe3\x60\xb5\x0f\x92\x52\xc8\xe9\x6c\x36\x44\x9f\xcb\x7a\x33\xe0\xb9\x70\xa8\xd6\x7b\x20\x1f\xf1\x2b\xd7\x85\xe0\x80\x14\x19\x3b\x3f\xa7\x59\x0e\xe5\x38\x2a\x9e\x81\xe4\xd5\xe8\x5b\xd6\x5e\x05\x6b\xaf\x82\xcf\xbd\x1c\x34\x5e\xaf\xc6\xda\xc7\xa2\xbc\x14\xeb\x63\x62\xaf\xc6\xfa\x94\xac\x9d\x67\x7e\xaf\xce\x33\x77\xf7\xa8\x5a\x95\xfb\x8d\x68\xe1\x38\x61\x77\xf2\x6c\x81\xfa\x33\x5d\x5b\x00\xea\xde\x7c\x5b\xa0\xf5\x3f\x85\x73\x0b\xcc\x74\x11\xef\x16\x5c\x9a\x65\xdd\x5b\xf2\x22\x2c\xa8\x7c\x67\x49\xe3\x9e\x5f\x28\x99\xe6\x14\xb3\x3d\xe1\xe7\x82\xcb\x40\x33\x28\xe0\x03\x8b\xd6\xcd\x6a\x8b\xd6\x21\xcb\xf2\xe2\x2d\x9f\x42\xbe\xa8\x6c\x4a\x5d\xa7\x00\xc7\xda\x3e\x9d\x26\x89\xeb\x2d\xf0\x9e\x4a\x05\x2c\xcc\x58\x6b\x0c\xcc\x5c\xfd\xd0\xd3\x72\xc4\xc7\x17\x6c\x42\x74\x84\x75\x00\xb8\x1a\xd1\x0c\x87\xab\xf5\xfe\x62\x3a\x20\x9b\x44\x35\x2f\x4b\x2f\xc3\x8c\x85\xf2\xdd\x58\x61\x83\x8e\xc6\xb8\x76\x49\x85\x78\x21\x98\x01\xe3\x4a\x59\x0c\xde\x94\xcc\x77\x05\x3e\xc3\x23\x4a\xce\x5e\x29\x80\xba\x43\x96\xc6\xaf\xde\xbd\xfd\x51\x1c\xf7\x96\xbf\x8c\x4e\x62\x4b\xa8\x6e\x85\x02\xff\xc7\x87\xb7\x3f\xa8\xc7\x9c\x6d\x4c\x5c\x92\x44\xd8\x3e\x17\xa4\xda\xaa\x7e\xfb\xe9\xd3\x05\x5d\xa2\x16\xe9\x66\xed\x1e\xb5\x94\x57\x8a\x91\xbf\xae\xd0\x87\xc8\x0c\x9c\x86\xb9\xb4\xc3\xf6\x07\x80\x5f\xc4\x3f\xf4\xdd\xf4\x01\xb9\xb2\x94\xe5\xd8\x0f\x6b\x61\x6a\x84\x79\xbe\x64\xb2\x27\x45\x8e\x4d\x8b\x31\x57\xd5\xb5\x77\xd7\x97\x39\x47\x8e\x57\xcc\x4c\x6c\xc9\x47\x61\x36\xf9\x13\x1c\xa2\x55\xac\xca\x7c\xb7\x4a\x3d\xfa\x2f\xef\x55\xe6\xa2\x3d\xe6\x9b\xa8\x41\xfc\xad\x2d\xf2\x23\x27\x29\xa5\x31\x3e\xc0\x2c\xf5\xff\xd5\x88\xa6\x5e\xac\x13\x96\x93\x11\x8b\x63\xed\x95\x52\x87\xbf\x26\x5d\xd2\x3d\xa3\x46\x30\xcb\x2f\x8f\xc6\xcd\x6b\x48\xe3\x2f\xe5\x9b\x27\xdf\x2a\x8e\x73\x9e\x5e\xe9\x57\x2c\x06\xce\xb4\xc6\x4f\xaf\x04\xe7\x32\x99\xc0\x0a\x77\x0d\x7f\xab\x58\xe2\xe3\xe3\xf7\x1d\xc2\xd3\x88\x96\xb7\x75\x2c\xe0\x68\x0c\x1a\x70\x81\x0d\xa6\xb1\x82\x83\xfa\x99\x66\xc9\x8d\xd8\x7c\x4a\x58\x51\xef\x13\x66\x2f\x36\xf2\xe7\x80\x5a\x05\x17\xa7\x81\xb0\x94\x15\x2c\x4c\x2c\xe5\xfa\x25\x2a\x40\x95\xd6\x14\xb7\x55\x2a\x49\xec\x86\xc0\x3b\xea\x8a\xe5\xa5\xc0\x3b\x03\x0a\x02\xf5\x14\xb1\x95\xa5\x87\x90\x58\xa5\xbb\x61\xc8\x35\xcb\xbb\xd3\x49\x1c\x16\xf4\x27\xc9\x5d\xb7\x4a\x46\xf6\xa5\x94\x99\xba\x93\x5f\x58\x92\xbc\xa7\x11\x65\x97\x60\xd0\x98\xcf\xda\x0f\x1f\xbe\xe5\xa5\x98\xcd\x69\x71\x2c\x36\xc7\xf2\x4f\xb3\x9f\x21\x30\x78\x8f\x90\x34\x0d\xef\x15\x8b\x7f\x86\xb9\xcd\x81\x27\x08\xd8\x9a\x64\xf4\xf2\x27\xdb\xbd\x45\x39\x9b\xc8\x62\xeb\x55\xf0\xd5\xa1\xed\xf3\x69\x7d\x78\xf4\x88\xcc\xbb\xed\xb8\xf4\xee\xeb\x86\x4b\x97\x0c\x0c\x95\xac\xc9\x8c\x69\x3f\x1a\x85\xe9\x39\xa4\x7d\xb5\x5b\xc5\x1d\x2e\x02\x45\x83\x56\xba\xc9\x3f\xa7\xe3\x79\xce\x9b\x05\xea\x6f\xad\xfd\x2e\xec\x46\xe2\x5d\x93\xb4\xea\xb7\xd0\x1d\x6d\x4d\xb7\xfe\x94\x1c\x76\x85\x6a\xab\xa7\x86\x47\x58\xd3\x1b\x4c\x35\x30\xfb\x19\xa6\xb4\x96\x48\x86\x2f\x59\xce\x06\x2c\x91\xee\x9d\x52\x0a\x63\x25\x99\x2b\xdf\x7b\xf6\xb5\x27\xdb\x9a\xbd\x3d\x4b\x38\x2a\x8b\x7e\x76\xa4\xa3\xb2\x93\x64\x76\x86\x0b\xf3\xc3\x74\x50\x56\x17\x94\x0f\x43\xe3\x07\xe3\xc6\xbc\xa0\xf3\xb2\x1a\xff\xbd\x39\x32\x57\x38\x29\x3f\x7a\x44\x8c\xf4\xc8\xba\x13\xcb\x3e\xcb\x2e\x5e\x23\x8d\xb9\xb3\xef\x72\x85\xf9\x6a\xd9\x87\xf9\x13\xc1\x8c\x78\x7d\x12\xa0\xb5\x54\x20\xae\x69\x24\x25\xfd\x32\x75\x21\xb7\x1d\xaf\x83\x99\xe3\x98\xe5\x45\x3d\x97\x1f\xf5\x9c\x7e\xd1\x0b\x79\x46\xd7\xfa\x46\x57\x01\x81\xa2\xc5\x67\x6e\x5d\x40\xdf\xa3\xd9\x3b\x28\xd2\xd7\xdb\xfa\xa0\x5c\xaf\x3b\xc4\x9d\x6a\x46\x87\x0e\xbd\x19\x7a\x8c\xb3\x5e\x57\x20\x3a\x9e\xb8\x90\xc7\xf4\xc0\x81\xbb\xb5\x7b\x6c\x57\xd1\x1e\x5d\xd4\x96\x7f\xd5\x7a\x7c\x03\xe3\x38\xd3\xe5\x1b\x85\xb3\x15\x3e\xdf\x96\x81\x03\x8a\x05\x1f\xbe\xe3\xb7\x16\xa9\x7b\xee\x2b\x77\x4b\x7c\xb4\xf5\x35\xf9\xe5\xf5\x77\x3f\xbd\x3c\xfa\xdf\xe4\x5f\x2f\xdf\x93\x37\x3f\xfe\xf3\xf5\xd1\x87\x37\xef\x7e\x24\x5f\x6f\x99\xd6\xce\x13\x3e\x08\x13\x88\x36\xff\x35\x79\x45\x0b\x1a\x15\x64\x98\x51\xc1\xb9\x66\xe8\x10\x7b\x86\x20\x67\x60\x47\x42\xc4\xb5\xdb\xfd\x35\xef\x8a\x91\x09\x3a\x26\x60\xff\x0e\x00\xe2\xf6\xc1\x67\xe8\xb9\xfc\x7d\x48\x02\x24\xb6\x60\x3d\x28\x4b\xf5\x5f\x5d\x74\xa7\x81\xc7\xaa\xfc\x53\x7f\xab\xf2\xf7\x31\x3d\x1d\x34\xce\xed\x16\xc4\xef\xad\xa6\xe5\x69\x3d\xd9\x6e\xb7\xdb\xa5\xe5\xbe\x5b\x16\x20\xb1\x1a\x2c\x57\x93\xaa\xec\x76\x77\x5f\x1e\x0d\x96\x1f\xdf\x8c\x07\x3c\xa9\x33\xa5\x7f\x26\x91\x81\xfc\x9c\xd3\x98\x84\xb9\x38\x9f\x34\xa3\x69\x44\x73\x78\xc6\x8a\xcd\xe1\xd3\x9c\x9c\xfd\x08\x8f\xfc\x33\x12\x71\x60\x72\x0a\xb3\x31\x3f\xbe\xfc\x91\x1c\x92\x1e\xd9\x02\x2b\x4f\xdd\x56\xc1\xc9\x18\x52\x0c\x24\x34\x8c\xc5\x35\x1e\xa6\xb1\x78\x9b\xb0\x44\xfc\xb8\x1a\xb1\x82\xe6\x93\x30\xa2\xba\x9d\x8c\x7e\xc8\xd8\x98\x1c\x92\xad\xff\xfb\x9f\xfc\xf1\x6f\xff\xc9\x1f\xff\x75\xeb\xdc\x6b\x31\x46\xbc\x19\x84\x31\xc9\xd9\x79\x4a\x63\x32\xa2\xd7\x61\x4c\x23\x36\x0e\x13\x99\x9a\x51\x3e\x85\xac\x76\xdf\xe4\xdf\x85\xf1\x3f\x20\xc3\xf0\xd6\xff\x3d\xd9\x7c\xfc\xb1\x77\x7d\xd2\xdb\x7c\x1e\x6e\x0e\x3f\x3e\xfe\xeb\x16\xab\xe9\x83\xa5\x61\x76\xd3\xd4\x26\x02\x88\x36\x7b\x83\x93\xde\x76\x43\x5b\x3c\x2a\x1a\x87\xf7\x0e\xbe\x43\x4b\xfc\xa4\xb7\xf9\xcc\x6e\xea\xbb\x29\x4b\x8a\x4d\x96\x92\x31\x2d\x46\x3c\xb6\x37\xe8\x0a\x59\x0b\x12\x92\x98\x4e\x04\x1f\x97\x46\x37\x84\xa7\xe4\x2c\xe3\xbc\x38\x73\x4e\xce\x4f\xd2\x4c\xd5\xb2\x58\x35\x81\xfa\x8e\x78\x7a\x49\x05\xee\x9f\xc1\xd8\xce\xc4\xc8\x95\x6b\x75\x77\x83\x00\xcc\xdf\x30\x29\x2b\xfc\x39\xa6\xe2\xcb\xbb\x21\x39\xc5\x2f\x4c\x3c\x84\x9f\x74\x7b\xdd\x1e\xfc\x8e\xc2\x82\x9e\xf3\xec\x86\xfc\x10\xa6\xe7\x50\x32\x09\xb3\x70\x4c\x3e\x7d\x7d\x8b\x93\x07\x75\x35\xfe\x85\x6f\xe2\x88\xe6\x39\xc4\xfe\xfb\x1b\x52\xe6\x9c\x7c\xc2\xde\x6f\xc9\x7b\x59\x00\x76\xe3\x7a\x44\xe4\x6f\xf4\x3a\x1c\x4f\xc4\xfd\x03\xa3\x3b\xed\x16\x1c\x31\xb4\xb5\xdb\xdd\x11\x34\xfe\x6b\xf1\xd0\x39\xfc\x96\xec\x76\x77\xca\x30\xf8\x4f\xf7\xed\x9b\x1f\x4f\xff\xf5\xf2\x87\x9f\x5f\xdb\x15\xf6\xe8\xe6\xee\xce\x93\x72\x9d\x37\xe9\x50\xbc\xba\x6f\x6c\x58\x55\x56\x86\x0e\x76\xbb\x3b\x41\x79\x1c\x5b\x56\x2c\x07\x05\x0a\x0b\x61\x9c\x65\x25\x69\xc3\xe5\xa9\x70\x92\x97\x77\xd7\x25\x7a\x23\xe1\xb5\x26\xea\xa9\x93\x2e\xdb\xf3\xc0\x7f\x7c\xf9\xa3\x0b\x8c\xe4\xc3\x03\x06\xa3\x6d\xc9\xc2\xda\xe3\xe8\xc2\xff\xbe\x1b\x12\x5f\x0f\xef\x7c\x6d\xb5\x49\xdf\x8c\x8b\xa8\x29\x68\x5a\xd5\xc2\xc8\x2c\xe4\x05\xc1\xbf\xc8\x63\x12\x04\xa2\x0e\xfc\xb2\x87\xe7\xac\xc1\x57\x65\xd3\x6f\x7b\x0d\x80\xac\xf7\xd4\x58\x48\x9f\x3c\x76\x96\x46\x0d\x02\x47\x9a\xd1\x49\x12\x46\xb4\x85\xb4\xa6\x23\xfa\x57\xc6\xea\xcc\x1c\x68\x73\xba\xbb\x05\xcd\xd5\x22\x59\x8c\x43\x4b\x03\x83\x53\xb3\x3c\xc0\x36\x30\xf2\x1e\x2f\x9c\xb3\x87\x9f\xba\x79\xc2\x22\xda\xda\x69\x77\x4c\x97\x2f\xc8\x0e\xe9\x93\x7d\xac\xd4\x27\x2d\x43\xb2\xec\x36\xc9\x0b\xa0\xb5\x6a\x86\x6d\x30\x4f\x2e\xdd\x5e\x0a\xaf\xc4\x2b\xc0\xbb\x76\x56\x9b\xe2\x6d\x45\x4e\xaa\x2f\x27\x93\xef\xc2\xda\x3c\x4f\xbb\x7b\x5f\x38\xcf\x13\x0e\xef\x01\xe4\x79\xda\x5f\x65\x96\xae\xb9\x38\x36\x49\x98\xa1\xfa\xca\xd2\x42\xc1\xab\x21\x77\x23\xfa\x7c\x06\x6f\x65\x77\xe0\x75\x7d\x3c\xab\x81\x6f\xea\xca\x6b\xf9\x61\xfa\x47\xa3\x55\xce\xfd\x79\xae\x82\x25\x4f\x1a\x8e\x6b\xe3\x2b\xed\x54\x80\x36\x35\x6f\xa0\x1c\x3f\xcc\x63\x85\x3d\x95\xfe\x94\x15\xa0\xb3\x7c\x36\x11\xca\x0c\x8e\x27\x3c\x7b\x1b\xa6\x6c\x32\x4d\xc2\x82\xd7\x91\xa5\xed\x9d\xbd\x3f\xb9\xeb\xe6\x12\x43\xfb\x80\x29\xdd\x57\x32\x3c\x68\x6b\x9e\x21\x6a\x72\x53\xa2\x3f\xc6\xaf\x07\x4a\x5a\x20\x3d\x73\x6c\xeb\xe4\xfd\xc0\xb9\x7e\xcd\x13\x2d\x7a\x07\xb1\x6a\x12\x16\xec\x52\x69\x0c\x08\x89\x59\x3e\x49\xc2\x9b\x3e\x09\x86\x09\xbd\xd6\xc5\x61\xc2\xce\xd3\x37\x05\x1d\xe7\x7d\x12\x44\x14\x45\x7b\xf2\xdb\xaf\xd3\xbc\x60\xc3\x9b\x23\x74\x6a\x29\x7f\x17\x0d\x1d\x8f\x32\x96\x5e\xf4\x49\x4f\x15\x82\x33\x56\x9f\x3c\xd1\x05\xe8\xba\x64\x97\x0c\x21\xa7\xe4\x98\x25\x37\x5a\xd9\x7a\x33\xe1\xe7\x59\x38\x19\xdd\x74\xcd\x47\x1b\xfc\x58\x8a\xc8\x3c\xe0\xc9\xf5\x07\xfe\x9e\x8e\x5b\x3b\x3d\x2d\x6c\x19\xf0\x2c\xa6\xd9\xfb\x30\x66\x53\x31\xa5\xbd\xde\xff\xe8\xf1\xaa\x70\x26\x7d\x2d\xf6\x53\x5f\xa6\x39\xcd\x8e\x69\x42\x23\x31\x4b\x70\xf4\x93\xfa\x41\xf8\x07\xce\xdd\x2b\x75\x00\xd4\x62\x47\x98\x66\x17\xc7\x34\x09\x13\x5a\x14\xb4\x3b\x08\xa3\x8b\xf3\x8c\x4f\xd3\xd8\x17\xbe\x99\x2f\x32\x3f\x2f\xea\x0c\xbd\x23\xdd\xa5\xe3\xc9\x28\xcc\xd9\x7f\x41\xa8\x3f\xa3\x65\xd2\xeb\xee\x3c\x6d\xdb\x23\x65\xe3\x73\x33\xc0\x71\x78\xfd\x0b\x6e\x46\xb0\xdd\xb3\x96\xe1\xaa\xaa\x50\xed\x52\x10\x4e\x0b\x1e\x18\x91\x94\x31\xda\xbc\x8b\x9b\x14\xbc\x38\x19\x28\x58\xc4\xcb\x15\xed\xe1\xc0\x8d\x36\xcf\xa2\x33\xc2\x33\xf8\xe3\x98\x16\xe2\x75\x87\x55\x64\xa4\x34\x12\xa6\x24\x4c\x0a\x12\x16\x45\xc6\x06\xd3\x82\x6a\x03\x62\xd4\x0d\xd0\x98\x9c\xb1\xf1\xf9\x59\xd9\xe5\x2a\x14\x9b\x55\x67\x4e\x2b\xc3\x1e\x95\xc6\x58\x70\xd9\x2e\x61\x11\x4f\xc5\xc0\x0a\x7a\xad\xfd\xb9\x72\xc2\x52\x30\x32\x14\xfd\xbf\xbc\x0c\x8b\x30\x93\xb6\xca\x38\x8f\x30\x8d\xc9\x59\x98\x14\x67\xe8\xc9\x8b\xaa\xcb\x94\x83\x43\x32\x04\x96\x17\x00\x29\x97\x23\x16\x5f\xb1\xf6\xc0\x9a\xcd\xe0\x46\xd1\x5a\x6c\x7a\x43\x9a\x50\xcb\x40\x6d\x03\x58\x11\x39\x1e\xb0\x76\x16\xa7\x94\x84\xf2\xfd\x5e\xe5\x71\xd6\xe4\xdf\x24\xe3\x66\x35\xae\xd2\x97\x71\x59\x5b\xb1\xeb\x98\xef\xa9\x65\x9b\x40\xc3\x8b\x5f\x07\x1b\x53\x7a\x4b\xf4\x22\x73\xd0\x0a\x71\x64\x70\x43\x8e\x46\x6c\x02\x9b\xf9\x03\xcb\x0b\x41\x3d\xdf\x44\xf0\x68\x96\xfa\x0c\x83\x1e\x80\x46\xe5\x4d\x39\x52\x9d\x2d\x8a\xa1\xc3\x69\x22\xba\x41\x0e\x12\x6d\x5f\xa1\xc7\xd0\x04\xfb\xd3\x4a\xcc\xdc\xea\x57\xf4\x47\xf3\x3b\x25\xcd\x88\x96\x1a\xf3\x07\xc7\x02\x01\x0e\x81\x3e\xc0\x9c\x17\x68\xf7\x81\xa0\xaf\x19\xbc\xbb\x15\x2a\x83\x5a\x39\xa7\x24\x24\xaf\xde\xbd\xd5\x6a\x50\x2e\x00\xec\x94\x0c\x6a\x74\xaa\x68\x49\x0f\x4b\xbc\xff\xef\x86\xb2\xd0\xc6\x4a\xd1\x16\xc2\x66\xba\x0b\x6a\x18\x68\x7b\xd3\xc5\x7a\x3a\x74\xb0\xc2\xac\x07\xeb\xab\x1c\x17\x05\x57\x2c\x81\x20\x28\x6c\x1c\x9e\x53\xcb\xf5\x70\x7c\x0e\x74\x7c\x61\x37\x8f\x33\x71\x75\xe5\x67\x15\xe4\xba\x86\x4a\x03\xfc\xc2\x18\x25\xc9\xed\xdc\x9d\x64\xd1\x52\x5d\xc0\x85\xb4\x48\x2f\xc7\x74\xd6\x9d\x83\x6e\x14\x9a\xbd\x43\x2a\x61\x07\x22\x15\x57\x6d\x08\x9a\x12\x19\x67\xdb\xb0\x10\xf2\x14\xeb\x4f\xf2\xb7\xf3\x59\x1c\x50\xa9\x26\xb6\x80\x44\xa9\x06\x93\x34\xc8\x85\xf2\x14\xe1\x25\x42\x55\x09\x7d\xe4\xb7\xad\x55\x53\x2e\xb8\x2a\x55\x60\x0a\xbd\x34\x84\x2a\x50\x00\x80\x15\xfa\x2b\xfc\xd2\x9f\xb2\xc8\x7c\xc8\x22\xab\xf8\x98\x16\xf6\x97\x63\xaa\xfb\x5b\x50\xf1\x6d\xc2\x77\x83\xd4\x26\x90\xeb\xac\xff\x14\x33\xf6\x63\x7a\x97\x96\x04\x0a\xd5\xc4\xc5\x0f\x35\x47\xd0\x8a\x8b\x19\xc1\x1f\x59\x24\xff\x39\xa6\x85\xd6\x8e\x3b\x61\x31\xd5\xb8\xad\xa7\xa9\x19\xaa\x1c\x5a\x57\xd0\xd2\x8e\x72\x52\x70\x84\x03\xae\x32\x5d\xc1\xdb\x2c\x6d\xc7\x45\x89\x47\x8f\xc8\x57\x62\x91\xe5\xbf\xc7\xb4\x68\x77\x5c\xdc\xd2\x52\x49\xcb\xa0\x02\x83\x96\x4a\x09\xa9\xdd\x9e\x1d\x4f\xb1\x1a\xab\x4c\x48\x0d\x67\x1c\x5f\x59\x51\x35\x04\x8c\xaf\x06\x65\xf9\xbf\xc2\x84\xc5\x4a\x07\xee\xf4\xe9\x19\x8c\x94\xfa\x6d\x5e\xd3\xaa\x51\xba\x8b\xd4\xf5\xce\x96\x36\x73\xb1\x4d\x4c\x7c\x95\x7d\xc2\x53\x5a\x35\xda\x0e\xf9\xe4\x5c\xae\xe5\xd1\x6a\x1b\x31\x3b\x08\x8b\xd3\x99\xdd\x9e\xa5\x50\x36\x31\x2f\xc4\x8e\xfe\xf6\x9b\x3c\x26\x6a\x79\x9a\x46\xeb\x06\xb2\x64\xe3\xf3\xa0\x33\xcb\x78\x00\x38\x6e\x8b\x5e\x01\xd9\x2d\x9d\xd1\x3e\x71\x0f\xa7\xbc\x01\x9c\x43\x6e\x2d\x87\xc2\x58\x36\x3e\x97\x2f\x1d\x4d\x3e\xda\xc6\x00\x73\x7e\x73\x0d\x87\x44\x61\x7f\x75\xd3\x2a\x0d\x03\x37\xc3\x0d\xe2\x6e\x29\xf6\x51\xe6\x2d\xdf\x05\x76\x4c\x6f\xa5\x44\xa2\xe9\x65\xf7\xc7\x77\xaf\x5e\x9f\xbe\xfe\xf1\x5f\x80\xdf\x7f\x99\x64\x3c\x9e\xc2\x55\xf0\x17\xf2\x42\x7b\x5c\x7d\x9a\x9b\x65\x73\x82\x00\x3c\x1c\x2e\xe8\x2e\xf1\x26\xfc\xfa\x8b\xc6\x9c\xb8\x27\x2e\xcc\x5b\xe9\x79\x5e\x97\xeb\x47\x58\xc5\x23\x6c\xf1\x47\xd0\xc6\xed\xac\x9b\x0d\xbd\x0b\xad\x7b\xba\xf1\xcc\xb4\x17\x69\x4e\x5e\xe5\x8d\x03\x9c\xbb\x41\x8b\x1d\xf8\xa3\x3d\x52\xe6\x5d\x03\x8b\x0b\x5a\xc9\x26\x29\x4e\x6a\x25\x1b\x84\xdc\xd8\xaa\x9a\x12\x1c\xdd\xec\xd6\x04\x7c\x9b\xf4\xc9\xa7\xdb\x03\x75\x75\x54\x58\x73\x59\x84\x1d\x82\x4a\xc3\x33\xa2\xc1\xb8\x4a\xea\x17\xcc\xb0\x50\x8e\x2c\x58\x8d\x14\x4e\x5c\xf0\x76\xca\xb0\xbb\x80\xdc\xb6\x5b\xf8\x67\xbb\x51\xf7\x36\x8f\x45\xd1\x6e\x95\x41\xd1\xd3\x2f\xa9\x1b\x6c\x48\xf4\xe1\x28\xec\x88\x32\xbf\xea\x86\x79\xce\xce\xc1\xd3\xd6\x78\xd3\xa0\xe1\x66\x9b\x7c\x32\xae\xde\x8c\x1c\x92\xed\x03\xc2\xc8\x37\x25\x77\xef\x03\xc2\xc0\x81\x1b\x4d\x5c\xf9\x34\x83\x70\xa4\xc6\x75\x9b\x7d\x3c\x30\xed\x5c\xd0\x1b\xc2\x52\x09\x26\x2a\x09\x76\x4d\x0e\x65\xa2\xfc\xab\xbb\xa3\x30\x7f\x77\x95\x2a\x7c\xc3\x9d\xc0\x2a\x1d\xd1\x82\xe0\x78\xa5\x75\xe9\x89\xf4\x14\xc7\xaf\xf0\xeb\x80\xdc\xc2\xff\x49\x2e\x09\xe1\x0e\xc8\xed\xe7\xc8\x3f\x72\x7f\x6a\x3d\x88\x02\xfe\x36\x9c\x4c\xa4\x19\x76\x95\xde\x72\xaf\xf7\x79\x73\xa0\xd4\xbd\x2e\x45\x17\xb0\x51\xb9\x42\x0b\xdc\x04\x71\xbc\x6f\x0f\x6c\xa4\x62\x30\x00\x85\x07\xa2\x46\x97\xa5\x31\xbd\x7e\x37\x6c\xb1\x36\xf9\xf6\x90\xf4\xda\x10\x66\x8c\xa5\x53\x7a\x80\x96\xd0\x73\x21\x0b\x0c\x80\xb5\xed\xca\x12\x5f\x98\xc0\x16\x3e\xf8\x15\xd0\xb2\x8c\x24\xf6\xec\xdc\x98\x08\x2d\xe5\x52\xd0\x21\x96\xc7\x94\x1a\xfa\x57\xfa\xb3\xed\x7a\x60\x03\x02\xce\x8e\x32\x7e\x05\x09\x35\x04\xc6\x60\x52\x8d\xbf\x1c\x85\x69\xca\x0b\x22\xc6\x4d\x42\xe4\x84\x49\x98\x93\x50\x1f\xc8\xbf\xb4\x01\xa5\xed\xa1\xd5\xfa\x6e\xb5\x72\x9a\x0c\x3b\xd0\x98\x1e\x9a\x28\x72\x7b\x7f\xaf\x0c\xd7\xe4\x10\x20\xd6\xc0\x28\xcc\x31\x9c\x28\xf8\x1c\x81\x53\x13\xcb\x69\x4c\x36\x49\x3e\x9d\x80\x5f\x82\x0d\x21\x7a\xa0\x31\x0e\x4d\x2e\x22\xcc\xe0\xd1\x23\x6d\x33\x04\xbf\xc5\x05\xfe\x17\xc4\x93\xbf\x08\x2a\x53\xfa\x66\x66\x49\x5e\x60\x71\x9f\x88\x11\x7b\x9b\xa1\x02\x63\xb4\xf2\xe9\x00\x78\xa9\x0e\x0e\x0b\xfe\x56\x53\x95\x8d\x9b\x0f\xf8\xee\xd0\x5d\x88\xd1\x79\x1f\x65\xda\x99\xea\xad\x39\x16\xb0\x82\x68\x67\x34\x87\x64\x2f\x90\xed\x84\xa2\xe8\x76\x40\xa1\x32\x0a\x69\x55\x17\x1d\xd0\x80\xfc\x85\x3c\x26\xa5\xb1\xc0\x52\xa9\xd1\x1b\xfc\x35\xa4\x58\x3a\x80\x5a\x03\x74\x86\x6b\xaa\xc0\x1b\xda\xec\x7c\x1f\x0e\x19\xd8\x78\x98\xc5\xb1\x2d\x6f\xc0\x03\xab\x43\xae\x32\x56\x58\xa6\x38\x26\x62\x83\x2e\x13\x68\xd6\xc6\x73\x66\x2f\xae\x1c\x5f\xee\x46\x76\x7f\x51\x5d\x5e\xb3\x41\x66\x6c\x56\x70\x8d\x43\x0b\x44\x6b\xd9\x2f\x55\xfc\x50\xd9\xbc\xfc\xed\xdc\x50\x48\x34\xcc\x53\x58\x82\x0a\x02\x02\xdf\xba\xe3\x70\x62\x45\xab\xb8\xf0\x2c\x8c\xc4\xf9\xbf\x80\x70\x22\xb7\x6d\xa3\xf3\xb3\x2f\x06\x47\xa1\x77\xf6\x8d\x97\x50\xe8\xdb\x33\xa9\xc2\x12\xc7\xf4\xec\x9b\x98\x5d\x7e\x7b\x66\xeb\xb2\x20\x9a\x0f\x64\x1a\x42\xa7\x2f\x71\xbe\x94\xf2\x6b\x14\x5e\x32\x9e\x09\x68\x54\xfa\x81\x3d\x2e\x39\xd3\x3c\x0f\xaa\xd3\x2a\x65\xfd\x55\x99\x4a\xc2\x14\x54\xc7\x76\x8c\x46\x5a\x10\x3e\x74\x06\xfd\xed\x99\xa5\x28\xe9\x90\x62\x14\x16\x24\xcc\x28\x29\xf8\xf9\x79\x02\x4a\xc5\x14\xf5\x79\x60\xc2\x0a\x16\x9e\x37\xd8\x5c\x42\xc3\x4b\xda\x45\x41\x70\xc5\x2a\x80\xce\x8f\xa5\x60\xfe\x8c\x91\x8b\x58\x64\x7b\x3d\x4a\xe1\x62\x2e\xd5\x9c\x19\x45\x7b\x55\x50\x1e\x4d\x32\x1a\x82\x56\x67\x0c\x87\x6f\x7a\x3e\x12\x88\x77\xc3\xa7\x30\xb4\xab\x4c\xde\x75\x7e\xd7\xdf\x9e\x91\x50\x2e\x26\x28\x55\xf9\x34\x23\x67\xdf\x7c\x1f\xc6\xf4\xdb\x33\x22\x4d\x51\x2b\x15\x83\x15\x8b\x97\xf2\x98\xba\xc2\xf0\x97\xe2\x54\x5c\xd2\x94\x09\xea\x08\xc3\xc7\xd5\xc2\x0c\x58\xb9\x38\xec\x31\xcb\x21\x1b\x96\x4a\x12\x69\x92\x47\x61\x13\x2a\x50\x93\xea\xba\x4b\x7e\xe4\xe0\x2d\x18\xaa\x35\xba\xc1\x79\x31\xa9\x33\xe5\x97\x34\xcb\x50\xfb\xab\x51\x28\x17\xdb\x88\xed\xf1\xd4\x8a\xf1\x64\xa4\x58\x1f\x2c\xb7\x04\xa3\x06\x96\x9e\x22\x55\x93\x1d\x70\x9e\x74\x96\x9d\x2b\xc6\x6f\x7c\x48\x53\x6d\x48\x1b\xe4\xcd\x74\xd1\xa9\x3a\x11\x2a\x73\xd9\xc2\x6a\xa7\x3a\xff\x5c\xe5\x64\x6b\x73\x1a\xe1\x5c\xed\x6d\x55\x91\xc4\x94\xb7\x2a\xc4\x24\x22\xc0\x4d\xb2\x4b\x2a\xfd\x2f\x73\x34\x2c\x47\xb5\x6f\x98\x13\x06\x0e\xd3\x14\xc3\xe0\x75\x2d\x35\x3c\xcb\xc9\x39\x4d\x69\x06\xe1\xc5\x62\x9e\x52\x41\xb9\x30\x25\xfc\x99\x2d\xe4\x3d\x23\x23\x7e\x45\x2f\x69\x26\x78\x3a\xd0\xc4\x85\x39\x68\x97\xc3\x54\x35\x8b\xad\x62\x97\x10\x13\x54\x8a\x5d\x46\x82\xdb\x49\x04\x35\xb8\x41\xde\x02\xf3\xde\x28\x03\x82\x82\x84\x91\x78\xe0\x08\x7e\x47\x69\xff\xc4\xed\x27\xee\x37\xdb\x6a\xe0\x0d\x12\x8f\x98\xfb\x7e\xba\xee\x34\x81\xa2\xe5\x00\x2a\x28\xb4\xb6\xbc\x20\x67\x00\xf5\x7d\x28\xae\xd4\x9b\x33\x6c\xb3\xe0\x40\x88\x88\x98\xd8\x0d\x36\xd3\x11\x3f\x70\x8a\x3c\x15\xeb\xa8\x88\xa9\x74\x09\xb2\x87\xf4\x37\xb8\xe0\xbf\x57\x2f\x35\xa8\xdf\xc7\x74\x71\xda\x23\x75\xf3\x5b\xa7\xc0\xa5\x5c\x72\x34\xd5\x5b\x2f\xee\x37\x7d\x79\xcd\xf1\x8c\xee\x94\x5a\x35\xbe\xc0\x56\x31\x0e\xd3\xbb\x31\xa1\xec\x40\x39\x3a\x29\x6f\x85\x0f\x35\xd7\x82\xd1\x81\x8f\xc3\x34\x3c\xa7\xe2\x9a\x9c\x75\x2d\x89\xf6\x58\x4a\x42\x92\xb0\xbc\xe8\x92\x1f\xd8\x05\x45\x02\x5f\x71\x01\x18\x1d\x5b\x55\xf7\x1d\x81\xb4\xa1\x68\x0f\xc3\x67\x8d\xc3\x68\xc4\x52\xd4\x68\xc2\x78\xd4\xb5\x02\x2e\xcf\xca\x1f\x66\x9a\xea\x9f\x82\x3f\xd5\xe3\x82\x83\x2c\x1a\x2b\xd8\x98\x2a\x17\x0c\xc1\x77\xb3\x98\xa2\x86\x54\x5e\x3a\x64\x40\x13\x7e\x25\xcf\x06\x0c\x5a\x5c\x4a\x67\xe4\xe8\xf8\xd8\xbe\x12\xc1\xa3\x6a\x40\x87\x3c\x83\xd6\xc8\x4b\x81\x95\x74\x9c\x03\x0e\x29\xcc\x17\xc4\x26\x8e\x8d\xb6\xfb\x03\x8f\xf9\x0f\x2c\x2f\xa4\x46\x36\x45\x26\x41\xcc\x53\x5e\xe1\xa2\xa5\x70\x5a\x70\x41\xb4\x22\x38\xab\x83\x9b\xba\x5b\xdb\xb0\x27\xd3\x9c\x92\xd3\x30\xbd\x39\xf5\x16\x58\xb4\x66\x45\x52\x48\x81\xcb\xa9\x58\x67\x71\x38\xc1\x22\x27\x42\xa7\x11\x51\xef\xec\xec\xec\xd7\xfc\x1a\x76\x73\x3c\xe1\x99\x9d\x43\x02\xea\xe1\x02\x04\x98\x15\xd1\xcf\x85\xb8\xe5\x01\x07\x07\xb2\x55\x7c\x16\xe9\x65\x50\x62\x0c\xcc\xbc\x68\xf2\x55\x7c\x12\xb0\xc4\x66\x8e\x2d\x6d\xf3\xd7\xa8\x81\x81\xc7\x0c\x96\xaa\x32\x37\x14\x1b\x43\x03\xc1\x93\x60\x44\x93\x84\x07\x1d\x12\x5c\xf1\x2c\x89\x51\x23\xca\xa2\x0b\xf1\xc7\x98\x06\x1f\x6f\xb1\xba\xfc\x07\xdd\x37\x5f\xc6\x71\xcb\xea\x0c\x06\x22\x5e\x15\x60\x74\xa8\x7c\xb5\xd1\x6d\x17\xba\x51\xe1\xe1\x4e\x54\x0d\x22\x76\x76\x3c\x29\x5a\x01\x3a\x66\xe7\x7c\x4c\xc1\x2c\x2b\xd0\xa3\xfd\x88\xce\x2c\xa4\x1c\x7f\x81\xc8\xa1\xeb\x0e\x6f\x15\xa8\x33\xc8\xf7\x80\x65\xe2\x85\xad\x07\x9a\xd0\xe6\x61\xa2\xa7\x84\xe9\x58\xc1\x42\xf8\xfe\x88\xb6\x58\x87\x6c\xd7\x0e\xcb\x1b\x95\x3f\x28\xdb\xef\x1d\xeb\x2b\xdf\x0e\xb3\x28\xc0\x63\x9b\x9f\x84\x7c\x33\x98\x16\x05\x4f\x09\x4f\x8f\xc4\x9e\x1c\x7e\x6a\xb5\xc9\xe1\xb7\xb6\x27\x2d\x6c\xc5\xed\xb7\x2f\xe3\x98\x88\x6e\xbf\xd9\xc2\x1a\x6e\x2b\x3e\x52\xdb\x1f\x09\xf9\x54\x5a\x07\xf1\xae\x68\x89\x3f\x3b\x84\x41\x87\x2d\xb7\x06\x21\xc0\x8a\x5a\xf1\x5c\x2e\xe8\xcd\x21\xac\xc0\xed\xb7\x3e\x68\xc5\xb4\x74\xcf\x50\xe3\x53\x40\x82\xdb\xaa\xcf\xb3\x67\xaf\xf7\xb8\xaa\x5b\x5c\x63\x01\x50\xd9\x78\xd5\x4a\xa9\x4f\x55\x03\xfe\x66\xcb\x9d\xb3\x07\xd0\x6e\x3b\x73\xf8\xc6\x3f\xe4\x16\xb8\xdb\xbe\x83\x27\xb7\x92\xb8\x48\x82\x60\xb8\xaf\xaa\x0b\x88\xc4\x9c\xe6\x40\x9e\x50\x74\x0d\x4c\x98\xe6\xe9\xf4\x2b\xec\x2b\xd1\xd2\xeb\xeb\x30\x2a\x92\x1b\x72\x3a\xe2\x57\xa7\xf2\xfe\x81\x83\x24\x2b\x50\x60\x82\xa6\x13\x45\x8b\x2d\xae\xad\x81\x6a\xe6\x5d\xe4\x9f\xc6\x34\x4c\x0d\xb7\x31\x66\xd7\x70\xd9\xa0\x3b\xa6\x9d\x76\x36\xca\x78\x9e\x93\x98\x0d\x41\x32\x53\x88\xb6\xf4\x40\x80\xb6\x6e\xe1\x3d\xef\x53\xd3\xd9\x71\x45\x8d\xe8\xc4\xab\x3b\x33\xa6\xa8\x07\xaf\x4c\x45\x20\xee\xff\xb5\xd6\xab\xfb\x72\x32\x0c\x19\xe4\xd5\x55\xe1\x0c\xb6\xb6\xc8\x1b\x19\x30\x47\xb3\xbc\xf9\x88\x4f\x05\x7b\x86\x91\x6f\x94\x27\x76\x47\x7b\x52\x16\x82\x57\xc6\x97\x8d\x76\x8d\x53\x51\x3e\x1b\x24\x61\x32\x74\x91\x37\x45\x94\x0f\xe2\x37\x6f\x3e\x6a\x8c\x33\x62\x4d\x5d\xd0\x1b\x0c\x74\xd5\xd1\x19\x73\xfe\x01\xb0\x99\x6b\x88\x11\x4d\x33\xb1\x93\x9e\xe0\x16\x94\x16\x76\x19\x24\x91\xb1\x7e\xb7\x9d\x80\x4f\x6a\x91\xdc\x70\x10\x52\x8a\x5e\xd1\x43\x5b\xc7\xb7\xb4\xc0\x4b\xc3\xf4\x0a\xbc\xc0\x8f\xa7\x2e\xf9\x36\x33\x07\x42\x68\x47\x0b\xf0\xcc\x62\x94\x76\x41\x46\xb2\x10\x54\xb3\x3c\x7e\x42\x62\x9a\xd0\x82\xea\x8a\x27\x26\xb4\x2b\x31\xb4\xff\x93\xf5\x74\xd7\x5d\xdc\xea\xc8\x15\xca\x46\xc4\xd9\x32\x3f\x98\xaa\x69\x61\x8e\x55\xf7\x4c\xc3\xac\x0d\x77\xf8\x61\x35\x6d\x2b\x90\x89\x86\x74\xa3\x6f\x39\x51\x15\xca\x38\x85\xcd\x76\x2d\x6c\xc2\x02\x2f\xd0\x97\x59\x98\x5b\x6b\x09\xd5\x05\xa9\x83\xe4\x38\x06\x37\xd2\xaa\xc7\x8d\xfe\x60\xa2\x4d\x54\x45\x5c\x61\x69\x39\xbc\x84\x16\x26\xc0\xd8\x65\xfa\x21\xd5\x74\x80\x5f\x03\x27\xee\x83\x0e\xb1\x50\x55\x01\xdd\x29\x5c\x78\x19\x61\xa1\x12\xfc\x9a\x01\xcf\x43\xdc\x1d\x17\x7f\xa9\xad\xb7\x56\xe2\x14\xc3\xe3\x48\x03\x19\x8f\xf8\x58\xca\x02\xb5\xed\x47\x78\xe6\xed\xdd\xf3\x3e\xf9\x5e\x89\x3a\x2e\x52\xe6\xe5\x16\xff\x44\x58\xfe\x56\x3e\x1d\xfa\x32\x86\x14\x2e\x0e\x8d\x55\x24\x20\x99\xe1\x1a\xe8\x9f\x60\xba\x75\x02\x95\x21\x3b\x27\xd3\x34\xa1\xb9\x78\x7c\x0b\x56\x4a\xdc\x44\xe2\xa9\x24\xd9\x77\xe8\x63\x63\xe6\x9c\xa4\x05\xa2\x3d\x17\x7b\x31\x27\x96\x69\x9a\x92\x74\xe6\x15\x91\x9b\xc9\xb7\x64\x87\x3c\x7a\x64\x29\xef\x76\x30\x3d\xb8\xf6\x10\x24\x2f\xdc\x8f\x7d\x2b\xfa\xd0\x81\x13\x98\x19\x8a\x4e\xc4\xff\x8a\x26\x50\x54\xfe\xc2\x29\xed\xdb\x18\x8f\x65\x72\x9d\x1a\xa7\x5b\x8a\x13\x67\x4f\xbc\x3e\x88\x9c\xbb\x2f\x4a\x2b\xba\x40\x77\x7e\x18\xb4\xca\x6e\x4b\xb1\xd2\x52\x7a\x5d\x38\xa1\xc9\xea\x82\x3a\xe1\xbe\xd0\x4b\xef\xbe\xb0\x38\x50\x45\x9b\x0e\x34\xbc\x68\x7c\xf1\xfb\x45\x0f\xa9\x44\x9d\x3d\x7a\x5e\x6e\x6b\x4c\xb3\x73\x6a\x97\xe4\xed\x96\x3f\xe8\x4e\x69\x58\xaa\x79\x5b\x4a\xaf\xbb\xee\x0e\x79\xf6\x3a\x8c\x46\x2d\xe7\x86\xf5\xae\x52\x38\x2e\x87\xfe\x95\x61\x5d\x71\x5f\x59\xa4\xd0\xb5\x95\x94\xc4\xb0\x5d\xba\x19\x17\xa6\xe2\x32\x2a\xce\x1d\x88\xf8\xad\xd3\xf9\x28\xcc\x7f\xca\xe8\x25\x39\x54\x5a\x71\x7f\x25\x0f\x5c\xe0\x1f\x91\x60\x49\x60\x7f\x91\x9d\xa6\x75\x4b\x60\x8f\xe7\xb6\xea\xdc\xb7\xe8\x6e\xff\x03\x8a\xae\x9c\xb0\x6b\xa5\x65\xd4\xed\xb4\xc1\x5a\x56\xff\xd4\x61\xa9\xf4\x08\xb6\xb6\x90\x7f\x66\x39\x28\xd4\x5a\x8a\xa5\x6b\x5b\x1b\xa6\xe6\xf3\xe8\x11\x69\x7d\xa5\x56\xe2\xb7\xdf\xcc\x60\xda\x5e\xfc\x3d\xf1\x94\xe6\x09\xed\x26\xfc\xbc\x15\x50\x13\x8a\x4b\x20\x8b\x86\x73\x10\xc4\x9d\xce\x3d\x5c\x90\xd6\xf5\xb5\x53\x7d\x7f\xe1\x59\xc0\xf3\x5f\x77\x51\x56\x54\x95\x31\xc7\x4c\xdd\xaa\x6b\xb0\xbc\xd8\x3c\x89\x49\x4b\x0a\x5b\x55\x15\x6d\x13\xfb\x95\xb5\xe2\x6a\xbd\xc5\x3e\x9a\x05\x77\x56\xc3\x5f\x71\x29\xdd\xf4\x17\x7c\x89\x25\x87\xa5\x04\x95\xa4\x35\x1b\x3b\x9a\x94\x9a\x91\x54\x37\xa3\x0e\x2d\xb6\x65\x68\x40\x0f\x73\x17\x3b\x26\x37\x20\xa9\x83\x5b\x33\x09\xf3\xa2\xa4\x86\x32\x5d\xe9\x35\xa9\x5e\x92\xb9\xce\x80\x1f\x34\xcb\x5f\xaf\x69\x2a\xc7\x5d\x5e\xb1\xbb\xa1\xe9\x6c\x54\x55\xe8\x5a\x3e\xa1\x3e\xd4\xf2\x08\x7c\x27\x24\x76\x11\xd9\x6c\xfe\xad\xba\x28\x7c\xb1\x56\xd5\x53\xa0\x3d\xcf\xe5\x2d\xdd\x1b\x0f\x6b\x83\x2c\xce\x0c\xa4\x68\x64\x8b\x26\x8e\xa2\xef\xe1\xe1\x8a\xd5\xbd\x80\x8b\xb2\xd4\xc0\xea\x88\xf6\x75\xd6\x33\x56\x28\x42\xdb\xa5\xc2\x6e\x0d\x9d\x27\x48\xf9\xca\xae\x64\x17\x10\x52\x3e\xbb\xa4\xa3\x0d\x30\x42\x07\xe5\x0f\xb0\x6d\x55\xe5\xd7\xac\x38\xf0\x33\x6f\xcc\x8e\xd2\x77\xe4\xaf\x95\xb3\xbc\xa8\xda\xb7\x78\x81\x71\x28\x11\x48\xce\x13\x71\xc6\xda\x6a\xd9\xb7\xb7\xe3\x33\x03\xc7\xf9\x18\x12\x59\x8c\xbe\xad\xf2\x2f\x31\xf7\x55\x7a\x97\x92\x31\x3a\xba\x39\x55\x60\xe1\xc2\x36\xf1\xa6\x0e\xda\x48\xfa\x6d\x7a\x5a\x1e\xfb\x67\xa5\x89\x64\x69\x9d\x4a\x31\x6a\xe4\x5f\x27\x3a\x70\xcb\xc7\xfb\x31\x8b\x7c\xf6\x10\x03\xde\x7c\x87\x52\xd4\x3a\x73\xba\x27\x5f\x38\xe0\x0d\x0e\xef\x21\x04\xbc\xd9\xff\x83\x07\xbc\xf9\xfc\x31\x69\xee\x35\xc4\xce\x3a\xe0\xcd\xef\x2b\xe0\xcd\x67\x89\x5e\xb3\xf2\xf8\x2b\x61\x1c\x5b\x29\x24\xf2\x49\x18\xb1\xf4\xbc\x3b\x4d\x59\x41\xbe\x26\x3b\xea\x8e\x0f\x1e\xf5\x05\x3b\xbe\x09\x57\x6e\xd0\xb7\x78\x59\xd9\xc0\x77\xbc\x28\xf8\xb8\xa6\x99\x5d\xe7\xb5\xb3\xda\x20\x1d\xbf\x83\xf0\x02\x9e\x03\xf5\x51\x98\xc5\x32\x40\x8d\xef\x45\x3d\xaf\xbb\x74\xbd\xab\xf4\xb2\x7e\xc3\x95\x0e\xc3\xca\xb9\x77\x2e\x5e\x11\xad\x53\xe6\xf2\x4c\x9c\xd7\x39\xd8\x38\xab\x1a\x17\x46\xf4\x58\xb4\xd6\xf0\xf3\xbb\x2d\xfe\x1e\xbc\xbb\x6c\x1f\x9d\xbb\x3a\xdd\x58\x8b\x0d\x9e\x37\xd6\xef\x7b\x72\xbf\x79\xbe\x52\x3e\x73\xa6\x3f\x8d\x7c\xa4\xb2\xa8\xee\x6a\x7d\x6a\x98\x06\x0d\xdb\x74\x31\x68\xa0\xcf\x77\x2f\xd0\xe2\x15\xc6\xc6\x90\xf4\xc1\x4e\xb3\x6f\x7d\x69\xc5\xe6\x6f\xe7\x72\x00\x94\x30\x93\x33\x18\x11\x58\x35\x82\x0e\xb1\xeb\x1f\xd4\xf8\x74\xb9\x5d\x96\xa2\x63\x3f\xef\xfd\xae\x19\x51\xc4\x03\x37\x95\x64\x0d\xe2\xec\xd7\x80\x37\xe1\x8e\x0b\xe9\x72\x3d\x5a\x3f\x5f\xc7\x04\x3e\xaf\x81\x6f\xe2\xfd\xbc\x96\x4d\x0b\x26\x39\x50\x5d\x77\xdb\xbd\x2a\xe8\xc6\xce\xac\x46\x8d\x8b\x56\x9d\xfa\xbf\xb6\xdf\xed\xd9\x75\x9b\x46\x51\xdf\xa1\x6e\x57\xd9\x5b\xd4\x0e\xa1\x0c\xda\xd4\xa3\x6e\xee\x7e\x1d\xcc\x54\xae\x95\x3a\x26\xfa\xb9\x0b\xe9\xa4\x7f\xa8\x7b\xc4\xec\x36\xd4\x99\x39\x32\x07\xfa\xa1\xc5\x78\xfc\x11\x53\x85\xde\x2d\x82\x22\x34\x32\x4f\xe8\x44\x96\xbf\xa2\x79\x44\xd3\x38\x74\xb5\x9d\x76\x79\x8b\x26\x1d\xa2\x3d\x37\x55\xf4\x66\xf4\xbb\x53\x8e\x4e\x10\x7d\x04\x8a\xba\x93\x30\xa3\x69\xf1\xa3\xa5\xe2\x92\xeb\x46\xd1\x2f\x4b\xd6\x04\x8d\x4c\x65\x27\x76\x0b\x2a\xc2\xb3\x6c\x02\x84\xfb\x77\x62\xd3\x8d\xc0\x77\x31\xd7\x71\xdc\x96\x25\x7d\xc6\x21\xcd\xc1\x32\xb1\x1c\xfc\x8a\x73\x07\x71\x80\xe1\xae\xc6\x3d\x1d\xf6\xc1\x0b\xdb\x20\xad\x03\x5f\x5e\x85\x37\xb5\x9d\x88\x75\xf2\x45\x99\xd2\xba\x1b\xcf\x1e\x98\x4d\x83\xdd\x2b\x18\xbe\x17\x96\xc5\x7b\x91\xb1\xf3\x73\x88\xe3\xc7\xa7\x05\x84\x0a\x54\xd1\xe4\xb4\xd0\x5c\xbb\x4b\x6c\xa8\x10\xf8\x7a\x48\x16\xf1\x58\x36\x35\x76\xa9\xad\x99\x26\x6d\xa5\x1a\xf7\x96\x32\xbb\xd4\xd3\x9f\x22\x7d\x76\x69\xd6\x8b\xa4\xd2\x2e\x2f\xd9\xb2\x69\xb5\x65\xe6\x3f\x81\x5a\xe8\xfb\x68\xdb\x5f\xe9\x6e\x1c\xcc\x03\xe4\x76\x32\x0e\xbe\x81\x37\xbb\x83\xf5\xa3\xf0\x92\xa2\x8f\xca\x19\x14\x77\x27\x19\xfc\xab\xae\xa0\xf6\x19\x19\x87\xd9\x05\x8d\xed\x6c\x82\x08\xa9\x65\xf5\xf0\xd3\x4d\xe1\x58\x93\x93\x5a\x8c\xe1\xf5\xf6\x36\xc9\xa7\x13\xc1\x62\x76\xc8\xd5\x88\x45\x23\x75\xec\xe0\xa4\xf9\x33\x02\xdf\x94\x70\x58\xc8\xcf\xd3\x74\xc0\x74\xc2\x39\x93\x4c\x52\x2e\x8f\x6f\xd3\x26\x48\xff\xcc\xec\xd7\xb6\x25\x9f\x99\x9d\xbc\x2e\xaa\xd3\xae\x89\x6b\x27\xe6\x11\xe0\x62\x57\xfd\x31\xc7\x37\xb1\xc9\x45\xc8\xd2\xdc\xe9\xa4\x2d\xd5\xd6\xde\xad\xe4\x80\x54\x19\xdf\x29\x9b\x0c\xbd\x58\x72\xcb\xcb\x2a\xe8\xcf\x97\x2f\xb3\x82\x80\xad\x3c\x77\xa6\x77\x20\x94\xdd\xd3\xe7\x48\x1f\xe8\x1d\xc3\xda\x6e\x17\x4b\x8b\x77\x2f\xd9\xca\x2c\x74\xd1\x79\xcb\x14\x3a\x06\x6e\x06\xbb\xb7\x7c\x9a\xd3\xe9\xc4\x49\xdb\xa5\x37\xd2\x05\xfd\xc0\xa7\xd1\x88\xa6\x71\x35\xac\x41\x3c\x53\xab\xc2\xf6\x57\x7e\xab\xcd\x9d\x55\x42\xa2\x99\xea\xd0\x32\x95\x5e\x46\x12\xb6\x66\xd4\xbe\x28\xa3\x56\x2b\xa2\xab\xc0\x87\x7b\x90\xb4\x3d\xdf\x7e\x88\x1a\xdd\xef\x79\x36\x56\x8e\x11\xd5\xcf\xd8\x9d\x79\x94\xba\xba\x99\xfb\x50\xeb\xea\xc6\xab\x34\xbb\x7a\x16\x3f\x08\x74\xaa\x93\x2a\xee\xef\xce\x3b\x0b\x68\xe6\xbe\x66\x01\x8d\x37\xce\xe2\x88\xa7\x45\x56\x9b\xf3\x6c\xe7\xf9\xdc\xf3\x90\x0d\xdd\xd7\x4c\x64\xf3\x8d\x73\xf9\x07\x4d\x26\x34\xfb\x80\x56\x98\xd5\xd3\x99\xcb\x62\xc0\x6d\xeb\xbe\x66\x64\x7a\x98\x67\x83\x9a\xb1\x6d\xae\xcc\x3f\x7e\x6b\xf7\xbc\x55\xb5\xb8\xf7\x99\x6d\x23\x9e\xdf\x2d\x61\xe3\x97\x16\x49\xaf\x93\x01\xad\x6d\x23\xd6\xb6\x11\x0f\x52\xea\x5b\x6f\xb0\x01\xca\x37\xcb\x18\xa3\x32\xdd\x8d\xf8\xf3\x95\x95\x17\x37\xe2\xc9\x74\x9c\x5a\x1f\x7f\xc9\xc2\x49\x9f\x04\x57\x59\x38\x09\x36\xe4\x23\x24\xe3\x57\xaa\x51\xbf\x7e\xc6\xaf\x02\x1d\x00\xe2\xae\xe6\x17\x98\x29\x01\x14\xc1\x25\xa1\x61\x55\xf4\x9e\xcf\xfc\xba\x58\x25\xaf\xff\xfb\x4f\x6b\x21\x35\xb2\x04\x42\x34\x88\xed\xb2\x32\xc4\xc8\x04\x15\x82\x76\x65\xfc\xca\x8c\x16\x10\xa9\xa6\x8f\x01\xe7\x09\x5a\xb6\x48\x49\xf3\x99\x66\x89\xcf\x20\xde\x4a\x0e\xb8\x91\xf1\x24\x27\xf9\x34\x1a\x91\x30\x27\x67\x20\x65\x1d\xf0\x6b\x99\x78\xe6\xf8\x8a\x15\xd1\xe8\x0c\x42\x68\xbc\x29\x54\x18\x97\xdc\x1e\x0c\x49\xc2\x1b\x3e\x2d\x00\xe4\x7b\x95\xcd\xe0\x7d\x18\x33\x7e\xd6\x01\x8f\x6c\xe9\x78\x0c\xf9\x6a\x74\xd0\x0e\x00\x90\x63\xb1\x63\x60\xe4\x05\x0d\x63\xc4\x55\x96\x13\x9e\xd2\xae\x9b\x44\x54\x4f\x61\xf5\x96\x39\x96\x7d\x77\x75\x02\x03\x31\x59\xf5\x2d\xe3\x57\xf7\x62\xd1\xe3\xa5\x00\x10\xd4\x40\x1a\xa1\x8b\x49\x0a\x6a\x34\x67\xc0\xf9\x25\x83\xf8\x8b\x79\x89\x89\xda\xf1\xf9\xdb\x07\x8b\x85\x43\xd7\x61\x70\xe6\x0b\x83\xee\x4e\x6a\x56\x28\x74\x8d\x00\x5f\x28\x1a\xfa\x1f\x81\x56\xfe\x1e\xec\xa3\xe6\x6a\x50\x1c\x8f\xda\xa6\x04\xfd\xf3\x0c\xad\x0c\xf2\x54\x04\x72\x02\x5a\x0a\x12\xd4\x95\x44\x42\x36\xc2\x0d\x72\xdb\x6e\x19\x69\xc4\xfd\x88\x89\xee\x96\x60\x7d\xe5\x62\xa2\xf5\x7b\xe7\x4b\xbe\x77\xd6\xa6\x4f\x6b\xd3\xa7\x87\x67\xfa\x74\xef\x11\xc1\xff\x00\xcf\x70\xa8\xf8\x26\x9d\x4c\x6b\x57\x7f\x7f\xcf\x5d\x7f\x14\x40\xd6\x8d\xe6\xd9\xfe\x9f\xfb\x71\xff\x27\x4c\xd8\x6b\xa4\x14\x2c\x4d\x58\x4a\x37\x9d\xdc\xbc\x8d\xe2\x8a\xe6\x6c\xbf\x5b\x5b\xe4\x3d\xcd\x69\x41\x86\x8c\x26\xb1\xf8\x43\xb1\x46\x30\x3e\x09\x35\x66\xa9\xcc\x10\xab\x73\xf3\x6a\x17\x16\x5d\x32\x0e\xb3\x73\x96\x5a\x05\x98\x61\xb7\x4f\x7a\x1b\x96\xa2\x16\xa1\x7e\xe4\xd9\x38\x4c\xec\x14\xb4\xa2\xf4\x03\x9f\xcc\x72\x89\x41\xc0\x7a\xbf\x97\x72\x57\xaf\x68\x9a\xd3\x39\x7b\x9a\xb7\x17\xb2\x45\x76\xec\x9e\x86\xd3\x24\x91\x0b\xa4\xfa\x71\x92\xe7\xde\xc1\x03\xe7\x2d\x0c\xa5\x96\xba\x62\x62\xa0\xd6\x09\x26\x23\x06\x9f\xca\x34\x87\x3f\x52\x58\x62\x7c\x68\xae\x50\xe4\x94\x2b\x99\xd3\x90\x67\x63\x25\x6b\x58\x8b\x9d\x1e\x98\xd8\x69\x9d\x4d\x75\xc5\xd9\x54\xdf\x0c\xc9\x99\x78\x08\x9d\x75\x64\x94\x8c\x01\x4d\x3a\x84\xc1\xa5\x1e\xa6\x31\x19\xc1\x8d\x8d\x49\xa0\x8d\x6c\x4c\x92\x6d\xcc\x69\x1d\x9a\x38\xd9\x18\x65\x40\xaf\xa2\x2a\x6f\x94\xfa\xcd\x1e\x4f\x6d\xc7\x29\xa1\x59\xc6\x33\xbf\x5b\x28\x5c\xbe\x4f\x2b\x92\x70\x98\x93\x2b\x9a\x24\x18\x26\x3a\x27\x8e\x8c\xed\x6b\x8c\xe9\x5d\x84\x17\x14\x22\x41\x0a\xd2\x31\x4d\x12\x24\x90\x82\x98\x40\x0d\xb4\x56\x53\x51\xa9\xb7\x36\x1c\x9a\x3a\xf7\x08\xfd\xc3\xc3\xd3\xef\x92\x69\xfd\x14\x05\xce\xcd\x6a\xe0\x7b\x1e\x4d\xeb\x4f\x70\xb9\x85\xca\x8d\x91\xb1\xfe\x63\x16\x85\x2a\xf4\x26\x86\xc3\x14\xe8\xc3\x72\x22\xdb\x8c\x2d\x19\xb0\x2c\x59\x70\x7b\x80\xfa\x63\x9e\x74\xa4\xff\x67\x1d\xec\x3c\x8c\x21\xd8\xf0\xa5\x78\x55\x46\x61\x42\xe4\x6d\xa6\x85\xb2\x02\x87\xd5\x26\xc4\x95\xc4\x4c\x5d\xef\x4b\xdf\x43\xb6\x7d\xf4\x4f\x46\xe6\x8c\xc1\xe4\x94\xac\x3a\x66\x59\x71\xb3\x35\x14\x8b\x4e\xe3\x2d\xc0\xd0\x2d\xb5\x16\x40\xc2\xe0\xda\x81\x85\x83\xd0\x9e\xe4\x3d\x4d\x20\x7a\x3c\x57\x49\x8c\xb1\x3d\x2d\xd4\x1e\xb1\xf3\x11\x30\x48\x6c\xc0\x92\xe2\x06\x26\x4a\xd3\x7c\x9a\xa9\xf8\xe3\x48\xcd\x21\xd8\x79\x72\x15\xde\xe4\xe2\xc7\x0d\xc6\x23\x4d\x73\x06\x5a\x16\x19\x61\x54\x27\xfb\xce\x68\xaa\x6e\xc1\x33\x4b\xad\x8e\x12\x75\xcc\xc0\x2e\x87\xa1\x92\x28\xcb\x90\x74\x43\x9e\x24\xfc\x4a\x0c\xd7\xac\x70\x1f\x02\xb5\x6e\x12\x6d\x14\x62\xfd\x36\x86\x08\xb2\x10\x5e\x11\xf6\xdf\xaa\x06\x1a\x88\xbb\x66\x23\xcb\x9a\x86\x5b\xad\xcc\x34\x0a\xb7\x60\x6b\x62\x9c\xce\x63\xf0\x6d\x9b\x91\x98\x68\xa7\xbf\x50\x1d\x8e\x9e\x15\x34\xc3\xa3\x83\xd9\x2e\x9c\xad\x10\x5b\x3a\x64\xf2\x62\xc6\x77\x16\x4b\x09\x30\x9f\xaa\xa9\x82\x03\x3d\xb9\x51\xf6\xc0\x24\xa7\xd9\x25\xcd\x08\x58\xde\xa3\x95\xa4\x8a\x3f\xef\xc4\x48\x5d\xd4\x94\xdb\x9a\xc8\x22\xd6\xdb\xf6\xfc\xdb\x73\x87\x59\xf5\x63\x76\x86\x31\xcf\x52\x1a\x1f\x17\x61\x56\xa8\xcc\x35\xfa\xfd\x90\x15\x37\x5e\x99\x3c\x64\x4a\x3c\x4a\x4a\x31\x41\xd1\xe4\x12\x08\x60\x93\xb9\xb7\xb1\x8d\x56\x66\xc2\x50\xa5\x14\xfe\xcd\xfd\xec\x59\x10\xdf\x5a\x8d\x7d\x65\x4d\xaf\x2b\x47\x59\x6e\xcd\x8a\x71\xa4\x67\x82\x89\x78\xbc\x46\xab\x26\x25\xae\x85\x19\x26\xec\x82\x85\x82\x52\x32\x66\xe7\xa3\x02\x54\x5d\x4a\xde\xd9\x35\x60\xdf\xf3\x8c\x98\xf4\x56\xa1\x0e\x4f\xa9\xa3\xf8\x43\x65\x48\xce\x84\xa9\xa2\x38\xbf\x30\xb5\x21\xf9\x7a\x98\x9a\x9b\x40\xb3\x08\x83\xa9\x78\x82\x09\xd2\x3d\xc2\x00\x73\x48\x3f\xa2\x69\xde\xad\x5d\x77\x98\xd5\xa3\x47\xc4\x9b\x8c\xbf\xfe\x02\xac\x61\xf9\x97\x5e\x7d\x3f\x30\x59\xfd\xf2\xbf\x12\xe8\xe8\xac\xbf\x8b\x4e\x0e\x06\x00\xee\x36\x8e\x40\x62\xf7\xdc\xbb\x7f\x94\xd0\x30\x6d\xe8\x7e\xa9\xde\x9b\x67\xef\x87\xfb\xad\xb0\x55\x96\x90\x76\xfe\x6b\xd3\x6f\xc9\x26\x59\x39\x07\xa9\x10\x90\x73\x45\xdf\x15\x6d\x1b\x27\x05\x29\x65\xea\xb2\xfc\xed\x94\xf9\x71\xd3\x4e\x02\xa0\xa4\xe2\x06\x3f\xa6\x09\x8d\x8a\xe0\x63\x5b\x47\x78\x83\x4f\x5d\x96\xc3\x3e\xca\x2a\x32\xfa\x17\xec\x42\xa5\x13\x81\xb5\x9e\x8e\x2d\x3d\x71\x22\xd8\x2d\x31\xc4\x8a\x81\xbd\xb4\x48\xa1\x33\xbe\x86\x91\xd9\xe4\xb3\x76\x80\xb7\x96\x29\x79\x4d\x04\xdd\x06\x9f\x05\xe7\x66\x75\xbc\x15\xbc\x08\xba\x35\xf6\xfc\x75\x71\x76\xe7\x08\xc6\x66\x5e\x19\x26\xc8\x9a\x2a\x71\xc2\x2b\xc2\x4b\x41\x83\xc0\x4f\xfb\xbb\x66\xc6\x34\x48\x66\x69\x52\xd5\x7f\x63\x2d\xb5\x40\x18\xfc\x6d\x47\xce\x3c\x55\xb7\x97\xd9\x01\x27\x80\xb2\xbb\x19\xa7\xe5\x2d\x72\xa7\x86\x48\x75\x6a\xe1\x98\xfd\x5d\x92\x28\x03\x21\x0b\x54\x7c\xb7\x52\xa4\x62\x42\xc6\xa8\xec\x93\xbb\xd5\x77\xb0\xc6\xbd\x68\x1b\x07\xd5\x27\xa5\xc1\x98\xd7\x5e\xed\xfa\xf7\x49\x69\xdd\x0d\x95\xc5\x3f\xca\xab\xdd\x97\xff\x56\xed\x56\x9f\x54\xed\x12\x4f\x5f\x49\xca\xe9\x91\x66\x17\x08\xc8\xa5\xe7\x86\x41\xc3\xd4\x05\x92\xef\x24\x9f\x71\x70\x81\xf0\x35\xe6\xdd\xc3\xe5\x33\xb6\x22\x67\x17\xa3\x14\xf8\x31\x1c\xd3\xdc\x89\xf2\x8a\x78\xb9\x53\x7b\x58\x6c\x5a\x8d\xa0\x25\xcb\x11\x42\x88\x65\xa0\xa2\xa1\x5c\x13\x15\xe2\x99\xa9\x38\x60\xb6\xa1\x0a\xf1\x53\xce\xdb\xc0\xe5\xa8\x89\x15\xc7\x79\x67\x8e\xf3\xbc\x53\x3e\xd0\xfa\x9d\x6d\x01\xe9\xb2\x86\x33\xbd\xd3\x2d\xa3\xdb\x82\x56\x33\xb2\x21\xb0\x9b\xb1\xec\x63\x6a\x6d\x68\xec\x90\x8e\x6a\xae\xe2\x6f\x98\x93\xf8\x43\x8f\x1b\xf2\xcc\xc0\xf0\x74\x38\x1d\xb2\xb0\xfb\x93\xb3\x1d\x66\x9a\x75\xe6\x2f\x55\x3b\x3e\x7f\xd4\x9d\x96\x85\xa9\x90\xec\x75\xa6\xb5\x84\x81\x37\x96\x3e\xb6\x74\xbd\xa3\x77\xec\xf0\x50\x3f\xc3\x67\x1b\x61\xd4\x37\x0b\x92\x74\xb7\x55\x7c\xe5\x2f\xd7\xa8\x41\x32\x83\x83\xed\x8e\x7d\x62\x1d\x7b\x25\x43\x26\xa4\x31\x91\x1f\x82\x78\x15\x14\xa8\xed\xc5\x25\x9d\xc3\x85\xcc\xba\x25\x66\x3a\x8f\xd9\xcf\xc3\x39\xb3\x8e\x99\xdb\x42\x3f\xde\xe4\x15\xa1\x7f\x5b\x92\x32\x5d\xa6\xae\x04\x29\x8f\x71\x24\x4a\xda\x1c\xc6\x1e\x4e\x5d\x58\x4f\xff\x1e\x9c\x3b\xaa\xe7\x2a\x4c\x6d\x94\xe7\x8a\x32\xb6\xb1\x64\x04\x9e\xa9\xcc\x93\xb5\x27\xc1\xda\xb2\xe6\x81\x7a\x12\xac\x6d\x24\xd6\xae\x0a\x9f\xcf\x54\x20\xe2\x09\xcf\x94\xd2\x7a\x12\x26\xb4\x28\x68\x17\xe4\x4b\xdd\x91\x16\x27\x1b\x19\x60\x5a\x7c\x1f\x8e\x59\x72\xa3\x6a\x14\x37\x13\x7e\x9e\x85\x93\xd1\x4d\xd7\x7c\xb4\xc1\x8f\xd9\x7f\x69\x05\xf0\xe4\xfa\x03\x7f\x4f\xc7\xad\xed\x1d\x7d\x87\x8a\xab\xe4\x65\xc2\xce\xc5\x35\x94\xd0\xa1\xf1\x05\x9f\x4b\x07\x9f\xb0\x94\xfe\x83\xb2\xf3\x91\xb8\x0d\xb7\xe9\xd8\xd4\x66\x69\x75\xb9\xb2\x3f\xc0\x8b\x1a\x8b\xe3\x05\xb4\xff\xbe\x56\x5f\xde\xb3\x8d\x0b\x0b\x30\xdd\x97\x4f\x7a\x6e\xaf\xfa\xd2\x9e\x63\x57\x14\xb0\xe1\x2f\x56\x13\xa6\x73\xed\x27\xf2\x3b\x52\xd8\x7b\x6a\xc3\x2f\xa8\x4e\x9e\xa7\xeb\x15\x2a\x94\x51\x63\xd9\xac\xa5\xec\xea\x7c\xca\xf8\x8a\x49\x6e\x08\x1f\x48\x55\xe5\x25\x0b\xb5\xb6\x6d\x98\xf1\x31\xb6\x6c\x73\xb6\x1b\x0b\x6a\x30\xf1\x4d\x23\xf5\x95\xae\x93\x8a\xd1\xc7\x55\x2a\xbb\xaa\x04\x0e\x9e\xe0\xb7\xda\x09\x65\x5e\x3f\x17\x29\x17\xa8\xf1\x75\x51\xfb\xee\x40\xf9\x32\x01\xd8\x23\x07\xc2\x91\x08\xe0\x1a\x39\xdf\xdd\x67\xfe\xd2\x8e\x31\x73\x3c\xf0\x2b\xdf\xf4\xd6\x33\x1e\x57\xd3\x7d\x91\x90\x43\xb5\x07\x5d\xf7\x03\xbe\xfa\x45\x05\x4b\x52\x62\x2f\x91\x6a\x4f\x49\x48\xf4\xca\xe8\x8e\x94\xc0\xc3\x2c\x0a\x6c\x29\x1b\x92\x96\xdb\x97\x92\x39\x41\xdc\x38\x24\xa3\xa6\x53\x41\x23\x35\x3f\x1f\xb4\x6d\x9b\x3e\x35\x2c\xb7\x35\xbd\x67\x4e\xd4\x29\xab\x6d\x39\xe2\xba\x86\xd5\x84\xbc\x56\xa1\xb8\xae\x49\xfb\x51\x5f\xd5\xa6\x59\x0b\xb7\x51\x5b\xb0\x7b\xab\x24\xe0\xda\x75\x6b\x51\x8f\xa6\x95\xc8\x40\x34\xc6\xeb\x15\x5e\x4e\x3e\x81\xe7\x02\x57\x73\xb9\x16\xe2\x06\x81\x49\x8d\x98\x43\x34\xbd\xb0\x6b\xd6\x64\x01\xc7\xac\x68\x21\xa7\x2c\x43\xf0\xd6\x9e\x59\x6b\xcf\x2c\x8b\x3e\x37\xbb\x67\xcd\xd5\x9a\xa2\xf0\x2b\x68\x4a\xde\x11\xf5\xeb\xe6\x5d\xed\x15\x1e\x64\x16\xa6\x47\x77\x91\x82\xad\xcc\xcd\xcc\x0a\x73\xa2\xc4\x5f\x56\x5c\x92\xfb\x71\x38\xdb\x7b\x58\x0e\x67\x28\x4e\xf8\x07\x8b\x63\x5a\x9b\x69\x66\xff\xe9\x17\xce\x34\x83\xc3\xab\x0d\x14\x83\x9f\xff\x59\x2b\x99\x79\x3e\xd7\xf8\x55\x2b\xf7\x37\x81\x7f\xe6\x0f\x21\x20\xcc\xd3\xdf\xb5\x18\x57\xc6\xaa\x07\x9a\xca\x86\x37\xb5\x28\xfb\xac\x0c\xdb\x18\xd7\x5e\x01\xe9\x6a\x17\xf4\xa6\x0e\xa1\x76\x77\x1d\xa8\xa6\x76\xc5\xf7\x87\x29\x91\xbd\x57\x69\xf7\x55\x98\xa5\x98\xb1\xb3\x52\xc2\xf7\xc4\x07\x6c\x14\x62\x22\x88\xe7\x94\xf8\x5d\x46\xc3\x8b\x09\x67\x69\x51\xb7\x4b\x4f\x76\x1c\x69\xa9\xd6\xbf\x56\x3a\x87\x3d\x29\xc3\xce\x12\xac\xa2\x32\xed\x4f\x2d\x57\x9d\xb3\x3d\xa4\x7e\x4a\x80\x56\xbd\x01\x4f\xe7\x1e\x9d\xdd\xda\x0a\x07\xa9\x86\x57\xc7\xe0\xdf\x76\x96\x9a\xee\x61\xad\x57\x51\x98\xde\x90\x17\xe4\xd3\xed\xfc\x61\x1e\xad\x86\x3b\xbf\x2b\x39\xe4\x1f\x28\x1a\x66\x9d\x58\x52\xfa\x5a\x88\x9a\xca\x30\x1e\x4c\xd2\x0d\xe9\x89\x69\xc4\xb3\xb0\xe0\x99\xde\x8f\xab\x46\xd7\x0b\xbc\x92\x1c\x8d\x6f\xdb\x0a\x4a\x23\x3b\x27\x9b\x04\xa8\x4e\x1a\x26\xce\x96\xdb\xb1\x5f\x14\xf7\x51\x0a\xfd\x32\x4b\x66\xc6\xd3\xe4\x46\x7f\x14\x3f\xd4\x87\xeb\xfc\x67\x23\xbc\x12\x3f\xd4\x87\x7c\x6c\x7d\x10\x3f\xb4\xd0\x2b\xb6\x3e\x88\x1f\x5a\x07\x71\x6e\x7d\x10\x3f\x74\x1f\x89\xdd\x47\x62\x7d\xc8\x5f\xf1\xab\xd4\xea\x5e\xfc\x34\x03\x70\x3e\xe2\x4f\x33\x08\xe7\x23\xfe\x34\x03\x71\x3e\xe2\x4f\x33\x18\xb7\xcf\xc4\xfe\x78\x25\xaf\x16\xfc\x76\x65\x1b\xf5\xac\x42\x94\x27\x16\x5e\xfc\x2b\xd6\x59\xfc\x2b\x96\x15\xa4\x76\x31\xfe\x2b\x16\x0d\xbe\x27\xf2\x5f\x58\x10\x84\x54\x7f\xe1\x54\x11\x5a\xfd\x85\x93\x10\x7f\xc1\x90\xb5\x15\xcf\xdc\x92\x07\x78\x6f\xc9\x0b\xdc\xcc\x01\x8a\x81\x2f\x32\x65\x28\x04\x51\x69\xfc\x05\x29\xe9\x75\x48\xf0\x36\x2c\x68\xc6\xc2\x64\xf3\xe7\x37\x7d\x32\x4d\xa5\xdf\x00\x8d\x61\x21\x71\x6d\x48\x86\xd9\xea\x63\x12\x90\xc7\x32\x95\x8f\xe6\xe7\xfc\xf6\xc9\x63\x12\x88\x33\x77\xf6\x8d\x7c\xcf\x6c\x7d\x7b\xd6\x0d\xc4\x0b\xf4\x92\xb3\x98\xf4\xb4\xb0\xf8\x92\x81\xb3\x81\x49\x96\x04\x86\xe2\x67\x62\xa1\xcf\x48\x34\xa2\xd1\x05\x61\x39\x19\x86\x39\x04\x2a\xe7\x82\xd3\x27\x7c\x5a\x90\x9c\xf3\x94\x66\x84\x0d\xc1\xe3\xa4\x2b\xe5\x94\xa2\x9a\x2d\x9d\x84\xc0\xf8\x5d\x96\x63\x80\x7c\xf8\x6a\x84\x7c\x3a\xbc\x3e\xc3\x70\xf9\x8c\x7c\x03\xc7\x4c\xae\x8d\x28\x78\x7c\x48\xb6\xfd\xd8\xe7\x03\xcd\xee\x90\x43\x80\x3f\x61\x1f\x8d\xe5\xac\xe8\x55\x22\xe1\xe1\xa1\x05\xeb\x1a\xe2\x9a\x59\x5b\xe1\xae\xf1\x3f\xa8\x52\x1b\x69\xdc\x64\xa4\x06\x82\xf0\xe8\x11\x31\x9d\xd9\x93\xaf\xe9\x42\xcb\x2c\xb7\xb6\xc8\xcb\x24\xe1\x57\x6a\xa5\x0b\x4e\x06\x70\x51\x0d\x40\xcd\x20\x48\xa5\x3c\x30\x78\x92\xc8\x9b\x21\x09\x93\x8c\x86\xf1\x0d\x19\xc1\x8e\x76\x48\xca\xb5\xc3\x0a\x6e\x14\x54\xc8\xd5\x5e\xc8\x01\xa8\x11\x6d\x6d\x91\x98\x16\x34\x1b\xb3\x94\xe2\xe0\x58\xc2\x8a\x1b\x32\x08\x73\x1a\x2b\x7f\xa6\x7c\x1c\x26\x09\xcd\x0b\x92\xb3\xff\x52\x32\x9d\x6c\x38\xfb\x74\x2a\x37\xea\x54\xec\x54\x99\xf9\xec\x0a\x4c\xd7\x9b\x77\xea\xef\x1e\xb4\xe0\x6c\x5e\x4d\x13\x27\xa7\xcc\xc9\x7a\x6f\xea\x18\x2a\x78\x62\xb7\xf4\x98\x04\x3f\x4f\x82\x9a\x3a\x36\xb1\xf2\x6b\xc1\xa1\xd7\xf5\xc4\xa2\x39\x7d\x29\x33\x6f\x7d\x71\x75\x59\x0e\xff\xfe\x3c\x69\xb7\xac\xa6\x3a\x88\x04\x6d\xc1\x83\x79\x1d\xd7\x36\x21\xbe\x56\x36\xe2\xa0\x7b\x1d\x9a\x3a\x48\x7a\xeb\xa2\x16\x78\x34\x78\x9b\x2f\x19\xee\x74\x9a\x24\xda\x70\x5c\x96\x19\x7f\x80\xdb\x46\x49\x12\x3e\x04\x0c\x9d\x69\xb7\xf4\x4b\xfe\x7e\xa4\x43\x0f\x32\x0f\xf1\xdf\x33\x16\xd7\xbd\x51\xe7\x0b\x58\x7d\x8f\xb2\x21\x31\xb8\x87\x20\x56\x59\x65\x0e\xe2\xb5\xb9\xdb\xef\xdc\xdc\x6d\x1d\x48\x6a\x1d\x48\x6a\x1d\x48\xea\xf7\x68\x24\x09\x15\x31\xb3\xfd\x77\x61\x5e\x27\x4b\x7b\xb2\x57\x01\xdb\xd4\x89\x81\x5a\x47\xa1\x5a\x47\xa1\x9a\x2b\x0a\x95\x13\x7e\xea\xd7\x69\x5e\xb0\xe1\x8d\x4c\x4e\x2c\xbf\x6e\xe6\x45\x98\x19\x93\xcf\x30\x61\xe7\xe9\x9b\x82\x8e\xf3\x3e\x09\x22\x2a\x70\x65\xae\xf8\x54\x05\xbd\x2e\x5e\xa1\x70\x0a\x21\xc0\x9f\xc1\xb6\xb5\xd4\xa1\x43\xac\xf4\xea\x15\x0d\xda\x55\x2e\xe8\xcd\x80\x87\x59\xfc\xbd\xf2\xa9\x53\x15\x07\x61\x74\x71\x9e\xf1\x29\x66\x1d\xb2\x4d\x35\xc1\xc0\x28\x66\x97\x4c\x05\x15\xd0\xf6\xa5\x12\x63\xbd\xd4\xee\x60\x62\xba\xbd\xe3\x45\xcb\x52\x11\xa5\xb6\x77\x1a\x6c\x54\xed\x16\xea\xcd\x63\x67\x66\x80\x6f\xb6\x47\xe5\x02\xb2\xb8\xe9\x93\x5e\x77\xcf\x85\x84\x29\x5a\x4b\x02\x71\x14\x54\x37\xc1\xf6\xe4\x9a\xe4\x3c\x61\x28\xf3\xa8\x58\xa3\x84\x9d\x8f\x8a\x57\xe5\x85\x3a\x9f\x16\x05\xcd\xf2\xd2\x34\x7f\xa0\xc3\x62\x56\xd0\x2f\x09\xfa\x1e\x8d\x7e\xab\x61\xed\xbe\x06\x40\xd0\x4c\x57\x45\x16\xa6\x0a\x23\xa4\xe1\xb2\x2e\xc9\xa5\x45\x4d\x2b\x30\x9b\xbf\x09\xd6\xba\x81\xed\x60\x14\x4f\x15\x06\x96\x1b\x50\xdf\xba\xf9\x88\x67\x05\xcd\x0b\xf5\x0c\x6c\x5b\x89\xfc\x47\xfc\x92\x66\x4e\x0e\xff\x6a\xd4\x36\x0e\x48\x66\x3c\x47\x55\xc6\xc3\x36\x46\x9a\x4a\x3a\x9e\x1b\x4f\xc9\x98\x0b\xc6\x3d\xa6\x97\x2c\xa2\xb9\x86\x08\xfe\x36\xa6\x31\x0b\x49\x0b\x46\xd4\x27\xa2\xd7\x76\xe0\x3a\xb8\x96\xba\x0e\x60\xbe\x98\xb6\x34\x30\xa2\x18\xd3\x6f\xf0\xe8\xaf\xda\x3a\x64\xb9\xb6\xdc\xb7\x33\xb6\x9c\xd3\x88\xa7\x71\x98\xdd\xbc\x94\xa1\xed\xac\xf8\x0c\x2f\xe3\x98\xe4\x7c\x4c\xc1\x48\x94\x92\x82\x93\x10\x24\x69\x11\x4f\x12\x96\x0b\xda\x16\xe6\xe4\xec\x07\x96\x17\x82\xec\x1c\xbb\x2d\x9d\x99\x76\x58\x4e\xc2\x41\xce\x93\x69\x41\x93\x1b\x4d\x3a\xac\x20\x0f\x73\x60\xdf\x93\x55\xdb\x6e\x7b\xe6\xc0\x6a\x16\x68\x25\x3b\xa0\x24\x94\x38\x6e\xf4\x27\x0a\xe7\xe7\x36\xbe\x7d\xe0\x6a\x99\xb5\x79\xf8\x3a\x9e\xdb\xe7\x89\xe7\xa6\xd2\x1e\x68\xab\x73\x79\xe0\x49\x4c\x73\x76\x9e\xca\xa5\x56\x3c\x03\x44\x1b\x42\xca\x8a\x41\x5b\xd4\x91\x54\x52\x77\x69\x83\x8f\x77\xfa\xd2\x91\xcb\x56\x10\x12\x8e\x0e\x31\x34\x5d\x06\x11\x68\xd4\xa4\x20\xda\xd8\x98\x5f\x3a\x83\xc5\xce\xfe\xae\xae\xe8\x65\xba\x0c\x89\x60\x0d\x12\x0c\x95\x03\x3c\x03\x50\xd6\x38\xc6\xe3\x24\x46\x34\x00\x26\x42\x11\x9b\x84\xe5\x05\x61\x05\x1d\xdb\xe3\x90\xcc\xc7\xac\xe4\x17\x82\xbc\x6a\x9a\xb8\x7c\xa0\x2b\xd5\xc4\xcc\x28\x57\x0a\xb0\xb5\x48\x50\x2b\x55\x49\x7a\x0e\x4b\xbe\x7a\xd1\x88\x52\xaa\x95\x45\xc2\x49\xe9\x9e\xdb\x32\xfd\x2f\xb6\xa5\x73\x1a\xb7\xe7\x4a\xb0\x6a\x56\x67\xa5\x91\x4a\x4a\x91\x36\xe4\x51\xb1\x22\xe2\x40\x89\x98\x26\x94\x29\xf3\x7e\x5d\x6a\xe2\x55\x7d\xce\x58\x11\xb5\xa1\x22\xf0\xe6\x35\xb1\x4e\xf0\x77\x55\x30\x09\x27\xac\xc3\x5c\xf1\x24\x1a\xc3\x49\x78\xcd\x55\x45\x94\x88\x2a\x23\x4a\xd4\x04\x94\x80\xf5\x35\xc1\x61\xc0\x78\xdd\xfe\x3e\x57\xfc\x18\x79\x86\x6d\x20\x8f\x45\xf5\xe9\x4d\xa9\x3d\x59\x7e\xe7\xc0\x12\x1d\x72\x12\xe0\x66\xf8\x19\x58\xe6\x8b\x30\xa1\x22\x18\xda\x6e\x29\x72\x36\x56\xb1\x1c\xad\xca\xe8\xa2\x90\x86\xe5\xaf\xe4\x7a\xce\x83\xcd\xb6\xa6\xcc\x0e\x3d\x52\x17\xf5\xa9\xe0\xa8\xc0\xb5\x31\xcb\xed\x7f\x14\xe6\x2f\x2f\xc3\x22\x14\xab\xa6\x33\xc9\x0b\x7e\xb9\x65\xa8\x25\x9c\x8a\x72\x32\x6d\x32\x2b\xfe\x12\xd4\x13\xab\xab\x48\x04\xf6\x24\x7d\x74\x88\x15\x26\x49\x8f\xc5\xe3\xbf\xed\x41\x49\xc5\xbb\x52\xcc\xcd\x8a\xfb\x94\xd1\xf4\xc4\xaf\xbb\x49\xb6\x3f\xda\xe3\xf1\x7a\xf3\xf7\xe6\xcb\xf9\xa6\xc8\x57\x70\x87\x7c\xe5\x62\xcf\x92\xfe\x25\xf2\x68\xa9\x43\xb7\x6c\x2b\xab\xf1\x97\x91\x74\x4f\xd2\xc3\xe5\xda\xf0\x1e\x7c\x9d\x0a\xd4\x59\xac\x61\x75\x0c\x7f\xfb\xcd\x3a\x11\x2f\x5c\x0f\x1d\xd2\xb7\x7e\x43\x23\x32\x8a\xd9\x1c\x5e\x3a\x0a\xa5\x12\x89\x79\xb3\x2c\xf5\x2a\x5d\x71\x3a\x15\x31\xa1\x8c\x7b\x8e\x7d\x92\x34\x83\xf2\x36\x04\x6f\x2c\x87\xbe\xeb\x01\x81\xde\x1c\x77\xc1\x3a\xdc\x7e\x5d\x5b\x3a\x6c\xeb\x28\xf1\x3f\x67\x42\xe6\xc2\xf0\xfb\x14\x0b\x1b\x24\x2c\xa8\xab\xe8\x89\xda\xec\x3c\x57\x6a\xcd\x3d\x90\x52\x2a\x7f\x31\x9b\x0a\x34\x28\x93\xad\x39\xc3\xfa\x38\xb9\xac\xf0\xbf\xf2\xb6\xd0\xbc\xab\x05\x8b\xb6\x9c\xa3\x1c\x89\xaf\xb6\x17\x6f\xc5\x3b\xce\x27\x67\x95\xdc\x4f\x5e\xe0\x19\xf1\x5f\xbb\x8a\x9b\xe8\x4e\xf8\xa4\x65\xc2\xe2\xb4\x4b\x0b\xb7\x64\xb4\x23\x77\xb0\x35\x03\x9d\x37\x3a\x8e\xa2\xc8\x33\x43\xe3\x68\x3e\xb7\x22\x2e\x8e\x92\x6d\xe8\xe8\x36\x76\xa0\x9c\x84\x61\x9c\x1c\xe4\x22\x35\x48\x45\xdc\x1c\xff\x99\x63\x7d\x90\xef\x0e\x93\x28\xca\x8c\xa7\xc2\x1b\x48\x3d\xee\x2a\x9c\x80\xf4\x13\xc5\xd4\xaf\x09\xac\x33\x4f\x23\x77\xf5\x23\x52\x83\x00\x0f\x22\xeb\x3d\xe2\xdb\x07\x3c\x7f\x58\xf6\x01\xa8\x83\x7a\x4b\xd3\x69\x9d\x93\x43\xaf\xf7\x85\x2d\x3b\xc4\xe0\x6a\x7d\x7e\xc4\x47\xb1\xda\xb5\xa3\x9f\xcb\x2e\x45\xb5\x72\x5f\xc3\x17\x6d\x37\x4e\x41\xbe\xae\x2b\xf5\x98\xbd\xb9\xdc\x96\x54\x2b\xf7\x35\x05\x40\xe7\x2f\x6e\x5f\xb3\xdb\xeb\x3d\xac\xf3\xf3\x85\xed\x6b\xd6\xd6\x2e\x6b\x6b\x97\xb5\xb5\x4b\xa3\xb5\x0b\xfc\x7a\xc5\xeb\xc8\xeb\x8e\xc1\x8f\x3c\xca\x78\x92\x0c\xc2\xec\x98\xfd\xb7\xce\x82\x60\x67\xbf\x57\x0d\xdf\xe8\x55\x68\x03\x7e\x56\x0b\x96\x9f\xf8\x84\x5f\xa2\x88\xa8\xf2\x76\xdc\xf6\x21\x9b\xda\x97\x20\x0b\xde\xbd\x0e\x68\x53\xf3\xfa\xa2\xfc\xb3\xda\xba\x6c\x6d\x91\xbf\xc9\x43\x41\x63\xcd\xb1\x13\xb9\xec\x0b\x8d\xf9\x83\xd6\x99\x0b\x2a\x36\x08\xa3\x8b\x3a\x7c\xee\xcd\x3d\x85\x8a\x36\xef\xc1\xef\xae\xe4\xcf\x66\xeb\xd2\x40\x1b\x57\x70\x92\x53\x4c\x26\xa2\x54\xc8\x4a\xd1\x31\xa6\xe9\xd4\xe8\x38\xc2\x34\x1a\xf1\xec\x75\xa2\x15\x6c\xff\xf8\xf0\xf6\x07\xf9\x18\x2b\x6b\xce\x6a\x26\xa2\x12\x0e\xbc\x1b\xb6\xac\xea\xed\x7a\xad\x59\x98\x82\x7b\xd4\xd6\x16\x19\x87\x45\x34\xd2\xdb\x67\x4d\x0b\xd8\x6d\x95\xe4\xab\x63\x22\x2d\x9d\x29\x46\xeb\x2c\x5f\xab\x85\x57\xa6\x16\x36\xac\x8a\xdd\x3a\x64\x94\x51\x24\xe7\x4c\x61\x98\xe9\x49\x7d\x02\xbc\x5c\xa8\x3f\x7d\x3a\x86\xe0\xaf\x38\xa0\x43\x9e\x51\xe8\x0f\xf6\x1d\x0c\xb2\xac\x29\xf1\xf4\xb5\x28\x59\x74\x7b\xab\x4e\xf8\x92\x9b\x5d\xd1\xd4\x6a\xb6\xbe\xdc\x70\xbb\x71\xa9\x20\x45\x87\x5e\x28\x96\xe3\x5a\xa9\x6c\x31\xf6\x6a\x41\x3a\xc4\xf5\x82\xb9\x0b\x36\x0a\xe5\x8a\xd9\x0a\x67\xb9\x60\x90\xb2\xe5\x4f\xbf\x5e\xa5\xb3\x78\xcd\x0a\xf7\x28\x5e\xb3\x85\xed\x31\xfe\x88\x0b\x55\x3e\x89\xd7\xac\xf0\x0f\x22\x16\xad\x97\xab\xf2\x1c\x5e\x0b\x26\xce\x5f\xae\xf5\x29\x74\x56\xcb\xa8\x3a\x44\xe7\x34\x2f\x72\xe5\x0b\x9a\x70\x6d\xe2\x23\x8d\x76\x26\x61\x16\x8e\xc9\x27\xbc\x70\x6f\x65\xba\x28\x93\x38\x2a\xe7\xd3\x2c\xa2\xda\xba\x4e\x76\x68\x2d\xff\x7b\xec\xe1\x48\xb4\xbc\x7c\x8e\xc1\xb1\x3c\x0e\xd2\xc5\xd0\xda\xdf\x09\x5d\xc4\x22\xd0\xb7\x41\xfa\x29\x9c\xd0\x6c\x71\x56\xe3\x4c\xf2\x43\x67\xca\x55\xfa\xa6\xc4\xe2\x48\xf6\xb3\x82\xc3\x91\x5f\x8e\x56\x60\x69\x07\x96\x9a\x0b\xb5\xf0\x01\xcc\xa6\x40\xa3\x2c\xf7\xcc\x98\xf9\x12\x96\x92\xb3\x71\x7e\xd6\x21\x3c\x23\x41\x38\x2d\x78\x60\x7a\xd2\x50\xaf\xb4\x99\x70\x53\x24\x32\x81\xaa\xad\x93\x1a\x88\x74\x3a\x1e\xd0\xac\x3e\x62\x1b\x1c\x02\x94\x90\x52\xe4\xd1\x9a\x1b\x42\x48\xb8\x42\x1a\x01\x37\xc0\x60\x79\x56\x04\x35\x98\xf8\xc7\xb6\x8a\x8e\x2a\xde\x52\x59\x91\xbc\xcb\x18\x46\x87\x04\x69\xa4\xb4\xa3\xeb\x93\xa0\xe0\x18\x9a\x70\xc4\x33\xf6\x5f\x9e\x16\x50\x08\xf6\x68\x81\xb6\xe3\x4a\x8a\x6c\xa1\xea\x10\x49\x5a\xd7\xae\x77\x71\x10\x6d\x4d\x04\x06\xf7\x8d\xbf\x75\x3e\xa1\xd1\xff\xd7\x87\x7d\x1e\x87\xd7\x6c\x3c\x1d\x93\x11\x84\x92\x16\xfb\x1d\x92\x9c\x8d\x27\x89\x3c\x4f\x26\xf4\x2d\x4f\xa9\xd8\xf3\xb1\xb8\xa4\x33\x7e\x95\x93\x84\x42\x32\xc8\x10\xe9\xc5\x25\xa3\x57\xaa\x7d\x6c\x4c\x86\xab\x55\x59\x26\x43\x52\x84\x93\x49\x38\x10\x0f\x89\x8c\x86\x84\x4f\x0b\x48\x3b\x28\x51\xcc\xee\x14\xbc\xcc\xaf\x46\x2c\x1a\x89\xa3\x12\xb3\x7c\xcc\xf2\x5c\x35\xee\xbc\x25\xc5\xf8\x75\x14\xec\x28\x4c\xa2\xd6\x76\xaf\x77\x39\x22\x9b\xe4\xf9\xd3\xc9\x75\x5b\x6a\x37\xa5\x99\x34\x7b\x77\x4c\xc6\x5c\x1c\xb4\xe9\x98\xa0\xdc\x47\x67\x3b\xfc\x85\x0e\x2e\x58\xf1\xee\x92\x66\xc3\x84\x5f\x1d\xab\x8f\xb0\xfa\xd3\x68\x14\xa0\x50\x5d\xae\xb6\x54\xc9\x2c\x6b\x6f\x27\xaa\xcf\xb4\xb5\x13\x40\x5a\x07\x70\x69\xe2\xf3\xeb\x9f\x05\x1d\x4f\x3a\x98\x73\x0b\xcc\x45\x0a\xf9\x71\x1e\x9b\x3c\x50\xdb\x48\x78\xe3\x45\x9f\x80\xb1\x8d\x36\x8f\x93\x56\x25\x60\x30\x27\x30\x09\x4d\x6d\x04\x54\x1b\xa3\x47\x48\xa7\x7b\xf1\xd7\x37\x50\x1b\x7f\x3c\x7e\x6c\x94\xd2\xa2\xea\x89\x28\xfc\x68\xb7\x8c\x25\x4e\x0c\x56\xa3\xa4\x05\xf5\x1e\xcc\x0e\xff\x58\x2e\x03\xa5\x8c\xb8\x29\x26\xba\x88\xc9\x20\x2c\x0c\xa6\x9e\x94\x36\x83\x18\x5a\xf1\x44\x34\xfb\xb1\x1b\xf1\x34\x0a\x8b\x96\x98\x55\x1b\xa2\x27\x8a\x62\xf5\x6f\xf7\x9c\x16\xd2\xf9\xe7\xa5\x94\x6e\xcc\xce\xed\x37\x56\x72\xba\xdf\x7e\x23\x5e\x51\x37\x87\x84\x73\x34\x06\xf5\x8e\xa5\xe7\xdf\xda\x22\x7f\x15\x77\xfe\xf7\xec\xfa\x2d\xad\x37\x5a\x7a\xc5\xc7\xdd\x21\x4b\xe3\x57\xef\xde\xc2\x3b\xbf\xe5\x36\xdf\xee\x0e\x59\x96\xa3\x79\x62\x9d\xce\x7c\xee\xc6\xdc\xb1\xca\x9d\x55\xeb\x32\x36\xb2\x48\xad\x81\x51\xdf\x86\xa5\xb4\x9a\x55\x39\x08\x75\x0b\x8f\x1e\x91\x3b\x2d\xd2\x92\x13\xc2\x61\xb6\xda\x07\xde\x6a\x97\xd6\x0d\xe2\x25\x9b\xe9\xce\xbf\x19\x76\xac\x07\x7b\xb6\x7a\x3c\x66\xb3\x66\xcf\xb2\xa2\x92\x3f\x83\x5b\x77\x8b\x30\x09\x10\xbc\x46\xdd\x7c\xa0\x4a\xa4\x66\x1b\x88\x02\x47\xe1\x65\x6f\x84\x32\x93\x61\xea\x0e\xeb\xb0\xa1\x67\x86\x29\x57\x73\x64\x96\x90\x5e\x03\x5b\x3a\x2d\x42\x5b\xb0\xa8\xe4\xe8\x57\x3c\xbb\xc8\x09\xf0\xf7\x13\xd8\x3a\xe5\xb9\x62\x61\x5a\xcb\xe9\xe0\x07\x5a\x04\x39\x91\x41\x9a\x20\x0b\xf2\x84\x51\xe4\x54\x13\x7e\xce\x22\x19\x45\x26\xcb\xc5\x8d\xa5\xc3\x9c\x88\xce\x32\x16\xab\x64\xa4\x10\x1d\xc3\xb4\xe9\x4b\x3b\x6b\x36\xc9\xdf\x67\xc5\x01\x46\x09\xa3\x69\x81\x57\x1a\xf9\xc6\xec\xa4\x53\xfe\xe8\x11\xf9\xca\x20\xaa\xb8\xe9\xbb\x32\xd0\x87\x1b\x91\x26\x47\x5d\x09\x86\xe4\x71\x14\x22\x56\xb8\x0c\xf2\x98\x04\x93\x6b\xcb\x72\x69\x06\x4e\x41\x7f\x27\xe8\xff\x13\xb3\x8c\x4a\x43\x46\xf1\xf0\xc9\x8a\x44\xbc\x79\x02\xcb\xa7\x2d\x20\x7d\xfd\x1b\x5c\x87\x02\x71\x13\x88\x81\x2d\xd6\x61\x57\x05\x70\xd2\xb7\xfc\xff\x40\x28\xa1\xc7\x38\xc9\xc7\x24\x68\x07\x95\x26\x53\x6e\xce\x57\xc0\xf0\xfa\x94\xb0\xf0\x59\x23\x7d\xe3\x59\x11\x43\xfb\xdf\xf4\x46\x46\x71\xf1\x32\xe8\x76\xc8\x05\xbd\x71\x09\x19\xdc\x97\x62\x91\x8a\x70\x10\xd8\x23\x80\x0a\xdd\x49\x06\xff\x2a\x1d\x8a\x41\xd3\xaa\x59\xd8\xef\xa5\xaa\x44\x9e\x55\x70\x5e\xa6\xdb\xb2\xa7\x19\x72\x14\xca\xac\x70\x9e\xab\xd6\xe2\x3d\xe6\xb2\xa4\x47\xbe\xc7\xb1\xa2\xd7\xaf\xcc\x57\x2c\x7e\xcb\xa7\x69\x9d\x1d\x7d\x09\xce\xbb\x26\xec\x69\x4f\xa8\x63\x15\xe7\x1e\x7e\x67\xce\x65\x6b\x79\xbb\x9f\x9f\x27\x71\x58\xd0\x39\x06\x84\x80\x2d\xb1\x85\x3f\x99\xe8\x6d\x6a\x68\x5f\xe9\x72\x18\x9a\x38\xbc\x0d\xa3\xdd\xda\x22\x3f\x52\x1a\xc3\x63\x3b\xa3\x78\x3b\x86\xb9\x4c\x90\xac\x9f\xb8\x68\xb7\x0f\x59\x28\x0a\x4e\xc2\x14\xed\xc2\xdf\xf2\x38\x4c\x1c\x1f\x48\x48\x96\x2c\xee\x00\x32\x16\xdf\x54\x16\xe6\x51\x98\x9e\x53\x93\x49\x59\xf4\x25\xf1\x8f\x84\xe9\x0d\x49\x68\x78\xd1\x5d\x6e\xfd\x96\xf0\x36\x10\xed\xab\x04\x94\x8b\xf8\x1b\x94\x52\x53\x2e\xed\x49\xe0\xa8\x13\x0c\xa4\x53\xec\xa6\xcf\x53\x17\xe5\xa9\x43\x38\x1c\xf3\x48\xf8\xf2\x57\x23\x3b\x30\xd0\xa6\xcc\xae\x50\x01\xe9\xd4\x3e\xb4\x98\x27\x15\x93\xb2\x04\xe6\x34\xe8\x88\x10\xac\xee\x9d\x72\xbb\x86\xbe\xd7\xad\x2b\x7d\x25\xde\x07\x35\x3e\x07\xce\x02\x63\x14\xbd\xd7\xe8\x11\x4f\x02\x33\x27\xf8\xe5\x8c\x59\x94\xc0\xe0\xee\x90\xd4\x52\xeb\xd4\xb5\xad\xb3\xcb\x23\x36\x27\xb6\x2c\x73\xfa\xd2\x71\xa7\xfc\xa1\x02\x19\xfb\xa4\x7e\x0f\x8c\xc6\xc9\x63\xcb\x6c\x20\x54\x9e\xa2\xb8\x40\xb9\xe2\x56\x5f\xc5\x46\x28\xd1\x37\x12\x06\x67\xcf\xb3\x30\xcd\x87\x3c\x1b\xaf\xa4\x35\x5b\x54\xd6\x10\xa4\xd5\x42\x58\xe7\xf6\xb2\x56\x68\xae\xda\xfa\x30\x7b\xad\xa8\x80\x0d\xca\x84\x19\xe4\x1f\x0e\xc4\x6d\x7b\xa3\xf2\x87\x97\x0c\x82\x2c\x62\xe8\x6c\x0c\x29\xca\x38\x35\x17\x56\x89\x61\x27\xb4\x4f\x02\x41\xe6\x03\xd7\x1a\x9a\xa7\x92\xd9\x70\x30\xc3\x62\x42\xec\xf9\x74\x5c\x92\xe6\x2f\x4f\x46\x87\x0e\x55\x1e\xb6\x52\xc1\x8a\x97\x16\x11\x49\xb3\xfd\x7c\x13\x70\x07\xee\x42\x3a\xeb\x58\x45\x9f\x75\x91\x5a\xe5\x5a\x23\x69\x31\xe8\x99\x06\xd2\xf0\xa2\xaf\x30\x8e\x46\x21\xaf\xb6\x65\xae\x92\x45\x4a\x71\xe5\xd2\x49\x39\xc5\xe7\x0f\x28\x4d\x05\xb3\x4d\xcb\xc2\x58\x8c\x0a\xac\x8b\x95\x64\xc5\xb3\x8c\xdc\x7e\x58\x96\x91\xf3\x18\x20\x3d\xfd\xe2\xc6\xc5\xca\xa6\xe9\x01\x58\xb6\xee\xfc\x01\x02\xf2\xff\x79\x8c\x5d\x0b\x2e\x9e\x2d\xd3\xb1\xc0\x43\x90\x5a\xd6\x5a\x45\xee\x37\x54\x6a\x1a\x42\xb9\x87\xb5\xa5\xed\xda\xd2\xf6\x0f\x61\x69\x7b\x41\x6f\xa2\x7a\xab\xca\x67\x7b\x3e\xe0\x8c\xd4\x1a\x02\xc4\xe0\x02\xfa\x92\xd5\xa6\x18\xd8\xd9\x2f\x81\x36\x86\x9e\x93\x30\xba\x52\x18\x15\xec\x92\x6a\x33\xc2\xea\xa9\x3e\x7b\x5a\x0d\xdf\xd4\x93\x03\x68\x68\xd7\x55\x4a\xb3\x57\x3c\x9a\x36\x74\xb7\x6d\x2d\xad\x03\xdf\xd4\x9d\x03\xa8\xab\x37\xd8\xf3\x6e\x5b\xc9\x54\x66\xd9\xf2\xae\xed\x78\xcb\x76\xbc\x62\x4d\xee\x6e\x12\xab\x8d\xae\xff\xc4\xf6\xa3\xab\x09\xf4\xe3\xb7\xc2\xd3\xef\x92\x69\xbd\x8e\xbf\x6c\x1b\x52\x6e\x40\xbf\x9f\x1a\xda\x70\x34\xbc\xf2\xb8\xdd\x45\xcb\x2b\x9a\x98\x4b\xd3\x2b\x00\xef\x55\xdb\x6b\x2b\x57\xfe\xf0\x1a\x5f\x50\x1b\x2c\xa8\xf5\x85\x05\x5a\x56\xf3\x0b\x09\x80\x25\x35\x80\xb7\xef\x34\xcb\x68\x5a\x7c\x08\x07\x6f\xd2\x98\x5e\xf7\x8d\xe8\xce\x55\x25\x24\x35\x5a\x51\x5b\xf9\x58\xf5\x7d\x90\x4c\xb3\x0f\x6c\x0c\x6f\xb7\xd2\x47\x14\x0d\x88\xf3\x52\x56\x4c\x98\x7d\x2a\x37\x94\xd3\x42\xfc\xc9\xa7\x45\xab\x4a\x1b\x6b\x2b\x22\xc4\xb8\xbd\xc4\x05\xd2\xf9\x7f\x1e\x65\x5f\x62\x2b\x3c\x55\x65\xb9\x64\xdf\x4b\x7d\x30\x34\xe2\x5e\xcf\x5e\xfa\x0a\xf7\x32\x35\x1f\xa1\x75\xa7\x79\x90\xc2\xe3\x41\x51\x4c\x85\x0b\xde\x71\x7a\x6f\xfb\x92\x10\x1c\x75\x46\xc5\x02\xc9\x1d\x6d\x39\x1d\xdc\x96\x95\x2a\x1d\xb2\xdb\x6b\x1f\xd4\x2b\xa2\xc4\xf6\xd4\xeb\xa1\xc4\x57\x4f\x61\x53\xa9\x84\xaa\x55\x40\xb9\x32\xf6\xa5\x36\x46\x54\xc4\x23\xaf\xb2\x85\x00\xb7\x67\x56\xce\x1d\xdf\xbd\xec\xa1\xb5\x7c\x46\x81\x36\x9d\x04\xe2\x48\xeb\xdf\x31\xbf\x4a\x83\x36\x04\x4e\xf9\xca\x19\xc1\x6f\xbf\xb9\x23\x7a\xf4\x88\x2c\x84\x06\xd5\xb8\x5f\x67\x70\x50\xa7\xc7\x9c\xc3\xe8\x60\x86\xad\x81\x4c\xee\x31\x4f\x57\x49\xb3\xd6\xdf\x42\x50\x93\x30\xc4\x5f\xc8\xd9\xaa\x49\x7b\x51\xec\x25\xeb\xa6\xf4\xba\x90\x5b\x7d\xcc\x06\x09\x4b\xcf\xdd\x15\x9a\x01\xbc\xd8\x70\xa7\x93\xbb\x0d\x56\x80\x32\x3e\xcd\xe7\x1e\x70\x75\x85\x86\x41\xd7\x1f\x7f\x79\x70\xeb\x29\x80\x04\xb0\xd5\xc9\x8d\x94\x40\xa0\xce\xf7\x25\x5b\x9a\x55\xd1\x02\x31\x01\x9f\xe6\x57\xa3\x60\x55\xee\x1c\x40\x4a\x2f\x56\x51\x55\x12\x9d\x7a\xb4\x56\xfd\xeb\x56\x4e\xd8\x47\x40\x02\xdc\x74\x7d\xdd\x66\xe7\xb4\xa8\xa6\xde\x36\xed\x66\x6d\x57\x86\xed\x65\xd6\xa9\xa4\xe7\x9f\x55\x49\x8e\x6c\xe3\xca\x15\xe5\xf5\xd7\x58\x93\x26\xfc\x17\x96\x24\x3f\xa7\xe3\x79\xfa\xb4\x40\xad\x6e\xa3\x84\x86\x99\xe2\x2c\x5c\xae\xa3\xbe\x7b\x6b\x90\x35\xbd\x3a\x3b\x2a\xfe\xd7\x9b\x68\x4e\x8b\x63\xc1\x96\xb5\x3e\x95\xd9\x31\x80\xd7\xd1\xb9\x2a\xba\x87\x33\x5d\xd3\xb1\x3c\xef\xce\xa9\xf2\x7a\x50\x4a\x6b\xe0\x0b\xbb\xde\xc7\x52\xc0\xa4\xe6\xe3\x58\x7d\x1a\xbf\x4a\x94\xd1\xa0\x73\x2e\x4c\x49\xb5\xbd\x58\x8d\xd9\x9a\x45\x1b\xf5\x14\x1e\x3d\x2a\xcd\xea\xdb\x43\xd2\x9b\x4d\x02\xdc\x83\xea\xb5\xf1\xb1\x64\x4a\xe0\x5f\x6e\x0d\x8d\xce\x34\x67\xab\x32\x48\x98\x8d\x49\xde\x91\x58\x90\x5c\x56\x73\x4e\xf7\xc4\xce\x56\x2d\x0e\x50\xdb\x82\x8e\x45\x3f\x27\xfa\xa5\x02\x8d\x96\x65\xda\x6e\xc3\x7a\x9b\xda\xb5\x83\x57\xf8\x0c\x3d\x74\xe1\xe0\xbc\x1b\x3a\x17\xa9\xcb\xa7\x95\xeb\x7e\x75\x78\x48\x36\xb7\x2b\x02\x55\x95\x08\x73\xa9\x6e\x39\x98\x93\x36\xf6\xa9\x63\xc3\xea\xda\x76\xc7\x3f\x6b\x3f\x9d\xd6\xdb\xb5\x31\xa5\x4a\xbd\xf4\xea\x49\xca\xc3\x34\x8d\x91\x41\xc8\x9a\x82\x67\xe2\x73\xc4\xb6\x76\x11\xbf\x5d\x08\xf3\x10\x39\xf5\x38\x98\xfb\x31\x20\x51\x91\x2a\x71\x2c\xf8\x97\xec\xf0\x2e\x46\x21\x35\xda\xfb\x39\x74\xf7\x75\x9a\xfb\x8c\xf3\xe2\xbd\xab\x6f\xc7\x92\x4a\x9d\xbb\xd4\xb8\x27\xd5\xda\xf6\xdb\xca\xdd\xb3\x03\xe8\x55\xed\x89\x63\x30\x50\xb5\x29\x52\xb4\xe6\xc9\x0e\x0c\x0b\x34\xdb\x24\x42\xc7\xe3\x1c\x87\x13\x1d\x9d\xb2\x63\xf1\xa1\x50\xd6\x21\xde\x35\x4d\xb4\x29\xbc\xd7\x1e\xcb\xff\x15\x26\x2c\x56\xfb\x03\xb5\x4b\xaf\x72\x2f\x75\x9c\x1e\xee\xc6\x46\x09\xa6\xb4\xfd\x09\x4f\xa9\xd3\xba\x6f\x22\x51\x78\xac\x02\xe4\x08\xc6\xcd\xa9\xbc\xd3\xc9\x0b\xd2\x23\x7d\xb2\xb9\xdd\xf1\xc6\x38\xec\xe3\x69\x94\x8c\xbd\xa2\x2b\xe4\x85\xb5\x3a\x8d\xd6\x17\x9e\x28\xa8\xc2\x02\x83\x58\xe2\x25\xdf\x68\x04\x48\x69\x5f\xb5\xe5\x3d\x15\xec\x55\xb3\x9f\x2f\x73\x19\x6a\x88\xa3\x32\x97\xb1\x06\x08\xe3\xec\xb4\x46\xf3\xe6\x2e\xfd\xf4\xc7\x11\x90\x2f\x22\x06\x9f\x53\xd8\x3d\xbf\x48\x9b\xf4\xc9\xa7\x4a\x9b\x17\xb3\x8d\xab\x4f\x93\xb8\xdb\xdb\x7d\x88\x26\x2f\xc7\x70\x9a\x6a\x83\xe2\x3c\xf9\xc2\x16\x2f\x38\xbc\x87\x60\xf0\xf2\xe4\x77\x6d\xf0\xb2\x8e\xfc\x76\xcf\xe6\x04\x32\xa5\x74\x5d\xb3\x4f\x7c\xc0\xc6\xd0\x58\x08\xe2\x9d\xd1\x37\x90\x55\xa2\xc6\x34\x6d\x7b\xaf\x0a\xba\xa9\x13\x0b\xec\xb3\x06\xf9\x6a\x9a\xc6\xf6\xee\xb6\x0b\xd7\xd4\xb6\x3b\xf4\xdf\x65\x62\xba\x66\xbb\x8c\x85\xf3\xbf\x2d\xa9\xea\x87\x85\x5c\x68\xdc\x8a\xbd\x85\x17\xf4\x9d\x47\xef\xb6\xd6\x3c\x07\xf1\xde\x7f\x33\x16\xb4\x0c\x02\x32\xa5\x43\x9e\x45\xe8\xb8\x71\x74\x7c\x4c\x58\xfa\xab\x34\xd2\x86\x44\x23\x1b\xf7\x93\xed\xae\x29\x2d\x1d\x38\x65\xf5\x49\xb0\xdd\xeb\xfd\x8f\x93\x5a\x0e\xb9\x56\xd3\x48\xb0\x39\xe6\xff\xdd\x0c\x27\x13\x1a\x66\x61\x1a\xd1\x40\xe7\xf9\xc2\x54\x5d\x63\x7e\x49\xc9\xf7\x2c\xa3\x43\x7e\x4d\xa2\x69\x5e\xf0\x31\x8e\x52\xd7\xbf\x02\x07\xed\xda\x26\xbe\x67\xd7\xe4\xf8\xf8\x3d\x61\x79\x3e\x55\x95\x0c\xac\xd7\x5b\x4e\x0b\x23\x4f\xf9\x65\x44\x53\x02\x87\x23\x8c\x0a\x41\xd3\xfe\xdf\x94\x45\x17\xc9\x0d\x06\x95\x28\xe8\x75\x41\xa2\x30\x25\x34\x8d\xc9\x74\x42\x14\x3b\x6e\xf9\xf6\xfd\x08\x6b\x22\xbf\x08\xd8\xa0\x20\x03\xaa\x21\x09\x85\x4c\x44\xaa\xc2\x34\xa7\xd9\xb1\x5c\x1d\x37\xd5\x99\xf4\x92\xeb\x93\xa0\x67\x65\x95\xf3\x53\x6c\xa1\xbb\x1e\xd9\x99\x5c\x93\x5e\x69\x1f\x8c\x6f\xdc\xe6\xcc\x26\xda\xba\xf6\x98\xa5\xbf\x60\x03\x35\xf9\xe7\xc4\x2c\x8f\x39\x61\x05\x89\x39\xcd\xc5\xfc\x22\x9e\x24\xe1\x24\xa7\x6a\x56\x23\xd7\x07\x9f\x8e\xa5\x73\x5e\xab\xba\x45\xb2\x49\x76\xda\xfe\x30\xa2\x69\x96\x43\x62\x34\x48\x3b\x6e\x25\x46\x0c\x1e\xf5\x51\x1e\xdb\x77\xc5\x84\xc7\x23\x7e\x85\x6e\x9b\xac\x08\x72\x92\xf2\x82\x84\x29\xee\x18\xe4\x24\xd2\xb0\x0d\xf9\x0c\x75\xa2\x26\x48\xd9\x03\xde\x8b\xd9\xf9\x20\x14\x2f\x7e\xf9\xff\xdd\xde\x5e\x1b\xbc\x18\xa1\x7c\x67\x6f\xaf\x43\xcc\xff\xe0\x57\x2b\x59\x1d\x9c\xc4\xf7\x61\xcc\xc4\xb3\xab\x67\xf2\xd0\x1d\x8d\x32\x48\xd2\x66\xe1\xb4\x7e\xce\x97\x4f\x00\xba\x65\x61\x63\x66\x11\xe0\x0c\xc1\x27\xf1\x52\x70\x56\x23\xaa\xc8\x29\x67\x46\x25\x96\xe4\x78\x14\xc6\xfc\x0a\x90\x4b\xfc\xdf\xff\xea\xf5\x7a\x41\xfd\x40\xde\xbc\xde\xde\x26\x61\x96\xf1\x2b\xd3\x7d\x7f\x73\x9c\x6f\xd2\xeb\x49\x98\xba\xb9\xed\x4c\x3a\x4c\x93\x94\xb2\x94\xc0\x4e\x20\xbc\x78\x6f\x98\x8a\x0a\x67\xc1\x28\xdf\x9c\xe1\x70\x18\x66\x0c\x46\xac\x82\x31\x6c\x98\x49\xa8\xa2\x3e\x09\x68\x92\xb0\x49\xce\x72\x73\x06\x46\xac\xa0\xc7\x93\x50\x9e\xf6\xab\x2c\x9c\xe8\x6f\xdc\xd4\x1b\x41\x72\x78\xfd\x25\x61\x29\xfd\xc7\x1d\x90\xd7\x9e\x65\x39\xbd\xa4\x46\x69\xf5\x66\xb0\xc1\x59\x64\xa7\xf2\xb3\xc8\xac\xca\xc3\xa7\x07\x99\xe1\xf8\x7a\x3a\x1b\x28\x9f\xf4\xc9\x13\x7d\x6e\x6a\xd3\x22\xea\x34\x12\xfa\x24\xc9\xa3\xb5\x09\x7a\xb3\x5c\x93\x50\xb1\xfa\xaf\x38\x10\xae\x84\x47\x17\x64\x02\x50\xa8\x5d\xcb\x09\xc7\x08\x1f\x92\xc0\x09\x56\x1a\x53\xae\x89\x09\x74\x8d\x88\x60\x65\x29\xff\xd0\xb9\x42\xfb\x56\x2b\x97\xea\x89\xf2\xf3\x66\x49\x42\x04\xd6\x8c\x43\x88\x90\x92\xdc\x20\xb9\x2d\x48\x18\x45\x3c\x8b\x65\xb6\x37\x18\x21\x88\xc5\x59\x0a\x81\x46\x8a\x11\x9a\x83\x81\x17\xa5\x14\x6a\x5d\xb1\x5c\x40\x99\x84\x82\x05\x49\x68\x98\x17\xe5\xde\xe5\xec\x81\xb0\x58\x61\x2c\xa7\x05\x97\xb4\x73\xa1\x8c\x83\x7c\x02\x17\xb1\xf4\x34\x46\x0f\x4c\x3e\x99\x26\x61\x41\xed\xde\x04\x43\x29\xf3\xd9\x1d\x85\x29\x4c\x53\x50\x11\x63\x4b\x88\x8e\xa1\x67\x29\x5c\x41\x67\x84\xe5\xe8\x01\x03\x09\xcf\xce\xb0\x93\x0a\x18\xb1\xc0\x0d\x46\x88\x7f\x7d\x4f\xc3\xf8\x5d\x9a\xdc\x48\x86\x67\xf1\x68\x9c\x6e\x0b\xed\x2e\xcb\x25\xdb\x19\x37\xc6\xe6\xb4\xe0\xbe\x64\x50\x4a\x2f\xae\x94\xbe\xc8\x05\x36\x89\xe5\x93\x04\x4f\x5c\xed\x97\x82\x77\x18\x12\x56\xe4\xf8\x06\x85\x70\x6c\xe3\x49\x71\x23\x77\xed\xdf\x7c\x0a\xdc\x03\x4f\x93\x1b\xc8\x3f\x28\x70\x4d\x85\xd8\xd2\x5b\xa2\x03\x44\xb1\x9c\x9c\xc1\x06\x9e\x91\x96\x12\x33\x3b\xf9\xe9\x44\xbf\xaf\x45\xfb\x0b\xe0\xdb\xcb\x94\x9c\x01\xd3\xab\xe3\x4c\x1d\xc0\x3d\x0e\x17\xe6\x28\xbc\xa4\x32\xb0\x57\x48\xc6\x61\x41\x33\x16\x26\x9b\x53\x06\x31\x82\xd8\x90\x45\xaa\xae\x19\x06\x1c\x81\x25\x13\x23\xde\x35\x29\xe2\x6a\x13\x22\xb6\x17\x8e\xd8\xe5\xae\xa3\x59\x13\x28\x5f\x26\x5a\x97\x87\x6b\x26\xea\x9a\xc9\xa7\x28\xe8\x59\x48\x10\x57\xc8\x19\x62\x63\xc5\x10\x10\x60\xb1\xac\x85\x48\x69\xcf\x00\x75\xcf\xc8\x78\x9a\x03\xe7\x1a\xa6\xe2\xea\x0f\x6f\x80\x8a\xe8\xc8\x6a\x30\xa0\x7c\x3a\x81\xd7\xc8\x78\x9a\x14\x6c\x92\xa8\xc3\x01\xf9\x7f\xef\x01\xe3\x55\x37\x0b\xcc\x6a\x46\x44\xd9\x9a\x68\xb2\x8b\x87\x77\x7b\x4f\xf5\x3d\xa8\x09\x04\xac\xe3\x7d\xac\x03\xaa\x07\xff\x85\x52\xae\xb9\x6d\xa0\xc5\x45\x83\xc9\x39\x65\xa6\xb2\x4c\x11\xe1\xa1\x4c\x7c\x9a\x16\x19\x4f\x12\x1a\x57\xe5\x40\xbd\x6c\xec\xcd\x0a\xe0\x76\x5f\xb7\x46\x73\x18\xe7\x19\x62\xf4\xe6\x20\x6f\x2a\x6e\x9b\x7e\x11\xe3\x8b\xac\x35\x31\xe1\x1b\x04\x1f\xa3\x6f\x77\xd4\x5a\x4c\xf2\xae\x2e\xd1\xcc\x97\x51\xb5\x56\x6b\x5a\x4d\x00\x82\xca\xf8\x03\x36\x4d\xd7\x30\x76\xa1\x02\x64\x52\x90\x84\x10\xf0\x4b\x7d\xb2\x89\x8f\x86\xb0\x0b\x15\xa0\xa4\x21\x0a\x04\x7f\xea\x57\xa0\x3a\xd2\xea\xb3\x2a\x50\x00\xfa\x9c\x68\x08\x5d\xa2\x19\x55\x83\xa7\x1a\xc8\x2a\xd3\xec\xf8\x62\x7a\x60\xad\x06\xd6\xab\xdf\x90\xc8\xd0\x5e\x3b\xf1\x1b\x56\x4a\xfc\x61\x2f\x88\xf8\x9d\x4a\x51\x06\x09\xd4\x44\x55\x4c\x02\x1d\x76\xc0\x1a\xba\xca\x9d\xb7\xb5\x45\xde\xa4\x79\x41\xc3\x58\x30\x86\x67\xf2\x22\xf9\x46\x9e\x01\xe8\xe3\xdb\x33\x41\x71\xe0\x62\x85\x60\x79\xc3\x84\x5e\xb3\x01\x4b\x98\xe0\x0a\x36\xc8\xdc\xfa\x2f\x74\x49\x96\xf2\x53\xcf\x5a\xa4\x21\x3b\x20\xa2\x06\x39\xc1\x09\x07\x1f\xdb\xe2\xef\xb7\xea\x66\xff\xf9\x4d\x9f\xdc\xf0\x29\x0e\x6f\x92\xf1\x4b\x16\xd3\x58\x50\x7c\x96\x5e\x86\x09\x93\x34\x4c\x93\x4c\x86\xf7\x9d\x22\x53\x5d\xb1\x2a\xbf\x50\x19\x61\x49\x54\x53\xd1\xdf\xd5\x31\x56\xec\xb2\xba\x29\x0d\x61\x09\x3e\x76\x7f\xe5\x2c\x6d\x05\xff\x49\x83\xb6\x38\xdc\x90\xa6\xbc\x07\xab\x3a\x8f\x9e\x56\xce\xab\x51\x17\xbf\xb5\x45\xde\xf2\x5c\x27\xf2\x96\x41\x9c\x72\x02\xb1\x05\x45\x2b\x10\x32\x85\x9c\x59\xd2\x60\x64\x6c\x44\x4d\x41\x2e\xe5\x17\x6b\xdc\x90\xbe\x57\x45\x27\x7c\xf9\xd3\x1b\x22\x1e\x96\x13\x41\xf9\x39\x48\xd8\x72\xe4\xc9\x8b\x91\xb8\xa6\x07\xe2\xed\x05\x9f\x04\x0e\x1a\xf6\x1d\x4f\xef\x91\x49\xd7\xe5\x88\xad\x5d\x83\x03\xcd\xb1\xda\x08\xbb\x61\xf4\xf0\x4a\x55\x0d\x4d\xce\x8e\xb5\x80\x74\xe3\x85\x7c\xb8\x58\xd4\x03\x8f\x72\x1f\x52\x38\x6a\xe7\x0d\xf3\x9c\xa9\xa5\x74\x7d\x52\x43\xe2\x74\xbc\x85\x2a\xda\xd6\x27\x55\x44\x4d\xf1\x2c\xd5\x94\xa8\x4f\x6a\x49\x50\x9f\x34\xd1\x9e\xbe\xfd\x03\x1f\xa8\x6d\x88\xeb\xd9\x3e\xd8\xb8\xdd\xd8\xc0\xb5\xaf\x0a\x22\x60\xcd\xdf\x4e\x97\x66\xcd\x42\x17\x4b\x2e\xb8\xd9\xb2\xe4\xd4\xdb\x60\xb0\x56\x00\x7d\xb0\x9a\xb9\x6e\xcf\x4c\xda\x64\x5f\x93\x03\x1d\x4f\x99\x34\xd3\x09\xb0\x24\x58\x41\x4e\x34\xd9\x12\xb9\x6d\xb7\xa4\xd6\xf1\x7e\xd4\xc0\x7b\x6b\x45\xe2\x1f\x44\x91\xe8\xae\x62\xdd\x18\x9e\xd5\xc0\x37\x75\xed\xb5\x6c\x69\xb9\x86\xf5\x99\x57\x20\xa6\xcb\x3d\xaa\x38\x4d\x32\xdc\x3a\x47\xe2\x0a\xd0\x46\x6f\x65\x0d\xf5\x79\xd3\x0c\x89\x85\xaa\x43\x98\x27\x2e\x58\x63\x86\x21\x01\xa0\xc1\x3f\xdc\x4c\xf8\x79\x16\x4e\x46\x75\x0a\xb1\x27\xbd\x0a\xd8\xa6\xf6\x0d\xd4\x43\xd3\x5b\x7e\x36\xe7\xe4\xe5\xf5\x77\x88\xe0\x9c\xa3\x5b\x28\x04\xe9\x04\xcd\xc6\x1c\xea\x8e\x38\xcc\x2e\x40\xbf\x81\x45\x07\xb2\xbe\xd1\x99\x1c\xf1\x84\x67\xa5\xa6\xf2\x51\x18\xd3\x1c\x1e\x7f\x1f\xbb\x06\xd8\x98\xae\x54\x6b\x15\x5b\x30\x4a\xcb\x55\x52\x4a\xa4\x5f\x83\xa8\xb9\x2f\xf8\x75\x56\xb0\x30\x09\x1a\xa5\xdb\x32\xcc\x56\x16\xe6\xc5\x07\x7a\x5d\xb4\xbc\xc1\x6a\x53\x45\xaf\xbc\xef\x17\x78\x9c\x4a\x9f\x04\x82\x59\xd7\x7d\x87\x09\x3b\x4f\xdf\x14\x74\x2c\x06\x16\x51\x47\x29\x25\x00\x7f\xc9\xc2\x49\x9f\x04\x8e\xaa\xc1\x68\xf1\x9e\x4e\xae\xeb\x95\x70\xbb\x32\xec\xa6\x54\x08\xcc\xca\xe5\x8c\xc9\xb7\xb1\x25\x70\x57\x81\x65\xcb\xbb\xd3\x49\x2b\x18\xc7\x41\xdb\xb0\x70\x46\x99\xb7\xb3\xbf\xaf\x39\xaa\xf0\x5a\x16\xee\x3d\xd5\x85\xae\xae\x6a\x47\xf2\x49\x4b\x0f\x25\xe6\x57\xa9\x3f\x18\xb1\x48\x7f\xcf\xf8\x55\x9f\x6c\xeb\xe6\xa1\x01\xb9\x43\x63\x9a\xe7\xe1\x39\xb5\xb4\x20\x6a\xf5\x2a\x16\x0d\x15\x9f\x3d\x47\x87\x12\x46\xa8\x33\xf9\xb4\xfc\x46\x8e\xc3\xec\x9c\xa5\x3f\xd0\x61\xa1\x95\x51\xee\x60\xf0\x53\xf5\x2e\xba\x8d\xbc\x47\x3d\xcd\x66\x19\x76\xd5\x5a\x12\xf1\x56\xc1\xb9\xcb\x08\xe9\x62\xd6\x96\x5a\x42\x2e\xcb\xef\xda\x68\xf2\xcb\x29\x00\x56\x13\xc3\x00\xc2\xeb\x23\x82\x57\x6e\x92\x46\xfe\xcf\xbc\x4b\xb6\x36\x66\xe9\x8a\xfd\x2f\x85\x17\xd6\x20\x7c\x19\x5e\x1a\x46\x17\x83\x30\x93\x01\x18\x4b\xc2\x3c\x19\xcf\x50\x49\xf2\x30\xb3\xfe\x7c\x52\x3a\xdb\x55\xa2\xc6\x53\x42\xed\xb4\x96\x9e\xe1\xef\x3b\x8b\xbc\x70\x87\x5d\x19\x97\xe3\x02\x21\x3b\xd2\x6e\x0f\xf3\xbb\x3c\x48\x9e\xcf\x15\x3f\xcc\xf0\x75\xb0\x52\x8e\xdb\x7c\x9d\xef\x33\x31\xa2\x61\x9c\xb0\x94\xbe\x0d\x27\x13\xa0\xe7\x9f\x2c\x13\x89\xf8\x66\xbb\x8f\xc9\xe7\x7d\x03\x04\xe9\x45\x11\x26\x34\x2b\x62\x16\x26\xfc\x5c\x13\xe3\xfc\xff\x4d\xc3\xcc\xb2\xb1\x15\xff\xd1\x84\x5e\xca\xd8\x7e\x4f\x4b\x5b\xd5\xb7\x62\x63\x20\x6f\x6e\x66\xa3\x02\x43\xe2\x5d\xa6\xab\xb4\xd5\x6d\x6c\x3b\x3c\xcc\xe5\x3b\xe2\xa4\xd2\xaf\x4c\xa3\xaf\xf0\xe3\xd6\x43\x18\xf8\xd5\xb6\x6f\x33\xf2\x62\x55\x7d\xca\xf6\x74\x97\xf8\x1b\x7b\x24\x7d\x10\x46\x6c\x80\x99\xff\xed\xc6\x86\x77\x7a\x96\xb2\xd8\x57\x31\x38\x3e\xcd\x4d\x77\x1d\x8d\xef\x1f\xe2\xde\xda\x98\x83\x99\xa3\x43\xe7\x3c\x37\xae\xd0\x1c\x0c\x99\x69\x4e\xd2\x84\xc6\x4b\x6a\xde\x06\x15\x5d\xe9\xac\xef\xa7\x25\xef\x27\x60\x76\xe9\xb0\x5d\xeb\x80\xb1\xa0\xc4\xce\x3d\xa1\x28\xba\x73\xcb\xee\x49\x86\xf7\x74\x2d\xc3\x5b\x5e\x86\xf7\xf9\xc5\x66\x0f\x4a\x6a\x88\x71\xac\xd6\x62\xba\x06\x31\xdd\x9f\x57\xd6\xf5\x30\x1d\x07\x16\x19\xda\xbb\x8c\xd1\x54\xe6\xa3\xa9\x39\xd9\xcf\xe7\x1e\x9f\xdd\xd8\xbd\x89\x0a\xab\x4c\xfd\x25\x87\x68\x27\x98\xfb\x34\x9f\x10\xc4\x93\x95\x48\x09\x48\x3d\x5c\xf0\xa8\x0f\x51\x1c\x36\x41\x89\xe8\xd8\x11\x3b\x3d\xf5\xfc\xa7\x41\xf0\xa8\x9f\x84\x4d\xf5\x64\xd7\xba\xa2\x23\x26\x4a\x0a\x9a\xa1\xca\xed\x07\xb1\x15\x7d\x47\x42\xd5\x27\xda\x6d\xb7\xc9\xd9\xc1\x16\x14\xf5\x56\x2d\xd0\x39\xa6\x45\x2e\x85\x1a\x74\x42\xc2\x9c\x60\xb0\x88\x2e\x79\x93\x93\x89\x60\x14\x51\xc0\x21\x26\x5f\x29\xe6\x40\xf0\x25\xb3\x5c\x8a\xde\xd1\x05\x22\x45\x73\xda\x1b\x72\x5c\x50\xd0\x72\x83\xc9\x12\x98\xd7\xe7\x53\x29\x68\x81\xec\x7c\x62\xa8\xfe\xaa\x1a\x33\x01\x33\xac\xd2\xc2\xcf\x3d\xc0\x63\x9d\x79\xf0\x4c\x0c\xe6\x8c\xe4\xd3\xc1\xa6\x99\x3a\xc9\xa7\xd1\x48\x2c\x14\x7c\x85\xc6\xcf\x3a\xf8\x43\x32\x43\x67\x7f\xbe\x38\x9b\x5f\x44\xce\xf5\x36\xcc\x2e\x1c\xd4\x15\x9b\x94\xd0\x82\xc6\x73\x63\xaf\xae\xb1\x2c\x02\xff\x84\x9d\xc4\xfc\x2a\x25\xc3\x8c\x8f\x35\xfe\xb2\x61\x19\x4d\x59\x4e\xc2\x24\xe7\x24\xa7\x85\x3d\x84\x34\xa5\x51\xc1\x17\x4e\xf6\xfe\x7b\xb0\x6c\x2d\x6d\x91\x72\x55\xe8\x48\x6b\x7a\xb1\x1c\xb2\x0c\xe0\x06\xd3\xa2\xe0\x29\x61\x43\xac\x0f\xc7\xea\x3b\x28\x3b\x43\x83\x18\xdc\x4b\x3e\x94\x87\x73\xee\x9d\x36\x3e\x12\xcb\x6d\xf4\xcf\x39\x66\x3d\x52\xa4\x6a\xc8\x33\x82\x36\x7d\x4e\x06\x6c\x86\xc1\x1b\x66\xa4\x84\x6d\x3a\x0b\xe2\xb2\x59\x60\x90\xaf\x80\x17\x87\x20\x1a\x7a\x91\xd1\xfe\x3e\x4c\xec\x4c\xc4\x58\x72\x87\x6c\xc4\xdc\xf0\x08\x8b\x62\xaa\xc3\xab\x2c\x89\xad\x76\x1b\xab\xc1\x58\xab\xc5\x92\x55\x66\x41\x27\x55\x62\x5c\xcb\x86\x11\x7f\x1a\x3d\x8f\x77\xd4\x35\x98\xf7\x61\x55\xe6\x9b\x9a\x62\x8a\x89\xd5\x0b\x87\x35\x7d\x33\x20\xaa\xc4\x80\x48\xfa\x63\x81\xc8\x12\x4b\x4b\x09\x67\xc7\xb6\x13\xc5\x53\x2c\x01\x64\xac\x12\x6d\x23\x1a\xd3\x6b\xed\xe7\x14\xe6\xc6\x7a\x54\xfc\xd0\x82\x69\x87\x81\x95\xc1\x7b\x4c\x99\x06\x93\x98\x6b\x60\x64\xc1\x2a\x04\xdc\x68\x86\xe9\xef\x51\x83\x91\xa7\x23\x00\xd7\x4b\x89\x3f\xe4\xa2\x49\x5b\x50\x58\x1f\xb4\x03\x85\x00\x60\x24\x10\x93\x87\x80\x41\x66\x92\xf0\x53\xce\x47\xcb\xd1\x21\x10\x96\x25\xf7\x5f\x48\x9a\x4c\xf3\x13\xab\xfd\x8f\xb3\x44\x6e\x9f\x6e\x3b\x46\x68\xeb\xa3\x6a\x09\xab\xdb\x1d\x17\xef\xda\x8d\x36\x94\x65\xd1\xb1\x25\x38\xae\x93\xf6\x57\x86\x17\x9a\x25\x19\x9f\x2f\x0c\x90\x89\x74\xb3\x40\x74\x9e\x99\x11\x98\x14\xff\xeb\xd2\x83\x2a\x06\xb4\x8e\x14\x38\x5c\x48\xe9\x78\xda\x37\x97\x7f\xec\x94\x2b\x1f\x1e\xbf\xc7\xc4\x0a\x02\x84\xb7\x88\x7d\xde\x3c\x0a\x5e\x71\xd4\xec\x6b\x42\xfd\xa5\x5f\x43\x76\x34\x21\x15\x97\x4c\xe5\x5d\x32\x24\xe4\xd1\xa3\x32\x29\x7c\xf4\x88\x7c\x05\x54\xe0\xd1\xa3\x19\x4b\xae\xe9\x0e\xf9\x54\x3f\xd8\x39\x56\x16\xad\x2e\xa5\x7a\xa1\xa0\x93\x3b\xeb\x14\xe6\x78\xe4\x78\x0a\x85\xf9\x18\x4b\xbf\xd2\x32\xaa\x8b\xb9\x18\x1b\xaf\xce\x5c\xec\x80\xa3\xf0\x9c\x53\x76\xaf\x89\x6a\x43\xbb\xf3\xea\x01\x2a\xc8\xf2\x0a\x5a\xb5\x08\xfb\xef\xf8\x49\xb6\x90\x72\xe6\x01\xeb\x7a\xec\x2b\x74\x15\x9b\x6b\x5d\xc2\x7f\x84\xc7\xd4\xbc\xf3\xb6\xf8\x8d\x15\xac\xa2\xe2\x58\x1a\x1f\x31\xf3\x36\x26\xb9\x9e\x15\x0c\x4b\x33\x4a\xab\x69\xcd\xe1\xc2\xfe\x68\xef\x19\x4f\x03\x08\x97\x60\x95\xdb\x41\xe4\x39\x03\x58\xd7\x96\xed\x87\x20\x2f\x18\x5d\x64\xee\x0f\xe3\x33\xb0\xb8\x96\xb1\xdd\x12\xe3\xba\x27\xd5\xe1\xb3\xb5\xea\x70\xad\x3a\x5c\xab\x0e\xef\xd5\xc2\xff\xbe\x6d\xf1\x31\xce\x5a\x41\x27\x6f\xa2\x5a\x2d\xd7\xd3\x9d\xed\x12\x68\x63\x3c\x36\x09\xb3\xd6\x7f\x3e\x74\x25\xe3\x9c\xcd\x36\xe0\xc6\xf6\xee\xce\xdc\xa3\x83\x66\x3e\xab\xee\x73\x71\xcb\x71\x5b\xb3\xe8\xa8\x4c\x65\xd9\xa5\x20\x64\x91\x5d\xa2\x2e\x78\xad\x75\xe4\x69\xf1\x8b\x8c\x3a\xb4\xd7\xeb\xd9\x0d\x5a\x57\xff\x1c\xd0\x4b\x84\x1c\x3a\xc2\xe4\x37\x34\x33\xc3\x73\x8a\x7f\xe4\x2f\xcd\x8b\xaf\xa4\x07\xae\x55\xf0\x36\xa9\x5b\xdf\x3b\x2b\x2d\xd6\xf7\x95\xca\x2f\x0e\x99\x26\x92\xe9\x38\x0d\xe6\xd3\xd7\x16\xf4\xba\x78\x29\xf6\xa4\xce\x90\xff\x03\x9f\xd4\xc5\x31\x5b\xb5\xce\xd6\x57\xa1\xae\x15\xb8\x6e\x7c\x91\x94\x8c\x79\x5e\x90\x28\xcc\x69\x2e\xc3\x87\xb0\xf1\x04\xc3\x35\x85\x04\x5f\xa8\x44\xe6\x62\xc2\x20\x27\x05\x2b\x12\x0a\x3a\x1d\x70\xdf\x16\x1d\x3e\x00\x25\xee\x1f\xc6\x20\xd1\xdd\x9f\x23\x2b\xcc\x62\x0e\x8b\x5e\x11\x05\xe4\xcb\xa9\x95\x1d\xfc\xfe\x42\x3a\xe6\x95\xe8\x4d\xe1\xdc\x34\x28\x4f\xd1\x76\xe1\x3e\x35\xa8\x1f\x64\xb0\x36\x2b\x72\xd5\xe0\xc6\xcc\x0b\xce\x19\xd9\x24\x6c\x08\x21\xa1\x72\x6a\xa2\x0f\x89\xbf\x25\x31\xa9\xc2\x0e\x94\x7b\x2f\x76\x1c\x91\x51\x58\xf2\x38\x42\xe5\xd5\x1c\x0e\xe0\x3e\x57\xaa\x03\x2e\xa9\x6a\xd7\xda\xde\x45\xb5\xbd\x70\x16\x7c\x95\xef\xa9\x26\x20\x79\xc7\xfe\xb1\xa3\x9d\x5d\x1b\x95\xc2\x0f\x47\xc7\x3b\x5b\x81\x1b\x59\x5a\x58\xf1\x63\x41\x2d\xed\xc2\xfa\xef\x7a\xb5\xf0\xfd\xeb\x7b\x17\xd6\xed\x3a\xea\xdc\x48\xaa\x6d\x5d\x2d\x6e\x95\x0e\x59\x2b\x7c\xef\x59\xc3\x6b\x61\xa6\xe0\x14\x67\xeb\x6a\x6c\xb4\x56\x3d\x98\x0b\x46\xfd\x35\x5b\x92\x5a\xd5\x8e\xc1\x3d\x83\x98\xcb\xb5\x54\xc5\xcc\x57\xea\xa4\x17\x68\x3b\x70\xce\x54\xe0\xeb\xb3\x9d\x53\x8e\x5a\x4e\xc8\xc5\x25\x3a\x3a\x9a\x6b\xc3\xec\xee\x76\x16\xdd\x8d\x9d\x05\x95\xf1\xcb\x34\x7c\xd7\xfd\xb1\xc7\x88\xd4\x4e\x12\x41\x77\xf1\x76\xda\x5f\xca\x38\x00\x48\x59\x95\xaa\x79\xb6\x2b\x9b\x51\xc8\x2f\xe2\xcb\xe7\x3c\x62\x17\x31\xb8\xa8\x7f\xfd\x76\xc8\x57\xa5\xed\x6e\x6b\x55\xbc\xfc\x63\x46\x04\x20\x2d\x0c\x33\x41\x80\x3e\xcd\x69\x71\x50\x67\xd3\x20\xad\x0d\x22\xdb\x64\x60\xb6\x36\x5e\x8d\x1b\x27\xb0\xb4\x73\x63\x3a\x4d\x92\xf9\xa6\xae\xc7\xd6\xe4\x28\x4a\xc8\x27\xe0\x6b\xfa\x24\x00\xc7\x50\x9b\x16\xf4\xfd\x13\x6f\x25\xc0\x52\x97\x87\x2c\x68\x97\xee\xad\x79\x51\x6f\xee\xe1\x45\xe1\x44\xde\x32\x15\x9e\x96\xba\x5b\x6b\x88\xc1\x3b\x75\xe1\xa8\x41\x6e\xa8\xff\x35\x36\x11\xb0\x35\x5f\xc0\x30\x62\xa1\x77\xfd\x2a\xec\x23\x96\xb2\xc4\x58\xc6\xa8\xe2\x8b\xbc\x49\x96\x12\x11\xf8\x15\xe7\x16\x11\xac\xfa\x15\xe4\xad\xe0\xcc\x67\x8f\x6f\xc6\xf2\x60\x1e\x29\x4b\x6d\x43\x4d\xfd\xb9\x77\xe3\x7e\x1f\x49\x6b\xf3\x9f\xb5\x30\xaf\xce\xbb\x78\x6d\x7b\x74\xef\x36\x38\xd1\x12\x76\x29\x0f\x4a\xc2\xb5\x36\x10\x7a\xc8\x22\xb0\x0a\x03\x21\xe4\x08\xe7\xb1\x12\x2a\xf3\x70\x8b\x1a\x10\xe1\x4d\x5f\x67\x4f\x54\xba\xdb\x03\xa3\xed\x0c\x30\x40\xa9\x1e\xaf\x1d\xa3\x54\x15\x2e\x17\xa6\x14\xcd\x91\xf0\xb1\x75\x3f\x36\x49\xfb\x0f\x2b\x33\xe5\x6c\x23\xa3\xcf\x6f\x07\xf4\xe7\x89\x6a\x7a\x4e\x45\x71\xc1\xc5\xd1\x7c\x37\xac\x19\xc2\x7e\x0d\x78\x93\x85\x8b\x0b\xe9\x5a\x12\x1d\x85\x49\x72\x34\xa2\xd1\x45\xdd\x9c\x9f\xd7\xc0\x37\x4d\xd5\x6b\xd9\xb4\x00\xcf\x5e\x78\x45\xd7\x75\xb7\xdd\xab\x82\x6e\xec\xcc\x6a\x54\xd7\x9d\xf0\x3c\x67\x83\x84\x1e\xf1\x34\x2f\xb2\x69\x54\xf0\xec\x3d\x08\x9e\x6a\xfb\xdd\x9e\x5d\xb7\x69\x14\xf5\x1d\xea\x76\x65\xe8\xd8\xfa\xa9\x97\x41\x9b\x7a\xd4\xcd\xdd\x6f\x7e\xcd\xcf\x61\x9a\xf6\x21\x0b\x53\xf4\x76\xaf\x23\x28\x4f\x2b\x60\x1b\xcd\xc6\x34\xd4\x67\xb5\x7f\x2b\x74\xb7\xb5\x9d\x3c\xf9\x3c\x39\x74\xab\x43\x15\x9b\x65\x59\x26\xea\xc5\x07\x0c\xe4\xba\x92\xc8\x17\xd0\xd6\x0a\x8d\xbe\x1e\xa4\xb5\x9c\x59\x6e\x41\x0c\x07\x61\x74\x51\x77\x86\x7a\x73\x8f\xb1\xa2\xcd\xcf\x63\xa4\x16\x59\xd6\x5a\x52\x8c\xa8\x72\x2d\xea\x74\x70\xf5\xd9\xed\xcc\xc9\x50\x36\x51\xd6\x59\x91\xf2\xd0\x56\x80\x0d\x06\x6d\xdb\x02\x0b\x4c\xab\x6c\xbb\x32\x9d\xe1\x11\x42\xa4\xda\xa0\x32\x21\x82\x01\xdd\xda\x22\xff\x10\x2b\x54\x70\x72\x4e\x0b\xa3\x7f\x05\xbb\xa3\x90\xa4\xf4\x1c\xf3\x90\xa0\xc1\x96\x00\x4b\x79\x01\x2c\x27\x1b\xa2\x59\x02\x76\x06\x5c\xec\x54\x4a\x66\xaa\xcd\xf4\x2a\xc6\xf1\x26\x75\x56\xab\x22\x45\xe9\x52\x16\x60\x06\x03\x5e\x4d\xb3\x26\x53\x4c\x37\x39\x4e\xb3\x07\x7a\xf3\x7b\x02\xd3\x8b\x17\xb4\x3e\x15\xbc\x72\x64\x27\x84\x5e\xb3\x7a\x99\x1d\x82\x6d\x40\xf4\xdd\x86\x11\xb7\x30\xc3\x4a\xf0\xb1\xfd\xb1\xbd\x62\xf3\x38\x30\x25\x83\x74\xac\x0b\x9a\xad\x44\x18\xcb\x83\xa4\x82\x48\x60\x9e\x32\x95\x7b\x34\x5e\x9b\x86\xdd\x97\x69\xd8\x83\x09\xb7\x2b\xb7\xf3\x18\x6d\x05\x97\xc8\x29\x85\x35\x67\xe4\x92\xaa\xc0\x3a\x75\x77\x4f\x73\x99\x2e\x4b\xac\x00\x84\x2e\x17\x98\x28\x73\x7c\xbd\x86\xcc\xbe\xc6\x96\xb1\xe0\x90\xe9\x2b\x24\xaf\xde\xbd\xd5\x99\x71\x64\xaa\x2d\xc7\x76\x0a\x3a\x51\x4f\x62\x9d\x38\x30\x24\x67\x68\x3f\x76\xe6\x5a\xad\xc9\x78\xab\x4b\x79\xd2\x7d\xd0\x11\xdf\x97\xf7\xa6\x83\x36\x56\xea\x51\x27\x4a\xdb\xe5\x65\x97\x64\x5f\x66\xef\xd1\x57\x1f\xda\xb0\x56\x1d\x7b\x55\xa4\x32\xb8\x2e\x60\x5e\xd8\x9c\x78\xcf\x5c\x93\x84\xa5\x76\x58\x91\xf9\xf5\x22\x8d\x66\x5d\xe9\x6b\xa4\xeb\x8b\xed\x69\x15\x67\xb3\xe4\xd6\x56\x34\xb5\x9a\x1d\x2e\x37\x3c\xc3\xc8\x4e\xae\x05\x46\x7d\x5f\x2f\x87\x5c\x0e\xc1\x7a\xad\x57\x43\xac\x06\x30\x36\xeb\xa5\x90\x4b\xb1\x3e\x26\xb8\x1a\xc0\x8c\xdc\x89\xcb\x80\xf7\xd0\x42\x2d\xc0\xa5\xad\x98\x7f\xc5\x13\x98\x9b\xa2\x43\x58\x4a\xc6\x2c\x49\x18\xe6\xdd\xb6\x33\xa2\x8e\xc3\x1b\x99\x51\xf7\x06\xb2\xc9\xa5\xe7\x09\x25\x05\x1b\x53\x3e\x2d\x30\x1b\xa7\x73\xe9\xe4\x1d\xc1\x36\xb0\x34\x66\x97\x2c\x9e\x82\x4b\x07\x3e\x9e\x40\x2c\x41\x23\xc9\x46\x18\xdf\x8f\x82\xcb\x87\x99\xf8\xcb\xcd\x8d\x1d\x85\x49\x24\x13\x4b\x9b\x4b\x4d\x74\x4d\x06\xa1\x60\x6e\x78\x2a\xef\x5d\x73\xcd\xc9\x81\xcd\x93\xfc\xf3\xae\xef\x9b\xf9\x5f\x38\xf3\xbd\x71\x64\x8e\x91\x39\x5f\x39\xfa\x11\x78\x24\x39\x09\xfb\x65\xde\x3a\x05\x6c\xfd\xab\x16\xe4\xe0\xf3\x1c\xf4\x17\x5a\x54\x68\xb4\x17\xaa\x89\x0e\x29\xd5\x03\x13\x3c\xdd\xae\x02\x6c\xa9\x48\x38\x96\xb3\xab\xfe\x59\xd0\xf1\xa4\x43\x4e\x8b\x11\xcb\x41\x45\x54\xc8\x8f\xc6\x0e\xce\xc8\x84\xcd\x18\x10\x5c\x75\xd0\x96\x75\x04\x7e\xb5\xa0\xd5\x04\xac\xa0\xc3\xec\x7c\x0a\x69\xc7\xbb\x09\x4d\xcf\x8b\x51\x47\x94\x88\xe7\x1b\xe4\x5d\x6d\x09\x28\xb1\x86\x17\xf4\x86\x1c\x92\xde\x01\xfe\xf5\x0d\xd4\xc6\x1f\x8f\x1f\x9b\x20\x3e\xa2\xea\x89\x28\xfc\x68\xb7\x8c\x25\x32\x3c\x0d\x8e\xc2\x98\x20\x82\x16\x08\x66\x88\x7f\x8c\x58\xae\xf4\x42\xf5\x52\x60\x7f\x92\xca\xfc\x49\x4d\xb6\x7b\x2a\xa8\x49\xc1\x4f\x4f\xc9\x6f\xbf\x61\x63\x9e\xac\xbe\xbc\x55\xed\x36\xa8\x90\xba\xe2\x4d\x73\x23\x15\x8e\x27\xa2\xf9\x8f\xdd\x88\xa7\x51\x58\xb4\xc4\xec\xda\xa0\xa5\x13\xc5\xea\xdf\xae\xca\x01\x79\x88\xe6\x70\xb2\x54\xa0\x55\xa5\x98\x40\x2b\x74\x14\xe4\x28\x4c\xe3\x84\xc2\x45\xef\x60\x9c\x78\x5b\x98\xa5\x85\x97\x06\x10\xba\xae\xe4\x8c\x0f\x65\x7d\x65\x5f\xee\xb0\xbf\x72\xb7\x09\x61\x43\xb9\xaa\x12\x4e\xb2\x14\x6d\xcb\xf0\xb0\xe2\x33\x76\x7e\xa0\xcc\x04\xa5\x64\xa5\x3c\x60\x78\x88\xd5\x8e\x19\x91\x77\xc4\xf2\xbf\x4e\xa4\x4c\xc0\xea\xca\xd8\xc6\x69\x1a\xa3\x00\x10\xbc\x2b\x4b\x1d\x40\x41\xa7\x7d\x30\x51\xa6\xe7\x2b\xfa\x94\x3b\xf2\x0f\x77\x9d\xd4\x3e\xbd\x70\x7f\x77\xa3\x84\xd1\xb4\x90\xc0\x7d\x99\x84\x54\x2d\x9d\x1e\x99\xb8\x24\x81\x54\xd8\x2b\x27\x3a\x53\x97\xc0\x8e\xce\x8a\x65\x8b\xd5\xce\x69\xf1\x72\x5a\x70\x6c\x5d\x61\x41\xcb\x19\xa0\x5e\x66\x67\x93\x8b\x2a\xdc\x31\x7d\x3d\x26\xc1\x38\x0f\x0e\xbc\x3d\xac\x45\x3a\x5d\x51\x6f\x29\xa1\x49\x4e\x71\x8a\xc8\x40\x38\x33\x45\x02\xea\xcc\x75\xd6\xd8\x54\x7d\x77\x64\x76\x3f\x08\xb0\x44\x9b\x5d\xb8\x16\xaa\x5b\x36\x8d\xc9\xac\xad\xca\x7c\x12\xdf\x6e\x57\x61\x26\x5e\x6d\x18\x8b\x31\x0a\x73\xda\xd5\x38\xdd\x70\xb0\x5c\x04\xc2\xe4\x5c\xb3\x4e\x14\x48\x16\x1a\x0f\x15\x4b\xcf\xe7\x3d\x57\xe0\x16\xb2\x08\x29\x40\xdc\x9c\x35\x46\x1a\xcf\x18\x22\x8d\xe7\x19\xe1\x35\x2b\x66\x9c\xfa\xbb\x9e\xc0\xd5\x6d\xcd\x35\x2b\x1a\xe6\x7c\xcd\x8a\x39\x27\xbc\x10\xa5\xdb\x59\x90\xd4\xed\xcc\x49\xeb\x76\xd6\xc4\xee\x4f\x40\xec\xae\x59\x4d\xc3\xf7\x42\xeb\x96\x64\x22\xf0\x48\x34\x1f\xad\x59\x04\x2f\x8c\xe3\xd7\x69\xfc\x03\xcb\x0b\x9a\x56\x30\x3f\x1d\x92\xd2\xeb\xc2\x3d\x64\xe6\xf8\x58\x19\xc3\xab\x86\xd8\x8c\xcb\xde\x29\xac\xc3\xa5\xdf\x7e\x33\xc4\xa8\xb4\x07\x7e\x1b\x4e\xbf\x07\xfe\xd2\xe7\xb4\xf8\x80\x9f\x5a\x62\x56\x1d\x55\x5d\x85\x6d\xec\x20\x9b\xaf\x2c\xe1\xe6\xe1\x7d\xad\x07\x01\xb4\x02\x7d\xe1\x9b\xc0\xb2\xdb\xa8\x7a\x94\x9c\xe0\x2c\x2e\xe8\x4d\x5f\x25\xb6\x97\x6a\x42\x69\x8f\xa4\x37\x02\x3f\xb6\x2a\x28\x1d\x92\x00\x96\x3b\xc4\xe8\x54\x31\x7a\xd5\xc4\x0f\xb5\x3e\x62\xc5\xa4\x27\x22\xfc\xb6\x21\x2c\xff\xcc\xd3\x6a\x07\x4d\xe2\x38\x69\x9e\x56\x7a\x69\x12\x2f\x4d\xdb\x69\x8d\x9b\xa6\xf8\x4f\xbf\xcc\xa4\x47\xe7\xa9\xf1\xd7\x84\x62\xa7\x4d\xf7\x7c\xd8\xd0\xce\x07\xbb\x8e\xbc\x59\x0d\xac\x2c\xa8\x80\xc1\x3b\xe6\xd4\x67\x1a\x2a\x20\x81\x3f\x38\xf5\xae\x6e\x0f\x0e\x6f\xe9\x53\xfb\x40\x96\x21\xfc\x2e\xb1\xc8\x86\x43\x4d\x8f\x86\x81\x9f\x35\x17\xda\x6c\xb6\xdd\xe2\xd8\x9d\xb1\x2c\xe6\x3f\x7a\x6a\x1c\x48\x01\x81\x16\x71\x20\x85\x3d\xc5\x1f\xce\x96\x81\x53\x28\xae\xa4\xf5\x27\x4b\xcf\xad\x5f\xe8\x6d\x8a\xab\x64\xfe\x92\x30\xb0\x30\xe2\x0f\x39\x7f\xf8\x53\x4c\x54\xbb\x98\x92\x86\x30\xb7\x75\xde\x48\xc6\xd4\xa6\xec\x8d\x34\x33\x0e\xae\x51\xb3\x96\x0f\x9a\x23\x69\x2f\xbf\xea\x2a\x40\xcb\x70\x95\x88\x59\x06\xab\xc2\xcc\x52\xbf\x65\xc4\xd3\xe2\x5e\x17\xca\xa1\x27\xce\x05\x22\x41\xdd\xc2\x12\x2a\xf7\xeb\x5d\x19\xc7\x2c\x55\xca\x23\xff\xa4\xdf\x76\xb0\x76\x5b\x37\xe7\xb9\x38\x8a\xff\xcc\xf5\x95\x17\x61\x41\xed\x0b\x67\xd1\x9d\x27\x3e\x65\xea\x38\x9f\x3e\x39\xbf\x16\x74\x8e\x8c\x96\x71\x8c\x94\x36\x20\x62\x19\xc2\x42\x6a\x11\x65\x59\xd0\x2e\xa5\x4d\x34\x8b\xe4\xfc\x5c\x60\xf2\x9e\xa7\x61\xdd\xc4\x49\x95\x03\x9e\xe4\x38\xfd\xba\x62\x0f\x86\xce\xdd\x36\xf4\xd8\x78\x67\xac\x70\xc9\xd9\xd2\x1d\x1e\xd3\x83\x12\xe0\xad\x57\x72\xeb\xf7\xba\xd0\x9c\x6b\x66\x5d\x93\xd2\xd1\x36\x72\x29\x77\x5c\xf2\x8b\x54\xff\xb9\x5b\x64\xff\xb2\xb8\x73\x35\x2f\xc5\x9f\x08\xfe\xe2\x23\xfc\x90\x88\xac\xb8\x89\x83\x8d\xdb\x56\x29\xf8\xb7\x2d\xed\xd4\x42\xb9\x2a\x33\x76\x49\x9f\x1c\x5b\x75\xa9\xe2\xd6\x2b\x51\xd2\xec\x06\xbd\x09\x06\xe5\x32\xb2\x69\xfb\x19\xa2\xf8\xff\x6e\x5e\x84\x69\x1c\x66\x90\x1b\x76\xa9\x84\x7b\x1b\x04\x44\xed\x1f\x50\x3b\xa0\xb2\x8d\x9a\x2c\x7c\x6a\x6a\xc1\xc6\xad\x25\x48\x3c\x28\x19\x99\x3f\x5f\x07\xbe\x5c\x07\xbe\x7c\xa0\x81\x2f\x6d\x77\xe3\x6a\x55\x49\x09\xb2\xa9\x71\x0d\xf4\x87\x8b\xac\x39\xa2\xc9\x84\x66\xb5\x93\xf8\x3c\x56\xc5\xbf\x77\x7b\xdc\xdf\x81\x1d\x33\x64\x0c\xbb\x2e\xe4\x0d\x55\x84\x83\x99\xba\x65\x3f\x0d\xf9\x22\xc6\x92\x18\x49\x71\x86\xf9\x68\xeb\x44\x47\x70\x84\xa7\x0e\x8d\x2e\x06\x1c\x12\x98\xc4\x34\xcd\xe1\xd5\x91\xf2\x54\xbe\x34\xee\x6a\xaa\xf9\x61\x44\x71\xd6\x24\xa2\x49\xa2\x8c\x2e\xf3\x07\x60\x60\x79\x7f\x09\xd4\x1e\x8c\x8d\xe3\x02\x46\x6b\x9f\xc3\x36\xf1\x4f\x65\x75\x68\x59\x01\x2a\x4b\x63\x19\xd8\x8f\x9d\x83\x65\x3a\x2c\xad\x6b\x1d\x91\x4e\xc7\x34\x63\xd1\x22\xa9\x0c\x55\x6c\x50\x19\x44\xd5\x46\x30\x30\x3e\xa4\x89\x15\xe7\x52\x02\x35\x5b\x5f\xcc\x4f\x1e\x04\x79\xba\x8f\x80\xb9\x03\x9e\xc5\x34\xfb\x8e\x17\x05\x1f\xf7\x49\xb0\x3d\xb9\x26\x39\x4f\x58\x4c\x02\xf2\x58\x2a\x0a\x26\x61\x42\x8b\x82\x76\x05\x6d\xed\x26\xa0\x21\x60\x97\x2c\x36\xcf\x34\x3b\x9a\x6b\x42\x87\x6e\xb0\x5a\xbd\xce\x55\xb1\x5f\x33\x14\xe0\xc8\x2f\x7e\x48\xd9\x8c\x5f\x6d\x66\xf4\x92\x66\x39\x0d\xc8\xd6\x16\x89\xc2\x94\x0c\x28\x89\x6f\xd2\x70\x2c\xcd\x62\xb4\x9f\x0e\x09\x0b\x92\x4d\x53\xb4\x88\xb9\xd1\xb4\xcf\x1e\xc9\x88\x86\x35\xe1\x78\xa5\x42\x44\x07\x90\xe9\x9a\x8f\x6f\x69\xcc\xa6\x63\x35\xc2\xaa\xc4\xa2\x62\x64\xbf\xf0\xec\x22\xcc\xf8\x34\xc5\x93\xfc\x81\xf3\xa4\x60\x13\x0d\x2e\x90\x85\xe5\xf9\x54\xca\xf5\xe5\x78\x24\x86\xbc\x52\xbc\x82\x17\xa3\xb7\x32\xfe\xed\x16\xd9\x41\xd5\x99\xb5\x3f\x5e\x80\xdc\x67\xcd\x00\x73\xb4\xb0\x2b\xb5\x73\x6a\xd6\xf3\x26\x6d\xad\x6e\xcc\xd3\x20\xb8\x53\x4f\xf3\x05\x82\x13\xeb\xd6\xdc\x56\x8e\xe4\xb1\xa9\x58\xc1\xa0\x47\xb6\x77\x26\xae\x83\xc9\x90\xf3\xc2\x76\x2d\x71\x4f\x40\x29\x25\xac\x3e\x56\x1f\xc4\xcd\x7a\x44\x93\x44\x45\xc1\x8b\x90\xdd\xa8\x8c\x70\x78\xe0\x44\xa6\xbb\x7b\x54\xc2\x59\xc1\x0f\xe5\x29\xd3\xdf\xe5\xef\x8e\xbb\x20\xfa\xb3\xfc\x6d\x07\x3d\xc4\xcb\xc8\x0e\x7a\xe8\x08\xd1\x97\x0d\x14\x58\x2b\xd1\xb5\xa4\xbe\x72\xb0\xe2\x4f\x39\x30\x57\xe6\xfb\x51\xc7\x8e\x43\xee\xe6\x50\x2d\x7d\x17\x7e\xeb\xb5\x3e\xb2\xa6\xa1\x94\x4c\xa8\x5f\x8a\x5c\xe3\x2f\xe2\x80\xea\x8f\xa0\x8a\xb1\x95\x45\x36\x14\x76\xfd\xe8\x11\xfe\xd1\x15\xc4\x84\xbc\x20\x41\x31\x0a\x48\x9f\x04\x45\x1c\x68\x45\xce\xb2\x01\x09\x57\x13\x7a\x50\xed\xbc\x42\x89\xa5\xc2\x05\x9e\xe8\x8d\x20\x8f\xb1\xba\x7c\x43\x75\xa3\x70\xc2\x8a\x30\x61\xff\xa5\xdf\xb3\x2c\x2f\x7e\x10\x37\x43\xd6\x6e\x49\xf0\xf6\xc7\x8e\xc6\xb5\xaf\x40\x43\x2b\x6e\x2f\xb1\x6a\x4e\xa9\xba\xf3\x96\x0b\x65\xe8\xd2\xcd\xaa\x0e\x97\x6b\x57\x6c\x69\xa7\x6a\x9f\x97\x6b\x0e\xe9\x4c\xa9\x41\x2c\xf6\x82\x23\xde\x31\x15\xe0\x91\x7b\x5a\xef\x14\xf1\xcf\x12\x3d\x62\x7c\x33\x4d\xf7\xee\x1c\xdf\x6c\xa9\x88\x63\x2b\xe6\xa3\xbc\xd6\xe7\xe1\x02\xfd\x10\x68\x7f\x84\x47\xd4\xdc\x41\xa8\x7e\x0f\x71\x87\x94\x66\xf0\x8f\xf6\xc8\x99\x77\x0d\xcc\xfd\xb9\x82\x48\x3d\xe6\x06\x5e\xcd\x81\xf3\x62\xe3\x18\x6a\x52\xa1\x54\xd0\xa7\x51\x6b\x15\x0c\x27\xa7\x13\x61\x08\xa6\xcc\xb4\x22\x39\x01\x45\x96\x6c\xc1\x8f\x91\x7a\x6a\xda\x59\x2d\xf5\x59\x4a\xc3\x60\x29\x13\xf4\x68\x02\x72\xdb\x6e\xe9\x5f\xf7\x13\xf7\x66\xbb\xf7\xb0\xe2\xde\xdc\xa7\x80\x7b\x9a\xd5\xc9\x1a\x77\xf6\x1d\xa8\x46\xb9\xf6\x34\xa3\x26\xa9\xd1\xe5\x79\x43\x8a\x9b\x9d\x3d\x1f\xb0\x31\xf9\x11\x82\x7c\x9e\x98\x14\x5f\x7f\xfd\xff\xb3\xf7\xae\xe9\x6d\x23\x49\xa2\xe8\x7f\xaf\x22\xcc\xe9\xb2\x00\x09\xa2\x48\x4a\xb2\x65\xc9\xb4\xc6\x25\xdb\xdd\x9e\x63\x97\x3d\x7e\x54\x57\x0f\x9b\x23\x81\x44\x52\x42\x89\x04\x58\x00\x28\x91\x65\xeb\xfb\x66\x21\xe7\x2e\xe3\x6e\xe0\x2e\x65\x56\x72\xbf\x8c\xc8\x27\x5e\x22\xf5\x70\x57\x9f\x33\x35\xd3\x16\x98\x8f\xc8\xc8\xc8\x88\xc8\xc8\xcc\xc8\xc8\x07\x7a\xff\x09\x36\xd5\x33\x21\xd6\xbe\xcf\xfa\x96\x3a\x79\xe0\x78\xd7\x1a\x0e\x6b\x53\x3f\x3b\x5b\xe3\x8c\x1c\x70\x2e\x6e\xef\x36\x77\xda\xd0\x7e\xdc\x6c\x3d\x1d\x6f\xee\x34\x77\xf7\xf8\x3f\x4f\x41\x7d\xbd\x6d\xef\xc0\x6e\x73\x77\xbc\xf9\x18\xf0\xff\x7e\xe7\xbc\x2e\x88\xf5\xbf\xd8\x62\x10\xfb\x49\xf0\x22\x49\xe2\xcb\xb7\x6c\x64\xf9\x98\x16\x32\xcd\xb8\xf0\xcb\x9b\x38\x6a\x40\x6c\x6f\x0a\xc3\x51\x89\xf7\x5a\x18\x2d\x07\x0f\xca\x50\x22\xf7\x2c\xce\x2d\x5a\x9c\x0b\xe5\xdc\x92\xba\x56\x58\x2c\x42\xa3\x3c\x28\x56\xa1\x66\xe1\x40\xb1\xdd\xfe\x1f\xe9\xfd\x1f\xe9\xbd\x73\xe9\xdd\xe3\xb2\xda\x7e\xdc\xdc\xde\x19\x2b\x89\xdd\x34\x64\xb7\x05\xbb\xcd\x27\xbb\xe3\xc7\xf0\x78\xb3\x4e\x76\x3f\x0a\xdf\xb8\x72\xe1\xc5\xdc\xef\x2f\xbd\x12\xa9\x6b\xc5\xf7\xa3\x70\x53\x2e\x26\xde\x4c\x80\x3f\x0a\x4f\xda\x9c\x04\x77\x6e\x25\xc1\xe8\x8b\xcd\x06\xf1\x2c\x1a\x56\x49\xc7\x6e\x47\x06\x5f\x4f\x49\xbe\x2b\xca\x6d\xef\x09\x87\x05\x78\x95\x24\x71\x02\x13\x96\xa6\xfe\x29\xde\xb8\x4f\x33\x3f\xca\xd2\xa6\x64\xa9\xd7\x5f\x7e\x3a\x3a\x7e\xf5\xf1\xe3\xfb\x8f\xc7\x9f\x5f\xfd\xf2\x99\x93\xe1\xd5\x7c\xca\x86\xb8\x6f\xaa\x46\x7b\xed\x40\x71\xea\x11\x0e\x61\x0a\x3e\x64\x67\x49\x9c\x65\x63\x16\x68\xa6\xc8\xce\xfc\x0c\xe2\x08\x77\x5f\x2f\xe2\x73\x96\xc2\x09\xcf\x3b\x01\x3f\xa3\xa7\xa2\x62\xde\xb7\x29\x4b\x38\x24\x76\xc1\x92\x05\x9c\x5c\xfa\x61\x76\x62\x5f\xab\xa4\xe3\xaa\x22\xf8\x61\x3c\xc1\x87\xa6\x30\xca\xcc\xc9\xd0\x8f\x86\x6c\x7c\xc2\x41\x4d\x58\x76\x16\xd3\x71\x0e\x26\x42\xc0\xe8\x15\x1c\xd1\x3c\xc7\x66\xe8\x53\x00\x29\x3f\xe2\x3d\x3b\x19\x8d\x67\xe9\xd9\x89\xae\xc9\xc1\x84\x93\x09\x0b\x42\x3f\x63\xaa\x03\xb8\xd5\xd8\x84\x0f\x49\x7c\x11\x06\x0c\x4e\x28\x80\x62\x7a\xc2\x9b\x0a\xa3\x20\x1c\xfa\x19\x83\xcb\x33\x86\x5b\x60\xd4\x18\x07\x94\x9e\xc5\xb3\x71\x00\x03\x26\xc0\xe0\x25\x4c\x7c\xf1\x8a\xf9\x74\x3e\x10\x05\x5b\x71\x02\x59\xe2\x87\x63\xfe\x9b\x05\xa7\x4c\x86\x45\x20\x8a\x70\x30\xd2\x7b\x1c\xe9\x21\xbb\x92\x2a\x98\xea\x99\x2f\x7c\xe4\x43\x5d\xcd\xe3\xb2\xc3\xb1\x95\xa7\x0f\x08\xa9\x40\xcc\x26\x7c\x9a\x0d\x52\xf6\xdb\x8c\x45\x19\x70\x7b\x33\x95\x87\x15\x25\x84\x17\xe2\x2c\x80\x25\x2c\xe5\x32\x21\xd0\xc5\xc6\x0b\x74\xe6\x4a\x8b\x97\x5d\x5f\xff\x29\xce\xd8\xfe\x3a\x9d\xc4\x88\xee\x9f\xe0\x20\x9c\xc8\xde\x9f\x88\xb8\x94\x29\xf8\x09\x53\xc7\x35\xaa\xbf\x38\x32\x36\x19\x4b\xe9\x26\x9d\x56\x89\xff\x46\x15\x7d\x41\x68\x9a\x86\x13\xae\x75\xb3\x33\x3f\x22\xd6\x0c\x66\x74\x96\xa6\x86\x41\x8d\x81\xe8\x0f\xef\x05\x65\x84\x29\x9c\xb4\x44\x4f\x54\xbf\x78\x22\xae\x50\x8c\x0e\x28\x9a\xf0\xdc\x80\x8d\x58\xc2\x57\x17\xb0\x0e\xb3\x28\x0b\xc7\x92\xea\x11\x9b\x67\x90\x85\xc3\x73\x0f\xd2\x70\x12\x8e\xfd\x84\xe7\x9c\x68\x17\xf3\x13\xc9\xf8\xaa\x9f\x23\x8e\x80\x44\xec\x13\x63\xd0\x7b\xe9\x5f\x84\x01\x1c\xc5\xc9\xc0\x1f\x9e\xc5\x6b\x9c\xa0\x59\x38\x1c\xb3\xbe\x73\x96\x65\xd3\x74\x7f\x6b\x6b\x98\xa6\x9b\xdc\x48\x38\xc7\x8d\xdc\x2d\xa1\x6f\xc2\xe8\x74\x53\x90\x8a\x7f\xb2\xf9\x74\xec\x87\x11\x0b\x36\xd9\xdc\x9f\x4c\xc7\x2c\xdd\x72\x79\x1b\xa3\x98\x6b\xa8\xcc\x0f\xc7\x29\xc6\xa4\x42\xc4\x83\x70\x34\x62\x09\x8b\x86\x2c\x85\x01\xcb\x2e\x19\x8b\xe0\xe4\xb8\x29\x29\x2f\x28\x74\xdc\x94\xaa\x4d\x61\xfc\xaf\x69\xe6\x67\xe1\x10\x3f\x27\x6c\x32\x60\xc9\xfb\x11\x1c\x53\x4e\xc8\x07\xa3\xd5\x6c\x37\x5b\xf8\x9b\x8b\xd9\x69\x9c\x2c\xe0\xb5\x31\x8a\xff\x3a\xf5\x13\x7f\x02\x5f\x65\xda\x15\x8e\x31\xca\x8a\x56\x48\xb1\x62\x81\xa6\x59\x87\xae\x87\x5c\x41\x8f\x8f\x65\xb7\xd5\xc7\x5a\x94\xc8\xe9\x6a\x6a\x23\x13\x86\xa5\x48\xb2\xd8\x02\x49\x0a\xf9\x0a\x7a\x82\x99\xbb\x5f\xaf\x08\xac\x64\x6e\x75\xb1\x5b\xd7\xe1\xab\x6f\xe6\x47\xba\x52\x53\x70\x52\x97\x0b\x41\x9f\x17\x85\x4f\xe2\x56\x39\x72\x2c\x67\xce\x9c\x2a\x29\x11\x81\x6b\xda\x90\xd2\xb3\x44\x23\x75\x82\x46\xad\x90\x6a\x48\xcd\x61\xf8\x28\x92\x88\xad\x2f\xcb\x94\x0f\x56\x15\xcc\x25\xd8\x61\x6b\x0b\x5e\xe0\xd6\x3c\x9b\x0f\x59\x9a\x86\x17\x5c\x0b\xcf\xa6\x81\x9f\x49\x89\x94\x67\x66\x70\x79\x16\x8e\x19\xa4\xc3\x24\x1e\x73\xe4\x10\xda\xaf\xff\x3e\x63\xc9\xc2\xb9\x0c\xa3\x20\xbe\x74\x9b\x71\xe4\xac\x51\x81\x35\x0f\x34\x37\x3a\x08\x90\x7d\x88\xe5\x8d\xfe\x76\xab\x85\xef\xcf\x48\x14\xde\x90\xda\x3f\x49\x58\xc4\x2e\x3f\xc7\xe7\x2c\x3a\xa1\xe8\x34\x78\x8c\x3b\x0e\x87\xe7\x7c\xde\x8a\x32\x2e\xcb\x23\xdc\xf7\x83\xc1\x2c\xc3\xf8\x66\x39\x55\x42\xd3\xdb\x2e\x4c\xc2\x68\x96\xb1\x14\x91\xc4\x83\x0a\x45\x8d\xae\x89\x98\x6e\xd0\x83\xed\x16\xff\x8f\x9b\x70\x6b\x72\x00\xd6\xc4\xce\x07\x9a\x67\xba\xbb\xe2\x9c\x9f\xfa\x8b\xe8\xad\x79\xba\x05\xb3\x63\x47\x34\x31\x5a\x83\xaa\x51\xb1\x15\x77\x19\x31\xa7\xf1\x14\xbd\x84\x4d\xf8\x4d\x9a\x6d\xb1\x99\xad\x07\x86\x15\x20\xfa\xc4\x53\x3c\xe0\x22\xe6\x49\x29\xd0\x47\x62\x92\x7f\xbb\xca\x07\x13\x28\xa0\x1d\xe1\x46\xc9\xb8\xdb\x6d\xdc\xf1\x42\x09\x7f\x68\xee\xc8\xc9\x63\x1b\xde\xe8\x25\xb2\xdb\xe7\xc5\x94\xa1\xd9\xe3\xe4\x8c\x1b\x71\xa1\x86\x00\x4a\x0b\xca\x91\x88\x49\x40\x1a\xaf\x35\xf1\xb9\x06\x61\xa4\xa4\xf8\x10\x1e\x3e\xcc\x09\x2b\xec\xcb\x4a\xe4\x57\x6b\xf4\x41\x8f\x5f\x15\x0c\x55\x78\x5f\xd5\x93\x68\x8a\x59\x57\x2a\x4e\x8b\x9c\x84\xab\xc2\x50\x61\x40\x74\x5c\x9b\xf8\xf3\xbf\xfa\x61\xb6\xb6\x4f\xc5\x29\xd1\xe0\x25\xf9\x89\xe1\x14\x70\x2f\x9f\xcc\xd4\xa6\xb0\x52\xf1\xb6\x0f\x8d\x22\x5f\x4c\xe6\xec\xdc\xed\xff\x71\x7d\xfd\x67\x72\x7d\x4d\xd8\xe8\x80\xab\x00\xb8\x64\xfe\xf9\x3f\x7b\x50\xdb\xff\xab\xbc\x42\xef\xda\xa5\xc7\x70\x52\xf1\x07\x69\x3c\x9e\x71\x7d\x2e\xf2\x64\xfc\xcf\x8e\xa7\xbc\x1f\x84\xdf\x83\x4c\xb0\x22\x6d\xae\x14\x81\xd4\xd5\x20\xc6\xe3\xa3\x33\x3f\x3a\x65\xc2\x21\xc8\x23\xa8\x96\x1b\xc6\x30\x1e\xc7\xc9\x8b\xe1\x10\xdd\xd3\x94\x2f\x86\x3f\x3c\x3f\x45\x3f\x9a\x23\x9e\xbd\x9f\xf3\x40\x22\x63\xcd\x4f\x16\xcd\x17\x9d\xfc\x7b\xdb\xe3\x38\xf9\x90\x84\x13\x3f\x59\x2c\x0d\x6e\x4a\xe5\x7b\xbb\xad\x56\x3f\xef\xf6\xb1\xca\x9b\xe9\xb4\x44\x8c\x93\x4f\xe2\xc2\x1d\x6f\x9e\x77\xfb\x9a\x28\x37\xb9\x73\x45\x41\xf8\x65\xab\x48\x87\xb0\xe5\x1d\x46\x71\xb9\x68\x1e\xb7\xac\x7c\x1e\xbb\x7a\x9b\x45\x27\xd5\x7f\x46\x87\x4d\xeb\x11\x63\xf2\xde\x1c\xc7\x89\xb2\x94\xfd\x81\xdc\x26\x88\x13\x2b\xac\x61\x5c\x1d\x11\xe9\xfa\xe0\x4b\x2a\xcc\x11\xca\xc8\x5a\xff\xfa\x80\x48\x82\x9f\xeb\x8a\x52\xef\xfa\xd5\x31\x43\x0b\x5d\xa5\xa1\x11\x5d\x45\xf7\x54\x61\x8e\xea\x9e\xd6\x47\xf1\x32\xa3\x44\xad\x2e\x15\xab\xcb\x05\x37\x76\xf2\x27\x7c\xcb\xef\xc0\x9a\xee\x5e\x4a\xb0\xf3\x4f\xd9\xde\xd5\x53\xb3\x9c\x89\xb4\xc7\xd5\x38\x56\x1e\x95\x48\x51\xab\x36\xa6\x68\xaf\x32\x52\x77\x4c\x98\x34\xd0\x05\x3d\xfa\xf8\x72\x14\xb1\x4c\x33\x8c\x02\x36\x7f\x3f\x72\xb0\xbc\x8b\xfe\x19\x9b\xed\x83\xdb\xf8\x28\x2d\x7b\xed\xb0\xb7\x86\x6d\x2e\xeb\x3f\x44\x08\xf6\xbd\x7c\xcf\xca\x3d\x63\xd4\xac\x89\xde\x5b\x36\x29\x0e\x0d\xe2\x55\xdf\x18\x95\xb7\x42\xf1\x82\xa6\x98\x2f\x0a\xb3\x05\x82\x16\xc6\xf3\xb2\xdb\xdd\x74\xf7\xad\xe4\xd6\x1f\x8e\xbc\x14\x15\x42\xfe\x4a\x39\xd8\x28\x4e\xfb\xfe\x3e\x36\xff\x07\x79\x82\x70\x7e\xab\x57\x92\x7f\x08\x85\xbb\x6c\x87\xe4\xbd\xf4\x6b\xf5\xea\x77\xb0\x35\x72\xf8\x9b\x1e\x1d\x77\xe0\x3d\xa1\xd8\x5f\x3a\x50\xa8\x84\x7b\xf2\xa1\xd8\xb9\xfd\x19\xce\x87\xaa\x95\xc9\x1e\x5f\xff\xa0\x7e\x45\xc5\xf0\x92\xa5\xc3\xca\xa2\x7c\x01\x58\x58\x93\x97\xae\xd6\x9e\x76\x5c\x38\x34\xee\xa9\x0b\x63\x07\xce\xd9\xc2\xa3\xc5\xaf\xb5\x2e\x08\x3e\x34\x47\x76\x19\x8d\x8d\xd3\x96\x35\xb8\xfe\x81\xfd\x25\xa0\x52\x7a\x4f\xc4\x07\xc4\x0c\xe3\x42\x31\xe5\x1e\xa8\x99\xd6\xa4\xf4\xee\x12\x94\x46\xa2\x6e\x6d\x41\xa7\xd5\xec\xf0\xff\x6b\xc1\x3b\x3f\x3b\x6b\x8e\xe3\xd3\xf6\xd4\x99\xbb\x45\x0a\xe9\x6c\xf8\xf6\x4d\xa3\x2f\x2b\x98\x84\x70\xe6\xd0\x85\x8d\xb9\x0b\xcf\x61\xb3\xcd\x36\xf7\xf8\x02\x6d\x0e\xcf\x00\xbf\x0f\x61\x0e\x9b\x30\x87\x75\x98\xa3\x5f\xfc\xbe\x82\xec\xb4\x61\x03\xe6\x6e\x79\x9f\x1e\xd7\xf5\x49\x8f\x9e\xc0\xf7\xf8\x78\x85\x5d\x92\x33\x3f\x99\xc4\xd1\x02\xc2\x09\xaf\x0b\xeb\x5b\xe4\x58\x7e\x2c\x24\xe0\xf8\xcd\xbb\x0f\xef\x3f\x7e\x7e\xf5\xf2\xf8\xdd\xfb\x97\x5f\xde\xbe\x3a\x6e\x1d\x07\xdb\xc7\x53\x3f\x3b\x3b\x3e\xae\x7a\x83\xe8\x89\x7b\x23\xc8\xed\xe3\x63\x79\x90\x58\x09\xfb\xf1\xe3\x9b\xc1\xee\x1c\x1f\x0f\x67\xc9\x05\x3b\x1e\x87\x11\xf3\x93\x4a\xf8\xed\xed\x9d\x9b\x35\xb0\x7d\x8c\xa0\x2b\x01\x77\x5a\xad\x9b\x01\xde\x39\x3e\x9e\xc6\x61\x0d\x49\x3a\x2d\xdc\x58\xc1\xff\x0c\xf8\x52\x39\x12\x4f\xf0\x76\x4a\xf8\xa4\xd7\xf0\x1b\x5c\xbe\x34\x53\x69\x93\x73\xde\xc2\x06\xaf\xc7\x8b\x03\x81\x2d\xce\xd1\xeb\x5b\x7d\x69\x4f\xce\xdb\x32\xc8\xa5\x48\x58\x70\x70\x62\x6f\x74\x49\x1e\x90\x80\x65\x57\xd6\xb7\xfa\xae\xd3\x52\x8b\xfe\x45\x7b\x69\x04\x07\x08\x67\x61\x22\xa8\x0d\xd9\x3b\x40\x2a\x4b\x66\xcc\xd5\x56\xb6\xbc\x14\x6a\xf6\x1f\xd9\xaf\x16\xe1\x02\x8f\x96\x34\xa5\x2e\x47\xcc\xb2\xe9\x4c\x36\x61\x87\x89\xf5\x13\xe6\x3b\x81\x9f\xf9\x66\x98\xd8\x50\x47\x7c\xf8\x55\x7f\x9e\xeb\x4f\x0c\x86\xe6\x67\xbe\x0c\xed\xaa\x32\x8c\x80\x2c\x82\x64\x7c\x20\x95\xbb\xa4\xd8\xf6\x98\x8d\x46\x66\x10\x8d\x79\xeb\x77\x8e\x1b\xbb\x14\xa1\x61\x23\x23\xf2\xc9\xa2\x90\x27\xc2\x42\xd1\xb5\x09\x41\x3b\xea\x99\xab\x3b\x8a\xa4\x71\xa8\xa1\x65\x06\xcd\xd0\x53\x92\x8e\xfc\x17\x8d\x97\x6b\x85\xb8\x0d\x29\x5c\x6d\x08\xcf\xba\x10\x1d\xc0\xc6\x46\xa8\xc3\x7c\x70\xa4\x1e\x3a\x21\x3c\x03\x7c\x95\x5e\x90\xc0\x09\x04\xb9\x7a\x61\xdf\x83\xd0\xc3\x6f\xd7\x45\xaf\x5e\x49\x25\x33\x54\x08\x87\x62\x50\xef\x61\x59\x19\x80\x5f\xa1\x0b\xa1\x19\x36\x84\x3a\xdf\xe4\x23\xfa\x29\xf3\x93\xcc\x71\x4b\x72\x39\xb7\x14\x72\x0b\x11\xc8\xac\xe2\xaf\xa2\x60\x79\x50\x82\x48\xe7\x1c\x39\xd8\x84\xf6\x01\x9c\xc3\xf3\x2e\xfc\x7a\x00\x9b\x9b\xe7\xf9\x78\x28\x02\x10\x0a\x9e\x33\x6f\xfd\xde\x3b\xef\x7b\x7c\xc4\x7b\xe7\x7d\x0b\xe4\xd5\x6a\x88\x71\x0a\xe4\xf2\xae\x1e\xd8\x7f\x4d\x12\x9b\x58\x71\x24\xc2\x3e\x4e\xc9\x2d\x27\xd0\x83\x45\x68\x51\xce\xc2\xca\xd1\x6d\xd8\xbd\x69\xc3\x21\x6c\xcc\xdb\x66\x51\xd8\x17\xf0\x3d\xae\x8d\x0e\x61\x63\x91\xcf\xa6\x46\xf2\x51\xed\x34\xc3\x13\x43\xbb\xca\xb0\x31\xe5\xda\x13\x72\x05\x1b\xd0\x68\x70\xbb\x83\x84\x5d\xd4\xb7\x04\x9e\x13\x4f\x45\x5e\x13\xb0\xae\x15\x11\x35\x67\x95\xea\x34\xb7\xa9\x98\x5d\xac\x8c\x9b\x24\x83\xf8\xaf\x2b\xfd\xa0\xa5\xc8\xea\xb0\x72\x1c\x9f\xe6\xdc\xd8\x4c\x76\x8e\x73\x98\xe5\x03\x49\xf3\x15\x25\x4e\x37\xe2\x38\xee\x18\x05\xa9\x21\xeb\xf3\x15\xe7\x31\xec\xdf\x85\xa2\xde\x38\x76\x3d\x63\x6e\x42\x5c\x69\x14\x0f\x68\x27\x56\xe1\xdf\xfa\x03\x77\xa0\x1a\xeb\xf6\xca\x58\xe3\x24\x2a\xf5\x2d\x1c\xd2\x9f\xfd\xef\xdd\x91\x76\xae\x23\x8b\x55\xfb\xb1\xf8\x7e\xd4\x5f\x14\xd9\x67\x91\x1f\x88\xc5\xca\xec\xf3\x1d\x3b\x50\x8d\xf5\xca\xec\xb3\xf8\x43\xb0\xcf\x22\xcf\x3e\x5c\xad\xfd\xd2\x82\xae\xf9\xfb\x6f\xd6\x90\x14\xfa\x26\x75\x68\x73\xee\xcc\x5b\x6e\x73\xe1\x2c\x5a\x6e\x09\xd4\xbf\xb5\x57\x84\xd2\x2e\x83\xf2\xcb\xf2\x50\xda\xe5\xb8\x68\xf3\x75\xa5\xf1\xd2\xd5\xee\x7d\x84\x1e\x3e\x34\x87\x48\x1d\x85\x5b\xbd\x90\x46\xf1\x4a\x7d\x50\x96\xb4\xba\x10\x0d\x0f\x05\xff\x3d\x7a\x04\x4e\xce\x62\x94\xd3\x93\x81\x0b\x66\xe4\x31\x51\x46\xfb\x4a\xb8\x98\xac\xaf\x41\x58\xb3\x38\xec\xe7\x8d\x58\x5d\xd0\xa4\x90\x48\xd5\x78\x19\xec\x70\x40\xae\xf3\xf9\x6d\x81\x27\xf7\xbf\x2d\x20\x96\x8f\xce\x20\x8c\xf0\xba\xad\xbd\x90\x54\x40\x9a\x81\x53\xda\x5e\xc3\x6f\x78\x16\xa3\xcb\x5e\x21\x25\x3e\xfa\x41\xe8\x8f\xdf\xe2\x72\xe7\x00\x37\xa7\x4b\x5a\x0e\x27\x93\x19\x5e\xb0\x72\x2b\x17\xb1\x03\x5c\xc4\x1a\x20\x6f\xb8\xb3\xb1\xdc\xee\x00\x6d\xc7\x15\x3a\x60\x63\x50\xbb\x32\xa9\x5b\xe1\x59\x4e\x00\x02\x16\x59\x5c\x74\xd5\xec\x2c\x4c\x9b\xc7\x52\x04\x04\x27\x5f\x3d\x78\x40\x25\x9b\x53\xf9\x6e\x85\x0c\x9a\x27\x97\x0e\xfb\x45\x75\x63\x80\xca\x2f\x31\xf0\x8c\x5b\x18\xdd\x4b\xd4\x54\xa6\x39\xd6\x53\xab\x88\x6b\x6a\xe6\x56\x1b\xaa\xee\xf5\x6d\x5a\x4b\x05\xac\x87\x26\xba\x51\xcb\xf7\x20\x29\xab\x49\xa6\x7c\x02\xeb\xb4\xef\x96\x86\x91\xc3\x97\x02\x3c\x61\x13\x53\x86\x71\xea\xf8\xae\x30\x66\xad\x68\x0c\xe6\xe0\xaa\x01\x31\xed\xf0\x44\xe4\x99\x41\x1a\x94\x14\xf3\xf5\xae\x59\x59\xeb\x25\x65\x37\x53\xfd\xc2\xe0\x6a\x4d\x90\x08\xde\xbe\x2a\x6a\x82\xda\xa7\xe9\xef\x56\x13\x2c\x21\x8f\xb4\xa9\xc4\x47\xe9\x76\xe2\x48\xdb\x21\xd4\xed\x4a\xa1\xdc\x6e\xdf\x7c\xbf\x71\x89\x2d\xbb\x07\x06\x0b\xe8\x1e\x39\x63\xe3\x6c\x96\xf7\xb5\xa9\x47\x6b\xdc\xf4\xf1\x99\x26\x9e\x3a\xf7\x20\x60\x63\x96\x31\xfe\x7d\x80\x99\xbc\x3b\xb3\x14\x73\x17\x46\xee\x42\xd4\xbd\xc9\x94\x38\x74\x96\xd8\x0e\xc9\x51\x53\x6e\x8a\x59\x73\xf6\xb1\x8b\x33\x91\xe3\x0a\x2e\x2c\x4c\x46\xc4\x7d\x5b\xeb\x30\x8b\x30\x8a\x54\xf5\x6e\x23\xd2\x9e\x4a\x29\xda\x8a\x52\x82\x55\x4a\xf6\x1d\x65\x2b\x9a\xce\xcb\x18\x22\xb5\x8b\x58\x92\xb6\x95\x08\x43\x70\x8a\x0a\x9e\x43\x74\x2b\xa6\xe2\xda\xb0\x9d\x77\x23\x80\x37\xdc\xd1\x9d\x7b\xb0\xb0\xa8\xdb\x73\x16\xb8\xe9\xe1\x4a\x2d\xc8\x75\xde\x1c\x36\xc5\x29\xc7\x87\x37\xb0\x05\x1d\xbe\xce\x31\xb5\xe4\xdc\xed\x97\xf7\xbc\x53\x7b\x3b\xf8\x8f\x6d\x84\xa4\xe3\x70\xc8\xc8\xf0\xc0\x03\x7e\xfe\x53\x3e\x67\xa5\xa7\xd2\x26\x15\x2b\xf6\xbc\xf6\x66\xe5\xf7\x3e\x95\x39\x9e\xd4\x9e\xc9\xec\x89\xa1\xbb\x21\x37\x71\xf6\x09\x12\xff\xd2\x98\x62\xc5\x04\xe6\x41\x1a\xfe\xce\xcc\xbd\xe6\x44\x9e\x97\xa5\xbf\x25\x99\xc3\x73\x61\x6b\x19\xd4\x7b\x8d\x5f\x69\x9b\x36\x14\x76\x10\xe8\xcd\xf4\xe6\x24\xbe\x60\x9f\x63\x27\xf1\xa0\x95\xcb\xf1\x93\xa1\xd3\xf2\xa0\xe5\x41\x82\xff\x2e\xd5\xd2\x04\x5b\xca\xfc\x99\x6a\xea\xaa\x9c\xbb\x6b\xef\xde\xfd\x23\xe4\xfa\xd6\x23\xb1\xeb\x72\xf9\x2e\xa5\xee\xe6\x36\xac\x73\x2a\x6e\x26\x39\x1a\x73\x0d\xcb\xf3\xaf\xcb\xc3\xfa\xe5\xf9\x4b\x64\x57\x64\x5d\x83\x94\xc8\xae\x86\x5b\x9d\x53\x83\xcf\xe6\xf5\xd9\x55\x59\x15\x08\x0d\xc7\x71\xca\x3e\xf8\xd9\x99\x53\xc7\x6f\xb5\x3e\xf0\xb7\xe0\x37\x8a\x65\x15\x6d\xb7\x2c\x96\x68\xc3\x16\x6c\x8b\xb3\x19\xcc\x3d\xc6\xa7\x3a\xb0\xdc\x3a\x67\x92\xef\xc3\xa7\x8b\x32\x3e\x15\xf8\x18\x27\x47\x73\xe8\xe2\xa4\x84\x39\xa5\x0c\xdc\xf2\x60\x73\x51\x3e\x2c\xf3\xa2\xe6\x10\x39\x2d\x3e\x41\x96\x0f\x65\x49\xa5\xe5\x86\xb1\xd6\xdd\xe3\x0f\x39\x35\x70\x20\xe7\x3e\x74\xa1\xd5\xdc\x7b\xda\xda\x6b\x6f\xb7\x9e\xb6\x77\x3b\x4f\x3b\x7b\xbb\x9d\xce\x5e\x5b\x38\x6b\x9f\x6b\x8d\x12\x46\xf5\x46\x55\x99\x4e\x87\x2d\x68\xb7\xb8\xfa\x51\x20\x9e\xc0\xfa\xea\x53\x03\x81\x11\x18\xcd\x57\xc6\xc8\xd2\xfd\x02\xa5\x75\x38\x17\xc7\x97\xe7\x9c\x19\xf5\x5a\xf0\x56\x10\xbf\x97\xfc\x94\xe8\xf9\x75\x38\xf7\x73\xa2\x73\x3e\x47\xc5\xa4\x0f\x62\x79\x1a\x97\xa7\xa4\x52\x96\x2a\x54\xdc\x5c\x4b\x8c\x7a\x23\x34\x84\x2e\xb4\xf1\x10\x15\x76\x73\x67\xa8\x3c\xdb\xaf\x3d\xfa\xae\xa4\xe5\x3a\x84\x7c\xca\xb2\x1e\xd6\x91\x9d\xa5\xa5\xba\xf5\x68\x87\xc9\x0b\xfa\x20\x2f\x87\x7d\x2a\xe6\x93\xa1\xa1\xde\x0b\x85\x86\xe8\xa2\xb3\x09\xbc\xf0\xc2\xc3\x3f\x73\xd8\x00\x9e\xbc\x30\xde\x39\x58\x55\x2f\xd4\x3a\x27\xfd\xd1\xcd\x89\xcb\x02\x9b\xe5\x38\x6c\xf3\xb2\x68\x5a\x24\x7c\xf9\x36\xf7\x60\xee\xc1\xa5\x07\x97\x75\xc4\xb9\x2f\x2f\x27\xb4\xed\x7f\x4b\xb2\x6d\x0b\xff\x6d\xf7\x7b\x4e\x6f\x9b\x85\xf9\xcd\x21\x94\xd6\x61\xdb\x2d\xb7\x75\x5b\xb4\x04\xeb\x54\xcc\x4d\xb2\xfa\xa2\x7a\xce\xab\x2b\xb2\x1c\xbf\xde\xd7\x0e\xb3\xdc\x37\xd9\x6c\x35\x85\x70\xa7\xb9\xc1\xe1\x9c\x24\x34\x32\xd7\x2c\x6a\xd2\x40\xb3\x45\x5a\x05\x5c\xab\x38\xe7\x22\xc2\x6c\x9b\x2b\xdd\xed\x7f\xa0\xce\xdd\x02\x4b\xe5\x72\x53\x2b\xd1\xdd\x00\xe9\x04\x95\x70\xe5\x6c\x94\x6b\x43\x17\xe6\x2d\xa3\x50\x5b\x16\x82\x0d\x53\x5f\xcf\xb9\x6d\xb6\x39\x6f\x1b\x25\x79\x0a\x1d\x7e\x15\xb8\x67\xce\xd9\xa7\xc2\xe2\x99\xb7\x3d\x10\x07\x53\xc5\xbc\x8e\x07\x8b\x0a\x9e\x43\xa5\xd8\x92\x5a\xb1\x25\xd4\x62\x4b\xea\xc5\x8a\xd6\xb0\x56\x5b\xd6\x6a\x8b\x5a\x6d\x59\xab\x02\x0f\xac\xd5\x91\xb5\x3a\xa2\x56\x47\xd6\xaa\xc7\x70\x43\x61\x48\x88\x09\x30\xf3\x7a\x0c\x37\x14\x86\x84\x98\xac\x55\x8f\xe1\x86\xc2\x90\x10\x93\xb5\xf2\x18\x2e\x27\x70\x7f\xc4\x8d\xdc\x23\x3f\x09\xc2\xc8\x1f\x1f\xf1\x1e\x04\x37\x35\x42\xa3\x38\x9e\xd6\x9c\xac\xec\xde\xdc\x69\x54\xa0\x57\x03\xfc\x49\x6e\x23\xd7\xee\x91\x16\xf2\x8c\x45\x69\x18\x47\xd6\x51\x8b\x3a\xac\x33\x0e\xe8\x28\x8b\x2b\x26\x87\x73\x89\xaa\xb6\x05\x8f\x71\x83\xd4\x86\x5f\x77\x2a\xb3\x04\xc9\x2a\xdc\x00\xd5\xf1\xcc\xcd\x41\x5c\x7f\x52\x43\x4e\x2d\xf4\xd9\xd6\x9f\x1d\xfd\xb9\xad\x3f\x77\xf4\xe7\x2e\x9e\xbd\x4b\x28\x0b\x0d\x65\xa1\xa1\x2c\x34\x94\x85\x86\xb2\xd0\x50\x16\xbb\xd0\x85\x9f\xfc\x9f\x0e\x0c\x50\x78\x80\x83\xfe\x7a\xd7\x1f\x19\xa5\x97\x61\x36\x3c\x03\xc7\xa8\xa9\x8d\xd2\xa1\x9f\x32\x68\x9b\xa1\xc5\xad\xf1\x96\x6a\x54\xf6\xd2\x53\x98\x1a\xfe\x61\x76\x8d\x9c\x80\xd3\x7f\x83\x84\xf9\xe7\x07\x39\x5f\x35\x6c\xbb\x53\xdd\xb6\x50\x30\xf7\xd7\xf6\x76\xa1\x6d\x3a\x18\xbb\xbe\x45\xab\xdc\x8e\x2a\xb7\x53\x5b\x6e\x57\x95\xdb\xad\x47\xef\xaa\xea\x3c\x4f\x6f\x62\x93\xa5\xb9\xc1\x13\x70\x17\xfb\x60\xc9\xa1\x6e\xed\xe7\x38\xa8\x7d\x60\xb2\xf0\xdc\x33\x59\x71\x71\x60\x63\x27\x99\xc5\x86\xd0\x39\xa8\xe5\x99\x1d\x0b\x2c\xff\xb5\x70\xcb\xe0\x76\xf2\x70\xb7\x0f\x0c\x31\x32\x40\xec\x96\x60\xa6\x6e\x78\x2f\xe5\xb1\xa1\x34\xa5\x3c\xfd\xa1\x26\xc9\x87\x19\x5f\x88\xa5\xa5\x9d\xd9\xc6\x55\x95\x3a\xf0\xca\x14\x83\x67\xaa\x88\xf9\x41\x95\x12\xf0\xca\xd4\x81\x67\x2a\x86\x85\x3e\x82\xbd\xbb\xe3\x26\xc7\x38\xcd\x4d\xb3\x78\xe2\x18\x0a\xdf\x3c\xca\x95\x84\xaa\x39\xcc\xbd\x6e\x0a\x51\xc7\xba\x12\x56\x53\xe4\x98\x67\x7b\xd6\x7c\x03\xda\x37\x02\x71\xdb\xb0\x40\x99\xa7\x70\x12\xe4\xc1\x83\x2b\xd7\xc1\x40\x33\x05\x3b\xe2\x3b\x9c\x47\xdd\xd8\x8e\x78\x3f\x65\xd1\x8d\x8f\x84\x97\x9d\xec\x0b\x73\x3d\x6f\xf5\xfe\x66\x7a\x0e\xfd\x06\xde\x17\x5c\xd3\x5b\xb3\xd9\x75\x4e\x17\xa2\x82\x98\x15\x97\xf4\xb7\xa8\x9e\xc5\x97\x9b\xa4\x6f\x31\x07\x63\x90\x1d\x8d\xf9\xb7\x6f\xd6\xcf\x87\xdd\x2e\xb4\x30\x52\xbd\x09\xb8\xdb\xe5\x6b\xe2\xeb\x66\x38\x8b\x1e\x38\x36\x2a\xa1\xd2\x2d\xe4\x7e\xa6\x91\xe5\xa6\x8a\x55\x14\x3f\xf6\xea\xb0\xd6\x2a\x30\xb4\xa5\x0b\xfb\xb5\x13\x91\x59\xb4\x0c\x8f\xed\x3c\x1e\x3b\x18\xd7\x05\x2f\x03\xe3\xf5\xf6\xd5\x26\x9a\xd6\xff\x4c\x34\xf7\x31\xd1\x94\xeb\xaf\x7f\xec\x34\xb3\xfd\x87\x0c\x0d\x1e\xa6\xaf\x7e\x9b\xf9\xe3\xca\x38\x4b\x8f\xf3\x25\xeb\xa2\x1f\x49\x60\xf9\xe0\x4c\xea\x0e\x52\xd3\x4f\xd3\xf0\x34\xb2\xee\x85\x3a\x99\x9f\x9c\x32\x3e\x9a\xa5\x1b\xe4\x79\x17\x9e\x03\x08\x37\x36\x78\x61\xdc\xa9\x8c\x67\x09\xba\x21\xa8\x52\xbd\xb0\x7f\xa0\xe1\x9c\xb3\x05\x84\x91\x28\xc6\x2b\x71\x15\x2b\x50\xd1\x3e\x0b\x67\x7e\xfa\xfe\x32\x92\x34\xa4\x5b\xcb\x54\x05\xef\xda\xba\xbc\x22\x21\x29\xef\xd8\x52\x2e\xfe\x3a\x80\x2b\xfc\x3f\x19\x9f\x13\xcb\x1d\xc0\x95\x8a\xb2\x84\x37\x7b\x8f\xc6\x7e\x6a\xc5\x0c\x42\xd7\x0a\xf5\xcb\x1a\xc5\x90\xa5\x82\x26\x1e\xc8\xd0\x16\x36\x69\xe8\x02\x96\x88\x3d\x51\x42\x96\x80\xa5\xc3\x24\x9c\x66\x3a\x80\x05\x92\x45\x27\x37\x19\x06\xf3\x17\xef\xf5\x94\xa7\xf3\x31\xf2\xc7\x29\xb3\xea\x0d\xe3\x68\x14\x9e\xce\x64\x4d\x8c\x0f\x87\x44\x6d\x20\x7b\x35\x38\xb5\x75\x71\xd7\xac\x7a\x99\x84\x99\x55\xad\x9c\x83\x65\xcf\x8d\x9a\x78\xdf\xd9\x80\x7a\x60\x12\x5c\x53\xf4\x28\x8e\xd2\x2c\x99\x0d\xb3\x38\x41\xc2\x65\xf1\x07\x7a\xe7\x88\x82\x5c\x7e\x90\xa4\xe4\xe8\xea\x6c\xb7\x48\x7c\x03\x90\xe6\x12\x13\xa4\x4b\x7d\xb6\xe0\xd6\x41\xb1\x51\x38\xd0\x4f\x3d\xab\x12\x07\x18\x71\xca\xb1\x63\x73\xc9\xa0\x1f\x1d\x0f\x8e\x33\x36\x99\xfe\x73\xbf\x57\xfb\x22\x0a\x27\x7e\xc6\xde\xf9\x91\x7f\x8a\xd7\x12\x4b\x63\xae\x3d\x6d\x55\x54\xa8\x6b\xcc\x2e\xa9\x00\x7c\x98\x25\xec\x23\x8b\x82\x9a\xd6\xb6\x4b\x0a\xd7\xb5\xa4\x4b\x69\x1d\xe7\xa7\xd5\x2f\x8d\x6e\xef\xe8\x16\x48\x76\xbe\x60\xf4\xcb\x8a\xe2\x7b\xed\x4e\x69\xf1\xda\x00\x6d\x46\x39\x55\x79\x96\x85\xe3\x2a\x0e\x21\x94\xee\x3d\x78\x9a\x6e\xa0\xe2\x41\x32\xde\x04\x2a\xd8\x54\xea\x2d\x92\x7d\x7c\x5d\xeb\xc0\xd4\x78\x21\x22\x20\x65\x97\xd7\x50\xb1\x73\x42\x17\x9e\x77\xa1\xe5\xe2\x3a\x24\x8c\xa4\x3a\x7a\xb8\x94\x92\x47\x04\x42\xd7\xac\x2c\xf4\x3c\xde\x75\x8c\x07\xbf\xa2\xde\x2c\x2a\x77\xb3\x77\x59\xcc\xe5\x78\x36\xe1\xba\x8d\x6e\xe9\xfa\x49\x22\x71\x25\xf7\xb8\x30\xd5\x19\x45\x65\xee\x81\x9f\x20\xd3\xa9\x42\x42\xa7\xbb\x72\x06\x4c\xf2\x4a\x9e\x57\x20\x1c\xfd\x24\xb1\x71\xe4\x59\x07\xea\x4e\xab\x4c\x25\x3c\x46\x49\x3c\x41\x24\x50\x83\x9a\x9d\xc8\x29\x61\x39\x32\x3a\xcc\x84\xa4\xbc\x31\x16\xe5\xfa\x5b\x57\xfd\x2a\x4d\x0e\xfc\xe3\x81\x9e\x5b\xc4\x9b\xef\x60\xce\x26\x32\x4d\x4e\x13\xf4\x1b\xae\x5c\xa3\x33\x7c\x40\xac\x28\x17\xba\xdb\xf1\xe0\xd7\xdc\xb8\xa0\xea\x3c\xf2\xc7\x63\x7c\x81\xd0\x09\xf1\x02\x0e\x9f\xd2\x0d\xb5\x2b\x3b\xf6\x50\x65\x83\xfc\x88\x47\x56\x41\xb4\x01\x4a\xe2\x9b\x36\x8e\xfc\x28\x8a\x29\x7c\x37\xf8\x14\xe0\x07\xfc\xd4\x08\xdc\xde\x28\x52\x7b\x1a\xa7\x69\x38\x18\x33\xa3\x01\x0a\xd8\xeb\xa4\x6c\x3c\xf2\x10\x98\x42\x8d\x27\xd9\xad\x7f\x64\x22\xda\xb3\x40\x81\x1b\xe8\x70\xe6\xa7\xd1\x5a\x06\x03\xc6\x22\x08\xa3\x30\x0b\xfd\x71\xc8\xad\xf3\x4d\x48\x67\x53\x96\x38\xae\x55\x82\xb7\xc0\x02\x42\x4d\x59\xb0\xe2\x52\x90\xb8\xed\x84\xbf\xf1\xc2\x13\xc9\x2f\xde\xaa\x2d\xe4\xe9\x5e\xc2\x21\x25\xef\x03\xc7\x38\x37\x18\xe2\x25\xd0\xd4\x49\x67\x83\x23\x9a\xdb\x10\x2d\xfc\x96\x5d\x15\xc0\x75\x06\x85\x53\xd2\xf7\xad\x1e\x3d\xca\x67\xd2\xc5\xf7\x8a\xa1\xf9\xc4\xcb\x72\xcb\x3a\x61\x29\x9a\xf9\x93\x59\x9a\x01\xa3\x47\x7b\x07\x8c\x6e\x1c\xe1\xf3\xbc\xb2\x09\x0f\xa3\x08\x37\x60\x03\x0a\xb8\x20\xa9\x24\xf6\xd6\xee\x85\x90\x03\x11\x67\xd1\x40\xd0\x42\xd7\xb4\x24\xbe\xd2\x2b\x00\x34\xf2\xfb\x5a\x50\x34\x71\x4c\x59\xa1\xf8\x01\x39\xc1\x28\x13\x1e\xce\x66\xd2\x34\x31\x88\x2b\xf0\x4b\x19\xd7\xbd\x84\xc2\xfb\x11\x1c\x96\xa7\x57\x0c\x90\xc6\xad\x79\x7c\x8c\x3d\xc1\x4d\x25\x5d\x44\xc5\xcb\x14\x73\xb1\x0c\x34\x64\x4c\xab\xf9\x17\xf9\x78\x11\xb4\x6b\xf8\x44\x45\x86\x8e\x65\x21\x1f\x1f\xd9\xef\x42\x6a\x26\x12\x6d\x78\x60\x14\xb1\x03\x3b\x88\x12\xa5\x8f\x81\x42\x41\x37\xd0\x2a\x5b\xd4\x91\xe1\x0e\x70\x1e\x45\xd1\xea\xd6\x49\x2c\xd5\x95\x28\x19\xd4\xf9\xf6\x4d\x52\xf8\xd4\xa6\xb0\x6c\xc7\xa5\x49\x88\x00\xe4\x10\x2d\x20\xf1\xa7\xa9\x08\xd7\x78\x4c\x47\x06\xfa\x6d\x0e\xdc\x39\x4a\x5f\x0c\xb3\x90\x6e\xfa\xe9\xd2\x4d\x99\xac\x0b\xfa\x59\x96\x84\x83\x59\xc6\x44\x64\x39\xb3\xb4\x95\xa7\xab\xf0\x49\x23\x57\x92\x27\xe9\x02\x59\x9c\xcb\xce\x62\x9d\x99\x66\x4c\xa3\xfd\x27\x19\x2d\x8f\x99\xc8\x1b\xcf\xa7\x9a\xa5\x64\x32\x5f\xec\xe2\xa0\x61\xc7\xcf\xfc\x28\x18\x33\x0c\x5d\x45\x41\x4c\x15\x49\x0a\x39\xcd\x41\x18\x05\x0e\x66\x8a\x6d\x30\x2a\x38\xc4\x5c\x19\x0e\xb4\x90\x66\x57\x53\x1b\x73\x0f\x25\x31\xf5\x26\x17\x55\xc5\x90\xdc\xdc\x66\x91\xe1\xe3\xbe\x5e\x89\xad\x01\xfe\xdf\xd6\x16\xaf\xad\xba\x18\x9a\x33\x03\xbd\x83\x81\xdc\x20\x9e\x26\xe0\xda\xc7\xa7\x21\x83\x94\x65\x22\x12\x5d\x16\xc3\x5a\x16\xaf\x09\x88\x86\xa6\xd4\x94\xeb\x96\xc5\xe3\xae\xc1\x31\x8b\x39\x8e\xf2\x38\x49\x7c\xc8\x10\x7a\xd5\xcc\x6e\x12\xd3\x08\xcc\x40\x83\xcc\xd5\x1d\xff\x90\xd6\xcb\x75\x74\xc2\xc2\xbd\x56\xbf\x29\xe2\xed\x09\xb0\x34\xd9\x73\xb0\x9c\xcd\xec\xe8\x22\x37\xee\xb7\xe9\xf8\x46\xad\x73\xe0\x2a\x55\x8f\xd7\xaa\x54\xd0\x87\x85\x55\x2d\x8a\xf6\x6c\xc9\x3b\x2c\x98\x5c\x5f\xaf\x3c\xbb\x8c\x07\xd4\x7f\x0b\x55\x9b\x48\x4b\x31\xa2\xc6\x51\xf6\x8c\x97\x56\x7b\x61\xe6\x06\x85\x56\xac\x3d\x02\x7d\xce\x16\xfb\xc6\x2b\x8e\x2f\xc3\xe0\x5d\x3c\x8b\xe4\x9b\xe0\x62\xd6\x32\xdf\x86\xb1\xcb\x39\xb6\x5f\xe3\xb1\xd4\x61\x65\x2a\xcc\x56\x62\x55\xfa\x0b\x60\xe8\x47\x3f\xb2\xd3\x30\xd2\xa5\x64\x8a\x54\x14\x62\x6f\x73\xc2\x31\xa0\xeb\xdb\x32\x8a\x7d\x41\x96\xb9\x92\x7e\x28\xeb\x9b\xec\x43\xa4\x2a\x48\x08\x02\x4e\x66\xd1\x0b\x29\xb4\x8e\xee\x8a\xe1\xe9\x78\x25\x83\x56\xe6\xe8\xf7\xd7\x70\x3c\xfe\xc8\x86\x2c\xbc\xc0\x71\x4f\xaf\xa3\x63\xbe\xbc\x13\xb1\x79\xf6\x41\x47\x3b\x95\x84\x35\x28\xa7\x4a\x5c\x47\x3c\x5d\x50\x26\x9a\x05\xf3\xf3\x84\x2e\x5d\x31\x4b\x80\x78\x70\xe7\x23\xd3\x06\x80\xae\x94\xcb\xd3\x23\x85\xa3\xb1\xc2\x00\x54\x68\x62\x31\x32\x29\xcb\x3e\x71\x21\x70\x4a\xe4\xfd\x06\xf2\xa7\xf1\xcf\x62\x2e\x87\xe6\x6f\xad\x3a\xdc\x82\xee\x28\x60\x8d\x4e\xbd\xd4\x75\x19\x75\xb9\xc7\x35\xba\x07\x6b\xb2\xef\xfc\x5b\xf6\x6b\xad\x6f\x71\x2b\xda\x51\x72\xf7\x55\x1b\x51\x9a\xf3\xf8\x84\x9b\x43\x56\x1e\x13\xd9\x12\x92\x4b\x2e\xa3\x63\x4d\x0f\xc2\xf4\x73\x12\x9e\x9e\xb2\x04\x85\xea\x61\x19\x7c\x2e\x4e\x25\x0d\x58\xdd\x21\xe1\x14\x5b\x35\xf9\x11\x14\xe9\xcd\x34\x8b\xa7\x8e\x5b\x3a\xfc\x42\xd7\xc5\xd3\x7f\xfb\xa4\xc4\xb0\xc8\x09\x76\x7e\x09\x28\xde\x23\x61\xda\x98\x1d\xfb\xf6\xad\xc0\xc8\x87\x06\x6d\xb1\xc6\x3e\x58\xb4\x3f\xb0\xb4\x43\x09\x0f\xde\xed\x0c\xe0\x1e\x54\x6b\x23\xb9\xe1\x8e\xb0\x14\xd6\x9e\x41\x1d\x0e\x89\xe0\x19\x11\xc9\xf8\xd8\xc9\xc7\xf5\x79\x0b\x4b\xaa\xb2\x2f\xd1\x64\x99\xd9\xc0\x28\x6a\x4c\x08\x39\x1d\x4d\x5b\xcd\x85\x71\x9e\x45\x9f\x66\x83\x74\x98\x84\x83\xa2\xb4\x1b\x79\x75\xac\xb2\x1a\xab\xd9\x99\x2a\x68\xdc\x3d\xf0\x61\x05\x85\x93\x59\x64\x54\xa8\xa0\xad\x5d\xc8\x0c\x80\x0d\xe6\xa2\x41\x3a\x8d\x1d\x94\x30\x7d\x99\x25\x2f\x6c\xf9\xa2\x15\x0f\x10\xcc\x12\xb2\x52\x65\xb6\x4c\x30\x0b\xa9\xad\x50\x2a\x42\x3f\xcd\x02\x03\x31\xf9\x50\xfe\x20\x3f\xeb\xc4\x9a\x95\x5f\x45\x81\x2a\x67\x27\x57\x54\xc0\x53\xfd\xb2\x2a\x98\x61\x51\x20\xe5\x29\x2a\x5f\xc5\xd7\x36\xf7\x5b\xb5\x9a\x45\x0a\x01\xd7\xb0\x14\xad\x1a\xfb\x24\xce\x41\x5e\xe1\x0f\xd7\xa1\x44\xd7\x53\x54\x12\x87\xa6\xc6\xaa\xc2\xb5\xc7\x20\x8c\xfc\xf1\xa7\x3c\x1a\x6a\x78\x4b\xb2\x9d\x82\x71\xdb\xc9\x33\x17\x5f\x8f\xe7\xea\x1c\x68\xb3\xf1\x41\x29\xeb\xfb\x49\xe6\xf4\xf2\xc4\xf2\x68\x9c\xbc\x32\x3c\xcc\x3e\xda\xe3\xd2\xaf\xd6\x1a\xc9\x2c\xfa\x94\xb1\xe9\x12\x5c\x6d\x15\xab\xe4\xeb\xed\x32\xbe\x96\x2b\xcd\xd2\x35\xe6\x2a\xac\x77\x1d\x27\x19\xc8\x60\x2b\x7f\x42\xc2\xd3\x5a\xc6\xb2\x67\x69\x17\x4e\x2d\x34\xa9\x30\xad\x76\xcc\x72\x22\xe3\x4f\x86\x88\xc9\xb2\x65\x42\x26\xc0\x7e\x0e\x27\x06\x54\xa3\x72\xd7\x78\x4d\x07\x0e\xa1\x05\xfb\x85\x42\xda\xfe\x42\xcb\x24\x08\x24\x8e\x7a\x65\x2a\xd2\x1c\x7a\x9e\x70\x28\xac\xa1\x37\x19\x9b\x78\x80\x7b\xef\xf9\x90\x8d\x98\x88\xad\xe7\x22\x35\xca\xfb\xe3\x02\x90\x56\xb4\x57\xda\x6e\xc2\x43\x4b\xdd\x7d\xd9\x54\x69\xff\x01\x8e\x65\xfe\x9f\x94\xc2\x51\x35\x8a\x3a\xc7\x50\x4b\xc5\x8a\x39\x62\xad\x31\x3f\x65\x6b\x9c\x62\xb9\x92\x36\x40\x19\xdd\x5e\xb5\x5a\x18\x53\x50\xb3\x2f\x9d\x75\x98\x85\xa7\x2a\xd5\xae\x51\xd0\x7e\xaa\x86\x9d\xa3\x47\x8f\x08\x37\x4d\x18\x2f\xc5\x0d\x19\x1c\x83\xe7\xd0\xc2\x38\xfb\x9c\x23\x29\x65\x13\xda\x7d\x61\xbf\xf2\x92\x07\xb9\xea\x39\x24\x0d\xac\xf5\x1e\xd6\x39\x5b\xa4\x14\x20\xdc\xb4\x77\x8d\x35\xb9\x41\x51\xe3\xad\xfe\x6f\xdf\xac\x8c\x74\x9a\x84\xd1\xe9\x5a\x29\x83\xf4\xfa\x5c\xab\x0e\xfd\xcc\x29\x39\x52\x91\xdc\xe3\x7a\xd0\x23\x15\xd0\xb4\xe7\x40\x63\xd7\x66\xdb\xcb\x05\xda\x24\x9b\x47\x90\xa9\x6c\xac\xb2\x58\x04\xfd\xb7\x93\x25\xf7\xed\x43\x39\x1f\x52\xcf\xf6\xc5\x5f\x23\xeb\xca\x98\x0a\xfa\x6e\x25\xc7\xeb\x57\x7a\xe4\x1c\x34\xcb\xc2\x71\xf3\x94\x65\x9f\x55\xce\xcf\xfe\xd8\x75\x0c\x8e\x31\xd4\xaf\x98\x75\xec\xd1\x8c\xd8\xa5\x52\x38\xa6\x31\x68\xf7\x5e\xf4\xd6\xa2\x93\xf5\x8a\x90\xfa\xae\x5b\xe7\x2c\x3f\x64\x12\xab\xba\xd9\xa3\x39\x0a\xc7\x19\x4b\x1c\x22\x42\x18\xb0\x28\x0b\xb3\x45\xc9\x14\xa6\x5e\x42\xbd\x7e\x26\xab\xc5\x0f\xf7\xaa\x12\x16\xcc\x86\xcc\x91\xfa\xce\x83\x9e\xa9\xb6\x3d\xba\xb6\x34\xf1\xe7\x8e\xa1\x76\xc5\xfc\xe8\xf6\x5d\xde\xb7\x32\x1b\xa5\x5f\x63\x42\x9b\x06\x7b\xf5\x44\x58\x39\x09\xe2\x0a\x78\x19\xc3\x56\xf2\x54\xee\x18\x5d\x5b\x36\x85\x1d\x2c\x7c\x3c\xa8\x7e\x9a\x5c\xca\x0c\xcc\x6f\x1e\xd4\x6e\x2f\x8b\x77\xa6\x5f\xd7\x59\xa5\x98\xfa\xb9\xca\x34\xbd\xd6\xea\x5c\x7a\x6e\xbf\x95\x2d\x7a\x8d\xfd\x61\xec\x72\x97\xef\x6f\x13\xfd\xf5\xe0\x99\x63\x69\x9b\x6f\xc6\xc2\x07\xba\xa0\x44\x40\x2d\x86\xca\xb7\xc3\x5d\x7b\x75\x75\x8d\xd6\xae\xdf\x69\x5d\x42\xaf\xcb\xc5\x69\x71\x9d\x72\xb0\xcc\x26\x8f\xb9\x93\x0c\xcf\xa1\x5d\x06\xba\xcc\x58\xbc\x16\xf8\x05\xbd\xea\xdb\xbd\xc9\x72\x5c\xf0\x21\x5f\x91\x8b\x4f\xd3\x1a\x5c\x5a\x9d\x9b\x53\x6a\x16\xbb\xa5\x3a\x5d\xc0\x5d\xd6\x52\xb7\x74\x3d\x5f\xac\x7c\xad\xd0\xe7\xd6\xdc\xb4\x82\x09\x5f\x60\xa7\x0a\xd5\x55\x28\x27\x8c\x06\x7b\xdd\x6f\x2c\x8c\x94\x51\x51\xd1\xb0\x51\xb4\x6a\xa3\xa1\x00\xcc\x3e\x33\x30\x36\x1a\x56\xda\x31\xc4\x3f\xd6\xfc\x27\x59\xa9\x02\xd5\x04\xcf\x39\xab\x74\x3a\x66\x96\xee\x88\x77\x2a\xb7\xc4\xcd\xa3\x31\x2a\xaa\xd4\x46\xd9\xda\x46\x96\xa9\x53\xdb\xb2\xcc\x32\x8a\x5b\x96\xad\x54\xdd\xda\xb2\x16\x25\x8b\xca\xb7\xb0\xab\xdf\x29\xdd\x99\x56\xe7\x84\xa2\x4c\x41\x7f\xca\x63\x48\x91\x5f\xba\x71\x21\x33\xed\xf9\xa1\x70\x62\xd0\x29\xdd\xf2\x2e\x28\x7c\x59\xb8\x46\xe5\x17\xb6\xbc\x15\xfa\x76\x4e\x45\x3b\x1f\x99\x9c\x8f\x4a\xda\x12\x99\x56\xd5\xec\x4c\xbc\x89\x59\xe5\x52\x25\xe0\x78\xd0\x5b\x93\x8c\xb2\xe6\xc1\xda\x40\x6e\x31\xcb\x51\xc7\x77\xc8\xcc\x51\xe5\x09\x34\x78\xd6\x4e\x34\x3e\x74\xc4\xa6\x29\xff\xe0\x24\xe7\x7f\x8b\x1b\xd7\x36\x85\xb0\x92\xdd\xff\x5c\x21\xd1\xb5\xb5\xbe\xbd\x2b\x32\xe4\x42\xca\x7b\x87\x9e\x89\xcd\x23\xd1\x81\x26\xa6\x3b\xb2\x3f\xee\x81\xbd\x95\x93\xa9\xa3\x5c\xad\x73\x51\xdf\x8d\x65\x96\xeb\xe8\xf3\xb1\x66\x6e\x0d\xb3\xda\xa9\xa2\x74\x95\x11\x25\x1d\xdd\x7c\xf9\x06\xa4\x75\xd0\x24\xba\x97\x5f\x21\xe7\x60\x96\x4e\x58\xc3\x71\x1c\xb1\xa3\x38\xca\xfc\x30\x42\xe3\x40\x2b\x3f\x2b\x07\x7d\xde\xf1\xcb\x6c\x41\xba\x13\x52\x8e\xf2\x24\x50\x29\x45\xbd\x03\x85\xf2\x7f\xe2\x74\x43\x47\x0d\x3b\xbd\x6c\x39\x25\x97\xc7\x15\x30\x72\x6b\xee\xaf\x57\x7c\xbd\x5d\x56\xd4\x86\x6a\x3e\x88\x57\xc0\x42\x65\xe6\x17\xc7\x09\x2e\x6b\x91\x33\x88\xab\x90\x60\xe2\x3d\x38\x57\xd3\x2b\x37\x85\x92\xa4\x79\x65\x07\xc7\x56\x39\xb5\x9c\x52\x7c\x60\x69\x9e\x92\x57\xe6\x8c\x09\xa5\x60\xac\x70\x6c\x8b\xeb\x1d\x7a\xeb\x43\xf2\x4e\x3b\x3f\xb2\x71\x34\x5e\xa0\xa8\x94\x48\x0e\xcf\x33\x05\xa7\xc0\x74\x36\xf7\xd4\x57\x2f\xb2\xf8\x52\x6f\xee\xa9\x36\xe9\xf1\x3d\xf5\xd3\x7c\xf0\x05\x0a\x98\x4f\xfc\xa9\x6a\xd9\x33\x9c\x82\x30\xad\x74\xff\x20\x2f\x09\x58\xd0\x58\x7b\xbb\xe2\xd3\x34\x35\xfa\xd6\xdb\x81\xea\x74\xf2\x4a\x51\x42\xb9\x17\x29\x5f\xec\x66\x10\xa6\xd3\xb1\xbf\x10\x9c\xb8\xa6\x35\x9c\x2c\x60\x7a\x52\x73\x3c\x69\xfb\xc1\x70\x9b\x56\x84\x32\x5f\xbd\x2b\xcb\x16\xef\x7d\x95\xe5\xc9\x97\xeb\x38\x05\xb3\xf8\x5e\xc1\x5b\xf3\x44\x79\x4b\xf2\x59\x56\xf4\x77\xd1\x1e\x2d\x72\xb6\x79\x60\xee\xa5\x94\xd5\xa7\x37\xed\x78\x7d\x71\x16\x55\x5f\x48\x6e\xbc\xdc\xa0\xd3\x02\xd3\xd2\xaa\x9c\xcb\xa8\xcb\x38\xe7\x95\xc3\xf7\x93\xc4\x5f\xbc\x1f\x39\xa5\xc0\x8d\xc7\x54\x97\xe9\x70\xe1\x35\x55\xa9\x62\x2a\x47\xab\x50\xe3\x16\xa4\x90\xef\x24\xe2\x9e\x27\x4d\xff\x6c\x93\x26\x74\xfc\x8c\x67\x99\x91\x2c\x7f\x52\x38\x6e\x7a\x54\xb1\x96\x86\xc8\x0b\xc6\xc2\x63\x98\xa6\xc6\x5e\xa3\x13\xf8\xe9\x19\x5e\xa9\x73\x3d\xf1\x28\xbf\x3f\xc6\x5a\xba\x4c\xfd\x00\xac\xd1\x50\xae\x89\xc6\x6c\x1b\xa4\xbc\x2a\x47\x0e\x5f\x0c\xc5\x3a\x52\xbd\xdc\x88\x78\x51\x1c\xb0\xeb\x28\x20\x27\xff\xf2\x06\x06\x71\x8c\xfa\x4f\x1a\x52\xf5\xa5\x96\xed\x9e\x90\xc1\x80\x0d\xc3\x00\xbd\xa8\xc2\x4c\x98\xa9\x90\x30\xe1\x83\x00\x97\x61\x76\x26\xcf\x11\xc8\xb0\xa6\x29\xfb\xf2\x8c\x45\xb4\xb2\x15\x8b\xaa\x07\x05\x1b\x77\x69\x2c\x65\xcc\x8e\x1a\x3c\x8b\x16\x61\xcd\xb0\x5d\x19\x1a\x98\xd2\xcd\x07\xac\xe5\x11\xb6\x67\xa9\x9a\x76\xab\x85\x29\xa4\x81\xd7\xd6\xa4\xb2\xa4\xaf\x9c\x5e\xa3\x44\x29\x4f\x42\x2a\xac\x51\x44\xbf\x5b\x6b\xc4\x64\x8a\xd0\x17\xbd\x7e\xd9\x50\xa9\xc9\xcb\xce\xe0\x4b\xc1\xab\x72\xa2\x95\xd5\x10\xd1\xdf\xe1\xeb\x15\x92\x22\x63\x93\xa9\xeb\x72\xb3\x92\xa8\x72\xf0\xa0\xe4\xa9\x4f\xed\x6e\x93\xbb\x8a\x58\x1b\x8d\x77\xa9\x17\x36\xdf\x86\x69\x76\xe4\x0f\xcf\xaa\x6e\xb2\xb4\xb7\x9f\xba\x52\xa7\xf9\xc3\xf3\xa3\x31\x45\xfd\x2f\xbd\x85\xb3\xb3\x6d\x16\x7d\x49\x51\xbe\xab\xca\xee\x98\x65\xff\xcc\xaa\xee\x41\x3d\xd9\xd9\x35\x0b\xfe\xc5\xaf\xba\xd7\xf4\x64\xe7\xb1\x59\xf0\x53\x0d\xc4\x27\x14\x05\x0d\xdf\xaa\x3e\x42\x1b\x27\x05\x9f\xaa\xc1\x10\x69\x41\x4a\x9a\x2f\x46\xd3\x2c\x4e\x18\x9c\xb3\xc5\x26\x6e\x04\xc0\xd4\x0f\x93\xb4\xf9\x00\xe8\xa1\xeb\x69\x12\x5e\xf8\x19\xc3\x6f\xc3\x15\x9c\xf2\xfc\xc4\x9f\xc0\x57\xdc\xa4\xbe\x82\x1e\x8b\xb2\x24\x64\x69\x1f\x9f\xfb\xce\xc1\xc3\xb7\xd8\x79\xc3\xb9\xd7\xb1\x3f\x71\x94\x1c\x51\x53\x07\x5f\x0f\xfc\xcc\x57\x37\x7b\x8f\xf9\x2f\x74\xe2\x8e\xd8\xa5\x1e\x4e\x55\x4b\x5d\xe8\xc7\x70\x5d\xe2\xc1\x3b\xfe\x4d\x51\xcd\xb7\xe0\x45\x10\xc0\x84\x65\x67\x71\x80\x78\x9c\x60\xa3\x27\xcd\x07\xf8\xd7\xb8\x78\x33\x14\x43\xaf\xf9\xe0\x20\x5f\xa6\xb7\x46\xa1\xdd\xd7\xfa\xb2\x1c\x31\x41\xa1\x60\x93\xae\x07\xc9\xb1\x2f\xe6\x9f\xe1\x38\xcb\x21\x2f\xe6\xa7\xba\xfe\x27\x5e\xbf\xf8\x7a\x29\xd6\x28\xb9\xbd\x5b\x1b\xdc\xd8\x7a\x2a\x75\x1d\x9f\xd1\x0f\xf0\x96\xcf\x60\x16\x8e\xb3\xcd\x30\x12\x94\x82\x44\x5e\xdd\x48\x9b\x1c\x1e\xfa\x02\xcc\xa2\x21\xba\x87\x43\x17\x5e\x0b\xc0\x1a\xe3\x03\x03\x60\x16\xf3\x05\x42\x3c\xbe\x60\xf8\xdc\x7b\xc0\x86\xf1\x64\x1a\x8e\x59\x20\xef\xc1\xc6\x23\xa5\x3a\x6c\xf8\x9f\xe3\x4f\x38\x59\x8a\x95\x23\x36\xd7\xcc\x44\xa2\xc1\xd4\x71\x74\xc1\x38\x19\x4e\x78\xa9\x13\xde\x60\x98\xa5\x12\xfa\x30\x0e\x58\x29\x07\x0b\x8e\x95\xc8\x5f\x61\x1b\xc8\xaf\x8a\x23\x39\xa3\x12\xf0\x26\x56\x21\x8b\x3b\x85\xaf\x34\x89\x5f\xc1\x47\x91\xc0\x3b\x96\x6b\xcf\x60\xec\x2c\xfe\x84\x79\x38\x02\xc4\xd8\xe8\x28\xcc\xdb\x7b\xa8\x6e\x83\xa0\x34\x67\xc9\x42\xad\x12\x8c\xab\xa2\x92\x12\xe4\x7b\x8f\x60\xa4\x4b\xed\xd0\xc7\x78\x06\x0c\x75\x6c\x05\x08\x6a\x6a\x03\xd6\xd6\xaa\xaa\x5d\xe9\xf5\xc4\xda\x1a\xca\x4a\x81\xc5\x64\x2f\x4a\xb8\xac\x36\xa4\xf1\x52\x8a\xf9\x13\xab\xd5\xcb\xdb\xdb\x52\x81\xa2\x1d\xf5\x29\x9e\x54\xaa\xda\xc7\x52\x31\xa2\x8a\xa9\xd6\xa0\xdb\x18\x8f\xcc\x62\x53\xf4\xfd\x4a\x19\x0c\xc2\x6c\xe2\xa7\xe7\x29\xca\x02\x29\x2e\x9e\xe5\x27\x61\x6a\xb2\xe8\xd1\xfb\x77\x1f\x5e\x7c\x7c\x75\xfc\xe1\xc5\xc7\xcf\x6f\x5e\xbc\x3d\x7e\xfd\xf6\xc5\x9f\xa1\x0b\x22\x7a\x9f\xcc\xfd\xf2\xd3\xfb\x8f\x2f\x5f\x7d\x7c\xf5\x52\xe6\x77\x34\xe7\xbe\x80\x74\xca\x86\x21\x3e\x5d\x1f\xc0\x05\x4b\xf0\xbe\x4f\x3c\x82\x93\x81\x9f\xb2\x37\xe4\x3c\xf9\x92\xb1\xe9\x09\xa2\x82\x7d\x4f\xc9\x0e\x4a\x67\x53\x8c\x44\x30\x22\xfd\x3b\xf5\x13\x34\x8b\x02\xc6\xa6\x16\xb2\x35\x9c\x2f\x74\x35\x42\x45\xbe\xa7\x2f\x41\x08\x3f\x61\xcd\x92\xd2\xb8\xc5\x80\xa5\xe9\xab\xb6\x0e\xad\x17\xae\x24\x41\xb1\x9a\xfc\x1e\x8d\xfd\xd3\xb4\x09\x9f\x18\xb3\x7a\x4b\x3d\x9d\xf0\x69\x28\x60\x99\x1f\x8e\xd3\x66\xb9\xb4\x52\x6c\x83\xf0\x77\x81\x8d\x25\xb3\x32\x2b\x4f\x89\x12\x30\x8c\x37\xfa\xba\x4c\xf2\x03\x96\xb1\x64\x12\x46\x8c\x97\x09\x2f\xfc\x31\x8b\xb2\x94\x0f\x0e\x72\x84\x0d\x8f\xce\x46\xae\xc4\xac\xfa\x39\xf1\x87\xe7\x29\x5f\x45\xf0\x21\x65\x01\x9c\x20\x95\x4e\xf0\xe6\xc4\x09\xd2\xed\x44\x4c\xba\x69\x4e\xb1\x70\x93\x94\xf9\x91\xd6\x2c\x27\xdc\x58\x3b\xe1\xfa\x22\x93\x23\x94\x82\x9f\x98\x48\x79\xe4\x56\x7f\x82\xce\x88\x27\x39\xdd\x83\xfd\xc3\xb1\x4b\x1d\xac\x2d\x76\x89\x3c\x39\x10\x9e\x41\x49\x4f\x93\xc3\xa3\xbe\xe8\x69\x38\x4c\x3f\x08\x1e\xeb\xaa\x31\x7c\x54\x2a\x03\x72\x7b\xc4\x4f\x92\xb7\x74\x12\xd6\x25\xc4\x73\x2f\xcf\xc6\xd9\x99\xca\x47\x9c\xe4\x7d\xd1\x07\x42\x41\x6a\x00\x0f\xbb\x46\xe9\x47\x8f\xe0\xa1\xa3\xd1\x79\xf4\xc8\xc8\x7b\xae\x5b\x75\x73\xc1\x30\x84\xaf\x26\xe9\x3a\x6e\x09\xa4\xe9\x6c\xc2\x60\xb8\x18\x8e\xc3\xa1\x18\x54\x49\x59\x7f\xdc\x7c\xa0\xb6\x6a\x87\xe7\xe8\xeb\x89\x5f\x7c\x2a\x27\x3a\xa2\x26\x15\xf7\xe9\xb1\x04\x5e\x24\x91\x45\xb0\x3f\x79\x0c\x14\x2c\xd1\x5f\x89\x0c\x92\x97\x1c\x91\x60\x53\x05\xff\x4c\x58\x4a\xf6\xb0\x34\xd7\xd1\xda\x63\x78\xac\xe2\x14\x47\xc0\xd6\x33\x2e\xfa\xff\x5e\x6a\xbd\xba\xaf\x77\x2f\x91\xbe\x84\x6a\x2a\x7b\x23\xb8\x02\x3b\xa5\xb3\x04\xa7\xc8\xfe\x12\xdd\xde\x9c\x46\x5c\x3a\xa3\x38\xda\x24\xa4\xf5\xd2\x97\x13\xed\xf2\x2c\x1c\x33\x70\x36\x36\x28\xf3\x99\x31\x20\x46\x6c\x55\x3f\x49\x7e\x46\xc5\x2a\x58\x83\x5c\x7e\x0c\x47\xb4\x38\x3b\x93\x05\x10\x0b\x51\xc0\x7c\x48\x58\xb1\xad\x7d\x3a\x25\x14\x51\x80\x2e\xd2\x82\x49\x14\xd8\x43\x83\xdb\x1d\xd9\x86\xa7\xd0\x11\x5e\x62\x4a\x46\x04\x6d\x48\x14\x14\x90\x7d\x13\x88\xae\xaa\xc1\x09\x20\xb6\xbc\x11\x10\xf3\x66\x0b\x6d\x91\x0a\x6c\x1f\x9a\x1b\xcc\xf6\x59\xa0\x2c\x63\x6e\x20\xaa\xbb\xdf\x39\x6f\x08\xc5\x35\x8a\xdd\xc1\x0e\xc4\x77\x25\x37\x39\x3e\xb2\xe1\x2c\x49\xc3\x0b\x36\x5e\x48\x9a\x49\xfd\xe2\xa4\xb3\x74\xc8\xa6\x59\x38\xa0\x7b\x5c\x78\x43\x96\x74\xdb\x38\x9c\x84\x59\xea\x36\x55\x07\x38\x47\xe6\xfc\x3c\xd4\x1c\x2d\x19\x48\xd9\x04\x9a\x44\x71\x76\xf6\x26\xef\x90\x07\xfa\x6a\x05\x4d\xdd\x08\xdc\x2c\xfb\xe8\x91\x55\x98\xff\xe7\x68\x56\x22\xb9\xa2\x1f\xdf\xbe\x69\x5d\x56\x3a\x46\xa5\xea\x8f\xc6\xc8\xcd\x23\x65\xb8\x03\xb2\xa8\x39\x9d\xa5\x67\x8e\xc2\xe9\xc0\x2a\x69\xbe\x7a\x7c\xe5\xda\x07\x26\x65\x03\x53\x1e\x23\x51\x5f\x26\x7b\xe8\x98\x07\x9d\x15\x3d\xb5\x30\xb8\x71\xaf\x15\x14\x03\xed\xa5\xb8\xe9\x4a\xea\x0c\xbd\x20\x32\x54\x64\x3e\x47\xeb\x19\x7d\x7a\x30\x1b\x67\xe5\x36\xa7\x31\x7b\x95\x98\x9d\xb5\x4f\x30\x2c\x65\x76\xbe\xf3\xa7\x75\x66\x67\xa7\xf5\x44\xae\xb2\x85\x1e\xe5\xcb\xc7\x2a\xc3\x73\x27\x57\xb6\x66\xf5\xfe\x78\x57\x2f\xca\xad\x75\x79\x24\x0c\xaa\xf2\x85\xf9\x2c\x0a\x7f\x9b\x31\xc3\x00\x59\x75\x59\x4e\x35\x69\x55\x2e\x66\xbc\xaa\xc5\xb8\xe8\x84\x43\xc5\x0c\x3b\xa0\x30\x51\x8d\xe5\x24\x2e\x20\xea\xf7\x32\x5b\xb0\x2f\x91\x35\xa6\xf6\xb2\x95\xbc\x1c\x88\x83\xb2\x19\xc4\xbe\x99\x89\xd5\xfd\x20\x10\x98\x89\x89\x41\x46\x5c\x2e\x5f\xe4\x8b\xce\xf0\x75\xbe\xf8\x34\x56\xd7\x3e\x8e\x69\x49\x06\x17\x74\x3e\xf1\xeb\xb1\x3f\x28\xab\x2f\x56\xef\x7a\xd4\x4b\x17\xe8\x22\xbb\x84\x8d\x6b\x5f\x0c\xc8\xad\xd1\x91\x59\xce\x18\x37\x2f\xc3\x11\xf8\x70\x82\x63\x77\x22\x56\x29\xdc\x74\x3e\x39\x67\x8b\x13\x60\xf3\x30\xcd\x6a\xad\x7f\x69\xb2\x12\xa7\x71\x86\xa0\xaf\x2c\x86\xdf\x66\x2c\x59\x58\xf6\xad\x5c\xef\x9e\xb3\x85\xdc\xd1\xe1\x96\x30\x37\x49\x59\xc4\x17\x9c\x9c\x8b\x38\x5a\xcb\x9b\xb3\x7e\x24\xaa\xe6\x91\xae\x35\x67\xd5\xcc\x80\x1f\x14\xe8\xca\x7c\xf9\x8c\x58\xf9\xcc\x4f\x1d\x9e\x53\xae\x54\x86\x7a\x98\xf2\x43\x51\xfb\x3e\x41\xc9\x50\xbc\x98\x4e\x31\x52\x18\x12\x82\x4e\x0e\x71\x89\x70\x42\xbc\x89\x7b\x11\xc2\xf8\xbf\xd9\x4a\x6c\x12\x07\xe1\x68\x51\xb6\x10\x13\xc2\x66\x4b\xb2\x8f\xf8\xe4\x06\x41\x54\x50\x43\xa0\xf1\x31\x08\x8b\x89\x1f\xf8\xcc\x26\xac\x96\x95\xe5\x3e\x6f\xdd\x8f\x46\xb4\x6d\x65\x9a\xfe\x28\xff\xd7\xc8\x37\xd9\x83\xa2\xfa\x06\xb5\xab\x62\xa7\xa4\xca\x0e\xb4\xf6\x2c\xb0\x4e\xf9\x68\xab\x8e\x95\x0c\x77\xed\xdb\x07\x65\xc3\x5d\xb9\x5e\x3f\x16\x7e\xc0\x85\x85\x7a\x3c\xcb\xf2\x6b\xf5\x30\x63\x89\x9f\x31\x06\xe9\x59\x9c\x64\x67\x7e\x14\x2c\xb3\x4c\xef\x21\xd0\xbe\xcd\x1e\x02\x14\xc4\x17\x2c\xa9\x58\xe0\x4e\x13\x16\x84\x43\x5e\xc8\x5a\xe0\x86\xd1\x45\xcc\xd7\x22\x53\x96\x08\x28\x61\x1c\xd5\x33\x0e\x67\x72\xae\xab\xa9\xa7\x2c\x10\x23\x5b\xc2\x47\xaf\xc9\x27\x5a\x70\x92\xc2\x60\x29\x66\xa2\xbe\xd9\x73\x48\xd9\xea\x31\x61\xe9\x1b\x01\xa5\x55\x58\x32\xf5\xfa\xcb\x70\x1a\xc7\xe4\xa2\x64\x15\x72\xa0\x8c\x5b\x85\xba\x73\x51\xb4\xec\x0b\x76\x52\x4f\xe2\xb4\xb1\xa1\x83\xfd\x58\x66\xd2\x12\x26\x8f\x41\xc0\x12\x8e\xad\x7d\x3c\xe0\x5a\x93\x67\x6b\x1d\x44\x48\x4f\xf8\xf9\xc5\x47\x78\xf3\xd3\xbf\xbd\x3a\xfa\xfc\xe6\xfd\x4f\xb0\xbe\x95\x87\xe6\xc2\x57\x74\x44\x89\xe3\xaa\x93\x05\xe3\xa8\x64\x36\x78\xcd\x95\x75\x95\xb5\xf3\xe4\xa9\xdc\x69\x7b\xc9\x32\x6e\xd0\x8c\x12\xc6\xb5\x56\x12\x62\x64\xbd\x13\x81\xf7\x89\xde\xfc\x4d\x18\x7b\xa5\x37\x1e\x85\xd3\xaf\x4c\xe8\xc2\x1a\x19\x46\x6b\x7c\xcd\x2d\x93\x1f\x3d\x82\x87\xf2\x2c\x29\x8a\x03\xf6\x79\x31\x65\x46\x7e\x2d\x02\xd4\x65\xbb\x7d\x11\x2c\xac\x6b\x21\xf3\xe8\x91\xc4\x66\x22\xb2\x6d\x64\x44\x2a\xc7\x45\x0c\xac\x89\x0a\x25\xd9\x98\x70\xa1\x9a\xc6\xd3\xd9\xd8\x4f\xe0\x28\x9e\x4c\xe2\xe8\xdf\x3e\x01\xfa\xea\xa0\x6e\x39\xb1\xf9\x43\xa3\x48\xe9\x9a\x48\x06\xca\x8f\x1e\x19\xbf\x34\x67\x75\xad\xae\x08\x2c\x7e\x94\x3b\xfd\x24\x07\x25\x1b\xfd\x3f\xce\x46\x23\x74\xde\xb2\x5b\x3c\x44\xd6\x68\x8a\x5c\x7b\x77\x61\xcb\x80\x5b\x38\x41\x40\x05\x99\x9d\xc5\xa9\x38\xd0\xc5\xad\x73\x7f\xc2\x20\xe2\xff\xf8\xa9\xd8\x57\x3c\x19\xc7\x81\x9f\x9e\x9d\x48\x3b\x4e\xe1\x13\xf9\x59\x78\xc1\xde\xa4\x0a\x2f\xf1\x71\x28\x3e\x9a\x61\x5a\x81\x54\xce\x78\xa2\x39\xfa\x84\x82\x9b\x0c\xa8\xae\x54\xc3\x14\xf8\x10\x3f\x27\x6c\x32\x60\xc9\xfb\x11\x1c\x53\x4e\x18\x0d\x19\xec\x34\xb7\x9b\x2d\x32\xb8\xfd\x8c\x9d\xc6\xc9\x02\xde\xfa\xd1\xa9\xa9\x81\xd7\xc5\x14\xad\x67\xe8\x1b\x18\x49\x25\x38\x16\xcd\x23\xf8\x57\x36\xf7\x27\xd3\x31\x13\xd8\x1f\x2b\x12\x38\x5c\x5d\x8b\xcf\x0e\x7a\x42\xad\xf3\x95\x7f\xf7\x39\xc5\x53\x2d\x2d\xfe\x25\x8c\xb2\x3d\xba\x6b\x62\x57\xc1\x06\x1f\xc8\x61\x08\xf5\x00\xe4\x46\xe4\xdb\x37\xad\x11\xca\x2c\x61\x59\xf3\xa0\x56\x1f\x5d\xd1\x51\x47\x9d\x4a\x73\xda\x4f\x76\x5c\xa9\xae\x5c\xb7\xa0\x2b\x6b\x03\xa4\x2f\xb5\x3c\xa4\x7d\x69\x2e\xbe\xc1\x0b\x9a\x96\xca\x15\xdc\x9e\x7c\xab\x8e\x57\xf8\x12\xf9\x49\x55\xc9\x8e\x7a\xd7\x88\xeb\x85\x2f\xd5\xe1\x0e\x9f\xec\xb5\xc5\xe3\x55\x3f\xc5\x01\x6b\xfe\x9a\xc2\x19\x1b\xf3\xb9\xba\x44\x42\x39\xa8\x1c\x96\x0a\xfa\xa3\x47\xea\xbb\x19\x1a\x65\xae\x11\x08\x3c\x9c\x0f\x47\x21\x9f\xe4\x39\xeb\x71\xa5\x67\xcc\xf7\x4b\xc9\xc8\x76\xb3\xf5\xfd\x65\xc4\x40\x74\x39\x41\xd1\x24\xc9\x71\x7f\x8d\xb4\x18\x75\x7a\xfd\x3a\x11\x29\x8c\x89\x35\x4c\x87\x9a\x5d\x9c\x7c\xa6\x0b\xfb\x05\xee\x2b\x17\x26\x2b\x3f\x27\x02\x3b\xcb\x04\x6f\xb6\x96\x96\xca\x3f\x60\x86\x5c\xac\xcf\x43\xce\xfc\x4c\xd8\x8c\xea\x9c\x95\xfc\x71\xb2\x54\x85\x31\x26\xbf\xa9\x51\x9c\x4c\x58\x70\x8b\x23\xd7\xcb\xc4\x9f\x56\x18\xb3\xaa\x01\x61\x06\xe7\xdb\xcd\x71\x8d\xae\x58\xb0\x61\xe5\x91\xb5\x6d\xbd\x72\x3b\xfa\x45\x72\x8a\xb4\xf2\x34\x58\x6b\x89\xa9\xe8\xe8\x27\xa7\xf9\x23\x86\x59\x34\x74\x54\x2d\x2c\x20\x63\x6e\x97\x99\x7a\xa2\xb5\x92\x71\xbb\x9d\xa7\xcb\x52\x66\xde\xe9\x38\x1e\xf8\x63\x61\xe6\x45\xf1\x65\x65\xb0\xd9\x8e\xfb\x00\xc0\x93\x96\xa0\x30\x7f\x2e\xc3\x28\xe0\x75\xb8\xfd\xa3\x66\xd9\x35\x38\x04\x02\x0b\xfb\xa2\x04\x56\xbd\x60\x51\x10\x27\x14\x3f\x66\x12\xff\xbe\xe6\xc1\xda\x25\x1b\x9c\x87\xd9\x5a\x1f\xf3\xd3\xd9\x68\x14\xce\xb5\x5b\x6a\x18\x47\xaf\x13\x7f\xc2\xd6\xa8\x61\x7f\x04\x5d\x6c\xbe\xb7\xc6\xf1\x62\x69\xb6\x06\x1b\xa2\x12\x01\x18\x1a\x45\x86\x7e\x34\x64\x63\xa3\x04\x9f\x90\xcc\xac\x8f\x45\x18\x0f\x46\x71\x62\x86\xa9\x7e\xc8\xdb\x7c\xf4\x08\xe3\x98\x0a\xe4\x73\xb1\x4c\x39\x3b\xe8\x46\x45\x99\x5e\xd8\x87\x0d\x58\x2b\x69\x00\x4c\x14\xed\xd2\x47\x79\x7c\xc5\x92\x42\x62\x5d\x56\xba\xa4\x05\xda\xf8\xc2\x83\x71\xb1\x2e\xc5\x8d\x88\xd7\xaf\xe1\xcc\xbf\x60\x90\xbc\x78\x0d\x83\x59\x86\xa1\xda\x86\x2f\x5e\x3f\x08\x47\x0e\x76\x92\x22\x49\x8d\xf4\xca\x6c\xec\xa7\xf8\xf0\x03\x62\xe1\x41\x18\x18\x3f\x7e\x9b\x31\x5c\x2b\xf5\xfa\x22\x61\xc4\x47\xe9\xa5\xbe\xa5\xd3\x6e\xb5\x5a\xb0\x05\x8f\x5b\x0f\x14\x7d\xf4\x33\x7b\xfe\x78\x3c\x50\x27\x8a\x7c\x79\xe5\x20\x3c\x79\x5b\x2e\x77\xc3\x00\xbd\xff\x89\x2d\xa3\xf8\xd2\xd1\xbb\xd3\x74\xa5\x5f\x3e\xcd\x37\xf1\xe7\x4e\x2b\x8f\xc8\x26\x38\x58\x75\x13\x7b\xe3\xca\xba\xa2\x6b\x58\x7d\x03\x81\xab\x43\xb5\xec\x73\x38\x61\xf1\x2c\x73\x0a\xaf\x5b\x48\x5c\x86\x53\xe8\x12\x01\xe8\xb1\x78\xa7\xa5\x51\xda\xda\x02\xf2\x14\x23\x02\x9d\xb1\x04\xe7\xb1\x69\xc2\x2e\x58\x94\x99\xc5\x24\x11\x52\xf2\x5f\xa4\xed\x9a\x30\x3a\x85\x71\x98\x66\x2c\x62\x49\x6a\x96\xce\x62\xd4\x57\xc3\x59\x92\x70\x2d\x87\x9d\x5c\x4b\xa9\x15\x55\xce\x26\xa2\x0a\x87\x83\xef\xb6\xe6\x43\xaf\x0f\xa7\x45\x36\x96\xff\x71\x8e\x18\x4e\x7b\x61\xbf\x49\x62\x32\x66\x41\xfe\x18\x24\x4b\x16\xf9\x73\x11\x59\x83\xba\xe5\x20\xbd\xed\x03\x11\xf2\x34\x71\x58\xf1\x4c\xa5\x82\xec\x22\x2a\x2a\x83\x2b\x0f\x5a\x6e\xf5\xe9\xca\x83\xfc\xd7\x95\xb8\xf7\x9c\xc4\xb3\x28\xc0\xa0\x63\x62\xe8\xa9\x00\x11\x0a\x0f\x6f\x24\x26\x74\xed\x6f\x1f\x36\x36\x42\x75\x43\x4a\xf6\x65\x5f\x7d\xe9\x1c\x41\x97\x7d\x39\xd1\x6b\x07\x7d\x31\x01\x84\x81\x7e\xac\xc1\xe2\x7e\x6a\x49\xd2\xa0\x64\x68\xcc\x61\xcc\x8d\x8e\x94\x14\x4e\x69\x82\x83\xc2\x62\x83\x54\x3d\xb4\x46\x50\x9c\x1e\xdb\xa7\x4b\x72\xa3\xbc\x30\x1f\x29\x6c\x47\xe2\x44\x6f\x6b\x0b\xfe\x9a\xf8\x53\x08\x23\xf0\xad\x69\xd3\x66\xef\xad\x2d\x38\xa1\x26\x4f\x60\x1a\x67\x2c\xca\x42\x7f\x3c\x5e\xc0\x80\x71\xd6\xa6\xc7\x13\xf0\x95\x11\xcd\xd3\xb4\x66\x40\xb5\x24\x61\x1a\xdb\x23\xfe\x88\xac\x7f\xae\x00\x3d\x18\x45\xee\x83\xab\x1c\xb6\xa2\x8b\x26\xd2\x84\xf2\xd0\x1f\x35\xfd\xe9\x74\xbc\x10\x95\xd5\x13\x0b\x25\x30\xa6\xf1\x78\x31\x0a\xc7\x16\x14\x5a\xcc\x6b\x27\xad\x87\x66\x02\xc8\x13\x19\xd2\xe4\x72\x13\x52\x38\xb9\x8b\xc9\xc9\x9e\xc3\x78\x51\x7f\xa4\x0b\x11\xde\x85\x32\x43\x7f\x84\x2a\xfc\x76\x0b\xa2\x9d\x76\xc9\x3a\x68\x67\x19\x1f\xc0\xeb\xd7\x41\x7f\x66\xd9\x67\xbf\x2a\x60\xfc\xae\xf4\x85\x35\x83\xc6\x56\x5a\x14\xf2\xa0\x2c\x4c\xe9\x10\xe2\x6d\x78\x5e\x55\x78\x67\x47\x6e\x1d\x9d\x50\xd9\x7f\x91\xfe\x7f\x27\x72\xb7\xaf\x64\x45\x44\xb4\x26\x74\xd7\x7a\x62\xcc\xa8\x7e\x7f\xed\xe0\xae\x9d\x1d\x3d\x83\x33\x64\xa9\x7c\x20\xf7\xef\xe6\x10\xa9\x9d\xd9\xf8\x2a\x4a\x7a\x19\x61\x47\xe3\xcb\xc8\xf4\xd5\x90\x80\xed\x10\xf3\x14\x40\x5e\xf6\x24\x17\x7f\x3e\xd7\x44\x18\xf1\xf5\x3e\xef\x83\x18\x9c\x13\x33\x42\x74\x6e\x34\x8e\xb2\x38\xb1\xb0\xb7\x7d\x1a\x09\x80\x7b\xed\x46\xcd\x74\xec\x53\x2c\x77\xbc\x04\x44\xcb\x92\xd4\x03\x5f\xa6\x01\x5d\xe3\x0a\x60\xb0\xe0\x98\x71\x48\x65\xc8\x01\xff\xff\x48\x6c\x41\xf9\x70\xd2\xeb\x29\xb6\xed\xf7\x4f\x70\x4b\x3f\x9a\x8d\xc7\x27\x4b\xaf\x76\x5b\xcd\xbd\xef\xbf\xda\xb5\x89\x71\xdd\x72\x57\x29\xef\xd7\x71\x4c\xda\x72\x5d\x1d\xa7\xe2\xcb\x35\x3c\xe1\xca\x58\xe7\x7e\xe0\xe0\xc5\x63\x50\x5c\xfb\xbf\x8e\xe3\xb2\xd5\x6e\x59\xf1\x5e\xdb\x83\x8e\x07\xdb\xa5\xcb\xe3\xb2\x0a\x5f\x61\x6d\xbe\xb6\x0f\x2d\x0f\xd6\x16\xfc\x2f\xdd\x5c\xaf\x58\x80\x9b\x15\xed\x38\xe6\xe8\x4b\x5b\x52\xd3\x58\xe3\xd9\xd5\xe5\x4b\x01\x0f\xd4\xd5\x57\xad\x93\x64\xe6\xb7\x6f\x86\x06\x94\x89\x0f\xbb\x5a\xcd\xd4\x79\x9a\x89\x60\x45\xa8\x15\x4c\xed\x28\xe0\x48\x2f\x32\x51\xa4\x6b\xbb\x03\xcb\xa0\x31\xc9\xcc\x82\x77\x44\x6f\xe4\x94\x3d\x0e\x81\x70\x3c\x58\x33\x78\x7d\x0d\x03\x6b\x62\x46\xd3\x48\x36\x5c\x30\xc4\xa2\x8e\xc0\x5a\x11\x33\x1e\x3d\xa2\x54\xf3\x7d\x01\xfe\x5b\x38\xe2\x14\xe5\xf8\x08\xdf\x27\xe8\x76\x0b\x52\x5f\xbe\x04\xb6\x06\xa3\x64\x21\x7c\x3b\xcf\xe2\x3b\x7f\x7d\x4a\x59\x1f\x46\x20\x3d\xe8\x82\x9d\xfc\x69\x9a\x94\x25\xff\xc8\x7e\x0f\x71\xbf\xd4\xdc\x95\x5e\xf9\xd9\x93\x7f\xe2\x77\x3b\x30\xce\xfe\xd1\xd1\x97\x8f\x2f\x8e\xfe\xc6\xf5\x0d\xdb\xdc\x11\x14\x18\xce\x06\xe1\x90\xe8\xf3\xda\x1f\x12\x73\x1b\xcf\xab\xe5\x32\x9d\x61\xdb\x83\x61\xc7\xda\x94\xe9\xb5\x3c\xd8\x86\x75\xe0\x59\xf8\xb7\x03\x9b\xf0\xd8\x4c\x68\xc3\xa6\xcc\xd9\x80\x76\xff\xe0\x81\x7c\xeb\x6a\x32\x1b\x67\x0b\x11\x97\x4e\x35\xaa\x12\x1d\x54\xde\xa9\x07\x99\xd5\x1e\xa5\xe2\x7d\x5f\x7d\xcb\x17\x13\x3d\x08\x73\xd2\x4b\xea\x7f\x9d\x16\x27\xd3\xf8\xd2\xc9\x78\x19\x94\x67\x57\x46\x72\x32\x80\x24\xcc\xc3\x25\x5f\x1e\x4a\xc2\x60\x03\x33\xa8\xa6\xee\x80\x41\xa0\x0a\xba\x95\x51\xcc\x78\xc9\xcc\x3c\x0f\xa5\x8e\x71\x8b\xb4\x8a\xec\xc2\x05\x53\x80\x29\x23\x94\xdc\xf2\x12\xf8\x05\x0c\xb7\x00\xc3\x0b\x76\x54\x8e\x69\x69\x81\x3b\xc6\x19\x74\xa4\xb1\x0f\xb2\x78\x6d\x20\xb0\xa5\x46\xb8\x30\xc6\xa1\x38\xef\x75\xc5\x2e\x41\x1b\x83\x6d\xb5\xfa\x95\x54\x53\xf8\xe4\x08\x47\x9b\x05\xc3\xd9\xd8\xcf\x18\xf5\x6b\x73\x40\x84\x9b\xa1\xd2\xf9\x89\x5d\x66\x71\xb4\x96\x0a\xab\x95\x18\xc1\xd6\x33\x15\xea\xc7\x08\x75\xab\xd3\xc5\xea\x49\xa9\x8a\xe3\x31\xfa\x19\xe7\x9f\xb1\xc3\xf5\x54\xaa\x94\x07\x2f\xe5\x7a\x70\x7c\xce\x16\xb4\x92\xc5\xaf\x67\x58\x9b\x7e\xe8\x75\x2c\xaf\xd8\x3b\x16\xef\xe0\xe8\x87\xef\x30\x45\x85\x75\xe7\x4d\xe3\x1b\x90\x58\x5a\x07\xa6\x5c\xa8\xb4\xb6\x4a\xc3\x67\x21\x31\xad\xa3\xcb\xa9\xb4\xed\x3e\xc5\x54\x20\x3f\xf2\xd3\xd4\xdc\x66\x6a\xe7\x9f\x0f\x17\xad\xe5\x1e\x02\x95\x97\x86\xf7\xd5\x02\x1b\x51\x6b\x35\x5b\xda\x7b\x73\x51\x48\x41\xb4\xda\x56\x19\x95\x52\xee\xf4\x49\x8d\xe1\xcd\xcd\x42\x53\x9d\xdd\x42\x5b\xed\x5c\x5b\xb9\x42\x4b\x37\xb6\x19\x46\xc5\xf6\x76\x3a\xf7\xd5\x37\xbc\x89\x7d\x93\xf6\x5a\xcd\xdd\xbd\x1b\xf6\xaf\xbc\xcd\xeb\x87\x6f\xb5\x26\xe5\x2b\x62\x2a\x57\x47\x74\xb9\xf4\x93\xc8\x75\xc4\x53\x38\x6b\x3d\x53\xe2\xfa\xfb\x5a\x0a\xe4\x5d\xe7\x01\xc3\x45\x49\x3c\x82\x35\xd8\x80\x35\xbc\xcc\x0d\x7f\x17\x7c\xf8\xf7\x35\x0f\xfe\x8e\x3d\xd3\x5f\x9b\x61\x64\xfc\x88\x67\x19\xff\x85\x75\xff\x6e\xd2\x80\xa7\x72\x0b\x8e\xf9\x7c\x79\x8b\x91\xf9\x03\xf8\x21\x5d\x23\x71\x36\x43\x4b\xf0\x2e\xe6\xd1\xef\xcd\xdb\x1e\xcc\x3b\x1e\x2c\xda\x1e\x2c\x3a\xfd\x26\xbb\x60\xc9\xc2\xd0\x8a\xd1\x6c\x92\x37\x58\xc9\xa0\x8c\x66\x13\x3a\x22\xa0\x8b\x40\x68\x4e\xf2\xb4\xe7\xe2\x4d\x60\xfe\xfd\x8c\x56\x1e\x18\xe1\x6b\x29\x0a\x71\x6c\x16\x12\xa3\x0e\x27\x16\x9f\xfc\xdb\xfd\xfa\x1e\x0a\xe5\x32\x9c\x25\x17\xec\x17\x7b\xaa\x70\xa8\x7f\x48\x06\x55\xe6\x6f\xb9\x32\xd4\x77\x55\x26\x60\xc9\x91\x04\x55\x3e\x7d\xe5\x80\x26\x7e\x74\xca\xe4\x8d\x06\x1d\x5e\x4b\xa5\x9a\x0b\x11\xd2\x5a\xb4\x42\xb4\x82\xc8\x09\xea\xb6\x0b\x6f\x8e\x50\xd9\x67\xe6\x06\xba\x28\xdb\xb2\x9e\x3d\x11\x89\xca\x33\xe9\x4a\x11\x66\x50\x98\x1e\x28\xc5\x39\xb6\xa6\x5a\x74\x06\xca\x38\x56\x70\x08\x6d\xd8\x87\xe3\x4c\xcf\xad\x73\xe8\x82\x8c\x59\x5d\xf6\xf2\xe7\xde\x01\x6c\x6c\x84\xf6\x1e\x3f\xbb\xf0\xc7\x9f\x91\xd6\x9c\x9a\xce\xdc\x85\x4d\xb0\xa2\x15\x07\x2c\xf9\x19\x2f\x1d\x29\x92\x3b\x73\x3b\x10\x12\xda\x55\xfe\x20\x75\x08\xd6\x26\x37\xd5\x9e\x69\x4b\xf3\xdb\x37\x09\x43\x27\x96\x45\x32\xc2\x51\x77\xe6\xc5\x78\x31\x73\xdc\xc3\x53\x03\x35\x87\x4d\x81\xf5\x96\x00\xec\x96\xd1\xd8\x82\x47\x74\x26\x8a\x36\xc3\xf4\x53\xc6\xa6\x53\xa2\xb6\x0a\x20\x2f\xaa\x51\x19\xc3\xb8\xab\x5b\x52\xa8\xe4\xdc\x9c\x4e\xe9\x8e\x3e\xd5\xa1\xe4\x92\x09\x1d\xc3\xee\x3e\x7a\x64\x4c\xc8\xad\xbe\x7d\x15\x05\x0e\xed\xcc\x7d\xf8\x7a\x25\x99\x5a\x44\x1f\xff\x53\x9a\x85\xa3\x11\xc5\x66\x1a\x85\xa7\x4d\xfc\xa9\x6e\x2c\x89\xbc\x5c\xd9\x5c\x13\xed\x56\x4b\xc4\x53\x52\x65\x24\x00\x99\x18\xf8\x93\x29\xf5\x56\x34\x23\x12\x64\x39\x9d\x5f\xa8\x91\x6b\x6c\xcf\x68\x2a\x07\x44\x25\x67\x46\x3b\x2a\x9a\x19\xa6\x9a\x45\xf2\xbd\x78\x62\x42\xce\x94\x70\xa5\x7a\xbc\xe5\x40\x89\x24\x87\x1b\xf4\xbf\xe0\x3b\xb1\xd9\x2f\x64\xf7\xff\x6c\xca\xdb\x6b\x35\xc4\x9b\x54\x14\x36\xa9\xac\x0b\xeb\x44\x5a\x2d\x7e\xaf\x5f\x6a\x0a\x71\x38\xb0\x2e\x69\x62\x99\xbf\x3f\xab\xfc\x0d\x70\x24\xfc\x4d\x55\x9b\x03\x0e\x32\xd8\xc2\xc3\x3c\xab\xe2\x2f\x26\x60\x59\x42\xac\x49\x7e\x31\x2e\x66\x29\x79\xc4\x3a\x0a\x5f\x43\x24\x1f\x3d\x02\xb3\xd0\xcf\x6e\xa9\x68\xca\xa5\x9d\xa0\x4d\xab\x5f\xf2\x2a\x50\x8f\xb7\xe1\x61\xb7\xfa\x5a\xd0\x04\x71\x2d\x49\x93\x7b\x28\x32\x0f\xc7\x52\x8c\x91\xba\x9f\x87\x59\x79\xe1\xab\x58\xe6\xab\xe4\x9c\xf0\x51\x7a\x99\x41\xdd\x59\xce\xa2\xee\x08\x93\xba\xa3\x6d\xea\x8e\x30\xaa\x3b\xe2\x67\x89\x59\xdd\x29\xda\xd5\x1d\xdb\xb0\x56\x61\x0f\x85\xb9\xab\x0d\xe4\x92\xb0\xaa\x32\x4c\x4d\xce\x52\x16\x91\x3e\x73\x86\xb2\x65\xbb\x56\x5b\x60\x15\xc6\x60\xb9\x49\x5a\x61\x82\x4b\xed\x6a\xae\x5d\x72\x21\xa5\xa9\xa6\x08\xee\x5a\x51\x53\x6a\xc8\x9b\xda\x70\x34\xc8\xfd\x7d\x18\x85\x49\x9a\x69\x4f\x94\x82\x21\x57\x61\xb1\x99\x36\x9a\x30\xd0\x0a\x16\x9b\x36\xfc\xf0\xe2\xf0\xdf\x45\x97\x4c\x63\x6e\x09\x6b\xee\xba\xb0\xb9\x39\xcb\x8d\xca\x1c\x54\xd9\x82\x4b\x92\x01\x8f\x7f\x34\x2d\xb4\x7f\x4d\x42\x3d\x97\xf1\xac\xae\x33\xd9\xe4\x23\xf9\xf8\x9a\xc9\x55\x21\x22\xcc\xce\xed\x6f\x80\xc9\x88\xdd\x55\x4f\x1b\x4b\xcf\xbe\xf8\x82\x25\x1f\x59\x5a\xe5\x0c\xbd\xd7\xda\xd6\xb7\xbf\x8c\x63\x9a\xf2\xb2\xc6\xed\x2f\xba\x13\xcf\x39\x36\x9c\x4c\xe9\x06\x09\x39\x31\xd0\xad\x82\x84\xa5\xd9\x09\x5c\x9e\x85\xc3\x33\x08\x62\x86\x4f\xa1\x5e\xf8\xe3\x10\x5f\x63\x8e\xb9\x86\x62\xc9\x90\x19\x5a\xe5\xe6\x6e\x57\x78\x6a\x0a\x3e\xf0\x26\x69\x3f\x83\x65\x2c\x81\x2c\x2e\xbd\xd2\xdf\xc3\xd8\xbe\x5d\x0e\x40\x68\xb2\xcd\x36\x5d\x4e\xc0\x0c\x98\xc6\x22\x80\x96\xb8\x26\x64\x43\xbd\xad\x9f\x16\x27\x18\x1f\x0d\xe1\xa8\x85\x4d\x5a\x3b\x45\xc6\x28\x38\x72\xe8\xcc\xc2\x9e\x1a\x78\x97\xae\xa7\xca\xe8\x18\x65\x9b\xd4\xb2\xb5\x92\xfd\xe9\x65\xee\x6e\x5d\x7f\xb6\xfa\x3a\x4e\xde\x5f\x46\x95\xaf\x6b\xcb\x98\x40\x74\xc6\xf1\xa3\x9f\xb2\x57\xfe\xf0\xac\xb2\xf8\xde\xd2\xdc\x35\x8a\x13\x0e\xe9\xa4\xec\xa6\xca\x8d\xae\xa9\x7c\x53\xb7\xca\xe2\xf1\x98\xd1\x58\xe1\xd5\x32\xfd\x73\xb9\x5b\x2b\xaa\xf1\x9b\x5d\x5a\x51\x78\xa8\x03\x34\x8d\x81\xb8\xf9\x24\x69\x2f\x48\x69\xd3\xd6\xd1\xa3\xe2\x96\xb9\x5d\xca\x8a\x25\x1c\xb1\xcc\x15\xb2\x6b\x54\x92\x38\x82\xaa\xba\x77\xb1\x77\xdd\x29\x69\x3a\xa3\x37\x77\x71\x18\xe9\xf8\x83\x6e\xd2\x72\x3d\x67\x84\xc4\xf0\x20\x6c\xb2\x26\x9c\x74\xbb\xdd\xda\xeb\x69\x77\x7b\x70\x39\x2a\xc3\x0f\xcf\x22\xcb\x71\xac\xb9\x0d\xc8\xed\x3b\x5e\xfb\x08\xcb\x73\x90\xe6\x32\xda\x5c\xec\xe2\xa4\x47\x5f\x8f\x1e\x81\x3a\xe5\x53\x87\x70\xe5\x67\x53\x79\xe8\x25\xc3\x7d\x77\x57\xc8\x26\x7e\x36\x3c\x63\xa9\x3c\x96\xa2\x9b\x64\xc2\x23\x40\xdc\xf0\x93\x84\xc3\xd3\xdc\xbb\x19\xdb\x9a\x9b\x9d\x53\xe9\x12\x90\xc5\x70\xca\xb2\x66\x8e\x25\xd2\x64\xf8\x73\x91\x2b\xb0\x17\x4b\xab\x77\x4e\x8b\x2a\x1d\x2f\xe8\x51\x18\x61\x7c\xa5\x5d\x36\x5e\xee\x99\x6b\xfb\xec\x70\x0b\x48\xfa\xed\xd8\xc7\xab\xc5\x13\xdb\xdc\xf2\x82\xaa\x89\xd7\xdb\xbb\x5d\xdd\x67\x15\x88\xc0\x51\x49\xf6\xaa\xf9\xdb\x37\xf5\xf0\xbc\x60\x35\x81\x54\xad\x47\x70\x45\x9f\x4b\xf8\xee\x76\x17\xc1\x0c\xa7\x9e\x2a\x2d\xb3\xf3\xd4\x50\x33\x7f\x66\x19\x0d\x1a\x8d\xb3\x9f\xc1\xc9\xd4\xcf\xce\xc8\x51\x82\x3a\x76\xd2\x84\x37\x6a\xaa\x8f\xc7\xdc\x98\xa3\xc2\x61\x8a\x4e\x18\x8a\x34\x27\x1e\xb9\x8c\x08\x93\xfb\x67\xa5\xb6\x88\xe6\x2c\xe0\x34\x0b\xb3\x14\xa6\x63\x7f\xc8\x56\xb8\x6e\xf0\x24\xef\x80\x41\x84\x2f\xbb\xf4\x2c\xd8\xe1\xb3\x75\xc7\xbe\x78\xed\x99\xe6\x12\x29\x22\xbc\xc7\x58\x05\x3f\x96\x13\x92\x9e\xd9\x4b\xe3\xde\xbd\xee\x2c\x5e\x7f\xd6\xc4\xc9\x51\x2f\x1f\x1f\x68\xdd\x96\x21\xbb\x70\x99\xd3\x87\x76\xc0\xc1\x37\x76\xd7\xfc\xb5\x7d\xe8\x7d\x85\xb5\xc1\xda\x3e\xff\x39\x5c\xdb\x87\x6d\xb8\x82\xab\x3e\x3e\xba\x2b\x3c\x2c\x30\x82\x8d\xf0\x2a\x59\xf3\x7b\xad\x7e\x73\xd0\x1c\xae\x99\x6e\x15\xdb\xa5\x65\x7b\x6b\x3e\x5f\xdb\xb4\x30\x78\x3b\x86\x5b\x5f\xeb\x5f\x5f\x6b\xcd\x47\xf0\x1e\xac\x09\x62\x59\x2d\xa9\x44\x5b\x3b\x98\x00\xf8\x78\x78\x60\x52\x5a\xef\x7c\xa9\x2b\xa1\xb6\x06\x80\x43\x43\x56\xf7\xa5\x2c\x58\x10\x8b\x31\x2a\x0a\xfb\x3d\x66\x93\xb0\x5f\x7b\xad\xf3\x94\x95\x99\x8f\xb7\xbf\xa2\x34\xf4\xd3\xec\x83\x9f\x55\x59\x83\xdb\xbb\x72\x01\x93\xc5\xff\x8b\x55\xad\x72\xda\x3b\xcb\xaf\x48\x4e\x59\x56\x6e\x2f\xca\x00\x9e\x35\xd1\x29\xbe\xaf\x14\x2e\x2f\x34\xb9\x95\x45\x81\x13\x90\x9b\xa6\x44\x65\x49\x70\x87\xb8\x2e\x56\x7e\x6b\xf6\xcd\xe6\x56\xe1\x62\x33\x2f\x5f\x72\x0d\x5e\xf4\x5c\xc4\x01\xc4\x5b\x07\xa5\x97\x95\x95\x10\x8b\x39\x09\xc7\x13\x91\xa0\x5b\xcb\x1b\x1b\x7d\x37\x7f\x2d\x5e\x3c\x6f\xa7\x60\x76\xbb\x0a\xe8\xa1\x04\x68\xdd\x92\xac\x5a\xfd\xfc\xb9\x8c\x7b\x77\x97\xb9\x5d\x74\x9d\xa9\x5b\x77\xaf\xae\xbd\xa7\x1c\x45\xab\x79\xb7\xd3\xd6\x71\x58\x39\x87\x7c\x8e\x6b\xc4\x61\xaf\xb3\xad\xc4\xa1\x7e\x8d\xde\x79\x6c\x5a\xd9\x7e\x9a\xa5\xca\x82\xe5\x6b\x65\xe2\x06\xba\xab\x8e\xe1\x8a\xd7\xe8\x19\xfc\x38\xaa\x0d\x36\x59\x6e\x49\x87\x11\xb7\x83\xb2\xd2\x88\x72\xc2\x7b\xb5\x5f\x26\x25\xdc\x58\x4b\x61\x99\x6b\xfb\x9c\x69\xb5\x90\x68\xdc\x0b\xd1\x35\x04\x6f\x8b\xdb\xee\x79\x67\x68\xe9\x59\x44\x56\x73\x6e\xe7\x48\x1f\x2a\x69\x06\xc4\x81\xcb\x43\x3b\x14\x71\x68\xfa\xb0\x6f\x8d\x99\x23\xc7\x44\xc2\xaf\x0a\xdf\x41\x48\x96\x30\x64\xed\xb5\x29\x3d\xcc\x02\xd6\xf1\xf1\xb2\x9e\x63\x4b\x5d\xa8\x9a\x26\xf1\x90\xa5\xdc\xd8\xdf\x5a\x87\x33\x3f\x99\xc4\xd1\x42\x48\x01\x38\x83\x10\xef\x79\xb8\xb0\xbe\x55\xd6\x66\x33\x70\x4a\xd1\x6b\xf8\x0d\xcf\xf2\x70\x97\x84\xbd\xf4\x93\xe8\x00\xbd\x80\xb6\xd6\x81\xa5\xe3\x30\xca\x20\x8a\x37\x87\x71\x94\xc6\x63\xb6\x0f\x2d\x7d\x09\xf1\x25\xbb\xa0\xd7\xbb\x38\x76\x4d\x16\x5d\x34\x7f\x7a\xff\xf2\xd5\xf1\xab\x9f\x7e\x46\x93\x75\x6d\x9a\xc4\xc1\x8c\xf6\x02\xc5\xb6\x37\x07\x6e\xee\x6b\xf3\xdf\xce\x30\x8e\x02\xdc\xd1\xf1\xb8\xb6\x9f\xf8\x99\x07\xbe\x07\x03\x0f\x86\x1e\x04\x1e\x30\x0f\x46\x26\xa3\xf0\x56\xf5\x6d\x79\x81\x17\x35\x68\xdc\x17\x7b\xf4\x48\x66\xd1\xfe\xa2\x61\xb1\x53\x23\xf6\x94\x6b\xec\x3b\x1b\xb5\x9c\xb5\xb7\xf1\xe9\x97\x2c\x1c\x73\x13\x12\x09\x8a\x81\x94\x58\x92\xc4\x09\x4c\x58\x9a\xfa\xa7\x7a\x87\x6c\xcd\x3e\xac\xa3\x70\x63\xb2\x6b\x76\x1c\xb3\x7a\x0c\xf2\x38\xbc\x0b\x23\xba\x30\xcb\xe6\x18\x3a\x8d\x4f\x98\x43\xbc\xba\x13\x1c\x00\xe7\x26\x5c\xf3\xc4\xd1\xe6\x44\x16\x0c\xd8\x05\xb0\xe8\x22\x4c\xe2\x08\x37\x4d\x71\x67\x94\x6e\xc7\x33\x18\xf1\xc9\x20\xd7\x85\x28\x00\x3f\x20\x4c\xfd\x31\x5e\x08\x1e\xcd\xc6\x38\x3a\x61\x74\x9a\x36\xd7\xf4\xd1\xa5\xf0\xc7\x53\xa8\x52\xc8\x3d\x3c\x67\xe8\xe5\x47\xad\x7f\x90\x2f\xa6\xe2\x6a\x18\x1e\x0f\x56\x67\x89\x32\xcd\x84\xa1\x89\xee\x6c\xfd\x90\x6e\x9d\x9a\xcf\x5d\x94\xbe\x74\x81\xa7\x0e\x12\xfa\xc6\x46\xdf\x7c\xe4\xa2\xec\x95\xaa\x07\x57\xb5\x82\x27\xee\x43\x2c\x2b\xd5\xce\x76\xc9\xd5\x88\xdd\xbb\xb9\x1a\xf1\x7a\xec\x67\x19\xab\xdc\xbf\xdb\x35\x6f\x87\xbf\x4f\x02\x96\xfc\x58\xb9\xdd\xbc\xdb\x31\xca\xd6\xec\x37\x6f\xef\xe8\x4b\x14\x6f\xc4\x5e\xd9\x91\x3f\xae\x72\x23\xdd\xde\xdd\x2e\x8b\x02\x2e\xa3\x8d\xc5\x23\x15\xbd\xc8\x83\x34\x4e\x32\x5a\x84\xf9\xe9\x50\x5c\x4f\x8b\x39\xd6\xc2\xa5\x5e\x98\xb9\x29\xc4\x23\x0e\x2c\x99\x45\x9c\xfd\x80\xf9\xc3\x33\x09\x85\x2e\x0c\x99\x9b\x7e\x67\xc9\x8c\x4a\xc8\x8d\xbd\x26\x7c\x3e\x0b\x95\xf7\x1a\xac\xc3\x94\x25\x9c\xad\x44\x6c\xf2\xc1\x98\x21\x22\x86\x8b\x7f\xc8\x67\x30\x96\xb2\xe4\x82\xd1\xa4\x16\x27\xe1\x69\xc8\x25\x81\x17\x14\x28\x12\x4e\xb8\x21\xa2\xba\xd4\xc4\xb9\x53\x36\x4c\x31\x3e\xe5\x4e\x22\xfa\xff\xc7\x91\xd6\x0f\xfb\xc2\x99\xc2\x5d\xc1\xf3\xbf\x9d\x5f\x78\x1e\xa9\x9e\xdf\xf5\x0e\x69\xb3\xd9\x74\xe4\x76\xca\x37\xf9\xd1\xeb\xbb\x57\xd0\x53\x1d\xec\xf6\x8e\xd5\x43\xa4\xfd\x3e\xee\xac\xd9\x04\xc8\x62\x22\xd9\x60\xb1\x5c\xc0\x1f\xc1\x11\xca\x62\x28\x5b\x63\xce\x52\x7a\xe3\xab\x47\xb7\x0a\xbe\xc2\x1a\x4f\x59\xdb\x87\xb5\x51\xc2\x82\x35\x0f\x00\xd6\xfc\x53\xb6\xb6\x0f\x3b\x7b\x70\xe5\x15\x4a\x0d\xfc\x24\x62\x0b\x7c\xe0\x0b\x4b\x6d\x3f\x2e\x2b\x55\x80\xd5\x5a\x0a\xd6\x0e\x5e\x6b\x80\xbe\x5e\xe1\xf2\x2e\xfd\xb8\x70\x10\x6b\x0f\x7a\x7a\xe7\xc8\x98\x63\xe3\x26\xcf\x3e\xa0\xf7\x76\xd4\x7a\xd4\xbc\x51\xd3\xeb\xe9\xb6\xb6\x1f\xf7\xf9\x02\x58\xff\xde\xc1\xdf\x02\xe3\x9d\x3d\xeb\x57\x0b\xc7\xa5\x14\x15\xea\x85\xc0\x7d\xb9\x96\x77\x72\x2d\x3f\xce\xb5\x65\xe3\xd1\x57\xdb\xdf\xd4\xb2\x71\xc0\xa1\x75\xa0\x66\x47\x4f\x33\x8e\x9e\xdf\x0d\x6e\x2d\xbf\xb1\xd0\xeb\x9b\xf7\x15\xd4\x1a\x48\x81\x52\x0b\x21\x82\xa7\x5f\xcc\xc4\xc5\x8a\xa5\xd2\xca\x71\xe9\xf1\x6e\xe9\x5f\xed\xbe\x32\x47\x35\x9f\x77\x25\x1a\xda\x51\x4a\x35\xd4\x29\x69\xa8\x1a\xb8\xf9\xab\x53\xd1\x94\x59\x3b\xbf\x10\x33\x34\xbf\xd5\x1d\x63\xf6\xd0\xad\x7b\xd0\x76\x3d\xc0\xc8\x12\x57\xa5\xa7\x0f\x34\x6e\x25\xf6\xef\xed\xe3\xb0\xb3\xdf\x2a\x43\x61\xee\xaa\x09\x07\xd5\x44\xcd\xa5\xbd\x76\xab\xad\x27\x27\x61\x4b\x94\x2f\xdd\x5a\xb9\x9b\x80\xab\x1d\x79\x70\xfd\x74\x1a\x5e\xb0\xc8\xf0\x13\xe4\xca\x9d\xee\x56\x47\xfa\x10\x89\x5b\x0a\x4b\x2f\xcb\xd4\x0d\x56\x5d\x5f\xec\x7a\x8a\x46\xf2\x7b\x7c\xb4\xb6\xae\xa8\x4a\x99\x71\x82\x1b\xeb\x55\x10\x8c\x8d\x90\x12\x10\x22\xd7\xae\xbc\x7c\xc4\xf0\x6b\x29\x43\x0a\xb4\xf6\x98\xc5\x12\x13\x3b\x14\x5a\xe1\xc2\xac\x3a\x5b\x91\x1b\xde\xd7\x5c\x8e\x12\x57\x45\xc5\x4a\x01\xa1\x1e\x18\x7e\x0b\x60\xf8\x8f\x2a\x8b\xf1\x50\xad\x45\xf1\x9e\x96\xc4\x81\x44\x9a\x43\x70\x2c\xec\xe4\x0d\x17\x33\x84\xb3\x06\x2e\x5c\x5d\xf4\x36\x89\xba\x53\xa7\x1e\x5f\xcb\xf9\x48\xfc\x26\x5a\x94\x51\xab\x41\xdf\xe5\x32\x84\x5e\xf4\xb4\xfc\x68\xc9\xa4\x68\x89\x24\x2f\xe3\xd8\x60\x1e\x2b\x5d\xb3\x67\x57\xf0\x21\x58\xc5\x6f\xa0\xe2\xf8\xaf\x24\xde\xff\x7a\xf1\x7d\x80\xf2\xf2\x2b\xde\x74\x3c\x45\x83\x95\x2f\x8c\xfc\x48\x06\xd0\xbf\x96\x6b\x71\xdf\x2a\x53\x9b\x0f\x18\x76\xb8\x78\x2e\xf8\x5c\x86\x62\xaf\xdc\xfa\x2a\xdb\xf9\xba\x9b\x63\xff\x57\xf3\x2c\x61\x93\xd9\xa4\x72\x57\xf6\xb1\xb1\x18\x78\x5b\xa9\x1c\x77\x65\xb1\xeb\x7d\x59\xcc\x47\x53\x26\xd3\x59\x26\x2c\x69\xbe\x24\xe5\x78\x10\x49\x38\xcf\x88\x18\xa1\xf0\x46\x7d\xf3\x71\x60\x93\x69\xb6\xe0\xca\x0c\x09\xbe\xf0\x72\x07\x3b\xe6\x21\x4e\x99\xf9\x9c\xb7\x97\x73\xe6\xb4\x32\x9f\xdf\xf9\xd9\x59\xc1\x70\x2e\x0d\x8f\x5a\xb4\x93\xab\x36\x7d\xad\x2e\x96\x07\x83\x9a\x84\x91\xd3\xdb\xc1\x7b\xab\x7b\x1e\x3c\xb6\x6c\xaf\x8e\x5d\xca\xca\x53\x04\xc8\x9d\x5f\x86\x91\x08\x83\x6d\x72\x1d\x25\x91\xcb\xad\x0e\x6a\x49\x8a\xe6\xd0\xe2\x0a\x19\x3e\x53\x8e\xaa\x27\xd8\x80\xca\x5e\xbb\x6d\x3b\x09\xa3\x12\xc6\x5d\x35\xc0\x6d\xbd\x5e\x19\xff\x93\xeb\x95\x31\x4b\xd3\xd5\x95\xca\xdb\x6b\x95\xca\xb3\xeb\x94\xca\xdb\x32\xa5\xb2\x8c\x2b\xc1\x77\xbc\xeb\xfa\x7f\xce\xa5\x53\x43\x2f\x6a\x9b\x46\xa4\x39\xa1\x35\x7e\xa1\x76\xfe\xfd\xf0\xf6\xc5\xd1\xab\xe3\xbf\xbc\x7f\xfb\xf2\xd5\x47\xc3\xf9\x37\x97\xcc\xeb\xae\xfd\xeb\xbf\x4a\xb8\xfe\x78\x0b\xf7\xc4\xce\xe2\x71\x80\x8b\x51\x22\xe7\x81\x3c\xee\xf8\xc0\x33\xff\x82\x99\x16\x36\x66\x06\xe7\xae\x3c\x53\xe1\x2e\xa4\xd9\xb4\x79\xfd\x33\x49\x16\x2d\xfb\xe6\x27\x4f\x51\x51\x5c\xf2\x97\x27\x8f\x79\x7e\xc8\x02\xc7\xdc\x6e\x2d\x5c\x0c\xc0\x78\x4c\xf0\xed\x5b\xf1\xca\x00\x5e\xa1\x23\x5b\xcb\xc4\xba\x50\xee\x19\x07\x60\x9f\xb3\x9a\x37\x09\xdc\x82\x17\x86\x44\xac\xec\x3a\xc5\x28\x12\x61\x5d\x14\x38\x33\xb6\x4b\xee\xc6\x29\x12\xe0\xa7\x02\x49\x7e\x72\x22\x8c\x26\xa3\x6c\xd5\xc8\xbe\x0e\xa8\x9a\x52\xee\xaf\xfa\x2e\x07\x12\xb4\xb0\xc1\x79\x8f\xf7\x25\xaf\xbf\x31\xa9\x48\x24\x77\x77\x8d\xd7\x76\x4e\x53\x11\x90\xda\x40\xda\x88\x57\x67\x6e\xca\xe2\xa6\xbc\xcd\x5a\xb4\x29\x6b\x1e\x56\xea\x8b\x94\xf2\xa1\x9d\x2e\x44\x45\x37\x9a\xf2\x41\x4a\xab\x2e\xc8\xe0\x90\xc0\xa6\x81\xbc\x57\x4d\xeb\xa5\x9c\xe9\x13\x96\x66\x2f\x6e\xe5\x50\x4f\x18\x12\x94\x7a\xc7\x7a\xc8\xbf\x77\x1e\xb1\x4b\xd1\x36\x0e\x80\x7d\x75\xd8\xa2\xbe\x71\x40\x96\x13\x21\x17\x0e\x55\xf3\xcd\xf4\x2c\x1c\x65\x8e\x4b\x82\xa3\x9a\xd4\xb7\x9f\x6a\xc8\x5e\xa2\xb3\x05\x7a\xae\xbc\xf4\x2c\x9b\x91\xbb\xef\x62\x1b\xde\xbe\x5a\x9e\x60\x2c\x53\x75\xf3\x41\xfc\xb6\xe5\x2a\xaf\x69\xc4\xc8\x8e\x22\x35\x2c\xa3\xc8\x00\x8a\x77\xa9\x0c\xa0\xf2\xb7\x7d\x2b\xce\xc1\xc7\x51\x3d\x60\x51\xa0\xbd\x39\xfc\x24\xd1\xd1\xbd\xad\x29\x06\x4b\xd3\x64\xc2\xa2\xc0\xba\x68\x86\xf3\x07\x6c\x52\x11\x3e\x98\x61\x5e\xbe\xfd\xc4\xb8\xf4\x31\xf1\xa7\x06\x72\xf4\x4b\x74\x53\x0d\xe6\x28\xc2\x19\x4d\x6b\x92\xd2\x49\xf0\x81\x25\x68\x09\x31\x44\xe4\xe6\x5b\x17\x33\xf5\x39\xa3\x27\xba\xdc\x1c\xe3\xa8\x27\x0e\x4c\x58\x3d\x75\x6d\xda\xd5\x60\x91\x33\xe4\x13\x48\x71\xca\xac\x2b\x2b\x32\xc5\xb8\xad\x82\x49\x65\x17\x55\xb6\x97\x53\x65\xdb\x42\xae\xb6\xb5\x5c\x6d\x0b\xb9\xda\x16\x3f\x4b\x2e\xaa\x6c\x17\xe5\x69\x5b\x5f\x54\x11\x0f\x08\xa9\x0b\xdb\xb9\xae\xcb\x69\xdb\xba\xd8\x32\x8a\x94\xcc\x25\x0c\x9f\x5c\xa3\x8b\x1d\x5b\x5b\xe2\x5e\x82\x71\xc0\x1d\xc9\xbb\x06\x78\x07\x3f\x44\x97\x77\x89\x8b\x04\xc7\xeb\xbc\xc6\x13\xd0\x88\xee\xc9\x88\x8d\x0a\x3f\x1c\xa7\x32\x5d\xdd\xef\x37\xef\x29\x14\x95\x96\xbc\x0f\x4b\x55\x8b\xd1\x1e\x12\x96\xea\x29\xc9\x12\x69\x9e\x25\x05\xd3\x93\x38\xd5\xcd\x81\xf9\x49\x50\x90\xc2\x14\x34\x95\xa2\x45\x4d\xd0\x6b\x75\x66\xb6\x28\x7d\x25\xde\x06\xe3\xf4\x1d\x30\x71\xaa\x6f\xc9\x57\x33\x9d\x8e\xc3\xcc\x59\x5b\x73\x65\xcd\xe6\xaf\x71\x18\x39\xe4\x74\x2f\x45\x8f\x4d\x62\x7a\xb7\x55\x89\x9f\x4a\xd1\xeb\x2a\x4a\x52\x4a\x47\x46\xad\x14\xaa\x97\xee\x8a\xe8\xe4\x8f\xd2\x01\x8c\x32\xea\x06\xcb\x92\x81\x9d\xe5\x64\x60\x47\xc8\xc0\x8e\x96\x81\x1d\x21\x03\x3b\xe2\x67\xe9\x9c\xbe\x53\x94\x82\x9d\x7e\xe1\x68\x5a\xf5\x8b\xae\x68\xa6\x85\xab\xd7\x17\xfe\xb8\x2c\x1c\x85\xb4\x18\x65\x7d\x6e\x3f\x4b\x1d\x9f\x2f\xab\x89\x64\x35\x6f\x90\x94\xb7\x7c\xa0\x12\x15\x41\x6b\x66\xfb\x07\x95\xf0\xaf\xca\xee\xf1\xec\xd6\x7a\xb3\xde\xc2\x71\xa3\x7c\x11\x54\xee\x6a\x61\x2f\x88\xcc\xe5\x90\xf4\xb3\x90\x4e\x1d\xe1\x04\x9d\x3a\xd6\xb7\xe8\x12\xec\xb1\x38\xa2\x3e\x7e\xf3\xee\xc3\xfb\x8f\x9f\x5f\xbd\x3c\x7e\xf7\xfe\xe5\x97\xb7\xaf\x8e\x5b\xc7\xc7\x69\x32\x3c\x1e\xf8\x51\x80\x0f\x1d\x95\x6e\xca\x3c\x6e\xdb\xc0\x13\x76\x5b\x9f\x91\x74\xe8\x8f\xd9\x8f\x7e\x14\x54\xf8\x8e\x2c\x89\x70\xaf\xe1\x37\xfa\x07\xf9\xbe\xdf\x11\x7a\x1f\xe2\x30\xca\x6e\x8b\xdf\xa0\x04\xbf\x65\xc7\xa6\x4d\xa0\xe4\x7c\x52\x3d\x3e\x7b\x3b\xf7\x42\x80\x37\xa2\xe1\x95\x69\x50\x40\xbc\x7c\x9c\x96\xa5\x43\x87\xc0\xd1\x4d\xc3\x4a\x2a\xb4\xf1\xca\xda\xdd\x53\xe1\x2d\x36\xbb\x32\x0d\x72\x48\xdf\x8e\x02\xdb\x02\x58\x7c\x5a\xd9\xfd\xa7\xad\x27\xf7\xd3\xfd\xf8\x74\xe5\xbe\x9b\xe8\xde\xae\xe3\x3b\x04\x29\x4e\x82\x30\xf2\xc7\x95\x9d\xdf\x7e\x72\x3f\x1a\xea\x3d\xb5\xbb\x32\x01\xf2\x68\xdf\xab\x9e\x7a\x33\x99\x8e\xc3\x61\xb8\xba\xaa\x2a\x62\x79\x1b\x6d\xb5\x4b\xd0\xa6\xf1\x65\x0d\x8f\xee\xdd\x93\xa6\xbe\x5c\xb9\xf3\x26\xba\xf7\x3a\x3c\x9f\x7e\x4b\x56\x1f\x1a\x1b\xbb\xdb\x0c\xcb\x63\x82\xf4\xdb\xcc\x8f\xb2\x70\xcc\x6a\xc6\xe6\xe9\xbd\x74\xff\xdf\x45\xc3\x2b\x93\xa0\x80\xf8\xed\x34\xc9\x13\x13\xdc\xef\x35\x74\x68\xb7\xee\x91\x0e\xbf\xaf\x4e\x87\x02\xe2\xb7\xa3\xc3\x1e\x81\xcb\xce\x12\x96\x9e\xc5\xe3\x6a\xab\xef\x69\xfb\x7e\x74\xea\x67\xd9\xf2\xca\x94\x28\xa2\x7e\x3b\x52\x3c\x15\xf0\xc2\x49\x35\x3b\x6c\xef\xdd\xcf\xb4\xfa\x39\x9c\xac\xce\x0a\x16\xc2\xb7\xb4\x2d\x85\x9d\x3a\xcb\x86\x9f\xeb\xfa\xff\xb4\x73\x3f\xfd\xff\x92\x0d\x57\x37\x2b\xf3\x38\xdf\x6e\xf8\xdb\xc2\x4c\x95\x67\xba\x1c\x7c\x25\x15\xee\x61\xe2\x3a\x63\x13\x76\xa4\xda\x5e\x9d\x1a\x25\xe8\xdf\x92\x20\x1d\x1b\x62\xa7\x35\xa8\xa1\xc8\x3d\x4c\x17\x26\x45\x3a\xad\xc1\xea\x24\x29\xeb\xc0\x2d\x69\xb2\x9d\x07\x39\xac\xa6\xc9\xf6\x3d\x4c\x1d\x36\x4d\x6e\x20\x34\x65\x1d\xb8\x25\x4d\x76\xf2\x20\x6b\x48\x72\x0f\x93\x88\x4d\x92\xd5\x29\x52\x82\xfe\x2d\x09\x22\xcc\xb5\xe1\x6c\xc0\xce\xd8\x38\x9c\xd7\xd0\xa3\x73\xd7\xf4\x08\xa3\x8c\x25\xd3\x78\xec\x67\xec\x48\xb6\xff\x92\xee\x39\xae\x4e\x9a\x62\x47\x6e\x49\x19\x61\xc5\x25\x7e\x18\x0d\xea\x56\x06\xdb\xdb\xf7\x48\x97\x8f\xd4\xfa\xea\xe4\xc8\x63\x5f\x3e\xe7\xde\x29\xae\x7f\xf5\x93\xc9\x5d\x20\x3a\xbc\x6f\x44\x8f\xe2\x78\xf5\x85\x71\x09\xa2\xb7\x62\x2f\x61\x1c\x5f\x84\x49\x18\x84\x69\x0d\x7b\xdd\xf9\x0e\x99\x41\x89\x9f\xa9\xf5\xd5\x89\x91\xc7\xfe\xbe\xd6\xa1\x06\xae\xef\xfc\xd3\x49\xd5\x85\xbd\x95\x30\xbd\x77\xfe\x7a\x13\x8d\x58\x12\xc5\x77\x81\xeb\xbd\x0b\xed\x87\xb1\x9f\xde\x0d\x59\x83\xdb\x48\x83\x58\x20\xa5\xec\xb7\x19\x39\x68\xd7\x08\xc4\xfd\x6c\x96\x7e\x52\x4d\xaf\x4e\x8c\x12\xec\x0d\x81\x58\xf2\xbf\xdc\xa1\x4d\x6d\xf0\x82\xdb\xdd\xb6\x9d\x45\xb3\x94\x05\xf9\x5b\xb4\x83\x30\x65\xc3\xec\x63\x78\x7a\x96\x51\xd3\xb5\xe5\xde\xb2\x91\x2c\x76\x83\x83\x1b\x75\xf7\xad\xfa\x64\xa0\x7d\xe3\x93\x07\x42\x30\xae\xde\x6f\xdf\x7e\xdc\xa2\x61\x41\xa7\x07\x89\xca\x8f\x58\x4d\xbd\x2e\xe4\x2c\xd9\x06\x1f\x68\xd8\x5a\x57\x01\x1a\xd6\xb7\xfa\x6e\x4d\x5d\xbb\xf3\x65\x95\x0f\xc8\x83\xd9\x18\x8d\x6e\x1e\xc9\x66\xc2\xd3\xcd\x82\x38\x1c\xc5\x72\x63\x36\xca\x2c\x32\xca\x86\xc4\x58\x5a\x82\xa2\x58\x09\x79\x17\xba\x5c\xa0\x14\x12\x6e\xd1\xa5\xf2\x71\x6d\x84\x82\xdb\xb1\xe8\xfd\xf1\xd4\x83\x9b\x93\xc3\xb8\xbf\x85\x5e\xb1\xe6\x8d\x2d\x72\x93\xb5\xc3\xe0\x8b\x54\x73\x5c\x44\xd4\x21\x7c\x3c\x41\x00\x31\x02\xa1\xd0\xd9\x31\x1f\xb4\x7d\xe3\x21\x54\x0f\xe6\x1e\x8c\x63\x0f\xce\x42\xfb\x0a\xf5\x38\xd6\xf7\xc3\xf8\x37\xa8\x48\xeb\x3c\xf7\x2c\xd4\xb9\xfc\x1b\x7c\xe3\x5a\x18\xff\x4f\x84\xc8\x18\xc7\xf0\xcc\x02\x4d\xa7\xfb\x13\x7c\x9c\x72\x1c\xc3\x06\xaf\xfd\xfc\xf9\x73\x30\x42\xe3\x1b\x7d\x76\xfc\xde\x24\x0c\xfa\x1e\xcc\x5d\x0a\x91\x8d\x98\xf0\xda\x1b\x66\x0d\xf4\x26\x45\x34\x26\x61\x60\xdf\x47\xd6\x67\xd9\xb1\xf4\xc8\xa0\x13\x6e\xce\x77\xff\x9c\x84\x78\xce\x09\x91\xef\xad\x20\x42\x19\x7d\xaa\x08\x21\x8e\xf4\x2d\x7f\xe1\x32\x5e\x1a\x95\x47\xea\x0a\x10\x19\xcb\xb9\xe4\x5a\xe5\x76\xbd\x82\x72\x46\x4e\xe0\x72\xc8\x3a\xd4\x56\x5e\x33\xdc\x63\xa8\x88\x7c\xec\x87\x70\x32\x99\xe1\x8d\x66\xf7\x1a\xf1\x9d\xfa\x61\x52\x36\xfd\x15\x75\x00\x3d\x1b\x84\xa5\x14\x38\x51\x4a\x80\xb5\xb4\x81\xb8\x49\x60\x04\x68\x18\x69\x86\x1b\xa9\x96\x45\x04\x1b\x72\xd8\x26\x77\x56\x7d\x45\x01\x36\xa1\xed\xc1\x54\xa6\xe2\x15\x49\x5e\x0d\x7d\x6e\xd8\xa5\x70\x89\x89\xb8\x84\xc1\x21\xb4\x60\x1f\xc8\xd3\x4d\xb0\x6e\x08\xcf\x20\x72\xa9\x06\xb9\x75\x8f\x9c\xa9\x09\x6f\x63\x23\xec\x9b\x9a\x06\x4b\xe6\x39\x8b\x27\x72\x29\x1b\xd8\x8f\xff\xf0\x94\x7e\xe9\x30\xd7\x5e\xf0\xff\xee\x13\xc0\x85\x9f\x84\x7e\x34\xac\xd9\x11\x7f\xbc\x7d\x47\x13\x80\x3d\xe4\x1c\xb3\x8b\x65\x0c\x07\x0b\xc9\x52\xd1\x52\x80\x8d\xb1\xba\x80\x43\x0a\xe8\x9d\xfe\x96\x64\xce\x85\x0b\xfb\x70\x21\x86\x2e\x3f\x20\xb5\x57\x54\xbf\xfb\x80\xd0\xbd\xc2\x1a\xb7\x87\x9d\x3b\x1a\x0e\x0a\x8a\x25\x2e\x0a\xc6\xc6\xa8\x70\x31\x13\x11\xb3\x84\x8f\x99\x50\xb4\x13\x33\x88\x14\x97\xc9\xcd\xb6\xca\x62\x7e\x64\xe6\xd2\x6d\x14\x15\xc9\x7a\x9c\xf9\x2a\xf8\x3e\x5e\x2e\xa3\x38\x1e\xea\x9d\x88\x78\x94\xbf\xb4\x2d\x64\x74\x63\x43\x48\xa9\x39\x73\x3d\x0c\xd3\x9f\xfc\x9f\xc4\x0b\x13\xcb\x71\x90\xa4\x6a\x29\xff\x50\x67\x7b\x61\xdf\x75\xcd\x79\x0c\xd1\x96\xb4\x80\x4d\xec\xa3\x9e\x96\xb0\xc7\x1b\x5d\x51\x6a\x0b\x36\x36\x26\x3a\x93\x77\x52\xe5\xad\xcb\xc7\x30\x08\x44\x69\x60\x91\x07\x60\xc6\x47\xf9\xee\x9d\x8f\x47\x9a\x08\x1e\x84\x82\x29\x52\xf7\x1f\x4a\x10\xde\xdb\x09\xbd\x36\x22\x43\x28\xcf\x26\xb0\xc5\x13\x37\xa1\xed\x56\x48\x73\xed\x35\xd5\xbb\x91\xe6\xef\x26\x70\xb6\x8c\x59\x32\x35\x09\x23\xf5\xe9\xcf\x57\x96\x26\xd8\xda\x82\xd7\x61\x14\x50\x60\x1f\xf4\x48\x1e\xaa\xd8\x9e\xea\x46\xa2\x62\x3a\xc5\x6e\x5a\x54\xcc\xf0\x70\xe2\xde\xaa\xc8\x36\x59\x66\x12\x46\x18\x43\x74\x2e\xeb\x6a\x96\x28\xc5\xe9\x48\x58\xff\x14\xd4\x65\xe2\x87\x18\xc8\x45\xc5\xef\x03\xd3\x84\xac\x41\xca\xcd\xbd\xec\x8d\xac\x14\x46\xf0\x5c\x62\x48\x78\xe5\x30\x52\x25\xfd\x39\x3c\x53\x25\xcb\x70\x2f\x7d\xeb\x7b\x79\x71\xbe\x15\xf5\x2b\x65\xf5\x8f\x36\x22\xd7\x22\xfa\x07\x18\x25\x69\xae\x71\x71\xe2\x40\xfa\x15\x5a\xa5\xf6\x76\xf5\xdd\xda\xe6\x37\xdd\x90\xab\x3a\x3f\xc5\x5b\x01\x85\x4d\xc6\xfb\x8a\x02\x37\xf1\xa7\xd4\x96\xb8\x1b\x83\x91\x14\xc9\x7b\xdf\x7c\x79\x1a\x63\xbd\x70\xc4\x94\x49\x4f\x68\x1a\xd7\x5d\x28\x99\xc3\x2b\x0e\x47\xed\x9d\xe1\x7f\xa8\x92\x17\xa1\xfc\xd3\x2c\x9e\x7a\xf8\x7a\x0b\x31\x39\xbd\x40\xd0\x85\x0d\x23\x9f\x7e\xca\x72\x1c\x4a\xd9\x7d\x3d\x17\x9e\x41\x07\x0e\xc1\x11\x55\x14\x00\x02\xd8\xf2\xf8\xfc\xb8\x0f\x7c\x95\xb3\x2d\x1e\xc0\xda\xe0\xf0\x74\xf8\x4f\x6b\x12\xe1\x4d\xa0\x5d\x3c\xf1\xe7\x4e\xcb\xa3\xef\x21\x0b\xc7\x0e\x35\xb0\x29\x5f\x2e\xd8\x22\xec\x5d\xf8\xa6\xad\x3a\x79\x2d\xca\x58\x5c\xb9\x66\xe0\xd0\x9c\xc1\x82\xc5\x69\x65\x45\xe8\x6e\x40\x88\x6f\x04\x71\xec\x6c\x01\xc4\xa2\x15\xb2\x57\x7b\x09\xf9\xbb\xaf\x8b\x07\x38\xe0\x59\x38\x3c\x7f\x13\x0d\x13\xbc\x7f\x7e\x53\x50\x43\x05\xea\x13\x92\x04\xa3\xdd\xb4\x5b\x72\x84\x70\xe5\xa2\x22\xb5\xb1\x5d\x2b\x5d\xc5\xa9\x61\x1d\x2b\xbd\x43\x01\x15\xee\x94\x8d\x87\xf1\x2c\xca\xcc\xf8\xc5\x78\x59\xa6\xdc\x48\x51\x56\x09\xef\x56\xaa\x5f\xdc\x12\x0c\x99\xe7\x7b\x5b\x2a\xb0\x21\xfe\x1b\x3f\x64\xc8\x15\x51\xaa\xdb\xa5\xda\x18\xa0\x91\x97\xc3\xfd\x22\xa9\xc0\xb1\x50\x5f\x56\xd1\xd7\x8a\xb0\xca\x33\xc9\xd4\x51\x51\x80\x24\x26\x88\x57\x24\x01\x38\x42\x24\xad\x71\x2e\xa3\x8a\xab\x6f\x25\x3f\x0c\xd3\xd7\x61\x14\x66\xcc\x11\x92\x63\x04\x9e\x52\x5d\x61\x53\xc2\x5b\xbc\x61\x24\x90\xd0\x52\x48\x29\x42\xf8\x0e\x44\x21\xc4\x0d\xcb\x8c\xc6\x71\x9c\x90\xa4\x5a\x65\x90\xda\xb9\x6d\x0f\x1b\xac\x96\x6d\xd8\x80\xb6\xbc\x60\x99\x17\x5c\x84\x43\x22\xeb\x28\x99\x75\x4d\xa1\x35\x0d\x1b\x0b\x7d\x89\x1a\x4f\x5a\xaf\xc2\x5f\x23\xb3\xbe\x1a\xfa\x1c\xea\x26\x81\x5a\x09\xfd\x4d\x8e\xfe\x96\xad\x73\x0c\x0e\x11\x55\xcc\xab\x63\xc6\x1b\xe4\x3c\x2b\xbf\xdf\x73\x2d\x47\x28\x39\x91\x5a\x3d\xaf\x57\x4d\xf5\x4b\x55\xa4\x98\x4c\xe3\x4b\xbc\x84\x6f\xd0\x13\x3f\xc7\xf1\x29\xf1\x94\xac\xfd\xf6\x27\x25\xff\x20\x42\x72\x76\xa9\xbd\x2d\xfd\xa6\x73\xbb\xe5\x11\x44\x6b\x0f\x0b\x9b\x78\xde\x85\x96\xa8\x7d\x08\x0e\x01\x78\xde\x45\xe5\x73\x08\xed\x16\xec\x83\x4e\xdb\x85\x43\xd8\xb5\x52\xf8\x74\xd4\x81\x7d\x3e\xf1\xac\x97\x35\x27\x20\xef\xc3\xa6\x95\xb9\x49\xb9\x7c\x05\x77\xf3\x16\x71\x4b\xcd\x1a\x0c\xae\x3b\xaf\x1d\x07\xa5\x54\xfd\x41\xba\xc2\x80\xf0\xaa\x6d\x59\x55\xf6\xa3\x6a\x74\x5a\xf6\xf0\x94\x8e\x4f\x4b\xf0\x62\x5b\x2a\x1a\x93\x12\xae\x68\x6f\xbd\x0b\x6d\xdc\x8c\x57\x31\xe2\x0c\xda\x18\x85\x76\x2b\xca\x74\x8c\x32\x9d\x03\xf3\x31\x39\xad\x0b\xe1\x10\x36\xa9\xd0\xbe\x44\xa8\x64\xaf\xf2\xbe\x2e\xc1\xdd\xd5\x62\xda\xda\x73\xd5\xea\x42\x0d\x8b\xb5\xaa\x36\x86\xa7\xe3\xd2\x41\x42\xa9\xbd\x71\x8f\x87\xc8\x7f\xb0\x1d\x84\x3f\xf8\xb6\xc1\x77\xdc\x30\xe0\xe8\x58\x4b\x4f\x7b\x65\x5a\xb1\x10\xfd\x27\xdf\x04\xf8\x07\x2f\xff\xef\x89\xe6\x72\x21\xca\xd9\xbb\x4c\xbe\x9f\xfc\xb1\x4e\xe0\x27\x61\x54\x73\xf6\xf2\xf4\x8e\x36\xfb\x27\x7e\x96\x84\x73\x23\x24\xa2\x43\xbb\x40\x3c\x55\x85\x22\xb4\x23\xa5\x5a\xb1\x2c\x36\xdb\x1e\x6e\xff\x2f\xb3\xdd\x8c\x3d\x2a\xdd\x6b\xa6\xf6\x3c\xf9\xe2\x83\x07\x59\xe2\x47\xa9\x88\x02\xa1\x6d\xbf\x89\x8b\xc1\x32\xe0\x19\x4c\x0e\x0a\x17\xe1\x7f\x15\xd8\x44\x1e\x24\xf1\x25\xbe\xa2\x2a\x60\x90\xdd\x67\xad\x4d\x61\x63\xe3\x57\xce\xcc\x07\xc6\x15\xf3\xf8\xb2\xf7\x6b\x5f\x75\xbe\xf7\x6b\x5f\xdf\x44\xb7\x83\x25\x2a\xc0\x79\x13\x90\xd0\x77\x02\x6b\xf6\x09\xd4\xf9\x78\x71\x1e\x7d\xf2\x1d\x8f\x76\xef\x7a\xfb\x28\x14\xd7\x0d\x2b\x77\x90\x96\x3e\x4b\x16\x17\x0f\x6f\x28\x28\xc1\xf6\xb1\x0e\x53\x5b\xed\xad\xf2\x64\xef\xc6\x2e\x50\xb8\xe1\x54\x09\x59\x88\x22\x05\xcd\x12\x34\x81\x2e\x7c\x8d\xfc\x09\xdb\x87\x86\x4c\x6a\x5c\x99\x9c\x22\xba\xec\xe0\xf6\x86\x9e\xae\xe5\x8b\x2c\x4b\x48\x53\xae\xdb\x52\xac\x26\xfe\x94\x44\x4a\x59\x99\x41\xcc\x95\x33\x86\xa2\x91\x49\xb3\xe8\x3c\x8a\xf1\x11\x47\x35\x88\xa8\x20\xc5\x2e\x8e\xf8\xab\x5e\x1f\xea\xf5\x61\x7f\x29\x0a\xf5\x1a\x03\x44\x82\x36\xf0\xd6\xb7\xfa\x14\xf7\x9e\x3a\x49\x71\x70\x24\x01\xd0\x4b\xd0\x51\x6f\x14\xf0\xce\x53\xa4\xa9\x00\x36\xa0\xd1\xf0\x50\xb9\x20\x39\xf0\xfd\xa5\x73\xb6\x10\x2b\x3b\x3a\xea\xb2\x8f\xbe\x64\x7f\x1e\x76\x75\x8f\x94\xd2\x12\x99\xca\x87\x05\x61\xa6\x04\x93\x9a\x21\x0a\x35\xa7\xb3\x94\xcb\xae\x5b\xf2\xb6\x1a\x6d\x58\x39\x21\x9e\x2f\xc1\x0f\xf4\x5b\xc8\xb5\x8e\x07\x83\x7d\x6a\x2a\x7a\x2b\xa1\x39\x36\x83\x97\x3d\x2c\xee\xe3\x49\x45\x41\x68\x50\xb0\x16\x81\x85\x39\x78\x77\xca\x1d\xfa\xb5\x6c\xa9\xc5\xf1\x4d\x00\x15\x3c\x24\xf0\xf8\x78\x94\x2f\xa6\x69\x08\x90\x8e\x67\x7e\xea\xd0\xb8\x39\x01\xaf\x8f\xa6\x13\x1f\x40\xd7\xcd\x53\xba\x94\xca\x72\x01\xc2\x29\x67\xbc\x89\x8d\x84\xcc\xc7\x5a\xd2\x74\xd4\x01\xc1\xec\x28\x6e\x87\xe0\xc8\x4a\xb7\x60\xd7\x63\xd7\x23\x0c\x5c\xd8\x17\x23\x6d\x8c\x89\x89\xa1\x96\xa3\x95\x70\xd4\xd5\x8e\x8d\x96\x0c\x3e\x35\xdb\x18\xc6\x53\x33\x8a\x55\x3e\x5a\x8f\x54\x24\x3a\x5c\xb0\x60\x40\x87\xfe\x18\xe9\x14\xaa\x8a\x84\x51\xa7\x8a\x66\x25\x52\x46\x1f\xed\xb1\x29\x99\xbc\xbe\x83\xc3\xca\x7d\x9d\x46\x04\xec\xb4\x93\xf8\xc1\x9d\x9f\x7e\x54\x4d\x96\x89\x1f\x74\x02\x76\xaa\x4f\x40\x04\x02\x72\x0b\xe1\xc3\x1b\xd8\x82\xf6\x5e\xeb\x40\x44\x1d\xc3\xd2\xd0\xe5\x49\x72\x71\xfa\xe1\x4d\x89\xc9\x7a\x8f\x2e\x2a\xe5\xfe\xca\xc9\xe9\xe0\x47\x3f\x0d\xd3\x5a\xa7\x66\x59\xe8\x68\x1c\xf3\xdc\x9b\x3a\x36\x93\x12\xab\x71\x3d\xde\x7d\x7c\x73\xb7\x66\x8e\x5f\x25\xe0\x4e\xa7\x75\xe3\x10\x25\x03\xdd\xf3\x9a\x38\x15\x3b\x37\x0e\x00\x52\x4f\x92\x36\x86\xff\x10\x2e\xf0\x37\x5c\x1c\xe8\x98\x4d\xc9\xe9\xe0\xcf\xfe\x64\xe2\x3b\x0b\x6d\xa3\x60\xfb\xcb\xcc\x42\x1a\x57\xa9\x68\x4f\x39\x2c\x9a\x80\x16\x39\x7b\x20\x39\x1d\xc8\xbd\x3a\x15\x45\x4f\x9c\x2a\x40\x97\xda\x74\xe4\x86\xff\xf2\x13\x20\x35\x3e\xc2\xc6\x93\xd3\x01\x35\x4d\xdb\x7b\x6e\x33\xf1\xc0\x61\x51\x70\x6b\x78\x1c\x5f\xb7\x99\x28\x83\x0b\xe0\x54\xa1\x8c\x6d\x35\x4f\xb1\x53\xcd\x53\xa3\xc8\x20\x57\x64\x40\x45\x06\x46\x91\x78\xea\x0f\x29\x12\xec\x4a\xa4\x2e\x59\x5e\x51\x13\x02\x1e\x35\x24\x7e\xd8\xd3\xb0\xd2\x20\x99\xb6\xaf\xa8\x2e\x1f\x84\xc4\xc9\x94\x47\x8e\xe8\x17\x74\xe1\xb4\x90\xca\xbb\x36\x28\xa4\xea\xde\x88\x2f\xa3\x84\xda\x86\xa4\x73\x85\x46\x43\x98\x60\xfa\x30\xf0\x74\xd0\x24\xe6\xe9\x2a\x9e\x34\xe7\xa8\xe4\x74\xc0\xd7\x62\x0e\xee\xff\x3f\x30\x99\xea\xd3\x74\x1c\x46\xcc\x49\xf1\x4f\xb9\x5f\x2f\x52\x2e\x35\x59\x2e\x92\x83\x93\xdf\x35\x03\xe4\x46\x73\x25\x69\x0f\x7a\x79\xce\xa0\x32\x27\xf4\xa8\x9d\x03\xbd\x94\x0d\x29\x38\x1b\x9a\x5a\x56\x68\x48\x58\x5e\xf2\x6a\xd9\x95\x3a\xd6\x13\x1e\xac\xd8\x27\x5a\x20\x63\x46\x33\x81\x6f\xdf\xb4\xc7\xf7\xa9\x99\x75\x6a\x65\x0d\xcc\xac\x81\x91\x25\x2c\x67\xe8\x02\x51\xdd\x49\x44\x4b\xa7\x3a\xe9\x54\x24\x0d\x74\xd2\x40\x24\x11\x40\xcd\x2e\xed\x6b\x59\x54\x22\x6e\xb3\xa8\xc4\xd9\x66\x51\x89\xae\xcd\xa2\x32\x18\x28\x12\x38\xcf\x80\x68\xfb\xa0\x26\x92\x73\x5f\xd7\xe0\xac\x65\x66\x19\xa9\xff\x8a\x17\x53\x72\x33\xe5\x72\x80\xf3\x93\x4c\xf9\xbd\x97\x82\xad\xf0\x1d\x1c\xe0\x56\xd8\xde\x5a\x66\x02\xbe\x3b\x6f\xd6\x9a\x1d\xf1\x83\x12\x95\x90\x99\xda\x20\xb4\x0f\xde\x1c\x27\x83\x1f\xf0\x46\x0a\xb9\x8f\x6f\x6c\x64\xb0\x0f\x99\x0b\xeb\x60\x8a\xf6\x45\x4b\xef\x27\x3b\x21\x6c\x40\x24\x17\x8f\x51\xdf\x28\xd5\x36\x76\x9d\xf3\x79\x9d\x1c\x84\x62\xed\xed\x5c\x89\x0e\x95\xb0\x24\x66\x99\x9d\x39\xc5\xa7\xc4\x48\x03\x61\xe1\xf5\x5d\xde\xd9\x4d\x08\x61\x8b\xaf\xfb\xd6\x21\xf2\xe0\xa2\xe5\xc1\x45\xdb\x83\x8b\x8e\x07\x17\xdb\xea\xd6\x42\x19\xc3\x7d\x07\xdf\xa8\x1b\x32\xc5\xbc\x7c\x26\xc8\xad\xad\xe6\x75\x9d\xfb\x0e\x9e\x46\x2b\x79\xeb\x8f\x67\xd5\xae\xfa\x9d\xf6\x93\xbb\x72\xd5\x57\xf7\x19\x50\x96\x50\x8f\xc2\x21\x0c\xe4\xea\x76\x5f\xfb\x04\x45\x7c\xb2\xf6\xa5\xb7\xfd\x24\x8c\x9c\x68\xe0\xa9\xdb\x42\xae\x59\x74\x6e\x4f\x90\xda\x08\x1a\x56\x65\x84\x3a\xaa\xb2\x39\x61\xfa\x62\xc6\x9c\xd3\xdc\xb4\xdc\x15\x02\xa4\x5c\xf9\xfd\x01\x3c\xa1\x18\xc8\xb9\x12\x9b\x13\x2d\x0d\x44\x4b\x43\x6a\x69\x80\x7b\xc5\x75\x9a\xa4\x12\x57\x01\x81\xa3\xac\x66\x24\x39\x1f\xd5\x31\xe0\x77\xf0\x7e\xba\x13\x26\x09\xc4\x18\xbe\xf4\x33\x66\xe8\x5a\xce\x1d\x1b\xbc\x24\x6c\x76\xc1\xf7\x4a\x28\xa6\xf6\xcf\x53\x96\x7d\x0e\x27\xcc\xf1\x61\x03\x06\xb0\x0e\x99\xeb\x41\x50\x47\x9a\xef\x70\x3a\xfd\x87\x97\x4d\xce\x6a\x5f\xaf\x4c\x41\xd2\xbf\xce\xd5\xf9\xae\x8f\x5e\x4a\xb8\xcf\xfb\xed\x9b\x7c\xd7\xca\xc7\x8d\xd4\x06\xbd\x1b\xd5\x70\x71\xa8\xbe\x5e\x49\xc7\x84\x41\x59\x95\x41\xae\xca\x40\x54\x91\x52\x73\x0e\x61\x24\xb1\x23\x30\x98\xe2\x1b\xfb\xb8\xbd\xf3\xbb\x11\xd9\x73\x14\xd9\x73\x69\xde\xe6\xde\x97\x1d\x52\x33\xbc\xc0\x41\xe9\xf1\x60\x85\xe4\x22\xba\x28\xad\x58\x9f\x63\xbb\x92\xb4\x7e\x07\xdf\x81\x3b\xbc\x4b\xb4\x43\x3c\x49\x4e\x7d\x2f\xa0\x0b\x5b\xbd\xcd\x8d\xfe\xa1\x73\xb8\xff\xf7\x60\xe3\xef\xcd\xc3\xbf\x07\xeb\xdf\xf0\xcf\x86\xeb\x1c\xee\xf7\xd8\xab\x3e\xe6\xf3\xdf\x87\x5b\xa7\xe2\xc2\x29\xfb\x51\x48\xfe\x47\x76\xfa\x6a\x3e\x75\x12\xf6\xa2\x99\xc6\xb3\x64\xc8\x3c\x68\x9c\x36\xac\x95\xda\xef\x2c\x89\x9d\xc1\x52\xb3\xf2\x40\x1b\xe5\xfa\x38\x05\xd7\x0f\xa5\xb5\xf3\xea\x84\x9b\xfd\xca\xc4\x27\x30\x77\x2d\x7a\x03\x2e\x7b\xbc\xb7\x63\x3f\xcd\xe4\xa3\x82\x09\xfb\xd1\xfa\xdd\xf2\x60\x6b\x0b\xd2\xa1\x1f\x89\x7d\x7d\xce\x66\x11\x9b\x67\x40\x83\x83\x02\x23\x98\xd6\x9f\x60\x61\x7c\xa1\x39\xca\x60\xe2\x67\xc3\x33\x14\x1f\xb9\x14\xab\xc8\x97\xf5\x07\x29\x35\x46\xaf\xc8\x4f\x13\x36\x64\xf8\x54\xae\xac\x60\xb4\xe8\x71\xe1\xf4\xa3\x85\xed\x26\xc2\x6b\xab\xf7\xe6\x52\xb9\xae\x17\xc7\x12\x1a\xf2\x30\x8e\xd2\xcc\xc7\x07\xfc\xa2\x00\x8c\xc7\x65\x64\x95\xdf\xe8\x45\x04\x5e\x45\xb5\x29\x83\x67\xc4\x49\x2a\x22\xb3\x1f\xd1\xc3\x4c\x61\x34\x9d\x65\xf4\x02\x2c\x82\x47\xb7\x02\x32\x2a\xe8\x88\x88\xac\x0f\x1a\x4b\xaa\xf9\x46\x87\xe2\x10\x17\x3e\xe3\x91\x68\x29\xa5\x87\x7e\x1f\xc1\xa0\xa9\xfd\x92\x1d\x7f\x22\x86\x8a\xcd\xd9\xd0\xf1\xd5\xab\x7b\x8f\x1e\x81\x33\x98\x88\x61\xc3\xbc\x81\xbe\xf2\x84\x2e\x0d\x03\x7c\x1f\x69\xd2\x44\xb2\xb8\xf0\x1c\x06\xa1\xf0\x8c\xf0\x6d\x42\x33\xf9\x38\x6d\xe9\xd0\x12\x18\x71\xc0\x30\x08\x3d\x18\xa4\xae\x79\xdd\x9a\x9c\x51\xd0\x75\x71\xa3\x0b\x83\x14\x69\x37\x8c\xfd\x31\x4b\x87\x8c\x9e\x04\x9e\x26\xec\x22\x8c\x67\xa9\x0e\x65\x0f\xf2\x76\x74\x8a\x57\x55\x01\x2b\x1a\x6b\x73\xec\x00\x76\xdd\x9f\xf4\x5a\x7d\x72\x55\xa5\xfe\x0e\x26\xe2\xb9\x1b\x3d\x46\x9a\x72\xc4\x59\xd5\xd8\x4d\x6e\x8a\xdd\xc4\xd6\xd5\xc4\x6e\x7a\x28\xf1\x29\x72\xde\x34\xa7\xaa\x40\x4a\x32\xa1\x84\x21\x63\xe9\x23\x9b\xd1\x29\xd3\xd7\x70\x1f\x42\x0f\xe6\xfb\xb7\xbf\x0c\xc7\x25\x70\x30\x71\xaf\xac\xc3\x41\x21\xe7\x86\x5c\x9b\xef\x0b\xbc\x08\x02\xe1\x18\x83\x5c\x88\x6c\x87\xf3\x27\xb7\xfe\x06\xb9\x27\x23\x72\x6c\x60\x9c\x75\xde\x90\x01\xca\x86\x5f\x62\xf6\x69\xca\x86\xa1\x3f\x86\x78\x9a\x85\x93\xf0\x77\x7a\x25\x8d\xab\x9f\x38\x1a\x2f\x38\xfb\x86\xd1\xe9\x98\xd1\x60\x37\xa9\xca\xfb\xec\x8c\x25\x97\x61\x8a\x6f\x69\xea\x81\xc1\x67\xb2\x63\x7a\xbd\x53\x32\x0b\x17\xfd\x84\xfd\x1a\x87\x11\x26\x13\x4e\x4d\xe3\x3c\x49\xbd\xb9\x44\xd7\x17\x7e\xeb\xb5\xfa\x62\xdc\x0e\x51\x91\xf3\x84\xe6\x5c\x3b\x8b\x8a\xb9\x41\x27\x70\x13\x04\x7e\xd3\x0f\xb6\x94\x6c\x09\x01\x40\xe1\x59\xaf\x98\x0c\x6f\x69\xb9\xa7\x3d\x27\xe6\x70\x38\x7d\x9b\x48\xa5\xb8\x39\x37\xf6\x84\x8c\x39\x23\xa5\xf7\x1f\x1a\x0d\x23\xf3\xaa\xe2\x9e\xe1\xde\x77\xf0\x22\xba\x93\x55\xef\xc6\xbc\xa2\x03\xdf\xc1\x27\x65\xc5\x57\x09\x44\x7f\xdf\xc6\x43\xbf\x26\x72\xf1\xde\x53\xe1\xe2\x91\x3b\x94\x52\x21\x8d\x46\x71\x32\xf1\xb3\x97\x26\xb0\xdc\xd9\xd4\xed\xa3\x1f\xad\x1e\xfc\xa9\xbc\x8f\xf7\x15\x02\x6c\xf5\x60\x9a\x55\xf8\xdd\xc1\x8b\x06\xe3\xfa\x01\xdd\xde\xeb\x2c\x33\xa0\xa5\x23\xb9\xe2\x9b\x02\x04\x09\x15\xe3\x28\xac\xb1\x8c\xb7\xf7\xee\x3c\x3e\xe1\xea\xa1\x3c\xab\x70\xbe\x93\xb7\x05\xb8\xd1\x12\xa6\x61\x1c\xbd\x0e\xe7\x35\x27\x98\x4f\x5b\x77\x1e\x49\x6f\xf5\x40\xd0\x15\x28\xdf\xc9\x53\x03\x0a\xe8\x87\x84\x8d\xea\x22\x79\xde\xfd\x73\x13\xab\x07\x84\xae\xc2\xf9\x76\x94\xd8\xcd\x41\xfd\x18\xcf\x6a\x5e\x87\x79\xda\x7a\x7c\xd7\x84\x18\xdd\x38\x5e\x7e\x0e\xe5\x92\xf8\x71\xb9\x49\xef\x8f\x15\x7c\x85\x37\x13\xb1\x28\xab\x59\xa1\x3f\xbd\xb1\xe6\x25\xbd\xf1\xe7\x24\x9e\x4d\x6b\xe6\xd2\x1b\xc2\xef\x48\xf8\x3f\xcd\x26\x2c\xf1\xc7\x35\xb1\x38\x5b\x37\xf4\xb1\xd8\x3e\xbe\xb9\xba\x5e\x41\x09\x50\x1b\x9f\x17\x53\x56\xdd\x87\xed\xfc\x8b\x3b\x2b\x88\x16\xc1\x27\x49\x7d\x31\xcb\xe2\x9a\x46\x76\x6f\xfc\xe4\xc3\xb5\x6f\x06\x3d\x6d\x6d\x1b\x42\xc1\xe1\x4d\x11\x23\x86\xab\xfb\xc6\xa2\xe1\x35\x7e\x6f\x78\xdc\xac\xe1\xd2\xd8\x98\x36\xbc\x46\xd4\xf0\x1a\xff\xdf\xff\xdb\xf0\x1a\x93\x86\xd7\x68\x78\x8d\xf3\x86\xd7\x78\xd7\xf0\x1a\x7f\x6e\x78\x8d\xcf\x0d\xaf\xf1\xa1\xe1\x35\x5e\x35\xbc\xc6\x7f\x34\xbc\xc6\xdf\x1a\xfd\x3b\xb9\x76\x4a\x96\x82\xde\x62\x39\xe5\xdc\x8b\x81\xc4\xd0\x49\x0e\x7f\xf2\xc5\xe1\xa3\x47\x32\x29\x3b\x8b\x67\xa9\x1f\x05\x29\x1c\x2e\x15\x83\xd0\x92\x8a\xd2\x35\x60\xae\x2d\xaf\xd0\x92\x5b\xeb\x26\x6b\x8d\x46\x49\x03\x6a\xab\x16\x37\x65\x86\x0b\xdd\x3b\x99\xa2\xc3\xe6\x0c\xc3\x89\x3f\xd6\x05\x44\x82\x3a\x79\x11\xa2\xa7\x0b\xa8\x94\x25\x68\x51\x22\xc1\x75\xe4\x90\xa0\xef\xa6\xf3\x53\x96\x0c\x19\x5e\xf5\x15\xe0\x65\xc2\xb7\x6f\xd0\xf8\xa1\x61\xfb\x0c\x45\xec\xf2\x35\x62\xea\xa4\x52\x13\xa8\xfb\xb3\x32\x61\x49\xef\x99\x52\x5b\xaa\xe8\x47\xa3\x9a\x39\xd0\xaf\xd9\x8e\xc2\xf1\x18\xbd\x18\x44\x5e\x93\x27\xe8\x33\x5a\x7f\x1c\x9e\x46\x56\x3e\xa6\xe8\x02\x69\x3e\x3f\xb5\xb3\x17\x93\x41\x6c\x37\x40\x49\xba\x08\x5f\x20\x5b\x05\x78\x82\xce\xbe\x0c\x03\x7c\x69\x57\xe7\x63\x8a\x2e\x30\x8c\xc9\xb3\x46\x17\xc0\x14\x5d\x40\x4d\xa7\x56\x21\x95\xaa\x0b\x66\x8b\x29\xb3\xca\x88\xa8\x0e\x3c\x4f\xdc\x19\x9a\x65\x74\x67\x88\xd4\x0c\xee\x16\xa4\xb3\xd1\x28\x9c\x37\x65\xa9\xd7\x71\x02\x9f\xde\x6c\x52\x01\x8f\x36\x11\xb0\x04\x3e\x83\xee\xff\x1e\x8e\x17\x78\x21\x6a\x96\xe1\xd3\xfd\x62\x18\x04\xbc\xae\x22\x58\xb7\x0b\x8d\x3f\x35\xe0\x50\x09\x54\xaf\xd5\x87\x7d\x2b\xfb\x5f\x1a\x5c\x61\x6c\xf5\x06\xf1\xfc\x97\xfe\x56\x33\x63\x69\xe6\x70\x8c\x5d\x38\x84\x46\xab\x01\x1b\xd8\xa1\x66\x16\xbf\x8d\x2f\x59\x72\xe4\xe3\x0b\xa4\xfb\xd0\x68\x18\xc3\x43\x98\xd5\x35\xdb\xe6\xcd\x6e\xf5\x7e\x98\xe6\x9b\x90\xbc\xbd\x2f\x77\x30\xb1\xfb\x7f\x3d\xf3\xe5\xca\xc6\x70\x97\x3f\x8b\x67\xe3\x00\x2e\x19\xcc\x52\x76\x28\x8b\xbe\x49\x21\x3b\x0b\x53\xc0\x3d\xe4\x8c\x9d\xb2\x04\x11\x56\xf9\x47\x7e\x44\x05\x70\x5c\x4e\x59\xc4\x12\xdc\xb5\x11\xd6\x45\xe8\x8f\x21\x8a\xe9\x95\xfc\x43\xcd\xcf\x6a\xde\xab\x75\xa3\xce\xcf\x90\x25\x02\xd3\xe3\xcd\x1a\xee\x0a\x13\x7f\x31\x60\x9f\x24\xc1\x1e\x22\x52\xdf\xbe\xc1\x56\x2f\x60\xa3\xd3\x69\x92\xfe\x60\x11\x48\x53\xe4\x13\xcb\x90\x0b\x24\x68\xcd\x8e\xe1\x88\x77\x40\xf1\x5b\xe0\xc9\x2a\x71\x02\xc3\xb1\x3f\x99\x12\xf7\xc8\x6c\xa3\x66\x16\x0b\xc6\x9a\xf2\x39\x87\x05\xc2\xd1\xdb\xe4\x41\x2e\x87\xe1\x28\x1c\xfa\x91\xd1\xa4\x07\x61\x06\x93\x59\x9a\xc1\x80\x41\x18\x41\xaf\xed\x41\xa7\xdd\xb7\x2a\xf2\xe9\x33\xa8\xa9\xd2\xf2\xa0\xd3\x12\x55\x4c\xd1\x32\xbe\xd5\xdd\x0b\xa4\x05\x1c\xc2\x63\xd8\x87\x76\x47\xfb\x6d\x73\x8e\xe2\x34\xcb\xf3\x94\xba\xb2\xdc\xf6\xf4\xc1\x7b\xa7\xed\x69\xe0\xae\x09\xa4\x10\xf1\x03\x8b\xb7\xac\xe2\x62\x20\x14\x2f\xd2\xb0\x3b\xb9\xbb\x79\x18\xb6\x8f\x27\x7d\x90\x82\x28\x04\xd8\xd8\x4e\xc3\x7c\xc5\x00\x24\x3a\x66\x7e\x88\xb7\xb7\x86\xea\xcd\xe8\x70\x24\xfa\x8f\x52\x35\x6c\xd8\xc1\x44\x4d\x58\x9a\x15\x25\x5e\x1b\x66\x89\x03\xbb\x1a\x74\x95\x8b\x57\xe1\x80\x50\x17\xd9\x10\x57\x0c\x55\xc6\xd6\x16\x7c\x60\x09\x6f\x0a\x79\x27\x8c\x42\x14\x21\x6a\x3b\x13\xbb\x9c\x39\x6a\xfc\xc4\x4e\xfd\x2c\xbc\x50\x97\x1f\xe1\x99\xf6\xa0\xd3\x4d\x19\xe8\xab\xcb\xe8\xd4\x0f\x73\x24\x6c\x54\xde\x8c\xc0\x87\x48\x82\x27\x48\x09\x5f\xee\xe0\x91\x09\xce\x09\xc1\x0c\xcf\x21\x34\x82\x1e\x64\x09\xf3\x33\xf0\x53\x98\xc6\x69\xc8\x6b\x6a\x9c\xd5\x7d\x5f\x85\xf3\xa3\x47\x82\x08\x14\xcb\xc2\x2d\x74\x69\xe4\x8f\xd3\x1c\x85\x96\xd0\xf1\xaa\xe7\x8a\x55\x72\xed\x1e\x82\x43\xb3\x22\x1f\x76\x87\x2b\x53\xfc\xb9\x0f\x8d\xcd\x06\x57\xc0\x3a\x73\xb3\xc1\x35\x48\xae\x70\xa3\x21\xca\x28\x2e\xa0\x86\x0e\x2a\x98\xc7\xfc\xb5\x61\x72\x5c\xca\xa1\x49\x7b\xb8\xb7\x07\x1b\xab\x5a\xf4\xd2\xf1\x8f\x60\xbc\x12\x7a\x97\xeb\x46\xd8\x82\xed\x3e\x6a\x7e\x8e\x64\x91\xee\xf9\x2e\xb9\x0d\x2a\x6c\x13\xfb\xc7\x84\xf9\xe7\x74\x4f\x98\xc6\x98\x05\x82\x13\xc2\x48\x68\x38\x39\x31\xfc\xf7\x7f\xfd\x6f\xcc\xf9\xef\xff\xfa\x7f\x60\xea\x27\x5c\xa3\xfa\x99\x78\x04\xd9\x04\x89\xe6\x2d\x3e\x8f\x1b\x05\x30\x4a\x7c\x94\x79\x7f\xcc\x35\xaa\x39\x6f\xfc\xf7\x7f\xfd\x6f\x1a\x52\x1b\x5e\x98\x72\x85\x6c\xf3\x94\xa1\xf6\xed\x0d\x7a\xf3\xe6\x11\x5d\x6b\xb6\x23\x09\x43\x4d\xc4\x43\x0d\x7e\xa8\x6a\x0f\xcf\xfc\xe4\x28\x0e\xd8\x8b\xcc\x09\x5d\x0f\x76\xf6\xe0\x39\x0c\x39\x7f\x0c\xe1\x39\xec\x3e\xc9\x57\xce\xb3\x01\x87\xd4\xed\xc2\xce\x63\x38\x54\x26\xb6\xe0\x1f\x71\x30\x23\x9c\xf0\xf6\xed\x44\xb7\x52\xd9\xd8\x42\x6e\x56\x6a\x79\x10\xba\xf9\x82\x03\x3e\x9a\x76\xe2\xd5\x83\xb2\x6f\x7d\xc1\xf9\x81\xa9\x0e\xe8\xbe\xf8\x78\x0c\x9c\x10\xfe\x30\x63\x89\x18\x0f\x6e\xcc\x78\xa0\x16\x49\xdc\x62\x98\x4e\xc7\x7c\x42\x1c\xb0\x51\x9c\x30\x98\xfa\x41\x60\xe8\x2f\x11\x87\x79\xe2\x73\x4e\x7c\xc8\x55\x89\xab\x7a\x81\x50\x88\x5f\x3d\x78\x13\x8d\xb8\x16\x5c\x68\xb6\xcc\x6b\x00\x1b\x30\x3e\x74\x2d\xa2\x7a\x9b\x92\x29\x8f\x84\x36\x2c\x3e\xb0\xc9\x5a\x70\xc5\x06\x09\x9d\xaf\x16\xe4\x91\x12\x19\xbb\x87\x86\xd7\x18\xa5\x6c\x82\x82\xd9\x76\xe9\x38\x87\x93\xca\x35\x8d\xaf\x7a\x3a\x56\xd2\xd0\x1f\xf1\x12\x75\x24\x2c\xa3\xa0\xc4\x5d\xf4\xd1\x53\x00\xd4\x3d\x31\x89\x78\x91\x06\xb0\xaf\x29\xef\x19\x54\xb0\x7b\xf2\x91\xe1\x79\x7c\x32\x1b\x66\xa2\x4b\x28\xc7\xb3\x6c\x3a\xcb\x60\xe0\xa7\x2c\x80\x38\x12\x86\x55\x1a\x26\xbc\x27\x7c\x65\x32\x61\x91\x12\xe0\xf4\x32\xcc\x86\x67\xe0\x60\x86\x29\x3f\x43\x3f\x65\xd0\x78\xd6\xd8\xb7\xb9\x5b\x28\x74\xd1\x27\x7b\xfc\x60\x43\x62\x7a\x90\xe7\x74\x82\xd6\xad\x84\x96\xa3\x55\x4e\xdc\xca\xa1\xfd\xa7\x01\x4d\x92\x56\xc9\x9e\xe2\xc1\x1c\xd1\x9f\x63\x50\xd1\x8d\x55\x3a\x23\x80\x8a\xe3\xdc\x02\x32\xc2\x66\x2d\xe0\xb2\x4c\x23\x39\x60\x4a\xda\xc5\x2e\xa8\x5c\x79\x0b\x4b\xc1\x7a\x11\x9d\xa6\x83\x66\x16\x7f\x22\x57\x84\x92\x0b\x84\xfa\x74\x53\xad\x95\x2d\xcf\x77\xd3\x69\x86\xc0\xa9\x33\xe4\x9c\x29\x48\x7d\xd0\xab\x63\xcf\x8e\xdb\x80\x8b\x0a\x72\x05\x12\xcb\x75\xe7\xbe\x97\xe7\x5e\x6e\x09\xca\x65\x63\xd4\x30\x52\x5d\xc3\x53\x9b\x99\x91\xef\x36\xf7\x0c\x43\x78\xcf\x8a\xe9\xb3\x8c\x13\x81\xde\xb8\xad\x8e\xa9\xeb\xf2\xb9\xdf\x75\x5d\x58\x87\x6d\x8d\xc5\x79\x3e\x9a\xd0\x26\x73\xad\x15\xb8\x69\x54\x0b\x6b\x84\xa1\x15\x51\x7e\x3f\x22\x67\x9e\xcb\x6c\xe7\x1c\xd6\x41\x99\xc8\x53\xc3\x2e\xba\xca\x87\xde\xfb\x6a\x70\xd2\xbe\x1e\x3d\xcf\x48\xa6\x91\xdf\xb7\x7e\x55\x3b\xc1\xed\x7d\x87\x80\xda\x2b\x07\x1f\xc8\xb1\xd6\x4d\x77\xec\x97\xdf\x2d\x7e\xf0\x60\x6b\x0b\x7a\x3d\x3e\xc1\xf4\x51\xaf\xf6\x7b\x29\xfd\x8b\x3b\x08\xfd\x5e\xab\xdf\x43\xd5\xdf\xef\x79\xfd\x9e\xde\x65\x11\xcb\x69\xe1\x94\x07\x5d\xd8\xfa\x4f\xe7\x70\xdf\x69\xba\x87\x4e\xef\xd9\xf3\xee\x7f\xf6\x5d\xfe\xb5\xf1\xf7\xcd\xbf\x3b\xd0\xe7\x9f\x7f\xfa\x17\xfe\xa7\xe5\x1e\x3a\xe8\x97\xe7\x78\xfc\xab\x49\xdf\x3d\x7f\xf3\xf7\x1f\xfa\xee\xe1\x9f\xb6\x42\xd3\x0d\x2f\x47\x8c\xfc\xbe\x9a\x54\x3c\xec\x12\x5e\x57\x96\x24\xcf\x3c\x3b\x5b\x87\xf8\x84\x6e\xbe\xaa\x11\xfe\x93\xfc\x7e\xd2\xcc\x8f\x86\x2c\x1e\x19\x78\x55\xb7\x66\x04\x2e\x21\xb7\xb7\x2e\x24\x8c\x3c\xb6\x0c\x61\x77\x21\x3b\x4b\xe2\x4b\xc4\xfc\x55\x92\xc4\x89\xd3\x08\xa3\x0b\x7f\x1c\x06\x8a\xbf\x1b\xb0\x01\xb9\xfd\x3d\x0a\x39\x9a\x0d\x95\xcd\x21\xb6\xfa\x30\xad\xd7\xee\xe3\xa6\x24\xa8\xcd\x20\xb9\xd3\x47\xd9\x1d\xca\x7e\xae\xb2\x53\x33\x77\x9b\x72\x37\x75\xae\xdc\xe6\xa3\xfc\x1d\xca\x57\xd9\x62\x8b\xef\xe1\x43\xca\xde\x55\xbb\x2a\x72\x73\x8f\xd2\x1f\xf7\x71\xcd\x26\x7f\xa8\x2d\x65\xb1\xc1\x27\xab\x3f\xd1\xfb\xad\xc6\xf6\x03\xe5\xed\x99\x20\xf6\xfa\x62\x7a\x6b\x2b\x5d\x24\x06\x91\xf2\x9f\x0a\x34\xa5\xff\xdd\xe7\x33\x06\x8d\xa8\x41\x85\x68\x63\xca\x1f\x87\x7e\x8a\xbe\x38\x0d\xef\xb4\x21\x9d\xa0\xf4\x1a\x2b\x6a\xb8\x0a\xbf\x2c\xe1\x86\x90\x54\xd8\xa7\x0a\xec\x3b\x7f\x0a\x72\xbc\x78\x6e\x2a\xb7\x6f\xa4\x72\x15\xd3\x9d\x19\xf5\xec\xe1\xf2\xe2\x5a\xb9\x75\xe5\x2a\x5c\xb4\x87\xe1\x88\xc6\x02\x59\x21\x4c\x8d\xad\x27\x35\xb3\x9f\xc6\x2c\x15\x46\x21\x8e\x39\x5f\x48\x09\x3b\x3b\x08\x4f\xc3\x2c\x95\x44\x40\x40\xdf\xbe\x81\x43\x7c\xc5\xa9\xd1\xc2\x1d\x49\xc1\x49\x3c\xa1\xdb\x70\x5d\x39\xfa\x44\x1e\xc1\x84\x68\x8e\x4a\x96\x6b\x74\x09\xc1\xec\x2c\x4c\x9b\xa2\x00\xff\x73\x20\xd3\x64\x41\xfc\xab\x52\xe5\xd6\xb3\x95\xa6\xf6\x9b\xf1\x43\xa5\x0b\x1c\xf8\x1f\x95\x26\x99\x0f\xff\xaa\x54\x39\x9a\xf8\x57\xa5\x96\x6e\x74\xa9\x5c\x41\x67\xda\x2e\xbe\x7a\xf0\xa0\x52\x47\xd4\x98\x34\x32\x3a\x8f\xa4\x81\x60\xd8\x0d\x83\x02\x76\x52\x5a\x4c\xc1\x3e\xab\x34\x47\xf7\x9c\x36\x84\x71\x09\x9e\xcb\x16\x44\x50\x3b\x76\xb8\xfb\x60\x6e\xc3\x19\xa5\xbe\x41\xcb\xcd\xd7\x27\x72\x1d\x42\xc3\x2b\x87\x5f\xb6\x2b\x88\x6d\x34\x9a\x5c\x67\x99\x3b\x78\xb9\xf2\x76\x6b\x8a\xce\x07\x0f\xae\x4a\xe6\xe6\x3f\xd6\xed\x40\xcb\x55\xab\xe6\xf0\xf2\xe6\xef\x9a\xdd\xff\xf1\xab\x3a\x48\x43\x27\x84\x5a\x5f\x9a\x8e\x38\x83\xbd\xf1\x41\x29\xe7\xff\x46\xa3\xee\x04\xae\x48\xd4\x8a\x63\xb8\xc6\x0f\x0d\xe3\x99\xa8\xb9\x07\x53\xc3\xf3\xc2\x99\xc3\x3a\xb4\x5b\x2d\xb7\x99\xc5\xe8\x6d\xe3\x4c\xdd\x03\x7a\x62\xaa\x31\xb0\xea\x19\x95\x90\x45\x71\x6b\xd2\x99\xbb\x4a\x80\x9d\x8e\xaa\x39\xac\xaa\x39\xa7\x25\x89\x28\x16\xac\xd8\x40\xbb\xa5\x5a\x60\x35\x7d\x9a\x37\xb3\xf8\x95\xde\xda\x32\x7a\x34\xba\xa6\x56\x9e\x02\xa7\xd7\x94\xff\x20\x45\xd3\xa8\x13\xaf\xd8\xa9\x3d\x55\x73\x5a\xd3\xda\xf2\xa7\xbc\x8a\x39\x4b\x17\x2c\x62\xb8\x39\x70\xd9\x6c\x52\xcb\x66\x4b\xc1\x45\x38\x69\x2d\x9c\x52\x09\xad\x02\xf5\xcb\xaa\x8c\xf1\x98\xff\xf8\x32\x9d\xca\x43\x3d\xd9\xb7\xf9\xea\x80\x0e\xe0\xaa\x7c\xb1\xf3\x4f\xfc\x32\x80\xbd\x5d\x7d\x63\xff\x31\x43\xe5\xe0\x6e\x6a\xcd\x6d\xef\x8e\xba\x6f\x94\x6b\xfb\x2e\x9c\x47\x84\x6c\x18\xf7\x11\x97\x59\xca\xe7\x50\x2f\x17\x0f\x14\x0c\xb9\x02\x09\xdc\x9c\xde\x52\x11\x53\xd8\x68\x14\x0e\x43\x72\x6c\x08\x7a\x2d\x65\x7e\xcb\xed\x02\x4c\x6e\xf7\xcd\xe0\xac\x2a\x6b\x13\x9c\xdc\xf1\xc1\x72\xdb\x15\x0a\x80\xde\x6d\xc0\xe0\xb6\x66\xc0\x7f\x03\xb3\xe2\x6d\xf8\x90\x2e\xfa\xc1\xa1\x59\x4c\x39\xe1\x87\xf0\x3c\x9f\x07\x1b\xc6\xb6\x6b\x08\x9b\x10\x19\xbb\xad\x8d\x56\xc3\xb5\x2a\xb7\xec\xca\xe6\xc6\x38\xa7\x1e\x1a\x37\xc5\xfc\x50\x03\x69\xb4\xb0\x8c\x6e\xb2\x8d\x41\xbd\x75\x73\xb0\x71\x97\x03\x6d\x1a\x5a\x53\x7c\xb1\x60\x13\xda\xae\xdb\x6b\xd1\x7d\xa6\x31\x4b\x53\xc8\xce\xfc\x08\xda\x8b\x87\xe5\x1a\xe1\x8f\xfb\x38\x05\xc5\x0a\x13\x77\x3b\x2e\x7c\x11\xe7\x57\x05\x9f\xcb\x47\xa6\x93\x57\x4c\x5b\xd6\xbb\x5f\x6d\x5d\xd2\x78\x86\x4f\xe4\xce\x5b\x2a\xb7\x17\x6a\x01\x98\xb7\x8d\x64\x2d\x00\x99\xba\xa0\x3a\x6f\xc3\x33\x98\xab\xb8\xf8\x9c\xf9\x43\xce\x23\x1c\x5c\xd8\xf6\xa8\xd5\xec\x40\x65\xce\x5b\x1e\xb5\x35\x6f\x7b\x04\x5d\x6f\x5b\xea\xe6\x31\xb6\x20\x75\x55\x48\xcb\xbc\x85\x72\xac\x51\x31\x8b\x60\xec\xe8\x79\xdb\x0c\x97\x4e\x05\x2b\xf6\xb9\xfe\x58\x0f\x53\xd0\x60\x0f\xfd\x31\x8b\x02\xff\xa6\x1b\x5c\xc1\xf6\x35\x61\x30\xf1\xca\xe8\x8d\x4c\xf1\x60\xfb\xd8\xb8\x53\x54\x13\xd9\xea\x86\xd1\xbe\x3a\xbc\x85\x2c\x9c\xd4\xdc\xc1\xee\xdc\xd0\x4d\x74\x5b\x81\x26\x25\x52\xb3\x88\xb8\x61\xf8\xd1\x9d\xa5\xc2\x8f\xde\xcc\x03\x75\x18\x47\x59\x18\xcd\xe2\x59\xf5\x96\x65\x7b\xe7\x86\x78\x3f\x3e\x3e\x8e\xc2\xba\xd7\x23\xf7\x1e\xe7\xfc\x4e\x83\x59\x82\x9e\x48\x9f\xd8\x30\xc6\xa8\x5c\xed\x56\x4b\x28\x17\x99\xf5\x2e\x8c\x66\x19\xe3\x1a\xc3\x2e\xbb\x0e\x8f\x73\x25\xff\x12\xcf\x12\xa3\x9c\xa8\x58\x2c\xf7\x12\x9f\x21\xb2\x6a\xad\x43\x67\xc7\x2e\xf4\x57\xc6\xce\x8d\x52\xbc\xce\x3a\x3c\xc9\xa1\x16\x47\xb8\x15\x62\x17\xda\xce\x35\xf7\x37\xe6\x27\xc5\x42\x8f\x77\xcd\x3d\xd8\xc0\xcf\x98\xbc\xca\x66\x6c\xb8\xbe\xa4\x64\xfb\xde\x33\xdd\xb9\xcb\x95\xce\x8c\x3d\x54\xac\x06\x87\x80\x31\x6a\x36\x14\x9c\x8d\x3c\x20\xa9\x1d\x9c\x05\xf3\x13\x0f\x26\xbc\x37\x1e\x5c\x32\x76\xee\x41\xe0\x2f\x3c\x38\x8b\x67\x3c\x1d\xe9\xe8\x41\x8a\x74\xe7\xbf\xc7\xe3\x50\xfe\x20\x11\x30\x9e\x57\xc0\x6b\x39\x4b\x18\x5b\x39\x56\x2c\x8b\x96\xb4\x4a\xed\xa1\xa8\x6d\x28\x95\xb7\x61\xc4\x29\xcf\xd7\x0b\x2b\xa9\x22\x09\xcc\x48\xfc\x89\xae\xf0\x72\xa4\xd4\xcc\x17\x5d\x30\x7a\x32\x06\x5d\x56\xe9\x67\x21\xfc\xae\x19\x1d\x56\x4d\xa1\x44\xb3\x77\x9a\x8c\xea\x44\xc2\x69\x34\x7f\x78\xdb\x50\x6d\x88\x0d\xf5\x7c\x99\xfd\x1f\x3e\xe5\xcb\x28\x21\x91\x65\x7e\x78\xb3\xff\xc3\xbb\x7c\x29\x21\x20\xba\x0c\xfc\x30\xcd\x97\x21\xe1\x50\x45\x7c\xf8\x21\xc8\x17\x11\xa2\xa1\xca\x0c\x4a\xca\x48\xd1\x50\x85\x7e\xcc\x97\x10\x62\xa1\x0a\xfc\xad\xa1\x8d\x0c\x7a\x56\x85\x26\x62\xf4\x49\xc7\x9a\x3d\xc9\x74\xd0\xf6\x04\x9d\x2d\x95\x20\x2c\x09\x5d\x6c\x97\xff\x0f\xd6\xaf\x29\xd6\xde\xe5\xff\xbb\xb6\xd8\x76\x8b\xff\xaf\xb2\x98\x94\x92\x02\x6e\x34\x34\x85\x62\x79\xdc\xca\x8b\x15\x70\x2b\x2f\x56\xc0\xcd\x2e\x06\x42\x92\x0b\xb8\x21\x43\x40\xa1\xd8\x36\xff\x9f\x01\xad\xa2\xd8\x63\xfe\xbf\x6b\x8b\xb5\x3b\xfc\x7f\x35\xc5\x48\xd7\x14\x70\xe3\x8c\x58\x52\xac\xc3\xff\x67\x40\xcb\x17\x23\xf5\x55\x80\x86\x3c\xab\x8b\x09\x5d\x57\x1c\x2c\x64\xdb\x42\xb1\x3c\x41\x72\xc5\x80\x14\x68\x01\x1a\xb2\x38\xf4\x1f\x00\xf4\x6d\x27\x76\xce\xdf\xe2\x58\x9c\x6b\xfe\x5c\xb4\x0a\x87\x58\x4e\x64\x3d\xc3\xc9\x01\x0e\x8b\x6a\xc3\x70\xe9\x24\x46\x28\xaf\xf1\x29\x5f\x98\x8f\x4b\x15\x70\x0e\xc6\x28\x1a\xf8\x8b\xf2\x92\x7c\x10\xcd\xf6\x39\x41\xf2\x25\x1d\x3e\x16\xe5\xd5\xf9\xa8\xed\x1b\xea\xc4\x74\x4f\xe5\xc4\xac\x40\x8f\xb7\x62\x94\xd4\x8a\xc4\xa5\x0a\x45\x67\x05\x53\x93\x38\xd2\xb6\xf7\xa0\xe2\x61\x3e\x5a\x7e\xc8\x62\xfa\x01\x14\x9d\x82\x6f\xf1\x60\x49\xe9\x8d\x29\xfd\x68\x78\x4b\xe2\x2d\xb2\xdc\x11\x11\xcf\xf0\x21\x61\x7e\x1a\x47\xf8\x9c\x07\x16\x95\x30\x25\x30\xcb\x39\x87\xcd\x33\xbe\xb6\x16\xb7\xec\xc5\x74\xe2\x47\x01\x87\x13\xcf\x4e\xcf\x80\xa5\x59\x38\xe1\xb4\xe1\x45\x38\xb8\x34\xfc\x5d\x7b\x32\x1b\x37\xf7\xfd\x34\x9d\x4d\x98\xee\x41\x98\x82\x3f\x4e\x98\x1f\x2c\xc0\x07\x6e\xc5\xea\x2c\x0e\x9f\x2f\x3d\x42\xe1\x0a\x24\xcf\xec\xe2\x91\x41\x00\x3c\xbe\xc3\xe9\xb0\x61\xfb\x01\x67\x7e\x72\xca\xb2\xba\x97\x95\x14\xf9\x73\xee\x80\xcb\x85\xb6\x54\xf1\xbb\x69\x76\x1e\x70\x21\xc8\xe2\x44\xbc\xa7\x2f\x17\x5c\xa1\xf9\x58\x41\xaf\x83\xf7\xff\x9a\x49\x78\x7a\x96\x39\xd6\xa4\xe2\x09\x7c\xad\xb8\x1b\xb4\xf9\x61\x95\xcb\x85\x6c\x00\xf1\x0c\xd4\xea\x58\x9f\x22\xd6\xf2\x89\x2a\x23\x44\x2b\x6c\x59\xfa\x42\xbc\x3e\x97\x4f\x54\x8b\x74\xed\x65\x64\x30\x25\x17\x99\x9c\x6b\x33\xf6\xc7\x44\x3b\x84\x5c\xd7\x7a\x62\xc4\xb6\x72\xc9\xb8\xc7\xd1\xef\x75\xfa\xf0\x2c\x9f\x83\xa9\x5b\x72\xa8\x0f\x69\x3b\x04\xf6\x41\xbe\x99\x61\x90\x27\xec\xb5\xfb\xa5\xb8\x86\xbd\x56\xbf\xd2\x0d\xfb\x8e\x69\x2b\x25\xbc\x9e\x7a\x86\x41\xab\xdd\xae\x40\xfb\x55\xa9\x48\xb5\x1c\x37\x75\x1c\xa7\x00\xec\xeb\x3d\x03\x76\xc1\x92\x85\xa3\x9e\xb2\x33\x1e\x08\x50\xe6\xa2\xe2\xd4\x45\x4e\xeb\x2b\x3b\x9d\x8a\x3a\x0b\xb7\x10\x7a\xbe\xe6\x95\x81\xea\xc8\xf3\x22\x32\xfc\x32\xab\xcd\xdc\x8b\x01\x22\x32\xbe\x27\x56\x1c\xae\xcb\x27\x04\x82\xe6\x36\x27\xfe\xd4\xd0\xb9\x06\x92\xf2\xf5\x3e\x2d\x92\x86\xd6\xd5\x8a\x56\xee\xca\x4a\x80\xc6\x7d\xa2\x56\x6e\xc3\x14\x20\xc3\x1d\xa3\x5e\x60\xec\x31\xf5\xed\xf0\xbc\x59\x9b\x73\x6b\xcb\xa8\xa2\xa3\xa9\x24\x2e\xee\x12\x65\x2d\x8f\x60\x67\x6d\x8f\x20\x1a\x5b\x48\x15\xf3\x04\xd6\x69\x7b\xd6\xeb\x84\xbc\x34\x1c\x42\x26\x62\xeb\x53\x11\xe9\x24\x2c\x02\x1d\x85\xd1\x70\x3c\x4b\xc3\x0b\x86\x0c\x68\x8e\x50\x42\x55\xe5\x0b\x83\xb0\x2f\xf6\xaa\x72\x14\x24\xeb\xc0\x24\x23\x4e\x2d\xa6\x37\x9b\x3d\xf2\x86\x77\x9d\x62\x51\x03\x90\x9c\x2c\x2d\x9f\x1d\xbb\xd9\x88\x1e\xe0\x5d\x71\xdc\x2c\x47\x34\x63\xea\xac\xa2\x28\x0e\x6c\x61\x2c\xc5\xf3\xb2\x6a\xf4\x14\xdb\x5e\xab\x09\xd4\x9e\x43\xe9\x16\x6e\x60\xc8\xbe\x69\x63\x94\xbe\x3d\x71\xcd\xab\x0b\xab\x2f\x69\x09\x21\x04\x4b\x3a\x89\x37\xe3\xdd\xe5\xba\xbb\xee\xe5\x86\xd5\x77\x88\x07\xb9\x1d\x62\x6b\x87\x41\x61\xbd\xd4\xa6\x5b\xaf\x71\x2e\x94\xf2\x84\xfd\x6d\x89\x65\xb8\x55\x75\xa4\xaa\x92\xa1\xbd\x4a\xdd\x5f\x55\x5d\x34\xf9\x57\xa9\xea\xab\xaa\xb8\x47\xb3\x42\xcd\x81\xaa\x49\xbb\x49\x2b\x54\x0d\x74\x5f\xc5\x7e\xd5\x0a\x95\x4f\x55\x65\xb9\x29\xb6\x42\xe5\xa1\xd1\xb2\xde\x8a\xb8\x06\x42\x71\xf3\xd3\xa4\x9b\x50\x36\x9c\xd9\xe5\x8b\x24\x3d\x35\xaf\x75\x5a\xad\x96\x47\x4f\x54\x7b\x50\x4c\xed\xb8\xfd\xaa\xe8\x4a\x7f\xac\xd0\x9e\xcb\x07\x27\xea\x74\x76\xea\x63\xd9\x68\x9a\xfd\x33\x06\x28\xaa\xeb\xd5\x07\x3f\x49\xef\xbe\x1f\xf7\x13\xc8\xa8\xaa\x1f\xb3\x6c\x58\xd6\x8d\xbb\x8e\x77\xf4\x74\x59\x1e\xb9\x8b\x98\x47\x61\x1a\xbf\xbe\xe6\xd4\xe2\x69\xab\x1e\x21\x05\xe2\x86\x98\x6c\x2b\x4c\x90\xba\xd5\x1e\x52\x9d\xc7\xd7\x22\xa2\xc6\xa7\x34\xbe\xcb\x77\x88\xbf\x7a\x43\xd7\x73\x1a\xca\x9b\x1f\xcb\x2d\x71\xb2\x65\x3e\x51\xc8\x5b\x43\x6d\x1b\x68\xdf\xe9\x16\x3c\xeb\x42\xd0\x5c\xc0\xa3\x47\xf8\xe7\x19\xba\x78\x99\x56\x9e\x9f\x31\x23\x8c\xb3\xb3\xd9\xf6\x20\x68\x4e\xf8\x3f\x01\xff\xe7\x2f\xfc\x9f\x77\xfc\x9f\x4f\xfc\x9f\xb7\xf2\xf5\x32\x3f\x63\xcd\x94\x65\xaf\x67\xe3\xf1\xdf\x70\x2b\xa7\x99\x7b\x71\x24\x10\x41\xa1\xaf\x4a\x0e\x3b\x82\xe6\xe2\xda\x56\xcc\x33\x8c\x59\x36\xbc\x75\xc7\xf8\x3f\xcd\x2f\x9f\x8f\xae\xef\x61\xae\x8b\x5f\x3e\x1f\xdd\xac\x97\xaa\xc5\xeb\xbb\x9b\x3f\xfc\x61\x97\xd8\xdc\xc2\xb2\xcd\xbe\x2e\xf6\x61\xe1\xc1\x64\x9f\x4f\xa4\xc1\x3e\xb4\x3d\xf8\x0b\x7e\xbf\xc3\x7f\x3f\xe1\xbf\x6f\xf7\xa1\x95\x0b\xa1\x6b\x32\x63\x21\xdc\x8a\x50\x5c\xbc\x1f\x9f\xc3\x09\x33\x22\x8f\x88\x14\xb9\xd8\x32\x0a\xda\x85\x72\x05\x32\x0b\x4a\x56\x84\x30\x65\x49\x18\x07\xa9\x15\x08\x84\x27\xe4\x8a\x71\x4b\x39\xf0\x17\xa9\xd9\xd8\x22\x5f\x28\x3d\x8b\x13\xdc\x5a\xb4\x4b\x62\xf2\xcb\x62\x71\x34\xc2\x8d\x72\xf4\xbb\x0c\xe6\xbb\x5c\x49\x23\x51\x9d\x5f\x10\xde\x1f\xf5\x81\xcc\x47\x49\x5e\xd9\x47\xd7\x08\x7e\x12\xc6\xc1\xdb\x38\x3e\xc7\xd8\x36\x72\x44\xf8\xcf\xaa\x2a\xa2\xff\xa5\xe0\x25\x6d\xf2\x85\x6b\x1b\x28\x54\x32\x89\x57\xda\x8c\x45\xdd\xd2\x6a\xb5\x0d\x96\x57\x47\x9a\x97\x36\x47\xa3\x61\x17\xac\x6d\x20\x57\x41\x8f\x51\x75\x6f\xde\x55\x55\xb9\xbe\x27\xa2\x6a\xee\x80\x8f\xf3\x08\x29\x9d\x86\xdf\x90\xeb\xef\x4f\x46\xcf\xa9\xa9\xc6\x8b\x86\xb9\x13\xae\xd3\x07\x76\x25\x6c\x44\x64\xfd\xa8\xb2\xcc\xd4\x61\x63\x1f\x57\xfe\xe2\x67\xa0\x0a\xbd\xf4\x17\xef\x47\x66\x49\x56\x9d\x35\xd2\xa0\xc3\x61\x12\xd3\xaa\x40\x08\x42\xe3\x2f\x2a\x93\xaf\x73\xe4\x91\x79\xe3\x8d\x95\xdc\xee\x88\xe4\x5f\xed\x56\x70\x23\x93\x72\xde\x1a\x8d\xa8\xa5\x87\x6c\x64\x62\x77\x8e\xce\x5e\x45\xde\x3b\xa3\x22\x5f\x2d\xc9\x3a\x53\x95\xfe\x01\x85\x45\x24\xff\xbb\x4a\xfe\x12\x85\x73\xae\xb3\xd2\xcc\x9f\x4c\x45\x6e\x5a\x9e\xfb\xc9\xc2\xe6\x93\x1e\x05\x2b\x7d\x96\x1f\x35\xc2\xf3\x5d\x1c\xe9\x11\xfc\x62\x95\xa1\x02\x9f\x66\x46\x81\x9f\x4b\x0a\xbc\xf9\xf4\x5e\xe4\x5e\x96\x37\x61\x41\xf8\x6b\x09\x04\x0b\x87\xb9\xcd\x14\xbf\xd8\x3f\x17\x0d\xf3\x14\x45\x24\xfe\x4d\x25\xca\xd9\x4d\x64\xfc\x87\xca\xf8\x8f\x38\x12\xca\x9b\x3c\xc7\x49\x32\xc2\x8c\x25\xfe\xf8\x03\x45\xb8\x51\x1b\x13\x5c\x22\x66\xd9\xf0\x75\xb5\x50\x7c\xf9\x7c\x54\x2b\x17\x5f\x3e\x1f\x55\x89\x86\xac\x5a\x2e\x1d\x5f\x3e\x1f\x2d\x25\x20\x5f\x3e\x1f\xd5\xc8\x48\x59\xee\xc8\x6a\xa3\x4e\x52\xbe\x7c\x3e\xaa\x10\x16\x91\x53\x22\x2f\xb2\xc5\x52\x91\xc1\x06\x6b\xa4\x46\x76\xba\x42\x70\xb0\x7a\xb9\xec\x7c\xf9\x7c\x74\x7f\xe2\xc3\x47\xaa\x42\x82\xf4\xf8\xd6\x0a\x91\x28\x56\x2b\x47\x56\x99\x32\x51\xca\xb7\x55\x21\x4d\x16\x9c\x1b\x09\xd4\x97\xcf\x47\xa5\x32\x65\x18\x8d\x05\xb1\xfa\xf2\xf9\x68\x55\xc9\x9a\xf2\x15\x50\x4e\xaa\x30\xad\x42\xa2\x30\xaf\x28\x4d\xba\x4a\x5e\x92\x30\x27\x2f\x45\x98\x48\x76\xe3\x4b\xcb\x1a\x44\xa1\xc2\xdc\x52\x81\x2a\xcf\x19\xa9\x66\xca\x05\x09\xf3\x0a\x42\x54\x4c\xfd\xd5\x6a\x21\x27\x3c\xa2\x81\x52\xc1\xd1\x7d\x2c\x08\x8d\xa8\x96\x17\x18\x4c\x2e\x08\x0b\xa6\x56\xc9\x4a\x31\xb3\x28\x2a\x34\x0c\x05\x31\x31\x07\xad\x42\x44\x54\x91\x0a\xf1\xc8\xe5\xdb\xa2\x51\x84\x5f\x10\x8b\x5c\xfd\x82\x48\xe4\x38\xc2\x90\x0e\x23\xc7\xe0\x93\x85\xcc\xc9\x09\x09\xa6\x95\x08\x08\xa6\xe7\x84\x83\x20\x97\xcb\x06\x5d\x4c\x4d\x19\x24\x6c\x38\x4b\xf0\x28\x26\x08\x13\x36\xc4\x58\x3b\x01\xc3\x40\x1a\x61\x1c\xa5\x2a\x48\x57\xc0\x46\x2c\x49\x28\xba\x9c\x30\xe0\x9a\x73\x2b\x82\x81\xb1\xce\x91\x1b\xf0\xa9\x7c\x23\x0a\x8b\xff\x52\x56\x1c\xd7\x39\xa5\xc5\x87\x55\xd0\x3f\x17\xaa\xe8\xf9\xb3\x0e\x27\x5d\x2a\x5f\xa9\x06\xb3\xea\x4a\xd7\xe0\x67\x55\xbc\x26\x44\xa3\xee\x8d\x7d\xa6\xa2\x9d\xd1\x0d\x37\x18\xe1\x49\x28\x6f\x7c\xf6\xfa\x79\x87\x81\xcd\xb6\x99\xf2\xab\xe9\x90\x0e\xe2\x92\x83\x0e\x05\x51\x8c\x20\x33\x34\x7f\x4c\xfd\xc0\xfc\x49\x68\x5a\xc1\xc8\x1e\x22\x72\x79\xff\x4a\xd7\x2d\xec\x23\x6c\x88\xf3\x50\xb9\xf2\xaa\x8c\x62\x84\x4f\x3c\xe8\xb8\x8b\x66\x04\x23\xf4\x40\xd8\xce\x85\x2d\x12\xcf\x29\xe0\xfb\x16\x46\x44\x48\xf4\xcc\xff\xd5\x83\xd0\xb5\xa2\x0a\xe1\x43\x1f\x53\x7c\x66\x7a\xea\x07\x69\x6f\x68\x47\x79\x3c\xf3\x93\x17\x19\xc7\xca\xed\xbb\xf0\x50\x7a\xb8\x54\x16\x32\x21\xe3\x61\x3d\x41\xa6\xb0\x49\x0d\x86\x71\xaa\x00\x6f\xa6\xb6\x1a\x79\x2c\x46\xea\x10\x93\x06\xbf\x37\xec\x53\x4b\x23\xed\xfb\x84\x57\xa8\xad\x56\xcc\xde\x0e\xad\x1c\x3e\xd2\x18\x8e\xc9\x78\x91\xe1\x81\xfc\xfb\x60\x55\x5a\xa9\x63\x7d\xac\x60\x3f\xf6\x70\x55\xf4\x24\x8a\xd8\x25\xee\x36\x9a\x4c\x1d\xb1\xcb\x97\x45\xff\x2d\xc5\xd4\x04\xda\x66\x6b\xf1\x32\x1a\x6e\xe2\xb4\x9f\xb6\x5a\x6e\x9e\xb9\x69\x0a\x50\x51\x0f\x02\xe3\xc8\xd7\x93\x42\xb1\xd1\xc5\xb7\x70\xec\xca\xea\x00\xd1\x76\x69\x79\xd8\x95\x5d\x94\xae\x2c\x2a\x94\xcc\x78\x9c\x0b\x82\xe4\xc3\x97\x9f\xde\xfc\x82\x5b\xce\x38\x41\xe5\x3c\x99\xa4\x5f\x4d\x66\x06\x3c\x6a\xfc\x7b\x03\xc2\x08\xf4\x3d\x28\x63\x2f\xef\xdf\xad\x18\x51\x9f\xcf\x18\xf8\x93\xcd\xe9\x04\x46\x63\x1f\xa3\x29\xb5\x30\x46\xc0\x8b\x77\x14\x78\xac\x8d\xbf\x3e\xbc\xb3\xa0\x4f\x25\xf4\xa0\xf9\x17\xe8\xe2\xbf\x3f\x40\xbb\x03\x1b\x10\x34\xa7\xb0\x0e\xed\x8e\x1d\x86\x8a\xfc\x2c\x02\x7f\xb1\x19\x8f\x36\x39\x49\x10\x34\xff\xe0\x09\x0b\xe6\x27\x90\xc5\x32\x9f\xff\xb4\x5a\xfb\x59\xb6\x66\x0b\x6b\xd0\xfc\x19\x9e\x41\x1b\xbe\x7d\x03\xfe\xf9\x1c\x76\xb7\x73\x64\x34\x4b\x3f\x74\x1a\x97\x02\x0e\x47\xfb\x52\xbf\x67\xab\xda\xf9\x8f\x62\x3b\x34\x80\xd0\x55\x5b\x9a\x92\x4b\x82\xe6\xc2\x75\x71\x60\xa1\x8b\x65\x9a\xa7\x4c\xac\x10\x1c\x4b\x3c\x44\x7d\x5e\xf0\x39\xec\x20\xb2\xbc\x4e\xb7\x8b\xd7\xae\x96\xda\x51\xee\x71\x7a\x6f\xad\x73\x1c\x68\x86\x27\x3f\x10\x16\x8e\xd1\x99\xcf\x85\xa5\x9e\xd5\xa9\x07\xe7\x12\xa8\x12\xcc\x97\x84\x39\x96\x30\xc5\x31\x6d\x33\x1e\x8d\x52\x96\x39\x24\x00\x38\x58\xf8\xea\xea\x3a\x3c\xb1\x5a\x09\x9a\x39\x0a\xaa\xcd\xdb\x5c\xb1\x89\x5d\x0c\x0d\xc3\x7c\x99\x20\x3f\x18\x19\x73\x30\xaa\x1f\x1f\xf0\x0d\x78\xec\xc2\x0f\xf0\xc4\xd0\x53\x79\x4f\x27\xd5\x69\xa1\x43\xea\x87\xfb\x7e\xc6\x9a\x99\xe7\xec\x77\x30\xd8\x65\xf0\x6e\x3d\xda\x85\x53\xf9\x9b\x0d\xf7\x32\x63\x7d\xed\x40\x5f\x3b\xca\x0f\xac\xd1\x46\x51\xff\x2b\x89\x3a\xc6\x4c\xf9\x52\xae\x5e\x4a\x14\x46\x63\x26\xaa\x1d\x42\xd0\x9c\xf1\x56\xf8\x14\xfb\x57\x95\xd8\x86\x7d\x33\xa6\x28\x71\x8b\x54\x2b\x70\x58\xae\x44\x4c\xc5\x01\xfb\xe5\x9c\x57\xc2\x6d\x44\x24\xb3\x35\x24\x8a\x81\x8d\x45\x0e\x54\xcd\x7f\xe5\xc3\x01\x9b\xe0\x70\xcc\x36\x60\xd7\x15\x5d\xa0\x82\x41\xf3\x8b\x9d\x6f\x13\xf2\x2a\x3f\x2b\xe1\xc9\xc1\xef\x71\xc4\x72\x13\x92\x3f\x1e\xc3\x28\x64\xe3\x20\x05\x3f\x11\x9e\xac\xd3\x84\x65\x2c\x00\x3f\x85\x2f\x9f\x8f\x50\xf9\x67\x67\x2c\xd2\x00\x89\x7b\xc0\x1f\x0e\xe3\x04\x43\xb7\xc8\xa8\xc0\x2a\x60\xb0\x6a\xcd\x9a\x1a\x4a\x54\x36\x9f\x8c\x36\xf8\x9c\xf4\x1f\xb0\x05\xed\x56\x0b\xbe\xd9\x54\x7a\x27\x73\x7f\xe0\xb9\x3a\x47\xcc\x1c\xfa\xec\xaa\xac\xe3\xa6\x0f\x6f\xbe\x9b\x74\xf6\x80\x88\x36\x6d\x6b\x46\x8e\x69\x50\x6d\xc8\x2c\x61\x60\x78\xf0\x6b\xfe\x31\x6c\xc3\xc2\xae\xb7\xaf\xff\x7f\xf6\xbe\xb5\xaf\x71\x1c\xd9\xfb\x3d\x9f\x42\x9d\xdd\x21\x76\x63\x42\x12\x68\xba\x27\x99\x74\x6f\x5f\x98\x5d\xf6\xe9\x69\x38\xc0\x5c\xfa\x30\x1c\xda\x89\x15\xe2\xc1\xb1\xb3\xb6\x03\xc9\x00\xdf\xfd\xf9\xa9\x74\xb1\x64\xcb\x8e\x73\xeb\xcb\x0e\xbd\xe7\x0c\xb1\x2d\x95\x4a\x52\xa9\x54\x92\x4a\xff\x22\xb2\xa2\x18\x1c\xc9\x27\xc9\xf0\x06\x26\xd8\xcc\xcd\x0c\xe5\x94\x99\x4c\x1a\xfd\x0f\xf4\xb2\x83\x86\x62\xaa\xdd\x16\xd3\x68\xd6\x5c\xe5\x16\xf4\xd6\x96\xe2\xd2\xdb\xd3\x18\xd4\x5a\x5b\x57\xce\xc8\xd8\xe3\xc6\x18\x31\xa1\x5d\x1f\x8c\x69\xf4\x4a\x9f\x13\xb5\x50\xef\x22\x65\x05\x50\x1a\xf7\xf7\xc8\x30\xfe\xe0\xa4\xa0\xb5\x45\x13\x43\x34\x71\x53\x53\x3d\x49\x7f\xf4\x24\x03\x4e\xaa\xe7\x1f\x5b\x5b\xa6\x5c\xa7\x2c\x89\x0d\x94\xf1\x60\xfd\x23\x47\x18\xe8\x3e\x86\xcc\x9b\x2b\x77\x3f\xa0\xf7\xb0\x13\x2d\x86\xb2\x45\xf9\x11\x58\xa8\xca\xc1\xa7\x4f\x15\xc2\x48\xe4\xa2\x27\x26\xe7\xfe\x79\xfd\x42\x85\x55\xbf\xb0\xc0\x9c\x87\x0f\x49\x84\x68\x5a\x07\x9d\xcc\x4a\x3b\x5a\x85\xcc\xaa\xc7\x57\xe5\x59\xbe\x4d\xe5\x5d\x15\xe3\x65\x78\xbe\x5d\x8c\xdd\xdb\xd5\x72\x9a\xec\x00\xce\x6e\x60\x76\x9e\x56\x9e\xdf\xa1\x92\x73\x55\x2c\xcf\xe6\x76\xb8\x08\xa3\xc3\x55\xf2\xa8\xee\x94\x6a\x99\xe5\x28\x1c\x19\xe5\x9c\xd9\x77\x49\xb2\xce\x2c\x6d\xe1\x92\x4a\x97\xb2\x70\x7d\xe2\x99\x75\xc9\x1e\x98\x1a\x4e\x8a\xba\xee\x38\xf9\xdc\x11\x26\xcc\x45\x1e\xd1\x19\xf4\x6e\xe7\x20\x25\x8f\x98\x02\xee\xe8\x11\x31\x25\xc8\xcc\xcc\x5c\x92\x85\xd4\x86\x73\x10\xe2\x7a\x5d\x4f\x89\xb9\x15\x9c\x6f\x19\x40\xec\x5f\xc1\x38\x8c\x0c\x93\xcc\xb8\x8d\x66\x3e\xcd\xd4\x59\xdd\x1c\x5d\xc2\x2d\xcf\x22\xd2\x73\x75\x4c\x19\x82\x0b\x74\x4f\xb2\xe2\x2b\x22\x5c\xba\x93\xca\x91\x9b\xab\xab\xd8\xc1\xa1\xae\xb7\xb4\x30\xae\xc9\x86\x54\xfa\xf2\x80\x0e\xa8\x57\x82\x06\xa6\xdb\x4c\xf2\x46\x34\x90\xcd\xc3\xe3\xcb\xdc\x45\x68\x53\xfb\x53\xaa\x50\x9f\x99\xa5\xd4\x12\x04\xed\x30\x9b\xbf\x11\xe5\x2f\xb5\xfd\xc6\xd9\x13\xde\x6d\x82\xc1\xd1\x12\x0c\x8e\x14\x06\xc5\x1e\xf7\xd2\x8d\x98\xda\x66\x5f\x6d\x3b\x72\x4f\xd5\x45\x9b\xd2\xe2\x6b\x91\x95\x36\xa1\x88\xb5\x4e\xcf\x29\xc1\xb1\xeb\xae\xb2\x5d\x81\x60\x3a\xa8\x72\x49\x7e\x20\xf2\xab\x5e\x81\xed\x63\x56\x19\x7a\xdb\xe8\x84\xa2\xdd\xfe\x1e\x3d\xfd\xdd\xd9\xda\x81\x80\xe3\x7e\x10\xe3\x16\x72\xaf\xfc\x20\xc4\x11\x8d\xad\x2d\x8e\x74\xa8\x38\xd1\x33\x20\x96\xf5\xbb\x1d\x8b\x0d\xa5\xff\x8c\x83\x18\xd3\xb7\xe7\xbf\xff\xfe\x7f\x7f\x7f\xba\xf5\xea\xfe\xfc\xf7\x0b\xc3\xac\xdd\x3d\x5c\xec\x5c\xc9\x40\x0c\x23\xdb\xe1\x38\xf7\x10\xd2\x89\xc2\x5c\x4a\xf8\x06\x14\x3d\x53\x84\xf5\x40\xaf\x20\x1e\x85\x1c\x1f\x48\x1c\x5c\xd0\x78\x16\xaf\xd0\x36\x4d\xdd\x4a\x20\x98\x93\xc4\x02\x94\x5c\x59\x32\x49\x98\x33\x40\x63\x0b\x19\x8b\x83\xdd\x6f\x71\x8e\x5a\xec\x47\xca\xa5\x90\xb5\x8f\x11\x29\x2e\x85\x51\x2d\xc4\x10\xcc\xdd\x10\xed\x67\xa1\xca\xef\xbf\xff\x7d\xb3\x62\xea\x9c\x08\x4f\xb0\xe1\xdb\x43\x1c\x65\x30\x2c\x4e\xf0\xd5\xc1\x64\x64\x54\xfe\xcf\x78\xd5\x02\xe8\x26\x92\x0a\xae\x8f\x31\xc2\x1c\xbc\xe9\x1e\xc0\x9b\x2a\x26\x91\x08\x57\x5f\x08\xf3\xbd\x92\x0a\xa2\x70\xbd\x44\xaa\xef\x1e\x2c\x25\xb8\x04\x2d\x27\x69\xcf\xf4\x71\xcc\xd0\x1e\x9d\x43\x9a\x73\x37\x6d\xdc\xa1\x0e\x72\xa5\x2e\x18\xda\x23\x95\x99\xbc\xe3\x52\x8d\x21\xc4\x6d\x50\x2e\xd4\x3a\x23\x94\xda\x92\x0d\x53\x86\x1a\x92\x4c\xfc\x2d\x1f\xae\x4c\xe5\xd8\x9b\xc5\x7c\xd1\x7d\xb8\xd5\xf3\x35\x5e\x8c\xaf\x95\x35\x56\x53\xc7\xd4\xcf\xcb\x30\x75\x78\x7a\xb4\x7a\x8e\x7e\x59\x86\xa3\x15\xf4\x9d\x96\xa9\x5f\xe7\x67\x2a\xf1\x72\x5e\x82\x99\x3d\x1d\x33\xd3\xf9\x99\x59\x9a\x11\x6d\xab\x08\x46\x88\xb2\xa5\x3f\x5e\xa2\xfd\x17\xe8\x15\x6a\x7c\x5f\xaf\xa3\x16\x6a\xd6\xeb\x75\xb3\x3c\x97\xff\x1b\xf8\xba\x85\x11\xe7\x72\xe7\xff\x8c\xff\x35\xef\x8d\xf3\xad\xed\x8b\xdf\x9d\xdf\x1d\xd3\x78\xd5\x6a\xbd\x32\xe0\xa7\xf9\x6a\x27\x9f\xf7\x7d\x1d\xef\xff\x4b\xaa\x7d\xde\xb8\x40\xaf\x10\xe1\x74\xdb\xf0\xcf\x9b\x50\x0f\x9f\x63\x8e\xd7\xeb\x15\x73\x0e\xe6\x25\x57\x98\xd5\xb7\xf4\x10\xb8\xad\x5f\x00\x52\x5c\x69\x96\x12\xa7\xa1\xd5\x73\xe4\xcc\x2f\x84\xc2\xc3\x68\x29\x6e\x76\xf3\xda\xa7\x6e\xa1\x85\xd8\xa2\xee\x50\xab\x6f\xa1\x7f\xcd\xcf\x0a\xf3\x99\x5a\x3d\x2f\x3f\xcd\xcf\x0b\xf3\xa8\x5a\x3d\x2f\xa7\x8b\xb4\x4b\xe2\x82\xb6\x7a\xe1\x79\xbf\x08\x43\x89\xd3\xdd\x52\x0c\x69\x75\xd3\x7b\x8e\x08\x42\x21\x17\x61\xe0\xc3\x61\xc9\x3c\xca\x54\xf5\xf1\x2a\x60\x52\xac\x00\xe6\xb1\x67\x52\x5c\xe4\x31\xa1\xb8\xee\x2d\xd8\x50\xba\x16\xfa\x9f\xf9\xbb\x4c\xe7\x45\xb8\x62\x8e\xe8\x1c\x68\x52\x28\xe8\x7a\x29\xd6\xd2\x37\x0a\x08\x47\x23\x65\x3d\x40\x56\x57\x4e\x72\x90\x6a\xa1\x91\x85\x9a\x5a\x4b\x3f\x51\x64\x39\x14\xd8\x06\xc8\x0c\x12\x8d\xe6\x6c\x12\xd4\x9f\xe4\xfe\x1e\x90\xaa\x72\xa9\x29\x0a\x3f\x4b\xb0\x51\x18\x27\x70\xc6\x81\x36\x40\x3b\x94\x09\x35\x54\x78\xbd\xde\x34\x1c\xd3\x42\x0e\x6d\x92\x5d\x6d\x25\xd2\xba\x27\xa7\x61\x94\x64\xc5\xf4\x54\xd5\xa1\xd2\xcb\x2d\x73\x8b\x18\x24\xf5\x8a\x96\xa2\x6a\x79\xe4\x31\x48\x37\xd4\x00\xd9\x38\xbf\xcb\xa4\x19\x28\xb7\xa2\x34\x45\x91\x18\x9d\xce\x6c\xae\x53\xa5\xa5\xf4\x54\xb4\xab\x32\x09\x9f\x9a\x42\x52\x2a\x87\xef\xe2\x1e\x61\xe2\xd7\xf1\x9c\x42\x72\xe5\x15\x90\x5e\x5e\x65\xf9\x2d\x29\x5c\x83\x04\x57\x60\x9c\x38\x86\xac\x5e\x4a\xf3\xdb\x4a\x59\x94\x8d\x8a\x1b\x8a\xd8\x49\xe0\x47\xf0\xb2\x93\x72\x85\x31\xcb\xc4\x3e\x57\x18\x76\x05\xc3\x67\x83\x71\x18\x09\x27\x16\xa7\x38\xd4\x79\x09\x1a\xd4\xb1\xc6\x91\xbb\x76\x8e\x1e\xc9\xa3\xb9\xd2\x3e\x21\x4b\x86\x55\xd0\x12\xbd\x43\x63\x6b\x96\x1e\x17\x5c\x72\x15\xb1\x95\xfb\xba\x48\x56\x92\xe5\xf2\xc2\x62\xaf\xf7\x87\xfa\x5c\x62\x9f\x3f\xb9\x38\xaa\x03\x13\x75\x27\x29\xa0\x24\x2f\xd7\x4b\x52\x63\xf4\xf6\xb4\xf4\xe8\x5a\x36\x19\x84\x7f\xf2\x21\x48\x6c\x90\x3f\x03\x1f\x1f\x51\x8f\x2c\x59\xb6\x8d\x3f\x19\xdc\x3b\xdd\x1e\x35\xfe\x44\x4f\xe9\xde\x5c\x65\xab\x22\x05\xa8\x21\x0c\xfd\x89\x76\xd0\x3e\x38\xcf\x58\x34\xc2\x51\x33\xfd\xfd\x3b\xb4\x9f\x7c\xd3\x71\xa8\x5c\xd1\x2a\xa8\xb6\xf0\xd4\x2b\x68\x3d\x71\x61\xab\x98\xce\x6c\x03\x44\xdc\xef\x2a\x45\xa8\x9c\x19\x22\xdf\x0c\x5b\xda\x12\xc9\x38\x52\x2e\x22\xeb\x37\x9c\xc8\x1c\x76\x48\xea\x0a\x5b\x71\xfb\x94\xb6\x46\x52\x37\xf1\xf2\x0c\x12\x7d\xe1\x05\x36\x89\x7a\xa1\x6e\x06\xb3\xa5\x2c\x93\xe4\x0e\xde\xac\xaa\xcf\xb6\x4f\x92\x7b\x75\xc5\xb4\xca\x58\x29\xfa\x8b\x78\x8a\xa1\x12\xdc\xf2\xc1\x2f\xbb\x20\x0b\x80\xfc\x5b\xd5\x56\x09\x6e\x0b\x8a\x59\x99\xb9\x12\x71\x11\x5c\xd2\x5a\x29\x16\xe5\xc2\x26\x2b\x61\xaf\xc8\xed\xb5\x4a\x93\x25\xe6\x5c\x2f\x6e\xb1\x68\x49\x2c\x67\xb0\xe4\x90\x5c\x65\xaf\xcc\x6f\xae\x68\x49\x29\x5e\xb1\x33\x0d\x16\xfd\xfd\x51\x9d\xcd\x92\xf4\xf7\x0c\xa9\x59\x81\xe5\xa2\xf5\xda\xff\x7c\x23\x60\x86\xb1\xa1\xb8\xda\xcf\xb4\x5e\x14\x54\x95\x79\x68\x16\xda\x30\xec\x6a\xad\x8a\x69\x57\xd9\xaa\xe7\x29\xfd\xd4\x96\x93\x9a\xed\x3b\xfd\x3c\xa1\x6e\x10\x29\x59\xb6\x9c\x99\x39\x84\x16\x57\x32\x4a\x7b\x67\x5b\x0e\xdf\x39\x03\x5a\x29\xb4\xa3\xef\xeb\x5f\x7f\xec\xa9\x3c\x1c\x32\x37\x0a\x4e\x25\x7f\x82\x85\x23\x4f\xcd\x03\xcb\x46\xdd\x12\xe4\x92\x51\x07\x55\xbe\xfb\xb8\xfd\xdd\x70\xfb\x3b\xe7\xec\xbb\x7f\xb5\xbe\xfb\xa9\xf5\xdd\x69\xed\xbb\xf7\xff\x5b\xc9\x86\xcb\x3d\x8c\x82\x0f\x76\xec\xde\x60\xe9\xe6\xa2\x04\xfc\x53\x8b\x83\xc3\xd3\x23\x16\x30\xcc\x14\x4e\x10\x22\x2f\xea\xc0\x15\x29\x25\xc4\xa5\xc8\x00\xc6\xef\xab\x74\x41\xf0\xb6\xd4\x8d\x0c\x1d\xda\x19\x1b\xd6\x12\x40\x9f\x21\x57\xdd\xa4\x31\xb7\x52\x48\x5b\x59\xd8\x48\xe8\x01\x9a\x4a\x34\x2c\x4b\xc5\x3a\x1a\x00\x24\x39\xe7\x1a\x30\xbf\xef\x1b\x5f\x13\x98\x9f\x17\x38\x76\x34\xb8\x74\xa3\x1f\x19\x27\xf9\x41\x51\x16\x0c\x44\xa3\x2d\x83\xb7\x99\xbe\xac\x5a\x11\x5a\xaf\x96\xde\xa2\x51\x78\x42\x6c\xf7\xf2\x91\xe0\x16\x8e\xb3\xc9\xc8\x2e\x51\x4b\x41\x63\xd1\xe8\x3f\xa3\x30\x18\x5d\xc6\x85\x91\xb9\xeb\xab\xa0\xbd\x44\x1d\x55\x42\x8b\xc6\x22\xea\x79\x76\x14\x81\x1f\x4b\xbe\xbe\x5b\x05\xed\x25\x2a\xaa\x12\x5a\x38\x24\xd2\x38\x76\xbd\xcb\xe3\x71\x88\x4f\xb0\xef\xe0\x30\x5f\x6c\x17\x0c\xdd\xca\xe0\x7b\x6d\xd7\xc7\xe1\xe5\x7b\x7b\x5a\x54\xc4\x82\xf1\x97\xf6\x2f\x2f\xa3\x81\x3d\xc2\x97\xef\x82\xfc\x61\xf7\x7c\x41\xc1\x7c\xce\x9a\xe8\x84\x8c\x9c\x9f\x63\xd7\x2b\x88\xf0\xb4\x60\xe8\xab\x17\xa4\x89\x86\x34\xc4\xe0\xe5\x7b\xbb\x8b\xf3\xc3\x3b\x3e\x5b\xb0\x17\xbe\x67\xb5\x78\x67\xc7\xf6\x8c\x4a\x2c\x1a\x7c\xac\xce\x8a\x78\x3b\xb0\xc3\x19\x0d\x25\xc5\xa8\xbc\x84\x98\x0c\xe0\xc4\x48\xe7\xe0\x9a\x1d\x81\x73\xde\xfd\x7d\xe2\xcf\x6b\xb0\xa8\x02\xe8\x0e\xee\x32\x1b\xfc\xf6\x54\xa3\x8d\x5c\xf4\x43\x06\x9e\xbd\x8d\xe0\xf2\xd0\x1d\x75\x2d\x0c\xc6\x21\x20\x70\x8b\x54\xe7\xee\x45\x3b\xa1\x73\x8d\xa7\xc8\xf5\x59\x32\x92\xc9\xed\xf3\xf5\x8f\x64\x47\x0c\xec\xe8\xe8\xd6\x3f\x0e\x83\x11\x0e\xe3\x29\x85\x70\xa7\x59\x2c\x42\xc1\x24\x19\x29\x93\xe7\xd7\x78\x7a\x81\x3a\x8c\x20\x3c\xb5\xd1\x03\xfc\x8f\x07\x95\x82\x74\xe0\xe0\x49\x9b\xa0\x17\x62\x3b\xc6\x6f\xc9\x68\x96\xdc\x42\x11\x98\x72\x49\x2c\x2b\xdc\x77\x7d\xcc\x38\x70\x71\xc4\xda\xc4\x42\x44\xdd\x45\x99\xa6\xa9\xd3\xa6\x81\x8f\xba\x66\x71\x70\xd4\x0b\xdd\x51\x1c\x84\x10\x44\x3c\x18\xd1\x66\x49\x5e\xd7\xb0\x3f\x1e\xe2\x10\x22\x6b\x74\x72\xde\x93\x3e\xb2\xbd\x08\x2b\xf9\x7a\x81\xdf\x77\xaf\xc6\x3c\x67\x1c\x8e\x71\x9b\xde\xf5\x03\x47\x4d\x7a\xdf\x4f\x24\x37\xe5\xac\xb7\xa1\x1b\x2b\xd9\x58\x3f\x28\x75\x9f\x8a\x9a\x4b\x39\xaf\xf1\x54\x7e\x36\xdb\x72\x83\x27\x2d\xfa\x36\xf0\xa3\x38\x1c\xf7\xe2\x20\x84\x86\x8b\x03\x42\x34\x82\xc8\x25\xb1\xdb\x3b\xe6\x4d\x49\xd8\x4d\x3e\x9b\xd9\xc6\x97\x08\x25\x52\x22\x93\x34\x69\x9d\x15\xba\x45\x54\x54\x16\xda\x9c\x75\x29\x05\x11\x18\xf4\x00\x31\x23\xa9\xd4\x10\x79\xb1\xd8\xdf\xa6\x85\x2e\x63\x3c\x1c\xc9\x26\x35\xfd\xf2\xd6\xf6\xbc\xb7\x03\xdc\xbb\x36\x38\xd4\x86\x25\x53\xe5\xb5\x7d\x22\x3e\xcb\x90\x1c\x72\x42\x10\xf1\x41\x18\xdc\x82\xff\xe9\xd9\x74\x84\x0f\xc2\x30\x08\x8d\xca\x5b\xdb\xf7\x83\x18\x91\x31\x81\x6c\x04\x85\x22\x3b\x42\xb6\x68\xf7\x0a\xed\x0e\x99\xb5\x51\x10\x45\x6e\xd7\xc3\x52\x01\x27\x50\x63\x23\xc2\x5e\x1f\xc0\xdc\x3d\xc1\x1a\x79\xa5\x96\x7e\x82\xfb\x38\xc4\x7e\x8f\xb3\x10\x0f\xdc\x08\x0d\xec\xc8\xaf\xc6\xa8\x8b\xb1\x8f\x00\x87\xc6\xf6\x5c\x62\x77\x6f\xa3\x68\x3c\xc2\x64\x3d\x2b\xa7\x20\x25\x60\x87\xb2\x96\x60\xb1\x7b\x68\x73\x53\x84\x67\x81\x67\x00\xe4\x08\x40\x0e\x2b\x44\xe0\x33\xdf\x92\x5a\xa2\x57\xf4\x75\x0b\x11\x8e\xdb\x6a\x8d\x5d\x7f\x80\x43\x37\x8e\x8c\x68\xdc\x7d\x4b\xbb\x0e\xd8\x82\xdf\xbc\xaa\x8c\x78\xf2\x01\x3d\x51\x8a\x20\xdc\xa5\x3e\x52\xa0\x91\x9c\xae\x39\x25\x69\xc9\x42\x23\xc4\x11\xc4\xb1\x07\x58\x1e\xec\xc6\x03\x1c\xa2\x2e\xa6\x11\x0d\x82\x50\xea\x2b\x0b\x91\xbe\xac\xa0\x2d\x94\xe1\x05\x9a\x8a\x73\x9f\x48\x7d\xa2\xb9\xa9\x1e\x33\x24\x06\x15\x76\xe5\x81\x72\x87\x7a\x49\xcf\xb7\x40\x27\x79\x63\xdc\x42\x49\xe3\x24\x6a\xa6\x45\x95\x8c\x85\xb8\x7a\x68\x81\x76\xb0\x90\xac\x69\xe8\x3b\x22\x66\x7c\xe4\x49\x8d\xcb\xf8\x8b\x70\x7c\xcc\x59\x38\xea\x8b\x1d\xc1\xd4\xfb\x9c\x0e\x4a\x78\xab\x5d\x5e\x42\x4d\x60\x7a\x4b\x92\x40\x7f\xef\x3c\x7d\xba\x81\x9e\xa2\x7f\xf4\x5d\x0f\x1f\xdd\xe0\xf0\xc6\x95\xa5\x15\xbd\x0b\xe2\x8d\x04\x57\x39\x09\xd8\x28\x52\xbc\x0b\xe2\x32\x81\x5a\x74\x76\x9b\x36\x52\x03\xd5\x01\x64\xf5\x08\xea\x81\xcc\xc7\x54\x5f\x28\x13\xcd\xe5\x5b\x6e\x7e\xd0\x25\x77\x22\xac\x32\x63\x16\x92\xd2\xa9\xd8\x44\x72\x32\x11\xe0\x21\xad\x7f\xc8\x20\xb5\x94\xa4\x1c\xc7\x84\xe3\x8d\xe7\x6b\x05\x9a\x57\x61\x47\xea\x86\xfb\x7b\xde\x95\x57\x6a\x57\x2a\x85\x99\x35\x7b\x34\xf2\xa6\x8c\x96\x30\x07\xcc\xe4\x92\x9c\x3c\x13\xa7\xaa\x7e\x4e\xeb\x74\x8d\xa7\x2d\x54\xbd\xc2\xf1\xdb\x00\xee\xb9\xdb\x31\xae\x5a\xec\x5a\x24\x08\xb0\x68\x12\x25\x8d\xa1\x5e\x17\x81\x25\x0a\xe9\x15\xc2\x4a\x0d\x1e\x64\xc8\x99\x09\xe9\x26\x3a\x73\x4f\xe4\xf7\xd3\xe4\xfd\x54\x49\xff\x7a\xe2\x46\x52\x1e\xf2\xa8\xe4\x53\xbf\xc3\xa3\x80\x77\x21\xfc\x4c\x4e\x59\x7c\x49\xc8\x5a\x13\x61\x3c\xf8\xf7\x29\xff\x3e\xd5\x7f\x0f\x71\x44\xd7\x30\xd2\x6d\xf0\x49\x8b\x91\x35\x26\xb0\xa5\x4c\x1f\x6a\x5d\xdb\x77\xf8\x5d\x8b\xf4\x2b\xc3\x44\x3b\xa8\x89\x5a\x0a\x02\x4f\x6f\xda\x62\xe5\x1b\x53\x20\x34\xcd\x12\x4a\xbf\x92\x08\xf1\x7b\xdb\x0a\xf6\xd4\xcc\xf1\xa5\x35\x66\xcf\x2b\x6f\x61\x80\xdd\xd8\x9e\xeb\x10\x31\x11\xdd\x7b\xe8\x9f\xd8\xfe\x15\xa6\x43\x8e\x36\x46\xad\x37\xb1\x58\x05\x4d\xa2\x06\x3f\x4b\x91\x53\x8b\x35\x85\xee\x12\x3b\x4d\x94\xc1\x44\xc8\xe0\xed\xc0\x05\x23\x0b\xc9\xf2\x1e\x82\x8a\x79\x17\xc4\x39\xb2\x2e\xbe\x1b\xc1\x88\x4e\x22\xdc\x28\x95\x84\xc4\x01\xd5\x76\x13\xb8\x0e\xaa\x2b\xbd\x31\xc7\x9e\x47\xcd\xae\xb9\xd1\x2f\xa4\x31\x0e\x3c\x4c\x46\x2f\x2b\x50\xa9\x2f\x2d\x68\x3e\xaa\x3d\x2f\xf0\xb1\x4a\x93\x57\x42\x83\x1e\xb0\xe0\xbe\x94\x61\xe6\xb3\x4b\x3f\x18\xda\x22\x97\xac\x1a\xe8\x34\x5e\xb7\xb2\xab\x68\xcd\x6c\x62\x89\xc5\x9a\x71\xf7\xc0\x5a\xc7\x52\xb0\x77\xc8\xa0\xa7\x3a\xa6\xa7\x28\x2e\x32\x86\xd9\x7b\x45\x71\xc1\x04\xf1\xc1\x1e\x62\x90\xb1\x1e\x11\xfc\x68\x3b\xe4\x7a\x77\xdb\x09\x62\xf2\xff\xd5\x04\x08\xc6\xcc\x62\x7a\x88\x33\xd2\x78\x86\xf8\x16\xca\xae\x56\x41\x37\x4b\x68\xe8\x66\x9e\x8a\x6e\xaa\x3a\x3a\x94\x3e\x84\x8a\xf2\x75\xa3\xdf\xca\x4c\xf9\x9a\x15\x3c\x77\xad\x71\xa3\x0f\xe3\xe1\x51\x78\x1a\xb3\xb3\xa5\x89\xd9\x56\xe8\x7f\x5c\x31\xfd\xa9\xa9\x22\xf9\x91\x1a\xdc\xdf\xa3\x27\x6e\xf4\x51\xa3\x77\x64\x24\xaf\x07\xb9\xe2\x3d\xa1\xcc\x78\x3b\xa7\xe6\x4c\xb5\x94\x24\xf9\x3c\x85\xd0\x36\xdf\xcd\xed\x49\x10\x79\xd1\x37\xbb\x35\x78\xd6\xca\xa8\x94\x48\xbc\x6b\x6f\x6c\xa8\x1a\xee\x98\x4d\xec\xca\x48\x99\xd9\xf6\xba\x3d\x26\xee\xee\x04\x16\x0d\x8e\xb0\x1f\x43\xdc\xc2\xd7\x71\x1c\xba\xdd\x71\x8c\x23\xda\x17\x49\xad\xcc\x85\x0b\xa2\xbd\xdc\x77\xbd\x18\x87\x07\x37\xd8\x8f\x0b\x0b\x91\xfa\xa1\x9d\x1a\x84\xcb\x28\x26\xd1\xe4\xf3\x6d\x25\xea\xf4\x94\x20\x75\x27\x6b\x98\x79\xb7\x64\x0d\xd3\xc8\x51\x4a\x55\x2b\xa1\x6b\xf2\xcb\xc2\xe4\x1f\xb4\x53\x32\x19\x52\x59\x12\x62\x21\x19\x35\xf3\xed\x05\x6a\xea\xc8\x4a\x21\xc6\xf5\x9b\xe9\xb1\x1d\x92\x16\x94\x04\x5c\xd1\xca\x93\x96\xd4\x67\xb5\xde\x04\x6d\xa3\x50\xd1\x59\xea\xf7\x69\xfa\x3b\x98\x54\x2d\x08\x0f\xac\xbc\x1f\x60\xf7\x6a\x10\xb3\x0f\x92\x8e\x66\x3f\x4d\x49\x1f\x5f\x98\x72\x30\x35\xd9\xb2\x6e\x6f\x3c\x94\x31\x00\xce\x2b\x62\xe9\x51\xb9\x30\xc5\xae\x47\xcd\x71\xa3\x91\x67\x4f\xd9\xf8\xac\xca\x94\xab\x49\x2a\xd2\x28\x64\x55\x9c\x19\x99\xf3\x8e\x14\x1a\xdc\xeb\xf8\xe4\xe0\xf4\xe0\xc3\xd9\xeb\xb3\xc3\xa3\x0f\x97\xaf\xcf\xce\x4e\x0e\xdf\xfc\x7c\x76\x70\x3a\x2b\xc8\x97\x9e\x24\xed\xda\x83\x5f\x0e\x3e\x9c\x65\x68\xc1\xf1\x67\x91\xe4\xea\x4f\x4d\x6a\x76\xcd\x67\x80\xcb\x1b\x6c\x75\xb0\x10\x11\x90\x5f\xe3\x8e\x06\xbf\x5b\x88\x02\x99\x65\xe1\x8c\x92\x2d\x42\xbe\x34\x1b\x1b\x08\xb9\xd1\x8f\x61\xe0\xc7\x0b\xd1\xe9\x06\x01\x20\x92\xdb\xde\xad\x3d\x8d\x4e\x07\xc1\xed\x52\x64\x26\x0b\xe5\x06\xc7\x50\x22\xcd\xc6\xf9\xe2\x82\xb1\x50\x3f\xc0\x31\x3a\x8d\xd5\x3f\xfd\x56\x59\xdf\x40\xe5\xe6\x84\xaf\xb9\x0e\x6c\x30\x1d\x3a\x5f\xa0\x02\xfc\x2e\xd4\xc2\x75\xa7\x15\x98\x7c\xeb\x15\x00\xa5\xf4\x05\xd8\x27\xaa\x6c\x21\xe6\x31\xb5\xb3\x2e\xcc\x8d\x07\x79\xfe\xa4\xdf\xb9\xd9\x7a\x27\x2b\x48\xba\xeb\x9a\x52\x77\xe2\xa5\xe8\xc1\xba\x22\x90\xf0\x14\xb6\x50\x03\x7e\xf4\x5d\xcf\x6b\xa1\xea\xdf\xfa\xfd\x3e\x2c\xbf\xa2\x38\x0c\xae\xc9\x6a\xef\x6f\xbd\x5e\xaf\xca\x53\x1c\x8d\xec\x9e\x1b\x4f\x5b\xa8\x91\xa4\xf9\x95\x1a\x1d\x8d\x8d\x07\x76\xb2\x61\x9a\x64\x8d\x41\xf9\x6e\x2f\x12\x86\x95\x06\x8a\x33\xd2\xfb\x8f\x29\x3f\x9a\xe6\xa3\x1f\xcd\xa3\x1f\xcd\xa3\x1f\xcd\xa3\x1f\xcd\x5f\xd3\x8f\x66\xdd\xae\x2e\xcf\xd7\xef\xea\xf2\x62\xed\xae\x2e\xdf\x2f\xe6\xe9\x02\x57\xc3\x9d\xb3\x00\xe0\xa5\xf2\x1d\x3d\x20\xd9\x61\x8c\x43\x3b\x0e\x42\xc3\x0e\x43\x7a\xf1\x9c\xf2\x64\x87\x21\xc4\xee\x68\xd3\x47\x5f\x78\x4a\xc0\xa3\x43\xa8\x52\x87\x0c\xea\x5b\x83\x3a\x68\xec\x53\xb7\x03\xa7\x8d\xe2\x70\x2a\xbb\x89\x5c\xba\xe0\x15\x13\x9e\x9f\x4e\x87\xdd\xc0\xab\xb9\xac\xcc\x0b\x83\x18\x08\x51\x1b\x3d\x31\xa0\x00\xe3\x12\xd6\xcd\x6e\xcd\xc7\x93\xd8\x30\xcd\x9a\x13\xf8\xd8\x6c\x27\xa5\x13\xee\x08\x67\x34\x3c\xc4\x65\x54\xa3\x88\x5c\x6d\x16\x2a\x61\x73\x93\x7e\xe5\xa0\x5c\x9d\x0e\xa9\x50\x37\xc4\xf6\x35\x75\xd3\xe8\xd9\x71\x6f\x80\x0c\x1c\x82\x37\x02\xd4\x82\x56\x0a\x2a\x80\xc3\x90\x24\xeb\xbb\xbe\xed\x79\xa4\x02\xb4\x1a\xb0\x27\x78\xe9\x03\x75\xf7\xbc\x42\xb7\x16\x2a\x17\xa6\xf2\x64\x98\x6a\x56\xd8\xbc\x77\x4c\x76\x58\x7e\x89\x15\x37\x11\xc2\x64\x5b\xe7\x35\x92\xf4\x01\xc9\x0f\xdd\x57\x73\x23\x8a\x12\x66\x87\xd4\x33\x82\x65\x62\x24\xc4\x49\x41\xaa\x69\x91\x2b\x02\xde\xa7\x32\x6a\x7b\x5d\x90\xca\x39\xde\x3f\xf4\xe1\x60\x08\xd9\x31\xb1\x90\x62\x08\xc1\x80\xe9\xc9\xe9\x38\xc4\xc8\x0f\xfc\x6d\x28\xb9\xeb\x25\x5e\x1d\xcc\x19\x43\x75\x25\x79\x74\x40\x7a\x74\x40\x5a\x99\x03\xd2\xa3\x5b\xdf\xa3\x0f\xd6\xa3\x0f\xd6\xa3\x0f\xd6\x57\xea\x83\xf5\xde\xf5\x71\xda\x09\x8b\x3a\xb1\x10\xbb\x9d\x7c\x95\xe7\xc0\xe4\xad\xce\xb7\x01\x02\x7a\xd3\x1c\x92\x63\xc3\xaa\x9d\x1a\x58\x09\x2b\xf5\x68\x58\x87\x37\x03\xe3\x33\xe3\xca\xa0\xb8\x31\x2c\x56\x19\xe5\xa8\xb0\x4a\x68\x54\x8b\xdd\x11\x66\xb8\x16\x10\x0a\xf0\x1f\xea\x5c\xf0\x20\x39\x81\x71\x8c\x68\xd7\xc7\xed\x0d\xee\xa3\x2d\xc4\x87\xc9\xc7\x57\xe8\xa1\x47\x38\x2b\xe3\xa2\x07\xb2\x5c\xd2\x47\x8f\xa4\x5d\xdc\x49\x8f\xe4\x9e\xcb\x4b\x0f\x8a\x5b\xd4\x4d\x8f\xd6\x3f\xed\xa7\x77\xe0\x3b\xc7\x81\xeb\xc7\x51\xbe\x9b\x9e\x48\x62\xb8\xd1\x6f\x16\x52\xbc\x18\xca\x78\xeb\x2d\xe0\x7d\x27\x7f\x27\xea\xe9\x4d\x20\xf9\xfc\xb1\x17\xb2\x0f\x07\xf9\xca\x5e\x67\xfd\x4d\xf8\x87\x69\xe6\xd0\x56\xfa\x08\xcf\xd9\xd3\x5b\x29\x05\x7d\x91\x78\x34\xc0\xe2\x4d\xf5\xe8\x20\xac\x50\xd4\x65\xb9\x31\x6a\xd3\xb6\x92\x22\xd2\x39\x0b\x2a\x29\x58\xb0\xa0\x0e\x4d\xaa\xb8\xf2\x45\x79\x9e\x7c\x6a\x19\x70\x60\xcd\x09\x18\x02\x01\x9a\x12\x96\x4a\x2b\xe5\xed\xa7\x5b\xcf\x97\xf4\xbc\x03\x3e\x2c\xca\x86\xa9\xc6\x9d\x63\xe3\x85\xb6\x42\x10\xba\xdc\x83\x03\x2c\x96\xaa\x87\xfb\x71\x15\xbd\x42\xe7\x77\x68\xd2\x42\x13\x4b\x9c\xc2\x83\xf3\x12\xbc\x43\x5b\xb4\x17\xe5\x6f\x17\xa8\xc5\xb3\xe8\x3e\xf3\xac\x4a\x96\xc2\x40\x5a\x6e\xf4\x5b\xba\x87\x2f\x35\x5d\x3c\x51\x9b\xff\x32\xd2\x39\x8c\xaa\x49\x44\x27\x5f\x66\x7b\x39\xfd\x2a\xaf\x9b\x2f\x79\x3f\xd3\x0c\xc6\xa5\xe8\xe9\xcb\xcf\xde\xd5\x97\xac\xaf\x2f\x0b\x3a\x7b\xa2\xef\xec\x38\x18\x25\x7d\xcd\xe9\x4c\x5b\x68\x2a\x7a\x4c\x79\xb9\xc5\x07\xa7\xd4\xdd\x39\x09\x74\xd9\xb5\x3d\x3e\xbf\xbb\xe7\x97\xf5\x97\x53\xfd\xb2\x9a\x65\xfc\xb2\x9a\x8a\x5f\x56\xc2\x5c\x49\x07\x3b\xcd\xbe\xe1\x4a\x1d\xec\xe6\xa0\xaf\x73\xb0\xdb\xdc\x9c\xdb\xc1\x0e\xf3\x89\x4d\xf2\xaf\xd3\x4c\x76\x6a\x59\x22\xd3\x5c\x5e\x76\x72\x51\xea\x46\xa7\x21\x3e\x59\xa8\xa9\x44\x56\x8d\x62\x1b\x2e\xb6\x27\x99\xcf\xeb\x4a\x50\x62\xec\x3b\xea\xe7\xc6\x85\xd2\xb1\xa3\x85\x9c\xed\x74\xbb\xdc\x6b\x71\xb6\xd3\x17\x34\x9f\xb3\x5d\xd2\x05\x93\x46\x8b\xb6\x98\x3c\x80\xa6\xe2\xa5\x34\x78\x26\xcd\x16\x69\x3a\x25\x1d\x7b\x35\xe5\x9d\xf7\x97\x74\xdd\x63\xcb\x06\xbd\xef\x9e\xb4\xd0\x63\x7e\x7b\xa3\xd2\x4e\x7b\xba\x53\x8d\xe5\x9d\xf6\x00\xa3\x64\xe8\xb2\x95\x54\x6d\xd2\x60\x2c\xd5\x26\xea\x38\x9a\x66\x92\x4e\x45\xd2\xa9\x9a\x94\xb9\xf2\x41\x72\xbb\x1b\x71\xca\x4d\xb4\xcd\x49\x37\x4c\x9d\x8b\x5f\x2a\xc3\x34\xc9\x30\x6d\x98\x0b\xb9\xfe\xbd\xa7\xcb\xab\x75\xf8\xfe\xbd\x67\xab\xc3\xc5\x9d\xff\xf4\x23\xb7\x84\xf3\x1f\xec\x09\x50\x7b\x7a\x19\x57\xb7\x0d\x26\x01\x4b\x38\xfe\x31\xc1\x58\x92\x02\x93\x97\x25\xa9\x70\x29\x5a\x98\x0c\x91\x23\x73\x49\x67\x46\xba\x7d\xb8\x9c\x27\x22\xa7\xf1\xe8\x46\xf8\xe8\x46\xf8\xe8\x46\xf8\x15\x78\xe1\x7d\xe3\x6e\x84\x4b\xf9\x11\x92\x15\xd9\x67\xf0\xe5\x63\x2e\x7c\x7e\xe0\xe3\xaf\xce\x85\x8f\x6f\x4f\xa6\x7c\xf8\x76\x1f\x7d\xf8\x1e\x7d\xf8\x1e\x7d\xf8\x1e\x7d\xf8\xfe\x9a\x3e\x7c\xeb\x76\xb0\xfb\x3c\x88\x58\x5f\x99\x0f\xdf\x82\x88\x58\xf4\x46\xf5\x09\xee\xc5\xb6\x7f\x55\x00\x9e\xf9\xe2\x11\x11\xeb\x11\x11\xeb\xd1\x21\xed\x11\x11\xeb\xd1\x1b\xeb\xd1\x1b\xeb\xaf\xee\x8d\xa5\x7a\xdc\xbc\x0e\xb1\xfd\x75\x7a\xdc\x10\xce\xca\x78\xdc\x90\x74\x65\x3d\x6e\x48\xda\xc5\x3d\x6e\x48\xee\xb9\x3c\x6e\xa0\xb8\x45\x3d\x6e\x68\xfd\xd3\x1e\x37\xc4\xd8\xc9\x77\xb6\x21\x5f\x8d\x81\x1d\xfd\xd6\xb0\x88\xf2\xf9\xad\x09\x7f\x3e\xd2\xa7\x8f\xcd\xf9\x3c\x6f\x7e\x21\xf4\x1b\x92\xef\x4d\x23\xfb\xb9\x29\x7d\x6e\x2a\xc7\x26\xe9\xdc\xd3\x46\xf6\xb3\x94\x7b\xda\xfc\xaa\x30\xb7\x26\x47\xdc\xbf\x62\x2e\x64\x2d\xa5\x08\x41\x62\x2e\x4c\x2d\x85\x0b\xea\x20\x21\x98\x08\xc9\xa3\xa1\x1c\x8f\x4f\x79\x92\x69\x6e\x92\x49\x43\x38\x50\x2a\x6d\xdc\xd4\xbe\x9e\xea\x53\x4f\x9b\x7a\x78\x29\x10\x36\x53\x39\x49\x15\xfc\x1a\x4c\x84\x4c\xb4\xc5\x1b\x34\x17\x7b\x89\x66\x83\xca\x9c\xd7\x2f\x32\xc7\xe0\xbc\xa8\xa6\x52\x54\x33\x5d\x54\xb3\x54\x51\xcd\xa4\xa8\x46\x6e\x51\x1f\x95\x5a\x41\xab\x70\xa0\xb4\xa4\x56\xd3\x19\x45\xd1\x6c\xb3\x6a\xf5\x51\xa9\x15\xb4\xb4\x52\x54\xb3\x54\x51\xcd\xa4\xa8\x9c\x5a\xad\xd3\x7f\x67\xd2\x98\x0f\x90\x6d\x99\xa2\x9a\x9f\xad\xa8\x69\x43\x60\xbe\xad\xbd\xa8\x66\x11\xbc\x5c\xde\xe1\x35\x34\x7b\xfe\x81\x35\xf0\x5f\x7c\x48\x0d\xc7\xd3\xb3\x0e\xa6\xe1\x48\x5a\x39\x8c\x5e\x02\xe9\xae\x60\x0a\x4b\x12\x14\x61\xdd\x85\xb8\xf7\x99\xc0\xee\x58\x49\xdf\x0c\xda\x1d\xe3\xb7\x1c\xdc\xdd\x62\x95\x2b\x89\x77\xa7\xdd\x9e\x59\x0c\xf6\xae\xd8\xd7\xdc\x0e\xb1\xbd\x4d\xaa\x52\x0a\xc8\x8e\x24\xfc\x9c\x9e\x79\x0d\xd9\x35\xaf\x91\x99\x7e\xc5\xa7\x66\x66\x0a\x16\x7e\x7b\x8d\xcc\x34\x2c\x3e\x35\xe7\x71\xd9\x93\xd8\x86\x49\x7b\xd5\x5e\x7b\x0d\xc5\xe8\x80\xc9\x7a\xd5\x45\x34\xd3\x45\x7c\x5c\x75\x2d\xa6\x99\x5a\x7c\x5c\x75\x2d\xa6\x99\x5a\xfc\x86\x3a\xac\x4b\x36\x37\x69\xc3\xa5\x79\xa0\x09\x3e\xf2\x04\x1f\x9b\xaa\x57\xa1\xc8\xfc\x84\x36\x3b\xfb\xf5\x51\xbc\x53\x2d\x8c\x59\xfe\x86\x4c\x31\x70\xa7\xc6\x59\x8b\x0a\x95\x17\x92\x79\x9e\xc2\xb8\x2b\xaa\xe4\x0e\x0d\xaf\x12\x89\xfd\x0b\xf9\xd0\x11\x65\x56\x06\xff\x0e\xba\x84\x39\xd2\x29\xfa\x53\x76\x78\x83\x9e\x28\xe5\x61\xa7\x3b\xd6\x58\xc0\xc3\x0e\x0a\x2c\xef\xa4\x46\x16\xb8\x6b\x72\x52\x7b\x4d\xdb\xf1\x4b\x20\xd4\x3d\x3a\xa9\x3d\x3a\xa9\x7d\x7e\x27\xb5\xc6\xb7\xeb\x26\x35\x69\x7e\xbb\xbc\x4f\xbf\xe1\x76\x9f\x7e\xb3\xed\xfe\xe8\x1e\xf8\x15\x78\xd7\x7d\xf3\xee\x81\x8f\x28\x83\xf3\xa1\x0c\x6a\x1d\x12\xeb\xb5\x67\x8a\xdb\x62\xca\x91\x71\xfd\x4e\x8a\xfc\x44\x27\xe5\xa4\xb8\xf7\x35\x39\x29\xae\xc5\x4b\xaf\xbe\x02\x2f\xbd\xfa\x72\x5e\x7a\x8d\x35\x7a\xe9\x35\x56\xe5\xa5\xd7\x58\x81\x97\x5e\x73\x8d\x5e\x7a\xcd\x55\x79\xe9\x35\x57\xe0\xa5\xb7\xbb\x7e\x2f\xbd\xbd\xb5\x3b\x9f\x3d\x9b\xd3\x83\xee\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xbf\xd9\x2d\xec\x6d\x18\x44\x91\xec\x0d\x46\xc6\x2f\xbc\x2c\x73\xc2\xa1\x33\x0d\xd6\xe2\x00\x06\x1c\x15\x38\x7e\xc1\xf7\x19\x0e\x5f\x90\x66\x6e\x47\x2f\xc8\x55\xc6\xc1\x8b\x92\x9f\xd3\xb1\x8b\xd5\x2b\xed\xd0\x75\x6c\xc7\x83\x7c\x87\x2e\xf2\xd5\x98\x58\x68\x6a\x71\x38\x1a\xba\x93\x6a\xa1\x38\x18\x59\xc8\xc3\x7d\xe9\xb0\x85\x55\xb4\xfa\x53\x15\x6d\x01\x82\x4d\xd5\x22\xbf\xe2\x60\x44\x7e\xdf\x54\x13\x64\x93\x2d\x96\x88\xe4\x17\xe9\xa6\xe4\xd7\xa0\xca\x91\x6f\x56\x7e\x4c\xba\xb2\x88\x8c\x1c\x7d\x89\x7d\xcb\x07\x5f\x62\x09\x58\x93\x49\x29\x48\x93\x88\xcf\xa4\x25\xa5\x6f\xd0\x26\xe2\x23\x79\x2a\x3e\x65\xd5\x1d\xb2\xc2\x7c\x51\xda\xa7\x52\x39\x34\xec\x27\x87\x86\x5d\x2c\x10\x51\x20\x02\xd8\xea\x08\x4e\x57\x4d\x10\xfa\x60\xd5\x44\x69\xbf\xad\x9a\x6a\x1c\x8c\x56\x4d\x12\x86\x61\xd9\x43\xcf\x99\xc7\x99\x99\x95\x7d\x16\xa2\x6f\x04\x4a\x63\x4e\x68\x16\xdd\xba\x68\x11\x68\x16\x29\x0c\x69\xb9\x5d\xd8\x99\x07\xa0\x3d\xa2\x1a\x95\x73\xcf\x64\xc8\x39\x2d\x71\x10\x5d\x46\x19\xf2\xd6\x36\xf3\x0f\x20\x41\x11\x17\x1f\x3c\xd6\xe7\x3c\x78\x7c\xcb\x2a\xb0\xc4\x81\xa3\xbe\x77\x4a\x1e\x38\x16\x1e\x14\xea\xb7\x52\x94\x03\xba\xc2\x63\xc2\x12\xf9\x67\x1e\x12\x96\xa0\x31\xfb\x88\xb0\x04\x91\x38\x18\x2d\x49\x81\x48\xd1\x92\x24\x4a\x0d\x8b\x5c\x3a\x74\x73\x7b\xd6\x0e\xef\x84\x6f\xda\xb2\xbf\x50\xf1\x7a\x52\x81\xba\xd4\x2d\x75\xb9\x79\xeb\x2b\xdf\x8b\x15\xc6\x56\x6a\x0f\xf6\x59\xd1\x1e\x2c\x23\x93\xbf\xef\x4a\xec\x86\xae\x1d\xe1\x83\x49\x1c\xe2\xe1\x78\x98\xb7\x83\xb3\xb7\xcf\x94\x05\x49\xfc\xcf\x9c\x8d\x33\x63\xf7\xd9\x9e\x94\x8c\x22\xc1\x63\x9c\x47\xb3\xde\x64\xd5\x21\x46\xf4\x19\x59\xd4\x0d\x71\x3c\x08\x1c\xe4\x46\xc8\x73\xaf\x31\xfa\x74\x59\x1b\xda\x93\x4f\x08\x4f\x7a\x78\x14\xa3\x78\x60\xc7\xc8\x8d\x91\xdd\x23\x8f\x11\xfa\xe4\xb2\x02\x3e\xa1\xdb\x81\xdb\x1b\x20\x97\xd8\xdd\xc8\xf5\x6f\x82\x6b\xec\xc0\x0e\x09\xb6\x7b\x03\xc4\xf6\xf3\x91\xeb\xa3\x4f\x76\x18\xda\xd3\x4f\x28\x0e\xd0\x15\xf6\x21\x37\x8a\x07\x18\xf5\x42\x42\x8b\x58\x56\xdd\x29\x25\x46\x28\x91\x2f\x14\x47\xd0\x8d\x50\x68\xfb\xd7\xd8\xa9\xa1\xb3\x01\x46\xbc\x60\xf2\x9e\x17\x77\xeb\xc6\x03\x14\xf8\x58\x98\xa8\x2d\xc4\x30\x1d\x6b\x1b\x88\xae\x13\xe8\xa2\x1f\x7e\x0e\x31\x11\xe3\xa3\x3e\xba\xa4\x5f\x5c\xb2\x16\xdf\xab\xd5\x6b\x75\x78\xee\xd9\x31\xbe\x0a\xc2\x29\xf8\x86\xc2\x9b\x91\x1d\xda\x43\x74\x07\x70\x64\x0f\x08\xaa\x01\xac\xd0\x5f\x71\xc0\x79\x42\xc1\x0d\x0e\x6b\x72\x16\xee\xd5\xf8\x80\xce\x39\xdf\x9d\xcb\x9a\xeb\x60\x3f\x76\xe3\xe9\x45\xaa\x42\xac\x36\xb0\x92\xa4\xed\x46\x89\x51\xad\x1e\xa1\xbb\xa7\x0f\xe8\x84\xfd\x26\xed\x33\xb4\x27\x2e\x91\x1b\xa8\x2a\x4d\x8a\x27\xf6\x70\xe4\x61\x56\x6b\xc0\xca\x84\x49\x93\x0c\xaa\xf3\x3b\x54\xf5\xab\x2d\xd4\xa0\xb0\x7f\xf0\xbb\x49\xd1\xfe\x20\x35\xf4\xf8\x9b\xa9\xc1\x72\x58\xc2\xe4\x35\x02\x29\xd0\x40\x50\xf3\xdb\x80\xff\x85\x9e\xa2\x9d\x1d\xd4\x79\x29\x91\x62\x84\x76\x76\xa0\x62\x9f\x2e\x61\x96\xc0\x61\x3c\xfd\x94\xd4\x32\x1a\x04\x61\x3c\xb0\x7d\xa7\xa6\x2d\xb3\xea\x57\x73\x69\xef\x24\xab\x7c\x9a\x0b\x3a\xc0\x12\xb4\xa9\x7d\xc2\xf8\xa4\x1f\xc9\xc2\x18\x7e\xb0\xad\x39\x3a\x7b\xbe\x52\xc6\x1d\x27\x23\x8f\x1b\x83\xd3\x04\xd0\x39\x36\xf2\x68\xe6\x96\x14\x12\x63\xe3\x61\x63\x83\x8e\xf7\x1a\x1b\xee\xa8\x43\x79\x23\x96\x72\x4a\x5b\xec\x7f\x4d\x27\x36\xc2\xf1\xf6\xe0\x3f\x63\x3b\xff\x8e\xf7\xde\xf2\x98\x12\xac\x80\xd5\x00\x4a\x30\x62\x8b\x9e\xb8\x08\x3a\xc7\x9e\xed\xfa\xd4\x9e\xcc\xad\xfb\xee\xde\xa2\x17\xb7\x73\xca\x59\xea\x8c\x47\x4f\x72\xd1\x13\x99\xf5\xa3\x8a\x68\xcb\x58\xea\xf0\x67\x65\xa8\x22\xbb\x09\xa9\x0f\x6e\xbe\xec\xef\x2e\x78\x6e\x99\x26\xbf\x14\x2e\x85\x4a\x6a\xd1\x03\xa9\xb5\x9c\xcf\xee\xad\xe0\x7c\x76\x6f\xb9\xf3\xd9\x67\x6b\x3c\x9f\x7d\xb6\xaa\xf3\xd9\x67\x2b\x38\x9f\xdd\x67\xed\x14\x0d\x83\x20\x1e\x14\xa8\xac\xd5\x90\x5f\xa2\xb6\x69\x52\x8b\x62\x84\xac\xef\x3c\xfa\xf9\xaa\xce\xa3\x9f\xaf\xe0\x3c\xfa\xc5\xfa\xcf\xa3\xbf\x5f\x3f\x6a\x4c\x72\x17\xe6\x14\xf7\xe2\xa0\xa8\x0e\x8b\x7a\x4b\x34\x78\x09\x6f\xc7\xe1\x4d\x01\x10\xca\x82\x88\x31\x8d\xa6\xec\x21\x7e\x86\x27\xf9\xea\x72\xff\xc5\x82\x45\xec\xae\x1f\x5b\xa7\xb1\x97\x29\xe3\xbd\x1b\xe5\xd7\xe5\xf9\xa2\x08\x5a\xcf\xe4\x72\xde\x62\x2f\xbf\x2a\x8d\xfa\xa2\x5d\xf2\x19\xe2\x09\x36\xb8\x17\xfc\x71\xe0\xd9\x61\x71\x19\xbb\x8b\xf6\xc9\xfa\xd1\x88\x1a\x9f\x01\x8e\xa8\x59\x67\x65\xbc\x0f\xae\x66\x35\x54\x03\xd0\x88\x1e\x01\x89\x1e\x3d\x4f\x1e\x3d\x4f\x56\xed\x79\xd2\x7c\x74\x3d\x79\x74\x3d\x79\x74\x3d\xf9\xca\x5c\x4f\xa8\xed\x8e\x22\x30\x7f\x23\x14\xf4\x91\x8d\x46\x6e\x16\x9a\x48\x72\x4c\x39\x76\x4b\x45\x02\xd3\xad\x10\xca\xb8\xa5\x34\xe7\xf6\x4b\x39\x76\x8b\x02\x80\x1d\xbb\x49\xd8\x2f\xd0\x4e\x21\xee\x33\xff\x13\x78\x24\x65\x12\x15\x05\xbe\x22\x97\xa1\x88\xad\xa3\xf7\x5f\x39\x76\x45\x60\xb0\x24\xa0\xb0\x87\x7d\x79\x16\x67\x93\x1a\x78\x9e\x90\x7a\xd1\x78\x20\x24\x95\x69\xa1\x4b\x32\xab\xc3\x24\x08\xbf\x7e\x80\xdc\xf4\x01\xa6\x40\x76\x4c\x4a\xb2\x9e\x5f\xb2\x09\x3b\xb1\x0f\xe0\x0d\x3f\x3f\x55\x7c\x68\x42\x00\xb4\x11\x9e\x3d\x06\x54\x08\x5c\x21\x66\x39\xd7\x90\x06\x41\x1d\x52\xb3\x32\x1e\x36\xa4\x01\x4c\xb0\x32\x98\x93\x0d\xc9\x6e\xa1\x73\x42\xec\x82\xcc\xb0\x3d\x3b\x36\x08\xf7\xa6\x69\xb2\x66\xe5\x7f\x6b\x64\x1e\x21\xb2\x73\x87\xdc\xe8\xb5\xef\x0e\xe1\x44\xfb\x47\xd7\x77\xa3\x01\x76\xd8\x50\x42\x0f\x3c\x75\xcf\xee\x0d\xf0\x71\x88\x6f\x88\xfd\xa9\x88\x02\x93\xd6\xa4\xb5\x18\x79\x1c\x9f\x92\x12\x8c\x3b\x34\x0a\xf1\x0d\x5d\xd2\x45\x2d\x21\xdc\x0f\xfc\xe4\x99\x97\xe0\x3a\x65\x04\x59\x67\x07\x9f\x57\x5c\x10\xe4\xb1\xef\xfe\x67\x8c\x0f\x1d\x2a\xc9\xc9\xb9\xf9\xc8\xc5\xdb\x55\x51\xef\x81\xed\x3b\x1e\x16\x35\x3e\x80\xf8\x2e\x8a\x31\x95\x53\x0f\x71\xd6\xae\x6d\x2f\xa2\x55\xc4\xa9\xba\x54\x35\x3c\x1c\x91\xa2\xf3\x3b\x5e\x12\xf6\x1c\x97\x28\x18\x52\x8a\x43\x94\x58\x35\xfd\xea\x7a\xde\x09\xee\x61\xf7\x06\xec\x85\xbc\x00\x73\xb9\xe9\x0d\x1f\x4f\xe2\xe3\x2c\x76\xc8\x0c\x57\x24\x9b\xd7\xff\xd0\x49\x1c\x7c\xa4\x97\x4a\x84\x1d\xd6\xe1\x22\x1d\x7b\xa1\xba\x01\x09\x3e\x6a\x52\xeb\xbe\xee\xc5\xee\x0d\x86\xd9\x4b\xba\xf7\x9e\x49\x20\xbb\x94\x64\x85\xd5\x38\xbf\xd0\x01\x8a\x24\x05\xca\x95\x21\x45\x49\xcf\x33\x28\x73\xd1\x4f\x9c\x57\x90\xde\x17\xec\x0a\xc7\x67\x78\x12\xbf\xf6\x7b\x83\x20\xcf\x25\x4c\x49\x63\x4c\x2c\xd4\x9b\x24\xc5\x13\x8e\x27\xe8\xa5\xf2\x2e\xf1\x64\x83\xe8\x3b\x55\x4d\x25\x27\xe8\x87\x9c\x2c\xd8\x77\xaa\x79\x3e\x37\xd5\xa1\xeb\x38\x1e\xae\xe6\xba\xb6\xb9\x11\x6d\xf8\x43\xdf\xc1\x93\x9c\xea\x28\x69\x0c\x57\x15\x2f\x3b\xf9\xa4\x62\x1a\x48\x1f\x54\xf9\x48\x05\x3c\x4f\x92\xe9\x1c\x8a\xa4\xcf\x35\x97\xfc\xf7\xa8\x4f\x38\x20\x9d\xbb\xdd\xc8\xab\xb5\x0b\x56\x9a\xc2\x40\x4e\xf5\xd9\xfd\x7e\xcf\x1d\x15\x78\x25\xaa\x89\xe6\x04\x44\xe9\xc9\xb1\xca\x7a\x8a\xb7\x5f\x4f\x8e\x56\xd6\x53\x1c\xfe\x86\xf6\xe4\xc4\x76\xdc\x71\x24\xa5\x10\xef\x32\x41\xaf\x5e\xfb\x57\x9e\x12\xdc\x4c\xbc\x94\x93\x66\x47\x63\x92\x23\xf3\x4d\xab\x22\xde\x8d\x43\x16\x85\x4e\x64\xcc\x7c\xd3\x66\x3c\xb0\x23\xd7\xbf\xd2\x65\xa3\x5f\xb4\x99\xde\xe0\x2b\x57\x5b\x14\x7c\x98\xa5\xc3\x9a\xb2\x32\x98\x03\x5a\x23\x73\x8a\x91\x0f\xad\x51\x75\x70\x9f\xab\x69\xf2\x8f\x58\xd6\x65\xc0\x27\xe6\x28\x02\xa1\x6a\x4f\x15\x4e\xfa\xef\x0e\xb9\xdc\x4d\xcc\x75\x64\xc8\x8c\x95\x95\x5b\x8c\x9e\xa1\x3f\x1e\xa8\xd9\x96\x42\xe1\x4e\x79\x42\x08\x43\x67\xb7\xd2\x72\x61\xa5\x92\x71\x7d\xd3\xca\x8a\x6c\x3a\xa9\xc3\xa4\xae\x95\x15\xd2\x74\x52\x18\xf0\x39\x13\x5b\x56\xee\x5a\x28\x5f\xdc\xc8\xbf\xc0\x97\xcd\x0e\xd6\x15\x59\x7b\x24\x9d\xad\x1f\x06\xc3\x56\xa6\x5d\x20\x34\x1d\x8c\xd7\x96\x34\xa0\x53\x89\x1e\xd2\xb4\xe2\x40\x47\x29\x18\xc7\x38\xa4\x7a\x82\xc3\xa2\xd9\x13\xc9\x9d\xb1\x26\x25\xb0\x24\x3d\x73\x7f\x8f\xea\x66\xba\x08\x84\x5c\xdf\x4f\xc8\xd5\xb3\xdf\x13\xc6\xa5\x22\xf8\xcb\x74\x0d\x36\x0a\xea\x23\x2d\x48\x42\xdc\x6f\x9a\x99\xaa\x81\xf3\x4a\xc2\x3b\x19\xe8\x24\xa1\x52\x9f\x0c\x7b\x4a\x05\x44\x16\xe9\x9d\x2e\x0b\x67\x5f\xa4\xe7\x2f\xda\xa9\xc4\x2b\x50\x26\xf3\x9c\xa1\x68\xc1\xc4\xb2\x12\xd0\x9b\xb4\x90\x3a\xd1\xb0\xf7\xd3\x16\x52\x67\x19\xfa\x4f\x91\x98\xc2\xd6\x54\x84\xa1\xb0\x11\x13\x29\x96\x25\xba\x48\x7c\xf2\x64\xc6\x54\x1b\x5d\x96\xa1\x04\x9c\x4f\x87\xc1\xa3\x9b\xe8\xd9\x01\x88\x8f\x0f\x63\x3c\x2c\x9c\xed\x95\x94\x79\xd0\x7c\xc5\x68\x76\xba\xce\x2f\x03\xc0\xb7\x88\x4c\xad\x08\x80\xaf\xd0\x49\x23\x0f\x80\x8f\xba\x81\x69\x01\xf8\x56\x38\xeb\xce\x71\x14\x58\x1e\x74\x0f\x36\xbc\x5a\x08\x02\xc0\xdb\xa1\xec\x8f\x2d\x43\xef\x91\x45\xa7\x47\xe4\x81\x46\x7c\x4c\xb9\x5a\xe7\xca\x59\x39\x19\xcb\xca\x97\x85\x58\x54\xe2\x6f\x52\xcc\x24\xd3\x18\xda\x0c\x75\x68\x75\xda\xa5\x2a\xb3\x80\x00\xf2\x52\xb4\x12\xb8\x82\xc6\x03\xfa\xfa\xf0\xcc\xf0\x69\x76\x70\xe4\x95\x58\x64\xf3\x1d\x55\x17\xe2\xb8\xcd\xc2\x9f\xb4\x3d\xf7\xca\x27\xa5\xbf\xb1\x23\x4c\x44\xbe\x25\xd6\x91\xda\x8b\x41\xfa\xb1\x12\xe3\x89\x82\x50\x69\xa9\x3d\x36\x8f\xc6\xce\xdb\x0b\x91\x93\x64\x37\xaf\xe8\x2e\xe4\xc0\x15\x8b\xb3\x54\x14\xe7\xec\x6a\xa8\x68\x67\x22\x1d\xc8\x3e\x9d\x7b\x73\x13\x3d\x49\x36\xe3\x6a\x9a\x8d\xa5\x99\xd7\x65\x24\xb6\x81\x89\xdd\xdc\x45\x25\x97\x79\x96\xae\x06\xcf\x99\x04\x64\xfa\x4a\x27\x22\xef\xe4\x84\x8e\x1d\xdb\xff\x0f\x4f\xa5\x64\xec\x8d\x9c\x08\xda\x5d\x4d\xc5\x5f\xa9\x01\x94\x5d\xcc\x3d\xf6\x67\xef\xfe\xad\x26\x6e\xb2\x8c\x1b\xd9\x1b\x47\x71\x30\x04\x71\xf8\x2c\x6c\x50\xcd\x90\xc3\xc1\x7b\x76\xee\xf7\x79\xb8\x60\x91\xeb\x12\x4e\x68\x38\x7b\x61\xf7\x52\x81\xd9\xdc\xa4\x3f\x6a\xca\xd7\xfb\x7b\xd4\xac\x2b\xfd\x08\x89\x48\x36\x36\xa6\x6a\x43\x7b\x64\x24\x06\x3a\xf6\xe3\x70\x6a\x21\x37\x1d\xe8\x7f\xe8\x0a\xbb\x99\xa6\x91\x36\x22\xd0\x16\xa2\xaf\xb8\x9d\x07\xf0\xef\x6a\x74\x7e\x1e\x98\xbb\x54\x8b\xe9\x1c\x35\x38\x00\xe9\x88\xbc\x3b\x0b\xde\xda\x61\x8c\x23\xd7\xf6\x69\x43\xd1\xf2\x7b\x13\x8b\x71\xd2\x9b\xf2\x5f\xf2\xb2\x62\x4b\x69\x3a\x4b\x54\xca\x54\x79\xf5\x64\x29\x53\x15\x2a\x1b\x04\x8c\xb8\xaa\x5a\x55\xd8\xa0\x44\x3b\x5a\x19\xe1\x55\xf3\xc1\xd6\x57\x0b\xb9\xca\x95\x4e\xb1\xc5\xd8\x62\x7a\xae\xa6\x6e\x3c\xf2\xf6\xac\x25\x55\x9e\x98\x72\x99\x3c\x41\xba\x6e\x92\xe8\x96\xaf\x5a\x3a\xb0\x63\xba\xca\x94\x03\x92\x2a\xa7\xda\x62\xc4\xcc\xae\xfa\x08\xe2\xb7\xb7\xd0\xf9\x17\x93\x13\x49\x30\x92\x76\xbc\x90\xa6\x3b\xb5\x49\x43\x6c\x7b\xef\x84\xaa\x65\x2a\x36\x49\xb2\xb3\x83\xce\x8e\xde\x1d\xb5\x60\x77\xdf\x8e\xdd\xae\x87\x51\x1c\x20\x2f\xb8\xc5\x21\xba\xc1\x61\xe4\x06\x7e\x54\xd2\xa4\xc9\x73\x37\x36\x4c\x83\x95\x0b\xc8\xee\x0b\x11\xe0\x5a\x3f\x63\x0e\xc9\xb5\xab\x42\xaa\xaa\x64\x17\x95\x59\x7a\x94\x60\xbb\xa8\xd0\x64\x3e\x12\xa5\x6e\x2c\x69\xec\xe6\xed\x8c\xcd\xe7\x59\x59\x68\x89\x21\x74\xc7\xac\x1d\x6a\x33\x55\xd1\x16\x72\xd5\x9d\x91\x64\x26\x27\x9d\x46\x87\xb9\x6e\x89\x9a\xcc\xee\xc9\xf8\x55\xf6\x73\xb2\x79\x93\x7c\x96\xa4\xcf\x4a\xdc\xab\xd5\xba\x97\x9d\x57\x6e\xf9\x74\x05\x31\x1c\xde\x4c\x79\xef\x24\xa3\xca\x92\x7b\xcd\x94\xd6\xef\xc2\x08\x4a\xb0\x95\x3f\x8f\xf1\x3c\x77\x97\xdd\xcd\xb0\x7b\xa3\xaa\xdc\x7f\xf4\x55\x49\x5b\x97\xee\xf3\xcc\x5c\x36\x26\xc9\x1e\xf7\x25\x16\xdc\x97\x28\x53\xe6\xac\x5b\x3b\x85\xc5\x7e\xd1\x2d\x41\xdd\xfa\x8e\xb3\xfa\x99\xb7\x66\xca\x31\x2c\xf7\xce\x8c\xd1\x11\x9d\x82\xcf\x9c\xed\x79\xd3\x12\x83\x44\x4a\x5d\xb0\x3e\xdc\xd5\xad\x0f\xe9\xe9\xe1\x69\x16\xab\x5d\xfa\x90\x39\x56\x2a\x6f\x2f\x7f\xc5\x53\x52\x22\x3e\xca\xce\x6b\xae\xda\xa3\x95\xae\x4a\x89\xcb\x60\x33\xe4\x2c\x79\x28\xd8\x44\xdf\xf5\x62\x1c\x1e\xdc\x60\x3f\x8e\x8e\xfa\x6f\x07\xae\xc7\x3c\x41\x68\x7f\x71\xf8\x75\xd1\xb0\xe9\x6d\x70\x2a\x37\x94\x31\x3a\xa9\xca\xdc\x65\xa7\xc5\xdd\x5a\x46\xb5\xb2\xf7\x99\xb3\xef\x57\x8a\x64\xb4\xe8\xa1\x1f\xe5\x24\x67\x3e\x2b\x23\xd5\xbf\xba\xf1\x40\x6c\x18\x94\x11\x6c\x25\x43\xfa\x48\x9a\xb0\xbe\xa7\x13\x6a\xba\x7a\xdf\xcb\xdd\x57\x48\x3b\x78\xec\x71\x0f\x8f\x72\xe7\xc8\x7b\x25\xcf\x91\xd5\x93\xdd\xbd\x32\x27\xbb\x99\xa3\xe7\xbd\xc5\x8e\x9e\xf7\x4a\x1d\x3d\x4b\xe7\xc8\x7b\xea\x39\x72\xd2\x96\x92\x2b\x14\x6f\x4f\xba\xf5\x23\x7d\x58\xcf\xb9\xf3\x72\x07\xb3\xf2\x48\xe9\xce\x3a\xea\x2c\x79\xbe\x5a\xf2\xc4\xb6\xc4\xf9\x2f\x3b\x20\x45\x71\x0b\xd5\x55\x43\x18\x8e\x3b\xc9\xfb\x86\xfa\x9e\x8e\x26\x70\x0c\x43\x5b\x79\x07\xbc\x25\x8f\x6b\xa5\x95\xa9\xf8\xa9\x1e\x4c\xee\xaa\x8b\x10\x22\x08\x31\x3b\x27\xdc\xad\xc5\xed\x8d\xd4\xb7\x28\xc6\x23\xe6\x66\x77\x7e\xd1\x4e\x7d\xec\xbb\x61\x14\x27\xbb\x2c\xe0\x39\x4b\x7f\x4a\xa1\xd3\x90\xd8\x5a\x0a\xf9\xe6\x0a\xe4\x93\xf6\x56\x94\x52\xf9\x14\xd4\x0f\xc2\x03\xbb\x37\xd0\x4c\x43\xe0\x6a\x93\x52\x98\x5c\xa0\xe1\x66\x40\x22\xd7\x9b\x9b\xf2\xe3\x39\x64\xbd\x68\x67\x73\xda\x8e\xe3\xfa\x57\x9c\x3f\x48\x86\x5e\xa2\x3a\x7a\xc5\x16\xce\x4a\x82\x96\x14\xc2\x8a\x89\x0f\xf8\xde\xe3\x1b\xfd\xa1\x2f\x84\x52\x3a\x1c\x2d\xee\x52\xe8\x50\x00\x23\x3f\xc6\x21\x59\xf1\xc7\x58\x46\x32\x22\xe5\x8a\x4d\x29\xb4\x0d\xf5\x95\x1d\x68\x52\xdb\x56\x68\x1b\xa5\xb7\xb6\xcc\xf4\xb1\x30\xdd\x1f\x8a\x31\x74\xae\x62\x8c\x69\xb6\x4d\x58\xaf\x49\xe7\xa5\xa2\xa7\xb7\x94\x86\x2d\x3a\x3c\x95\xb2\xb0\xd6\x32\x62\x33\x95\x3f\x95\x5d\x5a\x69\x25\x4c\x50\x61\xad\x8d\xc6\xd1\xc0\xa0\x35\xc8\x54\x4e\x92\x43\x9a\x22\xe7\x74\x3c\x13\x7c\x2b\x69\x1b\xe9\x7c\x5d\x6d\x5c\xdd\x61\xbc\xe2\xe0\x94\x6e\xfa\x4c\x15\x60\x67\x5f\x74\x74\x20\x58\x5d\x87\xe4\xd4\x2d\x24\x49\xc5\x0c\x79\x70\xb0\x17\xdb\xc9\x00\x49\x71\x68\x64\xdb\x99\x3a\x40\x7f\x29\x29\x92\xd8\x5d\x4e\x8a\x2e\x67\x8b\xd1\x65\xb1\x1c\x6d\xe4\x96\xb6\x5a\x1b\x7a\xc5\x56\x74\xda\x1d\x0c\x71\x5b\x73\xaf\x96\xbb\x42\x61\x2d\x67\x4a\x99\xcc\xec\xf1\x62\x49\x93\xb2\x8c\x15\xa9\xf5\x65\x7c\x56\xda\x3c\x7c\x36\x9f\x79\xf8\x4c\x77\xaa\x96\x94\x3e\x9f\x41\x95\x7b\x0a\x97\x9d\x4d\xd9\xbd\x01\xb8\xe6\xf3\x44\x2e\xe5\xfe\x1e\x3d\x59\x04\xb3\xc4\xa0\xd3\x06\x23\x63\xf1\x72\x4c\xdd\x4e\x80\x14\xc3\x4a\x6f\xba\xa7\xcf\xff\x72\xf3\x69\xd6\xb2\x2b\x47\xac\xdc\xcf\xed\xfb\x81\xeb\x24\x3d\xb9\x5f\x23\x8f\x45\xa2\xb1\xaf\x13\x8d\x2c\x94\xe4\x7e\x82\x25\x99\x7f\xbe\xb9\x9f\x3d\xdf\x94\xbc\x6a\xf7\xf3\xbd\x6a\xf7\x53\x5e\xb5\x29\x5f\x30\x96\x26\xc7\x91\x29\xe5\x6b\xc6\x12\xe7\xf8\x47\xe5\x0b\xfd\xfe\xac\xa3\x64\x68\x58\x22\x89\x91\x24\x95\x29\xc9\x2d\x05\xde\xa8\x9f\xc2\x74\xe8\x8d\xbd\xb2\xf0\x9a\x73\x90\x2c\x0b\xb0\x59\x9e\xa4\xd4\x2f\x2b\xa7\x2d\x75\x63\x69\x18\xcb\x94\xd7\x00\x3f\xd6\x57\x75\x95\x26\x41\xea\x68\x75\xca\x2f\xca\x15\x05\x22\xd5\x63\x52\x18\xa9\xab\x30\x0a\x80\xe4\x37\xb5\x71\x2e\x35\xc3\xc3\xea\x5d\xa6\xaf\x52\xbe\xd2\xdc\x85\xba\x85\xaa\xe3\xd0\x33\xfe\x06\x18\xc1\xcc\x77\x7a\x0b\x55\xcd\x6a\x6a\xa5\x99\x51\xbd\x86\xb4\xb5\x93\xda\xdc\x27\xb3\x8a\x94\x21\xe5\x8c\x52\xa6\x6e\x5a\x1c\x88\x05\x82\x11\xd2\x9d\x28\xb8\xec\x25\x95\x6b\x3c\xc9\xea\xa6\xfb\x7b\x9d\x20\xcf\x38\x16\xcc\x85\x92\x58\x80\x55\x3e\x37\x30\x6e\x35\x86\x8d\x0a\x60\x7a\xec\xe2\x62\xf8\xd2\xbd\x39\xe1\x4b\x8f\x61\xf0\x2c\x01\x5e\x9a\xb3\x7d\x59\x02\xbd\x74\x6e\x9a\xb4\x75\x0f\x7e\x39\xf8\x70\xa6\x85\x42\x2d\x05\xbe\xa9\x47\x2f\x4a\x22\x4b\x6d\x28\xbb\x5f\x0b\x51\x92\xe0\x40\x0b\xd1\x59\x73\x09\x94\x8a\x31\x35\xab\xf8\xc5\xdb\x80\x86\xc8\xea\x15\x22\xc3\x7e\xdd\xbc\xcb\xeb\xbf\xa5\x3a\x30\x59\x13\x2e\x45\x46\x5e\x38\x2e\x49\x4a\x71\x3d\xff\x56\xfb\x47\xf1\xb4\xff\x56\x2b\xd1\x0b\xc2\xff\x82\xae\x60\x3e\x25\x5f\xa0\x02\xb3\x43\xf9\xad\xa3\xee\x64\xf1\x77\x61\xd6\xdc\xe8\x84\xc2\xf2\xc0\xee\x38\x31\x2f\xff\x7a\x8d\x40\x6a\xce\xdd\x85\xfe\x82\x55\x27\x92\xbf\x50\xb5\x01\x16\xf7\xa8\x5f\x1a\xd9\x30\x13\x43\x18\x8a\x1f\xba\xfe\x2a\xe6\x03\x0f\x5f\x61\xdf\x39\x9b\x16\x87\xb3\x2c\xee\xc2\xf9\x4f\xa7\xbb\x60\x8a\xbd\x3f\xf8\xe7\xc1\x87\x77\x97\x67\x1f\x8f\xa9\x19\x46\xeb\xc5\x6f\xd2\x2d\x55\xb1\x0d\xb1\x93\xf2\x05\xbb\x68\xe0\x3a\x8b\xb5\x2a\x0f\xce\x2c\x7c\xd1\xbe\xc0\xf0\x62\xe1\xaa\x17\x1d\x23\x0b\x65\x64\xe8\xdc\x0b\xe5\x25\x6d\x46\x25\x08\x5a\xed\x4b\x28\x24\x29\xfe\xba\xec\xfb\xbc\x84\x20\xd3\xd8\xe5\xdf\x60\x1f\x48\xbe\x1d\x7f\x2d\xd9\x95\xab\x7f\x48\x3d\xae\xbf\x25\xd3\x6e\x09\xc5\x47\x4b\x35\x59\x98\xed\xcc\x66\xc9\x52\x8a\x30\x7d\xa7\x7c\xa9\x29\x2f\xe3\x81\xb1\x2a\x7a\x07\xcc\x2d\x63\xe1\x79\xf4\xbc\x8a\xed\x08\x57\x2d\x04\x7f\xb7\x5d\x5f\xfc\x0c\xc6\xb1\xf4\x9a\x3f\x46\x23\x62\x02\x91\x5f\xec\xe2\xe5\xec\xf8\xce\xe2\xe2\xc4\xdf\xfa\xfd\xbe\x88\xca\x4c\x9e\x5f\xd4\xc9\xff\xaa\x69\xa3\xa0\x1a\xe2\x5e\x0c\x6f\x59\xf8\x01\xbb\x1b\xf5\xdc\x28\xb2\x51\xd0\x47\xa3\x00\x4e\x32\x7b\x93\x16\xaa\x3e\xab\x7f\x27\x27\x0b\x42\xc7\xf5\x21\x78\x43\x92\x6c\x9a\x4d\x06\x4b\x6d\x7a\xd8\x4e\x52\x52\x57\x0e\x3a\x75\xa7\x16\xe2\x75\x29\x97\xe3\x12\xae\xdc\xc0\x27\x79\x9c\xd0\xbe\x75\xfd\x2b\x3e\xe1\x2b\xcb\xee\xdd\x7d\x39\x1b\x2c\x7e\x51\x48\xcf\x22\x82\xbe\x94\x23\x7b\x3d\x9f\x57\x83\x2c\x35\xb5\x59\x94\x45\x68\xf5\x05\xab\x96\xba\x54\xaf\xa7\x66\x71\xc0\x5e\x13\x96\x81\x88\xa6\x9d\xd8\x72\x90\x41\x33\x76\x4a\xec\xd9\xeb\x2d\x2d\x9f\x6d\xda\x9f\x46\x6c\xc7\xde\xd4\x8d\xa7\xbd\x7a\x3d\x67\x64\x34\x9e\xa5\x3e\x71\x21\x67\xa2\x2a\xaf\x7e\xaa\xe4\x57\x15\xa2\xc4\xf0\x0d\x41\x3b\x8c\xf0\x3b\xf9\xc8\x5e\xf5\x02\xda\xa3\x67\x06\xd4\xc3\x47\x06\x60\x21\xdf\x34\xf0\x2b\x29\x44\x81\x3d\xe9\xac\x9b\x93\x71\xaf\xfc\xc5\xfd\x14\x06\xd0\x5a\x43\x3b\x1e\x9c\x12\x3a\xcc\xe1\x3e\xcf\x37\x21\xe3\x8f\x40\x61\x22\x5c\xdf\x80\x1f\x76\x37\xca\xc9\x6c\x11\xb9\x54\x36\x66\x81\xed\xa7\x12\xb5\xb6\xdc\x8c\x57\x38\x3e\xc1\xb6\x77\xec\xe2\x0c\xd4\x98\x1b\xe3\x61\xd2\x88\x97\xe4\xf1\xef\x23\x36\xde\xc9\x83\x7a\x00\xe9\xd0\xec\x52\x32\xb8\xa6\xc8\x3f\xf7\x06\xae\xe7\x84\x00\x16\x27\x27\xe1\xaf\x45\x23\x8f\xa4\x6b\x74\x9f\xe5\x6e\x5e\x52\x13\xd1\xf0\x3d\xec\x79\xcb\x94\x3b\x60\x0e\xb2\xbe\xf3\xda\xf3\xde\x4c\x89\xb2\x63\x27\x70\xac\xb6\x85\x3b\xcc\x1a\x98\x66\x1d\x76\x20\xb4\x98\xdb\x47\x70\xf5\x06\x6d\x6e\x42\x07\xf0\x90\x29\xec\xb8\x8c\x49\x00\x7c\xd1\xfb\x3b\xab\x8e\x66\xfc\x58\x2a\xeb\x5d\x3c\xb2\xa7\x5e\x60\x3b\xec\x8a\x18\x3f\x76\xb3\xb2\xdd\x25\x5c\x5f\x68\x23\x6e\x6e\xd2\x1f\xcc\x2f\x2d\xfd\xac\xdc\x10\x7d\x48\x00\xd9\x48\xbd\x54\x02\xfa\x9a\xd1\x4f\x6a\xd5\xc8\xbb\x82\x2a\xe9\x99\x26\x99\xf2\x98\x61\x24\xce\x2f\xda\x19\xfd\xf3\x36\xe0\x73\xd1\x51\x9f\x62\x43\xaa\xc3\xc7\x62\xd6\x7a\x32\x8c\x68\x90\x47\xfa\x56\x0e\xf2\xc8\x02\x3c\xb2\x0f\x72\x80\x47\x1e\x58\x92\x7d\x52\x02\x4b\x8a\xa0\x92\xec\x23\x7d\x16\x83\x69\x68\x4f\x8e\x5d\x2c\x0e\xc8\x17\xbd\x89\xd7\xe3\xe3\xe8\x27\x01\x45\x93\xc4\x57\xe4\xf1\xee\x92\xd1\x33\x41\x1d\x1e\xc3\x73\x41\x5d\xd9\x15\x03\x17\x87\x3d\xec\xd3\xcb\x4a\xe9\xe1\x0a\xd7\xff\x18\x0b\xb4\x8d\x76\x50\x33\xe1\x62\x8a\x3a\x2c\xc8\xe8\x7a\x99\x98\x26\x01\xff\x58\x6f\xc8\x6c\xa8\xee\x0c\x6b\xe5\x44\xf6\x91\x50\x7a\xde\x42\x75\xc1\x8f\xea\x31\xb1\x56\x7e\xd2\x20\x46\x12\x3f\x8a\x5c\x3e\x45\xf5\xda\x0b\xc1\xa0\x8c\xaa\x26\x11\x53\x40\x90\x60\x0a\x8c\xfe\x13\xc6\x54\x02\xd1\x53\xd6\xff\x22\x92\xec\x53\x2e\x93\xf4\x02\x73\x32\x86\xef\x38\xf2\x0e\x47\xda\xc9\xc7\xcb\xc9\xc7\xdc\x91\xf7\x91\x12\xbe\x1e\xd2\xd3\x2a\x1c\x72\x46\xd8\xc9\xcc\xab\xc4\xbc\x78\x96\x68\x04\x52\x4b\x66\x74\x3c\xab\x81\xd2\x60\x83\x9b\x8e\x69\xf1\x89\x3e\x8a\x8f\xfe\x61\x8c\x87\x3f\x05\xe3\x08\xbf\xc7\xf6\x0d\x4e\x92\xa5\x3e\x68\x32\x1c\xf8\xc4\xf0\xd4\x64\x80\x0f\xc9\x54\x2c\x6c\x82\x63\x17\xa7\x0c\x05\x6a\x1c\xb4\x99\xaa\x7e\xc2\x93\xde\xdf\x23\xfe\x5b\xaf\xb0\xa9\x87\xf5\xc3\x46\xd6\xa8\x68\x6a\xad\x0a\xf9\x24\x43\x35\x1d\x9a\x35\xf9\x1b\x4f\xaf\x9a\x7a\x72\xea\x62\x8b\x4f\x4e\x99\x76\x75\x4d\xb9\x4e\x2b\x69\x75\x7e\x9b\x12\x5e\x83\x9c\x34\x05\xda\xc0\x4c\xdb\x74\x2a\xf6\xda\x12\xfe\x28\x09\xac\x83\x9c\x4c\xc1\x76\xa0\x17\xfb\x7d\xc5\x54\x24\x16\xa2\x3c\x7e\xd8\xe7\x44\x3f\x8a\x99\x8b\xf5\xaf\x6e\x3e\x53\xe7\x30\x9e\x95\x42\xfe\xaa\xdd\xac\xb5\x59\x05\xd9\xc4\x4c\x37\xee\xf2\x70\xa7\x34\x38\x53\x6c\x12\x06\x07\xf3\x6e\xf4\x2e\x63\x0e\x93\x3a\x26\x05\x8a\xb4\x71\x10\xdb\xde\xb1\x2d\xf7\x99\xa1\xe6\x7f\xd9\x21\x56\x32\x7a\x05\x55\x69\xc1\x7f\xb7\x51\xc3\x44\x4f\x95\xbe\xe6\xf4\x42\x6c\x7b\x67\x84\x26\xa7\xa6\x12\xdb\x86\xfc\x4f\x93\x1e\xd8\xce\x70\x20\x53\xd2\x5c\x31\xdf\xf8\xaa\xee\x8b\xcf\x9c\x14\x34\x51\x25\xb8\x81\x7a\x6b\x87\x6c\x69\xc3\xb0\xc1\xab\x3f\x47\x18\x55\x18\x93\x15\x14\x07\x28\x1a\xe1\x9e\xdb\x9f\x4a\xd1\x22\xc9\x2a\xde\xc5\xd6\xef\x3e\x77\xed\xc1\xf4\xb6\x21\xaa\x70\xde\x2a\xe8\xd6\xf5\x3c\xd4\xc5\xc8\xc1\xa3\x10\xf7\xec\x18\x3b\xc8\xf5\x51\xa3\xd6\xa8\xd5\xab\xcc\x62\xcb\xbd\xe1\xbe\xea\xbb\xed\xff\x1d\x0d\x24\xdf\xc6\x17\xfa\x38\x82\x90\xa6\x7c\x68\x87\xd8\x19\xf7\xb0\x64\x5a\x87\x38\x1a\x7b\x31\xbf\x4a\x27\x01\x8b\xdf\xd8\x5e\x29\x73\x62\x25\x97\xd2\xb9\x3d\x23\x26\x15\xca\x16\xda\xe2\x11\x42\x56\xe2\x7e\x78\x63\x7b\x26\x7a\x05\x35\x6b\xb1\x02\x1f\x64\x4b\x2a\xf1\xa6\xa5\x73\x9a\x74\x3d\xe7\x26\x70\x1d\x76\x81\x86\x42\xde\x0f\xd1\x4b\x54\xe7\xed\x95\x64\xe4\xed\x3c\xeb\x2a\xea\x17\x6c\x61\x5a\xb8\x4f\x5d\xb2\xd6\x59\x3a\x9f\xf7\x90\xab\x94\x3c\xa2\x16\x26\x51\xe1\xeb\xeb\x5b\xb4\x43\x04\x5f\x2e\x36\xc6\xc3\xd1\xa9\x6c\x4a\x48\x5d\x8a\xb8\x67\xbb\x02\x57\x9d\xce\xa0\xde\x59\x5a\x78\x11\xa2\xdb\x35\x92\xa6\x3c\xcd\x8c\x85\x74\x17\x7b\x32\xec\xc9\xf7\x73\x58\x9e\x8d\x54\xfd\x0f\x12\xf3\x28\x95\x7d\x8d\xb5\x31\xc4\x2c\xba\x25\xfa\xfe\x69\x6a\x06\x56\x04\x44\x06\x34\xca\xb0\x29\x57\x43\x01\x33\x62\x39\x1d\x2f\x59\x1c\x1b\x89\x45\x24\x2f\xa5\xd0\x96\x64\x2a\xc9\x6b\x9a\x0c\xbd\x38\x08\xbc\xd8\x1d\x1d\xd3\x9d\x12\x1a\xbc\xd7\x07\x97\x3f\xf2\x5f\x8b\xbb\xf8\xdf\xd8\x9e\x95\xda\x4e\xa1\x01\x7d\x33\x84\x82\xc8\x65\xd7\x69\xd7\x01\xa1\x23\xd5\x0a\xd6\x43\xd2\xe3\xd4\x52\x1a\x47\x01\x58\xe2\x36\x31\xd5\x74\xba\x9d\x22\xda\x6b\x2d\xfe\xc3\x4a\x79\x23\x29\x56\xbb\xd2\x40\x6a\x03\xb6\x52\xcf\x09\x17\x2d\xf1\x4b\xe5\xb3\x95\xe2\x3a\xd5\x8e\xad\xf4\x8b\x64\x17\x8b\x6f\x59\x89\x36\xb0\x14\xd8\x2c\xe8\xb7\xcf\x85\xb8\x92\xb8\x05\xcb\x86\xb2\x2a\xda\x49\x1a\x09\xdb\x57\x92\x75\x2b\x67\xdf\x4e\x7e\x2f\x9f\x25\x7c\x16\xe5\xc4\x9b\x3b\xe3\x05\x4f\x64\x29\x6f\xd3\x4d\xd9\xb7\xcb\xf6\x4f\x94\x8a\x73\x41\x2b\x18\xf8\xc9\xf2\xb7\x95\x59\x29\x2b\x69\x60\xc5\xdb\xca\x2c\x8e\x37\x28\x2f\x3c\xa4\x44\x73\x55\x51\xe9\x59\x08\x95\x54\x94\xe9\xe7\x8f\x51\xa6\xbf\x9a\x28\xd3\x6b\x0b\xae\xac\x2d\x63\x35\xe1\xa5\x97\x0d\xae\xdc\x5c\x4f\xb0\xe1\xe6\x0a\x82\x0d\x37\x97\x0b\x36\xbc\xbb\xc6\x60\xc3\xbb\xab\x0a\x36\xbc\xbb\x82\x60\xc3\x7b\xeb\x0d\x36\x9c\x26\xbf\x82\xf0\xd1\xcb\x05\x1b\x7e\xb6\xc6\x60\xc3\xcf\x56\x15\x6c\xf8\xd9\x0a\x82\x0d\xef\xaf\x3d\x10\xe9\xf3\xf5\x87\x33\x7e\xb1\xfe\xa8\xb0\xdf\x7f\x86\xa0\xb0\xf5\xf5\x47\x6c\x4d\x80\xd2\x8f\x03\x6f\x7a\x55\x30\x0f\x35\x9b\x8b\x56\xa3\xc9\x8b\x78\x17\x14\x44\x19\x5e\x34\xe8\xf3\xee\x67\x08\x5d\xbd\x48\xc4\xe4\xc7\xc8\xb6\x8f\x91\x6d\x1f\x23\xdb\x3e\x46\xb6\x7d\x8c\x6c\xfb\x18\xd9\xf6\xbf\x3e\xb2\xad\xed\xd8\xa1\x2e\x8e\x2d\x19\xc8\xf0\xb1\xcc\xa6\xa2\xce\x30\x5c\x4f\x14\x5b\x60\xa9\x20\x8e\x2d\x7c\x5f\x61\x24\x5b\xa0\xf7\x5f\x1a\xcb\x16\xea\x56\x26\x9a\x2d\x6d\x84\x2f\x1d\xcf\x96\xc2\xc4\xcf\x08\x67\x7b\xcc\xb0\xe4\x69\xe2\x6c\x30\xdb\x85\x83\xcc\xe6\x07\x97\x9d\x59\x08\xec\xc6\x2e\x55\x0c\x6b\x23\x7d\x39\x8a\xa3\x8e\x74\x38\xa8\x9e\x0a\xca\xbb\x98\x44\x48\xe4\x18\x72\xbe\xe2\xd2\x23\x1d\x5c\xc9\x5f\xe4\x33\x2c\xf9\xbd\x71\x29\x63\x41\xe0\x74\xcc\x55\x0d\xaf\xdc\x0b\x69\x16\xaf\xc2\x5b\x29\xcb\x2b\x7c\xd2\xf2\x0a\x5f\x34\xbc\xc2\xfb\x12\xbc\xae\x20\x2c\x30\xd3\x51\xdf\x6c\x60\x60\x36\x76\x44\x32\xfa\x9c\x17\x16\x78\xf1\x28\xbd\x6c\x40\xcf\x0c\xd2\x4b\xe1\x47\xde\x05\xf1\x4c\x30\x75\x96\x26\x0f\x49\x1d\x56\x17\x34\x89\xfe\xa0\x76\x8e\x1d\xca\x52\x30\xeb\x49\x61\xf3\x51\x5e\x15\xd2\x7a\xe1\x4e\xb2\x1e\xf2\x3c\x61\xb9\x08\x6c\x7d\x05\x55\x2c\x0b\x3a\xae\xee\x41\xcc\x11\x0d\x4e\x0b\x71\x1d\x92\xb1\xb9\xed\x04\xb1\x14\xf8\x2d\x8b\x9f\xce\x2a\x35\x03\x90\xed\x5d\x10\x17\xe3\xf2\x91\x04\x99\x69\xab\x38\x90\x95\x13\xc4\x2a\x40\xb9\x13\xc4\x4a\x82\xae\x1d\x95\x8f\x44\xa4\xdb\x4d\x5b\x45\x54\xa6\x77\x41\xfc\x39\x78\x70\x82\xd8\x4c\xb7\x0e\x78\xc3\x40\x93\x96\x8c\x63\xe4\x24\xbc\x6a\xb1\xd0\x69\x8f\x3a\x41\x4c\xa1\xc5\x65\x45\x18\xb6\xd0\xae\x78\x7c\xb0\x92\xb6\xb7\x52\xed\xa0\xc2\x77\xf6\x26\x3c\x3e\x4e\x0a\xca\x8e\xbf\x4e\xc1\xd8\x69\x22\xe2\x78\xba\x4b\x14\x29\xc8\x4c\x6e\x07\xca\x91\x40\xb8\x02\x74\x82\xd8\x12\x35\x5f\x28\x1e\xc7\xec\x31\x5b\x1a\x0c\x6b\x05\x01\x39\xc4\xb0\x55\x03\x72\x90\x17\xec\x61\x16\x7a\x22\xdb\x24\x2d\x19\x70\x20\x93\x5a\x3f\x8c\x85\x3b\x72\x0e\xc2\x26\x8b\x37\x20\x22\x79\x93\x67\x05\x90\x1b\x46\x3b\xff\x4c\x87\xba\x44\x3f\x64\xeb\x2f\x3e\x53\x31\x81\x59\x76\xa2\x02\x36\x54\xa0\x3c\x56\xd0\x12\xb3\x14\xad\x9b\xaa\x8a\x65\x63\xeb\x4e\x84\x79\x12\xa6\xf9\x6a\xe7\xb2\xfc\x5a\xd1\x2b\xf1\xcb\x70\xb6\x74\x4b\xcd\x1d\xfc\x54\xec\xe9\xcf\x9e\xf0\x16\xd4\xc0\x38\x1d\x9b\xa1\x60\x06\x50\xf5\x9b\xea\x10\xa1\x5d\x89\x58\xd9\xe4\xcc\xc7\x42\xbb\x18\x90\x95\xec\x67\x9a\xd4\xd4\x2a\xa9\x12\x20\xe9\xdb\x05\x42\xac\x7c\x8d\x9a\x73\x44\xc5\x49\x51\x9e\xf0\x45\xd1\xa5\xe8\x95\x0c\x7e\xa8\x58\x2f\x34\x34\xc6\x7c\xba\xb6\x7c\x18\x0c\x5d\x06\x5d\x18\x0c\x6d\x6c\x97\x59\xe1\x35\x53\xcb\x99\x5d\xb6\x9e\x29\x07\xf8\xba\xbb\x50\x10\x8c\xdd\x85\x82\x60\xec\x2e\x16\x04\x63\x77\xde\x20\x18\xbb\x45\x41\x30\x8e\x79\x6b\xa5\x20\x9b\x8f\x53\x8b\xc0\xcf\x33\x0c\xf2\xbc\x09\xfe\xfb\x43\x60\xd0\x71\xbb\x7c\x10\x8c\x9c\x2c\xb0\x27\xa5\xcf\x04\x9f\x24\x8d\x2c\x7e\x16\x06\xf5\x97\x63\x67\x34\x8b\x63\x67\x14\x9a\xef\x25\xe2\x59\x30\x11\x65\xe1\x2c\xe8\x93\x88\x66\xa1\x64\x2c\x0e\x45\x71\x29\x23\xf7\xff\x56\x66\x2d\xa3\x71\xb1\x28\x13\x90\x42\x04\x9f\x9c\xe8\x03\x03\xc8\x7c\x7c\x5c\x23\x1f\x22\xf4\xe5\x34\x0b\xf4\xaf\xf3\xa2\xcc\x0d\x4d\x30\x69\xa5\x1a\xcf\x88\xcd\x6c\x2c\x82\x69\x2a\xd5\x47\x23\x36\x53\x89\x1e\xcc\x74\x7c\x80\x4c\xc7\x7f\x86\x4e\x4a\xc7\x08\x4d\x77\x53\x9a\x8d\x35\xf5\x51\x3a\x40\x69\xa6\x97\xe6\xe8\x23\xb2\xa2\x9c\xd1\x41\x53\x35\x49\xa6\x77\xd4\xbe\xc9\x89\xd6\x20\xc7\xdb\xca\x2e\x9a\x44\x0c\x84\xf9\xe3\x1e\x30\x62\x65\xcc\x06\x2d\xf6\x7d\x7e\x58\xac\x94\x3d\xb0\x37\x97\x3d\xa0\x09\x8a\xb5\xe8\x0c\x9a\x1b\xf3\x60\x94\xe8\x37\xaa\x29\xd3\x11\x0f\x58\x09\x4b\x06\x3c\xa0\x54\x2c\x56\xc8\xac\x70\x07\x7a\x13\x2d\xcf\x3a\xce\x66\xcc\x2e\xa5\x57\x1e\xee\x20\x3f\xd4\x85\x12\xee\xe0\x59\x26\xdc\x41\x36\x92\xc1\x33\x7d\x24\x83\x94\xe8\x3c\x9b\x4b\x74\xb4\x01\x33\xb4\xb1\x03\x46\x49\xff\x2a\x12\xf0\x35\x62\xdb\xeb\x5d\x20\x15\x6c\x7b\x30\x65\x16\x44\xb7\xff\x1a\x16\x53\x7a\x78\xfb\xac\x88\x1b\x5f\x3b\x50\x3b\x1b\x78\x1a\x0d\xac\x02\xb4\xc3\x01\x56\x31\x44\x7b\x73\x4e\x88\xf6\x13\x26\x03\x4b\x80\xb4\xeb\xd7\xfd\x25\x30\xda\x4b\xc3\xaa\xeb\xfd\xb4\x15\x58\xf5\x12\x48\xc3\xb9\x54\x4a\xe1\xe9\xe5\xe6\x9e\x8d\xa7\x37\x8b\xfd\x45\xb2\x6a\x91\x86\x01\x28\xed\xf5\xc4\x8d\x8a\xb1\xe5\xd7\xd4\x10\x4b\xd4\x86\xb6\x21\x45\x47\xa4\x68\x6a\xdf\x76\x2d\x36\x92\x9d\xab\x05\xe8\xcc\x86\x59\xcc\xe7\x5e\x42\x19\x2d\x04\x97\x9c\x25\xce\x40\x61\xb1\xe1\x24\x53\x28\x8e\x51\x50\x8e\xc4\xf2\x5c\xd8\xb3\xa0\x90\x4b\x51\x09\x67\xe2\xb5\x96\x22\xc3\x0c\xa7\x25\xa9\x88\x5b\x81\x8b\x0c\x10\x58\x22\xc1\x05\x39\x1a\xd0\x60\x16\x10\xeb\x9a\x86\x5a\x09\x30\xd9\x19\xfa\x2f\x41\x53\x7d\x17\xc4\x5f\xa0\x06\xb3\xa1\x64\xd7\x56\xf9\x85\x32\x26\x10\xbc\x3b\x3b\xe8\x76\x80\xc1\xa7\x73\x60\xdf\x60\xd8\x65\x76\x7d\x34\x0a\xbc\x29\xf2\x5c\x1f\x6f\xc0\xc6\xf3\x63\x93\xce\xd1\xa4\x33\x91\xa5\xbf\xd2\x61\xb4\x50\xc6\x25\xba\x49\x6a\xb1\x52\xf0\xf2\xc5\xcd\x36\xf7\x81\x54\x01\xba\xfc\x2c\x48\xf6\xc2\x2a\xc1\xac\xaf\x1e\xc1\x2d\xda\x21\x1b\xe9\xc3\xb9\xa5\x08\xbd\xf5\xdc\xde\xf5\x52\x34\xe6\x82\x6b\x9e\xd1\x48\xa5\x23\x20\x95\x98\x06\xcb\x03\x3f\xcf\x43\xac\x0c\xf0\xf3\x3c\xf4\x66\x03\x3f\xcf\x90\xf0\x79\x81\x9f\x4b\xc3\x3d\x2b\xeb\x85\x7a\xd6\xf8\xae\x6b\xd0\x88\xa5\xe9\x96\xe3\x15\xc3\x44\x21\x12\xe8\xe1\xa1\x17\x42\x2d\xd6\x0f\xe0\x72\xa0\xc5\x0b\x42\x16\xcf\x83\x00\xb8\x9b\x20\x00\x26\xed\x26\xc2\x94\x27\xaf\xf8\xee\x83\x68\x6e\x91\x46\xbc\x11\xc0\x73\x74\x75\x2e\x0a\xa4\xc9\x94\xb7\x1a\x8c\x3a\x9a\x88\x63\x91\x49\x18\x9e\x82\xbe\x14\xbd\x13\x60\x35\xa5\x0f\x09\x00\x9d\xd8\x45\x53\xca\x9b\xe1\xce\x35\x17\xb8\x90\xee\xfa\x65\x39\x7c\x8d\x84\x61\x0e\xc2\x27\x60\x86\x18\xb6\xd2\x78\xdd\x2c\x38\x69\x64\x25\x11\x36\x5d\x69\xd0\xa8\x67\x7b\xd8\xf0\xe9\x76\x1a\x42\xb2\x7c\xa0\x8e\x24\x28\x2c\x21\x70\xce\x37\xde\x74\x07\x09\x33\xab\xa4\xbb\x37\x3b\x03\x38\x06\xd0\x33\x2d\xc6\x0c\x6b\x5c\xc9\xf3\x42\x8f\x79\x03\xd7\x67\x52\xd8\x9b\x7c\x4d\xa4\x50\x6a\xd1\x3f\x09\xf8\x62\xc6\x67\x8e\xa1\x84\x98\x2a\xb0\x67\xda\xdd\x67\x0d\xe8\x1d\xe2\xda\x48\x0a\xbf\xe3\xc5\x23\x7e\xc7\x23\x7e\xc7\x17\xc5\xef\x10\xa4\xe0\x8e\x52\x7e\xdd\x5f\xac\xaa\x80\xa5\x20\x3d\xd2\xc4\x16\xc5\xdf\x58\x0b\x6a\xc9\xee\x0a\x50\x4b\x76\x97\x43\x2d\xd9\x5b\x23\x6a\xc9\xde\xaa\x50\x4b\xf6\x56\x80\x5a\xf2\x17\x42\xf1\x58\x2b\x3c\x4b\x9a\xfc\x12\xb5\x4d\x93\x5a\x18\x53\x84\x7a\xbc\xd2\xe0\xcc\x05\x80\x22\x0b\x8a\xf1\x8b\xf5\xa3\x4c\x7c\xbf\x7e\xd0\x12\x61\x4f\xae\x11\x7b\xa5\xd1\x58\x00\x2c\x63\x41\x58\x91\x74\xdc\x8a\xbc\xaa\xd4\x17\x6d\xaf\xdd\xb5\xa3\xe1\x34\xf6\xe6\x04\x79\x79\x04\x16\x79\x04\x16\x79\x04\x16\x59\x33\xb0\x08\xdd\x30\xfe\xd5\x8d\x07\xc1\x38\x96\xca\x0d\xba\x7f\x80\xd8\x46\x5c\x1a\x68\x8b\xa2\x0e\xba\x7b\x68\xcb\x72\xe4\xfa\x28\xe8\xfe\xc1\x5b\x84\xe4\xa8\x81\x6f\xe9\x51\xdf\x70\x4d\xf4\xb2\x83\xea\x26\x22\x13\x8a\xeb\xf3\x4e\x7e\x52\x6a\xe8\x00\x03\xae\x29\x67\x66\xa3\xc7\x25\x63\x27\xe8\xfe\x01\xd2\x98\x1d\x32\x8f\xb0\x29\x8f\xb0\x29\x8f\xb0\x29\x5f\x19\x6c\x0a\x58\x60\xc8\x46\x57\x61\x30\x1e\xa1\xa0\x0f\x3b\x53\xb6\x87\xba\x5a\x34\x15\x06\xa6\xe2\xda\xde\x9b\x72\x80\x2a\x5a\x73\x6f\x6d\x88\x2a\x94\xaf\x62\x54\x15\x9a\x66\xb5\xc8\x2a\x94\xe6\x7f\x2f\xba\x0a\xad\x5f\x49\x84\x15\xd6\x18\x4b\xa3\xac\x6c\x64\xfc\x50\x53\x38\x22\xb4\xb6\xb3\xf1\x56\x1c\x3b\xb6\x67\xa0\xad\xbc\x83\xe8\xe3\x10\x56\xee\xbf\x17\x69\x65\x35\x88\x20\x7c\x8c\x7d\xb3\xa8\x20\x3c\x6a\x63\x12\xb0\x71\xf5\x88\x20\x8e\x7c\x57\x20\x17\x0f\xe4\x0a\xc7\x49\x50\x9d\x9c\x96\x52\xd2\x68\xbd\xc5\x0b\xae\x6d\x2b\x91\xa1\x72\x83\x42\xa1\x54\x60\xa8\x54\x4c\x28\xc5\x99\xba\x74\x40\x50\xcd\xb2\x75\xde\x80\xa0\xbc\xcc\x65\x83\x82\x4a\xda\x50\x13\x18\x34\xa7\x6f\xa8\x07\x32\xdd\xcb\x81\xc0\xdb\x85\x6e\xfc\x52\x3a\x7e\x81\x5c\x03\xd9\x12\x25\xa9\xe6\x85\x6d\xc9\x6c\xd1\x96\xb9\x0d\xaf\x96\x37\x1f\x71\xdd\x9d\xf8\x35\x00\xb7\xcc\x62\x9a\xfa\x67\xce\x80\x6e\x59\xaa\x9e\x25\x6f\xb4\x67\xb6\xf7\xb4\xf7\xd9\x53\x8c\xa6\xa5\x2f\xe1\xb3\x94\xdc\x45\x25\x41\x1e\x32\xa9\x0d\x16\x1b\xa0\x2c\x58\xcb\xac\x9b\xc7\x2a\xfe\xc3\x6e\x16\xff\x41\x0a\x50\x2f\xdf\xce\x4d\xde\x66\x13\x43\x38\xf7\x4c\x62\x78\xab\x5c\x69\x49\x45\xc3\x63\xa9\x75\x81\xf0\xc8\xbf\x80\x2c\x1f\x20\x61\xde\xfa\x99\x51\xb0\xd0\x79\x35\xa2\xe3\x1a\x55\x25\x46\x93\x47\x60\x85\x3c\xca\x65\x55\x2f\xcc\xc5\x51\x6c\x74\xdb\xab\x25\x2f\xfc\xd3\x7a\x65\xf5\x19\xed\xe7\x92\x08\x32\xa3\x0c\x7c\x8c\x8a\x05\x73\x97\xd3\xee\x6a\x04\x93\xe4\x06\x9c\xb8\xb4\xb7\x60\xcd\xfb\x69\xe4\x86\xe8\xa8\xff\x76\xe0\x7a\x0e\x5b\x11\x50\x40\x98\x91\x12\x63\xd7\x4d\x01\x1e\xd0\x51\x43\xdb\x21\x0b\x7c\x93\x87\x24\xe0\xda\xde\x76\xd7\x0e\xb7\x69\xbe\x6a\x52\xa5\x59\xb8\x34\xb2\xa2\x77\x61\x91\x2d\x4b\xf3\x2b\x65\x20\xb4\x90\x5e\x6f\xce\xba\x30\xc6\x86\x73\x79\xd4\x01\x5d\x86\x39\x51\x07\xf2\x6f\x19\x2a\xe6\xd2\x9e\x12\xe0\x1a\xcd\x7b\xc3\xb0\x04\xe2\xc0\xde\x42\x88\x03\x7b\x8b\x21\x0e\xec\xcd\x8b\x38\xb0\x57\x84\x38\xc0\x16\x1e\xa9\xdb\x92\xef\x14\x03\x73\xe6\x3d\xb1\xd9\x73\x54\x89\x7b\x62\x79\x87\x63\x7f\x09\xb4\x01\xba\x40\x29\x89\x38\x30\x0b\x3e\x60\x01\xa0\x02\x49\x3f\x8a\x9f\xab\x42\x1c\x28\x1d\xd6\x5c\x95\x4c\x86\x37\xf0\x8e\x85\x4d\xe7\xbf\x17\xc1\x1a\x90\x6f\x5a\x2b\xe1\xd5\x16\x5c\x12\xcc\xbe\xec\xaf\x06\x4c\x8d\xc3\x69\x4d\xb3\x4e\xc8\x63\x51\x8a\xe8\xb6\x36\x06\x45\xf0\x5c\xc6\x1e\x7f\x5e\x12\x9b\x40\x8e\x85\xa5\x6f\x75\x2d\x58\x41\x12\x1e\x4b\xd7\x0e\x65\x90\x0b\xd2\xed\x29\xad\x0d\xd5\x0a\x66\x0b\x57\x56\x9c\xe9\xce\x6a\x17\x63\x22\xac\xa9\x8b\x74\xf1\x76\xe7\xc1\x23\xc8\x69\x50\x23\x36\xcb\x01\x0b\xac\x42\xd3\xa3\x42\x6d\xaf\x73\x0c\x28\xbc\x14\x4c\xfe\xf9\x63\xcf\x53\xdf\x28\x10\x08\x9a\x25\x05\x87\x40\x90\x32\x2d\x00\x87\xc0\x08\x97\xb1\x67\xe6\xbc\x1b\xaf\x18\x2a\xcf\xe6\x30\x54\xb4\xf7\xd9\x93\x72\xcb\x4e\xed\xb9\x30\x08\x0e\x53\xbb\x4e\x12\x3b\x3a\x81\x40\x10\x31\xc4\x97\x00\x40\x00\x2f\x67\x20\x3f\x0b\xfc\x40\x6f\x29\x96\x00\x3f\xc8\xca\x83\xb4\xc5\x95\xdb\xd9\x6f\xec\xde\xf5\x55\x18\x8c\x7d\xa7\xb0\xbf\x93\x64\x05\x0b\xd7\x3d\x9d\xf1\x9a\x5a\x1d\x4a\x70\xa3\xf2\x97\xd4\x8a\x8d\x17\xf6\x39\xd6\x6d\x12\x47\x49\xc1\x4b\x2c\xe3\x76\x76\x10\x8e\x3c\xd7\x8f\xb7\x1d\x37\xb2\xbb\x1e\xde\xf6\xf1\x24\xde\xf6\x5c\x1f\x23\x3f\xd8\x1e\xfb\xe3\x08\x3b\xdb\x37\x76\x18\x29\x2b\x3f\xee\xee\x4d\x55\x32\xf5\x4d\x56\x06\x7f\xc2\x9c\x48\x95\xbc\xb2\x52\xca\x32\x8a\x8b\x16\xd8\x8c\xed\x73\x16\x8e\xda\x42\xd5\x84\x92\xbc\x7c\x66\x71\xf4\xa5\x66\x51\x26\x41\x0d\x2e\x84\x02\xab\xa3\x5f\xd0\xce\xbd\x82\x25\xb5\x51\x67\xdf\xbe\xeb\x79\x2d\x54\xfd\x1b\xc6\xb8\x2a\xa7\x94\xda\x23\x2d\x44\x6b\x5d\x01\xef\xcd\x58\x01\xeb\x70\x57\x97\x5b\x15\x27\xb5\x2b\xbf\x40\xde\xd3\x2c\x90\xe5\x16\x9b\x73\x0d\x3c\x3f\x68\xca\x7e\x39\xd0\x94\xfd\x0c\x68\x8a\x32\x6f\xec\x67\xe6\x8d\x2c\xa6\xca\xbe\x1e\x53\x45\x19\x42\x3c\xa5\x7e\x10\xe5\xcf\x45\xfb\xa5\xb1\x55\x1c\x3e\x71\x48\xd3\xca\x37\x8a\xab\x62\x87\xd8\x5e\x10\x56\x65\x25\xcb\xe5\xb9\x0d\xa8\x12\xa8\x2a\x92\x34\x14\xc2\xa2\xcc\x65\x05\xae\xd4\x06\xcc\xc7\xd9\xcc\xea\x81\x6a\x6a\x0d\x9e\x18\x06\xd2\xdc\xed\x28\xd6\xa1\xb4\x34\xf9\x36\x6b\xcf\x26\xe5\xfc\xaa\x73\x33\x35\xb7\xde\xab\xc3\xce\xc9\x73\x68\x2d\x89\x9d\x93\x0f\x19\xac\x28\xba\xa0\x77\xfd\xab\x1b\x71\x6c\xdb\xf4\xc9\xe3\x0f\xa8\x2e\x4d\x03\xcc\xde\xd4\x58\xfd\x19\x08\x1e\xba\x21\x53\x0c\xc3\xb3\x3b\x3f\x0c\x0f\x25\xbb\x1c\x14\x8f\x7e\x56\x5e\x25\x14\x8f\xfe\xf2\x81\x02\xc5\x53\x12\x85\x26\x97\x52\xa9\xdb\xf0\xb3\xf8\x58\xa4\xe0\x45\x50\x68\xbe\xee\x5a\xcc\x44\xf6\x58\x13\xfb\xb3\x60\x05\x72\x33\x32\x2c\x03\x19\xd9\xe3\xf4\x0b\xd5\x61\x36\xc2\xc1\x67\xa9\xfe\x21\x35\x87\x17\x16\x84\x92\xe0\x58\x5f\xab\x1c\x2f\xdc\xfe\x29\x70\xac\x8d\xf4\x02\xea\xb3\x37\xc5\x12\xf5\xa1\xad\x48\xa5\x62\xe8\xfa\x00\x10\x79\xea\xfe\xb9\xd8\xa8\x48\xc4\x62\x68\x4f\xde\xd8\xe1\x0a\x08\x39\xe0\x6e\xb6\x00\x89\xd9\x48\x57\xf9\x6d\x22\x21\x5d\x15\xa3\x4c\x95\xa8\xc0\x2c\x94\xa9\x52\x24\x5c\x7f\x39\xf1\x92\x69\x05\xe3\x78\x65\xb4\x66\x02\x4e\xe5\x52\x81\x9c\x09\x4e\x54\x39\xb8\x96\xe2\xe1\x33\xf7\x96\x42\x01\x5c\xcb\x4c\xc0\x9d\x35\x8d\x64\x00\x32\xf9\x12\xf3\xc2\x42\x79\xe9\x3c\x46\x5b\x2c\x59\x01\xfd\x25\x9a\x6d\x89\x29\x5c\x99\x89\x67\xe1\x02\x15\x57\x79\x1e\x5c\xa0\xe2\x36\x98\x03\x17\xa8\x04\xa1\x99\xb8\x40\x33\x68\xcc\x0b\x0c\x34\xa3\x95\xe6\x81\xf3\x29\xa1\xf7\xe6\x82\xf3\x99\x87\xde\x6c\x38\x9f\x19\x1a\x70\x41\x38\x1f\x0b\x55\xa3\x11\xb1\x03\x56\x05\xec\xa3\x5a\x12\x3a\xac\x1f\x3d\x94\x0f\x9d\xed\xcf\x2f\x16\x86\xf5\xd1\x2b\xfa\xaf\x11\xd6\xc7\x65\x11\xf4\x00\x60\x87\x3c\x08\x4c\x13\xbe\x53\x0f\x5f\x94\x2d\xda\x52\x50\x40\xc9\x9b\x33\xb7\x77\xad\x4b\x09\xef\xe7\x40\x0e\x12\x2f\x54\x82\xea\xeb\xd5\xc1\x0c\xf1\xcf\x51\x6c\xf7\xae\x53\x74\xa4\x77\x3c\x59\xd7\x0e\x8f\x83\xc8\xe5\x4e\x4e\x90\x4c\x7a\x97\x24\xf3\x1d\x22\x8e\x52\x1a\xfa\x42\xe6\x06\x1c\x06\x84\xbb\xa5\x60\x2a\x79\x2d\x01\x1a\x95\x3a\x0f\xd3\x5e\x18\x4e\x0e\x33\x7c\x87\xb3\x79\xd4\x7f\x63\x33\xe1\x94\x99\x07\x31\x81\x2d\x23\x38\x01\x1a\x05\xe2\xbc\x8f\x6d\x1a\x9d\x5f\x88\xeb\x07\xf3\x42\x33\x89\xbd\xe9\x60\x1c\xf3\xdb\xb1\x35\xfa\xc8\x3f\x5e\x92\xe2\xff\xce\x25\x92\x3c\xa8\x02\xd9\x1b\xb8\x9e\x13\xc2\xd5\x1d\x29\x69\x8d\xbf\xe6\xc9\x64\x75\x90\x4a\x2a\x7f\x12\x8d\x0b\x97\xc6\xdc\x1e\x93\x4a\xce\x61\xa7\xc3\x9d\x96\xaa\xe8\x95\x24\xb7\x2d\x49\xe4\x39\xe3\x5c\x4e\x82\xa1\x0d\x1e\x73\xb2\x2c\xbd\x92\xe9\x53\xa8\xa4\x9a\x03\x09\x0d\x1e\xf4\x88\x93\xe9\xda\x11\xfe\xa5\x34\xfe\x93\xbe\xaf\xff\xe0\x87\x9f\x6f\x38\x31\xa9\xaf\xef\x68\xb3\xb7\x78\x08\x4b\x89\xb3\x96\xd2\x0c\xf4\x18\x08\xba\x18\x7b\xde\x12\x67\xb1\x03\x21\x7a\xaf\x3d\xef\xcd\x94\x68\x60\x86\xdc\xc4\x3b\x6d\xce\x6b\xfc\xba\x2b\x6a\xa2\x1b\xe8\xbe\x6f\x49\xdc\x2f\xd9\x2f\x4b\x3e\x8a\xa5\xee\xff\xc9\x66\xb1\xb4\x1a\xd2\x7c\x95\xd6\x37\x9a\xaf\x8a\xdb\x4d\xfa\xa3\xe4\xbe\x93\xfe\x94\x98\xb7\x74\x2f\x3b\x7d\x2b\x81\xdd\x82\xe6\x42\x26\x1f\xbb\x2d\x27\x3e\x6f\xa0\x71\xe3\x70\xec\xf7\xec\x18\xbf\x99\x32\x91\xe6\x0e\x3b\xbc\xc0\xf3\x94\xfa\xda\xa2\xcd\x79\x61\xa9\x43\x81\xef\x3e\xab\xf7\x02\x96\xe5\x71\x0e\x88\x33\x53\x0e\x69\x58\xe0\xc9\x91\x0f\x2a\x64\x98\x0c\xd8\x4c\xf5\xd9\xa6\x35\x38\x17\x23\x96\xc1\x8b\x5d\xa4\xaf\x16\x89\xde\xd2\xa8\x95\x84\xa2\x2a\x62\x8b\xb6\x8b\xf0\x7b\x78\x6b\xc7\xf8\x6d\x10\x84\x8e\xeb\xdb\xb1\x32\xfe\x45\x0d\x6c\x18\xf2\xd9\xe9\x1c\xa1\x98\x4c\xaf\xad\xf4\xbc\x2e\x8b\x26\x9d\xc8\x5a\x28\x3d\xa5\x21\x14\xf4\xfb\x11\x8e\x5b\x64\xba\xaa\xd1\xdf\xb2\xb4\xc7\x21\x8f\x4f\x2a\x0f\x2e\x7a\x46\x4e\xfe\xa4\x8e\xa0\x95\x01\x92\x46\xa5\x83\xd6\x3e\x6f\x5c\x88\xb4\xca\x48\xd3\xa7\xae\x27\xa9\xd5\x51\x2b\x37\xff\x16\x30\x1f\xc1\xfc\xc0\x3b\x3b\x75\xd3\x49\x7b\xaf\x49\xb9\x2e\x24\xae\x40\xc9\xf3\x8d\x89\x5e\xa2\x3a\xda\xdc\x44\xe2\x6b\x42\xd5\x44\x3f\x20\x7d\xa6\x4c\xb0\x59\x92\x67\xb5\x17\xbd\xa4\xca\xdd\xdf\x23\x95\xe5\xa7\xb9\x95\xd9\xd6\xd6\x43\xf6\x42\x10\xed\xb4\xd5\xa1\x6c\xab\x83\x43\xab\xe5\xee\x34\x2a\xb0\x95\x89\x7d\x2b\x03\xf7\x29\x9b\x55\xd2\x83\xa5\x6e\x3d\x49\x0f\x96\xe2\xc1\x49\x0d\x83\xe2\xcb\x77\x3c\x15\x7f\xce\x38\xd7\x3d\x68\x15\x9d\x3a\xac\xf5\x80\x89\xf9\x52\x99\x93\x3e\x4f\xe6\x3f\x9f\xd6\xc8\x58\xec\x42\x69\xe8\x6d\xf4\x2f\xa5\x33\xa4\xe6\x29\x18\xd5\xa2\xbd\xe5\xd6\xdf\x96\xfb\x6e\xe1\xa1\x4d\xb3\x97\x1f\xdb\x97\xeb\x1a\xdc\xac\x56\x4b\x8c\x6e\x56\x15\xc9\xaf\x54\x6e\xae\xad\x0e\xe3\x5d\x3b\xfd\x15\x38\xf1\xa6\x35\x40\x72\xf0\xad\x62\x6d\x5a\xb2\xe9\xd0\x4a\xd9\xd7\x74\x36\x66\xc8\x9e\xe7\x0d\xe1\x4d\xb0\x6a\x4d\xa1\x73\x58\x6e\x21\x45\x27\x3c\x58\xcc\x60\xde\xdc\xa4\x3f\x98\x27\x7f\xfa\x59\x8a\x7b\x9e\xc6\x0e\xa5\x9b\x12\xcc\x94\xb5\xd8\x72\xa4\xc5\x97\x25\x6b\x82\x12\x4d\x70\x12\x52\x70\xa2\xdf\x7f\x85\x70\xa2\xa1\xed\x5f\xe1\x7c\x30\xd1\xfa\x82\x30\x6e\x69\xfa\xab\xc0\x12\x65\xa4\x1e\x91\x44\x17\x02\xfa\x5c\x0b\xa6\x66\x26\xde\xd7\x42\xb0\xa1\x4b\x61\x6a\xee\xae\x11\x53\x53\x8f\xc0\xbe\x10\x6e\xe8\xf2\x98\x9a\x7b\x6b\xc4\xd4\xdc\x5b\x15\xa6\xe6\xde\x0a\x30\x35\x9f\x5d\x3a\xbb\x97\x60\xa5\xe5\xe3\x69\x3e\x5b\x10\xf0\x76\x7f\x4e\x10\xc0\xc5\x20\x32\xd7\x0d\xfd\xf8\x79\x40\x32\x93\xdd\xa2\x33\x3c\xc9\x57\x1d\xfb\x2f\x28\x58\xe2\x23\x56\xe2\x23\x56\xe2\x23\x56\xe2\x4a\xb1\x12\x15\xa8\xc4\x54\xb3\x71\x84\x44\xb6\x59\x26\x21\x20\x4a\x98\x88\xfa\x16\x4f\xb2\xde\xa5\x80\xfc\x65\xcc\xb7\x3c\x88\xb7\x34\x0c\x1c\x00\xbe\xf1\xc5\x3a\x00\x23\xb2\x31\x03\x34\x25\x74\xbf\xa0\xfb\xc7\x23\x3e\xe2\x23\x3e\xe2\x23\x3e\xe2\x57\x87\x8f\xf8\x26\x1c\x47\x83\x14\x10\x22\xd1\x4a\xf0\xbe\xcc\x16\x8a\xce\xe6\x29\x83\x7f\x38\x37\xfc\x21\x70\x54\x00\x7d\x08\xdf\x0d\x05\x95\x4a\x8f\x67\x08\x09\x4d\x05\x0f\xb1\x2c\x62\x20\x64\x2d\x03\x13\x48\xcb\xa0\x10\x81\x2c\x33\xe5\x8c\x97\x2b\xa3\xe2\xbd\x0b\xed\x2b\xa5\x11\xb0\x74\xa4\xd1\x67\x88\x86\x35\x0f\xdb\x37\xf8\xcc\x1d\xe2\x50\xde\xef\xea\x79\xd8\x0e\xc9\xdb\x60\x1c\x67\x13\x26\xdb\x4c\xe9\x4f\xa8\xa3\xbf\x39\x95\x94\xc7\x2f\x49\x9d\x85\xf6\x0d\xf6\x3c\x1c\xfe\x14\xdc\xb8\xfe\x95\x5c\xb8\x5c\x09\x39\x19\x36\xb0\x16\x45\x4b\xa1\x7b\xea\xb9\x0e\x2e\xa6\x09\x49\x48\xeb\xc8\xf4\x36\xd8\x46\x71\xa6\x19\xcf\x82\x71\x6f\x40\x4a\x2f\x6a\x4b\x5c\xeb\x0d\x6c\xff\x0a\x3b\x90\x1a\x13\x3d\x45\x35\xcd\xe6\x26\x4a\x7f\xe3\x77\x99\x5f\xa2\x7a\x1e\x87\x94\xb9\x54\x3e\x79\x2f\x3a\x9f\x5d\x92\xb5\x3c\xd6\x62\xb2\x6b\x9b\xee\x10\xc9\x3d\x87\xa7\x90\x9a\x56\x86\x92\x94\xae\x25\x6a\xf8\x01\x0f\xb2\x5f\x43\x7b\x34\x02\xe9\xd0\x31\x35\x53\x38\x60\x23\xad\x7c\x2f\x2b\xe2\x18\xe1\x58\x95\x63\xa5\x99\x2c\xd4\xa8\xd7\xeb\x25\x9a\x15\x3c\xea\xa0\xd4\xa3\x50\x70\xb7\x40\x23\xe3\x49\xcc\x1d\x98\x88\xf6\x2e\xdb\x80\xab\x2d\xb9\x6c\xdf\x89\x81\x92\xc5\xd5\xc4\xea\x5d\x52\x7c\x83\x7d\x92\x20\x33\x0e\x0a\xe4\xff\x55\xe6\xcb\x79\xfd\x02\xb5\x50\x72\x58\xb7\x3a\x69\xe5\x21\xe4\xe8\xbf\x88\x7d\xc2\x50\xaf\xdf\x5a\x94\xfd\xda\xc8\xbe\xc2\xbf\x15\x36\x4b\xcc\x4b\x15\x8d\xf2\x2f\x68\xa8\x30\x92\x0e\xc7\x22\x46\x54\xab\xc6\x44\xc6\x5a\xd7\xf5\x1d\x0e\x1d\x5a\xa5\x79\xaa\xe2\x12\x1c\xf6\x9d\x39\x29\x90\x1c\x55\x53\xc3\x33\x07\x86\x4d\x70\x3b\x29\x96\x0d\x7f\x4a\xba\x83\xa6\x1f\x8f\x1c\x3b\xc6\xa7\x70\xa6\xc5\xa6\xbd\x16\xba\x63\x47\x68\xf2\xd5\x65\x3d\xd4\x29\x9b\x4f\x3f\x33\xcc\xe9\x0c\x88\xbe\x72\xe0\x17\x99\x3b\xcc\xb7\xae\x13\x0f\x92\xcf\xf0\x28\x7f\x4f\x70\xf8\x6a\x0a\xf8\x9e\x10\x93\x5f\x55\x02\xea\x7b\x39\x07\x6d\x74\x19\x85\x95\xbf\x51\xaf\x31\x4b\x28\xab\xc0\x3a\x31\x87\xf9\x8d\xe6\xe4\x93\xa0\x46\x3e\xf3\x07\xb8\x2b\x99\xca\x9e\x79\xa3\xb9\x10\xad\x8e\xc1\x8c\x88\x24\x3d\xa2\x9b\x9b\x13\xea\xb4\x2d\x09\x43\xf4\x97\xc2\xf0\x04\x3e\x4c\xd4\x97\xa9\x56\x24\x29\xd4\x57\x59\x2e\xc1\x7d\x0b\x76\xf5\x8d\x73\x89\xba\xa5\x14\xb5\x85\xd2\x5c\x6d\xe7\x96\x7a\x21\xd9\x3a\x49\x11\xe0\x53\x22\x84\x4a\x75\x1a\xd3\xb9\x33\x69\x11\x1a\x18\x3e\x1e\x3d\x3c\xa6\xc9\x24\xc0\x06\xf9\xa4\x3e\x4f\x0b\x26\xaa\x26\xe1\x43\x6a\xf1\x48\x38\x00\x99\xa9\x53\xf3\xbc\x1c\xd8\x77\x68\x7a\x85\x0f\xf6\x6b\x03\xe9\x81\x07\x94\xc1\xfa\xb3\x3f\x0c\xc6\x7e\x5c\x66\x5c\xb3\xa4\xd2\xec\x95\xf0\x94\x32\x23\x35\x2d\x4f\x3f\x4b\x23\xa3\xac\x31\x9b\x6f\xcb\xce\x32\x65\x73\xea\x7f\x85\x69\x23\x1f\xfa\x27\x44\xf0\xf2\xf1\x88\xe5\x54\x06\x08\xa9\x85\x26\xaa\x1e\xa3\xc0\xe7\xf0\x8d\x6f\xca\x49\x5f\x23\x36\x0b\xd7\xe5\x97\x18\x6c\x3d\x92\x71\x1b\x35\x44\x8b\xdc\x0e\x5c\x0f\x13\xe9\x73\xb8\x1b\x0c\x7a\x89\x1a\xe9\x13\xed\xa1\xeb\x38\x09\x3a\x70\xdf\x0b\x82\xd0\xa0\xc0\x4f\x68\x8b\x10\x36\xd1\x0e\x6a\xa6\x91\x47\x80\xbb\x73\x9a\xf5\x02\xbd\x44\x29\xf4\x34\xca\x0f\xfd\x2c\xc9\x73\x1a\x7b\x16\x89\xda\x64\x92\xa6\xd7\x0e\x6c\xbc\x4c\xd0\x4b\xd6\x34\xe7\xd8\x77\x2e\x88\xf9\xe0\x3b\x88\x9d\xfb\xe6\xc2\x62\xf0\x76\x9f\xd1\x2d\xe0\x90\x9d\x42\x1d\x86\xb1\xc5\x5c\x7f\xe9\x60\xfa\x2d\x3d\x8e\xf8\x57\xf2\x5b\x99\x76\x86\xe0\x68\x2a\x40\x97\x59\x6e\xc8\xa3\x60\x34\x0f\xed\x89\x48\x67\x4f\x0a\xd2\xb9\x3e\xf7\x44\xe6\x97\xcc\x15\x71\x4a\x8f\x10\x8b\xe4\x48\x97\x34\x2f\x05\x7b\x92\x41\x94\x90\xc0\x83\x85\x76\x69\x09\xee\x14\xe7\x49\xfe\x8d\x95\xcb\x7b\xb5\xa8\xa7\x88\x8d\x7a\xd4\x3f\x73\x7b\xd7\xf9\xdd\x95\xa4\x31\x52\xd8\x7d\x65\xa0\xbd\x95\xf9\xbe\x99\x99\xf0\x63\xb7\x77\xfd\x63\x10\x0e\xed\x38\x06\x05\xc0\xd3\x29\xef\xd3\xf4\x98\xd7\xba\x44\x12\xc2\xe3\x4a\x5c\xc5\x78\x12\x97\xd9\xf4\xd0\x9d\x25\xcd\x70\xa8\x74\x12\x3c\x42\x29\x72\x2c\x6d\x99\xf2\x70\x20\xb3\xe0\xa6\x95\xfa\x9b\xe8\x95\xda\x50\x06\xa9\x1f\xb1\x12\xc9\xdf\xdc\xfe\x4d\x2d\x29\x72\x7a\x38\xbb\x42\x57\xfb\x97\x5b\xb3\x89\x69\x2b\x77\x47\xca\xb0\x27\xdd\x42\x57\x8c\xa9\x0f\x56\x66\x0e\x95\x92\xe6\x8e\x74\xfa\x9d\x8e\xf5\xb4\xc8\xe5\x83\x40\xcb\x60\xcd\x93\x7c\xeb\x72\x37\x6b\x5e\xe6\x98\x91\xbb\x05\x76\x64\xa4\xdc\x59\xe0\xb0\xd3\xe2\x65\xaa\x56\xe9\x84\xfc\x95\x8a\xde\xf9\x16\xd6\x68\x52\x32\xfe\x4a\x91\x71\xee\x1c\x85\xe9\x32\x8a\x4c\x3b\x6a\x9b\x2b\xb3\x35\x4d\x9d\xda\x01\xe1\x24\x84\xda\x84\x17\x16\x22\x26\x1b\x37\xd4\x52\x6d\xb2\x0d\x9d\x33\x23\x09\xed\x51\x9d\x79\x4a\x4b\xfc\xa1\x88\x0d\x7b\x92\xb0\xc1\x49\xd1\xdf\x8a\x92\x7e\x90\x9a\xc2\xc7\xb7\x5a\x55\x6b\xa4\xb4\xe7\x6f\x2d\x2e\x7c\x5b\xb4\x50\x45\x7f\xfe\xd6\xa2\x82\xc7\xbe\x49\xeb\x52\x75\x3d\x40\xcb\x92\x3a\x19\x2c\x65\xe9\x11\x8c\x6a\x96\x4a\x74\x3a\x49\x23\xcc\x3d\xb2\x0e\xe0\x9d\x2a\xb7\x04\x7f\x27\x4a\xc9\x42\xde\xe5\xd9\xa6\xf3\x57\xb0\x68\x79\xae\x5f\x9a\xe7\xe9\x98\xec\x52\xb9\x50\xd9\x64\x93\x1b\xae\x63\xa1\xcf\xb2\xc3\x91\xbf\xc1\x91\xdd\x6c\xb3\x8a\xb6\x3f\xd4\x0d\x8e\x21\xbc\x15\x89\x0e\x9d\x16\x72\x25\x24\xad\x2e\x59\xa3\x97\xdc\xff\x98\xd9\xc8\x84\x4e\xb9\xf6\x65\x5b\xb8\x29\x85\xce\x2a\xaf\xae\xda\x41\xd5\x36\x73\xf5\x7c\xaa\x02\x42\x39\x37\x6b\xa9\x2f\x72\xa6\x4c\xa3\x48\xd9\x32\xdf\x14\x76\x46\x21\xbe\xe1\x37\x7f\x12\x86\xce\x33\x99\x2e\xb2\xf3\x42\x3e\x40\xf8\x44\x42\xc7\x2e\x98\x17\xf6\x4a\xcf\x0b\x7b\x05\xf3\x42\x46\x8b\xef\xc9\x5a\x5c\xae\xaa\x1d\xda\x43\xd8\xcd\x4a\x2d\x2e\xe5\xb9\x51\x59\x43\x8a\x49\x91\xdb\x76\x79\xf3\x41\xaa\x6b\xd6\x34\x1f\x88\xbe\x5a\x89\xbe\xd7\x50\xe3\x6c\xd3\x96\xd2\x08\x01\x43\x8d\xa6\x02\xb3\xa5\xfa\xd6\x17\x4e\x0f\x94\xa2\x99\xa3\x1c\x0c\x31\x54\x20\x66\xa1\x95\x39\xbf\x17\xdf\xad\xac\xa8\x5b\x59\x96\xcc\x42\x0a\xd5\x54\x6f\x55\x2d\xde\x93\x24\x1f\x4f\x67\x5a\xda\x6d\x68\xda\xa7\xba\x19\xa5\x68\x4e\x91\x96\x7e\xf9\xca\x47\xda\x7a\xca\x51\x3a\x9a\xfd\xcb\x72\x88\xfe\x6c\x6d\xa0\xdf\x0a\x54\x0c\xab\x51\x6a\x7f\x25\xc7\xac\x1a\x29\x9b\x2a\xe9\xb1\xaf\xd9\x37\xe4\x23\x3f\x67\xbb\x31\x33\xee\x75\xbb\x8a\x2a\xd6\x20\xec\x27\x48\x1b\x7b\xd9\x1d\x95\x32\xeb\x12\xd9\x7f\xee\xbc\x02\x3f\xc0\x19\xbd\x72\x61\x1a\x26\xdf\xf9\x9a\xdf\x75\xd7\x30\x8d\xba\x45\x78\x34\x4d\xbe\x69\x37\x29\x1a\xdd\xc9\x66\xdc\x6a\xb6\xe2\xe4\x8d\xb8\x5d\xed\x46\x5c\xb2\xfd\x95\x59\xff\x6a\x4e\x54\x8a\xcf\xca\x0a\xa7\xef\x54\x0a\xcd\xbe\x9e\x76\x37\x2f\xb3\x97\x97\xde\xc1\xcb\x5f\x6e\x2f\x8a\x34\x3c\x1f\xb8\xf4\x44\x42\x8b\x56\x44\x7d\x2a\x7d\x98\xe6\xcf\x7e\xcf\xb2\xa3\x60\x80\xdd\xab\x41\x2c\xa5\xa0\x2f\xe4\x24\x7d\xd7\xf3\xa4\x04\xe4\x51\x1d\xcb\x61\x70\x2d\xe3\x58\xd3\x17\x73\x44\x9b\xc8\x78\x29\x67\xf0\x17\x19\x8c\x81\xb2\x61\x42\x0a\x69\xb1\xbf\x09\x3f\x14\x37\x57\xe5\x71\xd2\x42\x52\x6b\x4d\x5b\x48\x6a\x22\x68\x90\x16\x4a\xb5\x0b\x6d\x84\x16\xfb\x3b\x5b\x8f\xd2\x7e\x3d\xb6\xfd\x20\xb4\x87\x76\x61\xe7\xf3\x44\x73\xc2\xc7\x4e\x24\x70\xd6\x9c\xae\xdf\x2f\xea\xfa\xfd\x99\x5d\xbf\xaf\xe9\xfa\x59\xa8\xb4\xd2\x1d\x75\x0e\x4a\x9b\xba\x9f\x8e\x60\x6e\x77\x1c\x39\xe0\xc9\x7e\x8d\xbd\x51\x51\xb4\x07\x76\x18\xb3\x0e\x2f\xc4\x72\x6d\x4a\x28\x8d\xac\xb4\xca\x45\x2d\xf0\xbd\xa9\xb8\x68\xad\x2e\xeb\x9e\xc8\xa4\xcb\xa2\xd3\x2e\x26\xb5\x72\xbc\x32\xb9\x54\x59\x74\x97\x15\x47\x69\x61\x62\x87\x00\xaf\xc1\x9a\x33\xf9\xd0\x0b\x86\x23\xbb\x17\xa7\x17\x32\x8e\x08\x30\x59\x56\xa4\x85\x6a\x2d\x94\x69\x91\xca\x10\x53\xcc\x6f\x16\x72\x1d\x9d\x88\x3f\xcf\x15\xf1\x44\x92\x9f\xab\x92\x9c\x63\xa1\x3f\x2f\xb0\xd0\x53\xb2\xfd\x5c\x23\xdb\x29\xbd\xf5\x3c\xd1\x5b\x09\xcb\x9e\xeb\xe3\x8f\xea\x8e\xfe\x14\x6d\x71\xea\x3b\xa8\x69\xd2\x73\x82\x24\x87\xb2\x01\x2d\xb7\x86\x84\xc1\x3e\xcf\x5e\xe2\x6c\xdd\x28\xaa\xb4\x4a\x68\x61\x79\x90\xeb\x10\x6a\xc1\x9e\xdd\x8e\x53\xd2\x41\xff\xa9\xa8\x49\xb3\xbc\x3e\x34\x39\x19\x4c\xd2\x2c\xaf\x0d\x4d\xce\x77\xc1\xad\xcf\x32\xe6\x3b\x17\x9c\xbb\xce\x85\x9a\x17\xb6\x13\xe4\x20\x3c\xe5\x33\x47\xf1\xd4\xc3\x2d\x74\x87\x7a\xe3\x30\x0a\x42\x38\xc1\xf3\xb6\x43\x1c\xb9\x7f\xe2\xaa\x14\xc6\x44\x82\xef\x5d\xed\x44\x98\xd6\x27\x69\x8d\x22\x74\xca\xac\xc1\x92\x55\x2f\x7c\x36\x4d\xcf\xb1\xc9\xec\x5b\xf5\x03\x5f\xc6\xa7\x2f\x05\xb7\x5c\xa2\x96\x64\xdc\xa5\x6b\xd9\x68\x81\x31\xdb\x50\xaa\xda\x68\xd1\x31\xaa\x4c\x95\x4d\x9a\x32\xb3\x98\x55\xb3\x36\x35\x59\x19\xea\x3e\xd4\x4a\x5b\xdf\xbf\xf5\xfb\xfd\xaf\xa1\xbe\x68\x0b\x35\x97\xa8\x73\x3a\xfb\xdc\xf5\x66\x3f\x67\xc6\x59\x21\x43\xb6\x38\xca\x0a\x49\xa1\x9e\xd4\x69\x26\x8d\x17\x25\x26\x8d\x17\xea\xa4\x91\x9a\x01\x5e\xcc\x9e\x01\x5e\x7c\x1e\xcb\xb5\x40\x9f\x46\x52\x73\xa1\x25\x34\xe9\xa2\x7a\x34\xab\x45\x75\x9e\x6b\x72\xfa\x8c\xe6\x2c\xce\x90\xd5\x96\xc3\xe0\x06\x2b\xe0\xe6\xaa\x6a\x49\x1b\xf6\x3a\x73\xff\x68\x64\xf7\xdc\x78\xda\x42\xf5\x5a\x53\x31\xfa\xf5\x07\xc6\x33\x4c\x2f\x39\xa2\xef\x6f\xc9\x71\xc7\xb2\x6b\x03\xb2\xbc\x2d\xb6\xa1\xf0\x24\xd6\xae\x09\xbe\x2f\x8e\xac\xac\x9e\x3a\x7d\x5f\xf6\x78\xea\x7b\xed\x4e\xca\x54\xfa\x5e\x34\x9a\xbe\xd7\x8c\xa6\x1c\x2b\xed\xfb\xc2\xf3\x35\x65\x00\x7e\x2f\x06\xa0\xd4\x06\xb0\x23\xba\x9b\x7f\x46\xa9\x6e\x59\xef\xce\x3a\x70\xdc\xcd\x7a\x17\x50\x20\x06\xd4\x41\xcf\xe4\x82\xed\x38\x56\xfc\x10\x11\x1a\x05\x10\x7a\x8b\x46\x48\x29\x16\xd0\x64\xbf\xe0\x2b\xb7\xf3\x0a\xad\x3b\x3c\x89\xd5\xc0\x03\x2b\x61\xbf\x88\x8c\xe6\x56\xe3\x8c\x08\x0a\xda\xa0\x3b\x08\xce\xce\x5f\xfb\xbd\x01\xe8\x18\x2c\xf6\x63\xf8\xbf\x1b\x1c\x42\x04\x29\x91\x84\xba\xcd\xa4\x52\xe5\xaa\x10\xb4\x8d\xd2\xe8\x1d\x88\xe9\x13\x65\x75\x20\x7d\x7d\xb0\xa8\x44\x29\xce\x63\x7c\xc3\x5a\xf2\xc2\x90\x36\xa6\x44\xc2\x15\x59\x19\x5f\xb0\x07\x22\xe9\xd8\x70\xc1\x3e\x48\xfb\xf3\x64\x8d\x9d\xad\xb5\x75\x4a\xd6\x93\xaf\xac\x01\x34\x7f\x04\xa1\x46\xbd\x9c\xbb\x4d\xa3\x5e\x22\x48\x50\xa3\xae\x8f\x12\x94\xd9\xb8\x21\x09\xd9\xbb\xac\xf6\xdd\x2b\xab\x7d\xf7\x66\x69\xdf\x3d\xd0\xbe\xf2\x67\x79\xe3\x57\x4a\x26\xbf\x56\x93\x4b\x5b\xc1\x4a\x7a\xe9\x7d\x8a\x7e\xea\xf6\x83\x52\x88\xfa\x4d\xf5\x0e\x5e\x3a\xb8\x51\xc9\xd8\x44\xfa\xcb\xfd\x4a\x6c\x22\x50\xc8\xa9\xe0\x44\x49\x39\x6e\xc4\x36\x15\xdd\x5e\xb9\x8d\x33\x49\x45\xf0\x1d\xb4\x5a\x0f\xdc\x47\xc5\x06\x1a\x5c\x4d\x6c\x7c\xf5\xf3\x97\x7e\x9f\x22\x69\x78\xcd\x1e\xc1\x4f\x41\xca\x28\x26\x76\x6a\xf9\x5d\x08\x76\xf9\x46\x93\xe1\xe7\x51\x86\xec\x81\xef\x68\x76\x1a\xd2\x71\x7b\xf3\x53\x66\x78\x15\x6f\x75\x1b\x0b\xfa\x80\x48\xa6\x7c\x54\x92\x08\xca\xe6\xa6\x9c\x3e\xd9\x95\xd6\x92\xd3\xac\xd2\xb4\xe9\x92\x8d\x40\x9e\x36\x73\x17\x23\x27\x3d\x75\x3c\x62\xf7\x2e\x92\xb4\x86\xa2\x1f\x20\x6c\x91\xac\x00\xe0\x45\xe6\xee\x9b\x5a\x35\x6a\x58\x6b\xf4\xb5\x1a\x22\x08\x6e\x5a\x14\x87\x07\x6a\xce\x19\x1e\xe8\x0d\x1b\xb5\xba\xd0\x40\xa5\x43\xf7\xe8\x31\x4e\xa4\xd0\x3d\x1b\xdc\xf4\x5c\x82\x46\xb2\xec\x5a\x8a\x48\x61\x40\x87\xdc\xfc\x14\xad\x5b\x89\xfb\x01\xd3\xf6\xaa\x48\xb1\x85\xdd\xaa\xc8\xf1\xf5\xdf\xaa\xe8\xa9\x56\xcc\x12\x74\x09\x31\x76\x12\xb0\x58\x3f\x4a\xb1\x39\xe2\x60\xb4\x24\x27\x08\x85\x4b\xb6\x13\xa5\xd2\x0d\xe2\x38\x18\x2e\x4d\xc6\xc3\xfd\x65\x78\xd9\xa0\x9b\x7d\xe5\xa2\xf2\xe4\xd2\x2a\x15\x89\x61\xd6\x38\x5b\xa2\x25\x16\xc9\x4a\xa3\xf2\x58\x25\xe2\xc5\xe4\x92\x80\x78\x31\x54\xc9\x24\x5e\xee\x4b\xf5\x67\xe2\x10\xbf\x14\x19\xc5\xef\x7a\x21\x5a\x22\xa6\x02\x37\x9c\x16\xe3\x28\x70\x30\x0b\x38\x41\xdd\x79\x96\xe0\x25\xb9\xfd\xf6\x2d\x8a\xe8\x85\x29\x63\xfe\x6b\x62\x24\x4c\x58\x30\x81\x29\xfb\xcb\x94\x7b\x5d\xd6\xcc\x7b\x75\x9d\x5e\x7d\x66\x6d\x24\x61\x75\xfb\xfd\x7e\x55\x9e\xf6\xaa\x7f\xdb\xdf\xdf\xaf\x2a\x1a\xf4\x8e\x2a\xc1\x86\xc5\x15\x59\xc3\x12\xca\xa8\x61\x31\x85\xd2\x40\x0f\x02\xa3\x70\x55\x10\x85\x02\xfa\x40\x81\x27\xdc\xab\xd7\x8b\xe0\x09\x19\x99\x7c\x48\x42\x38\x62\x07\x83\xfc\x84\xbb\x2e\x6a\xc0\xa2\xbe\xdf\xfd\x9e\x95\xbc\x81\x9e\xa2\xb7\x90\x3e\x42\xb6\x8f\x60\x0c\xa3\xa0\x8f\x68\x3f\x45\xc8\x18\x01\x90\xfe\x0d\x46\xb6\xef\xec\x04\x21\xf2\xf1\x95\x4d\x9e\x4d\x34\x0a\x83\x2b\xc0\x0b\xf1\xaf\x50\x3f\x0c\x86\x84\xd4\x27\x18\xfb\x9f\xd0\x78\x84\xe2\xc0\x42\xdd\x71\x0c\x38\x21\xae\xdf\xf3\xc6\x70\x76\x8d\x3e\x61\xdf\xf9\x54\x43\xaf\x51\x14\xe3\x11\x29\xe9\xd3\x76\xe3\x13\x72\x23\x34\x8e\xb0\x43\x16\x64\xb6\x28\x42\x26\xe8\x46\x28\x1a\xe1\x9e\xdb\x77\xb1\x83\x6e\x69\x1c\x68\xc2\x30\x90\x43\x41\x48\x12\xe2\xd1\xa7\x1a\x3a\xec\xb3\x77\x6e\x04\x45\x8b\x5c\x16\x21\xe7\xc6\xd5\x08\x45\x38\x46\x71\x20\x48\x13\x6a\xe2\x21\x1e\x60\x5f\x24\xa8\x7f\xaa\x6d\x20\x68\xa2\xa7\x4f\x3f\x04\x31\x6e\x3d\x7d\x8a\xfe\x6d\xdf\xd8\xa7\x80\x88\x84\xfa\x81\xe7\x05\xb7\x11\xc9\x83\x0e\x0f\x0e\x0e\xb6\x9f\x3f\xdb\x23\xca\xcf\x77\xec\xd0\x01\xe4\xa8\x10\x47\x81\x47\xac\x55\x42\xa3\xef\x05\x76\xec\xfa\x57\xdb\xb0\xc3\x48\x37\x0b\x22\x74\x3b\x70\x7b\x03\xd4\xb3\x7d\xd2\x9e\xce\xb8\x87\xd1\xd8\xc7\x93\x11\xee\xc5\xd8\x21\xf9\xc7\x5e\x1c\x71\x2e\xfe\x41\xe1\x8c\xe8\x4f\xd7\xef\x61\x54\xaf\x35\x6a\x75\x78\x1e\x62\xd2\x61\x47\x7d\x74\x09\x8f\x3d\x3b\xc6\x57\x41\x38\x45\x3f\xc7\xae\x07\x6f\xc0\x51\x12\xdd\xd1\x8e\x7d\x40\xe7\x50\xe1\x4e\xfd\x02\x9d\x0d\x30\xbb\x57\x16\xf4\xa1\x2e\xf4\x2a\x9d\x2e\x13\xf6\x1d\x48\x4e\xfe\xce\x4c\x7c\x4e\x7a\xa4\xd3\xa0\x05\x50\x40\xd3\x38\x20\xa2\x10\x52\xe7\x8f\x20\x44\x0e\xe6\x0f\xdd\x29\xa5\x41\xcd\xf4\x08\xdd\x01\x66\xf9\x03\x3a\x61\xcf\xa2\x28\x49\x38\x69\x8e\x08\x63\x74\x59\x73\xe9\x8d\x2c\x0b\x5d\x52\xaf\xb8\x13\xba\x6b\xff\x14\xfd\x03\x4f\xec\xe1\xc8\xc3\xac\x09\xd9\x67\x63\x8f\x2c\x11\x9e\xa2\x9d\x1d\xd4\x79\x89\xce\xeb\x16\x19\xeb\x4d\x0b\xed\x5e\xa4\xd2\x6d\x67\x12\x6e\x37\x2c\xb4\xdd\xb4\xd0\x76\x26\x6d\xc3\x42\xcf\x94\xd4\x8c\xa6\x85\xf6\xd2\x49\xeb\x16\x6a\xd6\xd3\xc9\xc9\x0b\x0b\x35\x08\x33\xcf\x34\x19\xb6\xf7\x48\xe1\x73\xb1\xb3\x67\xa1\x7a\x9a\x23\xf2\x7f\x19\xea\x4a\xa2\x0b\xc0\xa0\x21\x9a\x24\x64\x3a\x44\xd2\x28\x80\x95\x45\xd5\x51\x8d\x69\x23\x7e\xfb\xb2\xbd\x91\x51\x66\x8d\xaf\x10\x6b\x75\x8d\xd0\xa3\xda\x32\x56\x01\xba\xba\x3c\xf4\x68\x63\x3d\xd0\xa3\x8d\x15\x40\x8f\x36\x96\x83\x1e\x6d\xae\x11\x7a\xb4\xb9\x2a\xe8\xd1\xe6\x0a\xa0\x47\x77\xd7\x08\x3d\xba\xbb\x2a\xe8\xd1\xdd\x15\x40\x8f\xee\xad\x1f\xbb\xf3\x19\x07\x1b\x3f\xfa\x69\x06\xfe\x68\x63\x6f\x61\x8c\xd3\x75\xa3\x83\x3e\x9f\x0f\x1d\x74\x51\x88\x53\x25\x16\x78\x6e\x11\xcf\x16\xec\x09\x5d\x90\x9d\xbc\x76\xda\x5d\x50\x49\xd5\xb3\xd0\xf2\x79\x45\x3c\x07\x18\xd5\x47\x14\xd5\x47\x14\xd5\x47\x14\xd5\x65\x51\x54\x33\xe0\xa9\x14\x1f\xf3\x57\xba\x7c\x93\x4a\xe3\x50\xa8\x11\x97\x01\xda\x8e\x70\x67\xab\x2d\x4b\x4f\x82\xa9\xca\x50\x56\xa3\x1a\x5c\xdb\x3f\xea\x1b\xae\x89\x5e\x76\x50\xdd\x44\x44\xeb\xba\x3e\xef\xda\x27\xa5\x06\x0c\x30\xe0\x9a\x72\x66\x36\x66\x5c\x32\x62\x82\xee\x1f\x20\x83\xd9\x81\xf2\x88\xa3\xfa\x88\xa3\xfa\x88\xa3\xfa\x75\xe1\xa8\xbe\xb5\xc3\x18\x47\xae\xed\xa3\xd7\x13\x37\x4a\x01\xaa\x52\x15\x25\x92\xb0\x08\x89\x29\x1c\xd4\x92\x30\xa8\x0a\x95\x02\x38\x54\x25\x9d\x51\x8c\x88\xaa\xa4\xe5\x37\x08\xf8\xb9\xfc\x4c\x50\x54\x25\x77\x19\x70\x54\xb5\x38\xb3\x66\x8f\x46\xde\x94\x51\x13\x66\x09\x45\x29\xcb\xc2\xd6\xa5\xea\xaf\xc0\xd7\x45\x83\x60\xec\x39\xa2\x45\x7e\x86\xdd\xea\x1c\x3f\x19\x6d\x5a\x40\x17\xa2\x73\x4f\xea\xfa\x3b\xe9\xe4\x37\x01\x0f\x30\x5a\x63\x8f\xf2\xb9\x7a\x88\x23\xb1\x9d\x9c\x3b\xe9\x50\xfa\xe7\x55\x96\xbf\x7a\x91\xdc\xd7\xd8\xd9\x61\xe6\x09\x2f\xca\x8d\x50\x14\x0c\x71\xec\x0e\x71\x84\xae\xb0\x8f\x43\x3b\xc6\x0e\xc2\x37\x38\x9c\x22\xf2\x16\x6d\x27\x59\x7b\xa4\x3b\x51\x3c\xb0\xd9\xee\xa3\xed\x79\x53\xa2\xa1\x29\x23\x08\xff\x67\x6c\x7b\x6e\x3c\x25\x44\x3d\xf7\x1a\x7b\x53\x14\x07\xa8\x6f\xbb\x5e\xc6\x4b\x28\xd7\x47\x88\xf1\x75\xe4\x49\xe0\x77\x45\xed\xc0\x12\xe6\x36\x05\x0b\x9e\xa9\x6d\x0c\x26\x7c\xb3\x43\x07\xeb\x96\x6d\x3c\x46\x7c\x34\xb0\x3d\x2f\xb8\x3d\x20\x75\xa7\x20\x3c\x9c\x5d\xa9\x2e\xb0\xb3\xbe\xea\x72\x44\x1b\x58\x4a\x73\xac\xa5\x2c\xea\x39\x25\x79\x51\x09\x47\x04\xf8\x03\xda\x8a\xfc\x7b\x8a\xde\xda\x5e\x6f\xec\xd9\x31\x86\x9d\xcd\x9e\x88\x51\x16\xa1\xa0\x8f\xb0\xef\xc0\x1e\x71\x44\xec\x1d\x88\x43\xc6\xb3\xb1\x3d\x56\x74\x47\x19\x7f\xa0\xce\x62\x67\x03\x4c\x7f\x04\x7d\x64\xa3\xc8\x1d\x8e\x3c\x0c\xf9\x44\x36\x7e\x13\x97\x67\x33\x26\x0d\x0b\x4d\x1b\x66\x0b\xf2\x26\xc5\xcb\xa5\xa3\x9e\x17\x44\xb0\x67\x4b\x48\x81\xa7\x1f\xa7\x87\x8c\x49\xd3\x42\xd3\x66\xc9\xfc\x36\xa8\x61\xc8\xba\xb3\xa1\x07\xb1\x72\x7b\xd7\xef\x5d\x9f\x06\x6b\x2b\xc0\xb1\x92\x93\x01\x8c\xd3\x7c\x48\x56\x13\x09\x73\x2a\xc7\x23\xba\x59\x74\xbd\xb2\x39\xf3\x7a\x65\x53\xe3\x32\x1d\x84\x2e\xf6\x63\x9b\xc7\x57\x66\xe9\xa4\xb7\x8a\x5f\xa2\xdb\xbb\xe6\x51\x7e\x25\x20\x2d\x35\xc0\x1c\x42\x43\x97\x58\x1c\x52\x22\xfa\x42\xf1\x78\x9e\x34\x34\x61\x58\x11\x9a\x34\xb5\xaf\xa7\xfa\xd4\x53\x7d\xea\x78\xa2\x7f\x3d\x4d\x87\x75\x65\xb8\x70\x64\xdd\xdc\xe1\x5c\xbf\x42\xdb\x0d\xd4\x52\x6f\xd4\xf5\x5d\xdf\xf6\xce\x92\xca\x83\x33\x9e\x68\x0c\x62\x08\xb2\xdf\x72\x26\xf2\x0e\x64\xa1\x54\x80\x39\xcd\x2e\x00\x0f\x24\xed\x46\x1f\xe0\x4c\x21\xc1\x07\xab\x09\xda\xc4\xce\x54\xdf\x20\x7a\xbb\xb2\x96\xc8\xbd\xa8\x6c\x74\xeb\xc6\xbd\x01\x32\xa4\xde\x55\x50\x15\xed\x08\xa3\x6a\x1c\x8c\xaa\x2d\xb9\x47\x48\xd3\x43\xb7\x64\xc8\xa6\x3a\x62\x8a\xb6\xd0\x13\xd6\x8a\x4f\x99\xec\xb5\xd3\x9d\x08\x9d\x30\x6d\x12\x43\x1c\x62\xe6\xa9\x6d\xdb\x4e\xf7\xa2\xa8\x96\xfc\xa5\x1b\x62\xfb\xba\x9d\xe2\xdb\xc3\xfd\x58\x61\x1c\x8a\x9b\xce\x60\x1c\x2a\x36\x51\x18\xbf\xa5\xa0\x0b\xa9\x16\x00\x6e\x26\xa5\xf8\x9e\xce\xc5\x37\x9c\xec\x2e\xc1\x78\x49\xbe\xb7\x56\xc7\x37\xdb\x7f\x5d\x5c\x48\xca\xca\x48\x09\x9e\xcb\xc9\x48\xfa\x46\xf5\x1d\x5c\x41\x23\x4b\x0d\xb8\xe2\x06\xd3\x4d\x0b\x4d\x1b\x16\xbd\xc4\x06\xd3\x47\x8b\x70\xf0\x60\x01\x75\x48\xd9\x42\xf1\xc4\x42\xd3\x16\x61\xef\x61\x06\xec\xa1\xdb\xbb\x3e\x13\xce\xe7\xc5\x53\x46\x92\x4e\xeb\x8b\x9d\x0f\x43\xa7\xd3\xdc\xbb\x79\x9a\x3b\xa5\x92\x77\x75\x2a\x39\x71\x97\xcf\xea\xc9\x52\xaa\x23\x33\x04\x15\x8a\x42\xbf\x32\x57\x7c\xc4\xae\x45\x2c\x30\x42\x72\xe8\x12\x6a\x48\xb8\xfa\xcf\x27\xc1\x0a\x49\x7e\x0f\xa0\xb4\x40\x25\xb9\x67\x89\xc5\x2f\xca\x95\x83\x62\xd1\x50\xd3\x6a\xc5\x23\x1f\x8d\x4a\x27\x1e\x7b\x25\xc5\x63\x4f\x27\x1e\xea\x65\x09\xd2\x4a\xb4\xf7\x96\x90\x90\xbc\xfe\xcd\x16\x35\xab\x43\xf2\x66\xaf\x0c\xa5\x05\xa4\x50\x23\x2d\x05\x64\x4b\x0a\x61\x5a\x82\x54\x8a\x33\xae\x74\x90\x25\xed\x7b\xd7\x2f\xbe\xd6\xca\x13\x7d\x13\x00\x2f\x3a\x69\x7d\x96\x27\xad\x36\xab\x99\x94\x92\xbf\x2a\x10\xea\x67\x3a\xa1\xe6\x2b\x59\x25\x58\xee\x4c\x6b\x4d\x77\x2c\x24\x45\x76\x3e\x0e\x71\xc4\xf9\x7e\x1d\xc7\xa1\xdb\x1d\x93\xc5\x13\x98\x6f\x49\xa3\x9b\xf2\x8d\x5c\xf9\xf6\x33\x97\x90\xf5\x32\xc2\x5b\xcc\x54\x81\x4a\x94\x8e\xe8\x74\xe8\x88\x22\x26\x6e\xe6\x03\x75\x44\xab\xa6\x21\xa8\x7d\x8c\x9d\x7f\xf1\x0e\xd7\x53\xdb\xdc\x14\xe6\x56\x01\x61\x92\x8c\xf7\x18\x2f\x40\xdb\x5d\x6c\x7f\x20\x73\x73\x3d\x7d\x6b\x7d\x0a\x40\xf1\x82\xbb\xa7\x1a\xb0\x01\x7e\x87\x3d\x23\xc2\x60\x0f\xe8\xf3\x8b\x54\x0f\x69\x80\xba\x6c\xc3\xf0\x7b\xa9\x99\x3a\x83\x62\x9c\xd5\x30\x54\x51\x2e\xdd\x2e\xac\x1a\x94\x97\xa7\x9a\xba\x36\x52\xe8\x0d\xbc\x55\x8a\x73\x35\xe5\x5b\x6e\xba\x46\x99\x03\xbc\xb8\x2c\x5a\x41\x52\x5f\xfd\x2d\xd2\x1e\xdf\x04\xdc\x26\xe2\xbe\x0d\xb9\xd0\x83\x14\x63\x09\x15\x5e\x98\x76\x7b\xd7\x87\x31\x1e\x16\x5f\x9a\x66\x89\x8c\x60\x44\xf7\xcc\x59\xb3\xf3\x90\x7b\xa9\x15\x21\x49\x9a\x35\xaf\x20\x60\xce\x5c\xed\xe1\x46\xbf\xd8\x9e\xeb\xf0\x06\xa1\x85\x2b\x11\xce\xa5\xd2\xe6\x6c\x6a\x19\x41\x48\xa9\x95\x36\x58\xd3\x62\x0e\x47\x86\x39\x83\x67\xfa\xd5\xd0\x96\xbb\x8a\x4a\xce\x7f\x2f\x55\xe3\xd1\x50\xfa\x5e\xaa\x7e\x38\xe6\x20\x31\xa4\xa4\x96\xd4\x71\x1b\xc4\xa9\x2a\xe5\x7d\x50\x6e\x8c\xc2\x67\xf1\x9c\x3b\xe6\x78\x73\xe5\xed\xfc\x51\x91\x86\x6d\x3f\xdd\xd6\x1e\x77\x7c\x84\x6f\xb0\xbb\x46\x7f\xc5\x01\xb2\x7b\xf1\x18\xf6\x92\x19\x09\x23\xb8\xc1\x61\xe8\x3a\xe0\x45\x6a\xc7\xe8\xd6\x8e\xd0\xc8\x8e\xc0\x8f\xd6\x67\xd2\x24\xa8\xf3\x65\x19\x4c\x63\x62\xab\xfd\x81\xd1\xc2\xce\x99\xc4\x8b\x6e\x93\x2e\x19\x89\x79\x01\x68\xa4\x14\x80\x7d\x3e\x67\xb8\x99\x7c\x50\xb4\x98\xed\xfa\x49\xc8\x62\xfc\x55\x01\xcc\xc0\x7e\x2d\x0b\x68\x03\x1b\x99\x2a\x95\xf4\xe7\x2c\x92\xfd\x7e\x3e\x92\xfd\xd8\x77\x65\x64\x35\xf2\xa8\xd4\x4c\x2c\xaa\xc9\xc4\xa1\x9e\xcd\xb0\xf5\x47\x64\x28\x02\x2c\x35\x00\xba\xa3\x3d\xdf\x62\x02\xf0\x60\x2a\xb7\x41\x95\xc5\x94\xb8\xcc\x9c\x5a\xec\xb6\x8b\xd6\x16\x72\xa6\xf4\x32\x48\x81\x48\x98\xb8\x11\x3f\x4c\xf9\x4c\x66\x9b\x5c\x7c\x6f\x1c\xc5\xc1\x90\x30\xf9\x59\x98\x70\x7b\xd7\x66\x7a\x8b\xf1\x3d\xf3\x8d\xc8\x4c\xff\xa2\x69\x48\x6f\xc9\xf6\xe5\xba\x2d\x4b\xce\x95\x2a\x13\x6e\x8c\x01\x86\x38\x11\x3b\x1d\x9a\xa7\x85\xdc\xb4\x41\x79\x99\xde\x5b\x27\x15\xa5\xa1\x76\x32\xbb\xee\x14\xec\x53\xbd\x7d\xef\xc9\xf9\xd2\x39\x6a\x5e\x6a\xa0\x22\x65\xdf\x36\x9b\x9e\x7c\x95\xe2\xa7\xf0\x5e\xc8\xf6\x80\x76\x6f\xa1\x25\xfd\xb6\x72\xd7\x93\xad\xd4\x73\x62\x4c\xa9\xbd\x9a\xd1\x2f\x02\x11\x44\x87\x04\x02\xd9\x53\x02\x6b\x25\xb5\x55\xe9\xb9\xf4\x6a\x93\x6b\xa1\x91\x3d\xf5\x02\xdb\x69\x21\x68\x5b\xc5\xae\x13\x0f\x2b\xb0\xe8\x4a\xcd\xc0\x3a\xb7\xc5\xc5\xa0\x21\xca\xce\xbb\x29\x28\x08\x3a\xdd\xc0\x84\x5c\x45\x5b\xc8\x95\xe7\xe3\x85\x07\x15\xdd\xe5\xef\xbb\x9e\x40\x76\x39\xea\xc3\x9d\x78\x16\x0f\x95\xca\x3a\x53\xbc\x62\x94\x98\xda\x59\x68\x73\x73\xc5\x76\xf5\x62\xd6\x0a\x90\x51\x1b\x47\xd1\x55\x56\x32\x2a\xb3\x15\x81\x4a\xd0\x4a\xa7\x4c\x6c\x98\x13\x93\xf1\x66\xa1\x2a\xe9\x85\x25\x4c\xd0\x19\x61\x50\xa0\xb1\x6b\xcc\x92\x67\x23\x80\x3f\x6e\x21\x03\x66\xd8\xfb\x7b\x54\xad\x9a\xa6\xc6\xf6\x9a\x2b\x5c\x4b\xe9\xf1\x51\xbd\xaa\xce\x04\xcf\xd1\x74\x89\x8a\xa2\x03\xca\x78\x43\x61\x78\x85\xf8\x21\xf9\xf8\x9a\x99\x9d\x9b\xe7\xda\x9d\x9b\xdb\x14\xc8\xe6\xac\x1d\x25\x1d\xb6\x26\x54\xfa\x9f\xd4\x1b\x42\xda\x05\x7a\x5e\x53\x3f\x14\x83\x97\x3c\xd7\x63\x97\x0c\x5c\x47\x4e\x43\x1e\x55\xdc\x0e\xf2\x66\x1e\x98\x8e\x59\x10\x73\x31\x33\xd3\x38\x4a\x1c\x3c\xcb\x09\xfc\x00\xa6\xd4\xd9\x7e\x25\x94\x80\x85\xce\xab\x54\x2a\x24\x5f\x8a\x8c\x51\x08\x29\x4a\xae\x51\xcb\x8c\xb4\xa4\xd5\x95\x45\x5f\xb6\x4c\x80\x4f\x00\x13\x21\x89\xac\xcb\x06\x67\x42\x43\xb6\xc9\x50\x2b\xfd\x51\x6e\x90\xec\x72\x88\xd4\x85\x0a\xd9\x0f\x1d\x54\x27\x63\x98\x49\x14\x7f\x7c\x22\x31\xa5\x3e\xce\x09\xc2\xb2\xca\xa1\xbf\xc2\x89\xf1\xae\x2c\xf2\xc3\x4c\x5c\x18\x55\xd7\x28\x00\x31\xb2\xc6\x11\x23\x5f\x45\xc6\x48\x36\xa9\xf5\xe0\x1c\xb0\x0a\x49\x1a\xbf\x14\x0c\x95\xee\x5e\x80\xa6\x31\x58\x11\x6f\x6d\xcf\x7b\x33\x3d\xb6\x43\xd2\xd4\x92\x48\x69\xb4\xe3\x45\xca\x8d\x8c\x2f\x93\x8a\x4f\x71\x22\x5d\xd0\x02\xb6\xd8\xa3\xce\x51\xba\xa5\x5e\xa4\x7c\xd5\xf9\x57\x89\x04\x1a\xdf\xaa\xa1\xeb\x93\xa2\xff\x69\x8f\x44\xaa\xe4\x55\xfe\xbe\x3b\x4d\x99\xb3\xeb\x0e\xc8\x73\x37\xb6\x27\xd2\xf1\x17\x45\xab\xd4\xa4\x0a\x45\x6b\x54\x9a\x8a\xad\x50\xa5\x21\xfa\x24\x16\x03\x50\x51\x07\xfc\x85\x66\x10\x9e\x5f\x68\x07\xfb\x0a\x1d\x30\x78\xb5\xcd\xc4\x71\x71\x6e\x93\xcf\x67\x74\x4f\x23\x46\xd4\xd4\x54\x25\xb3\x26\xa7\x5c\x1c\xb2\xf2\xa5\xcd\x8c\x12\xa6\xe7\x22\xf5\x7b\x95\xf4\x79\x0b\xd5\xf5\x5a\x34\x91\x8a\x4e\x07\x55\x47\x64\x59\x18\xb2\x10\x23\x07\xbe\x53\x2d\x53\x2d\xa8\x08\x0d\xd3\x74\x97\x1e\x05\x4c\xaf\x5b\x69\x9c\x04\x55\xa2\xf8\x90\x68\x21\xe1\xb8\x27\x09\x71\x4b\x7e\xb0\xa4\xb1\xd1\x92\x7e\x5b\x20\x8b\x2d\xf8\xaf\xbc\x60\x8a\x43\x7d\xe0\x99\x82\x7a\x7f\xeb\x95\xce\xdd\x3d\xd4\x57\xe2\xc0\x77\x0c\x75\x43\xf6\x8b\x56\xa0\x00\x06\x55\x3f\x84\xf2\xb5\x77\xc1\x78\x4b\x06\xc9\x5d\x76\x87\x35\xaa\xd1\xc5\xdc\x8c\xcd\x0d\x96\xc3\x45\xdf\x49\xe2\xb4\x85\x1a\x14\xf8\xac\x9e\x0e\x59\x92\xef\x53\x10\x15\x85\x44\x53\x65\xed\x32\xc4\xfd\x26\xc4\x0e\x02\x79\x3d\xf0\x9d\xec\xbc\x14\x31\xe7\xe5\x66\x76\xea\xc9\x6c\x42\x8a\x64\x5a\xf5\xae\x3a\x43\x37\x75\x33\x55\xea\xe0\x17\x92\xe5\x3a\x29\x48\x93\x1a\x4d\xa9\x9f\xd4\xf8\xce\x27\x24\xa1\xb3\x4a\x52\x43\xf0\x0d\xa4\x7c\x64\xcf\xb7\xf9\x07\xed\xf9\x36\xff\x98\xbf\x1a\xe1\x29\xb8\x5f\x93\x54\x6c\xe4\xfe\x89\x69\x5c\xd1\xb9\x4f\x58\xd1\x2b\x54\x85\x32\xc1\xaf\x80\xd2\xae\xca\x55\xa2\x48\x0c\xa8\x83\x0c\x31\x5f\x9e\x5f\x98\xb5\xc8\x73\x7b\x58\xdd\x2e\x25\x8d\xc1\x7c\x18\xa1\x91\x5e\x95\x09\x15\x94\xbe\x8c\x7a\x5e\xe9\xf1\x6d\xc0\x53\x00\x5b\x01\x8a\x30\x77\x10\xa2\xe6\x39\xab\xeb\x05\x99\x35\xe4\xd2\x59\x30\x64\xe0\x56\x17\x0d\x99\xfa\x61\x92\x54\x2f\x3b\xa8\x59\x86\x39\xfd\xac\x36\x00\xf6\x86\x76\x3c\x38\x05\xff\x31\xe6\x69\x3d\xf6\xe2\xf3\xc6\x85\xe4\x9c\x86\xb6\x19\x33\xe7\x75\xf9\xb5\x49\xdd\x3f\x65\xce\x58\x64\xe3\xac\x4f\x29\x0d\x8e\xac\x39\xcd\xa3\x95\xe9\x74\xd4\x18\xcd\x9c\x90\x90\x06\xd2\xcd\xac\x6f\x5f\xa1\x09\x6a\xa1\x69\x72\xa8\x4b\x69\xe7\x25\xe5\x31\x95\xe4\x53\xd7\xdc\x63\xb2\x59\xe5\x16\x11\x9b\xc5\x88\xc4\xb3\x62\x19\x68\x75\x0c\xdc\x41\x38\x0b\xe1\x56\xc1\xd5\xd8\x0e\x6d\x3f\xc6\xd4\xcd\x3c\xb6\x5d\x8f\xbc\xed\x62\xc4\x30\xec\xb0\xa3\x6e\xb3\x92\x04\x6c\x81\x78\xce\xc2\x63\x5f\xb4\x33\x49\xde\x06\x7e\x3c\x2b\x7c\xcb\x92\xdb\x42\xa4\x98\x64\x57\x28\x79\xca\x32\xc3\xc6\xda\x6a\x07\x99\x54\x4b\x69\xac\x6d\x89\xc1\x9d\x65\x83\xaa\x4c\xe6\x4c\x49\xd9\x97\x46\x81\x70\xb3\x14\x1c\xef\xa0\x26\x0d\x87\x2a\x85\x72\x63\x23\x85\x37\x3c\xe9\x09\xda\x21\xea\x19\x91\xed\x7a\xea\x4e\xb2\xd8\x60\x6e\x09\x56\xd8\x6a\x3e\xc5\xc6\xb6\xf8\xfe\x94\x32\xd4\x4a\x27\xd1\x6f\x3e\x53\xf8\xd1\x33\xc2\xfb\x20\xb8\x4d\xd7\x33\xd9\xcd\xdf\xce\xa9\x26\x8c\x0d\x7a\x3f\x13\xee\xa8\xe9\x73\x17\x35\x12\xec\x1a\xa4\x82\xaa\x27\x1c\xe9\xa2\xa9\xe7\xb1\x66\x28\xd4\xb7\xa4\x29\xcf\x94\x3d\xc9\xb2\x7d\xa1\xeb\x04\xb2\xbe\x18\x04\xb7\xfc\x36\x9c\x2e\x2c\x9f\x12\xfc\x28\x18\xfb\x74\x31\x26\xc6\x2d\x7a\xc5\xe3\xd0\xa3\x16\xf9\xc5\x29\xe8\xae\x4c\x43\x76\x7e\x57\x5a\xe9\x1c\xb0\x7d\x84\xe2\x3f\x77\x53\x83\xb6\xb7\xfe\x01\x9b\xbf\x8f\xab\xb2\x12\xad\x63\xb8\xf6\x0a\x87\xaa\x2a\x34\xd4\xf2\x53\x25\x86\x30\x76\xa5\x0c\x60\xca\xbf\x32\x74\xd8\xa7\x28\x2d\xd6\x1a\xa9\x81\x4b\xc3\xbc\x4f\x14\xb9\x61\x46\x6a\x0a\x44\x3b\x19\xbf\x84\x8b\x1f\x60\xec\x6a\x38\xb8\x92\x07\x6e\xfa\xbb\x7c\x14\x20\xcb\x61\x7a\x9e\x9a\x83\x49\x99\xb1\x0c\x3b\xaa\xb0\xa7\x54\x45\x4a\x4d\xd0\xcc\x9a\xc1\x98\x69\xcc\x8c\x8e\x48\x67\xdd\xd2\x64\xcd\x57\x10\x59\xe5\xc0\xa7\xe9\x5c\xba\x46\x54\x56\x37\xb8\x19\xad\x20\x1a\xae\xbc\x5a\x60\x2b\x14\x66\xb1\xe9\x17\x35\x9a\x15\x0d\x65\x9f\x16\x33\xc7\x2a\xe6\x20\x37\x66\xa1\xbc\xd4\x24\x56\xfd\x6e\xfe\xa2\x65\xb7\xdc\xa2\x65\xb7\xec\xa2\x65\xb7\xdc\xa2\xa5\xc0\xf1\x3e\xb5\x68\xd9\x9d\xbd\x68\xd9\xfd\x2b\x2c\x5a\xbe\xec\x52\xa4\xfc\x92\xe9\x71\xd1\xf2\x57\x59\xb4\x28\x56\x0d\xb3\x7b\x88\x6d\xf3\x92\xda\x38\xdb\xdb\x8f\x86\xcd\x72\x86\x0d\x6b\xd3\xb9\xcd\x9b\xbc\x69\x75\xe5\xc6\xcd\xcb\x47\xe3\x66\x7d\xc6\x0d\x1d\x90\xb9\x0c\xfd\x97\x98\x36\x2a\xa2\xbf\xb2\x63\x5e\x8c\xec\xdf\x28\x46\xf6\x4f\x03\xfb\x2b\x94\x05\xc0\xbf\x82\xef\xaf\x34\xd1\xbc\x27\x54\x74\xd4\x1f\x9f\x1c\x9c\x1e\x7c\x38\x7b\x7d\x76\x78\xf4\xe1\xf2\xf5\xd9\xd9\xc9\xe1\x9b\x9f\xcf\x0e\x4e\xe1\x2c\x79\x6e\x92\xf4\x04\xf6\xe0\x97\x83\x0f\x67\x19\x5a\xa5\x63\x11\xe8\x41\x0f\xcb\x87\x00\xc8\xcd\x9f\x40\x72\x17\x02\xab\x97\xc8\x3f\x13\xec\xbf\x04\x8d\xd9\x08\xff\x25\x88\x28\xa7\x29\x0b\x50\x02\x20\x6e\xe3\x1c\x6c\x3d\x4b\x58\x76\x16\xbb\xad\x62\xf1\x0b\x29\x14\x9a\x7d\x67\x87\x62\xe9\x32\xeb\x39\xe8\xa3\xe8\xe6\x6a\x03\x25\x87\x3c\x8b\xf4\xa9\x14\x0e\x60\xd9\x5e\x5d\xbe\x5f\x57\xd3\xb3\x2b\xe8\xdb\x0d\xee\xfd\x4f\xef\x26\x2f\xda\xb3\xb3\x20\xd6\x73\x73\x77\x83\xc0\x2b\x1a\xfe\xb9\x19\x01\x1e\x7e\x21\x7e\xc1\x70\x59\x28\x2b\xa6\x5e\x34\x54\x48\xb9\x17\xca\xb7\xd4\x68\xb4\xee\x17\xa2\xc3\xbf\x65\xfe\xe9\xbd\xb5\x85\xb8\x87\xf2\x37\x36\x90\x72\x12\xbc\xd4\x48\x64\x47\xd5\x0b\xd0\x10\xd1\x24\x38\xee\xc7\x92\x9c\xcc\x8e\x7c\x53\x62\xda\x2b\x1d\x49\xa2\x78\x78\x6e\xa4\x5d\x27\x97\x22\xc5\xcf\xb5\xbf\x80\xc0\xce\x0e\x38\x32\x73\xe2\x53\xdd\x3a\xac\xc4\xcf\x03\xb6\xaa\x34\xee\x2e\x17\xe6\x85\xb9\xf1\x20\x19\x6d\x8b\x45\x8f\x80\x07\x31\x71\xde\xd1\x3c\x34\x47\x92\x3e\x49\x4d\xfd\xec\xd8\x04\x2c\x6f\xc8\x04\x7d\x0e\x6f\xa4\x98\x02\x62\x26\x4f\x72\xf1\xdb\x5e\x6c\x4c\x9c\x5f\xc0\x50\xcb\x86\xa6\x48\x14\x10\x0f\xeb\x9f\xa8\x54\xfe\x86\xce\x4a\xfc\x89\x0f\x79\x8a\xdb\x97\x1e\xc0\xcf\x24\x1e\xe8\x6a\x3e\x08\xf9\xd6\x54\xd0\xe7\x38\x51\xc9\x30\xdb\x57\x85\x4a\xe9\x90\x24\x0a\x06\x05\x7b\x5f\x30\xf6\x45\x06\xe4\x2e\x05\x1b\xdf\x5c\x2a\x06\x86\x0a\x15\xcf\x30\x49\xc1\xf2\x2f\xc0\x3e\x97\x52\x35\x49\x32\x68\x80\x60\xc4\x42\x38\xbd\x63\xbb\x05\x34\x81\x9a\xfc\x5d\x30\xcc\xc3\x8e\xfe\x5e\xa4\x84\x90\xc8\x51\x1e\x74\xf2\x0b\x91\xee\x9d\x1d\x0d\xba\x81\x4d\x6f\xc6\xe8\x92\x52\x80\x62\x35\x6d\x11\xc3\x22\x91\xd9\x56\xe1\x31\x75\xa9\x19\xb6\x2a\x5b\x59\x05\xdd\x3f\xc8\x62\x35\xe8\xfe\x51\xbb\xbc\xc4\xd1\x4f\xd0\xfe\xe8\x15\xbc\x27\x43\x86\x83\x36\xc0\x8b\x07\x8a\xc7\x08\x62\x36\xc4\xb0\xd1\x13\x03\x2c\x19\x2b\xbe\x46\xbe\xbd\x0d\x46\x53\x30\x68\x51\xb3\xde\x78\x0e\x12\x79\x15\x6c\xe3\x78\x80\x43\x3c\x1e\xa2\xd7\xe3\x78\x10\x84\x11\xa5\xe2\x46\xa8\xef\x7a\x18\xb9\x11\x1a\x49\xc1\x29\xe4\xf4\x9e\xdb\x0d\xed\x70\x4a\x48\xb3\x92\x75\x9f\x09\x85\x7e\x88\x31\x8a\x82\x7e\x7c\x6b\x87\xb8\x85\xa6\xc1\x18\x42\x6e\x84\xd8\x71\x23\x76\xb3\x0a\xb9\x31\x8f\x71\x32\x0c\x1c\xb7\x3f\x25\x24\xdd\x18\x8d\x93\xeb\x9a\x38\x1c\x46\x9c\x8f\x7f\x7e\xf8\x19\xbd\xc7\x51\x84\x43\x44\xd5\xb8\x87\x8e\xc7\x5d\xcf\xed\xa1\xf7\x6e\x0f\xfb\x11\x46\x76\x84\x46\xe4\x4d\x34\xc0\x0e\xea\x02\x39\x92\xf1\x47\xc2\xca\x29\x63\x05\xfd\x18\x8c\x7d\x87\xf9\x5f\x31\x9c\xd0\x1b\x1c\x02\x76\xe8\x2e\x2f\x8a\x11\xb4\x50\x10\x12\x22\x86\x1d\x93\x0a\x84\xec\xfa\xae\x89\x6c\x7f\x8a\x3c\x3b\x4e\xb2\x96\x68\x90\xa4\xde\x70\x59\x94\x14\x33\x08\x46\x98\xa2\x16\xba\x31\xba\x75\x3d\x0f\x75\x31\x1a\x47\xb8\x3f\xf6\x2c\x42\xad\x3b\x8e\xd1\xaf\x87\x67\xff\x3a\xfa\xf9\x0c\xbd\xfe\xf0\x11\xfd\xfa\xfa\xe4\xe4\xf5\x87\xb3\x8f\x6d\x11\x8f\x05\xdf\x60\x4a\xca\x1d\x8e\x3c\x08\xd4\x42\x66\x71\x3f\x9e\xa2\xa0\x4f\x28\xfc\x74\x70\xf2\xf6\x5f\xaf\x3f\x9c\xbd\x7e\x73\xf8\xfe\xf0\xec\x23\xd1\x43\x3f\x1e\x9e\x7d\x38\x38\x3d\x45\x3f\x1e\x9d\xa0\xd7\xe8\xf8\xf5\xc9\xd9\xe1\xdb\x9f\xdf\xbf\x3e\x41\xc7\x3f\x9f\x1c\x1f\x9d\x1e\xd4\xd0\x29\x75\x5e\x20\xf9\x67\xb7\x79\x1f\x7a\x2f\xc4\xc8\xc1\xb1\xed\x7a\x11\x6f\x89\x8f\xc1\x98\xa1\x4c\xa2\x81\x7d\x83\x51\x88\x7b\xd8\xbd\xc1\x0e\xb2\x51\x2f\x18\x4d\x4b\x77\x2a\xa1\x65\x7b\x81\x7f\x45\xa3\xc6\xe4\x09\x24\x3a\xec\x23\x3f\x88\x2d\x14\x61\x8c\x7e\x18\xc4\xf1\xa8\xb5\xb3\x73\x7b\x7b\x5b\xbb\xf2\xc7\xb5\x20\xbc\xda\xf1\x28\xb9\x68\xe7\x65\x8d\x0e\xe6\x18\x46\x4d\x07\x19\x75\x8b\x2b\x0b\xe6\xa2\xfe\xd3\xd8\x85\x21\x65\xb2\x45\xda\xc8\xf6\x70\x1c\xe3\x96\x7c\x43\x7b\x3a\x22\x33\x88\x63\x87\xd7\x55\xb6\x4d\x02\xc7\xf7\x3b\x3b\x88\x62\x16\xd2\xf8\x29\xb7\x83\xc0\x53\x46\x24\x14\xc6\x75\x58\x6d\x30\x75\x42\x3b\xc6\x26\x53\x72\x22\x2e\x93\xce\x55\x9e\xb3\xc8\x99\x3b\x0e\x83\x1b\xd7\xe1\xab\xaf\x3b\x5a\x9d\x16\xab\x15\x73\x51\x2f\x26\x2b\x69\x33\x9e\xc2\xa2\x60\xbb\x1b\xa6\x85\x9c\xa0\x07\x50\xa4\xb5\x2b\x1c\xb3\x1c\x6f\xa6\x87\x8e\x51\x15\xb5\xa9\x9a\x9a\x79\x64\x77\x85\xf3\xc8\xce\xd3\xa7\xe8\x1f\xac\xdf\x10\xec\xba\xa0\x9b\xc6\x7e\xad\x51\x6b\x6c\xc0\xad\x6e\x9b\x82\x4c\x3b\x63\x28\xa5\x36\x74\xfd\xda\x1f\x11\x8b\xb3\x92\xe8\x3d\xa3\x67\x12\xdd\xb7\xbb\x3d\xa2\xb7\x3b\x2d\xf4\xa3\xdd\xc3\xdd\x20\xb8\xb6\xd0\xa1\xdf\xe3\x91\x7e\x40\xfd\x31\x7c\xf8\x5e\xe0\x60\x8a\x15\x0a\x65\x3b\x92\x46\xfa\xe9\xf0\x8c\xbf\x46\x7d\xa2\x49\xd8\x58\x26\x24\xde\x1f\xbe\x3d\xf8\x70\x7a\xc0\x94\x28\x1d\x97\x61\x10\xc4\xc8\x71\x43\xdc\x8b\x83\x90\x49\x7d\x52\x50\x1c\x62\x88\xe4\x43\x63\xbf\x0c\x3b\xba\xf9\xe7\xc5\xbe\x69\xf9\xda\x2f\x8d\x46\xc3\xb4\x46\xda\x4f\x7b\x64\x1e\x14\x73\xcf\x7f\x0c\xdb\xbc\xeb\x07\x21\x9c\x03\x74\x3b\x69\x88\xfc\xed\x86\x85\x3b\x95\x9f\x5c\x9f\xc6\x7a\xa2\x2d\x8d\x01\xb0\xe3\x6f\x95\x2d\x7b\xab\xd2\x46\x37\x6e\xe4\xc6\x88\x0d\xab\x3e\x6b\xbf\xda\x95\x1b\x0f\xc6\xdd\x9a\x1b\xec\x40\x67\xec\x38\x41\x2f\xda\x81\x8c\xdb\x0e\x26\x8d\x18\xd6\x06\xf1\xd0\x7b\xe5\xfa\x37\x76\xe8\xda\x7e\xfc\xfb\x64\xd7\xa9\x6c\xd9\x96\xd3\xa9\xb7\x9d\x1f\xba\x6d\x67\x6b\xcb\xc4\x5b\x9d\xca\xef\x93\xe6\xbe\x1d\x5e\x45\xe7\x17\x34\x05\xf6\x49\xee\x9f\x4f\x0e\xc5\xa6\xa1\x91\x20\xf6\x3b\x5b\x8d\x0b\xb3\xdd\xed\x50\x04\x68\xbc\x55\x11\x53\x5f\x7f\xec\x79\x68\x88\xa3\xc8\xbe\x22\x26\x23\x51\xa5\xf0\xde\x0f\xfc\xed\x21\xaf\x9e\x83\x6f\x10\xf6\x6f\xdc\x30\xf0\x21\x0e\x12\xc9\x0c\x19\x81\xf1\x88\xcc\x48\xc8\x76\x1c\x97\xb4\x9c\xed\xa1\x01\xf6\x46\xfd\xb1\x47\x14\xab\xef\xfa\x57\x51\xad\x62\xb6\xbb\x35\xdf\x1e\xe2\x4e\xe5\x90\xd7\x0b\xfd\xe2\x06\x1e\xcc\x29\x95\x76\xb7\xd6\x0f\xed\x21\x8e\xce\x82\xe3\x60\xd4\x69\xb4\x29\x6c\x75\xb7\xfd\x40\xe3\xfb\x74\xee\xdc\xe8\xa7\x60\xec\xc7\xd8\x69\x89\x01\x62\xde\x51\x03\xe0\x49\xe3\xc1\xc2\xfe\x7f\xc6\x78\x8c\x7f\x0c\xc2\x1e\xa6\xb8\xbc\x72\x3a\xf1\xfd\x04\x8f\x3c\xbb\x47\x8c\xf4\x9c\x04\xa7\x38\xce\x7e\x7c\x68\x0b\xa1\x88\x0d\xdb\xea\x5a\xd8\xbc\x4b\xae\x87\x74\xec\x36\x3c\xc0\x19\xc8\x24\xee\x74\xdb\xec\xd6\x4a\x3f\xea\xf8\xf4\x37\x8d\x81\x17\x76\xf0\xfd\x7d\xf8\x20\x63\xbc\xbb\x91\x8a\x73\xd0\xb9\x7b\x68\xcb\xdf\x23\xc6\x4e\x47\xb0\x63\x5b\x5d\xf3\x8e\x03\x8f\x3f\xe9\x74\x18\x1c\xb7\xbd\xb9\x99\xc0\x81\x2b\xaf\x89\x6e\x7a\xd2\xb1\x5f\xfd\xc7\xa8\xbc\x78\x56\x31\x5b\xec\xac\x4f\xe6\xab\x96\xaa\x3c\xc5\x55\x26\x15\xad\x70\x06\x2a\xa6\xca\x58\x3f\x69\x68\x89\x37\xd6\x2c\x29\xb2\x52\xa7\x70\xca\x15\x29\x3f\x21\x9d\x8c\xba\xf1\xf2\x0d\x2c\x68\xdd\x90\xce\xbb\x49\xb8\xee\x48\x35\x68\x13\xb9\xba\xed\x8c\xa5\xaf\x3e\xbe\x45\x37\xed\xdb\x9a\x04\x41\xde\x19\xb7\x87\xc6\xad\x25\xe5\x33\xdb\xb7\x35\x37\xa2\x30\xbb\x4a\xcf\x3d\xa9\x27\x52\x32\x59\xbe\x12\x84\xbd\x69\x67\x92\x61\x6f\xaa\xb0\x37\x69\x0f\x8d\xa9\xca\xde\xb4\x36\xf6\x23\xc0\x43\xbf\x74\xa3\xd7\xd1\xd4\xef\x65\x19\x9d\xb2\x0b\x4f\x9d\xcc\x58\x92\x2e\x1d\x8a\x10\xec\x0f\x6d\x18\x84\x7f\x76\xee\x7a\xe3\x30\xc4\x7e\xdc\x22\x32\xf5\x60\xbd\xee\xcc\x88\x59\x60\xbd\xe9\x24\x42\xd9\x11\x42\x79\x3a\x1d\x76\x03\x6f\x73\x93\xfe\x3d\x27\xb2\x50\xb9\x48\x3d\x1a\x15\x3a\x53\xb1\x2d\xbb\x8a\x79\x7f\xbf\x5f\x6f\xd4\x77\xad\xb7\x9d\xbb\x6b\x3c\x6d\x3d\xa9\x5b\x21\xee\x93\x3f\x97\x97\x11\xf6\xf8\x2f\x98\x20\x5a\x4f\xea\xb2\x44\xbd\xe3\x9d\x01\x41\x3b\xac\x5e\xe7\xee\xc1\x1a\x74\x48\x15\xac\x6b\xf8\xd3\x76\xfb\x06\x1d\x25\x5d\x93\xe8\x7b\x98\x9d\xe8\x30\x79\xd2\xe9\x74\x49\x1f\x6d\x6e\x1a\xd7\xf4\x97\x69\x49\x5f\xae\xf1\x74\x73\xd3\x18\x74\x2a\x95\x2d\x78\x30\xad\xae\xf9\x9a\x46\x6a\xe8\x5a\x8e\xb9\xb9\xf9\xe4\x6d\xaa\x49\x0c\xf2\xd6\xe8\x9d\x3b\x17\x9d\xee\xb9\x73\x61\x82\x18\xf6\xb3\x93\x4b\x93\x30\xd5\xe8\x74\x3a\x7d\xb3\x27\x3a\xa2\x83\xdb\xec\xd2\x89\xd1\xf8\xa1\x9f\x4c\x4e\x57\x1d\x00\x63\x31\xfa\xa6\xe5\x75\xea\x6d\xef\x87\x7e\xdb\xdb\xda\x32\xaf\xce\xbd\x8b\x84\xf2\xb9\xb7\xd5\xbc\x68\x4b\xc4\xae\x1e\xdc\xbe\x61\x6f\x6e\xda\xca\xd6\x44\xd2\x02\xfd\x8e\xfa\xc5\xea\x9b\xb4\xea\x9d\x4e\x87\x54\x80\xd7\xa3\x0f\xf5\xa0\xe2\x73\xf7\xf7\xbf\xd3\x4e\x6e\xbd\xb1\xc0\xda\xb3\x2d\xd2\x5b\x03\xe8\xac\x6b\x0b\xe4\xaa\xd5\xb3\x2e\x83\x5b\x1f\x87\xad\x3f\x6b\x4c\xa0\x1e\x92\x31\x7b\x40\xb4\x08\x25\xc6\xb5\x5c\x27\xab\xce\x3a\xc0\x37\x2f\xac\xd3\xe9\xbc\xa1\x13\xc5\x8f\x25\x04\xae\xe6\xc6\xec\xbe\xef\x3f\x57\x2f\x9e\xff\x5a\x9a\x24\x31\xf6\x6c\x8f\x53\xdc\x4f\x94\x0a\x8e\x7a\xf6\x08\x93\xe6\xa1\x06\xc9\x5d\x05\xa6\xfd\x16\xfc\xa9\x57\xac\x4a\x8b\xfd\x6e\x56\x1e\x58\x77\x54\xfe\x5e\xd9\x32\x2a\x95\x2d\xdb\xac\x85\x74\xe6\x33\x76\xce\x3b\xad\x8b\x9d\x2b\x4b\x56\xda\x6c\xe8\x77\xcf\xed\x8b\x07\x13\x34\xcf\x61\x67\xe7\xf7\x9d\xad\x9d\x2b\xeb\xdf\x9d\xf3\x0b\x69\x2c\xfd\x3f\x3a\x96\x2c\xc7\xbc\x73\xfb\xc6\xbf\xf9\x05\x58\xe0\xa8\xd7\xf9\x77\x6d\x14\x8c\x0c\xb3\xdd\xab\xd1\xb3\xd4\x8e\xdd\xee\x91\x61\x71\x1c\xe2\xbe\x3b\xe9\x74\xdb\x3d\xd8\x0c\xec\x60\x22\x86\x4c\x0f\x3a\xf0\x7b\xec\xc7\x9d\x7a\x9b\xc7\xdb\x78\x60\xc2\x44\xa9\x50\x19\xa2\x34\x5a\x5d\x60\xbc\x85\x2d\x96\xbf\xe5\x58\x90\xbb\x55\x97\x64\xe8\x3d\xa9\x94\xcd\x99\x80\x21\x6e\x4b\x7c\xb0\x17\xc0\x0a\xfb\xcd\xb9\x11\x8f\x94\xa1\x46\xfd\x25\xaf\xe3\xe6\xe6\xbf\x6b\xa3\x71\x34\x30\x6c\xf3\x21\x69\x8f\x9f\x92\xf6\xa0\x4d\xc0\x05\x95\x0c\xdf\x0a\x31\x80\xfb\xae\x8f\x1d\x22\x0a\xbd\xfb\xfb\x4a\x37\x08\x3c\x6c\x83\x64\xf4\x4c\x5b\x51\x3e\x9d\x4e\xc7\xbe\xbf\xaf\xd0\x3d\x5c\x9e\x9e\xee\x5b\xf2\xa7\x64\x38\xf4\x52\xd2\xff\xcf\xc2\xaf\xff\x32\xf9\x89\xb5\xe1\x90\xb9\x97\xa4\xe9\xbe\xaa\xd4\x2a\x5b\x1f\x0c\xdb\xaa\x9b\xad\xae\x69\x35\x40\x11\x0d\x3a\xf5\x76\xb7\x93\x24\x68\x75\xb7\x2a\xad\x0a\x61\x11\x14\x4c\xcd\x8d\xa8\xa2\xb1\x4d\x93\xeb\x9e\xeb\x4e\xbd\x7d\xfd\x83\xcd\xdd\xa1\xae\xb7\xb6\xcc\xbb\x5e\xc7\x3e\xbf\xbe\x60\xaa\xad\xbb\xf5\xc1\xe8\x59\xd7\x66\x7b\xb0\xd5\xf9\xc9\xe8\x59\x7d\x68\xae\x07\xae\xc8\xfa\x9d\x1f\x37\x37\xed\xf3\x1f\x2f\xee\xef\xed\xf3\xca\x3f\xfe\xc1\x07\x67\xe5\xc2\xd2\x8d\xa4\x3e\x14\x6c\x77\xfa\x54\xcb\xda\xa6\x45\x18\x78\x62\xf4\x3a\x76\xcd\x87\xd0\xfa\x66\xcd\x09\x7c\xdc\x36\x7b\x9d\x1e\x75\x7f\xb1\x04\x0f\x5b\x5b\xa6\xa5\x70\x01\xea\x54\x6d\x39\x03\x13\x6d\x6e\x5b\xff\x31\x2a\xbb\x8d\x8a\x55\x39\x67\xd1\x10\xe8\x54\x77\x41\x52\x6d\xe0\x57\x2c\x0f\x5d\x5d\x5f\xe3\x69\x84\xee\x2a\x5b\x6c\x36\x24\x8f\x86\x6d\xd6\xfe\x08\x5c\xdf\xa8\x58\xa8\x62\x6e\x55\x1e\x2a\x2d\x6c\x55\x2a\x26\xd7\x93\x68\x90\x48\xeb\x07\x6a\xd3\x95\xd2\x79\xcc\x98\x23\x65\xbc\xe2\xfa\x00\x26\x9e\x56\xb7\x16\x07\xd4\x2b\xc7\xd8\xdd\x37\x13\xea\x47\x94\x3a\x15\x77\xd6\x68\x5c\xdc\xad\xae\xc5\x64\x7d\x6b\x4b\x96\xea\x63\x65\xc6\xec\xf0\x91\x64\xf5\x3a\xd2\x30\x6a\xdb\x9d\xd9\x44\xdb\x69\xb9\x79\xf5\x3f\x86\x6d\x39\x16\xb6\x46\xb5\x78\x60\xc7\x2c\x6c\xea\x6b\x36\x49\x99\x2d\x56\xc1\xcd\x4d\x83\x4c\x04\x9b\x9b\x46\xb7\xd3\xdb\x32\x9e\x40\xb9\xf7\xf7\xdd\xcd\x4d\x98\x67\xc9\x60\x81\x36\xa8\x54\x5a\xa0\xdf\xa0\x0d\x84\x8e\x3b\xb4\x2a\x7f\x27\x8b\xa3\x1d\xd2\xf4\xe4\x3f\xd8\xb2\x3b\xd9\xa9\xa9\x06\x31\x67\xc8\xfc\xd4\x85\xf9\x89\xd4\xb3\xcf\xe6\x28\x9b\x01\x2f\xb0\x99\xca\xae\xd1\x1f\x0f\xa6\xe5\x70\x35\x20\x35\xf2\xff\x70\x35\x60\xf5\x68\xa3\x11\x93\xa0\x4d\xeb\x82\xc1\x42\x20\x5c\xe2\x7c\x0e\xdb\xdd\xce\xff\x33\xba\xd6\x00\x28\xb4\xa9\x3e\xb0\xef\xef\x89\x7a\xa9\x54\xac\x63\xab\x6b\xb6\xdf\x1b\x5d\xf3\x61\xd9\xc9\xa5\x1f\xda\x57\x74\xc2\xa2\x36\xdd\x49\xe7\xee\x2d\x0f\x15\x7e\x37\xb4\x47\x2d\x79\x9d\x41\x24\x40\x68\x27\x9b\x2b\x11\xbb\x4d\xa5\xe2\xfc\xa2\x4d\xfb\x12\x2c\x29\x92\x98\xcb\xb6\xf3\x60\xf5\x83\xf0\xc0\xee\x0d\x4a\x91\x23\x55\x07\x1a\x09\xa1\x74\x03\x1c\x89\x06\x60\xda\x5e\x33\x7b\xb1\x3c\xaf\xea\x2d\x96\x49\x91\xb0\x0f\xbc\x00\xf3\xc1\x8a\x03\x90\x46\x85\x08\x9d\x52\x59\x9d\xba\x94\x15\xbd\x88\xf2\x5a\x76\x1f\xac\xc0\xf7\x54\x2a\x44\x66\x5f\x51\x23\xa9\xf5\x1f\xa3\xd2\xd8\xdb\xad\x88\xf4\xf6\xc3\x83\x25\x8c\xf0\x56\x6c\x91\x25\x44\xf2\x3c\xb6\x84\xd5\x0e\x36\x7b\xf2\x65\x62\x29\x1b\x50\xad\x77\x96\x0c\xca\x98\x69\x61\xda\x39\x43\xe3\xee\xc1\xb2\x39\xb8\x2c\x1b\xb7\xd6\xa0\x43\x45\x7c\xe3\xba\xc3\x05\x5a\xb6\x7d\xef\x32\x36\xef\x80\xfe\xb2\xae\x3b\xc2\x54\x33\xdb\x19\xfb\xb7\x97\xd8\xbf\x84\x1c\x1d\x57\x64\x0e\x82\x25\x81\x62\x5c\x32\x6b\x37\xfb\xa5\x4d\xd4\xfa\x15\x31\x3b\x25\x0b\xfa\x4a\x6b\x41\x93\xb7\x86\x73\x7e\x75\xd1\x11\xe6\x68\xf7\xfc\xea\x62\x73\x53\x30\xd6\x7f\xd5\x3f\xbf\xba\x68\x91\xb7\xd4\x9c\xb9\x2a\x30\xb0\xaf\x4c\x47\x6f\x60\x5f\x99\x77\x7d\x66\x58\x5f\x99\x6d\x3e\xdf\x51\x03\xfb\x0a\x0c\xec\xbe\xc6\xc0\x96\x88\xf5\x1f\xf2\x8c\xe2\x44\xf3\xf4\x40\xf3\x0c\x98\xd6\x71\xb8\xbe\xb9\x7e\x78\x60\xdd\xfe\xa3\x0d\x7b\x60\x1a\x61\x7d\x57\xeb\xba\xbe\x43\x87\x8e\x6d\xb6\xbb\x40\xb4\x63\x4b\xf2\xa9\x02\x83\xb6\x0e\xac\x0d\xb6\xf1\xde\xaa\xd0\x1d\xc1\x8a\x75\x79\x79\x7a\xf0\xf6\xe4\xe0\xec\xf2\xf0\xc3\xd9\xc1\xc9\x87\xd7\xef\x4f\x2f\xdf\x1d\x5d\x7e\x38\x3a\xbb\xfc\xf9\xf4\xe0\xf2\xe8\xe4\xf2\xe3\xd1\xcf\x97\xbf\x1e\xbe\x7f\x7f\xf9\xe6\xe0\xf2\xc7\xc3\x93\x83\x77\x2d\x06\xcd\x48\xc5\xe1\x88\x1a\xf2\x16\x0d\x39\xd9\x1a\x3e\x3c\x58\xa7\x7c\x59\xd8\x0f\x31\xfe\x13\x1b\x77\xfc\xfc\xe5\xe4\xc1\xb4\xce\x3a\xa7\x9b\x9b\x27\xf7\xf7\xa7\x6d\x35\x36\x73\xe7\xec\xbc\xc2\xd2\x55\x2e\x5e\xc9\x0f\xad\x33\x4d\xbc\xe6\xbd\x95\x6e\x98\x22\x76\x2a\x8c\x7e\x79\x7d\x82\x0e\x3f\xfc\xfb\xe0\xed\xd9\xe1\xd1\x07\xf4\x74\x27\xa1\x3d\x0a\x83\x1e\x86\x80\x6c\x65\xf6\x57\x1d\x7c\x83\xbd\x60\x04\x3b\xc1\xdf\xec\xe6\xea\xc6\xc6\x06\x0b\xe2\x48\x6a\x5e\xc3\xfe\x4d\xed\xc3\xd1\xbb\x83\xcb\x83\x0f\xbf\xd0\xf0\x73\xc9\x2e\x72\x85\xba\x47\x26\xcd\x45\x9e\xab\x49\x2b\x57\xf9\x51\x20\x8b\x4c\xaa\x3f\x33\x7c\xb1\xcf\x66\x25\xb1\xf3\x99\x97\xf0\x39\x4b\x88\x87\xa3\x78\x4a\xa5\x2d\xef\xc8\xb4\xd1\x60\x69\xd9\x56\x64\x6e\xba\xa6\x4c\x93\x3b\x60\xe7\xa4\x86\x8d\x62\x30\xf8\x07\x98\x02\x90\x09\x47\x4b\x6d\xec\xdf\x3d\x76\xca\x71\x76\xf4\xee\xa8\x45\x9b\x9b\xb4\x38\x0d\xba\x85\xba\xb8\x67\x93\xb6\x72\x63\x74\x85\xe3\x88\x85\x8b\xc5\x0e\x72\xc6\xc4\x9e\x43\xdd\xb1\xeb\x39\xec\xfc\x05\x04\xee\x17\x76\xf2\xd6\x41\x55\x2a\x79\xd5\xb6\x08\x31\xf7\xeb\xeb\x93\x0f\x87\x1f\xfe\xd9\x42\xef\x8e\xd0\x87\xa3\x33\x34\xb4\x7d\x0e\xc6\x0a\xfc\xd0\xd2\xd9\xe0\x13\x52\xe6\x46\xc8\x46\xcc\x38\x11\xfb\xbb\x9f\x44\x3f\x18\xb5\x5a\xcd\xfc\x84\xc6\x11\x9c\x10\x82\x14\xd1\x9d\x6e\x10\xcb\x68\x1a\xc5\x78\x48\x68\xd9\xbe\x43\x4f\xe4\x2e\xc9\xd4\x78\x89\xba\x98\x17\x2b\xf2\xf5\x82\x30\xc4\xd1\x28\xf0\x1d\xa8\x9a\xdd\xc5\x1e\x80\xc1\x02\x2f\x87\x31\xb2\xbd\x5b\x7b\x1a\xd1\xb0\x85\x11\x13\xc4\x9d\x1d\x74\xc0\x42\xb8\x43\xfd\x6b\x3f\x32\x33\x86\x76\x98\x4f\xa6\x4d\xf8\xc0\xdf\xa3\x0e\x8b\xaa\x9a\xc9\xfa\xee\xe8\x27\x76\xa0\x73\x12\x04\x31\x91\xf1\x9d\x1d\xf4\xd3\x38\xb6\x63\xc2\xce\x90\x54\xc7\xa0\x83\xfa\xdd\xd1\x4f\x16\x1b\xdf\xaf\x4f\xce\xf8\xcf\x0f\x76\xec\xde\x60\xb3\xc5\x99\xc2\xa1\x4b\x0a\xb4\x3d\xe4\x07\xc1\x88\x11\x60\x53\xa5\x37\x45\x63\x9f\xb4\x99\x2e\xf9\x88\xf4\x61\x04\x97\x02\x68\xa6\xb7\xa7\x24\x19\x49\x77\xe4\x93\x9c\x0c\x1e\xf7\xf6\xf6\x96\x0a\x40\x54\x13\x7d\xfc\x63\x10\x5e\x63\x07\xf5\xc3\x60\x88\xfa\xdd\x3f\xa2\x1d\x26\xdb\x2d\xf2\x71\x10\xc7\xa3\xa8\xb5\xb3\xc3\x8e\x19\x7a\xc1\x50\x1c\x3d\xec\x40\xe2\xae\x17\x74\x77\xf0\xfe\x7e\xd7\x6e\xd6\x6d\xe7\x59\x17\xef\xed\xee\xe2\xee\xb3\xbd\xbd\xe6\x6e\xbf\xd9\xad\x7f\xff\xdc\x79\xd1\xfc\x7e\xb7\xb9\xe7\x7c\xef\xe0\xfd\x1d\x22\xcb\xf6\x15\x8e\x68\xde\x28\xec\xed\x5c\x5e\xf6\x83\xf0\x3a\xba\xbc\xe4\xc5\x26\x2a\x0e\x38\xef\x0d\x20\x1a\xbf\x1b\xa1\x5b\x38\x97\x85\x90\x8e\x81\x87\x6b\x24\x39\x44\x11\xc5\xb6\x43\xd4\x0e\x7f\x0f\xa2\x64\x71\xf9\x71\x02\xe4\x07\xf1\x80\x74\xc7\xed\x00\xfb\xa8\xca\x92\x55\x09\x45\x3f\x88\x51\x34\x1e\xd1\xf1\x91\x88\x6f\x88\x41\xc4\x21\xa2\x98\xdb\x77\x71\xc4\x44\xcd\xa1\x22\xbe\xbd\xbd\x4d\xfe\x9c\xba\x43\xd7\xb3\x43\x14\x07\x92\x86\xe9\x8e\x63\x44\x84\x15\x79\xc1\x15\x19\x04\x5c\x4d\xb8\x7d\x46\xc3\xa7\x87\x1a\xbc\xf4\x21\x8e\x93\x72\x7b\xb6\xcf\x0e\x9f\x1d\x42\xd5\x0b\xae\x90\x1b\x45\x63\x1c\xd1\x08\xbd\x62\x12\x90\x8f\x4e\xe0\x5b\x2f\x74\x01\xd4\x93\x50\x1a\xd9\xf1\x20\xaa\xa1\x13\x3c\x0c\x6e\x48\xc9\xa4\x58\x2f\xb8\xba\x22\xbf\x61\x7c\x91\xb1\x98\xe8\x5a\x95\x16\x8c\xb6\x6b\x8c\x47\x5c\xe3\x47\xf6\x10\xb2\xbb\x3d\x68\xcd\x7e\xe0\x79\xc1\x2d\xd0\x84\x2f\x40\x90\x96\x48\xc7\x16\xd8\x34\xc1\xed\x71\xe8\x06\xa1\x1b\x4f\x7f\x15\x5a\x52\x09\xa2\xfc\xd0\xde\xd8\x20\x1a\x9e\xc6\x49\x70\xfd\x58\x97\xae\x0f\x1e\x67\xdc\x53\x5e\x5c\xa1\xb9\xa4\xd7\xa6\xd2\x16\x18\xc4\x6d\x24\x2a\x93\x9a\x58\x90\xea\x25\x6a\xa0\x57\x34\x03\xbd\x68\x5c\x37\x2d\x74\x79\x0d\xd7\xce\x1a\x6d\xfa\xeb\x07\xf8\x4e\x1f\xe4\x0b\xc6\x70\x12\x06\x29\xd8\x3d\xe8\xc4\x30\xbb\x84\x10\xd2\x1b\x92\xd3\x3f\xe0\x05\x87\x57\x87\xbe\x83\x27\x48\x00\xac\xc0\x71\x22\x3b\x08\xeb\xa0\x2a\xab\x63\x0b\x55\xd1\x16\xa2\x95\x4b\xb6\xd1\xbe\x8b\x76\xae\x2c\xb5\x91\xd4\xeb\x04\xc0\x0f\x2f\x63\x6b\x8b\x97\xcf\x2e\x08\x48\x51\x5d\x99\x7c\xc3\x9c\x5a\x15\x5b\x46\x12\x72\x90\x3c\x7e\x0c\xc6\x9f\x74\xcf\x00\xa1\x38\x9c\x8a\xc4\x3b\x3b\x44\xdc\xd1\xaf\xd8\xeb\x05\x43\x88\x6a\xe7\xe0\xee\x98\x4a\x13\x55\x61\x30\x1a\x78\x5a\x10\x63\xaa\xcb\x6f\x6d\xa6\x76\x7d\x1a\xa6\xb7\x17\xf8\x37\xd8\x77\xb1\xdf\xc3\x28\x0a\xa8\xc7\x05\x77\x48\xa1\x67\x84\x64\x0e\x8b\x6d\x1e\xbe\x8f\x90\x8b\x03\xd4\x77\x7d\x87\x0e\x1d\xdb\xf3\x22\x37\x66\xbe\x1a\x30\xc5\x39\x34\x13\x1f\x63\x90\x3a\x24\x63\x94\xba\x07\x88\x50\xb5\xf4\x90\x32\x55\x55\xd4\xb3\x21\xaa\xcc\x84\xc8\xe3\x06\x82\xe0\xdf\x68\x96\xec\x8a\xf1\x6b\x21\x55\x3c\x49\x07\xd0\x37\x70\x1f\x49\xb4\x7b\xd2\xec\x69\x76\xaa\x9f\x18\xdf\x59\xa2\x16\xaa\xd5\x6a\xa4\xc3\xcd\x4f\x7c\xc2\x93\x75\x09\x91\x9f\x2a\x17\x2c\x2e\x96\x55\xa5\x0b\x01\xe2\x4c\xd0\x4d\x98\x50\x46\x51\xb3\xdc\x30\x6a\xa2\x97\x70\xfb\x90\xfe\xde\x46\x4d\x69\x20\x11\x12\xcd\x36\xfb\x49\x87\x12\x7f\x54\x6f\xeb\x8b\xe1\x04\x14\xb2\xe3\xa9\x99\x05\x57\x93\x15\x03\x0b\xd0\x2a\x9a\xd5\x42\xe7\xb4\xa9\x2e\x6a\xbd\xc0\xef\xd9\x70\x34\xad\x86\x5d\x68\x6f\x3c\xe4\xa9\xa3\xbf\x37\x50\x47\xf3\x9a\x59\x95\x8e\xeb\x90\x17\x70\x4e\x49\x8f\x14\x7f\x0c\xc2\x9f\xfd\x21\x3d\x2f\x16\x2b\x69\x1a\xa5\x5b\x72\x2e\x23\xdd\xf3\x21\x08\x46\x06\xb8\x3f\xf5\x0e\x45\x1c\x6c\x88\x01\x1d\x52\xdc\x42\xd2\x22\x77\x42\x3b\x48\x67\x6f\xa8\x83\xd4\x7c\xf2\xc1\x5c\x5b\xca\xc1\x8a\x67\xb7\x75\x64\x0a\x9b\x9b\x20\xa0\x22\x0c\xba\x7c\xaf\xe7\xfe\x5e\x4e\x0a\x47\xe7\x80\x32\x57\xa5\xab\x2f\xcf\x8e\xa2\x6a\x52\x0a\x93\x34\x7a\x41\x57\x2d\x72\x0b\x55\x6b\x44\x00\x93\x4a\x25\x1a\xa8\x64\xcb\x9d\x27\xe4\x2f\xd2\x7a\x4e\x16\x62\x3e\x3e\x58\x5c\xe6\xea\x77\x11\x18\x8e\x2d\xf4\xd6\xf6\xe9\x24\x4b\x8f\x38\x91\x8d\x58\x11\x08\xfc\xa0\xc6\x7e\x4c\x27\x3b\x56\x5e\x8d\x8e\x18\xd0\x4d\xe3\x88\x9a\xaf\x43\x6c\xfb\x11\xd3\x3f\x9e\x87\x1d\xf4\x5d\x64\x98\x28\xf0\x11\xd1\x46\x9c\x63\x3d\x09\x30\x6e\xfd\x60\x3b\x18\xd5\x7e\xf7\x7f\xf7\x8f\x3d\x6c\x13\xab\x84\x45\xbf\xc5\xc9\x24\x4b\x1e\xbe\x8b\x24\x22\x55\x59\x16\x52\xbf\xe5\x46\x66\x62\xbc\x40\x73\xf2\x38\xfd\x10\xb7\x38\x09\x14\xcd\xf9\x26\x1c\xd9\xdd\x28\x0e\xc1\x0c\x3d\x3e\x04\x36\x49\x8d\x69\x3b\xc2\xf1\x7a\xe2\x0a\x03\xa2\x41\x24\x9a\x16\xfe\x3f\xe4\x2b\x73\x35\x66\x81\x1d\x9e\x22\x88\xe1\x1c\x11\xd3\x0a\x9c\xf8\x82\x10\xac\x1a\x50\xcb\x50\x25\xd0\xd8\xa2\x72\x08\xd6\x0a\xc0\x7e\x6d\x43\x09\xff\x90\x88\xe1\x43\x6a\x1c\x80\x3b\x9f\x88\x1a\x7f\x8b\xd1\x2d\xb1\xb3\xe2\x00\xc5\x38\x8a\x39\x15\x1e\xe6\x81\x9d\x88\x3c\xa0\xb3\x70\x0c\x68\x7a\xac\x34\x8b\x1a\xf0\x28\x20\x5c\xde\xba\x11\x16\xc5\x87\x41\x8c\x7b\x31\x05\x04\x82\x88\xda\xbe\x0d\x01\x89\x9f\xee\x6c\x20\x94\x78\x89\x48\x73\x80\xca\x1e\x17\x60\xc6\x01\x5b\x27\x20\xf4\x00\x0e\xc9\xa2\x9d\xc0\x69\x21\x4a\xda\xba\xc6\x96\xe3\xd4\x39\x0f\x84\xb9\x4b\xaa\x79\x13\x10\x53\x1c\x2c\x55\x17\x9a\xeb\xda\x27\x33\xe8\xad\x1b\x0f\x28\xa1\x1e\x0e\x63\xdb\xf5\xe3\x29\x9d\x07\x6f\xc9\x0c\x80\xd1\xd3\xa7\x7e\x10\x3f\x7d\x4a\x6c\x41\x9b\x2c\x35\x50\x1c\xda\x7e\x64\x53\x9f\x2c\xc8\x48\x73\x7f\x0c\xc6\x68\x68\x4f\x45\x1b\x42\x20\x79\x3a\x89\x92\x22\xc9\x78\x20\x05\xb2\x28\xce\x64\xc6\x77\x30\x1e\xe1\x10\xd9\x64\x75\xc9\xbd\x51\x19\x27\xbc\x57\xab\x11\x0d\x57\x8d\x06\x76\xc4\xcc\x75\x07\x0c\xe1\x4f\xdc\xdd\xe3\x13\x58\x03\x3c\x7c\x3f\xef\x7c\x4a\x06\xda\x01\xec\x4e\xf2\x9d\xb6\x00\xfa\xa4\x8d\x8d\xfd\xc9\x02\xb2\xdc\x4f\x93\xa6\xa5\x54\x3e\x09\x6e\x7e\x75\x3d\x8f\x25\x07\x93\x35\xf9\xf2\xce\x75\xd8\x07\xb9\xfc\x79\x25\x90\x36\x0d\xed\xb7\x10\x53\xc7\x87\x94\x30\xbf\xe2\xc2\xf2\x00\xf5\xed\xda\xbd\x6b\xf4\x96\xaa\x19\xbb\x1f\xe3\x50\x1d\x10\x54\x20\xd2\x03\xe2\x15\x3d\xba\x7b\x90\xb4\x04\x22\x5a\x9b\xfb\x6c\x92\xd7\x44\xcb\x09\xb9\x64\xdb\x31\x94\x75\x32\xb8\x39\x41\xf0\x79\x96\xa5\x5a\xe3\xdc\x94\x2b\xde\x96\xa8\x41\x76\x1e\x43\xf9\x53\x5e\x55\x72\xc8\xa1\x96\x49\x6a\x3c\x30\xcf\xa9\x08\x11\x01\x64\x55\x02\x21\xaa\xa1\xd7\x74\xc9\x2e\x6c\xc2\x20\x94\x05\x29\x0e\xd0\x70\x0c\xd2\x46\x93\x27\x72\xcd\xfa\x24\x26\xcb\x71\xf4\x29\x09\x46\xfd\x89\xd8\x9f\xee\x90\xe4\xea\x7a\x58\x15\x3d\x1c\x62\xba\x12\x53\x20\xc3\xd2\xf9\xb9\x57\xb0\x3b\x1c\x62\xc7\xb5\x63\x2c\xa6\x1e\xc7\x42\x51\x40\x89\xd9\xbd\x1e\x8e\x22\xd2\x25\x6a\xd9\xb4\xc3\x59\x6f\xd1\xdd\x12\x1c\x0f\x02\x07\xc6\xa1\xf0\x92\xc1\x28\xf0\x1c\x8a\x4e\xb2\x66\xe1\x0c\x58\x2c\x6c\x22\x83\x1e\x8e\xa9\xf3\x1a\xfa\x80\x27\xb1\xd2\xa2\xdf\x96\x2c\x2b\x8e\x78\x45\xc2\x2c\x57\x7a\x51\xd9\x0e\xa5\xc2\xb4\xc2\x7d\x8a\x63\x62\x23\x44\xe3\x6e\x84\xe3\x94\x74\x83\xba\x03\x7d\x8f\x27\x6e\x14\x47\x62\xbb\xee\x72\x84\x61\x13\x8b\xf6\x07\x8d\x1c\xfe\x14\xf1\x0a\xb3\x8c\x23\xea\x70\x4c\xa8\x0f\x71\x08\xab\x30\x32\x9b\xc7\xf8\x8a\xcd\x07\x6c\x5b\xc1\xbe\xb1\x5d\x8f\x88\x3b\x5d\xb1\xe1\x11\xa5\x36\x12\x70\xed\xe8\x76\xe0\xf6\x06\x08\xa6\x69\xbf\x3f\x26\x72\x5b\xfb\xff\xec\xfd\x7b\x5b\xdb\xc6\x16\x28\x8c\xff\xfd\xe3\x53\xc8\x3a\xdd\x46\x2a\x83\x03\xa4\xb7\x48\x55\x39\x04\x48\x43\x73\x21\x05\x92\xb4\x9b\xcd\x8f\x8c\xa4\xb1\xad\xda\x96\x5c\x49\x86\xb8\xd8\xdf\xfd\x7d\x66\xad\xb9\xca\x32\x21\x69\xf7\x39\xef\x79\x9f\xb3\x9f\xdd\x60\xcd\xfd\xb2\x66\xcd\xba\x8f\x90\x27\x1e\x7f\x9c\x16\x15\x73\xac\xe1\x14\xa5\x93\x16\xf9\x66\xed\xa0\x60\x11\x5b\x13\xf2\x44\x3e\x39\x3e\x98\xff\x55\x80\x3b\xa5\x65\x9d\xd1\xb1\x01\xb7\x22\x45\xdc\x42\x18\xe9\x0f\x46\x94\xa2\x46\xfd\xbf\x0e\xd7\xaf\xff\x51\x60\x56\x46\xa3\xf7\x00\xb2\xb9\x08\x5f\x0a\xc7\x12\xa9\x0a\x18\xde\x58\x6a\xb1\xef\x53\x20\x69\xf9\xb6\x81\xed\x2d\x2b\x2b\x45\xd1\xc2\x52\x20\xe0\x89\x97\xef\xa9\x41\xe2\x02\xf1\xa8\x86\xad\x2d\x87\xc5\x1b\x23\x52\xa9\x2f\x16\xb4\xc4\x41\x6a\x23\x41\x19\xb1\x3b\x94\xa9\xa2\x02\x72\x3a\xfc\x97\xca\x29\x59\x9f\x17\x37\x64\xf6\x21\x3a\x7c\xbd\xe7\x60\x95\xf1\xd5\xc9\xfe\x42\xd3\x63\xe9\xa5\x25\x3a\x05\x22\x02\x54\x17\x8c\x8e\x9d\x22\x67\x42\x4e\x9e\xff\x01\x94\xa0\x10\x2d\x63\x63\xe2\x9d\x30\x80\x45\xd3\xaa\xd2\x89\x54\x6b\x8b\x45\x2b\xa5\x0c\xfc\xa7\x5a\x80\x7b\x8c\x74\x25\x23\x29\x96\xfe\x3e\xe4\xd1\xbc\x1a\xd5\x65\x08\xa2\x3a\x2c\xf3\x59\x57\xa1\xe0\x0e\xfe\xa1\x6b\xf0\x9f\xbd\x04\x3f\x35\x36\x10\x08\xf1\x25\x30\xc9\x4c\x3e\xc4\x72\x96\x3b\xd5\x3c\x4f\x86\x65\x91\x17\xb3\x6a\x3c\x47\x61\x30\xb0\x3f\x73\xe8\x91\xdd\xb0\x5c\x3c\x2a\x17\x33\x27\xa6\x75\x32\x04\x91\xeb\x00\xb8\x98\x9e\x03\x8b\x98\xd0\x5c\xe2\x5b\x4e\xb7\xa3\xdb\x11\xca\x58\x15\xc6\x40\x1a\x5c\xac\x0b\xfb\xc8\x12\xf0\x2c\x02\x5a\x5a\xe2\x02\x3e\x42\x39\x40\xe0\x1d\xc5\x73\x76\x1b\x82\x84\xe6\xd7\x51\x2a\xa7\xfb\x9e\xd7\xa4\x06\xee\x50\x28\x3f\x35\xdb\x21\xa6\xaf\x92\x60\x60\x25\xc1\x3e\x2d\x32\x8e\xb3\x72\xde\x1c\xda\xe3\xd7\xb3\x92\x39\x1e\xc8\xba\xcd\x55\xf1\x7b\xce\xc9\x4a\x2b\xca\xbf\x67\x36\x85\xab\x43\xc0\x96\x46\x86\x4a\x6c\xe3\x78\x15\x0e\xc5\x3e\xda\x3e\xbf\xa9\x58\xc5\x70\x1b\x95\x4c\x3b\xcd\xfa\x7d\x8e\xd6\x6b\xde\x1a\x68\x1a\x00\x3e\xbe\x56\xd7\x1f\xb8\x76\xa9\x79\xf3\x4d\x32\xa6\x06\xe0\x23\x9c\x97\xd0\xe3\x95\x1f\xe1\x98\xf5\x8b\x12\x41\xbf\x8d\x5b\x20\x40\xfe\x03\xb0\xe5\xec\xd6\xb1\x47\xcb\xb3\x24\x6e\x51\xcc\xc7\x9c\xf1\x46\x11\x58\xaa\x6c\x90\xe3\xa2\xc3\x40\xc5\xfe\xd8\x77\xd1\x42\xdf\x21\x9f\xba\x94\x0a\x63\x72\x35\x1c\x15\x47\x4a\xb9\x8a\x74\x96\x30\x27\x7f\xc8\x45\x26\x34\x41\xea\x42\xfb\x8c\xeb\xac\x92\xf0\xa7\xaf\x32\xcd\xee\xda\x8c\xf0\xd7\x8f\x5a\xf1\x96\x02\x62\x53\x20\xda\x7e\x0f\x21\x5a\xef\x48\x91\xb4\xb5\x38\x10\x2f\x0b\xd7\x0f\xc2\xbc\xad\x2d\x23\x3b\x81\x52\x8d\x6c\x74\x91\x82\x67\x04\xa4\x4e\x51\x4a\x89\xe4\x30\x85\xac\xa8\xa6\x23\xe4\xbb\x85\x89\x5d\xd1\x17\x4b\x01\xf5\xe2\x31\x03\x14\x22\x04\x20\x45\x69\x1e\x3e\x24\x91\x10\x3b\xdd\xdf\x44\x6f\xd3\x77\x02\x15\xf6\xcc\xbe\x29\xda\xbd\x21\xd6\x5e\xe0\xd6\xad\x6c\x5c\x0b\xff\x88\x00\xe1\x0b\xc5\x07\x30\x80\x7f\x4a\x74\xf0\x77\x05\x07\x5a\xa0\xf5\xb7\x84\x06\x5f\x20\x32\xf8\xfa\xb3\x0e\x9c\x00\x29\x21\x08\xe3\x58\xfe\xf3\x8f\x9c\xc1\x45\xdb\x6a\x08\xeb\x9c\x3d\xc8\x49\xc6\x04\xb1\x06\x73\x6e\x40\xd9\x11\x9b\x96\x2c\xe1\xf8\x81\x13\xaa\x95\xc4\xe5\xfc\xb7\x52\x4b\x02\xdf\xe2\x14\x39\xd2\x87\x59\x22\xf4\x40\xf0\xc5\x10\x33\x57\x59\x9e\xc0\x1a\xdf\x32\xe7\x16\x00\x74\x9c\x8d\x04\x2f\x22\x3a\x00\x27\x49\xe2\xdc\xb2\xcd\x92\xc1\x26\x0e\x0a\xa1\xc3\x99\x14\x37\x98\xeb\x14\x37\xac\x94\x18\x98\xb7\x36\x29\x52\x56\xe6\x4e\xac\x88\xd3\x9e\x73\x82\xfa\x5f\xde\x90\x83\xba\x01\x87\x72\x72\xae\x06\x6b\x16\x78\x1d\x96\x1f\xde\xac\xef\x64\x1c\xdc\x90\x3e\x41\x38\x7a\xa4\x54\x90\x6a\x50\x29\x4c\x34\x92\x3a\x1d\x2d\xfd\xbb\xdc\x54\x1f\x9b\xc4\xd9\x54\xbd\x4e\xe8\x88\x39\x15\xbf\x5f\xf9\x89\x18\x33\x38\x9e\x40\xbb\x25\x65\x06\x04\x03\xfa\xb2\x09\x66\x0a\xb4\x39\xac\x42\xa5\x2d\x48\x94\x6d\x18\x44\xd9\x2e\x6f\x6b\x5a\x02\x8d\xe2\x4c\xd8\xa4\x28\xe7\xce\x98\xd1\x51\xd5\xdb\x14\xcf\x2c\x95\x16\xb7\x7b\x69\x33\xa4\xc4\xd9\x3c\x63\x7d\x30\xf3\xc2\x4b\x15\xe4\xd1\x1c\xc7\x55\xcc\x20\x44\x84\xde\xdc\xab\x18\xc3\x91\xdc\xa7\xe8\x47\xcf\x42\xd4\x45\x3f\x7a\xbc\xf7\xf8\x3b\xbf\xb7\x79\x85\x4a\x16\xb9\x82\x7c\xe9\x25\xf4\x64\x45\xde\xa6\x3c\x43\x92\x0f\xe5\xdd\x59\xde\x2f\x24\x87\x22\xec\xbb\xb0\x0d\x65\x97\xd7\x72\x1e\x88\x63\x36\x21\x15\x07\x03\x56\x07\xad\x9a\xd3\x36\x6d\xde\x57\xbb\x4d\x75\x02\xb8\x85\x6b\xb0\xcf\x72\x67\x3a\xa6\x59\xee\xfc\x42\x6f\xe8\x39\xec\xa2\x0d\xe0\x3d\xe7\x5f\xd5\x26\x4e\xe0\x72\xe7\x4a\xfc\xd8\xbd\xb2\xe2\x99\x03\x3d\xab\x94\x55\x5a\xb3\xa5\x55\xb6\xb0\x72\x4a\x1b\xd7\xcf\x81\x83\x04\x2d\xbf\x09\x8a\xa6\x76\xd1\xce\x69\x5a\x31\x62\x0b\xc6\x5b\x3f\xeb\x76\x44\x94\x24\x8d\x9e\x2e\x31\xf9\xca\xd4\xa0\x19\x0a\x84\x7f\x88\x1f\xb4\x8c\x54\xef\xe7\x09\x1f\x3d\x72\x8e\x66\xd3\x71\x86\xbb\x02\x14\xe3\xa1\xd1\xea\xff\x87\x79\xc6\x55\xee\xf9\x68\x36\x99\xcc\xc1\x6e\x62\xc3\x4e\xd3\x47\xc3\x89\x9c\x96\x03\x83\x56\x65\x53\x73\xd5\xdf\x18\x35\xac\xed\xb0\xda\xe2\x04\x73\xb3\xfb\x70\xa3\xbd\xa1\x9e\xad\xc5\xb4\x1a\x05\x8b\xa9\x03\x20\x8c\x68\xee\xb0\x8f\x75\x49\x1d\xdd\xcf\x1f\xb3\xc9\x54\xc2\x51\xc5\xc4\xe1\xae\x7a\x1b\xc2\xae\xcf\x6b\xef\x8f\xb4\xcd\x74\xfd\xe8\xda\xbc\x2b\x95\x9a\x4c\x2f\xb6\x6d\x26\xfd\x7f\x61\xb3\x1d\x36\xc1\xd0\xc5\x5a\x29\x13\x9e\xec\x35\x7c\x00\x40\xad\x69\xaa\x01\x51\x76\xb3\x7f\x0f\xa4\xd6\xf4\xb8\x0e\xa6\xd6\x0d\xf0\x7e\x9f\x58\x05\x5e\xeb\xaa\x8b\x97\xec\xa3\x95\x6b\x6b\xbd\xd7\xac\x45\xa6\xbd\x60\x6c\x5a\x71\x22\x3d\x19\x29\xb1\xa3\x60\x0d\xc1\xe0\xdb\x90\x9e\xd8\x19\x52\x09\xac\xf9\xf9\xdb\x61\xa1\x98\x88\xdb\x1c\x82\xaa\xa8\xcc\x0a\x49\x28\x8a\x4c\xb6\x36\x43\x8c\x19\xea\xd7\xc5\x26\x49\x72\x4a\xe9\x8c\x4d\x63\xee\xa6\xc2\xd8\x96\x7a\x3a\xff\x13\x76\xad\xf9\x3c\xbf\x92\x88\x4a\x0f\x61\xe0\xf7\x60\x05\xc0\x1d\xc6\xba\xfb\x54\xf4\xe1\xb5\x8e\xc3\xa1\x8c\xd0\x23\x9c\x5b\x14\x29\x5b\x53\x14\x5f\x43\xf7\xc2\xae\x1d\x18\x52\x08\x65\x52\x1b\xb2\xa7\x1c\x0c\x35\x45\x7d\xde\x5a\x5e\x94\xce\xb4\x18\xcf\xfb\xd9\x78\x4c\x78\x51\xce\x3a\x21\xe5\x80\x6e\x76\xc0\x6b\xf3\x7e\xc0\xde\x8e\x95\x60\xaf\x92\x27\xac\x87\xeb\x74\x7c\x70\x78\x71\x7d\xfc\xf2\xf8\xd5\xf1\xeb\x8b\xeb\x8b\xdf\xdf\x1c\x83\x51\x8a\xe5\x83\xd3\x64\x83\xbb\x5d\x91\x71\xc9\x29\xf8\xcd\xab\x95\x04\x6f\xd3\x72\x23\xdd\x04\x0b\x8f\x9d\x8f\x8c\x26\xdf\x8b\x95\x3b\x3b\x3e\x3f\x3e\x7b\x77\x7c\x74\xfd\xe6\xec\xf4\xcd\xb9\xd8\x1b\x88\x95\x2f\x83\x6a\x95\xac\xaf\x3f\x84\x33\xb4\xf9\x8d\x2e\xd1\x90\xa2\xf6\x43\x58\x1e\xf3\xe5\x7e\xc1\x24\xa5\x75\x3e\x2c\x6e\xf3\xb0\x99\x7f\xc6\xfa\x76\xbe\xc6\xc0\x43\x8a\xfe\x05\x67\xac\xef\x25\x45\xde\xcf\x06\xa6\xb9\x0c\xbc\x7d\x6b\xed\x2a\xba\x75\x60\x49\xd0\xca\xf4\x37\x7d\x3b\x7a\xbf\xe0\x03\x14\x7c\x0c\x58\x6d\xd4\x3f\x62\x48\xa4\x17\x65\xa3\x11\x5e\x4e\xd2\x6c\xbc\x5b\xd1\x4c\xb7\x2b\x1a\x94\x12\x5c\x31\x91\x96\x58\xbe\xca\x0a\xc0\x20\xfb\x36\xf0\x3f\xe9\x94\x0a\x3d\x72\xa4\x0f\x86\x7a\x06\xad\xb8\x6c\x59\x92\x17\x6c\xfe\x25\x4b\x32\x62\xf3\xbf\xbf\x24\xd0\xc8\xff\xc2\x25\x19\xb1\xf9\x7d\x4b\x82\x89\x2f\xd8\x9c\x8f\x59\x74\xf7\x33\x8c\x41\xde\xd9\x86\xd9\x13\x8e\x43\x5a\x34\x1d\xc4\xc5\xac\x3e\x90\x12\x6a\x34\x6e\x5a\xe5\x1b\xc0\x74\x6e\x3d\x44\xeb\xa9\xad\x2f\x63\x58\xe1\xb4\xdb\x31\x05\xce\x87\x11\x9b\x7f\x50\xda\x3a\x20\x12\x7a\xce\x45\x39\x17\x3c\x30\xf2\xa9\x4a\x68\x21\xde\x14\x00\x3e\x2d\xcb\x9d\x0f\x6a\x6d\x3e\x08\x5c\x8c\x4b\xc8\x52\xc0\x5b\xf3\x62\xe6\xe4\x0c\x31\x9c\x68\x48\x19\xec\x42\x13\x20\x9a\x05\x91\x90\xd0\x4d\xc1\x25\xa3\xf1\x3e\x81\x26\xc4\xad\x30\xa5\x38\x10\x30\xe2\x54\x62\x5c\x6c\x08\x87\xed\x49\xd6\xb1\x1f\xf7\x26\x0c\x99\xc5\x6d\xb1\x3a\xdb\xe8\x33\xb6\x69\x6f\x8b\x65\xa6\xe7\xb4\x6f\x4e\x03\xa4\x8c\x35\x6d\xe7\x17\xc5\xee\x03\xbc\x4a\xe6\x10\x58\xc3\xd6\xd6\x91\x91\x46\x90\x9b\x95\xfc\x2a\x17\x38\x0d\x19\xb4\x55\x88\x3b\x63\xfd\xbf\x0b\x71\x67\xac\xff\x20\x88\x6b\xe0\xc8\x56\x88\x6b\x94\x79\x08\xc4\x95\xac\xff\x7f\x21\x6e\x2d\xc4\x9d\xb1\xfe\x97\x42\x1c\xbf\x34\x3e\x01\x71\x67\xac\xff\x69\x88\x93\x92\x5e\x74\xd1\x93\x1a\xb2\xba\x70\xd0\xc3\xc4\xa1\x40\x45\x8b\xc8\x50\x78\xc5\x0b\x29\x70\x5e\x38\xe3\x22\x1f\xb0\xd2\xa1\x29\x27\x5a\x2a\xa1\x63\x80\x95\x06\xae\x7d\x0a\xb1\x5b\x73\xe2\x54\x85\x70\x89\x00\x79\x10\x6f\x50\xca\x72\xb3\xba\xe7\x1c\x8c\xab\x82\xf0\xe6\xa4\x62\xbe\xe8\xa3\x65\x23\x08\xf3\x38\x60\xdc\x16\xe5\x48\x89\xdd\xc0\x06\xcf\x91\xfe\x88\x4e\x3f\x63\xe3\xd4\xa1\x03\xca\x6b\x0b\xd2\xa4\xd7\x2f\xca\x55\xba\x84\xf7\x29\x9b\xcd\xfa\x20\x2e\x46\x1f\x0d\x30\xae\xc4\x29\x0a\x7a\xac\x29\x78\xfd\x7a\x09\x54\x52\x23\x69\xc4\xe6\x66\x0a\x2a\xe6\x17\xd2\x64\xa0\x64\xfd\x46\x79\x4e\xd7\x38\x07\xce\xd7\x35\x9b\x4c\x8b\x92\x96\xf3\xaf\x85\x60\x03\x85\x94\x35\x4b\x6a\x47\x58\x28\xdd\x02\x19\x08\xfa\xcc\x0f\x0e\x0a\x22\x35\x50\x0a\x55\x16\x73\x3e\x00\x7d\xfd\x01\x85\xe1\xe8\x56\x64\x39\xda\x82\x20\x18\xe4\xc3\x44\x99\xbf\xdf\x22\x5d\x4d\xd1\x76\xb8\xc7\x39\x3d\x29\x5d\x1f\xb0\xda\x29\x33\xf0\x6b\x41\xc2\x9d\xe6\xa9\x94\xfb\x39\x38\x3b\x3c\xd1\x15\x6a\x86\x68\x59\x16\xb7\xa0\x5b\x13\xe8\x45\xe8\xb8\x68\x05\x90\xc1\xff\x8a\x19\xf0\x54\xd1\x64\xc9\xd4\x31\x25\x82\xda\x95\xea\xc0\x1c\xe0\x47\xfa\xde\xe4\x4e\xcc\x86\xf4\x26\x2b\xca\x5e\x73\x1d\xd1\xcd\xef\x80\x73\x0e\x79\x21\x83\xc3\xa2\x9e\xc4\xa3\x69\x8a\xec\x27\x45\x85\xc2\x34\x1b\xa3\x8d\xa8\x32\xc3\xf4\x01\x00\xf2\x94\xb3\xd2\x60\x34\x91\x8d\x59\x0e\xc3\x19\x67\x39\x73\x64\xa0\x5d\x11\xa0\x12\xaa\x81\xc0\xad\x9c\x50\xa9\x9b\x30\x47\x03\xf3\x6a\xa4\xc1\x29\xdd\xb0\x39\x0f\x93\x59\x91\xfb\x63\x62\x66\x64\x09\x47\x6c\x4e\x38\xe8\x10\x80\x16\x22\xe6\x4a\xb0\x17\xa1\x49\xd4\xf8\x9e\xa9\x76\x10\x13\x48\x6f\x08\xce\x63\x50\xf0\x9a\x99\xa1\xaa\x29\xcf\xfe\x9c\xb1\xf1\xdc\xc9\x52\x96\xd7\x59\x7f\x8e\x4a\x14\xba\x02\xf8\xd0\x8a\xf2\xf5\x6d\xe5\x18\xc8\x86\xec\xea\xe9\x2c\x1b\xd7\xdb\x59\x6e\x9a\xf8\x00\x8c\xc5\x0c\xf6\xbf\x40\xb4\xcb\x8c\xa6\x31\x7c\x22\x4c\x15\xbe\x81\x0d\x18\xc9\xab\x11\xf8\x80\x52\xa2\x2d\xf4\x27\x16\xca\x53\xd5\xe9\x19\x4b\x8a\x32\x6d\x30\x94\xe8\x8e\x57\x65\xf1\x18\xad\xa0\xe1\x14\x28\xb5\x3f\x53\x87\xda\x71\x1c\xe1\x9d\x2c\xb7\x4d\xb8\x60\x18\xcb\x07\x5a\xe4\x0c\x03\x85\x3a\xfd\x31\x05\xfc\xa0\xf9\x50\xb0\x7d\xc8\x6e\x18\x9c\x9c\x29\x2a\x79\x8a\x5c\x56\x47\xe9\x00\xec\xb8\x13\xd3\x64\x84\x32\xca\xa2\x64\xc6\xf9\x83\xc3\x87\x8e\xc5\x46\xac\x48\x84\xdf\x9e\xb5\x8d\x42\x8f\x2d\x8e\xa0\xd0\xc7\x52\xe7\x3d\xa3\xa3\x57\x74\xea\x14\x68\xc4\xc4\xe6\x70\xaa\xb2\xc9\x14\xe7\x09\x02\x65\xd9\x4e\x52\x4c\x26\x85\x72\xc6\x5b\xe7\xcf\x85\xdd\xca\x75\xba\xc6\x11\x0b\x13\x11\x39\xa0\x02\x15\x0f\x7c\xd1\x69\xa9\x5c\x71\x04\xdc\x54\x0e\xa3\x55\xc6\x4a\x14\x83\xb0\x0a\x16\x7f\x3a\x2b\xa7\x45\xc5\x2a\x50\x94\xf0\xca\xb2\xad\xba\x65\x91\xf3\x22\xdf\x66\xf9\x6c\xc2\xe0\x9a\x72\x3c\xc4\x80\xd3\xa2\x82\x5d\x25\x42\x31\x8a\xb7\xb5\x6c\x27\xcb\x93\xf1\x2c\x65\x0e\xbb\x61\xe5\xdc\x8a\xed\x77\xcb\xc0\x22\xa3\x16\x7a\x0f\x5f\xe0\x3f\x86\x97\x07\xc4\xe9\xe3\x97\x8a\x6a\x68\x90\x17\xfc\x06\xcb\xc4\x06\xb4\xdf\xbd\xf6\xfa\x10\xa0\x30\x32\x50\x6c\x6f\x12\xd3\xd3\xc9\xb8\x6c\x45\x98\x68\xcc\xd2\xd3\x6b\x64\xdc\x96\x59\xad\x2f\x67\xa2\x58\x27\x7c\x36\x8e\x97\x34\xa4\xf8\x30\x60\xb8\x4a\x38\x56\x15\xb8\x90\x03\xc0\xd1\xf1\x3b\xd4\xc9\xea\xe3\xf8\x80\xd9\x10\x67\x13\x18\xee\x7f\x6c\x0a\x56\xb2\x98\x03\xef\xa0\x39\x85\x8b\xdb\x42\x42\x5c\x25\xa8\x0d\x74\xfb\xbe\x2d\x8c\xbb\x4e\xdc\x87\x82\x4a\x8b\xd1\x13\x33\x4b\x59\xc9\x14\x14\xb0\x3f\x67\x74\xdc\x0a\x78\xc2\x18\x83\x95\x60\xb4\xc1\x81\x62\x98\xa5\xe0\xa4\x0c\x57\xa8\x98\x8c\xb2\x57\x7f\xc0\x42\xc1\x6a\xff\x77\x97\x0a\xba\xb0\x16\x8b\xd3\xea\x56\x3c\x02\x4d\x9d\xdb\x61\x0a\x24\x80\xe2\x2d\x11\xde\x57\xc6\xd2\xb9\x68\x7e\x58\xe4\x5a\x82\xbf\x43\x41\x09\x02\x31\x80\x7e\x81\x9a\x28\x94\x37\x99\x0c\x19\x9d\x41\x5c\xe2\xf9\x14\x15\xcf\xe7\x8c\x29\x67\x5e\x20\xc7\xfe\xa8\x20\x26\x2f\xc4\x0b\x45\x0a\x9a\x4e\x33\x88\x15\xfa\x3f\x10\x04\xd4\x65\x61\xaa\x70\xec\xf0\xb5\x78\x51\x4a\x59\x81\x94\x55\xea\x4b\x91\xcf\x1e\x7d\x84\x36\xc4\x8d\x01\x31\xd5\x53\x30\xff\xad\xe0\xa8\x80\x04\x57\x78\x60\xc8\x2a\x95\x46\x78\x10\x14\x0a\x58\x75\x08\x6f\xb5\x21\x1f\xd9\xeb\x37\x52\xe0\x14\x36\x92\xf0\x3c\xca\xc4\x0d\xdc\x3d\x1c\xac\xd3\x91\x36\x24\x96\x2c\xa5\x29\x80\x32\xdd\x93\xfa\x28\xb4\x17\x62\x9b\xa6\xb7\x5d\x8b\xa8\x46\x57\xc6\x09\x6c\x82\xdf\x94\x92\x72\x58\x1e\xa4\x62\xf8\x22\x17\xe5\x6e\xb6\x27\xa1\xb3\x0f\x03\x76\x02\xbb\x10\xb6\xa2\xa6\xaa\xf3\x44\xca\xa7\x9a\x80\x62\xa1\xbe\xd1\x27\x34\x03\xe6\xc7\xa0\x23\xf8\x2e\x21\x29\xc7\xd9\x3b\x80\x37\xdc\x24\xbc\x27\xa1\x2e\xa8\x32\xe5\x6e\x83\x4b\xb2\x21\xae\x7a\x88\xb0\x4a\xd6\xf5\x9d\x6e\xd7\xe9\xd8\x72\xca\xa6\xb2\x53\x95\x35\xe5\x4c\x30\xa4\x4b\x99\x75\xa5\xd6\x42\x27\xb5\x49\x9f\x10\x2c\x65\xd0\x22\x79\xcb\x43\x2c\xed\x7a\x08\x6e\x66\xda\xc5\x52\x1a\x94\x15\x15\x22\x79\xa0\x69\xfb\xac\x2c\x59\xea\x14\x39\xe7\xb8\xe4\x85\x9a\xb3\xdb\xf1\x1c\xa8\x3e\x54\x11\x99\xcb\xd5\x13\xd0\x29\x0f\xcb\x4b\xf0\xbb\x6c\x71\xc5\x74\xb6\x9d\xbd\x50\x02\x6d\xa3\xb0\xf9\x90\xa2\xad\x27\xe0\xf3\x56\x2a\x03\xf5\x54\x5c\x4b\x1b\x3f\xe9\x16\xd4\x70\xc0\xe9\x53\x39\x7f\xda\x15\x04\x96\x6a\x7d\xa0\xd9\x2a\xd8\x78\xa9\x59\x37\x8c\xcf\xab\x69\xbf\xcf\xcc\xd9\x72\xf6\xae\xcc\x83\x64\x02\xcb\x1a\x2c\xdb\xc4\xa1\xba\x79\x7f\x75\x7f\xd7\x2d\x0e\x94\x0f\x0d\x00\x38\x63\x55\x31\xbe\xd1\x9a\x35\xc1\x34\x28\xbf\x6a\x0e\x94\xab\xe1\x87\x8c\xe5\x6b\x3c\xc7\xb1\x1a\x90\xa8\xfd\x94\xb4\x35\x27\xdf\xb8\x6f\x80\x73\xbb\x57\x71\x1b\xdc\x9b\x8d\xde\x0f\xfd\xa6\x24\x99\xe3\xa8\xc5\x82\xe3\x39\x7b\x20\xd2\x3e\x0f\x16\x52\xb1\xfa\x91\xed\x5d\x0e\x26\x7a\x76\x89\x4e\x14\xb5\xf2\x2c\xcd\xa7\x2e\xed\xd7\xe7\x44\x65\xd4\x1a\xda\xea\x8f\x7d\xb1\xaa\xb6\x57\x2b\xa4\xe5\xe2\x63\xf3\x6d\x0e\xe6\x6e\x9b\x0e\x32\x36\xda\x26\x43\xcc\xd0\x7e\x37\xf0\xf3\x64\xc9\xab\x4f\xfe\x61\xb3\xd6\x8a\xe9\x66\x1f\x2a\x30\x6c\x7b\x49\xd0\x59\x95\x8e\x9b\x37\xfc\x27\xf8\xd3\x15\x1d\x9c\x0c\xb6\x25\x79\x56\x53\xda\x74\x26\xc9\x08\x6d\x9e\xca\x59\x23\x61\x96\x5a\x35\x38\x0b\xb0\xee\xf8\xdb\x84\x05\x5a\x27\xcd\x45\x58\x20\x4d\x5a\x8c\x8b\x9c\x1d\xe4\xa9\x70\xe6\xe1\x37\x69\x31\x96\xe1\xa6\x08\x47\xaa\x2f\xe4\x0e\x72\xc0\xc9\xd9\xad\xe6\xdd\xad\xe5\xd1\xb5\x30\x32\x96\xa8\x4a\x1c\x23\x03\xd6\xcd\xf8\xbe\xc6\x35\xb4\x52\x24\xbf\x6f\xa4\x09\xde\xdf\x48\x92\x4b\xaa\xb7\x4a\x0f\xcc\x5c\xe8\xc3\x31\xdc\x25\xf7\x52\x6e\xe0\x87\xa3\x24\x09\xb4\x92\xb6\xff\x25\x92\xd2\x45\x86\xe2\xb0\xcf\x5b\x72\xde\x6f\x3b\x29\x67\x04\x7e\xd3\x94\xf5\xc3\x89\xb9\xd3\x32\x1b\x64\x9c\xbb\xc6\xeb\x8d\x5f\x89\x49\x31\xcd\x56\x28\x39\xa9\x7b\x87\xf7\x34\x57\x57\xed\x61\x64\x21\x92\x50\xb2\xba\x20\x9f\x34\x29\xc8\xf4\xb6\x0a\xb3\x89\x73\x4e\x41\x81\xfd\xbc\x6c\x1c\xac\x12\xd1\xcd\x40\xea\xc2\x55\x66\xcf\x26\x23\x99\x09\x15\xb2\x41\xa4\xa8\x5a\x9a\x34\x17\x12\xd4\xbe\xf9\x38\x1b\xb1\xf1\x5c\x58\x70\xd7\xb4\x1c\x30\x61\x88\x41\x05\x91\xa0\xc4\x61\x92\xa8\x80\xe7\x95\x70\x39\x2b\xa3\xa3\x22\xa6\x31\x27\x25\x9c\x18\x35\x6e\x42\x56\x56\x94\xda\x15\x17\x9a\x9b\x31\xa5\xf9\xb7\x69\x5f\x66\x43\xb3\xda\x3b\x58\x01\x29\xed\x53\x13\x22\x7c\xec\xac\xaa\x60\x55\xb3\x0a\x2c\x30\xcb\x2c\x4d\x59\x2e\xda\x2d\x84\x4e\x9f\x59\x07\xe2\xef\x12\xd7\x7c\x75\xb3\x31\x0a\x75\xaa\x9a\xd1\xb1\x30\x67\xe9\x6b\xf9\xea\x94\x96\x4a\x6e\xb4\x8e\x1a\x77\xd4\xf0\xd6\xa2\xc0\x7f\x98\x6c\x5f\x47\x32\x8b\x75\x63\x68\x2c\x2b\x33\xab\x56\x72\x41\x33\x96\xcc\x40\x5a\x9c\xe2\x30\xbf\x5b\x29\x0f\xa7\x49\x77\xac\xad\x61\xce\xfb\x7f\x3f\xad\xae\x41\x65\x1d\x85\xc3\x5b\xb6\xe6\xd6\x59\x47\xff\xdc\x4b\xbf\x7d\x29\x91\xd4\xfa\xc6\xf2\xc3\x39\x8c\xf6\xbb\xfc\xff\xf2\x1a\xff\x6f\xe2\x35\x1e\xc2\x19\xb4\xd1\x5e\xcc\xa2\x2c\x1e\xa4\x23\x30\xc9\x80\x77\xac\xd4\x21\xc5\x84\xa2\x44\x2b\xbd\x0c\x9d\xd7\x67\x5d\xf2\x59\x05\xf2\x4f\x7d\xcd\x6b\x3f\x05\xa9\x03\x93\xcc\xfa\x7d\xd1\x32\x3e\x60\xa1\x0f\x38\x22\x68\xd2\xb6\xe5\xd5\xee\x0b\x06\x1d\x61\xc7\x05\xf5\xb0\x0d\xdb\x9e\x0d\xa9\x7a\x31\x5d\xcb\x03\x08\x5f\x5a\xe3\xc9\x1d\xe1\xd6\xa3\x93\x6c\x76\xa3\x8d\x99\x50\x46\x89\x18\x8d\x8f\xc5\xb3\x81\xc0\xfa\xcf\x4a\x64\x28\x54\xac\x31\x78\x87\x4d\x2a\x29\xa4\xaf\x34\xea\xb2\x6f\x31\x00\x1e\xa8\x0e\xda\x1b\xea\x0d\x98\xbc\x4e\xce\x6b\x9a\x8c\x4c\xa1\xd2\xfa\x1a\x50\xf4\x80\xdf\x9e\xe9\x6c\xd2\xaa\xfa\x07\xe0\x9e\x4c\xc7\xf2\xca\xfa\x64\xc7\xfa\xb2\xe0\xd5\x56\xa2\x84\xf1\x44\xcf\x8a\x04\x65\x84\x33\x0e\xad\xb0\x48\x27\x17\xc7\x67\x07\x17\xa7\x67\xd7\xe7\xbf\xbf\x7a\x7a\xfa\xf2\xc1\xc6\x67\xea\xbd\x03\xb4\xed\x7a\x76\xf0\xf6\xb7\xeb\xd5\xb6\x36\x75\xe8\xf5\xcd\x10\x14\x54\x28\xf7\x15\x8d\x57\x53\x96\xf4\xfe\x0f\x30\xca\xfb\xef\x9a\xe4\xe9\x3e\xdf\x9c\x9e\x5d\x1c\xbc\xfc\x67\xbb\xc4\x97\x1f\x8c\x1e\x29\xf6\x78\x7e\xfc\xe6\x00\x76\x8b\x6f\x53\x6f\x53\x24\xbe\x7d\x6a\xa5\x07\x46\x0c\xd0\x63\x88\x0c\x8f\xd1\x38\x4b\x3a\x05\xb2\xa8\x2a\x84\x7b\x59\x45\xfb\xca\xbb\x84\x62\xd8\x4f\x9a\xd4\x59\xda\xd0\xda\x4b\x4f\x79\x5e\x17\xa9\x62\x8c\x37\x2f\xfc\x10\x25\x46\x92\xc5\x40\x57\x89\x05\x78\x95\x86\x1b\x81\x08\x55\x3f\x32\xb9\x41\x4c\x3b\x63\x03\x88\xc0\x27\x9e\xa5\x08\xad\xcc\xf2\x65\x51\x8c\x66\x53\xa5\xa1\xdd\x8c\x36\x03\x67\x33\xda\xd9\x44\xb1\xff\x66\x00\x9f\x7b\x9b\xa6\x63\x8b\x18\x04\x86\xc2\x77\x22\xc7\x03\x6a\xd0\x0a\x0f\x6f\xf4\x6c\x46\xf0\x9b\xd0\x3a\x19\x36\xa2\x03\x59\xe3\xb8\x84\x12\x70\x27\x2d\x2d\xfe\x71\xf3\x2b\xde\x87\xd5\xb3\x79\x83\x60\x94\x86\x0b\x56\x09\x34\x46\x39\x17\x32\x18\x4b\x9b\x1a\xd0\xfa\xe7\x0e\x3c\x24\x8c\x5a\x4a\x4e\x57\x64\x35\x9b\xe0\x1b\x80\xca\x30\x47\x98\x4c\x08\xcb\x10\x23\x7e\xa3\x88\x3b\x05\x16\x2c\xaf\x28\xd0\x95\xc2\x7a\x0f\xb2\x67\x15\x2b\xc5\xc3\x77\x9c\x6c\x3e\xb6\x17\x1e\xde\xf9\x08\x9b\x7b\xf5\xd6\xae\xe3\x81\xa7\xb0\x79\x43\xe0\xba\xa2\x03\xb1\x5c\xd8\xf5\x1d\x11\x67\xf3\xab\xee\xa3\x4d\x5f\x21\xb3\x37\xa7\xa7\x2f\xaf\xcf\x4f\xfe\xcd\x4f\xcf\xee\x0e\x82\x74\x5d\xd2\x1b\x56\x56\xec\x10\x0d\xed\xdf\x14\xfc\x2c\x39\xd6\xfb\x23\x03\x06\xc9\x2c\xbd\xb0\xcb\x7a\x13\x3a\x3d\xc3\x47\x0a\x1c\xf5\x42\x01\x71\x26\x74\x2a\x23\xf9\xc2\x87\x28\x8d\x13\x01\x59\xd9\x6a\x97\xf2\x4d\x13\x03\xe1\x37\x4a\x81\x9d\xd1\x6a\x3d\x7c\xfb\x04\x35\xf5\x76\xb6\x78\x3f\xc1\x89\x1c\x35\xcc\xf6\x72\x6a\xe8\x4e\xa4\xa7\xd1\x5e\x94\x2f\x09\x36\x28\x67\xd8\x5e\x4e\xfb\x2f\xe8\xf9\xaf\x2b\x39\x03\xc9\x8c\x08\x86\x29\x29\x01\xbb\x94\x41\x36\x5a\x07\x45\x5f\x6b\xf0\x64\x8b\x9e\x28\xd1\xac\x99\x78\xc2\xc5\xd8\x20\x91\x07\x4f\xba\x58\x9b\xa5\x35\x84\xf0\xc8\x8b\x31\x76\x9d\x35\xcb\xeb\xc0\xd9\xc1\x9b\x53\xc5\x4f\x53\x90\x52\x32\x08\xf3\xd6\x84\x93\xc6\x74\x84\x3f\xe6\xba\xed\x92\x97\xf0\x7d\xfb\xb4\xae\x8c\xd8\xa0\x75\xd9\x7a\x5f\xd6\x97\x30\xf6\xe3\x7e\x60\x75\x7e\xd4\x07\x4a\x02\x6e\x2b\x88\xce\xaa\xe1\xca\x12\x34\x63\xcf\x29\x42\xf4\xeb\xa5\x22\xde\x35\x13\x54\x97\x0c\xf4\xc8\x35\xcd\x84\xdf\x82\xaa\xd0\x91\x97\x41\x4e\x27\xec\xbc\x78\x46\x4b\x2b\xce\x0a\xbf\x49\xa6\xb4\x1e\xf2\xab\xa8\x4f\x1b\x55\xd7\x38\xe7\x62\xcc\x86\x42\x3a\x0c\x03\x76\x64\x34\x19\x0a\xd4\x09\xe1\xce\x7b\xcd\x41\x37\x8f\xeb\x5b\x41\xa7\xa0\x99\xa2\x36\x46\x82\x08\x9f\xb3\x01\x3c\x09\x0b\xe6\x0d\x58\x4f\x44\xe5\x15\x61\xcf\xad\xdb\xae\x83\x44\xc9\x12\xa8\x20\x41\xa0\x80\xc1\x9d\x58\x9c\x2c\x17\x51\x51\x67\xb1\x8e\xa3\xae\xe5\xb4\x62\x5c\x07\xe3\xb1\x5c\xce\x13\x4e\xfe\xc9\xea\x44\x2f\x9c\xe9\xfd\xdb\x0a\xb2\x80\x96\xd0\x53\x47\x86\x91\x55\x8c\x9d\xa9\x06\x69\x11\xfb\xeb\x74\xc1\x4e\xa8\x50\xb3\x8f\x1e\x39\x07\x3a\xba\x17\x8d\x8b\x1b\xe4\x65\xa7\xac\x94\xcf\xd0\x56\x00\xae\x28\xd5\x31\x58\x31\x45\xad\x6e\x34\x78\x52\xe8\x08\x98\x04\xab\x67\x84\x94\xc6\x70\x70\x41\x79\xa2\x7e\x08\x1c\xe3\x17\x0b\x43\xc3\x2c\x1f\x83\xa8\x01\x64\x4c\x16\xfb\x85\x26\x3f\x18\x23\x52\x18\x09\x15\xd3\x3a\x9b\x64\x7f\x09\x81\x1b\xf8\xb7\x83\x05\x23\x84\x5a\xa6\x49\xed\x3c\xcb\xf8\xf6\xd1\x31\xa7\x8c\xa0\xe1\x0a\x37\x0f\x83\x27\x73\x7a\xb3\x12\x01\xa3\xa5\x49\x04\xf8\x60\xa9\xe1\x1a\x0c\x91\x9c\xed\xa7\xf8\x1f\x7b\xbe\x0f\x6c\xc0\x20\x35\xe5\x46\x49\xe0\x68\x9e\x65\x2d\x04\x26\x72\x43\x4f\x84\x23\x35\x70\xaf\x18\x9e\x3b\x1b\xa7\x44\x84\x9a\x01\x79\x04\x3f\xa3\x54\xb8\x5c\x83\xfb\x3e\x27\x1a\xa7\x68\x50\x22\x09\x13\x65\x3b\x53\xc8\xa7\x97\x37\x2b\x34\x27\xc1\x18\xe6\x22\x5c\x76\xcb\x99\x18\x88\x40\xee\x8e\x63\xe0\x05\x98\xff\xa6\xb3\x6f\xd0\xb6\x5b\xfc\x72\x57\x0c\x1f\x88\xf7\xd4\xb9\xd8\xf1\x9d\x40\xd7\xf6\xad\x0b\x6a\x57\xc1\x9d\x92\x54\x84\x4a\xe1\xf0\xb1\x96\x01\x4f\x41\xc6\x8a\xc7\xf2\x50\x21\x56\xe4\x31\x67\x68\x82\xa1\x46\x6c\x3e\xa2\xa0\x23\x78\xa8\x23\x6d\x35\xad\xaf\x81\xfb\xe6\x66\x0c\xde\xd9\xb2\x48\x77\x75\x5a\xed\x87\x92\x94\x2c\x7f\x25\x9a\x76\x8b\x64\x45\xbe\xbd\xd5\x22\x5a\x31\x04\x3e\x97\x99\x92\x76\xc9\xc1\x83\x9b\x9f\x35\x8f\x35\x9b\x40\x9c\x4c\xa9\xbd\xac\x45\xdc\x8a\xee\xc7\x6a\x44\x75\x70\x1f\x46\x33\xcc\x69\x4c\xd2\x02\xa6\x2b\x78\xd2\x67\x1c\xcb\x34\xb9\x56\xe3\xe0\x5c\x36\xf2\xae\x20\x80\xae\xcc\x6c\xe3\x79\xaf\x56\x02\x71\x9b\x7d\x59\x2c\x9c\x5e\x54\x2d\x5d\x7c\xf4\xc8\xe1\x34\x37\xc7\x92\x33\xa9\x07\x02\xda\x1b\x22\x63\x60\xbf\x96\xf8\xb4\xd1\xba\xda\x3c\x96\xd7\x65\xc6\x2a\x5b\x42\x2a\xfd\x01\x9a\x94\x3d\x71\x36\xdf\xb6\x76\x85\x5a\x0c\x15\x1a\x5f\xbf\xc4\x20\x14\x1b\x73\xb0\xf4\x06\x8b\xfc\x59\xce\x3e\x4e\xd1\xd1\x14\x09\x9d\xaa\xe7\x1c\x16\xf9\x0d\x2b\xc1\x1e\x13\x4c\x46\x2a\xf6\xe7\x8c\xe5\x09\x7b\x04\xa3\x8e\xc7\x70\x89\x8f\xd8\x9c\x89\x36\x6c\x25\xa3\x88\x4d\xd0\x03\x3f\xfb\x07\x4a\x57\x3c\xdf\x50\xa4\x3a\x6d\x2c\x8c\xe9\x1f\x61\xca\x67\x95\xc9\x97\x86\x0e\x27\x32\x36\x4f\x88\xbe\xe5\x09\x0a\x8d\xf2\x55\xcd\xa6\xe6\x77\x96\x69\x7a\xd7\x71\x6e\x87\xd9\x98\x39\x5e\xc7\xe3\xc5\x8c\x26\xad\x87\xe5\xcc\x7d\x92\x47\x8c\x97\xc7\xb7\xe6\xf4\x78\xbf\xe4\x8c\xf1\xf3\xab\x5b\xf8\xaf\x1d\x34\x25\xe4\xd6\xe2\xdf\x95\x4b\xc9\x76\x42\xa3\x5a\x24\xb6\xb9\x19\xae\x9c\x05\x33\x5b\x7a\x97\xf0\xbb\x18\x80\x49\xb8\xce\x52\x27\x29\xc6\x63\x86\x94\x90\x81\x6d\x09\x0a\x22\x24\xff\x2b\xfc\x57\x10\x9e\xf8\xc7\x83\xc1\xc9\x9e\x9b\x2d\x46\x57\xd2\x00\x54\x0d\x19\x22\x70\x38\x9d\x2b\x21\x89\xd0\x62\x05\xf5\x9a\x79\x51\x0b\xc1\xaa\x61\xf1\x8d\x3b\xef\xc1\x4d\x11\x38\xff\xaa\x7c\x84\xfd\x66\x7f\x7c\x41\x1b\x0f\x08\xf2\x8b\x61\x73\xf5\xf5\x40\x3e\x2e\xf3\xfd\x40\x05\xbe\xf8\x8c\xe0\x26\x71\x36\x7d\xbe\x34\xcb\x4d\x27\x68\x74\x43\xd4\xfa\xaf\xb1\x4b\x34\x01\xc9\x92\x4b\x08\xe8\x30\xb0\x88\x74\x1f\xe6\x54\x4a\x96\xe0\xa3\x1a\x53\x96\xe0\x1b\xe0\xb4\x72\x3e\xd8\x42\x78\x0c\xd5\x03\x91\x5e\xe0\x61\x23\x20\xa6\x62\x66\xd4\x11\x24\xb6\x43\xeb\xba\xcc\xe2\x59\xcd\xaa\x40\x08\x9a\xb6\x9d\x0f\x2d\x10\xed\xb5\x78\x52\x43\x74\x7d\xff\xc3\xc3\x2a\x8d\x59\xbf\x7e\x43\x73\xa6\x32\x75\x6d\xe9\x60\xfd\xa1\x71\x2c\x50\x7a\xae\x03\xc6\x29\x2d\x84\x92\x3a\x73\xce\xc1\x98\x8c\x08\x8b\xc4\xf2\x3a\x2b\x0d\xb6\x01\xc2\xb3\x35\x9e\x04\x41\x6b\x70\x9a\x24\xb3\xc9\x0c\xdf\x3a\x87\xf8\xb8\x34\x9f\xa3\xfb\x0c\x9c\x40\xde\x8d\xf2\xfe\x91\x5c\x0f\xae\x28\xbc\xa6\xc0\x79\xd9\x1b\xba\xea\x59\x73\x0f\x87\xa6\xd4\x49\xf7\xf3\x58\x17\x8a\xb5\x9a\x4d\x35\x87\x02\x03\x53\x5c\xd6\x27\xf9\x2b\xf9\x17\xac\x88\xd5\x62\xfc\x77\x19\x27\x83\x38\xfc\x04\xa7\xd4\xe0\x46\x2c\x3d\xb7\x18\xde\x4e\x53\x7f\xf4\x69\x4e\x6d\x73\xf3\x7e\x3c\xab\x4f\xd9\xcf\x2c\xe7\xd7\x08\x73\x28\xca\x61\x6b\x11\x83\x95\x43\x16\x3a\x94\x80\xc9\xa6\xe9\xe1\x8f\x5e\x77\xfc\x16\x6e\x73\xa6\xd2\x05\x0f\x8c\xdf\x18\x61\x11\x0c\xbd\x05\x77\xee\x50\xf1\xf8\x93\x14\xc8\xaa\x46\xe4\x66\x64\xf0\xfc\x09\x3e\x82\x22\x41\x1d\xdf\x1d\xea\x5b\x95\xa5\x13\xa2\x8c\x6c\xd8\x2a\x02\xb6\xb7\x6c\xe5\x8a\xd3\x8e\x83\xd0\xab\x8e\xcb\x51\x20\x6f\xc6\x6f\x20\xe0\xcf\xf8\xea\x80\xca\x00\x4d\x35\x6e\x99\x11\xb8\x2c\x1e\x67\x79\x3a\x9e\x5b\x8e\x57\x2c\xaf\x66\xa5\x34\xab\x10\x4e\x22\x18\xfa\x36\x1e\x17\xc9\xc8\x99\x16\x9c\x41\xc9\xe8\x58\x06\x56\x3c\x3e\xc7\x50\x59\x1b\x8d\x57\x58\x54\x2c\x88\x26\x6f\xa6\x72\x4c\x85\x97\xd6\xb2\xa1\xff\xb3\x05\x57\xf8\xd8\xd3\x38\x4b\xb2\x1a\xa5\xb6\x4d\x89\xb2\x67\x55\x17\x22\x18\xe4\xd7\x26\xba\x1e\xf8\xb5\x95\x13\xe0\x79\xc5\xf3\x59\xb8\x65\x82\x37\xa9\x58\xad\x61\x16\x72\xac\x47\x60\x6d\xaf\x58\xf1\x24\xe7\x39\x88\x9e\x01\xaa\xbd\xb8\x28\x46\x2f\x18\x9b\xc2\x25\x22\xc9\x08\xcb\x27\x56\x08\xb1\x8c\x82\x20\xd7\x6a\xc8\xe7\x1a\x25\x54\xa0\x94\x0d\x14\xed\x29\x5b\x04\x83\x45\x25\x8d\x1a\xe2\xb9\x58\xe3\xdc\x9c\x00\xf5\xc5\x2a\x85\x75\xbf\xf8\x92\x92\x67\xe8\x73\xf4\xb3\xa8\x91\x51\x44\x7a\xbf\xe0\x09\x43\xe3\x12\x51\x51\x3e\xc5\xba\x3e\x9b\xe5\x89\x22\xe4\x10\xc2\x1b\x91\x3a\x39\x7a\x14\x8d\x38\x63\x46\xfb\x1a\xbb\xfe\x2d\xa9\x9b\x7a\x73\xef\x6b\xde\x71\xed\x2f\xcd\x11\x35\x50\x87\xc8\x69\x43\xdc\x76\x56\x03\x01\xcb\xcc\x55\xe4\x6b\xf4\x45\x1a\x6d\x3c\x18\xfd\x5a\x26\x09\x1b\xeb\x44\xee\x6b\x45\xff\xf0\x00\xa6\x83\xff\xde\x37\x1c\x53\xc6\xda\x7e\x93\xac\x1e\x91\x76\x12\xfa\x81\xb2\x65\xfb\xfc\x4d\xe8\xd4\x68\xf8\x24\xaf\x0b\x59\xaf\xed\x18\xc2\x1f\xcb\x7a\x52\x09\xa5\xcd\x83\x53\xb6\xcb\xd8\x1b\xa5\x5a\x05\xee\x7f\xe3\x58\x8b\x11\x4d\x40\x4a\x74\x28\x98\xa0\xcf\x3d\xe9\x6d\x62\x0f\xa3\x45\x25\xf9\x98\xd0\x29\x5f\xac\xf7\x59\x3d\x7c\x21\xe7\x71\x22\x1c\x43\xcd\x0a\x44\xac\x90\x5e\x3b\x62\xbf\xe5\xd8\xfe\x9a\xaf\x6d\x06\x63\x4e\xa9\xc5\x26\xae\x61\x38\xd1\x36\x5c\xa7\xb1\x2c\x2d\x36\xb2\xe6\xa0\xb5\x3d\x1d\x5f\x21\x27\x2e\x44\x34\x5f\x51\xc8\x47\xef\xdf\x71\x8a\x6c\x02\x4a\xd9\xe6\xc2\xc5\x8b\x38\x7f\xcc\xaa\xda\xa1\x95\x6e\xa4\x05\xbe\x15\x29\x9a\x16\x70\xd0\x0b\xc9\xdb\xac\xc8\x29\x34\xf8\x6c\x59\x2b\x01\x37\x5c\xb7\xeb\x78\x1d\x64\x7b\xa4\x64\x45\x45\xfe\x68\x94\xf5\x9d\xfd\x35\x5a\xc4\x95\x82\x5b\xce\xe6\x23\xce\xd1\x6c\x02\x77\xa3\x80\xde\xb6\x87\xe0\xbb\x8a\xaa\x0b\x73\xc1\x57\x55\x3e\xf7\x42\x8a\x3e\xe5\xc0\x68\x12\x67\x2a\x74\x84\x00\xf8\x2a\x18\x72\x43\x3d\x9d\xaa\xf3\x84\x7c\x2f\x1a\xfa\x43\x52\x03\x3c\x9a\xe5\xdb\x17\x00\xeb\x8a\x79\x7f\x21\xbe\x13\xe3\xb7\x3a\x6c\x4e\xe3\xd3\xb8\x6e\x2d\x3a\xfa\xfb\x28\x4f\x5c\xe0\x20\xc6\xf9\xdf\x79\x69\x4f\xe8\xb4\xed\xc2\x36\xf4\x8c\xf2\xc2\x06\xa3\xb0\xff\xdd\xb7\x36\xc7\xc9\x7c\xa0\x13\x3a\x55\x56\x09\x4d\x7f\xf9\xa4\xe5\xe6\x36\xe6\x63\x13\xe6\xd2\x90\x4c\x3c\x90\x2b\x06\x22\x5f\x80\x28\x4a\x70\x04\x85\xee\x8a\xbe\x12\x05\xda\x17\xff\x84\x4e\xdb\xee\xc9\xd5\x23\xf3\x85\xd7\xbc\xba\xd4\x2e\x41\x1c\xfb\xc0\x13\x2c\x11\xbd\xb8\xf3\x57\x20\x5f\x74\x58\x0a\x4d\xbb\x61\xd2\x8f\xd1\x5a\xdb\x79\xd0\x4f\x40\x28\x44\x20\xfe\xe7\x81\x14\x2e\xc4\x2f\x86\x26\xb9\xd5\xf7\xb3\xd7\x8d\x4d\x85\x2e\xdb\x18\x69\x73\x43\xd7\x73\xc2\x46\x8d\xb5\xf7\xeb\x6b\x45\x93\xd9\x91\x52\xc6\xb4\xae\xc1\xc6\x4b\x4d\x4f\x86\x9e\x78\x20\x5a\x80\x0b\x71\x03\x1e\xda\x46\x9f\x0c\xcb\x70\x86\x4e\x79\xf1\x52\x3c\x75\x50\xb2\x6d\x14\x59\x9b\xeb\xf0\x37\xb7\xab\x2e\x84\x3a\xcc\x92\x4f\x14\x0d\xad\xcd\x2a\xd1\xf6\x37\xe0\xfb\x61\x44\xcc\x5a\x98\x17\x85\xf1\x69\x81\xac\xac\xa4\xf0\x12\x04\x04\xed\x32\x59\x20\x3a\x6e\xb4\xdd\x2b\x2a\x0a\x31\xa8\xa0\x7c\x0c\xa7\xc8\x99\x6e\x08\x03\x4a\xc8\xa6\xfe\x81\x65\xe6\x5d\xb4\x84\x44\x54\x61\x1a\xa8\x1c\x32\x88\x05\xd4\x46\xd0\xaa\x9a\x4d\xe4\x90\x1b\x66\x56\x03\x56\x57\x68\x3e\x05\xb2\x3c\x0e\x2f\xc5\x8c\x97\x42\x6d\x67\x49\x54\x54\x4e\xa1\xee\x55\xcd\x8b\x38\x33\xe6\x1b\x0f\x18\xad\x47\xbd\xcc\x47\x6f\xe9\x5c\x3a\x3d\xd4\x59\x32\x1b\x83\xae\xa1\x9c\x25\x20\x70\x68\x9c\xc4\x56\x63\x5f\xfb\xb8\x9b\xfb\xa2\xda\xb1\x4f\xbc\xa9\x81\xc1\x73\x8f\x9b\x0b\xf4\x22\xdf\xa0\x0f\x66\x89\x0f\x0a\x71\x98\xaf\xc3\x5b\x4d\x1b\xf0\xcc\xeb\xa3\x84\xc0\x86\xe8\x4e\x83\xfe\xd5\xb9\x6d\x71\xfd\x31\xa6\xce\xa1\xb9\xa5\x8e\xd2\x3c\x81\x62\x00\x8c\x0a\xf4\x3e\x59\x81\x92\xc4\x3d\xdb\x88\xd3\xbf\x72\x95\x08\x73\xb2\x14\xe2\xe0\xc5\x3a\x9c\xac\xb4\x26\xd6\xe6\x7d\x18\xa5\xc6\x32\xf7\xd6\xf1\xbf\xa4\x21\xdf\x7f\x72\x54\x08\x80\x1e\xc2\x5b\xf1\x52\xe4\x84\x9b\x27\x3c\x75\xf6\x9d\x4d\xc7\xa3\x18\xe5\x0a\x93\x7a\xfd\x6c\xcc\x78\x9b\xfa\x95\xe0\xff\x7f\xef\xeb\xcb\xff\xfc\xe7\x3f\x8f\xae\x1e\x11\x41\xe3\x6e\x06\x46\x85\x71\x96\xb3\xd7\x88\xae\xb7\x9c\x4d\x9f\x53\xc2\x6a\x60\xd8\x81\x8c\xed\x10\xa3\x6a\x44\xe7\xca\xf2\x9b\x32\x20\x7c\xab\xe8\x8d\x17\xf5\xfa\x59\x2c\x03\xe1\x1a\x66\x23\x90\xda\x43\xa7\x4b\x5b\x14\xb6\x62\xa6\xd1\xb8\xc8\xa5\xa3\xe6\x72\x5d\xb5\x15\xc5\xa9\x51\x71\xad\x3b\x68\x68\xbb\x4f\xa2\x45\x89\x89\xc6\x34\x34\xbf\xc3\xd0\x21\xf8\x2c\xb6\x7c\x5e\x4b\x1c\x63\x87\x96\xa0\xbe\xa7\x0a\x90\xb4\xf3\xa2\x88\x83\x22\x23\x8f\x20\x4e\x44\xf7\x0b\x29\xe1\x2f\xcc\xa8\x3b\x3d\xf5\x0e\x67\x96\xd7\x2c\x17\x0e\xf5\xf8\xe0\x08\x70\x55\x00\xd3\x59\x0e\xd1\x43\xf0\x81\x12\x11\x68\x43\x45\x9d\x81\x58\x4a\x15\xc7\x57\x09\x2e\x10\xc8\x38\x45\xac\x97\x31\xcd\x07\x33\x3a\x60\x15\x0a\xff\xa9\x7a\xdb\x1c\x63\xa9\x7c\xfd\x48\x3f\xba\xad\x62\xe8\x88\xb9\x67\xf9\x40\xfb\x52\x2a\xcb\x76\x11\x30\xf2\xc8\xf2\xd0\xd5\x47\x40\x86\xaf\x30\x38\x5a\x15\x04\xc9\x26\xd9\xf4\x89\xf8\x1f\x70\xfd\x08\xa5\x5f\x43\x63\x58\xf4\x75\x10\xa5\x16\xab\x9e\x66\xb6\xb0\xef\x69\xe9\x83\x93\x1d\x9f\xea\xa2\xb7\x16\x2c\x9b\x01\x38\x7a\xda\x93\xd8\x68\x6d\xa5\x19\xb4\xae\x79\x76\x76\xf0\x73\xab\xb3\xb3\x1c\x1c\xa2\xb1\x67\x25\x1d\x80\x3d\xb8\xd5\xee\x3d\xfd\x37\xe1\xdc\xca\x5b\x41\x2c\x56\xb4\x3b\xbd\x91\x0f\xf3\x47\xa8\x84\x83\x83\x54\xcd\x02\x2d\xbe\x16\x5e\x6c\xcd\x6e\x8e\x30\x62\x03\xcd\x7d\xb5\x4d\xf5\xb9\x74\xde\x5b\x5f\x5c\xb9\x1b\x0a\x95\x36\x8c\x74\x2b\x5a\x83\xaf\x05\x8e\xbe\xaf\x39\x0b\x7f\x8b\x70\xa6\x36\xb6\x83\x1c\xdf\x12\x21\xa8\x6e\x1f\xac\x4c\x86\xcd\xd9\xb4\xec\x8c\x2a\xe9\xcd\xa1\x77\xa8\x15\x82\xfe\x31\x77\x80\xbe\x04\x39\xed\x10\x10\xab\xae\xdf\x1d\xbc\x3c\x39\xd2\x5d\xcb\xe8\xc0\x39\xbb\xe5\x7c\xb7\x77\x79\xb9\x29\xef\xc8\x4d\x02\x96\x14\x57\xc4\xb9\x14\xa1\x36\xe1\xf3\xca\x5f\xe7\x58\xf2\x19\x53\x78\x80\x6b\x09\xb4\xf6\x20\xe7\x12\xeb\x06\x3b\x62\xc9\x98\x62\x78\x21\x78\x7d\xdd\xd8\x1a\xc9\x6e\xae\x75\x19\x35\xcf\x86\x86\x6f\x1b\x4a\xd6\x57\xd6\x67\x28\x37\x1e\xe5\x33\x49\x84\xff\xe4\x87\xea\xed\x68\x61\xdd\x20\x42\x3f\x16\x7d\xe7\x03\xbf\xa6\x73\x71\x43\x7f\xe8\x99\x27\xdb\xa0\x33\x36\x6d\xd9\x30\x07\x40\x00\xec\x93\xbc\x5f\xd8\xf3\x15\x78\xc3\xf0\x22\x35\x90\x99\xf6\xb4\x94\x6a\xa9\x95\x0c\xcb\x41\xd3\xcc\xd5\x21\x67\x5a\x3d\x35\xdb\x7c\x92\xed\x7a\xa1\x2a\x27\xe9\x1e\x27\x7a\x30\x25\xa4\x2b\x1b\x34\x50\xb4\x4a\x17\x59\x47\xd0\x58\x7b\xfd\x50\x8a\x20\xc1\xd4\x18\x24\x89\x65\xd3\x56\xbd\xcd\xb0\x75\x0b\x04\x75\x01\xa6\x5c\x99\x70\x56\xda\x04\x5f\xa5\x11\x03\x72\x15\x94\x71\x9c\x2b\x65\xf0\x84\x4e\x3a\xcf\xe9\x24\x4b\x90\xe9\xac\x2c\xa6\xa9\x80\x40\x86\x82\x9f\x05\x71\xad\x65\x3e\x22\x88\x09\x88\x2c\x58\x89\xd0\x82\x23\xc6\xa6\x3a\x2a\xbc\x6a\x29\x66\xf5\x2d\x63\xf0\x20\x1c\xc6\xf8\xaf\x74\xbc\x76\x40\x6f\xcf\x69\xf5\x82\xcd\xdf\x56\x4c\x47\x3e\xbd\x5b\xa1\x01\x11\x9e\x15\xd8\x03\x58\x71\xf8\xf2\xd0\x33\xfb\x62\x3e\x35\x14\x7d\x59\xde\x2f\xc4\x3d\xb0\xf6\xe4\x29\x3a\xb1\x63\x3e\x06\x03\x81\x03\xa0\x45\x3b\x22\x88\xee\xc5\x26\x0e\xf6\xcd\x9c\xc0\xf8\x68\xde\x98\x46\x4e\x6e\xbd\x5a\xaf\x7b\x33\x3c\xa0\x71\xfc\x8d\xd3\x59\x17\xd3\xed\x31\xbb\x61\x63\x79\x4e\x41\x95\x8c\xc6\x7a\x3f\x72\x20\x31\x06\xbe\xe5\x6c\xfe\xb4\xe6\xb8\xf2\xc6\xd7\x40\x8b\xa2\x70\xd2\x82\x55\xf9\x66\x8d\x2e\x3b\x10\xc9\xd0\xd0\xe3\x9a\xaf\xd3\x21\x69\x87\xc0\xc0\x74\x08\x02\xc3\xd6\x16\x1e\x71\x12\x62\x0d\xa4\x28\x07\x65\x71\x8b\x11\xeb\x86\x65\x96\x8f\x9c\xa2\x14\x54\x68\xc9\x84\x18\xaf\x07\x96\xdb\xb6\x2c\x8b\x0f\x85\x0f\x89\x8e\x4b\x46\xd3\xb9\x13\x33\x96\x2b\xe2\x37\x05\xe8\x2c\xd9\x9f\xb3\xac\x84\x81\xf1\xe6\x70\xf0\x8e\x3b\x62\x73\x57\x7a\xc7\xaf\x8c\xde\x01\xb0\x00\xa2\x76\x56\x89\xe0\x0f\x09\x85\x07\x19\xab\x82\x13\xe2\x08\x93\x2a\x00\xad\x7c\xea\xac\x82\xb8\xc7\x05\x38\xef\x09\x2e\xd8\x08\xf0\x69\x3f\x40\xab\x18\x5b\xb9\x42\xca\xad\x90\x4f\x4c\x8c\xba\x42\x93\x8a\xa6\x8c\xd4\x00\x2f\xe9\xc4\x57\x89\xc4\xcd\x4a\x45\x41\x31\xd8\x5d\xb9\x24\x52\x65\xff\x82\x19\x71\xeb\x9a\x87\x05\xe0\xbf\x11\xec\xd1\x20\xef\x30\xa5\xa7\x57\xd9\xc8\x6b\x31\x14\x40\x00\x93\xa8\x69\x6d\x23\xea\xf5\x13\x8b\x19\x58\x3d\xda\xe2\xa6\x7b\xc8\xc9\x97\xda\x8c\x56\x7c\x72\xb9\xb6\x87\xab\xf6\x91\x7f\x6e\x2b\xe6\x8c\x1e\x3d\x72\xde\x56\xf8\xb6\xe7\xca\xbb\x18\xf2\xf9\x8b\xa2\xdf\x87\x03\x2c\x9e\x86\x03\x4b\x75\x9a\x24\x6c\x5a\x1b\x2a\x06\x5a\xc9\x68\x1d\x12\x74\xe1\xd9\x4d\xf1\x34\x25\xb4\xcd\xb9\x69\x15\x8a\x43\x08\x86\x38\x48\x6d\x56\xcd\x30\xa8\xd8\x10\x82\x3e\xb8\x1f\xd4\x0a\xda\xb4\x69\xa1\x7c\x30\x43\x2b\x87\x24\xbc\x1a\xc1\x20\xae\x15\xad\xda\x48\x81\x80\x4b\x9f\x22\x62\x1e\x3d\x72\x7e\xce\x84\x17\x60\xc3\xda\x47\xc6\x1f\x19\xcf\x55\x08\x48\x90\x57\x49\x0d\x85\xb4\x50\x55\xa3\x84\xe7\x43\xa9\x62\x76\xa9\xf4\xa2\x29\x8b\x09\xdc\xa1\x2b\x54\x92\x3d\x60\xdf\xbc\x48\xf5\x5b\x1f\xed\x3c\xa9\x0a\x86\x28\x0d\x45\x9b\x21\xce\x8f\xb5\x1b\x8f\x81\xfb\x38\x6a\x53\x56\xbd\x22\x70\xa5\xc0\x4a\x18\x87\xd7\x40\x4e\x60\x1f\xba\xf9\xaf\xea\x5f\x95\x25\x6a\x34\x43\x8c\x8b\x4e\xb7\xe1\x3a\x06\x65\x09\x3f\xaf\x66\x40\x62\xb4\xdb\x5c\x07\xa8\xc4\x58\x41\xb2\xc2\x91\x09\x1b\xe6\xe5\xa7\xd6\xa2\x29\xcb\x38\xce\xf1\x05\x3a\xbe\x89\x22\xfc\xaa\x28\xcb\x32\x8c\x98\xac\xf6\x08\xed\xc0\x50\x7e\x00\x01\x23\xc0\x95\x11\x16\x0c\x24\x90\x86\xec\xdb\xbe\x73\x2a\x8d\xbf\x05\x65\x47\x60\x6d\x73\xe3\x5d\xcc\x31\xac\xf4\x18\x31\x75\x2d\x04\x23\xe8\xa7\x25\xc3\x88\x7c\x12\x53\xbf\x2e\x52\xb6\x74\x72\x4e\x89\x9d\xc3\x30\x01\x1e\xc5\xe8\x71\x7b\x8b\x3e\xbc\x52\xa3\xe2\x4f\xb5\xe3\x6a\xde\xc4\x03\x11\xf5\xa1\xd0\x13\x57\x1e\xaf\xd4\x8e\xa3\x05\x15\x02\x03\xeb\xb4\x18\x36\xdb\xf8\x6b\xd5\x14\x81\x57\xbc\xd7\xfb\x82\x17\x68\xf7\xbc\x50\xe8\x81\x6f\x7d\x91\x32\xc3\xf3\xa2\xc5\x88\x20\x69\x98\x0f\x38\xad\xf7\x91\x50\x54\x36\x10\xb8\x63\x07\x2c\xd1\xc2\x8e\x46\x1f\xd6\x64\x64\x80\x64\x09\x73\x06\x46\x00\x68\x43\x28\x90\xc0\xd6\xd3\xec\x10\x9f\x30\x5e\x4d\x7a\xb4\x46\x62\xcb\x7d\xd5\x32\x32\x18\xca\x03\x1d\x3c\xbe\xda\xe5\x58\x13\x96\x70\x25\x07\x1c\x3c\x20\xab\x9d\xeb\xfc\x22\xf7\x8e\x47\x8f\x9c\xe3\xbc\x2e\xe7\xaa\xac\x7e\x44\x53\x3e\x2c\x9d\x19\xf6\x79\x95\x61\xbe\xc1\xef\xa5\xbc\xb8\x75\x6e\x99\x33\x2d\xb3\x1c\xd4\x0f\x8c\x03\x7a\xcd\x24\xea\x93\xcf\x5c\x4d\x9c\x31\xbc\xfc\x69\xc2\x84\x1e\x1b\x70\x73\x7c\x55\x5b\x1c\x43\x3e\xe1\xf3\x00\x6b\x1b\x5a\xa5\x4d\x8f\x87\x2f\xf0\x70\x68\x85\x58\xed\xee\xe0\xdb\x65\xdb\x41\x57\x17\x6f\x85\x5f\xc7\x8a\xcf\xd7\x16\x86\xc7\xb0\xa5\x85\x40\x76\x54\x49\xda\x88\xea\x50\x7a\xa5\x55\x42\x9e\x8b\x7e\x83\x4a\xc0\xcb\x7b\xac\x10\x11\x66\xc2\xc1\xf8\x6b\x6d\x11\x20\x6c\x2b\x25\xc6\xf9\x24\x35\xda\x8e\x95\xde\xc8\x7e\x6c\x39\x2b\x60\x03\x79\xb1\x1c\xc2\xdb\x0e\xd1\x8a\xa4\xb2\xcd\x10\x15\xcb\x76\xee\x11\xa8\x9b\x9a\x74\x21\xe8\xb0\x6b\x37\x59\xaa\x46\x6e\x6e\xf8\xc6\xe9\x55\x5a\x69\x44\x65\x29\x06\x50\xa5\x28\x87\xc4\x07\x92\x02\x0e\xca\xbf\xf5\x52\xa9\x96\x1a\x91\xe6\x08\xbe\x1c\xb2\x89\x06\xa9\xab\x57\xaf\x00\x9f\x07\x5c\xbb\x2b\x7a\x8a\xc6\xec\x80\xe5\x35\x63\x72\xb5\x2e\xb8\xa4\x5e\xee\xaf\x2c\x1f\x24\x81\xcc\x83\x29\x07\x30\x7e\xef\x6e\x36\xfb\x90\x4a\x54\xa1\x44\xb0\x1f\xe6\x15\xcf\x50\xe0\xf6\x03\x89\xa3\xe1\xb6\xea\x39\x6f\x2b\xa6\x49\x02\x75\xc7\xf3\x55\x4a\x9d\x0f\x66\x90\xac\x0f\xca\x2f\x6b\x73\xc5\xc7\x5b\x1c\x24\x47\xca\x18\x57\x0f\x12\xfa\xd0\x0a\xd6\x4d\x9d\x14\x20\x13\x64\x25\xe3\xa5\x86\xd6\xd3\x22\xcb\xb5\x1f\x17\x29\x51\x87\xb1\x7a\xb2\x2c\xae\xf7\xbd\xdb\x2a\x8b\x2a\x76\xe8\x5a\xa2\xb1\xd7\x9c\xaa\x1b\x1f\xe2\xeb\xcd\xbc\x2f\x7d\x0f\x41\xb9\x34\x4b\x4f\x44\x51\xe4\x61\x23\xfd\xca\x95\xd5\x90\xcc\x35\x9e\xb4\x02\x83\xaa\x79\x93\x1e\xb8\x36\xb0\xb1\xe9\xbe\x23\xc7\x28\xc2\x26\x5e\x36\xc4\xa5\x57\x9e\x4f\x9c\x6b\xc0\xcd\x4e\xc7\xbb\x6f\xfc\xde\xb5\x40\xd5\xd7\xed\xb8\x3a\xfc\xe4\xec\x6d\xba\x04\x23\xe4\x5d\x9b\x1e\x6b\xc6\x35\xd4\x69\x13\x2b\xf7\x86\xb4\x82\xd0\x2d\x26\xb2\x6f\x52\xf3\x27\x39\x92\x0d\x7c\xbe\xce\x87\x7f\x55\x1f\x40\x95\x35\xce\xf0\xf2\xfc\x60\x2b\x51\x3e\xf4\x0c\x2f\x42\x95\xaa\x21\x0e\x08\x7e\x7c\x70\x0b\x5f\xf7\x96\xd6\x1f\x22\x06\x18\xd0\xec\x60\xb3\x75\xaf\x57\x61\x5c\x32\x3a\x6a\x23\x93\x12\x5a\x27\x43\xc7\x63\x65\x29\xa7\xd4\x06\x1a\x9a\x84\x59\x81\x0b\x56\x96\x68\x38\xda\x17\xfc\x97\x0c\xb9\x30\xb7\x42\xf2\x75\xd6\xef\x4d\xb7\xab\x5b\xbd\xdc\x44\x74\xbe\x79\x65\xae\x70\x4b\x76\xd3\xc9\xad\xd9\x3f\xf6\xba\x32\x17\xb3\xd5\x7a\x58\x16\xb7\x8d\x09\xb5\x2c\x91\x44\xf4\x0a\x8e\xe5\xbb\x77\xa6\xf0\x62\x1d\x0c\x28\x5f\x2f\xf1\x84\xd5\xbd\x90\x00\x7b\xb9\x96\xb1\x7a\x30\x67\xd5\x1e\xee\xfe\x7d\x56\x0f\xdf\xa9\xb7\x32\x44\x14\x5e\xf9\x52\xec\x8a\xb1\x0e\x8c\xfe\xc2\x0a\xaa\xb0\x36\x62\xc1\x9a\x90\xc7\x6d\xb9\x15\x9c\xfd\xf6\x3c\xa1\x12\x0d\xd5\xc3\xb1\xb7\x20\x5a\x14\xde\x50\x09\xad\x18\x10\x96\xe8\xcf\x02\x7b\x07\xbe\x2f\x68\x46\x61\xc9\x1f\xf1\xd5\x16\x30\x46\x12\x11\x0f\x66\x49\xc2\x84\x27\xb0\xf1\x54\x90\xf0\x07\x8e\x19\x07\x62\x4e\xe0\x66\xb9\x10\x8e\x4a\x87\x98\x8e\x5a\x07\x8b\x4e\x17\x02\xd6\x4d\x9b\xae\x6e\x04\x81\x6c\x9b\xa3\xe1\x4a\x03\x89\xa6\xba\xc2\xc4\x99\xf0\x82\xab\x0c\x68\xc2\x6b\xee\x34\xc4\xbb\x5b\x91\xb3\xe9\xfc\x5e\xcc\xe4\x1c\xfa\x45\x39\x28\xd0\x07\xe8\x23\x68\xcd\x85\x52\x40\x0a\x49\x54\x28\xd2\x3e\xa7\x7a\x39\xc6\x71\x21\x6c\x81\x1c\x6c\x96\x03\x4b\x0c\xde\xaa\xe0\x6c\x07\x78\x67\x92\x7d\x64\xa9\x33\x9b\xaa\xd0\x94\x7c\x01\xf1\x7a\xcd\x26\xbc\x9b\xaa\xe7\x5a\x21\x45\xb5\xa6\x44\x8b\xe0\xd6\x69\x73\xcc\xc7\x25\xf8\x12\xea\x7a\xab\x73\xd5\x79\xad\x3a\x67\x59\xec\x13\x22\x7b\x63\xa0\x46\x8d\x35\xea\xce\xd6\x63\xdd\xf2\x36\x16\x06\xeb\x46\xb1\x35\x9e\xf9\xed\x6d\x6d\xdb\x43\xa5\x93\x9b\xc7\xef\x49\xc0\xf4\xb1\x7c\xed\x48\x3f\x55\xeb\x83\x1f\x24\x92\x3e\x8f\xb4\x62\x1b\x5e\x20\xe2\x85\xaa\xac\x66\x8d\x27\xf7\x2b\x1f\x4e\xc3\xa0\xa8\x03\xe7\x5f\xe2\x1a\x10\x70\x86\x10\x85\x11\xc7\x45\x2c\x71\x01\x84\xe2\xe9\x7a\x2b\x4a\x84\x7e\xfa\xc9\x9a\x56\x8f\x4e\xa7\xe3\x39\x78\x93\x12\x1d\x8a\x52\x05\x3d\xbe\x00\x7d\x1f\x18\xf4\x09\x2f\x4f\xde\x69\x56\x0d\x85\xbf\x5c\x91\x8c\xc4\x9c\x66\x55\x5d\x4c\x2c\x83\x31\x4e\xe9\xf5\x44\x33\x10\x0e\xec\x88\x5f\x94\x70\xca\xe1\x01\x32\x7c\xfd\x18\x15\x46\xea\x69\x38\xce\xc2\xa0\x19\xa4\x64\x4f\xd4\xa8\x7a\x1b\xf7\xda\x6f\x34\x5f\x24\xd1\xd1\x4c\xcf\x47\x19\x06\x84\x93\x4c\xa9\xd0\x63\x88\x0d\xe5\x78\x06\x77\x14\xdd\xef\xf8\x89\xe2\xa5\x8d\x17\x87\x20\x3e\x0a\x36\x26\x95\x1e\x02\x1f\x51\x78\x88\x08\x37\x5f\x6f\x29\x8e\x3b\x4f\x61\xd1\xf0\xfe\x49\x8a\xbc\x2f\x42\x67\x03\x12\xea\x29\xfc\x87\x98\x0e\x7c\xfb\xd8\xc7\x84\x81\x47\xae\x7a\xcb\x0c\xbc\x18\xc0\xf5\x41\xaa\xc8\x9c\x94\xdd\x40\xdb\xd3\xb2\x90\xeb\xeb\x9d\x01\x3a\x83\x38\x91\x19\x78\x0e\xf2\x2e\xc5\xf3\x4f\x43\x36\x9e\xf6\x67\x63\x67\xc2\xaa\x8a\x0e\x98\x7c\x72\xad\x2a\xc0\x7a\xd0\x5c\x09\x6c\xac\xcf\xb1\x01\x51\xf1\x8b\xc4\xa2\x55\xd8\x32\x9d\x4e\x19\x2d\x7b\xbe\xd8\x8b\x15\xbc\x69\x89\x8d\xf6\x50\x6c\xd4\x0c\xe4\xba\x22\x3b\x6a\x8a\xb8\x8c\x90\xa8\x57\x08\xee\x4d\x37\xef\x76\xd3\x2d\x71\xeb\x48\xac\xfb\x49\x8b\x97\x76\xba\xdc\x7c\xf1\xa6\x11\x9c\x63\x1d\xd7\xdb\x74\xa6\x65\x46\x68\xf5\xc6\x35\x2d\x5e\x4e\x6c\xb9\xa6\x1b\xb7\x32\xad\x59\x2a\x9f\x59\x8c\xee\xbb\xe3\x7b\x71\x96\xa7\xc2\x25\x4c\xad\xd5\xa3\x47\xce\x4b\x36\xa0\xc9\xdc\x19\x16\xc5\x48\x1c\x40\xad\xc4\x43\x13\x2f\x7c\x06\x53\x84\x2f\xb7\xbb\xec\x19\x91\x96\x8c\x17\xcf\xda\x5f\x3c\x6a\x56\x26\xce\x26\xaf\x67\xbc\x7b\xb4\xf6\x71\x23\x78\x8b\x72\xd5\xc6\x87\xff\x6f\x5c\xdc\xbe\x29\xb3\xa2\xcc\x6a\xf9\x70\xed\x57\xbb\x0a\x43\x5b\xc3\xcc\xf8\x05\x37\x2d\x19\x04\x17\xee\x39\x07\xfa\x75\x4f\x7c\x58\x32\xcd\x4a\x96\xd4\x63\x11\x6a\x21\x46\x43\x8c\x29\x85\x57\x2f\x45\xfc\x0f\x6b\x73\x7a\x9b\x06\x49\xdd\x3e\x65\x44\x98\xcd\x69\x3a\xfa\x5d\x26\x7c\xff\x51\x8a\x78\x8c\xf6\x1a\x16\x85\x06\x15\xba\x02\x46\xcd\x75\x6d\xc0\x93\x11\xd1\xbd\x01\x4e\x5a\x95\xb7\x8e\xf0\xb3\x1e\x26\x30\x5b\x5a\x7b\x21\x7c\xc1\xd9\xfe\xd4\xc9\xd6\x83\xe8\x29\xc0\x5d\x6e\xb4\x1d\x34\x5d\xd2\xb4\xfc\x6e\x3c\x62\xb0\xc6\x3e\xe9\xbf\x6d\x9d\xa4\x42\xfb\x8a\xa0\x9d\xd2\xfc\x37\xd0\xde\x7c\x81\xe9\x55\x42\x24\xa2\x3c\xa6\xc9\x30\x68\x3a\x9a\xca\x27\x58\x21\xd4\x9f\xe5\xb6\x80\x39\xc2\xf0\x3e\x90\x3f\x30\x95\xf3\x90\x81\x36\x62\xe6\xeb\x08\x4f\x20\x2a\xf5\x4e\xa0\x7f\xf2\x1a\x6f\x66\x25\x33\xf2\xac\x4f\x9e\x3f\xcb\x2b\x78\x73\xec\xfa\xa0\x9a\xe7\x89\x51\xd2\xfe\x86\x3e\x1a\x64\xd2\x3d\x98\x8a\xb7\x6c\xc2\x5a\x70\x0f\x0c\x13\xd5\xb2\x00\xfe\xe0\x3e\x04\xca\x4b\xdb\x22\xdb\xa0\xf1\x0d\x43\x85\x48\x0f\x45\x1e\xe0\x7e\xbd\xc3\x2f\xc8\xb9\xbe\x3e\x3f\x3e\x3c\x3b\xbe\xb8\x3e\x79\x7d\x71\x7c\xf6\xfa\xe0\xe5\xf9\xf5\xd1\xe9\xf5\xeb\xd3\x8b\xeb\xb7\xe7\xc7\xd7\xa7\x67\xd7\xbf\x9f\xbe\xbd\x7e\x7f\xf2\xf2\xe5\xf5\xd3\xe3\xeb\x67\x27\x67\xc7\x47\x72\x7b\x57\xd4\x99\xc1\x6a\x92\x0a\x4d\x06\x71\xf9\xe2\xb9\x60\x3f\x58\x09\x26\x31\x14\x8c\xbd\xe3\x59\x9e\x8e\x39\x42\x42\xe6\x61\x1b\xf5\xb0\x4e\x7d\x9b\x25\x10\x00\xff\xed\xab\x23\x2c\x03\xf1\x44\x1c\x47\x28\x6a\x03\xf9\x74\x05\x8a\xbb\xc2\x8d\x0d\xa0\x91\x72\xbe\x7b\x30\x8e\x67\x96\x98\xa9\x21\x7f\x68\xbd\x20\xe1\x30\xf1\xc2\xf2\x51\x0c\xac\xf4\xf9\x4b\x44\x4c\xf5\x0b\x27\xf6\x84\x76\x33\x2f\x6a\x4e\x4a\x8a\xe7\x18\x41\x07\x83\x6f\xb9\x68\xed\x4b\xbb\xd9\x62\xb0\x26\x5d\xad\xef\xf9\x30\x9b\x00\x9e\xc2\x03\x79\x74\xfa\xca\xd9\xfd\xae\xb7\xd3\xdb\x91\xef\x41\xd6\x9c\x88\x49\x99\x72\x03\x48\x1d\x0f\xd5\x18\xf0\xd6\x70\xea\xc3\xdd\xa8\x5f\xd5\x84\x6b\xb3\x64\x93\xe2\x06\xf6\x00\x5b\xdd\xfd\xbe\xb7\x63\x8c\x52\x9d\x86\x8b\x92\xb1\xe7\x45\x31\x0a\x9c\xbb\xa5\x7e\x31\xd9\x40\x10\x5f\xed\x69\x99\x99\x78\x1a\xea\x6e\xe3\xff\x27\x98\x2e\x31\xb7\x0d\x88\xb3\xab\xab\x3c\x76\x22\xc7\x53\xd5\xbb\x5d\x31\x06\x40\x41\x22\x35\xdc\xd8\x50\x63\x4d\x59\x92\xa5\x4c\x3e\xa5\xaa\x8d\x81\x04\xbb\xd8\x2f\xca\x89\x88\x69\x8d\x24\xc0\x90\x26\xa3\x39\xb0\x18\x13\x3a\x62\xf8\xb6\x76\x51\x8e\x90\x76\x04\xd7\xdc\xb3\x62\x3c\x9e\x4d\x81\x6a\xfc\x85\x55\x35\x46\xa1\x2e\x05\xbe\x13\x63\xbc\xdc\x14\x93\xd8\xbc\x72\xf6\xdb\x12\x03\x99\x18\x6e\x6c\x4c\x8a\x74\x36\x66\x3d\x1c\x51\xe5\x44\xd8\x18\x86\x18\xf6\xa4\xef\x94\xf3\xfe\xf8\xe9\x9b\x83\xc3\x17\xce\xbb\x83\x33\xe7\xe4\xf5\x2f\xc7\x87\x17\x27\xa7\xaf\x9d\xaf\x1f\x2d\x51\xef\x23\x6a\x13\xe7\xfa\xfa\x96\xc5\x53\x9a\x8c\xae\x85\x89\xcc\xf5\xb5\xf7\xd8\xf7\x7d\x90\xfb\x7e\xfd\xc8\x59\xfa\x84\x37\xf7\xcd\xce\xb7\xce\xd7\x8f\x44\x9a\xa7\x5c\x11\x71\x2c\xc4\xb9\xaf\x39\x7e\x70\x36\xdc\x59\x85\x6f\x1a\x27\xb5\x1b\xf2\x66\x9c\xff\x39\xce\x12\x96\x57\xd2\x87\xe3\x66\xf7\xbb\xde\x6e\x6f\x17\x2d\x94\x68\x52\x6f\xa7\xc5\xa4\x67\x40\xf5\x24\xcb\x7b\x7f\x54\x42\xd5\x72\x58\x4c\xe7\x25\xf0\xdf\x5e\xe2\x3b\x7b\x3b\xbb\x8f\xb7\xe1\x79\x13\x7e\x65\x3f\xa3\x09\x8b\x8b\x62\x44\x9c\x93\x3c\xe9\x29\x8f\xa0\xac\x92\xb6\x89\x60\x02\x98\x55\x8e\xe8\x3f\x05\x59\x04\x68\xd9\x9c\x57\x27\x17\x32\xd9\x0a\xe9\xc7\x9b\x78\x79\x72\x78\xfc\xfa\xfc\x18\x25\x03\xc2\x81\xa9\x2c\x8a\x5a\x50\x47\x9c\xcc\x94\xde\x3f\xa2\x23\x1d\x96\xe6\xd1\xd7\x1b\xce\xab\x22\x65\x65\x9e\xfd\x55\x3a\x8f\xf9\x81\x9a\x96\xcc\xf1\x0e\x91\xeb\x7b\x3a\xcb\xc6\xa9\xef\x2c\x78\xff\x1b\xc2\x68\x8f\xd2\xa8\x6d\x6b\x76\x7d\x32\x69\xcd\xd8\x7b\xbc\xe3\x93\x83\xd6\xac\x1f\xbe\xf3\xc9\xd3\xd6\x9c\x6f\x9e\xf8\x24\x69\xef\x68\xef\xf1\xae\x4f\xd2\x75\x79\x7b\x3e\x61\x6b\x06\xb8\xfb\xd8\x27\xc3\x75\xf5\x1e\xfb\x24\x5b\x97\xf7\x8d\x4f\x0e\xd7\x34\xb9\xeb\x1b\x01\x9d\x8f\x3c\xea\xdf\xf5\x8b\x12\x48\xa9\x38\x6a\x52\x50\xdb\xbb\x24\x89\xdc\x57\x59\x8e\x0e\x81\xc2\x43\x08\xa4\xb0\xff\xc3\xdd\xa2\x5b\x6e\xe8\xdc\x64\x55\x56\x83\xf1\x47\xf0\xe8\x51\x5f\xc0\x4b\x6f\x90\xd5\xc3\x59\xdc\xcb\x0a\x34\x04\x41\x9f\x33\xa8\xb8\x9d\x32\x0e\x34\x25\xf8\x9d\xed\x2b\xb7\xa5\xff\x7c\x7c\x9c\xba\x5b\x94\xa4\xd1\x4e\x98\xfe\x18\x87\xe9\xd6\x96\x9f\x6c\x45\xee\x7f\x3e\xee\x7d\x47\xcb\x41\x75\x79\x85\x25\x58\xce\x6b\xbf\x3d\x3b\x51\x98\xce\xa0\xe3\xd2\xad\xdd\x2b\x3f\x8c\x23\x90\xc2\x78\xc9\x96\x2b\x55\xbe\x4e\x7f\x36\xd6\x4c\x67\x01\x31\xb9\xd1\x0f\xb5\xc8\xb7\x27\x72\x7a\x9c\x99\x35\x1f\xe2\x85\xb8\x1c\xbc\xa2\x10\xd5\x01\xb3\x9a\xa6\x99\x08\x53\x25\x79\x59\xc9\x94\xf6\x5c\x3f\x8c\x41\xa9\x17\xb9\x27\x72\x5e\xce\xbb\xac\xc0\xc0\x53\x6e\x18\xf7\xe0\xf1\xde\xea\xa2\x78\x53\x4c\xa3\xdd\x10\x39\xe3\x38\x5c\x52\xba\x8f\x3e\x56\xc1\x91\xe7\xee\xed\x7d\xef\xfa\x68\xd0\x3d\xa6\xd1\x9d\x24\x97\x83\xce\x0e\x49\x69\x3e\x60\x65\x31\xab\xc6\xf3\x73\x56\x9f\xe4\x39\x2b\x9f\x5f\xbc\x7a\x09\x59\x88\xde\xde\x01\xc1\xaf\xbf\xc1\x16\x93\xa5\x3c\x25\x33\x8b\x57\xb3\x29\x3f\xe4\x15\x38\x32\xe7\xf5\x71\x8a\xcf\xba\x0a\xde\xc6\x2c\xf1\x7c\x9e\xa2\x68\xcb\xcc\xab\xe7\x63\xde\xcb\x32\x54\x80\xf4\x27\xf5\x28\x89\xfd\x3b\xa4\x86\x3d\xda\x8d\xfd\x28\x8a\xe2\x25\x62\x68\x1a\xdd\xbd\x7a\x7b\x8e\x97\xf3\x9b\xb3\xd3\x37\xc7\x67\x17\xbf\x07\xbb\xe4\xf9\xc1\xf9\xf5\xd3\xd3\xd3\x97\xc7\x07\xaf\xaf\xdf\x1d\xbc\x7c\x7b\x1c\x7c\x03\x69\xaf\xdf\xbe\x3a\x3e\x3b\x39\x14\x69\x3f\x40\xda\x9b\xd3\xf3\x93\x8b\x93\x77\xc7\x8d\xcc\x3d\xac\x71\xfa\xee\xf8\xec\xe5\xe9\xc1\xd1\xf1\x51\xa3\xc1\xc7\x7b\x90\x7f\x7e\x71\x76\xf2\xfa\xe7\x46\xde\x77\xdf\x90\x2c\xe7\x17\xe0\xd1\xe9\x2b\xc9\x4c\x1d\xc2\x0b\x35\x81\x42\xca\xd4\xbf\xc3\xa3\x51\x52\x92\x44\xb4\xf7\x46\xbd\x59\xb4\x58\xdc\x2d\x49\x1a\xd1\xde\xd1\xe9\xab\x03\x29\x72\x7f\xcd\xf7\x77\x4a\x13\x91\xcd\xda\xb2\x79\x4e\x48\x31\xe7\xd5\x0c\x7d\x29\x5f\x81\x01\x3b\x66\xc9\xe3\xd8\x87\xa7\x86\xfc\xbb\x8a\x36\xdf\x08\xea\xfb\xfb\x47\x9e\xfb\xcd\x0f\x2e\xe9\xfb\x81\xf0\xce\x03\x97\x95\xa8\xdf\xab\x8b\x97\xc5\x2d\x2b\x0f\x69\xc5\x3c\x9f\x8c\xa2\xe4\xb2\x7f\x15\x0e\xa2\x3b\x6a\x8e\x21\x18\x10\xba\x32\xe4\x00\xd8\x76\xa9\xd2\x84\x62\x7d\x32\xb1\x06\x88\x45\x26\xb3\xaa\x7e\x5b\x29\xfe\x33\xf8\x93\x7a\x23\x12\xf7\x56\x76\xd8\x27\x1b\x43\x5a\x3d\xc5\x28\xc7\x08\x99\xa2\xe8\xca\xc6\x73\x34\x57\xbd\xe6\x7c\x79\x96\xac\x94\xb4\x76\x1c\x4a\xbe\x29\xaa\xac\xce\x6e\xd8\xba\x1a\xed\xc0\x02\x55\x4f\x6f\x58\x39\x2e\x68\xca\xd2\x75\x03\x5b\x07\x4b\x50\x1d\xc3\x3b\xad\xab\xda\x06\x66\xfe\x32\xdc\xfd\x29\x1a\xf4\x1a\x4b\xb1\x05\x29\xe6\x04\x30\xa5\x7d\x7c\x06\x7e\xf8\x76\x87\x6f\x7b\xc8\x56\x81\xa2\xdb\xf5\x06\x3d\x6b\x5f\x23\x76\xd9\xbf\xf2\xc3\xf4\x21\x65\x01\x06\xa2\x14\x2a\xb4\x40\x1c\x54\xb0\xa1\x21\xa2\x50\xb8\xe2\x7f\xa2\xc1\x72\xb9\x24\x15\x8d\xee\x96\xc6\xf5\x52\x0b\xac\x90\xf5\xbd\xf1\x4a\x9b\xd4\x5f\x2c\xf6\x7e\xa4\xe2\xaa\xe9\x76\x3d\xb7\x70\xa3\x28\xa2\x97\x3b\x57\x8b\x85\x7b\x2a\x7f\xf3\x9e\xdd\x1c\xbf\x76\x79\xce\x6b\xf9\xdb\xf7\x11\xdb\x74\x76\xc3\xac\x0f\x42\x27\x8e\x72\x64\xe2\x4e\x58\xdd\x66\x75\x32\x94\xb2\xb9\xd8\xbf\x03\x85\x8e\x2b\xc2\x6e\xbb\x81\xe0\xdc\xdb\x46\xb6\x4f\xa3\xce\x4e\xe0\xc5\xd1\x8c\x7a\xd4\xe7\x9f\x71\x73\x03\x17\x0b\x48\x5a\x05\x08\x91\xb1\x06\xd0\x3c\x7e\xf2\xad\x43\xda\xab\x38\x99\xe4\xed\x90\x6f\x7d\x42\x23\x37\xa5\x35\xdd\x86\x29\x2e\x16\x2e\xbf\x44\xf0\xc3\x27\x34\xc4\xf1\x2b\x75\x8f\x1b\x60\x02\x6a\xb1\xe4\x17\xca\x7f\xe5\x17\x32\x70\x72\xae\x9d\x9d\x50\x52\xf8\x72\xe9\x96\x4b\xb5\x5b\x30\xd7\x3b\xe9\x6f\xd5\xb6\x2a\x15\xbd\xa4\x57\x80\x04\x10\xb1\xdf\x50\x8e\x17\x6f\x69\x74\x43\x57\x8f\x3f\x79\xce\x93\x57\x8e\x3a\xf9\x48\x65\xba\x75\x3a\xc9\x5c\xa5\xb7\x1f\x5f\xf2\x97\x2a\xb0\xee\x88\x92\x03\x55\xa4\xed\x28\x92\xa7\x34\xba\xd3\x18\x3c\xb8\x03\x11\xff\xb3\xd9\x78\x7c\x9e\x94\x8c\xe5\xc1\x73\x42\xab\x79\x9e\xf0\xbf\xb3\xba\x78\x56\x24\xb3\x4a\xfc\x7e\x33\xa6\xf3\xe0\x39\x49\xe8\x94\x73\x6a\xc1\x5f\x94\x24\xe2\x6a\xbd\xa5\x8b\xe7\x24\x29\xc6\x55\x30\xa7\x24\xb1\xef\xd3\xe0\x00\x93\x4a\x9e\xfd\x9c\xb8\x62\xf1\xdd\xe0\x39\xbf\xa0\x59\xc9\xff\x66\x15\x2f\x99\xf2\x9f\xc5\x6d\xce\x21\x86\xb7\x9e\x96\x74\x30\x90\x4d\x70\x4e\xe9\x75\x21\x24\x0c\x2c\x78\x4e\x86\xf0\xc4\x60\xf0\x9c\x8c\x8b\x62\x1a\x3c\x27\x93\xd9\xb8\xce\xa6\x63\x86\x83\x99\xcc\x6a\x39\xae\xdc\xac\x55\x4c\xa1\xce\x74\x4c\xe7\xd5\x09\x84\x5c\x0f\x9e\x93\x92\xd1\xf4\x34\x1f\xcf\xe1\x27\x7a\x23\xc0\x4f\x08\x3b\x01\x3f\x8b\x5b\x98\x5a\x59\xdc\x9e\x4f\x69\x1e\x7c\xa4\x64\xa3\x4a\x8a\x29\x64\x56\x8c\x4e\xc6\xac\xaa\xe0\xe7\x18\xf4\x4f\xd8\x71\x95\xfd\xc5\x78\x2d\x78\x8c\x93\xd7\xa9\x78\x5d\x9e\x30\x65\xe3\x31\x90\x25\x7c\x66\x48\x49\xec\x90\x9a\xc6\x10\x07\x31\xd8\x21\x59\xcd\x26\xe7\xbc\x7d\xbe\xf2\x60\x63\x7e\x38\xa4\x65\xc5\xea\x60\x87\x80\x08\x15\x6e\xa6\x1d\xc2\xe9\xc7\x67\x45\x09\xbf\xea\xe9\xf1\x9f\xb3\xec\x26\xd8\x21\x28\xf1\x3c\xa0\x4b\xb2\x72\xef\x06\x77\x76\x73\x2e\x7e\x6e\x27\xf8\xed\x1a\xad\xbb\xf0\xd3\x55\x7d\xb8\xfd\xa2\x74\x8d\x7e\x5c\xfe\x73\x9b\x2f\xd7\x8d\x0b\x3d\x35\xee\xf1\xe0\x0e\xc7\xa1\xc9\x08\x81\x05\x11\x49\x49\x1c\xe5\xd0\x1e\xf2\xf3\x6a\xa0\x9e\x0b\x15\x5d\x3f\x94\xa7\xba\x13\x71\x7c\x31\x9f\xb2\xc5\xa2\xb3\xcb\x11\x01\x3f\x96\xab\xe5\xf7\x69\xaf\x62\xf5\x4a\x3a\x71\xdd\xad\xd8\x0f\x28\x1a\x87\x66\xf5\xbc\xdb\xed\xe8\x8f\x5e\x4c\xd3\x93\x7c\x3a\xab\xbb\x5d\xda\x03\x1b\xf3\xa3\x22\x41\xfd\x16\x4d\xf8\xfd\x2a\xe4\x55\x7c\x0c\xdd\xee\xc6\x7d\x5d\x70\xec\x7f\x78\xff\xe1\x7b\x11\xdd\x7d\x1c\x67\xf9\x08\x57\x2f\x78\xf4\xe8\xf6\xf6\xb6\x77\xfb\x18\x62\x52\xec\x3e\x79\xf2\xe4\x11\xe4\xba\xe4\xe3\x64\xdc\x56\xe4\xb7\x57\x2f\x79\xb1\x1f\x1e\xe5\xf2\xb2\xe2\x4b\xdf\x3c\xd0\xb3\xba\x38\x43\xd8\x0d\x0e\x29\x61\x1f\xd1\x6c\xfa\x8c\x21\x1b\x59\x9d\x49\x10\x3f\xa4\x44\x3e\xe2\x79\x30\x9e\x0e\x69\x70\xb8\x06\x64\x8c\x06\x5d\xe3\xc3\xbd\xa7\x6d\x77\x6d\x96\xdb\xe8\xd4\xb5\x3e\xdd\x96\x11\x00\x2d\x19\xe0\xc2\x1d\x24\xf5\x8c\x9f\xe4\x17\x3d\xf8\x24\x98\x58\x26\x65\x31\x6e\x24\x3e\x2f\x59\xdf\x4e\x39\x5b\x29\x73\x3e\x2c\x6e\xed\x94\x8b\xac\x6e\x16\xba\x98\x4f\x75\xca\xc6\xc7\xc9\xf8\x29\xad\x20\x61\x32\xe6\xfb\xf4\x92\xe6\x03\xfd\x75\x0e\x54\x24\x7c\x2e\x97\xe4\x98\x46\x8f\x2e\xff\xb3\xfd\x9f\xe0\xca\xbb\xa4\xdb\x7f\x5d\xf9\x8f\x06\x9a\x5d\x78\x6e\x5e\x35\xfc\x2e\xef\xd5\xc5\xdb\xe9\x54\x5e\x89\xcb\x0d\x38\x9c\x79\xbd\x3d\x64\x22\xb2\x71\x36\x00\xa6\x6c\x3b\xa6\x15\xe3\xa8\xcb\xa1\x25\x8d\xb3\x64\x9b\xe3\x46\x47\x26\x6e\x57\xc3\xac\x5f\x3b\x09\x9d\xca\x8a\xc9\x38\x9b\x6e\xc3\xb3\x27\xf0\xab\x9c\x8d\x21\x54\x4a\x51\x6e\x83\x49\xfd\x54\x30\x67\x6d\x69\xdb\xfd\x6c\x5c\xb3\xb2\x12\x79\xd3\xb2\x00\x71\x05\x7e\x95\x4a\xc9\x99\x16\x93\x2c\xa7\xe6\xc8\x50\xe0\xb9\x1d\xd3\x64\x34\xc0\x68\x08\xfd\x6c\x3c\xde\x2e\xa6\x34\xc9\xea\x39\x7e\xc0\x40\xfa\xe3\xa2\x48\xb7\xa1\x41\xf1\x5b\x95\x29\xf2\x7a\xbb\x4f\x27\xd9\x58\xfc\xe6\xf8\x54\xff\xda\xa6\x29\xc4\x9e\xc3\x84\xba\x64\x75\x32\x94\x1f\xf3\xb1\x28\x28\x39\x50\xf8\xb8\xc5\xe5\x18\x8c\xe7\xd3\xe1\x36\x18\xab\xe2\xcf\xa2\xcc\x64\x3c\x97\xed\x61\x51\x66\x7f\x15\x79\x4d\xc7\x2d\x99\x37\xfc\x88\x25\x9c\xed\xe5\xa5\xb6\x69\x7a\xb3\xfd\x51\xfc\x46\x47\x98\xed\x8f\x4e\x36\xa1\x03\x66\x2c\xcd\x18\xde\xe0\xdd\xe6\x40\x0c\x9f\x7c\x08\x59\x3e\x10\x33\x9e\xd0\x72\xc4\xca\x6d\x96\xa7\xf2\xe7\x24\x53\x3f\xe1\xde\x80\x67\x61\x61\x5f\xc1\x1e\x01\x62\xa3\xc8\x94\x7a\x98\x25\xa3\x9c\x55\x95\x33\xa5\x59\x5e\x6f\x83\x23\x9e\x33\xa5\x79\x51\xb1\xed\x5d\x7c\xfb\x99\xb7\x7e\x03\x21\xf2\xd5\x98\x60\x8b\xf3\xda\xa9\x86\x74\x6a\x0e\xb5\xaa\x8b\xa9\x18\x17\xfc\x94\x1b\xc1\xa9\xa9\x11\x13\x31\x50\xf5\x30\xec\x64\x3d\x96\xaa\x2e\x8b\x11\xdb\x4e\x69\x35\x44\xdf\x10\x23\xa1\xe8\xf7\x2b\x56\xcb\x14\x3e\x89\x84\x4e\xcd\xcf\x3f\x8a\x2c\x97\xdf\x93\xac\xe6\x13\x9d\x64\xaa\x82\x31\x22\xfe\x79\x9b\xa5\xf5\x10\x1e\x00\xdb\xa6\x79\x32\x2c\x4a\xfc\x9d\xb2\xa4\x28\x85\x25\x12\xff\xd6\x33\x04\xc9\x9c\xbd\x98\x3a\x49\xcf\x60\x96\x67\x49\x91\xb2\xed\x38\x4b\x33\xf5\x51\xd2\x7c\xc0\xf8\x57\x5d\x6d\x4f\xf9\xaa\x4e\x9c\x9b\x6d\xca\x71\x56\xcc\xea\x2c\x71\x6e\xb6\x87\x34\x1f\xf0\x5e\x6e\xb6\xb3\x94\x15\x83\x92\x4e\x87\x90\x3e\xa1\xf5\x90\x4d\xd0\x31\xc5\xb9\x01\xd9\xde\x36\xeb\xf7\x59\x52\x3b\x1c\xa2\x00\x8e\xe6\xf8\x53\x81\x91\xf9\x35\x77\x6e\x8b\x32\x55\x20\x74\x5b\x66\x00\x41\x93\x22\x65\xce\x47\x79\xc8\xf1\x5a\xa1\x88\x1e\xe5\x17\xe2\x45\xf1\x35\x2c\x59\x5f\xfc\x34\x52\xab\x61\x71\x2b\x7e\xd6\x1c\xf7\xc9\xdf\xf3\x29\x73\xf8\x2d\xc4\x4f\x34\xff\x91\x57\x01\xe4\x40\xe2\x98\xe6\x03\xf8\x81\x77\x50\xaf\x9a\x8e\xb3\xda\x73\x1d\xd7\xef\x09\xf5\x99\xb7\x2a\x3d\xa0\xca\x13\xfb\x98\x92\x8d\xe7\xd4\x0f\x8f\x4c\x59\xc2\x65\x7c\x15\xed\xf0\xa4\x15\xfc\xcf\x73\xe8\xd2\x0f\x6f\x68\x6f\x8d\xac\xc2\x7b\x4a\xef\xcd\x3e\xa2\x42\x9a\xf4\x3a\xba\xbb\x4e\xe8\x6c\x30\x44\xff\x2a\xe4\xe5\xaf\x87\xb4\x3a\x34\x12\x3b\xbb\xe4\xba\x04\xc0\xbe\x6d\x94\x3a\x33\x53\x3b\xbb\x42\x74\x92\x15\x79\x70\x87\x3f\x21\xe7\x6d\x9d\x8d\x2b\x4b\x7c\xe2\xca\x0f\x4e\xca\x08\x5e\x8c\x8f\xf6\xa6\x18\xb1\x9f\x67\xb4\x4c\x59\x2a\x9f\x9a\xda\x3f\xf2\xdc\xdd\x27\xdf\xbb\x4a\xa8\x71\xc2\x99\xa5\xd6\xa2\xcb\x25\x69\x4d\xb7\x48\x2e\x92\x90\x94\x30\xd2\x27\x03\x32\x22\x43\xff\xee\x84\x0a\x8d\xf2\x6b\xa2\xb5\xc9\x6b\x1a\x3a\xc8\xd3\x43\x5a\x27\xc3\x67\x59\x59\x89\xb5\xb9\xaf\xe9\xd7\xed\xc3\x34\x35\xd8\x86\x02\x3b\xeb\x7b\xaf\x7b\xf6\xca\x7b\x3e\xc2\x4a\x19\xbd\xee\x25\x63\x46\x4b\x2b\x2f\x7c\xdd\x6b\xee\xc1\x62\xe1\xad\x26\x46\x9d\x1d\xf2\xba\x67\xed\x60\xb4\x51\xfa\xcb\x25\x11\x49\xe6\x5e\xab\xf9\xa8\x9b\xf8\x97\xf6\x05\x6a\xc0\xc8\x6a\x3d\x1c\x88\x51\x66\x49\x9a\x73\x30\x6b\xc1\xf4\x1b\x35\x70\xf6\x34\x7a\xdd\x33\x81\x34\xb4\x3f\x23\x30\x38\x5d\xa9\x1b\x75\x76\x43\x49\x4b\x2c\x01\x86\x7e\x70\xfd\xa5\x21\x9d\x3c\xa1\xed\x7b\xd6\xd2\x4e\x5b\x87\xb8\x2f\xe8\xa0\x36\x2d\x8b\xba\x00\x57\x15\x60\xdb\x51\x03\xa4\x16\x8b\x3c\xf6\xc3\xba\x9c\xdf\xc5\x62\x1d\x13\x52\xfa\x4b\xb0\x77\xf6\x72\xe8\xd0\x6a\x9b\xb4\x8c\x60\x67\xb9\xd4\xf2\x93\x5f\xa8\xb9\x5a\xe6\x46\x1b\xcb\x65\x6e\x76\xd8\xdc\x7c\x63\xc1\x6c\x38\x91\xe2\x67\x1a\x2e\x97\xbc\xa9\x17\x14\xca\x92\x97\x0d\x11\xce\x2b\x31\x84\x17\xd4\x97\x82\x49\xea\x64\xb9\xf3\x52\xe1\xb6\x97\xf4\x92\x5e\x91\x24\x7a\xc1\x8f\x6a\xca\x3e\x9e\xf6\x3d\xea\x87\xdb\xbb\x3f\x26\x86\xd4\xea\xc9\x77\x2e\xa1\x00\xf8\x9d\xd7\xf4\x32\xb9\xf2\xef\xe2\x1e\xfb\x08\xe1\xdb\x8e\xe1\x8a\x36\xcb\x7e\x0f\x65\xa1\x5c\x14\x87\x49\x14\xf7\xe0\x1a\x47\x27\x18\x39\x8a\x54\x88\x47\xc1\xa0\x30\x32\xa4\xa0\xfd\x28\xb9\x4c\xaf\xc8\x20\x8a\xc9\x28\x4a\xc3\xd3\x15\x41\xc6\x08\xc4\xa7\x4f\x9e\xb8\x64\xa4\x30\xcd\x29\xbd\x1c\x5d\x45\x7d\x68\x60\x18\xf5\x7b\xd3\x21\xad\x58\x7a\xc6\x06\x59\x55\xe3\x7d\x0a\xe8\x98\x4f\x60\x88\x1a\x13\x50\x5c\x0d\xfd\x61\xb3\x75\xe6\x77\xbb\x6f\xa8\x37\xbc\x64\x57\x1c\xd0\xfc\x90\xf1\x4d\x05\xd3\xad\x7e\xaf\x6c\x34\xb8\xef\xbd\xa1\xde\x6a\x32\x54\x24\xbc\xa2\x1f\x30\xbe\x57\xa6\x00\xf0\xc9\x0f\x2e\x49\x09\xe5\x2c\x97\x01\x2a\x6f\x04\x88\xfb\x77\xbf\xf2\xfd\x00\x54\xba\xb3\xc3\x17\x52\x4e\x11\xd2\xa3\x38\x3c\xc3\xbf\xc6\x9a\x5e\x26\x57\xbd\x94\x4d\x39\xa9\x90\x27\x19\xab\x00\x20\x5e\xd3\xe8\xf2\x8a\x9c\x72\x70\x20\xbf\xc2\xbf\x67\x00\x1a\xaa\xc7\x73\xa0\xe1\x5f\x50\xec\x6a\x57\x63\xed\x17\xf4\xde\xb3\xe2\x87\x1c\xa6\xb4\xd8\xe9\x82\xea\x7b\xb2\xb3\x4b\x12\xd8\xe1\x04\x9c\x21\xfd\xac\xef\xad\x6c\x5f\x22\x30\x65\x1a\x71\x00\x09\x5f\xb6\x14\xe8\x76\x5f\x02\xf0\x44\x51\xba\x58\x78\xf0\x1b\x47\xb9\xe7\x92\x44\x8e\x93\x60\x99\x94\xc4\x7c\x9d\x97\x71\xb7\x0b\xe3\x82\xbb\xf2\x2d\x8d\x1a\xba\xf1\xe9\x78\x36\xc8\xf2\x2a\x78\x4d\x09\x2c\x1c\xdf\xa6\xa3\xac\x9a\xf2\xb3\x8d\x37\x6d\x15\x9c\x52\xd2\xdc\xc9\x57\xa0\xd4\xad\x82\x5f\x57\xb3\x8e\x8c\x15\x0f\xce\x28\x99\x16\x15\xb8\xbf\xaf\x00\x1d\xde\xc1\xe2\x92\xe5\x7d\xbf\x81\xb1\x9c\x72\x8a\x37\x38\xa7\xab\x39\xd5\x53\x14\xdf\x5f\xd0\xa5\x4f\xde\x89\x83\xfd\x5e\xfc\xfd\x0d\xff\xea\x7d\xfc\x5d\x21\x47\xff\x2e\x56\xc2\x06\x77\x86\xb1\xb1\x90\x82\x76\x43\x2a\x3d\xe3\x2f\x68\x39\x60\x75\xf4\x1b\xf5\x52\x7e\x2d\x3d\xf0\xf2\xf4\x78\x07\x62\xdd\xa9\xbf\xd2\x1a\x8a\x14\xd5\x90\xfe\x2d\xe4\xc6\x42\x5c\xc2\xf7\xee\xf1\x8e\x06\x30\x25\x48\xa1\x52\x90\x12\xf3\x34\xdb\x83\x98\xfa\x80\xb7\xec\xc4\xd8\xd7\xa2\x97\xe9\xac\x1a\x0a\x34\xcd\x3b\x23\x34\xc4\x34\x2f\xf6\xf5\x6d\x22\x7e\x34\x5b\xd9\xbf\xa4\x57\xbd\xa4\xc8\x13\x5a\x7b\xb1\x1f\x5c\x52\x12\x5f\x69\x88\xfe\x4a\x9d\xc5\xe6\x90\xf6\xa9\x22\x12\x79\x7e\x40\xbb\xdd\x58\x44\x6d\xe7\x27\x1a\xb0\x6b\x8c\xfb\xa3\x57\x23\x8e\x95\xfc\x48\x1c\x94\x24\xa2\xbd\xeb\x54\x40\xdf\x4b\x78\x03\x90\x95\x15\x68\xa3\x54\xf2\x49\x5e\xd5\x34\x4f\x10\x67\x35\x9e\xb7\xf3\x15\x2e\x67\xd1\x4e\xc8\x7e\x4c\x94\x10\xbe\x43\x7b\x59\xc5\x4f\x12\x1d\x00\x00\x9e\xd7\xc5\x74\xca\x52\xcf\x0f\xd9\xd6\x96\x2f\x41\x85\xe3\xb6\xf4\x92\x5d\xf9\x21\xe0\xb5\xa4\xdb\x35\x80\x28\x6c\x1b\x1b\xce\xa9\x6d\x78\x32\x27\xab\xde\xb0\x52\xbc\x67\xe8\xf9\x8b\x05\xe5\xeb\x8b\xb6\x31\x45\xd9\x13\x01\xb0\x3d\x8e\xf6\xb4\xd5\x61\x6c\x48\x11\x60\x95\xf8\x41\x56\xd9\xe9\x6a\xf6\x2e\xae\x71\x16\x47\x77\x5f\x76\x9e\x8c\x6d\xf9\x43\x6c\x8b\xdc\x90\xaa\xa6\x35\x7b\x5d\xa4\x0c\x6e\xb9\xc4\x37\x23\x29\x22\xbe\x7a\x47\xbd\x04\xef\xc0\xd4\xca\x4d\xa2\xf4\x32\xbe\x0a\x69\x20\x34\x16\x4a\x55\x51\xe4\x87\xe3\x2c\x19\x29\x61\x3e\x7e\x1e\xa2\x10\x5a\xa7\x1e\x15\xb3\x78\xcc\x1a\x45\x8d\xc4\x95\x0a\xaf\x8a\x59\xc5\x8e\x8a\xdb\xbc\x25\xa9\xbd\xf0\xab\xe2\xa6\x2d\xa9\xbd\xf0\xdb\xe9\x4a\x82\x2a\xe8\xa5\x51\x27\xed\x49\xa9\xb7\xbf\x58\xa0\x42\x64\x3e\x65\x24\x8d\x3a\x9e\x1b\xcf\xea\xba\xc8\xa5\xfe\x23\xcb\xa7\xb3\x5a\x7e\xa0\x84\x59\x7e\x71\xf6\x96\x96\x8c\xa2\x76\xc4\x0f\x69\xd4\x49\x43\xf0\x39\x73\xa8\xd2\x72\xd0\xa8\xb3\xbb\x84\x73\x63\xad\x77\xb7\xdb\xc6\x95\x24\x1c\xcf\xec\x3d\xde\x75\x49\x4c\x64\x92\xc2\x39\x1b\x32\xf6\xa9\x86\xaf\x51\xac\x11\xa7\x3a\x4f\xa4\x1f\xed\x84\xfd\x1f\x5f\x4b\xbd\x56\xd8\xdf\xda\x42\x18\x19\x44\xaf\x29\x28\x63\xbb\x5d\x6f\x10\x0d\x6c\xf2\x47\xb5\xe4\x77\xbb\x1e\x8b\xfe\x4d\x3d\x46\x06\xbe\x2f\xf1\x0f\xd3\xbd\x8e\x01\xaa\x69\xb7\xeb\xd1\x98\x97\xa3\x31\xa1\xbe\x01\xf5\x93\xd8\x60\x3b\xe3\x50\xa2\x13\xba\xff\x15\xe5\x38\x27\xf6\x03\xf8\x91\xc6\x7e\x48\x01\xb3\x3e\xf9\x56\x63\xd6\xd7\xbd\x55\x3e\xc1\xc3\x33\x93\xc7\xcd\x2b\x51\x73\x80\x59\x4c\x06\xac\x96\x87\x3d\xf8\x23\x26\xd6\xe4\x82\x51\x4c\x58\xfe\xe7\x8c\xcd\x98\x48\x18\xc7\x44\xbc\xf0\x0b\x09\xbf\xf2\xac\x60\x12\x2f\x7d\x52\xc4\xd1\x2b\x5a\x0f\x7b\x25\xcd\xd3\x62\xe2\xf9\xd6\x93\x3a\x42\x55\xb6\xe7\x93\xd3\xc8\xbd\xbe\x06\xdb\x12\x19\xc0\x59\x22\x94\xaf\xdc\xad\x22\x26\xd3\x58\x15\x80\x1e\x9e\xd3\x3c\x1d\xb3\xb2\x82\x5c\xe3\x10\xff\x09\xab\xc5\x21\xe4\xf2\xf4\x4a\xdd\x0d\x97\xa7\x57\xa1\xb6\x8a\xb9\xbc\x0a\x3b\x90\xc4\xc9\x91\x18\xef\x08\xea\x13\xda\x13\xe1\xab\x8a\x94\xf9\x1c\x88\xf5\x27\xa2\xc5\x26\x02\x48\x04\x95\xca\xf1\x34\x6f\x2e\xeb\x7b\xdf\x72\x12\xa5\x57\xd3\xc1\x62\xf1\x9d\xfc\x29\x47\x91\xc2\x10\x42\xbe\xd3\x58\x81\xc3\x78\x8c\xef\x9c\xfb\x49\x94\x86\xab\x10\x59\xca\xd9\x7c\x0b\x9a\x02\xd5\x2e\x35\xdb\x35\x31\x15\xbf\x58\x1f\xbb\x06\xf4\x54\xb1\x25\x98\x9d\xc6\x57\x8b\x85\xd6\xf7\xd5\x2b\x30\x00\x96\xee\xc9\x90\xc1\x6b\xbe\xbc\xc9\x86\xce\x23\xbe\x3c\xbd\x8a\xe8\x92\x83\xc7\xe1\xb8\xa8\x58\x55\xcb\x7d\x7a\x56\x16\x13\xa8\xf0\x27\x00\xcf\x4a\xb2\x29\x43\xa0\xb8\x60\x42\x67\x49\x17\x8b\x6f\x3b\x62\x52\xdd\xee\x77\xf2\xe7\x3e\x1f\x67\x80\x7d\xf1\x16\x78\x4b\xb2\xd5\xa0\x84\x4e\x60\x94\xc2\x58\x13\x1c\x2c\x54\x6f\x55\x4c\x30\xd6\x1b\x14\x81\xbc\xc6\x4c\x60\x31\xa2\x78\xb9\xf4\x35\xe9\xf4\x2b\x1f\x5c\x5a\x38\x7c\x7c\x2e\x8e\xce\xbd\x0a\x21\xcc\x83\x47\xbb\x5d\x35\x4a\x4d\x50\xec\x53\x54\x9f\x6a\xa5\x6b\x2c\x69\x05\xc5\xd8\x70\x80\xa3\xa1\x9f\x6a\x48\x8b\x78\x47\x00\x0e\x34\x4a\x25\x62\xd9\xf9\x91\x6e\x6f\x87\x7e\xec\xa5\x9c\xff\x72\x85\x6a\x32\xe5\x14\xae\x28\xba\x13\xd2\x1f\x55\x71\xba\xb5\xa5\xca\xc6\xb3\x98\x63\x5f\x5e\xd4\xa0\xba\x6e\xd4\x50\x38\x9c\x47\x70\xbf\x25\xbd\xd4\x22\x72\xd7\x31\x46\x97\xf1\x95\xef\x27\x6d\x17\xff\xbf\xa9\xd7\x96\xce\x29\xae\xa4\x8d\x1c\xb0\xcb\xab\x74\x4e\x1e\xa9\x91\xde\x4a\x1c\x48\x1f\x38\xbc\x6e\x97\xaf\x73\xef\xba\x06\x72\x93\x37\x4a\x6e\x62\xab\xc9\x8f\x0a\x11\x3c\xbc\x55\x2d\xdd\x33\x1a\x0e\xe3\x28\xde\xff\x95\x53\x85\x70\xf0\x67\xb1\x17\x8b\xbe\x8c\xa5\x9e\xab\xa5\xa6\xdd\x6e\xd2\xed\xae\x2c\x73\x93\x59\xe8\x76\xd7\xee\x48\xb3\x28\x5c\x21\xff\xe5\xad\x30\x16\xee\xaf\xb5\x7b\xb1\x3a\x87\x79\x73\x13\x80\x23\x31\xb7\xe1\x00\x5a\x03\x02\xfa\x36\x36\x81\xf3\xa9\x71\xd9\x66\x7d\x2f\xe9\x76\x53\x9f\x06\x82\xfb\x4f\xb4\xd1\x54\x94\x92\x41\xb4\x43\x46\x11\x0b\x47\xe1\x28\xfa\xd5\x1b\xf9\xfe\x60\x6b\x2b\x1c\xf1\x6b\x59\x14\x1a\x46\xfd\x70\x18\x0e\xa3\x5f\xbd\xa1\xef\x8f\xb6\xb6\x10\xd1\xee\xfc\x38\xd8\x1e\x85\x3e\x8b\x7e\xf5\x98\x4f\x06\xdb\xdb\x32\x79\xb4\x3d\x08\xfd\x7e\xf4\xab\xd7\xf7\xc9\x48\x26\xf3\x7c\x18\x09\x8b\xa2\xa8\xbf\x58\xc0\x9f\x1e\x1d\xc3\x65\x54\x33\x5f\x52\x22\xd8\x5c\x88\xd5\x97\x0c\x39\x1d\xb8\x1e\x98\xe0\xc3\x22\x06\x2d\x32\x7e\xec\x39\x28\x74\xa2\xa8\x1f\xfa\x77\x83\x28\xd1\xcd\x49\x96\xa7\x13\x45\x83\x6e\x77\xc0\xfb\xc2\x1e\x42\x86\x58\x22\xf1\xc3\x24\xfa\xd5\x4b\xfc\x25\x70\xcf\xbc\xad\xb4\xdb\x4d\x55\x5b\xe9\x43\xda\x4a\xb0\xad\xd4\x0f\xd3\xe8\x57\x2f\xc5\xb6\xd0\x22\x53\xc5\x5a\x4a\xb7\xb6\xfc\x79\xec\xb1\xcb\xd4\xc4\x23\x0a\x3b\x25\x0d\xec\x34\x8f\xbd\xa4\x81\x9e\x62\xc1\x63\x1f\xae\x5c\x26\xea\x9d\x4e\x76\x71\x5b\xbc\xe1\x67\x4e\x72\xd8\xac\x0a\x0e\x62\x72\x5f\xfe\xf9\x28\x9b\x22\x33\x69\xdd\x1c\x00\x49\x1f\x63\x7f\x69\x54\x3e\xe6\x14\xc3\x4b\x46\x6f\xcc\xe6\x9f\x9a\xcd\x1f\x81\x19\xb2\x91\xbb\xd2\xe4\x5f\xb1\xbf\x5c\xfa\xe4\x28\x6e\x30\xd3\xc7\xb1\xe7\xdf\x75\x8e\xe2\x6e\x77\xd2\x4b\x68\xfe\xb6\x62\x47\xa7\xaf\xba\x5d\xef\x28\x8e\x80\x62\x15\x06\x97\x6e\x96\x3b\xa9\xd4\xb5\xcb\x1f\x42\xdb\xbe\x6f\x15\x0c\x5c\x30\xdc\xbc\x60\x1f\x6b\x57\x5d\x23\x47\x31\x90\x64\x67\xd1\xdd\x75\x59\x14\xb5\x10\xd2\x83\xce\x8c\x17\x14\xdf\x7d\xc1\x8d\xab\x24\x93\x7b\x79\x16\xa3\x5c\xef\xac\x67\x95\x93\x44\x42\x23\x19\xe8\x17\x4a\xe2\xe8\xac\xa7\xbb\x21\x49\x14\x8b\xed\x26\x29\x61\xd1\xcf\xb1\xe7\x93\x7e\xa4\x40\x45\x5f\x42\x49\xb7\x1b\x5f\xd2\xab\x28\x8a\xd8\x25\xbd\x82\xab\x48\x18\x2c\x26\xdb\x34\x44\x28\xdb\x0d\xd3\x1f\x39\x40\xc6\x97\xc9\x76\x8a\x45\xfb\xdb\xe9\x15\x00\x5c\xd8\x18\x4e\x24\x24\x4a\x1e\x25\xbb\x3f\xa6\xfb\xbb\xdb\xa9\x20\x60\xd5\x0a\x35\x2a\x68\x04\xc3\x07\x29\xe8\x1b\x61\xc0\x90\x41\x69\xbe\x8e\xfb\xe2\x2f\x86\xe6\x08\xc4\xd7\x25\xdf\xd3\x2b\x84\xd9\xe7\x71\xe4\xda\x58\xce\x31\xd0\x99\x93\x53\xb0\x9a\xb8\xc1\xa0\xa2\x2a\xe6\x0c\x88\x50\x58\xea\xb4\x71\xd6\xce\x2a\x3e\x76\x56\x51\xae\xa9\x66\x22\x27\x71\x74\xc7\xf9\x13\xdc\x66\xec\x1e\x7f\x5b\x42\x95\xe0\xe9\xca\x93\x30\x30\x10\x38\x38\x58\x1e\xcf\xaf\x10\x30\x25\xbc\xa7\x31\xd8\x1c\x61\xc3\xd9\x84\x9d\xd7\x74\x32\xb5\xa0\x5f\x11\x91\x2a\x7b\xb1\x38\xa2\x35\xeb\xe5\xc5\xad\xe7\x2f\x49\xda\x98\xb4\x10\x5e\x55\x17\xe5\xac\x92\x9f\x26\x1c\x9e\x6b\xb4\x0e\xee\x2e\xf6\xea\x46\x34\x84\x54\x63\x91\xa3\x18\x93\x8c\xb5\x8e\x92\x90\x46\x90\x68\x8a\x0c\x80\x31\xe8\xd3\x84\x29\xbc\xcf\x50\xa8\xb8\x22\x30\x64\xfc\xc6\xf4\xe2\x88\x5e\xb2\x2b\x7f\x9f\x37\x74\xc9\xae\xa2\xd8\x4b\xfc\xc0\xc5\x8e\x39\x93\xc9\x20\xa7\x87\x09\x51\x1a\xc8\x72\x09\x08\x42\x20\x6f\x75\xcf\x23\x81\x6a\x93\x5e\x73\x61\xf6\x57\x93\x02\xb0\xf0\x49\x7a\xb8\xc6\x60\x2f\xe8\xef\x5b\xbb\x78\x51\xce\x98\xbd\xaf\xcf\x20\x82\x8e\xe8\x7d\x15\xbc\xa2\x96\xc2\xd2\xeb\x73\x98\x55\xcb\x8d\x03\xef\x5c\xcb\x69\x09\xa7\xe7\xf9\x58\xc4\x34\x4c\xa5\x0d\xee\x4e\x73\x7a\x1d\x94\xb9\x8b\xe5\x37\xf6\x04\xf8\x16\xda\xb3\xdb\xdb\x6f\x26\x78\x7e\x20\x05\x8d\x96\x7a\xd0\x58\x01\x68\xc6\xf8\x8e\x3a\xbb\x3e\x59\xb7\xda\x2b\x8b\xe5\x2f\x49\x55\x17\x53\x63\x61\xcc\x39\xdd\x3b\xf4\x46\xbd\xfd\x95\x94\x75\x83\xc7\x83\xf4\x14\xce\x16\xb4\x64\x26\x44\x9d\x1d\x35\xfc\x4f\x6d\x97\x98\xc0\x14\xe5\x62\x2b\x9b\x61\x4a\xcc\x56\x2b\x2e\x89\x99\xdf\x02\x34\x64\x43\xfa\x9e\xd9\xda\x39\x63\x51\x5a\x8f\x13\x89\xe1\x40\xc5\x78\x98\xe0\x14\xc4\x57\xe2\x1a\x54\x18\xff\x79\x6c\xf2\x1d\x50\xe8\x39\xbf\x02\xb0\x20\x67\xa2\xce\x75\x8b\xd1\x49\x1c\x9e\xf7\xe8\x0c\xfc\x00\x21\xf0\x56\x64\xf3\x5e\x5a\xe2\xe7\xf9\x77\xcb\x44\x03\x6c\x24\x9f\x1e\xc7\x4f\x21\x67\xcb\xd9\xad\x93\x84\x07\x5e\xca\x79\x74\x99\xe7\x87\xc6\x47\x94\x9a\x5f\xe6\x3c\x23\x1a\x52\x63\x64\x07\xde\xdd\x12\xb7\xcb\x98\x3f\x6f\xca\x1a\x2d\x14\x30\x53\xc2\x5f\x38\x1d\xbb\xe4\x7f\xce\x4d\x7e\xd1\x26\x62\xa1\x1a\xe2\xe4\xa2\x18\x8b\x05\x93\x1a\xad\x46\x26\xb0\xfd\x78\xce\xd1\xe9\x8c\x28\x79\xab\x92\x11\x69\x57\x64\x38\xdc\xaa\x2f\x83\x8c\x3e\x43\x6a\x1d\x62\x93\x71\xa8\x14\x6e\x56\x96\xff\xc9\x63\x97\x4f\x50\x03\x87\xe7\x87\xbb\x3b\x3f\xb5\x0e\xb6\xdb\x6d\x0e\x13\x59\x56\x7d\xdf\xfe\x82\x1d\xea\x22\xc0\xdd\xf6\xd4\xf3\x8a\xd1\xaf\x71\x48\xa5\x78\x37\x3a\x8b\x75\xcd\x73\x63\xb1\xc4\xcc\xce\x71\xee\xa8\x4e\x97\x93\xb3\x21\xc7\x3b\x8f\xc9\x5d\x4a\x6b\xc1\x67\x1b\x8b\x7f\xf1\x65\xed\x5d\x34\xda\x03\xf5\x50\x1c\x5d\x3e\x21\xbb\x8f\xc9\xde\xf7\xe4\xf1\xde\x15\x79\x17\x47\x16\xb9\xe7\x1e\x8a\x10\x2a\x59\x91\x03\x4a\xe1\x44\xc6\x6d\x96\xa7\xc5\x2d\x79\x2f\x48\x46\xbb\x82\xa4\x01\x5f\x15\x29\x33\x89\xc3\x6e\xd7\x7b\x1f\x47\x2b\xa4\xe2\x2b\x08\x35\xc9\x87\xf2\x5b\x1c\x6e\x64\x7d\xef\xb7\xe6\x08\x38\xd5\xd3\xe8\xba\xdb\xed\xbc\x17\xf2\xea\xdf\xe3\x08\xd3\x7a\xfc\x0a\xa4\xe1\x6f\x71\xd4\xf1\xa4\xb1\x78\xa4\x70\xd9\xef\xb1\x29\x29\x35\xd3\x7b\xc2\x7d\xb9\xdb\xdd\xdd\xfb\x29\x9a\xd2\xb2\x62\x27\x79\xed\xe9\x0c\xcf\x27\xbb\x3b\xbe\x20\xf5\xff\x1d\x47\xbf\xc5\xe4\xab\xc6\x18\xbd\xce\xbb\x78\xb1\x78\x1f\x77\xbb\x3f\xfc\xc8\xff\xdd\xdd\xfd\x29\x7a\x1f\xfb\x84\x26\x11\x8a\xfc\x7a\xfd\xb2\x98\x1c\x0e\x69\x79\x58\xa4\xcc\x7b\xbc\xe7\x93\x38\x89\xee\x30\x66\x02\xd8\xad\x06\x77\x6b\x38\xf3\xe0\x4e\xb0\x26\x81\x5b\xe4\x4f\x75\x05\x57\x5a\x70\x37\x33\xa4\x7c\x9a\x13\x30\x86\x5a\xee\xd2\xad\x8b\xa9\xb9\x99\x79\xea\x12\x9e\x86\xef\xc7\x55\x15\x7e\xf1\xc5\x16\xed\xf3\xcf\x37\xb4\xaa\x99\x7b\xb5\x24\x89\x55\xf3\x61\xa3\x6d\xf6\x66\x0e\xd8\xce\x5b\x33\x66\x3e\x82\xa7\xe3\x59\xe9\xac\x0c\xdd\xc1\x81\x1f\x15\xb7\xb9\x63\xcc\x41\xfc\x7e\x3b\xe5\x3f\xb4\x6a\xc0\x20\x39\xad\x99\x9c\x83\x49\xf7\xe7\xce\x05\x6a\xb9\x64\x63\xcd\x74\x20\xfb\xf3\x26\x04\x55\xfe\x99\x29\xbd\x05\xd1\xdf\x67\xcf\x09\xab\xad\xdd\x22\xcc\xfe\xbc\x49\x61\x9d\x2f\x9f\xd5\x92\x24\x49\xd4\xd9\x35\x08\xec\x34\xc1\x3b\x54\xe8\x96\xa8\xd4\x2d\xc9\xb6\xa4\x6f\xc8\xf6\x6e\x27\x8a\xde\xc6\xca\x86\x23\xee\x8d\xd8\xfc\x10\xf0\x8c\x59\x01\xb5\x46\x02\x7f\xee\xed\x3d\xe9\x44\x91\x2a\x69\x15\xc4\xe3\x11\xa8\xa4\x15\x9d\x93\x58\x80\x87\xf9\xa6\xb0\x44\xc8\x81\x7b\x29\xab\x69\x36\x16\x97\xde\x2a\xca\xa2\x1c\x99\xd2\x9a\x72\xb4\x47\xf7\x69\x4f\xa3\x6e\x10\x0f\xc1\xe2\xe8\x77\x3a\xd6\xaf\x4d\xe3\x18\xca\x19\xb3\xc4\x8b\xfd\xb6\x79\x66\x7d\xef\xf1\x1e\x2c\x06\x78\xf7\xdb\xfa\xa6\x84\xd3\xc9\x92\x73\x4a\x74\x75\x8d\x37\x64\xfb\x34\x8a\x61\xc8\x84\x46\x51\x44\x93\x6e\x37\x49\x84\x5c\xbb\xb1\x3a\x0e\xd2\x51\x7a\x9f\x87\x89\xd2\x12\xf7\xa5\xf2\xb1\x65\x22\xa8\x3d\xeb\xbc\x8b\xbb\x5d\x01\x19\xfb\x1e\x8d\x9e\x71\xd6\x5d\xf0\xbb\x68\x26\x60\x32\xfa\x2a\xc5\xe2\xc1\x21\x11\x16\x94\x50\x21\xec\x6c\x59\x47\xc4\x85\x81\xb5\x1c\xad\xab\xd7\xf1\xe2\x5e\x52\x97\xe3\x17\x6c\xbe\x58\xc4\x3d\x3a\xae\xc5\xaf\x09\xab\xe9\x0b\x36\xf7\xf9\x6f\x51\xa0\xdb\x95\x05\x50\x56\xdd\x4b\x86\xb4\xec\x76\x77\x7f\xc4\x5f\x92\x92\x92\xaa\x5f\x48\x0c\xa1\xa0\xb5\x39\x6d\xb7\x8c\x2c\xb2\x6c\x1d\xf1\x1a\xa8\xf8\x2a\xc6\x4d\xc2\xbd\x5b\xb3\x53\xa0\x78\x4e\xa2\x3b\x6d\x77\x13\xc4\x49\x43\x51\xd6\x34\x31\x14\xc4\x20\x1f\xfb\xbb\xd8\x8f\x83\x4f\x40\x2a\x22\xd9\x00\x05\xa1\x71\xd2\x6b\x62\x6d\xa1\x1f\x8d\xd7\x4f\xa8\x59\xed\x38\x4f\xef\xad\x24\x50\xe0\x4a\x3d\x4c\x97\x55\x97\x7d\xa1\xfa\x12\x76\x50\xc9\x3e\xc0\x5e\xc2\xf9\xee\x96\x1e\xfd\xc0\x44\x36\x11\x78\x9f\xec\xed\x3d\x01\xde\x58\xa0\x9a\x96\x8a\x30\x43\x3f\xec\xef\x7b\x5f\xc5\x3c\x3b\x59\x2c\xfa\xfc\x40\xae\x16\xda\xef\x47\xcd\xf4\xe3\x3c\xed\x76\xfb\x09\x28\x5f\xf9\x61\xf0\x03\x4f\x1e\x87\xd4\x3e\x0b\x28\xe5\xe2\x27\xda\xf7\x49\x3f\x3a\x8f\x35\x2d\xeb\xf5\xc5\xae\x11\xb6\xdf\x07\x50\x88\x36\x58\xe0\xb1\x88\x25\x5e\xe2\x13\x21\x74\x85\xb1\x63\x2e\xf3\x7d\x72\x10\x7b\x7d\x9f\xb0\xa8\xef\x07\x42\x22\xec\xd1\xe8\xdf\xf1\xfe\x00\x57\x28\x18\xe2\x5f\x7f\xdf\x8b\xa3\x0b\xb3\xb3\x38\xe9\x19\xa4\x90\xec\x19\x41\x30\xa2\xbc\xdd\xd8\xf7\x03\x41\x6d\x22\x28\x5e\x32\x12\x5f\x2d\x97\xe4\x8f\x04\x4f\xef\x48\xfc\x1d\x27\x0d\x31\xe6\x24\x91\xda\x90\xe8\x3d\x78\x40\xde\xfd\x91\xb4\x93\x82\x7f\x24\xbd\x92\x41\x00\xfa\x43\x74\x74\x1b\xb3\xf4\xbc\xa6\xb5\x69\xb1\xb6\xfb\xe4\x1b\x17\xa9\xd5\x38\x7a\x47\x3d\x43\x01\xe9\x87\x6b\xeb\x9b\xc5\x88\xb0\x10\x88\x7d\x34\x56\xcc\x13\x69\xbf\x81\x1a\x3d\x55\xf3\x79\x51\xe9\x18\x28\x96\xdc\xea\x8f\x24\xa2\xa6\x49\x68\x01\x33\x1c\x25\xfb\x63\xfe\x7f\xc9\xb7\x04\xe3\x24\xba\xa4\x57\xc1\x88\x97\xd6\xb8\x75\x9a\xa0\xb0\x74\x94\x48\xf6\x78\x94\x90\x38\x1a\x27\xe1\x38\x89\xc4\x22\x86\xb0\x66\x80\x65\x7c\xcd\x07\x5b\x6c\xf0\x24\xf1\x38\x0f\x2c\x26\xf1\x67\xb2\x5e\xa1\x9e\x27\x52\x61\x0e\x6b\x71\x86\x2b\x14\x14\x09\x11\x8b\x05\xc9\x27\xfd\xd7\x8c\xa5\x2c\x0d\xa6\x89\xc9\xe8\x94\x89\xe9\x8b\xef\x50\x2f\x46\x0d\x7e\x65\x5f\x7e\xb5\xbe\x30\x2a\x65\xad\x22\xea\x86\x15\x5c\x59\x75\x39\xbf\xb3\x33\x96\x22\xe4\xed\x1d\x34\x46\xf8\xc2\xe0\x6c\x66\x49\x74\x07\xfe\x13\x18\xa8\xa0\x66\xf2\x6f\x9d\x4d\xe0\xb7\x2b\x3f\xb6\xc7\x45\x42\xc7\x2e\x4f\x63\x13\x9a\x8d\xf9\x8f\x49\x91\xd7\x43\xfe\x03\xbd\xde\xf8\xaf\x29\xad\xaa\xdb\xa2\x84\xd8\x05\xe0\x7f\x00\x91\x07\x18\x2d\x13\x28\x58\xb3\x31\xfe\xf9\x58\xc3\x5f\xd1\xcb\xac\x84\xe4\x5b\xc6\x46\x10\xa0\xc0\xd0\x6e\x26\x86\x5d\x44\xb7\x4b\x7b\x79\x91\x32\x54\x4b\xe9\xdf\xb6\x67\xae\x24\x32\x94\x15\x4a\xbc\xdf\xe9\xcc\x92\x4b\x84\xc6\xab\xc0\xb2\x41\x89\xf7\x3b\x3b\x41\x67\xd7\x50\x52\x2a\x92\x05\x45\x86\x8b\x05\xed\x55\x65\x22\xa4\xfc\x8b\x05\x32\x60\x21\xed\x25\x45\x89\xaf\xdf\xa4\x59\x3e\x78\x5b\x49\xaf\xbb\x6e\x17\x4c\x63\xd6\xe4\x2a\xb6\xff\x31\xe8\xf7\xf9\x04\xf8\x9d\xb2\x6f\x9a\x21\x04\x14\xb6\xe6\x63\x62\x33\x9b\xde\xc7\x44\x73\x94\xf6\x9b\xce\xdd\xee\x9a\x8c\xde\x90\x56\xcf\x18\xe5\x94\x6c\xb7\xdb\xd9\xe9\x44\xeb\x5a\x30\x0a\x7a\xae\x4b\x5c\xd7\x37\xe3\x8d\xcc\x35\xcc\x75\x8c\x31\x2d\x16\x71\xb7\xdb\xf1\x5c\x9a\xa6\x70\x11\x4a\x51\xb8\xc9\x09\x1b\xde\xde\x71\xe4\x16\xb9\xbb\x45\x85\x55\x05\x48\xa2\x64\xb1\x30\x59\x2c\x3c\x63\x7e\x56\x08\x30\xcf\x4d\xb3\x1b\xd7\x27\x89\xed\xc9\x18\x13\xa1\xbc\x0f\x79\x5e\xd4\x86\xe6\x92\xcb\xf8\xca\x0f\x3b\x49\xb7\xfb\x91\x23\xc2\xdb\x21\x63\x63\x71\x33\x79\x6b\x57\xd3\x5a\x0b\xbc\xe1\x7b\x58\x93\xb8\x8f\x7b\x3b\x7c\x69\x56\x6d\x38\xfe\x32\xe1\x14\x5f\x28\x90\x41\x35\x22\x0d\xa8\x7e\xb7\x6b\x18\x47\xd9\x60\xdb\xed\x7a\x2e\x78\x27\xc7\xc5\x47\x80\xcc\xc5\xc2\x2d\x69\x9a\x81\x7b\xbd\xa5\x54\x3d\x30\xfa\x82\x7e\xf7\x5d\xe1\xd6\xec\x06\xd2\xbd\x53\x61\xa9\x01\xab\x0d\xa1\xf9\x11\x3c\x21\x3a\xad\x39\xa6\xb3\xe4\x84\x5a\x98\x1c\xfb\x24\x8d\x5c\x77\x8b\x5e\xc6\x60\xec\xd2\x59\x11\xbc\xc7\x7e\xfb\xa5\x92\xf0\xce\xd6\x65\x55\x4c\x69\xa9\xda\xe3\x21\x72\xda\xe9\xce\x88\xf2\x98\xf4\xf4\x07\x49\x40\xaf\x30\xc3\x9c\xce\x0e\xb1\x14\x86\x0a\x67\xc2\x00\xb4\x70\xc8\x5f\x92\xaa\xa1\x58\xc4\x99\x85\x30\x1c\x53\x8a\x04\x6a\xc1\xbb\x01\x13\xa1\x58\x56\x9b\x4e\xa1\xad\x46\xae\x6a\x10\xc5\xd5\x17\x25\x4d\x46\x59\x3e\x30\xab\xd3\xde\x35\xec\x08\xe4\x31\x61\xd9\x9f\xb2\x31\xab\x99\xc3\x57\xd8\xb2\x06\x7f\x8a\xb8\xc7\xae\xb2\x58\x78\xcd\x46\x00\x00\x0c\x69\xdd\xa1\xbc\xf7\x3b\x54\x1f\x37\x65\xe4\x60\x56\x85\x0d\x35\x82\x2d\x88\xa3\xd8\x93\x33\xf7\x7c\x21\x8c\x75\x5d\x61\xc2\x84\x00\x46\x7b\x02\xc2\xf6\xdd\xba\x9c\x31\x37\x70\x21\x8c\xa6\x8b\x3e\xca\x33\xe6\x87\x54\x9b\x36\xd1\x4e\x14\x25\xfb\x5e\xdc\x93\x2b\xe6\x51\x9f\x74\x76\x7c\x8e\x67\x79\xeb\x47\xfc\xd2\x19\xc2\xe5\xf0\x30\xde\x1d\xca\x36\x18\x76\x48\x7b\x08\x97\x0e\x05\xe1\xd7\x38\x4b\x46\xfc\x07\x44\x08\xe0\x3f\x80\x04\x5b\xe5\xda\x91\x53\x3f\x67\xe2\x31\x79\xd1\xbd\xc5\xaf\x1b\xc8\xf1\x38\x51\x46\x21\xd1\xb9\x41\xe8\x1d\x25\x3d\x9c\x24\xca\x28\xfd\x10\xd1\x42\xe4\x62\xaa\x1b\x16\x9c\xbc\x0c\xc1\x74\x42\x5b\x2e\xc3\x8b\xb0\x82\xbe\xfb\xb9\x49\xdf\x3d\x87\x7d\x06\x53\xc2\x70\x12\x7b\x9d\x5d\x03\x06\x4e\x0c\xa4\x00\x06\x65\x7c\xab\x0f\x13\xd3\x76\xda\x10\xef\x6a\x84\xee\xaa\x35\x42\x93\x4c\xc9\x7d\xc1\x48\x7e\x05\xda\xc3\xbe\x86\x7e\x4d\xa2\x79\xe2\x09\x34\xc6\xb1\x56\xa7\x55\xce\xb9\x58\x3c\xf9\xb1\x5d\x00\x6a\xd0\x3c\x67\x9c\x42\x7b\xc6\xe9\xf7\x67\x09\x88\x08\x92\x21\x20\x5c\xcf\x2d\x72\x19\xd2\x46\x2c\x17\x39\x4f\x7c\xbe\x22\x62\x71\x8c\x99\x9f\xc3\xcc\x05\xe2\x03\xbc\x6a\x46\xc3\xe9\x76\x4f\x12\xef\x67\xe0\x59\x68\x74\xcc\x7f\x12\x4a\xe0\x92\xf7\x49\x9d\x78\xcf\x13\xb0\x8b\xd1\xdb\x79\xa1\xb6\xd3\x95\xa0\x02\x8d\xee\x7b\x7c\xb0\xe4\x59\x12\xc5\x7c\x18\x09\x79\x96\xf4\x68\xfd\xa9\x11\xfb\x0a\x16\xc5\xb5\xc3\x1b\xd1\x43\x7f\x2b\x0f\xae\xdb\x02\x70\xd2\x62\x56\x4a\x7c\xac\x6f\xc5\x63\xc9\x0d\xc3\x59\xea\xa6\xdf\x35\xb6\x18\xcc\x8c\x1b\x15\x62\xa3\xfc\x7b\xbb\xfc\x89\x69\xc2\xdb\x0e\x22\xd8\x00\x30\xc8\xbf\xd9\x0c\xf2\x51\x42\xae\xb3\x0a\x9a\x80\xc5\x39\xc7\x07\xda\x59\x1a\xfc\xfa\x40\xd6\x39\x8a\xf7\x4b\xce\x09\x05\x42\xfc\xde\x8f\x98\x41\xf9\xb1\x75\x94\x1f\x1f\xbc\xb6\x37\xee\x9b\xa6\xc8\x7d\x7e\x31\x65\x63\x98\x02\xc3\x60\xb1\x68\xcb\xf0\x4b\x12\x8a\x77\xb6\xbc\x9b\xc4\x63\xbe\x9f\xf5\xbd\x5f\x13\x7f\x10\xbd\xc7\x8c\xbb\x41\xf4\x36\x01\xac\x38\x8a\x2e\x12\xc1\x0a\x1b\xc3\x21\x1d\xdd\x4f\x27\x6a\xc6\x72\x5a\x2c\xf4\xa5\xde\x91\x3d\x77\xbb\xe2\x66\x57\x29\x8b\x85\x37\x88\xde\xa1\x99\xb9\xb0\x34\x86\xed\x50\x87\xf7\x38\xf1\x06\xa8\x37\x1a\x75\xbb\x23\x8f\x12\x50\x68\x35\x80\x0b\x59\xd5\x18\x40\x3d\xee\x5d\x8b\xc7\xfd\x81\xe9\x58\x2c\x98\x9d\xe0\x73\x02\x3a\x51\x2c\x58\xb7\x2b\x43\x57\x44\x7a\x94\x1e\xe5\xb7\x1b\x13\xef\x50\xc1\x93\xdf\xab\x31\x2c\x3a\x51\xb4\x41\xf9\x9e\xb4\x86\x99\xe0\x87\xcb\xe0\xdf\x7e\x4f\xbe\x48\x9b\xf3\x7b\x42\xee\x6e\x32\x76\x8b\x66\x09\x28\x4b\x34\x35\x3b\xff\x4e\xa2\xbb\x83\x71\x1d\xb8\x28\x5e\x72\x89\xe0\x2d\x03\x57\x88\x9e\x5c\xf2\x8a\xd5\x34\x70\x85\x54\xca\x25\xe7\xc3\xac\x5f\x07\x2e\x44\x1e\xe0\x09\xc6\x18\xbf\x32\x30\xe9\x8a\x92\x59\x09\xa7\x06\x8c\x63\xb3\xac\x9f\x89\xf5\xdc\x5f\x4d\xe2\x9c\xa9\x47\xa3\x7f\x27\x9c\x7b\xdc\xef\x74\x38\x17\x69\xf1\x1a\x34\xd5\x04\xc6\x57\x06\x31\x19\xa7\x0f\x5b\xa5\x8d\xdf\x13\x7b\x9d\xe2\x94\xdc\x55\x10\x14\xe7\x37\x5c\x2a\xfc\xf8\x5d\x98\x8a\x8c\x33\x96\xd7\xbf\x99\x1f\x22\x67\x4a\x07\xec\x37\xfd\x53\x96\xc7\xb5\x13\x2d\x89\x95\xc2\x2f\x5c\x67\x11\x58\x0c\xd7\x14\x3f\x9a\x6b\x10\xd0\x94\xa0\x73\x80\xb4\x5d\xe1\xbf\x85\xed\x4a\xc9\xc6\xb4\x66\x69\x8b\x01\x98\x11\x69\xc5\x28\x02\xa4\x50\xbf\x2c\x26\x82\x31\x00\x64\xaf\x99\xb3\x7d\x4e\x51\xcb\xe0\xbd\x56\x41\x4e\xde\xa1\x3b\x75\x92\x46\x77\x93\x62\x56\xa1\x39\x59\x70\xd7\xb4\x76\x0c\xa4\xf3\x03\xe4\xbb\x2d\x7a\x25\xc8\x3d\x95\x4a\x23\xfc\xba\x61\xa5\x7b\xb5\x24\xd0\x30\x98\xa8\xdd\xd3\x30\xe4\x7f\x5e\xc3\x4b\x92\xa6\x16\x82\x4d\xd2\x4f\xa2\x51\x81\xc7\x75\x33\x92\xed\x69\x2e\x69\x62\x2d\x14\x62\x7b\x35\x14\x8c\x21\x63\x37\xd4\x31\xee\x00\x65\x25\xcf\xa2\xb4\x87\xb8\x3a\x8a\xa2\x74\x3f\x0d\x3c\x9e\x62\x45\xa7\xf1\xf7\x99\xb4\x44\x79\x97\xb1\x5b\x8e\x91\x90\xe9\x7d\x0f\xf5\x04\xaa\x0f\xad\xfe\xf1\xe6\xa5\x51\x4c\xe2\xc8\x8b\xa3\x96\xc1\xab\x1d\xf7\xf7\xff\x8c\xa5\xfd\xae\x1f\x08\x77\x39\x90\x85\x45\xd1\x46\xbc\x32\xe0\x7e\x24\x9c\xd1\xf6\x59\x80\xf4\x12\x8b\xa4\xe3\x1a\xa4\xc4\xd2\xd8\x2d\x4e\x0d\xaa\x2e\x49\x7b\x7a\x97\x09\x45\x94\x3c\x10\x94\x1d\xe4\x8c\x61\x7f\x79\x1a\x9a\x1c\xf5\xc3\x81\x3d\xea\x88\x85\x49\x7b\xa3\x00\x73\xd2\x3e\x20\x31\x1b\x65\x00\x8d\x3c\x4d\x35\xd1\x68\xb4\x1f\x3e\x8d\xe1\x8a\x00\x41\x90\x10\x1c\x0e\x48\xc2\xa1\x87\xa5\x11\xa5\x5f\x10\x7d\xb9\xb7\x12\x86\x5a\x63\xc9\x7e\xaa\xe4\x24\x9a\xd9\x95\x61\xcc\x0c\xc5\xce\x3e\x0d\xda\x18\x42\x50\xf2\xe8\x77\xf6\x16\x0b\x0a\x31\x38\x83\x86\x4b\xe1\x20\x35\xd8\x6a\xd8\x4d\xc3\x58\x17\x2c\x7a\x63\xc3\x84\xdf\x8f\x23\xf3\x13\x6e\xef\xac\xef\xed\x74\xa2\xc8\x8b\x7b\x18\xc0\xe2\x82\x0e\xba\x7b\xea\x5a\xdd\x0d\x57\x1b\x01\x33\x7a\x23\x85\xdc\x57\x7f\x69\xc8\x73\x62\xf0\x67\xd8\x0b\x1e\x6b\x4c\x3e\x4c\x35\x36\x03\x49\x80\xed\xfd\x02\x72\x50\x7f\x7f\x2f\x8a\x22\x98\xa9\x75\x3b\x64\x50\x77\xaf\x23\xf2\xc0\x15\xf6\x87\x1f\x94\xd7\x8f\xb1\x4a\x7f\x98\xab\x64\x9b\x0c\x2b\x66\xcf\x89\xb1\x19\x02\x23\x6d\x36\x46\x76\x21\x55\xe8\xac\xa4\xe5\x5d\x12\x51\x92\x46\x71\x18\x4a\xaa\x2c\x31\x56\xa5\x1f\xb1\x7d\xa6\x3b\x0b\xe4\x79\xeb\xb0\xc5\xa2\x23\x6d\x93\xb3\xbe\xc7\x7a\x10\x0c\x15\x0c\xad\xf1\xd9\x56\xe5\x33\x31\x88\x44\x66\x38\x40\xab\xec\x41\x14\x45\x4a\xa8\x99\xa5\x1e\xf3\x09\xec\x3a\x4f\x4f\xed\xf4\x38\x1c\x44\x83\x5e\x95\xc5\xe3\x2c\x1f\x2c\xe5\x74\x96\x59\xdf\x33\x06\xd9\x89\xa2\x54\x7f\xf9\x49\xc4\x48\x1a\xf5\x25\x59\xd7\xd9\x55\x33\x1d\xa9\x91\x8c\x70\x24\x23\x18\x09\x2f\xb4\x13\x26\x11\x0b\x79\x35\x98\xd2\x52\x64\xa6\x22\x33\x85\xe3\x2c\x33\x47\xd1\x48\x8d\x89\xaf\xc5\x00\x27\x3b\x92\x73\x6f\x6f\xbe\x0f\xad\xac\x69\xbe\x0f\xfd\xaf\x36\x3f\xd8\xdf\x30\x64\xf5\x3f\x3c\xe1\x6c\xa9\x61\x7b\xce\xa7\x8e\x91\x39\xb4\x0b\xee\xf2\x31\xe7\xcc\x01\x4a\x1b\xfb\xaf\x24\x5a\x5a\x7a\x2f\x7d\x7d\xf9\x48\xf7\x69\x60\x98\xf8\x8c\xc4\xd1\x07\xb0\x0b\x4d\xb1\x83\xa3\xec\xc9\xe4\x91\x0d\x95\x63\x53\xac\x1d\x9b\x62\xd3\xb1\x29\x0e\x85\x2e\x90\x83\x86\xf8\xab\xf7\x0c\x30\xbf\x48\x55\x07\x3a\x06\x36\x04\x21\x0c\xce\x6f\x27\x96\xcb\x82\xfd\x75\x8c\xe3\xbb\x58\x18\x1f\x51\xf3\xee\xb2\x4e\xfa\x52\x35\x63\x0e\xc0\xc0\x0d\x7c\x28\x72\xfd\x4d\x55\xa3\x71\x16\xc7\xff\xb5\xc5\xe9\x76\xbf\xe9\xc8\xec\xff\x53\xd7\x89\xcf\x7c\x02\xae\x52\x7a\xc5\x72\x0b\x7b\x19\x2e\x39\x69\x81\x63\xf4\xef\x68\x0f\xec\xa9\xeb\xa2\xac\x94\xb3\x37\x9e\x08\x40\x53\x18\x7b\x20\x8a\xc3\xc4\xc4\xe3\x89\x89\xae\xc2\x24\xd2\xc0\x0f\x68\xce\x02\xf5\x22\xaf\x69\x96\x33\x78\xbe\x5c\x38\x02\xe3\xb2\xb5\xf6\x1c\xfd\x19\x7b\x89\xbf\x44\x8f\xb1\xd8\x17\xdd\xef\x84\xc9\x8f\x66\x71\xa1\x42\x4a\xb6\xb6\x7c\x40\xcb\x32\xe3\x32\xb9\x22\x45\xea\x71\x62\x75\xfa\x92\xdd\xb0\xf1\x05\x88\x5d\x09\x35\x19\x0d\x10\x51\x98\x09\x3e\x6a\x83\xa6\x69\xd4\xd9\x21\x45\x2a\x43\x67\x68\x97\x48\x58\x45\x9e\xdd\x31\x04\x3d\x6f\xa5\x30\x43\x9e\xef\xfd\x84\xf6\xc6\x20\xa7\xf7\x12\x12\x93\x32\x35\xde\xfe\xa1\xbe\xdf\x70\x73\xab\xd2\xb6\xfa\x42\x0e\x77\x4f\x03\x7a\x73\xcb\x54\x89\x15\xa6\xa9\xf4\xba\xbe\x45\x73\x0c\x5c\xc6\x50\x84\x80\x4d\x16\x0b\x23\x7a\xa2\x92\x1b\xc3\xb9\x10\x17\x64\xe2\x83\x96\x00\x28\x3c\xbe\x4b\x93\xd4\xb2\xbe\x4c\xa3\x49\x2a\x2c\x2e\x53\x6b\x71\x23\x1a\xa6\x96\xe5\x79\xcc\x0b\x68\xdb\xf4\x24\xa4\x51\x8a\x9c\x3d\x8d\xee\xcc\x9a\x01\x25\x46\xbd\x20\x26\xba\x56\x90\x10\xb5\xa5\xc1\xe5\xd5\x12\xd4\x6e\x75\xe2\xe5\x10\xe5\x43\x2a\xdc\xec\x5d\x46\xb9\x9e\xb5\xaf\x32\xc9\x18\x8e\x48\x69\x42\x52\xb4\x43\x76\x77\x7e\x52\x73\xee\x76\x27\xca\xd7\x70\x29\x0c\x15\xea\xb4\xa9\x9c\x1c\xb0\xda\xb9\xc6\xd0\x76\x06\xb3\x39\x4d\xc1\xdf\xd2\xb9\x1e\x82\x83\xed\x85\x18\xa2\x2e\x50\xa0\xbc\xfb\xb9\x95\x6d\x71\x68\x45\x1a\x51\x28\x73\x8c\x8d\x07\x7f\xa6\x24\xab\xe4\xc7\xaa\x00\x9d\x77\x59\x97\x74\x8a\xf6\xd4\xa8\x30\x0a\xde\x42\x92\x90\xe2\x8a\xb4\x2a\x25\xd2\x9b\x00\x13\xca\xd4\x54\x93\xce\x52\xd3\x7f\xff\x6e\x19\x82\x62\xcf\x14\xb9\x5c\x71\x1c\x69\x89\x85\x92\x4b\xf7\x3d\x8b\x47\x59\xed\x6e\xd1\xab\xc8\xbd\x15\xbf\x01\x5f\xbc\x2a\xfe\xc2\xd4\x09\xff\x01\x49\x93\x0a\x53\x5e\x9d\x8b\x84\x53\xfc\x2e\xdc\xad\x66\xcb\x4a\x11\x84\x81\x75\xd3\xe8\x8e\xe6\xd9\x04\x98\x3e\x96\xa7\xc1\x2c\xf5\xdc\x03\x99\xe0\x12\xfd\xfb\x38\x4f\x5d\x9f\xa8\xb2\xf8\xb2\x68\x56\xe4\xeb\x6b\x9c\xc8\x22\x66\x3d\x8c\xd3\xba\xb6\x0e\x1a\x96\xf8\x7c\x91\x73\x34\x98\x90\x83\xba\x50\x29\x2e\x31\x3e\x60\x58\x4b\x72\x9b\x46\x77\x4b\xf2\x91\xff\xdb\xd4\x41\xa6\xf7\xeb\xe8\x7a\x10\xc9\xd0\x9c\xa8\x6d\xcc\xba\x58\x78\x42\xf9\x71\x93\xf6\xcc\xa5\xd2\x1f\xa4\xa5\x80\x5a\x9f\xfb\x8b\xc1\x72\xe8\x4f\xdf\x9a\x5a\x73\x20\xba\xbe\xb5\x3c\xc6\x97\xa5\x02\x4d\x85\xa4\xf6\x36\xbd\xa4\xca\xe5\x1c\x3e\xe0\xbe\xb8\x31\x93\xa9\x50\xbe\x40\xa2\x19\x1a\x27\x46\x5f\xf4\x96\xc8\x37\x90\xfd\x31\xb5\x1a\x8e\xe2\xcb\x44\xba\x4f\xbb\x2e\x82\xd8\x5f\x29\x20\xa8\x83\xb8\x28\xeb\xc0\xa5\xfc\x8f\x4b\x78\x82\x01\x59\xc1\x3c\xf5\x5c\x73\x71\x5d\xce\xd6\x5b\x09\x56\x15\x05\x5a\x76\xc5\x4c\x43\x9c\x59\x5d\x27\x5b\x8d\xa0\x7d\xa9\xd5\x40\x85\xe0\x67\x56\xc6\x24\x22\xc4\x96\x81\x1b\x8f\x67\x25\x7c\x1e\x82\xb3\x45\xe0\xa2\xd3\x85\x4c\x82\xf8\xcd\x3c\x8d\xf3\x89\x66\xe2\x05\xc6\x70\x54\x79\x22\xa6\x23\x16\x41\xd5\x92\xd4\xb3\x10\x29\xfd\x0e\xdc\x04\x84\xe0\x98\x50\x54\x10\x30\xb8\xa8\x44\x09\xdb\xe6\xd7\x35\x8c\x8c\xe4\x7a\x35\x2d\xb6\xac\x42\x7a\x62\x2b\x66\x56\x56\xb9\x99\x30\x3e\x85\x82\x79\xcd\x3e\xd6\xaf\x58\x3e\xe3\x45\xe0\x63\xc2\xf2\x99\xc8\x9c\xf2\x99\x17\xd3\xb9\x4b\x36\xf8\xf7\x8c\xf7\x37\xc3\x2e\x8c\x20\x21\x81\x9b\xc6\x63\x3d\xaf\xa3\x92\x0e\x02\x37\x2d\xe9\x40\x7d\xc2\x74\x78\x8a\x9c\x07\x26\xd6\xac\x94\xc9\x20\xe8\x92\x19\x1f\xb3\x5a\xa4\x7f\xcc\x6a\x95\x8c\x42\x2d\x48\x47\xf9\x86\xcc\x38\xbd\x91\xed\x14\x37\x46\x33\x62\x81\x78\xba\x5e\x99\xa3\xb2\x98\xf2\xb4\x62\x8a\x9f\x33\x84\x23\xb9\x5f\xa9\xf8\x36\xf6\xed\x78\x32\xad\x33\x88\xcd\x8b\x3f\x30\x31\x4f\xca\xf9\xb4\x86\x64\xf9\x53\x64\xa4\x98\x98\xca\x04\x08\x61\xe7\xc2\x43\x20\x90\x80\xb1\xc1\xdd\x3e\x68\x75\x88\x54\x73\x04\x42\x7a\x4f\xb4\x6a\x25\x70\x47\x6c\x9e\x16\xb7\xb9\x4c\x04\x8b\x47\x48\x9d\xa2\x01\xb9\x54\xcb\x40\xda\x0c\x67\xf4\x12\x02\xc7\x1f\xd1\x9a\x06\x2e\x06\x91\x07\x9b\x56\x99\x85\x89\x46\xc9\x57\xac\xa6\xa9\x51\x7a\x22\xbe\x55\x11\xb1\x8c\x3c\x57\x2c\xe3\x86\x69\x93\x1b\xa0\x70\x48\x8d\x53\x05\x78\x11\x19\x93\x42\xec\x94\x94\xa7\x89\xf4\x42\x4c\x56\xc9\xf4\x64\xba\xdc\x42\x11\xfe\x45\x24\x8b\xd9\x81\x4d\x68\xe0\x4e\xc1\x34\x14\x13\x66\x15\x24\xcc\xc4\x21\xc2\xe3\xaa\xce\x2a\xff\xcc\xf2\x01\xa6\x64\x39\x82\xe4\x9b\xb2\x18\xe0\x5a\x4e\xc5\x2f\x48\x3e\x83\x47\xfe\x10\x10\x4a\x5a\x33\x03\x08\xce\x93\xb2\x18\x8f\x03\xb7\x82\xbf\x98\xc4\xd8\x88\x6f\x75\x05\x7f\x55\x12\x74\x56\xe1\x0f\x91\x68\xa9\xd4\x02\xa1\x1c\xb2\x81\xec\xbc\xa6\x63\xd0\x34\x57\xf8\x03\x13\x67\xd5\x94\x5f\x96\x6e\x85\x3f\x20\x51\x19\xfe\xa2\x0d\xd1\x89\x82\x9a\x8b\x6c\xc2\xe4\x61\xaf\xb3\x09\x33\x4e\xf9\x45\x31\x18\x8c\x79\x32\xfc\x15\x49\xb3\x64\x28\x11\x5e\xcd\x3f\x0c\xac\x07\x99\x70\x66\x21\x47\x75\xcd\x3f\x70\x6b\x21\x1d\xb7\x76\x43\xe6\x08\x40\x81\x2c\x7d\xe0\xac\x8b\x1d\x70\xb3\x75\xd5\x01\x6a\xb6\x53\x78\xad\x77\xc5\x78\x36\x51\x9b\x71\x03\x5f\xc6\x72\xbd\xa7\x10\xcc\x35\x70\x6f\xf1\x07\x26\x0e\x19\x9f\x0c\x9a\xc9\x2c\xc9\x01\x10\x10\x4f\xd3\x68\x87\x1c\xa6\x91\x8b\x42\x2f\xe5\x29\x7b\x72\xe4\x6e\x79\xae\xbb\x65\x45\x8c\xd1\x51\x62\x34\xad\x77\x04\x97\xae\xa0\x68\xb5\xdf\x97\x7d\x7d\x8a\xf8\x74\xe4\x10\xc3\x12\x5d\x1e\xa6\x57\xd1\xd3\x74\x6b\x8b\x1c\xa4\x97\xf0\x75\x15\xdd\x2d\x15\xa5\xa6\x12\x35\x93\x73\x9c\xca\xe7\x94\x42\xb0\x30\xeb\x67\x65\x85\x4f\x26\x86\x10\x20\xc6\xf8\x56\x9a\x74\xc3\x23\xdb\xa2\x47\xa1\xad\x90\x1a\x51\x0b\xd2\x30\x41\x5e\xfb\x31\x18\xc2\x4a\x8b\x2f\xff\x2e\x8d\xe8\x56\xd2\x33\x9c\xc6\x25\xc3\x98\xf5\x3d\xfa\x63\x14\x77\xbb\xe9\x4f\x2a\xe6\xfc\x1d\xaf\x17\x24\x04\xa3\x11\x07\xf1\x36\x5d\x02\xcf\x42\x03\x1c\xb8\xe8\x23\xe9\xe5\xec\x63\x7d\x8e\x9c\xb7\x7f\x97\x44\x56\x82\x8c\xb3\xb4\xe4\xe9\xda\xde\x6c\x29\x23\xdc\x2c\x61\xfc\x89\x19\xab\xeb\xe7\xf4\x4b\xcd\xef\x9c\xb8\xdb\xf5\x0c\x1b\xbc\x6e\x17\xce\x8c\x30\x7c\xc2\x60\x75\x96\x21\x1e\xc0\xa2\xd4\xe0\x37\x5e\x64\x10\x6a\xe6\xe7\x69\xf4\x50\xff\xab\xdd\xdd\x9f\xda\xfd\xaf\xc8\x49\x1a\xdd\x21\x1a\x78\x98\xf5\x09\xe2\x10\xdb\xfa\x04\xd3\x1e\xe4\x23\xa2\xee\x78\xcb\xf2\xa4\xcd\xe0\x44\xa1\x75\x47\x63\xe0\x4f\x1a\xa2\x90\x5f\x52\xe4\x17\x5f\x88\xbf\x2f\xc5\xdf\x57\xa9\xed\x50\xf2\x5a\x33\xe2\xaf\x52\x8c\x0e\x14\x45\xbf\xa4\x8b\xc5\x2f\x69\x27\x8a\x52\xea\xf9\x2b\x2a\x92\x24\xfa\x25\x0d\x35\xca\x44\x6e\x22\xcb\x9d\xa4\xdb\xfd\x99\xc3\xc9\x7e\x12\xdd\x21\x07\x92\xf4\xec\x52\x84\xa3\x4e\x23\xf1\x38\x4f\x97\x42\xbf\xd3\x1b\xb0\x5a\xcd\x68\xdf\x4b\xa2\x96\x64\xcf\x27\x09\xe7\xa4\x92\x61\x81\xd1\x89\x92\x9e\xfe\x20\xf8\xf3\x14\x4f\x82\xcc\xc1\x4f\x02\x37\xbb\xa8\xa2\x7e\x63\xaa\xaa\x60\x7c\x2d\xfd\x40\x02\xbf\x04\xdb\x97\x69\xb7\xcb\xa8\xf7\x32\x25\x89\x8f\x82\x22\xef\x65\x1a\x25\xc4\x36\xee\x39\x49\xc5\xe4\xc8\x8b\x94\x60\x1c\x42\xa1\xae\x11\xe6\x07\x8a\xa3\x8f\x7e\x49\x09\xd8\xf8\x10\x2a\xa0\xf8\xd4\xd6\xe5\x9d\x7c\x5a\x97\xd7\xa6\x60\x53\x40\x1d\x3c\x81\x10\x54\xca\x94\x34\x0d\x1a\x7a\x37\xd2\x07\x0e\xc5\xeb\x47\x1d\xe6\xfb\x77\x34\xb8\x63\xd1\x51\x8a\xe1\x4d\xce\x68\x4f\x42\x73\xa8\xa5\xf2\x3b\xe1\xe0\xc7\xbe\x44\x47\x03\x19\x09\x6d\x14\xf5\x2f\x07\xc8\xed\xac\x3c\x63\x34\xf2\x17\x8b\x0e\xbb\x1c\x5d\xf9\x77\x10\xf9\x54\x62\x9a\x25\x84\x51\xe5\x3d\x2f\xb3\xbe\xd7\xb7\x40\xac\x69\xe4\xd1\xe6\x87\x82\xf6\x37\x81\xb4\xcd\x30\x70\x04\x5b\xc1\x11\xbf\xa4\x11\xe3\xc7\x20\x96\x67\x20\x14\xf1\x51\x6c\xbf\xa5\x97\x69\xf4\x22\x8d\x7e\x69\x2f\x62\xb8\x3b\xbd\x02\x37\xf9\x46\xbe\x71\x9e\x9b\x4e\x52\xda\x27\xcb\x81\xb3\x47\x5e\xa7\x1e\x2a\xf2\x64\xb1\xe6\x41\xe6\xd3\x7a\x9e\x0a\x41\xe3\xc6\xaa\xbb\x56\xbb\xc7\x97\x23\xda\xb5\xe4\xaa\x86\xf9\xc2\x9b\x07\x1a\x0f\x34\x4c\x2c\xde\xa4\x44\xcb\x2e\x5e\x4b\x55\x1c\x61\x63\x3a\xad\x58\xca\x09\x1c\x61\x1f\x50\xb1\x59\xaa\xb4\xec\x4d\x6f\xdd\x5f\xbf\xac\xf3\x5f\x53\x72\x97\x8c\xb3\x69\x5c\xd0\x12\xe9\xe7\x55\x63\x00\xd7\x2a\x20\x1d\xc5\xec\x5a\x02\x97\x58\x89\x56\xe8\xaf\xb3\x07\x8e\xaf\x69\x58\x71\x96\x92\x3b\xdb\x5a\x41\xcc\xdc\x08\x89\x61\x89\xb1\xa5\x6f\x1d\xe7\x42\xc1\x45\x09\x07\x8c\xb6\xe1\x22\x89\xec\xa0\x4e\x7e\xf7\x31\x5e\x90\x1e\x8d\x76\x1f\xfb\x7e\x40\xa3\x58\x99\x89\xef\xfd\x18\xd1\xc5\x02\x4a\xd0\x7d\x1a\xec\x20\x0a\xb9\x48\xa3\xbb\xe3\x2a\x09\xdc\xe3\x2a\xa1\x53\xe6\x12\x78\xc4\x23\xa6\x65\xe0\x3a\x2e\x79\xc9\xfa\x75\xe0\x1e\x94\x65\x71\xcb\x7f\xba\x84\x53\xf2\xf0\xf9\x76\xea\x92\xb3\x6c\x30\x94\xd9\xf0\xdb\x25\xc8\x4b\x40\x0a\x40\x1e\x39\xe2\xc4\xdc\x11\x08\x48\x5c\xf2\x3e\xcb\x03\xf7\xf4\xdc\x25\xc8\xa9\x9a\x47\x80\x1c\x4c\xa7\x55\x23\x49\x92\xeb\xf8\xf7\x65\xc1\x39\xd3\x57\xc5\x5f\x6f\xca\x2c\x87\x73\xfa\x82\xcd\x03\xf7\x6d\x9e\xa5\x2c\xaf\xe1\x05\x47\x77\x49\xde\xa6\xd1\xdd\x0f\x81\xfb\x94\x26\x23\x8c\xcf\x4f\x9e\x04\xee\x05\x8d\x5d\xb2\xbb\x17\xb8\x87\x63\x46\x4b\x97\xec\x3e\x0e\x5c\x61\x95\xb1\xfb\x5d\xe0\x82\x05\x8f\x4b\x76\xbf\xc7\xfe\xcb\x62\xec\x92\xdd\x1f\x02\xf7\x60\xcc\x53\x9f\x04\xee\x1b\xe4\x4b\xf6\x76\x02\xf7\x90\x4e\x2b\x1c\xc9\xde\xf7\x7a\xd1\x1e\xef\xc1\x72\x3d\x7e\xcc\xcb\x0e\xf8\x01\x26\x8f\xbf\xc1\xdf\xb8\x0c\x8f\xbf\xe5\x3d\xa6\x2e\x79\xfc\x5d\xe0\x3e\x2f\x26\xbc\xce\xf7\xd6\xca\x3e\xfe\xc1\x58\xd9\xc7\x4f\xec\x65\xfd\x66\xc7\x5a\xd4\x6f\xbe\x0d\xdc\x93\xbc\x62\x9c\x38\xff\xe6\x3b\xbd\xbe\xbb\x7c\x8e\xcf\x76\xf9\x8f\xc7\x81\xfb\x6c\x8f\xff\xf8\x26\x70\x9f\x3d\xe6\x3f\xbe\x0d\xdc\x67\xdf\xb8\x64\x63\x97\x4f\xf9\xd9\xb7\x3c\xe9\xfb\xc0\x7d\xf6\x1d\xff\xf1\x43\xe0\x3e\xfb\x9e\xff\x78\x12\xb8\xcf\x7e\xe0\x6b\xb5\x13\xb8\xcf\x9e\xf0\x1f\xbb\xbc\xc5\x1d\xfe\x0b\xda\xe6\x8d\xef\xf1\xc6\x77\x79\xeb\xdf\x7c\x13\xb8\xaf\x67\x13\x5c\x90\x5d\x3e\x2c\x73\xaf\xf6\xf6\xbe\x09\x5c\xce\x99\x9a\x36\x51\xef\xbe\xd4\x22\xe9\x5d\x4a\xee\x46\x6c\x6e\x9d\x67\x50\xe3\x8f\xd8\x5c\x9e\x96\x8b\xf4\x12\xbe\xaf\x16\x0b\xf8\x0b\x66\x7c\x16\x84\x74\x8c\xd7\x97\x62\x81\xf8\x34\x2f\xae\x48\x4a\x7e\xbc\xe0\x18\x12\x71\x60\x04\xbc\x04\x6d\x2e\x83\xd4\xf7\x35\x97\x6f\x52\xa5\xc8\xcf\xeb\x46\xdf\x8a\xe1\xf1\x5a\x57\x8b\x85\x3d\xb2\xc0\x75\x97\x64\x5c\x24\x28\x3f\xfb\x62\xb3\xa9\x92\x4d\x19\x15\xe1\x80\xc0\xd1\x86\xad\x37\xa7\x92\xe8\xa3\x0d\x47\xb6\xac\x09\x2c\x48\xb0\xb3\x24\x62\x0a\x6b\xaa\x7d\x72\x19\xd4\x1a\xf0\xb6\xc0\xdb\xf2\x53\x03\xd8\xb0\x46\xf0\xd9\x9d\x98\x78\xfb\xfd\x03\xe1\x2f\x4e\x6d\xf0\x7b\x9f\x62\x18\x08\xe0\x84\xfb\xac\x5c\xb9\xb0\x7e\xfb\xc2\x0b\xe1\xb7\x94\xdc\x21\x83\x5e\x99\x01\x9d\x2e\xcc\x24\x64\x9a\x53\x2b\x6d\x2d\x04\xdc\x03\x35\x2d\x40\x60\x4e\xe1\xf7\x2f\xbb\x73\x7f\x4f\xc9\x9d\xf5\x6c\xe8\x67\xdc\xf7\x46\xcc\xef\x2f\xdc\x98\x7f\xf3\x8d\x61\xe3\x9a\xfe\xd6\x06\x45\x98\xa3\x9c\xc1\xb1\x1c\x4a\x17\x8e\x8c\xac\x6d\xda\x33\xd2\x38\x5c\x42\xd1\xdf\xd7\x36\xf9\xbb\xd5\xe4\xef\x66\x93\xbf\xb7\x34\x69\x15\x68\xc9\x57\x3d\xfe\x5b\x1a\xa6\x8e\x6b\xca\x99\x4c\xd3\x36\xf5\x2b\x90\x85\x50\x06\x0f\x34\xa0\xc4\xde\xa1\x86\xb4\x5e\x7f\x28\x39\xbc\x4e\xc2\x68\x09\x31\xe7\x26\x51\x46\xc4\xff\xbc\x19\xd3\xb9\xfc\x2b\x04\xe1\x0e\x88\x80\x1d\x90\x67\x3b\x89\xc1\x74\x26\xc5\x74\xee\x24\xb3\xda\x49\xb5\xcc\xd8\x49\x4b\x3a\x80\x7f\x78\xf7\xa9\x14\x07\xe3\xaf\x8f\x59\x0d\x3f\x40\xe2\x0b\xbf\x4e\x6f\x44\x1e\x0e\x26\x2d\x8b\xa9\x93\x5a\xb2\x5b\x47\x88\x67\x1d\x25\x8f\x75\x40\x08\x2b\x1e\x9d\x06\x86\xcb\x01\x51\x80\x93\xe5\xf0\x8c\x9d\x33\x12\x0c\xf0\x48\x06\x49\x18\x01\x1b\x3c\x2e\x68\xea\x8c\x95\x18\x55\xfc\x94\x72\x52\xf8\xc4\x51\x4c\x14\xb3\x3c\x91\x42\x4f\xfc\x75\x3a\x13\x99\x30\xec\x89\x60\xa3\x41\x68\xe9\x80\xa4\xd2\x99\xf2\xe5\x13\x22\x49\x47\x0a\x21\x9d\x52\x09\x20\x9d\x92\xc1\x8b\x4f\x70\x27\x3a\x28\x62\x74\x84\x54\xd1\x11\x32\x42\xa7\x9a\xc5\xf0\xca\x13\x4a\x07\x9d\x5a\x09\x00\x1d\x14\xf4\x39\xb5\x16\xf2\xe1\x6f\x8c\xe4\x21\xa4\x78\xf8\x4b\xc4\xc2\x30\xa5\x74\xce\x8d\x21\x7d\x73\x84\x88\xcd\x41\xb9\xda\x03\x1f\x2d\xba\xdc\x69\xbc\xcb\xb6\xb5\x41\x85\x70\x6d\x17\x1c\xe5\x8a\xdc\xdd\x8a\xc3\x38\xe2\xac\x05\x68\x38\xa3\x4f\x0b\x42\x12\x2d\xff\x48\xb6\xdc\x75\x71\x57\xe2\xab\x65\xf8\x15\xa8\xae\x92\x90\xb2\xcb\xf8\x2a\x4a\xa4\xe1\x6d\xcc\x2c\xae\xf7\xab\x87\x72\xbd\x94\x49\x15\x1b\xb3\xb8\xc7\xf6\xc0\x18\x3a\x30\x01\xa7\xad\xcf\x53\x2f\xb1\xc5\x1a\x9f\x66\xb2\x68\xf4\x2e\x6d\x67\x1c\x9b\x4c\x29\x8d\xce\x56\x4a\x8a\x68\xee\x59\xdf\xdb\x03\x71\x1f\x9a\x3b\xb7\x0f\xa1\x25\xfe\xfb\x9a\x80\x1b\x2b\xb1\xdc\x4d\x9e\xd3\x4e\x39\x9d\xd5\x2b\x49\x37\xcc\x1c\xbd\xc5\xc2\xd2\x28\x5e\x99\xc3\x51\x49\x07\x46\x79\xa1\x43\x5a\x49\xa9\xad\x56\xa5\xee\xa8\x91\x84\xc6\xce\x76\x5a\x63\x3c\x4a\x5d\x64\xa5\x15\xb0\x15\x1b\xef\x57\x46\x67\x08\xcf\x8d\x0a\x52\x6a\xde\x4c\x6a\x2c\x9a\x96\x95\xf3\xd6\x7f\x5b\x69\xdc\xd2\xcf\x07\xab\xc9\x5a\x09\xdf\x92\xa9\xda\x7d\xb3\x3a\x68\x4b\xc3\x1e\xd0\xe8\xf7\x95\x22\x48\x82\x43\x5e\xd2\xcc\x03\xe9\x3a\xcf\xfa\xf7\x2a\xc0\x15\xd3\xb9\xb9\xb9\xd6\xf6\x8b\x28\x1e\x34\xfa\x55\xd6\xd3\x11\xf6\xcf\x97\x9c\x4d\xd5\x12\x2d\x26\xed\x8e\x21\x02\x81\x12\xe2\x2e\x97\x61\x91\x46\xab\x87\x93\x46\x46\x1c\xfd\xd0\x72\x49\x0b\xb3\xb8\xd7\xfe\x4c\x83\xe7\x9e\xa1\x4f\x34\x2b\x8d\x2c\xe7\x1c\xfc\x6f\xcd\x94\x0b\x3a\x35\x3f\x75\xe8\x57\x33\x15\x71\xa4\xd5\x10\x08\x58\xcc\x14\x23\x56\x94\x91\x6c\x62\x52\x3f\xdc\x78\x47\xa3\x1a\xbc\x37\xd6\x06\x1a\x0f\xdf\xcb\x22\xcd\x80\xe7\xe1\x6f\x32\xa7\x19\xbc\xbc\x75\x19\xc4\x9b\x14\xde\xdd\xca\x9c\x83\x98\x91\xd6\x79\x06\x69\x4a\x56\xa6\x1a\xfc\x96\x90\x95\xd9\x06\xa7\x29\x69\x9f\x70\x90\x25\x82\x1a\x49\x58\x74\x79\x45\x52\x16\x6d\x1b\x31\x05\xde\x71\x34\xba\xf3\x53\xca\xc0\xc1\x42\xda\x7d\x26\xec\x32\x65\x57\x04\xff\x44\x82\xc0\xd9\xde\x36\x7d\xc6\x50\xa4\x9c\xb2\xad\xad\x50\x14\x53\xd5\xf5\x63\x31\x51\xbc\xcc\xd9\xad\x73\xce\x30\x1e\x2d\x63\xd1\x9d\xc8\x09\x0e\x97\xe4\x37\xfd\xd5\xd9\x5d\x92\x3e\x8b\x0e\x8d\x48\x3f\xcc\x70\x06\x19\xf2\x8f\xfd\x3e\x0b\x98\xb2\x4d\x35\xf4\x30\x19\xb3\xdf\xf5\x90\x11\x02\x39\xae\xc3\x27\xa8\xac\xf7\x3d\x0e\x85\x9f\x6b\xe3\x01\x90\xb4\xdb\x4d\x7b\x8d\x27\x0a\x5e\xb1\x49\x91\xfd\xc5\xd2\xb7\xf9\x84\x56\x23\x96\x82\x2a\x48\x60\x51\xe3\xe9\x72\x67\x6d\xc5\x57\x2b\xd5\x84\xcb\xc4\xdd\x92\xf4\x41\xec\xda\xc7\x57\xb1\xd8\x65\xff\x2a\x8a\x2f\xfb\x10\x05\x1a\x44\x45\x66\x2c\x8d\xcf\x19\x56\xbc\xbe\xfc\xea\x68\x22\x66\x44\x23\xd4\xa6\xeb\xe6\xda\xef\x45\x2a\x72\x3f\x3a\x99\xc9\x05\x36\x9a\x81\x55\xd6\xf5\xff\x80\xfa\xd0\x4a\xb7\xeb\xbd\xf3\x7e\x23\xd4\x27\xef\x3c\xc6\x1a\x0e\x97\x23\x26\x6d\x0c\xb1\x65\xdc\xdd\xaa\x28\xc1\x46\xf9\x3b\xc3\x46\xf9\x3d\xaf\x1c\x13\xea\x87\xef\xbd\xdf\x48\x62\x45\x20\x1f\xb3\x35\xcf\xba\xc0\xf3\x3a\xed\x63\x05\x39\x83\xf2\x4d\xe8\xd8\x7e\xec\xe6\x02\x69\x6b\xdc\x24\x5a\xc9\xf4\x7c\x3b\x52\x6d\xe2\xc3\x9f\xd4\x8c\xa4\xb2\xf3\x83\x4b\xc0\x61\x02\xc4\x07\x18\x7b\x94\xe8\x55\x87\x70\x95\x7c\x09\x8c\xf7\x40\x98\x74\xe9\x86\x15\x5c\x75\xeb\xd6\x60\x1b\x47\x71\xb7\x1b\xaf\xdd\x6e\x56\x0e\xec\xed\x5e\x2c\x0e\xc3\x3e\x8b\xf4\x29\x6a\x2c\xec\x6f\x32\x9d\x28\xc7\xe4\x8e\xe9\x6d\x90\xaf\x5b\xea\xd0\x7c\x3a\x6e\xf7\xbb\x27\xae\x88\xab\x22\x8c\x33\x61\x8b\xfa\xcc\x0f\x93\x87\x8f\x35\x4a\x43\x84\x9c\x50\x40\x0e\x8e\x15\x4c\x2c\xc1\x5e\x53\xe4\xf2\x71\x43\xb4\x7e\x3d\xcc\xdf\x25\x58\x89\xf8\xbf\x2a\x2a\xf1\x88\xcd\x65\x34\x62\x35\x74\x74\xf4\xab\xa5\x89\xa6\xc8\x45\xb5\xa9\x08\xaa\x0a\x4e\x0c\x10\x12\x55\xdb\x3c\xeb\xb2\x10\x7f\x2d\xda\xc1\x8f\x89\x98\x0f\x70\xeb\x58\x1d\x2d\x02\xe0\xc5\x94\xc8\x2a\x03\xf7\x8c\x08\x88\xca\x20\x5a\x88\x91\x52\xb2\xbe\xd5\x07\x2e\x97\x84\x61\x3a\x88\x12\xcc\x51\xae\x29\x72\x04\x63\x5a\xd5\xc7\x90\x88\x0d\x81\x0e\xdb\x4c\xc8\xd9\x47\xf9\xad\x3b\x60\x1f\xa7\x19\xd2\x37\x9c\xff\x97\x6d\x29\x97\x82\xe6\x7b\x5f\x85\x3a\xb9\x12\x97\x6a\xd7\x13\x61\xd4\x9b\xee\x7b\x18\xd8\xf5\x77\x0f\xd0\x07\x01\x01\x0f\xa1\x2d\x73\xf1\x49\x8a\x1b\x20\xdf\x15\x32\x76\xc7\x3a\xcf\xc6\x80\x28\x31\xfa\x8c\x52\x3f\xf0\x52\x73\x2d\x48\xda\x9c\x27\x49\xad\xa5\x10\x49\xc6\x6a\xa1\x6d\x71\xda\x5c\x8a\x24\x4c\xed\xed\x89\xc3\x54\x80\x04\x15\x46\xf7\x69\x63\x4b\xa9\xfd\x6d\xe4\x23\x58\x50\xfb\x3b\x4c\x2d\x18\xa1\xe6\x57\x98\x2a\x58\xa4\xca\x80\x3f\x15\x30\x27\xde\x6f\x0c\x53\x80\x16\xca\xff\x0d\x55\xd0\x0a\x23\x18\x52\x63\xb3\x84\xdf\x8f\x5a\xee\x3e\x2a\x2d\xc2\x36\x67\x2d\xc6\x77\x91\x69\x0b\x8c\x6e\xd7\xf8\xe8\x65\x15\xba\x89\xc9\x00\x4e\xfb\xb8\xdf\x7b\xa4\x4f\x62\x3f\xc0\x8f\x1d\xf8\x90\x3b\xcc\x37\xd1\x5a\x4d\x74\xd9\xaf\xfc\x60\xd5\x81\x8c\x69\x08\xfa\xf6\xa1\x8d\xac\x84\x17\x64\xf2\xda\x8a\x98\xe5\xe8\x2c\xb3\xc1\x2b\x80\xcf\x71\x6d\x9b\x1c\xa3\x3d\xde\x71\x09\xc2\x35\xdb\x67\x81\xac\x4b\x5c\xb7\x15\x60\xd4\x1e\x68\x13\x7d\x66\x3e\xd9\x87\x73\xda\xdd\x21\x29\x89\xfd\x30\x6e\xf4\x1b\xc6\x6b\x5b\x8c\x4d\xf3\x7a\xb5\xab\xb2\xc1\xef\xf0\x75\x8e\xcf\x6d\x52\x9b\xfc\xaf\xb4\xf8\xbd\x38\xb4\xd0\xa4\x38\xa1\x68\x37\x5e\x7e\x61\x1f\x35\xd3\x21\x33\xb0\x8f\x27\x6a\xd4\x74\x6d\x03\x86\x5b\xc3\x6c\x65\x90\xdf\x98\x83\x6c\x6c\x21\x9c\xcf\x92\xe5\x8b\xc5\xe5\x55\xdb\x00\x63\x03\xd3\xdc\x59\xae\x20\x01\xb5\x5d\x43\x88\x68\xf9\x50\xb4\x28\xc2\xe4\x5b\xe1\x83\x02\xda\x88\x27\xb4\x0c\xad\x98\x1a\x37\xc2\x0b\xe0\x96\x35\x5f\x0c\xfc\x68\x52\x5c\x8a\xe5\x8a\xfd\x3b\x23\xa0\x17\x84\x05\xc3\xa7\x69\x13\xff\x6e\x69\x98\xea\xcc\x25\xc5\xe0\xce\x72\x0c\xad\x93\x1a\x20\x7e\x7d\x7d\x76\x7c\x70\x78\x71\x7d\x74\xfc\xee\xe2\xf4\xf4\xe5\xf9\xf5\xcf\x2f\x4f\x9f\x1e\xbc\xbc\x7e\x7e\x7a\xfa\xe2\xfa\xba\x49\x5e\xdc\x5f\x1a\x7d\x92\xb2\xea\x48\x3c\x07\xb7\x58\x74\xe2\x5e\x85\x31\x1e\x2a\x74\x69\x54\x01\x66\xf8\xd0\x65\x90\x19\xe4\x86\x38\xa7\x78\xc3\xa2\x8f\xcc\x6b\x71\xf8\x8e\x7b\x10\x8b\x75\x92\x21\x2f\x76\x56\x14\x35\xbe\xb1\xe8\x87\xb7\x0f\xac\xf3\x36\x9f\x14\xb3\x5c\x56\x13\x6b\x95\xfa\x77\x4b\x45\xca\xe8\xa0\x4d\xcc\x7e\xea\x5a\x2f\xd7\x0d\xeb\x76\x6f\x98\x15\x12\xfb\x60\x6d\xe1\x5b\xd6\xed\xde\x42\x61\x23\x94\x8f\xb1\x97\x77\x31\xad\x98\x90\xdc\x13\x1b\xfa\x82\x1d\x02\xf7\x91\xd0\xfc\x50\xf9\x2b\x11\x21\x3b\x5f\x66\x32\x65\x48\xab\x67\x45\x99\x48\x33\xc3\xce\x2e\xc9\xaa\x93\x3c\xab\x33\x3a\xe6\x77\x48\x60\xc5\x5d\x3d\x64\xe6\x4b\x9c\x11\x85\x1b\x6e\x5f\x98\xb2\x89\xcf\x28\x0e\x3c\xfc\x05\x97\x24\xb0\x0c\x98\x0e\x64\x1b\xe8\xa6\x1b\x67\x65\xb1\x68\xa6\xfc\xd4\x3c\x4e\xfe\xca\xf9\x6d\x96\x30\x16\xe9\xa8\x41\x49\xaa\xab\x1c\x88\x76\xf3\x02\x94\xe4\x04\xbe\xaa\x66\xdd\x94\x4f\x19\x38\x1f\xf9\xe8\x48\x84\xa1\x87\x68\x94\x98\x65\x88\x5c\x07\xe0\xaa\x92\xf6\xea\xca\x67\x9c\x46\x14\x9c\x27\x31\x00\xad\xec\x9a\xee\x1f\x32\x2f\x25\xc2\xc1\x1c\x4c\x6e\xf8\x6a\x49\x4b\x2a\xb9\xc6\x9e\x28\x45\xc4\x16\xf8\x81\x4a\x51\xcb\x6b\x98\x1e\x32\x53\xa2\x02\x41\xe0\xf8\x86\x22\x41\x20\xa8\xcc\x35\xce\xd3\xa0\x63\xc1\xaa\x81\x69\x8f\xf8\x92\x99\x8f\x66\x4b\xa6\x0a\x8d\xf7\xcc\x79\x47\x51\x02\x41\xd0\x62\x2b\xd5\x00\xd5\xa4\xa7\x7e\x37\x81\x36\x69\x6c\xa9\x80\xe1\x04\xe1\x0b\xc1\x38\x81\xd9\x36\x80\x34\xe9\x59\xdf\x0f\x01\xf3\x25\xe7\x17\x56\x08\xd3\x46\x43\xfb\x7c\x57\xf5\xd0\x3d\xeb\x33\x8a\x6d\x4a\x8b\x34\x2a\x47\x9d\x1d\xdf\x30\x7e\xea\xec\x90\x51\x24\xa7\x32\x8c\x3a\xbb\x12\xae\x46\xa1\x7c\xeb\x7d\xd4\x18\x10\x3f\x2f\xe5\x4f\x7d\xcc\xce\xa3\xe6\x78\xe5\x71\xca\x17\x8b\xfc\xa7\xd2\x5f\x99\x4e\x19\x0e\x17\x0b\x6f\xc8\x7b\x36\x87\x2d\x58\x9c\x3b\x9e\x29\xc6\x13\x8d\xe0\xac\x4a\x78\xde\x10\xc9\x10\xd6\x01\x80\x4b\x9c\x84\xac\xef\x8d\x80\x2e\x9b\x8e\x69\xc2\x7c\x1a\x1d\x33\x6f\xc4\xb9\x26\xc2\x7c\x02\x7e\xc5\x32\xe4\x4d\x69\x66\xf9\x34\x1a\xec\x03\x33\x4a\x49\xe9\x07\x07\x1e\xff\x43\xc0\x51\x9a\x37\x07\x1b\x93\x42\x67\xf6\x36\xc1\x0a\xca\x55\xea\xc9\x4d\xed\x76\xbd\x32\x4a\x7a\xe6\x1e\xcb\x81\x97\x2d\x79\xd1\xe5\x95\x4f\x4a\xf4\x68\x1b\xf9\x3e\xf8\x3a\xf3\xc9\x2e\xe5\xb1\xb6\x4a\xef\x1b\xfe\xf8\x8b\xe8\xf1\x5e\xa0\x4a\xc1\x8a\x2c\x16\xcd\x31\x2e\x16\x9e\x0d\xea\x48\xe9\xe3\xe2\x9a\x8b\xde\x66\xe4\xfb\xaa\x81\xa8\xcc\x91\x18\x0f\x73\x25\x18\x42\xd4\x9e\x16\xaa\x7d\xf1\x41\x25\x33\xac\xa8\xa0\xc3\xe1\x9d\x2d\x16\xa5\xaa\x52\xa8\x7f\x22\x3e\x6a\x13\x51\x30\x74\xed\xde\x75\x09\x53\xe2\x11\xf1\x52\x77\x6c\x3d\x59\xf7\xda\xc0\x30\x3a\x2c\xb7\x78\xe5\x51\xac\x47\x19\xf5\x43\x83\xc3\x8a\xe2\x30\x6e\x8b\x53\x10\x61\x74\xb2\x7e\x74\x97\x55\xaf\xf8\x15\xcb\xd2\x60\x98\xaa\x88\xa7\xac\xc6\xc3\xa7\x6e\x68\x40\x41\x68\x84\xdc\xd2\x5a\x28\x5f\x7f\x87\x37\x7a\xc0\xd0\x92\xc9\x80\x1b\x5e\xe2\x87\x47\xcc\x4b\xc8\x5d\x03\xf1\x0c\x88\x89\x21\x03\x8d\x40\x02\x46\x14\xb8\xe3\xdd\x88\xc0\xca\x7f\x73\x20\x92\x4f\x5c\x23\x92\xc9\xd5\xd3\x5a\x7e\x48\xbd\x84\x0c\xfc\xa5\x9c\x86\x68\xe3\x9f\x99\x4a\xff\x9e\xa9\xf4\x1f\x36\x95\x9d\xcf\x98\xca\x06\x9f\x4b\x5f\xcf\xc5\x44\xa4\xe6\x54\xd6\x4f\x24\xd5\x13\x49\x71\x22\xa9\x10\x55\xae\x9f\x08\xb3\x27\x62\x91\x2f\x41\xba\x6e\x5b\x76\x1e\xb0\x2d\xcc\x5f\x4a\xda\xf9\x8e\xa6\xc5\x14\x4d\x07\xd4\xe3\xa0\x10\x15\x12\x03\x58\xda\x19\xa6\xb6\xc2\x16\x08\x93\x34\x02\x91\x32\xe9\x47\x6b\x25\x9a\x86\x80\x90\x0c\xa2\xfe\x3e\x08\x96\x53\x3f\x38\x0c\x91\xd7\x48\xbc\x98\x0c\xfc\x10\xcf\x50\xd8\xff\x9b\x82\xda\xf4\xb3\x04\xb5\xff\x0f\x7b\x6f\xdf\xdd\xb6\x8d\x3d\x08\xff\xaf\x4f\x41\x73\xbb\x32\x19\xc3\xb2\x9c\xa4\x49\x4a\x16\xd5\x2f\x4d\xec\xd4\x6d\x1c\x67\x62\xa7\x9d\x5f\x5d\x6f\x0a\x92\x20\xc5\x8a\x22\x15\x92\xb2\xad\x58\xfa\xee\xcf\xc1\xc5\x0b\x01\x92\x72\xdc\x99\xd9\x3d\xcf\x9e\xb3\x73\xa6\xb1\x08\x80\x17\x20\x70\x71\x71\xdf\x70\x6f\xa2\x19\x66\x10\xb0\xb9\x5b\xbf\x7c\xb0\x95\xaf\x6a\x86\xca\xc8\x4e\xc5\xa3\x83\x71\x47\x13\xc6\x82\x68\xb2\x93\x9f\xe8\x0a\xbd\x6f\x5f\x88\x70\xd0\x33\x3e\x89\x7e\xc4\x85\x63\x9c\xf8\x02\x4c\x5b\xa7\x81\x29\xd7\x4a\x54\xf8\x15\xa3\x6a\xe2\x23\x60\x42\x67\xf2\xc0\x20\x22\xd6\x98\xb1\x08\x9a\xa6\x61\x67\xac\xbc\x83\x34\x9d\xc3\x92\x7d\x71\x90\xd1\x4f\x69\xf5\xb2\x5a\xe5\xa1\xa9\x81\x80\xf4\x4d\x5d\x0d\xd3\x1a\x1f\xba\xbd\xfa\x8d\x88\xc7\x14\xcf\x21\x16\x51\x96\x01\x71\x83\x98\xe2\xe2\xbb\x50\x5f\x03\xc7\x45\x10\x64\x83\x37\x19\x0e\xe3\x51\x0f\x09\x71\x22\xa9\xc7\x82\xa3\xcf\x45\x2d\xcd\x8e\x1e\x5d\x5c\x4e\xe2\x5b\xb6\xcb\x08\xa2\x28\x42\x09\x84\x80\xfb\xda\x98\x5f\xa7\x91\x1c\x32\xd1\x4f\xc5\xc1\x53\x77\x23\xf2\xe3\x6e\xdf\x20\x8c\xae\x09\xb2\xab\x69\x72\x13\xb1\xb4\x41\x4b\x89\x95\x88\x31\xb6\x58\x2a\x81\x16\xad\xd6\x68\x8a\x4d\x59\x5c\xf0\x39\x33\xc1\x06\x4c\xe1\x10\xfb\xf6\x3b\xa5\xe1\xe7\xe8\xb5\xc4\x89\xc4\x15\x74\xcb\x50\x2d\x70\xfd\x5b\x86\x35\x01\xba\x75\x7b\x4f\xc3\xc4\x5c\x9e\x0f\x34\xa4\xe9\x35\x44\x96\xad\xd6\xeb\x19\xc6\x78\x3a\x1c\x2e\x31\xc6\xb7\xeb\xb5\xc3\xa0\xf3\x05\xb9\xe7\x2d\x67\x8a\x6e\x5d\x24\x1a\xee\x60\xbc\xdc\xb6\xbc\x89\x6c\x84\x04\xe7\xb5\xec\x4c\x0d\xe7\x34\x20\x72\x87\xb6\xf0\x13\xc1\xa7\x1b\x85\x28\x41\x53\x76\xa0\x2f\xb9\xc3\xfe\x6c\x07\xe3\xe9\x7a\xbd\x64\xf8\xb1\x5e\x2b\xb5\x3c\xdf\xac\x6d\x80\xc3\xa1\xf1\xd8\xe2\x7e\xa4\x01\xc1\x98\xbd\x41\x77\xfa\x5e\xa7\x91\x64\x97\x66\xb0\xef\x8c\x05\xe5\xb3\xd8\xda\xe4\xc0\x58\x69\x58\xf7\xd4\x45\x42\x8f\x70\x8c\xa7\x92\x39\xc2\x18\xcf\xfe\xa5\x71\x1f\x4b\x66\x15\x90\xf4\xad\x8e\xa4\xe8\x0d\xe6\xfa\x28\xff\xb8\x37\xf8\xf3\xdb\x51\x35\x2d\x96\x8c\x78\x8a\x8f\xe3\x20\x27\x5b\xca\x9d\x63\x44\xd1\xad\xeb\xbd\xd1\xa9\xcf\x1b\x43\xcf\xf9\x7e\x59\xd2\x96\xae\x73\x87\x12\x67\x86\x8e\xe1\xfa\x03\x71\x96\x6c\xf5\x76\xc6\x9b\xe3\x89\xd3\x37\xa2\x16\xc6\xf1\x7e\x87\xc3\xde\x62\x67\x0a\xc3\x41\x5f\x81\xa3\x16\x6c\x38\x6c\x2f\x83\xeb\xf5\x5a\xb7\xfa\x57\x7b\xf0\x6f\x2c\x37\x3b\x11\xa7\x2e\x8a\x1c\x46\x4c\x5c\x45\x3b\xa6\x8a\x5a\x30\x7a\x22\xa9\xff\xad\x3c\xc1\x8e\x37\x3c\x04\xfd\x19\xed\x5d\xbd\xf3\xd5\x3c\x28\xb2\xe1\x90\xff\xbd\xb4\xe3\xa2\xb4\xaf\x5a\x8f\x8e\x0d\x07\xe7\x68\x51\x94\x35\xc9\x6c\x77\xbd\x7e\x36\x3e\x1c\x3f\xd3\xee\x42\xb4\x94\xde\x4f\xbe\x27\x65\x02\x97\x62\x2a\x15\x45\x83\x93\x1e\x26\x22\xcb\xaa\xcb\x27\x57\x13\xfd\x81\xeb\x01\x04\x23\xf2\xcd\x37\x7c\x80\xde\x19\x45\x33\xe1\xa1\xa9\xb8\x25\xdb\xde\x8b\x90\x54\x37\x7a\x04\x99\xca\xc4\xa0\xad\x29\x0c\xf9\x0c\xfc\x83\xe2\x97\x65\x49\x56\xa3\xb4\x82\xbf\xe8\xc3\x43\xa6\x64\xc4\x2f\xe2\x17\x25\x3a\xa7\xe8\x82\xa2\x8f\x14\xfd\x4a\xfd\xc1\x83\xe7\x72\xe2\x9c\x53\xdc\x3b\x9d\x94\x8f\xd1\x76\xd1\xc5\x96\x16\x8c\xbf\xb3\x5d\xf4\x71\x4b\xb5\xa0\x35\x2e\xfa\x75\x4b\x83\xb8\x24\x09\xef\xc2\xf5\xd8\x30\xd8\xb2\x3d\x61\xbd\xb1\x1f\x4f\x19\x5c\xf6\xe3\x5b\xf6\x3e\xfb\xf1\x5c\xf7\x04\x96\x6a\x4e\xa9\x77\x59\xaf\x7b\x15\x9e\x66\xf8\x22\x82\x3f\xd0\xe1\x90\x5c\x7e\xa0\x57\xeb\x35\xb9\xb4\xff\xeb\xbf\xe4\xec\xd9\x57\xf7\x2b\x5a\xda\x01\x6d\xfe\x69\x88\x82\x01\x98\x5b\x34\x09\x50\x0f\x7f\xae\x59\x94\x45\xc2\x9b\x4f\x70\x31\xcb\xbd\x0b\xb0\xfc\xed\xeb\xd6\x18\x3f\x18\x0e\x9d\xc7\x32\xc8\x13\x9c\x8e\x87\x4d\xf4\x2e\x14\xe9\xd4\xcf\xf5\x0d\x0b\xf3\xd3\xe7\x90\x41\x9e\x33\xeb\xb6\xbd\x17\x6a\x83\x52\x91\x61\xb9\x75\x68\x38\x84\x3f\xa3\x4f\xdc\xd6\xf2\x81\xc6\x4c\x6e\x71\xb5\x90\x9b\xb1\x4f\x70\xd7\xb1\x50\xb0\x72\x18\xbf\x9a\x88\x9f\x77\x1b\x8f\xff\x6a\x94\x64\x22\xaa\x46\x70\x49\xaf\x3c\xf6\x0f\x26\x1b\x9f\xe8\x5d\xd1\x46\xbe\x96\xc6\x1e\x6d\x9e\xe0\x9b\x9f\x6a\x36\x7f\x39\x4f\xc6\xb7\x7e\x07\x29\xf0\x9b\xd8\x2b\x8d\xcd\x57\x2c\x4e\x73\xb3\x74\x07\x2b\x0e\xf3\xb5\x63\x3f\x39\xb4\x91\x7d\xc9\xcd\x43\x22\x0c\xfd\x15\x5b\xee\xce\x15\xe3\xba\x10\x57\x06\x84\x48\x3d\x11\x36\x25\xeb\x26\xad\xa7\xd6\x8c\xae\x2a\xeb\xce\xde\x13\xaf\xb1\x47\x27\x70\x47\x7f\x15\x69\xee\xd8\xc8\xb2\xdd\x3d\x7b\x63\x7b\x01\xb2\x6d\x5d\x25\xfc\x3b\xed\xa4\xc5\x94\x91\x3a\x03\x19\xbd\x5d\x43\x6c\xcd\xce\x29\xd6\xc6\x8f\xf4\x42\x1e\x0e\x0a\x87\x9a\xf5\x52\xea\x60\x16\x13\x67\xa1\x5b\x3e\x23\xa4\xb7\xc2\x91\x2b\x55\x75\xa2\xc0\xac\xf5\x3b\x56\x53\x5f\xb7\xaa\xbe\xd0\xf4\xcc\x11\x88\x46\x77\x46\x9c\xc1\x5c\x46\x39\x93\xa3\x89\x7c\x37\x84\x76\x88\x8d\x5f\x9a\x2f\xf5\xdb\x6b\x6d\xc5\x04\x4f\xc4\xc2\x84\xad\x53\xb2\x90\x60\x02\xdf\x55\xfc\xc3\x8c\xae\x26\x64\x54\xd1\x9a\xe7\x3b\x43\x81\xeb\xc9\x47\x30\x86\xa2\xc0\x45\x5a\x0c\xb2\x1e\x0b\x52\xec\x34\x71\x52\x9b\xa0\xe7\xb8\xa0\x8e\xca\xc8\x23\x4c\xfa\x48\x81\xe1\xaa\x9c\xa0\x6b\x42\x8a\xfc\xc0\x30\xc1\xcb\x77\x07\xec\xa7\xfe\x72\xdb\x36\xd5\x67\x1c\x4b\x1c\x22\x14\xc2\x02\x4a\x64\xc6\x71\x0c\xfd\xa8\x1d\xe4\x51\x4e\xb4\xf2\x44\xc2\xc2\x38\x8c\xa2\xef\xc3\x89\x2e\x14\xe0\xc7\x28\x74\xbd\xc8\x37\x8a\x7a\xd2\x59\xcc\xd8\xb6\x0f\x38\xdd\x00\x1e\x40\xf5\x67\x0a\x19\xf8\xb1\xdb\x33\xb9\x53\x23\x0c\xad\x80\x11\xac\xd7\xcf\x76\xda\xe1\xed\x30\x84\x11\xeb\x13\xd6\x60\x0d\x34\x57\x0b\xc2\x26\x1e\xcb\x65\xf3\x8d\xaa\x9e\x59\x2c\x3b\x43\xd8\xc1\xdc\x4f\x06\x2c\x98\x10\x09\x6e\xb5\xa0\xcd\x8c\x01\x64\xce\xb9\x00\xaa\x82\x35\xfd\x9f\x80\x0e\x2e\x8a\x8c\x81\x44\x7e\x84\x17\xf7\x8c\xdb\x1f\x18\x6f\xfb\x51\xdf\x58\x35\xbb\x70\xbe\x65\xba\x9e\x77\xa7\xab\xfa\xdf\x34\x5d\xab\x2d\x43\xf8\xae\x3b\x84\xfa\xde\x21\xf0\xe9\x0d\x45\xc8\xf0\xfe\x11\x71\xaf\x0b\x65\x4d\x16\x8d\xbf\x3a\xc6\xe5\x96\x31\xaa\xa8\x88\xeb\x75\xb0\x2d\xa6\x1f\xd7\x1f\xeb\x25\x66\x63\x93\x31\x83\xd6\x66\x51\xf3\xfd\xcb\xad\xdf\x3f\xd8\xbe\x06\x86\x0d\xfa\x21\x0b\x72\xdb\x58\x71\x5a\x9f\x7b\x38\xee\xae\xc9\xe7\xed\x6b\x82\xe8\xbf\x85\x18\xc7\x92\x81\x86\xd0\xfa\x6d\xe7\x8c\xa0\x89\xd9\xa7\x15\x1a\xbb\xdb\xb6\xf7\x82\xfe\xa1\x85\xdd\x81\xb1\x4e\x3a\xce\x1b\x81\x62\x5f\x9a\x9c\x8f\xc1\x48\xf2\xe1\xc2\xff\xff\x9c\x7a\xc0\x61\x89\xdd\xfd\x2b\x35\x26\x27\xe0\x1b\x5b\xad\xc2\x96\x01\x21\x38\x4d\xba\xc3\x0a\xd9\x76\xdf\xfa\x15\xfe\x20\x94\xdb\x5d\x3a\x31\x84\x7d\xb3\x2a\x32\x48\x5e\x50\x4f\xdf\xce\x0f\x9f\x1c\x78\xfb\xa3\x7a\x3b\xc4\xf5\x7d\x6f\x8b\xf0\xd1\x81\xd8\x89\xc6\x88\x90\x18\xca\x99\x36\x94\xe5\xdf\x18\xca\x26\x8d\x9d\x7f\x50\x27\x70\xd7\xeb\xdf\xa8\x96\x61\x84\xcf\xf5\xb6\xc9\xe5\x0a\xb0\xf6\x57\x09\x96\x6d\xd3\xcb\x0f\xbc\x6d\xdf\x06\x91\x88\x30\x81\x95\x52\x31\x87\xbb\x98\x19\xf6\x61\x66\xa8\xf3\x28\x3b\x4a\x59\xcf\x8f\x2b\xc6\x34\xb3\x1d\xd1\x8b\x83\xa1\xc2\xc1\x50\xe1\x60\xd8\x83\x83\x72\x6d\xc0\xc9\x10\xe3\x01\x9d\x84\x0d\x4a\x4e\xc4\xa6\x6e\x23\x23\xdb\xa3\x5e\x73\x60\x79\xcd\x35\x91\x8b\x0e\x44\x3a\xc9\xfb\x1a\x36\x68\x21\x08\x05\x9d\xac\xfa\xda\x9d\xf5\x00\x5c\x9a\x0d\xc5\xe2\x86\x7c\x71\xcd\xfb\x33\xcd\x9c\x35\xf4\x89\xdb\xd1\x60\x19\xc3\x2d\xcb\xf8\xa6\x45\xcc\xba\xcb\x15\xf5\x2d\x97\xe2\x67\x08\xbf\xa9\x00\x63\xe2\x56\x62\x86\x65\x08\xa4\x6d\xba\x65\xc5\x22\xb5\x62\x91\x5a\xb1\x68\xfb\x8a\xc9\x2e\x14\xf3\xcd\x58\xcc\xd0\x83\xbf\xb2\xd7\xc8\x58\x4a\x36\x82\xa8\xbd\x94\x14\xf1\x37\xbc\x41\xc9\x1b\x20\x99\x88\xf7\xe2\x6f\x75\x95\xb7\xde\xfe\xd8\x79\x5b\xcd\xc5\xaa\xd5\xf4\xec\x6f\x75\xb4\x54\x6f\x8b\x75\x8f\xf8\xba\x47\xee\xd6\xc9\xbf\x95\xaf\x34\x4b\x1f\xb4\xe3\x51\xa8\xa5\xbf\x70\x08\x8a\xd1\x35\x9a\x35\x51\xbf\x17\x9c\x8f\xfe\x22\x92\x58\xe2\x18\x4d\x71\x8c\xc7\x48\xc8\x1a\x62\xd5\xb2\xe1\x70\xfa\xfd\xb5\x34\x98\x4e\xf7\xf6\xdc\xbb\x8c\x33\xb5\x3f\x4c\x27\x4e\x8d\xd9\x9b\xd0\xbf\x57\xe3\x4c\x31\xfa\x0c\xfe\x0d\x66\x64\x23\x43\xd7\x97\xd3\x2b\x34\x73\x35\x15\xe4\x8d\xf2\x88\xc9\x86\x43\x27\xc3\xb5\x8c\x22\x1c\x0c\x87\x99\x62\x76\x6f\x74\x66\x97\x49\x2e\x99\xeb\xc7\x38\x71\x6e\x50\x8c\xa6\x2a\x5c\xed\x97\xc9\x02\xdf\x78\x5f\x14\x7b\x7f\xe3\x7f\xc1\x37\xfe\x20\xc3\x35\x9b\xc8\x29\xc6\xf8\xba\x95\xd0\x36\x02\x50\x68\xa1\x0d\x28\x13\x71\xa7\x5a\x5f\x9a\xc6\x4e\x86\xd9\xc9\x2b\x3e\xc1\x65\xdd\x67\xd0\x3d\xd2\xba\xcf\xb4\xee\xd9\x7c\x4a\x1d\x95\xb5\xd8\x30\xa8\x19\xa6\x7c\xf0\x5d\xe8\x35\x7e\xe3\x64\x88\xa0\xa9\xea\x01\xa4\x50\xb5\x65\x6a\x4d\xf6\xcc\x2e\x6d\x2e\xd4\xdb\x57\x72\xd8\x20\xf2\x4e\xa6\x1e\xfc\xe5\x93\x53\x77\x26\xa7\xd6\x46\x57\xfb\x5f\x70\x0d\xb3\xdc\xbd\xb8\xd8\xa4\xbc\x14\xb9\x2a\x5d\xed\x33\x24\x1a\x9d\x34\x68\xc4\x51\xe8\x37\xea\x5c\xf7\x1b\x03\x16\xdc\xaa\xd0\xe8\x4d\xfc\x6b\xbc\xe0\x72\xfc\xb5\x1c\xe0\x35\x6f\x73\xd8\xb4\x91\xc8\x39\xc5\x8b\x06\x2f\xbf\x68\x78\x89\x6e\xf0\x35\xc8\xc5\x8e\xab\xa1\xe8\xce\xcd\x28\x2a\x72\xea\x7f\xd9\xdb\x43\x83\xa6\x45\x83\xab\x5f\xee\xc7\xd5\x5c\xe0\xea\x8d\x38\xa6\x0d\x74\xcd\xdd\xbb\x6c\xbd\xde\x8a\xa7\xf9\x16\x3c\xcd\x51\x8c\xbe\xa8\xa5\x98\x4e\x16\x38\xf7\xa6\x8d\x18\xea\x4f\x71\xee\x0b\x34\xe5\xa3\x7f\x00\x82\xea\xdf\xa9\x7d\xe6\x0d\x60\x69\x33\x78\x69\xce\xba\x81\x44\xbf\x7c\xcb\x7c\x51\x38\x3b\x85\x2d\xd3\x0c\xe5\x06\x4d\xf1\x8d\xbb\x05\x69\xb7\xf4\xc8\x06\x2d\x90\xf7\x4b\x5f\xc7\x2d\x44\xbe\xb9\x1f\x91\x6f\x00\x91\xbf\x78\x37\x0d\x22\xdf\x74\x66\xcf\x18\xb2\x3f\xc5\x37\x0f\x42\xe4\x81\x89\xc9\x6d\xaf\x4e\xb0\xbc\xa1\x84\xa3\xf3\x14\xdf\xeb\xb2\xcc\xd6\x63\xea\x8a\x33\x8c\xf6\x9c\x61\xc4\x03\x30\xd7\x98\x82\x0b\x37\x9b\xc7\x29\x0e\x24\x9a\x4e\x79\x6c\xb8\xa9\x38\xf0\xaf\xd9\x1c\x1e\x8e\xd9\xc7\x81\x96\x91\x36\xa7\x9a\x37\x95\xbf\x45\x86\xac\x3b\x86\x12\xea\xeb\x5d\x10\x1c\xa6\x48\x7b\x63\x42\x5b\x27\xa0\x27\x0a\x10\x6b\x2d\xd9\xe2\x29\x3b\x9c\x4c\x49\x83\xe0\x40\x05\x89\x02\xf3\x0e\xf4\x24\xf1\x1c\xbc\x93\x42\x5e\x32\xc5\x6a\x00\x1b\xbd\x67\x87\x32\x6e\xb3\xdd\x7f\x3f\xf3\x99\x20\xca\x39\x7b\x6a\x70\x9f\x04\x53\xd7\x73\x12\xc6\xdd\xd3\x2d\x2f\xba\x28\x69\x64\x79\xea\xa2\xa4\x05\x20\x51\xe7\xde\xcc\x21\xae\x88\xe2\x74\x01\x4b\xc2\x97\x81\x2f\x49\xa3\xc3\xe2\x8a\x60\xbe\x14\x53\xb6\x14\xcf\x55\xcc\x7f\x98\x83\xa0\x99\x6d\x0a\x62\x1a\x05\x6f\x83\xd6\xe4\xd1\xee\xe4\x05\x9d\xc9\x83\x50\xf5\x4d\x20\x7e\xca\xc4\x8d\xad\xdf\xd9\xed\xc2\xf8\x30\xc9\x85\x10\x4f\xd7\xa7\xb0\xf1\x7f\xb7\x75\xfc\x9a\xb4\x9f\x28\x69\x9f\xf6\x4a\xfb\x6d\x74\xb0\xe4\x17\x31\x21\x67\xfb\x98\xbf\x06\xb3\xfb\x09\x67\x7f\x67\x69\x9e\xca\x4f\x1b\x0e\xb7\x6a\x16\x54\x28\x32\x55\x32\x1c\x0e\xb6\xab\x16\xa0\x79\x4b\xb5\xb0\x65\xdd\x4d\x9d\xc1\x7f\x0c\x09\x96\xff\x32\x12\x6c\x7a\x59\x77\xda\xc7\xba\xab\x33\x05\x8c\x11\xca\xcd\x21\x18\x0e\x55\x8a\x8b\x89\x63\x7e\x36\x6a\xd0\xdd\xf5\x78\x1d\x2b\x2b\xef\x19\x6e\xcf\x7e\x46\x33\x91\x76\xe3\x1f\xd4\x51\x56\x6f\xe0\x42\xc5\x4e\x4a\x63\xe7\x37\xbd\xea\xa4\xa9\x9a\x0e\x87\x20\xc6\x08\x91\xa2\xcf\xaa\x44\x25\x19\x26\x1c\xe3\x01\xa7\x1e\xf3\x1b\xd7\x87\x1e\x95\x21\x6f\x10\xb0\x17\x8f\x6d\x44\xcd\x24\x47\x14\x92\x1c\xad\xd7\xb6\x32\x20\xdb\x8a\x7e\xf0\x2f\xe6\x16\xc1\x6f\x28\xfe\x9d\x3a\x3b\x63\xb4\x33\x76\x11\x89\xe1\xe1\x10\x1e\x02\xf5\x70\xa8\x87\x61\x09\x63\x5d\xc4\xd2\xb4\xdc\x42\x7b\x93\x88\xea\x8e\xbb\xb6\xa9\x77\x96\x97\x53\xc4\xd5\x26\x65\xd5\x09\xd8\xca\x88\x52\xe1\x72\xac\xb2\xfa\x88\xe2\xc9\x37\xb4\xd3\xa6\xfd\x96\xa1\x5f\x6e\x1b\xd1\x72\x95\x06\x82\x08\x0b\x15\x7f\x32\xcd\xcd\x87\x8f\x5f\xb8\xbd\x8a\x66\x0e\xd1\xbc\xe4\xcb\x64\x40\x36\xaa\x9d\x43\x17\x71\x6f\x30\x3f\x34\xdc\x5c\x68\xd4\x5c\x52\x16\xb6\xb3\x70\x54\xd2\x3c\xa2\xa5\xe3\xfa\x66\xc7\x7e\x2c\xdc\x65\xfc\x96\x87\x07\x16\x99\x44\xfc\x96\xfb\x0b\x16\x82\xbe\xaf\x86\x31\x6e\xdc\xb7\xf8\xac\x18\xfa\xea\x26\x78\x9c\x76\xb7\x53\xda\x0b\x04\xde\x4f\xe0\xb6\xec\xa0\x5d\x8c\xda\x05\xa0\x22\x14\x26\x77\xd7\x53\x3f\x87\x43\x7e\xdb\x56\xf9\xd7\x30\x2c\x7a\xa3\x4a\x14\x09\x73\x5b\xca\x69\xdd\x8d\x5c\x0c\x1d\x0c\x6b\x7c\xe5\x01\xd9\x9f\x34\xbc\xb4\x76\x40\xc8\x8c\x4f\x44\xe5\xa6\xe1\x4b\x0e\x57\x07\x4d\x67\x33\xd4\xbe\x39\xc0\x26\x9a\x23\x99\x88\xa0\xaf\x27\x9b\xf1\x95\x45\x53\x25\xb4\x21\xcd\x03\x0a\xd9\xa2\x08\x9e\xed\x41\x7d\x21\x13\x7a\x68\x98\x6d\x36\xdb\x56\x6d\xc5\x27\x47\x29\x25\x1b\x9a\xf0\xc4\x2b\x55\x92\x1a\x5f\x50\x89\x39\x6d\x15\x3d\xf5\xde\xc0\x0e\xd9\x72\xb4\xb8\x9d\xd4\x39\x4b\x46\x60\xb8\xf7\xca\x39\xad\x2f\x9a\xd8\xc1\xe8\x16\x93\xd1\xb2\xa2\xe7\xab\x3c\x3c\x0f\xa7\x34\x5a\xc2\x34\x1c\x63\xd9\xfc\x35\x5d\x94\x69\x51\xa6\x75\xfa\x85\x9e\x2f\x83\xba\xa4\x14\xbd\xc5\x01\xb8\x5b\xff\x54\x54\xb5\x44\xa4\x37\xad\x32\x18\x0c\xba\xc0\xe1\x08\xe2\xc4\xff\xb4\x8a\x4a\x19\xec\xa2\xa6\xe8\x04\xb6\x4b\x45\xeb\x56\xf9\x17\x1c\x8e\xea\x72\x75\x51\xbc\xca\x48\x3a\x7f\x47\x6f\x45\x03\x12\x64\x54\xc5\x47\x20\xf8\x1d\x75\xe0\x96\x82\xe1\xaf\xd9\x72\x42\xc1\xc1\x66\x6b\x03\xe1\xde\x2f\x42\x1b\x2c\x30\x19\x75\xdd\x44\xd1\x35\xd6\x32\x9d\x9b\x55\x35\x26\xa3\xae\x17\x25\xfa\x25\x50\x4e\x7a\x46\x85\x74\x01\x09\x68\x92\xe6\xbf\x15\xe5\xac\x15\xb4\x06\x18\x88\x31\x90\xc4\xf6\xbd\x99\x76\xc9\x0f\x8a\x46\x71\x14\xf2\x7b\x50\x68\x2c\x7d\xda\xc9\x64\x00\x5b\xec\x5b\x4d\xa4\x05\xaf\x01\xce\xfe\x20\xda\x72\xb3\x43\x89\xf0\x9a\x4b\xb8\xd7\x5c\xe2\xfa\x11\x8e\x1c\xca\x39\x26\x83\xa6\xdd\xab\x37\xeb\x4f\xe5\x1e\x09\x02\x39\xe1\x83\xc5\x8f\x11\xc5\x80\xd9\x68\x01\x7a\x20\x54\x73\x9b\x59\x80\x39\x75\xde\x19\x23\xca\x4e\x74\xde\xfa\x10\x71\x32\x0a\xb6\x22\x73\xa1\x69\x93\xc1\xaa\xa1\x93\xbe\x38\x5a\x21\x6a\xad\x70\xf7\x0a\xdb\x6e\x85\x51\xc7\x4f\x31\x8d\x1d\xe5\x2f\xe7\xca\x93\x85\x27\xfd\x77\xd5\xdd\x87\xe6\xc4\x89\x78\x3a\xb6\x00\xe7\x1a\x0f\x65\x91\x4d\x24\x26\x32\xe2\x13\xc9\xde\xc5\x94\x47\x75\xfd\xfa\xe1\x20\x4d\xbc\xea\xab\x36\xe6\x47\x3d\xf6\x14\x8f\xc4\xe7\x4f\x5d\xca\x15\x03\x1b\x90\x89\x46\x1b\x1a\x32\xeb\x5c\x03\xd5\xd0\xa7\x40\xcd\x3a\xdc\x66\xf1\x22\xfc\x8b\x88\xce\xe2\x22\xbe\x0a\x8d\x7e\xf0\x89\xec\x96\x11\x28\xc0\x9d\x3e\x7f\xd4\x89\x13\x75\xee\xcd\x80\x6b\x2a\xe7\x96\xb8\x92\x12\x5c\xbd\x59\x9f\xf0\xc2\x89\xc3\x16\x3d\x97\xd7\x9e\x22\x4c\xa5\x27\x11\x32\x9c\x4b\x91\xe6\xba\xa3\xec\xcb\x7c\xd9\x87\xc3\x64\x34\x05\x4a\x41\x87\xc3\x0b\x27\x70\x27\xe6\xe9\xff\x58\xb2\x13\xd8\xe0\x48\x22\x14\xb2\x1e\xd9\x00\x24\x76\xe9\xe8\x25\x7c\x91\x35\xf4\x12\x8d\xd5\x68\xa5\x75\xe5\x5b\xef\x2d\x5b\xee\x5c\x5d\x17\xfb\xc2\x1e\x15\xe2\xb1\x5d\x97\x75\x70\x2d\x6a\xa3\x63\xae\x5f\x56\xcb\xe4\x6a\x8a\x73\xf2\xa9\xe6\xed\x9a\x60\xb5\xc3\x5b\x54\xcf\x1b\x80\x2e\xb4\xeb\xf3\x19\x0d\x87\xf0\x67\xe2\x64\x38\x6a\xa4\xde\xa5\x43\x51\xe4\x4e\xb8\x9a\xc9\x4b\x86\xc3\x25\x6c\xf7\xb6\x53\xe0\xe1\x33\x17\x71\x46\x09\x3d\x3e\x7c\xfa\xfc\xe9\x8b\x27\xcf\x9e\x3e\xe7\x6e\x4b\x3b\xb7\xc3\xe1\x31\x87\xe2\x74\x1c\x1c\x9a\xc6\x6c\xce\x40\x93\xe5\xf0\x99\xce\xba\xfb\x38\x32\x26\x5a\xed\x29\x13\xf9\x9f\xb5\xec\x15\x62\xae\x11\x69\xd3\xb2\x5c\xbf\xba\xd7\xea\xaa\xdb\x37\x41\x8d\xad\xe3\x85\xc7\x49\xce\x73\xfe\xf8\xdc\x6b\xd3\xc9\x5e\x2a\x41\xc1\xf1\x1b\x58\x50\xd3\x99\x59\x19\x56\x3a\xcb\xd8\xa2\x27\x40\xee\xcd\x61\x61\x4c\x5d\xda\x83\x38\x8d\x8c\x67\x5c\x42\x1e\xb4\x19\x6f\x2d\xfa\x01\x0a\xef\x61\xbe\xdb\xed\xfa\xde\xee\x50\x28\xda\x30\xa5\x5a\x28\x0f\x36\x65\xdf\xe9\x8b\x24\x59\x16\xe2\xdd\xdd\xcf\xb5\xf8\xff\x89\x79\xfe\x97\xa7\xb9\x4b\xc4\x9b\xc9\x94\x11\x1b\x74\xda\x41\xd9\x44\x6d\xa5\xde\x74\x2b\xf5\x3e\x1c\xb3\x99\xe8\x1c\x45\xdb\x0f\x9e\x36\xee\xf6\x1c\x43\x83\xee\x07\xf5\x9d\x4a\x52\xaa\x7b\xd8\x59\x23\x43\x7e\xc1\x7c\x3e\x83\x9c\x01\xc0\xc0\x1c\x93\x34\xa3\x51\x2f\x1b\xd3\xc3\x8c\xf4\x70\xaf\x06\x8b\x6b\xf4\xf2\xdc\x76\x37\x06\xdd\x79\xf6\xd4\xef\xac\x02\x50\xaa\x8e\x30\x01\x14\xcb\x08\xac\xa1\x6e\x23\xff\x0b\x5c\x55\xd0\x89\xf6\xe1\x07\xed\x68\x1f\x3e\x17\x7c\xc5\x61\xe6\x3f\x6e\x74\x3e\x40\x70\x9a\xcd\xd3\xa1\x35\x42\xd3\xd9\x3e\x68\x84\xfc\xd6\x91\xf5\xf4\x6b\x79\x91\x92\xcc\x75\x5f\x3a\xc6\xdb\xea\xae\xd5\x1b\x11\x02\x51\xa4\x5a\x53\x0c\x6a\xac\x8a\x78\x46\x1a\x51\x9c\x30\x06\x78\xc1\xd0\x51\xdc\x6e\x85\xbb\x43\x68\x06\x39\x4c\x72\xb8\xec\xaa\x57\xb0\x73\x63\x0a\x5f\x41\x17\xa4\x14\x0e\xf7\xa8\x84\x3b\x40\x65\x05\xc9\x5a\x42\x8a\x72\x0c\xd1\xcd\x3e\x14\x45\x6d\xca\x04\x2b\x86\xfa\xc5\x42\x17\x1e\x96\xbc\xad\x5e\x74\x6b\xb6\xe2\xaf\x1e\x83\x68\x0c\xbd\x5e\x14\x5c\x32\xa0\xac\x85\xfa\x92\xb7\x5b\x1a\x18\x9f\xfb\x86\x35\x2a\x16\x2d\xd1\xe3\x42\x32\x51\x27\xf2\xc7\x17\xe9\x5d\x4b\x46\xf3\x25\x57\xb9\x4d\x9c\x0b\xac\xa5\x28\xdc\xa0\x13\xdc\xde\x03\xad\xdb\xa2\xa1\x3b\x1c\x46\x4e\xe0\x6e\xd0\x97\x76\x34\x3c\xea\xde\x85\xfc\x0a\x0f\x34\x70\x3d\x88\x5c\xf5\xf8\x09\x63\xd7\xe1\xc7\x33\xdb\xf5\x07\x42\x76\x08\x8b\xf9\x22\xa3\x35\xed\xdd\x77\x5c\x8a\xe9\x52\x14\xb1\x77\x16\xee\xa2\x73\x86\x48\x22\x62\x1c\xe7\xdd\x9d\xd2\x54\x03\x4d\x69\xb9\x21\xe6\x5a\x40\x4d\x7d\xd3\x1f\x76\xe9\xbf\x62\x5a\xff\x02\x96\xb5\xa9\x78\xe2\xdd\x32\x6a\xf0\xab\xf3\x4f\x14\x88\x68\x4d\x81\xeb\x2f\x0c\x75\xcb\xa2\xa5\xa5\x18\x0e\x9d\x85\xba\x18\xd0\xae\x44\xed\x82\x26\xef\xe7\x56\xfe\xf1\x0d\x1b\x93\x9e\xa9\x1b\xef\x3f\xf1\x2f\xb4\x78\x86\xcd\x78\xbf\xf5\x56\x3c\x09\x69\xee\x70\xf1\xf1\x5a\x72\x79\x3d\x8e\xd3\xba\xdf\xf5\x1d\xe7\x02\xdb\xc7\x56\x6d\xd0\x8a\x12\x2f\x1d\xd7\xaf\xf1\x60\xea\xd4\xe8\x1a\x65\x68\x81\x42\x54\xba\x3e\xd7\x36\xaa\x22\xd7\x07\x45\x17\x2c\x19\x78\x66\xf7\x28\xbb\x64\x32\xdf\x9d\x85\x6b\xb2\x4c\x6d\xd9\xe0\xd9\xb3\xc6\x55\x3c\xe7\x4e\xef\x6c\x10\x69\xec\xb0\x69\x71\x8f\xc1\xe5\x8b\x08\x3c\xe6\x77\x6a\x08\xa6\xce\x35\x8c\x0d\xc8\x25\xf1\xb8\x09\x4e\xea\x6a\xa4\x9d\xb3\xc9\x53\x9c\x35\x79\x8a\xe1\xa7\xcb\x88\x67\xa6\x7b\xa5\x4b\x84\x7c\xba\x23\x9a\x28\x79\x32\x93\xca\xa0\xac\x93\xbc\x38\xf3\x33\x59\xed\x33\x7c\x48\xf3\x25\x24\x0c\x81\xcf\xd4\x13\x18\x4b\xb3\xa4\x99\xc6\x58\x96\xea\xc9\x8c\x33\x23\x99\xb1\x00\x62\x11\xd6\x91\x96\xc8\x38\xeb\x49\x64\xac\xd5\xc3\xb0\xa4\xea\x9c\x31\xce\x30\x59\x72\x0a\x75\x96\x8d\x6c\x94\xca\x0b\x16\x72\xd0\xb3\x92\x1d\x1c\x7c\xe6\xa5\xb1\xd3\x8b\x64\x5f\x00\x4f\xda\x38\xb6\x70\x55\x6a\xe7\xae\xef\xfc\xbf\x80\x1e\x0c\xf5\x43\x40\x12\x86\x21\x13\x26\xfb\xf0\x4f\xf3\xf4\x4f\x8b\x9d\x05\x22\x28\x6c\x39\x69\x49\xa6\xda\xe9\xd0\x24\xd7\x88\x02\xf7\xad\x0d\x66\x1a\x92\xe0\x17\xfe\x35\xbe\xbc\x12\x48\x06\x58\xd6\x7c\xef\x70\xe8\xe8\x0b\x16\xb8\x0f\xc0\xbd\xf5\xfa\xa9\x42\x43\x46\x67\x9f\x3e\xb7\x1b\xf4\xfb\x4e\x55\x5d\xf3\x90\x02\x19\xb7\x68\x1a\x5c\xd7\xbf\x80\x94\x5f\xc7\xc2\xc1\xff\x66\x34\xcc\xf0\x42\x85\x5f\x5a\xe0\xcc\x59\x08\x36\xe4\xba\xd1\x97\x82\x34\xa0\x89\x96\x50\x2a\xc2\xb9\x33\xa2\x63\x32\x26\x52\x5a\x52\xa5\x20\x34\x69\xa4\xbd\x47\x0c\x38\x1c\xf7\x89\x06\xa2\x88\x1d\x04\xe8\xc2\x3c\x1e\x04\x36\xb0\x25\xea\x32\xa4\x3a\x67\x44\xe3\xce\x2d\x09\xd2\xdc\x64\x6e\xdd\xb6\x71\xeb\x72\x75\x17\xf2\x00\x2e\x22\xd2\xcf\xb5\x7b\x17\xb0\x8d\xea\x9a\xd7\x14\xfa\x23\xf7\xbc\xa4\xc3\x21\xc4\xf5\xf1\xfb\xcd\x3a\x10\xab\xa8\x2f\x4e\xe8\x03\x6e\x11\x8b\x38\x44\x30\x44\x79\x53\xba\xbd\xa1\xb7\xdc\x9b\x6e\xdf\x37\x96\x21\x8d\xba\xdf\xa8\xb1\xe3\xdf\xf2\xe1\x6a\x25\xcf\x3d\xea\x10\x9d\x36\x1b\xaa\xe7\xe9\x70\x98\x40\xea\x68\xfd\xf6\x45\xe3\xa5\xc5\xf3\xd3\xa7\xb1\x13\xc9\x85\x6c\xc4\xcd\xf5\x7a\x3a\x1c\x3e\x6d\xec\xbe\x7d\xa9\xe6\x1b\x2a\xd4\xb3\x47\x8c\xb4\xf3\x83\xfe\xbc\xf3\xff\x46\xca\x79\xd8\xe3\xf7\xa6\xc8\xd7\x2f\x82\x34\x91\xa4\xbe\x95\x31\x01\xd6\xeb\x27\xcd\xcf\xa7\xf2\xa7\x61\x2b\x33\x66\x0a\x85\x78\xe7\x10\xc5\x92\xe3\x4c\x24\xc7\x29\xb2\xec\x87\x2e\x13\x14\xb5\xc1\x72\x1a\xc8\xaa\xa5\xf0\xc7\x49\xb4\xe6\xb4\xa4\x9c\x4c\x1b\x84\xfc\xd6\x8b\x71\xa8\x5f\xd2\xd6\x32\x6d\x49\x26\xcc\x68\xd1\xca\x6b\x9f\xa8\x84\x56\xb2\xfd\xd3\x07\xb7\xdf\x18\xd9\xf4\x37\x21\xde\x19\x6f\x04\x5d\x0e\x1a\xba\xcc\xf1\x01\x38\xc3\x64\x72\xe2\xc4\xba\x96\xc0\xf5\x2e\x5a\x05\xfe\x40\x31\x0b\xca\x28\x1c\xe3\xad\x8a\x05\x4f\x61\xa2\x6e\x59\xea\x59\xe6\x46\x0a\x36\x98\x89\x7f\x03\x45\x1f\x82\xa1\xbe\xe6\x2d\xe0\x30\x7c\x70\xff\x16\xce\x6e\xf8\x15\x7a\x1e\x92\x7b\x19\x64\x69\xa8\x04\x1d\x26\xa4\x49\xc9\xc5\x27\xa6\x7c\x06\x57\xea\x49\x57\xe0\xe0\x74\xab\xc4\x53\x46\x49\xe6\x69\x0d\x01\x02\x50\xae\x9e\x85\xb4\xb7\xc2\x53\x6e\xc0\xd1\x6d\x49\x4b\xd5\x8a\x95\x8a\x96\xb7\x78\x2a\x84\x4b\x2e\x55\x1e\x9b\xcf\x17\x45\x23\xde\xbd\xc5\xd3\x51\x0a\x89\x8e\x78\x34\x6a\xf4\x46\x15\x9c\xe4\xaa\x99\xa8\x1b\x5c\xc0\x10\xe6\xc5\x35\xe5\x80\x4f\xcc\xe7\xe3\xb2\x98\xab\x77\xfc\x46\x8a\x9a\xa7\xf5\x87\xd6\xc0\x8d\xb4\x1f\x2b\x83\xf4\x6d\x10\x7f\xe5\x7d\x46\x42\x9e\xc9\x44\x6f\x2b\x3c\x42\x64\xfe\x84\x66\x81\x4c\xdf\x90\x98\xb1\xd1\xd2\x66\xad\x36\x86\x49\xa6\xe4\x36\xf6\x55\x52\x4d\x61\xaa\xc1\xf7\xed\xeb\xc0\xd8\xd7\x91\xda\xd7\x72\x57\x07\xf7\xec\xd2\x76\x9a\xba\xa7\x0f\x6d\xad\x9f\xc3\xcf\x0e\x6d\x77\x13\x6a\x82\xd3\xe1\xb3\xe1\xd0\x61\x12\x12\x0a\x0d\x71\xea\xf0\x39\x13\x13\x02\xa0\x5f\x21\x1c\x11\x77\xfa\x5e\x0a\x7b\xf7\x52\xa8\xef\xa5\x58\x37\xe4\xba\x8c\x32\x72\x5d\xf7\x16\x42\xd3\xb3\x85\xb4\x7a\x6e\x18\xd6\xba\xfd\x16\xee\xee\xc0\x26\x7c\x26\x7f\xca\xdc\xa8\xcd\x77\x3c\x76\x25\x61\xb0\x02\x4d\xa0\x0c\xe5\xf1\xf6\x14\x8b\x57\xf5\x76\xdc\xa5\xa6\x43\x6e\x42\x30\x36\xf3\x53\x05\xc2\x36\x98\x1d\xf1\x60\x3b\x9a\x45\x5f\x66\x46\x54\x41\xa3\xf9\x2c\x0a\x62\x4a\x1b\x62\x4a\xf9\x00\x26\xd1\xe4\x0d\xb8\x03\x35\xd2\x65\xe8\x7a\x6f\xbb\x45\xd1\xe4\xd8\x2c\x74\x99\x48\x6e\x14\x18\xd2\x19\x35\xa4\x33\x2a\x09\x2a\xed\x7c\x21\xf5\xa9\xac\x36\x08\x2a\xdd\x42\x50\x69\x2f\x12\x50\x1d\x09\xa8\x41\x50\x07\x8a\xa2\x52\xbd\xd9\x86\xf6\x2c\xbe\x56\x0f\xc3\x52\xf4\x53\xec\x70\xc8\xaa\x96\x16\xb9\xb1\xc1\x13\xc8\xca\xdb\x0e\xdc\x4c\x34\x4d\xa4\xdf\xbe\xe2\xa8\x9e\xb4\x46\x7a\xb4\xe1\x16\x30\x45\x61\x3a\x8a\x9d\x2d\xea\x54\x83\x73\x93\x7e\x30\x06\x8f\xc9\x17\x46\xc5\x2e\x68\x6b\x7e\xc8\x76\xe3\x91\x0a\xda\x24\x43\xfb\x1a\xba\x2c\xbf\x1b\x07\x4d\x12\xba\x78\x38\xcc\x9d\x10\xc5\x88\x82\x87\x7f\x60\x30\x98\xcf\xbc\x6d\x92\xe5\xe3\x86\x6d\xe9\xe8\xb9\xfd\xa5\xa3\x2b\x46\xb6\x1b\xbc\x42\xd0\x68\x1b\x54\xaf\x4b\xa6\x9e\x80\xfe\x9a\xcf\xf4\xdb\x34\xa6\xaf\x56\x61\x46\xab\x87\xcc\x77\xef\x14\xeb\xaa\xa2\xa7\xae\xa6\x59\x72\xc3\xfe\x00\x38\x28\xec\x0f\x80\x83\xc2\x6e\x38\x1e\xc7\x6d\x02\x97\x44\x9d\x70\xd0\xa4\x13\x00\x7a\x4b\x97\xfe\x96\x2e\xfd\xb0\x27\x90\x87\x03\x91\xd1\x83\xd6\x82\x37\xde\x77\xa7\xe2\x4a\xaa\x31\xcf\x61\x7f\xf3\x10\x9a\x87\x2d\x8e\x4b\xea\xef\x9b\x89\xf4\xb8\x5e\xce\x14\x45\x8c\x99\x6e\x6c\x78\xc6\x84\x0f\x87\xa5\x13\xa2\x81\xc0\xd2\xf6\x4c\x9b\xc6\x86\x67\x9e\x79\xc4\xdd\x8f\x1a\x2f\xeb\x9a\x84\xd3\x0f\x34\xf6\x7a\xf2\x23\xb5\x84\xc8\xde\x48\xf6\x3d\xe2\xe0\xb7\x5e\xe0\xcc\x9c\xd0\x6d\x5b\x3c\x02\xc8\x98\xdd\x90\x9f\xbe\x9e\x89\xe8\xb5\xd1\x2b\x12\x21\xb4\x72\xbe\x2f\x8e\x21\x3b\x58\x23\x5f\x80\x54\xa2\x1e\x03\x0e\x03\xe3\x38\x86\x0d\xf7\xbc\x31\x8b\x35\xb7\xaf\xe5\x47\xc8\xf4\x04\xba\x16\x3e\xe2\xe5\xba\x12\x9f\x15\x6b\x99\x38\xe2\x78\x83\x62\xf3\x31\x31\x1e\x25\xeb\x65\xea\xf7\x3d\x4d\x8b\x2e\xf5\x07\x8e\x4a\x2c\xe0\x6e\x50\x9f\xe9\xa0\xf7\xa5\x44\x7b\xa9\x6d\x30\x30\xe6\xf2\x57\x87\xf2\x7c\x00\x31\xff\x93\x30\x8c\x47\xa6\x25\xc2\x78\x21\x56\x3e\x7e\xdc\x8c\xcc\x01\x20\x0e\x80\xbd\xda\x76\x77\x6a\x91\x93\xdf\x9c\x84\x27\x47\x08\x30\xa8\xfd\x7e\x63\x2f\x8a\x54\x04\x3c\xe9\x00\x6a\x79\x51\x75\xb0\x2e\xc2\xfa\x07\xa2\x19\xd6\x27\xc9\x1f\x44\x38\x74\x66\x48\x86\xa8\x73\xfd\x19\x37\xf4\x3b\xb2\x27\xc4\x7a\x8a\xf8\x68\xb9\xbb\xd5\xb6\xe9\x54\x50\x71\x1c\xfb\x89\xf6\x60\xe8\x58\xa6\x1d\xf4\x6a\x9c\x31\x65\xa8\x75\x38\xef\xc6\xae\x2f\xee\x2f\xda\xaf\x8f\xde\x1e\x5d\x1c\xbd\xb6\xfd\xd0\x88\x14\x69\xde\x74\x0d\xf5\x38\x11\x8d\x8b\x5e\x63\x71\x9b\x38\xfa\x93\x1e\x67\x22\x44\x7a\x0d\x06\x2b\xb7\x6e\xbc\x33\x6b\x37\xba\x7a\x48\xa3\xf9\xe6\x86\x95\xc8\x05\x8e\xc5\x62\x7a\x49\xcb\x6f\x46\x52\x81\x89\x63\x84\xc0\x44\x3b\x63\xd7\xdb\x39\x6c\x39\x2b\x04\x38\x01\x48\x7f\x0b\x84\x24\x14\x1c\x86\x11\xa7\x39\x92\x7a\x04\xd2\x27\x76\x90\xe1\xf0\xdb\x1d\x15\xa5\xf0\x89\xfc\x09\x9e\x8e\x5a\xeb\x95\x08\xcc\x49\x71\xbf\x6f\xa0\x3f\x60\xe4\x67\x2a\xcd\x64\x3e\x8f\x34\x22\xb6\x73\x8f\x57\x5f\x77\x7b\xee\x1c\x4a\xbc\xdb\xda\x70\x83\xbe\xe6\xef\x67\xb6\xbe\xcf\xfc\xa7\xb7\x04\x72\xf7\xad\xed\xf6\xbf\xa1\xdb\x03\x3b\x6f\x3d\xb3\x05\x5d\xf8\xfa\xd7\x6d\x44\xb8\x4e\x32\x0a\x49\x2e\xe0\x1b\x66\xd5\xa6\xd8\x30\x41\x0a\x79\xdd\xfc\xe0\x73\xe1\x83\x3a\xe5\x95\xc7\x0c\x89\x9b\x5a\x2e\xe4\x96\x6a\x45\x9a\x7e\xf2\xa6\xcc\xe8\x64\xc5\x79\xcf\x25\xff\x73\xcb\x84\xc3\x87\x2c\x1e\x71\xef\x96\x78\x30\xd5\x71\xb2\xed\xa8\xb1\x6a\x2e\xa7\xdf\xe2\x9d\xf1\x57\x17\x79\x89\xf9\x58\x7c\x36\x88\xbf\xb3\xe2\x3c\xb0\xcd\xad\x24\x86\x10\xdf\x4e\xc4\x8d\xe1\xa1\x61\xdc\xbb\x08\xcf\x1c\x6e\xeb\xdf\x89\xd6\x6b\x55\x6c\x18\xc4\x1f\x43\xc7\xda\xb0\x37\x81\xb3\x42\x4b\x77\xc3\x4a\x96\x78\xea\x44\x22\x2b\x8c\xf9\x16\xcc\x19\x62\xdb\xe4\xa1\x78\xa7\x92\x0b\x94\x8e\x19\xda\x53\x90\x90\x16\xa7\x02\x76\x35\xdf\x8c\xaf\x1d\xe8\x26\x47\xa0\x0e\x3b\x63\xc8\x70\xf5\x70\x3c\x6e\x14\x93\x79\x6b\x18\x66\xff\xe4\x7e\x3c\x17\x19\x97\x77\x30\x1e\xac\x9a\x40\xff\x6c\xa2\x6f\xb5\x9b\x7f\x2e\x9b\xa5\xb1\x0c\xdd\x27\x03\xa6\xb2\x66\x8a\x06\xad\xd7\xf6\x94\x12\xc8\xc6\x1c\x0e\x87\x76\x50\x44\x2b\xf1\x7b\x87\xc7\x9f\x30\xcd\x40\x2e\x97\xcd\x97\x7e\xe8\xbb\x01\xdc\x0e\x47\x21\x66\x1c\x94\xcf\xba\xf3\x97\x78\x35\x99\x19\x4a\x1a\x3d\xce\xda\xce\xd8\x38\xb1\xfe\xea\x61\x88\xde\x06\x78\x4e\xf0\xce\xb8\x2f\x25\x92\x7e\xe4\x73\x96\xe9\xb9\x1e\x53\x0a\x52\x96\x44\xab\xe3\xa2\xe4\x89\x03\x18\x56\x69\x77\x01\x72\x11\x56\xe0\xf0\x7b\x0d\x91\x5c\xcd\x2e\xac\x9d\x45\x0c\x45\xfb\x4f\x34\xa2\x66\x52\x3b\xc7\xc4\xc5\x1c\x4c\x7c\xf9\x43\xaf\xf5\xaf\x13\x91\x4e\xea\x33\x0e\xe5\x31\xf0\xd9\x97\xfb\x66\xe7\x10\xc9\x50\xc3\x90\x58\x41\x8f\xb2\x24\x5b\xc5\xf8\x73\x33\x66\x3f\x06\x45\xce\x4d\xe2\x7c\x86\xad\x15\x0f\x0f\x1f\xbf\x90\xf1\x3e\x3f\xb7\xd2\xf5\xec\x60\x9c\x0c\x87\xb7\x89\x93\xb8\x1b\x71\x9c\xc6\xc3\xfd\xc7\x4f\x1f\x2b\x19\xea\x27\xca\xe0\x7c\x6e\xd9\xd7\x0d\x2e\xbd\xbf\xc9\x09\x75\xb4\xde\xd0\xe7\x96\x29\xa2\x55\x3d\x30\xeb\x5f\x78\x6f\x43\x86\x9a\x2b\xf6\x15\x88\xfd\x3e\xdc\x7c\xc6\x9f\xb5\xa9\xde\x08\xbb\xc8\x69\xc8\xe8\xc8\xce\x18\x51\x7c\x1a\x6e\x18\x07\x25\x24\x8f\xcf\x1c\x07\x9a\xb8\x62\x68\xe6\x7c\x46\x54\x1d\xdd\x9f\x87\x43\xc7\x04\xe9\xba\x9b\x2f\x09\xdc\x01\x91\x48\x41\xfa\xd6\x85\x0d\x46\x45\x4d\xde\xba\x26\x53\x63\x4d\xa6\xc3\x27\xcf\x86\xc3\x97\x49\x7b\x4a\xa6\x6c\x71\x86\xc3\x1f\xe5\x62\x4d\x87\xcf\x9e\xaa\x5b\x9f\xf8\x73\x63\x5e\x10\xd0\xdf\xc3\x25\xdb\xf7\x70\x39\x9f\xba\xe8\xbd\x76\xbd\x95\x4a\x8b\x4d\xac\xe9\x77\x74\xfd\x06\xd5\x9f\xd1\x56\x28\xae\x82\x03\x13\xf8\xa2\x91\x3b\x10\x35\xa4\x6b\x6a\x1c\x32\x8d\x54\xfa\x0a\xd6\x25\x1e\x41\x22\x60\x74\xa7\xaa\xce\x6b\x12\xce\xbc\x78\x64\x16\x6c\x5c\x7f\x60\x48\xa6\x52\xe1\xc0\xd8\xf6\x80\x60\x01\x67\xab\xcf\x19\x04\x1d\x25\xc6\x3a\xfa\x9f\x3b\xc1\xcc\x3e\xe3\x63\xa2\x63\x0c\x20\x57\xc4\x30\x26\xfc\x1a\xc6\x44\xf7\x63\xcc\x9c\xe0\xb7\x01\xc3\x88\x3e\xf3\xe0\x17\x3a\x1c\x7e\x69\x19\xe4\x62\xf6\x61\x31\x51\x77\x89\x8f\x5d\x14\x13\xe1\xe7\x22\xcf\x0d\xe1\xf9\x4a\x50\xc0\x6b\xd0\xb5\x43\x5c\x7e\xa9\x4f\xa0\x66\x3b\xdd\x00\x38\xcb\xb1\x4f\x21\xf8\xbd\x00\x26\xf9\xd7\x8d\x69\x56\x95\x56\x28\x4e\x41\x8b\x44\xd7\x7b\x21\x82\x7e\x66\x14\x5b\x63\x35\x79\xf8\x68\xed\xfa\x3a\xc5\xc4\x37\x9c\x8f\x30\xc6\x3f\xeb\xde\x46\x80\x78\xad\xab\x36\xec\x34\x7a\xdc\xe8\x1f\x19\x5f\x3b\xe0\xd8\xc4\xe9\x97\x48\x4e\x10\x63\x6a\x78\xa6\xc7\xf2\x3a\x5a\x3c\x19\x7b\x71\xfb\x9b\x9b\xfc\x0d\xd4\x74\x5e\x49\x7c\x77\xcc\xfe\xb4\x5e\x18\x0e\xc1\xa7\x30\x5e\xaf\xe3\x1f\xda\x75\x2e\xbf\xbd\xde\xb9\x22\x94\xe0\x44\x7d\x7d\xfb\xab\x70\xbc\xd1\x55\x0a\xca\xfb\xb2\xd1\xa5\x34\x4a\x66\x8d\xe0\x43\x32\x05\x53\xcc\xd1\x9e\x14\xb6\xe9\x47\x8c\x80\x04\xca\x6d\xa3\x34\xdc\x76\x0e\x99\x20\x8d\x60\x7f\xc6\x49\x86\x8c\xf3\xae\xbf\x9f\xc9\xd6\x5e\x5a\x31\x05\x49\xab\x23\xd7\xed\x8d\x54\xe7\x0f\x74\x73\x3e\xc1\xa1\x70\x4c\xd2\x2f\xd0\x76\x0e\x6b\x61\xc1\xd8\xf4\x87\x1c\x89\x1a\x5d\xcf\x4d\x07\xa1\x95\xd1\x8f\x51\x14\x1c\xc2\x56\x6a\x9f\xfc\xdd\xcd\x42\x1b\x90\x79\x77\x93\xfc\x6b\x30\x63\x2d\x8e\x29\xa3\xe6\x9c\x1d\x06\xac\xfc\x79\xbd\xfe\xf9\x07\x02\xc1\x0e\x7e\xfe\x1e\xbf\xe3\x69\x25\x24\x2a\x1d\xf9\xee\x11\x9e\x3a\x47\xee\x84\x3a\x47\xae\x17\x39\x47\x42\xad\x6f\x34\x1a\x0e\x77\x16\x8e\xdb\x6d\xba\x91\x16\x80\x87\xf6\xf4\x55\xf8\x00\xd5\xbc\x45\xea\xde\xcd\xb9\x49\xf2\xa9\x76\x2b\x90\xf3\x6a\xa4\xbb\x9c\x03\xce\x8d\x32\x06\x95\x06\xeb\x75\xb0\x03\xc3\x12\x73\x7a\x24\x88\xd4\xfe\xe1\xf7\x11\xf5\xdd\x76\x32\x5a\x1f\xf2\xc5\x36\xa9\x2c\xf1\xab\xe6\xce\x04\x23\xc4\x73\x76\x86\xd3\x00\x13\xff\x67\x1c\xf8\x47\xb8\xa0\x0e\x55\x74\x53\xe6\x1c\x13\xaa\xb3\x9d\x43\x24\x6c\x01\x70\x8e\x37\x89\xb6\x7e\x69\x0e\x89\x5f\x42\xee\x01\x14\x0a\x8b\x60\xe0\xde\x05\x04\x8b\xec\xca\x1b\x4e\x80\x8e\x34\x8b\x52\xe2\xc6\x81\x11\xc1\x7a\x8a\x67\x0e\xc4\x08\xcc\x65\x80\x09\x38\x58\xcd\xdb\x93\x3b\xb1\x48\xfa\x15\xe2\xa9\x1f\xe1\x40\x44\x74\x08\x35\x9a\x26\x15\x1e\x89\x71\x0c\xff\x45\x9d\xa4\xa5\x89\xcd\x5a\x25\x4f\xbc\xe3\x76\xa3\xa7\xbc\x88\x11\xb0\x04\x43\xc8\xf1\x44\xcb\xaa\x88\xf1\x54\xd8\x78\x12\xac\x19\x62\x36\x47\x98\x32\x5e\x9e\x09\x72\xad\x79\xf2\xd9\x3c\x35\x96\x22\xb1\x57\x37\x01\x0e\x88\x1f\x73\xa6\xfd\xd0\x1f\x88\xe3\x4c\x53\x4e\x5f\x6b\x8e\x9a\x5d\x3c\x99\xa8\x84\xc2\xcd\xe0\x3c\x73\xe7\x1b\xb7\x8a\x5b\x3b\x10\x09\xf6\x19\xfc\x34\x24\x83\xaf\xbc\x3c\xdc\x10\x13\x54\xf2\x54\xb5\xb0\x62\x1a\xce\xf3\x55\xed\xd1\xcf\x24\x2a\x14\x0b\x43\x87\xc7\x6c\xb9\xc1\x87\xa1\x3f\x64\xf7\x3d\x0c\x12\x5c\x14\xda\x19\xa3\x18\xc7\x91\x93\xb0\x43\x37\x41\x90\x54\xc7\x7b\x22\x81\x82\x4f\x01\xbf\xbe\x5e\x3a\x09\x8f\xd7\xf3\x36\x54\xd7\x82\x24\x23\x31\x25\x95\x93\xb8\xaa\x38\xd1\x99\x3e\x59\xad\x85\x44\x69\x25\xc7\xe7\xf3\xc2\xe6\x68\x63\xae\xb5\x4e\xa3\xa5\xcb\x4a\x4e\x38\x8b\x21\x72\x3b\xbb\x7e\x4e\x46\x24\x8a\x1c\x11\x85\x78\x8a\x6d\xdb\x4f\x30\xf1\xa3\xe2\x8e\x78\x3d\xd8\x3a\x96\xb7\xe6\xf5\x3b\xf4\xdc\x14\x36\xc3\x83\x64\xf4\x29\xa2\xc1\x32\x39\xbb\xc9\x69\x89\x32\x2c\x9f\xcf\x8b\x65\x19\xf2\x9b\x58\xc7\x84\x4f\x97\x08\xa4\x03\x63\x9f\xb1\x31\xb1\xe2\x99\xeb\xfa\x33\x9c\xf9\xc7\x04\xdb\x7f\xe4\x96\x65\x59\x69\x6e\xd9\x7b\xce\x31\xd1\x52\xf0\xba\x7b\xce\x6c\x62\x5b\x0e\xa9\x2d\x7b\x6f\x36\x8a\xd3\x8c\xbe\x23\x73\x3a\x2a\x79\x88\x7f\xe7\xe0\x7f\x8d\x1e\x5d\xfe\xf1\xc7\x1f\x07\x57\x07\xc8\xb6\xdd\x3d\xdb\x63\xcd\xb2\x34\xa7\xef\x20\xe0\xc1\x9e\xed\xda\x5e\xce\x20\x70\x6f\xfc\xc8\x0a\x56\x96\xbd\x97\x43\xb9\x6d\xab\x1b\x1b\x8a\x53\x65\xa3\xb1\x37\xd3\x3d\x7c\x4c\x5a\xbb\xe9\x66\x9a\x66\xb0\x2f\x13\x3c\xf5\xe1\xc3\x88\xa2\x11\x8c\xd1\x7f\x2f\xc3\xe1\x32\xce\xaf\xe1\xa3\xd9\x70\x21\xce\xb8\xc1\x57\x27\x08\xf8\x64\x2f\xe0\x7f\x7f\x2c\x96\x79\x44\xca\x95\x17\x4d\xc2\x96\xd9\xc6\x6c\x70\xcc\xfe\x7a\x91\x59\x08\x5d\xc4\xe8\x06\x52\x24\xd4\xe5\xca\xa3\x1b\xff\x3d\x04\xdb\x0d\x51\xe0\x02\xad\x0c\x8b\xbc\x2a\x32\xca\xb9\x73\x27\x10\x5c\xba\xa0\x0a\xaf\xd8\x82\x1b\x0d\x5e\x25\xee\xe6\x6d\x30\x91\x34\x52\xe0\xae\x42\x24\x34\x88\x25\x26\xb9\xde\xb1\xd3\xf8\x2b\x86\x9b\x96\x3c\x60\xfa\x75\x1b\x61\x01\x1a\xd5\x49\x23\x2c\xbd\x07\xfc\x27\xcd\xf6\x30\x6c\xbe\xa2\x56\xdf\x1d\xad\xeb\xf9\x26\x44\x81\xff\xf7\xc2\x94\xd5\xfd\x40\x35\xfb\xc7\xe3\xf1\x23\xc7\x71\xde\x3a\xee\xde\xe1\x78\xec\x1e\x3c\x1e\xaf\xc7\xee\xde\xa1\x6b\xdc\x34\x57\x8d\x19\x3f\xfb\x17\x99\xfc\x45\xbc\x39\x99\xbc\x0d\x26\x87\xde\xcf\xde\xce\xeb\x64\xbd\xee\x0b\x93\x31\x3c\x9c\xe4\x8e\xeb\x1d\xb6\xe2\xa8\x2a\x60\x3c\x90\xdf\x8e\xde\xd7\x6d\x13\x85\x59\xa9\xa2\x7d\x75\xb9\xf9\x21\x49\x01\x7b\xb2\x00\xfa\x7d\xf3\x23\x00\x36\xb6\xf6\x36\xe8\xc1\xf6\xca\x1f\x02\xb7\x65\xa8\x6f\x77\x69\xdc\x15\xd0\x7c\x4e\x0c\xc2\xdf\x63\xfc\xdb\x99\x93\xe1\x30\xc4\x8c\x1d\x19\x0e\x83\xef\xf1\xcf\xc3\xa1\x73\x84\x29\xbf\xf9\x88\x7e\xc6\x63\xe9\x14\x1a\xf8\xa7\xc1\x0f\x47\x09\x84\x16\x3f\x7c\xf1\xad\xed\x1a\xbe\x24\x8c\x39\x16\x77\xf1\x69\xf4\xa1\x28\x6a\x37\x1c\x95\x74\x4e\xd2\x3c\xcd\x93\xa3\x56\x04\x69\xe9\x61\x79\x3a\x71\x0a\x82\x4f\x71\x88\x7a\x00\xe0\xd0\xf5\x9c\x53\x7c\xda\x57\x83\xfa\x4a\x0b\xa2\xd9\xa0\x79\x6c\x8b\xde\xfe\xe5\x15\x2b\xba\x5e\x47\xdf\xd3\xfb\xc6\xb9\x79\x43\xd6\x6b\x67\x46\x26\xef\x82\xe1\xf0\x8b\x13\xa2\x43\xd7\x3b\x84\xdb\xad\x27\xce\x21\x0f\x08\xe8\x25\xc1\x7a\xed\x24\xec\x14\x45\x3f\x53\xe7\xc2\x75\x05\xd7\xc9\xb9\x08\xc3\x78\xb1\x31\x22\xcd\xba\x77\x0c\xf5\x0e\xd1\x60\x67\xec\xea\x41\x40\x15\xb2\xbe\x0b\xb1\xe3\xfc\x42\x1d\x77\xff\x38\x71\x0f\x0e\x61\x97\x3c\xd6\xe3\x4c\xf2\xe5\x24\x78\x2c\xee\xa9\x6a\x32\xc7\xa9\x2b\x0f\xf3\x10\x9f\xa2\x08\x17\x44\x0b\x50\x2e\x26\x28\xfa\xea\x04\x35\x1e\x9b\x8a\x45\x3d\xe5\xac\xee\x53\x83\x85\x8b\x20\xe0\x62\x17\x05\xee\x60\x75\x7b\x6a\x70\xe3\x04\xa5\x78\x74\x06\xa4\x20\x6e\x41\x30\xed\x7b\xa5\x77\xc9\x29\xda\x0a\x5c\x07\x7b\xea\xde\x9d\xe2\xd0\xef\x47\x1a\xff\x21\xe3\xeb\xc3\xcf\xbe\x41\x6e\x85\x15\xf5\xed\x11\x75\xdd\x65\x0c\x7e\x41\xeb\x35\xfd\x9e\xb8\x04\x2e\x6f\x47\xbe\x1a\xbb\x60\x5e\x71\x04\x21\xf1\xbb\x40\x36\x21\x5e\x10\x4d\xf6\x66\x9b\x39\x98\x9c\x06\x7b\x7b\xde\x69\x80\xc7\xfe\x82\xe0\xc0\x3f\x0b\x30\x31\x02\x55\xba\x77\x27\xce\x18\xe9\x39\x5f\x4f\x38\x25\x9c\x06\x82\x07\x7f\xd3\x04\xff\x5b\x90\xe1\x90\x11\xe2\xb3\x40\x92\xb1\xf5\xfa\x2c\xf8\x1e\x33\x16\x72\xe7\x2c\xf4\xdd\x2f\xce\x82\xa0\xb3\xc0\x45\xda\x4b\x53\xd6\x98\xed\x8c\x43\x75\xb8\x2f\xc8\x7a\xdd\xd9\x30\xfe\x54\xa0\xef\x19\x28\x18\x61\xcc\x69\xec\xbc\x0f\xdc\x7a\x5a\x16\x37\x16\xc1\xef\x43\xf4\x9e\xf3\x6b\xe8\x3d\x83\x87\x88\xaf\xe5\xb5\x05\x6d\xfb\xdd\x1b\x21\x84\x69\x71\x23\xde\x80\x10\x96\xc6\x4e\xf8\x3d\x7e\xeb\xb8\x4d\xe6\xf6\x38\xcd\xd3\x6a\xca\xef\x83\xaa\x7d\x31\x71\xcc\x0a\xe9\x04\xb5\x8d\x3a\x04\x0e\x5c\xad\xef\x7b\x29\xc2\x09\x37\x01\xe4\xea\x1e\xbb\xb3\x1d\xd0\x00\x20\x09\xb2\xd1\x1e\x1e\xfa\x3f\x34\xbc\x85\xe3\x4e\x5a\x6d\x23\xef\x2b\xd0\x5d\x98\x61\xed\xb0\x5d\x38\x06\xdf\xc0\xa4\xa9\x60\xbd\x9e\x06\xa3\x3a\x9d\xd3\x0f\x12\x94\xe3\xfe\xf0\x26\x99\xec\x1c\x7a\x67\xe0\x58\xad\xde\xbe\x66\x48\xa9\x10\x85\xaf\x66\x73\x8d\xc7\x5f\x6c\x1f\xcd\xd8\x7f\xcf\x90\xea\x3d\x20\xd5\xfb\x10\x13\x2e\xe5\xd6\x18\x5c\x4b\xd0\x2f\x01\x06\x27\x00\x74\x4c\x71\xdd\xbd\xa0\x99\x99\x85\xf4\xb6\x46\xf3\x04\xd7\xa3\xae\xf3\x01\x7a\x43\x31\x04\x9f\xaa\xd1\x2f\x01\x5a\xa2\x95\x8b\x6e\xf0\x1b\x3a\x52\x31\x52\x50\x9e\xa8\xe7\xe6\xca\x31\x2a\x12\x1c\xc9\xd7\xdc\x91\x7e\x2b\xd2\x1f\xd4\x18\x2e\x81\xcc\xf8\x31\x7b\xc3\x3a\xee\x77\xf8\x45\x3f\x51\x55\xa7\x3c\x7b\xd1\xaa\x79\x41\x3a\x03\xa2\x93\xa6\x21\x74\xff\xb2\x69\xd3\xb8\x91\xa1\x1f\x9b\x52\xe5\x41\x84\x6e\x75\x70\xb2\xf0\x17\x8a\xc9\x28\x2f\x6e\xd0\xcf\x60\x75\x17\xc4\xe7\x35\x8d\x69\x59\xd2\x48\xa6\x35\x44\xaf\x93\xde\xb0\x3c\xd7\x49\x73\xed\x56\xc9\xb7\xe8\x4b\x02\x5e\x42\x15\xad\x5f\xc6\x35\x95\xa5\xc7\x09\x66\x07\x1e\x7a\x17\xe2\xc7\xe8\x2f\x76\xb2\x81\xfc\x8c\x8e\x38\xe2\x6a\x5c\x09\xfa\x2c\xe8\x01\xff\x93\x0b\x75\xb1\x50\x28\x2b\xf5\x71\x0c\xe4\xe2\x2d\xff\x17\xb4\x1e\x85\xa8\x39\xe5\x7f\x80\x3e\x21\xc0\x63\xb4\x10\x55\x67\x01\x1e\x23\x20\x46\x82\xdc\x48\xe2\x23\x08\x15\x9a\x41\xf3\x77\x50\x77\x94\xe0\xc3\xa3\x27\x88\x51\x2d\xf4\x26\xc1\x87\x9a\xd7\xf6\x62\x59\x53\x48\xd8\xd7\xa0\xab\x97\x23\x51\xd1\x94\x1d\x17\x25\x24\xa4\xf4\x56\x68\x20\x27\x17\x1c\x2b\x97\x28\x60\x42\x05\x15\xee\x6e\x6d\xcf\x3f\x7e\xba\xcf\x88\x3f\x03\x3a\xd7\xce\x9b\x0e\xb7\xa0\xb3\xd5\x9d\x33\x23\x38\x74\xd7\x6b\xc6\xcb\x28\xb6\x65\xb3\x41\xcb\x7c\x2b\x74\x60\x7f\x67\x64\x38\xdc\x79\x17\xb8\x77\xef\x82\x0e\xf8\x06\x3a\x4c\x82\xd2\x4d\xb2\x1a\x14\x67\xcb\x6a\xca\x90\xa0\xc7\x1f\xcd\x18\xad\x88\xe4\x19\xe2\xbf\x88\xff\x17\xc1\x87\x2a\x7f\x7a\x84\x89\xa3\x45\x00\x10\x5d\xfd\x45\x70\xb8\x91\xe6\x27\x15\x48\x4e\x55\xcf\x08\x0e\x10\x3f\x05\x0e\x5f\x34\x06\x50\xa4\x7f\x73\x24\x70\xb6\xef\x93\xf9\x00\xf9\x50\x72\xc7\xdd\xf6\xc1\x7f\x11\x1c\x98\x97\xb8\x66\xbd\xfe\x6b\x33\x10\x6a\x5b\x71\x3f\x78\x38\x71\x8d\xfd\xd6\x1d\xd9\xcc\x8b\x10\x3e\xc1\x60\x07\x56\x57\xb2\xfa\x11\x0a\x72\x2c\x6e\x45\x29\xb8\x3c\xaf\xe3\x94\xc2\x4e\x10\xe1\xb7\x39\x81\xe9\xce\x51\x4f\x94\x73\x14\x69\x5c\xe4\xc2\x56\xb2\x2f\x82\xe4\xed\x65\x19\x19\x15\x5e\xda\x42\xaf\xbd\x31\x6a\xeb\xbb\xbc\x9d\x43\xa4\x1f\x3e\x22\xb3\xaa\xf0\x30\x83\x07\xf3\x7e\xb4\x48\xa0\xcd\xbd\x0a\xbc\x00\x75\xd8\x22\xae\x2d\x53\xd2\xb4\x71\x7b\x55\xe6\x89\xec\xfd\x7c\xb8\xbb\xac\xb2\x44\x8a\x2f\x06\x2e\x02\xdc\xf7\xfb\x73\xc9\x82\x12\xc8\x0f\x3c\xae\x18\x63\xd2\xfc\x70\xf8\x58\xfa\xd5\xeb\x57\x44\x9f\x8f\x6d\x57\x69\x38\x9f\xec\x88\xb8\xb4\x22\x68\x2d\x75\xa6\xae\x7b\x07\x31\x60\x95\xfe\x6c\x5b\xbe\x54\x5a\x26\x66\xbe\x54\xb1\x5f\x82\x8d\x33\xc5\x53\x4d\x00\x34\x7a\x3f\xb4\xdd\x8d\x09\x5f\xcc\xf1\x26\xc4\x53\xea\x84\xee\x24\xa3\x4e\x88\xa6\xae\x37\x95\xc6\xfb\x57\xcd\xd5\x21\xd1\x76\xa2\x7e\xe1\xd0\x6b\x07\xe3\x83\xb8\x1c\xa5\x1f\x34\xc9\x75\x03\x8e\xf5\x81\x5f\x0a\x27\x6e\x62\x26\x40\xfd\xcf\xa6\x43\x9d\x44\x8e\xeb\x81\x72\xe9\x35\x75\x92\x4e\x02\xdf\xd2\x4c\xe0\x7b\x27\x82\x36\x79\x64\xd3\xe4\xf1\x0d\xb6\xa7\x57\x1e\xdc\x9f\xc8\x37\x76\x12\x54\xba\x9b\x36\xdd\x26\x23\xb3\xa0\x4b\x7b\xc9\xa8\x5d\xd4\xa1\x55\x64\xd4\x2a\xd1\x08\x2d\x19\xa9\xdf\x48\x51\x12\xb6\x0b\x7a\xfd\x6c\x08\x26\x3a\x5e\xef\xc8\x80\x02\xba\x7a\x54\xb9\x18\x72\xff\xe7\x1e\x47\xc3\x50\x55\xea\x69\xda\x0c\xf7\x3f\xab\xd3\x62\xb3\x61\xdb\x3c\x32\x1c\x91\x82\x4e\xd1\x6f\x69\x3d\x7d\x57\xbc\x87\x44\x87\x55\x6b\xe8\xd9\xc3\xe8\x2a\x4a\xf3\xbf\x28\x6c\x9b\xe2\x35\xbd\xbe\x28\x8a\xac\x4b\xed\xb9\x3f\x4a\x1e\xc1\x16\xfe\x71\xa5\x8f\x40\x76\xb0\xa2\x0e\xa4\x88\x1f\x10\x74\xd7\x1e\xe5\x8f\x2b\x7e\x6c\xf7\xb8\x30\xb1\x33\x80\x7f\x69\x0f\xec\xbe\x17\xc2\x49\xe8\x10\x91\x92\x62\xe3\x4a\x4f\xe9\x2c\x96\xc9\xda\xe2\x92\xd2\x2f\xd4\xb9\x93\xf3\x3b\x8b\x37\x2e\x9a\xc7\x38\x8b\x87\xc3\x59\xbc\x5e\x67\x31\xca\x63\x3c\x8f\x2f\x6d\xd1\xc2\xbe\x9a\x18\x4f\xde\x3c\x46\x45\xdc\x13\x7a\x7b\x41\xcb\xb8\x28\xe7\x6c\x60\xfd\x21\xf0\xb4\x06\xc0\x04\x2e\xa4\x6b\x86\xbf\x88\x71\x11\x4f\xba\xfe\xcd\xad\x37\x1c\x77\xd3\xe3\x04\xfd\x9a\xd4\xb2\x16\xa8\xe7\x67\x05\x76\x90\xc6\xce\x7c\x14\x92\xfc\x63\x45\x5f\x9f\x9d\xba\xc6\x0d\xe4\x26\x04\x40\x49\x3f\x2f\x69\x55\x9f\x44\x19\x95\x1b\x92\x2f\x6b\xc9\x4d\x1e\xa8\x8a\x19\x7f\x56\xc3\xbf\xcb\x18\x8f\xd1\x75\x8c\x9f\x3c\x41\x37\xf0\xef\x6d\xec\xdf\xc2\xf0\xef\x0c\xd9\xa4\x67\xa0\xcb\x78\xbf\xfb\x41\x1b\xef\x21\xef\x69\xdf\xc8\x3f\x72\x15\x63\x5b\x12\x74\x6d\xdc\xdf\xd8\x7b\xa7\xa4\x9e\x8e\x4a\x92\x47\xc5\xdc\x71\x55\x46\x3e\xe7\xc9\x33\x77\x54\x65\x69\x48\x9d\xc7\xae\x7f\x93\xe6\x51\x71\x33\x22\x51\x74\x74\x4d\xf3\xfa\x2d\xdc\x8a\xa4\xa5\x63\xcf\x69\x55\x91\x84\xda\xc8\xd8\x2a\xa3\x0a\xcc\x07\x18\x63\xfe\xe2\x70\x48\x46\x11\xa9\x09\xc6\x78\x15\x0f\x87\x0e\x9f\x1f\x82\xcb\x18\xc9\x29\xcb\x35\x97\xfd\xdb\xd8\x75\x37\x10\x33\x95\x8d\xfc\x4b\x6c\x24\x49\x84\x59\x95\xbe\x68\xfb\xcb\x78\xef\x26\xf6\x83\xef\x6f\xe2\xe1\xf0\x3a\xfe\xfe\x26\x9e\x38\x2f\x7e\xe0\x06\xe2\x17\x2e\x9b\xf0\xe0\xfb\xeb\x78\x72\x1d\x7b\x81\xeb\x5d\xc7\x38\xf0\x97\x31\x26\xec\x95\x2a\x5e\xaf\x61\x1c\x63\x34\x10\x5f\xb7\x28\xaa\xfa\x94\x7f\x8f\xb3\x8a\x91\xfd\xc8\x76\xdd\x8d\xff\xd9\xec\xbe\x8c\x31\xf1\x6b\xf6\x72\x0d\x2f\x0b\x5c\x78\x99\xa7\x73\xce\xff\x94\x64\x4e\x9d\x2f\xb1\xab\x28\xc5\x78\xc3\xcf\xb3\xcf\x31\xee\x41\x1c\x5f\xd6\xe9\x9d\x30\xf1\x2b\x9d\xd3\x62\x59\x3b\xda\xea\x12\xe7\xab\x2b\x7f\x92\x33\x56\xa6\x5e\x6d\x36\x5a\x54\xfc\xf1\xc6\x1f\xb0\xf9\x7a\x19\xe3\x83\xff\x75\xe9\xbd\xdc\xff\xfd\x13\xd9\xff\xf2\xc7\x72\x3c\x7e\x35\xde\x67\x7f\x5e\x3f\x83\x7f\x5f\xc0\xc3\x31\x3c\x1c\xc3\xc3\xe3\xe3\xe3\x3f\x96\xe3\x27\xcf\xa1\xd9\x93\xe7\xaf\xe1\xdf\xe3\xfd\x3f\x96\x87\xc7\xac\xe6\xf1\x78\xfc\x6a\x1f\xfe\xbc\x66\xff\x42\xb3\xc7\x87\x2f\x58\xcd\xab\x31\x3c\x1c\x1f\x1d\xff\xb1\x7c\x32\x1e\x1f\xee\xff\xb1\x7c\xfd\x9c\xbd\x73\xfc\x1d\xd4\x1c\xbf\x7e\xc5\x1e\x5e\x1f\xc3\xc3\xf1\xf1\xeb\xab\xff\xbf\x0e\xec\x8f\xfd\xd1\x78\xff\x3b\xd6\xf5\x8f\xcf\x59\x37\x63\xde\xe7\x33\xe8\xe6\xc9\x31\x74\xf3\x74\x7c\xf5\xe8\x9b\x03\xf4\x63\x8c\xef\x36\xe8\x15\x5c\x32\x51\x4c\xf9\x6b\xe9\x80\xf0\x2a\x1e\x4d\x49\x75\x76\x93\xbf\x2f\x8b\x05\x2d\xeb\x95\x43\xa4\x5d\x90\xeb\x8a\x7e\xbc\xa7\x01\x98\xee\x5f\xc6\xa3\x9a\x56\x75\x53\x6c\xbd\x8a\x2f\xc9\x15\x13\x6a\x7e\x94\x3f\x94\xaf\x75\x23\x25\x1c\xc5\x66\x76\xde\x25\x13\xd2\x40\xc9\x37\x1c\xd6\x04\x2e\x2a\x35\x8a\x59\x79\x01\xfa\x94\xd6\xd3\x22\xf2\xe9\x84\x27\x1c\x12\x2e\x62\xe1\x7a\x1d\xb1\x41\xfe\x58\x14\x19\x25\xf9\xaf\x24\x5b\x32\x66\x49\x16\xbf\x5b\xce\x69\x99\x86\xa2\x38\xad\xde\x91\x77\x90\xcf\x06\x2a\xdf\x17\x55\x5a\xa7\xd7\xd4\x6c\x74\xf8\x83\x7c\xf9\xec\x9a\x96\x59\x41\x22\x1a\xb5\xa0\x1f\xc2\xc5\xfd\x63\x1e\xb0\xc2\x63\x43\xac\xea\x8f\x15\x95\xb3\x34\x21\x97\x3c\xee\x03\x7b\x78\x47\xe6\xf4\x0a\x87\x9e\x13\xe0\x68\x44\xea\xba\x4c\x83\x65\x0d\xd6\x46\x04\x79\xe6\x8d\xa2\x6a\x41\x42\xea\xf2\x0c\x97\x2f\x55\xc5\x39\x5c\x37\xb1\xed\xbd\x90\x75\xd6\xfa\xd8\xaf\x8d\x75\x0c\x63\x35\x21\x3a\x90\xa1\xd4\xeb\x29\xdc\x0b\xa5\xf2\xed\x0d\x5f\x23\xb1\x1c\x93\x90\x5f\xf6\xd2\x16\xf1\x8d\x5a\xc4\xd7\x31\xc4\x8f\x11\x06\x10\xd6\x19\xbf\xc6\xad\x81\xde\xde\x59\x63\x06\x88\x75\x81\x8b\xa3\x44\x38\x71\x02\x1c\xb6\x50\xc0\x9d\x40\x0c\x0c\x1e\x1c\xd0\x0b\x7b\x66\x3f\x6c\xcf\x7e\x7b\xd2\x26\x3b\x87\x9e\x6d\x7b\xdd\x81\x86\xe6\x7a\xb8\x3d\x4d\x02\x7d\x12\x7e\x8a\xcd\x78\xe6\x3c\x2d\x49\x04\x77\xe6\x68\x38\xa3\x91\x24\x79\x2f\x9d\x3b\x76\x56\x4b\x41\xbc\xaa\xe9\x42\xfe\x9e\xa7\xb9\xfa\x49\x6e\xc5\xcf\x0d\x0a\x90\xe4\x70\x5e\x71\x50\x2a\x1b\x30\x2f\x85\x0f\x91\x65\xd0\xaf\x08\x1b\x1c\x4e\x18\x13\xfc\xe9\xa6\x24\x8b\x05\x2d\x81\xb7\x1f\xa5\x3c\xfc\xdb\xaf\x3c\x25\x9c\x80\xc7\x9b\x47\x93\x68\x5b\x73\xd1\xf1\x46\x57\x8c\xb7\x3e\x58\x1f\x8c\xdf\x02\x83\xef\x4c\x38\xa2\x43\x35\x37\x13\xf5\xcb\x53\x80\x44\x53\xa4\x0f\x58\xbd\x07\x5f\x39\x11\x7f\x85\xe0\x5d\x16\x59\x46\x23\xcf\x06\x48\x41\x71\x6b\xf3\x60\x0c\xab\x05\x5d\xaf\xed\x92\x44\x69\xd1\x94\x4c\x5a\x03\x30\x01\xeb\x7a\x8c\x9f\x5b\x9f\x29\x57\x53\xcc\xf0\x70\x08\x24\xcc\x16\xc5\x36\x0a\xd7\x6b\xc6\x1d\x28\x14\xd0\xaf\xf1\x0a\x9b\x46\x38\x1c\xda\x36\xc8\x70\xd0\xc2\x15\x7f\xb1\x3d\xb6\x95\x81\x46\xcb\xa7\x10\x88\x44\x2c\x10\xbf\x62\x41\xca\x8a\x1e\x67\x05\xa9\x1d\xf9\xfa\x7a\x3d\x46\xe1\x0e\x0e\xd6\xeb\x10\x7c\x68\x44\x39\xeb\x50\x41\xb6\xf7\x42\x79\x2d\x42\x54\x42\x19\x68\xe0\x9b\x26\xc2\xe3\x85\xef\x5e\x31\xfe\x26\x34\x95\xbe\xc0\xc0\x35\x69\xcf\x1c\x5e\xbb\x8d\x63\x36\xea\x36\x91\xbe\xc5\x6a\x5a\x3b\xbd\xbd\x92\xe5\x0d\x2c\x51\x84\x77\x76\xda\xad\xf4\xfd\xf8\x4b\xdc\xbe\x09\x0c\x93\x08\xd2\x9a\x5d\x2d\x83\x79\x5a\xdb\xdc\xe1\xc4\x06\x85\xab\xad\xdf\x2e\xb5\xc3\x22\x2b\x4a\x59\xcf\xe4\x4a\xfd\x37\xe3\x74\xda\xcf\xfb\x59\x11\x92\x4c\x96\xce\x8b\xbc\x9e\xca\x07\xbd\xf9\x0d\xa5\x33\x46\x6d\xe4\x9c\xfb\xf2\xa7\x39\x53\x2d\xef\xe6\xa6\x11\x47\xcf\x00\x13\xc8\x22\xe1\xdb\x36\x77\x9b\x72\xf8\x33\xb6\x6d\xd7\xef\xce\x53\xbb\xe4\x21\x4d\xda\x90\x03\xdd\x1a\x1b\x37\x9a\x41\xf6\x09\x64\x24\x15\x5c\xca\x8b\x99\x18\x4c\x37\x5f\x64\xb2\x5e\x77\x43\x96\x91\xe1\x50\xa2\xba\x56\xb8\x5e\x3b\xc1\x1e\x26\x1a\xa3\x18\x68\x4b\x7b\x2a\x96\x96\xe0\x97\xce\x9d\xca\x3a\xa4\xa8\x25\xf0\x0f\x01\x7e\x1b\xcb\x30\xa2\x25\xcd\x5d\x97\xa8\xdf\xcd\xbd\x1c\xcd\xf6\xf7\x2e\x6e\xf2\x48\x10\x4c\x46\xc5\x82\x15\x43\xe8\xc5\xc0\xbd\x0b\x80\x6d\x52\xd1\x1a\xc6\x3e\xfd\x3e\x94\xf9\xd4\xe8\xde\x9e\x1b\x5c\xda\xdf\xd8\x7b\xe1\x25\xbd\x02\x46\x87\xdf\x7a\x19\xfb\xe1\xf7\x44\xb6\x0a\xf7\xf6\x20\xfc\x6f\x8b\x8b\x62\xaf\x91\xcb\xf0\x4a\x6c\x65\x04\xbf\x2b\x9a\xd1\xb0\xa6\x11\x8f\x28\xe9\x18\x65\x98\xba\x88\x0e\x87\x91\x2c\x17\xcb\x76\x2e\xab\x77\xc6\x22\x5c\x60\xc8\x53\xc0\x0b\x23\x22\x1b\x11\x1f\x37\xd1\xc7\x0d\xb7\x82\x2e\xa9\xe8\x9e\xc7\x9a\x85\xe7\xaa\x81\xe7\xf3\xbe\x68\x6f\x5f\xf2\x12\x96\xf4\xe0\x5b\xaf\x79\xcb\xb4\x22\x41\x46\x23\xb6\x8e\x98\x95\xb8\x9b\xc6\xc7\xcf\x09\x74\xf0\xae\x4e\x6c\xcf\xfa\x0e\xd1\xad\x87\xc9\xaf\xad\xa3\xce\xa4\x2d\xe8\x86\x54\xa7\xcb\xac\x4e\x17\x19\xf5\x18\xad\x98\x8b\x07\xcd\xe1\xe0\x7d\xac\xa7\xb6\x08\x46\x11\xc9\x13\x5a\x16\xcb\x2a\x5b\x9d\xd3\xfa\x24\xcf\x69\xf9\xd3\xc5\xe9\xdb\xc9\x6b\xc7\xfe\xee\xb0\x73\xe1\x1a\x74\x20\x01\xba\xbb\xd6\xcf\xdf\xbe\x33\x59\xe1\xa8\x6d\xef\xdd\x77\x1e\xeb\xc7\xeb\x3f\xb6\xf0\x13\xa1\x50\x3c\xca\x88\xc2\xc6\x27\xab\xa8\x47\x25\xcd\x85\xd8\x1a\x28\x27\x6e\x08\x30\xf5\x5d\x13\xa8\x01\xbd\x2c\x4b\xb2\x1a\xa5\x15\xfc\xe5\x8c\xdb\xe1\x0f\x38\x10\x08\xa2\x69\x48\xbf\x7b\x62\x43\x32\xf5\xcb\xf1\x95\x8b\x00\xb1\x54\x3c\x30\x3e\x0c\xdb\x76\xd9\xd0\xdc\xaf\x2c\x95\x6d\xef\x45\xfa\x72\x7f\xe8\x5d\x6e\x75\xb2\x3a\x1c\x87\xd9\xe1\x26\x49\x9f\x76\x60\x85\xcd\xe1\x71\xff\xa9\x13\xba\xd2\xf8\xfe\xb5\x96\xad\xc3\xa9\x59\x8c\xf3\x58\x0f\x1e\x50\x6b\x17\x6b\x21\xa2\xd4\x3d\x4b\xaa\x0d\x58\x78\x19\x5f\xc4\xf8\x6e\x5a\xcf\x33\xcf\x9e\xd6\xf5\xc2\x3b\x38\xb8\xb9\xb9\x19\xdd\x3c\x19\x15\x65\x72\x70\xf8\xdd\x77\xdf\x1d\xdc\xb2\x5a\x1b\xcd\x49\x3d\xdd\xda\xea\xc5\xc1\x29\xa9\xa7\xf0\xcf\xe9\x5b\x1b\x55\xd7\x49\x5f\xc3\xc7\xe3\xf1\xf8\xa0\xba\x4e\x6c\x3d\xb0\xc0\x47\xf8\x16\xa9\xc9\x54\x27\xe2\x75\x62\x0b\xfd\xe4\x7d\x80\xc4\xf1\xc8\xc6\x76\x4f\xf3\xce\x00\x5b\x1a\xd0\xfb\xbf\x5c\xdb\x9f\xbf\xc6\x86\xa3\x5a\x73\x8e\xdc\x0b\x00\x74\x9f\x1f\x19\xe1\xbe\x77\x52\x78\x2c\x00\x3b\x2e\x4a\x9a\x26\xf9\x99\x52\x01\x06\x93\xfb\xc1\x7b\x64\x03\x3a\x8b\xdf\xd4\x6d\xac\x7f\xb6\xf4\x30\xfc\x23\x9b\xe4\x51\xcd\xc9\x76\x7a\xfe\x72\xb1\x18\x0e\xe1\xcf\x88\xde\xd2\xf0\x63\x5e\x91\x98\xbe\x65\xcc\xc3\xb1\x00\xd1\xe8\x0e\x55\x36\xa7\x7b\xdb\x3b\x5d\x5d\x0b\x51\xaf\x6e\xdc\x8d\x47\x36\x8e\x69\xc9\x62\x54\x1f\x8e\x75\x90\x32\x3f\x7e\x38\xd9\xc1\xf8\x22\x1e\x55\xd7\xc9\x7a\x6d\xa7\x92\xea\xd9\x69\x6e\x11\x97\x8c\x54\x01\xe6\x01\x90\xee\x7e\x8b\xf1\x6f\xf1\x7a\x1d\x15\xe1\x72\x4e\xf3\x5a\xc4\xa1\x3e\xe2\x36\x03\xc7\x8e\xd2\x6b\xdb\xf5\x7f\x8b\xb5\x17\xed\x3f\x6e\x9f\x84\xd5\x75\xf2\xc7\xed\x13\x6a\xef\x05\x7b\xf0\x7c\x20\x0b\xe0\x74\x0a\xf0\x6f\x31\xbf\x3d\x02\xcc\x84\x4f\xf4\x07\x97\xe8\xf1\xc0\x1c\xbd\x8e\xdb\x8d\x64\x98\x6f\xd5\x5c\x8b\x4b\xe6\xe8\x75\xee\x66\xe3\xa2\xff\x8e\xf1\xc1\xa5\xbd\x3b\xfc\xfe\x87\xab\x03\x6d\x67\xfc\x1e\xab\xe9\x09\x74\x5d\xb8\x82\x9b\xc6\x8e\xf0\x24\xe2\x97\x66\x5e\xf1\x70\xe5\x4f\xb8\xaf\x5f\x11\xd1\x0b\xce\x63\xc2\x6f\x41\x52\xe4\x09\xb9\x31\xe8\x06\x0e\x36\x03\x4d\x9b\x3b\x1c\x3a\xb6\x56\xcb\x66\x5e\xcd\xae\xfc\x21\xe6\x77\xbd\x76\x7e\x8f\x71\x67\x3d\xb9\x37\xa3\x1a\x03\x31\x86\xa0\x22\xc6\x06\x5c\xf2\xfd\x7a\xfa\xf6\x00\x88\x3c\x7f\x51\xfc\xe6\xf3\xf1\xdf\x31\xa0\xa1\xd0\xd2\x28\xbd\x8d\x6d\x23\x8a\x62\x3c\x16\x8c\x46\xc8\x53\x9f\xfa\xf4\xfb\xc0\x60\x37\x14\x33\x1e\x4e\x49\xf9\xaa\x88\xe8\xcb\xda\xa1\xae\xcc\x97\xf4\xd4\x0b\x19\xa6\x3c\x7e\xf6\x79\x59\xd4\xbe\x6d\x5c\x59\x78\x21\xeb\xc8\x7c\xd1\xaa\xfa\x4e\x56\xfd\x8f\xdb\xc7\xcf\xcd\xba\x67\x63\x59\x97\xb5\x00\x3e\x7b\x2c\x6b\x92\xa6\x46\x52\xa9\x26\xd4\xab\x60\xc1\xa2\x3d\x1c\x8c\xaa\x65\xc0\xd9\x57\x27\x46\xd4\x75\xfd\x18\xd3\xbd\x43\x3f\xda\xc3\xe1\x26\xc0\xd0\x72\x12\xed\xb5\x9b\x79\xd1\x66\xf3\xcf\x58\xe4\x75\x73\x5d\xae\xed\xfc\x26\xc6\xbf\xc7\x88\x24\xf8\x8e\x48\xdd\xec\x49\x4d\xb9\x3d\xee\x55\xb1\xcc\x6b\x6f\x67\x8c\x82\xa2\x8c\x68\x79\x32\x27\x09\x3d\x5b\xd6\x15\x6d\x17\x9e\x67\x69\x48\x5b\x65\xbf\xa5\x51\x3d\xe5\x65\xb7\xc7\x19\xbd\xd5\x7e\xbe\x29\x8b\xe5\x42\x3c\x9f\x95\x51\x9a\x93\x4c\x15\x85\x45\xb6\x9c\x37\x3d\xf3\xc7\x8a\xfd\x8c\x05\x90\x98\x43\xb8\x91\xbf\xa5\xc2\x4c\x3e\x9f\x4f\xcb\x34\x9f\xc9\xa7\x77\x34\x21\x7a\xed\x19\x1b\x20\x7b\x48\xca\x34\xfa\xc0\xa1\x88\x9f\x47\x79\xa4\x3d\x9d\x2f\x48\xae\x3f\xd6\xa4\xac\xe5\xf3\x2b\x18\x95\xf9\xa4\xbd\xcd\x0b\x74\x00\xa2\x44\xc2\x88\x8b\xbc\xfe\x8d\xa6\xc9\x14\x9e\xb2\x34\xa7\xaf\x32\x32\x5f\xc8\x87\x9f\x54\x55\xb1\x20\x61\x5a\xaf\xe0\xa7\x1c\x78\x51\x2e\xa6\x84\x4f\x49\x4d\x82\xf3\xf4\x0b\x7c\xdb\x4d\x1a\x15\x37\x50\xf8\xe5\x84\xe1\x3b\xfc\x2a\x8a\x39\x74\x97\x66\xd9\x59\x03\x69\x10\x67\x45\x11\x69\x05\x55\x5d\x2c\x8c\xc7\xb2\x98\xd1\xd7\xa4\x9a\x12\xc6\x8d\x99\x45\x45\x1c\x8b\xf5\xe7\x65\xa7\x69\x4d\xcb\x2c\x05\x0f\x01\x59\xd6\x81\x25\x71\x61\x83\x82\x04\x5f\xda\xbf\xd1\x60\x96\xd6\x36\xb2\xe7\x95\x8d\xec\xd3\xe2\x8b\x8d\xec\x33\xfb\xca\x17\xa6\xb4\x19\x5d\x55\x0e\x49\xdc\x6e\x4e\x5b\xe2\xde\x05\x49\x6f\xaa\xdb\x00\x07\x7b\x04\xb6\xf2\xcb\xda\x19\xbb\xa3\xba\xf8\xc8\x98\xa0\x57\xa4\xa2\x8e\xbb\x47\xb4\x9d\x70\xe8\xfa\x24\xb9\x0c\xae\x30\x49\x2e\xc9\x15\x18\x00\xb4\xc4\x85\x89\x14\xe7\xc8\xa8\xaa\x57\x59\x73\x93\x33\xb4\xd2\xdc\x82\x0c\xa3\x1d\xc1\x29\x54\x8e\x8b\xa0\x51\xe1\xf4\xe6\x2c\x76\xec\xfd\x7d\xdb\x95\x79\xfc\x44\x48\x8f\xe0\x32\xbc\xf2\xa9\xb8\x3b\x1a\xaf\xd7\x3d\x64\x90\x95\xda\x70\xb1\xd4\xb6\x3d\x2d\x13\xfd\x8e\xde\x42\xdc\x16\x25\x49\x7b\x30\xd4\x1d\x0e\x49\x72\x49\xaf\x26\x8e\x6d\xef\xc5\xee\xa8\x2e\xd3\xb9\xe3\x7a\xf1\x9e\xbd\xb8\xb5\x7d\x3b\xce\x0a\x02\xac\x85\x60\x6a\xc3\xaa\x02\x15\x8e\xed\xfa\x11\x57\xc8\x36\xdf\xc5\x68\x06\x93\xec\x30\xe5\xd6\xce\x28\x61\x52\xee\x9c\xe6\xcb\xb4\xa6\x73\x58\xcf\x3b\x52\x52\x02\x5b\x99\x54\x9c\x02\x94\x62\xdb\xb2\x3f\x74\x1e\x50\xd8\x15\x53\x28\x4d\xe7\x09\xfc\xc9\x17\x4b\xc0\x96\x19\x5d\x25\x34\x17\x58\x0f\x3b\x76\x4e\x6b\x80\xb6\x20\x25\x01\xd4\xe5\x16\x32\xc0\xf5\x92\x84\xd0\xe6\x06\xba\x30\x96\x8d\x26\x2a\x46\x06\xa3\x90\x6c\x61\x95\xa8\x11\x68\x89\x4b\x1f\x20\x5b\x1d\x3e\x79\x6e\x23\x82\x42\xc7\x55\xa9\x5e\xd0\x57\x5e\xeb\xe9\x8a\x41\xd2\xc2\xe7\xa2\xae\x55\xf7\x1e\x68\xf6\xa7\x4f\xc0\xdc\x31\x84\xdb\x3a\xd4\x46\x22\x7a\x76\x68\xbb\xcd\x18\x01\x6b\x87\x43\xd9\xe1\x8e\xd6\x21\x54\xc1\xc8\x1e\xdb\xc6\x07\x6a\x62\x50\x9c\xa8\x63\x7c\xff\x10\xce\xf1\x06\x9b\x6d\x69\x4f\xe9\x66\x5d\x0d\x46\x69\xe5\xb7\xf9\x78\x92\xe7\x05\x57\x91\xef\xdf\xce\x95\x3e\x0a\xd4\x59\xfb\x8b\xb2\x88\xd3\x4c\xe9\xa2\x18\x41\xdc\x8f\x49\xd8\x2d\xd8\xaf\xca\xb0\x5b\xb8\x2c\xd3\x6e\x21\x58\x80\xeb\x6e\x39\xe3\x2e\x95\x36\x2c\xad\xaa\x34\x4f\xf6\x93\x6c\xb5\x50\x62\x43\x37\x2a\xd2\x98\x23\x7c\x92\x30\x5e\x94\x2d\x06\x9a\x26\xf8\xc7\x51\x3d\x25\xf5\x07\x68\x51\x39\xb6\xad\x63\x60\xaa\x08\xc7\x77\x06\xf7\xb3\x5e\x1f\x1e\x1a\x05\x13\xe2\x91\x51\x71\x93\xd3\xf2\xb5\x60\xa6\x04\x37\xf3\x1a\xdc\x26\x02\xfc\x81\x5c\x06\x57\x8a\xec\x44\x78\xec\x47\x0d\xe7\x12\x31\xce\x45\x44\x53\xbc\x8c\xae\xfc\xb0\x6f\xfb\x87\x97\xf4\x6a\xbd\x76\xec\xba\x58\xfc\x36\xa5\x14\x84\x10\x3a\x59\x85\x8e\x7d\x03\x8f\xee\xe4\xa3\x56\x89\x44\x29\x22\xae\xc7\xda\xcc\x8b\x65\x45\xfb\x1b\x6a\x55\xac\xb5\x59\xf9\xfa\xec\xf4\x94\xd5\x9f\x87\x65\x91\xf1\x06\xac\x5a\x3c\xc2\x10\xaa\xc8\xd1\x8a\x90\x5d\x99\x4d\x8f\x8b\x70\x59\xd9\xfc\xde\x07\x7b\xfe\x31\x5b\x96\xfc\x45\x47\xbc\xc9\x5b\x20\x3b\xe6\x7f\x89\x8b\x44\x05\x34\x45\x76\x00\x7f\x88\x8b\xc2\x91\x28\xc4\x8c\x18\x8d\xe4\xab\x70\x89\x91\xb5\x7f\x45\xf2\x50\x4e\x8c\xc3\xbe\x3a\xe4\x05\x68\x67\xec\x0e\x87\x02\xa8\x68\x84\x54\xa5\x04\xcc\x2b\xf0\x40\x41\xcb\x8a\x8a\xea\xc0\xe0\xd9\x84\xc5\x8b\x64\x95\x82\xc4\x1e\x61\x54\x5f\xa2\xbe\xa5\xfc\xe8\x50\xf4\x25\xba\xa4\x57\xf0\xc6\x25\xbd\x12\x5a\x2a\x86\x02\x7f\x25\xf8\xae\x2e\x16\x2f\x83\xa2\xac\x3d\x9b\xb0\x3f\x36\xe2\xa3\x7b\x9f\x91\x95\xc7\x86\xbd\xc8\xc8\x4a\x2f\xbc\x98\x96\xc5\x32\x99\xaa\xba\x9a\x3f\x43\x93\xd7\x4b\xc1\xf5\x4d\x19\xc9\xf1\xec\x48\x3c\x87\xf0\x0c\x4d\x8e\xe6\x8b\x3a\xa5\x91\x67\x53\xfe\x83\x17\xe6\x61\xb9\x5a\xd4\x50\x2c\x7f\x8a\x8a\x88\x17\x46\xb2\x00\xae\x01\xda\x70\xed\x0e\x0a\xde\x82\x6d\xf0\x35\xa9\x89\x67\x73\x3b\x61\x44\x6a\xa2\x55\x9d\xd2\x9a\x44\x5a\xf5\x5c\x3c\xab\x26\x9c\xa5\x82\xda\x8a\xfd\x84\x8a\xf7\x64\x59\x51\xcf\x5e\xb0\x3f\xbc\x00\xe6\x43\x4d\x06\x7b\x4c\xf3\x84\x97\x30\x42\x06\x85\x65\x91\x94\xb4\xaa\x3c\x7b\x21\x7e\x41\xf1\x07\x52\x53\x39\x23\x25\xa9\xa9\x36\x1b\xe7\x94\xce\xd8\x07\x56\xf0\x57\x15\x01\xe4\x8a\xff\xe0\x85\x35\xe1\xd6\xa0\x8a\xff\xe0\x85\xcb\x8a\x49\x85\x9e\x5d\xf1\x1f\x50\x78\x91\xce\x45\xe2\x23\x0f\x54\xf5\xdc\x0b\x12\xaa\x7e\x65\x1c\xa4\x1a\xc9\x35\x3c\xc9\xb1\x0c\xd8\x36\x24\x69\x0d\x3d\xdf\xf0\x1f\xb6\x66\x5b\x9f\x69\xc9\x94\x43\x20\x50\x8d\x88\x38\x09\xbd\xb0\x45\x8f\x22\x8c\x71\x92\xc0\x2d\x60\x50\xd0\xb8\xa2\x64\xc2\x36\x6c\xba\xa8\xb9\x52\xc3\x21\x38\xec\x15\xb7\x11\xe9\x48\xdb\xf0\x1a\x93\xaf\xb9\xac\xad\x1e\x6d\xc4\x43\x51\x6e\x11\xa7\x5d\x8f\xe0\xfe\xb3\x66\xd2\xee\x9a\xa0\xbb\xb4\xf2\x58\xd5\xc6\xf5\x3a\x95\x0c\x50\xab\xf0\xdd\x39\x04\x27\xed\x51\xbf\x67\x89\xae\xe8\x11\x09\xe5\xd5\x74\x05\x5e\x60\x4e\x97\xab\xe5\xbe\x7a\x57\x44\xd4\x21\xfa\x79\xba\xd0\xa6\x9e\xd3\xed\x38\xe1\x31\x4f\xa5\xfc\x29\x4f\xcb\x34\x2e\xb5\x73\x4a\x1c\xdf\x82\xc6\x32\x4c\xb7\x11\x60\x39\xa3\x1d\x82\x97\x0c\x75\x21\xd2\xbe\x4e\x23\x5a\xc8\xd7\xc9\x32\x4a\x0b\x1b\xc2\x62\xc7\x8c\x71\xfd\x2b\x71\xff\xea\xb0\x8a\x31\x10\x98\x18\xfd\x95\x5c\xc6\x8c\xc0\xf8\x6d\x90\x9c\xf9\x92\x83\x38\xe2\xdb\x56\x6e\xdf\x9e\xf6\xe9\x3c\x91\x03\x48\x99\x08\xb8\xfd\xcd\xfe\xcf\x6a\xc3\x63\x07\xba\x84\x01\x97\x2d\x6c\x24\x0c\x64\x0d\x8c\x73\x6e\x3e\x43\xd2\x8e\xd6\x07\x27\xa2\x35\x49\xb3\x4a\x82\xba\x28\x92\x24\x63\xc4\xb8\x16\x3f\xfa\x3e\x85\xf1\xa8\xb6\x07\x86\xe5\x90\x55\xff\x24\x7e\x71\x10\x27\xf9\x35\xc9\x52\x36\xf8\x54\xfe\x22\xae\x3f\x48\x13\x27\x42\xb6\x24\xa1\xb6\x11\xd6\xc0\xe6\x66\x1c\xdb\x8b\xf1\xa9\x80\x65\xcc\x35\x98\x21\x6c\xef\x4c\xf5\x08\x2a\xfd\xd0\x54\xe9\x6f\xee\x1f\xc0\xbd\xfd\xd7\xf4\xb6\x66\xdc\xba\xed\xfd\x43\xf5\xf1\xfe\x01\x5f\xb5\x05\xa8\xe4\x98\x62\x1c\x6e\x28\xc3\xe9\x18\x4d\xc5\xed\xf7\x04\xc7\x88\xc7\xe0\x9e\x31\xe4\x83\x58\x65\x1d\xec\x9b\xb9\x32\x1a\x55\x72\x39\xbb\xf2\x6d\xe0\x4e\xd9\x36\x9f\x4d\x40\x0a\x9b\x32\x70\x9e\xbd\x85\xff\xe5\x0d\x9d\x29\x9e\x4e\xa6\x23\xce\x2f\x7b\x46\x3c\xaa\xe9\x70\x08\xba\x8e\xa9\xeb\x7a\xb6\x64\xcb\xf9\x5b\x5d\x92\x32\x9d\x38\xcd\xf4\x70\xdb\x11\x18\x1d\xa7\xee\x70\xf8\x0d\x87\xe2\x75\x55\x53\x53\x51\x39\xb0\xed\x3d\xd6\xa0\x5a\x2e\x16\xec\xdc\x10\x9a\xb3\xa3\x28\x05\x2f\xe8\xdf\x48\x99\x0b\x43\xe3\x6c\x38\x54\xad\x54\x7c\xbc\x56\x3d\x59\xd6\x05\xe7\x73\x78\x81\xf3\x0f\xd2\x9d\xba\x89\xfa\x48\x58\x9d\x99\xeb\xd1\x09\xb8\xbe\xcc\xd8\x50\x55\xe5\x91\x2c\x52\x21\xd4\x1a\x72\xc3\x11\xfc\x47\xc8\xd2\xf2\x4b\x0f\x42\x36\xe8\xc2\xdb\x9c\xf7\xb4\x91\x28\x2d\xcc\x24\xd2\x2e\xd2\xf2\xaa\xb1\xa1\xd8\x46\xa2\xbe\x1f\xef\x89\xb2\x89\xe1\x9d\x9d\x50\x3d\xf8\x81\x04\x2b\xed\x26\x13\x30\x8f\xea\x6d\xf8\x85\x71\x35\x08\xd3\xae\xd2\x6d\x6d\xb6\x80\x34\xf8\x26\x46\xf7\xf9\xd8\xc6\xa3\x22\x7f\x95\xa5\xe1\x0c\x8c\x28\x45\x1e\xb2\xdf\x78\xf0\xa3\x61\x32\xfc\xac\x88\x3d\xa2\x32\xfc\x9d\xee\xab\xdd\x9e\xfc\x50\x51\x95\x88\xff\x8a\xd8\x9e\xbc\xbc\xea\x9d\xe3\x50\x91\x8d\x88\xff\xea\x6b\x2c\x67\x33\xdc\x46\x3d\x22\x5e\x11\x75\x2a\x3a\xa0\x9a\xf5\x0f\x15\x99\x88\xf8\x2f\xb3\xe7\xee\xb4\x35\x42\x67\xd8\x4c\x5b\x7f\x8e\xa2\xbe\x59\xfd\xd1\xe5\x04\x25\x6a\x08\x0a\x9a\x89\x00\xf3\x40\x55\x12\x46\x55\xc0\x85\x65\xa7\xc3\x35\x27\x4c\x00\xea\x2b\x14\xe8\x71\x99\xc0\x8d\xfb\x86\xdc\x24\xae\x22\x54\x01\x54\xa3\xc0\xed\xa8\x78\x66\x70\xb9\x7f\xbd\x76\x08\xbe\xdb\xb8\x88\x5c\xce\xae\xf0\xc0\x16\x09\xbe\xb6\xd2\x28\x1e\x94\xa5\xa1\x3e\xe2\xf9\xeb\x74\x22\xf9\x0a\x9d\x48\xda\x74\x22\xe9\xa5\x13\x89\x3b\x89\xd7\x6b\x87\xad\x95\xeb\x39\x31\x8e\xd7\xeb\xcb\x2b\x97\x27\x20\x4b\xf8\x95\x2b\xb7\x99\xd0\x48\xd2\xe3\xe8\x32\xb9\x12\xc6\x7a\x30\x66\x5f\x26\x57\xfa\x55\xf2\xbe\xc9\x9d\x0a\x73\xba\xa0\x3c\x4a\xd3\xe2\xb6\xe7\x9a\xdb\x33\x9a\x19\x77\x77\x7a\xe6\x1a\x12\x3a\x4d\xfb\xca\xdb\x6b\x60\x8b\xbb\x3a\x00\x6c\xea\xf6\xbc\x33\x1c\x06\x97\xb3\x2b\x46\xcb\x2f\x67\x57\xdd\x45\x64\xa5\x32\x4a\x2b\x9b\x2a\x39\x5d\x28\x96\xd3\x44\x5c\x17\x11\x3c\xbd\x7f\xa5\x31\xc6\x83\xa4\xff\x38\x0a\x70\x30\x09\xb6\x1d\x51\x01\x1b\x18\xc4\x77\x33\xd7\x06\x4e\x94\xd6\xc1\x95\x4c\x02\x1e\x0e\xa9\xeb\xb9\x32\xed\xf3\x5c\x99\xc2\xb7\xf4\xc0\x7d\xc8\x49\xf5\x00\x0c\xec\x47\x38\x47\x3f\x99\x28\x4a\x5c\x14\xaf\xd7\x62\xe0\x7c\x6a\x7b\x50\x91\x1d\x50\xa4\x33\x0d\x02\x6f\x34\x2e\x3d\xd6\x88\x6d\x69\x10\xdb\x38\xe1\x79\xf0\x23\x0c\xbf\xa8\xab\x34\x28\x60\x09\x6a\x34\x28\xf1\x1e\x7e\xac\x2e\x8f\x31\xbe\x77\xc6\xfe\xec\x1d\xea\x1c\x48\xc2\x39\x90\xd9\x57\x39\x90\x64\xf2\x4f\x7e\x35\xb8\xbd\x52\xdf\x88\xe2\x48\x1c\xd4\x33\x7e\x3a\x27\xac\xac\xeb\xbc\x99\xc8\xc3\x6b\x36\x39\x52\xcd\xc0\xf3\xb4\x89\x7d\x1a\xb6\xce\x0e\xf0\x05\xa4\xae\xff\xaa\x9d\x66\x4d\x23\xdc\x1f\x44\x9b\xfe\xf3\x76\xbb\xa3\x00\x56\xa8\xdb\x6e\xa5\xf9\xb1\xa0\x7b\xea\xf0\xce\x0e\xd5\x0e\x5c\x4c\x85\xcb\x88\x24\x29\xe2\x50\xd6\xdb\xc0\x11\xce\xb6\x83\x5e\xac\x28\xca\x80\x1a\x87\x76\x0f\x00\xda\x39\xd5\xbd\xbe\x46\xf2\xe7\xe4\xf2\xca\xb3\x6d\xd6\xa9\x71\x82\x57\x06\x52\xfd\x3b\x22\xda\x43\x44\x33\x40\xcf\x87\x8b\x67\x7f\x47\x34\xfb\x4f\x8a\x65\xff\x09\x91\xec\x6f\x8a\x63\xf7\x88\x62\x5f\x11\x55\xe8\x56\xf9\xa7\x2d\x61\x0d\xfe\x65\x48\x1d\x49\x0a\xdd\x03\x0a\xb5\x41\x71\xe6\x26\x04\xe6\x26\x6a\x98\x1a\x20\x49\x9c\xb1\xe9\xe5\x5f\x9c\x98\x73\x27\x2d\x4a\xd3\x15\x66\xe2\x89\x61\xde\xe7\x79\x74\x9c\x08\x5f\x36\x6f\xa2\xf8\xaa\x4f\xa0\x89\x19\xeb\x6e\xbe\x6a\xdb\x7b\xdd\xb7\x59\xe1\x95\xeb\xf5\xd1\x7f\xc9\x67\xc5\x8a\xfe\xf7\x68\x3a\xfe\x13\xa2\x87\xe2\x74\x0d\x26\xf9\xeb\x8c\xbc\xc6\x91\x0e\x4c\x9e\xb3\xb9\xaf\x2e\xa9\x41\x6d\x68\x82\x2c\xcd\x91\x81\xb1\x3b\x5c\x0b\xbb\x4c\xda\x37\x00\x0d\x35\x93\x37\x4b\x90\xa9\x1f\xf2\xb2\x04\x55\xec\x1c\x01\x7a\x2b\xa6\x2e\xa5\x95\xb7\x48\x50\x94\xc6\xb1\x56\xf2\x39\x11\xf7\xa0\xb5\xb2\x92\xb7\x12\xd1\xda\x23\xad\xa6\x32\x6b\x58\x7f\x5e\x9d\xa0\x1b\x52\xe6\xc7\x45\xf9\x31\x9f\xf3\xdb\xab\x17\xad\x3c\x29\x1b\xd9\x02\xa2\x53\xd0\xa8\x09\x9c\x2f\x3f\xe1\x41\x8d\xb7\x82\x3d\x81\x4c\x7b\xb2\x29\x8d\xee\x83\xda\x6e\xdb\x05\x5a\xd2\xaa\x2e\x4a\xb8\x18\xce\x7d\xec\xdb\xd1\xe5\xb9\x19\x70\x0b\xca\xfd\x2c\x11\x09\x87\xdc\x69\x99\x71\xa7\xca\x1d\x3f\x34\x2e\x3b\x0b\x36\x35\x84\x3c\x22\x0b\x52\xd2\x1c\x96\xcf\x77\xe1\x8a\xb9\x56\x10\xe2\x70\xf4\x79\x49\xcb\x15\x77\x46\x2d\xca\x97\x59\xe6\xf0\x1e\x2f\x59\x27\x7f\xdc\x3e\x89\xec\xbd\x9f\xcf\xcf\xde\x8d\xf8\x5e\x4d\xe3\x95\x03\x7e\x8b\x7b\xbb\x57\x97\xac\x4b\x68\xc1\x87\x71\xb5\xeb\x0a\x17\xa4\xb1\x1f\x34\x8e\xbd\x81\xb4\xfb\x44\x38\xbc\x0c\xae\x80\x0f\xe7\xd7\x00\xa3\x11\x23\xc9\x60\x62\x62\x3f\xa4\x96\xb1\x0a\x9c\xc8\xf5\xa9\xee\x38\x39\xb6\x5d\xff\xe7\xd8\x01\x4f\xac\xcd\xe6\x1e\x8e\x61\xcb\x4e\x53\x92\x78\xe3\xcd\xb9\x45\x14\xdf\x6c\x36\xae\x9f\x87\x23\x7e\xc3\x17\x2e\xd8\x36\x0b\xc6\xe3\xb5\x88\xbb\xe0\xce\x52\x48\x78\x3f\x25\xfc\x7e\xe3\x49\x22\x28\xa2\xba\xf3\x90\x34\x6e\x6c\x3b\xce\x0e\x59\xaf\x0f\x77\x74\x7b\xda\x70\xf8\x5d\xeb\xf9\xb0\xdd\xc0\x79\xb1\x63\x9a\xe4\x6c\x0b\x2e\x78\xee\x43\x1a\xdb\xfd\x45\x91\xe6\xf5\xbe\xbc\xb3\x6e\xd9\xaa\x31\xf7\xbc\x34\x1c\xf9\x13\x71\x3b\x7b\xf2\x5d\xcb\xa8\xd7\x76\x8d\xf2\x74\x45\xb6\x91\x49\xa0\xe7\x1b\xd6\xeb\x1d\x20\xa5\x9a\xca\x24\x22\x35\xd9\x87\x51\x96\x45\x51\xdb\x6c\x14\x6c\x9a\x7e\xc7\x79\xec\xdc\x75\x73\x27\xf5\x26\x96\x92\xe0\xdb\x04\xf8\x3b\x11\xea\xf2\xd0\x23\xd8\x21\xb8\x33\x76\x77\x62\x7a\xe4\x79\xbf\xf2\x6b\x23\xc8\xee\x28\xff\x02\xfc\x02\xbc\x14\x89\xb6\x21\x3c\x82\x08\x0e\x0c\x08\x5c\x1e\x04\x97\xe0\x9a\x24\x70\xcd\x8c\x60\xe1\x50\xa9\x22\x93\x40\x76\xa6\x76\xae\xa8\x56\xdc\x0b\xd1\x56\xbe\x8a\x3a\x41\x39\xfa\xae\x6e\x13\x95\xe5\xa2\x89\x66\xa1\x11\x95\x9f\x12\xbc\xe0\x29\xea\x08\x8e\x88\x48\x51\x1f\x39\x84\x47\x35\x15\xe8\xcf\xf3\x58\x94\x35\x77\x44\xe4\x33\x7c\x07\x16\x27\xb8\x43\xa6\x37\x41\x34\x8f\xf4\xc2\xa3\x3c\xda\xf0\xcb\x2c\x2a\x9c\x8a\xb8\x49\x9b\x50\xe1\xc0\x9e\x16\xf9\x70\xd8\x53\xe8\xb8\x70\xd7\x3a\xe4\xb1\xbd\xc2\x51\xc9\x38\x08\xf0\x8d\x72\xef\xd8\x76\x24\x79\x38\x2d\x4a\xa0\x42\x82\x38\x88\xa2\x33\xf0\xd2\x41\x14\x87\x23\xb0\x95\x2a\x42\x05\x4f\xbc\x16\xe2\xa7\x34\x96\x0d\x44\xd5\x4f\x11\x2a\xf3\x96\x75\x92\xeb\xc9\x30\x85\x3c\x85\x12\xbc\x7f\x88\x66\xec\x9f\x29\x1e\xa3\x12\x8f\x51\x8e\x89\xc8\x0c\xe3\x07\x2a\x9b\xb0\x64\x6b\x96\x90\x5a\x98\xeb\x55\xc7\x3c\x9c\xd5\x93\x1d\x8c\x73\x6d\x03\x38\x09\x8e\xf7\x22\xd7\x67\xad\x28\x6f\x15\xf6\xb4\x9a\xe1\x78\x2f\x74\xfd\x27\x58\x2f\x67\xbc\xd1\x9e\x78\x86\x3d\x2b\xa8\xa6\x1e\xff\xd0\x59\xe2\xdc\x30\x2d\x71\x3c\x5e\xe1\xdc\xcf\xf1\x72\x23\x47\xcc\x5e\x68\xd2\x48\x5a\x81\xbf\xe2\x81\xb4\xf7\xf6\xa6\x98\x87\xe1\x4a\x70\xec\x42\x29\x65\xa5\xa5\x70\xa4\x99\xb1\xd2\x26\xb8\x1f\xf4\x06\x01\x4f\x78\x7c\x76\xd9\x5d\x8e\x57\xac\x4b\x6d\xb3\x6c\x58\xef\x01\x06\x5f\x8b\x64\xbd\x86\xbf\x33\x1e\x2c\x61\x20\xf0\x2b\x01\x84\x9a\x89\xeb\xd1\x7c\x45\x36\x01\x9b\x4b\xd1\x60\x0c\x0d\xc6\x46\x03\xff\x24\xc1\x77\xb0\xd8\xfc\xc4\xf5\x08\x52\x08\xf9\x01\x6c\x88\xc1\xc6\xff\x1c\x39\x8c\x5a\xa3\x76\x94\x27\x7d\x77\xf0\x7d\x71\x92\xa0\x00\x36\x07\x02\x37\xd4\x06\x2e\x8f\xc1\x6f\x40\x86\x7b\x2a\x7c\xfd\xa6\xc4\xd9\xe6\x3b\x0a\xb7\x69\xf9\x4e\x0b\x41\x4b\x14\x60\x88\x42\x51\xd6\x88\xe0\x68\x44\xf3\x08\xa9\xf8\x24\x22\xe7\x80\x8b\x7a\x36\x23\xe3\x96\xcd\x52\x1c\xa0\xd0\xd8\x7d\x18\xae\xee\xcf\x53\x46\x43\xc4\x11\xa6\x30\x44\xde\x71\xeb\xd9\x7c\x0c\xfb\xfb\xf7\xa4\x70\xe9\xba\x3c\x0a\x1c\xf7\x4a\x1e\xd1\xa4\xe9\x46\x7e\x08\x75\x55\x32\x0e\x88\xbf\x48\xf3\x68\x42\x3c\xad\x19\xfb\x4a\xea\xfa\x3b\xc1\x88\xde\xd6\x34\x8f\x86\x43\xf2\xc3\x20\x82\x84\x18\x11\x9b\x59\x44\x30\x75\x7d\x8a\x8f\x23\x27\x6c\xec\x7e\xf0\xc4\x93\x13\xd1\xe1\x90\xb1\xe7\x87\x90\x10\xb1\xa1\x0e\xeb\x75\xa0\xd1\x06\x48\x6e\xc0\x36\x47\x53\xcc\x29\x00\x54\x70\x87\x3e\x56\xa5\x28\x05\x13\x19\xd4\x0b\x1a\xc5\x80\x72\xde\xde\x95\x3a\x94\x96\xe7\x35\x60\x80\xe3\xfa\xc9\xa8\xa2\x35\x2c\x87\xc3\xfb\x46\xb2\x27\xd7\x0f\xa4\x02\x24\xcb\xa0\x79\xe5\xb8\x3e\xf9\x21\x9a\x38\xc1\x88\x44\x11\x87\x90\xb8\x48\x4e\x8a\xc3\xc7\x82\x9a\xae\x3d\x07\xc0\x1f\xf5\xd4\x21\x03\x86\xbb\xd9\x04\xf8\x92\x7b\xd3\x10\x1c\xf2\x6c\xd5\x1a\x2b\x67\xba\xe6\x0c\x87\x01\x57\x3c\x35\x31\x67\x50\x46\x63\xa0\xf0\xe0\xa9\xf2\x96\xc6\x35\xaa\x8b\x85\x2a\xb8\x28\x16\x1b\xd7\x4f\x09\x44\x1e\x57\x17\xad\x02\xfd\xa2\x15\x01\x97\x3f\x44\x46\x02\xa6\x06\x0a\x93\x11\x03\xdf\xa9\xbb\x28\x16\x78\x40\x46\x75\xb1\xd8\x48\x76\xe8\x73\xe4\xfc\x94\xb8\xbe\xe0\x92\x36\x42\xa4\xd8\x92\x29\x8a\x2b\x2f\x08\xd6\xcc\xfe\x3e\xb9\x3c\xbb\xc2\xd4\x27\x97\x8b\xe0\x4a\xbf\x74\x86\xb8\x73\xfa\x89\xbc\x12\xcb\xb8\x15\xf3\xc8\x6d\xf9\xaf\xf3\xa8\x29\x24\x4b\xbf\x50\xfd\xa5\x92\xe6\x9d\x51\xb8\x77\x0b\x7d\x04\x5e\x87\x2b\x0f\x96\x75\x0d\xa6\x0d\xc3\x28\xd2\x23\xde\x35\x0c\x2a\x01\xeb\x90\xd2\x7d\xab\x93\x09\xc2\x1c\x76\xce\x7b\xe1\x4b\xd1\x37\x3d\xa2\xad\x61\xb2\xd9\xa0\xbe\x84\x75\xbd\x2c\x48\x33\x24\x6c\xdc\x26\xd4\xdd\x14\x1a\xbf\xc3\x1e\xb7\x76\xbd\xb6\x71\x0e\x1c\x7c\xdd\x3b\x50\x5e\x5e\xbb\xc7\x7f\xb0\x67\x2c\x5b\x1a\x0b\xbd\xb4\xfc\xf0\xd7\x74\x51\xa6\x45\x99\xd6\xe9\x17\x7a\xbe\x0c\xea\x92\xd2\xde\xaf\xdf\xd9\x09\x46\xd3\x34\x8a\x68\xbe\xd1\xa4\xdb\xad\xe8\x08\x51\x81\xb8\x2c\xcd\x11\x31\xd2\x10\x30\x2f\x6e\xbc\x45\x8c\xe4\x6d\x7a\xef\x4e\xcb\x10\x6f\x46\x16\xe2\xa4\xc8\x51\xb9\x8d\xef\x59\x5d\x8e\xe7\xd4\x2f\xcd\xe5\x6d\xe7\x96\x6f\xc1\xd7\x2f\x45\xd8\xb6\xec\xa6\xc9\x3a\xdf\x11\x33\xf5\xab\x0d\xa1\xdc\x4b\x0f\xdb\x44\xfd\xc9\xea\xf5\xd7\x06\x81\x7b\xf7\xa2\x2d\x66\x34\xd4\xcb\xc8\x69\xef\x04\x88\xb8\x5e\xb7\x17\xbd\x4d\xcf\xe8\x5b\x20\x42\xf5\x46\x27\x31\x7e\xe7\xe5\xbf\x31\x32\x48\x9e\xd9\xd3\x95\xe6\xf7\xd3\x99\x2e\xdd\x27\x28\x30\xdb\x1a\x29\xf8\x5b\x2f\xde\x37\x2a\x13\xa4\xd7\xe9\x63\x83\x54\x52\x4a\xef\xae\x9b\x78\xb1\x5f\x12\x69\x0b\x72\xc1\xa8\x2e\xde\x16\x37\xd2\xf3\x5c\xd5\x42\x20\x7f\xa3\x4a\x44\xc4\xda\xa0\xfe\x64\x8e\x6d\x4c\x10\x64\x07\x2e\x85\xad\xd7\x4f\x8c\x6e\x15\xa8\x6d\xc9\x1f\xcd\x04\xb4\x3c\xc1\xa7\xce\x9f\xfa\x64\x38\x6c\x4b\xcd\x66\x17\x90\xe5\xd3\x78\xc5\x10\xdb\xfa\xb2\x4a\xf6\x76\xaa\xdf\xaa\xfa\x77\xfa\x9c\xde\xb3\x38\x7c\xbb\xa3\x98\x91\x81\xb3\x2b\x1c\x8b\x53\x2f\x94\xaf\x2b\x25\x3f\x45\x91\xab\x40\xdd\x43\xc1\x04\x20\x05\x40\xe8\x05\x37\x28\x4a\xa3\x77\x45\x7d\xca\xa4\x25\xa9\xb2\x52\x98\xb9\x2d\x19\x68\xef\x5b\xdb\x1b\x0f\x78\x6b\xd1\xf0\x55\x13\xd4\x71\x3b\xe4\xad\x88\xdb\x34\x39\x4e\x73\x4d\x77\xf7\x20\xa8\x5b\x5e\xf9\xda\x67\x9a\xaf\x3d\xbc\xe5\x56\xb8\x1b\xb4\x2d\xbe\xad\xf7\x39\x46\x9d\xe8\xb6\xfc\xaa\x40\x19\xe2\xdf\x5b\x21\xfe\x34\xe7\xed\xb7\x86\xd5\xe7\xe7\xc4\x09\xf5\x98\x8c\x8f\xc7\x63\x5b\xb9\xdc\x89\xd8\x92\x1f\x8a\xa2\x09\x3a\x0c\xa9\x0c\xdd\xdf\x47\xad\x98\x95\xe0\x12\x05\xf6\x37\xb8\xba\x16\xe1\x68\xbd\xfe\x85\xc1\xe6\x59\x45\xc1\xed\x40\x85\x54\x8b\x45\x5a\x2b\x71\x69\x30\x34\x88\x53\x2c\xdd\xaa\x7e\x1f\xb5\xc2\x82\x72\x41\x60\xcb\xb8\x70\xe2\xff\xde\x89\x5a\xa8\xdf\xd0\xec\x1b\x72\x02\x43\xde\x28\xb5\xcc\xef\xa3\xde\x70\x85\x4e\xac\x5d\x49\x3e\x4d\xf4\xbb\xd3\x8f\xbf\x27\x65\x02\x32\x41\x25\x18\xe1\xe1\x90\x7f\x25\xdb\xdd\xb2\xea\xf2\xf1\xd5\x44\x7f\xe0\x3a\xb2\x9f\x13\x27\xe8\xce\xbd\x18\xca\x7b\x0a\xcb\xc4\x03\x8f\xea\x6a\xb9\x77\xa2\xff\x7a\x9a\x56\xbd\x13\xd1\x9d\x37\xd8\xbf\xef\x12\x2d\x68\x65\x49\xf3\x88\x96\xad\xdb\x8c\xdd\x19\x22\x68\x5b\x2f\x2a\x7f\x93\x6f\xc0\x5d\xe6\xa0\x66\x34\x6e\xe5\x76\xc1\xc2\xbb\xf7\x43\x26\xae\x08\x50\x76\x96\x60\x61\x64\xe0\x01\x18\xbd\xd3\x04\x22\x19\xbe\x3e\x3b\x05\xfd\x5b\x2b\x4c\xb0\xb8\xa9\x6c\x04\x8f\x4c\x63\xc7\x94\x7d\x64\x2d\x51\xe9\x4b\xfb\x82\xa8\x82\xf7\x86\x42\x8c\x76\xb8\x45\x27\x70\x7b\x53\x0d\x12\x31\xb7\x3c\xf0\xef\x0b\xdb\x85\x95\x3d\x7c\x62\x23\xe3\xc2\x97\xdb\xd0\xe2\x0e\xfd\x15\x7d\xbe\x4d\xf8\x44\x41\x8e\x90\xb1\x60\x22\x18\xe8\x07\xbd\x70\x08\x2f\xa8\xe0\xa4\xfc\x4d\xc1\xe6\x9e\xe4\x75\x3f\x17\x26\x18\x58\x75\xdd\xbb\x51\x4a\xf4\xcd\x10\xfb\xc4\x27\x2f\x3a\xd1\x19\x14\x81\xd9\x39\x84\x23\x47\xe0\x84\x52\x83\xbf\xac\x3b\x0b\x07\x7a\x6f\xb9\x13\x06\xaf\x1d\xfb\xa9\xb6\x13\x48\x1f\x96\x4c\x9c\xfb\x77\xbb\x9c\x0b\x31\x21\x3b\x87\x48\x0f\x9a\xd7\xbb\x6f\x78\xd0\xd4\x8d\x2b\x72\x87\x6b\x93\xd7\xc6\x3f\x55\xd1\x0a\x9b\x5a\x87\x4d\x55\x3b\x5e\xea\xef\xf7\xc4\x4b\xfd\x5d\x8b\x97\xfa\xe9\xd3\xf9\xd1\xab\x0f\x47\x17\x9f\x4e\xde\x5d\x1c\x7d\x78\xf7\xf2\xed\xf9\xa7\xd7\x67\x9f\xde\x9d\x5d\x7c\xfa\x78\x7e\xf4\xe9\xec\xc3\xa7\xff\x3e\xfb\xf8\xe9\xb7\x93\xb7\x6f\x3f\xfd\x78\xf4\xe9\xf8\xe4\xc3\xd1\x6b\xef\x0e\xe2\x2f\xbe\xcf\x96\x49\x9a\xff\xb4\x0c\xbc\x3c\x40\x5a\xc9\x07\x9a\xa4\x55\x5d\xae\xbc\x8f\x44\x14\x97\xc5\x82\x24\xa4\x2e\xca\xca\x7b\x15\x20\x11\xaf\x56\x5a\x2c\xd4\x32\x79\x9f\x43\x5e\xf7\xfa\xec\x54\x15\x5e\x30\x21\xa9\x0e\x54\x85\x11\xf9\xd1\xab\xa3\xcd\xc6\x1f\xfc\x3e\xea\x06\x3b\x75\xee\xb6\x45\x1f\xfd\x1c\xa0\x60\x99\x47\x19\x6c\x4c\x6f\x8c\xae\x69\x59\x31\xa6\xd4\x3e\x7c\x36\x3a\x1c\x1d\xda\x02\xe7\x69\xf9\x9e\x84\x33\x92\x00\x6f\xe9\xd9\xdc\xa4\x11\x15\x73\x7b\xc3\x8f\x8b\xf7\x1d\xcb\xa4\xd4\xda\x9f\x25\x1b\x17\xfd\x23\xc1\xef\x93\xe1\xf0\x2c\x59\xaf\xdf\x27\xfe\xbc\x60\x27\xea\x88\xde\x2e\x8a\xb2\xae\xf0\x3f\x12\x3d\x4e\xa9\xf1\xe4\xfd\x23\xf1\x07\x83\xc1\xc1\xa3\x47\x8f\x0e\xac\x8d\x8b\x06\x07\x8f\xac\xa7\xe3\x67\xd6\xa3\x03\x51\xd6\xe0\x1c\x07\x8a\x2c\x01\x15\x59\x9f\x3e\xdd\xd0\x60\x41\xc2\xd9\xa7\x92\x7e\x5e\xa6\x25\xfd\xf4\xc9\xb5\xee\x06\x03\x7b\x59\x51\x8b\x49\xad\x61\x6d\x0b\xe0\x03\xeb\x91\xf5\xaa\x58\xac\xca\x34\x99\xd6\x96\x13\xba\xd6\xe3\xf1\xe1\x93\xfd\x05\x13\xe1\xf2\x1a\x59\xc7\x24\xa4\x41\x51\xcc\x90\x75\x92\x87\xa3\x81\x05\x2f\x5c\x4c\xd3\xca\xe2\xae\x11\x56\x58\x44\xd4\x4a\x2b\x2b\x4b\x43\x9a\x57\x34\xb2\x96\x6c\xd2\xac\x7a\x4a\xad\xd3\x93\x0b\x59\x6c\xc5\xc5\x32\x8f\xac\x34\x67\x15\x0c\xc4\xdb\x93\x57\x47\xef\xce\x8f\xac\x38\xcd\xa8\x28\xb6\xca\xa2\xa8\xad\x28\x2d\xc1\xba\xb7\xb2\x8a\xd8\xaa\xb5\x8e\x18\xf9\x90\x03\xf8\x2f\x46\xf2\x20\x7e\x54\x35\x60\x33\x02\xf4\x3a\x05\xa5\x9a\x85\xfb\x3e\xdf\x79\x3a\x7e\xee\xfa\xea\x8b\xff\x0b\x2e\x3e\x5a\x77\x8f\x36\x16\x57\x0a\x58\x17\x53\x2a\x7f\xd6\x85\x05\xa0\x47\xd0\x52\x90\x82\x3b\x71\x81\x74\x63\xfd\x36\xa5\xf5\x94\x96\x56\x51\x5a\x79\x51\xc3\xc0\xc5\x8b\x69\x65\x11\xeb\xf5\xd9\xa9\xc5\x04\x5c\x8b\x91\xfc\x11\x8c\xae\xb9\xbd\x56\xa9\xdb\x0b\xfc\x15\xb6\x2a\x96\x25\xba\xe0\xe3\x57\x35\xc3\xa1\x80\xab\x0e\x0f\x0b\x63\xeb\x89\x3f\xd8\x0c\x06\x26\x1a\x59\x58\x83\xec\x77\x70\xe6\xf9\xff\xc3\x99\x5e\x9c\xf9\x3f\x83\x0b\xbd\x68\xd0\x41\x01\x30\x2b\x15\xa1\x85\xe5\xfb\x13\xb9\xf8\xc6\x25\x18\x6b\xbd\x96\x0d\x3c\x15\x2e\xc2\x97\xef\x0b\xc7\xac\x94\xde\x58\x98\xd5\x8e\xf4\x92\xf5\xda\xe2\x5a\x76\xbf\xc1\xb8\x9d\x1d\x31\x08\x86\x6c\x8e\x74\x16\x6e\x5e\x1a\xf1\x0d\x85\xb1\xb5\x2b\x07\xbf\xab\x46\x66\xa5\x82\x90\xf6\xbd\xe3\x59\x02\x9a\x68\x0b\x30\xf8\xef\x5d\xd6\x99\x51\xab\x23\x38\xb6\x76\xb9\x12\x6f\x4b\x33\x46\x84\x79\x33\xae\x7d\xdb\x75\xdd\x6d\x3b\xa2\x7f\x37\xbc\xf8\x0f\xee\x86\x83\x47\xd6\x6f\x47\x3f\xbe\x7f\xf9\xea\x17\xeb\xd7\x97\x1f\xac\x93\x77\x3f\x1f\xbd\xba\x38\x39\x7b\x67\x3d\x3a\x68\x60\x2f\xca\x22\xa4\x55\xe5\x5a\x77\x07\x8f\x1e\x59\xff\x25\x91\x1b\xce\x31\xeb\x9a\x9f\x35\x0c\xbb\xd4\xc1\x32\x8a\xe8\x35\xcd\x8a\x05\xa8\xaa\xff\xaa\x04\xfa\xfe\xdf\xb5\xe1\x0e\x06\x83\xc1\x20\x8d\x2d\xf9\xf5\x23\x9a\x5f\x8f\xde\x9d\xbd\x3e\xfa\x74\xf4\xee\x57\x6b\x07\x63\xcb\x5e\x94\x45\xb4\xe4\x3c\x2c\xdf\x03\x1a\x13\x65\xdd\x0d\x76\x9b\x99\xde\xf5\x39\x81\xe7\x53\xd6\x4f\xdf\x0f\x45\x9c\x8d\x34\xbf\x26\x65\x4a\xf2\x6d\xed\x5e\x3c\x17\x0d\x6f\xb8\x93\xed\x36\x70\x87\x8f\x45\xbb\xa3\x5b\x1a\x2e\xb9\x85\xeb\x3a\x2d\x8b\x1c\xb6\x61\xff\x4b\x8f\x9f\x8c\xc5\x4b\x9f\x48\x55\xa5\x49\xbe\x6d\x0c\xcf\x44\x33\x3a\x5f\xd4\x2b\x19\xd3\xe7\x9b\xc3\x6d\x47\xd7\x77\x72\x28\x3a\xcb\xb3\x75\x0c\x72\x26\x12\x5a\xbf\x0c\xeb\xf4\x5a\xfa\x17\x6d\x7d\x41\x7e\x69\x35\x25\x59\x56\xdc\x1c\x7d\x5e\x92\x6c\xeb\xb4\x3c\x11\x8d\x45\xda\x8b\xfb\x8e\xdc\xc7\x4f\x64\x63\x65\xf1\xda\xda\xf2\xa9\x3e\x23\x67\x82\x66\x6c\x19\x82\xfc\x40\x20\xcc\x8c\xa5\x64\xa4\xa3\xda\xd6\xfc\x5b\x09\x7a\xba\x5a\x4c\x69\x4e\x6a\x7a\x5e\xaf\x32\x41\x47\xb6\xb0\x0a\x72\xc2\x43\x32\xa7\x59\xfa\xe5\xeb\x6f\xc0\x98\xe4\x81\xf2\xdb\xcb\x0f\xef\x4e\xde\xbd\xf1\xac\xd7\x67\xd6\xbb\xb3\x0b\x6b\x4e\xf2\x25\xc9\xb2\x95\x25\x5e\xe0\x1b\x46\x10\x2c\xb5\x53\xe1\xc0\x10\x29\x48\x61\xb9\xe2\xa2\xb4\xfe\x54\xe8\xec\x8c\x46\x23\xf7\x4f\x6b\x59\xf1\x74\xa3\x6c\x27\x82\x3f\x29\xdf\xda\xd5\xaa\xaa\xe9\x9c\xc1\x22\x79\x64\xdd\xa4\x59\x66\x7d\x2a\xf2\x6c\xf5\xc9\x0a\xa8\xec\x56\xbd\x17\x16\x65\x49\xab\x45\x01\xc9\x2a\xac\x80\x04\x34\xb3\x16\xa4\xaa\x60\x2c\x27\xb5\x45\xb2\x1b\xb2\xaa\x2c\xc8\x39\x56\x89\xcd\xbc\xc3\xf7\xde\xa4\xd9\x5f\x4e\x4c\xb2\x8a\x22\x6b\x57\x32\xe4\xd6\x0d\xa9\x2c\x7e\x7d\xd8\x0a\x40\xff\xcc\x37\xec\xc8\x3a\x25\x33\x6a\x55\xcb\x92\x5a\xab\x62\x09\x4d\x60\x1c\x1c\xe4\x82\x33\xd7\xf2\x15\x56\xcb\x86\x25\xa1\x8e\x76\x5d\xcb\xb3\x64\x40\xfc\xc1\xc1\x01\x3b\x9d\x2b\x6a\xa9\x48\xbd\x95\xc5\x6d\x2a\xec\x4b\x49\x96\x59\x59\x71\x43\x4b\x30\x67\xd5\x85\x05\x08\xcd\x66\x92\xbd\x08\x85\x69\x5e\xd1\x9c\x07\xb2\xb1\x04\x33\x00\xa4\xe5\xe8\xfc\xe8\xc3\xaf\x47\xaf\x3f\xbd\xff\x70\xf6\xfe\xdc\xc2\x40\x90\x54\x0c\x3f\xab\x2e\x97\x14\x0d\x2c\x6b\x8b\x79\x47\x6b\xa0\x87\x02\x6c\x97\xca\x48\xb8\xaa\x3c\xed\x02\xb8\xff\xca\x40\xb7\x5d\xfb\xd2\x80\xd6\x82\x21\x2d\x7f\x1c\x6c\xfc\x81\x16\x7c\x85\x0d\xe3\x94\x54\x33\x87\xbb\x99\x59\x41\x5a\xcf\x49\x35\x33\x98\x51\x5e\x67\x0d\x9b\x4a\x76\xe8\x8a\x07\x38\x71\xd9\xb4\xbd\x3e\x3b\x95\x4e\xa9\x27\x20\x79\x31\xf8\x7c\xf2\x60\x33\x58\xd6\x23\xeb\x94\x2c\x16\x6c\x45\xe3\xb2\x98\x5b\x79\x51\xce\xc1\xa8\x19\x21\xbe\xbb\xd8\xa2\x44\x96\x8c\xd8\x6c\x81\x37\x13\xac\x1c\xa3\x30\x71\x9a\x88\xcb\xf1\x56\x3d\x25\x35\x87\x57\x2d\x68\x98\xc6\x29\xad\xac\x69\x71\x03\x88\x44\xaa\xaa\x08\x53\xc8\xc4\xcb\xf0\x50\x01\xd3\x10\x23\x64\x87\x10\x8d\x18\xa3\x26\xa4\xba\x68\x04\xe0\x0e\x06\x96\x75\xfa\xf1\x9c\xcb\xb8\x6c\xf1\x8f\x3e\x5c\xfc\xb7\x67\x8d\x6f\x0f\xd9\x1c\xfe\xf4\xf2\xfc\xd3\x8f\x67\x67\x6f\x8f\x5e\xbe\xfb\xf4\xeb\xcb\xb7\x1f\x8f\x58\xcd\x53\x59\xf3\xee\xe3\xe9\xd1\x87\x93\x57\x4d\xcd\x0b\x59\xf3\xfe\xec\xfc\xe4\xe2\xe4\xd7\xa3\x6e\x93\xc3\xb1\xb5\xd6\x5b\x9e\xfd\x7a\xf4\xe1\xed\xd9\xcb\xd7\x47\xaf\xbb\x1d\x3d\x1e\xcb\x56\xe7\x17\x1f\x4e\xde\xbd\xe9\x19\xca\x18\x0d\xf4\xb9\xe6\x8b\x60\x55\xc5\x9c\xf2\x79\xe2\x73\x6d\xcd\xf2\xe2\x26\xa3\x51\x42\x2d\x12\x14\x4b\xce\xa8\xb2\xcd\xc5\x49\x4f\x4d\x66\xb4\x52\x33\x2e\xb8\x2d\x0e\xf0\x26\xad\xa7\xd0\x3a\x2e\xd8\x56\x62\xeb\xb8\x68\x5c\x61\xa1\x0d\x6f\xa8\x39\xc8\x4a\x9e\x6f\x2e\x16\xde\x58\x13\xb6\xc0\x6c\x7d\x8b\x9c\x72\xde\x81\xf2\xf7\x7b\x31\x29\x2c\x80\xc5\xac\x2b\x60\xb0\x97\x59\x36\xb2\x4e\x62\x46\x44\xca\x66\xff\x5b\x69\x95\xef\xd6\x70\x2f\x89\x96\x80\xf8\xd6\x23\x2b\xad\xad\x9b\x82\x15\x27\xb4\xb6\x6e\xca\xb4\xae\x69\xce\x7a\x95\xdf\xad\x0d\xfc\xf5\xd9\xe9\x4b\x23\x0a\x7b\x67\xfc\x9c\x4e\x35\x1d\xca\x4f\x10\xc0\x38\x18\xb3\x7a\x64\xbd\x34\x9e\x2b\x10\x0f\x24\xe6\x46\x8c\x8c\xc3\xeb\x8f\x1e\x29\x72\x25\x97\xb0\xd9\x21\x1c\xd2\x7d\x43\x5d\x90\xf0\x3f\x33\x5e\x80\x64\x7d\xfc\xf0\x76\x64\x39\x5f\x1f\x79\x5e\x34\x2f\x8d\x5c\x73\x80\xef\xb5\xd8\xeb\x95\x67\x55\xe9\x3c\xcd\x48\xc9\xba\xef\x8c\xde\x0a\x96\xfc\x94\xd3\x10\x24\xa5\xd5\xc8\x40\xa8\xd5\xbd\xf3\x77\xff\x64\x9d\x1a\x91\xe3\x2b\x4f\x43\x52\xa0\x27\xea\x40\x16\x5b\xc5\x92\xc6\x71\x6b\xce\xdf\x60\xe8\xc6\xa1\xfd\x09\xe4\xf0\x4f\x76\x4a\xab\x18\x8f\x08\x86\xd0\x7a\x47\x12\x9d\x65\x5e\x51\xbe\xcf\x24\xea\xeb\x83\x93\x32\x27\x5f\xb9\x8d\x15\x15\x73\xf9\xbd\xaf\xf8\x26\xe4\x07\x35\xfc\x24\x95\x15\xd1\x2a\x2c\xd3\x80\x46\x6c\xff\x5e\xd3\x86\x74\x71\x7d\x97\x36\xef\xfc\x75\xcf\x52\xd4\xde\xe9\xc0\xe6\x74\x9e\xcb\x8c\x3a\xd5\xee\xdb\x82\xbe\x6a\xa9\xcd\x1d\xee\x8e\x77\xa4\x55\xaf\xd7\xd6\xdd\xa6\x79\xb1\x1f\x6b\x7b\x81\x6c\x69\xfa\x35\x80\x0f\x83\xd5\x03\xa6\x85\x20\xdb\xe0\xb4\x9b\x09\x40\x00\x89\xe1\x2f\x38\x5f\xb2\x65\x06\x16\x31\xcd\xb5\xb9\x92\x73\x6d\x59\x3b\x3b\x1a\x8a\xb7\xee\x73\xc8\x77\xdd\x3e\x06\xcb\xde\xb2\xc6\xc0\x11\x7a\xd6\x7f\x17\xcb\x5d\xc6\x53\x96\x2b\xb6\xf7\xeb\x42\xa0\x84\x49\x75\x77\xff\x67\xb5\x6b\xdd\x4c\xd3\x70\x6a\x4d\x49\x65\x91\xac\xa4\x24\x5a\x59\x01\xa5\xb9\x68\x4f\xa3\x11\x03\x65\xcd\xc9\x4a\x1c\x98\x69\x44\xf3\x1a\xf8\x56\xde\x02\xc0\x4f\xa9\x55\xb1\x8f\x34\xa0\x0b\x3c\xad\x6f\xd2\x90\x22\x46\xaa\x57\x0d\x20\xed\xdd\x9b\x42\xb4\x14\xbb\x6f\x4a\xae\x39\x8e\x67\x29\x6f\x61\x72\x01\x23\x1b\x59\xcd\xc4\x68\x3c\x20\x9f\x4f\x48\x0b\x25\xcd\xfc\x91\x85\x55\x5b\xd3\xfc\xef\x6b\xcd\x59\x0b\xb1\xbd\xb0\xb6\x46\x97\xf2\xcd\x2b\x03\xf8\x42\xed\x85\xb8\x10\x3c\x0d\xff\x9f\x91\x24\xc2\xd3\x06\x81\xfa\x9b\x00\x16\x7b\x70\x7e\x35\x2d\xf4\x1c\x15\x9e\x1a\x7b\x53\x6f\x66\xbd\x90\x6f\x6b\xd5\x46\xda\x0b\x4f\x63\xea\x9a\xaf\x44\xcd\xf6\x1e\x75\x78\x1c\xb7\xe9\xab\x95\x1f\xe3\xeb\xc0\x3a\x6c\x91\x09\x4c\x4f\xa9\xf2\x30\x60\x06\x9b\x64\x02\xeb\xcb\xd3\xf2\x30\xa0\xfd\x4c\x98\x09\xbd\x3f\x73\xca\xc3\xe0\x6f\x63\xdd\xcc\x1e\x78\xfe\xaa\xbf\x0f\xbd\x8f\xe5\x73\x05\xe0\x8d\xc4\xea\x1d\x47\xc7\xd2\x76\xa2\x13\x6b\xcf\x6a\x57\xeb\xb3\xd8\x53\xdd\x3f\x1d\xd6\xf7\xd8\x3a\xec\xa7\x4d\x1a\x55\xf2\x2c\xde\x38\x24\x39\xdb\xf8\x82\xc1\x13\xaa\x52\x64\x15\x0a\xb4\x56\xc6\xb8\x3a\x18\x90\x25\x45\x91\x65\x0d\x47\x3d\x63\x46\xe7\x41\x9a\x73\x37\x21\xeb\x7f\x56\xf7\x13\x83\x34\xb6\x9c\x0e\xc1\xdf\x4a\x65\x5d\x6d\x33\x83\xdf\xb5\xfe\x1a\x3f\x08\x4d\x48\x3d\x14\xc2\x32\xe7\xae\x0d\xc2\x78\x96\xab\xb5\xb9\x77\xb8\x70\xd6\x3d\x68\xcc\xdb\x7b\xe6\x7c\x5c\xcf\x17\x00\x70\xfd\x33\xfa\x47\xd4\x3a\xe9\xfe\xfe\x68\x4c\xb2\xc5\x47\xd2\x02\x7a\xcf\x28\x0e\x0e\xac\xd7\xc5\x4d\x0e\x82\x7a\x49\x63\x5a\xd2\x3c\xe4\xe2\xe0\xcd\x34\xad\x69\x96\x56\xb5\xc6\x28\x2a\xe5\x3c\x1c\xc2\x73\x3a\x0f\x68\x59\x4d\xd3\x45\x03\x8c\x49\x2f\x4c\xdc\x61\x00\xf7\xa5\xdc\x9f\xd6\x2b\x21\xf7\x80\x76\xa0\x82\x43\xad\x81\x5f\x17\xd6\x22\x0d\x67\xd6\x52\x83\xf3\x27\xb4\x8c\x97\x59\x56\x85\x25\xa5\xf9\x9f\x48\x1c\xa6\x8d\x84\x29\x85\x8c\x65\x25\xcf\xc9\xd6\xf1\x28\x04\xd9\x06\x28\xe8\x77\x00\xf0\x71\x03\x78\x60\xcc\xa9\x71\x38\x89\x23\x4e\x4e\x35\x9f\xbc\xcd\x80\xfd\xb7\x01\xe5\x93\x45\xab\x2c\xcd\xeb\x7d\x91\x89\xc1\x9a\x93\xdb\xfd\x8c\xe6\x8c\x51\x84\x7c\x6b\x17\x17\x1f\x4e\x7e\xfc\x78\x71\xf4\xe9\xdd\xcb\xd3\xa3\x4f\xe7\x17\x2f\x3f\x5c\x7c\x7a\xf5\xd3\xcb\x0f\x16\xb6\x6c\x95\xed\x4c\xa6\x3b\x13\xf9\xce\x64\xc2\x33\x91\xf1\x4c\xa6\x3c\x13\x39\xcf\x64\xd2\x33\x91\xf5\x4c\xa6\x3d\x13\x79\xcf\x64\xe2\x33\x91\xf9\x4c\xa6\x3e\x13\xb9\xcf\x64\xf2\x33\x91\xfd\x4c\xa6\x3f\x13\xf9\xcf\x64\x02\x34\x91\x01\x4d\xa6\x40\xe3\x39\xd0\xb8\xe6\x5d\x7c\x2d\xcd\x1f\xf0\xb1\xe2\x33\xb7\x4f\xc1\x9e\x65\xff\x21\x52\xab\x89\xdc\x6a\x32\xb9\x9a\xc8\xae\x26\xd3\xab\xf1\xfc\x6a\x60\x09\x03\xbd\xd1\xd9\xd9\xc5\x27\x13\xac\x85\xad\x5d\xf3\x5a\xd9\x6e\xa3\x1b\x3c\x25\x0b\xae\x08\x51\xd8\x61\x33\x09\x37\x22\x25\x97\x60\x6c\xd0\x7d\xe4\x52\xa4\x03\xf1\x3b\x65\x0c\x08\x97\xdb\x41\xe3\x51\x58\x15\xad\x19\x30\x03\xcb\x84\x7a\x1e\xa4\xfa\x23\x12\x4e\x25\x08\xa9\xa8\xf5\x84\x59\xc0\xe4\x5e\x58\x89\x65\x7d\x64\x1c\xd4\xcd\x94\xe6\x42\x39\xc2\x50\x78\x4e\xca\xd9\x72\xc1\x48\x34\x0c\xe2\xcf\x47\xcd\xad\x39\xf7\xcf\x51\x07\x12\x50\x18\x56\x6a\x30\x36\x1a\xf8\x22\x57\xe6\x30\x65\x39\xaa\x46\x96\xc3\x95\x9f\x79\x98\x2d\x23\x5a\x19\xbb\x9b\xf1\x88\x40\x4f\xa8\x15\x2d\x99\x04\xcb\xa1\xd1\x5b\xee\x08\x62\xc5\x24\xac\x8b\xb2\x62\x12\xe8\xa3\x36\xbf\xc4\x9b\x9e\xc4\x56\x5e\xe4\xfb\xc0\x3b\x71\xd5\x29\xeb\x99\x92\x48\xa8\x1e\x9a\xd9\x63\x7b\xd1\x08\xa6\xe4\xfe\x69\x91\xb8\xa6\x25\x07\x24\xa2\x36\x88\xe9\x19\xf1\x0e\x4d\x0e\x8c\x37\x94\x06\x41\x03\x38\x6b\x6a\x68\xa1\x48\x1e\x89\x2f\x8b\x98\x74\xd7\xac\xb7\x26\x2b\x3e\xea\xb0\x65\xf7\xf4\xd0\xd0\x21\xee\xcf\x26\x56\x13\x44\xd0\xc2\x22\x16\x1c\xd7\x2b\x7e\xc8\x4a\xd8\x06\x43\xf5\x80\xd1\xcb\x93\xba\x28\x2d\xc8\x48\x05\x23\x57\xa5\xec\x93\xd4\x28\x38\xb4\x87\x0f\xa5\x97\xc7\x7b\xc0\x90\x16\xe2\xbd\x2d\x63\x93\xd5\x1c\x52\xef\x48\xff\xc6\x20\xb7\xb0\x8a\xf7\x0c\x53\x70\x42\x80\x78\x30\xa0\x38\x23\x20\xce\xdf\xd0\x2c\x83\xbf\x6c\x67\x11\xad\x1b\xcb\xfa\x60\x8c\x07\xcc\x5f\xd9\xca\xa2\x60\x93\xa9\x0b\x3e\x30\xdf\x12\x96\x3f\x75\xc0\x09\x18\xf0\x16\x87\xd3\x7d\xb5\x2e\x97\xad\x37\xd5\x6b\x05\x1b\xfb\x4d\x5a\x09\xd3\x9d\x26\xfd\x70\x71\xff\x6e\xd3\x50\x30\x50\x62\x57\xac\x27\xf8\x60\xd2\x52\xed\x81\x19\x83\x1d\x86\x14\xc8\xb2\xa2\x11\xdc\x80\xce\x75\x24\xa6\x35\x5c\xdd\x05\x69\x36\x1f\x83\x84\xf8\xd8\x38\xa7\xc1\xd8\x93\xb4\xfa\x40\x2b\x5a\x5e\xf3\xcb\xf8\xd0\x46\xf1\x21\x32\x6e\x0d\xcc\xce\x80\x1f\x8b\xec\x1d\x50\x0a\x71\xe7\x48\xeb\x07\xeb\x31\x98\xb9\x59\xd9\xe5\xf8\x4a\x98\xa4\x77\x99\x34\x6f\x14\x9d\xed\xba\x4d\xbb\x43\x51\x98\x37\xed\x64\xd1\xbb\xdd\xaf\x76\xcf\x67\x97\xb5\x86\x20\x50\x66\x6b\x58\x0f\xd1\x98\xdf\xd8\x51\x26\x78\xed\xcb\x2d\x6e\xb6\xd8\x15\x3c\xf3\xae\x27\x38\x04\xe9\x63\x0d\x93\xa7\x66\xee\x65\x18\xd2\x45\xad\xe3\x27\x9f\x27\x5f\x83\xa4\xf4\x57\x02\x16\x2f\x15\x46\x77\xbd\x48\x18\xd8\xf5\x22\x61\xc1\x6f\x0d\x42\x7e\x89\x32\x74\x78\x1a\x97\x23\x96\x19\x59\xd5\x6a\x1e\x14\x99\xf9\xa6\x36\x63\x1b\xcd\x42\x91\x34\xd1\xd1\x19\xab\xc3\xbf\x41\xb7\x4e\x6c\x57\xa5\xe4\x42\x8d\xa2\x71\x50\x39\x70\x4f\x5c\x84\xf6\x8d\x7e\x1e\x38\x7b\x7f\x07\x05\xf5\x55\xed\xd1\x22\xf4\x7e\x99\x2f\xc0\xeb\x6d\x5b\x60\xef\x15\xf3\xd6\xeb\x4e\x7d\x57\xea\xec\x6b\xd5\x4f\xd2\xcc\xe1\xd3\x38\xbd\xb5\x30\x57\xaf\x1a\x9a\x15\x91\x8e\x79\x8c\xac\x6f\x5d\x5f\x5f\x1a\xfe\x06\x96\x6c\xd0\x2e\xef\xb9\x29\x65\x22\xe4\xfe\x2e\xac\x84\x49\x53\x80\xb3\xa1\x6c\x2a\x7a\xa8\x0a\x23\x58\x82\xc7\x01\x3e\xbd\x88\xb5\x35\xe6\xfe\x13\x7c\x69\x80\xb1\x4e\x85\xb7\xa8\x50\x86\xb3\x76\xc0\x1e\x54\x23\x61\x3f\xd4\xe8\x1b\xc7\x82\x01\xe8\xde\xe1\x58\x61\xc7\x40\x91\xb3\x63\xf9\xa7\x8b\xd3\xb7\x96\xbc\x35\x28\xfd\x88\x16\x65\x7a\x4d\x6a\xaa\xfb\x0e\xf1\xad\xb2\x81\xc1\xf6\x7b\x0a\x9d\x70\x86\xa3\xf5\x35\x6a\xcc\x6c\x38\x55\xdb\x4b\xa8\x8b\x6c\xfa\x1e\x30\x4d\x96\xbd\xfb\x40\xd9\xe9\xd2\xaf\xaa\x79\xa1\x59\x47\x49\x64\xe1\xe6\xd5\xae\x0a\x89\x1b\xc9\x3b\xca\x20\xe3\xa5\x4e\x6d\xf3\x92\xa1\x96\xe9\xbc\x64\xd4\x36\x2f\xf5\x2b\x75\x3a\x6f\xf7\x37\x6b\xc0\x6c\xd3\xdd\x74\x00\x6d\x6b\xd8\x80\xea\x53\xd4\x74\xc0\xf4\x35\x12\x93\xce\x70\xac\xa3\xdc\x95\x46\xd4\x03\xc6\x59\xe4\x16\x89\xc0\x28\xae\x19\xbd\xc1\x9e\x03\x1e\x3d\x55\x8d\x00\x69\x97\xa5\x30\x79\x57\x05\x6b\xcf\xd0\x6d\x0e\x4c\x33\x83\xc2\x70\xef\xcf\x45\x51\x55\x69\x90\xd1\x73\x21\x71\x00\xdf\xfe\xa7\xf0\x44\x60\xef\xd2\x1c\xa0\x84\x04\x84\x58\x02\xbe\x40\xe0\x2d\x00\xe6\xc0\x83\x03\x8e\xbe\xc2\x73\x06\x0c\x35\xba\xd9\x8f\x13\x2c\x25\xd1\x9e\x83\x44\xeb\x75\xf1\x83\xab\xc7\x0e\x0e\x34\x4b\x6e\x4d\xca\x84\x72\x59\x85\xde\x72\xa3\x50\x96\xe6\x33\xc1\x21\xfd\xb9\x28\x29\x23\x53\x7f\x82\x3f\x18\xef\xa5\x5a\xe5\xe1\x7d\xb0\xdf\x15\x35\xf5\xd8\x67\x97\x82\x27\x91\x36\x1e\xee\x1a\xc0\x64\x8b\x45\x49\xaf\x69\x5e\x57\x56\x5a\x73\x99\x2c\xa0\xec\xb3\xbb\xe6\x42\x09\xb3\xe0\xe4\x27\xcc\x52\xc6\x41\x55\x69\x44\xad\x80\x86\x44\x1a\xa3\x82\xb2\xb8\xa9\x68\x59\x59\x84\xf5\x99\x87\x45\x5e\x81\xaf\x4e\x3d\xb2\x4e\x84\xd8\x71\xc3\x26\x37\xcb\x2c\x71\xc3\x72\xc4\xbf\x45\xde\xb2\xdd\xfa\x3d\xac\x05\xc4\x56\xdf\xd6\x20\x24\x8b\x7a\x59\x52\xef\x5e\xdc\x16\x4d\xa5\x13\x42\x77\xb3\xaf\xb7\x82\x2f\x32\x31\xb8\xfe\x7d\x25\x5b\x19\x2e\x0b\xde\xd6\xdd\xd1\x34\x2f\x15\xe0\x9e\x06\xbb\x82\x9b\xd8\xdd\xda\x02\xfc\xda\xb7\xd7\x8a\x8c\x94\xdb\x1b\x14\x37\x39\xc3\xab\x87\x4c\x5b\x54\x92\x24\x79\xc8\x67\xc5\x45\x39\x7f\x57\xfc\x4a\xb2\x14\xae\xb2\x6e\xeb\x9b\x5f\xeb\xdd\x5a\x9d\x15\xc5\xe2\x3e\xf4\x7e\x45\xc0\x27\xcd\xb7\xfe\xe4\x21\xb9\x54\x7a\x4d\x30\x51\xb2\x73\x8c\xdf\x7c\x89\xd8\x69\xfa\x27\xaf\x54\xd1\x83\x58\x1b\x09\x48\x4e\x92\xd8\x69\xad\x90\x89\x7f\x72\x0c\x95\x2f\xfe\x2d\xa4\x99\x2f\xeb\xbf\x89\x66\xf9\xd7\xa7\xad\x58\xdc\x33\x69\x8b\x8c\xac\xaa\x93\x3c\x4b\xf3\xed\x00\x4a\x4a\xa2\xb3\x3c\xdb\xbe\x95\xa4\xb7\xd4\x3d\x0d\xae\x69\x59\xdd\xd7\xa0\xb8\x79\xc0\x6e\x29\x45\xea\xab\xee\x51\xc8\xeb\xab\xb0\x58\xdc\xd3\x49\x45\xc9\x3c\xa3\xd5\xf6\xdd\x23\x11\xe2\x6f\xad\x40\x95\x7e\xa1\x5f\x1f\x3a\x0f\x87\xb2\x6d\xe0\x8c\xb0\x2f\x17\x8b\xa2\xe4\x74\x7c\x51\x16\xd2\x02\x58\xd2\x64\x99\x71\xcb\xab\x25\x9c\x12\x2b\xeb\x3a\x25\xd6\xaf\x87\x70\xb2\x44\x56\x95\x15\x75\x65\x39\x56\x35\x25\x51\x71\x63\x45\xc5\xdc\xe2\x36\x8f\x4a\x4d\xd5\xbd\x03\x5b\xd0\x8c\xe7\x1b\xff\xda\x2e\x3d\x38\xb0\xc0\xa9\x4f\xa9\x12\xe8\xed\x22\x4b\xc3\x94\x49\xcc\x8c\xfd\x13\x9c\x66\xe3\x25\xc1\xce\xd9\x91\xe0\x26\x43\x79\x27\x45\xed\x22\x7a\xbb\xa0\x21\x13\xc3\xc1\xe9\x4a\xf3\xa0\x91\x5e\x58\x63\xd5\xed\x2f\x94\x2e\xd8\x89\x23\x7a\x68\x14\xcf\xf2\x28\x49\xc1\x79\xdc\x50\x59\x53\x98\xc9\xf3\x5f\xdf\xf0\xed\x58\x93\x80\xe7\x1e\xd3\xc0\xa6\x35\x9d\x9f\x33\x94\x61\x2f\xb3\xd6\xec\xbf\xd3\x34\x2c\x0b\xc6\x84\xcb\x15\x19\xa9\x8f\xa7\xd4\x12\x19\x2f\xab\x70\x4a\xe7\x04\x32\x5e\x46\x45\x58\x1d\x24\x15\x64\xe2\x81\x96\x0a\xea\x7d\xb4\xa8\xe3\x90\x07\x73\x5a\xd5\x64\x65\x7c\xe4\xbe\xf1\x95\xf5\x94\xae\xc0\x02\xdc\x10\xa2\x18\x14\xfe\x6d\xcf\x95\xca\x72\x98\x50\xd0\xe3\x3d\x42\xb3\xe2\x86\x63\x07\x01\xc1\xed\xd5\x94\x94\x15\xad\xd5\xac\x84\x19\xa9\x2a\x6e\x5f\x15\x25\xec\xbb\x8e\x8b\x52\x7b\xae\x17\x47\x9f\x97\xe9\xb5\x3e\x93\x2f\x9b\x0f\x01\x9a\xd8\x76\x0a\x51\x28\xd3\xb8\xa3\xb4\xd7\xb2\x99\x65\xee\x02\xc2\xc5\x03\x69\xf7\xe2\x6a\x20\xe5\x9d\x08\xac\x03\x9d\x92\xeb\xb4\x28\x85\x73\x02\x18\x09\xb7\x21\x30\x93\xce\xd8\x60\x7b\x1c\x97\xee\xfa\x66\x63\x97\x3f\xef\x87\xbc\x60\xb7\x33\x39\xbb\xf0\x7b\xb7\x35\x45\xbb\x71\x51\xee\x76\xa6\x69\x97\xfd\xde\x67\x24\xf2\x7a\x57\x1b\x48\xc7\xd3\xe6\x4e\xff\x92\xc6\x17\x05\x82\xc8\x98\xea\x0d\x53\x53\x62\x28\x4a\x34\xf9\x37\x6f\x22\x0b\x34\x6a\xa2\x5d\x78\x6b\xd7\xed\xb3\x23\xbd\x03\x7d\x86\x05\xc1\x4e\x2a\x70\x03\x93\x0c\x60\x5d\x52\x52\x83\x87\x2d\xd7\x2a\x73\x6f\x39\x70\x8e\x63\x9b\xae\xb2\x52\xcd\x48\xf3\x6a\x5a\x16\x73\x3a\xb2\xde\xd2\xda\x62\x74\x7f\xc5\xc4\xb6\xc4\xe2\x61\xc6\xb8\x8f\x37\x5b\x3f\x3e\xfc\x06\x71\x49\x25\x5c\x93\x46\x0d\x28\x36\x73\x95\x77\x70\x90\xa4\xf5\x74\x19\x8c\xc2\x62\x7e\x10\x0b\xbf\xfd\x03\x30\x15\x1c\xa4\x55\xb5\xa4\xd5\xc1\xf3\xc7\xdf\x3e\xf9\x1f\xf0\x3b\x2c\xe6\x6c\xa0\xfb\x8f\x9f\x3c\x1b\x3f\x7f\xfa\xe4\xf1\x33\x6d\xc6\x60\x46\x18\x3f\x0c\xde\xf4\xea\xd2\xc4\x7a\xcd\xe7\xca\x08\x73\x27\x27\x0a\xe4\x6f\xd0\xb9\xe8\x53\x0c\xed\x0d\xe5\xb7\x68\x8f\xac\xdd\x5d\x6b\x4f\x2c\x97\x9a\x64\x4b\xc4\x72\x12\x43\x80\x00\xac\x69\xbd\xb2\x86\x43\x6b\xc7\x28\x19\x05\x24\x3a\x61\xf3\xcf\xaa\xa0\xc6\xb8\xcb\x32\x22\x86\x77\x3a\xfb\x0a\xd6\x48\x1f\x19\xd8\x03\xf3\xdd\x5a\x4e\x35\xc9\x75\xbf\x3f\xd0\x93\x31\x76\x01\xc2\x54\x53\x7e\xf1\x23\x20\x91\xfe\x3a\xac\xff\x48\x2c\x23\x77\x8c\x0e\x33\x4a\xca\x66\xd5\x46\xd6\xcb\x28\x4a\x19\x0c\x92\x65\x2b\x64\x45\xac\x43\x1d\x04\xd7\x1d\x50\xc6\xfd\x0b\x6c\x6a\xbc\x57\x80\x8f\x47\x8d\xfe\x54\x76\x34\x4f\x93\xa9\x01\x84\x51\x80\x85\x55\xc4\xb1\x55\x97\x24\xcd\x18\x0e\x45\x34\x4c\xe7\x24\xb3\xc0\xe3\xbb\x02\x69\xab\x91\x25\x96\x15\x2d\x77\x2b\x1d\x42\xb8\x2c\x2b\x76\x9c\x82\x4e\xbb\x00\xf1\xe4\xaf\xe5\x7c\x21\xc5\x94\x80\x26\x69\x0e\x17\x1a\x84\x69\x83\x7f\xb9\x06\x41\x07\x76\x92\x2b\x07\x6b\x58\x21\xc4\x24\x13\xf8\x22\x92\x5b\x45\xfe\x63\xb6\x2c\x2d\x10\x8e\xf8\xb7\xc2\xbc\xd5\x65\x9a\x24\xb4\xd4\xc1\x80\x04\xaa\x76\x37\x49\x48\x9a\x73\xc5\x35\xcc\x0b\x5c\x38\x29\x2a\x6d\x10\x7f\x13\xd3\x5a\x16\xce\xfb\x04\x6e\xb8\x3c\xf1\x20\x91\x1b\xc0\xbc\x93\x2e\xde\xb7\x90\x11\x91\x93\xb5\xbe\xec\xcf\xac\x1a\xa8\xe0\xed\x3c\xeb\x6d\xf6\xcf\xd3\xb7\x3c\xf7\xb5\xf2\x88\xdc\x1d\x68\xda\xf2\xc6\xb5\x5f\x2a\xad\x98\xf8\x77\xfe\xeb\x1b\x43\x96\x67\x73\x9c\x53\xc6\xff\x34\x42\x6a\x9a\x27\x08\x74\x52\x02\x2e\x7b\xb6\x8a\x52\x1d\x22\x82\xe4\xc0\xc6\xd0\xd5\x53\xff\xbe\xbe\xe0\xd1\x7f\x42\x5b\xf0\xa8\xa3\x2b\x80\xd1\xb1\x2f\xd7\x0e\xd8\xb7\x69\x55\x83\x05\x45\x12\x47\x6d\x66\x2f\x3e\x1c\x9c\xff\xfa\xe6\x80\xd4\x35\xa4\x46\x14\x4c\xc9\x23\xeb\xfc\xf4\xe4\xad\x75\xbe\xa0\xe1\x3d\x2f\x56\xf3\x34\x1b\xe8\xb6\x60\xb6\xde\x97\x70\x12\xe6\xf5\xfe\x14\xf2\xbe\x32\xa4\x23\x99\x98\xbd\xfd\x80\x54\x94\x09\x0e\x50\x5a\x92\x20\x0d\x21\xcf\x21\x7b\x94\x55\xfb\xd5\x34\x8d\xe1\xb5\x90\x2c\x34\x20\x61\x96\x2e\xf6\x17\xa4\x9e\xaa\x87\x72\x99\x01\x20\x9e\x83\x11\x74\x91\x8b\x22\x03\x42\xb5\xa5\x78\x3f\x4e\xb3\x9a\x96\x55\x53\x2d\x32\x37\x36\x05\xca\x34\xcb\x8a\xa2\x62\x9e\xe6\xa4\x35\x6e\x6e\x0a\xdf\x0f\x48\x38\x4b\xca\x62\x99\x47\xac\x30\x4e\xb3\x6c\x5f\xe4\xb7\x55\xcf\x72\x80\x90\xa1\x76\x1f\xe0\x37\x8f\x7a\x63\x9e\xdc\x71\x9e\x66\xcd\x23\x93\x11\x8c\x87\x7d\x12\xfd\xb5\xac\xea\xa6\xac\x2e\x69\x1d\x4e\xb5\xe7\x55\xd6\xbc\x21\x3c\x88\xd4\xf3\x8d\x9a\x47\xc8\x15\x09\x59\x24\x9b\xa7\xa2\x4c\x69\x2e\x92\x5b\x4e\x8b\x32\xfd\x52\xe4\x35\xc9\xfa\xeb\xaf\x69\x59\xa7\x21\xaf\x85\xb6\xfb\x24\xba\xde\xbf\x6d\x1e\x8b\x32\x4d\xd2\x9c\x97\x40\x84\x76\x73\x4e\x33\x5a\xd7\xb4\xdc\x17\x9b\x0d\x4a\xd8\xd0\xd2\x3c\x69\x66\x68\x4e\xca\x19\x2d\xf7\x29\x9f\x5b\xf1\x34\x4f\xf5\x27\x90\x8e\xd8\x33\x78\x3c\x31\xbc\x91\x34\xdb\x28\xac\xa7\x69\x38\xcb\x69\x05\x4b\xbe\x20\x69\x5e\xef\x43\xea\x61\xfe\x98\x17\x15\xdd\x3f\x84\xdf\x05\x20\xca\x3e\xd7\x55\xb1\x12\x35\x68\x40\x21\x3e\x95\xd5\x94\x2c\x5a\x9f\x53\xd5\xc5\xa2\x19\x38\x3c\x69\x2b\xcb\x0e\xa4\x19\x15\x79\x09\x8d\x11\x9a\x35\xc6\x30\x79\x96\xe1\xfd\x48\xa6\x2c\x6e\x95\xf1\xd8\x80\x5a\x21\xfb\xd0\x90\x2c\x5a\x25\x7f\x15\x69\xae\x15\xcd\x55\x66\x63\xad\xd0\x1c\x29\x2b\xb9\x49\x23\xbe\xc3\x6a\x7a\x5b\xef\xf3\xf0\x8a\xea\x31\xa2\x61\x51\xaa\xfd\x05\x45\xc6\x5c\xc0\x75\xc7\xce\x5a\x34\xa5\xc6\x57\x2e\xf3\x34\x2c\x22\xba\x1f\xa4\x51\xaa\x3f\x43\xdc\x47\x51\x50\x57\xfb\x0b\xb6\x28\x40\x20\xae\xf7\x49\xb6\x98\x92\x80\xd6\x69\xc8\x9f\xa7\x24\x4f\x44\xd7\xd7\xfb\x69\x44\x8b\xa4\x24\x8b\xa9\xac\x9d\x13\x46\x6b\x89\x42\xd6\x6b\xb8\x4b\xb9\x4f\xe3\x98\x86\x35\x2f\x28\x6b\x40\xde\x95\x7a\xd2\x71\x57\x2f\x80\x16\x37\x45\x19\xe9\x78\x7b\x53\x42\x6e\xc2\xfd\x79\x11\xc1\x80\x6f\x35\x6a\xc5\x4f\x3c\x12\xd6\x4b\x52\x53\xad\xa0\x0c\xcb\x22\xd3\x0a\xa6\x25\x8d\x9b\x27\xb3\xae\x9a\x16\x37\xcd\x53\x9d\xd6\x7a\x25\xe3\x49\xe1\x69\x9e\x79\x8c\x3a\x89\xdf\x79\xe5\x89\xd3\x94\x57\x65\x84\x8f\x95\xfd\xe6\xe7\xe6\x95\x38\xe3\xcf\x7f\x7d\xb3\x4d\x1f\xde\xa3\x6e\x5e\xd6\xc5\x07\xae\x91\xd9\x2e\x32\x7d\x73\xc8\x05\x19\xe9\x3a\xf2\x81\xf2\xeb\xaa\xd5\x07\x43\xd9\x73\xdf\xab\x0b\x61\xaa\x79\xc9\x56\xfa\xbe\xe6\x5f\x17\xcf\xf4\x11\xef\x6a\x4f\xbb\x5f\x1d\xe4\xee\xd6\xba\xdd\xde\x51\xee\x1a\xcf\xbb\x5b\x87\x26\xee\x91\xf0\xf1\xc1\x2a\xbd\xe4\xf8\xe1\x59\xef\xce\x47\x50\x80\xb4\x3a\x8e\x2a\xbd\x75\x3f\x95\x34\xee\xad\xf8\xb0\xed\x8d\xf3\x69\x71\xd3\x5b\x71\xc1\xd0\xaa\xbf\x66\xb5\xe8\x56\xcc\xb3\x1f\x49\x25\x8a\xe7\x99\x2a\x7c\x4b\xf2\xa4\x53\x78\xce\x3d\xb2\x79\xa9\xc1\x5f\xbe\x7a\x79\x7a\xf4\xf6\xe4\xf7\x23\x0b\x5b\x07\x97\x7f\xec\xff\xe1\x5d\x39\x97\x64\xff\xcb\x95\x7b\x90\xc8\x2b\xa1\x8b\xb4\x86\x2b\x27\x16\xd6\x04\xdb\xba\x98\xd1\xdc\x30\xcf\x41\xc9\xe5\xe1\x95\x99\x22\xdd\x87\x9e\x80\x23\xe9\xe4\x57\xb7\x1c\xbe\xa7\x49\xd6\xc4\x04\x00\xc1\x50\xf8\x94\xca\xda\x91\xb8\x25\xea\xc8\xc1\x22\x6d\x54\x2e\x78\xa8\xf6\x6d\x21\xed\x8a\xc6\xa5\x02\x7b\x65\x61\x6b\xec\x6f\x7b\xa3\xeb\x08\x6b\xbc\x28\x07\xe4\x0f\x36\xac\xdb\x86\xfd\xde\x76\x63\xa1\xd7\xd4\xe5\xfa\x0f\x78\xb3\x6f\x78\xae\x7e\x2d\x1c\x92\xac\x7c\xac\xd3\xac\x6a\x4c\x67\x1f\xc5\x65\x59\x08\xfe\x02\x92\x7e\x3a\x5f\x66\x4c\x96\x23\x56\x5d\xae\xf6\x21\xfc\x36\x93\x4e\x3e\x85\x64\x99\x4c\x39\x8c\xc6\x51\xff\xd3\x94\x54\xaf\xf4\x0a\xee\xf4\x3c\x30\x81\x73\x31\x89\x5f\xc0\x05\x8f\x54\x6e\x8a\x39\x28\xe1\x08\xe5\xea\x1d\x88\xc6\xc7\xef\xeb\x42\x77\xa2\xae\xa7\xbf\x0f\x46\x4d\xd3\xa1\x9a\x21\xb9\x4b\x79\x41\xf3\xd5\xba\x96\x45\xde\xe8\x68\x6a\xb5\x6b\x28\xd2\xc7\xa4\xdb\x68\x94\xe6\xd7\xc5\x8c\xbe\x59\x92\x32\x6a\xa2\xbd\xb5\xc2\x3f\xf4\xba\x81\xef\x9e\x08\x60\x56\x2f\x08\xc7\x6d\x5c\xe0\xd4\x30\xcd\x8b\xbd\x42\xaf\xd1\x3f\x80\x07\x8f\x55\xf3\x89\x35\xef\x45\xb2\x06\x5a\xdf\xd6\xcd\x34\xcd\xa8\x95\xb0\xb7\x41\x76\x61\x92\xab\x5c\x21\x25\xdf\x2f\x16\x34\x57\x96\xfa\xb4\x16\xf7\xd2\x44\x5e\x72\x26\x28\xf3\x0b\xd8\x69\x6c\xa5\xb5\xb8\x2d\xad\xab\x02\xe0\xbe\xe2\xa0\xb9\xf3\x75\x02\x5e\x1c\x22\xe4\x01\xe2\xd2\x18\xfb\xff\x7c\xc1\x35\x20\x70\xad\x0d\x46\xa3\x21\x27\xc4\x22\x29\x29\xa9\xd8\xa0\x69\xa3\x9c\x78\x04\x57\xe0\xb4\x96\x22\x24\x43\xb6\xb2\x20\x18\x83\x90\xdb\xb9\x37\x7e\x75\x43\x16\x16\x77\x13\x53\x5a\x56\x0e\x44\x75\xce\x95\x28\x69\x6e\xbd\x3e\xfa\x95\x89\x78\xb4\xef\xb6\xda\xb9\xe6\xe5\x20\xd5\x0c\x30\x87\x0c\xef\x97\x15\xd7\x52\x67\x45\x92\x80\x1a\xa2\xb4\x22\x1a\x2c\xe1\xc1\x04\x23\x03\x1e\x6c\x60\x3d\xe0\x0b\x9b\x54\x30\x85\x40\x02\xf3\x95\x47\x1b\x65\x1b\xbe\xe0\x17\xe3\xe0\xb7\xe8\x16\x54\x0e\x21\xc9\x32\xe9\x7a\x2d\xc1\x99\x40\x46\xa3\xd1\xa3\x8d\x45\xca\xa4\xb2\x5e\xca\x88\x78\x5c\x55\xae\x37\xe7\xb7\xea\x7a\x90\xcb\xd0\x63\x82\x83\x1a\x7b\x46\x72\x30\xc8\x22\xc8\x0a\x90\x15\x22\x2b\x42\x16\xab\x75\xd5\x56\xed\x81\x36\x22\x8b\x45\xb6\x72\x5a\xb4\x0b\x59\x2a\x56\x1f\xa8\x41\x5a\x68\x7c\xce\x26\x9e\x54\xfd\x10\xf9\xe5\x09\xcd\xc1\x95\x1f\x44\x5c\x36\xe7\xb8\x8a\x18\xa6\x42\x62\x97\x6a\x20\xef\xc9\xa6\xb9\x45\xac\x24\x2b\x02\x92\x31\xbc\x49\x6b\xe9\xb6\x28\x88\x54\xce\x88\xdc\x9f\xe2\x41\x23\x87\x7f\x5a\x8c\x92\x96\x62\x57\x5c\x9c\xbd\x3e\xf3\xc0\xaa\x90\xc6\x06\x39\x05\xbd\x80\x41\xf0\x94\x5b\x64\x0e\xca\xf3\xff\x87\x68\xed\x85\x7c\x99\x47\xaf\xd8\x96\x86\x60\xaf\xf2\x24\xf8\xd7\x50\xaf\x85\x5e\xfd\x54\x53\xa0\x22\x23\x48\x6d\xfc\xe3\xaa\xe6\x36\x14\xf3\x5c\x74\xb4\xdb\x20\x10\xc2\x03\x16\x19\x77\xfa\x06\xbd\xab\xf1\x9e\xaf\xa9\xb3\x77\xda\xcd\xdb\xa7\xa1\xae\x17\xfe\x5a\x5b\x0b\x6b\x3e\x89\xbd\x2f\x94\x66\x6b\x18\x73\x8f\xde\xd1\xdc\x7e\xaf\x97\x60\xc6\xa1\x32\x22\x0c\x43\xcd\x84\xcf\xa5\x5a\xa0\x8a\x11\x5d\xae\x67\xe6\x8c\x40\x9b\x01\xe0\x37\x47\x38\x40\xd9\x54\xf1\x0a\x05\xdb\x18\x53\x92\x47\x59\x13\xae\xa3\x2e\x16\x56\x46\xaf\x69\x26\xde\xe7\xd5\x65\x73\x07\xb8\xbb\x37\x75\x7c\x69\x39\x12\x76\x1b\xff\x1d\x4a\xd4\xe1\x88\xb6\x75\xd3\xb7\x42\xda\x9b\x0d\xc4\x36\x56\xf4\xc1\xec\xc3\xc1\x16\xc0\x87\xa1\xa0\x4e\x98\xe4\x6a\xdf\xd7\xc6\xc2\xc2\x69\x74\x3b\xda\xbd\x32\x5a\x2b\x7f\x56\x6d\x2a\x34\xdc\x12\xb6\x93\xbb\x86\xdd\x69\xf1\x51\xed\xd9\x80\x98\x2a\x8c\xe0\x30\x74\x80\xab\x71\x12\x89\xa0\x1c\x10\x2c\x12\xb7\x99\x04\x37\x52\x59\x59\x3a\xa3\xd9\x8a\x1b\x13\x00\x8b\x88\x15\x2c\x21\xe5\x9d\x88\xc7\xf2\x3e\xa3\x84\x11\x51\xc6\x03\x91\xdc\x02\x53\xd3\x48\x9a\xd1\x4c\x7d\xfb\x36\x8e\xec\x5f\xa2\x47\x7f\x63\xfe\x1e\xb8\x2a\x10\x5c\x68\x99\x87\x2f\x19\xad\xc5\xd6\xcb\xb2\x24\x2b\x2d\x26\x2c\x78\xa8\x8e\xd8\xfc\x39\x0a\x9b\x91\xf5\x04\xbe\xb4\x2e\x57\x62\x21\x18\x00\xb1\x09\xd4\x07\x48\xa0\x1c\xf7\x2d\xce\x62\x39\x54\x47\xb5\xaf\x0c\x51\x5b\xf6\xaf\x7f\x77\xe3\x35\xcc\x26\x5e\x88\x2f\x27\x0d\x37\x06\xf6\x19\xc5\xc6\xf5\x2f\x0a\x3b\x60\x1a\x37\x37\x11\xcc\x52\x7a\xff\x91\x9a\x7b\xc7\x58\xf3\xa2\xa4\x56\x9e\x86\x0c\x43\x54\x70\x0f\xe1\xb9\xb6\x5b\x59\x32\x6a\x26\x67\x3c\xd3\x88\x12\x86\x51\x75\xa1\x34\x0b\x1c\xa0\xfd\x1e\x2c\x55\x45\x6e\xd1\xdb\x90\x82\x07\x52\x65\x2b\x2b\xf6\xc8\xfa\x51\x58\xf9\xb9\xbf\xc4\x4d\x49\x16\x70\xdb\x0e\xcc\x5a\xfb\x8b\xb2\xb8\x4e\x23\x1a\x0d\x0c\x07\x71\xc6\xd5\x6c\x63\x6c\x18\x0f\x21\x6e\x56\x08\xfe\x59\x7e\x9f\x55\xc4\x03\x61\xe8\xeb\x9b\x93\x65\x05\x81\x4d\x14\x97\x8c\xd4\x28\xb4\x81\x83\xbf\x1e\x58\x85\xe5\x98\xd8\x0e\xb2\xf8\x72\x6a\xed\x9a\x71\xc8\x59\x12\x41\x46\x16\xf0\xad\xcb\x3c\xa3\x15\xbf\x4d\x28\x02\xb8\x81\xb1\x8c\x4d\x3f\xc4\x57\x81\x90\x4d\xb7\x75\x49\xac\xaa\xa6\x0b\x76\x76\x80\xbe\x1e\x2e\xbe\xcb\xd9\xec\xf4\x39\x92\x16\x24\x0e\x69\x99\xd7\x69\x5e\x2f\xc1\x27\x84\x89\x10\xc5\x32\x99\x22\xe5\x53\xc1\x44\x51\x51\x28\x66\x7e\x0a\x64\x02\x60\xaa\x88\x51\x08\x9c\x1d\x1b\xb7\x50\x35\xd8\xdd\xca\x5a\xd0\x92\x21\x90\x04\x4f\x1b\xa2\xb2\xcc\x39\x9c\xd1\x40\xd8\x12\x0f\x0e\xac\x8b\x06\x2d\xc4\xd7\x2d\xb8\x14\x78\x3f\x7a\x20\x25\xc9\x70\x21\x46\x0c\x45\x49\x32\x5c\x0a\x51\x4e\x93\x1c\xf7\x57\x79\x38\x2d\x8b\x1c\x42\x2f\x59\x51\x5a\x2d\xa0\x29\xb1\x62\x32\xa3\xd2\x54\x59\x88\x67\x0e\x50\xde\x36\x43\xc2\xb4\x9a\x65\xca\xb2\xaa\x50\x10\x8a\xf9\xee\x29\x8b\x39\x63\x9e\xd3\x08\x68\x22\x87\x28\x8e\xda\x81\xba\xaf\x09\x1b\xa9\xe9\x72\x24\xdd\xba\x15\x18\x29\x06\x1a\x73\x67\x4b\x4a\x6d\x73\x09\x8f\xc3\x53\x5c\xb7\xd1\xd7\xc8\xfa\x71\x69\x78\xc9\xa8\x53\x9f\x8b\xa3\xc0\xae\xeb\x52\xdc\xc1\xc1\xff\xc7\xde\xdf\x77\xb7\x71\x23\xf9\xe2\xf8\xdf\xf1\xab\x80\x3d\x59\x93\x4a\x28\xca\x4e\x76\x67\x27\xd4\x68\x7c\xf5\xe4\x44\x37\xb1\xe5\x6b\x2b\xe3\xdd\xeb\xf5\x11\x41\x36\x48\xf6\xa8\xd9\xe0\x34\x9a\xa2\x39\x13\xbf\xf7\xdf\x41\x55\x01\x28\xa0\xbb\x29\xd9\x49\x7e\xf7\x9c\xfd\x6e\xfe\x88\xc5\x6e\xa0\x1a\x8f\x85\x42\x3d\x7c\x8a\x08\x14\x5a\xaf\x02\x07\xce\x6b\x91\x69\xc2\x4d\x01\x03\x42\xb5\x5e\xd5\x0c\x33\xc5\xee\xa5\xb9\x95\x56\x67\x85\xde\xe0\xa4\x8a\x73\x50\x40\xe7\xb7\xaa\xd8\xd2\xfd\x74\x9e\xdf\x2a\x23\xd6\x86\xcd\x8e\x9b\xc5\x10\x7b\x34\xad\x11\xde\x8c\xf5\x8d\x5d\x60\x5f\x2a\x59\x3f\x24\x9d\x09\xb8\x66\xe1\x20\x32\xb6\xe3\x9c\x93\x70\x8b\x1c\xbf\xba\x00\x19\x0a\xec\xa1\x56\x4a\x77\x57\x54\xa1\xd7\x95\x63\x6f\x34\xc3\xe7\x7f\x65\x7c\xa0\x9d\x05\x50\x68\x05\x29\x3d\x10\x01\x13\x3d\x26\x42\x1c\x0c\x43\x9a\xa4\x44\x54\x6e\x81\x01\xe2\x5e\x0a\x80\x19\x4a\x3b\x04\xce\x1d\x04\x93\xbc\x4d\x6d\x04\x39\x1e\x8b\x5d\x5b\x04\x94\x97\xd6\xc4\x51\xe8\xf7\x40\x05\xd7\xdb\xa3\x48\xf4\xce\x43\xfa\x4c\xdd\x7e\xee\x39\x2d\x82\xa7\x9a\x9d\x79\xbb\xae\xed\xd0\xb0\x10\xb7\x8e\x4d\x54\x2f\x2a\xb5\xf1\xb7\xcd\xa1\x78\xab\x02\x35\x84\xc3\xc1\xc3\xc4\x1e\x77\xc2\x2d\x02\xe7\xb8\x00\x9b\x06\x63\xf0\xf2\xda\xc7\xba\x09\xc4\xbc\xa4\x58\x4c\xef\x0c\xd1\x72\x07\xf3\x9b\xd1\xf7\x19\xd5\x39\x03\x31\xce\xf2\x8c\xee\xac\x20\x6e\x97\xea\x56\x55\x10\xa6\x18\x35\x8e\xbe\x48\x2c\xd7\xd4\x95\xac\xd5\x7c\x2b\x36\xba\xba\x31\xc8\x5b\xf3\x59\xb4\x6e\x73\x23\x66\x85\xbc\xd9\x5a\x06\x13\x68\xcd\x64\x5e\x60\x6c\xba\x65\x39\x76\xd1\xba\x7d\xce\xc5\xf7\x01\xf7\xf7\xb3\x3b\xd5\xb2\xc3\xca\x9e\xca\x3c\x46\x3c\xec\x7f\xdc\xe3\xb2\xb6\x07\xd8\x90\x89\xba\xae\x6b\x5e\x88\x60\xbe\x4b\xb0\x6e\x1a\xdc\x0c\x18\x99\x6d\x16\xe7\x63\x6f\xe9\x26\x12\xf1\xd9\x40\xca\x33\xdc\xb8\x1e\x29\xac\xc6\xd1\x76\x19\x03\xe7\xb6\x7c\xd4\xb6\xde\x77\x77\xa3\xe2\xe9\xdb\xb1\x8e\x78\xff\x3e\x53\xba\x73\x72\x1d\xc2\x88\xc9\xa2\x60\xba\xc8\xc8\xbf\xe8\xad\x12\xf9\x72\xa9\xb2\x5c\xd6\x0a\x20\x1a\x97\x9a\x4e\xb3\xf8\x68\x20\x1e\x4b\xe0\x9b\x5e\xc5\xc6\x49\x95\xca\xd8\xc3\x6f\xdc\xba\x1d\xc7\x40\xcf\x88\x4c\x03\x4b\x9e\x16\xd2\x2c\x86\xe2\xd2\x69\x0b\x07\x70\x0c\xa6\xa4\x60\x9c\x36\x10\xaa\x4a\xde\x37\xb8\xc0\xc3\x04\xd0\xf0\x1a\xf0\x2c\x29\xb7\x58\x63\x91\xcf\x17\xb1\xa3\x0e\x39\x28\x9a\x9a\x8d\xae\xf0\xcc\x86\x1c\xeb\x22\x78\xd1\xbe\xba\xad\x21\x5d\x65\x34\x7a\x03\xf2\x1e\x0b\x37\xeb\x3b\x85\x67\xfc\x8f\x2d\xd3\xe8\x8e\xf4\xb1\x65\xbd\xc6\xfb\x25\x39\x1d\xdf\x2a\x02\xff\xca\x0d\xd3\xb6\x07\x77\x2e\xbe\x77\x64\x0d\xf7\x24\x54\x63\x0d\xc5\x45\x6d\x25\x1c\xf2\x6a\x71\xa7\x90\xbf\x38\xb9\xdd\x01\xdb\x60\x96\x57\x0a\x44\xe5\x88\x5c\x29\x74\x39\x55\x87\xb0\x81\xd4\x07\x69\x0f\xa6\x81\xe5\x09\xa5\x2e\xf7\x9d\x67\xb0\x15\x1f\x0a\xa3\x69\xb6\x93\x9d\x11\xa8\x59\x91\x44\x46\x3b\x12\xda\xe3\x7c\xae\x00\x79\xd3\xf6\x95\x07\x2a\x9b\x1c\x03\x4f\x6a\x2d\x96\x1a\x9c\x89\x78\xeb\xb4\x21\xff\xc5\x21\xe0\xc4\xda\x76\xd9\xcd\xda\x32\x88\xd0\x3b\xba\x09\xf8\x5e\x0d\x1c\x14\x1f\xd2\x2b\xa4\xd7\x57\x60\x5d\x80\xcb\x00\x5c\x50\x7b\xab\x6c\x0a\x3e\x5e\x0a\x00\xa9\x03\x05\xcd\x40\x6e\xa3\x00\x82\x30\x1c\xfd\x6d\xf4\x3d\x36\xe9\xb4\x16\xba\x54\x9c\x43\xf6\x40\x90\x09\xf4\xfc\x2c\xc2\xa5\xa7\xe4\x5e\x99\xb5\x46\x47\x36\x14\x98\xd0\x39\x77\xa2\xea\x8d\x52\x25\x0c\xc8\x34\x08\x06\x44\x0c\x9a\xe1\x5c\x98\xb0\x11\x19\xad\x0f\x44\x3d\xc4\xa6\x25\x73\x89\x5b\x0d\x9c\x90\x1d\x4c\x5c\xe0\xd9\x7e\x58\x1c\x67\x27\xc9\x7b\xb2\xae\x1b\x3c\xdd\x2e\x51\x3b\x23\x28\xe8\xe2\x30\xe9\x40\x2e\x9f\x97\x76\xa2\xf2\x20\x14\xa6\xc7\xd9\x44\x91\xa1\xa8\x0b\x29\x2e\xd1\x8a\xc4\x36\x17\x34\x65\xb1\xa3\xd9\x36\x9b\x9f\xf5\xc9\x2c\xc1\xd9\x89\x2a\x89\xe4\x1c\x7a\xa3\xda\xf5\x20\x88\xcd\x7f\x5a\x69\x63\x2e\xc1\x62\x98\x94\x4a\xd9\xb5\xc6\x02\x7d\xf8\x24\x67\xd7\xae\x03\x78\x66\x45\x3a\x3b\x91\x34\x20\x56\xff\x59\x09\x90\x2a\x93\x8b\xb1\x95\xd0\x90\xcc\x54\x17\xa5\x86\xe7\x4f\xc2\xc3\x22\x2f\x95\x7b\xca\x5b\x20\xda\x3b\x12\x7f\xed\xe3\x2e\xde\xc6\xef\x2b\xf6\x10\xe3\xf3\x83\x1c\x57\x1c\x09\x94\xf1\xf6\x7b\xe2\x6b\x94\xdb\xc4\x33\x54\x85\x8f\x44\x0f\x0f\x17\xd2\x3a\xba\x65\xe6\xa5\x41\xe7\xc0\x2e\xe9\xa8\x8e\x0f\x09\x2a\x42\x32\xae\xcc\xb2\x98\xe3\xf7\x60\x88\x7a\x03\x37\x01\xe1\x20\x75\xe7\x44\xa3\xca\x1d\x87\x44\x68\xd3\x9b\xf6\xfb\x5b\x2a\x86\x10\x57\x89\xc5\x02\xae\x35\x67\x3b\xd6\xc0\x25\x87\xbb\xa6\x76\x0a\x5b\xc9\x28\xb7\x08\xd7\xb7\x20\x5a\xc3\x3f\xc1\x9f\x5c\xdd\xd6\xc3\xbc\xcc\x6b\x7c\xeb\xfb\x4a\x9b\x2d\x3e\x09\xfd\x18\x45\x5c\xc2\x56\xda\x8b\x50\xaa\xdc\xde\xe5\xab\x0a\xf4\xdf\x6c\xfd\xc6\x2b\x0e\x23\x2c\x02\x4b\x81\x9e\x59\x6e\xd1\xc6\x4c\x50\xb4\x05\x76\x32\x64\x34\xdc\xce\x29\xd5\x46\xe0\xe6\xea\x1d\x97\x4c\x95\x48\x96\x1e\xba\xff\x12\x74\x17\xe0\xac\x86\x58\x17\xfc\x20\x9e\x73\x76\x65\x3e\x72\xbc\x0d\x58\xd6\xc6\xb2\xcb\x1c\xb8\x99\xd7\x59\x38\x4d\x24\xf9\xd9\x3b\xb1\xf9\x91\xf8\x5a\xf4\xac\xe0\x9c\x97\xca\x18\x17\x54\x03\xe7\x46\x5e\x1b\x31\x51\x84\xc2\xc4\x55\x0b\x41\xa3\x60\x3f\xdd\x6b\x53\x2b\x38\x43\x91\x53\xce\x38\x8c\x26\x0a\xe8\x32\xe8\xe7\x0f\x2d\x3f\x3b\xff\x2b\xf8\x46\x09\x5d\x16\x5b\xbb\x7a\xa6\x37\xa6\x43\x3e\x50\xc6\xe9\x2a\xec\x3d\xc0\x1e\x26\xd0\x7c\x18\x1b\xea\xd0\x50\x5c\x55\x5b\xb7\x06\xdd\xad\x84\x2e\xff\xdc\xe6\x4b\x9a\x3c\xe8\x80\xae\x08\xf3\x81\x40\x1b\x25\xbc\xac\xca\x40\x13\x81\x6e\x85\x59\x83\x42\x86\x89\x2b\xb9\x41\x12\xfe\xc4\x75\x2a\x5c\xd4\xe7\xc1\x68\x0e\xc4\x6a\x97\x8e\x57\xc4\x7e\xfc\x4d\x9e\x16\xaf\xc0\xe6\xea\x79\x74\x2c\xa6\xb6\x0a\x79\xa1\x35\x56\x12\x9f\x54\x3b\x76\xe8\x5a\x0e\xf0\x37\xb6\xb7\x30\x84\x10\x5f\x05\x7d\xa0\xea\x3e\xad\x84\xe0\x09\x10\xb0\xb3\x2e\x5e\xc9\x8c\x0e\x0e\x66\x93\xe1\x52\x61\xc8\xc4\x3e\xb4\x82\x5c\xe1\x90\x0a\x60\x81\xc1\x89\x59\xce\x74\xb5\x94\xe4\x6b\xd0\x64\xcf\x9f\xa2\x97\xed\x28\xdf\xa9\xf1\x6d\xa8\xfa\x3f\xd9\x78\xf0\x49\x86\x09\x7e\xd2\x20\x80\x0c\xe3\xfe\xfe\xce\x12\xb3\xff\x36\x99\xbf\xe3\x04\x70\x58\xa7\xdd\xee\x19\xed\xfa\x07\x0f\xec\x81\x9e\x4c\xa9\xe1\x29\x52\x4f\x04\x90\x8d\xfb\x1a\x02\x77\x1a\x7a\xb8\x7d\xaf\x43\x09\x9f\x98\x00\xc3\x78\xde\xc3\xba\xc8\xa6\x0a\x2d\x77\x7e\xee\x3f\x72\xef\x7f\x74\x8b\x01\x20\x1c\xf0\xed\xa5\xf0\x0c\x9c\x97\x15\xe4\xc8\x32\x01\x72\x47\x85\xcc\x59\x97\xb6\xb4\x6f\x54\x0b\xb9\x65\x04\xaa\xee\x40\xd3\x39\x61\x72\xd4\x67\xf4\xa1\xd8\x95\xc6\x2f\xa4\xb0\x3e\xaf\x95\xe5\xf4\x14\x8e\xa0\x1c\x0d\x08\x5a\x08\x90\x76\xce\x0f\xc7\xb5\x1d\x24\x66\x2a\xea\x3a\xd8\x02\x93\xc1\x40\x2d\x2a\xf7\x19\xd6\xcf\xbc\x9c\xb3\xe9\x7f\x98\x0e\x83\x9b\x6f\x7b\x59\x97\x79\x0d\x3a\xf0\xc2\xf2\xb4\x71\x5a\x12\x62\x9f\x3d\x9c\x2d\x33\x47\x3a\x44\x93\x00\xd6\x0b\x95\x1c\x5c\x6f\x3c\x30\x7c\x7d\x61\xb9\x17\x18\xf2\x70\x94\x14\x7c\x17\xa8\xbc\x3f\x4c\xaa\x40\x7c\xa6\x13\x55\x59\x13\x87\x10\xcb\x70\x39\xeb\x87\xba\xb4\xc9\x1e\xf6\x79\xcd\xbf\x88\xfd\x76\xc4\xcd\x5e\x5b\x7e\x35\x71\x2a\x4b\x54\xf4\x02\x07\x8d\xd6\x17\x9e\x1c\xa4\x76\x50\x1f\xec\x84\x92\x36\x20\x99\xb8\x81\x18\xff\x8b\x19\x0f\x7b\x03\x36\x3a\xa9\x8b\x16\xa0\xd4\x44\xbd\x87\xe6\xbe\x0f\xe7\xc5\x54\x97\x75\x5e\x3a\xae\x89\xbc\xf6\x21\x1f\xc6\x21\xd8\x40\xa6\x28\x54\x99\xfb\x77\xf1\x3c\xea\x14\xf8\x93\x05\xd5\x30\xac\x06\x4e\x77\x4c\xd1\x9a\x28\xb4\xd8\x8e\x79\x75\xf8\xee\x1e\xb6\xf5\x4e\x1c\x45\x0b\x81\xcd\xf5\x7a\x52\xe4\x66\xa1\x32\xea\x4c\x5c\x6e\x08\xf3\x00\xc9\x49\xb0\x8a\x5f\x7e\xf0\xc2\xad\xbe\x84\x08\x73\xd5\xa3\x37\xf0\xfc\xb9\xae\x70\x44\xfa\x49\xf9\x77\x9e\xd8\xfb\x41\xf4\xf9\x41\xf8\xcc\x27\xac\xa4\xe7\x32\x2f\x50\xf1\x4e\xdf\xa1\xd5\x04\x43\x08\xf1\xdc\xb8\x6a\xdc\x5a\xf1\xdf\xd8\x35\xa8\x1f\xdd\x41\x40\xcc\xe6\x15\x75\xc1\x04\xe5\xa4\x73\x59\x0b\xfe\x47\x4e\x90\x0e\x9e\x10\x66\xbd\x5a\x15\xb9\x67\x3f\x81\xd3\x24\x60\xea\x54\x91\x3c\xc7\xcf\xdc\x65\x23\x4e\x28\x81\x3a\x17\x77\xf3\x68\xa3\xf3\x8a\x6f\x7e\xfc\xe1\x06\xc5\x4b\x79\xa1\x72\x03\xf1\xe7\xaa\x5a\x2b\xa7\x31\x0e\x37\x7d\xb3\x06\x29\x68\xb6\xb6\x92\x9b\x9f\xca\x61\x37\xc7\x6c\x5f\x04\x71\x1f\x77\x4c\xbc\x5d\x4c\x0f\x1f\xfa\x07\x67\x51\xbd\x06\x7a\xd6\xfd\x57\xcc\x0f\xeb\xc9\x48\xbc\x60\x2a\x24\xcf\x4f\x64\x5d\xab\xe5\xaa\x8e\x17\x91\x07\x0e\xa7\x6b\x0a\x2c\x98\xc6\x1a\x8a\xd7\x4d\x57\xa3\xd9\x8a\xb7\x37\xb9\xe8\x25\x48\x2a\xb0\x35\x17\xd2\xa8\x8c\xd6\x35\xcc\xb8\x87\x8a\x8f\x2a\x0c\x3b\x0a\x7a\x4c\xae\xf6\xd7\x6e\x97\x86\x13\xc5\x96\xf3\x5b\x7a\x77\xa5\x9d\x94\x1b\x98\xbb\x8e\x70\x03\xb6\xb8\x9d\x80\x65\x42\xed\x94\xdf\x79\x52\xef\x83\x94\x49\x13\x94\x16\xee\x68\x5d\xf7\x42\x6b\x3a\x4f\x35\x21\xd1\xc2\x8d\x23\x99\x83\x2a\xf9\x8c\xeb\x69\x57\xe3\xee\xa8\x7e\x57\x2b\x5b\xa0\xda\x62\x3c\xba\x56\x4e\x25\xf8\x67\x28\xa9\x06\x70\x2c\x54\x89\x82\xad\x32\x53\x65\x9d\xcf\xb6\x9c\x77\x61\xdc\x56\xca\xab\x1c\x60\x58\xda\x74\xf1\xba\xf9\x11\x08\xcf\xfc\x0d\x38\xd4\x2e\xf6\xd2\x18\xe2\xfb\x8f\x29\xb1\x98\xb4\x02\x16\x34\xef\xd2\xe7\xef\x7f\x2f\xce\xd2\x98\x9e\xc0\x60\x9a\xeb\x8b\xf3\x99\xfb\xb7\xbc\x29\x07\xa4\x65\xce\xd4\x4a\x95\x99\x2a\xa7\xf9\x3d\x08\x30\x01\x81\xf1\xb4\x61\xc6\x68\x00\x3f\x0b\xf2\x68\xc8\x35\x40\x5b\x3d\xfd\x44\x5b\xf2\x03\xa7\xd2\x68\x32\x84\x98\xdc\xfb\x16\x7a\xee\xe6\x37\x13\x8d\x15\x41\x00\x9a\xe5\x99\x5e\x4f\x0a\x75\x5a\xe4\xd3\x9b\x5e\x60\x51\x9d\x1f\x1d\xea\x32\x9b\x14\x53\x5b\xbc\xf5\x7b\x6d\xf2\x02\x12\x51\x95\xf1\xf2\x9f\x13\x17\x00\x46\xc4\x0a\x0c\x24\xfd\xc1\x8d\xc4\xab\x17\x93\xbd\x67\x94\x12\x49\xc6\xe2\x8f\x51\x2a\x50\x10\xd1\x55\xe6\x63\xb5\xd3\xfb\x0e\x83\x47\xf5\x97\xa8\x77\xef\x23\x74\xe7\x70\x2b\x0b\x27\x9d\x5d\xae\x59\x2c\x85\xc4\x97\xbe\x96\x43\x2e\xb9\x9e\x45\x94\x5b\x18\x91\x8e\x6f\x7d\x9e\x7c\xc7\xda\xfe\x64\xea\xa1\x33\x9d\xa4\xf9\xd2\xdf\x45\x3f\x24\x68\x6b\x7c\xc9\x38\x34\x03\x44\x67\x04\x27\x46\xcb\x5a\xc9\xc9\x03\xe2\xe1\x1d\xaf\xdd\xc8\xaa\x74\x37\x19\xa0\xa6\x67\x62\x99\x1b\xb8\xab\xc6\x6a\xef\xa1\x38\xbe\x95\x79\x61\xef\xcd\x96\x00\xe8\xfc\x72\x64\xff\x43\x9f\x18\x56\xfc\x13\xb3\x0e\x7e\x0c\x53\xdc\xb5\x82\xa9\x73\x07\x07\x56\xc4\x33\x75\xec\x44\x85\xb9\xad\xc0\x1b\x46\xed\x20\x41\xdf\x4f\xae\xf6\x08\x05\xcd\x34\x05\x6e\x99\xf5\x27\x5b\x37\xc1\x00\xec\xd8\x04\xb0\x77\xb5\x20\x7c\x1f\xdc\x88\x33\x35\xd5\xeb\x95\x15\xe6\xc9\xb7\xc9\x41\x40\x92\x9e\x94\x74\x6f\xe9\x8e\xf2\x9f\xcf\x01\x55\x93\x8c\x7e\x99\xaa\x55\xb5\xcc\xcb\xdc\xd4\xf9\xd4\x4e\x9c\xac\x32\x70\x77\xb3\x8d\x84\x0c\x7e\x88\x4f\x50\xee\xd7\x0b\xb5\x3f\x0b\x49\x63\x74\x39\x10\xaa\x9e\xa6\xe7\x1f\x84\x0f\x7f\x14\x2e\x6e\xe8\x3c\xb9\x26\x43\x51\x87\xe1\xd9\xb5\x77\x87\x69\xd8\x58\x4a\xe5\x63\x02\xa8\xd9\x5a\x28\x44\x4b\xb5\xea\x1d\x1e\x36\xf4\x11\xbf\xc5\xad\x3c\x8c\x72\x6c\x85\xc5\x1c\x3c\xb2\x52\x4e\x75\x1e\xd2\xfa\x40\xda\xc4\x65\x74\x2c\x4e\xf5\x0a\x12\xb0\xa2\x5b\x6f\x12\x4f\x75\x70\x20\x4e\x0b\x5b\x8a\xaf\x8e\x10\xe1\x41\x50\xa7\xd9\xb6\x94\xcb\x7c\x0a\x7a\x64\x42\x24\x1f\x3a\xd1\x3b\x56\x45\xed\xf0\xbe\xe8\x1c\x41\x3c\x21\x3b\x34\x3e\x5c\xcc\x72\xcb\xdf\xeb\x2c\xb4\x07\xce\x9e\x6c\xc5\x38\x9e\xf7\x31\x3a\xa7\xb2\xfd\xe0\x31\x99\x2c\x2d\xe2\x09\x61\x1d\x3b\x26\x6e\x29\xb5\xaf\x81\xb1\x5b\x9e\x4e\x37\x46\x57\x50\x5f\x55\x1a\xb1\x92\x15\x82\xce\xca\xb9\x72\x78\xf0\xf9\x3f\x90\x77\xe9\x8a\xad\xfc\xae\x6b\xa9\x23\xf6\x32\x56\xc3\xf9\x8c\x00\x9e\x01\x36\xf5\x77\xbf\x6e\x2f\x98\x13\x00\xe3\xbf\x6b\x37\x50\xb1\x7e\x7b\x3b\x43\x48\x6a\x6e\xdc\x1c\x9e\xe5\x55\xbd\xe5\xda\xd0\x0e\xfd\xda\x2e\x8a\xa4\xf4\x6b\x2f\xd2\xb8\x0b\x05\x0d\xc3\x6e\x8d\x53\x8b\xee\xae\xfd\x0b\x4d\x1d\x1e\x34\xa7\xbc\x6f\x33\x1c\x2a\x78\x3b\x45\xf0\x0b\xe4\xed\xe0\xe9\xc0\x76\x54\xfb\x4c\x0e\x53\x6f\x34\x83\x51\x8b\xb5\x80\x41\x89\x0b\xc2\x72\x2c\x1f\x77\x6b\x6e\xc4\xae\xde\xb5\xa9\xc5\x44\xcb\xfa\x08\x56\x94\x8f\x0c\x1c\x3d\x29\x17\x02\x48\x3a\xf9\x05\xb3\x26\xb4\x8c\x86\x38\x12\x78\x84\x0f\x67\x95\x52\xff\x50\xfd\x7f\x3e\xf8\x82\x7a\x3f\x72\xc3\x30\x78\xf0\x45\x97\xc0\x35\xea\x14\xc5\x06\x0f\xbe\xe8\x10\xa3\x46\x5d\xf2\x55\x4b\x15\x2e\x1e\x35\xeb\xf1\xb7\x83\x07\x5f\x74\x0a\x0e\xa3\x6e\x99\x62\xf0\xe0\x8b\x76\xee\x36\xea\x38\xf9\xda\x2a\x10\x13\x68\xa9\x42\x6f\x30\xd4\x9b\xf2\x4b\x43\x60\xf5\xe9\xba\xb2\xeb\xcd\xee\x0e\xf3\xbc\xd2\x4b\x72\x5f\x45\xd3\x05\x15\xbc\xa0\x84\x1f\x5d\xef\xed\x33\xfb\xce\x95\x0b\xa6\x8f\x08\xbd\xfa\xcb\x6f\x28\xb8\x1b\x9f\x9c\x3a\xdb\xf4\x55\xa5\x22\x98\x39\x27\x56\xb8\x35\x75\x47\x53\x5d\xf1\xe1\xae\x72\x87\x8e\x52\x4b\x5f\x38\x81\xf4\xb5\xaf\xd7\xd2\x47\x5e\x2f\x7d\x4d\x37\x2f\xc7\x2f\x08\x48\xa9\xdf\x46\xe8\xf1\xe3\xb6\x76\xc5\x3c\xc3\xc5\xff\xc5\xa7\x44\x34\x82\x94\x50\xd0\xc7\x72\x83\xe1\x95\xe0\x9e\x72\xe3\x85\xeb\xb6\x16\xe8\xd6\x59\x6e\x89\x29\x82\xff\xec\x9c\x12\x74\x1b\x1a\x20\xdd\x86\xb3\xf7\x5d\x3c\x66\x5a\x5f\x46\x06\xc3\xc8\x3b\x08\x3d\x90\xb0\xdc\x4f\xde\x47\xd3\x79\x0a\x5d\x37\x5e\x1d\x36\x6a\xb9\xb6\xb7\xd4\xf2\xaf\x98\xcb\xb5\x37\xaa\x5e\x98\xe3\x2a\x88\x47\xb9\x81\x7f\xfb\x8d\x0f\xee\x1d\x36\xab\xfe\xa4\x4a\x71\x94\x52\x7a\xd6\xec\x87\x4b\x60\x31\x6a\xe9\xe2\x33\xf1\x54\x8c\x7c\x22\x34\xdc\x2c\xd4\xda\xdd\x2d\xf3\x9d\x62\x2d\xf3\x55\xb1\x65\x09\xa5\x67\xcd\xb1\x6a\xb6\x2c\x0c\x63\xdc\x32\xb7\x7c\xd3\xd6\x1d\x35\x06\xe0\xf1\xe3\xa4\x1d\xbc\xc8\x4f\xaa\x6c\x59\xd6\x76\xcd\xc2\x92\x21\x93\xe0\x98\x16\xde\x47\x2e\x62\x7a\x33\x40\xd0\xc7\xd3\x65\xd3\x51\x8f\x54\x6c\x6f\xb6\x65\xbd\x50\x75\x3e\x85\x8f\x7d\xa4\x1a\xf1\x53\xf4\x35\xb4\x97\x4c\x5e\xd3\x1b\x00\x1c\xda\x44\xe6\xdc\x9a\xbc\x0f\x5d\x78\xd3\x9f\x2e\x64\x39\x57\x46\xa8\x0f\xa5\xf7\x64\xd9\xe3\xe4\x66\x3e\x88\xd9\xb5\x53\x1c\xaf\x56\x45\x3e\x45\xd0\x2b\x8c\x0c\x0d\x4e\x8d\x51\x28\x33\x80\x1a\x5c\xb8\x54\x08\xde\x95\xc7\x0f\x70\x2c\x11\x62\x5c\xab\x3f\xfd\x70\x87\x0d\x42\x63\x07\xbe\x05\x03\xa0\x10\x44\xc2\x1a\xdd\xd6\x70\xdf\xc0\x8f\x5f\x7e\x11\xbd\x75\x79\x53\xea\x4d\x89\xc8\x55\x3d\xaf\xd1\x1f\x4e\x91\xbb\x5e\x21\xe6\xfb\x51\x1b\x43\x81\x75\xb2\xd7\x16\x08\x78\xcf\x88\x69\x08\xf8\xe0\x0d\x66\x59\x7b\x91\x73\x74\xb7\xc7\xe7\x09\xa1\x95\xe3\x00\xf0\x0e\x0c\x18\x1c\x45\x5e\x2b\x9f\x94\x1c\x40\xb2\xbc\x15\xab\x67\xc4\x54\x17\x88\xbb\x1c\x74\xc0\xa4\x36\xea\x1a\x67\x65\x2e\xe8\x26\x9a\x0e\x78\x18\xe0\x4f\xe5\x6d\x9f\xce\xd9\x82\x96\xb1\x95\xf5\xf6\xc3\xa0\x39\xf9\xed\x2e\x8e\xd7\x30\x91\xe4\x80\x35\x23\x72\xf1\xe7\x4e\x1e\x77\x28\xf2\xaf\xbf\x8e\xcd\x24\xd8\xe4\xdc\xd8\xc3\x58\xce\x61\xdc\xdf\xd4\x7a\xb5\x52\x59\x3f\xb2\x88\x4c\x2a\x25\x6f\x62\x2b\x04\x5c\x82\xc3\x90\xc9\x32\x13\x61\x30\x20\xe8\x6f\xa3\xed\xbd\x4e\x16\x85\x2a\x04\xa8\x24\xc8\x5c\x6e\x5f\x92\xe6\x23\x2f\x21\x28\xc2\x79\xd3\xdd\xbd\x49\x1a\x7d\x7b\x97\xbf\x1f\x34\x67\xe3\x5d\xfe\x9e\x9f\x8e\x4d\xdb\x48\x18\x49\xea\xe5\x67\x7c\xba\xe5\xbb\x7e\x0e\xbb\xd6\x0f\xf3\x85\xe9\x5a\x2e\x2d\x9b\x04\x2e\xa5\x5d\x2b\xdb\x4e\xd8\x71\x7d\x55\xad\xd5\xc5\x72\x85\xc0\x8c\xbe\xe2\x39\x8f\xa6\x97\xe2\x11\xe2\x98\x3c\x0a\x0a\xd3\x7d\xca\xe2\xe0\x21\x64\x6a\x72\x7f\x2f\x83\x8d\x18\x34\x55\xd3\xe9\xda\xb1\x55\xca\xd4\x80\x0c\x57\x57\x0e\x53\x5b\x83\x7f\x63\x05\x19\xd8\x5c\x8c\xd2\x05\x0f\xbf\x41\x3d\x08\x84\x10\x7e\x25\x8c\x2a\x8d\xf3\x30\x77\x16\x5c\x04\x84\x46\x34\x7c\xb6\xc3\x45\x7f\xb2\x9e\x4c\x0a\xbb\x65\x6b\x2d\x6e\x94\x5a\x85\xb8\x29\xf0\xab\xff\xca\x59\x98\x20\x48\xc1\xd8\x4e\x28\x09\xa8\x2d\x4e\x55\xed\x86\x81\x60\x3c\xc8\x21\xb2\x56\x25\x68\x3b\x6d\x9b\xa8\x41\x2e\xc7\x57\xa6\x24\xc4\x40\x41\x9b\x1a\xc3\xa6\x82\xda\xdb\x59\xa6\xbf\xfa\x48\x68\x32\xa1\x21\xe0\x8d\x84\x5f\x76\xb7\xc3\xbc\x9c\xb3\xae\x0d\xe3\xc9\xda\x79\x3a\xee\x34\x83\xcf\x04\x22\x14\xdb\x2f\xb2\x71\xe3\x93\x96\x1b\x31\x07\x6f\xdc\x0a\x55\x5c\x4f\x86\x91\x72\xfe\xd8\x17\x35\x80\x4b\xee\x33\x04\x9a\xda\x25\xee\x01\xcf\x6e\x5d\x05\x66\x2f\xf2\x92\x0e\x79\x44\x60\xd0\x25\x85\x77\x81\xa2\x28\x18\xee\xec\xca\x00\x5f\xd3\xa5\x5a\xea\x6a\x0b\x41\xf3\xf6\x1a\x0c\x51\x01\x96\x2f\x80\xaa\x15\x8f\x5c\x1f\x07\xbc\x36\xc2\xc8\x69\x95\xcf\xf2\x29\x66\x20\x3a\x7e\x75\x01\x78\x06\x25\xfa\xb5\xbe\xc9\xad\x68\x3c\xa6\xe3\x65\xec\x94\x4a\xd0\xc8\x89\x9a\xe9\x4a\x51\xc6\x91\x95\x34\x98\x9b\x10\x08\x43\xa0\xc3\x57\x58\x0c\xc2\xde\x62\x98\xdd\x01\xad\x05\x07\xdf\x8a\xc8\xc8\x79\x2d\x30\x02\x4f\x87\x0f\xba\x8c\x8f\x63\x29\x8e\xd8\x40\x5f\x94\xb5\xee\xcb\x81\x98\xec\x1d\x8e\xa9\x04\x28\x93\x6d\xeb\x43\xb8\x89\x59\x49\x7b\xed\x46\x45\x76\x86\x2e\xae\xe3\x40\x04\x7d\x41\x8c\x5e\x2a\x0c\xbd\x80\x6e\xa3\x08\x15\xaf\xb9\x5f\x60\xf8\xfe\xfc\xd5\x5f\x3e\x8a\xe3\x32\xb4\xc2\x85\x6c\xda\x79\xa4\x69\x0e\x38\xc2\x71\x53\xa9\x3b\x03\x51\xaa\x0f\x24\x73\x3c\xec\xdb\xbf\xc5\x43\x07\x17\xde\xa6\x2f\x49\xa8\xe0\xdd\xe6\x98\x2f\x37\x58\x43\x3b\x97\x4f\xac\x53\xa5\x73\x8f\xda\x93\x82\x95\x3b\xa0\x72\xf5\xa1\x46\x0e\x8b\x3a\xd8\x13\x5d\x2f\xe0\x38\x01\xf7\xab\xe5\xaa\xde\x0e\xc5\x5b\x14\x86\x47\xe2\xa5\x0f\xa6\x10\x1f\x86\x53\x5d\x4e\x65\xdd\xdf\xee\x21\xcc\xcc\x96\x14\xc1\x18\xf7\x72\x70\x20\xa6\xaa\xaa\x25\x28\x37\x65\x2d\x3e\x40\x40\x4e\x89\xc2\xbd\xe8\x7f\x10\x53\x37\x71\xd2\xa1\xcd\x03\x5f\x40\xa2\xe4\x0c\x05\xf9\x66\x9a\x47\x37\x75\x68\x8f\x2b\xe4\xe2\x12\x30\xf2\x4c\xe3\x86\x15\x86\xab\xb5\x59\xb8\xd8\xaf\x68\x92\x12\x04\x0c\x7a\xc9\x15\x74\x9c\x44\x9f\xd5\x69\xd6\xf8\xf8\xa0\xb5\xd1\x51\x93\x0e\x0e\xc4\xb1\x98\x40\xd4\xa8\x16\x99\x15\xa8\x2b\xbd\x06\x5d\x2a\xe5\x0f\x1d\xdb\xe2\x63\xee\x12\x28\xde\xd1\x37\xde\xbb\x81\xf7\xad\x80\x2f\x26\xa5\xb0\x63\xef\xa3\x13\x2f\x36\x65\xc8\x0a\xce\x89\x47\x7c\x89\x3f\xf2\x6b\x9c\x7c\xd1\x73\x23\x54\x8e\x79\x13\xdd\xdc\x69\x30\x76\x48\xc7\x78\x6d\xe9\xa1\xf8\xd9\xa8\xd9\xba\xc0\x85\xb0\x92\x79\xe5\xf2\xb3\x40\x1c\x12\xdf\x85\x78\x3d\x0f\x1e\xf7\x12\x0e\x2e\x94\x53\xd7\x75\x5e\xe4\xf5\x96\x24\x1a\x34\x15\xe1\xa8\x10\xa0\x18\xe6\x94\x95\x4e\x66\xe5\x7b\x12\x4e\x21\x4c\x7c\x59\x66\x3e\xd4\x16\xec\x6c\xd0\x28\x9f\x58\x49\x7d\x90\x80\x3a\x66\x4f\x63\x5b\x53\xf4\x2d\x0f\x83\x00\x7f\x58\xf2\x14\xc6\x8d\xa6\x24\x60\xa1\xe0\x8f\x0e\x83\xb6\x37\x6c\xbf\xe8\x4c\x27\xc2\x7b\x17\xa3\xbc\x4f\xdd\x87\x23\x53\xb9\x70\xf0\x2a\x6a\x7a\x44\xeb\xd9\x47\xf1\x0e\x12\xa8\xbc\x17\x98\x14\xc3\xe5\xe0\x1c\x5b\x5e\x3a\xc6\x28\x7a\x16\x6e\xca\xc5\x73\x82\x65\x64\xac\xa2\x2f\xab\x6a\x20\xa6\x93\x01\x26\x65\x09\xbe\xaa\xf1\x92\x94\x55\xe5\x57\xa4\xac\x2a\x8f\xef\x18\x2a\x26\x5e\x30\xb6\x82\x4b\xf2\x38\x41\x53\x0a\x94\x1b\xd8\xea\x41\xdf\xe9\x6d\x24\x74\x8f\xfb\xfb\x5a\xd1\xc9\x8d\x5e\x87\x01\x8e\x9e\x9f\xa6\xf5\x42\xe5\x55\x74\xd4\x96\x99\x65\x28\x96\xd4\x46\xe6\x35\x99\x95\xa0\x5e\xa3\x2c\x09\x72\x59\xe2\x9c\xfc\x7f\xe0\xcb\xa9\x5b\xf2\x19\xff\x86\x0b\x54\x2e\x33\x51\x29\x88\x41\x30\xfe\x70\xf2\x87\xf1\x4a\xeb\x62\xe0\x00\x33\x56\xaa\x72\x79\xb2\x12\xcb\xc9\x33\x67\x3a\x49\x2e\xdf\xe1\xfa\x1e\xb9\x09\x0e\x7f\x97\x5b\x38\x73\x9a\x81\x71\x48\x45\xdc\xe3\x32\x7b\x8d\x1d\x6d\xaa\xa7\x1a\x77\x39\x7f\xa1\xe9\x90\xe9\x77\xdc\x05\x99\x27\xc6\x43\x7f\x27\xf2\x43\xc7\xef\x42\x2e\xae\xad\x34\x75\xb5\x9e\xd6\xba\x1a\xd2\x4c\xb0\x4b\x1c\xd3\xc9\xdd\xd1\xab\x37\x7e\x94\xa2\xee\x45\x58\xa7\x3b\xaa\xf7\xd5\x00\xf4\xff\x88\x7c\x7a\xc7\xb7\xae\xf4\xea\x27\xd0\x67\x7c\xf6\xa7\x5c\x50\xd6\xc7\xc3\x07\x3c\x93\x22\xec\x1d\xcc\x37\xd1\xaf\xe5\x3c\x06\x6a\x95\x73\x74\x65\x99\xac\xeb\x5a\x63\xa2\x57\xff\x0c\xb2\x28\xc4\x8f\x30\xb1\x52\xfc\xac\x56\x1f\x6a\x59\x29\xd9\x6b\xcb\x2f\xfa\x0a\xf3\xcc\xbd\xd0\x6b\x43\x81\x66\x68\x7d\x41\x15\x05\x64\x7e\xc4\x06\xb9\x2c\xb0\x25\x73\x81\xa3\xbc\xab\x25\xfa\xd7\x8c\x9a\xcf\x4e\x31\x02\x3a\x79\xc5\x9d\x72\x3a\xdf\xb4\x57\x85\x76\x9e\xe9\x4d\xd9\xf5\x7c\x47\xb5\x17\xfa\xb6\xf3\xf9\x8e\x6a\x3f\xaf\xda\x9f\xc6\x55\xfc\x8c\x3d\x7c\x08\xa9\x52\xcd\xd0\x27\x2f\x7b\xfc\x38\x9d\xe4\xed\x4a\xed\xed\xb5\x26\xa5\x6d\x4d\x3d\xdb\x48\xd7\x40\xe8\x84\x88\x9d\x32\x93\x53\xbc\x08\x26\x9e\xf5\x1a\x8d\xc4\xa6\x46\x84\x2e\xc0\x99\x21\x27\x63\x64\x47\x70\xc1\x8d\xea\xd8\x4b\x40\xf0\x5b\x87\x9b\x09\xc4\x18\xc3\x3d\x20\xa0\x5b\x53\x5d\xd1\x70\x6b\xf7\xc7\x64\x1f\xc5\xbc\x81\x38\xbb\x7c\x01\x2f\x51\x7f\x35\x10\xee\x39\x32\xcf\xbd\x91\xf8\xea\x23\x92\x12\xc2\xa1\x45\x0f\x29\x4b\x84\xa8\xf5\x8a\x34\x88\x9e\x2b\x52\x28\x32\xdc\x39\x50\x6c\xc4\x63\x9e\xa0\x7d\x5c\x16\x76\xe1\x3d\xae\x4c\xcc\x96\x0d\x4b\x19\x62\xa5\x55\x3b\xd6\x13\x85\x87\x56\x16\xb9\x67\x85\x21\x12\xa4\xb8\x05\x57\xb8\xb1\x37\x99\xbb\x2f\x5d\x42\xa8\x9f\x2c\x06\x71\x4c\x03\x04\xe9\xd3\x37\x41\x8c\x77\x2e\x81\xd2\x87\xc7\x00\x0a\x66\xb0\x93\x39\x82\x64\x6a\x77\x9a\x1e\x77\x0b\xac\xc8\xcd\x2c\xe8\x9b\x87\xe2\xaf\x78\x5f\x87\x7b\xbc\x1d\x11\x22\x6c\xbf\xe7\xa8\x4d\x5c\xc2\x2f\x22\x49\x19\xf7\xc5\x38\x35\xf2\x8d\x21\xcd\x7c\x87\x77\xee\x98\x0f\x46\xcc\xe4\xf8\xac\xe3\x97\x06\x3c\xaf\x32\xcc\xf7\x5e\xcb\x68\x91\xcc\xc7\x96\xab\xbe\x55\x55\x95\x67\x4a\x2c\xf4\x26\x1c\xd6\x73\x55\x1b\x3e\x2b\xe2\x64\xeb\x88\xd1\xde\x19\x44\x8a\x72\x3a\x3c\x57\xe0\xe5\x03\xe2\x99\x5f\xeb\x56\x40\x23\xff\x05\xe7\x1c\x9b\x07\x6c\x60\x7b\x3b\xc5\x85\x1c\x9c\x39\x10\x03\x37\x20\x70\x40\xba\x9d\x49\xa1\x82\x30\x60\x67\x75\x1a\xa9\x02\x28\xcd\x14\x65\xfa\x75\xe9\xe5\xb8\xdf\x64\x10\x5c\x82\xf1\xf0\xa9\x43\x86\xfe\x2a\x81\x1b\xbd\xd3\x19\x49\xf0\x76\x78\xe8\xce\x4f\xb3\xb5\xb6\x7d\xf8\xd7\xbb\x86\x74\x35\xe6\x1e\x76\xdc\xc3\xc6\x4d\x26\x34\xc7\x20\xfc\xa9\xb3\x13\x0c\xc2\xf5\x05\x74\x44\x80\x3d\x1f\x24\xd0\xe1\xbd\x3c\x9b\x5f\x12\x98\xab\x5f\x45\x7d\x35\x9c\x0f\xc5\x98\xce\xb1\xf1\x5e\x1c\x47\xf1\x2c\xdc\x07\xae\x00\xba\x44\x57\x31\x44\x0c\x97\xd9\xe7\x2a\x04\x31\xda\x46\xb7\xb9\xfc\x3a\x5d\xba\xfb\xfe\x21\xdd\xd0\x11\xba\xb6\xe3\xa8\xb6\x5d\x3e\xbb\x7c\xb1\x4f\xb9\xde\xa6\xc8\xc0\xd4\x2c\x2f\x73\x58\xad\xa4\x30\xf1\x97\xf4\x22\xbf\x55\xc2\xde\x8d\x0e\xe1\xe6\xe3\xce\x08\xcc\xe9\x0f\x71\xbe\x13\xc8\x32\x82\x59\x9f\x84\xd1\x10\xd6\x6e\x9b\x65\xec\x45\x95\xec\xc9\xb6\x0b\x43\xff\xc0\x85\x22\x3c\xf4\x4f\x78\x48\x1c\x45\x25\x03\x9c\x97\x15\xa7\xfb\xea\xc3\x48\x68\xc8\x6b\xea\x98\x23\xb8\xe0\x4c\x2b\x04\x7a\x2e\x20\xd2\x78\x2f\xba\x0b\x3b\x7d\x2f\x4f\x5a\x6e\xd0\x32\xd3\x69\x0f\xef\x87\xd6\xf8\x06\x32\x59\xa6\xb5\x71\x9d\x1f\xf5\x6b\xe2\x08\xbf\xdd\x74\x9d\x76\xdf\xe8\x12\xa9\x9a\xfe\xea\x30\x88\x5c\xc6\x4a\x35\x35\xec\xfb\x0f\xfb\x0f\x7d\x13\xac\x5c\x87\xd8\x5d\xa1\x55\xf7\x80\x40\x3f\x77\x27\x24\x44\x4a\xf9\xaa\x38\xff\x92\xf1\x6b\x87\xd0\x3c\xd7\xf6\xee\xed\xd5\xb0\x50\x0d\x3c\xeb\x5a\x1c\xd6\x07\x69\x93\x52\x0f\x76\xe8\x51\x58\xd9\x41\xa2\x39\xc6\x33\xc0\x1d\x6d\x51\xec\xa6\xd0\x80\xbb\xb6\x2e\x41\x4b\xa0\xfd\x89\x4e\xcb\x06\x58\x8f\x97\x10\x30\xa5\x13\x24\xa3\x74\x81\xfc\x89\x7b\x35\xd3\x33\xb7\xa8\xfa\x52\x31\xa1\xe1\xd7\x16\x59\xc8\x98\xcc\xd3\xaf\xe9\x56\x80\xe8\x0b\x98\x2a\xfa\x02\x36\x39\xb6\xe7\x1c\xaf\x4a\xec\x07\x8a\x42\x61\xcb\xe3\x17\x23\x0f\x35\x66\x8c\x72\xce\xdd\x2d\x26\x28\x4c\x24\x8d\x99\xff\x1c\xf3\x4d\xfd\x0b\x97\x72\x6b\xa7\x18\xf3\xe8\x0b\x59\x8b\x6a\x5d\xd6\xf9\x92\xa0\x3d\xb8\x27\x31\x45\x68\x1c\xf9\x20\xc3\x9c\xf9\x9c\xc5\x85\x12\x3c\x5b\x1c\x0f\x1e\x67\x18\x95\x1e\xfe\x46\x03\xc6\x01\x99\x93\x6f\x46\x38\x2c\xae\x15\x89\x8e\x15\x9f\x0f\xd2\xe6\xb6\x26\x74\x0b\x17\x3a\x9a\x9b\xb0\x64\xcf\x4b\x10\x16\x21\x69\x77\x7a\xe5\xb7\x32\x45\x50\x52\xb3\x30\x1b\x67\x15\x19\xaf\x2a\x3d\x55\xc6\x9c\x7b\x7d\x05\x45\x05\x47\x72\x0a\xb3\x91\x53\x67\x7e\xed\x8a\xc5\x36\xd3\x04\x28\x36\x64\xfe\xca\x1f\xec\x78\x5c\x95\xd2\x36\x84\xf0\x8e\xec\xd4\xa6\xa1\x07\xe2\xea\x16\x44\x6c\x8b\xc5\xef\xc8\xf6\x05\xad\xf2\xbd\x6e\x6f\x7b\x63\xc4\xfa\x89\xd6\x82\x32\x99\x8e\x15\x1b\xd3\x5a\x47\x86\x0c\xa2\x01\xfe\xb6\x75\x9a\x7f\xa0\x56\xf6\x2e\x30\x73\x80\x5a\x0e\xb1\x12\xd3\x72\xd2\xc8\x65\x94\x93\x21\x10\x1a\x86\xc3\x88\x9e\x9c\xf3\x81\x0b\x8d\xf1\x96\xca\x58\x3d\x45\xe7\x45\xdc\x15\xd1\xa6\xde\x6b\xfb\xc2\xe0\x5e\x3a\x11\xae\xd1\xfb\xed\xc8\x3b\x35\x88\x37\xd5\x92\x13\x3a\xf6\xaf\xed\xf0\x69\x4e\xe1\xde\x88\xe5\xb5\x74\xe3\xbd\x51\xf6\xc6\xd4\x35\xe0\xe1\x42\x80\xab\x46\xbc\x61\x69\x9c\xe1\xf6\xb3\x90\x08\x28\xba\x55\xb5\x98\x28\x55\xf2\xe4\x15\x2d\xfe\xe7\x70\x9b\xde\x04\xc3\xc4\x5c\xeb\x4c\x58\xd6\x88\x97\x2d\x44\x4e\xc8\x11\xb8\x4e\x73\xe5\x9c\x47\xb5\x03\x40\xc9\x61\x8b\x1b\x48\x13\x4d\x82\x1c\xca\x13\xe7\xd0\x1f\xd6\x93\x36\xbf\x50\x96\x4e\x85\xdd\x0f\x06\x0f\xbe\x60\x82\xe4\x88\x4b\x95\x83\x07\x5f\x44\x3c\x76\x14\x9f\x51\xf6\x35\xe7\x00\xa3\x98\x21\x0c\x1e\x7c\xd1\x98\xa1\x51\x73\xdf\x05\xdf\xca\x8b\xd2\x05\x5c\xc8\x5a\x79\x27\x3d\x3c\xb2\x0e\x0e\xc4\x09\x6e\x3a\x07\x17\xe6\xd0\xba\xd0\xca\xed\xf6\xb5\x04\x5b\x16\xe4\xf6\x05\x9a\xcf\xfd\x73\x4e\xf0\x29\x2a\xe5\x4e\x6d\x31\xfe\xfc\x1b\x7c\xfe\x83\x36\xf5\x6b\xad\xed\x93\x6f\xe1\xd3\xf0\x03\x2c\xf5\x0b\x6d\x6a\x51\x57\x4a\x0d\xc5\xa9\x9b\x63\xc2\x2d\xf4\x38\xba\x90\x0d\x05\xd3\x7e\x7a\x72\xaf\x74\x65\xa5\xd0\x23\xf1\xaf\x87\x68\xb8\x31\xeb\x49\x42\xc6\x2e\xc4\xb2\xb6\x47\xae\xce\x1d\xb0\x6f\x70\x6c\xc6\xcc\x6e\xaa\x0a\x24\x79\xc3\xff\x2d\x34\xfc\x4a\x7d\xb0\x4f\xfe\x48\x5d\x94\x45\xd4\xf3\x7f\x0f\x8f\x7f\xc0\xf5\xf6\x6a\x81\x5a\xdc\x3f\x1d\x52\x5e\x21\x7b\x40\xf1\x2a\xdf\xe1\x8b\xe7\x95\x9c\x2f\x69\xf8\x9e\xd0\x8c\x55\xb2\xcc\xf4\xf2\x47\xb5\x15\x47\xe2\x85\xac\x17\x43\x7c\xd0\xdf\x1b\xd6\x1a\xd3\x59\xf4\xbf\xfd\xe3\x1e\x46\x4d\xf4\xbf\xd9\x3b\xa4\xbb\x29\xf2\x63\xe7\x58\x81\xd5\x7b\xd7\xd7\x00\x6e\x73\x91\xbc\xfd\xb2\x27\xbe\x0e\xdf\x89\x29\xc0\x22\xa2\x6e\x98\x98\x4c\xf4\x2a\xa5\xc1\x4f\x01\x35\x95\xd3\x85\x02\x81\xdf\x8a\xf5\x5f\x3e\xed\xdb\x29\x26\xc1\xc1\xdf\x3a\xec\x5f\xef\x5a\x1a\xfe\x5e\x1c\x09\x57\x9e\x9f\xe6\xdf\xe7\xb7\xa0\x6a\x0a\x70\xcc\x4e\xef\xba\x50\x62\x5a\x68\xa3\x4c\xed\x93\xd1\x86\xc1\x46\xb3\x98\x7b\x6e\x67\xf2\xb4\xe1\xbe\x26\xc0\x19\xa5\x86\xa4\x4a\xc9\x6d\xf0\x14\x09\xa7\x1e\xa9\xfd\xd0\x0f\x97\xc0\xb8\xb5\x2f\xe9\x55\xa1\xab\x1c\xb7\xf4\xbe\x95\xc5\x8d\x58\xaf\x30\x67\x43\xa5\x14\x01\x95\x6c\x94\x98\xe5\x25\x78\x9c\xb8\xe6\x8a\x0d\xa0\x35\xfa\x6e\xb8\xdc\xbb\x30\xfe\x99\x3f\xf7\x64\x45\x62\xd6\x3b\xf8\x0e\xb2\xeb\xfe\xc3\x3b\x1b\x4d\x15\xc9\xb6\xea\x2e\x68\x2c\x6b\x34\x16\x78\x19\x25\x5b\x2e\xc9\x2b\x3b\x7e\xdf\x9a\xb6\x00\x90\xbf\x57\x8e\x63\xe3\xd6\x05\x56\x0f\x34\xb8\x41\xdd\xc5\xcc\x48\x82\x83\x82\x61\xe9\x03\x28\x76\xa0\xb5\x2e\x97\x7a\x5d\x82\xff\xd2\x4a\xd7\xaa\xac\x73\x59\x14\xdb\xbd\x61\xac\xae\x0d\xf0\x3c\x1f\xdd\x98\x43\x3a\x36\x5a\x40\x1c\xd5\xd0\xb9\xb2\x52\x77\x3a\x27\x0e\x82\x10\xe0\x92\x48\x6a\xfc\x98\x95\xfc\xf2\x8b\x68\xbc\xbd\xf2\x2e\x08\x0e\xa1\x1f\xb6\x0b\xa9\x4b\x41\xe7\x49\x6e\x63\x13\x45\x71\x81\x6a\x65\xdb\x57\x69\x5d\x47\xb7\xdf\x1c\xb6\x09\x83\xa5\x39\xc4\xe1\x7b\xfc\x18\x1b\xb5\xab\xf1\x7b\x87\x6e\xba\xfc\x54\xeb\x55\xb0\x00\x85\x31\x09\x1f\x09\xf2\x36\xbd\xbd\xf7\x16\x6d\xdb\x9a\xed\xfb\x12\x83\xaf\x9c\xc6\x48\x57\x28\x20\x12\x02\x06\x34\x78\x43\xf2\x03\x71\x70\x02\xf6\xc8\x0d\x45\xb0\x35\x76\x71\xba\x7d\xbf\x7c\xca\x36\xf0\xa7\x4e\x33\x77\x6f\xf8\x15\xd3\xde\x98\xc1\xc6\xfe\xe8\x58\xb1\xc9\x8b\xe6\xf0\xdf\x7f\xa4\x63\x1e\xaa\xab\x4a\x99\x95\x2e\x33\x0a\xff\x74\xd3\xd8\x1c\xcf\xd4\xcd\xf6\xcb\xa7\x6c\x64\x7e\xbb\xed\x20\x30\x95\x50\x6e\xc4\xdf\x5c\x7c\x2c\x28\x8b\x70\x11\x20\xa0\x77\xa9\x37\x00\x70\x2b\x8d\x59\x2f\x95\x47\x72\x24\x50\x6e\x80\xc7\x07\x01\x63\xca\x07\x03\x45\x0e\xf5\xa1\xb9\x95\x62\x6d\x99\x67\xc9\x04\x51\x8f\x0e\x54\xe0\x01\xe6\x65\xe7\x01\xb8\x5d\x61\xbe\xb5\x52\x97\xfb\x67\x97\x2f\xf6\xc3\xc7\x08\xcd\x0f\xf5\x9d\xa5\xfa\x50\xfb\x2c\x13\x58\x9b\xb2\x6d\xb8\x98\x08\xdc\x87\x4c\x4d\x6a\xd6\x2b\x55\x81\x31\x68\xed\xee\x32\x4d\xa9\xbd\x65\x46\x82\x2b\xbb\x83\xb4\x06\x5f\x76\x6e\x54\xdc\xa5\x94\x8b\x36\x48\xdb\xe1\x95\xca\x09\xef\x21\x80\xcd\x2d\x48\xff\x8d\xf5\x2a\x93\x35\x8a\x02\x40\x9f\xe8\x46\xd6\xca\x3b\xe8\x92\x26\xcf\x0b\xe5\x8d\xd5\x7d\x65\x0f\x83\xb6\x98\xad\x54\x10\x19\xb5\xc9\x26\x28\xab\x77\x1c\xf3\xa3\x1d\x22\x00\x56\x6c\xad\xd1\x64\x37\x58\xb8\x39\x49\xad\x7b\x09\x0b\x77\xce\xcd\xe8\x8e\x99\x1b\x3c\xf8\x22\x1d\xf6\x51\xcb\x44\xe0\x25\x81\xaf\x86\x57\xb0\xf8\xd8\x4e\xce\xb4\xcf\x3c\xe7\x8f\x81\x77\x3d\x5c\x0e\x3d\x52\x39\x79\xc5\xf7\xc5\xcc\xc3\x4a\xca\x20\xee\x6f\x94\x58\xc2\x3e\xdd\x48\xf2\xb4\x90\x79\x21\xf4\x9a\x76\x1e\x5c\xee\xd0\xbc\x83\x56\x17\x30\xb6\x01\xe8\xf4\x46\x61\x1d\xba\x0a\x90\x70\x6f\x44\xbf\x90\x5b\x70\x66\xb6\xc4\xc0\x59\xd6\x51\x72\x66\x43\x4d\x7e\x28\xb8\x99\x80\x3b\xa0\x57\x1b\x00\x6a\xcf\xb5\x77\xb7\x0f\xf2\x09\x29\x3b\x1c\x25\xe0\x0f\xc0\x64\x10\x1b\x55\xd6\x78\xfd\xf4\xf0\x9d\x33\xc7\x51\xc5\x4b\x54\x65\x82\x3a\x9f\xdc\x7f\x0b\x55\x8b\xb5\x71\xb4\x32\xe7\xaa\x02\xb7\x95\x99\x92\xf5\xba\x02\x9d\xde\x47\x27\x89\xc1\xe8\x52\xb8\x0a\xb0\xc5\x87\x29\xd3\xdc\x6b\x3b\x7f\x5a\x04\x80\x8e\x83\xe1\x75\x60\xf2\x85\xde\x28\xe4\x86\x4b\xcd\x04\x49\x3d\x13\xc7\xd0\x87\x93\xf4\xc0\xdd\x82\x65\x33\x47\x4f\x61\x7f\x75\x82\xa9\x68\xb1\x9d\x00\xf5\x53\x20\x7e\x4c\xb4\xa1\xcd\xc7\xa8\xae\x3e\x61\x91\x08\x6a\x55\x2f\x8e\x5d\xd6\x58\xaf\x4e\xad\xd5\x72\x75\x4c\x4b\xed\xf8\x10\x7f\x1e\xfa\xa7\x61\x91\xc2\x13\x2f\xa9\x20\xb1\xaf\xbf\xe6\xb6\x07\x78\x76\xd2\xfa\x81\x13\xfa\xc0\x09\x52\x76\xff\x34\x3e\x70\x12\x7f\xe0\xc4\x7d\x80\xd2\x2a\xd9\x31\x83\x85\xab\x56\x56\x74\x9b\x56\x72\x53\x88\xf5\x6a\x18\x64\x6c\xea\xe4\xbe\x6b\xcc\x5f\x02\x0a\x34\x74\x30\xfa\x22\x3c\xf1\xae\x06\xb6\xe2\xfe\x7e\xf2\xbd\x93\xfb\x7c\xef\xc4\x7d\xef\x38\xfd\xde\x49\xe3\x7b\x27\xfc\x7b\x27\xf1\xf7\xe0\x1e\x92\x97\xa2\xd0\xd3\x1b\xc8\x34\x94\xdc\x43\xc4\xd2\xa5\xbd\xf5\xc3\x2d\x8e\xe8\xcb\x87\x49\x9b\xf6\xf7\x53\xa9\xe9\x18\x0e\x7f\x6c\x15\x89\x04\xec\xd1\x50\x16\x70\x1e\xd4\xaa\x55\x5c\x3a\xe6\x2e\xa0\xbb\x47\x72\x57\xbf\xef\xde\x32\x39\xcd\xb1\x8c\xf7\xca\x49\xe2\xce\xce\x36\x18\xf2\x94\x70\x27\xa3\xdb\x0d\xba\x66\xef\xe7\xa5\x7f\xd3\xdc\x3d\xd8\xbe\x38\x74\x89\x1f\xc0\x09\x8b\x8e\x42\x8b\x72\xe7\xd1\x8e\x57\x29\x79\xab\x2a\x23\x0b\xbc\x33\xd5\x1b\xbd\x0f\xce\x02\x03\x9f\x54\x18\x19\x27\x69\xc9\x62\x1f\xfd\x90\xd9\x12\xa9\xa8\xab\x8d\x06\x85\x06\x19\x44\x67\x25\xa4\xf4\x0b\x3b\x79\x25\x61\xe2\xa3\xcb\x25\xe7\x53\xf6\x3d\xde\x21\x7d\x30\x96\x3f\x51\x1a\x5d\x0a\xfb\x37\xf7\xdb\x36\x87\x0b\x4a\xbd\x08\x86\x95\xfd\x7d\xbb\xb4\x0f\xbd\x2a\xb6\xec\xdb\xf7\x10\x1f\xd3\x73\x39\x92\x7a\xd8\xcc\xe8\x6e\xc4\x8d\x35\x11\xc1\x60\xa9\x89\x68\x51\x30\x46\x44\x8a\x39\xf9\xd0\x00\xe1\xa0\x5f\x9c\x89\x45\xae\x2a\x59\x4d\x17\x90\xc8\x85\x4c\x05\x26\x46\x1c\x1c\x4f\x27\x63\x01\x9c\x77\x2b\x2e\xce\x0c\xe5\xfe\xf8\xca\xd9\x22\x50\xc9\x59\xa9\xa9\x82\x43\x45\x8c\x97\x60\x99\xb4\xc2\x11\x3a\x7d\xc0\xef\x9f\x94\xbc\x55\xe3\x00\xc9\x05\xc2\x7a\x48\xd2\x64\x3f\x1b\x67\x0f\x20\x55\x7e\xa9\x64\xd5\xc6\xfd\x5d\x42\x80\x52\x83\x13\xbe\x25\xf7\x48\x95\x60\xe5\x7b\x64\xbf\xfa\xa8\x50\xb3\xfa\x11\x65\x96\x40\x3d\x6d\xc7\x5a\x81\x96\x42\xf3\xfa\xb3\x4a\x2f\x07\xa2\xd6\x7e\xc5\x3c\x87\x07\xb2\x9a\x5f\xe9\xb0\x78\xa8\x29\x47\x68\x24\x7c\xfc\xd8\x9e\xde\xcf\x3a\x8f\x12\x47\x73\x4f\x8c\xa2\xd4\x7d\x76\xc6\x2c\xf9\x74\x19\x82\xc3\x20\x87\x87\xb0\x04\x02\x47\x61\xa1\x5e\x1f\x7d\x19\x68\x88\x65\x44\xd8\xb4\x1d\xa5\xed\x97\x3d\x9f\xa2\x2e\x04\xc6\x15\x74\x25\xa1\xcc\x43\x96\x35\x80\xd5\xbc\xcf\xc7\x5c\x17\x71\x27\x41\x3f\x08\x0c\x14\xfb\x1d\x76\x92\x7f\xf7\x91\x8d\xce\x95\xbe\x73\x6c\x6a\x7d\xc7\xc8\xd4\xfa\xfe\xe3\x72\xcd\x07\xa6\xd6\x6d\xc3\x72\xdd\x3e\x2e\xd7\x9f\x31\x30\x57\x1a\x87\xa5\xd6\x34\x28\xb6\xa9\xfc\x30\xd7\x7b\x0d\xe8\xde\x84\x17\xc0\xd8\x76\xf3\x03\xfb\xba\x85\x27\x3c\xe7\x63\xed\x49\x5f\x3b\x8e\x75\xa5\x3d\xc9\xeb\x0e\xa6\x75\xa5\xdf\x5d\xb7\xf0\xad\x2b\xdd\x60\x37\x6f\xf4\x92\x67\x7c\x30\xe4\xaa\x6d\x77\x2d\x19\x1a\xb9\x6a\xbb\x81\x88\x65\x5b\xc7\xf2\xbd\x7d\x25\x1e\xc1\x99\x60\x20\xb6\x60\x15\x82\x22\x49\x07\x67\xcf\x78\xc3\xf2\x14\x41\xfa\xcf\x39\x68\x18\xa0\x5e\xc2\x00\x5c\xc1\xe3\x9a\x9f\x15\xe4\x7c\xcc\xa8\xc3\xdb\xb0\xfd\x9b\x58\x70\xc4\xd5\xee\x07\xae\xf9\x2e\xa5\xfc\xfe\x30\x3a\x2e\xef\xf2\xe5\x89\x1c\x1c\x84\x59\x82\x1d\x54\xd5\xc9\x88\xd8\xa9\xb4\x4b\xd2\x0c\x30\x70\x00\x72\x98\xd9\xfb\x39\xea\xe9\xa6\x53\xb5\xaa\x85\xa4\xea\x12\x94\x90\x80\x0f\x36\xe3\xd0\xf1\x18\xec\x35\xb7\xad\xc1\x04\x1e\xf4\x9d\x47\x3e\x72\xaf\x52\x32\xdb\xba\x50\x43\xf4\x03\x7c\x24\xf6\x5d\x9a\xdf\xaf\x40\x0e\x37\xaa\x36\xed\x1e\xfb\x05\x56\x07\x6b\x1a\x80\xb9\x80\xab\x35\x44\x3b\xf8\x6f\x05\x33\xb7\xa5\xe7\x5d\x4b\x7c\xe6\xcc\x83\x3c\xa3\x84\x9d\xc7\xaf\x2e\x50\xd4\x34\xf9\xbc\x84\x20\x80\xdc\x88\x8d\xdc\x12\x02\xdd\x54\xaf\x2b\x39\x57\x98\xd6\xc0\xd2\xe2\xa3\x45\x09\xcf\x72\x45\x9e\x1f\x3e\xbf\x40\x1c\x20\x18\xa2\x04\x06\xc2\xe4\xa8\xbe\x66\x40\x61\xee\xbe\x48\x81\x19\x68\xd4\x2b\xeb\x1c\x07\x21\x89\xfe\x23\xe3\x71\xf8\x80\x02\x4d\x18\xc6\xb0\x40\x38\x8c\x2e\x55\x1c\x05\x78\x25\xe7\xf6\xa2\x3a\x8e\x23\x10\xc7\x38\x62\xcc\x1f\x80\xb9\x70\x42\xee\x15\x6c\x3e\x33\x8f\x41\x70\x8b\xaa\xd4\x20\x0e\x8d\xb1\x47\x31\xc6\x44\x68\x31\xb1\xf2\xb2\xae\x04\xe6\x08\x61\x99\x4a\xc1\x15\x58\x3a\x80\x41\xf0\x0b\x78\xb1\xae\x65\x1d\x81\x6e\xf6\x8c\x58\xaa\xe5\x04\x22\x8f\xbb\xbe\x30\x75\x69\x61\x36\x15\x3a\x96\xc2\x06\x77\xdd\x78\xe4\x52\x22\x60\xfe\x56\x99\x93\x3e\x8a\xc5\xa2\xa6\xf8\x05\x07\x6d\x61\x74\x67\x10\x1b\x0a\xa6\x3f\x16\xd1\x8d\x7b\x8b\x04\x4c\x16\x94\xf0\xcf\x06\x60\xc3\x40\xf4\x5c\x3d\x04\xd4\x32\xcd\xb0\xcb\x5e\x74\x74\x31\x7f\xae\xdd\x1c\x06\xd8\x8a\xbb\x25\x07\xe7\x26\xe6\x28\xd1\x1e\xa1\xdc\xe6\x36\xd1\x52\x32\x20\x00\xd0\x01\xb3\x23\xa2\x79\x37\x49\x5f\x92\xb0\x0f\x52\x2e\x7f\x4a\xeb\x9d\xc7\x04\xbb\x88\x65\x5c\xff\xc5\x96\x81\x03\xd0\xca\xcf\xd8\xb0\xee\x0b\x03\x46\xa3\x1c\xb8\x50\xad\x4c\x6d\xf6\x86\xe2\x27\xf9\x8f\xbc\xd8\x86\xd8\x29\x40\xee\x83\xc0\xb1\x66\xd8\xea\x50\x88\xb7\x64\x80\x81\x64\xa0\xa4\x2f\xb1\xe4\xc2\x6a\x45\xcc\x7e\x55\x59\x0e\x97\xdc\x3a\xfc\xb2\x86\x30\xd9\xb7\xca\xe1\xc4\xb9\xd2\x7c\x63\xc6\xb5\xd8\x2e\x8f\x83\xc9\x88\xe1\xf9\x0c\xb5\xa1\x19\x4b\xb9\xc5\xf8\x32\x38\x0c\x99\x8a\x02\x5c\x91\x3a\xd7\xb2\xbb\xd5\x84\x85\xfc\x06\x1a\xc4\xc3\x6a\xbc\xcb\x4d\x48\xe8\x74\xbf\x73\xc9\x2d\xbc\xc6\x15\x8a\x16\x03\x77\xa5\xba\x63\x7b\x71\x98\x89\x48\x1a\xb0\xa7\xa5\x34\x3c\x8a\xaf\xab\x4b\x63\x0c\x05\x37\x37\xf9\xca\x80\xe7\x36\x4e\x17\xb6\xe1\xec\x93\x47\xe8\xcd\x4d\xbe\x42\x3f\xaf\xdf\x74\xac\x40\x39\xe3\xc7\x25\x60\x4c\x84\x67\x0c\x2f\xdf\xdf\x94\xad\x74\x19\x2a\x3d\x6b\xb9\x46\x87\xd7\xfc\xd6\xd0\x32\x37\x81\xe8\x67\x4f\x0a\x0f\x2d\x77\x69\x6d\x11\xe3\x12\x0f\xce\xca\x21\x59\xfa\x94\xba\x85\xd6\xa8\x4d\xc4\xd1\xc1\x00\xff\x54\x76\x1b\xb6\xcd\x36\x36\xac\x31\xd7\x30\xd5\xf4\x6d\xa4\xf6\xf7\x75\x4e\xd9\x84\x28\x67\x9e\x4f\x40\xf7\x42\x56\x37\xf6\x62\x49\x36\x46\x43\x1f\x89\x4e\xe7\x4c\xec\x58\x22\x8d\x53\x00\x93\xcc\x65\x67\xa1\xa7\xc9\x12\x71\xba\xce\xdd\x4b\xa5\x0b\xc7\xfb\x53\x44\xc6\x76\x44\xe0\xe4\x50\xb9\x97\x8c\xe8\x2e\x2c\xe9\xb1\xf2\xbb\x1c\x2c\xbf\xf1\xd1\xd2\xc4\x40\xe6\x6b\x94\x1d\x32\xa0\x0f\x68\x88\x43\xc8\x39\x00\x87\x96\xd8\x33\xf8\x46\x26\x0b\xe8\x6e\xc0\xa3\xdd\x12\xc5\xaf\xe3\xc1\x5d\x8b\xa5\x75\x99\xb6\x30\x60\xcb\x12\x1a\x1b\xfa\x5e\xfc\x30\xf2\xc7\x6c\x71\xd8\x73\x7e\xac\x77\xf3\xd4\xc4\x34\xb7\xb3\x42\xc2\x7e\x7f\x8b\xcf\x07\x9a\x9d\x0d\x09\x9a\x1d\xd6\xff\xc2\xfe\x1e\x08\xd0\x15\x61\x3a\x78\xd4\xce\xd8\x06\xed\x54\x09\xb5\xcd\xcd\x40\x70\x72\x9d\x0d\x49\x97\xcc\xa7\x8f\x42\xfb\xa2\x4b\xdd\xfe\xe8\x46\xa3\x61\x37\x37\x8c\x8b\xbb\xc6\x74\xb4\x73\xc4\x07\xbb\x2b\x87\xa9\xd8\x4d\x26\x94\x8b\x08\xb6\x4d\xd3\xe8\x8e\x69\x8c\x08\xa4\x83\x33\xda\x31\x70\xc1\xcf\x10\x52\xf6\x96\x35\x3a\x8c\xc5\x51\xdd\xdf\x2b\x4a\xc8\x7e\xa3\xb6\x3e\x42\xce\xa5\x70\x53\x1f\x6a\x57\x17\x38\x50\xe4\x73\x10\x87\xf1\xb8\x78\xa0\x1f\x77\x93\xd9\xe5\x5c\x3d\x57\x35\xba\x3f\x40\xc9\x63\xa8\xac\x2b\x9e\x33\x8a\xf5\xe3\xf1\xe3\x00\x29\x74\x5e\xde\xe6\x95\x2e\x31\xd1\xa3\x2c\x7f\x36\xea\xec\xf2\x05\x73\x58\x78\x55\xa9\x99\x15\xab\x02\x71\xc8\xe2\x50\x96\xaa\x02\xdf\x41\x27\xb6\x2e\x65\xb9\x75\x51\x0f\xc6\xa5\xab\x17\x13\x5d\x2f\x10\x26\x81\x72\x5c\xfe\xf5\x7b\xf1\x67\x4b\xeb\x2f\x4e\xdb\x6a\x28\x75\xa0\xab\x11\x28\xc3\x45\x17\x90\x14\xfe\x9c\xe5\xb7\x7f\x01\xc1\x02\x4d\xab\xd1\x94\xf4\x58\xd3\x7a\x90\x19\xcf\xe5\xad\x74\x7f\x50\x5a\x78\xf1\x2c\x29\x0b\xa9\x42\xe9\x6b\xbd\xc4\x68\x12\x3e\x71\x98\xc6\xbe\x2e\x54\xb1\x52\x3e\x15\x1f\x04\x5d\x19\xae\x0e\x21\xcc\x88\x78\x01\x80\xb1\x02\xd1\xd3\xc0\x4b\xc0\x81\x3d\x40\x50\xeb\x54\x2f\x57\xb2\xca\x0d\xde\x07\x5c\x1d\xba\xff\x00\x26\x01\x60\xdc\x38\x25\x55\xa4\x1c\xbf\x70\xf9\x34\x82\x07\x11\xe0\x4e\x60\x08\x36\xa4\xf6\x46\x53\x7a\xb1\xc5\x3c\xf2\x86\x92\xc8\xeb\x09\xdc\x8b\x2c\x0d\x98\xa5\xbc\x4e\x16\x2d\x28\xfa\x6b\xe3\xea\x8b\x95\x36\x39\xc1\x22\x63\x12\xc9\xcb\x17\x0e\xc0\x87\x0e\x4f\x17\xf4\xb2\x94\x5b\x8a\x9c\x80\x74\xe1\x18\xc7\x15\x04\x73\x6c\x66\xb6\xae\x5c\xdf\x89\xf0\x80\x9c\xe1\x09\xc2\x1e\x3e\xee\x3f\x5a\x6b\xb4\xcd\xd9\x87\x44\x72\x19\x86\xc1\x87\x32\x32\x72\x6f\x6a\x54\xd1\xda\xa5\x7c\x5d\x69\x5d\xa3\x88\x3c\xb0\x3f\x4d\x2d\x2b\xd8\x30\xec\xd9\x8c\x4c\x0a\xe1\x71\x12\x22\xef\x00\xad\x55\xbf\x23\x8e\x26\xfd\xf8\x10\x3e\x0b\x49\xd1\x92\xf2\x87\xad\xa5\x7d\xab\x50\x7c\xb3\x7f\xf5\xf7\x98\xda\x0f\x41\x82\xf9\xd9\x51\x29\xa3\xea\xfe\x5d\x5f\xa7\x8b\xc1\xee\x0f\x76\x97\xe2\x03\xc3\x61\xcd\x38\xf3\x39\x93\xb5\x64\xdc\x66\x37\x91\xc4\xcc\xbf\xbb\xf0\x21\xf7\x65\x84\x06\x1f\xf2\x1f\x10\x7c\x2c\x8e\x76\x75\x2e\x2a\xff\x13\xc2\x71\x1e\xb1\xda\x4e\x91\xed\x22\xa1\xca\x8c\xfd\xe9\xe8\x47\xf3\x41\xef\x3c\x2d\x57\xce\x53\x72\x2a\x73\xf8\x08\x6a\xe3\xf1\xcf\x3f\xf3\x56\xd0\xc3\xa0\x91\x87\x68\x0c\xdf\xae\x77\xf0\x27\x22\x64\xbb\x2f\xd0\xb3\x4e\xa3\x81\x1f\xa9\x65\x5e\x9e\x97\x99\xeb\x27\xb5\x74\x3f\x0c\x20\x34\x4f\x41\x89\xa7\x87\x96\xbc\xf8\xf3\x11\x55\x82\x9f\xbb\x1b\xe5\xe9\xa9\x32\x4b\x1a\x18\xc6\x05\xdf\xde\xdd\x54\x70\xf8\xbe\x92\x79\x81\x23\x29\xfe\x22\x9e\x02\x34\x2a\xd4\x17\xa3\x80\x35\x75\xaf\xe5\xe9\xe7\x02\xfd\xc8\xa1\xb9\x83\xf0\x0d\xbe\x9f\xee\x5a\x78\xc9\x1a\xc7\xf9\xf7\x6b\xbc\x07\x71\x89\x70\xe4\xb4\x6f\xbd\x3b\x97\x39\x78\xbc\x02\x95\xc6\xe9\xd3\x56\xf4\x5d\xd7\x21\xef\x30\x97\x84\x32\x45\x5e\xd6\x08\x50\xb9\x8f\xe1\x90\x23\xf1\x04\x74\xc3\x94\x80\xfc\xad\xac\xca\xe7\xba\x3a\xce\x32\x95\xbd\x54\x1b\x87\xd7\x1e\x10\xea\x11\xbe\xfe\x55\xa5\x3f\x6c\x29\xb6\x05\x60\x4d\x28\xb6\x12\x9e\x27\xb1\x9e\x58\xe7\xfc\xaf\xe7\x2f\xaf\xae\x5f\x5d\x5e\xfe\x74\xfd\xe6\xe2\xff\x9e\x73\xbf\x7f\x34\x00\x9f\x28\x0a\xdd\xc9\x5e\x79\x0c\x07\x71\x24\xde\xf5\xe2\x3b\x4f\x6f\x20\x7a\xec\x0e\x63\x7f\x32\xee\x69\x7f\xe6\xe6\x0c\x23\xee\x29\xc2\x15\xec\x4a\xbd\x36\xf4\x4b\xa0\xd5\xb8\x97\x46\x4f\xfd\xc5\xb2\xc7\x72\xd4\xfc\xaf\x80\x68\x71\x7e\xeb\x50\xfb\x0c\xa5\xd7\x1d\x1d\x1c\x6c\x36\x9b\xe1\xe6\xdb\xa1\xae\xe6\x07\x57\xaf\x0f\xce\x2e\x5f\xec\x43\x2c\xd2\xfe\xb7\xfb\x18\xcb\x72\xe0\x8f\x23\xf8\x7d\xe1\xa9\xe1\x61\x64\xc7\x32\x9c\x3b\x35\x49\xc4\xee\xf7\xc1\x81\x88\xd1\x56\x73\x03\x66\x01\x90\x84\x98\x32\xf4\x50\x94\x1a\x8f\xc9\x12\xb2\x5c\x50\x5c\x99\x3d\xfc\x1f\x88\x98\xc4\x08\x51\xd5\x5c\x74\xcb\x97\x4f\x87\xf5\x42\xd6\xe8\xd9\x61\x5e\xd2\x77\x61\x2c\x41\x12\x0f\x6d\x41\x83\xa0\x09\x0f\xa6\x76\xac\x20\x4d\x0c\xeb\x40\xbe\x54\x6f\x6a\xb9\x5c\x8d\xba\xa0\xa7\x79\x18\xe3\xd0\x17\x17\xbf\xfc\x22\xce\xec\xe2\x2e\xf5\x86\xa0\xeb\x2d\xb9\x2c\x99\xdc\xf0\xa1\xdc\x40\x32\x19\xf7\x88\x87\xe7\xbf\x49\x23\xfc\x64\x95\x66\x47\x8c\x70\x49\x20\x58\x98\x72\x7a\xe4\x70\x8c\xae\x74\x69\x10\x2d\x10\xd3\xc3\xc4\xa0\x1f\x99\x2a\x14\xd9\x80\x42\xbe\x74\x12\x09\x95\x51\xc2\x6c\x0d\x40\x98\x91\xaf\x03\xda\xc2\x0a\x9f\xe2\x46\x17\x04\x25\x55\xa9\x6c\x4d\xb2\xd0\xac\x52\x7f\x5f\xab\x72\x0a\x71\x5d\x73\x59\x4d\xe4\x1c\x84\x28\x06\xd7\x85\x51\xfd\x40\xda\x51\x9e\x2e\xd4\xf4\x46\x8c\x39\xae\x11\x04\x1a\xba\x58\x28\xe5\x23\x9d\x48\x26\xc3\xf6\x87\x78\x50\xc2\x39\xca\x62\xa4\x29\x92\x30\x11\x6b\x91\xc3\x5c\xfc\x6c\xd0\xc3\x17\x5d\x39\x00\xa9\x4c\x7a\x38\xaa\x2c\xa6\x4e\xee\x19\x63\x7a\xed\xd1\x3a\x1a\x93\x03\xf8\x67\x66\x3d\x81\xc0\x2b\x65\xf6\x12\xb4\x17\x7b\x51\x42\x8c\xa3\x6f\x05\x45\xf3\x1e\xbf\xba\x10\x13\x50\x86\x97\x56\xcc\x2e\xf2\x7f\xd8\x86\x3a\x79\xf3\xef\xeb\xbc\xba\x31\x43\xf1\xc6\x93\x0c\xd0\x6a\x96\x47\xca\x2a\x2f\xb6\xde\xa0\xc4\x52\xa2\x3a\x57\x70\xbf\xdf\x0f\xc5\x74\x6d\x6a\xbd\x14\x92\xe1\x47\x7b\x60\x03\x6a\xfe\x54\x96\xe8\x6f\xe9\xba\x00\x56\xb3\x7b\xa6\xda\x3c\x8d\x32\x6c\xba\xdb\x5e\x16\x90\xb7\x73\xd3\x92\x6f\xf3\xab\x8f\x5c\x17\x8c\xba\x29\x9f\x4a\x2f\x32\xa9\x31\xe3\x40\xa3\x29\x8c\x91\x3a\xe7\xce\x28\x4e\x3d\xaa\x14\x63\xe6\x7c\x6c\xca\xb0\xe2\x2a\x48\xf3\x89\x1a\x35\x56\x94\x35\x32\x71\x7e\x6a\x7c\xba\xbf\x8c\x62\xae\x79\xb2\x87\xcc\x01\x25\xe2\xc0\x20\x58\xc4\x0c\x92\xab\x83\x41\xce\x90\xdf\x5f\xa1\xc0\x18\x94\x9b\x21\xa3\x7b\xd8\x78\xb9\x42\x4e\x43\x87\x4a\xf3\xbd\xa9\xf5\x8a\x9d\x2d\x5e\x1e\x85\x97\xc9\xec\x36\x73\x6d\x52\xb9\xeb\x48\xff\x1f\x2b\xfe\xd3\x26\xc6\x17\x06\x9f\xae\x93\x1f\x23\x50\x85\xc3\x97\xf9\x97\x91\x47\xe8\xaa\xd2\x2b\x97\x61\xc6\x97\x88\x3c\x63\xfc\xd3\x46\x02\x17\xaa\x7a\x47\x16\x19\xf7\x8e\x0d\xd8\x3b\x57\xf5\xfd\x21\xce\x19\x45\xc5\xde\x39\x63\xc1\xc5\xc6\x6d\x72\x4c\x00\x41\x2d\x64\x74\x59\xac\x16\x15\x0c\xad\x8c\x9b\x00\x91\x2f\x54\x86\x5f\xdb\xf6\x5a\xc3\x52\x00\x64\xc0\x8d\x19\xa2\x96\xc1\x4c\xf5\x78\x68\x3f\x8c\x7d\xed\x91\xd0\xdb\xae\x76\x2d\xa4\xdb\x1a\x16\xaa\xa6\x7d\x8b\x81\x00\xbc\x1f\x6a\x7c\x32\xc6\x24\x86\x8d\xd7\x84\xfd\x2a\x9e\xed\x2e\x36\x8a\x5e\xe3\x59\x4d\xb7\x9e\x23\x96\xb8\x08\x70\xb7\x93\xba\xde\x18\x68\x87\xa4\x29\x97\x59\x69\xbc\x5b\xf0\xb8\x8a\x73\x9e\xfe\x0a\x4a\xcf\x03\x4e\x99\xa7\xd0\x94\x06\xef\x49\xc3\x87\x0d\xe5\x18\x98\x71\x8d\xf0\xc1\xfd\x98\xa7\x85\x2c\x5f\x03\x68\x79\xcc\x44\x46\x8d\xac\xfd\x8e\x5d\x34\xfb\x15\x32\xff\x78\x18\x0e\xb7\xc1\x1b\x6c\x2b\x20\x1b\xa6\xbe\xc3\x6e\x4f\xfa\x62\x8a\x5a\xc9\x9b\x95\x5a\x77\xe2\xb7\xfd\x78\x4f\x80\x5b\x1c\x4a\xfd\xaa\xb1\x32\xec\x8d\xcf\x25\x2f\xe8\xa5\x64\xa3\x25\x14\x16\x90\x5b\xd3\xbf\x6e\xb1\x00\x4a\x54\xc2\x92\xdb\x86\xfb\x77\x18\xcc\xe4\xab\x69\xb7\x93\xd7\x77\x0d\x27\x8a\xd2\x27\xe8\xad\xdc\x31\x9e\x10\x43\xa2\xc4\x29\x40\x6f\xb2\x90\x7d\x8f\x55\x63\xb9\xea\x23\xc2\xc4\xdb\x22\x42\xe7\x23\xea\xf6\x4c\x57\x81\xca\xc5\x39\xf9\xbe\x91\x38\xeb\x6c\xb4\x5e\x4f\x6b\x9b\x01\x01\x2a\x15\xc9\xf8\x05\x00\xe4\xc9\x32\x0b\x44\x64\xb9\x15\xa0\x0d\x56\x60\xb3\xab\xb5\x88\xfa\x80\x58\x05\x8f\x5e\x80\x43\x0f\x50\x9f\xe9\x75\x99\x3d\x1a\x0a\x71\x1c\x88\xd0\x18\xa0\x1c\xab\x67\xe2\x11\xf5\xfa\x91\x98\xe6\xd5\x74\xbd\x74\xde\x5f\x10\x6e\x63\xd6\x0a\x85\x45\x48\xe4\x68\x34\xef\x90\x70\x62\x99\x0f\x83\x6d\x19\xd7\x38\xb1\x16\x5f\x7e\x9f\xca\x1f\xe2\x05\xe8\x61\xca\xde\x7a\x89\x1a\x90\x46\xd8\x95\x23\xb5\x37\x1a\x92\xb1\x99\x7f\x47\xa1\xf5\x6a\x20\x64\x86\x51\x89\x96\x5c\xbd\x50\xcb\x16\x20\xd8\x38\x97\xa5\x74\xee\x6a\x0b\x5d\x64\x42\x97\x10\xfb\xef\x27\x86\x84\x75\x4b\x6d\x03\x9a\xf5\x89\xb2\x9f\xb0\x97\xa0\x26\xdd\x07\x0e\x1d\x8d\x64\xf6\x4e\xc6\xc5\x2f\x1c\x9f\x35\x50\xa7\x76\xc2\x0d\x46\xde\xf8\x75\xd8\x72\x2d\xe9\x6a\x24\x52\xd9\x95\x42\x3e\x37\x0c\x6a\x8c\xd3\x24\xc8\x53\x01\x48\x0b\x9b\xdc\x28\x06\x0a\xc7\xba\xb5\xf3\x96\x0c\xc7\x43\xdc\xa3\xf1\x2b\xdb\x86\x0c\x60\x21\xc6\xe0\xed\x80\x5e\x6f\xe3\x4c\x39\xb1\x0c\xfc\xe1\x61\xc2\x7d\xd0\x44\x5e\x7b\xd0\xdf\xd0\x8c\x50\xa3\x8b\x95\xdd\x5f\xf8\xbb\xaf\xf8\x27\x98\x68\x42\x36\x40\x54\xb3\x79\x11\x10\x43\x54\x1d\x91\x01\x38\xa0\x40\x97\x09\x9c\xdd\x15\x3c\x43\xac\x37\xcb\xf3\x42\xe1\x16\xb1\x6d\xaf\x35\x03\x7a\x9b\xd7\x72\xb7\xc6\xa8\x3d\x09\x0a\x88\x56\xdd\x95\xde\xe5\xef\xdf\x33\x0d\x77\x2a\xbb\xee\xea\x7d\xa2\x7c\xba\xc7\x10\x24\x35\x00\xff\xde\x77\x7c\xe7\xa7\xe2\xe3\xf8\x9e\x5f\x6b\x54\x4a\x16\xf1\x3d\xbf\x9d\x1c\x5e\xf7\xfc\x78\xb3\x56\xc7\xd7\xc9\x53\x63\xef\xf0\xc1\x83\x44\x8e\xe2\x0b\x3b\xd6\x96\x05\xed\xce\x0f\x68\x71\x0b\xfa\x93\x89\xce\x0b\x55\xad\x0a\x59\x13\xd6\xfa\xd4\xf9\xaf\x06\xad\x42\x7a\x1f\x0f\x58\x89\xb0\x63\x5b\x41\xb4\xfd\xb7\xe1\x3a\x9b\xb4\x54\xae\x01\xd1\x04\x6a\x47\xe8\xcb\xf0\x64\x90\xee\x30\xbb\xa4\xdf\x40\x88\xf3\x11\x09\x93\xf4\xf0\x3c\xaa\xbc\x07\x89\x92\x85\x38\x0f\x12\xa5\x38\xc2\x8a\xe1\xc9\x61\xc0\x79\xf2\x45\x4a\xb5\x11\xe7\x7d\xc4\xbc\x76\x32\x2a\x13\x4a\xa1\x51\x81\x02\xcc\x43\xf2\x0c\xe3\x8f\xc3\x17\x92\xd7\x9c\xc5\x88\x23\x7c\x0b\x5f\xc3\x72\x7c\xe2\xdc\xf7\xff\xf9\x71\x40\x4d\xf7\x6f\xf9\xb8\x84\x8f\x24\x63\x89\x75\xf8\x43\x5b\x54\x66\x84\x33\x8a\xfa\xb3\x2b\x8d\x23\x4d\xd0\xd5\x07\x5f\x7d\x85\xea\x68\x88\x4f\xc7\xa3\xf5\x56\x55\x5b\x4c\xb6\x01\x8e\xd4\xa9\x22\x02\x35\x7b\xa2\x52\x46\x17\xb7\x8a\x94\xd9\x28\x65\xe8\x12\x32\x75\x88\xb7\x6a\xf2\x63\x5e\x7b\x43\x36\xe2\x35\x90\x4f\x3c\x14\x20\xa8\xe2\xa0\xc2\x26\xdf\x75\x4b\x38\xe4\x54\xe9\x7f\xff\xc3\x1f\x9e\x3e\x79\xf2\xf4\xc9\x1e\xac\x24\xef\x22\x96\x28\xd6\xbd\x9d\xfd\x2b\xd4\xdc\xef\x13\x5a\xb3\x28\xf5\xbe\x5d\x22\xfb\x94\xba\x04\x0e\x09\x91\xa6\x56\xc3\x35\x00\x14\x93\xdb\xc9\x80\xdf\xd9\x71\x0e\xf9\xc1\x52\x13\x0c\xb2\xac\xe6\x11\x68\x1d\xbb\xfa\x50\xce\x0a\x57\x92\x78\x07\xfa\x62\xd3\x53\xb6\xb8\x88\x94\x67\xef\x03\xfa\x03\x88\xf0\x2f\xb3\x25\x35\x00\x41\xa5\xb3\x11\xa1\x6b\xfc\xa4\xa3\x56\x85\x8a\x03\x56\x53\xd8\x79\x68\xeb\xa7\x9d\xad\x01\xc2\x48\xee\x45\xe5\xc3\x8d\x1f\x25\x70\x2e\x0e\xf4\xc4\xe3\xc7\xe2\x21\x75\xb5\xf5\xb4\x6d\x53\x99\xec\xd9\x5a\x3b\x8e\xaf\xbc\xcc\xd4\x87\xcb\x19\x95\xb5\x17\xec\xfd\xa7\x69\x9b\x82\x67\xf9\x0e\x83\x0d\x40\xab\x43\xdb\x62\x8c\xfb\x81\x78\x04\xb2\x62\x0a\x0b\x98\x1b\x51\x29\x50\x37\x82\x4b\x26\xba\x2b\x83\x44\x82\x99\x2e\xcc\x50\x5c\xcc\xc4\x56\xaf\x7b\x95\x12\x8f\xc4\xd7\xe2\x91\x51\xca\x45\x04\x0c\xdc\x0b\x94\x55\x85\x84\xe9\x71\xf7\x0e\xe7\x10\x90\x7e\x12\xb9\xea\x10\xa8\xf5\xae\x7c\xca\x7a\x5b\xc1\x88\x12\xf2\xba\x38\x11\x6d\x28\xde\x28\x85\xd9\x34\x17\x75\xbd\x32\xa3\x83\x83\xd9\x64\xb8\x54\x07\x00\xcf\x84\xe9\xf1\xf6\x9d\x1e\xdd\x76\x00\xb2\x7c\x33\xa7\x0b\x9f\x47\x33\xfc\xb7\xd3\xda\x15\xae\x05\xee\xbf\x8f\xd1\x2f\x1c\x5b\x90\x5d\xac\xe8\xe0\x8d\x74\xe1\xbf\xc8\x26\xdf\x46\xe6\x63\x2a\xee\xd0\x6f\xbf\xd9\x55\xd9\xb9\xd7\xc1\x51\xaf\xc9\xff\xe2\x5d\xbe\xd7\x76\x42\x5a\x79\x23\x9f\x6d\xc3\x64\x10\x46\xaf\x93\x3f\x19\xe7\x42\x8b\x12\x89\x9e\x18\x58\x11\x79\x3b\x92\x57\x92\x93\xdf\x5a\x4f\xcc\xb9\xaa\xff\x4a\x29\xb7\x9d\x68\xee\x15\xdf\x91\xa0\x41\xab\xa1\x19\x19\x7c\x6f\x89\x12\x3f\xc5\x80\x6d\x8c\x93\x33\x82\x7d\x12\xcb\x34\x0c\x94\x7e\xb6\xfe\xe9\xfc\x87\x50\x07\x0f\x76\x2c\x3b\x83\xc8\xb0\x80\x7d\x18\x55\xe3\x2f\x30\x9c\xcd\x55\x8d\x59\x32\x1f\x88\xc0\x58\x8c\xaa\xfb\xb7\xb2\xe0\xf2\xb9\x74\x0d\x61\xad\x7a\x26\x7a\x46\xd5\x3e\xe2\x05\x91\xe2\xc1\xed\x88\x3f\x76\x9b\xa2\x77\xe8\x83\x4a\xfa\x92\x3c\x8c\x7b\x0e\x6c\x5f\xcd\x66\x6a\x4a\x0e\x35\xd2\xae\x18\xbd\xea\xc5\xe9\x80\x6e\x65\xe1\x35\xd3\x7c\x7c\xfb\xf7\x68\x25\xfa\x9a\xb5\xb4\x33\x7e\x91\xb4\x14\x3d\x96\xcd\xba\xa8\x1b\x04\x43\x8e\x00\x68\xaa\x6f\x10\x10\x75\x2f\xe9\xd0\x84\xc8\x98\x96\xbe\x23\xe9\xb8\x93\x38\xbd\xcd\x7e\xb6\x55\x64\xdd\x26\x76\x7a\xaa\x4b\x44\x7b\x8c\xb5\x52\x8e\xd9\xa6\xa5\x7e\x13\x4e\x1a\x31\x51\x60\xab\xf4\xe2\x5f\x0c\xc2\x19\x83\x6b\xa0\x63\x83\x07\xb8\x7b\x73\x95\xa5\x5f\x1d\x8a\x7f\x31\xc4\x49\x91\x38\xc6\xb0\x60\x1a\x3d\x80\xda\xcd\xe7\x79\x29\x1b\x58\xa7\x42\x56\x7a\x5d\x66\x03\x30\x44\x92\xd6\x0f\x4f\x8b\xfe\xde\x10\x19\xee\x1b\x32\x6c\x7f\x0e\xd3\x1d\x08\x37\xea\x61\x9f\xb2\x89\xfb\x98\xba\x50\xe0\x6e\xff\x2c\xab\xd0\x45\x94\x4e\x15\x5e\x9d\x46\x02\x2a\x0a\xd9\x78\xa4\xa7\xaf\x87\xca\x31\x52\xba\x40\xf2\xe5\x91\x87\x6c\xd3\x3b\xea\x01\x7e\x18\xae\x98\x46\x29\xc8\x4b\x14\x70\xbd\x3e\xa7\x67\xd1\x3a\xcf\x7d\x82\xeb\x18\xc9\xc1\x8a\xfc\xc9\xb7\x3f\x6b\x18\x53\x27\x32\x58\x7d\x7c\x6e\x98\x5a\xf4\x8e\xd1\x7e\x48\x2e\xec\xae\xc9\x7a\xd6\x28\xdd\x0e\x06\x7e\x55\x6d\xbd\x51\x9c\x14\x68\x0e\x5b\xd5\x4f\x08\x2a\x82\x24\x9a\xa8\xc1\x87\x92\x05\x41\x01\x0e\x78\x0c\xa8\x4a\x4e\xf4\x5e\x9b\xd2\xdf\xbb\xf7\x82\x10\x7f\x4e\x5d\x58\xdc\x12\xd9\xb5\x26\xd6\x66\xd1\xef\x74\xaf\x6f\x1c\xdf\xcd\x81\xb1\x5f\xe8\xa6\xef\xe3\xda\x1b\x45\xfc\x56\xa2\x58\xf0\x30\x75\xad\xc5\x2b\x9f\x7d\xa9\x39\xd7\xde\x37\x3c\x16\x2e\x20\x15\x44\xfc\xe8\x37\x74\x90\xf9\x03\x9a\xd2\xf7\x99\xa3\x13\x3e\xf1\x9e\x33\xa7\xe1\x4d\xab\x13\x4d\x26\x6b\xd9\xf4\x03\xf9\x5d\x8c\xef\xce\x3d\x3b\x0e\x0d\xf9\x9d\xad\xf0\xea\x43\xad\xca\xcc\x34\x82\x4e\x3a\x0c\xed\xe9\x70\x35\xd8\x42\xdc\xf8\xfb\xd9\xdd\x89\xed\xa4\x0b\x03\xd9\x1d\x1e\x69\xbf\xf2\x33\xb0\xf8\x1a\xf4\xb9\x22\xa0\xdf\xd9\xc5\x41\xf7\x1a\xd9\xfb\xdc\xa5\xfa\xcd\x93\xa7\xdf\x1e\xbc\x3d\xdb\x6f\x2e\xd9\x7d\xfb\xea\xe9\xd3\x27\xff\xe6\xd2\xbe\x08\xbf\x88\x21\x01\x56\xb2\x7c\x2f\xec\xb3\xff\x59\xb8\x77\x2f\xdc\x30\x50\xff\x0d\x97\x6c\xe8\xdc\xa0\x6d\x45\xb8\x10\x93\xf3\x97\x67\xd7\x3f\x9e\xff\xe7\xe9\xe5\xd9\xf9\x1b\xcb\xf3\xbf\x1b\x88\xa7\xdf\x0e\xc4\x37\xff\x3e\x10\xdf\x7e\x83\x5e\x14\x57\x72\x32\x20\x2c\xa6\x81\x38\x37\xd3\x81\x78\xb3\x92\x53\x85\x8c\xfb\xea\xf8\xf5\x95\x23\x20\x8e\xc4\x37\xdf\x7c\xe7\x62\x57\x20\xa0\x23\xdd\x26\x56\xce\xd9\x19\xfe\x21\x1e\x3f\x16\xbd\xb4\x16\x38\xba\x6e\xf2\x32\xd3\x1b\xa2\xee\xe2\x2b\x5e\x10\x2e\x2e\xa8\xd7\xe1\xb0\xbd\x9b\x3a\xaf\x1b\x45\x6d\x38\x78\xbe\x88\x74\x23\xa4\xe3\x05\xa0\x58\x7e\x7c\xf0\xe0\xe0\x40\xbc\x55\x93\x9b\xbc\x16\xda\x0a\x06\xf6\xca\x01\x89\x28\xd6\x98\x1d\x74\x5c\xab\x0f\x35\x8c\xfc\x98\xa7\x47\xa0\x34\xc3\xb4\x8f\x2c\x11\x0c\x60\xc5\x70\x85\x4a\x19\x5b\x72\x8c\x01\x18\x58\x1b\x7d\xf1\x2e\xce\x91\x62\xce\x29\xe6\x68\x4a\x95\xc6\xd2\xc1\xef\x0e\x84\xd1\x98\xe0\xb3\xec\xd5\x14\xcb\x30\x64\x33\x72\xe5\x5a\xf5\x09\xf3\x61\xeb\xa4\x13\x01\x2a\xaa\x68\xac\xec\x83\xdc\xbc\xaa\x94\xa9\x35\x28\x87\x11\x73\xf4\xe2\xfc\xbb\xaf\x07\x1e\x44\xd9\xc5\x16\x69\xee\x68\x2c\x5c\x34\x19\xe2\x02\x2a\x60\x54\x1e\xdd\xc9\xd2\x99\x50\x90\x09\x6e\x7d\x7e\x74\x97\x59\x88\x58\xc7\x7c\x6f\x80\xb8\x3a\xad\x87\xe2\x7f\xcb\x95\x2c\x95\x1d\x81\x4c\xe9\x79\x25\x57\x8b\x7c\x6a\x89\x19\xbb\x7c\xcd\x80\xf2\x53\x91\xbc\xd7\xff\xaf\xf5\xb7\x4f\x9e\x3c\xd9\xf3\xd9\x80\x2b\x35\xd5\x55\xa6\x32\x41\xf4\x8a\x2d\x0e\xe3\xda\xa8\xe7\xe4\xaa\xcd\xd6\xe9\x99\x6d\xf1\x7d\x06\xb3\xff\xb0\x63\x67\xfc\xf2\x8b\x48\x87\x33\xfa\xfd\x17\xf1\xa7\xc6\xb3\x3f\x1f\x89\xa7\x4f\xd9\x89\x73\xb9\x52\x95\x84\xa7\xdf\xd8\x81\x28\xd6\x99\x32\xc2\xcf\x5e\x98\x3c\x1c\x69\x6f\x8a\x9f\xe5\x98\x78\x14\x62\x70\x60\x81\xb9\x9c\x1a\xe2\x35\x24\xfd\x2a\xc5\x8d\xda\xae\x20\x81\x11\xe5\xc7\x49\xbc\xee\xc2\xbc\x7b\xc1\x1d\x32\x85\x89\x23\xfa\xe2\x10\x7e\x72\x27\x17\xd4\x9a\x50\xa9\xa3\x23\xd1\x43\x5e\x0f\xba\x4f\xfe\x72\x78\x6b\x2f\x8d\xf6\xe6\x1c\x69\x56\x6c\xb1\x95\xac\x8c\xba\x28\xeb\x7e\x54\xb0\xbf\x37\x10\x4f\x9f\xec\xe1\x30\x04\x11\xf3\xd5\xf1\xe9\xf9\xc9\xf1\xeb\x6b\xe2\x54\xdf\x12\x84\x7e\x78\xfe\xc3\xf1\x6b\x2b\x77\xc2\xc1\x35\x9c\x55\x7a\x79\xba\x90\xd5\xa9\xce\x54\x3f\xaa\x4b\x2b\x9b\xbc\x43\x31\xd7\xb8\xca\xab\x18\xe8\x37\xe8\x1b\x31\xd4\x3c\x24\x69\x85\x24\x7a\x74\x1e\xb3\x5d\x3e\x72\xb0\x6e\xed\xe1\xfc\xa3\x10\xc9\x80\x40\x49\x23\xd1\xd3\xe5\x49\xa8\xdf\x73\x7a\x6f\x07\x78\x94\x16\x70\xc9\x1a\x1f\x30\x2d\x39\x4f\xc9\x36\x12\xef\x7a\xb5\x5e\xf1\x65\x59\x82\x17\x7b\xad\x57\x3f\xaa\xad\x9d\x5e\x43\x3f\x3d\x0b\xa1\xdf\xaf\xa4\xa9\x55\xef\xbd\xf3\xa2\x9e\x46\x24\x3e\xab\x63\x69\x2b\xda\xfa\x16\x97\xb9\x67\xf7\x4e\x8a\x75\x45\xad\xee\xea\x29\xe4\xd6\x6c\xed\xf7\x8f\x6a\xfb\xf3\x8a\xfe\x0e\x69\x38\xdb\xfa\xfd\xa6\x96\xd5\xe7\x4d\xe9\x69\x42\xe4\xce\xbe\x43\xa9\x5f\xd5\x7b\xfa\xce\x6f\xd9\xff\x9f\x01\x17\xf7\xd7\x0e\x00\x52\xb9\x73\x04\xb0\xd8\xaf\x1a\x02\xf7\xa5\x5f\x35\x06\x28\x53\x1f\x88\xab\x4a\x4e\x6f\xbc\x2f\xfc\x46\xf5\x6e\x41\xc0\xad\xc8\x7d\x3f\x13\x32\x70\x53\x82\x10\x84\x13\xc9\x3e\x45\x46\xb1\x90\x06\x44\xac\x1f\x5d\x31\xaf\x34\x4c\xa0\x31\xdd\x47\xa4\x3b\x19\x3d\x61\x2f\x1f\x20\x82\x77\xe6\x33\x9d\x4d\xf5\x72\x29\x4b\xcc\xc6\xec\xd4\xa1\x15\x25\x1e\xf5\x11\xb5\xcf\xf3\x4a\xcd\xf4\x07\x38\x18\x8c\x18\x3b\xaa\x63\x9f\x7b\x4c\x57\x10\x78\x4c\xc4\xc0\x56\xd9\x9f\xae\xeb\x01\x84\x83\x0c\x28\x02\x74\x5f\x02\x04\x40\x3d\x1d\xee\x61\x44\x6d\xbd\x00\x80\xe0\x52\x8b\xe9\x42\x42\x0e\xaa\x0a\xb3\x3f\x19\x55\xf9\x74\xd6\xec\x4c\x71\xfd\x3f\xc5\xcf\x44\x4e\xb4\x5c\xe4\xe6\x2f\x86\xd3\xba\x2a\x7e\x54\x60\xa5\xe2\x8f\x65\x51\xb7\x3c\x5d\xaa\x5a\xfe\xa8\xb6\x7b\xe2\xf1\x63\x8a\x7f\xa1\xda\x08\x25\x68\xff\xb2\xd7\x9b\xbf\xaf\xf3\x5b\x59\x50\x00\xf2\x71\x51\x7f\x5f\x21\xf0\x98\x93\xbf\xd8\xa8\x8a\x87\xad\xad\x79\xfc\xb8\xa5\x35\x11\x52\xda\x55\x25\x4b\x03\x6e\x05\x34\x97\xb5\x5e\x09\x16\x08\x62\x50\x23\x45\xa2\xa4\x3d\x45\x52\x37\x03\x77\xe7\xe2\x09\xc6\xda\xcc\x23\xcd\x74\x1c\x89\x2c\x62\x2b\x46\x69\xca\xe2\x04\xc8\xcd\x37\x2e\x35\x70\x1b\x63\x49\x12\xfb\x86\x43\x70\x98\x32\xcc\xc3\x4e\x4a\x96\x41\xdf\x8b\xce\x39\x06\x50\xb6\x53\xa1\x5d\x7e\x2f\x42\x58\x36\x45\xa2\x01\x38\x50\xbd\xae\x84\x0b\xd6\x13\x13\x65\xea\xfd\xf9\xda\x6e\xb9\xa5\xce\x54\x61\xef\xc3\xe5\x4d\xe4\x68\x96\xcf\x21\x59\x71\x08\x65\xe1\x92\xef\x42\x1a\x31\x51\xf3\x75\xf9\xec\xbe\x93\xd9\x7d\x33\x7e\xd0\xe6\xa5\x96\xee\xa9\x16\xd9\x15\x06\x3f\x49\x4b\xd7\xb5\xd5\x78\x29\x72\x53\x0f\x1c\x33\x5d\xe5\x37\x6a\x7b\x0a\xb7\xa8\xa3\xa3\xf8\xa6\x78\xb8\x73\x4c\xed\x40\xfa\x71\x94\x35\x1f\x4c\x4a\x71\x6a\xa5\x7e\x08\x57\xf7\x7d\xf8\x7f\x38\x7c\xe7\x65\x76\xd7\xe0\xdd\x6b\xe7\xe0\xd1\x32\x0a\x8e\xa6\xc4\xf6\x2c\xa7\x75\x4c\x12\x73\x46\x29\x59\x89\x8b\x17\xe7\x28\xaa\x27\x99\x58\xf8\x85\xde\x9b\xfc\x5b\x26\x65\x0f\xdc\x0e\xf6\x9f\x1e\x36\x1a\xc1\x92\x8b\x43\x33\x30\x75\x26\x7c\xd0\x4d\xa8\x73\x2d\xbc\x51\xdb\x4c\x6f\x4a\xb0\x3a\x6d\x14\x24\x8c\x83\x6c\x61\xf6\x50\x0a\x04\xa6\x00\x0d\x40\xd0\x67\x70\x0b\x54\x1f\x72\x08\xe1\x92\x55\x91\x43\x3c\x1b\xef\x41\xdb\x0a\x7a\xd8\x5c\x41\x69\xb3\xf1\x94\x1e\xc5\xcf\xdb\xb3\xa5\x3b\x39\x80\x77\xf2\xd6\xc7\xee\x01\xa6\x1a\x25\x70\xf4\x78\x53\xc1\x33\xd9\x0e\x44\xd2\xe2\x60\x88\xff\x84\x64\xe6\xdf\x6b\x3d\x2f\x14\xea\x66\xc4\x95\xd6\x85\xb1\x97\x86\xdb\xdc\x5e\xd9\x38\x87\x80\xbb\xf0\x6d\x2e\x85\x14\xa7\x10\x20\x86\x4a\x1d\x4b\xc2\x63\x0c\x8e\x6d\xa1\x71\xb8\x74\xac\xf4\x0a\x71\x5a\x9c\x7f\xc4\x38\x53\xb5\xcc\x8b\xb1\x77\x8c\xa0\xbc\x02\xe0\x64\x64\x84\xbc\x95\x39\x84\x56\xc6\xe9\x09\x5d\x36\x6b\xd2\x22\xd8\x4a\xa5\xae\x07\x2c\x23\xc1\xaa\x90\x08\x62\xdf\xb8\xcd\xc3\xf9\xe8\x6e\xfd\x04\x81\x8c\x7e\xd3\xb2\x60\xd9\x4c\xbb\x42\xd7\xba\xf6\xa5\x03\x2c\x69\x9c\x61\xf6\x02\xfe\xdc\x5e\xda\xc2\x18\x35\xe5\x05\x0c\x65\xa9\x31\xde\x3b\x8e\x4c\xb1\x0f\x9d\xc5\x86\xae\x9f\xae\x64\x72\x39\xed\xd9\xc1\x46\xc5\x11\x14\x48\x42\x4d\xf1\xe1\xd0\x16\x4a\x6d\x68\x1e\x0d\xdd\x09\x89\x00\x27\x4d\x18\x17\x76\x7f\xf1\x51\x34\xb5\xac\xd7\x66\x40\x19\xf8\x86\x14\x1d\x4d\x7c\xa7\x9c\x37\x65\xc2\x30\x46\x6e\x10\x8f\xbb\x95\xf4\xc3\xd6\x94\xae\x0d\x55\xfe\x6f\x94\xdc\xf5\x8a\x39\x12\x3a\x36\x7f\x06\x03\xe4\x40\x1b\x5a\x75\x22\x11\xd2\x24\x9e\x38\xf7\x13\x57\x58\x6c\x0f\x84\x5a\xb0\x71\x8b\x10\xf3\x3f\xe7\x34\x4c\x62\x2f\xa8\x59\x77\x8a\x35\x1f\xe3\x26\x7d\xc6\x49\xd2\x36\x1a\x3b\xa5\xa0\x8f\x6e\x74\x1f\xfa\x62\x9d\x49\x96\xa9\x64\xb7\x72\x8b\xe1\xf2\x5c\xb1\x55\xcb\x57\x6c\x6e\x5c\x1e\x70\xbb\x76\x29\xc4\xd9\xb2\x01\x86\x46\xea\x68\xe8\x5b\x55\x6d\xaa\xbc\xae\x01\x68\x27\x2f\x22\xa5\x9e\x0f\xf7\x23\xd0\x9d\x74\x0e\x3d\x68\x99\x97\x42\x76\x0c\x7f\x98\xaf\x78\xf7\xec\xc4\x54\x69\xc4\xcf\xdc\xe7\x73\xe7\x65\xb6\x17\xc5\xf3\xb5\x2c\x3b\xfb\x1f\xdf\x01\xb8\xa2\x11\xc2\x64\x47\xfc\x9d\x0b\x27\xea\xde\xcf\xde\x14\x1b\x9a\xfa\x89\xc9\x85\x69\x09\xf0\xd6\x45\xd9\xa3\x00\x73\x08\x4e\x23\x87\xb7\x9c\x21\x14\xb1\x17\xdc\x20\x67\x81\x0f\xa0\x48\xdd\x48\xc2\xf2\xc9\x0d\x66\xb9\x20\x18\x7f\x7f\x6c\xe9\x99\xbb\xfb\x74\x9a\xd7\x86\x61\x0b\x00\x8b\x45\x36\xc8\x18\x4a\x12\xd4\x07\x8a\x6f\x38\x12\xe2\xd1\xde\x75\x54\x84\x18\x2d\x56\xd3\x81\xa9\xa7\xa1\x57\xd4\x88\x50\x32\x41\x19\xb9\x1b\xe9\x8e\xc3\x82\x28\x6f\x16\x4f\x8c\x73\x57\x8c\x2d\x98\x58\xac\x15\xaf\x41\x53\x8d\x73\x31\x3e\x41\xb3\x58\xb0\xc3\xcb\xb2\x36\xe3\x5f\x61\x54\x6b\x40\x85\x61\xbe\x7f\x42\x50\xe2\x3a\x4f\x98\xf7\xdc\xc4\xd6\x8b\x40\x2a\x49\x76\x06\x1f\xe4\x0a\xca\x85\xac\xd2\xe4\xd8\x9f\x27\x48\xef\xbe\x38\xde\x7b\x01\x74\x09\x97\x3e\x0e\x47\x40\x2c\xce\x85\x5f\xb4\x0d\x8b\x0f\xca\x93\x5e\xb8\x1a\xc0\x35\x67\xae\x65\x01\xf7\x18\x2d\x96\xf2\x46\x05\x42\x56\xca\xc2\xbc\x26\xcb\xa1\xf8\x41\x6f\xd4\x2d\xa6\x2e\x54\x95\x42\x61\xcb\x49\x4f\x53\x00\xca\xf0\x7a\xa3\x89\xac\x50\x75\x14\x9a\x54\x92\x65\x6a\xe0\x82\x43\x01\x5b\x01\x65\x53\x74\xfb\xf2\x35\x1b\x8d\x0e\x64\x50\xe6\x35\x5c\x59\x03\x97\x10\x70\xba\x9a\xac\x6b\x91\xd7\xe2\x2b\x59\x18\x6d\x8b\xae\x5d\xc6\x0e\x5a\x42\x81\x4c\xad\x61\x8b\x62\x78\x55\xad\x01\x46\xcb\xb5\xc5\x37\x63\xa2\x16\xf2\x36\xc7\x3c\x30\x66\x5a\x69\x14\xb5\x5d\xf2\x28\xa0\xb3\x92\x73\x15\x3a\x19\x9e\x83\x28\x05\xae\xc1\x5e\xee\x16\x5f\x79\xb7\x32\x7b\xf9\x18\xce\x41\xd6\xb6\xbc\xfa\x60\x75\x30\x5d\x54\x7a\x99\xaf\x97\x07\xe0\x7e\x6f\x0e\x50\x60\x7b\x96\x67\x47\xdf\xfe\xdb\xbf\x3d\x7d\xf2\x6d\xdb\x27\xb4\x90\xe0\xea\x13\x82\x03\x51\x2a\x26\x04\x3e\xae\x73\x93\x10\x69\x56\x6a\x3e\xb2\x81\x52\xd0\xcb\xb9\x55\x11\xba\x74\x40\x7f\x81\xdf\x20\xb8\xfd\xc7\x42\x2a\x3c\x3b\x64\xe7\x0b\x16\x82\xbb\x51\x64\xa1\x68\x71\x69\xf7\xf1\x47\x3e\x18\x51\xb4\xa9\x19\xb9\x4b\xb1\xb3\x67\x73\x03\xc9\xe1\x83\x78\x6b\x04\x53\x00\xbb\x4b\x11\x3f\x02\xe1\xd6\x2d\x1d\xe3\x14\x90\x10\x0e\x48\x27\xc4\xd9\xe5\x8b\x21\xeb\xb3\x2d\x6c\x52\xc1\xdc\x49\x89\xee\x18\x9a\x89\xbc\xee\x19\xbe\x82\xfd\x37\x06\x2e\x5d\xa1\xcb\x6e\x1e\x61\xf8\x93\xf6\x35\x90\xca\x6b\x41\xd0\xbd\x7e\x06\x51\xdd\x66\x45\x16\x48\xa8\x96\x2f\x97\x2a\xcb\x65\xad\x8a\xed\x50\x1c\x97\x59\x65\x97\xc0\xa9\x5d\x3e\x2a\x90\x71\xf9\xc9\xe6\x96\x05\xac\x8d\x25\x66\xd7\x9c\x71\x86\x58\x00\x2e\xb1\x9d\x2f\xe4\xf4\xa6\xc8\x4d\x0d\x06\xd9\x30\x89\xd4\xeb\x68\x12\x7f\x38\x7e\x6d\x65\x9c\x74\x82\xee\x3b\xb1\x0e\xca\xc9\x52\xa6\xc1\x4b\x2e\xa6\x07\x07\xe2\xb9\xdd\x6c\x98\x00\x1a\xd9\x17\xd3\x2c\x0e\x08\xc4\x64\x41\xc9\x11\x5b\x3e\xc8\xaf\xb2\x96\x94\xc7\x5f\x84\xc1\x27\x0c\x14\xba\xd0\xe2\x15\x34\x65\x34\x03\x77\xeb\x70\x78\x31\x72\x65\x25\x81\xca\x0e\xb8\x3b\x60\x6a\xc4\x19\x9a\xe9\xaa\xcd\x6d\xe3\x3e\x0a\xd0\xff\x17\xa7\xa3\x17\x88\xa8\x17\x3e\x43\xfb\xbd\x4e\x46\x27\x80\x7f\xea\xd9\x88\xbb\x63\xa3\xe0\xd0\x09\xc8\x8b\x53\x2f\xf3\xf6\x2f\x5e\x9c\xef\xc1\xea\x5e\x53\x66\x4d\xdf\xd0\x5a\xdb\x29\x33\x9a\x50\xa0\xea\x6a\xcb\xee\xe8\x94\xc7\xd4\x92\x51\x19\xdf\xd2\x30\xa6\x35\xef\x30\xa9\x17\x7c\x6b\x9a\x6a\x01\xce\xfa\xc0\x2d\xc0\x7d\x44\xba\xd1\x02\x5c\x64\x49\x29\x3d\x53\x2f\xbd\x41\x08\xa5\xf5\x35\x71\x23\xfb\x36\x90\xe9\xfa\x41\xa7\x0c\x8e\x59\x77\x5a\xf4\x98\x89\xe0\x20\x7e\xf9\x45\x74\x59\xeb\x1f\x3f\xfe\x1c\x65\x60\xd8\xc0\x9c\xdf\x35\x2e\x00\x04\xad\x78\xd8\x7a\x6f\x61\xee\xe3\xe9\x4e\x17\xfe\xf2\xd0\x76\xbf\xbb\x97\xec\x84\xb6\xdc\x51\xc4\x70\xa5\x58\xd9\xa7\x4e\x29\x34\x9d\xae\x2b\xe3\x71\x41\x1d\xef\x1c\x50\x10\xbe\x26\x17\x0e\xd0\x4d\x32\x1d\xa0\x6d\xe1\x50\xbc\x0a\x84\xa2\x90\xe9\x42\x49\x60\x92\x6c\xcd\xb3\x79\x6c\xe5\x77\xf7\x14\xcf\x8e\x21\xb3\xcb\xed\x37\xff\x3e\xf0\x56\xad\xa5\xdc\x82\x65\x2b\x39\xb9\x0d\x83\x7d\xe5\x26\xaa\x40\x8b\x72\xe0\x06\x83\x95\x38\x16\x33\xb5\x21\x6d\x61\x5e\xe4\x75\xae\xcc\xa8\x45\x7e\xd8\x17\x63\x38\xab\xc7\x76\xf9\x8f\x9f\x8c\x87\xe2\xb8\xb2\x83\x75\xa3\xb6\x06\x7c\xaa\xec\x5f\x68\x2a\xbb\xab\x36\x5e\x98\x94\xb1\x5b\x11\x4d\x70\x99\x42\x69\x8c\xda\xdc\x21\x5c\x08\x21\xce\x3f\x8c\x44\x0f\xac\x57\xe2\x6b\x91\x8d\x45\x5e\x8a\x57\xba\xc8\xcd\x02\x3c\x8c\x50\xca\x2c\xb5\x58\xea\x0c\xe3\x00\x82\xdc\x17\x00\x1d\x80\x10\xf0\x32\xb2\xff\x4d\xf2\x92\xa0\x67\xcb\xac\xd3\xb2\xe7\x2f\x85\x9c\x8a\xf3\x64\xc1\xd6\x3f\x7f\x4e\xd6\xc6\xe8\x40\xb6\x9c\x13\x3a\x05\x3a\xe4\xf1\xd3\x27\x4f\xc6\x42\x96\xdb\x8d\xdc\x46\x3d\x7b\xa9\xc5\x38\x72\x8c\x82\x99\x82\x95\xfa\x2b\x06\xd4\x9b\xf5\xa2\x7e\xfa\xe4\xe8\xf0\x65\x84\x2d\x5b\x43\x1c\x99\x1d\xdf\xf1\xe9\x32\xfb\xfa\x74\x3c\xb4\x4d\x6a\x1d\x8a\x01\x0d\x14\x27\x72\x77\xdb\x0f\x98\xc0\xf0\x70\xb7\x61\x94\x0b\x09\x88\x56\x11\xc6\x35\xb5\xe4\xe2\x62\x97\xb6\xfd\x15\xa5\xbf\x92\xa5\x50\x4b\xfd\xb7\x5c\xdc\xe6\x92\xd3\xb9\xd2\x6b\x54\xf8\x4f\xb4\xac\xc0\xfa\xf2\x16\x1c\x7b\xcc\x50\xd8\xfb\x86\xb1\x6f\x25\x6c\xca\x01\x7e\xca\xf6\x3e\xa8\xa4\x39\xa9\x85\x2e\x32\xf6\xa1\x30\x4c\x45\x7e\xa3\xc4\xf8\xbf\xd6\x67\x7f\xfa\xf6\xec\xbf\xd6\x67\xe7\x4f\x8e\xc7\x43\x21\x4e\xc8\x28\x6d\xef\x0d\xe8\x30\xcf\x89\xe5\x46\x7c\x33\x88\xd5\x08\x6e\x72\xbd\x7f\x53\x70\xac\x0b\x1f\x0d\x4e\x5d\x7c\xb0\x92\x8e\x6c\x14\xf7\xce\xf3\xd9\x28\x93\xbe\x39\x9f\x28\xa1\x67\x9c\x18\x1e\xb2\xd4\x98\xf0\x19\xc0\x8e\xe2\x16\x62\xbb\xbc\x13\xc3\x99\x7d\xe6\x82\x03\xfe\x22\x92\x28\xcd\x16\x33\x89\x2d\x1f\x22\x01\x99\xda\xaa\x71\x7d\x68\x25\xd5\xe6\xf3\xd4\xac\xc9\x3e\xf0\x20\xfe\xb7\x9b\x37\xef\xbe\x8a\xef\x70\xa5\x7b\x86\xf8\x51\xa3\x96\xcb\x80\xe8\xb4\xb3\xb4\xc9\xa6\xe7\x5e\xbc\x68\x11\x20\x11\x34\x83\x0b\x65\x03\x31\x01\x2c\x10\x2b\xaf\xe4\x4c\x3a\x86\x04\x0d\x4c\x82\xd5\x91\x0d\x18\xef\xae\x4d\x74\xf5\x16\x45\x7c\x2c\xbd\x36\x55\xf0\xec\x04\xfc\xad\x54\xf0\xe1\x1e\x10\x54\xed\xb1\x1b\xa8\x17\x03\x82\x44\xf2\xc9\xfa\x99\x86\xea\x8d\x11\xfb\x0c\x91\xf6\x30\xce\xd1\xcb\x4f\x16\x54\xab\x20\xe7\x0d\x6c\xb5\x6c\x91\x1e\x48\xc4\x40\x2a\x13\x05\x9c\x30\x1b\x7a\x58\x7a\xdb\x84\x5d\x1a\xf1\x56\xcd\x2b\x9b\xc0\x16\x9d\xab\x19\xb2\xd5\xf4\xe9\x0a\xd8\x58\xa7\xe8\xa4\xba\x5f\xa9\x43\x3c\xa5\x34\x66\xa5\x18\x47\x2e\x81\xde\x2f\x59\xa3\x3a\xf6\x01\xa9\x4d\x3e\x27\x34\xa1\x2d\x22\x21\xe0\x94\x7a\xfb\x3d\x62\xa0\x5a\xa6\xed\xb7\x19\xf3\xeb\x6d\xd1\x45\x7d\xc5\x6c\x93\x79\x49\x97\xef\x81\x78\x23\x67\xb2\xca\x07\xe8\xf0\x8a\x47\x6a\x82\x33\x85\x87\x1e\x48\xa9\xb0\x77\x75\xe9\xe4\xc4\x31\x14\x1f\xa7\x1e\x84\x94\x95\x85\xa0\xef\xc7\xba\x24\xef\x6b\xea\x44\x7c\x75\xcb\x0d\x68\xe3\x7a\x19\x49\x5e\x75\x80\xf6\x44\xa3\x2b\x4f\x49\x40\x58\x56\x5f\xe1\xd9\x11\x9d\xf5\xfe\x88\x72\x37\x65\x5b\x8f\x1c\xc8\x9b\xb8\xfe\x1b\x4c\x4c\x08\x56\x5b\x9f\xff\x0f\x73\x13\x66\x99\xdd\x03\x53\x5d\xd6\x95\xc4\xcb\x1b\xea\x07\xd5\xd4\x8e\xca\xda\x0c\xa2\xc1\x25\xb1\x67\xa2\x4c\x32\xc4\x7e\x41\xe4\x1c\xdb\x9f\x6b\x71\x42\x6e\xc4\xa8\x01\x6e\x1f\x22\x6a\x05\x7d\xbe\x8e\x51\x3a\xfd\x5a\x08\xab\x00\xb0\x4c\x09\x02\x17\xec\xed\x90\xe4\x6c\x99\x63\x8c\xf2\x98\xdd\xfe\xc6\xde\x49\xbc\x5e\xac\x4d\x94\xc3\x00\x13\xf7\x99\x05\xdc\x7b\xd9\x85\xd3\x33\x68\x10\x1e\x2d\x65\xc8\x36\x10\xcf\x24\x4d\x4d\xcb\xa7\x82\x93\x15\xc6\xd5\xa4\x9c\x99\xf0\xd0\xd0\x95\x37\x30\x80\x11\xfb\x1b\x50\x9b\x88\xb1\xe3\x86\x89\x30\x22\x7e\x15\x67\xf7\xfb\xfd\xdd\x6f\x6e\xbc\x1d\xfc\xf6\x87\xd1\xfb\x43\xee\x22\xf9\x33\xe2\x1d\x83\xcb\x38\x4c\x5a\x59\x57\xba\x28\xc8\x72\xa8\xfc\xe5\x12\x61\xe5\x68\x3a\x16\xd2\x38\x06\x0e\xf3\x31\xcb\x27\xaa\x8a\x12\xfa\x87\x2c\x29\xf6\xfd\x6b\x05\x83\xe2\x48\xfb\x52\x68\xc9\xc2\x58\x6c\x40\x47\x81\xdf\xcf\x2d\xb5\x50\x3a\xa2\xcb\x27\x6d\xc1\x5f\x5c\x2c\x57\x45\x62\x18\x85\x56\x05\x6e\x80\xdb\xd7\xe9\x08\xad\x18\x9b\x6d\x4b\xb9\xcc\xa7\x21\x82\x2a\x52\x13\x3a\x52\xd8\x28\xbc\x49\x47\xb4\x50\x90\x6c\xed\x7b\xa3\x69\x61\xcc\x29\x60\xde\x8e\xf6\x95\x87\x0f\x85\xa1\x62\x6f\xfe\xcf\x5a\xad\x43\x34\x4d\x94\xe9\xc1\xbe\x06\x38\xf8\xcb\x19\x65\x49\xaa\xd9\x52\x84\x48\x18\x96\xb5\xd0\xb2\x17\xf2\x66\x04\xe6\x55\x73\xa7\xad\xe0\x5e\x02\x59\x10\x8d\x76\xea\x5a\x24\x44\x89\x4a\x5d\xb2\x6e\x54\x3d\x81\xac\x4e\x43\x4b\x28\xe3\x18\x3d\x8d\xf9\x68\x2e\x42\x14\x35\xad\x47\xfb\xeb\x79\xa5\x97\x2f\xad\x28\x5b\x07\x9b\x2e\xde\x9f\x92\x6a\x6c\x06\x7f\x2e\x21\xd1\x2c\xa9\x89\x03\x24\xe3\x47\x70\xec\x6c\x19\xf5\x10\xac\xd0\x7c\x39\xa4\x81\x0b\xab\x8a\xf2\x82\x44\x81\x0c\xed\x21\xca\xb0\x1c\x61\x51\x38\xcd\x39\xae\x08\xd4\x25\xa3\x2e\x5b\x48\x1a\x12\xe2\xb3\x70\x59\x0e\x5b\xc9\x85\x70\xe0\xa1\x58\x55\x1a\xee\xa1\xf6\x8e\x55\x6c\xd1\x60\x93\x61\xfe\xe1\xc9\xda\xca\x51\xb8\x5f\x86\xe2\x15\xc6\xeb\xce\xf2\x02\x44\x06\x30\x76\xa4\xc1\xce\x0e\xe1\xcd\x89\x77\xb0\x77\x50\xe3\xf8\xca\x3e\xf6\x43\x9f\x0e\xf5\x10\xf6\xb7\x7d\x05\xd3\x71\xef\x31\xdb\x41\x68\xd0\x58\x06\x43\x84\xa1\x82\x06\x86\xfc\x53\xb9\xdb\xf6\x5f\x7e\x2b\x8e\xee\x66\x0e\x7c\x03\xa8\xf2\xef\x76\x6b\x40\x4b\x5e\x63\xfb\xa2\xf5\x6f\x57\x55\xb4\xbb\xb8\xa6\x91\x6f\x2e\x8e\xf6\x19\x9e\x52\x96\xed\x16\xcf\x83\xb6\xd2\xe2\x48\xbc\xc3\xb2\xef\x1b\x9e\x25\xee\x5c\x88\x37\x7a\xed\xc1\x81\x3f\xa6\x19\x5c\xfc\xbe\xbe\x98\xbd\x54\x2a\x53\x19\x4f\xdb\xd4\xda\xa5\x78\x4f\x84\xf4\x92\x10\xe0\xcd\xca\xbb\x65\x02\x23\x97\xe1\x33\x13\x0a\x41\x57\x50\x68\x6d\xe3\x4a\x8d\x2e\x13\x4f\x12\x3b\x99\x91\xdb\xe1\xd1\x37\x7d\x66\xf0\x16\xb0\xbf\xa8\x60\x3b\xbe\x5f\xeb\xf7\xa2\x7a\xef\xf2\xf7\x69\x52\xc0\x5d\xc7\x4f\x5b\xde\x33\xbf\x36\x47\x7c\x99\x0e\x1e\x7c\xd1\xb2\xf2\x46\x6d\xcb\x71\xf0\xe0\x8b\xb6\xd9\x1c\xb5\xce\x31\x82\xe1\xe1\x31\x9c\x09\xc9\x50\x3d\xa7\x68\xa7\x05\x14\x51\xf4\x80\x26\xa8\x1e\x1f\x50\x48\x00\xe8\x0c\xf2\x13\x62\x18\x2d\x9b\xae\x54\x99\xa9\x4a\x55\x43\xf1\x06\x74\x28\xbe\x6a\x2f\x49\xa5\x4b\xda\x56\xcb\x8f\xc0\x0b\xb1\xca\xc4\x4a\x56\xf5\xd6\x12\x2a\xf2\x49\x25\xab\xdc\x4a\xc5\x64\x37\x6b\x69\xd3\x10\xdd\x35\x41\xfc\x24\x6f\xc4\xe3\x57\x17\xa8\x38\x9b\x6b\x21\x6d\x6f\xec\xb7\x2d\x41\x06\xcc\x06\xb7\x0e\x9f\x94\x81\x54\x08\x43\xf1\x56\xf5\x8a\x02\x13\x53\x51\xef\x4c\xbe\xcc\x0b\x59\x01\xd1\x5a\x0b\xbd\xaa\xf7\xad\xf8\xad\x67\x10\x3d\x68\x09\xac\x2d\x83\xdd\xe8\xea\x06\xc3\x00\x48\xff\x93\x69\x61\xb6\xe5\x74\x51\xe9\x52\xaf\x0d\xbc\x1f\xc2\x40\x13\x44\xa2\x09\x72\xcb\x49\x3c\xc8\x1c\x96\x6f\x56\x0e\xc4\x44\xeb\x9b\x1b\xa5\x56\xde\x6a\xe1\x3c\x49\xcb\x3e\x7f\x75\xe8\x0f\xf7\xdc\xbc\x54\xc6\x0a\xcd\x44\x38\x18\x0a\x3c\xe1\x78\x0c\xdb\x3f\x83\x16\x93\x98\x14\x77\x02\x6a\xb1\x2f\xe5\xa5\xc1\x8b\x0b\x1a\x13\xe1\x2b\x03\x6e\xf8\xdc\xc8\xbc\x16\xeb\xb2\xce\x0b\x91\xfb\x6c\x6c\xb3\x75\x41\xb6\xa9\x42\xd5\x21\xd7\x38\x2e\x57\x70\x15\x85\xe4\x33\xa8\x98\xb6\xaf\x80\xa4\xcc\x32\x7e\xb1\x08\xe2\x92\xc4\xad\x0c\x49\xe4\x61\xd4\x99\x7c\xdc\x32\xde\x8d\xce\x3b\x7e\xd6\x32\x8c\xce\x24\x5e\x57\xdb\x58\xee\xbe\x37\x5d\x31\xcb\x4b\xb8\x29\xf9\x71\xfc\x41\x55\xe0\x11\xcd\x86\xc6\xae\xf2\x35\xad\x06\x58\x86\x2e\xf9\xbb\xbd\xd7\xa1\xa1\x3f\x37\x56\x16\xd4\x55\x2d\x4b\x3f\x8e\xb0\xc5\x50\xd3\xc8\x8e\xfe\xa9\x63\x36\x98\x30\x37\x2f\x45\x21\xb7\xaa\x22\xdb\xc4\xc1\x81\xf7\x8e\x98\xe7\xf5\x62\x3d\x01\xc7\x88\x99\x9c\x2a\xdb\x74\x84\xe0\x71\xce\x11\x4f\xff\xf8\xdd\x9f\x98\x78\x0b\x9c\xc0\x89\xed\x28\xab\x6b\xf0\x4f\x6d\xfd\x3a\x79\xef\x75\x2e\xcd\x94\xbf\x86\x43\xe8\xb0\xc1\x49\xbf\x57\xa5\xaa\xf2\xe9\x09\x31\x91\x1d\x42\x7c\x3c\x25\x5c\x76\xbf\x8e\xb7\x80\x3f\x19\x5a\x37\x64\x52\x38\x96\xa5\x03\x97\xfe\x57\x27\x4c\x74\x35\x90\x39\xe8\xa6\xd8\x0f\x0b\x59\x6f\xe6\xa0\x64\xb1\x17\x75\x73\xb0\x51\x93\x7d\xb9\x5a\x99\x03\xda\x5d\xfb\x76\x2d\x1f\x2c\xd7\x45\x9d\xaf\xe4\x5c\x1d\xd4\x0b\x85\xfa\x95\x7d\xca\x60\x38\x5c\xd4\xcb\xe2\x0f\xf8\xc8\x0a\x3d\xfb\xb2\xae\xab\x7d\xb3\x5e\x2e\x65\xb5\xf5\x17\x57\xe3\x30\x1f\xe1\x22\xc7\x03\x50\xa7\xba\xd0\x55\x80\x21\xc3\xa0\x3d\xfe\xab\xce\x97\xec\x49\xcf\x3d\xda\x2f\xf4\x54\x16\xbd\xf0\x46\x2d\x65\x5e\x84\x9f\x4b\x5d\xd6\x8b\xf0\xb3\x5c\x2f\x27\x8a\x7d\x67\x25\x8d\xd9\xe8\x2a\x0b\x4f\x2a\x7b\xcf\x0b\x3f\x8d\x92\xd5\x94\x11\xa8\x55\xc1\x7f\x7c\xa8\xd9\xaf\xa8\x85\xeb\x8a\x15\xdc\x28\x75\x83\xbf\x92\x6c\x7a\x26\x68\x3f\x71\x1c\xfb\x76\x3c\x83\xc2\xb4\xd4\x99\x72\x49\x90\x0b\xb5\x04\x77\xd3\x42\x2d\x87\xfe\x79\xfa\x60\x58\xeb\x9f\xf4\x46\x55\xa7\xd2\xa8\x7e\x70\xa5\x0c\x74\x00\xe1\x11\xfc\x64\x92\xcb\xfb\xc3\x87\x2d\xb3\xf3\x0e\x88\xdb\x09\x7d\x1f\x79\xe7\xc6\xf4\xec\x38\xc8\x4a\xc9\x94\xa4\x63\x58\x1f\x1f\x3c\x48\x23\x10\x82\x4e\xf0\x87\xab\x17\x3f\x41\x3f\xc1\x00\x0e\x18\x83\xa4\xdc\x09\xc6\x12\xe0\xb4\xf6\x35\xdd\xda\x6c\xf1\x07\x3e\xa3\xd7\xf9\x4f\xe7\x2f\xce\x5f\x5e\x5d\xbf\xc4\x78\xea\xa7\x78\x95\xbc\x3a\xff\x0f\xff\xe8\x5b\x7c\x74\x7a\xf9\x82\x17\xfc\x13\x3e\x3d\xbb\x3c\xfd\x99\x3f\xfe\x2e\x79\xfc\xfc\xf5\xf1\xf7\x11\xfd\xa7\x2d\xc9\x4f\x79\x52\x47\x70\x46\xf0\x81\x90\x91\xab\x06\x5c\x73\xa6\x53\x7b\xb3\x23\x77\x0c\x54\x53\x4d\x75\x89\xe0\x95\xd3\x1c\xf2\x68\xfa\x5a\x67\x97\x2f\xec\xe1\xdf\x99\x58\xe7\xd3\x7c\x43\xd2\x74\x36\xdd\xc9\x6b\xe6\xaa\x66\x25\xdb\xe3\x17\xda\xd2\x7f\xb8\x9c\x20\x49\x74\xa3\xa9\xa6\x2e\x01\xe9\x2f\xbf\x04\x00\x0d\x60\xe6\x2f\x7d\x9e\x13\x48\x8c\xba\x36\xca\xe7\x45\x75\x02\xda\x1f\xfe\xf5\xbb\x3f\x7e\xeb\x42\x22\x1c\x18\x29\x73\xf8\xfc\xd9\x28\x22\xef\xf1\xda\xe3\x2b\x47\x57\x71\xae\xdb\x47\x4d\x6e\xb0\xc9\x3b\xe1\xb0\x44\x34\x02\x3b\x48\x46\xf4\xed\x45\x6f\x18\xd6\x56\x6e\xc4\xb7\x7b\xe4\x65\x92\x72\x55\xcc\xc8\xb4\xb4\x15\x2c\x67\xfd\x9b\x39\x40\x92\xd7\x01\x7e\x12\xd8\x26\x8b\x69\xc3\xc6\xfa\xdd\x60\x77\x57\xf8\xd6\x33\xf7\x1e\x33\xd9\xdb\x96\x88\x91\xbf\x53\xd1\x11\xb5\x36\xea\x07\x69\x9e\x2b\x59\xaf\x2b\x75\x1f\x24\x12\x1c\xb1\xa8\x1a\x07\x1b\x49\xf4\x47\x0c\xf7\x21\x79\x35\x5c\x84\xfa\x2e\x86\xd5\xab\x50\x00\x3e\x1e\xf8\x81\x5d\xdc\xa5\xda\x28\xe6\xa7\x25\x8d\x58\x61\xae\x2e\x7b\x90\x97\x99\xac\xb2\x96\x11\xcd\xf4\x72\x08\x5a\x64\x76\x58\xfd\x21\xd3\xcb\xfd\x4c\x2f\xe3\x96\xec\x2f\xa4\x99\x61\x4b\x18\x8a\x4a\x77\x73\xfb\xbd\xde\x40\xf4\x7a\x18\x87\xe6\xd3\x8b\x3a\x93\x85\x87\xec\x97\xcc\x71\xc8\xb3\x4a\x17\xd6\xe4\xa2\x10\x94\x1b\x6b\xa1\xd8\x60\xd3\xe6\x7d\x79\x79\x75\x3e\x42\x2d\x08\xdc\x10\x4a\x5d\xa3\xe8\xee\x6d\xc0\x70\x37\x2c\x75\xb9\x3f\xc7\x33\xdc\x3b\xa8\xd0\x3d\x66\x8c\x7a\xc8\x31\x04\x5d\x8d\xc1\x3b\x67\x3c\x10\xe3\x42\xcb\xcc\xfe\x0b\xba\x95\x31\x5a\x21\xc6\x18\xfa\xec\xcd\x06\x27\xba\xb2\x03\x8e\xdc\xe9\x85\xce\x54\x55\xe6\xff\xa8\xba\x1c\xd7\xe0\xbb\x96\xc3\xbf\x59\xcf\x66\xf9\x07\x42\x7c\x2e\x01\xdb\x50\x0d\xe7\x43\xf1\x68\x5a\xe4\xd3\x9b\x47\x91\xc3\xda\x33\x9f\x90\x80\x22\xe4\x71\xf4\xf0\x72\xa5\xfc\x43\x88\xc2\x8f\x46\x71\xd8\x1a\xf1\xc8\xd2\x1a\xa8\x96\xa1\x6f\x64\x82\x16\xff\xab\xc8\xa7\xaa\x34\x2a\x74\x4f\x7c\x3b\x7c\x32\x7c\xb2\xaa\x94\xe8\xa3\x8b\xb5\x38\x59\xe7\x45\xb6\x27\x7e\x11\x2f\x2e\xae\xd2\x90\x4a\xe8\xa4\xc7\xa5\xee\x27\x63\x30\x70\x1d\x60\x8a\x89\x3b\x50\x56\x7e\xf9\xc5\x77\xfa\xf1\x63\xf1\xb0\xdf\x73\x70\x78\x2e\x0f\x63\x8c\xfa\x93\x1c\x9f\x2c\x58\x8f\x9b\x00\x49\x1e\xe8\xe9\xb2\x27\xbe\x4e\x27\xea\xd0\xe3\xc2\xf2\xc4\x95\xa1\x1e\xfb\x9c\x17\x0e\x1e\xb2\xc2\x51\xe6\x18\x62\xc2\x8c\x1b\x20\xf6\xb5\x93\x55\x7a\x59\x7e\xeb\x10\x58\x9d\x1c\x68\x54\x7d\x5c\xd7\x55\x3e\x59\xd7\x2a\x8c\xe0\x40\xf4\x48\x5d\xe3\xca\xc7\x0d\x74\x49\x61\x90\xc8\x3b\x5f\xef\x7d\x0b\x8a\xed\xc7\xb6\x76\xdb\xf1\x8d\x79\x98\x8b\xcc\x61\x8b\x18\x68\x6d\x16\x4a\x15\xbd\x48\x57\x8e\x31\x84\x80\x20\x5a\x16\x5b\xa7\x82\xa8\x95\x09\xb9\x61\xd0\x71\x52\x89\x31\x54\xf7\xa8\x47\x08\x2a\x34\x6c\xe9\xd1\x7d\xd8\x0e\x1a\x62\x86\xd8\xa2\x81\xe8\x7d\x3b\x7c\xd2\xdb\x4b\x05\x26\x46\x36\x46\xac\xcc\x0d\xec\x2e\x39\x29\x54\x22\x35\x12\xae\xbd\x97\xdd\x0e\xdb\xa5\x49\x2f\x34\x32\x93\x2d\x17\x2c\xdb\x65\x4a\x2e\x42\x02\x8c\x50\xed\x1d\x17\x21\x9f\xcd\x44\x7f\x00\x7f\xc5\xf0\xb8\x92\x59\xae\x7b\x7b\xcd\x54\xb2\x95\x9c\xde\xa8\x0a\x84\xc9\x48\xb7\x00\xf2\xc8\x35\x88\x82\x54\x26\xae\x9b\xa9\x5a\x4e\x17\xcd\xea\xcd\x7a\x5d\x99\x9a\x21\x2f\x93\xd7\x0d\x07\x0a\x76\x94\x6e\x29\x67\x53\xaf\xe7\xf5\xf4\xa1\x00\x87\x1a\x66\xc2\x2d\xf9\x77\xfa\xf9\x80\x0a\x61\x2f\x21\x41\x68\x1e\x8c\x91\xca\x20\x0f\x7b\xb5\x56\x00\x06\x0c\x1b\xbd\xd7\x12\x31\xc4\xea\xc5\xdf\x8b\x1b\xc1\x3b\x57\xdb\x8e\x43\xf7\x2e\xcb\xae\xce\x3d\xcf\x55\x91\x01\x5e\x71\xd2\x62\xdb\x2a\x6a\x20\x34\x0c\x93\xfb\x1e\xfa\x78\x55\x33\xad\xf2\x15\x42\x9f\x92\xe6\x70\xae\x6a\x86\xfe\x7e\xe6\x4b\xf4\xb1\xb3\x0c\x7e\x93\xa5\x65\x08\x8d\xd8\xf3\x09\x21\xe8\x00\xfd\xab\x1f\x7c\xf1\x35\x74\xfc\x5d\x28\xfc\xde\x49\x8c\xf9\x0c\xd2\x10\xe8\x52\x61\x4e\x3d\xf2\xab\x77\x79\x07\x24\x8d\x9c\xae\xbc\x75\x1e\x74\x6a\x13\x99\x17\x24\x97\x94\x19\x69\x11\x61\xb8\xa8\x3c\x9c\xc9\xe8\xe1\xa5\x11\x97\xdd\x6e\x3b\x70\x04\x9e\x91\x01\xd0\x90\x5b\x32\xc6\x9c\xf4\x8c\x98\x60\x1a\xbf\x1a\xbd\xd7\x16\xb2\xca\xc4\x4c\xe6\x05\x8a\x1e\x07\x07\xa2\x5f\x82\x1e\x01\x2d\x22\xaa\xaa\xa5\x95\x17\x94\xa9\xe9\x8a\x63\x56\xdb\xcb\x92\x80\xae\xe8\xea\x63\xdb\x86\xcd\xde\x63\x97\xad\x14\x66\x9f\x0d\xa1\xdb\x6c\x10\x27\xec\xc6\xdf\x4e\x0c\xc2\xf9\x07\x9c\xaa\xd6\x72\xa6\x51\xae\x4d\xbf\xfe\xa0\x2b\x73\x0a\xe4\xf1\x67\x13\xea\x52\x11\xa8\x72\xbd\x54\x84\x2d\xce\xbe\x16\x1e\x23\x2e\x4e\x17\x08\xf9\x5c\xb5\x66\x61\x62\xa1\xcd\xbc\xa3\x01\xd8\xd0\xa9\xbf\x19\x94\x79\xa0\x92\xe4\x3e\x68\x5b\x71\x11\xc4\x7d\x3c\x4a\x1c\x3d\x11\x29\x31\x55\x7b\x58\xc7\xb5\x67\x3c\xff\x74\x3d\x81\x2f\xec\xec\x0e\x6f\x4a\xda\x83\x46\xed\x4f\xeb\x86\x23\x54\xeb\x95\x0b\x4f\x6a\x6f\x4a\x0b\x53\x0d\x03\x01\x79\x2d\x9b\xdb\xd1\xf7\x9f\xc3\xa9\xb5\x71\x6c\x78\xc8\x58\x91\x5d\xd6\xe9\x09\xd0\xb1\xee\xec\x09\x7d\x79\x76\x39\x12\x97\x98\x39\xaa\x67\xc4\xdf\xd6\xa6\x16\x68\x97\xdc\x28\xc0\x31\x5c\xea\x5b\x45\xe6\x5e\x4d\xc7\xc0\xa6\x92\xab\x95\xaa\x40\x9d\xd7\x75\x36\xb4\x33\xcb\xb8\xe9\xa8\x0a\x85\x42\x17\x33\x4c\x42\x97\x25\x3d\x69\x3b\x1f\x9a\xc2\x5b\x58\x19\x69\xcf\x0f\x3d\x5b\xab\x99\xf7\xb3\x2b\xef\x70\x47\x56\x3a\x2f\x89\xeb\xac\x4b\x34\x9e\x52\x8c\x04\x40\x93\x20\x92\xb4\x9c\x4b\xc0\xd6\x2b\x0a\x7b\x67\x98\x2a\xb0\x1f\x43\x1b\x89\xdc\x2e\x15\x8d\x6d\x65\x21\x8d\x5f\x4b\x54\x65\xe8\xd6\x70\xc8\xfb\x5f\xaa\x0f\xbe\x54\xfb\x71\xea\xce\xce\x50\xd2\x72\x19\x4f\xdd\xdf\xd3\xe9\x13\x6e\xa1\x87\xf2\x31\x18\x78\x68\x67\x8b\x26\x29\x86\xb4\x03\xd0\x66\xd0\x29\x2e\x50\x97\xf7\x39\xd8\x5f\x50\xb5\x03\xf0\x0b\xde\x7d\x06\xca\x17\xd1\xc4\x1f\xf6\xf6\x44\x7f\x3f\xd7\xd3\xb5\x43\xf5\xe2\x68\x76\x0d\xf8\x2f\x8f\xf7\xf5\x46\x51\x76\x6c\xa2\x19\x50\xbf\xfc\xb2\x45\x49\xfd\xb8\xcc\x8e\xbd\xcb\x1e\xcb\xa0\x08\x38\xed\x89\xab\x4c\xdd\x86\x97\xd0\xc0\xbf\xfe\xf2\x69\xab\xb3\xe1\x97\x4f\x87\x38\xdc\x03\xd1\x4d\x3a\xa0\x93\x93\x84\xda\xc3\x3a\x3d\xda\x00\xcf\x0b\x39\xe7\x18\x3b\xe0\x96\x21\xd1\x00\xe7\x2d\x31\x4e\x4f\x6f\x85\xee\x1d\xe6\xf0\x5f\xe1\xad\xc8\x62\xc9\x2e\xce\x85\x59\xe4\xcb\x00\x69\x2c\x21\x01\xc5\xb9\xbf\x19\x05\xd7\x95\xe8\x0d\xa5\x38\x26\x5b\xb1\xcb\xcf\x7e\x7e\x7a\x75\x71\xf9\x72\xe4\x9c\x26\xdc\x65\xde\x7b\x18\xb2\xcb\x28\xba\x8b\xfe\x6c\xa2\x49\xdb\xa9\x1b\xbe\xbf\x4e\xb8\x29\xec\x83\x98\x8e\xfa\x02\x10\x13\xda\xd4\xc5\x9e\x6c\x10\xec\x67\x79\x61\xe7\x8e\x73\xcb\xa5\x2c\xd7\xb2\x70\xc3\xcc\x1b\xdf\xaa\x42\x74\x6b\xec\x8e\xd5\xda\x18\xdb\x64\x7d\xed\xd0\x56\xee\x1d\x06\xd7\x5d\x72\xe2\xb2\x12\x56\x9c\x2e\xd4\xed\xfd\x81\xd8\xa8\x5e\x86\xe7\xcb\x24\x2f\x33\x0c\x12\xc6\x68\x00\x89\xa6\x59\x24\x86\x16\x46\x17\x5a\x5d\x66\x68\x28\xcb\x6b\x31\xd7\x10\x7d\xb4\x9e\x2f\xd0\x16\xc3\xc3\xfc\xce\x97\xb9\x15\x16\x87\xe2\x4d\x8e\x47\xd9\x03\x1e\xb6\x09\x66\x45\x1c\xbe\x62\x2b\x0a\x50\x10\xf8\x6b\x27\xfb\x12\x3a\x69\xb9\x3c\xee\xb4\x03\x28\x47\xe9\xc1\x81\xed\x18\xe2\xda\x2e\x94\x90\x13\x83\x2e\xe7\x0e\x97\x16\x89\xa3\x72\x0d\x8b\x3b\x23\x11\x66\x23\xc2\x3c\xf1\x5b\x81\xa7\x50\x29\x74\x95\x61\x42\x1d\x55\x1a\x7b\xa7\x86\x93\xc6\x0e\x84\xf3\x83\xb3\xeb\xb8\x32\xa2\x5a\x97\xce\xb3\x19\x8c\xa7\xa0\xa3\x57\x1f\x6a\x51\x29\xb4\xc5\x8b\x3e\x82\xc0\x7a\xa3\x7b\xa8\x2b\x6b\x2b\x77\xa0\x81\x56\x96\x53\xd8\xc5\x48\x8c\xb4\x01\x86\x45\x35\x84\x20\x08\xf2\xd7\x85\xb5\xb9\x37\x14\x6f\x09\x1d\x09\xe5\xb3\x60\x02\x64\xb1\x7b\x68\x85\x44\xb1\x1f\xb4\x6e\xb8\x06\xc0\x70\x6c\x6b\xfc\xcd\x27\x52\xc9\x6b\x97\x9c\xd4\xa7\x84\x25\x3c\x42\x77\xe0\xaa\x40\x12\x61\x0b\xc9\xe5\x20\x73\x30\xac\x74\xa5\xa8\xd4\x2d\x86\x1d\xd1\xc0\xd0\x22\xf2\xf1\xed\x07\x07\x61\x20\xac\x1c\x53\xad\x4b\xcc\x02\x75\x6f\xb3\xe8\xbf\x3f\xf9\x93\x9d\xcf\xc4\xa4\x5e\xad\x1d\x5a\xc5\x09\x5a\xc1\x1d\xb7\x8b\xbc\x6e\xe2\x42\x3c\xdf\x05\x2d\x2b\x54\x50\x30\x56\x49\xab\x0b\x9e\x83\x43\x0c\xba\x89\x35\xef\xf6\x76\x93\x5e\xcc\xe0\x20\x77\x32\x53\xf0\xd1\x4c\x4d\x08\x2f\x11\xe0\x9a\xfe\xb2\x72\x84\x73\xa0\xfa\xf2\x29\xaf\xe6\x64\x8a\x56\x91\x2c\x90\x4a\xf5\x68\x71\xa2\xf9\x46\x3a\x96\x2b\xff\xfa\xb9\xae\x38\xd7\xe9\x72\x31\x0d\x82\x5f\x7b\xec\x26\x9e\x69\x77\x37\xa2\xeb\x58\xc8\x63\xbf\xf3\x03\x72\xab\x08\xce\xaf\x5c\xcf\x44\x52\xd0\x7d\xf5\xfc\x10\x87\xf5\x9d\x98\x16\x32\x5f\xa2\xb3\x32\x29\xb8\xfc\x66\xf2\x2b\xbf\x86\x9b\x2c\x14\xaa\xab\x7c\x3e\x57\x95\x65\x70\xe0\xcd\x82\x7c\xcb\xde\x0a\x20\x34\x5a\x7d\xa8\x5d\x8c\x79\x3e\x2f\x21\x3f\x0e\xec\xda\x38\x76\xb2\xab\x07\x0d\xbd\xab\xb7\x4f\x02\x48\x75\x2b\xec\x39\xc7\xa8\x1e\x26\xe0\xd4\xdf\x45\x60\x96\x7d\x3a\xc6\xff\x7c\xf4\xdd\x9e\x00\x18\x1e\x83\x42\x27\xc7\x46\xe6\xde\xbd\x1e\x0a\x75\x25\x8d\x51\xd9\x7e\x5e\x3a\x46\x04\xae\xde\x65\x06\xca\x81\xca\x05\x93\xe3\x3e\xf7\x01\x58\xc1\x89\x14\xf6\x73\x96\x83\xbf\xc1\x3a\x37\x0b\x0c\x6d\x73\xb0\xa5\x95\x5e\x5a\x72\x58\x9b\x74\x0b\x96\x0f\xfd\xef\x37\x89\x21\xce\xd8\x26\xbf\x25\x2e\xfd\x5c\x57\x6c\x4b\xf9\xd4\x7e\xe9\xd2\x4c\x85\x94\xe0\x76\xd7\x26\xa4\xc4\x2b\x33\x2a\x31\x44\xe6\x8c\xdb\xa1\xa7\xcb\x78\xbc\x7a\x03\x5a\xb2\x4e\x1b\x80\xcd\xea\x1e\xfe\xd7\xca\xde\xd3\x0c\x77\xbc\x25\x3d\x38\x8b\xe0\xf6\xfe\x3c\xfb\x78\x37\xc8\xdc\xf0\x83\xcd\x03\x31\xc8\x84\xfa\x90\x9b\xda\x34\x86\x4a\xaf\x3a\x46\x8a\xdd\xd5\xa2\x0e\xb6\xfb\x12\xc6\x63\x80\x17\xe3\x4f\x1e\x83\xe6\x34\x38\x87\xc2\x6e\x49\xb1\x63\xdc\x7e\x80\x2f\x00\xca\x5d\xcb\x82\x1d\x08\xa3\x4a\xca\x48\x18\x8b\x94\x22\x9f\xb9\x60\x0f\xd2\x88\xa1\x2d\x05\x1b\xe0\xf5\xfb\x0b\x69\x68\x09\xa6\xc0\xb7\x6d\x5d\x6b\x0a\x72\x69\x78\x9f\x6b\x24\x48\x90\xa0\x5b\x42\x3d\x62\xfb\x60\x93\x2a\xa0\xe5\xc0\x68\x8c\x93\x67\xec\xf7\x93\x32\x9b\xdc\x1e\xfb\x83\xa7\xda\x73\x5d\xb1\x08\x0a\x5d\x6c\x67\x79\x51\xb4\xf2\xfc\x4f\xe0\xfd\x78\x95\x8b\xc0\xaa\x2c\xbf\x1d\xa4\x13\x87\x31\x41\x98\x4e\xcc\xc4\x48\xf7\xa8\x5b\xb4\xff\xcc\xe7\x5b\x9f\x7b\x9e\xc1\x7b\x80\x71\x1a\xbc\xad\x10\x25\xdf\x90\x7e\x26\xc3\xb0\xa1\xa9\x2e\x6f\x55\x99\xc3\x16\x72\xf8\xc7\xb9\x2e\xf1\xc3\xde\x4b\x6d\xb5\x52\x12\xa1\x50\x80\x5c\x5e\x82\x68\x42\xeb\xa3\x52\x4b\x99\x97\xe0\xc9\x25\x8d\x32\xc4\xda\xa7\x94\x65\x45\x1b\xc5\x9b\x35\xd3\xd5\x46\x12\xc8\x8a\x5b\x75\x6c\xc9\xb1\xc5\xc5\xc6\x84\x22\x1a\x43\x6c\x2b\x4a\x65\x12\x43\x7e\xa6\x91\x98\xe4\x24\xa4\x88\xae\x8f\x4e\xf0\xd4\x91\x83\xfc\xef\x37\xd4\xda\x4a\xa1\xa6\x52\x48\x61\x50\x47\x0b\x11\x96\xa8\x47\x1f\x23\x93\x26\x2f\x37\x47\x4b\xaf\x93\x5b\x1c\xea\x2d\xc0\x21\x1e\x30\x22\x92\x38\x1f\x3a\xeb\x70\x44\x88\x87\x13\x2d\x47\x92\xb3\xa4\xfe\x1e\x4b\xf5\x2e\x45\x69\x2f\xb7\x20\x68\xdb\x59\x83\xf1\x2d\x0a\x7b\xc2\xc2\xed\xc3\x8a\xa4\xd2\x28\x0c\x46\x00\x52\xcb\x1c\x02\xc3\xa5\x98\x14\x6b\x77\x71\x32\x7a\xa9\x16\x7a\x33\xf4\x2a\xbe\x2e\xf6\x77\x48\x25\x3e\xe9\x2c\x49\xb0\x0b\x5b\x17\x3c\xe8\x37\xdc\x7a\xbf\xab\x05\x1f\x09\x72\x12\x79\xdb\x9f\x28\x58\xee\xbb\x61\xb7\x38\x76\xcf\x1d\x7a\x8f\x9d\x99\xaa\x4c\x40\x1b\xde\x01\x21\xfc\xf3\x6a\xe7\x6b\x50\xca\xb0\x3d\x7e\x49\xd0\xe9\xf1\x56\x73\xcc\x99\x79\x07\xe5\xa4\xba\x74\x02\x8b\xf7\xa6\x2c\x7b\xde\x8d\x72\xa1\x8a\xd5\x6c\x5d\xc0\x6a\x5d\xc3\xd6\x83\x2a\x60\x95\x49\x4e\x94\x90\x00\x23\x5a\x73\xdf\x7d\xf7\x2f\x6e\x23\xd7\xf9\x52\x0d\x1c\x36\xae\x20\x04\xdf\xf5\x4a\xc8\x4a\xd9\xfd\xe6\x2f\x7c\x43\x98\x0e\x2f\xee\x61\x16\x0e\xe1\xee\x93\x9c\x71\x91\x6c\x34\xcb\xab\x98\x6d\x51\xa0\x94\xcb\xe9\x39\xa6\x6d\x86\xae\x50\x7e\x37\x80\x3a\x1d\xda\x81\x0c\x10\xcc\xad\xd4\xbc\x01\x03\xf0\x80\x56\x0e\xc5\xa9\xbb\x9c\x62\xab\xd7\x06\xae\xaf\x8e\x1a\xb8\xf1\xe7\x48\x6e\xca\x4a\x42\x5f\x0b\xfb\x72\x8d\x61\x5a\xc1\x73\xc3\x5d\xa7\xa1\xf9\x8e\xce\x8d\xda\x9a\xba\xd2\x37\xb0\xca\x41\x48\x83\x58\x48\x00\x14\x11\x95\x5a\x29\x59\x8b\x7e\x5e\xf7\x10\x71\x43\x8a\x22\xaf\xeb\x42\x59\xa6\x2b\xb7\xe0\xd8\x9e\xcf\x17\x9e\x18\xbb\x00\x1b\x35\xd5\x84\x99\x0c\xe4\xf7\x86\xe2\x12\xb8\x1e\x0e\x1b\x66\x18\x35\xa2\xaf\x86\xf3\xe1\x00\x81\x4d\xf6\x84\x51\x6a\xc9\xbc\x89\xa1\xf9\xe9\xc2\x2a\xc1\x61\xca\x01\x06\x04\x30\xb9\x7b\x1d\xa1\x77\xde\x3e\xc0\xaf\xe3\x0e\x9d\x94\x2d\x92\xaa\xa4\x5c\x30\xdd\x22\xa1\x01\x88\x3e\xaa\x56\xd3\xda\xcb\xb9\x96\xc5\x93\xa9\x18\x66\x0f\x0c\xc4\x38\x2c\x86\x3c\x7f\xc0\x28\x0f\x30\x4c\x72\xba\x80\xeb\xba\x11\x72\x5a\x69\x63\xe0\xa0\x0a\x01\xad\x1b\xcb\x42\x99\x67\x4c\x9a\x4b\x06\xf0\x0f\xc0\xaf\x79\x6c\x19\xe7\x18\x6d\xf6\x70\x67\xfe\xfd\x4c\xe2\x89\x9e\x2c\xb2\x8b\x27\xef\x3a\x8d\xe3\xd1\xad\x34\x0c\xf8\xe7\x5e\x4a\x41\xdf\x9c\xdc\x49\xef\xbc\xa7\xdf\x7d\x5f\x06\x06\x7d\xf9\x5b\x5c\x9b\x51\xf3\xdd\xc9\x77\xdb\x6f\xd5\x9f\xd1\x03\x5c\xe7\x21\x1c\x06\xbe\x6b\x8f\x31\xa7\x13\xf7\xb6\x1c\x6f\x79\x02\x21\x0e\x15\xdb\x96\x87\xeb\xe9\x54\x9a\x5c\xa3\x27\xbd\x15\xdc\x87\xe2\xed\x62\xfb\xcc\xb9\x01\x80\x40\x1f\x43\x74\x36\x4d\x5a\x68\xbd\xb2\x8b\x1f\xd4\x84\x67\x97\x2f\x30\x8d\x2d\x59\xad\x48\xd5\x9d\x97\xc2\xa8\x95\xac\xec\xdf\xab\x42\x4e\x41\xbe\x00\x47\x6a\x0c\xdf\x83\x26\xc5\xa6\x2e\xa7\xbe\x8d\x9f\x06\x5f\x1f\xe3\x0a\xe1\x5f\x43\xe6\x2d\xef\x6a\xc2\xe2\x04\xb9\x1d\xdd\xa5\xbb\x2c\xc2\x0e\x58\xcb\x11\x00\xd4\xbb\x7c\x5e\x32\xe9\x4f\x3a\x57\x20\x17\x07\xee\xfc\xe4\xe8\x3e\x52\x82\x34\xd3\x70\xbc\x20\xdb\x7f\x70\x7a\xf0\x66\xf0\x39\x77\x2f\xf2\xf7\x0a\xdb\xd8\xc8\x2c\x0a\x65\x4d\x4b\x59\x6e\xbb\xe5\x6c\x90\x47\x83\xa3\x32\xda\x10\x4c\xc1\x69\x74\xa3\x02\xb9\xb1\x74\x1e\xab\x26\x8a\x0b\xa6\x68\x78\x60\x52\x10\x7f\xea\x14\x98\x6d\x70\x00\xb5\x90\x70\x3c\xa3\x24\x0f\x56\x3d\x0f\xf5\x6e\xf9\xff\x57\x8e\x34\xc8\xc1\x48\xa8\x67\xbc\xa7\x02\x6a\x3b\x29\xb1\xb2\x14\x33\xbb\xbd\x95\xf7\xe6\x0b\xea\x15\xaf\x43\x95\x95\x1a\x3d\x00\xc4\x21\x3c\x7e\xfa\x46\x29\x31\x6e\x3a\xa0\x8f\xf7\xb0\x94\xf3\xe9\xc6\x5f\x78\x04\x85\xbc\xa4\x61\xbb\xdf\x23\xf6\xfc\xcb\xa7\x10\x7d\x7e\xdd\xaa\x00\x1a\xb5\xeb\x85\x7e\xdf\x78\xf5\x86\xea\x31\x90\x10\xcf\xee\xd6\x43\x8a\x11\x77\x61\x46\x72\x31\x63\x5c\x97\xd3\x01\xbf\x6d\xda\x07\x01\xcc\xb7\xd5\xb8\xd3\xa2\xbf\x14\x4d\xaa\x64\x3d\xee\x50\x59\x36\xc0\xa2\x5b\x02\x0c\x5a\xbf\x83\x65\x5b\xe6\x81\xa3\xf4\xdc\xa7\x31\xcd\xf3\xc0\x63\x42\xc6\x81\xa4\x9f\x40\x2e\x92\xff\x03\xf6\x4f\x32\xbc\xe2\xe8\xee\xeb\x7d\x82\x6b\x1d\xc6\xa9\x4d\xb4\xf9\xfc\x09\xf1\x34\x9c\x87\x84\x9f\xf9\x46\xf5\x18\x87\x0f\xcf\x8e\xe6\x47\xba\xcf\x54\x0e\xc2\x9a\xfb\x43\x36\x50\xbc\xa7\x81\xad\xc5\x66\xdb\x05\x45\x2e\x44\x6a\x31\x8d\xc6\x34\xf4\x35\x99\x9f\xd0\xb2\xe4\x45\x6b\xe7\x30\x9e\xba\xd1\x51\x22\x7f\x70\x20\xde\x82\x47\x57\xb1\xae\xaa\xbc\x9c\x0f\x30\x8f\x7e\xcb\xb1\x03\xfe\xd4\x70\x8a\x91\x7c\xe9\x9b\x77\xf7\x75\x56\xec\x90\x15\x38\xcf\x61\x0b\x25\x8a\xbe\x0d\x96\xdf\x17\x3a\x5b\x17\x64\x3e\x03\x04\xb6\xbf\xa9\x69\x4d\x48\x32\xb5\x16\x63\xc6\x49\x7f\x58\x4f\xc6\x03\xe7\x1c\xa6\xa6\x98\xaf\x07\xb8\xb0\x15\xa2\xab\x65\x5e\xe6\xa6\xce\xa7\x68\x9a\x23\xdf\x34\x5e\x7f\x6c\x86\xe2\x98\x29\x81\x9c\x37\x2b\xa6\xe5\x47\xf8\x16\x4b\x0d\xcf\x3a\x2b\x40\xd3\x59\xb2\x90\xb7\x84\x73\xba\x92\xd3\x1b\x89\x87\x5a\xb5\x15\xba\x64\x60\xd0\xce\x57\xd6\xbb\xbd\x49\xc8\xb9\x41\x75\x89\xa6\xbd\x26\x41\xf3\x82\x7b\xbc\xb1\xf2\x33\x59\x13\x31\x91\x8e\xda\x42\xf4\xa6\xc7\x12\xf0\x06\xb6\xaf\xb0\x84\xef\xdf\xc6\xa9\x4c\xf2\x72\x56\xac\x55\x39\xc5\xa0\x59\xd4\xd0\xdb\x86\xc2\x20\xd8\xd2\xe0\x10\x3e\x7e\x8d\x61\x1e\x64\x73\xa5\x41\x41\xe0\x7f\x80\xb2\xf3\xb8\x3a\x6f\xc0\x33\x37\x2a\x45\xda\x7b\x18\x9f\x56\xb8\x6a\x52\xd1\xe5\x86\x8f\x70\x5e\xb6\x12\x73\x86\xbd\x80\xdb\xe2\xc2\x6f\xb0\xc4\x25\x0c\xc7\x91\x78\xd7\x6b\x6b\x72\x6f\x20\x7a\x0d\xa2\xf6\xe1\x95\x5c\x25\x4f\xce\xcb\x5a\x55\x3f\x29\x79\x9b\x16\x6d\x1c\xd3\x40\x14\x8e\xf2\xe4\x61\x3b\xa2\x4c\xef\x7d\x6b\x0a\xe9\x9f\x2f\xce\x6f\x3f\x27\xdf\xb9\x1f\x07\x22\x90\x26\x85\xbe\xcd\xd5\x06\x93\x42\x43\xd0\x1f\x80\x61\xff\x4f\x92\x68\xff\x92\x46\xed\xbf\x61\x86\x68\xea\xd9\xa0\xb1\x30\x58\x42\xd9\x2b\x06\xe3\x02\x5a\x25\x02\x07\xc5\xf4\x7f\x74\xbb\x90\xc6\xe8\x69\x0e\xf9\x20\x18\x24\x62\x98\xb3\xe1\xa7\xe7\xe8\xbf\x51\x5b\xb3\xff\x82\xbe\x65\x42\xd0\xa1\xfb\xfc\x8f\x6a\x7b\xa5\x5f\x55\x7a\x45\x8b\xf8\xb8\xa8\x47\xa2\x87\x59\xf5\xc0\x7f\x8c\x4e\x8f\x91\xe8\x51\x06\x3e\x78\xfa\x42\xd5\x72\x24\x7a\x94\xf5\x0f\x1e\xbd\x59\xe4\x33\x5b\xd7\xd8\x7f\xed\x43\x87\x51\x74\x71\xfe\xa7\xa0\xd5\xf0\xe1\x04\x56\x4a\x70\xed\xc2\x9b\x1f\x2a\xbe\x8d\x2d\xb1\x15\x4b\xb9\x12\x79\xed\x06\x46\x97\x05\x80\x1a\xf0\x41\x33\x42\x7d\x40\x20\x65\x62\xa7\xa4\xbd\xaf\x8d\x2a\x66\x83\xf0\x45\x67\x21\xfe\x49\x4f\x6f\xf6\x6d\xbd\xa1\xa5\x74\xea\xcc\x74\xa0\x16\x17\x4b\xf9\x37\x0e\xbd\xad\x3e\x4c\xd5\xaa\x26\x90\x34\x50\x6a\x45\xc6\x66\x46\x2a\x78\x0e\xf1\xbe\x7c\x0f\xe7\x4b\xff\x46\x6d\x8f\xab\x79\x70\x17\x30\xd1\x7a\xb2\x72\xfb\x22\x37\xde\x27\x91\x6d\xba\xa3\xa4\xe8\x90\xbd\x3c\x6c\x31\x59\xa5\x63\x99\x62\xf1\xed\x28\xea\x1a\xc9\x81\x48\x6e\xd4\x96\x96\x44\x63\x99\xbc\xc3\xe2\xef\x99\x82\xc9\x95\x7e\x26\x1e\x3e\x64\x5f\x7a\x47\xcf\xdf\x8b\x11\xf3\x75\x6c\x44\x68\xc6\x8d\xe9\xca\x96\xd7\x32\xba\x51\x72\x8f\xc0\xdd\x21\x51\xd9\xaf\x64\xf0\x81\x46\xca\xe3\xcd\xb4\x52\xaa\xfc\x8f\xc0\xe6\xf1\xc1\x7f\x86\x07\xd3\xc2\x1e\xaa\xff\x91\x3e\x60\x25\x56\x72\xae\xfe\x23\xfe\xc9\xeb\xe3\x2e\x63\x5f\xa0\xfd\x14\x9e\xe0\xee\x0c\xbf\x69\x17\x86\x07\xe9\x1c\x8f\xda\x47\xdb\x16\x9d\xac\xeb\x5a\x97\xa1\x2a\xfe\x36\xe1\x41\xa5\x20\xff\x19\xb2\x45\x7e\x89\x65\xee\x36\xb1\x44\x3d\x8c\xaa\x88\x5f\x7e\xa1\xb2\x00\x8b\xea\xcd\xc9\x2e\xf9\x0f\x8f\xad\x7d\xe6\xdc\x2b\xb5\x7b\x42\xf7\x70\x5e\x75\xef\x30\x15\x4f\xff\x3b\x1f\xa9\x74\xa4\x74\x1d\xaa\x61\xa5\xfe\x2e\xe7\x2a\x7d\xfd\x77\x3b\x57\x1d\xfd\xf6\x73\x35\x74\x6e\xd0\xb6\x25\xf7\x0e\x1b\xae\xd3\xdf\xd0\x36\x5d\x42\x69\x5b\x70\xe4\x17\x68\xec\x38\x0d\xae\xd0\x2f\x7c\xb1\x5e\xa7\x07\x34\x94\xb9\xf4\x4e\xcd\xf8\xf3\x56\x55\x21\x5d\x33\x7c\x0c\xe4\xd7\xbb\x3f\x06\xc5\x3e\xf7\x63\x1e\x34\xa3\x55\x62\xde\xad\xc3\xfa\x06\x34\x52\x04\xe8\x8e\xce\xc1\xb2\x00\xe3\x3d\x5e\x93\x80\x81\x4a\x72\x20\x54\x62\x0a\xf9\x76\xec\x65\xcb\x25\xce\x71\x90\xed\x80\xfc\x28\x45\xad\x57\xfb\x90\xe4\x03\xe9\x8d\x61\x10\xf4\xad\xaa\x08\x14\x14\x7f\x33\x68\x54\xb8\x14\x01\xe2\xfd\x50\x5c\x96\x05\x80\x73\xf2\x62\xfe\xee\x02\xf8\xf0\xca\x25\xbe\x70\xa9\x09\xb2\xf5\xaa\xc8\xa7\xd2\x63\xde\xb3\xc4\x3e\x4b\x7d\xeb\xb6\x21\x90\x8b\x30\xd2\xbf\xf2\xdb\x0c\xa4\x2e\xbd\xae\x01\x64\xc7\xc7\x2f\xa3\x81\xad\xd1\xde\xa1\xb8\x28\x91\x33\x78\x1b\x3f\xba\x4f\x3a\xf0\x51\xd6\x5f\x3f\x14\x2c\x3d\x17\xe0\x8c\xff\x6e\xfa\xbf\xce\xfb\x7f\x58\x30\x60\xc7\xe1\xe7\x7e\x83\x29\xf3\x97\x9c\xbd\x36\xa2\x7b\x02\x1a\xf5\xc7\xf6\xaf\x3f\x8c\xbe\x4e\x46\xa4\x1d\x25\x6e\x15\x57\x52\x1c\x1c\x88\x17\x21\xad\x9d\x90\x7e\x12\x05\xb8\x97\x40\x38\xdb\xba\x16\xfb\xe8\xaf\xd0\x9d\x47\xc5\x6b\x57\x20\xeb\x4f\x5e\x06\x7d\x65\x63\x1c\x87\xa8\xfe\x84\x61\xeb\x1c\x64\x68\xd9\xb8\xf1\x1a\x30\x5f\x57\x95\x9e\xc8\x49\xb1\x15\x92\x34\xa9\x2c\x5f\x87\xfd\x6f\x03\xdb\xb1\x51\xb7\x15\x92\xce\x9b\x69\x9e\xdb\x43\x0a\x3b\xbb\x59\x6c\xc5\x58\x6f\x4a\x55\x9d\x91\xad\x1d\x91\x72\xf5\x12\x50\x63\x8c\x58\x97\x2e\x5a\x30\xd8\x03\x5d\xdf\x33\x3d\x6d\xfb\xf8\x30\xa2\xc7\x15\x6f\x99\x9e\x72\xbd\x1b\x36\x3e\xd3\xd3\x21\x69\x0e\xfe\x9a\xab\x0d\x79\x2c\x12\x76\xc3\x5b\x52\x1f\x77\xa8\x46\x91\xc2\x26\x2e\x94\x4e\x91\x5d\x73\x87\x41\x9d\xad\x0f\xef\xb3\xb4\x19\xee\x8b\xc0\x1d\x9d\x3a\x00\x3a\x82\xb4\xde\x13\x78\x8f\x9d\xbb\xc0\x8b\x1d\x8e\x4e\xad\x01\x67\x0f\x09\x81\x62\xfd\xb4\xd0\x46\x99\x26\x32\x26\x15\xda\x13\x23\xbe\x1e\x1b\x13\xfd\x42\x3b\x25\x95\x64\x58\x2b\x8e\x29\x59\xc6\x82\x83\x36\x8c\x7b\xc8\x73\x13\x41\x9b\xd2\x2e\x33\xb5\x25\x56\x39\x3a\x12\xb5\x8e\x56\xf2\x4b\xca\x1c\xbb\xc2\x28\x4e\xb8\xcf\xe8\x75\x25\x96\xb2\x94\xf3\x08\xe9\xea\x3e\xfb\x6b\x46\x1d\x17\x47\xd4\x46\x6c\xa4\x78\x06\x73\x3f\xea\xb0\x41\xd8\xa2\x7b\x7c\xce\x9d\xf9\x42\xdf\x93\x40\xad\xf7\x98\xcd\xa2\xb0\x27\x20\x8f\xf0\x09\x42\x42\x7b\x90\xcf\x37\xc3\x70\x56\x0f\xa0\xe1\xf7\x54\x1a\xc3\x97\x7c\xd4\x0f\x10\x81\x47\xbd\xe8\xb5\xc3\x6c\x71\x83\xc3\x5f\xc6\x0b\xef\x88\xfa\xce\x3a\xa3\xec\x01\xfc\x19\x9d\x01\x59\x60\x20\x6a\x7d\xcf\xae\xc0\x77\xe2\xae\xc0\xa3\x5e\xf4\x3a\x6d\x66\x78\x95\x76\x24\x74\x16\x0a\x85\x98\xa5\x20\xa4\xb0\xa8\xa5\x02\x87\x5e\x61\xa3\x71\x06\xc2\xa4\x3a\x1c\x66\x5e\xea\x7d\x43\xdc\x1f\x83\xc9\xd9\xad\x8a\x17\x72\x35\x16\x4b\x99\x97\xb8\xaa\xa5\x58\xca\xd5\x0a\xc0\x89\x10\xc6\x68\xb5\x9e\x14\xf9\x54\xcc\xe4\xd4\x87\x60\xcd\xd6\x05\xc2\x16\x11\xd8\xad\xbd\x02\xef\xf9\xc8\x07\x87\xc8\x11\xf0\x9b\x24\x0f\x5c\x25\x25\x32\xf8\xd2\x19\xa2\x6e\xa9\x39\x7f\x18\xbb\xb7\xa7\xa0\x3d\xb0\xc4\xc0\x1f\x87\xbe\xed\xbf\x27\xc1\x36\x2b\xab\x39\x7a\x51\x41\x62\x57\xb9\x02\x15\x35\xe4\xf6\x7b\x80\xb9\xfe\x7c\x43\x88\xb4\x87\x61\xd1\xb5\x62\xf9\xdc\x97\xa8\x9c\xb7\xa2\x8a\x87\x12\x04\x08\x6f\x0c\xe6\xc0\x4c\x6e\x19\x61\xdf\x42\xff\x0b\x65\x80\x98\xcb\x5d\x2d\x26\x6a\xaa\x97\x68\x31\x46\x30\x72\xf1\x42\xae\x48\x8b\x8f\x72\x5f\xa5\xe4\x0d\x2a\x82\x23\x8b\xf3\xf1\xab\x0b\xe6\x14\x68\x6f\x09\x2a\x13\x63\xf4\xe7\x1c\x93\x63\x60\x2f\xf3\xd1\x3e\x4b\x79\xa3\x04\x46\xe2\x68\x02\xd7\x81\xbe\x56\xb2\x34\x84\x78\xac\x10\xd0\x1a\x6f\x5f\xe8\x62\x7a\x71\xee\x14\x2f\x43\x34\x9b\x04\x5c\x64\xa8\x94\x1b\x04\x41\xb4\xa4\x02\xb0\x0d\x79\xb0\x57\xaa\x04\xdc\x10\x4a\x12\x11\x2b\x20\x70\xe2\xff\x19\xa9\x32\x86\xd7\x15\x2e\x2f\x1c\x7c\x70\x74\x38\x4c\x3c\x30\xcc\x7d\x2b\x82\xe0\xe3\xcf\xea\x98\x8c\xc1\xef\x0f\xb8\xe5\xbf\x8b\xcc\x11\x83\x4a\xf0\x40\x7e\xae\x88\x71\xc0\x79\xc3\xeb\xeb\x37\xe7\xa7\xaf\xcf\xaf\xae\x2f\x5e\x5e\x9d\xbf\x7e\x79\xfc\xd3\x9b\xeb\xb3\xcb\xeb\x97\x97\x57\xd7\x3f\xbf\x39\xbf\xbe\x7c\x7d\xfd\x9f\x97\x3f\x5f\xbf\xbd\xf8\xe9\xa7\xeb\x93\xf3\xeb\xe7\x17\xaf\xcf\xcf\x22\x84\x6f\x5c\x3e\x97\x56\x4c\x70\x24\xfd\x37\x86\x8d\x22\x87\xa1\xe6\x99\x9a\xac\xe7\xf4\xee\x79\x85\xee\x48\x6d\xd5\x1b\xe5\x0e\xe3\xf9\xf0\xd0\xae\xf6\xd2\x84\x20\xd1\x0d\x54\x10\x78\x4a\xb0\x20\x71\x96\xf1\xe0\x94\x84\xab\xa7\x11\xc2\x42\x50\x22\x1f\xbb\xaa\x75\x40\x08\x40\x89\xa1\xbd\xe7\x16\x12\x9d\xc2\x09\x89\x60\x58\x92\xa7\x55\x47\x6a\xf2\x33\xf0\x0a\x0e\x7e\x10\x76\x69\x6f\x34\x01\x25\x8c\x60\xf8\x5e\xea\xf3\xd9\x4c\x4d\x6b\x44\xd2\x3d\x38\x10\xe1\xbf\x27\x93\x27\xf4\x1f\x94\x7c\x85\xa0\xe0\x2a\x7b\xab\xab\x1b\x80\x89\xf3\xc5\x7d\xc9\xa7\xf0\xd9\xff\xd4\x6b\x58\xfa\xcc\x01\xa3\x52\xa6\x16\x7d\x60\x07\x59\x26\x96\xba\x52\x7b\x98\x07\xfd\x55\x21\xa7\xce\xbf\xff\x9b\xb8\x01\x8e\xea\x53\xfc\x3e\x86\x66\x89\x23\xf1\xaf\x49\x3b\x7d\xc9\xa7\xae\xa5\x8e\xe6\x71\x99\xf9\x5a\x7f\x84\x5a\xae\x24\xd1\x3c\x83\x10\x1c\x80\x9e\xfc\x53\x6b\xef\x9f\xba\xde\x9f\xea\xb2\x56\x65\xfd\x5a\x19\x38\x74\x9e\xfe\x31\xe9\xfd\x53\x3f\x4e\xa7\x2e\x57\xc1\x91\xf8\xb6\xa5\x47\x4f\xc3\x88\x9e\x57\x76\x99\xff\xb1\xd9\x1f\x28\xf9\x94\x8d\xfd\x6b\x35\xb3\x1f\xfd\x26\x6d\x24\x94\x7c\xea\x66\x09\x55\x87\x97\x3f\xbf\xbc\xba\x78\xf9\x7d\x00\xf2\x83\x27\xe7\x67\x30\xc0\x38\x92\x2f\xc3\xa3\x6f\x63\x38\x45\xd8\xed\x2f\x10\x38\xfd\x62\xb9\x2a\xd2\x3d\x50\x92\xc8\x85\x4c\x89\x5c\xa2\x70\x47\xc8\x02\xb6\x5a\xad\x62\x94\x59\x1e\x91\xef\x8b\x10\xd4\xef\x32\x9f\x2f\xe8\xce\x55\xaa\x8d\xa8\x2b\xe5\x6d\xbc\x76\xe1\x86\x4c\x14\x48\x6d\xab\xec\xb5\x78\x26\x72\x5b\x80\x30\x49\x72\x3a\x20\x08\xef\x77\x45\x91\x1c\x3e\xbd\xad\x50\xb8\xbc\x6d\xef\xea\x90\x83\x1c\x9d\xa1\xf0\xdd\x95\x9c\x8b\xc7\x61\xd1\xa0\x37\x94\xdb\x17\x8d\xcb\xa8\x1b\x5f\x7e\x21\xc5\xb4\xe7\x40\xf3\x1d\xe1\x34\xf5\xde\x87\x9a\x34\x68\xf1\x6b\x7e\xff\xf9\x8c\xd6\x74\xb4\x27\x4a\x39\xce\xa5\xff\xcf\x6f\xe2\x47\xc6\xb1\xd0\xbd\x4d\xce\x81\x5d\xfd\xa0\x4d\xfd\x5a\xeb\x9a\x43\x41\xc1\x3d\x92\x81\x96\xe5\x46\x6c\x00\x96\xba\x54\xc6\x1e\x8a\xae\x8e\x43\xbb\xb5\xe7\x64\x4e\x69\xc0\x0e\x0e\x08\x78\xda\xee\x35\x99\x97\xaa\xba\x28\x6b\xfd\x66\x3d\xb1\xeb\x22\xf2\xd5\xa5\xe5\xeb\x38\x9f\x87\x33\xce\xf2\x0c\x90\xad\x73\x94\x7d\x2a\xad\x6b\x12\x22\x96\x4a\x96\xc6\x45\x96\xf5\x28\x60\x03\xc2\xcb\xa6\xba\x2c\x09\x8d\xbf\x52\x8a\x01\x42\x2c\xa4\xc1\x84\x28\x6b\x97\x49\x60\x18\xb8\xac\xdf\x42\x29\xa4\x14\xdf\x40\x7c\xf3\x78\x30\xaa\xae\x1d\x66\x47\xb4\x83\xa6\x23\xe7\x6f\x48\x48\x32\xb8\x62\x69\x7e\x62\xf2\x23\x72\x48\x12\x59\xb8\xda\x62\x51\x97\x02\x5d\x3c\x7e\x8c\x95\xfd\xa4\x82\x06\xf4\x34\xfe\x50\xf4\x19\x27\x0f\x68\x3c\x82\xc3\xdb\x3c\xa4\x6e\x08\x05\x03\xb8\xbf\x2b\xba\x91\x55\x99\x97\xf3\xbe\x2b\x3e\xbc\xb6\x4f\x54\x76\x3c\xd1\xeb\xfa\xb5\x9a\x99\x8b\xf2\x35\xac\x82\x81\xe8\xfd\x0b\x78\x0a\x58\x69\xd6\x18\x8c\xb1\xa6\xa1\x70\x50\xd5\x79\x6d\x68\xcd\xf4\xf7\xbc\x7a\x6b\x28\x7a\xe2\x6b\xd1\xf3\xcf\x79\xd0\xc8\xca\xca\x7e\x7e\x68\xf5\x8c\x72\x1f\x40\x5c\x38\xc2\x54\x5f\xb8\x54\x53\x48\xa5\x54\xb7\xaa\xa2\x26\xa0\xfa\x63\x81\xba\x3e\xc0\x57\xfd\xfb\x1a\x9c\x11\x4d\x2d\x0b\x85\x09\xf5\x7d\x18\xde\xaa\x52\xb7\xb9\x5e\x1b\xde\x98\x81\xc7\x21\xac\xd4\xcc\x0c\xed\x6d\x9c\x50\x57\x0a\x3d\xcf\xa7\xe0\xd7\xed\x86\xfe\x2c\xcf\xa0\xb3\xd0\x36\xa0\xc1\x5f\xd1\xb1\xe6\x22\x18\x7a\x83\xa6\xf4\x12\x26\x01\x10\x8e\x7a\xc7\x81\x76\x2f\xb8\x3d\xdd\x35\x0b\x51\x26\xe9\x8f\x1c\xe8\x64\x46\x0b\xc1\x8a\xb1\x61\x65\xc6\x87\x42\x37\xa6\xcb\xaf\xd9\x11\xd2\x58\xe6\x7e\x61\x5a\xb6\xd9\xc3\xfe\xbd\xe8\xb5\x67\xea\xf8\xb9\x94\xe8\x3d\x2a\x66\x39\x64\x76\xcc\xc0\xc3\x56\x32\x16\xc0\x10\xb1\xa3\x44\x1a\xbc\x79\xb6\xb2\x93\x31\xed\x97\x7f\xb6\x6b\xf7\x4d\xa1\x37\xaf\x64\xbd\x48\x0f\x54\x7f\x24\x7a\xc9\xd2\x3f\xf1\x43\xf9\xa9\x27\x2b\x62\x7b\x43\x6c\x88\x87\xde\x77\x2c\x19\xce\x4e\xc1\x18\x5a\xe2\x0f\xdd\x35\x7a\xb8\x00\x1e\xf6\xb1\xa0\xe5\x1f\x9e\x05\xfe\xe6\x83\xe9\x78\x95\xf1\x39\x56\xdc\x21\x77\xa7\x6a\x98\x03\xba\x37\x8e\x07\xbc\x05\x6e\x74\x70\x14\x9e\x54\xb2\x9c\x2e\x94\x01\xdc\x8a\xa2\x10\x1b\x59\xdc\xc0\x0d\x78\x23\xab\xcc\x88\xf5\xca\xd9\xff\xed\x51\x42\x67\x83\x16\x46\x29\x4c\xe0\xb5\x92\xf5\xc2\xbf\x46\x7c\x21\x7b\xff\x1e\xba\x88\x26\xc8\x5e\xa0\x00\x11\xd7\x9e\x49\xc1\x13\x0c\x49\x81\x7f\x9a\x2c\x28\x48\xd0\xee\x73\x6c\x45\xa6\x64\x81\x20\x0a\xe0\x34\xe6\x56\x0a\x97\xbb\xec\x83\x89\x38\x12\xd1\x62\xa1\x33\xde\xee\x57\xee\xa8\x8b\x1a\xd3\x63\x5b\x3a\x3d\xdb\xc3\xeb\x13\x71\xe4\x0b\x3e\x73\x7f\x85\xb5\x18\xa9\x15\x61\x51\xba\xc2\xbf\xfc\x22\xe8\xef\x93\x48\xdd\xf7\x16\x8e\x59\x19\x4e\x62\xa7\xd5\x83\xab\x7c\xea\x8d\x78\x31\x43\xbb\xce\x54\xaf\x72\x65\x5c\xf8\x15\xd2\x25\x4e\x83\xf0\x4d\x2e\x1d\x9a\xbd\x05\x4d\x17\x79\x01\x90\x23\xf6\xb6\xe1\x28\xf1\xc4\xf1\x98\xf1\x2c\x2f\x32\xa6\x9c\x20\xf5\xc9\x42\xae\x56\xaa\x0c\x39\x31\x26\x32\x2f\x20\x33\x44\x29\x0a\xbd\x71\xc4\x56\x55\xae\xab\xbc\xde\x8e\x30\xc9\x9a\xcc\x0b\x95\x81\x7e\x1c\x9a\xd4\x33\x44\xbd\x52\x6b\x43\x61\xd9\xce\x3f\x1f\x5e\x04\x79\xd3\x0d\x28\x96\xb7\x4b\x9a\xc6\x0c\x9f\xa4\xd9\xa4\xa1\x90\x88\x2a\xf9\xf3\x13\x27\x39\xa9\xe6\x12\xd0\x3b\xea\x32\xce\x0e\x8a\xf3\x71\xab\xbc\x0f\xa4\xe5\x0a\x76\x84\x8e\x1d\x70\xa7\x6b\x37\xee\x88\x21\xab\x9b\x72\x5b\x6a\x15\xf3\x66\x6d\x6e\x3b\x2e\x8a\x36\x1b\x37\xb9\x67\xe3\x4e\x7e\xd3\xc6\x45\x5b\x25\x6d\xa0\x1b\x72\x9c\x36\xcb\x1c\xf2\x72\x1e\x8b\xd4\x2e\x39\x96\xcb\x75\x0d\x82\x01\x5e\x3b\x18\x71\x50\x18\xc9\x72\x8b\x2c\xd6\x8a\x0a\x20\x33\x8b\x37\xcc\x8f\xc8\x53\x03\xd7\x52\xb0\xf1\x01\x49\x62\x4b\x5b\x5a\x9c\xe0\xe9\xca\x84\x68\xcf\x37\x07\x10\xc5\x0f\x40\x32\x43\x7f\x8e\xff\x5a\xfe\xdb\xd0\xe3\x33\x66\x01\xfc\x7e\xd2\x76\x6f\xa0\x54\x69\x34\xc4\xb0\x45\x55\x65\xb7\xef\xb1\x57\x67\x36\xdf\x9d\x84\xbd\x9c\xe5\x33\x48\x3f\xc3\xf2\x8b\xc3\x22\x32\x43\x3b\xd4\x7c\x2f\xc7\x64\x0c\x8d\xff\xb4\xca\x8d\xd9\x87\x90\x11\x40\xd0\x38\x06\x47\xd5\x40\x6c\xa2\x0a\x8d\xf6\x8e\xc0\x0b\xec\x0d\xde\xb6\x70\x88\x24\x11\xed\xf9\x04\x3d\x5c\x5b\xca\x07\x62\x54\xf1\x84\x2a\xba\xb1\x97\x61\xab\xba\x15\x33\xf1\x8f\x4e\x3a\x4d\x6e\x8d\xa1\x31\x2d\x2c\x0e\x45\x02\x4a\x6c\xe3\xb4\x98\x6b\x0c\x13\x0c\xb4\xc8\x4c\x36\x10\xa6\xd0\x1b\x38\x95\x46\xc2\x4c\x65\x19\x77\x1a\xd8\xaa\x92\xd3\x85\xe3\xab\x61\xd1\xe2\xa1\xc6\x16\x26\xc4\xd5\x62\x4d\x1c\x12\xd0\x2b\xe3\x63\xa3\x3c\x2f\x3f\x38\x08\x75\xde\x40\xa6\x07\x47\xfb\xd8\x33\x47\xa3\x6a\x6e\x1b\xcc\xb3\xe7\x56\x3e\xa2\xfd\x16\xa5\xc0\xb7\xef\xaf\xef\xc3\xfc\xae\x5b\xb9\xdf\x75\x27\xfb\x4b\x3e\x1a\x04\xda\xce\x09\x6c\x9d\x44\x7a\x1c\xce\x2f\xd1\x60\x72\xd7\x9d\x5c\xee\x8e\x36\x4c\xda\xdb\x20\x3f\xb1\x0d\x7e\xf8\xae\x77\x72\x32\x38\xc1\x79\x8b\x78\x5b\x1b\x73\x79\xd2\x32\x97\x22\x9d\xa9\x93\x78\xa6\x76\xcc\xd5\x5d\xb3\x75\xe7\x58\x75\x0e\x4b\xe7\x30\x36\x46\x8c\x8f\xd9\x5d\x33\x77\x8f\xf6\x74\x2c\x95\xce\xa5\x75\x47\x7b\xee\x98\x45\x5e\x38\x9a\xc5\x56\x41\x1c\xdf\xd8\x03\x04\xdc\x4d\xf4\x1a\xd2\x5c\x39\x04\x09\x9a\x62\xbb\xa7\x29\x38\xa1\xcc\xc0\xcd\xc5\x24\xe9\x04\xbd\x19\xda\x49\xc4\x11\xef\xba\x5f\xb2\x41\x91\x9a\xe1\x1f\xf6\x25\x93\x31\x69\xec\xdb\x3a\xf1\x9a\x09\x18\xc6\x1d\xc1\x94\x1d\x61\xa2\x90\xab\x01\xa6\x9c\xf9\xaf\x5e\xe0\x6b\xbf\x4f\xca\xc4\x70\xa7\xf0\xa2\x7f\x8e\x83\x2b\x21\x71\x27\x44\x74\x82\xfe\x6a\xc0\x94\x4d\x4d\x5d\xd3\x50\x5c\x0c\xd5\xd0\x45\x58\xb3\x2b\x99\x1d\x95\xa6\x92\xed\x37\xbf\x64\xc1\x21\x1f\x14\x34\x4e\x57\x14\x6f\xc9\xcf\x93\x1c\x3b\xae\x61\x10\xbe\xbf\xc9\x8d\x12\x27\xa0\x5e\x43\x93\x60\x93\x40\x53\x62\xeb\xb8\x5f\xdb\xd1\x81\x0b\x2b\x09\x7e\xe1\x5e\x4d\x44\x5f\xe1\xf2\x3e\xba\xe3\x52\x4e\xb5\xfd\x8d\x3b\xaa\x9d\xfa\x32\xf3\xbc\xe2\x07\x07\xe2\xa5\xfa\x50\xbb\x8b\x5b\x95\xdb\xff\xeb\x8d\x73\xdd\xf2\x18\x77\x6e\x86\x02\xf6\x43\x94\x2b\xf3\xe0\x4a\x7d\xa8\x87\xb1\x8e\x3d\x6a\x43\xc7\xf5\xae\x55\x27\x1b\xf2\x13\xfa\x80\x64\xf6\xd6\x7e\xa9\x79\x8d\xf6\x0a\x3a\x16\xd3\x47\x70\xeb\x11\xf7\x0e\xcf\x98\x74\x78\xc4\xea\x47\xaa\xe4\xf8\x48\xb0\xdb\x22\x2f\xb9\x2e\x29\x74\x00\x9a\xd7\x3a\xea\x9d\x57\x7d\x1a\x8e\x87\x18\xaa\x8c\x1c\x32\x0e\xc8\x7c\x18\xab\xb3\xdd\x70\xf0\x96\x77\x7f\xb5\xe5\xbb\x81\xef\xde\xa1\x2e\x77\xf1\xd3\xd8\xa8\xc6\x48\xa5\x55\xf8\x88\x31\x56\xff\xd1\x81\xba\xea\x8d\x4b\x1f\x1b\xf8\x2e\x68\x6f\x17\xaa\x52\x08\x5a\x74\xfe\xe6\x27\x2b\x3a\x42\x16\x3e\x74\x43\x80\x34\xe3\x68\xf2\x38\x38\x10\xca\x14\x79\x59\xef\x67\xb9\xb1\x0c\x63\xbf\x54\x1f\xea\xfd\x22\x2f\x95\x28\xf5\xfe\xba\xac\x2c\xff\xb4\x2f\x5a\xcc\x88\x3b\xb7\xdd\xdb\xbc\x5e\xbc\xd4\xaf\x74\x55\xcb\xc2\xfc\xcf\x1e\xfc\x3d\xf7\xa0\x43\xcf\x00\x42\x0f\x89\x10\x8e\xfc\xff\x6c\xcf\xff\xef\x6e\x4f\xb0\x38\x1f\xff\xf4\xd3\xc9\xf1\xe9\x8f\xd7\x27\x97\x97\x3f\xfe\x78\x7e\xfe\xea\xe2\xe5\xf7\xd7\xaf\x2e\x2f\x7f\xba\x7e\x73\xf1\x7f\x21\xe3\xda\x13\x34\xfc\x4e\xc9\x34\x7d\x12\xf2\x5a\xbe\xd2\xba\x10\x47\xe2\x1d\x8b\x54\x7c\xee\x36\x49\xa6\xd4\x4a\x99\x9a\xe4\xbf\xb0\x91\x5c\xae\xcf\x62\xeb\x44\x1d\xe7\xfe\x0c\xc2\x90\x53\x71\x7e\xc5\x10\x20\x83\xab\x13\xe2\x32\x11\x6c\x83\x2a\xeb\xbc\x52\xf4\x01\x2b\x13\x01\xce\x82\x33\x16\x52\xc2\x4b\xdb\x7b\x4b\x0d\xe4\xbb\x3d\xb0\x00\x37\x2a\xe8\x9a\x2a\x0d\x7c\xb2\x2c\x00\x16\x89\xa3\x16\xec\xf6\xb7\xc2\x94\x37\x30\x52\x66\x6b\x53\xa7\x80\x25\x35\x28\x6d\xc1\x64\x34\xd7\x3a\x13\x79\xa6\x24\x22\xab\x4d\x17\x01\x28\x9f\x62\x5c\xc5\xba\x0c\xd0\xbf\x67\x97\x2f\x48\x51\x5c\xc9\x5b\x55\x19\x59\x10\xac\x9c\xf4\x38\xc1\x59\x3e\x9b\xe5\xd3\x75\x81\x1a\x10\xcd\xb2\x57\xb9\x58\x62\x4c\x03\x2a\x91\xd0\x72\x4d\x0e\x60\x7a\x62\x54\x75\x8b\x80\xc2\x0c\xdf\x58\x16\x05\xa4\xb9\x23\x74\xa0\x61\x60\x53\xb6\x67\x4d\xad\x0d\x05\xc9\xc7\x2f\xb9\x5f\x0a\x80\xa2\x70\x36\x93\x5a\x79\xd1\x2d\xbd\xf4\x7a\xaa\x59\x24\xe7\x2a\x87\x47\x9c\x9a\x6d\x03\xd7\x0e\xd6\x1f\xfb\x29\x26\x82\x06\xcb\xef\x4c\x3b\x2f\x96\x9f\x29\x60\x06\x53\x95\x3a\x88\x63\xb1\xc8\x55\x65\x6f\xa9\x18\xa1\xa8\x57\x02\x5d\xe0\xdd\x1a\x8f\x21\x77\xc8\xa1\xf7\x94\x6d\x80\x1f\x71\x03\x24\xbe\xf0\x2d\xb0\xeb\x31\xf6\x4e\xc7\x1e\xa2\x94\xd3\x5c\xef\xce\x0c\xa2\x5d\x95\x56\x7a\xe5\xb0\xe5\xbc\x25\x2e\x76\x3e\x8e\xdc\xd8\x93\x92\x71\xc0\x5e\x12\xa1\xc7\x29\x06\x70\x8e\xa6\xe7\x2e\x9b\x08\x5b\x38\x99\x1f\x4a\x32\xc0\xda\x30\x8a\x7e\x61\x20\x09\xfb\xf4\x28\x1a\x41\xac\xed\xbf\x38\xe2\xa1\x06\xf0\xce\xcd\xa6\x19\x89\x77\xef\x31\x11\x46\x9c\xd7\x1c\xee\x63\xbb\xa6\x2f\x8f\x52\xff\x77\x8d\xa2\x5b\x7a\x5d\x63\x97\xbe\x8e\x86\xac\xf1\xd6\xb7\x9a\x66\x1d\x9c\xa7\xee\xb5\x3e\xc4\x9f\xef\xe0\xd6\x6e\x01\x75\xae\x98\xb5\x59\x84\x3e\x1f\x76\xa0\x33\xb9\x01\x03\x03\xde\x24\x8c\x56\x0a\x1c\x4d\x1d\x64\x25\x86\x7c\x7d\x20\xff\xf9\x49\xeb\x95\x07\x65\xb7\x5c\xde\xef\xbc\x81\x87\x59\x04\x5b\x64\xcf\x80\xe6\x9b\xb8\x77\xec\xcf\x6d\x2f\xcc\x75\x8f\xa5\x3d\xf6\x30\xbf\x93\xb5\x95\x6e\x20\xfa\xb8\xaa\xe4\x16\xb3\x10\xd3\xf8\x3a\xac\x01\x3b\x1a\xc0\x11\x4b\x4a\xd9\x11\x63\xa0\x0f\x1c\xfa\x41\x8a\x8d\x8e\xa9\x4d\xb2\x7c\x86\x01\xba\x67\x97\x2f\x06\xa2\x50\x32\x43\x1f\x78\xca\x1a\x92\x24\x0f\x05\xc3\x1b\x1c\x30\x60\x54\xe8\x19\x14\x00\x80\xf3\x23\xb6\xf8\x1f\x9e\x3e\x7d\xf2\x6f\xde\x2c\xe7\xf8\x51\xba\xb5\x32\xcd\x04\xc4\x87\xae\x58\x90\x60\xf8\xa0\x87\x05\x05\xf3\xeb\x0b\x7b\x7d\x32\xb7\x99\x39\xfe\x02\x87\xed\x51\xc7\xa1\x96\x90\x80\x36\x54\x8c\x8d\xb7\xd0\xbc\x7f\x83\x58\x9f\x77\x85\x24\xd8\xcf\xc1\x0a\x75\xe7\x11\x23\xf3\xa0\x3d\x8d\x7f\x7b\x1b\x5a\xd2\xf9\x77\xae\x5f\x5f\xeb\x5d\x4e\xf2\xdb\x75\xbc\x27\xfa\xd1\x6a\xef\x0c\x84\xe2\xa5\x76\xe5\x4a\xe8\x28\xb7\x17\x01\x76\xa2\x54\x61\x57\xe3\x46\x01\xca\x27\x84\x8e\x63\x6e\x2c\xf0\xcb\x7c\x06\xf2\xd9\xb5\x02\x7d\x4e\xd0\x31\xc2\xc3\xb8\xf9\xe2\xc8\xab\x70\x22\x57\xde\x1f\xe2\x4e\xc6\x95\x70\xd4\x9a\x94\xe2\x07\x0d\xf7\xe0\x73\x6c\x4e\x9f\x9a\x45\x54\x42\x23\x1f\x3e\xa4\xbf\x53\x8f\x25\x57\x31\xf2\x7d\xba\xe6\x85\x03\x2a\xc1\xca\xa4\x01\x6c\x46\x4c\xb6\x24\x02\xc5\x59\x04\xba\x92\x6d\x46\xcc\xfe\xb5\x9a\xea\x8a\xd0\x6c\xc7\x3c\x7d\xc4\xa9\x86\x15\x5a\x9b\x71\x6b\x9c\x2d\x31\x8d\x13\x69\x10\xad\x10\xcf\x06\x70\xde\xee\xf3\x8c\x9d\x7b\xad\xe1\xb5\x0e\x0b\xda\xc5\x0d\xeb\x92\xac\x25\xb5\xa6\x0c\x0d\x1e\xab\x3b\x4e\xd6\xf9\xcc\x51\x38\x2e\x29\x86\x0b\x39\x90\x14\x15\xa0\x7d\x07\x6f\x25\xa4\x07\xde\x8e\x33\x5d\x4d\x95\xf7\x39\x6f\xfc\x47\x35\x2d\xcb\x8b\x3f\xca\x92\x7d\x1e\x44\xc9\xa5\x56\x27\x98\xc0\xa3\x0d\x81\x30\x19\x98\x81\xeb\x2b\xc3\x04\x57\x6d\x68\xe0\x6d\xf2\x1e\xd0\x77\xc9\x3b\x87\xd8\xb8\xbe\xc3\x27\x6f\x7e\xc9\xc5\xf6\x62\x14\xca\x24\x2f\xb3\x3e\x84\x85\x47\x33\xbe\xb7\xd7\x5c\x51\x32\x5d\x53\xe9\x92\xc2\x8c\x44\xff\xb3\xa6\x7e\xcf\x35\x45\x29\x9e\xfe\xff\xbc\xa8\x28\xd7\xd4\x6f\xb4\xaa\x42\xce\x4c\x5e\xa9\xfb\xd2\xc0\xda\x7f\x1d\xb1\xcd\x06\xfa\x63\x02\xb9\xe1\xe3\x99\x76\xe4\xe2\x39\x6c\x13\xde\x76\x9c\xc0\xed\x21\x58\x21\x09\x38\x50\xe0\xbe\xa0\x2e\x22\xc1\xbf\xf5\x6a\x2b\x07\x65\x09\x79\x78\x13\x37\x57\x76\x4d\x8a\x3d\xd4\x36\xca\xb6\x2e\xc0\x07\xf7\xd5\x87\x91\xc8\x97\x73\xa1\xcb\x42\xcb\x6c\xcf\x8b\x77\x7a\xb9\xcc\xeb\xda\x39\x56\x3a\x0a\xc1\x5f\x91\x3c\xd6\x06\x21\x3d\x06\x25\x7a\xde\x88\x3e\x39\x8c\x0f\xec\x7d\xd3\xfe\x55\x0b\x69\xc8\xd3\x0d\x5c\x8f\xbd\x67\x10\xb6\x41\x97\x10\xfa\x58\xee\x07\x1d\xc2\x1e\x38\x1b\xa0\x33\xba\x2c\x8c\xbd\x90\x83\x7b\x69\x25\x20\x89\x8b\x67\x1a\x26\x42\x93\xa7\xf5\x40\x47\xf8\x92\x00\x9c\x29\x08\x9c\xa2\xb0\x45\xeb\x3d\xc2\x4f\x3f\x93\x1d\x08\xb5\xee\x57\xdf\x53\x41\xb2\xaa\xab\x6d\x98\x07\xe4\x39\x98\xe5\x68\xa2\x28\x6b\xc7\x54\x01\x18\x3a\x47\x17\x9b\x6e\xa7\x85\xa2\xb0\x32\x57\x77\x4c\x1a\x8e\x33\x74\x30\x18\x63\xa7\x92\x5c\x39\xcd\x2b\x47\x24\x3d\x91\x08\x38\xcb\x11\xef\xd5\xed\x85\x3b\x2f\x76\x0d\x12\x51\xec\x91\x83\x02\x73\xdb\x3e\x64\x54\x9d\x55\x4a\xfd\x43\xf5\xff\xf9\xe0\x0b\xbb\xf6\xbc\xb4\x62\x65\x91\x86\x24\x22\x3e\x0e\xa8\x58\x22\x1a\x45\xa5\x13\x29\x09\x2a\x35\x24\xae\x51\x53\x08\xc3\x62\x24\x0b\x8d\x98\x40\x35\x78\xf0\x85\x97\x91\x46\x41\x5c\x1a\x3c\xf8\x22\x3d\x8a\x47\x8d\xc3\x99\x0a\x45\xbc\x75\xd4\x64\xb7\x83\x07\x5f\x44\x1c\x6b\x14\x33\xb0\x07\x1f\x19\x34\xd4\xf7\x76\x00\x65\xad\x58\xec\xa2\x9e\xf9\x54\xf2\xe2\x56\x95\x99\xae\xc4\xaa\x52\xb3\xfc\x83\x32\x74\x8c\xa2\x82\x10\x43\xc0\x4d\xbd\x2d\x58\x0e\x17\x59\x66\xb4\xd9\xec\x49\xd7\x75\xc0\x42\xa5\x57\x95\x5e\xed\x4c\x9f\xce\xce\x35\xe3\x4f\xc6\xf8\xa8\x59\xca\x1b\xf5\x0a\x1a\xf7\x42\xae\xfa\x9e\xec\x20\x10\x09\xd7\x5e\xdf\x89\x23\xf1\xcf\x8f\xb0\x57\xdc\x93\x77\xbe\x62\x8c\x4d\xfd\x9e\xa7\xff\x6e\x66\x82\xf3\xd5\x7b\x6f\xd5\xe4\x26\xaf\x7b\xe2\xeb\xd0\x33\x5b\xb7\xb7\xf1\xcf\x3d\x99\xb8\xe2\x0b\xfd\x8f\x66\xad\x25\x3e\xec\xa8\xb2\x34\xcd\x1a\x2f\xde\xec\xa8\x70\xd9\x2c\xaf\xa3\xe2\x69\xcf\xc2\xe9\xea\x88\x70\x21\xeb\x18\x64\x00\xf0\x27\xf2\xf3\x8c\x91\xa7\x51\x46\x5a\x5f\x2a\x59\x42\x01\xd1\x0f\x5f\xbc\x62\xb3\xf2\xc0\x5e\x2f\xf3\x25\x68\x3c\x55\x99\x8d\x92\xe9\xed\x1d\xbb\x97\xbd\x81\x08\x3f\xce\xcb\xac\xb7\x37\xe0\x75\xf3\x5a\x21\xfe\xc9\x3d\x29\x5c\xb8\xf2\x09\x1d\xc8\xf9\x70\x4f\x1a\x90\x1e\x09\xeb\x43\x74\x68\xde\xd5\x89\x2b\xff\x16\x10\x09\xfd\x2f\xe8\x06\x0f\x35\x3e\xe7\xc3\x8b\x51\x29\xb7\xca\x27\x6c\x86\xf0\x14\xc4\x86\xa7\x60\x5b\x1a\xe1\x4c\xf4\xf3\x99\x90\x2b\x80\x2c\x99\x14\x6a\x2f\x8c\xb8\x2b\x71\xee\x66\xde\xef\x05\xf7\x49\x92\x36\xbd\xd7\xf8\x8c\x6f\x7e\x5d\x06\x52\xb8\xed\xe3\xda\x27\x5a\xd7\xc6\x72\x23\xf0\x51\x04\xbd\x34\xcf\x35\x74\xdf\x34\x5b\x8e\xf4\xce\xc4\xf9\x43\x28\xe5\xd4\x54\x97\x25\xc4\x67\x88\x55\x21\xeb\x99\xae\x96\x06\xb4\x53\x2b\x59\xd5\xf9\x74\x5d\xd8\xe6\xda\xb7\x74\xf0\x80\x2f\xdc\x71\x99\x55\xf6\x2a\xfd\xaf\xc3\x0f\x83\x90\x98\x6e\x5d\xee\xfb\x51\x7c\xe4\x97\xc1\x23\x18\xde\x47\x61\x5a\x1f\x39\x7e\x97\x93\x0d\xc2\x31\x43\xcc\xf0\x40\x1e\xde\xd0\x0d\x12\xc1\x27\xeb\x9a\xe7\x22\x84\xe9\xc4\x5c\x34\x90\x6d\xb6\x26\x7c\x1b\xf7\x71\x97\x11\xac\x54\x2e\x0b\x1f\xf7\xe3\x4f\x5b\xea\x04\x94\x4a\x89\xb5\xa1\x6c\x2b\x65\x66\x4b\x96\xba\x66\xc2\xfb\x32\x44\xa8\x2c\xe5\x6a\xe8\x64\x55\xb6\xa2\x61\x61\xf4\x04\x64\xc1\x2d\x33\xbd\xf1\x32\x1d\x65\x31\x8e\xb7\xec\x90\x6f\xd6\xf0\xe3\xf0\x3e\x35\xfc\x16\xfd\xc4\x7a\xb0\x25\xe3\x3a\xce\x10\xfc\xc6\x4a\x32\x12\xec\x6b\xb7\x2a\x74\x8e\xed\xb0\x4f\xeb\x5d\xb4\x8d\xd9\xaf\xc3\x04\xfe\xfc\xb8\xae\xd5\x72\x05\xde\xff\xc1\x53\x86\xf2\x1c\x82\x71\x27\x61\x81\xf7\x39\x20\x3b\xce\x40\x7a\x1d\x9f\x81\x73\x55\xff\x95\xb7\x3c\x6c\xef\x7e\x72\x0a\x82\x37\x7a\x83\x07\xbc\xf3\xa5\xde\x27\xf7\xad\x9d\x65\x0f\xe3\x0c\x37\x0f\xe3\xd1\xeb\x26\x1a\x9d\x52\x5e\x1c\x5e\x39\x06\x29\x8e\x44\x27\xa5\x58\x75\xe8\x8f\x34\xd8\xeb\xae\x3e\x37\xcd\xfb\x87\x69\x06\x78\x5f\x15\xf2\xe4\x45\x84\xe0\x47\xc3\xc2\xbd\x73\x24\xc4\x51\xf8\x7c\x10\x25\xde\x27\x71\x53\x44\xa9\xd7\x8b\x34\x16\xdb\x15\xf2\xa3\x4a\x6e\x84\xc9\xe7\x10\x51\xef\x77\xa9\x43\x8f\x9a\xca\x35\xdc\x4f\x90\x87\x78\x7b\x97\x5b\x3c\xcf\xb5\xcf\x8d\x07\xd9\x56\x7b\x66\x3d\x59\x5a\xb1\x03\x6f\xf8\x98\x1f\xca\x2b\xba\xeb\x62\x4b\x29\x5b\x45\x9f\x54\x00\x8a\x80\x10\x56\x08\xad\x5f\x58\x61\x00\x35\xdf\xf5\x42\x96\x62\xec\x38\xf1\x78\x6f\x00\xa9\x5d\x41\x1d\x5f\xb3\xe7\x08\x34\x0c\xc0\xfb\xa0\x8a\x4f\x01\xb3\x88\x9d\x61\x4b\x30\x9b\x29\x71\xa4\x85\x82\x6c\xc4\x74\xaa\xf0\x7b\x4e\xc8\x45\x5d\xeb\xd5\xf1\x44\x57\x80\x0d\x6a\xff\x05\x08\x33\xfb\x90\x49\x00\xa3\x5d\xdb\xa0\xc7\x19\x55\x0f\x43\xe2\xa2\x47\x29\xc1\x8b\x20\x40\xdc\x8b\x6c\x1e\x04\x88\x98\x78\x78\x91\x7e\xe2\x0d\xca\x16\xf7\x22\x6f\x50\xb6\x88\x49\xe3\x43\x22\x7b\x52\xac\xab\x91\xe8\x4d\x20\x63\x36\x3e\x3a\x95\xe5\x54\x01\x74\x2a\xfc\xc1\x1e\xbf\x2a\xe4\x16\x9f\xaf\x0a\xb9\x4d\x5e\x5c\xa1\xb1\x27\xbc\x27\xeb\x8f\x2f\x46\x89\xc1\x5d\xfa\x69\xf7\xb8\xc8\xa7\x37\xf6\x29\xe6\xe6\x76\x0f\xb5\x81\xa2\xf6\x5f\xff\xd0\xde\xec\xbd\xc8\x33\xa2\xd8\x46\xcf\x68\x5b\x8a\xd1\x50\xf1\x82\x51\xe7\x59\x51\xbc\x97\xc6\x65\x31\x53\x59\x28\x5c\xd6\xea\x43\xfd\x42\x95\x6b\x28\x06\xbf\x96\xaa\x5c\x87\x02\x2b\x18\x1d\xbd\x0a\x43\xb3\x86\xcf\xaf\xfd\x17\xcf\xf4\x7a\x52\x28\xd7\xe7\x6c\x52\x44\xdd\x3e\xab\xe4\xdc\x3e\xae\xe4\x9c\x3f\xc2\xde\xda\xa7\xac\x9b\xf8\x02\xb0\x02\xe9\x95\x03\x04\x74\x2f\x3f\xe4\xb5\x7b\xf7\x21\xaf\xf9\x2b\x82\xfd\x83\x77\x85\xc7\xf6\xa3\x97\x97\xb7\x9e\xa6\xbe\x8d\x49\xba\xf1\xb4\xef\xa2\x81\x3c\xab\xf4\x0a\x9e\xeb\x95\x7f\x44\xd0\x95\x7e\xda\x33\x7a\x10\x4f\xff\xf9\x72\x55\xe7\x90\xe3\x5d\xe1\x5f\xfe\x45\x39\xad\xb6\xab\x1a\x5f\xb9\xbf\xc3\xcb\x8c\x5e\x64\xec\x61\x55\x69\xdb\x72\x70\xdc\x75\x0f\x21\x37\xe0\x48\xf4\x66\x98\xee\x1d\x1f\x02\xe4\xf6\xc8\x25\x0f\xa2\x87\x94\x63\x6c\x24\x7a\x94\xce\x8a\xbd\x78\x55\x29\x63\xf0\x0d\x24\xcb\x62\xaf\x7e\x5e\xe1\xf3\xb5\xef\xf9\x4f\x5a\x66\x2a\x3b\x93\x80\x35\x5c\xc0\x8f\x4c\xd6\x92\xbf\xa6\x17\x71\x8d\x17\xaa\x96\x19\xaf\xb5\xa4\x07\xbc\x98\x9b\x02\x5b\x22\x9a\x02\x00\x5e\xa2\x0e\x00\x3e\x12\xef\x02\xbc\x7c\xa1\x61\xd2\xe1\xa5\x95\xec\xa2\x97\x97\x30\x20\x0e\x4f\x30\x7e\x85\x0b\xc2\x63\x07\x46\x2f\xa1\xfb\xf0\x2a\x0c\xc0\x2b\x69\x60\x2b\x41\x76\xad\xf0\x70\x6d\xf0\xe1\x3a\x6c\x69\x62\x28\x9c\x9b\xd8\x47\x79\x39\xa7\xa7\x79\xe9\x77\xc2\xab\x4a\xcf\x69\x1a\x56\xf4\xa7\x7b\xf5\xda\x27\x56\x18\x89\x5e\x25\x6b\x15\xaf\xb1\x37\xd3\x4a\x17\x96\xa1\x19\xf8\xc3\x3f\x56\xea\x06\x56\x91\x81\x3f\xf8\x63\x6c\x80\xc1\xbf\xc2\x8b\x28\x99\xdd\xc8\x25\x6f\x6f\xac\xe9\x37\x35\x40\x0a\xd9\x02\xf8\x97\x7f\xb1\x36\x2b\xb8\xd9\xf5\x0c\xfe\xe5\x5e\xf8\x7c\x21\x23\xd1\xab\xdd\xdf\xfe\x65\xbe\x54\x9e\x3d\xd5\xf9\x52\xc5\x7c\xe9\x4a\xcf\xe7\x05\xbc\x82\x3f\xc2\xe3\xf5\x74\xe1\x59\x79\x6d\x7f\xc5\xfc\x1c\x0a\x20\x6b\x81\xb7\xbc\x39\xf6\x37\x2d\x17\x78\xc7\x97\x0b\xbc\x74\xcb\x10\xde\x46\xeb\x30\xba\x97\xee\x3e\xa6\x22\x39\x99\x4e\xa9\xf8\x19\xd1\xfc\xab\x2e\xd6\xcb\x30\xc3\xb7\xf0\x33\x1e\xf3\xb7\x32\xaf\x71\xd6\x36\xf8\x97\x7f\xb1\x50\x30\x02\x1b\xfb\x6f\xcf\x83\x91\xb6\xda\x63\x82\xd8\x10\x84\x89\x51\x2a\x5b\x00\x89\x46\x3a\x6f\xc8\xcb\x1d\xe5\xf4\x36\x28\x0b\xb6\x24\xf5\x36\x77\x67\xf5\x76\x79\xe2\xea\x4a\xc9\xa5\x11\x12\xee\x7c\x59\xc3\x3e\xd5\x92\xc6\x02\x73\xb3\xf9\xac\x10\x18\xfe\x85\x9e\x75\x1a\x50\xa6\xd6\x65\x5e\x03\x76\x3b\xde\x8e\x09\x98\x0c\xa8\x8c\x9d\x77\xbd\x53\xfb\x75\xe4\xa6\xf5\x06\xe3\x5f\x07\x09\xea\x61\x70\xed\xc0\x47\xb0\xa3\x9f\x4f\xd8\x8e\xec\xae\x39\xf1\xfe\x8f\xd1\xac\x8a\xa3\xf6\x05\x11\x99\xfa\x4d\x50\x58\xbc\x59\x2f\x97\xb2\x02\xb7\x13\x1c\x3e\x5e\xfb\x7c\x99\xd7\xb5\xaa\xc6\xdc\xaf\xc4\x2e\x4d\x12\xba\xc5\xbe\xb8\xf2\xd3\x68\x2f\x90\x73\x49\x06\x70\x8f\xf2\x0c\x12\x35\xc0\xdc\x96\x2d\xa0\xcb\x14\xa0\x42\x06\xb7\xa5\xdc\x62\xd4\x3e\xe6\xd9\x20\xe5\xfc\x52\xc2\x1f\x95\x92\xa8\xe2\xc9\x9d\xa3\xa9\x59\x59\x71\x7e\x92\x17\x76\x11\xe8\x19\x11\x69\xd5\x8e\x0f\x7c\xa6\xcc\x90\x30\x04\xd3\x3e\x96\xe8\xba\x03\x66\x18\xc2\x2e\x23\x42\x76\xd9\xcd\x41\x8b\xe7\x72\xa5\xae\xab\xa9\x0f\xa9\xa1\x56\x40\x73\x37\xba\xba\xf9\xff\xb1\xf7\xae\xfd\x6d\xe4\xc6\x9e\xf0\x7b\x7f\x0a\xd8\x67\xc6\xa4\xc6\x14\xe9\xcb\xe4\x26\x45\xf1\xf1\x48\xf2\x89\x36\x96\xe5\xb5\xe4\xe3\xcd\x3a\x5e\x1b\x62\x83\x62\x47\xcd\x06\xa7\xd1\x94\xcc\xc4\x7e\x3e\xfb\xf3\x43\x5d\x70\x6b\x90\xa2\x3c\x33\xd9\xec\xc9\x99\x17\x63\xb1\x1b\x8d\x6b\xa1\x50\x55\xa8\xfa\x57\x88\xaf\x1b\xf6\x9c\x2a\xc3\xfe\x0f\xfd\xbc\xbd\x55\x3e\x0b\x18\x74\xa5\x50\xdb\x1d\x8d\x01\xa1\xec\x00\x05\x63\xe2\xd1\xf1\xc5\x8f\x8b\xb2\xb9\xec\x4e\xdd\x39\x28\x17\x8a\x5b\xb7\xbd\x82\x0b\x99\xa4\xe5\xe7\x3e\xdf\xae\x51\xbc\x2a\xd4\x60\x9f\xa3\xee\xc3\x4c\x08\x7e\xa7\x02\x52\x17\xad\x2c\x0f\x0c\x4c\x5d\xed\x56\x6e\xff\xba\x59\xaf\x05\xa8\x7d\x60\xe7\x91\xe6\xd2\xed\x68\xb4\xe3\x2c\x21\x6f\x2f\xd7\xa7\x1d\xe2\xb0\xac\x97\x1e\x85\xdf\xe7\x81\x77\x94\x37\x55\x19\x8e\x51\x62\xe6\xdf\x9a\x79\x12\x86\x46\xb9\x2b\x70\x59\xd7\xba\x95\xad\xbb\xb4\x42\xf0\x1d\x68\xf9\x9e\xe3\x14\xe6\xde\x00\xb2\xfe\xfe\x08\xd9\x62\xec\xce\xf0\x69\xc6\x21\xe5\xec\x01\x59\xaf\x3c\x48\x33\xfe\x76\x40\xe2\xeb\xba\x08\xbd\xf3\x6d\x05\x26\x31\xfe\xd2\x4a\x29\x57\xa5\xba\xb6\x2d\xe3\x2d\x1d\xc7\x12\x13\x25\x2e\x4d\xab\x66\xbc\x09\x1f\x6c\x07\xff\x3d\xb0\x23\x81\x7b\xe9\xcf\xf6\xaf\x83\x93\x63\xd0\xe0\x3f\xbb\xc7\x2b\x4a\x0b\x5f\x8c\xfe\x0b\x1e\x5f\xa5\x8f\x57\x36\xe9\xf9\x6f\xd0\xe4\x67\x21\xdc\x2d\xd5\xfa\x9e\x74\x6f\xdd\xe9\xbf\xb0\xec\x83\x15\xfd\x5d\xf5\xc9\x83\xcf\x41\x1a\x9c\xcf\x9b\x7d\xec\xdf\x7d\x26\x6c\x6f\xf8\xdb\x77\xfb\xf3\x9a\x6e\x5f\xad\xee\xf6\xe7\xb0\xf6\xcf\xee\xe3\x68\x2a\xa8\xd6\x75\x53\x10\x56\x16\x3e\x1f\x6e\x6f\x6f\xff\xe1\x73\x4c\x70\x9f\x73\x95\xc1\x43\x5c\x27\x1a\xd6\xe7\xce\xeb\x61\x3a\x49\xee\xe7\x83\xb8\xaf\x9f\xc5\xab\x46\xcf\xe5\x85\x6c\x75\x63\x3e\xaf\x20\x84\x95\x95\x7d\xe6\x7c\x44\xf8\xe4\x73\x38\x4c\xee\x19\x1d\x43\x6b\x7b\xf6\x7b\x58\xea\x70\xb5\x84\xf8\xac\x31\xc6\x13\x1e\xfe\xf4\x61\x8a\x45\x6b\x0f\x9b\x52\x99\x70\xce\xba\x0b\x90\xab\x6c\xc3\xd5\xbc\x91\x34\x36\x23\x41\xf1\x7f\x72\x0d\x6d\xb8\x73\xfc\xcb\xcf\xa0\x95\x8f\x40\xc7\x0e\x76\xce\x83\x75\x1f\x3f\x70\xdb\x2e\xbf\x73\x42\x22\xbf\xc5\x86\xff\xcc\xb7\x39\x20\x60\x7c\x76\xbc\x25\xaa\xf3\x73\xc4\xfc\xa2\xf1\xac\x7b\x9c\xe9\x58\xd6\x05\xc8\x3d\x46\xa6\xbc\x6f\x65\x06\x9a\x03\xbc\x42\xae\xc4\xab\x45\x33\xd7\x86\x1d\x9d\x68\x06\x4e\x81\x5f\xfb\xd4\x3f\x74\x7d\x85\x4c\xb1\xac\x2f\xce\x34\x5d\x22\x21\x6c\xb6\x1c\x83\x1f\x04\x1f\x39\xfb\xe0\x65\xd2\xa0\x8f\xb5\xb3\x99\x6a\xa1\x6a\x00\x72\xad\xc1\x5d\x63\x52\x95\xe3\x96\x7c\x77\x89\xe8\x75\xab\xea\xb6\x94\x15\xf5\x96\x7d\xa6\x0d\xa7\xe0\x9e\xcb\x0b\x15\x19\x1d\xb9\xc1\xa3\x83\x3f\xa9\xa5\xd8\x13\x3d\x04\x42\x0d\x9e\xf7\xc4\x03\xd1\x87\xec\xaa\xc7\xb2\x9d\x0e\x1b\x59\x17\x7a\xd6\xdf\xda\x1a\x9a\xaa\x1c\xab\xfe\xe3\xad\x04\x4e\xd4\x8d\xf0\xb9\x76\xb8\xe7\x7d\xf0\x0e\x79\xe6\x23\x4e\x20\x39\xee\x6f\x07\x80\xe8\x6f\x5f\x00\xd0\x3a\x45\x12\xd3\xcd\x11\xc8\x47\x5a\x01\x28\x22\x68\x01\x1f\x63\x5b\xf6\xc7\x3b\xe4\x92\x82\x61\x24\xee\x56\x87\x3c\x22\xe6\x8d\x6e\x35\xe0\x85\xc6\x9f\x61\x56\x0d\x6a\x76\xd0\x9d\x03\x77\x37\x42\x45\xde\x75\x4a\xbc\x07\x78\xf2\xfc\x82\x3d\x78\x40\xce\xc2\x9d\xd5\x7e\xb7\xba\xbe\xf7\x44\x09\x91\x7f\xd7\xed\x6a\x08\x95\xae\xb7\x2a\x0c\x94\x41\x8b\xb7\x15\xde\x16\x2c\x13\x39\x6a\x70\x29\xe5\x1d\x8e\x3e\xc5\x42\x59\xd9\xf8\x93\xb8\xfa\xed\xf0\xe1\x23\x04\x30\x75\x28\x2d\x18\x6f\xbe\x25\xd4\xa7\x69\x79\x5e\xb6\xe0\x07\xd1\x00\xe2\xe9\xb9\x9a\xca\xab\x52\x37\x10\xe4\x04\xd8\xcc\x0c\x06\xf3\x51\xd7\xce\x68\xf3\xd1\x5d\xda\xb5\x78\x37\xc9\xd6\xf6\xd6\x45\xeb\x87\x3d\xb3\xf5\x90\x4f\xdb\x10\x24\x2b\xb3\x9c\xcd\x5b\x3d\x33\xe2\x5a\x35\x8c\x9b\x39\x11\x4b\xc0\x54\xc7\x0c\x06\x58\x09\xa5\xa7\xd0\x57\xaa\xf1\x08\x76\x60\xa7\x27\x8f\x71\x17\x69\x85\x50\x89\x20\x6f\x23\x14\x09\x44\x6b\xa9\x4f\xd2\xca\x0f\x3c\x53\xe7\x72\x7c\x79\xd1\xe8\x45\x5d\x6c\xb1\x36\xea\x25\x64\x2f\x28\xda\x2f\xe3\xd1\x5e\x83\xe5\xdf\xc1\x34\x07\x09\x34\xb0\xdb\xb6\x26\x4c\x5c\x42\x7e\x54\x1f\x83\x8f\xf3\xcb\x94\x80\x80\xea\x89\x18\xeb\x45\x83\x59\x10\x21\xa5\x3d\x04\x47\x05\xf5\x18\x87\x9e\xad\xeb\x0b\x64\x17\xe5\xc9\x29\x69\x14\x03\xf1\xd7\x85\x69\x31\x63\x64\xa3\x4c\xdb\x94\xe3\x96\xa6\x2a\x37\x42\x02\x42\x48\xba\x04\x2a\xd1\xc0\xae\x69\xa5\xa4\x71\x29\xf3\xb1\x4f\xb6\x0f\x78\xb9\xce\x77\x3e\xde\xb1\xcc\x13\x96\xed\x73\x2c\x11\xa7\x59\xa4\xb0\xbf\x33\x5d\x28\xc8\x26\x75\x5e\xe9\x8b\x91\x6c\xc6\xd3\xf2\x4a\x99\xd1\xe3\x87\x8f\x1e\x8e\x1e\xfe\x6e\x04\xf6\xe8\x0f\x50\xd1\x87\x42\x55\xc3\x69\x3b\xab\xa8\xbe\x67\x95\xd1\x03\xf1\x11\x6c\x9d\x1f\x47\x1f\xd9\x16\x8a\x7f\x16\xfa\xba\xfe\xc8\xe9\x4f\xe8\x96\x88\xc6\xca\xb9\x26\x30\x9f\xf7\x39\x66\xc2\x04\x15\xc6\x97\x73\x57\xf6\x2b\xae\x35\xd3\xdc\x34\x02\xfe\x17\x28\x19\xe4\x1a\xfb\x51\xd7\x60\x5c\xff\x98\x77\x8e\x1d\x23\x20\x2f\xb3\x55\xf4\xbc\x12\xfc\x93\x34\x2f\x7d\x5d\x13\x48\x01\x07\x47\xc4\x36\x10\x6c\xf2\x4c\xf7\xd3\x4e\x0d\xf2\xf5\x7b\x63\x07\x31\x20\xb1\x97\x2f\xc8\x9e\x9a\xa5\x71\x5c\x0b\x3d\xfc\xd6\x1e\x09\xfc\x55\x98\x98\x07\x38\x6c\xdc\xb9\x83\xe0\xf5\xbb\xf4\xe5\xfb\x95\xb1\x15\x61\xad\xb9\x90\x8a\xa8\x65\x7b\x00\x86\x1f\xb8\x68\x0a\xbc\x51\x0f\xc6\x95\xde\xab\xfa\x2a\xe0\x62\x35\x28\xf9\xce\xbf\x7a\x9f\xe4\x4e\x0e\xdb\xa5\x7c\x1b\x60\xed\xeb\xa5\x20\x3f\x25\x5a\xd9\x5c\x7e\xe5\x3e\x59\x03\xb7\x62\xcc\x96\x8e\x4b\xbb\xaf\x71\xc0\x06\xc4\x81\x08\xe7\x1d\xff\x8b\x52\x3f\xa7\x2d\x01\x1b\xf9\x8a\xe6\x82\xef\xd6\xb4\x99\x40\xa2\xf1\xc9\x43\xa1\xc5\x9a\x3c\xd6\x15\x20\x89\x10\x68\x16\xf1\x79\xb4\x85\x07\xc9\x7f\x7c\x2d\x37\x30\x8e\x42\xcf\x46\xc8\x69\x46\xad\x32\xad\x19\x61\x55\xc4\x2a\x36\x1c\xde\xc1\xc9\x31\xdc\x1f\x9c\x92\x49\x3e\x37\xc4\x3b\x9d\xe9\xcd\xac\x38\x55\x10\x4e\x6d\xd7\x8d\x3c\x28\x38\xf0\xd7\x00\x9d\x36\xd7\xb7\x04\x57\x49\x3d\x48\x29\xd3\x7d\x99\xe4\x30\x5e\xd5\x09\xac\x63\xe0\xee\xa3\x32\xc3\xce\x7f\x08\xf5\x0f\xf8\xa2\x36\xf8\x2c\x44\x60\x8a\x92\x15\xd8\x92\x70\x44\x40\x53\x64\x05\x09\x6c\x32\x0d\x19\xe2\x30\x28\x00\x7c\x90\xc6\xca\x6f\x9b\x60\xaf\x52\xf3\x1d\x10\xa3\xa4\x0c\x8c\x2d\x29\xb4\x7e\x46\xf1\x7a\x62\x83\xed\xca\x37\x17\x50\x77\x66\x1b\x75\xe7\x6b\x9f\xbf\xf0\xdf\xae\xa6\xb0\xce\x50\xf0\xeb\xdb\x8d\x05\xae\xaa\x37\x18\x0a\x5e\x69\xdf\x62\x24\xf4\x81\xfb\xf2\x36\xe3\xb0\x9f\xac\x1e\x46\x64\xdd\x5e\xc3\x92\x53\xba\x8e\xb6\xb5\x2f\x17\xc7\x42\x98\x90\x73\x67\xf6\x1a\x53\xee\x0a\x5e\x9f\xc1\x10\x8e\xc3\xc5\x02\xc9\xfe\x59\x55\x85\xc7\x5b\xe6\x60\x8e\xf4\xa7\xff\x6b\x67\xec\xff\x5b\x47\x6c\x8a\xbf\xec\x51\xdd\x39\xc3\x44\x43\xc9\x3d\xd8\x25\xbc\xbc\x52\x35\x46\xf3\x5a\xa5\x84\x4b\x39\xe4\x94\x4a\xc9\x09\xbe\x62\xc8\x02\xc0\x12\x69\x54\x9d\x8a\x7d\x07\x27\xc7\xe4\xb5\xf9\xf9\xe0\xe4\xf8\x4c\x7d\x82\xb4\x4a\x5f\xe0\xe3\x28\x68\x69\x45\xc1\x8e\x9f\xdb\x0b\x25\x27\x18\xdd\xa2\x0b\x12\xc8\x02\x70\x7b\x07\x93\x02\xfd\x8c\xb0\xed\x42\x1c\x0f\xff\x36\xd1\x35\x11\x2a\x25\x98\x08\xca\x8b\x5f\xab\x4f\xad\x20\xf4\x0f\x56\x97\xa4\x17\x2b\x49\xad\x00\x2d\x04\x40\x84\x17\x73\x56\x8e\x0e\x4e\x8e\xd1\x17\xd6\x56\xdd\x33\x5c\x09\xdd\xe7\x81\x0b\xaf\xfa\x34\x95\x0b\x83\xe8\x5f\x5f\x37\x79\x4f\x37\x9d\xbd\x53\x6c\x7d\xf5\x04\x76\x60\x6d\xec\xc8\x4f\x53\xfc\x96\x60\xb6\xc2\x02\x29\xc6\x0a\x4f\x37\x62\xfb\x30\x0c\xfc\x97\x64\x7e\x49\x71\x2a\x94\x19\x37\xe5\x39\x07\x17\xd8\x0f\x0d\x23\x51\xe2\x3c\x8b\xf1\x54\x36\x72\x0c\x58\x99\xb2\x15\x7a\x32\x41\x2c\xca\x8d\xe6\x0c\x21\x9c\x7d\x39\x0c\x68\xfa\x42\xb5\x64\xe3\xe7\x3a\xb3\x07\x19\xc1\x74\xb3\xcf\xdd\x38\x81\x6f\xfb\x98\x68\x00\x2b\xea\xe4\xca\x08\x49\xd6\x85\x44\xf3\x7b\xb8\x7c\x67\xf8\x00\x7e\x78\x58\x17\x64\xed\xba\x61\x65\x74\xa1\x5c\x8a\xba\xb3\xc3\xff\x75\xf6\xe1\xe5\xc9\xc1\x61\x8c\x06\x84\x75\xf9\xa6\x1e\x10\x88\x90\xfa\xd4\x52\x4a\x13\xe6\x53\x77\x02\x71\xdc\x97\xff\xfd\x1e\x8d\x8b\x37\x96\xad\xf0\x0f\x7b\xd1\x60\x23\x92\x08\x4f\x41\x5b\x7e\x07\xfe\x3f\x08\x9e\xe2\xa7\x3b\x5c\xef\xb6\xef\x9d\x3f\x05\x3b\x47\x4b\x38\x59\xd4\x8d\x08\xb1\x36\x33\xd9\x39\x6a\xdf\x4a\xe9\xaf\x4b\x35\x5f\x84\x5e\xb4\x18\x45\xbf\x19\x51\x20\x11\x98\xbe\xfb\x2c\xc8\xb7\xcd\x5e\x25\x2e\x1b\xe1\xd0\xf6\xca\x3d\xbd\x7f\x3f\xf7\x98\xe2\x2f\xe0\x18\xf0\x35\x7c\xfe\xec\xab\x1b\x82\x9d\x09\x0c\x6d\xb0\xf8\x0f\xd7\xe1\x63\x11\x4a\xc1\x54\x37\x94\xed\xce\x57\xe3\x1f\xef\x46\x05\x71\x48\x99\xa2\xf8\x82\x0b\x83\x38\x6a\xbf\xfe\x06\xfc\x34\x7d\x61\xf7\x22\x2a\x99\xa9\x35\x78\xce\x7e\xfc\x47\x35\xeb\x3e\x83\xb0\xdb\x4e\xfc\x7d\x89\x68\x0c\xb5\x38\x57\xe2\x9e\xac\x75\xbd\xb4\x5a\x90\x28\xca\x2b\x73\x6f\x20\xc0\x74\xe0\xfc\xef\x17\xf3\x11\x20\x81\x51\x52\x69\xc2\x46\xfc\x3d\x38\x8b\x81\x0d\x66\xef\x1e\xb2\x81\x7b\x7f\x18\x8a\x67\x51\x5d\x6c\x00\x31\x4a\xcd\x1c\x56\x04\x26\x7c\x0f\x3c\xff\xad\xf0\x57\x5e\x5c\xa8\x06\xdc\x61\xc5\xbd\x57\xaa\x99\x95\xc6\x40\xc0\xa8\xaa\x4b\x55\x20\xf6\xe4\x3d\x38\x01\x6a\xf0\x32\x28\x5b\x73\x87\xc0\xc5\xa3\xf8\x01\xcc\x31\xa1\x0a\x34\xee\x81\x3c\x6f\xdb\x2e\xeb\x8b\x6a\xe9\x11\xeb\x01\x32\x5a\x0b\x09\x18\x00\x50\x37\x58\xa8\x00\xc8\xc2\xe5\x7e\x33\x46\x48\x1f\x8e\x85\x50\xe8\xcb\x79\x39\x86\x00\xbc\x6b\xdd\x5c\x1a\x0a\x9f\xac\xb7\xe3\x09\xa4\x00\xc7\xd1\x88\xad\x67\xf5\x92\xc0\x33\xd1\x34\x28\xc9\xea\x09\x18\x8e\xb2\x29\x0d\x22\x62\xe0\x27\x56\xcd\x34\x3b\xa3\xd1\xf9\xe2\xe2\x6f\x65\x55\xc9\xe1\x4c\xe3\xbf\x56\xd3\x34\x53\x7d\xfd\xe1\x7c\x71\x31\x1c\x5f\x94\x4f\xcb\x62\xef\xf1\xc3\xdf\x7e\xff\xf8\x37\x71\xac\xe2\x77\x09\x0e\x16\xa2\x5f\x2d\x8c\x2a\xb6\xd5\x27\x30\x50\x95\x76\x11\xbf\x1b\x31\x08\x05\xd1\x86\x63\x84\xc8\x11\x42\xaa\x4c\x5e\xf9\x26\x30\x02\x70\x5d\x0b\x5f\x68\x0e\xfa\x9d\x64\xf6\xe1\xe6\xa2\x67\x98\xf0\x5c\x35\x35\x31\x83\xe7\x8d\x9e\xbd\x82\x7c\x00\x9e\x2d\x84\xe4\x3c\x88\x36\xda\x20\xea\xf3\x20\xdc\x2d\x91\x0f\xd1\x6b\x1f\x03\x20\x9b\x76\x20\x54\x5d\x7c\x21\x27\xa1\x8f\xf0\xe8\xa3\x03\xe5\xe4\x13\x6a\x34\xd6\x85\x42\x63\x6e\x59\x17\xea\x13\x39\x8a\xf4\x57\x75\x65\xcb\xdb\x82\x95\x08\x4e\x09\xf0\x8f\x71\x43\xf9\x38\x40\x4a\xf9\x4e\x7c\x54\x75\xe1\x5a\xe5\x16\x44\xdf\x8d\x27\x1e\x0c\x9f\xd5\xaf\x03\x8c\x2e\xb2\xfe\x02\x58\x98\x28\x6b\x71\x21\x9b\x73\x79\x61\x2b\xb3\x9b\x14\x53\xf8\x31\xe2\xab\x4b\x7b\xfb\xd7\x85\x69\xc5\xb8\x91\x66\xca\x55\x1e\x7e\xa2\xbc\x7b\xb0\x73\xc0\xea\xaa\x4c\x4b\x01\xfe\x31\xc3\xfe\x85\x56\xca\x71\xfd\x18\x14\x88\xd2\x6b\xc0\xc9\xb5\xfd\x88\x9f\x28\x38\x97\xfd\x6f\x98\xba\xb7\x30\xf5\xcf\xa0\xbd\xf0\xf3\xe0\x25\x6b\xe6\x91\xc0\x20\xf6\xfc\x99\xc5\xcf\xbd\xc8\xe5\x22\x8f\xef\x08\x2c\xb6\xb3\x2a\x53\x04\x08\xb9\x41\xe9\x2c\xde\x61\x82\x0a\x18\xb0\xe8\xfb\xf7\x99\xae\x98\xd3\xdb\xa3\xc9\x21\x20\xae\x10\x57\x42\x19\x82\xe7\x89\x66\xf0\x81\x48\x4f\x1d\x91\x80\x58\xbb\x6e\x44\x47\x91\xed\x48\x74\xe2\xdc\xb6\x1f\xb8\x3a\xae\x17\xd1\x29\x95\xea\xbc\x9b\x4a\x63\xc2\xd5\xb7\xe7\xfb\xf1\x9f\xb2\x5a\x28\x27\x81\x65\xaa\xee\xf3\x9a\xa4\x3a\xcd\x1e\x85\xed\x87\x0d\x44\xa0\xd2\x41\xd6\x02\xca\xfa\x8b\xf0\x15\xb6\xa6\x8f\x90\xde\xb3\x35\xa4\xcd\x21\xc0\xe4\x47\xdb\xd4\x47\x36\x20\xc6\xf4\x93\x01\x90\x54\x9f\xe2\xdc\xbf\x37\x93\x4a\x22\x20\xb9\xee\x1d\x45\xac\x05\x90\x81\x59\x9b\xa4\x44\x71\x70\x63\x03\x60\xcf\x10\xae\xae\xc6\xba\x2e\x44\x5b\xce\x94\xb8\x2a\x4d\x89\x97\x34\xbe\xbe\xd2\xa5\x89\x9b\xc2\x3d\x5a\xa6\x36\x8c\xb6\x0b\xf4\x59\xad\xe7\x03\xe7\x66\x14\x64\x69\x80\x0a\xaf\x64\x55\x16\x81\x30\x67\xbb\xb3\x4a\x32\x81\x34\x26\xea\xc7\x85\xac\xf0\xd2\xa4\x34\xa4\xad\xf9\xea\xec\x07\x50\x0c\x25\x60\x23\x1e\x42\xa8\x22\xa9\x3a\xd2\x28\xcb\xf1\x7c\x56\x3b\x74\xd4\x2c\x30\xa6\x6d\x18\x2f\x36\xce\x69\x6e\x67\x84\xeb\xd7\xd9\xa6\x0f\x1e\x64\xf8\x8d\x2b\x75\xd2\x91\xed\xe3\x7d\xb9\x41\x73\xe9\x76\x8c\x1a\x24\x1e\xc6\xc5\xba\xcd\x85\xdb\x2f\xd7\x58\xb4\x29\x22\xfd\xf4\xee\xa6\xbb\x82\xa8\x38\x56\x4c\xb3\x74\x3f\x4c\xcb\xf8\xac\x35\xab\xf7\x55\x64\x2e\x08\x37\x56\xb2\x7b\xbe\xb0\xa0\x4f\x33\xbc\x67\xcf\x04\xcb\xa9\x60\x0a\xe0\x57\x0a\xbc\x98\xe4\x1f\x99\xcf\x55\x3d\x14\xfd\xb7\xf0\xd0\x03\x32\x82\x0f\x23\xac\xe6\x08\x8d\xc6\xa8\x4e\xdb\xa1\xf4\x1c\xc0\x06\xe6\xda\xad\x96\x9c\x4e\x0d\xdd\x22\x18\xb3\x13\x06\xbf\x75\x93\xe4\x83\x9d\xa3\x28\x69\x94\x4b\xee\xd0\x1a\xee\xd8\xff\x39\x50\x3f\x92\x61\x8e\x00\x91\x4d\x81\xf1\xa0\xde\x3e\x3a\x64\xaf\x4e\xc3\x89\x7c\xd8\x0d\x15\xb7\xc8\x84\xbc\x35\x61\xcf\x50\x62\x26\xc8\xb3\xcb\x9b\x31\xca\x4a\xbc\x23\x8e\x0e\x1f\x3d\x7c\xc0\x55\x20\xbb\xf0\xea\x16\x5f\x1a\x9f\x03\xf6\x2a\xb8\x54\xa0\x8c\xef\x1d\x5f\xe1\xde\x59\x7d\x6a\x41\xac\xc1\xbc\xc7\xec\xc6\x19\xe4\x10\x54\x57\x76\x96\xdd\x48\x8e\x0e\x07\xa2\x44\xa4\xb8\xd6\x89\xea\x94\x44\x19\x02\x1c\xe4\x6c\x26\x5b\x92\xbf\xc9\x57\x5b\xba\xe1\x04\xea\x90\x38\x9b\x2e\xcc\xc0\xa1\x7a\x1e\x1d\xda\x4a\xae\x54\x03\x62\x29\x4c\x10\xe5\xfe\x10\xba\x2a\xc4\xd1\x21\xe4\x3f\xf6\xfe\xdf\x7a\xd1\x64\x26\x66\x63\x63\x52\x72\xc3\x4a\xdc\x29\x16\x9f\x8c\xd7\x77\x41\xaf\xe7\x52\x01\xee\x4d\x46\xa3\x5d\x03\x81\x73\x83\x8a\xdc\x77\xe6\x12\x27\x55\x01\x46\xef\x85\x02\x14\x65\x92\x4e\x9f\x81\xd2\xa3\x9b\xfe\xd6\xfb\xe0\x30\x0d\x25\x2f\x70\xd8\x99\x95\x75\x9f\xfa\x3b\x24\x11\x9a\x60\x3b\x63\xb1\x8c\xcb\xf0\x26\x74\x09\x94\xc5\x53\xaa\x70\xa7\x5b\xa1\xaa\x8b\xa0\x3a\xd2\x65\x0f\xc5\xa3\x47\x02\x92\x43\x11\xa9\xb8\xe1\x22\x15\xb2\x57\x0f\xd3\x3c\x38\xb9\x02\xf5\x11\xf1\x0d\x19\x65\xb8\x9c\x67\x08\xc6\x70\x90\x38\xec\x1b\xe5\x60\x9e\x8c\xd5\x1a\x95\x00\x2b\xc1\xb0\x63\x4a\x18\x52\x0b\x10\xf6\x6a\x47\xf3\x07\x3b\xee\x50\x10\x6c\xd5\x6c\x2e\xf6\xec\xd3\xdd\x3b\x9e\x21\x43\xe1\xdd\x3b\xe1\x81\x60\x0b\xc6\xcb\x69\x5f\x1c\x4b\x70\xbd\xde\x5b\x63\x32\x43\xe2\x81\xd2\xe1\xe4\x6f\xfc\xa5\xed\xf0\x6e\xc4\x3c\xe9\xd3\xfb\xf7\x7d\x3d\xa1\xc5\x6c\xa5\xed\x04\xce\xa7\x9c\x49\x04\xde\x06\x55\x0f\xd9\xbe\x9c\x37\x8a\x74\x8a\x7b\xbb\x59\xc6\x30\x02\xa5\x5d\x47\x33\x55\xa7\xf2\xab\x2f\x9b\x9a\xde\xfc\xa6\x8a\xd0\x21\xc1\x13\xa9\x83\xa0\xf0\xda\x3e\x66\xcc\x59\xa4\x0f\xa3\x5a\xb0\xac\xf5\xd3\xb1\x0e\x32\xc3\xa1\x2f\x83\xd9\x04\xc7\x9a\x67\x55\x05\x35\x9b\x3e\xdf\x63\xfa\x43\x2d\xa2\xae\xf0\x53\x59\x14\xd8\x1d\xe8\x87\xbb\x4e\x4a\xe9\xb4\x1f\x4f\xd3\xa0\x3b\x15\x11\x6c\xba\x9b\x16\x1e\xdc\xe1\xe6\x55\xdc\xd8\xbb\xdc\xed\xd5\x51\xed\x2e\x99\xbc\x99\x96\x4e\x47\x32\x5c\xc3\x92\xf7\xdd\x52\xf0\x1f\x87\x0c\x51\x06\xdf\x85\xa7\xe4\xbf\x53\xf6\xf2\xf9\xc2\xb3\xc2\x1d\xe7\xc9\x68\x15\x63\xcf\x37\x31\xff\xfe\x50\xfc\x20\x0d\xc2\x4f\xb8\x2f\x86\x7f\x35\x03\x5b\x9b\xe5\x34\x00\x83\x5a\xfa\x3c\xfc\x8b\xb2\x05\x0b\x88\x3d\x6b\x1a\xe7\x64\x3f\x85\x64\xbd\x63\xbd\x00\x87\xaf\x09\x64\x47\x41\xe0\x8f\x3e\xb1\x2a\x5b\x1f\xe5\xe5\x62\xab\x1a\x48\xa9\x48\x6f\x9e\x33\x21\x92\x94\x2a\xd0\x7b\xe7\x28\xdb\x67\x68\x1c\x33\xaf\xa0\x77\x68\x98\xe2\xde\xc7\xe8\xc9\xb9\x3c\x27\xc7\x63\x40\x75\x8b\x4d\xec\x2f\x31\xdd\xbb\x7d\x01\x9b\xbf\x52\xb3\xa1\x7b\x9e\x3e\xe8\x02\xf8\x04\x37\x19\xfc\x45\xdf\x57\xbb\xb7\xc7\xa1\xa5\xae\x2a\x9f\xae\xbd\x55\x9f\xda\x1e\xab\x95\xbe\xbc\x7d\x2c\x1b\x25\xe1\x15\x7c\x42\x2e\x42\x87\x05\xcd\x39\x16\x6b\x16\xaa\x97\x80\xcc\x85\x27\xdf\x51\x3d\xd1\x0d\x86\x79\xf7\xfd\x88\x81\x2d\xa8\xc2\x52\x0e\x72\xc9\x67\x63\x88\x9b\x22\x60\x94\x70\x48\x7f\xf7\xd6\x30\xfc\x60\x27\xfc\x31\x88\xf7\xf1\x6b\x0c\xc8\x5b\x39\xef\xc1\x97\x5b\xe2\x69\xd4\xd1\x6f\x1e\xc5\x6f\x31\x55\x64\x2a\xf7\xfd\x7b\x03\xb0\xac\x2a\x20\xe7\x23\xb4\x89\x06\x7a\x95\x1f\x32\xb8\x40\x3a\x1f\xde\x6a\x29\x2a\x0d\x98\xd1\xdf\x09\xaa\x07\xb4\x3c\x0e\x45\x5a\x18\x35\x59\x54\x88\x29\x3f\xc7\x3c\xf5\xe0\xf2\x38\xa7\xc8\x7b\x8e\x57\x01\x21\x99\xc0\x50\x0a\x3d\xb3\xd5\x91\x5c\x5c\x17\x62\x5e\xc9\x31\x21\x12\x40\xfe\xf6\xb2\x1e\xd8\xc6\x16\x55\x8b\x19\xc5\xc9\xfb\x02\x31\xd4\x6c\x77\x12\xcb\x52\x3a\xc0\x3e\x64\x8f\xcc\xad\x67\x94\x22\xe3\xf9\x06\x2b\x8a\xe8\x18\xa5\x4e\x0a\xaf\x6c\x60\x18\x2c\x48\xf4\xfd\x69\xb4\xde\x6b\xab\x88\x49\xc3\xc1\x5b\xc7\x1d\xb6\xfa\x56\xa7\x63\x70\x25\x1d\x70\xc5\xb4\xc0\x56\x78\x2e\xaf\xa4\xb8\x95\x5f\x59\xaa\x6d\x93\x59\x0e\xca\x0d\x72\x23\xdd\x4a\x55\x37\xf8\x00\x8d\xf6\x35\x5f\x28\x60\x18\x2a\x9a\x18\xd0\xa5\x8a\xe1\x03\x82\xf8\x39\x2b\x0b\x9a\xb2\xa1\x74\x0c\x31\x06\xb4\xa1\x4c\x0a\xe9\x73\xd1\x9d\xa4\xdd\xd0\x66\x12\x94\xe3\x3f\x03\xad\x33\xb6\xa6\xb8\x02\x91\xbd\xe9\xf0\xc5\xe1\xf1\xe1\xcb\xae\xc9\x29\xc1\x71\x0e\x2f\xe7\xc8\x97\x78\xc7\x95\x09\xef\xe8\x2a\x35\x09\xde\x0c\x71\x3a\x5e\xa8\x49\x1b\x16\x6a\xf5\xbc\x53\xe6\x4c\xcf\xfd\x2d\xde\x56\xac\x75\xd3\xec\x3b\x19\xa8\xbb\xc4\xbb\x5c\xa2\xeb\x5a\xb1\x16\x0d\x9a\xcd\xa4\x13\x1d\x4c\xa1\x77\xa8\x10\xf0\x6a\xc8\xde\xd3\x7e\x34\x90\x06\x61\xa2\x87\x76\xb8\x6b\x8a\x9e\xe9\x39\x97\x6c\xf5\x3c\x91\x04\x98\xbf\x85\x2c\x71\x47\xfc\x87\x6a\xd9\x58\xc5\xdc\xed\x5c\x2f\xea\x02\x9c\x7e\x25\x33\x62\xc1\x67\xc5\x80\x4e\x75\xdd\xb0\x63\x76\x78\x5e\x80\x26\x6e\x5f\x6c\xff\x7b\x89\xa1\xe5\x2f\xb4\x06\x1f\x83\x5c\xed\x68\xe3\xb2\xe5\xf0\x13\x3e\x0e\x58\x47\xe7\x4f\x4e\xdd\x25\x42\xf0\xf0\xb0\x2e\x32\x4e\x03\x01\xab\x87\x8a\xf3\x37\x9c\x0e\x97\x1a\x29\xb5\x17\xb7\x04\xa0\x4b\xc1\xd7\x64\x41\x01\xad\x88\x23\x3b\xd1\x21\x9b\x66\xc2\x4d\xce\x30\x3e\xaa\x28\xb4\x3b\x30\x3b\xc0\x17\xc3\x64\x60\x77\x9c\x2d\xa9\x53\xe0\x90\x60\x3c\xbf\x04\xf8\x45\xae\x4b\x7c\xe1\xa1\x78\xf6\x75\xc3\xda\xf6\xea\x0e\x05\xd7\xc0\x38\xc4\xd4\x4c\x12\xdd\xe3\xfe\x9d\x3b\xfe\x90\xa6\xff\x61\x72\x56\x9a\x88\x96\x4e\xd7\xd3\x12\xf7\xca\x76\x14\xe7\xce\x59\x24\x95\x61\x9b\x06\xce\x40\x40\x43\x30\x39\xa7\xaa\xbd\x81\x84\xc2\x75\xc0\xaf\xd9\x68\x29\x08\x70\x13\xb0\x22\x21\x57\xa9\x6e\x66\x14\x86\x60\x68\xd8\x8a\x30\x93\x2f\x54\xfb\x5d\xc7\x8e\xe0\x59\x38\xb4\x94\x98\x12\x42\xe5\x3d\xd6\xd9\xfd\xc2\xc6\xaa\xba\x23\xbc\x8e\xda\xce\x04\x97\xa8\xb1\x5f\x36\xa6\xd4\x1c\x81\xc5\x0a\x71\x97\xc2\x42\xa3\x03\xd8\x06\xb0\xc8\x55\x60\xf1\xdf\xea\xd0\x9f\x49\xe8\xc8\x4f\x4a\x04\x81\x6a\x2e\xcb\x14\xc3\x82\x53\x59\xac\x47\xd7\xb3\x67\x73\x8f\xd5\x0f\xbb\xf9\x60\xac\x2e\x84\xe1\xfe\x7d\xd1\x51\x52\x6c\x29\xf1\xfb\x3d\xf1\xe8\x11\xe1\x2d\x80\xfb\x29\x22\x28\x3c\xa1\xbd\x88\xe3\xde\xa1\x41\xcc\xa7\x56\x13\x79\x9d\x38\xcd\x99\x1d\x9f\x7a\x00\x9d\x0e\x77\x44\x4f\xd7\x38\x8c\x1e\xaf\x2a\x79\x39\x87\xef\xc8\x8f\xb2\x87\x5b\x16\x0b\x86\x7e\x73\x3b\xe2\x5d\xe8\x56\x1b\xe3\xfb\xd0\x13\xe7\xac\xeb\xd1\x61\xfc\xaf\x37\x73\xfa\xdb\x01\xaf\x84\xbf\xdd\xdb\x64\xc2\x7b\xef\x71\x45\x68\x56\x64\x28\xb5\x81\x3b\x04\x5a\x4b\x3b\xef\x8e\x6a\x93\xbe\xaf\xa4\x09\x9c\x42\xc2\x37\x33\xee\x91\xcf\x95\x1b\x7a\x4e\x49\x8f\xef\xcd\xf2\x89\x14\x8b\xba\xfc\x71\xa1\x44\xa3\xe6\x8d\x32\xaa\xe6\xe4\x41\x93\x28\x5b\xa3\xd7\x73\xc9\x4a\x18\xe4\x23\x06\x12\xc5\x0b\x08\x08\x01\x51\x01\x70\x98\x90\x90\x6c\x99\xc4\x66\x1f\x94\x6f\x7c\x38\xc8\xb5\x16\x65\x61\xe5\xf6\xb1\xac\x42\x85\x50\x07\x60\xc3\xe4\x3a\x58\x55\x2e\xff\x8c\xfb\x02\x07\xb4\xc6\x7a\x99\x71\x7f\x5b\xe5\x9a\xe3\x59\x8c\xd7\xcc\x57\x6d\x78\x36\xc1\xac\x14\x48\xd1\x81\x28\xf6\x05\x48\x0e\x22\xcc\x11\xb6\xfa\x1c\x8a\xdf\xe7\x8e\x21\xdb\xbb\x35\x06\xd4\x8d\x2d\xa6\x9d\x1e\x7a\xbb\xd6\x4e\xd6\xda\x35\x88\xca\x9d\x90\x8f\x56\xde\xd4\xc5\x65\x9d\x24\xb7\x93\x33\x71\x45\xa5\xba\x15\x06\x8f\x83\x59\x08\x4e\xc1\x57\x56\x02\xf7\x83\xc5\x1c\xd5\x56\xc7\x83\xf8\x4e\xb0\xb7\xa3\xc4\xde\x71\x9b\x64\x0b\x76\x80\x29\x12\xbb\x72\x9d\x32\xac\x02\xbc\x4b\xe8\xc6\x12\x7b\xdb\x2c\xc6\x34\xa5\xe8\x1a\xbd\x09\x08\xca\x68\x24\x0e\x31\x28\xf5\x5a\x39\xb4\x16\xd1\x00\xae\xb8\x43\xa3\xc7\x3b\x46\x82\xf1\x5b\x58\xa1\x87\xc2\xf4\x8a\x46\x5e\x5c\x04\x69\xbf\xfc\xc8\xfb\x70\x1c\xcf\x08\x2f\x81\x10\x2b\x3e\xe2\x7b\x86\x26\xe1\x90\xc3\xad\xa1\x38\xaa\xc5\x1f\xcf\x8e\x5f\xfc\x6a\x40\x55\xdc\xa1\xb4\xea\x0d\xc4\xbe\x56\x4b\xa1\xeb\x40\x4e\x70\xd2\x43\x3b\x5d\x30\x22\x05\xa4\xf2\xa9\xb5\x93\x52\x39\x11\xc1\x35\x79\xfa\x60\x24\x1f\x63\x38\xb0\x81\xd9\xf3\xaa\xcf\x9f\xbb\xec\x90\x40\xe6\x33\xaf\xac\x0e\xd9\x55\x7b\x6f\xc8\xf8\x78\x02\x5e\x1e\x80\x9e\x6a\x95\x7e\x3f\x59\x60\xc1\xe2\x7b\x2d\x4f\x1f\x61\x42\xca\xd3\x58\x70\xf3\x3b\x27\xe9\x99\xcf\x45\x19\x33\xe8\xcf\x9f\xc5\x5d\x33\x05\xfb\xd6\xe1\x8f\x0b\x59\xf5\xa3\xd7\x83\x4e\x33\x6e\x2c\x29\x9f\x4f\x0b\x92\xfa\x03\x9b\x3c\xa2\x50\xb1\x27\x62\x92\xfd\xe6\x91\xdd\xf3\xaf\xb4\x86\xf4\x2c\xc1\x81\x4c\xdc\x65\x90\x3b\x73\x36\x40\xdc\x41\x21\x24\x6a\x8a\x0c\x5e\x0c\x91\xd5\xdb\xcd\x96\xe1\xec\x05\xc9\x14\x52\x8d\x72\x3c\x5e\xcc\x16\x95\x6c\xd5\xd9\xb5\x7e\x65\xc5\x83\x03\x07\x00\xd2\x8f\xab\xe2\x4e\xb0\xdc\x1c\xbd\x4c\xa5\x6a\x97\x06\x91\xc3\xc2\xed\x46\x41\xb8\x03\xba\x13\x33\xf6\x8c\xfc\xc8\xa2\x04\xef\x16\xd8\x80\x0e\x7f\xc6\x10\xf9\x50\xd0\x25\x58\x38\xf1\x94\x03\x91\x96\xa8\xdf\x9d\x48\x2e\x02\xc4\xbd\x11\xb2\x51\x3b\x20\x1d\xd3\xc6\xea\x5b\x4e\xf5\xb1\x34\x0e\x0c\x8c\x26\xe4\xe3\x16\x96\x8a\x24\xea\x54\xdd\x73\x07\x32\xa5\x0a\x84\x68\x5a\x2b\x45\x27\x08\x42\x80\xea\x31\xe3\x03\xde\xa1\xee\x4c\xb4\x25\x4c\x70\x53\x97\x4b\x43\xdd\x7a\x4e\xbb\xbf\xa3\x5a\x4e\x4a\x55\x15\x46\x48\x23\xae\x15\xa0\xd3\xe0\x08\xcc\x30\xfc\xce\xea\xe3\x63\x5d\x55\x72\x6e\xb9\x41\x24\x3a\xb8\x32\x98\xfe\x00\x19\x1a\xeb\x1a\x18\x5b\x1f\xb0\x51\x02\x04\x40\xa1\xd1\x93\xed\x4e\x24\x53\x0e\xec\x02\x47\x18\x52\x3b\x3e\x61\xc9\x4f\xc4\xa9\xa2\x10\x0c\x3d\x8e\x13\xe6\x61\x91\x21\x85\xb7\x82\x6b\x4d\x27\x33\xc7\xd3\xcc\x07\x4e\x70\xde\xc9\xbc\x8c\x0c\x34\x07\x27\xfb\x6f\x9c\x85\x26\x57\x57\xb6\x0a\x7d\x5d\x2b\x17\xc2\xb2\xeb\xdc\x00\x1a\x39\xbe\x74\x07\xa1\xac\xc2\xa0\x64\x04\xdb\xa6\xa8\x63\xb7\x19\xc0\x1f\xa6\xd6\xb5\xc2\xf7\x03\x04\x62\xe5\xfa\xec\xe9\xc3\xa0\x43\x0c\x4b\x05\x79\xce\x9e\xfc\xfa\xc9\xef\x86\xce\x52\x77\xd7\x4e\x9b\xe5\x7d\x6b\x03\x76\x02\x91\xde\xce\x73\x37\x08\x25\x4c\x14\xeb\x2f\x1c\x61\xbc\xe4\x75\x11\x24\xcd\x78\xea\x2e\x02\x1b\x3d\xe3\xfc\x26\xdf\x3c\x0a\x53\x8e\x88\x1d\x92\x82\x98\x7b\x5d\x97\xe0\xb6\x19\x25\x73\x71\x9d\x70\xd3\xe7\x94\xe2\x20\xec\xde\x9e\x1d\x70\xe6\x0d\x9d\x36\x62\x54\xa0\x3f\xec\x38\xd3\x16\x06\x84\xa5\xdb\xbb\xef\x87\x01\x10\x78\xfe\xe7\xba\x2b\x80\xc8\x65\xbe\xab\x46\xf8\x4a\x76\x57\x95\x73\x2a\x45\x9a\xdc\x11\xff\xcb\xab\x17\xce\x4a\x97\x77\x94\x71\x43\x07\xbd\xca\x8f\x7c\x95\x9e\xb3\xbe\x63\x71\x99\xf5\x1d\x8a\xba\x31\x1a\x89\x03\x90\x36\xe0\xac\xf7\x18\x50\x68\x39\x0d\x65\x28\x96\x9f\xe8\x56\x60\xe6\xe1\xa5\x7c\x55\x46\xcd\xa4\x55\x33\x0c\xab\x43\xc4\x52\x43\xfe\xdf\x59\x7b\xaf\x15\xfa\x59\x08\xf5\xb2\x38\x92\x32\x3f\x89\xa1\x46\xba\x93\x6d\xe0\xcd\x7c\x45\xf5\x41\xd0\x56\xb0\x8b\xbe\x46\x48\x0d\xe6\x74\x7f\xda\xe8\x19\xba\xae\x1d\x1d\xe2\xdc\xd6\xba\xde\x76\x39\x3f\x78\x92\x23\xd1\xaa\x74\x02\x37\x20\x61\x04\xd3\xaa\x67\xaa\x2d\x67\x10\xae\x83\x70\x0c\x53\x69\xea\x5e\x6b\x85\xd1\xc3\x1e\x07\xac\x92\x04\xba\x00\x8b\x91\x6e\x0a\xb6\xf7\x35\xca\xcc\x51\x4c\x15\x2e\xf6\xf5\x52\x61\x1a\x11\xdc\xa1\x1e\xaa\x03\x50\xda\x41\xc8\x22\x34\xe9\xd2\x8c\x6d\x7f\x4b\xb7\x6c\xa3\x91\xaf\x88\x63\xa8\x53\x2f\x8b\x04\xec\x13\x2a\x43\x64\x7d\x3f\x58\xd3\xca\x76\x61\x7c\x5d\x78\xbe\x01\x9a\x9a\xed\x9c\xaa\xdb\x66\x49\x38\x1c\xee\x1b\xca\xc0\x4b\x65\x09\x4a\x01\x5d\x97\x00\x61\xcf\xd7\x06\xc8\x0b\x03\xf6\x6e\xc6\xb6\x75\xed\x3f\xa1\xe3\x98\x8e\x74\xa0\x14\x3d\x11\x53\x5d\x01\xee\x36\x96\x89\x6a\x1b\xe0\xd4\xcf\x16\x55\x5b\xce\x2b\xe5\x6a\x0a\xf2\x02\x20\xee\xa4\x6d\x92\xb4\x00\x85\xdd\x10\xa5\x19\x06\xdc\xd1\xf9\x5b\x1a\x0d\x0e\x45\x72\x3e\x6f\xb4\x1d\xb6\x3d\x53\x8e\x0e\x1d\x08\xe2\x80\xa1\x2d\x44\xa3\xa4\xd1\x75\xec\x9f\xe8\x88\x3b\xb5\x9a\xc4\x3c\x74\x95\x21\x2b\x66\x8a\xd1\x9e\x8a\x3c\x5b\x27\xb2\xaa\x0c\x27\x27\x4d\x9b\x66\x43\x4f\x67\xc3\xa1\xcd\x67\xe7\xe7\xdb\x53\x5f\xee\xe4\x75\x95\x20\x31\x06\xe6\x49\x9b\xc8\x31\x81\x23\xe5\x60\x3d\xae\x9f\x40\xac\xc4\xd9\xeb\xd1\xd8\x98\x27\xdb\x1e\xe6\x7b\xf4\x6f\x71\x7a\x86\x6d\x57\x59\x54\x8d\xd9\x19\x8d\x0a\x7b\xe6\xe9\xb9\x6a\xa2\xf0\x0b\x55\x6f\xbf\x39\x1d\x15\x7a\x6c\x46\x6f\xd5\xf9\xe8\xd9\xab\xa3\x51\x5c\xa3\x93\xd6\xe2\xc7\x47\xae\xd3\x49\x6a\x96\x97\x72\xa6\xf0\xa2\xd7\xaa\xf9\x0a\x45\xc3\xb3\x32\x7c\x38\x37\x6a\x51\xe8\x43\xbe\x66\x82\x4b\xe1\x70\x42\x12\x65\x9d\xd5\xc9\x7d\x48\x20\x23\xf6\x39\x8f\x0c\xec\x2c\x86\xd3\xe4\x42\x28\xdc\x38\xbc\xc1\x0e\xc8\x08\x97\x23\xa7\x20\xfa\x07\x8d\x4c\x93\x25\x87\x18\x92\x32\x80\xb2\xd6\x0d\x06\x04\xf1\x32\x83\xdf\x89\x1f\xa1\x9b\x8a\x11\x7f\x5f\x6b\x56\x70\x2f\xe3\x19\xee\xc7\xe3\x1e\x24\x5d\xdf\x4c\xac\x25\xc2\xeb\xe8\x88\x00\xf0\x64\xa7\x6a\x20\x7e\x62\x33\xa0\x65\x75\xea\x97\x8b\x0b\xbb\xb8\xfb\x95\x34\xa6\xbf\x62\x80\x83\x55\x24\xb5\xf5\xd5\x9b\xa3\x2a\xe7\xe7\x5a\x36\xc5\xb6\x9c\x97\x66\xe4\x48\x77\x9f\x9f\x67\x49\xd7\x7d\x85\x70\xde\x5e\xa3\x50\x57\xdd\x2c\x83\xbd\xa8\x34\xd8\x07\x91\x58\x9e\xd2\xc2\x47\xef\x9d\x08\x1a\x3f\xee\xf2\x80\x7f\x55\x92\x8f\x57\xe6\xbf\x20\xc9\xc7\x03\x1c\xac\x22\xc5\x3c\xc9\x83\x72\xb1\x01\xdd\x1f\x9c\x1c\x6f\x83\x4a\xb3\xfd\x64\x1b\x15\x63\x4f\xfb\xbe\x8e\x94\xee\x1b\x55\xc9\x56\x15\x38\xa8\x7f\x2d\x36\xfc\xe6\x68\x2d\x55\xfa\x39\xfb\x45\x28\x92\x5a\xff\xc5\x28\x92\xeb\xcf\x53\xa4\x1f\xdc\x20\x47\x1c\x01\x25\x7e\x1c\x4f\x65\xb3\x0f\xd1\x0b\xee\xce\x08\xef\x9b\xd1\x8e\x2a\xee\xb9\x68\x42\x31\xd6\x85\xba\xc7\x30\xd4\x46\x4e\x00\xf1\x6b\x61\x94\x03\x12\xfe\x78\x0a\x4b\x3f\x9c\x34\x7a\xb6\xcf\xf5\x0e\xc5\x33\x23\xcc\x62\x3c\x1d\xa0\xe8\x79\xa9\x96\xce\x23\xab\x41\x20\xeb\x02\x7d\xe5\xcb\x9a\x4d\x60\x61\xac\xff\xbc\xd1\xc5\x62\xac\x84\xa4\x48\x1c\xdf\xe3\x81\x47\xa1\x56\x9f\xc6\x6a\xce\x37\x05\x1c\xe7\x03\x00\x9e\x43\xbe\xdf\x3a\x93\xe7\xdb\x56\x78\xb7\x8a\x0c\xa5\xf8\x54\x05\x28\x3e\xae\x65\x87\xb5\x08\x56\x11\xcc\xb6\x16\xb6\x67\xab\xb2\x73\xb4\x98\x41\x1c\x22\xe7\x9d\x0f\xa3\x09\x7c\x6f\x5b\x79\xbe\xed\xe7\xae\x74\x7e\x0e\x9d\xcb\xad\xdb\x11\x3a\x5f\x63\x30\x82\xc1\x4b\x36\x64\x86\x33\xe3\xe2\x7f\xbb\xf1\x8f\x08\x8c\x4e\x05\xfb\x9d\xe4\xb5\x60\x29\xa7\xb7\xec\x3c\x76\xa9\x96\xfb\x14\xb9\xe2\x8b\x0f\xe9\xa9\xf7\xf8\xe0\xcf\xf0\x42\x2d\xad\x58\xb8\x6a\x93\x7a\x7c\x6b\xce\x3d\xeb\x79\x10\x9d\xa1\xda\x70\x5c\xac\x75\xc0\xd2\x6e\x83\xea\x83\xfa\x93\xbc\x90\x65\x6d\x5a\x80\xb5\x43\xb2\x73\xa6\x2b\xdf\x2e\x44\x02\xde\xbf\xef\x07\xb4\xb7\x27\x1e\x3d\xf1\xea\x46\xd0\xc3\x47\x4f\x02\x4f\x9f\xc4\x49\xe4\xe8\xf0\xb7\xbe\x83\xce\x10\x1b\x11\xa6\x55\xb4\x5c\x57\xc0\xb4\x14\xa5\x03\x03\x37\x80\x74\x52\xdc\x84\x06\x19\xcd\x10\x19\x32\x24\x51\xd8\x3e\x56\xa3\x6b\x14\x19\xa2\xcb\x3a\x68\x7a\xe4\x5a\x1d\x38\xfd\xb8\x9d\xaa\x19\x85\x12\x1c\x2f\x4c\x8b\x17\x4e\xfe\x9d\xe8\xdb\x16\xb6\x7c\x13\x6e\x72\xf9\x72\xc7\x75\xf2\x0f\x7b\xe2\xc9\x63\xf1\xf9\xb3\x88\xe6\xd4\x4f\x21\xeb\x52\x01\x01\x85\x16\xfb\x87\xa1\xb9\x9e\x09\xd7\xdd\x50\x17\x96\xff\x8c\x01\x75\x1d\xae\xb0\x60\x02\x3f\xe2\x64\x99\xaf\x57\x75\xfe\xa4\x96\xfe\x30\xfe\xb7\x3f\xa9\xe5\x07\xc8\xa8\xe8\x0e\x4f\x77\x13\x80\xc0\xaf\x76\x20\x87\x66\xbc\x23\x7a\x87\x66\x2c\xe7\x98\x98\xe2\x74\x2e\xc7\xea\x5c\x36\x3b\xa2\x27\xe0\xc1\x0b\x70\x91\xeb\x3d\x6b\x1a\x7d\x6d\xff\x86\x87\x90\x43\x05\x1e\xbd\xc1\x1c\x2a\xaf\xcb\x8b\xa9\x2b\x06\x3f\xe0\x31\x65\x77\x81\xa7\x07\x9c\xdd\xe5\x00\xb2\x5b\x1c\x40\x22\x3a\x78\xf0\xb6\xb4\x85\x4e\x4e\xe1\x07\x65\x2b\x8a\x7c\x1b\xee\x08\xf1\x6c\x3e\x37\x99\xc7\x2e\x51\x0a\xfe\xf1\x42\x53\x6a\xa2\x63\xfd\xb7\x57\xbc\xca\x7f\x52\xcb\x1d\xd1\x7b\x53\xd3\x79\x5c\xaa\xa2\x17\x4a\x06\x90\xfe\xa3\xc2\xb5\x81\xfb\x87\x4a\x5d\xc8\xf1\x32\x20\xea\x56\x87\xcb\x64\xbf\x81\x6b\x39\x33\x57\xe3\x52\x56\x48\xa7\x86\x6f\x4b\x06\x60\xa9\x46\xd0\x54\xf2\xdf\x20\x93\x07\xac\x8d\xa8\xe4\x52\xa3\xbf\x11\xb1\xbc\x5f\x6e\xbd\x5b\x1a\x99\x3a\xd3\x7e\xc5\x7b\xbf\xed\xed\x88\xde\x0f\x72\x7c\x69\xec\x52\xc3\x6c\xf5\x7e\x67\x9f\x9d\xc9\x73\xfc\xf5\xe8\xb1\xfd\xb9\x5f\x29\xd9\xd0\x83\x27\xf6\xc1\xa1\xcb\xd7\xd4\x7b\xf4\x6b\xfb\xe0\x74\x5a\x12\x3d\xf4\x1e\xfd\xa6\x47\xab\xd3\xe8\x8a\x1e\x41\x43\xcf\x2a\x2e\x01\x6d\xbc\x72\xb9\x74\x7a\x8f\x1f\xc2\x27\x72\x6e\xdc\xaa\xf5\x1e\x43\x35\x01\x39\xf6\x9e\x40\x5f\x04\xfd\x78\x82\x75\x5c\x28\x22\xbb\xde\x93\xef\xf9\x89\x23\xaf\xde\x93\x5f\x61\x6f\x0b\xfa\x09\x7d\xfd\xa3\x9e\x71\x8d\xd0\x46\x4c\xcf\xbd\x27\xbf\xed\x25\x14\xdd\x7b\xf2\xbb\x5e\x97\xa0\x7b\xdf\x3f\xec\x75\x08\xba\xf7\x3d\xb4\x78\x54\x1b\xd5\x70\x31\x68\x34\xa0\xf1\xde\x23\x9c\xd5\xe7\x8f\xf8\x27\x8c\xe5\xf9\x63\xfe\x09\x03\x79\xfe\x84\x7f\x42\x8d\xcf\xbf\xe7\x9f\x50\xdd\xf3\x5f\xf1\x4f\x18\xc2\xf3\x5f\xf3\x4f\xe8\xfc\xf3\xdf\xf0\x4f\xe8\xf8\xf3\xdf\xf2\x62\x42\x8f\x9f\xff\x8e\x7f\x3e\xc2\x6e\x3c\xe4\xdf\xd4\x2d\xee\xd7\x63\xec\xd7\x23\xee\xd8\xf7\xd0\xb1\x97\x8b\x99\x5f\xa5\x47\x38\xde\x64\xcb\xf5\x1e\x3f\x86\xa2\xc7\xaa\x95\xbd\x75\xa2\xf7\xed\x4e\x7f\x96\xb1\xc3\xd3\x1f\xb8\xe5\x0d\x07\xff\x9f\xd4\xb2\x7b\xe6\x43\x9c\x76\x7c\xb2\x07\x5e\x9a\xae\x09\x51\xd6\x81\x2b\x10\xb2\x65\x7f\x0a\x9d\x2f\x9d\x80\x23\x8a\x85\x42\xd4\x14\x8c\xc8\x4e\xae\x2a\xc1\x6f\xf1\x5a\x37\x97\x60\xcd\x6c\xe4\xa4\x45\xa6\x31\x21\x80\xf3\xa1\x17\x04\xca\x46\x3d\xd7\x9f\x7c\x0d\x86\x46\x69\x8f\x57\xce\x89\xf9\x31\xe1\x6a\x1f\x39\x82\x92\x6b\xf1\x07\x5b\x20\x55\xf6\x6b\x3f\x73\xad\x16\x1f\x43\x46\xf8\x71\x2b\xc8\x35\x3f\x74\xd7\x54\x97\xc0\x2d\xc2\xe3\xe2\x5d\x32\x6b\xef\x21\x1e\x24\x7e\xe6\x51\xdd\xec\xf7\x77\xf7\xf6\x12\xa6\xdb\xb9\x22\x73\xdf\x7c\x09\x04\x01\xca\x4b\x93\x15\x3b\xec\x8c\x0c\xc4\x5c\x57\xcb\x09\xe6\x18\x11\xb3\xc5\x78\x8a\x68\x33\x68\x4c\x16\x63\x59\x0f\x33\x0b\xed\xa3\x59\x5c\x42\xb4\xf0\xa6\x34\x90\x4d\xd6\x0a\x8e\x5e\x72\xb3\x72\xb6\x62\xe9\x01\x80\x41\xd4\x78\x5a\x53\xec\x2b\x84\xf4\xc6\xb2\x76\x57\xfa\x1e\xfb\x94\xfd\xe0\x93\x02\x88\xd1\xe8\x15\x68\x49\xcc\xa3\x15\x0f\x44\xad\x09\xed\xbd\x23\x20\x51\x98\xf4\x30\x27\x93\x90\xc4\x22\x9e\x32\xeb\x16\x3b\x22\xa3\xb6\x38\x99\x67\x8b\x31\xe2\xd6\x4e\x1e\x24\x69\x4b\x57\x3f\x2a\xb1\x98\xf7\x82\x4d\xf5\x16\x6e\xb0\xe0\xf6\x2a\x3d\x03\x5d\x06\xd9\x48\x0d\x9b\x29\x59\x53\x6e\x76\x25\xc7\x53\xae\xc7\x1f\xc7\xb0\x1f\xed\x31\x0b\xf9\x86\xec\x69\xeb\x36\x3f\x1c\xc5\xa4\xcd\x2c\xea\xf2\x4a\x35\x46\x56\xa1\x10\xea\x70\x00\xc3\x93\x31\x25\x6e\xdb\x0c\x10\x78\x4c\xbf\x09\x84\x5e\x9c\xdd\x34\xb0\x73\x44\xc7\xf2\xd7\x9b\x3a\xa2\x6a\x52\x6b\xc7\xa5\x95\x69\x02\x56\x67\x19\x70\xa5\xc7\x94\xc8\x93\x4d\xd3\xe3\xb6\xa9\x40\xfa\xe1\x07\xc6\x9e\xd8\xd1\x13\x59\xc5\xbf\x67\xaa\x95\xd1\x83\x46\xcd\x95\x6c\xfd\x6f\xdb\x4a\x15\x98\xbf\x11\x68\xc6\xce\x50\x73\xda\x42\xc6\x37\xee\x56\xf4\x78\x80\xbb\xfb\x05\xca\x56\x47\xde\xae\xef\xc8\x75\xa5\xad\xd2\x2e\xbe\xd7\x8b\x7c\x5e\xa8\x45\xd5\x22\x87\xe5\x74\x87\x64\x61\xb1\x9b\x2b\xd1\xf0\xd1\xd5\x53\x4f\xfc\x86\x73\xe4\x96\xe1\x99\x9e\x2d\xbb\x9a\x4b\x13\x08\xed\x1c\x59\x0f\x67\x42\x25\xc7\xc8\x9d\xc8\xbf\x6d\xa9\x5a\x31\x29\x6b\x59\xd1\xb6\x6f\x3b\x87\x03\x2a\x32\xb2\x5e\x8a\x99\xfc\xab\x97\x03\x87\x28\x55\xba\x26\x11\x1f\x04\x87\xed\x55\x3c\x75\x13\x3b\x0b\xb1\x9a\x62\x46\xa6\x88\x85\xf9\xbb\x25\xaf\xac\x90\xc7\x31\x11\xff\xda\xa5\x70\xfb\x30\xbf\x12\x56\x2a\x1a\xbd\x99\x6f\xbe\x16\xf3\xe9\xd2\x80\x47\xac\x63\x0f\xa0\x8f\x85\x8c\xb6\xcb\x19\x7c\x45\x28\x62\x3b\xb7\x5b\xcb\x68\x4c\x2f\x65\x35\x5c\x19\x63\x8f\xd4\xe4\xf0\xcb\x49\xe5\x87\xe2\x99\x31\x8b\x19\x5a\xea\x24\xa0\x26\x80\x8f\xf1\x9b\xd3\x55\x35\xcd\x1b\x7d\x55\x42\x48\x9d\x30\x8b\x66\xde\x94\x06\x11\xcc\xe4\x78\xbc\x68\x64\x0b\x69\xc7\xe7\x80\x9a\xa1\x1b\x5b\x8d\x9d\x88\xc3\x85\x15\x59\x64\x8d\x9d\x1c\x72\x55\x07\x0b\xc5\xb6\x9c\x01\xb5\x5c\xa9\x49\xcb\x60\xf4\xc0\x3a\x5b\x1d\x9c\x83\xe0\x55\x69\x67\xbf\x9c\xad\xa7\x0c\xc7\xab\x33\xef\x02\x2e\x1d\xe7\xab\x1e\x06\xda\xf9\x4a\x42\x81\x89\x5c\x4b\x26\x50\x02\x93\x7c\xd4\x42\x56\xa5\x44\x6f\x1d\x55\xc2\x41\xe6\xa9\x48\x37\xe1\xee\xc6\xd5\x84\x45\xae\x9d\x4f\x83\xdd\xb0\xb6\xeb\xb4\xee\x81\xfb\xc2\xcf\xbe\x23\xfe\xa1\x13\xf9\xdf\xf6\x69\x78\x1d\x1d\x74\xff\x05\x4d\xd4\xd1\xf8\x06\x2b\xce\xf5\xfc\x95\x09\x64\x45\xfe\x69\x62\x84\xab\x22\x15\x21\x0a\xd9\x4a\xb0\x7d\x4c\x54\xf3\xaf\x75\x5f\x02\x8e\x48\x6b\x49\xd2\x4d\xda\x2f\x42\x8e\xbe\xfd\x5f\x8c\x22\x83\x26\xf2\x44\xe9\x46\x38\xc8\x50\x48\x9e\x18\x31\xfd\xee\xcd\xd4\x08\x79\x87\xb6\x55\x42\x87\xfe\xeb\x94\x10\x31\x97\xaf\xf1\x22\x25\x2e\xf9\x59\xfa\x98\x9c\xb2\x3a\xcf\x6f\x14\x61\x37\x10\x83\x37\x94\x62\xff\x55\x76\xc8\x0d\x1c\xdb\xaf\xe5\x7f\x41\x76\xed\x07\x37\xc8\x11\xed\x57\xbb\x73\x3c\x7e\xf8\xf0\x77\xa3\xb7\x07\xdb\xe0\xf3\xe4\x93\x46\x9b\x6d\xfb\xe2\xe1\x93\xc7\x0f\x47\xff\xe6\x9f\xd2\xf6\xd9\xfe\x7a\xe3\x70\x90\xd5\xfa\x2a\x74\x7c\x4a\x9e\xa7\x9b\x91\xad\x6a\xff\xed\xf8\xb4\x6e\x7f\xac\xdf\x1d\xf1\x0c\xff\x17\x74\x03\x49\x46\x38\x58\x49\x54\xf9\xcd\x02\x29\x75\x7e\xa2\x58\xe3\xeb\xe8\xc8\x35\xaa\x6a\xe5\xff\xba\xd1\xf3\x09\x8b\x65\x5c\x9e\xf0\x85\xd8\x01\xb3\xac\xac\x2a\x00\x49\x69\xb5\xd5\x68\x94\xaa\x0e\xe0\x2d\x5a\x5e\xdf\xaa\xf3\xcb\xb2\x25\x3d\x9f\x4d\xc7\x7d\x0c\x84\x2b\x0d\xa1\x6a\x5c\xa9\x2d\xd4\x55\x7a\xc1\xf7\x51\xb3\xb8\xd7\x87\xc1\x6b\xb1\x13\xa8\x5a\xd0\x9f\x3f\x6f\x36\x9e\x3f\xaf\x1a\xcf\x9f\xd7\x8e\xe7\xcf\xeb\xc6\x03\xfe\xb5\x6b\x87\xf3\xe7\xf5\xc3\x59\xdf\xf6\x47\x72\xb8\xfd\xfd\xef\x6e\xdf\xf0\xfa\x76\xbb\xb3\xf8\xbf\x99\x79\x45\xa6\x66\xe3\x92\x7b\xdc\x83\x52\xc7\xe0\xfc\x51\xb2\xc5\x9f\x50\x71\x1a\x79\x2d\xa0\x6e\xac\x8a\xf0\xa8\x75\x4d\xb1\x82\xb5\xb6\x5c\x8b\x63\x7f\x11\x56\xc5\xc3\xb9\x3e\x18\x6d\x8b\x47\x8f\x1f\x0e\x04\x38\xf0\x56\x4b\xa1\x7e\x5c\x94\x57\xb2\xa2\x8c\xf8\xf3\xf2\x93\xaa\x0c\x5d\x5c\x3f\x13\x17\x5a\x17\xe8\x8f\xfc\x89\x3c\x0a\xad\xea\x7b\x70\x72\xfc\xe1\xe0\xf0\xc5\xd9\xb3\x0f\x2f\x8e\x5e\x1e\x8a\xfe\xa3\x2d\xdb\xc0\xaf\xbe\xb5\xef\xae\x4a\x75\x8d\x2e\xdf\x76\xe6\x74\x83\x35\xfd\x7f\xdf\x3f\xa4\xaa\xd1\x89\xd9\xd7\x70\xba\xff\xfa\xf0\xf0\xa5\xe8\x3f\xde\x22\x83\xc3\x6f\x7f\x33\xcc\xd4\x34\xe4\x89\x3b\xc6\x0c\x07\xff\x42\x1c\xfe\x66\x1d\xc1\x73\xa0\xff\xb2\x4a\x82\x1f\xe2\x20\xc7\x70\x03\xee\x7e\xb6\x68\x6a\xf0\x5c\x78\xd7\x93\xe7\xba\x69\x7b\x03\x31\x1c\x0e\xdf\xdb\x27\x65\x8d\x59\xe4\x7d\xec\x1b\x32\xea\xef\xec\x5e\xc6\xc2\x3b\xfc\x7b\x3d\xa8\x02\xe7\xea\x0d\x71\x15\x9e\x61\x6b\xfe\x65\x84\xac\x00\x6f\x19\x58\xc1\x15\xfa\xe2\xfe\xca\xe0\x2b\x60\x85\xef\xa9\x08\x17\x1d\x0e\x81\x50\xbe\xec\x22\xdc\x29\x86\x5c\xe1\x99\x74\xa6\x0f\x62\xba\xf7\xa3\x73\xd5\xed\x88\xbf\x03\x20\x00\x95\xf8\xe2\xea\x1a\xa5\x50\x13\xdf\x07\x39\x82\x6f\x6e\xe7\xcb\xee\x1d\x3f\xe1\x3d\xe7\xb5\x0e\x77\xdf\xc1\xef\xa3\x96\x00\xc2\xa2\xa7\x88\x09\xe0\x33\xb4\xf9\xbc\x63\xf6\xaf\x57\x95\x5c\x06\x7f\x9e\x61\xec\x01\x66\xf5\x2a\xc7\x97\x61\x7a\xaf\xde\x38\x06\xa2\x18\xeb\x39\x7e\xba\x80\xea\x0b\xbd\x38\xaf\xd4\x3e\x7f\x55\x34\xf2\x82\xff\xa5\x8e\xe2\x9f\xe0\x5d\x40\x3f\x3e\x95\x2d\xff\x0d\x69\xa9\xf9\xc7\xc9\x95\x2f\xe4\xfa\x5f\x34\x1a\xc0\x2b\x0a\xe2\x35\x14\x82\x31\x10\x3d\x35\x9b\xb7\xa5\x82\x36\x54\x3d\x6e\x96\xf3\x96\x7f\x14\xf4\x47\xd3\xe8\x26\xcc\x6e\x47\x30\x78\xf0\x07\x78\xe1\xd9\x3f\x2f\x3d\x94\xc6\x25\x99\xe7\xe9\x6f\x44\xcd\xa8\xb4\x2c\xf8\x5f\x85\xae\xd4\xee\xd7\xb1\x6a\x65\x11\x3c\x71\xbd\x9e\x85\x28\x1c\xf0\xe3\x58\xe3\x40\xe1\xc7\xc9\xc2\x97\xe2\x51\xcf\x3c\x50\xc7\x5c\x9a\x56\xe1\x1f\x0b\x5c\x84\x39\x2d\x98\xfd\xb7\xac\x61\x8a\x01\x94\x97\x3a\xdb\xc8\x56\xf9\x89\x69\x94\x51\x6d\x94\x59\xb0\x67\x94\xba\xc4\x49\xb1\x7f\x51\x0d\xa6\x85\x24\xb6\xf0\xe7\xe2\x7c\x86\xab\x62\x16\xc6\x6e\x1b\xc0\x0b\x29\x67\xea\xcd\xbc\x90\xd8\x97\x56\x5f\x5c\x54\xf4\xd7\x62\x3c\xf5\x19\xed\xe0\x27\x2d\x36\xfc\xcd\x43\x85\x1f\x6e\x4a\xbc\xfe\x43\x65\xaf\x74\xb5\x98\x05\xdd\xbe\x96\x80\x82\xee\x93\x5b\xbe\x1f\x4e\x74\x73\x28\xc7\xd3\x7e\x56\x3c\x82\xbb\x5d\x39\x2f\x5b\xbc\xff\xc6\x63\x60\x0f\xf7\xdb\xbb\x87\xef\x87\xad\x7e\x33\x9f\x33\x4c\xa2\x78\x40\x47\x02\xa6\xb9\x7e\xe4\x20\xe9\x48\xaa\x15\x7b\x96\xa5\xf4\xc4\x83\x4e\x95\x5c\xb0\xd5\x73\x57\xb2\xd5\xf3\x7c\x51\x2e\x8b\xe1\xe6\xb7\x85\x92\x61\x91\xbb\x83\x23\xc3\x9d\x7c\x00\x3e\x35\x37\x21\xc9\x70\x4f\xdf\xdf\x21\x44\x8a\x90\x05\xbd\x83\x1f\x90\xcf\x8e\x52\x8a\xac\xe7\x44\xbe\x36\xf7\xc9\x17\x38\x1b\x08\xbf\x00\x8e\xfe\xb2\x16\x07\x87\xff\x89\x77\x00\x98\x07\xac\xbc\x52\xb5\x32\x06\x9d\x5d\xc9\x1f\x02\xbc\x0f\x6a\x7d\x5d\xff\xf1\xec\xf8\xc5\x59\x98\x9b\x4f\xec\x85\xfc\x79\x20\xe2\x94\x89\xf8\x83\x79\x96\xff\x15\xb0\xad\x30\x31\x61\xab\xe7\x07\x1d\x66\x61\x47\xe1\xf9\x85\xfd\x15\xb2\x0c\xf8\x5d\xf8\xbf\x99\x71\xb4\x7a\x7e\xc4\x2c\x03\xfe\x76\x5c\xc3\x4e\x1a\x31\x06\xfa\xd3\xf3\x06\xf7\x20\x64\x0f\xf4\xd0\x6f\x07\x3d\x7f\xc5\xbb\xdb\xfe\xed\x47\xf7\xca\xef\x71\xfb\x2b\xd8\xe6\xad\x9e\xbf\x8e\x76\xba\x7d\xc0\x9b\x1d\xe2\xd4\x78\x97\xd3\x0f\x5f\xcd\xa9\xdf\xeb\xf6\x97\xdb\xee\xf0\xc3\xef\x78\x3d\x3f\x4b\x36\xfd\xfc\x2c\xd8\xf7\xf3\xff\x4c\xf6\x6c\xab\xe7\x6f\x69\xdb\xbe\x27\x10\xa1\x53\xb8\xcb\x02\x92\xd9\x24\x54\xfe\xfb\x7f\x40\xa8\x7c\x7a\xb4\xde\x4c\xf1\xae\xcd\x30\x9d\x61\x5c\xcf\xda\xa0\x70\x6e\x1a\xaf\xa4\x38\x26\x4f\x53\x96\x83\xf5\xe1\xdd\x61\x88\x1f\x1e\x47\x3e\xca\x2f\x08\x08\x75\xd8\x10\x82\x2f\xc5\x38\x46\x55\x37\x89\xd3\x44\xab\x35\x45\x14\x23\x6e\xa8\x09\xeb\x83\x6b\xc8\xfa\x5a\xc2\xdd\x75\x5c\x95\x19\xa2\x13\xad\x55\x22\xa6\x98\xe8\x3c\xe3\xfe\x12\x56\x16\xf9\xb0\x0c\xc5\x49\xad\xc4\x35\x00\x96\xaa\x4f\x73\x35\x6e\xc5\x99\x3c\x27\xf0\x5e\x0e\x0f\xed\x13\x90\x7d\x89\xc1\xb6\x51\x64\xe5\x7a\x3f\xef\x28\x69\xd8\x8a\x95\x10\x61\xa8\xe5\x77\x71\xa8\x25\x27\x61\xfa\x9a\x68\xcb\x74\x5d\x43\x70\x93\xe8\x0e\xe8\xa6\xa0\xea\x28\x32\x7d\x65\xa8\xfe\xba\xe6\x7c\x60\xc4\x8d\x01\xdc\x20\xa5\xdd\x40\x4c\x20\x00\x12\x25\xe9\x9a\x90\x7f\x30\x47\x33\xbc\x32\x31\x25\x05\xb1\xe9\x98\xad\x8c\x29\x29\xa8\xc7\xc4\xab\x1a\x3a\xe4\x20\xfc\x32\x2c\xe5\xe3\x9f\x77\x29\x0f\x02\xc1\x34\x1f\xad\x9e\x5f\xe9\x63\x27\xac\xdd\x18\xe3\x3e\x1a\x89\xb3\x93\x83\x93\x1d\x71\x80\xb9\xbe\x02\x30\x15\x4e\x70\xa1\x5b\x11\xc4\x86\xe0\x34\x32\x42\xcb\xa6\x23\x39\x66\x89\x31\xdf\x21\x90\x1f\x3b\xaf\x72\xc1\xfa\xeb\xe9\xc8\x2b\x8c\x37\xd1\xd1\x81\x15\xf2\x3b\x2d\x1e\x90\xc8\xbf\xe2\x45\x9b\xeb\xe5\x01\xab\x03\xd9\x37\xa8\x1c\x64\x5f\xe5\x07\x7d\xe0\x14\x87\xcc\x2b\xbd\xe9\xfe\x75\x57\x66\x37\xcd\xc3\x59\x20\x07\x77\x1a\x3c\x63\xa9\x38\xff\x26\x4f\x61\x67\x5e\x62\xde\xac\xaf\xfe\x0e\xe3\xa6\xce\x3e\x0b\xf5\xc7\x4e\xc3\xcf\xba\xda\xe4\xea\x32\xb7\xe9\x60\x1c\x37\x7b\xe3\x8c\x46\x3a\xc2\x86\x53\x10\x9b\xa7\x6f\x6a\x82\xf2\xae\x6f\x56\x37\x5d\x26\xdd\x54\x27\xa6\x91\xdf\xac\x4a\x6f\x6a\xb9\x19\x6f\x63\xbe\xcc\x6c\xec\x1c\x23\x78\x05\x0a\xe3\x66\x1d\x88\xc3\x3a\x57\x74\xa2\x50\x13\xb9\xa8\x5a\x5f\x63\xc8\x9a\xc1\x0b\x38\x2b\xc7\x0f\x21\x43\xd2\xc9\x24\x91\x6c\xe2\x24\x40\xfc\xdf\xb5\x6c\xea\xb2\xbe\xe8\x03\x38\xc8\x40\xf4\x3a\x82\xe3\x8e\x78\x53\x73\xe2\x28\xb2\x05\x82\x14\xf8\xf1\x5b\xf3\x91\x93\x15\x63\x1d\xc2\x6a\x63\xbd\xd2\x88\xaa\xbc\x54\xd5\x52\x40\x40\x1b\x78\xda\x4a\x80\xff\x2f\x6b\x82\xe8\x17\xaf\x2a\x65\x27\x6d\x52\x82\xec\x22\x4a\x63\x16\x6a\xd8\x8b\x53\x85\x6f\x85\xc0\x33\x5f\x3a\x87\x0f\x30\x7e\x3b\x74\x9c\xe6\x48\x98\x5a\x7d\xdf\x31\x6d\x67\xd5\xaf\x46\x30\x3f\x43\xfb\xf7\xbf\xd1\x25\xe0\xc3\x8d\x16\x8d\xae\x6c\xb2\xab\xe5\xa5\x4d\x45\xfa\x69\x5a\x53\x80\xb3\x96\xda\x18\x6f\x21\x51\x63\x6b\x6b\x61\xd0\x42\x9f\xab\xd0\x5b\xca\x7b\x44\x19\xd5\xfe\x11\x96\x94\xe9\xa6\x3f\x8d\x7e\x06\x66\xc7\xa3\x1a\x50\x41\x31\xcd\x82\xa1\x24\x0f\x46\x57\x90\xaf\xea\xe0\xe4\x58\x4c\x4b\xd5\xc8\x66\x3c\x5d\x12\xf4\x3d\x28\x1b\x00\xca\xe2\x52\x26\x96\x50\x07\xa0\x3e\x0f\xf1\xef\x80\xbe\x4e\x6c\xd1\xfe\xc1\xc9\x71\xfa\x6c\x6b\x37\xf8\xf0\x31\x7d\xb8\xaf\x67\x73\x5d\xdb\xe9\x68\x94\xea\x03\x39\x1d\x9c\x1c\x47\x4f\x83\xce\x43\xc8\x5b\x39\x9b\xeb\xa6\x95\x35\xa1\xbf\x50\x17\x8d\x28\xeb\x71\xb5\x28\x90\x40\x69\xa7\x89\x3e\xdf\x53\x4c\x25\x0c\xb0\xd5\xa2\x51\x3f\x2e\xca\x46\x11\xfc\xf1\x6c\x6b\x83\x21\x99\x1f\xe0\x72\x17\x40\xd2\x33\xfb\xa9\xf3\x68\x70\x47\xa0\x88\x0f\x67\x6d\x54\x36\xfb\xd8\x96\x0f\x20\x4e\xb8\x6c\xe7\x11\x84\x6f\xa5\x98\x69\x3b\xdd\x47\xb6\xdc\x0f\x80\x2b\x83\x18\x54\x61\xe1\xfc\x73\xb4\x3e\x60\xaa\x1d\x2b\x74\x3d\x33\xcb\x7a\x7c\xba\x38\x6f\x1b\xa5\x9e\xbd\x3a\x72\x58\x46\x69\x89\xf1\x54\x15\x8b\xaa\xac\x2f\x7e\x58\x1e\xe0\x94\x1f\xd5\xbc\x88\x1e\xa1\x68\x34\xa2\x24\x9c\x86\x18\xc6\xf3\x46\x82\xf1\x3c\xa8\x0f\x5e\xf0\xf3\xd5\x9f\x1e\x9c\x1c\x73\xbe\x1a\xad\xc3\xef\xf7\xdd\x43\xff\xb1\x7f\xfb\xc6\xa8\xe6\xac\x9c\x95\xf5\x45\x38\x9a\x3b\x10\xf4\xd8\x4a\xb8\xb0\x9a\xe9\x42\x09\xa4\x40\xbb\x0f\x06\x94\x53\xe5\xd9\xeb\x33\xfe\x13\x2f\x43\xb6\x76\x82\x7a\xf9\xeb\xd7\x6a\xac\xeb\x71\x59\x41\x86\x22\xac\x1c\x7b\xae\x9a\x12\xa2\x5b\x2a\x51\x6b\x3d\xa7\x46\x08\xdd\xb1\x5a\x0a\x4c\x31\x1b\x55\xf9\x52\xeb\x79\x54\x5d\x34\x13\xbe\xbe\xb9\x6a\x38\xdc\x06\x6b\xdd\x3f\x8d\xea\x79\xe5\xde\xe7\x6a\xeb\x58\x9a\xae\xaf\xaf\xc5\xf9\xa2\xac\x0a\x33\x44\x42\x00\x5f\xe1\xd3\x56\x8e\x2f\x29\x77\xc1\x1d\x97\x69\xa4\x3c\x07\xe7\x1e\xf7\x86\xb0\xa7\x31\xc9\x2b\xe6\x2e\x0d\x40\x53\x61\x61\xf6\x17\x8d\xd1\x4d\x9f\xf6\x25\x24\xb7\x8c\x2e\x71\x28\x0a\x18\x27\x66\x47\x84\xe5\x5c\xbe\x90\xa0\xd2\xb9\x9e\xdb\x59\x34\xba\x19\x60\x77\x7c\xb0\x12\xf6\xe2\xf7\x5e\x89\xe5\xf3\x31\x3d\x19\xdf\xd4\xa8\x3e\xab\xc2\x56\x37\xec\x65\xfc\xbc\x5d\x8c\xaa\xcf\x4a\x01\xad\x41\xa8\x8e\x9f\x86\x77\xd0\xe6\xfb\xad\x4d\x9a\x7a\x0e\xdf\xcf\xf5\x7c\xae\x8a\xa8\x4d\x68\x07\xc7\x34\x64\x2c\xe6\xbd\x60\x15\xa8\x11\xb2\x86\x26\x4f\xc3\xdc\xac\x94\xdd\x25\xed\x5d\x80\xa6\x86\xf0\xe6\xf6\xe9\xf6\x76\x9c\x66\x06\x72\x41\xf0\xc4\x52\xd4\x48\x38\xbf\xf6\x9b\x07\x0f\x56\xf6\x21\xee\xfe\x0d\xbd\x81\x67\xbb\xeb\x47\x1e\xf7\x0e\x4c\xf0\xdf\x3c\xa2\xa4\x37\x94\x22\x03\xd7\xfb\x0f\x81\x28\xb4\x76\x76\x3c\x3d\xac\x9b\x21\x07\xdc\xe4\x66\x29\xc0\x58\x2f\x94\x19\x37\xe5\xb9\x72\xa7\xd4\xf3\x06\x33\x0d\x79\x03\x5b\x2d\x67\x00\x1e\xb6\x68\xc6\x6a\x20\x00\xac\xd1\x9e\x20\x11\xc9\xf7\xfe\x52\x63\x0b\x20\x67\xc1\x27\x14\x41\x03\x62\x60\x6f\xcb\x3e\xc5\x2a\xc4\x53\xd1\x13\x7d\xd9\x42\x49\x7c\x34\xb4\xc2\x16\x24\x2e\xa2\x88\x8a\xfe\xe8\xff\x0c\xbf\x7b\xf7\x97\xbf\xfc\x65\xf4\x7e\x34\x10\x3d\xf8\xbc\xb7\x13\x7c\x50\x95\xb5\x7a\x09\xc0\x00\xf6\xcd\x56\x4f\xec\xf8\x8e\x61\x03\xb8\x55\xe1\x00\xb5\xdf\xf9\xb7\x5c\xbe\x07\x69\x89\xc2\xdd\xcd\x73\x01\x64\xdd\x0f\x48\x85\xad\x71\xf0\x68\xd8\x4a\x67\xd9\x03\xf1\xfa\xa8\xe6\x48\x26\xcb\x1b\x78\x1e\x77\x7c\x81\xe7\xd4\x80\xac\x72\x6f\xe1\xd2\x35\xf7\xe2\x8f\xda\xb4\xc9\x73\xba\x90\xb0\x63\x61\xa2\x1b\x7e\x28\xd4\xf9\xe2\xe2\xc4\x3e\xdb\x0d\x0a\xd1\x64\xc7\xa5\x4e\xe1\x61\x58\xac\xc6\xd5\xbe\x50\xbe\x29\x10\x0f\x70\xf4\xbb\x69\xab\x94\x86\x2a\xb4\xb9\x58\x46\x02\xef\x42\xe9\x3d\x2c\xdc\xa9\x1b\x4b\xa7\xb9\x4a\x89\x92\xf2\x04\xb9\x92\x08\x77\xef\x64\x94\x91\x20\x44\x8b\xc1\xb6\x09\xf2\xcd\x73\x72\x59\x23\xa0\x06\xc4\xdd\x55\x56\x81\xa0\xac\x82\xd7\xba\xb9\xdc\x2e\xeb\x6d\xbe\x3d\xc3\x09\x04\x33\xe6\x68\x84\xdf\x14\x0b\xc8\x84\x7f\xae\x50\x9c\x14\x63\x6d\x85\xa6\x56\xe1\x45\xce\x50\x1c\x60\x52\x7d\x5b\xaf\x28\x5b\xc8\xd0\xd0\x60\x62\xfc\x76\xaa\x1a\x5b\xcd\xb8\x6c\xc6\x8b\x19\x02\x7d\x9a\x61\x8c\xe6\x6e\x77\xf1\xb3\xa2\x50\x75\xb1\x98\xfd\xb0\x7c\xab\x9b\xcb\xa3\x9a\x6d\xfc\x48\x9a\xd7\xd1\x33\x7f\xd7\x45\xa9\x61\x70\xdc\x41\xda\xec\xb8\xbc\x7d\x59\x68\x97\xf3\x61\xa2\xc5\x83\xbd\x84\xf6\x6b\x8e\x07\x44\x14\x6a\x97\x0c\xbf\x9d\xba\xa4\x17\x02\xd2\xad\xab\x46\xcc\xc0\xfe\x87\xc9\xd7\x29\x66\xe5\xba\xd1\x56\x3e\x6d\x94\xc2\x15\xa9\x7d\x9e\xd9\x77\x3d\xfc\xbc\xf7\x1e\xe1\xe0\x89\xf1\xb9\x06\x19\x28\xbf\x9e\xe8\x4e\xd2\xb0\x7d\xe4\xa7\xd0\xc5\x13\xa6\x00\x62\xa0\xde\x96\x8f\xcb\xb5\x47\x22\x96\xa5\xfa\xf0\x3b\xcf\xcf\xe3\x43\xb0\x9b\x68\x7a\x8d\xcd\xfe\x86\x0d\xe8\x76\x84\x4b\xd4\x2b\xee\xdf\x07\xcd\x54\x4f\x84\x7f\xd1\x73\x99\x3b\xb2\xb1\x2a\xab\xf7\xcc\x97\x38\x12\xd1\xc1\x43\xaf\x9a\xab\x88\xa2\xfe\xd1\xf3\x35\x1a\x89\x53\x39\x51\x1e\x43\x66\xe2\xb2\x33\x60\x4d\x88\xe5\x0b\x60\xbd\x88\xf6\x81\x02\x5e\x59\x5f\x0c\xb8\x02\x40\xe2\x01\x47\xa5\x8b\x85\x6c\x64\xdd\x2a\x97\xe1\x0f\xc8\x2d\xdd\xb1\x94\x4b\x36\x8a\xf9\xdc\x6c\x67\x79\xb6\xb7\x76\x82\xe1\xf0\x0e\xa7\x89\x66\xb5\x3b\x87\x96\x79\x0d\xfd\x7a\xb0\xa4\xc9\xb3\xb4\x7e\xd2\x6f\x2e\x08\x0c\xc7\x15\x0b\xbb\x98\x76\x30\x38\xce\x36\xee\xe5\x3a\x3a\xda\xa8\xf7\x4e\x2c\xfa\x09\xdd\x07\x0b\x42\x1f\x4a\xae\xea\x7e\x54\x17\xfc\xeb\xe4\xf8\x7c\x61\x06\xcb\x63\x11\xdd\xf9\x34\xdb\x6f\xc3\xe0\xd7\x64\x16\x77\xba\x8f\x20\xa0\x20\x2d\xb5\xb6\xcc\x2b\x6c\x24\x79\x40\x61\x08\x59\x1e\xb7\xb3\xf2\x4d\xe6\xab\x68\x95\x3a\x5f\x46\x6f\xd1\x9b\x6f\x24\x5e\x35\x6a\x52\x7e\x12\x33\x25\xcd\xa2\xe1\xfb\x09\xcd\xb1\x90\x3d\xe3\xb2\x3d\xdb\x4d\x37\x29\x2b\xcb\xf6\x11\x6b\x67\x34\x12\x2f\x74\x7d\x61\xb5\x00\xa8\x03\x93\x6f\x8b\x29\x20\xee\x68\xd1\x28\x89\x57\xff\xea\xea\x4c\xeb\xca\xe0\x0d\x3f\x24\xe2\x3c\x9c\xe9\xbf\x96\xf6\xb0\xfa\xcb\xe2\xf1\xaf\x7f\xf7\x43\x0f\x35\x5c\x52\x36\xa2\x97\x07\xdf\xd3\x4b\xce\x77\xed\x15\x60\x72\x38\xd0\x13\xce\x87\x68\xcf\xd3\x94\xb9\x06\xcc\x37\x28\x35\x9c\xc9\xe6\x12\xa3\xf8\x98\xe8\x56\x95\x1c\x57\x4a\x36\xc7\xb2\xb9\x34\x9b\x95\xa7\x79\xbc\x4d\xe5\xf8\x45\x5a\x3f\xae\xce\x9f\x94\x9a\x8b\x16\xe0\xbc\x75\xca\x3c\x79\x95\xae\x15\xf8\x4d\x50\x6e\xf3\x76\x0a\x80\x65\xf5\x75\x89\xe8\x33\xe0\x24\x04\x8b\x85\xb7\x51\x70\x8c\x57\x5a\x5f\x1a\x9f\xab\x46\x62\x3a\xf7\x37\x75\xd9\x9e\x4c\x2c\x6b\xb4\xeb\x66\xd0\x26\xa2\x9a\xa1\xd8\x97\x35\x64\xe6\xae\xcb\xc9\x12\x16\xff\xe9\x9d\x20\xd9\x04\xef\x2a\xdc\xc8\xa3\x91\x38\x9a\x88\x6b\xd5\x6b\x14\x83\xfb\xce\xca\xa2\xc0\x64\xab\x10\xd0\x3a\x86\xfc\xb4\x18\x8f\xeb\xe4\x2b\x4a\x06\x6d\xf9\x7c\xd9\x3e\xb5\xb5\xbc\x56\x98\xbe\xf0\x63\xd8\xcc\x47\xba\x30\xc6\x8c\x3d\x13\x2c\xe1\xa0\xe0\xf9\x9c\x71\xcd\x60\xfd\x20\x74\xf9\xec\x87\x24\xc1\x8d\xf5\x6c\x56\xb6\xb8\xed\x45\xab\xb5\xc3\x2a\x2e\x00\x8d\xbb\xa6\x73\x86\x66\xb2\x6c\x45\xdf\x94\xf5\x58\xd9\xca\xaa\x72\xa2\xc6\xcb\x71\xa5\x5c\x4a\x82\xa8\x32\xac\xc0\x72\x8b\x19\x5c\x82\x83\x34\xb4\x35\x0c\xe7\xec\x55\xc4\xfc\xd2\x17\x9d\x19\x3d\x28\x0b\xdf\xa8\x98\x6a\x7d\xe9\x96\x47\xc8\x5a\x2c\xc0\x23\xe3\xa9\x43\x36\xd6\x93\x56\xd5\x42\x46\x1b\x63\xde\xe8\x73\x48\x8a\x0a\x68\xd6\x76\x9c\x90\x9c\xe8\x32\x22\xb0\x92\xd2\xb7\x90\x09\x12\x0e\xde\x9a\x42\xbd\xed\xf6\x43\x3a\x82\xd2\x38\x62\x13\x18\xd3\xc7\xd2\x8c\x25\x04\xf0\x62\x7f\x68\xc7\x97\x56\xc1\x99\x95\x6d\x8b\x7b\x36\x30\x69\x4d\xa5\x21\xc3\x9b\x2a\xd0\xa9\xe4\xa8\x26\x7e\x85\x9f\x6c\x5c\x9c\xa7\x33\x28\x8d\xfd\x83\x24\xd8\xae\x98\x25\xed\x17\x1a\x52\x1d\x3e\x24\xab\xda\x64\x02\xc6\xdb\xb0\x94\x6b\x9b\xca\x94\x86\x9c\x58\x9e\xeb\x66\x9f\x3d\xd9\x43\x73\xd6\x41\x48\x50\x28\xcd\x80\xaa\x60\xa6\xfa\x5a\xc8\x90\xb5\x0a\x0d\x4b\x61\x25\x67\x24\x77\xab\xda\xdc\x41\x40\x70\x09\xc9\x05\x4d\xdb\x28\x74\x91\x4e\x88\x0a\x34\x94\xa8\xaa\x2b\xd5\x4c\x95\x2c\x86\x94\x60\xeb\x5c\x55\xa6\x3b\x86\x5a\x5d\x8b\x53\x05\x49\x56\xef\x60\x76\xdd\x66\x26\x21\xe1\xf5\xcb\x54\xd7\x9f\xd1\xc3\x48\xb9\x0f\xf8\xf5\x03\xd1\x03\x75\x9a\xcb\xed\xba\xcc\x60\x58\xe9\x0b\xdb\x85\xa8\x46\xe8\xd4\x80\x19\xfb\x37\xdf\x3c\xf2\xea\x0a\x1e\x19\x56\x3f\x71\x2f\xc5\xd3\xf8\x08\xc0\xf6\x76\x3a\x5d\x60\x05\xc7\x2c\x26\x99\x2a\x7a\xe2\x2d\xfe\xdc\x81\xce\x06\xef\x76\x48\x39\x72\x1a\xa2\x78\xc0\xdd\x78\x80\xf3\x27\x1e\x50\xa5\x7e\x68\xa0\xe7\x1d\xc3\x71\xb1\x72\xaa\xd2\x93\xa5\x1f\x4f\xb2\x2f\xbd\xe5\xeb\x75\xe7\xca\x86\xf5\xfa\x73\x68\x93\xda\x29\xf9\x77\x6e\x31\xb8\x78\x7e\x59\xb0\xee\x56\x15\x21\x85\xac\x68\x6f\x37\xfd\xc6\x11\x80\x27\x87\x0c\x09\x80\x53\x61\xb3\x64\xf7\xc7\xee\xd9\xd9\x8f\x2b\x1c\x74\x3b\x45\x59\x05\xc7\x10\x4c\xd0\x57\x8d\x95\x6d\xbf\x60\xe0\xc3\xd1\xc4\xae\xe9\x55\xa9\x17\x06\x86\x0a\x59\x96\x67\xa5\x71\x07\x85\xd1\x33\xc6\x73\x1f\xe0\xa9\x01\x7c\xb0\x9d\x36\xfa\x9a\xc2\x30\x80\x8d\x62\x26\x65\xd8\xc7\x53\x39\x9f\xab\xda\x6a\x2f\x68\x3f\x1f\x37\xd2\x4c\x19\xca\x43\x2c\x02\xf3\x2b\xe4\x57\x56\xb2\xa9\x4a\xc0\xe4\xf4\xb9\x1d\xe6\x56\xd3\xd5\x35\xed\x62\xdd\x28\x01\xee\xc7\x66\x48\xf1\x28\x80\xb8\x06\x1d\x36\xa2\x9c\xcd\x54\x51\xca\x56\x55\x4b\xcf\x17\x2e\x1a\xcc\x78\x73\xbe\x98\x4c\xb0\xee\xb5\xd4\x91\x4e\xd6\x4a\xa9\x23\x99\xec\x80\x86\x2e\x14\x1e\xb9\x59\x5e\x41\xcb\x0a\xda\xef\xd1\x41\xc4\x31\x78\x27\xf5\x44\xff\xdf\xec\x16\xa3\x32\x68\x7b\xeb\x56\xdf\xe5\x1a\xe3\x50\xf9\x1d\x88\xd2\x1c\x5b\xf6\xac\x8a\x81\x08\x14\x01\xab\x8d\x92\xd4\x9f\x68\xa3\x08\x1c\x62\x50\xa3\x84\xba\x4c\xd9\xd2\x5f\x35\x46\xdd\xb4\xb2\x02\x04\x8d\x48\xea\x8d\x81\x94\xc2\x3e\xc0\x60\xde\x81\x71\xd3\x75\xc6\x72\x1a\x3c\xe6\xc0\x9e\x38\xb3\x4f\xd1\x54\xf9\xbe\x97\xcf\xb9\xda\xed\x08\x9e\x01\x37\x34\x3c\x04\x36\x85\x7a\x4d\x98\x8d\x11\x18\x93\x5b\xa0\x68\x02\x41\xe8\x89\x66\x8b\x0e\xc4\xa0\xe6\x95\x66\xbf\xc8\x74\xcb\x5b\x9c\xd7\x30\x36\x7b\x1c\x1d\xf0\x7b\x3f\x2d\x5c\x42\x5a\x45\xa1\x96\xad\x72\x76\x10\x2e\x5b\xd1\x82\x47\x04\x70\xe3\xa2\x3b\x04\xd6\x48\x9c\xb8\x7f\x3f\x7f\xf0\x0d\xa7\xd2\x20\x8d\x6e\x05\x64\x41\xe7\x74\x7a\xb4\x0e\xbc\xd0\x07\x27\x76\xb1\x98\x57\xe5\xd8\x76\x1d\xeb\x66\xb1\x92\xab\x81\xf4\x71\x08\x12\x63\xb5\x9e\xc2\x9d\xc4\xe8\xe1\x7c\xa5\x9a\x65\x48\x58\x28\x51\x71\x13\x5c\xc9\xb5\x44\x93\xd9\xca\xf3\xfe\x5c\x2d\x75\x5d\x88\x5a\x8d\x95\x31\xb2\x59\x46\x54\xe2\x32\xa6\x58\xae\x97\x9f\x01\x59\x14\x34\x03\xce\xef\x7c\xe6\x77\x72\xba\xb9\xd3\x0d\x6d\xeb\x76\x47\x5f\xcc\xf2\x1d\x8e\xd6\x42\x25\xc7\xd9\xbf\x12\x35\x7e\xd5\x8c\x3a\x36\x1d\xce\x68\x70\x66\xdf\x3c\x81\xf9\x53\xfb\x5f\x72\x32\x49\xc6\x59\x2b\xd7\xf8\xd9\x45\x97\xcb\x23\x00\x3c\x64\xf5\x2a\x99\x62\x97\xe2\xf2\x8f\xda\xb4\x7e\x4e\x9d\xbb\xe6\xb9\x82\xac\xc4\x73\x3c\xf9\xed\x86\xb5\x67\x48\x55\xd6\x8a\x8e\xfa\xb7\x8a\xa4\x06\x44\x6b\x26\x85\x9f\x2e\x8e\xc0\x37\xc9\x6a\x98\x80\x6e\x88\x82\x87\xd5\xb4\x41\x22\x78\xfd\xf2\xe9\x8d\x57\x4d\xb6\x57\xaf\xb5\xbe\xe1\x96\xc8\x3d\x3f\x53\x9f\xd2\x47\xaf\x74\xd3\xca\x2a\x78\xf8\x1a\xb6\x72\xf6\xda\x8a\x1c\x18\x92\x5b\x15\x9f\x08\x2a\x7f\xeb\x12\xf0\xa5\x88\x33\xbc\x42\x64\x27\x50\xd3\x8e\x03\x1d\x26\x5c\x03\x7f\xae\x47\x3a\x72\x68\x46\xef\xea\xc8\x77\x93\xc3\x3f\xe6\x43\xfd\xce\x07\x83\xa8\x0e\x67\xec\x5d\xad\x7c\x8b\xbc\xc6\x2e\x6e\xa1\x8d\xf2\x4c\x80\x25\xe6\xac\x9c\xa9\xc6\x64\x06\x3e\x1a\x89\xd3\x56\xcf\x0d\xa0\x1a\x7a\xc7\x0a\x4c\x36\x96\x37\xcf\xb5\x53\xb5\x04\xc3\xc6\x39\x42\xb1\xcd\x54\x81\x15\x95\x13\xc0\xc3\xd4\x75\x5b\xd6\x0b\x30\xc3\x48\x51\xc9\x56\xd9\xdd\x3e\x51\x4d\xa3\x0a\x51\x59\x35\x18\x30\x8f\x9d\x15\x68\x51\x97\x80\xe5\x66\xc9\x72\x78\x27\xbe\x20\x08\x6d\x30\xbb\xfe\xce\x3a\xd8\x37\xc1\x05\x01\xf3\x10\xb3\xcf\xc3\x40\x8b\x9d\xbf\x2f\x08\x79\x1d\xf3\x37\x30\xbc\xe2\x62\x86\x77\x08\xdc\x03\xf8\x37\xb9\x41\x72\x53\x8b\xa3\xc7\xb9\x7d\xad\xc6\x8b\xc6\x94\x57\x56\x7c\x5e\xb1\xc7\x5d\x4f\x7d\x7d\x1d\x4a\x5a\x51\x65\xfa\x5d\x84\x9c\xb9\xd1\xe8\x63\xc1\x2d\x1c\xfd\xd6\xea\x41\xe5\x09\xe6\x35\x94\x40\x92\x89\x28\x84\xec\x82\x8d\x62\xfa\x29\xbc\xe8\x53\x49\xd3\xc6\x74\x30\x8c\xf7\x5d\x7e\x67\xad\x9a\x8f\xf0\xa3\x60\x00\xc1\x75\xc9\x58\x37\xc5\x21\xd8\x59\x82\x3d\x9e\x71\x67\x72\x39\xec\x57\xda\x64\x1e\x3c\x70\x97\xba\x49\xfd\xbc\x15\x71\x27\x6e\xd6\x4e\x2a\x4d\x7a\xf2\xdc\xc4\x30\xe5\x59\xa1\x87\x8f\xdb\x88\x71\xa1\x89\xda\x1d\x2f\x6f\xcb\xaa\x82\x03\xb1\xb7\x41\xc1\xd7\x6a\xac\xca\x2b\xf5\xaa\xd1\xf3\x10\xe4\x6e\x03\x5e\x14\x77\x37\x9e\x42\x48\xed\xfd\x5a\xfd\xb8\x50\xa6\x65\x03\x17\x2c\xf4\xe6\xf3\x98\x31\xcf\xdf\xbf\x2f\xee\xe6\x4c\x67\xbe\xdb\x2b\x0c\x6b\x61\xb6\x41\x2f\x83\xf6\xfa\x54\x18\x91\x8f\xcd\xb2\x1e\xc3\x25\xbb\xfd\x68\x38\x1c\x6e\xc5\x2e\x48\xf1\xf0\xf4\x3c\x3b\xba\xa2\x2c\x0e\x3f\xcd\xcb\x46\xfd\x84\x61\xde\x38\x9a\x28\xb9\x61\x70\xcd\xf1\x0d\x64\x8d\x74\x5d\xb0\xfa\x24\x5a\x17\xae\xa5\x11\xe7\x95\x1e\x5f\xa2\x55\x75\x26\x41\xd8\x68\x94\x2c\xac\xa6\x19\x7a\x5f\xb0\x04\x74\xe3\xd4\x0c\xc4\x06\x45\x12\x13\xcd\x4a\x42\x79\xab\x1b\x9a\xbf\x84\xa3\xde\x30\x77\x77\x33\x34\xf2\xf9\x73\x57\x30\xa3\x6a\xd3\xcb\xe5\xe4\x5e\x19\xee\x18\xf0\x48\x1d\xb8\x5c\x28\x90\x1c\x18\xb8\x97\x37\xdc\xdb\x33\x6e\x18\x3a\xe5\x3d\x0f\x0f\x94\x20\x7e\x6f\x0d\x5f\x5e\xd7\x97\xb5\x3c\x3f\xa0\xe6\x78\x26\x31\xde\xfe\x9f\x63\x2a\x5f\xab\x99\x02\x6f\xaa\x6b\x45\x55\x58\x55\xd8\xf9\xb5\x84\x36\x67\x77\xd3\x82\xa3\xee\x3a\x89\x4c\x2a\x39\x53\xe3\xa9\x6c\x5a\x34\xab\x01\xd0\xaa\x42\x48\x58\x34\xbf\xcd\xec\x61\xe5\x2e\x08\x36\x99\xc1\x60\x07\x25\xe2\x5d\xe6\xec\x4c\xf6\xfd\x3f\xc7\x0c\x47\xc4\x5a\xb6\x46\xcc\x65\x43\xb8\xc1\xb7\x27\xd9\x58\x06\xa2\xee\x6e\x28\x77\xdd\x9e\x7c\x83\xc9\xdf\x40\x68\xeb\x2e\xc0\x73\x59\x56\xaa\xf8\xef\x65\xf8\xf9\x96\xa1\x73\x86\xf4\x9e\xd5\x68\x4d\x86\xa3\x03\x0c\xd9\xb5\x28\x21\xf9\x13\x21\xed\xc0\xcb\x73\xbd\xa8\x0b\xd9\x2c\x7b\x37\xad\x66\x72\x10\x64\x8e\x00\x10\x2a\x82\xf5\xec\x58\x66\x6f\xbf\xac\xeb\x26\x67\x9d\x0a\xd9\xdf\xba\x91\x85\x63\xdf\xd6\x36\x90\x51\xff\x82\xe3\x21\xd1\x00\x43\x63\x6c\x42\xed\xc1\xc4\xfc\x52\x93\xf1\x13\x15\xe4\x0c\xfd\xdc\x28\x3d\x3e\x15\x3d\x57\x40\xc8\xce\x3d\x6f\x46\x2c\xd9\x58\x03\x5f\x21\x76\xac\xd4\xba\xd7\xab\xea\x2b\xa4\x95\x17\x1a\x81\x0b\x9a\x7e\xec\xe5\xb0\xd1\x12\xa5\x4e\x0e\x51\x0d\xbb\x5f\x4d\xd2\x37\xde\x4e\x8b\x38\x59\x71\xab\xe7\xa2\x52\x57\xaa\x02\xb1\xcd\x9d\xbc\xcf\xd8\xb1\x34\xd6\xff\x64\xa3\xf8\xca\x87\x9c\x5b\x4b\xf2\x88\x0b\x05\x6a\x94\x37\xcf\x1a\xa5\x04\x87\x56\x94\x10\x8d\xe9\x84\x69\xa7\x63\x22\x66\x7d\x5e\xc5\x2c\x6b\xe1\xbc\xef\x52\x3d\x93\xd5\xcb\x58\x7f\xec\xaf\x39\xad\xfd\x62\x81\x8b\x69\xb3\x98\xb7\xaa\xf8\x61\xf9\x4b\x6d\xa7\xce\x6e\xf0\x94\x86\x41\x18\x41\x1f\x32\x9b\xa9\x53\x66\xd8\xca\x0b\xb8\x92\x62\x73\x5d\xe8\x19\x9d\xb0\x6d\xbb\xa8\xdb\xb8\xa8\xb8\x93\x44\x50\x15\xba\xf3\xf0\x55\x66\xa3\xea\x42\x35\x3d\xe7\x37\x1d\xde\x2e\xf1\x30\x6e\xb4\x02\x27\x13\x9a\x5a\x83\xb3\x7d\x64\xe7\x12\x7b\x2e\x02\xa8\x4d\xe7\x62\x6c\xe3\x3e\xdf\x09\x7a\x0e\x5c\x6c\xdd\x1e\xf8\x83\x78\xd4\x09\x43\xa1\x3e\x9d\xc1\xfd\x0b\x90\x5e\xc7\xe5\xa4\xf7\x55\x9b\x0c\xa0\x56\xba\x24\xbe\xa8\xdb\xb2\xc2\x24\xfa\xea\x53\x48\xcb\x81\x25\x8f\xcf\x1f\xaf\x8b\xad\xd9\x55\x56\x0f\x5b\xfb\xfa\xe6\xa3\x17\xed\x0f\xbf\xf0\x11\x13\x7b\xec\x78\x7d\xfc\x16\x0e\x3b\xb6\x78\xfe\x62\x0a\x4e\x73\x9e\xb6\x90\x1d\x05\x8d\x62\xc4\xa0\x21\x3e\xd4\x65\x14\xbf\xf4\x2c\x6c\xc2\x1a\x6e\x9c\x8c\x55\xf4\xfb\x22\xef\xc8\x95\x3d\x5a\x77\x6f\xb9\x69\x1e\xae\x6a\x74\x3f\x88\x79\x4e\x5b\x01\x28\x4d\x74\x5a\xa0\x3d\x13\x6d\xa3\x5b\xae\xfa\xba\x1e\xa2\x01\xaf\x43\x61\x9b\xd3\x4c\xb2\xd7\x72\x24\x63\x37\x59\xfe\xf9\xa6\xbb\xcb\xb2\x6e\x34\x58\x9a\x5f\x76\xa3\xdd\xe4\x7d\xb6\x66\x87\xc0\x1d\x15\x75\xf2\x86\x6d\xf2\x0f\x1b\x0e\x1e\x42\x0b\xc4\x59\x5b\x39\xb4\xdd\x8d\x87\x9e\x5d\xe7\x70\xe0\x3b\x74\x24\x2d\x10\xfc\x4c\x9c\xe9\x56\x56\x1d\x0a\x88\xa7\x6a\x8d\xb6\xea\x08\xc0\xee\xd0\x7d\xf0\xef\xfc\x27\x5b\x7f\x59\x55\x76\x44\x9e\x83\x1c\xa3\x0b\xc9\x0d\x14\xf0\x8f\x1a\xcf\x2f\x48\x00\xab\x46\xbe\x8e\x04\x56\xcf\x56\x4a\x04\x7c\x91\x6e\x39\x84\x2a\x9e\x9d\xeb\x45\x7b\x8c\x3e\x63\xff\xa1\xda\xfd\x69\x59\x15\x84\x98\x43\xc8\x9b\x18\x55\xf6\x8c\x82\x3d\x39\xf4\x89\xdd\xb3\x67\xaa\xb9\x50\x85\x20\x68\x4c\x81\x78\xb4\x0e\x20\xb8\x95\xe3\x4b\xf2\x05\xc6\x02\xe0\x96\x8f\x71\xc5\x62\x2f\x0e\x33\x56\xb3\x79\xbb\x3c\x81\xef\xb7\x76\xd3\x26\xa5\x38\xd7\xba\x52\xd2\x2a\xfb\x05\xa4\x15\xac\x2f\xc4\xf5\x54\x81\x3a\x80\xfe\x24\xd8\x01\x4a\x27\x55\x5f\x28\x72\x16\x2d\xca\xe2\x15\x6a\x07\x96\x31\xaf\x69\x1f\x18\x33\xb6\x1c\x7b\xa2\x47\x82\x5e\x32\x50\xd4\x0c\xa4\x49\x46\x8c\x17\xe4\x0b\x8e\x24\x6b\xb5\x15\x50\x85\x1c\x8f\xad\xde\x40\x33\x48\x06\x19\xae\x50\x4e\x5a\x34\x4b\x62\x5e\xb7\xaa\x51\xb2\x58\xda\x8a\xe6\x0b\x70\xc0\x73\xa2\x19\x7f\x40\xa9\x99\x9a\x01\x01\x4a\x5f\x3b\x37\x6e\x58\x13\xfb\x41\xe9\xe6\x9d\xfc\x93\x79\x18\x7e\x85\x83\x59\xdf\x8d\x23\xab\xde\xd4\x33\x69\x2e\x15\x53\xc3\xca\x60\xbc\xa9\x34\x27\xd7\xb5\xaf\xb1\xe4\xda\x5f\x51\x07\xd3\x2f\x77\xef\x38\xa1\xc2\x7f\x18\xb8\x2e\x1d\x4d\x02\x13\x15\xb8\x1e\xa5\x43\x16\x65\x6b\x54\x35\x19\x58\x0a\x00\x6f\x7d\x8c\xbf\x68\xdd\xf2\x70\x55\xc9\x74\xf2\x5c\xda\x92\xfa\xba\x16\x63\x4b\xed\x7e\x49\xc3\x25\xb4\xd4\x17\xd7\xe5\x1a\x0f\x10\xad\xee\x19\xa5\xee\xe5\xab\x1b\x0a\x90\xdd\x27\x1a\xe4\x77\xec\x61\x90\xe9\xc9\x11\x54\x1f\xe9\x60\xcb\x75\xa3\xac\x4d\xcb\x0e\x56\xdd\xa1\x47\xae\x51\xc9\x72\x26\xe1\x5c\xdd\x2d\xe7\x83\xdc\x62\xfb\xfc\x78\xaa\xf2\xab\x3c\x10\x8b\x98\x0a\x06\x22\xfa\x19\x86\x64\x62\x90\x67\x27\x0a\x73\x68\x5a\xd9\xaa\x97\x94\x20\x8a\x8b\x0d\x3f\x7c\x00\x57\x67\x00\x59\xae\x65\x75\xac\x66\xba\xfc\x9b\x2a\x1c\xd1\xc5\x7c\x28\xe9\xc5\x26\x35\x1d\xe7\xea\x49\x6a\x49\x62\x09\x8f\xd7\xd0\x7b\x67\x26\xfc\xd0\x09\xe2\x34\x19\x36\x63\x8a\x06\xcc\x8f\x01\x3e\xed\xab\x61\xf8\x8c\x77\xc4\xdd\xf0\x61\x82\x7c\x1f\x6d\x54\x9f\x47\xf4\x19\x78\xcc\x36\x0a\x58\x19\x40\x62\x40\x27\x1d\xdd\x2c\xea\xca\xf2\x1c\xee\x7c\x9e\x4f\x22\x00\x9e\x84\x60\x44\x00\x2f\xd7\x81\xb7\x30\x25\xbe\x2b\x6b\xb1\xa8\x9d\x87\x1e\x58\x66\x80\x95\xad\xbc\xb3\x0d\x1d\x8c\x67\x72\x29\xda\xa6\xbc\xb8\x80\xc4\xf9\x93\xb2\x2e\x5b\x05\x3a\xa6\x81\x38\xc9\x55\x55\x50\x2b\x06\x42\x1a\x5b\x35\xbc\x25\xad\x81\xbd\x82\x8a\xde\xbf\xff\x95\xb4\xb7\xd7\xa1\xbe\x64\x61\x6e\x4f\x88\x6e\xfd\x02\xda\xa0\xc3\x56\xc0\xb6\xef\x73\x76\xda\xb2\x16\x39\x92\xa0\x67\xef\x20\x43\x6d\xa7\x7f\xf0\x78\x37\x46\xc1\x58\x17\x02\x9f\x32\xf6\xae\xad\x04\x7c\xbc\xec\x8a\x40\x2f\xfa\x61\x97\x06\xdc\x19\x8f\x8f\x6d\x25\x0e\x70\x4e\x5b\x11\xc0\xb8\x2e\x52\x6f\x2b\xa4\xed\x7d\xcb\x98\xba\xa4\x8b\x11\x3d\x63\x59\x93\xbb\xf8\x8d\xc4\x1f\xf9\x95\x82\x7f\x32\x71\x5a\x23\x1c\x7a\x02\x32\x6a\x90\x24\x2a\x69\x4c\xe0\xb9\x5c\x1a\x5a\xe2\xb6\x84\xa2\x46\x93\xcf\x9b\x5d\x29\xb7\xf8\x09\xbd\x79\x6f\xb6\xdb\xf0\x56\xea\xb7\x9f\x84\x98\x93\xc7\x0c\x6b\x2a\x99\xef\xa3\xda\x57\xf4\x23\xd7\xf4\x95\x72\x4f\xfe\x10\x70\xa7\xf6\xbe\xae\xcd\x22\xb9\xbd\x62\x8f\x37\xf6\xd5\x83\x5d\x11\xe3\x39\xd8\x0d\xe6\xbd\xff\x22\xee\x26\xee\xe6\x02\x5f\xbb\x62\xc2\x4f\x6b\x30\xd8\x5f\x6b\x5a\x9d\x3b\x3c\xc8\x5c\xb3\xc0\x83\x57\x75\x2c\xde\xf6\x6e\x89\xe6\x7a\xde\x5f\x39\xd7\x0c\xc4\xb2\x4b\x05\xbb\x47\xb2\x2f\x91\x74\x93\x61\xc0\xa8\x33\xc8\xf9\xc3\xce\xfe\x32\x0d\x2f\xcc\x74\x4d\xcb\xc1\x6e\x2f\xca\x02\xe9\x0e\x7b\x73\x37\xd3\xc4\x90\xe4\x77\x67\x49\x7e\x2a\xca\xfa\x4a\x36\xa5\xac\xdb\x1c\xcc\x0e\x6f\xdb\x89\x5e\x60\x3c\x27\x89\x62\x67\xfe\x62\xef\xeb\x81\xed\xb6\xc4\x8e\x00\x76\xf1\x10\x2c\x2b\x08\x9a\x93\x99\x15\x37\xc0\x60\x02\x6d\xd9\x35\x53\xed\xa6\x62\xc5\x9c\x36\xda\xf2\x9f\xf0\x04\x70\xd7\x75\x12\x55\xc1\xd5\xc2\x14\x92\x78\x74\xae\x61\x26\xef\x94\xdc\xf7\xd6\xee\x86\x5d\x62\xa9\x67\x27\x07\x27\xa2\x7f\x7e\x25\x17\x17\xd3\x7a\x4b\xbc\x46\x18\x1a\x8e\x28\x9d\xca\xab\x52\x37\x04\x10\x52\x07\x8b\xb5\xc5\x5e\xc0\x93\x45\xbb\x68\xd8\x07\xf8\x08\xc5\x08\x82\x17\x51\xb5\x90\x45\x81\x0e\xc3\xcf\xf9\x7a\x79\x26\xd9\xe1\xbf\xbf\xa8\xcb\xba\x55\x35\x02\xc4\x6c\xf9\xd6\xca\x5a\x9c\xa2\xd6\x84\x1b\x90\x5c\x89\x1d\x67\xbd\x48\xb4\xd2\xbb\x51\xe8\x70\x0a\x18\xf5\xf5\x2e\xe2\xc1\x2d\xc7\xdd\x1b\x75\xe3\x77\x51\x1b\xef\xd3\x8b\x8f\xdb\x7c\x9b\x78\x81\x75\x81\xa8\xbe\x35\x19\xee\x56\x1a\xce\xb1\x6f\x37\xc1\xa2\xf5\x91\x1a\x35\x28\x9b\x11\xb5\x6d\x71\x08\x26\x80\x43\x92\x9e\xe3\x26\x58\xfc\x59\x2f\xe0\x38\xa5\xa4\xb5\x18\x4f\x9e\xa9\x44\xd7\xe2\x5b\x23\x00\x7c\x70\xa6\xaf\x14\xd6\xd6\xed\x1a\x78\xda\x96\xed\xb0\x37\x10\x89\x3b\x7c\xf4\x33\x01\xc6\x89\x12\xc7\x46\xfb\x22\x16\x97\x62\x81\x9e\x77\x34\x13\xc0\x0a\x91\x23\x45\x59\xe8\x25\x83\xeb\x39\xd7\xd6\x15\x77\xfe\xf9\x0f\x92\xce\xac\x22\x59\xbc\x00\x48\xef\xcc\x6f\xdd\xe9\xc0\x8c\x13\x88\x89\xc4\xaf\xfe\x44\xd2\x62\xd0\x2c\x13\xa5\x63\xcd\x99\x32\x24\x56\xe6\x18\xf3\xb7\xa6\x3b\x8e\x1d\x90\x4a\xef\x7d\x6b\xee\x71\x1e\x70\x02\x1f\xc8\xd6\x6b\x29\x60\x93\xbd\x37\x08\x06\x11\xb2\x69\x1c\xe9\xcd\x02\xec\x8a\x88\x8f\xae\xdc\x9a\x76\x70\x10\xf5\x79\x40\xc4\x2c\x12\x39\xd6\xd9\x25\x2c\x2b\x97\xe3\xb6\x1c\x83\x1b\x1e\x6d\x37\x5d\x2b\x0c\x23\x28\x6b\x8a\xf3\xbf\x56\xe2\x1a\x22\xac\xc0\xe6\xc3\x87\xd8\x51\xdb\x33\x60\xaf\xe0\xea\x8c\x9e\xa9\x73\x5d\xb0\x2a\xb5\xb0\xc4\x73\x5e\xa9\x0f\x78\x95\x48\x38\x8e\x47\x75\xab\x6d\xf7\x64\x59\x83\x2d\x93\xc2\xab\xe8\x48\xe1\xaa\xdc\xc1\xc9\x3e\xee\xce\xb6\xe4\x84\x58\xb7\xd9\xcf\xd8\xc4\xe1\x9c\xd6\x28\x62\x94\x2b\x73\x00\x36\xb6\xc3\x7a\xd1\x82\x6f\x0d\x99\xc1\x9a\xe8\x16\x0f\x2d\x4f\x86\xcc\x59\x04\x93\x64\x4f\x84\x20\x1d\x3c\x9c\x0b\x46\xb5\x43\x77\xbb\xdf\xc8\x06\xc0\xf2\x21\x38\xc4\x4e\x13\x84\x64\x36\x43\xf1\x56\xf5\xaa\x4a\xc8\xca\x68\x66\x30\x60\x5d\x7b\xf6\xea\x68\xb8\x6e\x9b\x6c\xa6\x4e\x10\x63\xf9\x20\x8d\x29\x2f\xea\xfe\xdf\xbf\x24\x87\x6f\x4c\x0a\x19\xa9\xe8\x06\xa3\xd6\x3a\xf9\x31\x29\x9a\xe8\x8f\x41\x1c\xc9\xed\xf4\x5b\x34\x32\xda\xbe\x45\x16\x50\x69\xe0\x82\x6b\x69\xff\x08\xf1\x4c\x54\x0d\x60\x1d\xb8\xf6\x76\xad\x2e\x9a\xb2\x65\x95\x88\x6c\x6e\xae\x65\x08\xdc\xb1\xfb\x1b\x50\x8b\xc4\x52\xb5\x03\x07\xa3\x00\x2d\x82\x17\x8e\x6c\xc5\xa4\x6c\x0c\xa4\x69\x21\xf8\x22\x02\xb6\x13\x65\x6c\x4f\xa3\x90\x0c\xb0\xd7\x51\xc6\x21\xd4\xd8\x82\x9e\xb3\x7a\x3f\x63\xc5\x19\x4c\xcb\xfb\x79\x1e\xbb\x89\x42\x9f\xa9\xe0\xf3\xe7\xc4\xe2\x19\x7b\x85\x66\xec\xb2\x5e\xdb\x44\xb3\x2a\x08\x47\x65\x8b\x03\xe2\xd9\xab\xa7\xaa\x29\xdb\xe0\xf3\x9e\xb1\x52\xe1\x36\xf9\xa5\x6c\x43\xf4\x13\x26\xf2\x77\x51\xce\x65\x2d\x8b\x2b\xd5\xb4\x18\xfb\x02\x5e\xd0\x11\x9e\x84\xc8\x58\x6b\xd7\x99\xf4\xd6\xc8\xb4\xab\x67\x74\x20\x32\xc6\xd9\x0d\xe4\xdd\xf5\xaa\x65\xa6\xd6\x4e\x30\x65\xa8\x0a\x32\x41\xa8\xf5\x3b\xa7\xa3\x74\xdc\x62\xb3\xdc\x75\xe5\x72\x67\xdd\x21\xab\x20\xad\x26\x83\xb1\xb7\xeb\x58\x15\x03\xe4\x63\xe0\x70\xbf\x8c\x36\x62\x19\x47\x32\x36\x20\x2c\x58\x30\xa6\x48\xbb\xbd\xc0\xcc\xec\xb7\x0b\x86\x52\x5d\x96\x73\x72\x0b\x67\x30\x1a\xbb\x73\x81\x90\x2c\x45\x15\x48\x75\x66\xff\xcd\x30\xf2\xb4\x02\x32\x34\x81\x55\xaf\xac\x96\xc0\xe1\x67\xf3\x05\x5a\x53\x88\x6c\x90\x72\xc9\x83\x19\x77\x28\xd0\x91\x23\xcb\x9c\x86\x93\x2e\x5d\x42\xcc\xec\xca\x78\xfb\x2d\xbc\x17\x37\x4f\x82\x3b\xec\x62\x56\x66\x94\xd0\x55\x21\xfa\xba\xc1\xcd\xee\x6d\xeb\xb0\x79\xf1\x26\xe5\xda\x9e\xdc\x6e\x42\x8e\xd0\xce\xe3\x50\xaa\xbd\x67\x6c\xc8\x5a\x1d\x3e\xcc\x95\x6a\x8c\x42\x80\x6d\xf2\x92\x59\xaf\x8c\x67\x36\xd9\x6a\xbd\x3c\x5b\x78\x34\x12\x2f\xf5\xb5\xe7\xf6\x76\x00\x8e\xe3\xd7\x05\xe2\x3f\x10\x90\x55\x6a\xdc\x5d\xcb\x19\x82\xa9\x5c\xd5\xcf\xcd\xd5\xdf\xcc\xf7\x91\xfb\xd6\x57\x4d\xd3\x4f\x6b\x3e\x83\x67\xe7\x14\x9a\xbf\x67\x99\x6c\x62\x69\x5f\xcd\x73\xbb\x65\x6f\xe4\x8c\x41\xa4\x64\xd0\xad\x49\x59\x17\x24\xc3\xa4\xb7\x6e\x71\xb4\xae\x73\x96\x76\x61\x20\xda\xe1\x41\x03\x6d\xaf\x16\x1e\x77\x81\x29\x80\x08\x50\x4e\x44\xd9\x62\x85\x33\x79\xa9\x8c\x30\xaa\x36\x0a\xd6\x09\xd2\xbd\x82\x39\xa7\x44\xa4\x40\x8a\x5f\xe6\x7e\x78\xa3\x5b\xd6\x28\x97\xd7\x24\x1c\x77\x35\xd8\x2f\x66\x68\x94\xfe\x48\xcc\x28\xe8\x3a\xb1\xbc\xfe\x32\xac\x36\x80\x0b\x9d\x24\x11\x9e\xf6\x31\x0c\xec\x6e\xc6\xa7\x91\x23\xe8\xe2\x03\x0a\xf0\x3c\xbb\xd8\x90\xb6\x22\x77\xfc\x6c\xce\xdb\x52\xff\x02\x9a\xa7\x1c\xa2\xa8\x10\x77\xe9\x6d\x6e\xc6\x9f\x83\x05\x2d\x40\x6b\x29\x54\x2b\xc7\xd3\xce\x12\xfc\x02\x53\x2c\x3c\x0e\x2a\xb6\x91\xdc\x4a\x26\x73\x13\x9a\xb6\xed\x90\x5f\x6a\xc0\x64\xdb\x13\x0f\x77\x7d\x56\xa1\x37\xe0\xb1\x28\xf4\x5c\xfe\x68\xcf\xb2\xe5\x5c\x21\xb8\xd4\xe1\xe9\x8b\xb2\x6e\x85\x55\xb3\x2a\x46\xcd\x43\x99\x73\x59\xb7\xf2\x13\x65\x61\x5b\xd6\x63\xb1\x27\x1e\x21\xc0\xd5\x4b\x48\xdd\xb5\x27\x1e\x3f\xfa\xfe\x37\xdf\xff\xf6\xc9\xaf\xbf\xff\x0d\xb4\x73\x2c\x3f\x59\x99\xf8\xc9\xe3\x1d\x71\x2c\xdb\xe9\x70\xae\xaf\xfb\x8f\x07\xe2\xc9\xa3\x2d\xb1\x2d\x1e\x61\x45\x6f\x5e\x1e\x9d\x7d\x38\x3d\xfa\xdf\x87\xb6\x36\xc2\xcb\x3a\x7e\xf6\x1f\x47\xfb\x1f\x5e\xbe\x39\xfe\xe1\xf0\xf5\x87\x93\xe7\xcf\x4f\x0f\xcf\x6c\xe5\x08\x68\xf7\xc8\x85\x19\xab\x4f\xf3\x92\x12\x04\x03\x16\x4b\xa3\xe6\x96\x15\xd5\xad\x11\x8f\x1e\xce\x42\x60\xdc\x99\x39\xd3\x87\xae\xf4\x59\x39\x53\xfd\x99\x71\xfb\xff\x19\xe6\x59\x96\x45\x01\xf3\x31\x99\x18\xd5\x86\xd8\x78\x88\xec\x61\xf7\xd1\xd4\x9f\x75\x33\x79\x51\x8e\x45\x8d\x28\xd2\x13\xcd\x73\x3c\xf4\x6b\xd2\x9f\x19\x31\x0a\xc6\xf7\x59\x3c\xdc\x12\x0f\x72\x83\x4b\x6e\x8e\x15\x5c\x19\xf6\xeb\xc5\x0c\x0e\xf8\x71\x69\x4a\x5d\x47\x26\xfc\xbe\x7d\x29\x46\xfe\x2d\x57\xfe\x68\x4b\x7c\xe7\x9f\x26\xf5\x82\x08\xa2\xfc\x3c\xfc\xb0\x18\x5f\xaa\x96\x1d\xec\xed\xac\x0c\x82\x39\x3d\xaa\x8f\xcd\x40\x9c\x43\x99\xd3\xf2\x6f\xea\xd8\x44\x5d\xe0\x5e\x06\x5f\x8b\x07\xc9\xe7\xe1\xf0\xe3\xaa\xc2\x37\x5b\x01\x99\xfa\xf3\x82\x48\x01\x92\x2b\xa0\xcf\xa0\x41\x7a\xbb\x13\xb8\x48\xfc\x20\x8b\x63\x39\x7f\xa5\xab\xe5\xc4\xea\x50\x81\x1f\xa0\xc7\x87\x42\xd6\x54\x1f\x7e\x6a\x55\x0d\x6a\x1b\x1e\x2c\x62\x4f\xe0\x1f\x43\x7b\x56\xa9\xba\xa5\x02\xba\x36\xfd\xbf\x7f\x61\xf9\xe0\x3b\xa1\x4c\x55\xd6\xed\x76\x81\x29\xb8\x44\xad\xb7\xad\x90\x40\x59\xb4\xec\x9f\xc7\x72\xde\x7f\xf7\x2e\xd3\x02\xba\x08\xbd\x7f\x4f\x75\x31\x8e\x5a\xae\xe8\xfb\x4e\x7b\xe8\x56\x15\x35\xe7\xe1\xaa\x42\xa0\x22\xd8\xca\xfb\x1a\x82\x75\x9c\xb7\xa9\x90\xe7\x7a\xd1\x8a\x73\x59\x88\x39\x4d\x8e\x61\x4f\xcc\xce\x9c\x45\xf1\x85\xe0\x21\xf4\x9c\x9d\x44\x40\xc3\xd2\xb5\x90\xc2\xdf\x10\xc1\xae\xa8\x95\x2a\x0c\x1d\x35\x85\xae\xad\xd4\x06\x0e\x3b\xf6\x6f\xf2\xd1\xb0\xda\xdd\x1d\xb0\x55\x20\x5c\x55\x3b\x05\xd0\x6c\x04\xaf\xf3\xc7\xd1\x1d\xbf\xa0\x10\xbb\x04\xfe\x5c\xc0\x4c\x1e\xc5\xe4\x0b\x9d\xb2\xdc\xad\xdf\xca\x8b\x81\xb8\x54\xcb\x01\x7a\x8e\x03\x32\x3a\x9a\x9f\x18\xf0\x02\xb4\x47\x94\x81\x2d\x2d\x4c\x4b\x83\x47\xab\x68\xe5\xc5\x2e\x3f\xb9\x54\x4b\xb1\x67\xeb\x71\x4f\xc8\xe7\x80\xbd\x74\xe1\x99\x63\xaa\x21\x74\x3e\x64\xb6\x3b\x57\x0d\x15\x0a\x40\x00\x92\xaf\xd1\xf4\x95\x56\x59\x9e\x57\xe8\xb6\x1a\x3d\xe6\xa4\x11\x78\xa2\xc2\xa3\x46\x4d\xc2\x66\xe1\xd9\x9c\xc2\x98\xe0\x2a\x3f\xa9\x82\x75\x8b\xec\x4b\xd4\x81\xff\xe7\x42\x2d\x3a\x83\xe4\xef\xc0\x21\xa0\xd3\x62\x77\x96\xc1\x64\x90\x3e\xe4\x99\x21\x47\x49\xfe\x1a\xdd\xf4\xf0\xa3\x97\x1a\x5f\xba\x86\x6b\xf5\x89\x3c\x4b\x3b\xad\x82\x0d\x24\x79\x47\xaf\x2a\xd9\x79\xe3\x5a\x8b\xb8\x3c\x34\x89\x61\x36\x5c\xc0\x63\xcf\x74\x12\x45\xc0\xfb\x0f\x1e\xce\x26\xa4\x47\xf6\x3b\x0e\xca\x9c\x32\x46\xbe\xf7\xea\x0e\xde\x9e\x10\xca\x77\xf6\xe5\x0d\x01\x7a\x60\xf1\xea\x6e\x55\x0f\x01\xbb\x8a\x73\x25\x08\xb0\x5e\x84\x5a\xc9\xea\x6c\xa7\xd2\x68\xed\x20\x68\x08\x5c\xa5\x5c\xc2\x28\xae\x78\x20\x1a\x49\x3e\x82\xd2\x32\x87\x57\x27\xff\xe3\x24\x2c\x38\x10\xa6\x2d\xab\x0a\xfc\xec\x50\xb4\x21\x33\x19\x1c\xa6\x78\xe5\xa5\xab\x0a\xf0\xe8\x76\xe0\x4c\xdf\x12\x2f\x35\x98\x6d\xc9\x0d\x0c\xcf\xe2\xa5\x37\x17\x10\xd2\x19\x9a\xbf\x4a\x33\x74\xfb\xdb\xbd\x41\x18\x13\x5b\x9b\x10\xc8\x71\x8a\x72\x32\x29\xc7\x8b\x0a\x64\xe2\x79\xa3\x8a\x72\xdc\xa2\xb1\x0c\x70\x4f\x2e\x54\x2b\xf4\xbc\x2d\x67\xa0\x8d\x4b\xd4\x4a\x97\x10\xf9\x24\xab\x99\x36\x2d\xd5\x55\x83\x70\x53\xd6\x15\x98\xe4\xe7\x8d\x9e\xab\xa6\x02\x9b\xbf\xe5\x0d\xe5\x18\x98\x59\x59\xa9\xc6\x80\x8b\xe2\xe3\x74\x2c\x8d\x15\xfe\x74\x2d\x3e\xf2\x60\xf4\x44\x10\x14\x2d\x44\x43\x5b\xa6\xd3\x2a\xd3\x96\xf5\xc5\x50\xbc\xe5\x08\x6a\x6a\x5c\xa2\x6c\x02\xf0\xbc\x68\xe7\x6b\x19\x38\x0c\xe2\xa7\x47\x23\xf1\x64\xcb\x7e\x85\x40\xfa\x0c\x0a\xa6\x5c\x7e\x1c\x94\x58\x10\xe6\xb6\x5e\xcc\x54\x53\x8e\x31\x69\x2b\x60\xd1\xfa\x21\x2b\x69\x4a\x04\xba\xb5\xa4\xaa\xdd\xcc\x20\xf6\x4b\xad\xeb\xed\xff\x71\x74\x26\x54\x7d\x55\x36\xba\x9e\x01\xe7\x1e\x8d\xc4\xf7\xd0\x36\x5c\x73\x49\x53\x56\x4b\x71\xa1\xd1\x5e\x1e\x13\x0e\xf8\x9a\xa2\x57\x08\x9e\x2d\xe4\xe8\x59\x95\xad\x6a\x64\x65\x09\xde\x1e\x2b\xd4\x7a\x69\xc4\x44\x9a\x96\x86\xf7\xab\x2d\x71\xd4\x06\x08\x4a\x4a\x1a\x40\x35\x24\xb1\x14\x1d\x41\xa5\xd8\x17\xd8\x1a\x2c\x24\x60\xd2\xda\x67\x90\x8f\x0a\xd2\x04\x59\xba\xa5\xfa\xed\x7a\xc9\xd6\x9e\xbe\xe4\x45\x1b\x74\x2c\x44\x49\xd9\xe8\x9c\xf9\xe6\x79\xa5\xaf\x9f\x97\x9f\x8e\xd5\x0e\x0a\xc9\x53\x39\x27\x1c\x6b\xf5\x49\x8e\x5b\x01\x67\xe1\xf9\xa2\x15\xb6\xa0\x33\xcf\x5b\x9d\x20\x9c\x22\x13\xc8\xf2\xea\x7a\xd3\xc3\x2e\x49\x41\x82\x93\xe4\x12\xb3\xf5\x03\x0d\x32\x90\xdc\xee\xde\xf5\x2f\x86\xf3\x46\xb7\x1a\x48\xf0\xfe\x7d\x91\x79\x3c\x2c\x0d\x28\x29\xbe\xaa\xdd\x84\x45\x80\x52\xd3\x6a\x9a\x45\x2b\x41\x7b\x16\xeb\x02\xa2\x0b\xcd\xb2\xc4\x30\xcd\x87\x14\x03\xe9\xf7\x9d\xb1\x33\x3c\xe7\x42\xb9\xd4\xf2\x75\x6f\xa8\x8c\x8d\x13\x1e\x67\xc8\xf3\x79\x76\x5a\x4b\x4b\x76\x41\x1f\xc9\xb9\x58\x8a\x02\x72\xbb\x12\x52\xa6\xdd\x38\x73\xad\xd1\x8b\x4f\x8d\xa7\x75\x69\xd5\x25\xbe\xcf\xf1\xd0\xd9\xa0\x2b\xf4\xaa\x8a\x6b\x03\x1b\x02\xb0\x0e\xf0\x20\x96\xad\xb0\x3c\x45\xb4\xd7\x9a\x33\x0c\x18\xab\xc4\x20\xb6\x33\x6c\x7c\xdb\x0a\xd0\xd0\x3d\x08\xc8\xbc\x47\x39\xb1\xb8\x42\xd0\xff\xb8\x9d\x46\x89\x89\xd5\x38\x01\x26\x7d\x61\x94\xbf\x09\xaa\xe4\xdf\xec\x46\x64\x1f\x2c\x67\x19\x97\x55\xa5\xd1\xc5\x9b\x2b\x84\xa4\xd8\xb4\x15\x0d\x23\x33\xd4\x17\x14\x99\x69\x29\x18\x59\x1f\x0a\x0e\xc5\xd0\xee\x43\xb8\x48\xb2\x55\x5d\x8b\x85\xdd\x79\x5c\x57\xa3\xc6\x95\x2c\xf1\x9e\x0c\xeb\xb5\x32\x45\xb3\xb4\x53\x6f\xc7\xcf\x36\xb3\xee\x7a\xf9\xcd\xc7\x6b\x3f\x04\x9a\xe7\x1f\x40\xfb\xfc\x23\xbb\x07\xba\xf5\xb2\x24\xe7\x2a\x24\xb7\xd1\x4e\xb9\x50\xba\xe3\xc2\x81\x85\x3b\x72\x82\x18\x8d\xc4\xc1\xe1\x7f\x6e\xc3\xba\x4e\x4a\x55\x15\x9c\x99\x31\xa9\x33\x90\x20\xb8\xca\x10\x12\x6f\xe5\x17\x4e\x9e\x88\xbf\x8a\xb3\xee\x64\xbf\x64\x59\x23\xfe\x30\xc8\x29\x42\xf1\x68\xc9\xc7\xa1\x28\x14\x25\xea\xe8\xec\xa1\x6c\x16\x98\x14\xa0\xf4\xad\xf7\x08\x67\x6b\xbf\xab\x60\xe8\xcd\xc9\x56\xb9\x06\x2a\x41\x01\xae\x95\x17\x39\xca\x58\x21\x36\x7a\x53\xbb\xab\xa0\x2a\x4d\x4b\x1e\x1a\x15\x26\x13\x80\x7b\x8f\x6c\xa5\x19\x71\x33\x53\x2a\x2f\x79\x76\x8a\x65\xa4\x50\x9a\xe9\x74\x28\xa9\x4c\x1a\x3f\xd8\xed\x7e\x91\xc8\xf8\xe1\xcf\xdd\x4c\x03\xac\x65\xf0\xba\xc1\xef\x4c\xb5\xa9\x7a\xc0\xe5\xa3\xe7\x6b\xbe\x63\xf5\x20\xfd\x0e\x9e\x67\xbe\x8b\x35\x0e\xfe\x2a\x78\xea\x1c\xa8\x00\x6e\x97\xaf\xce\xf5\x95\x6a\x9a\xb2\x28\x54\x1d\x46\x83\xbb\x2b\xc0\xf8\xba\xbc\xdb\xaa\x57\xaf\xdc\x8e\xc6\x27\x99\x1e\xb2\xce\xe5\xf9\x4b\xa1\x3e\x65\xca\xa1\x22\xc6\xa5\x1a\x35\x09\xef\xde\xd2\xad\xf1\xa5\x93\xf3\x8f\xcd\x9e\x61\xb6\x97\x08\x1c\x2f\x60\x82\x5c\x96\xc1\x34\x9c\x51\x24\xc4\x4e\x25\x23\x6b\xb7\x25\xa8\xe3\x79\xa3\x67\x87\x28\xf7\xf4\x29\x65\x78\x4e\x7c\x58\x7d\xaa\xea\x44\x79\xc1\x3d\xce\x4f\xa9\xca\xe1\x07\xcd\x1c\xc6\x5d\xb2\xf3\x80\xbc\xdd\x32\xf0\xe5\xe7\xef\x00\xc9\x92\xf8\x19\x2a\xe1\xfc\x06\x94\xf1\xd8\x63\x0d\xbf\xcd\xaa\x35\xdc\x58\x2a\xf6\xb4\x90\x14\xf8\x69\x34\xab\xb1\x45\x7d\x8d\x58\xb7\x13\x7d\x96\xcf\xce\xb6\x4e\x20\x73\x1d\xe3\x33\xc8\x9f\x3d\xf8\x38\xd9\xdb\x3c\xf4\x39\xef\xbd\x20\x54\xb7\x33\x05\xa6\xb5\xdb\xa1\x33\x01\x29\xf9\xfc\xdf\xef\x28\x0a\x15\x2e\x6b\x49\x2e\x95\x15\x48\x97\x7c\xe1\xd1\x43\x43\x6a\x2f\x90\xc6\xfc\xad\x8c\x34\x80\x4c\xe9\x6e\x36\x08\x96\x12\x2d\xbf\xa4\xb7\x51\x4c\x90\x57\x8d\xf8\x2c\x1a\xc6\x96\x32\x7b\x70\x2c\xed\xe1\x2d\xcc\xd2\xb4\x6a\x06\xee\xea\xae\xa5\xf3\x46\x5f\x12\xcc\x14\x79\x0c\x80\x9a\xa7\x67\xe8\x8d\x64\x86\xe1\xf9\xd3\x28\xf4\x13\xa4\xea\x5a\xdd\x28\xd7\x7a\x92\x0a\x84\xd4\x37\x9f\xaf\x04\xef\x14\x8d\xbb\x85\x0c\x83\xff\x20\x42\x29\xe6\x29\x4f\xc5\x5b\x52\x5b\xe3\xc1\x5f\xa8\x96\x51\x12\x54\x21\xe8\x96\x89\x63\xb4\x82\xa6\x09\xce\x53\xd6\x28\x2c\x62\xf3\xd8\x13\xdd\xd0\x5b\x8e\x73\x1b\x57\xba\x56\xa2\x6c\xc3\xb1\xe2\xcc\xce\x1b\x7d\x2e\xcf\x2b\x08\x00\xaf\x40\x32\xbc\x96\x4b\x94\x40\x71\xe7\x2d\x1a\x74\x7a\x1d\x46\xd4\xf9\x95\x74\xe5\xad\xb7\x51\x62\x3a\x11\x21\x67\x38\x8a\x73\x09\x7b\xc4\xe7\xcf\xe2\x56\xe4\x48\xa6\x11\xab\x13\x23\xe7\x18\x56\xaa\xbe\x68\xa7\xf0\xe5\xc3\xd0\x07\x95\xb3\xdd\xf5\xc0\xb7\x93\x6e\x75\x26\xba\xb9\xd0\xac\x73\x5b\x95\x74\xa9\x17\x81\x7d\xd3\x7b\x8f\xc1\xed\x4e\x4f\x3c\x10\xf7\xc0\x07\xcc\xbb\xf8\x0d\xec\x1a\x2c\xf5\x82\x54\x78\x90\x9d\x66\x00\x0b\xbe\x98\xbb\xf4\xcd\x10\x8d\x28\xed\x2e\xc0\xeb\x74\x33\xbc\x17\x7b\x7a\x76\xd3\x2c\x22\xbb\x7e\xba\x2a\x1b\x5c\x82\xb9\xe3\xd2\xce\xf9\xec\x11\xc9\xa8\xff\x52\xff\xa5\xde\x47\x5c\x62\xa0\x7e\xc8\x4b\x48\x2e\xb0\x7a\x22\x3e\x76\x12\x65\x7e\x1c\xa6\xd0\x1d\xe4\x9d\xd0\xb9\xca\x44\x12\xc0\xb5\x81\xc8\x10\x10\xe1\x76\x84\xbb\x69\x93\x02\x59\x9f\xe8\xdb\xbd\x79\xbe\x28\xab\x76\xbb\x0c\xb0\xee\xcd\x16\x6e\x1b\xb8\xec\x1c\x05\x90\xad\x94\x5f\x31\x01\xce\x37\x5b\xb0\x3f\x2f\x74\xbb\x23\xbe\x35\xc3\x6f\x4d\x6f\xc0\xd4\x82\x74\xf1\x14\x7f\xee\x84\xa4\x34\x80\xa9\xd8\x4a\x62\x80\xba\x09\x32\xc3\x13\xd2\x04\xc2\x7b\x27\xdf\xdf\xea\xa3\x14\x8b\xde\x28\x37\xde\x46\x1e\x60\x3c\x66\x16\x08\xcc\x26\x12\x01\x9c\x1f\xeb\xc5\x15\xae\x77\xfd\x51\xb3\x6e\xe7\x9b\xdd\xcd\x47\x7c\x8b\x01\x9f\xa9\x4f\x2d\x7a\x67\xdc\x56\xfa\x59\x75\xac\x9e\x81\x37\x07\x4a\x65\xb7\x19\x27\x75\xe2\x97\x19\xa6\xed\x18\xdb\x42\x9f\xeb\xe6\x40\x55\xca\x16\xdb\x40\xc8\x0c\xa4\x84\x9c\xa4\x19\xc9\x06\xbd\x83\xc3\x17\x87\x67\x87\x07\xbd\x5b\xf5\x6d\x5f\x56\x55\x7f\x2c\xf3\xf3\x75\xbb\xf9\xb7\x55\x05\x1d\x06\x08\xab\x9b\x09\x8e\xcd\x00\xb6\xf4\x54\xd6\x45\x85\x7b\x2c\xbf\x4a\x12\x99\xe1\xcf\xbf\x44\x08\x92\xde\xc7\xf2\x2f\x21\x77\xd9\x4f\x9d\x8e\x04\x77\x7d\x23\xaa\xfc\x39\x87\x84\x40\xf0\x7d\x70\xec\xfa\x19\x56\xd7\x63\xcb\x0f\x04\xd6\xb9\xc1\xe2\xa6\x4a\x32\x7e\x07\xba\x6f\xa3\x6a\x2b\x07\xbc\x7b\x7f\xab\xd1\x27\x51\x41\x94\xe6\x11\x7d\x95\xc0\xdb\xe7\xa8\x9e\xe8\x1d\xd7\x50\xf8\x14\xd5\x19\xea\xd1\x3e\x75\x81\x52\x41\x5a\x19\xea\x0d\x79\x7e\x04\xa9\xea\x49\xc0\xc4\x23\x31\x32\x53\xbb\x26\x12\xeb\x35\x64\x7f\xdf\x70\x91\xac\x06\xd9\x8f\xbb\x28\xa6\xcb\xa2\x91\xad\xf2\x7e\x4f\xcb\x71\x05\xd7\x17\xa4\x38\x95\xba\x26\x33\xe2\x78\xaa\x64\x8b\x98\x96\xb0\x85\x48\x56\x6e\x40\x40\xb1\x02\xa5\x4f\x68\x32\x1a\x09\x3f\x63\x56\xfc\xae\x97\xec\x72\xbc\xa8\xcb\xba\x6c\x4b\x59\x95\x7f\x53\xc5\xf3\x68\xd9\x13\x85\x98\x15\xc5\x46\xeb\xd6\x4f\x3b\xe7\xd7\xec\xd6\x33\xc8\xad\xcb\xc6\x0b\x42\x7e\xe2\x33\x59\x42\xaa\xb0\x88\x0e\x76\xe8\xc2\x10\x0b\x81\xf1\xbb\x58\x3e\xd7\x0d\x02\x8b\xec\xe0\x2d\xdd\x80\xce\xf3\xba\x34\x53\x84\x26\x0d\x6b\x26\xe7\x9b\xf0\x11\xf7\xa3\xfb\x86\xd6\x64\x87\xff\x18\x90\xaf\xc0\xa7\xd6\x21\x26\x41\xca\x06\xf8\x84\x29\xa0\x3b\x21\x11\xd5\xda\x59\x0c\x08\x05\x7f\x92\x8b\x85\xae\x71\x24\x8e\x48\xa2\x14\x82\xd1\xdb\x37\xf5\x8c\x90\x58\x7c\x81\xa9\x34\x2f\xf4\xc5\x85\x2a\x0e\xc1\xb9\xc9\xdd\x5a\x86\xb8\x07\xed\x78\x0a\x6f\x4d\x7f\x12\x7b\xad\x78\xb1\x4c\x36\x0e\x05\xc6\x3b\x6a\xf8\x72\x35\x14\x20\xd3\x65\x9c\xa4\x2b\x94\xfd\x9b\x05\xdc\x5a\xdc\x8d\x3b\x15\xca\xae\x9d\xee\xae\x8f\x09\x43\x64\x35\x4e\x37\x2a\x54\x3d\xc6\xcb\x5f\xb8\x1e\x44\x7f\x2e\x2b\x2f\xf6\x06\xf6\xef\x4c\xa4\xd5\x97\xd4\x03\xdb\x6a\x16\xec\xa0\x66\xfa\xcc\xcd\x82\xb8\x06\x12\x2f\x3f\x7c\x78\x7d\xf8\x6c\xff\xec\xc3\xc1\xe1\x7f\x9e\x9d\x9c\xbc\x38\xfd\xf0\x1f\x2f\x4e\x7e\x78\xf6\xe2\xc3\x1f\x4f\x4e\xfe\xf4\xe1\x03\xea\x30\xdd\x7c\xcf\xe0\xbd\xea\xba\xbb\x22\xfa\x81\x7c\x65\xb4\xbe\x14\x7b\x37\xb4\xc3\x37\x25\xb6\xf0\xb0\x34\x07\xe8\xf2\x52\x84\xde\x26\x78\xc7\x60\xf5\x4a\x29\x1a\x25\x2b\xba\x0e\x6d\x97\x1c\x97\x60\xbf\x45\xe5\xb7\x6c\x39\xb3\x04\x58\x7c\xe1\x46\x51\xe8\x85\x8b\x61\xd1\x13\x3f\xd3\x18\x38\xe1\x15\x7a\x69\x8c\x1e\x63\x60\x38\xad\x91\x81\xe7\x95\xbe\xf0\x3a\xf8\xb4\x6d\xe7\x66\x67\x34\xba\x28\xdb\xe9\xe2\x7c\x38\xd6\xb3\xd1\x44\x8e\xd5\xb9\xd6\x97\x23\x70\x0d\x1c\x81\x23\x9d\x19\x3d\xf9\xed\x6f\x7e\x13\xce\x8e\x77\x78\xe1\xab\x76\x3b\x60\x06\x2a\x7a\x5e\x06\x19\x29\x12\x28\x34\x47\x29\x67\x1c\xd6\x01\xb9\xdf\xe9\x3e\xc7\x0e\x29\x21\x21\xb8\x9d\xd4\xe0\x38\x0d\x41\x46\x65\x55\x81\xc7\x28\x5c\x86\x41\xa4\x9f\x73\x28\x63\xf5\x3f\xad\xcc\xb9\x07\x12\xd4\x5a\xdc\xc2\x10\x6b\xe1\xb9\x98\x9c\x0f\x67\x0a\x47\xbf\x5d\xa8\xab\xd6\x16\xe9\x45\xb0\xa8\xa3\x51\x40\xe0\x94\x3c\x1b\xb0\xb5\xdb\xa9\x5e\x5c\x40\x10\x06\xdf\x51\xb2\xef\x1f\x72\x98\x55\x33\x18\x7b\x5a\x91\x31\xa2\x81\xeb\x0f\x24\x24\xd8\x05\x01\xf1\xef\x06\x17\x06\xa0\xec\x9a\x05\x40\xf8\x4c\x16\x15\x5c\xab\xff\x15\x54\xbe\x81\x30\x1a\x8e\x1a\xbc\xf0\x36\x72\x82\xfe\xf6\xca\x9e\x9c\x50\x33\x51\x42\x8e\xa3\x45\x4c\xc8\x71\x9d\x26\x02\xd3\xa4\xa1\x40\x1f\x3b\x75\xf4\xfd\x38\x06\xc0\x40\x79\x0e\xe9\xdf\x15\x8c\x32\xdf\x6e\x94\xe3\x64\x4d\xc3\x54\x4f\xd4\xb6\x8f\x97\xe6\xc6\x73\x0c\x11\x60\x1d\xec\x43\x59\x55\x94\x17\x30\x88\x38\x83\x5b\xda\x9a\x67\x10\xe0\x9d\xd9\xb0\xee\xce\x11\xd8\x7b\xc3\xb5\x34\xbf\x21\x77\x1c\x46\xec\x91\xb3\xcd\x77\xc9\x6e\x5d\xec\x0a\x4f\x0b\x2e\x85\x5b\xb6\x80\x63\x66\x56\x3d\x6b\x23\xce\xac\x2c\xaf\xe6\x97\x6c\x93\xbc\x08\x09\x80\x41\xae\x59\xb7\xee\x37\xb7\x1c\xd7\xba\x9b\xa2\x86\x15\x65\xf1\x56\x36\x35\x63\x23\x9a\xb2\xa0\x3c\x24\x91\x67\x3b\xac\x32\x66\x5c\x40\x07\x03\xcb\x49\x38\xc8\xa7\x20\xb0\xd1\xb2\xbe\x82\x6b\x5e\x5d\xdf\x81\x2f\x4e\xcb\xfa\xa2\x5a\x8a\xaa\xac\x2f\x55\xb1\x0d\x97\x65\x7a\xe2\xe2\xa1\xd0\xae\xe8\x12\x00\xc3\x4e\x63\xb9\x63\xc0\xbe\x26\x10\x7f\xde\xea\x3b\x64\xa7\xfc\x11\xee\x73\x28\x76\x31\x4e\x28\x4d\xc6\xd8\x6e\x4e\x7d\x14\xad\xc1\x6c\xda\x5e\x6b\xac\xc2\xd8\x0a\xed\x30\x8c\x9a\x4b\x2b\xfb\x70\xc4\xf5\x52\x98\x29\x78\xe1\x84\xe2\xb2\xb3\x30\x0e\xef\x8c\x46\x41\xce\xdc\x34\x78\x92\xed\xb6\xb6\x02\x0c\x78\x2c\xbc\x0d\x2e\xdf\x2f\xc8\x68\xec\xda\x46\xc1\x90\xcf\xb3\x68\x7c\x76\x00\xb2\x25\x67\x26\xba\x26\x2f\x27\x64\xad\x0d\xeb\xb5\x15\xda\x99\x3b\xd7\x0d\xb0\x32\x5b\x13\xfd\x48\x3a\x38\xd6\x57\xb0\x83\xce\x97\x60\x78\x85\xfc\x1a\xb6\xb7\x7c\xd5\x44\x83\x3d\xcb\x75\x1e\x17\xc2\xb6\x43\x0e\xcc\xc2\x2c\xce\x2d\x83\x4c\xd6\x06\xca\x71\x4d\xce\x90\x0c\x0e\xeb\x90\xa6\x14\x70\x0e\xb9\x9b\x9d\x56\xce\xd5\x58\xcf\x94\x09\x6b\x1c\xde\xe9\x28\x1d\x6f\xfc\xa5\x5e\xff\x5c\x1a\x05\x57\x82\x5e\xe9\xfb\x91\xee\x00\x71\x6b\xb8\x02\x3b\xfe\x4f\x14\x7c\xd5\x1a\x61\x1c\xae\x65\x43\xd9\xb9\x92\xf1\x6f\x4e\x47\xf2\xa2\x8c\x9f\x4f\xa5\x79\xae\x9b\x31\xf5\x31\x92\xe1\x4b\x73\xe4\x25\x69\x7a\xc3\x52\x36\xf6\x15\x27\xaf\x34\xaf\x30\x1a\x2b\xf1\xd5\x0b\x5c\xf0\x7f\xc4\x0b\xcd\x58\x00\x34\xaa\x69\x79\x57\xb7\x1a\xa7\x07\x0a\x32\xa1\x7a\x27\xf4\xb9\x55\x12\x60\x96\x3d\x5e\x32\xdc\x93\xd7\x05\x2f\xa8\xdd\xbd\x0c\xe8\x80\xfd\x02\x88\xec\x8c\x2b\xcb\xff\x64\xd2\x80\x50\x9a\x60\x20\x30\x89\x62\x4f\x84\x9f\x53\x83\x1d\xdb\xbb\x2f\x03\x17\xe7\x51\x41\xb1\xb2\x86\xa8\x7f\xa9\xd6\xbd\xc7\x0e\x99\x56\x3d\xcf\x16\xf9\x03\xd5\x35\xcc\xd9\x0f\x44\xfe\x9b\xbd\xfc\x37\x5d\x26\x9f\x2e\x48\x90\xfa\xa1\xb3\x20\x18\x38\x8d\x9e\x0c\xad\xb0\x22\x58\x0b\xee\xcb\x20\x9f\x06\xce\x3c\x45\x69\xda\xb2\x1e\xb3\x42\x4f\xbc\x8d\x75\x60\xe7\x01\x11\x65\x05\x88\xbd\x93\xdc\x06\x79\xe4\xde\x47\x77\xe4\xc1\x84\x3e\xca\x26\xab\x85\x9b\xad\xb7\xc9\x65\x13\xa6\x77\x83\x0d\x86\x1a\xba\xbb\x5f\xc7\x83\xe2\x5a\x21\x32\xa8\xcb\xd6\xc6\x21\x7b\x85\xb2\x94\x08\xae\x96\xe1\x95\x15\xe5\xb8\x40\xb4\x44\xe2\x03\xc2\xef\x1e\x87\x6f\xe2\x29\xce\x72\x55\xd7\x3a\x70\x97\x9a\x75\x01\x88\xa0\x88\xbc\x0a\xc0\xb9\x11\x25\x1f\x70\x84\x7c\x09\x71\x55\x73\xf0\xb1\x46\x71\x5f\xce\xe7\x4b\x8e\xbf\xb0\x4c\x6f\x3e\x6f\xb4\x1c\x4f\x87\x9e\x2e\xb2\xf3\xe7\x6c\x0e\x21\x8b\x0a\x50\x1f\xc2\x05\x78\x1c\x5d\x5d\xdb\x59\x4f\xd6\x2f\xc5\x6f\x77\x5f\xc5\xe5\xd2\xf5\x0b\x56\xf0\x71\x67\x05\x37\xaa\x65\xfd\x28\x48\xce\xea\x6c\xde\xc7\x91\x67\x4a\xf0\x90\xfe\xb0\xc3\xa1\x99\x7b\xca\xcf\x76\x22\x37\x77\x2b\x96\xc0\x19\x97\x15\x11\x08\x95\x04\x33\x85\xb8\x22\xde\x51\x78\xe8\xd8\xa8\x1d\x3f\x91\x70\xcc\x4c\x99\x0f\x3c\x8e\x2e\xe5\xf0\x51\x54\x12\xc2\xe4\xee\xae\x94\x94\x3a\xb0\xd5\x4e\x6e\xf5\x08\xf4\x7d\xc6\xbc\x1b\x70\x44\x3d\xfd\xd2\x10\xc2\x33\x76\x55\x5d\xcb\x70\x90\xa0\x61\x65\x47\xea\x07\x2a\xde\xc4\x0f\xc2\x9c\x9f\xf3\x45\x63\xfb\xe1\xb4\xbd\xbf\xa9\x46\x0b\x5b\xd1\x36\xba\x30\x99\xa1\x0f\xe0\x40\x47\x5d\x77\x51\x75\x50\x12\x60\x36\x5e\x6f\x21\x36\x0c\x67\xdd\xea\x39\x13\xc4\x3a\xf9\x31\xcd\xdb\x16\x42\x13\x34\xaa\x47\xc1\x8e\x96\xb3\xd1\xc1\x24\x8b\xee\x31\x24\x49\x8a\x00\xee\xa7\x3e\x95\xf1\x31\xd4\xa5\xe9\x35\x27\xdf\x23\xc7\x69\x77\x03\x95\x72\x37\xee\x1b\x81\xe6\xfc\x18\x1d\x63\x83\xf0\x9a\x1a\x7a\xa9\xc5\xb9\x6e\xa7\x01\xcb\xf5\x8c\x32\x3e\x1a\x3d\x99\xe5\x8f\xcc\x5b\xf4\x77\x4d\xd1\xc7\x9b\x0c\x0d\x7a\x6c\x4f\x72\x2f\xc3\xd3\xe8\x5c\xce\x0b\xbf\xd3\x5c\x6a\x4d\xb8\xf6\x74\x5f\xde\x89\x30\x45\xf4\xc4\x49\xc7\xb2\x02\xd9\x19\x38\xe8\xa9\x1e\xf8\x84\x5c\xb8\xca\x92\x84\x0c\x0d\xeb\xad\x27\x77\x9c\xf3\x01\x54\x3b\xbc\x73\x8b\x99\x18\x8d\xc4\x0f\xe8\xe3\x00\xce\xfe\x6e\x61\x98\x6c\xa6\x4a\x7c\xb4\xa3\xf9\xe8\x40\x4c\xf4\x84\xd7\xc0\xb1\xa2\x54\x7e\x48\xb0\x43\xb1\x1b\x49\xe4\x5e\x2e\x0d\xa7\x0b\x30\x5d\x09\x67\xb7\x22\x00\x95\x84\x37\x8e\x12\xf1\x16\xb3\x98\xf7\xae\x3c\x95\xa3\x62\x9d\x84\x97\x99\xba\xe9\x61\xf0\x5d\x47\x6a\x49\x26\x01\x78\xd4\xf3\x46\xcf\x28\x35\x25\x7e\x3a\x70\xb1\x11\x88\x02\x40\x9c\x0c\xbc\x28\xbc\xdc\x3d\x97\x8d\x3d\x9f\xd9\x71\x8f\xc4\xa4\xf0\xe9\x6e\xac\xe0\xc6\x1f\x64\x15\x5b\x3f\x3b\xcf\x6b\x8c\x47\x8d\x2a\x4b\x86\xf8\xbc\x1e\x5a\x86\xd5\x5f\xd3\xdb\x8e\xe0\xe9\xf1\xaa\xa2\x9a\xbf\xe4\x00\xe0\xc2\xf3\x70\x05\x50\xc6\x80\x39\x5b\xd8\x07\xf0\x2a\x47\x79\xe3\x30\x23\x69\x06\x49\x92\x72\xf9\x91\x86\xe9\xba\x43\x0b\xb1\x2f\xb9\x73\xa8\x21\xc7\xf8\x15\x0a\xdc\x20\xd4\xfd\x32\x6a\x1b\x4f\x39\x3d\x66\x8a\xfc\xd1\xcb\x16\xac\x5c\xad\xf5\xbe\xe4\xd3\x31\xd0\xbd\xc2\x1a\x87\x89\x22\xd6\x55\xc5\xa2\xd2\x89\x9b\x00\x7d\x42\x1a\x5a\x54\xd2\x41\xd9\x78\x8d\x2d\x7a\x6f\x1f\xf1\xeb\x44\x1b\x8b\xca\x45\xef\xf8\x03\xe7\x3a\x8a\xfe\xd8\xc4\x50\x23\x3f\x60\xc7\x25\x41\xb9\xc7\x8c\xb6\xe4\xa5\xec\x34\xdf\xa1\xaf\xce\xf9\x27\xcf\xf8\xe1\x2a\xad\x72\x85\x5e\x89\x27\x6d\xe2\x24\x32\x1a\x89\x53\x45\xd1\x2a\x93\x4a\x5e\x04\xf8\x37\xd7\x24\x60\xb1\x68\x02\x2a\x39\x9a\x95\x5d\x06\x36\x3e\x8b\xb9\x2e\x6f\xb4\xb2\x82\x19\x66\x6f\x0a\xe1\x7c\x57\x68\xad\xde\x6a\x7b\x27\xf1\xc5\x76\x97\x61\x69\x4c\xf5\x90\x52\xde\x99\xcb\x72\x0e\x7e\xb9\x10\x95\x45\x26\x8c\x81\x0b\x78\x18\x8d\x44\x59\x5b\x3a\x67\x6c\x76\x39\x1e\xeb\xa6\x00\xd3\x93\x63\xf6\x6b\x63\xf3\x7e\x3e\x35\xe6\x67\x55\x62\x7e\x36\x15\xe6\x06\x05\x06\x12\xcc\x13\x93\x8e\x15\x90\x1f\xbb\xd4\xcf\x6c\x86\x3f\xf8\x31\xde\xc0\x1d\x76\xba\xa2\x5c\x97\x63\x74\xfc\xb9\x3d\x21\x05\xcd\x47\x94\x44\xf6\x4b\x5d\xb7\xc7\x0b\xfb\xd5\x2b\x66\xee\x41\x29\x7f\x60\xb8\x4e\x00\x57\xd8\xf5\xd6\x4f\x40\xdb\x09\xec\x2a\x84\x1d\x41\x5f\xa5\x5a\x97\xaf\xf0\x70\x63\x43\x40\x78\x5c\x1f\xa6\x26\x87\xd5\xe7\x40\x78\xf1\x45\xbd\x71\x28\x5e\x74\x79\x31\x99\x94\xe3\xd2\x32\xec\x79\x53\x6a\x40\xff\x42\xf0\x20\x76\xa1\xe4\x8b\x91\xec\x7d\xb3\x9b\x91\x5c\x8f\xb1\xcf\x2b\xbf\x8c\x8c\x29\xab\x4a\xfd\x21\x3b\x53\xe1\x25\xe9\x68\xc4\xca\xcb\x7a\x56\xe0\x3e\x58\x6b\x83\x39\xcc\x8e\xe3\x4b\x30\x9e\xbb\xb4\xde\x61\x1f\x3c\x09\xc4\x37\xb4\x5d\x92\x35\x9e\x36\x7d\xb5\x04\x3f\x0d\xb9\xea\x69\x6b\xc2\x16\x27\x6a\xa0\x52\x8e\x06\xe9\x71\xed\xc0\x41\x84\x4b\x75\x1f\xc5\xcb\xe4\x16\x7e\xe5\xa2\xbb\x4f\x8e\x26\xf6\x0c\x72\xa9\x08\xd8\xde\x0b\x47\x8f\xe5\xa3\x73\x55\x0c\x44\xd1\x68\x82\x97\x62\x4d\x92\x6d\xd4\x78\x9a\x9f\x3b\x13\x8a\x2c\xae\x64\x3d\x66\xe1\x60\xaa\x64\xc7\x1c\xb8\x6a\x5a\x63\x8b\x5f\x66\xd0\x9e\xbf\x50\xa1\x8e\x65\x22\x31\xf3\x85\x0e\xa3\x5f\x92\x99\xa2\xa3\x26\x3d\xae\x2c\xed\x7f\x48\xc4\xd0\x10\xd5\xc4\xef\x4a\x08\x35\x04\xad\xdc\xb7\xcf\xac\x6b\x23\x31\xd8\xa4\x42\x25\x50\xd6\x5a\xd6\xd4\x49\x84\x97\x76\xf5\xeb\x1b\xb6\x03\x8b\x6a\x8b\x9c\x6a\x27\xa2\x9f\xe9\x59\x58\xa4\x13\x5d\x7a\x54\x5c\x8a\xa9\xbe\x06\x02\x87\x98\xe1\x29\xfa\x64\x43\x38\xf2\x30\xf8\x8e\x27\x2d\x84\x65\xa4\x2e\xc6\x1d\xf2\xfb\xac\x93\x0e\xb0\x5b\xcb\x4d\x35\xf8\xbd\x9c\x9d\xf1\x28\x8b\x79\xe4\x0e\x1c\x12\x00\xc8\x53\x45\x4a\xc2\xb1\xa0\xb5\x22\x75\x3e\xd5\xc1\xe2\x5a\x26\xd5\x62\x60\x65\xd7\x82\x6f\xc2\xb8\xbc\x09\x99\xf5\x87\x50\xe8\x73\x2c\x3a\x7c\x18\xad\x72\x5c\x3a\xb3\x89\x6e\xae\x4f\xec\x91\xb7\x5a\x38\x97\xd1\x67\x43\x80\xec\x8a\xec\x0b\x58\x6e\x15\x5b\xfb\x72\x27\x12\x21\xa2\xd6\xd2\xc9\x59\x19\x7c\xf7\x79\xcf\xdd\x39\x26\x31\x1f\x39\xc6\x01\x26\xba\xdc\x9a\x45\x3e\x24\x2a\xb1\xeb\x0c\x39\x86\x1c\x80\xc4\xdc\xb9\xb9\x56\x9d\x89\xe2\xed\x72\xec\x2f\x77\xa2\xac\x39\x4d\x62\x61\xfd\xa5\xd3\x21\xe6\x4e\x80\x5e\x23\x58\xc7\x60\xa3\xa4\xbd\x52\xd5\x09\x02\xcf\xac\x6c\xdd\x1d\x2e\xdf\x04\x8d\x53\xa4\xf2\x8d\xa8\x0f\x34\xd4\x75\x84\x17\x5a\x9f\x02\x15\x04\xcf\x0d\xbb\x05\x60\xc5\x00\x4e\xfc\x52\x21\x86\x19\xe8\x48\x85\x83\xd9\x25\x3d\x24\x84\x6f\xc1\xa4\x0c\x59\xfa\xe5\x25\x71\x20\xca\x25\x02\x4e\x95\xe2\xf7\xd1\x88\x28\xbe\x62\x57\x94\x0f\x1e\x74\x25\x3a\xf2\xc4\xe5\xc2\xef\x4a\xda\x15\xd1\xb6\xf4\xc4\x3e\x0e\x88\xb3\x73\x60\x63\x40\xc5\xb9\x43\xf6\x55\x85\x90\x17\xb2\xac\x87\x62\xbf\x52\x92\x52\x5c\x71\x95\x46\x13\x38\x6f\x5d\xb9\xb3\x97\x26\x80\x87\x2d\xd2\x56\xa3\x23\xf1\xae\xf3\xe6\xf2\xaf\x13\x03\x4a\x0e\x55\xec\x08\x83\x1d\x84\x6c\x2e\x16\x10\x05\x31\x97\xd8\x53\xe3\xfa\x36\x14\x87\x3e\x10\xc2\x9b\x9c\x8f\x28\xa7\x51\x83\xc9\x5d\x0a\xf2\x4d\x73\xcd\xa7\x00\x62\xee\x05\x5a\x64\xe2\xbc\x18\xe4\x1f\x38\x91\x97\x8a\x3d\xd6\x8e\x3c\x08\xe8\xdf\xbf\xa0\xff\x5f\x69\x9e\x35\x8d\x5c\x8a\x3d\x01\xff\x0e\xe9\xf7\x6e\xc7\x95\x01\x90\xda\x61\x97\x3d\x83\xe3\xc3\x8e\x0c\xdd\x28\xc9\x32\x87\x75\x06\x59\xd3\x4e\x6a\x9a\x89\x7d\x3f\xb9\xde\x87\x86\xbb\x8e\xae\xdf\x71\x94\x0a\x1b\xfc\xa3\x69\x67\xab\x2f\xad\xc9\x8a\x25\x01\x44\xee\xfe\x70\x38\xdc\xda\xf1\x73\xec\xec\xb0\x7a\x8e\xb8\xfa\xe2\x23\x7f\xfe\xd1\x2f\x13\x47\xa3\xe1\xed\xc0\xda\x45\x01\xd0\x76\xd7\xed\x81\xeb\x0c\x4e\xbd\x0f\x82\xc5\x00\x7e\xa3\xc5\x45\xa3\x8d\x21\x2f\xba\x9e\xf1\xf7\x8f\xb5\xae\xb7\xc7\x4d\xd9\x96\x63\x59\x81\x29\x9e\x3c\xec\xd8\xd1\xa1\x24\x8b\x2e\xf8\xde\x2d\x8c\xc2\x98\xad\x4a\xcd\x8c\xc7\x07\x98\x29\xc2\x08\xb9\x28\xaf\x6c\xff\xeb\x72\xac\x1a\x02\xab\x9b\x29\x63\xe4\x05\x58\x9b\xd9\x44\x20\xc7\xed\xc1\xc9\xf1\xa3\x5f\x0d\x37\x81\xd2\x6e\xb8\xf8\xaf\xbd\x6b\x3a\x56\x64\xa7\x78\x8b\x54\x71\x30\x58\x5c\x97\x60\x2b\x68\xf4\xb5\x11\x52\xdc\xfb\x90\x41\x3b\x65\x34\x74\x4f\xf3\xf7\xee\x10\x70\xc1\x58\xcd\xf9\x7e\x89\xe2\xb7\xd0\x39\xf2\x15\xb9\x23\xf6\x73\x74\x3c\x10\xbd\x5c\x33\xbd\x01\xd1\x91\x02\x7c\x14\x3b\xc6\xc8\x47\x00\x70\x5a\x77\x02\x5a\x0c\xdc\x50\x3b\xbb\x79\xed\x38\xae\x64\x59\x01\xac\x17\x43\xff\x89\x47\xbf\x7e\x40\x2b\x43\xe1\x64\x76\x75\x0c\x44\x83\x61\x1c\xd8\xa2\x6a\xcb\x79\xa5\xc4\x58\xcf\x4b\x65\xbc\x87\x21\xdc\x42\x37\x4a\xc8\xb6\xb5\x67\x28\xa5\x98\xaa\x95\xb1\xd3\x45\x75\xff\x8a\x7c\x3c\xe8\xd2\xca\x35\x89\x8f\xf1\xa6\x69\x83\x55\x1d\xd0\xb2\x95\xa6\xfe\x8b\xf7\x0a\x54\xc5\x50\x9c\x35\xcb\xf8\xfc\x70\xfd\x76\x77\x4a\x63\x3d\x5f\xfa\x5e\xf7\x6d\xb7\xcb\x42\xc9\xaa\x5a\x0e\x84\xb9\x2e\x21\x8f\x85\x76\x64\x36\x44\x5b\x29\x86\x02\x6c\x0d\x43\xcf\x45\x74\x7e\xa3\xc5\x9e\x34\x4a\xfd\x4d\x65\x17\xd9\xa3\xc9\x41\xa5\x70\x91\x9a\x5c\x0a\x84\x7c\x85\x6f\xf9\xc0\xcd\xa4\x0b\x91\xf7\x5c\x37\x94\x73\x9e\x6c\x23\x04\x47\x42\xbf\x02\xa1\xdd\xaa\xa0\x49\x8e\x23\x94\xa0\xe9\x4e\x34\xb2\x83\x34\xce\x20\x5b\x1a\xc2\x02\xdd\xf1\x7f\x92\x2b\x4c\x0d\xa7\xec\x29\x29\x20\x21\x01\x06\x76\xec\x40\x18\x0f\xf8\x4a\x94\xb8\x83\x03\x2e\x2e\x54\xeb\x33\x29\xed\x26\xd6\xcd\xe0\xd8\x4d\xe2\x29\x9f\x22\x2b\xdd\x11\xf1\x51\x2b\x92\xe4\x1c\x1d\xf6\x1d\xb0\xec\x1e\x1b\x27\x7b\x5b\xb9\xa0\xc5\x8e\x25\x61\xe5\x32\xf4\x43\x77\xc8\x44\x6a\xf0\xdd\x49\x2d\xd7\x79\x63\xb5\x88\x26\x6f\x27\x9e\x4a\x57\x86\x07\xe1\x87\xef\xdf\x39\x7d\x35\x62\x17\xf8\x06\x15\x99\xce\x0b\x2b\x9b\xef\xbb\x2a\x43\x63\x32\xbe\x73\x7e\xfe\x82\xad\xc8\x22\x73\xe5\x98\x73\x5b\xe1\xb2\x21\x41\x73\x91\xc4\x95\x86\x36\x55\x44\x66\xaf\x83\xfb\xf0\x3c\xa9\x99\x7f\x72\x1a\x0b\x6f\xf4\xff\x99\xe9\xcc\x7c\x15\x81\x59\x25\xe6\xff\x65\xfa\x8a\x2f\x4a\x32\xe4\xf5\x4f\x4b\x57\x81\x63\xc8\x3f\x33\x59\xc5\x6b\xfd\x53\xd9\x56\x4c\x6e\xff\x4c\x54\xe5\x24\x66\xaf\x55\x4f\xd5\xf8\xf2\x94\x30\x40\xe8\xec\x25\x53\x5d\x7a\x0f\xac\xab\x82\x0e\xf0\x5a\x5d\xd3\x5f\xba\x2a\xe8\xf8\xac\xd5\xb5\xff\x2b\x49\xf7\x03\xe1\xf1\x15\x23\xe7\x04\xfa\xc5\x1a\x2b\x45\x78\x6f\xbc\xba\xd8\x0a\x4b\x49\x98\x40\x24\x01\xcd\xf2\x28\x4b\x46\xc8\x9a\x8d\xf7\x68\xb3\x19\x84\x4e\xf5\x54\x51\x12\xb4\xe1\x8c\xb6\xb7\x48\xf4\xb0\x49\x4e\xd6\x7c\xa2\x31\x93\x5b\x98\x95\x38\x95\x69\xa2\xa8\x74\x01\x7b\xd9\xea\x7a\xd1\x96\xc2\x22\xce\x56\xb8\xbe\x27\x7d\x4f\x08\xd9\xe5\x77\x04\xda\xc9\x33\x95\xe5\x24\x56\x0d\x8d\xda\xbf\x1b\xf2\x23\xcc\xff\x94\xef\xc7\xd6\x8e\xc0\xa0\x5e\xf0\xe4\xf7\xe8\x10\xa8\x4d\x02\x50\x1c\x68\x9a\x9c\xb1\x1b\xb4\x92\xa1\x38\xf6\xb6\x1b\x1d\x2e\x34\xb8\xb4\xd9\xdd\x9d\x4d\x17\xb5\x2e\x39\x69\xc0\xe3\x62\xfa\x09\xc7\x15\xd1\x11\x2f\x7b\x0c\x26\x18\x3f\x19\x96\xe6\xd5\xa2\x51\x09\x96\x60\x1a\x13\x73\xd7\x4c\x01\x5b\xee\xf0\xc7\x85\xac\xfa\xdd\xdd\x0a\x3d\xed\x14\x4a\xb6\xef\x56\xd4\xb9\x4e\xc4\x52\x87\x75\x80\xd8\xce\xea\x43\x36\x03\xd1\x2f\xb0\x55\xc2\x43\x6e\xc3\x14\xb2\x21\x8d\xa3\xb6\xf6\x0a\xe1\xce\x43\x22\xc7\x17\x71\xde\xbd\xa8\x70\x7a\x0b\x91\x5f\x38\xc6\xe7\xf1\xeb\x47\x78\x1f\xab\x36\xae\xc8\xa6\xd8\x23\xcb\xca\x4b\x2d\x3e\xe2\xf7\x1f\x19\x30\xc4\x65\xa3\xc4\x3b\x47\x22\x7c\xaf\x3b\x01\xad\xf3\xa8\x76\x44\x51\x16\xa0\x5c\xca\xf1\xb8\x2c\x54\xdd\x5a\x05\x92\x97\x56\xd6\x0c\x27\xea\xee\xd0\x02\x60\xcd\xa7\x94\x70\x6c\xfd\x65\xc7\x2f\xd8\x75\x40\x76\x91\x84\x89\x87\x68\x31\xad\xaa\x01\x14\x13\x53\x02\x72\xfd\xc3\x4c\x4f\xd3\xad\x88\x60\xe6\xff\xa1\x5a\xba\x8f\x07\x82\x3f\xa9\x0f\x4f\x7f\x2d\xf6\x7c\x36\x9e\xe1\x45\x5c\xc0\xee\x9a\x55\xef\x1c\xc0\xa7\xdd\x05\xcf\xe6\xf3\x06\x0c\x49\xe1\x07\xd1\x8d\x2b\x4f\x54\xbe\x13\x98\xd2\x2f\x6a\x1a\x50\xc1\x89\x9b\x41\xaa\xc3\x81\x90\x62\x5e\xc9\xb2\x16\xff\x43\x5e\xc9\xd3\x71\x53\xce\x11\x5c\x9f\x63\x19\xcf\xc2\x24\x1c\xce\xda\x00\x66\x65\x28\xa6\x7c\x82\x61\xb4\x61\x60\x98\x24\x3e\xdb\x0f\x2a\x3a\x20\xa2\x99\x59\x7e\xe9\xe7\x5b\x92\x62\xee\x42\x57\x89\xc9\x76\x28\xc5\x4d\xf6\x01\x82\xf0\x00\x0b\xca\x4e\x76\x58\x20\x9d\xec\xf0\x5d\x76\xb2\xb3\x53\xdb\x69\x12\xa7\x36\x6a\xe8\xff\xe2\xd4\x42\xee\x08\xc6\x3f\x76\x13\xe9\xe7\xb8\x08\xfb\x49\xf3\xdb\xa1\x6f\x9c\x5f\xe6\xbc\x2e\xa3\x60\x34\xb9\x73\x7e\xda\x9d\xa5\xce\x87\x03\xd1\x73\xc5\xa3\xc9\x41\x39\xc9\xf1\xef\x30\x66\xf9\x5b\x33\x14\xd1\x60\x60\x78\x99\x11\xf9\x9a\x37\x1b\x4e\x92\x46\xd6\x8f\x28\x4d\x51\x9f\x1f\x54\x9c\x50\xb1\x17\x65\x7e\xfe\xb9\x87\x16\x55\xbe\x7e\x74\xee\x80\x3a\x8d\x85\xac\x54\xea\x1b\x67\xcb\xc5\x49\x66\xbb\x83\xcf\xd6\x0e\xdc\x18\x65\x5d\xe6\xc0\x74\x2d\x83\xde\xf0\xb9\x6f\xfa\x5b\x43\x11\xed\xfe\x15\x32\xd7\x53\xde\x16\x0a\x0f\xe1\xd2\x88\xf9\xb4\x91\x74\xfd\x22\xc5\x8f\x0b\x65\x40\x50\x08\x9c\x08\x45\x90\x6c\x1b\x3f\x57\x41\x9e\x33\x3e\x93\x48\x3e\x4b\x67\xf1\xab\x45\xa5\xe0\x60\xbe\x41\xb4\xbe\x9b\x07\x0b\xc8\x9f\x72\xd9\x79\x5d\x31\x59\xb4\xf5\xf3\xad\x92\x97\x79\xad\xe1\xbe\x0d\x53\x27\x4d\x55\x2d\xd4\xa7\x16\xb1\x2f\x88\x95\xd8\x91\x79\x98\x69\xac\x91\xe2\xdb\xb1\x28\x95\xf3\x03\x2f\x27\xf9\x0e\x31\xf6\xf4\xc6\x02\xee\x33\x08\xc4\xf0\x07\x75\x5e\x9b\x0f\xa8\xf0\xa0\x2c\x7c\x68\xf7\x4a\x0a\x0f\x4a\x6d\x4c\xdf\xfe\x9b\x4d\xa9\xdb\x7f\x61\x17\xe2\x87\x24\x35\xb1\x59\x8c\xa7\xa2\x2a\x27\x6a\xbc\x1c\x57\x0c\x89\x9f\x3b\x05\x5d\x7d\x6f\xcb\xaa\x72\x15\xae\x38\xf9\xc2\xee\xbe\xc6\xeb\x2c\x06\xdb\x59\x37\x1b\x51\xd1\xdb\x4c\x49\xf8\xe1\x2d\xe6\x25\xfc\xec\xb6\x93\x73\x34\x71\x73\xd3\x26\xc1\x0b\x28\x24\x94\xe0\x95\x30\xd7\xb5\x01\x0d\x0b\xf2\xbf\x01\x22\x38\x75\xd2\x56\x62\x19\x43\x34\xb1\x69\x8f\xd2\x56\x26\xaa\x1d\x4f\x45\x21\x5b\x69\xd5\x34\xa8\xa3\x59\xd4\x51\x48\x90\x7d\x31\x5b\x20\xf0\x8f\x11\x72\xd2\x2a\xba\xd0\x80\x39\x21\x44\x6e\xe8\xe7\x9b\xa3\x81\x88\x7a\xe0\x62\x86\xfa\x5b\x37\x71\x71\xea\x6c\xa9\x36\x58\xd9\x4e\xd9\x8d\x97\x36\xfd\x72\xd3\xb5\x4d\xbf\xeb\x70\xf5\x35\x93\x9e\x25\xe9\xa9\x34\xe8\x98\xe4\x10\x90\x23\x39\x03\x87\xb4\x06\x8a\x39\x1d\x63\xf2\x75\x07\x87\xf2\x6e\xd2\x60\xa8\x58\x40\x1c\xb6\x1d\xb6\xa5\x26\xf0\x12\xc6\x7c\xf0\x1f\xbf\x35\x1f\x07\xa1\x4b\x86\x06\x87\x00\x44\x8e\x5c\xcc\x7d\x44\x10\xb6\x09\xa1\x59\x31\xe4\x64\xcf\x44\xb9\x17\xac\xb4\x80\x2e\x05\xc3\x7b\x94\x7b\x79\x9d\xdc\x12\x49\x98\xa1\xdc\x12\x8a\x74\xab\xe5\x96\xf0\xf3\x81\xe8\x9d\xaa\x16\xb3\x65\x86\xb5\xae\x95\x59\xf8\xb2\xd4\x4b\xa7\x0e\x38\xe5\x5c\x89\xf2\xa2\xd6\x8d\xe5\xf9\x96\x50\xf8\xae\x7d\x90\x95\x3a\x81\xbc\x52\x09\x15\xc5\xa2\x5e\x66\x1e\x02\x9b\x18\x7b\xbe\xe5\x34\x20\x7b\x80\xe3\xfb\xfb\xf7\x9d\xb1\x0b\x1f\xdc\x0d\x91\x46\xad\x12\x80\xbe\x11\x58\x7c\x6b\x6b\xdd\xad\xf1\xb7\x64\x43\xd8\x11\xb3\x85\x69\x03\xcc\x1c\xaf\xdb\xea\x06\x6c\x89\x1b\x1c\x76\x5b\xa9\x67\xdc\x4d\xb9\xff\x57\xe9\xf4\xce\xa1\x25\x63\xc5\xc8\x24\xcf\x0f\x91\x56\x6f\x93\xfc\xbc\x5b\x13\x4f\x42\x90\x06\x1d\xb2\x82\x02\x87\x36\x99\x24\xfa\x9b\xc8\x00\xa9\x37\xcc\x97\x8e\x35\x08\xdc\xcf\x8e\xea\xf9\xa2\x7d\x85\x11\x6b\xa6\x63\x7f\x74\x77\x10\x3e\x6e\x30\xe2\x00\x6b\x11\xd7\x77\xe3\x4f\xcc\x86\x4e\xf8\x71\x27\x65\xa1\xe7\xed\x3a\x93\xd5\x9a\x4e\xfa\xcb\x67\xfa\x0b\x7b\xb4\x26\x27\x02\x7f\x1a\xb8\x57\x05\xf9\xac\x31\x0b\x98\x1c\xa3\xdf\x2f\x25\xf6\x81\x1b\x1b\xce\x9e\x47\x20\x50\x6c\xde\x8f\x40\xef\x4c\x70\xa7\xb3\x22\x4b\xa9\xdf\x31\x9c\xd0\x36\xca\xf9\x18\x38\x28\xe5\x5c\x01\x56\xad\xb3\xe3\x8e\xeb\xa7\x31\x08\xa5\x23\xb7\xbc\x16\x30\xc4\x56\xda\xf4\x10\xf3\x2e\xca\x34\x8a\x66\xbd\x34\xfd\x68\x76\xac\xc0\x86\xed\x84\x06\x69\xb9\xf9\xef\x7d\x5d\x9b\x45\xd7\x1e\x1e\x7c\x39\x76\x1f\x45\x75\x00\xfa\xef\xf1\x9a\xc6\x07\x69\x8f\xed\x36\x49\xf2\xaf\x76\xcc\x9f\x90\x26\xb7\xd5\x4d\x9f\xa4\xa0\x71\x64\x2c\xbf\x0d\x85\xfa\x8c\x0e\xfb\x72\x3c\x55\xae\x33\x99\x44\xe1\x98\xc5\xa4\x51\x60\x8c\x80\x44\xca\x71\xc9\x45\x5d\x59\x32\xe4\xb4\xcb\xcb\x20\xe5\x84\xf3\x03\xe1\xa2\x66\x01\x06\x44\x76\xcd\x07\x4f\xea\x31\x74\xe0\x7c\x01\x14\xdb\x6b\xc1\x28\x52\xab\xeb\x6a\xb9\xcd\x26\x11\xee\xb5\xf1\x4e\xf7\xe1\x64\x7b\xc6\x09\x55\x6d\x38\xdf\xe9\xec\xc5\x66\xeb\x70\xff\x25\x44\x1c\x02\xa2\x5a\xf9\x07\x9c\x47\x6e\xe4\x05\x37\x5e\xb0\x8c\x3b\x75\xf6\x02\x32\x63\x6b\xfb\xaa\xd3\x31\x2b\x35\x62\xcf\x78\xad\x57\xdc\xa4\xd0\x05\xdb\xa9\x3b\x4a\xe3\xfa\xfd\xe4\xae\x53\x67\xb3\xed\xee\x08\x74\x41\x04\x39\xa4\x6c\xd4\x18\x32\xfd\xea\x20\xbd\x1f\x6b\xf2\xf7\x0a\x35\x6f\xd4\x18\x16\xbb\x8f\x4e\x66\xde\x7b\x2a\x94\xaf\xee\xa1\x9c\xea\x84\xac\x2d\xb4\xb4\xf8\x18\x3e\x6f\x44\xd9\xf0\xb4\xf6\x4a\x28\xb1\xe6\x61\xc6\x31\x23\x60\x97\xf1\xec\x20\xfe\xeb\xd6\x4a\x86\x97\xd2\x4a\x24\x2b\xaf\x22\x99\xf0\x92\xb4\x7b\x21\x7a\x3b\x42\x0a\x1b\xfc\xc9\xf4\x14\xf5\x3e\xdb\xc7\xdd\x9b\x28\x2d\x39\x84\x2d\xbd\x71\x57\x72\x94\x86\x1c\x36\x58\xc5\x0d\xae\x6b\xc0\xe6\xe0\x4a\xf4\x76\xa3\x5b\x97\xbb\x1b\xba\xc9\xbe\x8b\x5a\x7d\x7f\xd3\x7d\xcb\x9a\x79\x5a\xb9\x0d\x80\xf0\xe3\xbd\xf0\x0b\x6c\x83\x68\x1c\xc1\x0d\x87\xd8\xd4\x61\x38\x99\x89\x4e\xa4\xd8\x97\x5f\x6c\x1b\x41\x32\xd1\x2b\x7d\x49\x18\x58\x68\xea\xa9\xca\x89\xda\x06\x83\x82\xc1\x04\xa9\x1c\xef\x55\x2d\x29\x6b\x96\x4b\xcb\xe0\xda\x08\xb7\x24\xd4\xb2\xfe\x90\x5c\x17\x94\x18\x04\x84\x77\x25\x92\x00\x5c\x28\x92\xa2\x6e\xbe\xed\xfc\x69\xee\x01\x79\xbd\xc9\xee\x03\x87\x28\x43\xa8\x04\x79\x61\xb9\xab\x6a\xdf\xc5\x92\x39\x5d\x02\xb3\x52\xb0\xa6\x40\x9f\x52\xcd\xf6\xe8\x06\x0d\x13\xee\xa1\x70\xae\x7f\x99\xbc\xe7\x3f\x45\xe8\xcb\x2b\x10\xf3\xaf\xd4\x14\xe2\xd0\xc8\xe0\x3e\x78\x62\xba\x19\xf5\x23\xce\x1a\xf4\xf9\x76\x92\x62\xc0\x4f\x31\x5d\x31\x24\x6b\x26\x17\xe2\x67\xaf\x8e\x32\x7e\x2f\x94\x7d\x63\x95\x5b\x4c\x62\x1a\xdf\xb4\xa0\xf7\x4d\x2f\x0d\xf4\x21\xb1\x9d\x5b\xcd\xd4\x72\x8b\x00\x23\x28\x4d\x03\xd5\xc9\x70\xfb\x79\x2f\xca\x3d\x9d\x75\x78\x58\x69\x27\x3b\x5e\x83\x0b\x29\x6e\x2d\xba\xed\x46\x0e\x41\xd7\x4a\x4c\x25\x64\x48\x2d\x29\x3a\x21\xf4\x33\x36\x3e\x65\x16\x10\x39\x73\xa9\x81\xa8\x54\xdb\x33\xbe\xa6\xb9\x0f\xd7\x9c\x89\x5a\x5f\x87\xe1\x6f\x71\xa8\xd5\x6a\xd7\xa5\xf0\x56\x23\xe7\xf8\x14\xa7\x11\x49\x88\xf9\x36\xf8\x1d\x41\xe5\x9b\xa2\x78\xac\x0a\x35\x5c\x67\xb9\x5e\xbf\x6c\xeb\x62\xe4\x62\xaf\x18\x7f\x70\xec\x73\x00\x11\x9e\x10\x80\x7c\x0a\x00\x4f\xe0\x2a\xee\x3a\x41\xae\x3f\x06\x5d\x76\x10\x53\xb2\x51\x98\xf5\x08\x47\x87\xd5\x8d\x19\x52\x0a\xd2\xf8\x14\x04\x77\x10\x1a\x30\x16\x33\x75\xdc\x3d\x5a\xb0\x5c\x3a\x84\x1d\xe1\xc0\xd4\xe1\x2d\x87\x32\xbf\x50\x57\xaa\xda\x11\xaf\xc2\x9f\x54\x68\x6b\x47\xb0\x03\xd2\xdf\xf9\x33\x10\x00\x36\x3d\x29\xe0\x8b\xdb\x18\x5a\x38\x3a\x46\x58\x02\x76\x3e\x3e\x1b\x98\x4d\xc2\x6f\x5e\x6d\x76\xe0\xc0\x27\x20\x9e\x79\x87\x23\x37\xcc\x08\x36\x8b\x41\xb0\xeb\x25\x28\xc3\x44\x88\x00\x0f\x01\x98\x18\x2e\xcf\x92\xc7\x88\xc0\x42\xc3\xa8\x3a\x04\xdb\xe7\x45\xc5\xc4\xb9\x1e\x9c\x64\x5e\x29\x40\xc0\xf6\xc0\x16\x02\xf3\xc8\xaf\x18\x4e\xc7\xd8\x44\x5f\xf8\xc3\xd3\x3f\x0b\xea\x21\x2e\x3b\x08\x5f\xd2\xf1\xca\xd9\x98\x11\x5f\x34\x38\x67\x21\x56\x28\x1a\x57\x72\xbc\xf6\xc4\x83\xb0\x3e\x21\x7a\x5f\x79\xe0\x06\xdd\xda\x72\x63\xfa\x12\xd3\x5e\xad\xae\xdf\x7c\xa5\xdd\x25\xae\x65\x7f\xf3\xc3\xb0\xdb\x66\x40\xaa\x58\xa1\x0e\x4c\xac\x9d\x03\x77\xb7\x53\x76\xb3\x55\x0d\xc9\xd4\x4f\xcd\x4d\xb7\x36\xc1\xdd\x5d\xc4\xdd\xc4\xfd\xfb\xbe\x12\xef\xe0\x0a\x0c\x9c\xe9\xe3\xf3\xe7\x70\x24\xf4\x8a\xc7\xcc\x5f\x47\x1b\x65\xbd\xbe\x19\xd2\x45\x32\xab\xe1\x2b\xc7\xe6\x73\x44\x9b\x3e\x64\x63\x4a\x9e\x58\xf8\xaf\x2c\x4a\x01\x03\x2e\x60\x02\x39\x77\x23\x93\xbb\x72\x8e\x97\xec\x36\xa7\xa4\x5b\xb2\xd5\xc7\xa4\xdf\xde\xa7\xab\x4f\xc8\x0d\xe7\x2e\x3c\x2f\x37\x99\x53\x17\xf4\xb2\x7e\xa2\xe7\x99\x13\x61\xcd\x5c\x23\xa0\x0f\xfa\x65\x40\x42\x3a\x25\x2b\x42\xd8\xf1\x3a\x22\x98\x89\xa7\x00\x4c\xa7\x0a\xba\xe8\xe4\x00\xcc\xa0\xae\x8c\x78\x25\xeb\x82\x57\x0d\x0d\x78\x9d\x22\x4f\xed\x72\x43\xca\xba\xa0\xa6\x45\x1d\x5e\x2d\x2d\xaf\x25\x42\x77\x64\x36\xd5\xdd\x35\x9e\xe5\x1b\x2e\xc4\xba\xbd\x7c\xf3\x7c\xaf\x3b\xe2\x36\x5a\xc2\xcc\xb6\xc8\x6e\xd8\x18\x02\xc6\x49\x29\x4c\x2e\x3d\x13\x41\x5c\x0c\x30\xf4\x94\x18\x02\xa1\xfb\x19\xc8\x22\x10\x55\x49\x19\x05\x30\x5b\xf5\xb9\x2c\x61\x63\xe9\x45\x3b\x0c\x8f\xa6\x44\xfd\xe1\x79\xd8\xcd\x94\x61\xc9\x91\x47\x9b\x2b\x13\xda\xc1\x79\xf8\x41\xb9\x34\x3f\x46\x97\x68\x83\x79\x28\xad\x84\xe2\xc7\x57\xeb\x6b\x77\xaf\xe1\xd2\xe6\x8f\x75\xd3\xa8\x71\x8b\xce\x2e\xd7\xc8\x3f\xd6\x92\xad\x23\xb5\x1b\x47\x7e\xf3\xb8\x6f\x18\x75\x48\xd5\x5f\xa9\xae\xac\x62\xe8\x1b\x68\x2c\x9e\x0e\x32\x6d\x39\x87\x58\x76\x39\x62\xf4\xb2\x95\x0c\x3a\x20\x1a\x7f\xe8\xdf\x96\x03\xb3\xd1\x3e\xfa\x32\xcb\x86\x6f\xc3\x88\xd7\x72\x00\x91\x74\x34\x79\x99\xe5\xc8\x2b\x36\xf4\x0a\x2e\xb1\x9a\x2f\x87\x9c\x39\x10\x9a\xbe\x6c\x46\x19\x6b\x15\x22\xaa\x73\x33\x9d\x28\x6d\x75\x35\x61\x7b\x0d\x21\xf2\xda\x1f\x8d\xb2\xa6\x38\xa2\x8f\xd0\x16\x67\x39\x53\x93\x2a\x53\x65\x4b\xe7\xb9\x95\xd9\x1b\x85\x1a\x55\x64\x8e\xc3\x9a\x62\xa5\x69\xa5\x36\x7a\x93\x61\x6e\x63\xa3\xd9\xad\xf5\x20\x67\x34\xdf\x54\x03\xe0\x6b\xc5\x4d\x35\xa0\xac\xfa\x23\x12\xdd\x47\x36\xea\xeb\x95\x1f\xf1\x15\x9a\x8f\x88\xd5\x1e\x1e\xff\xae\xf3\x53\x48\x75\x99\xbc\xfb\xc1\x4f\xd5\x69\x7e\x06\x93\xa1\x70\xb6\x08\x5a\xc8\xf5\x0a\x82\x5b\xbe\xaf\x55\x6f\x5c\x05\x3f\x83\x66\x43\xc8\x38\xad\xda\xe1\xdc\x1b\x2d\x60\x6f\x06\xdb\x6f\x90\x1c\x6b\xa3\x64\xab\xdb\x13\xf3\x7a\x2a\x5d\x0e\x28\x30\x94\x43\x72\x77\x6f\x3d\x27\x44\x03\x76\xa7\x85\xa8\x93\x6d\x70\x09\xb2\x05\xef\xd1\xae\xbc\x37\x14\x7f\xd4\xd7\xf6\xfb\x01\x57\x46\x86\xaf\x0c\x76\xf6\xb5\x42\x1f\xaa\xa8\x02\x26\xc9\xcd\x2c\x7a\xeb\x75\xa8\xaf\x52\x9d\xd6\x18\x04\x7f\xca\xfd\x5c\x64\xa9\x04\x60\x3c\x88\x46\xf5\xa0\x78\x64\x2e\x34\x0c\x29\xe7\x88\x9e\xd6\x28\xce\x42\x91\xa0\xd0\x06\x17\x76\x37\x83\x47\x3a\x1d\xe0\x15\x83\xe1\x61\x13\x84\x5a\x62\x77\xea\x30\x24\xd2\x55\xf8\x70\x1b\xc4\x58\xfa\xc9\x5c\x7f\x6e\xaf\x64\xea\xab\xdb\xc8\xcf\xf8\x1a\xa3\x63\x12\x5f\x14\x74\x88\x67\xaf\x63\x4d\x8e\x43\x4b\x99\x7c\xee\xdf\x0f\xe6\x7b\xcf\x9f\x93\x9c\xf5\x8e\xbd\x43\xa6\xb2\xbe\x50\x45\x1f\x11\xf2\x37\x99\xad\xdb\x45\xa4\xa6\xa7\x80\x87\xbf\xbf\x96\x3e\x1a\xb5\x04\x48\x66\x9e\x4d\xc7\x67\x9d\xeb\x8f\x8b\x54\xf5\x75\xa1\xb8\x10\xa5\x1f\xeb\x28\x0b\x03\x27\x73\x8f\xdf\xbe\x19\x8d\x0f\xde\xa0\xd8\x0d\x62\xe3\x30\xf1\xaa\x5f\xe9\x9f\xbd\x3e\xe8\x34\x59\x02\x3b\x49\x8c\x0d\x1b\x1d\xa8\xb4\x9d\xbd\x8b\x42\x5a\x2a\x83\xe1\xb7\xa9\xd1\x58\x64\xae\x30\x53\x65\x25\x76\x52\x8c\x03\x30\x7e\xd9\x20\xe8\xe0\xa6\x27\x6c\x37\xc9\xc7\xb8\x8e\x7f\xde\xb8\x04\xb7\xf3\x27\x48\xe3\x7e\x57\xb9\x0a\xdc\x2e\xc8\x37\xe7\x32\x10\x2f\xc9\x4f\xa6\xb4\xcd\xe9\xe1\x4b\x8e\x97\xfc\xf7\x06\xfc\xc7\x6c\xc0\x68\xba\xf3\xe1\x27\x2e\xf2\x93\xc4\xcb\x60\xc6\x21\x1f\x82\x0f\x25\xf0\x95\xc5\xf2\xe5\x08\x4f\xc3\x56\x8b\xb2\x2e\xca\xb1\xb3\x86\x81\x35\x0b\x32\x44\x3a\x78\x2f\xbe\xed\xb1\xff\x85\x48\x44\x39\xe1\xed\x55\x04\x43\x1a\x22\x15\xe5\x4a\x67\x42\xa6\x7f\x4e\x6b\x10\xd4\xb6\x32\x84\x27\xd2\xd4\x86\xf9\x0b\xf1\xd0\x2e\x72\x83\x51\x64\x13\x8b\xc8\xca\x70\xf6\x10\xbb\xf1\xef\x2b\x1c\x19\x77\x32\xcf\x5c\xd2\xdf\x8c\x4f\xe9\xce\x8a\xe7\xf8\x4d\xd7\x07\x64\x27\xf3\xcc\xc9\xb7\xab\x6e\xf7\xb0\x40\x46\x83\xdd\xc9\x3d\xa4\x34\xb5\xbb\x77\x38\xad\xdc\xe9\x72\x76\xae\x2b\x0c\xd9\x6a\xb5\x68\x25\x4a\x85\x66\xae\xc6\xa5\xac\x28\xe8\xc4\x6e\x6e\x33\x0c\xaf\xbf\x44\xad\x45\x2d\xdb\xf2\x8a\x6b\xb0\xf5\xd5\xba\x11\x73\x5d\x2d\x27\x65\x55\x91\x46\xc8\x11\xa9\xf5\x62\x46\x00\xec\xd0\xd2\xc4\x96\x54\xcd\x44\x37\x33\xf4\x8d\x01\xc4\x2e\x48\x4e\xfb\xea\xe4\xf5\xd9\xb3\x17\x1f\xce\xfe\xfc\xea\xd0\xc7\xa3\x50\x2f\xbb\x92\x37\xbe\x78\xd7\x9b\xe8\xa6\xf7\xbe\xf3\xa0\xdf\x03\x87\xe1\x21\x26\xd4\xee\x81\x53\xd6\xc3\x4f\x4a\x8e\xe5\x6e\x27\x85\x1d\xa2\x8e\x7d\xf3\xa8\xcf\x29\xc4\x07\x69\x4a\x69\x27\xcf\x4e\xca\x8b\x45\xa3\x2c\x77\x84\xb9\x7a\xf6\xea\x08\x63\x68\x1b\x6d\xcc\x36\xa7\xef\x4c\xb2\x7a\x0f\xef\xc4\xbf\x3d\xdc\xe7\xa5\x5a\x8a\x3d\x07\x2c\x68\x08\x1f\x53\xfc\x41\x3c\xb1\xe3\x71\xcf\xdf\x3d\x79\x1f\xc3\x49\x88\xa7\xf1\xcb\x20\x73\x53\x44\xc7\xac\x6e\xdb\xa5\x05\xe4\x04\xb1\x00\x77\xed\x45\x5d\xfe\xb8\xb0\x1a\x2d\x84\xd4\x97\x93\x25\xe1\xd2\x1b\x87\x15\x87\x53\x02\x95\x7c\xf3\x0d\xae\xc4\x4e\x77\x95\x90\x00\x2f\xd5\x72\x07\x87\x42\x32\xa6\x03\xdf\xe9\xf5\xc4\x03\xfb\x86\x76\x8a\x4b\xc6\xed\xe6\x99\x77\xd0\x0d\xd9\xbc\xd3\x2c\xe9\xb9\xf4\xe8\x84\xfd\x76\xa1\xda\x7d\x3c\x1b\xe0\x8a\xfb\xb4\x95\xe3\xcb\x67\x45\xa1\xea\x62\x31\xfb\xe6\x91\xd8\x23\xc4\x39\x75\xbe\xb8\x08\xcb\x0d\xd7\x7d\xb7\x7b\x27\x8f\x72\x79\x2c\x81\x4f\x79\x9b\xf2\x77\xdf\xd9\xee\x7e\xe7\x72\x67\x71\xa2\xa5\x5a\xc3\xfc\xa8\x4f\xf3\xaa\x1c\x97\x6d\xb5\x84\x28\x0f\x5d\x8b\x62\x59\xcb\x59\x39\x16\xb2\x69\xe4\x12\x40\xfe\x5c\x16\x7b\x00\x62\x14\xdf\x71\x14\xc8\xa5\x5a\x26\xa9\x3f\xc9\x48\x01\xeb\x6a\x68\x61\x2f\x95\x9a\x8b\xb6\x91\xe3\xcb\xa8\xae\x73\xd5\x5e\x2b\xe4\xca\xdf\xb9\x0c\xa0\xf0\x6b\x44\xc3\xd2\xd7\xb5\x6a\xfe\x28\xcd\x9f\xd4\xf2\x8d\x51\x6f\xd1\xbf\x90\xa0\x3a\xe3\x12\xcf\x69\xef\x9c\x2d\xe7\x49\xb9\x00\xd2\xf3\xb9\x6e\x8e\x4b\x00\xc9\xfd\x13\x90\x78\x00\xe7\x69\xfb\x14\x62\xeb\xc0\x83\x2c\x70\x27\xbc\xb8\x1b\xc5\x96\xc4\xa8\x21\x69\xb8\xcb\x5d\xf8\x64\xf8\xc1\xb4\xba\x01\xef\xb3\xf0\xf7\xd0\xe7\x4b\x75\x6f\xec\xa2\xdc\x4d\xd5\xc8\x6e\xdd\x2e\x1c\x26\xaa\xff\xe6\xa8\x17\xdc\x4a\x41\x40\x6b\x9d\x99\x1c\x12\x1d\x30\xdd\xa0\xa0\xbe\xfe\x32\xf6\xa7\x15\xd3\xc1\x0e\x95\xa9\x7f\xa1\xeb\x38\xe4\x35\xb6\xbb\x51\xec\x89\xde\xa1\x1c\x4f\x69\x6d\x4a\x80\xe0\x00\xda\x15\xb6\xa3\xad\x6a\x64\xab\x9b\x64\x48\xc8\x6c\x30\xc2\xef\xde\xa5\x5a\xa2\xfd\x65\x28\x4e\x95\x12\xb9\xec\xd5\xe4\xdc\xba\x0d\x14\x3f\xe1\x30\x49\x80\x22\x2e\x6b\x38\x36\x80\xa9\xda\xa7\xfd\xf5\xbb\xbd\x8f\xae\xb8\xac\x2c\x80\xa8\x99\xa3\xf3\x77\x2b\x07\xfc\x7e\x1d\x59\xdc\xb6\xae\x78\xa2\x53\x1f\xde\x7f\x96\x79\x05\x24\xe1\x9b\xe6\x95\xf1\x6b\x89\xe9\x52\xc0\x1b\xf0\xd7\x14\x1e\xd8\xbe\x3f\x3a\x3b\x7c\xfd\xec\xec\xe4\xf5\x87\xd3\x3f\x1f\xff\x70\xf2\x62\xe3\xc3\x7d\xc8\x43\x47\x0c\xe2\xe7\xcf\xde\xfc\xaf\x0f\xdd\xba\x7a\xff\xfe\xef\x5c\xae\xb7\x6b\xcf\xbc\x1f\xf0\x6e\x98\x2a\xb7\xf2\xcc\xf0\x26\xa1\x07\xf6\xd1\x21\x1e\x2a\xdb\x76\xbb\xfd\x43\x05\x9f\xc3\x17\x87\xc7\x87\x2f\xcf\xe0\x4c\xdd\x0d\x9e\xef\x3f\x7b\xf1\xa2\xf3\xf0\xf5\xe1\xd9\x9b\xd7\x2f\x3b\x8f\x9f\xbf\x7e\xf6\x1f\x41\x25\x81\x62\xb6\x99\x04\x85\x94\xde\xed\x8f\xd8\xcb\x0b\x56\x0a\x27\x0b\x37\x57\xd2\xdd\x55\xdf\x58\xdd\x31\xfc\x20\x18\xca\xaa\x4f\x70\xdb\x85\x1f\x45\x03\x5d\xf5\xd9\xa4\x91\x17\xdc\xbd\x40\x93\xce\x0e\x0f\xc4\xc2\xdf\xe4\x87\x01\xef\x7e\xbb\xaa\xc7\xf0\xf6\x77\xab\xbb\x06\xef\xcf\x3b\x79\xdd\x8e\x88\x5a\x9f\xd7\xfd\x99\x5c\x9e\x2b\xf8\x7d\x5e\x05\x09\xc8\xa2\xc7\xb9\xc3\xb1\x5b\x20\x83\xfc\x40\xb2\x60\x98\x07\x14\x76\xab\x6b\x5e\xec\x75\xb6\xe6\xfd\xfb\x71\xdd\xef\x92\x02\xef\x6d\x27\xe2\x12\xb9\x6d\x09\xd8\xed\xa1\x71\x20\x68\x33\x6b\x0b\xe0\xb0\x27\x57\x6e\x37\x4e\x9b\x87\x83\x88\x31\xf5\x55\x33\x56\xaf\xd5\xc4\x9b\x76\x89\x26\xbd\x80\x3d\x2b\x3f\xa9\xe2\xb5\x9a\x88\x3d\x7e\x37\x6c\xd4\x84\xfb\xe6\xde\x86\xd6\x51\x9e\xe0\xf0\x5d\xb7\xbb\xe0\xfa\x4c\x35\x7e\x80\x83\x20\x86\xaf\x84\x47\x41\xab\x58\x26\x0c\xbc\xb6\x0a\x6b\x62\xf1\x0e\x8e\xa8\xad\x24\x06\x05\x1e\x72\x26\xe1\xa8\x2e\x2b\x9e\xf8\xb7\x90\xee\x70\xaf\x93\x0e\x31\x2f\x9f\x80\xfa\x0c\xb1\x73\x61\xa2\x02\xfc\xc2\x88\xb1\xac\x5d\xae\xa3\x46\x4d\x4c\x57\x9e\x60\xbd\x9b\xbb\x84\x3d\x48\xae\x3a\xbd\x71\x05\x22\xca\xb3\x1d\x21\x71\x88\x66\xcd\x32\x4a\xd3\x52\x8e\xf7\x09\xa0\xd9\xfc\x2c\xe2\xd0\xc0\x2d\x6a\x77\x20\x18\xc5\x60\xdb\x44\x6a\x01\xcd\x85\x8b\x07\x6e\xd8\xfb\x53\x35\xbe\xb4\xcb\x34\xf7\x17\x1b\xae\xa7\x33\xd9\x8e\xa7\xca\xc0\xdd\xa8\x7f\x1c\x2c\xed\xba\xbc\x82\x4d\x42\x87\xc1\x73\x2b\xb2\xb9\xae\xed\xed\xf9\x8e\x86\x54\x42\xfb\x24\xf8\x2c\x07\x72\xd2\xc0\xe8\xbc\x38\x0e\x60\x35\x29\xb1\x51\xe8\x80\x5d\x2e\x0a\x23\xd8\x8b\x02\x09\x60\x0d\xdd\x3b\xf1\xf7\x2f\x62\xc7\x3f\x88\xc3\x9d\xa0\xfe\x6c\x66\x14\x21\x0a\x55\xa9\x16\x69\xeb\x9d\x1b\xd2\xfb\xc0\x28\xd7\x45\x6b\x4b\xca\xda\xfd\x63\x1b\xc8\x18\xf2\x76\x9d\xd8\x16\x4f\x9f\x9f\xbc\xdd\xd8\xd8\xee\x26\x2c\x69\xd6\x09\xff\x9e\x97\x58\x8e\x80\xd5\xac\x10\xfc\x5d\x42\x01\x3b\xdd\x9c\x2e\xc0\xe7\xee\x6b\x00\x9f\x00\x52\xc5\x65\xf6\xd4\xdd\x98\x67\xe4\x1b\xc0\x22\x50\x3f\xa4\x2c\x9e\xab\x71\x39\x29\x19\xbd\x88\x88\xaf\xff\xad\xd9\x82\xb8\xd6\x5a\xd3\xd6\x82\xb2\xaa\x1d\x8a\x3f\x87\xd8\x74\x2b\xb1\xe6\x2b\x2d\x0b\x55\x0c\x45\xbf\x50\xad\x2c\x2b\xb3\x93\x15\x2c\xed\xa2\x6c\xcf\x16\xa6\xdd\xb6\xb5\x6d\x23\xff\x5a\xb7\xdd\xbe\xc4\xac\xdd\x6f\xb3\x90\xbd\x43\x86\x00\x87\xcf\x8b\x84\x67\x75\xce\x3e\x7e\x45\xe0\xec\xb5\xba\xde\xf7\x1a\x25\x26\x4d\x73\xaf\x39\xe8\x64\x4f\xf4\x5a\xf5\xa9\x95\x8d\x92\x51\x2e\x53\x49\x12\x2d\xec\xf7\x38\xee\x3c\x7c\xd5\x41\x71\xa1\xbb\x69\x29\xc6\xba\xaa\x94\x4b\xc8\xe8\xad\x47\x0b\xa3\xbc\x04\xef\x50\x01\x21\x20\xee\xd6\x5a\x0b\xa9\xb7\x1d\x12\xc0\x19\x49\x6c\x02\xa1\x09\x07\x75\x89\x3e\x80\x16\xee\x88\x6f\xcd\x16\x8a\xf6\x04\xa4\xef\x43\x68\x5a\x7d\x8a\xb4\x08\xb9\x41\xfc\x84\x02\x99\xbf\x23\xf3\x03\x7e\xf5\xbe\x27\x9e\xb2\xce\x8b\xfe\x9c\xa0\x4c\xfc\xdd\x8e\x8a\xea\xb5\x0f\x7c\x25\xc3\xbf\xea\xb2\xee\xf7\x06\xa2\xb7\x65\x67\xe1\x4b\x4f\xec\xb8\x25\x1b\xb8\x49\xf6\x89\x48\xdc\xea\x23\x38\x73\x68\x6b\xe8\x07\x59\x72\xd6\xe9\xa7\xcf\x5d\x1e\xee\xf5\x33\x43\x87\x0a\x6e\x82\xf9\x5c\x81\xc1\x06\xd6\xca\xae\xb5\x43\xf3\x0a\xb5\x77\x87\xc8\xfa\x7b\xff\x74\xf4\x07\xf4\x61\x21\xd7\x22\xac\xe1\xa4\x41\x11\x29\x26\x1b\x3b\xbf\x94\x09\xd4\xc5\x6d\x48\x48\xe1\x09\x29\x76\x9c\x04\x74\x4b\x22\xb9\x13\x6b\xb6\x19\xfb\xcc\x06\xfa\x6d\x9c\x32\xe8\xeb\xea\x0a\xf5\xdb\x54\xbb\xfd\x2f\xb0\x2a\x1b\x29\xc6\x6e\x55\xbe\x90\xc6\x59\x1a\x71\xdd\xd8\x91\xf8\xdc\xf8\x78\xb1\x62\x1c\xb4\xdc\x91\x40\x1c\x39\xe8\x4d\xa5\x6b\x45\x48\xa6\x05\x80\x50\x29\x39\x9e\x8a\xb9\x6c\xa7\xb6\x3e\x3a\x4b\xac\xcc\xdf\x6a\xc8\x52\x33\x2b\xff\xa6\x7c\x19\xb8\x4f\xba\x2a\x0b\x44\x39\x38\x5f\x8a\xf3\x46\xd6\xe3\x29\x24\x75\x94\x4d\xb5\xa4\xe9\x05\xf0\x02\x5b\x1f\x46\xf5\x96\x95\x6a\xec\xa9\x44\x78\x0b\x85\x16\x65\x2b\x66\xb2\x86\x5a\x86\xe2\x8f\xaa\x9a\xab\x86\x10\x87\x30\x47\x14\x66\x38\xb6\x55\xb9\x06\x6c\x75\x95\xd5\x8d\xf5\xa2\x85\x88\x61\xc8\x55\x18\x4c\xeb\xd0\xef\x6e\xd8\xff\xaf\xd5\x58\xd7\x63\xdb\x36\x5d\x2d\xef\xdb\xb1\x0f\xc8\xca\x71\xd6\xc8\xf1\xe5\x69\x59\xa8\x43\x84\xc5\x42\x42\x75\x35\xa0\xec\x00\xf5\xc4\x07\x02\x50\xd1\x99\x3e\x80\xf7\xa1\xb4\x7e\x77\x5d\xbd\x82\x7d\x9c\xf4\x7c\xb8\xde\xc4\x18\x74\x35\xfa\xf4\x2d\x39\xc1\x35\x56\xa0\xc1\x81\xe1\xd5\x99\x80\xf0\x63\x0c\xde\xbb\xe2\x64\xd0\xe1\x95\x2d\x64\x4a\x19\x8a\xb7\xc1\x6d\xa1\x1c\xb7\xb8\x82\xd7\x40\xa4\x41\x6a\x68\x2c\x9b\x18\x25\xc2\x97\xce\x1d\xcf\xd7\x16\x2e\x99\x26\xeb\x30\xcc\x9f\x9d\xc8\x10\x7a\x2c\xbc\xd4\x8d\xe6\xd1\x07\x16\x67\x45\xb9\x70\xaa\xbc\x08\x16\xd5\x00\x8e\x0a\xd9\x1a\xc3\x19\x1e\x8d\xc4\x01\x75\x0c\x19\x85\x3d\x21\x0a\x84\x62\xbb\x52\x8d\x95\xf6\x11\x0e\x08\xc1\x41\x64\x51\x58\x4a\x65\xfc\x99\x46\xd7\xad\xc3\xfe\x78\x46\xb7\xa9\x70\x2d\x39\x08\x10\x7b\x11\xa7\xa6\x67\xf8\x0a\x1c\x72\xa2\x71\x42\x3a\x4a\x30\x44\x69\x90\x70\xf6\xb8\x43\x83\x00\x92\xe4\xaf\x0b\xd3\xba\x9c\xfa\x53\xe5\xa7\x93\xfa\x02\x09\x3a\xc1\xde\xe4\xb2\xaa\x72\x7d\x0c\xf3\xc6\xbe\x94\x30\x42\xcc\x68\x8c\xdb\x1e\x7d\x20\xc5\x7c\x2a\x8d\x1a\x8a\x93\x1a\x89\xc7\x5d\x79\x44\x97\x82\x65\x7d\x31\xc0\x71\x5a\x8e\x49\x18\x8c\x96\x09\x7b\xef\x2a\x4a\xe0\x19\x8a\x45\xf6\x11\x92\xbf\x37\x8c\x42\xb1\xae\x4f\x95\x7d\x0c\x79\x05\xb1\x7c\xba\x8c\xb1\x0c\x9d\xd6\x9e\x2f\x9d\xc8\xd7\xe1\xa7\x90\x53\xd0\x7d\x7b\xab\x4a\xef\x74\x48\x2e\xee\xb6\xcf\xd6\x16\x17\xf2\x6e\x01\x7b\x8e\xf6\xba\x98\x2b\xc8\x6e\x5e\xf3\x5a\xee\x93\xa4\x97\xb0\x1e\x3e\x18\x1a\xd3\xee\xa7\xd7\x1c\x5f\xc7\x7e\x82\x6e\x07\x99\x69\xe1\x26\xf2\xb9\x46\x07\xca\x80\x21\x89\xb1\x34\x6a\xc0\x31\x31\xe4\x61\x3b\x2b\xc7\x8d\xde\xe6\xa3\xa2\xb0\xba\x72\xd9\x86\x59\x66\x0d\xd2\x11\xb2\x77\x1f\x86\x83\xf9\x1d\x51\x88\xbc\x56\xbd\x2b\x9f\x3d\x1d\x49\xd6\x6e\xc8\x65\x3b\x75\xf9\x11\x41\x30\x4b\xb7\x7c\x3a\x23\x04\x3b\x85\x39\x9e\xe3\xd2\x5d\xda\xdb\x90\xc7\xef\x6e\xc4\x6f\x4c\x79\x6e\x19\x72\x48\x2d\x1d\xf3\x58\x04\xd3\x20\xe7\x5f\xbb\xdc\x96\xfb\x14\x45\x92\x53\xd9\xdd\xc5\xb5\x5a\x48\xd1\xaa\xd9\x5c\x37\xb2\x59\xda\x76\x9c\x9b\x0d\x31\x97\x49\x89\x5c\x65\x16\xac\x12\xc8\xd9\x3f\x2e\xca\xf1\xa5\x3d\x91\x8f\x66\x78\x91\x28\xfa\x38\x63\xf0\xf6\x42\x31\x37\x21\x88\x1b\xb8\x64\xa4\xac\xe3\xaa\x6c\xac\x6c\xa0\x3e\xb9\xb5\x62\xef\x0e\x1e\x1c\xa1\x3b\x1d\xcb\x79\x3f\x74\x39\x8f\x8a\xdd\xb8\xa4\x71\xe9\xee\x92\x82\xd9\x2c\x2c\x43\x57\x70\xdd\x33\x25\xed\xde\xd0\xa8\xb6\xfb\xe9\x20\x2e\xe7\xbd\xb6\x52\xd3\xc1\x06\xd5\xc1\xf4\xac\xac\xf0\x4e\xa6\x1e\xb1\x17\xff\x5e\x43\x64\x69\xfb\x5d\x82\x5b\x18\x15\xe5\x49\x09\x1d\xf4\x3b\x29\x51\x3c\xa5\xbd\x75\xb2\x01\xdd\x2a\x53\x1f\x5c\x9a\x4f\x48\xbc\x66\x87\x66\x9f\x3c\x14\x20\x36\xb0\xe4\x59\xe2\xc9\x27\x8d\xa3\xb3\x56\x03\x52\x3d\x62\x10\x16\x9a\xc3\xec\x70\x14\x20\xd0\xb4\x43\x71\x38\xbc\x18\x82\x95\x0e\xf8\x4f\x59\x5f\x54\x8a\x18\x85\x65\x40\x1e\x23\x2b\x2b\x2b\x01\x9f\x00\x6e\xb5\x47\xee\x17\x6f\x23\xdf\xa4\x8d\xc6\xef\xf6\xbc\xad\x08\x57\x0e\x52\x8e\x46\x8f\x79\x26\xe2\xec\xd5\x6c\x27\xb3\x45\xb2\x07\x12\x4e\xaa\xbe\x52\x4d\x63\xc5\x58\xf4\x84\x8a\x12\xa2\xa3\xdb\x1c\x86\x97\xc0\xfc\x35\x55\xf9\xff\xb3\xf7\xee\x5d\x6e\xdc\x56\xbe\xe8\xff\xfa\x14\x90\xd7\x44\xdd\x7d\x42\xb1\x13\xdb\x99\x7b\xae\x3a\x6d\x2f\x59\x8f\x44\x77\x22\x59\x57\x92\xc7\xf7\xac\x4c\x96\x02\xb2\xc0\x66\x9d\x2e\x16\x98\x42\xb1\x29\x8e\xa5\x59\xf3\x21\xe6\x13\xce\x27\xb9\x0b\x7b\x6f\x00\x1b\x28\x54\xb1\xd8\x0f\x1f\xc7\xb1\xfe\xb0\x25\x16\xde\x8f\x8d\xfd\xfc\x6d\x3b\x64\xbf\xac\x8b\xd0\x54\x97\x25\xb4\x54\x56\x54\x00\xc7\x07\x8d\xc1\xd5\xc7\xec\x7f\xcc\x09\x4c\x1a\xce\xc0\x6d\xeb\x87\x14\xea\x63\x69\xb8\x7b\x23\x60\xa5\xba\xe9\xd8\xf3\x09\xe5\xa9\x30\x7b\xee\x5e\x69\xce\x04\xb8\x12\x9d\xc5\xc4\x9f\xf3\x8b\x89\xdf\xf8\x56\x89\x73\x91\x03\x4e\xe5\xbc\x57\x02\x96\xe0\x6f\x00\x30\xca\x48\xee\x6b\xb5\x25\x2a\x6b\x1f\xfe\xd7\xf6\x43\xf1\x02\xef\x67\xad\xb6\xf0\x37\x77\xa2\x5c\x51\x3f\x70\x57\xe0\xec\xa6\x6f\x6f\xd2\x75\x1a\xc3\x11\x50\x78\xfc\x10\x12\xa6\x36\xa7\xf2\x4d\xcc\x04\x15\xb6\x1d\x08\x2b\x4e\x23\xb2\x07\xb8\x32\xbf\x4f\x47\x94\xe4\xf2\x77\x18\xff\x52\xac\xf4\x15\xcb\xda\xef\x87\xc7\x37\x1f\x9a\xb1\xfc\xe4\x59\xaa\x41\xce\x4e\x3b\x43\x52\x7d\x8f\xad\x5a\x21\xd6\x63\x2b\x77\x5e\xe0\x99\xa6\xcd\xba\x69\xec\xf3\x72\xf5\xb3\xa8\x29\x8f\x14\x65\xfb\x1c\x3f\x93\x7d\xdb\x97\x39\x75\x6f\x81\x88\xc5\x67\xef\x24\x71\xa2\xb2\x0f\x2a\x70\xe1\xcd\x00\xed\x03\xd2\x51\x03\x14\x14\x3e\xc4\x85\x16\xd2\x35\xb3\x76\x23\x85\x06\x68\x76\xf5\x05\xa2\x2a\xba\x87\x29\xa1\x9e\xe9\xa1\x15\x0f\x1e\x64\xce\x5b\x46\x2c\x1b\xb3\x56\x31\x1f\x44\x15\x32\x4f\x13\x78\x0c\xbd\x53\x1f\xda\x57\xba\x50\x59\x2e\x68\x22\x08\xad\xb2\x45\x43\x5c\xf6\xb9\xe2\xf7\x81\xdb\x34\xdd\xd1\x6f\xe5\x05\xdc\x93\x3f\x6a\xd3\xbe\x8b\x70\x15\x21\xfc\xcf\x2e\x17\x7f\x44\x08\x9c\xd1\x3d\x23\x30\xa0\xe7\x8d\x5e\xd9\xaa\xc7\xd1\x70\xb8\x24\xd1\x45\xfc\xe9\x7f\x5d\xb0\x87\x3f\x1f\x91\x11\xfa\x2f\xb1\x50\x92\xbe\x28\x58\xba\xef\x4d\x89\x3c\xb0\x39\x67\x25\xce\xc3\xdb\x3f\x6a\x35\xcf\x12\x5e\x64\xe4\xf8\x5c\xf1\xbe\x8b\x80\xbb\x4c\x96\x85\x9e\x4d\x26\xd3\xc4\x98\x0d\xce\xd9\xb2\x30\x37\xd2\x79\x30\x8b\xda\x1f\xa2\x5d\x7e\xa9\xaf\x94\x98\x41\x1e\x06\x5d\x33\x8e\x75\xc4\x92\xb9\x36\xd7\x83\x1c\x83\x6b\x62\x8a\x96\xb0\x01\x23\xf2\xa1\xcb\xdc\x65\x36\xa7\xef\x0b\x35\xdb\x5c\xbc\xd5\x9b\x06\x62\x42\xbd\x61\xc7\xc0\x2f\x67\x7d\x15\xbe\x1d\x34\x1e\x7f\x1a\xdc\xd6\x6e\xd4\xc0\xe8\x7b\xe3\xb6\xde\x6f\xf2\xcd\xae\xcd\xf8\x15\xbe\xc9\x3d\xeb\x39\xc6\x4f\x64\x55\xf5\x9c\xe1\xb9\xac\xaa\x01\x86\x3a\xc2\xae\x40\xb7\xd8\xca\x68\xd0\xcb\xc8\x46\x89\xa5\xac\x8b\x0a\x01\xa9\x0b\xd5\xaa\x66\x55\xd6\x4a\x6c\x97\x0a\x35\xc6\x1a\x3d\xf6\xbf\x3e\x88\xdc\x3d\xe1\x41\x80\xd7\xa4\x79\x30\x5f\x9c\xd9\x4f\x81\xd8\xdd\xe0\x1a\x67\xb7\xe7\x4e\x49\x1e\x42\x70\xf5\x9c\x16\xfc\xd5\xbe\x7b\x37\x7d\xd5\xb0\x9b\x9b\x6e\x74\x34\x58\x1c\xd6\x0d\xaf\x29\x25\xac\x0b\x2d\x4e\x23\x9b\xfa\x4f\xe5\x5c\x00\x52\xd5\x5e\xaa\xbe\x67\x32\x77\x72\x7e\xd0\x57\xbe\xe7\xfc\x60\xfc\xc1\x6d\x70\x44\xd8\x0d\xff\xea\x3d\x6d\xa6\x91\xcf\x3c\xd4\xc0\x7e\x93\x0f\xd9\xba\xb1\x33\x3d\xaf\x9c\x0b\x5b\x38\xf8\xc0\xd2\xea\xb8\x75\xf8\x29\x50\xa7\xc3\x58\x31\xb7\x92\x4e\x4f\xf6\xf1\xa3\xf8\xf3\x5f\x7e\x5c\x0a\xf5\x9c\xbc\x19\x7b\xce\x98\x73\x76\x4c\x07\x35\x11\x97\x6a\x77\xe8\x51\x73\x7d\x5d\x73\xbb\xfd\x50\xc3\xa0\x0e\xdb\x72\x1c\xf4\x4f\x60\xdf\xfb\x56\xf5\xae\xb6\x9a\x72\xed\x75\xd5\xdd\xc1\x61\xa2\x9f\x88\x90\x8f\x92\x2b\x1a\xf9\x28\x31\xb7\xd1\xf8\x3b\x3a\x28\x1f\x45\x3b\x6d\x85\x27\x51\xeb\x42\x19\xb2\x1b\x82\xd5\xf2\x52\xed\xbc\x2f\x74\x70\x7d\xab\xc1\x44\x6d\xc0\x36\x45\x71\x2d\x97\x6a\xa7\x0a\xae\xfd\x02\xcd\x80\xa5\x42\x65\xbd\xa1\x54\xb5\x68\x10\x2d\x51\x37\xad\x37\xad\x90\x33\x8d\x82\x70\xac\x57\xab\x75\x0b\xaa\xf2\x0f\x6d\x68\xd0\x76\x39\x1d\x2d\x04\x82\x17\x5f\x58\xbe\xff\x03\xb4\xa7\x03\x32\x11\xef\x80\x4b\x1a\x83\x42\x7d\x9f\xd6\xdc\x6c\xcb\x76\xbe\x14\xde\xad\x66\xea\x42\xb2\xb8\x02\x68\x2e\x8d\xca\xf8\x37\x3f\xf2\x05\x44\xe4\x49\xe7\x01\x91\xb0\x45\x2f\x99\x65\x1c\x99\x4f\x92\x8a\xb8\xf2\xef\xf7\x93\x00\xdf\x3a\x02\x6e\x04\xff\xa8\x43\x29\x82\x6f\x88\x93\x06\xf7\xe7\xfd\xc8\xfd\x71\x7f\x68\x9f\xde\x47\x1b\xe5\xfe\x64\x7c\x0e\xd3\x09\x7f\xde\x2f\x39\xdd\xf8\xa8\xa5\x73\xfa\xbc\x23\x44\x21\x1b\xe4\x1d\xac\x7a\x2b\x5e\x73\x35\x3e\x4f\x96\xe3\x1e\xff\x7b\xee\xac\x79\x67\xf9\xfe\x83\xc6\x17\xef\x8b\x1e\xd1\xe5\x96\x56\xce\x77\x33\x6e\xfa\xc9\xe4\xbf\x38\xdb\x3b\x5d\xe6\xff\x3f\x6e\xc2\x5f\xf6\xb2\xf0\xb7\x3c\xe5\x2f\x1d\xef\xeb\x2f\x4b\xe2\x1a\x1b\x15\xbe\xd6\xfa\x7c\xb9\x7f\x7d\x58\x70\xe8\xb8\xf5\xf9\x5d\x2f\xc7\x78\xcb\xeb\xf3\xbb\x6b\x4d\xf9\x77\xf1\x94\x93\xa9\x43\x42\x09\x17\xfb\xc4\x5c\x27\x3f\x7e\x4c\xc2\x3c\xfc\xa7\xd4\xd5\xda\xf5\xf3\xcf\x23\xc8\xe8\x35\xe8\x66\x48\x6a\xc0\x97\xe2\x9f\xf7\x2f\x45\xb2\x0c\xff\x7c\x96\x4e\xfd\x40\xf7\xdc\xe8\x39\xcc\x60\x87\xc4\xcf\x62\x1e\x40\x23\xe3\x12\x9a\x18\x13\xa2\x30\xff\xbc\x5d\x1f\x19\xea\xb7\x95\x4e\x98\x69\x5d\x15\x23\xd9\xad\x18\x24\x01\xb3\x5e\x61\xac\x2f\xda\xe1\x21\x0a\x60\x22\x74\xbb\x54\xcd\xb6\x34\x8a\x8f\x67\x1a\x0c\xeb\x18\xfb\xed\xba\x0d\xea\xd2\xaf\xfd\x6f\x60\x1b\x7f\xc4\x53\x28\xfc\xa3\x72\x7a\x76\xde\x7d\x8e\x02\x1d\x47\x99\x8e\x86\x74\xc8\x7c\x11\xb6\x3d\xe1\x15\xb3\x34\xe5\xef\x86\x9d\xc3\x68\xfc\x73\x2e\xff\xf5\x94\x3c\x8c\xf1\x4b\xd6\x34\x2f\x97\x76\xaf\x52\x87\x01\x1c\x12\xf9\xdc\x9f\x4f\x79\x4e\x65\xc0\x4c\x31\xe2\x0e\x8f\xe2\xf6\x32\x47\xaa\x3b\xa4\x6b\xb3\x43\xe3\x37\x2a\x9a\x71\x57\xa3\xfd\x13\x98\xee\x28\x76\x08\x32\xb1\xb5\x00\xf7\x72\x53\x42\xe3\x1b\xbc\x39\xb9\x49\x5b\xdc\x95\xaa\x2a\xa6\x9d\x9d\x72\x1b\xd4\x0d\x5f\xea\xec\x50\x4e\x8f\xfc\x13\xd8\xa3\x51\x2c\xd9\x35\x0f\x65\x4e\xf5\xf9\x23\x4f\x39\x99\xfa\xcd\x58\xb2\xa1\x87\xa6\x67\x44\x6c\xd1\xaf\x45\x1b\xf7\x70\x6d\x3f\x13\x86\xcb\x32\xb4\x2f\xe5\xfa\x38\xf5\x83\x8b\x78\x5a\x74\xee\x29\x3e\xfc\x64\x54\x5e\xce\xe5\xbb\x56\x25\xd8\xf7\xe0\x03\x24\x03\x57\xf3\x4b\x20\x5c\x1a\x52\xdf\x37\x8c\x6d\x51\x5b\x24\x62\xce\x47\xe4\x52\xa1\xc3\xfe\x4c\xb7\x4b\xf0\x69\x6f\x7d\x77\x13\x44\x13\x07\x86\x91\x2b\xb5\x30\x8e\xb4\x70\xe1\xbe\x1d\xdf\xc5\x0b\x05\x42\xc1\x8b\xe2\xc3\x49\xc8\xb1\x95\x39\x82\x79\x96\x87\xb7\xfe\xf7\xcf\xf6\x80\x10\x35\x72\xc1\x62\xea\xe6\xa0\x8a\x60\x21\x59\x5c\x1a\x28\x99\xd2\x75\x0d\xf7\xe7\x9a\x9c\xd3\x08\xda\xf0\x3e\xde\x99\xd1\xcc\xd3\x80\x76\xec\x53\x4e\xb6\x1d\xe0\xa0\x7a\x86\x30\x48\xc0\x6f\xa6\x17\xe2\x1d\x7e\x7e\x97\x7b\xb7\x87\x99\x8a\x07\x72\xa3\xa9\xdf\x90\x29\x3a\x94\xe8\xf8\xf6\xf6\x93\x1e\x9c\x71\x96\xee\xf4\x6c\xc9\x17\x07\xd2\x9f\xcc\x5a\xe7\xd8\xa2\xb8\x8f\x1b\xad\xf6\x78\x8d\x13\xef\xf3\xcb\x1f\xed\xa8\xe5\x58\xa4\x78\x28\xa3\xa7\x9f\x2c\xc3\x2d\x68\x9f\xf8\x38\x7e\x77\xf0\x56\x1f\x4a\xd3\x7e\xf7\xb3\xe7\x7a\x22\x04\x38\xe3\x21\xe0\xd0\x2b\xb7\xd8\x58\x99\x46\xb6\x0a\x00\xe7\x09\xf2\xe2\x52\x81\xef\x3d\x00\xb1\x25\xd1\xcf\x34\xe9\x7f\x51\x3b\x0c\x95\x99\x88\xcb\x5a\x6f\xeb\x7f\x51\x3b\xef\xba\x9c\x99\x62\x17\x36\xcd\xe3\x9d\x0d\x04\xef\x85\xa6\x53\x25\x8a\x7b\xb6\xe7\xd7\x7f\xb3\x87\x9f\x85\xfd\x77\xb9\x03\x9a\x46\x28\x72\xfc\x76\x04\x95\x9a\x87\x76\xe3\x9f\xd9\x02\x39\xfe\x3e\x40\x38\xc4\xb4\x62\xd6\x28\x79\x99\xbb\x78\xae\x1d\xbf\x54\xbd\x82\x21\x2b\x01\x54\xf9\xad\x6a\x8f\x93\x97\xd9\x17\x99\xca\xa2\x38\xee\xbe\xdc\x7b\x47\x71\x3f\xb4\xb0\x94\x06\x5a\xe8\x1d\xc6\x75\xfa\xe8\xe0\x93\xd5\x73\xbd\xa9\x5b\x48\x6c\xdb\x6e\x75\x08\x68\x72\x11\x46\xc2\xc8\x15\xbc\x39\x13\xf1\xd7\x5f\x99\xbf\x52\xd0\x35\xac\x02\x01\x97\xcd\x94\x03\x2d\xf3\xc0\xc2\x01\x6e\x66\x25\x4b\x70\x55\x71\xc1\x4a\x80\x4c\xd9\x12\x7c\x82\x04\x80\x4d\x0f\x5d\x28\x5e\xe9\xfa\x21\x35\x45\x3a\x57\x82\x83\x89\xe2\xac\x66\x84\x8e\xe6\x2f\x5e\x21\x64\x5d\x9c\xea\x46\xe8\x55\xd9\xda\x7f\xfe\xf7\x7f\xfe\x17\x0c\x7d\xa6\x96\xf2\xaa\x44\x74\x99\x38\x4d\x54\x81\x4d\x60\x38\xdd\x1c\xf0\xd6\x01\x9f\x4d\x2c\x36\xed\xa6\x51\xe2\x4a\x35\xc6\xc3\xa6\xc1\xe4\x47\x61\xa7\xf5\x6c\x41\xa1\x16\x72\x53\xb5\x8f\xfa\x4a\xf0\x9c\x96\xb9\x8b\x1b\x8b\x5e\x2e\xea\x44\x39\x72\x0e\x6f\xc5\x9e\x28\xb6\x40\x4d\x33\xcc\x66\xea\x13\x2f\xab\x0b\xdd\x94\xed\x72\x45\xa9\xf3\x7d\x44\xfa\x6c\x27\x8c\x92\x0d\x86\x9e\x43\x28\xbe\x65\x42\x8c\x50\x75\x61\x84\x29\x31\xa8\xd5\x35\xc5\x18\xa0\x99\x9c\x5f\x7a\x24\x61\x4d\x01\x23\x66\x2a\x5e\x1c\xad\x44\xdb\xec\x28\xb0\xc9\x28\x25\x96\x7a\x2b\x16\xd2\x07\xad\x5f\x28\x1f\x19\x4b\x07\x52\xb6\x62\xa5\x0b\x55\x01\x0b\x54\xb6\xd8\xf5\x66\x4d\x51\xb2\xb6\xa5\xad\x6e\xe8\xe8\xb6\x8d\x2c\x94\x5e\x2c\x10\x3f\x7b\x2e\x3d\x80\x31\x85\x18\x43\xb8\xce\xd4\x47\x60\x3e\xbb\x72\xe7\x5e\xc2\x5d\x50\x75\xa1\x0a\x37\x79\x58\x2c\xdb\xce\x51\x41\xf1\xdb\x2c\x52\xdf\xb1\x66\x96\xe8\xf9\xf1\xc2\x13\xe1\x33\xac\x88\x05\x84\x03\xd8\x93\x86\x59\x6d\x66\xcd\xa6\x85\x9a\x73\xe5\x43\x84\x65\x53\x1a\xf0\xa0\x73\xe8\x07\xae\xb1\x0b\x0d\x2b\x4e\xdd\xbc\x94\xeb\xa9\x78\xd1\x1e\x15\x02\x31\xed\x34\x60\x90\xea\x46\x89\x65\xd9\xb6\x3e\xea\x13\xa0\x03\x30\xe0\xb3\xf4\x53\x5f\xe8\x66\x2b\x9b\xe2\x21\x84\x33\xd8\x95\x84\xc1\xc0\xbf\x2e\x34\xef\x41\x68\x8a\x51\xae\x75\x5b\xce\x95\x8f\x65\xac\x15\xe9\xed\x4e\x4f\x45\xa5\x5b\xc0\x95\xa9\xb4\xbe\x14\x72\xa9\xa4\x43\x7a\x28\xb4\x32\xb8\xfb\x75\x51\x29\x8a\xf3\x96\x95\x90\x46\x6c\x55\x05\xff\xf7\x2b\xec\x1a\xc3\x93\x05\xc8\x36\xb6\xaf\x23\x7b\x67\x37\x66\x23\xab\xa9\xf8\x46\x99\x12\x24\x6b\x37\xbe\xfc\xf6\x88\x56\xfb\xd5\xd7\xcd\xa5\x3d\x69\x0e\xce\xcc\xd0\xd6\xb9\x00\x8e\xb9\x5e\xef\xa0\xa5\xed\x52\x57\x90\xe2\x3c\x9c\x83\x17\x35\x41\x1c\xe0\xd2\x01\xc7\xe5\x36\xbf\xaa\x30\x4a\x1c\x30\x11\xe0\xac\x84\x25\xb7\xe7\xbc\x88\xce\xc0\xb1\x2c\x0a\x52\x54\x52\x54\x2d\x06\x8a\xbe\x94\xeb\x13\x4b\x6f\xec\x74\xe0\x1b\x85\x8d\x9c\x62\x88\x8f\x1f\x08\x22\xd4\x10\x7d\xa2\x00\xe0\x42\x4d\xd0\x77\x79\xe3\x30\xb7\x13\x72\xe0\x58\xc4\xe3\x13\xb1\x5d\x96\xf3\xa5\x6b\x6d\x63\x28\xcd\x12\x50\x74\x7f\xc7\xa7\x31\x5b\x75\x7a\x2a\x80\x6a\x4c\x84\x83\x12\x45\x9d\x2e\x53\x64\x44\xef\x20\x0f\x1b\xd3\x8d\x38\x06\x10\x34\x08\x34\x13\xa5\xf8\x3d\xa7\x3a\x84\x83\x7c\x26\xca\x5f\xff\x3a\x65\x59\x89\x91\xe1\xc5\xff\x5c\x32\xd0\x28\xde\xe5\x7e\x36\x2a\xcb\xd8\x21\x04\x96\xd9\x54\x76\xb7\x02\x61\x8c\xe6\x80\xc9\xcc\x51\x69\xfd\x8a\x02\x67\x7c\x01\x5f\xc2\x5b\xf7\x7a\xe3\x66\x5d\x84\x3e\x0b\x54\x0a\xb1\x77\x94\x1c\xc5\xca\x1d\xc9\x6f\x1f\xda\x6f\x43\xd3\x61\x54\xb0\xae\x67\x19\xa3\x22\x6a\x66\x6c\x43\xf9\x85\xc6\x8f\x7c\xb5\x29\xf2\x8c\x87\xd6\x7d\x25\x9c\x24\x10\xb6\x24\x19\x8a\xab\x11\xf6\x43\xe7\xc6\x99\xd1\xf9\xf6\x34\x14\x87\xd4\xc6\x58\x66\x75\x58\xf7\xf1\x56\x5d\x7b\x5e\x70\x1a\xfd\x3e\x9c\xa4\xe6\xa1\xc6\x33\x3c\x9e\x0f\x13\x78\x87\x10\x28\x4a\x5e\xc2\x6b\x85\x18\x12\x06\x88\x1d\x10\x5c\x58\x7c\x1f\xda\x25\xde\x01\xb5\xe2\xcd\x6c\xea\x85\x6e\xda\x0d\xc4\x70\xb1\xa8\xdc\xb6\x29\x2f\x2e\x10\x73\x45\xd9\xf6\xb6\x48\xa2\x11\xaa\x46\x41\xdc\x28\x84\x9a\x79\x12\xeb\x9e\x2b\x31\x53\x6d\x0b\x40\x5f\x3b\x24\x5e\xab\xd5\xa6\x46\xa1\xc3\x07\x29\x50\x7c\xa9\x90\x20\x84\x58\x61\xc4\x65\x01\xf6\xed\x50\xaa\xe7\x49\x80\x1c\x9f\x08\xd5\xce\x83\xb2\x80\x1f\x8f\x1e\x36\x98\xef\x3c\xdb\x5c\xae\x39\x1f\xe0\x71\x86\x62\xe0\x32\xf9\x23\xb0\xa7\xb1\xb1\x71\xc2\x87\xf9\x92\x78\xea\xd6\xb9\x9d\xc0\xab\xb2\x55\xa2\x28\x29\x67\x9c\x4b\x68\xe6\x7d\x45\x29\x3e\x19\x94\x34\x71\x7b\x3e\xe6\x0f\x21\x08\xa2\x5a\x28\x95\xb0\xf2\xbd\xe8\x06\x6e\x36\x27\xdd\x95\x72\xff\xef\x52\x8c\xf1\xb1\xb3\xc5\x87\xe8\x9c\x77\x89\xd8\xd0\x79\x07\xff\x7d\xbd\x69\x11\xdc\x47\xd9\xe7\x7c\x4d\x0f\x39\x30\x06\x88\xd9\x64\xfc\xeb\x8b\x0f\x63\xb3\xa9\x79\x38\x68\x96\xb2\xb2\xe0\xc3\x2c\x7d\xf0\x43\x78\xaa\x16\xaa\x71\x51\xee\x20\x62\x63\x88\x35\x18\xf5\x10\x2c\xa7\x29\x2f\x96\x2d\x05\xbd\xe3\x48\x4a\x03\xbb\x3b\xe5\xcd\xbd\x98\xaa\x29\x56\x87\xb4\xfa\x70\x55\xc1\x65\xca\x50\xd4\xbb\x87\xd2\xf1\x6c\x5c\x01\x7d\xdb\xe6\x78\x43\xf0\x36\xcb\xf9\x92\x35\x11\x72\x94\x01\x4e\x8d\x7d\x84\x91\xc9\xdd\x72\xd4\xa9\x40\xb5\x78\x73\x5e\x9e\xf2\x46\x51\x5d\xb3\x70\xda\x74\xc3\x78\x64\x76\xba\x88\xf7\xf2\x55\x32\x45\x07\x2f\x2b\xd3\xff\xbb\xe7\xe8\xfc\x3c\xf3\x8e\xc4\x80\x48\x80\x19\xd2\xd8\x85\xa1\xfb\xa5\xea\xc2\x9d\x9b\x28\xe2\x15\x30\x0c\x64\xcd\xaf\x4d\xa3\x8c\xdf\xac\x51\xd8\x2b\x9d\x4b\x43\xd2\x51\xe6\xb4\x75\xe6\x34\x40\xc7\x90\xb5\xb2\xe4\x20\x88\x28\xb2\xb6\xec\x70\x93\xde\xed\xc6\xa5\x81\xad\xc5\x7c\xa9\xb5\x01\xc8\x47\x69\x90\xb9\x0e\xcd\xa1\xec\xe3\xe6\x28\xb6\xa5\xe5\x71\xab\xca\xca\xaa\x3e\xdc\xd9\xf3\x50\xf4\x9e\x1f\xf8\x74\x93\x6e\x8f\x3d\x8f\x7b\x5d\xcb\xc7\xbc\x8a\xa4\x76\x78\x9f\xc6\x47\xe3\x1f\x67\x89\xcf\x91\xf7\x41\x72\xf5\x7e\x3c\xbd\x3a\x80\x62\xdd\x2e\xcd\xea\xa3\x5a\xef\xd3\x6b\x94\x35\x66\x0f\xdc\xd8\x5c\x03\xbd\x37\x3d\x57\xfe\xd3\x61\xc7\x9d\xa0\x69\x24\xe3\x4a\x50\xce\xb8\x54\x08\x45\x63\x17\x01\x60\x66\x40\x52\xdb\xb8\xcc\x9d\x3d\x80\x31\xfb\x41\x72\xd8\xbd\x74\x03\xf8\x17\xa5\xd6\xc2\xcc\x65\x0d\x78\x22\x56\xa6\xf4\x39\x43\xe5\x1a\x1d\x39\x30\xc1\x02\x5e\xfc\x02\x00\x06\x20\x39\x89\x95\x79\x68\x40\xd7\xbb\x19\xd1\xbd\xf8\xdc\xf3\x8d\xd7\x34\x4e\x8f\x65\x25\x43\x8f\x29\xe3\xb2\x9f\xbd\x49\x5b\x60\x6c\x4d\xde\x47\x81\x74\x33\x48\x62\xc9\x39\xd1\x64\x50\xe7\x90\xd1\xf1\x0a\x6a\x82\x24\xec\x78\xc5\x84\x80\xf4\x04\xa5\x64\xeb\x92\x53\x05\x2f\x48\xcf\x91\x06\x1e\x28\x6d\xae\x6c\x51\x19\x04\x6a\x0c\xb8\x44\x00\xbf\xc6\x00\x90\x90\xd0\xc6\xc8\x6e\x0e\x5d\x2d\x6d\x0d\x50\xd6\xa2\x1f\xd3\x1d\xfc\xf3\x11\x8e\xe3\xe8\x2f\x7c\x0d\xfb\x4c\x3b\x71\x91\xac\xf1\xe5\x70\xb2\xf6\xf9\x2d\xd3\xb5\x3d\x94\xe8\xf3\x1b\x93\xa2\xcf\x0f\xa5\x45\x9f\x67\xa5\xe8\x31\xe7\xdb\x92\xa3\x7a\x97\x79\x48\xe9\x34\x20\x44\xde\x5c\xd7\x66\xb3\x52\x85\x90\x33\x4b\xca\xed\xcf\x8e\x36\xa4\x42\x10\x22\x18\xc9\x82\xf0\xb3\x92\xf3\x13\x1d\x98\x8e\xa9\x6b\xa1\x9b\x67\x72\xbe\x3c\xee\xc9\x55\x23\x02\x95\x1d\x06\x26\x0b\x4a\x85\xd8\x1c\x35\x4c\xa2\xf7\x68\x6e\xbd\xaa\xe6\x00\xe5\xad\xd3\x68\xed\x53\xe2\x96\x4c\xd9\x93\x04\x83\x4a\xd3\xa7\x44\x3e\xf1\xd9\xc9\x2c\x1d\x09\x39\x65\x7d\xb2\x12\x87\x78\x1c\xb4\x21\x51\xde\x81\xbc\x85\x92\x8d\x9a\x16\xef\xfe\x88\x0c\x02\x39\x84\xec\xc7\xb5\xcb\x9c\xe4\x1c\xfe\x28\xb9\xc0\xac\xba\x8b\xf4\x3a\xa9\x66\x0c\x32\x40\xc9\x99\xf6\x6b\x03\xb9\xa2\xa4\xf1\x47\x9c\xbd\x0f\x89\x6d\x92\xad\xc1\x54\xd5\x6d\x53\xaa\x34\xef\x70\xca\xea\xad\xb5\xb1\xf7\x58\xbd\x94\xeb\x58\x33\xe6\xda\x49\x08\x4d\x28\x1e\x75\x10\x56\x38\x49\xa4\x48\x96\xa0\x34\xf5\xd5\x44\x1c\x7d\x97\x9d\x5b\xce\x8a\x02\x8c\x2e\x2d\x34\xb8\x5a\xa2\x5d\x65\x53\xab\x80\x95\x6e\x2f\x86\x99\x8a\x27\xba\xbe\x52\x4d\x4b\x0f\x80\x14\x46\xfd\x6d\xa3\xea\xb9\x3a\x75\xfb\x27\xd0\x8a\xa7\xa8\x0d\x9e\xbb\xc5\xf8\x73\x37\x3e\x8f\x8d\xfb\x93\x49\xed\xe5\xd2\xd0\xc7\xe4\x90\x67\x89\x1c\x52\x81\xa2\x14\x54\x55\x08\xcd\x27\x8a\x72\xb1\x50\x10\x7f\xeb\x2f\x09\xc2\x80\x39\xce\xd3\x72\x52\x90\xaf\x7a\x9a\xf0\x2b\x8c\xe5\x0a\x9b\x14\xe3\x75\x77\x6f\x4e\x60\x1d\x5c\x81\xf4\xdc\xf4\xa9\x67\xa9\x63\xd3\xaa\x35\xd1\x79\x4f\x24\xad\x70\xc8\x4d\x99\xc4\x87\xdd\x87\xc2\xd3\x42\xd7\xea\x6c\xa8\x62\x7c\xb0\xb8\x3e\x17\x1b\xe8\x84\x2c\x5d\x4f\x9d\x9b\x6a\x4c\x98\x62\xf7\xba\xab\x79\x9f\x7f\x1b\xce\x36\xff\x38\x50\x1a\x47\x83\xd6\x8d\xbe\x2a\x0b\x55\x88\x5a\xfb\x3e\x33\x04\xe4\xef\x53\xf3\xec\xbf\xd2\xbe\xf7\x9d\x97\x21\xed\xf4\x7d\x76\x7e\x1c\xdf\x3e\xe9\x6f\xf0\xe7\xab\xa7\x0e\xd7\xe0\x17\xf5\xf4\xcd\xd4\xd3\xf7\xbd\xec\xf9\x8b\x5a\xfa\x17\xb5\xf4\x2f\x6a\xe9\x9f\xb3\x5a\xda\xbf\x1e\xbf\xa8\xa0\xef\x46\x05\x7d\xed\xf7\x39\x51\xba\x7d\x31\xa4\x8d\x1e\xf1\xf6\x25\xfa\xb0\x2f\x7a\xa8\xe8\xcd\xb5\xd1\x5f\xfc\x3d\xab\xa3\xbf\xb8\xb1\x12\xe8\x8b\x43\x95\x40\x5f\xfc\xa2\x91\xbe\xd9\x45\x89\xae\xc9\x97\xd7\xd5\x4d\x8f\x64\x1f\x59\x47\x39\x35\xf2\xb5\x74\xd3\x5f\xfe\xa2\x9b\x66\xad\x5d\x4f\x37\xfd\xe5\x7e\xdd\xf4\x97\xb7\xa8\x9b\xfe\xf2\xc7\xd5\x4d\x7f\x79\x63\xb2\xf4\xe5\xa1\x64\xe9\xcb\x5f\x74\xd3\x77\xa6\x9b\x46\xd0\xec\x41\x58\x68\xae\x99\x1e\x01\x10\x8d\xe4\xc1\xa5\xcc\xf7\x1e\x98\x10\xf8\x64\xe9\x2b\xf8\x7a\xeb\x9a\x85\x50\x7a\x5f\xe2\x88\x3d\x72\x8d\x91\x98\x89\x32\x22\x2c\x7b\x80\xd7\xee\x8c\x30\x87\x58\x1c\xbe\xfa\xc4\xaa\x59\x70\xea\xef\x43\x76\x14\x62\xd0\xc2\xc1\x81\x90\x2c\xa3\x45\xa5\xda\x23\x83\x3e\xa1\xe4\x90\x59\xb6\xf0\xd8\x44\xe4\xc8\x9e\x92\xeb\x70\x9f\xdd\x01\xd3\xf5\xf1\x5b\xbe\x07\xf0\x6e\xec\x56\x9d\x25\x67\xf4\xda\xe8\x77\xfe\x35\x60\x22\x6c\x48\x39\x13\xa1\x82\xf8\x35\xdc\x06\x22\x8e\x5c\xa4\x15\x42\x5c\x5b\x61\x2d\x63\x19\x57\xd7\xee\x8d\xbe\x66\x1a\x9f\xa0\xff\xba\x6b\xcc\xf1\x51\x50\x66\x5d\xa0\xb9\xc1\x0b\x3a\x84\xe8\xcd\x37\x7d\x0f\xb6\x77\x08\xb0\x71\xb0\xd4\x3e\xc4\x86\xeb\x71\x47\xa4\xfc\xc9\x70\x07\x9e\x3b\x7e\x81\xf1\x39\xfe\x05\xb4\x7b\x3a\xef\xc4\xe3\x91\x08\xdc\x7a\xa6\x59\xae\xd7\x55\xa9\x8c\x73\xeb\xf6\xd7\xc8\x3b\x66\xaf\x04\x46\x96\x44\x64\xd6\xe7\x39\xeb\x43\x3c\x08\x05\xdc\xed\x77\x51\x6e\xe2\xeb\x08\xc3\xbc\x2f\x0e\x58\x3c\xa2\xd1\xef\x41\x3e\x1f\x7f\x38\xb3\x57\x7b\xf0\x7a\x47\xbb\x3b\x3c\xda\xaf\x63\x10\xf5\x80\x79\xfa\x68\x24\xba\xba\x18\x44\x58\x8f\x46\x92\xad\x33\x06\xa3\xeb\x87\x2c\x57\x35\x1a\x6b\x3d\x53\x69\x18\x6f\x5d\x24\x81\x51\x59\x82\x26\xf2\x3c\xcd\xf8\x3d\x1d\x8a\x0a\xfa\xd4\xa7\x7d\x1a\xfb\xd8\xd3\xff\xfd\x1d\x5d\x66\x92\x15\xf9\x87\x71\xcc\x49\x49\xd2\xf9\xec\x45\x82\xcc\x1f\xab\xc3\x01\xcd\x18\xe9\xb9\x03\x88\x58\x0e\xc8\xf6\x7f\xdd\x1d\x3e\xbe\xef\xa2\x0f\x21\x3f\x43\x95\xbb\x95\x47\xce\xd7\x97\x0f\x0f\xef\xe0\x6b\xd1\x0b\x9c\xcf\x07\x35\x04\xa1\xcf\x02\x31\x65\x55\xfd\x43\x3e\x12\x3d\x80\xfe\x87\x11\x84\xeb\x10\xf9\x41\xec\x7c\x71\x20\x9d\xfd\x39\xd3\xb9\x3b\xcd\xa5\x70\x17\x4c\xdc\x40\x8e\x02\x7e\x31\xf1\xfb\x50\xb6\x82\xb1\x22\x16\xf8\x68\x98\xa0\x2b\xde\x1d\x35\x4a\x00\x68\x7c\xa5\x8c\x99\x8e\xbd\xd2\xfe\x72\xf4\x24\x03\x8c\x2f\x4e\x6f\x8a\x84\x1b\x5e\x9c\x3d\xd7\x66\x30\xb5\xc0\xf8\xe4\x02\x87\x5c\xaf\x9e\xcb\xd5\x73\xf2\x0f\xba\x58\x1d\x97\x87\x3b\xcf\x25\x31\x2a\x93\xc4\x5d\xdc\x8a\x81\xcc\x0b\xfc\x56\x0c\xe7\x60\x08\x0f\x16\x21\xfd\xff\x23\x3e\x59\x2c\xc1\xc4\x83\x07\xee\x1e\xf5\xa4\x97\x38\xef\x4b\x2f\x91\xa9\x99\xf8\x13\x9e\xef\x4f\x2e\x71\xe3\xcb\xbe\xf7\xba\x1f\x96\xd0\xe1\xb0\x7b\xfd\x0f\xfc\x6c\xde\x46\xa2\x8f\x9b\x10\x09\xe7\xce\xfa\xf8\xf5\x0b\xb4\x69\xda\xb3\xed\x95\xf9\x31\x52\x45\x48\x7a\xee\xcc\x70\x3e\x43\xa7\x24\x6d\x3e\x58\x04\x8c\xaa\x16\x90\xc7\x7b\x87\x4d\xce\x14\x4f\xb1\x1b\x37\x04\xd6\x02\x08\x5b\x07\x1f\x3e\x80\xae\xd9\x5c\x40\x87\xd8\x9c\x1f\x87\xa4\xac\xe1\x6b\x09\x99\x37\xfa\x1d\x7f\x61\xd2\x66\xb4\xcf\xef\x3e\x47\x5f\xdf\x0b\x29\xd7\x1a\x35\xdf\x34\xa6\x74\xb9\x22\xd1\xd2\x0c\x0e\x3c\x7a\x2d\x2a\x75\xa5\x2a\x22\x31\x90\x8d\x51\x36\x8d\xdc\x81\xe3\x40\x6b\x57\x1e\xb4\x97\x06\xdc\x33\x61\x11\xbd\x50\xe7\xda\x02\xf5\x9d\x2d\xe0\x12\x69\x4c\xc5\x2b\x65\xc0\x1f\xd4\xb6\x84\x8a\xdc\xa5\x42\xa0\x64\x88\xff\xf7\x6b\xdc\xd2\x19\xa3\x24\xa8\xa7\xa7\xbe\x0d\xd4\xfa\x4e\xc5\x1b\x1c\xba\xae\xbd\xbd\x94\x9c\x2c\x6a\xdd\xac\x64\x25\x16\x95\xde\x86\xf0\xf8\x3f\x22\xb8\x40\x98\xd6\xa6\x46\xff\x51\xd7\x2c\x18\xf3\xd0\xe0\xb4\x43\x25\x3e\x8e\x71\x1a\xad\x5f\xa5\x64\x61\x40\x89\x5f\x0b\xb9\x9a\x95\x17\x9b\xb2\xdd\x89\x99\x6a\xb7\x4a\xd5\xe2\xf7\x5f\xfd\xf0\xe7\xe9\x74\xfa\x97\x4f\xbf\x3f\xfd\x0a\xb6\xf8\xf7\x5f\x4d\xa7\xd3\xdf\x9f\x7e\xe5\x1b\xf9\xde\x2d\x9d\x1d\x28\x36\xa0\x37\x06\x70\x00\x0c\x19\x10\x9c\x23\x76\xd0\x53\xab\x5a\xce\x2c\xff\x27\xe7\xad\x57\x3e\x3d\x78\x90\x47\x37\x1c\x02\xe2\xe3\x3f\x0e\x6b\x81\x78\xc1\x3c\xfc\x69\xe8\xb5\x0f\xa5\x2e\xb5\xf1\xd2\x0e\x90\x3b\xa4\xed\xde\x78\x8a\x52\x1a\xc4\x75\x12\xe7\x87\xcf\x8a\x01\x63\xbb\x66\x6e\x1f\x71\x90\x08\x4e\x27\x53\xe8\x35\x15\xad\xbd\xd7\xd5\x99\xa4\xc5\x08\x28\xbd\x91\x63\x1a\x25\xce\x0f\x0d\x28\x33\x9e\x1e\x7c\xbb\x91\x23\x1a\x29\xc9\x1c\x38\xa6\x1e\xe4\xa8\x91\x63\x1a\xc9\x47\xee\x1f\x53\xc7\xca\x78\x3b\x20\xa5\x23\xa7\x31\xda\x14\x37\x0c\xfa\xd9\x45\xfd\xcc\xa0\xcc\x75\x06\x77\x43\xb0\xa1\xfd\xd0\xa3\x7b\x31\xed\xfa\x06\x72\x70\xec\xcc\xfe\xb1\x74\x69\xcd\x4f\x13\xa8\x6e\xb0\x55\xef\x3c\x7b\x94\x7a\x9b\x45\xfe\x71\x18\xcd\xe1\xfd\x6c\x1d\xf3\x42\xab\xcd\xdc\x38\x00\xcc\xcb\x94\xdc\x94\xe9\xf1\xbd\x26\xb8\x40\x60\x18\x6d\x1a\xdd\x00\x28\x13\x5a\xeb\xa9\x21\x78\x13\x00\xff\xa8\x28\x8d\x7d\xf2\x8a\x49\x68\x67\x1b\xec\xab\xed\xb2\x51\x5b\x7c\x2d\xa7\x09\x9d\xe7\x2c\x67\x2b\x2f\x3a\x54\xfe\x49\x25\x8d\xf1\xda\x85\x7e\xb4\xc8\x14\xbb\x15\x1e\xa9\xda\xb4\xb2\x9e\xab\x98\x21\x0d\x92\xce\x59\x52\x07\x4e\x09\xd5\x99\x36\xaa\x2e\x54\x33\x7d\x5f\x9a\x97\x7a\x7e\xe9\xb6\x2c\x07\xaf\xef\x6c\xc9\x95\x5d\xab\x4d\xab\x1f\xae\xf4\xfc\x12\x78\x8e\x75\xa3\xe7\x0a\x78\x22\xc7\xa8\x1c\x45\x89\xf9\x31\xbd\x44\xda\x5e\x07\xe2\x4d\x74\x50\x61\x73\x70\xda\x84\x6e\xd4\xaa\xda\x0e\x54\x56\xd5\x4e\x2c\xd0\xbb\x9b\x78\x5a\x4d\x67\xe4\x43\x0b\x4b\x3b\x41\x00\x21\x42\x71\x32\x00\xf6\xc5\x9b\x72\x07\x18\x01\xad\xe6\x76\x1f\x54\xe4\xac\xaa\x4c\x55\xd6\xed\x43\xda\xfa\x87\xb6\xe1\x87\x95\x3d\x70\xa2\xd6\x0f\x6d\xd7\xd4\x73\xbc\xa1\x6e\x25\x65\x35\x62\x57\xed\x2e\xfa\x62\xc9\x36\xda\xc3\x17\xaf\x52\x37\xac\xe3\x57\xe6\x78\x3a\x9d\x9e\x3c\x12\xaf\x34\x02\x34\x6d\x21\x3a\xce\x36\x02\x9c\xa4\x5e\x09\xda\x67\xe4\x16\x01\x91\xaa\xda\x91\x63\x92\x74\xe7\x1c\x4e\x0c\x70\x71\xa5\x71\x28\x90\x53\xf1\x6d\x33\x41\x47\x33\xdb\x80\x65\x9d\x6d\x0f\x93\x28\x75\xc8\xd1\x24\x0c\x7f\x5a\x94\x66\x5d\xc9\xdd\x2b\xb9\x52\xf6\x19\x09\x1f\x6a\xfa\xe5\xc8\xff\x74\xd4\x83\x22\x2a\x22\x06\xcd\x0b\xa1\x8e\x1d\x6d\x14\xfa\xf3\x7b\x56\x1c\xc3\x07\xa6\x5c\x04\xbb\x81\x3d\x1d\x7a\xce\x52\x6c\x14\x7a\xce\xee\x7d\xba\x77\x0f\xe3\x61\xba\x1f\xc5\xb9\x80\x7f\xbd\x71\xdf\x9a\xe3\xb6\xd9\xa8\x09\xc4\x6b\x59\x2e\xaa\xaf\xe2\x8b\x1a\x7c\x9d\x32\xf5\x69\x97\x79\x03\x2b\xbd\xa9\xdb\x43\x2a\xc3\xff\x6c\xed\x90\xd3\xaf\xd2\x75\x24\xca\x79\x9f\xb5\xad\x6e\x2e\x5f\xd4\xaf\xc9\xe3\x0d\x49\xc1\xfd\x6c\x82\xc6\xb8\xe4\x34\x20\x79\xba\xcc\x8d\xe4\x0a\x94\x0b\x45\x7a\xa3\xcc\x66\x45\x50\x77\x97\x20\x91\xed\x54\x1b\x82\x3c\x55\xd1\x09\x42\xb2\x74\xab\xb7\x47\x2e\x05\xe0\xde\xf9\xad\x04\xd5\x00\x0e\xc8\x89\x06\xb9\x66\xce\xee\xc5\x61\x58\x5e\x8d\xf0\x7d\x54\xf8\x98\x37\x35\x89\x1a\x9e\xae\x55\x5d\x94\xf5\xc5\x6b\x34\x44\x47\x9f\x32\xcf\x76\x7e\x2e\xbe\x7f\x98\xb3\xfb\x47\xa4\x76\x88\x2b\x42\x53\xa4\xeb\xe3\x3d\x3a\x1f\xb5\x54\xf5\x97\x2c\x45\xae\x0e\xde\xca\x9c\x28\x15\x1c\xdf\xee\x76\x6d\x46\xcf\xfc\x13\x5b\x24\xee\xd8\x0f\x02\xd8\xa7\x7b\xf7\x7e\xa0\x5d\xb5\x2c\x89\x2a\x20\x80\xf2\xad\x33\x15\xbc\x51\x0b\x7b\x5f\x7f\xf8\xe4\x6f\x34\xca\xb2\xf6\x3e\x7c\xa3\x2e\xca\xda\xce\x4e\x9c\x0b\xe6\xda\xa6\xeb\x45\x79\x31\x11\x4b\x6d\x5a\xd2\x18\x4d\xc4\x72\x57\xe0\xe8\xfd\x2f\x66\xbe\x54\xc5\xa6\x82\xd5\x99\x00\xa7\xb1\x69\xd5\x33\x3f\xcb\xe7\xba\x61\xd1\x3f\x10\x9e\x06\x1e\x7f\x6f\x15\xb8\x6f\x91\x9f\x0e\x98\x5f\x6d\x77\xd3\xdc\x57\xc7\x81\x6c\x8c\x7a\xbb\xab\xe7\x6f\xb1\x47\xda\x1a\xac\xd6\xf9\xe4\xea\x60\x7b\x4f\xd5\xba\x29\x75\x53\xb6\xe5\xbf\xab\xb7\x9b\x59\xdb\x28\x95\x76\x99\x29\xe2\x6e\xc9\x7a\x63\x96\x7f\x0c\xab\x20\xce\xf9\x9a\x4c\x93\xaf\xae\x63\xfe\x33\xe8\x66\x07\xaa\xc1\x77\xd7\x9b\x25\x08\xcd\x1f\xdd\x3a\xc3\x06\xda\xaa\xc9\xc2\x4f\x33\xc5\x26\x9e\x03\x37\xaa\xdd\xdf\x42\xa6\x98\x6b\xa1\x6d\x76\xef\xf4\x93\x4a\x96\xab\x57\xea\x03\x95\xb1\x1c\xc1\x8b\xc0\x7e\x75\x9a\xdb\x57\xe7\xcc\xd1\xa7\xf7\xe1\xe4\x05\x56\x50\x9c\x8b\xdc\xcf\xf6\xe5\x3c\x1e\x79\xc4\x26\x62\xa5\x56\xba\xfc\x77\x45\xf7\x8e\xfe\x05\x13\x3b\x71\x33\x93\x85\x5e\xb7\xd0\x3e\x9b\x4b\x76\x44\xd3\x6e\x51\xd7\xc8\x5c\xd7\xa6\x6d\x36\xf3\x91\x0d\xe5\x8b\xbb\xc6\xf0\x7d\x1b\xd5\x50\xb7\xa8\xbf\x1a\x88\xa7\x3f\xaa\x95\x4c\xd9\x33\xa7\xb9\x05\x2b\xc9\x1b\xb5\x42\x25\x58\x69\xbc\x1b\x7e\x57\xae\x6c\x9f\x45\xa4\x4c\x14\x65\xa3\xe6\x6d\xb5\x9b\xde\x1b\xc6\x50\xe8\x7b\x7c\x27\xc0\xc7\xa6\x41\xd2\x7b\xfb\x1d\xd7\x5c\xfa\x35\x47\x87\xf7\xa1\xf6\x5e\xb3\x63\x64\x26\x9f\x8d\x4e\x3c\xde\x95\x02\x11\x1c\x42\x8a\x45\xa3\xcc\x12\x25\x42\xcf\x40\x83\x1b\xf4\x52\x02\x78\xeb\x4c\xa9\x9a\xba\x53\x85\x65\x31\x26\x21\x08\x11\x20\x56\x6d\x21\xef\xf4\x4a\x40\x01\xa0\x38\x9e\xa1\x8d\x0b\x80\x7d\x57\x65\x5d\xae\x64\xc5\x95\xea\x66\x2a\x5e\x60\x3c\x7f\x2c\x0c\x62\xcc\x92\x73\xa5\x06\x3e\x55\x33\xc7\x7d\x0c\x94\x13\x65\x2b\x2e\x54\x6b\xfc\xc8\x30\xc2\x15\x19\xf2\xa8\xb9\xb9\xac\x03\x44\x2f\x4c\x3b\x36\x07\xa0\x42\x7f\xb6\x03\x0e\xaa\x6d\xe4\xfc\xd2\x8e\x37\x1a\x27\xb5\xd7\xc3\x6e\xf4\xb0\x92\xc7\xe9\x06\xe6\xaa\x8f\xda\xd6\xc8\x9f\x89\x6d\x2e\x63\xde\x72\x6d\xe7\x04\x7f\x77\x2c\xbc\xf0\x1f\x90\x60\xf1\xef\xdd\x70\x8d\x92\x87\x5f\x44\x2b\xbb\x94\x57\xe0\x27\x6f\xd9\x4e\xd3\x4a\x82\x83\xd8\x79\xd4\xdd\x76\xa9\x18\x68\xf7\x14\x7d\x13\x30\xca\x71\xab\xec\xfd\x8f\xed\x9e\xc0\x4f\x33\xd4\xe9\xe0\x07\x2c\x11\xa8\x57\x2f\x7c\x14\x72\x34\x0f\xdb\xf8\xbd\x68\xaa\x14\x5f\x69\x07\xe3\x26\xa2\x0a\x1c\x17\xa9\x1a\x28\xb0\xc4\x5e\x02\xd4\xea\xa0\x8d\xa1\x34\x02\x10\xaa\x85\x61\x46\x59\x74\xee\x46\x1d\x47\xd9\x0a\xbd\x69\xf7\x9c\x88\xac\xa1\xe7\x6e\x8e\x43\xb4\xc5\x93\xae\xd9\x65\x42\x69\xd1\x9c\x86\x05\x01\x4b\x24\x2e\x76\x14\x5d\xb3\x55\x47\x57\x6c\x47\x5c\x85\x99\xba\xd8\xd4\xc2\xe8\x95\x62\xfb\x6a\x0f\x8e\xe5\x76\xc0\xae\x93\x64\x6b\x43\xc4\xeb\xad\x12\x95\x5a\xb0\xf3\xa2\x17\x0b\x7b\xc9\xfc\xdd\xb3\xa3\xb8\x90\x65\x6d\xda\x4c\xd0\x32\xec\xe8\xc1\x4b\x7c\x57\x17\x6f\x5f\xe2\xfe\x41\xb9\x2f\x60\x2b\xb0\x48\xb6\x64\x44\x9c\xb3\x0f\xae\x35\x4b\x69\x88\x0b\x7a\x02\xd0\xcf\x05\x8f\x28\x3b\x3d\x15\xaf\xc0\x1a\x56\xed\xdc\x0e\xcc\x64\x59\x61\xf0\x21\x5c\xdf\xb5\x11\xea\x6f\x1b\x59\x81\x19\x0b\x43\xae\xe6\xc4\x6a\x2e\x01\xcf\x05\xda\x8c\x2e\x34\x86\x59\x14\x9a\x50\xac\xcb\x0a\xf2\xec\xe1\x1e\xbb\x4c\x35\x18\x9d\xee\xb7\x0b\x3b\xf2\x78\x40\xa4\x5f\x01\x10\x03\x3e\xe3\x4c\x44\xd1\xf0\x92\x10\x9b\x55\xb0\x35\xf1\x7a\x8d\x40\x08\xb3\x9d\x64\xe4\xea\xa8\x35\x02\xb8\xec\x72\x05\x5e\x67\x41\x53\xff\xb6\x7e\x8c\x97\xe0\x79\x59\x97\x66\xa9\x0a\xcb\x2a\xf6\xee\x36\x0f\x7e\xb8\x2e\x7b\x82\x6d\x70\x86\xb3\x73\x98\x33\xe5\x69\xd4\x7d\x22\x79\x7c\x76\x57\xb2\xb9\x64\xee\xa8\x43\x87\x16\x3d\x58\x93\x66\x1b\xb5\x08\x47\xd4\x96\xe0\x36\xc8\xe3\xfb\x8e\x30\x7f\xfc\xe8\x55\x18\xae\x50\xa3\x16\xf1\x01\x26\xb9\xca\xd2\xf7\x37\x6a\x21\xf0\xb5\xcd\x5f\x7b\xfc\xf6\x4e\x5e\x88\x8f\x96\xa5\x5f\xec\xb9\x99\x5d\xd5\xe1\x98\xf9\x2e\x32\xe7\x30\x28\x0f\xdd\x35\xa6\x33\x34\x7c\x87\x7d\x8d\xe4\xe4\x8d\x38\xe6\x3f\x8f\xab\xcf\x6e\x5a\xe6\xde\xbb\xd5\xd8\x7f\xcb\x7f\x18\x6c\xd7\x1e\xb3\xfc\xdd\x86\x7f\x65\x42\xe8\x6e\x70\xb5\x83\x7e\xd5\xcb\x34\x56\x06\x2b\x0b\xd5\x88\x59\x53\xd6\x17\x10\xe6\x54\x93\xe4\xef\x4f\x1e\xe6\x93\x3e\x3e\x81\xf4\x17\x0c\x3d\xea\x45\x2b\x30\x8c\x15\x72\x99\xd8\x47\x73\xca\xd5\xb6\xf6\xf0\x6c\xea\x95\x34\x97\xaa\x08\x2a\x82\x0b\xd5\x7e\x17\xff\x78\x9c\x1d\x2b\x68\xec\x78\xad\x97\x03\x75\x26\x69\x47\x27\x67\xf7\xb2\x2f\x57\x02\x85\x06\x72\x20\x41\x70\x41\x98\xc5\xd4\x4b\x1d\x19\x3d\x93\xaf\xf1\x54\xcd\x36\x17\x1c\xb9\x6b\x6a\x3c\x92\xd7\xeb\xa5\x34\xea\xf8\x08\x5f\xe3\xa0\xdc\x4e\xde\x8a\x45\x1d\xce\xc2\xc4\xcd\xf3\xe4\xc0\x4e\x58\x4e\xaa\x4f\x41\x51\x2e\xe7\xad\x78\xaa\xae\xde\x69\x5d\x59\x41\x01\x7c\x42\xc0\xbd\xa6\x92\x17\xb8\x3f\x43\x94\xe9\xb5\x6a\x16\xba\x59\xe1\x71\x3a\xfb\x31\x9e\x02\x3c\xe7\xd7\x78\x07\x98\xbc\xbe\x97\x48\x0e\x8b\x9b\xa7\xa7\xe2\xf5\xc6\x2c\xfd\x79\x23\x3c\xac\xc6\x08\x25\x9b\x6a\x87\xf6\x2d\x75\x05\xec\x3a\x15\x31\xad\x9c\x5f\x8a\x55\x69\x10\x0b\x27\xb8\xe2\x3c\xdd\x34\x20\x2d\x5a\x91\x0a\x54\xdb\x8e\x32\x5d\xd6\x7a\xcb\x84\x40\xd7\x90\x15\x3d\x48\x72\xf1\x46\x3c\x97\x75\x04\x08\x15\xf7\xcf\x01\xc1\x92\xd8\x7d\x97\xe2\x3d\x6e\xae\xac\xc5\x02\x08\x42\xb2\x2e\x27\x84\xef\x22\x17\x2d\x18\x35\xed\x62\x94\xf5\x45\xf0\x94\x0e\x04\x5b\x9c\x83\x92\x8e\xfe\xf5\x9a\xd6\xa2\x7b\x4b\x7d\x55\x24\x17\x94\x75\xfe\xdc\xab\xeb\xc5\x5e\x41\x1e\x70\x90\x92\xcd\xf6\x26\xcb\x04\x4a\xe7\x45\x4d\x6b\x54\xb6\xa5\xac\x50\xe4\xdd\x2a\xb1\x82\x59\x85\x6c\x28\xa4\x51\x8a\xd6\x33\xd8\x1d\xf3\x1a\xa7\x7d\xec\x36\x7f\x18\x99\xb5\xaa\xab\x75\xea\x34\x34\xc0\x93\x0b\xaf\x84\xf5\x0b\xc7\xe1\xfc\x3a\xde\x92\xd7\xb3\x9e\x9c\x25\x4b\x28\x21\x88\x7a\xa5\x5c\x0e\x98\x34\x2c\xd8\x1f\x41\x7a\x96\xe1\xc1\x8c\x00\x80\x92\x31\x63\x73\x2f\x6f\xb8\x14\xd9\x07\x33\xe9\x29\xa3\x9e\x3b\xf0\xb6\xc7\xfc\x2d\xf9\x07\x64\xee\x4a\x6f\xab\x7c\x44\x13\x76\x63\x32\x6a\xb2\x5b\x6a\x38\x10\x28\x30\x54\x50\xa6\x32\xd2\x55\xb9\xb4\xe1\xd9\xe7\xda\x65\xd3\x44\xb3\x1f\x92\xe2\x3d\x8c\x33\xf3\x56\xbb\xcf\x47\x14\x31\x6e\x4f\x3a\x34\x92\x06\x45\x30\x4f\x5a\x98\x27\xdf\x41\xac\x86\x27\x32\xec\xb6\x77\xa7\xe6\xce\x36\x52\xb4\x61\xa2\x13\x6c\x98\xee\xd8\xdc\xa2\xd4\xe3\xc9\x19\xf3\xa5\xe8\xa3\x4d\x67\xcc\x30\x8d\xd3\xbc\x77\x1d\x76\x22\x23\x57\x73\xe2\xf9\xc3\xed\xf2\x1c\x89\xbf\xc7\xf1\xcf\x92\xdd\x38\x3d\x15\x2f\x91\xe3\x20\xee\xde\x4a\x00\xb0\x6f\x0c\x05\x98\x00\xcb\xb6\x8a\xf0\x0e\x88\x89\x25\xff\x88\x7b\x11\x83\xfc\x46\xe1\x8b\xb1\x69\x42\x88\xff\x15\x3c\xa1\xb2\x70\x0d\x79\x60\x96\xf8\xc5\xe1\x86\x96\xce\x49\xf6\x45\x61\x70\x63\x98\x25\x5f\x63\x4d\x0f\x91\x1f\x28\x64\x5d\xc3\x6b\x89\xef\x21\x90\x73\x12\x92\x12\x60\x82\x46\xcd\x65\x35\xdf\x54\xa8\xec\x9e\x66\x04\x36\xf6\x3e\x8f\xbe\x97\xe4\x98\x20\x3a\x98\x1d\xe3\x58\x39\x67\xf4\x7b\xa3\x75\xdb\x23\x15\x70\xa9\x5e\xeb\xee\x8d\x4a\x7d\x9d\x40\xb8\xd7\xba\x75\xaf\x77\x67\x72\xb6\xcf\x77\x7a\xfd\x27\x75\xa5\x9c\xe7\x3f\xfa\xc5\x75\x9f\xae\x6e\x33\xd9\x1f\x51\x47\x60\x7f\x8f\x19\x7a\xa6\xee\x89\xbe\x46\x9a\x04\x24\xa2\xb2\xda\xca\x9d\xb1\xe2\x94\x51\xed\xf5\x06\x3a\x77\x23\xe4\xb4\x12\x2f\x6c\xc7\xb6\xda\xdf\x82\x0f\x9b\xc9\xbc\x6d\xf8\xfc\xb8\xfd\xba\x1e\xcb\x3d\x62\xc7\x03\x8d\xc4\x0e\xff\xdf\x8d\xda\x64\x88\x32\xfb\x18\x76\x9e\xd7\xe8\xc6\x3d\x39\x90\x5a\x67\x02\xee\x51\x69\xc0\xe7\x33\x56\xc7\x50\x79\x70\x76\x33\xe6\xbb\xd0\x49\xff\x22\xb0\x91\xb8\x50\x3e\xfc\xef\x20\x43\xe4\x50\x8d\x68\x84\xe7\xe7\xd8\x77\xca\x13\xa3\x49\x04\x87\x95\x98\x42\x02\x1a\x23\xa4\x20\x94\x5e\x25\xe2\x80\x52\xd1\xc2\xc0\x9b\xab\x35\xb2\x92\xa0\x52\x07\x43\xa0\x32\xde\xa8\x00\xa8\xa9\x4c\x17\xd1\xb1\x91\x73\xdc\xe5\xdb\x54\x55\x80\xed\x1f\x59\x5a\x41\xcb\x30\xa5\x7f\xf3\xbd\x19\x45\x14\x70\x61\xb3\x7e\x4c\x5d\x8b\x14\x9e\x99\x07\x0f\xf0\x52\xa0\x5d\x5f\xd9\x7f\x67\x5c\x0c\xd2\xb3\xdb\xdd\xa8\x2e\x44\x62\x6a\x01\xc2\x75\x46\x02\x3e\x53\x2c\x90\x8e\x63\x6e\x07\x1f\x4c\x20\x14\x6d\x03\xd2\x29\x0d\x6e\xca\xec\xa2\x80\x05\x16\xbc\x11\x5c\xd0\x0f\x58\x36\xec\x38\x78\x7b\x33\x1a\xd0\x32\x20\xdc\xb9\xe9\xa2\xe3\x64\x69\x48\xb7\x59\x5e\xa9\x6a\x17\xce\x19\x7a\x1a\x4a\x13\x9f\xa2\xd6\x75\x6b\xe5\x4b\xfe\xe9\x9d\x37\xd9\xce\x4a\x88\xca\x91\x62\x29\xe7\x97\x53\x0c\x3d\x91\x94\x3f\x7e\xa9\x4d\x8b\xdb\x09\xf1\x39\xe0\x56\x0e\xbb\xef\xc3\x0c\xa1\x31\x92\xa7\x01\xed\xea\xa8\xf1\x06\xb5\x6a\x87\x09\x70\xbd\x00\x8e\x27\x06\x6d\xab\x5b\xb9\x13\xa5\x01\x69\x25\x86\xfe\xb5\xdb\x07\x51\x36\x0e\xef\x1d\xc6\xb4\xb2\xdc\x01\x1c\x75\x5c\x55\x32\xdc\xce\xf5\x6a\x85\xc9\x32\xa3\x5d\x71\x48\xab\x04\xf1\x53\x1a\xb1\x25\x24\x54\x82\xfd\xf1\x3d\x03\x53\xb2\x28\xeb\xe2\xe9\xb7\x2f\x21\x0e\xd1\x37\x33\xc8\x2b\xb9\x85\x38\x8b\x16\xf5\x59\x6d\x36\x0d\xa5\x35\xf5\x3b\x08\xb3\x17\x65\x0d\x76\xe7\xd2\xe0\x72\x6e\xcb\x76\x69\x29\x80\x33\x11\x47\x62\x5d\x64\xd5\xc6\x04\x04\xd0\xb0\x49\xf0\xe5\x10\x6a\xd0\x8f\x85\xce\x85\x11\x0c\x63\x0e\x0e\x41\xe1\x6b\x52\xd4\x14\x9d\xa8\xa2\x77\xb2\xb7\x63\x8d\x66\xf0\x17\x43\x02\x67\x06\x29\xf7\x5b\x7b\x3b\xb6\x25\x38\x75\xd8\x2d\x0f\x77\x87\x08\x6c\x8d\x6e\xbd\x5b\x25\xe4\x2c\xa4\x0e\x40\x09\xd8\xfe\x1d\x6c\x96\xbc\x45\x20\x1c\xe3\x69\xe6\x68\xbe\x37\x45\xdd\x70\xa4\x72\x90\xe1\xe4\x7c\xe6\x5e\xf6\x2c\x88\xc9\xbd\x63\xf6\xef\x0f\x26\x90\xaf\x7d\x22\xd7\xbf\xe1\x5b\xd7\xfb\xf0\x80\x7b\xbe\x3d\x8f\x4b\x09\xd5\x30\x34\xeb\xde\x6d\xbc\x1b\x7d\x7c\xca\x0d\xf5\x83\x89\x2b\x5b\x8f\x2a\x6c\x58\xd7\xb5\xcf\x0d\x2c\xcf\xfd\x30\xb1\x94\xc2\xd7\x07\xad\x3b\x87\xdb\x6a\x0e\xb2\x09\x89\x11\xe6\x91\xbd\xc6\x91\xfb\xac\x7a\x60\xcd\x72\xee\xc1\xdf\x2b\xa7\x5b\xa0\xd7\x0e\x9e\x4e\x1a\x92\xd0\xde\xa3\x97\x4e\xd0\xed\xa7\x4d\x09\xf7\xc0\x71\x8c\x6e\x66\xae\xe7\xfb\x01\x0b\xd3\x31\x10\xf1\x1e\x3c\x4a\xe3\x00\xff\x5e\x0d\x63\x89\xcd\xfa\x9a\x56\xac\x5b\x55\xd4\x24\xfa\x0d\xdf\x5d\x12\xe6\x89\x41\x9c\x4f\xc1\x0d\xef\x9d\xab\x62\x59\xc9\x8c\x4b\x2d\x84\x22\xc5\x76\x09\xbf\x73\x9d\x36\x52\x8c\x45\xb3\x56\xf3\x52\x56\xf8\x4a\x48\x72\xfc\x43\x84\x40\x7c\xdb\x90\xe3\xb1\xec\x8d\x7d\x1f\xa7\x8c\x1f\xb2\x2c\x85\x7f\x41\x4f\x4f\xa1\x09\x60\x41\xb6\x9a\xa5\x1f\x77\x31\xcd\x8d\x2a\x17\xa5\x72\x10\x0d\xcc\x30\x80\xe9\xd6\xb1\x74\x68\x0c\x39\xc2\x3a\x30\x57\xaa\xbe\x2a\x1b\x5d\xaf\xbc\xa3\x1c\x60\xad\x23\x63\x3a\xb7\x92\x8d\x70\x7c\x83\x3d\x08\xc8\x3b\x85\xe6\xa4\xbd\x1e\x06\xa2\x80\xe6\xc0\xe4\xb9\xa7\xcf\x83\x4f\x52\xd8\x15\xc4\x62\x35\xf2\x4a\x35\xa0\x79\x29\xfd\x5b\x98\x6e\x9c\xcf\x68\xc1\x0e\x59\xb8\x6d\x0f\x1e\x0c\x6d\x95\x2f\x77\xd2\x05\x25\x07\x50\x18\x88\xbe\xf2\x79\xfe\x73\xdb\x02\x80\xce\x14\x99\x4d\x5c\x84\x6e\x22\x50\x0b\x88\x2d\x99\x70\x35\x8a\xf3\xbd\xc5\x80\x74\x68\x8b\x5c\xb6\xd1\x1a\x0a\x0f\x67\x8f\x07\x50\xc4\xd5\xd1\x6c\xde\xd8\xf2\xd1\x09\x1f\xa9\xad\x3d\x3d\x15\x4f\x00\x1e\xc7\xef\x2e\xba\x6f\xc3\x20\x95\xa2\x68\x2c\x16\xdd\xdf\x28\xa1\x17\x0b\x33\x6f\x94\xaa\x4f\x97\x65\x51\x38\x4f\x25\x74\x87\xe8\xbe\x82\x40\xe4\x5e\x81\xd2\xeb\xc1\x03\x71\xbf\xeb\x6d\xee\x37\x28\xe3\x2b\xde\xb9\x50\xd1\x2e\x3d\xd5\xdb\xfa\x61\xa8\x13\x8d\xb4\x6f\xf1\xe2\xb1\xd1\xc8\xce\x42\x9b\xdf\x30\x0a\x37\xd7\x2b\x05\x56\x6b\x7f\xa0\xf1\x64\x42\x62\xa3\x69\x4c\x93\xd8\x29\xbc\x77\x0b\x8a\xc8\xbb\xb6\x7b\xba\xbb\xb6\xcf\x2d\xe4\x6e\xb8\x92\x3b\x67\x1d\xf6\x73\x2e\x9f\x0e\x5f\x66\x78\x5e\x51\x66\x6d\xb5\x7d\x11\xc1\x67\x21\xa4\x99\x53\xcd\xaa\xac\x65\x35\xa5\xbc\x58\xf4\x64\xce\xf5\x6a\x4d\x28\xc8\xa6\x55\x6b\xd7\x52\xb9\x5a\xa9\xa2\x94\xad\x65\x32\xc0\xaa\x1a\xb1\xb0\xee\x34\x25\xae\x4b\x56\xb4\x79\x51\x17\x8a\xba\x6a\xd5\x0d\x39\xd3\x6e\x4c\x56\x7f\xd2\x27\xde\x2d\xf3\x94\x26\x16\x0b\xb5\xda\xf0\x06\xac\x50\x4a\xbd\x23\x86\x6a\x9c\x9f\xd2\x7a\xec\xa1\xfa\xa9\x78\x99\x10\x96\x54\x64\xb8\xb1\x07\x7e\x51\x4f\xd7\x8d\x6e\x35\xb0\xef\x01\x19\x83\xff\x4c\x06\x99\x3d\x69\xf4\xfc\x8e\x41\x54\x25\x0c\xf6\x09\xff\x29\x3f\x41\xc1\x32\xe4\xd1\x61\xf8\xec\xdd\x52\x89\xdf\xff\xca\x88\xd3\xaf\xd8\x31\x90\xeb\xb5\x92\x0d\xbc\xfc\xc8\x08\xb8\x68\xcf\x95\x6a\x97\xba\x40\xd0\xfb\xe0\x98\xd0\xaa\xba\xa0\x7d\x0f\xd1\x9d\xe2\x33\xf1\x6b\x71\xe4\xae\x13\x9d\x17\xc8\xdb\x02\xdc\xa5\x3d\x48\x66\x2a\x90\xef\x15\xbf\x82\xbe\xf2\x2d\x79\xd6\xf3\x68\x12\xcf\x3b\xf9\x67\x47\x02\x3e\xdc\xa1\x07\xf6\x0d\x3d\x72\xd6\x39\x6f\x9c\xbb\x32\x75\x79\x8a\x48\x07\x82\xc6\x91\x20\x8a\xe0\xaf\xdc\x41\x91\x17\xdf\x77\x70\x4e\x4f\xc5\x6b\x8a\xcb\xde\x40\x41\x40\x76\x31\x66\xb3\x5a\x03\x39\x02\xde\x2f\xc4\x51\x40\xe0\xb3\x37\x33\xe5\x9f\x5f\x40\xe4\x4a\x42\xd5\xcf\x98\xeb\xfa\xed\xf8\xd1\xdc\xa5\x27\xcd\x1d\xfb\xd2\x5c\xd7\x9b\x06\xeb\x76\x63\xab\x3a\x34\x08\x76\xde\x57\xb8\xa9\x13\xca\xb5\xfc\x20\x30\x9a\x39\xf1\x7f\xc8\x39\xf4\x1f\x72\xfa\x16\xde\xe5\x35\xdc\xf1\xa1\x33\x98\x71\x91\x75\x93\x8a\x09\x27\x8f\xaa\xcf\xbe\x39\xbe\xb4\xbd\x8e\x3d\xc8\xa8\x8e\x86\xde\x0f\xd4\x0e\x0e\x8b\xc3\x0c\xdb\xad\x95\xe1\x51\xf8\x9d\x8f\x56\x98\xaf\x35\x68\xf6\x09\xac\xc2\x4a\xf4\xf9\x69\xdf\x4a\x30\xfd\xa7\x68\x5a\x5d\x1f\xe8\x9e\x2c\x28\xe8\x01\xb1\xd0\xe2\x5c\x1c\x1d\x9d\x25\x1f\x00\x79\x9a\xde\x9f\x1e\xaf\x81\x24\xa7\xe9\xb7\xae\xc6\x71\x14\xe7\x0f\x59\xa5\xdc\xa7\x14\x69\x02\xba\xff\xf5\xb9\x38\xfa\xb7\xfa\xdf\xea\x20\xdc\x44\xef\x91\x95\xa5\xff\x7a\x24\x7e\xcd\x86\xf4\x6b\x71\xf4\xd7\xe9\x51\x8c\x26\x90\x8c\x9f\x76\xf1\x5f\x00\x4f\x31\xd4\xec\xba\xdb\x23\xf2\xf6\x8b\xa7\xb0\xbc\x9d\x65\x88\xb1\xbc\xb3\x55\xdf\x76\x70\xbd\xed\x94\xd9\xa7\x74\xd2\xd1\xd0\x58\xb9\xa9\x65\xa7\xdc\xfc\x1e\xd9\x19\xf3\x8f\x55\x59\xab\x57\x80\xc7\x93\x43\x51\x10\xde\xc7\xae\x27\xf2\xf9\xcf\xa1\xd7\xbf\xe4\x06\xb4\xaf\x4e\x27\x07\xad\xe8\xb2\x1b\x47\xbe\x76\xe0\x83\xfd\x49\xe7\xd7\xe2\xa2\xbc\x82\x38\xbd\x85\x99\x62\xe6\xdc\xc7\x6d\x6b\x05\x6f\xc4\x34\x23\xbd\x04\x46\xbf\x2d\x90\x7a\x2f\x64\x59\x4d\x7f\x65\x20\x97\xae\x3d\x34\x93\x91\x87\x32\x4a\xb4\x9b\xa4\xd9\xed\xa6\xab\x09\x29\xa3\x46\xcb\x83\x09\x8d\x1e\x92\x51\xd6\x91\x57\xe1\x28\xb5\x7c\xd6\x0d\x96\x83\x3a\x5f\x4f\x96\xf0\x2a\x35\x59\x55\xff\x40\x11\x3e\x30\xdb\xbe\xe8\x1e\x5c\x0a\xc7\x43\x86\xcc\x2b\xf9\xe8\x1e\xa7\xdc\x86\x6a\x7f\x07\xba\xed\xbe\x78\x24\xbe\x24\xe3\x63\x91\x64\x2a\xcb\xe7\x0f\x52\x76\xe5\xbc\xf9\xf4\xfb\xa5\xc2\x53\x02\xcb\xb0\x81\x50\xdd\xc4\xc9\xd7\x21\x32\x39\xcf\x87\x57\xba\x50\x6e\x77\x43\x73\x9a\xe9\xbd\xa6\xe2\x9d\x03\x91\x2e\x5b\xf0\x4d\xb4\x63\x62\xec\xe0\x5d\xab\xa5\xed\x4a\x30\xad\xb4\x13\x29\xac\x20\xb6\xd0\x55\xa5\xb7\xa0\x1f\x05\x2e\x08\x22\x14\x17\x23\xe2\xca\x7d\x62\x7b\xd7\x5a\x58\x8c\x56\x93\x99\x36\xac\xc0\x08\x5d\x50\x9f\xeb\xc4\xf5\x4d\xb2\xbe\x89\x1f\x27\x48\x78\x60\x02\xd7\x89\x67\xbd\xc1\xe8\xaf\x39\xa2\xbb\x5c\xd6\x7b\xe3\xd4\x65\x70\x8b\xcf\xc2\x01\x2d\x8d\x97\xa1\x5a\x79\xa9\x84\x6c\x66\x65\xdb\xc8\x66\x07\x0e\x41\xe4\x5b\x38\x07\x42\x66\x76\xf5\x7c\xd9\xe8\x5a\x6f\x4c\xb5\x43\xcf\xca\x99\xba\x28\x6b\xd7\x98\x92\x17\xca\x4a\x81\x44\xbb\xb7\x74\xd2\xb3\x5e\x00\x12\x30\x5d\x29\xe8\x1d\xe6\x32\x1d\x50\x94\x46\x5e\x3e\xb9\xd7\x11\x11\x14\x6f\xd1\x0a\x9c\xf7\x9e\xeb\x1b\x56\xc6\xa3\xee\x97\xa0\xda\x71\x41\xb5\x07\x3f\xbd\xcb\x31\x39\xf0\x7f\xd2\xaf\xef\x4f\x2c\x1a\x78\xc4\xcb\x61\x25\x7d\xb8\x61\x08\xcc\xe6\xec\xa0\xcc\xd3\x90\x72\x53\xae\xed\x12\xc7\xf6\xa8\x82\x69\x79\x42\x73\xf6\x64\xca\x96\x3c\xad\x18\xee\x02\x37\xc1\xa1\xc7\x58\xc8\x09\x4c\xbe\x6a\x01\x66\x39\x34\xb7\xa8\xf4\xd6\xd3\xb1\x42\x47\x9d\x4e\x63\x2a\x87\x80\xcd\x3e\x29\xb6\xd6\xde\x71\x25\x34\xe7\xbf\xd0\xe9\x01\xe8\x08\x83\x00\xde\x52\x7c\x46\x0b\xf5\x99\xfb\x21\xe4\xb1\x9f\xa6\xec\xce\x13\x17\x7e\xb9\xa9\xcb\xc5\x0e\xfd\xd3\x4b\x6a\x69\x49\x5a\x2e\xf4\xdd\xd2\xcd\xe5\x3e\x18\x8f\x1f\x11\x51\xe0\xf0\x10\xef\xe4\x65\xbc\x99\x71\xed\x1a\xdd\x8f\xb6\xb3\x9d\xfe\x8f\x18\xee\x66\x63\xfc\x18\x29\x0b\x27\x07\x10\x14\x8f\x04\x81\x2c\x2d\x42\xaa\x46\xfa\xcd\x5d\x90\x4a\xb5\x1e\xbd\x7e\x91\x64\x68\x28\x34\xbf\x45\xdc\x97\x2f\xf8\x7f\x5a\x52\x5b\x49\xe3\x7c\xed\x1c\x6b\x8b\xf8\xec\x62\xae\x9b\x46\x99\xb5\xae\x0b\x86\x1a\xc3\xf1\x66\x1a\x55\x1f\x99\x7c\x53\x9c\x32\xdf\xe7\x88\x93\x50\x1a\xa7\xdb\x0d\x41\xee\x14\xf1\xa8\xfc\xec\xb7\x54\x33\x1f\x92\x3a\xd8\xfe\xbb\x4d\xa3\xf5\x39\x34\x9f\x2f\x15\x0f\x21\x94\x81\x7c\xc5\xfb\x07\xc3\xc5\xfb\x7c\x43\xbe\x76\xf8\x29\xa5\xd6\x51\x52\x8d\xf3\x4c\xa2\x07\x5b\xf0\x7f\x9c\x46\x6c\xc8\xb5\x28\xb0\x03\xeb\x93\xf5\x5c\x55\xb6\xa4\xbd\x80\x7d\x81\x98\x41\x82\xf2\x6f\x5b\x59\x28\x60\x04\x66\x4a\xc8\x19\x00\xcc\x07\x66\x00\x15\xf2\xa9\x73\x00\x3c\x83\xb5\x76\x0d\x42\x12\x77\x74\x09\xd7\xa2\xd0\x2c\x3f\x7f\x36\xaf\xa9\x30\x6a\x2d\xc9\x65\x52\x2f\x42\xc6\xff\xd3\x53\xbc\x0f\x47\x46\x90\xad\x7f\x07\x07\xd1\x63\x2d\xd9\xae\x77\xaa\x15\x0f\x13\x1d\xbf\x73\x58\x2d\xb4\xa5\x8c\x95\x6e\x7d\x7b\x74\x05\xc0\x09\x19\x06\x08\x15\x85\xac\x77\x5b\xb9\x9b\x8a\x6f\x69\x74\xc8\x9d\xd8\xdb\xc4\x86\x46\x7c\x91\x65\x50\x5d\x73\x7e\x59\xd0\x9b\xb1\xb3\x2a\xe0\xa7\x18\x56\xc3\x03\xed\xb8\xd9\x00\x6c\xbf\x0f\x1c\xca\xe8\x5b\x5d\xc9\x6f\x17\xfe\x79\xff\xfd\xb9\xaf\x0f\xa1\x1d\x2c\xd6\x2f\x76\xae\x84\x27\x95\xb9\xe7\x92\x2b\x0f\x03\x26\x72\x68\x57\xb0\x79\x68\x08\x99\x29\x55\x47\xcd\x91\xd3\xb2\x2a\xf8\x13\xaa\x62\x7a\xb3\x13\x17\x0a\x79\x1e\x60\xd4\xdb\x46\xd6\x66\xa1\x9a\x46\x15\x62\xb3\x9e\x86\xe6\x38\x37\xc0\x18\xb3\x90\x66\x66\x48\x4e\x83\x16\x44\x9e\xb0\xa6\x84\x9c\x67\x02\x81\x7a\x9f\xc2\x5f\x3b\x6e\x1b\xa7\xa7\x8e\x5b\x19\x8d\x6b\x7a\x0d\xef\x0b\x7f\x93\xff\xa4\xb7\xaf\x69\xff\x6e\xf9\x06\x53\x36\x82\xc8\x71\x55\xb4\xf2\xc2\xe0\xf1\x84\x24\x1e\x2e\x49\x8f\xac\xaa\x8e\x7b\xea\xc9\xd7\xae\xbd\xb7\x4a\x89\xd7\x6f\xc4\xff\xfc\xdd\xff\xfd\x1b\x51\x94\x66\xbe\x31\x90\x94\x62\xa1\xbd\xd5\x1b\x4a\x3a\x84\xea\xae\x9d\x25\xd0\x5e\x70\x6a\x73\x11\x3b\x01\xc6\x78\x74\x1c\x8f\x48\xe1\x9e\x07\x31\xaf\x0f\x30\x99\xe5\x9a\x0d\xf9\x82\xba\x23\xbd\x25\xf1\x2d\xe9\xf8\x53\x42\x84\x01\x9a\x2b\x80\xd4\x45\xc1\x09\x0e\xd0\xcb\x6f\xd3\x1f\xf5\x16\x48\x12\x5d\x63\xcb\x80\x7e\x0d\x3f\x96\xa4\xf1\x46\x0d\x39\x80\x4b\xd9\xa3\x5d\x7c\xcd\xcf\x6d\xe4\x6a\x92\xc6\x21\x70\x3e\xe9\x14\xa3\x89\xec\xb9\x41\x20\x43\x1d\xd8\xb0\x53\x27\xd7\x05\x45\x5a\xf0\x5a\x19\xe7\x63\x43\x47\x65\x58\x54\x09\xe5\x33\xde\x31\x43\xee\xeb\xb6\xde\x5b\x1e\x03\x35\x14\xb4\x45\xfd\xb0\x00\x2e\x70\x36\xb3\x0f\x8b\x0b\xe7\x50\x71\x64\x96\x73\xee\x0f\x24\xd7\x49\x83\x58\x0c\x92\xba\x18\x05\x51\x1f\x9e\xce\x1b\x72\xb5\x04\x21\xb0\x1b\x14\x36\xed\x12\x0f\x87\x28\x7b\x3d\x0d\x44\xe6\x61\x49\xdd\xe1\xce\xcf\xc5\x2b\x0d\x98\xb5\x5d\xa9\x31\x29\xfb\xd5\x60\x5f\x5d\xe1\x71\x0c\xc1\x8b\x84\xc6\xd1\x64\x25\xef\x11\xf5\x28\x61\xd5\x6e\xd1\x7b\x2a\x22\x16\x83\x30\xed\xd4\xf5\xe1\xa8\x4c\xa3\xc8\x5c\xd4\xfa\x8d\x90\x4c\x3a\xe4\x2f\x26\xd3\x51\x47\xd7\x8c\xdc\xec\x74\xb1\x6f\x42\x37\x89\xbc\xe8\x74\xf6\x4e\x7d\x18\xea\x67\xd0\x15\x32\xde\x0b\x59\x55\xf8\xc2\x36\x10\xd7\x1e\x1a\x8d\x22\xd4\x1a\x05\x52\x3d\x5d\x7b\x74\xf3\x95\x17\x4e\xb0\xf2\x30\x24\xb6\x85\xde\x88\x26\x72\x96\xe1\xa6\x39\x66\xf0\x18\x48\x60\xe0\xf2\x5a\xe2\x60\x9c\xbb\x4b\xc8\xbc\xc4\xa6\xb2\xf7\x54\xdd\xc0\x30\x18\xad\x5b\x92\xfd\x32\x5a\xb6\xc7\x3e\xeb\x59\xf0\xe0\x32\xa8\x02\xa6\x00\xbe\xa5\xae\x0a\x2b\x38\x30\xe6\x5b\x34\x9b\x3a\x49\x43\xe6\x1b\x84\xd4\x0d\xba\x56\xdc\xcb\x72\x9a\x4e\x30\xb0\x7e\x03\xcf\x7e\xb4\x18\x37\xd3\x03\xc7\x54\x83\xb0\x13\xfb\x48\xc5\x3e\x68\x45\xd7\x58\xa1\x16\x72\x53\xb1\x66\xba\xda\xca\xef\x6a\x2b\x0d\xd5\x62\x53\x63\xd4\x24\x4a\x64\xf2\xe2\xb6\xf4\x92\x7d\x96\x65\x78\xad\x9e\xcb\xb2\x1a\x96\x53\xaf\x8b\xad\x04\x2f\x6d\xab\x31\x9e\xc0\x9e\x93\x8d\x59\x9e\xae\xf5\x9a\x61\x19\xa0\x57\xd8\xf4\xb0\xd7\xe4\x0e\x79\xca\xdb\xe2\x7d\x47\x6c\x3a\xa5\xea\xc1\xb0\x2f\xda\xf4\xdb\xde\x70\xb7\x41\x8f\x8b\xc2\xa7\xbe\x71\x4a\x26\xb2\xec\xc8\xda\x05\x9f\x00\xc6\x29\x94\x20\xed\x29\xf9\x46\xaf\xca\x16\xc9\x60\x8e\x2b\x8b\x3c\x20\x9f\x35\x0d\xb7\x7d\x3a\x4a\xbb\x55\x65\x53\x50\x68\xa5\x43\x5e\x2d\xb4\xf8\x0c\x03\x2b\x3f\xc3\xe3\xfe\xdf\xff\xf9\x5f\x2c\x38\x7d\x01\x87\xd2\xc5\x9c\x9e\x9e\x0a\xbd\x69\x9c\x86\x0b\x9d\x46\xa6\xe2\x9b\xa0\x7d\xae\xb5\xa8\x74\x7d\xe1\xfc\x9b\xa5\xe5\xa7\x49\x49\xf1\x59\x40\xd7\x75\x6d\x41\xb4\x6e\xa9\x6b\x33\xf9\x8c\x71\x8b\x3e\x54\xa4\x0b\x42\xdc\x6a\xb1\x92\x97\x4a\x80\x2c\xed\xc3\x7d\x3d\x97\xd8\x22\x4c\xec\x94\x18\xf3\xe7\x65\x6d\x4f\xfb\x4c\xb5\xad\x6a\x20\x22\x19\x5c\x6e\x69\x8d\x4b\x33\x11\x6b\xd5\x2c\xe5\xda\xb8\x75\x96\xa0\x79\x70\xcd\x5d\xa8\x5a\x35\xb2\x12\xfa\xca\x96\xda\x54\x76\x12\xb8\x2d\xd0\x86\xf7\x43\x3c\xc8\xd6\xeb\xf3\x4e\xe4\x22\x71\xb2\x65\xef\x77\x33\x7c\xec\x69\x3b\x2a\xdd\x31\x2e\xfc\x1d\xb1\xb5\x49\x3c\xbf\xd3\x1d\x4d\x28\xe0\xe8\x02\x94\x55\x33\x84\x86\x5f\xad\x37\x2d\x7a\x32\x34\x41\x5b\x13\x00\x59\x5c\x7b\xad\x16\x45\xa3\xd7\x50\x8c\xe5\xeb\xcc\x3a\x15\xc7\x7a\xd7\xb0\x63\x49\xb1\x48\xa5\xc9\x62\x10\x4f\x4f\xc5\x77\x35\x86\x87\xe7\x60\xa8\x43\x02\x27\xf6\x96\x7b\xec\x74\xdb\x0e\xb4\x92\xf3\x73\xf0\x23\xb9\x5b\x88\xf8\xb3\xde\x43\xe3\x13\xdc\x47\x0f\x40\x0c\xfb\x31\x0a\xdc\x29\x7b\x8e\x53\x41\x36\x86\xe3\xd9\x53\xc9\x49\xa5\x31\xea\x4f\x12\x6e\xb4\x5f\x0b\x45\x65\x70\x42\x5e\x98\x7c\x14\xfe\x3a\x09\x5f\xc2\xc3\xfd\x28\xfd\xc1\x36\x77\x76\xef\xd3\x59\x9a\xf0\xe4\x09\x46\xba\xa8\xeb\xe5\x3c\x09\xa9\x4c\x10\xf4\x9c\x25\x5c\xa0\x8c\x22\xf1\xef\x3e\x6b\x04\xfc\x6a\x19\xf8\xbe\x1a\xfc\x9b\x4f\x58\x01\xb6\xc4\x17\xc8\x87\xfb\x44\x36\x58\xab\xfb\xcd\xd5\x5a\x94\xb5\xac\xca\x7f\x57\xfc\x1b\x19\x9a\xb1\x6a\x4f\x01\x9f\xbd\xa4\x51\x6b\xd9\x28\x0f\x4a\x47\xb5\xa2\x9f\x7d\x02\x8b\x8d\x4b\x2b\xed\x8a\xb9\x5f\x7c\x6b\xaa\x31\xa5\x69\x55\x34\x65\xf6\xe3\x19\xad\xe7\x85\x02\x1e\x63\x28\x6d\x4a\xae\x88\xef\x46\xaf\x07\xd2\xb4\x44\x1f\x5d\x95\x0b\xd5\xf6\x57\x89\x3f\x66\x7a\xc9\xe6\x75\x49\x3e\xbb\xb9\xd1\xd2\xbd\xd3\x18\x7c\x06\xc2\xdc\x50\x3a\x95\xa1\xf2\xc9\x2e\x45\x65\x92\xf3\x35\xaa\xdd\xdc\xb9\xb3\xf3\xd8\x9b\x42\xa6\x53\xe8\xec\x5e\x07\xc2\x9a\x50\x75\xf3\x1a\x63\xcb\x20\x51\x7e\x68\x8c\x58\x44\x53\x72\xed\xa1\xff\xd0\xea\x85\x5c\x14\xe2\xfc\x49\x06\xca\x51\xd6\xad\x37\xe2\xc8\x5a\x60\x57\x8f\xeb\xc2\x97\xd8\x1f\xae\x82\x75\x32\x4a\x3a\x0a\x4b\xcd\x8f\x7b\xa8\x45\x02\xbd\x8e\x9b\xc3\xab\xfa\xb8\xaa\x50\xbc\x74\xb6\xd5\x8e\x36\x36\x72\x52\x45\x0f\xaa\x61\xfa\x0d\xee\x14\x11\x8c\xa8\xfd\xd7\x9e\x4c\x52\x4e\x8f\x4b\x26\x3e\xe8\xa8\xeb\x26\xef\x9a\x8e\xd2\xd3\x07\x4d\xfd\xc7\x8f\xa2\xf3\x15\xa2\xa2\x73\x1f\x50\x22\x4d\xc1\x10\x93\xe0\x3d\x54\xf3\x93\xa7\x34\xb0\xb0\x14\xe8\xeb\xba\xf4\x31\xb3\x47\x29\xc2\x49\x67\xac\x89\x18\xdf\xb5\xee\x1a\x48\xc1\x44\x95\x76\xeb\x0e\x66\x8a\x6f\x31\x30\x82\x1d\x1f\x1e\xff\x39\x5a\xef\x3a\x4a\x44\x49\xbb\x18\xca\x86\x4f\x2e\x13\x43\x6a\x43\x66\xdb\x12\xf2\x7c\x65\xfa\x77\x43\xe4\xbd\x33\x67\x9a\xcc\xa7\xfc\x61\xe3\xcb\x92\x33\x21\xb3\x29\x84\xf6\xd2\x41\xf3\xd1\x76\x96\xa3\x5b\x8d\x2f\x4b\x92\xe4\xbe\x1b\x4d\x7a\x05\xea\x9d\x77\x9a\xeb\xb3\xae\xef\xfc\x3d\x1f\xeb\xaf\x7b\x1f\x4a\xe6\x1c\xab\x08\xc6\x0e\x03\xe0\x75\x75\x85\x62\x69\xad\xb7\x77\xe0\x43\xe5\x08\x1c\xa4\x6e\x84\xd0\x5c\xef\xf4\x6b\x87\x07\xde\x6c\xc4\xd0\x14\x53\xf1\x4a\x6f\xb9\xe5\x93\xbc\xd9\x8c\x65\x55\x8b\x04\xf2\xf1\x45\x2b\xb6\x6e\x1a\x75\x39\x57\x2c\x26\x72\xb5\xa9\xda\x52\x98\x56\x5e\x50\x2f\x8d\x5a\x5b\x19\x11\x50\x9d\xec\x2c\x5c\x4b\x06\x52\x1e\xf3\x0c\xb3\xba\x11\xb2\x15\x76\x56\xad\x68\xad\xcc\x00\xf5\x7d\x5e\x9f\x1a\x93\xcf\xeb\x5a\x99\xa9\x78\xe2\xcc\x45\x5e\x40\xb0\x52\x6f\xa3\xfe\xb6\x41\x4c\xb6\xa2\x28\x29\x66\x68\x51\xaa\xaa\x48\x31\x9a\xb6\x12\x71\x08\x20\x05\x91\x0e\xaf\x88\x9f\xe7\x5b\x07\x0b\xe5\x5a\xa4\xde\x51\x0c\x6d\x02\x9a\xf5\x2b\xdd\xaa\x47\xb1\x83\x14\x30\x31\xa8\x0e\x90\x55\xab\x1a\x08\x27\x46\x3c\x8b\x17\xd4\x7f\xbb\x2c\x6b\x70\xb5\xb6\xab\x6d\x44\x78\x8b\x98\x5e\x13\xd7\x10\xc6\x60\x45\xec\x85\x6e\x84\xba\x52\xcd\x8e\xa1\x9d\xf5\x6a\x53\xf9\x71\x0f\xe7\xe0\x9b\x4d\x09\xd8\xb8\x2c\xff\xaf\x49\x76\xd6\x92\x3d\xd9\xd0\x08\x00\xf6\x01\xc5\xe9\x56\x37\x76\x7f\xf4\x5a\xfe\x6d\xa3\xc4\x52\x55\x96\x09\x83\x33\x2a\x9e\x44\x70\x04\x98\x54\x02\x1f\xdc\x73\xf1\x67\xba\xb5\xa3\x1f\xb1\x24\x02\xda\x9e\x80\x29\xad\x79\x37\xf4\x19\xbe\xae\xbb\x50\x3d\x31\x8c\x3c\x05\xad\x52\x8f\x3c\x22\xb9\x93\xd9\x74\x18\xb7\x66\x4e\xae\x4b\xbd\x12\xe5\x41\xb9\x81\xb2\xf9\xab\x47\x3a\x97\x1d\x64\x8f\xf7\x6b\xef\x1d\xc9\xd0\x2f\xaa\x8f\x81\xc0\xe0\x4f\x5d\x57\x3b\xe7\x1d\x62\xef\xf7\x9a\xb2\x3d\xe3\x3d\xb2\x94\x83\x12\xcb\xce\x36\xad\x27\x1b\x8d\x9a\x6f\x1a\x63\x2f\xd9\xb6\x16\x65\x70\x46\xe1\xb8\x79\x0b\xd0\xee\x50\x8e\x27\x07\x28\x80\x70\x68\xd3\x3d\x0c\x0c\x7b\x04\xef\x84\xff\xe0\xaf\x5a\x57\x42\xf2\xcb\x86\x2f\x8f\x47\x61\xdf\xc7\x4f\xe4\x99\x18\x96\xc4\x0a\xe8\xe6\x1a\x4a\x38\x74\x95\xd6\xe1\xe2\x45\xd4\x8a\xa0\x62\x22\x3b\x80\x5b\x6a\x96\x83\xcb\x65\x5c\x23\x04\xf3\x0b\xd5\x72\x1f\x50\x00\x79\x51\x72\xbe\x74\x09\xc2\x22\x58\x3a\x70\x9b\xc3\xa1\x84\xb4\x7c\x3f\x15\xee\xc6\x75\xbd\x87\x21\x89\xd9\x91\x5f\x58\x23\xce\x1a\x05\xb0\xd8\x54\x14\x0d\x8e\xd7\x69\x99\x10\x1c\xdc\x57\xe6\x1d\x8a\xc0\xe1\xb3\x5d\x44\x27\xcb\x73\xdb\xbc\xaa\xe5\xac\x52\x2f\xe1\x4b\x7d\x11\x32\x30\x47\x9e\xd2\x2f\x9d\x5a\x60\xa5\x0b\x77\xd6\xf3\x63\x0e\xfa\x97\xfe\x3d\x80\x37\x5a\xaf\xdd\xc2\x9e\x65\x1a\x0c\x13\x64\x0a\x9d\x61\xb8\xda\xd7\x72\x57\x69\x7b\xc7\x10\xbd\x47\x57\x05\x65\x2a\xa9\xd5\x96\xfe\xd6\x90\xd1\x83\xfc\x62\x50\x48\x4e\x46\x86\x8f\xee\xbb\xdd\xda\xbd\xf9\x6b\x35\x2f\x17\xe5\xdc\xa3\xf1\x38\xe3\x46\x88\x7c\xf6\xd5\x13\xe2\x18\x43\x00\x47\xa3\x3c\x4b\xa8\x4e\xf0\xed\x10\x6b\x2c\x21\xca\xba\x28\xe7\xb2\x75\x90\x94\x1e\xb4\x50\x52\xbc\x83\x7d\xfc\x4b\xf2\xb7\xe3\xad\x41\x91\x5a\x6d\x31\xe4\x54\x81\xf0\x4b\xf9\x3f\x4d\x90\xc6\xa7\xe2\x31\x11\x7c\xb0\x50\x00\xaf\x54\x23\x5e\x24\x98\x47\xbe\x67\xc1\x66\x1c\x9e\x98\xc6\x1f\x5f\xa9\x7e\xd5\x40\xf7\x9a\x65\xb6\x9b\xce\xea\x88\x9d\xd6\x55\xf1\x0e\xf4\x78\xb5\xda\xa6\xcf\x43\x58\x48\x50\xff\x14\xe5\x62\xa1\x1a\x33\xc1\xf9\x13\x0a\x59\xdf\xec\xeb\xbd\xb3\xa7\x9e\x91\xb8\x76\x3b\xbf\xd6\x1a\xa4\xc9\x96\x3a\x92\x89\xbb\x95\x81\x7d\x01\x39\x84\x52\xfa\x17\xb1\x19\x94\xc1\x90\x05\x6d\x5c\xf7\xa6\xbf\x76\x1f\xdb\x9e\xbb\x1e\x0a\xa0\xc4\x0e\x29\x07\xd9\xbd\x07\x36\xad\xd2\x35\xd7\x95\xb2\x1e\xa7\xd1\xb7\x09\x5b\x21\x64\x4f\xfc\xfd\x83\x17\xfc\xad\x6a\xd3\xea\xf9\x52\xbc\x21\x64\x04\xe0\xcb\x3b\xbd\xaf\xbd\xe1\xc2\xbc\x59\xa7\x46\x8d\x0b\x21\xd3\xca\x5b\xec\x2d\xc7\x31\x45\x1e\xd7\x62\x53\x2f\x74\xd3\x6e\x40\xd6\x70\x21\x92\x1d\xce\x2f\x86\xb6\xb6\xbc\xdd\x56\xd3\xd9\x85\x58\x1e\xf4\x97\xb7\x34\xc7\x78\x5c\x62\xbb\x03\x9d\x86\xd8\xe4\x52\x35\x78\x32\xe5\x81\xd7\xf1\xb6\x19\x4d\x71\x0d\x66\x53\x8c\x65\x38\xc5\x5e\xa6\x53\xdc\x0e\xe3\xb9\xff\xcc\xe5\x56\xb9\x87\x27\x15\x07\xf3\xa5\xe2\xb6\x78\x53\x71\xfb\xfc\xa9\xd8\xcb\xa3\xe6\xe6\xdb\xcf\xa7\x8a\xb1\xbc\xaa\x18\xe6\x57\x45\x86\x67\x15\x19\x94\x89\x11\xbc\xab\xc8\xf0\x8c\x71\x43\x63\xf9\x58\x71\xeb\xbc\x6c\x7e\x6c\xf1\xe8\xf6\xf0\xb5\x69\xf1\x03\xf9\xdb\x74\x1f\x22\x1e\x57\x0c\xbf\xfb\x87\xf2\x8d\xa0\x68\x80\x53\xf6\x6d\xf3\x66\x1c\x74\x3e\x3d\x57\x74\xd0\xbf\xab\x5d\x7e\x91\x4e\xcd\xc8\x42\x7d\x7e\x1e\xf9\x69\xb1\x40\x20\xde\x48\xbc\x15\xc0\xd4\x12\x6b\x66\x26\xe4\x2c\xa6\x1c\x76\xb4\x0f\x32\xed\xe6\xf7\xea\xc0\x7a\x07\x84\x37\xb7\x38\x7c\xd2\xb1\x63\xf7\x59\x52\xab\x56\x5b\xf6\x0e\xf6\xbc\xa5\x81\x5a\x75\xf0\x6d\x7a\xdf\xb6\x50\x67\xc2\x3b\x39\x49\xcf\xe3\x18\x36\x28\x3e\x70\xd1\xe4\x5c\x72\x12\x0e\x45\xe0\x3b\x3b\x8b\x97\xfb\xc5\x82\x61\xc7\x77\x52\xc8\x4c\x78\xa4\x6f\x2e\xaf\x39\xc3\x3a\x15\x5c\x1f\x96\x79\x50\x8f\xd9\x20\x7a\x9d\xe2\x68\x54\x21\xbd\xaa\x37\x7c\x51\x7a\xe8\xb0\xa3\xad\x16\x66\x2b\xd7\x10\xbd\x13\x7d\x99\xde\x1e\x53\xfd\x7f\x52\x86\x8a\xc2\x80\x6a\xed\xf1\xf6\xa5\x31\x7a\x5e\x02\xeb\x00\xb6\x41\x8a\x13\x28\x14\x3d\x61\xb5\x65\xc2\xf5\x22\xf6\x3c\x71\x29\xc5\x9d\x4f\x7b\x24\xac\xd9\x06\x2e\x36\xb2\x91\x75\xab\x18\xec\xbf\x4f\x03\x07\x1b\x8e\x1a\xf6\xd5\xf4\x76\x69\x02\x53\x57\x72\x1f\x00\xd2\x4c\x66\x28\x51\x96\x88\x88\x07\x0f\xe2\xb5\xef\x79\x39\xae\x4d\x5e\xbc\x4a\x9c\x61\x97\xe1\x6d\x69\x14\x9a\x2b\x24\x00\xdc\x95\x7a\x63\x90\xaf\xe7\x75\x07\xc0\x20\x92\xb9\x9f\xed\x23\x68\x8d\x9a\xef\xe6\x15\x07\x6a\x1d\x45\xbf\x3d\x5d\xe3\x8b\xcc\x45\x8c\xe3\x64\x20\x07\x9c\xe5\x6c\xe8\x16\xdf\x9d\x49\x66\xd4\xbd\x34\x33\x71\xbf\x38\x66\x63\x76\x83\xd8\x77\x8d\x6e\x4e\x4d\x07\x36\x8c\x8d\x27\x9d\xc2\x9e\xb7\x2d\x7b\xa9\x11\x3e\x3b\x8a\xef\xa3\x04\xf5\x11\xe8\xf4\xa2\x92\x17\xe1\xa2\x5b\x29\x7c\x29\xaf\xc0\xbd\x2c\x3e\x69\x18\x4b\x7c\x05\x81\x81\xe0\x5d\x8d\x9e\x69\xb5\x6e\xc9\x3b\xad\xd5\xc2\x1e\x77\x02\xc3\x91\xf5\x0e\x40\x71\x3b\x4d\x84\x8c\x18\x28\x3b\x19\x82\x23\x0f\xa9\x57\xd8\x2c\xd4\x36\x92\x4d\xd6\x8d\x5e\xcb\x0b\xc8\xbb\xb6\xde\xca\xa6\x30\xd3\xeb\xec\x46\xf7\xf8\xdf\xc1\x73\x95\x79\xb0\xe2\x03\x37\xea\xbc\xdc\xb9\x52\x66\x94\xea\x24\xd1\xdc\x38\x50\x72\xaf\xc1\x41\xa1\x04\x99\x19\xd2\x6d\x11\xd6\x25\x51\x04\x7b\x20\xca\x68\x79\x5c\x76\xa5\xce\x15\x43\x10\xda\x8e\xdb\x51\x8c\xf4\xc7\x48\x7b\xec\x51\x14\x7b\x11\xc5\x95\x86\x48\x65\xc7\x23\xec\x98\x16\xa2\x87\x10\x4c\x32\xdd\xef\x63\x3c\x10\xff\xd9\x1d\x21\xa6\xf5\xa2\xfb\x26\x6b\xba\xac\x13\x4c\xc2\xe9\xaf\x19\x5d\x10\xff\x96\xe0\x83\xd7\x77\xc9\xdc\xab\x5b\xa9\xd6\xb0\x90\x7e\xc3\x2e\x98\x37\x19\xd3\x73\xde\x2e\x55\xd9\xc4\xa1\xc9\x74\xea\x6f\xc8\xef\xec\x55\xa0\x31\x5d\xd6\x78\x15\x5a\xaa\x31\x7b\xa5\xf5\xba\x47\x57\xf6\x4a\xa3\x8e\x4c\xaf\x15\x5a\x04\xcd\xcf\x5b\x39\x3e\x3c\xb2\x5b\xd3\xe3\x76\xbb\xd9\xbb\xd3\xb6\xca\xa8\x3d\x8e\x0c\xb1\x73\xe6\x3c\x7a\xed\x50\x91\x3f\x90\xb7\x7d\x65\xd9\xd3\x96\xa7\x06\x22\xce\xe5\x40\xb0\xf9\x6d\x3f\xd6\x7c\x5f\x53\x39\xa8\xf9\x5e\x67\x78\xd5\x97\x29\xe1\xe3\xc7\xec\x54\xd1\x93\xdd\x96\x88\xce\x7e\x88\x31\x73\x51\xa7\x64\xd6\xdf\xd4\x95\x87\xbd\xdc\x42\xee\x8f\x22\x4a\x99\xc0\xa0\xb1\x3a\x54\x93\xaf\x49\xec\xdb\x7f\x60\x78\xe6\x98\x00\xc9\x4e\x2c\x56\x5f\x14\xce\x0f\x29\xa5\x05\xee\xa1\x52\x48\x58\xd1\x4c\x84\xa9\x23\x26\xc2\x68\xc1\xe3\x81\xca\x85\xa5\xa2\xd3\x48\xde\x5d\x8f\x8e\xe8\xc9\x0e\x35\x90\xc1\x9e\x18\x9f\x1f\xe2\xde\x86\x02\xc8\xa3\xbe\xd6\x7a\x3d\x26\x67\x67\xe7\xa9\x04\x3f\x9d\xd1\x0a\x19\xc7\x34\x53\x9d\xde\x5c\xa7\xf8\x27\x94\x0b\x90\xf7\x7d\x75\xcf\x7a\x6a\x26\x19\x4f\x53\x41\x2e\xc1\xdc\xcd\x05\xa1\x0c\x25\x5b\xec\x53\xd4\x52\xea\xb8\x09\x1c\x07\xa3\x23\xd9\x94\x92\xeb\x59\xb1\xb6\x51\x2b\x59\xd6\x10\x26\x4f\x0f\x64\x57\xb9\x0a\x15\x1b\x05\xa8\x25\x9d\x8c\x74\x22\xe7\xe0\x3b\xb4\x65\xe1\x0d\x07\x37\x26\x7c\xc5\x97\x72\x7e\xb9\xa3\xa4\x71\xa0\xa5\xff\xc0\x52\xff\x0d\xe4\x10\x14\xa2\x1b\xbf\x7f\xcd\x3c\x82\x62\xc8\x17\xf7\xc1\xb9\xf8\x0f\x96\x4c\x90\xef\x5d\xf8\x7b\xe6\xd5\xbd\xf9\xdd\xda\x43\x0f\x62\x5f\xf4\x7d\x57\xe5\x66\x3c\xe9\xbe\x74\x6a\xdd\x03\xcc\x51\xf8\x7b\x19\xd4\xfb\xfb\x8e\x32\x25\xda\xf7\xae\x73\x98\x28\x4f\xac\x94\xac\x4d\x40\x43\xf7\xfa\x2e\x82\xd9\x23\x09\x30\x6d\xd3\x67\x21\x92\x1c\x21\x86\xf9\x37\x76\x14\x3d\x6e\xfa\x8e\x6b\x61\x6a\x96\x1e\x5c\xbd\x68\xf8\x17\xaa\xa5\x36\x0b\x6f\x6d\xcb\x29\x9a\xa8\xcc\xc4\x5b\x52\xd2\xe6\x10\xac\xc6\x3d\xc2\x10\x11\xc5\x59\x6e\xaf\x8e\x59\xf5\x5c\x8f\xb7\xeb\xaa\xe4\x30\x0e\xe2\xf1\xeb\x17\x96\x41\x27\x9c\x1f\x94\x63\xe0\x41\x85\x0e\xae\xcc\xb4\x93\x58\xc8\xb7\x08\x92\xb2\x8b\xc7\x73\x8e\x9f\x25\x13\x31\x1d\xc1\xe0\x09\xbe\x0a\x01\x79\xb3\x2a\xcb\xfb\x77\x97\xf7\x80\x30\xa3\x50\xe9\x60\x31\x89\x3b\xaa\x78\x95\x57\x1c\xa3\x72\x5c\x26\x6a\x93\xd1\xec\x6a\x4e\x6e\x3a\x39\xbb\x17\x75\x7f\x50\x9c\xff\x0d\xb9\xe7\xa4\x6b\x0e\x10\xeb\xd0\xec\x93\xa5\x6e\xd4\xa2\x6b\xe2\xe9\x89\x5f\xe8\xb7\xf9\x64\x75\x10\x00\x98\xe6\x46\xdc\xed\xe4\x7e\xca\x54\x71\x02\xb1\x07\x98\x12\x92\xce\xba\xeb\x41\xc7\xd7\x1e\x66\xfb\x2f\x88\xdb\xbb\x3b\x3c\x4a\x7e\xcb\x6c\x0f\x18\xfd\x0b\x78\x88\xee\x09\x82\xcc\xa7\x11\x7c\xb2\xfb\x93\x7d\x01\x44\xca\x11\xe0\x91\x7d\x7f\x8d\xa3\xee\xaf\xfe\x4b\x7d\xa5\xd2\x10\x33\x48\xba\x46\x31\x70\x40\x33\x2f\x95\x5a\x5b\x99\x1d\x72\x2c\x70\xac\x23\xd6\xdc\x67\x90\x7c\xe4\x33\x97\x34\x04\x85\x6f\x00\x9b\x74\x6e\xa5\x51\x58\xa4\x25\x7f\xda\xae\xaa\xef\x29\x6d\x50\x37\x91\x14\x24\x0a\xe5\x21\x45\x61\xf1\x22\xbf\xec\x25\xe8\xc9\xd6\x0f\xbf\x02\x1b\xb2\x6e\xd2\xc6\x66\xba\x6d\xf5\xea\xe1\x57\x9b\xf5\x54\xbc\xf3\xe5\x4a\x23\x16\xd2\x58\x4a\x55\xd6\xe2\xc5\xb3\xdf\xfe\xb6\x4b\x7b\xb6\xd2\x50\x0c\x13\x50\x83\xc3\xd8\x19\x90\x71\x42\x03\xdd\xa3\x1d\x6f\x03\xfa\x42\xd9\x85\x8a\xf7\x03\xbc\xf1\x29\xfd\xb0\xc2\x05\x7b\xed\x63\xc4\xa3\xc6\x5a\x6d\xb7\xc7\x68\xcc\xc2\x92\x1e\x2a\xca\x04\xd8\x1b\xf1\x95\x4d\x60\x9f\x21\x65\x99\x03\xd7\x51\x10\x0b\xa6\x5b\x04\xd3\x80\x53\x17\x3a\x3e\x11\xb5\xae\xce\xa7\x1d\x60\xf5\xd6\xeb\xaa\xc4\xa7\x80\x03\x58\xb0\xd6\x90\xcf\x7b\x08\x01\xf2\x1d\x0f\x32\xb3\x71\xe0\x06\xfc\xcf\x38\xd5\xa8\xe8\x98\xa6\xb3\x84\x8a\xee\x1b\x7b\x8f\xe2\x9d\x3a\x1e\xa5\x4c\xcf\x2e\x60\x5f\x46\xc2\xf0\xa7\xab\x56\x7d\x5f\xf6\x2b\x55\xbb\x67\xe3\x89\x6a\xec\x38\x5c\xfc\x71\xe3\x03\x16\xdc\xb2\x02\x06\xb5\x53\x9b\x83\xe6\x92\x70\x59\x10\xd9\xb5\xdb\xe2\xb1\xba\x10\x4f\xbf\x7d\xe9\x5b\x14\x66\xb3\x5e\xeb\xa6\x35\x42\x6e\x5a\xfd\x70\xa1\xe7\x1b\x6c\x68\x4e\x5d\x53\xaa\x65\x73\x92\x69\xec\xa5\x0f\xfa\xb7\x1b\xc9\x46\x69\xb9\x24\xc7\x9a\x15\xd0\x1c\x24\x1c\xcc\x92\xcd\x21\xab\xc7\xfb\xf4\xf1\x3e\xd4\xe6\x71\x93\xe3\x34\xa8\x85\xf5\x23\x1b\x24\xf5\x07\x25\x9e\x11\x89\x69\x84\x50\x78\x16\x48\xc2\x7d\xd6\xd4\x6c\x12\x4e\x09\xc1\x12\x33\x39\xbf\xbc\xf1\x6b\x7f\xb0\x4c\x13\x03\x13\xa5\x96\x3a\x52\xca\xa1\xc9\xa8\xc3\x59\x27\x40\x8a\x87\x4a\x15\xc4\xc8\x53\x07\x87\xf0\xf1\x37\x10\x43\x3a\x22\xb5\xbe\xa6\x18\x32\x0e\xbc\x29\xa3\xe0\xdc\x6b\x21\x62\x69\xd5\xdc\xfa\xdb\x33\x77\x64\xda\xa6\xac\x2f\x8e\x7e\xe1\xd7\x7a\x4f\x77\x7a\x05\xe8\xf9\xb8\xbe\xa8\xdd\xcb\xef\x7d\x3e\x4a\xb6\x79\x7f\x63\x66\xe6\xfd\x20\x37\xd3\xc7\x5f\x44\xf6\xa5\xa4\x8f\xdb\x24\xb2\x3d\x6f\xf6\x35\xed\x5f\xf9\x7d\xca\x3e\xde\x9f\x0f\x9a\xc0\x6e\x42\x13\x87\x41\xc9\x6e\x25\x66\xf5\x2c\xed\xaf\x17\xcf\xad\x03\xde\x56\xeb\x2d\x30\x6e\x84\x16\x84\x7c\x19\x44\xda\xdd\xeb\x59\xfc\x01\x10\xb7\x7e\xed\xf7\x10\x58\xda\x53\xad\x00\xd1\x33\xb6\x06\xf6\xb5\xd4\x8b\x33\x36\x0a\xfd\x6c\xbc\xca\xfa\x20\x7d\x5f\x66\x08\xa7\xa7\xe2\x19\x10\x38\x3b\x16\xc3\xc7\xb5\x0f\xdd\xf1\x3a\xd9\x6a\x81\xde\xce\x14\xe4\x77\xe6\x05\x83\x76\x15\x52\xf6\xd6\xb7\x8c\x91\x86\x79\x4c\x4c\x55\xd6\xed\x43\x32\x89\x3d\xac\xd5\x87\xf6\x61\x55\xd6\x4a\xd4\xfa\xe1\x42\x56\x15\x41\xda\x51\x85\x9f\x1e\xbe\x5b\x04\x22\xc3\xe5\xd5\x47\xd1\xbf\x62\x90\x98\xb2\xbe\xd2\x97\xea\x0f\x1b\xd9\x14\xaa\x78\x42\xcc\xd6\x3f\x7d\xee\xf2\x00\xc2\xd6\x7f\xd7\x96\x95\x99\x66\x4b\x9e\xdd\x73\x59\x31\xe5\xe6\x62\x89\xc5\xff\xe9\xb7\x99\xda\x71\x11\xac\x36\xaf\x94\x6c\xf6\x55\x4c\x0b\x9d\xdd\xcb\xa0\xdb\x50\x38\x4a\x16\xdb\x66\x2e\xd7\xed\xa6\x51\x50\x39\x40\xd9\x5c\xa8\xf6\xf5\x66\x56\x95\xf3\x2e\x36\x4d\xe7\xd3\x6d\x02\xbf\xb8\x68\xb6\x39\xa7\x3b\xdf\x97\x55\x45\xe0\x4d\xdf\x97\xed\x12\xc0\xa4\xf3\x46\xe2\x32\xb1\x39\x03\x96\x25\x90\x47\x44\xa0\xf6\x05\x8f\xe6\x99\xc6\xdd\x91\x89\x21\x8e\x86\x59\xcc\x18\xd9\x28\x53\x96\x81\xf1\xfa\xb2\xb9\xce\x1d\x1b\x60\x5a\xbd\x66\x23\x46\x64\xfd\x33\xc2\x38\x7e\x82\x9b\x45\x39\x85\xd1\x24\xa4\x76\xe4\xb4\x5f\xd6\xad\x6a\x9a\xcd\xba\x15\x9b\xda\x65\x8f\x9d\x72\x53\xb5\x91\x0b\x55\xed\x9e\xf4\x2c\x6d\xff\x2a\x32\x93\x79\xee\x32\x1c\x5b\x7a\x38\xd9\xbf\x65\x13\x41\x05\x3b\xfd\x38\x2a\xe3\xf2\xfc\xf0\x33\x7f\x7c\x92\xfa\x6f\xd3\xec\x90\xec\x9e\x67\xae\x09\xe7\xa8\xf8\xf1\x0e\x33\xe4\x4d\x24\xc9\x94\xbb\x16\x7e\x5c\xb6\xa7\xaa\x95\xf3\xa5\x15\xaa\xa8\x15\x0e\x21\x61\xe5\xb5\xb0\xf5\x0d\x22\xbe\xb8\xe4\x0e\x39\xc9\x2f\xc2\x3d\x19\x58\xd4\x46\x2d\xdc\xb2\x41\x03\xb1\x2b\xe8\xf0\x5a\xf9\xa1\x8d\x5b\xa9\xbe\xb5\x72\x0d\xe4\x7c\x68\x7a\x56\x0c\xd5\x14\x7f\x2a\x17\xea\xc9\x6e\x5e\x29\x06\x44\xbf\x60\x09\x20\xfc\x25\x25\x83\x3c\xff\x76\x00\xbe\x65\x3a\x61\xa6\xf3\x89\x5a\x1c\xb0\x23\xb3\x52\xcc\x5c\x48\x58\x40\xb9\xf0\x8b\x7e\x84\x41\xf7\x27\xa5\x3c\xbc\x13\x4e\x7e\x9e\x96\xc5\x4b\x4e\x7b\x58\x3f\x29\x15\x8a\xc6\x39\x20\xed\x66\x88\x52\xb6\x2a\xa3\x4c\x99\xaa\x9d\x11\xa6\x72\x4a\x9e\x54\x85\x3f\x03\x7a\xb9\x75\xa3\xae\x0e\x30\xc3\x85\x4a\x6f\xf7\x13\xd9\x6b\x6d\x01\xee\xf4\x4f\x7a\x0f\x48\xcc\xf2\x4b\x37\x09\x0b\x72\xe8\xc6\xf4\xc8\x38\xc1\xa8\xe6\xe2\x8d\xa3\x21\xb3\x4f\xe9\x0d\xe2\xb5\xfa\xb4\x5c\x48\x13\x1c\x81\x33\xc7\x09\x0c\x7d\xc6\x31\xba\x2b\x7f\x5d\xcb\x7d\x05\xe4\xe9\xeb\xcd\xeb\xfd\x98\x89\xa5\x8a\xe6\xa8\xf1\x38\x4c\x4d\x7c\x9d\xf9\xca\xc4\xdc\x47\x19\xb5\x44\xba\x6e\xef\xa3\x85\x7b\x7f\xf3\x95\x1b\x41\x52\x7d\x2f\x9f\x0f\x10\x55\x56\x07\x24\x50\xa7\x15\x5e\xc9\x5d\xd0\x94\x6d\x29\xab\xce\x4c\x61\xb8\x34\xe6\x92\x8f\x61\xbd\x30\x9b\xda\x0a\x7d\x3d\xe2\x56\x3b\x7a\xec\xa8\xf1\x44\x97\x5d\xd6\xeb\x4d\x8b\x66\x9a\x85\x6e\x56\x60\x0e\x6b\x74\x15\xeb\xb4\x31\x1d\xa9\x09\xea\x74\x92\xb4\x20\x80\x75\xa6\x78\xfe\x98\xa5\xaa\xd3\x41\xa2\x34\x4d\x43\x9d\xc4\xcd\xca\x4b\x89\x75\xbc\x5e\xb7\xd6\x8e\x70\x9d\x7a\x05\xe4\xb4\x47\x2d\x7a\xce\xbc\x2e\x0e\x7c\xa0\x98\x9b\x47\xfc\xa4\x26\x4e\x1e\x31\xec\xce\x58\xca\x86\x0b\x82\x2f\x42\x38\x17\x4e\x53\x4f\xfe\x7b\xd1\x33\xdf\xeb\x26\xb5\xf7\x68\xf6\xeb\x98\xd1\x85\x8e\x52\xff\x88\xaa\x5c\xa8\x87\x73\x60\x35\xba\x01\x42\xea\x43\x64\x11\xd9\xdb\x69\xaa\x4b\xb8\x5e\xb7\x18\x92\x66\xc6\xf4\xdc\x11\x95\xa3\xd8\xe3\x8e\xd8\x0c\xc2\x71\x2a\x33\xbb\x63\xeb\x91\xf2\x78\xe6\xa4\xdb\x56\x06\xec\x63\xfc\x1e\xb7\x8e\x55\xce\xb1\x7b\x81\x5f\x8e\x8e\xdc\x08\xa6\xf9\x20\xee\x6e\x3f\x57\x39\x4c\x03\xed\x7e\x2d\x8e\x3b\xc2\xae\x77\x2c\x89\xd3\xa7\x47\x30\xe7\x99\x2d\xc5\xd6\x3a\xc4\x7a\x78\x1d\x07\x45\x0e\xfa\xe9\x4d\xbf\xe4\xc1\x4a\x74\xd7\x32\x7c\x3c\x66\x82\xc5\x27\x96\x4f\xe7\x3b\xa3\x9a\x87\xba\x29\x2f\xca\x1a\x11\x24\x48\xe8\x3c\xb6\xc7\xde\x9d\xfa\xba\x80\xcc\xf5\x27\xfc\xfc\x79\x39\xf4\x5e\x84\x2b\x0e\x7e\xad\x28\xa9\x56\xa8\x9c\x5c\x41\x1a\x84\xed\x14\xb6\x20\xd7\x15\x36\x8a\xcd\x04\xe9\x36\x6a\xb0\x6c\x8f\x8c\xd0\x97\x72\xd7\x5d\xbe\x44\xae\xe5\x38\x16\x64\x25\xd1\xf5\x13\x5e\x12\x88\xee\x91\x6b\x85\xd9\x4b\x92\x72\xbe\xc5\xac\x5f\xb1\xdb\x8b\xeb\x49\x30\x7d\xc2\x66\xea\xc7\x57\x8e\x8a\x17\x8c\x66\x3b\xa8\x7e\xe8\x9d\x3b\x1f\xd6\x01\xaa\x83\xbb\x62\x47\xc6\xac\xcf\x60\x1f\x3d\x7a\x7a\xde\x07\x1e\x9f\x57\x80\x0d\x48\x33\xf4\x22\x6c\x0f\x1c\xc3\x4d\x5f\x15\xf4\x2d\x71\x06\x48\x04\xc2\x28\xaf\xd2\x18\x4c\xf2\x1a\x97\x95\xd1\x70\xd3\x20\x0f\x3a\xe5\xe4\x43\x94\x8f\x38\x67\xab\xe8\x40\x2b\x6c\x4b\xc2\x66\x58\x6f\x2c\x51\xcc\xe7\x19\x19\x46\x75\xb2\x1c\x49\x8a\x02\xe5\xfe\x90\x5e\x25\xda\x47\x93\xdd\x23\x16\x5b\xd0\x0f\x2a\x63\xbb\xca\x20\xd1\xb8\x3f\x6a\xb5\x6e\x77\x2e\xb7\x89\x53\xde\x67\x3b\xdb\xbb\x53\x7d\x24\x38\x39\x04\x8d\xd6\x2d\x47\xd4\x03\xd4\x06\x8c\x32\x2c\x21\xa3\x2d\xd8\xee\x57\xfa\x4a\x15\xb1\xe9\x3e\x86\xd5\x98\x4b\xc2\x93\x87\x1c\xfc\x60\x1b\x02\x39\x81\xa2\xbc\xcb\xba\x56\x08\x5e\x62\xbc\xb7\x69\xbb\x54\x3b\xdb\x8d\x6b\x7d\xb6\x73\xc8\x2a\xae\x21\xc0\xd5\x74\x99\x20\xbf\xa7\x53\xc2\x7b\x14\xd9\x7b\xaf\x6b\xc1\x46\x03\x45\x4c\xd9\x42\xcf\x0b\xed\x30\x23\xc3\x5c\xe0\x74\xe2\x10\x00\xd3\x03\x06\xd1\x28\xc5\x92\x15\xfb\x27\x8a\x40\x1d\xec\xa2\xe1\x7a\x13\xca\x45\xdb\x6c\xd8\x5e\xc6\xc4\xba\xe6\x37\xeb\xf4\x54\xfc\x6b\x69\x4a\x06\xd3\xcf\x97\x03\x98\x7f\x8a\x7b\xc7\x2c\x95\x7e\xf4\x42\x37\x61\xcc\x86\xa5\x1f\x7e\x7b\x59\xae\x1d\x6f\xe6\x1b\x8b\x47\x70\xc2\xb2\xd6\x5d\xd9\xde\x0d\xbe\x55\xfe\x52\x86\xab\xd2\x83\x46\x62\x8f\xed\x71\xe8\x13\x5d\x0f\x6c\x47\x5e\x43\x6e\x4f\x44\x63\xaf\x22\x3a\xb7\xd5\xad\xf6\x83\xc2\x3b\x1d\x0d\x49\xc8\x99\x0e\xb4\x20\xc9\xc3\x30\xb6\x5d\x14\x42\xe2\xcc\xe4\xf7\x7d\x45\x8e\x61\x73\x3f\x86\x91\xf9\xd1\x31\x00\xf9\x25\xeb\xde\xd8\xbb\x47\xfe\x4b\xfb\xff\xe9\xe1\xfd\x79\x22\x55\xc0\x3b\x08\x66\x9e\x94\xcd\x39\x3d\x15\x4f\x36\x56\x46\x58\x30\x60\x58\xb1\xd6\xc0\x47\x81\x23\x5f\x51\x9a\xb9\xae\x6b\x35\x6f\x21\x22\x3a\xbe\xcd\x2f\x30\x89\xee\x44\x6c\x7d\x0a\x16\x62\xf1\x40\x8b\xcc\x72\xc3\x50\x93\x49\x7a\xe6\x80\x91\xdb\x6a\xe2\xf7\x42\x5a\x5c\xfb\x00\xfd\xe1\xc9\xa3\x00\xff\xc4\x93\xdf\x42\x36\x73\x2b\xbf\x63\x5e\x19\xf8\x27\x35\x5a\x1a\x9e\xbc\xc3\xb5\xa6\x6b\x15\x3c\xe9\x8d\x6a\xdb\x0a\xdd\xe0\xff\xf0\xe4\x91\xcb\xd7\x43\xa1\x55\x2e\x3d\x2f\x25\x2f\x26\xef\x11\xfb\x77\xd7\x56\xd9\x1a\x55\x2d\xf0\x99\x9c\x29\x1a\xa4\x93\xe2\xdd\x30\xc8\xad\x07\x53\xae\xab\x0f\xad\x68\x4b\x97\xa1\x8c\x86\x16\xef\xb2\xd7\xe9\x24\xf1\x3f\xec\x0b\x77\xeb\xf6\x4b\xd7\xe1\xd6\xc3\xa7\x4c\x13\x99\x52\x3d\xc3\xf0\xe7\x08\xdc\xb9\xd3\xb7\x1c\x91\x63\x40\xe9\x94\x05\x92\x14\x7d\x00\x71\x4e\xb4\x83\xc4\x67\xfb\x10\xd0\xfa\x8a\xdd\x1a\xda\xdb\x19\x87\x3a\xcb\x71\x0a\x39\x0b\x62\x1e\x2a\x68\x98\xc7\x8e\x90\x76\x5e\xd4\x0b\xed\xd1\x76\x52\x9c\x9d\xa8\x0a\x0c\xe9\x10\xa0\x9d\x24\x09\x6b\xdf\x02\xc6\x15\x26\x71\x3f\x41\xf0\x3c\x8b\x5e\xdf\xfc\xa2\xe4\xa4\x77\x31\x52\xb4\xde\x23\xf2\x88\x84\x05\xce\x51\x59\x91\x70\x6e\xc3\xd2\xfa\x0d\xda\x8b\xd5\x4c\x37\x6a\x2a\x56\x43\x0f\xf0\xff\xb9\x5e\x32\xe0\x54\xfb\x2d\x58\x62\xf0\x08\xe6\x00\x9f\x26\x49\x6d\xfb\xe7\x7d\x17\x35\x69\x08\x54\xa9\xe3\xb5\x3c\xf6\x34\xa6\xfd\x74\x4c\x17\xfb\x56\x3a\xa3\x59\xe9\x2e\xe4\x4f\x53\x69\x26\x86\x70\x33\x12\x6b\xd9\x75\xae\x65\x3e\xea\xdd\x53\xec\x01\x31\xeb\xe3\x47\x31\x8c\x53\x10\xf9\xce\x84\xf1\x81\x9b\x99\xbd\x3d\x4f\x10\x6f\xe3\x51\xff\x28\x3f\x4d\x92\xba\x3e\x12\xf3\x90\x4a\x4f\x49\xf5\xf3\x68\x98\x74\xa3\xbf\x19\xf0\x46\xa0\x9e\x0a\x39\xc3\xf3\x9e\x17\x4e\xf0\xda\x2e\x75\xe5\x99\x85\xe9\x48\x8d\x40\xb4\xc3\x39\x86\x8c\xf1\x8d\xe9\x7c\xd0\xfd\x28\xe3\xc8\xd2\xb7\xc7\x9d\x93\x71\xdc\xa3\x6a\xff\x34\xb9\x97\xf4\x15\xcc\xf1\x8f\x3a\xbf\xa4\xe3\xf2\x1a\xdc\x47\xe9\x0f\xdd\x1d\x49\x4a\xfa\x1f\xb2\xe7\xbb\x97\x75\xb8\x11\xf0\xc6\xed\x21\x3b\x70\xf6\xe7\x25\xea\xc5\xbc\x74\x35\x65\x3f\x4f\x62\xe1\xd5\xe5\xc5\x4a\x8a\xc6\x89\xb1\x9a\xe4\xb6\xf0\xf2\xe9\xb7\xb8\x7d\xfb\xa1\xaf\x8f\xf0\x2d\x4e\x11\xe6\x52\x1f\xf8\xe2\xec\xe7\x4c\xc9\x18\xfb\x35\x57\x89\x95\x98\xf8\x95\x36\xaa\x69\xbf\x41\x45\x01\xab\xc5\x7f\x8f\xcb\xbe\xa8\x7d\x23\x7d\xd5\x3a\x45\xc2\xfa\x05\x4d\x49\xb4\x74\xfe\xe7\x4c\xc9\xe7\x8d\x5e\x65\x67\xd6\x57\x26\x49\x59\x45\xbe\xda\xaf\x25\xa6\x75\x98\xc1\x8d\x9b\x05\xda\x08\x6f\x36\x8a\x05\x84\x2a\x90\x0a\x74\x24\xa8\x52\xa1\x7c\x5a\x83\xd2\x84\x4e\xa8\xe4\x49\x57\x04\xa6\x8e\x52\xf1\xd2\x77\x8f\x7f\x49\xfb\xa7\x17\xa0\x73\x29\x9e\x7d\x58\xab\x79\x4b\x08\x5b\x98\x9c\x13\x54\x26\x21\x1e\xf0\xb6\x9e\xbf\x58\x66\x8d\xe6\x1a\xad\x25\xcd\x12\x73\xb6\xf4\x62\xed\x76\x3f\x03\xaf\x94\xfd\x82\x5c\x57\x77\x0c\xb4\xab\x6f\x51\xba\x8e\x47\x81\x38\x48\x3e\xa3\x65\xab\x85\x51\xb2\x41\x99\x74\x2b\x9b\x22\xc4\xf7\x81\x48\xb9\xa9\xdb\xb2\xb2\x32\x2c\xad\xa1\xd3\x45\xd8\xb5\x74\xed\x61\x9a\x98\xef\x02\x98\xb3\x15\xac\xcb\x05\xa6\xd5\x59\x57\x8a\x23\xe5\xca\x46\x79\x24\x71\x29\x1a\x4c\xdf\x43\xf1\xe1\x5e\x12\xc7\x01\xad\x21\xa7\xce\x52\xad\xa6\x0e\x4f\x49\x62\x88\x9e\xfa\x80\xcb\x55\xca\x8a\x0d\x3e\xc8\xab\x34\xc6\x4e\x66\x0e\x58\x07\x72\x43\xc4\x22\xe6\x51\x5e\x69\x17\x94\x50\x65\x61\x45\x77\x9c\x3c\x61\x3d\x4d\xac\xc0\x7f\x64\x44\xdb\xec\x7a\xfa\xbc\x35\xf5\x4d\x74\x98\xe2\x72\x27\x39\x84\xb0\xad\x02\x2c\x0d\x0d\x9a\x11\x54\x8c\xd8\xc3\xa3\x1b\xb1\xa4\xb8\x7a\x07\x97\x1d\x52\xd0\xa1\xd2\x3d\x0e\x74\x3c\x3d\x15\x95\x5d\xfd\x64\x56\x62\x5f\xa8\xc0\x8f\xac\x31\x8a\xd7\x99\x2b\xf7\xc2\x95\x7a\xf0\xa0\xab\xfa\xcb\x03\xe3\x97\x2d\x7a\x31\xb4\x4c\x1f\x2c\x6b\x44\x3b\x60\x70\x74\x3c\x6a\x8d\xb4\xe2\x1c\x59\xed\xf4\x54\xbc\x6b\x76\xec\x5e\x15\xe8\x04\xce\xaf\x51\x04\xec\xe7\xb5\xac\xdc\xf5\xc1\xb3\x8f\x3d\xbb\x8c\x1a\x25\x1a\x8f\xc3\xb8\xa6\xf3\xe8\xce\x76\xaa\x0e\x15\x4c\x43\xe9\x0b\xe5\xf6\xf0\x86\xbd\x90\x25\xa7\x32\x5a\x98\x9c\x3e\x1a\x94\xdb\x92\x90\x0b\xd7\xb2\x69\xbd\xde\xca\xa3\xe9\x67\x56\x27\x06\x95\x19\x99\x75\x6f\x78\xc2\x5d\x0f\xbe\x91\xc0\xda\x03\x2a\xe0\x4f\xc9\x51\x3f\x3d\x15\x4f\x96\x6a\x7e\x89\x89\x28\x52\x5b\x83\x69\x2d\x97\x06\x49\xc4\x66\x00\x75\x0b\xae\x43\x20\x6b\x16\x5c\x0b\x7f\x7f\xe8\x84\x24\x27\xf9\xb9\xde\xd4\x85\x28\xdb\xfb\xe9\xf3\x1a\xc3\xad\x8f\xb3\xd1\xfb\x5e\xb2\x62\x19\x38\x42\x79\xb3\x01\x91\x79\x80\xcf\x08\xd6\x89\xf0\x9e\xd0\xcb\x9b\xf0\x15\x08\x9c\x7f\x9e\xe7\x44\x3a\xbc\x7f\xc4\x8f\x70\xa5\x1d\x18\x8d\x4d\x9f\x4a\xcf\xa9\x74\x58\x97\x19\x03\x76\x8f\xf2\x25\x61\x40\xb0\x76\x0e\xbd\x36\xea\x1e\xf8\x90\xf0\x71\x54\xe6\xf9\xc1\x8e\xfa\x60\xad\xe3\x6e\xed\x3b\xb6\xaf\xd7\x4e\x38\xd1\xdd\xf6\x7b\x40\x5a\x7c\xc6\xa1\x11\xbb\x73\xeb\xc1\x32\xa4\xdf\x65\x33\xe5\xb7\x8a\xe4\x13\x90\xfc\x7b\xb0\xdc\x22\x04\xce\xd8\x2a\x40\x36\xc5\x42\x23\x9a\xe4\x8e\x31\x3e\x3d\x42\x92\xe3\x86\x99\x49\xf0\x09\x18\x20\xf8\x40\x82\xf1\xc2\x85\xe0\xca\x8b\x88\x39\xee\xcc\xe3\x5c\xfc\x07\x6f\x20\x72\xe4\xb0\x37\x65\xe6\x84\x93\x0e\xa7\xd8\xb9\x71\x23\x13\x5e\xe0\x4c\xef\x38\xb5\x1a\x1f\xde\x80\xc9\xf5\x16\x12\x5a\xd8\x26\x70\x91\xba\xb9\x32\xd8\xc1\xef\x38\xcf\xe7\x45\xbc\x9e\x2c\x6c\x13\xda\x87\x11\xa1\xcf\x4c\xe2\x3c\xa8\xb1\xa1\xc7\x6e\xcf\x5c\xf2\xb2\xf1\xbe\x84\x72\xbd\x53\x60\xcd\x8d\x6a\xa3\xfb\xa2\x5e\x23\x55\x1d\xba\x1b\xd0\x1d\x74\xd6\x2f\x80\x20\x40\xa6\xe4\x97\xa4\x75\x23\x0c\xd6\x7d\xca\xba\x1f\xdb\x70\xdd\xaf\x34\xfc\xc9\x1a\xb0\x87\x1d\x86\xb8\x44\x7e\x9b\x14\x96\x51\x4c\xea\x2a\xa4\x53\x7d\x66\xcf\x63\xd9\x12\x18\xaf\x8f\x56\x7b\xed\x2d\xd0\x6b\xbd\xde\x54\xc1\xd1\xd7\xb6\x73\x64\xa2\x87\xb9\x5c\x58\xce\xdd\xd3\x72\xde\xc0\x0b\xf3\xaf\xf6\x1d\x0f\x84\x3b\xf7\x35\x66\x8e\x3a\xa5\x32\x8c\x5d\xd2\x4a\x8e\xcb\x1b\x7e\x0d\xee\xe7\xc6\xd1\xb1\x86\xba\xee\xfb\xf2\xb8\xd8\xa7\x0a\x5b\xe8\x51\x1b\x08\x00\x9d\xe8\xa8\xc2\x72\x10\x13\x3f\x8e\x7a\x2a\x8b\x2d\x11\x33\xc3\x5d\xcb\xe6\x7e\x53\xa4\xe8\xec\x18\xb5\xd5\x6b\xc2\x1b\xd8\xc1\x84\x51\xc6\x3f\xc0\x40\xb2\x05\x3f\xcb\x8f\x2f\xb5\x47\x8e\x19\x5a\x7f\x7a\x98\x3d\x03\x8d\x59\xdc\x83\xc6\x99\x33\x8f\xfe\x84\x46\x1a\x25\x9b\x19\x56\xb7\xc6\xc5\x7b\xae\x37\xef\xdf\x87\x44\xdc\x02\x57\x96\xb5\x53\xd5\x31\xeb\x70\x7a\x2a\x1e\x43\xd4\x8d\xe3\x29\x19\xaa\xfa\x95\x72\x14\x59\x15\x13\xaf\xef\xd9\x82\xd7\x2d\xe2\x53\xae\x10\xfe\x2c\x7a\xf8\x81\x94\xc6\xfe\x43\xd1\x2b\xd6\xb7\x11\xe9\x1b\x95\x57\xc8\xc7\xd5\x07\x78\xa2\x0c\x57\xc5\xda\x1c\xdf\x0c\x9f\xda\x53\xe0\x7a\xae\xf2\x4e\x88\x5b\x25\x64\xd5\x28\x59\x90\xa3\xa0\x2a\x22\xe8\xce\x83\xf9\xb1\xef\x89\xd5\x02\xb8\x3d\x48\xd3\xed\x98\xb0\xb2\x25\xd4\x07\x13\xe9\x28\xfd\x86\xd8\xc5\x4f\xf5\x4b\xe0\xc3\xd4\x28\x69\x4c\x79\x51\x43\x0b\x72\x7e\xe9\x01\x72\xd6\x7a\xcd\x39\x2c\x67\x00\x95\x3b\xb1\x59\x4f\xf3\xc7\xd7\x3f\xe9\xfb\xae\x5f\xbf\xdb\xa6\xd3\x74\xa1\xb6\xd0\xf9\x6e\x26\xe1\x5f\xbd\xba\xad\x7c\x04\xde\xcd\x55\x52\xb9\x3c\x6f\x09\x53\x9d\x5e\xb1\xac\xbb\xea\xd0\xcc\x01\x03\x6f\x87\x2f\x19\xf8\xaa\xa6\x31\x6f\x33\x55\xe9\xed\x4f\x6b\xea\x39\x5e\x37\x63\x6d\xff\xb1\xd9\xdc\xac\xc1\xff\x9a\x1c\x6e\x0f\xd5\xcd\x29\x4a\xe3\x0b\xca\x2c\x08\xee\x92\x32\x84\xb6\x46\x99\x16\x9d\xa7\x63\xad\x9e\x6f\xe9\x6d\x59\xcf\x99\x63\x38\xc0\x76\x4a\x01\xc0\x9c\x2e\xd7\x14\x34\x08\x97\x98\x99\x70\xe2\x14\x25\xfb\x99\xc7\xdc\x7e\xde\x1d\x37\x1f\x3b\x69\x64\xd8\x78\xae\x0c\x75\x00\xe6\xb1\x32\xd4\x3f\x23\x7c\xd9\x6e\xcd\x9b\x63\x4c\x7c\x42\x9f\x0b\x47\x6e\xaa\x71\xd2\x87\x3b\x06\x37\xb8\x8d\x48\xde\x83\xc1\x11\x7c\x85\x7e\x84\x6f\x8c\x8d\x0a\xa9\x90\x09\x58\xac\x10\x4a\x36\x55\x19\x67\xa4\xeb\x24\xb4\x18\x1b\x76\x0a\x7a\xfb\x86\x30\x49\xc9\xd5\x3d\x24\x2f\xf3\x79\xaf\xdb\xa5\x93\xfe\xda\x46\x21\x3c\xa9\xc7\x5a\x4e\xdb\x93\xce\x83\x17\x07\x03\x11\x0c\x09\xaa\x34\x5c\x3f\xf7\x4c\xa1\x1b\x35\xa4\x4c\x85\xe4\xd9\xb9\x1c\xa6\x80\x46\x67\xd4\x18\xe0\x71\x1e\x15\x9e\x05\x41\x10\x8f\xb2\xe0\x89\x87\x04\xf8\xa6\xc9\xc8\x55\x14\xe0\x8f\xc6\x14\x9e\x9d\xbc\xf7\x25\x16\x3d\xa0\xdb\x63\x22\xe9\x45\x6f\xa9\x4c\x1e\x85\x4c\xa2\xf0\x01\xe0\x4c\xee\x66\xc3\x20\xbf\x47\x43\x6e\xf7\xc6\x29\xef\x43\x82\x1b\xb8\x85\xfd\x41\xcb\xf7\x8f\xf3\x77\x6e\x8f\x24\x0c\x92\x2e\x07\x00\x93\xa8\x62\x27\x03\x2b\x60\xa7\xda\x43\x73\xa7\x32\x31\x9c\x39\x86\xbe\x37\x8a\x80\xc4\x48\xa0\xe3\xae\xfa\xed\x5e\xf4\xdb\xbe\xe6\x7d\x97\x3c\x0b\x49\x3a\xf2\x86\xbf\x4b\xf2\x8e\xa4\x7e\x5d\xc7\x7c\xdd\xf7\xe0\x82\xde\x00\x27\xe3\x1f\x26\x3c\x3d\xf5\x5a\x4d\xf9\x94\x8e\x09\x2a\x1f\xfa\xe9\x23\x28\xfa\x02\x25\x13\xb7\xa6\xd8\xb5\xb7\xeb\x3a\x9b\xff\x3d\x76\x04\x64\x4e\xb3\xc9\x0f\x71\xb9\xe0\x27\x1b\xff\x3b\x2e\xe5\xc1\xef\xe8\xef\xf1\xd7\x31\xfe\xa2\x63\xbd\x45\x47\xf9\x8a\x82\xa7\x68\x9c\x40\xad\x73\xba\xdc\x2a\x0f\x7b\x73\x7e\xf2\xf8\x7d\xaf\xbe\x7d\xff\xe4\xdb\x57\xef\x9e\xfd\x7f\xef\xc4\xb9\xf8\xc1\xfd\x1a\xc0\xf1\x62\x24\xfe\x14\x1d\x2f\xc2\xc3\x03\x2d\x42\x5c\x3e\x20\xe2\xa5\x1f\xdd\xc4\x13\xa4\xd8\xb4\x5a\xf2\x8d\xe1\xdf\xe1\x0f\x6f\xad\x40\xf0\x64\xd3\x18\xc4\xef\xc2\x10\x11\xf8\xe7\x71\x98\x19\x4c\x99\x55\x82\x89\x1d\x56\xb3\xd1\xda\x53\x98\xb1\x35\xf9\xc5\x22\x7c\xf2\xc2\x41\xda\xce\xdd\xd9\xbf\x7f\x3c\xc7\xec\x60\xa1\xe6\xb0\xb6\x97\x38\x10\x5c\x2a\x70\x65\x2b\xcd\x5d\x69\x7b\xe9\x62\xce\xb3\xfe\x81\x19\x80\x5f\x0e\x60\xc1\x16\x4c\x9c\x77\xe6\xdf\xb3\x9e\xd3\x58\xd2\xa0\xfe\x79\xe1\xee\x50\xd6\x1b\xb3\x8c\xc7\x01\x76\xff\x09\x78\xd5\xbd\x61\x55\x99\x98\xf5\x7a\x63\x96\xfe\x11\x02\x07\x37\xcf\xc6\x6b\xe7\x6c\x02\xb2\xa6\xb7\x60\xc3\xfa\xca\xaa\xd2\x5b\x23\x36\x86\x44\x58\x45\x95\x41\x67\xe4\x54\x37\xb2\x01\xe5\xd1\xda\xf9\xdf\xd8\xf1\xf5\xcd\xb7\x3b\xc8\x09\x7a\x2d\x38\xd8\x7b\x64\x10\xb0\x48\x94\x10\x23\xb9\x18\xc7\x9d\xc9\x06\x83\xcd\xbb\xc6\x0a\xcd\x2e\x07\xb6\x6d\xc1\xca\x87\xf6\xdf\xcc\x3e\xb4\xc6\x3c\x69\x85\x17\xa0\xdd\x9c\x91\x78\xbb\x49\x83\x6f\x60\x5d\xed\xb0\xaa\x89\xea\xda\x47\xed\x6f\x1b\xdf\x8b\x61\xd3\xef\xb9\x78\x34\xd9\x30\xe7\xb4\x42\x76\xa9\x7c\x9a\x81\x50\x2b\x39\x11\x29\xb8\x6d\xe4\xbe\xba\xd6\xeb\x6c\xf3\xd1\x18\x42\x99\x9e\x31\xb3\x82\xbd\x7b\xdb\x37\xbe\x14\xde\x3a\x8a\x2b\x74\x7b\xdc\xa1\x18\x9d\x21\xe7\x2f\xcb\x3c\xe4\x69\xeb\xbf\x27\xb6\xc1\x8e\x97\xf6\xad\x5c\xd9\x1b\x4e\xc2\x9d\xf7\xe8\xac\xa7\x6f\x87\x6b\x66\xe2\x1c\x9a\x41\x7c\x69\xf2\xa7\x1f\x15\xd4\x76\xf2\xc8\x98\xc2\x7e\x1e\x19\x3f\x48\xca\xa4\x08\x30\x29\x78\x80\xf1\xdc\x82\x5e\xde\x8d\x02\xb2\xea\xfa\x51\xa5\x61\x3f\x91\x73\xcc\xcf\xec\xc2\x1d\x72\xd9\x3a\xa7\x0a\x96\x1f\x9d\x34\xf5\x3a\xca\x59\x89\x0b\xe1\xd7\x80\x05\x2d\xbb\xd9\xf8\x45\x49\xcf\xed\x09\xae\x07\xe0\x73\x98\xf1\xcb\xc2\xf6\x33\x5d\x95\x29\x17\x47\xa2\x09\x64\x77\xf8\x16\x09\xc8\xa7\x84\x49\x30\xaa\xe7\x49\xed\xbf\x38\x82\xf3\x0e\x44\x09\x86\x6f\x6a\xa7\x46\x17\xfd\x39\xa6\x50\x8f\x92\x7f\x4f\xee\x65\x38\x37\x18\xef\xa3\xec\xaf\x13\xb7\x24\x49\xd9\xf4\x97\x4e\x39\xe8\x3b\xfe\xf7\xc4\x1f\xd9\xb4\xb1\xf4\xa7\x6e\x49\x6c\x2e\xfe\x61\x12\x24\x9a\xa4\xc1\xee\x6f\x31\xf2\x35\xe3\x91\x9d\x28\x3e\x86\x51\x46\x41\xef\x6d\x1a\xe8\x44\x2c\x6f\xee\xab\x63\x95\x83\xc4\xef\x8b\xfb\x9f\x1c\xfe\xf1\x0b\xf2\x11\x2e\xb4\x32\xde\xf3\x3a\x54\x5c\x41\x32\x48\x17\xd8\xee\x7f\xef\x11\xc4\x54\xdd\xb2\xc9\x01\x92\x26\x8f\xc5\xcb\xc4\xdf\x44\x8a\xf5\x4f\x51\x5c\xd7\x60\x3b\xbe\x68\xdb\xec\xde\xe9\x27\x95\x2c\x57\xaf\xd4\x07\xaa\x63\xc9\xa1\x3b\xce\x7d\xf5\x86\x72\x41\xf5\x8d\x79\x80\xc9\x1e\x4c\x2d\x75\x02\xf9\x02\x20\x9b\xef\x0c\x73\x04\xdc\x9e\x6a\xa9\xb3\x76\xfb\x92\x50\xdc\xd2\xe4\xa2\xbc\x11\x3f\xee\x04\xd3\xd4\x1d\x71\xb8\xeb\x2c\xb6\x82\x67\xcf\x19\x13\x8e\x03\x3c\x7a\x4d\xb3\x63\x1c\x8d\x3f\xef\xd3\xee\x67\x2f\x88\xfb\x2f\xef\x62\x65\x5e\xae\x32\x2f\xc2\x04\xda\xf8\xe8\xbe\x75\xb6\x3d\xd6\x44\x5f\x21\xd6\xc8\xf3\xb2\x31\xac\x80\x8b\xea\x8b\xda\xc8\x95\x89\xa9\x45\x7e\xfa\xcb\xfc\xdc\x97\x7b\x26\x9e\xf9\xee\xaa\x16\x65\xf1\x4a\xb7\x2f\x65\x3b\x5f\xba\xa4\x2a\x9e\x6c\xf6\xb6\x37\xb6\xd2\x40\x27\x87\xb4\xdd\xdf\x24\x95\xc8\x65\xb2\x49\x5b\xec\x2b\x9a\x6d\x70\x7f\x3b\xf9\xea\xcf\xcb\xba\x60\xdb\x3a\x62\x58\x7b\x6a\x8c\x6a\x7e\xcf\x5a\x8e\xa8\x35\xd4\xcd\xe8\x96\xc7\x34\x76\xd0\x50\x79\x61\xf7\x4e\xbe\x5b\x2a\x51\x28\xb5\x56\xa6\x25\x5e\x94\x6c\xa2\x68\x61\x2e\xeb\x2b\x5d\x5d\x59\xe6\x1c\x72\x8c\xf9\xf7\x93\xf1\xa6\x8e\x5d\x5f\xc9\x9d\xcb\x3a\xa2\x6a\xa0\x74\xde\x5b\x58\x37\xbc\xf2\xd4\xd1\x26\xff\xcb\xeb\x28\x7c\xc5\x19\x7a\x9c\x08\x94\x5d\x3a\x5e\xa8\xa4\xfc\x45\x48\x5c\x88\x24\x72\x7e\x32\xf3\x7e\xf7\xc5\xe6\x46\x56\x8b\xbd\xc1\x1b\xbd\xc3\xeb\xa1\x49\xc7\x71\x27\xf4\x08\xf4\xac\x03\x8b\xb1\x8c\x67\x18\x7c\xc2\xe8\x15\x70\x3f\xa4\x90\x4f\x95\x6a\x55\x77\x78\xc7\x58\xeb\x39\x0a\x40\x7d\x29\x1c\x9c\x39\x9a\x15\xee\x05\x45\x4d\x7d\x07\x87\x29\x44\xd4\x64\xcf\xf2\xf6\xe0\x43\x26\xe0\xa9\xc3\xce\x95\x59\xfa\x12\xcf\x07\xe5\x65\xf6\x4b\x64\x74\x89\x3f\xb1\xf0\x80\xfd\x63\xfb\xc4\xe5\x24\x78\x87\xd1\xf9\x9f\x92\x96\x3b\x6d\x29\xb4\xfc\xbc\xd1\x2b\xce\x57\x3d\xd7\x8d\x77\x8c\xa0\x1e\xa2\xda\x51\xb6\xab\x38\xcd\x60\x54\x2e\xf2\xd8\x60\x33\xc9\x35\x19\x02\x5e\xce\x85\xeb\x9c\x29\xce\xe0\x7e\x83\x27\x96\x51\x6a\x05\x3c\x0f\x7a\x9a\x55\xba\xbe\x30\x96\x64\xac\x29\x07\x92\x2a\xe0\xdc\xbb\x36\xa6\xe2\x8f\x7a\x6b\x19\xa8\x89\x6b\xab\x05\x0c\xed\x90\x36\xb6\x13\xbc\xa8\xbc\xc6\xbe\x44\x5a\x53\x95\x06\x3e\xc5\xe9\xa9\x5d\x5a\xea\x72\x11\xb2\xb8\x21\xc8\xac\x57\xf8\x47\x3e\x8b\x94\xbf\x0f\x0c\x78\x2d\x46\x95\xd2\x33\xee\x9a\x93\x17\xd2\x52\x39\xd2\x50\xa0\x93\x89\x1d\x9e\x69\x6d\x1d\xb2\xf7\xf9\xb8\x4a\x4a\xa9\x62\x94\x83\x00\x73\xcd\x34\x0a\xf7\xb6\x08\xe2\x36\x3f\x46\x95\x34\xed\x33\x8c\x3d\xea\x5a\xab\xf3\x05\xa7\x96\xcc\x50\x9d\xf3\x78\xe3\xce\x06\x2b\xe6\x4b\x27\x8e\x6a\xbc\x2a\xa0\x94\xfb\xba\x07\x35\xda\x8d\xde\x07\xf2\xff\x4a\x3b\x1e\xb1\xc8\xd3\x9f\x88\x0e\x2f\x92\xe8\xab\x8f\xe7\x22\xc9\xc3\x7f\x1b\xe4\x29\xf6\x0d\x08\xb4\x9f\xfb\xfd\x8e\xa0\x51\xb1\x17\x40\x70\xdf\xc9\x0c\x65\x0c\xb9\x0a\xa3\xf1\x1e\x1b\x8e\x46\xa5\x0e\xc8\x29\x1e\xbb\x2d\x47\x70\x49\xd9\x0c\x13\x23\xd9\xa9\xe3\x64\x19\x22\xa8\xf6\x0e\xfe\x52\x87\x1a\x27\x93\xec\x62\x65\x09\xe6\x1d\x70\x1b\xe3\x8e\x64\xb5\xee\xd8\x53\x8b\x77\xef\xa0\xe3\x8c\x83\x9d\x02\x9f\x46\xbe\x37\x7d\xc7\xea\x1d\x6e\x67\xfa\xf0\x74\x3d\x75\xb0\xb8\x73\xfe\xe9\x7d\x96\xfa\x2a\x46\x2a\xeb\xcc\xe9\xbd\xb3\xf3\xfa\x7e\xe4\x81\x7d\x7f\xd3\x13\x9b\x6c\xf6\x3b\x3c\x9d\x61\xd5\x26\xc9\x4a\x4c\x70\x68\x13\xea\xf9\x16\x8f\xf0\xfb\x1b\x9e\xe1\xcc\xd1\x1d\x35\x9b\xdb\x3f\xd3\x59\x00\xfa\xae\x9b\x6e\x97\xbe\xb7\xcd\x8e\x28\x3b\xb7\x33\xa6\x36\xc6\x81\x63\x76\x88\x37\xe2\xe0\x09\x1b\x4f\x0c\x53\x3c\xf4\x8e\xf6\xe3\xb8\x8e\x3c\x68\xfa\xe8\x5f\xe2\xef\x98\x77\x3a\x4b\xe4\x87\x0e\xb3\x16\x2f\x77\x27\xd2\x24\x93\x54\xb4\xc7\x5d\x77\x64\xa6\xe5\x51\x47\x36\xe3\xbd\x95\x57\xf3\xa4\x2b\x95\x9e\x4c\x80\x93\xe7\x0d\x8d\x5f\xa6\x36\x92\x53\x6f\x75\xa9\x3a\xa7\xbd\x5b\x3c\x7b\xd2\x07\x75\xb1\xb1\x2c\x09\x1a\x65\x26\xb0\xf5\x99\x50\x04\xb3\xf2\x71\xc1\x36\xdb\xc5\x59\x68\x3a\x77\xcb\x08\xd2\x0f\x30\x75\x18\x67\x3b\xc5\x0c\xec\x65\x1b\x89\xe3\x1e\x0d\xa3\x97\x41\xcb\x09\xa4\xb1\x59\x27\x15\x49\xa3\xe5\xde\x2f\xcf\xe6\xd6\x02\x26\xb7\x87\xa8\x64\x60\x85\xe6\x12\xd4\xfb\x58\x89\x70\xf1\xdd\x6a\x66\xc0\x85\x18\x5e\x0c\x06\xbf\xa0\xbf\x60\x69\x84\x34\x42\x8a\xa5\xda\x34\xa5\x69\xcb\xf9\x54\xbc\xb0\x75\x67\xd2\x28\x40\x5b\x2f\xeb\x76\x53\xc2\x69\xb0\x02\x82\x95\x58\x0a\xd9\x4a\xcc\x2b\x11\xda\x43\x19\x69\xa6\xc4\xa2\x92\x5b\x5b\xb1\x11\x9b\xba\x56\x73\x65\x8c\x6c\x7c\x50\x72\xb2\xe3\x7d\x3a\xd0\xe8\x86\x45\x99\x0f\xa3\x33\x20\x3e\x7e\x14\xe3\xd7\xed\x5a\x27\xe5\xa6\x67\x65\xf0\xb4\x8c\x3b\x2f\x7d\xc1\x23\xb8\x89\x2b\xd9\xce\x97\x64\x3e\x75\xdb\xec\x42\xc9\x6b\xbd\x15\xd2\x98\xcd\x4a\xa1\x04\x88\x78\x4d\x8d\x81\x42\x62\x2b\x4d\x68\xc9\x6c\xd6\xaa\x59\x54\x1b\xbd\x31\x94\xd0\xdd\x36\x40\xe1\x07\x65\x3b\x0d\xc1\x18\x78\xea\x94\xbc\x50\x4d\x08\x50\xe0\x27\x01\xab\x12\x1a\x17\xcf\xff\x5e\x78\xc9\xf8\x1d\x65\x7f\x97\xed\x04\x4f\x20\xb8\xe9\xd6\x4a\x15\xf6\x24\x16\x9b\xd5\x6a\x17\xda\x43\x84\xa9\x34\x77\x50\x08\xf2\xe8\x55\xf6\xe4\xf7\x27\x4f\x65\x22\x6c\x8f\xfd\xbb\x72\xb0\xf6\xab\x73\xa0\x13\x0b\xfa\x90\xb1\x89\x8e\x75\x4f\x02\xef\x65\x30\x64\x72\x9d\x5e\xd9\xab\xcd\x0b\x5e\x16\xa9\xa3\x7a\x62\x13\x60\xce\xe2\xdc\xc9\x62\x91\x55\x17\xed\x1d\x5c\x7c\x33\x52\xa7\xfb\xd2\x44\x3e\xf6\xf0\x03\x70\x3e\x7a\x11\x7c\xed\xa7\x4c\x52\x8e\x3d\xe4\xa3\x99\xf8\x1e\x08\xbb\xc1\xfb\x43\xe3\x3c\xcb\xba\x28\xe7\x84\x4d\x8e\x97\x02\x33\x8f\x49\xe7\xcc\xac\x1b\xc4\x59\x52\x8d\xd7\x6c\xc0\xe7\x5a\x6d\x21\x29\x13\x84\xa9\x35\x97\x81\x76\xd6\xd4\x45\x50\x7b\xec\xf3\xcd\xef\xbc\xe6\x78\xf0\xd2\x27\x79\xff\x21\x89\xf8\x92\x8e\x62\xb7\xe3\x8c\xde\x73\x10\xda\xc8\x0e\x9d\xd9\xe0\x50\x14\xad\xd3\x1e\x68\x33\x63\x0f\x4a\x5c\xb1\x59\xdb\xf1\x11\xe0\xa1\xf5\xbc\xd5\x34\xe0\x53\x45\x34\x6c\xdf\x22\x08\x70\x3c\xaf\x2a\xa7\xb8\x77\xee\x37\x5b\xd8\xe6\x24\x28\x37\x68\xf5\x63\xf0\x7c\xfa\x57\x1c\xe9\x91\x00\x8c\x45\x29\xd3\x10\xd4\xdd\x4b\x9e\xdc\x1e\xc1\x68\x48\x1c\x50\xc7\xcb\xe7\x39\xc4\x11\x9a\x1e\xb1\x2f\x90\x3d\x95\x6c\x6f\x4d\xeb\x23\x0e\x30\xf9\xe5\x55\x14\xd9\x33\x32\x56\x52\xfd\x94\x5f\x82\x5e\x79\x7d\x68\x1d\x46\xa9\x29\xc4\x4d\x54\x15\xe2\x06\xea\x8a\x9e\x85\xbe\x9e\x1c\x7d\xab\xeb\x9e\x81\xd7\xe9\x12\x33\x7e\xb5\xb3\xae\x63\xef\x34\xf0\x80\x3d\x78\xa7\xd7\xc5\x8e\x85\xb4\x48\x1e\x9b\x22\x0f\xe9\x98\xf9\xfe\x26\xca\x6b\x32\x0a\x35\xb6\x87\x5b\x08\x38\xb4\x5d\x67\xb9\x01\x7b\x1c\x26\x5b\x76\x34\x21\xd7\x76\x24\x09\x20\x0a\x2b\x98\x31\xc1\xa9\xb0\x8e\xfc\xe8\x3a\x56\xcb\x89\x4f\xc1\x54\x7b\x28\x98\xd0\x18\x47\x25\xc8\x4b\x87\x43\x32\x9e\x93\x4b\x8e\xc8\xae\x11\x32\x04\x2d\x3d\x03\x8c\xe1\x48\x98\x0a\x2a\x67\x55\x45\x28\x25\xce\x4b\x8a\xad\xa5\xdb\x91\x4d\x15\xc5\x90\xad\x0f\x24\x06\xc7\xc2\xb5\x68\x14\x18\x3b\x59\xa3\x7a\x21\xf4\xa6\x61\x4c\x2e\xa1\x37\xba\x39\xf6\x1f\xbe\xbc\xa8\xc7\x85\xef\xdc\xfa\x84\xf7\xb4\xab\xb3\xb9\xc7\x97\x88\x42\xd4\xea\x9d\x68\xd4\x4a\x96\x35\x60\xe1\x7a\x8e\x11\x0d\x30\x51\xac\x34\xb1\xd9\x90\x63\xa9\x76\x21\xf0\x0c\xf2\xa7\x20\x96\x89\x1f\x84\xa5\x92\x05\xac\xd5\x4c\x17\x3b\x61\x80\x7f\x07\xd4\xcc\x56\xd5\xd0\x28\x0c\xa2\x91\x75\xa1\x57\xae\x3d\x6d\xb9\x1e\x0f\xb9\x48\xb8\xb9\x0e\x87\xb3\xbc\xa8\x7d\x02\x29\x8c\xc7\xc7\x2c\x9e\x9b\x26\xc1\xb3\xa3\x68\x30\x58\xf1\x42\xb9\x58\xed\x69\xcc\xf8\x7d\xa3\x5a\xd8\x2d\x2f\x76\xc6\xc7\xbf\xe7\xd6\x7e\xfc\x88\x8b\x6b\xbf\x1c\xd9\x19\x1e\xd9\x8b\x1c\x7e\xb2\x73\x85\x9f\xee\xe7\xdc\xe8\x8e\x7b\x39\xd8\x93\x38\x41\xcb\x01\x9a\x89\x10\xc5\x9f\xd5\x4e\x0c\xc8\x27\x39\x71\x35\x90\xdb\x1b\x89\xca\x91\x11\x76\xdf\x31\xef\x15\x66\xb2\x94\xed\xeb\xfe\xa1\x24\xfc\xe5\x49\x94\xab\x79\xd0\x60\x9f\x71\x0f\xf4\xae\x6c\x7b\x7c\x25\x06\xc6\xcf\x52\x07\xe5\x85\xf0\xae\xd7\x6b\xd6\xdf\x31\xf3\x23\xf7\x19\x4d\x4a\x67\x7e\xc4\xd2\xfb\x1d\x1b\xf7\x95\x20\x7f\xd6\x41\x47\xc7\xa1\xaf\xfd\xf5\x63\x7f\xc2\x7d\x25\x82\x97\x6e\x32\xf7\xce\x4f\xc1\x5f\xd6\x19\xd3\x2b\xd5\x82\x63\xfb\x52\xeb\x4b\x84\x70\x21\x8f\x78\x4b\xe5\x66\x9b\x0b\xb1\xb5\x6c\x3e\xf8\xe2\x03\x04\xe6\xd4\xd6\x7c\xab\x94\x58\xb6\xed\xda\x3c\x3a\x3d\xbd\x28\xdb\xe5\x66\x36\x9d\xeb\xd5\xe9\x42\xce\xd5\x4c\xeb\xcb\xd3\x46\xc9\x79\x7b\xba\xde\x54\xd5\xe9\xff\xfc\xcd\x17\x5f\x4c\x7d\x6f\x84\xc5\xcc\x6d\xec\x6b\xc8\x55\x2b\x1e\xbf\x7e\x31\x81\x6f\xea\x4a\xd5\x80\x1b\x01\x5e\x8b\xe2\xa9\xba\x7a\xa7\x75\x65\xa0\x8d\xff\xa5\x37\xe0\xdd\x03\x44\xb6\xac\xff\xb7\x9a\xb7\xa0\xc8\x98\x6d\x2e\x6c\x21\x4b\xae\x76\x7a\x83\x21\x9c\x9a\xfc\x1e\x69\x3e\x88\x13\x38\x4d\xfc\x84\xed\x0a\x36\x9b\x95\xaa\x5b\xe7\xc6\x6b\xcf\x9d\x6f\x10\x2f\x4c\xc6\xbf\x38\xa9\xf7\xfe\xb7\xe2\xbc\xff\x2b\xd5\x26\x8d\xef\xdb\xa5\xde\x3e\x2d\x65\xa5\x2f\x62\xa7\x64\xb9\x6e\x37\x8d\x2a\x9e\x35\x8d\x26\x9e\x22\xba\xa2\x6e\x0c\x86\x57\xef\x34\x79\x76\xef\x9e\x6f\xb2\xd2\x17\x4f\x78\xa3\xb9\x2e\x6c\x8b\x95\xbe\x80\x5f\xc4\x39\x6b\x3c\x29\xec\x9c\xb4\x1e\x57\x95\xde\xd2\xca\xab\x82\x97\x07\x0f\xd5\x75\x63\x77\xaf\x75\xe3\xb2\x2f\x90\xd1\x95\x9a\xa2\x8f\x6a\xa5\x2f\x2e\x08\x78\x3c\x8d\xac\x68\x7c\xea\x75\xf0\xe8\x80\xa5\x7c\x25\xdb\xf2\x8a\x22\xfe\xe1\x6d\x5a\xc9\x5a\x5e\x28\xd1\xa8\x62\xa6\x3f\x88\x99\x5a\xca\xab\x52\x03\x54\x83\x7d\xa6\xc2\x34\xce\x89\xa4\xc4\x3e\xd4\x9e\xc0\xf0\xd0\x1e\x7a\xc7\x5e\xc9\x15\xda\x17\xd8\x9c\xa7\xd1\xd7\x28\x87\x08\xfe\x0c\x7e\xfc\xfd\xb5\xe0\x73\xa8\x06\x4b\xf0\x8d\xde\xd4\x85\x6c\x76\xd9\xfe\x3a\x25\x7a\x2a\x23\x16\xf4\x60\x6d\x28\x12\xaa\x6f\xcb\xaa\x7a\xa3\xda\x66\xd7\xa9\xe5\xbf\x60\x18\x67\x66\x59\x5e\x2a\x63\xec\xaa\x9f\x27\xab\xf5\xb5\x38\x7a\xb7\x54\x98\xe6\x91\x7c\x90\xf5\x1c\x78\xcc\xc2\x79\xa8\xfc\xfe\x48\xfc\x3a\xa9\xf5\x6b\x71\xf4\x55\xf8\xe9\xd1\x91\x78\x34\xdc\x8c\xae\x81\x5f\xd9\xe9\x8d\xa3\x07\x81\xdd\x79\x74\xc4\x22\xf2\xa2\xe9\x87\x31\xf3\xd0\xc9\xd3\xd3\xdc\x3a\xce\x11\xc8\xdb\x08\xb3\x59\x2c\xca\x79\x69\x85\x84\xcc\x66\xf9\x62\xad\x16\x46\xb6\xa5\x59\xec\xc4\x73\x8f\x7e\x04\x21\xd5\xdd\xb6\x1f\x3c\xe8\xb6\x14\x63\x18\xfa\xf5\xe7\x1c\x4a\xcf\x5c\x8e\x70\x01\xb8\xdf\x90\xf3\xf0\xa1\x00\x7f\xcf\x96\x81\x5b\x10\xc0\xd2\x98\x79\x63\xa5\x54\x61\xb7\xe2\xf8\xc8\x25\xdf\x75\x4b\x3d\xa3\x4e\x80\x6a\xba\xd0\x9f\x09\x14\xee\x2e\xc1\xaf\xc5\x11\xf7\x16\x4f\x41\xa6\xfa\x46\xcd\x9c\xd4\x11\xf1\x12\xc0\x1f\x00\x17\xb3\x2e\xaa\x90\x16\x36\x19\x51\xff\x18\xfe\xad\xb6\xdf\x8e\xde\xe0\xdc\xdd\x84\xba\x53\x5e\xc8\xd2\x36\x6f\xb4\x60\x0b\x47\x68\x3a\x01\xf5\xed\x28\xe1\xd1\xe2\x69\xf5\x4d\xea\x89\x06\xb9\xad\x11\xb2\x28\x10\x17\x3a\x1d\x7f\xab\xf1\xd4\xc2\xb8\x5a\x2d\xe6\x1b\xd3\xea\x55\xf9\xef\x6e\xa2\x30\x7b\x90\xc1\x1c\x1d\xa3\x79\x21\x18\x97\x7b\x5d\x17\xb3\xe9\x4a\xe1\x7b\xfa\x10\x2a\x3e\xa4\x1e\x4a\x65\x30\x4d\xa5\x6c\x28\x93\x2c\xa2\xcd\x47\xc3\x28\x95\x71\x13\xfc\xc4\xaf\xf7\xac\xac\x55\xc1\xa6\xd3\xb9\xa8\xee\xdb\xaf\x53\x72\xf7\x6b\x71\xf4\x6f\x35\x8e\xf4\xf8\xa8\xb3\x47\x54\x8d\xc5\xfa\xbd\xa8\x45\xa1\xae\x54\xa5\xd7\x10\xf1\x0f\x30\x6e\x14\x13\x66\x57\x47\x6f\x6b\xb1\xa2\xbe\x40\x7a\xf9\xdf\x1b\xcc\x0f\xc2\x0e\x33\xf8\xff\x72\x11\x0b\xf1\xa7\xca\x7a\x5e\x6d\x0a\x74\xad\xa3\x3c\xec\x15\xcd\xde\xb5\x68\xa5\xad\xff\xe7\x2d\x39\x10\xb3\x4c\x05\x62\xd6\xe8\xad\x51\x8d\x6b\x73\x29\x8d\x47\xc5\x5b\x37\x65\xdd\x62\x0c\xa0\x77\xeb\xb3\x55\xe4\x7a\x5d\x95\x73\xe4\x12\xcc\x96\xc2\x8e\xfd\xb9\x75\xc0\x83\xe0\xa1\xe7\x9a\x2d\x4a\xb3\xae\xe4\x2e\x1c\x71\xea\x16\xe4\xc1\x4b\x23\x28\xaa\xf9\xe9\xb3\x7f\x7d\x08\x0c\xcd\x42\x5e\x2a\x81\x0f\x68\xdb\x94\xe0\xf3\x8c\x47\x17\x68\xf5\x77\x6d\x59\x91\xa8\x1c\x3d\xab\xc7\xc9\x7e\x3a\x34\x01\x64\x17\xca\xfa\x4a\x5f\xaa\x3f\x6c\x64\x53\xa8\xe2\x89\xac\xaa\x99\x9c\x5f\xfe\x93\x67\x57\x58\xcb\xd9\x92\x67\xd0\xc8\x52\x9a\x27\x72\x73\xb1\x6c\x1d\x9f\x90\xd6\x8d\x0b\x60\x25\xc8\xb9\x3a\x5c\x2d\x2d\x62\x1f\x21\xc7\x95\x14\x65\xf1\xbd\x6c\xea\xc7\xf6\x50\x03\xeb\xfa\xae\x91\xb5\x29\x89\x4b\xf3\x22\x03\x2b\xfa\x56\x61\x41\xb0\xf0\xb0\xb8\xaf\x5c\x51\x5b\x0e\x75\x60\xcf\x75\xf3\x9d\x83\x8f\x0c\x72\x2d\x01\x2f\x60\xa5\xad\x1b\x07\xd6\xf8\xb6\xf6\x15\x92\x1c\x77\x89\x9e\x2c\x65\x2f\x2e\x54\x90\x9c\xed\x4f\xae\xc6\xc7\x8f\x44\xdb\x01\x51\xeb\x28\x58\xd8\x47\x8e\xf6\xcf\x51\x47\x7f\x19\x32\xf3\xdb\xa9\x80\x68\x48\x11\x48\x4f\x64\x8d\xcc\x34\x19\x65\xa4\x70\x33\xb3\xd7\xc8\xfe\xd5\x92\x28\xa0\x4b\xc1\xec\x83\xac\xdb\xc6\x6c\x80\x8c\xaf\x94\xac\x0d\x3c\x20\xa4\xe7\x37\xb4\x0f\x13\x97\x61\x91\xfe\x05\xad\xe8\xc6\xf2\xf6\x73\x9a\x0e\x64\xf2\xae\x03\x7e\xa7\x48\x3b\x41\x43\x8f\x7e\xa8\xd7\x53\x4b\x76\x28\x82\x09\xc7\x03\x2f\x32\x92\x8a\x42\xf9\x64\x41\xbf\x62\xef\xe0\xf4\x68\x12\x6f\x82\x83\x4b\xbb\xd6\xba\x32\x8d\x53\xe6\x6c\x50\xb6\x83\xef\x28\xcf\x2e\x3f\x18\xa9\x63\xbb\xb3\x23\xc0\x9e\x3f\xb5\xb2\xc6\x13\xd4\xcd\xa1\xde\x79\xbd\x94\x46\x25\xce\x49\x47\x2e\xe6\x9a\xce\xf5\xd1\xa3\xc8\x76\x31\x70\x03\xc6\x42\x0e\xa6\x27\xc3\xed\xe2\xf1\x74\x3a\x3d\x79\x24\x9e\xc8\x1a\x94\x88\x12\xf3\x15\x3b\x95\x00\xa9\x2f\x93\xd1\x1d\x9f\x70\x64\x9b\xe1\xeb\xb9\x2f\xb7\xc5\x11\x8a\x06\xf9\x09\xe7\xa8\xc3\x75\x27\x4c\x33\xa4\x8b\x50\x6c\x1a\xf7\xae\x7f\x28\x0d\xdc\x02\x50\xa4\x88\x36\x90\xa1\x63\xb3\x99\x2f\x85\x44\xbd\x5b\x59\xc3\xb1\xfc\xec\xaf\x38\xde\xbf\x42\xa8\x49\x8d\x0a\x3c\x7f\x8e\x30\xc8\xdd\x0a\x87\xf3\x56\x37\x27\x53\xf1\x06\x0a\x8b\x95\x6a\x97\xba\xf0\x88\x59\x9f\xd9\xf3\x3d\xb3\xb7\x11\x94\x79\xfe\x24\xe9\x05\x79\x97\xd9\x87\x0d\x86\x73\xc6\xdb\x8b\x10\x8a\xc0\x61\x1c\x2e\x8a\xb4\x77\xac\x2d\x1f\xae\xa5\x95\xa2\xea\x09\x68\x7d\xe7\xb2\x16\x33\x25\x30\x2b\x7e\xab\xc5\x5f\x23\x5c\x42\xc8\x17\xf8\xd7\x69\x66\x17\x7b\xe8\x71\xef\x2e\x7e\x22\x8d\x43\x2a\x40\xbf\x25\x3f\x84\x66\x30\x32\x77\x19\x61\xd0\x64\x21\x70\x5c\x9d\xb3\x34\x94\x27\x5b\x2f\xf9\x98\x56\x4e\xc3\x9f\xc5\x39\x1f\xc2\x34\x1f\x1d\x9d\xc6\x47\xf7\x57\x62\x20\x3b\xdd\x50\xe6\xa4\x5a\xb7\x80\xa7\x39\xef\xc3\x84\xbe\x51\x17\x65\xfd\xbd\x6e\x2e\xa3\x69\xfa\x5f\x69\x7e\x89\xe1\x3f\x5d\xa2\x89\xf7\x0a\x01\x44\x25\x38\xae\x9b\x56\x3d\xfb\xb0\x2e\xb1\xdc\x73\xdd\xa0\xa9\xc3\x8d\x7e\xc6\xba\xcd\x8d\x66\xea\x0b\x44\x35\x9e\x03\x47\xbe\xb7\x5e\x28\x96\x9b\xb2\x25\xcf\x95\x6a\xd5\xf7\x3a\x9a\x73\xf8\x79\xec\xb4\x4f\x18\xd2\x93\xaf\x1a\x0f\x2c\x34\x3a\xe5\x85\x7a\x86\x45\x90\x54\xe9\xb0\x3c\xe6\x26\x0d\x8a\x24\x70\x54\xac\xc4\x68\x53\x29\x92\x56\x67\x34\xd4\xd6\xf4\x20\xe0\xad\x3d\xad\xec\xc1\xe3\xda\x53\xbb\x1f\xa6\x6b\x4f\xc5\x21\xf4\xae\x3d\x55\xf7\x82\x7a\xed\xa9\xbf\x0f\xeb\x6b\xef\x94\xa9\x9c\x3f\x07\xb5\xde\x06\x04\x80\x5a\x6f\x5d\xbb\xee\x5e\x3d\x55\x0b\xd5\x34\x81\xad\x66\xe8\x02\x3d\x25\x5c\x0b\x1b\xa3\xde\xee\xea\x39\x91\x4b\xd4\x97\x53\xd5\xce\xa7\x24\x40\xfd\xb9\xa6\xa1\x87\x2a\xe9\x97\x88\x1a\x01\xc2\x7a\x5a\x23\xfd\xe2\x14\x81\x6f\xd4\xda\x7e\xaa\x5b\x13\x59\x38\xdb\x72\x05\xb6\xc4\x95\xf1\xb1\x95\xa6\x95\x4d\xfb\xae\x5c\x21\x20\xef\xf6\xd8\x13\xdb\x95\x36\xed\x1b\x35\x57\x75\x4b\xec\x0f\x15\x5a\x99\x77\x3a\xd0\x1e\xfb\xe3\xf1\x6f\x4e\x7a\xfa\x55\xbe\x1c\x76\x0d\x3e\x29\x65\x3d\xd7\x2b\xbb\x54\x1b\x62\xc6\xe8\x59\xdd\x18\x35\x15\xc7\x84\xc7\x70\xcf\x39\x12\xbd\xd2\x48\xf5\x9c\x6c\xe8\x74\x97\xa6\x6d\x64\xab\x2e\x76\x8f\x84\x34\xbb\x7a\xee\x1b\x2b\x6b\xfa\x61\x05\x11\x78\xf6\xaf\xd8\x16\x2b\xe0\xbf\x4f\x4f\x68\xb2\x61\xa0\xe1\x95\xc0\x9e\xfd\x21\x2a\x8d\xfd\x67\x1a\x3a\x4a\x91\xb1\xe0\x4b\x08\x7a\xed\x32\x84\xb8\x91\x2f\x1e\x86\x93\x81\x19\x37\x18\x79\xb7\xd4\x16\xfa\x4e\x3a\x23\xda\x77\x75\xd9\x7e\xbb\xa0\xdb\x99\x86\xb7\x52\xfe\x76\xf7\x33\xf5\x0c\xeb\x6a\x3b\x58\x96\xf3\x65\xa7\x1b\xe4\x76\x6c\x47\xb6\x43\xde\x15\xb2\x36\xf1\x46\xc6\x93\xe6\x53\xa3\xbc\x95\x65\xbb\x04\x9e\x8b\x52\x62\xe5\x26\x86\x77\xb0\x25\x45\xb2\xeb\xcd\x47\x84\xe1\xe8\xb1\xf5\x7f\x51\x6a\x6d\x19\x36\x04\xa8\xc6\x09\x2c\x10\x9d\x06\x8c\xad\x4e\x17\x1a\xd4\x37\xd0\xa3\xb3\xf2\xce\x94\xd3\x51\x91\xca\x1a\xd6\xad\x34\x84\x60\x5f\x38\xe0\x67\x50\xbd\x55\x95\x42\x26\x46\x42\xa2\x02\xcf\x4e\x3d\x2d\x8b\x27\xa0\x8e\xf2\x8e\x50\x53\x0f\x88\xc0\x34\xb1\x26\x5e\xf8\x7d\x23\x27\xdd\x16\x71\xa9\xfc\x06\xce\xa0\x33\xc2\xb1\xe4\xaa\x76\x10\xa5\x8a\x72\xb1\x50\x50\x0e\x33\x9f\xc9\x3a\x19\xc6\xc4\xeb\x49\x42\xe6\x4c\x84\x55\x83\x6c\x97\xf7\x7c\x9a\x23\x55\x17\xce\x82\x03\x5d\x06\x81\xcd\x2e\x1f\x79\x02\x34\x7a\x2d\x2f\x2c\xd7\xac\x70\x8e\x73\xdd\x60\x56\x24\xcb\xc4\xcb\x7b\xe4\xea\x3a\x43\xdd\x9d\x2c\x2b\x83\x9a\x2c\x18\x97\xae\xe7\xca\x2d\x15\x4e\xf7\x9b\xa0\xf9\x8a\x16\xeb\x59\xa2\xf2\xc2\x5d\xec\x6e\x6e\x66\xb5\xf0\x30\x4d\xa3\x1c\xda\xaf\xad\xfc\x95\xed\x0b\x86\x52\x36\xa6\xfd\xae\x9e\x47\x8a\x0d\x5e\xa0\x28\x8b\xe7\xb2\x95\x55\x74\x8b\x5d\x26\x43\x77\x74\x53\xbd\x44\x69\x48\xfc\xcc\x5c\xff\xef\x8c\x3d\x6a\xba\x11\x6b\xd5\x2c\x74\xb3\x02\x6b\x2a\x9c\x0d\x76\x07\xca\xba\x55\x4d\xb3\x59\xb7\xaa\xf8\x66\xc7\xaf\x41\x6c\xd3\x7d\xc2\x40\x8b\x8e\x23\x90\x73\x97\x09\x0f\x94\x65\xc1\x9a\xfa\x4f\xbf\x3d\x0e\x2e\xa2\xa1\xd4\x1c\xe0\x8b\x4c\x28\xe7\x25\xbf\xb3\x7b\x79\xf6\xf6\xb8\x17\x90\xfc\x71\x55\xd9\x92\x78\x83\x8d\x1f\x15\x33\xe3\xf7\x46\xa9\x06\x49\xaf\x47\x96\xb6\x23\x63\xff\x66\xad\x9d\xa4\xfe\xdb\x8d\x9a\xeb\xa6\xc0\x8f\xc7\x4e\x83\x49\xc4\x9b\xc5\x24\x87\x16\x42\x74\x28\xf7\x88\xdf\x9f\x78\xb0\x8f\xd9\xcb\x0f\xae\xa7\xe9\x37\x6a\x91\xa6\x3a\x0a\x58\x52\x6c\x8c\xb2\xb2\x32\x9f\x6c\x55\xec\xec\x98\xa2\xfd\xe6\xf2\xf5\x7b\x36\x27\x01\x9b\x17\x91\x83\x59\x70\xe7\xb1\xb4\x7c\xa1\xab\x4a\x6f\x41\x5a\x46\x25\x07\x48\xa9\x2b\xf2\xe5\x04\x4d\xd3\xdc\x5e\xec\xa6\xb6\x17\x13\x14\xd6\xeb\x94\xfd\x0c\x4f\xe9\x04\x04\x5d\xe7\xa7\x6e\xc0\x51\x5d\x82\x49\xc7\xd2\x18\x8a\x1b\x90\x45\x21\x24\xea\x0a\xec\x25\x51\x57\xaa\x61\xde\xea\x6b\x6d\x4c\x39\xab\x94\x98\x95\xed\x4a\xae\xc5\x95\xac\x36\xe0\x90\xcf\xf2\xc2\x08\xa3\xe6\x1a\xb5\xf6\x4e\x78\x76\x90\xfe\xa1\xa1\x90\xa5\x11\xa5\x6f\x9c\x1e\x40\x54\xc8\x16\x9b\x9d\xb2\x23\xb3\x6e\xca\x95\x6c\x76\xcf\xd8\xc9\xe1\xdb\xf7\x1f\xc7\x9e\x15\xfc\x68\xe9\x97\xf8\x18\x27\x87\xfc\x68\x37\x58\x7c\x14\xaf\xf1\xca\x27\x68\xdf\x3e\xd9\x53\xd2\x49\x27\xe6\x38\x60\xef\xb2\xdd\x4d\xbc\x55\x93\x94\xb0\x99\x43\xe8\xd7\x00\xb3\x58\xda\x15\xfb\xcc\xef\xda\x67\x94\x12\x2f\x2c\x8f\xd1\xee\xe1\x16\x97\x96\x31\x26\xb7\x6e\x7c\x1c\x9c\x97\x9b\xcb\x6c\x98\x76\x21\xeb\x9d\xa8\xca\x85\x7a\x38\x47\x41\x00\xcc\xc1\xfc\x31\x05\xd5\x84\xb8\x50\x2d\x7f\x4e\xa3\x26\xd0\x9f\x69\x51\xd6\xc5\xd3\x6f\x5f\x42\x20\x97\x83\xde\x6a\x54\xb5\xc3\x2d\xb3\x8f\x61\xbd\xc3\xd7\x66\xb6\xb1\x87\xf3\x25\x2a\xff\xd2\xc6\x6c\x55\xd8\x70\x5f\x02\xb0\x7b\x2d\x17\x3a\x87\xe8\x07\x59\xef\xb6\x72\x67\x27\xbd\x55\x8e\xd1\x9c\x29\x21\x67\x55\x67\x6e\xad\x16\x97\x60\xbc\x5b\x96\x09\x4c\x7d\x8e\xa8\x40\xc2\xcf\x24\xe6\xdc\xfd\xd9\x17\x19\xec\xab\x3d\xae\x49\x23\xd9\x7f\x00\x4e\x4f\x43\xf1\x9f\xf3\xc9\x18\xb3\xc6\x69\x9f\xb8\x76\xd1\xaf\x20\xf6\x8f\x25\xb5\x22\x12\x88\x8f\xdf\xfb\xb4\x1b\xbd\x6b\xb9\x6f\x67\xf7\xed\x26\x1f\xde\xe7\xd7\x1d\xdf\xe7\x37\x18\xa0\x87\xf1\xee\x1d\x62\xc2\xeb\x74\xf3\x9a\x25\x29\x59\x7a\x87\x92\x67\x9a\x46\x0d\xd6\xe7\x95\x89\x44\x87\xb0\x56\xe1\xaf\x91\x33\xa9\x9b\x48\x0f\xb7\x81\x9c\x10\xe7\x37\x4e\xfa\x22\x39\x3d\xeb\x13\x74\x19\x07\x71\x3e\xe3\xd8\x92\x1e\xe6\xe1\x98\xac\x2f\x1f\x85\x7b\x85\x4e\x62\x44\xb7\x98\x13\xe2\x67\x6b\xec\xc9\x4f\x15\x35\xc7\x43\x47\x7f\x2c\x97\xd3\x37\xb0\x44\xab\x73\x10\x23\xf5\xac\x69\xc6\x77\x01\xfc\xfe\x1f\xc9\x72\x3f\xd8\x8d\x93\x4b\x87\x8f\x15\x8a\x2f\xb5\xd9\x34\xca\x53\xc6\x79\xa5\xd0\x6d\xdc\x28\xb1\x59\x73\x9a\x89\x76\x6f\x39\x9f\x97\x85\xaa\x5b\x30\xbe\x41\x12\x26\x9e\xc0\xed\xf4\x54\xbc\x38\x5a\x81\xd8\x26\xe7\x2d\x5a\xe8\xa8\x79\x40\xc6\x6a\x5b\x2b\x43\xb2\x0c\x5f\x18\x3f\x88\x22\x1e\x03\x5d\x09\xcd\xd9\xc7\x8f\x61\xae\x04\xc7\x65\x2b\x96\xeb\x1a\x19\x2e\xf0\x51\x46\xff\x3d\x6f\xc1\xc7\x55\x5e\x6c\xaa\xd0\x96\xae\x95\x99\x8a\xb7\xda\xfb\x5c\xb7\x9a\xe6\x0b\xad\x60\x2c\xa8\x34\x21\x7f\x06\x61\xdf\xc0\x1b\x3b\xed\xdc\xd9\x69\x46\xf2\xef\x5b\xd6\xc6\xcb\x2e\x61\xf7\x21\x06\x89\x2d\xf0\x5c\xd6\x9e\x47\x50\xc9\x32\xb4\xf2\x82\x30\xc6\xa5\xb1\x52\x3e\xa6\xf6\x67\xa2\x64\x78\x9b\xba\x03\xa5\x53\x30\x4c\x0c\xde\x68\xdd\x9b\x91\xff\x7b\x45\x5b\xdd\xf8\x6c\x5b\xa5\xf1\x43\xe7\x1a\x65\x98\x04\xa9\x23\xe0\xcd\x0c\x72\xb1\x6b\x8c\xd7\xc9\x4b\xc7\xa8\x04\x04\x43\x24\xe6\x1e\xa1\x59\xe3\xa9\x94\x8d\xaa\x8f\x7c\xae\xd8\x4a\xcf\x65\xe5\x83\x04\x03\xe8\x4e\x38\x65\x24\xfc\x43\xb7\xe0\xdc\xe5\xfa\x9a\x7f\xff\x9d\x6d\xcc\xb5\xe4\x25\x76\x55\x19\x05\x01\x62\x13\xee\x54\x08\xb1\x83\xe4\xbe\x03\x9c\xc5\x4c\xd9\x46\x98\xe4\x4b\xce\x58\x4c\x8f\x16\x1e\x97\x44\xfa\x0e\x1f\x40\x3f\x89\xdf\xde\x95\x2b\xa4\xd9\xf7\x04\x03\xe0\xde\x93\x36\xe6\x3e\xc0\x70\x27\x80\xc5\x7c\x13\x73\xb9\x03\x9c\x39\x35\xa4\xa1\x32\x72\x45\x4e\x4c\xd2\x10\x07\x14\x54\x2a\xeb\x46\xcf\xe4\xac\x72\x90\x9e\x8d\xc2\x64\xbe\xe4\x40\xe2\x62\x1f\x4a\x55\xdd\x55\x42\x1d\x98\x62\x69\xde\x28\x59\xec\xb8\x5e\x39\x28\x2a\x22\x05\x01\xfa\xc9\x41\xdc\x0f\x65\xa5\xb7\x1c\x99\x5d\x79\x7b\x4b\x90\x81\xbb\xe7\x1f\x52\x7a\x31\xbf\xdd\xd6\x8a\x23\x22\x7b\x15\x06\x53\xbc\xf8\xeb\xc4\x07\x87\x41\x0a\x6c\x87\xc2\x0d\xff\x2a\x91\xa0\x78\x74\xcc\x63\xd4\xa8\x1d\x19\xc7\xa2\x02\xbc\xd7\x5c\xd7\xa6\x34\x2d\x09\xab\x7a\x11\x65\x07\x47\x0a\x47\xae\xc4\x96\x8e\x95\x0b\x46\x21\xec\x56\x68\xc8\x16\x63\x82\x12\x33\x8a\x1b\xb1\xb2\x6a\xd9\xba\x7d\x63\x2a\xb4\x8a\x32\x46\x30\x81\xb3\x51\x66\x53\xb5\xb8\x66\xc6\x87\x42\x92\xda\xae\x15\x5b\x92\x34\x2a\x8d\x62\xb0\xeb\xfd\xc8\x08\x97\x89\x9d\x0f\xae\xb4\xc3\x2a\x2c\x01\x3e\x23\x25\xb9\x95\xae\x29\x9b\xaa\x93\x7a\xc9\x6f\x13\x4e\x21\xba\x57\x39\x8a\x00\xfb\xcf\x5e\xd0\x68\xb9\x07\x81\xc4\x92\x4c\x5a\x7d\x58\x62\xbc\xd0\x19\xab\xca\xf7\x3c\x6a\x88\x7d\xea\x75\x49\xec\xaf\x3e\xe8\xf4\x87\xba\x0c\x8c\x42\xae\xb5\x3b\x1d\x84\x46\xc9\x57\xe2\x90\xe1\xb9\xe0\x8f\xc4\x02\x73\xcc\x7c\xe5\xe8\x56\xb9\x5d\x89\xac\xf9\xe4\x62\x20\xd1\x69\x51\x7c\x8f\x78\x00\xda\xc1\x4c\x88\x76\xab\xc5\x5a\x1a\xa3\x0c\x83\xae\x77\xf0\x02\xf6\x83\xd3\x1e\x1a\xdf\x3e\xc4\xcd\x86\xd4\xf6\x93\xa0\x75\xf1\x1a\x17\xfb\xf8\xdf\xf3\xe7\x71\xe1\xc8\x2f\xf5\x91\x6c\x60\x32\x61\x46\x57\x99\x7a\xcf\x93\x58\x71\x00\xa3\x5b\x94\x85\xd3\xb4\x46\x4c\x3e\x08\x3b\x8a\xbe\xc4\xf9\xbf\x22\xd8\xe5\x9c\x07\xdc\xb1\xed\x66\x92\x55\x41\x4e\x70\x08\xb1\xc6\x2c\x76\x71\x3b\x3e\x89\x35\x66\x6c\x84\xa9\x3c\xe3\x07\x98\x7a\xbb\x1d\x67\xf5\x69\xa1\x47\xd7\x26\xef\xe9\x7e\x7e\xb1\x72\x4f\xcc\x5b\x96\x7d\x0d\x38\x51\x3c\x4a\x77\x98\x71\x8d\xb3\x21\x6c\x9c\x13\x5a\x82\x38\xe7\xec\x13\xcb\xf6\x3d\xdc\xac\xa3\x45\x1e\x3c\x09\x9d\x23\x37\xc8\x58\xe7\x83\x60\x4d\xab\xd7\xfd\x67\x12\x9f\xba\xc4\xe2\xc9\x6f\xe8\x3b\xca\x17\xf9\xb0\xac\x1f\x7a\x23\x1c\x92\x4b\x4c\x3a\x1d\xd9\x42\xe1\xa6\x22\x62\xe5\x06\x23\xd7\x15\x5a\x87\x02\x23\x16\xdd\x50\x7a\x0b\x38\xf7\x35\xf1\x3c\x1e\x84\xca\x34\xea\xaa\xd4\x9b\xd0\x65\xe4\x6e\xea\xfa\x75\xcc\x55\x26\xd1\x28\xfa\xfe\xd0\x93\x1c\x34\x9f\xd0\xbd\xef\x2a\x1e\x1d\xd2\x34\x32\x3d\x9a\xde\x4e\x9c\xfe\xe5\xf4\x3b\x06\xbd\x10\x31\x46\x29\x01\x76\xdd\xbc\xa8\xd3\x91\x10\x64\x09\x11\x2c\xa0\x57\x5c\xf1\x83\xd8\x9a\x0b\x60\x29\xec\x5d\x0e\x14\xef\x4f\xac\xd4\x52\xae\xd7\xaa\x46\x2c\x1d\x63\x69\x2e\x62\x4e\x98\xc0\x35\xdb\x76\xbd\xb2\x8a\x91\x3f\xd7\x5a\xa4\x7b\x76\x6f\xa3\xaa\xdb\xb2\xa1\x27\x12\xa3\x46\xc9\x6f\x18\xb0\x86\x91\xd6\x14\x71\xf6\x10\xe8\x14\x22\x36\xdb\xa6\xbc\xb8\xb0\xf2\x17\x86\x9a\x62\xc8\xcb\x43\x0f\xb4\x41\xae\xf1\xee\x39\x3e\x90\xc8\x06\x59\xfb\x5a\x34\xf6\xfd\x7e\x22\xfb\xf9\xcd\xa9\x2c\xf3\xdc\x38\x9c\xc8\xbe\xdf\x4b\x65\x3f\xbf\x06\x99\x7d\xff\x73\xa3\xb3\x9f\x27\x8b\x7a\xa7\x44\x35\x27\x5b\xb1\xe3\x93\xf1\x69\x88\xc9\x70\xcf\xa9\x0d\x05\xa2\x9f\x01\xca\x6d\xb7\x56\x7a\x21\x74\xfd\xc4\x4b\xcd\x10\xf2\x75\xe4\x44\xcf\xa3\x30\x3b\x5e\xa8\x27\x91\xe9\x49\x1a\x4d\x6f\x4f\x96\x78\xf0\x60\x28\xd8\x6f\xea\x03\x04\x4f\x62\x95\xe0\xbe\xe2\x53\x37\x20\x50\xb7\x66\x32\xb9\x7e\x4a\x02\xd3\xd1\xcc\x0c\xf4\x82\xa4\x68\x2f\xa6\x63\xc0\xcf\xaa\x64\xee\x7b\x96\x42\x95\x4d\x4e\xe2\xd7\x1d\x48\x9c\xac\xad\xfb\x24\xc9\xf8\x98\x7c\x9e\x2e\x74\xf3\x4c\xce\x97\xc7\xae\x43\x38\x82\x6f\xd4\x5c\x5f\xa9\x66\xe7\x8f\xdd\x3e\x33\x7a\x38\x37\x20\x49\x74\xec\xe9\x3d\x04\x0a\x16\xe0\x0b\x47\x05\xa3\x2a\x67\x9c\x21\xef\x33\xce\xe3\x81\x88\xbe\x1e\x53\xa3\x27\x1d\xc8\x00\x0f\x04\x40\x6e\x2b\xfc\x29\x9b\xaa\xc8\xa9\xe5\x2c\x4c\x26\xa9\x75\xee\xdc\x5d\xb8\x37\x77\x8f\xd3\x07\x0c\xbf\xdf\xcd\xc1\x0f\xce\x25\xe0\xe3\x3d\xf5\x04\x70\x27\x4e\x54\xf6\x09\x7f\x51\xbf\x26\xb6\x65\x42\x0f\x90\xfd\xc4\xc1\x2e\xc2\xaf\x98\x04\x11\x72\x8e\x3c\x78\x20\xe2\xda\xc9\x12\xe0\x54\x6d\xd1\x93\x44\x8a\x0a\xf8\xda\x4e\x69\x15\x02\x7b\x64\xa3\xc4\xb2\x2c\x0a\x55\x4f\x29\x27\xd8\x6c\x33\x9b\xb9\x63\x1c\x9a\x49\x9c\xbc\x4c\x8c\x89\x91\x5e\x9c\x27\x10\x17\x80\xfe\x12\x80\x2c\xe9\x1e\xf6\xa9\xdf\xdc\x5a\x6d\x3b\x7e\x49\x17\x8a\xc2\x3b\x06\x57\x8d\xf3\x82\x60\x66\xb4\x4f\x9d\xf1\xf2\xfd\x15\xc4\x6e\x79\xda\xe2\xcb\x7e\x83\xf3\xda\xac\x91\x87\x80\x1c\xe3\xa6\x4d\x27\x16\x06\x38\xa7\xd4\x22\xc9\xa2\xc3\xcf\xd1\xb3\x8e\x05\xbb\x17\x06\x6e\xb8\xfd\x96\x6e\xd4\x7d\x7f\x26\xed\xa6\x1e\x67\x56\x22\x14\xf8\xf8\x31\xb3\x52\x5f\x89\x5c\xbb\xd1\x4b\x9d\x5b\xde\x5c\xa5\xd4\x03\xc3\xcd\x1a\xcb\x76\xf2\xf6\x8b\x7d\x67\xb0\xdb\x71\xd6\xe5\x04\xdc\x78\x83\x23\x5c\xba\xc3\xb1\x11\xc6\xbe\x06\xdd\x33\xed\xb3\xe7\x57\x1b\x4b\xc0\x27\x14\x1b\xe0\x8e\x38\x3a\xb3\x91\xc6\xc6\x1b\x47\xb8\x8a\xbe\x50\xa0\x99\xaf\x09\xfe\x90\xec\xc6\xdc\x3e\x8d\xac\xba\xfd\x05\xbd\xf8\x40\x83\xa3\x1a\xa6\x20\xc2\xc0\x9b\xd8\x38\x00\x07\x51\xd6\x10\x96\x68\xe7\x2b\x2b\x54\x0b\x3a\xed\x05\x79\x10\x86\x46\x9c\x14\xc3\x7d\x17\x02\xc7\x9e\x2c\x78\xc7\xce\x73\xb0\xff\x4d\xe7\x36\xc5\x27\x80\x59\x4d\xe6\x91\x3f\xb7\x5b\xf0\x94\x86\xf5\x39\x1a\x9e\x8c\x1e\x61\xaf\xcd\x2e\x31\xe6\xc4\x70\x62\xf1\x38\x52\x20\x22\x72\x7c\xc5\x03\x9c\xaf\x12\x8e\xb7\x27\x66\xfb\x29\xf6\xc0\x6c\xd9\xbd\x87\x05\xcc\x71\x7a\x96\xa9\xb2\xcb\x89\x2c\x55\xcf\x56\xdc\x88\x09\x12\x87\x31\x42\x61\x83\x7b\x07\xf3\x89\xeb\x0c\x5e\x2c\xdc\xb1\xf0\x2c\x10\x1c\x68\xb3\x96\xdb\x5a\x15\x80\x08\xb8\x05\x67\x5e\x82\xb3\x84\x15\x73\xda\x32\x2b\x7f\xf3\xd6\xc0\xfb\x06\xf4\x7c\x90\x6f\x21\x78\x0b\xd0\x13\x5b\xb3\x1c\xe7\x91\xf9\x70\x1f\x52\xdc\xe9\xa9\x78\x6c\x85\xcf\xa2\xa3\x60\x25\x09\xdf\xb9\x3c\x62\x86\x07\x4f\x30\x7c\x9e\xdb\xc8\xf6\x84\x46\x16\xca\x3c\x11\xd0\xf0\xd0\x2e\xe3\x96\x03\x52\xdb\x14\xb6\x8d\x45\x94\x6b\x42\x48\xea\x39\x41\xda\x63\xba\x45\xac\x38\x8d\xb6\xbf\x37\x13\x43\x56\x7e\xe8\xcf\xdb\x90\x9c\xf9\x8c\xce\x96\xef\x30\x04\xc4\xc7\x35\xf6\xa8\x96\x0f\x4c\x6a\xd1\x1d\x6e\x9f\x3a\x7a\xcc\xc0\x73\x68\xcf\x99\x14\x15\xbd\x33\xe2\x4b\x90\x9c\x72\x76\x28\x96\xb2\x88\x34\xc1\x60\x4f\x90\x78\xbc\xca\x56\x3c\x7e\xfe\xee\xd9\x9b\x68\xcb\x8f\x4c\xcf\x46\x1b\x80\x8e\x9a\xcb\xda\x6b\x56\xe6\xaa\x69\x65\x59\xc7\x9a\x66\xe4\x4e\x9a\x60\x3d\x80\x76\xd0\xa9\x77\x62\x05\x57\x80\x81\x11\xab\x4d\xd5\x96\xeb\x4a\x91\xd6\x59\x58\x11\x80\x1d\x5e\xb2\x68\xf8\x68\xed\xad\xac\xa3\x03\xcd\xa1\x68\x5d\x20\x78\x74\x28\x6b\xff\x33\x9c\x7d\xef\x95\xbc\x00\xb3\x09\xd3\x1b\x82\x6a\x1a\x81\x0d\xfc\xa9\x47\x05\x12\x13\x8b\x4a\x13\xd4\xf8\xad\x26\x0b\x0e\xd9\xb2\xc1\xc1\x9c\x37\x47\xda\x36\x55\x17\x31\xa2\x24\xf7\xb7\x48\x59\x91\xd4\x15\x14\x1a\x7a\x7b\x59\xae\xc5\x4c\xb7\x4b\xc7\x51\xd9\x0b\x1f\x19\xa4\xd0\xac\x0c\xc9\xaa\x23\x34\x03\xbe\x88\xbc\xc5\xb8\x32\x95\x02\x8f\x74\x09\x4a\x85\x18\x33\x07\x58\x08\xe4\x2d\x80\xbb\x76\xba\xc5\x96\xfb\x46\xc5\x0e\x11\xbd\x06\xb3\x1f\xed\xb2\x45\x17\x2c\xb5\xe8\x1c\x42\x6e\x6e\x78\x53\x07\x9c\x5d\x47\x3d\xa4\x37\x7a\x46\x6f\xf3\x11\x8d\xde\xae\x88\x29\xe9\x79\xbc\x5e\x2c\x02\x0a\x2f\x78\x48\xc2\x23\xdb\x02\x48\x74\x49\xde\x93\x51\xe6\x9c\xe8\xb5\x4d\x9f\x51\xde\x63\x62\xa9\x1b\xf9\x98\xba\xf1\x1c\x81\x39\x2e\x8c\x28\x33\x96\xa9\x70\x2b\xc2\x2c\xe3\xf8\xc5\xb7\x18\x2f\x53\x2e\x23\x95\xa0\xf4\xbe\x65\x1d\x94\x8c\x9d\xa3\x88\x68\x8f\x57\xe0\x1b\xe1\x21\xbf\xb9\x75\x30\xf2\x20\x48\xb9\xbf\x2e\xb6\x68\x9f\x89\x3d\xd6\x74\x3a\xde\x84\x69\x0d\x3e\x25\x02\xf0\xf7\x65\xbb\x44\xe7\x14\x4b\xf5\x3e\xac\xab\x72\x5e\xb6\x68\x8c\xa7\xda\xcf\x2b\xbd\x45\xd6\x41\x96\x35\x70\x25\x25\x46\xaf\x7b\xc8\xa9\xdd\x5a\x71\x39\x57\xbc\x09\xce\xd2\x08\xd5\x03\xe2\x11\x49\x47\x95\xd6\x6b\x57\x5a\x99\xaa\xac\xdb\x87\x45\x69\xe4\xac\x52\x0f\xed\x89\x78\x58\x95\xb5\x12\xb5\x7e\xb8\xa9\x61\xa9\xbc\x6b\x6c\x32\x97\x04\x97\x13\xc9\xd0\x5e\x39\xed\x16\x44\xb2\x5b\x10\xc8\x6e\x41\x1c\xeb\x08\x63\x63\x45\x31\x57\xfb\xad\x82\x1b\x05\x21\xb4\x75\x86\x41\x66\x97\x79\x4a\x4a\x56\xd9\xb4\x7b\xe8\xd8\x1e\x8f\xc7\x51\xf2\x5d\x9c\x61\x42\x9c\x87\xf0\xe1\x6b\x0b\x76\x37\x71\xc4\xfc\x51\xd4\xbc\x21\x04\xbb\x67\x49\xfc\x40\x6a\x9f\xce\x3e\xa2\x7c\x99\xcc\xd1\xb0\x8b\x4c\xc8\x99\x73\x52\xe7\x4e\x4a\xd8\x5e\x91\x8a\xd2\xfd\x77\x29\x1a\xd4\x48\x9f\x9c\x44\x4a\xca\xde\x5e\x8c\xe4\xfe\xe5\x0e\xff\x5c\xef\x70\x88\xd4\xff\xe5\x26\xff\x4c\x6f\xb2\x6d\xff\x4f\x5a\xaf\x8f\x13\x85\x2f\x33\x19\x24\x36\x8d\x2e\x17\xc7\x79\x4a\xd9\x28\xb1\xa9\x1d\xf6\x9b\xa2\xa0\x53\x8a\x68\x22\xfd\x87\xb1\xfc\x09\x1c\x7a\xcb\x5a\x30\xbd\x29\xea\xdc\xff\xa8\xb7\xe0\x4c\x07\x76\x51\xb4\x29\x20\x3a\x1f\x5e\xc8\x85\x04\x87\x8a\x76\xf9\xb5\x78\x29\x77\x33\xc7\x09\xa2\xb5\x3d\xb4\x35\x07\xea\x70\x99\x09\xb4\xb5\x9c\x18\xc5\xd9\xa6\x23\x05\x09\x0e\x40\x70\x64\x68\x69\xa1\x9b\x4b\x55\x88\x2b\xd5\x18\x42\x69\xc1\xde\xde\x30\x66\xd0\x4e\xe9\x7b\x5a\xca\x77\x4b\xd9\x82\x95\xc2\x3c\xd7\x0d\xbb\x42\x2a\xaf\xc2\xcc\x27\x28\xea\x0f\xb1\x4e\x14\xf8\x3d\xc5\xbe\x12\xf9\x0d\xcd\x9a\x55\x06\x3b\xfc\xfd\x79\x3e\x94\x3f\xda\xff\xe7\x96\xa4\x83\x3e\x0c\xba\x25\x8f\x12\xb7\x3a\xcc\x49\x81\x45\xa8\xe7\xc4\x81\x4e\x10\x7b\x97\x4f\x8c\x8b\xa4\x18\xcc\x1d\x57\x3f\x1a\x99\xd9\xd5\xf3\x65\xa3\x6b\xbd\x21\x7a\x0b\xf1\xce\x84\x08\x20\x0b\xe0\x61\x9b\x8d\xe5\x96\x37\xa8\x89\xf3\x06\x9b\x7d\xc3\x67\xf0\xd7\xff\xcb\x3e\x1c\xc7\x27\xb7\x3a\xa1\xce\x8d\xbd\xc6\x51\x63\x97\xf9\x1f\xf4\x5c\x79\xef\x13\x0e\x98\x9b\x2c\x7c\xac\xdb\xc0\xc8\x6c\x21\x33\xd7\xbf\xb3\x85\xac\x5a\xdf\x7e\x77\x58\xa5\x9e\x5d\xcf\x2a\x45\xae\x7f\x88\x3a\x1e\x1d\x3f\xb5\xfb\xf1\xcb\xc6\xf4\xdd\xf3\xf0\xc8\x00\xc0\xc4\x37\x95\x9e\x5f\x42\x2c\xc2\x84\x1c\x09\x10\xd7\xc4\x21\x92\x4e\x7a\x2e\xa6\xcf\x5a\x71\xa1\x29\xa2\xba\x51\xc0\x55\xe6\x50\x59\x63\x64\x05\x5f\xc0\xf3\xe0\x4f\x74\x3d\x57\x6b\x8c\x3b\x9a\x10\x74\xc7\xa6\xde\x96\xb5\xf7\x24\x47\x34\x4f\xf1\x7d\x70\x8a\xc7\xef\xde\x42\x01\x4f\x33\x42\xa4\x40\xd9\x89\x68\xb5\xc6\x0e\xb0\x24\x41\x0d\x98\xe3\xdc\x2c\x4f\xa2\x60\x84\xbe\x69\xa0\xba\x38\x73\x42\x3c\x17\x9f\x6e\x13\xce\x1c\x73\x07\xa0\x00\xe2\x1a\x3b\x0a\xe1\x01\x68\x93\x41\x17\x41\xd7\x92\x43\xa1\xdd\xcc\x1a\xe5\x33\x74\x07\xc4\xc3\xa9\x78\x9a\x8f\xbb\x99\x08\x89\x29\xb8\xa4\x77\xf0\xf4\xb1\x13\x84\x17\xc7\x72\x2b\x91\x2c\x12\x4f\x73\x42\xfc\x8c\x73\x3b\x74\xed\x48\xd1\xa8\x87\x78\x7a\x82\x8f\xe1\xa8\xa3\x9f\x59\xe5\x27\xa4\x27\x73\x80\x33\xd8\x62\x1f\xd7\x98\xf3\x54\x71\xa7\x98\xce\x6e\xfe\x94\xde\xbf\x1f\x5c\xc9\x72\x5e\x78\xa1\x19\x40\x19\xa6\x65\x69\xd4\x7c\xd3\x98\xf2\x4a\x55\xbb\x3b\xf2\xc7\xeb\x06\x1b\xc5\x97\x8a\xe2\xc4\xb4\x58\x6d\x10\x3e\xb0\xcf\x83\x78\xea\xd2\xa3\x35\x6e\x0e\xe4\xbe\x12\x2e\x05\x3a\x7b\x95\xad\xa8\xb5\xa8\x74\x7d\x01\xc2\xf0\x23\x97\x5c\x90\x6e\x93\x17\x25\xca\x96\xdb\x35\x47\x06\xf0\xa0\xf3\x4c\xe9\xf2\xc6\xc0\x05\xb2\x93\x83\x78\x2b\x29\x16\x8d\x32\x4b\x77\x2d\x31\x2f\x1b\x16\x6c\x94\xd9\xac\x5c\xc1\x20\x0a\xa3\xbb\x72\xb5\x13\x3b\x4b\xd8\xa3\xc7\x19\x74\xbf\x76\xaa\xf0\x0c\x38\xf4\xa1\x8f\x1f\x45\xc6\x61\xa5\x97\x45\x20\x46\x84\x9f\xdd\x9c\xf0\x91\xa0\x9b\x38\xf8\xc4\xa6\xf5\x28\x49\x0e\xef\x21\x52\xe0\x66\x10\x53\xce\x98\x3c\x46\x70\x49\xb6\x46\xf4\x73\x1e\xf7\x28\xef\xfa\xd2\xb9\x79\x88\xe7\xfd\x7d\x24\xd4\x1d\xbb\xde\xa6\x21\x88\x16\xdc\x6a\xb3\x02\x03\xb1\x56\x5e\x31\x00\x6c\x20\x28\x07\x3a\x2f\x8d\x97\xe9\xf3\xbe\xbf\x1e\x57\x3d\xf2\x43\xf3\x2e\x46\x83\x1e\xbf\x8e\x00\x0c\x0e\x75\xbf\xd3\x6f\xaf\xc7\xef\xfe\xa0\x8a\x54\x2d\xfe\xb8\x66\x28\xe4\xed\xb2\xd1\xdb\x9a\xc7\x3c\x22\x01\xa1\x98\xc7\x7b\x8c\x6b\xe9\xba\x07\x53\x70\x06\xa0\xfc\x24\xa6\x0a\xa0\x31\x5b\x70\x3a\x5f\x00\x08\x10\x3e\x8f\xe4\xde\x26\xdb\x56\xad\xd6\x2d\x21\xb7\x83\xc5\x14\x0e\x5e\xc9\x6c\x06\x59\x17\x46\xc5\x9d\x1c\x93\xb0\xf6\xc8\x4b\x65\xc1\x11\x16\xe3\xfd\xe6\x4b\xce\x8b\xf5\x38\x30\x64\x56\x6b\xb6\x69\xb9\x21\xc6\xe9\x12\x36\x75\xd9\x7a\xc0\x29\x5c\x81\xb9\xac\x79\x63\xe4\x8b\xdf\x13\x61\xea\xb3\x3b\x1e\x99\x40\x84\xb9\xcc\x3e\xe5\xc7\xc1\x61\x2b\xc5\xc7\xa1\x63\xad\x61\xb8\x34\x9f\x11\xef\xf8\x19\x7f\x22\x77\x00\x10\xe2\x86\x53\x2b\x69\x99\x1e\xff\x72\x4e\x23\x1b\x58\xad\x43\x63\x9d\x17\x56\x79\xe0\x38\x4e\x3a\xec\x5e\x78\x6e\xe3\x3c\xf6\xd8\xe6\x6c\x4b\x1c\x18\x73\xdf\x3f\xb0\x07\xf8\x9c\x2f\x20\xd5\x40\x07\x80\xfe\x0e\xde\xbb\x31\xc7\xdf\x2d\xf0\x56\x61\x20\xb8\xe7\x15\x33\x97\x02\x06\x88\x67\x23\xf2\x59\x00\x73\x78\xd8\x2b\x8f\x22\x66\x78\x9c\x63\x06\x29\x6c\xcf\x51\xe8\x0b\x70\xe8\x92\xb8\xf1\x81\x0d\x39\x1e\xdc\x91\xbc\x03\x58\xf1\x5b\x0a\x35\x1b\x13\x69\xd6\x5d\xa0\x6e\x58\x84\xe7\x5e\xa2\xf0\x1f\xcb\xdc\x89\x67\x1f\x4a\xce\x51\x73\xfd\x5c\x84\xfa\xeb\x1f\x90\x4d\x42\xca\x72\xce\xdb\x31\xcb\x54\xe8\x5a\x39\x0e\xd4\x03\x0b\x0a\x78\x46\x3d\x5c\xc0\x66\xed\xd4\xdf\x68\x89\x0f\x8f\x5c\x04\x84\xe6\xc2\x06\xb2\xe0\x68\xa2\x3f\x3e\xa1\x8b\xe1\x26\x86\xbd\xcb\x3d\x4b\xb3\xd9\xe3\xc9\x9e\x3a\xa0\x47\xe5\x4f\xb2\x9e\xde\x59\xce\xed\xeb\xd8\x23\xdd\x9b\x12\x58\x8e\xaf\x4f\x1e\x32\xd3\xb6\x13\x0b\x2d\x7d\x82\x1c\x70\x75\x20\x94\x53\xda\x03\x4f\x3f\x30\xdb\x5c\x11\xf9\xd2\x0e\x53\xb5\x20\x5f\xbe\x20\x28\x41\xc7\xb5\xa2\xad\x99\x81\x50\xa8\x0f\x65\x4b\xc3\xd8\x18\x40\x4f\x2c\xe8\x46\xef\x57\x61\x8b\x1b\x19\x11\xdc\x10\xdf\x2a\xd9\xcc\x97\x1e\x45\xde\x3d\x08\x09\x4d\xbd\x97\xa1\xed\xec\x00\x9c\x9e\x8a\xd7\xd2\x18\x64\xc4\x3b\xe9\x97\x4e\x62\xa6\x2a\x4d\xe7\x93\x30\x5e\x3c\x67\x4f\x8e\x27\x4b\x52\x09\xc5\xa3\xf8\x23\x66\xca\x25\xe8\x3d\xc4\x02\xf7\xe2\x24\xe0\xf4\x78\x71\x83\xe4\x53\xb4\x62\xa1\x5b\x14\x20\x45\x2e\xb5\x69\xb9\x3c\xee\x12\xc5\x5a\xda\x5c\x02\xb8\x08\x24\x5b\x2e\x5b\x03\x4e\x5a\xec\xe5\xac\x41\x1d\x47\xc8\xe7\xd2\x60\xea\x44\xd7\x14\x25\x2d\x0c\x86\x33\xec\xd2\x72\xe4\x10\x70\x6f\x70\x1f\x2c\xc7\xb1\xb9\x58\x32\x7f\x47\xc3\x12\x12\xfa\xa3\x06\x59\x09\xcf\xb3\xb9\x42\xd9\x0e\x2d\x62\x3c\x69\xd7\x4c\x69\x9e\xf3\x78\x8b\x1d\x6b\x37\x4d\x53\xef\xec\x37\xf0\xf0\xb8\x88\x3f\x2c\x3e\x21\x3e\x01\x42\x3c\xe1\x41\x86\x48\x40\xff\x1e\x6f\x43\x02\x4d\x72\x2e\x03\x1e\x90\x54\x2d\x0e\xcf\xa2\x8c\x12\x1e\x6c\x75\x63\xda\x87\x00\xa7\x64\xe6\xaa\x96\x4d\xa9\x7d\x24\x36\x35\x43\xc6\x4d\x58\xb3\x99\x0a\x30\x77\x37\xe6\xa5\xb2\x6a\x40\xc4\x38\x2e\x54\xb4\x98\x5d\xaf\x67\xa7\xe7\xb3\x25\xb9\x76\x2f\xec\x45\x8f\xe6\xd5\xd6\xf0\x7b\x09\x59\x30\x7c\x12\x86\xf8\xf1\x4b\x52\xa9\x43\xbd\x6c\x9e\x5e\x16\x29\xe6\xca\x4f\xbb\x98\xac\x7d\x71\x63\xec\x39\x4d\xaf\x69\x17\xae\x2a\x77\x1d\x3b\xa9\x3e\x6a\x0c\x35\x8b\x2a\x9e\x9e\x8a\xe7\x79\xe6\xed\x7e\x54\x8e\x13\x9b\x4e\x3a\x62\x4e\x27\xd2\xb1\x7d\x4a\x55\x93\x9d\xb5\xee\xde\x1b\x1a\xd8\x3b\x2b\x87\x06\x66\x0b\xc0\xd6\x28\x13\x47\x32\xd6\x7b\x23\x06\xca\x1c\x5c\xb3\x37\x0f\x56\xa7\x3b\x06\x7b\x21\x7c\x9b\x65\xc8\xd1\x03\x40\x08\x4e\xb1\xd6\x82\x0f\x40\x5c\xd3\x27\xbe\x0d\xb0\xc1\x1b\x0f\x15\x36\xc1\xc7\xcf\xd9\xfa\x79\x76\xaa\xb8\x15\x12\x7b\xf0\x54\x87\xfa\xac\x6f\xf4\xe3\x06\x6d\x26\x5d\x48\xa4\x6f\x69\x3b\x91\x9a\x94\xaf\x43\x00\x30\xcb\x3b\x4e\x46\x4c\x69\xb2\x92\xf1\x4c\xe9\x9e\xc7\x2a\xc4\x00\x49\x48\xd9\x52\xb4\x30\xe0\x61\x90\x0e\x90\x2f\xb4\x5b\xe5\x01\x00\x5d\x1f\x7b\x38\xcd\xec\x18\xd0\x2d\xc8\x9a\x11\x20\x80\xbc\xb7\xb0\x03\x02\xc6\xf4\x13\x91\x18\x1e\x37\x25\x85\x29\xeb\x8b\xca\xcf\x68\x4b\x5e\x6d\x9e\x97\x2b\x75\x9d\xae\x67\x3e\xf0\x90\x53\xa2\x7c\x91\xe9\x52\x1a\x3c\x83\xa0\x51\xb2\x17\x24\x30\x54\xbc\xfa\x70\xed\x50\xe9\xe4\x24\xdd\x4e\xdc\x2a\xa3\xf9\x9e\xf8\xb7\xd0\x1d\xc1\xe9\x75\x4e\x40\x90\xb9\xa8\xd9\x80\xba\x4c\xe2\x12\x38\x0f\xf8\xed\x7d\xf8\xdf\xff\xf9\x5f\x80\xc0\xa8\xd4\xda\xf2\xef\x41\x69\x8b\x7f\x3a\xac\x4d\xf8\xd4\xc3\x93\x24\xa3\xa2\x87\xc2\xfe\xaf\xfb\x44\xc4\x71\xc3\x0b\x91\x93\x78\x39\x46\x4f\xe1\x51\x8e\x18\xc4\xb6\x5e\xb8\x1b\xc8\xf2\x9c\xc5\xe9\x4c\x3d\xbe\x64\x68\xcb\x6c\x66\x46\xfd\x6d\x63\x79\x47\x3a\x85\xce\x81\xd4\xc5\x63\x8c\x5a\xc0\x69\x47\x8f\xc2\x03\x36\x73\xf8\x37\x99\xa8\x4e\xb5\x15\x6f\x55\x9b\x2a\xab\xba\x65\xa7\xb2\x28\x3a\x5a\xf7\x70\xd5\x82\x1d\x60\x53\x1b\xb9\x50\x42\x6f\x5a\x96\xe3\x19\x9d\x74\xd0\x67\xc1\xa9\x85\x81\x32\x98\x29\x97\xf4\xc4\xaa\xbc\x58\x82\x7b\x78\x86\x88\xa0\x34\xee\x49\x00\xdc\x6f\xa4\x0b\xdc\x2f\xc3\xbe\x13\xa5\xc1\x04\x89\x0e\xad\x82\xce\xef\x5a\xb6\x4b\x86\x94\x8e\x9e\xbe\x2b\x09\x7e\x5a\x80\x94\x3a\x9f\x6f\x9a\x38\x3c\xee\x9d\x6d\xc2\xb5\x27\xe7\x73\xb5\xc6\x44\xdc\x17\xe5\x15\x69\x06\x66\xaa\x56\x0b\x54\x3b\x61\x3a\x39\x88\xf3\x34\x96\xd7\x5d\x61\x52\x6c\xcc\xa2\xc2\xf8\x97\xf7\x9d\xc4\x9d\x17\x0a\xff\xfa\xb8\x28\x54\x5d\x6c\x56\xdf\xec\x62\xbd\x2b\x8a\x0a\x8c\x2b\x3c\xcb\x36\xd7\x9b\xdd\x8b\x57\x1c\x71\xa4\x03\xfc\x19\x9c\xce\xc0\x10\x9a\x56\x03\x19\xb6\x2c\xdd\x45\xa5\x67\x92\x21\xea\xad\xe4\xda\xd6\x65\xde\x29\x18\x03\x9e\xa4\xcf\x03\x94\x36\xe8\xe8\x52\xf1\x84\x74\x71\xa4\x78\x17\x1d\xce\x67\x1c\x5f\x69\x03\xaf\xa8\x21\x7a\xf5\x52\xae\x71\x40\x6f\x55\x7b\x86\xe9\x81\x25\xfc\x08\x1c\x69\xcb\x34\x66\xe8\xa6\xe3\xf2\x24\x92\xef\x1c\x4f\x33\x0c\xd3\xeb\x3e\x92\x19\xcf\xa2\xdc\xed\xea\x06\x54\xab\xad\x1d\x48\x4f\x18\x5f\x54\x9c\xd2\xfd\x52\x43\x7c\xf3\x1e\x25\xfb\xdb\x97\xfe\xf5\x51\x7a\xac\x92\x9c\xad\x8f\x48\xac\x8e\x7f\x75\x7c\xcf\xa3\x1c\x8b\xf9\x75\xa0\x34\x9e\xb3\x25\xa9\x7e\x28\x21\x6c\xae\xad\x81\xec\xb3\x8f\xba\x3f\x65\xf2\xc5\x3e\x0a\x7f\x75\x8b\xe9\x8f\x72\xbc\xf0\x53\xa3\xda\xe3\xa0\xdf\xca\x64\x0f\x16\x98\x72\x9b\xad\xf8\x9e\x04\xc5\xc1\xf3\x7e\x0e\xcc\xfa\xb1\x4a\xa4\xb2\xd7\x04\x0c\x88\x36\xd1\x72\x91\x11\xb9\x91\xc3\x30\x51\x0c\xcd\x63\xaa\x60\x69\x10\x00\xe8\x10\x28\x61\xa6\x01\x12\x9b\xec\xd9\x66\xc9\x55\x91\xc0\xc5\xed\xc6\x29\x19\x55\xf7\xf0\xed\xe5\xd5\x0a\xb5\x50\x8d\x8b\x59\xa2\xdc\x63\x1b\x9f\x25\x2f\xc2\x22\x0f\x76\x6c\xf0\xc1\xc0\x8c\x13\xac\x45\x8a\xb2\xb7\xf4\x3e\x92\x77\x03\x4a\x47\x2a\x80\xf5\x40\x36\x0c\xa0\xc3\x67\xe0\x1d\xd2\x47\x2d\xc2\x06\xce\x72\x4e\xc9\xeb\xe6\xf6\xbb\x1b\x69\xf1\xad\x15\x6a\xb7\x25\x00\x22\xb9\xa8\xae\xb0\x3e\xb5\xcb\xc3\x2b\xb8\x9b\xe0\x0b\xe2\xee\x3d\x0e\x6a\xad\xe6\xca\x18\xbb\x6e\x3d\x76\x9f\xaf\x6d\x9d\x32\x8a\x53\xf3\x82\x75\x70\x54\xc0\xe7\x94\xac\xde\x21\xff\x89\x64\x38\x8e\xeb\xa6\xd4\x4d\xd9\xee\x26\xbc\x29\xc7\xc1\xce\x35\xf2\xaf\x0e\xbb\xb2\x96\x15\x4a\x31\x5f\xfb\xd2\x59\x7c\x8d\xcc\x4a\xd1\xff\xe9\xa5\x75\xdf\xcf\xb8\x08\xdf\x83\xb1\xd1\xe7\xa6\x5a\xeb\x48\xe2\x02\xe3\xc2\x24\x31\x31\xc3\xd9\x0f\x04\xdb\xb1\x2e\x7b\x0c\x57\x9f\xb8\x52\x33\x1f\xf3\xd1\xf1\xf3\x89\x52\x6a\xfa\x8d\x4d\x48\x3e\x71\x6d\xe1\x19\x09\x13\x70\xf9\xf1\x83\xbb\x28\x25\x0e\x70\x0d\xb6\x5a\x84\x3c\x92\x89\x4b\x39\x0d\xb5\xc7\xbb\x15\xa5\x89\x98\x06\x5a\x41\x20\xe4\xf4\x84\xbf\xf5\x09\x12\x3d\x15\xb9\x08\xd1\x5d\x9f\xae\xc6\x2a\xbb\x3e\x1d\x86\xf3\x90\x15\x72\x4d\xb1\x0c\x0b\xfb\x56\xa8\xd3\x5f\xb4\x46\x1d\x96\x76\xfc\x2a\xf5\x57\x1d\x5e\xa7\x1c\x58\xb3\x47\x23\x7e\xde\x49\xd3\x9a\xb0\x04\x29\xb4\xe8\x5e\xf7\xe6\xb4\x81\x64\x73\x2f\x54\x9b\xf6\x7e\x96\x7d\x43\xff\x7c\x84\xfe\x45\x47\x7f\xe9\x2b\xdf\x19\x8e\xe8\x51\xa8\xc5\xf5\x33\xcb\x1b\x93\xf4\xb8\xb8\xcf\x55\xd1\xad\x1f\xd9\x91\xae\x3d\xed\xeb\x4c\xbd\x07\x7a\xea\x7e\xb2\x1e\xf7\x87\xcc\xa6\xaf\x34\x49\x31\x0b\xdd\x90\x30\x91\x31\x5e\xdf\xba\xc9\xd4\xa5\xeb\x48\x16\xb5\xe5\x09\x3b\x40\x69\x12\x6b\x3e\x03\x82\x7e\xa2\xf5\x4c\xda\x61\xfa\xcf\xa4\xc6\x42\x47\x1c\x6e\x97\x79\x8d\xd6\x6e\x1a\x7f\x0d\xeb\x7e\x16\x85\xa7\x3f\xae\x2a\xa2\xfe\x3c\xd7\x39\xba\xc9\x73\x43\x92\xcb\x0f\x3c\xdb\x31\xa6\x26\xd2\x84\xfb\xf7\xdb\x47\x64\x87\x33\xdc\xab\xb3\x8d\xf7\x7b\xea\xb2\x6f\xd7\x0b\x7d\x92\x46\x49\x9e\xf1\xb5\x75\x9a\xce\x38\x8f\xec\xa8\x97\xb1\xf7\x75\xcb\x0c\x25\xc7\xfb\xc4\xa3\xa1\xfc\x72\x6c\x1c\x9d\x73\x4a\xb9\x84\x21\x0c\xf3\xb6\x0f\x67\x78\x8c\x63\x9a\x99\xfa\x56\x36\x7a\x65\x1f\x05\x4e\x28\x9d\x05\xa0\xd1\xab\x08\x84\x28\xd2\xf7\x87\x65\x73\xc7\xde\x29\x9c\x3b\xd9\x69\xfa\x8e\x3b\x24\x54\xa5\x91\xbc\xc6\x64\xf1\x8d\x53\xa0\x87\x32\x49\x6e\x07\xbf\xc9\x7d\x0d\xf2\x9c\xb1\xa3\x1b\x8b\x4f\x8c\xe8\x24\x88\x1d\xdf\xd2\x6b\xdd\xb4\xb2\xba\x41\x5b\x1c\xb3\x10\x77\xe2\xfc\xdc\xde\x9c\xae\xc6\x12\x3f\xa4\xc8\x2f\xc1\xfb\x9f\xbc\xc1\xe2\xde\xe2\xbe\x52\x16\x3c\x8e\x78\x8f\xaa\xfa\x54\x1a\xfd\x6a\xbf\x2c\xe2\xfd\x7a\xd3\xaa\xc7\x66\x57\xcf\x83\xab\x1c\xcf\x48\xf6\x07\xaf\xeb\xf1\xb9\xda\x2a\x6d\xd9\x90\x72\x05\x99\xc5\xd1\xa6\x0d\xf9\x99\x63\x10\x2d\xf1\x3d\xba\xe4\x34\x96\x3a\xc5\xac\x1e\xe6\xc6\x03\x5b\x86\x4b\xd6\xd8\xea\x0b\x65\x65\x0b\xef\xc1\x4c\xae\x35\x5e\x5f\x46\xc0\xcb\xff\xf1\xdb\xdf\xfc\xe6\x37\x2b\x33\x15\xbf\xfd\xdc\xfe\x5f\xac\xe4\x87\x4e\x84\x9f\x83\x8a\x53\x73\x59\xcd\x37\x95\x6c\x15\x8b\x5a\x70\x62\x51\x9c\x0c\xf2\xa5\x15\x9c\x6c\xd3\xe1\xe3\x6c\x33\xbf\x54\xed\xdb\xf2\xdf\x15\x7c\xfc\xdc\x7d\x73\xec\x68\x9a\x9c\xf7\x1b\x28\x7f\xcc\xc6\x30\x89\x3a\x98\x44\x2d\xe6\xb9\xa5\x7c\xba\xdf\x6e\x46\xfb\x0e\xe2\x56\xca\x2b\x75\xd3\x5c\xde\xcf\x80\xe0\x91\x7f\x99\x0b\x4d\x67\x3b\xe8\x3c\xbf\xb7\xd2\x08\xa3\xbc\x5f\x65\xa7\xdf\x4e\x3f\x1d\x99\xc7\x7b\x76\xc4\x7e\x7b\x7d\x42\xb0\x4f\xf6\x93\xcb\x53\xd0\xd1\x89\x1a\xe6\x7f\x05\xb9\x3e\x9d\xc0\xc7\xdb\x9b\xed\x1c\xad\x0f\xc2\x69\x67\x22\x6f\x77\xf5\x7c\x48\xf0\x75\x83\xea\x91\x58\xdd\x48\x30\xf8\x25\x92\x41\x31\x6f\x67\xe4\x58\xe5\xad\xee\x84\x00\x4f\x19\x14\xc8\x36\x5c\x0c\x0c\xb3\xcf\xb1\x75\x5f\x70\x95\xe5\xb8\xf6\x6f\x33\xe6\x79\x43\xdd\x08\xa4\x45\x70\x56\xbb\xd0\x50\xc7\x1f\xe8\x89\xbb\x63\x42\x82\xe6\x21\x8b\xa5\x47\x3e\x39\x9d\x1c\xba\x0f\x1e\x88\xfb\x24\x48\x38\x11\x9c\xce\x11\x26\x85\x01\xba\x44\x4b\x9f\xfa\x02\x04\x33\x3d\x4b\x0b\x7b\xfd\x0d\xf6\xcd\xd5\x51\x9e\xd9\xfe\x06\xfb\x48\x67\x37\x2c\xcc\xd3\x8c\xae\xef\x71\x12\x31\xc6\xd2\x7f\xe3\xb2\xf4\xb9\xe1\x3b\x4c\x0f\x56\xe1\xc5\x6a\x5d\xe5\x2b\x4d\xd0\x48\x94\x21\x39\x63\xeb\x97\x26\x46\x18\xf5\xa3\x98\xeb\xa6\x70\x29\xe4\x71\x9f\x3c\x4c\x37\xbf\xed\xf7\x93\x06\x40\xa8\x74\xcc\xf7\x1e\x67\x83\x84\xe9\x5e\xa4\xbc\xb6\x2b\xb7\x75\x59\xf1\x89\x6b\xa3\x63\x73\xec\xea\xe6\x1d\x92\x39\x3f\x15\x80\x47\x86\x19\xaa\xd3\x53\xf1\xbd\xac\x2e\x99\x53\x0c\x1a\x57\xb8\x57\xa4\x04\x70\x24\xe0\xaa\x95\x9c\x2f\xa1\x8f\x23\xa6\xdd\x1f\xb8\x26\xc0\x45\xe4\x70\x3d\x43\xd0\x5f\xa6\x44\x7f\xbc\x9f\xc8\x96\xef\xf3\x84\x4f\xd9\x9b\x3d\x32\x6b\xb7\xd8\x88\xa1\xf7\x96\x1d\x9a\x84\xd8\x53\xb7\x6f\x42\x79\xb4\xe9\x98\x3d\x1a\xe7\x10\x93\x77\xd2\x60\xe0\x32\xc3\x6e\x30\x2c\x72\xe6\xc1\x03\xaa\xc2\x63\x2e\x1e\x3c\x48\x89\xcc\xef\xfb\x09\x7e\xc6\xae\xcd\xe3\xac\xa0\x75\x1f\x4c\xd1\x06\xe7\x50\x36\xb5\xfd\xc1\x98\x39\xe2\x18\xd9\xfd\xc5\xf1\x70\x52\xdc\x93\xa4\xa9\xd4\x01\x74\x11\x63\xfd\x88\x04\x21\x4a\xe4\xd2\x61\xc7\x1f\xb3\x89\xb4\x93\xfa\xc3\x09\xb0\xf3\x5d\x37\xea\x6f\x1b\x65\x10\x1f\x3a\x1b\x0f\x35\x18\x6e\xf8\x43\x67\xb5\x6f\x42\x01\xf1\x8f\xa7\x6f\x48\xd8\xbe\xad\xbf\x73\xb1\x6b\xc4\x1f\xf6\xaf\x63\x17\x75\xab\xff\x72\x1c\x24\x3e\xe4\xf5\xe3\x11\xbb\xda\xf7\xc4\xd8\xf7\x78\x02\x9e\x52\xd9\x60\xb4\x3c\xeb\x1e\xc4\x92\xb7\x9b\x99\x3d\x65\xad\x07\xeb\x07\x36\xcb\x68\x51\xb6\x62\x51\x42\x0e\x1d\x30\xc0\x7f\xf1\xf9\xac\x6c\x8d\x27\xf5\x2b\xe3\xb2\xdf\x8b\x87\x21\x23\x3e\x4e\xef\x80\x3c\xf8\x2b\x73\x12\x09\x03\xd9\xaa\xdd\x69\x81\x69\xa9\x51\xfe\x69\x5a\xd4\x9c\xa9\x77\x61\x5a\xcf\x32\x29\xea\x7b\xf8\xec\x5c\x36\xfb\x61\xbe\x84\x5b\xfe\x9c\xda\xd8\x7f\xfc\x24\x16\x65\x0d\xca\xa2\x1f\x3a\x0c\x7f\xe8\xa0\x77\x9c\xbd\xa7\x24\x30\x71\x77\x33\xe5\xc0\xdb\xfd\x88\xd3\xf3\x6a\xfe\x67\x21\x65\xde\x4c\xa1\x4e\x0e\xa9\xe5\xb6\x29\xdb\x16\x73\x5f\x94\x0b\xcc\xfc\x64\xd0\x2b\xb5\x2a\x17\x21\x6f\xd8\x3d\xc2\x4e\x44\xc7\x50\x33\x15\x2f\x92\x9c\x42\x92\xd2\x39\x3f\xdc\xac\xa7\xd4\xf3\x9f\xca\xfa\x52\x15\x0f\x1d\x1c\x29\x20\x65\xf0\xc4\xe8\x8e\x27\x2b\x12\xe2\x69\x0b\x54\xb2\xef\x7b\x48\x90\x4e\xf1\x15\xbe\x58\x37\x4f\xfa\x1b\x6f\x70\x4b\x3e\x59\x92\xfb\x1c\x81\x83\x32\x9d\xb3\xaf\x03\x14\x19\x62\xe1\x28\x9a\xfd\x69\x89\x25\x55\xda\xd1\x52\x9a\xef\x1c\x2c\x48\x27\xa0\x04\x43\x1e\x92\xaf\x51\x7a\x78\x17\x2c\xdf\x99\xfc\x37\xb2\x9d\xdb\xdd\x74\x22\x5f\x26\x45\xfc\xac\xaf\x88\xcf\x14\x4f\x29\xfa\x58\xda\x3c\x78\x3b\x17\x96\x5c\x29\x08\xd7\xb0\xfb\x56\x2b\x63\xcf\x01\x29\x41\xa8\x83\x57\xcf\xde\xbe\x7b\xf6\xf4\xfd\x77\xaf\x9f\x3e\x7e\xf7\xec\xfd\x9f\x5e\xbc\x7c\xf1\x8e\x29\x27\x70\x11\x6d\x35\xec\xfc\x09\xf8\x2d\x9f\x93\x92\xdb\x7e\xb5\x94\xf0\x8f\x6a\xd3\x94\xa6\x2d\xe7\xcf\x75\x13\x3d\x91\xbf\x75\x63\x64\x0f\x1c\x8b\x5f\x26\x7f\x14\x47\xb4\xd1\x6d\x1a\xa0\xe7\x25\xf2\x14\x8d\x9a\xab\xf2\x0a\xb2\xbf\xb0\x54\x06\x10\x5b\x70\x64\x00\x58\x5d\x47\x7e\xce\x60\xb7\x92\x00\x79\xe7\x03\x83\x65\x2b\x8c\x5e\x29\xb1\xd6\x65\xdd\x7a\xb4\x98\x4d\xbb\x69\xa0\x31\xf6\x0a\xec\x79\x83\x23\xb8\x8c\x74\x49\xbe\xca\x2d\xe4\x09\x0f\x9b\x4c\xb4\xbd\x2f\xe5\x87\x72\xb5\x59\x39\xb6\xbd\x50\xeb\x76\x29\xfe\x7f\xf2\xfe\x75\xbd\x8d\x1b\xd9\x17\x87\x3f\xbf\xba\x0a\x38\x93\x84\x52\xc2\x83\xe5\x24\x33\x13\x29\x4a\xb6\x22\xc9\x89\xd6\xb2\x25\xbf\x92\xec\xcc\x6c\x27\xdb\x02\xbb\x41\x12\x51\xb3\xc1\xd5\x68\x8a\x62\x26\xbe\xf7\xff\x83\xaa\xc2\xa9\x1b\x4d\xc9\x8e\xb3\x66\xaf\x67\xfb\x83\xc5\xc6\xf9\x58\x28\x14\xaa\x7e\x25\xee\x32\x40\x5c\xf5\x06\x75\xd6\x8a\x0e\xf5\xb1\x02\x7d\x84\x4a\x2c\x04\xaf\x45\x0e\xd2\xe0\xa2\x80\x1b\xf5\x25\x18\x1b\xd3\x59\x14\x7b\x02\x22\x95\x82\x2a\xf2\xdd\x43\x5e\x7b\x08\x3f\xb4\x90\x73\x89\x98\xc1\xac\x5c\xce\xc7\x08\x2b\x1c\xaf\x99\x70\x85\x45\xcb\x4b\x07\x32\x66\x7b\x68\x82\xca\x93\xe5\x0e\x2d\xc6\x0f\x4d\xb5\x87\x0e\xb0\xa6\xc7\x5e\xd3\x3e\x50\xf9\x5d\x18\x0e\xd3\xc2\x27\x47\x59\xad\x21\x31\x60\x8a\x36\xe8\x4b\xea\x0a\x75\x15\x16\x5f\x06\xfa\xfc\xb6\xd8\x7c\x08\x0d\xf6\xca\xad\x50\xba\x73\xb8\xf0\x40\xcb\x5e\xd3\xac\x04\xc5\x4b\xfa\xc7\x4b\x10\xce\x14\xb1\x0c\x2d\x8d\xa9\x55\x89\x3e\x47\xc9\x5a\x3c\x62\xab\xdc\x7b\x8b\x48\xe4\xb9\x3f\x45\xb2\xd4\x76\x47\xef\x13\x1f\x5d\xa5\x96\x82\x9b\x27\x44\x73\x33\x2b\xd5\x8a\xdf\x40\xa7\x07\xa4\x72\xb2\xcc\x2a\xc1\xb5\x17\x6a\x45\x4e\x3d\x5a\x73\xb8\x69\x8a\xc3\x19\xed\x2c\x21\xba\x6c\x36\xaf\x53\x5d\x15\x27\x05\x90\xe4\xe9\x0b\x3b\x34\x8c\xa7\xfb\x5d\x17\x61\x4b\xdb\x36\x38\x3f\xa3\x4d\x61\x55\xa9\x2a\x21\xca\xba\xe2\x65\xb6\x36\xb4\x80\x2a\x43\x99\xa1\x85\xae\x70\xc3\x1f\xe0\x24\x5b\xe4\x0c\x27\x65\xf4\x7a\xf7\x5e\x41\x06\x0e\xaf\x0d\xbe\x3b\xb0\x7d\x8d\x53\x30\x01\xf6\x03\xad\x89\xea\xc6\xd7\xc8\xb0\x78\xab\x5d\x3f\xee\x2a\x0d\xca\x1b\x0e\x87\xcb\xb2\x10\xe8\x71\xac\x72\xf4\x72\x89\xd9\x1c\xbf\xdc\x37\x67\x05\x42\x69\xc0\x73\x8e\xd3\xe0\x0e\xcb\x02\xcc\x42\x04\x67\x08\x94\x91\xe8\x76\x6a\x16\xc6\x79\x19\x80\x5c\x18\xce\xb1\x43\x8d\xa7\x49\x3c\x91\xd9\xfb\x41\xd4\xac\x92\xd0\x59\x93\x17\xe5\x3c\x3a\x70\x36\x27\xe7\xa4\x3f\x14\x8b\xe1\xdd\xea\x84\x1a\x5d\xf7\x83\x76\x6d\xe3\x8d\x28\xf0\xc6\x15\x48\xd1\x1f\x25\x78\xb2\xe0\x2c\x4b\x32\x6c\xa1\x15\x0a\x5c\x75\x2e\xf0\x3c\xb5\x69\x23\x8f\x4e\xfe\xa2\x76\x4c\x97\x14\x9b\x6c\x9b\xda\x08\x17\x8a\xc8\x45\x52\x93\xcf\x9f\xc8\x32\xff\x51\x4e\x67\x42\xd7\x2f\x68\xdf\xc0\x50\x87\x1c\xff\x2c\x8e\x27\xae\x24\xbc\x8b\x27\x52\x35\x99\xd4\x2e\xaa\x9e\x76\x58\x64\x19\xfa\x7b\x49\x7b\xa8\x56\x5c\xdd\x47\x2a\x49\x44\x58\xa5\xeb\xfd\x10\x74\xee\xa1\x94\x2e\x6d\xaf\x03\x0d\xf3\xa6\x9e\xe6\xea\x81\x02\x7b\x82\x10\x96\x81\x7c\xc8\xb1\x7b\x4d\xfb\x1d\x5c\xf3\x57\x01\xb4\x9f\x66\x95\xc8\x97\x39\xb7\x3e\x0c\x01\xc2\x18\xf4\x1c\xcb\x89\x7d\x01\x07\x2a\x60\x88\xd7\x2c\x2e\x0d\x6f\x47\xe0\x50\x1a\xf6\xae\xa8\x13\x47\x1a\xf9\x2b\xee\x33\x81\xef\x8e\x60\x7e\xb8\x12\xf8\x2e\x1a\x97\xe7\xda\x0f\xec\x74\x05\xca\xf3\xa0\x83\x19\x0a\xbb\x1e\x6d\xa7\xe7\x3f\xd4\x6f\xda\xb4\x92\xee\x33\xfb\xe7\xde\x1b\xa4\xf5\xd0\x8e\xb3\xfb\xe7\xf9\x9d\x0b\x40\x5b\xcc\x2a\x48\x33\x20\x09\x01\xa1\x95\xe2\x99\x21\x03\xf5\x70\x3c\xd1\x91\xff\x8e\x21\xee\xd9\x26\xc6\xa6\x2d\x66\x7b\x30\xeb\xd4\xce\xda\x78\xa7\x8f\x31\xc9\x6d\x17\xdb\xe5\xdf\xd3\x3d\xf4\xe6\xb9\xb9\x7f\x01\x88\x6a\xba\xab\x0f\xe8\x63\xe8\x9b\x04\xff\x3d\x8c\x05\x6b\xe7\x7b\xf0\x68\xa7\xc6\xa7\x55\xe9\x3d\xc3\xe3\x56\x69\xf7\xe8\xa4\x66\x2f\xb9\x93\xde\xa7\xfb\xdd\x64\xf5\x9d\x97\x5e\xd7\xfa\x89\xfb\x9f\x6c\x79\x27\xcb\x7d\xdf\x52\x78\xf8\x5c\x6d\xc5\x99\xba\xc6\x70\x53\x85\x89\xfe\x00\x38\x45\xea\x20\x8d\xb8\xdf\xae\x93\xe3\x9b\xd4\x21\x9c\x58\x30\x09\x36\xb8\x8f\x82\xac\x9e\xc6\x22\xaa\x28\x4b\xfa\x68\xbf\xf7\x90\x4b\x64\x4d\xde\x6d\xe2\xd1\x7c\xb7\xe5\xdf\x5e\x24\x5b\xf7\xac\x8d\x44\xf5\xd5\xc3\x16\x48\x52\x3d\xd2\x21\xef\x22\xc5\xb1\x57\x29\xa7\x24\xc0\x35\x8b\x1c\x0b\x23\x77\x5a\xbb\x27\x6e\xbc\xf4\xdb\xa2\x48\xf0\xc2\xae\xba\xa5\x4b\x7d\xbc\x79\xcd\xd1\x50\x42\xc4\x52\x03\x96\xa9\x65\x59\x0f\x5b\x62\xd8\x86\xd8\x2e\x16\xe4\x79\xe5\x92\x54\xf2\xf0\x38\x4d\x16\x77\x70\x90\x9a\x65\x3f\x51\x2d\x01\xce\xe7\x9f\xef\x77\xdc\x46\x11\x46\xcc\x49\xa6\x0c\x2b\x81\x2a\x6e\x20\x06\x1d\x76\x15\x88\x42\x32\x3f\x35\x6d\x41\x65\xa2\x81\xfb\xcd\xa4\x2d\x56\x2e\xb1\xec\xdb\x92\xff\x26\x0f\xbd\x9d\x3b\x66\x31\xbc\x02\xe0\xe6\xed\xb3\xbc\x48\x3c\x8a\x84\x09\xe7\xb2\x3c\x69\xbc\xd1\xfb\x12\x03\xd1\x66\x1e\x80\x51\xfc\xa7\x10\x0b\x07\xb4\xa6\x4a\x82\x57\x76\xf0\xa1\x2d\xbf\x1e\x80\x41\xe2\xd1\x45\x57\xe4\x61\xc3\x16\x17\x22\x8e\xe2\x98\x77\xf2\xff\x01\xd3\x2e\x4a\x3e\x2e\xc4\x4b\x0d\xae\x2d\x65\x39\x3d\x7c\x71\x6a\x96\x8c\x6b\x72\xb7\xe3\x79\x2b\x03\xee\x9e\x8b\x6f\xee\x51\xf9\x42\xf5\xb9\xe4\x2d\xc8\x55\x10\xcb\xcc\x02\xc0\xd4\xae\xc5\xde\xdd\x9c\x86\x8b\xc7\xd6\x94\x25\x90\x7c\x3b\xfa\x75\xc0\x5a\x99\x77\x40\x77\xa6\x25\x23\x4f\xde\x2c\xe9\xc6\xdb\xe8\x45\xbf\xbb\x46\x37\x5e\xe6\xae\x4f\x98\xa0\x48\xb8\x68\xb1\x7b\x41\x4f\x88\xf2\xbb\x61\xfe\x63\x52\x18\xe0\x0b\xc1\x75\xdd\x6b\x13\x9d\x48\x80\x2b\x31\x6b\x8d\x97\x21\x84\xad\xb3\x11\xb6\xde\xc6\x9d\x7b\x70\x44\x8a\x69\x7b\xa5\x29\xc4\x04\xad\xd5\x99\x5e\x4e\x26\x32\x93\xa0\xa7\xe1\xe4\x39\x01\x59\x8e\x84\x0e\xdc\xd7\xc0\x10\xad\x50\x82\x90\x15\x78\x7f\xe7\xa9\x8a\x40\xb5\x48\x39\xd1\x0b\x29\x01\x93\xab\x7b\x2d\xdf\xf3\xb2\x62\x29\x53\xec\x6b\xc7\xf7\x46\xdd\x8a\x2a\x34\xbc\x02\x85\x2b\xdb\xdc\x61\x20\x0b\xef\x5e\xae\xff\x57\x0a\x12\x9c\xe8\xb9\x10\xbc\x1c\x58\x4c\xa9\xd6\x0b\x4d\x18\x98\x7c\x15\xea\x24\xfa\x6e\x68\x5a\x6f\x46\x29\xdf\xc6\x5f\xb2\x83\xc6\xdb\x91\xed\x5a\xe7\x8b\x12\x30\x31\x9b\xde\xa3\xcc\x3f\xb4\xd7\xa2\x3a\xba\x84\x28\x5d\x92\xaa\x6e\x38\x56\xff\x12\x97\xba\xab\xb6\xca\xfb\xef\xc3\x65\xc5\x51\x8f\x5e\x0a\x63\x68\xd6\xf8\xa9\xc1\x30\x3a\xa0\x79\x07\x0b\x5e\x55\xf0\x6e\x3c\x6a\xc3\x89\x3b\xb9\xc4\x0b\xae\x75\x24\x78\x03\x4b\xe8\x6a\xba\x44\xae\x47\x05\x6f\x4e\xd6\xf5\xbd\xf9\xdd\x25\x9d\xfb\xa6\x5b\x65\x38\x21\xfd\x74\x2d\x0d\x05\xdb\xa1\x27\x71\xcb\x2a\x86\x61\xa1\x08\x3b\x4a\xdb\xe1\x71\x2b\x29\x77\xb7\x54\xc7\xb9\x11\xb4\xd6\xa6\x75\x43\x4a\xdd\x68\x4d\x7c\x39\xb9\x47\x8e\x9d\xa5\xfd\xb5\x77\x1b\x87\xde\x5f\x63\x73\x70\xee\x01\x1c\x8e\xc5\x60\xf7\x8e\x96\x3d\x58\x6e\x45\x40\x96\x1d\x1c\x24\x3b\x6a\x8f\xd1\x1f\x1e\x83\x77\xc2\x6c\x6f\xad\x95\x37\xef\xb2\x58\xde\xfc\x8f\x59\x2d\x6f\x3e\xd4\x72\x69\x8d\xcf\x3b\xad\x97\xfb\x07\xec\xbe\x05\xe3\x8c\x2d\xdd\x39\x64\xf8\x15\x44\xbb\x94\x73\xd1\x14\x6d\x4e\x10\xee\xc2\xea\xb4\x37\x21\x71\xba\x81\xf5\xa9\x84\x4b\xb0\x80\x07\x2a\x66\xce\x7a\xb7\x62\xdb\xde\xec\x3e\xc4\x7c\x24\xe7\xc4\x2d\x23\xc7\x4d\x05\xcd\x79\xce\x41\x5f\xdd\x81\xaf\xe9\x68\x65\xb5\xfc\xfa\xda\x71\xb1\x30\xcf\x6e\xd5\x31\x43\x5c\x9b\x08\x3b\x89\xc5\xf0\x26\xb5\x15\x58\x0c\xa6\x95\xba\x69\x77\x68\xa6\x58\x95\x9d\x9f\x66\xa2\x0c\x2f\x41\x7e\x6f\xf6\x49\x6f\x21\x53\x65\x26\x0b\x51\x31\xae\x6f\x74\xac\xcb\x80\x5a\x3c\xee\xcd\x69\x34\x62\x80\xa7\xcd\xc4\x9d\xc8\x96\xa8\x10\xf9\x54\x55\xec\xf8\xfc\x39\xc0\x0b\x49\x33\x3e\x74\x03\x97\x1a\x79\x51\xd2\x69\x38\xcd\x0b\x71\x14\x30\x6e\x5e\x57\x2a\x5c\x26\x81\x7e\x83\x67\x86\x5a\x4b\xd9\x59\xff\x36\xb8\xc8\x30\xdb\xd0\xcc\xa4\x7b\x48\xdc\xde\x61\xdf\x6e\x50\x13\xb9\xbf\xe8\x14\x17\xe6\xb9\x44\xeb\xbc\x90\x02\x62\x6d\xa9\x33\x55\x83\x06\xc5\xda\x42\xb2\x03\xf8\xac\x52\x37\xc3\x86\xd3\x82\x40\x61\xc4\x79\x10\x83\x72\x39\x16\x57\x2f\x17\x05\x58\xe5\x6d\x37\x41\x39\xfb\x0e\x9b\xd5\x42\x60\x86\x23\xdc\x44\xfe\x8c\x40\x32\x1f\x75\x32\xcf\x1b\x5f\x02\xc6\x22\x5a\x53\x7f\xe6\x03\xc0\x68\xc4\x5e\x96\xb1\x47\x5d\xd8\x90\x5a\x79\x57\x69\xc8\x40\x95\x0e\x7a\x3e\xbe\xe4\xdb\x62\x78\x89\xd8\x90\x5e\x8d\xa7\x25\x13\xd9\x40\x62\xc2\x27\x3b\x20\x70\x1b\x58\xeb\x14\x67\x1c\x5e\x2a\x5a\x6c\x75\x03\xae\x20\x5e\x41\xf6\x65\xda\x2e\x8b\x71\xb0\xd3\xfc\x6b\xb8\xdb\xb4\x85\xb8\x15\x45\x1f\x34\x4c\xf0\x8a\xb7\xe5\xc4\x17\x7e\xb3\x47\x7b\x30\x7e\x75\xde\x9e\x94\x7d\xc6\x53\x5a\x8b\xa7\x09\x55\xb1\xd6\xc3\x39\x8d\x50\x22\xa9\x1f\x81\xb4\xd6\x22\xef\x54\x5b\x4c\x95\xd6\xd9\xa8\x90\x8d\x78\xd4\xce\x89\x77\xc2\x84\x36\xc2\x3d\x8f\xd3\x2d\x7f\x28\xff\x7d\xf3\xd3\xd4\x0b\x08\x94\x4a\x93\xba\x0b\xd4\xc7\x0d\x5a\x08\x69\x9d\xbe\x70\x89\xc6\x88\x39\x2d\xd5\xd2\xd4\x2c\x75\x15\x1b\xdd\x09\x13\x56\x42\xb6\xd4\x0f\x35\xaa\x68\x39\x79\xef\xa8\x82\x24\xc6\x4c\x73\x87\x8e\xee\x9f\xb9\xda\x1b\x1a\xc2\x1f\x74\xdd\xdf\x7f\x45\x76\x3d\x0f\xaf\xc6\xe8\x10\xc0\xca\x84\x9a\x2e\x5f\x86\xec\xb4\x36\xdc\x34\x61\xa7\x51\x1e\x50\x09\x44\xd5\xbd\x80\x03\x77\x9a\x37\xa9\xd7\xdc\xcd\x0a\x20\x76\x15\xd0\x30\xe1\x38\xa4\x15\xbc\xf7\x3a\xc2\xfb\x61\x9e\xb6\x6d\xe9\x5e\x77\x14\xe6\x0c\xf5\xf7\xf7\xa2\x2f\x8c\x8f\xb7\xe2\x5e\xe3\x1b\xd3\x34\x37\xec\x5e\x5b\xb5\x07\x05\xc8\x76\x22\xf6\xfc\xcf\x3e\x31\x1c\x91\xe6\xfc\x5e\x33\x60\x0b\xe0\x11\xde\xee\x6f\x6d\xfd\x6b\xcb\x89\x8c\x7f\xb2\x16\x13\x67\x81\x54\x28\xd8\x81\x6f\xb7\xb6\x46\x23\xf6\xd8\xcc\xd5\x8b\x8b\xf3\xe3\x3e\xdb\x35\x3f\x8f\x4f\x5e\x0d\x4d\xf8\x73\xd4\x27\xc8\x73\x13\xf9\xf4\xf4\xd9\x89\xe5\x5c\xb7\xb6\xdc\x9e\x99\x3a\xbf\x24\x4f\x55\x75\x89\xe8\x85\xdb\x68\x12\xd6\xb0\xe4\x00\xea\x9b\x8c\xf1\xd6\x81\xf3\x45\xbd\x3e\x1f\xff\x2a\x32\xef\xfe\x11\x85\x0a\x88\x05\x32\x15\x75\xab\x6c\xab\x11\x6c\xc3\xad\x12\xfb\x44\x96\x39\x49\x30\x5e\x96\x73\xae\x6f\x84\x85\x14\x08\x8c\x45\xa8\x5e\xa9\x9b\x36\xfe\x64\xc0\xf1\x1d\x5b\x54\x2a\x13\x5a\x1f\xcd\x64\x11\xe7\xef\xc7\x35\x9a\x75\x1d\x05\xc0\xe0\x9a\x86\x79\xef\x9e\x17\x8e\xec\x7c\xbc\x6b\x5a\x68\xc7\x70\x3b\x53\xe5\x44\xd2\xc1\x63\xb2\x4c\x45\xfd\x62\x39\x2e\x64\x76\xea\xad\xfe\x30\xcd\xb0\x15\xe5\x94\x9e\xdf\xf8\x8a\x2e\x9d\xf2\xf2\x01\x4b\x84\xda\xfa\x2c\x26\x54\x7a\xdb\x98\x1b\x48\x22\xf3\x70\xd3\x26\xdb\xb0\xcd\xee\x29\xae\x6b\xf3\xc5\xdb\xaf\xab\x90\xf6\xa6\x6c\x6e\xcb\xae\x9c\xa9\x4d\xd8\xde\xae\x5d\xb9\xd3\x9b\x38\xd8\xc6\x5d\x19\x1b\x9b\xbb\xb5\xbd\xbb\xf2\x35\x92\xed\x27\x6d\x91\xae\xd4\xe2\x99\x39\xfc\xc8\x1c\xd5\xb9\xea\x11\x78\x56\xf6\x9d\xc0\xdc\x6e\xbf\xd0\x50\xb5\x03\xb8\x1e\x6d\xbc\x01\xa5\x1a\xa9\x79\xcf\x39\xba\x6d\x27\xb6\x12\xc9\x48\xec\xde\x49\x8e\x1a\x5e\x76\x3a\x69\x56\x8c\x29\xbd\xe2\x15\x5c\xe4\xec\x11\x86\x07\x1c\x1d\x4e\x3a\xe0\x11\x38\x5b\x2c\x2b\x11\xdc\x7e\x00\xa8\x73\xa1\xad\xef\xa5\x5a\xec\xb3\x1e\xfb\x9c\xf5\xc8\x39\x99\x39\x23\xe9\xad\xd8\x6b\xb6\x5b\x5d\x73\x38\x13\xc9\xec\xdd\x29\x6d\x17\x6a\x25\xf2\x21\x16\x72\x3a\xf1\xe0\x6e\x7d\xeb\xef\xac\xa9\xb1\x2e\xcb\x94\xca\xfb\xcf\xe5\xcf\x25\x94\xe1\x05\x2f\x55\xd8\x29\xd3\xf2\x4f\xf4\xb0\xd7\x6f\x03\x7c\x6e\x9e\x07\x40\xb7\xea\xbd\x2c\x6f\x4a\xb5\x2a\x7b\x69\x2b\x60\xbb\x24\x00\x4b\xc6\xfe\x3c\x38\x60\xcb\x32\x17\x13\x59\x8a\x9c\x7d\x87\x53\xb9\xe7\xe2\xf7\xa3\xb5\x63\xe7\x23\xca\x0d\x39\x7e\xff\x9d\x11\xfe\x79\x14\xe7\xd1\xce\x9d\xd3\xb4\xed\xe1\x70\xb8\xb3\xc7\x4e\xee\x16\x22\xb3\xb2\x28\x50\xd4\x51\x60\x6c\xc9\x0b\x76\x6d\x8b\xb8\x8e\xc4\xdc\x30\xcd\x30\x76\xb6\xd0\x21\x33\x04\x52\xf0\xdc\xda\x6b\xe4\x7b\x34\x78\x6e\xf1\x47\x6f\x2f\xf7\x62\x4a\xc4\xc2\x7a\xb0\x28\x1d\x00\x8b\x69\xb7\x55\x64\x3a\xbf\xaa\xf8\x62\x21\x02\xcb\x86\x21\x81\x2e\xdb\xb2\x6a\x40\x35\x0f\x4c\x18\xbc\xdd\x34\x3d\x02\x84\x30\xfc\x63\x59\xb3\x95\x90\x55\x0e\x1a\x87\x84\x2c\xec\x6e\xb1\x08\x6b\xca\xb4\x58\xf0\x8a\xd7\x82\x5d\xe3\x68\x02\x85\xbe\x66\x87\x2f\x4e\xfd\xc3\x18\x3e\x3e\x43\x0c\x1d\xd6\xf4\xfc\x6c\x3b\xf1\xc8\xef\x58\x0a\x1a\x02\xf6\x4f\x47\xf8\x70\x51\xa9\x5a\x3d\x2c\xc5\x70\x69\x8e\xac\x71\x21\xde\x48\x0d\x2d\x40\x8f\x1a\x6e\x8f\x01\x58\x4c\xb5\x0c\x5e\x70\xdf\x11\x71\xa0\x21\xce\xeb\xca\x9d\x80\x17\xb1\x1b\xa5\xb5\x24\x48\x5b\xe4\xa0\xa3\xd0\xbd\x26\x4e\x80\xe5\x69\x79\x55\x4b\x5e\x80\xed\xcb\x1e\xfb\x97\x1d\x90\x3d\x37\xcc\x6f\xdd\x79\x49\xab\x71\xaf\xf1\xac\x8b\x62\xbc\x45\xc1\x33\xb1\x87\xdc\x9a\x0f\x7f\xaa\xaa\xcc\xac\xe7\x28\xb8\x14\x77\xee\x39\x32\xc6\x68\x35\x31\x18\x82\xbd\xa3\x1b\x4a\xa9\x45\x45\x96\xb4\xa7\x65\xad\xa2\x81\xe8\x53\xc7\x69\x40\x22\x54\x06\x7f\x9c\xdc\xe7\x50\x11\x5e\xc3\x95\xae\x2d\xab\xd2\x46\x71\x99\x29\x5d\x5b\xee\x20\x60\xd8\x7e\xb4\xc1\x91\x5d\x2f\xbc\x5e\xfa\x0c\x5d\x52\x40\x2f\x43\x8f\xee\x94\x2e\x67\x6c\x9e\x9e\xb8\x5c\x80\xdf\x3b\x87\x85\xb4\x17\xf3\x69\x18\x78\x5a\x4e\x54\x9f\xcd\xd6\xb9\xd9\x6f\xad\x16\x60\x09\xc8\xf2\x29\x55\x77\x65\xa3\x46\xd2\x05\x81\x1e\x6c\x13\xb5\xfa\x63\xdb\x3b\x3f\x69\x70\xc1\xed\x23\x3d\x44\x1f\x9d\xb4\xd4\xa8\x62\x3f\x2a\xe0\xd7\xbf\xec\xd5\x6c\x9c\x76\x1f\xe6\xfd\xdc\xb8\x6c\xf6\x68\x71\x80\x6c\x31\x68\xc0\x3b\x3a\xc0\xb7\xd9\xda\x3e\x84\xd2\x10\x68\x0f\x77\x99\xff\x5c\x2d\xcb\x00\xd7\xca\xb5\x3f\xf5\x0c\x00\xf4\x91\xf6\xe7\x1f\xad\x97\x2c\xd3\x1f\x58\xf3\x7b\xd6\x11\x2f\x99\xae\x2a\x12\x8f\x05\xe1\xdc\xba\x0b\xd3\x83\x6e\x72\xa1\x28\x2d\x58\x0c\xb6\x90\x14\x2a\x76\x3b\x95\xad\xb4\xf3\x69\xcc\xe7\x21\xcf\xa3\x47\x9d\x59\xb7\x1a\xb7\x84\x87\xf3\xbe\x6e\xfb\x6d\x3d\xe8\x16\xff\xe0\x6b\xfc\x83\x6e\xeb\x94\x2c\x7d\xdd\x87\x28\x77\xd1\x33\x24\xc4\x52\xd0\x24\x31\x8a\x15\x38\x5c\xb0\xa5\xab\x89\x3d\xeb\xe7\xf0\x51\x9c\x7c\x08\xfe\x83\x77\xda\x72\xbe\xf0\x61\xd2\xae\x23\x8b\xaa\x97\x2a\x22\x89\xb2\xd7\x89\x89\x47\x95\xb4\xee\xb6\xe9\xa2\x1d\xfd\x0e\xd6\x79\x0b\xca\x30\x40\x29\xdb\x54\x44\x83\x17\xb6\x8b\xa1\x79\x72\xed\xb5\x42\xfa\xe9\x84\x3f\xc9\x7a\x76\xa6\x10\x61\x4f\x87\xb3\x15\x1d\x7d\x0f\x3b\xfc\xa2\xb2\x1a\x08\x17\xf7\x9d\x85\x1b\x27\x6e\xf3\x89\xe8\x8e\x24\x59\xfe\x2a\xb2\xda\xf0\x06\xc7\xe2\xd6\xd0\x9c\xa8\x43\x39\x85\x1d\x05\xb2\x0b\xe6\x95\x40\x72\x28\xf9\xfb\x75\x38\x38\xec\x80\xc5\xb9\x86\x1d\x09\xdd\xa9\x62\xe5\x33\xb6\x25\x80\x8f\xa5\xb7\xdf\x70\xad\xe5\xb4\xdc\xfe\xd7\xdb\x7e\xa3\xc4\x7e\x64\xcd\x1a\xcf\xcd\xf7\x6b\x92\xf7\x75\xce\x4a\x50\x65\x07\xef\x12\x28\x3e\xf4\xa3\x8a\x12\xbd\x08\x2b\x72\x10\x4c\xad\x33\xef\x51\x47\xee\xc4\x03\x39\xca\xe3\x48\xe0\x1a\x8a\xbe\xc9\xe2\xa8\xed\x59\xab\x63\x21\xb0\x24\x22\x4a\x57\x3f\xda\xf8\x51\xc1\x59\xb2\x13\x0a\x6a\x51\xfe\xd8\x29\xf4\x7a\xc2\x0e\x18\x4a\xf7\x86\x93\x4a\x88\xdf\xc4\xf6\xbf\xb6\xfe\x7f\x76\xe7\x76\xc8\xc9\xb6\xde\xee\x6c\x2a\xf2\x0b\x76\xc0\xb6\xbb\x6a\xb3\x02\x8a\xb6\xf0\x0d\x6e\xc4\xe9\x5c\xfb\x20\x12\x45\xce\x69\xbc\x04\x28\x59\xb0\xf0\x32\x37\x18\x7a\xc1\x46\xd4\xab\xec\x86\x4f\xc5\x70\x6b\x2b\x48\x9f\x8b\x0c\x5c\x9e\x94\xcd\x1b\xe2\xdd\x42\x55\x35\x9b\xa8\x6a\x0e\x82\x55\x7b\xb1\x9b\xf1\xec\x66\x0d\x57\xba\x39\xbf\x11\x9a\xc9\xda\x1a\xb8\xd6\x33\x36\x56\xf5\x8c\x5d\xa8\xa2\x58\x2e\x40\x54\xf1\x1f\x42\xd7\xc3\x2d\x34\xaa\xe3\x59\xed\xdb\x1c\x09\xf9\xc2\xb1\x79\xdd\xa3\xc1\xed\xfd\xc2\xbe\x7b\x40\x9a\x8e\x39\xf8\x22\x1c\x12\xcb\x49\x5a\x0f\x7e\xd6\xad\x92\xac\x0d\xf9\xd6\x66\x59\xaa\xca\xac\x49\x82\x09\x1c\x2f\x0d\xbd\x0d\x66\xf0\x15\x79\xb8\x3f\x60\xbd\xdd\xbf\x0e\x77\x87\xbb\x3d\x2c\x9e\x5b\xc5\x80\xc3\x52\xce\xf1\x76\x56\xf1\xb9\xe8\x03\x56\xb8\x05\x1c\x04\x6d\x0c\xeb\x19\x11\xb1\x9e\xc8\xe6\x76\x82\x89\xeb\x99\x28\x4d\x69\xa1\xf3\x02\xb6\x50\xba\x7e\x2e\xb4\xe6\x53\x41\xc6\xb3\xd0\xd4\xc0\x7c\x18\xdc\x16\x2c\xb8\x34\xf7\xf4\x9f\x10\x66\xb3\x9e\x89\x2d\x44\xdd\x77\x79\xf1\x89\xb6\x62\xb9\x32\x97\xf4\xf9\x32\xb3\x16\xc0\xda\x83\xf3\xd3\x3b\xb3\x69\xe7\xe7\xd8\x28\x86\x2e\x65\x46\x23\xf6\xfd\xda\xde\xd1\x6d\x7f\xa4\x59\x5e\x00\x0e\x21\xcb\x5a\x85\x77\x78\xb4\x69\xa8\x65\x76\x03\x5e\x29\x4b\x8d\x3e\x50\x78\x6d\x0a\x2a\xf8\x5a\x2d\xeb\x3e\xb6\x18\x3d\x16\xc2\x3b\xf6\xb8\x52\x2b\x2d\x2a\xf2\x67\xa8\xd1\xc8\xc1\xf4\x6f\xca\xcd\x1e\x46\xe0\xf4\x5b\x2e\x0b\xf0\x61\x83\xa8\x6b\xe4\x33\xc7\x37\xd5\x64\xcc\xd7\x25\x9f\xcb\x0c\x9e\x9e\x78\xfe\xeb\xd2\xdc\x19\x86\xf8\xb2\x60\x68\xd6\x89\xd5\xf6\x38\x29\x6f\x65\xa5\x4a\xb8\xec\x67\xbc\x7c\xa9\xc5\xf1\xf9\x73\xb3\xef\x48\xe0\x93\x9c\x52\x10\x0b\xb6\x7d\xdd\xb5\x05\x7a\x3c\xab\x59\x2e\x0c\x0b\xa8\x99\x07\xc3\x88\x0b\x1b\xb2\xe7\xfc\x46\x30\x37\x3c\x6c\xad\x96\xac\x50\x3c\xb7\x02\xa1\x85\x2a\xd6\x13\x09\x23\xcc\x54\x91\xfb\x51\xd2\x43\x36\xab\xeb\xc5\xde\x68\x34\x19\x0f\xe7\x62\x04\xbb\x6a\x60\x93\xeb\x1e\x5d\x68\x49\x8a\x3f\xe3\xfa\x8c\xd7\xf2\x56\xbc\xf0\x28\x5f\x67\x6a\xc5\x0e\x6c\x57\x43\xf4\x2f\x10\x6f\x29\xa0\x74\xbd\x60\x34\x82\x24\xc3\xd2\xe4\x8d\xc6\x81\xc8\x1c\x44\x38\xc9\x13\x69\xec\xa6\xaa\xc6\x71\xc3\xe4\xfe\xa0\x69\xbc\xa8\x34\xaa\xa4\x67\xd5\xfd\xad\x80\xe5\xbe\xa7\x84\x63\xb3\x7a\xa3\xac\x01\x35\x08\x14\xa5\x56\x7c\x8d\x48\x27\x65\x26\x8a\xbe\xa3\x0b\xc8\xa0\xe4\x4a\x68\x74\x3b\x3e\x27\x12\x76\x7a\x14\xf4\x12\xba\xf9\x68\xf3\xaa\xc2\x66\x61\xbe\xe0\x00\x37\x6b\xe0\xa8\x71\xf7\xd5\x02\x94\x56\xd5\xb2\xde\x6e\x77\x8b\xb1\x28\xcf\xb6\x3f\x65\x23\x05\xa1\xbd\xc4\x88\x44\x87\xe5\x29\xda\x1a\xad\x53\x67\x22\x1d\x89\x31\x42\xd6\xe3\x78\xe8\x03\xb7\x90\x09\x8d\xa8\xe4\x1e\x19\x8d\xd8\x0b\xbb\x9a\x93\x5a\x54\xf4\x12\xe4\x08\xdb\xc5\xe9\xd1\x91\x97\xeb\x36\x40\x7e\x4c\xd6\x0d\xe8\x46\xf1\x36\x4b\x24\xb4\x6f\x73\x26\xfa\xd8\x2b\xaa\x43\x37\xd1\x99\x17\x11\xe8\x65\xcd\xb8\xd6\xcb\x39\x12\x3d\x5e\x83\x6d\xc3\xb2\x64\xbc\x66\x5f\x3c\x9e\x2c\xb4\xf5\xe6\x8e\xa7\xe6\xcc\x2a\x64\x39\x0c\xbd\x2d\xf2\x59\x52\x14\x44\x8b\xf0\x10\xba\xe5\xc5\x12\xe0\x85\x38\x9b\x70\x6d\x08\xb8\x29\x4b\x4e\x4c\xf1\x53\x41\x5e\xb9\x27\x15\xf9\x59\xe3\xb6\x3b\x5b\x64\x38\xcd\xe7\xe8\x7b\x2c\xb2\xfe\x32\xa1\x24\x2c\xfc\xe2\x0b\x3b\x16\x3c\x33\x9b\xaf\x19\x97\xea\xbe\x7f\xba\xbc\x77\xdf\xb2\x54\xce\x40\xce\xf8\xa0\xc5\x88\xc3\x0c\x83\x4b\xd4\x0f\xbb\x6f\xcd\xb2\x43\x40\x42\x39\x07\xcf\x3c\x56\x4b\xe2\xf0\xa9\xbb\x09\x87\xc5\xc1\xc1\x98\xca\x09\xa3\x3d\x04\xdd\x35\xa0\xb5\xa1\xca\x7a\xb1\xe2\x6b\x0d\xa2\xdb\x61\xf3\xfa\x11\xaf\x8e\x41\x9a\x1e\xf9\xcd\x03\xb2\xc9\x48\x1c\xf0\x61\x46\xe9\xa9\xdd\x05\xb5\x0a\x08\xda\x7d\x8d\x8d\x49\x5f\xb3\x95\x5b\x6e\x9d\x5b\xb7\xfb\x21\xaf\x50\x57\x12\xab\x43\x67\x4a\x70\xd0\xc3\xb1\xdc\x74\x94\x54\x09\xe4\x3b\x68\x3d\xcd\x31\xff\x7f\x8a\xb5\xe1\x90\xde\xbc\x81\x53\x29\xdc\xe5\x1f\x9b\x53\xed\x39\xaf\x67\xc3\x8a\x97\xb9\x9a\x6f\xef\x0c\x6b\x75\x59\x1b\x16\x69\xfb\x8b\xbf\xee\x0c\x75\x21\x33\xb1\xfd\xc4\xbd\x8b\x9b\x9a\xaf\x24\x10\x80\x40\xa4\x78\x1b\x3c\xbe\x83\xdc\xcb\x04\x0c\xb5\x5a\x56\x19\x9e\xcf\x2b\x59\xe6\x6a\x05\x10\x32\x10\x95\xf3\x9a\x43\x84\x6f\x60\x53\xee\x19\x69\x5e\x76\x93\x17\xeb\xea\xc4\xd1\xa5\x14\xb9\x8a\xe5\xce\x49\x42\xc6\x9c\x17\x92\x80\x64\x36\xdd\xa1\x10\x91\x4f\xac\xa2\xf8\xde\x82\xe0\x50\xb0\x91\xb4\x23\x52\xb8\x8d\xf2\xfc\xc4\x8c\xc0\x33\xa9\x6b\x51\x9a\xa9\x24\x33\x2c\x11\x9c\x52\xf6\x6a\x26\x04\x69\xc5\x6a\x35\x17\x16\x10\xaf\x06\xda\xa4\x2a\xc3\x7e\xb0\xd3\x13\x33\xd3\x38\xba\xc3\x66\xd9\xdb\x3d\x1a\xdd\x5e\xdf\xcd\x9b\x87\x2e\xb6\xe4\xc8\x52\xb2\xd6\xac\x56\x7c\x12\x81\x82\xdd\x4f\xc3\x59\x00\x02\x10\x12\x38\x2a\x89\x0d\x1a\x7b\xe2\xf3\x26\x31\xf4\xd3\x10\x17\xf1\x4d\x8b\x6a\x86\x56\xb1\xdd\xc9\x62\x88\xf4\x66\x99\x7f\x6f\x6c\xeb\x63\x31\x11\xa5\x96\xa0\xbf\x9e\xcb\x72\x0a\x1a\xfe\xa8\x00\xaa\x97\x0b\xb8\x73\xa1\x95\x76\xc0\xde\xc2\xf4\x96\x6c\xf7\xc9\xe3\xd9\x6f\x91\xab\xae\x53\x77\x72\x14\x6a\x85\xb4\xb2\x84\xa5\xd0\x67\xe8\xc8\x6c\x51\xa9\x31\x1f\x17\xa4\xb6\xea\xf3\x36\x07\xef\xef\x4d\x79\x0b\x16\x0e\xb6\x7e\xd0\x8c\xa9\x12\x1a\x50\x49\xfa\xfe\xd8\x03\xdb\x42\x93\x84\xfc\xd1\xea\x99\x69\x3d\x30\x54\x75\x36\x63\xcb\xc5\x30\x2a\xac\x5e\x29\x3a\xc3\xc0\xa3\x3a\xa6\x96\xa8\x78\xbb\x72\xc5\x72\x70\x86\x58\x32\x59\xe6\x92\x9c\x2e\xd2\xda\xf6\x85\x39\x9f\x64\x74\x68\xb4\x06\x0c\x07\x62\x85\xf9\x62\x4f\xc6\x6a\x51\xcb\xb9\xfc\x2d\x50\xf6\xa7\x13\x09\x8f\x69\xb5\xac\x82\xe3\x3c\xba\x53\x64\x99\xaa\xcc\x8c\x15\x6b\x54\x18\x17\x77\x7c\xbe\x28\x44\x1f\x0f\xb0\x5e\x15\x34\xb0\x5a\x96\x25\xa9\x15\xc3\xa4\xb1\x5c\xea\x45\xc1\xd7\x4c\x55\xec\x6b\xf3\xfd\xea\xc2\x06\x85\x8e\x3b\xcd\xad\xc0\x0c\xec\x9c\xdf\xd9\x3b\xa2\x19\x34\x59\xa2\x2c\xd2\x0c\x35\x06\xcf\x41\xe7\x8d\x97\x8c\x97\x6a\xce\x8b\x35\xcb\x81\xad\xf0\x45\xcd\x25\x38\xd2\xc7\x11\xb1\x7a\xdf\xce\xc8\xba\xcd\x1d\x34\x57\x6d\x7b\xd9\x7f\x97\x08\xdb\x8b\xf3\x25\x5f\x34\x53\x7c\x4a\x2a\x57\xfb\xe4\x0c\xf6\xf4\x86\x3d\xfc\xa8\x41\xb6\x43\xf5\xd0\x26\x3d\x0f\xb5\x31\x88\x9c\x05\xe7\xdf\xb6\x3f\x26\xfa\xac\xf7\x59\x2f\xa6\xb6\x09\x46\xbe\xf9\x7e\x65\xa5\x24\xbc\x41\x93\xd1\x35\xbf\x55\xfe\xc6\x0d\x43\xf4\x9f\xd7\x8c\xe3\xcd\xdb\x5e\x3e\x70\x07\xd8\xf2\x66\x6a\x45\xd7\x91\xa5\x06\x61\xcb\x70\xd3\x21\x13\x6b\x39\xd0\xe8\x74\x10\xd4\xa6\xeb\x3a\xc3\x5d\xe5\x32\x87\x1b\x4f\x03\x2a\xce\x34\x19\x4c\x23\xac\x0b\xbb\xc0\x96\x15\x66\x6c\xd8\xf5\x7c\x07\x85\xd2\x3d\x6a\xce\x6b\x51\x49\x5e\xc8\xdf\xc2\xce\x0a\x27\x00\xa8\x67\x95\xaa\xeb\x42\xe8\x7e\xb4\xd7\xd1\xbb\xee\x8a\xa3\xd2\x04\x7a\x9c\x44\xcf\x11\xee\xc6\xe4\x54\x56\xcc\x04\x81\x5b\x55\x33\x08\x88\x6a\x89\x52\x08\x5f\x9c\x9d\x13\xf0\xdf\xdc\x74\x8b\xe0\x16\x4e\xf7\x21\x14\x2e\xa1\xe4\xe5\x7e\x3b\x3a\xeb\x76\x12\xaf\xba\x8f\xdb\xf7\x59\x5c\x59\x89\xfb\x11\x5e\x5d\x3f\xfb\x6c\x8b\x7d\x66\x68\xce\x8d\x55\x71\x9d\x8c\x7f\xd5\x23\x92\x3e\xec\x99\xc8\x59\x5d\x2f\xf4\xde\x68\x34\x95\xf5\x6c\x39\x1e\x66\x6a\x3e\x9a\xf0\x4c\x8c\x95\xba\x19\x41\xe2\x71\xa1\xc6\x23\xf1\xd7\xbf\x8e\xf9\x93\xc7\x3c\xff\x6a\x2c\xbe\xfc\xe2\x0b\x31\xfe\xea\xcb\x2f\x9f\x7c\x31\x79\x32\x7e\xfc\xf5\xdf\xf2\xbf\x3f\xf9\xfa\x8b\x27\x5f\xe6\x5f\xe7\xe2\xaf\x23\x12\x15\x6a\xcc\xab\xab\x6c\xf4\xe6\xcd\x44\x55\x37\xfa\xcd\x1b\x5b\xed\xf0\x57\xbd\xc5\xa0\x61\xe7\x66\x7d\x67\x33\x5e\x4e\x41\x10\xb3\x42\xee\xd2\xfa\xf4\x34\xc9\xc1\x15\x80\xe0\xa0\x0e\x14\xf9\xfa\xec\x9b\xfc\xbc\xcc\x59\xae\x58\xa9\x90\xfb\x00\x7d\xdc\x1e\x25\xeb\x59\x95\x25\x3a\x1c\x01\x92\xf0\x33\x32\x9a\x13\x40\x98\xb5\x9c\x2f\x0a\x39\x91\x42\x93\xab\x91\x5c\x40\x9a\xc1\x60\x60\xfe\x5c\xca\xb9\x2c\x38\x40\x9a\x3a\x25\x62\xb8\xbe\xc1\xb6\x2c\xd4\xd4\x2c\x18\xea\x93\x55\x94\xc9\x54\x99\xcb\x1a\x9d\x06\x42\xed\x73\x51\xfb\x7a\xe9\xb8\x03\x8b\x90\x5a\x99\x22\xd0\xec\x03\x94\xa4\x72\x71\x2b\x0a\xb5\x80\x17\xd9\x80\xdd\x42\x05\xaa\x4a\xd6\xe6\x34\x31\x25\x2d\x78\x3d\xd3\x84\xeb\x65\x45\x6b\x85\x9a\x4e\xcd\x6f\xd3\x05\x84\x67\xaf\x54\xbe\x44\x6a\x13\x95\x05\x17\x4b\x58\xc2\x80\x44\xfc\x19\xc2\x91\x14\x6a\x2a\x11\xdb\x0e\x91\x87\x3d\x50\x09\x14\x88\x35\x6e\xb1\xcf\x46\x28\xb5\x29\xd4\xca\xc1\x5f\x50\xf7\x1b\x32\x95\x50\x33\x77\x51\xc9\xb2\x4e\xa5\x83\xbb\x91\x63\xcc\x4d\xab\xb7\x41\xb5\xb3\x10\x25\x3b\x70\x1a\x4f\x7a\x58\x88\x72\x5a\xcf\xfa\x26\x44\xb3\x03\x76\x58\x55\x7c\xbd\x0d\xa9\xbe\x65\xbb\xec\x3b\xcc\x30\x60\xbb\x6c\x8f\x3d\xde\xe9\xb3\x37\x37\x70\x9d\xd8\xdd\xc7\x5f\xdf\x40\x3c\x7e\x7c\xfe\xb9\x27\x5e\xa6\xb4\xd7\x90\x62\xc0\x76\x7f\x09\x2b\x84\xd0\x5f\x5a\xda\x31\xbc\x9a\x9e\x96\xb9\xb8\xf3\xb8\x22\xc1\x15\xc6\xdc\x5f\xa8\x8f\x7b\x20\x8a\xc3\xce\x0d\x2b\xd4\x6a\xd9\x1e\x7d\xa2\x47\xd3\x7e\xf2\xce\x66\xcd\x9c\x4c\x7b\x6c\x1d\x9f\x7f\xfe\x4b\x2c\x56\x09\x04\x28\xb4\xbe\x51\x68\xe2\x34\xd6\x7a\xc1\x45\x20\xd8\x3f\xf6\x68\x8a\xc8\x49\xa8\x91\x3f\x1a\x99\xe5\xce\x7e\x12\x45\xa6\xe6\x02\xef\x70\xe3\x25\xae\x26\x14\x4a\xc2\x6e\x60\xe1\x31\x85\x36\x4e\x2b\x00\xb1\xa9\xd4\xaa\x44\xd2\x99\xa9\xf2\x56\x94\x52\x98\x6b\xb4\x56\x5e\x3e\x69\x16\xbd\xf3\x5f\xad\x03\x17\x77\xe8\x1c\x6a\x62\x01\x27\x00\x44\x57\xd6\xc2\x7a\xc2\xc6\x5d\x02\xfa\x1a\xb4\x78\x20\x75\xe5\x0e\x0d\xb4\xaf\x2f\xc5\x8a\xa1\x65\x57\xa3\xab\xd6\x7d\xf1\x9d\x59\x8f\xee\x28\xbe\x67\xed\xba\xfd\xdb\x67\xf1\xf2\x04\xa3\x64\x08\x89\x35\x05\xfd\xb0\x37\x9b\xd3\xbb\x76\x5a\x82\xcd\x42\xfb\x6c\x38\x1c\x9a\x09\xdf\xb9\x06\xda\x2d\x2b\x11\xd2\x12\x10\xe5\xda\x85\x65\x97\x65\x6f\xa7\x69\xec\xf7\xc8\x95\x1b\x88\xfb\xc2\x5d\xf4\xe4\x61\xdb\xe8\x09\xfb\x96\x3d\xa1\x7d\xf4\x84\x0d\xd8\x93\x60\x23\x99\x22\x9e\xec\xd3\x4f\xdc\x4a\xf6\x33\xdc\x4c\xc1\x76\x82\x12\xda\xfb\xe9\xc9\x2f\x2d\x2d\x86\x90\x30\x0c\xf9\x62\x51\xac\xb7\xdd\xb0\xf6\xd9\x6b\x1c\xaa\x5f\x86\x99\x2a\x33\x5e\x6f\xc3\x70\x35\xde\xdf\xba\xc8\x11\x68\x9c\xb7\x83\xf1\xed\x45\xea\xc3\xba\xae\xe4\x78\x59\x8b\x33\x73\x46\xf3\x89\xd8\xde\x81\x07\x04\xc7\xea\xe7\xcb\x45\x61\xee\x10\x22\x37\xc4\xf7\xf8\xfc\xf9\x73\x5e\xdd\x2c\x17\xe7\x0b\x81\x2a\x60\x7a\xe8\xa5\xc2\x00\x98\xc2\xed\xcd\x17\x76\x3b\x3d\xda\x48\x8d\xe2\xdf\x57\x87\xcf\x4e\x8f\xdf\x1c\x5e\x5d\x5d\x9c\x7e\xff\xf2\xea\xe4\xcd\xd9\xe1\xf3\x93\x37\x17\x27\x3f\x9c\xfc\x83\xbc\x37\x5f\x88\xe9\xc9\xdd\x62\xbb\xf7\x7f\x5e\x9b\x99\x6f\x24\xbc\xbc\x3a\xbc\xb8\x7a\x73\xf4\xe3\xe1\x85\x59\x15\xbf\xa4\x92\xb8\xc8\xcf\x3e\x36\xab\x04\x04\x21\x45\x21\xa6\xbc\x88\x7a\x7a\xc4\xb3\x19\x68\xf7\xbd\xc5\x34\xe0\x36\xc7\x74\xb2\x33\x55\xe0\x01\xb7\x3d\x66\x3c\x0c\xf1\x56\x0f\x1b\x4a\x1d\xce\xb8\x3e\x5f\x95\x2f\x2a\xb5\x10\x55\xbd\x6e\x94\xd0\x10\xc5\x7b\x73\x52\x32\xf3\xea\xea\xd1\x3b\x95\x1a\x18\x08\x63\xb1\xdd\x93\x33\xac\x85\xae\x3b\x4a\xdb\xd0\xc9\xd7\x51\x8e\x5f\x36\x5b\xca\xb2\xee\x89\xea\x2e\x27\xfd\x82\x64\x9d\x57\xba\x6c\xac\x04\x7f\xf3\xd7\x9f\xe8\xeb\x5e\x9f\xc5\xfd\xb0\xb5\xc7\xa3\x82\x8f\x1d\xa8\x4c\x7e\x3a\x2d\x55\x25\x5e\xf1\x62\xf9\x27\xee\x8e\x86\x19\x74\x58\xe7\x82\xa6\x13\xb5\x08\x41\x20\x4b\x8f\x22\xd8\x64\x14\x88\x07\x5a\xd7\x61\x06\xb3\x24\xbe\x57\xaa\x10\xbc\x84\xd2\x40\x25\x1f\x73\x24\x52\x9e\x2d\xe7\xa2\x92\x99\x4b\x29\xf5\x19\x3f\xdb\xa6\x2a\x13\xe9\x5f\x28\x2d\xcd\x9d\xb2\x99\x0f\x2b\xf8\x86\xed\xa6\x32\x9d\xdf\x8a\xaa\x50\x3c\x17\x79\xb3\x61\xb6\x27\x91\x9d\x12\x32\xee\x7e\x48\x61\xd0\x72\xc1\xe1\x91\x17\x5e\xcc\x8f\xcf\x9f\xdb\x4a\xa4\xb0\xdc\x19\x3c\xd0\x63\xde\x1f\x04\x0a\xbf\xb1\x78\x93\x9d\xbb\x46\xa1\xd5\x32\xb8\x2f\x42\x1e\x1c\xce\x5a\x33\x99\x27\xaf\x20\xe9\xe5\xe5\x85\x5d\xe3\x52\x95\xc4\xc0\x0a\xf6\x91\x20\x65\xf5\x8f\xbc\x42\xba\xd4\x98\x1b\x78\x80\x99\x2c\xd1\xad\xaf\x15\xbd\xdb\x0c\xd4\x0c\x09\x0d\x65\x97\xe0\x0e\xc0\x35\x1e\xaf\x65\xf3\x65\x51\xcb\x45\x21\x98\x39\x10\x6f\x79\x61\x0a\x87\x5c\xd4\xb9\xd0\x0a\x0b\x06\xef\xa9\xaa\xdc\xa6\x37\x7d\xe9\xc3\x8a\xef\xbb\x3a\x71\xbd\x84\x96\x8d\x7e\x4a\x50\x05\xf0\x45\x10\xb2\x5d\x72\x87\x2a\x81\xa8\x77\x3e\x2e\x56\xf8\x99\x2f\x51\x43\xf1\x39\x1a\x2a\x1c\xc4\x73\x1d\xc7\x86\x2a\x4c\x8d\x7c\xcd\x45\x32\x5f\xea\xfa\xa5\x16\xb6\x4d\x29\xf5\x26\x95\x8b\xd7\x51\x1e\xfb\x01\x24\xa2\x53\xc3\x10\xb8\xd7\x70\xff\x37\xdb\x1c\x45\x36\xdc\x19\x6b\x90\xb6\xe3\x6a\x8d\x30\x99\x53\x03\xd5\xbd\xd2\xdb\xba\x40\xb0\xfc\x66\xdc\x9f\x2c\x1d\xb4\x36\x6c\xcc\xad\x6d\x86\xc9\x3b\x15\x75\x57\xde\xfd\x28\x27\x1d\x4b\xb4\xcb\x7a\xbd\xb6\xb3\xa5\x06\x61\xf6\xff\xde\xb6\x0a\xba\x8f\x54\xb9\xd5\xd7\x59\x0b\x34\xe5\xbe\x6a\xc2\xf6\xb2\xcf\x1b\x6b\x3a\x51\xa8\x4d\xb0\xa9\xdc\xae\xfa\x03\xad\x59\xff\x5c\xfb\x6e\xd3\xf3\x87\x46\x06\xe5\xa8\x33\x9e\x83\x60\xd2\x9d\x5f\xe6\xaa\x8d\x65\x96\xbd\x1a\x69\x84\x49\x03\x32\x25\xad\xcc\x25\x3e\x67\xb2\x6e\x96\x64\x15\x66\xf0\x92\x42\x5c\x74\x5a\x49\xec\x1d\x16\x51\x13\x8b\x74\xd3\x69\x93\xe8\x9e\x15\x6b\xad\x50\xc8\x84\x89\x41\xd4\x1e\x08\xb9\x6a\xf0\xbf\xc2\x43\xb2\x2d\x75\xb3\x24\x50\xff\x31\xd7\xb2\xe8\xdd\x46\x26\xe1\x45\xed\x80\x27\x7b\x9f\x5a\x30\x61\x2f\x47\x23\x76\x72\x2b\x4a\xf7\xf6\xe9\xce\x0e\x90\x27\x72\xa0\xb5\x7a\xc1\x11\x1e\xcf\xdc\xef\xc2\x91\x8c\xcb\xb1\x42\xbb\x95\x7b\xbe\x95\xb5\xf6\x05\xe4\xf0\xb3\xd9\x01\xb5\xac\xac\x19\x68\x5c\xda\x95\x6a\x55\x77\x76\xe9\x85\x8c\x20\x0d\xc9\x78\x81\x85\xa2\x06\x94\x43\xca\x30\x83\x15\x97\x26\xcb\xa0\x26\x54\xd9\xf0\xf1\x0d\xda\xf7\xe0\xf5\xf2\x36\xa6\x90\xef\xb9\x31\xac\xb1\x7c\xd8\x08\xcb\xf0\x7c\xe7\x4f\xd6\xbd\x30\xc5\x7e\x6a\x2b\x37\x4b\xd8\x40\x51\x3a\x17\x47\x42\x79\xbf\xdd\xbe\x84\x7a\x88\xbf\xaf\x05\x7c\x4d\x8a\x37\xf1\xfb\xfe\x3d\x99\x93\x7a\x26\xab\xfc\xfd\xf9\x12\x60\x4a\x40\xa8\x68\x1b\xf2\x07\xf8\x12\xbf\x44\xee\x63\x4c\xac\xac\xbd\x75\xbd\x2a\x63\x22\x9b\x78\x75\x36\x39\xdb\x54\x3a\x99\xcf\xf7\xb7\x69\xe6\xe8\x7f\xef\xb5\x8c\x89\x36\x9f\xb8\x0d\x7e\xe9\xde\x03\x2b\xb9\xb4\x22\xf9\xb6\x3b\x98\xc2\xb5\x72\x29\xc8\x25\xd2\x3d\x8c\x2c\x89\x94\xff\xd7\x82\x57\x7c\xce\xfe\x75\x7c\xfe\xfc\x04\x55\x86\xdf\x42\x7c\x18\x87\x2b\xf6\x2d\xcc\x4a\x18\xfe\xd9\x5b\xac\x24\x9e\x56\x7d\x0f\xbb\x19\xdc\x4d\x1e\xce\x65\x6e\xb5\x8f\x11\x73\x17\x40\x4a\x71\xd9\x1c\x66\x5b\x49\x68\x4d\xf6\xee\x5c\x68\x9b\x07\xf5\x93\x13\x87\x53\xff\xb0\xd2\xe8\x71\xee\x21\xe4\x2c\x6e\x2b\x63\xb9\x28\x44\x2d\x36\x8c\xe1\xce\x7e\x6a\x91\xfb\x0a\x1f\xc6\x26\x8f\x46\xec\x48\x95\x75\xc5\x2b\xd0\xcd\xbb\xd6\xc1\x28\x5e\xf7\x19\x6a\x28\x86\xb7\x0e\x5e\xd9\x4b\x48\xe8\xf1\xfa\xda\x2a\x98\x5c\xa3\xae\xf9\xe9\xc9\xdf\x47\x5f\x3b\x90\xe9\xcd\x1c\x38\x3b\x08\x99\xab\x06\xc9\x7c\x57\x2e\xdc\xe7\xf2\x47\xed\xa6\x1c\x90\x62\x3f\xe8\x48\x34\x00\x78\x69\xc4\x41\xd0\xe6\x44\x56\x73\xa1\xf1\x25\xe3\xfa\x35\x06\xff\x72\x6d\xa8\x2c\xf4\xb7\xef\x8b\xd9\x86\xed\x4c\x8b\xdc\x69\x6e\xab\x65\xbd\x40\x45\x36\x96\xa9\xaa\x32\x23\xeb\x14\x73\x76\x06\xa8\x3f\x15\x5c\x7d\x5c\x0f\xc2\xd3\x06\xdd\xe7\x46\xc7\xb8\x4f\xd8\x90\x58\xf4\x59\xd0\x8c\xc6\x45\xe7\x3e\x7e\xec\x7d\xaf\xe3\xb1\x79\x6e\xa2\xbd\xdb\xad\x26\x76\x03\x20\x3e\x20\x73\xbb\x7f\xfe\xf0\x0c\x8b\xd3\xf7\x9d\x33\xf7\x50\x11\xf6\x1d\x75\x72\x2f\x04\x9f\xf1\x7b\x0f\xb8\x17\xac\xca\xd2\xe2\x14\x31\x4c\xd7\x1d\x50\xc3\x87\x1d\x6d\x61\xbd\xf1\x49\x12\xe9\x37\xc1\xf8\x55\xe0\xcb\x26\x71\x04\x45\xe3\xd3\x1e\xea\x32\x35\xc2\x89\x6e\xd2\x91\x73\x0c\x04\x4b\x47\xb7\x11\x42\x43\xf8\xc3\x87\x4d\x70\xb0\xc4\x74\x31\x35\x9c\x56\xeb\xb9\xbb\xeb\xed\x46\xff\xa9\x47\x65\x67\xeb\x53\x54\xfd\x1d\x8f\xc4\x6e\xb1\xcb\x7f\xd3\x71\xe7\xdf\x74\xde\xf3\x04\xb2\x7d\x4d\x11\xf7\xf0\x9c\x08\x85\x42\x0f\xbd\x48\xba\x93\xc7\x1e\x34\x31\xac\x58\x8a\xdc\x44\xc9\x7b\xbd\x06\x55\x89\x73\x24\xd7\x58\xf7\x59\x13\xbe\xc3\xb4\xb6\x5e\xf7\x2e\x8d\x50\x82\xe0\xb0\x56\x45\x21\x72\xe8\xac\x19\xce\x2b\x30\x3b\x42\x8d\x57\x70\x40\xe5\x02\xc9\xa4\x3f\x7c\x57\x9e\x71\xc0\x81\x34\x57\x04\x7b\x43\xc3\x46\x8c\x97\x75\xad\xca\x3d\xa0\xdf\x04\x87\x65\xca\x1a\xab\xbb\x30\x4c\xce\xf9\x54\x84\x01\x33\x99\xe7\x22\xca\x56\xf1\x5c\xaa\x28\x40\x68\x51\x87\x01\x7a\x39\x9e\x4b\x0a\x71\x4f\x8c\x76\x19\x84\xbd\x61\xb8\x27\x43\xad\x5d\xc0\x65\xe9\xbb\x05\xd3\xf7\xf0\x19\xfe\x41\xc5\xf1\xf9\x90\x38\x98\xd0\xdf\x7f\x6f\xf5\x1f\x62\x35\xc0\x50\xfc\x62\x8f\x3c\x3d\x54\xe5\x11\xea\x57\xb8\x90\x8a\x32\xf9\x90\x5c\x6a\x3e\x2e\xc4\x43\x4d\x61\x6d\x94\x7f\xe9\xfc\xa7\x5a\x9a\xa2\x6e\x65\x6e\x2e\x5c\xec\x1a\xfa\x7a\x0d\xa5\x93\xce\xba\xaa\xe6\x6c\x02\xe0\xa9\x86\x0f\x01\x2d\xf9\x12\xdf\x39\xaf\x6d\x0b\xaf\xad\xc9\x11\x61\x81\xac\xa4\x73\x23\x0b\xf6\x52\x3c\x1f\x00\xbb\x02\xc5\x00\xc2\x08\x02\xd9\x80\xfb\x27\x53\xb2\x47\xc1\x31\xdb\x1b\xec\x93\xb4\x60\xd7\x64\xf2\x05\x63\x74\x3d\x64\xe7\xf5\x4c\x54\x2b\x09\x6f\x26\x26\xbf\x16\x35\x13\xe8\x86\x20\x68\x8a\xaa\xd8\xb5\x1d\xa8\x6b\xef\x5a\x35\x58\x4e\x80\x49\xf1\xc1\x26\xf3\xdf\x38\x59\xd4\x9b\xff\xcb\xa6\xeb\x88\x5a\xf5\x07\x27\xcc\x6d\x4a\x38\x25\x19\xfb\x8c\x11\xea\x19\x80\xfc\x95\x37\x22\x77\xab\xd5\x0b\x20\x26\x0a\x2d\xcb\x91\x3a\xc1\x68\xe8\x21\x33\xe3\x46\x6d\x2e\x55\x6d\x1a\x8b\x05\x82\x74\x4c\x2d\x6b\x80\x0e\x24\xe5\x4b\x84\x28\x3a\x7f\xde\x2c\xc6\x2f\x0b\x54\xa9\xfc\x6c\xb4\xc5\x36\x53\xc3\x61\x4c\x07\x23\x65\x85\x9a\x4f\x71\xb1\xd1\xea\x9b\x82\x03\x62\xaf\x56\x18\x67\xdd\x76\x34\xc9\x65\xe8\x99\xbf\xbd\x3e\x73\x05\xb9\x12\x12\xe6\x4f\xb9\x04\x36\x1f\x6d\x1e\x11\xdf\x16\x34\xbf\x07\xa4\xf2\x05\xca\x5e\x9f\xc1\xad\x6a\xcc\xf3\x21\x7b\x2a\xef\xd8\x5c\xe0\x13\xf8\x54\xd4\x21\x56\xd3\xf9\xaa\x14\x95\xa9\x11\xac\x64\x3b\xf0\x9c\xba\xf2\xec\xa7\x4a\x84\x56\x1f\x1a\x02\x9e\x2f\xe7\x60\x28\xfb\xb0\x52\xa3\x7c\x64\x94\x46\xb0\x5c\x30\x0f\xc7\x01\xf1\xf0\x87\x6e\x90\x8a\xd6\xe9\x71\xb4\x6a\xd3\x29\xdd\x0c\x5f\xa9\x97\x65\xb0\x30\x52\x89\xc3\x04\x57\xea\x28\x91\x38\x7c\x9c\xf7\xf1\x48\x88\x3c\xeb\xb5\xd4\x42\xfb\x46\xf9\x13\x02\x05\x35\xf6\x5c\xec\x79\xf2\xe2\x23\xe1\xf4\x03\xae\x81\x68\x48\x58\xd6\x77\x94\x9c\x88\x87\xc3\x43\xda\xa3\x70\xe4\x40\x1f\xd9\x07\x23\xcf\xa6\x9e\x5a\x4b\x6e\x60\xaf\xbf\x91\xe5\x62\x59\x7f\x0b\xd6\xf9\x01\x00\x19\xc8\xb6\x01\x6a\x0c\xbc\x6a\x5b\x0b\x52\x2d\x1c\x36\x16\x28\xc2\x99\x9a\xf6\x3c\x01\xeb\xdb\xad\xdc\x6f\x51\x91\x3e\x28\xb7\x35\x8e\x02\x62\x83\x4f\x27\x01\x0d\x34\x64\xc4\xd2\x83\x4a\x38\xfd\xc1\x42\x8a\x9c\x6d\xab\x0a\xba\x33\xf2\x8c\x62\xdf\x0c\x0a\x1a\x4d\xa9\x52\x6f\x01\x35\x30\x4d\x9f\x4c\xe0\x46\x6c\x6e\xc7\x34\x40\x80\x3a\x60\x8a\xc7\x91\x01\x6a\x69\xb5\x4f\x1b\xc0\x58\x16\x50\xca\xb7\xaf\x9e\x89\x35\xaa\xbe\xbb\xb6\x98\xfe\x98\xd6\xb5\x1a\x14\xd8\xc6\xe7\x0e\x81\x09\xaa\x2b\x55\x0d\x2d\xdc\x5c\xab\x85\x12\xeb\x93\x87\x32\xb5\xd0\x6c\x0e\xde\x6f\x48\x4f\xb3\x64\xaa\xca\xd1\xc8\x03\x3b\x9c\xa8\x0f\x51\xca\xb0\x86\xdc\x76\xe4\xaa\xb3\x65\x63\x53\xac\xac\x51\xc7\x17\x44\xb6\xcb\xd2\x0e\x9c\x19\xf5\xe6\x74\xee\x98\xe2\x40\xa0\xc1\x09\x47\x93\x86\x35\x4c\x8c\xb3\xbc\x63\x6b\xbf\x14\xc2\x9a\xc0\xae\x56\xab\xe1\xea\x8b\xa1\xaa\xa6\xa3\xab\x8b\xd1\x93\xc7\xbb\x4f\x46\x3f\x1d\x0f\x66\xf5\xbc\xf8\x6a\x60\xbe\x76\x1f\x3f\xf9\x6a\x54\xcf\xc4\x00\x56\xe7\xc0\x8e\x8c\x49\x80\xcf\xec\xa1\xc8\xf7\x47\xa5\xe1\x3a\xa3\x3d\x74\x51\x63\x0f\x1a\xa6\x98\x1d\xd8\x1e\x5b\x53\x25\x2b\x58\x0d\xf6\x8b\x8d\xca\x1a\x1b\x96\xbe\x1d\x73\x39\xb3\x55\xb2\x03\xe6\xd0\x21\xb6\x48\x5e\xe3\x2d\x84\xc9\xe7\x2a\x6e\x69\xf2\x58\xc0\xcb\x35\x99\x4f\x07\x82\xb0\x6d\xbb\xc7\x86\x24\xfe\x8c\x9c\x1c\x60\xfe\xb9\xe0\xa5\xa6\x04\x00\x6f\x6e\x76\x2c\x88\x8b\x76\x77\x61\x73\x81\xb7\x57\xb4\x32\x33\x19\xf6\xfc\x75\xaa\xdf\xdd\x34\x5d\x8b\x85\xab\x87\xa6\x30\x6e\x8c\x8b\x35\x49\x6d\x41\xcd\xc6\x54\xca\x54\x96\x9b\x2b\x2e\x20\x11\xf5\xd9\x98\x6b\x80\x20\x54\x25\x83\x3a\x16\x95\xc8\xa4\x96\xaa\xc4\x16\x9a\xb0\x87\xb5\x70\x2e\x4b\xf6\x29\x1b\xce\xf9\x5d\xb3\x9d\x4e\x47\x9c\x86\x12\xb7\x85\x2d\x09\x50\x0f\xab\x52\x54\x60\x81\xa1\x99\x5e\x66\x33\x30\xa4\x87\xfd\x03\x86\x1a\xb9\xa8\x24\x68\xf0\x82\x64\x01\x4a\xed\x33\x31\x9c\x0e\xd9\xa9\xd6\x4b\xc1\xfe\xf2\xb7\xdd\xbf\x3d\xc6\xf6\xce\x65\xd9\x6a\xee\x9c\xdf\x05\x61\xe6\xbc\x76\xe7\x3a\x2e\x86\x78\xd3\xb4\xf2\x87\xdb\xa4\x15\x49\xb7\x95\x88\x8c\x87\x72\x23\x73\xcf\x7b\x43\xb8\x7f\x00\xfc\x36\xa4\x0d\x0c\xc5\x35\xd8\xe4\xe6\x21\xf1\x9d\x0b\xd9\x54\x12\xb5\x7b\x0b\x95\x60\xb7\x22\x24\x17\x58\xfd\xfb\x91\x64\xca\xe4\xfa\x29\x28\x26\xb9\x1d\x71\x60\xde\x85\xe1\xda\xee\x01\x11\xe8\x85\x4c\xd6\x06\xc6\x23\xf4\x7d\xd7\x3c\x21\xc3\x87\x17\x30\x10\x03\x76\x3e\x66\x1c\x5a\xa9\x1e\x6d\xe2\x33\x76\x5a\x80\x94\x56\x1b\xec\x13\x6d\xb1\x80\xc8\x26\x6a\x41\xbe\xd5\xcc\x5e\xfe\x44\x07\xa0\x1b\xb6\x7d\xa0\x4b\x1f\x37\x06\x5b\x48\x50\x9f\x50\x82\xb0\x67\x37\x9c\x08\x63\x61\x19\xf1\x80\x9b\x01\x27\x82\xc1\x37\xe4\xde\x06\x04\x8d\xc9\xda\xa6\x0f\x4f\x46\x53\x4b\x9f\xdc\xba\xa5\x5a\x80\x8e\xa7\xcd\x59\x07\x45\x99\x46\xef\x0c\xd9\x31\xa2\x8f\x8c\x45\xbd\x12\xc2\xf0\x26\x88\x7e\xb1\xa1\x21\x38\x06\x50\x86\x3d\x7c\x4c\x9f\x51\x5a\x11\x98\x48\x69\x61\x3b\xfe\x5c\x81\x9f\xb8\x89\x42\x95\xee\x9e\x35\x95\x08\x21\x14\x7c\x05\x03\xcf\xdb\xf7\x5a\xcb\x24\xe0\x78\xb7\x11\xa1\xf4\xd0\xf3\x3b\x76\x71\x01\xa5\x75\xd2\xdf\x7b\x18\x4c\xaf\xab\xf2\xb6\xb1\xe2\xec\xa6\xdd\xb4\xde\x5e\xa5\xd3\x3c\xea\xe2\x7d\x3f\xc4\x4a\xc3\x76\x05\xeb\x0c\x1b\xf1\xe7\xae\xb2\x5b\x57\x47\x73\x8d\xbd\x0a\x62\xfe\x9f\x5e\x61\xa9\x8b\x4e\xbc\xba\x1c\x36\x79\x1e\xa7\x6a\x2f\xa9\xfd\x4e\x9e\xa7\x4d\xe8\x9d\x68\x2c\x26\xf8\x7b\x1d\x57\x8b\xe6\x95\x63\x2f\x49\x41\xfb\x61\x89\x74\xb6\x25\xae\x24\xae\x34\x7b\xa2\x85\x9d\xb0\x18\xfa\x76\xdc\xf7\x52\x57\x2c\x77\x41\xf6\x7e\x2a\x80\xdd\xa5\x33\xe8\x1d\xb8\x41\x2f\xe4\x8e\x2e\x85\x89\x3a\x83\xc3\xe5\x51\xe2\xe0\x0c\xb2\x7f\xfa\x29\x8b\xbf\x1e\xdd\x73\xb1\xec\xde\xe0\xc1\x32\x02\x3d\x60\x73\x0d\x80\xad\x50\xa6\x56\x7f\xb0\xf3\xf1\x12\xe0\x53\xa4\xf7\x78\x20\x52\x21\x8c\x3d\x60\x87\xa2\xa2\x6b\x15\xf6\xc6\x30\xf9\xb7\x32\x13\xec\x56\x54\x9a\xef\x50\xb1\x1f\x64\xbb\x5a\xe5\xb1\x42\x4e\x04\x18\x57\x2a\x6b\xd6\xe5\x90\x8d\x83\x2d\xfb\xe0\xdd\xfa\x89\x8e\x36\xe0\x7d\x4c\xc4\xf6\x4e\x73\x8b\x6e\x10\x07\xa4\xce\x81\x7b\xd7\xc6\xa3\xf4\xe2\xe8\x12\x51\xbc\xc7\xe2\x60\xf7\xaf\x8c\x70\x32\xde\x69\x6d\xc4\x2b\x23\x9a\xd3\xff\x07\xd7\xc6\x06\xb9\x52\x07\x15\xef\xbc\x5f\x12\xc6\x44\x4c\x78\x77\xda\xcf\xce\x8d\xd7\xbe\x1e\xe5\xe8\xf5\x5d\xd1\xbf\xff\xee\x90\x1c\x82\x8a\x3b\xee\xbc\xfe\xd1\xb7\x51\x65\xac\x57\xf4\x18\xfc\x2f\x9b\xa5\x9d\x56\xe6\x0d\xa3\x58\xef\x71\x2f\xd0\x85\x38\x53\xb5\xd8\x63\xa7\x27\x5f\xb3\x4a\xa0\xf8\x92\xb3\x72\x39\x1f\x03\xc2\xc5\x62\x69\xbe\x35\xeb\xd5\xe2\xce\x9c\x94\x5a\x61\x37\x48\xf8\x41\x16\xa8\xc3\xd4\x9b\x60\x28\x2f\xc3\xf2\x7a\x91\x42\xca\xa5\x9c\x83\x77\x51\x76\x0d\xd5\x60\xeb\x0e\xf5\x19\x24\xbd\x1e\x42\x8b\x72\x25\x22\x43\x55\xaf\xd3\xea\x86\xcc\xe6\x30\x43\xc7\x2b\x2d\x9e\x16\x8a\xd7\xdb\xbe\xbf\x70\xde\x3f\x76\x7a\xd9\xa6\x75\xbe\x0d\x42\x17\xb2\xac\x07\xf4\x6e\x30\x28\xc5\x5d\x3d\x28\x64\x29\x5c\x25\x34\xf0\x71\x4d\xbf\xff\xfe\x8e\x25\x1c\x34\x4b\x88\x27\xcb\x56\xd0\x00\xb5\x38\xe2\xba\x76\x12\x37\x04\x85\xab\x2b\xb2\xf5\x73\x38\x70\x5e\x1b\x16\xee\xe4\xa4\x70\x52\xac\x87\xec\xa7\x99\x2c\x44\x58\x9e\x85\x3b\x33\xa4\x86\xe0\x17\x72\x85\x22\x7a\xae\x43\x67\x05\xbf\xea\x5c\xcd\xad\xf6\xed\x30\x56\xd3\x70\x6b\xc8\x29\x0c\x24\xdf\x4e\x1d\xa5\xf5\x0c\x77\xa8\x2b\x13\xea\x25\x7d\xb8\x5e\xfe\xe1\x3e\x6e\xec\x61\xeb\x41\xb7\x79\xab\x88\xdc\xfe\x27\xee\x13\x0d\x4c\x9a\xd1\x88\x9d\x96\xec\x68\x56\xa9\xb9\xe8\x33\x14\x55\x99\x7e\x47\xb9\xcc\xe9\x2e\x2a\x73\x83\x20\xb2\x8b\xe8\x93\x24\xa7\xd4\x14\x18\x69\x7c\xda\xc2\x9f\x82\x48\x36\xd8\xc7\x28\xb5\xb4\xa0\x19\xd8\xe6\x42\x69\x28\x8e\xcb\x02\xeb\xce\xe4\x9c\x17\x6c\xa1\x64\x59\x6b\x42\xe4\x98\x73\x59\xd8\x22\x82\x79\x83\x86\xb3\x8a\x4b\x53\xc2\x47\x57\x33\x81\x50\x90\x13\xe9\x34\x47\xbf\xb9\xfb\xd6\xf9\xc6\xc0\x36\x52\x61\x3c\xcf\x2b\xa1\xf5\x47\xbe\xb5\xbe\xdc\x1f\x05\x4a\x98\x90\xcc\xd4\x8a\x69\x21\xac\x05\x79\x34\x34\x33\xae\x3d\x66\x09\x0a\x60\xf3\x3e\xfa\x40\xf0\x32\xf1\x45\xa5\xc6\x85\x98\x6b\x5f\xfe\xca\x02\xad\x80\x74\x5a\xd2\x10\xa2\x18\x5d\xdc\xd5\x89\x16\x6d\x42\x01\x80\xc3\x6b\x84\x86\xea\xa3\xbf\x3d\xf9\xea\x8b\x50\xb1\xcb\xac\xa6\xd6\x9d\x12\x96\x55\x7b\x7d\xb4\x94\xa9\x1a\xd7\x89\x8e\x6c\x6d\x75\xa8\x94\x7c\xa5\x6b\x65\x1e\xa5\x4f\xb3\xb8\x05\xfe\x5a\xfd\xe8\x51\x2a\x77\x78\x88\x86\x2c\x3f\x80\x80\xa8\x65\x59\xbf\x2b\xd7\xbf\x45\x90\x3e\x35\xcf\xec\xc5\x18\x58\x9b\xb0\xdf\x00\xf0\x83\x58\xf5\xb9\x62\xbc\x5c\x23\xca\x81\x05\x8d\x09\x5c\x50\x12\x0c\x13\x28\x23\x18\x56\x06\xf4\x14\x82\x93\xad\x9e\x29\x4d\xe4\x45\xb3\x4f\xa3\x4a\x50\x0d\x12\x9f\x42\x87\xec\x6a\x26\xd6\x58\x98\x7d\xfd\x80\xa2\xe0\x75\xd6\x74\x41\xa3\x65\xb7\xd4\x4c\x59\xd3\xb4\xa6\x05\x83\xb9\xf1\xda\x25\x8b\x45\xe1\xfd\x57\x5b\xba\x35\xa0\xea\x6d\x7b\xb6\xc5\x94\x7d\x74\x89\x6d\xff\xff\x2f\x45\xb5\xfe\x68\x07\x17\x70\xa9\x42\x2b\x88\xd1\xc8\xbd\x5a\x03\xf6\x9f\x05\xe4\x0e\xee\xb5\xf6\xd9\x93\x6b\xc1\x7a\x38\x1a\xbd\xbd\x20\x08\xfa\xd2\xb3\xb0\xd9\xe3\x4a\x70\x02\x3c\xc1\xe8\x4c\x15\xaa\x8a\x32\x98\xfb\x5c\x2b\xc0\xf0\x7e\xc9\xc0\x01\xd8\x1d\x44\x51\x73\x55\xd6\xb3\x28\xa4\x95\x7b\x25\xc4\x8d\x6b\x93\xb5\xb0\x9f\xc8\x3b\x52\xe5\x2a\xd5\x40\xcf\xd4\x0a\x71\x22\xc0\xc9\xe7\xf9\x25\xbb\xe4\x13\x5e\x49\x18\xea\xc3\x32\xaf\x94\xcc\x89\x54\xed\xbd\xd7\x8e\xfe\xe2\x8b\xf4\xd9\xb0\x9f\x0a\x6e\x6d\xdc\xfd\xf6\x78\x36\x00\xca\xdb\xf9\x6f\x93\x19\x2d\xca\xdc\x99\xaa\xe6\xe8\x14\x76\x25\x7a\x39\x03\x78\xa5\x5c\xb1\x6b\xc8\xea\x99\xd7\xf0\xf3\x1a\x65\xfd\x74\xef\xb7\xaf\x00\x85\xd0\x1a\x97\xeb\x78\x39\xb5\x1e\x11\x11\xc7\xaf\x14\x22\xc7\xfb\x03\xa2\xda\xc2\x13\x82\xb9\x13\x20\xc9\x1f\x2f\x01\x4e\xa4\x12\xee\xfd\x31\x26\x08\x01\x4c\x23\xa0\x9f\xc9\x39\x80\x78\x4c\x8a\x25\xe0\x1f\xf8\xd3\x5c\x4d\x1c\x4f\x0c\xb8\x73\x04\x86\x97\xc3\xce\x37\xb4\x60\x67\x88\x65\x5d\x88\x89\xa8\x04\x20\x69\xdb\xa9\x1b\x2f\xa7\x86\xbe\x55\x6a\x2e\x97\x73\x78\xae\x5a\x8c\xec\xa7\x9d\x3d\x53\x90\x2c\xbe\x93\xf9\xc1\x5f\x1f\xff\xfd\xcb\xdd\xbf\x3a\x9c\x3e\x0b\xb9\x53\x8b\xf9\x42\x55\xbc\x92\xc5\x9a\x2d\x4b\x43\x17\xc0\x30\xc6\x70\x21\x80\x48\x9a\x4b\x5d\x2d\x17\xd0\x45\x78\xf1\x25\xf5\x29\x36\xad\xd4\x72\xe1\x40\x23\x4b\x54\x69\x83\x21\x2f\x49\x85\xcd\x2a\xf6\x12\xc9\x8f\x34\x35\x29\x3d\xae\xa1\xb7\x5b\x9d\xd4\x36\x11\xbc\xff\xce\xa9\x1f\xd0\x10\xdb\xe6\x98\x7c\x57\x42\xd7\xaa\x12\xfe\x06\x05\x77\xe5\x8f\x77\xdf\x41\x78\x13\x0b\x7d\xf0\x3e\x64\x85\x35\x36\xf6\x8c\xcf\x45\x7e\xa4\xcc\xb5\x53\x37\x92\xb4\xe5\x47\x51\xe2\x4a\xa9\xfa\x2c\xc8\xe0\x1b\xe2\x55\x0c\x75\x34\x21\xe9\x57\x7c\x60\xc6\x71\x84\xa2\x53\xd0\x14\xf5\x5f\x86\xe6\x82\xef\x63\x74\x4a\x8f\xd0\xf8\x10\xbd\x32\x8c\x27\xdb\x76\x29\x86\xe8\x21\x03\xdc\x11\xb8\x73\x34\xcc\x9f\x4a\x19\x01\xa9\xa0\x2d\xdc\xb5\xad\x67\x38\x51\xd5\xfc\x1a\xcc\xe2\x4a\x55\x0e\xc0\x91\x0f\xe2\xb9\x19\xee\x08\x2e\xff\x75\xb5\x66\xd7\x00\x26\x6e\xc5\x02\xd7\xee\xb9\x0e\xb1\x54\x79\x1d\xec\xc1\xb1\x98\x71\x73\xd8\xe8\xba\x32\xdc\x52\xb1\x26\x9d\x76\xf4\x87\x0f\x25\xf2\xc2\x1c\x62\xd5\x1a\xe5\x00\xb6\x2c\xac\x63\x2a\x6a\xd2\x85\xd5\xdf\x83\xae\xe6\x75\xdf\xd7\x02\xdb\x1d\x94\x9a\xe8\x29\x8a\x54\x62\xc0\xcd\x42\x25\x4a\x5b\x94\xa1\xcb\x78\x6e\xcb\x32\x2b\x96\xb9\xb0\x47\x31\x94\x62\xe1\xab\x7e\xbc\x7a\xfe\xec\x2b\xac\xf6\x20\xd0\x3e\x1a\xb2\x4b\x59\x66\xee\x11\x16\x80\xb3\x81\x01\x9e\x3b\x40\x7c\xa0\x23\xf0\x66\x4e\xba\x5a\xe0\x9e\x34\x19\x0f\x28\x3f\x58\x52\xae\xb2\x25\xbe\xf0\x3f\x13\x75\x4f\x23\x59\xb5\x8d\x41\x93\xb9\x6b\x98\xbf\x4b\x51\x88\xac\x56\xd5\x61\x51\x5c\x07\x37\x14\x6b\x44\xe7\x1e\x61\xa5\xd6\x8e\x2b\x19\xba\xe5\x04\x74\x23\x5a\x0a\xcd\x42\xe9\x49\xed\xb5\x59\x90\x07\x86\xe5\xfb\x8f\xcb\xf3\xb3\x21\xde\x88\xe4\x64\x8d\x06\x07\xa8\x41\x0c\x88\x17\x66\x31\x1f\x7c\x04\x0b\xf9\xa3\x5f\x7a\x56\x08\xea\x90\x4e\x24\x00\xf2\x30\xc9\xbe\xc1\xba\x09\xe8\x64\x9f\xc9\x10\xa1\xc4\xa4\x84\x87\xef\x33\xdc\xc2\x90\xf4\xb5\xfc\x25\xd4\xc5\x0d\xe2\x0f\xfc\x5e\x30\x77\x6b\x17\x03\x0b\x16\xe8\x4c\xb4\x84\x9b\x3e\x60\x64\xd9\x64\x5b\xfd\xd9\x8e\xaa\x1f\x00\x16\x23\x27\x11\xcd\xd5\x5e\x3d\x62\xbc\x66\xb9\x9c\xc0\x89\x60\xae\x82\x0b\x29\xb4\x39\x4a\xe0\xe5\xd2\x97\xc7\x09\x3a\x07\x6c\x26\x61\x7f\x1b\xb6\xcd\x15\x02\x30\xeb\x2e\x1e\x5a\xbe\x6d\xcd\x2b\xff\xb2\xfb\xf5\x17\x5f\xef\x84\xf8\x6b\x08\xa0\xe8\x70\x1f\xd5\x0d\x5f\xef\x7b\xcb\x49\x2f\x9c\xc0\x85\xc3\x75\x2b\xce\x97\x35\x97\x77\x1e\x3f\x28\xee\x21\x3c\x07\x99\xbd\x8e\x91\x2a\x00\x17\x74\x53\x64\x75\x1b\xa6\x02\x45\x60\x24\x0e\x83\xe0\xa7\x95\x9a\x9b\x61\xff\x78\xd7\x4f\x97\x93\x88\x3d\x0a\xb2\xa7\x3c\xff\x5a\xb5\x3c\x10\x33\xee\xb1\xe7\x61\x33\x51\xa1\xc6\xb6\x0b\x1b\x4d\xdb\xd6\xf9\x41\x80\xc1\xbb\x36\x03\x7d\xdd\x46\x17\x4b\x78\xfb\x0d\x2c\x7f\xa5\x8e\x05\x8e\xed\xb3\x16\xc0\x81\x32\x07\x96\x8f\x37\xe1\x19\x0f\x86\xd5\x90\x49\x8b\x8a\x08\xf7\x41\x3c\x18\x6b\x65\x3d\xb7\xc1\xd2\x72\x2e\x0a\xac\xfc\xdd\xdc\x60\xc5\x20\x73\x8c\x8b\x5d\x3c\x9a\xf1\x85\x39\x2e\x2a\xe9\xfc\xc1\x37\xcf\x33\x37\xc4\xfd\x60\x66\x76\xba\x6e\x43\x93\xc2\x5c\x01\xca\x23\x22\x87\xdb\x96\x2e\xfa\x63\x0b\x1c\x1a\x81\x73\x2d\xc3\x19\x20\xaf\xf2\x14\x73\x39\x2a\x8a\xe4\x13\xb0\xdf\xbc\xe6\x13\x2c\x33\xa0\x10\x9a\xb9\x3b\xbf\x26\x28\x5b\x49\xd0\x27\x28\x37\x30\x5b\x40\x82\x71\x5a\x3e\x74\xdc\x50\xc6\x4b\xa6\x65\x81\x00\x26\xfa\x46\x2e\x10\x0c\xd3\x39\x74\xa0\x12\x8e\xcf\x9f\x83\xd3\x30\x40\xd9\x40\x51\x37\x16\x01\x58\x52\xc8\x92\x6b\x41\x2a\x1d\xb2\x44\x84\xc5\xa1\xd5\xe1\x1c\xda\x9e\x1b\x9a\x70\xc2\xb3\x99\x1b\x81\x10\xf9\x2b\xf2\x3a\x84\xf2\x56\x59\xe4\x4d\x7b\x97\x2e\x8b\x4f\x0b\x02\x46\x79\x0e\x58\x0f\x87\xa5\x17\x7a\x9e\xf4\x91\x2d\xa1\xa4\x9d\x81\xcf\x0f\x30\x59\x30\x97\x91\x96\x05\xa5\xdb\xa0\xba\x87\xaa\x78\x69\xdd\x3d\x33\x76\x1a\x6f\x71\xd7\x1a\x28\xbf\x61\xd1\x51\xb2\x35\x6c\xe8\x50\x59\x2c\x9d\x6e\x25\x2a\x52\x41\x65\xdb\xeb\x65\x39\xd5\xb5\xa8\xf4\xce\x1e\xe2\xdf\x09\x47\x97\xcc\x71\x10\x56\xe5\x1b\x38\x6c\x41\xe6\x20\x8f\x64\x13\xdb\x91\xef\xb3\xde\x4b\x3a\x0d\x63\x15\xb2\x50\x29\x10\x45\xc2\xaa\x64\xdf\x60\xf6\x6f\x43\x80\x42\xab\x9e\x0c\xcb\x27\x68\x8c\x0a\x1a\x13\x78\x5a\xe8\x94\x22\x74\x30\xa0\xa3\x11\xde\x29\x0e\x3e\xfa\xc8\xbe\x8c\xcc\xf9\x8d\x40\xb9\xd3\x52\x04\x0a\xcc\xdb\x7f\xf9\xeb\x93\xdd\xaf\x77\xb6\x52\x5a\x01\xd1\x2a\xb3\xaa\x6d\x91\xb5\x54\x0f\x92\xba\x57\x89\xd0\x62\xea\x6d\x87\xee\xdb\x06\x96\x39\xa9\xac\xe6\x36\x7b\xa0\x78\xe4\xf4\x97\x3c\xfa\xb3\x27\x17\x4d\xd2\x62\x65\x3f\x44\x60\x9c\x41\x2d\xe5\xb0\xfd\x73\x95\xbb\xa4\xd6\xab\x5a\xe9\x9d\x6e\x27\xf5\x8a\xfe\x5c\xb5\xe7\x87\x2b\x28\xbf\x8b\xda\xf3\x97\xef\xad\xf6\xdc\x74\xa3\xde\x52\x09\x40\x1f\xde\x0e\x9f\x28\x5c\x04\xc7\x22\x2b\x38\xca\x82\xc0\xc2\xc0\x16\xbb\xed\xd7\x80\xb2\x9d\x20\xcf\x7b\xe9\x31\xd9\x76\x46\x60\x2e\x7d\x03\xbd\xab\xf7\x73\xf9\x73\xb9\xc1\x61\xf0\xb5\xd9\x81\xbe\xb2\xcf\x59\xef\x7a\xd8\x6b\x60\x5d\x99\x83\x87\xcc\x90\x6e\xad\xe2\x17\x98\xcf\xb2\x03\xf6\xda\x2d\xfd\x5e\x48\x01\x7a\xbf\xec\x3b\x22\xf8\xca\x89\xa1\x03\xd7\x9f\xa1\xd6\x70\x52\xcf\x38\xb0\x9b\x83\x73\x18\xb9\xe1\x58\x35\x9f\xf6\xcc\xbb\x29\xa7\x21\x91\x79\xa0\x76\xda\x97\xb8\x4f\x52\x9c\x73\x3c\x14\x29\x16\xba\x61\xdc\x16\x67\x70\x8c\xb4\xa3\x37\xa1\xf1\x59\x0b\xa9\x3e\xe2\x90\x3d\xd6\x80\xd4\x00\x4a\x68\xc1\x09\x87\xf4\xdd\x2c\xb0\x01\xd2\xa4\x87\x0e\xa1\xe1\xd3\x4f\xd9\x23\xca\xd4\xfd\x64\x7d\x65\x08\xfc\x27\x9a\xec\x5d\x9c\x46\x75\xad\x3c\x4d\xb7\x7a\x47\xbc\x64\x1c\x5a\x24\x89\xb8\x5f\xdb\xaa\xe0\x30\x03\x27\x10\xee\xfd\xd6\x59\x50\x74\x6f\x88\xb6\x61\xe1\xa3\x76\x0f\x3e\x68\x07\x98\xce\x78\xc1\x2b\x6c\x3d\x49\x53\x27\x2c\xee\x06\x94\xfb\x5e\xfd\x68\x9d\x09\xc8\x3d\x9e\xc3\x59\x67\x45\x1d\xb6\x2e\x2c\x1d\x15\x6c\x0c\x1f\x40\xe4\xe5\x92\x8e\xc9\x80\x5a\x60\x76\x2b\x6e\xa2\x4f\x47\xe2\x6d\x79\xe1\xc2\xb4\x67\x2d\x89\xb4\x0f\x7c\x55\xfb\xe9\x34\x04\x70\xd8\x75\x91\x8c\xcb\x4b\xdf\x28\x47\x23\xf6\xa2\x12\x13\x79\xe7\x65\x69\xd9\x8c\x2b\xba\x2e\x58\x97\x61\x37\x62\xed\x2e\x38\x51\xa9\xaf\x7b\xe0\xdc\x22\xae\xe9\xb5\xfc\xe5\x97\x84\x4e\x87\x47\xf5\xa4\x36\xbe\x31\x8d\xa4\x81\x71\xad\x7b\xd3\xba\xf0\x7a\x16\x27\xae\xa7\x09\x99\x88\x4d\xa1\xf2\x5e\xbf\x91\xbf\x0c\x63\x43\x74\xa0\xc9\x41\xac\x2b\xd7\x5c\x84\x75\x34\x81\xf8\x2f\x99\xd8\x27\x6d\x5e\x8d\x01\x55\xc2\x26\xfb\xf4\xd3\xce\xd5\xd1\x2e\x3c\x8f\x93\x35\x70\xb6\x3b\x0c\xe8\x47\x23\x76\xac\xf0\xf6\x26\x6a\xcb\xa8\x0d\x2d\x01\xd7\x4c\xdc\x99\x2b\x20\x48\x92\xa4\x32\x64\xc9\xdc\x3e\x32\x55\x6a\xf0\x5c\x51\x33\x9e\x55\x4a\x6b\xc6\xc9\xc7\x74\xf8\x24\x0b\x36\xd7\x70\x09\xd3\xf6\x62\x0b\xf3\xd6\x5c\x7c\xee\xa9\xab\xb1\x48\xdb\xfd\xf1\x46\x7d\xc1\x2a\x78\x62\x97\xc1\x93\xe4\x3a\x88\xb0\x59\xe3\xc9\x7b\xf2\x4b\xa0\x3d\x11\x37\x2b\x3d\xc6\x4f\xa2\x19\x8c\x11\xd2\x70\xde\x36\xcd\x55\xa3\xa4\xcd\xd3\x15\x02\x50\x85\xb7\x9f\x78\xa1\xb4\xca\x08\x5e\xfe\x1e\xc5\xb5\x25\x4c\x25\xdb\x2d\x08\xb3\x74\x3d\x35\x36\x73\xb5\xbd\xaf\x34\x52\xa4\xc7\xac\x89\x83\x14\xde\xa8\x3c\xf1\xde\x60\x0c\x65\xcd\x9f\xcc\x25\xd6\xdb\x45\x39\x63\xa8\x4d\x5c\x08\xc8\x5d\xdb\x74\xdf\x9b\xf9\xf8\x43\x03\x70\xc1\xe1\x56\x69\x86\x2f\x91\x13\x0c\xa0\x13\x19\xed\x71\xa9\x26\x41\x7e\x1d\x1a\x5a\x51\xfb\x02\xe1\xc9\xc3\x4c\xab\x08\x14\x1a\x4d\x90\x2c\x74\xb9\x1d\x62\x1c\x95\x8d\x36\x55\x4e\x26\x66\x37\x8b\x6f\x13\x62\xa7\xbd\xab\x65\x95\x3d\xa4\x42\xcb\x2a\x92\xc2\x48\x78\x58\x58\xa8\x52\xc3\x33\x4b\xd8\x8d\x86\x75\x55\x64\x28\x1d\x1b\x59\x99\xf2\x9c\x9d\x55\xba\x6a\x27\xf7\x09\x07\x38\xbe\xb9\x22\x6e\x1b\x3c\x9a\xf6\xd1\xf6\xc7\x35\xdb\x8a\xb4\x6c\xbf\xe9\x35\x96\xec\xb1\xc2\xf1\x6d\x5e\xd8\xa3\x8b\xdf\x93\xe4\xc5\x8f\x78\xed\xd0\x75\x6d\x64\x9a\x72\xdb\x30\x3a\x21\xf1\xc3\x26\x7b\x8e\x77\x7a\x95\x09\xec\x5f\xd3\xac\xf6\x43\xd4\xd2\xee\xd7\x58\x7e\xb5\xd9\x4a\xa6\xad\xca\xd0\x27\x39\x84\x7e\x4e\xdb\x69\xcf\x29\x1c\xd8\x0d\xe6\x2c\x96\xd3\x0a\x38\x1f\x56\xad\xff\xe3\xdd\x6e\x36\x13\x07\xee\x7f\xac\x32\x3e\xae\xde\xff\x26\x6d\xfc\x7b\x55\xea\xe1\xfe\x9c\x38\x08\xba\x65\x40\xe9\x8d\xb5\x41\xb7\xde\xdd\x21\x0e\x5a\x6b\xea\x1e\x9b\xc3\x4e\xfd\xcb\x14\x3b\xdf\x2c\xbb\x6f\x2d\xd7\x02\x7d\xcf\xa6\x92\xe4\x26\x25\xb1\x87\xd5\x91\xd8\x4a\x88\xcf\x94\x96\xa6\xbd\x7c\x4f\x55\xfc\xd1\x88\x1d\x3a\x67\x75\x0d\x65\x82\x95\xd3\x65\x77\x94\x71\x50\x0a\xad\xd9\x9c\x97\xa8\xa0\xa5\x15\x3d\x88\x2c\xb8\xd6\x81\xba\x01\x8e\x6d\xae\x56\x65\x92\xaa\x44\xa6\x73\x2c\xd8\xba\x4e\x0e\x16\x10\x0c\x7b\x2b\x8a\x4b\x08\x12\xa4\x29\xd7\x30\x2e\xa2\xbd\x40\xfe\x6d\x2b\x24\x6c\x98\x21\x5c\xcd\xdc\x81\x8f\xa4\xa7\xaa\x22\x9f\x2d\x99\xac\xd7\x7d\x56\x09\xf0\x1a\xd0\x3a\xf4\x5a\xec\x8a\x9a\x4e\x0b\x0b\x83\xfa\xb0\x55\xf9\x41\xd6\x65\x0b\x65\x07\xd4\x3c\x6e\x45\x85\xa6\xe1\x44\xa1\xac\xab\x46\x59\x6b\x4b\x0d\x41\x51\x83\x98\x1b\x30\x1c\x1f\xbe\x47\xa3\x1c\x3d\xf8\x8e\xbd\xfe\x85\xed\xb1\x5e\x2f\x9c\x81\x14\x0d\xea\x50\x87\x78\x17\x4a\xd4\xb9\x86\xfe\x8c\x45\xf4\x67\xc9\x69\x63\xa9\xd9\x57\x1f\x08\x4c\xc2\x1f\x07\x01\x88\x43\xf2\x22\x50\x8b\xbb\x9a\x57\x82\x3f\x08\x17\xc1\x61\x1e\xf0\x32\x37\x45\x35\xd9\x7e\x78\x73\xc6\xb7\x64\xc2\x30\x03\xef\x70\x15\x47\xd7\x21\xbc\x80\x47\xaf\xc3\x17\xa7\xee\x31\xcc\x2b\xdd\x7d\xc6\x96\x7a\x69\x6f\x1b\xe6\x66\xfc\xe2\xe8\xf8\xf0\xea\xd0\x49\xef\x3f\x1c\x67\xef\x11\x13\x4c\x79\xef\x83\x91\x10\x34\xe0\x8f\xa0\x24\x98\xd2\x4c\x8e\x77\x42\x49\x78\x3f\x3e\xfe\xc3\x80\x25\x24\x60\x10\xfc\xd5\xac\xbd\x20\xcc\x2e\x74\x3a\xcc\x8e\x0b\x73\xaf\x23\xf6\xc5\x65\x3b\x17\x8b\x4a\x80\x93\x87\x9d\x8d\xfc\xff\x17\xef\x40\x1c\x1e\x59\xc2\x6b\xc6\xa6\x82\x47\xec\x4b\x51\x9f\x96\xa5\xa8\x7e\xbc\x7a\xfe\xcc\x0b\x8a\x53\x6f\xf7\xd7\x1d\xb9\xae\xbd\x01\x05\xbc\x86\x69\x51\x82\xc7\xc3\x60\x1b\xc5\x4f\xf3\x74\xcc\xa3\x1f\x5f\xd0\xb4\xb7\x9d\x0f\xb5\x25\x50\xab\x85\x9d\x96\xec\xf4\xe4\xeb\x7e\x40\xaf\x81\x50\xc2\xe4\xe2\x72\x21\x47\xc2\x56\xe7\x76\xc2\xae\x4d\xbd\x47\x38\x8e\xb0\x1c\x01\x6c\x4e\xe4\x43\x16\xa8\x20\xe5\xa8\x6b\x28\xb2\x1b\x73\x5d\xd4\xa2\xbe\xf2\x99\xb6\xac\x6b\x24\x74\xff\x17\x61\x25\xcb\xc9\xc8\x29\x77\x13\x5b\xd1\xdc\xda\x30\xee\x84\x51\x40\xf0\xd7\xa6\x4e\x7a\xc7\x56\x86\xd2\xd4\x02\xb8\x95\xe2\x96\xbc\x32\x9d\x9e\x7c\xcd\xc6\xcb\xe9\x0e\xf2\xde\x97\x62\xcc\x75\x2d\x79\xf9\xf9\xa5\x5a\xcc\xa4\xe9\xb8\x98\x93\xc7\x32\x79\x83\x59\xac\xe3\xd7\x02\x7c\x98\x83\xe2\x30\xd5\x49\x3e\xce\x1c\xca\xb9\x59\x62\x84\xbd\x4a\x5e\xa1\x7a\x9a\xad\x66\x6b\x26\xcd\x8f\x89\xaa\x32\xab\x4d\x89\xfb\xc0\xda\x46\x0c\x37\xbd\x1f\xde\x77\x9f\x7c\x00\xc2\x81\x7f\x81\x44\x7d\xa3\xcd\x6c\xd9\xfb\xa2\x10\xbc\xd3\xe1\xf9\x3e\xe8\x04\x76\x91\x3f\xf0\x09\xe8\xab\xd6\xe3\xc9\x87\xb9\x56\xfa\xc3\x6d\xc3\xbb\x05\x35\xf5\x7f\xec\x95\xd2\x8e\x35\x16\xf3\xdf\x79\x99\x8c\x78\x87\x0e\xab\xbe\x0d\x80\x32\x8d\x0b\x86\x67\xc9\x46\x23\x84\x58\x1f\x23\x26\xcc\x44\xd4\xd9\x2c\x50\x76\x76\x44\x87\x2c\x0e\xa6\x8a\x8c\x96\x50\xc3\x68\x13\x5e\xeb\x83\xad\xc5\x1f\xae\xde\xd1\x3a\xa4\x64\x44\xe4\x5d\xb5\xc1\x53\x7f\xac\x26\xb0\x1f\xab\xdc\x98\x24\x2d\xb6\xdf\x4b\x8a\x9b\xcb\xf7\xa1\xca\x21\x81\x42\x88\xe5\xd1\x60\x01\xb8\x3a\x9b\x67\x53\x53\xc8\xfd\x68\x3b\x1e\xb8\x4d\xa7\xe2\xe9\x04\x7c\xec\x01\xc7\xd3\xba\x08\x01\xe2\xab\xaf\xaa\x4f\xbe\x32\xe1\x7a\xea\x79\xb8\x84\xde\x9a\x19\xa2\xf8\x09\xd6\x69\x5a\x84\xb2\xf4\x47\x2e\x98\xde\x1e\xd8\x37\x07\x6c\x37\xdd\xd0\x80\xa9\x35\x27\x04\x1c\x6d\xe8\x84\xb9\x66\x73\xc3\xe5\x82\x77\x5b\x53\x5c\xaa\x41\x2c\x9c\x54\xfb\xf3\xf5\xe3\xb6\x4f\xb9\x94\x45\x51\x3c\xfd\x2d\xa1\xfe\xab\xd4\xf2\x4d\x94\x14\x65\x8f\x37\x54\x73\x4d\x43\x73\x1e\x2c\x3e\x84\x46\x36\x0f\x9b\x0d\xd0\x02\xef\x24\x09\x7d\x9f\x4b\xfd\x87\xb4\x58\xfc\x83\xf6\x8a\xe8\xaf\x7d\x15\xcd\xa7\x27\x5f\xd6\x1f\x08\xbe\xbe\x02\x00\xa3\x80\x8b\x84\x66\xdb\x16\x70\xa9\x50\xda\xda\xbd\x79\x0e\x6e\xa7\xef\x99\x2b\x47\xe3\xc8\xbe\xce\xad\x0f\x57\x2f\xbc\xf6\x04\xc6\xb6\x49\x83\x63\x9b\x3a\x8d\xc9\xb2\x79\xad\xa5\x8c\xe1\xda\xe5\xbd\xdd\x7a\xa8\xf4\x22\x55\x5e\x9a\xfa\xde\x23\x84\x7c\x17\xee\xde\xea\x37\x83\xb9\xa1\x2f\x2a\xf4\xfe\x02\x36\x29\x3c\xcb\xc0\x2c\x07\x99\x6d\xd0\xb8\x84\x1b\x3f\xf2\xaa\x78\x7f\x24\x1b\xb4\x5b\x2e\x0b\x44\x06\x2d\x6b\x59\x90\xe9\x4c\x64\x73\x0f\x16\x92\x20\xa0\x43\xf9\x8e\x69\x5a\xc0\x7f\x5b\x69\x59\x10\x14\x9d\x7b\x60\x0e\xe3\x67\x51\x4e\xa2\xcc\x52\x33\xf1\x5f\x4b\x5e\xb8\xcb\x1f\xb9\xae\xb0\x5a\xa7\x28\x1e\x84\xac\x74\x53\xd8\x7d\x3c\x02\x40\xb4\x1a\x4c\x87\x40\xe7\xd7\x5b\x12\xc1\xa5\xac\xe0\x99\x98\xa9\x02\x50\x52\x03\x6f\x39\xd6\x98\x68\xa1\x16\x68\x30\x1e\xb6\x03\x74\xad\x8b\x82\xb4\x59\x2d\x23\x41\xfe\x82\x45\x35\x9c\xcb\xac\x52\x5a\x4d\x6a\xb0\xf2\x72\x5f\x03\x91\x4f\xc5\x68\x51\xf0\x7a\xa2\x2a\x67\x30\xb4\xfb\x78\xf7\xab\x27\x5f\x8d\x68\x2d\x45\x63\x75\x90\x94\x2d\x86\x94\x29\x5a\x60\x76\xe5\x47\x83\xfb\x40\x99\x52\x7a\x61\x8d\x46\x0c\x41\x53\x03\x48\x09\x74\xdc\x4d\x53\xbc\x4f\x94\xb0\x69\x78\xd3\x26\x89\x4e\xc9\xcb\xdc\x11\xc1\xab\xe3\xe5\x8b\xc3\xa3\x13\x90\xc3\xf7\xda\x38\x80\xbb\x5f\x7f\xfd\xf5\xe8\x6e\x56\xcf\x8b\x1e\x2a\xda\x3d\x3f\xbc\xfa\xd1\x67\xeb\xcc\xf4\xf7\xd1\x73\x5e\xcf\xe0\xbf\xe7\xcf\x28\xeb\xe5\xab\x1f\xee\xcb\xf9\xe4\xf1\xe3\xc7\x23\x7d\x3b\xed\x91\x94\xc8\xf9\x6f\xb0\x78\xd1\xa6\x25\x7b\xad\xb6\x9b\x9b\xcb\x9c\xd7\x33\x13\x17\x37\xd0\xc4\xe8\xdb\xe9\x5e\x5c\x39\xe0\x65\x9b\xcb\xae\xf3\x2b\x4f\xcb\xb2\x54\x0c\x0d\x74\xbc\x6f\x89\x61\x74\xc1\x3f\x2d\x0d\xb9\xd7\x32\x73\x2d\xdb\xf6\x26\x96\xd6\xf4\x32\x61\x74\x79\x3b\x75\xb6\x8c\x74\x51\x8a\x1a\x14\x9a\x5b\x9a\x8e\x34\x13\xc7\x9d\x4a\x1a\x13\x52\xca\xe6\xd0\x24\xf5\x53\x41\x5d\xd4\xf7\x80\x6c\x92\xbc\x8b\x09\xdf\x01\xa0\xab\x71\x74\xe4\x5c\xb2\x15\x75\xd0\x6a\x41\x70\x7a\x9e\x29\x90\x7b\x51\xcb\x77\x5a\x63\xbd\xc7\x16\xca\x6c\x17\x43\x3e\x44\x59\x57\x6b\x34\x46\x1f\x86\xba\x8e\x1b\x26\x21\x74\x96\x90\x6a\x59\xbc\x00\x3f\xfd\x94\x79\x73\xb0\x89\xaa\x84\x9c\x96\xe7\x70\x21\xef\x05\x4d\xfe\x09\x18\xfc\x42\x70\x40\x24\xbc\x7c\xf5\x43\xd4\x98\xf4\x68\x43\xc6\xef\xd7\xb6\x9f\x7d\x64\x2c\xbd\xb7\x12\x80\x84\x1c\xfa\x3b\x73\xa3\xad\xa4\x5b\xce\xa6\x85\x1a\xf3\x42\xb3\xe7\x97\x87\x8b\x05\x88\x9a\x48\x2a\x7a\x54\x09\x43\x0a\xb9\xd7\xb4\xc4\x33\xc2\xd0\xfc\xde\xb2\xd4\x7c\x22\x7a\x6c\x51\xc9\x5b\x59\x88\xa9\xd0\x6c\x9b\x7c\x29\x83\xf9\xcc\x4a\x96\xb9\x5a\xe9\xbf\x33\xbe\x00\xb4\xa6\xcf\x46\xb0\xd3\x32\x28\xf3\xb9\xa5\x91\x2f\xa1\x94\x67\x2a\xe3\xc5\x53\x5b\x49\xe4\xa3\x7c\x59\x66\x7e\x85\x90\x7e\x3d\x36\xb4\xe1\x7f\xdb\x8c\x33\x44\x0c\xc5\x9d\xc8\x12\xe5\x36\x3d\xd1\xba\x3a\x78\x35\x7d\x0c\x6e\x99\x77\xe1\xff\x27\xf0\xff\x17\x9e\x3b\xd8\x58\xea\x76\xca\xa5\x78\x54\x49\x57\xf9\x8e\x77\xb6\xef\x01\xfb\x4d\x3d\xa9\xa0\x10\xda\x5e\x48\x4e\x2e\x5f\xfd\x00\x66\xa5\x16\xf8\x8d\x84\x9b\xa7\x27\xac\xe0\x19\x98\xa4\x4b\x2b\x9d\x83\x31\xaf\xc4\x12\x14\x71\x2e\x5f\xfd\x70\xe4\x72\x1c\x78\x81\x9c\xf7\xf4\x44\xef\x6e\x56\x20\xb8\x70\xbe\x2b\x26\xe4\xbb\xe2\x3d\x5c\x57\x10\x6c\x2b\xfb\x5f\xb2\xac\x45\x85\xd8\xc1\xb8\x16\x74\x24\x7c\x7c\xc0\xd2\x08\x06\x1b\x79\x16\x53\xb6\x3b\xba\x4e\x4f\xbc\x28\x12\xbd\xf2\xb9\xc2\xc1\x6d\xd9\xab\x1f\xd0\x86\x1e\x10\x66\xec\x2d\x71\x65\x92\xfd\xea\x64\xdf\xa6\x9c\x52\xac\xd8\x1c\x5c\xea\xa2\x85\x1f\x0c\x35\xf0\x5b\x64\xef\x55\x32\xb8\x1b\x3b\xc1\x2d\x99\xe6\x93\x5a\x9a\x2c\x6b\xb5\xe5\x6c\x07\x6b\x5e\x4d\x89\xc9\xb1\x6f\x30\xce\x2e\x16\x76\xe1\xcb\x8b\x53\x20\x0d\xfe\x08\x1a\xea\xdb\x29\x88\x77\xb6\x7b\xae\x07\x3d\xd3\x14\x93\x31\xf0\xdb\x92\x9c\xd4\x64\xf0\xef\xbf\x7b\xeb\x43\x1c\x65\x9a\xb5\xed\x5e\x2e\x6f\x7b\xce\x03\x4d\x3b\xeb\x50\x06\x13\xd4\xfb\x46\xdf\x4e\xbf\x35\x57\x00\x33\xee\xe6\x4e\xfd\xcd\x08\x42\x02\x25\xcf\xdb\x29\x19\xf8\x25\x4b\x9b\xc8\x4a\xe3\xa9\x80\x59\xc8\xc0\x15\x46\xc4\xc7\xed\xa4\xdc\x62\x40\x4c\x2b\x65\xc8\xed\x53\x61\xd4\x84\xee\xf2\x0c\xc7\x52\xe6\x58\x5e\x22\xf1\x26\xd7\x1a\xe1\x68\x98\x31\xa0\x6d\xb9\x83\xfb\x32\x33\x3d\x07\x63\x41\x84\xf3\x9c\xab\x1c\xa1\x4a\x40\x36\x2c\x74\xc6\x17\x02\x60\x8e\xed\x8e\x7b\xae\xf2\x65\x61\x6e\x71\x95\x74\x9a\x5a\xec\x7f\x19\x8a\x0a\x3c\x96\x21\xc5\xe0\x7b\x85\xd7\xd9\xec\xc7\x7a\x5e\xa0\xa3\x72\x76\xc0\x46\xaf\x3f\xea\x7d\xfa\xcd\xb7\xbf\x8c\xfc\xee\x3d\x81\xe2\x9d\xde\x6b\x36\xe3\x15\xcf\x6a\xc4\x6f\x81\x95\x38\x95\xb7\xc2\x7a\x0b\x34\x1b\xda\x34\xa4\xe1\x8a\xc6\x6f\x5a\x4a\x06\x88\x2b\xfe\xe2\x89\x55\x98\xcd\x24\x4b\x2d\xaa\x1a\x49\x4d\xad\xe0\x7c\x82\x72\x88\x64\xd9\x72\xb0\xec\xe5\xb8\x90\x59\xe3\x11\x03\xcb\x32\x9d\x22\xf7\x88\xfe\x6a\xa3\xeb\xca\x5e\x35\x31\xca\xde\xa3\x61\x1c\xd8\x41\x73\x3c\x80\x34\x9b\x52\xbc\x19\xca\x23\x48\xd2\xa0\xf8\xba\xae\x22\xb5\x23\x6c\x82\x2d\x1c\x96\xb4\x95\x33\xa0\xd0\x2e\x17\x77\xa0\xe7\x49\x01\x05\xd7\xf5\xa9\x0f\xb4\x9a\xfc\x36\x1d\x54\x39\x84\xaf\x7d\xca\xfc\x8d\xa9\xd3\x6b\x2f\x9b\x30\xaf\x19\x6a\xb9\x38\x93\xc4\xcc\xd6\x91\xca\xc5\x61\x8d\xc5\x05\x62\x1e\x60\xd6\xbe\xf8\x72\xcf\x1d\x2d\xa3\x11\xfb\xc8\x7d\xd0\x94\x1c\xb0\xde\xa7\xff\xb5\x54\xf5\x7e\xcf\x4b\x6c\x02\x3c\x08\x5b\xca\xdf\xa3\x52\x3e\x4d\x95\xc2\xe7\x8b\x7b\x0a\xf9\x3a\x2a\xa4\x97\x2a\xe4\x2f\x77\x4f\xfe\xb6\xdf\xdb\x07\x53\xd4\xae\x3d\xb0\x8f\xee\x21\xf1\xd1\xa1\xf7\xe9\x5f\xbe\xf8\xba\xb7\xa1\xd6\xbf\x3e\x8e\x6a\xfd\x26\x55\x6b\x71\x4f\xf7\xff\xfa\x24\x2a\xe3\xdb\x54\x19\xd3\xee\x32\x1a\x7c\x70\xdb\x8c\xc2\x89\x1c\xfc\x42\x31\x3c\x0a\x4e\xa8\x9b\x4f\x24\x9d\x07\xb0\x32\xf4\x72\x8c\x2b\xdc\x67\xe9\x53\xfa\xa8\xd0\x70\xe5\xe1\xca\xfa\x9c\xed\x62\x0a\x5b\x9c\x5f\xcc\xa1\x4d\x55\xa2\x25\xec\x3b\x4b\xbd\xef\x69\x01\xdb\x23\x12\xf7\xd6\xd0\x36\x51\xe6\xef\x40\xdf\x62\xa2\xa4\x51\xfa\x53\x2b\xb0\x9e\x35\x9c\xb8\xce\x2a\x89\x98\x17\xbc\xae\x79\x76\xa3\x9b\x3e\xb1\x3e\x7b\x8b\x79\xae\xcc\x7f\x78\xd1\x75\x04\x68\x98\xa2\x34\xec\xd0\xd2\x94\xdc\x3f\x60\x85\x76\x3f\x18\x19\x3c\xf3\x3d\x55\xd5\xf7\x28\x19\x83\x5b\x78\x8b\xcb\x84\xfa\x81\x69\xa7\x97\xb4\xd0\xc4\xd3\x47\x36\x2c\x3c\xad\xce\x91\x9e\xa9\xaa\xce\x64\x95\x2d\x65\xcd\x66\xa2\x58\x68\xb6\x10\xd5\x04\x5f\xa1\x11\x5f\x8b\x1c\x08\xdf\x94\x6a\x45\x6a\xac\xe2\x56\x54\xde\x47\xee\x68\x94\xa0\xe6\x7d\x26\x28\xb0\x58\x13\x49\xaf\xd1\xa9\xaa\xd4\x2c\x70\x49\x81\xbb\x4b\x4d\x6a\x0f\x8b\x30\x41\xc3\x5d\x51\xc9\x8c\xe5\x6a\xce\x64\xae\xa3\x4b\x06\x50\x5c\xd3\xb1\x86\xc5\x56\x40\xaa\x61\xa0\xf6\x63\xef\xa0\xc8\xe6\x04\x72\x8c\x36\xd7\xd8\x47\x99\x25\xaa\x4b\x9b\x5e\xcf\x64\x4d\x77\x14\xd0\x90\x15\x5a\x54\xb7\x02\xd4\x27\x00\x3b\xc1\x42\x46\xc0\x71\x0b\x4b\x00\x44\x39\x0b\xa5\x2a\x06\x2b\x56\xd6\xd6\x4f\x4c\x24\xa7\x29\xf3\x3e\xe3\x73\x55\x4e\xd9\x9c\x97\x6b\x53\x1c\x0a\x5d\xfa\x74\x5e\x69\xf6\xcd\xb8\x8a\x4c\x46\x11\x50\xb2\x16\x15\x37\xc3\xbf\x2a\x24\x48\xc1\x79\xa5\x87\x01\xf7\x48\x98\x16\xe0\x9c\x16\xbc\x2f\xa2\xf5\xe7\xfb\xf8\x71\x43\xf8\xaf\x0e\x66\xf8\x2a\x12\x9c\x35\x79\xdd\xc6\x22\x75\x5f\x78\x38\x79\x06\xc6\xca\xdc\x42\x5e\xcb\x91\xa6\x20\xd9\xa7\x9f\x46\x99\xac\xf0\xc9\xd0\x81\x44\x82\xa1\x89\xbc\xb2\xf7\xd8\xab\x93\x7f\x5c\xbd\x39\x3b\x3f\x3e\xf1\x74\xad\x91\xf4\x55\x20\x9c\xda\x8f\x44\x07\xb1\x40\xb5\x29\x1e\x74\x59\xcc\x5d\xc7\xb4\xf8\xe4\x4e\x64\xf0\xc8\x7d\x52\xde\xca\x4a\x95\xc8\xc4\xf2\xf2\xa5\x16\xc7\xe7\xcf\x03\x4f\x87\xf8\x16\x4b\xc5\x00\xbf\xec\x78\x5e\xfb\x83\xa6\x67\x27\x80\xd4\x7c\xe8\x98\xb3\x10\x70\xed\xbe\xb1\xb0\xd8\x37\x1d\xe3\xd0\x65\x5d\x11\xde\x87\xa8\x01\xf7\x52\xad\xe8\xf2\x68\x65\x6e\x71\xbf\x40\xe6\x16\x07\x79\xb6\xf1\xe8\xf2\x32\x74\x45\x81\x17\x7c\x9e\x65\x62\x51\x5b\x2b\x7f\x78\xbd\xb5\x78\x64\xb2\x64\xcb\x52\xd6\x80\x86\xf1\xd1\xe2\xee\xa3\xa1\x5b\xc0\x52\xbf\x2c\x65\x5d\x08\xed\xc1\x32\xcd\x78\xf0\x52\xce\xc1\x86\xed\xb4\x26\xc4\xb2\x23\xb5\x2c\x03\x2f\x6e\x63\x50\xcf\x39\x9d\xf3\xa9\x38\x5f\xd6\x91\x83\xb7\x20\xea\xb2\x90\x99\x48\xc6\xfc\x24\xf3\x7a\x16\xc6\xdc\x3d\x2d\xc4\x5d\x2b\xe0\x87\x4a\x2d\x17\x51\xe8\x79\x95\xcb\x92\x17\x8d\x88\x4c\x15\xcb\x79\xb3\x8d\x18\xa8\x7d\xc0\x24\xaa\x62\x82\xe5\xaf\xe2\x90\x17\x4a\xcb\x5a\xde\x8a\x38\xf4\x72\x56\xc9\xf2\x26\x0e\x3b\x13\x53\xde\x4e\x79\x6e\xba\xe8\x83\xa6\x95\xcc\x2f\xc2\x3a\x28\xe0\xa4\xcc\x5b\x61\x97\x0b\x5e\xb6\x03\x6b\x5e\xd5\x71\xe8\x11\xf4\x2b\x15\xd6\x2a\x15\x83\xdb\x05\x53\x78\x5c\xf6\x44\x95\xf5\x4f\x42\x4e\x67\x41\x98\xa1\xad\x47\x05\x9f\x2f\xe2\xa0\x1f\x1b\xc9\xd4\x82\x67\xb2\x5e\x07\x01\xf1\x30\xa8\x6a\x31\xe3\xe1\x54\xd4\x7c\x7c\x29\x7f\x0b\xc6\x6e\x25\x73\xb5\x0a\x12\xfc\x06\x6c\x4d\xf0\xad\xd4\xdc\x7e\xe1\x45\xfd\xf2\xd5\x0f\x83\x4a\x14\xbc\x26\x97\x07\xb8\x19\x4c\x3f\x64\x51\x9c\x37\x1b\x34\x29\x94\xca\x5b\xa1\xba\x56\x8b\x44\x60\xa5\x6e\xc4\x31\xd7\x33\x30\xcc\x49\x45\xa8\xc9\x24\x5a\xf3\x18\xf3\xdc\x9c\x49\x85\x74\xce\x0d\x7d\x4c\x47\x1d\xc1\x2e\x40\x31\xd1\x67\x9f\xa5\xce\x9f\x05\x5a\x4c\xde\x8a\x32\x57\xd5\x80\x14\xd1\x32\x0a\xee\x33\x31\xdd\x63\x3f\x89\xf1\x8d\xac\x53\x99\x6f\xc4\x9a\xe9\x7a\x5d\x08\xeb\x4f\x7d\x6a\x2a\xe4\xa5\x06\x4d\xc6\xe3\x25\x6e\xef\x24\x77\xe6\xb3\x51\x5d\x56\x73\xee\x1a\x3f\xaf\xfb\x34\xf0\xc5\x9a\x65\x7c\x2e\x8a\x23\xae\x45\x0e\x55\x98\xf2\xb0\x4d\x57\xa9\xba\x02\x16\x0f\x8b\xfa\x4f\xb1\xde\xb6\xfd\xb9\x11\xeb\xc8\x20\x86\xba\xff\xb9\x89\x80\x4b\xd7\x61\xbd\xfd\x78\x67\x58\xab\x97\x8b\x85\xa8\x4c\x9d\xdb\x3b\x14\xeb\x39\xe3\xdd\x98\xe3\x21\x8d\x08\xdf\x23\x62\xe5\xe6\x7c\x8d\x60\x2f\x0b\xae\xc9\x63\xbe\xeb\xea\x78\xcd\x78\x0e\x90\xa1\x0b\x51\x59\xe7\xa7\xc0\x50\xa8\x09\x4d\x86\x4d\xac\x3d\x45\xb5\x21\x60\x19\x8f\x43\xd0\xeb\xb3\xde\x5c\x9b\xff\x9f\xab\xdf\xcc\x9f\x73\x34\x8e\x1f\xb1\x97\xf0\xcc\x8a\x82\xe5\xe1\x8d\x58\x6b\x36\x13\x95\x00\xa5\x1c\x90\x62\xe0\x73\x71\x29\x8b\x02\x30\xab\x06\xb2\x64\x85\x52\x0b\x72\x29\x7d\x7a\xf2\x77\x36\x55\x78\x99\xe7\xe5\x16\x3c\xaf\x4d\x64\x29\x6b\x01\xa9\xfa\x1e\xa9\xa5\x66\xc0\x2e\xd5\x42\x33\x75\x4b\xcf\x81\x86\x73\x82\x1e\x5a\xa7\x25\xac\x56\x6a\xb8\x15\x34\x66\xbb\x79\x3a\xec\x38\x8c\x96\xd8\x89\x23\x4e\x97\x1b\x8b\x54\x22\x13\xe5\xf0\x5b\x1a\xc5\xbe\x6e\xaf\x01\x28\xf5\x17\x00\xf4\x6f\xa5\x55\x0b\x50\x61\x00\xdb\xa7\x9d\xe0\x50\x54\x25\x68\x89\x5b\x64\x0f\x07\xe4\x84\x6b\x94\x65\x5a\xb3\x55\x25\x11\x97\x93\xde\x1f\x51\x54\xe2\x56\x39\xa2\x14\x81\x19\x97\xf3\xb3\x58\xa8\xa9\xcc\x78\x61\x98\x08\x36\x5b\x2f\x66\xa2\xd4\x3b\x7d\xc3\x52\x3a\x85\x50\x60\x59\x4b\x76\x7d\x74\x79\x69\x8d\x83\x87\xcd\x66\x5f\x37\xf9\xce\xd0\x47\x70\x78\x9e\xaf\x31\xc4\x3e\xc4\x5f\xd7\x6a\xf1\x9c\x57\x53\x59\x5e\x0f\x53\x5e\xf7\xe3\xac\x18\xe4\xf2\xee\x3e\x5e\xdc\x5d\xa7\x2f\x5e\x88\x16\x09\xba\xb0\xd8\x7f\xab\x3d\x5c\xcf\x58\x2e\xe7\xa2\xd4\xa0\x66\xcc\x51\x27\xb8\x71\x2b\x73\x4a\xa5\x97\x26\x2b\x7a\xb3\x0f\x1c\x59\xf7\x99\xd4\x47\x4b\x5d\xab\x79\xec\xed\x97\x20\xc5\xed\x1d\xaa\x77\x2b\x48\x15\x2c\x0f\x38\xa6\x80\x55\xda\x61\x19\x2f\x0a\xdc\x12\x4c\x4b\x82\x88\xa4\x77\xdf\x99\x2a\x9c\x94\xcb\x6a\xf8\xda\xab\xa4\x53\xf6\xf4\xe0\x2e\xf0\xbe\xfe\x2b\x1a\x07\xc4\xb2\x5e\x14\x1a\x83\xbd\xe6\xda\x3b\xf9\x64\xf8\x52\x82\x4a\xd7\x39\xaf\x39\xb3\xaf\xd1\x6b\x50\xc5\xc1\xc2\x2c\xea\xeb\x58\xa2\x07\x7d\x33\x19\xc8\x8c\x19\xba\x32\x76\x28\xc3\xbc\x96\x19\xdb\x3e\x45\x3d\xd6\xb2\x57\xb3\x4a\x2c\x2a\xd4\xe6\xd8\xd9\x8b\x1f\xa8\x57\xab\xd5\x50\xad\xb8\x5e\xc0\x93\x27\x5c\xea\x87\x8b\xd9\x62\xf4\x8f\xcb\xcb\x37\x4f\x65\x51\x8b\xea\xcd\xc9\x2d\x37\xb3\xf3\xe6\x68\x26\x78\xfd\xe6\x72\x26\x44\xed\xcb\xa0\x22\xea\x99\xb9\xaa\x19\xbe\x74\x98\xa9\xe1\xf2\x66\xf4\xe4\xf1\xe3\xbf\x8d\x76\x77\x47\x4f\xfe\x3a\x5a\x16\xb5\xe1\xee\xc4\xe0\x4e\xeb\x41\xa6\xf5\x00\x3b\x23\x55\x39\x8a\x35\x12\x00\x9f\xb9\x64\xff\xb8\xbc\x64\x30\xdc\x86\xa5\xb4\xd7\x30\x1e\xbc\xc6\x99\x6e\xbb\x32\xf0\xf6\x66\x67\xc9\xbe\x3c\x15\x26\x0f\xa8\xc4\x4c\x41\x94\x5d\xb1\x5c\xea\x6c\xa9\x4d\x47\x18\x1f\xab\x65\xcd\x66\xe6\x46\x1d\x69\xcc\xd1\x24\x55\x4b\x5d\xb3\x97\x17\xcf\x34\x9b\x2b\x74\xfd\xa5\xaa\x15\xaf\xf2\x21\xb8\xa7\xfb\xcb\x93\xdd\xdd\xaf\xbe\x7e\xbc\x6b\x05\x84\x52\x9f\x80\x52\xf7\x01\x8b\xc1\xb7\xbd\x18\x20\x00\xc2\x0f\x85\x04\x21\x3e\xbe\xd5\xf4\xa1\xc2\x9a\x88\x2a\x3d\x27\xb2\x21\x77\xed\xf1\x72\xb7\xaf\x87\x71\x5d\x24\x73\xf0\xee\xf2\x1f\x59\x78\xfe\x47\x2d\x42\xdb\xc4\x1a\x40\x60\x3f\xc0\xb9\x68\x90\xc3\x12\xc0\x3d\x1a\x0d\xc4\xf2\x3f\x67\xbd\xc5\x1d\x0a\xf4\x5e\x54\x02\x1f\xb3\xad\x21\x10\x44\x31\xbd\x9c\x98\x93\x75\x02\x3a\x9b\x58\xac\xbd\x3f\x34\x64\x52\xdb\x01\x48\xfb\xb0\xae\xe4\x7c\xdb\x2b\x0b\xac\x50\xdd\x52\xe6\x40\x0e\xd8\x01\x6a\xd5\xdb\xe7\x9f\x8f\x77\xc9\xfd\xf4\x68\x64\x4e\x41\x60\x07\x26\xaa\x9a\xf7\xc0\xf5\x05\x6a\x3f\x59\xb8\x48\xe1\xdc\xec\xd1\x19\xea\xc9\x70\xc6\x17\xb2\x46\x8a\x45\x13\x3d\xe6\xf9\x2b\x38\x84\x05\x56\x7c\xc6\xe7\xe2\x05\xc0\x29\x97\xec\x80\x8d\xfe\xcf\xf6\x77\x7b\x2b\x38\x7e\x7f\x9f\xab\xdf\x7e\x57\x3b\xaf\x0f\x07\xff\x1b\x64\xef\x28\xa4\xf1\x54\xcf\x56\x43\x80\x05\x80\xa9\xce\x99\x16\x73\x99\xa9\x02\x70\xa2\xa9\x3a\x4f\xee\x7e\x92\xf5\xec\xd2\x26\x08\x2a\xdd\xff\x59\x7f\xf6\xf1\x28\x30\x41\xab\xca\xa0\x75\xda\x01\x68\x34\x22\x1d\x02\x47\x33\xf6\xa9\xaa\xce\xf8\x59\xc3\x91\x6a\x23\xc1\x29\x9e\xf9\xeb\x46\xaa\x20\xd9\x8f\x70\x6c\x19\x46\xd9\x35\x25\xbe\x36\xc7\x6e\x6c\x03\x23\xda\x66\x07\x3a\xd7\x65\x33\x21\xad\xcb\x0e\x5c\x36\x7c\xf9\x49\x66\x89\x54\x75\x5b\xda\xa4\xa5\x43\x0e\xa4\x09\x74\x47\xdf\x27\x7a\xc8\x8e\x65\x0e\x34\x7c\x2e\x78\xc9\x3e\xd1\xdf\x01\x3a\x0b\x76\x0e\xd8\x53\xf9\x9b\x70\xd5\x61\xd3\x7d\xaf\x09\x9f\xe5\x6d\x34\x70\xdf\x27\x96\xd8\xff\xfc\x91\xa3\x7b\x84\xe3\x73\xdf\x6d\x24\xcd\xff\x1b\xb8\x70\x88\xd6\xe6\xde\xbf\xbd\x7b\xdf\xf0\x76\xec\xa7\xc4\x08\x13\x5f\x71\xcf\x40\x13\xf0\x4c\x63\xa4\x49\xff\x30\x1e\x6a\x42\x8e\x81\xb8\x07\x0f\x76\x94\x69\xd3\x70\x7f\x74\x19\x0f\xe9\x43\xc8\xcc\x90\x7d\x64\x28\xf6\x55\xb5\x66\x1f\x7d\xa2\xf7\xd8\x27\xfa\x23\xe7\x45\x25\x18\x7e\x64\x5c\x2b\x01\x3a\x71\xdb\xf7\x12\xa5\x3e\xeb\xf5\x1e\x3e\x0d\xa7\xfa\x8c\x9f\xbd\xcf\xf0\x07\x74\xea\x01\x83\x19\x53\xb5\xee\x45\x7b\x7d\xc6\xcf\xc0\x18\x08\x18\x2e\x04\x9b\x24\xd8\x7f\xb2\x5a\x00\x44\x27\xc3\xd8\xc7\x6b\x38\x1c\xb0\x07\x77\xdd\xd2\xd1\xf7\xec\x7f\x44\x86\x1f\x36\x08\x4d\xca\xbd\x61\x24\x6c\xd2\x3f\x67\x38\x5a\x27\xf8\x3b\x0c\x00\x6c\x78\xe0\x53\xcf\x27\xdb\xbd\x41\x6f\x87\x7d\xcb\x06\x0d\x84\x84\xc4\x01\xd4\x24\x9d\x2d\x90\xaf\x0d\xc7\xfb\xb0\x16\xba\x46\x0a\x1a\xd7\x93\xa2\xd7\x0f\xa9\x68\xf3\x1e\xc2\xea\x90\x8c\xc4\xf5\x75\xe4\xeb\x18\xb4\xd6\x93\x63\x27\x8f\x18\x4b\xaf\xa5\xd9\x95\xad\xfa\x9b\x2d\x80\xbd\xbb\xb1\xe6\x18\x43\x4d\xea\xa7\x20\x2a\x78\x40\xc1\x76\xf1\xdd\x57\xba\x7f\x23\xe8\xe0\x0d\x41\xa8\x1d\x07\xf9\xfb\xfb\xb9\x75\x8e\x81\x80\x50\xb9\xe0\x05\x5e\xee\xea\x59\x43\xe0\x4d\xb6\x95\x94\x0f\x6e\x2b\xa8\x20\xa3\x03\x95\x7b\x73\xc9\x94\xda\xa9\x1f\xd3\x9b\xb5\xf8\xaf\xa5\xbc\xe5\x05\x59\x90\xd6\xf6\xfa\x0f\xaf\x44\xee\xb2\x38\x15\x25\x08\x4b\x40\x04\x04\xaf\x5c\xd5\x00\xf4\xe4\xd1\xb6\x14\x6d\x1c\x6b\x36\x5e\x0f\x40\x6a\xa4\xed\x76\xd5\xd6\x9c\x58\x8b\x6c\x59\x19\x52\x02\x86\x67\xe0\xff\x03\x0c\xf7\xc0\xc8\xd7\x5c\x2b\xc9\x1a\x28\x00\x3a\x00\x0c\x2c\xeb\xad\x44\x91\xa5\x16\x07\xb9\x5c\xa6\xe6\x0b\x5e\x49\x6d\xce\x88\x53\xe8\x14\xa8\xe1\x2f\x49\x5e\x75\x7c\xf2\x0a\x55\xa5\x2e\x2f\x62\x7f\x3f\x11\x80\x22\x8c\xcf\xb1\xbf\xb8\x9b\x5e\x3c\x55\x15\xcc\x81\xde\x86\x41\x88\xdc\xfd\xe2\x8b\x44\x65\x0d\x66\xbd\x2d\x07\xda\x28\x81\x94\x53\x54\x41\xb8\x03\xda\xd2\x8e\x53\x92\x25\x0b\x0b\xb6\xeb\xf9\x11\x06\x36\xcf\x69\x97\x6f\xe7\x21\xc0\xe0\xae\x26\x4b\x3c\xb1\xd0\xd7\xae\x94\x08\xa4\x3c\x48\xd9\x32\x5e\xb2\xd7\xc6\xc6\x1d\xee\xc0\x77\x24\x20\x6f\x86\xbe\x81\x5b\x35\xff\x2c\x14\x8c\xd2\xe7\x07\xc1\xd0\x7c\x4e\xe2\x22\x5e\x07\x5c\xa7\xef\xa4\x39\xec\xf7\x7a\x9d\xc5\x24\x44\x2c\x2e\x6f\x3f\xe8\x79\x42\xd8\xe2\x5c\x9a\xb1\x78\xa2\xbc\x92\x44\x88\xd4\x65\xf5\x6c\x7c\xf5\xbf\xff\xee\xf0\xd3\xde\xc6\xaf\xc6\x3a\xb0\x5f\x31\xf3\xed\xd0\x12\x70\xf0\xd1\x76\x0a\x5e\xd1\x18\x3b\x9d\x78\x49\x5c\x20\x2c\x63\x1c\x24\xa8\xbd\x1e\xdb\x46\xe3\x6b\x52\x24\xea\x93\x89\x42\x85\x28\x50\x20\x76\x6d\x30\xa6\x56\xcc\x03\x0e\x39\xde\xe5\x1d\x17\x2d\x69\x49\x9e\xad\xe3\x8d\x11\x38\xe8\xa3\xbd\x80\x6f\x78\x98\xb6\x79\xe4\xb9\x55\x67\xdf\x6b\x35\xd2\xb0\x87\x2d\xff\x77\x5c\xfc\xdd\x88\x9f\xef\xb3\x54\xa3\x1d\x98\x16\xd0\x79\xea\x1f\x92\xec\xd6\xba\x0b\x37\xd9\xc6\x63\x20\xb1\x4b\x1f\xb2\xae\xe3\xf2\x13\xcb\x3b\xda\xd5\x78\x27\x03\x35\xed\x42\xf1\x3a\x38\x3b\x83\x68\xd6\xcb\xb4\x06\x07\x80\xbd\xa6\xa9\x51\xf7\x50\x40\xfe\xa1\x16\x75\x7b\x96\xc2\x1d\x98\x46\x2d\x81\xf8\xa0\x23\x76\x92\x5a\xe6\x49\x08\xc7\xf1\x54\xa1\xd1\x45\xdf\x79\x75\xab\xf9\xd4\xc9\x3f\xd4\x5c\x82\x78\x44\x56\x2c\x2b\x94\x39\x38\xf8\x14\x7c\x73\xdc\x08\xb1\x60\x1c\x55\x33\x0a\xa9\xc1\xe4\x73\x0b\x04\x9b\x26\x15\xe9\x9c\x0c\x40\x91\xca\x94\x37\xc4\x43\xd9\x14\x57\x8b\xfc\xc8\x14\x75\x65\xaa\xa1\x47\xdf\x4a\xf0\xe0\xad\x95\xeb\xf0\xe9\xb6\x8a\xde\x55\xfd\x87\x98\x8f\x45\xf0\xe8\x38\x0b\xd2\xc9\xf9\x34\xf8\x40\xef\x01\xf6\xf3\x46\xac\xa7\xa2\x8c\x1e\x15\x83\xe7\xd5\xb9\xa8\x83\x96\xc0\x2e\x0e\x9e\xce\xd4\xb2\x0a\x5f\x95\xeb\x8a\x67\x41\xde\x95\x6d\xaa\x55\xbc\xee\x18\xda\x8c\x97\x4e\xe7\xd8\x59\x64\x22\x33\x31\xe3\xda\x63\x1a\x2c\x96\xd5\xc2\x0c\x26\xd7\xa6\xb0\xeb\xe6\xd8\x5d\x33\x71\x07\xef\xee\xc0\x70\x5c\xcf\x45\xb9\x94\xb5\x98\x5f\xdb\xa9\x43\x4b\x1c\xd4\x6c\xae\x35\x4c\x1f\xb0\x27\x7c\x4a\x93\x71\xab\x64\x4e\x94\x8b\xe6\xc2\x19\xec\xc3\x48\x60\x79\xb6\x4b\xfd\xd6\xe4\xed\xec\x7b\x93\x1d\x34\xd4\x79\xf3\x86\x4c\x72\x3c\x95\x33\x6c\x4a\x55\xc3\xae\x46\xc4\xf8\x9a\x4f\x43\xdb\xf7\x80\xc4\x79\x80\xdd\x58\xa8\x18\x58\x2f\x90\x14\x1f\xa4\xe3\x80\x20\x7d\x70\x70\x4d\xb2\x5e\x62\x78\x26\x04\x60\x82\xd6\xe0\xa4\xed\x3f\xb4\xe6\x93\x71\x8f\x5f\xd7\x7c\xea\xae\xe0\x8f\x1a\x20\xe5\x09\x0f\x75\xef\x83\x83\xf1\x09\xf9\x92\x00\xed\x79\x07\x21\xc2\xa7\xa8\x11\xb7\xd4\x35\x2b\xc9\x3c\x1e\x66\xea\xda\x56\x7f\xcd\x4a\xd3\x03\x2d\x58\x27\x92\x06\x5e\xae\x60\x3c\x83\xbb\x55\x64\x8c\xdb\xb0\x41\xec\xe8\x40\x83\x31\xe9\x1a\x89\x74\x07\x8f\xac\x79\xb0\x16\xb5\xb5\xac\x0f\x7a\xa1\x2a\x76\xbd\xb1\xf6\xeb\xb6\x01\xf1\x23\x7b\x3f\xb9\x6f\xdc\x0f\x58\x0f\x4f\x58\x90\x6d\xd3\x3a\x84\x87\xd4\x0d\xf9\x3a\xf0\x4a\x36\x37\xd2\x61\x1f\x90\x76\x34\x78\x67\xb9\xfe\x17\x2e\xf8\x3d\x36\x1c\x0e\xdf\x5e\x0f\xd9\x8b\x42\x18\x82\x77\x2b\xb5\xac\x93\x2e\x85\x5d\xbd\x83\xa0\xa2\x81\x16\x26\xa6\x14\x15\x68\x43\x22\x7f\x63\xe1\x08\x2a\xd4\x86\x69\x0e\xd2\xdb\x2e\x2f\x09\xcb\xc5\xa2\x12\x5a\x93\xe2\xce\x49\x8e\xaf\x8e\x3f\x61\x22\xc3\x60\x11\x50\x53\x16\x27\x00\xab\xa9\xe4\xac\xb7\xbd\x46\x5f\x37\xf2\x22\x7e\x29\x09\x96\x74\x38\xf9\x73\x5e\xf2\x29\x5e\x66\xc0\xa6\x1e\xdd\x6e\xd0\x55\xa2\x54\x2b\xb6\x56\xcb\xca\xa2\x6f\xca\xb1\x2c\xcc\xcd\xa5\x56\x6c\xba\xe4\x15\x2f\x6b\x41\x2f\x76\x25\x2d\x2b\x28\x03\x0f\x18\x32\xa1\xa8\x0c\x4f\x66\x2f\x5a\xc5\xda\xab\x98\x9a\x6b\xdc\x72\x51\xc8\x0c\xa1\x5c\xec\xbb\x12\x94\xe0\x7c\xe6\xa0\x82\x12\xbc\x25\xa9\x92\x17\xb8\x9f\x9a\x62\x8a\x00\x08\x87\xf8\xaf\xd6\xb3\x4e\x1c\xeb\x17\x65\x7a\xa5\x01\x1e\x38\x24\x26\x04\x22\x6c\xbf\x21\x12\x73\xbe\x58\xc0\x33\x53\xa5\xe6\x31\x0f\x2a\x11\xd3\x08\xc5\x79\x7d\xf2\x5f\x4a\x8a\xab\xe8\x12\xf5\x8e\xcf\x01\x77\x0b\xb2\x1d\xfc\xeb\x5f\x73\x78\xbb\xbd\x40\x6d\x19\xbd\xe0\xe0\xaa\xe6\x73\xf6\x73\x4f\xcc\x7f\xee\xbd\x7d\x8b\x4f\x95\x88\xa2\xf1\x1f\x97\xff\x68\xf5\x3d\x58\x6d\x11\x60\x0a\xf1\x2c\x47\x76\x41\x18\x7a\x8e\x7c\x49\x40\xb9\x41\xc4\x80\xe1\xb1\x80\xc6\x8c\x8e\x17\xd1\xd0\x05\x20\x1a\x45\xa9\x23\x37\x29\x76\x0a\x9c\x0d\x23\x96\x1a\xa8\xcf\x5e\x01\x8a\x07\x3a\x52\x42\xbd\x50\x30\xdd\x31\x4b\x12\xcd\x3c\x1d\x7e\xc9\xd0\x66\xf9\xc9\x7a\x42\x9a\x4b\xb0\xd0\x91\x3a\xe0\x63\x6a\xa5\xd8\x7c\x99\xcd\x42\x43\x68\x9c\x21\x72\xd2\x83\x6a\xb7\xd3\x0a\x6d\xe5\x6c\x1b\x18\x2f\x40\x43\xb3\x96\xb7\x02\x41\xec\x90\x3d\x40\x85\x07\x67\x63\x87\x3e\xc0\xc4\x0a\x2d\x8b\xb5\xb7\xa2\xce\x54\x79\xab\x8a\x65\x6d\x71\xef\xc2\x87\xd9\x2f\xb2\x21\xb9\x85\x94\x6a\xb4\x12\x63\x0f\x3e\x32\x32\x8c\xd6\x28\x83\x29\x19\xfd\x05\xff\x0e\x6c\x7f\x07\x99\xaa\xc4\x20\x53\xa5\xe1\x12\xd0\xdd\x2c\x9a\x72\x02\xff\x01\x64\x65\x70\x37\x8f\x3d\x60\x82\x53\xcd\xc1\xa2\x52\x13\x59\xc4\x8e\x2f\x27\xaa\xac\x07\x13\x9e\x75\x84\x0e\x74\x95\x75\xc4\x2c\x2b\xd9\x11\x83\xe4\xad\x23\xd2\x0c\x5a\xec\x9d\x53\x6a\xb3\x5c\x07\xd3\x62\xbd\x68\x99\xa2\xba\x17\xaa\x2e\x0b\x54\x2b\xe2\x74\x5a\x8f\x66\x5b\xbe\xf0\xbb\x0b\x39\xd1\x9e\x09\x1d\x64\x08\xc8\xd3\xdb\x63\x8f\xfb\xf8\x64\x87\x46\xcc\x18\x8b\x3e\x1c\x35\xc4\xfa\x40\x02\xaf\xee\xc8\x33\x93\x79\x2e\xca\x8e\x48\x12\xa9\x76\xc4\xde\x88\x35\x6a\x87\x2f\xeb\x46\x9d\x05\x1f\x8b\x22\x0e\xaa\x54\x21\x72\x41\xfa\xf2\xaa\xb4\x91\x66\xd1\xcb\x7c\x2a\x6a\xe6\xfc\xc6\x68\x97\x87\x2f\x6b\x65\x81\xa6\xe2\xd2\xac\xa3\xf8\x28\x50\xdc\x2d\x78\x99\x37\x43\x67\x5c\x2f\xd4\x62\xb9\x68\xb4\x50\xdc\x36\x5b\x38\x57\x39\x6f\x06\x99\xcb\x7c\x21\x4b\x91\x08\x46\x0c\x08\x33\xb4\x71\xa4\xaa\xa4\x28\x71\x11\xc7\x11\x81\xc9\x7e\x23\xc2\x9c\x8b\xcd\x66\x57\x82\xe7\x86\x7b\x69\x86\xa2\x61\x6a\x1c\x6a\x31\x1e\x1b\xa1\xaa\xaa\xe3\x10\x20\xd2\x73\x7e\x97\x0a\x95\x65\x22\xb4\x54\xab\x44\x28\xb8\xb7\xf7\xf3\xf7\xcc\x10\x96\x0b\x31\x35\x54\x38\x35\x89\xb5\x9a\xcb\x2c\x2e\x66\xbc\xd4\x8d\x8e\x15\xf2\x56\x34\xbb\x5a\x88\x5b\x5e\x86\x35\x1d\x57\x7c\x3a\xe0\x65\x3e\x38\x36\xa7\x53\xa2\xae\xdc\xec\x1a\x00\xee\x88\xcb\x9a\x56\x7c\x3c\xf6\xe3\x03\xf0\x99\x05\x0a\x56\x67\x32\x59\x12\xcf\x0c\xbd\x34\x0b\x56\x94\x79\xd0\x0a\x5a\x7e\xaa\xc8\xd4\x32\x11\x0a\x67\x4a\x2b\x54\x2f\x78\xd9\x0c\x04\x18\x83\xe6\x56\x85\xfd\x31\x16\xf9\xb8\x31\x3a\xa2\xaa\x54\x35\x17\x5a\xf3\x69\x63\x94\x26\x85\x5a\xd5\x2a\xb1\xfb\x8a\x76\x29\x6a\x55\x36\x2a\x5c\x98\x9b\x17\xf8\x32\x8e\xb7\xea\x2a\xd1\xbb\x4a\xad\x12\xbd\xab\xd4\xaa\xdd\x3b\x2d\x6a\x2d\x7f\x83\x96\xc2\x8d\xd3\xbf\xcd\xc7\x64\xed\x2d\xe2\x1c\x54\x87\x17\xa7\x87\x88\x54\xc2\xd0\x12\x6e\xbb\xf7\x7f\xb6\x4d\x49\x3b\x83\xd7\x86\x31\x3a\xbc\xba\xba\x38\xfd\xfe\xe5\xd5\x09\x98\x8e\xbf\x39\xfa\xf1\xf0\x02\x3c\x3a\x7e\xf6\x71\x6f\x27\x28\xe2\x88\xcf\x45\x91\x2e\x07\x14\x1d\x1e\x50\x16\x14\x16\xcb\xa1\xd8\x81\x55\x46\x5c\x54\xaa\x56\x86\x27\x68\x48\xaa\xf6\x63\xb0\x80\x08\x28\x6d\x3b\x14\x92\x99\x53\x37\x85\x01\x5a\x19\x76\xa4\x9d\x73\x7f\x2b\x30\xf9\x33\x79\x3d\x32\x38\x7e\xef\x59\x27\x44\x49\x1f\x68\x20\x9e\x71\x4c\x50\xe9\x98\x13\xc3\x03\xc5\x1d\x18\x66\xbc\x28\xb6\x9b\x33\x64\xf3\xb8\x57\x62\x1f\x15\x3f\xc8\xb7\xce\x31\xaa\xc4\x4f\x4a\xe2\x75\xca\x1e\x74\x56\x18\x05\x0b\xa7\x17\xbf\x96\x7f\xb9\x33\xac\xd5\x33\xb5\xb2\x6f\xe9\x5e\xda\x4e\x4a\x32\x94\x39\x3e\x30\x9b\x72\x44\x5b\x8b\x61\x7a\x5d\x8d\x7b\x24\xcf\xb5\x2c\x4d\xe8\x5e\xb1\x84\x64\x83\xe0\xf9\x03\x95\x71\x48\xfd\xcb\x30\x63\xf8\xcc\x60\x38\xa8\x9b\x52\xad\x4a\x76\x7c\xfe\xdc\x96\x74\x7c\xfe\x3c\xe0\x8d\xc9\x0b\x2d\xfa\x06\x08\x1e\x29\x9b\x35\x78\x4c\xe1\xa8\x6b\x4d\xc1\x7c\xf3\x11\xf4\x94\x8a\x83\x1d\xe4\x5f\x6b\xae\x3f\xd1\xd7\xc3\x46\xa0\x66\x13\x55\x14\x6a\x85\xfa\x9f\xa4\x9f\x63\x9b\x61\xaf\xfc\xa0\xdc\xb9\x12\x95\xe1\x6b\x52\x4f\xa4\x2d\xd7\x3d\xac\x63\x6d\x34\x3c\x72\x34\x96\x88\x15\x36\x82\xa6\x60\x3c\x10\x3a\xd2\x33\xa5\xa6\xec\x33\xbd\x9c\x4e\x85\xae\xc9\xc7\x2c\x05\xb3\x5b\x51\x69\x7c\xd8\x61\x0d\xef\xcd\xc1\x28\xbe\xe7\xe8\x45\xfa\x1e\x26\x28\xd2\x9d\xf1\xc5\xff\x49\x83\x13\xef\xa2\x8e\x0d\x54\xd8\xbd\x91\x9f\x79\xf7\xd4\x5d\x7b\x46\xd7\xbc\xcc\x79\x95\x3f\x68\xd3\xc4\x25\x9b\xad\xd3\xa8\xeb\xff\xde\x0d\x14\xf7\x33\xb5\x83\x1e\x3a\x23\x01\xeb\xfe\x67\xaf\xd7\xb0\xd1\xdd\x0b\xf6\x65\x89\xa3\xf5\xee\x0b\x36\x2c\xff\xcf\x5c\xb1\x51\x4c\x78\x32\x99\x72\x69\xbf\x99\xd6\x93\xc8\x75\xbd\x68\xbb\x24\xa7\x19\xb6\x58\xad\xaf\x7f\x89\x9d\xcd\xdd\x88\xb5\x93\xa4\x85\x7b\x41\x6a\x90\xe5\xa2\x92\x6b\xe3\x10\x84\x6a\x6e\x44\xf8\x50\xf2\x88\xd2\x07\xef\xb0\x41\xbd\xc3\xc5\x52\xcf\xb6\x7d\x8e\x08\x20\x73\x89\xb3\x60\x12\xe2\xa3\x31\x58\x33\x07\x99\xe7\x7c\x91\xb4\x06\xf0\xda\xb2\xd7\xd6\x6d\x13\x38\x83\x43\x61\xc2\xce\xf0\x57\x25\xcb\xed\x5e\x9f\xf5\x3c\x00\x40\x54\x2e\x81\x23\x1e\x1c\x00\x3a\xe2\xbf\x92\x6a\x31\xa7\xc1\xfe\xc0\x1a\x3e\x41\x3f\xa3\x9f\xe8\x6f\xf1\x8d\x04\x44\x4d\x4f\x41\x9d\x00\xae\x8b\x7d\xa6\x85\x68\x08\x05\xa9\xda\x01\xdd\x4f\xd4\x02\x96\x52\xab\xe3\x88\x7c\xd4\xb9\x9e\x02\xdd\x8a\x54\x3f\xbe\x7d\x87\x5e\xe8\x7f\x67\x37\x36\xb1\x58\x52\x24\x96\x71\xf8\x88\x16\x08\xa4\x82\x64\xe9\x87\x84\x7b\x37\x89\x53\x22\x09\xfd\x83\x9c\x19\x9e\xd0\x2b\xb9\x76\xf2\xa2\x1f\xef\xfe\x7b\xb9\x51\x29\xf4\xc7\xbb\xe9\xc1\x02\x60\x29\x00\x42\x82\x47\xb1\x9e\x03\x9b\x82\x30\x87\x4d\x1c\x07\x93\xcf\xca\xd4\x50\x86\xaf\x0b\xae\xa1\xee\xbd\xc4\x6b\x17\x39\x7f\x5f\xcd\xf1\xb4\x85\x26\xc6\xd9\x53\x3d\xd7\xf2\x83\xa0\x39\xbe\x9a\xa6\xe7\x89\x84\x0e\x5b\x88\xf7\xae\x90\x6a\xdb\xf3\xc4\x9c\x94\x63\x01\x2d\xa4\xc5\x7e\xa4\x4a\x2d\x73\x51\x59\x88\x61\x8b\xd5\x8e\xbe\xb2\xd0\x49\x72\xe4\xaf\x02\x20\xbf\x15\xbb\x36\x2d\xbe\x26\x21\xb5\x62\x59\x21\x78\x13\xfd\x50\x55\xec\xda\x3d\x4a\x5d\x93\xf6\x7b\x80\x58\xec\x05\x7b\xf4\xb6\x93\xdc\x2f\x66\x81\xa5\x9f\x7e\xff\x9c\x8e\x7b\x44\x97\x07\xf4\x09\x4a\xfa\x00\x1d\x0b\x5e\xa8\x7f\x32\x43\x4e\xf6\x70\x01\x43\x40\x5a\x54\xf0\x14\x44\x78\x4d\x4e\x8a\xdb\x37\x5d\x43\xd8\x53\x65\x8a\xe0\x85\x56\x80\xe2\x0e\x6e\xc4\x6b\x82\x33\x9d\x23\x9e\x8e\xc7\x48\xcd\x38\xf5\xdc\xb0\x4d\xc4\x7c\xc2\xc9\xbe\x05\xee\xdc\x51\xd5\x0a\x7d\x50\x2c\x94\xd6\x72\x5c\x88\xcb\xe0\xc4\xb7\x42\xc4\xd1\x88\x10\x6e\xc8\x32\x7a\x8f\xf5\xf0\x47\xaf\xef\xc2\x00\x35\x40\xf8\xa8\x23\xfc\xee\xe1\xf5\x1e\x82\x06\x94\xa6\x97\x4c\x84\xb8\x9c\x37\x62\x4d\xb1\x5a\xff\xa7\x58\x53\x8c\x21\x0b\x10\x0c\xe2\x31\x08\x33\x77\x92\xc9\xb2\x28\x74\x56\x09\x40\x51\x87\x90\xa7\xcb\xa2\xb8\x84\x10\x4a\x05\x0d\x2a\xa8\x06\x6d\x3e\x34\xfd\x5e\x97\x19\x7c\xae\xcb\x0c\x43\x96\xb5\xf2\xa6\x11\x26\x6a\x59\xab\x23\x17\xe0\xd3\x90\x64\xd1\xa6\xb0\x82\x46\x1f\x0f\xc3\xec\xa2\xe1\xcb\xc5\x4e\x54\xb6\xd4\x14\xf7\xd4\xfc\x76\x31\x8b\x82\xaf\x29\xe2\x45\xc1\xd7\x2e\x5c\xf3\x5b\x5b\xd7\x25\xbf\xc5\x7a\x32\xbe\xa8\x97\x95\x09\xa6\x5f\x18\x2a\x8a\x62\x81\xeb\xca\xc4\x88\xa2\x78\x81\x5f\x2e\x96\x9e\x4d\x28\xf6\x12\xbf\x30\x76\xc6\x0b\x73\xbe\x42\x99\xf6\xb7\x8d\xa1\x89\x35\xbf\x2e\x69\xb6\x48\x92\x0a\xa1\x28\x53\xc5\x50\x07\x6a\x6f\x7f\x62\xb8\x84\xf1\x32\x7f\x70\x41\x64\x05\xd7\xda\xac\x03\xf8\x61\xd6\x1a\xa6\x33\x5f\x32\xb7\xe1\xa7\xc7\x3e\xd4\xac\xda\x76\x7a\x55\x98\xc1\x34\x7f\xdc\x37\x58\x68\x9b\xa0\xcb\x05\xa7\xda\xf1\x79\x0f\x42\x11\x1d\x21\x08\x15\xf4\xe8\xe7\x63\xed\x33\xa0\x4f\x75\x57\xcf\x45\xb9\xb4\x29\xee\xea\xe7\xa2\x5c\xba\xd8\xca\xb6\x81\x44\x73\x61\xb8\xd9\xba\x41\xdc\x33\xa9\x6d\xdd\xaa\xca\x31\x97\xf9\x81\x61\x95\xd2\x5a\x55\x72\x2a\xa1\xfd\xe6\xeb\x1c\xbe\x20\x36\x78\x5e\xd5\xa2\x86\xc7\x55\x7c\xa9\xed\x75\xbc\xf0\x52\xae\x9a\x43\x92\x9a\xdb\x6f\x51\x4b\x18\x48\xf3\xf3\x4a\xd2\x38\x5a\x77\xd3\x66\x46\xec\x4f\x48\x8f\xbf\xfd\x64\x53\xc0\x51\x30\xe7\x14\x44\x2e\x10\x62\xc7\xd5\x14\x2f\x2a\x8c\x10\x15\x86\x48\xf8\x96\xf6\x0b\x1f\x1a\x20\x88\xde\x1c\x20\x5c\xad\xca\x42\x71\x08\xa7\x9f\x18\x5e\xf1\xe9\x94\x66\xcc\xfd\x86\x18\x51\x66\x86\x0e\xef\xb1\x9e\x28\xb3\xab\xf5\x82\xfa\x36\x51\x95\xe9\x97\x19\xae\xa7\x0a\xeb\x9c\xa8\x6a\xbe\x07\x31\x73\xf7\x8d\x6e\xbc\x29\xf4\x39\x7c\xb8\x38\x47\x81\xcc\xc7\xa1\xa7\x42\xe6\xd3\xd7\x6a\xbe\x4e\x82\x9a\xcd\x77\xa9\x2c\x37\x43\x09\xce\x14\xb9\xf0\xf6\x69\x10\x23\x8f\xe2\xaf\xe0\x03\xe3\x0c\x4b\x35\x26\xfb\xff\x1e\x7c\x7d\x0f\x5f\x10\x3b\x13\x3c\x17\x95\x59\x44\xf4\x8b\x42\xf1\x81\xb4\x87\x3f\x30\x0c\xde\x6a\x4c\x18\x3e\xda\x60\xd8\x74\x06\x21\xd3\x19\x7e\x57\x62\x62\xbe\x2b\x31\x71\xdf\x05\x07\x52\x61\x7e\x3e\xe3\x44\x27\xcc\x28\x4e\x54\xd5\x18\x4f\xc3\x3e\x83\x3e\xf0\x1e\xa2\xcd\x9e\x98\xdf\x38\xfa\xe6\x73\x00\x71\xbd\x56\xa4\xcc\x60\x50\xcd\x1f\xfc\x36\xc3\x2f\x71\xd8\xc3\x25\x2e\xa3\x45\x0d\xac\xde\x5c\xe5\x62\x8f\xd8\xbe\xe7\x2a\x17\x14\x53\x8b\x69\x05\xe8\x00\x3d\xf7\x1b\x63\xcc\x38\x49\x1c\x22\x59\x8b\x39\xd6\x54\x8b\x39\x91\x18\xf3\xd3\x30\x15\x14\x6a\x38\x4f\x17\x8e\x23\x63\x7e\x5d\xd0\xe0\x98\xdf\x3a\x53\x30\xe9\xe6\xf7\xa5\xf9\xed\x62\x68\x35\x98\x9f\x6e\x29\xdc\x88\x35\xe8\x5e\x99\x66\xdc\x88\xf5\x0b\xf8\x6d\x63\x28\xc3\x8d\x58\xfb\xf4\xb2\x34\x2d\x34\x7f\xe0\x1b\x64\xf3\x7b\xac\x87\x2f\x64\x18\x02\x93\x53\xd8\x89\x21\x52\x53\x58\x12\x53\x28\xe8\x8d\xf9\x43\xdf\x2b\xf8\x5c\xc1\xd7\x9c\x97\x72\x22\x20\x87\xfd\x49\xe1\xd5\x54\x96\x2b\x04\x53\xe8\xe1\x17\x40\x2b\x04\xb1\x6e\x89\xe1\xe7\x8f\x7e\xa1\xcd\xf9\x1d\x04\xdf\xd9\x2f\xbc\xb1\x61\xd8\x33\xf8\x8d\x31\x22\x97\x86\x2e\xc1\x5f\x1f\x32\x45\x24\x12\x0c\x06\x58\x12\x8a\xa3\x8d\x39\xf7\x9b\x72\x0e\x44\x72\x4e\xc4\x71\x2e\x4b\x5f\x93\x2c\xc3\x9a\x9c\x9f\xcb\x9e\xfd\x49\xe1\x35\x50\x1c\xf8\x0b\x21\x74\xbe\x94\xf6\x68\x29\x55\x99\x41\x80\xf9\x4b\x21\xc1\x56\x2e\xe3\x6d\xac\x16\xb0\xc1\xcc\x1f\xfa\xae\xe5\x7c\x39\x87\x20\xf8\x05\xa1\x24\x3e\xdd\x63\x3d\xfa\x85\xa1\xfe\x81\xcf\xc4\x04\xcf\x7d\x14\xbb\xd6\xb2\x2c\x64\x29\x30\x76\xad\x4f\xe1\x0b\x63\x95\xae\x31\x1b\xfc\xc0\xb0\x4a\x10\xdd\xa4\x5f\x14\x0a\x4f\xe0\x10\x8a\x8f\xe1\x26\xb4\xe2\xb9\x54\x76\xdc\xe1\xc3\x8f\xbb\x7d\x4a\x34\x31\x82\xe7\xe7\x65\xb1\xa6\xf0\x89\xa8\x2a\x51\x2d\x54\x21\x33\x8c\xc5\x80\x17\x10\x40\x69\x0a\x88\x28\xe8\x0b\x9f\x1f\x21\x88\x5e\x22\x31\xfc\x56\x54\x9a\xc2\xf1\x27\x86\x2b\x68\xa8\xf9\x43\xdf\x2b\x0d\xdf\x2b\xed\xbe\xf1\x98\xaf\x10\xeb\x05\x42\x35\x2f\xf3\xb1\x32\x2b\x90\x7e\x61\x28\xed\x53\xed\xf6\x28\xfc\xca\x6d\x50\x4e\x61\x86\xb1\x47\xd6\xc8\xfd\xc6\x18\xc1\xe7\x85\xd0\xa6\x7e\xfb\x93\xc2\xf1\xf1\x74\xcf\xde\xe0\x6c\x49\x33\x8e\xf5\x99\xbf\x18\x82\xec\xa4\xb6\x4c\xa4\xf9\xa1\x29\x80\xca\xc2\xce\x68\xd7\x93\x85\x28\x0a\x38\x74\x21\x54\x14\x05\x1c\xb8\x18\x57\x19\xb6\x55\x57\x99\xfd\xca\x15\x05\x1c\x2b\x17\x46\xc4\x41\x57\x99\x23\xdc\xba\xca\x90\x8b\xd3\x55\x66\x99\x38\x8d\xa8\x35\x3d\xf8\x4b\x21\x62\x01\x01\x62\x41\xdf\x6b\x98\x0a\xf8\x8b\x21\xcb\xf9\x9c\x57\x66\xda\xe9\x17\x84\xd6\x7c\x2c\x11\x65\xa6\x57\xf3\x31\x00\xce\x50\x38\x1d\x6d\xb5\x3f\xd6\x6a\x59\x43\x99\xf0\x17\x43\x90\x00\xd6\x96\xfa\x2d\xb5\x98\x73\xd3\x8e\xa5\x16\xcf\x39\xb6\xc4\xf2\x17\xb7\x8e\xb1\xb0\x54\x6a\xe5\xe8\xd3\x8a\x4e\x05\xf8\x8b\x21\x15\x94\x63\xfe\xf4\x02\xb4\x1b\xc3\x5a\x8f\xd5\x12\x98\x74\xf3\x17\xd2\x9a\x4b\x47\x59\x3b\xea\x86\x9f\x01\x75\xa3\x90\x01\x9d\xac\xa9\x24\x3c\xcb\x96\x73\x00\xd0\xc7\x58\xfa\xc0\xb8\x3c\x27\x38\xa4\x9e\xfd\x89\xe1\x85\x9c\x02\xaa\xd7\x98\x6b\x41\xdb\xdc\x85\x7d\x4f\x61\xd4\x00\x1b\x3c\xb0\x69\x7b\x9d\x89\xe1\x3a\x54\x09\xcb\x3d\xc0\xe7\x85\xf0\xec\x03\x2f\x16\x33\x3e\x16\xb5\x84\x5b\x90\xfb\xc0\xb8\xf9\xa2\x90\xf5\x12\xc6\xd2\xfd\xc6\x98\x8a\x8f\x65\x46\xec\x13\x7e\x3c\xb5\x4c\x14\x7d\x83\x12\x4c\xaf\x1d\xcd\x75\x86\x4c\x38\xfe\xc0\x30\x7b\xfb\x25\xea\xeb\xbe\x1d\x87\xef\x42\x68\x8d\xb8\x6f\x77\x54\x9a\x8b\x11\x51\x0f\xba\x26\x5d\xe0\x17\xc6\xfe\x26\xe7\x4b\x58\x26\xf4\x0b\x42\xcd\xf0\x4d\x0c\x29\x12\x25\x50\x30\xf3\xfd\xd4\x7e\xbb\x14\x66\x2c\xf5\x4c\x4e\x6a\x4a\x61\xbe\x2f\xcd\x37\x76\xd7\x06\x0d\x20\x4d\x2f\x99\xc8\x84\x78\xca\x6b\xbe\x5e\x04\xd4\x77\x8c\xe4\x6a\x6c\x69\xd5\x58\x20\xf3\x0f\x7f\x31\x44\xc2\xa5\xd5\xfc\xc1\x6f\x68\x2d\x36\x31\xe3\x45\x46\x0b\xde\xfc\x74\x5c\x50\xc6\x17\x6e\x11\x67\x7c\x11\xae\xe0\x8c\x2f\x82\xe5\x1b\x47\x66\x85\x5c\xc0\x05\x4b\x2e\xdc\xf7\x82\xc3\xd0\x99\x9f\x2f\x38\x8d\x1d\x7c\x0d\x16\x80\x9e\xdf\x88\xb2\x59\x00\x21\x2d\x88\x7c\x69\xbe\x5d\x8a\x6a\x89\xb7\xad\x42\x2e\x2e\x96\x85\x08\x0a\x35\x31\xbd\x66\x14\x68\x70\xed\x91\x26\x97\x0f\x01\x00\xc1\x85\x42\x75\x0c\x1b\x7d\x1a\x06\x52\xc1\xa0\x00\x16\xa5\xee\x75\x27\x6f\x17\x3d\x01\xa4\x10\x9d\xcc\x82\x28\x22\xba\xb3\xa2\x01\x65\x4e\x57\x18\xe6\x86\x58\xbf\x50\xe0\x33\x5c\x29\x4d\x3d\xb6\x44\x12\x08\x70\x66\x75\x36\xc5\x85\x0d\x08\x8b\x71\xa9\x7a\xe9\x64\x74\x11\x46\xad\x2b\xda\x78\x14\x76\x09\x61\x6e\xf3\xd9\x94\xe6\x78\x68\x24\x34\x41\x3e\xdd\xb2\xd2\x38\x8b\xf0\x03\xc3\xcc\xda\xcf\x70\xe5\xc3\x2e\xa4\xad\x07\x37\x3e\xfc\xc5\x6b\x4e\xa5\xda\x9f\x18\x2e\x32\x51\x80\x5d\x21\xdc\x2b\xed\x07\xc5\x59\x3a\x43\xbf\x30\x54\x4e\x26\x4b\x2d\x32\x55\xea\x9a\x63\x2c\x86\x1c\x51\x08\xa5\xaa\x84\xbd\xe9\xb9\xdf\x14\xa3\x49\x3e\x43\xbf\x28\xf4\x56\x62\xb7\xe8\x17\x86\xaa\xb9\x2c\x79\x44\xcf\x6d\x50\x4c\xce\x6d\x68\x44\xcd\x93\x49\xf3\x25\x54\xb2\xa4\x0a\xcc\xc0\xe5\x38\x70\x39\xb4\x09\x9b\x23\xf2\xa9\x20\x82\x60\x7e\x3a\x82\x00\x1a\x51\xd4\x2d\xf7\x1b\x63\x4a\x73\x79\x1e\xf3\xec\xc6\xf0\x80\x70\xe5\xc0\xa0\xef\x5d\x10\x36\x15\x43\x07\x3e\x65\xaf\x2b\xa9\xa0\x52\xe8\xeb\x0e\xc5\xa4\x26\x88\x7e\x52\x38\xc2\x7f\x56\x02\x6d\x50\x74\xc0\x22\xda\xb8\x0b\x1b\x77\x11\xf2\x8c\x13\x59\x18\xd6\xd2\xfc\x71\xdf\x0e\x33\xaf\x17\x00\xd6\x61\xc3\x4d\xc0\x80\xe2\x7b\x89\x04\xe6\x9b\x08\x92\xf9\xe9\x09\x12\x64\xb4\x04\x29\x8a\xc2\x4d\x8d\xa1\x96\xe7\xc6\x9f\x15\xf0\x75\xf8\xfb\x82\x78\x3b\xfc\xb2\x14\x11\xbf\x3c\x3d\x04\x2c\xbd\xa0\xf9\x01\xb4\x1e\x35\xc3\x84\x44\x1d\x68\x26\x81\x00\x4b\x24\xe1\xe3\xc8\x51\x4a\xca\x8e\xa4\xb3\x1d\x0d\xc2\x48\x12\xa5\xb8\xdf\x14\x53\xd6\x13\x3e\x97\xc0\xfd\x9b\x8f\xa7\xf0\x41\x85\xa2\x4a\x2b\x04\xb4\xa3\xcd\x27\xb1\xbc\xe6\xe7\xa5\x65\x7b\x31\x1b\x29\x78\xc5\x51\x36\x0b\xcf\x7f\x5d\xea\x3a\x88\x3d\x84\x80\x46\xf6\x01\x26\xeb\xa5\xd3\x41\x59\x75\x25\xea\x6c\x66\x13\xe0\x57\x58\x0a\x85\x24\x12\x60\xf6\x75\xe1\x9a\xef\x18\x5f\x9b\x75\x5d\xf8\x0e\xb8\x48\xf3\x45\x7a\xf1\x14\xf7\x0a\xbf\x82\xac\x14\xdf\x4b\x24\x30\xdf\x2b\x7b\x66\x7b\xf0\xc8\x20\xf3\xca\x9d\xda\x8d\x68\x54\x39\x26\xe1\x11\xb7\x82\x23\x05\xe2\xad\x4a\x91\x78\xcb\x10\x8c\x09\x12\x8c\x09\xcc\x28\x4e\xd5\x74\x77\x8f\xf5\xa6\xbb\xf8\xfb\x89\xf9\xfd\x04\x7f\x17\xeb\xc5\x8c\x58\x32\xf8\xed\xd8\x31\xfc\x24\x55\xe6\x66\x24\x7c\x05\x7a\xac\xe6\xf7\x6f\xaa\xac\x79\x61\x93\x9e\xfb\xc8\x1f\x5d\x64\x58\x70\x90\x7b\xe0\xb3\xf7\xee\xcf\xdf\xac\xfb\x56\x54\xb5\xcc\x92\x35\xbf\xa2\xa8\xae\x7a\x6d\xd6\x54\xad\x51\x5e\x88\x44\xe9\x10\xfc\xb4\xe2\xa1\xa9\xb9\x48\x8b\xb2\xae\x2d\x40\x93\x49\x40\x61\x1e\xb4\x29\x4c\x69\xc9\x83\xfd\xf6\x04\x62\xc6\xcb\x29\x1e\xe7\xf4\x0b\x43\x4d\xe7\x79\x7e\x6b\xe6\x15\x7e\x1f\xe6\xb7\xff\xc0\xfe\xc0\xe7\x80\xe7\xb7\x83\xbb\x5e\x2b\x16\x87\x14\xa4\xca\x2e\x2b\x0a\x99\xa3\xdc\x98\x22\x28\x20\x4c\x23\x73\xa1\xa6\x15\x5f\xcc\xe0\xe6\x10\x7c\x61\xec\x9c\x4f\x45\xc8\x85\x40\x40\x83\x0b\x81\xb0\x98\x0b\x49\x24\x93\xe5\x13\x90\xe3\x3d\xa1\x4c\xc0\xb7\x11\x5f\x2c\x4b\x92\x77\xe1\x0f\x0a\xab\x45\x45\xcf\x53\xee\x37\xc4\xdc\x98\x75\x7e\x83\xeb\xfc\xc6\x14\x7a\x83\x65\xde\x7c\x61\x7e\x7f\x81\xbf\xbf\x34\xbf\xbf\xc4\xdf\xe6\x27\xfe\x12\x55\x29\x8a\x39\xaf\x2b\x79\x07\x22\x3a\xf3\xf9\x1c\x3e\x83\x78\x44\xfc\x22\x01\x14\x06\x99\x19\x0c\xe4\x50\x26\x10\xc7\x83\x7e\x51\xe8\x1a\x1c\x2f\x59\xa9\x20\xfc\xb6\x31\x7a\x01\xf7\x0f\x8c\xba\xc4\x0f\x1b\x57\xcb\xb9\x8d\xb9\x32\x3f\x21\x1c\x5b\xe0\x68\x28\x7e\x06\x94\xb1\x10\xb5\xe1\x37\xdd\x13\x10\x7e\x87\x8f\x40\x14\x34\xa0\x34\xbd\x64\xa2\xc2\x90\x1e\x59\x4e\xed\x91\x63\xbf\x83\x53\xc7\x06\xf9\x83\xa7\x9d\x08\xac\xe9\xa1\x98\x52\xf0\x72\x0a\x04\xd7\x86\x1d\xa9\x52\x1c\x9a\x30\x4c\xa9\x70\x1f\xc3\x5f\x08\x99\xf3\xea\x06\x16\x19\x0a\x21\x6f\x44\x75\x62\x19\x15\xfc\x1c\x08\xe4\x50\xe2\x48\xfc\x0a\xc5\x97\x37\xa2\x8a\xc4\x97\x26\x00\x65\xc3\xf8\xfb\xb9\x8c\x8b\x9d\xcb\xa0\x58\x1b\x89\x5f\x56\x96\x82\x5f\x97\x4e\xa2\x62\xb3\xa2\x8c\x25\x91\x00\xbf\x2d\x05\xc0\x2f\xbf\xff\xf1\x3b\x10\xc8\xde\x88\x2a\x14\xc8\xea\x1b\x08\xd6\x37\xee\x9b\xf8\x6f\x5f\xa0\xbe\x21\xe3\xb9\xb0\x54\x7d\x13\x26\x08\x63\xea\x19\xa2\x2c\xc2\x98\x87\x9f\x18\x8f\xfc\xa5\x13\xb0\x94\xcb\xb9\xca\x6a\x7e\x0b\xcb\xb1\x5c\xce\xcf\xf1\x03\xe2\x2c\xb4\x6f\x0f\x7f\x60\x98\xe3\x75\x54\xc0\xc3\x28\x00\x2c\x81\xe5\x64\x7f\x62\x38\x49\x2f\xbc\xd8\x02\x09\x35\x04\x49\xcb\x4c\x06\xc4\xdb\x45\x78\x1e\xd7\x3d\xa9\x29\xff\x9a\xa6\x6e\x45\x35\x41\x89\xb8\xfd\xe9\xc2\xcd\x46\x5b\x28\xc4\xd9\xa5\x78\x13\xf4\x82\x82\x70\x52\x6d\xe8\xc0\xa6\xec\x75\x25\xb5\x81\xf5\x4c\x66\x37\x25\x0a\x12\x6d\xd8\x95\x0d\x6b\x14\xea\xd2\xf6\x3a\x13\x2f\xb8\x2c\x6b\x3b\x3c\xf0\x71\xee\xc6\x08\xbf\x07\x38\x68\xed\xe8\x05\x2f\x95\x16\xbb\x10\x01\xbf\x6c\x26\xf3\x31\xd8\xed\x35\x22\xcc\x85\xde\x11\x37\xf3\x11\x90\x35\x12\x63\x37\x96\x1c\x85\xb6\x56\x1d\x85\x87\xc7\x22\x05\xc5\xa7\x22\x05\x36\x8a\x0b\xca\x51\x40\xde\xc1\x95\x06\x24\xc0\xef\x13\xf8\xa6\xce\x60\xd0\x00\xd3\xf4\x92\x89\x1c\xe9\x5d\x78\xba\x8b\x3f\x79\x7d\xe7\x82\x0f\xeb\x7f\x44\x31\xeb\x20\xe6\x9f\x51\xcc\x6f\x41\xcc\xff\xc6\x18\xc0\x85\x43\x41\xfc\x84\x4e\x0c\xeb\xed\x01\x44\x6e\x18\x05\xdf\x87\xe6\x3b\x4e\xa1\x17\x22\xab\x01\xc8\x27\x4c\x07\xa1\x17\x26\x94\x52\x03\xd1\xbc\x15\x6e\xb8\x6c\x40\x30\x60\xa4\xd1\x88\xc2\x7f\xf8\x09\xe1\x66\xed\xe0\x9a\x30\x7c\x07\xe8\x25\xe0\x0f\x0c\x13\xc0\x37\x56\x62\xf2\x0f\xfb\x4d\xd2\xfe\x7f\xd2\x37\x9d\xd6\xd2\x3e\xaf\xbb\x90\x53\xff\xcc\xee\x03\x07\x98\xae\xd7\x91\xb0\x12\x0b\xc1\xeb\x0c\x81\xe7\x7b\xf8\x05\x30\xf4\x41\x2c\xde\x83\xf1\xf7\x31\xdd\x86\xed\xcd\xd1\x5c\x1b\x11\x6b\x37\x78\x66\x38\x71\x81\x51\xda\x89\xe0\xf5\x12\x6f\x6b\x36\xe8\x29\x05\x51\x3a\x0b\x8d\xd0\xb3\x3f\x6d\x38\x91\x79\xfa\x65\x43\x97\x05\x05\xda\x97\x73\xfc\xa9\x5d\xa0\x7d\xb8\xa8\x51\x68\x81\x3f\x30\x0c\x06\x19\x17\x07\xc8\xd5\x49\xa4\xae\x33\x8e\xa2\x77\xf3\x17\x43\x08\x0b\x09\x9e\x1c\xf0\x27\x85\xd3\x33\x44\xf8\x04\x11\xf2\x60\x10\xd0\xe0\xc1\x20\x2c\xe6\xc1\x12\xc9\x74\x41\xaf\x27\x85\x7b\x3d\x71\xfc\x83\x0e\x98\x02\xb3\x28\x97\x05\xaf\x02\x01\x8b\x0d\x8a\x24\x2c\x36\x30\x90\x0b\xd8\xa0\x93\x50\x3e\xa0\x17\xd4\xa7\x85\xeb\xd4\xa2\x12\x3c\x77\x6f\x81\xf8\x19\x3c\xd3\xc3\x74\xb8\x13\x07\xbe\xce\xfd\xb1\xa3\xeb\x3c\x17\xb7\xd2\x9e\x11\xba\xce\x8f\xed\x27\xc5\x8b\xf9\x0c\x1f\x3e\xe6\x33\x17\x72\x4b\x21\xb7\x14\x22\xeb\x6c\x56\xcb\x02\x5f\x6f\xe0\xeb\xca\x7c\x51\xac\x5a\x58\x96\xc8\xfc\x0e\xd8\x21\xf3\xe9\x59\xa1\x38\xd2\x7c\xf9\x33\x31\x00\xd1\x0f\xb2\x06\xb7\xff\x66\x02\x5d\x57\xf2\x46\xd4\xb3\x4a\x2d\xa7\xb3\xe0\xd4\x8a\xc2\xe3\xa3\x2b\x8a\x8a\xce\xaf\xee\x4c\x51\x4c\x78\x92\x45\x11\x8d\xe3\x2c\xae\x28\x3a\xd3\x36\x64\x43\xe5\xbc\x3d\x67\x30\xdd\x77\x10\xff\x18\xa6\x6e\x44\x10\x96\x7b\xd7\x02\xbd\x86\xb3\x01\xd7\x08\x75\x23\x06\x2e\x5d\xaf\x23\xa1\x2f\x2e\x58\x43\xb1\x8f\x82\x56\x81\x14\xdc\x95\x14\x03\xcd\xd1\x9d\xf1\x85\x4b\xf4\x0c\xbf\xa3\xc2\x28\x4d\x2f\x99\xc8\x17\xf3\xab\x92\x65\x94\xc4\x04\xb4\x0a\x82\xc0\x74\x32\x0c\x9a\x07\xbe\x15\x7a\x4d\x77\x0b\x51\x71\x3e\x65\xaf\x2b\x29\x06\x5a\xfe\x34\xf0\xc5\x10\x15\x84\x4f\x74\x89\x04\xf8\x1d\x6e\x80\xc0\xc7\x43\x54\x44\xb4\x09\x9a\x89\x2c\x4a\x44\x43\xa7\x8b\x34\x1c\xe1\xad\x72\x13\x8c\x44\x54\xc6\x6c\x9d\x23\x78\x5e\x3b\xf7\x8f\x36\x2a\xce\x57\x4d\x78\x26\x1c\xb9\xc6\xcf\x4b\x4f\xb5\xd7\x86\x84\x14\xbc\x9c\x2e\x39\xa8\xd7\x61\xc0\x33\x0a\x80\x34\xd0\x18\xc4\x42\xc0\x17\x54\x8b\x90\x4a\xb1\xd5\x54\xd4\x77\xee\x15\xf5\x1f\x41\xe8\xda\x85\xe2\xa1\x0c\x3a\xcf\x65\x36\x03\x3a\x64\x3e\x0e\xe1\x03\x87\xd2\x7c\x0f\x30\xb6\xd7\x8e\x36\x9f\xb9\xc8\x54\x65\xa9\xa4\x09\x38\x76\x01\x41\x11\x3e\x55\x2f\x9d\xcc\x04\x39\x9e\xd1\x7c\x04\x3c\xa3\xf9\x0c\x0f\x27\xf3\xdd\x38\x9b\xa0\x92\xe8\x68\x6a\x27\xaa\x0d\x53\x54\x23\x0f\x14\x72\x94\x75\xc4\x4a\xf6\x10\x8b\xa1\xb7\xe7\x7e\x99\xd0\xa5\x61\x7e\x97\xc8\xde\x2e\x9f\x98\xdf\x28\x0f\x58\x9a\x0a\x1a\xfc\xbf\x0b\x8b\xa9\xa8\x0b\x8e\x28\x68\x3a\xb1\x0b\x0d\x29\xa7\x0b\x6c\x50\x4d\x5f\x70\x44\x31\x3b\x92\x2f\x4b\x99\xe1\x8d\x8c\x7e\x85\xa1\x63\x99\x4b\x1f\xf3\xbd\xcc\xa5\xad\x02\x02\x06\x26\xbe\x97\x48\x40\xdf\x15\x47\x75\x50\xfa\xbc\xe0\x56\x23\xd4\x15\x00\x29\x7a\xa9\x24\xc0\x8c\x1a\x26\x64\x8e\xb1\xb5\x7e\x21\xaa\x93\xb9\xcb\x5e\xeb\xc1\xc2\xb0\xe7\xf3\x5e\x3b\x7e\x59\x7a\x1b\x79\x88\x0d\x4c\xe6\xfb\xa8\x09\x10\x3c\x5d\xdf\x1e\xc6\x6f\xd7\xbd\xdb\x41\xf0\x9a\x9d\x48\xe0\xb6\xd9\xad\xdf\x61\xb7\x22\xab\x55\x85\x26\xe0\x26\x06\x3e\x4f\xd0\x22\x1c\x0b\x85\x90\x81\x33\x12\x6f\x27\x21\x1b\x2d\x88\x82\x5f\x36\xb4\xe6\xf9\xed\x1a\x83\xeb\xc3\xfc\xf6\x9f\xb6\xc0\xaa\x06\x29\xdd\xba\xd7\x8c\x33\x1f\x5e\x46\x67\xbe\x22\x11\x1d\xe4\x0c\x25\x74\xcd\x14\x3e\xff\x3a\x8a\xfd\x67\x3b\xff\xba\x97\x48\x71\xeb\x65\x8e\xb7\x3f\x06\x42\xc7\xde\xed\xc0\xca\x20\x9b\x51\xb7\xb1\x50\xf0\xf6\xb4\x21\x15\xec\xdd\x0e\x42\x41\x61\x2a\xc9\xad\x14\x2b\x7c\x0e\x37\xbf\xbe\xa7\x17\x71\xf3\xdb\xe9\x90\x98\x8f\x40\x3d\xf2\x56\x5a\x88\x1d\x88\xb3\x1f\x18\xd7\x90\x63\xdc\x3e\x6f\x0a\x32\x7a\xb7\x83\x48\xb8\x91\x4c\x74\xab\x32\x3e\x36\x31\xe6\x2f\x84\xc0\x49\xa6\xad\xd6\x09\xae\x9e\x95\xaa\x72\xcf\x16\x9b\xaf\x48\xa8\x66\x02\x42\x91\x5a\x33\xc1\xaa\x02\xa1\x97\xd5\x5d\xc1\x2f\xf7\x78\x67\x03\x06\x20\x72\x49\x24\xb8\x33\xc4\xec\x0e\x89\xd9\x9d\x21\x66\x77\x48\xcc\xcc\x50\xe2\x20\xde\x65\x33\x5e\x96\xa2\xc0\x7d\x04\x27\xc3\xdd\x11\x06\x5d\x52\x10\xa6\x73\xa2\xb1\xbb\x50\x69\xe0\x2e\x50\x19\x08\x23\xee\x0a\x59\xde\xf0\xac\x5e\xe2\x95\x06\x3e\x0f\xf1\x93\x32\x02\x14\x1d\xa5\xe8\xa5\x92\x60\x11\x55\x46\x0a\x5f\x18\x8f\x9f\x51\x11\x14\x94\x4a\x02\x01\x24\x85\x87\xdf\x3f\x5a\x15\x56\xca\x0c\x2a\xad\xad\x48\xf8\x0a\xab\xbd\x68\xd4\x19\x55\x78\x11\xd5\xa6\x67\x20\x39\x82\xdf\x97\x33\x12\x1d\x51\x36\x13\xd7\x6b\x45\xc2\x97\xd5\x7b\x82\x8f\x2b\xa7\xfc\x44\x19\x51\x1b\xaa\x1d\x8d\x59\xf1\x11\x1c\xa3\x9c\x62\x33\x65\x34\xdf\xad\xc8\xbb\x79\x81\xb0\x83\xbd\xbb\x79\xf1\x3d\xd7\x36\xcb\xbc\xd8\x33\xe1\xbd\x46\xc4\xdd\xbc\x20\x9d\xb1\xbb\x79\xe1\x74\xc6\x20\x39\x68\x98\x36\x22\xee\xe6\x05\x5c\xb3\xe1\xaf\x4f\x0a\x90\x40\x94\xf6\x12\x7e\xbb\xc4\xd8\x56\xca\xf1\x0f\xf3\xe1\xb2\x95\x7a\x0f\x62\x7b\xed\xe8\xbb\x39\x98\x2c\x88\x66\x91\x6b\xb3\xe6\xd7\xb8\xe6\xd7\x66\xcd\xaf\x71\xcd\x1b\x4a\x80\x04\x60\xdd\x5e\xf3\xeb\xd4\x9a\xff\x6d\x8f\xf5\x7e\xc3\x5f\x4a\xcd\x79\x99\xa3\x2a\x9e\xf9\x38\x2c\xf3\x17\xbc\xec\x01\x14\x45\xb7\x71\xdc\x93\xff\x1e\xe3\xb8\x7f\x45\xbe\x2a\x42\xcb\xb8\xc8\xd7\x45\x6c\x8e\x0d\x91\xf7\xa2\x50\x60\xce\x93\x57\x27\x67\x57\x08\x6e\x71\x71\xf2\xc3\xc9\x3f\xc0\xf1\x87\x2a\xad\xab\x0f\x4c\x04\x46\xe5\x50\xea\x7b\x82\x6e\x04\xc5\x00\xc2\x43\x57\x59\x0f\x06\xde\xc0\x02\x9b\xa6\xbb\x50\xac\x37\xa5\x8d\xd0\x2c\x08\x75\x3b\x44\x92\x6d\x8e\x5a\x1a\xd8\xe2\xe3\xdd\x0d\xd0\x16\x1f\xef\xa6\xbd\x4d\x44\xc6\xce\xae\xc2\x4a\x4c\xa5\x46\xd1\x5e\x69\x5a\x86\x8e\xd0\xd3\x9e\x2d\x1e\x56\xe2\xa2\x58\x4e\x65\x19\xd9\xfa\x82\x43\x9c\xe6\xb4\x26\x01\xdf\xd1\x0e\xbf\x54\x0c\xbd\x13\x53\x59\x08\xe0\x38\x16\xa2\x74\x0e\x9f\xfa\x6c\x25\xd8\xdc\x9c\x00\x04\x1d\xc8\x09\xd4\x9b\x89\xc0\x3b\xa9\x2f\xf5\x18\x50\xc9\x40\x93\x15\xcb\x26\x6f\xec\x52\x03\x04\xd6\xf0\x9e\x8e\xbd\x33\x56\x41\x73\x5c\xd9\x81\xb3\x6b\xbb\x68\x44\x3d\x00\xba\xa0\x33\xeb\xeb\x38\xed\x2f\x31\xaa\x41\x6a\x82\xdb\x58\xd9\x5d\xa6\xcb\x38\x05\x33\x5e\xe6\x05\xb8\xef\x21\x34\x99\x07\xd8\xea\x37\xeb\x4c\xd8\x23\x3e\xd9\x60\xb1\x6f\x57\xf0\xfd\x36\xfb\xae\x97\xf1\x30\x78\x64\x3c\x55\x5a\xc0\x64\xb3\x04\x1b\xa9\x9c\x15\xf7\x93\xfb\x01\x0b\x36\x0e\xc6\x69\xed\x70\xac\xe5\xb4\x54\x95\xc8\x37\x41\x8f\x7c\xc8\xbe\x8f\x46\xec\x19\x39\x7e\x6e\x40\x2a\xcc\x94\xba\x71\xd4\xa8\x89\xa4\xe2\x57\x07\x92\xd1\x60\x2f\xb2\xdf\x7f\x8f\xa8\x62\x72\x9b\x3e\x7c\x2a\x08\xb5\xb1\x04\xa5\x1e\x89\x4e\xb9\x36\xa4\x50\xcb\x10\xec\xb9\x39\x19\x70\x9a\xb1\xa5\x06\x54\x72\xb0\x59\x04\x83\x52\x55\x7e\x5f\x2c\xab\xd0\x99\x34\xc5\x9e\x96\x14\x0f\x5f\xe7\xcb\x9a\xcc\x71\x0f\x8b\x02\x4f\x46\x4b\x0a\xd0\xa7\xae\xf3\x9e\x57\x2b\x36\x5e\x8e\xc7\x80\xf9\xa8\x3a\x0b\xc3\xb2\xac\x3b\xde\x52\x88\x5c\xe4\x23\xef\x91\x67\xbc\xc6\x3a\x86\xbd\x3f\x6f\xa1\xe3\xd8\x39\x03\xa5\x0d\x43\x77\x0c\x4a\x84\x88\x25\x0b\xee\xde\xfd\x12\x96\x1e\x8a\x95\xf0\x4d\x16\xa2\x42\x40\xe2\x00\xa4\xa0\x09\x9b\xda\x67\x85\x52\x37\xcb\x85\xf3\xed\x0c\xa1\x60\x0a\xbd\x01\x8e\xf6\x4f\x1e\x09\x73\x62\x6f\x18\x04\xc0\x07\x35\x69\xae\x63\x2f\x82\x0e\xde\x72\xa2\x2a\x36\x59\xd6\xcb\x0a\x61\x90\x65\x49\x53\x88\xc3\xf0\x82\x6b\x73\x6a\xe4\xf2\x56\xe6\x4b\x5e\x60\x51\x83\xeb\xd0\x72\xda\x3a\xf7\xf9\xf3\xe7\x5c\x37\x9c\xce\x59\x20\x00\x1f\xe2\x4c\xc7\x5b\xae\xeb\x1e\x05\x30\xa0\x9b\x76\x5b\x26\xa4\x19\x15\x8e\xd6\xed\xe0\xcd\xc2\x9a\xac\x07\xd8\x2d\x12\x48\xa0\x47\xcf\xb1\xa0\xb1\x7d\x73\xb2\xd6\x16\x5a\xd6\xba\x18\x00\x7f\x81\x04\xaf\xea\x0c\xd6\x6d\xcb\xfe\xfc\x83\x62\xa3\x0b\xbf\xb4\x53\x96\xce\x71\x39\xe3\x67\xb1\x97\x1e\x8f\xe5\xf3\x07\xc6\xe3\xcf\x3f\x34\x10\x6c\xe6\xc2\x2e\xfa\x83\xe0\xc3\x94\x89\xc4\xde\x03\x23\xfd\x27\x1c\x80\x6d\xbc\xa0\x39\xaf\xb3\x19\x42\x16\xa0\x71\xbf\xf7\x07\x41\xc8\x48\x8e\xc6\x64\xaa\x9c\xc8\xa9\x47\x0d\x4a\x9a\xf8\xdf\xc3\x06\xf9\x09\x49\x60\x41\x25\x0b\x6c\x32\x47\xb1\xf3\x90\x20\x3f\xec\x9f\x08\xb7\xa8\x9b\x2b\x0a\xc0\x9d\x1e\xc4\x0b\x6d\xc6\x2d\x8a\xa6\xf5\xc1\x13\x9b\x98\x5a\xe7\xa2\x21\xf2\x06\xe4\xe6\xf8\xd3\x4f\x99\x43\x6a\x6a\xb2\x97\x01\xef\x6d\xb9\x9d\xf6\x64\x03\x07\xee\x71\xa0\xec\x8c\x93\x03\x57\x5e\xf7\x34\xf8\xfa\xac\x67\x62\xed\x8b\xb3\x4c\x91\xc9\x92\x33\x5e\xae\x57\x7c\x8d\xbe\x7f\x88\x57\xf7\xbe\x77\x36\x9e\xf8\xb9\x12\x78\x30\x55\x22\x53\xd3\x52\xfe\x26\xfc\x9e\xb3\x00\x1c\x1c\x66\x86\x00\x7a\x9d\xe7\x57\xd8\x6c\x01\x10\x75\xb1\x66\x2b\x5e\x5a\xbc\x61\xbe\x58\x08\xc0\x6b\x82\xe2\x4c\x7e\xae\x19\x67\x08\xf6\x4b\xc7\xbb\x07\x00\x03\xf3\x37\x93\x93\xeb\x60\x24\xa0\x11\x96\xec\x63\x1e\xaa\x9b\x67\x99\xcc\xcd\xc1\x68\x6a\xb5\xae\xa8\x6b\x44\xa0\xe6\x6c\xc1\xcd\x75\xdc\xc3\x77\xf4\xc9\x6f\x2e\x35\x99\xd2\xd9\x76\xd9\x7e\x05\x0b\x2b\x9e\xc6\x7f\x07\xe5\x74\x8e\x56\x3f\xfd\x94\x3d\xc2\x75\xe2\x80\x48\x0f\x01\x55\xe3\x7b\x4c\xe1\xbd\x09\xef\xc4\x5e\x83\x6e\x63\xbf\x6a\x1b\x68\x6d\x70\x02\x95\xaa\x1c\x50\xd5\x4d\x08\xb1\x9f\xcb\x9f\xcb\x70\x0a\x60\xae\x6b\x05\x82\x4d\x41\x93\x4e\x43\xda\x87\x29\xf1\x07\x1a\x4d\xe1\x1e\x8e\xff\x27\xfa\xe0\xa3\x4f\xf4\x47\x4c\x55\xec\x13\x7d\xf0\x2f\x74\xd0\x57\x2b\x44\x5b\xda\xde\x79\x8b\x13\x41\x67\x56\xd9\xbc\xd1\x3f\x88\x88\x37\x00\x66\xfe\x07\xf5\xbd\x59\x13\x38\xad\xaa\x95\xa1\xf2\xb9\x74\xfb\x0c\xfc\x9b\xc8\x1a\xf7\xbb\x29\xc8\x45\x3b\x36\xe5\x6d\x9f\x60\xe3\x4d\x6b\xe2\x24\xdf\xd1\x42\xdb\xf3\x6c\xcc\xdb\xd8\x75\xe2\x7d\x83\x1f\xfe\xbf\x79\x22\x3e\xd8\x55\xec\x0c\x28\xa0\x73\x84\x6d\x6f\x5f\x39\x91\xcb\x3e\xcb\x15\x90\x31\x1b\x61\xf3\x81\x2f\x6a\xb3\xbf\xd0\xc9\x86\x63\x47\x01\x85\xc9\x6d\x40\x4f\xce\xef\xbf\x88\x8d\x46\xec\x27\x5e\x95\x88\xa9\xc4\x59\x83\xaa\xa3\xdf\x8c\x31\xcf\xa1\x52\x8f\x28\x87\x7b\xf8\x52\xd4\x6e\x1b\x87\xde\xe1\x76\xba\x31\x08\x37\x0f\x55\x84\x42\xb8\x95\x68\x76\xec\x5a\xee\xa5\x47\x37\x73\x48\xbb\x81\x04\x2d\x85\xb8\x17\x00\xa2\x59\xc4\xbd\x3f\x04\xb8\xe7\x50\xbe\x6e\xc4\x9a\x2a\x7b\x7d\x23\xd6\xbf\x6c\x84\xdf\x0b\x1b\xf1\xce\xf0\x7b\x51\xe6\x0f\x01\xbf\x87\xad\x8c\x8a\x7d\x17\xf4\x3d\xef\x0f\x2c\x09\xc1\x77\x82\x8e\x55\xe8\xc8\x0a\x4f\x2b\x3a\xa9\x68\x67\x9b\xfc\x11\xa9\x01\x1f\x32\x86\xe1\xf6\xec\x2f\xf8\x3b\x32\xb4\xc2\x1d\xc3\x0f\xc3\xc6\x43\xbf\x1f\x6e\x51\x0f\xc6\x62\xc6\x6f\xa5\xaa\xde\x0d\x22\xcf\x91\x82\x80\x73\x4a\x8d\xda\x03\xb0\xfe\xc8\x23\xac\x1d\xb4\x36\xe2\x5f\x3c\x6a\x00\x98\xf5\x47\xc7\x0d\x0a\xf9\x77\x8f\x5c\xfc\x30\x91\x00\xcd\x7b\xf2\x61\x11\x06\x5b\x14\xa2\x0d\x31\x38\x1a\xb1\xab\xf3\xe3\xf3\x3d\xb2\xa4\x64\x72\xbe\x50\x55\xad\x59\x21\x6f\x04\xd3\x6a\x2e\x06\x0b\x9e\xdd\xf0\xa9\x18\xe9\x2a\x1b\x7d\x06\x12\xa0\xb1\xe1\xe0\x9e\xca\x3b\x36\x17\x88\x44\x36\x15\xb5\x7d\x36\x91\x63\x51\x9d\xaf\x4a\x51\x19\x66\x0b\x84\xfa\xed\xa7\x15\x93\x66\xd8\x95\x67\x3f\x55\x62\x63\x3c\x1f\x5c\x6a\x94\x6f\x3f\x02\x54\xa4\xc5\xe8\x14\x84\x3c\xae\x62\x90\xe8\x72\xc6\xf3\xb5\xe1\x2b\x3d\xe8\xa2\x89\x3d\x3e\x3c\xfb\xe1\xe4\xe2\xfc\xe5\xe5\xb3\x7f\xbe\xb9\x3c\xb9\x7a\x73\x7a\x76\x76\x72\xf1\x06\x3d\x02\x75\xc3\x3b\x61\xc9\x97\x2f\x5f\xbc\xb8\x38\xb9\xbc\x7c\x73\x74\x7e\x76\x75\x72\x76\xf5\xe6\xe4\xf8\xf4\xea\xf0\xfb\x67\x27\x6f\x7e\x3a\xbc\x38\x3b\x3d\xfb\xc1\x14\x71\x8f\xf2\x53\xa3\xa4\x1f\xff\x79\x7c\x71\x78\x75\x7a\x7e\x66\x8b\x40\x57\x58\x9d\x3a\x50\x98\xfd\xf0\xe5\xd5\xf9\xd3\xf3\xa3\x97\x97\x00\xca\xed\xc0\xcd\x30\xf2\xe8\xc7\xd3\x67\xc7\x17\x27\x67\xe0\x3d\xce\xe2\x82\x51\xb5\x57\xff\x7c\x76\x02\xe5\x83\x2d\xdd\xbe\x73\xc0\x15\xbb\xdf\xb2\xa1\xf0\x92\x71\xf9\xe2\xf0\xc8\xe4\x39\xb3\x5e\x48\xf4\xd0\xa4\xdb\xdf\xda\xb2\xb3\x7d\x49\x0f\x71\x0d\xf7\xf9\x43\xc3\x26\x5c\xc0\xc2\xd6\xdb\x3d\x78\x3f\x32\x8b\x3d\xc8\xb0\x79\xa5\x34\xbc\xd1\xd3\x86\x08\xfc\xbe\x01\x0b\x70\x34\xab\xd4\x1c\x7d\xa6\xcc\x04\xba\x92\x9a\xf3\x5f\x55\xc5\xc6\x95\x5a\x69\x51\xa1\xef\xd2\x99\x44\xd7\x38\xdf\xd4\x72\x2e\xbe\x1d\xb2\xef\x97\x70\xc5\x51\x13\xf6\x1f\xcb\x62\x6d\xcb\x7a\xf2\x78\xf7\x6f\x48\xa5\x6b\x51\xe6\x80\x11\x08\xae\x07\x64\xcd\x72\xa4\x47\x2b\x99\x0b\x54\x86\x65\x4b\xcd\xa7\x02\x9c\xd9\x45\x77\x2f\x5b\xd6\x67\xe0\x23\xe6\x33\x68\x3c\x90\x4b\xac\x1a\xa4\xb1\x86\x30\x80\x5f\xd5\x65\xe9\x6e\x7b\x20\x4c\xa5\xce\x90\xef\x18\x5b\x94\xac\x99\x56\xaa\xb4\x57\xcd\x3e\x22\x81\xf3\x72\x6d\x2e\x77\xe1\xc3\x11\x22\x2f\x9a\xdb\x1b\x5c\x43\xf1\xc2\x89\x08\x64\xd6\xcb\x9c\x75\x38\x53\xa1\xd3\x9b\x95\xaa\x6e\x40\x52\xaa\x8a\xf5\x44\x16\x05\x52\xf6\x6f\x72\xc9\x0b\x35\xfd\x76\x08\x82\xf7\x85\x50\x8b\x82\x84\x85\xf4\xdc\x84\xf1\xe4\xdb\x2d\xf4\x4d\xdd\xa6\x8b\xa7\xe5\xb1\xb8\x15\x85\x5a\x80\xeb\xb2\x8d\x5c\x0e\xbb\x0f\xb6\x75\xbf\x23\x51\x03\xb0\xb4\x33\xd9\x93\x56\x32\x6c\x39\x21\x2e\x9a\xfb\x2a\x8c\xa0\x13\x93\x6b\x76\x74\x01\xa3\x7d\x74\xf1\xec\xa9\x99\xff\x67\x4f\x87\x98\xfe\xb4\x46\x54\xc8\x8c\x97\x0c\xd8\x95\x9f\x97\x8f\x1f\x3f\x7e\x6c\xd6\x82\x62\x3f\x2f\x9f\x3e\x7d\x7a\x6c\x58\x79\x99\x8b\x40\xd0\x40\x79\x9d\x67\x9e\xd5\x6a\xb8\xfa\x62\xa8\xaa\xe9\xe8\xea\x62\x64\x36\xd5\x57\x23\x53\x7f\x61\x08\xf7\x54\xc0\x36\xfb\xcb\xa2\x12\x8b\x4a\x65\x02\x9d\xd7\xd4\x33\x31\x00\x14\x2e\xb0\xaa\xe5\xf3\x2d\xfb\x9c\xb8\x12\xb8\x0e\x38\x9b\x4b\x0d\x52\xab\xbe\x59\x08\xee\xf5\x10\x16\x14\xac\x31\xb3\x2b\xa9\x21\x3f\x09\x5c\x53\xe8\xeb\x6f\x01\xb2\xae\xe5\x22\x7a\x34\x04\x48\x70\xb3\x85\x26\xb2\x42\x89\x04\x71\x06\x43\x9a\xf1\xb3\xf3\x8b\xe7\x87\xcf\x4e\xff\xf7\xc9\x9b\xb3\x93\x9f\x9e\x9d\x9e\x9d\x5c\xfa\x17\xed\x9f\xab\x9f\xcb\xef\x46\xd3\xfd\x76\xd2\x97\xcf\x9e\xbd\x39\x3c\x3b\x7e\x73\x71\xf2\xe2\xd9\xe1\xd1\xc9\x73\x43\x4c\x7d\x36\x18\xca\xdf\x71\x14\x4d\x76\xca\xef\xa6\xe5\x39\xaf\x6e\x96\x8b\xa7\xaa\xba\x12\x77\xf5\x79\xe5\x38\xf9\x68\x79\xcd\x21\x51\xc8\x0b\x63\x88\x63\x47\xe9\xb2\x8f\xa1\x91\xdb\x28\xf6\x9d\x0d\xdd\x63\x3d\xc3\x6c\xe0\xd7\x7e\xc8\x9e\x86\x85\x39\xb7\xf6\x5d\x83\xd1\x67\xbd\x9f\xcb\xde\x4e\x2a\x5d\xe7\x48\x80\x07\xfc\xb6\xe7\x77\xea\xf5\xb1\x9c\x4c\x44\x25\xca\x2c\xee\x34\xca\x9c\x4c\x82\x3e\xcb\x0a\x30\x81\x15\x77\x75\xf8\xfa\xde\x71\x84\x76\x39\x7e\xb7\x63\xe7\x5f\x8e\x8e\x5c\xb1\xe0\x4b\xf6\x9e\x29\xd9\x0e\x5a\xb1\x9f\x28\xed\xd2\x35\xf8\x41\xa5\xf9\xfe\x05\xd7\x94\x74\x69\x07\x07\xc9\x46\x6f\xea\x68\x37\x7b\xd1\xed\xe1\x1e\x2a\x23\x4d\x68\x53\x00\x6c\x16\xd8\x80\x43\x86\xcd\xd9\x63\x20\x6a\xc0\x26\xe0\x47\xaf\x9f\x1c\x82\x7e\xba\xc5\xc9\x45\x60\xc8\x5a\xc7\x22\x30\xe4\x8d\x9c\xbd\x42\xd1\xe4\x6f\x19\x67\xe2\x55\x53\x1d\xe3\x03\x2d\x08\xeb\x28\xf7\xa1\x2b\x22\x74\x41\x9b\x5a\x12\x0f\x2f\x2f\xe8\xe4\x86\x45\xf1\xca\xc3\x49\xa7\x5a\xfe\xa1\x97\x85\x99\x1e\x14\x6a\x75\xac\x89\x4f\xb4\x5b\x11\x70\x25\xf1\x93\xf6\x1f\x97\xe7\x67\x43\xa4\x44\x72\xb2\x4e\x77\x64\x67\x43\xb2\xb0\x57\xe9\xb5\x73\x72\x57\x57\xdc\xfb\x53\x8a\x16\x4f\x04\x0a\xa5\xff\xe0\x42\x79\xc8\xc8\xc1\xe4\x13\xfc\xf1\x6b\x7a\xbf\x88\x1b\x31\x9c\xa8\xea\x84\x67\xb3\x40\x5e\x10\xbf\x64\x40\x76\x14\x47\xd0\xbb\x0e\x34\x61\x27\x3d\x35\xd0\xfb\xc8\xe5\x8a\xbd\x9f\x6a\x37\x37\x24\x81\xd6\xe9\xf1\xa3\xfe\x80\x75\xe3\x33\xa9\x6b\x51\x82\xa3\x72\xdf\xbc\xb6\x72\x48\x41\xc9\xc2\x01\x2d\x5c\xd6\x03\xba\xa3\x74\x3f\xc8\x9d\xd0\x03\x1b\xae\x29\x97\xb3\x56\xe6\x70\xe7\xae\xea\xbe\xd3\x10\x98\xaa\x9a\x5d\x43\xee\xb6\xd8\xf4\xdf\x23\xcc\x6c\x0f\xca\x43\x42\x36\xdf\x11\x1e\x0a\x65\xfe\x5e\xc3\x67\xdd\xc0\xab\x09\x66\x03\x7d\xbe\x8e\xae\x10\x33\x61\x4b\x7e\x78\xbb\x43\x26\xf4\x05\xaf\xb4\xf0\xb0\xe4\x86\xf1\x84\xab\x86\xac\xd9\x18\x9c\x41\x2a\x4f\xbc\x7c\x32\x92\x9e\x68\x85\x72\x59\x59\x63\x61\x86\x33\x1d\x0b\x9c\x6b\xc3\xd4\x67\x6a\xbe\xe0\x95\xd4\xe8\xd9\x24\x22\xb9\x74\x03\x0c\x4e\x10\x78\xb8\xe9\x03\xfe\x6c\xe0\x2c\xf3\x27\xc1\x32\xff\x52\x96\x55\x02\x04\xbf\x9c\x69\xb1\xe0\x15\xaf\x85\xd3\x93\x60\x70\xc1\xa8\x15\xe3\xb7\x4a\xe6\x36\x7b\x65\x78\x57\x59\x83\xbb\x7e\xd3\x62\x7a\x83\xb2\x0e\x27\xcd\x9e\xa8\x67\x62\xcd\xc4\x9d\xd4\x35\xde\xd1\x80\x0f\x1d\x57\x82\xdf\x68\x5b\xca\x4c\xad\xd8\x37\xa5\x42\xb8\xac\x6f\xcd\xc5\x6f\x2c\x4c\x69\xa8\xb7\x94\x0f\xd9\xa5\x32\xdc\xf0\x92\x46\x12\x7c\x61\xdb\x76\x39\xe7\x98\x97\x02\x63\x73\xa9\xb3\xa5\xd6\xe0\x9b\xb4\x74\x8c\x39\xb9\xcb\xcc\xd4\x7c\x34\xe1\x99\x18\x2b\x75\x83\xf2\xa4\xd1\x62\x59\x14\xa3\xdd\xdd\xdd\xaf\xfe\x36\x74\xc4\xab\x16\xba\x26\xb7\xd0\xec\x80\xde\xbc\x86\xce\x67\xe7\xcb\x8b\x53\xd8\xdf\x8d\xfb\xf4\x77\x36\xa1\x5a\x95\xa2\x3a\xb6\xed\xc3\x31\xa5\xd2\x68\x1a\x86\xce\x6b\xe9\xde\x03\x32\x9d\x5d\x6e\x27\x9a\xd0\x67\x8d\xb2\x70\xf5\x05\x4d\x1f\x4a\xef\x19\x99\xe1\x05\x3f\x94\x62\xa7\x12\x7a\xb1\xb6\x5b\x39\x88\x84\x8f\x34\x51\x96\xd3\x2b\xb5\x5d\x29\x55\x1f\xa1\x73\x5f\x51\x9d\x58\x01\x60\x73\x03\x05\x8e\x65\xb4\xed\xd7\x79\xf5\xb4\xe2\x53\x1a\xd6\x54\x31\xc3\x52\xe5\x00\x7a\x06\x03\x7c\x7c\x7e\xf4\x12\xb8\xe7\xb3\xf3\xe3\x13\xd0\xf0\x7a\x78\x96\xa7\x17\x87\x3f\xb8\xbc\xf6\xba\x92\xab\x0c\xf4\x06\x12\xed\xf9\x2e\x59\x38\xdb\x4b\xd7\x19\xcd\xd6\x3e\xa1\x07\x8b\xd2\x0c\x4e\x8b\x8e\xe4\x2a\xdb\x89\x87\x74\xfa\xff\xb1\xf7\xed\xef\x6d\xdb\xc8\xa2\x3f\xaf\xff\x0a\x24\x9b\x46\x52\x22\x53\xb1\xf3\x6a\xe5\xb8\x39\x6e\xec\x6c\x7d\xda\xd8\x3e\xb1\xd3\xdc\xbd\x3e\xbe\x0e\x44\x42\x12\x6b\x8a\x50\x09\xca\x8e\x36\xf6\xff\x7e\x3f\xcc\xe0\x49\x82\xb2\x1c\xbb\xdd\xdd\x73\xba\xfb\x7d\x8d\x4c\x82\x03\x60\x30\x18\x0c\xe6\xc9\xca\x7d\x17\xc0\xdb\x82\x4f\xde\xbb\xdd\x04\x51\x8c\x08\x55\xab\x77\x53\xe4\xdd\x6a\x7a\x4a\x31\x69\x54\x0c\x82\xa3\xae\x02\xf2\x0c\x2b\x67\x34\xbc\x9b\xd2\x33\x26\x88\x60\xb9\x00\x56\xf1\xeb\x4c\x94\xf2\xcb\x09\x4d\xa1\x03\x42\x01\x4f\xa4\xa0\xa0\x50\x2e\xc7\x34\x57\x2c\x87\x50\xf2\xa9\x2c\xe8\xf4\x07\xf0\x5f\xc3\x63\x18\x8d\x87\x8c\xc6\x63\xd0\x4a\x41\x67\x98\x7d\x40\x29\x8b\x4a\x3e\xdd\x1a\xf0\x42\x25\x21\x55\xb1\xe4\x25\x9f\xbe\xa1\xf9\x01\xe6\x9a\x8b\x69\x6e\x72\xcd\xd9\x17\x47\x18\x36\x6b\xdf\xab\x38\x5a\xdd\x6c\x7b\x86\xcb\xf7\x66\xac\x02\xb8\x12\xf5\x20\x1e\x9b\xf8\xac\x92\x4f\x77\x26\xd3\x32\xc5\x84\x6b\xf8\xcb\xbc\xc8\xe3\x62\x3e\xc5\xd4\xb6\x4c\xff\xb6\x2f\x13\xf5\x22\x71\x1e\x16\x05\x78\xd8\x43\xbd\x49\xfd\xf0\x67\x4e\x13\x96\x6c\x63\x06\xfa\x0c\xfe\x30\x79\xe8\xcd\xeb\x77\xac\xa4\x89\xdb\x64\xa2\x1e\xb8\xcd\x0e\x55\xcc\xbd\x6c\x61\xa3\xee\x4b\x3e\x3d\xa0\x33\x08\x71\x98\xca\x7f\xcd\x43\xc4\x9d\x8b\x38\xf9\x08\x83\x73\xa6\xf8\xcb\xbc\x28\xf8\xa8\xc0\x78\xbc\xa9\xfa\xa9\x5f\xbd\xa7\x25\x33\x18\x94\x47\x89\x8f\xbd\x43\xc6\xce\x74\xd4\xfd\x99\xc5\x84\x7c\xac\x62\x46\xf1\x97\x79\x51\xd2\x0c\x93\xdc\x0b\xfc\x65\x5e\xcc\xc4\x14\x33\xd9\x08\xfc\xa5\x5f\x1c\xa5\x13\xf6\x61\xaa\xd2\x4d\x97\xe9\x84\xcd\xa6\x26\xdd\x74\xc9\xa7\xbf\xf0\x6c\x36\xb1\x23\x3c\x87\x3f\xfd\x31\x7e\xa4\x10\x29\xd4\x27\xad\x0b\xfc\x55\x89\x65\x90\x14\xfb\x26\x4b\xe3\xb3\xfd\x7c\x8f\xe7\x90\x9b\x12\xeb\x97\x6a\x6e\x2f\x37\x64\x47\x57\x00\x79\xc7\x07\x69\xc6\xc8\x21\x1d\xd2\x22\xb5\xce\x21\xa0\x85\x41\xd7\x9c\x6c\xae\x1c\x38\xe5\xc5\xce\x7a\x7c\xf3\x1c\x01\xe4\x3c\xc7\xf4\x98\xd8\x89\x39\x65\xbb\xaa\x68\xf4\x84\xd1\x5c\x90\x84\x65\x6c\x84\xe6\x5b\x00\xa2\xe5\x17\xa1\xcc\xb8\x08\x4b\xf6\x1a\x41\x99\xea\x0b\x5e\x9c\x51\x48\x3f\xa8\xbc\xc2\xe4\xf1\x3b\x1b\x91\x34\x3f\xe7\xd9\x39\x13\x52\xac\xa6\xf1\xd8\x2b\x00\x03\x90\x11\x90\x11\xbc\x38\x5a\x73\x30\xd8\x0c\xca\xb1\x3b\xba\x31\xa5\x1a\xfb\x6d\x96\x16\x67\x62\x22\xdf\xf1\x62\xd4\x1b\x64\x7c\xd4\xa3\x45\x3c\x4e\xcf\x99\xe8\xad\x3f\x59\x7b\xd2\x7b\xf2\x5d\x0f\x80\x9f\xc2\xdc\x4f\x13\x96\x81\xce\x0c\x21\xfd\xe7\x4c\x94\x50\x5c\x27\x2d\x95\x62\x14\x15\xc4\x38\x51\xe3\xde\xa4\xc5\xa6\x0b\x5d\xd5\x1b\x64\x9b\x92\xab\xea\xf3\x84\xe6\x73\x84\x27\xa5\x80\x33\xc6\xb0\xc2\x3a\x2f\x48\x5a\x46\x64\x8f\x97\x58\x27\x26\x05\x0d\x5c\xce\x94\x5c\x0d\x85\x6e\xa4\x28\x3d\x66\x38\x51\x33\xf1\x54\xac\x28\x59\x68\xc2\xcf\xb1\x5a\xb7\x31\xe3\xec\xe7\xd9\x5c\xe2\x1d\xb0\xaa\x9d\xee\x74\x85\x5d\x45\x0a\x82\x4c\xe8\x7c\xc0\x5e\x43\x86\x74\x89\x19\x35\x9f\x9a\xf6\xdd\x3f\x44\x04\x2b\x77\x51\xf4\xda\xde\x7f\xe7\x6a\x57\x29\x58\xec\x27\xf6\x60\x0e\x1e\xd7\x39\xfb\x5c\x82\xa5\xb0\x5b\x2f\xe1\x7e\x44\x47\x48\xb5\xc6\x16\x2d\x71\xfb\x13\xda\xa3\xcd\x87\xee\xbd\xe7\x9e\x79\x5a\x75\x87\x53\x5f\x3a\x56\xf8\x98\xe7\x65\x9a\xfb\x05\x29\x41\x76\x55\x20\x20\xa0\x45\x41\x3b\x56\x9f\x9f\x58\x2d\x80\x1e\x8a\x3c\xe3\xc0\xf8\x61\x21\x5b\xa7\x14\x50\x17\x28\x20\xae\xa3\x0e\x2c\xcd\xdb\x82\x31\x25\x6d\xcb\x36\xaa\xae\x3e\x96\xe8\x77\x89\x47\x8a\xdb\x54\x88\xd9\x04\x4c\xc5\x17\x40\x4a\x03\xe6\xc3\x9a\xcc\x4a\x0a\x1e\xc7\x1f\xb5\xb6\x36\x93\xf2\xfd\x5c\x59\x38\xec\x96\xd2\xbe\x85\x54\x98\xf8\x0e\xf9\x3f\x15\x5c\x34\x84\x21\xd9\x21\x5b\x97\xb9\xab\x8a\xbb\x07\xd6\x50\x4e\xc1\x97\x9c\x7c\x42\x96\x06\x69\x14\xc5\x0f\xf3\xdd\xed\x4f\xa8\x97\x90\x83\x92\x44\xfd\x09\xa6\x86\x4c\x50\x7c\xd2\xfd\x0a\x86\xaa\x84\xb7\xbc\xc0\x2f\xdb\x2e\xb9\xe8\x31\x58\xcb\xa9\x7f\x1f\xab\xae\x41\xb3\xf5\xcd\x77\x7d\x94\x70\x7f\x2c\x27\x99\xb3\xbc\xe4\xb5\xf9\x79\x2c\x3f\x38\x71\xaf\x9a\xae\xdb\xa3\xf9\xb6\x16\x05\x42\x70\x1f\x28\xf1\xb5\x36\x11\xf9\x51\xa7\xd1\xd5\xd0\x9d\x86\x36\xb1\xf9\x9e\x5e\xea\x0e\x68\x49\x33\xe8\x82\x0c\xab\xb2\x25\xef\x45\xc6\x4f\x5d\xdd\x8a\x20\x58\x5f\x99\x0d\x2d\xeb\x90\x0f\xc1\xc5\x56\xee\xef\x88\xec\xe6\x64\x77\x67\x6d\x4d\x7f\xeb\x02\x75\x3f\x07\x6f\xc1\x57\xba\x26\xdb\xf7\xa8\xe7\x07\x23\x00\x52\x96\xad\x7b\x80\xb7\xca\xd2\x05\x24\xe4\x1d\xeb\x22\x2d\xc7\x8a\x0e\x1d\x38\xb3\xbc\x4c\xc1\x41\x70\x4c\x05\x1a\x9d\x20\xa6\x01\x5c\x1f\x13\x32\xc8\xe4\x95\x37\x21\x74\x44\xd3\x3c\x72\x41\x5e\x7f\xb5\x4a\x85\x98\x31\xd1\x7b\xf1\xf2\xe9\xda\x5f\xe1\x77\xcc\x27\x90\x7d\x7d\xfd\xf9\xb3\x6f\x5f\x3e\x7b\xfe\xfc\xa9\x81\x07\xc5\x85\x69\x7e\xc8\x40\x3f\xaa\xa7\xbc\x49\x4a\x3a\xaa\xd6\xa2\xbb\xbc\xb4\xeb\x01\xaf\x5a\x1b\xde\xbe\xaf\x81\xf1\x19\x80\xf0\xde\x3d\x58\x0b\x12\x7f\x68\x03\x5a\xba\x09\x52\x85\x72\xc8\xae\x90\x66\x73\x57\x60\x85\xa8\xf5\xb7\x90\x46\xaf\x37\x56\x5f\x5e\x92\xe0\x07\x01\x9b\xb4\xe7\x41\xbb\xc7\xf9\x74\x51\xcf\xc6\x3a\xed\x7d\xf5\x91\x19\x2b\x23\x58\x34\x95\xce\x20\x9b\x6b\x61\x00\xf5\xc2\x24\x99\x81\x3a\x43\xae\x7e\xea\x46\xb7\x7d\x64\x64\x90\xd1\xf8\x0c\x2e\x05\xa9\x52\x31\xb8\x97\x83\xaa\x43\x36\x34\x54\xa6\x54\xc9\xa1\x99\xd2\x6f\xa5\x39\x39\x3c\x7c\x1f\x55\x67\xb0\x64\x94\x60\xfd\x88\x72\x8f\x8f\x10\xcf\x01\x22\x28\x66\xcc\x09\x51\xf0\x49\x52\x9f\xd2\x2d\x9f\xf6\x16\x28\x1b\xf5\x28\x16\xd2\x20\x59\xfa\x36\xae\xe7\xd4\x48\x57\xcd\x87\x7e\xe5\x88\xb0\x5a\x79\x97\x7a\x9b\x46\xeb\xf4\xd0\x8c\x40\x6d\xdf\x6c\x15\x8c\xc0\x09\xa6\xaa\x09\x42\x30\x08\x54\x0a\x54\x67\x00\x84\x4b\x2a\x57\x6e\xeb\x7e\x64\xe8\xc1\x82\xf3\xbc\x8e\xa5\x14\xe5\x86\x55\xa5\x39\x4d\xce\x59\x21\xf7\xa0\x13\x49\xe4\x46\x30\x90\xa3\x71\x2a\x2c\xb4\x81\x7c\x28\xc8\x0c\x4e\xed\x2c\xcd\x19\x2a\x50\x8d\xee\x49\x3b\x1e\x19\x13\x2d\xe8\x9a\x90\xe1\xa3\x6f\x78\xe0\xa8\x35\xe4\xb6\x14\x1a\x6b\xe5\x4f\xf1\xa4\xf7\x45\x3d\x17\x12\xbe\x3f\xa0\x73\x79\xc9\xeb\x92\x0b\x1a\x58\xdf\x45\xa2\x9e\x11\x59\x7f\x04\xa5\x5b\x18\x80\x2b\x12\xa6\x64\x93\x3c\xd9\x20\x29\x79\xe5\xf7\xad\x3c\xcf\xe4\x9b\xc7\x9b\x36\x46\xd1\x95\x22\x37\xfd\x2f\x8e\xd3\x93\x0d\xaf\x8d\x36\x14\x55\x5a\x91\xc7\x64\x6d\x39\x41\x70\xb1\x84\x63\xba\xb8\x4b\x11\xa7\x51\x0c\x31\xbd\x2d\xee\xa3\x2e\x7f\x2c\x3c\x3d\x16\x40\x5d\xbc\xb3\x75\xbf\xbf\xa8\x90\xaa\x90\x3c\xb5\xe4\xd6\xaf\x8e\x21\xe0\x1c\x2e\x2f\xa3\x25\x5b\x0a\xde\xe2\x23\xb0\x61\xb8\x4b\xef\xaf\x06\x7c\xfd\xef\xe3\x48\xfe\x8a\x2c\x42\x5a\x23\x2b\xf2\x94\xd3\xbe\xa3\x4e\xd3\x6d\x13\x55\xd5\xc6\xdf\xcc\xb0\x9c\x8f\xda\xe6\x20\x05\x3d\x73\x49\x32\x6a\x6e\x89\xab\x72\xcc\xd2\xc2\xc6\x9d\x28\xc8\x5d\xc2\x3e\xc7\x6c\x5a\xea\xba\xaa\x92\x75\x78\x5a\x4b\xf4\x45\xfb\x1a\x35\xab\x55\x16\x6b\x94\xe8\x27\xbe\x05\xa0\x3a\x29\xed\xbc\x7c\x8d\x9d\x40\x13\x6f\x05\xd8\x48\xf2\x0f\xb9\xf6\x22\x8d\x0d\x48\x40\x6d\x47\xfb\x90\xde\x00\xb8\x7b\xf1\x0a\xf1\x03\xd0\x82\x2f\xf2\x62\xdd\xb0\xb4\x77\x88\xd4\x8e\xfe\x43\x90\x89\x60\xc0\x08\x6a\x98\x06\x73\xbd\x30\x66\x5c\xaf\xad\x06\xe5\x82\xe9\x68\x0e\x0b\x0c\xca\x28\x91\x57\x87\xbf\xfc\xed\x7b\xb9\xaf\x5e\x4d\xb6\x8e\x7e\xfc\xbe\x1a\x46\x15\x1c\xf1\xe5\x25\x31\x35\x9f\xc1\x6c\xe7\xa5\x30\xe8\x92\xd6\xab\x6f\x04\xe9\x81\xf5\x08\x75\x43\xb3\xe9\x54\x05\x3b\x49\x1c\x45\x64\x2b\xbb\xa0\x73\x01\x56\x24\x1b\x07\x05\xd6\x11\xa0\x3d\x15\x73\xa5\xa3\x9f\xd1\xfe\xd7\x09\xc6\x13\xa9\x6b\x20\x98\xab\x5a\x9e\x58\xf3\x46\x11\xb3\xdc\x97\xf0\x9a\x9c\xa7\x94\x38\x86\x18\xc1\x49\x5a\x0a\x72\x7f\x4a\x0b\xc1\x8a\xd5\x34\x17\x92\x0d\x24\xf7\xc9\x30\xa3\x23\xe2\x6e\x79\x55\x44\x1a\xc4\x4c\xa8\x3f\xec\x04\x94\xb1\xcf\x2c\x9e\x95\xcc\x59\xe4\x24\x3d\x27\x9b\x64\x91\xe5\xa9\x95\xa4\xe7\x36\xbe\x37\x49\xcf\x3d\xf3\x50\xeb\x95\xb2\xbe\xbd\x02\x3c\xf4\xd4\x5f\xad\x0d\x39\x14\x26\xb2\x34\x2f\x57\x55\x75\x51\x48\x92\x68\xc7\x79\xa4\xe2\x45\x47\x33\x5a\xd0\xbc\x54\xfa\xb2\x79\xca\x32\xb0\x23\x22\x16\x74\x20\x98\x33\xe2\x61\x5a\x88\xf2\xcd\x38\xcd\x12\xb2\x09\xc3\xb1\x0f\xcc\x20\xcd\x0e\x54\x4d\x90\xe3\x42\x9b\xb6\x6d\x5e\x3f\x02\x95\x4c\x8e\xe5\xc0\x53\xd1\x70\x6d\xef\xf5\xc8\x83\xb7\x19\xbf\xd8\x95\x57\x53\xf2\xc9\x43\x97\xa9\x8a\x3d\x50\x07\x82\xd2\xe5\x7c\x64\x03\x62\xc8\x52\x84\xc6\xb9\x68\x0d\x70\x87\x7d\x81\x6a\x9a\x66\x70\x57\x8d\x47\xd2\xa1\x36\xc2\xc2\x8b\x41\x41\xf3\x78\xec\x1e\x23\x48\xe7\x9f\x0c\xa4\xcb\x4b\xe2\x14\xde\xa6\x03\x7e\x6e\x1c\x4f\x65\x73\x4a\xde\xa6\x05\x1b\xf2\xcf\x64\x30\x1b\x45\x6e\x37\x5f\x69\x35\x7d\xf1\xed\x77\x2f\x9c\xad\x9d\x27\x0d\x60\x06\xb3\xd1\x3f\xd2\x2c\xa3\xd1\x84\xe3\xbf\xbc\x18\xf5\xc4\x98\x5f\x9c\xca\x81\xc4\xa3\xf4\x75\x9a\x6c\xae\xad\xbf\x7c\xb1\xfe\xec\xc9\xd7\xa0\xd4\x3d\xa9\x5c\x24\x2e\x0b\x64\xef\xb0\xed\x5b\x56\x1d\xb6\xbb\x42\x1c\x35\xe7\x92\xdc\xd7\x84\xda\x04\xd8\xd8\xc3\x87\xf5\x84\x42\x3a\x4a\x0d\xd3\xe6\xd8\x51\x63\x0e\x90\xd6\xb1\x52\x4d\xca\xce\x94\xcb\xb4\x6a\x70\x82\x41\x8c\xd7\x64\x28\x72\xb3\xf1\x38\x2e\xd7\x6a\x9a\xd5\x38\x46\xaf\xcd\xb1\x6c\x52\x8f\xe3\x0d\x65\x28\x28\xe9\x08\x63\x46\xd2\x8a\x13\xb4\xf6\x3d\x55\xde\xdb\x7e\xb4\xe9\x84\xa9\x78\x3f\x94\x52\x08\x55\x19\x2e\x9c\x00\x53\xb0\x58\x01\xd7\x84\x58\x60\x10\x7c\x30\xc8\x35\x77\x78\x3c\xd6\x59\xa8\xf0\x6d\x23\x4c\xea\xa5\x54\xd6\x53\xf7\x68\xaf\x4b\x36\x52\xea\xde\xe3\x09\x93\xa2\x0d\xb8\xf0\x5d\x6b\x8d\xfd\x4a\x49\x23\xf2\xfb\x83\xde\x3a\x4d\x5a\x7e\xcf\x37\xda\x15\xd7\x40\xe1\x5f\xd0\x8b\x83\x66\x01\xcc\xb5\xc5\x2f\x2b\x0c\xb8\x50\x01\x9d\x4d\xfe\xdc\x9e\x3b\x78\xe0\xbb\x86\xa0\x19\xb5\x19\xee\x55\x63\x3b\x1e\x3e\x74\x96\x27\x12\xf2\xb1\x44\x65\xb3\x1f\xd5\x37\xc2\x9e\xf9\xd0\x1c\x23\x8a\x3e\xf8\x0f\x90\x6e\x14\x71\xd1\x1c\x29\x48\x6b\x4f\x41\xb8\x2e\x39\xba\xa5\x10\x31\x1b\x94\xd9\x5c\x92\x52\x73\x24\x4d\x1b\x32\xce\xb4\xb6\x2c\xa1\xba\x67\x6b\x35\x5a\xc5\x0d\x74\x54\x94\x68\xee\xdb\xef\xe8\x19\x43\x79\xc9\xd8\x1d\x40\xc8\x4a\xc5\x3b\x3e\xcb\x41\xca\x62\x43\x5e\x30\x79\x60\xa2\x11\x6e\xae\xc4\x62\xc1\x94\x85\x50\x7b\xff\xc0\x41\x20\xfb\x11\x17\x69\x19\x8f\x21\x6f\x97\xc6\x1b\x6c\x92\x56\x0a\x45\xb0\x5b\x7d\xe7\x11\x32\x17\xf5\x08\x52\xc1\x7a\x56\xf8\x76\x4b\x19\x91\x5b\x5d\x34\x20\xb7\x5c\xeb\x92\x99\xf3\x54\xc5\x30\xea\x95\xd7\xcf\x01\xa3\x1b\x4e\x77\x90\xe9\xd2\x1b\x00\x9d\x25\x29\x37\xfd\x5b\x21\xca\x18\xd8\xb4\x1b\x80\xeb\x6f\xa0\x5a\x1b\x6d\x04\x26\x3a\x4a\x73\xd7\x4d\xa0\xaa\xb1\x73\x5e\x55\x55\x80\xf0\x79\xc7\x57\xd6\xd5\x30\x01\x8d\xba\x6e\x0f\xc7\xf0\xe8\x24\x88\x91\xba\xe9\x66\x69\x1c\xa9\x84\xf9\x0b\x97\x64\x07\x5d\x05\x8c\xcf\xc0\xad\x16\x25\x9d\x8c\xbc\x25\x81\x62\x42\xb7\xef\xff\xf7\xa6\x25\x2c\x94\xba\xa8\xb3\xf7\x0c\x92\x89\x43\x11\x01\xf8\xb1\xec\x28\x0f\x67\x03\xc8\xd0\x4d\x5a\x42\xff\xba\xcd\x48\x55\x54\xe3\xe2\xc1\x1e\xf1\x11\x94\xec\x21\xad\x52\xff\xba\xd5\xa2\xe6\xd3\x99\xdd\xd7\x69\x9e\x96\x1f\x0b\x2a\xcf\xcb\xc3\x92\x56\x54\x30\x15\x7e\x6d\x3b\x19\xb1\xf2\x47\x2e\xd0\x16\xbb\xf8\x8b\xe0\x8c\x94\xa2\x5b\x4e\x29\x35\x3f\x03\x73\xea\xf5\xc8\x5b\xf0\x67\xcc\xcb\x82\x67\x19\x4b\x2c\x5b\x15\x92\x23\x52\xbc\xba\x69\x63\x3c\x2a\xc1\x95\xba\x26\xd3\xba\x70\x0b\xab\xe4\x44\x7b\xef\x44\x64\x47\x45\x67\x95\x60\x5d\x80\x54\x51\x86\xb5\x68\x21\x78\x59\xad\x7a\x4b\x83\xb5\xcc\xbe\x86\x76\x3e\xc5\x64\xd6\xe6\xaa\x63\xcf\xcb\x6b\x50\x18\x42\x7a\xe5\xac\xaf\x7d\x53\xe7\x1d\x90\x9c\xb3\x71\xd9\xaf\x83\x17\x1c\xc3\xfa\x9f\x4b\xbf\xd4\xd2\x1b\x1b\x65\x23\xf6\xaf\xc1\x64\x10\xfb\x4f\xff\xc4\xfe\x35\xd8\x4f\xd8\x90\xce\xb2\xb2\xbf\x80\x43\x82\xcc\x45\x85\x60\x45\x09\xf9\x0f\x70\x3b\x82\xb0\xaa\x14\x97\x8e\x29\x60\x85\xdc\xd6\xbb\x66\xba\xc0\xb3\x06\xe1\x37\x4a\x68\x1e\xd7\x0e\x48\x89\x56\x40\xb4\xb9\xba\x30\xda\x6f\x96\x4f\x94\xc4\xc8\x0b\x92\x70\x90\x14\xe3\x8c\xd1\xdc\x02\x9b\x4d\x49\xce\x62\x26\x04\x2d\xe6\x2a\x0d\x12\x38\x39\x9d\xb3\x02\x2a\xa9\x48\x6a\x8a\xcf\x94\x98\x39\xe1\x85\xc9\x30\x0a\xcf\xdb\xa1\xe3\x88\x8b\x12\x04\x55\x45\xe7\x37\x64\x57\xb5\x2d\xf3\xef\x37\xe3\xeb\x36\xe8\x75\x27\x44\x0d\xde\x2d\x59\x7e\x0d\xde\x35\x4c\xa7\x79\x23\xd5\x54\x69\x3c\x7f\x83\xae\x69\x8d\x36\x6e\xb3\x7c\x47\x2a\xdc\xb4\x24\x13\x3a\x07\xa5\xe5\x80\x11\x61\xdc\x0c\x0f\x7f\xf9\x5b\x97\xbc\xa3\xe5\xf8\xdd\xcf\x72\xed\x2a\x71\x03\xd6\xcf\xe4\x5a\x17\xcb\xc0\x02\x5d\x55\x27\x76\xa5\x3c\x98\xdf\xd0\x2c\x9e\x65\x5a\x41\x9b\xa4\xc3\x21\x19\xb0\xf2\x82\x69\xb7\x9c\x0b\xae\xbc\xc0\x44\x64\x6f\xe0\xb2\xd9\xe2\xbb\x77\x46\x45\xf9\xde\xdc\xbf\x73\xf6\xd9\xf9\xab\xf9\x36\x7e\x83\xeb\xb4\x0b\xd2\xaa\xa5\x20\x27\x8b\x6b\x21\x25\x9b\x36\x8b\x2e\x64\xfe\xa5\xea\x08\x31\xf6\x0b\xed\x56\xb7\xf8\x8e\xe8\x71\x20\x03\x64\x91\x34\xe8\x62\xc0\x2c\x83\xe9\x6d\xd1\x97\xb5\xa9\xc9\xff\x55\x67\x75\x7c\xb2\xec\x5e\x6a\x1a\x6d\x65\xd9\x6e\x34\xde\x80\x8b\xd0\x6d\x46\x5c\xd9\xad\x8d\x23\x5e\xbf\xc5\x88\xd7\xef\x74\xc4\x35\x1e\xdd\x38\xe6\xa7\xb7\x18\xf3\xd3\x3b\x1a\x73\x85\x87\xb9\x63\x75\x07\x14\x1a\x8f\xdb\xe9\x46\x9d\x07\x1a\x50\x86\x0f\xfa\xbe\x3e\x01\x6f\xa0\x7f\x63\x96\xd9\x28\x2f\x39\x9e\xc3\xbe\xcc\xe4\xb8\x78\x6c\x98\x84\xfe\xf3\x8c\x61\x1e\x19\xe7\x81\x72\x48\x35\xfc\x4a\xe9\x71\x1c\x27\x63\x83\x6a\xd7\xc9\xf8\x5a\x1f\x63\x72\x79\x49\xee\xd9\x55\x5a\xd0\xca\x34\x32\x0e\xc6\x64\xb3\xea\x5b\x10\xf2\x53\xbe\xc6\xef\x44\x73\x5d\x70\x3a\x51\x04\x17\xf2\x63\x56\x13\x36\xd8\xd1\x53\x86\xef\xaa\x6a\x2b\xf3\xa2\x3a\x21\xf3\x79\x45\x71\x85\x49\xd1\x1c\x44\xfb\xaf\x49\x75\x11\xb0\xfa\x81\xfe\xdf\xd5\x4a\xb8\xe1\xb1\xe9\xee\x84\xf8\x4e\x97\xbe\x9e\xeb\xc6\x3e\x34\x55\xa7\xc5\xba\x27\x8c\x72\x50\x8c\x8c\xad\x51\x05\x06\x62\xee\x0b\xa6\x9c\xf3\xc1\xab\x16\x43\x38\x52\x31\xa9\x39\x03\xfe\x2b\x3b\x52\xe2\xec\x76\xd1\xc2\x9b\xb7\x4a\x08\xca\x20\xc6\xeb\x4b\x78\xd9\x5f\xee\xc2\xc1\xd1\xb1\xdb\x52\x4c\x80\x4b\x33\xac\x28\x40\x76\x87\x20\x46\x1b\xed\xab\x1e\x82\x13\x0c\x81\xb7\x36\xe7\xda\x37\xa6\x98\xcc\xfd\x7e\x8c\xda\xf2\xfb\x64\x98\x0e\x58\xa1\x0b\xcd\x4a\x3e\x21\x8c\x19\x55\x70\x03\x8b\x2a\x9f\x50\xef\x06\x89\xed\x50\xd2\xaf\xd8\x8d\x81\xb2\xbd\x53\xc0\x25\xed\xe6\xe3\xc1\xa3\xcc\x2f\xfe\xdd\x97\x66\x19\xe1\xe0\x72\x8a\xae\x31\x89\x76\xe6\x49\x71\xd2\x34\x49\x9c\x34\x94\xbf\xcd\xd8\x0c\x53\x04\xe9\x6c\x3e\x0a\x03\x8c\x5c\x8c\xd3\x92\xa1\x2b\xab\xf2\x7e\x85\xb9\x91\xe9\x98\x0a\xe3\xfd\xa3\x67\xd2\xae\x0e\xd6\xff\xfb\xf2\x92\x1c\x9f\x74\x30\xfe\xdd\xfa\x08\x4a\xf6\xe4\x9a\x11\xea\x7c\xb3\x16\x9c\xb1\x64\x60\x85\x2b\x2e\xba\x7c\xcb\xa9\xa7\x12\x60\x99\x35\x6f\xfd\xe5\x42\x41\x3c\x0f\x6e\xb9\x29\x4c\xcf\xfe\x0b\x93\x1c\xdc\x8e\xec\x0e\x78\xf4\xff\x86\x20\x11\x7d\x6c\x54\x67\x06\xb9\x92\x05\x53\xb3\xc1\x10\x12\xdd\xee\x93\xc9\x0b\x24\x9f\xea\x4e\x3e\xd9\x71\x84\x8f\xac\x3a\xf2\xdc\xce\x9b\x8f\x2c\xb9\xae\x96\x56\xe0\xe4\xd6\x7f\x2c\x38\xe7\xaa\x27\xd9\xb5\x47\xdd\x35\x87\x9d\x7f\xdc\x2d\x7b\xe0\xb9\x5f\x5d\x79\xc8\x45\xd6\xa5\xb0\x0b\x24\x82\x11\x85\x89\x52\x3d\x58\x6c\x2f\xc2\x6b\x98\x28\x5d\x72\x5d\x8c\x57\xdd\x89\x3b\x03\x48\x16\xae\x83\x6d\xec\xf3\x7f\x1e\x42\x03\x83\x59\x8c\xe1\x9a\x73\xe9\x1d\x84\x42\x5d\x3b\xe1\xc5\x27\x0e\x59\x78\xea\x54\xb1\xe1\xbb\x49\xfb\xbc\xdd\x1b\x41\xc8\xf1\xbf\x2a\x38\x2b\xec\x2d\x15\x37\xf2\x7b\x87\x68\xe9\xd3\x43\x7d\x6b\xd8\xb5\x3d\x34\xbe\x3e\xbc\x4b\x73\x13\xf5\x7e\xd3\x86\x75\x79\xeb\xf0\x35\xe7\xa9\x89\xc0\xf1\xa2\xc4\x16\x13\x1c\xde\xd4\x76\x9d\x34\x6c\x25\xe7\x04\x75\x4a\x3a\x4a\x14\x59\xb9\x4d\xe0\xa6\x33\x36\xba\x70\xb4\xe3\x9f\x3e\x0a\xa2\x65\xd6\x31\x1c\xa3\x66\xd0\xed\x6e\x71\x60\xaf\x8b\xa2\xd7\xb4\x3f\x65\x63\x1c\x93\x8b\xdf\x5b\x61\xf7\xe0\x5f\x34\xbe\xe9\x77\x8b\x0e\x42\xbf\x66\x46\x47\x10\xd1\x8d\x82\x34\xca\x8f\x52\xa2\x3d\x07\x6d\x23\x9f\x8d\xc6\x9a\x40\xa0\xc4\x17\xc8\x8a\x92\x20\xe6\xac\xf4\xb9\xd3\xbf\x63\xa0\x51\x88\x71\x7a\x92\x9c\x4b\xab\x55\x65\xc8\x1d\x5d\x4c\x9a\xae\x26\x68\x1e\xba\xe1\xd5\x64\x89\xcb\xc9\x57\x5f\x40\xf2\xb9\xba\x80\x98\x38\x37\x6b\x79\x0b\xdc\x3e\xc0\xd1\xb2\x1c\xb3\x9c\x5c\x38\x37\x90\x61\x9a\xc9\xe9\xa4\x25\xe1\x33\x37\x3a\xde\xde\x4a\x54\x14\x9e\xbd\x99\xdc\xea\x2e\x12\x8a\x57\xd2\x35\x4a\xea\x87\xe9\x0d\xba\x00\x71\x3d\x70\x20\x5e\x59\x77\x3b\xef\x63\x9d\x9e\x64\x6b\x3a\xcd\xe6\x46\xb1\x1f\x55\x23\xa7\x1a\x55\xf8\x95\xc0\xa9\x6b\x34\xfa\xd6\x93\x2e\x18\x20\xd5\xec\x4a\x57\x53\x86\xde\xdc\x1b\xaf\xa6\x13\x0d\xcc\x9a\xfc\x9e\x81\x62\x1b\x9e\xe3\xda\x4e\x6e\xbd\xd6\xa8\x46\x33\xee\x27\x11\x8f\x99\x64\xa6\x89\x24\x08\xeb\xb0\x66\x36\xb4\xae\x10\xd0\xeb\x69\xf9\x38\xba\x91\x4d\xf4\x83\xde\x85\x8c\x5c\xa0\x91\x8b\xa8\x14\x16\xd0\x54\x90\x47\x74\x58\xb2\xe2\x91\x8d\xe5\x41\xfb\x15\xf2\x96\x31\x15\x5e\x4c\xc2\x58\x42\xc8\x09\x7c\xa2\xe5\x48\x0f\x7f\x9f\x22\xb2\x2f\x37\xe8\x45\xaa\x22\x06\x9e\x63\x3f\xda\x7a\x93\xf2\xdc\x71\xdc\x2f\xa8\x6c\xa6\xbc\x14\xb1\xd4\xdb\xb4\x40\xff\x34\xbc\x4d\x5e\xe8\x34\xf5\x05\x9f\xa8\x4c\x57\x54\x88\x74\x94\x33\xa3\x1e\xc0\x41\x84\x4c\xaa\x15\x22\x58\x71\x8f\x1c\x4c\x5f\x0b\xa6\x52\x7d\x3d\xd5\xe7\xcb\x24\x85\x42\x2e\x3a\xff\x19\xc2\xef\x12\x31\x8b\xc7\x50\x3d\xc6\xc2\x79\x4f\x93\x94\x93\x51\xc1\x67\x53\x22\xc6\xe9\xb0\x34\x4c\x43\x02\x66\x89\x53\x00\x2a\x47\xb6\x95\xd3\x09\x4b\x48\x01\xdf\x01\x5e\xfc\x59\x40\xac\xd1\xee\x10\xed\xf7\x49\x48\xfb\x7c\xbd\xc5\xc1\xc3\xc7\x32\x06\x99\xeb\xcc\x2e\xbd\x1e\x79\x85\x8f\xbe\xf7\x50\x02\xcc\x1f\x7c\x41\x79\x1c\xcf\x0a\x45\x14\xaf\xd0\xcc\xf4\x7d\x55\x94\x83\xac\x1f\x31\xcf\xe3\x34\x4b\x81\x0c\xd4\xf3\x29\x17\xe5\x87\x65\x97\xb0\x32\x60\x3f\xd6\x4a\xee\x6a\x4c\xb2\xe8\x17\xae\x58\xe4\x01\x5c\x89\x4b\x5a\xc6\x08\x59\x90\xa6\xf4\xe4\x8e\x1f\xc5\xf1\x22\x71\xeb\x04\x03\x73\xbc\x1c\x90\xb7\x70\x36\xfe\xd3\xd1\xf8\x5f\xd5\xd1\xf8\x8f\xf7\x2d\xfe\xd3\x87\x38\x60\xa0\xbb\x6b\x5f\xe1\x7f\x71\x9f\xe0\x7f\x3d\xdf\xdf\xdf\xd3\xc7\xf7\x4e\x7d\x79\xff\x74\x10\xbc\xb5\x67\xee\x5d\x7b\xd9\xfe\xb9\x24\x77\xe5\x31\xfb\xbf\x1e\x93\x0b\x1c\x35\xac\x44\xe8\xfb\x69\x58\xa1\x8f\x79\x59\xc3\xf7\x54\xca\x6e\x79\x43\x39\x64\xa5\x5b\x17\x9e\xba\x99\xc5\x1d\xa9\xc9\x3e\xc7\xb6\xa1\xec\x20\x4e\xb1\x0c\x93\x1a\xe4\xf1\xe3\x8a\xe6\x19\xeb\xa1\xda\xa6\xc7\xe9\x49\xd4\x54\xa8\xde\xca\x20\xd5\xea\xa7\xbd\x1e\xf9\x61\x96\x66\xe5\x2a\x26\x04\xf2\x4b\xc7\x19\x4d\x08\x4b\xcc\x07\x8a\x73\xd3\x92\xae\x42\x5c\xab\xc4\xbf\xa1\xc5\x0a\xc5\xaa\x0e\xde\x58\x6a\x71\xb0\xa2\xeb\x69\x9b\xe2\x79\x75\xa5\x31\xe4\x02\xc4\x42\xeb\x58\xff\x8a\xe7\x2e\xe9\x95\x74\xe4\x38\xf1\x28\x41\x47\xde\x4c\x16\x8d\x07\x9b\xa9\x9b\xd9\xf5\x0d\x91\x6d\x2d\x6e\x59\xf1\x9f\x52\x53\xd8\xf5\x8a\x91\xea\x9c\x63\xbc\x48\x47\x69\x4e\x33\x58\xbf\xc8\xff\xe2\xab\xa3\x8a\xd7\x9e\xbc\x78\xf9\xc2\x05\x16\xa0\xd2\x88\x26\x49\xbb\x4e\x2d\x4d\x61\x9f\xcd\xae\x92\xe1\x1c\x87\x85\xa7\xed\x51\xca\x4c\xfd\xf0\x4e\x32\x1c\x9a\x3b\xd5\xe2\x04\x87\x41\x5f\x18\xc9\xb3\x4a\xb7\x46\x85\xbe\x95\x82\x4c\x0f\x39\xc1\x19\xe6\x6b\x13\xa5\x9b\x41\xae\x9a\x54\x04\x4d\x18\x58\x0f\x99\x26\x3a\x6d\xbc\x4a\x89\x00\x79\xc7\x05\x19\xa7\x49\xc2\x54\x41\xc6\x0b\x66\x72\x97\xc3\x25\xc8\xe1\x7c\x6e\x27\x3b\xd1\x28\x22\xf7\x87\x9c\xdf\xc7\x14\x75\xd8\xc1\xfd\xe1\x2b\x31\xa5\xf9\xf7\x9c\xbf\xea\xc1\x8f\xfb\x60\x6f\x86\x7e\xc0\x99\xdb\x42\x13\xb4\x4c\xc5\x10\xec\x7a\xb3\x82\x14\xec\xb7\x59\x5a\x20\xbb\x21\xfb\xfe\x03\x5d\xf9\xbd\xe4\x72\xf5\x92\x59\xcc\xc8\x94\x15\x43\x16\x3b\x1e\x25\x26\xef\xba\xc3\x87\xc8\x6e\xc2\xb0\xaa\xae\x49\xe6\x32\x55\xe5\x2b\x89\x28\x8b\x59\x0c\xb5\xd4\xe5\xf8\xd2\xb2\xe5\x60\x8c\x9f\xe9\xee\x90\xb3\x93\xf3\x14\xea\x37\x9b\x95\x30\x9e\xe9\x2c\x07\x0d\xbf\x6c\x99\x27\x69\x2c\xef\x22\x17\x63\xea\x0c\x0b\xec\x00\x36\x37\x2b\xde\xb2\x72\x9e\x30\x61\x4d\x4b\x17\x69\xc1\x12\x32\x9b\x92\x92\x3b\xe1\xfa\xc8\x4d\xa0\x4e\xa6\x7b\xbe\x4c\x90\xaf\xd0\x9c\x50\x82\x25\x87\x60\x59\xf6\x78\xc2\x54\x7d\x60\x49\x25\x35\x38\x2a\xbb\x87\x4a\xaf\xee\xb0\x76\x9b\x5f\x01\xf2\x4a\xff\xa2\xb5\x3e\x8a\xc0\x5e\x3b\x7a\xfe\x65\xb3\x24\x42\xc9\x09\xdb\x83\x9b\xdc\xb0\xc9\x1e\xe0\x9b\x40\xee\x35\x69\x29\xaa\x46\xd9\x60\x59\x9d\x86\xbe\x83\x86\x90\x05\x96\x5b\xb2\x49\x8e\xf5\xbe\xb4\xdf\x9e\x34\xda\x0f\x6f\x92\x31\xf0\x1a\x0c\xf9\x36\xb5\x7f\x27\x34\x79\x23\x0f\xe1\x6a\x85\xfc\x99\xbb\x6f\x99\x84\x58\xce\x39\xf0\x8b\x92\x35\xac\x91\xcb\xf1\x5c\x8b\x79\x51\x30\x31\xe5\x79\xa2\x8c\x47\x69\x61\x4a\xfa\xab\x92\x9f\x6e\x36\x16\xa7\xe2\x8e\x6b\xd5\xd7\x16\xa9\xdd\x7c\xc8\x5d\x8b\xfd\x32\x04\xd6\xeb\x91\x6d\x74\x87\x42\x35\xb1\xaa\x56\x91\x8f\x22\xf2\x11\x44\x68\x90\x85\x40\xd3\x94\x65\x8a\x01\x6a\xad\x79\x54\xdf\x42\xbf\x9b\xa1\x98\x5c\x5e\x3a\x7a\xa3\x1b\x49\x77\x5f\x23\xdb\xb9\xc3\x52\x02\x5e\x75\xb4\x46\xa0\xab\xbd\x30\x02\x5c\x05\xd1\xc6\xbe\x7d\x2b\x1f\x10\x5c\xf3\x82\x5e\x5c\xeb\x04\x72\x79\x29\x77\x74\xdf\xf3\x8a\xb2\x64\xa4\x72\x0a\x39\x7c\xc4\x2b\x30\x61\x9b\x6b\x82\x54\x1f\x78\xd5\x4b\xaa\xf7\xbe\x8a\x93\x86\x9c\x9f\xf7\xb9\xdc\xbb\xb6\xfb\xe0\xde\x3d\xf0\x0a\x6c\x39\xce\x37\xe6\xb3\xae\x37\xa4\xc5\x59\x60\x17\xf8\x18\xda\xdc\x42\x6f\xd3\xcf\xef\x18\x59\xd5\xc7\xec\x80\x91\x34\x1f\x32\xcc\xa8\x8b\xb2\x8b\xf1\x88\xb1\x22\x6f\x40\xe0\x3d\x6e\xa1\x77\x6a\xeb\xa4\x5d\x65\x0f\x3e\x2a\xb5\xeb\x39\xa6\x16\xd9\xd6\xc5\x4f\x31\xc1\x8c\xcd\x87\x18\x60\x54\xc2\x2b\xd2\xe5\x2c\xde\xc8\xad\xac\xad\xea\x8c\x36\xac\x04\xf6\x6e\x97\xe2\x97\x6a\xa5\xfc\x25\xd7\x42\xa5\x67\xf4\xc0\x2e\x5e\x8d\xc5\x59\x0f\xff\x88\x05\xf1\xaf\xaa\x8d\x88\x1d\x7d\x4d\x6a\x55\x0f\xd9\xde\x71\x75\x27\x78\x5e\x2e\xed\x71\xa0\xce\x7a\x7d\xac\xd5\xa3\xd6\x3d\x41\x70\xf6\x07\xce\x93\xc0\xf9\x7d\xeb\xc5\x5a\x66\xb9\x74\xff\x91\x57\x96\xcc\x13\x6c\x1a\x57\xed\xe0\x26\x89\x5c\x49\xc8\x8f\xcc\xa4\x2b\x34\x36\xba\x70\x36\x41\x17\x8f\x7e\xeb\x05\xa9\xa7\xf0\x7f\x15\xe0\x0d\xd9\x05\xc1\xa6\x6f\x3f\xba\xba\x5d\x9f\xb7\x5c\xb5\xdb\x6e\xb3\x20\xa2\xff\xa8\x51\x35\xe2\xf1\x0e\x36\xbf\x05\xfb\x4f\x64\x03\xbe\x42\x05\x7b\xf8\x6a\xd4\xe2\x91\x51\xd7\xea\x88\xf4\x1f\x8c\x7c\x4f\x9e\x2c\x79\x89\xb9\xc5\xd2\x86\xcb\x26\x86\x06\xd5\xa9\xd8\x53\xff\x8c\xdc\xff\xdf\x1b\xb9\xef\x99\x7d\x82\x46\x25\xa5\x9e\x43\xf7\x20\x70\xd4\x53\x68\x02\x5c\xa0\x89\x5f\xdb\x15\x20\xc3\xe7\x98\x29\xff\x13\xe3\xfc\xe7\x6a\x89\xe4\x88\x09\x60\x4a\xde\xe2\x86\xbc\x88\x99\x72\x07\x4c\xd2\x73\x56\x8c\x94\x13\x91\xab\xda\xfa\x91\x5f\x48\x14\x75\x65\x6b\x47\x73\x05\xc3\x84\x11\xe1\x24\x6c\x75\x9c\xdf\x66\x29\xd4\xf9\xb3\xd9\x84\x4b\x55\xed\x47\xb7\xb5\x60\x94\xbe\xad\x60\x22\xc5\xd4\xfe\xca\x31\x71\x7b\xff\x1d\x11\xa5\xbc\x8b\x82\x3f\x97\x2a\x5e\x68\xba\x48\x54\xbc\xcc\x98\xd9\x55\x32\xe4\xf2\x86\x43\x51\x6d\x2c\xeb\x9e\x70\x74\x37\x52\xe5\x72\xea\x78\x8c\xea\x6b\xd3\x9c\xb5\xc0\xa8\x6c\xff\x9d\xa3\x70\x1b\x9d\x1e\x83\x4e\x42\x47\xec\x73\xa9\x12\x17\xee\xf1\x84\x75\x01\x71\x5e\x2d\x3e\x75\x0a\x40\x75\x0d\xd5\xca\xd1\xf0\xc9\xc3\x44\x3e\xde\xb0\x3d\x3b\xdf\xf8\xfd\x2a\x26\xfa\x21\x07\x15\xef\xc2\xbe\x11\xd1\x61\x7d\x53\x7d\x14\xea\xcb\xba\x3b\x94\x02\xb0\x8d\x91\x7a\x38\x67\x3a\xc8\x9c\x64\xd4\x4a\x8c\x82\xee\x41\xe3\xe9\xf6\xff\x3b\xd6\xbc\xad\x3a\x0b\x6d\xab\x1a\xc1\x78\x85\x51\xe7\xac\xd2\xad\x73\x9d\xc7\x9a\x50\x95\x32\x33\x87\x7f\xa3\x96\x1a\x33\x60\x62\xaf\x66\xfe\x32\xae\x5d\x1a\x59\xf5\x26\x37\xc0\x99\x5a\xad\x7f\x2f\x84\x99\xf2\x39\x90\x52\x1d\xaa\x70\x07\x91\xa7\xc8\xe8\x16\xf8\xda\x55\x11\x1a\x7a\x63\x85\x49\xcc\x66\x10\xfa\x27\xa1\xcd\x94\xc1\x6d\xa4\x30\xd8\x9c\x92\xab\x56\x49\x0d\xc7\x7e\x77\x18\x0a\x10\x54\x95\x01\x00\x6f\xd6\xb5\xdc\x5b\xad\x6a\x35\x19\xb5\xf6\x60\x35\x91\xb0\x55\xb9\x39\xb3\xe0\x42\xc9\x01\xe5\x98\xcd\x5b\x4a\x27\x57\x30\x30\xdd\x80\x2c\x91\x3a\xe2\x83\x2e\xa6\x5b\x3b\x6f\xde\xeb\xb4\xfd\x52\x18\x71\x22\x0c\x54\xc8\x4e\x4c\x73\x28\x5c\x89\x85\x6e\xd5\x40\x24\xfa\x60\x2c\x0e\x7c\x33\xa8\xa8\x71\x41\xff\x35\xe9\xc0\xee\x1f\x79\xa0\x55\xf7\x10\xa6\xbc\xfd\x1a\xb2\x28\x98\x28\x79\xc1\xac\x0a\xb5\xee\x9c\x54\xdd\x2e\x4b\x0a\xd3\x61\xc8\x81\x92\x18\x56\x76\x73\xb1\xda\x20\xb0\x36\x40\x7d\x7a\x23\xa8\x15\x4f\xa0\x06\x98\xeb\x4b\xc1\x04\x74\xca\x53\x1a\xbc\x47\xb7\xf7\xdf\x81\x33\xa8\xd1\x68\x91\xcd\x4a\x24\xf0\x97\x95\xbf\x78\x79\xac\xfb\xd5\xd2\x0c\x5d\xdd\x40\xa7\x18\xee\xd7\x52\x1c\x77\x57\xfe\x12\xca\x31\xdc\x6f\xc8\x3c\xdc\x5d\xf9\x8b\x9f\x10\xa9\x5f\x4b\x90\xd4\x5d\xf9\x4b\x35\xe4\xa2\x1f\x08\xc2\x50\x90\xea\xce\xcd\xfd\x46\xa7\xe7\xca\x27\x72\x12\xfd\x80\xf0\xd3\x5d\xf9\x4b\x48\x32\xe9\x37\xc8\x2b\xb6\x79\x93\x58\xd1\xbf\x5e\xee\x58\x00\xc4\xeb\xbb\xe1\x14\xb6\x9f\x37\x1c\x3b\xfd\x6b\x8f\xa5\x66\x10\xde\x00\xc2\x4c\xbb\xbb\xf2\x97\x30\xe5\xf6\x1b\x28\x7a\xe5\xaa\xb3\x81\x55\x81\x81\xa7\x26\x69\x21\x19\x77\x3a\x99\xf2\xa2\x14\x24\x4b\xe5\x0d\x90\x4f\xd8\xea\x94\xc6\x67\x74\xc4\x7a\xa2\x88\x7b\x8f\xc0\x8e\x32\xa0\x49\x44\xde\xa6\x9f\xc9\x84\x45\x40\xec\x0b\xcb\xaa\xbf\x20\x9b\x6a\x37\xb0\xc1\x6c\xe4\xb6\x8b\x16\x7d\xb7\x81\xfb\x48\xdb\x6b\xb6\xf7\xdf\xed\x31\x51\xa2\x3b\x7b\xad\xaa\xe6\x8a\x2a\x46\x02\x92\xbf\x0d\xe9\x20\xb1\x64\x91\x17\x54\x90\x8b\x22\x2d\x4b\x96\x93\x01\x15\xf2\xc2\x9a\x9b\xb3\xe5\xb9\xe4\x93\xe8\xfe\x3d\x65\x71\x7f\xc5\xab\x8b\x37\x2e\x27\x59\x24\x9f\x47\x17\x63\x5a\x5e\x8c\x20\xeb\xfd\x64\x96\x95\xe9\x14\x30\x32\xcf\x4b\xfa\x19\xaa\x9b\xfe\x75\x4c\xc5\x2a\xcd\x57\xd5\x2d\x62\x35\xcd\x57\x45\xcc\xa7\x0c\xe0\xad\x28\x03\x8f\x5c\x0b\x38\xb3\x4c\x15\x88\x18\x3d\x37\xb2\x8c\x28\x2f\x37\x92\xe3\x24\xbb\x24\x87\x5b\x35\x13\x70\x59\x2c\xe6\xf2\x20\x68\x53\xa1\xbd\x19\xa0\x96\x6c\xa9\xa2\x55\xe5\xe0\xc8\x14\x2e\x27\x31\xcd\xc8\x80\xe5\x6c\x98\xea\x8b\x98\x00\xc7\x8a\xf3\x34\x61\xa2\xb3\xa1\x73\x58\x74\xb1\xb2\x47\x91\x13\x9e\x67\xaa\x94\x2a\x94\xa3\xa7\x82\x09\x72\x81\x85\xe2\x21\x8d\x41\x21\x58\x81\x4e\x20\xa3\xf4\x9c\x11\x8a\x8f\x48\x59\x30\x8c\x57\x62\x60\xfe\x83\x2b\x2c\x0c\x03\x56\x7a\x45\x05\xc8\x96\x50\x22\x39\x82\xfb\x34\xfb\x4c\x27\xd3\x8c\x75\xc9\xab\xc1\xf7\xaf\x92\xf4\xfc\xfb\x57\x3d\xfc\xef\x00\xf2\xcd\xeb\xf9\x0f\x66\xce\xbd\x56\x8e\x50\xd5\x79\x55\x35\x10\x52\xe5\x6a\x82\xc3\x50\x36\xd2\xb8\xcc\xe6\x1b\xf8\x15\x4e\x4a\x4e\x45\x59\x2c\x61\x42\x40\xcc\x12\xb3\x60\xf6\xeb\xf5\xc8\xab\xe9\xf7\x58\x32\xc4\x4e\x75\xc0\x46\x69\x0e\xe1\x12\x3a\xd2\x89\xc5\x3c\x4f\xf4\xbd\x50\x6e\x8c\x2c\x8d\xd3\x32\x9b\x93\x38\xe3\x02\x92\x03\x30\x53\x89\x57\x94\x5d\x28\xe4\x08\xb7\x6e\x79\x62\x0f\xf1\xf7\x84\x09\x11\xad\x7c\x35\x55\x29\xe1\x46\x67\x5e\xc2\xbf\x8e\xe4\xc0\x37\xc9\x71\x8b\x26\x09\x96\x6b\x26\x2d\x3a\x9d\x66\xe8\x2a\x0d\xe7\x23\xfc\x5b\xa6\x31\xfa\x29\x53\x79\x39\x97\x3f\x24\xf5\xeb\x7f\x87\x3c\x87\xf6\x83\x11\xdc\x8c\xe1\x67\xc6\xe3\xb3\xdf\x66\xbc\xc4\x46\x3c\x99\xc3\xbf\xe0\x0f\x3e\x98\x95\x25\xcf\xe5\xaf\x98\xa2\xbe\x44\xfe\x94\x32\x1b\xbc\x8e\x79\xa6\xfe\x81\xb0\x23\xf9\x3b\x01\x98\xda\xa5\x5a\xfe\x4c\x0b\xfc\xe7\x1c\xfe\x81\x0f\x12\x18\x03\x9b\x0c\x18\xb4\x1e\xa6\x2c\x4b\x94\xcf\xf7\x30\x1d\x39\x5d\x0d\xd3\xd1\xac\x80\x71\x0d\x39\x57\x9d\x82\x03\xb9\xfc\x17\xa2\x16\xf4\x0f\xf5\xf9\x78\x0d\xfe\xbb\x0e\xff\x7d\x0a\xff\x7d\x06\xff\x7d\x0e\xff\x7d\x01\xff\x65\xe8\xb4\x2e\xff\x45\x90\x63\x33\xfc\x31\xfe\x5d\x4e\x60\x9c\xa9\xe9\x23\x9d\x8c\xd0\x2b\x55\x4a\x37\xf2\x87\x48\xf3\x84\x7d\x06\xdf\xf7\x14\xff\x9b\x9f\xe1\xbf\xb0\x93\xe5\xcf\x09\x4d\x73\xfc\xb7\xf8\x6d\xc6\x00\xcc\x84\xe5\x33\xfd\x6f\x5a\xb2\x09\xfe\x2e\x61\xe9\x72\x0a\x18\xca\xb9\xc1\x4b\xce\x71\x6a\xf8\x5b\x95\xad\xe9\x9a\xe8\x0c\xf9\x0b\x86\x09\x23\x9f\xd2\x82\x02\xbc\x69\x46\xe5\x1e\xfc\x0c\x0d\xa6\x88\x3d\xfb\xad\x60\xb1\x46\xae\x92\x80\xba\x26\x16\x41\xfe\x02\x23\x21\x78\xd0\x4f\x26\xb4\x00\x52\x80\xe3\x0e\x7e\x68\xe2\x28\x61\x78\x25\x9b\x4c\x33\x8a\x64\x63\x64\x34\xf9\x5b\xae\x15\xfc\x18\xe3\x7f\x15\xbe\xcb\xb4\x54\x70\x0a\xfc\x2f\x8d\x01\x65\x33\x98\xc4\x05\x52\xdc\xe7\xc9\xb4\x75\xb2\xf1\xf5\x7b\xa7\x99\x23\x83\x16\x25\x3f\x94\x7f\xd9\xbd\x64\x36\x90\x43\x74\x7a\xf5\xed\xbc\x13\x3b\x1b\x67\x31\xed\x32\x58\x4c\xdc\x62\xe0\xe5\x24\x83\x2a\xe1\x23\xbc\x34\xac\x42\xa0\xb3\x1b\x07\xb4\x8d\xa4\x35\x4b\xc5\x98\x0c\xe6\x4e\xb1\x2d\xe0\x66\xab\xab\xc0\x00\x5f\x01\x96\xbf\xef\x92\x34\x8f\xb3\x59\x02\x25\x6d\x51\x7f\x87\xa0\x58\x51\x08\x7d\x12\x4a\x06\x21\xf9\xde\x90\x5d\x48\x76\xaf\x5c\x38\x56\x08\xec\x31\x96\x8e\xf2\x7d\x33\xc3\x84\x89\xd8\xae\xe1\xdd\x2e\x10\x32\x19\x6f\x9d\xf0\x91\xbb\x56\xce\xca\x45\x31\xcf\x63\x5a\xb6\x8f\x35\x7b\x3a\xe9\xdc\x62\x3c\x23\x96\x33\x29\x50\xad\x02\xab\x67\xc9\x2a\xcb\x93\x55\x79\x4a\x68\x92\xc1\xc7\x3b\x79\x62\xa8\x46\xf1\xb8\xd2\xee\x7e\x6e\x88\x87\x4f\x4b\xc3\x4c\xe0\x3f\x05\xfe\xb7\x54\x48\x03\x93\xbf\x14\x64\xb6\xf2\x18\x04\x34\x65\x5f\x55\x77\x28\x94\x8b\xfa\xe0\xfc\xd4\x45\xb3\x91\xe4\x77\x47\x74\xa4\x9f\xc9\x47\xf4\x88\x8e\x76\x11\x21\xee\x63\x44\x47\xf8\x5d\xce\x07\x45\xf8\xcd\x14\x1e\xff\x60\x31\xee\xf5\x2e\xf9\xd9\x6e\xc9\xe4\x08\xb6\x66\x25\x97\x87\x20\x54\xd6\xb7\xdf\x27\x59\xd3\x7b\x79\x33\xda\xf0\xdd\x78\x13\x77\xda\x0f\xd6\xc8\x26\x31\xb7\xd0\x36\xcf\x12\xf9\x54\x5d\x36\xa5\xcc\x42\xf3\x98\xb9\x09\xb1\xa8\x8f\xb3\x53\x8c\xbe\x6d\x7f\xb9\xea\x12\xf5\x31\xb9\xbc\xac\xa3\xd7\xf1\x87\x4f\x15\xb6\x65\x1f\x7d\xbf\xa3\xbe\xf9\xa5\x46\xad\xc2\x12\x1d\xc2\x03\x9e\xbf\x3f\xc4\x5b\xef\xbd\xcd\x4d\xb2\xea\x64\xab\x70\x07\x17\x39\x2b\xe4\xb8\x2c\xd7\x9a\x55\x57\x6c\x51\x5b\x7f\x05\xbd\x96\x56\x69\x51\xd9\x38\x37\x18\x71\x8d\x0c\x2a\x3d\x68\xc3\xe1\x21\x63\xa4\x98\x65\x0c\xf5\xfc\x8a\xfe\xcd\x8e\x50\x45\x7f\x54\x51\x40\xfd\xcd\x57\x6c\x4b\x25\x9f\xaf\xca\x43\x74\x35\xcd\xe5\xc9\x63\x26\xe9\x48\x44\xa1\x09\x82\x83\xa0\x2e\x3f\xad\xa5\x25\xef\xa1\x14\x46\xbc\x07\xd3\x56\x03\x56\xc2\xe4\xbf\x68\x99\x42\xdb\x21\x84\x4a\xef\x23\x6d\x60\xda\x04\x02\x75\xa8\x4f\x8e\x10\x6d\x1f\x52\xea\x69\x18\xa4\xe2\x10\xe6\x6b\x9f\x24\x0c\x08\xda\xf4\xbd\x4f\xac\x0b\x61\x28\x8e\xdb\x00\x28\x40\xce\x0b\xa1\x49\x92\x6e\x82\x55\x23\xf7\x85\x90\x1a\x17\x30\x44\xd6\x0b\x21\x65\xe9\x8d\x69\x61\x21\xbc\x04\xbd\x01\xed\xdf\x65\x13\xfc\x06\xca\x71\xa1\xaf\x58\xbd\x93\xf7\xed\x86\x61\xb5\xbd\x47\x8f\x64\xa3\x47\xe4\x3d\xb4\x82\xbb\x8e\xbc\x13\xc1\xc3\x9e\x31\x26\x1d\xd1\x11\x78\xa1\x7e\x4c\xcb\xf1\x01\x55\xb4\x67\x59\xb1\xa3\x61\x76\xdc\xb1\x7a\x3d\xf2\x16\x2f\x3d\x52\x68\x12\xd6\x44\x8c\x91\x55\x69\x0e\xe9\x24\xf2\x99\x98\xd1\xcc\x5c\xb0\x27\x3c\x61\x51\x84\xaa\x56\xad\x35\xac\x41\xbe\x23\x2e\xe1\x59\x3d\x83\x6a\x3e\x83\x3d\xb3\x1e\xea\xe8\xf6\xd6\xc8\x1c\xe2\xde\xd3\xbf\x82\x50\xbd\xe1\x81\x37\x2d\x6f\xd6\x81\x0f\x4a\x72\xd5\xb2\x48\x63\xa8\x29\x3b\x65\xf4\x0c\x54\x01\x82\x61\x86\x89\xdc\x66\x31\xd0\x59\x46\x27\x8c\xe6\x0e\xd2\x4d\x46\x04\x0b\x6f\x30\x2b\xab\xe3\x74\xad\xdd\xf5\x51\xd6\x46\x74\xfb\xd5\x28\x93\xbb\x84\xa6\x04\x74\x0b\x72\x8f\x1b\x2b\x80\xa9\xa2\x6b\xac\x0c\xc2\x1c\x52\x34\xcb\xc8\x80\xc6\x67\xa4\xe4\xe4\x7e\x9a\x13\x79\x92\xdc\x07\xaa\xf4\x0d\xed\xb2\x9d\x2a\x4d\xab\xc1\xc2\x05\x40\xd9\x2f\x2e\xc6\x69\x3c\x26\xa8\x8e\x18\xd0\xc4\x90\xb7\xe9\x5a\x67\x7a\xbd\x53\x0c\x16\xde\x22\x96\xc5\x82\x05\x2c\xc7\x3e\x89\x95\x15\xbe\x83\x37\x3b\xff\x11\xde\x0a\xfd\xcf\xf4\x55\xe6\x6e\x49\xc1\x9c\xdf\x66\x2e\x70\x97\xec\xfb\xcf\xe0\xa6\x58\x79\x36\xf4\x23\xfb\x6a\xd3\x2e\xfe\x85\xa6\xa9\x15\x21\xde\x0c\x8c\x76\xa4\x79\x12\x31\xcf\xfe\x90\x55\x90\xf4\xec\x63\x17\xae\xb8\x0b\x06\x46\x03\xcc\xcb\x4c\xc8\x1f\x32\x2c\xa8\xff\x08\xd6\xce\x7f\x04\x4b\xfc\xaf\xb3\x62\x72\x38\x1e\x46\x3c\x12\xac\x23\x04\x74\x69\xde\xb8\x8c\x56\xcd\x7f\xaa\xf4\x6b\xde\x43\xd0\x11\x79\x4f\x40\xf7\xe3\x4f\x13\x2e\xd8\xde\x23\xa3\xfa\xa9\x3c\x55\xca\xa1\x3f\x1a\x99\x6c\x42\xf3\x32\x8d\x05\xe2\xb3\x1c\xb3\x55\x50\x5d\xa8\x0b\xbd\x8f\xcc\x72\x92\x2d\x40\x66\x9d\x16\x80\x86\xfc\x13\xf6\xaf\x89\xaa\xcd\xb9\x08\x90\xec\xa7\x7a\x51\x39\x28\xf8\x80\x0e\xb2\xb9\x4e\xce\x6b\x99\xbf\x2b\x9a\x74\x95\xbf\x13\x9f\x95\x19\xbd\x00\xc5\x38\xc0\x8d\xf9\x64\xc0\x85\x86\xe5\xeb\xc6\xe5\xb7\x78\xba\x28\xf5\xb4\x52\x12\x13\x3e\x65\xb9\x00\xef\x22\xa5\x2b\xe6\x64\x00\x89\xa8\xb5\xff\xe2\xdd\xde\x85\x02\x46\x58\x83\xf9\xb5\x0a\x1f\x1d\xaf\x57\x1f\x3c\xad\x3e\x78\x56\x7d\xf0\xbc\xfa\xe0\x45\x7d\x0d\x8c\x28\x87\x17\xa9\xf1\x1a\x5c\xac\xaa\x4f\xd7\x83\x4f\x9f\x06\x9f\x3e\x0b\x3e\x7d\x1e\x7c\xfa\xa2\x65\x5c\xec\x71\x88\xc5\xb4\x32\xe6\x22\x40\x37\xbe\x4a\xc7\x5c\x21\x1d\xa9\x74\x13\x2e\x92\x15\xd8\x81\x13\x4b\xf3\xc7\x7e\x95\xe3\xd7\x9f\xf8\x67\x80\xca\x85\xe2\x24\xde\x09\x32\xa0\xc0\x36\x5a\x70\x7c\x2e\x3e\x3b\xf5\x19\xbb\xcc\xa1\xeb\x0a\x1a\x60\x60\x93\x02\x15\x5c\xea\x69\xc1\x70\x93\xa0\xe1\x06\x72\x26\x51\x32\x64\x17\x6a\x6d\x54\xf6\x64\xc8\x9f\x6a\x9c\x34\xc6\x69\xe6\xc5\xd5\xfb\x9b\x68\x75\xd5\xde\x21\x12\x7e\x91\x83\xb6\xb2\x8b\x99\x12\x73\x9e\x33\x34\xcd\x70\xc1\x88\x32\xff\x12\x9a\x7b\xe0\x70\x07\x63\x85\x7a\xb9\x0b\x21\xa6\x6b\x68\x0d\x4a\x67\x39\xbf\x40\x3b\x95\xda\xc1\x18\xf1\xdb\x85\xf0\x5a\x9d\x45\xde\x05\x88\xf6\x23\x0a\xe2\x35\xcc\x33\x6a\x26\xfb\xcd\xc0\xdd\x5e\xf3\x27\xe5\xf4\x71\x83\x9b\xd9\x30\xcd\x13\xe5\x3e\xa2\x35\x58\x6f\x79\x81\x97\xfb\xca\xf5\xcc\xbd\xff\xe9\xed\xbf\x80\x23\x68\x45\x88\xbf\xd2\xda\x5e\x54\x79\x0a\xa6\x23\xff\x99\x63\x26\xaa\xd0\x36\x9a\x83\xfc\x87\xd5\x9c\x3a\xea\x69\x4a\x33\x3e\xaa\x3d\xac\x7d\x9c\x9e\x57\x9f\x54\xe9\xdf\x98\x8c\xaa\x8f\x47\xe1\x2d\xa9\x0c\x49\x95\x87\x68\x53\xaa\xef\xbf\xfa\xc3\xd0\xee\x05\xfb\x4e\xe5\x11\xcb\x67\x95\x47\x39\xad\x4e\xa6\xc6\x1d\xaa\x80\xb5\x8d\xa6\xf2\x54\x59\x64\xfc\xa7\xb3\x1a\xb0\xda\x34\xb5\x49\xaa\xbf\x40\xf4\x53\xd3\xac\xce\xfb\xf3\xa4\x3a\xb6\x3f\xec\x60\x59\xac\xc5\xa9\xb0\x66\x2f\xa9\x54\x18\x84\x56\x92\x5d\x5e\xde\x0c\x74\x96\x5e\x03\x38\xac\x16\xaa\x40\x49\xaa\x2c\x36\x09\x9c\x4b\xd7\x6a\x83\xaa\x07\x12\x2a\xe3\x16\xc3\xa9\xea\xe4\x2a\x30\xa8\xcf\xe9\x0f\xa7\x2c\x26\x02\x9c\xdc\xf9\x84\x29\x7f\xf2\x01\x9f\x95\x44\x02\x44\x3b\x37\x24\xa5\xe5\x43\x32\xa1\xc5\x19\x2b\x44\x57\xe5\x5b\x40\x5f\x6b\xe1\x42\x63\xbf\xcd\xd2\x73\x9a\x19\x7f\xf3\x54\xe9\x8c\x6a\xec\xb4\x49\x1d\x59\x19\x2c\xe8\x0b\x17\x4f\xd7\x57\x1b\x86\xb8\xb2\xe6\xd6\xd6\x34\xa1\xdc\xf6\x54\x4e\xfc\x15\x12\x76\x3f\xb1\xec\x17\xce\x33\xc8\xb6\x8a\xbf\xc0\xf1\x2e\xc4\x8e\x2b\xf6\x0a\xef\xcf\x90\xa1\xc2\xda\x29\xf0\x7c\x09\x7c\xa7\x55\xc5\xd5\xa6\x78\x44\x38\x9f\x19\x69\x09\xbe\x2a\xe9\xc8\xd1\x2a\x9b\x61\xd7\xe3\xec\xb5\x7b\xa2\x9e\xa3\x3e\xdf\xba\x10\xf3\x5c\xc1\x4a\x1f\xf3\x8b\x58\x70\xa9\x20\x53\x2a\x04\x4b\x34\x6a\xe8\x48\xe7\xe9\x18\x30\x80\x63\x03\x50\x6d\x0f\xbe\xf6\x49\xad\x16\x5a\x6b\xa0\x4f\xa3\xa0\x0c\xe9\x2d\x9d\xd5\x70\x04\xb8\xd7\x58\x83\xa4\xef\xe0\x60\xa3\x0a\x56\x63\x1e\x74\xac\x6e\x47\xe6\xe3\xc6\xd3\xd8\xe9\x94\x36\x19\x9a\x1c\x88\xfb\x45\x63\x5f\x97\x97\xd5\xe1\xd8\x84\x32\xf7\x1a\x80\x34\xb9\xa0\x9a\xce\xf5\x98\xb4\x51\x20\x08\x05\x69\xc2\x7c\xa2\x1c\xb0\x30\xd6\x6d\x81\x5f\x57\x5b\x47\xb5\x62\x2e\xe5\x22\x87\x50\x6a\x72\xcf\x1f\x2c\x79\x4c\x5a\x97\x2d\xf2\xd8\xae\xb2\x7e\xe0\x8e\xcd\x3c\x33\xde\x5f\xc4\x77\xbe\x3d\x56\x1d\x9c\x2c\xe1\x75\x6b\xda\x1a\x77\x5b\x33\xcc\x92\x8e\xb6\x53\x31\xcd\xe8\x7c\x0f\xf3\x55\xe9\x51\xd9\xf9\x43\x92\x29\x30\xa7\xab\x4d\xa7\x23\xe4\xed\x7e\xf1\x55\xa5\x7e\xe2\x8a\xde\x7f\x1f\xf6\xa2\x92\x89\xd2\xee\x2d\x2f\x34\xb6\x36\x82\xd6\x91\x71\x43\x36\x17\xde\x5a\x18\x64\xfd\xab\x8f\x66\x98\x8e\x1f\xb3\x13\xcb\x5f\x9b\xc6\x7d\x27\xaa\x6b\xce\x67\x4a\x22\xc6\x62\x36\xf9\x1c\x63\x24\x9d\xaf\x6c\x5d\x4d\x29\xec\xf3\x9c\xdc\x97\x8b\x04\x09\x38\xb3\x14\x45\xf1\x39\x9f\x15\x04\x3d\x46\xc0\xd3\x2e\x6a\x2d\xcc\x77\x51\x9f\xc3\xab\x2a\x5d\x7c\xef\xef\x7c\xb4\xba\x3a\xc4\xe4\xa7\x1c\x4b\xfd\xf5\xc1\xf6\x1e\xc5\x83\x86\x03\xc4\x1b\xc9\x05\xfd\xc5\x2b\x2b\x79\x5b\x24\xb0\xc7\x9b\xa4\x45\xb6\x92\x84\x50\xf2\x0a\x2e\x56\xdf\xcb\xe3\x0a\xe6\x09\xae\x84\x25\x57\xb9\x90\x74\xc4\x14\xf8\xc1\x69\xc7\x01\xa8\x66\x06\xc9\x62\xc1\xa1\xac\xe0\x17\x82\x15\x55\xa4\xd4\xfd\xbe\xeb\xdc\xb4\x1d\x45\x51\xa7\x4f\xbe\x11\x24\xa6\x79\xce\x4b\x42\xa7\x53\x26\xb7\xa6\x49\x02\x24\xd1\x0f\xee\xde\xdf\x08\xf9\x7f\x0c\x05\x70\xb0\xdb\x75\x77\x57\xb7\x42\x0c\x5d\x98\x6c\xd7\x6c\x36\x1d\x1f\xe9\x2f\xd7\x2d\x87\x99\x30\x11\xb3\x3c\xa1\x39\x48\x08\x80\x15\x35\xe0\xeb\x06\x5b\x1d\x96\xbd\x37\x69\xff\x17\xbc\x53\x61\xb9\xa5\x92\x13\xaa\xf2\x57\xb3\xcf\x53\x5e\x94\xc1\x53\x3b\x0a\x38\x1d\x98\x1c\xf6\x15\x57\x04\xdd\x17\x26\xe9\x82\xcf\xc3\x30\xed\x21\xb4\x9b\x43\x8a\x9d\xcf\x01\xdb\xd9\xbf\x81\x34\xe0\x88\x44\xc1\x73\xb5\x6a\x03\x7c\xf8\x90\xdc\x6b\x3e\x10\xeb\xb3\x56\x32\xd6\x55\x93\x47\x2f\x78\x7f\xd4\x1f\xdf\x95\x77\xb2\xe7\x51\x6f\xf2\x6a\x18\xaf\xeb\x0d\xa7\x91\x76\xaa\x37\xad\xac\x97\x3d\x36\x0b\xb9\xd4\x93\xcd\x06\x4f\x7b\xfc\xc4\x77\xae\x27\x9b\x35\x6f\x7b\x6c\x56\x75\xaf\xb7\x15\x16\x82\x10\xeb\xce\xf5\x0a\x72\xc8\xeb\xbe\xfe\xd9\x11\xd2\x6a\xdd\xf3\x1e\x9b\x86\xdc\xec\xc9\x66\x83\xf7\xbd\xf7\x49\x93\x7f\xbd\xfd\xba\xd9\x03\x7f\x31\x20\x7f\x0c\x0d\x5e\xf8\x1e\x88\x06\x47\x7b\x0b\xa4\xd1\x13\x7f\x21\x18\x7f\x20\x61\x6f\x7c\x77\x4d\xab\x4c\x27\xb4\x01\x42\xfc\x09\x61\x4c\x0b\x16\xd3\x78\xcc\x40\x02\x53\xb4\x59\x7b\xe6\x77\x08\x8f\x0f\x54\x45\xdc\xea\x23\xe0\x6f\x2b\x3a\x98\xb4\x39\xab\x92\x3c\x58\x9b\xe2\xf7\xe1\x48\x73\x82\x74\xdf\xd1\x6a\xe2\x2d\xc9\xc6\xde\xd1\x69\x34\x2d\x78\xc9\x65\x2b\x53\x0c\xd0\x16\x2d\xf2\xde\xcb\x5b\xf9\x8e\x14\x2e\xea\x70\x54\xf3\x43\x56\x06\x5e\x1e\xb2\x72\x61\x27\xde\xfb\x08\xfd\xe5\x17\x75\x71\xed\x88\x3a\x4e\x20\xac\x7b\x3c\x62\xba\xf8\x84\x4d\x59\x9e\x80\xbc\x24\x91\x42\xf3\x04\xc6\x3d\xd0\x29\x4d\x25\x60\x11\x55\x13\xb9\x4b\x71\x0c\x12\xae\x51\x3c\x28\xa7\x3c\x9b\x0f\x53\x88\x0a\x20\x3c\x4b\x58\xa1\x85\x09\x11\x81\xd5\xa0\xdf\xeb\x0d\x07\xd1\x84\x61\xce\xcd\x55\xdd\x5c\xb4\x6c\x48\x57\x9a\xff\x8a\xba\xa3\x07\x4f\x23\xfc\xad\x22\x91\x74\x0c\xc8\x8f\x5c\x94\x36\x7d\x7f\x38\x5c\xa9\xa3\x82\x30\x30\x75\xfc\x4e\x2e\xf7\x99\x4d\xbc\x89\xfc\x30\xc3\x6e\x24\xc1\x16\x13\x1d\xe4\xa6\x8a\x98\x83\xa2\xf3\x11\x39\x2a\x66\x4c\xa7\x5b\x94\x24\x95\xa5\x2c\x01\xe9\x09\x22\xd8\xa0\x4e\x90\x0a\x7e\x90\x7f\xdb\x9a\x3c\xf0\xf1\x7f\x80\x3b\x33\xf9\xf2\x7a\x7b\xff\x9d\xda\x9f\x57\xd8\xf0\x68\x0c\xa1\x7e\x09\x66\x50\xd3\xf0\x22\xf8\x48\x1d\x67\x5f\x06\x9c\x67\x8c\xe6\x57\xde\x18\x64\x53\xa7\x57\xff\x4b\xa8\x29\x94\xd3\x6c\x85\x3c\xea\xd9\xc0\xb8\x54\xc0\xa1\x68\x32\xbd\xb5\xe5\x07\x48\x0a\xaa\xab\x7b\xf7\xe0\x19\x54\xed\xca\x75\xd0\xdd\x11\x12\xe5\x26\xd9\xf9\x79\xe7\xdd\xce\xde\xd1\xe9\xde\xfe\xf6\x0e\xd4\xc8\xac\xb5\xd8\xde\x7f\xf3\x61\xd9\x26\x6f\xdf\x6f\xfd\xed\x9a\xb6\x6f\xf6\xdf\xd9\x16\x0f\x1f\xda\x16\x2a\x8f\x89\xa4\x69\x82\xe4\x03\xc9\x09\xd0\xc9\x78\x75\x96\x0b\xf4\x75\x68\x75\x3a\x7e\xa4\xf8\x88\x95\x40\x24\xef\x39\x2f\xd5\x3a\xa0\xd4\x83\xf8\x88\xf5\x2f\x44\x0a\x5c\x5a\x2b\xcf\xea\x7a\x97\x15\xd5\xd2\x34\x5c\x80\x92\x0a\x0c\xfb\x89\xb6\x0a\xaa\x41\x01\x60\x57\x92\xad\x7d\x60\xd3\x62\xd6\x03\x20\x51\x45\xa1\x78\xf9\xf6\x8c\x1d\xf1\x9f\xd9\x88\xc6\xf3\x1f\xd9\xac\x48\x45\x99\xc6\xd5\x89\x42\xba\x35\x8b\x12\xbc\x34\x2f\x87\xa8\x0d\x8f\x78\x5c\x20\x0f\x1f\xba\x30\x17\x50\x52\xa5\xe1\x98\x0a\x9b\x93\xe6\xfd\xfe\xfe\xd1\xe9\xd6\xd1\xd1\xfb\xdd\x1f\x3e\x1c\xed\x40\xce\x9f\xea\x9a\xe2\x6c\xb7\x66\x25\x7f\xcb\xe3\x99\xf0\x59\x82\x64\x55\xe1\x48\xcf\xf9\x94\xf9\xa1\x9e\x9e\xfa\xb1\x1e\xfd\xd9\x98\x79\x23\x10\xcf\xa9\xd0\x81\xc5\x7e\xa8\x1e\xd9\x86\x5f\x3d\x0a\x78\xae\x11\x28\xb7\xf7\xdf\xbd\x67\x79\xc2\x0a\x56\x90\x4d\xa4\xe9\xf7\xaa\xa4\x0b\x2b\xda\x72\x9c\x72\x49\x38\x2f\x71\x7e\x20\xa7\xf7\x1d\x31\xdd\x4b\xe1\xb8\x1b\x70\x36\xc6\xa3\x85\x40\x30\xf1\x13\x2b\x60\xe7\x4e\x76\xa6\xda\x3b\xb3\x64\x24\x08\xde\xac\xe9\x86\x67\xad\xd1\x4f\x2b\x26\x1b\x6f\x23\xf4\x83\x6f\x3c\x96\x60\x15\xa3\x5e\x25\x0b\x1c\xcf\x02\xae\xf3\xda\x35\xb2\x93\x3e\x69\xfd\x75\x58\xd0\x11\xfc\xe5\x26\x47\xd2\x34\xdf\x38\xb9\xc0\x96\xd4\xff\x73\x91\x06\x30\x5e\xc3\x3f\x91\x79\xfe\xe1\xfd\x2e\xe9\x83\xe6\x49\xee\x50\x9b\xe9\x4a\xa9\x1e\x5b\x5e\x9a\xa6\x4a\xe2\x6b\x7d\xc3\xae\x25\xc0\xae\x26\xee\x32\x9b\xb0\x8a\x0f\x8f\x6d\xbe\x6e\x98\x9e\x8d\xac\x26\xfd\x70\x93\x2a\xb6\x2a\xb9\xbc\x1c\x7e\xe7\x4e\x5b\x32\x72\xc7\x99\xd8\x59\x33\xfb\x41\x49\x47\xba\x18\x7f\x08\xa5\x75\xbc\xb9\x5d\x77\x01\xde\xf5\x18\xc4\xff\xba\xaa\x16\x93\x36\x13\xef\x93\x20\x1f\x05\xf3\xba\xcb\xc6\xa7\xf4\xda\x5b\xb6\x5a\x4e\x17\xac\x57\x1d\xdb\x6c\xf5\x2f\x76\x7a\x7d\xfb\xd3\xbf\x60\xf6\x2b\x3d\x5e\xb9\x3a\x41\x7d\xe6\xb8\x59\xd9\xae\xba\xc8\x14\x00\x55\x0d\x5c\x01\x17\xd9\x79\xa9\x90\xa7\xd0\xe2\x22\xa7\xd6\x74\x9b\x9d\x9b\x4b\xb7\xf3\xd8\xc3\xd1\xe2\x55\x0b\x81\x8c\xf2\x86\x75\xac\xe1\x7c\xbd\x01\xe9\x41\xa8\xee\x87\x08\x78\x89\x95\x38\x5d\x6e\x29\xd6\xfd\xb5\xb0\xc8\xaa\xa7\xcd\xab\xe1\x49\x75\xdb\x84\x9b\x10\x51\xeb\x75\x3d\x98\x0d\xb2\x34\xde\x35\xe1\x1c\x76\x55\xab\xb1\x24\x5a\xed\xe1\xec\x5b\x00\x32\x2d\x98\xec\xe6\x2d\x97\xc2\xf0\x24\xf5\x28\x43\x7f\x5b\x95\x8a\x53\xfd\x5b\xef\x86\x06\xe1\x78\xc4\xca\xc3\xc0\x1b\xfb\x55\xa9\xe1\xc0\x39\x67\x67\x06\x55\x70\xb6\x86\x25\x5b\x30\x28\x15\xeb\x6d\x3a\x68\x87\x06\xb1\x78\x7c\x96\x07\x39\x43\xf1\x26\xab\xbe\x0f\x5f\x0b\xd4\x60\x51\x7f\x12\x5a\x03\x47\xb0\xe8\x86\xd9\x67\x97\x8c\xdd\x7d\xa7\x45\x72\xfd\xfa\x47\x9a\x27\x99\x77\x42\xd7\x89\xca\x3d\x90\x1d\xcf\x72\xa5\x3f\x94\xd7\x2f\xbb\x01\x51\x89\x18\xc7\x90\xa4\x0b\xec\x58\x3a\x84\x3c\x1f\xb9\x19\x96\xc7\xd5\x1d\x3e\x0e\xed\xed\xfa\xe5\xbe\x6d\x37\x55\xb7\x02\x24\x0a\x18\x8d\xbc\xab\x35\x0a\x42\xa6\x3c\x40\x43\xfd\xdf\x50\xab\x40\x6e\x72\xb8\xb1\xc1\xc7\x44\x65\x22\xf7\x3f\xdc\x58\xa9\x1c\x5a\xd7\xab\x4b\xdb\x0b\xe6\x13\xe4\x26\x0d\x28\x42\xe4\xe0\xe0\xba\xd5\xae\x6b\xe9\xb5\xea\xeb\x3d\x6e\x60\x95\x55\xf6\x63\x93\x78\x54\x35\x81\x4b\xd1\x65\xa5\x63\x35\xb0\x9a\x3e\xa6\x1d\x26\xd9\x40\x09\x9b\xaa\x7a\xa6\x31\xcb\x88\xe2\x54\xf6\xb5\xd9\x69\x50\xfb\x32\x51\xfa\x47\xe0\x95\xf5\x73\xcc\xce\xc0\x49\x10\x45\x88\xff\x32\x42\x48\x00\x02\xad\x57\x96\xf7\x0c\xd3\x1c\xf2\x3a\xbb\xdd\x14\x2c\x77\x7b\xf2\xb2\xc4\x5c\x8b\x4b\xe3\xa8\x14\x50\x9d\xde\x14\x94\x87\xa1\xa5\x2f\x35\x55\x66\x8f\xe5\x1e\x17\xcf\x88\x67\x89\x29\x29\xab\x4b\xf3\x5c\xcf\xc2\x42\x42\xc3\x32\xcc\xc4\xab\x3b\xa0\xf2\xe0\x99\x4d\x0e\x69\xde\xf0\xa5\x1e\x95\x7d\xe9\xd5\x0e\xaf\x7e\xd9\x58\x44\x3c\xd8\x30\x54\x4d\xbc\xce\x48\x6a\x1f\xff\x9b\xf0\x12\x4f\x48\xf4\x35\xf3\xb7\x59\x7e\x4b\x5c\x26\xe5\xf2\x91\x2d\xc4\xd0\x70\x1a\x56\x84\x92\x52\x5f\x4a\xec\x3d\xf9\x1a\x96\x7f\xa3\x83\xa1\xd6\x2a\xd1\x99\xc6\xb3\xf9\xa1\xdc\x94\xb9\x4e\x03\x0f\xb1\x4b\x18\x00\x0e\xe6\xa3\x85\xad\xef\x69\x1d\xac\x2d\xce\xb0\xf0\x83\xe8\xf4\x74\x0c\xb9\xea\x9d\x09\x54\x90\xb7\xcd\xa6\x45\xca\x8b\xb4\x4c\xff\xc1\x0e\x67\x83\xb2\x60\x4d\xf2\x44\x05\x83\x5a\x8f\x80\x25\x70\x2a\xa2\x89\x5c\x8f\xa0\x78\x02\x32\xc7\xed\xe5\x92\x9b\x6e\xf6\x05\xa4\x8c\xdd\x5d\x2f\x39\xd8\x63\xae\x6c\x32\x64\x2d\x9a\xde\x8d\x4f\x33\xdd\x8b\xcf\x80\xf5\x53\x85\xef\x95\x15\x42\x72\x7e\xd1\x97\xff\x81\x50\xf2\xc9\xac\x04\x51\xb3\xaf\x75\x48\x20\xcc\x42\x56\xd7\xc5\xcc\xd7\xee\xb9\xc5\x98\x27\x5e\x11\x1c\x79\x08\x68\xd9\xfa\xaa\xeb\xf4\xb8\x98\xdf\x57\x8b\x8a\x37\xee\xff\xeb\xc6\xe2\x17\xbb\xc6\xd2\xf5\x63\x68\x43\x04\x37\x85\x5c\x95\x67\x72\x1a\x8f\x55\x13\xaa\xc2\x0c\x78\xce\x04\x38\x57\x5b\x70\xe0\x6a\xad\x03\x85\xb1\xe4\x29\x02\x2c\x84\x5f\xb7\xb9\x41\xac\xd0\x63\x77\xab\xe8\xf9\x55\xc8\xdd\xa4\xb0\x4a\x35\xee\x80\x5d\xae\x2c\x79\x13\xc6\xfc\xa5\x80\x3b\x4d\x03\x6b\x74\x84\xa5\xd0\xca\xba\xa5\x75\xac\x17\x88\xb7\xc4\x12\x70\x7d\x99\x4b\x67\xe7\xc3\x08\xd1\x6f\x2f\x67\x17\x47\xce\x61\x4d\x88\xdb\xce\xd5\x9d\xeb\x96\x5e\x87\x8e\xec\xb4\xb4\xf8\xb5\xa4\x00\x16\xea\xe3\x88\x9b\xed\xeb\x76\x67\x14\x45\xb5\x9e\x16\xe8\xd9\x5d\xa5\x97\x7b\xca\xdb\xe6\x4e\x2e\x41\xcc\xa6\xf8\x03\xd4\x19\xc6\x31\x76\x89\xaf\xd3\x26\x21\x07\x26\x0b\xab\x69\x8e\xe6\x44\xc6\xb9\xba\xfd\x5c\x8b\xd0\xae\x2a\x7c\xfc\x66\x21\x76\x43\x43\x77\xbf\xdb\xa8\xf7\xef\x68\xee\xeb\x43\xa9\x22\xbb\x61\x14\xbf\x27\xe6\xeb\xc3\x5f\x88\xfb\xa5\x41\xf8\x5b\x74\xc2\xcf\xd9\x2d\x29\xdb\x01\x12\xa2\x6c\xe7\xf5\xdb\x82\x4f\xfe\x49\xb4\xdd\x34\xc8\x85\x38\x5d\xf0\x91\x39\x94\xaf\xe0\xe0\x1b\x6b\x33\xba\x39\xf9\x68\xae\x4c\x4d\x8b\x74\x55\xde\x15\xc8\x9f\x74\x5a\x35\x27\x80\xf8\x55\x35\x36\xd6\xb5\xb5\xd0\xcc\xfb\x38\x90\x1e\xd4\x99\x6d\xc5\x70\x47\x9c\xab\xb8\xce\xba\x37\x86\x3c\xfd\x17\x64\xc0\x58\x4e\x0a\x4c\xd5\x2f\x8f\x11\x9a\x9b\x14\x6a\xee\x49\x12\x50\xbc\x59\xde\x6d\xd0\xd2\x24\xa3\x39\xa8\xf1\x38\x76\x25\x39\x2d\xfa\xd4\x86\x50\x74\xb4\xf3\x7f\xea\x34\xd1\xeb\x91\x1d\xc8\x56\x8b\x62\xa8\x2d\x1a\x05\xc9\xe6\xc0\xbb\x0f\x44\x5c\x38\xb6\x59\xc1\xc8\x05\x16\xc7\x62\x90\xf2\x0d\x12\xd1\x29\xf7\x40\x37\x4b\xfa\xed\xb0\x67\x9d\x3b\x97\xc1\xdc\x88\x95\x7b\xec\x73\x69\xbd\x62\x0e\xd3\x41\x06\xee\xd9\xcd\x2a\x50\x6b\xb0\x22\x2e\x4d\xb0\xcf\xa5\xfa\xd8\x4d\x4e\x70\x96\x4e\x49\xce\xf3\xd5\xb1\xe9\xc1\x4f\xa0\x7b\x31\x4e\x33\x46\x8c\x25\xdc\xb7\x4b\xd7\x68\x33\xd8\x22\xb8\x34\x6a\x78\xd8\xba\x3e\xb4\x2b\x1f\x37\xb9\x92\x3e\x5d\xbc\x40\xbe\x0a\x8b\x98\x6b\xd8\x59\x05\x39\xe8\xf1\x53\x61\x69\xbe\x1d\xf9\xa6\x18\x92\x20\xe5\xfc\xd9\xe7\xf2\x1a\x0c\xd5\x5a\x84\x31\x84\x63\xc4\xd6\xd7\x63\xa8\x2a\xbe\x8c\x6f\xc8\x87\xee\xe2\x86\x74\x93\xab\x46\xea\xdf\x51\x1c\x65\xee\x01\x17\x22\x1d\x64\x73\x92\xb0\x21\x2b\xd0\x2d\x74\x96\x97\x29\x14\xa4\x53\x72\x20\x99\x8e\xa9\x60\x2a\x78\x57\xd5\xaa\x53\xea\x6b\x0b\x6e\xc4\x4a\x42\xcb\x52\x8e\x27\x69\x94\xa3\x2d\x32\xfc\x14\xc0\xd7\x6b\xa1\x49\x45\x7f\xb2\xcc\x9d\xf0\xe6\x9a\xce\xda\x4a\x87\x7d\x02\x9b\x16\xb5\x66\x5b\x59\x74\x51\xf4\x49\x67\xd1\x7d\x7a\xd7\xe3\xd7\x77\x49\x17\x2e\xf4\xaa\xc5\xaa\xea\xdd\x18\x18\x8a\x3f\x93\x24\x4d\xf6\x78\xf9\x4e\xb2\x70\xfd\x9d\x99\x7b\xd3\xf4\x10\x63\x6f\xac\x6c\x12\xe8\xc4\xcc\xcb\x52\x40\xc8\x95\xb2\x79\x7c\x15\x89\x2c\x30\xce\xc5\xc3\x3b\xc2\x35\x86\xdf\x07\xee\x4a\xfb\xbd\x35\x0d\xdb\x2d\xb8\xe9\x00\x39\x6e\xf6\x1e\x3c\x41\xf5\x64\xe1\xd7\x32\xba\x83\x49\xab\xf9\xd6\x48\x72\xe1\x92\xd4\x8f\x3c\xbf\xc2\x59\x5d\x46\x90\xf2\xc3\x5a\xb0\x0c\x53\x93\xfb\xea\x82\x5e\x1d\xf3\x7a\xbd\xbc\xd5\x22\x7f\xd6\xe5\x60\x5e\x8b\xac\x5b\xd1\x45\x1d\x77\x77\x45\x0d\x77\x8c\xf9\xc0\x90\x6f\x8b\xf8\xc5\x20\x9b\xf1\xfe\x36\xcd\x1d\x80\x37\xa3\xd5\xa0\xac\x5f\xdb\x42\x0d\x9e\xcb\x8b\xc1\x2d\xd8\x56\x0d\x23\xbe\x11\xd3\xbb\xc1\x70\xc3\xc4\x7d\xdd\xde\xf7\x07\x79\x3b\x6e\xd7\x74\xa3\xba\x43\x36\xb7\x78\x8d\xc2\x63\x59\x7a\xf6\x77\xc2\xef\xff\xb0\xa9\x07\xf7\x54\x68\xb9\xcd\x5d\x59\xc8\xf3\x61\x96\xb1\x6d\x86\x65\xe0\xde\xd0\x2c\x1b\xd0\xf8\xac\x4f\x8a\xdd\x37\xd0\x62\x26\xd8\xe1\x3c\x8f\x0f\xb1\x21\x5c\x72\xee\x31\xf0\x45\xd8\x12\xde\xf3\x1f\xe6\xdb\xe8\x0f\xb6\x9b\x6b\x37\x67\xcc\x7d\x6f\x7d\xa4\x9f\xb9\x3e\xd2\x3f\xe0\xe1\x84\x7a\x43\xd1\x76\xdc\x0b\xa3\x81\xf7\x4a\xbb\x47\xcb\x49\xb3\x64\x6b\xc0\x67\x9a\xe3\x6e\x1d\xec\x92\x4d\xed\xa6\xe8\x96\xd7\x90\x70\x94\x09\x63\x37\x2f\xad\x0e\xcf\x6c\x06\x65\xa8\x54\x2a\x8e\x82\xe5\x8e\x76\xad\x8b\xe5\xc3\x54\x1f\x5d\x12\x2b\x9c\xe0\x02\xdc\xab\xf9\x28\x3b\xae\xaa\xaf\x21\xf6\xb3\x48\x69\x5e\x1a\x8f\xf5\x23\x5a\x48\x91\xd7\xfa\xc2\xa9\xd2\x60\x14\xd4\xbe\xda\x0d\xbb\xd5\x21\x7d\x23\xc7\x7a\x55\x60\xac\x0a\xe4\xb4\xd0\x0e\xaf\xa6\x73\x88\xb7\xab\xab\x64\xee\x35\xaa\x64\xb4\x48\xac\xe9\x83\x6c\xba\x8e\x9d\xd1\x50\x52\xbf\xf3\xfa\x63\x5a\x8e\xf7\xf8\x01\x2f\x4a\x9a\x89\xc5\x43\xd1\xa1\x51\x9e\x7b\x85\xdb\x55\x95\x80\xd3\x7c\xe4\xbd\x77\x1d\xfe\xe4\xf1\xe4\x2c\x48\x0b\x97\x54\x45\xc2\xed\x96\x24\xe3\xfc\x4c\xc5\x27\xc9\x3b\x06\x10\xdc\x2a\x36\x62\x09\x7c\xc9\x30\x22\x0e\xee\x29\xe0\xed\x6f\x17\xe0\x82\x0a\xa5\x09\xc3\x7c\x2a\x7c\x56\x12\xcc\x23\x0f\x70\x22\xd4\x15\xa8\x65\x82\x6f\xc5\x6c\x3a\xe5\x72\xa7\x41\xa8\x01\xe4\xe9\xc7\x4c\x44\xac\x28\x78\x21\x22\xb2\xab\x13\xfe\x4b\x62\xc1\x6f\xf4\x26\x88\x54\x05\x3f\x43\x74\x5b\x38\xc5\x92\xab\xa2\x3d\xd4\x59\xc1\x56\x6d\xa7\xae\xe8\x55\x4b\x85\x44\xb7\x5a\xa9\xe4\x87\xf9\x21\x9f\x30\x8c\x86\xd8\x24\xf7\xee\x2d\x5c\x1a\xeb\x30\x8b\x6e\xcc\x37\x75\x9f\x56\x64\x43\xc5\x1e\xcf\x71\x10\x34\xc6\x2b\x39\xf4\xad\x9c\xaa\x25\x2d\x42\xf9\x54\x5c\xce\xb7\x05\x9f\x60\xd0\x8c\x7a\xdf\xd1\x81\xcc\x7a\xf1\xef\x05\x21\x5e\x5e\x36\x4f\xb5\x4a\x09\xef\xd9\x34\xa3\xb1\x59\x39\x87\x02\xb4\x29\x56\xe5\xcb\xc9\xd9\x05\xfa\xc1\x2a\x52\x50\x4b\x11\x91\x5d\x88\xaf\x35\x45\x14\xe4\xaa\xcc\xac\x19\xc9\x80\xd1\x94\x94\x43\x06\x2b\x00\x22\x3f\x53\xa1\xf6\xaa\xdc\x03\x46\xf9\xc2\x9d\xf7\x33\xa6\x00\xb1\x00\x2c\xd0\xb4\x50\x05\x00\x01\x8a\xa4\x27\x1c\x35\x7c\x28\xc7\x69\x46\x27\x0c\x60\x3e\x04\xc2\x32\x13\x95\x64\x85\x5f\x01\xc5\x78\x58\x6d\x60\x07\x55\x6d\xe5\xbd\x9a\xb3\xab\x7c\x5a\x7b\x18\x95\xfc\xc3\x74\xea\x29\x34\x5b\x3f\xec\x6f\xff\xbd\x65\x97\x02\xd6\x41\xfe\x82\x09\xdb\xc1\x63\x30\x21\xe4\x03\x2b\x39\xd1\xce\xca\xd1\x80\x27\x73\xa2\x37\x65\x92\x8a\x98\xcf\x0a\x3a\x62\x49\x57\x25\x93\x4c\x4b\x61\xd1\x06\xd9\x8f\x86\x25\xcb\xc9\x84\xe6\xe9\x74\x96\xe9\xf8\xdf\x72\x9c\x16\xc9\xea\x94\x16\xa5\x8a\x05\xc6\xac\x6b\x02\x36\xa8\x0a\xe3\x21\xec\x73\xc9\x72\x91\xf2\x5c\xa8\x3d\x3d\xa1\x73\x92\x49\x84\x96\x9c\x88\xd9\xa0\xcc\xd4\x2a\x14\xca\x91\x3d\xa5\x2a\x0c\x45\xcc\x98\xfc\xa6\x98\xab\xc5\x81\xb4\xee\x18\x04\x6b\xf9\x88\x56\xb8\xa2\xe9\x37\x41\x50\x43\x5e\x60\x24\x33\x9d\x4e\x23\x1d\x29\xb4\xe2\x79\x73\x5f\xbb\x57\x21\xac\x43\x36\x76\x9d\xef\xbc\x98\x09\x79\xec\x39\x87\x94\x5c\xba\x9b\xc4\x54\xe0\xa6\xd6\xe9\x65\x55\x7d\x13\x0c\x4f\xd7\x84\x8b\x2c\xd4\x56\xa1\xbd\xe7\xc1\xf7\x0f\x14\x3c\x99\xed\x51\x6c\xdf\xc8\x49\x28\x15\x59\x4d\x4f\xa3\x54\x74\x7e\x13\x8b\x9b\x8c\x2a\xb5\x9f\x7b\x6e\xb8\x37\x0b\x18\x95\xea\x5a\x45\x68\x28\x38\xd7\x87\x72\xe8\x86\xd7\x87\x72\x78\x5d\x12\x3b\x55\x5b\x60\xac\x7a\xa6\xe9\x83\xdf\x6e\x0f\x25\x02\x80\x76\x75\x4c\x05\x24\x72\x99\x4d\x89\xe1\x56\x83\x39\x51\xec\x6d\x30\x2b\x95\xd2\x1b\xb9\x43\xc1\xc8\x2c\x2f\x18\x92\x3d\x26\x46\xa5\x82\x5c\xb0\x2c\xb3\xa7\xd4\x84\xcb\x25\xe4\x93\x09\xe4\xe1\x82\x73\xc9\x86\xc8\x43\x48\xfa\xaa\x76\xc0\x44\x71\x91\xd0\x02\xaa\x74\x62\x01\x34\xcb\x34\x71\x58\x51\xab\xa1\x44\xf3\xd5\x35\x56\x19\x07\xaf\x41\xef\x1f\x57\x08\xf6\x89\x19\x22\x9d\x5d\x72\x96\x0f\x82\xe2\x5e\x55\x86\x08\xc9\x83\xfe\xca\x64\xfc\xe2\x00\xdd\x5a\xe6\x2a\xac\xf2\xc1\x5a\x60\x89\xde\x84\xd9\x6b\xbb\x23\x59\x85\x52\xbd\x35\x20\x4c\x21\x5a\x0a\x05\x50\x6d\xf7\x82\x17\x67\xc8\x2f\x10\x1a\x39\x5f\x7b\x19\xa9\xa3\xca\x11\x57\xbc\x4e\xac\xd8\x00\x07\x96\x69\xa0\x7a\x6e\x77\x24\xd6\xe4\x89\x73\x41\x73\x55\xfd\x07\xec\x16\xa0\x47\xd5\x6e\x04\x4e\x41\xbb\x80\x20\x41\x8c\x96\xfd\xe2\x3d\xf2\x21\x57\xf0\x43\x1e\x16\x10\x00\xba\x3e\x63\xd1\x3e\x28\x4b\x70\x32\xb4\xe0\xcb\x47\x86\xdd\x28\x17\x44\x55\xa8\x57\x9d\x9e\xaa\x72\xac\x12\xfa\x91\xe3\xb8\x43\x9b\xe5\xfe\x7d\xa0\x5d\x77\xc7\xae\x7c\x00\xed\x9c\xb9\x18\x19\x5f\x8d\x47\x5f\xd3\xdc\x7b\x80\x16\xf2\x95\xa6\xb2\x53\x0b\x70\x5b\xae\x87\x62\x09\xf0\x4e\x88\x95\x0b\xd4\x78\xd4\xcb\x21\x6a\x29\x0a\x76\x55\x25\x9e\x0c\xd7\x0a\x85\xf2\x76\xe0\x02\x63\x43\xe6\xce\x20\x55\x0c\x2d\x46\x33\x2c\xba\x9b\xb1\x7c\x54\x8e\xc9\xf7\x64\x5d\x6e\x31\xf3\xfc\x78\x1d\xaf\x99\xa6\xf8\x37\x79\xed\xbf\xec\xeb\x50\xd3\x3f\xe6\xfe\xe3\x98\x1d\xa6\x54\x08\xb3\x1d\xc8\x14\xe6\x0c\xf9\x24\xe1\x33\x3c\xae\xa9\x40\x71\xc0\x8c\xd9\xe2\xd7\x45\xd5\x83\xb5\x10\xb2\xb4\xc3\xf8\x19\x94\xa6\x77\xd1\x6c\xe4\x63\x77\x33\x8c\xdd\xf3\xcf\x39\xd3\x97\xdc\x4b\x63\x67\x17\x49\x81\xb2\x61\xdf\x14\xb0\x69\xae\x56\xcc\x10\x9c\x78\x69\x25\x2d\xd6\xf2\x63\xe1\xb4\xbc\xbb\xaa\x33\xbe\xa6\xce\xe4\x40\x6e\x42\xd9\x88\x2c\x87\x9c\xaf\x36\x82\xa3\x54\x97\x1e\x7f\x98\x77\x3d\x38\x1c\x4c\xf3\xc0\xbc\x12\x91\xaa\xe6\x8b\x4b\x11\x7d\xef\x2f\x50\x77\xc8\x0b\xf0\xf6\xfe\x3b\x2c\x01\xe9\x3a\x45\xa8\xad\xbc\x5f\x54\x7c\xa5\x5c\x39\x88\x5f\xe0\xf2\xe1\x6d\x06\xaf\xc3\xfb\x17\xce\xdd\xd8\xbd\x1a\x63\x63\xed\xc7\x59\x75\xfb\x75\x0e\xb7\xf7\x6c\x28\x76\xf3\xf7\x7a\xd9\xe1\xbb\x08\xae\x10\xe0\x4d\x71\xda\xd0\x74\xa3\x76\xd9\x6e\x68\xd8\x25\xad\x6f\x40\x90\xa0\x71\xcc\x04\xdc\x83\x1d\x2c\x48\xa9\x21\x4d\x50\x2c\xd7\xc7\x55\xa4\xa5\x66\x75\x7a\xd9\x8c\x63\x94\x4c\x67\x05\xb3\x88\xd3\x6e\xa9\x58\x23\x5d\x8e\x39\x92\xd7\x77\xf5\x01\x40\xc1\x3a\xf5\xd8\xb7\x93\x04\x0f\x3c\xf6\x0a\xf6\xdb\x2c\x2d\x98\x90\x9f\x66\x8c\x24\xb4\xa4\x58\x04\x0f\x7d\xfc\xd8\x79\xca\x67\xc2\x1d\x4c\x97\x88\x59\x3c\x26\x70\xc1\x1f\x8a\x88\xbc\x33\x05\x6c\x33\x3e\x4a\x63\xac\xf3\xaa\x96\x72\x3b\x4d\xc0\x1b\x12\xc6\xe6\xdf\x0b\xb7\x53\x75\xd8\xe8\x1b\x58\xd4\xea\x42\x88\x94\x6e\x20\xaf\x46\xb8\x82\x1d\x29\x7b\xb7\xb6\x2c\x58\x57\x7c\x5a\x76\xad\x2a\x52\x8b\x7b\x64\xa3\x0a\xa8\x4a\x7d\xa4\x46\x36\x35\xef\x87\x45\x9f\x37\x0b\xc8\x35\x80\xf5\x8f\x37\x6a\x9a\x89\x5c\xa8\x88\xec\xd0\x3e\xd9\x30\xe3\x90\xed\x6a\xf0\x17\x69\x9f\xf0\x0b\xaf\x3f\xc7\x57\x3f\x30\x2d\xcd\x1b\x1b\x8a\xd7\xd7\x0f\xa7\x0f\xa0\xc9\x94\x64\x21\xfb\x46\x09\x9d\xab\xb2\x1a\xc0\xc0\x40\x9b\xa4\xb5\x05\xad\x70\x0a\xa7\x3a\x58\xbd\x4a\x98\xa9\x49\xe7\xa5\xce\x59\x0a\xd5\x12\x91\x3d\x98\x62\xb5\x39\x87\xe0\x6a\x20\x10\xf2\x13\x9b\x8b\x3e\x81\xec\x4d\xaa\x84\xed\x19\x9b\x8b\x10\x5e\xdd\xbc\x4d\x5d\xe3\xf6\xe4\x71\x2d\xa6\x7d\x46\x5d\x9f\x2e\x8f\x09\xbb\xd1\x5a\xe3\x82\x5f\x10\x8e\xac\x47\x97\x78\x96\xdb\x14\xf2\x97\x21\xf0\xd7\x2b\xce\xca\x2d\x50\xb3\x22\x33\x0e\x75\x2f\xc9\xbc\x2a\x0e\x61\xd0\x9d\x04\x76\xd3\xc1\xdf\x66\x24\x6a\xad\xea\x43\xd1\xc9\x19\x4e\x9b\xc1\x86\x8c\x34\x46\xd6\xab\x77\xa6\x6a\xc6\x57\x06\x7f\xaf\xfa\xa9\x4e\x0e\x29\x65\xb3\x31\x15\xd5\xd7\x9d\xb0\x7c\x55\x05\x32\x99\x09\xe5\x2c\x85\x79\x37\xf0\xb2\xf0\xc6\xb2\x27\x4f\xd0\x5a\x06\x87\x4b\xcf\x70\x01\x4a\x43\x2a\xd0\xa0\xd7\xa1\xc1\xce\x4d\xe5\xcc\x70\x1f\x4a\x51\xf8\x75\x4a\xf8\x25\x14\xf0\x21\x6b\xdc\x6d\x14\xad\xe6\x7b\xa3\xfc\xdc\x86\xf2\xaf\x2c\x2f\xb5\xb2\xd7\x6a\x5b\xef\x2d\x54\xb7\xd6\x05\x80\x7b\x4d\x50\xbb\xe4\x7e\x03\xfa\x24\xee\xc6\xe8\x5b\x25\xef\x9f\xad\x82\xc9\x4b\x27\x9b\x4c\x41\x4b\x54\x72\xbd\xb4\x98\xb7\x10\x35\xeb\x56\xab\x41\x73\x55\x1f\x96\x4f\xe7\x52\x16\x40\xfd\xba\x7b\x37\x55\x3f\x7a\x3d\xf2\x21\xbf\xf6\x56\xf8\x15\xf7\x42\x72\x3d\x73\x50\x92\x63\x8d\x33\x84\xc1\x91\xeb\x2f\xbd\x5e\x72\x81\x2b\x3b\x59\xd7\xa9\x4a\xe9\x9d\xe1\xde\xdf\x64\x20\xb8\x48\x41\x69\x43\x7e\x9b\xa5\xf1\x99\x14\x6c\x40\x3c\xe3\x79\x17\x56\x02\xca\xfd\x11\xeb\x53\xf5\x49\xb2\xd6\x4f\xf8\x55\x44\x8e\xc6\xb4\x6c\x09\x29\x7c\x61\x4d\x06\x79\xad\x7b\xed\x9f\xbc\x56\xe2\xa8\x9c\x67\x3e\x25\x9f\xde\x96\x94\x9b\xed\x06\xa7\xd7\x19\x0e\x4e\x2b\x96\x03\x35\xdd\x37\xba\x0e\x16\xba\x9e\x99\x3d\x5d\x0a\x96\x0d\x31\xe7\x10\x6e\x16\xb8\x5f\xb8\x5e\x9d\xda\x94\x62\x46\x6d\x26\xe4\xe7\x8b\xf0\xdc\x24\xe4\xf8\x9a\xb9\x91\x63\xb6\xc2\x9c\x7d\xf7\x82\x4e\xcf\xc1\xeb\x4d\x7d\x87\x86\x90\xf5\x7b\xed\x4e\xc4\x91\x94\x7e\x0d\x37\x2c\xf9\x74\x35\x63\xe7\x2c\x73\x90\x81\xd2\x48\x10\x67\xaf\x49\xeb\xef\x7c\x06\x6a\x75\xcc\x70\x1a\xc7\x69\x22\xef\xe5\x59\x36\x57\x89\x89\xb1\x60\x56\x65\x39\x8c\x61\x03\xc4\x6e\x3e\x44\xa5\xbf\xb5\x82\x91\x3e\x69\x19\x93\x9a\xb1\xaa\xa8\x42\x02\x46\x16\xd2\x46\x15\xf9\x31\x9a\x54\x8c\x24\x5f\x30\x25\x0a\xa6\x39\xe1\x05\x58\x57\xb8\xb2\xf9\xa9\xb4\xd8\x35\xa1\xce\xe1\x46\x7e\xfe\x1b\x47\xca\xd2\xe9\x31\xd9\x64\xca\x0b\x5a\xcc\x09\xcd\x52\x2a\x94\xe1\x02\x4a\x22\x14\x8c\x26\x73\x22\xc6\xe9\x74\xca\xf4\xd9\xbb\xf6\x82\xbc\x7f\x83\x96\xa8\x14\x34\xea\x46\xe6\x52\x23\x32\x9a\xc2\xb5\x97\x91\x2b\x80\x5c\x73\x57\x35\xed\x7c\x3e\xd8\x27\xfe\xdf\x7e\xdb\x44\x59\xfa\x4d\x63\x97\xa5\x56\x5e\xe2\x8d\x38\x9b\x89\xf1\xe1\x3c\x8f\xfd\xa6\xe6\x31\x34\x3a\x3d\x3d\xdc\x79\xf3\x7e\xe7\xe8\x74\x77\xef\x68\xe7\xfd\xde\xd6\xcf\x87\xa7\xdb\xfb\xa7\x7b\xfb\x47\xa7\x1f\x0e\x77\x4e\xf7\xdf\x9f\xfe\x7d\xff\xc3\xe9\xc7\xdd\x9f\x7f\x3e\xfd\x61\xe7\xf4\xed\xee\xfb\x9d\xed\xbe\x95\x3f\xdf\xf2\x82\x1c\xd1\xe9\xce\x39\xcb\xcb\x83\x6c\x36\x4a\x73\x15\xa2\x95\x0a\x32\xe5\xd3\x59\x46\x71\x1d\xa7\x2c\x57\x79\x70\xe1\x4b\xa7\xfd\x8f\xb3\x41\xbf\xf2\x77\x57\x43\xff\xa0\xd4\xe1\x25\x13\xe5\xea\xac\x4c\x33\x51\xfd\xfa\x3d\x1b\xa5\xa2\x2c\xe6\xfd\xd0\xc3\xae\xd3\xba\xe0\x53\x3a\xa2\x25\x2f\x44\xbf\xf6\x04\xdb\x29\xd1\x5e\x67\x7f\x33\xfb\xb5\xdf\xf8\xc6\xf9\x6e\x7b\xff\x9d\x79\x7c\x04\xd1\x97\xc1\xc7\xfe\x17\x30\x8e\x9f\x53\x51\x32\x90\x4b\x83\x8f\x31\xff\xd6\xc6\xca\x8a\x14\x67\xd0\x79\xe3\x0d\x10\xd3\x7b\x63\x63\x32\x1a\xe7\xd8\xbc\x70\x75\x37\xf6\xa9\xab\xcd\xc2\x22\x77\xc2\xb5\x52\x8d\x8d\x7d\x4a\xbd\x74\x85\x5a\xf5\x28\x32\x8d\x36\xdd\x7b\xaf\xf1\x99\xbe\x58\xac\x7a\xdb\xf0\xf2\x9c\x0e\xf9\x2c\x4f\xb6\xd9\xf9\x11\xe7\x99\xa8\x28\xe2\xd0\xdb\x44\x9e\xf9\xba\x01\xe4\xa9\x92\x57\x3d\x74\x41\x99\xbb\xb7\x4d\x4c\x87\x04\x85\x84\x6a\x67\x91\xc4\xf9\x60\x96\x27\x19\x1c\x0b\x7d\xb2\x26\x1f\x9c\xb3\x42\x40\x98\x09\x0c\xf7\x17\xfc\xcb\x5e\x66\x58\x71\x80\x59\x53\xf7\xe8\x84\xf5\x25\x4f\xa2\x71\xb9\x9a\xf0\x49\x0b\xfd\x62\x4c\x02\x37\x7f\x0a\x0f\x1f\x92\x9d\xcf\x2c\x9e\x49\x54\xed\xe4\xe7\x69\xc1\x73\x10\x4e\x63\x9a\x7f\x10\x4c\x8a\xab\x0f\x1f\x92\x8b\x34\x4f\xf8\x45\x54\xf2\x29\x20\x51\xfd\x29\x8f\x3f\xe7\x5e\xb7\xeb\x14\x8a\x7c\x33\x2e\xf8\x84\xc9\xeb\xdd\xdb\xb4\x60\x43\xfe\x19\x5c\xa1\xce\xd3\x44\x5e\x14\x12\x7e\x91\x43\x62\xc4\x2c\xcd\xe1\x5c\x95\x87\x01\xf8\xe2\x49\x52\xb5\x36\xc0\x9c\x9e\xa7\x40\xed\xd1\x4c\xb0\x62\x6b\x24\x87\xa5\x8b\xf9\xb4\xb0\x87\x56\x87\x7c\xaf\x4a\xc2\x2e\x6c\xbd\x93\x8c\x64\x5b\xac\xfb\x03\x29\x99\x16\xb5\x56\x63\x56\xc0\x7d\xe3\x23\xe8\x1c\x63\x2e\x05\x14\x85\x86\x8c\xc7\xa0\x18\x8e\xf4\x2b\x47\xee\xda\x86\x58\x12\xbc\xe2\xe6\x84\x7d\xe6\x65\x1a\xab\xf2\x33\xe0\x4d\x12\xc3\x2c\x56\x8d\xe5\xb8\xdf\xeb\x45\x8e\xd2\xae\xf7\xff\xda\x50\x4f\xea\xf5\xe5\x30\xcd\x58\xa7\xff\x40\x25\x21\xd7\x3d\x75\x2a\xc1\x4f\x82\x67\x2c\x4a\xf3\x21\x6f\xb7\xbe\x89\xb7\x35\x9a\x8d\x0d\x88\x98\x55\x37\xb6\x63\x4a\x06\xac\x2c\x59\x41\x12\x79\x0c\xf3\x29\xe8\x11\xd8\xe7\x29\x2b\x52\x06\x44\x0a\x2d\x75\x51\x2b\x37\x3f\x65\xc2\xce\x4b\x09\x4b\x36\x68\x5b\xac\x80\x2e\x24\xcd\x58\xbf\x25\x8f\xeb\xff\xce\xe1\xc0\x4e\x47\xe3\x92\xe4\x4c\x39\x3c\x08\x49\x04\x12\x6b\x19\xf9\xf1\xe8\xe8\x40\x1b\x92\xda\x8e\xfb\x01\x40\xe8\xf5\x3a\x4b\xf4\xbf\x3a\xa4\xbf\xc1\x09\xde\xea\x74\xe5\x9c\xf2\x72\xf5\x82\xc9\x0e\xfb\x03\x9e\x25\x21\xc3\x14\x24\x07\xf4\xb5\xb5\x0f\xd6\xc9\xa6\xd6\x80\x0c\x0b\xc6\xfe\xc1\xda\x5f\x56\xfe\xa2\x33\x8e\x11\xdf\xc3\xcc\xfb\xf0\x29\xd9\x24\x6d\x17\xce\xc3\x87\x56\x07\x0c\xda\x3a\xfb\xce\xcb\x7d\xcc\xe2\x14\xb5\x3f\x72\x79\xac\x20\x84\xe9\xae\xa1\x2a\x78\xb4\xa2\x03\x89\x20\x96\x28\x3e\x9b\x83\xc1\x76\x42\xcf\x98\x20\x69\x09\x96\x3f\x3c\xe7\x07\xbc\x1c\x93\xf7\x3c\xcb\x66\x98\x9d\xf4\x3f\x99\x28\x31\x4d\x32\xe0\x6a\x9b\x4f\xb4\x9a\x18\x86\x7c\xdc\x52\x33\x6b\x9d\x90\xd7\x0d\xcf\xfb\xce\xf3\x8d\x95\x95\x09\x4f\x66\x19\x8b\x70\x74\x42\x67\xe4\xdb\xe6\x90\xd3\xff\xaa\xd3\x46\x63\x46\xef\x11\xf9\xb8\xf3\xc3\xc1\xd6\x9b\x9f\xc8\x2f\x5b\xef\xc9\xee\xde\x7f\xee\xbc\x39\xda\xdd\xdf\x23\x8f\x7a\x57\x91\xbc\x7c\xb4\x15\x80\x2e\x39\x3d\xbd\x60\x83\x29\x8d\xcf\x4e\x95\xd6\xf5\xf4\xb4\xfd\xb4\xd3\xe9\x40\x7e\xd1\x47\x3d\x72\xd5\xe9\x4a\x70\xcf\x9e\x7c\x47\x1e\xf5\xd4\x33\x73\xe5\x6a\xe3\x70\xba\x64\x11\x38\xb9\x37\x56\xee\x4b\x6a\x13\x50\x7d\xf5\xfe\x86\x4e\x5d\xfa\x86\x4f\xe7\x05\xd0\x64\x3b\xee\x90\xf5\x27\x6b\x4f\x57\xa7\x05\x13\xa0\x63\x78\x4b\x63\x36\xe0\xfc\xac\x4b\x76\xf3\x58\xa7\x2b\x85\x45\x70\x72\xe2\xcb\x05\xc9\xd2\x98\xe5\xf2\xb0\x9f\x19\x77\x9a\x77\xbb\x47\xfa\x31\x1e\x14\xaa\x36\x9d\x04\xf1\xf3\xee\x9b\x9d\xbd\xc3\x1d\xa0\x6c\x5d\xb2\x0e\x04\x54\xf4\x5b\xe1\xc5\xdc\x78\xfd\xa8\x8e\xe4\x05\xd2\xe4\x4b\x2d\xe7\x53\x06\xb5\x55\x04\xa4\x30\x55\xe4\x3b\x9e\x4f\xc7\x2c\xc7\x03\x30\x84\xd0\x67\x6b\x4f\x34\xc1\x4e\xc4\x81\x94\xd5\xa1\x0c\x4a\xef\xff\x4d\xc4\x6a\xcf\xa6\x72\xfd\x51\x83\x81\x4c\xf4\x74\xc2\x32\xc9\xa2\x12\xf2\xe6\xf0\x10\xf4\xe9\xac\x28\xe7\x90\x59\x09\x7c\x15\x09\xfb\x4c\x27\xd3\x8c\xf5\xd5\xd8\x08\xf9\xde\x0e\xe4\xb0\x9c\x67\x70\x02\xb5\x5b\x03\x1a\x9f\x8d\xc0\xf4\xff\x86\x67\xbc\x68\x75\xb0\xf1\x2b\x72\xdf\xbe\x59\x8d\xe5\xab\xfb\x8b\xc0\xbc\xe3\xff\x38\x2a\x68\x2e\x52\xd4\xae\x1a\x20\xab\x13\xfe\x8f\xd5\xd2\xbc\x59\x08\x63\x22\x1a\x40\x88\x0a\x04\xf9\x6a\x4b\x90\x77\x3c\x61\x45\x9e\xfe\xa3\x20\x62\x36\x1a\x31\x51\x0a\xd2\x56\x29\x7a\x27\xfa\x55\x14\xf3\x49\x2f\xe1\xb1\xe8\xfd\x75\x5a\xb0\x61\xfa\x99\x25\x9d\x2e\xa1\x39\xf9\x34\x11\x9f\x08\x3e\x92\xe0\x40\xfa\xcf\xcf\xd1\x15\xa2\xe4\xe4\x93\xec\xf5\x53\x35\x11\x2e\x06\x27\x5e\xa9\x20\x45\x2f\xdb\xad\x7a\xe5\xa7\xae\x0d\xcc\x12\xdb\x79\xe9\x6b\x4d\x2b\xfd\x32\x2a\xd0\x2f\xa0\x6d\xc8\xa1\x4b\x5a\x72\x40\x2d\xdc\xc0\xb5\x6d\x5e\xef\x67\xa3\xba\x43\xd7\x9e\xdc\xe1\x0e\x5d\xf9\x1f\xb4\x47\x41\x9d\x31\x9b\x4e\x59\x21\xb7\x93\xb3\xfd\xda\xc7\x5b\xab\xff\xf7\xa4\xd3\x1b\x5d\xbf\x05\x75\xbe\x9b\xeb\xf6\xdd\x4d\xb7\x9b\x7c\x29\x2f\x42\x72\x8b\x43\x51\x51\xcc\x9c\xd6\x85\xd3\xf9\x53\x7d\xd5\x3f\x99\x3b\x34\xde\x95\xe4\xd9\x23\x14\x73\xc8\xe6\x12\x1a\xba\x3e\x66\x19\x39\x67\x79\xc2\x0b\xb5\x03\x18\xe4\xd2\x88\xb3\x59\x92\xe6\x23\xd8\x1a\x77\x46\xf9\x21\x82\xc7\x47\x86\xca\x6b\xd8\x97\xd4\xfe\x60\xad\xd5\xa9\xa6\xb9\x5c\x48\xfa\x75\x8a\x5f\xfb\xf3\x4c\x6a\x3c\x93\x80\x78\xd3\x7f\x34\x1f\x49\xeb\xe1\x23\x69\xd5\x3f\x93\xde\xe8\x3d\x20\x37\x84\x59\x8a\x9b\x9c\x49\x7a\x20\xc1\x23\x09\x77\x42\x70\x93\xbc\xf1\x8e\xa4\x00\x94\xca\xc9\xe3\x00\xf1\xce\xaa\xc5\x20\x44\x18\x82\x7b\x52\x39\x07\xd2\x56\x9e\xa4\xe4\x70\x22\xb7\x98\x3e\x91\xe4\x1b\x7d\x28\x5d\x5c\x5c\x44\x34\x4f\x52\x21\x5b\xc0\xc1\x34\xc8\xf8\xa8\xb7\xfe\x64\x6d\xbd\xf7\x64\xdd\x9e\x59\xab\xfa\xa4\xea\xa9\xa3\x6a\x75\xf1\x59\x95\xc9\x3d\x02\x29\x89\xef\x62\xe7\xd6\xf1\x10\xd8\xc1\xba\x51\xbb\xb2\x95\xdd\x03\x0b\xce\xab\x86\x5d\x5b\xeb\xa4\xbe\x7b\xd7\xff\x3c\xaf\x9a\xcf\x2b\xdc\x6a\xce\xc6\x5c\x6d\x47\xde\x49\xd5\xb4\x31\xaf\x39\xa9\xcc\xba\xde\x70\x13\xde\x05\xc1\x2d\x73\x52\x78\xf3\x76\xad\x31\xa7\x5d\x12\x8f\x69\x41\xe3\xb2\x96\xf2\xde\x3c\xf7\xdd\xd6\xf1\x4a\xb4\x98\x3c\xeb\x54\xf9\xf4\x4e\xcf\x94\xc6\x7b\x98\x85\x3d\x2d\x78\xcc\x04\xa8\xd3\x56\xd4\xd5\x17\xfd\xf1\x54\x40\xf9\xdc\x5e\xd6\xee\x9f\x9e\x32\xf1\x0e\xc6\x72\xbf\xab\xdc\xa9\xb2\x19\xeb\x83\x3a\xcd\x5e\x8a\x4f\x41\x8f\x91\x88\xf5\x26\xde\x5f\x6d\x28\x2f\xcf\xa7\x10\x04\xce\xa7\xef\xb1\x99\x8a\xea\x6a\x1b\x58\xe6\x1b\x7f\x70\x4d\x7d\xbc\x6c\x68\xbf\xa8\xab\x0a\x64\x03\x61\xc4\xca\x03\xed\x62\xb6\x3f\x6c\xe8\xf0\xdb\x86\xe6\xeb\x0b\x3a\xf4\x5b\x1a\x00\x71\x46\x85\x78\x43\xb3\x0c\x2c\x4e\x4d\x33\xfc\xae\xa1\xfd\xa2\x19\x56\x20\x5b\x08\xe8\x3b\x28\xdf\x36\x75\x67\xaf\x90\x6e\xeb\x85\x9d\x39\x40\xcd\xb7\x53\x4c\xe8\xc0\xde\xf0\x5c\x94\xc5\x4c\x72\x27\x2c\x94\xdc\xd8\xef\xda\xf5\xdf\x2e\x1a\x45\x73\x87\x06\x6e\x9a\x8f\x59\x91\x96\xcd\x53\xaf\x37\x5d\xd4\xa3\x01\x67\xbe\x2a\x94\x0d\x3d\x08\xdc\x6f\xb5\x88\x5c\xa0\x81\xc5\x46\xc1\xa7\x47\xf3\x29\xd4\x86\x0a\x01\x7e\x52\x6f\xb9\x08\xb8\x69\x64\x3e\x1b\xc8\x23\xbf\x69\xd8\xcf\x9e\xbd\xac\x34\x5c\x04\x1c\x5b\x98\x0f\xca\x31\x9b\x30\x6d\x26\x68\xc2\xcb\xcb\xf5\x70\xfb\x45\xfd\x78\x0d\x1d\x2e\x43\x63\x30\x9a\x34\xce\xe5\xdb\x7a\xdb\x45\xdd\x98\x46\x1d\x37\x00\xb4\xa1\x35\x1f\xfc\xda\x21\x5f\xf4\x59\xc1\x07\xbf\x82\x4d\x62\xf0\x6b\x64\x99\x29\x79\x0d\xcf\xfb\xe4\x8b\xa9\x6e\x00\x0f\xae\x36\xc8\x95\x2d\xb4\xe3\x19\x10\x21\xcd\xb5\x3c\x7a\x3f\xc1\x9c\x3f\x19\x61\x18\x0a\xdd\xec\x6a\xf5\xa0\x14\x05\x74\x0b\x7a\x4e\xd3\x0c\x1c\xcf\xa0\xfc\xba\x55\x07\x43\x9d\xc3\x72\x4c\xf3\x33\xf0\x19\xc3\x87\x31\x66\x21\x89\x02\x5d\x2b\x5f\x09\x29\x2f\xb2\x02\xec\xfc\x03\x46\x20\xfe\x83\x96\xe4\xd1\x23\x23\x7e\xe8\x2a\x92\xce\xa0\x0b\xc6\x1e\x3d\x8a\xe0\x78\x96\xe8\x7e\x37\x4b\x8f\xe4\xe0\x0e\xd0\x28\xe0\xfb\x17\x9f\xc2\x40\x1e\x58\x4f\x24\x38\x71\xda\x4f\xba\xce\x36\x8c\x14\xbe\x3a\xed\x2a\xa8\x2e\xa9\x7d\x0f\x96\x6f\x03\xbf\xfa\x41\x5b\x65\x49\x89\xfd\xb4\xbe\xd0\x5f\x85\xc3\xda\x5e\xa5\x50\xd5\xad\x81\xd2\x8e\x03\xbd\x1e\xf9\x1b\xc3\x72\xf4\x7c\x56\xa2\x24\x37\x61\xd6\x97\x34\xd6\xa9\x74\x62\x9a\xeb\xca\xb9\xc6\xa6\x75\x0a\x02\xdb\x26\x0e\xa0\x99\xf5\x55\xc7\x52\x43\x44\x74\x7a\x0a\x6a\xf9\xd3\x53\x72\x79\x89\xd0\x2a\x27\x54\x33\x12\x3b\x1d\x54\xd7\x22\xe8\x0a\x82\xf4\x2c\x61\xa0\xd1\xa0\xe0\x34\x51\x0c\x03\x3a\x51\x5c\xc1\x02\x57\x2a\x78\x6c\x3e\xcb\xc5\x6c\x20\xe2\x22\x1d\xb0\xdd\xc4\x73\x5f\xc1\xf7\x80\x2f\x18\xcb\x75\x2f\x2b\xdc\x41\xf7\x17\xa5\x18\xf5\xd1\xd6\xc3\x35\xe1\x20\xda\x7c\x8a\xe6\x7d\x5c\x12\xc1\x49\x5a\xea\x65\x40\xaf\x60\x1d\xf1\x67\xe3\x31\x43\xb3\x8d\x04\x2b\x0f\x4b\x5a\xb2\x36\xbe\x98\xb0\x62\xc4\xf6\xe5\xf8\x7e\xe6\x31\xcd\x60\x90\xea\x15\xa6\xab\x85\xfe\x3a\x7e\x52\x55\x78\x6f\x62\xf6\x90\xe2\x9c\x33\x76\x11\x91\x1f\x23\x95\x9e\xb1\x79\x9f\xb4\x74\x39\x05\x95\x41\xa8\xd5\x55\xc4\x04\x32\x9a\x5b\xec\xc9\x6d\xd5\xf6\x0d\x5b\xa7\x05\x1b\x6e\x54\x5c\x12\xe4\x33\x28\x9b\xdd\xc5\xc1\x55\x44\x2a\x3b\x3e\xd9\xb0\x5b\x59\x91\xe8\xcd\x8f\x5b\x7b\x7b\x3b\x3f\x77\x89\x8f\xb9\xce\x72\xc0\x5a\x93\xca\x9c\xf7\xd1\x9c\xdb\xea\x3a\x36\x2f\x31\x66\xac\x14\xef\x68\x4e\x47\xac\xe8\x13\x07\xdd\xde\x9b\xae\xf9\x20\x49\x05\x64\x50\x93\xb7\x43\xf1\x37\x2c\xf1\x0a\x46\x55\xe7\xd3\x86\x36\xc6\xaf\xaa\xab\x70\x65\x3d\x35\x88\xbb\x18\x35\x8f\xef\x86\xe5\xa8\xb5\xab\x2e\x88\x1c\xd2\xba\x8a\x57\xd8\x70\x5c\xd7\x0e\xf5\x06\xd2\xd6\x23\x87\xc7\x74\x49\x3a\x24\xea\xe2\xa9\xbe\x08\x6e\xbb\xa6\xcd\x63\x5a\xc1\xd6\x8f\x0c\xa3\xb2\xdc\xd9\xee\x41\xd7\xf8\x88\x83\xf5\x37\xa8\xfd\x63\xc3\x75\xa7\x7a\xcb\x8b\x0b\x5a\x24\xae\x8f\x0d\xee\x45\x1d\xb4\xcc\xeb\x9b\xcf\xe9\xa2\x69\x07\xae\x2f\xd8\x82\xeb\xa1\x3d\x68\x5d\xe4\x16\x2d\xe2\xc7\x34\xcb\xde\xb3\x98\xa5\xe7\x40\xaa\xe2\xba\xc5\xac\xb6\x87\x9c\x70\x07\x7e\x4a\x12\x8f\x17\x69\x53\xa8\x8b\x03\xc7\x04\x5c\xe5\x20\x18\xc2\xa1\x61\xaa\x19\x39\x0b\xd1\xc4\xa5\x9a\x99\x54\x15\x58\x30\x7b\x47\x33\x72\x94\x23\xe5\x32\x78\x51\x4d\xdb\x95\x0c\x25\x75\xfa\x0c\x85\xa9\x34\x51\xac\xf3\x65\x85\x66\xeb\x80\x83\x51\x8a\xbd\x1e\xf9\xc8\x4c\x56\x48\xcc\xcc\x60\x65\x24\xf4\xf4\x72\xfd\xba\x28\xb8\xec\xce\xf2\x9c\xc9\xd3\x82\x42\xd0\xb6\x8a\x8e\x5f\xa9\xe3\x2a\x84\xf2\x16\xba\x76\xe1\x66\x86\xe8\x32\x02\xcd\x6c\x75\xee\x8a\xe0\x40\x73\xdc\x2e\x0e\xa5\x04\xb1\x1d\x5c\xdf\xcc\xfc\xf4\x28\xf0\x88\x13\x95\x67\x02\x17\x09\x75\x8e\xa8\x30\x62\x13\xe6\xba\x21\xa8\x08\x08\x0b\xa8\x31\xe4\xc1\x9c\x1c\xb6\x6d\xbb\x72\x72\xd7\xfd\xdf\xc0\x2b\xa5\xda\x6a\x11\xc8\x26\x0f\x3a\x38\x56\xb4\x6a\xc1\x9e\x27\xf2\xf8\xaa\x80\xef\x3a\xd0\x9a\x99\x00\xae\x6a\x03\x65\x9b\x70\xa4\x4a\x84\x89\xb3\x61\xfd\xaa\x09\xd0\xc1\x89\x5b\x20\xb0\x7a\xaa\x6f\xac\x5c\xa9\xcb\x9e\x25\x6f\x4f\x8a\xad\x89\x78\xaa\x95\x2e\x0b\x2b\x87\xd2\x78\xc2\xa1\x9f\xf1\x4a\xed\xd0\x04\xe1\xf3\x6a\x63\x25\x00\xde\xbd\x6a\x2a\x75\x51\xc4\xf2\xf3\x68\x6f\x7f\x7b\xe7\x74\x67\xef\x17\xd8\xa8\xf7\xa7\x05\x4f\x66\x80\x94\xfb\xe4\x35\x8c\x01\x6e\x2e\x84\x3c\x22\x7f\x07\xa7\xe3\x9c\x40\xac\xb8\xf5\x00\x92\x7b\x2c\x33\x45\x41\xd1\x74\x04\xf3\xfe\x8f\xb5\xe7\x5d\x42\xd1\x69\xd3\x7d\xfa\x02\xc8\xf1\x51\x6f\x85\x98\x73\xa1\xef\xde\x6f\x0d\xba\xc0\xfb\x36\x15\xea\x2a\x96\x74\x43\x83\x51\x18\x82\x1d\x35\x32\x08\x52\x94\x8f\xd6\x30\x4c\xce\x8e\xaa\x53\x74\x23\xc3\x01\xc8\x0b\x96\x12\x16\x67\x82\x0d\x67\x19\x56\x16\x2a\x0b\x0a\xde\x59\x1e\xe7\x80\xdb\x15\x9f\x95\x10\xcf\xa6\x80\xff\x78\xf4\xee\x67\x04\x64\x13\x3d\x88\x92\x4d\xf5\x49\x8e\xae\x30\xaa\xaf\x9f\x59\xd9\x12\x44\xd0\x39\xf8\x6e\x43\x70\x3e\x74\x81\xfe\x2f\x74\xca\xb3\x8c\x43\x5e\x97\xcf\x65\x01\xae\xb5\x78\x89\x78\x04\x90\x7e\x9b\xb1\x22\x65\x82\x4c\x68\xc2\xb4\x3c\x0b\xf7\xd4\x21\x8d\x4d\xec\xb6\x1c\x5a\xe4\x23\x47\xa4\xa3\x3c\x1d\xa6\x31\xcd\xcb\x6c\x4e\xc4\x94\xb1\x84\xcc\xa6\x28\x31\xe3\x2c\x69\xe6\x20\xc7\xb9\x7d\xaa\xf5\x69\xa4\xbf\xd0\x72\x0d\x38\xcf\xbc\x35\x3a\x92\x48\x70\xe9\x93\xa4\x02\xaf\x98\x25\x27\x09\x4b\x66\xd3\x2c\x8d\x21\x38\x1e\x8c\x96\xd0\x94\x98\x94\x4f\x5a\x09\x3e\xa5\x23\x66\x16\xac\x25\x9c\x0f\x25\xfe\x2c\x8b\x6f\x2b\x99\x09\xd7\xbc\x43\x62\x3e\x9b\x66\xfa\xcb\x7d\x77\x49\xc0\x09\xde\x5e\x80\x35\x21\xe7\xec\xc2\x64\x91\x43\xcd\x37\x8d\xc7\x10\x47\x08\x1e\x38\x1a\x27\x95\x1d\x17\xc2\x04\x96\xe2\xf0\x70\xb1\xa5\xb8\x3f\xbe\xb2\xd0\xe0\x69\x03\x94\x9c\xed\x0f\xe5\xb3\xf6\xf1\x82\x4e\x82\x9f\x4a\xc6\x76\xd2\x71\xf6\xce\xca\x15\xe9\x93\x2f\x57\x21\xb6\x13\x3b\xd7\x08\xcd\x1f\x16\x30\xdf\xa6\xa3\x3b\x76\x20\x20\xe7\x6d\x90\xf9\x17\xa1\x0c\xd5\xcf\xf5\x21\xfa\xa3\x5b\x66\x08\xe8\x9e\xb5\x95\x24\x84\x92\x8b\x82\x4e\xa7\xcc\x53\x61\x70\xcd\x2c\xb0\x48\x3d\x19\xb3\x4c\xb6\x98\x48\x21\x60\xc4\x84\xa6\x3d\xc7\x91\x4e\x82\x63\x8e\x4f\x25\xfc\x2d\xb2\x34\x2f\x57\xd5\x2e\x59\x95\xc2\xd7\x6a\x96\xe6\x4c\x55\xc1\xef\xe5\x7c\x75\x32\x03\xdf\xe9\x55\xa5\x7e\x0f\x2a\x4c\x3e\xaa\xf1\x6d\x06\x0e\x11\xf0\xbb\x6d\x64\xd7\x2d\xcb\xae\xd5\xc1\xdd\x0c\xbb\x51\x67\xa2\x9a\xb4\x43\xf5\x59\xaa\x27\x98\x5f\x8f\xab\x7e\x93\x75\xea\x36\x6d\x34\x8f\xc6\x3b\x8b\x14\xad\x69\x8d\x5d\xf3\x3d\xd9\x7e\xd5\x25\xad\xea\x4b\xe5\xf3\xa2\xd0\xac\x81\x04\x50\xaa\x86\xb0\xd0\xae\xf2\xb5\xfe\x6d\x6b\xcf\x6e\x65\xf7\x09\x9b\xd8\x9f\x77\x36\xea\xa6\xa7\x50\xd3\xf5\xa7\x9d\x48\xd9\x7e\xa8\x90\xac\x5f\x59\x34\xdd\x01\x3e\xbf\xd5\x00\x7b\x3d\xb2\xf6\x5d\xb4\x16\x3d\x8d\xd6\x88\xd7\x53\xbb\x84\x20\xb9\xae\x32\x4d\x76\x80\xcc\x1f\x28\xf7\xc7\x86\xd1\x82\xea\x59\xb5\x69\xab\x7f\xa3\x43\xf2\x58\x7f\x17\xbd\xed\x92\x16\xf6\xd2\xea\x92\x2f\x04\x7b\xea\x37\x38\x22\xbc\xe8\xc0\x0d\xb0\x36\xe1\x17\x77\x69\x1f\xd6\xf3\x5f\xbf\x66\xfe\x5d\x12\x45\x11\x22\x61\xc4\xca\x9f\xd8\xbc\x69\xc9\xbe\xfd\xae\x83\x55\xda\x47\xfb\x07\x87\x4d\x3a\xf4\x17\xcf\x54\xa3\xe9\xee\x4e\xa3\x7d\xe5\x85\x6a\x53\x72\x1c\x58\x93\x45\xed\xa9\x6a\xb7\xbb\xb0\xd9\xda\xf3\x97\xaa\xdd\x03\x9c\xa0\xf5\xa8\x35\xa4\xd5\xeb\xe9\x23\xd4\xfa\xae\x8a\xf9\x64\xc0\x33\x15\xb2\x8f\x2f\x21\x04\x27\x61\x25\x2b\x26\x69\x0e\xc9\xa4\xac\xcb\x07\x5e\xc3\xda\xbf\x7c\x4b\x06\xb3\x51\xa7\x4e\xe5\xf7\x74\xef\x97\x97\xc1\x61\xbe\x58\xeb\xd4\x22\xf7\xe4\xa0\xb7\x40\xcf\xb5\xa1\xfe\xfa\xc1\xfc\xb5\x88\x65\xe7\x7c\x15\x72\x98\xa8\x8f\xe4\x6a\x1c\xc2\x6c\x50\xe5\x29\x9f\xfd\x44\x36\x49\x8b\x0e\xe2\x84\x0d\x47\xe3\xf4\xd7\xb3\x6c\x92\xf3\xe9\x6f\x85\xc0\xda\xcb\x5b\xc7\x87\x27\x64\x93\xbc\x94\xbf\x7f\x8a\xc4\x34\x4b\xcb\x76\xab\xd5\x89\x86\xbc\xd8\xa1\xf1\xd8\x19\xe8\x59\x87\x7c\x21\x3f\x1c\x9f\xc9\xe6\x67\x1b\x4a\x73\xa1\x18\xae\x9a\x31\x1c\xb5\x5b\x1d\x09\xf2\xde\x26\x79\x29\x11\xe0\xc6\x74\xbb\xad\x7e\xe8\x74\xa2\x5f\x79\x9a\xcb\xce\x64\xe3\x9f\x36\x56\xae\x3a\xe4\xb5\xe5\xf7\xe1\x2d\x4a\xbe\x04\xd0\x61\x31\x21\xc5\xb4\xd5\x73\x5a\x08\x35\xf7\x23\xb2\x69\x68\x4b\x81\x32\x78\xa1\x3f\xb3\x3c\x90\x2b\x46\xbf\x06\x57\x7c\xb2\x49\xd6\xf4\x83\x11\x2b\x0f\x15\xa1\x6c\x02\xe5\x47\x43\xd3\x56\xec\xe4\xb3\x89\xbc\xa1\xec\xee\xe0\x53\x95\xea\x0b\xfa\xf8\x1e\x61\xb9\x41\x23\x72\x9d\x14\x2d\xb7\x6d\xde\x19\x68\xf6\xf8\xf1\x89\x93\x82\xf0\x0c\x77\xa1\xd3\xf7\x6b\xbd\x39\xdb\x87\x1d\x29\x3b\xc4\xb4\x6c\xdb\xd7\xed\xc3\x4e\x07\xcb\x5c\xab\x26\x16\x94\x4a\x85\xb3\x09\x30\x9d\xc9\xe2\xdb\x5f\xc9\xa6\x5b\x67\xfc\x8c\xcd\xf1\x0f\x35\x11\x93\x47\xe7\xd7\x0e\x66\x36\x80\x19\xe3\x81\x73\xd8\x55\x69\x77\x24\xe0\xe3\x5f\xe5\x04\x3a\xe4\xe8\xf8\x8c\xcd\x25\xa9\x1c\xc2\x0f\x4c\x2e\xa4\xa8\xe5\x68\x03\x04\xbb\x07\x8d\xfc\xfe\xe5\x6d\xf9\x3d\x5c\x34\xc9\xea\xf7\x64\xab\x28\xe8\xfc\xaf\x2a\xac\x42\xbe\x81\x64\xb4\xee\x9b\x38\x9b\x25\x4c\x28\x2e\xb4\x98\xbf\x80\x59\x10\x1b\xfe\xac\x91\x19\xe6\x6b\xcf\x4c\xc3\xad\x81\xe0\xd9\xac\x64\xbb\x8a\x9c\xc2\xe7\xc0\xb7\xa1\xd3\xd2\x6e\xbd\xdd\xc3\xd3\xdd\xbd\x37\x3f\x7f\xd8\xde\x39\xf4\x3c\x48\x6c\x8b\x07\x68\x26\x61\x59\x17\x4c\x3c\xbb\x55\x82\xdb\x87\x8d\xa0\x49\x0e\x5a\x87\x48\x43\x4f\xac\xbd\xaf\x08\xc4\x69\xa4\x37\x44\x65\x4e\x6d\xd3\x5f\x97\xd4\xbe\x01\x8d\x85\xb1\x7e\xf8\x28\x97\x77\x2a\x41\x0e\xe9\x04\xcb\x5f\xfd\x5f\x56\x70\xc2\x7e\x9b\xd1\x2c\x2d\xe7\x84\x66\x23\x5e\xa4\xe5\x78\xa2\xbf\x5d\xc4\x01\x05\xcb\x86\xab\x52\x4c\xa6\x05\x33\xa1\x3b\x0e\xce\xc8\xc3\x87\x84\x65\x92\xcb\xb0\xac\x53\xa3\x68\x6f\x73\x2a\x25\x8b\x3c\x38\xcc\x76\x74\x82\x69\x6e\x34\x0a\x1c\x07\xc2\xbb\xb7\x89\x80\x3b\xf5\x58\x64\x07\x31\x40\xa5\x24\x1d\xe5\xbc\x60\x82\x8c\x79\x26\x85\xc6\x0a\xd6\x56\x49\xce\x4b\x37\x88\x59\xde\xf9\xda\x1b\xfe\x74\x36\x88\x1a\x7c\xa7\x86\x0b\x28\x5d\x23\x57\x32\xcd\xc9\xbe\xaf\x06\x55\x53\x3e\x01\xdd\x9a\x44\x95\x1a\x6b\xf0\xf3\xcb\x4b\xcd\x2f\xcc\xbe\xbe\x57\xc1\xf9\xea\x9a\x8e\x5c\x0b\xec\xf1\x6f\x6f\xb5\xc7\xd5\x76\xcd\x4b\x36\x6a\x36\xe3\xbf\x78\xa2\xb6\xe1\x84\x4a\xc2\x7d\x47\xcb\x71\x34\xa1\x9f\xd5\xb3\x34\x37\xcf\xd2\x7c\xe1\xf6\x4b\x3d\xea\x06\x94\xd9\xcd\xa0\xc6\x80\x8d\xdc\x33\x11\x9b\xbc\x22\x4f\xc8\x6b\x39\x00\x6c\x40\x1e\x2b\x30\x5d\xf2\x44\x32\xea\x49\x9a\x57\xc0\x87\xb1\x75\xbb\x10\x94\x20\xd3\x59\xd7\xd8\x79\xb0\x90\xe9\x59\xf9\x7c\x11\x8e\x2a\x6e\x5b\x69\x09\x67\x42\x97\x24\x4c\xc4\x1e\xcb\x7a\x10\xf6\xf3\xf2\x3f\x08\xe2\x60\xfd\x76\x4e\xfe\x4b\xca\xf6\x56\x58\x7e\x46\x7a\x64\xed\x79\xb4\x1e\x3d\x8d\x5e\x90\xf0\xa8\xf7\xbb\xe4\xa0\x4b\x4c\x3e\x4d\xd1\x59\x7c\x33\x20\x8f\xc8\xbd\xe0\xa5\xec\x65\xc7\xbf\x34\xf8\xdd\x84\x2f\x0f\x4f\xd7\x3b\xd1\x30\x78\x7b\x58\xbf\x9d\x6f\x78\x98\x58\xd6\xbf\xe2\x3e\xe7\xdb\xfa\x03\x03\xbd\x9d\x1b\xac\x5d\xaa\xef\x48\xb0\xc7\xf6\x7e\xe7\x46\xb7\x8b\x07\x4b\x79\xdb\xad\x3f\x03\xf7\xa6\xf0\xab\xb5\x4e\xbb\xe5\x43\x69\xd5\xf3\x6a\x54\x4f\xef\xca\xa8\xd3\xb2\xa2\xce\xa8\x8c\xab\x6d\x24\xda\x54\x25\x45\x92\x2c\x36\x44\x08\xb7\x73\xe8\xac\x2d\xf7\x17\x72\x5f\x69\x28\xee\x37\x5c\x68\xd7\x9f\x75\x24\x3c\xed\x5c\x84\xde\x99\x72\x78\xd5\x91\xdd\xbd\xca\x61\xed\x85\xbc\x4c\x86\x57\xe5\xe9\xb2\xc4\xbb\xf6\xe2\xbb\x4e\x34\x6c\xb7\xd2\x92\x15\xb4\xe4\xa0\x9f\xa9\x8d\xfd\x76\xda\x88\x9b\x9d\x5c\x3a\x3d\x65\xd3\x85\xf7\x3b\x64\x59\x46\xaa\x3d\x04\x9f\xe2\xbf\xd2\xd2\x93\x82\xd5\xd3\x98\x27\xec\x80\xa7\x79\xb9\x55\x2e\x3a\xee\x8e\xf6\x4f\x0f\x8f\xde\xef\xee\xfd\xad\x41\xd6\x2c\xc7\xb4\xec\x92\x29\xf7\xc2\xe0\x25\x08\xec\xa6\xad\xc6\x0c\xed\x3a\xae\x00\xe9\x9d\x97\xf2\x7b\x47\x02\x25\x9b\xa4\x7e\x29\xa1\x5d\x32\x70\xb2\xa9\xc1\x61\x2a\x05\x10\xf2\xfd\x26\xb1\xe2\x89\x19\x2f\x79\x4d\x5a\x2d\xd2\xb7\x59\x3d\xf1\x5b\x0a\xb0\xe3\x31\x2d\xde\xf0\x84\x6d\x95\xed\xd4\x77\x81\xa1\x12\xee\xe7\xe4\xdb\x27\x00\x9c\x92\xef\xe5\x5f\x83\xe1\x10\xbb\x7a\x4c\xd6\x40\x1e\xca\xc0\x85\x69\x50\x83\x25\x1b\x74\x3a\x08\x22\x46\x10\x03\x04\x31\x1c\x0e\x95\x70\xf5\xda\x1b\x23\x7e\x0f\xe3\x20\x7d\x42\x55\x9b\x7e\xa5\x8d\xc8\xd2\x98\xb5\xd3\x2e\x0c\x61\x5d\xb6\x6c\x53\xb2\xaa\x07\xfa\xea\x15\x59\x7b\xd2\x21\x8f\xe5\x88\x56\x55\xd7\xf2\xcf\x27\x9f\xd7\x9e\x3c\x79\xf2\xa4\x59\xee\x5a\xbf\x53\xd5\x12\x44\xdb\x80\x72\xb5\xf1\x2a\xf4\xad\xa1\x64\x4c\x58\xce\x9b\x88\xfe\x5b\xdd\x52\xb0\xf2\x88\x23\x2d\x1d\xd1\x51\x23\x60\xad\x84\xda\x55\x7b\xd5\x70\x48\xa5\x38\x91\x3b\x60\xfd\x39\xea\xbd\xa2\x35\xf2\x4d\xad\xdd\x37\xc7\xff\xf1\x1f\x7a\xa3\x9f\xb4\x3b\x41\xde\xf1\xfc\x49\xa7\x5d\xfb\xb0\x41\xb5\xfa\xa4\xe3\x32\x8e\x0a\xdb\x77\x6d\xb3\xa8\x3c\x59\xb4\x05\x1d\x5f\xbb\x2e\xd9\xdb\x7a\xb7\xd3\x05\x87\x0b\xdc\x70\xce\x4b\x9b\x7f\xd4\x14\xe4\x0e\x0d\xf7\x0b\x7c\xdd\x77\xd6\xa0\xbd\xa6\x21\xa2\x1e\xc7\xc7\x79\xbd\x7f\xf2\x98\xb4\x0c\xa6\x5b\x0d\x02\xda\xed\xae\xed\x40\x24\x07\x0d\xcb\xfd\x54\x5f\xbd\x69\xbe\xf0\x2c\x37\x8c\x73\x09\x0d\xe6\x72\x47\xc2\xd3\x97\x1d\xf2\x3a\x28\xff\xa5\x4c\x90\x7e\x83\x08\x9c\x32\x01\xd2\xa1\xf9\x0b\x97\x4e\x8f\xbe\xbd\x6f\xd4\x50\x56\xc3\x03\x1a\x1b\xe7\x0b\xdd\xa2\x49\x71\xa3\x79\xea\x13\xfd\xc7\x81\xa3\x79\xb2\xf7\xc1\x0e\x49\x0e\xa2\x21\x8c\x46\xeb\x68\xd2\xc7\x8f\x4f\xdc\xc1\x1d\x1f\x78\x4e\x01\xfb\xe1\xe5\xbd\xfd\x8d\x4d\x97\x44\x68\x42\xf5\x8b\x4e\xa4\x9b\x04\x0e\x6c\xf3\xf5\xc3\x87\xb6\xb8\x82\xfe\x61\x52\x75\xd6\x86\x7d\x97\xd1\xfb\x48\x82\x49\x72\xc4\x3f\xe4\x22\xe6\x53\x3a\xc8\x1a\x9d\xe0\x9f\x3d\xd5\xb4\x08\xe6\xf5\x26\x61\xf2\x59\x85\x8d\x35\x81\xfb\xee\x89\xd1\x29\x2d\xa1\xa5\x02\xe6\xb7\x0e\x46\x8f\x67\xa8\x41\x70\x52\x15\xb3\xbc\x2c\x24\x81\x76\x9c\x56\x6b\x4f\x6b\xcd\x40\x67\xeb\xb6\x59\xff\xae\xd6\x06\x94\x1a\x7e\xab\xa7\x4f\xaa\xad\x2a\x7c\x76\x49\x49\xec\x65\xa7\x0d\x70\xba\xa4\x05\xff\x7a\x82\x34\xc2\x63\x49\x97\x9c\xa5\xb9\x2a\x98\x80\x49\x95\x4b\x4f\xd3\xa5\xdb\x75\x36\x88\x14\x93\x40\x03\x6c\x9a\xe2\xe6\x21\xf5\xff\xf5\x7a\x58\xf6\x14\x6e\xe6\xa6\xf9\x99\xdc\x3e\x69\x9e\xd4\xbe\xe8\xf5\xe0\xb9\xc1\xc1\x73\x30\xb5\x7c\x03\xa3\xae\x9f\x3a\x50\x45\xb5\xdd\x59\xb9\xaa\x5f\x0c\x8c\xa6\x0e\x67\x62\x58\x44\x9a\x27\xe6\xe9\x59\x55\x41\xad\xe6\xf2\xf8\xb1\x29\xa4\xb1\x6f\xb5\x34\xdf\x6f\x12\xa3\xca\x53\xd2\x9a\x45\x53\x45\x4e\x32\x61\x69\x6c\x0a\xa1\x21\xe8\x2f\x24\x21\xe2\x00\x36\x49\x4b\x92\x44\xab\xe3\xb5\x7c\xd2\x25\x56\xf5\xe1\x35\x46\xda\xa8\x37\xd7\x6a\x26\x97\xe5\xe8\x77\xc7\x4a\x19\xa2\xdb\xc8\x46\x57\x5d\x0b\x0b\x29\xdb\xa8\xcc\x7f\x4e\x45\xe9\x52\x17\x49\x85\xc2\x3b\xe0\xfb\x14\x3f\xfb\x86\xb4\xbf\x8b\x9e\x45\xcf\xa2\x17\x5d\x82\x3f\x5e\x76\x56\xcc\x7e\x8b\xb6\x34\x34\xb2\x49\xdc\xa7\x05\x9d\x6f\xac\xac\x54\x77\x7b\x5b\x21\x61\x23\xf0\xc6\x8e\xb2\xfe\x4e\x6d\xba\xd0\x8d\xe2\xe9\x32\x9a\x8d\xf0\x95\xcc\x97\x31\x7a\x8f\x54\x85\x25\x09\x3c\xd0\xcf\xed\x14\x03\x5f\x71\x1f\x7c\xba\xbe\xdc\x7d\xf0\xe9\xed\x34\x01\xe1\xbe\x9f\x36\xde\x07\xbf\x6d\x78\xf3\xec\x69\xd3\x1d\xf2\xd9\xd3\x97\x37\x51\x80\xa0\x35\x26\xb0\x02\x77\x19\x62\x29\x77\xc2\xce\x9b\x77\x5b\x87\x20\xd3\x91\x17\xc6\x8e\x29\xc6\xe9\x04\x85\xa0\x8c\x0f\x68\xd6\x7c\xda\xe2\x81\x32\xa6\x4d\x53\x79\xa1\xa5\xae\xed\x9d\xc3\x37\xef\x77\x0f\x8e\xf6\xdf\x37\xd9\x7b\x9f\x1a\xd3\xeb\xf5\x3a\x36\xcc\x0a\x84\xbc\xa7\xf1\x5c\xd4\x5d\xbf\xdb\x39\xda\x6a\x8c\xd3\x7a\xd2\x89\x7e\xda\xf9\xbb\xea\x78\x48\xd3\xac\x71\x26\x6b\xfa\x2c\x1e\xd3\xa2\xf9\x3e\x6d\x26\x7c\xc3\x3b\xc8\x2c\x6d\x04\x09\x9e\x10\x90\xe0\xfe\xac\x51\xc4\x7c\x62\x9b\xec\x7c\x6e\xb4\x6e\xbf\xf8\xce\x36\xdb\x5e\x84\xbc\xb5\x97\x7a\xb6\x2c\x9f\x4d\x16\x88\xc1\xcf\x9e\x6a\xe9\x23\x15\xc0\xef\x1a\x57\xe3\xf9\x0d\xc5\xef\x1b\x98\xd2\x0e\x8a\x74\x92\x96\xe9\x79\xe3\x6c\x9e\x6b\x42\xc5\x0b\xce\x36\x13\xf1\x75\x57\xc8\xd3\x25\x2f\xa5\xa3\xfd\x83\xbd\x66\x8c\x3f\x7b\xaa\xa7\xfd\xe0\x6f\xfb\x07\xdb\x8d\xc8\x31\xa4\xbf\x7d\xed\xf5\xe5\xc1\xd9\x72\x6e\x15\xb2\x33\xe8\x34\x1a\x6e\xd8\x9b\xd1\x83\xed\x03\xfd\xb7\x1c\x39\xda\xa1\xe5\x04\xf4\xd3\x07\xc8\x78\xe4\x0b\xd8\xfa\x86\x11\xc1\xcb\xff\x3c\xdc\xdf\xb3\xaf\xe4\x5f\x0a\x5b\x18\x89\x9e\x0e\xe5\xfa\x63\xab\x87\x0f\xf1\x47\x64\x5e\x61\xd3\x83\xf7\xfb\x47\xfb\x47\x7f\x3f\xd8\x21\xe8\xc6\x85\x32\x4d\x0b\x5f\xfe\xb8\xbb\xbd\xbd\x23\x7b\xb8\x38\x13\xed\xd6\xe9\x38\x4d\x12\x96\xb7\xd4\xa4\x8e\xf6\x4f\x0f\xde\xef\xbe\xdb\x3d\xda\xfd\x65\x47\x37\x71\x16\xbf\x65\x08\x51\x99\xd2\xbf\x5c\x45\xda\xe3\x62\x17\x9e\x41\xbc\x1f\xc3\x56\x38\x2d\x9d\xb1\x92\x6c\xaa\x6d\xdd\x6e\x21\x0b\x5c\x2d\xd4\x1b\x0d\x75\x2b\xcb\xac\xed\xde\x6f\x2b\x74\x9b\xfd\x83\x7a\x13\x3e\x5d\xad\xb6\x02\xaa\x06\xe9\xc2\x78\x97\x1c\x1b\xac\x9c\x60\xa3\x0f\x87\x3b\xa7\x7b\x5b\x6a\xa6\xca\x75\xdd\x2c\x8d\xeb\xb6\x8e\xcd\xff\xcb\x6c\x15\xb5\x34\xff\xa5\x0d\x2e\x26\x7f\x1f\x30\x7e\x48\x93\x07\x5e\x7e\xff\x55\x12\xe4\xfa\x5d\xa2\x13\xd3\x8d\xd2\x72\x3c\x1b\x40\xe6\x8d\x7f\x64\x3c\x2d\x78\x7c\xd6\x8b\x79\xc1\x56\x7f\x15\x3d\x2c\xef\xd6\x5b\x7b\xf9\x54\x33\xb7\x12\x74\x8f\xf7\x74\xcf\x97\x97\xe6\xb7\x33\x99\x86\xc7\x50\xb5\x00\xc2\xb8\x36\xb4\xb1\x1d\xb2\x9f\x83\x25\x92\x67\x09\xd9\xca\x93\x82\xa7\x89\x1d\x5b\xcc\x13\x16\x8d\x38\x1f\x65\x0c\x06\x38\xed\x9d\x7f\xab\x07\x95\xb0\x92\xa6\xd9\xeb\x34\xd9\x7c\xf1\xed\x4b\x3d\x3c\xc4\x95\xda\xe9\xee\xe1\x23\xe9\x12\xf8\x7c\xcd\x83\x46\xbb\xfe\x29\x2d\x48\x72\x00\x6e\x26\x2d\x6a\x82\xb5\x46\xac\xec\x87\x75\x32\xc9\x81\x8a\x32\xc4\xd6\xda\xcf\xfe\x25\xb9\xea\x44\x74\x03\xbd\xe6\x3b\x9d\x88\x82\x53\x4b\xd5\x4f\xc5\x9a\xae\xb6\xad\x10\x0f\x3b\x43\x0d\x5f\xee\xe6\xb6\x43\x36\xba\xf2\x0e\x4a\xcb\xa6\x65\x87\x24\x50\x31\xda\xa5\x30\xe3\x3a\x91\x1c\xb8\xdd\xd4\xbe\x85\x7c\xcd\x25\xf8\x56\x3a\x5f\xcb\x8b\x7f\xad\xe3\xae\x1d\x5b\x07\xdd\x30\x92\x03\x5d\x6e\xb6\xa0\x53\x4f\xa4\x2c\xe9\xc8\x4e\x49\xcc\xe5\xae\xb4\x1b\xe9\xb8\xa4\xa3\x13\xc9\xc9\x14\xc2\x15\x7d\x3b\x74\x82\x8a\xa5\xf9\x04\x6f\x4e\x25\x1d\xb9\xf2\xfe\x7c\x62\x0b\xd6\xa4\xc2\xb0\x2d\x67\xe7\x3c\x7c\x58\xd9\x3a\x91\x16\xf3\x61\x0f\xe1\xbe\x6c\x55\x96\xc2\xa3\x05\xf5\x79\x5a\xba\x1f\xe0\xa4\x1b\xbf\x49\x4b\xe3\x4d\x6d\x7b\xb6\x43\x7d\xe0\x9b\xe6\x96\x31\x81\x2a\xb2\x00\x0d\x76\x09\xaa\x64\x6f\x8d\x1e\x54\x6d\x8a\x9a\x0d\x79\xcb\x6d\x14\x47\x29\x3a\x30\xa1\xc3\x8d\xc3\x3f\xdb\xd0\x18\xca\x26\x7b\xed\x2d\xb5\x8c\xa9\x68\xdb\xe5\x43\x2a\xec\x38\x65\x77\xef\x6d\x47\xcc\xb0\x59\xdf\x31\xe0\x9e\xfc\x56\x4e\x08\x39\x7c\xa7\xa3\x09\x12\xff\xee\x3a\x27\x73\x7b\xad\x4b\xbe\x5c\xd9\x08\xae\xb4\x3c\xc6\x46\x27\xda\x21\xa8\x31\x0b\xbb\x1e\xa4\xd3\x11\x12\xb6\x07\xa1\x13\x00\xe9\x55\x61\xdc\x76\x88\x72\x5b\x6e\x67\x3b\xab\xbe\x3b\xd0\x27\x2a\xef\x7d\xc7\x06\xe1\x19\xea\x74\x39\x50\x75\xe7\x5d\x39\x6c\xc3\x7b\x75\xb5\x11\x20\x91\x94\x35\xdb\xc9\x53\x86\x93\x3d\xa8\x28\x07\xd3\xb2\xaa\x1d\xd4\x72\x5c\xfb\xc0\xd3\x6e\x1c\x74\x3a\x41\x45\x60\x16\x56\x16\x2a\xa7\x2e\xad\x21\x44\xe5\x60\x95\xfe\xd4\x94\x2a\xaa\x42\x44\xbd\xeb\xdd\x50\xda\x09\x1b\x61\xab\x92\x3d\xd9\x9d\x9c\xfa\xec\x00\x36\x80\x5b\x76\xed\xd4\xb4\xed\x90\x7e\x1d\x79\x6d\xe7\xbd\x04\x66\x7b\x0d\x49\x07\xee\x18\x42\xef\xe5\x2e\xb1\x2c\x4d\x9e\xce\xae\x23\x1b\x1e\x02\x8b\xb6\x96\xd9\x4c\x18\x20\xef\xef\x65\x5d\xc5\xa4\xba\xc9\x20\x47\xbe\x7c\xe1\x6f\xed\x4e\xa7\x96\x76\x5d\xfd\x8d\xe5\x6a\xe5\x17\x66\x44\x1d\xf3\xa8\x06\xfd\xf2\x92\xd8\xa6\xce\xbe\x91\x0f\xfc\x8d\xf2\x9a\xec\x90\xbe\xda\x7f\x57\xd6\xe4\xbd\x7f\x91\xeb\xd5\xdf\x76\x8d\x34\xae\x7d\x3a\xd8\x46\xd3\x8a\x62\x70\x55\xcd\xdb\x52\x8c\x2a\xcc\x16\xbf\x16\x95\x9a\xd2\xb7\xf5\xb9\xab\x47\xa8\xbb\xda\x5e\x08\x79\x19\xf6\xd3\x21\x2e\x9f\x74\xf8\x99\x2e\xef\xd4\x84\xdb\x3d\x3a\xf1\x79\x41\xe0\xb5\x39\x8d\xe4\xf7\xb9\xfa\x40\xca\xf8\x6d\x0f\xb1\x66\xd7\x17\x4c\x60\xbc\xc0\xf1\x49\x90\x11\xf8\x3b\x1e\x00\x46\xae\x65\xc0\xe1\xfe\x01\xa4\x90\x4d\x1c\x03\x30\x01\x40\x86\x7c\x78\x6f\x53\x0b\xfa\xf6\x81\xbc\xa4\x77\xd4\x68\xa2\xe9\x4c\x8c\xdb\x1a\xe9\x57\xb6\xdc\x8e\x7c\xd9\x84\x1c\x2b\x7a\x37\xa0\x47\xfb\xb7\xba\x08\xda\x3d\x3c\xdd\x97\x0c\xb1\x4e\x3f\x1b\x21\x14\x62\xf3\xd7\x8e\xa0\xdf\x27\xbf\x37\x5a\x97\xc2\xaa\x19\x19\x50\x76\x55\x52\x54\x5b\xb6\xe3\xe3\xd7\x11\xc4\x0c\x6b\x0e\xe1\x5a\x79\xc9\x3c\x03\x1b\xa8\x72\x0d\x3f\xd6\x76\xc0\x94\xe7\x27\x1d\x88\xd5\xb9\x67\x05\x2f\x1c\xbe\xbd\x49\x9a\x05\xd1\x8e\xe5\xce\xf4\x80\x0d\xd6\xe5\xa5\x8e\xaa\xad\x75\x34\x9f\xb2\x9d\xa2\xe0\x45\xbb\xa5\xc0\x99\xba\x1b\xb1\xb5\x30\xde\x6b\x39\x8e\x00\x25\x68\x5b\x66\x69\xd2\x0e\x14\xf1\x7c\xe2\x95\xe9\x7c\x72\xe2\xda\xfa\x1d\x18\x0f\x04\xf3\xeb\x30\x2a\xd7\xcb\x6a\xc8\x77\x40\x18\x13\xac\xc4\xb3\xc0\x61\x30\xf8\xf5\x46\x45\x4a\xa9\xf1\x5b\xfd\x50\xb3\x8b\xae\x9c\x4b\xa7\xe3\xf3\x61\x25\x34\x7b\x02\x8b\x2f\x6d\x20\xdc\x92\x8e\xaa\x52\x15\x0e\x43\x8b\x2a\xd6\x2d\xa2\x72\x3d\xc2\xcb\x5d\xa7\x02\xd5\xa3\x2a\x00\xfe\x45\x2e\xc1\x30\x1d\xcd\x94\x64\x84\x75\xca\x84\xbc\x24\x01\xfe\xae\x7c\x27\x09\x79\x39\x80\x0b\x81\x89\x92\xd2\x1a\xbc\x80\xe4\xdf\x25\xad\x52\x69\xcf\x5c\xab\x8d\x7e\xd6\xae\xf8\x37\x39\x86\x8d\x2b\xcc\xec\xa2\x54\x1f\x64\xb3\xf9\x80\x92\xad\x41\x1f\x22\x1b\xf9\x32\xcc\x06\xd4\xe7\x08\x69\x6a\x5e\x74\xa0\xbd\xd1\x9a\xd4\x3b\x00\x36\xdc\x04\x60\x6d\x4d\x01\x08\x0a\x1f\x8d\x5f\xbd\x78\xd6\x09\x75\xa5\x08\x0c\x26\x1c\x58\xc8\xa0\xab\xe0\xda\x8b\x6f\x3b\x16\x7b\x6a\x01\xbc\xc5\x6d\x85\x86\xd6\xea\x86\x87\xec\x1c\xc4\x10\xc9\x8e\x0a\x48\x18\xac\xdd\x3d\x92\x5b\x55\x56\x0c\xa8\xe1\xe2\x4c\xe0\x3b\xa7\x40\x45\xd5\xff\xf1\x6f\x8e\xff\xe3\xc7\xaa\x2f\xa4\xe5\x39\x92\x1c\x11\x1d\x7d\xc3\x79\x80\x14\xc0\xb9\x19\x34\x99\xe2\x85\x3d\x23\xda\x18\x15\x03\x7c\x6d\x3d\x5a\xef\xea\x5f\x4f\xcd\xaf\x67\xe6\xd7\x0b\xf3\xeb\x5b\xf3\xeb\x3b\xf3\x6b\xed\x89\xfd\xb9\x66\x7f\x5a\x90\x6b\x16\xe6\xda\xb3\x15\x42\x5a\x63\x2a\x74\xad\x8c\x2e\x94\x08\x8a\x69\x79\x38\x2d\x18\x4d\x00\xa1\xfa\x8e\xda\x9d\xd0\x32\x1e\x77\x55\x72\xc7\xae\x60\xb4\x88\xc7\x5d\x31\x65\x71\xca\x44\x17\xe2\x6c\xba\x8e\x54\xd4\x2d\xad\xb6\xb9\x3b\xb3\x76\xa3\xd6\x4a\x47\x07\xe5\x74\x5b\x9d\xae\x0a\xd3\x70\xb0\x61\x99\xe3\xaf\x1b\x1d\xb9\x22\xf6\x15\x86\x62\xb8\x48\xbc\x60\x59\xf6\x53\xce\x2f\x72\x8b\x4a\x50\x48\xca\xa5\x8c\x44\xc9\x0b\xd6\xe9\x92\x33\xec\xa2\xda\xd6\x76\x74\xb6\xd1\xb1\x2a\xe8\x76\xb5\xdd\xf1\x99\xea\xf5\x5a\x57\x58\x77\xf9\xd5\xf9\xa0\x94\x35\x76\x6d\xf5\x99\x15\x0d\x79\x01\x32\x85\x5c\x82\x21\x2f\x5a\xee\x15\xde\x88\xa0\x36\xeb\x38\x15\x6d\x5f\x47\x88\x47\xef\xe3\x4d\xd2\x6a\x75\x8c\x57\x96\xdf\x04\x0e\x52\xe3\x8d\x15\x78\x27\xd1\xa5\x0e\x41\x23\xde\x74\xbd\xe1\x3e\xd7\xc3\x3d\x63\xf3\xb7\xbc\x68\x8b\xf9\xa4\x83\x42\xf0\x5b\xee\xd6\x50\x74\x5e\xbb\x32\x98\x56\x84\xc0\x8b\xfa\x21\x2a\xe6\x13\xf0\xc3\x31\x87\x28\xaa\x34\xcc\xf9\x69\xd6\x59\x4e\x35\xcd\x2b\x53\xc0\x50\x80\xe0\xb4\x36\x37\x09\x0c\x45\x61\x4f\x89\x37\x58\xc8\x50\xb0\x43\x38\x51\xaa\xba\x33\xa3\x44\x04\xf9\xd7\x36\x86\x64\x22\x8d\x8d\xf1\xe0\x23\x57\xe8\xaf\x7a\x33\x12\xb1\x0e\xd2\x06\xe7\x6b\x72\xfb\x6b\xe7\x1c\x75\x51\xdc\x27\xc7\xae\x6f\xcb\x49\xc7\xd4\x40\xee\xeb\xab\x6a\xd7\x03\xf0\x6c\x69\xef\x6e\x52\xf3\xcc\xae\x9c\x3c\x3e\xe0\xa7\x4d\x6e\x43\x15\xd7\xa0\x2a\xdc\x94\x89\xc0\x4d\xd8\x87\xfd\xc2\x71\x79\x0e\x5f\xce\x64\x1f\x12\x74\x53\x83\x7e\xf3\xd9\xea\x77\xf5\x32\xdc\x15\x5e\x58\xf6\xeb\x5d\xc0\x8b\x1a\x74\x78\xea\x03\xfe\x36\x0c\x58\x8b\xfa\x01\xd0\xea\x55\x0d\xb8\x7a\x8e\x54\xd5\xeb\x91\xf5\x67\xd1\xd3\x68\x9d\xf8\x16\x0c\x15\x8a\x73\xdc\x25\x8a\x2b\x17\xf2\xb7\x98\xd2\x98\x9d\x9c\x74\x56\xac\xe1\xe3\x1a\xaa\x74\x85\x65\x79\xfb\x6e\x50\x48\xeb\x38\xbf\x07\x6e\x40\x66\xaf\x47\xde\x1d\x92\x9d\x64\xc4\x74\x9a\x6b\xa1\x76\x31\xca\x77\x90\x05\x11\x06\x42\x05\xf9\x72\xb5\xa2\x72\x03\x0d\x7e\x4a\xcb\x25\x3e\x50\x49\xfc\x7a\x3d\xf2\xcb\xb7\xc8\x3d\x04\xe1\x39\x19\xf0\xcf\x2c\xd1\xd6\x61\x47\x55\x6e\x31\x73\x7c\x78\x02\x51\x98\xad\x63\x09\xe2\xa4\x05\xa1\xab\xf6\xf5\x17\x42\xfb\xe4\x90\x5c\x61\x9b\x2f\x57\xd5\xf7\xea\x0a\x75\xd8\x31\x0d\x36\x56\xae\x3a\x9d\x2e\x69\xc9\x91\xa9\x1d\x6b\x9a\x3b\xcc\xc1\x82\xb0\x4e\xef\x8e\x46\xc0\xea\x89\x2e\x2f\x8d\x96\x18\x6e\x6a\xfa\xbe\x0f\x55\x9f\x76\xbe\x55\x7f\x0a\x05\x50\x4e\xda\x7c\x6b\xbd\x89\x8b\x91\x3c\xf1\x8e\xd3\xf2\xc4\x77\x4a\x5e\xb3\x7f\x6a\xca\xe8\x92\x07\xfa\xa7\x17\x07\x19\xb8\x94\xa4\x1d\x80\x8c\xd7\x32\x27\x98\xd3\x06\x72\x1a\x72\x83\x68\x53\x71\xbc\x76\x62\xa5\x77\xa5\xa3\xb6\x4d\xfc\xac\x46\x0f\x9c\x6f\xfd\x01\xc9\x8f\xed\xdb\xcb\x4b\x72\x4f\xd9\x70\xdb\xfa\x21\x60\xc9\x7c\xed\x1d\x97\xfa\x36\xe1\x5d\x89\x0c\xb4\x8e\x09\x82\x33\x8f\x2a\x0a\xb2\xd0\xa5\xc8\x9e\x5e\xea\xa6\xa2\xe9\xcc\x09\x02\x54\xd7\x16\x85\x85\xda\x9c\x6a\x84\x19\xd1\xe9\x34\x9b\xb7\x61\x6b\x76\xe1\x33\x25\xab\xea\x8d\x0e\xe7\xee\xd3\xe8\x99\x3e\x77\x5d\x9f\x33\x47\xbc\x3a\x69\x8f\xd3\xbc\xec\xac\xd4\xaf\x2a\xc7\xae\x5d\xf2\xa4\x29\x64\xfb\xf9\x93\x4e\xf0\x9a\xe3\x7e\xdc\x25\xf5\x16\xe8\x1f\x07\xf9\x95\xed\x60\x9f\x87\x07\x6b\xe4\xbf\x93\x95\x8a\x37\xae\x82\x6b\xa5\x24\x04\xb7\xfe\x04\x5c\x9b\xbf\x83\x20\xb6\x6b\x40\xc8\x26\x5d\xd2\x92\xff\xb4\x8c\xd0\xaf\x19\xe5\x53\x60\x20\xd7\x40\x70\xac\xc6\x76\x5f\x2b\x40\x35\x37\x97\xdb\x85\x77\xf4\x7a\x50\xc5\xc3\xd1\xb2\x61\x9e\x15\xd0\x48\xeb\x62\x1e\x4c\x18\x8e\xb6\xa4\xbf\xef\xf9\x5d\x65\x2c\x58\x14\x2a\xe8\xa8\xa7\x8c\x16\x49\xfb\xf6\x3a\x7a\xfd\x86\x60\x72\xb9\x8f\xec\x2b\x2f\xbe\xc2\xb6\xb6\xc1\xde\x69\xe9\x86\x57\xd4\x82\xd0\x2b\x9a\xab\x70\x64\xb7\xa8\x8a\xf7\x69\x3d\xc2\xdb\xda\x04\x54\x6b\xe4\x6e\xcb\x6b\xfc\x6a\x04\x72\xeb\x8c\x1e\x9e\xd1\x79\x77\x67\x6d\x8d\x0c\x66\xa3\xd1\x7c\x81\xa8\xa2\xea\x91\x0e\x0b\xaa\xd2\xd9\x61\xf1\xbc\x9b\xb9\xab\x28\xb7\x8b\x66\xed\x82\xf6\x6a\xc1\x8d\x83\x7e\x0c\xfa\x2f\x6d\x67\x85\x7e\xb5\x3a\x58\x1d\x00\xf8\x10\xd8\x3f\x12\x7b\xcb\x56\x3d\x94\xbf\x9a\xe7\xb5\x42\xac\x7f\x7a\x48\x42\x43\x18\x1d\xd2\x07\x6d\xa6\xde\x2c\x1f\xbd\x41\xd4\x09\xb8\x2c\xe6\xfe\x95\x0a\x54\xa8\x8a\xe0\xae\x48\x2c\x6f\xb7\xa4\x5d\xd3\x0b\x58\xa8\x2a\x80\x45\xf3\xeb\x9a\xbb\xbd\xaf\x64\x58\xa4\x0b\xaf\xc3\x06\xf3\x86\x42\xaa\xa6\xd0\x0e\xe0\xee\x58\x71\x0a\x9c\xde\x49\x0b\xd3\x25\x38\x93\x55\x76\xa6\xa0\x4e\x3d\x44\xa8\xb7\x0b\x97\x69\xf2\xce\x6a\xb7\xa8\x98\xe7\xf1\xee\x82\x30\xb3\xa7\xb7\x8b\xa6\x68\xee\x99\x0f\x04\x2b\xce\x41\x2b\x14\xea\xf6\x76\x5e\xfe\x5f\xe3\x23\xfa\xdd\x92\x3e\xa2\xbf\x43\x0c\x34\x84\x72\xde\x34\xac\x55\x5c\x13\xd6\xfa\xec\x76\x81\xca\x4e\xba\x22\x13\xd7\x2a\x2a\x71\xad\xca\x8b\x63\xe9\x8c\x45\xb5\x2b\x8d\x1f\x6f\xec\x83\x6f\x58\xa7\x67\x6b\x9d\x48\x2b\x86\x6b\x53\xbe\x9d\x67\xb1\xbc\xe3\x40\x35\x2f\x60\xd1\x36\x69\x38\xcf\xb3\x79\x44\xf6\xb3\x84\x9c\x7f\x4b\x62\x0a\x85\x4c\x4d\xd6\x1e\xa8\xb1\x0b\x2d\x95\x78\x20\x22\x39\x16\x3f\x45\x03\xc9\xf9\x2a\xb6\x51\x69\xdf\x53\xb1\x90\xd1\x3f\x5f\xbb\xa1\xa3\x23\x54\xaf\xf1\x38\xa8\x59\x9c\x50\xc4\x8f\x12\x94\xd5\x33\xd5\xee\xe1\x43\x35\x0f\x9b\x74\xb6\xaa\xfa\xc1\xf7\x8f\xc9\xfd\xbe\xc2\x83\x5c\x09\x2a\x88\x11\x21\xef\xdd\x47\x06\x56\xdf\x80\x18\xdd\xd5\x0f\x93\x12\x04\x35\xb6\x0c\xc6\x5b\x24\xcd\xc9\x97\x2b\xf2\xba\x21\xcb\x0e\xaa\x99\xac\x83\x10\x13\x65\x17\x0f\x5e\x30\x1d\xd8\xfb\x84\x3d\x3e\x94\x85\xa3\x09\xdf\xdf\x75\xda\x6f\x15\x3c\xe0\xe4\xe1\xd8\xba\xf5\x67\x2f\x3b\xd1\x50\xdd\x33\xad\xdc\xdc\x25\xce\xd0\x81\x3a\xbb\x64\xdd\x29\xc6\x2f\x58\xa9\xc6\x78\x7c\xe2\x3c\x46\x49\x61\x93\xdc\x83\x97\xae\xfd\x0a\x2e\x50\x36\x3d\xac\x7b\xcc\x99\xaf\x94\xbe\xcb\x4f\xb9\x6a\x6f\xb4\x0d\x3b\xd5\xad\x92\x2b\x49\xc6\xbe\xb1\xe3\x92\xc4\x01\xbd\x74\xc8\xbe\x93\x3a\x7f\x13\x1b\xda\x76\xe0\x35\x23\xe7\x16\x80\x61\x43\xb8\xd4\x1c\xd4\xc5\x0b\xbc\xe1\x94\xbf\x8b\x6b\x35\xeb\xae\xa8\x01\xf5\xf1\x9f\xd0\x21\xf8\xec\x76\xde\xf9\x5f\x71\x26\x3c\x7b\xba\xdc\x99\xf0\xec\x76\xfe\xf4\xe1\xbe\x9f\xdd\x61\x5e\x0c\xa5\x93\x3c\x30\x6e\x60\x95\x34\x18\xee\xfb\xa0\x00\xf2\xec\x76\x57\xa9\x1b\x67\xbd\x58\xb7\x59\x2f\x9e\x5f\xab\x58\xbd\xe6\x58\xd1\x5a\xd7\x26\x1f\xec\xf0\x51\x72\xbb\xab\xc1\xad\xaa\x50\xfd\x5b\x16\x52\x33\x65\x0f\x21\xf4\x47\x33\xd3\x26\x97\x76\x7d\x11\x4e\xf3\x73\x5a\xa4\xb4\x31\x16\xf3\x5b\xed\xd4\x7e\x41\x8b\x1c\x6f\x32\xe1\x65\x34\x81\xb9\x3a\xe3\x5e\x10\xda\x0b\xaf\x6a\xf5\x81\x4e\x89\x79\xc8\xe2\xa2\xf1\x6c\x58\x7b\xfe\xdc\x3d\x64\x0f\xae\x29\x3a\xb4\xf6\xfc\xd9\xc2\xa8\xea\x76\x2a\x7e\xa1\x59\x9a\xa8\x48\xd1\x2e\x9e\xb1\xfb\xf9\x36\x20\x78\x2b\xd6\x95\xc8\x08\xe9\x3d\xd2\x91\x33\xca\x14\x09\x39\x6f\xc1\xe3\xe4\x68\xe7\xfd\xd6\xd1\xfe\xfb\xd3\xc3\xbf\xbf\xfb\x61\xff\x67\x7b\x7d\x33\xce\xdd\xae\xfa\x4e\x1e\xec\x15\xd7\x55\x7d\xff\x7f\xbb\xf5\xe1\xff\x9c\xd6\xa1\xb5\x6c\x2c\x5b\x0b\x74\x9b\x3f\xb0\x21\x2f\x98\x06\x2f\xa6\x2c\x86\x0c\xef\x26\x41\xef\x7b\xa5\xf7\x84\xdc\xca\xda\x3d\x76\xc2\xca\x31\x4f\xdc\x0c\xf8\x79\x49\x41\x8d\xaa\x72\x3c\x43\x4b\xab\x57\xc1\xbc\xbe\x08\xf0\x07\x46\xc4\xac\x80\x12\x08\x69\x7e\xce\xcf\x30\x47\xb5\x01\xa5\xd2\x2e\x3b\x20\xa8\xd0\x55\x59\xfa\x0e\x18\xa3\x7c\x50\x63\x7a\x9b\xa3\xe6\x62\xd7\xfc\xdd\x9e\x60\x6c\xe4\x20\x53\x6a\xc4\x47\xc4\x6a\x7f\x75\x23\x75\x6c\x3e\x52\x87\x9b\x0b\x11\xfc\x7e\x74\x3b\xbc\x04\x86\x21\x12\x12\x45\x91\xfd\xf3\xca\x19\xa5\xae\xea\xf7\x1a\xf1\x70\x45\x26\x74\x3e\x60\x1a\x88\x6a\xa3\xeb\xfb\xbd\xd6\x48\xb8\x32\x69\x90\xdd\xeb\xab\x3b\x33\x17\x8a\xab\xc4\xf1\xb0\xe1\xb5\x42\x37\xa0\x0a\x3d\x3c\x7c\xe8\x37\x3a\xae\x34\x00\x75\xa5\xdf\x22\x44\x57\x5a\xf4\x71\xd4\xcd\xee\x40\x1a\xf2\xe8\x1b\x3f\x4f\xdd\x72\xc3\xa6\x90\xf7\x48\xf0\x0d\xcf\x32\x95\xfb\x9a\x0f\x15\xed\x49\x82\xa4\x90\x0e\x9c\x5f\x90\x84\xc5\x19\x55\x19\xce\x69\x9e\x90\x73\xb9\x0b\x4d\xc2\x73\xc8\xbd\xab\x9a\x17\x0a\xe7\x62\x36\x9d\x66\x29\x66\xdc\xd6\x25\xa1\x54\x12\x64\x11\x91\x1d\x2c\xed\x48\x66\x82\x8e\x98\x4f\x74\x10\xa2\xa2\x32\xd1\x2b\xce\xd0\x6e\xf9\x2c\xa7\x65\x69\x03\xc2\xcb\xe6\x5b\x45\x99\xc6\xe0\xc9\x07\x0d\x23\xa7\xfc\x4d\xdb\xa1\x3e\x93\xc6\xb7\xef\xd3\x64\xaf\x47\xb6\x72\x95\xa1\x9d\x66\xda\x00\x21\x5b\x83\x9b\x57\x22\x65\x1d\xe3\x6d\x75\x3f\x72\x3f\x75\x5e\xf4\x71\xd8\xca\x58\xd5\xad\xec\x24\xec\x45\xcf\x28\x01\xcd\xa8\xd7\x45\x4c\x4b\x36\xe2\xc5\xdc\x87\xaf\x9f\x6a\xe0\x90\x9a\xbb\x7d\xdc\xda\x63\x17\xa2\xd5\x6d\x1d\x8c\x79\xc9\x45\xcb\xcb\xb8\xdd\xd0\xb3\x37\x9d\x94\x66\x7c\x74\x1f\x97\x4c\x0d\x49\x10\x9a\xdb\x2c\xe4\x7c\x48\xb6\xa1\x91\x3f\x5b\x78\xa4\xc7\xa2\x1b\xef\x0f\xdb\xd8\xd6\xcb\xfb\x6d\x77\x6b\xd7\xfe\xc6\x7c\xf5\xd6\x7a\x04\x96\xe5\x28\x8a\xd4\x96\xb6\xd5\x54\x4c\xf2\xf2\x89\xe4\x9d\x43\x5e\x4c\x28\xf2\x4e\xc8\x2a\xaf\x09\x6f\xcc\x2f\x24\x27\x13\xcc\xd0\x2c\xe6\xb7\x67\x89\x4f\x53\x90\x5d\xa3\xbf\x49\xa8\xbc\x1b\x5c\x0e\x38\xcf\x2e\xe5\x08\x2e\x91\x67\x5c\xe6\xb3\xc9\x80\x15\x97\xb8\x70\x97\x0a\xc5\x51\x14\x9d\x74\x2e\x9d\x39\x42\x66\x5d\x05\x50\xee\x07\x09\xd0\xa7\xcb\xe8\x8b\xec\xe8\xaa\xed\xa0\xa1\xf3\xda\x19\xc8\x0e\x8d\xc7\xb0\x7d\xd8\x39\x2b\xe6\xde\xa6\xc2\x74\xda\x50\x92\xad\xce\xa8\x05\x9d\x30\x48\xa9\x4f\xcb\x59\xc1\x22\x90\x55\x10\x22\xec\x4e\x3c\x3a\x80\xe6\x15\x5e\xe2\x99\x28\xf9\xc4\xdd\xa5\x1a\xa8\x88\xa0\x60\xb7\x2d\xad\x6a\xb1\x84\x5b\xe9\xe7\x34\x3f\xbb\x66\x1f\x35\x6c\xa3\xf0\x2e\xe2\x05\xf9\xf0\x7e\xd7\xa3\xbe\x71\xc1\x86\x1e\x95\xcb\x07\x0e\x4d\xa8\x42\x61\xf2\x9f\x3d\x28\xcd\x6c\x38\xc7\x9e\x75\x63\xd2\x24\xa9\x63\x75\xa6\xbf\x28\x7b\x17\x7c\x7d\xac\x3f\x3e\xf1\x4e\x11\x1d\x72\xa3\x1a\xdf\xc3\xab\xba\x13\xa6\xe2\xbe\xdb\x24\x2d\x9c\x83\x14\x02\x3c\x28\xf2\x7f\xf7\x1c\x38\xce\xed\xf3\xc3\xfb\xdd\x4e\x75\x84\x86\x11\xe7\xec\x82\xa0\x2e\xa0\x06\xae\xb5\xf3\x79\xca\xe2\x92\x25\x84\x3a\x98\xa3\x39\x20\x6f\xc8\x0b\xd2\x22\x8f\x0d\x46\xd0\x83\x24\x97\xcf\x6a\x80\x3c\x5c\x55\xde\xfa\x47\xaa\xdd\x73\xde\x6f\x67\xbb\x86\x76\x6b\x14\x45\xba\xad\xbf\x55\xff\x03\xea\x42\xe4\x34\x53\x47\xab\xce\x88\xbc\xb7\xbf\xf7\xf7\x77\xfb\x1f\x0e\xa5\x68\xf4\xea\x15\xcd\x79\x3e\x9f\xf0\x99\xf8\xfe\xfb\x16\x78\xcd\xf5\x7a\x64\x17\x72\xd6\xd3\xbc\xbc\x87\x7f\xff\xc4\xd8\x14\xc5\xe4\x2c\x85\xbb\x3d\x11\xf3\x3c\xc6\xed\x60\xd3\xce\x13\xa8\x95\x81\xd5\x1a\x3e\x45\xbd\x21\x05\x09\xfb\x63\x5a\x8e\x8f\xa4\x50\x98\xe6\xa3\xc3\x71\x3a\x11\xd1\xaf\x50\x72\x9a\xd4\x05\x57\xa5\x58\x21\xc8\x15\x74\x5c\x89\xb1\x37\xca\x36\x50\xaf\x8f\x15\xed\x16\x34\x69\x75\xb0\x86\x8b\xe4\x1f\x8b\x9b\xcb\x16\x8c\xe6\xfa\x03\x89\xbf\xc5\x1f\xd8\xc3\x1b\xbf\x40\x8e\xb4\xf8\x1b\x6c\xa3\xbf\x40\x56\xb6\xf8\x0b\x65\x95\x50\x5f\x20\x99\x2d\xfe\x42\x6d\x00\xfd\x85\x72\xef\x5b\xf8\x85\x32\x6f\x76\xb1\xaa\x0e\xcd\x0d\x66\xb7\xf2\xb9\xdb\x52\xc1\x04\xcc\xee\x0f\x4d\x23\xfc\xd3\x69\x88\xcd\x54\x91\x17\xdd\x4c\x5d\x00\x02\xf0\x2c\xc3\xd6\x6d\xb5\xab\x5f\x0d\x66\xce\x13\x13\x4e\xb4\xc7\x93\x2a\x24\xc4\x96\x85\xb3\xaf\xfe\xae\xc1\x81\x03\xc3\x8c\x2c\x9f\x4d\xc2\x2d\xe4\x53\xdd\xea\x43\x9e\xf2\xbc\xd6\x4c\x8c\xa9\x6d\x72\x28\xff\xa8\xe3\xe1\x33\xb5\xab\x7c\x08\x77\xe4\x50\xc3\xab\x0d\x4f\xbe\x4b\xf3\x0c\xee\x0e\x4a\x19\x90\x0a\x32\xe5\xd9\x7c\x98\x66\x99\x2d\x45\x85\x62\x80\x64\x3c\x31\xcf\xc5\x6c\xc2\x0a\xc8\x42\x00\x45\x5b\xd2\x82\xf0\x8b\x1c\x61\xe9\x80\x50\x55\xa1\x82\x15\xd1\x84\xff\x23\xcd\x32\x1a\xf1\x62\xd4\x63\xf9\xea\x87\xc3\x5e\xc2\x63\xd1\xfb\xc8\x06\xbd\xff\xa4\xe7\x14\xa3\x5c\x7b\xef\xd9\x90\x15\x2c\x8f\x59\xef\x6f\x70\x31\x3b\xc5\xc1\x88\x1e\xfe\xdb\x53\x47\x5a\x0f\xc6\x5d\xd7\x00\xbb\xa9\x79\x7d\xc1\x3d\x15\xed\xcf\x5d\x62\xdc\x07\x7b\x3d\x9b\x90\xb8\x92\x83\x58\x72\xff\xcf\x20\x2d\xcf\xbd\x22\x56\x87\x25\x9b\x0a\xb2\xb6\xfa\xbc\x4b\x5e\xae\xae\x3d\xa9\xbe\x78\x11\x0d\x56\x5f\x44\xac\x4f\x1e\x3f\x91\x47\xc6\xea\x13\x5f\xbc\xfe\x0c\x67\x05\x64\x8d\x5b\x23\x3d\x82\x1d\xc8\x5f\xf3\x60\x88\x9c\x02\x4b\x5e\x44\xb4\x4f\xf6\xe8\x1e\xd9\xdc\x94\xff\x84\x60\x7e\x96\x27\xd3\x1c\x7e\xce\x5d\xd1\xdd\xc1\x10\xcb\x1b\x10\xe4\x2e\xff\x47\x90\x89\xe4\x69\x02\xa7\xcf\x6a\x96\x9e\x19\x7b\xbc\x3c\x5b\x06\x34\x3e\x83\x62\x7a\xf0\x79\x99\x0e\x52\x4c\xe0\x2c\xc8\x94\x71\xa8\x2b\x46\xe7\x24\x36\x85\x81\x2c\x07\x45\xc5\x46\x36\x07\xa1\x26\xcd\xa5\x7c\x56\x6a\x7a\x99\x95\xd3\x59\x19\x91\x1f\xf9\x05\x83\xca\x37\x17\x8c\x24\x26\x0e\xba\x60\xea\x9c\xc0\x11\x49\xd9\x73\x2e\x25\xbd\x48\x8e\x15\x9b\xf9\xe0\x44\x49\xe3\x33\xd9\xea\x82\xce\xbb\xd0\x1d\xca\x3b\x58\x82\x67\xa2\xc8\x1c\x94\xe9\xe3\x74\x00\x6c\x29\x9b\x13\xf6\x79\xca\x72\x91\x9e\x33\xb9\xf4\xe5\x98\xcd\x41\x3e\xc4\xcd\x23\x6f\x26\x9c\xf0\x61\xc9\xf2\x2e\x11\x33\x29\x99\x09\x72\x31\xa6\xa5\x22\x73\x3a\x95\xdf\x42\xcd\x36\x53\x0e\xa7\x03\xe8\xa2\xf9\x1c\x25\xca\x01\xde\xec\xa1\xce\x5a\xce\x50\x9a\x06\x9f\x61\x96\x44\xf5\x0b\xa6\x46\x1b\x4a\x00\xaa\xe0\x8b\x97\xd1\x47\x3d\x93\x17\x4b\xfc\xb5\x61\xdf\x21\x02\x36\x49\xab\xa5\xb3\xfa\xf4\x7a\xe4\x1d\x3d\x63\xe4\x93\x23\x7e\x00\xec\x4f\x44\x94\x72\x6b\x83\x9d\x45\x0e\x18\x89\x4a\x5e\x3a\x00\xd9\x72\x6c\xde\x60\xbc\x14\x74\x95\x27\x7e\xd5\x5b\x25\x10\x8e\x69\x0a\x74\xe7\xf2\x5f\x25\x6c\x32\xd7\x07\xec\x06\xe5\x63\xb4\x28\x37\xa1\xf9\x8c\x66\x7a\x78\x50\x34\x97\xc6\x63\x66\x2a\x29\x84\xdb\x7d\x44\x0d\xd7\x1b\x3e\x03\x6d\xd8\x13\xbb\x5b\xdc\xc1\xcb\x91\xc2\x3a\x3a\x97\x25\xb2\x58\xda\xc4\x12\x6f\xf2\x73\x6c\xf2\x76\x96\x65\xf8\x5c\x80\xde\xcb\x0e\xde\xfb\x8c\x6c\x56\xfe\xbe\xbc\xb4\x92\x90\x9e\x86\x0b\x4f\x09\xae\xe6\xcf\xcb\x4b\x33\xa2\x0d\xb7\xc2\x1d\xf6\x0a\x38\x0c\xa9\xe1\x5c\x1b\x05\x86\xc8\x34\xe8\xc7\xf4\xff\x7a\x3d\xb2\xc7\x2e\xc8\x80\x8d\xe9\x79\xca\x0b\x2c\xb1\x26\x69\x66\x26\xe4\x01\xc0\x87\xe4\x93\x1c\xc7\xaa\x24\x05\xf1\x89\x4c\x69\x7c\x46\x47\xcc\x01\x60\x94\x90\xed\x15\x57\x0c\x35\x65\xe2\x1c\x11\x57\x2e\xa6\xdc\xb0\x96\x7f\x28\x9a\x91\x0c\xc0\xb0\x12\xe5\x19\xad\xaa\x0a\xda\x32\xba\xa1\x71\x44\x5a\x04\xb6\x9d\x7c\x10\x8c\x7c\xb2\x37\x32\x5f\xed\xd8\xee\x7c\x92\x07\x9e\x64\x65\xc0\x36\x02\xdf\xbf\x67\x34\xc1\x4b\x27\x2d\xe1\xac\xeb\xf7\x7a\xc3\x41\x34\x61\xbd\x99\x60\xab\x00\x6e\xd5\x8e\xa4\xb5\x52\x95\xae\x89\xc3\xf2\x97\xde\x02\xce\x0d\x44\x1e\xbe\x3c\x53\xf7\x0f\x63\xe3\x69\xd5\x56\x6d\x3f\x4b\xec\xaa\xc9\x05\x53\xac\x1a\xcb\x92\xe1\xf5\xcd\xcc\xdb\xf9\x14\x74\xb1\x72\x47\xfd\x04\xce\x40\x3e\x95\x3e\x26\xad\xbe\x7b\xd1\xd8\x70\x17\x7a\x48\xfc\x25\xbe\xd7\xb0\x55\x8f\x35\xf8\x13\x75\x6f\x72\x87\xbd\x05\xb2\x86\x98\xd2\xc9\x44\x97\x4f\xd3\x33\x1e\xb0\x98\xca\xb3\xc1\xf0\x69\xe0\xcd\xe8\x26\x0f\x68\x82\x93\x8e\x7d\x8e\xd9\x14\x8f\xad\x2c\x1d\x10\x3a\x2b\xc7\xbc\x10\x5e\x37\x0b\x58\xc3\x2b\xf2\xd4\x5d\x31\x0f\xa9\x44\xeb\xc9\xfd\x69\x06\x69\x99\x90\xd6\xdf\x55\x35\x3d\xec\x2d\xc3\x03\x52\xce\x89\x56\xb1\xef\xde\xc3\xab\xf4\x46\xac\xe2\x0e\xe6\x04\x94\xfe\x8d\xc0\x82\xec\x84\xe7\xf0\x07\xde\xf8\xe5\xce\x48\xd8\xb4\x60\x31\x9c\x5e\x01\x48\xe8\x11\x05\xb4\x5d\xf0\x0b\x6d\x82\x90\x87\x43\x42\x33\x79\x42\x2d\xb7\x87\xd4\xe4\xe4\xa1\x3f\x60\x44\x30\x86\x2b\x95\x0a\x63\x48\x48\x66\xa0\x5d\xa6\xf2\x69\x91\xac\x4e\x69\x51\xce\x9d\x6d\x1d\x00\x98\xa5\x83\x82\x16\xf3\x88\x1c\x32\x66\x44\x48\xdc\x57\x58\x88\x50\x81\x5e\x4d\x78\x5e\xae\x4a\x54\xc2\x2e\x2b\x35\x3c\x88\x18\x21\x98\x68\x44\x44\xad\xea\x6a\x78\xac\xb9\xf2\xae\x76\x23\xb6\xeb\xbf\xb1\x80\x6e\x42\xf4\xec\x66\x3e\x08\x7f\xe5\x52\x1b\xa6\xf3\xd3\xff\xbb\x5a\xa9\xfe\xba\x72\xf8\x7a\x45\x6b\x41\x02\xa5\x6b\xd1\xa3\xcf\x28\x96\x3c\xda\x0d\x83\xa8\xc3\x20\xbe\x32\xc2\x17\x49\x5a\x47\x63\x06\xb8\xd6\x47\x1e\xe8\x19\x3e\x69\x86\x60\xce\xa6\xc7\xa4\xf5\x49\x12\xe3\x84\x16\x67\x2c\x91\x62\x93\xd1\x6a\xca\xb6\xed\x96\xbc\x91\xcb\x5f\x35\xe6\xf2\xa9\x4b\x06\xb3\x92\xa4\xa5\x50\xee\xc9\xa9\x20\x9f\xe4\x18\x3f\x45\xad\x4e\x27\x8c\xad\xdf\x77\xc0\xa8\x45\x21\xed\xd6\x0d\x06\x6c\xb8\x72\x65\xd4\x76\xcc\x7a\xc4\xa6\xf0\x7c\xed\x16\x40\x1c\xcf\x6a\x10\x9b\xae\xd1\x7a\x35\xc9\x21\xb5\x5a\xc4\xf0\x0f\x1a\xdc\xc0\x5e\xf4\x46\x0b\x3d\x92\xd9\xeb\xdf\xd1\x20\xcd\x93\xb6\x1c\x9e\x76\x28\x40\x30\xd5\x6f\x1c\x45\x66\xd3\xe7\xda\x7d\xd8\x99\x52\x15\x8a\x09\x4d\xac\x88\x91\x41\x05\x02\x53\x7a\x30\xf9\x4c\x53\xae\xf9\xee\x96\xc8\xaa\x0b\x6d\xcb\x28\x0f\x9d\x66\x0a\x8f\x98\xcb\x1f\xfe\xb2\x5a\x40\xcf\x91\xde\x34\x96\xc7\x78\x68\x4a\x04\x8f\xc3\x4f\xe6\xf3\x4f\x64\x00\x7c\xd6\xd1\xc0\x77\x89\x90\x97\x1d\x39\xe1\x5e\xc1\x46\xec\xf3\xb4\x4b\xa6\x54\xa0\xba\x57\x2b\x73\x5c\x68\xb0\x40\x48\xb1\x17\x0c\x2b\xe6\x0e\x87\xac\x20\x14\x05\x1a\x79\x74\xa4\x82\xe1\x2d\x40\x5f\x31\xc8\x98\x15\x8c\x14\xb4\x1c\x83\x85\x9b\xe6\x2e\xc0\x16\x1f\xe2\x4d\xe7\x13\xf6\xf6\xa9\x15\x99\xd7\x88\x13\x80\xe8\xa2\xc5\x3c\xf0\x30\x53\xdb\x19\xf5\xbd\xbc\x9b\xc3\xea\x2e\xbd\x9f\xf5\xd0\x9c\xed\xeb\x0e\x07\xda\xb8\x46\xa8\xc6\x0d\xae\x97\x87\xb4\x3a\x16\x94\xbb\x66\xd0\xce\xdd\xea\x15\xc7\x21\xbb\xcd\xaf\xbc\x6d\xb0\xc4\x5d\xa9\x69\x6b\x54\x75\x65\xbe\x8b\xee\x02\xc8\x9e\x03\x41\x24\x6f\xa4\xca\xbc\xbc\x27\x4f\x82\xc6\xee\x6a\x5a\x37\xb0\x32\xaa\xdf\x77\xbd\x0d\x2b\x51\xfc\x28\xf7\x3a\xfd\xa1\xec\xbb\xa8\x2e\x78\x80\x7c\x4c\x3a\xa7\x66\x72\xb1\x55\x58\x1b\x68\x01\xd2\x68\xa6\x8a\x0e\x35\x7c\x29\x80\x22\x31\xa6\x39\x14\x61\x56\x1a\xcb\xa8\x55\xa3\x87\x25\xb9\x09\x38\x10\x62\x7e\x65\x1d\xef\x63\xf7\x8a\x3b\xdb\x1b\xb1\x9d\xdf\x7d\x6f\xa9\x71\x7c\xc5\xc6\xa2\x39\x22\x2d\xb4\x87\x4c\xc0\xab\xca\xe4\x9c\x92\x57\x16\x87\x3a\xf9\x11\x49\x1f\x3f\xae\x22\x06\xb9\xd8\xa6\x4b\x38\x16\x2b\x5d\x92\x2e\x49\x8c\x72\xac\xc7\x72\x06\xa9\xfc\x75\xd2\xea\x86\xef\xd5\xbe\x87\x1f\xf6\x5d\xd5\xbb\xf8\x82\x96\x5a\x0d\x68\x5a\x97\x11\x7e\x7f\x16\x12\x52\x91\xff\x6e\x1b\xf9\x26\x94\xef\xfb\xf0\xfc\x4f\x27\x7d\x5d\xa5\x1e\xa8\x4a\xcd\xf9\x8f\x3d\x4b\x02\xf6\x0f\x23\x65\x81\x69\xf7\xf7\xe5\xef\xf7\x6a\x17\x13\x67\xdf\xf8\xe3\xa8\x6d\x71\xf7\xad\xd2\x92\x79\xcf\xa2\xbc\x49\xb7\xa6\xc2\x45\xe3\x72\x46\x33\xf7\xf3\x11\x2b\xcd\x9f\xd5\x81\xfd\x51\xf4\x54\x1d\xd5\xd7\x8b\x2a\xae\xbb\x86\x27\xb6\xf8\xc0\xff\x58\x7a\xab\x58\xc0\x0c\xad\xc1\x9e\x15\x5e\xb2\x04\xff\x10\xac\x34\xb4\xd4\xb0\x9c\x0e\xed\xb5\xd1\xdf\xa0\xc2\x86\x98\xb5\xd2\x11\xbd\x1e\x92\x41\xab\xef\x1f\x52\x2e\x3a\xf5\x81\x45\xfa\x04\x54\x56\x4f\x36\x7c\xc4\x2d\x14\xb4\x36\xdc\xcb\xd8\x3f\x8d\xdb\x86\x8e\x56\x1f\xc7\x4d\xe7\x2b\xaa\x1a\xdc\xe3\xd4\xff\xee\x38\x3d\xe9\x04\x4f\x3b\xf7\xc6\xeb\x1e\x76\xce\xc0\x31\xe4\xdd\xc4\xd6\x55\xe2\xfb\x2b\x34\x50\x41\xfa\xdd\xec\x47\xbc\xc9\x9b\xf7\x88\x45\x78\x89\x9b\xf4\x66\x5b\x91\xe7\x40\x2f\xb2\x9d\x37\xb5\xc7\xa4\x65\xf7\xdd\x9d\x6d\xae\x80\x11\xfa\x4f\x51\xbd\x51\x54\xd7\x26\xfc\xaf\x97\xd5\x6f\x77\xf3\x37\x1e\x17\x4b\xe1\xe5\x9f\x2d\xaa\xe4\xda\x97\x78\x91\x98\xae\xf2\xd2\xd8\xc9\x57\xd8\x86\x95\xdd\xc7\x54\x38\xf1\xa0\x6d\x37\x57\xad\x73\xc4\x2f\x96\xe2\x21\x4f\xc1\xd2\x72\x7c\x24\xe7\x08\x9f\x5c\x23\xc3\x2f\x2f\xc5\x37\xc9\xf1\x8b\xf4\xb9\xbf\xdf\xd1\x5a\x75\x1b\x69\xd3\xda\xc5\x7d\xd1\x01\x1b\x6a\xfd\x47\x9c\xb2\x47\x10\xe7\xf5\x07\x9c\xb4\x81\x03\x2f\x30\xe7\xf0\xa9\x67\x82\x14\x54\x92\x8f\xda\x67\xc7\xa9\x77\x8f\xd1\xf6\xba\x6b\x19\x61\xc0\xaa\x54\xb3\x28\x2d\x89\xc4\x88\xec\x54\xef\xd4\x44\x8f\xc1\xba\x78\xa2\x06\xd0\x37\xc2\xb4\x0a\x16\xb3\xf4\x9c\x25\xe4\x1b\x41\xa8\x2a\x8b\x44\xbe\xa9\x98\x52\x24\x7b\xe3\xa2\x1c\xa6\x9f\xdf\xf2\xc2\x31\x67\xb4\xd5\x2c\x3b\x6e\xe3\xd4\xfc\xae\x0b\xce\x4b\xac\x59\x45\x65\x7d\xf7\x27\xd6\xad\xa8\xe1\x66\xf4\x80\x14\x11\x3b\xfc\xeb\x6b\x94\xd3\x61\x83\x7e\xd0\x8a\xb3\x9c\xb8\x75\x77\x47\x8d\x4b\x8d\x0b\xed\x25\xbf\x83\xc8\xe3\xb9\xe6\xfd\xbe\x57\xd5\x54\xc8\xce\x6a\xf7\xc2\xdf\xe7\xf8\x5e\x1a\xa7\x9e\x3a\x01\x88\x44\x8e\xf2\x8f\xbd\xd4\x55\x9d\x0c\xdb\x42\x3f\xf8\x1d\xd5\x07\xff\x83\x64\xb4\x80\x74\xf6\x35\x97\x0d\x6d\x87\x59\x46\x44\xab\xaf\x50\x9d\xad\xd9\x36\xa6\x4e\x85\xb3\x1d\x62\xff\x52\x81\xff\x8b\x79\x5e\xa6\xb9\x6b\x05\xbf\x0a\xea\x65\xe3\x3f\x4c\x9a\x33\xb2\xdc\xbf\x96\x02\x36\xec\x9d\xfb\xe7\xc6\xf9\x97\xdb\x38\x90\x9e\x8f\xe4\x0c\x61\xa1\x30\x45\xb3\x0c\x0b\x37\xa4\x39\x89\xa9\x60\x44\xf0\x09\x03\x7f\x1f\xe3\x3a\x20\x85\xac\x49\x2a\xc0\xdf\x6a\x58\xf0\x89\x85\x06\xe8\x8e\x1c\x24\xd3\x2c\x53\x99\xad\x30\xc4\x16\x22\xf9\x2b\x8b\xd2\x75\x37\x6c\x4d\x85\xa3\xf6\xb4\x02\x74\xa7\x1b\xba\x71\xcd\xbc\x6b\xd0\x8d\x17\x50\x8e\xf8\x93\xda\xc2\x4b\x5f\x47\xa3\x9a\x3f\xde\x7f\xe7\x3f\xd0\xc4\x44\x37\xc8\xaf\x2a\x1a\xa3\x1a\x1a\xd1\x2f\xa1\x45\x40\x49\x5a\x05\x06\xa6\x07\x58\x59\x04\x56\x85\xa6\x3c\xe4\x21\xa3\xae\xb3\x1e\x1e\x54\x07\x66\xd0\xfb\xe3\x7f\x06\x17\xbc\x3d\x1b\x74\xa4\x29\x4f\x55\x20\x2e\x52\x48\xc9\x51\x8d\xb9\x72\x7c\x69\xe5\x8e\xd3\x01\x2e\x7d\xef\xa1\x8a\x48\xf1\x1f\x5a\x3f\xc9\x7e\x95\x15\xb9\x0e\x5b\xd8\x58\x07\xe7\xd4\x9a\xde\x33\x23\xf1\x3f\x50\x7c\xae\xef\xa1\x7a\x19\xfb\xad\x81\x6c\x95\x22\x10\xf9\xd7\x46\xcc\x04\x89\xc7\x8f\x50\xd3\x3e\x5c\x98\x3c\x73\x09\xbb\x59\x70\xde\xce\x95\xe0\xda\x90\xee\x90\x75\x2d\x18\xd0\x1d\x00\x17\x88\xe7\x0e\x81\x53\xd9\xf0\x4a\x36\xad\x6a\x64\x9c\x71\xc9\x13\xc6\x41\x1b\x56\x5e\xad\x39\x6c\x62\xfe\xbb\x7b\x6d\x55\x9e\x59\x7f\xaf\xea\xf3\x76\xa2\x84\xe7\xac\xfa\x91\x2f\xeb\xcb\x2f\xa3\xf3\x00\x1e\x3d\x6c\x7a\xc9\xfe\xeb\x8b\x56\xfd\xab\xe6\xec\x45\xf0\x60\xd0\x78\x46\x2f\xcd\x69\xc1\xcf\xd3\x84\x11\x39\xb9\x39\x39\x3e\xeb\x9e\x9f\x90\x72\x36\xcd\x98\x70\xfd\x71\x94\x56\x39\xba\x8b\x89\x03\x67\xca\x55\xb9\x3d\x33\xf1\xea\xbc\x80\x93\xe4\x90\x6e\xba\x8e\x10\x17\x77\xd0\xe8\x78\xad\x6a\x0b\x58\x06\x77\x55\xec\x2d\xc4\xe6\xca\x02\xbc\x86\x3b\xb9\xaa\x79\x1c\xb9\xfb\x41\x65\xae\xa9\x31\x00\x07\xc8\x55\x80\x9b\xa9\xd4\xa8\x5a\x18\xe9\xd6\x39\x57\xaf\x47\xf6\x28\xd4\xc1\x54\x39\x23\x8c\x26\xce\x8a\x59\x4e\x1d\xb3\x5a\xa4\xbe\x53\x57\x6b\x45\x03\x5c\x36\xe3\x28\x42\x56\xd9\x45\xbd\x7e\x61\x88\xc7\x2d\xaf\x79\xcb\x6f\xbf\xd4\x48\xde\xba\xf9\x1a\x73\x9e\xaf\x8a\x29\x8b\xe1\x24\xcb\x20\x0b\x89\xce\x86\x79\x31\x4e\xe3\x31\xc8\x4a\x3a\xca\x4c\xc5\xc3\xb8\x7a\xb3\xc6\x6c\x1b\xd3\x50\x58\xad\xae\x49\x72\xdd\x28\xab\x0b\x79\xa5\x42\x4c\x77\x7e\x9b\xa5\xe7\x34\x63\x79\x09\xa6\x52\x1c\xc3\x27\xf4\x94\x4b\xcb\x31\x46\x96\xd3\x8c\x8c\x69\x9e\x80\x13\x37\xc4\xf9\x80\x7e\x8d\xe6\x09\x41\xef\xbb\xa8\x92\x2e\x22\x20\x2c\x3b\x89\x22\x1c\xc1\xba\x7a\xd0\xd9\x5c\x0e\xd7\x9f\x22\x6a\x46\x2a\x02\xd5\xbd\xa2\xf8\x27\x85\x83\xac\xf7\x6c\xb4\xf3\x79\xea\x45\xb8\xed\x67\x09\xb9\x60\x83\xb3\xb4\x14\xa4\x4d\x4b\x92\x31\x2a\x4a\x32\xcb\xcb\x34\xd3\xa5\x1e\xc9\xb3\xe8\x89\xc9\xf7\xeb\x2c\x49\xdd\x35\x10\x1c\x03\x55\x82\x4b\xf0\x59\xc7\xe9\x51\xd5\x71\x44\x3e\xb2\x56\xf6\xff\xd9\xfb\xf7\xf7\x26\x72\xa4\x51\x1c\xff\x79\xf2\x57\x88\xec\x2c\xb6\xc1\x97\x38\x37\x20\xd9\x2c\xc3\x84\xb0\xcb\x3b\x03\xe1\x21\xcc\xcc\x77\x4e\x26\x07\xda\x6e\x39\x6e\xd2\xee\xf6\xdb\x6a\x27\x64\x20\xdf\xbf\xfd\xf3\xa8\x4a\x97\x92\x5a\x6d\x3b\x24\xb0\xec\x79\x66\xce\x7b\x96\xb8\x55\x92\x4a\xa5\x92\x54\x2a\xd5\x25\x65\x19\x38\xed\x27\x7f\x72\xb4\x1d\x07\x3b\x43\x91\xa3\x97\x54\x6f\x90\x46\x3d\x22\x30\x47\x42\x70\x61\x2d\xc8\xbb\x24\xa8\x09\xa1\x81\xea\xd4\x27\xc2\xdc\x95\x59\xa5\xa4\x49\x22\xc8\xfc\xdb\x9e\xae\x4f\x39\x07\x2c\xef\x81\x2d\xb8\x40\x33\x4a\xb4\x49\x87\xad\xf9\x1d\xe1\x82\x77\x5d\x76\x98\xa5\x97\x10\x7d\x00\xc8\xe2\x98\x59\xc2\xfe\xdd\xeb\x81\xf9\xfb\xbb\x7a\xf3\xd7\x77\x55\x1e\x0b\x19\x54\xd2\xf4\x3d\xbe\xe3\xfa\x9e\xeb\x38\xa2\x3d\x89\x5c\x79\xa2\x4a\x15\xe7\x35\x94\xd2\xe6\x1a\x97\xc4\xea\x46\x57\xb9\x22\xd6\x32\xed\x53\xe2\x3a\x46\xf1\x92\xb2\x65\xc3\x33\xa2\x5e\x9a\xf3\x6d\x33\xb8\x82\x1b\xbe\xea\x79\xc1\xe4\xeb\xd0\x3c\xc6\x27\x1f\x98\x17\xdc\x67\x41\x4b\x8e\x77\x99\xc8\xf8\x45\x44\x83\x7c\x56\xe2\xfb\x06\x5e\x96\xe4\xec\xa8\x99\x27\x61\x17\xda\x6c\xd5\x4c\xd0\x2a\xcb\x0b\xb6\xaa\x6f\xbb\xb0\xca\x57\x7d\x1e\x08\xaa\xe4\xcf\xfd\x0d\xa7\x0c\x5a\xe1\xd2\x20\xdf\x54\xf0\xf6\x85\x6d\xdc\x5f\x76\xe6\x0b\xbe\x66\x33\x42\xab\xf9\x52\x91\x8b\xd5\xca\xd6\xf8\x15\xe6\xd0\xfd\xa4\xe6\x23\xd0\x74\xa5\xe5\xba\xd3\xda\xc2\x5c\x05\xa6\x6c\x98\x46\x42\x40\xc4\x09\x0c\xba\xa5\x1f\x83\xdb\x92\x7b\xa2\xec\xd2\x5f\x68\xae\x55\x50\x65\x99\xd9\xbb\x41\x97\xa4\xbd\x82\x98\xed\xc1\x92\x6e\xe6\x28\x64\x14\xca\x9e\x99\x52\x85\xff\xc2\xcd\x18\x8e\xf4\xa2\x8d\x54\x42\x6a\xb9\x1f\x76\xab\x35\x28\xb0\x5b\x04\x26\xda\x0a\x13\xbf\x04\x63\xf6\xd5\x46\x61\xbb\x42\x49\x7f\x5e\x58\xb7\xe6\x46\xab\xd5\xaa\x44\x89\xbb\x59\x5c\x5e\x3f\x4a\xdc\x5f\x61\xdf\xfc\xb0\x6f\xd7\x8e\xd3\x36\x27\xf0\x1a\xb2\xb2\x0d\x91\x39\x4e\x26\xb7\xe4\x84\x41\xbc\x5a\xf7\x16\x7a\xb5\xc2\x1d\x4a\xce\x11\x7a\x38\x8b\x68\xc4\xd9\xc5\x98\x67\xe0\x7c\x27\xcf\xdd\x22\x9f\x28\xf7\x3b\x67\xe5\x39\x22\x83\xef\xb1\xea\xbc\xc6\x7e\x61\x2f\x55\xf0\x4f\xad\x77\x4f\xad\xf5\x4e\xfd\x2c\xbf\x54\x9b\xe8\x4d\xce\x97\xeb\xcc\x23\xbf\xec\x7a\x7b\xe0\x91\x9c\x55\xcf\xd7\x40\xc3\x41\x33\x5f\x22\x58\x0b\x7d\x8a\x5d\x3a\x56\x8b\xc4\x8a\x06\x63\xb1\xbf\x31\xd6\x8a\xfd\xad\x23\xa9\xd8\x2f\x5a\x97\x68\xbf\xe8\x48\x28\xe4\x8b\x8a\x74\x82\x5f\xb0\xe7\xcc\xe9\xd7\xc4\x2d\x51\x74\xf3\xc2\x94\x58\x40\x1a\x90\xc4\x81\xc5\xf0\x23\x3e\x5e\x15\x30\x15\x5d\xa4\xfa\xed\x0d\xc4\x13\x71\xbe\xab\x00\x22\x2e\x4a\x18\x31\x44\x7d\x33\xb1\x41\x16\x9d\x25\xce\x96\x74\xab\x47\x89\x7f\x0c\xcc\x0d\x92\x6e\x37\x2b\xb5\x29\xbd\x7d\xbb\xec\x91\x10\xce\x08\x15\x6c\x70\xd5\xc6\xa9\x5d\x25\xd9\xe3\x31\x62\x6d\x6b\x77\xc5\x7b\xd9\xf9\xb1\xc8\xa3\x78\x28\x6f\x50\xcd\x24\x4b\xca\x24\x4a\x8f\x4a\x23\xbe\x42\xf2\xe6\x44\x94\x3c\xe3\x85\x30\x61\x0b\x60\xe3\x8e\x75\xa2\x1a\xf9\xeb\xad\x28\x31\xe3\x32\x6d\xc2\x8d\xb6\x20\xe7\x0c\x80\xfc\x45\x89\x75\x2b\x2a\x0a\x61\xe0\x45\x49\xc4\x69\xd3\x93\xc0\x2e\x18\x73\x12\x53\x53\x95\xb7\x41\x9c\x26\xa5\x70\x93\x4f\xa4\x3c\xab\xa6\xa6\x56\x2f\x15\x68\x64\x91\xf2\xcc\xb3\xa6\xe8\xf5\x40\xea\x32\x74\x91\x23\x13\x6c\x96\x89\xd9\x40\x0c\x8b\x64\xc0\x63\x16\xcf\x40\xc0\x36\x43\xb8\xe0\xec\xfd\x4c\x94\x4c\x9c\x25\x53\x96\x94\xe4\xfa\x60\x70\x3c\xc6\xec\xd6\x27\x27\x2d\xf6\x91\x55\xbf\x2a\x22\xec\x12\x61\x5f\x0b\x89\xa6\x5f\x7c\xf0\x89\xb2\x53\x08\x7f\x17\xdb\x6c\x96\x5c\xc3\x40\x38\xb3\xe7\xb1\x43\x66\x53\xdb\xe0\x12\xb8\x91\x99\xb1\xd6\x59\x06\xa1\x93\xb6\x8d\x09\xd6\x30\x35\x26\x72\xe0\x03\x4e\x62\xc1\x75\xd5\xab\x83\xbd\x92\x0d\x67\x45\xc1\xb3\xf2\xb9\xe4\xa9\x24\xc6\x39\xb0\x34\x30\xa5\x27\x6c\xcf\x7c\x56\x97\xb4\x98\xdd\x37\xf9\x92\xb4\x7e\x5f\x83\x13\x1a\x15\x7c\x92\x9f\xbb\x64\x90\x87\x1c\x7c\xd6\xae\xfb\x06\x63\x8d\x27\x25\x13\x99\x5e\xd6\x4c\x8c\xc3\xb2\x45\x32\x01\xec\xcc\x4d\xc8\x88\xb9\x3a\x5a\xa7\xe1\xff\x1d\xf3\x57\xdb\x30\xc8\x8e\xf9\xab\x6d\x27\x64\xc7\xfe\xd9\xa6\xfd\xef\x38\xc8\x5c\xad\x5c\x81\x40\x3b\x8e\x8a\x49\x9e\x5d\xea\x0b\x86\x12\x39\xd9\xbd\x5e\x68\xd7\x39\x36\xf1\xae\x25\xd2\x4d\x6f\x23\x08\x05\x41\xbe\x59\x16\x06\x77\x2f\x5b\xa9\xd9\xcd\x4c\x33\xde\x0e\x06\x7b\x8c\xd9\xc3\x20\xd5\x92\xce\xd9\xa1\x54\x5d\xc6\x08\xd7\x99\x01\x90\x1b\xdf\xba\x9d\xac\xd7\x25\x54\x69\x85\xe1\x37\x24\x3c\x04\x83\xcb\xa7\x4a\xe0\x78\x8a\xa4\x6b\xfa\x2d\x9b\x16\xce\xea\xf3\xfe\x6c\x6c\x38\x50\xeb\x73\x5a\x97\xe5\x06\x98\x7f\x28\x79\x16\x8b\x8d\x3a\x71\xda\x07\xdc\x9c\xd3\xb0\x6e\x4b\xd6\xd1\x74\xd4\x5c\xb3\x87\x27\xac\x1c\xd3\xee\x8a\x3d\x29\x6a\x9a\xca\x07\xef\xe5\x6e\xa5\x58\x3c\x1f\xbc\x67\x77\xef\xca\x7f\xba\x76\xfe\xd8\x63\xf8\xbe\xc3\x3e\x9a\xab\x2f\x7c\xb8\x92\x3b\xd9\x8a\x56\x49\x21\x23\x49\x39\x74\x10\x09\x0c\x0b\xac\xc3\x2a\x9c\x26\xe5\x78\x36\xe8\x0e\xf3\x49\x2f\x4a\x8a\x41\x36\xe8\x59\xc1\xb0\x03\xc8\xb2\x82\x4f\x73\x91\x48\x19\xac\x2b\x5b\x34\x41\x9a\x92\x8c\xe5\x05\x5c\x7a\x72\x56\xf0\x78\x36\xc4\xe8\x46\x28\x44\xc9\x6b\x4c\xcc\xa7\x3c\x8b\x79\x36\x4c\xd4\x8e\x09\x80\xb8\x53\xe4\x13\xce\xf8\x87\xb2\x88\x50\x2e\x07\x91\x42\xc8\xe6\x65\x13\x0a\xdf\x8b\x48\xc8\xa3\xe2\x8c\xc7\x5d\x24\x7f\x95\x1d\xeb\x19\xb5\x01\xc8\x83\x98\xbb\xc3\xfe\x98\xad\xaf\xad\xfd\xd8\xa0\x34\x37\x13\x61\xb4\x50\xc2\xbb\x94\x3c\xcf\x88\x8d\xaf\x9a\x84\xe6\x5a\xdb\x32\x81\x9e\xd6\x96\x79\xa2\x57\xcd\x00\x94\xc7\xe8\x2e\xb0\x87\x2f\x49\x9a\x8c\x37\x25\xaa\xab\x99\x65\x67\x59\x8e\xc6\xd1\x90\x0c\x57\x36\x0e\xdc\x6d\x9b\xc4\x3a\xdd\x51\x92\x96\xbc\x68\xba\x6d\x55\x14\x0b\x77\x0c\xa6\xbe\xd9\x35\x80\xab\xeb\x0f\x51\xd3\x51\x04\x48\x72\xee\x4a\xc3\xf2\x78\xb2\x16\x01\x21\x5a\x42\xd0\x18\x3d\x20\x15\x0a\x18\xae\xc8\xf8\xc0\xee\x74\xf4\x3e\x4f\xb2\x66\xa3\x8d\xee\x4b\x8d\x2e\x7b\x95\xf2\x08\xa2\x81\x01\x03\x49\x36\xa1\xed\x60\x8c\x7a\x63\xbb\xef\x68\x4b\xf4\x4b\xf5\x15\x24\xfd\xa9\xec\xbd\x5f\x20\xcf\xcc\xd6\xe7\xe4\x99\x91\x73\x5a\x3d\x1a\xb6\x6e\x27\xbb\xcc\x7a\xb7\xbf\xe9\x48\x6f\x87\x2d\x95\xb9\x6a\x7e\x22\xac\x0d\x9d\x1c\x61\xce\xae\x0b\xd9\xd6\x82\x84\x58\xdf\xec\xb7\x9a\x0d\x59\x95\xe6\x05\x6f\x3a\x4b\x8a\x26\xc9\x15\x24\x2f\xa4\xce\x9c\x00\x9f\x35\x9a\x26\x6d\xff\xd5\xee\x4a\x28\x9b\xc0\xd6\xcd\x12\xd3\x7c\x46\xea\x8a\xad\xf5\xe5\x52\x57\x6c\xdd\x2c\xa9\x46\x98\xba\x0f\x5b\xbb\xe1\xcc\x4f\xdb\xdb\x35\x25\xeb\x9b\x1b\x35\x25\x9b\x5b\xb5\x25\x90\xfd\x26\x5c\x52\x5f\x67\xeb\x3a\x4b\xe0\x45\x34\x0d\x4c\xe6\xcd\xb2\x7d\x78\x52\x11\xda\x11\x14\x79\x6d\x6e\x83\xcd\x2d\x9d\x09\x44\xdb\xa9\xd4\x21\x6c\x12\x15\xbc\x78\xf2\x4a\x1e\x35\x2f\xa2\x69\x43\x25\xa2\xdd\xe8\xf6\xd9\x8b\x68\xaa\x96\x9a\x58\x8e\x02\x9b\x5b\xdb\xad\xe6\x8b\x27\xaf\xe8\x1a\x39\xe5\x65\x78\x99\xbc\x88\xa6\x4d\x22\x16\x9c\xf2\x52\xe5\xe9\x0c\xe4\x2a\x5d\x63\x8f\xed\xe7\xe3\xb5\x13\x27\x15\xcc\x2e\x2c\x22\x93\x5e\x59\xa2\xde\xdd\xe8\x6e\xcb\x0e\xec\xc3\x71\x57\xb6\xaf\x12\x71\x9f\xf2\x72\xc7\xb9\x70\xd2\x4c\xdc\xae\xb9\x80\x24\xb3\xac\x7a\x20\xbf\x18\xbb\x1f\x85\xe8\x8b\x27\xaf\x5a\x60\xda\xd4\x72\x2e\x16\x58\xfb\xee\x5d\xfc\xa3\x7b\xbe\x4b\xf2\x6d\x2b\xe4\x1e\x79\xc8\x09\xc4\x41\xa7\x27\xd5\xa9\x8f\xe8\x25\x37\x90\xfe\x54\x6b\xab\x10\xcb\x98\x8f\x6a\x11\x04\x2d\xa3\x24\xe2\x1a\xdb\xf1\xf3\xa0\x5e\x49\xda\x61\x1b\xb5\x89\x31\xb7\x6e\x96\xcd\x25\xc0\xc1\xf1\xab\x3a\xd1\x77\xdd\x64\x23\xc4\xfb\x46\x6d\x06\x8f\x87\x8a\x79\x0b\x8e\x9c\xf0\x24\x4d\x6b\x53\x1c\x6a\x3d\xf2\xb0\xfc\x50\x9f\xd1\x49\x67\xd0\xd2\xce\xe3\xb5\xcb\x46\x27\xd1\x1a\xe5\xc5\xe1\xa8\x0e\xbf\x75\x0d\xf5\x7d\x52\xf2\x02\xb3\xce\xd7\xa6\xf0\xd4\xea\x6b\x65\xda\x12\x1e\x84\x5e\xd6\xf2\x12\x88\x09\xf9\x6b\xd7\xa1\x5e\xd8\x4f\x0f\x8e\xf6\x5f\x3f\x7f\xf5\xe6\xf0\x75\x5d\xfa\xd0\x0d\xdd\xf5\x28\x12\x25\xc6\xc7\x0b\xe7\xe0\x5b\x6b\x75\x15\xc8\x35\x37\x97\xa3\xe7\xff\xe7\x80\xed\x39\xa8\x3c\x66\x8d\xb7\xa2\xc1\x76\x58\x43\x24\x7f\xf2\x86\x4d\xef\x78\xa0\x56\x1e\xc9\xd5\x35\x8e\x30\x8b\x67\x4b\x2f\x70\x89\x05\xbc\xa8\x69\x15\x13\xb8\xf5\xec\xe9\x01\x98\x84\x9e\x66\x25\xef\xaa\x04\x66\x08\x08\xaa\x89\x67\x8d\x96\xd5\x7b\x44\x65\xf7\x6d\x72\x0c\xa5\x27\x4a\xe3\x3b\x2a\xf2\x3f\xb9\xf6\x0d\xd4\x9d\x81\xba\x47\xef\x0d\x58\x6d\xb4\xab\xba\x30\x7b\x06\x2e\xfa\x8c\x2a\x47\xf0\xd3\x19\xdb\xdb\xc3\x71\xd0\x7d\x62\xb7\x26\xcd\xa4\x52\xfe\x9e\xf2\x72\xdf\xbe\x8c\xd1\xf4\xf4\x17\x45\x34\x9d\xca\xeb\xcb\xcb\x27\x2f\x0e\xda\xec\xf9\xd1\x5b\xd8\x78\x9f\x3c\x7d\x7a\xf0\x9a\xee\x65\xfb\x6c\x8f\x29\xd8\xa6\x4f\xd5\xc4\xcb\xf5\xc1\x08\xf3\x2b\x90\x7d\xdd\x41\xe3\x6d\x62\x1d\x4a\x71\xf0\x52\xd8\x92\x85\xbb\xfa\x91\x12\xe2\x31\xd9\xb4\x1a\x72\x6b\x73\x2a\x24\x6c\x4f\x67\x96\x82\x07\x79\x48\x15\x03\x74\x77\xc0\x46\xce\xfd\x5c\xb5\x3b\x4a\x0a\x51\x22\xcd\x1c\xe0\x34\x04\x9c\x46\x01\xd8\x63\xc9\x88\x27\xe8\x17\x45\x10\x96\x1c\x48\x34\x6d\x26\x41\xcc\x1d\xd2\x6e\x0b\x97\xba\x29\xb4\xf4\x86\x86\x81\xe8\x27\xf8\xc3\xbb\x77\x90\xcd\xa9\xb9\x4f\x33\xc0\x11\x35\xa1\x3a\x14\xfa\xde\xa1\x30\x4c\x79\x54\x34\x5b\x0e\xdc\x3a\xe4\x87\x3f\xe2\x65\x2d\x1c\xfc\x22\x8c\xa2\x4a\x89\x79\x80\xb1\xaf\x86\x87\xfd\x3d\xe6\x1d\x1a\x72\x46\x5b\x10\x81\x2b\x32\x6c\x9e\xb4\xd9\x35\xf9\x1e\xff\xc3\x8f\x45\x20\x86\xa0\x5d\x17\xd3\x96\x02\x9b\x9a\x56\xa6\xdd\xcc\x57\x92\xe9\xff\x62\x9e\xf2\x92\x03\x76\xc7\x08\x4c\x3d\xd2\xac\xd5\x9c\xe5\xa4\x10\x9b\x38\x60\x84\x2f\xb4\xa5\x44\xbb\x32\x39\x1b\xde\xe4\x20\x1e\x5a\xa2\x70\x27\x68\xd3\x9b\x20\x05\x6b\xce\x76\xf9\x5f\x03\x3f\x36\x76\xdc\x04\xe7\xbe\x91\xfb\x9c\x29\x72\xa3\x7e\xe8\x69\x30\xb2\x8a\xdd\x37\x3d\x73\xe9\xaa\x91\xa3\xac\x9f\xf1\x0f\xa5\x9d\x45\xdf\x6e\x75\x5a\xf0\x73\x3b\x3b\x81\xf9\xd0\x9b\x68\x75\x4a\x16\x31\x81\x6c\xba\x05\x1d\xc0\xa4\x4b\x3c\x7c\x10\xf9\xad\x05\x25\xc0\x23\x12\xd6\x07\x31\xd3\xad\x90\x6c\x11\x06\x08\x35\x69\x98\xc2\x83\x4f\x03\xed\x5b\x1e\xe9\x74\x08\xab\x19\x35\xc4\x1d\xb3\x91\x07\x78\x67\x1d\x44\x51\x97\x1f\x46\x79\x71\x10\x0d\xc7\xcd\xa1\xb2\x2d\x1c\x65\x6d\x78\x4d\x7c\x52\x9c\x52\x2e\x6d\x55\x98\x70\xcb\x63\xc2\x6b\x36\xa4\xc0\x09\xcb\x55\x1b\x60\xbd\x7b\xac\xad\xd9\xce\xb4\xc0\xee\xf5\x5c\xce\x5c\xc4\x8e\x92\xee\xc3\xf2\x83\x83\x59\x40\xae\xef\x3b\x72\x7d\xdf\x91\xeb\xdb\x6c\x23\xc4\xe3\xf6\x93\xb2\x07\x76\x36\x20\xf6\x58\xb3\x30\xdb\xc1\x18\xe2\x6f\x47\x2e\xb3\x8f\xd4\xb6\x73\xae\xb6\xb4\xee\x19\xd2\xcc\xb1\xd5\x86\xa7\x80\x73\x5e\x94\xac\xcc\x51\xe9\x0f\x07\xca\x87\x44\x40\xf4\x75\x7a\xb2\x54\x30\x31\x82\x7f\xd1\xf2\x36\xc7\x69\xc0\x17\xa1\xba\xd3\x3c\xf0\x26\x79\x1c\x89\xf0\x36\xf3\xc0\x63\x2b\x09\xe8\xec\x31\xe3\x48\x90\xb9\xd6\xed\x54\x0d\xc5\xee\xdc\xa9\xbb\xe1\xa8\xb3\x80\xee\x22\x57\x15\xb5\x1a\x11\xec\x5a\x2c\x7e\xe5\x1e\x73\x28\xe0\xd9\xe3\xce\xbd\x7b\x35\x03\xd8\x84\x50\xc0\xe5\x17\x46\x41\x55\xdb\x37\xd7\xac\x98\x26\xd6\x21\x02\xa4\x77\x7b\x5a\x6a\xd7\xd4\x9b\x5f\x1b\xc5\x14\xfc\x08\x51\x27\xa3\xec\x94\x87\x38\x22\xb0\xc7\x2a\x86\xc3\x7d\x5c\xef\x80\xb2\x11\xbc\xdf\x64\xfc\x82\xd4\xf7\xcc\xbd\xed\xb6\xa4\x71\x25\xa1\x27\x76\x42\xb2\xaf\xba\xc4\xb5\x65\x0f\xff\xe8\x38\xe2\x15\x63\x67\xea\xfa\x57\xf3\x1f\x56\x39\xe3\x96\xb9\xcf\x77\x10\xe9\x9a\x2a\x58\x01\x20\x4c\x95\xe9\x8e\x3e\x2f\x14\xf2\xed\x40\x15\x09\x91\xe4\x33\xe1\xad\xa5\xcc\xd9\x00\x6a\xba\x83\xb3\xca\xad\x27\x25\x9e\x48\xd2\x6d\x1e\x9a\xa8\x72\x8d\x35\x17\x51\x27\xbf\x3b\xea\xb8\xa0\xe7\x86\xb3\xdd\x04\x8e\x2a\xa7\xdc\x1e\x12\x36\x02\x72\xaf\xc7\xa2\x38\xc6\x94\x84\x76\x12\x02\x37\x11\xf7\x0a\xe2\x36\x7d\x45\xef\x29\x86\xc7\x35\xc3\xee\x98\xbf\xda\xa8\x34\x38\x82\x8b\x3c\xe5\xff\x7d\xf7\x8a\x40\xcc\xf6\x25\x72\xa0\x44\x6d\x33\x74\x8a\x90\x7f\x28\xaf\x93\x36\x3b\xb6\x39\x1d\x4f\x74\x0d\xb5\x45\x6d\xb6\xf5\x5f\x0f\xcd\x5f\xfd\xbe\xfd\x73\xbd\xad\xf7\xa8\x2d\xf3\xd7\x43\xf3\x57\x7f\xcd\xfe\xd9\x87\x96\xc9\x0d\xd9\xa2\x4b\x73\xfb\x4b\x34\x24\x43\x9c\x25\x59\x4c\x1f\x93\xe5\xfe\xee\xc8\x47\x16\x14\x0f\x25\x89\x74\x19\x15\xa7\xbc\x74\xea\x9c\xb1\x3d\x68\x6b\xb7\x8e\x5b\x64\xa1\x53\xa3\x7a\xcd\xf0\x6a\x68\x86\xc6\x49\xab\x6a\x89\x99\x2b\xd1\xc9\x56\xa9\x4b\xaa\xec\xd0\xac\x98\x33\x5a\xe2\x0a\xde\x29\x61\xae\x65\x8f\xa8\xeb\x1e\x4f\xbd\x9e\xe4\xaa\xea\x32\x23\x0b\xa5\x04\x2b\xd0\x66\x75\x77\x0a\x9d\xc2\x50\x41\x2e\x2e\x2f\x10\x70\x5e\xb0\x51\x92\x25\x82\x64\xe6\x54\xef\xe9\x76\x4d\xe1\xfc\x06\x24\x77\xa3\xfc\xe2\xd3\x66\x3f\xe4\xde\x4a\x00\xd8\xe0\x92\xce\xa8\x1c\x07\xd2\x7b\x8f\xa1\x52\xbf\xe5\x34\xb7\x66\x44\x03\xc7\x11\xd8\x54\xc1\xb5\x52\x57\xe9\xdc\x0f\xe0\xa5\x8b\x8f\x8d\xbc\xa1\x00\x75\xf0\xbd\x2b\xbd\x36\xd9\x63\xd6\x50\xeb\x0f\x94\x23\xaa\xa3\x36\xbb\x63\xae\x9b\x24\xf2\xb4\x5a\xc1\xc7\x3f\xfc\x20\x50\x1b\x74\xa2\x56\xe0\x7a\x57\x2f\xc0\xf5\xee\x3a\x80\x5a\x8d\x51\xd3\x08\x6b\x57\x21\xc3\xa4\xad\xdb\xcc\x62\x8c\x4a\x1d\xcc\x48\x5b\xa3\x7c\xda\xd6\x7a\xb9\xbc\xa8\x55\x24\xe9\xa7\x9b\x79\x2a\xc3\x6b\x6b\xbb\x8e\x5e\x1d\xec\x3f\x3f\xa8\x05\x5b\x6b\x35\x1b\x8a\xaa\x8d\xb9\x46\xa2\xac\xf9\xd3\xc1\xef\xd6\x08\x6a\xdf\x7a\xbe\xc8\x21\x1d\xff\x74\xf0\x3b\xc4\xb5\x27\xbe\x25\x8f\x49\xc9\x8e\x22\x0f\xfc\xd2\x6a\x2a\x3a\x8a\xbb\x77\xd9\xbe\xfc\x9f\x3b\xfb\xc7\x0a\xe3\x13\x29\x63\x75\x47\x72\x9f\x54\x5f\xb4\x70\x35\xcc\xb3\x51\x72\x3a\x03\x05\x05\x3e\xdf\xa0\x70\x59\x15\xb9\xec\x91\x92\x08\x34\x15\xba\x0a\x67\xf1\xde\xba\x4d\x73\xe5\x6b\xb0\xc3\x12\xa9\xbf\x21\x1f\x0e\x07\x1d\x45\x9d\xbe\x52\xeb\x35\x93\xb4\x4e\x51\xba\xdd\x57\x40\xe3\x24\xae\xe3\x3f\xa3\xed\xbd\x8e\x9e\x79\x39\xcd\xf0\x35\x54\xcd\x89\x98\xfb\xbe\xb9\xd5\xb7\xba\xe1\x37\xd6\xe3\xad\x56\x77\xfe\x68\x89\x35\xa5\xd5\xf0\x3c\x1a\x8e\x6b\x15\xcd\x0f\x5a\xcd\xb5\xeb\xad\xbe\x79\x6b\x09\x4f\x7e\xa3\xda\x54\x09\x4e\xc1\x9e\x61\x92\x67\x56\xeb\xf6\xfc\xe8\xed\x6f\x07\x4f\x7e\xb2\xeb\xee\xc7\x48\x80\x1f\x08\xae\x26\xd9\xcc\xc9\x2e\x59\x92\xb2\x58\xff\x06\x65\x1d\xdb\x23\x5b\xae\xe0\x25\x6c\xb7\x51\x1c\x37\x34\x14\x5c\x61\xd8\x1e\xae\xbe\x7d\x9a\x1a\x0a\xcb\x0f\x8d\x95\x23\x9c\x8a\x74\xec\x9f\x3e\xe9\x2d\x60\x9f\xdd\x71\x96\x3e\x9c\x99\x0a\x77\xe5\xa3\x54\xe6\xfa\x16\x0f\xcb\x1c\x98\xb5\x59\x95\x1d\xe4\x1d\x61\xbf\xd9\xd2\xd2\x59\xb3\xa5\x9c\x5e\x95\x39\x00\x11\xea\xd4\xa5\x82\xa8\x61\x89\x6b\x05\x00\xed\x63\x0a\x9c\x49\x9e\x75\x5d\xf5\xf2\x7c\x9d\xf2\x02\x7d\xa6\x9a\x2b\x05\x26\x57\x66\xf7\xe5\xc1\xc1\x53\xa2\xf5\x71\x6e\x36\x35\x6a\x69\x10\xd5\x16\x29\xa6\x15\x10\x51\x4d\x0f\x89\x6a\x1a\x4a\xbb\x6f\x87\xa0\xf9\xb9\x80\xa9\x6f\x3a\xe7\xf8\x75\x35\xbc\xd0\xa0\xd5\xf1\xc2\x4f\x4f\xcb\x2b\x97\x48\x53\xf2\x4f\x1b\xd4\xad\x6d\xd4\x8a\xb5\xd5\xcc\xb6\x25\xba\xe3\x48\xb4\x05\x2f\xdb\x20\x6f\x2b\x69\x5b\xcb\xda\x65\xfe\x3f\x47\x87\x2f\x1b\x5d\x31\x4d\x93\xb2\xd9\x68\x37\x5a\xed\xd0\x01\xa3\x25\xc2\xe7\x47\x6f\x35\x13\xff\x74\xf0\x3b\x1c\x2f\x92\x75\x25\x47\xe9\xdf\x92\xa5\xe9\x98\xe5\x77\x8c\x60\x58\xe6\xc0\x68\x86\x0d\xef\xde\x35\x95\x00\xf7\x46\xab\x05\xbb\xa1\x3b\xbb\x3f\x1d\xfc\x4e\x51\x8a\xda\x6c\x40\x85\x39\xe7\xd9\x40\xde\xda\xf7\xa1\x8a\xa7\x7a\xbc\x63\x10\xbf\x7b\x97\x91\xfe\xef\xe8\xcd\xad\x19\xb5\x8c\x50\xa5\x91\x3a\x95\x8b\xf3\x31\x51\x45\xed\xf8\x7e\xcf\xb8\x37\x0b\xb4\x4b\x43\x69\x7d\x08\x07\x6a\x33\x72\xde\x3d\x01\xe9\x8a\x00\x69\x70\x7a\x8c\x16\xfd\x3b\xaa\x2d\x23\x51\x7a\x53\x4d\x96\xef\xcd\x75\x1d\x0a\xdb\xae\xac\x18\xd2\x6e\x80\x69\xa8\xbb\xa5\xeb\x0b\x12\x4a\x81\x87\xb8\xd7\xc9\x8d\x4a\xc2\xab\x73\xb3\xa9\xfe\xed\xfe\x8b\xdd\xd7\xdf\xba\xbf\x91\xbf\x9f\xb5\xd9\x21\x36\xa0\xe7\x05\xb7\x53\xb5\x2d\x98\x7b\x64\xe5\xf2\x48\xed\xdc\xf7\xc3\x22\xc3\x5c\xd3\xf6\x65\xec\x7c\xd6\x58\xe7\x9f\x0c\x9c\x83\xff\xa6\x16\x10\x58\xff\xd8\xaf\x93\x68\x0a\x36\x0a\x04\x0e\x0c\xc6\xe4\xc7\x0d\xfb\x51\xe4\x13\x2e\x3f\x6d\xda\x4f\x10\x89\x42\x7e\xdb\xa2\x75\xb3\x58\x7e\xda\x76\x3f\x3d\x87\x2b\xfb\x92\x6f\xc6\xcf\xe7\x1e\xce\xfd\x2d\x2d\xb0\x2c\x6b\xa5\x54\xe6\x3f\xa3\x8a\xb4\xee\xfc\xd6\x4f\xc1\x91\x18\xd6\x1e\xcd\x0f\x43\x86\x2b\x96\x1d\xdf\xfc\xfe\xea\xa0\xcd\xbe\xc7\xf3\xc2\x9e\xa4\xea\x58\xdc\x63\xb2\x5c\xae\x40\x63\xbc\xff\xfc\xe8\xed\xb3\xe7\x3f\xbf\x81\x7d\x47\x17\xae\x93\xc2\xa3\xc3\x17\x07\xa4\x68\x83\x14\x1d\xfc\x7a\xf0\xfa\x77\x52\xb6\xe9\xb4\xf9\xf2\xe9\xdb\xe7\x2f\x9f\x1e\xfc\xff\x08\xc0\xb6\x06\x78\x79\xf8\xf6\xdf\x87\x3f\x83\xa0\xae\xcb\xb6\xe4\xda\x73\x2a\x6a\x60\x63\x30\xa0\x46\x25\x01\x23\x31\xdc\x0d\x58\x9f\x34\xbf\xc7\x8d\xca\x55\x9d\x47\x25\xd5\x0e\xca\x33\xde\x18\x6c\x7d\x4f\x94\xc4\x28\x68\xa5\x52\xc0\x53\x33\xdf\x3c\x24\x45\x21\xe5\x37\x2a\x16\x37\x5a\x8e\x4f\x01\xce\xb0\x9e\xec\xa6\x6c\x52\xe9\xc6\xa9\x2b\x82\x52\xf1\x11\x77\x04\xb3\xdb\x19\x19\x46\xbd\xaa\xaa\x41\xa9\x36\xd8\x0e\x99\x33\x1f\x66\xad\x45\x95\xed\xb6\xed\xf3\x28\x6d\xcb\x0e\xa8\x87\x83\xd1\xd7\xa3\x12\x14\xff\xb9\x7f\xbf\x05\xbb\x87\x99\xa1\x4f\x9f\x14\xae\x49\x06\xd4\xa1\x87\x96\x94\x98\xe5\x37\xf2\xca\x8e\xdb\x20\xf0\x64\x13\x3a\x85\x22\xdc\x98\xec\x99\x21\x27\xdd\x0f\xb7\xab\x15\x59\x48\x06\xab\x35\x93\x58\xa3\x10\x24\x77\x08\x5d\xc3\x78\x4f\x17\x5c\xb4\x8c\x3b\xb0\xdf\xae\xf2\xd1\xdd\xd8\x71\xc2\x2c\x30\xfa\x5f\xaf\x07\xe6\xbe\x7e\x95\xad\x1d\xa2\xb9\xf6\x34\x43\xf0\x6e\x6d\xf4\x0e\xa6\xca\xb6\xa9\xa2\x08\x5a\xad\xf2\xdc\x51\xdb\xaa\x7a\xeb\xfa\x70\xea\x4e\x67\x62\x2c\xa9\xd6\xda\x75\xea\xc1\x2e\xa8\xbf\x10\xc7\x71\xbd\x04\x5b\x6e\xb0\x08\x59\x09\xb7\x44\xe7\xe8\x59\x71\x8f\x47\xb2\x40\x1f\xb3\x4e\x1f\xb9\x0a\x16\x3b\xae\x43\x5c\xdc\x8f\xed\x9f\xf4\x08\xbd\x0a\x1f\x12\x37\xf3\x13\xe8\xf5\xd8\xa3\xee\x66\x77\xbd\xbb\x81\x1b\xb6\xd2\x6d\xec\x23\x83\xe7\x45\x72\x9a\x64\x51\x0a\x45\x66\x31\x58\xc3\x6b\x2e\x88\xcc\x5b\xbb\x7b\x3e\x5a\x70\x55\xd1\xbd\xd8\xd5\x46\x8c\xdc\xa4\xe0\xd9\xac\x76\x66\x2a\xb5\x5a\x4d\xb3\xce\x43\xe4\xb9\x99\x29\xef\x75\xee\x8b\x2a\x0c\x47\xed\x85\x76\xeb\xd6\xf5\x25\x86\x06\x56\x69\x62\x0c\x74\x54\x4c\x10\x4b\x26\x72\x5b\xd0\x1f\xa9\xab\x38\x79\x4a\xc9\x85\xe8\x14\x3c\x4a\x27\x92\xb7\x61\xdb\x35\xcf\x31\xe6\x36\x56\x89\xbb\xd2\xdc\x07\x09\x11\x49\x00\xe1\xa6\x10\x01\x22\xd6\xc9\xcb\xd5\x7e\x55\x05\x89\xe8\xaa\xcd\x7f\x9f\x68\x36\x25\xac\x55\xd6\xd0\xad\x6c\x9f\x44\xa2\x08\xb4\x08\x6a\x18\x23\x5b\x01\xac\x15\x7a\x1f\x2b\x1c\x77\x6a\xa4\xae\xed\x1b\x5b\x57\x07\x1c\x29\x9e\x46\xe7\x49\xfc\x63\x31\x8b\xb2\xb2\xf7\x22\x9a\x76\xdc\xe7\x46\xbc\xb4\x2c\xab\xae\x59\xf1\x45\xd3\x57\x44\x1c\x7d\xdd\x46\xdb\xd3\x36\xfb\xc8\xb0\xd9\x1a\x23\xe5\xed\x7e\xab\x09\x90\x2d\x16\xb2\x9a\xde\xbe\x99\xd5\xf4\x0d\xa9\x00\xd1\x17\xf2\x3a\xad\xcf\xba\xb1\xca\x05\x7f\xed\x9a\x6d\x67\x7b\x7d\xbe\xd0\x06\x92\x7f\xd0\x9c\x16\x11\x69\x52\xbb\x33\x85\x10\x5c\xc9\x5a\xf2\xb6\x8b\xb5\xd1\x07\xcf\x3a\x38\xc8\xaf\xec\x3e\x5b\xfd\x1b\x36\xc1\x12\x91\x35\x4a\x76\xca\x33\x5e\x24\xc3\x55\xf7\x95\x55\xe2\xde\x34\x92\x50\x78\x73\xdf\xbe\x99\x85\xf8\x72\xea\xb3\x79\x44\x92\x77\xf8\x36\x7b\xfe\xe6\xe0\xf5\x93\x37\x87\xaf\xed\x3e\x63\xc4\xa6\x63\x58\x97\xf6\xc2\xaf\x12\x42\xb6\xe9\xe9\xaa\x7f\x90\x86\x88\x1c\xa9\x0f\xb8\xd0\xf0\x6f\x66\xed\x4d\x98\xb0\x1c\x6e\x3c\xea\x2a\x4e\x4c\x72\x70\x68\xca\x45\x94\x76\x04\x2f\x27\xd1\xb4\x93\x8f\xe4\x6c\xf4\xfe\x26\xf8\xb0\x33\x89\xa6\xdd\x7c\x54\x63\xc1\xbe\xa9\x17\x4d\x00\xd9\x5b\x35\xec\xbd\x36\xee\x4b\xef\x1e\x73\x66\x7b\xff\xf0\xe7\x9f\x31\x2e\x07\xce\xb4\xbf\xd1\x1c\xb5\x99\x05\x91\x3b\x4c\x4e\xcd\x03\xf2\x51\x93\x8a\xfc\x46\x28\xf7\x8d\x55\xac\x80\xfc\x84\xa9\x03\xa3\xe9\x88\xea\xea\x91\x0d\xbf\x75\x3a\x2d\xf6\xe4\x18\xff\x3e\xa1\xad\xe9\x6f\xce\xa2\x92\xd2\x82\x5c\x53\xcd\x27\xb8\xaa\xea\xb4\xf1\xdb\x37\x7b\x9c\xf9\x7c\xce\x82\x48\xaf\x61\xde\xda\x9e\xc3\x5b\xb7\xfa\x78\xf0\xc5\x78\x0b\xae\xd1\x0b\xe2\x90\xac\xdb\x87\xaa\xc5\xca\x80\x9b\x6d\x5e\xd7\x66\x67\x39\x58\x6a\xd2\x25\x77\x68\x15\x73\x05\x6c\xb9\x26\xd1\xf4\x19\xb1\x0b\xb3\x96\x5c\xf0\x82\x22\x0b\x1d\x06\xed\x9f\xec\xd2\xd2\x69\x92\x9d\xb6\xd9\x93\x36\xcb\xda\x6c\x38\xc0\x22\x43\xad\x26\xb9\x13\x2b\x58\xb6\xa7\xda\xbc\xb3\x17\x94\x99\x14\x58\x8b\x34\x02\xf0\xc4\x9e\x48\x21\xbf\xe7\x68\x67\xfd\xa5\xa2\xe0\x9f\x98\xdd\xdc\x6b\x5e\x8b\x63\x19\xb5\xeb\x1c\x0e\xd4\xcd\x5c\xd1\xc4\x8e\x7a\xfd\xa4\xcd\xd6\x69\x04\xe2\xc3\x91\xc2\xc3\x9c\x0d\x76\x8a\x32\xfe\xa1\x7c\x5e\xf2\x09\xbd\x3f\x3e\xc1\x2b\xd9\x70\x60\x4a\xdb\x2c\xbb\x7f\x9f\x04\x5e\xd6\x7a\x44\xd7\xbe\x27\xd8\xd5\x13\x75\x02\x3d\x09\x7a\x01\x2e\xbb\x5b\xdc\x4c\x11\xf7\x19\x2e\x64\xdb\x0f\x97\x73\x21\xdb\xbe\xd9\xed\x2f\xdc\xf7\xa3\x90\xe0\xd4\x59\xfb\xd0\x1f\xd1\xff\x02\x64\xba\xd9\x5d\xab\xd7\x63\xeb\x6b\xe8\x97\xb8\xc6\x5e\x82\xcb\x70\xf7\xc5\xf3\x97\x6f\x8f\x9e\x3c\x3b\x78\xfb\xfc\xe5\x9b\x83\x7f\x1d\xbc\xfe\x6c\x19\xf9\xa8\xcd\x1a\xd8\x26\x88\xc6\x7e\xbb\x3b\xd5\xf1\x05\xc5\xe2\x07\x37\xbb\x1c\x2c\x08\x3a\xb5\xbe\xd6\xdf\x6a\xb3\xdf\xa3\x71\x9e\xdf\xd1\x51\xa6\x6c\x71\x30\xb2\xd4\x4b\x7e\xc1\x7e\x3c\x7a\xca\x7e\xc6\x22\x4c\x90\x2f\x0b\xa2\xe1\x30\x9f\x4c\xa3\xec\x52\xee\x24\x4e\x8c\x29\x88\xb9\xc8\x8b\x89\xd0\x31\xa4\x20\x5e\xce\xc1\x93\xfd\x37\x6f\x8f\xde\x3c\x79\xf3\x7c\xff\xc8\x98\xc6\x0d\xc7\x49\x1a\xef\xe7\x59\xc9\x3f\x40\x26\x50\x41\x1f\xc3\x87\x35\xdf\x15\x6b\x83\xcb\xae\xf3\x3d\x11\xd3\x34\xba\x7c\x19\x4d\xfc\x37\xf5\xa7\x35\x35\x26\xc9\x87\x24\x73\xbe\x18\x3f\x65\xfa\xb1\x84\x48\x36\x18\xa9\x40\xbd\x8d\xff\xf4\xf2\xf0\xb7\x97\xde\x70\x32\xa7\x63\x94\x1e\xec\x6f\x73\x0f\xb1\x9f\x20\x28\x54\xe1\xfd\x26\xe5\x66\xcf\xa3\x9f\x92\xf2\xd2\xc3\xc5\xf5\xfa\xb6\x11\x53\xdc\xef\xbb\xda\x6f\x87\x78\x5f\x4b\x52\x91\x10\x2b\x81\xc2\x50\x2d\x1d\x47\xb5\xa6\x9e\x2a\x0e\xd5\x7c\xca\x31\x56\x07\xe8\x72\x82\x95\x2d\x84\xa9\xff\x4a\x13\x0e\x4e\x6a\x5b\x8b\x7c\x47\x58\xf4\x00\x32\x9f\x4d\x30\x48\x53\xfb\xee\x5d\xef\x8b\x0a\xa7\x3e\xff\x98\x1f\xe7\x89\x28\x5f\xe6\x19\xc4\x0a\x3a\x2a\xa3\x32\x19\x0a\xf5\xb0\xb9\xaf\xfd\xcd\xdb\x2a\x74\x1a\xf9\x30\x48\xa3\xe1\x59\x9a\x88\x32\x10\x7b\xc5\x03\x46\xeb\x42\x15\x39\xbc\xc5\x3e\xb2\x5e\x8f\xc5\xb9\xbc\xd9\x41\xdf\x2c\x3f\xe7\x85\x8e\xf0\xd8\x1c\x97\x93\xb4\x65\xa3\x06\x88\x15\x47\xdf\xea\xd1\xc0\x0f\x7c\x8c\x4a\xea\x31\x2f\x92\x92\xc7\xb6\x7f\x9f\x52\x4d\x0f\x41\xc7\xe0\x5a\x9b\x45\x56\x5a\xb9\x7b\x37\xd4\xb6\x1c\xdb\x02\xac\xe4\x7f\xcb\x51\xb9\xda\x3e\x25\xb4\x8b\x25\x4d\x80\xe6\x3c\x40\x2a\xb7\xf2\x00\xb7\x07\xc6\xed\x50\x37\xc8\xe8\xfe\x68\x54\xf3\x10\x81\x68\x98\x67\xc3\xa8\x0c\xd7\xab\x74\xe6\xc4\x5b\x37\x7f\x86\xd2\x44\xd1\xe8\x46\xec\xfe\xfd\x24\x34\xcd\xe0\x4a\xca\x54\xb0\xa1\xea\xfc\xdd\x71\x36\x64\x48\xc6\x00\xef\xbb\xce\xc6\x66\x3e\x37\xef\x18\x2a\x83\x65\x84\xf9\x05\x10\xc1\xf8\xda\xb8\x33\x91\xf5\x5e\xb7\xd0\x7d\x3a\xf8\x9e\x30\xfa\xbf\xb2\xb8\xc4\xa5\xf1\x04\xd2\xb0\x8d\xa2\x24\x9d\x15\x5c\xa0\x8e\xa6\xe0\x51\xdc\xc9\xb3\xf4\x92\x44\x66\xa8\xb4\xc0\xf0\xf0\xa0\x01\x6a\x2a\x1c\x06\x26\xd7\x16\xef\x00\x1e\x57\x6c\x18\xc1\xbb\x84\xe4\xe3\xba\xa8\xe0\x81\x00\xdf\x6e\x4f\x5a\x5a\x5c\x99\x07\x12\x10\x15\x1f\xdc\x4c\x6f\x76\xeb\x61\x7b\x30\x46\x4d\x26\xbe\x7f\x2f\xc4\xf7\x99\xf8\x5e\x8c\x39\x2f\x0f\xa7\x65\x92\xeb\xb2\x29\x89\xc4\x16\x92\xa7\xd6\x48\x2b\xb5\x0a\x39\x13\xcc\x07\x61\xdc\xe0\x35\xbf\x25\x69\x3c\x8c\x8a\xb8\xf9\x36\xb3\xf1\x75\x4c\xb7\x75\xf1\x81\x36\x1f\xac\x57\x81\xe7\x05\x07\xb2\x2d\xb6\x6e\x3d\x92\x4e\x43\x09\x35\x0d\x1a\x4b\xa7\xae\x0b\x33\x5e\xd5\x87\xda\xf8\xab\x1d\xb8\x08\xec\x9a\x0b\x8d\x72\x23\xbb\x38\x1c\xbc\x47\xdb\x28\xd3\xc4\x1d\x13\x7f\xb9\x92\xdb\x85\x74\xa6\xb8\xc6\xf1\x67\x21\x6b\x1b\x03\xae\xe6\x83\xf7\xb8\x94\x5b\xaa\x2b\xdc\x4d\xe0\x34\xc0\xe4\x2f\xf2\x42\xa4\xcb\x0c\x01\x14\xc4\x2e\xb9\x43\x1d\x22\xee\x0e\x45\x3c\x8e\xd5\x9d\x59\xc7\x11\xb4\x03\x76\x50\x0f\x33\xbb\xad\x6a\x02\xeb\x29\x37\x0a\x9e\xcd\x26\x9c\xda\x68\x86\xec\x36\xd9\x45\x91\x94\xf6\xb7\x94\xea\x2d\x9d\x73\x3b\x6a\xf4\x27\xb1\xcf\x06\x38\x21\x26\x5e\x93\x4b\x80\x66\x70\x45\xc1\x5c\x55\xc2\xfc\x84\x61\xdb\x2c\x13\xdd\xf7\x42\x6e\x05\x96\xb9\x49\x27\xb2\xac\x75\x9d\xb6\xec\xcf\xcc\x69\x54\xc5\x42\xbf\x7e\x5b\xe2\x35\x3f\x4d\x44\x59\x5c\xd6\xa2\x58\x28\x80\x6b\xb5\x3d\x89\xb2\xe8\x94\x17\x75\x38\x86\xea\xb5\x2a\xd7\xde\x07\x37\xd3\x8b\x7f\xa1\x5d\x76\xa9\x9d\x34\xc8\x4f\xb2\xcd\xf7\x42\xec\x60\x24\x27\x4b\x17\x08\xc8\xd9\x6a\xe2\xe9\x9d\xe3\xe4\xce\x07\x62\xca\x36\xe1\x5f\x3c\x03\xf7\x0d\x13\x97\x7a\x87\x56\x91\x24\x23\xf1\x5c\x95\x99\x14\xf9\xa2\x6e\x78\x2a\x11\xd9\x65\xca\x8f\xe4\x6c\xcc\x6b\xa3\xad\x4e\xca\x49\x7e\xbe\x64\x0d\xb0\xb7\x6c\xc3\x43\x00\xf2\xd1\xfc\x91\x45\x71\xbc\xb8\x7f\x9d\xa2\x62\x61\xbf\x2b\x55\x5d\xca\x83\x5b\x8d\x2d\x73\x5b\x4c\xa5\xae\x24\xc6\x16\x9e\x24\xbe\x58\xd5\x48\xae\xca\xa3\xc5\x29\xef\xda\x9c\x3a\x12\x10\xe3\xd1\xae\xb2\xc7\xf4\xf1\xd8\x39\x00\x55\x6d\x75\x0c\xed\xd4\xc2\xa9\x73\x6c\x11\x32\xf2\x9c\xa3\x81\xce\x25\x84\x02\xc6\x52\xb8\x77\xf8\x29\x49\xd8\x63\x8b\xea\x8e\x8b\x12\xce\xd6\x0a\xbb\xc7\x0e\x3e\x94\x45\x34\x2c\x31\xaa\xfe\x65\xca\x85\x0e\x2d\x01\x31\x83\x8d\x8c\x29\xd0\x3d\x68\x98\x67\x65\x94\x64\x4e\x92\x3c\x4c\x87\x73\xaf\x17\x5e\x8b\x76\xe4\xd8\xbc\x09\x96\xc1\x45\x9a\x64\x65\x27\x4e\x84\x3c\x4e\x3a\x19\xff\x50\x76\xd2\x24\xe3\x2c\xcb\x3b\x62\x1c\xc5\xf9\x05\x0d\x5f\xc9\x11\x4d\xa7\x11\xe5\xb6\x24\x0f\x0a\x0c\x40\xb6\xc2\x42\x89\x17\x9d\x1a\x24\xeb\x3d\x84\xd1\x91\x65\x4e\x6e\xb6\x73\x1b\xbb\x5f\x51\xec\x3c\x98\xc8\xe1\xb1\xf3\x6b\x47\x73\x96\x89\xf0\x4f\x9e\xd7\x4b\x93\x80\x21\x98\x91\x18\x9d\x97\xf2\x16\x8e\xe4\xe3\x15\x89\x01\x90\xbb\xc7\xa9\x56\xd8\x5a\xf3\x99\xd2\xcf\xed\x20\xf9\x01\x11\xbe\xa3\x93\x55\xc9\x7b\x8e\x9b\xd9\xa4\x9a\x60\x09\xac\xe9\x91\xc4\x10\x8f\x5a\x93\xfb\x3c\x90\x7b\xca\xc0\xb9\xf7\xa0\xfa\x61\xd0\x81\x98\xca\x01\x8f\xe3\xd0\x1d\x21\xdf\xf5\xe2\x90\x7a\x8c\xb0\x1b\xda\x79\x6e\xf5\xe9\xf0\xb6\x76\x1e\x95\xb5\x0d\x12\x21\xec\x79\x5e\x2f\xe6\x97\xd3\x49\xc2\x85\x31\x29\xd7\x31\x0b\x83\x17\xe4\x29\x89\x1b\xa8\x63\xfd\x56\x6f\xa4\x98\x9a\x2f\x39\xd9\x25\x9f\xbb\x56\xe8\x63\x7b\x35\xdf\x3f\x7d\xd2\x46\x59\xa4\x9c\x8a\x86\xda\x92\x1e\x58\x60\x15\x46\xbf\x2a\x57\x1e\xb9\x57\xd2\xaa\x5a\x82\x34\xd5\xc2\x04\xd6\x23\x27\x35\x2b\xb7\x55\x10\xa9\x2b\x06\x94\xc4\xae\xa9\x8d\x8a\xc8\x57\x18\x1b\x5f\x80\xa2\xe5\x95\x26\xa5\x4a\x5c\xa2\x8a\x5b\x55\xe2\x93\x86\xa8\x35\x35\xa9\x83\x63\x76\xda\x9d\xd7\x8a\x8b\x82\x11\xfa\x09\xc4\x2e\x5c\x86\x9a\x86\x6b\x74\x2e\x93\x9a\x47\xbb\x4d\x1f\x70\x5e\x40\x56\x05\xf2\xd5\xaf\x73\x60\xed\xb1\x1f\xa5\x29\x44\x96\x6f\xea\x10\xec\x6d\x3a\x6e\x3d\x1f\x77\x4c\x31\xcd\x24\x43\x01\x25\xa4\x0d\xd6\x6c\x8d\x45\x56\xf7\xa3\x2c\xcb\x4b\x0c\xd8\x1f\xa9\x8c\x23\x91\x20\x61\x9b\x57\x5b\xea\x5e\xa5\x8e\x3e\x10\xa9\xc4\x0b\x94\xa0\x31\xd5\xc4\x19\x67\x11\xfb\x8d\x47\x67\x2f\xa2\xa9\xca\x9c\x95\x08\xc9\x72\xc9\x69\xa6\x12\x92\xe6\xb3\xac\x64\x56\x24\x93\x0d\x69\x4c\x31\x06\x6b\x54\x96\xd1\x70\xdc\x8b\xb9\xfc\x87\x45\xb3\x32\x9f\xc8\x39\x8f\xd2\xf4\x12\xcf\x49\xb0\x5a\x73\xfa\xde\xab\x18\xe3\x9b\xdf\x0e\xa0\xb1\x08\xf0\x69\x8a\x96\xb3\x0e\xac\x3e\x83\xc0\x92\x1f\xaf\x20\xe4\x49\x12\xbe\x16\x7c\x54\xf9\xa6\xf4\x79\xf8\x0d\x36\x5e\xba\x73\x35\x9d\x2e\xda\xec\x18\xd1\x39\xe3\x97\x3b\xe8\x10\xd1\x56\xe7\x32\xec\x80\x75\x91\xec\x5c\xf3\x61\xd3\x6d\x17\xbe\x1c\x8e\x9a\x54\x23\x46\xfd\x11\x70\x14\x8e\xa5\x2e\xd8\xa6\x69\xc7\x06\x44\x23\x8a\xe3\x1a\x34\xa2\x38\xc6\x38\x04\xd0\x90\x8b\x8d\xa1\x10\xe9\x89\xe6\xd7\x57\xb4\x32\x74\xa3\x65\x8a\x66\x66\x20\xe6\xf4\xa7\xc3\xc4\x26\xcd\x18\x11\x05\x47\x4e\xb0\xbe\xf7\x9d\x7e\xcb\xb5\xc3\xd5\x60\xaa\x11\x78\xd1\xd5\x2d\x58\xfc\xf0\xfb\x9a\xf9\x06\x44\x85\x6f\x48\x51\x97\xa4\xaa\x2d\x65\x58\xd2\xd1\x41\xc8\x03\x14\xc5\x4b\x66\x0d\x51\xb1\xf0\x73\xa7\xd7\x90\xde\xa5\xbc\x67\x8d\x8d\x81\x71\x14\xe5\x8d\x59\xf5\xde\x1e\x5b\x6b\x61\xed\x2e\x2e\xba\x26\x89\x03\xe6\x42\xdb\xd8\x07\xca\x57\x5c\x21\xa5\x8a\x5b\x04\x4d\x31\x4d\x93\x21\x6f\x2a\xa3\xef\x35\x57\x41\x4b\x69\x57\x4b\xaf\x59\x36\x97\x62\xba\xf8\x73\x69\x66\x79\x65\x4f\xf1\x8a\xe3\xbc\xae\x04\xeb\xe4\x34\xcb\x0b\x4f\xae\x96\x77\x88\x3c\xb5\x86\xe2\x70\x41\xd4\x27\x07\x91\xdb\x5b\x4d\xf5\xde\xdf\x70\xd6\xfb\x0e\x1b\x46\xd9\x1f\x8d\x12\xec\xc0\xd5\xb4\x95\xb9\x19\x4f\xa3\xe2\xc3\xe4\x3b\xbf\x07\xe7\xd1\x09\x74\x5c\x9d\x39\x1a\xda\x68\x1e\x1f\x54\xb9\xa7\x8b\x5b\x70\xd3\x8f\x10\x53\x9d\x30\x74\x8f\xd2\xef\xa7\xde\xc6\x55\xcd\x73\x68\x66\x87\x5a\x60\x41\xb3\x27\x8e\x1f\x92\x43\xbc\xdd\x15\x3c\xd6\x83\xb7\x24\x0f\xd2\x17\x68\x6f\xd5\xf7\xfd\xaf\xab\xf4\x6d\x5f\xa5\x83\x53\x3a\x4c\xf3\x0c\x55\x37\x9a\x60\x89\x38\x1c\x08\x5e\x9c\x2b\xe1\x37\xa8\xfa\x07\xbf\xef\x2a\xf8\x3c\xb1\x8e\xc2\x7d\x25\xd9\xce\xb5\xcf\x77\x2e\x97\x34\x3d\x8b\xa1\x00\xde\xd6\xcc\xd5\xff\x08\xf3\x34\x61\x56\x1b\xa5\x42\x30\xa9\xdd\x67\x82\x17\x8c\x67\xb1\x60\xb3\x29\x2a\x21\xca\x31\x9f\xb0\xc1\x25\x8b\x86\xc3\x24\xe6\x19\x24\x93\x42\xb1\xfb\x32\x05\x6b\x2c\xd4\xe1\x9b\xa0\x16\x48\x72\xa7\x27\xf5\x9c\x8c\x37\x63\x79\x85\x3a\x4a\x26\xd3\x94\xbf\x9e\xa5\x5c\xa7\x38\xc2\xb7\xe0\x23\x6c\x53\x4f\xb1\xee\x62\xb9\xbb\x3f\x8e\xd2\x78\x2f\x3a\x2d\x92\x37\x6f\xed\x87\xed\x94\xa9\xf4\xda\xc1\xb2\x8a\xda\xc0\x1d\xaa\xcd\x12\xa2\x87\x8b\xb9\x52\xe5\x38\x9f\xe5\x59\xf9\x2c\x1a\x9a\x91\x52\x67\x06\x44\xd7\x25\x5c\x77\x12\x4d\x9b\x76\xe2\x5a\x3e\x21\x09\x07\xe3\x0d\xbc\xcb\xc8\x37\x01\x79\x66\x93\xc9\x64\x56\xa2\xab\xb2\xc8\xd9\x05\x57\xaf\xfb\x19\x07\x09\x7a\x45\x05\xe3\x9c\x5e\x62\x5a\x2d\x85\x14\x1c\x45\x0e\xcb\x3b\xe7\x51\x08\x57\xc0\x4d\xbd\xed\xe8\x79\x43\xbd\x83\xb9\x24\x43\xc6\x41\xad\x04\xa2\x5a\x23\x47\x03\x74\x2c\xc1\x88\xad\x5e\xf3\x06\x9a\x9f\x56\x4d\xaa\x4d\x8d\x23\xf6\xe5\xec\x0f\x9e\x96\x65\x98\x67\x65\x92\xb9\x69\x3f\x2b\xb5\x8d\x42\x88\xea\x46\x34\x54\x20\x06\xff\x83\x9b\x99\xbc\x2e\x17\x64\xfb\xc1\x83\x90\x8d\xd7\xcd\xac\xfd\x7c\x1b\xaf\xda\xc4\x87\xb6\x6d\x8c\xb5\xd0\x56\x49\x2e\xa0\x95\xdb\x7a\x92\xc8\x33\xc8\xa0\x5c\x4b\x80\x87\x15\xd0\x79\x3b\xb7\x86\xf9\x8a\xbb\x76\x91\xe7\xe5\x2e\xeb\xdd\xd3\xe1\x4e\x2e\x92\x2c\xce\x2f\xd0\x70\x8d\x9a\xec\xf0\x74\x84\x76\x3a\x96\xd5\x95\x77\x47\x9e\x97\xca\x65\x72\x77\xc5\xd3\x44\xe6\x23\xdd\xde\xbc\xaa\x08\x12\xaa\xac\x70\x9a\x57\x19\x41\xdc\xca\x85\x0e\x9d\xa7\x60\x70\xde\x0d\x0c\x29\x31\x96\xbd\x0d\x22\xca\x35\x5a\x4d\xcc\x5a\xe1\x78\x62\xe0\xdb\x89\x9e\x44\x67\x2f\x92\x8d\xd9\x14\x3e\xee\xa9\xaf\xdd\x2f\x6e\x98\xa1\x73\xb3\xdf\x0a\x17\xf4\x1f\x6c\xb6\xd4\xe2\x09\x24\xf1\x7c\xf0\x1f\xcd\x72\xf4\x5d\x4d\x92\x23\x97\x42\x28\x46\xd9\x7d\xfe\x95\xa2\x31\x11\x1c\xea\x40\x90\xf2\xd8\x53\x61\x48\x0d\x3f\xde\x6a\x81\x0f\xa6\xba\x8b\xbf\x76\x57\x56\xbe\x23\xec\xf5\x36\x98\xe5\x1c\xda\x03\x30\x55\xde\xcd\xad\x38\x05\x65\xdf\x19\xa6\xa8\x42\xec\xae\x7c\xf7\x9d\xe1\xb3\x00\x68\xb3\x61\x61\xe5\xfd\xe8\xbb\xef\xbe\xab\x36\x42\xf8\xe6\xbb\xef\xae\x56\x68\x83\xa6\xbd\xc6\x0f\x3f\x90\x96\x76\x57\xbe\xbb\x5a\x59\xf9\x2e\xe0\xf3\xe3\x31\xc4\xcd\x6c\x88\x3f\x63\xf3\x9d\x16\xf9\x90\x0b\x71\x9b\xbb\xee\x17\xd2\x81\x42\x95\xb9\x51\x9f\xfa\x0f\xb6\x3c\xc0\x79\x4d\x23\xc4\x57\xdc\xcb\xf7\x8f\xc0\xeb\x55\x61\x46\x4d\x09\xf6\x8f\x8e\x14\xde\x3c\x3b\x47\xd5\xbf\x9c\x94\x2e\xcf\xce\xbb\x2f\x0f\x9f\x1e\xbc\x3d\x78\xf9\x6b\xdd\xbd\x85\x3e\xd8\x15\x46\x64\xff\xcd\x93\xe2\x18\x17\xc3\x68\xca\x59\x52\xaa\xe8\x2d\x2a\xb5\x68\x9b\x0d\xf8\x30\x92\x6c\x73\xc1\x41\x18\xcc\xf2\x92\xcd\x84\x9c\x3e\x29\xd8\x37\x04\x36\x97\x64\xd3\x59\x09\x62\x9a\xe0\x29\xa4\xe5\x15\x6d\x5d\xe3\x14\xdf\xda\x21\x83\xb7\x29\x06\x13\xd0\x94\x97\x1c\x94\xa8\x2a\x96\xe9\x39\x2e\x65\xdb\x3b\x8d\x7c\x57\xd8\x28\x22\x92\x50\x9f\x3e\x31\xf9\x6f\x17\xf1\xd6\x72\xd9\x62\x05\xc8\xf1\xff\x1c\x1d\x9d\x30\x5b\x93\x4d\xf3\x14\x65\x80\x24\x63\x4f\x0f\x7e\x95\xa7\x0d\x24\xfe\x52\x6c\xa3\x72\x11\x27\x82\x0d\x8a\xfc\x42\xf0\xa2\x0d\x89\x97\x1a\x90\x7f\x8b\xe5\xb3\x32\xe4\xc9\x39\x89\xca\x71\x12\x89\xc1\x65\xc6\x33\xd1\xb3\x9d\x35\x5c\x1f\x47\x18\x94\x2b\xf2\x59\x58\x98\x2e\xd8\x03\xbe\x40\x76\xe8\x87\xb7\x69\xa8\xff\xd7\x93\xda\x5f\x4f\x6a\x7f\x3d\xa9\xfd\xbf\xf5\xa4\x26\x09\xf6\x2a\x9d\x9d\x26\x99\x31\x74\x9b\xf7\xaa\xe5\x81\x2e\x78\xd7\xf2\xa0\x9d\x97\xad\x71\x9e\x9f\x09\x12\x7c\x3a\xcf\x30\xd8\xc6\x6b\xf0\xf3\x3a\x3e\x69\x9b\xef\xaf\xf0\x10\xac\x2d\x80\xab\x73\xb8\x04\x6d\xaf\x68\xc9\x3e\x84\xd9\xfe\x15\xb7\x25\x5a\xf0\xcb\x34\x86\x7c\xa8\xc7\x27\xfa\xb9\x05\x5e\x1b\xf1\xbf\x7b\x4c\x0e\x8d\xbd\xa3\x48\xbe\x63\x38\x04\x92\xf0\x36\x32\xf9\x5d\x92\x91\xfa\x86\x39\xcd\x23\x80\xed\x9a\xe6\x7a\xa8\x22\x08\x3f\xd5\x79\x54\xf3\x1e\xeb\x28\x0a\x35\xef\x14\x14\xa4\x99\x41\xb2\xf8\x98\x0f\xd3\xb6\x36\x9d\x6b\x51\x5f\xc1\xca\x0e\x6a\x67\xa7\x4b\x1b\xf2\xf6\x54\xc7\x02\xa5\x98\xe1\x16\x16\xae\x79\x9c\x9c\x04\xb1\x70\x9f\x07\x0a\xb8\xf2\x6b\xc1\x78\x96\x72\xff\x0d\xc2\x4b\x59\x68\x2c\x4e\xcc\x34\xd9\x49\x22\x1c\xa3\x66\x49\x91\x5e\x5e\x97\x2b\x8f\x08\x0e\x7c\x2d\x49\x09\x8c\xc2\xf5\xe3\x8a\x8b\x7d\x37\x11\x0a\xc8\xba\x97\x86\x9e\xcb\x00\x56\x11\xa1\xab\x1e\xa4\x96\x9d\x0f\x82\x45\xdd\x84\xd4\xc1\xcb\x69\x28\xe0\xd8\x77\x1f\x20\x8d\x0f\x40\xaf\xc7\xbe\x7f\x96\xe6\x17\xcf\x92\x0f\x2f\xb8\x3f\x36\xa5\x88\x83\xc6\xdd\x95\x47\xca\xdb\xcc\xed\x40\xcf\x9c\x47\x1c\x27\x6f\xc7\xc2\x59\x84\x4e\xae\x33\x8d\x50\x61\xd1\x3c\x12\xf5\xb6\x8b\xb5\xf3\xae\x97\xf1\x0f\xa5\xd6\x50\x5a\xd5\xe5\x75\x66\x0a\x6a\xd7\x4d\x15\x6d\xbe\xb6\x32\x2c\x1f\x0d\xe8\x53\x58\xb7\x14\x9a\x3b\x45\x78\xa5\x0a\xb7\x9d\xf9\xaf\x6a\x8b\xe8\x2f\xbb\xba\x16\xfd\x65\x85\x85\xf4\x97\x40\x4d\x8f\xe4\x4b\x13\x15\x9e\x8e\xaf\xc1\xff\x50\x41\x12\xd2\x67\xfd\xf9\x14\xc0\x33\x61\xa9\xb1\x23\x68\xed\xa8\xb1\xb8\x19\x47\x65\x54\xc3\x6e\x0b\xc7\x8e\x4d\x2c\x35\x6a\x04\x95\xe3\xad\x76\xb8\xec\xd8\xc9\x41\xb9\x14\x01\x08\x7c\xfd\xb1\x64\x61\x9a\xca\x79\x41\x4a\xe2\x88\xa0\xbb\xf2\xa6\x7a\xb3\xf8\x55\x29\xfc\x1d\x4b\xca\xc5\xe7\x96\xed\xa9\x8e\x62\x95\x1e\xea\x1a\x90\x74\x74\x81\x1d\xb4\x6b\xce\x29\xb7\x46\xdd\x5e\x87\x87\x3c\x2f\x58\xc4\xa6\x70\xec\x6b\x22\xb3\xe7\x23\x4b\xb9\x44\xb0\x69\x24\xdb\x6a\xc3\xbd\x1d\x6c\x7e\xc7\x79\x51\x0e\xd5\x5d\xfc\xdd\x47\x67\xa7\xbf\x7a\x37\x6f\xaa\x66\xa2\xd6\xbe\x41\xf0\x26\x62\x11\x60\x4b\xfd\x22\xe3\x03\x90\xc7\x7d\xa0\x1d\xbe\x74\xb4\x98\xff\x05\xed\x59\xb0\xb6\x82\xd9\x05\x6d\xd9\xb2\x57\xf9\x5f\x54\x4e\x63\xd9\x26\x5b\xfd\xbb\x58\xed\x36\xda\x80\x55\xc8\x4c\xc0\x7d\xcf\xf7\x24\xaa\xb9\x2f\xfa\x15\x58\xff\x46\xfd\x4d\x7a\xb6\xd9\x67\xd1\xda\x07\xea\xad\x00\xf0\xbc\x2b\x92\x85\x32\x15\x7f\xe2\x97\xa3\x22\x9a\x70\x31\xb7\xa3\xed\x30\xfc\xbc\xbe\x1c\x40\x53\x7d\x3f\xcf\xe2\x44\x92\x37\x4a\xe7\x76\xf8\xa0\xae\xc6\xbc\x2e\x3d\x50\xd3\x04\x7d\x78\xad\xed\xf1\x61\x10\x7c\x5e\x77\x14\xce\x54\xfe\x35\xe1\x17\x72\xa2\xe7\xf6\xf5\x28\x08\x3e\xaf\x2f\x0a\xf7\x15\xd5\x9a\x70\x05\xe4\xfa\x4e\xd7\xf8\x61\x38\x8e\x0a\xc1\x25\x1c\xe5\x38\xb2\xda\xda\x00\x96\x4c\x24\xae\x8b\xa0\xe4\x42\x17\xd3\x68\xc8\x17\x01\x9e\x69\x56\x92\x80\x2e\x03\x56\x60\x27\x3c\x4e\x22\x09\xe7\xf3\x4d\x05\x52\xe0\x33\xba\x58\x0a\x78\x94\x67\x65\x67\xa4\x70\x75\x18\xa4\x02\x7a\xae\xa6\x4a\x42\x3a\xd3\x5b\x81\xec\x4c\x44\x67\x19\x68\x78\xf7\xc7\x03\xe6\x1e\xd3\xee\x4f\x6a\xd7\x16\xca\x34\xf6\x22\x49\x53\xe5\x6e\x24\x8f\x1e\xf9\x63\x96\x72\x3c\xe0\xef\xf5\x56\xae\x6a\x5e\x80\x68\x92\x74\x35\xd9\x2d\xb0\x3b\x08\x24\x1c\x24\xc1\x95\xde\x8b\x29\x2f\x46\xa0\x2f\x05\xfb\xae\x7c\xd4\x39\x17\x1d\x31\x1b\x88\xb2\x90\x7f\x15\xfc\x94\x7f\xe8\x44\x65\xa7\x1c\xf3\xce\x80\x9f\x26\x99\x3c\x0a\x3a\x1b\x26\xc6\x9a\x8a\xbb\xfe\x9a\x9f\x1e\x7c\x98\x36\x1b\xff\xb7\xc1\xee\x33\x9a\x92\x95\x5e\x36\xa9\xf2\x62\xd9\x7b\xb0\x79\x8d\xe9\x96\x5c\x94\x00\xd9\x62\x8f\xa1\x4f\x35\x4c\xf0\x82\x08\x37\xb1\x63\x93\xe8\x93\x68\x6e\x1f\x3d\x7d\x86\x83\xa2\xce\xd0\xee\x1d\x2c\xdf\xa4\x33\x1f\xdc\x18\xe6\xec\x4f\x90\xe6\xdc\x03\x9d\x7b\xaa\x68\x20\x4f\x19\x3c\xa7\x8b\xfe\x7a\x3f\x00\x3c\xaf\x13\x0b\x15\x34\xca\xfa\xef\xb6\xe1\xaa\xf5\x9c\x74\x39\xee\xda\xab\x00\x55\x8e\xf3\xad\x79\x64\x45\x6b\xcc\x43\x9c\xb7\x7a\x3d\xb6\x1f\x89\x92\xbd\x93\x10\xef\x58\x99\xb3\x77\xb6\x8d\x77\x6d\x26\x12\x50\x63\x96\x4a\x8e\x85\xd0\x3c\x60\x9f\x77\x3a\x8b\x8a\xb8\x6b\xcc\x7b\xe0\xb2\xfa\x3d\xe8\xdf\x87\xba\x6d\xa2\x61\x02\xf4\x08\x0f\x38\xc8\xe1\xd8\x3e\x5e\x51\x0d\x93\x46\xee\xcd\xe1\xd3\x43\x8b\xa8\xbc\xe1\x88\xb2\xe0\xd1\xa4\x2b\xb7\xa1\x61\x91\x0c\x78\xb3\xf5\x4e\x8d\x0b\xc4\x6b\xfc\x3c\xc5\xa7\x31\xdc\x35\xc5\x38\x9f\xa5\x31\x1b\x70\xb9\x18\xd3\x64\x98\x94\xe9\xa5\x6e\x73\x96\x99\x86\x62\x0c\xf5\x70\x31\xe6\x19\xbb\xe0\x4c\x0a\xad\xf8\xae\x84\xfa\x9f\x44\xb0\x2c\x67\x69\x9e\x9d\xf2\x02\x1e\xe5\xb8\x1a\x3e\x0e\x9d\x20\xe4\x79\xe0\x05\x64\x72\x79\x0b\xa9\x58\x49\x99\x8b\xbf\x2c\x6d\xe2\x45\x05\xad\xa5\xe4\xdf\x27\x81\xb4\x8b\xce\x26\xa8\x34\x6f\x90\x13\xce\xd3\xbd\x2e\xa1\x0d\x43\x26\x82\xd9\x22\x3a\x6b\xb2\x35\xd0\x19\x73\x95\x64\x66\xfa\xd5\x56\x60\x75\x80\xa6\x44\x6b\x61\x5e\x1b\xbd\x06\x61\x91\xb7\x69\x9e\x4f\xe9\xf6\x0f\x1f\x80\x00\x73\x9c\x08\x91\x28\x8e\x8d\xf9\x82\x35\xa0\xcd\xc5\x14\xc1\x1a\xda\xec\xcb\x64\xc7\x50\x09\x6c\x03\xcd\x43\x55\x32\xc3\xae\x26\x88\x10\x18\x52\xb1\xc8\xff\xf9\x95\xe6\x97\xc4\xff\x2c\x05\xc8\x04\x5b\xd8\x80\x7f\x9e\x8e\xf9\xe6\x3b\x5a\xd6\xb0\x0f\x10\xb3\x00\x55\x25\x21\xa1\xe3\xf1\x80\xc5\x90\xe1\x43\x8f\xbe\x15\xb0\x7f\xbb\x0a\x58\x36\x3c\xfc\x26\xdd\x8b\x25\x3d\x7f\x4e\x44\x5d\x30\xb5\x47\xfd\x0a\xe4\xbc\x53\x41\xc3\x7c\xc5\x53\xf4\x8c\x0f\xa2\xc1\x3e\xe6\x2c\x0a\x1a\x26\x3d\xdc\xac\xc2\xce\xeb\xc2\x00\x7d\xbd\x83\xfa\x2b\x1c\x9e\xbd\x1e\x7b\xa2\xcc\x94\x58\xc1\xa7\x69\x34\xe4\x13\xb0\x4c\x06\x15\x47\x7e\xc1\xf6\xd8\xd3\xa8\xe4\xdd\x2c\xbf\x68\xea\xe0\x9b\x19\x2c\x2c\xf1\x52\xde\x6c\x1a\xfa\x97\x94\x41\xb3\xfc\x42\x83\xc0\x84\x68\x08\x54\x40\xb3\xfb\xec\xfe\x7d\x00\xf9\xa2\x47\xb6\xb2\x91\x92\xe5\x68\x80\x47\x0c\xa4\x2a\x4f\x26\x37\x39\x4a\xf5\xb9\x72\x6c\x46\x7b\x62\xce\xe9\x85\x07\x88\x7a\xa3\x5b\x42\x0f\x4f\x8d\x7d\x47\x19\xf1\x48\x5e\x66\xdb\x5a\xb0\xb5\x3b\xe6\xc1\x3e\xb1\xdc\xed\x6b\xde\x36\x3e\xca\x8e\x81\x7a\x76\x1d\x39\xc4\x83\xed\xd2\x73\xfe\xbe\x32\xe4\x73\x4e\x36\x45\x4f\xcd\x60\x60\xc6\x93\x79\xa6\x23\x97\x0e\x3d\xf5\x33\xe5\x3c\xdd\x32\xc9\xdd\xf5\x5c\xa9\x0b\xe1\x7e\xa7\xa3\x00\xf0\x02\x3d\x26\x25\x45\x79\xf7\xb4\xcb\xbc\x1b\x6d\xd7\x30\x17\xc8\x11\x58\x97\x1e\xe7\x66\x0f\xa4\xe3\xb6\xde\x36\xa6\x52\x77\x66\x51\xf3\x3c\xb1\x28\x59\x3e\x53\x68\xa8\x92\xd4\x8c\x7a\x24\x25\xaf\x71\x74\xce\x59\x24\x99\x48\x79\x2a\x4c\xa2\xa9\x55\xa0\x42\x45\x70\x53\xa8\xc6\x44\x20\xa3\xa7\xb3\x33\x47\x02\xab\x07\xad\x0a\x63\x3e\x2c\x32\x17\x12\x29\xac\x9e\xaf\x0e\x92\xec\x3a\xaa\x80\x2c\xcb\x1a\x42\xa0\x08\xa5\x47\xdb\x06\x19\x9c\x67\x65\x52\x70\xec\x20\x11\x2c\xbe\xcc\xa2\x49\x32\x84\x37\x6d\x04\xc7\xf7\x6c\xdd\x1e\x28\x0e\x06\xdc\xbe\x6d\x83\xa8\x0b\x11\x26\x74\xbb\x96\x7c\x0a\x21\xcf\x5d\x53\xa1\xac\x0a\x5d\xd6\x30\x64\x7d\xbb\x84\x64\xfb\x96\x8a\xb6\x6f\x83\xb2\x6d\x9d\x08\xf2\x8d\xc5\x19\x40\x2d\xc7\xe9\xc1\x07\x29\xbe\xf6\x9a\xc7\x4f\x3a\xff\xe7\xa4\xd5\x3b\xd5\x05\x70\x4a\x51\xc1\x56\x7d\xb2\x76\x7e\x6a\xaf\x58\xed\xac\xb2\xfb\x12\xb3\x6e\x99\xff\x9c\x5f\xf0\x62\x5f\x65\xaa\xa3\xbe\x4e\x26\xe4\x6e\x8d\xcd\xa0\x35\x59\xeb\xea\x7e\x10\xb7\xb6\xee\x37\x18\xbb\xe1\xe1\x37\xe9\xea\xf6\x97\xa1\xd9\x5f\x86\x66\xdf\x8c\xa1\x19\x54\x31\xee\xea\x61\xbb\xe5\x6d\x0f\x70\x5e\xd3\x08\xf1\x15\xef\x18\xff\xad\x36\xd7\xdf\xb0\xf9\x9d\x8a\x68\xf1\x2f\x5e\x9a\x03\x7a\xaa\xc3\x13\x42\xcc\x09\xea\xd1\x8c\x27\xe6\x10\xd5\x2e\xb8\x3d\xe1\x9e\x0d\x31\x47\xa9\xd4\xa8\x60\x50\x47\xa2\xa2\x10\x43\xa3\xf8\xf6\xae\x2e\xf4\x34\x48\x68\x51\x50\xa9\xf1\x80\x4d\xa2\x4b\x35\xb6\x64\x64\x50\x92\x22\xc2\x0c\x9f\x61\xbb\xb4\xbb\x46\x03\x2d\xd9\x48\x88\x8e\xc5\x03\x12\xc1\x01\xd9\xc8\x88\xce\xb8\xdc\x01\x09\x3b\xa0\x26\xad\x74\x8b\x43\x32\x19\x41\xaf\xec\x99\x88\x46\x4b\xd6\x88\x5f\x62\xa4\x03\xdd\xc9\x8e\x8e\xde\xfc\xfe\xf3\xc1\xdb\xd7\xbf\xfc\x7c\xb0\xc3\xfa\x52\x5c\xff\xe9\xe0\xf7\x67\xaf\x9f\xbc\x38\x38\x52\x1f\x1f\x78\x8f\x33\x25\xc8\x60\xfb\x47\x47\x0c\xd6\xed\x19\xbf\xd4\x4f\x30\x2b\x57\xbb\xe7\x18\x57\xfa\x27\x1e\x32\xc8\x24\x71\x9f\x3c\x00\xfb\x55\x12\xf6\x0d\xff\xe0\x24\x20\x54\x99\x82\xfc\x5c\x24\xec\x9f\xac\x2f\xd7\x15\x4d\xda\xe0\xe6\x5b\x60\x8f\xdd\xc2\x1d\x9d\x03\xc1\x72\x9c\xec\xab\x8b\xcf\x3a\x4d\xd9\x4f\xdb\x7c\xd4\xc1\x10\x1a\x1f\x1b\x2d\xd6\x61\x7d\x9d\xea\x27\x94\x45\x51\xcd\xb4\x93\x75\x48\x4d\xbe\x09\x9a\x45\x69\xdf\xb5\x54\x6f\x55\xd8\x5f\x39\x21\x48\x24\x76\x97\x6c\xce\x9d\x33\xcf\x1c\x2c\x9a\xc8\xdd\x55\x37\x20\x7f\x3a\x6a\x31\x7c\x39\xd2\x8b\xc2\x3e\x45\x82\x27\x81\x03\xdd\xeb\xb1\x37\x63\x5e\x70\xa5\x0e\x2e\x74\x73\xe8\x84\x20\xaf\x66\x69\x9a\x5f\xc8\x43\x48\x79\x23\x88\x1d\x5b\xb3\x23\xb9\xf9\x11\xfd\x7d\x14\x8d\xa2\x22\x61\x0f\xba\xfd\xee\x43\xfa\xfd\x45\x3e\x48\x52\xae\x8b\x1f\x75\xd7\xba\x6b\x64\x38\x6a\x7a\xc8\x88\xd4\x17\x3f\xe2\x48\xe3\x07\x39\x80\x2a\x67\x05\x66\xd8\x3e\xbf\xb6\x5a\xae\xd1\x4b\x8f\x5e\x33\x85\xb3\xd8\xdc\x96\x29\x26\x26\x29\x54\xb3\xb5\xeb\x6c\x2e\x92\x48\x7a\x7a\x03\x1b\x8b\x2a\xb1\x7b\x0b\x65\x05\x9c\xd4\x10\x93\xa0\x83\x24\xe1\x19\x7c\xc9\x7c\x4d\xf6\x04\x39\xd1\x82\x97\x25\x2f\xd8\x45\x24\xc0\x4d\x46\xcc\x86\x43\x2e\xc4\x68\x96\x76\x11\x7e\x7f\x56\x14\x3c\x2b\xd3\x4b\x76\x91\x17\x67\xe8\x22\x3f\x2e\xf2\x09\x87\xb8\x7c\xdd\x95\xea\x3e\xed\xe0\xb0\xe7\x63\xe1\x1c\x14\x02\xc6\xfe\x6e\xcc\xa3\xf8\x1d\xe3\x29\xe8\xaf\xd8\x6c\x9a\x2b\xc6\x49\x0a\xa1\x4f\x9e\x2c\x66\xc3\x68\x38\x96\x97\xf7\xd2\x46\x30\x3a\xe5\xe5\xbf\x79\x14\xd7\x6c\x2a\x63\x2c\x82\xd8\xd5\x6b\xbb\xa1\x05\xea\xa8\xfa\x25\x78\x4b\x57\x8a\xf3\x21\x6c\x10\x5d\xf8\xfd\xe9\x93\xfd\x70\xca\xcb\x03\xc4\x54\xfc\x78\xf9\x26\x3a\x7d\x19\x4d\x78\xb3\x21\xc1\x1a\xad\xe3\x35\x37\x77\x91\xfc\x1a\x9a\x75\x18\x7a\x24\x2f\xf1\x2c\x1f\xe1\x8d\x15\x32\x5f\xb3\x0b\x58\x48\x72\xf0\x74\x53\x8f\x32\x36\xcb\xd0\xc3\x26\x86\x90\x82\x92\x1c\x70\x4c\x40\xe4\x27\xd9\xd4\x34\x2f\xe5\xfd\x37\x4a\xd3\x4b\xa6\x21\xf3\x8c\x43\xba\x09\x54\x9c\xcc\x04\x3a\x4d\x41\xf8\x82\x64\x74\x09\x7b\x35\xea\x43\x64\x73\xb2\xcf\x61\x5e\x14\x5c\x4c\x25\x6b\x67\xa7\xec\x7f\x74\x79\x97\x3d\x01\x1c\x54\xcd\x84\x17\xb2\x55\x79\x91\xd8\x3f\x3a\xb2\xa2\xda\x05\x67\x59\x5e\x4c\x00\x05\x79\x05\x7a\x47\x27\xfe\x5d\x97\xbd\x19\xe7\xb3\xd3\xb1\xa4\xb5\x4e\x56\x68\x3d\xab\x4a\xfe\x01\xa2\x58\x29\xad\x8e\x30\x63\x18\xe6\x31\x67\xd3\x3c\xc9\x4a\x81\xfa\x9d\x77\x3b\x59\x5e\x36\xff\xf6\xc7\x1f\xeb\x6b\xad\x77\x6d\x89\xc1\xe1\x0b\xbc\xcb\x0f\xf3\xc9\x54\xee\x10\x09\x04\x84\x51\x70\xac\xf5\x4e\xb6\x0b\x4a\x80\xdc\x0c\xb9\x21\x3c\xec\xd8\x05\x38\x96\x4d\xe0\xb8\xd5\x03\x77\x16\xa5\x6c\x45\x5b\x01\x5c\x5c\x5c\x74\x2f\x36\xba\x79\x71\xda\x7b\x2e\x05\xbd\x2c\xc2\x9d\xa0\xf7\xbf\x33\x2e\x40\xc7\xd8\xfb\xdf\xa8\x83\x43\x10\x7f\x1b\x0a\xa1\xfe\xa4\x7c\xfb\x8b\x9e\xd0\x9f\xf8\xa5\x78\x11\x4d\x6b\x78\x58\xeb\x18\x2c\x13\xab\xb8\x17\x10\x6b\x08\xec\x8f\xd5\xf1\x1e\xe2\x6f\x98\x3e\x2f\xa3\x11\x51\x43\x86\x53\xfa\x8d\xa2\x21\x1f\xe4\xf9\x59\x6f\x94\xe6\x17\xbd\x44\x88\x19\x17\xbd\xf5\xed\x47\xdb\x76\xa9\x28\x55\x86\x46\xce\xac\x0d\xbc\xa3\xaa\xe5\xd1\x6c\x40\xb9\xf6\x1f\x0b\x5d\x3c\x91\xbd\x82\x46\x8d\x44\xbd\x0b\x50\x24\xa4\xfe\x35\x75\x6c\xbe\x32\xf4\x3c\xb2\x1e\x7f\xda\x84\x5d\xff\xde\xb5\x27\xce\x61\x26\xf9\x58\xcd\x92\xad\x00\x99\x21\x90\xeb\x92\x91\xe4\x35\xc3\xb2\x11\x1b\x44\xc3\x33\x26\xd2\x48\x8c\xbb\xf4\x28\x35\x75\xef\xde\xb5\x2c\x65\x4e\x99\x3f\xfe\x68\xb4\x4c\xc0\x2d\x27\x88\xd2\xcf\xd1\x9f\x89\x5c\x4c\x18\x57\x0a\x5f\x61\xe9\x2b\xab\xa1\x85\x65\x07\xf7\x79\x4d\x6d\x8f\xcd\x56\x37\x9a\x4e\x79\x16\xef\x8f\x93\x34\x36\x11\x42\x2c\x9c\xc3\x4e\xd6\x9c\x9d\x39\xf1\xf5\x51\x5c\x95\x0b\x15\xb2\xc7\x64\xf4\x80\x61\xf7\x59\x83\x7d\xbc\x6a\xd8\x7a\x78\xef\xa3\x0f\x9d\x34\x58\x19\x33\x0e\x04\x6f\x95\x14\xec\xb8\x0e\x28\xb2\xb9\x46\xc5\xe4\xa4\x7f\x0d\xbb\x96\x0a\x67\xd6\xd5\x1f\x48\x75\x47\x38\x12\x2d\xc9\xf6\xc7\xfa\xd7\xf1\xda\x89\x73\x46\x9d\x68\x1e\x38\xe3\x97\xf5\x01\x41\x99\xc9\x6a\x5a\x25\xb5\x25\x33\xc6\x4a\x0e\x91\x39\xb4\x62\x99\x9f\xbc\x6a\x12\x4d\x43\xa7\xc5\xb3\xc4\x44\xf4\xe3\x3a\xe4\x15\x68\x7b\x23\x15\x9a\x8d\x8d\x93\xd3\x31\x64\x0f\x8a\xf0\xe4\x54\x96\x09\xea\x00\x20\xf2\xc4\x28\xc9\xe2\x7f\x03\x30\x1a\xad\x17\xc6\x31\xc7\x79\x8e\x09\xae\x55\x05\x1a\x5a\xae\x8e\x4b\x88\x82\x33\x0b\xd6\xcc\x65\xd7\x8c\x41\x2e\x04\xf8\xa2\x5d\x47\x70\x18\xff\x64\xee\xef\x00\x98\xe0\x85\xfc\xf3\x95\x3c\x11\x40\xba\x08\x17\x55\xe2\x65\xf9\xc1\xd2\x56\x3c\x27\x9c\xab\xc5\xd4\x96\x84\x05\x42\x8b\x12\xc9\x5e\x47\x5b\x51\x2e\x4f\x5c\x8f\xaa\x10\x02\x8f\x25\xec\x9f\x48\xf6\x4e\xe7\x16\x29\xfc\xb5\x48\x27\x0f\x62\x10\xe4\x80\x6a\xab\xef\x85\x58\x95\xfb\x74\x12\x87\x98\x71\x1f\x61\x5f\xe6\x31\x6f\x96\x46\x9e\x25\xd2\x9b\x59\x5c\xbb\x35\x7c\x29\xe1\xba\x90\xd5\x4a\x36\x12\x3c\x4d\xf0\x41\x34\x96\x5b\x91\x07\xed\x90\x50\x82\x74\xe5\xff\xbc\xd1\xb7\xa9\x87\x92\x8e\xe6\x33\x9a\xe0\x97\x45\x32\x69\x62\x84\x9d\x92\xdc\x48\x2d\x51\xf2\x98\x5f\x87\x5a\x80\xd8\x80\x8f\xf2\x82\x6b\x93\x46\xce\x86\xb0\xb4\xe5\xb4\xe0\xed\x00\xa6\xb2\x4a\xbd\x57\x05\x3f\x07\xd2\x39\x0c\xa6\x74\xf0\xda\x01\x52\xab\xdf\x42\x71\xfe\x77\x57\xb4\x83\xba\xcf\x88\x24\x22\x9e\xbc\xe0\x15\x97\x20\x3b\x22\x4a\x0a\x5b\x89\x59\x26\xa5\x7c\xb5\xfd\x68\x2c\x3d\x76\x5d\xbc\xe7\x78\x5c\xdc\x72\x38\xaf\x5b\xf0\x2c\xe6\x05\x2f\xba\xea\x82\x60\x9f\x84\x0e\xcb\x31\x2f\x2e\x12\xc1\x35\x62\xd1\xa8\x54\x49\xd4\xd2\x48\x94\x66\x15\x2b\xa3\x24\x1f\x9f\xfa\x75\x7a\x3d\x84\xba\x92\x08\x4a\xe8\x39\x4a\x06\x69\x92\x9d\xd2\x80\x58\x8a\x76\x23\x77\x71\xc0\xf3\xc3\x38\x4f\x63\x5e\xa0\x87\xa5\x9a\xaf\x44\x60\x48\x32\x1d\x12\xcc\x5f\xb7\x35\xab\xd6\x04\x1a\xf0\xe0\x6d\x34\xba\xc0\x06\x40\x12\x60\x99\x59\xd3\xf8\xed\x55\x96\xa7\xb7\x4d\x10\x25\x04\x02\x59\x95\x05\xfe\x06\xb2\x10\x7a\xe8\x57\x3c\x08\xae\x06\xe9\xd0\x47\x09\xc7\x8b\x85\x6e\x19\x25\x7d\x90\xd6\xa5\x64\x15\x49\x99\x7c\xc0\xd9\x28\x9f\x65\xb1\x56\x27\x68\x61\x93\x75\x74\x9b\x83\x28\xd6\xed\x0d\x13\xb8\x31\x09\x7c\x22\xbd\x64\x52\xee\x89\x0a\x9c\xff\x7a\xe7\x8c\x10\x69\xde\x0b\xd1\x30\xfe\x1a\xcf\x3d\x04\x57\xff\x2e\x56\xe1\xba\x0c\x98\x75\x1b\x6d\x16\x20\x8e\x13\x15\xcb\x5b\xfb\xd8\xa0\x12\xa0\xf5\xc5\x37\xc9\xca\x1c\x86\xf8\xf4\xf0\x85\xb7\xd8\xb1\x79\xc7\xc0\xa0\xb2\xe4\xaf\xc3\x29\xf8\xde\x8b\x9b\x87\x9a\xea\xca\x5e\x62\x58\x4a\x03\x52\x36\x99\x46\x85\xe2\x0b\x78\x19\x42\x80\xae\xfd\xaa\x16\x29\x54\x37\x1f\x5b\xa4\x9a\xc2\xea\x47\xd8\x4a\xf4\x98\x4c\x4f\xf4\x16\x4d\xd7\xd2\x6f\xa0\x83\x80\x83\x25\x51\xfa\x28\x08\x77\x9c\x5d\xe2\x3e\x5a\x82\xde\xeb\x7a\x4b\xc1\xdd\xf2\x75\x10\x3c\xb2\xf9\xe9\x3b\x92\x28\xa3\xe1\x99\x94\xff\xe5\xc5\x08\xae\x4a\xf6\xbe\xb7\xd9\xdf\x58\x7f\xf8\x60\xfd\x61\x6f\x94\x17\x43\xde\x19\x46\xa2\x4c\xb2\xd3\x4e\x92\x75\x24\xb0\x21\x9b\xdb\xb3\xda\x33\xd8\x1e\xf3\xa7\xc8\x88\xd0\x0e\x9d\x83\xb5\xc3\x44\x7f\x4b\xa9\xfe\x76\x01\xd9\xc3\xed\x92\xe5\x7b\x4d\xf7\x26\x7f\xb9\x24\xa8\x5b\x52\x0b\x58\x72\x77\x23\x3c\xc3\x56\x92\x5e\xc0\x1d\x4a\x71\xfd\x34\x9f\xbc\x56\x9b\xf1\x3c\x4f\x7f\x02\xe6\xde\x2a\xc2\xae\xfe\x04\xdc\x71\xf3\xd7\xcf\x16\x28\x95\x10\xff\x53\x0c\xfb\x6a\x4b\x45\xb8\xd4\xde\x39\xc9\xaf\x5d\xa7\x7d\x54\x80\xe3\x1f\x6e\x49\x40\x5f\x10\xf8\x4a\xea\x8c\x23\x81\xf3\xc0\x63\x7d\x5f\xb2\x9a\x82\x8a\xd6\x56\xc9\xb9\xf2\x8a\x29\xe7\x48\x1f\x71\x46\x71\x04\xca\xf6\x88\xc9\xdb\x76\x1c\xa5\x79\xc6\x99\xb9\x6e\x77\xfd\xc3\x32\x24\x70\x44\x71\xec\x86\x9b\xb6\xa1\x72\xf5\x45\x8e\xda\xbf\x16\x7c\xe4\x04\x63\x66\x8f\xc9\x0f\x2d\xd3\xb2\x1d\xf6\xf1\xca\x5e\x2b\xc1\x03\x46\xca\x3b\x05\x1f\x75\xe1\x07\x2d\x2b\x49\x51\x49\x4a\xb8\x59\x83\x50\xe8\xca\x18\xd0\xa7\x85\xd0\x7f\x51\x75\xe0\x3c\x95\x07\xad\xae\x54\xf4\xac\x21\x85\xc6\xde\x50\x88\x46\x00\x46\xf0\xf2\x49\x59\x16\xc9\x60\x56\xf2\x66\x23\x8e\xca\xa8\xa3\xce\xa1\x06\x39\x6f\x61\x6c\xad\x79\x35\xd1\x19\xa8\x8d\x24\x71\x6a\x96\xf3\x2b\x42\x97\x12\x0a\x2a\x1b\x73\x96\x05\xa9\x52\x20\x77\xad\x18\xe6\x05\xef\xc4\x51\x76\xaa\x82\x3b\xa3\xd4\x9d\x81\xbd\x47\x28\x40\x94\x7d\x79\x05\xa8\xb7\x6f\xa9\x24\x9e\x0d\xf9\x5c\x44\x01\xa2\xd1\xc6\x0e\xec\x71\x6b\x1e\xa4\xea\x0f\x58\x64\x6d\x56\x16\x9c\x9b\x17\x2a\x3c\x5c\xfe\xfd\xe6\xc5\xcf\xc0\xd5\x7a\x5f\xce\x38\x8f\x05\x1b\x25\x1f\x92\xec\xf4\x7a\x9a\xb2\x4a\x20\x0c\xb2\xa7\x78\x41\x30\x50\x48\xad\x8b\x16\xaf\x42\x8a\x9b\x4b\x86\x14\xa1\x70\x89\x42\xa0\x5a\xb0\x7b\xd2\xd8\xaa\x20\x50\xfc\x03\xa8\x24\x53\x2d\x46\x25\x82\x45\x69\xc1\xa3\xf8\x92\xee\xc0\x44\x3f\xe5\x90\x99\x1c\x38\x9f\x3e\xb1\x3b\x76\xd5\x79\xc6\x6a\x78\x1c\xcb\xfd\x42\xe9\x90\x0b\x2d\x85\xf3\x58\x05\xdb\x7a\x87\xbf\x31\x74\xc5\x93\x57\xcf\xdb\x4a\x3e\x7f\x87\xab\x58\x47\xc6\x36\x71\xd3\xdf\xd9\x86\xf5\x4b\x91\xca\x3e\xc5\xca\x71\x2e\x38\xf1\xec\xb2\x9e\x10\x0c\xcc\x48\x38\x44\xb5\x02\x85\x1c\x28\xe2\x66\xa7\x38\xfa\x91\x22\x00\x79\x14\x35\x72\x44\x54\xa0\x58\x29\x18\x70\x45\xcc\xa7\x69\x7e\x69\xaf\x5b\xfa\x96\x83\xd8\x41\x24\x30\x4c\x50\x24\x45\xe6\x0a\xf9\xfc\xdd\xb6\xe2\xcf\x8e\xcd\x37\x89\xde\x6d\xc1\x2e\xad\xf5\x4f\xba\x27\x22\x01\xd2\x09\x6b\x07\x36\xc6\x56\xbd\x8b\x36\x50\xd3\x5d\x15\x2a\x9b\xa7\xbb\x2a\x6a\x1c\xae\x71\xce\x6a\x98\x55\x4f\xa8\x19\x7a\x0d\x63\x39\x6a\x32\x0a\x53\x8b\xf7\xf3\x0c\x22\xd1\xec\x1f\x1d\xe9\x28\xca\xb0\x94\x75\xd3\x73\x11\x96\x64\xaf\x45\x18\xe7\xc4\x09\x7f\x12\x64\xf9\xc0\x78\x5c\x4d\x68\xe3\x8f\xac\xc1\xee\xd3\xb9\xd0\x79\xcb\x9a\x2d\x76\x1f\x8a\xeb\x07\x87\x77\x57\x65\xb9\xb8\xe4\xc0\xec\xda\xaa\x19\x9c\x05\x50\xa1\x52\x40\x67\x15\x48\x38\xa1\x0f\x5a\xb3\xd1\x5a\x7d\xcf\xb2\x1a\x57\x7c\xa9\x30\xda\x74\x3b\x74\x47\x65\xaf\x10\xd0\x09\x06\x74\x2b\x26\x82\x3d\x85\x05\x1b\x3e\xd7\x7e\x41\x4f\x82\x31\xa4\x60\xfa\x52\xdf\x25\x63\x15\x65\xa1\x87\x6a\xd6\x50\xc0\x8c\x82\x5d\x27\xf0\x5e\x94\x29\xf9\x15\x27\x2a\x03\x17\x29\x70\xa2\xe5\x31\xce\xda\x1f\xd9\x1f\xc5\xdf\xe5\x41\xed\x84\x51\xa8\x5a\x60\x30\xa2\x5a\xae\x5b\xff\xa8\x80\x77\x95\x4a\x46\x79\xed\xe6\x1d\xf1\x59\xe9\x29\xda\x79\x23\x2b\xcd\x5f\x16\x12\x70\x0e\xf7\x58\x00\xdf\x8a\x61\x31\xe7\x10\x30\x27\x99\x84\x7e\xf2\xd0\x0d\xd6\xe7\x92\x08\x91\x4d\x1f\x1a\x06\x2f\x77\x92\x1d\xbb\x96\x30\x75\xfe\xc5\x95\xe2\x96\xe5\x23\x16\x19\x5b\x95\xf9\xab\x0c\x50\xae\x5d\x62\xee\x80\x1c\x0a\x91\x55\x53\x25\x52\x75\x09\x59\x7b\x61\x4d\xb3\xb5\x5d\xfd\xf7\x3f\x2a\x6b\x45\x95\xb8\x51\x40\xc8\x9b\x07\x50\xd2\x30\xcd\x5b\x9d\x60\x44\x11\xe9\xad\x4a\xe8\xe2\xf2\xa3\x2a\xec\xf4\xeb\xe9\xa7\x3c\xb0\x23\x30\x12\xd3\x8f\xa9\x2a\x6a\x18\x9a\xf6\x82\x40\xf2\x21\x81\xdb\xaf\x7a\x7f\xa8\x25\xae\xaa\x33\x87\x0b\x09\x84\x35\x7f\xa8\x06\x58\x59\x8a\xcb\x30\x06\xd2\xc5\xbe\x26\x90\x86\x0e\xee\x92\xc1\x1d\x7f\x39\x0e\xb4\x7d\xcc\xe3\x43\xe3\xa8\xae\xf7\xfa\xb9\x21\x69\x4e\x39\xa0\x28\xea\x53\x1b\x41\x71\x4d\x9a\x90\x3a\xce\x63\xe1\x08\x23\x44\x54\x9d\x1b\x5d\xc4\x81\xf3\x4d\xa8\x6f\x16\xea\xfd\x2f\x13\xea\xbf\x4c\xa8\xbf\x05\x13\xea\x6f\xda\xda\xd6\xbb\x92\x23\xb4\xbc\xbc\x8f\xf3\x58\x74\x66\x82\x77\xc0\x55\x5b\x6e\x28\x4a\xeb\x8c\xcb\x15\x2c\xf1\xa2\xe1\x19\xcf\xc0\x1e\x28\xce\xa5\x70\x33\x46\xa1\x1a\x2e\x91\xef\x85\xb5\xb0\xfa\x35\x29\xca\x59\x94\x2e\xa3\x65\xf3\x40\x17\xc4\xd3\xf4\xa0\x5b\xe1\xf8\x91\x1e\x94\x77\x75\xd6\x7a\xb6\x9a\x6d\xd1\x58\xe5\x56\xb7\xc5\xc2\x71\xed\xad\x6c\xb6\xf3\x5a\x3d\xad\x6d\xb5\xd1\xa8\x6d\x93\x28\xfc\xe6\x20\xab\x2d\xfd\xae\x8d\xef\x4f\xbc\xee\x8a\x83\x85\xd7\xc2\x75\x49\x85\x44\xa0\xe6\x92\xb7\xc3\x60\xcd\xa5\xae\x69\x81\x9a\xd7\xb9\x07\x55\xa8\xe0\x19\x62\xdc\x40\x48\xbe\xde\x94\x5d\x4f\xf2\xb9\x26\xda\xd7\x10\x16\x82\xf4\x5c\x46\xe2\xad\xa0\xd4\xe9\xd7\xca\x13\xde\x1a\x9e\x2b\x53\x54\x60\x7d\xb9\xe2\x36\x13\xb9\xdc\x9a\x5c\xf1\x5e\x88\x37\x7c\x32\x4d\xa5\x6c\x5c\xe7\xb2\xfe\x30\x04\x3d\xcf\xad\x84\x80\xd1\xaa\xff\x9a\xe7\xb8\xb2\xf9\x68\xad\x0a\xbb\xa0\x93\x7f\x19\xf7\x15\x5d\xed\xe0\x43\x29\xcf\x86\xba\x2e\xfa\x55\xd8\x05\x5d\x20\x10\xad\xf6\x92\x0b\x4c\xf2\x1c\xee\x62\xb3\x0a\xbb\xa0\x0b\x04\xa2\xd5\xf6\xf3\xc9\x34\xaf\x8f\x21\xf0\x68\x2b\x00\xbc\xa0\x13\x05\xe5\x54\x8c\x26\x3c\x9d\x17\xab\xe0\xd1\x76\x10\x7c\x51\x4f\x1a\x8e\x56\x56\x00\xbf\x64\x49\x5d\x6c\x87\xcd\x47\x0f\x6a\x2a\x2c\xe8\x8f\x40\xba\xb3\x3b\x8d\xe6\x70\xc2\xa3\x2a\xec\x42\x4e\x90\x40\xb4\xda\xaf\x3c\x8b\xf3\xe2\x55\xc1\x47\xc9\x07\x90\x2f\x42\x5d\x6d\xad\xf5\xeb\xeb\x2c\xe8\xd2\x05\xa6\xcd\x80\x08\x78\x94\x17\x75\xd4\xdc\x5a\xdb\x0e\x82\x2f\xe8\xd0\xc0\xdd\xbe\x4b\x98\xda\x2a\x03\x21\x94\xba\xaa\xa8\xc6\x8c\x58\xbf\x98\x05\xdd\x65\xd6\x5c\x77\x99\xb5\x79\xee\x32\x6b\x27\xf0\xea\x46\xc3\x83\xc1\xbe\xaf\x82\xb2\xed\x30\x0c\x27\x40\xf7\x38\x8d\x5a\x4b\x5b\x16\x74\x4b\xbd\xaf\xb5\x99\x86\x56\x5b\x55\x15\x56\x79\xd7\x59\x48\xb5\xe3\x54\x21\x39\xee\x32\x16\x52\x6d\x1c\x55\xc8\x0c\x37\x0b\x0b\xa9\x97\x7f\x15\x74\xa8\x96\x3c\x81\x35\x4b\x38\x00\x6d\x96\xad\x85\xa7\x8b\xb0\x5a\x23\x26\x0b\x8f\x8e\x11\xd6\x52\x68\x8c\xb0\x7e\x2c\xa4\xb7\x14\xaa\x35\xce\x5d\xf6\xb7\x35\x2d\x3b\x57\x2b\x4d\x0d\x0b\x9f\x28\x7b\xd4\xea\x49\xfc\x1f\x4d\xf3\x54\x9b\x1c\x2d\x2a\xe6\x84\x8d\x79\xe4\xc2\xcd\x4d\x8b\x26\x01\xbe\x62\xc0\x49\x27\x0c\x95\x1b\xf8\x2f\x1c\x9f\x8a\xc4\x00\xa1\xa1\xb1\x03\x56\x5d\x4e\xe4\x6c\x4c\x29\x06\xa3\x77\xf3\x89\xd9\xc0\xe8\xbb\x26\xd4\xc0\x82\xdc\x3c\x8e\x93\xfd\x47\x3f\xc2\x96\x3b\xa2\x30\x0f\xdd\x66\x66\xa8\x6f\x3d\xd5\xd3\x57\x62\x24\xc1\x27\xc9\x6f\x49\x39\x7e\x29\x65\xc4\xde\xee\x1f\x59\xcf\x1a\x92\xbf\x8c\x92\x73\xf4\xd1\x04\x0e\x00\xbf\x16\xd6\xd1\x79\x35\x05\x78\x74\xa1\x4a\x77\x90\xc7\x97\xac\x99\xe5\x36\x35\x52\x0b\x61\x15\xd2\x02\xfa\x19\xe6\xa9\xbc\x12\x66\x31\xa8\x31\xc0\x1a\xc0\x5a\x60\x62\x64\x9a\x26\xff\x30\xe4\xd3\x92\xe5\x23\x34\xc9\x94\x40\xaa\xa9\x97\x39\xc3\x8d\x58\x29\x42\xd5\x93\x0a\xa8\x1e\x16\xb1\x9e\xe3\x0e\x4a\xfd\x64\xf0\x68\x82\x2f\xd3\x34\x51\xfe\x80\xe8\xcd\x29\x7f\x37\x2d\x79\x6a\x0d\x8a\x01\xb0\xce\x8c\x18\x62\x13\xed\x21\x0c\x18\x0f\xaf\x68\xcd\xfb\x1d\x08\x28\xe8\x79\x9b\xa0\x45\x65\x9a\x67\xcf\x95\x8a\x5a\x02\x59\xdf\x8f\x9d\x86\x63\x46\x69\xe1\x3c\x77\x90\xc5\x2f\x55\x2f\xa2\x74\x94\x17\x13\x1e\xd3\x47\xd2\xd5\xbf\x8b\xd5\x06\xc6\x5b\x9a\x9b\xd9\xd3\x44\x7f\x51\xf8\x29\xc7\xd7\xb5\x36\xc1\xbd\xa5\x0c\x9f\xed\xb8\x74\x80\x22\x5a\x85\x8c\xe1\x3e\xeb\xbb\x75\x48\xf4\x21\x37\x79\xa8\x1f\x20\xa8\xba\x51\x3c\xfa\x26\x53\x3f\xa1\xc0\x21\x6c\x34\xd9\x48\x88\xe4\x34\x03\x6d\xad\xe1\x54\xd4\xa1\x56\xd4\xc6\x7d\xe4\x35\x5f\x1a\x73\x54\xc7\x22\x9f\x15\x60\x3d\x63\xc5\xaf\xe4\x64\xd7\xb6\x73\xc6\xc1\xa2\x03\xc1\xb4\xf2\x51\xa1\x62\x74\xa5\xdd\x71\x24\x0e\x2f\x32\x3d\x4a\xcc\xbd\x85\x55\x30\xab\x3c\xe8\x22\x01\x49\x88\x0c\x2b\x99\x1b\x4a\xe1\x17\xaa\x77\x8d\x82\x17\xe1\x30\xe1\xf4\x5f\x1a\xf5\xbf\x34\xea\xd7\xd7\xa8\x07\xf7\x75\x23\xff\x93\xdb\x56\x5d\x60\xdb\xad\x87\xdf\xb8\x62\x5e\x6f\xa6\x68\xca\xd9\xf8\x01\x2f\x30\x8d\x5d\x55\x20\xe5\x70\xb7\x88\x35\xd4\xb0\x91\x06\xfb\x3a\xb0\x99\x2f\x09\xfa\xfa\xf6\x00\x78\x13\x98\x09\x93\x62\x57\x22\xec\x85\xf5\xf0\x81\x56\x1c\x13\x4d\x6d\xb6\x68\x86\x61\x8b\xce\x60\x18\x67\x8e\xa5\xaa\xbd\x68\xaa\xbf\x48\x59\xa1\x9e\xc3\x25\x69\xe5\x14\x77\x75\xec\xb5\xa6\xde\x4a\x9b\x24\x4c\x5f\xdb\x9c\x7e\x68\x39\xb4\x03\x8d\xe0\xa9\xd5\x6a\xf9\xf1\x3f\x8d\x27\xa2\x0e\xb4\x25\x3c\x33\x24\xb4\x1d\x03\x33\x54\x05\xaa\x09\x75\xac\x3f\x9c\xb4\xd9\x47\xd3\xd0\x8e\x6d\xf2\xca\xb5\x4b\x22\xcd\xa9\xc4\x18\xcd\x80\x01\x22\x86\x41\x31\x76\x18\xca\xca\xd0\x79\xdc\x08\x90\xde\x7b\xe0\x50\xba\xda\xf9\x9a\x5c\x15\xaa\x21\xf4\xf2\x8b\x58\x9e\x72\x15\x08\xbc\xee\x41\x1a\x23\x34\xaa\x77\x7c\x15\x49\xbd\x50\x6f\xed\x3a\x4b\xc6\xdc\xf7\xe9\x28\x8e\xe7\xe0\xa9\x4a\x55\x24\xc6\x90\xfb\x02\x0b\x24\xdf\xb2\x13\x16\xac\xe7\xbc\xd0\xeb\x7b\xab\x64\x2a\x8d\x6e\xe0\xe2\xe4\xbd\xd4\x17\x0b\xde\xe8\x89\xad\xc8\x22\x7b\x9a\xe5\xb4\xe6\xae\xe5\x42\x75\xa2\x1c\xb8\x45\x56\x18\x42\x99\xb0\x38\x06\x89\x41\xe4\xb4\x39\x56\x0d\x76\xc4\x50\xad\x1e\x35\xdf\xa4\x2b\xa0\xe7\x0f\xb0\xb3\xd6\xf5\xdb\xdd\x4d\x29\x22\xe2\xe5\x36\x37\x0a\x3d\x97\x7d\xe6\xed\x6d\xb4\x11\x67\x6b\x53\x21\x50\x30\x98\xc9\xa2\x1d\xcc\xf3\x1a\x97\x95\xb4\xd0\x6b\x36\x75\x25\xad\xb4\xbc\x3d\x8f\xb8\xe2\x48\x06\xb5\x81\x4a\xfd\xad\xa8\xcd\x96\xdf\x08\xb5\x05\x7b\x75\xbf\xb2\x5b\x64\xe8\x45\xb5\x4a\x13\x6f\xcf\x59\x96\x5b\x2a\x0b\xd8\x67\x9a\x6e\x05\x74\x01\xeb\x50\xa4\x28\xe7\x08\x3e\x8d\x8a\xa8\xcc\x8b\xd7\x26\xb0\xe0\x1f\xe2\x5e\xfb\x0f\x71\xaf\x77\x4a\x65\x81\x28\x8e\x8f\x86\xf9\xd4\x21\xab\xfc\x6d\x6f\x89\xd3\xa8\x80\x80\x65\xc6\x0b\x5f\x5f\x0a\x9d\x0e\x4c\x32\x06\xa8\x1d\xcb\xd3\xaf\x51\x77\x59\x84\x16\x43\x97\x45\x55\xf7\xfe\x1e\xfe\x05\x1e\xf2\x0d\x76\x1f\x2b\x1c\x27\x27\xce\xd5\x48\xb9\x49\xc9\x02\x79\x6f\x3a\x69\x91\xea\x8d\x36\x6b\xf8\xf7\x24\x28\x04\x2f\x18\x33\xf8\x71\x94\xc5\x29\x47\x95\x67\x48\x32\xb0\x7b\x8f\xab\x0f\xa6\x19\xfc\x0c\x4f\x91\x58\x9c\x24\x36\xb9\xde\xa1\x85\x13\x95\xf6\x27\x79\x4d\x30\x69\x8e\x55\xc4\x09\x62\x2a\x5e\xc9\xba\xe4\x04\xa5\x70\x72\x07\x76\xdd\x93\x02\xe3\x3e\x40\x7e\xa5\x45\x2b\xc3\xae\x02\xc3\x04\xb6\x0d\xe3\xee\xdf\xaa\x2c\x8d\x4a\x60\x5c\x1c\x4d\x95\xb0\x9a\x37\x91\xb4\xb7\x45\xd1\xf9\x71\x80\x95\x28\x3f\x25\xf7\x71\x85\xa2\xde\x68\x40\x51\xaf\xbe\x51\xd5\x43\x68\xc7\x32\x84\xa1\x4d\x7a\xed\xf9\xf4\xda\x9d\x33\x47\xde\xde\x85\x17\xfb\xe5\xe7\x29\xb4\x5b\xd5\x05\x2a\xa6\xd1\xd8\xf6\xf3\xec\x9c\x17\xa5\xab\x3a\x2a\x73\xbd\x49\xc8\x29\xd7\x2e\x03\x7c\x82\xb6\xed\x36\xdc\x0c\xc8\x7b\x3a\x9a\xcb\x0f\xb2\xc2\x84\x7d\x94\xa3\xb9\x82\x86\xe0\x6b\x34\x4d\xd8\x74\x36\x48\x93\xa1\xeb\x82\x69\x2e\x29\xfe\x51\x15\x88\x70\x5d\x23\x81\xeb\xb8\x5a\xa0\xdf\x31\xd3\xe6\xfb\x8f\xf3\x8b\xa0\x68\x1f\x6e\xd9\x91\x12\x74\xfb\xc7\x6b\x27\xa8\x09\xfe\xa1\x01\x0e\xec\xe4\xac\x02\x1e\xf2\x8e\x2b\x85\x8e\xfa\x3a\x07\xa1\xba\xe3\xb8\x0e\x1f\xeb\x28\x4a\x8e\x40\xfc\x80\x8e\xe7\xd4\x41\xd4\xb5\xc2\xc7\x6f\x36\xae\x99\xbe\x7f\xc8\x8b\xbb\x2a\x73\x1b\xac\x82\x52\xd3\x58\xf7\x35\xc9\x8b\x72\x72\xe5\xd3\xd0\x7b\x7b\xb2\x0b\xc0\x3d\xff\xdd\x6c\x13\x26\x75\xce\x8a\xcb\x1c\xf3\xd2\x4b\x14\x26\x76\xdb\x1d\x54\xdc\x83\xf3\x98\xeb\x68\xb3\xd4\xc6\xbe\x4b\x40\xeb\xb6\x2a\xdf\x27\x79\x5e\x5e\x9f\xf6\x62\x6d\x7e\x45\x47\xf7\x4d\x26\x93\x53\x4f\x24\x7b\xda\xf5\xf7\x08\xe3\xe5\x4b\x3e\x59\x35\x57\x77\xe2\x1a\x8c\xe5\xdd\xa4\xe4\x20\x10\x20\x20\x06\xd9\x5f\x65\x8f\x89\xbc\xea\xaa\xeb\x55\xed\x7c\xf0\x7e\x97\x5d\xb1\x9d\x5a\x38\xa5\xd6\x5f\x84\x4c\x3e\x78\xdf\x1d\x5a\xb5\x04\x40\x28\x60\x2c\x05\x7e\x51\xb8\x1a\x25\x0e\x7b\x6c\x51\xdd\x71\x51\x9a\xa3\x79\xc1\xf7\xd4\xaf\x11\x2f\x76\x89\xbc\x45\xfd\x07\x0f\xfe\x1b\xf2\x16\x61\x0c\x2e\x64\x51\x7a\x8b\xd1\xdf\x54\x1f\x76\xad\xa9\x5e\x9a\x76\x52\x70\xab\x32\x8f\xec\x0d\xf6\xd8\xf9\xb5\xa3\x59\x17\x9a\xc2\x2d\xba\x81\x01\xcc\x61\x4f\xbf\xf3\xa4\x28\xa2\xcb\x6e\x22\xe0\x5f\xec\x4f\x7e\x5e\x90\xf0\x45\xc2\x19\x05\x3b\x9a\x84\x0e\x67\x85\x48\xce\x79\x7a\xc9\xf0\xe4\x26\xa7\x24\x39\xfd\xb0\xac\x36\xc9\xb0\x32\xae\xd7\x0e\xd0\x01\x23\x83\x0d\xd7\xc8\x60\x63\x9e\x91\xc1\x86\x36\x32\x70\xdf\x39\x31\x54\x94\xc2\x32\xf4\xd2\x19\x88\x1a\x85\xb1\x50\x46\xea\xba\x89\x12\x8c\xd6\x9b\xd0\xf6\x1c\x67\x14\x55\xc1\xf7\xad\x30\xed\xec\xed\x29\x27\x84\x65\x3d\x88\x9e\xa0\x66\xa3\x2c\x12\x14\x56\xd4\x18\x92\x52\xf0\x74\xc4\xfe\x28\xfe\xc8\x88\xf3\x10\x57\x91\x19\x75\x7f\xde\x41\x57\x8d\x88\xa5\xe5\x1b\x13\x42\x3f\x58\x4f\x5d\xe4\x8b\xe8\xe2\x98\x0e\xfc\x84\x06\x02\x53\xb3\xec\x34\xe8\xcc\x76\xdb\xcc\x72\x28\x39\x8f\xbd\xde\x31\x33\x08\x97\x4f\x1d\x92\xeb\x91\xd8\x7b\x95\xf5\x7c\xd1\x8e\x2f\xb4\x82\xbd\x66\xf9\xbe\x2f\x94\x3b\x15\xb0\xf2\x94\x9a\x8f\x3d\xc1\xd5\x43\xc5\x11\xc8\x35\xc2\xae\x84\x02\x0f\x66\x92\x0b\xb1\xd4\x91\x37\x02\x08\xa9\x7f\x16\x91\x93\x90\xce\xec\x26\xce\xb8\x30\x3b\x80\xcf\x9b\x77\x74\x43\xaa\x9c\xb9\xbf\x49\xd0\xbf\x3a\x7a\x29\xf9\x3d\x88\x9d\x9f\x6e\x8b\x92\x8c\x41\xca\x27\xaf\xb3\x6a\xcb\xbe\xb0\x85\xff\x1f\x22\xa9\x4e\x2f\xd9\x20\x12\x4a\xea\xef\xae\x2c\xcc\x9d\x80\xf1\x2d\xaa\xe4\x77\x9f\x36\x1d\x0a\x1a\x04\x55\x72\x05\xb9\x19\xb9\xe4\xd5\x25\x61\xa6\x52\xa5\x75\xe4\x71\x52\x36\xd4\xce\x60\xb5\x0b\xaf\x01\xb6\xb7\xb0\x53\xb7\x8f\xfa\x76\x68\x03\x34\x1a\xd5\x0a\x15\xeb\x55\x90\x0a\x7b\xb9\xfa\x37\x08\x90\xec\x1d\x62\xf1\xce\x09\x77\xfd\x79\x57\x26\x94\x2e\xaa\x57\xa6\x25\x53\xd7\xd3\x87\x61\xbd\xf3\x3f\x9e\x77\x18\xed\x90\x2c\x33\x2b\x41\xeb\x14\x95\xbe\xc7\xfd\x1d\x96\x68\x6f\x33\x8b\x65\xef\x1e\xfb\xed\xe0\xc7\x57\x4f\xf6\x7f\x62\xbf\x3e\x79\xcd\x9e\xbf\xfc\x9f\x83\xfd\x37\xcf\x0f\x5f\xb2\x7b\x3d\xdb\xb6\xbe\x70\x7c\xec\xdd\x63\xea\xaa\x72\x91\x64\x71\x7e\x81\xef\x07\xd8\x75\x57\xf5\x5c\x6b\x96\xb9\xd1\x52\x0d\xc9\xcb\x92\xaa\xff\xe9\x13\x28\xe6\x30\xaa\x60\x2d\x26\x57\xf8\x3c\x3c\x6f\x68\xcd\xcd\x7e\xab\xd5\xaa\x90\xea\x76\x33\xa1\x55\x06\x6a\xdd\x24\x40\xbe\xb5\xe2\xcd\xab\x3c\xbb\x1c\x25\x69\xda\x2c\xf2\x1c\xb8\xe6\x3b\x3c\xf1\xc5\x2c\x2d\x77\xf1\x87\x96\xb2\x99\x04\xe9\xe2\xaf\xdd\x95\x95\xef\x88\x64\x41\x04\x71\x9a\x46\xe9\xe3\xca\x77\x00\xa5\x04\xed\xdc\x8a\x99\x50\xf4\x1d\x76\xc3\x8c\x24\x6e\x01\x76\x57\xbe\xfb\xce\xac\xd1\x2a\x64\xb3\x61\x41\x1b\x2d\x09\xfc\x5d\xa5\x09\x38\xc8\xd5\x30\xbe\xbb\x5a\xa1\xcd\x99\xd6\x1a\x3f\xfc\x40\x1a\xda\x5d\xf9\xee\x6a\x65\xe5\x3b\x93\x02\x16\x2b\x4b\x31\xca\x9f\xad\x6f\x2c\x69\xcc\x5f\xe6\x14\x21\x3b\x5e\x63\xc1\xfa\x5f\x65\x98\x16\x30\x51\x5e\xac\xc3\xb7\x8a\x22\x5b\x7c\xd7\x66\x0d\x1a\x91\x4a\xdf\x37\x8f\xff\xb8\xe8\x9c\xdc\x87\xa4\x42\xdf\x82\x52\x10\xe7\x48\x9d\x70\xbd\x9e\x7a\xf8\x25\xef\x25\x6c\xc0\x55\x0c\xa5\xbc\x60\xdf\x17\x7c\xe4\x66\xeb\x63\xee\x83\xae\xf2\xfb\xe1\xa3\xa6\xc9\x70\xe6\x1d\x86\x76\x31\x40\xb8\x6a\x64\xbb\xd0\x33\xaa\x69\xc0\xdc\x78\x74\xa6\x69\xaa\x7f\x6a\xd1\xe7\xd0\x4a\x20\x64\xe7\x86\x63\x0d\x85\xbd\x00\x09\x90\x4c\x16\xe2\xe1\x25\x2a\x94\x78\xc1\x47\xbc\xe0\xd9\x50\x07\x48\xf8\x3b\x44\x8e\xff\xbb\xe8\x36\x00\xdf\x36\x41\x4e\x5f\x53\x20\x46\xd3\xa7\x4f\xb6\xc4\x7f\xaf\x35\x96\x06\x57\xe6\x78\x87\x40\xa1\x91\x78\x92\x39\x31\xe0\xf1\x8b\xcd\x03\xe5\x64\x82\x32\xc6\x77\x77\x4d\xdc\xe5\x5d\x93\xc2\xc1\xf7\xbf\x7a\xa5\x98\x72\x24\x9a\xc8\x5b\xaf\x20\x45\x07\xf2\xea\x2b\x92\x8e\xd5\x72\xb0\xf6\xe2\x93\x1b\x99\x85\x9b\xf3\xd2\xa4\x6f\xcf\xb2\x79\x5a\xd9\x76\x58\x5b\x79\xc5\x5e\x71\xf5\x89\xd0\xf0\x2d\x23\xdc\xc7\x2a\x8a\x60\x7d\xe0\x6d\xa3\xb4\xf5\x6a\x58\x8b\x47\xd2\xc1\x7b\xec\xe0\x3d\xfb\x87\x3f\x08\xd3\xc1\x7b\x37\x50\x81\x1d\xaf\x19\xa6\xed\xe2\x3d\xb9\x91\xe2\x2d\x58\x0e\xad\xa5\x87\x48\x5e\xc4\xf0\x3f\xc8\x69\x80\xc1\x07\xa2\x34\x65\x77\xd9\xe0\x52\xc5\x40\x86\x31\xe4\xda\xe8\x86\xdd\xb5\x61\x7c\xd5\x8d\xd8\xb4\x61\xdb\x56\xac\xa3\x3c\x04\x20\x73\xba\xfc\xcb\xe4\x0f\xa3\xbb\x94\xe6\x03\x29\x75\xaa\xde\xf4\x2b\x5f\xa6\x36\x6e\xf7\xce\x43\x59\x51\x1f\xcf\xbe\xc2\xf8\x94\x97\x87\xb8\x20\x54\x40\x02\xb3\x1c\x2a\xcf\x09\xbd\x1e\x53\xa0\x12\x6d\x36\xe0\x3c\x33\x91\x9e\xf0\xc9\x37\x6e\x43\x22\xd0\x0b\x4c\xd6\xc0\x92\x4c\x7e\x86\x70\xa9\x18\xbe\xd8\xd5\x77\xdb\xf8\x10\xe1\x37\x1c\xac\xb6\xe3\x05\x69\xbe\xcf\xfa\x36\xf3\xb2\x9e\xd9\x24\x3b\xfd\x99\x9f\xf3\xd4\x7b\x0e\xeb\xd2\x32\x55\xc5\x03\x77\x7f\x7a\x2a\xa2\x3e\xdb\x71\x01\xee\xb3\xbe\xab\x85\x77\x50\x77\x5e\xe2\xc8\x65\xc9\x36\xe0\x36\xa7\x5f\xeb\xd4\x38\xed\x16\xe5\x1a\x70\xdc\x67\x7d\xf5\x6a\x35\x47\xdf\x5f\x9b\x0c\x74\xa1\xde\xdf\xde\x60\xb4\xfd\xb0\xce\x74\xe9\x11\x53\xbf\xa4\x68\x40\xfb\x04\x69\xb3\x05\xe8\xed\x41\x9f\x2a\x5e\xe1\x32\x89\x48\x13\xeb\xad\xa7\x56\x87\xc9\xb9\xe4\x83\x90\xac\x28\xca\x36\x93\x3c\x45\xb9\x01\x7e\x4c\xab\x77\xef\xb2\x3b\x81\xfa\x95\xe7\x4c\x46\xc6\xb7\xcc\x22\x71\xba\xd3\x1d\xf8\xbb\x10\xcd\x03\x50\xd9\xf1\x6d\x8a\xcb\xae\xf3\x5a\xc9\x48\x78\x7e\xbd\xd2\xf4\xa1\xa7\x9b\x29\x2c\x4b\xbc\x9f\x89\x92\x41\x1c\xbc\x91\xdb\x80\xdc\xae\x1c\x89\x45\xee\x4f\x2a\x44\x1b\x89\xa5\x2c\xff\x6b\xed\xe2\xeb\xba\x99\xc7\x96\x3b\xa7\x35\x92\x43\xdd\x26\x29\xa5\x10\x41\x5b\x17\x34\x36\xa5\xb2\x8d\xb0\x29\x13\x47\xaf\xdd\xac\x89\xb2\x7f\x12\x6d\xdf\xae\x93\xcf\x7b\x1b\x0e\xdb\xdc\x85\x35\x62\x01\x3e\xf9\x58\x45\x84\x8e\xfb\x15\x8c\x7a\x48\x38\xb3\x48\x4e\xc7\x34\x56\xb4\xda\xbb\x51\x45\x9b\x33\x9e\x89\x59\xc1\x15\x54\x5e\x60\xc4\x04\x4b\x2c\x33\x48\x95\xad\x7c\x96\x92\x64\xc6\xa6\x50\x67\x14\xf0\x28\x40\xc7\xea\x30\x96\x31\x32\x24\x21\xdf\xea\xb2\xf6\xba\x07\xc9\x2d\xea\x3b\xbe\xb1\xbc\x97\xc1\x2b\x91\x72\xd5\xfb\x6f\xbf\x13\x91\xf4\x4f\x7e\x96\x19\x7d\x05\x41\xfa\x5d\xd9\x9b\x8a\xb9\x8d\x28\x00\xb4\xae\xba\x42\x6b\xe4\x97\xd1\x44\x85\x00\x51\x16\x81\x00\xa9\xd9\xe1\xc7\x3c\x4f\x79\x94\x5d\xb1\x51\x1a\x9d\x42\x90\xa3\x64\x18\x41\x8c\x26\x33\xd2\x8b\x48\x90\xec\x4f\xa9\x14\x9c\xb2\xbc\x74\xaf\x3b\xda\x3a\x14\x4d\xc9\xd4\xd6\xab\x7b\x37\x37\xa0\xa3\xb3\x64\x0a\xd6\xf5\x97\x2a\x0d\xb1\x36\x0e\x22\xa0\x4e\x94\x04\x55\x0d\xfd\x7f\x58\x54\x14\xd1\x25\xcb\x47\x6a\x34\x19\x44\x79\x7e\xf7\x51\x79\x62\x8a\x1d\x76\xdc\x18\xe5\xb9\x14\x02\x07\x51\xd1\x38\xb9\x7a\xa7\x9a\x77\x5f\x1a\x6c\x5f\xcb\x3c\x33\x18\xe8\xfa\x37\x06\x3c\xe7\x8e\x78\x89\x47\xe1\x5c\x52\xa8\xc7\x07\x2f\xfc\x9d\xaa\x1c\x0a\x6f\xe6\x2e\x69\x6d\x9c\x70\xe5\x51\x46\x4c\xe5\x56\xa6\x2f\xb5\x71\x2d\x81\x24\x7d\x98\x24\x8e\xa1\x8d\x1d\x9f\xb9\xfe\xb0\x46\x8b\xfd\x93\x78\x19\x19\xb9\x74\xce\xb8\xd4\x45\x44\xd6\x6d\x39\x77\x30\x73\x61\x08\x0a\x28\x2b\x6e\xfe\x6e\x3e\x92\xdb\x6c\xc4\xd2\x7c\xa8\xb8\xba\xbb\xe2\xe3\x69\xe4\x86\xef\x9d\xe8\xf4\xf6\x29\x4f\x89\xf0\xfa\x66\x4b\x50\x44\x43\x97\xbe\xb1\x11\x57\x27\xa7\xf7\xa4\xb7\xd4\xc5\xf6\xb5\x77\x8b\x55\x81\xac\x95\x40\xda\xf5\x5f\xee\xdc\xeb\x6a\x75\x7a\xc3\x8f\x88\xd7\xc2\x68\xff\x72\x98\x26\x43\x86\x73\x9d\x28\xf7\x9a\x92\x0f\xcb\xcf\x40\x47\x91\x10\x48\xc7\xc5\xb1\x3e\xb2\x4e\xe0\x8e\xa5\x8d\x15\x1d\x08\xf5\xb0\x78\xa6\x4d\xfe\xc2\x1c\x1b\xe0\x81\x79\x9d\x98\xa9\xa3\x16\xa1\x26\x3f\xa5\xa7\xe1\x51\x4c\x6e\xd3\xa3\x49\x4e\x8a\xcd\xd1\x0e\x6d\x19\x6d\x8f\x01\xba\x5d\x8d\x8f\x3a\x82\x96\x7f\xd4\x70\xd2\xcc\xe1\x5b\x86\x5e\xac\x21\xa1\x3f\xb4\x04\xbd\x5a\x26\x2c\xb3\x8a\xe8\xaa\x0b\x1c\xba\x4c\x0b\x7e\x8e\x61\x8f\x47\x49\x96\x94\x9c\xa5\x79\x3e\xed\x56\xec\xec\x4c\xab\xbb\x35\x62\xc5\x0d\xa5\x8a\x6f\x2c\x14\x5c\x30\x79\xb8\x71\xdc\x9f\x93\xc1\xdc\x9a\x4c\x28\x41\x5a\xbb\x59\xaa\x6c\x4b\xc0\x64\x78\x26\xff\x4d\x09\xca\xdd\xd0\x71\x2d\xca\xc2\x39\x9b\xd5\x77\xff\xa4\xbd\x6e\x5e\xf4\xea\x52\x91\x63\x82\x30\xd1\xb1\x65\x0b\x3c\x2c\xca\x9c\xc5\x91\x18\xdb\xa3\xa4\x4e\xf6\x00\x2e\x70\xb0\x55\x25\x2e\xb6\x43\xec\x12\x70\x21\x37\x48\x75\x7b\x3d\xc7\xa0\xd0\x7b\xda\xa4\x63\xfe\xa5\xd3\x54\x00\x91\xb7\x36\x71\xfb\x89\x63\x84\x7c\x62\x36\x1f\x74\x5d\x93\x6c\x3d\x8a\xd2\x74\x10\x0d\xcf\x1c\xf3\xcb\x90\x39\x82\x05\x6c\xd9\xde\xed\x57\xf3\x9c\x6d\xbe\x74\x27\xd1\xb4\x49\xc6\xac\x6c\x36\xc2\x75\x2b\xb4\x21\xfd\xf9\x62\xbb\x69\x81\xce\xe7\x93\x34\xcd\x2f\xe6\xcd\xe6\xe0\x52\x57\x94\xdc\x08\x2a\x6e\xc8\x44\xa7\x66\x99\x17\xc9\x9f\xd5\x19\x76\xb6\x3b\x3a\x95\x7a\x25\x2c\xb3\xbd\x2d\xa0\x6c\xcb\x89\x5b\xae\x1e\x97\xf1\xaa\x9b\x26\x67\x9c\xfd\x30\xca\xb3\xb2\x33\x8a\x86\xbc\xad\x52\x1f\x0d\xa3\x8c\x8d\xa3\x73\xce\x26\xb3\xb4\x4c\xa6\xa9\xda\xa2\x40\x79\x1c\x65\x28\x1a\xfa\xfa\xc7\x5a\xab\x91\x5a\x51\x4e\xfb\x22\xa3\x94\x16\x9a\x23\x5f\x80\xf3\x62\xa4\x92\xcd\xda\x95\xdc\xaa\x0b\xe1\x76\x6e\x66\xdf\x64\xd8\xab\xbf\x6c\x2b\xe7\xda\x56\x92\xd0\x2e\x5f\xd9\x02\x12\x2a\x93\xee\xeb\x4d\x05\x1e\x06\xc1\xe7\xf5\x45\xe1\xbe\x92\xb5\xa5\x3e\xd7\xd2\x3c\xe3\x98\x31\x18\x0d\x21\x31\xf5\x4f\x1c\xcb\x4b\x45\x70\x7b\x3c\xe7\x85\x48\xf2\xcc\x33\x65\x8c\xe2\xd8\xc4\xf0\x89\x7f\x45\x10\x6b\xb0\xe9\x1d\xff\x9d\xe3\xa8\xf3\x27\x9e\xff\x8e\x2a\x95\x3e\x37\x55\xce\x6a\xfa\xde\x74\xdc\x3f\xe9\x96\xf9\x2f\xd3\xa9\x3d\xaa\xd5\x03\x96\xb2\x99\x3c\x1c\xbc\x37\xd6\x59\xfe\x5b\xb4\xc1\x8a\x29\x48\xfd\xa6\x9c\xab\x3f\x77\xbd\xb2\xb9\xc7\x25\xad\x74\xe5\x18\x02\x1d\x0e\xde\x9b\x9c\x3a\x33\xc5\x30\x41\x32\xb9\x6c\x42\x2d\x1e\x03\x26\xa5\x2c\xe6\x7c\xaa\x13\xe7\x47\x42\x50\x75\x83\x77\x1a\x19\x55\x06\x66\x9b\x36\x53\x48\x61\xd4\x5b\xfc\x27\x38\x60\x3e\xbd\x84\x34\x4d\x9f\xb0\x62\xeb\x8a\x4c\xba\xce\x8b\x5c\xd1\xa3\xe0\x8d\xc4\x91\x66\xe6\xb7\x89\x6f\x34\x12\x6d\xdd\x28\x4d\xc9\x05\xdb\x18\xa7\x49\xfb\xbd\x17\x1a\x10\xf7\x31\x9b\xbf\xa6\xb5\x8a\x7a\xe1\xcb\x46\xbf\xaa\x50\x1a\x6e\xb1\x72\xbd\x56\x9b\x8d\x0a\xb7\xb1\xa4\xd5\x30\x76\xbb\x4b\x0c\x68\x1d\x13\xe2\xfa\x83\x1b\x2b\xb6\x74\xe7\x0d\x38\x72\x1b\xd6\xa4\x6e\x81\x81\xb1\x5f\xdd\x31\x4f\x51\x27\xa1\xb8\x48\x20\x1c\xbf\x84\x31\x52\x5f\x24\xb8\xc1\x6e\x27\x68\x66\x69\xc4\x26\xc7\xd2\x92\x88\x01\x19\x2f\x5e\x29\x89\x52\x51\xdd\xb5\x94\x4d\x67\xf2\x5c\x57\x50\x72\x41\xe8\x29\x34\x1f\xdb\x15\xa8\xaa\xc3\x31\xcd\x89\x3b\x28\x78\x74\xe6\xcb\x08\x34\x92\xfb\x3c\x94\xb0\xab\xb7\x41\x8c\x60\xd4\xf7\x59\xa3\x23\x2f\xc8\x6f\x2b\xf8\xbd\x9d\x87\xa0\xc6\x83\x20\x87\xd4\xc5\xa9\xdc\xa9\xc8\x4f\xf6\x81\x18\x5a\x0f\x3f\x0b\x1b\x02\xfa\x68\x1a\x9a\x5d\x07\x15\x95\x64\x8d\x4e\x34\xf2\xb7\x3c\x7b\xd7\x3c\x9d\x7e\x60\x8d\xb0\xfb\xe6\xd5\x52\xd9\x9c\x7e\xfa\x84\x3b\x97\xfd\x69\x72\x26\x05\xf1\xd0\x3a\x59\xbf\x24\x28\x8e\xff\x8a\xeb\x92\xc8\xe4\x71\x0c\xdd\x49\x19\x1b\x82\x8a\x24\x43\xa5\xeb\xf4\x0e\x1b\xb2\x5f\x7e\xd1\x70\x7c\x7a\x47\x31\x3b\xf6\xa1\xed\x22\x78\xde\xd1\x57\xb2\x2f\xf1\x7a\xb9\xd4\xf3\xa2\x1b\x12\xc8\xe5\x2a\xe7\xdd\xa4\x32\xae\xd6\xe2\xa7\x10\xea\xa0\x37\x8e\xb2\x53\xcc\xdf\xda\x54\x3b\xf5\x94\x18\x6f\xa8\xea\xc1\x1d\x3d\xdc\xf3\x75\x24\xfa\xb6\x8b\xc0\x8e\xfb\x33\x2c\xef\x7f\x63\xc1\xf5\x14\xd7\xeb\xd0\x03\x31\x7b\x2f\x44\x47\xb1\x76\x07\xd6\x01\x04\x15\xd3\x47\x30\x2c\x44\x7d\xc2\x03\xa3\xe0\xc6\x0e\x4b\x23\x28\x2b\xcb\x4e\x1b\x51\x96\x4c\x20\x93\x7e\x27\xe6\xa9\xdc\xa9\x58\x63\x82\x51\x8c\x69\xd1\xac\x80\x3f\x68\xa9\x3c\x15\x4e\x21\x9b\x53\x47\x6b\x45\x65\xf1\xf4\x43\x6d\x71\xe7\xc3\x22\x80\xcb\x1a\x00\x91\xfc\xc9\x49\xd1\x00\x1e\x08\x29\x28\x7c\xe8\x0c\xf2\xb2\xcc\x27\x8d\xba\x82\x4e\xca\x47\x65\xa7\x88\xe2\x64\x26\xea\x81\xe0\x09\x72\x21\xd4\x45\x12\x97\xe3\x40\xb1\xec\xa2\xe6\x73\x6d\x9d\xda\xbe\x00\x95\xba\xef\xb5\xcd\x89\x69\x34\x4c\xb2\xd3\x40\x49\x99\x4f\xc3\x5f\x17\x50\x46\x42\x2c\x20\x8b\x04\xa9\x43\xa8\xee\x3b\x3c\x06\xd7\x96\x62\x26\xb0\xda\x62\x9e\xc5\xb5\x65\xe3\xbc\x48\xfe\xcc\xb3\x32\x4a\xe7\x10\x43\x94\x51\x51\x4f\x44\x50\xec\x0c\x83\x0d\x20\x07\x38\x55\x3e\x74\xc4\x38\x8a\xf3\x0b\xda\xd0\x30\x4f\x67\x93\xac\x73\x1a\x4d\x03\x5f\xe5\x6e\x5e\xf3\xb9\x8a\x92\x2a\xac\x7c\x1f\xa5\xfc\x43\x67\x10\x89\xc4\x99\x10\x50\xef\x78\x0b\xc6\x7e\x94\xab\xbc\x8c\x48\xd1\x98\xcb\x89\xb5\xbf\x25\x27\x90\x8a\x29\x2f\xcb\x30\x4f\xa5\xf9\x29\x10\x08\x1b\x08\x95\xf8\x08\x4f\xa2\xe2\x34\xc9\x08\x20\x7e\x40\x3e\x68\x54\xbf\x23\x07\x84\x0a\x2a\xeb\x5c\x15\xf8\xab\x4f\x7d\xae\xac\x23\xf5\xdd\x5b\x0f\x93\xe8\x43\x60\x34\xf2\x6b\x85\xf4\xaa\x01\x9e\xc5\x81\xaf\xc0\x59\xee\x77\x71\x56\xb3\x0b\xba\x45\x97\x95\x22\x7f\x22\x25\x36\xf5\x94\xa7\xa5\x55\x9c\x93\x2c\x54\x25\x09\x70\x96\xfc\x38\xa7\x17\x52\x5a\x99\xe3\x5c\x0e\x84\x02\xc3\x87\x4e\x3e\x1a\x09\x4e\x5b\xc9\x67\x65\x9a\x64\x9c\x40\xaa\x2f\x55\x50\x53\xe2\x77\x36\x8d\xe2\x38\xc9\x4e\x09\xa4\xfa\x12\xe0\x10\x5d\xe2\xb3\x88\xfe\x5e\xe1\x11\x5d\xe0\x31\x89\xfe\x5c\x61\x5a\xd3\x75\x85\x6b\x75\x89\xc7\x2d\xfa\x73\x85\x5d\xa6\xbc\x10\x53\x3e\x2c\x93\x73\xde\xc1\xf7\x33\xe4\x99\xbf\xd7\x16\x5f\xda\x62\x52\x6a\x9b\x2c\xdc\x35\xde\x10\xe3\x68\xca\x3b\xc8\xae\xa4\x67\xc9\x6c\x04\xaa\xe4\x1f\xca\x4e\x92\xc5\x3c\x73\xd0\x83\xcf\xa2\x2c\xf2\x33\x5e\xf3\xb9\x32\x51\x65\x3e\xa5\x90\x45\x94\x89\x51\x5e\x4c\x14\xfa\x64\x6c\x7e\x91\x33\xf0\x4a\xe1\xe5\xbc\xc2\x3f\xfd\xc2\x24\x2c\xe5\xd0\xb2\x80\x98\x63\x0e\x82\x28\x4d\x4e\x29\xb1\x60\x8c\x64\x54\x17\x79\x11\x07\xf6\xc9\x5e\x8f\xbd\xcc\x4b\x9b\x9e\x6b\x6a\xc2\xf9\x75\xb1\xf4\x17\xc1\x21\x25\x4c\x04\x26\x82\x2a\x8d\x3a\x18\xcd\x4a\x79\x0f\x63\x4f\x33\x50\xf3\x9d\x22\x76\x5d\xf7\xcc\xf1\xa4\x2a\xfb\xfd\xb2\xe6\xfb\x20\x9d\x15\x35\x45\x62\x5a\xf0\x28\xae\x1c\x1c\xb0\xf8\xaa\xfb\x00\xce\x78\x00\x09\x5a\x70\x59\x57\x40\xd0\x08\x05\x1f\xfd\x26\xa3\x14\xff\xa5\x7c\xf7\x94\xef\xae\x99\x18\x46\x50\xff\x4f\xe8\xdd\x21\x22\x69\x6d\x46\x81\xb5\xaf\x62\x5d\x66\x3b\xf0\xd8\x2c\x1f\xbc\x57\xfe\x17\x5a\x1d\x05\x37\x7a\x47\xdd\x5c\x13\xba\xd4\x56\xfd\xa8\x59\x52\x5d\x91\x6d\x58\x55\xe4\x52\x30\xc7\x35\x81\x54\xf5\x37\x1d\x21\x15\x7f\xb3\x2b\x88\x97\x89\x2e\x6d\x46\x33\x6d\x54\xa0\xd6\x47\x0a\xa7\xd9\x28\x5e\x5e\x44\x53\xa5\x68\x61\x83\x4b\x76\x9a\x9c\xf3\x0c\xf6\x31\xff\x79\x13\x94\x99\x57\xd6\x96\x4c\x1b\xa2\x55\x55\xce\xc6\x2c\x24\xa4\x73\xae\x00\x19\xfb\x10\xef\xf5\x9e\x4d\xa2\xe9\x94\xc7\xb6\x1f\xa2\x03\x9a\x44\x53\xb8\xea\x8b\x1f\x2f\x25\x35\xa9\x06\x82\x2a\x57\xa8\x8a\x18\x5e\x98\xed\x5a\x4b\x4a\x3e\xf1\x94\x15\x78\xa3\x7e\xa3\x43\xac\x49\x08\xa7\x49\xd0\x52\x04\xed\x02\x90\x26\x65\x6e\x23\x07\x7e\x09\xca\x19\x0b\x82\x31\x9f\xf0\x36\x68\x82\xc8\x23\x35\xb4\x2e\x50\x23\x24\x1b\x13\xcb\x19\x3e\xfa\x44\xb7\xc6\x05\xc6\xe6\x91\x3e\xf4\xc8\x4e\x0c\x85\x1c\xaa\x8b\x21\xa2\xe5\xc6\xd3\xc7\xaf\x5a\x1f\xb5\x07\xb6\xbd\xae\xea\xbe\xfb\x3e\x4f\xb2\x66\xa3\xdd\x30\xaa\x75\xaa\x32\x85\xed\x6c\xad\xe5\xe6\xd8\xaa\x51\xb1\x1f\xaf\x9d\xb4\x0c\x64\x00\xd3\xe3\xb5\x13\x17\x59\xd3\xa3\xa3\xe2\x97\xcd\x54\x83\x83\x54\x95\xf4\xd6\x9e\x8c\xf4\xee\x30\xd4\x62\x2e\xf5\xde\x8d\x28\x41\x58\x23\xc8\x6a\xea\x9d\xae\x96\xd7\xcc\x4c\x23\xdc\xcd\xb9\xad\xd6\x56\xd6\x18\xc0\x26\x82\xe9\x87\x04\x68\xe9\x33\xf8\xca\x5b\x7a\x15\x42\xb5\x59\x22\x9e\xa9\x3e\xc8\x4b\x10\xc6\x2c\xc0\xe4\x1a\x87\x83\xf7\x56\x51\xad\xbe\x0f\x67\xa2\xcc\x27\xaf\x68\x69\xcb\xe1\xa5\x15\xcf\xd7\xeb\xf8\x44\x9b\x56\x42\xd0\x4b\xd9\x0b\xc8\x76\x82\x45\xd9\x25\xcb\x72\xb8\xfe\x65\x71\x54\xd0\xf7\x34\x1b\x3d\x21\xdc\xa3\x31\xb6\x44\x6d\xbb\x05\x11\x72\xc0\x97\xa9\x51\xa0\xe2\x48\xeb\x5b\x72\xa8\x40\xad\x59\x5f\x45\x42\x40\x90\xe5\x19\x98\xe1\xa7\x29\x73\xd0\xd4\xd6\xc2\xea\x14\x3a\xe3\x97\x42\xbd\x2a\x99\x78\x65\x9e\x3d\xef\x20\x12\x5c\xbf\xb2\x84\x68\xec\xc6\xed\x40\xfe\xd7\x75\x4e\xfc\x40\x1a\xa1\xa5\x6a\x81\xdd\x27\x25\x9c\x89\xee\x74\x26\xc6\xcd\xd0\x12\x36\xf5\xda\x06\xc7\x36\xc5\x10\xfa\x78\x9e\x1d\x0e\xde\xb7\xe8\xf3\x12\x9e\x8a\xb4\x71\x1f\x8d\x5d\xc7\xe5\xc1\xc6\xbc\x20\xce\x03\xbd\x1e\x3c\x52\x68\xa1\x08\xe7\x13\x4c\xd4\x50\x40\xc1\x23\x9a\xe6\xb1\x0f\x91\xce\xf6\xc9\xee\xe8\xfd\xf0\xe3\x4a\x68\xfc\xf3\x6b\xb7\x42\xe1\x3f\x56\x3c\x67\xb8\xf9\x7b\x09\xb2\x18\xb9\xb4\x68\x39\x00\x76\x17\x30\x12\xc2\x5b\x2c\x5a\x40\x95\x39\x9a\xec\xc6\x49\xc1\x87\x65\x7a\xf9\x19\x3b\xcf\xd2\x06\xf8\x7a\x75\xb5\x59\x39\x8e\x4a\xed\x86\x02\xa1\x3e\x93\x28\xad\x62\x7e\xfd\x8d\x49\xa3\x82\xd3\x28\xaf\x64\xf9\x2c\x40\x12\x85\xc0\x45\x24\x8c\x23\x60\x14\xc7\x78\xa9\x0b\x98\x7a\x2d\x58\xdb\xa4\xbc\xba\xa5\x55\x9e\x76\x08\xb4\xe3\x14\x5b\xe4\xd3\x97\x18\x68\x97\x40\x68\xa3\x3d\x6d\xc6\xfa\x7c\x54\x79\xfa\x67\x71\xce\x45\xd6\x50\xf7\x55\x33\x1e\x15\x40\x94\x75\xe4\xc8\x20\x36\x61\x9e\x71\xf3\x34\x45\xdf\xca\xd5\x06\x7b\xc7\x7b\x31\xbf\x7b\x97\x35\xed\x60\xe4\xfe\x0b\x41\x4b\x81\x73\x9b\x1a\xdb\x56\xcb\x35\xfc\x97\xc2\x5d\x16\xdb\x47\x48\x60\xb8\xa7\x60\x78\x9d\x17\x4d\x5f\xca\xfe\x78\xd5\x36\xe3\x6e\x53\x64\x54\x80\xcd\xd6\xb1\x2e\xb5\xee\xb4\x6a\xbd\xa2\xb5\x84\x66\x5a\x3d\x5a\xc7\x93\xcd\xce\x83\x8d\x26\x6a\x6d\x0a\x6d\xd3\x6c\xcf\x45\x1b\x8d\x14\x6d\x9d\x39\x90\x2b\x76\xa9\xf6\x7a\x3a\xab\xbc\x3d\x14\x1d\xe3\x6b\xd0\x15\xc4\xf9\x0c\x52\xd0\x1a\x09\x8f\x5a\x19\x13\x02\xf8\x6f\x67\xe7\xfe\xc3\x2a\xd2\x54\x8e\x34\x52\xb4\xc8\x38\x8f\x85\x72\xa3\xb7\x16\x96\x0b\xed\x55\xbd\x82\xcf\x93\x07\x74\x6d\xd3\xef\x91\x6a\x9f\xac\x22\x97\x15\x9c\x98\x34\x0b\xd7\x8c\xf3\x1c\x4a\x73\xaa\x38\x96\xad\x0b\x2c\x35\x88\x89\x25\xca\x01\x6a\x32\x94\x8c\x6d\xe6\xa8\x40\xbb\x1c\xd4\xda\xe8\x26\xef\xd4\x8a\xa6\xee\xb1\xb8\xc8\x0c\x63\x19\x7b\x4c\x6b\x3f\x3b\xc7\x32\xd3\x3c\x0b\x13\x96\x36\x76\x9a\x01\x5a\x57\xc0\x34\xf1\xe5\x2d\xb3\x45\x83\x9b\x5d\x91\xbf\xfd\x63\x93\x1c\x9c\xfe\xab\xf4\x9c\x5b\x84\x7f\x94\xb7\x1c\xaf\xf4\x27\x40\x75\x70\x0f\x75\xb5\x6d\xa8\x52\xe3\x93\x69\x49\x1c\xa4\xc8\x94\x08\x1a\xc7\xab\xce\x09\xd0\x1c\xa5\xd6\x3b\xb2\x79\x03\x4b\xa1\xcf\xb9\x44\xb4\xea\x02\xa2\x85\x59\xc4\x9b\xae\x45\xd3\x59\x33\x8f\xb5\x02\x8f\x3b\x6b\xd7\x92\xd1\x77\x57\x6e\x30\x69\xcb\x4f\xd9\x95\x39\xee\x5e\x44\x97\x03\xce\x22\x70\xdb\x98\x95\x5a\x6d\x40\xec\xcd\xd0\xdc\x19\x7b\xd3\x57\x10\xc6\xec\x54\x3b\x83\x95\x24\x6f\xd4\x75\x4b\x77\x5b\xe1\xc7\xfb\x7a\x12\xc7\x82\x4d\x73\x21\x92\x41\x92\x26\xb8\xa1\x5f\x14\x49\xc9\x19\x2a\x7b\x79\x7c\x63\x67\x19\x54\xc4\xdd\xc4\x57\x46\x1e\xd1\xcb\x9b\x9c\x2c\x65\x8a\x0e\x57\x10\x34\x44\xcf\x33\xce\x06\x97\xf0\x0f\xe6\xbf\x18\xe5\xc5\x24\x2a\x41\x88\xfc\x02\x96\xe6\x01\x96\x77\xf6\xad\x6b\x5b\x9c\xd7\x1e\x3f\xb7\x62\x79\xbe\xb5\xf6\x8d\x65\xde\xd2\x8c\xab\x94\x22\xbe\x5e\x89\xac\x57\xb8\xeb\x18\x5d\x57\xc1\x4f\x67\xa9\xce\x13\xd7\x55\x6e\x15\x14\x3c\x4d\xc0\x11\x7f\xc0\xd3\xfc\x82\x5d\x24\x69\x2a\xe5\x0d\xf3\x92\xa3\xde\x45\xb4\xc7\x8f\x75\xc1\x1c\x5c\xa2\x57\xa6\xcd\x98\x6f\x4e\x03\x88\xe6\x87\xaa\x69\xfa\xed\x63\xd8\xa0\x04\x94\xa4\xf5\xc6\x2c\xba\x58\xdb\x9b\x58\x70\xcf\xde\xc4\x2f\x50\x8f\x8c\xfe\x67\x7c\x4a\xf4\xbf\xea\x97\xc7\xca\x77\x6d\x6b\x41\x0a\x88\xa1\x81\xfe\x3a\x4a\xf9\x07\xfb\x4b\xbf\xb1\xeb\xdf\xe6\x89\x54\x7f\x30\xef\xae\xa6\xd5\xc0\x73\x9c\x2e\x33\x45\xde\xa7\x04\x1f\x79\x91\x41\xac\x11\x72\x1d\x83\x58\xa1\xc8\xe1\x08\xc1\x92\x4c\x24\x31\x67\xf8\xb0\xc0\x87\x25\x6c\x79\xec\x59\x5e\x30\xde\x3d\xed\xee\xb0\xd5\x8f\x7a\x36\x76\xd8\xf1\x5a\x9b\xad\x9d\x5c\xad\xb2\xbd\x7f\xb2\xd5\xc0\x7c\xed\xb0\x35\xb6\xb6\xbb\x1a\xe0\x09\xb8\xec\x87\x18\x43\x17\x48\xee\xb0\xcd\xa0\xe6\xbc\xd7\x63\x81\x4e\xcc\x23\x29\xa8\xd3\x5d\x18\x59\x50\x4b\x8d\x69\x54\x80\x29\xb6\xdc\xee\x06\xb3\x24\x85\x3b\xf3\x30\x2f\xe4\x95\x43\x53\x03\x15\x05\xe8\xd7\x46\xe8\x61\x47\x53\x1d\x06\xc1\x5f\x4f\x34\xee\x82\xf0\xe2\xba\x86\xb1\x55\xd4\xeb\xaf\xfa\xa5\xcd\x57\xd4\x4f\xb4\xf7\x58\x83\x04\x36\x84\x7f\x6e\xd6\x8a\xa5\x8a\x6e\x29\x2a\xcb\x68\x38\x9e\x40\x26\x15\x88\xde\xa0\xdc\xce\xd2\xbc\xa0\x1f\x92\x49\x74\xca\xe9\x07\x3b\x2d\xf6\x5b\xc1\xa7\x3c\x52\xed\x98\x1e\xd5\x12\xc5\xde\xd4\xdb\xac\xad\x22\x70\xef\x0d\xf6\xac\x9b\x70\x57\xe9\x2d\x34\xa4\x17\xf6\x2d\x34\x65\x76\x9a\x5b\x68\x4b\x6d\x4e\x37\x68\xc9\xec\x21\x37\xc1\x46\xee\xfd\x1d\x94\x29\x0c\xbb\x5d\x4e\x17\x4e\x3e\xe1\x10\xdd\x14\xdd\x92\xb0\x21\x7d\x57\xa6\x15\xf5\xe3\x3e\xfd\xd6\x28\x93\x49\x92\x9d\x76\x4c\xf8\x49\x5a\x88\x65\xcf\x54\x91\x2a\x81\xf7\x7c\xce\x63\x15\x59\x0e\x2e\x79\xb8\x94\x27\x49\x1a\xa9\x78\xe4\xee\x13\x3e\x18\xb3\x76\x86\x91\xe0\xfa\x7e\x1e\x5d\xba\x03\x30\x86\x96\x1a\xff\x2c\x9a\xf0\x2f\x8a\xbb\xb9\x9f\x4a\x61\xf8\xfa\x88\x2b\x0c\xf0\x5d\x3b\xc9\xb3\xce\x30\x9f\x81\x91\x08\x99\x27\x5d\xb6\x2f\x8b\x6e\x09\x03\xd0\xd0\xf8\x74\x18\x25\x69\xda\x99\xe4\x31\x77\xfa\x97\x5f\x5f\xe4\x31\xbf\x9d\x9e\x1b\xd3\x34\xba\xec\x88\x32\x2a\xdd\x5e\xe4\xe7\x23\xf9\x15\x3f\xde\xa8\x97\xab\xea\x19\x8f\xdc\xf0\xc1\x6c\xb3\x97\x76\xff\x4d\x67\x85\xf9\x81\x66\x1b\xe6\x67\x75\x57\xcd\x04\xf7\xf6\x4b\x6a\x8a\xb1\x44\x47\xb5\x4b\x79\x99\xe3\x3f\xf4\x28\x92\x90\xd3\x1f\xc5\x53\xf7\xe4\x4f\xb2\x61\x3a\x8b\xb9\x2f\x0c\x59\x2d\x98\xaa\xac\xca\x1b\xa4\x15\x3c\x2f\x9d\xc7\x11\x72\x6a\xfa\xdf\x3f\x56\x0e\x0f\xec\x6a\xc7\xef\xba\xfe\x6c\x53\x66\x53\xbe\x78\xe9\xec\x57\xb4\x14\x3e\x99\xf6\x46\xb9\x5c\x1e\x1f\xe9\xc6\xa9\xcc\x35\x61\x6f\x6c\x6b\x35\x55\x12\x49\x38\x2c\x52\x3f\x55\xe1\x85\x36\xe1\x84\x32\xfc\xd5\xd0\x3b\x71\xc1\xcb\xe1\xd8\x36\x09\x3f\x75\x21\xe2\x6d\x0d\x46\xd5\xca\x89\x26\x49\x7a\xa9\x0b\xf0\x97\x2a\x92\xbb\xfe\xbf\x75\x6f\xd4\x2a\xe8\xc6\xeb\xcb\x33\x31\xa2\x3f\x0d\xa1\x40\xd0\x45\x42\x9d\x16\xf9\xc5\x8e\xb2\x80\x95\x7f\x2b\xfc\xc0\x18\x76\xc7\xb1\x8c\x6d\xfb\x3b\x07\x16\x9a\x0f\x9a\x86\x45\x34\xd5\x65\xf2\x6f\x4d\x8b\xd4\xf6\x23\xff\xd6\x94\x1b\x17\x49\x76\xa6\x0b\xf0\x97\xc1\x13\x0c\xc5\xcc\x8c\xf2\x74\xb4\xc3\x1a\xf0\xad\x23\x7f\x34\xcc\xf6\x38\x11\xa6\x00\x7e\x35\xf4\x02\xcb\x4a\x10\x93\x54\x99\xfa\xdd\xa0\xab\x8d\xde\x15\xbf\xb1\x0c\x30\x75\x19\x4f\x7e\xe5\x59\x9c\x17\x2a\x4d\x4e\x61\x52\x19\xeb\x82\x5a\xdb\x9d\x75\x6d\xe3\x73\x6e\xe0\x5c\xfb\x9d\xdf\x92\x34\x1e\x46\x45\xdc\xb4\x8d\xcd\x33\xf7\x31\xe0\xca\xee\x06\x42\x31\x86\x8c\x7d\x5c\x63\x20\x62\x37\xe3\xbb\x90\x9a\x26\xec\x63\x5d\x8d\x4f\xe9\xf2\xc1\x8d\xb5\xdd\x4f\xab\x55\xe7\x83\x0a\x21\x8d\x55\x99\x43\x6b\x40\xd6\xf5\x32\xc5\x1c\xb9\xc4\x8b\x4a\xd1\x52\xc5\xe8\x84\x4b\xb6\x13\xde\x80\x5d\x8c\x79\x06\x8f\x00\x0b\x62\x18\xcc\xd5\x42\xb9\x53\x5e\xab\x8d\x5a\x90\xa4\x09\x34\x6d\x67\xfc\x72\x54\x44\x13\x4e\x95\x9b\x3a\xaa\x0d\xc3\x9c\x5b\xf7\xd5\xa8\xba\x38\xaa\xee\x50\x08\x76\xdf\x00\xd9\x08\x45\x5e\x60\xfe\xff\x98\x1b\xd6\xfc\x97\x07\xe5\x59\x06\x2e\x4b\xaf\x30\x4b\x3c\x89\x25\xa4\xe2\x28\x62\x84\x2a\x0c\x57\xcb\xf6\xf4\xf8\x9d\xcf\xb0\x7c\x9d\xd0\x91\xa0\xc9\x74\x6a\xde\xbd\xeb\x35\xa5\x13\xdc\xb5\x5c\x04\x4c\xdc\x30\x17\x3d\xfd\x3c\x57\x8f\x9f\xf1\x22\xf4\x10\x44\xdf\x30\xa7\x6f\x6d\x23\x17\xc4\x16\xdb\xa1\xe8\xfe\x6a\xfc\x17\x95\x69\x9d\x8b\x92\x83\x31\x84\xba\xb2\xe3\xf9\xf4\x89\x02\xfb\x4f\x2f\x16\x70\xde\x6b\x80\xd6\x34\xba\xe4\xfb\xf4\x89\x99\x8c\x10\x2e\xa2\x9f\x3e\xd9\x14\xfc\xac\x26\x46\xed\x0d\xfd\xe9\xc2\x34\x9e\x7a\xa4\xad\x51\x51\x06\xd2\x8e\xb5\x6f\xdd\xd1\x6e\x6b\xed\x36\x53\x3c\xdc\x62\xc8\xc3\x0a\xbf\x56\x0a\x74\xeb\x8e\x16\x06\xf6\x50\xe2\x2b\x6a\x6d\x52\x55\x49\xd8\xf2\xf5\x61\xcb\x05\x9c\x67\xf3\x8a\x10\xa6\x42\x08\x9f\xf0\xe9\xb9\x51\x5f\x67\x5e\x7f\x15\xe0\x6a\x33\x9a\x46\xe1\x7e\xb7\x6a\x2a\x2c\xd5\xe9\xaf\x8a\x4d\xbf\x46\x98\x8b\x5a\xc7\x48\x24\xf9\x8e\x99\x1d\x02\x01\xae\x12\x3e\x85\x76\x42\x24\xae\xab\xa4\x96\x8a\x4f\x1c\x02\xbe\x72\xb5\x6b\xf2\x4f\xdf\x03\x47\xcf\x5f\x9d\x33\x1b\xe3\xcf\x81\xc1\x65\x46\x6c\x03\x46\x3c\x2a\x67\x05\x67\x25\x06\x58\xc6\x47\x67\xdd\xca\x0f\xc3\x7c\x7a\x89\x11\x56\x0f\x53\x7e\xca\x8e\xd2\x7c\x90\xc7\xe2\x2c\x4f\xd8\xfa\x5a\x7f\x4b\x43\x5d\xf0\x81\x48\x4a\xce\xc6\x65\x39\x15\x3b\xbd\xde\x69\x52\x8e\x67\x83\xee\x30\x9f\xf4\xde\x0b\x54\x55\xf6\x86\x42\x74\x70\xa7\xd1\xb5\xd2\x64\xc8\x33\xc1\xd9\x8b\xe7\x6f\xf0\x53\xcf\x1a\x89\xdb\x95\x50\x25\x66\x60\xf9\x51\xae\x9e\x4b\xd3\x39\x4b\x77\x0e\x69\xab\x22\xf4\xed\xe6\x51\xf9\x32\x22\x74\x85\x10\xd6\x6e\xfe\x79\xf6\x63\x91\x5f\x08\x5e\x27\x44\xf7\xd7\x37\x5a\x01\xe8\xf9\x46\xf6\x06\xac\xf5\xe5\xf7\x33\xb8\x0c\x26\x7f\xd6\x6f\x27\x9b\x15\xd0\x79\xad\x6b\x98\xaf\x98\x97\x10\xa2\xa8\xeb\x18\xdf\x18\x13\x60\x38\xe6\x3a\xfa\x1a\x18\xfa\x51\xca\xd3\xe8\x1d\xc0\x02\x50\x3f\xce\x87\x10\x61\x40\x25\x2b\x3f\x48\x21\x59\x45\xb3\x31\x6d\x60\xc4\x00\xb5\x1f\xdc\x63\xbf\xe1\x02\x67\xfc\x9c\x17\x97\x76\xf1\xe7\x99\x27\xd8\x2b\x12\xea\x94\x17\xec\x1e\x3b\xcc\x86\x58\x97\xc7\x6d\x6d\xd3\x9a\x08\xc4\x36\xee\xb2\xe7\x25\x58\xf7\x0b\x36\x13\x6c\x36\x95\x17\x83\x07\x6b\x7f\x67\x53\x5e\x8c\xd8\x20\xcf\x85\x6e\x45\xee\x0c\x3b\xbd\xde\x7b\x21\x4b\x60\x63\xe0\x88\x2b\xea\x2c\x3a\xa8\x8b\xe9\x44\x10\xd7\xb6\x73\x2e\x3a\xd3\x34\x4a\xb2\x8e\xf6\x47\x57\x3b\xd2\x3d\x06\x57\x83\x34\x55\xc4\x02\xdd\xc0\x59\x96\x5f\x64\x4c\xca\xee\x44\x51\x04\x0f\x47\xf1\x6c\xc8\x59\x34\xc9\x67\x59\xc9\xf2\x11\x36\x40\x2d\x05\xd0\x68\x49\xc2\xd2\x4d\x90\x45\x25\x2b\x66\x59\x99\x4c\xb8\x8b\x7c\x1c\x9d\x27\xf1\x45\x94\x8a\x31\xa4\xa4\xef\x21\xe5\x3a\x48\xb9\x15\xdc\xc0\x74\xc0\x18\x65\x2f\xb0\xa7\xf2\x3a\x75\x4f\x79\xb9\xaf\x3e\xe2\x65\xc1\xcc\x9c\xfe\x43\xcd\x5d\x5b\xc7\xc3\xf0\xef\x83\xba\x4d\xe7\xe1\x3d\x11\x2f\xa3\x97\x4d\xbc\xf5\x01\x49\x8e\x35\x18\x5c\xf9\x30\x66\x1a\xf9\xe0\x67\x69\x7e\x23\xc7\x0b\x46\x5c\x56\x4b\x26\xec\xc6\xd1\x56\x5c\x4e\x3e\x59\x40\x20\xbe\xde\xd1\xef\x69\x06\x4a\x46\x9a\x87\xe2\x2e\x7b\xad\x6a\xbf\x03\x41\xff\x9d\x2c\xcc\xf2\xd2\x36\xe6\x5f\x14\xa9\xa1\xa6\x17\xf9\x30\x60\xff\xfd\x49\x1b\x87\xcd\xbd\x55\xd6\xdc\x6d\x74\x10\xe4\x67\x79\xc1\x04\x2f\xce\x79\xd1\x01\xed\x60\xc1\x33\x1b\x49\x1c\x68\xcc\xad\x6f\x81\xac\xa9\x6d\xb9\x7f\xe3\x18\x01\x4f\x0e\x08\x97\x07\x64\xee\x42\xdc\x2f\x79\xd9\x66\x29\x2f\x05\x8b\x73\x88\x84\x25\x21\x74\x8b\x38\x51\x53\xd7\x5a\x57\x87\x32\xb1\x65\xc6\x68\x1c\xf7\x26\xad\x14\x33\xe4\x65\x03\x3e\x8c\xe4\x41\x72\xc1\xd9\x30\xca\x1a\x88\x06\x9b\x09\xb4\x42\xe9\xf5\x60\x4d\x88\xcb\xac\x8c\x3e\x00\x37\xf1\xee\x69\x57\x72\xd2\xb3\x67\xca\x8f\x50\xcf\x7e\x70\xee\x59\x24\x58\x22\x97\xba\x46\x1b\xec\x8c\xcc\x66\xea\x44\x13\x42\x8a\x26\x19\xe3\x69\xd7\x0d\x12\x49\x86\xba\xa7\xc8\x67\x32\x0a\xce\xef\x9e\xb0\x97\xe2\xad\xee\x0a\xb1\xac\x09\xc8\x05\xdd\xf7\xf2\xfa\x3e\x07\x4d\x0c\xd3\x53\x8b\xac\x8f\x6e\xa8\x0b\x54\x11\xe8\x81\x54\x12\xfc\xb9\x0d\xf8\xa1\x7c\x43\x73\x5c\xbd\xea\x7c\x63\x49\xbf\x82\xa2\x85\xa6\xaf\x1f\x86\xf5\xb8\xf3\x87\x38\xb9\xdf\xec\xb6\x1e\x87\xd2\x3e\xb9\x2b\x5a\xbb\x14\xc9\xfd\x97\x84\x85\xab\xdb\x13\x96\x0a\xc7\xaa\xf1\xaa\xc4\x63\x15\x65\x51\x89\xb9\xa6\xc2\xbd\xa1\x15\x3b\x49\x04\x05\x5f\x75\xd2\xa6\xa1\xd3\xcc\x90\x3d\x66\x43\x37\x4e\x1c\xdb\x01\xa7\x8f\xea\x3c\x7e\x9b\x51\xfa\x6b\x44\x44\x65\x4f\xfc\xff\x82\x7c\xf8\x95\xe4\x37\x2a\xae\x55\xe4\xb9\x05\xf2\xdb\x12\xb2\x9b\x09\xd2\x87\x27\xe8\x54\x25\x8b\x57\xfa\x3f\x79\x90\xa2\xaa\x35\x74\xc6\x2a\x18\xb1\xfc\x61\x5b\xe7\x4f\x69\x83\xf4\xdd\xe8\xe8\xb5\x1a\x25\x74\xbf\x20\x31\xd6\xae\x7b\x04\xdb\xd0\x7b\x24\x54\xbd\x32\xf7\xca\x0b\x16\x31\x0c\x59\x26\x4f\x2f\xf3\x1d\x82\xd8\x36\xfa\x8d\xae\x39\xb9\x2f\x22\x29\x12\x66\xe9\xa5\x22\x2c\x38\x1c\x2b\x3f\x95\x31\x2f\x78\x77\xa5\xea\xa7\xa0\xd5\xb7\x90\xca\x1a\xfc\x11\x50\xfa\x9a\x46\x85\xe0\xcf\xb3\x52\x6b\xd8\xfa\x6b\xad\x56\x5d\x20\x41\xc9\x33\x3f\x81\xfe\xd9\x1c\x7a\xf7\x09\x8c\x95\x0e\x34\x64\x9d\x84\x60\xca\x0d\x29\x0e\x20\x28\x2f\x3f\xe7\x19\x38\x6d\x5d\x80\x61\x6a\x51\xe4\x05\x26\x4b\x9c\x70\xd8\x5e\x45\xdb\x8a\x02\x3a\xaa\x38\x3c\x16\xb1\x3d\xcc\xd3\x00\xc6\x11\x97\x36\x73\x15\x1c\xd2\x38\x7e\x2a\x10\x30\x73\x7a\x1e\xeb\x91\x58\xaf\x60\xc8\xd6\x3c\x8c\x20\x78\x20\x2f\x0a\x57\x18\xb0\x23\x73\x0e\x48\x3f\xfa\xbd\xf6\x42\xfb\x55\xf3\x72\xbd\x60\x12\xc0\xe4\x8e\xb2\xb5\xad\xeb\x98\xe0\x49\xce\x6f\x77\xb8\x61\x01\xc4\xba\xdc\xd5\x8b\x07\x76\x42\x55\x40\xe5\x22\x1e\xe6\xb1\xba\x5d\xc8\xd3\x4e\x9d\x87\xab\xa3\x94\x7f\x58\x95\x5f\x56\x3b\x13\xd1\x91\xbf\x06\xf9\x87\x55\x98\xa1\xe7\x07\xfd\x35\x9b\xf9\x8b\x98\x8a\x6b\xc8\x46\xcb\x60\xd2\x20\xb5\x75\xfa\xa6\x79\xd3\xa3\x11\x0b\xd0\xb6\x6e\xd0\x0b\xe8\x3c\x8f\xc2\x2b\x26\xad\x88\x0b\x14\xaa\xa5\xa6\x7f\x45\xc5\xcc\x17\x5c\x59\xba\x29\x27\xd6\x95\x9a\x71\x29\xaf\xcb\xba\x15\x52\x3d\x9b\xbf\xd1\x58\xf7\xfe\x0b\x28\xf8\x60\x1d\xe5\x45\x69\x0c\x6a\xe5\x0f\xe5\x19\x38\xb8\x64\x68\xcf\xdc\xad\x3c\xa3\x99\x7a\xfe\x0b\x9a\x90\xdf\x64\xf5\x35\x7c\x09\xf0\xb3\x8a\x40\x91\xf6\x92\xee\x20\x88\xb6\x9a\xfe\xe2\xcf\x5f\xea\x95\x54\xa7\xc7\xd7\x89\xd0\xf5\x83\x18\xc9\x38\x0b\xce\xa6\x28\xbb\x77\x61\x48\xf2\x7f\x5a\x35\xa9\xd2\xa6\xd4\xd5\xcd\xcb\x81\xae\x1c\xdc\xdc\x20\xf5\xfa\x23\x75\xaf\xaa\x24\xe3\xbe\x0d\x9b\xed\x6f\x32\x5a\x38\xaa\x5c\x7e\x43\xd7\xc5\x57\x46\x5b\xb2\x5e\xa7\x69\x5b\x54\x71\x63\x8e\xd0\x56\xd7\x57\x2b\x18\x2e\x04\xe5\xa4\x37\x97\xd3\xfc\xb4\x88\xa6\xe3\x4b\x1b\x12\x9b\x4f\x27\xbc\x38\xad\x0d\x19\xb2\xbe\xd9\xaa\xc0\xce\x8f\x9d\xad\x80\xbe\x4e\x8a\xa9\x1e\xfb\x07\xeb\x9f\x0d\xd8\x34\xba\x4c\xf3\x28\x66\xf9\x39\x2f\xc6\x3c\x8a\xf1\x49\x3d\xcd\xe5\xb5\xa9\x87\x03\x4c\x04\xfb\x27\xdb\x38\x1b\x74\x09\x5e\x60\x21\xd4\x24\x22\x95\x42\xe5\x45\x54\x8e\xbb\xa4\x90\xdd\x63\x7d\xbe\xd5\x62\x3d\xf9\x8f\x7b\xe7\xf1\x29\xdb\x9c\x46\x10\xc5\xad\xcd\x4a\xf3\xcd\x46\x45\x7d\x5b\x70\x12\xd0\xc6\x42\x78\x79\xb9\xd9\x63\x52\xa6\x5b\x6c\x61\x60\x18\xf5\xb5\xad\xd6\xa4\x6c\xf1\xfb\x51\x9e\x95\xcf\xc0\x74\x48\x4e\x4d\xc1\x47\x5d\xfb\x45\x03\x56\x60\x9c\x5a\x5e\xf8\xd5\xc6\xea\xeb\x7c\x90\x97\xf9\x6a\x9b\xad\xfe\x9b\xa7\xe7\xbc\x4c\x86\x91\xfc\xf1\xa4\x48\xa2\x74\xb5\xcd\x44\x94\x89\x8e\xe0\x45\x32\x02\x47\x2b\xb7\xb9\x0a\x6e\x47\x4a\xdd\xac\x31\x93\xbf\x29\x5e\xa4\x9c\xc0\xfb\x99\x31\x37\x69\x4f\xb4\x09\xf3\xf1\x37\xb0\x61\xfa\x19\x1e\x5d\x48\x77\xe4\x33\xed\xb5\x0a\x5d\x6d\xc4\xc3\x61\x63\x6d\x8d\x22\x11\x68\xd8\x2b\x7b\x0d\x26\xf8\x55\x64\xf0\x7b\x51\x45\x47\x15\x54\x11\xd2\x2d\x79\x18\x6d\x86\x30\x42\xd8\x1a\x94\x5e\xf0\x38\x99\x4d\xaa\x28\xe1\xf7\x2a\x46\x0e\x7c\xa0\x1d\x0f\xa1\xad\x10\x42\x6e\xdb\x50\x38\x2e\x27\xe9\x33\x8f\x37\xe8\x37\x0d\x1c\x80\xf3\xea\xfa\x7c\xb2\xad\xfb\x0f\x35\x97\x97\x63\xb8\x9a\x83\xae\xab\x6e\xdf\xb5\x5e\x80\xb2\x9d\x36\xa4\x63\xd3\xcc\xdd\x68\xa3\xad\xde\x11\xd8\xf0\xe1\xdf\x84\x0f\xdc\x4f\x6a\x36\xdd\x8f\x48\x0c\xf9\x8d\x22\x88\x01\xe6\x89\x8c\x30\xfd\xf0\x26\x7f\xcd\x27\x4d\x27\xaa\x36\xbd\x1b\xb1\x9e\x4b\x9c\xfb\xac\x51\xf0\x49\xc3\x3f\x60\x61\xa4\x76\xf3\xb6\x63\x53\xd6\xdb\xd8\xcd\x8e\xfe\x43\x99\xe2\x99\xf1\xee\x30\x7f\x61\xeb\xd1\xef\x30\x77\x21\x7a\x94\xd8\xf1\x3f\xf8\x50\x8a\x38\x3b\xd5\x4f\x3e\x24\x52\x6c\xa7\xf2\x45\x9b\x1b\x8a\x69\x1a\x5d\x6e\xee\x18\x41\xc5\x62\xa8\x89\xd8\xef\xaf\xb7\xaa\xac\x5d\x83\xe2\xfc\xe1\x33\x86\x61\x3a\x8f\x30\xfa\xdc\x0e\x6b\x74\xba\x6b\x9b\x7c\xd2\x30\xc5\xc4\x6e\x13\x0f\x91\xfe\xfa\x43\x79\x76\xf4\xd7\x5b\x72\x92\x08\x28\x3a\x80\xfc\x8c\x51\x40\x3b\xdd\xb5\x6d\x52\xa6\x6c\x7f\xd5\xee\xdf\x2d\xf9\x87\xb2\x2b\xf8\x30\xcf\xe2\xa8\xc0\x0c\x31\x57\xce\xf8\x37\xe6\x8d\x7f\x6b\x7b\xc1\xf0\x03\x1b\xd2\xb5\x08\xb0\x3e\x97\x00\x0f\x36\x58\x8f\x6d\x6d\x2f\x1a\xfe\xe6\x0d\x86\xbf\x3e\x6f\xf8\x9b\x5b\xb7\x3a\xfc\xca\xf8\x36\xe5\xfc\x6e\x6e\x7d\xc9\xf1\xf5\xe7\x8d\x6f\x63\xf3\x0b\x8f\xaf\xcf\x7a\x6c\x63\xf3\x8b\x8c\x4f\xca\x6b\xd4\xc1\x25\x34\xbe\xf5\x2f\x3c\xbe\x8d\xf5\xee\x16\xeb\xb1\xf5\xca\x08\x43\xa3\x98\x16\xc9\xc4\x1b\x43\x99\x94\xe9\xfc\x01\xf4\x17\x0c\xa0\x7a\xfa\x5e\x07\xff\xf5\x4d\xc4\xbf\xff\x99\xf8\x8b\xd9\x40\x4e\x03\x71\x69\x0b\x6e\xa2\xb7\xbb\x89\x04\x46\x21\x77\xc9\xca\x2e\xb1\xe4\x18\x06\x79\x3c\x7f\x13\xe8\x2f\x62\xa2\x9b\xce\x81\xc4\xfe\x73\x39\x48\x62\x3f\x77\x89\x2f\xc4\xfe\xa6\xc4\x5f\x03\x16\xfa\xec\x01\x0c\xa3\x29\x75\xaa\x0a\x0e\x61\xd1\x19\x7c\xc3\x21\xf4\xb7\x71\x08\x95\x63\x76\xe9\xbd\x68\x30\x2b\xcb\xf9\x63\xd0\x5f\xcc\x48\x64\x63\x6f\xac\xe7\x6e\x63\x36\x9d\xf2\x62\x18\x09\xde\xb8\x39\xb3\x19\x2d\xca\x55\x1b\x05\x57\x9d\xe2\x7f\x98\xe6\x72\xc3\x04\x9d\x1f\x06\xbd\x35\xf6\x18\x50\x04\x79\x89\x9c\xf0\x88\x54\x79\x72\x9b\xa9\x17\x7a\xf7\xd8\x6f\x07\x3f\xbe\x7a\xb2\xff\x13\xfb\xf5\xc9\x6b\xf6\xfc\xe5\xff\x1c\xec\xbf\x79\x7e\xf8\x92\xdd\xeb\xd9\xb6\xa7\xa8\xcf\x81\xea\xb7\x97\x33\x3b\x2a\xce\x88\x69\x68\xaa\xee\x71\x15\xcb\xd0\x33\x7e\x59\x17\xac\x74\xc3\x3e\xc5\x49\xa8\x79\x8a\x0d\x59\xfe\x5f\xa3\xe8\x79\x85\x8c\xfe\x85\x33\x88\x7f\x05\x0d\x92\xca\x31\x14\x27\xa7\x79\x4d\xfb\xeb\x0f\xd6\x3c\xc0\xb9\x2f\xa9\x00\x61\xdf\x46\x93\xec\xac\xb6\xdd\xbe\x03\x36\xf7\x01\x35\xc9\xce\x0c\xf0\x69\xc1\xeb\x2c\x84\xfb\x0f\xd7\x1c\xb0\x79\x6d\xca\x72\x03\x5c\x80\x3d\x54\x18\xcd\x75\x0a\x35\xaf\xc5\x82\xc7\xd6\xb0\x2f\x9f\x4c\xf2\xac\x16\xcd\xbe\x07\x38\xd7\xfe\x0f\x20\x48\x85\x34\x2f\x5e\x44\x59\x32\x9d\xa5\x18\x85\xb9\x86\x2d\xb6\xbe\x61\x0d\xa1\x1c\x89\xde\x4f\xfc\xfd\x45\x6e\x49\x72\xcf\xb7\xde\xcf\x70\x14\xee\xb0\x46\x71\x3a\x88\xe4\x65\x5b\xfd\x5f\xf7\xe1\x83\x96\xf6\x60\xd3\x67\x4d\x00\x6a\x6b\xb3\x65\xdc\xe6\x44\x34\x48\x79\x1c\x00\xda\x78\xa8\x81\xc6\x09\x78\xab\xd5\x03\x24\x43\xf0\xbb\xab\x07\x88\x93\xf3\x04\x13\xba\xf8\x30\xfd\xf5\x96\x71\x3d\x3c\x1d\x97\x4f\x6b\x01\xd7\x1e\x6c\xb5\x8c\x07\x5e\x92\x4d\x67\x86\x1a\xe8\x3a\xff\x33\xe6\x1a\xf0\xab\x6d\x9a\xf6\xc7\x3c\x9d\xf2\xe2\x0d\x90\x71\x0e\x45\xd2\x68\xc0\xd3\x85\x50\x80\x40\x0d\x94\x9d\x83\x39\xd4\x95\x78\x19\x7f\xc2\x21\x95\x62\x22\x1d\xda\xff\xb3\x66\x6d\x7d\xbb\x35\xc7\x91\xd5\x70\x2b\xee\x05\x7a\x13\x3f\xde\x5a\x3b\x51\xee\xce\xd1\x54\x52\x5f\xaf\x41\x0d\xd0\xbd\x18\x27\xa5\x52\xb9\x44\xd3\xe9\x8f\x51\x51\x69\xa2\xbf\xa6\xdb\x50\x4f\xd4\xcf\x0a\xf0\x71\xf7\xc0\xd6\xd7\xd6\x4e\x34\x7e\xf4\x06\x26\x4a\x3e\xc5\xae\x5d\xf8\x4d\x05\x0f\x8e\x91\x72\x8d\x78\x47\xb0\xfa\xb9\x60\x85\xac\x6f\x6d\xb5\x99\xfd\x9f\x7e\xed\x22\xf1\x00\xd7\xba\xb5\x73\x59\x81\xdc\x0a\x2d\x97\x7a\x28\xba\x66\xea\xa1\xbc\x85\x53\x01\x9c\xbf\x7c\x2a\xe0\xd7\x59\x44\xf5\xa4\xa8\xae\xa4\x7a\xd8\xca\x72\xaa\x07\xad\xac\xa9\xba\x59\x5b\x66\x2a\x96\x59\x5b\x9f\xdd\xfe\xc6\x52\x6b\xac\xf1\xb7\x8d\x35\xf9\xff\x1a\xee\xd2\x72\xf9\xfb\xa1\x59\x36\x35\xeb\xea\xd1\x72\xeb\xea\x51\xcd\xba\xea\xf5\xd8\x9b\xc3\xa7\x87\x3b\xec\xb7\x71\x54\x32\x31\xce\x67\x69\x0c\x26\xae\xb0\x70\x4a\xf0\xe6\x07\xc3\xd8\x51\x5e\xe8\x45\x08\x0d\x3c\x86\xac\x16\x10\x10\x21\x36\xce\x8d\xec\x74\x96\xc4\x7c\xf9\x05\x6b\xce\x5a\x30\xa8\xce\xca\x22\x12\x30\xc3\x4d\x38\xb2\x6d\x14\x67\xb4\x02\xf5\x8e\xf1\x2e\xa9\xf4\x3a\x2a\x93\xbc\x85\xd5\xda\xd5\xed\x69\x90\x42\x34\xc8\x7f\xb0\x07\x9e\xd2\x5a\x8e\xd2\xb9\x3e\x7a\xd1\xb6\x61\xd5\x78\x00\xd5\xa7\x36\x25\xdb\xda\x57\x31\xf3\xb6\xa6\xbe\x7c\xaf\x2a\xb3\x3d\x73\xe1\x53\x5f\xf4\x65\xcb\x02\x54\xeb\x78\x8f\x09\x5a\xa6\x34\x22\xf6\x4e\xa5\x8e\x79\xd5\xd0\xdf\xcd\x46\x46\x30\x30\xdf\x34\x34\x05\x0a\xd5\xf4\xf1\x00\x19\x34\x84\x45\xa5\x65\x53\x82\x26\x4c\x16\x07\xf8\xad\xa1\x74\xa1\x0f\xed\xf7\x2b\x85\xca\x50\xb7\x4e\x63\xe6\xab\xca\x89\x6a\x2e\xda\x97\x53\xf3\xf0\xa2\x8a\x3c\x50\xff\xdd\x11\x78\xa0\x41\x3b\xa2\x6d\x5c\xf3\xf1\xc6\x3c\xc5\x1e\x37\xd4\x5c\x35\xda\xac\x61\x08\x26\x7f\xc0\x30\xe4\x1f\xb2\x1b\xfd\x04\x03\xee\xb4\xe3\x28\xe6\xf2\xde\xf8\x11\xf8\x76\x07\xfe\xb7\x8d\x3c\xba\xa3\x84\x43\x4c\x4a\xa9\x2e\xb7\x5d\x9e\x9d\x77\x5f\x1e\x3e\x3d\x78\x7b\xf0\xf2\x57\x30\xd8\x58\x9d\x16\x79\x3c\x53\x99\x41\x1e\x23\xd2\xfa\x86\x65\x91\x54\xe6\x80\x4d\xec\xf0\x58\xe2\x71\xd2\x6a\xb3\xc6\x8b\xa8\xe4\x45\x12\xa5\x9d\x5f\x9e\xef\xc0\x26\xa1\x46\x83\x84\x7c\xd7\x60\xf7\xf1\xaf\xfb\xac\xf1\xae\x6a\xb0\xd8\x68\xb1\x1d\x6b\x52\xa9\x2c\x41\xb0\x81\xc3\x59\x39\x9d\x95\x9a\x8a\xf5\x0f\x43\xb8\xae\xab\xf2\x87\xd2\x78\x42\xf4\x20\x3b\x39\xe6\x90\x77\x56\x05\x39\xd3\x3d\x3e\x05\xc2\xef\x30\xc2\x46\x72\xeb\xf2\x77\x30\xd5\x0a\x90\x66\x47\xfd\xab\xfa\x87\xb3\x89\x12\x0d\x76\x0e\x72\x7a\x79\xa5\xf0\xad\x6d\x4e\x1e\x39\x32\xa7\x1c\x3f\x2a\x35\x10\x39\x48\x1c\x20\x5b\xa0\x0f\x7a\xb9\xbb\x3b\x20\xf2\x93\x1a\x90\xbb\xcf\xee\xf8\x1f\x6e\xa8\xd7\x59\x51\x91\x8b\xcf\x99\x62\x2a\x1d\x56\xbe\x96\x21\x1b\x96\x21\x1b\x34\x24\x6f\x9c\x8c\x46\xbc\xe0\x99\x9b\xf3\xdb\x7e\x6d\x0e\x22\x01\x29\x4f\x26\xd3\xa8\xe0\x6e\x48\xd4\x3b\x95\xaf\x4c\x03\x12\x43\x24\x12\xc4\x94\xbe\x4a\x82\xd2\xc5\xf2\x9d\xec\xa6\xd5\x1d\x25\x69\xc9\x0b\x92\x1a\x64\xec\x3a\x8c\xab\x06\x74\xc7\xc7\xe3\x19\xb7\x01\x63\x75\xc0\x01\x62\x17\xa5\xd8\x7e\x5f\x1e\x57\x07\x6a\xd7\xb3\x8f\xac\x7e\x61\x33\x83\x88\xd6\x35\x23\x96\xed\x4d\x12\xcc\xf3\xbd\x57\x4f\xa1\x5d\x73\xd0\xdc\x68\x6b\x50\x3d\x39\xa9\x37\xe4\x66\xe6\x6c\x0d\x72\x23\x80\x28\x12\xf7\x59\x03\x15\x9d\x72\x37\xd0\x48\xca\x8d\x63\x94\xa7\x69\x7e\x21\x7f\x8d\x67\x72\x19\xc9\x1a\xba\x69\x93\xec\xa3\xcd\x1a\x47\x9c\xa3\x34\xa2\x76\x7b\x68\x4c\xb4\x19\x1e\x81\x6d\x96\x17\x4c\x9e\x42\x6d\x16\x09\x25\xf2\xf3\x18\xc3\xe8\x4d\x34\x42\xb3\xa4\x87\xb5\xba\x8d\x13\xd5\xf6\x1f\x59\xa3\x45\x37\x23\x3a\x3d\x55\xea\x93\x8d\xda\x3f\x7a\xdb\xee\x06\xa6\x0f\x75\x45\xec\x40\x53\x74\xa3\x77\xcf\x4f\xbf\x29\x03\x59\xdf\x98\x3e\x28\x9c\x03\xd1\x6f\x07\x80\xea\xdb\x90\x5b\xdb\xa2\x26\x94\xde\xc7\x7d\xc2\x77\x40\xa4\x50\x34\x47\xeb\x7a\x85\x31\x4d\xe6\xa9\x71\x9b\x1b\xad\x56\xab\xa2\x15\xfe\x26\x73\x80\xb9\xf5\xeb\x14\xac\x0f\x6a\xe0\xe7\xe9\x55\xbd\x96\x4d\x0b\xfc\x43\xc9\xb3\xb8\x56\x97\xbb\xe9\x03\xce\xeb\x43\xb7\x35\x4f\x57\xfb\x22\xf9\x90\x64\xe2\xab\xa6\xcc\xa2\x1d\x37\x21\x2d\xf8\x34\x4f\x32\x39\x2d\x2a\xa3\x5e\x9b\x4d\xa0\x90\x08\xd7\x65\x9e\xa7\x83\xa8\xd8\xf5\x0d\x4b\x34\x15\x7c\xe9\xe1\x74\x56\x96\xbc\x10\x24\x9d\x9a\xfa\x82\xc6\xa7\xc2\xcb\x90\x2d\xba\x2a\xa4\xe6\xcf\x7c\x24\x69\xa3\x10\xe9\x42\xe6\xe5\x7b\x6c\x7d\x37\x08\xfc\x5a\xe9\xe4\xe6\x43\x1f\x93\x21\x76\x67\xd3\x66\x43\x4c\x1a\x2d\x1d\x79\x40\x6d\xd4\xb6\xf3\x1d\xbf\xb5\x8d\xb6\x0f\xf6\x1a\x85\x40\x1f\x4e\x9f\x41\xbb\xee\x49\x87\x48\xec\xd2\x67\x26\x45\xcc\x1d\xd6\xd4\x74\x25\xd8\x4c\x92\x4c\x3f\x6b\x6d\x6d\xab\x5a\x5a\x56\x73\x98\x9b\x58\x29\xa9\x56\xda\xcc\x1f\xea\x07\xd1\x80\xc7\x30\x08\x5c\xd0\xcc\x8b\x84\x67\xa5\x0a\x6e\x98\x46\x59\x2c\x86\xd1\x94\xb7\x1a\xed\x50\xe7\x9b\x0f\xb1\xf3\xd6\xe7\xf7\x2e\x09\x1d\x6c\x7b\x7b\xd3\xb4\xad\x6b\xb7\x50\x1c\x52\x8c\x17\x78\xb6\xea\x7f\x63\x71\x9a\xf5\x2d\x21\xbf\xf8\x89\x5f\xfe\x32\x19\x14\xd1\xa1\x64\x08\x88\xa4\xb0\xd6\x5d\xf7\x00\x5e\xf1\x6c\xe6\xc3\xf4\x37\x29\xd0\x93\xc9\x40\xce\xce\x11\xfc\x70\xc0\xd6\x77\x2b\x8b\x17\xa1\x9a\x8e\xd5\xea\x71\xb3\x92\x6a\xff\x1f\x7b\x6c\x8d\x3d\x26\x57\xac\x1d\x27\xb3\x3e\xb0\xc6\xf4\x03\x48\x04\xc1\xca\xfd\xda\xca\xfd\xc5\x95\xd7\x6b\x2b\xaf\x2f\xae\xbc\x51\x5b\x79\xc3\x54\x76\xf5\xad\xb2\xa9\xf0\x7c\xdc\x67\x0d\xc9\xe3\xc1\x7e\x36\x6b\xfb\xd9\x5c\x8c\xe4\x56\x6d\xe5\xad\xc5\x95\xb7\x6b\x2b\x6f\x2f\xae\xfc\xa0\xb6\xf2\x83\x65\xc8\xe3\x73\xe3\x3c\x0a\x3d\xac\xed\xea\xe1\x62\x3c\x1f\xd5\x56\x7e\xb4\x04\xf7\xd5\xf3\x6e\x7f\x19\xe6\x9d\xc3\xbd\xfd\x85\x54\x0a\x2e\x47\xa0\xd3\x09\x4d\x91\xa7\x5c\x1a\xb1\x8e\x60\x7b\xec\xb8\x91\xe5\x19\x6f\xb4\xdd\x85\xba\xd6\x66\xfd\x36\xdb\xd0\xdd\xf4\xe1\xff\xf0\xef\x75\xf8\xbb\xd3\x6f\x05\xab\x6c\x11\xb0\x75\xfd\xf7\x06\x56\x59\x0f\x57\x79\x48\xc0\x36\xc9\xdf\x1b\x35\x55\xd6\x01\xac\x83\x08\x6d\x92\x2e\x25\x96\xf2\xaf\x40\x9d\x0d\x00\x53\x75\xb6\x48\x9f\xb2\xce\xe6\x12\x75\xb6\x55\xdb\xa6\xd2\xc3\x70\x25\xc4\xa7\x83\x43\x7f\x80\x95\xfa\x86\x6e\xb2\x95\x40\xa5\x2d\xac\x84\xe4\x7e\x48\x2b\x6d\x20\x7a\x21\x32\x6c\x01\x52\xaa\xd2\xa3\x36\xeb\xaf\xd3\x4a\xdb\xe1\x4a\xdb\xb4\x12\x74\xb3\xa9\x6b\x6d\xe2\xa0\x36\xc2\xb5\x1e\xb4\x59\x07\x27\xa7\x2f\x47\xbf\x45\x6a\xad\xaf\x85\x6b\x3d\x80\xb1\xe8\x5a\x12\xbb\x07\x9a\x27\xb6\xda\x6c\x5d\x4e\xe3\xc2\x5a\x72\x28\x8f\x68\xad\xcd\xda\x5a\x8f\x6c\x2d\x89\x54\x9f\xd6\xda\x0e\xd7\x7a\x88\xb5\x90\x81\xfa\x0a\xa9\x75\x3d\xdf\xeb\x0f\xdb\x6c\x2b\x5c\x4b\x52\x4e\x57\xdb\x46\xac\x4c\xb5\x8d\xb5\xfa\x6a\x7d\x5b\xed\x01\xa2\x65\xab\xad\x87\xab\x3d\x72\xab\x3d\x44\xbc\x0c\x7f\x6d\x6c\xb6\xd9\x76\x4d\xb5\xf5\x36\xeb\x6c\x63\x35\x49\xc3\x47\xb4\xda\x76\xb8\x5a\x5f\x11\x5d\xd5\x83\xa9\x35\x1b\x81\xe4\x8e\x87\x6d\xf6\x60\x89\x7a\xb2\xce\x06\xa9\xb7\xb9\x36\xa7\xde\xa6\xad\xb7\xde\x66\x1b\x5b\xb4\xde\x7a\x4d\x3d\xb5\x6e\x3b\x0f\xb0\xde\x06\x0e\xc9\x2c\x86\xcd\xcd\x36\x7b\x58\x57\x6f\xcb\xd6\xdb\xc4\x21\xd9\x7a\xdb\xb2\xde\x49\xf0\xfe\xa3\xf6\xcc\x4a\x84\xa8\xfe\xcd\x82\xac\x06\x2d\x70\xfa\xf2\x0e\x86\x4d\x74\x55\x0b\x75\x16\x15\x1b\xad\xee\x4b\x70\x84\xee\x82\x93\xb2\x94\x15\x3d\xfc\x6e\x16\x51\xaf\xd7\x63\xeb\x6b\xdd\x7e\x77\xbd\xbb\xc9\x68\x47\x4d\x74\xbf\x6e\xc1\x79\xf2\x3d\x36\x53\x6b\xf5\x21\x6f\x94\x0a\xa6\xa9\xfe\xed\x1e\xb5\x59\x03\x1b\x54\x02\x3d\x34\x4b\x6e\x60\x4e\x37\xf6\x4d\x8a\x8b\x34\xc9\xca\x8e\x7a\x69\xeb\x64\xfc\x03\x26\x21\x67\x59\x0e\x41\x74\x3b\x4a\xad\x45\xdf\x72\x94\xab\x38\x78\x58\xcb\xbf\x54\x74\x9c\x56\x80\x5a\xdf\x58\xbc\x2f\x98\x00\x15\x3c\x39\x12\xa0\xf0\xfa\xf3\x39\xa4\xba\xb9\xc8\x8b\x33\x15\x34\x39\x1a\x88\x3c\x9d\xe9\xc4\x6e\x02\x2d\x42\x14\x18\xde\xd4\x26\xf9\x20\x49\xf9\x91\x7e\x78\x7b\xb4\x06\x11\xbc\x27\x3c\x9b\xed\xb0\xfe\x1a\xfe\xd2\xaf\x88\xfd\x3e\xfe\x8e\x8b\xe8\x82\x17\x87\xe7\xbc\x80\xd8\xee\xfd\x75\xfc\x9c\x45\xe7\x4f\xa1\x64\x87\xf5\x37\x14\x64\x12\xa5\xf9\xa9\x85\xdc\xa4\x9f\x77\x58\x7f\x0b\x7f\xa7\xd1\xa5\xac\xb5\xae\xfa\x9b\xe6\xd3\xfc\x1c\x3e\xa8\x0e\x45\x16\x0d\xcf\xe0\xa2\xb9\xae\x10\x94\x97\xad\x32\x99\xee\xb0\x8d\xb5\xb5\xb5\x95\x70\x6e\x71\x1c\x67\x75\x59\x7e\x9b\xd1\x55\x08\xe2\x2a\x28\xc2\x93\x34\x05\x4d\x6c\x9e\x49\x59\x0f\x23\x44\x43\xd8\xdd\x8c\x3d\x8c\xa7\x4c\xfc\xef\x2c\x2a\x38\x68\x78\x81\xcb\x4f\x8b\x04\xd3\x0b\xe0\x94\xb6\x19\xe4\xf0\x2e\xdb\x70\x65\x8e\xb9\x38\x2b\x21\xf7\xb6\x6c\x59\x07\xe9\xd3\xfa\xce\x6e\x92\xf7\xe0\x15\x56\x36\x24\x7a\x69\x74\x99\xcf\xca\xde\x84\xcb\x51\x8a\xce\x19\xbf\x84\xef\xe0\xd6\xf4\x37\xff\x6b\x47\x23\xd0\x91\x08\x88\x15\xc6\x66\x59\x52\xee\xb0\x87\x81\xb0\xd3\xfd\xdb\x0c\x88\xf2\x1f\xb4\xd8\xf4\x54\x5f\xff\xe2\x19\x2f\xa2\x92\xef\xa7\x91\x10\x2f\xa3\xc9\x97\x36\x58\xfc\xe2\x1a\x36\x4c\xd5\x3b\xe0\xe9\xab\x74\x76\x9a\x64\xcf\xd2\xfc\xe2\x35\x8f\x86\xf0\x3a\xf9\xe6\x72\xca\x05\xa4\xd3\x2b\x2f\xa7\xfc\x2d\xf8\x36\x1f\x8d\x39\xaf\xdb\xe3\xfb\xeb\xeb\xad\xee\xf5\x1b\xfb\xf4\x29\xd8\xda\x5a\xab\x1b\x65\xda\xed\x77\xc9\x56\x4f\xfd\xe9\xa9\x3d\x8d\x36\x97\xc6\xb4\xda\xe6\x2d\x22\xfc\x7a\x96\xde\x06\x8e\xd0\xcc\x32\x68\xa9\xc1\xe4\x05\x64\xdd\x80\x97\xe9\xb5\x5d\x38\x5f\x74\x64\x99\xc8\x1e\xbe\x17\xe3\x64\x38\xd6\x55\xb8\x90\xab\xfd\x7f\x67\x9c\x0d\x25\x21\xe0\x01\x47\xc0\x96\x14\xb3\x3c\x63\x43\x6c\x4f\x74\x65\x5b\xbf\x61\x74\xf0\x0b\xdb\x1d\x3d\xd1\xd5\x52\x8a\x31\x7a\x80\xae\x89\xc1\xce\x04\x2f\xb1\x05\x1b\xad\x0f\x3e\xc2\xa1\xe7\x80\xcb\xed\xef\xe8\xe8\x35\x06\x38\x89\x86\x63\x88\x94\x06\x71\xd7\x7a\xbd\x15\x88\x16\xd3\x10\x72\xff\x4c\x26\xd3\x22\x3f\xe7\x31\x3b\xe7\x90\x67\x93\xe5\xa3\x15\xb2\x2f\x92\xe0\xa5\x43\x21\x92\xec\xbd\xe8\xbd\x17\xa2\x37\x48\xf3\x41\x6f\x93\x6f\x47\x6b\x5b\x71\xbc\x31\x7a\x30\xd8\xde\x7a\xb0\x3e\x8a\xe3\x8d\x68\xb0\xde\xdf\x7e\xb8\xdd\x8f\x1f\xf1\xcd\xcd\xed\xe1\xfa\xda\xc6\x46\xbf\x27\x8a\x61\x6f\x56\x26\xa9\xe8\xd5\xec\x12\xdd\xf7\xc2\x57\x87\x55\x60\x9a\x56\x75\x2d\x07\xea\x4e\xd0\x9c\x67\xd2\x3d\xef\x99\x54\xee\x00\xca\x5b\x1b\xc3\x11\xfa\xc9\x76\xb5\x1c\x55\xe1\x85\xfb\x7b\xac\x4f\x12\xf6\x55\xca\xff\xc9\xd6\x9d\x84\x7d\xf3\xa4\xb0\x61\x9e\x89\xdc\xe4\xc8\x55\xbf\xf0\xb5\xa9\xe9\x3d\x07\x5e\x28\x13\x22\x0c\x59\xcb\x63\x36\xc9\x0b\xce\xca\x71\xa4\x23\xcc\xab\xcc\x8f\x30\x77\xc0\x08\x96\x03\xed\x20\xba\x8d\x36\x6b\xfc\x9e\xcf\xb4\x91\x12\xc4\xfb\x91\xa7\x48\x9e\x85\x2b\x48\xae\xc5\xc6\x12\x9e\x95\x4c\x24\x31\x87\x36\x9e\x8f\xd8\x65\x3e\x63\x71\x8e\xef\xdc\x17\x89\xe0\x6d\xf8\x52\x46\x67\xf8\xda\x58\x24\xe2\x4c\x72\x26\x60\x3d\xcc\xb3\x51\x9a\x0c\x21\x91\x09\x5d\x19\x18\x8b\x42\x4d\x8a\xf7\xb6\xe8\x85\x98\xd7\xd1\x70\xcc\xf3\x31\xe6\xc2\x14\x72\x77\x34\x06\x49\x84\x25\x70\x9e\x6e\xe1\xb5\x96\x36\xfa\x0f\xd6\xe7\xfd\xea\x5b\xad\x1c\xf8\x04\xde\x2c\x60\xb4\x11\x9b\xf0\x49\x5e\x5c\xb2\x94\x47\x67\x40\xae\x37\x6a\x61\xee\xdb\x65\x6c\xec\x3a\x04\xae\xe0\xd3\x22\xbf\xc0\x1c\xd8\x93\xd9\x70\x6c\x69\xe1\xbe\xb2\x1a\xbe\x5b\x8a\xcb\x49\x98\x7f\x95\x8b\x7f\xd8\x50\xe1\xfc\x15\x26\x4e\x5e\x46\x08\x13\x0f\xa7\xcd\xdd\xbb\x48\xd8\x6e\x0e\xce\x3f\xa2\x3b\xe1\x65\xe4\x3d\x97\xf3\x32\x82\xcb\x9e\x0f\x46\x52\x92\x1e\x45\x59\x52\x26\x7f\x22\x43\xa8\xc8\x53\x91\x30\x39\x0a\x67\x02\xcd\xde\x62\x7e\xce\xd3\x7c\x3a\x91\x1c\x56\xe6\x26\xa1\xc2\xd8\xf0\x21\x8f\x6d\x9b\x96\x7d\x74\x32\x60\x85\x89\xfc\xc7\x04\xb4\x93\xfb\xea\x6b\x08\x6a\xd7\xec\x1d\xdf\x59\xfd\xdb\xf7\x7f\xbf\xdb\x68\xb6\xee\xdd\x6f\x77\x7b\x3b\xbb\xec\x1f\x7b\xff\x7c\xfc\xc3\xf1\x1f\x7f\xfc\x71\xf2\x7f\xdf\x7d\xfc\x74\xf5\xff\x3f\xe9\x9d\xb6\xda\xac\xd1\x51\x21\x62\x09\xc1\xa0\xed\xfb\x0c\xc3\x24\x9a\x5c\x09\xf4\x43\x88\x90\x3a\x37\xfc\x02\xf8\xab\x2f\xf4\xe4\xdb\xbf\xcd\x58\x3e\x5f\x5f\xac\xfc\x62\xee\x3d\x5f\xea\x09\xf8\xbf\xdc\x19\xe7\x1b\x75\xd6\x70\x0c\x5b\x41\x12\x16\xfb\xf2\x88\xd3\xb9\x62\xc5\x61\xa1\x7e\x7b\x11\x9d\x50\x74\x68\x82\xdd\x6d\x1b\x76\x0a\x6a\x14\xa5\xd2\x44\x9a\x60\x2d\x5e\x5b\xd5\x88\x2d\x1e\x00\xb6\x2b\xf7\x64\xaf\x80\x6c\xce\x77\x00\xa6\x2b\x87\x59\x24\x31\x17\x10\x1a\x2f\x53\x52\xb1\x5f\x78\x2c\x0b\x4e\x2a\x5b\xb5\xf3\xbc\x6c\xad\x9e\x6c\x9b\x7b\x2c\xd8\xd0\xae\x37\xd2\xdf\x92\x72\x7c\x48\x2a\xd5\xbd\xee\x5f\xb5\x55\x05\xbd\x07\x86\x2c\xb9\x4c\x5f\xad\xee\x28\x2f\x0e\xa2\xe1\x98\xd8\x73\x9d\xf1\x4b\x3b\x8a\x1b\x1e\xba\x01\xdc\x21\x5a\x73\xf0\xe8\x95\xd7\xfe\xb2\xb8\x04\xbb\xa8\xdc\x50\xc8\xa4\xe1\x87\x43\x35\xce\x39\x9e\xb9\xfc\x43\x22\xca\xae\x71\xe2\xec\xf5\xd8\xf7\xf2\xd2\xf0\x2c\xf9\xf0\x82\xb3\x0e\xe4\xaa\x62\x89\xc8\x1a\x25\x13\x93\xa8\x28\x19\xcf\xf2\xd9\xe9\x58\x41\x37\x9e\xa9\x83\x09\xec\x34\xd5\xd6\xfe\x0e\xfe\xc8\x47\xec\x9d\x37\x21\x5d\x6a\xc3\xf5\x6e\xbe\xe9\x14\x0b\x4d\x97\xce\x57\x54\x6b\xd1\x59\x4f\xa6\xdc\xf9\xad\x85\x29\x3d\xb7\x0e\x8f\x39\xd5\x2b\x61\xbc\xd0\x7e\x11\x96\xd4\x8e\xfa\x17\x69\xa7\xce\x7c\xeb\x54\x0b\xc9\xa0\x77\xec\xcb\x9c\x63\x19\x31\xe6\x93\x24\x3b\x3d\xc8\x94\xd1\xff\x52\x8b\x4f\x1f\x91\x01\x45\x83\xbf\x25\xcc\x3d\xa7\x3e\xfb\x1c\xfd\x0f\x47\x23\xab\x3b\x1a\x71\x16\xe0\x4e\x44\x6d\x1e\x9b\x90\x33\xcb\x98\x79\xd2\x6e\x12\x2e\x9a\x65\x54\x9c\xf2\xb2\x6d\x82\xbf\x91\xe4\xe0\x2a\x31\x38\xfb\x07\x16\xda\xa4\xe0\x90\x10\x1c\x6d\x49\xb9\x18\x16\xc9\x14\x3d\xff\x30\x24\x5c\x72\xb2\x4b\x3e\x77\x79\x36\x9b\xf0\x02\xc2\x86\xee\xd5\x7c\xff\xf4\x49\x85\x33\xa4\xe5\xf2\x6e\x90\x9c\xce\x74\x4d\xc8\x36\x04\xbb\xe8\x2a\x8c\x7e\x15\x25\x44\x0d\xde\xa2\x55\x2f\x8a\xa4\x74\xaa\x85\x49\xac\x47\x4e\x6a\x9e\xf1\x4b\xfa\xbb\x85\x99\xc0\x2a\x77\x8c\xfd\x3c\x13\x65\x31\x1b\x96\x79\x01\x84\x2b\x73\x88\x23\xd8\x06\x9f\x8d\x64\xf8\x4a\x93\x52\x49\xe4\xaa\xb8\x55\x25\x3e\x69\xc8\x26\x2d\xa3\x4d\xb6\x76\x55\x76\x7c\xd2\xee\xbc\x56\x5c\x14\x4c\xae\x32\x02\xb1\x0b\xa7\x6f\x93\xb8\x91\x46\xc3\x5a\xa5\x94\x0b\x35\xdf\xdd\x34\x1a\x96\x24\x0a\xb1\x52\xb3\xd4\x34\xbc\x56\x85\x9c\x1f\xb2\x58\x01\xd9\xcc\x37\xfa\xb8\x0e\x3e\xff\xd8\x70\xc8\x47\x49\xcc\x7f\x8c\x6a\x33\xe0\xf5\x2b\x90\xf3\xd0\x50\x20\xa6\xca\xbf\x79\x14\xd7\x06\x7e\xde\x7e\xb0\xe9\x01\xce\x6b\x1a\x21\x4c\x85\x17\x51\x52\xe7\xae\xbb\xfd\x60\xdb\x01\x9b\xd7\xaa\x2c\x37\xc0\xfb\xf3\x9c\x80\x1f\x7d\x1d\xff\x5c\xdb\x41\x99\x4b\x9e\x9c\x4d\xe4\x3a\x85\x7c\xe1\xcd\x08\xe2\xdf\x02\xbb\xc3\x87\x6e\x22\x6c\x41\x75\x63\x6a\xb3\xa8\x00\x92\x1a\x20\xb5\x3f\xb5\x70\xcb\xb2\x1f\xcc\x86\x25\x2b\x1c\x27\xf2\xe4\x8c\x8a\x02\xf6\x29\xb3\xb6\x65\x11\x49\x43\xa8\xbe\x22\x1e\xa3\x22\x9f\x00\x12\x2a\xd7\x9f\x1d\x04\x5c\x3a\xf7\xa3\x34\xdd\x1f\xf3\xe1\x59\x33\xc9\x44\x19\x65\x43\xde\xa6\xeb\x4d\x8f\xe9\x8e\x29\x66\xfa\x8f\x7c\xe4\x00\x4a\x48\x0c\x48\x2c\xaf\xa9\x92\xdf\xd1\x90\x78\x75\x3f\xca\xa4\x88\x22\x4f\x2b\x16\xa9\x9b\x6e\x44\xb5\x8d\xab\x55\xd4\xa6\xb9\x10\xc9\x40\xde\x2b\x4d\x07\xa8\xa5\x6c\x0a\x9e\x8e\xda\xd0\x98\x41\x4d\x7e\x72\x7b\x7f\xcd\x95\xa9\xbb\x42\x01\x12\x36\x8c\x23\x10\x80\x06\x9c\x67\x2c\x91\x57\xf8\x28\x4d\xe4\x5d\xbd\xc3\xc4\x6c\x0a\x49\x08\x29\x84\xec\x81\xc7\x88\x9a\x89\x37\x9b\xa6\x92\x65\x74\xb4\x68\xf8\x2d\x0f\xf7\x55\xf4\xee\x59\x95\x47\x41\xa5\xcc\x8e\x92\x3d\xc6\xcf\x3b\x90\xfa\xd3\xe3\xa8\x24\x1b\xf3\x22\x29\x45\x53\xcc\x06\x70\x08\xb6\x11\x2d\xf8\x5b\x0f\x55\x0b\x18\xa6\x00\x85\x4f\xd3\x85\x4a\x80\x47\x0b\x75\xda\xc9\xe0\xd4\x1c\x49\x58\x79\xe6\x17\x5c\x80\x86\x74\x32\x13\x25\xe3\x09\x78\x2e\x0d\x38\x26\x2e\x86\x68\xdb\xba\x8b\x36\x88\x9b\xab\xca\x9f\xc7\xc1\x05\x48\xa5\xb1\xb7\xe7\x81\x8d\xe6\xaa\xae\x30\x04\x41\x07\x5d\x7a\x84\x7c\x04\xbd\xa1\x9a\xf9\x1d\x38\xad\x41\x66\xb0\xc4\xb1\x07\xb0\xf2\x40\x69\x33\x7d\x70\xea\x3c\xfd\xf4\x0c\x56\x69\xf9\xaf\xa4\xb4\xa8\x33\x07\x1a\xe2\x2a\xfc\x04\x2f\x5f\x69\x14\x0e\x47\xec\x71\xf8\x7b\xcd\x04\x59\xdc\xba\x6f\xdf\xc2\x48\xde\xbe\xc5\xc0\xfb\x0a\x44\x52\xa7\xd7\x63\xfb\x26\xd1\xd6\xfa\x5a\xff\x01\x7b\x33\xe6\xec\x34\xef\x70\x49\x71\x3e\x9b\xb0\x27\xb3\x72\x9c\x17\x42\xde\x2e\xdf\x48\xa6\x1d\x25\x29\x5c\x1f\xa7\x52\x6a\x57\x3a\x50\x0a\x9f\x26\x83\x22\x2a\x2e\xb5\xea\xdb\x6f\x4e\x15\xcb\x16\x46\x05\xe7\x4c\xe4\xa3\xf2\x22\x2a\x38\x5e\x31\x86\x51\xc6\x0a\x1e\x27\x52\x9c\x1b\xcc\x4a\xce\x92\x92\x45\x59\xdc\x83\xe7\xc5\x38\x19\x5d\xca\x26\x93\x12\x84\xdf\x42\xa5\x37\x29\x26\x42\xe3\xf1\xaf\x97\xbf\xb0\x9f\xb9\x10\xbc\x60\xa8\xd2\x4e\xd9\x2b\x88\x0e\xcf\x7e\x56\x19\xbf\x22\x81\xf1\xe2\xc5\x98\xc7\x6c\x00\xcd\xc9\x8a\xcf\x24\x2a\x47\x0a\x15\xf6\x2c\x9f\x65\x71\x84\xcc\xa5\x58\x4f\x2b\xec\x37\x74\x57\xaa\xc1\x36\xcb\x0b\xd9\x48\x33\x2a\xe5\x00\x0a\x25\xae\xb7\x58\x94\x5d\xb2\x54\xde\xa0\x74\xd5\x25\x08\x62\xc7\x0d\xfa\x3a\xd9\xcd\x38\x9f\xaa\x9b\x55\x52\x52\x85\xde\x68\x96\xb6\x65\x6b\x83\x59\xc9\x7e\x7b\xfe\xe6\xdf\x87\xbf\xbc\x61\x4f\x5e\xfe\xce\x7e\x7b\xf2\xfa\xf5\x93\x97\x6f\x7e\xdf\x85\x87\xf8\x7c\x56\xea\xb8\xec\x9c\xfd\x7f\xec\x7d\x79\x73\x1b\x37\xb2\xf8\xff\xfe\x14\x70\x7e\xfb\x4c\x32\xa6\x48\x49\xbe\xe9\xf5\x66\x1d\xd9\xde\xe8\xc5\x57\x59\xf2\xe6\xa5\xf4\x54\x34\xc8\x01\x49\xac\x86\x83\x79\x33\x43\x49\x8c\xa3\xef\xfe\x2b\x74\xe3\x9c\x8b\x97\xa8\xd8\x89\x5d\x5b\x1b\x11\xd3\x68\x1c\xdd\xb8\xfa\xe4\xd3\x38\xe4\x2c\x20\x17\x34\x49\x68\x94\xcd\x95\xf2\xe1\xcd\xcb\x0f\x07\x3f\x3d\x7f\x7b\xfc\xfc\xc7\xc3\xd7\x87\xc7\xbf\xca\xc5\xf5\xea\xf0\xf8\xed\xcb\xa3\x23\xf2\xea\xdd\x07\xf2\x9c\xbc\x7f\xfe\xe1\xf8\xf0\xe0\xe3\xeb\xe7\x1f\xc8\xfb\x8f\x1f\xde\xbf\x3b\x7a\xd9\x21\xca\xd7\x45\xd6\x5f\x3c\xe7\xa8\x1c\x4e\x40\xa8\x4e\x79\x98\xea\x99\x70\x04\xe4\x20\xcf\x4d\xd8\x90\xf1\x73\x16\xc8\x3d\x59\xc4\xf3\xa5\x89\x2a\x71\xd1\x50\x44\x63\x34\x3e\xa8\x62\x48\x72\x08\x39\x80\xda\x24\x65\x8c\xfc\x5d\x65\x56\xba\xb8\xb8\xe8\x8c\xa3\x59\x47\x24\xe3\xae\xca\x0a\x97\x76\xff\xd1\x01\x61\x0a\xbe\x7c\xa0\xfb\x12\xe7\x0b\x9a\x4e\x06\x82\x26\x81\xd5\x8e\xa3\x61\x83\xb9\x3b\xd9\x60\xd7\x50\xa2\x45\x18\x9e\x17\xaf\x35\x9a\xa7\x71\xac\xfc\x9f\x6d\x19\x3c\xe9\x45\xca\x55\xf6\xe7\x84\x85\x34\xe3\xe7\x36\x16\x12\xfe\x53\x21\xed\x54\x4a\xe7\xdc\xc7\x0b\x1e\x64\x93\x1e\x69\xec\xed\xee\xfe\x57\xee\xd3\x44\x67\xc3\x2e\xf9\xe6\xfa\xec\xe1\xfb\x5a\x7b\xa1\xda\x2f\xfa\x61\x68\x2a\x5e\x69\x77\xa4\x2b\xd4\xdb\xd9\x29\xe2\x68\x1a\x32\xa5\x2a\x7f\x14\x4c\x57\x5b\x69\xf1\x30\xcd\x02\x42\x5c\x4c\x44\xc8\x48\x4c\xc7\xac\x4d\xa6\xf4\x8c\xa5\x72\x93\x8c\x54\xba\x40\x43\x4f\x4c\xd2\x00\x26\x05\x21\x4f\x33\x16\x21\x59\xa6\x2c\x4d\xe9\x98\x39\x8a\x3e\x20\x3a\xa4\x66\x90\x47\xea\x50\xc8\xd7\xb0\x06\x6b\x93\x59\x1c\x80\xf2\x10\xfd\x41\xc7\xac\x91\x6a\x4f\x74\x32\x14\x49\xc2\xd2\x58\x44\x01\x8f\xc6\xe1\xbc\x83\x97\x3c\x3b\x20\xf7\x01\x28\xaf\x7e\x38\x22\x4d\x5c\x7b\x58\x9a\x1a\x6d\xe2\x80\xe9\x34\xbb\x1a\x85\x81\x6a\xe6\x62\x84\x93\xc2\x25\x48\xde\x14\xda\xb6\x82\x15\x9d\x6b\xcf\x12\xb9\x29\x3f\xab\xbb\xa0\x20\x06\xdb\x33\xe7\x38\xf8\xfd\x77\x7d\xa4\x8c\xfd\x23\xc5\xb6\xd7\xc2\x57\x3d\x22\xc1\xde\xba\x7d\x80\xf6\x3b\x09\x53\x54\xcb\x3f\x94\x3d\x1e\x83\xc5\x82\x94\x7c\x06\x07\xff\x2f\x6c\x70\x24\x86\x67\x2c\x6b\x36\x55\xb6\xb2\x50\x0c\x61\xe3\xc5\xa3\x77\x28\xd4\x95\x05\x35\xa4\xdf\x91\x1f\xc8\x77\x17\x69\xda\xeb\x76\xbf\x23\x3d\xf9\xa7\xfc\xab\x45\xee\x92\x7c\xed\x89\x48\x33\x72\x97\x7c\xd7\xa5\x31\xff\xce\xed\x2e\x48\x80\xa0\x0b\x1d\x11\x29\xbe\xf0\xfa\x2c\xb7\xcb\x2c\xdf\x71\xdd\xf9\x69\x3a\x26\xcf\xc8\x7f\x1f\xbd\x7b\xdb\x81\xdc\x1b\x08\xdd\x09\x68\x46\x5b\x4f\x0b\x35\x4c\x34\x00\x7c\x29\x74\x78\xfa\x76\x16\x86\xef\x92\x8f\x5a\x72\xd3\x6a\x4e\xd3\x71\xab\xac\x31\x62\x36\x8c\x22\xda\xab\x42\x09\xd2\x00\x99\x1b\x50\xfa\x95\xae\xaa\xc6\x3f\x0c\x45\xca\x6a\x29\x86\xe0\xd9\x31\x9f\x32\x31\xcb\x9a\x39\x62\xb7\xc1\x0c\xaa\xd8\x5a\x59\xc3\x6e\x1f\xbd\x26\x65\x7f\x73\xad\x6a\x0d\x6d\x28\xc6\x25\xc3\x41\x4c\x29\xcb\x8e\x32\x39\x5e\x8b\x29\x4e\xd8\x39\x94\x55\x91\x0f\x62\xe8\x63\xfb\x27\xa7\xc5\x89\xd5\x9f\x3b\x78\x28\x7d\xd4\x7d\xfd\x7c\x55\x84\x85\x67\x53\x94\xb2\xc4\xe3\x78\x2c\x69\x82\xd4\x03\x4d\xdf\xda\x24\xe4\x53\x5e\xca\x50\x6e\x93\x5a\x02\x79\x72\xda\x19\x8a\x68\x48\xe5\x54\x17\x1e\x74\x66\x7c\x28\x6b\x6c\x97\x3d\xfa\xb0\xd5\x56\x09\x37\xca\x7f\x17\x13\x79\x79\x6b\x7a\xad\x6a\x8b\xff\x7f\xd4\xf7\xb4\xd0\xdb\x4e\x3a\xe1\xa3\xac\x59\xd1\x52\x91\x49\x2b\x67\x58\x8f\x1d\xf3\x5f\x17\x10\x15\x8b\xe4\x75\xeb\x03\x6b\xe9\x17\x93\xd1\x7b\x4a\x6a\x99\x13\x23\xa6\x69\x46\xe4\xc2\xec\x94\xae\xcb\xdb\x8b\x17\x66\x67\xc2\xd3\x4c\x24\xf3\xca\x05\x8a\xea\x59\xd0\x40\x3f\x33\xb8\x5e\x3c\x3f\x7e\xde\xff\xf9\xe5\xaf\x47\x1d\xfc\x54\x3e\x3d\xb2\x6a\x96\xd0\xd1\x88\x0f\x4b\xeb\xaa\x6f\xe5\x95\x0d\x19\xb0\x85\xd3\x0a\x76\xf6\x40\x15\xc2\x3a\xd8\x15\xa7\x45\x8d\xef\x88\x4e\xe3\x50\x72\xdc\x32\x7c\x63\x3b\x5c\x89\xa8\x33\xa5\xb1\xb3\xa6\x59\xc8\xa6\x75\xa8\x49\xce\x25\xbe\xba\xeb\x12\x53\x47\x05\x03\xff\x81\xec\x92\x1e\xb1\x25\xe5\x13\x42\x1c\x8f\xf8\xb2\x7f\xf9\xd5\xa4\x46\x67\x17\x94\xee\xcd\xeb\xc3\x37\x87\xc7\x6a\x98\x8b\x06\x53\xc0\x56\xbb\xcc\x48\xe5\x52\x23\x95\xcb\xcd\x12\xa1\x7c\xc5\x55\xe3\x5c\x95\x43\x14\xd3\xad\xc4\x22\x0e\xa3\x56\xa3\xfa\x8a\x99\x44\x8f\xaf\x8a\x4b\xd4\xf7\xa5\xd9\xc4\xe0\xbb\x76\x3e\x71\x28\xb1\x0a\xa3\x14\x4b\xba\x5d\x72\x88\x47\xa5\xdc\x98\xe5\xbd\x4f\xee\xcb\x24\x55\xb4\x5c\x7b\x7f\x56\x0b\xaa\x6a\xaa\xd4\x61\x5c\xb5\x31\xb7\xc9\xc9\xd2\x6d\xf8\x2c\x91\x2f\x3f\x6d\x97\xaf\xf4\x65\xae\x6e\xcb\x8e\x55\xb3\xc5\xca\x83\x55\x15\x97\x1b\xad\x02\x2e\x0e\xd7\xfb\x50\x18\xaf\xee\xdc\x75\x0e\x38\x14\xd5\x37\xe3\xca\xc1\x86\x62\x9c\xb6\xc9\x89\xaa\x5f\xe8\xa7\xc4\x59\xd6\xc7\x42\x91\x9b\x73\x89\x66\x39\xd6\x77\x57\x7b\xf1\x86\x3b\x9c\xd0\x68\x2c\x1f\x61\x2a\xb5\x9d\xdd\xa5\x30\x60\x5b\x7e\x4c\xeb\xdd\x66\x4d\xd2\x2c\x05\xd3\x41\xe4\x20\x5f\x55\x7f\xfe\x40\x3e\x9b\x18\x71\xaa\xe8\x8a\xf4\x0a\x97\xd9\xfa\xd1\x88\x98\x45\x56\xe5\x53\xfd\x4e\xc8\x8d\xe2\x33\x58\x30\x82\xf3\x06\x0a\x39\xeb\xa7\x4c\x3e\x43\x36\x6b\x05\x23\xfe\xd4\x37\x93\xaa\xab\xbf\x8f\x53\x4f\x91\xe6\x94\xe3\xe7\xff\x3a\xea\x4c\xc4\x94\x75\x78\xd0\x96\x5b\x97\x9a\xbb\x29\x8b\x66\xfe\x2b\xca\x1d\x21\x40\xc2\x50\x39\x0a\xad\xe4\xd7\x01\x05\x0b\x44\x39\x87\xc6\xb2\x0e\xff\xe1\x06\xd1\x23\x27\xa7\xbe\x10\x46\x2d\xa4\xe2\x07\xc9\xd8\xc5\x52\x77\xbb\x96\x94\x75\x07\x9f\xe3\x14\x98\x02\xcf\xca\xa5\xdb\xb5\x82\x99\x17\x3c\x78\x03\xb9\xca\xf1\x4e\xad\x45\x24\x2c\xcd\x28\xc8\x4a\xc1\x64\x50\x89\xe3\x46\x3c\x49\x33\x72\xc1\x06\x29\xbc\xdc\x5d\x71\x0d\x1d\x65\x4a\x2a\x6b\x30\xa3\x25\x75\x14\xb0\x84\x05\x9d\x5b\xd8\xb2\xab\x58\x77\xe5\x25\x27\x96\x32\x67\x6c\xde\x23\x8d\x42\xff\x1c\x99\x95\x12\xbf\x5b\x6b\xa4\x3c\x6c\x81\x7b\xfc\xb7\xab\x7b\x52\x3a\x3b\x40\xb7\x4b\xac\x2c\xc3\x8c\x9f\xa5\x84\x96\x0f\x39\x27\xa1\x6a\x7b\xe2\xa9\xbc\x00\x2a\x75\x9b\xa1\x51\x40\xb2\xc4\x64\x8c\xd7\x6d\xc2\x50\x0c\xfa\x50\xa4\xa9\x9e\x36\x55\x4f\x3d\xa1\x69\x44\xc3\xf9\x6f\x8a\x50\x45\x49\x97\xc4\xee\x4a\xbb\x86\x13\x9a\x64\x69\xa3\x46\xdc\xe5\xb6\x71\x8c\x35\xa2\x31\xd3\x54\x57\xab\x00\x42\x60\x6a\x63\x65\xbd\x64\x2d\xb1\x41\x40\x9d\x25\x7c\x3c\x66\x90\x10\x95\x5d\x28\xe2\x6b\x71\xf6\x1b\x4f\x1e\xd8\xb9\xa5\x6c\x57\x48\x9e\xf2\x58\xab\x86\xdc\x08\x50\xa0\xb1\xee\xbb\x64\x2d\x96\x7a\xf9\xbd\x79\xf4\x1f\xb4\xe8\x1e\x60\x02\x79\x94\xee\x36\x5b\x9d\x82\x88\x4a\xd7\x7e\x86\x2c\x83\xb6\x1a\xaa\xf0\xe9\x2d\xff\xb4\xd0\xcb\x0b\xf5\xf9\x26\x88\xa3\x9f\x58\xb7\xb0\x7d\x37\x02\x7e\x9e\x93\xbf\xca\x7f\x9f\xb1\xe9\xb7\x20\x14\x56\x0d\x76\xb4\x98\x58\x9b\xf8\xb8\xff\xea\x9b\xd5\x6a\x72\x1b\x2b\xa9\xfc\x38\xc5\x0d\xaa\x47\xec\x2e\xd9\x51\x9b\x5b\xb1\x45\x0d\xaf\xa0\x9d\xf3\xa1\x78\xae\xb6\x56\xee\xb0\xb6\x19\xb8\xee\x1e\xc3\x09\xa3\xc0\xdd\xd3\xa6\x02\xda\x3d\xc2\x75\x2d\xb7\xec\x3a\x86\x0a\xa6\x06\xd7\x3d\x4e\x7d\x98\x39\xf0\x58\x54\x0e\xae\x8f\x21\x07\x5c\xdd\x8d\x4b\xc1\xcd\xe9\xe4\xc0\xeb\xeb\x65\x69\x05\x3c\xb5\x1c\x68\xb8\x9f\x95\x82\xfa\x47\x99\x3b\x5e\xe7\x43\xc9\xbc\x7b\x45\xde\x96\x0e\xff\x7f\x9a\xb3\xc4\x33\xa7\xcd\xd3\x5b\x57\xca\xc6\xa6\xe3\x49\xe9\xad\x90\xdc\x35\xb9\xd1\xd1\x05\x61\x45\xf6\x5c\x23\x1b\x43\x5e\x54\xb8\x77\x78\xaa\x4c\x3c\x82\x0a\xef\x50\xb8\xfa\xaa\x30\x4c\x76\x1b\xd2\x26\x86\xad\xa6\x27\xe8\xcf\xd9\xc9\x5d\x67\xe2\x89\x6f\x76\x72\xdf\xec\xe4\xfe\x50\x3b\x39\x65\x1b\x6d\x8d\x31\x68\x9a\xf2\x71\x04\x44\x31\x03\xc6\xa9\x2a\x70\xc7\x9e\x36\x49\xf2\xa3\xd6\x78\x1c\x92\x8a\x59\x02\x11\x39\x6d\xd8\x1a\xc9\x21\x06\xcf\x19\x9b\x63\x7e\x72\x09\xa6\x27\x4d\x75\xc5\x4c\x49\x67\x42\xd3\x77\x17\x91\x26\x1d\xaa\xc2\xb0\x4a\x5b\x62\x40\x1b\x23\xe8\xa4\x16\x63\xe3\x57\xf8\x85\x54\x34\x74\x44\x38\x98\x87\x6f\x66\x17\xdf\xcc\x2e\xbe\x99\x5d\x94\x98\x5d\xfc\x05\x4c\x68\x31\x58\x45\xa5\xa3\xf5\x83\x1c\x60\x5d\x27\x10\xc2\x54\xd0\x71\x15\x3e\xf2\xaa\x5e\xdc\xb3\x36\xb4\xaf\x79\x5a\x39\xc7\x8f\x1f\x79\x60\x75\x5d\x90\xdf\xad\x49\xec\x84\x9d\x27\x22\x52\x41\x28\xcb\xad\x6d\xef\x95\x41\xd7\xb5\xe0\x80\x7d\xa1\xb6\xb7\xdf\xcc\x56\xbf\x99\xad\x7e\x33\x5b\xbd\x41\xb3\xd5\x32\xf3\xbc\x82\x34\x6a\x23\xe3\x3c\x8c\x35\xf4\x1e\xf3\x9c\xac\x6a\x9f\x57\x67\x67\xa7\xcc\xf3\x8c\xee\xe2\xc3\xf3\x5f\x5e\x7e\xe8\xff\x72\xf8\xe2\xf8\x27\xfb\x78\x6d\xe7\xfa\x81\x82\x9c\x9e\xb9\x34\x37\xfd\x1e\xd5\xda\x03\x42\xfc\x9e\xc3\x8c\x4d\xd3\x1e\x69\x0c\x99\xdc\x0b\x73\x10\xff\x99\xa5\x19\x1f\xcd\x8d\xc0\x03\xb0\xec\xb0\x28\xc8\xc1\xa9\xf0\xbd\x3d\xd2\xd8\x25\x8f\xe3\xcb\x86\xd3\x5f\x65\x32\x88\xd1\x67\x3b\x26\xa0\xed\xe7\xbc\x74\x3b\xc2\xa9\x7b\x31\x4b\xa8\x9f\xed\xd2\xfe\x83\x1e\x6a\x1b\x44\x5b\x25\xed\x04\xaa\x52\x07\x20\x78\x34\x3e\x1a\x26\x8c\x45\x45\x79\x02\xbb\xe4\x59\x2d\x82\x90\xd1\x73\x53\xdf\xd7\x86\xd8\x31\xa1\x68\xc1\xda\x36\x6a\xfe\xd2\xc6\x8b\xd4\xc8\xf8\x5d\x79\xa6\x64\xb9\x32\x55\x46\x9d\xc9\xa0\x16\x46\xd5\x19\x0c\x2a\x98\x65\xcd\x05\x1d\xcf\x1a\x0d\x08\x3e\xfd\x7c\x78\xf6\x0e\x04\xcc\x19\xe5\x51\x4a\x44\x74\x20\x8b\xe0\xb2\x9a\x99\xc6\xec\x9a\x9a\xb2\x68\x46\xb8\xe4\x9d\x8e\x8b\xe7\x10\x0e\x2e\x50\x14\x60\x68\x0b\x01\xa7\x1d\x8d\x02\x92\xb0\x59\x8a\xf6\x38\xe0\x00\xca\xa3\xb1\x83\x16\x83\x0e\x40\x5b\x20\x93\xb6\x91\x34\x5c\xec\x72\x6b\x75\x2d\xaa\xe0\x8c\x4c\x65\x1f\x93\x39\xc9\xf8\x54\xc5\xbd\x40\xb9\xf2\x94\x65\x13\x81\xe6\xa6\x28\x76\x66\x41\xc7\x11\x1a\xaf\x62\x1f\xa9\xe6\x6c\x19\xeb\x48\x3d\xbd\x4b\xd9\x46\xea\x59\x47\x43\x32\xbf\x73\xa1\x10\xb1\xcb\x27\x50\xe0\x7b\xf8\x5a\x68\x1e\x38\xb6\x42\xc7\xcf\xff\x75\x84\x76\x58\x3c\x28\xb3\x8f\x53\xad\x9e\xf0\xe0\x74\x39\xfb\x46\x34\x65\x54\xf4\xd1\x97\xa4\x12\x75\xa9\x6b\x9c\x87\x75\xf0\x5d\xdb\x39\x63\x65\x2a\xef\xbe\x2b\x43\x77\x85\xa8\x4d\x1e\x2c\x67\x39\x98\x7f\xb1\xbb\x33\x50\xd0\x10\x9a\xf9\xcb\x8b\x02\x49\x9d\x2e\xcc\xd3\x48\x99\xe5\x58\xd0\x47\xad\xab\x95\x30\x7c\xb8\xaf\x74\x0a\x39\x83\xcc\xaf\x44\x6b\xa1\x1f\x24\x7e\x76\x19\xf7\x5f\xb9\x14\x1b\x73\xdd\x34\x62\xf9\x20\x4f\x25\xe9\x4b\x54\x1f\xc4\x95\xaf\x7e\xd6\x09\xc6\xb4\x0e\xc4\x39\x8d\xcb\xd4\x20\xc4\x57\x4a\xe0\xd0\x4b\xd4\xae\xc4\x3f\x5b\xcd\xb8\x56\x9b\x06\x52\xad\xc0\x91\xff\xe4\x55\xaf\xfc\xcb\x1a\xed\x2c\x68\x8b\x54\x29\x8d\xdc\x6b\x43\xd5\x8c\x6d\xd0\x25\xa8\x6a\x5f\x9b\x9d\xc3\xa1\x88\x7e\x84\xdc\xcf\xd5\x4d\x61\x5f\xd5\x89\xd3\xf3\x99\x54\xa4\xa5\xea\xad\xe5\x7b\xea\xbd\x25\xad\x56\x05\xee\xec\x95\x68\xcb\xbf\x94\xa8\x72\x16\xb7\x5f\x3d\xc1\xf0\x7e\xae\x5e\x31\xfa\x5f\x35\xd7\xc8\x7f\xea\x14\x42\xe3\xde\xa6\xb7\x01\xe6\x4c\xe1\x32\x5a\xb0\xa6\xce\xff\x5b\x6f\xf1\x97\x0e\xac\x23\xff\x4f\xde\x2d\xeb\x69\x47\x80\xf4\x3a\x39\x38\xbe\x29\x60\x47\xcd\xe8\x18\xcc\x2c\x0c\x57\xe0\x2e\x69\x0e\x2f\xfc\x7e\xba\x88\x37\xc8\x62\xfe\xf0\x7a\x7b\xcc\x2e\x33\xf9\x34\x32\x49\xb7\x64\x3b\x19\xcf\x42\x96\xd7\x28\xe5\xff\xd5\x99\xd7\x55\xb0\x53\xa1\x74\x55\x9d\x95\x3a\x8f\xaa\x34\x56\xfa\xda\xb2\xa9\xbe\x4a\x47\x9b\x40\x8d\x63\x59\x95\x81\x10\x61\xa1\x82\x52\xad\x96\xc1\x4b\xae\x2c\xc2\xfb\xca\xd5\x25\xea\xad\xa9\x48\x73\xae\xc0\x39\x35\xda\x17\x96\xa9\x47\x0f\xcd\xbc\x54\x0b\x29\xd8\xb7\x1a\x50\xe9\xe6\x53\x04\x7d\x29\xe9\xdf\x31\x91\xb8\x2f\xab\x28\xef\xc2\xe3\x0a\xf0\xda\x0c\xe4\x1e\xa4\x55\x96\x7a\xcf\xb5\xaa\x31\x3f\xa9\x80\xaf\x1b\x6a\x0e\x73\x99\x7a\xb6\xaa\xb9\xbd\xdd\x32\xe8\xda\xc6\x1c\xa4\x56\x70\x5e\xf5\xc4\xaa\x6c\x77\x6f\x71\xdd\xba\x5e\x54\x37\xe8\x24\xb5\xc7\x57\x76\x65\x17\x8a\xa0\x75\x2d\x1a\x74\xdb\x8d\xf7\x01\xb4\xc4\xd8\x8d\x15\x7a\x82\x12\xd0\xda\x34\xf3\x06\xca\x06\xbb\x10\x01\x0d\x2b\x67\xe5\x91\x0f\x57\x1b\x15\x43\x02\xd8\xb8\x6b\x66\x2f\xae\x52\x01\x94\x80\xd6\x46\x69\xb3\x9b\xbb\x89\x2d\x12\xf2\xa0\x32\x54\xad\x93\x7e\x1f\xe0\x6a\x23\x90\x48\x00\x03\x8e\x0f\x8c\x8a\x5d\xe8\xbe\x0f\x56\x87\x15\x00\x0c\x38\xa6\x98\xae\x24\xa4\xc5\xeb\xc8\xaa\xaa\xa6\xee\xfe\x97\x16\x87\xf9\xad\xa8\x24\xc4\xde\xd2\x11\x83\x01\xc9\x82\x88\xc1\xdd\x2e\xf9\xa7\x5a\x7c\x2c\x30\x17\x20\x02\xbc\xb7\x52\x8f\x8f\x0b\x52\xc8\x2a\xca\xec\x2e\x3d\x80\x12\x9c\x8b\x02\x20\x7b\x51\xf7\x24\x17\xbe\xe0\x09\x1a\x7d\x36\x69\x34\x9c\xb8\x19\xa5\xf1\x37\x06\xed\x0a\xd9\x28\x6b\xe4\xa4\xd6\x0d\x30\x23\x68\x40\x48\x31\x0c\xb8\x92\xaf\x85\x00\xf9\x6a\x80\xab\xa6\x56\x26\xe2\x42\x9d\x40\x5c\x44\x0d\x13\xbc\x0c\x34\xf0\x4e\x0d\xcc\xbc\xde\x68\xd9\xb8\x66\x8d\x59\xdc\xb0\x59\x7e\xf4\xb6\x50\xb8\xf2\xd4\x08\xe7\x3d\xd1\x7c\x20\x86\x67\x2c\xb0\x62\xe3\x51\xc8\x2e\x41\x1e\xbd\x4b\xe8\x2c\x13\x0d\x65\x4f\x0a\xff\x89\x7d\xe1\xbd\x38\x67\xc9\x28\x14\x17\xbf\xf6\x48\x03\x60\xf5\x9b\xa2\x42\x7a\x2e\x7f\x18\x9a\x80\x31\x72\x38\x9b\x46\xe6\xb3\x2b\xe3\x3f\x9f\x78\xb5\x64\xa1\xee\x90\x2e\xc7\xa4\x00\x5a\x2a\x8d\xbf\x3a\x26\x73\x81\x86\xfa\x85\x0d\xce\x78\xf6\x4e\xf5\xf4\x68\x98\x88\x30\x44\x89\x7b\x26\x66\xc3\x49\x03\xcc\xcc\x9f\x07\x01\xe1\xef\x8e\xc8\x54\xc8\xa7\xcd\x6c\x4a\x52\x0d\xa7\x85\x42\xdd\x2e\xc9\xd8\x34\x16\x60\xe0\x00\x33\xaa\x3e\x38\xaa\x8b\x11\xbf\x64\x56\xc0\x9f\x89\xb8\x47\x76\x0b\xb3\xf7\x1c\x68\x8b\x69\xfd\xf4\x3c\x86\xf0\x6b\x57\xd7\x4c\xd4\x34\x94\x4f\x3f\x22\x50\x09\xff\x7c\x0c\x3e\x11\x14\x9a\xaa\x2e\x1c\xcb\xfe\x7d\xf6\x3a\xdb\x2e\xef\x0f\xb2\x60\x15\xfa\x02\xf5\x3c\xa8\x29\xbd\xfc\xc9\x27\x6b\x45\x77\x7e\x54\x8d\x78\x3d\xf2\x71\x55\x74\x2b\x3f\x6f\xd7\xd5\xa3\x17\xb0\x30\x7c\x4a\x0d\x44\x12\x30\x3d\xf9\x8d\xbd\xf8\x92\xa4\x22\xe4\x01\x24\xe9\xf2\x43\x3c\x40\xd2\xf8\x80\x9f\xf3\x80\x25\xb5\x0d\x78\x74\x40\xfc\x7a\x2e\xae\xa7\x81\x1c\xab\x60\x13\x38\xac\xeb\x69\x20\x4f\x3a\x6c\x01\xc6\xb5\x56\x03\x53\x79\x00\xf5\xc8\x67\x08\xa5\xf3\xdf\xb3\x34\x23\x10\x81\x22\x15\x24\x66\x22\x0e\x19\xd8\x56\x99\x58\x99\xe8\xa8\x3c\x0f\x21\xa8\xb2\xd2\x2d\xad\x70\x76\x3d\x57\x7b\x6d\xd5\xd1\x22\x22\xf6\x6e\xd4\x3c\xc1\x9d\xbd\x8d\x3b\x78\x5b\x6f\xff\x6d\xb3\x3f\x9f\xb6\x56\x6b\xf6\x58\xe5\x9e\xaf\x6f\x34\x66\xc9\x94\x46\x20\xde\xf5\x85\xbd\xa4\x61\x76\xa3\x95\x9b\x06\x7b\x42\x9d\x9b\xe4\xfb\xef\xe5\x94\x7f\x0f\x12\x11\xcc\x9c\x8c\xf1\x44\x20\xeb\x32\x5a\xd5\x80\xad\x16\x8d\x63\x46\x13\xd8\x0d\xbf\xef\xde\x22\x04\x8f\xa8\xde\xc6\xb3\xd6\xbe\xe5\xf6\x02\x44\xf6\x28\xc7\x30\x96\x70\xd8\x0b\xdb\xf2\x70\xc2\xc3\x20\x01\xc9\x34\x6a\xf9\x57\xba\x56\xe5\x43\xe4\xae\x50\xd9\x91\x9f\xac\x5f\xb1\xb7\x52\x77\x2b\xe7\x37\x9d\xd0\x98\x35\x57\x40\xd5\xf2\xa4\x46\xee\x9c\x7f\x04\x13\x3c\x92\x09\x82\x72\x0c\xbb\xa0\x24\xd1\xc1\xce\x2e\x13\x4e\xf6\x1a\x87\x12\x46\x18\x56\xc1\x04\x20\x28\xf0\x5b\xfb\x27\x1f\x47\x02\x13\x37\x59\x1c\x28\x68\xaf\x1a\x2a\x04\x5f\x2f\xf2\x09\x0b\xd9\xb9\x97\x35\x20\xcf\x28\x06\xa0\x12\x35\x26\x8a\x2a\xa2\xd6\x5a\x6d\xa3\xb4\xb5\xcf\x88\x36\xe1\x11\x99\xf2\x30\xe4\x98\xa1\x5b\x4d\x07\x58\x00\x4e\xe9\x9c\xa4\x31\x1b\xf2\xd1\x1c\x54\xd9\xd1\x38\x64\xa0\x5d\x15\xb3\x0c\x50\x51\x70\xe5\x31\x2f\x12\xc8\x5f\xce\x23\xd8\x01\x67\x34\x0c\xe7\x2a\xd3\x13\x3c\x30\xd8\x30\xb3\x43\x29\x53\xf3\xaf\xc6\xfd\x65\x57\xf4\x35\xd7\x42\x09\xaa\xeb\xe1\xd3\x22\xe2\xdc\xf6\x60\x85\x4d\x2e\x6b\x42\x50\x63\x78\xb4\x7c\x02\xd7\x72\xb0\x1a\xd0\x33\x07\xe5\xb0\xe3\xad\xc4\xa6\x07\x34\x0c\x07\x74\x78\x46\x46\xb0\x6a\x2f\x54\x1c\x24\xc7\x2f\x4b\xa5\x23\x01\x0d\xfc\x80\xa1\xcc\x16\xf5\xe4\x9a\xd3\x63\x9a\xd0\x29\xf9\x8c\xe8\xaf\x94\x41\x00\x70\x2e\xfc\xa5\x8c\xa9\x75\xca\x0b\xd5\xa0\xe9\xb8\x88\x3e\x60\x0b\x07\x4a\x1a\x5c\xde\x79\x49\x3f\xbf\xeb\x87\x23\xf2\x29\x4b\x66\xec\x53\xdb\xdd\xc4\x95\xd3\xa4\x9d\x18\x54\xee\x55\x60\x1d\x08\x11\x16\xd6\xad\x88\x9c\x75\x0b\x27\xf9\x82\x29\xad\xdc\x72\x6a\xe8\x08\xef\xb6\x12\x3a\x42\xf9\xea\x74\x94\xd3\x0d\x86\x5e\x62\x54\xd8\x1f\x50\x87\x7a\x3d\x27\xb0\xb9\x75\x18\x4b\x54\xc7\x4e\x05\xf8\xfd\x6f\x39\x6b\x15\x90\xb5\x1b\xf1\x98\x8d\x8b\xad\x5e\x2f\xa4\x50\x0b\x34\x18\x36\xda\x15\x80\x35\xdd\xf0\xf0\xfd\x84\x8d\x9e\xda\x70\xeb\x7d\xd9\xbf\x36\xaa\x7f\x20\xc3\x7f\xe6\x46\x47\xcf\xc9\x40\x6d\xfb\x2a\x36\x96\xb1\x82\x25\xae\xb9\x40\x3f\x64\x91\x6b\xfe\xaf\x9c\x04\xda\xb2\x24\x35\x71\x4e\x25\x54\x0b\x23\xb0\xa3\xdb\x09\xfc\xf5\x77\xa8\x8d\x3f\xc0\xa5\x40\xdd\x16\x65\xd5\x93\xbe\xb2\xf4\xb7\x8e\x05\x50\x52\x96\x9a\x42\x8e\x84\x3c\x23\x4d\x18\x1f\xfe\x81\xe6\x28\x30\xae\x6a\x99\x67\x7e\x88\x4d\x39\x5f\xe4\x99\x1a\xaa\x6f\xa2\x02\xa8\x72\x72\xe9\x3c\x89\x94\xa5\x4a\x47\x72\xf0\x1c\x90\xb5\xc9\x89\x44\x6d\xe2\x0d\xc9\x91\xb5\x5a\x2d\x45\x03\xfd\xdf\x82\xd3\x74\xb7\x4b\x5e\x33\xc8\x66\x94\xa6\xb3\xa9\xb2\x91\x87\xe8\x78\xee\xfd\x2b\xbc\xa0\xf3\x54\xee\x34\xda\xf5\x97\x88\x88\xcc\x52\x96\x40\xd2\x77\xe6\xbc\x53\x7f\x01\xb3\x7a\x44\x83\x6d\xc9\xc5\x9f\x80\x9b\x81\x20\xe9\x19\x8f\xd1\xfd\x14\x6e\x74\xce\xd1\x22\x8f\x3d\x08\x44\x3f\x61\x16\x99\x32\x46\x25\x53\xf0\x65\xd6\x9b\x95\xb5\xce\x52\x4f\x74\x9e\xa4\x19\xb8\x08\x2b\x25\x0c\xde\xe6\x91\x07\x75\xb6\xf6\x65\x48\xe3\x70\x6b\xcb\x88\x44\x90\x61\x1d\x21\x7a\x71\xb5\x28\xbb\x92\x9c\x8f\xf3\x2f\x3c\x0c\x3f\xa0\x29\x3e\x6c\x1d\xea\x0d\x58\xe9\xe7\x9c\x87\x77\xac\x4e\x72\x6e\xf2\x46\xc1\xe8\x8e\x1c\x4c\x3d\xd5\x97\x2b\x37\x09\x90\xb6\xda\x2b\x31\x79\x59\x68\xee\x62\xcc\xe7\x7d\x33\x14\x57\x7b\x8b\x77\x71\xd9\x63\x30\xca\x02\x03\x00\x2c\x73\xa1\xf4\xbd\xd9\xc2\xe8\x12\x0f\xca\x98\xbc\xf4\x3d\x73\x97\x02\x8c\xce\xbe\xe6\x40\xc9\x22\x17\xce\xde\xd0\x0c\x9c\x29\x72\xe1\x8a\xb7\x1b\x5b\xa1\xf8\xcd\xad\x69\x4f\x77\x5b\xc3\x96\xb9\x90\xfe\x71\x6a\xa1\xfd\x72\xaf\x46\xec\xce\x95\xfc\xe5\x7e\xb5\xe7\x91\x85\xb1\x65\xde\xe8\xe4\x49\xe9\x0c\x08\x72\x7b\xb8\xdf\xd5\x4b\x50\x7d\x9e\xc7\x7e\x2f\xc0\xdc\x59\x6d\x6e\x55\xca\x3a\x67\xfd\x20\x73\x90\x93\x06\x32\x80\x3c\xa7\x34\x99\xe1\x6f\xa4\xa6\xf9\x53\x92\x4c\xfe\x30\x74\x81\x83\xad\x30\xe7\xb2\xd4\xce\xab\xfc\xe5\xcf\x1b\x94\xc4\xd8\x84\x9d\x05\xc0\x25\x87\x0b\x7f\xcc\x63\x86\x4f\x55\x87\xb1\x93\x2c\x34\xc9\x40\x02\x2d\x18\x54\xf2\xd5\x2c\x6c\x3c\x75\x40\xb5\x4c\xd4\xe1\x76\xfd\x99\x8f\x48\x53\x62\xba\x73\x87\xd8\x17\x27\x3e\x35\x4f\x3b\x3c\x1a\x86\xb3\x80\xa5\x5a\x04\xec\x9a\x72\xe4\x70\x3a\xe2\x60\xf2\x83\xc6\x40\x7a\x8e\x54\x97\xb8\x91\x0d\xc0\x67\xd2\x38\x9e\x2c\x67\xfa\xa1\x14\x1d\x45\xe3\x95\xcf\x65\xeb\xa6\xa7\x98\x03\x24\xc7\xe6\xb6\x41\x7e\x70\x56\x96\x23\xee\x92\xff\x30\x93\xa8\x32\x08\x29\x5b\xb2\x3d\xe7\xf8\x47\x0d\x97\x65\x1e\x6d\xe9\x04\x02\x9e\xb6\xde\x0a\x4e\x1a\x8e\xc0\x07\x32\xdb\x4b\x04\x4a\x03\xd3\x19\xd2\x98\x67\x10\x31\xee\x95\xdc\x09\x5f\xb3\x2c\x63\x49\x4b\x4f\xf6\x69\x5b\x27\x00\xf1\x14\xdc\x7e\xee\x96\xb2\x76\x50\xb0\xb4\x7a\x6b\x30\x5f\xb7\xfd\xf9\x6a\x59\xeb\x10\xc7\xe8\x45\xaf\x0a\x55\x60\x6d\x4c\xb5\x2f\x83\x4a\x49\x66\xee\x7f\x2e\xe3\xac\x6a\xef\x53\xb0\x37\xab\x4a\x65\xb3\x1a\xa1\x50\x74\xdf\xb6\x95\x5a\xf2\xac\x81\x2d\xc3\x33\xb9\x42\x2e\x35\x05\xad\x52\x56\x4e\x43\x1e\xf0\x68\xfc\x62\x55\x8e\x46\x85\x60\x91\xa3\xab\x86\xe8\x4e\x0b\x8f\x1a\x3d\x92\xdf\x5a\x03\xab\x21\xa8\x54\xe4\x78\x1b\x28\xbe\xb0\x7b\x25\xe7\x88\x77\x4a\xc2\x7d\xa7\x47\x6e\x3b\x9e\xf0\xf6\xf4\x76\x58\xc4\xd9\xdb\x5b\x79\xaf\x81\xc5\xdc\xa2\x1f\x08\x5f\x31\xbb\x78\x9c\x50\xc3\x35\xdd\xae\xdd\x9f\xcc\x72\xbb\xb5\xce\x90\x95\x42\x7c\x2d\x26\xfa\x91\x0e\xcf\x82\x44\xc4\x45\xe9\xc1\x22\x8e\x58\x69\xf2\x40\x28\xed\xce\x9d\x37\x63\x13\x71\x51\x64\xe4\xfc\x13\xde\xff\xed\x72\x1c\xd0\xa0\xed\x5c\x67\x1c\xec\x65\xd4\x70\x2f\x97\x98\x21\x49\x07\x63\x00\x28\x6b\xd7\x66\x67\xde\x0f\xc9\x80\x6f\x1e\xf5\xcd\x15\x08\x6b\xb9\xae\x3a\x47\x7d\x31\xda\xde\xc3\x76\x85\x30\x0a\x09\xa2\xfc\x4c\xfa\x4b\xbb\x98\xa0\x5b\x49\x39\x7c\xde\xa3\x04\xf6\x6e\x94\x5a\xa0\x4f\x95\x79\xc2\xbb\x67\x63\xb7\x4b\xde\x40\xd2\x6c\xbc\x99\x77\xe4\xc3\xbc\xc2\xd0\xcd\x31\x95\xc8\xa7\xa5\x6a\x93\xcf\x64\x14\xf2\xd8\xba\x6f\xf1\x6c\x72\x8c\x22\x0f\xb4\xb5\x8c\x80\x6d\x1a\x6f\x66\x1c\xe7\xb2\x41\xae\xcc\xc3\xb0\x60\x1e\xb7\xbf\xfb\x55\x67\x35\x5c\x6c\x4d\x77\xf3\x06\x6f\x5b\xc8\xb1\xf8\x45\xd9\xd0\x6d\xd5\x3e\xf1\x9b\x81\xde\x37\x03\xbd\x2f\xcf\x40\x0f\x7e\xbd\x10\xd3\x2a\xdb\xa1\x27\x05\xc8\x85\xb8\x5f\x88\xe9\x8d\xda\xff\x6d\x33\x93\xea\x19\x9b\x0f\xab\x2d\xc3\x9c\x18\x07\x0a\x70\xc1\xbe\x27\x41\x1c\x2e\x78\xf1\xee\x4d\x95\x81\xdc\x03\x1f\xac\x0e\x2f\x00\xd8\x69\xd4\x3e\x91\x55\x5c\xf8\xb8\x00\x5a\x3b\xdf\x0a\xc6\x54\xc2\x38\x5c\xea\x32\x59\x19\xfc\xe1\x61\x39\x7c\x5d\x4b\x1e\xa0\xdd\xe6\x2f\x22\x26\x1f\xa6\xb3\x9a\xe6\xf6\x1c\x2e\xf5\xe0\xeb\x9a\xf3\x00\x6d\x6f\x83\xe0\xe5\x39\x8b\xb2\xd7\xf0\xa0\xa8\x89\x6e\xf1\xa8\xb2\x4a\xed\x18\x73\xb0\xab\xdb\x56\xbe\xa2\xd5\x06\xa3\x8f\x1e\x7b\x60\x75\x1d\x91\xdf\x6f\xd4\xd2\x15\x6e\xf2\x6f\x68\x44\xc7\xd5\x96\xa9\xfb\xf7\x4a\xc1\xeb\x5a\x72\xe1\x4c\x65\xfd\x38\xa9\x6c\xe7\x61\x01\xb4\xae\x0d\x0d\x63\xed\x66\x45\x92\x55\x5a\x1c\x3f\x70\x2c\x8e\x11\xb0\xd6\xc2\x16\x20\xbe\x34\x63\x58\xb5\x08\x6b\xcc\x65\x96\xb7\x89\x75\x71\x2d\xb2\x25\x5d\xbd\x8b\xd7\xd5\xbd\x85\x5d\x83\x27\x4e\x40\xc3\x94\x04\x22\x6a\x64\x28\xa8\x56\xf1\x43\x55\x2a\x98\x54\x80\xaa\x80\x5c\x00\xc0\x20\x61\xf4\x8c\x0c\x45\x34\x9c\x25\x09\x8b\x86\x10\xd1\x8a\x1c\x40\xb8\x22\x1a\xa6\x82\xc4\xb3\x0c\xe1\x31\x52\x2a\xd8\x65\xad\x67\xff\x6b\xf4\xe6\xd7\x68\xff\x6b\x70\x5e\x23\xcd\xbe\x10\x8b\x65\xd9\xe3\xdc\x76\x04\x4f\x53\x6f\xcf\xb1\x8f\x53\xbd\x9a\x37\x37\xfa\x4d\x84\x70\x4c\x02\x2b\xcc\x75\x4b\xd3\x5e\x95\x07\xe2\xa8\xb4\x82\x2d\x35\xd2\x0d\x38\x0d\xc5\xd8\x37\x94\xcd\x19\x79\xba\xf6\x80\x13\x1e\x04\xcc\x09\x6c\x71\xce\x53\x3e\xe0\x21\xcf\x64\x8f\xf1\x63\xc3\xca\x43\x56\xb6\x00\x2c\xb5\x87\x3b\x9e\x30\x72\x70\x74\xa4\x42\x02\x41\x26\x6c\xa5\xfc\x1c\xe8\x2d\xbd\x60\xa3\xa0\x77\xe7\x83\xb5\x6c\x9a\xde\x43\xec\x21\xc7\xc2\x04\x9b\xce\x04\x68\x73\x69\xea\x35\x5e\xd2\xa8\xae\xb7\xaa\x65\x90\xb7\xc3\xae\x69\x12\xe4\xe2\xb8\x1e\x5b\x20\x07\x63\xab\xd6\xbe\xc5\x90\x03\x3c\xfb\x81\x35\xd0\x14\xd4\x9f\x9e\x43\xfd\x69\x05\x9b\x97\x52\x53\x30\xd3\xde\x1f\x6d\x13\x56\x2b\xf7\xfc\xeb\xd9\x86\x3d\xd7\x93\x0b\x8a\x1d\x13\x94\xbb\xb0\x48\xd7\x35\x1f\x35\xa7\xfc\x66\x4b\xe4\x7a\x97\x47\xeb\xeb\x37\xe5\x7c\x8e\x86\x2d\x67\x8c\xc5\x2a\xaa\xba\x32\x53\x50\x61\x23\x5f\xbc\x7b\xd3\xd1\xcb\x91\x3b\x81\x3c\x86\x34\xb2\x01\x24\x25\xf0\xd1\xcb\x77\x24\xe5\xd9\x4c\xd9\x84\x26\x58\x09\x2c\xf7\xe6\x62\x46\x2e\x68\x94\xc9\xd1\x4f\xe9\x25\x9f\xea\x04\x57\x18\xaf\x3d\xe5\xe7\x2c\x62\xa9\xb1\x38\x86\xdb\x95\x9d\x1b\xd9\x35\xd0\x11\x81\x13\xf7\xb2\x9b\x47\xcd\x36\x15\xf0\x94\x0e\x42\x6d\x2d\x28\x9b\x50\x25\x7a\x49\xaf\xd7\x0c\x78\xf8\x2b\x03\x1e\xdb\x1e\x58\x0f\x45\x22\x03\x4b\x46\xb4\xb1\xf3\xf5\x10\x9f\x8c\xed\xa1\xed\x0f\x52\xd6\x9e\x67\x18\x48\x60\x8d\x3e\x4d\x78\x06\x01\x8b\x58\x3a\xa4\x31\xdb\xa4\x33\x2f\x01\xc3\xcf\x6c\xfe\x71\x95\xe9\xc9\xf3\xa8\x7b\xb1\x5a\xdf\x20\x34\xb5\x06\xa1\x2e\x5d\x81\x00\x60\x98\xe5\x98\x59\x46\xcb\xcd\x62\xd1\x8e\x33\x67\x82\x3a\x60\x23\xa1\xe6\x0c\x06\x21\x1b\xd4\x2a\x15\xb7\xb9\x97\x2a\xd6\xd7\x9a\x27\x80\xbd\xc0\x6f\x7c\x02\x18\x54\xd7\x7d\x02\x68\xc4\xad\xe5\x6c\x76\x17\x4f\x17\xf8\x83\x7d\x9b\xb1\xdc\x8c\x4d\xa8\x9a\x32\x77\xa7\x52\x33\x06\x11\xf4\xff\xe2\x13\xe6\xec\x02\x6a\x7b\x83\x68\x5a\xf2\x8c\x62\x69\xca\x02\x4c\x47\xe2\x32\x20\x97\xd7\xc8\xe1\x2c\xf5\xa6\x73\x89\x7d\x6d\xbd\xcd\xe1\x92\x67\x79\x66\xc7\x28\x7e\x7f\x71\xba\x95\x6e\x0d\xe5\x93\xf5\x6d\x63\xa8\xdc\x18\x2e\x79\x96\xdb\x17\xa0\xe4\xdb\x74\x7d\xd5\xde\x22\x6f\xf4\x82\x28\x3c\xa4\xd1\xc4\xa5\xe6\xe2\x95\x0f\x2f\x04\x4d\xe0\x23\x1a\xd9\xc6\xce\x46\x9c\x88\x73\x1e\x40\x06\x28\xf4\x0d\x1d\x99\x30\xf5\xf0\x26\xc6\x28\x96\xd1\x98\xa0\xa0\x28\x6d\x4b\x44\xb1\x88\xc5\x39\x4b\xf0\x85\x7c\x31\xa1\x19\x3b\x67\x09\x78\xd9\x77\x6e\x19\xd7\x41\x3b\xdf\x18\x51\x94\x67\x29\xf9\xa4\x9f\x14\x9f\x48\x24\x02\x06\xbb\x70\x22\xd0\x9a\x9d\xda\x0b\x9c\x6b\xd4\x6e\x7a\xae\xfd\x8a\xc4\x68\x84\x01\x4a\x47\xec\x82\x4c\x58\x18\xcb\x47\xc7\x88\xd1\x6c\x26\xcf\x01\xd9\x2f\x32\x93\xef\x4f\x08\xfc\x4a\x28\xf9\x84\xd2\xf4\x4f\x4e\x97\xe4\x69\x90\x8a\xa9\x7a\x90\xa5\x3d\xd9\xc4\x0e\xc1\xbb\x68\xaa\x46\x4a\xd2\x8c\xe2\x1d\x1e\x78\x48\x44\x6c\x87\x66\x3b\x74\x07\x42\x74\x02\x6a\x0e\x51\xa0\x59\x24\x66\xe3\x49\x07\x51\x1c\x80\x5a\x3a\x75\xc6\xd2\x86\x59\xc4\x47\x85\x44\x06\x62\x7c\x8a\x82\xc1\x01\x0b\xc5\x85\x5d\xcc\x0a\xc7\x61\xa6\x5e\x56\xe1\x9c\x4c\x55\x97\xe0\xa8\x7a\x4a\xa6\xe2\x1c\x1e\x15\xc2\xd9\x01\xd4\xeb\x1a\xe8\x42\x60\x64\xf2\x91\x04\x4d\x65\x2a\x5f\xfc\x2c\xca\x78\xe8\x6f\xb2\x86\xeb\x55\x8b\xea\xd5\x93\x5a\x6f\x7b\xcd\xdf\x31\x1d\x1b\x47\x50\x95\xee\x53\x79\x2f\xc9\xaa\xcf\x83\x20\xd5\x2e\x0c\x89\x88\x13\x08\x9a\xfa\xfc\xc3\xe1\x73\x92\x08\x89\x8e\x26\x0c\x22\x05\x4c\x69\xc6\xe5\x4a\x99\x5b\x8a\xca\x5e\x18\x8a\xa4\x13\x2a\xa9\x37\xa5\xd1\x1c\xa4\xe3\x2c\xce\x52\x14\xb7\x9c\x80\xf6\x78\x47\xd2\x35\xa4\xf3\xf4\xb4\x89\xc9\xd2\xbb\x5d\x2c\x1f\x08\x91\xa5\x59\x42\xe3\xce\x98\x67\x93\xd9\xa0\xc3\x45\xd7\xaf\xd1\xfd\x7f\x30\xea\xb4\x25\x9b\xee\x82\x34\x52\xc7\x86\x59\xd7\x31\xe8\x0d\x1a\xa0\x2d\xf0\x0b\x02\xa8\xad\xb9\x05\x99\xb0\x34\xe4\xcf\xee\x15\x84\x32\x80\x15\x9c\x82\x70\x6a\xd6\xf0\x09\xb2\xe1\xde\xdf\xa3\x2b\x05\x0d\xc3\xa6\xf5\x18\xda\xb2\x03\x8d\xe2\xaa\x6a\xff\x19\x37\x49\x60\xad\xe3\x4c\x3e\x43\x20\x84\xbf\x77\x42\x52\xca\x03\xc4\x35\x8a\xcd\x27\x9e\x64\xfa\xfe\xe0\x67\xb7\xbc\xb2\x92\x7d\xdf\x8d\xa6\x2a\x93\xe1\x2a\x59\x0c\xa1\x0f\x53\x94\xed\xe4\x72\xf2\x82\x61\xef\x82\xde\x4f\x68\x14\x84\xec\x68\x22\x2e\x9a\x2b\xf4\x77\x63\xaf\xa4\x88\x5d\x66\xef\xfd\xa0\xd5\xb2\xb7\xa6\x18\x3a\x4b\xee\xdc\x71\x73\x7e\xe1\xec\x2e\x33\xff\xf9\xbc\x9f\xcb\x0d\x08\xb3\x89\x2d\x33\x14\x84\xac\x1a\x44\x9e\x63\xe4\x30\xfc\x81\x15\xc6\x30\x94\x5b\xd5\x2b\x91\xbc\x92\xe7\xd5\x2a\x84\x78\xc1\x83\xe5\xba\x6d\x00\x21\x83\x6c\x59\xaf\x4d\xb9\x3f\xf7\x6b\xf1\x8e\x76\xe2\x93\xc7\xd8\x05\xe5\x18\xf0\x5b\x69\x1f\xf4\x35\xdb\xdc\x00\x41\xa0\x4b\x43\x79\x29\x97\xf8\x7e\xe2\x81\x72\x05\x5c\x48\xb0\x68\xba\xec\xca\x56\xa0\xb9\xb5\x9d\x27\xd4\xef\xbf\x7b\xa6\xf5\x15\x0c\x67\xbb\x59\x1c\x76\x6e\x35\x62\x1e\xb1\xca\xc1\xb8\x54\xaf\x1a\x85\xcf\x19\x5e\xf7\x95\x31\x93\xd9\x09\xf3\x1d\x0d\x69\x9a\x41\x3d\x7d\x86\xf8\xd6\x43\x9e\x52\x76\x01\xc3\x25\x2c\xcd\x44\xc2\x5e\x6b\x8c\x95\xae\x7f\x3e\x58\xd9\x7c\xdb\x5e\x69\x16\x33\x25\x1d\xb8\xaf\x55\x8f\x03\xbf\xbb\xe1\xc7\x0b\xe3\x74\xec\x7a\x17\x0c\xc9\x72\x6f\xc5\x60\x5c\xf6\xf6\x7c\x19\x03\x31\x34\xee\x6c\x9e\x81\x94\x73\x86\x19\xfb\x3e\x1b\xbf\x94\x47\xc1\x8b\x77\x6f\xde\x8a\x80\xc1\x44\xb4\xcc\x30\x1c\x36\x74\x85\xbb\x1d\x1a\x04\x08\xe9\x01\x8a\x48\xb7\x07\x12\x17\xc7\xb6\x0a\x69\x9c\x37\xa0\xb2\x9d\x0a\xc4\xb0\x4d\x1a\x67\x6c\x3e\x8b\x1b\x6d\x97\x97\x3d\x84\xf9\xd6\x60\x66\x57\x6e\x65\x84\x5c\xe2\xb6\xe2\x21\x6a\xc3\x49\xe5\xb7\xe5\x51\xb7\x84\x62\xa3\x1a\xce\x1b\xe5\xd8\x0d\x62\x9f\x83\xad\xc8\x72\x4b\x60\x73\x6a\xb6\x5c\x57\x3f\xa0\xa3\x4d\xf7\xad\xb6\x05\x79\x7b\xd6\x4c\x8f\x4f\x17\xc9\xba\x07\xf2\x6d\xe7\x56\x86\xb1\x1c\x46\xfa\xb6\xed\x0d\xe3\xce\x1d\x75\x15\xd2\xd6\x86\xb6\x97\x6e\x9b\x6d\xaf\x96\xef\xeb\xe3\xf5\xed\xce\x1d\x72\xdb\x6d\xcf\x5d\x7c\x70\x2c\xb8\xd0\x9d\x09\x4d\x9f\x67\x2a\x2b\x5a\xb3\x91\xd1\x01\x18\x43\x34\x72\x29\xd9\xbd\x2a\x29\xcb\xca\xaa\xb4\xc9\xce\x9e\x17\x36\x59\x99\xfb\x77\x58\x74\xde\x79\xfb\xee\xc5\xcb\xfe\xcb\xb7\xff\xc6\xf4\x3b\x71\x22\x82\x99\x4a\xc0\xf3\x83\xf2\x7b\x50\xb6\xa7\x76\xf0\xca\xc9\xa1\xf1\x46\x85\x1f\xdf\xf9\x78\xd8\x2b\xbe\xf6\xf0\xf5\x1c\x08\x96\x82\x0a\x87\x0e\xe5\x83\x49\x09\x34\x21\xba\x53\xe3\x95\xd6\x91\xb3\x88\x8d\x38\x3e\xb0\xd3\x94\xa7\x90\xe7\x38\x63\xc3\x49\x24\x42\x31\xe6\x2c\x6d\x23\x3c\x84\x56\x51\x83\xd2\x4f\x3f\x7c\xa2\xa7\x64\xc0\xe4\xb9\x97\x32\x50\xda\x7d\xb7\xb3\xf7\x5d\xa7\xd1\x22\x3d\x72\x2e\x78\x40\x76\x4b\xf3\x4c\x7b\x33\x37\x5a\xf2\x32\x60\xcf\xa3\xda\x8d\x0c\x0f\x2c\xff\xde\x58\xb2\xe9\x24\x6c\x2a\xce\x99\xbf\xef\x98\xbd\xbb\x62\xef\x69\xd5\xee\x4c\x1a\x65\x19\x3a\x6f\x4f\x68\x95\x6e\x39\x85\xea\x2a\x63\x77\xfe\xa4\x59\xe0\xac\xae\x75\x58\xb5\x4e\xeb\x1a\x28\xb7\x91\x68\x0f\xe6\xfc\xf3\x90\xfc\x83\xec\xca\x15\x64\x1f\x77\xbb\xa7\xc0\xb3\xe6\x14\x22\x3f\xf8\x1f\xdd\x4c\xfb\x4b\xb8\xc5\x17\x2c\x63\xac\x97\x75\xe1\x53\x69\xbd\xa2\x9b\x7b\xe1\x53\x59\xbd\x72\xdb\x32\x1f\x41\x11\xa6\x0c\x93\x31\x5a\x29\x22\x30\x9f\xf2\x6e\x68\x16\x54\xfe\xb2\xee\xd6\x2b\x3a\xe4\x81\xd5\xee\xf2\xfe\x78\xc6\xbb\x12\xbd\xa3\xd0\xb1\x53\x76\xa0\x6d\xdd\x33\x6b\xe6\xa7\xc4\x0d\xb1\xbe\xa3\x45\x02\x7a\x9b\x28\xb7\xd6\x3e\xb5\x13\xe6\x98\x2c\xd4\x92\xd6\x4f\xb1\x80\x5b\x82\xa7\xd7\xb5\xfb\x91\x76\x36\xbe\xd6\xf8\x0f\xa5\x89\x4e\xec\x12\xd8\xaf\x5c\x03\x39\xc3\x02\xc3\x1c\xfb\x9d\xdc\x97\xe5\x16\xce\xfe\xba\x2b\x67\x7f\xe3\xa5\xb3\xbf\xf1\xda\xd9\xaf\x5f\x3c\x25\x36\x0f\x4e\xd5\x92\xaf\xc5\xca\x8e\x2e\xaf\x50\xd5\xf9\x56\x1b\x95\x63\x7f\xa9\xb0\x1c\xfb\xcb\xc5\xe5\xd8\x2f\x0f\xcc\xe1\x58\xb4\x38\xa0\x4e\x69\x3b\x7f\x21\x51\x07\xdc\x7b\x9f\x87\xdc\x4f\xfe\x72\xa9\x9a\xc6\xdc\x17\xbf\x52\xf9\xf4\x79\xe5\x4b\x84\xf4\xd8\xaf\x8b\xe9\x81\xda\x6b\x1f\xbb\x2c\x29\x01\x52\x7e\x3c\x3e\x1c\x98\x2f\x15\x40\xbd\x69\x34\x65\x39\xc0\x4b\x9e\xf9\x50\x97\x3c\x2b\x82\x14\x5a\xc5\xb2\x22\x60\xbe\x4d\x28\xaa\x3c\x0c\xf6\xe1\x34\xd8\x38\xb0\xc8\x7e\x9b\x9c\x34\x72\x3b\x47\xa3\x4d\x1a\x85\x5d\xc1\x2b\x74\x03\x8d\x54\x2f\x62\xf7\xab\x59\xa0\xb2\xb0\x64\xe9\xd9\x62\x87\x37\x96\x8d\x75\xe2\xf0\xb9\xfc\xe9\x32\x31\x46\x36\x29\x34\xe5\xb1\x60\x45\xf4\x13\xa4\xba\xf3\x27\x8f\xc6\xce\x2f\x6c\x0b\xe9\x64\xff\xb2\x30\x40\x3e\xf9\xb7\xa4\x93\x17\x27\x05\x1e\x12\xee\x8a\x95\xaf\x8e\xa5\x24\x7c\xea\xc8\x8f\x66\x61\x58\x1a\xf1\x21\x2b\xe8\x35\x53\x27\x2c\x95\x63\x4c\x54\x58\x24\xae\xdd\x4c\xd9\xca\x70\xac\x44\x4a\x96\x83\x36\x44\xc8\xaf\x01\x47\xe7\x5e\xc2\xf8\x8e\x86\xd9\x1e\xc2\x96\x8d\xf0\xa3\x1e\xa6\x77\x48\xe2\xc3\x00\xcc\x42\x8b\x61\x2d\x0e\x14\xc7\x74\x44\x14\xce\x9b\x9a\x7f\xbc\xf7\x68\xdf\x22\xf8\x9b\xbe\x72\xda\xa2\xe2\xa1\x9b\x08\x3c\x75\xf2\xd5\x3a\xf2\x83\x17\xb9\x42\xbf\x7d\xca\x80\xf5\x47\x6f\x28\xd0\x3f\x63\xb0\x7e\xe5\x3d\x4d\xb1\x59\xf7\x02\xed\x32\x83\xad\xd9\x51\xfd\x2b\xc2\x93\x1f\x48\x23\x50\xaf\x90\x06\xe9\x01\x44\x81\x73\xe0\x01\x62\x3a\xbe\x44\x73\xce\x28\x9d\x7a\x98\xbf\xf5\x07\xb2\xb3\x47\x7a\xc4\x8e\xb5\x84\x4d\xb5\x56\x53\x0f\x5b\x3f\x01\xad\xb0\xf4\x10\xa2\xa7\x11\xcb\x0c\x24\xe4\x67\x8e\x3a\xb8\xf0\x7e\xb7\x74\xcb\x65\xa3\x6f\xca\x9b\xab\xf7\x22\x87\xfd\x11\xfc\xc8\x1d\x55\x51\x71\xe1\xb4\x3a\x23\x91\xbc\xa4\xc3\x89\x93\x38\xaa\x90\x73\xd0\x4e\x8a\xce\x6c\xef\x47\xb7\x41\x0d\xcd\x84\xca\xc9\x7c\xa5\xd0\x94\xb6\x06\xd5\xdb\x05\x26\x84\x62\x37\xfb\x91\x7d\xff\x62\x38\x7a\xdb\x99\xfc\xa4\x96\x34\x52\x4a\xf9\xb2\xe9\xb0\xc3\x6a\xa9\xb7\x9d\x3b\xec\xda\xd5\x37\x0c\x45\x64\x2e\xf5\x16\xb2\xed\x4c\x55\x31\xee\xc8\x8a\x4f\x19\xe5\xfa\x56\x1f\x73\x49\xe5\xba\xcb\x85\x4d\x4a\xd8\xc8\xbb\x9b\x8f\x9a\x91\x08\x58\x21\x43\x22\x66\xd8\x02\xc9\xb5\x4a\xde\x00\x52\x8c\x1f\xe0\x3f\x9d\x31\xcb\x5e\xd3\x39\x5c\xea\x7b\xde\x66\x4c\xfc\xec\xa8\xcb\xbe\x7d\x9c\xda\x4b\x07\x8a\xf1\xfa\xbb\x52\xdc\x93\x44\x88\xcc\x09\x7b\xb2\x42\x40\xa7\x0e\xba\xe6\xb4\x4b\x0e\x29\x37\x5f\x97\x0d\x7f\xe2\xf7\x72\xb9\xb9\x77\x66\x1f\x05\x7e\x12\x28\x97\x03\xd3\x6d\xcc\x0b\xdb\x72\x3b\xff\x3c\xba\x73\x27\x77\xd6\xfe\xfe\x3b\xa9\x53\x6e\xe8\x13\x38\x27\x00\xf1\x16\x57\xab\x70\x99\x06\x16\x37\x85\x65\x0f\x46\x2f\xa6\x0b\x88\x16\x17\x86\x74\x41\x85\x75\x49\x44\x97\x12\x07\x21\xeb\x6b\xea\x2e\x8a\x3a\x87\x92\x7b\xbb\xbb\xed\x72\x6f\x1a\x13\x8b\xc5\x33\x93\x37\xa5\x05\xcb\x76\xf3\xa5\xd4\xc6\x3c\xf7\xd5\x33\x8e\x34\xdf\x7c\x23\x6e\xf7\x97\x71\xfd\xca\x6b\xd5\xbd\x84\xb0\xb9\x6f\xea\xb1\x6d\x1e\xda\xf7\xdc\x87\x76\x49\xc4\x4e\x4f\x51\x7a\x4b\xe5\x58\x5d\xa0\x5d\xd0\xcb\xbe\x42\x2d\xe0\x7d\x2e\xd1\x80\xd5\x6b\x6a\x1c\x01\x79\x19\x2a\xbd\x25\xc1\x87\x5b\xa4\x52\xab\xe0\xd9\xa6\xe8\x75\x06\xb7\x4f\x9c\x16\xd3\x31\xb9\x18\x54\x51\x89\x0c\x94\xa7\xc7\x22\x46\x33\x14\x04\x72\x8e\x53\xe4\x68\xcf\x7e\xe3\x26\x75\x0d\xba\x3f\x6a\xa9\x95\xe8\x1a\xcc\x48\x95\xb6\xc1\xfd\xed\xea\x1b\xcc\xdc\xe4\xf5\x01\xde\xef\xdb\xcf\x8a\x0a\x88\xdb\x6b\x68\x20\xec\x04\x56\xcb\xb8\x95\xef\xa3\x4f\x5f\x8f\x1d\xab\x73\x16\x6f\x9d\xc8\xee\xcd\x01\x62\x53\xd8\x61\xab\x8e\x40\xcc\x3e\x96\x0e\x1b\x0b\x99\x05\x5f\xa2\xf7\x2c\xb1\x72\xf7\xef\x72\x39\xc2\xbd\x2a\x39\x42\x85\x14\xe1\x5e\xa5\x14\xa1\x5a\xd4\x73\xaf\x28\xea\xd1\xcf\x38\x39\x01\x5e\x07\xec\x30\xbd\x62\x35\x1d\x85\xc9\xcb\xf5\x52\xf2\x51\xa1\x2d\x17\xa5\x0b\x9d\xc3\x59\xc2\x26\x79\x69\x4d\x0d\x9b\xb8\xe9\xa9\x81\x68\x58\xa0\xd8\xf5\x18\xca\x97\x24\xe1\xfd\x1a\x12\x96\xcb\x8f\xee\x57\xcb\x8f\x2a\xc8\x78\x7f\x01\x19\xab\xda\x29\xf9\xea\x93\xd2\xfb\xe4\xce\xbc\xf7\x61\x65\x72\x56\xa2\x5d\x8d\xa0\xf9\x67\x71\xe5\xd6\xee\xad\x70\x0d\x5d\x16\x7c\xf8\x81\x79\x6f\x29\x51\xd0\x83\x1c\xf5\x5a\xa6\xba\xb6\x7e\x43\xb0\xb6\xd5\xe1\xf8\xf3\xa0\x2a\x2f\xb2\x00\x53\x60\x79\xbb\x11\xe5\xe6\x7d\x0d\xa1\xdd\x6c\x24\x37\xd8\xcf\x20\x90\x9b\xb6\x73\xac\x89\xb5\x76\x85\x86\x7a\x75\xc1\xdb\x9a\xf2\xa8\x29\xc4\x82\xdb\xfb\xb2\x52\xa5\x6e\x29\x00\xd0\x8d\xc4\x10\x01\xf5\x80\x69\x49\x44\x92\xb5\xaf\x9e\xde\xaa\x34\xef\xf1\xe1\x61\x21\x98\x95\xa0\xe5\x1e\x9d\x42\x60\x1c\xdd\x49\x5b\x51\xbe\x31\xda\xb8\xf3\xe1\x9b\x08\xb9\x33\x69\x93\x21\x8d\xb3\x59\xc2\xf2\x3b\x20\x3e\x04\xf3\x98\x9b\x35\x18\xe4\xf9\x0b\x0c\xaa\x17\xcd\x53\x93\x4f\xce\xf6\x34\xcb\xe8\x70\xf2\x12\xb7\xe8\xa5\x3b\x59\xd1\x37\x8b\xab\xd9\x10\x51\x83\xdc\x75\xab\x3a\x07\x82\xfb\x00\x93\xfb\x2c\xf4\xf4\x82\x47\x81\xb8\xe8\x40\x0d\xfb\xf8\x62\xfa\x9c\x78\x66\xff\xfc\xfd\x77\xc2\x3a\x69\x32\x54\x17\x3b\x17\xd8\x3b\x43\x0a\x2f\x39\xd5\x7b\x5c\x75\x6a\x6c\x56\x34\x60\x66\x49\x6e\x0d\x72\x87\xb8\x2a\xdb\x1b\x44\xf4\xf4\x16\xae\xb4\x8e\xfa\x68\x63\x68\x9c\x34\x14\x5c\xe3\xb4\x18\xbf\x71\xff\xdb\x9a\xbd\xb6\x35\x3b\x1a\x79\x8b\x76\x34\x5a\xb8\x6a\xfd\x1a\xde\xf9\x75\x03\xab\x16\x2d\x28\xbe\xd8\x85\x1b\xb0\xba\x85\xab\xab\x2e\xb7\x3c\x46\xa3\x35\xd7\xc7\xbd\xaf\x3a\xbe\xe9\xf6\x63\xf7\xf1\xf4\x17\xd8\x21\x2b\x03\x75\xdd\x2f\x80\xd6\xae\x58\x05\xf3\x47\x85\xa6\xdb\x4e\xb8\x40\xf4\x02\x1a\xd0\xe4\x88\xff\x56\x9d\x89\x78\xb7\x1c\xbe\xae\x19\x0f\xd0\xc6\x75\x83\xa7\xec\xf3\x84\xd3\x9f\x40\x4e\x59\x49\x9b\x07\x37\xb2\x37\x76\xbb\xe4\x98\x9e\xb1\x08\x93\xf0\x69\x7f\x23\xe5\x5f\x34\x14\xd3\xbc\xeb\x51\xde\xe1\x68\x10\x8a\x41\x77\x4a\xd3\x8c\x25\xdd\x34\x19\x76\xdf\xb8\xcf\xf5\xff\xa4\x7e\x76\xdc\xf7\x34\x08\x78\x34\x86\xcc\x90\x8e\x58\x55\xf5\x3e\xa6\x49\xca\x0e\x23\xfc\x82\xb1\xa5\x3a\xb1\x53\x43\x6e\x71\xbb\x6d\x02\x01\x54\xb1\xe7\x2f\x04\xb9\x60\x64\x42\xcf\x19\xa1\xca\x9b\x8b\x0c\x68\xf2\x83\x6d\x74\x20\x82\xf9\x61\xaa\xd3\xb0\xf2\x68\xec\x34\xbb\xa4\x59\x70\x84\x11\x2b\x11\xfe\x82\x47\x1a\xde\xac\x18\xcf\x8c\x16\xcd\x36\xd5\xac\x82\xeb\x35\x1d\x0e\x21\x89\x4d\x2c\x32\x16\x41\x52\x9b\x48\x44\xe4\x37\x96\x08\x32\xa5\xc9\x98\x9b\x20\x6a\xb2\xaf\x1d\xd5\x0e\x46\x4f\x79\xa6\x6f\x38\x63\x96\x1d\x88\x69\x3c\xcb\x58\x00\xef\x0b\xd9\x52\x47\xc2\x9b\x8e\x21\xaa\xd7\x6c\x24\xd7\xa1\x99\x49\x9c\x44\x74\x1e\x82\xfd\xe9\xdf\x72\x0f\x6a\x36\x10\x7a\x07\x53\x10\xab\x29\x75\xf1\xe0\x7c\x2f\x8f\x48\x65\x25\x56\x98\x2c\x49\x9d\x5e\xdd\x25\xba\xcf\x9d\x61\xc8\xc1\xc4\x3f\xc8\x26\xe4\xae\xd7\xe2\xdf\xe5\x80\x3b\x3c\x8a\x58\x02\x9f\x35\xa1\x75\x82\x46\xca\x23\x96\x90\x74\x22\x66\x61\x00\x21\xe6\x20\x12\x4b\xe0\x87\xa1\xc3\x18\x72\x8a\x28\x07\xa6\xd6\x33\x92\x3b\xe6\xc9\x0f\x7a\x7a\xcd\x09\x29\xbb\xa7\xec\xfd\xb4\x23\x29\xbc\x12\x95\x73\x22\x6c\x73\xa8\x36\x03\xd7\x08\x74\xb6\xeb\x86\x74\xce\x92\x14\xbc\x04\x8f\xf8\x34\x0e\xf9\x88\xb3\xa0\x4d\x06\xb3\x8c\xf0\x28\x8d\xd1\x55\x7e\x4e\xbc\x95\xd3\x48\x89\xbb\x54\x50\x79\xa1\xfc\x05\xff\x09\x6b\x3d\xa2\x21\xf9\x98\x62\x55\xeb\x23\x9b\x09\xc2\xa2\x54\x1e\xf8\xe8\x38\x89\x86\xb0\x4e\xff\xd0\xf3\xcf\xfa\x22\x80\x0e\xc7\x6d\xca\x95\x3b\xa3\xd3\xd9\xf5\x98\x48\x6a\x19\x87\x44\xfa\xb7\xa1\x3b\xed\x09\x1b\x75\x4c\x81\x06\xcb\x43\xb8\x55\x72\x4d\x15\x48\xd9\xcb\xd5\xf0\x9a\x9e\xf0\x80\x1d\x71\xf0\x40\x7d\x2b\x02\x34\x5e\x92\x3d\xc8\x97\x9b\xc8\x72\xe5\xf0\x25\x78\x72\xdd\x02\x79\x41\xaf\x1c\x18\x16\xc1\x86\xe6\xd1\x76\x42\x6e\x2b\xbd\x75\x9b\x34\xfe\x37\xf2\xac\xa5\xe7\x62\x06\x0e\x3b\x53\x91\x66\xa0\x7d\x0e\xe7\x84\xc9\x8b\x06\x3a\x32\xa3\x37\x78\xc0\x9c\x48\x0d\xff\x1b\x0d\x12\x71\x91\xb2\x04\xfc\xe9\x29\x19\x4e\x68\x34\x64\x92\xaf\x24\x7f\x62\x06\xd6\xbf\xcb\x75\xf0\x8f\xce\xff\x46\xef\x43\x46\x53\x89\xfd\x1c\xa3\x3c\xf0\xa9\xbc\xdd\x10\x95\x28\x8c\x45\x81\x36\x9f\x36\x35\x08\xf1\xec\xa5\x6f\x39\xe2\x6e\x39\xb3\x27\xa7\xa6\x2c\x4e\xd8\xb9\xde\x98\x1d\xf5\xba\xfd\xa8\x4e\x0b\xa7\x9a\xe1\x6a\x1a\x04\x28\xb8\x76\x3d\x4e\xa1\xe0\x30\xb8\xd4\x66\x12\x69\x87\x47\x01\xbb\x7c\x37\x52\xa0\x79\xf1\xb9\x04\x95\x33\xbb\xb3\x57\xb8\xe2\xea\xef\x9e\xe4\xa8\x88\x1f\x97\xcb\x53\xfb\x35\xed\xc4\xb3\x74\x52\x6c\x2f\xcf\x1e\xb6\x41\x8c\xbb\x98\xbb\x13\xb8\xbc\x9a\x3a\x8c\xa0\x54\xef\x56\xbf\x52\x14\xf1\x79\x3d\x03\x96\x75\x46\xd7\xed\x92\x23\x79\x58\x8a\x99\x51\x7e\x98\x64\xea\x24\x85\xc3\x74\x48\x23\x92\xb0\x73\x96\x64\xb6\x8e\x76\xf8\xe2\x19\xfa\x87\xd3\x30\xd4\x14\x95\xbc\x87\xfe\xd5\xb7\x15\x7c\x8e\xac\xa6\xef\xea\x40\xd7\xcd\x79\x26\x24\xc5\x53\xda\x54\xf3\x8c\x22\xf2\x5c\x91\xbf\x52\xd8\x5a\xa7\xf6\x05\x0f\xc7\x69\xee\x8e\x07\xb3\xee\x5f\xe4\x4a\x3c\xab\x48\xa1\xf7\xde\x75\xe4\x99\xd7\x1f\xb9\x0d\xde\xcd\x35\x74\x97\x34\xe2\xcb\xc6\xd3\x5b\x5e\x5f\x20\x50\xa5\xde\x69\xcc\xc9\xf3\x7f\x33\x96\xcc\x8f\x58\xc8\x86\x99\x48\x9e\x87\x61\xb3\xd1\x99\xce\xf8\x0e\x46\xb5\x74\x7a\x64\xbc\x9f\x39\x7a\x33\x73\xf2\x77\x07\xa3\xe6\x48\xc2\xc9\x5d\x8f\xf2\xba\xf1\xdc\x00\xf2\x13\x68\x31\x9d\xf0\xd3\x9c\xab\x87\x1d\x2a\x32\xb9\x8b\xca\x03\xf5\x90\x54\x4c\x9c\xfb\xb3\x6a\xd6\x34\xbe\xab\xbc\x21\x46\x15\x4f\x91\x67\x26\x2e\x67\x99\xaf\xb6\xbb\xa8\xaf\xbc\xed\x44\x79\x2b\x5c\xcb\x8e\xf2\x6c\xd5\x1d\x25\xed\xa4\x71\xc8\x87\xcc\xa0\x68\x93\xbd\x02\x66\x6f\x45\xef\x5a\xec\x35\x53\xe1\x2e\xc4\xa7\x15\xe0\xf5\xfc\xec\x99\x80\x6d\xc2\xb6\x6b\x33\xed\x32\xac\xe4\xf6\x99\x93\xbb\x64\xef\x34\xc7\x41\x86\x6f\x72\x5b\x53\xc1\xed\xb0\xe4\xd0\xb1\x7b\x54\xf5\x16\x5e\xb5\x89\xa7\x13\x71\xb1\xc2\x26\x6e\xbc\x85\x88\x91\xdc\x54\xb7\xd9\xed\xa2\xf5\xca\x05\x97\xc7\x33\x3d\x63\x04\xee\x84\xe0\xc9\xc4\x2e\x33\x92\x89\xd8\x06\xc0\xd0\x16\xe9\x99\x20\x94\x1c\x7d\xa8\x3d\x79\xa8\xf9\xd3\xf8\x67\x21\x03\x9e\xf8\x7c\xb8\x43\xf6\x4e\xab\xce\xa1\x85\xeb\xcd\x51\xe3\x7a\x6b\x4e\x55\xbc\x7d\xdb\x6f\x4b\xeb\xb7\xcb\xfa\x00\x0b\x62\x8a\xa6\x2a\xaa\x99\x92\xe8\xc6\x9f\xe5\x8d\xa1\x27\xff\xaf\xad\x16\x7b\x4f\xfd\xb7\xed\x74\xa6\xe7\xfc\xad\x94\x5b\xee\x50\x14\xba\x0a\x29\x56\xf1\xa2\xbd\x1d\x3d\xce\xfd\x2f\x4b\x26\x5c\x9c\x88\x31\xcb\xf0\x61\xfc\xd4\x7b\xfb\x63\x59\xf1\xd5\x1f\xe9\xfc\xf8\xf0\xea\xc7\x07\x99\x32\x61\x23\x3d\x2c\x94\xff\x67\xe2\x04\x3f\xd1\xf6\x6d\xaa\xc5\x7f\x73\x06\x76\x52\x50\x16\xd3\x04\x5e\x96\x80\xa4\xa7\x0d\x59\xae\xaa\xa5\x8b\xdf\x29\x2c\xdf\x95\x48\x17\x1f\x7c\x99\x33\x4d\x5d\xd1\x91\xfd\x61\x01\xdc\xcb\x23\x79\xe6\xbe\x6f\x52\x27\xa9\x92\xb3\x39\x91\x67\xc4\xfd\xf9\x54\xbe\xb8\xc9\x05\xa3\x67\x28\xb2\xfa\xf1\xf5\xf3\x83\x9f\x5f\x1f\x1e\x1d\xcb\x3d\x11\x92\x5e\x85\x10\xbc\x80\x34\xd2\x61\xc2\x63\xb0\x2b\x87\xad\x19\x44\xb4\xb0\xcd\xa7\x3f\xf1\x80\xa2\x13\x8c\xb3\xe8\x55\x21\x04\x28\xb1\x8f\x50\x4b\x5d\x7c\xa7\xe9\xdf\x26\x4e\x37\x1d\x6b\xe7\x12\xf9\x59\xfd\x7c\xea\x73\x90\x61\x8f\x3d\xb9\x5b\x98\x1e\x9b\xf3\x5a\xd5\xea\x64\xe2\xb5\xb8\x60\xc9\x01\x4d\x59\xb3\xd5\x52\x87\xb5\x0d\xdd\x9d\xda\x19\xb1\x21\xcd\x55\x99\xbf\x83\xcf\xc0\x5a\x66\x80\xc3\xc0\x2c\xc5\xf2\xc4\xd0\xf1\x56\xa0\xa4\xf5\x54\xee\xd3\x2c\x0d\x79\x94\xed\x28\x8b\xb4\x9d\x90\x47\x8c\x44\x62\x07\x02\x6f\xed\x24\x8c\xa6\x29\x1f\x47\xb7\x88\xac\xac\x6c\x79\x71\x6b\xb0\x67\xb5\xf1\xcc\xc9\x49\xeb\x5d\x8d\x04\x34\x68\x86\x8b\x5f\x71\x74\x72\x42\xec\xdc\xc3\x17\xe7\xfe\x30\xb0\xf2\x2d\xa5\xd4\x6f\xe1\x74\xd8\xb7\x96\x61\xb1\x26\x7a\xd6\xd9\xa6\xc1\x80\xc7\xed\x89\x35\xbc\xb8\x52\x9f\xdd\x20\x14\x28\xd7\xf3\x7c\x8b\x25\xf2\x1d\x75\x67\x83\x14\xb0\x33\x86\xd7\x06\xcf\x72\xd8\x51\x88\x54\xd4\x55\x41\x67\xae\x9c\x7e\xbb\x7c\x5f\xa0\xdd\x5b\xd3\xe9\x4a\xf2\xbe\x05\x7d\x48\xf9\x8c\x2b\xce\x73\xa6\x46\xa5\x67\xd3\x73\x79\x85\x32\x4a\xcb\x44\xce\xfa\xda\x7e\x67\xb4\x89\x41\xae\x37\xb9\xfd\xed\xe1\x57\xad\x3d\x59\x9c\x1d\x6e\xab\xb9\xcc\x6e\x3e\xf5\xdc\x17\x95\x27\x0e\x83\x7b\x6d\x2f\x29\xd7\x8d\x64\xcd\xda\x6e\xd2\x9f\x2f\x29\x9d\xcd\xdb\xea\x0c\x5e\xcb\x27\x8a\x01\x24\xcb\xa4\x16\xb9\xee\x3c\x21\x3a\x99\xc7\xce\xde\x75\xa6\x08\x29\xcd\xff\xd1\xb6\xef\xab\x0f\x70\xde\x90\x71\xc2\xe6\x64\xc2\xc7\x93\x50\x62\x57\x9f\x7f\x61\x83\x33\x9e\x1d\xd3\xf8\x27\xfd\xe1\x40\x84\x22\xd1\xf9\x46\x62\x1a\xb2\x2c\x63\x9d\xa1\x98\x4e\x45\x84\xc9\xe4\xf1\x6a\xaa\xf1\x0f\xe8\xf0\x6c\x9c\x88\x59\x14\xd4\x55\x04\xcc\x3f\x86\xd4\x5a\x1c\x5a\x7f\x19\x5d\xc5\x4d\x62\x8a\x6f\x90\x66\x43\xc4\x74\xc8\xb3\x79\xa3\x65\xe7\x2b\x0c\x0f\x26\x34\x1a\xb3\x1e\x31\x5f\xf5\x47\xf5\x3b\x97\xfd\xc4\xf1\x65\xff\xbc\x52\xa7\x9d\xd1\xba\x96\x82\xd7\x91\x1d\xe5\xc0\x04\xdf\x0f\x30\xd6\x24\x8f\xd2\x8c\x46\x43\xd6\x46\xf9\x75\x14\xb0\x84\x50\x02\xdd\x81\x8f\x3c\xc0\x37\x31\x3d\xa7\x19\x4d\x36\xcf\xc6\xf0\x56\x3f\x56\xd6\x09\x14\xfb\x16\x9f\x34\xd7\x11\x1a\x16\x6e\x0c\x5f\x7f\x12\x86\xd5\x72\xaa\xf0\xa5\x72\xa9\x00\xa3\x69\xe5\x9d\xea\x26\xd9\x21\x46\xa5\xe6\xc5\x5b\x75\x14\x65\xc6\x8b\x26\xb6\x71\xd6\x8c\xeb\x23\x7a\xca\xa3\xb9\x6a\xde\x4f\xde\xfa\xc8\xab\xef\xbe\x87\xbc\xeb\x1d\xef\x00\xb8\xbe\xf1\xdc\x89\x19\x80\x20\x3c\x1f\x29\x60\x45\xb7\x69\x34\x6c\x26\x27\x4b\x39\x26\x9b\xc6\x8c\xff\xaf\xeb\xfe\x08\x6e\xd4\xba\xe5\x25\x5c\xb6\x96\xf7\xd3\xb2\x83\xb4\x33\xd0\x72\x53\x5d\xbb\x12\x98\x25\x7c\xd3\x1c\xaf\xb4\x65\x12\x97\x7b\x03\x6c\x13\xef\x39\xd1\x53\x4f\x91\x7c\x84\x10\x27\x7b\x3f\x5e\xa9\x35\xd7\x80\x31\x32\x2c\x52\xa4\xe1\x72\x7a\x3f\xa5\x7f\xfd\xbc\xf4\x22\x74\x82\x1d\xb7\xff\x2c\xdb\xd8\xad\xab\x45\x4c\x83\x01\x4d\x1d\xfe\xad\x9d\xa3\xd6\x2a\xe8\xd4\x1a\xa8\xdd\xb3\x96\x45\xc8\x9d\xe8\x01\x35\x1b\x54\x0b\xc2\xa4\x8e\x5a\xca\xce\xc0\x70\x50\x89\x0f\x1d\xcf\xf9\xbb\x6d\x60\x7b\x6e\xcd\xcd\x4d\x00\x05\x72\xd5\x6a\x3a\x99\x1d\xb7\x21\xac\x7c\xf4\x55\x3f\x31\xbf\x65\xad\xfe\x96\xb5\xfa\x2f\x9a\xb5\xfa\xeb\x34\xf2\xfe\x22\x5f\xc3\x9b\xa6\x83\xd4\x61\x10\x33\x41\x62\x4c\xbb\xcb\x23\x22\x12\xf9\xd4\x91\x97\x7d\x4c\x01\x83\xd1\xeb\xc1\xa0\x43\x12\x0e\x04\xa6\x7f\xe6\xd7\x8e\x79\x39\xf8\xc9\xdb\x20\xd1\xd7\x80\x11\xed\x4d\xca\x23\x95\x3f\xc0\xa4\x73\x83\xac\x15\x10\x74\x61\xd1\x1b\x62\xe9\x27\x84\x24\xb2\x49\x88\xbc\x6e\x98\x7d\x44\xb0\x30\xce\x3e\x82\x6d\x2d\xd0\xbe\x4d\xc6\x4c\xfe\xec\x91\xf6\x71\xa8\xab\x84\xda\x57\x93\xb3\x46\xac\x7d\xe5\x47\x3f\x37\x4e\xf7\x37\x10\x61\x5f\x33\x54\x79\x88\xfd\x0d\x82\xd7\x77\xbb\xe4\x68\x16\x83\x1d\x20\x1c\x1b\xff\xdc\x7b\xd0\xb9\x6c\x9b\xa5\x87\x6a\x9a\x80\xd0\x0c\xd3\x8e\xc4\x82\x7b\x91\x70\x6e\x97\x38\xcb\xe3\x08\xd4\xfc\xe6\x23\x49\xa3\x58\x47\x85\x32\xd9\x6a\x94\xf5\xaf\x6e\x8c\x1b\x07\x54\x87\xc6\x67\x51\x49\xf3\x25\xcd\xea\x80\x32\x15\x4d\x39\xf1\x66\x8a\x91\xf5\x81\xf9\x4b\x82\x84\xe3\x92\x30\xe6\x44\xfe\xab\x1e\x1e\xf4\xc5\xc0\xe1\x73\x96\xe4\xb4\x88\x01\xcd\xe8\xce\x74\xc6\x77\xf0\x80\xf4\x35\x89\xb6\x2b\xbe\x99\xb7\x8d\x64\x9e\xeb\x1a\x21\x1e\xa0\x5c\xe9\x2c\x0a\x20\x02\x43\xd3\xa9\x51\x63\xa0\xa6\xb6\x2c\x0b\x5c\x39\xa7\xde\xdc\x57\x4c\x6c\x8e\x3e\xcb\xcc\xae\xeb\x00\xef\xf4\xeb\x06\xd9\xba\x04\x74\x86\xec\x67\x8e\xb6\xe7\x99\x89\xc4\x9d\x9b\x52\x2f\xf4\x93\x47\x0c\xb7\x09\x9f\x4a\xd8\xf9\x4a\x2a\x79\xc1\xfe\xdd\xad\x78\x41\xbc\xd4\x3a\xc2\x94\x93\x65\x89\x10\xc1\x85\xe8\x9b\xa5\xc1\x37\x21\xc1\xbe\x81\x90\xbf\xfc\xe8\x7c\xb2\xc4\x9d\x8f\x6e\x97\xfc\x38\x87\xac\x0c\x68\xfa\xcd\x53\x32\x65\xd9\x44\xc8\x6b\x50\xe9\x8e\x4e\xa3\xc0\xad\x5c\xb6\x23\xb6\xc9\x5c\xcc\x1a\x09\x23\x6c\x34\x62\x10\x1a\x25\x9c\xdb\x3c\x59\x94\x7c\x77\x21\x92\xe9\x44\x84\xec\x3b\x92\x4d\x68\xe6\xa2\x1b\xcd\xa2\x88\x85\x29\x81\x0b\x4d\x23\x25\x13\xce\x12\x9a\x0c\x27\x7c\x48\x43\x32\x03\xfc\x29\xc9\x26\x89\x98\x8d\x27\x68\x9a\xa6\x6f\xae\x44\x44\x84\x46\x2e\x2e\x16\x65\x3c\x91\x4d\x07\x7c\x34\x62\x70\xcd\x8d\x69\x92\xb9\x79\x9b\x3a\x06\x5e\x12\x00\x28\x6c\x72\x27\xaf\x1a\x7d\xaf\x82\x7d\xd3\x8c\x0e\x42\xd6\x47\xb2\x1f\xcd\x06\x59\xc2\xd8\x61\x94\x09\xe3\x98\xa0\xae\x18\x6e\xe3\x2a\x0c\x95\xdd\x1c\xab\x63\xa3\x55\x6f\xc6\xb5\x49\x1e\x56\x8e\xea\xbb\x20\x76\xef\x92\xa1\x61\x3d\xee\xdc\xd7\xec\xb9\xc1\x3e\xb3\xe6\x46\x53\x17\x6d\xb2\xdb\x25\x07\x54\xf9\x09\xe1\x5c\xb0\x40\x39\x09\xed\xa4\x26\x65\xc9\xc2\xc4\x1c\x65\x8b\x2d\x27\x98\xae\xec\x6a\xd3\x1a\xef\x54\x31\x82\x17\x4d\xbe\x9e\x09\x6e\x55\x8c\xb9\x18\xbd\x0b\x5b\x5f\x18\xbe\x4b\xdd\x82\x4b\x64\x8f\xf8\x48\x32\x62\x47\x05\xb8\x8e\x98\xfb\xf3\x9f\xe7\x09\xba\xd4\xdb\x51\x09\x76\x8b\x72\x5a\x4d\x93\x6d\x48\x5a\x1f\x7f\x99\xc6\x8a\x31\x4d\x53\x7e\xce\xde\xc5\x2a\xa8\xb6\x9d\x14\xe3\x3e\xee\x94\x3a\x0e\xea\x4e\x69\x89\x27\xbc\x5b\x27\xe7\x81\xef\x7c\x1a\xd2\xe8\x63\xca\x50\x90\x55\xb0\x0e\xf2\xc7\x56\xe9\x85\xfb\xa4\xce\xe2\x67\x29\x0b\x9e\x9b\x72\xe3\x3d\x74\x5c\x0d\x4b\xfc\x78\x47\x74\xc8\x06\x42\x9c\x75\x47\x83\xff\xf8\x6e\xbb\x72\xcc\x74\xcc\x52\xfc\x92\x26\xc3\xee\x50\x24\xac\xfb\xf2\x92\x0d\x67\x10\xcb\x27\x3a\xe7\x89\x88\xe0\xaa\xf5\x9f\x14\x26\xc3\x9d\xd9\xb2\xd9\xbe\x7d\xbb\xa9\xd6\xb9\x32\xe8\x85\x38\x5b\x86\x06\x0d\x39\xbc\x9c\xef\x65\x49\x91\xff\x1c\xd0\x84\xa8\x21\x78\xc9\x27\xdb\xab\x3b\x77\x48\x23\x0f\xd0\x90\x57\xa3\x0b\x65\xad\x2c\x91\xd7\xf3\x5a\xf9\x57\xbf\x89\x12\x18\xaf\x15\x20\xd5\xcb\xc7\x77\xf5\x09\x89\x63\x2a\x65\x7c\xbf\x34\x37\x12\xfb\xad\x30\x88\xf2\xc5\xe5\x97\xfa\xd8\x9c\x6f\x85\xce\xbe\xc7\x25\x4c\x04\xac\xe1\x74\x09\x56\x7b\x23\x02\x96\x44\xfc\xb7\xc4\xf9\xcb\x65\x38\x95\xc0\x74\x27\x60\x19\x1b\x66\x69\x37\x10\xd3\xae\xda\x28\x20\x86\x44\xa8\xe6\x2d\xd5\xec\x56\xb5\x8b\xe4\xcb\xf3\xc1\x3a\x90\x55\x87\x13\x2f\x0e\x61\x21\xf0\x85\x6b\x46\x8b\xd0\xda\xdf\xb2\xe0\xc5\x03\x9f\x0b\x71\xc5\x52\xa4\x64\xfa\x3e\xdf\x1d\x34\x3f\x07\xb8\x2c\x99\x1b\x64\x8a\xcd\x0b\x71\x79\x1a\x19\x4b\xb3\x46\x5b\x49\x88\x4a\x74\x8e\xfb\xbe\x22\xbd\xa1\xc6\xdf\x70\x63\x98\x8e\x59\xe6\x3f\xca\x9b\xfe\xb5\xa5\xaa\xb3\x6e\x12\x42\xe7\x49\xab\xaf\x29\x57\x64\x48\xb3\xe1\x04\x23\xf1\x5c\xd5\xd8\x35\xb3\x69\x9c\xcd\x71\xcc\x7a\xea\x4b\x9b\x7c\xea\x49\xf7\x2a\x40\x74\xd8\x10\xf9\x7f\xf9\x13\xef\xc9\x97\x75\xe2\xad\x70\xaa\xec\x39\x1a\x94\x4d\x4e\x95\xe2\x0d\xc3\x87\xb9\xa1\x83\x47\xb9\x0a\x98\xa6\x72\x73\x28\xda\x24\x6e\xcb\x1d\x2e\xf1\x0c\xfd\xea\xd9\xdb\xa9\x54\x62\xba\x7c\x6f\x77\x23\xda\xc3\x46\x2f\x44\x95\x4e\xee\xde\x93\x96\x15\xff\xff\x8b\x65\x98\xf4\x37\xe3\x53\x96\x66\x74\x1a\x9b\x8c\x51\xb3\xe9\x80\x25\xf2\xd7\x94\x87\x21\x4f\xd9\x50\x44\x90\x20\x98\x66\x18\x92\x82\x85\x34\x4e\xe5\x83\x83\x47\x43\x26\x71\xc9\x5a\x1f\x23\x7e\x49\x58\x2c\xe4\x52\xda\x23\xff\x4d\xa3\x19\x4d\xe6\x64\xef\xc9\xa3\x5d\xb2\xbb\xdb\x83\xff\x91\x8f\xc7\x07\x2d\x9d\x3b\xf8\x9f\x69\x46\x33\x3e\x84\x3f\xa7\x4c\xb6\xf8\x6e\x44\xfa\xf8\x45\xe2\x25\xfb\x9d\xfb\x9d\x5d\xf8\x3d\xa4\x19\x1b\x8b\x64\x4e\x5e\xd0\x0c\xda\xfb\x27\x4e\x75\x4a\x3e\x63\x5f\xaf\xc8\x07\x55\xe0\x0d\x08\x02\x17\xfc\x93\x5d\xd2\x69\x1c\x32\xd5\x6c\x5f\x92\x82\x25\x76\x72\x01\x12\x08\xf8\x3d\xfa\x11\xa6\x22\x64\x9d\x50\x8c\x9b\xfd\x4e\x04\xd9\xf6\x76\x08\xc2\x3c\x95\x20\x57\x6d\xa2\xca\xf1\x77\xb7\x4b\x9e\xfd\x83\xbc\x16\xe3\xb4\x6e\xee\x78\x46\x32\x21\xce\x4c\xda\x49\xe8\x43\x02\x7a\x9c\x73\x31\x84\x98\xc0\x56\xe5\x12\x81\x13\x9f\xe9\xa0\xc7\x5c\x92\xba\x1d\x39\x0d\xd8\x07\xb4\x3e\x2c\x38\x01\x45\x98\xa8\x28\xc7\x5b\x9b\x05\xca\x93\x3d\x3b\x9a\x4f\x07\x22\xac\x52\xdc\xdf\x53\xdc\x85\xc1\x1d\xe4\x50\x07\x33\x1e\x66\x3b\x3c\xd2\xe2\x9a\x84\x81\x8c\x63\xc8\xd2\x8e\x1e\x2c\x9a\xb6\x80\x5e\x82\x3c\x23\x6a\xb3\x8a\xb5\x9a\xc2\x45\x98\x09\xcc\x3f\xa9\xaa\xa4\xd0\x82\xb8\x88\x54\xbc\x88\x8c\x3b\x58\xfd\x20\xf4\xe4\x99\xdb\x4c\x2e\x42\xbd\x5d\x11\xba\x95\x84\xa5\x22\xc4\xb8\x00\xb2\xf8\xe4\x53\x26\x8e\xc0\x5e\xe6\x98\x8e\x3f\x61\xea\xea\x5e\xb7\xcb\x86\x53\xba\xa3\x34\x67\x72\x26\x69\xd8\x11\xc9\x18\x8b\xf7\x1f\xee\x77\x1f\x75\x76\xbb\xff\x2f\x65\xc3\x1d\x91\x1b\x53\x27\x13\xca\xfc\x46\x62\x17\x23\xdc\x70\x53\x87\xfe\x34\x93\x27\x05\x54\x3b\x56\x4d\xe7\x86\xa0\x7b\xa4\xe6\xe7\x47\x3d\xcf\x80\xaa\x6c\x9a\xd3\xf9\xf4\xd8\x8e\x82\x3c\xd3\xa4\xfc\x41\xfd\xd1\x71\xc6\x48\x7a\xde\xa3\x42\xcd\xce\x73\x92\xc6\x6c\xc8\x69\xc8\x7f\x63\x01\x39\x67\x49\x8a\xe1\xc6\xc8\xa7\x01\x4d\xd9\xbf\x58\x26\x67\x87\x5c\x4c\xf8\x70\xa2\x62\x81\xa6\xe4\x53\x11\xf9\x27\x67\xb8\xb0\x3c\xe3\x84\x9f\xeb\x65\xad\x72\xf6\x7f\x7f\xa5\x06\x72\x3c\x61\xea\xaf\x4c\x10\xf0\xc8\xed\xf8\xcb\x1f\x27\xd2\x5f\xfe\x09\xbd\x20\x1e\xc9\x72\xf6\x90\x63\x96\x7d\xa0\x17\xc7\x74\xdc\x04\xd4\xf6\x42\xc5\x25\x5b\x90\x67\x39\xe6\xc1\x77\x2b\x80\xb6\x73\xd3\xd8\x72\x3c\xb9\xc8\x33\xec\xe9\x89\x0f\x82\xae\xc6\xf6\x8e\x54\x0a\x53\x74\xd9\x95\xdd\x99\x45\x53\x9a\x9e\x79\x79\x94\xfd\xbb\x8a\x36\x68\x4c\x58\x8a\x87\x64\x19\xe3\x38\xdd\x87\x0b\x8f\xbc\x0b\x6a\xcc\xee\xfd\x10\x06\xef\xca\xd3\xca\xfb\x99\xd1\xb1\xbe\x36\x79\x42\xbe\x80\x85\x2c\x63\x55\x53\x60\x24\x39\xce\x46\x06\x9d\x86\x23\xb0\xb0\x7d\x19\x0a\x95\x6c\x62\xcb\x44\x0e\x84\xfd\x6a\x1b\x1b\xd1\x57\xbd\x4b\x48\x3c\x07\x22\x3a\x67\x72\x92\x3f\x01\xba\x4f\x28\x9e\xc6\x86\xc8\x2c\x95\xff\xff\x29\x3f\x74\x83\xe6\xd3\xea\x6b\x76\x88\xed\x2d\xb1\x6a\x15\xa4\xbc\x55\x20\xdf\xfa\x8b\x56\x78\xe3\x74\x57\xae\x16\x19\x2e\xe4\xfd\x32\x4e\xf3\xd1\x96\xb0\xdb\xd7\x1d\x88\x6f\xb1\x2b\xd9\x5f\xdc\xdb\x6b\xab\x9e\x74\x7f\x0a\x57\xb2\x2d\x06\x71\xfc\x0b\xb9\xa9\x29\x49\x9f\xf6\x06\xdf\xc8\x3e\xcf\xc5\xb5\x35\xa7\x35\xa8\x38\xa1\x81\xb8\x70\x12\x63\xa1\x57\x94\x2a\x2e\xc9\xcf\x84\x5f\xda\x04\x9c\xb5\xf5\x5d\x42\x81\x9f\x34\xf0\x8f\x06\xb9\x8b\xdf\x4f\x9d\xd4\x68\x03\x71\x79\x04\x5f\x7b\x0a\x1c\x6f\x0c\xda\xc3\x37\xf7\xb6\xae\x4a\xc7\xe3\xfb\xd6\x2d\xf0\xe9\xb2\x9f\x3b\x31\x8d\x59\x82\x2d\xb6\x15\x22\xb9\x4f\x06\x0e\x2e\xb0\x4a\xfc\x40\x03\x3e\x4b\x7b\x64\xdf\x55\x59\xaa\xe1\xb5\xae\xc7\x0f\xec\x6b\xf4\x75\x42\x53\x4e\x9d\xd9\x74\xa6\xaf\x5c\x70\x15\x17\x22\x73\x4c\x36\xc9\x4b\x0e\xde\x3e\xe6\xc6\x91\x09\x09\xaf\x14\xe4\x4c\x29\xb5\x85\x04\x70\x2d\x11\x75\xef\x6c\xbe\x9d\xd5\x54\x6d\xde\xe2\x5b\x53\xe3\xe6\xe2\xb8\x1e\xc5\x9b\x83\x31\x67\x02\x8a\x4b\x81\x04\x2c\xce\x26\x6d\x32\x14\x49\xc2\xd2\x18\x45\x30\x82\x7c\x0a\xe2\x4f\x84\xab\xa8\x90\x31\x1b\xaa\x99\xc5\x8c\x6d\x90\x41\x5c\x4e\x2c\x5e\x16\xc9\x80\x65\x17\x8c\x45\x64\x97\xd0\x28\x20\xfb\xf7\x09\x8f\x86\xe1\x2c\xe5\xe7\x8e\x0d\x2d\x0b\xd9\xb9\x4a\x4a\x54\x31\x2c\x94\x69\x54\x3a\xb8\xa9\xd5\x22\x3b\x1a\xb1\x04\x23\xa7\x29\xd9\x69\x60\x9b\x49\xff\x6f\x46\x93\x65\x1c\xdc\xac\x45\xa8\x5c\x96\x05\xa7\xb5\x25\x7d\xd2\x54\x62\xd5\x0a\xbf\x34\xa3\x29\xf6\xc1\xf2\x29\x78\xb1\xcf\xe6\x3b\xfe\xd4\x1f\xcd\xbc\x99\xef\xa6\x64\x63\xdf\xb6\x0a\x7f\xb6\xa1\x9b\x0d\x14\x7b\x23\xff\x32\xed\x1a\x37\xb7\x0d\xe3\x33\xda\xa1\xfd\xe3\x19\x06\xcc\xb4\x25\x7f\x27\xfb\x0f\x8a\x99\xed\x79\xea\x80\x7c\x82\x98\xd9\xe6\xe7\x5d\xd2\xf8\x44\x38\xe6\xb8\xe7\xd3\x18\xd9\x9e\x05\x9d\xb2\x70\x8a\xae\x4f\xe1\x4a\xa9\xd4\x98\x77\xc0\xe4\x47\xf0\x83\xd3\x9d\x1e\xd9\x6d\x9d\xae\xe2\xcd\xa7\xf8\xbb\x4d\x6e\xe3\x94\xbb\x9e\x7c\xef\xd1\xc3\x68\x59\x6f\x3e\x8f\xef\xda\x4b\x39\xf3\xd9\x19\x31\x1e\x7b\xf8\x96\x81\xe5\xf1\x07\x79\xe7\x7d\x21\x3b\xb1\xd3\xad\x8d\xeb\xf7\xbe\x8c\x93\x20\x37\xd3\xcb\x6e\xce\xb9\x6a\x4b\x6c\xb6\x4e\x8d\x3f\x8d\x9f\xa2\xbb\x3f\xfe\xd9\xae\x08\xcb\xce\x81\x3d\x0c\x2a\x27\x15\x59\x66\x59\x84\xe6\x9c\x59\xde\xf3\x13\xb7\xa6\x12\xd3\x2b\x67\xe3\x30\x3e\xcd\x0e\x8b\xef\xbb\xbc\x7b\x7d\x7e\xa1\xd0\x1d\x70\x0a\x85\xbf\xb6\xe3\x11\x7a\xaf\x36\x7c\x9d\xc5\xa2\x10\xf7\xfb\xcb\x4a\x8d\xca\x85\x40\xa5\x08\x73\x02\x21\x57\x1c\x04\xef\xa8\xee\xf7\x64\x42\x93\xa9\x88\xe6\x3a\xde\xf1\xf7\x5d\xb4\x9c\xec\xab\xe9\xe8\x1f\xbe\x79\xff\xee\xc3\xf1\xcb\x17\xfd\x37\xef\x5e\x7c\x7c\xfd\xb2\xbf\xdb\xef\x3f\x8f\xe3\x1f\x69\xd2\xef\x57\x66\x10\xb8\xbf\x31\xea\xbe\x25\x6d\x49\x13\x9d\xa8\xb9\x14\x16\xbf\x1b\x09\xc3\x99\x21\x4d\x8d\x1c\x12\x01\x44\x22\xda\x99\xd0\xa9\x48\xe6\x2d\xd9\xc5\xb2\xe6\x82\x8a\xd9\xc5\x76\xbe\x6b\x7b\xaa\x39\x73\xf0\xaf\x32\xce\x0e\x7d\xba\x2e\x41\xf6\xfa\xfd\xe7\x10\xf3\xa3\x92\x20\x0f\xee\x3d\xdc\x18\xf5\x06\x04\x71\xb0\x6c\x9d\x20\xd0\xce\xca\x04\x29\x19\xe7\x06\x04\xd9\xef\xf7\x7f\xa4\xc1\x98\xd5\xd0\xe3\xd1\xa6\x98\x37\x20\x87\x45\xb2\x6d\x6a\x40\x33\x2b\x13\xa3\x38\xc8\x0d\x68\x71\xaf\xdf\xff\x51\x64\x99\x98\xbe\xa5\xe7\x7c\x0c\xa7\x4a\x0d\x59\x9e\x5c\x63\x23\x1b\x50\xa8\x14\xdf\xd6\x89\x95\x6b\x71\x65\xba\xd5\xce\x42\x09\x09\xed\x10\x06\x3c\x0a\xe4\xa5\x4e\x76\x99\x8f\x9a\x65\xbd\x16\xab\x4e\x57\xc9\x88\x7e\x9c\x65\x99\x88\xbe\x6b\xb5\x36\x9a\x17\x85\xe5\x5a\x66\xe7\xa4\x0a\xfb\xe9\xda\x0c\x7f\xbf\xdf\x47\x1c\x35\xc7\xf3\x9a\xbb\x8f\x83\x7a\x03\xe6\x76\xb0\x6c\x9d\xa5\xd7\x23\x55\xc9\x38\x37\xd8\x81\x1e\x68\x6c\x3f\xd2\xb4\xfa\x48\xb8\xff\xe0\x5a\xb0\x6f\x40\x97\x1c\xa6\x9b\xa1\x8d\x6c\x6b\x65\xfa\x54\x8c\x79\x03\x1a\x3d\xec\xf7\x0f\x68\x12\x54\x9f\x0c\x0f\xd6\x24\x8f\x41\xbc\x01\x61\x0c\x8e\x6d\x93\x44\xb6\xb2\x32\x31\x0a\x23\xdc\xe6\x4e\x6f\x1a\x53\xbd\x7d\x0e\x1d\x4d\x57\xdd\xd2\xdd\xaa\x6b\x8f\xf7\xc4\x43\x53\xdc\xb0\xb7\x36\x68\x95\x9b\x7c\x9d\x41\xeb\xaa\x1b\x0e\x5a\xa3\xb9\xc1\x41\xff\xc4\x68\xc0\x92\x75\xc6\xac\x6a\x6e\x38\x64\x85\xe5\x06\x47\xfc\x86\x05\x9c\xae\x33\x60\xac\xb8\xe1\x78\x11\xc9\xfa\xd7\x90\x47\xfd\x3e\x84\xdd\x18\x88\xcb\xea\x5d\xf5\xe1\xde\x35\x20\xdf\x60\x67\xf5\xf0\x6c\x7d\x77\x55\x2d\xad\x4c\x99\xd2\xd1\x6e\x70\xd8\x3d\x96\xf8\x78\x5c\x4d\x96\x47\x6b\x92\xc5\x20\xde\x80\x24\x06\xc7\xf6\xc9\xc1\xe3\x95\x49\x51\x18\xe1\x06\x64\x78\xd2\xef\xcf\x32\x1e\xa6\x7d\x48\x44\xff\xfc\x82\xce\xb5\x73\x4c\xf5\xcd\xfd\xc9\xee\xf5\xb7\xb5\x01\xb1\xea\xd0\x6e\x9d\x7e\xf9\x26\x57\x26\xe6\x32\x93\xb2\x89\x58\x6e\xb7\xdf\x7f\xc1\x69\x28\xc6\x35\x2b\x6d\x4d\x41\xa9\x8b\x7b\x13\xc1\x9c\x83\x66\xdb\xf4\xc2\x76\x56\x97\xcc\x95\x8c\x74\x9b\x37\x4c\xb7\x3d\xd3\xeb\x35\xaf\x99\x7e\xe5\x4d\x46\x7e\x92\xc3\xb5\xc5\x6b\x48\xe9\x04\xac\x79\xe5\xf4\x2b\x5f\xc7\x04\xdc\xc0\xcd\xb3\x6e\x02\x8e\xd9\xe5\x66\x93\x00\x08\xae\x71\x22\x00\xdf\x4d\x4f\xc6\x31\xcf\x42\xb6\xde\x34\x60\xd5\xeb\x98\x00\xc4\x74\x73\x43\xbf\xe0\xd9\xe4\x8d\x18\xf0\x90\xa9\x9d\x6c\xc5\xf1\x17\xea\x6f\x36\x09\x05\x74\xeb\x5f\xd5\xf7\xf6\x24\xe2\x73\x1e\xd4\xdc\x3c\x1e\x3c\x5e\xf3\x4e\xe8\x21\xdf\xe4\xa8\x72\xf1\x6c\xff\xac\x82\x86\x56\x27\x51\xd9\x60\x37\xb9\x42\xec\xf7\xfb\x2f\x12\x7a\x51\x77\x25\x7c\xb4\xa6\x64\xca\xc5\xbd\x09\x5d\x1c\x34\x5b\x27\x0b\xb4\xb3\x3a\x55\x4a\x46\xba\x09\x51\xee\xf5\xfb\xaf\x44\x32\xad\xb9\xa5\xaf\xbb\x56\x0c\xe6\x4d\x08\x62\x90\x6c\x6b\x5f\x34\x0d\xb4\xc9\x77\xf2\x0f\x79\x14\x25\x22\x5c\x75\x43\x74\xab\xae\x4c\x52\xd3\x87\x13\x0f\xcf\x36\x8f\x83\xfc\xb0\xff\x95\x88\x59\xbc\xce\xa0\xb1\xe2\xa6\x43\x46\x2c\x37\x39\xe0\xd7\x74\xc0\xd6\xa2\x32\x56\xdc\x74\xc0\x88\xe5\x26\x07\xfc\x13\x64\xbf\x5f\xe7\xce\x97\xab\xbd\xe9\xd0\x1d\x54\x37\x39\x7e\xb5\xaa\xd6\xa6\xbb\x57\xff\x9a\x96\x78\x15\x17\x2c\xbd\xc7\xde\xef\xf7\x31\x73\x5c\xcd\xfe\xbd\xee\x91\xea\xe0\xde\x64\x07\x77\xd0\x6c\xfb\x48\xc5\x76\x56\x27\x4e\xc9\x48\x37\x39\x52\x1f\xf4\xfb\x87\xc3\x1a\x95\xf5\x93\x75\xe5\x24\x06\xf1\x26\xf4\x30\x48\xb6\x4d\x0d\xd9\xca\xea\xb4\x28\x8c\x71\x13\x4a\x3c\x44\x64\x0b\x4c\x08\xf6\xee\xad\x29\x88\xcc\xe3\xdf\x84\x2c\x39\x54\x37\x41\x9c\x35\x0d\x0a\xaa\x46\xbd\x09\xa1\x1e\xf5\xfb\x87\x51\x3c\xcb\x6a\x68\xb4\xee\x35\xd4\xa2\xde\x84\x3c\x16\xcb\xd6\x29\x23\x9b\x59\x9d\x28\xc5\x61\x6e\x55\xb0\x68\x9b\xd3\x5d\x5e\xeb\x60\x75\x6a\x6e\x30\xe2\x13\x17\xcf\x36\xef\x14\xc5\x51\x3f\x0f\x44\x02\x01\xf6\xd6\x1a\xb9\xad\xbd\xf9\xe8\x2d\xae\x0d\xee\x13\x8f\xfb\xfd\x7f\x25\xbc\xda\x74\x64\xff\xc9\x9a\xd6\x56\x16\xf3\x26\xab\xd0\x20\xd9\xf6\x22\x94\xad\xac\x4e\x93\xc2\x18\x37\xd9\x12\x9f\xf4\xfb\xaf\x79\x5a\xb3\x23\xae\x6b\xf8\x66\x31\x6f\x42\x0a\x83\x64\xdb\xa4\x90\xad\xac\x4e\x8a\xc2\x18\xb7\xba\x1b\x9a\xd6\x54\x7f\x0f\x33\x36\x5d\x75\x43\x30\xf5\xd6\x1f\xeb\x89\x45\xb2\xcd\x5d\xb0\x6c\xb4\xca\x54\x7d\xcd\x31\xaf\x6b\xe8\x5e\x32\x72\x85\xea\xa6\xc7\x0f\x97\xdd\x35\x47\xbf\xde\x45\xb9\x64\xec\x80\xe8\xa6\x47\x7e\x04\x21\xe0\x68\x32\x47\x75\xde\xba\x93\x90\x47\x73\x1d\xf3\x91\xc7\x79\xd3\x53\xb3\x8e\xb0\xc5\xab\x7b\x1d\x93\xb0\x75\x41\x4b\x7e\xe4\x47\xb3\xc1\x64\x2d\xfb\x36\xbf\xf2\xa6\x63\xb7\x98\xd6\xbf\x0f\xed\xef\xf6\xfb\x6f\x58\x34\xab\xb9\x0f\xad\xe9\x64\x61\x31\x6f\xe2\xfb\x62\x90\x6c\xfb\x10\x96\xad\xac\xee\xfa\x52\x18\xe3\x36\x0f\x61\xdb\x9a\xea\xef\x3a\x87\xb0\xa9\xb7\xfe\x58\x4f\x2c\x92\x2d\xae\xba\xc2\x68\xe1\x9a\xb4\xc6\x68\xd7\xba\x5e\xe5\x47\x0b\x48\x36\x58\x66\x7b\xfd\xfe\x1b\x11\xd0\xb0\xfa\xb2\xbb\xbf\xae\x8f\x99\x45\xbd\xc9\x42\xb3\x58\xb6\xbe\xd2\x64\x33\xab\x13\xa4\x38\xcc\x4d\x5c\xfe\xf6\xfb\x7d\x70\x25\xae\xd6\xa0\xaf\x29\xc2\x74\x30\x6f\x42\x0e\x8b\x65\xdb\xe4\x80\x66\x56\x27\x47\x71\x98\x9b\x90\xe3\x5e\xbf\xff\x5e\xc4\xe2\xbc\x86\x20\xf7\x76\xd7\x94\x8f\x79\xc8\x37\xa1\x89\x8b\x67\xeb\x54\xc1\x86\x56\xa7\x4b\xd9\x60\x37\xa1\xcc\xfd\x7e\xff\x7d\x22\xc6\x09\x4b\xd3\x4a\xd2\x3c\xdc\x5d\x77\xef\xf2\xb0\x6f\x42\x1b\x0f\xd1\xb6\x4e\x24\xaf\x91\x36\xf9\xee\x80\x27\xc3\x59\x48\x13\x5d\xb8\xb2\xf5\x7f\xbe\xfe\xca\xd4\xf6\x7a\x74\x52\x44\xb8\xcd\xf3\x39\x3f\x1b\xaf\x79\xc4\xd6\x9f\x8b\x5c\xed\x4d\x67\x22\x87\x6e\x83\x93\xfb\x41\xbf\xff\x81\x06\x5c\x54\x73\xff\xde\x9a\xca\x15\x07\xf5\x26\xac\x6f\xb1\x6c\x7b\x53\x82\x66\x56\x27\x4d\x71\x98\x5b\xbd\x25\xdb\xe6\x74\x97\xd7\x32\xfd\x70\x6a\x6e\x30\xe2\x13\x17\xcf\x06\x5c\xf8\xb0\xdf\x3f\x62\x21\x1b\x56\x4b\x4b\xef\xed\xde\xdb\x1c\xf7\x26\x7c\xe8\xa0\xd9\x36\x23\x62\x3b\xab\xd3\xa5\x64\xa4\x9b\x9c\x8d\x8f\xfa\xfd\xa3\x88\x0e\xcf\x06\x35\xb1\x3c\x1e\xee\xad\x7b\x36\x7a\xd8\x37\x21\x8c\x87\x68\xeb\xa4\x51\x2d\xad\x4e\x9c\xd2\xf1\x6e\x75\xa7\xf0\x5a\x74\xfa\xbe\xa6\xf9\x7c\xbe\xfa\x66\x33\x70\x52\xc0\xb7\xc1\xf6\xf1\xb8\xdf\x3f\xca\x58\x5c\xf7\xe0\x79\xb8\xb7\xae\xa0\xc7\x45\xbe\x09\x9f\xba\x78\xb6\xce\xa6\xd8\xd0\xea\x34\x2a\x1b\xec\x56\x99\xd4\x6d\x50\x75\x7c\x65\xc6\x94\x75\x36\x1a\xe9\x09\xe2\xd8\xe6\x75\xb2\x64\x9c\xeb\x05\x00\x71\x6a\x5e\xc3\x98\x2b\x03\x7c\x6c\x75\xe4\xeb\xee\x40\x4e\xd5\x6b\x18\xfb\x0d\x78\xef\x94\x0d\x7e\x2d\x3b\x0b\x5b\xf1\x1a\x06\xbe\xa9\xd5\xe2\xfe\x93\x7e\x1f\xe3\xd8\xd5\x78\x68\x6c\x8e\x7a\x93\xcd\xd6\x41\xb3\x2d\xd2\x3a\x4d\xb4\xc9\x77\x6f\x66\xfc\x78\xc2\x20\xe0\x2a\x7a\x6b\xac\x2a\xca\xcd\xd7\x5f\x99\xce\x4e\x7f\x4e\x8a\xe8\xb6\xc9\xe4\xfe\x4c\xd8\xb0\x87\xeb\x38\x25\xa9\x9a\x9b\x8d\xde\x41\x74\xb3\xe3\x86\x39\x5f\x67\xd8\x58\x71\xf3\x51\x23\x9e\x9b\x1b\x34\x86\x0f\xd6\xdc\xb6\xea\xc8\x73\xb5\x37\x1b\x7e\x0e\xd9\xfa\xdb\xdb\xbd\xdd\x7e\x7f\x28\x42\x91\xd4\x88\x04\xf7\xd7\x34\xca\x76\x71\x6f\x12\x92\xcd\x41\x53\x45\x68\x0c\xed\xa9\x32\xc8\xac\x7c\x83\x44\xec\xab\xc7\x15\x73\x3a\xb6\x3e\x01\xf6\xfa\xfd\xa3\xf3\x71\xad\x0d\xf6\xda\x04\x70\x71\x6f\x42\x01\x17\xcf\xd6\xaf\xf3\xd8\xd0\xea\xd4\x28\x1b\xec\x26\xe1\x0b\xf7\xfb\xfd\xa3\x0b\x9e\x0d\x27\xd5\x2b\xe3\xfe\x9a\x7a\x0c\x17\xf7\x26\x74\x71\xd0\x6c\x9d\x2c\xd0\xce\xea\x54\x29\x19\xe9\x26\x44\xb9\xd7\xef\x1f\xd3\x41\x58\x1d\xcd\xed\xe1\xfd\x35\x65\x67\x0e\xea\x4d\x48\x62\xb1\x6c\x9b\x22\xd0\xcc\xea\x04\x29\x0e\x73\xab\x01\x22\x6d\x73\xba\xcb\x3f\x8a\x60\xbe\xea\xe1\x69\x2b\x6e\x30\xde\x13\x07\xcd\x16\x6f\x0d\x25\x43\x3e\x60\xe1\xca\xaf\x20\x5b\x71\xf3\x21\x03\x9a\x9b\x1d\xf2\x2b\x21\xb2\xd5\x5f\x06\x6e\xd5\xcd\x87\xad\x10\xdd\xec\xc0\x7f\x62\x34\x58\x6b\xd8\x50\x71\xf3\x41\x03\x9a\x9b\x1d\xf2\x7b\x3a\xe6\x98\x51\x71\xad\x81\x3b\xd5\x37\x1f\xbe\x83\xec\x66\x27\xe1\x83\xb8\x58\x6b\xf4\xb2\xde\xe6\xc3\x96\x58\x6e\x76\xbc\x47\x22\x59\xcf\x8d\x26\x57\x7b\xf3\xb1\x5b\x5c\x1b\xbc\x83\xee\x03\xd6\x9a\x57\xd0\x83\x75\xef\x15\x06\xf3\x26\xd7\x0a\x83\xe4\x06\x6e\x15\x6b\xbc\x84\x0a\x63\xdc\xea\x9d\xc2\xb4\x86\xfd\x5d\x83\x01\x37\x18\x21\x30\xdd\x26\x9c\xf6\xa0\xdf\x3f\x9e\xc7\x62\x9c\xd0\x78\x32\xaf\x8e\x4a\xbc\xa6\x25\x42\x1e\xfd\x26\x4c\x97\x43\xb5\x75\xd6\x33\x6d\xad\x4e\x9e\x8a\x51\x6f\xf2\xd4\x78\xd8\xef\x1f\xb3\xcb\xec\x15\x67\x61\xb5\x8f\xd9\xc3\x87\xeb\x6e\x0b\x3e\xfa\x4d\xc8\xe4\x63\xda\x3a\x95\x74\x53\xab\x13\xa9\x7c\xc8\x9b\xd0\xe8\x51\xbf\x7f\x2c\x44\x58\xa7\xb5\xdf\x7b\xbc\xa6\x78\xde\x43\xbe\x09\x7d\x5c\x3c\x5b\xa7\x0e\x36\xb4\x3a\x6d\xca\x06\xbb\x09\x65\x1e\x23\xbe\xac\x26\xda\xe9\xc3\x87\xeb\xca\xb5\x5c\xe4\x9b\x50\xc6\xc5\x73\x13\x94\xc9\xd6\x08\x7c\x5a\x3a\xd8\x4d\x28\x63\x82\x6f\x5e\xf0\x6c\xf2\x0b\x0f\xb2\x6a\x01\xd7\xde\xba\xe9\x84\x4a\x1b\xd9\x84\x52\x65\xf8\xb6\x4d\x31\xd3\xd4\xea\x34\xab\x1b\xbe\xa6\xdd\x82\x7f\xdd\x2e\x61\x69\xc8\xa3\x6c\x47\xe5\xef\xdc\x89\xd8\x65\xb6\x13\xf2\x88\x29\x32\x74\x47\x3c\x49\xb3\x62\x45\x3f\x15\xd6\x83\x3f\x79\xd2\xf4\xad\x66\x0d\xff\x8b\x67\x64\x87\xa4\xe9\xdd\x2e\xf9\x27\x8f\x26\x2c\xe1\x19\x0b\x4c\xd2\x4c\xcc\x08\xfb\xd5\x67\x54\xdf\x6e\xd6\x73\xa8\x38\x81\x10\x52\x95\x83\xb0\x0c\x0a\x33\x5a\xe7\xc3\xe2\x80\xd5\xf5\x41\x27\xd6\xfb\xa2\x92\xae\xbf\x15\xc1\xe6\xd9\xd6\x01\xc9\xd6\xd2\xac\xab\x79\x28\xcb\x5f\x1e\xf0\x34\x0e\xe9\xbc\x47\x1a\xa3\x90\x5d\x36\x74\x4e\x61\xf9\xe3\x05\x4f\xd8\x10\x53\x26\x36\x86\x22\x9c\x4d\x23\xf3\xf9\x42\x6e\xfc\x3d\xd2\xd8\xdb\xdd\xfd\x2f\x53\x38\x10\x97\x47\xfc\x37\x1e\x8d\x7b\xa4\x81\xa9\xcc\x77\x06\xe2\xb2\xd1\x26\xdd\x2e\x79\x9f\xb0\x73\xb9\xb6\x62\x1a\xc8\x07\x32\xe1\x69\x3a\x63\x44\xf2\x14\xa4\x98\x06\xa7\x29\xc8\x1e\x3d\xe2\x97\x2c\x20\xb1\x48\xb9\x6c\x99\x05\x04\x93\xda\x75\x54\x1b\xbf\x1d\x46\x01\xbb\xd4\x59\xd6\xf1\x57\x87\x02\x88\xdb\xf5\xa3\x49\xc2\xa3\xb3\x1e\xd9\x75\xf3\xad\x6b\xa4\xaf\x64\x13\x76\x06\x74\xb1\x9c\x02\xf9\xc5\x8c\x27\x13\x71\x8f\xec\xea\x5f\x21\x1b\x65\x3d\xd2\xa0\xb3\x4c\x18\x88\x84\x8f\x27\x59\x45\x2b\xcf\x07\xa9\x08\x67\x19\x2b\x6d\x88\xaa\x8f\xd7\xd4\xd6\x51\x46\x33\x3e\x2c\x6d\x29\x85\x4f\x8d\x85\x93\x03\xea\xde\x17\x7a\x21\xac\x9e\xdd\xde\xa7\xc1\xb0\x0c\x7a\xcc\x32\x08\xb8\x46\x53\x08\x31\xdc\x5c\x80\xab\x55\xe8\xde\xfb\x84\x4f\x69\x32\x5f\xba\x7b\x31\xc2\x9f\x3c\xd8\xdd\x3d\xdd\xa0\x67\x2e\x9a\x62\xa7\x9e\x0f\x87\x90\x69\x74\xc9\x3e\xa5\xda\x19\xbe\xf3\x7c\x7f\x77\x77\x83\x5e\xf9\x88\x54\xbf\x6e\x11\x72\xf5\x14\xb2\x99\xae\xb0\x81\x41\x3f\x2b\x76\xb0\xdd\x56\x47\x44\xec\xdd\xa8\x79\xd2\x50\x27\x65\xa3\x4d\x1a\x6a\x46\xe4\x9f\x14\x86\x2f\xff\x52\xbb\x28\x66\x07\x5f\xa1\xf9\xf7\x8a\x59\x17\xf7\x40\xf3\xb2\x59\xa8\xce\x42\x5a\xb9\x55\x27\x5f\xac\x49\x37\x7f\x3c\x61\x64\x88\xf6\x84\x44\x8c\x60\x67\x32\xb9\x64\x6d\x8e\xf9\xe1\x84\x87\x41\xc2\xa2\x55\xd3\x52\xe3\x41\xb1\x66\xda\x5f\xa8\x7c\x3d\xf9\x7e\x25\xaa\x96\x9f\x67\xff\x63\xca\x46\xb3\x90\x64\x82\xe0\x45\x11\xf3\xfe\xcb\x73\x84\xd0\x38\x0e\x39\x0b\xe4\x37\x33\x17\xa9\x33\x19\x4b\x65\xf6\xf6\x5b\xfb\x27\x1f\x47\x22\x61\x3e\x0e\xcc\x43\x5e\x35\x3e\x48\xd0\xec\x63\x41\x62\x49\xd6\x2d\x90\x8a\x1c\x66\x8d\x94\xcc\x52\x79\xd2\xc8\x2f\xb0\x72\x88\x5a\x39\xe4\x62\xc2\x22\x92\x4d\x68\x46\xa6\xf4\x8c\xa5\x24\x65\x51\xca\x9c\x11\xe1\x5a\xbc\xb6\xd5\x50\xec\xb5\xde\x9e\xa1\x7b\xf3\xd8\x69\xdb\x6e\xdc\x1b\x2d\x05\xd8\x01\xec\x25\x09\x8f\x50\x4c\xfc\xdf\x52\x8f\x11\x7d\xb7\x94\xd3\x9e\xda\xc4\xf8\x8a\xb5\x31\xcd\x7b\x9c\x76\x74\x81\xd9\xa8\x90\xdc\xf6\x3b\xfe\xf6\x3e\xeb\x8c\xf5\x3e\x90\x2c\xf5\xb6\x3b\xfb\x59\xfe\x6a\xe7\x8e\x2e\xf3\x55\x17\x68\x00\x48\x4e\xaf\x93\x33\x57\x3d\x0d\x6c\xa6\x66\x40\xd2\x26\x27\x0d\x3d\x92\x86\x97\x61\xdc\xcb\x0e\xde\x80\x9e\x00\x49\x55\xa3\xb8\xad\xe8\xc9\x31\x39\xf2\x55\xeb\xce\xe5\xdc\x36\x68\xf3\xf9\x8b\xcc\x64\xf7\x3f\xb1\x18\xc9\x5d\xac\xac\x2e\xcf\x9d\x21\x8d\x79\x46\x43\xfe\x1b\x7b\x25\x1f\xbd\xaf\x25\x8b\x26\xad\xa6\x86\x6f\x9d\xb6\x49\xd3\x21\x95\xdc\xb2\x16\x27\x52\xb7\xf0\x4e\x17\x70\x74\x4b\xb6\x0f\xc0\xb2\x71\xa4\xd5\x6d\xb9\x6d\x69\x9e\x5f\x9c\xd3\xdb\x6d\xbf\x31\x9d\xf1\x1d\xcd\xa5\x96\xbc\xb0\x0f\x42\x69\xab\xed\xf2\x62\xab\xed\x73\x51\x0b\x98\x53\x0b\x26\xf0\xa5\xa5\x5b\xea\xa0\xb5\xa0\x4a\x60\xde\x04\x0e\x51\xaf\x08\x0d\x82\x6c\x03\xdd\xd5\xcf\x64\xdb\xcf\xcf\x26\x0d\xb8\x7c\x96\xb7\xbd\xc4\xe1\x18\xb5\xa4\xd1\x76\x33\x87\xdf\x6f\xbb\x7b\x95\xe5\x87\xab\x36\xb2\x65\x4b\xdd\x0b\x14\xab\xdd\x22\xa4\xf5\xf4\xd6\xd5\xad\x5b\xea\x0e\x1b\xeb\xbd\x18\x99\x7b\xc8\xd2\xb4\xc3\xa2\xf3\xce\xdb\x77\x2f\x5e\xf6\x5f\xbe\xfd\x37\xcc\xf2\x77\x71\x22\x82\x19\x46\xca\x21\x3f\x10\xc8\x8f\xae\xf3\x9a\x2f\xb5\xd7\xe6\x92\xf4\x5f\xf7\x76\x96\x43\x7f\x4d\x3b\x56\xbe\xd3\x7f\x86\x23\xf6\xd6\xe2\x75\x8a\xb9\xef\xed\x76\x54\x4b\xd8\x65\x53\xe9\xbb\x5b\x5a\xed\x79\xba\x34\x42\xb5\x2d\x5e\x1b\x0f\x2d\xdb\xb0\xd9\x34\x17\xb6\x5d\xcf\x5d\x72\x87\x49\xd8\xa8\x25\x5f\xfb\x57\x4f\xf5\x72\x54\xad\xb9\x37\x41\xb5\x58\x6c\xff\x6f\x95\xbc\x0f\xe1\x74\xd5\xcf\x6f\x2b\xf9\x85\x11\x39\xb2\x14\x3b\x1a\x7c\x90\xb7\xc9\x67\x12\xc1\xc6\xd1\x78\x33\xe3\xd8\x87\x06\xb9\x6a\x35\xf1\xcf\x56\xad\x10\xf2\xaa\x33\xa4\x61\xd8\xac\x93\x6a\x36\xef\xb5\x5a\xad\x82\x90\xf4\xe1\x35\x0a\x49\xaf\x41\xea\x89\x82\x1e\x8c\x0e\x57\x99\x4a\x18\x44\x7f\x0b\x9a\x32\xdc\x84\xed\xb0\x68\x36\x65\x09\x1d\x84\x7a\x2f\xbf\x45\xc8\x98\x65\x3d\x2b\x15\x19\xb3\xac\xd9\xd2\x22\x10\x75\x9a\x54\x88\x99\xb0\x7b\x2d\x4d\xc0\xa7\xf2\x55\x85\xbd\xdf\xba\xdc\x29\x47\xbd\x47\x5f\x22\xf5\x20\x91\x7a\x65\xba\xf3\xc7\x7f\x30\xf1\xa0\x77\x5f\x02\xed\x1e\x7f\x53\x4f\x7c\x53\x4f\x6c\xa0\x9e\x20\xdd\x2e\x21\x17\x8c\x9e\x7d\x53\x45\x5c\x8f\x2a\xe2\xaf\xab\x34\xf8\xf0\xfc\xc5\xe1\xc7\x23\xf2\x8c\xec\xed\x6f\x49\x8d\xe0\x5c\x92\x12\x16\xd2\x8c\x9f\x5b\xd9\xb6\x55\x31\xf0\x28\xe4\x11\xdb\x01\x4d\x83\x2b\x48\x1d\xc8\x3d\x7b\x65\x9d\x44\x22\x2e\xbc\x6f\xbf\x24\x34\xee\x91\xc6\x45\x42\x63\x53\xfe\x9f\x59\x9a\xf1\xd1\x5c\x39\x09\xf7\x48\x43\x5e\x46\xe5\xb3\x4e\x7d\xa7\x21\x1f\x47\xf5\x5f\x0f\x33\x36\x4d\x8b\xdf\x16\x4a\xf3\x77\x70\xd6\x73\xf2\xfb\x5c\xe9\x48\x44\xd9\x2b\x3a\xe5\xe1\x5c\x4b\x7f\x33\x63\xec\xd5\xb1\x1f\x5d\xf0\x5f\x18\x62\x2a\x05\xc7\x8f\x2e\xf8\x11\xff\x8d\x95\x00\xc7\x97\xc7\xe2\x03\x9b\x36\xb1\x3b\xad\x9c\x62\x47\x31\xcc\xf7\x64\x5f\x7f\x98\xa8\x56\x8b\x5f\x50\xd5\xf3\x81\x06\x7c\x26\xa7\xe9\x81\xab\x11\xaa\x97\x85\x7b\x82\x9f\x52\x11\x78\xc6\x2e\xb3\x03\x17\x4a\xeb\x7f\xf6\xe4\xee\xf8\x81\x45\x01\x4b\x40\xc2\x07\x1c\x44\x44\x24\xa7\x9e\x88\x11\x89\x85\xa4\x28\xa7\x21\x49\x78\x1c\x87\x0c\x25\x96\xdf\xb4\x09\xdb\xd7\x26\x2c\x14\xac\x27\x40\x35\x16\x80\xf6\x8f\x47\x96\x7c\x56\x0c\x0a\x3f\xcd\xaa\xbc\x61\x11\x80\x23\x8a\x58\xbf\x62\xef\x8f\x12\x3a\x78\x82\x94\x3c\x09\x70\x95\x5c\xf0\x30\x24\x03\x46\x68\x10\xb0\x80\xe8\xed\x9a\x64\x82\x64\x13\x9e\x92\x48\x0e\xe5\x8f\x57\x76\xfc\x49\xc9\xf0\x4d\xd3\xb2\xaa\xa6\xc5\xbe\x15\x4b\xc4\x4a\x05\x5d\x07\x3c\xff\xf2\xaa\x0e\x77\x3f\x31\x8a\x05\xb7\xf0\xc6\xd4\x1b\x0b\x15\x2c\xeb\xaa\x37\xdc\xd1\x2c\xa5\xe2\x30\xfa\x90\xd3\xd6\xd3\x8d\x35\x1c\x8e\xb0\xde\x9d\xf1\x95\xd0\x41\x95\x45\x82\xc1\xcf\x57\xd7\xa9\xd0\xd0\xac\xd5\x5a\x55\xc9\xd0\x08\xf8\x79\x63\x81\x6a\x61\x15\x4d\x01\xfe\x5a\xa2\x61\x42\x1a\x69\x4c\xad\x21\x8e\xd7\x4c\x6e\xd2\xaf\xec\x35\xcc\xf2\x06\x14\xb5\x8c\x66\x02\x96\xcb\x1f\xa3\x98\xf8\x76\xc8\x5f\xcf\xe9\xf2\xed\x8c\xde\x7c\x16\xff\x6a\xaa\x9a\x05\x67\x6a\x4e\x5f\x82\x9b\x44\x8d\xba\x44\xa3\xbb\x16\xcd\x08\xb4\x06\x8a\x11\x14\xe5\x6e\x47\x2f\xf2\xe4\x8b\x94\xac\x8b\x2c\x13\xd3\xb7\xf4\x9c\x8f\x69\x8d\x49\xd4\x03\x70\xa1\xfb\x43\x85\xec\xb9\x8e\x96\xc9\xdb\x4b\x47\x84\x91\xea\x2a\xc7\xb5\xb7\xcc\xb8\xca\x71\xde\xc4\x30\xb1\xa5\x2f\x40\xb9\x70\x7f\xf7\x4f\xae\x5c\xb8\x79\xf9\xff\x56\xd5\x19\xdf\x94\x0b\x5f\xa9\x72\xe1\xaf\xab\x33\xb8\x21\x47\x83\x45\x02\x7a\x2d\x77\x7e\xf0\x70\x49\xa1\xb2\x63\x47\x1e\x83\x23\xcf\x16\x45\x99\x5f\xa0\x8d\xf0\x9f\xe6\x4a\xfe\xf5\x8b\xcd\x0e\x68\x18\x4a\x6e\x24\x23\x98\x54\x25\x0c\x63\x78\x1a\x92\xe1\x84\x46\x63\xa5\x97\xd0\xcd\xc6\x34\xa1\x53\xf2\x19\xbb\x74\x45\xd0\x65\x46\x32\x1c\xfe\x95\x8a\x59\x32\x64\x86\xeb\x14\x7a\xbf\x2e\x8d\xe6\x57\xaa\x85\x5f\x98\xde\x70\x50\xb6\xcb\x08\x8f\x02\x76\x69\xea\x4b\x16\x35\x43\x14\xd1\x01\x74\xa8\x72\x84\x92\x1f\xfd\xf1\x1d\x8e\xc8\x27\x79\xa4\x7f\x6a\x13\x1a\x86\xe4\x53\xf9\x6d\xe9\x53\x8a\x02\xe7\x74\x22\x2e\x64\xbb\x3c\x21\xa1\xe4\x08\x35\x72\xf2\xe3\xdc\xf4\x52\x44\xe1\x1c\x09\x0b\xf1\xef\x59\x50\x89\xd3\x41\xc9\xb3\x14\x11\x5a\x92\xcb\x72\x08\x9b\x52\x4d\xf5\x81\x10\x61\x51\xc8\x89\xf3\xa6\xe7\x67\x96\x24\x2c\xca\xc2\xf9\xe2\xee\xd8\xa6\xd5\x4d\xc7\x6c\x91\xf0\x5b\x4b\xe9\xe4\x7f\x40\x4e\x68\x19\x55\xfe\xd4\x97\x51\x3e\x22\xcd\xdb\xea\x6e\x15\x27\x22\x13\x60\x1b\x3e\xa1\xe9\xbb\x8b\x48\xdf\x57\xf0\xb9\x93\xc3\xd7\x6a\x99\x5d\x36\x9b\x24\xe2\x82\x44\xec\x82\xbc\x4c\x12\x91\x34\x1b\x20\xa9\xfc\xd4\x20\x77\x0d\x34\xb9\x4b\x1a\x9f\xc8\x84\xa6\xb0\x35\x91\xff\x6d\xd0\x68\xfe\xbf\x8d\x36\x19\xcc\x32\x72\x41\x53\x12\x89\x4c\xc2\x9e\xf3\x00\x17\x15\x54\xf6\x3a\x0c\x18\x3a\xe4\x3d\x4d\x53\x7b\x73\x23\x22\x21\x34\x9a\x2b\x01\x26\x8c\xbb\xd3\x00\x79\xa0\xda\x7e\xf3\x82\xda\xdc\x54\xe6\x65\xb6\x7a\x07\xf5\x45\xad\x5b\x31\x47\xd7\xbc\x6f\x20\x74\x81\x06\xb0\x0c\x65\x40\x6c\x91\x06\x42\xe6\xd1\xdf\xe1\xd7\x4d\xd8\xac\xeb\xbe\xca\xbf\x6d\xa7\xe4\x2f\xe8\xc2\xf5\x58\xb0\xfb\xc6\xd8\x39\x4f\x81\xbc\xd8\xf2\x40\x7d\xea\x4c\x69\xdc\x74\xc9\x68\x9d\xcd\x09\x96\xb7\x11\x0d\xe8\x74\xbd\x55\x90\x47\xc9\xd3\x7f\xd3\x90\x07\x5a\x14\x0a\xb5\x5a\x2d\x7d\xdd\x88\x66\x61\x88\x8c\x66\x7a\xf6\x6f\x45\x0c\xf8\xd1\x71\x48\x22\xef\x3e\xb6\xd1\xa7\xde\x2b\x30\x2f\x7e\x0d\x45\xc4\xbc\x26\xdb\x66\x9d\xe9\x2d\xa1\xe7\x35\xf7\xec\x19\xf1\xe8\x6e\xe8\xd1\xf3\x3a\x62\x8a\x41\xae\x6a\x57\xd0\x0f\x15\x50\x3d\x52\xc1\x6d\x6e\xeb\x79\x66\xee\x99\xbf\x70\x09\xc2\x52\xbc\xfa\xa3\x05\xdd\x56\xf0\x9c\x5b\xfe\x7f\x8c\x0c\x7a\xc9\x93\xe2\x9b\xbc\xf5\x9b\xbc\xb5\x1c\xa1\xb3\xfb\xd6\xdc\x9b\x96\xc5\xe6\xed\xdf\x35\xfc\xb8\x2c\x3e\x3c\x01\xda\xeb\x5c\x47\x36\xbf\x8c\x7c\x89\x57\x91\xab\x5b\x57\x79\xd9\x76\x7e\x1f\x2a\x11\x73\xbb\xbb\xc4\x88\x86\x29\xbb\x1e\x39\x77\xae\x65\x14\x79\xe7\x05\xab\x5b\x91\x7e\xdf\xdf\xfb\xb2\xa4\xdf\xdf\x8c\x8d\xff\x48\x79\xe0\x98\xc9\x62\x5c\xe1\xef\x46\x15\x5d\x78\x5c\x01\x5e\x27\x4a\xf3\x21\x7d\x59\x9f\x7c\x1c\x1f\x4c\xd8\xf0\xac\x6a\xcc\x4f\x2a\xe0\xeb\x86\x9a\xc3\x6c\x31\xc0\xc5\x06\x34\xe3\x55\xcd\x41\x7e\xc4\x02\x74\x6d\x63\x0e\x52\x53\x37\x16\x69\xca\x07\x21\x3b\x10\x51\x9a\x25\xb3\x61\x26\x92\x0f\x70\xd9\xaa\x6c\x77\x6f\x71\xdd\xba\x5e\x54\x37\x68\xf0\x2a\xbf\xac\xea\xa1\x17\x41\xeb\x5a\x34\xe8\x7c\xb1\xf0\x37\xe1\x71\xb9\x65\x3a\x8a\x08\x7e\xa4\x69\x95\xec\xf6\xfe\x83\x12\xd8\xba\x46\x2c\x94\xa9\x78\x38\xac\x54\xaa\x3d\xb9\xef\x41\xd5\x21\x96\xdf\xbf\x34\xa1\xb7\x7a\x8d\x6c\x2c\xf7\xd6\x78\x16\x88\xbe\x2b\x42\x42\xd9\x29\xff\x0b\x49\xec\xb3\x84\x46\xda\xc6\x5d\xd9\x8f\x9b\x92\x54\x3d\x16\x9b\x27\x8e\xd3\x3c\xc6\xf6\xd9\xc9\x44\xdc\x38\xb5\x4f\x65\x42\x82\x59\x42\xab\xd0\xe8\x6f\xf2\xb9\x9b\x64\xaa\xca\x95\xb1\x47\x57\x38\x8f\x45\xdc\x23\x8f\x73\x85\x78\x57\xea\x91\xbd\xdd\xdc\x87\xd7\x10\x3e\x67\x6f\x3f\x57\xfc\x01\x35\x09\xb6\x7c\xca\xa3\x5f\xd0\xde\xfd\xb1\x41\x31\xa5\x97\xaa\x6c\xef\xe1\xe3\x85\xb6\xe9\xd6\x6e\xda\x75\x44\xe8\x91\xc6\x9e\xe7\xdf\x60\xa5\x05\x9f\x4b\xc6\xf5\xb0\xb6\x19\xd7\x5e\xbc\x0c\xa7\x5c\xb4\xef\xa2\x70\x5e\x8e\x1b\x71\xa5\x31\x1d\xf2\x68\xdc\x99\x45\x3c\x23\xdf\x93\x7d\x17\xcf\x45\x42\xe3\x98\x25\x65\x8a\x1a\xd7\x5d\x63\x19\x97\x88\x45\xba\x9c\xd2\xa8\x51\x15\x91\xa6\xdc\x2e\x86\x28\x42\xf9\xbc\xbe\xcf\xc4\x02\x27\x88\x52\x2c\xb2\x0e\xd9\x21\xfb\x86\x17\x85\x9c\xc5\x6c\xde\x23\x7b\xed\x92\x15\xd2\x90\x75\x76\x52\x59\x69\xb7\xb3\x9f\xb6\x35\x38\xfc\x6a\x14\x6b\xbc\x60\x38\xc9\xbb\x9d\xbd\xb4\x94\x59\x5e\x17\x47\xbd\xee\x30\x3c\x3f\x83\x09\x0f\x02\x16\xe5\xb0\x9b\xb1\xed\xd6\xf4\xd4\xef\x27\x1f\xca\x61\x17\xb9\x66\x10\x8a\xe1\x59\xc3\xae\xa7\x64\xcc\x23\x1d\xcc\xea\xba\x95\x71\x5f\xa3\x5a\xe8\x78\xc2\x60\xee\x08\xc3\x23\xa9\x43\x0e\x47\x84\x12\x04\x25\x3c\x35\x2f\xde\x36\xe1\x99\x31\xd6\x9f\xa5\x2c\x20\x34\x25\x14\x18\x81\x84\xf2\x7d\x38\x4b\x1c\x63\x6a\x24\x47\x9d\xdd\x97\x9c\xd0\xe6\x49\x7d\x4f\x57\x94\x68\x99\xd3\x79\x4d\xa1\x96\xae\x7f\x3d\x52\x26\x85\xad\x55\x16\x73\x07\xf6\x10\x33\xe5\x66\xd6\xd4\xd6\xf2\x15\x47\x99\xa8\x67\xd1\x35\xd4\x7a\x25\x28\x42\x3e\x3c\xdb\x00\x83\x3d\xfe\x96\xd6\xc6\x39\xba\x45\xb9\xa4\x2b\xcc\xc8\x96\xd3\x02\xae\xd0\xec\xaf\x62\x46\x86\x34\xd2\x4b\x90\xcc\xc5\x2c\x21\xe2\x42\x09\xce\x3a\xe4\x5d\x36\x61\xc9\x05\x4f\x59\x9b\x5c\x30\x32\xd2\x0a\x5e\xa5\x5e\x05\xb9\xb0\x0d\x71\x03\xda\xd6\x6f\xaa\xc1\x65\x55\x83\xf2\x2c\xa8\x34\x17\xb4\x8a\xa3\x3e\xac\x86\xbf\x99\xbb\x39\x0e\x10\x44\x6f\xe6\xf5\x6a\x05\x6f\xe5\x08\xdb\xa4\x80\x05\xf4\x22\x95\xca\x49\xac\x66\xcc\x06\x6d\x08\x59\xfb\x33\x63\xd3\xb8\x4d\xfa\xd9\x84\xa7\x20\x61\xcc\xd4\x47\xab\x67\xb3\x22\x0c\xdb\x3f\x04\xaf\xb0\x33\x54\x18\x46\x22\x21\x4d\x68\x23\x04\x7d\x1b\x4d\xc6\xb3\x29\x9c\x66\x21\x8b\xc6\xd9\xa4\x2d\x4b\xe4\xd1\xf8\x3c\x49\xe8\xbc\x29\xa1\x5a\x6d\xd2\x3f\x63\x73\xf2\x8c\xec\x3e\xc5\xbf\xfe\x0e\xb5\xf1\xc7\xdd\xbb\x96\x2b\x64\xd5\x13\x59\x78\xea\x62\xc6\x12\x4d\xa1\x9c\x92\x0c\x44\x9d\x30\x5e\xfc\x63\xc2\x53\x2d\xfc\xac\x16\x61\xe4\x87\xac\x55\x37\xe5\x43\xef\xf4\xfb\xc0\xe6\xfd\xbe\x7c\xf9\x00\xea\x9c\xd8\x69\x11\x89\x5b\x2d\x58\x0f\x1d\x79\x0d\x98\x2b\x79\xf8\x89\x6c\xfa\xb4\x33\x14\xd1\x90\x66\x4d\x39\xf2\x16\x98\x3a\xcb\x62\xfd\xdf\xce\x84\x46\x41\xc8\x8c\x42\xd8\x32\x1e\xd8\x60\xd8\x89\x43\xa2\x4f\x78\xfa\xb7\x58\xdd\x4c\xb0\x3e\x2e\x40\xf3\xf6\xf1\xb4\xcb\x0e\x7c\x41\xc7\x4c\x1c\x15\xb2\x0b\xe7\x29\x14\x15\x3e\xb9\x1f\x17\xd1\xc9\x52\xd4\xf5\xea\x2d\x43\xb7\xd1\x72\x1e\x63\xba\x0c\xc7\xd3\xc6\x36\xd5\x62\x34\xc4\x36\xd5\x25\xce\x5c\x6d\x59\xa4\x26\xc3\xd6\xc2\x7b\x21\xae\x02\xad\x9d\x58\x86\x19\x9c\xf5\xa2\x04\xf4\x7a\x31\xbb\x52\xb8\xc5\xeb\xf9\x04\xbb\x78\xc6\xe6\xe0\x81\x1e\x05\xe6\xd9\x91\xdf\x76\xf1\x63\x33\x47\x48\x37\x60\x99\xf3\x63\xff\xe9\x2d\x17\x4a\x53\xba\x9c\xd0\x78\xc5\x78\xa6\xc0\x3a\xf0\xd3\xfd\x2e\x6f\x68\xca\x10\x41\x81\xc8\x12\x17\xc2\x18\x9a\x18\x08\x5d\xe2\x42\x59\xa3\x87\x7e\xa9\xd5\x03\x29\xb1\x7c\xe8\x57\x98\x3e\x10\x57\x4b\xed\xc3\x9a\xe2\x2a\x66\x5e\x82\x8f\xab\x58\x78\x35\x7b\x88\xbe\x31\x88\x80\x39\x6d\xb4\x49\x43\xce\x1c\x58\x3c\xa8\xf9\xa9\xb3\x90\x30\x03\xc9\x9b\x4b\xf8\x06\x12\x9a\xca\xeb\x18\x49\x5c\x4b\x84\x3e\x4b\x6c\xc3\x08\xab\x45\xda\xcb\xe3\xd1\xa2\x81\x36\xb9\xed\xd3\xf8\xce\x1d\x72\xdb\x69\x62\x61\xf4\x3d\x3d\x35\x1c\xc5\x8c\x68\x6f\xe1\x6c\x14\x9a\xb3\xdd\x9d\x42\x96\x2f\x30\xe3\xb0\xd5\xee\xdc\xd1\x57\x70\xb3\x48\xc0\x41\x0f\x5f\x25\x0d\x17\x2f\xd1\xbd\xa8\x35\xd7\xd0\x68\xda\x5e\x4d\xef\xc9\xb6\x98\xb6\xb0\x3c\x4d\x8f\x3a\xb9\x25\xd4\x72\x10\x5f\x99\xad\x90\x90\x2b\xc2\xc2\x94\x2d\xd5\xe3\x32\xff\x3e\xfc\x87\xb2\x5a\x3f\x88\xa1\xfe\x27\xa7\xdf\x2f\xd1\x5d\x74\x0a\xdd\x0e\xe5\xf7\x76\x49\x4a\x58\x49\xab\x39\x68\xe2\x86\xe6\xf1\xfa\xfe\xaa\xcc\xbe\x5f\xe4\x52\xdc\x63\xd6\x62\x79\x07\x9b\x23\xd5\x58\x81\xdd\xf7\x5b\x96\xc1\x97\x37\x8a\x01\x02\x39\xb2\xfa\x22\x99\x56\xb2\x95\x69\x93\x91\x18\xce\xd2\x0f\x10\xa8\x02\xb5\xa2\xc6\x7c\xa6\x4d\x3e\xdb\x07\x58\xf1\x7e\x62\x05\xa5\x4b\x7a\x8f\x92\x82\x07\x29\xc9\x7b\x91\xea\x19\x55\x82\x41\xeb\x46\xaa\x39\xcd\xfd\xbd\x02\x4b\x17\x9b\xcd\x35\x9c\x63\xc9\x2b\x1f\x14\xbe\xba\x0c\x7e\x2b\xff\x97\xfb\xa2\x38\x85\x1f\x8a\xa4\xe5\x97\x86\xa7\xb7\xae\x0a\x1b\x94\xf7\x1e\xb8\x6e\x05\xbf\xf2\x53\x2a\x53\xf3\xdb\x0b\x7f\x4e\x51\xbf\xff\x4d\x51\xff\x4d\x51\xff\x4d\x51\xff\x4d\x51\xff\xe5\x2a\xea\xe1\xd7\x0b\x31\xad\x52\xd3\x3f\xb9\x51\x95\xfe\x19\x9b\x0f\xab\xb5\xae\x8f\x1e\xe4\x01\xeb\xd0\x2b\x90\x1b\x35\x17\x38\x63\xf3\x81\xa0\x49\xf0\x4a\x5e\x09\x2a\xfd\x64\xef\x19\xf8\x63\x31\x1b\x4e\xf0\xea\x50\x09\x7d\xbf\x0c\xba\xae\x5f\x0e\x58\x6e\xb1\x61\xe1\x4f\x70\x07\xa9\xcc\xe8\xf3\x20\xbf\xa0\xbd\x5a\xb5\x04\x2d\x82\x7f\x69\x06\x09\x37\xa5\xd3\xcf\x79\x68\xae\xa6\x02\x91\xa5\xd7\x65\x32\x01\xb8\xfe\x58\x8f\xc1\xeb\x56\x44\xd7\x45\x2b\x84\xb8\x72\x53\x71\xce\xc8\x38\x61\x73\x32\xe1\xe3\x49\xc8\xc7\x13\x6d\x9a\xf0\x0b\x1b\x9c\xf1\xec\x98\xc6\x3f\xe9\x0f\x15\xa1\xed\xa6\x53\x11\xa1\xa5\x43\x4c\x13\x27\xc4\x50\xc1\x7d\xb1\xe1\x00\x61\xb2\xa4\x0f\x2c\x65\x99\xf1\x8a\x82\x3b\x98\x56\xd3\xce\x32\x39\x13\x3d\xd2\x88\x44\xc4\x1a\x7e\x08\x3e\x47\x79\xeb\xc7\xe4\xb3\x81\xe1\x66\x49\x8a\xf1\xad\x05\xf7\x26\x64\x96\xb2\xe4\x08\x5e\x48\x79\xd4\xf2\x0d\x40\x13\x1a\x0d\x0b\x8d\x66\xec\x32\x7b\xc1\x86\x42\xdb\x76\xf8\x5f\xbb\x5d\x72\x24\xc8\x05\x23\x19\x3d\x63\x24\x4e\xd8\x90\x05\xe0\x32\x79\xae\x22\xf6\xa1\x96\x56\x8c\x08\x25\x11\x06\x20\xfb\x3b\x25\xdd\x7f\x78\x2a\x3a\x6b\x13\x61\x83\x8b\xab\xf2\xc6\x9d\x5e\x6f\x67\x2a\x7e\xdb\x81\xb7\xd3\x0e\x8f\x22\x96\x34\x7a\xce\xab\x1b\xa7\x00\x76\x57\xdd\x37\x87\xb6\xaf\x78\xc2\x46\xe2\x92\x04\x22\xcb\x58\xa0\xe7\xb5\x93\x93\x67\xde\x52\x6c\x48\x07\xa1\x9f\x31\x0a\x66\xef\xe5\x39\x8b\xb2\xd4\x0c\x5c\x62\x7f\x81\xb0\x24\xe4\xd1\x19\x01\x20\x0a\x8c\x9f\xe6\x09\x60\x22\x66\x90\xeb\x55\x88\xe7\xf4\x66\x2a\xf8\xa1\xd1\x22\xe3\x3a\x60\x41\xc7\x28\x46\xe7\xe4\x42\x44\x8d\x8c\xa4\x19\x4d\x32\x42\x33\xed\xfa\x96\x8a\xc4\x1d\x80\x59\x32\x8e\x06\x1d\x70\xe9\x57\xeb\x4a\x7e\x76\x5f\xb0\xff\xec\xb7\x1c\x3b\x45\x62\x69\x2b\x38\xb0\x41\x18\x09\x5c\xbf\x72\xaf\x76\x62\x05\x92\x97\x1c\x84\xba\xc6\x90\x21\x13\x12\x9e\x50\xf2\xe2\xdd\x1b\xbd\xa8\x41\x11\x98\x27\x37\x34\xe2\x6d\x76\x84\xa7\x84\x92\x4f\x83\xbc\x73\xa5\x93\x9e\x63\x2d\x33\x05\x3c\x15\x37\x33\x55\x00\x1c\xd7\x6a\xae\x20\x4b\x5b\xb5\xda\xef\x01\x4d\x19\x19\x38\x2a\xef\x01\x33\xbb\x92\x9d\x1d\xbb\x4f\xad\xab\x65\xc7\xdd\x82\xb0\xd1\x88\x0d\xb3\xc5\x2d\xad\xbc\xf4\x17\x0d\x6b\x42\xcf\x25\xc3\xe8\x2b\x30\x8a\xc5\x54\xaf\x14\xaf\x7c\xf2\xda\xfe\x44\xa6\xb3\x34\x23\x34\x4c\x85\xec\xe9\x27\x70\xce\x70\x18\xc6\x93\xab\xad\xb4\x43\x1d\x1c\x1d\xe1\x92\x31\x6b\xf3\x62\xc2\x43\xe6\x6f\x57\x92\x4f\xfd\xce\xba\xb3\xe4\xdd\xe4\x59\x70\xb0\xd6\x02\x2c\x1a\x63\xfc\x18\xce\xaa\x63\x26\xde\x84\x35\x87\x88\x60\x44\x2b\x60\xa8\x72\x84\xf7\x26\x52\xcd\x1f\xe6\x84\xb4\x4c\xa0\xe8\xfe\x0b\x23\x59\xc2\xc7\x63\xd8\x61\x3e\xa9\x2e\x7c\x32\x3e\xf0\x24\x13\xa2\xe3\xf4\xf0\x67\x77\xee\x37\x1a\xeb\xcf\x6c\xfe\x42\x5c\x54\x5b\x56\x2d\x89\xe3\x63\xbc\x11\x86\x37\x62\x96\xb2\x8d\xfb\x01\x58\x5e\x33\x7a\xbe\x99\x39\x10\xa0\xd9\x70\x40\xf0\xc2\x7c\x19\x55\x6f\x56\x4b\x23\x79\x23\x36\x1c\x0e\x60\x39\x92\xd7\x9f\x0d\xd0\x24\xa2\x66\x8b\x29\x5b\xd8\x1f\x53\x86\x91\x51\x63\x25\x73\x94\x07\x66\x0c\x1b\x0e\x49\xd8\xc8\xe5\x6c\x7b\xdc\x96\x5c\x94\x64\xf9\x07\x36\xda\xa0\xeb\x19\x1d\xa8\xa0\xda\x6b\x1b\x0f\x46\xb3\xe9\x80\x25\x0b\x5c\x2a\xf3\x56\x79\x85\x7e\xcc\xe3\x45\x53\xe8\x79\x90\x6a\x93\x21\xd7\xbf\x62\x6d\x33\x21\x83\x64\xb1\x69\x90\x01\xdd\x9e\x39\x90\xe7\xe0\x41\xfe\xf4\x26\x40\x66\xb8\x2b\x99\xfd\xd8\x49\x5a\xd7\xd4\x27\xcd\x68\xc6\xd4\x0b\x8a\x90\xc2\x89\xad\x9d\x3d\x89\xb6\x6d\x91\x75\x72\x67\x8b\x95\x84\x55\x1a\x0a\x61\xbd\x33\x3c\x47\x24\xa0\x44\xfa\xd4\xfb\x98\xb2\xec\x48\xf6\xa5\xf9\xb9\xd8\x07\x54\x07\xb6\x3c\x7d\xbb\x63\x69\x94\xef\x90\xab\x2a\xaf\x01\xab\x36\xe0\x91\x55\x12\x2d\x4f\x04\x55\x73\xf9\x08\x74\xf1\x40\x9b\xe8\xe5\x60\x6d\x5b\xc7\x7c\xca\xc4\x2c\xab\x03\x81\x75\x20\xe1\xc8\x33\xf2\x60\xb7\x14\xe4\x0d\xbd\x34\x50\x92\xd9\x1e\xf8\x06\x5b\x3f\xdb\xde\x6d\x6c\xb1\x65\xef\x25\xbe\x8d\x95\x29\x77\x81\x9d\x3b\x66\x0e\xdc\xf9\xe2\x9b\xd0\xd8\xbe\xfa\x16\x5c\xaa\x7c\x15\x63\x2f\x3b\x32\x5c\xeb\xb0\x66\xb4\x68\xdb\x2e\x16\x4d\x6d\x2b\x9c\x81\xb9\x94\xcc\x24\xeb\xc9\xf7\x56\x98\x30\x1a\xcc\x49\x20\x3b\x96\x09\x42\xcf\x05\x0f\x48\xc2\x62\x46\xb3\x94\x0c\x98\x7c\xd2\x0d\xc5\x2c\xca\xd0\x0c\x7d\x3a\x0b\x33\x2e\x87\x4c\x87\x19\xc7\xf4\x88\xa9\xc3\xa0\xee\xa4\xdc\xb9\x43\x6e\xfb\x1c\x74\xe7\x8e\xbb\x00\x3b\x39\x96\x97\x9f\x61\x30\x60\x00\x12\xd3\x21\x6b\x14\x99\xda\x32\xa3\x5c\x1f\xd6\xd6\x01\x06\xda\x89\x59\x92\xf2\x34\x6b\x3a\x46\x10\x2e\x63\x77\xd2\x4c\xc4\xda\xfe\xcd\xb2\x8b\x6f\x65\x92\xab\x40\x93\x2c\xb7\x66\x5c\xab\x8f\x9c\xd9\x9c\x22\xa4\x6f\x38\xa7\x0a\x0b\x2b\xcf\xd2\x44\xaf\x50\x42\x87\x43\x26\x77\x51\x1e\xf2\x6c\x0e\x9b\x7f\x04\xf6\xc4\x4a\x1c\x73\xce\xf4\x83\xda\x9d\x73\x1c\x7a\x46\x93\x31\x43\x83\x7c\x6f\x7d\xde\xb9\x63\x78\xe9\xce\x1d\x87\xc3\xbd\x1f\x60\x73\x43\x1b\x25\x85\x03\xa5\xbb\xbe\x73\x87\x34\x73\xc4\x91\x5b\xb5\x29\x42\x39\x6b\xcb\x1d\xb9\x22\x09\x26\x80\xd7\x12\x7b\x67\x16\x17\x9a\x14\x7a\x8b\xfc\x63\x5c\xb7\xc4\xf3\x9b\x63\x8e\x0f\x6b\x57\x87\x37\xa6\x7a\x16\xad\xe3\x47\x6f\x7b\xbf\x4e\x86\xd4\xa7\xaf\x5b\x2f\x9e\x85\xa9\x3c\x37\xea\x38\xb3\x7c\x66\xd4\xab\xa4\xf6\xb8\xf8\x18\x2f\x43\x14\xf3\x36\x31\x46\x44\x25\x3a\x9f\x82\xc5\x67\xc3\x54\x03\x13\x3d\xb9\xbe\x1a\xe5\x63\x1f\x86\x8c\x26\xea\x0c\x69\x56\x1f\x2f\xa6\x93\x9a\xc8\x16\x02\xd9\xe0\x67\x36\x7f\x9f\xb0\x54\x92\xaf\x09\x44\x32\x35\xec\xdc\x2c\x49\xed\xba\xf3\x1a\x50\x17\x08\x70\xd5\x2a\x99\x34\xe0\xe5\x55\xa7\xec\x63\x8c\x13\x26\xe2\x46\x19\x4e\x78\xde\xad\x81\x16\xea\x19\xcc\xed\x65\x96\xd8\xc2\xc9\xaa\x5f\xf9\xe5\x13\x63\x5f\x63\xab\x0d\xc2\xd6\xb3\xfc\x54\x86\xfa\x65\x14\xac\x81\xf8\x65\x14\x54\xcd\xba\x79\x84\x5e\x2f\xda\x1f\xc3\x59\xb2\x1a\x46\x59\xa3\x94\x80\x37\xb9\x94\x56\x5d\x1f\x79\xf2\x6b\xb5\xf7\xd2\x3b\xbc\x96\x4e\xba\x7c\x87\x3b\x65\xd9\x09\xfb\x8a\x5f\xc2\x71\x3a\xc9\xb2\x38\xed\x75\xbb\x63\x9e\x4d\x66\x03\x79\xb1\xeb\x8e\xe8\x90\x0d\x84\x38\xeb\x82\x3d\x43\x97\xa7\xe9\x8c\xa5\xdd\x47\x8f\x1e\x3e\x71\x5a\xbe\xed\x9e\xa9\xc5\x7d\xc1\xdc\x85\x91\xf3\x55\x04\xc1\x63\x38\x92\x0b\xdd\xa9\x38\x19\xd4\x5d\xce\xb9\x1b\x6b\x49\xc0\xb3\xda\x27\x48\x67\xc0\xa3\x40\x33\x83\xbf\x6d\x97\x90\x31\x60\x19\x1b\x66\xfe\xcb\xc1\x18\xe3\x3b\x63\x69\x97\xf7\xa5\xee\x39\xb2\xe0\x19\xb2\xe0\xf9\xb1\x6d\xff\x01\xe7\xa1\xef\xf9\x0c\x98\xfb\xce\x0b\x1e\xbc\x91\xf7\xdc\x0a\xf7\x81\x02\x5c\xd3\xf5\xb0\x72\x79\x00\x7a\xa1\x8d\x63\x3a\x23\x1e\x05\x2f\xde\xbd\x01\xbd\x10\xbc\x7f\xeb\xa8\x13\xf2\x34\x63\xd1\x2b\x91\xbc\x52\xab\x2d\x6d\x35\x5d\xeb\x46\x6d\xd5\x9c\xeb\xfa\x2f\x3c\x0c\x3f\xc6\x01\x35\x99\xe8\x2a\x3b\x6f\x21\x9b\x11\xbb\xc4\x60\x47\x6d\x22\xff\x84\x75\xeb\x2f\xb7\xea\xfb\x94\xa9\x50\x76\x87\xbf\x5d\x7f\xc5\xbf\x5d\x5c\xc4\xca\xe2\xc4\x61\x9d\xb2\xbb\x4e\x9e\x6b\x16\x4d\x48\x34\x5d\x86\x9c\x0e\x68\x25\x45\x6d\x9c\xc1\xdc\x56\xba\x68\x27\xbd\x92\x7b\xcf\xc7\x14\x35\x7c\x13\x16\xc6\x24\x4b\xe4\x8a\x3e\xb3\x17\x7e\xfd\x8a\x22\xea\x26\x79\xab\x38\x2c\xf4\x5c\xc1\x49\xaa\x75\x6e\x41\x90\xbc\x8b\x8b\xec\xe4\xbe\x72\x5e\xf1\x96\x6f\x25\x25\x2a\xc8\x54\xb2\xd7\x2e\xb0\x03\xf6\xec\x8e\x8c\xb5\xb4\x6f\x22\x1f\x45\x2c\x01\x41\xa6\x19\x8c\x2e\x6a\x46\x72\xd1\xe4\x0c\xf9\x71\x38\x8e\xa4\x42\x04\xce\xad\x9b\xf8\xd6\xc3\xa8\xaa\xee\x39\x7e\x3b\x1d\x57\x7b\x5d\xf7\xa0\x2b\x84\x98\x2c\xe1\xb7\x8d\xfc\x8d\x56\xf1\x30\x72\x3b\xed\x38\xf5\x38\xa5\x1e\xb4\x13\xa2\xb3\x3c\x7c\x2a\xd9\x82\x37\x91\x27\x3c\xa9\x91\x9b\x68\x66\xb2\x60\xba\xa4\x04\x2a\x3f\x64\xaf\xb8\x46\x1a\x53\x2b\x88\xa9\x52\xd0\xd9\x8a\x55\x10\xbe\x84\x46\x5d\xd5\x8c\x3f\x94\xfc\xed\x43\x18\x63\x3e\xef\x10\x2c\x08\x85\x7c\xc3\xbf\x52\xb9\x5d\xa5\x20\xa9\x56\x86\xa4\xdf\xcd\x7d\xef\x71\xe7\xc3\xb8\xcf\x38\x03\x67\x0a\x4b\x60\xf5\x4b\xc3\x07\x86\xd2\x12\x68\xbf\x7d\x55\xe4\xc3\x39\xf7\x73\x03\xa8\xcb\x4a\x20\xd5\x9d\xdb\x07\x95\x85\x25\xb0\xfa\x41\xe1\x03\x43\xa9\x0b\xad\x94\x29\x16\x50\x15\xb8\x30\x5a\x5d\x62\x81\x74\x89\x07\xa5\x0c\xf0\x14\xc4\x3c\xbe\x1e\xff\x37\x77\xa9\x7b\x49\xdc\x6a\x33\xbe\xa9\xd5\x27\x7f\xe8\x35\xe6\xfc\x6d\xb1\x39\xeb\x44\xfe\xac\xe2\x7e\x74\xa3\xd3\xcf\x0d\xc5\xcc\xf8\xa7\xc7\xab\xa6\x48\xbf\xf2\x15\xdf\xe1\x9f\xde\xfb\xdf\x65\x1e\xe7\xb7\x86\x75\x1f\x4b\x0e\xa1\x9d\x9f\xe6\xe5\xa7\x28\x26\xff\xd4\x74\x81\xbf\xe7\xf1\x97\xe4\xe9\x67\xb6\x3a\xb3\x0d\xae\xe6\xe9\x57\xb9\x75\xfd\xfe\x3b\x69\x34\xda\xa4\xe6\x7d\xbe\x82\xbb\x1f\x5e\x7c\x8c\x9d\xd9\x95\xf7\xd1\xe8\xc7\xd4\x99\x60\xd8\xcc\xbf\x5b\x78\x60\x79\xff\x40\x58\x07\x9d\x09\x84\xe3\x74\x8f\xf7\x3c\xee\x06\x6d\xd4\xfa\xd7\x15\xe0\x95\xb8\xb2\xc6\x07\x4e\x36\x9f\xab\xe6\xc8\x39\xdd\xee\x38\xb3\xd0\x51\xcb\x3a\x53\x26\xb1\xf9\x76\x6a\xb0\x2b\xd1\x6a\x15\xe2\x44\xc0\x81\x55\x28\x2a\x69\xc4\xaf\xe8\x1c\xa3\xfa\xcf\xaa\x3b\xcc\x92\xbe\x5a\x5e\xbf\x17\xbb\xb4\x15\x8e\x42\xcf\x4f\xad\xe2\x2c\xf4\x60\xaa\x0f\x36\x0f\xac\xfa\x64\xcb\x83\x55\x1e\x6d\x1e\xe0\xc2\xb3\xad\x08\x5d\x7d\xb8\x15\x61\xab\x4e\x37\x0f\x72\xc1\xf1\x56\x84\xad\x3b\xdf\x8a\xd0\x85\x03\xce\xea\xfa\x0d\xdf\xfc\x40\x76\xf6\x48\x8f\x94\x1d\x62\x65\xce\x8a\x76\x45\xb5\x5d\x3e\xb4\xee\x8a\x9e\xc4\x7a\xd4\xd3\x67\xaa\x73\xc7\xb6\x4d\x14\xef\xa3\xf8\xe0\xf3\x5e\x31\xea\x5b\xb5\x77\x9f\x79\xd2\x2f\xf4\xe8\x73\x34\xcd\x65\xd9\xec\x3c\x83\x56\x54\x72\xe6\x8d\xc8\x4c\x69\xce\x06\xce\x94\xdb\x19\x06\xab\x6b\x34\x6a\xd0\x4b\xf8\xd6\xd5\xd3\xcd\xbd\x0a\xcd\x18\xd0\x93\xd0\xb3\x15\xc8\x79\x0f\xde\xfb\x53\x64\x09\xcb\x89\x1c\xc9\x33\x92\x2b\x71\x27\xb5\x20\xd6\x92\x1b\x63\xb1\xd4\x56\x29\xca\x5a\xc8\x33\x52\x2c\xbc\x11\xff\x22\x9a\x44\x3c\x1a\x57\x39\x6e\xdc\xcf\x03\xd6\xba\x16\x21\x88\x75\xc4\x11\x51\x46\x79\x54\xe5\x52\xb4\xb7\xff\xb8\x00\x5a\xeb\xa8\xa3\x60\x4c\x25\x1a\x04\x60\x0f\xff\x1a\x66\xae\xd2\x37\x68\xff\xd1\xa3\xca\x2a\x75\xed\xe5\x61\x6f\x26\xe7\x9e\xe7\x81\x03\x8d\x44\x34\x54\xbb\x05\xb2\x08\x8f\xc6\xf9\xad\xc2\xf2\xa5\x1b\x2d\xdc\x74\x36\x07\xd3\x8c\x95\x20\xdd\x44\x5d\x57\xa6\xcd\xaa\x1c\x2f\x0e\xc6\xcd\xd6\x5c\x20\x74\x6f\x4a\x56\xc7\x8f\x42\x84\x8c\x46\x06\xb3\x91\x8b\xaa\x99\xa8\xaa\x0a\x79\x19\x4c\x3f\x4b\x16\x4d\x93\x47\x69\x46\xa3\xa1\xdc\x3c\xf0\xd6\xd0\x36\x76\x6a\x36\x71\x0b\xcd\x32\x36\x8d\xb3\x12\x2b\x25\xf2\x0f\x72\x4f\xd2\xc0\xda\x18\xdd\x3b\x2d\xa4\xc0\xf0\x3e\xf6\xc8\x1e\x5c\x27\x97\x4e\x08\x01\x5b\xa9\x5a\x1d\x76\x1f\xd5\xfd\xae\x30\x3a\x69\x93\xc6\x1b\x9a\xb1\x84\xd3\x70\xe7\xe3\x61\x8f\x4c\x79\x0a\x09\xcd\x17\x54\x6b\xb4\x48\x8f\x80\x99\xc4\xee\xd3\x6d\xf5\xd1\xb3\x7a\x59\xad\x9f\x5e\x55\xaf\xaf\x92\xd1\x4a\xab\x58\x4b\x9d\x94\x65\x5a\xb8\x59\x54\x24\x19\x0b\x0f\x87\x8d\x21\x86\x47\x33\x10\x43\x20\x5e\x07\xcd\x14\xdc\xf0\x80\xcc\x06\xe0\xc5\xb7\x96\xde\x65\x1c\x3d\xbc\x66\xaa\x72\x34\x2d\xc7\xac\x40\xb3\x9d\x11\x8b\xe3\xa3\x40\xf6\x4c\xf3\xdf\xdf\x97\x99\x17\x8b\x71\x45\x7e\x6f\x1b\x3e\xbf\x4b\xf6\x7c\xd9\xfc\x02\xb6\xc1\xfc\x27\x72\xa5\xbc\x7a\x77\xf0\xf1\xa8\xff\xf3\xcb\x5f\x8f\xc8\x33\x72\x22\xdf\xab\xf2\xa9\xaa\x5c\xd5\xb4\x29\x82\x2c\x49\x87\xf2\x3f\x33\x78\x0d\x07\xea\xc9\x1c\xb2\x11\x3e\x78\xf9\x78\x92\x35\x4e\xdd\x2d\x86\xa7\xfa\xd8\x72\xb5\x67\x6a\xf5\xdb\x46\x3b\x10\xa0\xee\xdd\xa8\x59\x6b\x16\xd1\x02\x1e\xde\xd9\xf3\x77\x87\xe2\x01\xa9\xb8\xa3\xdb\x25\x87\x59\x23\x25\x94\x48\xd6\x0c\x19\xe8\x90\x2e\x18\xe6\xf6\x8a\x18\x8a\xc0\xb1\x36\x11\x72\x92\xb0\xce\xf3\x30\x15\xf8\x6c\x25\xa1\x18\xf3\x21\xe1\x29\x19\x86\x1c\xb2\x9e\xf1\x00\xab\x03\x9e\x00\xbc\x95\x00\x11\x25\x19\xa3\x89\x9c\x8f\x8e\x4e\x58\x61\xb6\x36\xb3\x3b\x6b\x02\xc3\x18\x0b\x27\x8e\x1d\xec\x05\x8f\x02\x71\x81\x52\x8f\xd9\x42\x05\x78\x61\x86\xbd\x97\x6d\xf5\xd6\xec\x1a\x2b\x69\xfd\xf7\x53\x7f\x3f\x37\x3d\x77\xc0\xaf\x6e\x5d\x6d\x25\x0d\xc4\xfd\x2f\x3c\xba\x84\x2e\x78\xf1\xf2\xf5\xf3\x5f\xfb\x1f\x0e\xdf\xbf\x7f\xfd\xf2\xc6\x83\x4e\x7c\x51\x21\x20\x32\x71\x20\xa2\x74\x36\x95\x6f\x0f\xb0\xf5\xad\x8c\x15\xf0\xb8\xa6\x52\x5d\x17\x8a\x2d\x7c\x8b\x3f\xf1\x2d\xfe\xc4\x9f\x22\xfe\x84\x86\x5c\x88\xfb\x85\x98\xda\x90\x09\x26\x0e\xf6\xbf\x12\x31\x8b\xab\x5a\x79\xfc\xb0\xaa\x46\x6d\xa0\x05\x1f\xf4\x4f\x97\xfc\xa2\x3e\x30\xc5\x83\xbd\x1c\x60\x1d\x76\x1b\x8e\xe2\x86\xdf\x7d\x2f\x3e\x7e\x78\x0e\x07\xed\x33\xf2\xe0\xc1\xee\x53\x2c\xf3\x0f\xa4\x8a\x73\xea\xf1\xee\xd6\x23\x23\xf8\xc1\xd6\x9d\xb8\x06\x74\x90\x8a\x70\x96\x59\x87\x7c\x71\xce\x92\x51\x28\x2e\x7a\xa4\x81\xb1\xd2\x1a\xe5\xc1\x02\x0a\x9e\xf6\xa5\x51\xfb\x75\x5a\x66\xbf\x34\x84\xc4\x0b\x36\x84\xbc\x88\x9d\x5f\xe5\x5e\xf3\xea\xe3\x6f\x5a\x68\xa6\x2c\x81\xe0\x3f\x85\xd4\x04\x36\x02\x7f\x09\xd8\x6b\x46\xcf\xe1\x39\x5e\x1d\xd3\x9e\x46\x7c\xaa\xa3\x15\x4c\x67\x7c\x07\xad\x07\x76\xd8\x25\xcf\x48\x83\xdc\xb5\xa4\xbe\x4b\x1a\xd3\x14\x8a\x8a\x19\x2b\x18\x95\x37\x5b\xf9\x1f\x76\x18\xbd\x9b\x65\x25\x5d\x79\x0f\xa6\x2a\x5e\x67\xea\x48\x53\x3b\x6d\x55\xb4\x5e\x81\x2c\x15\xc3\x56\x06\x35\x64\xef\xc1\xee\xee\xd2\xa3\x95\x53\x43\xf6\xa1\x02\x8f\x46\x3c\xe2\xce\x38\x10\xef\xbf\x39\x9c\x33\x6e\x2c\x06\x4b\x89\xce\xbe\x7f\xfb\xc5\xaa\x8d\x7f\x9e\xb1\xf9\x28\x81\xfd\xce\xa5\x0b\xbc\x84\x2c\xa2\xc6\xee\x7f\x79\x21\x1e\xa0\x9f\x23\x91\x4c\x7b\xa4\x91\x0e\x69\xc8\x9a\xbb\xad\x86\xc6\x6f\x02\x45\xc0\x54\xd4\x57\xdb\xb3\xd5\x96\xe9\xd6\x25\xcf\x6a\x7a\x95\x63\xd2\xda\xae\xd8\x89\x59\xa1\x7d\x45\xb7\x95\x26\x66\xaf\x64\x62\x1e\x2c\x9e\xce\xce\x93\x6b\x9d\xd0\x44\x49\xcb\x3f\xfb\x3c\xfc\x60\x37\xcf\xbf\xb6\xa4\x76\x6d\x14\x57\x78\xdd\x32\xcb\xed\x73\x0f\x9c\x15\x62\x83\xb2\xf4\x48\x43\x99\x6d\x42\x78\x96\x46\xb1\xfb\x05\xfe\x76\xb8\xfb\x9e\x97\x3d\x23\x3f\x25\x8b\xb6\x21\xc9\xee\xd7\xb3\x0f\x21\xc6\x57\x34\x75\x0e\x0d\xd3\xea\x0b\x93\x8e\xa7\x01\x0b\xf9\x66\x82\x90\x60\x84\x91\xd4\x84\x18\xc1\xd1\xe6\x23\x80\x20\x82\x84\x82\x81\x44\x36\xa1\x91\x86\x87\xd3\x43\x82\x3b\x41\x49\xf2\xb1\x48\x56\xf0\xf1\xff\x3a\x82\x71\x00\x35\x00\x8b\xc1\x41\x76\xac\x20\xda\x75\x07\xfe\xbe\x0b\x64\xf3\xc3\x81\xad\xeb\x0e\xeb\x60\x59\xe8\x0f\xeb\xc0\x6e\xcd\x21\x36\x17\x8f\x8c\xfc\xd9\x3d\x62\x9d\xf1\xae\xe2\x12\xeb\x4e\xd3\x75\xf9\xc4\x46\xec\x32\xfb\x99\xb9\x5b\xac\x8a\x29\xd4\x23\x27\x3a\x1f\x95\xaa\x0a\x0c\xca\xa3\xb1\x6b\x49\xe6\xb9\x8a\xc2\x0e\x70\xcc\xa7\xa0\x1d\x72\x7d\x41\xed\x87\x03\x31\x9d\xf2\xbc\xab\xa8\xbe\xa8\x3c\x2b\x75\x6a\x70\x50\x34\x3f\x5f\xb5\xc9\x67\xa2\xe0\x1d\xdf\x59\xaf\x9f\xa9\x32\x06\x2b\x43\x26\x39\x0a\x24\x7a\xe5\xea\x8b\x5d\x5f\x7d\xb1\x5b\xa7\xbe\xd8\x3d\x55\x29\x66\x2d\x66\x11\xc3\xd6\x5d\x8e\x7b\xcf\xc7\xbd\x57\x87\x7b\xaf\x88\x7b\x38\xf0\x78\x75\xff\xd4\xfd\xd8\x57\x2d\xff\xcd\x4e\xa5\x2a\xd1\x93\xeb\xea\xfd\x2d\x50\xb1\x5e\xae\x4b\xe8\xcd\xd1\x2b\x00\x7a\x31\x82\xf5\x37\xb5\xe7\xdb\xb6\xb1\xa0\x68\xe1\xea\xb6\xac\x4b\x72\x0d\xf7\x0b\xb6\xbc\x72\x7d\xe4\x06\xe5\x76\xac\xd8\x96\xf9\x34\xa2\x67\x56\x55\x61\x70\x38\xa5\x9e\x85\xa9\x07\x5c\x8e\x63\xd1\x24\x39\xc0\x7e\xc2\x06\xe5\xc3\x69\xe2\x14\x4d\xe5\x52\x02\x89\xbf\xf5\x48\x2c\x2c\xb3\xa2\xaf\x45\xe5\x4a\xb4\x36\x44\x15\x3e\x32\x65\x9d\xc8\xe4\xb6\xa2\x3c\xaa\x96\x6a\xca\x97\x72\xbb\x2b\xcb\xcc\x9b\x3b\x5d\x3f\xc0\x62\x97\xf3\x63\x04\x34\xc6\x7c\xc3\x71\x9b\xc0\x4d\xd5\xf3\x93\x49\x18\x88\x93\x98\x41\xd4\xed\x92\xbf\xc9\xeb\xca\x2b\x7e\xf9\x46\x9b\xaa\xe8\x80\x72\x63\x96\xfd\x28\x6f\x78\x3c\x1a\x1f\x80\x66\xe1\x03\x1b\x66\x4d\xc8\x03\x6d\xc6\xa4\x2e\xa4\xbb\x96\xe0\xfa\x46\xea\x14\xe5\xae\xa4\xfa\x52\xaa\x07\xec\x7a\x59\xff\x8b\xe1\xed\x05\xd2\xc2\xa9\xbb\x4e\xe2\xda\x9c\xc3\x28\xa0\xe0\x7f\xc8\x33\x47\x99\xe8\x7f\xfb\xb5\xe6\x1b\xa4\xa9\x7b\xe6\xea\xf6\x34\x1d\xed\xb2\x50\xee\x48\x30\xea\xff\x01\xa2\xc2\x46\xe6\x16\xff\xaa\x8a\x7f\xff\x9d\xdc\xf6\xc1\xef\xdc\xd1\x25\xc0\x08\xcc\xf3\xed\xb1\x7d\x7f\x43\xb3\x49\x07\xae\xd0\x4d\x49\x96\x0e\x4c\x25\xe9\x92\x7d\xc7\x2d\xd5\x8e\x26\x0f\x8d\xd3\xec\x81\x17\xec\xfc\xd0\x64\x53\x8d\x21\x37\xa6\x1f\x72\xbf\x7b\xc4\xeb\xf2\xc9\xee\xa9\xfe\xf4\xb4\x04\xdf\xaf\x39\x7c\xbf\xe6\xf0\xfd\x5a\x8d\xef\xd7\xfc\xe8\x72\x73\xa1\x3b\xb4\x03\xcc\xda\x91\xbc\xb3\x68\x42\x74\x9b\xaa\x4a\x06\x66\x99\x25\xeb\x14\xe9\x5b\xa4\x86\xe2\x08\xc0\x98\xfe\x5f\x92\x35\x9b\xfb\xe4\x7b\xfc\x19\x8b\x0b\x87\x3a\x6d\xb2\xdf\x22\x77\x73\x5f\x90\x12\xf2\x53\x8b\x74\xc9\x3d\x6b\x11\x8a\x0e\x74\x22\x21\xa9\x98\x32\x92\x30\x9a\x0a\x0c\xe3\x64\x1e\x16\x84\xa7\x64\x90\x88\x33\x50\xed\x91\x37\x62\xc0\x43\x46\x0e\x26\x89\x84\xe7\x23\xbb\x10\xf8\x08\x66\xb3\x63\x10\xcb\xd1\x38\x7d\xff\x2f\xb2\x8f\xdc\x98\x73\x80\xb6\x10\x77\x9f\x91\xbd\x12\xe3\xce\x32\x8e\x91\x2d\x1a\x9a\x4c\xe9\x65\xd3\x1d\x4e\x61\xb3\x20\x08\x47\x07\x69\xb3\x69\xb7\x15\xbd\x85\x20\x65\x20\x3f\x28\xe9\xc9\xee\xed\x68\xa2\xb7\xda\xe6\x2f\xf2\x3d\xd9\x27\x77\xc9\xfe\xd3\x42\x37\x7e\xbd\xd6\x6e\xfc\x84\x4b\xc6\xeb\xc7\xaf\xa6\x1f\xbf\x96\xf4\xa3\x82\x3d\x0c\xfd\x61\xaa\xf2\x4c\x01\x1d\x07\x76\x28\x73\xa8\x84\x2b\x27\x23\x01\x3b\xe7\x43\x56\x12\x8d\xa0\xb8\x63\x74\xbb\xe4\x7d\xc2\x62\x9a\xb0\x62\xcc\xb9\x4e\xee\x70\x29\xb9\x17\xd6\x87\x6b\x80\x0a\x08\xdb\x74\xee\x81\xfa\x52\xa2\x69\xd4\xd3\x7f\x98\xd9\xd2\x25\xbf\xb6\x9d\x59\xea\x39\x7f\xb7\xc9\x70\xd0\x93\x97\x2c\x2f\xd5\xc7\x53\x77\x58\x2f\x58\x1c\xd2\x39\x8c\x8a\x5d\xb2\xe1\x0c\xba\xe9\x6d\xfa\x0b\x87\xb9\xc8\xf2\xa2\x6e\x72\xdc\xe0\x02\x35\x13\xe8\x3a\xb1\xc1\xa5\xd8\x15\x5a\xb7\x20\xec\xf0\x2f\x0c\x43\xf1\x65\x82\x4c\xe9\x19\x23\x94\x64\x09\x0d\x98\x18\x8d\x30\x3a\x1b\x3c\x6e\x30\x8d\x5b\xd5\xca\xfb\x03\xc8\x71\x55\x72\xcb\x2f\x61\x9b\x98\x26\x74\x9a\xfa\x37\x7e\x7b\xe1\xc5\xaf\x65\x97\x62\xbb\xbb\x2b\x18\xdd\xe7\x02\xcc\xaf\x79\x98\x5f\x8b\x30\x6a\x11\x7a\x60\x30\x2e\xf7\x2e\x3c\xb0\x10\xc3\x81\x67\x7c\xaf\xe3\xba\x3e\xf3\xa2\x54\xa8\x52\xf7\x02\xf2\x3c\x08\x08\xd5\xdc\xa7\x43\x89\xa9\xca\x54\xbe\x8c\xfd\x47\x1d\x79\x46\x4e\xcc\x0b\x11\x1e\x9b\x45\xdd\xb1\x7d\x6f\xaa\x4a\xad\x36\x39\x59\xe0\xff\x57\xe3\xfa\x07\x2e\x74\xee\x28\xd4\x8b\xd3\xb1\x12\x36\x12\x17\xf7\xce\x9f\xf7\x52\xcb\x70\xd1\xf4\xbc\x95\xc2\x2e\x79\xd6\x33\xe2\x34\x77\x72\x95\xc0\x48\x7f\x72\x16\x84\xf9\xb3\xc0\xaf\xf9\x93\xde\xf2\x6d\xfe\x40\xb7\xfc\x5b\xb2\xf9\xba\x7c\xac\x79\xb7\x75\x6a\x0f\xda\xbc\x0f\xbd\x41\x61\xde\xe2\x25\xd3\x45\xee\xda\xb4\xc4\xce\x1b\x5d\xfd\x71\xcb\xac\xf6\xe1\xa0\xf8\x1c\x16\x25\x31\x55\x00\xb2\x2e\x70\x80\xdd\x5a\x5a\xc5\x4b\xe9\x12\x9c\x79\x3c\x91\x0c\x39\x1b\x4e\xbc\x30\xc3\x62\x38\x9c\x25\x2c\x95\xac\xfa\x7f\x33\x3e\x3c\x0b\xe7\x1d\x5b\xe5\x17\x46\xd2\x8c\x87\x21\xb9\xa0\x51\x26\x41\x20\xf5\x67\x6e\x6b\x5d\xf4\x90\x61\x51\xe0\x87\x77\xf1\x36\xc8\x92\xf0\x15\x55\xa1\x5b\xea\xf6\xdf\x25\x77\xdf\xcd\xb6\x7f\x1b\x32\xc6\x10\x55\x11\x76\xb7\xb5\xf0\xa1\xb7\xa0\x87\xce\x2c\x6a\x8a\xde\xb9\xa3\x89\xab\x64\x16\x75\x71\x51\x0a\x1b\x9e\xe5\xc5\x4e\x1a\xf2\x21\x6b\xee\xb5\xdc\x1e\x3b\x23\xb8\xb9\x60\x00\x9e\x98\xb3\x3c\x1a\xc0\xc6\x1e\xe4\x45\x3f\xf1\xc2\xc2\x51\x34\x71\x5c\xc4\x47\x3c\x04\xe1\xf8\x2c\x23\x20\x01\x20\x6c\x3a\x0b\x69\xc6\x02\xe4\xc9\x54\x5e\xaf\xa7\x70\xbd\xee\x98\xba\xbf\x30\x15\x6f\x39\x03\x4e\xe2\x11\x01\x75\x87\x44\x07\xb6\x77\xb0\x56\xdc\xed\x1f\x02\x39\xc3\x02\xfc\x6e\x18\xf2\xe1\xd9\x77\x24\xe4\x67\x4c\xb5\xd0\x71\xd0\xa2\xc9\x9d\x5e\x73\x4a\x1f\xe9\xde\x6a\x2c\xa6\x74\x98\x88\x30\x34\x38\x6e\x99\xb5\xce\x53\xf9\x38\x90\x75\x26\x42\x9c\x81\x15\x25\x0b\xc0\x00\x10\xa5\xfb\x09\x3b\xe7\x62\x96\xea\x5d\x5c\x02\x43\x3c\xb2\x4e\xa5\x1f\xfc\x4a\xee\xd6\xcb\xb8\x55\xe7\x1d\xaa\xd7\x76\x92\x5e\xe0\x20\xbd\xa1\xf3\x67\xa5\xab\xa7\xeb\xdd\xb8\x62\x2e\xb3\xbc\xc5\xca\xf2\x09\xcd\xdc\xf1\xdb\xe8\xdc\xc5\x54\x5f\xda\x01\x3f\xf1\x13\x41\xe2\xf9\x9c\x2f\x5d\x29\x49\x1f\xba\x65\x96\x64\xe5\xd3\x29\xd4\x5a\x39\xef\x22\xef\x44\x52\x9f\x2a\x9d\x8b\x9c\x2d\x62\xa1\x77\x91\x2b\xb5\xaf\x74\x2f\x72\x7c\x02\xd6\xf3\x04\x1a\x85\x3c\xd6\x2e\x07\x8e\x5b\x90\xd3\x38\xf8\x05\xe5\x54\x26\x39\xc3\xcf\x07\x1b\x19\x7e\x22\x60\x47\xc1\xc9\xe1\x91\xef\x54\x4f\xbf\x2b\xd7\x68\x3d\xb8\xff\xb0\x25\xf1\x69\xfb\x1b\x2d\x9a\x2f\xf6\xec\xe1\x46\x3d\x2b\x35\x2c\x7b\xf8\xb0\xf5\xb4\xf4\xcb\x83\xfb\x8f\x5a\x4f\x8b\xa3\x29\xb5\xb7\xba\xd7\xea\xc0\xf5\xb7\x33\x4a\xc4\x54\x2e\xb4\x5c\xbf\x1f\x5d\xa7\x29\x2d\x48\xa6\xb2\xcb\x2a\xbb\xa9\x27\x2d\xb4\x42\xfa\x1b\xe2\xad\x74\xb5\x51\x60\x99\x40\xcb\xdc\x2a\x9f\xa5\x7b\x0a\x4e\x6e\xca\x55\xb8\xc0\x54\x0b\xbc\x60\x52\x98\x86\xc3\xac\xda\xc5\x07\xd2\xff\x60\xc3\xaf\x51\xb9\x51\x65\xd1\x78\x5f\xb7\x0c\xfb\x92\x36\x19\xae\xcc\x63\xf4\x58\x81\x8f\x59\x26\xdb\x7f\x15\x55\xf6\x00\xc4\x56\x6a\x7a\x9a\xea\xbf\x9d\x23\x72\x57\x4f\x59\xe7\x15\xf9\x9e\xdc\x2e\x6f\xe5\x49\xcb\xb9\x79\x71\x94\xb0\x11\x4b\x7b\x2c\x7a\x0a\x91\xab\x1a\x50\xdc\x68\x6b\xcb\xf7\xfd\xfd\xce\x5e\x67\xbf\xb3\xe7\x82\xc3\x2b\xeb\x35\x3f\x63\x6d\x32\xa5\xf1\x28\x72\xed\x97\xd1\xe2\xfd\x79\x32\x76\x0b\xe5\x0e\x26\x6b\x3a\x87\x9a\x8f\x88\x74\xbf\x27\xcb\x22\x23\xdf\x77\x5d\xa5\xec\x3b\x79\x06\x2a\x76\xb0\x08\xd5\xee\x07\x5e\xdd\xca\xbb\x19\xc4\x16\x3c\x25\xf9\x64\x09\x50\xd8\xc3\xf1\xd9\x5a\xf4\x75\xa9\x0e\xd6\x02\xe8\xce\x02\xe0\x3f\xc8\x5e\x51\x99\xe5\xd8\x74\x3b\x95\x62\xb4\x83\xc7\xea\x9e\x3a\xcc\x82\x71\x15\x8d\x61\xd7\x29\xd2\xdc\x61\x38\xa5\xf9\xce\x19\xa4\xd6\x10\x27\x2c\x85\xc7\x68\x9a\xb1\xb8\x0d\x95\x68\x26\x12\x65\x8f\x3f\x22\x4d\xd5\x81\x96\xe9\xfe\x30\xbb\x6c\xc2\xdf\x6d\x3d\x92\x7d\x6f\x24\xfb\xde\x48\xda\x46\x98\xdd\xed\x4a\x7c\x78\xd6\x13\x9e\xca\xeb\x14\xb4\x36\x08\x19\x11\xb2\xbb\x0d\xf5\x1a\x47\xf9\x8a\x3e\x10\x74\x8f\xc8\x0e\x5c\xed\x52\x3e\x95\xb7\xad\x21\x55\x31\x89\xc1\x11\x01\x47\x7a\xdb\x25\xf9\x9d\x3b\xe4\x76\xf3\x40\x92\x0e\xc8\x24\x7f\x3b\xab\x56\x55\x71\x9d\x69\x40\x97\x6e\x1a\x7b\xa6\xa6\x0f\x9d\x0a\xde\xb5\xf4\x3c\xc9\xb7\x01\xbb\x20\x07\xcd\xd6\x53\x72\xbb\x29\xe7\x4c\x81\xca\x5a\xf0\x0c\x6d\xb6\x5a\x9d\x40\x44\xec\x29\xd2\xc4\xd5\xa8\x93\xdc\x1a\x6f\xea\xb9\x07\xc8\xb6\xa1\xf5\x0f\xb0\x0b\x99\xce\x28\x36\x6f\x93\x13\xd9\x9e\x4a\x24\x8d\x75\x4e\xdb\x70\x86\xb4\x48\x8f\xd8\x6f\xf9\x47\x84\x2f\x96\x0a\xf5\x6e\xa4\x37\xa6\xe6\x3b\xfd\x94\x79\xea\x4e\x45\x6e\xbc\x1a\x84\x18\x55\x2d\x74\x60\xa3\x51\xc2\xb0\x9a\xef\x4e\xf4\x50\xe0\xbf\x72\x2c\xba\xa8\x24\xca\x15\x51\x84\xe8\x98\x71\x60\x3f\x6e\x39\x37\x3e\x84\x50\x3e\x23\xad\x92\x73\xea\xf1\x75\x9f\x53\x7f\xf3\xfd\x3d\x2a\xb6\xe4\x7b\xfb\xde\x56\xff\x82\xa5\xc3\x2a\xff\x01\x70\x20\x28\x1c\xca\x76\x4b\x56\x06\x36\x7a\x4e\x91\xee\xc6\x7b\x12\x77\x03\x1e\xa9\xd5\xd6\xca\xf7\xaf\x33\xca\x23\xb0\x3d\x92\xd7\x2f\x44\x07\xb3\x0f\xbc\x83\xc0\x8a\x28\xe4\x19\x7e\x47\x33\xa9\xfc\xd4\x3e\xd9\x68\x6a\xe5\xe4\x1c\x1e\xbf\xfc\xf0\xfc\xf8\xdd\x87\xaa\x49\xdc\x6d\x35\x1b\x7a\x69\x34\xd4\x84\x1e\x3d\x7f\xf5\xb2\x7f\xf0\xfa\xdd\xd1\xe1\xdb\x7f\x59\x35\xef\xad\x2c\x99\x1b\x8f\xcc\x84\xe3\x69\x7d\xf2\xe8\xf4\x44\x37\x71\x8a\xe2\x0a\xf8\x74\xd2\x40\xee\x69\x9c\xe6\x05\xec\x79\xec\xa0\xd9\x45\xb1\x77\xb7\x4b\x58\x1a\xf2\x28\xdb\x51\xae\xf0\x3b\x72\x0b\xd8\x09\x79\xc4\x48\x24\x76\xb2\x49\x22\x2e\x76\x42\xe8\x6d\x78\x8b\xb8\x27\x22\xb4\x99\x0b\x50\x49\x00\x9e\xec\x3f\x05\x81\xee\x15\x19\xd2\x6c\x38\x21\x4d\x49\x58\x79\xdc\xb1\x69\x9c\xcd\x89\x9c\xec\x5a\xd6\x60\x97\x6c\xd8\x26\xe9\x19\x8f\x0f\x42\x91\x1a\xef\x2f\x70\x0d\x73\x4a\x61\x87\x74\x47\xd6\xd2\xcb\xc7\x28\xc9\x41\x65\x43\x47\xcc\x55\x9c\xeb\x29\x55\x67\x5e\xa2\xa6\xd4\x3f\x76\xe0\x18\x4c\xf2\xd3\x4c\xe0\x1b\x6c\x92\x85\x29\xd6\x76\xde\xf2\x9d\xcd\x7a\xba\x55\x75\x3f\xd6\x2a\x06\x0f\x67\x15\x0a\xd9\x86\xa9\x21\xe7\x42\x1e\xf1\x28\x09\xa9\x99\x50\xb3\x77\xc8\x96\x4b\x39\xfb\xc1\xee\xb5\xfa\x89\xe9\x77\x8f\x63\x8e\xaf\x6d\x06\xf4\xa7\x31\xcb\x0e\x26\x3c\x0c\xde\x98\x2b\x40\xae\xc4\x82\x4e\x59\x32\x66\xee\x27\xc9\x12\xc5\xc2\xa5\x5d\x50\x94\xb9\xdd\xbf\xf8\x39\x8b\xc8\x27\x57\xe2\xac\x82\x55\x7c\x6a\xeb\x09\xa3\x7a\x97\x31\x1b\xfb\x19\x83\x3c\x1e\x00\xda\xb9\x45\xd0\x70\x0f\x44\xf8\xe4\xf3\xf7\x57\x36\x22\x5b\x29\x5e\x00\xd6\xdc\x80\x88\xaf\x88\x9e\x01\x31\xf2\x90\x83\xc1\x9f\x61\x82\xdc\xe4\x34\x4d\x5c\x0d\xd9\xb1\x57\x91\xf5\xcd\x9e\x62\x4a\x6f\x87\x7f\xb0\x04\x6b\xe8\x83\x4c\xf5\x01\xea\x9a\xb0\xd9\x30\x71\xb9\x0c\xfe\x2d\x5d\xef\x07\x04\xd6\x3f\x7b\xd8\xc9\xa7\xb7\xb4\x39\x04\x1a\x6b\xa8\x53\x55\xf9\x09\xe2\xbe\xdb\x8c\x66\x61\x08\x3c\x0a\x2a\x6d\xd5\xf1\x96\x6e\xef\x40\x15\x74\xa6\x34\x76\x86\x65\xd9\x7f\x98\xeb\xf4\x10\x1a\x6d\x75\x46\x22\x79\x49\x87\x13\xe7\x2a\xef\x0d\xb1\xdb\x25\xc9\x0c\xd5\xd7\x53\x1a\x5b\x7c\x13\x96\x30\x70\xe0\x65\x34\x20\xa9\xc0\x14\x2d\x12\x4a\x85\xc9\xd7\xc6\xaa\x33\xc8\x1a\x18\x31\xe7\x58\x3e\x41\xaa\x2b\xab\x41\x6f\x5e\xb1\x4f\x8e\x58\x41\x1f\xd3\x57\x86\xdf\x7e\x99\xb0\x88\xcc\xc5\xac\x91\x30\x42\x83\x00\x48\x2e\xe7\x6c\x2a\xce\x21\xf4\xbe\xe6\x1c\x50\xbe\x4f\xe9\x9c\x0c\x00\x4e\xf6\x42\x81\xb1\x40\x1e\x7b\xd9\x84\x49\x74\x29\x05\x1d\x7d\x14\xb0\x04\xb2\xca\x74\xc8\x2f\xcc\x17\x9b\x7f\x3f\x10\xd9\xe4\x7b\x92\xf2\x68\xc8\xc8\x85\xf3\x91\x4f\x67\x61\x46\x23\x26\x66\x69\x38\x97\xb8\x50\xbf\x6f\x63\xce\xcb\x66\x68\x04\x49\x13\x3b\x28\xda\x33\xd3\x97\xd1\x33\x96\x12\x6a\xe5\x79\x29\xcb\x14\xeb\xa6\x88\x2a\x20\x14\xae\x55\xce\x07\x28\x85\x15\x0b\xf3\x3b\xc5\x4b\x30\x87\xb4\x03\x69\x46\xc6\x33\x96\xa6\xd6\x50\x38\x49\xd8\x30\x93\xb8\x40\xbc\xc9\xa3\x71\x87\x1c\x22\x21\x47\xb3\x6c\x96\xc0\x58\xe4\xfc\xc8\xfd\x41\xee\x3b\x72\xbe\x54\xe5\x59\xc6\x43\x9e\x71\x26\x47\x20\x31\x80\x61\xeb\x9b\x59\x98\x71\x60\x33\xa3\xef\x84\x47\x0e\xa3\xe9\x1c\x42\xdc\xa8\xf8\xfb\x17\x08\x2e\xfb\xc5\xc2\x11\x09\x04\x4b\x49\x24\xa0\x27\x01\x97\x7d\x0a\xe7\x4a\x6b\x2a\x6b\x0f\x45\x34\x64\xb1\xc9\x70\x38\x8b\x94\x2e\x58\x4e\x8c\xe6\x69\x18\xb7\x3c\x12\x74\x01\x10\x0e\x92\x66\xc2\x4d\x1f\xb4\xfe\x3c\x03\x9e\xcc\x6f\x26\x7a\x7b\x90\xf8\xf0\xff\x0c\x87\xd0\x54\x71\x19\x0b\xe0\xe1\x28\xab\x7d\x82\xbe\x5b\x31\x9f\xbb\x5b\xe4\x37\xdb\x66\xeb\x53\xa7\xac\x29\x38\xbc\xe0\xff\xae\xbf\xa9\xfc\xae\x07\xf9\xbf\x80\x47\x60\x01\x9a\xe0\x25\x34\x0c\x91\x65\x78\x44\x3e\xc9\x61\x7f\x42\x96\x52\xc5\x12\x97\xfc\x22\x7b\xf9\x09\xd8\x54\xd9\xa9\xa8\x97\x56\xc0\x92\x8e\xbf\x73\x16\x0f\x8a\xa6\x44\x8b\xb1\x70\x71\xb3\x80\xd9\x7d\x86\xff\xf9\xfd\x77\x65\x75\xa9\x4e\x72\xf8\x8f\x2a\x74\x8d\xa2\xc7\x2c\xfb\xb7\xbc\x28\xbe\x12\xc9\xcf\x6c\xde\x3c\x63\xf3\xdc\x36\x05\xdb\x49\x84\xf5\x7f\x80\xff\x9c\xc0\xc6\xd1\x83\x76\x4e\xb4\xa1\x31\xa8\x06\x94\xd9\x0d\xa3\xc3\x09\xd4\x13\x23\x35\x42\x34\xaf\x0f\x79\x6a\x97\x52\x26\xe4\xee\xc5\x92\x8c\x0c\xd8\x48\x24\x2a\xc7\x14\xb6\x86\xa8\xd4\x0e\x36\x80\xa7\xa2\xac\xab\xb6\x67\xa5\x47\x4c\xdf\x33\x30\x91\xab\xda\xa7\x15\x74\x8c\x50\x2a\x5c\xce\x09\x74\xd6\x98\x64\xcb\x21\xfc\x8c\x03\x94\x7f\xba\x61\x23\x9c\x4f\x76\x86\xcd\x47\x8b\xb4\x44\xc5\x94\xeb\xe0\x89\x42\x25\x37\x5b\xa7\xa2\x55\x7c\x95\x75\xb1\xf2\x69\xe8\x36\x1d\xcf\xd2\x89\xee\xa8\x2b\x18\xd6\x63\xe7\x9e\x35\x1e\x3c\x6a\xfc\xbb\x0a\xb2\x88\x99\x0e\xad\xa1\xcd\x8d\x59\x8e\x38\x3f\x26\xf5\xfb\x34\xff\x36\x47\x9b\x75\x4e\xfe\x5e\x98\x05\x5d\x43\x8b\x5c\x08\xf7\x1f\xa4\x0e\xb1\xde\xaa\x7e\x3c\xab\x44\x72\xc2\x4f\xed\xfc\xb9\x83\x3a\xa9\xa9\x71\x8a\xb7\x33\x97\xdf\xfd\x06\x4b\x9f\xb2\x65\xd8\x4b\x30\x45\x0e\x0a\xb3\x18\x78\x44\xc3\x70\xde\x96\xe7\x9f\x3e\x9b\x53\x72\x31\xe1\xc3\x09\x09\x78\x10\x35\x32\x95\xb5\x58\xaf\x01\x1a\xcd\xf5\x82\xc3\x85\x73\xab\x38\xaf\x45\xde\xf3\xa6\xd2\xeb\xae\x03\x5b\x3b\x7e\x05\x50\x08\xc0\x33\xf4\x2e\xb2\x57\x85\xeb\xf6\xde\x97\x15\x96\xe1\x06\x62\x2c\xf8\x9d\xab\x6a\xe3\x51\x05\x7c\x5d\x53\x39\xcc\x5f\x66\x54\x87\x6f\x81\x15\xbe\x05\x56\xf8\xf2\x02\x2b\xdc\x44\x10\x02\x7b\x4f\xac\x5a\xf3\x65\x71\x15\x96\x0b\xa9\x70\x23\xb1\x02\x36\xf5\x95\xfc\x3a\x1c\x11\x97\x49\x1b\xad\xac\xe4\xd2\x36\xc9\xe6\x31\x1f\xca\x23\x9a\xf0\x28\xe0\x43\xf0\x84\xd7\x07\xb5\x9b\xd9\x19\x7d\xcd\xc4\x88\xd0\xc8\x4b\xfb\x0f\x5d\x33\xd6\x77\x4b\xfb\x74\xbe\xe0\x74\xca\x1c\xa7\x52\x37\x71\x34\xa4\x4a\x75\x2c\xf0\x6a\x13\x99\x3a\x69\x46\xfd\x16\x7e\x12\x09\xff\x4d\xbe\x45\x42\xe3\x68\x9c\x33\xf0\x45\x25\x7f\xbe\xcd\xff\x59\xb7\xc1\x7f\xcb\x93\x62\xb8\x6a\x73\xbf\x2e\xdf\xdc\xad\x2b\xb0\xf8\x55\xe1\x2e\x56\x72\x35\xdd\xd8\xcb\x74\x49\x07\xd3\x2d\xfb\x96\xfe\x85\xdc\x4a\x57\xf7\x28\xbd\x66\x67\xd2\x9c\x03\xbd\x89\x9b\x69\xbf\x99\x20\x1e\x25\xa9\x57\xc7\x2c\xc3\xfe\x1c\x15\xa2\xa7\x34\x41\x94\xea\x1b\x7d\xf9\x86\xd6\x18\x52\xbb\xd4\xce\xda\xb1\xec\x76\xa0\xaa\x0c\xbb\x1d\x90\x5f\x0b\x06\x57\x05\x4f\xb2\xb2\x16\xb5\x4b\x59\xd9\x37\x70\x25\xdb\x71\x9d\x61\xba\xe8\x8f\x51\xb0\x27\x46\x2f\xb4\x6a\xd0\xff\xd1\x8f\xae\x9c\xb9\x2f\x86\x87\x7e\xa9\x2c\xde\x6a\x1c\x6a\x8b\xb6\x9c\x39\xf2\xc1\x03\x41\x35\x92\x37\x2a\x56\xad\x5c\x56\xfa\x6c\x2c\x68\xc4\xf0\x41\x55\x23\x5b\x36\x0d\x2d\xb5\x0a\xdd\x28\xcf\x8b\x17\x77\x7f\x7f\xa5\xac\x2f\xd7\x9c\xa1\xc5\x71\xef\x45\xa8\x5a\x6f\x87\xfe\x12\x8b\xc2\x83\xa9\xf6\x76\xe8\xd7\xad\xc2\xf5\xcd\x22\x2b\xf2\x5e\xe8\x30\x29\x10\x23\x13\x3a\x6f\xff\xfc\xd5\xfe\x29\xfb\xd1\x38\xf5\x6c\xd8\xfb\x7a\xdf\xb2\x9b\x58\x71\x4c\x6a\x19\xc8\x61\xb9\x16\x85\xaa\xb8\x08\xaf\x38\x3a\x0f\xaf\x8a\x37\x49\x4c\xa1\x82\x0e\x5d\x57\x6e\x0a\x3f\x9c\x52\xdb\xef\xfe\x6a\x69\x2a\x72\x28\x4d\x58\xa4\xb6\xe6\xc1\x55\xb2\x51\x60\x3f\x0e\x56\xcb\xd9\xa1\x96\xb1\xdb\xad\xfd\x55\xa7\x66\xdf\x0e\xc4\xa7\xb1\xcf\x09\xab\x4c\x4d\x01\xe5\x2b\x9a\x66\x15\xb3\x02\x9e\x77\x9b\xda\xf5\xae\x60\xd2\x4b\x44\xf4\xd2\x49\x97\xe5\x9c\x17\x6d\xf9\x09\x2d\x76\x73\x7b\x7c\x89\xad\xed\x92\x7d\x24\x25\xc6\xc2\x9f\x4b\x33\x0f\xf8\x29\xbd\xea\xd1\x2b\x9c\x3e\xa6\x1c\x03\xb5\xf1\x99\xa5\x06\x93\xbb\x5c\x38\x49\xef\x5a\xe4\xca\x1a\x15\x2f\xcc\x46\xb0\xa4\xad\x70\xb5\x99\xb0\x79\xf7\xd4\xd8\x09\xeb\x46\xf2\x82\xc3\xfd\x2f\x4b\x70\x68\x7d\x24\x8a\x09\x4c\xdd\xd8\xca\xe7\x2c\xca\x90\x22\xe8\x05\x64\x7d\x8f\xb4\x59\x86\x51\xcf\x22\xcb\xc9\x0a\x7e\x58\x5e\x50\x1e\xbb\x0e\x4b\x03\x34\x5f\xcb\xb5\xe2\x7b\x5c\x58\x1f\x21\x43\x07\xf8\xe9\x66\xb8\xcb\x1b\x86\x78\x95\x4d\xa4\x67\x64\x2d\x47\x9b\xe1\x7f\x38\xc1\x71\x9d\x36\x2b\x3a\x61\xc0\xf1\x22\x70\xe7\x8e\xb6\xc1\xf4\x3f\x9c\x34\x44\xd4\x20\x77\xed\x84\x9d\xa2\x5f\x93\x31\xd0\x2c\xe9\x40\x45\xc5\xb2\x9e\xa8\xa1\x9a\xa0\xc3\x20\x9a\x2e\x32\x5f\x09\x31\x8b\x9c\xf8\xe7\xc8\x3c\x61\xc2\x34\xde\x6c\xc4\xe1\xbf\xb8\x34\x1c\x1f\xf7\x5f\xb7\x5c\xf3\x26\x82\xab\x4e\x58\x18\xb3\xa4\x72\x10\xf7\xbf\x34\xf9\xe7\xdb\xea\xbc\x29\x7b\xad\xce\x2a\x48\x7e\xff\xbd\x4a\xc0\x45\xa3\xf9\x96\x62\xae\xce\x52\x96\x1c\xb1\x90\x0d\x33\x1d\xbb\x54\x3d\x46\x51\x3f\x28\x42\x91\x3c\x1f\x0e\xc1\xfd\xc9\x1c\x42\xb2\xb0\xa7\x42\xf7\xc5\x34\x64\x59\xc6\x3a\x29\x1b\x8a\x28\xa0\xc9\xbc\xf3\x7c\x7f\x77\xb7\x04\x07\x86\xe6\xab\xc5\xa1\xc2\xdf\x61\x76\x84\x02\x8a\x03\x11\x65\x89\x17\xfa\xaf\x14\xc9\x98\x65\x1a\xf2\x98\x5d\x66\x4d\xff\x6b\x9c\xf0\x29\x4d\xe6\x27\x0f\x76\x77\x4f\x5b\x85\x26\x5e\xa8\xec\x51\xcb\xf5\x53\xe7\x9a\x2a\xa0\x79\x99\x24\x22\x59\x80\x83\x49\x18\xe8\x46\xa1\xfa\x7b\xec\xe3\x02\x04\xee\x48\xec\xa5\x6d\xe5\x48\x87\x10\x0e\xb2\x82\x7d\x77\x5b\x1d\x11\xb1\x77\xa3\xe6\x89\x8d\x9e\x4b\x1a\x14\xd8\x01\xff\x82\xe3\x19\x92\x31\xe2\x8c\xe7\x73\x31\xc2\x28\xe1\xd5\x8a\xbd\x45\x6f\xbe\x4d\x95\x0b\xc7\x13\x06\x2e\x62\x5a\x6a\xcc\x87\x90\x80\x26\xca\x48\xc8\xc7\x34\x9b\x25\x8e\x74\x5c\x1b\xf5\xf4\xf4\xdd\x63\xa5\x55\x9d\xf7\x13\x59\xa5\x72\xb5\xee\x61\x42\x63\xd6\x5c\x01\x55\xeb\x6b\x0c\xf2\xe8\x63\x39\x06\xf3\x1c\xc9\x6a\xf9\xd0\x98\x1d\x4c\xac\x31\x4b\xb5\x36\x05\xd8\x9c\x28\x36\x27\x17\x13\x16\xa1\xb5\xcf\x14\x8c\xf0\x52\x16\xa5\x2e\x79\x71\x69\xdc\x18\xf7\xa2\x1d\xb1\xd9\x6a\x0f\x87\x78\x47\xd3\x42\x5a\x63\x35\x83\xf9\x89\xcb\xd3\x13\x5b\xc1\x57\xa9\xdc\x2b\x2f\xf3\xaa\x10\x79\x0d\xd5\xc2\xd5\xb9\x88\x43\x61\x5c\x7b\x57\x94\x39\x59\x91\xd3\x52\x69\x57\x43\x91\x18\xa7\xdc\xe5\xa5\x3a\x8d\xa9\x4e\xf1\x23\x57\xab\xc4\x9b\x4b\x40\x5a\x2b\x63\xf8\x7c\x65\xe0\x4f\x54\x17\xc8\x5d\xac\xa3\xae\x0b\x9d\x21\x8d\x79\x46\x43\xfe\x1b\x7b\xc5\x93\x34\x7b\x2d\xb9\x27\x69\x35\x01\xb8\x75\xda\x56\xf3\x05\x69\xa7\x34\x3b\x94\x0b\x66\x96\x17\x46\xb8\x4f\xfc\x4a\xb1\x43\xd9\x9b\x5f\x72\x5f\xc2\xe9\x8e\x8a\x58\xde\x23\x0d\x79\x47\x6f\xe4\xe5\x0d\x43\x63\x40\x49\x30\xbb\x8e\x64\x37\x78\xfa\xc0\x26\x81\xc4\x5f\x2e\x39\x93\x52\x95\x7c\x5e\x7a\x13\xf0\x74\x77\x37\xbf\xce\xf2\xcd\xff\x19\x76\xf1\x5b\x8b\xa5\x73\xa0\x83\x72\xd6\x5e\x2d\x89\x16\x4b\xe6\x1c\x74\x6a\xfd\xd6\x6e\xd9\x4b\x23\x84\x05\x58\xdd\xbb\x6b\xe7\x86\x16\xa8\x38\x46\x2d\x15\x1d\x14\x96\x41\x99\x2b\x3a\x32\xa9\x69\x18\x36\x6b\x00\x9e\xce\xb8\xda\xa1\x1a\xf2\x77\xe3\x69\x99\x04\x60\xb5\x84\x95\x80\x87\x5c\xb5\x9a\xf2\x8f\x56\xed\x73\x7e\xdd\x44\x46\x0f\xae\x33\x91\xd1\x97\x28\x6e\xf8\x8b\x4b\x04\xb6\x2a\x6d\x01\x71\x43\xb7\x4b\xfe\xa9\x56\x03\x0b\x8c\xa4\xd6\xc9\x2d\xfb\x4d\x20\xb1\x58\x20\x01\xdb\xca\x1b\x1a\xf1\x78\x16\x2a\x57\xe2\x72\x6b\x37\xcb\x2d\x76\x82\xab\x68\x5b\x06\x5b\xd7\x2f\x3f\x21\xee\x5f\x57\xfe\xb1\x24\x3e\x75\x4f\x3b\xc6\xc4\xe6\x9b\xf5\xcd\xc5\x75\x93\x22\x9a\xaa\x2b\xe5\x55\x5b\xa7\x4d\x98\xc7\x62\x9c\xd0\x78\x32\xef\x60\x26\x66\x1b\x80\x2e\xe4\x11\xfb\xc9\x64\x4d\xe9\xdc\x67\xd3\x46\x1b\x92\x18\x4e\xe3\x44\x9c\x43\x9c\xd3\x80\x0e\x78\xc8\xb3\x39\x18\x07\x4d\x67\x61\xc6\xc1\xc9\x15\x31\xe9\xf0\x64\x03\x71\x79\xc4\x7f\x03\x93\x85\x06\x26\x9a\xd8\x19\x88\x4b\xa3\xd6\x9a\xf2\xe8\x17\xb4\x08\x79\xfc\xd8\x29\xd3\x2d\xdf\x7b\x68\x12\x58\xa0\xf3\x97\x16\x62\xa4\x31\x1d\xf2\x68\xdc\x99\x45\x1c\x52\xaf\xc4\x97\x4e\x36\x08\xef\x23\x46\xfb\x6c\xc4\x97\x15\xf9\x2e\xf6\xdb\x75\x42\x92\x8c\x5d\x66\x5a\x52\xe2\xe5\xb0\x50\xd9\x34\x8a\xe9\x27\x94\x5b\xc8\x49\xc3\xe6\xce\xd8\xd1\xf7\x9d\xc6\x40\x5c\xee\xa4\x13\x1a\x88\x8b\xc6\xa9\x1b\xec\x2f\x30\xa9\x27\x8a\x08\xf5\xb7\x4e\x3a\x11\x49\x66\x6c\x3e\xfe\x3f\x7b\xef\xde\xdd\xc6\x8d\x24\x8a\xff\xef\x4f\x81\xcc\x66\x4d\x32\x26\x29\x52\x96\xfc\x90\xc7\x93\x75\xe4\x64\xe2\xbd\xf1\x38\xc7\x72\x26\x77\x7f\xbe\x3e\x16\xd8\x0d\x92\x88\x9a\x8d\xde\xee\xa6\x44\x25\xf6\x77\xff\x1d\x14\xde\xe8\x07\x9b\x14\x29\x4b\x32\x67\xf7\xc4\x22\x1a\x28\xbc\x0a\x85\x42\x3d\x75\xda\x91\xfb\x47\x53\x76\xee\xe4\x83\x41\x88\x0f\xfb\x25\x09\x98\x4e\x68\xe1\x24\x15\x02\x6f\x81\xb7\x04\x5c\xcd\x62\x19\x49\xcb\x8d\x54\x6a\x67\xfe\x38\x16\xeb\x22\x93\x93\xba\x94\xac\x3f\xc6\x21\xe9\xb4\x6b\xd6\x0c\x0d\xfa\xc3\x7d\x4b\xfd\xd9\xfa\xaf\x19\x09\x29\x46\x6d\x18\xf4\x11\xe2\x03\xeb\xb4\xdc\xe8\x84\x85\xbe\x5b\xb0\x1e\x09\x4e\x39\x0f\xa8\x2b\x5a\x7a\xcf\xd6\xfd\x6f\x35\x07\xb8\x1e\xac\x7b\xf6\xbf\x6a\x75\x43\x12\x67\x56\x42\x93\x3a\x1c\xec\xa1\x61\x3d\x1e\xba\x38\x68\xf0\xfe\xd1\x41\x19\xde\x6b\xac\x1c\xb3\x38\x17\xa6\x99\x85\x23\x9b\x2c\xde\xb1\xb7\x64\xd6\x2e\x7c\x50\x6d\xf8\xa0\x1c\x19\x65\xc4\xe9\x55\x21\xcd\x8c\x9b\x14\xc9\xe4\x55\xf2\x13\x5e\xe1\x88\x4e\xe2\x57\x39\x99\x95\x65\xc3\xfa\x63\x9e\xe5\x74\x7c\x79\xcc\xe2\x5c\x84\xba\xd2\x3c\xb4\xd5\xff\x38\xc2\xf9\xea\xc2\xc9\x5a\x4c\xbf\x02\x9e\x3a\x7d\xf8\x78\xba\xfc\x84\x6c\x12\x93\x5d\xec\x33\x8b\xb5\x86\xe4\x7c\x5b\xab\xe5\xf5\x72\x33\xd7\x6b\xf3\x22\xfe\x6d\x2d\xe7\x2a\x43\xb8\x79\x6b\x0d\x53\x7c\x25\x4e\x78\x61\xad\x4b\x8f\x7e\x8a\x69\xb6\x54\x2f\x52\xbf\x28\x93\x94\x5c\xbe\x7f\x68\x6f\x4a\x61\x0a\x15\x0d\xba\x16\x33\x02\xb7\xaf\x26\xe1\xf0\x2b\x7b\xbf\x6f\x11\x99\x6f\x9d\xf4\xd4\xde\x85\x52\x09\xe1\xd1\x07\xb5\x4e\x16\xc6\x08\x45\x54\x33\x00\x4f\x4a\x00\x94\x5f\x6a\x95\x20\xcc\x44\x97\x2e\x0d\xdc\xd1\x21\x3d\xa7\x21\x49\x4b\x06\xde\x00\xd5\x8b\x4b\xdd\x7f\x31\x1c\x0c\xb6\x8e\xa5\x15\x5b\x7c\x45\xae\xa0\x7a\x75\x6c\xe3\xaa\xe5\x53\x6a\x36\xa9\x35\xa6\x65\x0e\x62\xc5\x91\xf4\xb0\xf6\x08\xfd\xe5\x9c\xbc\x66\xd7\xee\x1a\x84\x71\xc9\x4c\xd6\xbf\xc8\xcb\xe1\x3c\x1e\xd8\x58\x7e\x2d\x38\x56\x50\x94\x56\xee\x81\x58\xea\x46\x97\x76\xfd\x4a\xbb\x97\x6d\xd3\xb5\xbe\x0a\x23\x50\x09\xe9\xe0\xda\xcf\x74\x89\x25\xc0\x92\x15\xdf\xae\x66\x3f\xbc\xb2\x52\x7f\x8c\x47\xa6\x71\x4d\xba\x45\xfd\xc0\x18\x14\xdf\x09\xba\x48\x25\x87\xd4\x4f\x63\x9d\x1c\xf2\xd1\xd2\x7b\xee\xd1\x87\x35\x6f\xa7\xe1\xfe\x07\x77\xf9\xb7\x69\x2b\x20\x25\x15\xfc\xc1\x6c\xa9\x00\x94\x34\xdf\xd1\x06\x68\x1d\xc0\xc6\xec\x02\x02\xf1\x82\x51\x6a\x66\x4b\x9a\xf1\x65\xcd\x01\x2c\x85\xd6\xfa\x0d\x8f\xbe\x94\xea\xaa\xd2\x93\x6f\x67\x8b\xb0\xaa\x2d\xc2\x7a\xa7\xa3\x6c\x06\x4a\x9a\xcf\xf9\x05\x11\xac\x7c\x4a\x40\x74\x88\x62\x8e\x37\xa2\xea\x8f\x14\x8c\x01\x30\x12\x2b\xc1\x77\x43\xc4\x53\x7f\xf9\xe6\xb5\xce\x30\xc6\x78\x05\xdb\x17\x52\x75\xa2\x94\x63\xa0\xda\x41\x34\x43\x18\x9d\x8a\x23\x75\x6a\xcf\x5b\x47\xc8\x5e\xed\x50\x39\x42\xda\x35\xcf\x96\x0d\x63\x33\x08\x6f\x41\x2c\x1a\xde\xf0\x15\xc8\x66\x38\x8a\x48\xaa\x89\x7b\x17\xd1\x90\xe0\x48\x6e\x01\x84\x6a\x83\x90\xf3\x01\x4e\x43\x69\xfa\x6d\xe1\xbd\x14\x4a\x35\x76\xff\xf5\xbc\x92\xc5\xea\xa3\x0b\x1a\x45\x68\x44\xf4\xe5\x66\xc1\xd7\xd7\xdd\xba\x5d\xf8\xfe\xcc\xd2\x29\xb7\xbc\x4b\x74\x2a\x7f\x0b\xcb\xe9\x53\x34\x9b\x67\x39\xc2\x51\xc6\x78\x5d\x0e\xb5\x30\x34\x60\x71\x45\xf5\xf5\x07\xe9\xa4\xc7\x58\xbe\x1c\x57\xe9\x0e\x80\xf3\x43\x33\x8e\x98\x70\xfa\x96\x59\x3d\xe4\x5e\x70\x72\x47\xe3\x89\xe9\x13\xf8\x85\xc6\x3d\xf1\x73\xf6\xdb\xdb\x5f\xf8\xc9\x8c\x68\x7c\xc6\xff\x95\x84\x46\xef\x36\xcd\x10\xe4\x32\xd0\x8b\xfe\x6a\x8c\x74\x34\x5e\x1c\xa3\x53\x7c\xaa\xcf\xb2\x5a\x0a\xa0\x0a\x38\x2b\x23\x0a\x7c\x8c\xd3\x94\x8c\xaf\xe2\x1d\x6f\xe3\x21\x5f\x1b\xc1\xc9\x15\xd7\x42\x09\x0e\x1a\x2f\x87\x4f\xe3\xf9\x99\x6c\x92\x4f\xd8\xe8\xc4\x84\xaa\xcc\x37\xcb\xb2\x5c\x8f\x74\xb8\xa7\x2f\x6f\xaa\x05\xd4\x40\x7f\x82\x5f\x96\x24\x17\x70\xd9\x7c\x95\x05\x5e\x05\xeb\x38\xf9\x55\xad\x4f\x5a\x20\x8d\x47\xba\xd6\x18\x8f\xb4\x9b\xb2\xd8\x3e\xed\x08\x0c\x3f\xaf\xcf\x9e\xac\x8b\x5a\x30\x77\xdf\x16\xa4\x38\x0f\x5e\x3a\xc6\x23\x70\x74\x84\x41\x3a\xb6\x68\xe3\x08\xe7\xe8\x39\xfa\x46\x4e\xe7\xfe\x7d\xf4\xcd\x18\x8f\x9e\xad\x64\xa9\xb6\x19\x77\x43\x61\xd5\x06\xa1\x9c\xd7\x6b\x2f\x76\x40\x6d\xcc\xa7\x4f\x7c\xe7\xd6\x03\xc5\xb7\x79\xfd\xd6\xb6\xac\x50\x59\xd1\x3d\xf7\xac\xe8\xd6\x19\x94\xd1\x25\x74\xc5\xb6\xdd\xbf\x6f\x43\x57\x0c\xd1\xfa\xd0\xc5\x3b\xbe\x14\xb8\x64\xb1\xd6\x87\xad\xde\xa1\xa5\xd0\x35\xdb\x76\x95\x9d\xd7\x6b\xf3\xcd\xc6\x17\xc7\x16\x73\x94\xc3\xbf\xd2\xfa\xb8\x6f\xfa\xf2\x0e\xae\xb8\x44\x82\x4e\x0a\xe2\xb9\x26\x04\x45\x4b\x35\x99\x6d\xe2\xb3\xdb\xdc\x34\xd4\xb6\xea\x70\x7d\x54\x97\xa4\x9c\x29\x35\x17\xf5\x6e\x84\x23\xe4\x5f\x05\x63\x9b\xa5\xfa\xa6\x9a\xfa\x7b\x52\xc6\x63\xaf\x33\x92\xf5\xbd\x1a\x52\x0c\xe2\x98\xa5\x36\x72\x81\x75\xdd\x5f\x8b\x66\xb0\x24\xeb\x83\x3a\xd3\x08\x7c\x2d\x6b\x57\xe1\x90\x2a\x6c\x5e\xc5\x42\xde\x64\xab\xd7\xf5\x5e\x74\x5e\x57\xcb\x9f\x05\x7e\x83\x26\x7c\xbe\xd7\x66\x19\x63\x5a\xde\x45\x53\x7e\xdd\x6b\xdd\x80\xf3\x2b\xef\x6f\xf5\xae\x1a\xf0\x88\x37\xc5\xa0\xf8\xce\xc8\x81\xbe\x36\x6b\xe6\xf5\x4e\x79\xf3\x41\x48\x19\x4a\xab\x7b\xe7\x84\x28\x4d\xd7\x40\xbd\x00\x6a\xce\x7d\x63\x50\xe6\x0d\xb1\x39\x68\xee\x2b\x64\x73\x70\x37\x09\x52\x3c\x8d\x36\x00\x68\x9a\x92\xf1\xa6\x4e\x98\x7c\xa8\x6d\x64\x5c\x1c\xbb\x1a\x8c\xcb\x76\x17\x90\x1c\x44\x8d\xc3\x80\x3e\xdb\xe6\x22\xd6\x41\xbc\xcc\x3d\xab\x8b\xe0\x1a\xf5\x2b\x38\xb7\xa4\xfe\xa8\x2e\x41\xbf\x76\xa1\xa2\xb8\xc2\x5a\x42\xac\x22\x3c\x17\xae\xea\xa1\x20\xe6\x0d\x3e\x0a\xe2\xcf\x2d\x79\x29\x5c\x2d\xeb\xde\x96\xe2\xfa\x1e\xe3\x34\xac\x32\xea\x3f\x04\xa3\xf0\x25\x1d\x59\x04\x9f\xf7\x42\xe2\xf9\x4c\xa4\xb6\x32\x89\x1d\x27\x24\x3f\x72\x82\xa3\xb7\xbd\x70\xe8\x55\xc6\xdc\x7c\x70\x1d\xb5\x79\x56\x56\x23\x3d\x72\x69\x87\x57\x65\x37\x2f\x92\x09\x2d\x9b\x80\x05\x68\x5b\x93\x90\xe0\x6b\xe7\x22\x5c\xbf\xab\xec\xf3\x0f\x0f\x1f\x37\x9d\x8b\x04\xb4\xad\xb9\x48\xf0\xb5\x73\x79\x0d\xca\xf1\xaa\x99\x34\xde\x15\x00\xb3\xad\x79\x00\xf0\xda\x59\xfc\x4c\x70\x58\x99\xe7\xf0\x10\xf2\x30\x36\x9a\x86\x80\xb3\xad\x79\x08\xe8\x65\x13\xd9\xba\xf7\x83\x47\xe0\xae\x96\xbc\xf3\x4b\xbb\x61\x7d\x29\x57\xab\xad\x7a\x37\xdd\x28\x3f\xae\xad\x78\x4f\xfd\x8a\x93\xea\x33\x7a\xe0\x56\xab\x83\x0a\x15\xae\xe7\xd4\x94\x3b\x9b\xc1\x00\xae\x6e\xdc\xb1\x95\x18\xcf\xa0\xa2\xdd\x84\x0e\xcb\x53\x41\x71\xfa\xe5\x2b\xa0\xb6\xa2\x62\xf1\x74\x20\x8d\x04\x94\x12\x67\xb4\x58\xb2\xda\x77\x9d\x44\xe4\x5c\xba\xa0\xc8\xd1\x7f\x8f\x9e\xa0\x23\xb4\x6f\x44\x82\x42\x48\xc7\xe7\xbb\x9e\x88\xae\xde\xed\x7f\x2d\x31\x52\x53\xcc\xb8\xf7\xb9\xe9\xdb\x44\x3e\x24\x60\x96\x25\xcf\x08\x87\xc9\xaf\x60\xdd\x79\xdb\xed\xb0\xdf\x9b\x4c\xd1\xbc\x73\x12\xfe\xda\x6e\xae\x5d\x4c\xb2\x26\x2e\xc0\x30\xab\x9f\x6b\x03\x93\x3d\x7e\xf2\x75\x3b\xe6\x56\x7b\xbd\x02\x89\xb4\x82\x8e\x69\x83\xd7\x7d\x6d\xa0\x2b\x5d\xd6\xc6\x11\x51\x3e\x76\x8e\xb7\x9a\xc8\x07\x20\xbf\x68\x2b\xdb\xd6\x7e\xb2\x40\x07\xc9\xa2\x75\x4f\x5a\xea\x0a\xb3\x9c\x13\xe1\xb6\xa7\x7a\x9b\xe1\x74\x42\xe3\x23\xd4\x1a\xe8\xba\xab\xda\xbd\x36\x35\x36\xf5\x2c\xe8\x76\xe1\xa7\x6e\x8c\xc9\x67\x19\xdb\x27\x2d\xf3\x50\xc8\x50\xcc\x72\x91\xe4\x90\xa3\x16\x2f\xc5\x91\xc4\x9b\x82\x21\xd9\x0b\x17\xc7\x56\x63\x09\xa5\x88\xc1\xe7\x0c\xcb\x40\xfb\xa6\x3c\xce\x47\x5f\x65\x7a\x65\xfb\xa5\x6a\xdb\xa5\x75\x19\xd3\xb2\x61\x83\x6e\x64\x99\x4d\xd0\x4a\xac\x2c\x0c\xb2\x15\xd2\xf3\x15\xa2\x30\x35\x08\xaf\x0d\xb6\x3b\xba\x49\xc7\x57\x80\x97\xee\xd7\xf7\x66\x37\x8e\xac\xd4\xb2\x3f\xab\xf0\x54\x11\x8b\x89\xca\x88\xc9\x57\x50\xeb\xde\x3b\x56\x02\x58\x35\x02\x87\x92\x19\x5d\xb8\x85\x43\x5f\x46\x21\xbe\xf2\x21\xb8\x29\x6a\xd7\x5d\x1c\xa7\x6a\xfd\x93\x7f\x46\xeb\xb5\x34\xb6\x66\xc5\xc6\xc7\x92\x77\x51\x39\xb6\xd4\xbd\x92\x56\x53\x70\xd8\x42\x61\xf4\xb9\xd3\xb6\xa5\xb8\xdb\x79\x6b\x3d\xd9\xbd\xb5\x76\x6f\xad\xaf\xf9\xad\x85\xd3\x58\x66\xfb\x28\x1b\xfa\x81\x5f\xb1\xf6\x99\x25\xaa\x5c\xd7\x3b\xee\x26\xbd\xcc\x6e\x66\x74\x22\xff\x9d\x66\xfc\x3c\x45\x04\x93\x56\x00\x7e\xa8\x5d\xef\xe3\x5b\x92\x10\x2c\xa2\x47\xf7\x52\xf8\xbb\x50\xe5\x57\xa6\x02\xee\xa8\xa7\x9c\x7a\xb2\xf1\xfe\x40\x61\xa5\x3a\x75\x82\x9a\x38\x8f\x35\x70\x4c\xd5\x62\x65\x48\x7e\xdc\x3a\xa7\x21\x61\x60\x7c\x33\x0f\x29\xfc\x91\xd0\x20\x9f\xa7\x60\x26\x4e\xc7\xa9\x34\x32\xa7\xb3\x49\xeb\xc3\x06\xde\x7c\xb7\xf2\xe9\x33\xc3\x13\xc2\x87\x25\xdc\x63\xf8\x4b\x5b\x38\x86\x60\x6b\x83\x10\xe5\xb5\x5c\x97\xb1\x53\x28\x3b\x45\x2c\x45\xa7\x59\x1a\x9c\xc2\x0b\x41\xb8\xf7\x8c\x08\xca\x12\x12\xd0\x31\xd5\x1e\x29\xff\x62\xb9\xcc\xca\x1d\x48\xef\x28\x5e\x51\xd4\xba\x94\x4f\x7e\xc1\x44\x5f\xd0\x8c\x88\xb0\xcd\x30\x32\x90\xbe\xf3\x07\xd8\x88\xa0\x73\x91\x72\xc6\x2c\x1b\x54\x59\x69\xba\x2f\x62\x84\x23\x8a\x33\xf0\xc6\x52\x53\x48\xe4\xb5\x23\xc7\xfa\xe2\x1c\xd3\x48\xe4\x4e\x8f\xa3\x4b\x91\x97\x5f\xb8\x3d\xfb\x5b\x87\x5e\x7b\xc5\x47\xe8\x14\x70\xee\xb4\x8b\x4e\x01\xe7\xf8\x1f\x12\xe7\xf8\x9f\x02\xe7\xe0\xaf\xd9\xc4\xf2\x91\xcb\xd2\x60\xa5\x69\xf8\x7b\x2f\x73\xba\xac\x80\x3d\x46\x01\xc3\x57\x42\xa4\xf1\xe2\xa4\xdb\xda\xe9\x3b\xee\xbc\x57\xf2\x00\x87\xed\x6c\xe4\x19\x74\xe5\x87\xb3\xc0\x6e\xf5\x19\x7e\xa9\x4f\x82\x62\xa8\x4f\xf0\x4b\x7f\x4a\x03\xf3\x21\x0d\x54\xb1\xde\x4c\xd7\xd1\x48\x95\x5e\xd9\x51\xa7\xc2\x39\x07\x46\xcd\xff\x80\x31\xc2\x1f\x69\xd0\x72\xcc\x15\xd5\x73\x7d\x25\x85\x8f\xe2\x0e\xcc\x50\x7e\x60\x2c\x22\x38\x6e\x8b\x55\xfb\xf4\x89\x2f\x44\xa7\x8b\x5a\xaf\x55\xd4\xe8\xdf\x5e\x1d\x21\x52\x43\x98\xf8\xf1\x2e\x21\x4e\x2d\xfe\x54\x51\x59\xed\x55\xa2\xfb\xec\xb5\x73\x95\xa0\xe7\xfe\xdd\xd2\xa7\x71\x48\x16\x6f\xc6\x6d\x67\xdd\x3b\x30\x9f\xde\x50\xbb\x13\xf1\x8f\x19\x09\x4f\xe4\x76\x7e\x53\x00\x7c\xff\xbe\x44\x83\xef\xab\x25\x13\x86\x08\xbf\x12\xc4\xae\x35\x4f\xa3\x76\x0b\x3d\x90\x4d\x1f\xa0\x56\x07\x22\x43\xc3\x1e\xf0\xe9\xc0\x1f\xfe\x20\x9a\x25\x10\xdb\xa4\x6f\x53\x61\xba\x6b\xba\x8b\x28\x0e\xa0\x5b\xd8\x98\x6a\x97\x8c\x15\xdc\x31\x9c\x2d\xac\xd6\x75\xde\xf3\x9d\x2f\xfc\x75\x15\x67\x4c\xd2\x61\x67\xeb\xe5\x17\x4e\xe1\x0b\x18\xf0\x3d\xb2\x31\x1a\x1d\x99\x27\xd7\x3d\x54\xa6\x44\x85\xe6\x5f\xca\xd9\xe1\x66\xdc\x04\x6b\x59\xc8\x57\xb4\x6f\x6c\x28\xbf\xdd\x9b\xe8\x2e\x9a\xcd\xab\xbb\x61\x23\xc0\xc4\xb5\xb2\x19\x50\xf2\xaa\xda\xcc\xaa\xdd\x6d\xb3\x7c\x5f\x96\x27\xa8\x4f\xa9\xa1\xb4\xa6\x0d\x20\x6d\xdf\x98\xf8\x4e\x58\x42\x2a\xe1\x9d\x30\x5d\xdc\x8e\xe8\xee\xe9\x4e\x74\xb7\x13\xdd\x5d\x45\x74\x57\x61\xde\x66\x99\x41\xdf\x7a\xe9\xde\x35\x58\x52\xbc\xd3\x71\x6e\xab\xd0\x66\x50\x52\xb7\xae\x13\x53\x6b\x75\x13\x7a\xbf\x76\x5d\x3f\xb6\xbd\xfb\x0d\x93\x27\xde\x14\x4b\x8f\xf5\x52\xd0\x95\xda\x7f\x94\x5b\x80\xd8\x51\xd9\xf0\x39\xce\xb1\x95\x66\x8d\x37\x06\x33\x8f\x01\xc2\xf3\x9c\x99\x58\xcd\xa0\xc8\x7f\x2b\x6c\x4e\xca\x23\x8c\xdb\x60\x03\x15\x02\xd9\x83\x3b\x44\x43\x01\xd7\xae\x9c\xd3\x9c\x3f\x07\x54\xac\xc6\x6c\x3e\x9a\x82\xd5\x3a\x2f\x5a\x2b\xc4\x5a\xa5\xa9\xc9\x0b\x98\xad\x0e\xf3\x04\xee\x2d\xc2\x42\xde\xc8\x72\xd4\x8a\xdc\x62\xdd\xea\xed\x37\x35\x69\x66\x17\x64\x61\xca\x9d\xd9\xad\x92\x99\x03\x9a\xbe\xe3\x87\xc4\x4c\x5d\x9e\x99\x5b\x3c\xed\x12\xc1\xa2\x38\x8a\xbe\x64\x51\x1c\x48\x2d\xaf\x13\x3f\x37\x1b\x5b\x48\x23\x92\x11\x1b\xaa\x12\x9d\xf0\x80\x2f\xb8\xfe\x0c\xbf\xae\x2a\x30\x14\x33\xa9\x8b\xeb\xa3\x47\xc1\x7f\x40\x9f\x6b\x24\x8d\xab\x30\xc8\x31\x01\x39\xf6\xf6\xd0\x8b\xf0\x8f\x79\x96\xcf\x40\x25\x04\xfa\x87\x90\x24\x9c\x54\x30\x11\x41\x2b\x49\x49\x46\xe2\x00\x72\x45\xe2\x58\xee\x88\x1c\x04\x0c\x4b\x2a\xe1\xe4\x56\x7d\x8f\x5a\x23\x16\x5e\xee\xb7\xd0\x11\x6a\xf1\x09\x44\x34\x26\x2d\x25\x6c\xd3\x93\xaa\x69\xc4\xff\x1a\xb6\x56\x0d\x17\x62\xf3\x20\xcd\xe2\x85\x54\x25\x93\x77\x2c\x95\xe4\x00\xef\xdf\x6f\x18\xb4\xc3\x58\x52\x55\xc4\xec\x90\x00\x75\xd0\x0e\xbd\x9e\x08\xad\x14\x1d\x64\x69\x47\x8a\x90\xe8\x9e\x1a\x26\xde\xb7\x99\x46\x77\x21\x45\x57\xc2\xcf\x56\xef\x7c\xd7\x79\xda\xca\xf4\xfa\x25\xc3\x11\x67\xc8\x0a\x4e\x0d\x05\xf2\x57\x67\xb3\x63\xd4\x7f\x29\xaf\x60\x07\xed\xec\x80\xd6\xc5\xb1\x3b\x1f\x85\x73\xb3\x8e\xc7\xeb\x7e\x2d\xce\x51\x77\xa3\xab\x59\xf3\xf5\x3f\x76\xbc\x30\x2d\x86\x08\x7e\x19\xe9\xe5\x1d\xe0\x7d\xee\x8c\x68\xd0\xa6\xfd\xb7\x78\x3f\x1a\x87\x24\x80\xdb\xed\xb6\x4f\xd5\x96\x05\x6e\x42\xb2\x27\x9d\x83\x95\x68\x4f\x7a\xf3\x6e\x45\xb6\xf7\x68\x70\xc7\x65\x7b\x5b\x95\xb4\x7d\xe5\x49\x18\xef\x84\x59\xde\x35\x08\xee\xa6\xb5\xde\x4f\xfb\x07\x5f\xb7\x4c\xec\x56\x1b\xfe\x5d\x55\x6c\x37\x8a\x58\x70\xe6\xc9\xdb\x8e\xd0\xc0\x16\x94\xc9\xca\x07\x25\x79\xd0\xd4\x27\xa7\xe2\xc3\xea\x8a\x0f\x9d\x8a\xfb\xd5\x15\x5d\xf7\xb2\x61\x75\xc5\x61\x57\xfa\xa5\x89\xe7\x5e\x49\x45\xf5\xc9\x91\xfa\x15\x6a\x59\x4f\x6b\xc9\x02\x59\xe9\xe6\xac\x7a\xe6\xa3\x34\x94\xe4\x8f\xc7\x92\x7a\x50\x6e\xaa\x94\xcd\x00\xca\xa5\xe0\x12\x27\x4e\x0e\x42\x53\x49\x7e\x91\x90\x20\x14\x50\x19\x28\x91\x42\xd2\x78\xdf\xfd\x42\xc6\xd6\x76\xe7\x64\x91\xbf\xe0\xc5\x47\xa8\x15\x91\xb1\x9b\x1e\x0a\xea\x1f\x83\x8c\xb6\xbc\x45\x99\xfc\x96\x7f\x92\x62\xd9\xb2\x26\x29\xff\x54\x6c\xf1\xdf\x22\x53\x5d\x79\x1b\x99\xc6\xce\x69\x15\xb3\xdf\x53\x9c\x98\xfa\xec\x9c\xa4\xe3\x88\x5d\xf0\x07\xbe\xc8\xbf\xde\xb5\x20\xbd\x31\x5f\x49\x14\xd1\x24\xa3\x99\xfe\x7e\x31\xa5\x39\x39\x49\x70\x40\xc0\xda\xf5\x22\xc5\x89\xd3\xd3\x64\x9e\xe7\x24\xfd\x81\xe5\x39\x9b\x99\xfe\xc4\x79\x50\xa5\xad\x41\xff\xe1\x21\x99\x39\xed\x12\x9c\x62\xd8\x84\xaa\x46\x4d\xa4\xd6\xab\x66\xf4\x82\x6f\xab\x67\xf3\x2b\x80\x38\x51\xcf\xcb\x25\x40\x20\x29\x93\x7e\x8b\x16\xc0\xac\x9a\x2a\xef\x60\x30\x28\xc0\xf8\x31\x4d\x59\xba\x04\x04\x64\x17\xb7\x9a\xaf\x25\xa5\xaf\xa1\xdf\x76\xc4\x40\x49\xd8\x64\x20\x6b\xa0\x5d\xd6\xdf\xfb\xd6\xdf\x43\xfe\xb7\x16\x37\x59\x6f\x8a\x96\xa1\x15\x22\x01\x69\x28\xda\x09\x29\x13\x7f\xbc\x89\xb3\x0d\x65\x22\xde\xd7\x55\x52\xa9\x60\x71\x8e\x96\x4c\xcc\x8a\x7f\x08\x94\xa0\x6b\x3c\x74\xd5\xb1\xed\x9a\xb3\x28\x72\x4d\xdd\x09\xcf\xaf\xbb\xa2\x9d\xd8\x72\xe6\x90\x1f\x2e\x75\xe2\x90\x0b\x82\x66\x38\x11\xb9\x54\xf8\xa1\xc9\x19\xc2\x68\xc2\x58\xa8\x6b\x28\xac\x2f\xf5\x9e\xbe\x21\x26\x69\x5b\xcf\x2c\xf2\x65\x53\xd2\x94\xc7\x33\xb5\xe4\x86\x76\x70\x53\x20\xa0\x2d\x2b\x3e\x9e\x9f\x9c\xc6\xf3\xb5\xe6\x74\x5f\x18\xf9\x0b\x0f\x6b\x34\x82\x4b\xad\xe0\x5f\xed\x5e\x9e\x35\x3e\x88\x6e\x6f\xbf\x13\x84\x53\x82\xc8\x2c\xa1\x29\x0d\x70\x14\x5d\x72\x84\x4b\xf4\x6a\xf1\xdd\xd3\xf6\xc1\x80\x7d\x29\x8e\x27\xa0\x0e\x08\xe9\x78\x4c\x52\x8e\xc5\x36\x46\xf3\x16\x12\x8f\x7f\x62\x29\xa2\x71\x96\xe3\x38\x20\x5d\x34\x1d\xf2\xf6\xd3\x47\x7d\x3e\xc3\x4b\x36\x47\x17\x34\x9b\xc2\x09\x9f\x02\x44\xb9\x0b\xd0\x77\x17\x2a\x04\x38\xe6\x7d\x9f\xd3\x90\xf0\xdf\x29\x62\x17\xb1\x72\x41\x88\x72\x92\xc6\x38\xa7\xe7\x24\xba\x34\xb5\xe7\xd2\x35\xe2\x54\xef\xbf\xef\xbc\x00\xb9\x3b\xe4\x91\x79\x2d\x3a\x5b\x82\x9c\x7f\x7d\x6e\xba\x41\x31\xcb\x11\x67\x6a\xba\x9c\x49\x84\x99\x13\x2c\xc3\x23\xe5\xe9\x3c\x0e\x30\x47\x38\x9a\x4f\x11\x8e\x91\x62\x8e\xcc\xa8\x14\x9f\xd5\x78\xeb\xd6\x44\x14\x8b\x5b\x6a\xdc\xd5\x0b\xa0\xc7\x99\x75\x80\x0c\xe3\x2b\x5f\x3d\x96\x82\xb2\x2e\x9a\xf4\x17\xbf\xdc\x3d\xe5\xa3\x51\x25\x34\x71\x6b\x80\xfb\xdd\xe8\x23\xf9\xaf\x4d\xa7\x3a\x69\xe4\xa8\x50\x93\x11\xc5\xa6\x03\xba\x86\x5d\x68\xf2\xe6\x39\xa7\x40\xd7\xf5\xca\x55\x75\x81\x9e\xba\x96\xf8\xa9\x3e\x6a\x9c\xd2\xdf\x75\x89\x7e\x1c\x08\x9e\x4f\x2a\x51\x2d\x45\xcc\xda\x3a\x54\xbe\xfa\xf5\xa9\x51\x8c\xf1\xa9\xc9\x93\x62\x2f\x85\x8d\x58\x72\xba\xbc\x48\xcc\x0d\xc8\xb9\x9a\x45\x4b\x85\xce\xdd\x88\x12\x96\x64\xef\x39\xb0\x0f\x5d\xb4\x11\x87\x82\xf7\x72\x76\xe8\x81\x68\x3c\x55\x31\x13\x70\x42\x73\x1c\xd1\x3f\xc9\x4f\x34\xcd\xf2\x5f\xf8\x8d\x97\x76\xda\x50\xb9\xf3\x41\x25\x23\xf9\x86\xdf\xef\xea\x32\x5a\xcf\x07\x41\x22\x83\xc4\x91\xf5\x60\x38\x28\xea\x60\xf1\x7a\xf0\x0c\x02\x1a\xec\x5c\x0b\x92\xc2\xb4\x86\xab\x0b\x95\xf9\xea\x0a\x5a\xf1\x8d\x97\xea\x65\x69\x8e\x0c\x8e\x58\xb6\x6b\x8d\x4b\x11\x3e\x7d\x42\x6d\x73\xd8\xbe\x47\xad\xa4\x85\x8e\xfc\xa3\x2c\x90\xab\xc3\x2b\x0b\xb5\xe6\x1a\xde\x1e\x35\x51\xed\xea\x15\xe7\x42\x9d\x69\xc8\xea\x97\x51\x67\xae\x7c\xc5\xaf\x92\x11\xe1\x8b\xdf\x61\xbe\xee\x76\xf7\xea\xfc\x2a\xf4\xc2\x77\xdc\x9b\x62\x93\xd9\x26\xae\xfa\x24\x6b\x3a\x1c\x8f\x9b\xd8\x44\xe2\x80\x02\x3f\xb2\x8c\x74\x35\x85\xac\xd9\x9a\x0d\x8c\xd2\x66\x8c\xb6\x9e\x95\xe0\x8b\xd3\x5b\x4f\xbd\x6f\x5d\x6e\x25\xbe\x3e\x92\x1a\x1b\x14\xac\x48\x94\xe0\x3e\xd8\x75\x22\x83\xc2\xcd\xf5\x97\xa7\x00\x6a\x4d\x87\x2d\x5f\xd7\x53\x28\xdb\x2f\x29\x1b\xda\x65\x46\x59\x63\xca\xa4\x5e\xa6\x35\xdd\x6f\x15\xb5\x30\xad\xe9\xc3\x96\xa3\x6e\x69\xe1\x8c\x86\xa4\xe5\xe8\x57\x5a\x89\x8e\x4c\xa1\x9e\xb3\x7a\x62\xd6\xbb\xb3\x90\xb5\x01\x16\x7f\x23\x4e\x51\x66\x6f\xc0\x74\xc2\x71\x6e\xd8\x86\xe9\xc4\xf0\x46\x26\x6f\x98\x92\xe0\x6c\xc4\x16\x55\x06\x01\x8f\xf6\xbf\x74\x02\x07\x39\xc0\x1b\x10\x9d\xfe\xd1\xfe\x1d\x37\x7e\xd9\x39\xb6\xdd\x5e\xe3\x97\xeb\x30\x4c\x39\xb9\xa0\x79\x30\xfd\x01\x67\x95\x26\x15\x4f\x1e\x96\x54\xae\xeb\xc5\xd4\xd2\x0d\x5f\xc5\x21\xc9\x49\x3a\xa3\x31\xce\x09\x1c\xff\x1f\xaa\xe9\xd3\xe3\x41\x7d\xbb\xba\xbe\x4b\x1b\x7c\xdd\xc6\x35\x57\xb7\x5c\xd1\xb3\x5d\x57\x45\xcd\xf7\x81\x84\x6b\xea\xc9\x4d\x0a\xa9\xda\xe6\x22\xe8\xa7\x4e\x4d\x5a\xa6\x9f\x76\x70\x1d\x18\x0b\x0b\xa1\x0d\x63\x71\x05\x0d\x70\x65\xc8\x5c\x2d\xd2\xa1\x99\x5a\x0e\x3b\xcc\xb1\x5c\x9f\x3a\x0e\x98\xf7\xda\x7e\x5f\x27\xb3\xaf\x7f\x66\xfa\x8a\xa6\x77\x53\x82\x68\xc0\x62\x94\x33\xc5\x22\x9a\xcc\xe9\xd5\xe3\xe5\x33\xd3\x4a\x4d\x9a\x29\x0d\x4d\xd8\x45\xb4\x98\x3d\x1d\xa3\x31\x8b\x73\x14\xd1\x09\xce\xe7\x29\x29\xcc\xf8\x55\xc0\x6e\xb7\x70\xe1\xf6\xab\xb4\x7d\x28\xf2\x14\x1c\x2f\x41\xc9\xa5\xfa\xa8\x0c\x4e\x96\xc6\x08\x75\x2c\x0b\x11\xa1\xaf\xd0\x45\x2a\xb2\xb6\x93\xf1\x98\x04\xf9\xf2\x9e\x1a\x24\x46\x5d\xf7\x84\xcc\xe3\x2d\x9c\x11\x7a\xb7\x0e\x47\x25\x45\xc4\x49\x42\x70\x9a\x21\x6a\x5f\xdd\xd6\x32\xd8\xc5\x5b\xd9\xbd\x92\x8e\x37\xb4\x83\x36\xe0\x3b\x46\xeb\x0c\x3f\x6c\xd3\x36\xd0\xbe\xd3\x38\x99\xe7\xa7\xca\x24\xc0\x5e\x8e\x44\xf0\xd1\xab\xd1\xb9\xdf\x32\x69\x1d\x60\x1b\x22\x24\x38\xe3\x0b\x9f\x92\x31\x44\x4c\x1c\xe1\xe0\x4c\xf5\x2f\xec\x02\x44\x6f\x65\x66\x31\xf0\xe1\x2d\x19\x57\x0e\x82\xaf\xb5\x1c\x42\x39\x8d\x8c\x57\x25\xb2\xc7\x6a\x88\x63\x88\xab\xa4\xd1\x30\xcb\x71\x4e\xc4\x15\x8b\xe3\x89\x22\x1f\xb2\xd3\x04\xa7\x78\x86\xfe\x12\x4b\xf2\x19\x91\x73\x8e\xae\x1c\xab\xc5\x5f\x19\x9b\xa7\xc2\x31\x53\xc4\xe4\x17\x3d\xb8\x6d\x47\x22\x2e\xdc\x67\x75\xdf\x42\xf3\x53\xf9\xe3\x54\xbc\x26\x15\x04\x41\xb0\xf5\x1c\x59\x7c\x0c\x63\x6a\xb2\x4a\x15\xcb\x94\xe3\x11\x67\xc7\x17\x57\xe0\x6b\xe2\xf9\x6c\x44\xd2\x35\x38\x1b\x67\x6a\x25\x48\x20\x1f\xd2\xb5\x70\x7d\x47\x65\x29\xb5\xf0\x2d\x05\x2c\x5e\xc6\xca\x24\xa0\xcb\x74\x44\x43\xfb\x3b\xb5\x3f\xd8\x54\xc2\xd4\xb0\x4b\x4b\xab\x3a\x1d\x16\xbe\x5c\x39\xa8\xa1\x99\x01\xc4\x32\x54\xff\xda\xfd\x14\x0a\xa0\xf6\x4a\x29\x08\x0c\x03\xbe\x2c\xb8\x9c\xcd\x31\xba\x4b\xf6\x7d\xc9\xba\x1c\xa1\xc2\x16\xd0\xc6\x4d\x79\xcd\x92\x00\x73\x72\xff\xbf\x50\x7c\xb9\xeb\x7a\x23\xdc\x1d\xe6\xfc\xce\x68\xfe\x5c\x9e\xfc\x06\xe7\xf8\xde\x64\x2e\x6e\x49\x71\x6e\x31\xfe\x35\x9e\xa9\x47\x53\x37\xb1\x78\x05\xaa\xfc\x95\xac\xa4\xe2\x30\x37\x75\x96\x15\xb3\x58\x0d\x8f\x2f\x4f\x63\x1d\xec\x06\x89\x82\x62\xd0\x36\x33\x32\xc5\xab\x2d\x51\xc3\x6e\x82\x59\x6b\x3a\x24\x60\xd1\x56\x4c\x56\xaf\xef\xe8\x12\xcd\xac\xf7\x90\xd4\x5a\xc8\x92\x57\xda\x92\x0c\xa0\xe5\x52\x69\x93\x11\x34\x9e\x47\x51\x67\x33\x41\x1e\xe5\x7c\x84\x23\xb8\x52\x9b\x6d\x47\x97\xf9\xf0\x8e\x6b\xc2\x76\x6e\xe0\xdb\xd5\x84\xa1\xbd\x3d\x84\x2e\x08\x3e\xab\x8a\xf5\xf8\x03\x18\x54\x70\x5e\x7f\xe7\x31\xbe\x5c\x31\x67\x56\xab\x0a\x61\x0f\x4b\xea\xd6\x75\x62\x6a\xad\xe4\x96\x2e\x14\x71\xe2\xb1\x59\x56\xeb\xa9\x5b\xab\x56\x3b\x17\xb0\x98\x57\x2e\xed\xec\x70\x97\x2f\xb4\x89\x52\x8f\x1f\xb3\x1f\xe3\x6c\x9e\x12\x74\x7c\x72\xa2\x82\xf5\x07\x34\xbf\xbc\xb7\x1d\x4f\xf5\x12\x47\x64\x25\x5c\xa8\x0a\x1a\x39\x66\x71\x2e\xb2\xde\x14\xfc\xa4\x93\xc5\x3b\xf6\x96\xcc\x38\x6e\x69\xc7\x60\x91\xb4\xa6\xd4\x4d\xf7\x91\xf1\x57\xa8\x09\x41\xf9\xc8\x78\x22\xc8\xec\xa6\x03\x55\x32\x62\x69\x48\xd2\xb7\x38\xa4\xf3\xec\x08\xb5\x0e\x07\xff\xd9\xea\x36\x50\x23\xf2\x7f\xce\xb5\xdc\x25\x4f\x71\xac\x72\xf0\xc8\x19\xe9\x92\x4c\x72\x07\xed\x96\xc9\x45\xd0\x53\x76\x8a\x26\x1a\x55\x38\x4f\x71\x15\x00\xf5\xad\x9f\x4d\x59\x9a\x93\x2c\x97\xad\x3e\x77\xae\xec\xe8\xbb\x5f\xe2\xe8\x7b\xcc\xe2\x3c\xc5\xd9\x32\x28\x13\x92\xab\x9a\xef\xc8\x22\x6f\x57\x6b\x6b\x8b\xc3\xdc\x80\x67\xf4\x4a\xee\xd8\x57\xd1\x11\x0b\x08\x11\x3f\xa0\xa6\xb9\x93\x48\x49\xa1\x41\x93\x50\xab\xb6\xdd\x1f\xff\x9f\xb4\xa8\x3e\x56\x71\x51\x4b\x87\x2f\x44\x53\x85\xbe\xc9\xac\xe5\xa3\x3f\x14\xda\x4d\xcf\xc8\xe5\x88\xe1\x34\xfc\x89\x05\xf3\xcc\x5e\x00\x83\x8d\xc7\x95\xda\xfa\x90\x9e\x53\x15\x94\x6c\x83\x11\x57\xd7\x94\xd8\x0b\x83\xcb\x32\x69\xad\xf8\xd2\x50\x66\xef\xeb\x7f\x1c\x3d\xc4\x6a\x8a\x9d\x58\x40\xa8\x54\x62\xdf\x01\xf3\xf8\xdb\xaf\xc1\xfe\xb2\xde\xbf\xc6\x4c\xb2\xc2\xea\x3c\x90\x34\xd4\x32\x3a\x5f\xe2\xf3\x2b\xcf\xc1\x35\xa8\xce\x37\xaf\x33\x5f\xf5\xe8\x83\xdb\x7c\xc9\x89\xe7\xe5\xcb\xce\xbb\xd0\xcf\x40\xd7\xdf\xa1\xb7\x64\x4c\x52\x05\xf5\x3d\x67\x34\xb3\x0f\xed\x3d\x40\xdd\x3d\x7e\x88\xb3\x0e\xca\x88\xe0\x7e\x24\x9a\x84\x2c\x98\x73\xc2\x00\x57\x2f\x07\x91\x92\x09\x4e\x43\x85\x2b\x58\xa7\x39\x03\x1a\xc0\x12\x71\x57\xdf\xe3\xe3\xd3\x8c\x14\xef\x47\xb0\xd5\x4d\xfc\x47\x35\x19\xd3\x6a\x1b\x5d\xa2\x79\x92\xed\xe7\xa4\xae\xf1\x1e\x55\x78\xe0\xa7\xcf\x0e\x55\x05\xb9\x2d\xfa\xbb\xfc\x7d\x55\x65\x93\x5e\x86\x46\x39\xae\x6d\x7f\x4e\x4b\x8c\xdd\x92\x83\x59\x23\x07\xb6\xfd\x80\x6a\x16\x3f\xd6\x5f\xee\xe6\x89\xb1\xef\x86\xcf\xa7\x46\x0c\x8d\x33\x35\xe9\xa6\x34\xe6\xc1\xeb\x41\xd1\x14\x65\x46\x5e\xc2\xc5\x1c\x17\xc3\xab\x7a\x35\x7c\x8c\x3d\x42\x1e\x53\x27\x70\xd1\x70\xe0\x9a\xa0\x14\x8e\x5c\xca\x4b\xe5\x67\xd1\x78\xa5\x58\xbc\x4e\xe4\xd8\xd2\x60\xbc\xc0\x5a\x9a\x68\xb0\x92\x59\x30\x27\x9d\xef\x86\xb8\xd8\x38\x1f\xd0\x34\x0a\x2e\xbc\xb5\xcb\x62\xf4\x96\x8c\x00\x28\x98\x15\x8e\x56\xf5\x2d\x0b\x3a\xa8\x28\xf2\x54\xc9\xd6\xfb\x33\x9c\x58\x29\xd6\x35\xe5\x13\x65\x1d\xeb\x85\x43\xc7\xa8\x5d\xcc\xdc\x4e\xb3\xd7\x73\x2a\x47\x2f\x73\xb5\xf3\x13\xaf\xf4\xca\x27\xe7\x13\xa9\x34\xee\x38\xa1\x7b\xab\xce\x6e\xc4\x62\xbd\x16\x12\x98\xdd\x6c\xc5\x13\x09\x6a\x78\xb1\x1a\x7d\x8f\x5a\x76\x2c\xa8\x9f\x3b\xcf\xf4\xaf\xcf\xf7\xee\x79\x63\x84\xe6\xcf\xdc\x27\x9b\x89\xec\x6b\x6e\x88\x2f\xa3\x37\x6e\xca\x3a\xdf\x11\x76\xf6\xce\xe8\x7c\x1b\x7a\x3a\xae\xc7\x7e\xde\x19\x25\xb1\xba\xf2\x97\xe9\xc0\x6c\x1d\x91\x75\x22\x4b\x73\x75\x15\x7d\xf5\xcc\x25\xa3\x95\x46\x1e\x7f\xbc\xb9\xac\xfc\x66\x74\xa0\xf3\x31\x3f\xb7\xa4\xf5\x39\xb8\xe3\x5a\x9f\x9d\xff\xd3\xed\xf5\x7f\xba\x03\xaa\x9c\xaf\x51\x43\xb1\xed\x80\xb9\x34\x8e\x68\x4c\x7a\x6e\xdc\xdc\x31\x8d\xa2\x23\xd4\x0a\xe6\x69\x4a\xe2\xfc\x58\xdc\x9e\x9e\xf0\x74\xff\xc0\x53\x39\x98\x82\x79\x46\xd2\x13\x12\x91\x40\xa4\xe2\x8f\x89\xa3\xe3\x38\x99\xa6\x34\x3e\xb3\xb4\x0a\xcd\x14\x02\x7c\x4c\xeb\x2a\x01\x52\x4f\x07\xb0\x39\xe9\xac\x64\x9f\x33\x10\xcb\x90\x10\xd1\x58\x4a\x4d\x4e\xfe\xfd\x4f\x10\x68\xdc\x00\x09\xe7\x5a\x59\x6c\xfd\x86\x8d\xd3\xd7\x6e\x9a\x09\x75\x58\xf0\xdb\x2e\x5e\xfd\x55\x48\xc8\x33\x84\xd1\x74\x3e\xc3\x71\x2f\x25\x38\x04\xb9\x98\xc8\xea\xa2\x02\x60\xea\x08\x80\x53\x9c\x43\x22\x2b\x4c\xe3\x0c\x51\x25\x77\x9f\xe6\x79\x92\x1d\xed\xed\x5d\x5c\x5c\xf4\x2f\x1e\xf6\x59\x3a\xd9\x7b\xf7\x76\xef\xe4\xdf\xff\xec\x71\xae\x34\xcb\xf6\xfe\xe3\xc7\xff\x9d\xd3\x73\x1c\x91\x38\xbf\xe7\x24\xbb\x7a\x01\xdf\x57\x1a\xf3\x8b\x28\x62\x17\x19\xc4\x05\xcc\x19\x4a\x89\xb8\xaa\xd1\x05\x1f\x9a\x90\x10\xb3\x34\x04\xeb\x9d\x0c\x42\xf2\xb1\x79\x8e\xe6\x31\xcd\x33\x34\x23\x38\x46\x34\xce\x68\x48\x10\x8e\x51\x76\x3e\xf1\xf4\x07\x3f\xb1\x14\x91\x05\x9e\x25\x9c\x3f\xa2\x63\x7d\x70\xd4\xf4\x69\x86\x0e\x07\x03\xd4\x06\x0a\xd3\x41\xa3\x4b\xb4\xcf\x7f\x0a\x12\x24\x04\x0b\xdf\x21\x1c\x87\x30\x38\x10\x8c\x9e\x53\x72\xf1\x03\x5b\x3c\xff\xdb\x00\x0d\xd0\xe1\x00\xed\x0f\xfe\x26\xab\xe5\x53\x2a\x46\x24\x73\x33\xf9\x43\x97\xe3\x04\x24\x3a\x9f\x08\x69\xee\x84\xa1\x71\xca\x66\x42\xdc\xcd\x12\x14\x91\x31\xdf\x8e\x34\x26\x29\xe7\x44\x07\x1d\x09\x9a\xa9\x00\x81\x10\xfb\x07\xb5\x0f\x07\xdd\xfd\x41\x07\x46\x46\x70\x30\x85\xe5\xd0\xf2\xe1\x0b\x96\xe6\x53\x34\x1c\x24\x0b\xcb\x82\x5e\x0c\x7b\x35\x1b\x7a\xf9\xdc\x2f\x9a\xd0\x6f\x5d\xea\x69\xa1\x92\x9b\xcc\x4b\x94\xa9\x6a\x72\x56\xba\x8a\xfc\x7d\x75\x6b\xfa\xe5\x32\x4d\x6b\x34\xfc\xa7\xec\x79\x0d\x69\x66\x2b\x3b\x9f\xb4\xb6\x25\xbe\x2c\x4a\xf5\xc6\x2c\x98\x67\x22\x32\x44\x0b\xde\x41\x2d\x6f\x31\x8f\x90\xb7\x8a\x2d\x9c\x52\xdc\x93\xe1\xc3\x8f\x9c\xad\xf9\x5e\xc1\x40\x47\xa8\xc5\xd9\xfc\x96\x23\xcf\xeb\x58\xa1\x4a\x74\x8b\x66\x72\x3a\x19\x02\x46\xfe\x8c\xe7\x51\x54\x82\x1a\xf7\x94\x38\xcc\x7c\xb7\x64\x65\x42\xa2\x23\x71\xf8\x4b\xb9\x01\xec\x6e\xe4\xab\xdd\xc8\x77\x46\x42\xe4\xd2\x8b\x8d\x80\x54\x34\x67\x35\xa3\x5b\x75\x20\x4a\xa4\x29\x9a\x02\x80\x8d\xd0\xfe\x01\xda\x3f\x10\x81\x7e\x54\x9b\xd9\x9c\x4a\xba\xad\x45\xc1\x1b\x10\xa2\x28\x50\xe8\x73\xa7\x2d\xff\xde\x92\xf8\xe4\xf0\x26\x06\x00\xda\xca\x63\x3c\x99\xa7\x55\xaf\xc7\xfd\x27\x4e\xad\x3a\x98\xfc\xbb\x09\x27\x22\xb6\xa6\x0a\xea\xa1\x5f\xb1\x36\xe8\x88\xde\xe6\x6b\x09\x21\x74\xcf\xf0\xd7\xa8\x87\xa0\x9f\x18\x47\x8e\x26\xfb\xbb\x3d\x2d\x25\xe1\xe3\xae\xbd\xa4\x5a\x09\xce\xa7\xfc\xa9\x88\x42\x8e\xc1\xc3\xa7\xe8\xf0\x7c\x78\xf0\xf3\xe1\xbf\x0f\xa7\xc3\x83\xd9\xa0\xb7\xff\xf3\x61\xd0\x1b\xf6\x87\x68\xd0\xdb\x47\xfd\xa7\xbd\x7d\xb4\x7f\x3e\x3c\x08\x06\x68\xd8\x1f\xf6\x9f\xa2\x7d\xfe\x7f\xd3\xe1\x41\x00\x55\xd0\x7e\x8f\x97\xf5\xf6\xff\x7d\x18\x0c\x78\xab\x1e\x6f\xc1\xff\xef\xcf\x16\xd2\x58\xa2\xec\xd6\xdf\xcc\x73\xfe\x9c\xfe\x21\xc2\xf1\x99\xfd\x38\x2f\xfb\x6e\xf3\x6d\x2b\x68\x57\xd5\xf6\xb9\xda\x2a\xc1\x1c\x29\x4d\xdb\x58\xde\xaf\xd2\x86\xbf\x38\x30\xa0\x00\x80\x5e\xe6\xec\x97\x55\xed\x94\x43\x68\x4c\x69\xca\x1a\x3f\x2b\x9c\xfb\x47\x5f\x52\x6c\xaa\x06\x6d\xe1\xeb\x73\xa0\x01\xab\x11\x80\x8c\xe4\x2f\x85\x50\x45\x2e\x4c\xf9\xd9\x7e\x5a\xd1\xa0\xee\x34\xba\x35\x8d\x04\x2d\xc5\xc9\xf2\x2e\x1f\x1f\x54\x35\xa8\x95\xbb\xb9\x55\xaf\x85\x10\x98\x0e\xe0\x76\x3f\xc6\x51\x04\xe8\xd3\x36\x71\xef\x8f\x59\x9c\xe5\xe9\x3c\xc8\x59\xca\xfb\xa2\x63\xd4\xfe\x46\x7f\xd6\xf1\xf1\xd9\xd8\xa9\xc8\x6b\xe6\xd3\x94\x5d\xa0\x98\x5c\x20\xce\xd0\x40\x72\x96\xf6\xdf\x8e\x71\x1c\xb3\x1c\xac\x68\x10\x16\x1c\xa4\x8c\x40\x20\x47\xf2\xb7\xce\x33\xf4\xd9\x1d\x5a\xc2\xb2\x8c\x8e\x22\x62\x75\xf0\x16\x66\xdc\xce\x48\x34\xee\x02\x30\x3d\x34\x5e\xe4\xf6\x0e\x86\x35\x24\x0e\xd4\x10\xe0\x51\x3a\xc5\x59\xdc\xca\xd1\x88\x10\xfe\x5a\xa6\x39\xc5\x11\xcd\x48\x88\x7a\x28\x9b\x27\x24\x6d\x77\x9c\x1a\xbc\x07\x12\x8a\xa1\x29\xa5\x29\x9f\xc1\xfd\xfb\xa8\xad\xb4\xe1\xfc\x37\xe7\x4f\xff\x26\xb8\xaa\xbf\xa1\x4f\x9f\x50\xe1\x9b\x99\x25\xfa\x5e\x14\x1f\x21\x3e\x62\x6f\x33\xa4\x26\x2c\x6b\x67\xf3\x11\x98\x12\x74\xc5\xb0\xe0\x6f\x35\x55\x09\xdc\x7c\x10\xfc\xba\xee\x82\x8f\xce\xfb\x08\x7e\x3d\x55\x5b\x73\xc2\xeb\xf2\xa3\x9f\x92\x2c\xe3\xc3\x98\xcd\xb3\x1c\x11\x91\x06\x64\x44\xa0\xb1\x48\xf8\xa1\xba\xe8\x42\xca\x80\xbf\xa1\x07\xa8\x30\x16\x58\x2a\x35\x7a\xfe\xd2\xc8\x99\x8c\xa0\x2e\x59\x04\x29\x62\xb4\x06\xe8\x0c\xd7\x34\xe1\x77\x4a\x60\x76\x9e\x23\xb2\x64\x1a\xcc\xe2\xd8\xc1\xfd\x84\x86\x0b\x5d\xa4\x34\xb7\xa2\xfd\x71\x10\x63\x3a\x99\x5b\x11\x00\x39\x9a\x75\x9e\xc1\x52\xda\x8b\x2b\xc7\x97\x11\xce\x07\x8a\x21\xbc\x19\xa3\xef\xcb\xcb\x2b\x36\xc8\x8c\xad\xff\xf1\x23\xcc\xe4\xe3\x47\xf4\xdc\xaa\xa2\x25\xdf\xd9\x94\xcd\xa3\xf0\xb7\x24\x14\xae\xf3\x46\xb2\x6c\x95\xb7\x73\x92\xe5\xce\x9d\x65\x8c\x18\x7e\xc0\x19\xd1\x0e\x2a\xca\x02\x81\x03\x1e\x63\xbe\x5a\x97\xea\xde\x01\x82\x2a\x17\xfd\x27\xf1\xa9\xe3\x35\x7e\x76\x4f\x37\x3e\xa9\x18\x55\xfb\x63\xa1\x2f\x64\x61\xab\xdd\xac\x8b\x3e\x16\x40\x23\x03\xc9\xae\xda\xb6\x2d\x27\x7c\x42\xc4\x4f\x6b\xd7\xa9\x6e\xa0\x99\x3b\xbc\x9a\x44\x88\xf6\x66\x2c\x7d\x9c\x24\xd1\xa5\x2c\xc6\xe9\x04\x2c\xe8\xb2\x8e\x36\x90\xd0\xe6\x11\x76\x97\x06\x1b\xfb\x62\x63\x34\xb8\xaa\x9d\xf3\x2a\xb4\x63\xb2\x10\xef\x0a\x7b\xae\x72\xf4\x7c\x7b\x61\x40\x7d\x29\x6e\x31\x95\xf5\xa8\x9e\x2d\x19\x56\x4a\x62\x91\x04\x5e\x8f\x43\x94\xb4\x4b\xfa\x93\xa8\x61\x75\x59\xd2\x8f\xac\x6b\x77\x27\x2a\x7d\x96\x7c\x75\xbf\xb0\xbd\xfc\x24\x55\xca\x11\x5a\x46\x8e\xd0\x32\x63\x92\xbd\x00\x8a\x7a\x97\xb3\x61\x92\xc4\xd3\xc9\xbb\x48\xcd\x67\x07\x8b\xbb\xa8\x65\x1f\x9d\x56\xa7\xd3\xf6\x70\x47\x29\x23\x2a\xa7\x28\xb5\x14\x45\xc6\x2a\x73\x2a\x6e\xe3\x31\xf6\x78\xa3\x8f\xb1\x1a\x2e\x0b\x48\x0f\xc9\x4f\x72\x9c\xd3\xc0\xc1\x5e\x55\xd8\x3e\x23\x97\x5d\x41\x69\x57\x21\x3d\x7b\xdf\x21\x92\x45\x34\xce\x7b\xd2\xc0\x00\xc5\xac\x07\xc1\x5c\x7a\x29\xc1\x59\x46\x27\xb1\x90\xbe\x22\xe4\xb4\x7f\x7f\x46\x2e\x3f\xa0\xe7\xa2\xc3\x67\x1e\x28\x12\xd7\x43\x92\x43\x73\x00\xd6\xef\xa4\x9a\x65\x91\x2f\x7e\x72\x5d\x5b\x20\x39\xd2\x29\x8e\x22\x76\xf1\xe3\xff\xce\x71\x54\xc5\xef\x0e\x4d\xfc\x4a\xbb\x7a\x2d\xfb\x6a\xd5\xbb\x16\x46\xb2\xb8\xc6\xee\x58\x4d\xa0\x5c\x7f\xc1\x9f\xee\x04\x10\x3b\x01\xc4\x36\x04\x10\x0f\xa5\xc8\xa1\x5c\xe6\xf0\xc4\x15\x3a\x94\x4b\x1d\x9e\x28\xb1\xc3\xac\xf7\x14\x0d\x0f\xa2\xde\x61\xef\x10\x0d\xfb\x07\xc3\x1e\xff\xcf\x2f\xc3\x01\x1a\x1e\xf4\x87\x8f\xa3\xc7\xfd\xc3\xa7\x3d\xfe\x9f\x5f\x86\x4f\xd1\x93\xa8\xf7\x14\x3d\x2d\x93\x54\x94\x49\x27\xae\x55\x22\xb1\x44\x0a\x61\x49\x1e\x56\x96\x36\x14\x0e\xf6\xe3\x4d\x66\x65\xdf\x1d\xec\xdd\xc1\x2e\x1c\xec\xab\xca\x12\x67\xbd\x7d\x34\x1c\xfc\xfc\xf8\xbc\xb7\x3f\x1d\x0e\xce\x1d\xe1\x62\x55\xbc\x67\xe3\x38\x53\x56\xe1\x5a\x0e\x73\xd5\xd0\xca\x4e\x76\x55\x34\xe9\xd2\xf2\xc6\x67\xbe\xb4\x75\x91\x00\xdc\xd0\xdc\x02\x34\xa9\x8c\xdb\xfd\xe5\xf3\x0a\xd0\xe4\x06\xe4\x14\x78\xbc\xc9\x9c\x02\xbb\xd0\x28\xb7\x3c\x34\xca\xc4\x95\x84\x95\x0f\xe1\x49\x45\xf5\xba\x7b\xc9\xad\xe9\x5a\xc2\x6a\x01\x50\xd5\x9c\x9f\x56\xd4\xaf\x9b\xaa\x07\xd9\x40\x00\x9a\x0c\x82\xb9\xaa\xee\x86\x83\xb2\xda\xb5\x9d\x59\x40\x0d\x0f\x50\x25\xa7\xaa\xec\x77\xb8\xbc\x6d\xdd\x28\xaa\x3b\xd4\x70\x95\xf8\xae\x72\x08\xc5\xaa\x75\x3d\x6a\x70\xdb\xe5\xb9\xae\xc3\xb4\xfa\x8c\x5c\x06\xd5\x26\xc7\x8f\x0f\xfd\x8a\x75\xe0\x65\x95\x6b\x8d\xc0\x73\x8c\xe3\x80\x54\x89\x15\x0e\x1f\x3f\xf4\x2a\xd6\x41\x17\x35\xcc\x92\xb2\x88\xa5\xaf\x71\x4c\x93\x79\x84\x73\xf0\xc6\x2d\x47\x1d\xb3\x46\x2f\xce\x71\x8e\xab\x2a\xee\x3f\xf1\x2b\xd6\x0d\x46\xd4\xf8\xba\xad\xd3\x57\xcb\x51\x77\xe5\x71\x29\x38\x5b\x33\x9c\xe7\x0d\x85\x8d\x29\x7a\x8e\x1e\xee\x3f\x53\x1e\xe7\x6e\x10\x10\x9d\xa9\xd6\xc3\xbf\x3e\x99\x25\x53\x9c\xd1\x3f\x49\xc7\x0b\xf3\x62\x00\x98\xf0\x76\x83\x3e\xd0\x34\xd1\x43\x48\x22\x22\xc2\xe6\xd5\xf7\x30\xc6\x61\x01\x38\xc4\x20\x91\xbe\x6a\x1c\xec\xfe\xa3\x8e\x9d\xab\xb4\xcc\x0b\x60\xcc\xe2\xfc\x27\x3c\xa3\xd1\x65\x49\x6c\x21\xf3\x71\x85\x40\x44\xc3\x87\x9d\x55\xe2\xbb\x78\x11\x90\x0a\xe1\x5d\xbc\xef\xca\xf5\x40\xfc\x5b\x1b\x79\xc8\x8f\xb7\xe3\xed\x9d\x1e\x65\x21\xb0\x8b\x57\x50\x1e\xf9\x48\x22\xc7\x1e\xda\xd7\x3e\x10\x53\x9a\x93\x93\x04\x07\x04\x5c\x1e\x2e\x20\x3b\xa0\xeb\x1f\xd1\x1a\xd3\xbc\x17\x88\xb9\xb5\x56\xf2\x7d\xd0\xa3\xdd\xdb\x13\xa1\x75\x84\x2d\xb1\xbc\xdd\x84\x65\x33\xd8\x29\x0b\xab\xd2\x7c\x4a\x62\x74\x1a\x44\x34\x38\xe3\x6f\x81\x53\xa9\xda\x66\xe7\x24\x4d\xc1\xf8\x5c\x34\x60\x29\x1a\xb1\x7c\xaa\x56\x71\x9e\x66\x05\x5f\x3d\xfe\x3f\x26\x4c\x37\xb4\x27\x07\x1f\xc4\xbf\x98\x2a\x46\x10\xd1\x05\xbc\xc8\x8d\xd5\x76\x8c\x8e\xa7\x29\x9b\x11\xd4\xc6\x19\xca\x53\x3a\x99\x90\x94\x84\x68\x74\xa9\xa3\x98\xc3\x83\xb2\xe3\xac\xad\xd3\xc1\x5b\x32\x63\xe7\x04\x9d\x0a\x87\xdb\x53\x59\x45\xd6\x37\x71\xa9\xca\xaa\xca\xaf\xd2\xd2\x55\x58\x9d\xaa\xa5\x30\xa8\x6f\x1a\x4e\x52\x72\x89\xa6\x74\x32\x8d\xf8\x9e\xca\xcf\xbf\x93\xd1\x19\xcd\xdf\xe1\xe4\x67\xf5\xa1\x34\xee\x4f\xc0\x66\x33\x16\x8b\x2d\x4b\x70\x6a\x67\x15\x57\xcb\x99\x30\xea\xe0\x70\xeb\xfe\xd1\x94\xef\x44\x17\xdd\x3f\x82\x85\x6b\x1d\x59\x5a\xb1\x02\x3a\x2e\xa5\x30\x3e\xbe\xa2\x41\x7f\xf0\x44\xad\xec\x67\xab\x57\x11\x84\xcb\xed\x8d\x2d\x4e\xa6\x38\x64\x17\x3a\x12\x18\xfc\xca\xde\x0f\x3f\x74\x37\x3b\xa4\xe1\xbe\x1e\x92\xbd\x31\x40\xef\xdc\x8d\x69\x5d\xc7\xb2\xd8\x63\xc0\x70\x81\x9b\xde\x44\x8e\xff\xb7\x82\xd2\xf4\x7c\x27\xa7\x87\xfb\x3e\x31\x32\x25\x4d\xe8\xe3\xa3\x4e\xb1\xef\x63\x6d\x86\xec\x05\xad\x1a\x3e\xf5\x3b\x1b\x3e\xb5\x9b\x7b\x61\xb6\xd6\xa0\xb8\xf2\xb0\xfc\x42\xc6\x1c\xf8\xbe\x57\x2c\x17\xc1\x94\x57\x3b\x76\xd5\xd1\x3f\x7d\x16\x4a\x83\x8d\xe9\x2b\xef\x1a\x0f\xa7\xa8\xee\xdd\xb6\x4b\x8f\xae\x0e\x1b\xe6\x84\xe7\x13\xf8\x02\x46\xb9\x07\xc9\x02\x0d\x50\xef\x49\xb2\x28\x1c\x77\x07\x9d\x83\x3a\x24\x16\x77\xbb\x3f\x36\x34\xe8\x1f\x78\xe8\xbb\x39\x27\x36\xc9\x0e\x17\x72\x8c\xa8\xa3\xb1\x56\x82\xe4\xab\x26\x47\xde\x6c\x62\xe4\x3b\x10\x9a\xeb\x78\x9e\xe5\x6c\x26\xb1\x16\xe2\x28\xf5\xd1\xef\xd2\xa7\x28\x9b\xb2\x8b\x18\xb1\x38\xba\x44\x74\x8c\x4e\x59\xcc\xdf\x1e\x24\xcb\x5f\x42\xe5\x53\x44\x33\x94\x11\x6b\x67\xed\x53\x77\xf7\x76\x57\x04\x31\x03\x46\x4b\xc5\xa7\x02\x52\x69\xe6\x2f\x29\xe7\x2d\x8e\xcd\x51\x8f\x61\x2c\x3e\xe6\x3c\xcf\x15\xf2\xcd\xb0\xf8\xff\x90\xcb\x97\xec\xa2\x3a\x19\x7e\x11\x86\xc9\xcc\xa3\xde\x56\x5e\x8a\x1e\x0b\x77\x21\x51\x0f\x1f\xa3\x9d\xe7\x2b\x23\x82\x7d\x75\x2a\x5e\xd8\x38\xde\xb7\x06\xe8\xe0\xf8\xad\x48\xad\x03\xd4\x5a\xaa\xa5\x8e\xa7\x34\xc9\x50\x4a\x92\x94\x64\x1c\x51\x39\xb1\x89\xc8\x02\x91\x38\xa7\x90\x09\x8a\xc6\x28\x9b\x61\x3e\xf7\x88\x05\x67\x60\xd5\x17\x4c\x85\x81\x2a\x78\x84\x06\x96\xf6\x4a\x6a\x12\x2c\xe3\x38\x40\x9e\x6f\x3d\x9b\x18\xb8\x71\xb4\xe0\xcc\x56\xba\xd2\xa4\x8b\x0a\x6d\xe0\xfd\x68\x69\x89\x69\xd2\xb6\xcd\xfa\x64\xc8\x02\xfd\x33\x27\x33\x0e\x45\x5a\xb9\xa5\x24\x97\x1f\x8d\x37\x9c\x91\x8c\x9a\xbe\x45\x75\xd0\x36\xc8\xfa\xfc\x65\xd2\x06\x88\x11\x78\x31\x6a\xcb\xb8\x7e\x44\xe2\x49\x3e\x05\x5b\x39\x7e\x89\xbd\x48\x53\x7c\xd9\xe6\xb5\x3a\x5d\x10\x7c\xa1\xe7\x68\xf0\x4c\xfc\xf5\x77\x68\x2d\x7e\x3c\x78\x60\xac\xbc\x78\xd3\xf7\x1f\xa5\x85\x8f\x86\x2c\x4a\x94\x41\x96\xa3\x1e\x49\x09\xb8\xcc\xc0\xec\xc4\x1f\xfc\xf5\xa4\x54\x5c\x95\x72\x50\x7f\x82\xca\x59\x8d\x4f\xd4\x32\xc4\xfc\xf4\x49\x00\xf2\x24\xd5\xee\xd6\x74\x3a\x60\xc4\x25\xcd\x05\x85\x7b\xd1\x7b\x0e\xf6\x43\x3f\x60\x71\x80\xf3\x36\x9f\x55\x07\x72\xab\xf3\x62\xf5\x6f\x3f\x98\xd2\x44\x44\x98\x03\x17\x3c\x59\x3a\xc5\x71\x18\x91\x97\x86\xc3\xe0\xc7\xd0\xc1\x1e\x48\x8a\xd5\xb1\xf9\xb1\x93\x9c\x25\xc2\x33\x19\xf2\x65\xc1\x6b\x73\x34\x1f\x8d\x22\x1a\x4f\xd0\x3c\xd1\xe9\xca\xf8\x70\x4f\x65\x33\xa8\xda\xcf\x72\x96\x70\x22\x86\x27\xe0\x91\xdf\xd6\xf6\x7d\x7c\x87\xbd\x43\x8c\x9e\xcb\x21\x0a\x7f\x51\xef\xab\xb6\x07\xa4\x63\xd4\xf6\xbe\xd9\xa6\x85\xde\x27\x39\x9b\x67\x1e\xf3\xef\x2c\x86\xa4\x75\x75\x8b\x20\x50\x7c\x4a\xb3\x6f\x13\xc9\x43\x59\x43\x35\xcf\x25\x4d\x7b\x55\x85\x6f\xd5\x5c\xa0\xd4\xad\x58\x3a\xf9\x6f\x4b\x27\xef\x36\x34\xe3\x75\x9b\xc8\x72\xbd\x52\x7c\xd0\xe2\x5c\x00\x96\x29\xd9\xb0\x41\x2f\xb5\x36\xce\xca\x8a\xf1\xdf\xbf\x8f\xda\xd0\x16\x42\xaa\x71\xd6\xbe\xc5\xd1\x55\x17\x89\x97\x84\x13\x6a\x4c\xec\x78\x92\xc2\xbf\x4a\xee\x69\xc5\xfb\x92\xa0\xfd\x1d\x41\x24\xca\x48\xd9\xae\xf2\x31\xe8\xfe\xf8\xcd\x22\x86\xb1\x5a\x97\xb5\xc8\x60\xba\x36\xf3\xca\x82\x95\x7a\xe0\x8d\x9d\xe3\xe6\x06\x5f\x73\x3e\xf5\x47\xd1\x3c\x6d\x3b\x11\xd0\xd4\xbf\xce\x0e\xc8\x7d\x74\xb1\x5a\x16\x56\xe3\x33\x99\x25\xca\x39\xb1\x09\x61\xb2\x28\x75\x47\x28\x78\xd5\x15\x61\xab\x95\xfc\x5b\xe2\xbd\x18\xd2\x19\xe1\x0f\x4d\x61\xd8\x2b\x5f\x3b\x52\x55\x5a\x6d\xf5\xab\x8f\xd0\x3e\x7a\x0e\x42\x28\x07\x4f\x3f\xaa\x73\x55\x7e\xac\xc4\x63\x84\x53\x12\x8e\xf5\x02\xe1\x45\x99\x5d\xcb\xf8\xb6\x7f\x2c\x75\x6e\x47\xb6\xa3\xb6\x0b\xac\xe0\xe5\x8e\xd4\x13\xdb\xd4\x81\x9f\x15\x87\xbd\xe6\x9c\x5b\xc7\xd5\x3b\xa9\x4b\xe8\xc1\x52\x52\x60\x18\x79\x77\x32\xa6\xdc\xae\xad\x38\x1d\xb7\xae\x2a\x75\xc6\xb2\x9a\x6f\xfe\x47\xed\x9c\x2f\xb6\xa4\xce\x35\x1f\xd6\xb0\x25\x92\xee\xf0\xa5\x12\x7f\xca\xf5\x10\x3f\x9c\xe9\x42\x64\x52\x3d\x9d\x96\x9d\x5f\x47\xb9\xf3\x2b\x14\xb2\x43\x17\x34\x0e\x21\x5a\xeb\xcb\xfb\xd7\x67\x13\xa6\x53\x8b\x11\xbb\x6a\xdb\x97\xba\x02\xdb\xcd\xb5\xb0\xab\xeb\xef\xb4\x1d\xdf\x93\x03\xe9\x38\xe7\xc2\xcc\x5d\xde\xe3\xcf\xaa\xaf\x41\x4e\x30\x3d\x94\xb8\x7f\xbf\x60\xf7\x43\xb3\x7f\xe3\x88\x86\xca\xf0\xc7\x6d\xe0\x10\x74\xa7\xef\xda\xf8\x91\x2e\x10\x37\x90\xa4\x7e\x8d\x54\xb3\x1f\xa5\xe7\xb3\x49\x20\x05\x0b\xd1\xbd\x99\x57\x07\xa1\xfc\xdc\xe0\xea\x69\xbe\x0a\x6e\x3a\x23\xa9\xbe\x34\x0a\x9e\xd2\x18\xa2\xf6\xa8\x1b\xac\x8e\x3d\x62\x1b\x35\xb0\xd2\x63\xfa\x68\x61\x11\xcb\xe5\xfb\x6f\x2a\x3b\x7b\xbf\xb7\x87\xbe\xe5\xcf\xd0\x9f\xe8\xe2\x35\x41\x3d\xa1\x35\x88\x18\x3b\xcb\xa4\x41\x4d\x74\x89\x02\x96\xa6\x24\xc8\x85\xf3\x15\xa4\xd1\xb8\x98\x5e\x22\x9a\x23\x92\xa6\x2c\x15\x62\x13\x8b\x7a\x2f\x43\x22\x33\x12\x17\x81\x56\xc2\x08\x79\x29\x58\x17\x46\x01\x13\x1c\x6c\x93\xd2\xd7\xe3\xd5\xfb\x38\xd6\x91\x5c\x8b\x7d\xf9\x50\x4b\xb1\xcf\xde\x4b\xad\x1a\x79\xee\x90\x69\x87\x35\xfb\x46\x7d\xb1\xf7\xc9\x6a\xa8\xd0\xe5\xd3\xa7\xc2\x65\xf2\x3d\x1a\xa0\x23\xd4\x1b\x16\xfa\x6e\x6e\x1b\xc8\xff\xd7\x0a\xe9\x79\xcb\x2c\xdf\x92\x90\x28\x00\x9f\x41\x30\x13\xa1\x9e\x69\x55\x9c\xf3\xd2\xbb\xd7\xbc\xcb\x4b\x6f\x28\x75\x6c\xea\x6e\x5c\xe7\x50\xc9\x32\xb3\x11\x85\xb8\xc6\x48\x45\x30\xb6\x78\x98\x71\x3b\x66\x21\xe9\x78\x91\x71\x05\x1b\x63\x3f\xb0\x58\x48\x9e\x59\x55\x3e\x5b\xfb\xdd\xf5\x8e\x81\xf9\xdd\x70\xd5\xfd\xc8\xc8\xa8\x61\x74\x64\xa4\x38\x18\xfd\xdb\x1a\x8b\xa1\x41\xb2\xc8\x72\x48\xfa\xfc\x01\x7e\x48\xdc\xe0\x8c\xdf\xb3\x7b\xca\xd9\xca\x0a\x6b\x6c\x4b\x0a\xae\x9e\x9d\x8d\x26\x32\x33\x9b\x10\x05\x78\x76\x80\x9b\xcc\xa8\xb6\x33\xe1\xde\x99\x70\x4b\x13\xee\x7d\xb4\x7f\xfc\xa8\x7f\xf0\x18\x4c\xb5\xe5\x1f\xc3\xfd\xec\x80\xff\x35\x1c\xe8\xff\xef\xc9\x82\xde\x70\x70\x32\x7c\xdc\x3f\x7c\x08\xd5\xd0\xfe\x9f\xb3\x43\x34\x7c\x08\xde\x16\x87\xfd\xc3\xa7\x68\xf8\x98\x17\x0f\x1f\xf6\x0f\x86\xe8\x09\xff\xcf\xf0\x31\x7a\x8c\xe4\xb7\x01\xfc\x77\x1f\x3d\x16\x9f\xe0\x3f\xa2\xbe\xf8\x02\xb5\x1e\xf3\x26\xa2\x29\x40\xe1\x9f\x25\x04\xc7\x8f\x43\xd9\x53\x19\xf9\x1c\x94\x5c\x8f\x0f\x87\xea\xbc\xd4\x83\x43\x99\x67\x89\x3f\x9a\x7b\x6f\x40\xf5\xe2\xc1\xdf\x64\x50\xdd\x8d\x1d\xfc\x97\x14\x47\x6c\x52\x69\xce\x76\xf8\x85\x8d\xb7\xc5\xf0\xca\xcc\xb7\xad\xd1\xbf\x00\xb0\x55\x36\x7f\x87\x8f\x1f\x35\x99\x84\x03\x6a\x7b\x53\x91\x1d\x2c\x99\xd1\x3b\x08\xa2\x58\x35\x9f\xc7\xcd\xe7\xf3\x4e\xc4\x37\xdb\xd6\x6c\x00\xfc\x92\xb9\x48\x2b\xa8\xca\xd9\x3c\x69\x3e\x9b\x63\x65\x74\xb4\xad\xf9\xc8\x0e\x9a\xcd\xe8\x1d\x59\x54\xcf\xea\xe9\xca\xb3\xe2\xe0\xb6\x3e\x33\xde\x49\xe5\xec\x38\x8b\xf3\x9a\x8d\x68\x44\xea\xa9\xc2\x93\x41\x93\xc9\xf9\xd0\xb6\x31\x37\xbf\x8f\x9b\xe0\xe7\xb1\xc9\xe0\x5f\x37\x31\x76\xfa\xce\x2d\x64\xcb\xb1\xd3\x2b\x12\xe5\xbe\x66\x21\x8e\x6e\xbb\xf5\xff\x75\x58\xe8\x37\x4e\x5f\x0b\x2b\x5a\x69\x65\xff\xd8\xad\x57\x37\x08\xa8\xa0\xab\xff\x84\x2b\x6d\xd6\xf7\x1f\x3f\x71\xaa\xd5\x01\xe5\xdf\x75\x65\xcb\x98\xb6\x6a\xe1\xcc\xbc\x7e\xc5\x09\xa9\x72\x0a\x38\xf4\xaa\xd5\x8d\x00\x2a\xec\x3c\x02\x1a\xc0\xd3\xa7\xf4\x9d\x88\xc7\x54\x63\xc2\xb1\x1a\xe0\x77\x7a\xdf\xb5\x4d\x4a\x05\x66\x0d\x1a\x4f\xbe\x04\xe6\x06\x97\xc2\x40\x7f\x29\x63\xd7\x6f\x72\xc4\x1a\xe6\x97\x48\x36\xb0\xcc\xac\xbf\xcc\x40\x55\x2a\x35\xc5\x2b\x94\x9f\xa7\xa5\x66\xae\xca\x0e\xb3\x34\xa7\xf1\x81\x9d\x80\xe0\x25\x4d\x45\xf2\xc2\x23\xc8\x0c\x34\x9f\xc5\xc5\x1c\xcc\x43\x37\x07\x73\xc2\x94\x91\x7e\x2b\x25\x11\x64\x58\xb5\x3a\x5e\xfc\xac\x2c\x43\x9f\x0e\xce\xa7\xc6\x72\xfe\x9c\xa4\xe3\x88\x5d\xfc\x8f\x36\x19\x45\x7b\x7b\xe8\x27\xba\x40\xaf\x7e\x1c\x0e\x11\xcd\xb2\x39\xe9\x8a\x98\xea\x60\xec\x8a\x73\x94\xb1\x19\x41\x60\x77\xaa\x44\xe7\xa5\xf6\xd0\x9e\x4d\xbe\xa7\x09\x36\x8b\xf6\x3b\x0d\xf3\xe9\xff\xcd\x6c\xe3\xe6\xc5\xef\x76\x82\xe8\x51\x4a\xf0\x19\xf4\x97\xf5\x81\xa5\xc9\xfa\x8b\xac\x1c\xcc\xc9\x6c\x25\x30\xd9\xac\x1c\xcc\xeb\x70\x25\x30\x33\x27\xaf\xf0\x78\x1e\x45\xb2\x45\x69\x6e\x61\xbf\xee\x49\x90\x12\xdb\xae\x5a\xe1\xc8\xc0\x77\xcd\x70\x32\x13\x9b\x61\xb9\xe5\x26\x6d\xb0\x57\xfb\xe7\xd2\x0f\xae\xcb\xc8\xc0\xc8\x56\x37\x63\xb4\x2b\xdf\x1a\x26\x9b\xdc\x3c\x9b\xe3\x28\xba\x04\x3b\x1c\x1a\x07\xd1\x3c\x24\x21\xca\xe6\xa3\x5e\xa9\x19\xeb\x5d\xc8\x4f\x76\xfb\x6d\x7a\xad\x4c\xb2\x56\x86\x00\x8e\xba\xbd\x0c\x70\x57\xc3\xb7\xd1\x79\x9d\x44\xb5\xa0\xbc\x56\xe9\x58\xf9\xe5\x15\xa6\x2c\x11\x3d\xc6\x2c\x07\x43\x4d\x61\xc1\xa5\x15\x47\xc7\x11\xcb\xc8\xa9\x4e\x32\x6b\x96\x4b\xcc\xfc\x07\x09\xa3\xde\xd0\xb4\x76\x4c\x53\x9a\xe7\x7c\x48\x24\x0b\x70\x42\xae\x32\x98\x1f\x01\xc2\xff\x21\x97\xbf\x25\x2b\x0c\xe5\xdd\x94\xe8\x2c\x32\x3a\xf5\x86\x61\x19\xbb\x88\xc6\x68\x46\xa3\x88\x8a\x1c\xf0\x12\x63\xd0\xff\xb0\x39\x9a\xe1\x4b\x94\x25\x24\xa0\xe3\x4b\x84\x51\x46\xe3\x09\xe4\xf0\x98\x11\x36\xcf\x01\x14\x8e\x22\x0b\x54\xd6\x45\x2c\x45\x34\x86\x1c\xe1\xe2\x98\x72\x0e\x1c\x61\x60\xfb\x48\x60\x99\x66\xe7\x85\x4b\x7b\xd5\x33\x5a\xc6\x4a\xac\x79\x62\x4b\x40\x6d\xe6\xfc\x16\x01\x7b\xa7\xf9\xa5\x8c\xea\x21\x10\x61\x86\x17\x82\x56\xeb\x7c\xc3\x40\xfd\xfa\xd6\x3e\x0a\x72\x28\x2a\x4d\x52\x76\x21\x92\x91\x08\x22\x40\xff\x24\xaa\xa1\x38\x56\x5d\xa1\xcd\xd6\x79\x95\x69\x86\xe6\x40\x3e\x04\x40\xa6\xcc\x95\xb3\xb3\x9c\x9f\x92\x29\x49\x09\xe4\x18\x99\x81\xdf\x5f\x4c\x38\x65\xe5\x57\x75\xc0\xf8\xa7\x38\x47\x21\x1d\x8f\xc5\x5f\x62\x04\xd0\x25\x0e\x52\x96\x41\xe6\x94\x54\xc0\x05\x3a\x14\x88\xcc\x44\x7a\xc3\xcd\x75\xb3\x24\x3d\xe1\x02\x6c\x69\xb2\x19\xff\xef\x2c\x2c\x4b\x7c\x2d\x30\x92\x92\xb0\x8b\xb2\x3c\x25\x79\x30\x25\x99\x5a\x99\x9c\x99\x55\xec\x3b\x64\xa5\xbe\xf7\xe2\xb1\x31\x66\xde\xae\x75\xb7\xa6\x2a\xbe\x69\xb7\x30\xd7\x6e\x46\x30\xea\xac\xca\xa1\xbb\x11\x19\x33\x49\x1e\xe4\xcc\x80\x63\xcc\xec\xae\x7e\xe4\x25\xeb\x1f\x1b\xf3\x66\xb8\xf2\xb1\xd1\xa0\x36\x7d\x6c\x14\xe0\x4e\xb3\xbd\x91\x4b\x45\x33\xb1\x5a\x9c\x35\xf6\xd7\x0b\x5c\x2a\x77\x4b\xe6\x2f\xd9\x14\xcb\x35\x73\xb1\xf9\x47\x51\xb4\x5b\xb1\xcc\xac\x98\xbc\xc7\xcf\x08\x10\xd4\x94\x44\x04\x67\x24\x84\x34\x48\x40\xc4\x41\x6e\x44\xc1\xb3\x01\xde\x34\xce\x7a\x36\xb8\xc1\xd7\xa1\x0d\x0b\x9a\xbb\xfd\x2c\x68\xbe\xdb\xb4\x72\xca\xb0\xa0\xb9\x4f\x18\x44\xd1\x6e\xc1\x2a\xe8\xc2\x82\xe6\x1e\x59\x80\x92\xdd\x7a\x59\xeb\xa5\x5f\x5c\x28\x15\xbc\x7c\x06\x09\xd3\x08\x0a\x38\x4f\x2f\x57\x4f\x3e\xaa\x20\xa6\x2e\xfa\x4b\xf0\xc4\x9f\xa5\xb3\xc9\x3b\xed\x76\x92\xb1\x79\x1a\x68\x56\x4e\x3d\x06\xee\x15\x5c\xc2\xe0\xb5\xb0\x02\x19\xb1\xde\x24\x1c\xf0\x4b\x7d\x24\x58\x42\x6c\x97\xb3\x64\xa5\xd7\x97\x59\x31\xc7\x5a\xa5\xc0\xe7\xaf\x8a\x2d\x9e\xd4\x74\x4d\x44\x71\xa1\x6c\x06\x47\x1c\x98\xc2\xdb\x4d\x99\xf0\x88\x35\xcd\x10\x4e\x09\x08\xc6\x22\x4c\x43\x79\x23\x80\x70\x08\x8d\xe0\xae\x30\xcf\x73\xf9\x40\xd2\x5c\xa5\xb0\xf3\xd1\x12\x48\x01\xcf\xcf\x7d\xf7\x51\x3f\xc3\x85\x6f\xc1\xf9\xf5\xe4\xc3\x33\x8f\x73\x5d\xc7\x14\xa9\x4a\x25\xcf\x66\x5d\xbb\xe4\x9b\xdb\xcc\xba\x1e\xbd\x46\xd6\x97\x62\x50\x11\x4b\x96\x2c\x6d\xfd\x0b\x9f\x7c\xa9\x97\xae\xaa\x0a\xec\x49\xba\x35\x74\x89\x96\x78\x26\xd6\x0a\xf0\x1f\xfa\x43\x5c\x3e\x6f\xaf\xdc\x54\x2f\x9b\xaf\x53\x6a\x55\xe5\x9c\x98\x5d\x89\xff\xf6\x3e\xd3\x78\xe2\xd7\x00\x59\x8c\x53\x89\x84\x7e\x1d\x91\x26\x4e\x56\x59\xd0\xdc\xfe\xbe\xa0\xb9\xfb\xd1\xeb\x43\x94\xb8\x55\xdc\x1e\xa0\xc0\x54\xb0\x69\x97\x55\xcd\x2e\x56\x95\x0d\x65\x91\x9e\x1c\xfe\xe6\x5e\x47\x8a\x45\x83\xe1\x90\x30\xbf\x88\xc1\xa6\xd8\xda\x37\xf0\xdf\x28\x20\x21\x3c\x69\x25\xbe\x29\xd8\xfa\x07\x47\x24\xe1\x17\x52\x00\xef\xa0\x84\x2c\x10\xba\x05\xfd\x27\x8d\x27\xd6\x2f\x48\xbf\xdf\x12\x8b\x6f\xfe\x32\x75\x60\x4f\x1c\x27\x14\x58\x78\x77\xd4\x6b\xa4\x91\x94\xca\x50\xd7\xbc\xee\x3a\x12\x4a\xaa\x25\x2b\x0a\x5c\x8e\x4a\xe8\x44\x0d\xad\x3a\x2a\x2b\xac\x24\x52\x47\xc5\xa2\x0a\x5a\x70\xe4\x17\x94\x12\x81\x23\x54\x71\xfa\xdd\x1b\xbf\xfc\xb8\x64\x53\x76\x71\x04\xc4\x49\x2a\x08\x9c\xfc\x97\x8d\x6c\xb0\xdd\x13\xa7\x00\x1b\x8d\x0c\x4e\x12\x02\xa1\x32\xa4\x69\x8e\xf8\x5f\x8b\xc6\x2d\xd1\xb1\x29\x93\x42\xc2\xba\xd5\xb7\x44\x18\x1e\x39\x73\x1f\xeb\x45\x4a\xe6\xbc\x4c\x0b\x44\xcc\xbc\x7f\x5c\xfa\xe5\x70\xfa\x05\xd2\x65\xb3\xb5\xea\x2f\xa5\x71\x52\x75\x1a\xda\xb1\x4b\xdd\xb9\x7b\x0a\xdc\x85\x44\x88\x44\xe4\x5c\x22\xa8\x49\x29\xbe\xf2\x79\x00\xa6\x42\x3b\x5f\xbd\x6f\x19\x0d\x54\x0b\x3d\x10\xed\xa5\xc1\x43\x3f\xc0\x09\xcd\x71\x44\xff\x24\x3f\xd1\x34\xcb\x7f\x21\x79\x4e\xd2\x4e\x5b\xd1\xa3\xce\x87\x2e\x6a\x5b\x8c\x05\x7a\x8e\xfe\x5a\x9e\xf6\xd2\xd4\x37\x1e\x60\x16\x4f\x60\xb1\x0c\xcb\xf3\x49\x56\xc1\x12\x77\xaf\xb9\x98\x3b\x5d\x9b\x01\xea\x58\x2e\x27\x66\x19\xad\x0c\xac\xfc\x7f\xa2\x4e\x47\xe7\x63\x15\x6c\xd5\x97\x49\xc7\x7a\xa3\x38\xe2\xb5\x52\xb4\x56\x42\x68\x9c\xab\x75\xfb\x5c\xf9\x4d\xc9\x81\xbb\x49\x45\xe0\x9d\x49\x43\xeb\xf0\x54\x35\x0f\xcd\xa6\xf0\xca\xb9\xb2\x8d\x01\x76\x99\xaf\x0d\x80\x2d\xe5\x0c\xbf\x0a\xed\x57\xd3\x15\xb2\xb8\xe4\x55\xd5\x45\xab\x20\xe1\x92\x3e\x56\xd9\xd3\x22\xdb\x5e\x23\x97\x69\x0e\x54\xf1\xf9\x5f\x85\xa4\x6d\xc5\x65\x11\xef\x99\xdd\xca\x14\x57\x06\x1e\x77\xbb\x85\x71\x17\xa6\x09\x15\x5f\xf1\x70\x8a\xe7\xf5\x6e\xa1\x0b\xab\xb2\x3b\x9a\x15\x0b\xb3\x3b\x99\xc5\x75\xf1\x44\x50\x9b\x38\x9a\xc9\xa6\x58\x4b\x4b\x1c\xb6\xea\xbe\xdd\x16\x05\x46\x07\x82\x23\x8d\x3b\xe8\x08\xfd\xf5\xf9\x99\x7a\x1b\xcb\x85\xb0\x8d\x32\x6d\xe3\x3c\x91\xf3\xb7\xca\x4c\xce\xfb\xea\x48\xb8\xf4\xb7\x32\x13\x30\x21\x21\x21\x42\x2a\x64\xfb\x35\xf4\x95\x05\x5b\x5f\x59\x76\xd8\x6a\x07\x02\xe2\x9e\xf2\xfa\x11\xc1\xe7\xba\xfa\x3d\x29\x25\xb0\x8c\x5f\x39\xeb\xe8\x9a\x08\xe9\x11\x0a\x4d\x58\xc9\x80\x8f\xa4\x83\x86\x5a\xa5\x8a\xa4\x97\xab\x85\x06\x90\x8e\x70\xe8\x73\xa7\x2d\xfd\xd5\xb6\x92\xf2\xf4\xf1\x17\xcd\x43\x7f\x0d\x2e\x68\xd7\xef\x25\xb6\x55\xa7\xb7\x9b\xe7\x82\xb6\xf3\x32\xab\xf3\x32\x2b\x0f\x68\xf1\xf8\xeb\xf5\x94\xda\xdb\x43\x27\x0c\x5d\x10\x14\xb2\xb8\x95\xa3\x29\x3e\x27\x08\xc7\x97\x3a\x53\x03\x4a\x52\xca\x52\x0a\xf6\xa9\xd9\x9c\xf4\xb7\xe3\x9e\x53\xe1\x4f\x53\xf0\xda\xe1\x5f\x7b\x24\x0e\x1b\x05\x96\xaf\xf1\xc6\x79\x80\x5a\xc9\x02\xb5\xd0\x83\xb2\x8f\x7b\x68\x5f\x54\x28\xba\xe4\x0c\x84\x4b\x8e\xed\xe3\x81\x03\xfb\x72\x74\x62\xb1\x2f\x85\x6f\xc3\x11\xc1\x89\x2c\x38\x34\x96\x37\xde\xa3\x83\x4d\xfb\x6d\x94\x04\xa7\x2e\xb1\x0e\xb9\x13\x62\xd9\xdb\xe8\x9f\x21\x8c\x56\x3c\x33\x13\x19\x7d\xc2\xb7\x36\xb9\x06\xcb\x92\xad\x29\xf0\x57\x57\x61\x5b\xa1\xbf\xaa\x14\xd7\x57\x53\x59\x2f\x53\xcc\xaa\x70\x6b\xfd\x19\x4e\xda\xc6\xef\xc9\x44\xec\x15\xc7\xb8\x90\xd1\x7f\x49\xf8\x3b\xd5\xaa\x24\x50\x5e\xb3\x20\x68\xa5\x91\xb8\x04\x69\xb2\x35\x6f\xb5\x91\xef\xc4\x20\xae\x10\xf5\x4e\x01\x10\xff\xd6\xc5\x3e\x54\x9a\x3f\x19\xed\xcb\xd7\xfd\x49\x5c\xff\x32\x2a\xc0\x3b\x41\xf6\x6e\x83\x36\xca\x7e\xd7\x6e\xe6\x79\xa6\x42\x00\x99\x57\x9a\x8a\xd9\xb3\x9d\xc7\xda\xe3\xdd\x63\x6d\xf7\x58\xdb\x3d\xd6\xb6\x1a\x12\xe4\x9d\xce\x60\x55\x85\x13\x83\x92\xba\x75\x9d\x98\x5a\x5f\xef\xb3\x6f\x1b\x8f\xb8\x82\x67\xbb\x4e\x92\x57\x1a\x0f\xe1\x61\xfd\x2b\xcc\x54\x10\xff\xdb\x1f\x34\xa8\xbb\xe4\xc5\xb6\x7b\x41\x7d\x25\x2f\xa8\x5a\xd7\x0a\xfd\x64\xba\x00\x91\xc7\x88\xa0\x8b\x14\x27\x89\xc8\x0e\x89\x91\x49\x99\xe7\x6f\x29\xfa\x09\x1c\xa8\xb3\x1c\xc7\x01\xe1\xb0\x70\x8e\x02\x1c\x73\x08\x73\xbd\x2c\xbc\x40\x64\x1d\x40\x38\x46\xd3\x03\x68\x40\x70\xc8\xd1\x04\xeb\x89\x84\x34\xc3\xa3\x88\x18\x52\x54\xeb\xd3\x51\xfa\x20\x84\x00\x7e\x5f\xe0\x39\x58\x18\xba\xae\x5a\xf8\x72\x1d\x26\xe0\x85\x4e\x6f\xc3\xb3\xb2\xb8\x86\xdf\x9b\xad\x3b\x6a\xf6\x06\xb4\x6f\x3b\xdf\x9a\xf5\x2f\x20\x38\x47\xa8\x95\x43\x10\x49\xf3\x04\x74\x4c\x2f\xfd\x67\x17\x60\xd4\xee\xd1\x75\xa7\x1f\x5d\x8d\x00\x16\xcf\xd4\x32\x75\x6d\x51\x47\x29\x90\xa9\x44\x51\x59\x42\xfa\x40\x89\xb7\x41\x35\xdd\x3b\x89\xf5\xea\x15\x28\x62\x9d\x6e\xe7\x0d\xf8\x64\xf7\x06\xdc\xbd\x01\x77\x6f\xc0\x6d\xbd\x01\x77\xcf\xb3\x95\x9e\x67\xd0\x50\x3c\x8d\x20\x8b\x55\xd9\x53\xe9\xd9\x92\x8c\xfc\xe2\xe9\x34\xf4\xe3\xcf\x15\x43\xc9\xf9\xcf\x3c\xa9\xf2\x52\xfd\x9b\xe7\xdd\x92\x12\x3b\x53\xf1\x98\xa6\x59\xde\x03\x76\xc0\x09\x37\x27\x3b\x79\xc7\x92\x23\xd5\x58\x39\x00\xed\xde\x76\x5f\xd5\xdb\xae\xf4\x31\x24\x55\xc4\x85\xe7\xd0\x92\xd7\x4e\xa3\xd7\xd2\x96\xb4\x63\xd6\x7b\xc6\x7f\xe6\xdc\x16\xed\x98\xf5\x9a\xb0\xdf\x11\x72\x33\x76\x2f\x89\x3b\xfd\x92\xd8\xbc\xfa\x46\xe5\x08\x30\x8c\xbb\x0a\xea\xbf\x1d\xd6\xfd\xe9\x8e\x75\xbf\xcb\x11\xd9\xb7\xfa\x8e\xd8\xb1\xee\x3b\xd6\x7d\xeb\x9a\x95\xaa\x5b\xfc\x73\x57\xb2\xf6\x46\x56\xdd\xcf\xe6\xa3\x29\xc1\x9c\x47\x36\x16\x1c\x01\x8b\x58\xaa\xd4\x2f\x09\x8e\x48\x9e\x93\x7e\x4e\x16\x79\x5f\x44\x13\xc5\xe9\xa5\x6f\x2c\x37\x30\x16\x19\x3b\x76\xfa\x6b\x67\xa7\xdf\x91\x45\x91\xa5\xfe\xba\x0c\xce\x92\x1b\xc4\x50\xf3\xed\xd8\x31\xd5\x3b\xa6\x7a\x1d\xa6\x1a\x52\x54\x15\x18\x6b\xc8\x29\xb5\x15\xe6\xfa\xc9\xe0\x56\x33\xd7\xd7\xc2\x41\x6e\x81\x6d\xbc\x48\x71\xf2\x52\x18\xd3\x4b\x1a\x5b\xca\xf2\x1f\x54\x35\xa8\xe5\xee\xdc\xaa\x0e\x6f\xa8\x82\xb2\x95\x4e\xe6\xc9\x41\xb1\xee\x32\x36\x52\x04\x93\xb9\x61\x5c\xe4\xcf\x74\x32\x25\xe9\x9b\x34\x24\xa9\x49\xee\x54\x95\x84\xe8\x51\x63\xbe\xb2\x14\xec\x06\xf3\xba\xfc\xa0\x73\x5a\x54\x21\xf2\x7e\xe3\xb1\x5a\xb0\x36\x38\xc2\x57\x31\x3f\xaf\x24\x2c\x65\x20\x5f\x8d\x11\xcd\x00\x1f\x5e\xb2\x8b\xb8\xcd\x12\x61\x1c\x6c\x32\x75\x74\xba\x6a\xfb\xf9\xf9\x75\x03\x8b\x37\xc8\x57\x60\xdd\x75\x25\xe1\x22\x45\x4a\x80\x94\x64\x09\x8b\x33\x7a\x4e\xa2\x4b\x95\x1e\x41\xc6\x71\x47\xdf\xe1\x1c\xb1\x14\x8d\x48\xc4\x2e\xbe\x03\x26\x6f\x42\xcf\x49\x8c\xcc\x00\x39\xb4\xb6\x44\x3d\x88\x3c\xda\xca\x66\x2d\x08\xd1\x3f\x83\x0c\x78\x28\x24\xe7\x34\x20\x59\xa7\xcf\x6b\xfe\x8b\xe5\x34\x20\xc2\xbc\x04\x42\xc4\x0b\xfc\xe8\x41\x2e\x0f\x64\x30\x04\xa2\x18\x73\xf6\x11\xe7\x74\x14\x11\x11\xac\x32\x23\xe9\x39\x49\x51\x46\x43\x22\xcd\x50\x44\x38\x5d\x99\x9f\xb6\x24\x4f\xa0\x3e\x60\xfe\xb7\xb6\x61\xfa\xe4\x9a\xa3\xe7\x08\xa7\x93\xf9\x0c\xb8\xd5\x88\xc4\x93\x7c\x8a\xfe\x81\x06\xfc\xc4\xe9\xf2\xf7\x83\x0f\xc0\x82\x68\x69\x04\xfa\xde\xfd\xc8\x8f\xa1\x59\x1a\xe1\xe3\xc9\xdf\x1a\x9a\x2d\x33\xc6\xf4\x26\xb9\xb3\x7c\xd2\x00\x4a\xd9\xd8\x5c\x44\x06\xc1\xe1\x21\x03\xe5\x77\x7f\x5a\x16\x43\x8b\x9a\x26\x1f\xd7\x23\xe9\x56\x73\x82\x36\xba\xe9\x9b\x1a\xf0\xb6\x6f\xe1\x6f\xa7\x6d\xc6\xda\x95\x1c\x30\x04\xc4\x07\x66\x50\x8c\x4d\x67\xc1\x86\x7f\xfc\x09\xac\xc5\x02\x7a\xb9\x6a\x6a\xf9\x10\xfb\x40\xc0\x38\x24\x43\x82\x64\x0a\xf8\xca\x3e\x5b\xa6\xcf\x96\x59\xe0\xc2\xf8\x43\xe7\x82\x12\x4b\xe5\x5d\x43\x56\x2a\x5f\xb3\xf2\xc5\xbc\x94\xee\x42\xc9\x9d\x74\xd7\xde\x02\xd5\x69\xfb\x43\x81\xf6\xf2\x9d\x5b\x64\xb7\xfc\xee\xb6\xc3\x28\x0d\x6f\x66\x6e\xe1\x73\x1a\x56\x67\xa2\x7b\xb2\xff\xc5\x93\x0b\xc3\xf8\x6e\x40\xd2\xd0\x27\xfb\xb7\x9a\xd1\xdd\x25\x0d\xdd\x19\x80\xec\xa4\xc8\x9b\x36\x85\x57\x69\xda\x86\x05\xf1\x2a\xe4\xdf\x7b\x4b\x32\x92\xa3\x51\xca\x2e\x32\x92\xaa\x31\x89\x1e\x54\xce\x3d\x91\xb9\x4d\x65\xd7\xb3\xcd\xda\x4f\xa6\x29\x8d\xcf\xb4\xa4\x56\x1a\x94\xaa\x79\xa9\x11\x8c\x70\x70\x36\x49\xd9\x3c\x0e\x8f\x2b\x85\xc0\xa1\x20\xa2\x36\x1c\x1a\x67\xa4\x60\xd2\xff\x0b\x19\xe7\x47\xe8\xf1\xbe\x5d\x31\x12\x13\x5c\xa5\x3b\x68\xf2\xb2\xd8\x27\x1e\x65\x2c\x9a\xe7\xc4\x40\xb3\x52\x1d\xaa\x8f\x56\x4a\xbb\x3c\x67\x33\xcb\xcb\x20\x82\xd1\x95\xa7\xd3\xdb\x90\x69\x88\x19\x61\xe3\xc0\xfb\xb7\x43\xf8\x5b\x6b\x27\x2f\xd1\x43\xa7\x84\xa3\x71\x48\x62\x27\xd7\x84\xc4\x96\xc6\x8b\x52\xd7\x81\x88\x3c\x20\xf0\x8a\xa4\x42\x75\x61\x7a\x92\xe8\xb6\x8a\x8d\x3c\xc0\x6e\x12\x9c\x5f\xed\xae\x16\x48\xab\x82\x55\x25\xda\xbf\xda\x81\xd0\x0b\x52\x6d\x58\x2c\x13\x38\x9f\xff\xd2\x28\x0c\x29\xbd\xd4\x27\xf8\x75\x55\x59\xb8\x39\x37\xd5\xa6\xf3\x30\x06\xfe\x07\xf4\xa8\xa5\xe3\xda\x70\xc6\x66\xd0\x1b\x88\xb5\x37\x13\xa0\x58\x2f\xbe\xde\x97\xf5\x82\x13\x8b\x05\x16\xab\xbe\x1a\x04\xb1\x1b\xdf\x6b\x48\xe2\xb7\x71\xab\x56\xb6\xf6\xc0\x44\x79\xf1\x8e\xbb\x2e\x36\x74\x9e\x35\x56\x37\xb4\xa6\x69\xab\xe6\x71\xe9\xbb\x77\xc3\xde\x68\xed\x81\x52\x16\x00\xce\x7f\x19\x15\x41\x23\x1a\x79\x1b\x44\xf0\xcd\x62\xcf\xca\xa3\xb3\x81\x20\x66\xe2\xf0\xad\x66\x60\x2f\xf6\xb9\xc4\xb8\xde\xec\x82\x89\xf2\x25\x88\xb4\xfe\x2d\x49\xe9\x26\x6d\xee\x61\x38\x52\xbb\x20\xde\x65\xdb\x79\x2a\x3f\xdc\x3d\xb5\x76\x4f\xad\x1b\xfa\xd4\xb2\x89\x6e\xf9\x51\x2e\xd4\xac\x03\xae\x2b\xed\xde\x72\x77\xc1\x22\xa8\x21\x3c\xc9\x0c\x88\x98\x94\x57\x1c\x9b\x0d\x6b\xab\xfe\x06\x90\x47\x11\x9e\x7d\xda\xe5\x40\xbd\xfb\x92\x94\xce\x70\x7a\xf9\xde\x7b\x0d\xea\x90\x9b\xe2\xee\x43\xdf\xa3\xd6\x8b\xc7\x83\x41\x0b\x1d\xa1\xd6\x8b\xfd\xc1\xa0\xf5\x61\x99\x8f\x02\x8b\xf3\x9f\xf0\x8c\x46\x97\x47\x45\x4b\x28\xf3\xb1\x5b\x67\x07\x45\xe3\x64\x9e\xf7\x23\xbe\x98\xef\xc8\x42\x33\xdc\xbc\xf5\x09\xfd\x93\x94\x00\x4e\x16\xef\xd8\x5b\x32\x6b\x0f\x1f\x75\x0c\xe7\x1e\x93\x9f\xfd\xc7\xbe\x76\x88\x70\x9e\xe8\xb0\x4c\xc4\x4a\x3d\x2f\x47\x65\x96\xcf\xae\x4d\xd2\x94\x7f\xac\xb5\xe4\x82\x3a\xfd\x17\x07\x03\x57\x14\x20\xfc\xeb\x8a\x1d\x95\x4d\x5f\x55\xde\xf9\x50\x7c\x55\x46\x5f\xc5\x1c\xe4\x26\x43\x22\x47\x52\x9d\x89\x9c\x1f\x3b\x14\xb3\x50\x6a\x55\xd1\x8f\x14\xde\xa3\x18\x09\x38\x7c\x2e\x9c\xab\xc2\xe8\xe5\x9b\xd7\x88\x08\x8a\x83\x18\xaf\x50\xb6\xdd\xaa\x68\xd5\xfd\x76\xc8\xe2\x9a\xdb\x6e\xc3\xd8\xcc\xee\x5b\x10\x8b\x69\xb0\x6d\x39\x07\xd0\x18\x94\x4d\xd9\x3c\x0a\xd1\x88\xa8\x68\x87\x24\x44\x34\x46\x58\x1f\x58\x94\xe5\x38\xb7\xd4\xd7\xe6\x20\xaf\x2b\x60\xa9\xef\x38\x16\x44\xc6\xef\x56\x52\x9e\x75\xfb\x04\xba\x22\xce\x3c\xcd\xe4\x08\x68\xa6\xa8\x1f\x6a\xc3\x7f\x47\x97\xe8\xf4\x27\x96\xce\xfe\x99\xb2\x79\x72\x6a\x1d\x87\x8e\xa5\xbd\x57\xf4\xf2\x6a\xb3\x07\xe1\x12\x8d\x43\x1a\xe0\x5c\x2b\xd5\xd5\x30\x21\x45\xb0\x78\xc3\x9a\x8e\x55\xc9\x2a\xe2\x26\x3e\x99\x5f\x78\x7f\x4a\x02\x03\xc4\x6f\x91\x5f\x53\x5a\xc8\x7a\xc9\x93\x6d\xab\x22\xab\x68\xa5\xaa\xac\xa2\x70\xcd\x01\xa4\x0a\x55\x25\xc0\x0c\xa7\x06\x94\x98\x9b\x13\x36\xcc\xa9\x20\xcb\xba\x5a\xd7\x2e\x96\xd6\xa9\x93\x5a\x52\x84\xab\x88\xbc\x9a\x44\x8b\xd0\x13\xb7\x42\x47\x40\xae\x3d\x98\x09\xa4\xfd\x13\x23\xe6\x7f\xaa\x81\x81\x64\x4c\xec\xd8\x6c\x4e\xf9\x56\x1f\xb3\x38\x4f\x59\x84\x9e\xab\x7d\xee\xbb\x1f\x8c\x20\x4d\xc1\x40\xcf\x9d\xc9\x3f\xb3\x79\x27\xf8\x6a\xad\x9e\xfa\xa8\x09\xc3\x73\x67\x7f\xd4\x67\x71\x7a\x9f\x9b\x6d\x01\xbc\xa2\x63\xd4\x76\x07\xa3\x54\xaa\xfc\x8b\xa4\xbb\x66\x54\x9c\x9a\xea\x77\x68\xcb\xb6\x8a\xd0\xe3\x76\xa1\xe9\xed\x7a\xa6\x79\x06\x07\xb4\x9e\x51\x15\x64\x33\x65\x0f\xb0\xfc\x50\x01\xd7\x2c\x46\x15\x60\x6b\xb9\x3c\xc8\xea\x4b\x05\x68\xb9\x90\x55\x70\xd5\x3a\x7b\x40\xa1\xd8\x40\xfc\xfc\xe5\x45\xa7\xea\xb0\xa9\x25\x5e\x4f\x70\xaa\x4f\xbd\x5e\xd0\xf5\xe0\x08\xda\x20\x56\xaf\x89\x94\x14\x44\xf1\x59\x4e\x52\x9a\x9d\x1d\x37\x5a\xc3\xfa\x41\xf1\x45\x2c\x1d\xcb\x0a\x42\xd9\x7b\x0e\xf9\x6c\x6e\x09\x5e\x22\xa2\x75\x0d\xbc\xbb\xf7\x9c\x43\xd6\x34\xee\x67\x2b\x4b\x70\xdc\x32\x51\x5e\xac\x2e\x8b\x4b\xa7\x83\xbe\xb4\xfe\xdf\x7c\x7f\x30\x78\xfa\x9d\x50\x87\x99\xa8\x2f\xfa\xd2\xfa\x42\x46\xe5\x37\x84\x1d\x5c\x2b\xcd\x5e\x45\xfb\xc6\x49\xf6\xb6\xcb\x8e\xee\xcc\xf7\x6f\xb0\xee\xc0\xe6\x41\xee\xda\x3b\x68\xc5\x08\x43\xe1\x66\x54\x28\x8a\x79\xdb\x00\x28\xc3\xfe\x6d\x00\x98\x66\x20\x57\xd1\xee\x18\xaa\x5c\xa2\xdf\xb1\x68\x66\x0b\xde\x37\x2d\x78\x88\x98\x36\x92\x1f\x55\xc4\x9c\xb7\x71\xf9\x96\x23\x5b\x00\xad\x6f\x1b\x71\x24\x36\xa2\x0e\xd2\x63\x01\x85\x90\xfe\xb5\x25\x95\xd0\xc1\xcd\xb2\x9e\xfc\xc2\x3a\x9e\x1b\xa5\x71\x99\x10\x5e\x9c\x33\x4e\x24\xde\x8c\x2b\x86\xf0\xa4\xa2\x7a\x9d\x52\xc1\xad\xe9\x6a\x3d\x8e\x71\x14\x1d\x4f\x49\x70\x56\x35\xe7\xa7\x15\xf5\xeb\xa6\xea\x41\x36\x10\x80\x47\x03\x8e\xab\xaa\xbb\xe1\xa0\xac\x76\x6d\x67\x16\x50\xa3\x33\x62\x59\x46\x47\x11\x39\x66\x71\x96\xa7\xf3\x20\x67\xe9\x5b\x60\x60\x2b\xfb\x1d\x2e\x6f\x5b\x37\x8a\xea\x0e\x35\x5c\x1a\x4f\x49\x4a\xf3\xea\xa9\x17\xab\xd6\xf5\xa8\xc1\x6d\xd7\x43\xea\x3a\xd4\x68\x21\x19\xb1\x79\x1c\x54\xe9\x70\x0e\xf7\x0b\x35\xeb\x3a\x50\x75\xdc\x19\xff\x78\x4e\xe2\xfc\x17\x9a\xe5\x24\xae\xb4\xd3\x3e\x78\x58\xd3\x66\xe9\x92\x39\xb5\xef\x94\x8a\x30\x65\x17\x99\xd0\xda\xa0\xe7\x68\xff\x60\xa9\x02\x0c\xac\x3d\x2d\x05\x94\x65\x9f\x98\x92\x08\xe7\xf4\x9c\x33\x87\x7b\x7b\x68\x44\x02\xcc\xaf\x14\x10\xfa\x4f\x71\xc8\x2e\xd0\x14\x67\x35\xf6\x8c\xbe\xb5\x22\xbc\xd9\xf8\x05\x8e\x53\x82\x55\x77\x4e\x25\xd1\x4e\x19\x98\xda\x65\x29\xc9\x40\x6f\x65\x9b\x8c\x8e\x19\xb0\x0a\xf2\x6c\xc9\x42\xa3\x9f\x92\x8f\xd2\x79\x9a\xb1\xb4\x50\x6d\xc4\x16\x27\xf4\x4f\x11\xd9\x4b\x98\xa3\xf6\x46\x4c\x05\xeb\xb2\x15\x5f\x85\x76\x45\xd3\x55\x36\xcf\x79\x0b\xb7\xd0\x18\x8d\x1e\xc9\x5c\x7e\x09\x4e\x39\x5f\xac\x16\x42\x2c\xe1\x91\x76\x09\x28\xce\x6f\x6f\x0f\xbd\x91\x71\xc9\x10\x8e\x32\x86\x62\x42\x42\xa1\x63\x99\x92\x94\xf0\x7f\x53\x32\x63\xe7\x62\x4b\xc8\x22\x4f\x31\xdf\x7d\xd5\x16\x87\xb2\xb2\x5a\xf2\x0c\xd1\x18\xfd\x44\x53\x32\x66\x0b\x61\x8a\xab\xc2\x9e\x1d\xa1\xd6\x94\x86\x21\x89\x4d\xcf\xff\xa6\x19\x1d\xd1\x88\xe6\x97\x76\xb7\x34\xb4\x3b\xe3\x80\x11\x87\x8c\x58\x8c\x68\x82\xc3\x4c\x38\x32\xe9\xa6\x3e\xdc\x6a\x5c\xd1\x7b\x6e\x45\x5f\xbb\x98\xd2\x9c\x9c\x24\x38\xe0\xeb\x92\xa4\xa4\x77\x91\xe2\xa4\x25\x9c\x21\x36\xa0\xc6\xbb\x8d\xda\x2c\x1f\x8a\xa4\x01\xff\x16\x9c\x5a\xd5\x70\x62\xf2\x66\xcc\x57\xa4\xfd\xbe\xbe\xab\x2a\x00\xf1\x7c\x36\x22\xe9\x87\xce\x92\xb1\xac\xae\xd2\xf1\x41\xb0\xf8\x78\x8a\xe3\x49\xf5\x54\x38\x05\x75\x41\xfc\x0b\xc6\x86\xd8\x18\x08\x1f\xdf\x31\xa9\x08\x42\x17\x53\x12\xa3\xd9\x3c\xca\x29\x3f\x9d\xd2\x9b\x0e\xd1\x0c\x65\x24\x87\x63\xe1\xf8\x53\xf2\xd6\xd7\xbd\x82\xaf\xf1\x82\xce\xe6\x33\x14\x6f\x70\x0e\xaf\xf1\xe2\xba\xa7\xf1\x5b\x26\x75\x4f\x89\x7c\x54\xf0\x91\x25\x38\xcb\x10\x46\x29\x19\xa3\x40\x65\x7c\xe5\x03\x9e\x12\x14\xc3\xa5\xa2\xc9\x92\x52\xad\x9a\x79\xa8\x2f\x6f\xc9\x78\x05\x4c\xf0\x91\xe9\xfc\x7a\x0e\x05\xd0\x22\xe9\x55\x2b\x87\x80\x7a\x08\x2e\xf8\x18\x47\x8e\xaa\x58\xfa\xa9\xbe\x53\x13\xb7\xac\x4f\xda\x1f\x81\x76\x7d\xeb\x79\x85\xc2\xeb\x54\x33\x98\xe6\x6d\xaa\x40\x74\x51\xa1\x1d\x08\x80\x35\x5c\x55\xb1\x6d\x7b\x99\x4a\x7b\x31\xfd\x33\x27\xb3\xa4\x8b\x3e\xe6\x53\x9a\xc1\x73\x3d\x97\x1f\x8d\x74\xda\xbc\x24\xcc\x18\x44\x75\xd5\x41\x47\xb6\x19\xb3\x14\xb5\x01\x6a\x04\xba\x3f\xdf\xa7\xb6\xcb\x4b\x38\x2d\x7e\x91\xa6\xf8\xb2\xcd\x6b\x75\xba\xe8\xe3\x19\xb9\x44\xcf\xd1\xe0\x99\xf8\xeb\xef\xd0\x5a\xfc\x78\xf0\xc0\x68\x2b\x78\xd3\xf7\xbc\xf0\x83\x0d\x59\x94\x94\x79\x4b\xf2\xb9\xf0\x37\x3e\xcc\x50\xfc\x31\xa5\x99\x7a\xf5\x57\xbf\x1d\xfc\x49\x2a\x71\xb0\x9a\x6c\xff\x23\xbf\x5b\x72\xf6\xf1\x23\xfa\xf4\x49\x00\xf3\x5e\x78\xc5\xad\xea\x74\x40\x0c\xd0\xe7\x77\xcb\xa5\x14\xa2\xbc\xe7\xe0\x3f\xf4\x03\x16\x07\x38\x6f\xf3\xd9\x75\x20\x29\x2e\x2f\x56\xff\xf6\x41\x85\x2d\x2f\x2f\xfb\xaa\x8c\xe7\x51\x24\x6d\x63\x64\xcd\x29\x8e\xc3\x88\xbc\x05\x56\x42\x4d\x52\x33\xe1\x66\x44\x06\xe9\xc8\xb9\xe5\x7f\x8c\x54\x7f\x97\x71\x20\xb8\x1f\xfe\xfe\x3d\x01\x36\x45\xd6\x7c\xa6\xfa\x1b\x3e\x7a\xd4\xf1\x7b\x1d\xbf\x02\xb5\xb3\x8d\xd4\x31\x0b\x89\x0f\x9e\xca\x5a\xfc\xdb\x33\xe5\x3e\x30\x96\x5b\x23\xf3\x6a\x59\x04\xa0\x63\xc5\x49\xad\xa8\x22\xba\x51\xb0\x3e\x97\xaf\xc9\xf8\x84\xc6\x93\x88\x70\x32\x2a\xa6\xb4\x74\xa0\x59\xb1\x81\x19\x73\x09\xfc\x86\x50\x97\xc2\x12\x57\xa0\x03\xa8\x74\x9f\x80\xbe\x71\x8e\x9e\x7f\xec\xe7\x38\x9d\x90\x5c\x14\xca\xa3\xe8\xe8\x01\xed\xb5\x93\x2d\x5d\x9d\x20\xe8\x69\xac\x21\xda\x0b\xbf\xb7\xe7\xd9\xd1\xd0\x0c\xc5\x2c\x07\x05\x71\xca\x22\x50\xa8\x5d\x10\x60\x14\xc1\x6a\x26\x09\x85\x3d\x02\x3c\x14\x22\xce\xbf\x42\x97\x7d\x6f\x27\x45\x47\x7a\x22\xd6\xb4\x9e\xf9\x35\x97\xe1\xa4\x3e\xf9\x45\x64\x52\x4c\x45\x15\x26\xa9\xef\x05\x78\x7a\x6f\xc8\x2c\x51\x52\xd1\x26\x34\xc3\x22\xa4\xc2\x07\xfb\x9e\xa2\xe4\xb6\x94\xa4\x8c\x98\xbf\x17\x23\x3c\x23\x9c\x73\xd6\xab\xfd\x3b\x8d\xa2\xd7\x6c\x1e\xab\x37\x88\xbc\xd8\x34\x7a\x14\x2b\xb6\xcd\x5c\xf7\xf6\xd0\xdf\xe1\x60\xfe\x83\x3f\xfd\x48\x90\x67\xae\xc1\x5a\x86\x68\x2e\x83\x29\x64\xe2\x45\x91\x25\x2c\x86\x6d\x6c\x41\x47\x2d\x03\x28\x63\xe2\x9e\xa7\x22\x35\x48\xc0\x2f\x04\xce\xa2\x80\x4d\x43\x3e\x25\x97\xfc\x31\x80\x42\x9a\xe6\x97\xb2\x91\x83\xa8\x05\x0c\xfc\xf4\xc9\x2e\xb3\x79\x59\xfe\xa9\xd5\x7a\x66\x43\xc9\x48\x7e\xc2\x29\x61\xdb\xec\xa2\xa2\x84\x82\x07\x6c\x5b\xb0\x38\x27\xd4\x41\xdf\x59\x8f\x61\xb5\xab\x1d\x4b\xab\xad\x82\xc9\x79\xeb\xfd\x92\x86\x8d\x96\x5b\xd5\xb3\x56\xbb\x1a\x59\x39\xb5\x6e\xd0\x37\xdf\xc2\xb7\x24\x20\xf4\x1c\x44\xb4\x59\x93\x2d\xb7\xeb\xb7\x63\xb2\x10\x42\x75\x33\x28\x7e\x20\x74\xb1\x5c\xfa\x6f\x9e\x97\xef\x87\x5c\x4a\x53\x5d\xf2\x94\x1d\x68\x51\xbe\xd0\xfc\xb3\x7d\xb8\xea\x17\xa1\x8b\xcc\x10\xbd\xb3\xb6\x64\x5d\x7e\x8b\x67\x4d\x4f\x81\xac\xea\xef\x8c\x7d\x41\xf6\x03\x1c\x07\x24\x6a\x57\x6f\x4a\xd9\x14\x2a\x3a\xaf\xa1\x4f\x7a\x04\x9c\x29\x4a\xe4\x43\xb4\x24\xd2\xc8\xd0\x8d\x34\x32\xac\x8b\x34\x32\xfc\x80\x8e\xac\xed\x73\xe9\xbd\x75\xcb\xdc\xbf\x8f\x4a\xaf\xb2\x65\xb4\x7d\x6d\xba\x6e\x5d\x38\x05\xec\xfa\xa6\xca\x06\xc5\xe0\x8c\x7b\x1f\xb8\x97\x15\xf0\x3b\xe8\x7b\xd4\x6a\xa1\x23\x74\x02\xbc\x79\xdb\xaa\xd1\x31\x57\x86\xbe\x09\xc4\x9a\x1b\x69\x8e\xa2\x41\xfe\x72\xf4\xb3\x80\xcf\x56\x54\x7a\xe6\x34\x8e\xc9\x85\xd7\xb6\xac\x85\xbd\x98\xff\x9c\xe3\x34\xa4\xf1\x04\x38\xe1\x3f\xb2\x90\xcd\xba\x9c\x46\xa6\x04\xd9\x6d\x10\xcd\xe2\x16\x7f\x31\x91\x4c\x3d\x7d\x14\x80\x13\x42\xd0\x34\xcf\x93\xec\x68\x6f\x6f\x42\xf3\xe9\x7c\xd4\x0f\xd8\x6c\x2f\x9f\x25\xe7\x38\xdd\x03\x88\x7b\x90\xaf\x3a\xdb\x1b\x0e\x86\x0f\x9d\xb5\xb7\x86\x6b\x23\x8f\xbb\xd6\x82\x39\x2e\x5d\x2f\x0e\x43\x1e\x72\xf7\x7c\xa3\x7f\xe8\xd3\x6f\x51\x58\x17\xae\xbd\x56\xaf\x71\x3e\xed\xcf\x68\x5c\x01\xed\x3b\x6b\x57\xba\xa6\x61\xf9\x26\x16\xe1\xe2\x85\x99\x69\xd7\x02\xd5\x79\xe6\x4e\xc5\xf0\xcf\x7d\x71\x57\x00\x12\x9a\xee\x4a\x50\xb0\x78\xcb\x20\x9b\xe7\x56\x4d\xad\xaf\x9f\x9d\x51\xdb\xff\x96\xd0\x14\x71\xd3\x56\x50\x11\xf1\xb1\xed\x92\x8c\x8f\x8a\x66\x98\x03\xd5\xb5\x7a\x37\x56\x94\x1f\x4b\xcd\x28\x91\x17\x96\xf2\x63\x85\x1d\x25\x42\xae\x34\xc9\x54\xb5\x4b\xed\xda\x8a\x6f\x32\x35\x55\x89\x5d\x0b\x24\x1a\xba\x06\xff\xe5\x7f\x7d\x8d\x17\x6e\x85\xd7\x78\x61\xd7\xb1\x38\x7d\x53\xcf\x2a\xb4\xeb\x9e\xbb\x43\x3f\x2f\x8c\x79\x35\xf3\xcb\x8f\xa5\x11\xed\x9d\x0c\x5d\xd6\xe2\xf0\xdf\x6a\x09\xc0\xc4\x92\x5d\x64\xea\xdf\xd7\x78\xc1\xff\xb4\x86\xcd\x7f\x0a\x06\x4b\xf9\x26\xa3\xa6\x01\x9b\xf4\x84\x9a\x24\x4a\x16\x46\x78\x20\xd7\x3c\x42\x7f\x69\x4c\x2e\x1e\x8d\xcf\xb5\xc9\x94\x9d\x01\x94\x69\x5c\x8c\xeb\xf0\x5f\x48\x3c\x46\x8e\x50\xeb\x82\xc6\x70\x69\x22\x16\xbf\x95\x12\xee\xe2\x4b\xf5\x73\xa7\x69\xbf\x7a\xfd\x5a\x5d\x8f\xa2\x8d\x3d\xc0\x85\xe7\x5e\xe9\x79\x68\x12\xd6\x54\x10\x7c\x63\x6e\xa7\x86\xd0\x71\x70\x14\x8f\x5e\xc5\x21\x59\x1c\xa1\xde\xd0\xc7\xef\x23\xd4\x1a\xb6\x9c\x42\x82\xc3\x37\x31\xb8\xf7\xa4\x2e\x7a\xb6\x70\x4a\x71\x4f\x8a\xcc\x41\x6f\x30\x27\xad\x02\x7e\x1f\xa1\x56\xcb\x50\x9c\xad\x2c\xde\x17\x5f\x32\x9f\x50\x2c\x5d\x99\xea\x45\x75\x65\xe4\x55\xd4\x4c\xae\x2c\xfc\x73\xc5\xc5\xad\x32\xa2\x5c\x3a\xc9\x95\x16\x39\xd7\xaf\x46\x13\x72\xf7\x6a\xd3\x2e\x23\xee\x0e\x66\x88\x22\xb3\x3a\xd2\xfc\x73\x29\x3a\xc1\xfb\xd3\x5a\x54\x3f\x45\x3a\xbf\x26\x85\x19\xba\x24\x7f\xea\x45\xfc\xec\xde\xe7\x76\x21\x4b\xbd\x2d\xe9\xd4\x02\xb9\x12\x73\x22\xb1\xc6\xc3\x7b\x1b\x88\x36\xab\xba\x01\xab\x1f\x5b\xe2\xe9\x19\xec\x1c\xee\x7c\xb8\x77\x3e\xdc\x57\xf1\xe1\xde\xfb\x0e\x91\x2c\xa2\x71\xde\x93\xda\x34\xf4\x47\xb6\xe8\xe1\xe1\xf0\x72\x0f\x2c\xe2\x7a\x53\x9c\xf5\xf8\xc3\xe2\xbb\xbd\x9d\xbf\xf7\x2e\x81\xf7\xb5\x3a\x95\xcb\xab\x6e\x53\xbe\xdb\x9b\x74\x2d\xbf\x9d\x19\x30\x2c\xdf\x9e\x24\xc2\x97\x60\x6b\xc2\x19\xd6\xde\x38\x22\x26\x6f\x1c\x8e\xe8\x24\x7e\x95\x93\x19\x67\x24\x03\xc2\xd1\x40\x7f\xd3\xc6\x2d\x10\x71\xd5\xfa\x00\x71\xd8\xc0\x34\x64\x92\x92\x4b\x34\xa5\x93\x69\x64\x3d\x5b\x7f\x27\xa3\x33\x9a\xbf\xc3\xc9\xcf\xea\x43\x69\x64\xb3\x80\xcd\x66\x2c\xee\x5b\xd6\x2b\x6e\xc8\x37\x11\x3b\xad\x37\x3c\x70\x8b\xdf\xaa\x17\x46\x49\x82\xbe\x7d\x3e\x34\xed\x85\x9b\xb2\x0b\x25\x02\xc1\xb0\x6e\x6c\x8c\x52\x1c\x52\xb6\x07\xb2\xe5\x11\x5b\x48\x21\xfc\x3d\xd4\xdc\xf9\x5b\x86\x7f\x73\xdd\xfb\xf4\x4a\xa9\xb8\x9d\x36\x60\x20\xad\x06\xea\x3c\x23\xe9\x09\x89\x48\x90\x2b\x7b\x1c\xc3\xa6\x6c\xc6\x83\xdc\x4f\xda\xad\x65\x6f\x38\x49\x08\x4e\x33\x94\x41\xf7\xb6\xe3\x26\x2c\x48\x8d\x71\xc5\x72\x7d\x36\x98\x5f\xd4\x1b\x9b\x94\x68\xf6\x6f\x9d\x89\xcc\x0b\x25\xbd\xd4\x76\x05\x5e\x6a\x73\xaa\x13\x9b\x8f\x08\xc2\xe8\xf4\x2d\x47\xb8\xd3\x2e\xff\xf3\xe4\x82\xe6\xc1\xf4\x54\x38\x79\x9f\x1e\x4b\x1c\x3c\xb5\xbd\xbc\xa5\x9d\xf9\x5a\xbe\x0d\x57\xf5\x6b\xb8\x8a\x33\xcf\x55\x1c\x79\x36\xeb\x4b\xe1\x3a\xf0\xd4\x1e\x0b\xb1\x8f\x2a\x46\x9f\x3a\xd3\x57\xf2\x22\x5f\xd3\x58\x45\x68\xad\x4b\xfc\xfe\xe1\xc3\x6a\x86\x2a\xef\xa6\xc2\xf8\x85\x77\x21\xd2\xeb\x6b\x9f\xf5\x38\x88\x58\x46\xe3\x89\xf4\xef\x2e\x58\xc6\x48\x4a\x75\xcd\x9e\x4e\x6b\xe1\x9d\xdf\xb0\x31\xd2\x6d\xda\xb7\xaa\x88\x6e\xe5\xe4\x26\x5e\x95\xd2\x1c\x2b\x54\x19\xc3\x04\xc1\x56\x4b\x10\x48\x9c\x13\x50\xa3\xc0\x7b\x59\xe2\xab\xec\x34\xc1\x29\x9e\xa1\xbf\x04\xfd\xfb\x2c\x94\xf7\x80\x11\xe2\xaf\x8c\xcd\xd3\x80\xe8\xb0\x22\xb2\x07\xb7\x2d\x47\x6a\x82\xe3\xcf\xea\x4e\x80\xe6\xa7\xf2\xc7\xa9\x94\x81\x4a\x08\x19\x50\xb4\x7b\x57\x30\xb0\xe3\xc0\x1d\x90\x25\x87\xa0\xde\xd4\xca\xce\xc5\xa4\xd2\x0f\xa4\x2c\xe1\x38\x9f\x92\x24\xc2\x81\x8c\xac\x21\xc0\x6b\x7a\xac\xa9\x31\x8e\x43\x8b\x18\xbb\x16\x55\xf2\x3c\x83\xce\x4a\x2b\xb0\xc6\xe8\x92\xcd\xd1\x05\x8e\x73\xdb\x96\x8e\x9f\x2f\x30\x5b\x85\x43\x24\xcc\xb1\x9c\x18\x07\xd2\x89\xa8\x3e\xd4\x81\x5a\x73\x13\xd5\x00\x7e\x6f\x36\xa8\x41\xa0\x5d\xf0\x55\x48\x03\xf8\xbd\x52\x40\x03\x45\x98\xac\xa8\x9c\xa2\x40\x87\xf7\x01\x12\xa3\x03\x73\xf2\x5f\xea\x53\x6c\xa7\xb0\x8a\xed\xec\x55\x46\xe6\x5f\x2e\xf2\x2f\xd1\xdd\x5d\x3d\xf4\x01\xac\x70\x7d\xe4\x03\x58\x1f\x3f\xee\x81\x9a\x31\x84\x01\x05\xaf\xad\x2e\x6a\xc5\xb2\x8d\x2d\xa9\x37\x72\xf8\x55\x23\x21\x2c\x09\x66\x70\xcf\x51\x89\xca\x61\xf6\xdd\x0d\xab\x52\x8c\xae\x1b\x1f\xa0\xbc\x17\xcf\x99\xbf\x51\x24\x85\xcd\x86\x25\xb8\x5a\x10\x81\xc6\xee\xf0\xa5\x2e\xfe\xeb\x06\x2e\x85\xc1\x2b\xdc\x81\x1f\x57\xf2\x90\x2f\x74\x16\xb1\x58\xf7\xa5\x0e\x79\x61\x71\x8f\x50\xe1\x35\xa3\x1e\x03\xa5\x88\xa5\x49\x94\x67\xe0\xf5\xbd\x26\x5e\x47\xe5\x2d\xec\xe3\xef\x57\x01\x92\xf0\xe9\x13\x2a\xa3\x06\x7e\x5d\x4d\x25\x3e\x7d\x42\xa5\x04\xc2\x6f\xa0\xcd\x4f\x1c\x82\x61\x58\x2b\xb7\xb6\xa6\x6c\x9f\x3e\xe9\x3a\x02\xcb\xaa\x96\xb9\x4c\x7b\x66\xcb\x63\xb4\xee\x4a\x7e\x2b\x55\xa4\x09\x7a\xf9\xd9\x21\x9f\xf0\xb7\x1b\x74\xc0\xbe\x45\xbe\x54\x42\xbb\x6b\x79\x2a\xde\x21\x9f\x75\x75\x7b\xec\x5e\x75\x1b\x79\xd5\x7d\x19\x47\x79\xeb\xb6\xaf\x61\x6e\x1b\x47\x2e\x96\xfc\xc2\xee\xa9\xb5\xde\x53\xab\xe9\x3a\xc7\x1b\x3c\xc8\x16\x4b\xb7\x01\x0c\x38\x97\x36\x1d\xcb\x86\xe6\xc7\x37\x70\x2e\x80\x9b\x11\xb2\xc0\x1e\x92\x8e\x5c\x60\x17\x6e\x29\x80\xc1\xa3\x5b\xad\x0f\xbd\x91\x4a\xc2\x2d\x68\xfb\x7e\x06\xab\x8a\xff\xae\x54\xc5\x3d\x7d\x54\xa8\x5a\x07\x5c\xd5\xf1\x1a\x1d\x67\x55\x1d\x1c\x3e\x79\x5a\xac\xbb\xbc\x87\xe3\x6c\x17\x77\xf9\x6e\x64\xc8\xbc\x8d\x51\x76\xef\xcc\x45\xbd\x0d\x1d\xcc\xcf\xca\x4f\xdc\x4f\x16\xda\xb6\x83\xa0\x32\x30\xd7\x5a\xfe\x48\x59\x6d\x67\x6d\x74\x5f\x73\x7f\x2d\x10\x9b\x59\xf3\x1f\xec\x74\xae\x55\xa7\x26\x4d\xf1\xe5\x9b\x71\xfb\x4e\xcd\xb6\xe3\x6b\x14\x5f\x8d\x85\x7d\x9e\xcc\x2f\x9b\x09\xd9\x2d\x98\x81\xe2\x38\x44\xf3\x44\x6b\x7b\x84\xad\x9f\xc1\x96\x45\xf6\x5b\xb2\x5a\xbc\xdc\x35\x3b\xca\x66\xd7\xd4\xd1\x2c\xbc\xa6\x8e\xa2\xc9\x35\x75\xb4\x88\x36\xd9\x51\xc8\x2e\xe2\x1a\x74\x78\xc9\x2e\xea\x73\x1f\x6f\xae\xb3\x6c\x76\x8d\x9d\xcd\xc2\x6b\xec\x2c\x9a\x5c\x63\x67\x8b\x68\xc5\xce\x4e\x12\x12\xd0\xf1\x25\xba\x98\xd2\x60\x8a\xe8\x2c\x11\xb2\x06\x61\x2b\x22\xc2\xb3\xf7\x11\x6a\xfd\x91\xb5\x10\x15\x7e\x8d\xda\x08\xbd\x15\x64\x59\x0b\x5d\xb0\xf4\x2c\x43\x23\x92\xe7\x24\x05\x8b\x13\x91\x42\x5a\x40\x2f\xe4\x91\x56\x2a\x5d\xa7\x9f\xfa\x1b\xaa\xfd\x9e\xf7\x2e\xbb\xf3\x89\xdd\xff\xb0\x39\x98\x1a\xcc\x95\x8e\x4a\xeb\x9c\x41\x57\x18\x4c\x99\x50\xf6\x82\xda\xeb\x8f\xec\xd4\x9f\x61\x6d\xd2\x6b\xad\x52\x7c\x91\xa1\x53\x61\x67\xdf\xa7\x71\x4c\x52\xc8\x0c\x7c\xca\x17\x64\x1e\xe3\x73\x4c\x23\xb0\x23\x64\x52\x37\x09\xd0\xba\xa2\xe5\x85\x5e\x2f\xe1\xf9\x29\x81\x83\xa6\x6c\x96\xe4\x97\x9a\xe1\xe2\x3c\x58\x38\x4f\xd5\x58\xc7\x34\xcd\x72\x04\x1e\x76\x32\x74\xfe\xab\x18\x65\x6c\x46\x50\x46\xf3\xb9\x18\xfb\x25\x9b\xa3\x19\xf8\x15\x28\x3d\x1c\xc4\xd2\x8f\xd1\x94\xa4\x34\xcb\x69\xc0\x8b\x70\x92\xa4\x6c\x41\x67\x38\x17\x1c\x87\x18\xa2\xc8\x3c\x0e\x81\x81\x34\xe7\x17\x51\x3e\x06\x95\x55\xd2\xae\x62\x2f\x85\x6b\xe8\xc1\x87\x10\xa8\xf0\xf0\x73\xbd\xd2\xf3\x8c\xa4\x3d\x3c\x91\xc1\xfc\x0d\xf4\xde\x94\x6a\x13\x16\x70\xc0\x3a\xda\xdb\x0b\x70\x4c\x39\x92\x05\x6c\xb6\xf7\x1f\x19\xc1\x69\x30\x7d\x2e\x6a\xff\xe7\xfe\x60\x0a\xd9\xcf\xb5\x1d\x00\xcd\x29\x8e\x7e\xaf\x4d\x41\x2d\x62\x46\x38\x9a\xd0\xb7\x76\xf2\xf5\x29\x0d\x49\x66\x22\xa7\x8f\x70\x46\x42\xb3\x73\xc2\x24\xc8\x43\x12\x4f\x8f\x29\x9e\x46\x7e\x66\x40\x0f\xaf\xb4\x46\xd0\x29\xbe\xaa\x9e\xce\x85\xa6\xbd\x5a\xe8\x18\xb5\xfd\xfe\x39\xa7\xf2\x47\xd6\xf2\xf3\x21\xd7\xfb\x9c\xe8\xb7\xa7\xf1\x34\x11\xba\x15\xed\x63\xbd\x0a\x1c\xfe\xc4\x2c\x02\xfa\x7c\xef\x9e\xf8\xbc\x96\xe4\x7e\xa5\xe7\x8e\x10\x18\xc9\xde\x4a\xcc\xd7\x7d\x2a\x04\x74\x46\xf3\x41\x3a\xe3\x99\xe0\x56\xf4\x4f\xc1\x53\x98\x7c\x68\x13\xe7\xa7\xb8\x9f\xcd\x4f\x79\x87\x5a\xc0\xbc\x02\x75\x17\x59\x00\xbd\x02\x45\xd3\xeb\x52\xae\x89\x49\x6e\x47\xc4\xf4\xf8\x4a\x22\x26\x51\xb1\x2f\xeb\xf1\x95\x47\x7f\x93\xe3\xfe\x5b\xf9\x29\x3e\x7c\xf2\x04\x78\x78\x25\x3b\x10\xf2\x22\xf4\xb9\xe8\x0c\xf0\xe4\x4a\x23\x03\x45\x29\x4b\xab\xc4\x09\xfb\x0f\x3b\xcf\xa0\xce\xb7\xff\x7d\xf2\xe6\x5f\xa0\xf5\x4d\x49\x1f\xfe\xfe\xf4\x09\xb5\xcd\x2f\x3e\x25\xf1\x44\xa3\xe3\xcb\x23\xc4\xcb\xfa\xfa\x37\xf8\x2e\x16\xd6\xc0\xb2\x62\x95\xf5\xda\x34\xef\xa0\xbf\xd0\xde\x9e\x67\x9d\xde\x83\xa8\x44\x31\xeb\xcd\xe3\x79\x46\xc2\xde\x39\x4e\x33\x73\x0e\xbf\x75\x3b\x93\x91\x4f\xa0\xb4\x6b\x9c\x99\x3b\xcf\x34\x3d\xb4\x57\xef\xe9\x1d\x10\x1d\x9e\x91\xcb\x2a\x99\xd7\xc3\x87\x4e\xad\x3a\x69\x17\xff\x7e\x33\xa5\x91\xd7\xef\xb1\xb1\x55\x07\x94\xad\x08\x57\x2f\x70\x1a\x73\xce\xa3\x02\xec\x81\x5f\xb1\xd6\x01\x41\x54\xf1\x82\xae\x9a\xe7\x76\x15\xb2\x1d\x98\x39\x4e\x49\x94\x90\xb4\x52\xd4\x7b\x70\xa7\x42\x61\xde\x30\xa9\x2d\x2a\x7a\xf7\x8c\x23\x76\xc1\x9b\xef\xc9\xca\xbd\x73\x1c\xd1\xb0\x37\xa6\x11\xe9\xe1\x38\x66\x92\x61\x52\xde\x3e\x0d\xc7\x22\xee\x5b\xc5\x4c\x94\xce\xeb\xc9\xa3\xc6\x33\xb3\xa1\x6d\x41\xe8\x5b\x65\x50\xf3\xb9\xbb\xd6\x74\x9f\x57\x79\x2c\xf1\x11\xa2\xef\xd1\x5f\x9f\x9b\x4b\x5d\x2d\xc0\xdd\x9d\x70\xfa\xcb\x0b\xa7\xb7\xed\x8e\x60\x75\x2c\x6e\x71\x43\xa6\x26\x24\x26\x29\xce\xc9\x49\x69\x96\x48\x21\xe8\xd0\x31\xda\x8c\x43\x8f\xf2\x1e\xf9\xec\x98\x9c\x15\xe8\x76\x9f\xdf\xf1\xfd\x94\x84\xf3\x80\x58\xe1\xd9\x94\x3a\xf7\x8c\x5c\xaa\xa7\x92\x28\x7a\xdf\x62\x71\x74\xd9\x42\x0f\xc4\xe9\x91\x44\xbd\x1f\xe0\x84\xe6\x38\xa2\x7f\x92\x9f\xf8\x0b\xfd\x17\x10\x7b\x74\xda\xbc\xf9\x07\x13\x0f\xae\xc6\x86\x4e\x38\xd2\x8c\xac\x81\xf1\x7e\x00\x40\x57\x4e\x52\xfa\xec\xca\x71\x9c\x91\x4b\xf4\x00\xb5\x7e\x4b\x5a\xeb\x76\x30\x4f\x96\x83\xe7\x2f\x8c\xb5\x3b\x08\xd9\x45\xec\x77\x61\xbf\x3a\x45\x57\xcf\x64\xa8\x8e\xcf\xe2\x11\xe8\xb8\x79\x2d\xf7\xea\x2a\xc5\x8e\x67\xab\x45\x86\xf4\x9e\xf0\xc7\x59\xe6\xbf\xe2\xaf\x9a\x51\x8d\xef\xa5\x65\xb8\x6b\x52\x88\xf2\x27\xa5\xfe\xc0\x7f\xa8\x0f\xfc\x71\xa9\x3f\xf0\x1f\xda\xd1\x2b\xb4\x3e\xf0\x1f\xda\x2a\x6e\x62\x7d\xe0\x3f\x74\x1f\x91\xdd\x47\x64\x7d\x80\x47\xa8\xd5\x3d\xff\x69\x06\xe0\x7c\x14\x3f\xcd\x20\x9c\x8f\xe2\xa7\x19\x88\xf3\x51\xfc\x34\x83\x71\xfb\x8c\xec\x8f\x1b\x4e\xd1\x06\x27\xb5\x8b\x5a\x7c\x5d\xf9\xbf\x7c\x19\xf9\xbf\x7c\xd5\xc0\x30\x79\x22\xfe\xe5\x6b\x22\xea\x01\xba\x43\x4d\xf5\x97\x98\x9a\xa8\xad\xfe\x12\x83\xd6\x62\x96\xc6\xd6\x85\x60\x3c\x22\x79\x4d\x2f\xdd\x14\xbc\x44\x4c\x99\x10\x8a\xa8\x08\x55\xfc\x3e\x1a\xe8\x70\x97\x4b\xab\x42\x38\x2b\x28\xee\x4f\x71\xf6\xe6\x22\xd6\xcf\xa8\x56\x4a\xc6\xad\x4e\x17\xb5\x5e\xe3\x9c\xa4\x14\x47\xbd\xdf\x5e\x1d\xa1\x79\x9c\xcd\x13\xfe\xbe\x22\xa1\x12\x93\x52\x92\xa1\x54\xc4\x36\x0b\x91\x26\x76\xe5\x3d\xff\xc1\x68\xdc\xe6\xcb\xd2\xe1\x04\x03\x72\x30\xfe\x5d\x1c\x24\xb4\xf7\x8f\xd3\x7e\xab\x83\x8e\xd0\x39\xa3\x21\x1a\x3c\x2b\x33\x43\x7e\xff\x41\x84\x4d\x55\xc1\x4b\xa9\x08\x46\x4a\xd1\xdf\x2b\xa9\xb5\x98\x2b\xaf\xf3\xe0\x39\x1a\xda\xe1\x55\x47\x8e\xc2\xbd\xbc\xf9\x7b\x2a\x03\x96\xba\x0d\xcc\x19\x79\x6f\x41\x91\x14\xb6\xac\x81\x8d\xc7\x5e\x13\x81\x1e\x92\xd8\xd1\x31\x6a\xdb\xdd\x18\x13\x6e\xbd\x0c\xfd\x64\x9e\x4d\x95\xd9\x75\x49\xf7\x1d\x3f\xc3\x9c\x3b\x8a\x15\x21\x6a\xe4\x2d\x98\xa5\xf3\x03\xa3\x80\x55\x80\x5a\xe9\xfa\x03\x78\x1f\x56\x94\x12\x0a\xc3\x6f\x2b\x23\x59\xa5\x81\xb7\x18\xa7\x3c\xfb\xda\x12\x58\x13\xf1\xeb\x12\x24\x5e\xd5\x4c\x4c\x0f\x18\xec\xc3\x6c\x0b\x9b\x2d\x48\xed\x9e\x0e\x6e\xb5\x74\x67\x17\x28\xe3\x8b\x07\xca\xb8\xe5\x49\x54\xb6\x1d\x37\xe2\x6b\x13\xe1\x38\xc9\xe3\x36\x13\x9f\x02\x60\xed\x62\x54\xc8\x3b\x5d\xd8\xc3\xa3\x07\x28\xa4\xe7\xe8\x1f\xe8\x7e\xeb\xc8\x0a\xfa\x24\xc2\x3e\xbc\x63\xc9\x11\xea\x95\x47\x7d\x90\x55\x55\x4c\x65\xf8\x47\x25\x03\x39\xc9\x71\x6a\xf5\xb4\x24\x86\x44\x19\x84\x1f\xe3\xd0\x6f\x2f\x42\x53\x54\x35\xdf\x5c\x24\x87\x3a\x41\x50\x17\xc5\x2c\x9d\xe1\x28\x02\xdf\xd3\xd3\x57\x01\x8b\x7f\x98\xe7\x39\x8b\x21\xc0\x80\xd0\x8b\xdc\x00\x61\xd1\x26\x45\x37\xb7\x3f\x7c\x84\x1b\x0b\x57\x47\x2a\xe1\x23\xe7\x27\x02\xc2\xb6\x4b\x1b\x81\x1f\x29\xbc\x14\xb1\xdc\x4a\x6d\xe3\x80\x5e\xbe\x79\xad\x5c\xf7\x45\x28\x89\x32\xd9\xe0\x0d\x49\x10\xbb\x85\x3c\x99\x05\x83\x21\x2d\xb8\xa0\x99\xb5\x5a\x53\x12\x2b\xc7\x46\x74\x91\xe2\x24\xe1\xa5\x34\x46\x18\x59\xb7\x63\xc9\xca\xc9\x36\xa6\xd2\x0a\x06\x45\x7c\x77\x15\xd5\x10\x26\x39\x38\x64\x69\x0c\x3b\x95\x4d\xc1\x56\x44\x84\x60\x41\x2a\xf7\x95\x8a\x03\x71\x0a\x41\xec\xac\x50\x20\x26\x97\xd1\x12\xfb\xa0\x8c\xd3\x37\x48\xc3\x1e\x87\xad\x0f\x1d\x47\xc8\xe8\xc8\x18\xa1\x87\x17\x6a\x3c\xbe\xf4\x67\xad\x1c\xfb\x0d\xb2\xe3\x37\xf5\x58\xaf\xf6\x56\x2f\x6c\x88\xef\x93\x6e\xbe\xa8\x26\x7a\x0f\x54\x4d\x55\xb0\x51\x21\x8c\x9d\x0f\xbf\x32\x80\xab\x3f\x44\x5e\xa8\x46\xa3\xa5\x2b\x1b\x4f\xa8\xed\xaf\x6e\x93\x88\x8f\x9b\x4c\xa7\xee\x5c\xbe\x5d\x6b\x3f\x38\x45\x11\x18\xbb\x5e\x66\x74\xeb\x4e\xf6\xc1\x72\xfc\xaf\x4e\x96\xde\x91\x37\xbb\xe3\x30\xad\xfc\x9b\x35\x9e\x8b\xe1\x71\x02\x02\x09\x2b\xbe\x29\xe2\xde\xf7\x1b\x71\xff\x15\x81\xa5\x5a\x19\x09\x58\x1c\xe2\xf4\xb2\x65\x1c\x7f\xad\xb7\x3e\x42\x1d\x74\x54\x7c\xfc\xbb\x07\x79\x97\x80\x7c\x5d\xef\xd6\xdb\x91\x80\x7c\xb5\xfb\x68\x97\xbd\xfc\x46\x7b\x82\xef\xb2\x97\x97\x5d\x88\x1b\xf0\xce\xd6\x57\x6a\xf5\xde\x2f\xe5\x97\x3c\x67\x5b\x8f\xcc\x2e\xc9\x28\xae\x42\xa5\x97\x1c\xd7\x3a\xdb\xc5\xd5\xa4\xa8\xee\x90\x40\x94\xea\x16\x6d\x49\x9e\x3a\xdc\xc9\x53\x77\xf2\xd4\x1b\x2a\x4f\x4d\x76\xc1\x84\x9b\x05\x13\xfe\x89\xa5\xb3\x4a\x1f\xec\xe1\x4d\x13\xb9\xde\x6e\x79\x26\xc4\xb4\x1d\xb3\x74\xf6\x26\xa5\x13\x1a\x1f\xa1\x56\xce\x12\x14\x91\xb1\x1b\x19\x76\x6c\x07\x6a\xf8\xcb\x7b\xbc\x16\xb3\x18\x23\x80\xa0\x73\x4f\x23\x94\xb3\xc4\xfa\xb5\xb7\x87\x32\x88\xb6\x8b\x70\x94\x93\x54\xbb\x31\x65\x09\x09\x90\x94\x52\xf2\xdf\x33\x9c\x07\x53\x74\x4e\xb3\x39\x8e\xc4\xc7\x94\x64\xf3\x28\xf7\xc7\xae\x32\x4b\x47\x38\x27\xfc\x9e\x02\x8d\x68\xa9\x00\xf6\x21\xea\xa1\x21\xa8\xc6\x93\x45\x07\x65\x01\x8e\x48\x7b\xd8\x29\x06\xc1\x7d\x49\xe2\x8c\x1c\xd9\xc9\xe3\xf8\x7b\x96\xc4\x99\x18\xab\x92\x84\x09\x61\x88\x08\xc4\x04\x4d\x4e\xc5\xea\xf7\xd7\x1f\xe1\x7e\xff\x10\x3d\x58\x36\xc6\x6c\x9a\xd2\xf8\xac\x64\x17\xfd\x7e\x86\xfd\x43\x03\x64\xd0\x7f\x7c\xd8\xd1\x3b\xd4\x70\xe7\x71\x0c\x6e\x49\xa1\xd7\x99\xdc\x78\x31\x05\x53\x92\xc9\x47\x66\xbb\xa5\xc1\x3b\x59\x36\xc2\x79\x8a\xab\x5a\xaa\x6f\xfd\x6c\xca\xd2\x5c\x3a\x67\xc1\xff\x08\xce\x20\x43\x79\xb1\x8d\xf8\xc2\xff\x21\x6f\xe6\x26\xb7\x9d\x3d\x81\x86\xd1\x92\x61\x0f\x75\xd0\xb4\x2d\x8a\xc7\x33\x1d\xe0\x11\x90\x07\xc2\x8e\x9c\xee\xc4\xdf\x37\x4c\xfc\xed\x85\xe0\x35\x38\x27\x0f\x84\x4c\x3f\x5d\x19\x8a\xf7\x85\xaa\xb5\x9a\x4b\xa9\xea\x13\x5c\x44\x4c\x54\x41\x98\xc3\x95\xc2\xfd\x7a\xf3\x11\x5a\x2c\x2b\xa0\x70\x12\xe1\x4b\x13\x7e\x37\x4d\x41\x31\x83\x73\x2b\xa9\x36\x14\xae\xd0\xe3\xa9\xdc\xbc\x53\xe3\xed\x69\xed\x36\x1c\x00\x2b\xfa\xce\x69\x31\xc6\xaf\xf5\xf5\x78\x0d\x3c\xf0\x66\x2c\x02\x17\xcb\x7c\x7c\x72\xfe\x34\x43\x63\x16\xcc\x33\x7b\xff\x64\xc1\x8a\x4b\x1b\x02\xf1\xef\x8a\x15\xc5\xe1\x1f\xf3\x2c\x47\xe7\x9c\xc1\x0c\xe0\xe6\x12\x14\x1e\xbd\xe3\x5d\x43\xca\x58\xa9\x0e\x63\xa3\x1c\x43\x52\xc3\x73\x8a\x55\x6c\x4d\x34\x4e\xd9\x4c\xbb\x71\xea\x38\x92\x7a\x80\x42\xaf\xb7\x54\xda\x0e\x23\x2a\x78\xe2\xd2\x4a\x34\xa0\x71\x48\x03\x91\xd5\x10\xe7\xd6\x8a\xd1\x0c\x49\xf8\xd6\x22\xa9\x92\xab\x22\x20\xcd\xf8\x55\x36\x8f\xcf\x2c\x17\x73\x79\xb5\xd5\x00\x2e\x53\x17\xd4\x07\xab\x2d\xd3\x19\x58\x21\x3b\xcb\x03\xc7\xfa\x27\xd9\xaf\xa8\x3f\xf8\x02\xd1\x75\xed\x52\x1b\x06\xc5\x2d\x9e\x0b\x5d\xb7\xf8\x49\x1b\x90\xc2\xb2\x3a\x80\x45\x91\x9b\xb2\xc0\xa9\x20\x8a\xae\xaa\x89\xb0\x03\xd1\xfa\x2b\x07\x5a\x88\x72\x73\x51\x47\x39\x51\x9c\x17\xd8\x85\xc2\x04\xc0\x2e\x14\x46\x7a\x85\xc0\xb5\x02\x14\x7a\x6e\xad\x93\x1f\xb4\x56\x55\x29\x66\x8b\x2e\x8f\x1f\xab\x41\x16\x02\xc2\x72\x52\xf8\xe9\x93\x5f\x2e\x09\x4f\xc9\x17\x50\xcd\x91\x10\x54\x14\xcf\xec\x00\xb2\x62\xda\xbc\x0b\xbd\x79\xcf\xdc\x41\xab\x1a\x4d\x07\x6d\x20\xba\x43\x10\xe5\xcf\xae\x1c\xbd\x76\x23\x3a\x1b\xeb\x31\xd2\xf5\xe7\xb1\x16\x40\xc5\xe3\x76\xb5\x1e\x45\x63\xe8\x7a\x00\xe5\xd1\x92\x38\xb0\x1e\x8c\xd2\xf8\xbd\x6b\xc0\x31\xef\x99\xae\x83\x0e\xe2\x82\xa8\xd6\x43\xfd\xba\x46\x84\x60\x78\xba\x03\x15\xfa\xc5\x84\xd1\xae\x8c\x14\xdc\x0a\x71\x8e\x7b\xf2\x14\x1f\x21\xb5\x68\x65\xf6\xa5\x5d\xc3\x0a\x96\x90\x3f\x4f\x59\x56\xae\x87\xfa\x82\x81\x68\x1b\xf1\x6b\xe5\x6d\x9a\xf1\x91\x3b\x65\xca\x0d\x56\xa6\x94\x5c\x7a\x1b\xd0\x23\x6c\x36\x66\x2c\x30\xf7\x9b\x01\x55\x7a\x57\x6f\x64\x67\xe4\x0d\xb9\x99\x61\x4a\x96\x61\xa9\x16\x46\xf1\xd1\x4d\xe1\x2a\xd6\x78\x33\xa3\xd4\x2c\x4e\x3d\xac\x82\x36\x48\x10\xbb\x12\x4d\x90\x21\x45\x3a\x72\x45\x91\xd2\x18\x3d\x90\x05\xec\xcb\x47\x70\x35\x83\x31\x0a\xa5\x2d\x46\x6d\x7d\xba\x7f\xc7\x95\x49\x37\x4a\xfb\x72\xc7\x34\x5b\x22\x8b\xe5\x1e\x7a\x81\x26\x29\x0d\x1d\x4b\x4a\x1d\x3d\x8a\x45\x11\xbb\x80\x24\x47\x74\x94\x21\x9c\x21\x1a\x67\x09\x95\x42\xd0\x7b\x7b\x7b\xbc\xfd\x4f\x52\xd2\xec\x45\xc1\xe1\x9f\x7a\x2a\x38\xd3\xf9\x41\x0f\x47\xc9\x14\xf7\x27\x24\x1f\x31\x96\x67\x79\x8a\x13\x08\xd5\x14\xe1\x4b\x36\xcf\xf7\xc6\x11\x59\x8c\xd8\xa2\xc7\x87\xb2\x67\x9a\x7a\x89\xf5\xcf\x52\x9a\xe5\x6c\x4c\xd2\x3f\x58\x46\x92\xa9\x6a\x05\x8d\x46\x11\x1b\xed\xcd\x70\x96\x93\x74\x2f\x4b\x83\xbd\x20\xcb\xec\xef\xfd\x20\xcb\x2a\xe1\xa6\xec\x32\x22\x64\xf0\x78\x70\xb0\x07\x1c\x64\xcf\x1e\x8e\xdb\x6a\x26\x3d\xe1\xfa\x38\x9e\xcc\x23\x9c\xfe\x91\xf5\x59\x3a\xd9\x8b\x70\x4e\xb2\x5c\xcd\x86\x72\x6a\x23\xd9\x33\xbd\x4a\x7c\x29\x85\x68\x47\x42\x47\xff\x9c\x43\xf0\x4d\xa6\xa2\x9e\x71\xf4\x4f\xb3\x1c\x4b\xf9\x23\xfc\x8c\x2e\xf9\xf2\xcf\x58\x48\xa2\x23\x77\x24\x41\x96\xf5\xf8\xd9\x3d\x03\x4b\xc1\xbd\x2c\xa6\x49\x42\xf2\x0c\x26\x8e\x7b\x13\x0e\xbb\x97\x33\x35\x95\xad\x26\x21\xbd\x2b\x6a\xbd\x35\xa2\x74\xc8\x42\x7e\xbc\x7e\xc2\x41\xce\xd2\x2a\x37\x91\xc3\xa7\x0f\x6b\x1a\xd5\xaf\xb5\x5f\xdb\x8b\xc1\x5c\xa9\x89\x3c\xf4\x2a\x2e\x8f\xd4\xfc\x75\xab\x2e\xef\x8e\x0b\xcb\x97\x8d\x2b\xf2\xcf\xdf\xde\xbd\xfb\xf1\xed\x09\x7a\x8e\xde\x0f\xba\xe8\x49\x17\x0d\x1f\x75\xd1\xfe\x41\x17\x1d\x0c\x3e\x88\x58\x58\xff\x7c\xfb\xea\xe5\xc7\x93\x57\xff\xdf\x8f\x50\x49\x84\xa9\x1c\x76\xd1\x7e\x17\x3d\xec\xa2\x83\x2e\x3a\xec\xa2\x47\x5d\xf4\x18\x1a\x3f\xed\xa2\xe1\xa0\x8b\x86\xc3\x2e\x1a\xee\x7f\x78\x56\x12\xea\xe1\x9f\x29\x0d\xdb\x93\x88\x8d\x70\x74\x22\xb9\x32\x50\x9d\x75\x2d\xf7\x5b\x21\x3f\xb2\xee\x2b\x3c\xcf\x19\x12\x04\x9b\xc6\x13\x25\x65\x53\x14\x66\x79\xfc\x82\x16\xbf\x1c\x7a\x2d\xf4\xc0\xea\x44\x29\x12\x39\xd1\xfd\x01\x67\x34\xd3\x2a\x65\x5e\xf2\xcf\x94\x5d\x1c\x21\x99\x42\x7f\x86\x17\x32\x02\x61\x6b\x38\x18\xfc\x27\x84\x9e\x10\xc2\x0c\xb3\x36\xfd\x31\x4b\x7f\xc4\xc1\xd4\x0e\x34\x41\xff\x24\x25\xf9\x9f\x20\xaa\x27\xbc\x8b\x65\xca\x39\x2b\xf3\xd3\xde\x1e\x3a\x39\xa3\x89\x15\x0f\x92\xc5\x84\x5f\xe6\x22\xeb\x3b\xc2\x23\x76\xae\xf5\xc1\xe2\x54\x2b\x5f\xdf\x7b\xb2\xfd\x9b\x38\xba\x44\x67\x84\x24\xe8\x11\xca\xe8\x24\xa6\x63\x1a\xe0\x38\x47\x22\x4a\xa2\xd0\xfb\xc0\xfa\x89\x50\x90\xcf\xd1\x6b\x9c\x4f\xfb\x29\x9b\xc7\x21\x8c\x18\xed\xa1\xe1\x3e\xfa\x4e\x14\x27\xec\xa2\xcd\x37\xf4\x51\xa7\x83\xf6\xdc\xa2\x03\x50\x2a\xff\x67\x4b\xba\x42\x17\xa3\xf0\xcc\xf0\xa2\x17\x91\x58\x08\xe2\x85\xd6\x3b\x62\x99\x36\xfd\xd7\xbc\x45\x81\x1b\x91\xb5\x4b\x2e\xff\xfc\x62\x94\xed\xe9\x86\x82\x8f\x18\x0d\x0e\x07\x4f\xf0\xd3\xc7\x87\xe1\xe3\xe1\x30\x7c\x34\xda\x3f\x08\x06\xc3\xf1\xe1\xe3\x30\x3c\x3c\x38\x38\x0c\xf6\xf7\x1f\x3d\x7d\x3a\xc6\xc1\xc1\x5e\xc6\x6f\xdb\x19\x5d\xd0\x38\xdb\xfb\x08\x7c\x06\x2f\xf9\x8f\x5f\x1e\x3d\xf5\x26\x40\xe2\xb2\xf1\xab\x18\x21\x25\xa8\xc4\x17\x02\x8a\xf8\xfa\x7d\xd0\x01\x4b\x1c\xdc\x82\xd5\x36\xe2\x71\x85\x50\x50\x2c\x76\xf0\x99\x41\xab\xbd\x3d\xf4\x2f\x86\x62\x22\xdd\x64\x30\x9a\x91\x90\x62\xf4\xbf\x73\x92\x5e\x6a\x73\x01\x81\x1f\xbc\xcb\xfe\x3d\xdf\x75\x5c\xe0\xd7\xc2\x04\x83\xac\x10\x9b\xb9\x07\x31\x53\x57\x2c\x42\x9f\x11\x89\x32\x22\x1b\xdb\xb5\xde\x97\x06\x1b\xb1\xce\x2e\x9f\xbf\x15\xfd\xe3\xde\xe7\x32\x22\x30\xe7\x4c\x54\xbb\xe2\xe0\x3b\x87\xfb\x2f\x11\xe4\x45\x92\xa9\xb2\x53\x26\xf4\x61\x5d\x44\xe3\x90\x2c\xec\xf3\x06\x05\x22\xc2\x42\xf9\x09\x53\x4f\x47\xc7\xca\xa2\xe4\x54\xa9\xad\x97\x5d\x55\xee\xbe\xf8\x6c\x23\x80\x52\xaf\xf5\x94\x1d\xca\x1e\xda\x57\x48\x70\x21\x49\x4a\x80\xa3\xa0\xcd\xe9\x0a\xc4\x58\xd0\x60\xa4\xc9\x86\xb6\xb0\x68\xdd\x47\xff\x40\xdf\x72\x1a\xf2\x2a\x27\x33\xc7\x53\x30\xc1\x61\x08\x26\x0d\x56\x2f\xae\x6f\xa0\x85\x5b\x5e\x80\x96\xcf\xf7\x38\xab\x2a\xf9\x05\x74\x7c\x72\x22\x9e\x7e\xc0\x80\x73\xf4\x3d\x42\xad\x01\x1a\x02\x05\x6e\x75\x55\xe1\x4b\x9a\x92\x40\x1a\xeb\xa4\xec\x42\x7c\x70\x52\x6a\xf3\x5a\x3d\x69\x73\xaa\x5a\xfd\x9e\xe2\x04\xa2\xf7\x5c\xa4\x38\x11\xc5\x7f\xcc\xb3\x9c\x8e\x2f\x8f\x85\x31\x83\xdf\xee\xaa\x26\x4a\xb5\x6e\x22\x7c\x25\x79\xbf\x98\xc6\x24\x35\xab\x39\x62\x8b\x13\xfa\x27\xac\x66\x6b\xc4\xd2\x90\xa4\xbd\x11\x33\x79\xc3\x4d\x10\x22\x27\x9d\xb8\x35\x3d\x39\x39\x77\x8f\xd5\xb5\xa1\xed\x48\xd4\x3e\x36\xee\x58\xef\xc5\x40\xed\x85\x8b\x61\xad\x41\x4b\xdd\x98\x76\x52\xe6\x56\x86\xe6\xc2\x60\x02\x82\x23\x83\x4e\x08\x02\x20\x63\x74\x3a\xa6\x93\x79\x4a\x5c\x5d\xb9\x1a\x5f\x2b\x54\x5b\xdc\x5b\x64\xbd\x80\x45\xf3\x59\x6c\xe1\x9c\x8f\x04\xb2\xc2\x32\x08\xbd\x94\x9c\x93\x34\x23\x4b\x21\xe9\x8a\xd5\x10\x53\x76\xd1\x00\x9c\x5d\xcb\x81\xc5\xb7\x89\x83\x91\xd8\xe8\x42\x70\x31\xb5\xb4\x1d\xfc\x5b\xde\xbf\x85\x08\xe5\x7d\xc3\x49\xe9\x51\x7e\x54\x60\x6d\x44\xfa\x79\x03\xa4\x2c\x39\x7d\x1d\x00\xeb\xd0\x54\x00\xb1\x6a\x2c\x05\x44\xe2\xb0\x16\x0c\xff\x5e\x07\x64\x84\x33\x12\xd1\x98\x54\x01\xd1\xdf\x4b\x80\x48\xab\xa6\xea\x55\x31\x94\xa2\x7a\x5d\x2c\x20\xd5\x2b\x53\x4a\x72\x1a\x00\x2b\x59\x1d\x0f\x54\xc5\xfa\x58\x80\x38\x99\x26\xbd\x11\xc9\x2f\x08\x89\xab\xa1\xb9\xd5\x9a\x80\xc4\xc0\xc6\x2d\x83\x28\x6b\x39\x00\x25\x21\x2e\x5d\xf8\x02\x91\x2e\x5b\x7a\x0b\x40\xc9\x3a\x95\xd3\xf9\xc2\x4a\x59\x40\xaa\xd6\xa8\x00\xa9\x66\x95\x0a\xe0\x0a\xeb\x53\x01\xcd\x59\x21\x11\xc3\xac\x9c\x75\x01\x16\xab\xdb\x3c\xf6\x1c\x0e\x82\xf9\x6c\x1e\xe1\x9c\xa5\x4e\x00\xba\xbd\x3d\x48\xb9\x0c\xe1\xe8\xc9\x78\x4c\x82\x1c\xb1\x73\x92\x22\x3a\x9b\xcd\x73\x3c\xa2\x11\xcd\x05\xe3\x27\xc5\x4f\x09\x49\xc7\x2c\x9d\x71\x2a\x2f\xc8\xb6\xf3\xbc\x72\x7a\x91\x23\xe5\x9d\x09\xa6\x46\x5e\x8e\x56\x25\x13\xa6\xad\xb3\xb2\x81\x22\xef\xf0\x84\xfe\x59\x63\x87\x7e\xd5\xcc\x98\x52\x77\x32\xfc\x50\x9d\xe5\x45\x56\xd9\x5f\x5e\xe5\xe1\xf2\x2a\x07\xcb\xab\x1c\x2e\xaf\xf2\x68\x79\x95\xc7\xcb\xab\x3c\x59\x5e\xe5\xe9\xf2\x2a\xc3\x41\x83\x3a\x0d\xd6\x77\xb8\xff\x01\x42\x3e\xdd\xf5\x2c\x54\x3b\xe3\xd5\x5d\xec\x86\xed\xc6\x6e\xb0\x8d\x17\xcd\xda\x82\xe9\xe4\x14\x9f\x8b\x2c\x5f\xfc\x8a\x44\xdf\x05\xea\x89\xf2\x1d\x1a\x91\x29\x3e\xa7\x2c\x95\x8b\xfd\x3f\x6c\xae\xa2\x2b\x8c\xac\x58\x0f\xdf\x01\x23\xf6\x9d\xe2\xf2\x2d\x00\xf6\x52\xeb\x77\xcf\xba\x26\x97\xf5\xa3\xe6\x63\xd8\xe4\x80\x29\x3c\x95\x1a\x8f\xf5\x25\x08\x03\x45\xee\x9a\x53\x87\x57\x92\x2e\x15\xda\x8a\x58\x65\x5a\xe1\x0f\x25\x75\x02\x41\xe4\x12\x45\x2a\x1f\x4a\xc6\x6f\x37\x33\x14\x97\xa5\x5a\xea\x75\x99\x92\x3c\x98\x82\x09\xa2\x60\x9a\xba\xee\x1b\xd7\xe2\x84\xba\x3e\x2f\xd3\xf5\xd8\x11\xdf\xfc\xb6\x64\x96\xb0\x94\x1b\x9a\xa3\xe4\xd7\x97\xcc\xd0\x9d\x8c\x37\x49\x35\x2d\xb3\x0a\x9a\xf9\xaf\x9d\x0c\x34\xd6\xaf\xbd\xca\xf9\x40\xe4\x93\x46\x13\x0a\xcd\x93\x70\xc9\x7c\x40\x9c\xe1\xbe\x1b\xbb\xfa\x7d\xdb\x2d\xbc\x4f\xeb\xa6\x01\x9b\x87\xe4\x6e\x0a\xc3\x7f\x4e\x5e\x4e\xf9\x26\x9d\xfa\x14\x90\x4f\x27\xc0\xb1\x08\x27\x0b\x99\x75\x44\x92\x1a\x2c\x1b\xe9\x53\x51\x68\x09\x76\xce\x42\xf0\xb3\x6c\x76\x05\x09\x7f\x91\x32\x25\x29\x3b\xa7\x21\x09\xa5\xf5\x39\x3f\xa5\xe2\x64\xbe\x17\x9a\x85\x0f\xed\x3d\x9c\xd0\x3d\x19\xf4\xd7\x22\x03\x38\x0e\x65\x62\x42\x13\x68\xd4\x0c\x50\xd4\x5f\x95\xb2\xfb\x31\xc8\xd7\xa1\xec\x36\x8c\xcd\x50\x76\x0b\x62\x1d\x12\xab\xd7\xc7\x32\xca\xd3\x1c\x8b\x25\xc4\xcd\x9c\xc9\xf5\x49\x0d\x80\xe1\x88\x71\x75\x42\x73\x01\xa2\x92\x25\xd3\x51\x02\x43\x25\x5b\xf3\x44\x2b\x75\x63\x15\x4a\x0f\xce\x63\x4e\x52\x1a\x66\xde\xcd\x45\x33\x34\x61\x86\x4f\xa9\x1b\xbe\x95\x42\x0b\xa6\x20\xce\x04\xf8\x1e\xb0\x0b\x92\xe5\x28\x49\x29\x4b\xa9\x5a\x03\x91\x4b\xaf\x49\x1a\xce\xdd\x8b\xe8\xf6\xbf\x88\xb6\x8c\x7f\x70\xe8\xb2\xd9\xa9\xad\x73\xe0\xd4\xf6\x82\x86\x3a\x6b\x5b\x86\xe8\x18\xc5\x4c\x88\x0d\xd2\x42\xa2\xc5\x1d\x26\xee\x30\x71\x53\x98\x38\x0b\xd7\xc7\xc4\x59\xb5\xd5\xfa\x0e\x13\x77\x98\xb8\x22\x26\x46\x93\xf5\x31\x31\x5a\xc2\x2c\xef\x30\x71\x87\x89\xcd\x31\x71\x11\xd5\x63\xa2\x9d\xad\x77\x87\x77\x5f\x07\xde\x79\x8e\xc5\xa0\x99\x69\x12\x7d\x74\x23\x6e\xbd\x3a\x60\xa6\x5b\xad\x10\xa6\x54\x49\x15\xac\x2a\xb2\x44\x55\xa1\x39\x99\x99\xdc\xb6\x39\x99\x75\x4b\x74\x8b\xba\x82\x5d\xd8\x2d\x68\x7f\xdd\x6a\x50\x64\x0c\x2b\xa4\x84\xc6\x72\x8c\x96\x25\xda\xeb\x58\x5a\xb7\x68\x97\x63\x69\xf9\x23\x3f\xeb\x74\x51\xe2\xab\xf8\xd9\x75\x15\x7d\xfa\xab\xfc\xad\xed\x34\x52\x6c\x56\x89\xff\x30\x79\x74\xac\x1c\x3a\x26\x7f\x8e\x95\x3b\xc7\xe4\xcd\xb1\x72\xe6\x98\x7c\x39\x56\xae\x1c\x93\x27\xc7\xca\x91\x73\xe5\xd0\xac\x15\x4e\xce\x6e\x98\x56\xb5\xa9\xfc\x07\xdf\x43\xfe\xaf\xbd\x55\xfa\x37\xec\x89\x70\xae\x96\xab\xaf\x64\x03\x34\x9e\xf0\x3f\xc5\xb2\xf2\xbf\xe4\x12\xda\xef\xf2\x85\xf0\xa4\x9e\x89\xec\x3a\x22\xb3\x8e\xc8\xaa\xa3\x63\xbe\x36\x77\xf6\xdd\x8c\x7b\xaf\x63\xe6\xd3\x35\x08\xbf\x9e\xfb\xab\x32\xdb\xe9\xc2\xb1\x58\x0b\x86\x31\x23\x5b\x64\x60\x36\x76\x02\xba\x12\x65\xc7\xd6\xf9\x60\x0d\x12\xdd\xbf\xaf\xb1\xfe\x1b\xb0\x63\x5b\xaf\x47\xc7\x70\xc6\xea\x53\x97\xf3\x5e\xcd\x09\xe4\x5d\x71\x72\xe5\xb8\x7c\x99\xf3\xb8\xe6\x20\x94\xe5\x8c\xd5\x3f\x2f\xe2\x5d\xc3\xf1\x2b\xef\x15\xaa\xac\xd7\xa1\x67\x97\x62\xf5\x6b\x50\x9d\xf7\x6e\xd1\xa7\xf2\x31\x58\xd5\xaf\x32\x12\xcb\x5c\xc3\x1f\x8b\x3c\x86\x7a\x34\x8a\xac\xd6\x8c\x47\x35\x59\x6f\x44\x96\x69\x84\x35\x16\x59\xca\x87\xa1\x08\x66\xf9\x08\x54\xc5\xf5\x3a\x07\x13\xda\x45\xd6\xfa\xd0\x05\xfa\xfa\xfc\x39\xf8\x99\x5d\x0d\x98\x3d\x8d\x05\x6c\xeb\x22\xe3\xc7\x67\x21\x36\xf5\xaa\x1d\x64\x33\x3e\x5a\x4e\xf8\x37\x02\xcc\x39\xf8\xb3\x8e\x00\xcd\x0f\xfb\x6c\x23\xa3\x9d\x85\x7c\xb4\xfc\x46\xda\x08\x30\x7b\xb4\xb3\xb0\x23\x40\xdf\xbf\xcf\xff\xbb\x89\xd1\x46\x13\x3e\x5a\x7e\x55\x6e\x04\x98\x3d\xda\x08\xe8\x69\x34\xe1\xa3\x8d\x26\x1b\x19\x2d\xbf\xcb\xba\x70\x87\x6f\x04\x98\x83\xb7\x51\x47\x80\xe6\x78\x1b\xd9\xa3\xad\x8f\xaa\x20\x6e\x55\x0e\xf0\xd7\x25\xe9\x5f\xab\xd2\x6d\xe9\x54\xfd\xd2\x92\x5c\xa9\x77\xfe\xb2\x2d\x86\x9a\x45\x00\x97\xee\x4b\x7e\xf4\x6f\x97\x1d\xab\x07\xe5\x30\xaf\x5d\x33\x31\x11\x89\x6d\xc5\x9c\x63\x95\xc0\xc0\xf6\x19\x48\xdb\x2e\x94\xb8\x18\xd6\x1d\x0d\x25\x7e\x27\xec\x88\xee\x4c\x00\x8b\x5d\x34\x70\xf7\x3d\xb6\x81\xb8\x0e\xf2\x45\xb7\x01\x48\xde\x9b\xf0\x7a\xad\x5b\x56\x1a\xa4\x7a\xa8\x6e\xcd\x3c\xa5\x79\xe8\x14\xf3\x50\xde\xb4\x6d\x49\xe3\xc0\x1e\xfa\x7d\xbe\xaa\xfd\x47\xd3\x1e\xf4\xb3\xff\xae\x19\x70\x34\x5d\x00\x23\xed\xb8\x06\xe3\x8b\xa6\x83\x92\x72\x97\xab\xda\x4f\x34\xed\x6e\xb1\xec\xc0\xed\x84\xd7\x77\x45\x78\xdd\x98\xf2\xd4\x5c\x3c\x3b\x94\xf8\x2a\x51\x62\x56\x13\xad\x6a\x87\x12\x5f\x25\x4a\x44\xcb\x58\x93\x1d\x4a\x7c\x6d\x28\xb1\x88\x76\x28\xf1\xf5\xa0\x84\x1d\x52\xb0\xa0\x4d\x90\x52\x34\xdf\x57\x55\xbd\xca\x3c\x7f\x04\xe7\x43\x59\x2a\x2a\xcb\xb9\xc5\x8a\x4a\xe8\x07\x2c\x30\x26\xe9\x3a\x92\x5d\x57\x3b\x9a\xe8\x76\xda\xe2\xda\x0d\x4c\x60\x19\xdc\x0f\x1f\x75\xb5\x1d\xb3\xe0\xaf\x41\xef\xbf\xb7\x87\x5e\x84\x21\xc2\xc2\xcd\x85\xa4\x96\x5d\x49\xce\xb4\xb7\x26\xca\xd8\x8c\xa0\x29\x89\x78\x8d\x19\xc9\x32\x3c\x21\x19\xa2\xb1\x8c\x4e\x71\x4e\x22\x96\xcc\x48\x9c\x73\x70\x24\x3e\xa7\x29\x13\x49\xb9\xe0\xb7\x13\x6d\xa5\x17\x93\x45\xde\xe3\x4f\x57\x44\x67\x09\x4b\xf3\xbd\x98\xf5\xc0\x77\x34\x22\x3d\x19\x3a\x41\x44\xf3\x49\x69\xf8\xbb\x1c\x93\xd0\xec\x3c\xbb\x77\x8f\x8e\x51\xbb\x52\xf0\xd9\x32\x82\xcf\x96\x31\x5d\x90\xdb\x2d\xcd\x0b\xe0\xc8\x5b\x45\x2a\x54\x96\x39\xf6\x2d\xde\x55\x4b\x46\xcd\x71\xc6\xe0\x58\x48\xc8\x62\xdb\x50\xa2\xa1\x9c\x97\xb7\xee\x0a\xb5\xba\x90\x10\xab\x48\x2a\xdf\xf2\xa7\xe0\x4f\x74\xf1\x9a\xa0\x1e\x0a\x70\x1c\xb3\x1c\xcd\xe8\x02\x45\x64\x82\x83\x4b\x64\x84\xbf\x60\xd2\x1d\xcc\xd3\x94\xef\xd2\xcf\x6f\x8e\x51\x82\xf3\x9c\xa4\x71\x79\x20\xba\x31\x0e\xc8\x88\xb1\xb3\xbd\x71\xc4\x2e\xf6\x68\x96\xcd\x49\xb6\x77\xf0\xe8\xe0\xe0\x3f\xe0\xef\x80\xcd\xf8\xb0\x7a\x0f\x1f\xee\x1f\x3e\x1c\x3c\x1d\x3c\x75\xe7\xed\xc8\x9c\xc5\x2c\x5d\xfc\xb7\x16\xb3\x6d\xc9\x8b\x64\x50\x62\xfb\x40\xd4\xd7\xb4\x30\xbf\xbe\xa2\x46\xf5\xfa\x6a\xd1\xc4\xab\x01\xc2\x27\xf9\x71\x16\xd6\x7c\xcc\x66\x75\x1f\xd5\x79\xaa\xef\x5d\x9c\xb3\xfa\x3a\x0b\x7f\x4d\x44\x3f\x32\xfd\xca\xd5\x03\x87\x02\x22\xa3\xcf\x9d\xb6\xb5\x9d\x5b\x8a\x19\xfa\x70\x83\x31\x43\x37\x10\x04\x74\x6f\x0f\xa1\x0b\x82\xcf\x84\x03\x70\xf1\xb8\xdb\x87\xb9\xf8\xb5\xad\x49\xe0\xbf\xf0\x8c\xbc\x8a\x7f\x4c\x53\x96\x56\x11\x94\x32\x38\x6d\xf9\x37\xe8\x6f\x3c\xda\x60\x5c\xec\xa5\x65\x0c\xff\x47\xc6\xfa\xb6\xbb\xed\xa2\x88\x05\x22\xcf\x02\x54\xf9\x69\x1e\x45\x90\x27\x57\x87\x04\xe0\x63\xb1\xbf\x9c\xe0\xb1\xca\xd2\xac\x8a\xd0\xa7\x4f\x1a\xbe\x0c\x7f\xe5\x44\xf8\x82\x21\xbc\x57\x35\x3e\x08\x2a\xea\x06\xcc\xff\x46\xd4\xb1\x67\xf4\xa1\x63\x85\xf4\x91\xd3\x8a\xc9\x05\x82\x75\x6a\xb7\x20\xc9\xb6\xca\x7d\x72\xda\x42\x0f\x8a\xa3\x7c\x80\x5a\xa7\x88\x8d\x45\x3e\xa8\x16\xd4\x29\x5b\x73\x51\x6f\x36\xcf\x72\xdb\xd1\x0c\xaa\xdb\xe3\x81\x6a\xfd\x56\x47\x86\x0d\xd0\xd1\x90\xcc\xe0\xe6\x51\x24\xe3\x24\x49\x82\xab\x3f\x59\xbb\xf6\xac\x22\x5a\x6f\x11\x41\x9e\x15\xf0\xff\xe0\x66\xe1\xff\x2e\xa3\xe2\x97\x8c\xe9\x3b\x21\xbc\x38\x67\xfc\x90\xbd\x19\x57\x0c\xe1\x49\x45\xf5\xba\x70\x9a\x6e\x4d\x37\xfc\xe9\x31\x8e\xa2\xe3\x29\x09\xce\xaa\xe6\xfc\xb4\xa2\x7e\xdd\x54\x3d\xc8\x5e\x4c\x53\x88\x73\x5e\xd5\xdd\x70\x50\x56\xbb\xb6\x33\x0b\xa8\xc9\x09\xc9\xb2\x8c\x8e\x22\x72\xcc\xe2\x2c\x4f\xe7\xfc\xf8\xbd\x85\x93\x5b\xd9\xef\x70\x79\xdb\xba\x51\x54\x77\xa8\xe1\xd2\x78\x4a\x52\x9a\x57\x4f\xbd\x58\xb5\xae\x47\x0d\xae\xb3\xcb\xc3\x59\xc4\xbe\x6b\x0d\xd8\xbb\x8b\x52\x7b\x83\xa3\xd4\x6e\x3a\x07\xa8\x0c\x54\x37\x34\x41\x03\xa5\x29\x34\xcd\x72\x40\x09\x08\xac\x16\x93\x42\x04\x3b\x9d\xd0\x53\x87\x33\x34\x25\x26\x37\x68\x4a\x22\x9c\xd3\x73\x37\x7a\x98\x6e\xf1\x97\x0b\xe2\x1d\x4b\x54\x66\x46\x3b\x31\xa6\xd7\xd1\x0f\x2c\xcf\xd9\xac\xac\xa2\xdd\x47\xe8\x26\xf1\xac\xef\xc1\x8e\xf3\xb8\xb4\x17\x1d\xae\x51\xe5\xe3\x9c\x8f\xa6\x04\x87\x76\x54\x42\xbb\xb7\x81\x09\x4b\xb5\xf1\x74\x92\xbb\x68\x3c\xbb\x68\x3c\x5f\x6f\x34\x1e\x3e\x67\xce\x22\xe8\x5c\x8b\xf2\xd8\xa1\x90\x64\x74\x12\xcb\xa5\x3e\x23\x97\x23\x86\xd3\x10\xbc\xbc\x66\x8c\x2f\xa9\x48\x6e\xa8\x12\x60\xaa\x4d\x11\xf0\x21\x46\x00\xcd\x84\x53\x18\xfc\x01\x16\xe9\x7d\xe4\x3c\xe8\x68\x86\xf0\x39\xa6\x11\x44\x1e\xce\x19\xef\x31\x20\x71\x88\xe3\xdc\xc2\x3f\x84\xc1\x47\x4d\xc0\x95\x59\x22\x75\x2e\x3a\x13\xeb\x44\x10\xaa\x3a\xc9\x79\xd5\x02\x14\x26\xae\xa6\x94\x92\x19\x3b\xe7\xb3\x4a\xd9\x4c\xcf\xa8\x90\x42\xf4\x57\x45\x86\x1b\xf7\xfd\x5b\x26\x53\x44\xea\x85\xc8\x19\x4a\x70\x96\x21\x8c\x52\x32\x46\x01\x8e\xa2\x11\x0e\xce\x54\xd0\x68\x40\xf1\x12\x6c\xe5\xe5\x6f\xc9\xb8\xb2\x67\x8e\x83\x65\xe7\xa8\x9c\xe8\x75\x4d\x4e\xcd\xd3\x5f\x68\x96\xbf\xca\xc9\xcc\x4a\xaa\x6b\xd1\xe7\x5b\x4c\x0a\xf5\xd5\xc1\x67\x68\xdf\xf6\xed\x8f\xd0\xee\x5b\x6d\x38\x2b\xae\x7c\x10\x92\x69\xc6\xdb\x88\xc8\x78\xf3\x2e\x2a\xb4\x01\xb9\x88\x86\xc9\x2b\xb5\x9d\x58\xd4\xde\x6b\xc9\xc0\xcb\xa7\x34\xeb\x42\x03\x37\x5e\x21\xb4\xaa\x7e\x7b\xf8\x00\x60\x5c\xfd\x8f\x7c\xd2\x39\xfb\xf8\x91\xb3\x42\x00\xc1\x7b\x16\xba\xf3\xe8\x74\xfa\x90\x2b\x57\xc2\xc0\xe9\x64\xce\xa9\x46\xd6\x31\x36\xc7\x62\xf0\xd6\xd3\xcb\x5f\x89\xf7\x62\x92\x67\xe4\xf2\x08\xb5\x26\x24\x3f\xe6\xf7\xe6\xb1\x38\xa4\x92\xe7\x91\x72\x05\x2b\x2c\xb6\x53\xab\x6d\x04\x41\x0e\x9f\x65\x71\x21\x7c\x7c\x7d\xe9\x26\xc7\x4b\x94\x84\xe6\x99\xe1\x0d\x54\x7c\x7b\x31\x90\x94\xc4\x21\x49\x2b\xfa\x17\x1f\xdb\xae\x0c\xcc\xf7\x4d\xd4\xe5\x89\xe4\x21\xcc\x18\x4c\x6e\x6d\x3b\x2b\xe9\xc7\x52\xff\x45\x54\xe2\xc3\xf8\xb1\xc2\x89\x11\x95\x38\x32\x7e\xac\xf0\x64\x44\xc8\x27\x43\xa6\xb2\x5b\xee\x8c\xc4\x24\x59\xfd\x58\x9e\x65\x55\x2f\xba\x05\x0e\xd2\x1f\x5a\xdf\x35\x41\x30\x75\x74\x91\x5d\x4f\x52\x29\x53\x4b\x16\xd8\x75\x56\xf4\x03\xfc\xb8\x9a\x23\xa0\xbb\x12\x7e\xc2\x54\x91\x9d\xac\x8b\x5a\x7a\xf4\xc2\x5c\x11\x06\x29\x3c\xf8\x0c\x1e\x7c\xb9\x8c\x9d\x62\xfd\xe5\xae\xdc\xbf\xaf\xd3\x6c\xca\x59\xad\xe7\xd9\x27\x6f\xbc\xee\x66\xa0\x99\xed\x37\xc8\xd1\x24\x39\x26\x5a\xd1\xdb\xc2\x3b\x1f\x06\x91\xd6\x73\x00\xe9\xc2\x2b\x7c\x7c\xa4\x31\xf5\x73\xc7\x80\x2c\x41\x69\x2b\x37\x26\x52\x9e\x19\x92\xfc\x88\xec\xb9\x72\x2e\x9c\x32\x3e\xbb\xf7\xb9\xed\xcf\xc9\xb9\x2e\x80\x60\x97\xe8\x85\x6d\x1d\xef\x3c\x02\x12\x26\xa9\xa0\x9f\x74\x4e\xf3\x1f\x26\xe5\x9c\x80\x1a\x58\xd4\xd5\x56\xba\x29\x56\xa9\x24\xd3\x9c\x4e\x0d\x7d\x55\x75\x11\x1f\x00\xa8\x8b\xe4\x95\xe6\xcb\xb8\x0f\xef\x78\x5e\xb8\xeb\x97\x5a\x6f\x55\x08\x7f\xa3\x44\xe2\x3b\x89\x66\xa5\x44\x13\xa7\xb1\xe4\x01\xca\xd6\xe6\xc0\xaf\x58\x2b\xcc\x14\x55\xbe\x46\x69\xa9\xbc\x6e\x36\x25\x94\xfc\x22\x02\x49\x99\x83\xe3\xe1\x23\xed\x8a\x48\xe8\x64\x9a\xdb\x25\x63\x16\xe7\x27\xf4\x4f\xa2\xa4\x73\xf9\x65\xc2\x26\x29\x4e\xa6\x97\xfd\x64\xf1\x8e\xbd\x25\xb3\xf6\xf0\x49\xc7\x15\x58\xbe\x15\x40\x0e\x6c\xc9\x1d\x0d\x58\x5c\xe8\x78\x7f\xe0\x77\x6c\x4a\x1a\x74\xbc\x3f\xe8\x5c\xa7\xc0\xcf\x7e\xfb\xbe\x38\xc7\x39\x4e\x4f\xaf\x2e\x03\xd4\x68\x74\x35\x79\xd0\x55\x5c\x15\xaf\xe2\xa6\xb8\x59\x19\x94\xeb\x9e\x78\xfb\xe4\x91\x82\xaf\x02\x30\x2a\x1c\x12\xca\x20\x87\x97\x36\x76\xcb\x19\x0c\xf8\x52\x04\x47\x92\x82\xaa\x19\x0b\x89\x3a\xdc\x39\xb3\xb1\xeb\xbb\xbd\x7b\x8e\xa4\xe0\x55\x4e\x66\xe2\xab\xb2\xe6\x90\x42\x2e\x71\xd6\xe9\x18\xb5\x95\xd4\x4b\x3e\xcd\x9e\x5b\x8c\x87\x7a\xc6\x36\xf6\xe4\x05\x76\x4e\x5e\x03\x86\x97\x13\xcc\x25\x6a\xbd\x96\x59\x44\x7b\xbf\xbd\x3a\x42\x7f\x77\x87\xf7\x0f\x90\xdb\xd5\xce\x5e\x0c\x50\x4c\xfb\xff\xc5\xe2\xd4\xe7\x0c\xfd\x5d\x02\xe8\x43\x54\xec\x90\x41\x9c\x32\x48\xf8\x45\x73\x34\x8f\x23\x92\x65\xe8\x92\xcd\x11\x4e\xc5\x51\x4d\x59\x14\xa9\x54\xaf\x30\x88\x7f\x48\xc8\x3a\xf6\x6a\xab\x83\x8e\xd0\x39\xa3\x21\x1a\x38\x72\x13\xf7\x59\xab\xe5\x18\xf0\x84\x33\xaf\xdf\xf2\xc7\xef\x66\x62\x11\xad\x1d\xda\xc6\x7a\x9a\x96\xbe\x6e\x55\x4c\x99\xaa\x17\x53\xc4\x62\xfd\x60\xd2\x53\xab\xcf\x0a\x65\x1d\x82\x9a\xc8\x34\x4b\x13\x0e\xba\xcf\x5e\x07\x59\xfd\x87\x5f\x57\x6f\x43\xdf\x5b\x3f\x79\xe1\xa8\xcf\xc7\x9b\x1d\x1a\xbf\xab\x4a\x86\xe6\x8d\xc5\xef\xbb\x23\x44\x4b\x22\x5c\x80\x70\xa1\x77\x8f\x44\x59\x66\xef\x26\xcf\x2c\x0f\xca\x6c\x4e\xa5\x6c\xa1\xe5\x7e\x69\x6d\xe8\x49\x66\x41\x54\x8f\x33\x53\xb4\x25\x73\xbe\x47\x77\xfc\xa9\xb7\xb3\x7e\xda\xe6\x53\x6f\xfc\x0c\xb9\x06\x98\xbb\xe7\xdf\x17\xcd\x40\xfd\x4e\xf3\xea\x55\xf8\x3e\x28\xa9\x5b\xd7\x89\xa9\x75\xd3\xde\x81\xd7\x6b\x35\x73\x5d\x26\x29\xda\x6c\xa4\x35\x40\xc3\x47\xc9\xc2\xca\xb5\x79\x04\xd9\x55\x7b\x70\xff\x95\xe5\xda\xfc\x85\x8c\x73\x65\x8a\xa1\xb3\x6c\xca\x47\x60\x9c\x11\xab\xf3\xa6\xb0\x4a\xec\x42\xbe\x43\x8f\xcb\x3a\xf0\x2c\x51\x9a\x3c\x5e\x1f\x76\x6c\x00\xfc\x7e\x3e\x02\xe9\xfb\xde\x1e\xfa\x35\x25\x99\x74\x4b\xc1\x90\xf7\x9e\x53\xde\x34\xc6\x11\x0a\xe6\x59\xce\x66\xf4\x4f\x30\x97\xd6\x0d\x5f\x56\xf5\xde\x92\xca\xc1\xd6\xa6\x9f\xab\xb7\xe3\x59\x54\x9f\x2d\x47\x71\xda\x17\x2c\x6e\xe5\x3a\xfd\x0d\x09\xd1\xe8\x52\xa4\xf8\x50\xa4\xc4\x4f\x0b\xe2\x26\xf4\x04\x5d\x79\x80\x63\x69\x66\x20\x97\x85\x17\x08\x1d\x1e\xc2\x31\x9a\x1e\x40\x03\x82\x43\xfe\xb8\xc7\xbe\x92\xde\x10\x99\x2b\x24\xff\xd1\xd3\x91\xf6\x01\x34\x0e\x49\x9c\x93\xb0\xaf\x04\x0c\x34\xb3\x52\xfd\x80\x41\x04\x05\x41\x43\x4a\xf8\x93\x29\x66\x28\x22\xe3\x1c\x61\xe0\xb6\x10\x4b\xc5\x4f\xce\x92\x5a\x39\x7f\xc4\x39\xaa\x1d\x23\x7f\xe5\xd1\x19\x4e\x2f\x6f\xb5\x2a\x1e\x1c\xca\x48\xc0\xe2\xf0\xb6\xcf\xc4\x8b\x79\xab\xb8\xea\x77\x64\x91\x97\x3e\xe5\xb7\x1b\x04\xb7\x80\xf1\x56\x6c\x59\xef\x8b\xbe\x12\x04\x3a\xe9\x8a\xf2\xb7\x8e\xfc\xaa\x76\xc9\x04\x80\x55\x25\x3a\x5e\x2e\x47\x5b\x13\x30\x97\xff\xda\x56\x8c\xd7\xc2\x2c\x78\xa1\x1c\x31\xa8\x71\xd5\xd8\x20\xec\x2b\x1f\x49\xeb\x83\x0e\x17\xa7\x94\xda\xce\x0b\xf0\xd9\x6a\x21\x5a\xb7\xad\xdd\x5d\x4f\xf9\x2a\xd6\x5c\x6c\x44\x13\xa5\x6b\x73\x85\xab\xf6\x31\x5d\x57\xc1\x2a\x9f\xf4\x0a\xcb\xee\xdf\x47\xed\x22\x92\x7e\xaf\xbf\x1f\x35\x8c\xb9\x67\xb1\x97\x7e\xdc\x3d\xc3\x6d\xf0\x53\x7a\xa4\x75\xfb\xa0\xfe\x37\x8a\xdc\x26\xb2\x05\x1d\x04\x97\x2c\xf2\x65\x1b\x63\x4b\x1a\x34\xd7\xa0\x76\xb5\xa3\xb8\x1a\xef\xd4\xc1\xaf\x8e\xf2\x08\xd4\x47\xad\x6a\x95\x4c\x8d\x8d\xae\x53\xc0\x22\x96\x1e\x39\xa7\xc7\x5f\xc3\x11\x0b\x2f\x87\x37\x67\xf9\xf4\x48\xe5\x02\xde\x03\x55\xbc\x25\x9a\xe1\xf4\xf7\xfa\xa3\x1c\xde\x99\x90\x75\x65\x74\xb6\x86\x2d\x69\x1c\xb6\x0d\x28\xf2\x46\x40\x19\xa2\x7f\x8b\x99\x87\xc6\x31\x87\xac\x6b\xed\x76\x4f\xd7\x0e\x8b\xe0\x9c\xd5\x12\x33\x98\x12\xf6\x5d\xdb\xbf\x68\x26\x58\x97\x58\xec\xa4\x2e\x93\x0c\xb5\x31\x8e\x71\xba\x5c\x53\x6e\xbb\x29\x59\x2c\x1f\x83\x23\x89\xe5\x05\x5b\x92\xc3\x3e\xde\xb9\x95\x7e\x55\x16\x2d\x77\x40\xe2\x78\x93\x84\x81\x77\xc1\x28\x44\x9b\x62\x1c\x94\x5a\x75\x94\x0a\xe3\xb4\x47\x97\x32\xec\x38\x30\x69\x54\x80\x65\x14\xad\x12\x1c\x91\x3c\x27\x7d\x0c\xc3\x82\x7f\xce\xf5\x93\x74\x1c\x91\xc5\xc9\x34\xa5\xf1\xd9\x35\x3b\x72\xd9\x76\x1d\xaf\x02\x16\x9f\x76\xd1\xe9\xc9\xf9\x44\xfc\x29\x9a\x83\x2b\xd0\xe9\x4c\xe9\xbb\xe7\xb4\x47\x03\x16\x67\xa7\xe8\xe4\xdf\xff\x04\xd9\xcc\x26\xdd\xc2\x76\x26\x21\x77\xd5\x24\xe4\x45\xa5\x3d\x04\x38\xd3\x9c\x5a\x36\x20\x38\x96\xc8\xc8\x71\x4f\xa3\x63\x85\x45\x08\xff\xe6\x27\x50\xda\x59\x30\xac\x67\xc1\xe0\xd9\x27\x34\xb4\x47\x28\xea\xfe\x37\xc5\xfd\xf1\xbd\x75\xb8\x3f\x5e\x50\x62\x2c\xfd\xe4\x8e\x6b\xd0\xaf\x5f\xc9\x7d\x6d\x7a\xe5\x1d\x13\xb6\xd3\xc8\x1a\x7f\x76\xe3\xd0\x8f\x47\x19\x8b\xe6\xb9\x89\x07\x90\x4a\xc3\x5a\xf5\x3b\x67\xc9\x11\x6a\x1d\x0e\xfe\xd3\x8b\x18\x00\xce\xf0\xbd\x52\x4e\xed\xe1\x17\xe2\xac\xd4\x7d\xf6\xc3\x3c\xcf\xe5\xad\x96\x91\x48\x66\xd5\x92\x66\x7c\x3b\x8f\xfa\x1b\xc2\xae\x14\x18\x8c\x13\x25\x33\x79\xa1\x69\xff\x56\x78\x8d\x22\x9f\x51\xcf\x04\xd4\xea\x21\xfe\xba\xd2\x85\xdf\x51\x42\x64\xcb\x93\xcb\x15\x1d\x7b\x8b\xf2\x85\x72\xe5\xdc\x85\x93\x72\x1b\xc4\xe1\x65\x02\x49\x1f\x03\x4a\x4c\x33\xbd\x2a\x9b\xb4\xd1\xf4\x41\xdb\x4c\xa2\xf7\x6d\x4b\xd2\xc2\xa7\x77\x9c\xe7\xdc\x59\x6d\xde\x01\xab\xcd\x3b\xc0\x5d\x43\x43\x11\x0b\xb9\x72\x12\x07\x37\x8d\x0d\xff\x92\x91\xbb\xbe\x8a\x97\xc2\x88\x2d\x4e\xe8\x9f\xc2\x4a\x73\xc4\xd2\x90\xa4\xbd\x11\x5b\x58\x51\xc5\x62\xf2\xb3\x94\xe5\xb6\x0e\x9e\x24\x8b\xe5\xf1\xc6\x96\x5b\x5d\xfa\xa1\xbb\x1a\x09\x85\x4b\x65\xc0\x60\x59\x53\x30\x11\x1a\xb3\x38\xff\x09\xcf\x68\x74\x59\x62\xb3\x69\x3e\xda\xd5\x7f\x27\xf6\x18\xbc\xea\xe2\xe3\x6b\x12\xd2\xf9\x6c\x05\xcf\xc2\x52\x58\xbc\x8d\x63\x2c\x0a\xf3\xfa\x55\x29\x18\xff\xaa\x9b\xad\x54\x43\xbe\x3f\x1c\x0c\x3e\x14\x40\xbc\x12\xd6\xa1\x05\x10\x9e\xd9\x68\xa9\x0d\xed\xf2\x2d\x7b\x6a\xb7\xce\x72\x1a\x9c\x5d\x96\xbe\x36\xc5\xa7\x96\xf3\xb6\xd4\xde\x98\x7f\xbe\x8a\x43\xb2\x38\x42\x43\x55\x30\xc2\xc1\xd9\x04\x92\x32\x1d\x97\x0e\x76\x17\x83\xed\x2b\x79\x31\x5e\x7f\x0c\x36\xe8\x44\x31\xcf\xc0\xd4\x09\x5f\xc3\xd3\x91\x90\x2d\x7c\x85\x91\xda\xc4\xb2\x47\x2c\x2d\x9e\x10\xe1\x87\x3a\xcf\x94\x8b\x24\xd0\x08\x24\xe9\x12\xba\x98\x92\x58\x98\x4e\xcf\xf0\x19\xc9\x50\x46\xe2\x8c\xd8\x0b\x08\x67\xbb\x3e\x95\x45\x4b\xee\x85\x67\x62\xa9\xe8\xc1\x87\xea\xa8\x72\x7c\x3c\x10\x63\xeb\x44\x87\x09\x02\xb3\xe9\x98\xe5\x82\x52\xa9\xe0\x66\x39\x4b\x50\x38\x07\x34\xc9\x82\x94\x45\x51\x21\xc0\xda\x89\x24\x6c\xeb\xda\x6d\x97\x0d\xa3\x60\xbd\xdd\xcc\xf6\xba\x44\x86\xa2\x01\xfb\x92\x93\x52\x0b\xdf\xeb\xd1\xdc\xf8\xe1\xa3\x2a\xa2\x47\x09\xb4\x32\x9f\x23\x96\x7a\x46\xc4\x62\xe9\x7d\x03\x62\x51\xba\x4d\xd3\xdf\x65\x1a\x24\x3f\xc2\x13\x8c\xdd\x32\x0e\x3e\x91\x17\x9e\x6d\x00\xfc\xa5\x6d\x7c\xdf\xcb\x51\xa2\x07\xa2\xb1\x64\xfa\xfb\x01\x4e\x68\x8e\x23\xfa\x27\xf9\x89\xa6\x59\xfe\x0b\x3f\xbc\x69\xa7\x0d\x95\x3b\x1f\xba\x72\x97\x20\x9a\xbe\x3a\x8d\x1b\xb1\x10\x5e\x27\xc0\x93\xd8\x78\x1d\x2d\x4a\x2c\xf3\x66\xad\x8d\x4b\x42\x3b\x5d\xc9\xea\xb8\x54\xc6\xa7\x0f\xed\x2e\x0b\xf6\xba\x76\x04\xbb\x2c\xd8\x3b\x19\xea\x2e\x0b\xf6\x3a\x59\xb0\xc5\x55\x75\x45\xc6\x6b\x45\x2b\x6e\x7d\x21\x5e\x9b\x05\xb7\x2f\x54\x37\x24\x77\x49\xb4\xbb\x88\xca\x84\x66\xe2\xed\xa9\x17\xa2\xc8\x10\xd6\xdb\xf8\x9a\x0e\x3d\xd9\xbd\xfe\xb0\x29\x89\xbd\x01\xa8\xe4\xf4\xba\x64\x2b\xd2\xf9\x47\x83\xc1\x4e\x3a\x7f\x47\x4c\x7f\x77\xf9\x5d\x76\xf9\x5d\x6e\x5e\x7e\x17\xf8\xf5\x92\xcd\xaa\x34\x12\x4f\x0b\x35\x97\xc2\x7e\xc9\x66\xd7\x12\xa7\x50\x66\xc6\xab\x52\xa6\x0c\xf7\x9f\x14\xaa\xd6\x6a\x84\x64\x1d\x4b\x57\x37\x62\xf3\x38\xa8\x52\x2e\x1c\xee\x17\x6a\xd6\x81\x57\x75\xdc\xf5\xfc\xf1\x9c\xc4\x39\xbf\x47\x48\x2c\xc2\x2b\x97\xd1\xc0\x87\x35\x6d\x96\xee\x86\x53\xfb\x5a\x75\x5d\xaf\x59\x88\xa3\xca\xcd\x79\xec\xd6\xab\x83\x0d\x15\x74\xf5\x7f\xa6\xec\xa2\x6a\xd0\x83\xa1\x53\xad\x0e\x28\xff\xae\x2b\xff\x8a\x93\xca\xe5\x3f\x3c\x70\xab\xd5\x01\x85\x0a\x37\x4d\x87\x77\x6d\x0a\xb2\xbd\x3d\xf4\x5f\x92\x6c\x91\x50\xbf\xee\x11\x6c\xdf\x4a\x23\x7e\x97\xe2\x58\xa8\x34\x8e\xb5\x94\xac\x94\x3a\x0d\x1a\x8f\xbf\x08\x72\x83\x2a\x48\x0b\xb8\x4a\xe8\xb0\xc9\x01\x2b\x98\xcb\x46\x6c\x07\xdc\x7f\x33\x1e\x67\x24\x7f\x07\x59\x25\x83\xdc\xa4\xbe\x30\x52\x4b\x06\x35\xd0\x73\x34\x00\xb9\x8d\x95\xdf\x51\xa7\xc9\x80\xf7\x57\x3c\x9f\x8d\x48\xda\x52\x61\x07\x75\x33\x55\x0b\x42\xee\x21\x12\x65\x04\x60\xb8\x8d\x03\xc2\xd1\xbf\xd8\x98\x0f\xaa\x2f\x9c\x54\xd0\x1e\xda\xaf\x85\x31\x82\xcc\x42\xb5\x30\x74\xd8\x3f\x75\xa0\xa0\x0e\x08\x81\x8a\x8b\xf2\x0b\x19\xe7\x72\x55\xa6\x2c\xa5\x7f\x72\xba\xdf\x68\x5d\x4c\xed\xfa\x95\x31\xf5\xbc\x79\xf9\x00\x6a\x57\x07\xbc\x70\x4a\x16\xc7\x07\x02\xf6\xa4\x75\x30\x1a\x2e\x0e\x20\xdc\x98\xa5\xb3\x37\x29\x9d\xd0\xf8\xdf\x9c\x95\x6f\xe7\x6e\xa1\xa3\xce\x7e\xef\x7d\xec\x9b\x91\x75\x91\xff\x4d\x6d\xe9\x87\xfe\x0c\x27\x6d\x93\x8c\x23\xf6\x12\x9d\xca\xa5\x8e\x9d\x15\x46\xdf\xa3\x18\x3d\x40\xad\x64\xd1\x42\x47\x48\x04\x79\xec\xf4\xff\x60\x34\x6e\xb7\x50\x4b\x08\xfb\xf6\xf6\xd0\xc9\x5c\x24\x6f\x11\xda\x85\x77\x2c\x41\x23\x92\x5f\x10\x12\xa3\xfc\x82\x29\x6d\x54\xd6\x77\x66\x7d\x02\x75\x7f\xc5\x29\x89\xf3\x76\x02\xff\x48\x0f\x01\x83\x11\x44\x3b\x84\xc1\x07\x15\x61\xc2\x74\xa3\x70\xe5\x62\x4a\x23\x82\xda\xaa\xfe\xfd\xfb\xba\xe9\x37\xcf\x9f\x23\x01\x5d\xcd\xd7\x00\x95\x7f\xf5\xc5\x77\x4e\x68\x45\x80\x4b\x03\xff\x81\xa9\xa4\x0b\xc5\xae\xea\x75\xb3\xca\x3f\x2f\xb3\x54\xe0\x03\x48\xf8\x4d\xa5\x54\xc8\xd5\xe6\xca\xec\x9c\xa4\xe3\x88\x5d\xfc\x0f\xff\x64\x62\x4b\xa9\xe2\xff\x7b\x84\x5a\x22\xcf\xb8\xfc\xc0\x77\x81\xa1\x0b\x82\x32\x02\x5a\x2a\x94\xb0\x84\x57\x16\x3a\x2a\x9a\xb7\x32\x44\x66\x49\x7e\xd9\x57\xb5\x41\xb1\x35\x63\x59\x8e\x22\x7a\x46\xa2\x4b\xc4\x62\x04\x09\xa6\xf9\x1f\xf3\x8c\xa4\x11\x8e\x85\xe2\x06\xcd\x68\xfc\xbb\xf0\x4c\x1b\xca\xc8\xc6\x33\x1a\x2b\xe3\x08\x5d\x84\x17\xb2\x52\x2b\xc0\x51\xd0\x1e\x0e\x06\xe7\x17\xa8\x87\x1e\xee\x27\x8b\x4e\x4b\xd7\xd1\x36\x15\xba\xd2\xd4\xab\xd4\xba\x7f\x34\x66\xc1\x3c\xb3\x22\x5a\xb1\x79\x1e\xd1\x58\x1b\x5c\x18\x1d\xf9\xaa\x2a\x72\x71\x26\xe4\x4e\x98\x53\x53\xaf\xa3\xe3\x30\xda\xef\x97\x08\x93\x22\x32\x06\x65\xdd\x32\xa1\x93\xa4\x3c\x0d\x6a\x0a\xf2\x52\x53\x51\x9c\xd1\x0f\xbe\x3c\x56\x1d\xf8\x0d\x4c\x2a\x67\xc9\x66\xe7\x24\x6f\x94\xd5\x26\xc5\x37\x79\x15\x33\x08\x79\xa6\xe4\x2e\x83\x25\x46\x6d\x67\xde\xfa\x45\x60\x0c\xd2\xb4\xc5\xaa\x83\x2b\xb7\xd1\xa0\x19\xa2\x90\x82\xcb\x51\xdf\x4b\xcd\xf2\xa5\x0a\x75\x25\x6a\xe7\x0c\xf1\x8b\x46\x9c\x71\x39\x55\xa9\xb7\x96\x67\xde\xa8\x5b\x71\x1c\x4c\x59\xfa\x63\xa4\x65\xf3\x3f\xbf\x7b\xfd\x4b\xa5\x87\x64\xc5\x9c\x55\x94\xb0\x37\xe3\xb6\xd5\xbc\x53\x2d\xe0\xc5\xf1\xa5\xaf\x60\x37\x13\xd4\x63\xbe\xda\xec\xa4\xd2\x9e\xa5\x21\x8d\x71\x4e\x32\x08\x68\xac\x72\x38\xa2\x9c\xdd\xd3\x39\xd2\xc0\xda\x43\xa4\xe6\x6e\x65\x28\x88\x28\x9f\x3b\x4e\x09\xf6\x97\xe9\x57\x4d\x8c\x6b\x05\xd7\x82\x28\xad\x8c\x56\x2b\x23\x16\x02\x59\x24\x2c\xa3\xb5\x8a\x21\xc9\x49\x3a\xa3\x31\xc9\xf8\xa5\x17\x4c\xe5\xd8\x41\x35\xcc\x17\x2f\x25\x63\xe1\x19\x29\x16\xd2\x2c\x43\x43\x5c\x79\xcb\xdb\x93\x38\xa8\x36\x5c\x51\x67\x59\xe1\x56\xab\x8b\x5a\xee\x02\x16\x8c\x16\xdc\xfd\xa7\x71\x8e\x60\xff\x89\x1a\xfc\x05\xc4\x6f\xb3\x46\xd5\xca\x44\xc3\x53\xd5\xc9\xa9\xb0\x29\xc0\x79\x8e\x83\x29\xca\x59\x5f\xc3\x8c\x99\xb4\x94\x91\xc6\x18\x32\x8b\x9d\x37\x1b\x5e\xd3\x1f\xa5\x98\xba\xa8\xfe\x26\xe1\x45\xd9\x91\xf8\x65\x48\xe8\xfb\x1c\x1c\x17\x81\xc0\x75\x91\x20\x5f\x1f\x9e\x89\x5a\xf6\xfd\xf1\x9e\x6f\xae\xa9\x08\xb4\xfb\x83\xbf\xb6\xe2\xf6\x69\x84\x5e\x77\xf4\x6e\xba\x8b\xb7\x93\x75\x4e\x6f\x87\xcd\xdd\x5a\x2a\x69\xbf\x61\x63\x5d\xf4\xa6\x35\xb5\x37\xc4\xa3\x9d\xef\x31\x89\xc8\x39\xae\xa5\xa9\xba\xc6\x12\xba\x5f\x42\x2e\xf5\x5b\x89\x66\x90\xad\x92\x84\x88\xc6\x08\x0c\x95\x05\x9d\xcf\x53\x4a\xce\x89\xc4\x2e\x81\x6c\x92\x9c\xaa\x27\x8b\x34\xd5\xe2\x8c\x3e\xaf\xc5\x12\xb8\x03\x88\x1a\xad\x45\x5c\x75\xb0\xff\x22\x02\xbb\x30\xad\xe0\x9b\x38\xd6\x85\x34\xce\x68\x48\x4a\x2e\x69\x69\x3d\xa7\x96\x3e\xe5\x6f\xe3\xe8\x52\xbe\x99\x20\x71\x69\xf3\xcb\x5e\xd5\x00\x33\xb6\x3c\xc5\x39\x99\x5c\x22\xbe\x08\xe0\xf1\x3f\xc3\x67\x75\x6b\x81\xfe\x98\x67\x39\xc2\x23\x26\x56\xcc\xbe\x23\xdc\xe5\xe2\xbb\x36\x21\xf9\xb1\x80\xf2\x42\xf3\x4f\x15\xdb\x57\xcc\xff\x79\x92\x90\x80\x8e\xf9\xa8\xa6\xec\x02\x05\x11\xcb\x88\xb2\xc3\x23\xe1\x44\x2f\xfe\x05\x8d\x43\x76\xe1\xbc\xd4\x02\x1c\x73\x4c\x25\xd8\x42\x20\xe9\x91\x3a\x4d\x49\x36\x65\x51\xb8\x12\x1a\x69\xf1\xd5\x18\x4e\xec\x88\x8c\x59\x4a\x5c\x6a\xc4\x91\x0b\xc8\x23\x8d\x27\xa6\x53\x16\xff\xc8\xcb\x56\x25\x4c\x65\xc2\xb8\x35\xc9\x54\x09\xa8\xcd\x90\x90\x22\xe0\x4e\xed\xa2\x29\xa6\xa2\xe1\x92\x81\x3b\xc1\x6e\xd5\x4a\x56\x6d\x8a\xe5\xb2\xd9\xd6\xa0\x72\xd5\x48\xb8\x5b\xb4\x9a\xf3\xb9\xa0\xb9\x8f\x6b\x0b\xba\xb2\x5d\xdb\x5d\x5c\xb2\x8a\xd3\x59\xbe\x60\xbb\xb3\x59\x7b\x36\x17\x34\xf7\x8e\x26\x94\xec\x96\xac\x74\xc9\x78\xe7\x24\xcb\x81\xf5\x18\x11\x71\xcd\x87\xf6\x83\xf2\xbf\x12\x9c\xe2\x19\xfa\x4b\xf0\x8e\x9f\x11\x39\xe7\xcd\x80\x6b\x84\xbf\x32\x36\x4f\x03\xcd\x0d\xa8\x74\xe4\xf6\xfa\xbf\x15\x5d\x1c\x73\xd0\x2b\xf0\x1f\x9e\x65\xbe\x62\x2e\x68\x86\xce\x29\x58\x52\x58\x7d\x24\xa4\x9a\x31\x1d\x31\x16\x55\xf2\xda\xc6\xcc\xc6\xe6\xad\x81\xa9\x04\x4d\xec\x69\x91\xa9\x82\x72\x10\x7f\x5d\xc9\xb1\x26\x65\xd1\xaa\x3e\x35\x15\xb2\x07\x23\x20\xa7\xc1\x54\xd4\x75\x65\x0c\x96\x84\xa2\x95\x21\x26\xd4\x29\x6b\xca\x0c\xba\x68\xd1\x4e\x16\x9d\xa6\xa2\x03\x55\xdd\x2c\x9f\xa7\xd6\xd9\x09\x11\xbe\x06\x21\x02\x8e\xe9\x4c\x3c\x30\x2d\xe7\x08\xef\xc0\x19\x9a\x84\x33\x44\x73\xc1\x64\x71\x74\x05\x92\x9e\xd9\x89\x13\xd4\x2b\x4f\x38\x7c\x85\x94\xbf\xc6\xd0\x88\xc6\xa1\x74\x20\x7b\x7f\x7a\x7c\x72\x62\x88\xa3\x71\x7a\xc9\x4e\x3f\xb4\xa7\x79\x9e\x64\x47\x7b\x7b\x60\xdb\x12\xb0\xd9\x6c\x1e\xd3\xfc\xb2\xcf\xd2\x89\x28\xea\xe5\xba\x61\x6f\x92\xb2\x79\xb2\xf7\x1f\x0e\xb4\x1e\xef\xbd\x67\x39\x31\x78\xb8\x6d\x9b\x08\x5c\xe1\xd2\x51\x66\x0b\x57\xbf\x73\x24\xa4\x8d\x5f\x39\x02\xae\xb7\xdb\x27\x04\x12\xa5\x08\x55\x1f\x44\xb0\x9b\xe7\x8c\xef\x7d\x00\xf1\x7f\x02\x1c\x05\xf3\x08\xe7\xc4\x5a\x2b\x94\xd3\x19\x41\x23\xcc\x5f\xd7\x2c\x96\x81\x27\xcb\x16\xf5\xe5\x3c\xad\x97\x41\x2c\x3f\x2d\xf2\x79\xd9\x84\xe8\x10\xf1\x74\x5c\xf2\x4e\x85\x9a\xc0\xc5\xd6\x56\x14\xe7\x62\xa9\x24\x9a\x2f\xda\x87\xce\x87\x8e\x56\x07\xfe\x2a\x69\xbb\xe5\x1c\xde\xfe\x08\x7b\xf3\xad\x49\x0d\x0e\x4a\x18\x30\x45\xd6\x66\x81\xc6\x10\x59\x42\xe8\xa2\x42\x33\x50\x38\x6b\xb0\xb2\x5e\x5b\x69\x97\x75\x74\x86\x7b\xe6\x67\x4e\x66\x49\x17\x7d\xcc\xa7\x34\x03\xa3\xed\x5c\x7e\x34\xbe\x51\xc6\xfa\xd3\x8c\x40\x54\x97\xf0\x55\x16\xf7\x31\x4b\x51\x1b\x80\x46\xe0\xe2\x86\xd3\xc9\x5c\x28\xd7\x23\x12\x4f\xf2\x69\x97\x97\x64\xe8\x39\x7a\x91\xa6\xf8\xb2\xcd\x6b\xf1\xf5\x3b\x23\x97\xa0\x2b\x17\x7f\xfd\x1d\x5a\x8b\x1f\x0f\x1e\x74\xb4\x9a\x95\x37\x7d\xcf\x0b\x3f\xd8\x90\x45\x89\xca\xc0\x6e\x9b\x0c\xf0\xa9\xa0\xe7\xa8\x0d\x13\x14\x7f\x70\x32\x23\xed\xbb\xab\xcd\x3d\xfd\x39\x2a\x67\x1f\x39\xd7\xfe\x47\x7e\x6e\x72\xf6\xf1\x23\xfa\xf4\x49\xc0\xf2\x6c\x72\x0b\xdb\xd4\xe9\x80\x99\x77\x1f\xc2\x41\x4a\x23\xfa\xf7\x1c\xf8\x87\x7e\xc0\xe2\x00\xe7\x6d\x3e\xb7\x0e\x84\xc6\xe6\xc5\xea\x5f\xe3\xb0\xf7\x3b\x8d\xa2\xdf\xe2\x19\x9b\x83\x65\x80\xc1\x1a\xb3\x3a\xa2\xc1\x14\xc7\x61\x44\xde\x92\x8c\xfe\x49\xfa\x01\x8e\x03\x12\xb5\x55\x7a\x7a\x05\x34\x23\xf9\xaf\x46\x58\x75\x52\x88\x53\xa0\xec\x14\x0c\x6c\x3a\x2e\x33\x5e\x10\x86\x03\x1d\x2b\x85\x00\xdf\x79\x5b\x0e\xf6\x5c\xf6\x38\x29\xf6\xa8\x3b\xd1\xf9\xff\x91\x0b\xb7\x9f\x0b\xc7\x45\xd3\x8e\x97\x3c\xab\xa8\x0c\x79\x74\xdc\xda\xbc\xa8\xaa\xba\xc7\xae\xf8\xfd\xb8\x5f\x15\x90\xcf\xee\x32\xfe\xff\xec\xbd\xfd\x7f\xdb\x36\xf2\x20\xfc\xbb\xff\x0a\xb4\xcf\x6e\x28\x35\x92\xac\x57\xbf\xc8\x75\x7b\x49\xda\xee\xe6\x73\xed\xa6\x4f\x92\xdd\xbd\x7b\xb2\xb9\x18\x22\x41\x9b\x1b\x8a\xd4\x91\x94\x5f\x9a\xf8\x7f\x7f\x3e\x18\xbc\x83\x20\x45\xc9\x52\xe2\x26\xee\x7d\x6f\x63\x81\x83\xc1\x00\x18\x00\x83\x99\xc1\x8c\xa3\x53\xf5\xa3\x48\x47\xc7\x52\x98\xc9\x11\x62\x4f\x27\xad\xaf\x72\x68\xf6\xf7\x11\x2c\x3f\x9e\x4c\x88\x7b\x8c\xc0\xc5\x88\x4b\xfa\x24\xe0\xa2\x20\x1d\xf6\x34\x41\x38\x41\x51\x92\x90\x4c\xea\x1b\x93\x34\x20\x7b\x1a\x21\xbe\xae\x41\x7c\x21\x9c\x83\x64\xcf\x9e\x95\x3f\x6b\x33\x26\xa9\xfa\x1b\x57\x8f\x72\xef\xa2\x34\x14\x37\x06\x45\x0c\xaf\xa5\x35\x8d\x2b\xda\x34\x1a\x73\xd0\xa7\x58\x45\x38\xdf\xbc\x24\xe0\xf8\xac\x18\x90\x47\x28\x16\x93\xcd\xac\xa9\xe0\xf7\xa1\x92\x56\x88\x10\xc8\x26\x10\x73\xfc\x10\x33\xed\xe8\xa2\x64\x0a\x2e\x6a\x9b\xd2\xba\x54\x35\x17\x39\x89\x43\x8d\xcc\x32\xa7\xc9\xfe\x5a\x8e\x55\x2d\xd1\xa3\x8e\x6b\x72\xda\x06\x33\xc8\xf3\x56\xb4\xab\xb1\xaf\xde\x38\x2c\x21\x7d\xbc\x61\x55\x75\x2b\xbd\xb0\x4e\xb4\xca\x7c\x49\x19\xb5\xa1\xac\x5c\xdd\x74\x6c\x13\x08\x98\xa8\x89\x4e\x81\x8c\xc7\x72\xc2\x34\xd7\x3c\x01\x09\xa2\x36\x3a\x65\x4d\x6a\x90\xdc\x4d\x4d\x75\xfc\xdf\x42\x2d\xcd\x57\x48\x8e\x0a\xfc\x9e\x72\x59\x26\x0c\x3f\x6c\x09\xa1\x28\xa1\x42\x8a\xef\xd3\x0d\x53\x6b\x88\x35\xad\x2f\x3f\xa6\xe8\xee\xc1\x62\x61\x3c\x80\xba\xf6\x2a\xd5\x49\x05\x92\xaa\x10\x00\xa7\xb9\xea\x57\xac\x63\xe9\xcf\x88\xaf\xa3\x1c\xd2\x20\xe7\x28\xbf\x88\xc2\x42\x4d\x23\xb8\x19\xa6\x0b\xf4\xbd\x8d\xd4\xde\x77\x83\x28\x0c\xf9\x58\x57\x76\x00\xb1\xcf\xa7\x00\xac\x15\x56\x70\x03\x7a\x6c\x42\x6a\xce\x86\x7c\x6e\x7f\xb0\x47\xd4\xa6\xea\x1d\x27\x8b\xc3\x77\x6d\xf8\x12\x65\xef\x9a\x93\x66\x80\xde\x8a\x31\xbe\x63\xfa\x6b\x8b\x4b\xd1\xf7\x25\x9e\xf9\xf8\x11\x7d\x63\x43\xd1\x32\x0b\xae\x83\xde\x98\x39\xb4\x0d\x5b\x8a\xae\x10\x2c\xd2\x14\x15\x54\x3c\xf0\x3a\xc8\x7b\x95\x42\x00\x87\x0c\x36\xd3\x88\x25\xbd\x4b\x52\x48\x9d\x97\x13\x92\x88\xfd\x26\xf7\x33\xfa\xab\x05\x6f\xc9\x6d\x6a\x4a\xa3\xdc\x66\x4e\x92\x6d\x68\xe1\xf7\x98\xe0\x1c\x0c\x51\x79\x04\xa9\xf3\x20\xc6\x0c\x0b\x81\x7e\xdd\x65\x35\xcf\xa8\x8c\x1f\xcd\x17\x19\x37\x48\x81\xc7\x5d\x97\x5c\x2f\x48\x16\x91\xc4\x27\x3d\xef\x2d\x77\xb3\xfc\x4f\xe2\xb5\xf5\x0c\xdc\x15\x9c\xae\x39\xa7\xd6\xf3\x3a\x6c\x01\x2b\x99\x1d\xa6\x7e\x28\x76\x8c\x1a\x7e\x67\xdf\x39\xaf\x0c\xab\xf9\x4a\xa3\xef\xb1\x0d\xad\xb1\x3d\xdb\xa8\x7e\xb0\x76\x01\x27\x75\x23\x74\xca\xf7\xb5\xae\x05\x5e\x41\xdd\x68\x2d\xea\x46\x25\xc6\x37\x82\x49\x21\xe1\x03\xc4\xf6\x5e\x4f\x0b\x10\x25\x3c\x7d\xf8\x66\x6b\x7e\x2a\xe9\x71\x9a\x3a\x00\x9b\x27\xa7\x14\x92\xd4\x35\xef\xe7\x58\x7f\xe6\xd7\x31\xe4\xd5\xbf\x69\x7e\xe9\xe8\xd4\x70\x53\xaf\x00\xfc\x95\x1d\x4e\x86\xef\xb6\x09\x0a\xa6\x9b\xd5\x62\xad\x2e\x7e\x71\x7b\x8f\x3e\x9d\x8e\xcf\x25\x39\x48\xce\x40\xb5\x78\x6d\xd5\xb9\xed\x38\xc4\x75\x71\x31\x91\x8f\x86\xb4\x9c\xfc\x0e\x79\xdf\x74\x40\x56\xaf\xb0\x64\x64\x85\x30\x4a\x82\x9f\x5e\xfc\xf6\x8f\x34\x20\xad\xf2\x64\x48\xea\xd7\x21\x7a\x70\x70\x00\x57\x13\x32\x5f\x88\xa7\xc2\x4d\xae\x51\xda\xd5\xb2\x2d\x9d\xce\xd9\xed\x52\x7b\xeb\xe7\xb8\xdc\xbe\x61\x9d\x7d\x4f\x6e\xa6\xc8\xb3\x24\x44\xaf\xb3\xc7\xc6\x7d\x7f\x1f\xb1\x16\x73\x11\x4d\x66\x1f\x58\x5b\xc9\xa4\xba\x01\x5f\x54\xa1\xe2\x81\xd4\xa4\x9a\xee\x5e\x62\x54\x5b\x29\x95\x61\x82\x1b\xca\x27\x49\x9a\x80\x93\x16\xdd\x11\xa3\x80\x04\x6d\x7e\x7d\x86\x67\xad\xba\xdf\xf8\x4a\x21\x56\x4e\xe0\xfe\x3e\xfa\xcb\x2f\x71\x7a\xf5\x4b\x74\xfd\x1b\xd1\x26\x15\xb4\x32\xf4\x42\xa6\x58\x4f\xad\x4f\xe5\x33\x49\x27\x9d\xf1\xa5\x28\x29\x43\x29\x99\x53\x87\x64\xa5\x65\x68\xe5\x8d\x66\x55\x90\x1f\xca\x75\x34\x6f\x56\xa3\x8a\x28\x3f\xd9\xdb\xd3\x16\x5b\xa9\x9d\xd3\xd3\x92\xdb\x9b\xbe\xfa\xf8\x96\x66\xa3\xb4\x96\x9d\xba\x53\xa8\x0c\x2d\x72\x94\x3e\x7e\x44\x41\xea\x83\xaa\xa0\x47\x27\xf3\xa4\x54\x89\x5f\x22\x0c\x0c\x54\x3c\x7f\x9a\x2e\x41\xf5\xf8\x0c\xee\x07\x14\xaa\xd5\x2e\xd7\xfe\x97\x7c\x92\xe2\xbe\x52\x9d\x9e\xa2\x3e\xfa\xd1\x98\x0f\x25\xc4\x4c\xe5\x53\x8f\x93\xfa\x5d\x5c\x51\xda\x63\x1b\x7a\xc5\xe6\xd9\x52\x80\x1d\x8b\xc0\xb6\xbd\xff\x6b\x38\xf9\x51\x50\xb5\xd1\x3a\xb0\x96\x0e\x26\xfb\x00\x70\xae\x4d\xd9\x71\xb5\x36\xcd\x5b\x2a\xe4\xc6\x80\x45\x68\x5d\xb9\x12\xca\x3f\x62\xf1\xed\xb1\x84\x0c\xd6\xe6\xe0\xb8\xb2\xf2\x83\xcd\xb1\x4c\xeb\xee\xb7\xc6\x16\xcb\xb8\x7a\x58\xb9\x1c\xcb\xce\x38\x72\x29\x0c\x4b\x17\x69\xd7\x1a\x2d\xaf\xba\xa1\xbd\xec\x4e\x56\x5f\xdc\x95\xe4\x45\xd7\x99\x83\xa8\x47\x8f\xca\xed\xa9\xd5\xf7\x73\xec\xd9\x42\x8c\x5f\xea\x55\x19\xab\x4b\x89\x43\xdb\xb7\xeb\x3e\x7a\xc4\xb7\x7b\xf1\xdc\xd6\x94\xb7\xd9\xdb\x1a\xb3\x4e\x5b\xa7\xa7\xfc\xae\xc6\x7e\xa1\x53\x89\xe6\x44\x43\xe2\x1e\x3a\xab\x46\x2f\x95\x92\xc8\xe3\xd2\x37\x5d\x57\x80\xf6\xd1\x10\x75\x35\xaa\x3e\x7e\xa4\xd3\x20\x1a\xbb\x55\x43\xb2\xbf\x8f\xbe\x39\x05\x8e\x36\x02\xdb\xc9\xef\x77\xbc\xb2\x68\x22\x8a\x7b\x9b\x81\x89\x2e\xd2\x85\x57\xba\x93\xdc\xa4\x4b\x79\xc3\xf0\x2f\x70\x72\x4e\x0c\x32\xcf\x9c\xf8\xce\x78\x5c\x3e\xb0\x3b\xe3\x38\x4f\x11\x8b\x51\x42\x17\xa7\x08\x44\x77\x56\x66\x16\xe5\xc6\x27\x6c\x43\xa5\xdb\x10\xdc\x4f\x5e\x24\xf1\x0d\x04\x0b\xa4\x47\x2e\x3f\xbd\x8b\xab\x54\xd4\x8e\x58\x24\xb0\x57\xa4\x70\x37\x52\xa4\x28\x59\xc6\xb1\x4c\xae\x5d\xd5\x87\x65\xc2\x3a\x1c\x88\xab\x8c\x71\x8d\xb1\xe6\x90\xef\xca\x0e\x06\x72\x6f\x77\x40\xf4\x8c\x5e\xb3\x4a\x6a\x23\x15\xac\x4f\xd7\x8c\xed\xef\x83\xbb\x21\xd7\x66\x38\x1c\x05\xf9\x8e\xa9\xeb\x35\xe8\x52\x03\x84\xc4\xbd\x21\x5a\x72\x7b\xf5\x66\x58\xa5\x88\x32\x77\x42\xf7\xea\xb1\x35\xfc\xe8\x07\x34\x80\xcd\x46\xea\xe7\x07\x6f\x81\x97\xa5\xe8\x4f\x4f\x43\xfd\xe3\x54\x8d\xb7\x5b\x61\xa6\xf1\x77\x49\x33\x5b\x75\x6a\x2a\x13\x6c\xd5\x49\xa9\xb4\x6d\x55\x3a\x86\xb6\xbd\x01\xb0\xca\x9a\x26\x51\x33\x60\x57\x9e\x9d\xd5\xed\xd4\x1c\x9e\xa5\xe9\x64\x69\xee\x2b\xa6\x90\x7d\xb4\xee\x06\x20\x74\x8b\x73\xcb\x38\x41\xd8\x29\x33\x6a\x2e\x61\x8e\x6a\x44\xcc\xf2\xf1\x35\xda\x40\x6a\x1c\x59\x62\xe3\x4a\x51\x76\x54\x29\xcb\x6a\x01\x16\x05\xa8\x1d\x62\x11\x19\x61\x16\x25\x94\x19\x68\x11\x21\xcd\x3f\x5a\x03\x93\x65\x0d\xa5\x80\xd1\x0a\x29\xc0\x61\x11\xe0\xf5\xac\x2f\x7a\x25\x7e\x15\xd5\x80\x79\x89\x03\x88\x1b\x62\x4c\x38\xf0\x43\x29\x81\x92\xa0\x0c\x49\xec\x86\xaf\xa3\xc2\x84\xba\x8e\x8a\x32\x48\xa9\x55\x56\x56\x06\xb4\xdb\x84\x22\x03\x6c\x61\x4c\x26\xfd\xa9\x7f\x56\x8e\x3b\x1a\x90\x2a\xd4\x41\xb3\x34\xd6\xd9\x94\xfe\xd4\x3f\x3b\x54\xf5\x1c\xd2\xfa\x52\xaa\x64\x87\x24\xd0\xab\xe9\xdf\xdc\x15\x85\x01\xdc\x59\x53\x7c\x34\x46\x64\xbd\xa0\x9a\x1c\x29\x3d\xfc\xcb\x8f\xa2\xe4\x2a\x75\xbc\x93\x92\x25\xe2\x00\x41\x55\x71\x39\xe5\xa2\xa0\x3f\xca\xfc\x4e\x4b\x2d\x6e\xa6\x45\x9c\xc3\xb4\x3f\x21\x3b\xbb\xfc\x45\x04\xd4\x75\x54\xa8\xbf\x14\x0c\xb0\x0a\xfc\xbd\x60\x14\xa9\x69\xa7\xbf\xe8\xfc\xd2\x7f\x0b\xfb\x1c\xe4\x45\xfa\xcc\x98\x85\x62\xd0\x65\x9e\x3a\x84\xd6\x09\x60\x49\xff\xe3\xd1\x4b\xec\x74\xeb\x35\xa1\x2c\xf3\x8b\xf4\x6a\x0a\xdc\xde\x41\x4f\xb1\xff\x3e\xc8\xd2\xc5\xf3\x84\x7b\xc5\xb1\xd8\x59\x76\x64\x4b\x68\xa8\x19\x3d\x88\x47\x3e\x29\x13\x84\x0c\x41\x1b\x71\x1f\x7f\xd6\x60\xc7\xf8\xe2\x45\x89\xc7\x29\x34\xca\x95\x43\xbe\xa5\x7e\x73\x82\x81\xa3\xab\x7b\x1b\x32\x5c\xae\x9d\xfb\x8f\x72\x2f\x2e\x6f\x3c\x86\x27\xad\x73\xc7\xd1\xfd\x46\x5d\x5b\x8d\xf0\xdf\xb3\x77\x06\xb7\x0f\x50\xdd\xea\x46\xe0\xfe\x92\x2e\x8b\xa9\x63\xa1\xdb\x4d\xa6\xc5\x4b\x12\xea\xe7\x39\x2b\x69\x25\x69\x40\xda\xd6\xec\x70\x85\xdd\xd0\xd6\xac\x26\x32\x3c\x80\xf8\xef\x56\xfb\x75\xab\x37\xd9\x98\x63\x90\x88\x6c\xe3\x62\x9a\x6a\x4e\xb6\xe8\xb5\x43\xb4\x92\xbc\x07\x41\x06\x3a\x16\x9c\xf6\x18\x49\xfe\x69\x76\xa8\xa3\x6d\xf6\x6d\xb3\x7a\x7d\x9f\x5c\xf1\x91\x64\x9f\xd0\x07\x54\xe0\xec\x9c\x14\x53\xe4\x31\x63\x9e\xd7\x01\xff\xd6\x9c\xa7\x11\xb0\xf5\xb4\xb7\x56\xdb\x5a\x7c\x59\xf1\x5f\x7b\xcf\xfe\xab\xad\x89\x76\x6f\xe1\x07\xdf\x4f\xb8\xb2\xf3\x64\xef\xb6\x65\x77\xc2\x70\xea\x11\xde\x27\x8e\xd8\x89\xa5\xa7\xb1\xda\x3e\x5f\x7a\xdd\xc9\xfd\x80\xa4\x7c\xcc\x2e\x86\x50\xa8\xcb\xb3\xcc\xa1\x72\x8f\xb3\x4e\xc9\x2c\xb0\x39\x16\xcb\xe7\x4b\x45\x8f\xd0\xe6\xff\xa8\xe3\x7a\x5b\x34\x38\xd8\xbb\x3d\xb9\x73\xb8\x46\x3e\x8e\x10\xa8\x51\x79\x2f\xed\x22\x44\xe3\xe0\x7e\xa5\x5b\x7f\x88\xab\xf8\x10\x57\xf1\x21\xae\x62\xb3\xb8\x8a\x62\x93\x01\x35\x23\x86\x5b\x83\xf8\x73\xa7\x51\x17\x0d\x97\xe4\xca\x60\x76\x43\x37\x7c\x5d\x33\x06\xa0\x11\xc2\xef\x35\xa4\x8c\xa8\x60\xd6\x61\x19\x74\x55\xb0\x3f\x00\xba\x6f\xa1\xee\x3e\x71\xea\xfe\x8a\x80\x77\xc6\x24\x40\x64\x2a\xd0\x75\x32\x66\x13\xc9\x54\x48\x5e\xe4\xbd\x87\xa0\x78\x9f\x34\x28\x1e\x2c\xec\x16\x1c\x98\x46\x24\x33\x2f\x87\x0f\x1e\x7a\xcc\x55\xde\x8f\x41\xd5\x8d\x1e\xa3\xdf\x70\x71\xd1\x5b\xa4\x57\xac\x52\x07\x0d\xc1\xc5\xa6\xed\xc9\x28\x5b\x6b\x13\xae\x6b\x01\x76\xee\x07\xdf\xd4\x0b\xbe\x89\x0f\xfc\x3a\x1e\xf0\x5b\xc8\x18\x65\xbf\xb8\x12\xd7\xd5\xc6\xb9\x61\x9e\xa0\x3c\x4a\xce\x63\xc2\xe4\x76\xa9\x67\x2f\xbd\x08\xdb\x34\x00\x46\x65\xfc\xa2\xf5\xea\xdf\x25\x33\xc3\x5d\xb2\x32\x6c\x37\x30\x7e\x75\x3c\x0c\xed\x21\x60\x7e\xc1\x43\x0d\x48\x43\xd0\x09\x2a\xb2\xe8\xfc\x9c\x64\xcc\x6e\x0c\xec\x2a\xde\x0c\xa9\x67\x47\x7a\xde\x9e\xcd\x1e\x0a\xda\xcc\xf4\x35\x87\x16\xa8\x18\x8b\xaf\xf5\x5d\x72\xc5\x70\x7c\xa5\x4f\x8e\x1d\xa3\xf1\xb5\x3e\xf2\x77\x0f\xc5\xc3\x32\x79\x78\x98\x8f\xfe\x99\x13\x16\x37\x50\xf7\x74\x58\xe0\x3c\x47\x18\x65\x24\x94\xef\xe8\x85\x03\x04\x64\x4d\x74\xc4\xde\x92\x2a\xe1\xc6\xcf\xea\xed\x69\xc8\x59\x06\xd8\x35\x23\x46\x3d\x3c\xe8\xfd\x5a\x1e\xf4\xda\xfc\x02\x89\x23\xd7\xe6\x97\x40\xdc\x59\x42\xdd\x63\x8f\x59\xf0\x51\x94\xa0\x79\x14\xc7\x11\x4b\x03\x2c\x18\xe3\x7f\xa7\x4b\x88\xaa\x99\x43\x1c\xaa\x1b\x84\x85\x34\xce\xed\x25\x80\x0a\xc7\xb1\x86\x2a\xef\x50\xee\xa2\x6c\x73\x19\x05\x4b\x78\x70\x7c\x15\x15\x17\x08\x83\xd6\x80\xf8\x85\x1e\xf5\x60\x07\x2f\x95\x85\x21\xe7\xab\x78\x9e\x0c\xf3\xcb\x66\x17\x12\x2a\x68\xc3\x14\xf1\x58\x69\xb3\x1b\x98\xeb\xdf\x4b\xde\x5b\x7b\x2a\xa4\x1a\x5d\xe1\x6f\xdc\xeb\x54\x2d\xed\xf3\xa8\xb8\x58\xce\x7a\x7e\x3a\x67\x4b\xfa\xbf\x79\xc5\xd2\x6e\x23\x50\x21\x25\x74\x0a\x69\x2b\xfb\x70\x8b\xe4\x09\x1f\x36\x7d\x42\x4d\xab\xaf\x7c\x3f\x4d\x81\x76\xf6\x78\x5a\xa4\x9a\x40\x5f\xfa\xcb\x69\xda\xd1\x75\x9e\x4d\xc3\xc0\x6c\xfa\x66\x9a\xf2\xf3\x6b\xbe\x99\x54\xbe\x38\x29\xbf\x0e\x31\x8d\xad\x90\xca\x98\xbd\x15\x4e\x17\xd8\x8f\x0a\x3a\xcc\x5e\xdf\x3b\x29\x7f\x57\x1e\x7e\x4a\x49\xdc\xea\xf7\x0e\x27\x6d\xc3\x27\x77\x83\x87\x26\x40\x52\xc5\xeb\x63\xad\x1b\xcc\xd5\xa6\xaa\x27\xd2\x17\xec\x2f\xe2\x5d\xc1\x3b\xb7\xdb\x57\x21\x14\xc1\x0a\xb8\x07\x65\x06\x90\x1c\x58\x03\x8c\x95\x1a\x5e\x66\x81\xd2\x67\x99\xce\xc9\x12\x05\xb8\x1f\xd3\xcd\x47\x1f\x07\xad\x1a\xcf\xd3\xae\xce\x01\x78\x24\xbc\x2c\x52\xe6\x7f\x2b\x14\x66\xd0\x5f\xc3\x33\x57\x73\xfa\x75\xb1\x84\x68\xc2\xf1\xbe\x8b\x8b\x01\x06\x89\x56\x36\x07\x9b\x48\xd1\xf5\x32\x2e\xf6\xa5\xbe\x5e\x0f\x36\x7c\xab\xb6\xaa\xb0\xbf\xcf\x62\x4b\xf2\x03\x9e\x45\x00\xba\xc2\x59\x42\x4f\x57\x58\x93\x3e\xe6\x29\x9d\x75\x77\x55\x9b\x3b\x85\x39\xe1\x4d\x79\x48\x99\xb9\xa7\xe5\x71\x2e\xf7\x3a\x0e\x72\xa7\xf2\x2f\xd1\x50\xbb\xe3\x98\x1d\x81\x4a\x2e\x88\x15\xc8\xd0\x77\xa8\xdf\x3b\x38\x38\x90\x48\xc5\x9b\xc2\x8e\xa7\x96\x8e\x7b\x21\x0e\x1a\x2f\xc4\xc1\xca\x55\x18\x25\xe7\x2b\x16\x62\x94\x9c\x37\x59\x8b\xcc\x31\xae\xe1\x3a\x1c\xae\xb5\x10\x87\x0d\x57\xe2\xf0\x61\x29\xde\x61\x29\x5e\x47\x76\xe5\xaf\x6c\x25\x2a\xfe\x0a\x48\x8c\x6f\x2c\x80\xd1\x68\xb4\xc1\x52\xdd\xe2\x99\x79\x1d\x15\x35\x2b\xf5\x3a\x2a\x6a\x57\x29\x0e\x82\x9f\x93\x40\xcb\xa9\x66\xae\xd4\x0e\x4a\xc8\xb5\xe5\xf2\xae\xd6\x98\xf5\xbc\xd9\x26\xae\x7e\x21\x59\x4b\xd5\x58\x03\xfa\xa3\x91\x12\xd3\xd9\x15\xad\xd3\xd6\xe2\xb5\x9c\x14\x1c\x6b\x8b\x76\xa5\x23\xaa\xeb\x8f\x4e\x77\xfc\x72\x93\xc9\xd4\x6f\xee\xe8\xb9\xbe\xe2\x01\x24\x18\x7c\xb4\x07\x87\xf0\xbb\xd6\x05\xdc\xe9\x01\x6e\xfb\x50\x37\x74\xa1\xae\xf6\xa0\xd6\x1d\xa3\x1d\x7e\xd1\x5c\xa9\xa3\x40\x78\x81\x0e\x03\xab\x83\xa7\xec\xe7\x50\x50\xd4\xcc\xe3\x78\x85\xc3\xb1\x62\x26\x83\x8f\x9c\x47\x4f\x85\xf8\xb7\x91\xe7\x31\x38\x1e\xc3\x24\xd9\x1e\xc4\x75\x0e\xc0\xdc\xe7\x97\x0f\x12\xfd\x13\x46\xa2\xda\x7b\x97\xf5\x06\xfe\xa4\x64\x1b\xbe\xbb\x32\xef\x91\xa0\xdd\xe1\xb6\x78\xdb\x91\x8c\xd3\xd3\x87\x5e\x4d\x8a\x11\x83\xe5\x97\x34\x43\x39\xc9\xe8\x0d\x18\xa2\x8b\x33\x56\x16\x81\x5d\xf9\x1e\xf1\x8d\xb6\x6c\xa3\x84\x2e\x76\x36\x10\xfa\xee\x50\xb3\x63\xda\xef\x8f\x9a\xfa\x1e\x9b\x6e\x21\xcd\x7d\x90\xf5\x35\x24\x15\x67\x2b\x3c\x5d\x1b\x39\xff\x1a\xb6\xa4\xf2\xf5\xa5\xbc\x90\x4c\x30\x6b\x25\x99\x3b\x39\x07\x35\x0b\xcb\x1b\xc6\x14\x95\x37\x0a\xae\x25\x85\x7f\x64\xb1\xf0\xb1\xee\x18\x9e\xb7\x19\x09\xa7\x62\x09\x2b\x50\xcd\x13\xd4\xf2\x02\xad\xf4\xf7\xa4\x5b\xe4\x4a\x67\x4f\xb8\x30\xbb\x3c\x3d\x2d\xdf\x6c\xa9\x9b\x52\x6e\x94\x0e\xe5\xe6\x87\xdb\x15\x8e\x93\xcc\xb1\x47\x31\x02\xbf\x81\x9f\x94\x5c\x1a\x87\x9f\x33\xeb\xb4\xe8\x80\xe6\x1f\x74\x0a\x23\x61\xb9\x2c\xa2\x53\xc4\x9d\x25\x71\x9e\x47\xe7\xb0\xec\xd4\x59\xcf\x7c\x7d\xdb\xe8\x83\x52\xb9\x44\xe8\x14\x0d\x4e\x50\x84\xbe\x2f\xa9\x5d\x4e\x50\x04\x8a\x14\xb6\x83\xb0\xa0\xb8\xba\x0a\x25\x7a\x7b\xa2\xf0\xbc\x27\x37\x54\x1a\x64\x60\xb4\x12\xdd\x02\x38\x29\x0b\xa1\xe8\xe8\x5d\xe0\xfc\xc5\x55\x22\x3c\x38\x99\x73\x29\xab\xd2\xa1\x18\xda\x6d\xe9\x90\xfc\x86\x6b\x6c\xd8\x57\xf8\x75\x82\x6e\xe1\xff\x89\xac\x78\x00\x77\x82\x6e\xa5\xb3\x9d\x50\x05\x57\xba\x91\x88\x10\x84\x3a\xa0\xe9\xa0\xf5\xef\x28\x0e\x7c\x9c\x05\x2d\x85\x4d\xba\x81\xe1\x20\x00\xb6\xaa\xf4\x4d\x1b\x95\x40\xeb\x1c\xc6\x04\x8c\xe6\x2f\x37\x4f\x2f\x49\x7d\x13\x13\x17\x74\xbd\x8f\x9d\x04\xdb\x6d\xd2\xe4\x95\xbe\x7b\x87\x07\x0e\xd8\x3a\xfc\x0e\xa7\xbd\xdf\x57\x4c\xf1\xf0\xf0\xf8\x93\xb8\xdf\x55\x35\x20\xd9\x87\xb7\x40\x17\x81\x13\xbd\xd9\xfc\x89\x14\x7f\x61\xad\x25\xe4\xea\xc5\xec\xbf\x74\xdb\xbb\x3d\x91\x28\xbe\x39\x85\xb7\xbd\xc6\xe2\xe5\x8b\x4e\x6b\xac\xd1\x8a\x4b\x67\xff\x15\xcb\x8d\x35\x25\x16\x5b\xca\xff\x64\x2b\x8d\x7d\xd3\xf6\x4c\xa0\x94\x53\xcd\x3e\x02\xa0\x3e\x1c\xa6\xd6\xb7\x25\xf2\x93\x75\x90\x26\x69\x0b\x5a\xbf\x91\x9f\x91\xf8\x23\x0d\x0d\x40\xd8\x0e\x2e\xb2\xf4\x8a\x36\x87\xe8\xc4\xff\x9c\x65\x69\xd6\xfa\xf6\x19\x4e\xe0\xd9\x36\x8e\x63\x84\xd9\x79\x8d\x70\x8e\xb0\xdc\xeb\xbe\x6d\x97\x48\xab\x94\xf9\x5b\x39\x89\xc3\x0e\x20\x93\xa4\xd1\x22\xb3\x75\xf9\xc4\x80\x93\x00\xf7\xde\x0b\x9c\x27\x5e\x81\x66\x84\xd0\xbb\x70\x54\x44\x38\x8e\x72\x12\xa0\x2e\xca\x97\x0b\x10\xee\x75\x08\x96\x2b\x86\x91\x26\x5e\x55\xd3\x1e\x3c\x7a\x24\xaf\xfc\xf0\x9b\xde\xa4\xbe\x65\x12\xe6\xb7\x74\x03\x2f\x7d\x53\xbd\x44\x3f\xb2\xe2\x29\xa2\x14\x97\x78\x93\x29\xfe\x5b\xf9\x72\x06\x3b\x40\x87\x91\xc5\x76\x03\xde\x55\x8e\x5c\x7d\x60\xaf\xef\x65\x13\x94\x3a\xeb\xa3\xe0\x43\xe7\xd4\xbc\xa2\xb0\xf4\x3c\xcc\x48\x9e\x53\x32\xe6\xcb\xbc\x40\x24\x02\xe9\x79\x46\xe4\x03\x75\x35\x57\x1d\x78\x82\xff\x2d\x7a\x8c\x4a\xb4\xc0\x50\x09\xea\x15\x57\xab\x53\x8e\xdf\xf6\x35\x02\x0d\x72\x55\x95\x0e\xfa\x00\x61\xbf\xf8\xcc\x4f\x61\xa9\xc1\x85\x4c\x0d\x0e\x49\x96\x73\x92\x61\x78\x72\x16\xe2\x38\x27\x1d\x74\x95\x45\x05\x96\x6f\xd0\x20\xc4\x42\x18\x9d\x2f\x33\xac\xbd\x4b\x43\xb7\x6d\xb6\x4c\xf5\xc1\xe5\xf4\xe5\xa6\x23\xfe\x8f\xee\xf2\x8a\x09\x52\xb4\x69\x06\x84\x53\x0d\x44\xba\x02\x6b\x47\x93\x9c\x7e\x51\xc6\x6f\xf8\xfc\xfd\x91\xe1\xe3\x29\x1e\x02\x3f\x7a\x24\x9f\x27\xe5\x8b\x38\x2a\x20\x83\x6c\x2f\x4c\xb3\x9f\xb1\x7f\xa1\x45\x60\xf2\xad\xc4\xb4\x20\x44\xc9\xb3\x4e\xc9\x50\xbc\x45\x76\x6d\x6e\x9f\x88\x44\x8c\xe6\x01\xa7\x5d\x84\x65\xf1\xae\x69\xd5\x0f\xcd\x5a\x72\x81\x5e\x43\xa0\xe0\x02\x16\xdc\x95\xde\x39\x6e\x18\x3d\x09\x4d\x85\xe7\xdd\x79\x17\x48\x17\xce\x04\xcf\x09\x04\xb0\x98\x11\x19\x1d\x06\x02\x29\x44\x05\xd3\xd0\xcd\x08\xca\x97\x61\x18\x5d\x73\xf7\x6a\x82\xfd\x0b\x94\x17\xf8\x9c\x4c\x11\xe9\x9d\xeb\x96\xe3\x33\x45\xd5\xe9\xb7\x21\x0e\xc8\xb7\x67\x9c\xba\x1c\x9d\xd1\xdf\x5d\x20\xe6\xac\xa3\xff\xea\x62\xbf\x88\x2e\xc9\x59\x87\xe3\x60\x5f\xae\xa3\x42\x81\x5d\x47\x85\x84\xe2\x65\x4c\x8c\x3f\xeb\x00\xa9\x7a\x91\x00\xe4\xfd\xa4\xd3\xa9\x19\xbe\xf5\x71\x83\x6c\x4c\x71\x0e\xe9\x1d\x72\x9e\xd3\x29\xa0\xb0\x64\x41\x2f\xa2\x49\x11\xdf\x40\xe6\xdc\xa9\xde\xc3\xb3\xb3\xff\xf2\xcc\x85\x5a\x5f\x3f\x7c\x60\x45\xf2\x72\xe1\xcd\x6f\xba\xe2\xbe\x6e\x7c\x7a\x02\xc4\x71\x00\xf8\xdb\x86\xe3\xe6\x6b\x0a\xc0\xe2\x1a\x19\x1f\x1c\xf5\x2d\x28\xb8\xf9\x41\x6d\xb8\xfe\x6b\xc5\xae\xba\x1a\xcc\xed\xad\xec\xa2\xd6\xe1\xff\x01\x1b\xe5\x07\x96\x77\x01\x7d\x44\x66\x4f\x7f\x9c\x22\x91\x91\xa1\xdc\xcb\xd2\x47\xa0\xd4\x5d\x5a\x55\xe3\x3a\x2a\x9c\x85\x6e\x78\xde\x05\x99\xf1\x8d\x5f\xbe\x95\xbc\xa7\xf9\xc7\xbc\xba\xc0\x0b\x62\xbb\x35\x9f\x7d\xaf\x96\xe4\x0f\x67\xca\xd9\x88\x65\x09\x89\xe6\x73\x12\x44\xb8\x20\xf1\x0d\xc2\x61\x41\x98\xc3\x86\xc7\x26\x80\x2e\x30\xa1\xa3\xe1\xa2\x44\xc4\x39\x85\x2f\xd0\x5e\x69\x58\x7f\x11\x77\x34\xba\x75\x4c\xd1\xdf\x8b\x79\xfc\xb3\x88\xc2\x13\xe5\x4f\x00\x19\x5c\xf8\x67\x69\xca\x22\x5c\x98\x2e\xb6\xaa\x5f\x65\x77\xa6\xbb\x74\x86\xb3\x07\xed\x13\x43\xe6\x19\x6b\x4b\xf5\x6f\x57\x5d\x83\x2f\xbb\xea\x5d\xa9\x5b\x9e\x3c\x15\x70\x46\xd0\x77\xdf\xb1\xed\x3d\xf8\xee\x3b\x14\x66\xe9\x5c\x26\xed\x05\xe5\xfb\x96\x3b\x4a\x82\xdd\xf4\x93\xae\xeb\xbb\x73\xa1\x41\x2e\x6c\x2c\x3b\xa2\x55\x32\xd6\x66\x2c\xb5\xe7\x70\x24\xdd\xed\xa8\x12\x31\xa8\xdb\x64\x18\x7b\xb8\xcb\xcc\xc1\x5e\xa1\x72\x07\xa3\x27\xe8\x4c\x75\xe2\x4c\x3b\xf7\x99\xef\xd0\xb3\x57\xaf\x74\x0f\x30\x38\x28\xa5\xfc\x90\x2b\x4f\xa3\x28\xc9\x17\x2c\x3d\x19\x73\x4a\x22\xd7\x3e\x89\x63\x8a\xe7\x4d\x72\xde\x65\x35\x08\xf3\x38\x9a\xee\xef\x5f\x5d\x5d\xf5\x92\x73\x5e\x0a\xae\x84\x6d\x14\x47\xb3\x0c\x67\xe0\x56\x44\xb1\x9a\x2e\x89\x4a\x02\xc0\x68\x81\xa3\x0c\xd1\x2b\x08\x30\x66\x02\xa7\x70\xb0\xcc\x64\xc4\x2b\x79\xa8\x9f\x71\x39\x61\x0f\x72\x38\x06\xe8\x0c\xe4\x01\x26\x75\xe4\x32\xa2\x95\x72\x7b\x04\xe1\x28\x8c\xb2\xbc\x28\x6d\x4d\x2c\x28\x14\xc4\xd9\xa2\xd8\x98\x2b\x1d\xfa\x96\x31\xdc\xb7\x02\x5c\xcb\xbb\x09\x5f\xc0\xbd\x8d\x0a\x53\xf4\x46\xa8\x3d\x96\x80\x0e\xfe\x5b\x64\x8b\x3a\x8b\x12\x16\x92\x8b\xc5\x20\x3e\x3f\x8f\x99\x18\xc6\x5e\x65\x00\x88\x7a\xba\x06\xc2\xd4\x39\x29\xf6\x78\xba\xe6\x33\x72\x8d\xe7\x8b\x58\xc8\x44\x30\x5f\xfc\x0a\xca\x53\x9b\x9a\x10\x42\xb0\x51\x80\x30\x3a\x41\xc0\xf2\x86\xd2\x0a\x09\xb9\x2e\x50\x11\xf9\xef\x55\xf2\x64\x4c\xef\x1a\x97\x24\x01\xa1\x51\x3a\xe8\x01\x76\xcd\x57\x14\x3a\x21\xe7\x8f\xc9\x38\xdf\xa1\x68\xbe\x48\x33\xeb\xcd\x1d\xe3\x70\xaf\xc2\x7f\xd4\x00\xf5\x4e\x38\x42\xb8\x30\xa1\x5f\x70\x00\xb6\x83\x0f\x52\xcf\xdb\x41\xbd\x1e\xd3\xec\xa3\xdb\x36\x3a\xfd\x01\xb5\x28\x34\xfa\xde\x7c\xe4\x47\x8b\x10\xfa\x20\x40\x6f\x79\x01\xd7\xdb\x9e\x7e\x98\xf4\xfb\xa2\xac\x24\x7e\x42\xf9\x0f\xec\xeb\x07\xd1\x2c\x83\xfe\xde\x24\x16\x80\xda\x92\x62\x98\x07\x4a\xf1\xf3\xe4\x49\x12\xbc\x58\x16\x48\x68\x46\xc1\xd9\x4d\xa9\x9a\xa9\x40\xf4\x1d\x0b\x8c\x27\x2e\x85\xad\x5e\xaf\x07\x8e\x55\xe2\x1b\xe2\xd7\x78\x51\x7e\x22\x8a\x59\xdc\xd8\x02\x17\xe4\x14\x89\xe8\x25\x70\x63\x44\xb7\x9c\x10\xc4\x8c\x92\xcf\x29\x03\x5c\xe2\xb8\xd5\x82\x71\x92\x78\x05\x0a\x52\xbc\xa2\x58\x64\x08\x94\x6f\x14\xe6\x1e\x3c\x0d\xba\x6d\x8b\x2a\xb7\x1d\x34\xe9\xf7\xfb\xfc\x37\x1f\x39\xdd\x88\xf8\x9d\x6e\x2e\x69\xa9\x96\xbe\x87\x09\x8c\x92\xd3\x0f\x16\xf2\xdb\x1f\x14\x10\x42\xdf\x07\xd1\xe5\x0f\x7f\x27\x71\x9c\xa2\xab\x34\x8b\x83\xef\xf7\x69\x81\x86\x66\x9f\xe2\x91\x05\x3a\x1d\xb7\x7b\x42\xfc\x64\xfb\x1b\x5f\x06\x7e\x9a\x66\x19\xc9\x17\x29\xf3\x7a\xa6\xec\x2f\x9c\x65\xcf\x80\xa8\x1f\xb4\xcd\x6f\xaa\x98\xd8\x67\x2b\xa4\xa7\xae\x1a\xa2\x7b\xdc\x52\x34\x45\xfd\x5e\x7f\x70\x22\x9a\xb6\x80\x7b\xa5\x2b\x4a\xa9\xfa\x80\xcf\xa4\x5a\x07\x53\xf1\x91\x0e\xf2\x3c\x47\x04\xe7\xa4\x0b\xf9\x2f\x4a\x6d\x5c\x47\x45\x05\xc2\x32\x60\xcf\xbe\x07\x55\xf7\xc4\x4d\xcd\xc8\x49\x0d\x1f\xec\x7d\x76\x4f\xb5\x5f\x4e\xaf\xf2\x0a\x55\x8a\x21\xa3\xe6\x4a\x87\x50\x03\xda\xf4\x0c\xad\x72\x05\xb5\x15\x82\x0c\xa0\xf4\x22\x1b\xfd\x69\xbc\x40\x6b\xd4\x88\xbc\xf3\xd6\x18\x1a\x9e\x9c\xd6\xb7\x86\x5e\x9d\xca\x5a\x6f\xbb\x6d\x60\x21\xa5\xba\x7c\xad\xce\x49\xf1\x4c\x5d\x9a\xf5\x04\x27\xb2\xb4\x25\x11\xa0\x1f\x95\x50\x3d\x15\xf2\x76\xbb\x14\x35\x8e\xd6\x92\x6e\x57\x06\x2a\x75\x43\x3b\x31\x63\x82\x6b\x3a\x17\x22\x14\x3c\x4c\x22\x93\xde\x2a\x2e\x55\x15\xc5\xb4\x53\x2f\x52\xc3\xbf\x61\xf3\x81\x1d\xde\x7d\x64\xd9\xce\xf0\xac\x7e\x7c\x87\x3d\x0b\xac\x34\xcc\x61\x9c\x5e\x3d\x49\x82\x27\xe6\x60\x5a\xb5\x3e\x81\x4b\xa0\x1e\x50\xaf\xc1\xb8\x56\x73\xc9\x8a\x21\x5c\xd5\x13\x12\xac\xe8\x08\x09\x56\xf5\xa3\xa9\x5b\xa3\x31\x53\xa3\x0a\x8e\xe0\x4c\xbf\xc6\x9a\x1a\xad\xb7\xa8\xf8\x10\x59\xe1\xed\xdd\xeb\x4f\x0c\xe1\x1d\x16\xe0\xdd\x5c\xd2\xf4\x50\x89\x6b\x0e\xf0\xb8\xf9\x00\x37\x5a\x5a\xe3\x4f\xb0\xb4\x58\x5f\xeb\xc7\xab\xc1\xc2\x12\x41\x23\xab\x46\xac\xc1\x96\x5b\x4b\x63\xed\x9a\x81\xef\xb5\x14\xda\x47\x8e\xe6\x7a\x70\xb3\xb0\x26\xd6\x2f\x9f\x4d\xdc\x61\x4d\x7e\x30\x9d\x98\xf4\xc5\x22\x4c\x62\x0a\xc7\x37\xa7\xa7\xc8\x63\x4a\x45\x0f\xfd\xa8\x7d\x79\x43\x61\xdf\xa2\xa9\x0e\xfc\x18\x79\x5d\x8f\x1b\x9c\x0c\x77\xe1\x32\xbf\xac\xdb\x12\xc5\xcd\x94\x9c\x9e\xd1\x28\xb4\xc9\xb5\x25\xa5\xd8\xbd\xa5\x40\x71\xf4\xcf\x12\x83\x4d\x4b\xe4\xdd\x96\xdc\x1b\x6b\xe4\x13\xa7\x43\xa3\xf9\x0a\x51\xd9\x8d\x0d\x16\xaa\xb0\xd6\x48\xde\xd2\x27\x57\x04\x94\x32\xf8\xc0\xb1\x58\xa1\x8e\xe6\x42\xa4\x2f\xd1\x0a\xc1\x42\x41\x3b\x96\xb5\x59\xc7\xbd\xa0\x55\x23\x8f\x1e\x55\x99\x9d\xf8\x4a\x76\xb5\xe2\xac\x54\xde\x04\x20\x96\x71\xed\xd0\x5a\xdb\x89\x39\xbc\xee\xbd\x46\xd1\xc6\xc7\x19\x9c\xb2\x99\xaa\x00\x2e\x55\x29\xfd\xc7\x27\xf0\xda\x76\x81\xa3\x84\x7b\x8d\xed\xef\xb3\x2c\xca\x08\x12\x0f\xf9\x24\xcf\x71\x76\x63\xa8\x4d\x34\xdf\x6c\x16\x33\x8e\x07\x37\x17\xa9\x91\x94\xce\x87\x79\xf7\xed\x7f\x87\x48\x1e\x47\x49\xd1\x0d\xa2\x1c\xcf\x62\x82\x92\xb4\xbb\x4c\x96\x39\x09\xba\xca\xec\x9b\x33\x7d\x98\xf0\x7c\x16\x81\xe2\x4f\x2c\x14\x24\x59\x8d\xa1\xe6\x70\x5a\x3d\xd4\xf4\x7a\x6c\x8e\xaf\xe1\x75\x2b\xcc\x7c\x25\x13\x9f\xda\x8f\xc4\x96\x19\x90\x98\x14\xcc\x0b\xde\xda\xa3\x50\x53\x2f\x45\x97\xdd\xb0\x63\xb6\xcb\xbd\x46\xc5\x46\x69\x7a\x18\x5a\x5e\xba\x7a\x58\x06\x43\xf0\xb2\x00\x94\xeb\x61\xd9\x7f\xd7\x70\x39\x34\x1d\x77\xf5\xc7\xfd\xc6\x89\x6d\x02\xe8\xcd\xc3\x4f\xb6\x25\xb5\xb5\xe9\xe1\x83\x63\xcc\xd2\x4a\x3f\xc0\xd2\x9c\x4a\x5b\x6c\xd3\x9c\x01\xaa\xce\x14\x7d\xb8\xd5\x42\x9b\x29\x97\x16\x8b\x24\xe6\xce\xd7\xe3\x70\xe8\x54\xf8\xf5\xbd\xf1\x78\x15\xef\xed\x6e\xe2\x25\x8e\xee\x57\xbc\xc4\xf2\x40\x89\x45\x28\x3c\xb1\x2e\x70\x5e\xef\xa9\xa6\xa2\x29\x0a\xd0\x3a\x5f\x2f\x01\xf3\x69\xbd\xb7\xe4\xce\xa2\x52\x68\x98\xdb\xac\x96\xfc\x95\x2d\xf9\x5f\xa3\xbc\x68\xa3\x52\x51\x0f\x07\x41\x4b\xdb\x98\xe4\xeb\x9b\x6f\xc0\xed\x40\x8e\x40\x29\xf7\x47\xdb\x42\xc6\x4f\xb3\x72\xd9\x63\xe4\x41\xf0\x2d\xed\x42\x70\xdb\x8c\x5d\x6d\x56\x1b\xdf\x77\x56\x13\xa3\x75\xa2\x26\x4a\x14\xad\x3b\x51\x9c\x47\xbe\xf9\xc6\x38\xf9\xcb\xd3\x27\x92\xb3\x94\xe6\x50\x68\x53\xbf\x05\xff\x24\xd7\xb4\x7c\x8b\xbe\x6d\xf7\xa2\x24\x20\xd7\x2f\x42\x0e\x66\x7f\x86\xbd\xa9\x3b\xa8\x9d\xb1\x6f\x79\xff\xbf\x75\xcc\xd8\x64\xab\x33\x56\x22\xc1\xe9\x88\x73\xe7\x15\xc1\x90\x95\x06\xb4\x11\xb7\xf7\x32\xb2\x88\xb1\x4f\x5a\xcc\xf1\xee\xfc\xe7\xeb\x45\xcb\x6b\xfd\x9f\x8f\xff\xf9\x4f\xde\xf6\xac\x01\xf6\x5a\x3f\x4e\xff\xf3\x9f\xfc\xe3\x5f\xda\x10\x7f\xdd\x6b\x77\x90\xf7\x97\x81\xd7\x96\x38\xf6\xff\x93\x3f\xde\x3f\xef\x20\xf0\x13\x92\x85\xff\xe7\x3f\xf9\x77\x1f\xff\x93\x7f\xf7\x17\xf8\xe4\x71\xaf\x1f\x6b\xe0\x0f\x3e\xa7\xcb\xf7\xd6\x56\x56\x2e\xb2\x5c\xcb\xf7\xe0\x62\x67\x36\x71\x57\x05\x13\x3d\x6c\xbb\xe1\xeb\x22\x8a\x5a\x98\xef\x67\x94\xdc\x9d\xc6\x03\x86\x58\x09\x15\xc1\x30\xe9\x02\x79\x5e\x90\xf9\x2e\xfd\xb1\x61\x8d\x24\xe2\x7a\xed\xf2\x95\x76\x80\xd6\xa1\x57\x50\x46\x60\x54\x99\x43\xdd\x29\x06\x38\x40\x57\x05\x51\x65\x50\xb2\xa2\x18\xab\xaa\x5e\x1c\x1f\x95\x40\xeb\x5a\x10\x30\xf7\x2d\x4a\xeb\x3f\xd2\xa0\x2a\x12\x6d\xf3\x10\xad\x80\x64\x8b\xe1\x4a\xf9\xbd\xe5\x35\x73\xb9\xdd\x4a\xf8\x58\xc0\xd5\x84\x44\xb9\x6b\x95\xb6\x31\x39\x6d\xac\xa4\x05\x4f\xde\x0c\x5f\x51\xee\xf8\x99\xa6\xc5\xb4\xee\xc9\x1b\x7f\x3c\x7c\xb3\x48\xcf\x33\xbc\xb8\xb8\xe9\xe5\xcb\xd9\x05\xc1\xf4\xde\xab\x6e\x60\x22\x65\xfa\x70\x2c\xae\x3d\xb3\xf4\xfa\x55\xf4\x07\xdc\x8b\x3c\x1e\x41\xb3\x3b\x4b\x55\x26\xd9\x19\xf6\xdf\x9f\x67\xe9\x32\x09\xa6\xc8\x4b\xd2\x84\xc8\x2f\xe9\x25\xc9\xe8\xf5\x7e\x8a\xbc\x8b\x28\x08\x48\x22\xbf\x14\xe4\xba\x78\xa1\xbe\x92\x38\x8e\x16\x79\x94\xcb\xef\x57\x17\x51\x41\x5e\x2d\x30\x44\xb8\x4f\xd2\xab\x0c\x2f\xe4\x37\xef\xd1\x34\x4c\xfd\x65\xee\x4d\x35\xd5\x9d\x4e\x04\xeb\xe7\x02\xc7\xa4\x28\x48\x8f\x36\xd5\x03\xb7\x4a\x88\x92\x83\xf4\x14\x09\xde\xa3\xe9\x05\x44\x88\x77\xa3\x7a\x96\xc6\x69\xd6\x04\x1f\xbf\x02\x32\xb4\x39\x89\x89\x0f\xd7\xc4\x0f\xa5\x11\x6a\x86\xf1\x96\xdd\x24\x6f\xb7\x10\x42\xf5\x37\x92\x2c\x51\x44\xf7\x13\x3e\x75\xf9\xdd\xa3\x9e\xb2\xb5\xbb\x61\x14\x2c\xa8\xbc\x9d\xc0\x57\x14\x55\x39\x2a\x5b\xb8\x8c\x51\x91\x72\x37\x08\x96\x40\x1b\x5e\x83\x6a\xde\xc7\xd2\x08\xaf\x0f\x46\xcc\x5f\xd0\xad\x11\x17\xcb\x8e\xac\xa5\x69\x35\xab\xfa\xc7\xbd\x40\x6d\x7f\x69\xdd\x27\x4a\x44\x87\x16\x41\xe3\x94\x77\x16\xfa\x99\x3d\x2b\xc0\xdc\x9b\x94\xf6\x85\x0a\x5d\x18\xbc\xb8\x44\x2e\x5b\x78\x6c\xe0\x88\x34\xa7\x5c\x0f\x36\x8b\x72\xcb\xb6\xc5\xbb\x45\xba\x05\x1c\x5b\x8d\x3a\xfb\x9a\xe9\x55\xeb\xa6\x85\x25\x7a\x59\x63\x46\x20\xb6\x5f\x0a\x1c\x73\x23\x97\x33\xb0\x91\x78\xf3\xcb\x02\xef\xc9\x85\x5e\x13\x8f\x16\x56\xb1\x3a\x7a\xe9\x7a\xa4\xe7\x71\x8b\xe9\xda\xb8\x20\x9b\x69\x39\xca\x34\x85\x9b\x7a\x7d\x2b\x39\x8b\x3f\x18\xb7\xb4\x72\x12\x4c\xb2\x91\x04\x91\xb6\x77\x0e\x22\xbb\x23\x20\x44\x81\x00\xe0\x99\xb3\xc4\xbb\x75\xf5\x20\x7d\xcd\x07\xe1\xf2\x3d\xb8\x96\x3b\x4a\x12\x0c\x3f\x04\x69\xf0\xe0\x9b\x53\x21\x93\x39\x89\x27\xdd\xb6\x25\x44\x05\xdb\x62\x12\x9c\x6a\x50\x3c\x93\xa0\x8b\xa6\x23\xf2\x6b\x1b\x02\xbc\xf5\x02\x9c\xc3\xcb\x01\x90\x63\xd3\xee\x98\x03\xde\xd6\xb5\x7a\x2b\x54\x9e\x52\x28\x53\x0a\xcf\xda\x27\xd8\xb3\x65\x51\xa4\x89\x9e\x82\xc9\xce\x4b\x54\xe0\xd9\x73\x7a\xdf\x9e\xa2\xee\xa0\x63\xea\xf5\x75\xeb\xc9\x9e\xc1\x00\x53\xf5\xe7\x9e\x7a\xe7\xdc\x6e\x43\xd0\x72\xc1\x84\x1b\x69\x19\x45\xa0\xaf\x0f\x8d\x37\x4d\x23\x24\x73\xa3\xe5\x68\xd5\x68\xb4\xd0\xac\x3a\x5f\xc4\xe1\xb6\x77\xbb\x8a\x91\x59\xb0\x34\x6d\x8d\xd5\xce\x44\x7b\x1d\x74\x7c\x9d\xd6\x4e\x54\x63\x84\xda\x5a\xff\xd2\x0e\x9f\xa6\x63\xc0\x73\xd4\x6d\x65\x3c\xb5\xed\xb2\x66\x49\xb4\xc1\xfa\x19\xb6\xb9\x3d\x40\x2e\x7b\x47\xb4\x01\xb6\x28\xbd\x39\x49\x96\x54\x5a\xf4\xcc\x65\x07\xbe\x9e\x7b\x6e\x93\xc2\x7a\x29\x99\x04\x0d\x90\x93\x49\xfc\xd8\x51\x52\xa6\xc3\xfb\xa5\xf9\xe5\x69\x5c\xa2\xcc\x5f\xc6\x38\xfb\x3d\x4b\xcf\x33\x52\x63\x50\x80\x7b\xfe\x8a\x46\x3d\x1b\x1b\x0f\xfe\xa4\xbf\xec\x14\x07\x0b\x64\x3d\xd3\x33\x61\xb4\xac\x17\x83\x95\xf9\x64\xac\x36\xda\x62\x86\x99\x51\xfd\x56\xd3\x47\x24\xa4\x41\xc7\x8e\x9b\x74\xcc\xc4\xb5\x8b\x6e\x99\x2d\xb8\x3a\xb5\x73\x7d\x89\xc5\xaf\x47\x0f\xea\xd7\x2d\xab\x5f\xbf\x9e\x0c\x68\x2c\x54\xed\x83\x7a\xb5\x46\xbd\xfa\x49\xd4\x9f\xaf\x9e\xff\x7f\x3f\xa3\x53\x34\xe9\x5b\x69\x87\x5e\x92\x18\x17\xd1\x25\xf9\x17\x5d\x35\x22\x93\xd0\x3c\x4a\x3a\x68\x8e\xaf\x8d\x6b\xe0\x7c\x41\x02\x80\x42\xa7\x2c\xf5\xd0\x3c\x4a\x5a\xec\x0f\x7c\xdd\x82\x2a\x2c\x7b\x11\xab\xaa\x85\x1b\x6a\x19\xb5\xbb\x14\x7d\x1b\xed\xa3\xd6\x1c\x5f\xf3\x5f\x32\x65\xd1\xb6\xb4\x8d\x42\xc3\x15\x44\xf9\x02\xa2\x08\x7a\x51\x12\x47\x09\xe9\xce\xe2\xd4\x7f\xef\xed\x69\xda\xb6\x45\x16\xcd\x71\x76\xc3\x35\x60\x1f\xe4\x8d\xd5\xa1\x10\xe3\xa0\x6f\x26\xfd\xfe\x5b\x1d\x05\xf6\x7d\x92\x14\x4d\x30\xb0\xd7\x53\x38\xbb\xe9\x3d\x19\xf6\xfb\x3a\x8e\xfc\xf2\x9c\xde\xa6\x0a\x92\xcd\xa3\x04\x17\x44\x21\x92\xcf\xa7\xa8\x1c\xb4\x8c\xba\x0b\x7e\x34\x74\x7d\x7e\x00\x76\xb3\xb4\xc0\x05\x41\x83\xde\x38\x47\x31\x1c\x1f\x28\x4a\xc2\x28\x89\x0a\xe2\x59\x6d\xfc\xe4\x6a\x41\x86\x42\x9c\x52\x69\x10\x1e\xc2\x74\x8f\xfb\x01\x39\x6f\x1b\xd5\x69\x7b\xb1\x56\x2d\x2f\xb2\xf4\x3d\x95\x9f\xfc\x65\x96\x89\x01\x90\xea\x50\xf6\x95\x9e\x66\x3e\x5e\x00\xe2\x65\x12\x38\xf0\x6d\xdc\xeb\x00\xe7\x17\xac\xcf\xfc\x59\x46\x37\x5d\x16\xaa\xe3\x82\x8e\xfd\x7d\xf4\x2a\x9d\x13\xb1\x30\x78\x16\x2d\x48\x91\x10\xa7\xe9\xfb\x1c\xd1\x2d\x1a\x5d\x61\xe6\x04\x2b\x34\x5c\x2a\x50\x40\x91\xa2\xf7\x91\xff\x3e\x47\x51\xd2\x33\xba\xf6\x13\xce\x2f\x70\x96\x01\x77\x1d\xf5\x3b\xc3\x7e\xdf\xea\x3b\x05\x48\x21\x0b\xff\x14\x19\x73\xed\xfd\x8f\xf7\xe4\x26\xcc\x60\xd7\xaa\x9b\x51\x4d\xfd\xeb\x0d\xfa\xfd\xbf\x1a\xea\x60\xc7\xa4\x8d\x0e\xb4\x49\x53\x4e\xa1\x0d\xdb\xa4\xe3\xa9\xb7\x68\xb5\x57\xee\xf4\xc0\xe8\x73\x75\xaf\x75\xc5\xf6\x64\x35\xd6\x7e\x7f\x25\xde\xee\x60\x52\xc2\x5c\x1a\xa0\x4d\x51\x0f\xfb\xe6\xf8\x6d\xa4\xf4\x86\xb5\xb0\x22\x8f\x5a\xeb\x8d\xc7\x77\x14\x48\x73\x0e\x9b\x08\xfd\x8b\x5b\x2a\xbd\x75\x73\x95\xfd\x56\x6d\xbb\xd2\x9a\xd4\x56\x1b\x6b\x4c\x2f\xd8\x4a\x7a\xb4\x3f\xaf\xb2\x9b\xce\x19\x7f\x1c\xab\x14\xd5\x7a\x3e\x01\x78\x36\x0b\x01\x2a\xf9\x8e\xce\x9c\x34\x61\x37\x99\xe3\xf7\x24\x47\x39\x49\x78\x0c\x5e\xae\xdc\x86\x53\xe0\x6e\x6c\x50\x26\x95\x1e\x9d\x6c\x23\x4b\x43\x24\x96\x32\x8a\x12\xa4\x4d\x26\x9a\x4b\x05\xfd\x3e\xe4\x32\xbe\x5e\x99\xd4\xa1\xd4\x4c\x94\xac\xdd\x4c\x4d\x1e\xb4\xca\x66\x28\xe3\xa6\x21\x4b\xc2\x76\x93\x2e\x33\xd9\x56\x0f\x19\xc7\x03\xab\x42\xf7\x68\x3e\xec\x24\x23\xe0\x51\x9b\x72\x32\xe9\x27\x59\x97\x41\x6b\x27\x1e\x7c\xf6\xd3\xa4\xc8\xd2\x38\x26\x81\xea\x11\x54\xd6\xfa\x00\x0f\xcb\xef\xb6\x8e\xca\xbd\x84\xc4\xdd\x82\xbb\xe0\xe8\xd3\x54\xf6\x90\xe7\x7b\x8d\x61\xdb\x4e\xb2\x9d\xe2\x22\xf2\xdf\x27\x74\x04\x2a\xe8\x92\x00\x6b\xcf\xe9\x9a\x6c\xc3\x6f\x6d\x2b\xd2\x3c\x1a\x26\x0b\xfb\xfe\x6f\x9b\x2e\xde\x59\xce\xc1\xeb\x98\x33\xea\x4c\x19\x6c\x63\x17\x66\x8c\x38\x95\x7e\xc0\x30\xc1\xd2\x7c\x11\xfd\x41\x94\x38\x70\xa3\xd9\x2e\x8c\x68\xba\x6a\x06\xc4\x67\x59\x22\x40\xe6\x6c\x5b\x67\x5f\xe9\x0f\xf1\xe1\x92\x4b\xe3\xec\x0b\x93\xdd\x45\x9d\x28\x51\x55\x22\x19\x73\x98\x6e\x1b\xb2\x18\x5f\xef\xce\x82\x02\x82\x20\xf2\xe8\x20\x98\x61\x73\x45\xe7\xe8\x0f\xda\x17\xfa\x2f\x50\x0e\x05\x11\x84\xe4\x9d\xe3\x6b\xc3\xcc\x42\x45\x7a\x79\xd0\xdc\xaa\xb9\x04\x5e\x7d\xc5\xc7\xf6\x03\xbc\xc1\x88\x42\xd4\x9a\x4b\x4d\xb9\xbe\x22\x75\x4f\xf3\x8c\xc4\xff\xc2\x31\x8b\xfb\xbd\xe2\x02\xf4\x1d\x1a\xf4\x79\x70\x6c\xd1\xe6\x72\xce\x23\xd0\xa1\x53\x34\x44\xdf\xb1\xcb\xd0\xef\xcf\xd1\x77\xa8\x05\xb7\xac\x7d\x34\x44\x5d\x24\xc3\x88\x6b\x64\xf6\x6c\x71\x43\x5c\xa5\x40\x36\x6e\xb5\x06\xfd\x3e\xea\x72\xea\xe8\x0d\x89\xfe\xfe\xce\x6a\x13\x08\xea\xf3\xaf\x7d\xf4\x18\x79\x8b\x6b\x1e\xac\xd7\xdd\x12\x08\x3f\x66\x43\x75\x18\x85\x1f\xbd\x18\xf3\x37\x1e\xce\x22\xdc\x85\x81\x49\xd2\x2b\xef\x2d\x3a\x65\x8c\x77\x52\x0d\x47\xe7\x91\xc2\xcd\xa3\xa4\x0e\x8a\x4e\x33\x85\xc2\xd7\xf2\x19\x4c\xf3\x20\xc3\x5e\x10\x5d\x72\x41\x6e\x45\x28\x61\x4d\x20\x68\x6a\xa4\x63\x8b\x1c\x1e\x18\x89\x53\x58\x0b\x78\xf6\x86\x7d\x7e\x8c\x3c\x76\xe3\x79\xab\x7b\x67\x1a\x6b\xbe\xda\xed\x05\x5d\x45\x41\x71\x31\x85\x3d\xa3\x23\x9d\x5b\x60\x07\xb9\xe5\xe1\x9e\xdb\xba\xe5\x73\x8a\x3c\xb1\x91\xce\x70\x26\xae\x51\x6a\x60\x85\x21\x8d\xd5\x69\x14\xa4\xd9\xcb\x2f\xcf\xa5\x28\xac\xc4\xe6\x46\xc3\xd5\x7a\x67\x3c\x1b\xfb\xb0\xda\x1e\xa4\xe0\x35\x0b\xa7\x75\xe7\xed\x20\xb5\x76\xcd\xf3\x74\xb5\xfd\xa1\x02\xff\x4f\x6e\xec\x16\x6e\xad\x76\x5b\x7b\x0c\x75\x19\x91\xab\xa7\xe9\xf5\x14\x79\x7d\xd4\x07\xb7\x6f\x58\xe0\xc2\x07\x9c\xfe\xb0\xaf\x21\xf5\x23\xef\xb1\x25\x6a\xa4\x42\x58\x8b\x3d\x59\xfd\x75\xac\xc8\x8e\x4b\x76\xcd\x30\xb7\xf5\xab\x11\x30\xb0\xb6\xa9\x68\xaf\xc4\xae\xa7\x48\xec\x75\x5a\xe9\x8d\xab\x34\x53\x85\x74\x5b\x54\x1f\xc2\x28\x8e\x6d\xcf\x2c\x71\x23\xfb\x37\x5b\x1d\xf2\xb8\x10\xc3\x0c\x11\x7e\x10\xfd\x5f\xa6\x33\xb2\x65\x80\xcf\x63\x39\xde\x8a\x90\x6f\xdb\x96\x57\x4b\x84\x56\x8d\x6d\x48\xad\x16\xca\x26\x52\x99\x4d\xc5\x4a\xf9\xdf\xae\xb0\xf2\x5e\xa2\x55\xf8\x82\x0c\xcf\x4c\x44\xba\x1b\xcf\x34\x6d\x8d\x1e\xb5\x95\x6d\xb1\x41\x6e\x8c\x0a\x64\xb4\xed\xa0\x62\xf2\xdf\xdd\x38\xb6\xb1\x65\x9a\x89\xa2\x5b\x21\x5c\x88\xb3\x5b\x61\x2d\x5d\x24\xde\x0a\x75\x42\x9c\x5e\x85\x4c\x37\xc1\x97\xf6\x51\x87\x29\x9e\xef\x72\x8a\x27\xe5\x2e\x35\xee\x77\xcc\xbb\xe2\xa8\x77\xa0\x76\x24\x6b\xca\xb4\x7d\xa5\x2f\x37\x8c\xbe\xdc\x09\x06\xfd\xfe\x56\x0c\xfa\x25\x0b\x34\xba\x6d\xb7\x4a\x26\xe3\xdd\x18\xf8\x8f\xbf\x70\x83\xe9\x4e\xcd\x97\x5f\xf9\x63\x98\x2f\xc2\x60\x8a\xb3\x84\xe7\x2b\x72\x91\x3e\xb6\x01\x6b\x6d\xa5\x0c\xe4\x8b\x32\xc6\xbe\x7e\xf9\xe4\x1f\xaf\x9e\xd3\x55\xfc\xee\xa7\x7f\xbe\x7c\x02\xcb\xf9\x14\x8d\x4f\xd0\xfe\x3e\x1a\xf7\xfb\xf3\x7c\x37\xc6\xd0\x45\x2a\xa2\x9a\x79\x19\xd7\x7a\x34\x78\x12\x21\xee\xa6\x93\xd5\x46\xd3\x15\xef\x09\x84\xf9\x74\x60\x99\x4f\x75\x64\x4f\xf1\xfa\xf8\x6c\x73\x2c\x2f\xff\x09\xe7\x17\xee\xd7\x0e\x74\x00\x70\x10\xe1\xb8\x7b\x4e\xff\x85\x9b\x19\x7a\x5c\x43\x2d\x5c\xf9\xfa\x7f\xed\xa0\x06\x60\x83\x83\xbf\x76\x98\x71\x6e\x81\x33\x92\x14\x68\x3c\xfc\x6b\xdb\xf1\x28\xe5\x15\x1c\x9d\xde\xa0\xbf\xb8\x46\xf4\x7f\x1c\x20\xbf\xab\x09\xa3\x50\xdd\xe1\x68\x71\xed\xad\x34\x3c\xaf\x18\x35\xcd\x04\x3d\x30\x4d\xd0\x1a\xb6\x75\xa6\x41\x43\x38\x76\x21\xbc\xe3\x3c\x98\xf4\xd6\xcc\x84\x03\xf0\x53\xce\xc5\x4c\x1f\x32\xae\xdd\x61\x46\xc9\x4e\x79\xfd\xe1\x59\x9e\xc6\x4b\xcd\x4a\x1d\x93\xb0\xe0\x62\x10\x20\x4b\x8b\x22\x9d\x6b\x05\x45\xba\xd0\x7f\x69\x11\x0a\x55\x86\x45\xd4\xef\x0d\x85\x03\x80\xd7\xb1\x6d\xfb\x2f\xb2\xe8\x9c\x8a\x5a\x1e\x6d\xca\xa0\x3c\xb0\x26\xa8\x8e\xce\x39\xce\xce\xa3\xe4\xb5\x41\x8d\xd8\x21\xcc\xde\x3a\x87\x40\xb7\xea\xcf\x96\x61\x48\x32\x34\xca\xa5\xcd\x5e\xd0\x6e\x0c\x2b\x40\x3d\xc5\xd9\xd0\xf2\x57\x28\x77\xbf\x47\x79\xc2\xb5\xb7\x3e\x46\x5e\xee\xc2\x4d\xb7\xc7\xa7\x80\xbf\x86\xd9\x3d\x8d\x7f\x4a\xb5\xff\xdf\x25\xc9\x6e\x6a\x1d\x29\x06\x47\x65\x47\x0a\x43\x20\x7e\x8a\xb3\x41\x99\x71\x64\x2e\x2d\x56\x18\xc7\xcf\x2e\x70\x72\x4e\xf8\xf4\x75\x50\x46\x87\xdc\x39\xac\xf3\x65\xd4\x35\x1a\x18\xa0\x61\x6f\x90\x23\x7f\x39\x8b\xfc\xee\x8c\xfc\x11\x91\xac\xd5\xef\x1d\x4c\x3a\xa8\xdf\x3b\x1a\xc0\x3f\x87\x23\xf8\x67\x74\x3c\x69\xbb\x3d\x47\x6c\x8a\x87\x3b\xa5\x78\xe8\xa4\x78\xc0\x49\x1e\xd3\xff\x1d\x8f\x3b\x68\xd0\x2e\x7b\x7b\x48\xbc\x3f\xb1\xec\xa1\xde\xa0\x37\x98\xe4\x26\xbb\x57\x8f\xbd\x46\xb4\x96\xb7\x74\xcb\x5c\x27\x39\x5a\x6b\xfa\x0f\xfe\x92\x62\xb0\xb3\xc6\x86\xbf\xb3\x83\x6a\x3b\xab\xa8\xbc\x3f\xae\x75\xe2\x2b\xaa\x9e\xc0\x11\xf1\x49\x89\xaa\x3e\x00\xf7\xf7\xd1\xaf\xe4\x9c\x5e\x47\xa6\xe2\xf7\xc7\x8f\x28\x23\x8b\x8c\xe4\x24\x29\x72\x30\x91\x5e\x46\xe4\x8a\x8a\x63\x02\xa2\x8b\x74\x08\x8c\x62\xca\xe7\x1a\x0d\x02\xee\xda\x82\x0b\x70\xf6\xde\x06\xb3\x9d\x74\xcc\x75\xac\x79\xb7\xec\xef\x23\xf4\xb1\x4b\xff\xa3\xff\x7b\xdd\xfd\xc8\x7f\xf0\x7f\x84\x86\xdf\xf2\x88\x61\x87\x8c\xd7\x1d\x4d\xfe\xaa\x69\x5c\x33\x7d\xf7\xb6\xf5\xd9\x66\x43\xaa\x85\x8f\xd7\xd7\xd7\xd7\xaa\xa1\x03\x77\x4b\xc6\xde\xaf\x5a\xea\x1e\x3b\x5a\x2a\x3b\xf0\xac\x81\x44\x9f\xc5\xda\x41\x1c\xda\x83\x48\xfb\x71\xcd\xff\x77\xad\x41\x1c\xba\xc9\x5a\x6f\x14\xbb\xd7\x46\x53\x95\xc3\x78\xe8\x1c\x81\xa3\xb5\x46\x71\x25\x8e\xaa\x41\x64\xab\xb5\xc6\x35\x4c\x85\x5f\x56\x0d\x34\x91\x9c\xea\x1c\xc3\x54\x60\xe6\xcd\x71\x96\xc6\xa2\x31\xa1\x74\x76\x4b\x78\xf7\xd0\x76\xdf\x40\x3f\xf8\x49\xdd\xdd\x4f\xca\xe9\x1c\x55\xe9\x4e\xd4\x31\x05\x99\xbd\xf5\xdd\x89\xb6\xe3\x1e\xd4\x11\xd2\x2f\xfd\xeb\xff\x52\x19\xd2\xd9\x91\x92\x0f\x4d\x07\xa5\x49\x7c\x83\xae\xd2\xec\x7d\xc9\x9f\x06\x27\x01\x5f\xa9\x9a\x6b\x0d\x62\x3e\xd7\x33\x52\x5c\x11\x92\xa0\x3e\x40\x0d\xfa\xfd\xf5\x1c\x6f\x6a\x28\x63\x2d\xda\x74\x6d\x4a\x87\x10\xc6\xd7\x71\x03\x32\xdf\xcb\xd4\x38\x01\x19\x66\xde\xa1\xf1\x6b\x64\xfc\x1a\x7f\x1a\x77\xa1\x4d\xfc\x7a\xb4\x51\x32\x01\x58\xd9\xce\x1d\x7a\x4a\x2e\x3b\x5a\xe3\x86\xcf\x0e\xbb\x53\x8a\xd0\x74\xab\x0d\xdb\x0c\xbe\x83\xb6\xe3\x58\x60\x68\x80\x84\x3b\x07\xd8\xbb\xc5\x0e\xb2\x99\x43\x81\xae\xd0\x30\xd0\xf2\xdd\xc8\x76\x25\x38\xd1\x5d\x98\x9e\x6d\xf2\x5a\x5c\x67\xd9\x75\xc7\x63\x58\x1a\x10\x90\x87\xef\x3c\x1e\x43\x7b\x40\xca\x68\xd5\x78\x6c\x82\x55\xdd\xcb\x75\x57\x05\xbe\x63\xde\x01\x27\xdc\xd6\x75\x94\x6c\xeb\x35\x67\x6d\xd8\xb6\x63\x9b\xb2\xe0\xa4\x6c\x00\xd7\x9a\xc3\x19\xce\xcc\x29\x1c\xad\x3b\x85\x23\xf7\x14\x3e\xc5\x77\x9f\xc5\x91\x73\x16\x6d\xcc\x1b\x4c\xa4\x86\xb8\xa4\xe8\xa8\x76\x3d\xa1\x37\x2d\xc7\xc4\x6c\xd2\x6a\x4d\x9b\x9b\xfa\x14\x69\xd8\xd5\xf5\xdd\xcd\x9c\x7a\xad\xb6\xe4\x1f\x79\xe9\xbc\x23\x07\x8d\xd7\xe5\xa0\xb1\x83\xf2\xe1\x1d\x97\xd5\x78\x3d\xae\x44\x8f\x1e\xb1\xf6\xbe\xd9\x6e\x7b\xf5\x8d\x6d\xa1\x73\xab\xd7\xc5\x36\xbb\xb6\x62\x2f\xdd\x66\xc7\x4a\xea\xbc\xb5\xd7\xa5\x8e\x57\x71\x39\x7b\x64\x27\xcd\x73\x1f\xc4\xb6\x39\x05\x9e\x95\x6b\x80\xfe\x64\x31\xd3\x2b\xdc\x7b\x57\xbb\xf1\x52\x08\x26\x27\xd1\x91\x97\x16\x6a\x15\xda\x5e\x27\x45\x70\x4d\x4f\x29\x94\x4e\x91\x97\xfb\x38\x26\xff\x0b\x2c\x0e\x0c\x13\x73\xb8\x7d\x8c\xbc\xb6\x27\xe2\xea\xd7\xba\xc1\x6a\x1e\xb5\xec\xe5\x23\x8f\x02\xcf\x73\x88\x0b\x6d\x7a\x53\x2f\x34\x70\x6f\xe0\x06\x51\x35\x81\x3c\x01\xb2\xf7\x1b\x2e\x48\x16\xe1\xb8\xfb\xcf\xe7\x53\x7a\xa9\x41\x09\x61\xf7\x43\x9e\x73\x16\x61\xde\x8b\x05\x67\x02\xb0\x90\x78\x70\xb1\xb1\x1e\xc0\x47\x6e\x5f\x7c\xaf\x8d\xa6\xe8\x32\x8d\x02\xd4\x3f\x51\x57\x5d\x24\x63\xe8\x96\x99\xef\xd3\xce\x85\x81\x45\x29\xf1\xaa\xf0\xb4\x74\x59\xf9\xe3\x47\x24\x3c\x9c\x75\xa4\xf7\x65\xaa\xaa\x67\x49\xbf\x49\xb9\x27\x68\xeb\x6e\xd3\xba\x66\xc0\x94\x5b\xab\x1d\x8e\x4b\xbc\x81\x7e\x5c\xe5\x0a\x0b\x84\x98\x29\x17\xf4\x4b\xc3\x2d\xed\x6c\xb2\x8c\xe3\x26\x1e\xcd\x2e\x64\xb6\xc4\xd6\x11\x1e\xad\x2e\x6e\x94\x41\xf2\xdc\xbb\x0e\xfa\x91\xe5\x4b\x9f\x6e\x40\x47\xf9\xe4\x77\x53\x22\xe1\x98\x97\x2b\xf3\x6f\x35\x79\xe2\xd3\x7b\xb7\x3e\xf8\x5b\xae\xe1\x64\x79\x77\x77\x46\xa7\x5e\x68\xdb\x7e\x7f\xcd\x91\x3d\x15\xb4\xac\xe3\x4a\x68\xb1\x6c\x43\x47\x42\xa7\xab\xe0\x56\x1c\x01\xad\x88\x2d\xe8\xb6\xdd\xb2\x42\xac\xec\xc4\x09\x70\xd0\xbf\x8f\x51\x7e\x5e\xe2\x20\x4a\xab\x1c\xa7\x06\x83\x26\x11\x70\x44\x48\xfb\x1d\x84\xbe\x01\xea\x2a\xc3\xf8\xc0\xd7\xbf\x65\xe9\x72\x51\xd9\x81\x71\x93\x0e\x28\x3c\x3b\xeb\x03\x60\xbf\x07\xa1\x7b\x06\x83\x2f\xc2\x13\x15\xc6\xf4\xa7\xd4\x77\xfa\xc2\xdd\x83\x70\x3e\x19\x09\x87\xe0\xbc\x87\xae\x08\x7e\xbf\x4b\xef\xcd\x4f\x11\xe9\xfb\xd5\x55\x54\xf8\x17\x4f\x71\x5e\x19\x6c\xfa\x68\xe4\x00\xae\x6b\x45\x41\x99\xab\xf9\x29\x04\x99\x84\x94\xa4\x10\xf9\xd3\xbd\xaa\x87\x35\x95\xea\x5a\x2d\x43\xbb\x10\xfd\x33\xf1\x57\xb4\x3f\xaa\xad\xd6\x90\x02\x09\xff\x75\x47\x3c\xbf\xbb\x4f\xab\xec\x6d\x6d\xa0\x1d\x88\x5d\x2d\x45\x6a\xdd\xb2\xcd\xa7\x61\xc3\x50\x3f\x3c\xd7\xd6\xaa\xea\x18\xba\xd2\x13\xd0\x2e\xcb\xb1\x38\x8a\xd7\x93\x66\xa0\x16\x08\x31\x50\x4f\x5b\x7e\xe6\xc3\xd7\x28\x59\x2c\x21\x0c\x24\xf7\xb1\x64\xae\x59\x1c\xe4\xb9\x9f\x26\xab\xae\x32\x6e\x5e\x57\xc1\x63\xe9\x7d\xa8\xad\xe1\xe4\x2b\x6c\x5d\xd4\xcf\xdc\x88\xf7\x20\x6f\xd5\x1e\x00\xf6\x78\x10\x27\xae\x34\x65\xe7\xb7\xe7\x94\x0c\xe1\xd3\xc9\x9d\x0d\xf3\xcf\x43\x9e\x81\xbe\x63\x9a\xb8\xe9\x9d\x9c\x8f\x84\x1e\xad\x9c\xf3\x53\x9d\xe0\x4f\x5b\x6d\xbd\xa9\x09\x89\xb9\xe2\x9a\xe3\xb2\x0e\x47\x3e\x8b\x4e\xc4\x87\x47\xda\xb0\x6b\xe8\xa5\x3d\x93\x41\xba\xa3\x5c\x28\x24\x82\x0e\x8a\x78\x7e\xfd\x19\x61\x91\xbe\x71\x8e\x30\x0a\xd3\xa4\x40\x71\x74\x8e\x8b\x65\x46\x4a\x3d\x66\x53\xfd\x27\x8e\x62\xfb\xe7\x0f\xd1\x6e\x63\x31\xd7\x62\x6d\x58\x62\x13\x91\xc5\xf1\x39\x6c\x2b\x92\x23\xc4\x36\xa6\xba\xac\xb6\xc1\x4d\x9b\xc8\xa2\xc5\x22\x26\x88\x84\x21\xf1\x8b\xd5\x2d\xbd\x04\xf0\x35\x9a\x6b\xbe\x42\x96\xc9\x0e\xd6\x48\xf4\x65\x2d\x0e\xe5\x36\xa0\x2f\x06\x3a\x94\x67\x70\xd2\x9c\xc9\xe4\x51\x6a\x04\x68\x39\x6c\xaf\x6b\x2d\x0c\x88\x71\x7f\x81\x0b\xa5\x1c\x2d\x52\xb4\xc0\x79\x0e\x19\x35\x43\x44\x6f\xe3\x33\xec\xbf\x17\xed\x27\xf0\x8e\x85\xb5\xe6\xca\x2e\x00\x1f\x5e\x92\xb0\x92\x08\x3a\xd6\x9c\x04\xf7\xa2\x4a\xd6\x5d\x95\xcf\x04\x89\x61\x94\x91\x40\x71\x5d\x0e\x51\xfa\x60\x4f\xc6\xc9\xb9\xe0\x37\xde\xe8\x02\x67\x78\x8e\x3e\xb0\x21\xb9\x45\xe4\x92\x72\x27\x65\x62\xf6\x57\x9e\x2e\x33\x5f\x85\x0f\xe2\x2d\x98\x75\xe9\x22\x20\x38\xb9\x15\x1b\x34\x54\x3f\xe3\x3f\xce\x94\xcf\x8e\x5a\xe1\xb2\x8f\xf4\x20\x66\x8e\xcf\xab\x47\xa9\x62\x98\x54\x38\xf8\x8d\x0f\x42\xee\x6d\xb4\xfe\x51\x68\x74\xcd\xc1\x04\xf5\x4e\x4e\x0c\xaf\x14\xcc\xb8\xbe\x74\x85\xa6\x37\x5f\xe0\xc4\xe3\xd2\xca\xc9\xde\x9e\x96\x06\x16\xbc\xc8\xf2\x34\x26\xf1\x0d\xcb\xeb\x1a\x9d\x9f\x93\x0c\xe1\x45\x84\x82\xd4\x47\xe7\x24\x21\x19\xb8\xa8\xd3\x4a\x66\x0a\xd7\x6e\x42\xae\x8b\x6e\x1c\x25\x7a\x2a\xd6\x4b\x9c\xe5\x4a\x62\xb4\xae\xc1\x7a\x99\x94\xa0\x65\xa1\xee\x0d\xa5\x6c\x04\x21\x08\xa1\x12\x68\x73\xad\xf2\xf0\x4e\x41\x13\x3e\x95\xdc\xf4\xe5\x08\x2c\xcd\xb4\xf1\xc3\x2d\xab\xe3\x87\x5b\xd7\xc7\x0f\x95\x1a\x91\x8b\x2a\x2b\xe3\xc5\x37\x44\xca\xc5\x87\xed\xa2\x63\xb2\xc7\x96\x70\x52\xc1\x60\xed\x64\x03\xf7\x8a\x0b\x9b\x77\x55\x4a\x00\x5b\xe3\x43\x71\x9a\x57\x23\xa4\x03\xd4\x18\x5d\xb2\x4d\x8e\x16\x67\xe8\x96\x68\x13\xe7\xe9\x0a\x93\xd2\x36\x0e\xd4\xc6\x34\xad\x30\x31\xc9\x01\x03\x78\x61\x10\xda\x85\x71\x65\x78\x1f\x8d\x2b\x3b\xd1\xf8\x2e\x96\x59\x95\x7a\x6e\x78\x64\x40\xd5\xe1\xa4\xdf\x95\xce\xf6\xf2\x9c\x1e\x85\x55\x58\x27\x36\x60\xad\x66\x97\x81\x7c\x2a\xdb\xc6\x9e\x12\x3c\x51\x17\x41\x3b\x09\x8e\x0d\x91\xef\xbb\xfd\x35\xa4\xb8\x05\x2e\x2e\xc0\x60\x1f\x4c\x91\xf7\xdb\x60\x88\x0e\xfd\xee\xb0\x77\x78\x80\xfa\xdd\x09\x1a\xf6\x86\xe3\xee\x04\x4d\x72\xfa\x07\x9a\xb0\xff\xd7\x65\x3f\xba\xec\x8f\x2e\xfd\x63\xf2\xc7\xbc\xdf\x9d\x3c\x3b\xe8\x8d\x8f\xd0\x10\x0d\x11\xff\x63\x30\xcc\xc7\xf4\xaf\x41\x5f\xfe\x5f\x97\x17\x74\x07\xfd\x57\x83\xc3\xde\x64\x08\x60\x68\xf8\xc7\xbc\x8f\x06\x47\x3e\xfd\x3c\x44\xfd\xee\x51\x77\xd4\x9b\x1c\x75\x8f\xba\x47\x39\xfb\x03\xc1\xff\x47\xf4\x07\xa2\x3f\xd8\x1f\xb4\xec\x0f\x0f\x49\x06\x74\xaa\xd4\x4d\xa1\xd0\xf8\xea\x96\x0e\x57\x79\x90\x48\xae\x90\x2a\xbb\x3d\xee\x3b\xb3\xc8\xa5\xaf\x46\xc8\x3d\x18\xb8\x98\x69\x13\x05\xbb\x0d\xf0\xac\xda\x63\x9c\xda\xfa\x72\x61\x6f\xbe\x8c\x84\x26\x90\x53\x52\xa3\x0b\x34\xaa\x96\x12\x0b\x0f\xee\x59\xba\xf7\x87\x6d\xe4\x4b\xd9\x46\x86\xf7\x6a\x37\xd0\x4d\x5c\xae\xfd\x40\x7e\xff\xd4\x3b\x82\x4e\xd8\x8a\x3d\x41\xb7\x9f\xb9\x8a\x37\xd9\x17\x64\xe5\xf2\xce\xb0\xcd\xec\xfc\x9f\xde\x70\xfe\xb5\x65\x99\x39\x27\xb4\xb8\x48\xe9\x25\xe5\x45\x58\x41\xc2\x51\x05\x78\xdd\xbe\x64\x42\x9a\x91\x91\x9e\xe1\x38\x86\x93\xa5\xaa\xcf\xc7\x15\xf0\x75\x5d\xb5\x30\x2b\x0c\xb0\xec\xc0\x85\xb0\xaa\xb9\x41\xdf\x05\x5d\xdb\x98\x86\x54\x9d\x01\x69\x9e\x47\xb3\x98\x3c\x4b\x93\xbc\xc8\x96\x7e\x91\x66\x2f\x61\x2b\xa8\x6c\x77\xb0\xba\x6e\x1d\x15\xd5\x0d\x4a\xbc\x3c\xe2\x61\x75\xd7\xcb\xa0\x75\x2d\x4a\x74\xbb\x3d\x73\x7f\x49\xb3\x79\x9d\xbf\xd2\xf0\x78\x58\x86\xad\x43\x2f\x81\x64\xb5\x0b\x12\x2f\x48\x56\x19\xca\x6b\xfc\xd5\x3a\x1b\x54\x64\xfc\x97\x23\x78\xf7\xd7\xdb\xec\x25\x34\xe4\xae\xae\xd1\x3c\x7f\x11\xe9\x3e\xcb\x0a\xf7\x84\x9e\xb4\x60\x04\x2b\x52\x94\x11\x11\x4a\xbc\x28\xeb\xe2\x21\xd9\x42\x6f\x73\x63\x8a\x6d\x66\x48\x93\xa7\xf1\xb2\xfa\x89\x70\xd9\x4e\xe1\xb2\xc6\x60\x04\x3e\x11\x3c\xc9\x2d\x8a\x72\x99\x53\x72\xdb\x36\x19\xd6\xa5\x5b\x3e\x2a\x60\x90\x81\x3f\xcf\xa4\x21\x46\xe4\x3d\xd6\x29\xda\xa6\x5d\x26\x4d\xfe\x27\xb9\xf9\x29\xbd\xaa\x0e\xcb\x5b\xc6\xf1\x2f\xc3\x54\xe4\xa2\x70\x43\xdb\x8a\xe1\xc3\x29\x37\xa6\xd6\x3b\x60\xbf\xbf\xc8\x75\xca\x24\x50\x90\x08\xe5\x7e\x6e\x49\x85\x80\xa4\x83\x4a\x35\xe1\xfd\x90\x29\xe4\x02\x68\x4b\x4f\x00\xc0\xa3\x2c\xca\x9f\x05\x99\x53\x5c\xc5\x45\x94\x83\xf2\xaa\xe0\x1f\xd5\x03\x3d\x75\x78\x2b\x3a\x18\xb8\xe6\xf0\xc9\x6b\x85\x69\x86\x5a\x80\x37\x26\xf4\x7a\x84\xb3\xf3\xe5\x1c\x5c\x06\x62\x92\x9c\x17\x17\x1d\x5a\x42\xf7\x93\x27\x59\x86\x6f\x5a\x14\xaa\xdd\x41\xef\xde\x93\x1b\x74\x8a\xfa\x27\xec\xaf\xef\xa1\x36\xfb\xf1\xf8\xb1\x7a\x4b\x43\xab\xbe\xa1\x85\x6f\x75\xcc\xac\x44\xbc\x0a\x31\xfc\x54\x33\x48\x33\xd0\x82\x3e\xb2\x3f\x2e\x22\xf9\x26\xbb\xfa\xc0\xb6\xbb\x29\x9e\x11\xa8\xee\xf6\xde\xd1\x6d\xa2\x48\xdf\xbd\xa3\x9b\x31\xa0\xb3\x04\x2b\xd7\x94\xb5\xdb\xa0\xf3\xeb\x41\x12\x73\xee\x6d\xfe\x86\x36\xf1\xb6\xe7\xa7\x89\x8f\x8b\x16\xed\x61\xbb\xdd\xe6\xf3\x21\xfe\xed\x01\xf7\x51\xc2\xdf\xbc\x15\x45\x61\xea\x2f\x0d\xc3\x57\x4b\x7b\x73\x14\xa2\xd6\x37\x46\xcd\x8f\x1f\x91\x51\xc0\x67\xa3\xad\xc5\x07\x61\x63\x76\x22\x03\x7e\xc8\x57\xf7\x19\x82\xb6\x5e\x0a\x1a\x0c\x3c\x61\x14\x17\x24\x6b\x29\x2a\x92\x32\x4e\xf4\x8d\xf2\x06\x93\xf8\x05\xc3\x70\x6a\xb5\x26\xd6\xa3\x4d\xac\x50\xc3\xa5\x8c\x8b\x06\xbd\x30\x4a\x82\x76\x4b\xc3\xdd\x41\xf5\x94\x26\x3d\x79\x2b\x72\xd2\x69\xb4\xa6\xd7\x37\x3e\xb0\xc9\x69\xb5\x4f\x56\x75\x40\xa3\xec\x4d\xff\xad\x59\xed\x56\xcc\xf4\x05\x4e\x82\x98\x00\x14\xdb\x10\x8d\x59\x87\xed\xb8\x23\xcc\x7c\x26\x0f\x88\x0b\xe6\xa3\x47\x1c\x15\x0b\x9a\x20\x36\x56\x9d\x7e\xd7\x77\x81\x1b\xfe\xe9\x15\x38\x3b\x27\x45\x4f\x7f\xed\xa7\xe2\xe6\xb0\x6d\x44\xe8\xd2\x9b\xac\x2c\x6d\xc3\x69\xcb\x14\x18\x6c\xcf\xd1\x04\x78\xf7\xc6\xf7\x86\xd1\xfd\x9e\xdc\x40\x38\xcf\x24\x20\x22\x00\x16\xdf\x90\xe5\xf0\xb0\x8f\xda\xd2\x60\x5b\xde\x45\x04\xe2\x34\xfd\xf7\x44\x67\x26\x38\xfb\x73\xfe\xa5\xa7\x5d\xe2\xb9\xbb\x23\x17\x68\xe8\x22\xe0\x41\x2d\x78\x89\x0e\x95\xb0\x9b\x38\x87\x48\xb4\x80\x18\x48\x0b\x70\xf1\xce\x11\xe1\x82\xfe\x27\x06\x5f\x81\x88\x12\x03\x6a\xbd\x20\x17\xef\x54\x94\x0b\x4e\xb0\xa7\x2c\x40\x2a\xa0\x85\xb4\xe2\x88\x68\x16\x88\x65\xe9\x31\x36\x20\x39\x60\xcd\x95\x24\xc0\x60\x4a\xca\x37\x55\x25\xa8\xee\x39\x1e\x4f\xff\x01\xcd\x9f\xc3\xb3\x05\x95\x37\x5f\x55\xb7\x49\x78\xc6\x3b\xd9\x9b\xe3\x45\x4b\x4e\x91\xb6\x68\xa0\x8c\x05\xc4\xb9\xd6\x57\x81\xd8\x3a\x2d\x7c\x51\xfe\x2f\x1c\x47\x81\xe8\x13\xd4\x6e\x9b\xf5\xd4\x0e\xb2\x8c\xe3\x13\xed\x83\x5c\xeb\x75\x43\x16\xa7\x09\x31\xb0\x77\x2c\xe4\xc0\xea\x40\x6e\xc7\x28\x67\x22\xa5\xcd\x63\xba\xe7\x8f\xec\xb4\x28\x6a\x25\x54\xac\xb5\xf0\xb3\x8e\xbb\xbf\xf0\xcd\x61\x28\xb6\xfc\xc5\x32\xbf\x60\xa0\x27\x16\xe4\xad\xf1\xfb\xd6\x24\x49\xfa\x3c\xf0\x15\x70\x7a\xca\xd6\x53\xaf\x62\x21\x18\x02\x20\x23\xa0\xb4\x13\xea\xe3\xac\x51\xc3\x53\x65\x80\xd2\x4d\xd0\x75\xfb\x56\x4f\xcb\xaa\x76\x93\x93\xbd\xdb\x56\x89\x7f\x74\x89\x4a\x3b\xf4\x37\x71\x16\xf9\xf0\xe5\x5c\x84\x1a\xde\x60\x1a\xde\x53\x1a\x0b\xf8\xcd\xc5\xf8\xa6\x02\x39\x37\xce\x56\xe8\x47\x39\x5b\xec\xc2\x74\x3b\xf9\x02\x34\xab\x5f\x79\x8c\xfa\x9d\x2a\x96\x8b\x94\x8a\x4c\xcb\x39\x15\x95\xe1\x82\x54\xa9\xf4\x3b\xaa\xa9\x54\xd7\x64\xb9\x85\x07\x45\xf2\x83\x22\xf9\x1e\x2b\x92\x3f\x45\xce\x86\xf7\xe4\xc6\xaf\x56\xce\x1e\x4e\x6c\xc0\x3a\xf4\x1c\xe4\x93\xe4\x83\xf8\x8d\x24\xcb\x0a\xc4\xa3\x7e\xdf\x00\xab\x43\x4b\xbf\x4b\xe0\xe7\xe0\x4c\x5e\xb5\xeb\xa8\xa1\x78\x92\x65\xe9\xd5\x4f\x59\xba\xa0\xe7\x72\xe5\xf3\xc1\x03\x37\x7c\x1d\x35\x06\xe0\x57\xab\xc3\x5f\x87\x28\x7e\x73\xb8\x33\x5d\x02\xcf\x16\x49\xab\x7a\x62\x06\x4f\xcd\x41\xc3\x0a\x21\xd4\x85\xba\x75\x91\x2e\xd2\x4b\x92\xb1\xa7\x26\x78\x59\xa4\x73\x5c\x44\x54\xd6\xba\x41\x33\x82\x72\x52\x20\xec\xfb\x69\x16\x40\x98\x55\xf6\x06\x22\x2a\xc8\x3c\x47\x51\x92\x47\x01\xe8\xe0\x59\x13\x73\x92\x2c\xf9\x3d\xf1\x2a\xca\x89\xfe\x7c\x05\x17\x28\x26\x38\x2f\xca\xad\x33\x1d\x0e\xbb\x28\x29\x1d\x2f\x25\x83\xa7\xe4\xab\xf1\x81\x35\x1c\xbc\x6d\x8b\x41\xba\x00\xfe\xe5\xcf\x44\x72\x78\xd5\x91\x2e\x96\x31\x2e\x88\xde\xf0\x55\x54\x5c\xf4\x84\xe2\x3e\x81\x1e\xa7\x73\x82\xce\xe8\xfa\x7c\x5e\x90\xf9\x19\x53\xe0\x9f\xb1\x67\x1f\x67\x28\xca\x11\x84\xdd\x81\x80\xa2\x67\xac\x11\x07\x0c\x1d\xeb\x7b\x60\x94\xd1\x46\x68\xf3\x8a\xd3\xcf\x75\xfb\xa9\x9c\xdf\x4f\xfb\x74\x8e\x72\xd3\xb3\x57\xaf\x58\x5d\xa6\x69\x32\x99\xb7\xf4\x14\x69\xb3\xc7\x75\xf6\x9b\x38\xc1\xa0\xbb\x7b\x13\x27\x2d\x2d\x74\x41\x53\xb6\xe5\x0f\xd7\x48\x00\xfa\x47\x14\x85\x28\x2a\x78\xb6\x72\xfa\x99\xcc\x17\xc5\x0d\x5f\x2d\xff\x3b\x5d\x22\x1f\x27\x2c\x10\xef\x92\x2f\x77\xf1\xf2\x48\x2e\x05\xf9\xa8\x2a\xca\xd1\x19\x2c\x9c\x33\xd4\x12\xba\x26\xa3\x2b\xb4\xdd\x9f\x29\xfe\xcd\x96\x7c\xe5\x13\x5a\xf5\x82\x8e\x6e\x60\x58\xbc\xdf\x3a\x63\x7d\x77\xbc\x23\x63\x00\x1b\x53\xc1\x76\x59\x61\x74\x9b\x2f\xf3\x02\x36\xc0\x04\xb1\xbc\xc8\x98\x73\x2b\xdd\x2c\x19\x6d\xf9\x72\x41\x6f\x83\x68\xbe\x8c\x8b\x68\x11\x8b\x59\x89\xd2\x24\xdf\xc5\x50\x8b\x66\x36\xeb\x60\xcd\xbb\x3c\xba\x63\x3a\x86\x93\x16\xaf\xff\x2a\x0f\x3c\xab\x70\x51\x64\xd1\x6c\x59\xc8\xf5\x26\x27\x2d\xcd\x10\xcb\x1a\x55\xfd\x1c\xf0\x73\x1a\x7e\x85\xf0\x64\x58\x80\x61\xc6\xc5\x42\xdb\x95\xf9\x57\xd4\x85\x13\x07\xea\xb2\x0b\x02\x1f\x1e\xf6\xd2\xf1\x0a\x2b\x02\xb6\x6b\xf9\xfd\x25\xf5\x97\xd5\x13\xbd\x1a\x43\x46\x70\xf0\x22\x89\xeb\xf7\x00\x13\xc5\x4b\xb0\x36\x98\xdb\x19\x2c\xbe\x5d\x2c\x1e\x66\xda\xf8\x57\xad\xc2\xab\xdc\xcb\x0d\x9f\x98\x56\x9d\x2e\xac\xbc\xe1\x13\xd3\x95\x8f\x16\x3b\x28\x13\x07\x7d\x98\x66\x08\x0b\x17\x8a\x98\x04\xeb\xbf\x6c\x5c\xfd\x42\x84\xaf\xbc\x15\xf1\xdf\x85\x9c\xf4\x97\x97\x9c\x21\x9e\xb0\xa4\xf2\xb6\x28\x54\x81\x25\x4a\xf2\x02\x27\x3e\x79\x11\xb6\x4c\x0c\xed\x6a\xf1\x04\x27\x37\x6f\xdb\xe0\x37\xb0\x96\xbf\xee\x2b\x98\x0c\x71\x81\xdb\xd4\xc3\x40\xc3\xb2\xd2\xc5\x40\x83\xdd\x99\x8f\x81\xd6\xc6\x57\xe1\x64\xa0\xf5\x77\x1d\x2f\x03\x7d\x98\x36\x75\x33\x60\x8f\xb4\x4f\xd5\x50\x24\xfe\x45\x9a\xfd\x1c\xeb\xc1\x28\x11\x4a\x17\xf4\xf6\x00\x1b\x93\x69\xa8\x66\x4c\xfa\x0f\x72\x5d\xd0\xd3\x8a\xb2\x20\x0b\x0a\xaa\x9b\xb1\x9f\xc5\x91\xff\xbe\x6c\xc0\x6e\xeb\x89\x69\x5e\x2c\x48\x22\x12\x69\xb0\x93\x2a\x47\xe7\x29\xbf\xf3\xcd\x28\xea\xe2\x82\xf4\xd0\x73\x25\x50\x81\xe1\x9c\x04\x90\xcf\x84\xed\xa8\x7e\x9c\xe6\xfc\x48\x93\xd6\xed\x12\x7d\x54\x3e\x3a\x31\x40\x72\x52\xbc\x82\xd4\x65\x7a\xde\x14\xb8\x2c\x65\xba\x75\x4a\x0d\x0c\xb3\x8d\xfb\xcb\x2c\x23\x49\xf1\x1a\x4c\xe4\x7b\xa6\x41\xca\xb6\xe3\x93\xff\xbb\x24\x79\xf1\x8c\xd2\x57\xe1\xbe\xb1\x82\x14\x35\xf2\x95\x8d\xd0\xdb\x62\x79\xa4\x99\xdd\x52\x36\xc3\xf9\xb7\x72\x26\x0c\x3f\x12\x9e\xa9\x81\x0b\x6c\xa6\x91\xb0\x92\x5e\x37\xcd\x25\x6b\xdd\x9e\xd1\xe0\x2a\x4f\x05\xbe\xa5\xe8\x76\x72\x47\x8d\x93\x3d\xbb\x82\x30\xbc\xeb\x41\x64\xb5\xcf\xcc\xbd\x41\xfb\x6e\x19\x85\x75\x27\x08\xdb\x46\xaa\x2a\xeb\x50\x95\x56\x60\xbb\x97\xee\x51\x45\x8a\x64\xd8\xc6\x7a\x51\xce\xb7\x33\xad\x2a\xf3\xc6\x40\x3f\xa2\x37\x72\x6d\xc3\x36\x51\xb6\x09\x58\x9e\x17\x46\x7d\x7a\x14\xbd\x79\x6b\x5a\x73\x21\xa4\x75\x41\xe6\xf0\x0e\x93\x0e\x32\x13\x64\xc0\x06\xfd\x22\x6c\x95\x4c\xb7\x96\x31\x98\xf6\x51\xab\x7e\x7a\x8a\xba\x83\xb2\x69\x99\x23\x05\x8b\xf2\x2a\x8c\x56\xbc\x62\x0b\x45\xbe\x88\x23\x9f\xa8\x26\x3b\x68\x60\xd7\xdf\x5b\x81\x4b\x0e\x77\x89\x92\xca\x99\x64\xd3\xbd\x20\x59\x1e\xe5\x45\xcb\x68\x50\xe7\x04\x71\x18\x38\x3c\x1c\x60\xe1\x02\x50\x07\x7d\x90\x12\x0d\xa3\x44\xf3\x3d\x02\xfa\x6c\xbf\x1c\xb6\x9e\xf5\x85\xc4\xff\x75\xee\x09\x62\x4f\xae\x5a\xee\x8a\x2b\xed\x7d\xf2\x94\xed\x94\xfa\xf4\x41\xc8\x07\x82\x78\x66\x51\xa5\xdd\x40\x38\xa3\x62\x7e\x7c\x43\x77\xeb\x94\x09\xb6\xb3\xe5\x6c\x16\xc3\x6f\x26\xee\xb1\x91\xd9\x33\x07\x2a\x2f\xd2\x05\xbd\x9a\xe1\x73\x08\x0f\xa1\x8f\x65\xdd\xe1\xb2\xd2\xc3\xaa\xbc\xa3\xd0\xea\xd5\x9e\x4f\xf4\x2b\x1f\x19\x87\x8f\x93\x1a\x4d\x6e\x90\x6e\x36\xa0\x0c\xb9\xb8\x50\x34\x70\x6c\xa3\x55\xdf\x78\xf9\x02\xfb\xe0\x97\x03\xd1\x3a\xbd\x20\xbd\x4a\xbc\xb7\xbd\x28\xf1\xe3\x65\x40\x72\xb6\xd0\x85\x45\x42\xb1\x14\xa3\xc2\x70\x4f\xe1\x6c\x9a\xc1\xbf\x42\x6d\xae\x8d\xf0\x4e\xce\xdc\x46\xa7\x6e\xed\xe1\xe1\x3a\x79\x9b\x9d\xbd\xfa\x01\xe3\x9c\xbe\x57\xe2\xde\x62\x4c\xa0\xe9\xff\x52\x3a\xfd\xe4\x65\xa7\xc1\x0c\x3a\xeb\x69\xbd\x4b\x20\xe6\x6f\xa2\x65\x3e\x82\x69\x78\x7a\xc3\x2e\x63\xa5\xe8\x3e\x38\x47\x57\x04\x5c\x04\x72\x42\xaf\x6a\x91\x7f\x81\xd8\x05\x1b\xb5\x40\x9b\xd3\x56\xe3\x2e\x76\x11\x7b\x9f\x77\xc9\x0c\x3b\xf6\xda\x33\x2e\x13\x9f\xcb\x6d\x4f\x6a\xf0\x95\x4f\x9d\x2c\x5a\xdf\xbd\x4f\x2a\x54\xe9\x76\xa5\x81\xda\xd9\xaf\x24\x2c\xb3\x5c\x3a\x93\x68\x21\x2d\xaa\xa2\x02\x12\x25\x16\x94\xd4\x4a\x1a\x90\xb2\xb4\xb9\x0b\x22\x67\x2c\xed\x3b\xfd\xad\x43\x48\xfd\x9f\x84\x11\x25\x3a\x14\xfb\xf4\x17\xa9\x55\x53\xd0\xb2\x48\x07\x2f\xc3\xe9\x55\xf5\xec\x09\xe8\x47\xf4\xe1\x96\x5e\x8f\x2d\x28\xd3\x4f\x92\x6f\x27\xef\xf4\xad\x7b\x03\x4f\x4a\xa6\x28\xd2\x81\xa0\x40\x87\x11\x3b\xb7\x02\x12\x25\x26\x94\x54\xc8\xe8\x80\xb2\x50\x87\xcd\xb5\xfd\xe7\x9d\xb5\x4b\xac\xe5\x2d\xba\xa9\x1f\xa8\x5c\x00\x90\xe2\x4c\x73\x0a\x35\x73\x9f\xa9\x9c\x68\x5a\x78\x19\x4f\x67\x3b\xdd\x91\x34\xe1\x79\xf5\x91\x27\xd8\x85\xfe\x2d\xa7\x8f\xb9\x98\xd2\x69\xf2\xcc\x90\x21\x1e\x1f\x73\xfa\xa7\x18\x59\xf6\xb7\x1c\x3c\xfa\x53\x8e\x90\x72\x5a\xd5\x1d\x55\xc1\x83\x11\x28\xd0\xf7\xe7\x3b\xe6\xb5\x50\x2b\xe1\x54\xde\x67\xcb\x49\x2e\x7c\x9c\xa0\x24\x2d\x40\xa7\x67\xe8\xf2\xc0\x32\x27\x70\x48\xd5\x5e\x44\x72\x96\xa1\x04\x33\x2b\x64\x4e\x97\x6b\x11\xcd\x09\x15\x99\x30\x3a\x7b\xc5\x55\xcb\x4a\xc7\x53\x4a\x7f\xb1\x85\xae\x7d\xa3\xf3\xa6\xd5\x29\xe8\x84\xf6\xdd\xd4\x4a\xf2\xae\x06\x68\x76\x63\x9c\x54\xf3\x05\xd3\x0f\x82\x08\xb7\x1b\x9a\x8d\x1d\xcf\x45\xb4\x0e\x70\x67\xaa\xad\x53\xbe\xa9\xaf\xb3\x91\x6a\x84\xfd\x67\xa4\xc5\xd0\xf3\xb2\x99\x6e\xb2\x8d\x1b\x40\x62\x39\x78\xa6\xcf\x6c\xd5\x3d\xc3\xba\x35\x69\xc4\xac\x4e\xc4\xc5\x1a\x5a\x15\x27\x87\x5e\x65\x64\x16\x32\x71\x82\xc9\xd3\x4d\x4f\x2c\x47\x2b\xb7\x3b\x16\x45\x55\x9e\xcc\xba\x6d\xd1\x75\x30\x22\xa4\xcc\x23\xe5\x33\x00\x19\x6e\xc4\xae\xfd\x1f\x21\xcd\x58\xe0\xd8\xfb\x91\x12\x4f\x1c\x2e\xca\xba\x99\x40\xfc\x65\xde\x3a\xb9\x17\x82\xed\xd0\x4d\x2b\x86\x53\x75\x0e\x98\x95\xda\xb6\xeb\x34\xdb\x9f\xb5\xc2\x76\x73\xae\xb1\x5c\x6f\x54\xb4\x61\x27\x4f\x42\xdc\x50\xe9\x40\x2d\x5d\xa8\xad\xcb\x89\xf2\xe1\x76\xa4\x3c\x42\xa8\xb8\xc8\xd2\x2b\x94\x90\x2b\xf4\x73\x96\xa5\x59\xcb\xb1\x4e\x2f\xcb\xdb\x8a\x54\xfe\xab\xec\x4d\x2a\xa3\x6e\x79\x53\x04\x7f\x09\xb1\xd5\x9e\x32\x43\x49\xcf\x2b\xd3\x0b\x29\x39\x79\x14\x54\x5b\xfd\xa3\x7d\x7b\x15\x25\xe7\x20\xf1\x78\x9e\xe3\xeb\x6f\x4a\x22\x52\x9a\x12\x48\x93\x9a\xce\x17\xcb\x82\xfc\x24\x1b\xe0\xf7\x52\x0e\xb2\xbf\x8f\xfe\x91\xca\x24\x48\x82\x0c\x9c\xdc\x08\x4b\x36\xbb\x13\x87\x11\x89\x03\xd3\xac\xcd\x47\x1a\x16\x1d\xd3\x06\x47\xf9\x4f\x51\x56\xdc\x30\x85\x71\x8f\x87\xab\xf8\xf8\xd1\x90\x0d\x6d\xf5\x9d\xb6\x87\x9b\xea\x17\x35\x22\x1a\x48\xcb\x56\xbc\x38\x14\x25\xa5\x0e\x9b\xf7\xb9\x5b\xd7\xf0\x33\x27\x9d\x72\x28\x91\x66\x0f\x35\xca\x2a\xc9\xf5\xdf\x67\x38\x5f\x67\xdc\x6a\x57\x26\xf5\x92\xcc\xa5\x03\x84\x1c\x60\x4e\x35\x1d\x10\x64\x2a\xe8\x84\x52\xcd\x5c\xf1\x1b\xac\x89\x92\xc5\x7e\xad\x85\x21\xc5\x0e\x6d\x51\x20\x5b\x83\xa5\x77\x7a\x85\x82\x0f\x8e\xe9\xee\xe0\xc4\xea\xbc\xc4\xf0\xe8\x91\xc5\x1b\xf6\x08\x58\x4b\xa9\xac\xf6\x13\x1c\x60\x91\x5b\xc3\x8c\x36\xf9\xee\x67\x25\x77\x26\x59\xee\x0d\x2e\x6a\x2b\x88\x5d\x2d\x3c\xac\x78\xf5\xc3\xdf\x3e\x31\xbf\x2e\xaf\x7c\x7b\xa0\x27\xa2\xf8\xcb\xba\xf7\xc4\x91\xff\xde\x7a\x35\x23\x4d\x02\x7c\x79\xb8\x34\x25\xe6\x5b\xc7\xea\x91\x51\x7b\x87\x14\x8f\x7f\x2c\xcd\xee\x7f\xd3\x28\x69\x51\x49\x9d\x0a\x54\xc6\x38\x3a\x77\xe8\x79\x94\x44\xf3\xe5\x9c\x5e\x16\xc4\x5d\x5d\xd9\xa4\x7a\x42\xe9\x83\xbe\x39\x65\xd9\xc8\x1e\x3d\x42\xdf\xa8\x7b\xfd\x8f\x2e\xd8\x9e\x1f\x47\x24\x29\x18\xc4\xd4\xc8\x95\x52\x3f\x2f\x6e\x99\xcb\x12\xe9\x1a\x09\x74\x77\x90\x17\x4d\x01\x60\x13\x71\xcd\xfc\xfd\x1b\x78\x44\x6e\x59\x84\x33\x05\x52\xc8\x12\xb9\xc8\x48\x9e\x93\xc0\x9b\xea\x53\x92\x2e\x48\x82\x7e\x44\x1e\x3d\x2a\x3c\x34\x45\x1e\x1c\x92\x96\xe8\xaa\x82\x28\x4b\x95\x88\x4c\x3d\xd7\x37\x41\xf9\xd2\x60\xcf\xf1\x2d\x34\x8c\x8c\xf4\x2a\xc9\xdd\x34\xcc\x49\xb2\xec\x42\x92\x44\xd0\x92\x7c\xfc\x88\x3c\xcf\xcc\xb7\x67\x62\xba\xc0\xf9\x22\x5d\x2c\x17\xde\x94\xd3\x6f\x3f\x52\x93\x6f\x93\xca\xea\x61\x1b\x94\x89\xa9\x96\x52\xbe\xf4\xe8\x8d\xad\x5e\x39\x08\x1f\x3f\x2a\x05\x84\x1c\x10\xdb\xa4\x6a\x23\x31\x05\x5a\x7d\x87\x72\x68\x95\x94\xb0\xd7\x94\x75\x59\x30\x52\xaf\xd3\xe4\xbe\xc1\xa5\x67\xd7\x19\x89\x7e\xe4\xa7\x0e\xdf\x2c\xd8\xe5\xcb\x16\xb3\xdd\x57\x83\x1a\xc1\xdb\x2d\x74\x83\xc0\xed\xd2\x01\xeb\x58\x0b\x96\x36\x84\x79\x74\x79\xda\x26\xd9\x78\x68\x36\x12\xb7\x37\xd8\x32\x98\x5b\x7f\xf9\x2d\x6d\xc3\x3b\x60\x14\x4c\x2b\xd6\x82\xc9\x4a\x4a\xdd\xee\xd8\x62\x2d\xae\x63\xfa\x7a\x73\xc9\xd9\x8c\xa9\xdb\xbf\x8d\xe9\xd0\x3f\x18\xfc\xaa\x14\x87\xf6\x25\x8a\x7e\xf8\x35\xca\x45\xa4\xfd\x1a\x1b\x9b\x44\xd1\x33\xea\x38\x6e\x65\x6c\x67\x89\xa3\xbc\x98\xa5\xd7\x5e\xed\xb5\xec\x77\xbc\x20\xd9\x3a\x6d\xab\x0a\xe5\x86\x79\x5a\xcc\x86\xf7\x77\x44\xcf\x4b\xee\x95\x6e\x9f\x9c\x16\x68\x05\x05\xf2\x24\xfd\xd1\xf9\x99\xe5\x26\xe2\xdb\x62\xdb\x1a\x86\xbd\xaa\x31\x01\x39\x5f\xed\x26\xfc\xaf\xca\x57\xb8\x9a\x75\x60\xe5\x33\x5c\xdd\x2d\x46\x0f\x77\xa7\x8a\x3d\xd7\x8b\x4e\xa3\x89\x5d\x3c\xe9\x3c\x78\x08\xa3\xf9\x10\x46\x73\xeb\x61\x34\x0f\xd1\xa0\x1f\xb3\x98\xbb\x13\x3d\xb0\xa5\xfd\xea\x4a\xf6\xd4\xf8\xf0\x49\x42\x59\xee\xd9\xb4\xb8\x82\x58\xda\x8f\xb9\x8c\xdf\x8d\xc3\x56\x1a\xb5\xca\xf1\x2a\x0f\xef\xe3\x12\x7c\x95\x60\xff\xfd\x0c\x67\x95\x4f\xe3\x8e\x3e\x73\xc2\x51\x41\x60\x65\xce\x51\x01\xf0\x8c\x07\x7a\xab\x7a\x68\x38\x69\xd2\x11\x0b\xd9\x2e\x3b\xc4\x9b\xb8\x0f\x29\x48\x8f\xee\x17\x67\xae\xce\x1f\xfa\x10\x36\xf5\xe1\xb5\xfb\xc3\x6b\xf7\x46\xaf\xdd\x3f\x47\xaa\xdd\x3f\xe9\xfb\x7a\x68\xf1\xe7\x4b\x92\x14\xf4\xe6\x45\x12\x52\x75\x2a\x8e\x47\x35\x75\x56\xf6\xc9\x80\xfe\xa4\x69\x83\x8b\x0c\x27\x79\x04\xef\xe4\xaa\x1a\x51\x5b\x27\xe8\x6b\x9e\x5c\xe1\x9b\x15\x83\x31\x3c\xee\x57\xd7\xa9\x23\xb0\x04\xbc\x56\xc8\x5c\x76\xf6\xc7\x51\xe5\x43\xf7\xe1\xd1\xc0\x84\xab\x95\xca\x29\xc0\x66\x22\x85\xab\x46\x6d\x53\xd6\xf9\xff\x10\x3a\xe0\x4f\x1d\x3a\x40\xde\xfe\x69\x79\x05\x81\xfc\x7d\xd9\x7a\x88\x5f\xcb\xc5\x2a\x5f\x49\x56\x30\x7a\xbf\x71\xff\x1d\x38\xb7\x38\x14\x0a\xfb\x4f\x4b\x96\x3e\x6f\x9b\x14\x4b\x9c\x3b\xcb\x61\x4d\x2b\x9e\x2f\x8b\x02\xb6\x3a\x96\x2c\x3a\x5f\x60\x3f\x4a\xce\x7b\xcb\x24\x2a\xd0\x77\x68\x74\xc2\xc1\x0a\xf0\xa9\xfc\x40\xff\x9d\xa2\x3e\x73\x65\x87\x91\x4a\x8b\x22\x9d\xc3\x27\xf6\xa7\xf1\x35\x8b\xce\x2f\x0a\xf8\xf8\xdf\x65\x5e\x44\xe1\x0d\xdf\x03\xa6\xc8\x0b\x63\x72\xdd\x25\x49\xe0\x29\xe8\x98\x84\x75\xc0\x79\x81\xb3\x42\x03\x2f\xd2\xc5\xab\x05\xf6\x89\xa2\x8b\xf7\xc5\x22\x4e\x01\x09\x0a\x6d\x38\x20\x53\x81\xc1\xcf\x32\x14\x25\x4f\x01\xd1\x5f\x65\x18\x9f\x24\x6c\x34\xd9\xcd\x88\x01\x79\x93\xfe\x5f\xb9\x75\x82\xa3\x06\x37\x3f\x5e\x04\x67\x54\x98\x66\x73\xb0\x63\xe0\x24\x8f\x71\x41\xfe\x57\xab\x3b\xe9\xff\xb5\xed\xb1\xf4\xdc\x76\xba\xf1\x2c\x4d\xb5\x5c\xe3\x7f\x70\xeb\x0c\x9b\x40\xf6\xab\x97\xf3\x4d\x57\x68\x01\x17\x29\x63\x2a\x3a\x98\xd1\x35\x09\xa4\xb5\x84\x9b\x1a\xf8\x20\xcb\x62\x46\xb9\x34\xef\x70\xba\xe5\xef\xd2\x0c\xb1\x8e\xcb\xea\x38\x8e\xce\x93\xe7\x05\x99\xe7\xea\x1b\x53\x36\x32\x08\xa6\xa8\x7e\x9d\x2e\x9e\xc1\xb7\xe9\x2a\x03\x18\x47\xcb\xae\x2e\x53\xf4\xa6\x48\x17\x22\x05\x3a\xef\xf7\x2c\x23\xf8\xfd\x22\x8d\x92\x22\xef\x2d\x17\x2d\x6f\x1e\x78\x6d\xa5\xcd\x95\x15\x19\x2d\xbc\x6e\x5b\x27\xe6\x29\x30\xc7\x86\xf4\x30\xce\xda\x36\x49\xaf\xd3\xc5\x4b\x36\xf0\xeb\x0f\x4f\x87\xcd\xd9\x5a\x24\x71\x76\xd5\x98\xd3\xc4\x09\xdc\xdf\xd1\x96\x4b\xf5\x38\x6e\x46\x37\x1b\xc6\xad\x93\xae\xed\x03\xab\xa8\x7f\x9d\x2e\x7e\x05\x54\x9b\x8c\x38\x25\x62\x2d\xaa\x1d\xdb\x81\x73\xc4\xe5\xd6\x53\x3d\xe0\x1b\x51\x2d\xc6\x7b\xcb\x84\x1b\xe3\x5d\xa2\x9d\xed\x69\xb7\xeb\x1d\xb5\x2f\xb2\xe8\x3c\x4a\xf8\xc6\x7a\x91\x66\xd1\x1f\x69\x52\xe0\xf8\x0e\xaf\xcc\x01\xa2\xf5\xc6\xa3\xf4\x79\x6f\xdb\xf5\x19\x0d\x5b\x6f\xc4\x2e\xd6\x00\x12\x06\xa7\x0e\x90\xbd\x60\x67\x79\x60\x2f\x49\x06\xa1\x94\xb6\xd0\x93\x22\x5d\x6c\xb7\x23\x6c\x1e\x9b\xf4\x84\x4e\xe7\x36\x92\x57\x60\x26\xaa\x28\x97\x3c\x2d\xde\x93\xcf\xce\xaf\x3f\x75\xa8\xd6\x52\x7f\x61\x05\xcb\xd8\x25\xe2\xaa\x74\xa6\x75\x1b\x20\x18\xfb\xaf\x20\x85\x2d\xce\x2f\x69\x71\x7c\x31\xcb\x83\xed\xd9\xa5\x8c\x25\xf0\x99\xce\xfe\x3c\x8a\xe3\x28\x27\x7e\x9a\x04\x10\x86\xec\x0a\x47\x05\x9a\x91\x30\xcd\x88\x15\x6f\x2d\x88\xf2\x79\x94\xe7\x54\x46\x17\x88\xa2\x1c\xcd\xc8\x05\xbe\x8c\xd2\x8c\x07\x68\x62\x0e\x2a\xb3\x1b\x71\x35\x66\x9e\x87\xec\x05\xc4\x32\x8e\xcf\xf4\xe8\x27\x22\x96\xda\xdf\xa3\x80\x88\x2b\x47\xe5\x68\xf3\xd8\x1b\x1b\xf6\x44\xd1\x8e\x70\x48\xe5\xe4\x65\x4e\x32\x66\xa3\x63\xab\x9b\x77\xe9\x79\x88\xce\x6c\x92\x0c\x97\xe4\xc4\x2b\x50\xbe\x20\x7e\x14\x46\x24\xe8\xa0\xa8\x40\x41\x4a\xe0\x25\xc1\x85\x1a\x98\x95\x58\x14\x0a\x34\x5b\x16\xe8\x2c\x23\xf9\x72\x4e\x4c\x70\x68\xab\xc3\x10\x5e\x11\x39\x9e\x45\x5a\xc6\x8d\xf6\xd1\xf0\x0c\xcd\x73\x3d\x14\x8c\x8d\x70\xad\x81\x7d\x1e\xc2\x23\x96\xab\x28\x67\x73\x57\xe0\xf7\x32\x7b\x0d\x82\x78\x7c\x10\xa5\x45\xbc\x8e\xb3\xa3\xb6\xc8\x17\x30\x4b\x3b\xb6\x0c\x1f\xa0\x7f\x2b\x87\xd5\xa8\xe8\xa0\x24\x55\x1b\x10\x17\xec\xcf\x1c\x41\xb2\x98\x5b\xb2\x1e\x64\x6c\xd3\xd0\x75\x52\xc9\xb1\xe1\xf6\x2c\xea\x6f\x67\x87\xe6\xd8\xda\x9f\x33\x8c\x9c\x1d\xeb\x68\xb3\x20\x71\x30\xaf\xfc\xfc\xa4\x93\x2b\x9d\x41\xfd\x34\xc9\x89\xbf\x84\xe7\x35\x62\xa6\x73\x14\x66\xe9\x1c\x61\xf1\x66\x9c\x4d\x2f\x8b\x83\x96\x83\x5b\x28\x43\xfa\xbd\xa8\xb0\xff\x43\x07\xe1\x80\x0d\xc4\x7b\x72\x63\x04\x2c\x22\x49\xbe\xcc\x08\x04\xc4\x5f\x50\x3c\x49\x81\x8a\x8c\xe0\x62\xce\x13\x52\x11\xec\x5f\xa0\x39\xc9\x73\x7c\x2e\x62\x2f\x91\xde\x79\x4f\x21\xa7\x18\x4f\x3f\x70\x88\x5b\x44\xdb\x92\xc1\x22\x3b\xfc\x11\x34\x7c\x43\x73\x7c\x83\x96\x8b\x00\x17\xa4\x1b\x25\xdd\x45\x4c\xef\xe5\x38\x61\xb1\xaa\x50\x48\x70\xb1\xcc\x48\x8e\xf2\xa5\x7f\x81\x70\x5e\xda\xe0\xa0\xfa\x8c\xd0\xe5\xe1\x13\x23\x62\x1e\xbc\x82\x95\x3a\x93\xf7\xe4\xa6\xc5\xdf\xe6\xd1\x7f\xe0\x1d\xa9\x9a\x6d\xfa\x53\x18\x41\xc1\xdf\x9c\x5b\x02\x17\xc2\xce\xd4\xbb\xc0\xf9\x8b\xab\x44\x88\xe2\xcc\x97\xc5\xc2\xa7\x39\xa4\x97\x5c\xd1\xe1\x29\xeb\x99\x87\x1e\x4b\x68\xf4\x18\x79\x67\xe8\x02\xe7\xb0\xd6\xd0\x7f\x3c\x9c\xdc\xfc\xc7\xeb\xc0\x06\x76\x85\xd9\x63\xaa\x45\x96\x5e\x46\x01\xe3\x4c\xa8\x6c\x10\x0c\x18\x7a\xe8\x77\x9c\xe7\xda\xcb\xce\x34\x83\xc7\x0f\xec\xdd\x22\x3b\x1d\x3c\xdd\x3f\xa8\xbc\xe5\x8b\x89\x70\xc9\x6a\xfc\xdb\x17\x24\xac\x59\x19\xbb\xf8\x81\x06\xbb\xb2\x54\xd8\xc1\x3b\x11\x7a\x98\xc9\x33\x88\x45\x3c\xfb\x99\xa9\x14\xd6\x1b\x0b\x97\x36\x74\xc3\x91\x71\xa0\xda\xce\x38\x95\x11\xd7\x8f\x9a\x8c\xa9\xd6\x70\xcc\xa2\xe4\xfc\x61\xd8\xdc\xc3\x46\x77\x00\x18\x37\x7d\xef\xe2\xc3\x46\x82\x87\x51\xab\x5b\xa2\xd7\x51\x61\x73\xdb\x75\x54\x3c\x8c\x59\xf5\x02\x75\x8f\xd8\xc3\xf2\xac\x5f\x9e\xd7\x51\x61\xad\x4e\x28\xf9\x2a\xc7\xac\x1c\x07\xf4\xb7\x74\x99\x13\x7e\x34\xde\x21\x9c\x28\xa0\xf9\x95\xe0\x9a\x70\xbc\xcd\xf2\x6f\x9a\x77\xa7\x8c\x79\xbd\xc3\x15\x96\xca\x89\x2a\x84\x8e\x10\x81\x6e\x16\xfc\x46\x7e\x66\x3a\xcf\x43\x6c\x6f\x91\x86\x34\x27\x05\x62\xd1\xfb\x22\xd6\x82\x1d\x99\x49\x5c\x2d\x2f\x22\xff\x42\xaf\x28\xae\x79\xa6\x5a\x08\x9d\xa5\x0b\xc2\x2f\xb1\x06\x31\x2c\x2c\x00\xce\xe1\x86\x8b\x33\x3c\x27\xf4\x7a\x0d\x31\x4d\xe1\x99\x9a\x08\xd5\xee\x42\x9f\x91\x7c\x41\x2f\x06\x20\x2e\x5a\x7d\xe1\xe4\x85\x69\x86\xc8\x35\x9e\xd3\x4b\x04\xcc\x00\xbd\x1f\x9c\xf9\x71\xe4\xbf\xc7\x57\xf8\xe6\x6c\x57\x19\x4a\x59\x97\x78\xd4\xf5\xe9\xd9\xb7\x45\x34\x27\xe9\xb2\xf8\xf6\x0c\xb5\x1c\x57\x7b\x72\xbd\xa0\xd3\xd9\x46\x69\x36\x45\x67\xdf\x4a\xf2\xbe\x3d\xd3\xf8\xc5\x7c\xe7\xd0\x98\x63\x54\xd4\x66\x35\x19\x51\x0e\x4f\x2b\xb4\x15\x0e\x0f\x2d\xb6\x1c\x33\xb9\x74\x25\x2f\x05\x7b\xb5\x20\xd6\x8f\xa4\xac\x56\xaf\x2b\x9c\xab\xda\xd6\xd6\xdd\xb9\x2c\x57\x81\x0d\x37\x2d\x13\xcb\x76\xf6\x2b\x03\xa7\x43\x33\x17\x88\x7b\x22\xe5\x7c\x73\x6f\xef\xd0\xa5\xac\x6b\xb9\xb4\x20\xc2\xf4\x56\xc9\x94\x4a\x37\xf2\xfa\x8c\x38\xd3\xb2\xd0\xb9\x71\xac\xa1\xca\x3b\xf4\xde\x15\x25\x41\x74\x19\x05\x4b\x58\xa3\xa0\xa8\xc3\x09\x8f\x21\xe5\x9a\x04\xa5\x4a\xda\xf4\x18\x51\xce\x0a\x77\x3e\x46\x24\xaa\x6d\x1f\x23\x02\x71\x5b\x1a\x8a\x34\xc7\xed\x8d\x43\xe8\x0a\xa3\xf8\xca\xf8\xb9\x1c\x70\x77\xc1\x73\x85\x93\xf7\x57\x11\x39\x97\x77\x76\xad\xb0\xb9\x62\x80\xb6\x15\x33\x77\x7f\x1f\xfd\x93\x1f\x7e\x10\xe6\x9b\xe9\xb9\xc0\xaa\x74\x49\x90\x70\x97\xc8\x7b\xd2\x96\xc9\x44\x35\x47\x38\x5d\xba\x9e\xb3\x27\xfc\xf4\x41\xec\xb5\x96\x19\xc5\x4e\x89\x36\xeb\xc4\x21\xd4\x45\xa2\xea\x40\x88\x0a\xc6\x19\x0e\x11\x19\x84\xfc\x8e\x97\x39\xa9\x48\x5c\xab\x04\xa7\x0d\x88\x84\x7a\x2b\x88\x04\x98\x06\x44\xbe\x04\x2d\x79\x05\x95\xd2\x67\x72\x3d\x22\xf5\x53\xbe\x9a\x4c\x1d\x4a\x04\xef\xf4\xa4\xd8\xe0\xd5\x87\x2a\x84\xb1\xad\x88\x14\xec\xc7\x04\x67\xaf\xd9\xbe\xdf\x72\x70\x4d\x55\x08\x62\x3a\x10\x35\xb9\xa3\x75\xea\x4b\x1a\x4d\xfe\x6e\xd0\x0e\xca\x61\x46\xba\xb4\xed\x11\x10\x3b\xc2\x19\x2a\x46\x8b\x00\x29\xa8\xa6\x1d\xca\x56\x20\x34\x42\x44\x98\x31\x18\xf5\x28\x0c\x15\xb8\xeb\x7b\xf8\xf1\x23\xea\xb7\xd1\x77\xa8\xdf\x9b\xd4\x4f\x8d\x3a\x46\xd8\x8d\xab\x61\x3c\x67\xb9\xe8\xa9\xa4\xf7\x69\xc3\x31\xca\x83\xc9\x88\xc5\x28\x85\xb1\x7f\x47\x71\xfc\x5b\xba\x4c\x8a\x8a\xb8\x8c\x65\x40\x3b\xeb\xb8\xce\xf7\x0b\x92\x98\x41\x81\x1a\x8c\x82\x1c\x69\x50\x06\x23\x27\x95\x3f\x45\x41\x23\x22\x05\x9c\x45\x63\x03\x12\x4d\x6e\x59\x83\x34\x3a\x2e\x2f\x89\x4f\xa2\x4b\xc2\x43\xde\xad\x1e\x47\x1d\xbe\x95\x90\x6b\x26\x58\x9b\x34\xcb\x62\x16\xc6\xe0\xd1\x23\xfd\x99\x35\x1b\xc8\x26\x43\xcd\xd2\x45\xad\x39\xd6\xff\x04\xeb\x47\x83\xc1\x66\x80\xad\x45\x46\x2e\x1d\x5d\x90\xc5\xac\x0b\x74\x43\xa8\x99\x89\x15\x13\xb5\x72\xaa\xdc\xa1\x8b\xf4\xed\xb2\x72\xb7\x44\x46\x14\xa3\x26\x33\xfe\xcf\x64\xde\x74\xd1\x70\xd0\xaa\x3d\xbc\x7a\x0b\x67\x92\xd3\xfe\x3e\x82\x8e\x32\x3b\x2b\xbf\x5d\xe7\x28\x20\x31\xd8\x99\x40\x13\x29\x64\x0c\x30\x46\xa1\x8b\x28\x20\xf9\x5e\xb9\x03\xf6\xd0\x55\x10\x5f\x1e\xe1\x86\x31\x59\x4b\xbb\x6a\x59\xd8\x44\x3f\xa0\x3e\x65\x65\x25\x2a\xf6\xdf\x9a\x07\x05\xfa\xd1\xfc\x38\xe5\x01\x9c\xaa\x76\x1c\xe3\xa4\xa5\xfb\x78\xdd\x36\x7f\x5a\x3e\xc8\x2a\x82\xf9\x36\xe5\x1b\xa7\xd8\x96\x93\x42\x54\x75\x1d\x0e\x7a\x9c\xe1\x61\x65\x3f\x8c\xcf\x4d\x7a\xe2\x3a\x14\xcd\x53\xd1\xdd\x58\x8b\x49\x99\x1e\xbf\x4c\x6a\xb2\x49\xa7\x3c\xa5\x2b\x06\x18\xce\x51\x9b\x7d\x99\x38\x03\x57\x5d\x60\x64\xa9\x13\x63\x3e\x1a\xb9\x72\xd3\x48\xce\x95\x3b\x89\x38\xb8\x04\x96\xd4\xae\x78\xc1\xd3\xff\xa1\xab\x28\x09\xd2\xab\xde\x9e\x6c\xf0\x25\x01\x87\xee\xba\x26\x93\x14\xc5\x69\x72\xae\xfb\x88\x34\x6d\x9c\x35\x07\x4e\x1e\x17\xe9\x55\x02\xd1\xb0\x7b\x8e\xe5\xb6\x41\xb8\xe3\x15\x41\x8d\x7d\xf1\x0e\x80\x8f\x3e\xfc\x76\x84\xe7\xd5\x1d\xbb\x34\x70\xad\xd4\x08\x38\xcb\xfd\xa0\x54\x8c\x5e\x1d\xb2\x27\x3e\xeb\x55\x94\x23\x58\x45\x25\x05\x60\x47\x65\xb6\x36\x88\x77\x6e\x46\x32\xa3\xbe\x94\x44\x4b\x2d\xd6\xae\xfd\x6d\xc3\xe8\xce\x2b\x22\x36\x4b\x6f\x89\x15\xd1\x9f\xcb\xba\x14\x55\xa1\xfc\xcd\x88\xbf\xcc\x6d\xde\x2a\xfc\x32\x2b\x30\xc3\x7c\x89\x9b\x9f\x0c\x5c\x0c\x05\x0e\x18\x9e\x7f\xd6\x00\xe3\xa9\xda\x2d\x48\x3d\x0c\xb5\x2c\xb2\xe0\xae\xa3\xc2\x00\xba\x8e\x8a\x32\x84\xdd\x24\x2b\x2a\xc3\x59\x0d\x42\x89\x09\x65\x5c\x72\xdf\x95\xaf\xa7\x0e\x68\x71\xdb\x7c\x57\xbe\x27\x9a\xd0\x56\x32\x96\x77\xae\x1d\xd1\xa8\xb1\xd0\xf9\xc7\x0e\x6f\xe3\xd2\x8f\x2a\x68\xd7\x57\xbd\xb6\xba\x4c\x98\x81\xc5\x35\x8d\xa0\x4e\xc9\xc6\x81\x9f\x99\x12\xae\x83\x3c\x7d\x8d\xc2\x6f\x6b\xd9\xb1\x08\xcc\xf6\x92\x72\xc6\x8b\x66\x21\xa2\x8d\xd0\xd1\x65\x06\x87\xb8\xd0\x8c\x8f\x59\xcc\xe7\x9f\xd9\x53\x0e\xf9\x67\x94\x9c\x6b\xbf\x58\xa8\x69\xc6\x13\xea\x2f\x05\x03\xac\xc2\xfe\x56\xcc\xa0\xfd\x86\xe9\x66\xbf\xf5\xe9\x84\x92\x05\xa3\xdd\x35\x25\x26\xed\xa5\x00\xd3\xdf\x34\x92\xbf\x1d\xd1\x26\x8d\x60\x77\x85\x31\xd7\xb9\xa6\x3e\x42\x28\x4a\xa6\xc8\xe4\x2c\xbc\x58\x10\x9c\xd9\x99\x10\xf8\x09\x3d\x75\x6c\x33\x0a\x48\x3a\x85\x94\x36\x07\xdd\xf5\xc1\xb5\x25\x68\x36\x7e\xc7\x46\x20\x4c\xd9\xf6\xf2\xd7\x0c\xb6\x8e\x45\xaf\x2c\x93\xc0\xb6\xfc\x35\x2a\x8f\x45\xf2\xec\x02\x53\x91\xef\x17\x7e\x28\xf2\x28\xa7\xee\x8b\x76\x47\xa2\x12\x31\x86\x6e\x4f\x9c\xc3\xab\x1e\x9a\xca\xed\x9f\x4a\x53\xf5\x01\xbc\xec\x37\xa7\x2a\x84\x57\x55\x74\x26\xe5\x88\x24\x36\x6a\xe9\x46\xce\xcf\xe9\xdb\x8e\x73\x7b\x68\xb7\x4f\xdc\x7c\x51\x8a\x54\x4b\x99\xcf\xdc\x22\x8c\x0b\x9f\x5e\xb1\x71\x08\x31\x13\x9f\xfb\xe8\x2a\xed\x53\xa5\xc1\x95\xdf\x94\xac\x68\x5f\xbd\x36\x23\x8f\xbf\x2e\x5e\x27\xc4\x19\x0a\xa2\x8c\xf0\x91\x57\xa2\xcc\xe9\x29\x02\xaf\x6c\xf4\x23\xcf\xa2\x82\xa6\x90\x54\x05\x5e\xa1\x98\x3d\x6d\xaf\xdb\xd5\xcd\x82\x49\xba\x9e\xb7\x97\xfb\xf9\x01\xb1\xd4\x40\x53\xe4\x31\x39\xd3\xeb\xa8\xd0\x7e\x25\x85\x5e\xc7\x15\x60\x90\x89\xdb\x9b\x84\xa4\x74\xbc\x39\x77\xcd\xc4\x07\x11\xb1\x90\x42\x96\xe3\x12\x82\x4a\x75\xe3\x10\xe7\x76\x54\xcc\xdd\xc4\x37\xcf\xd2\x54\x85\xcb\x7c\xc3\xcf\x45\x88\x8a\x67\xec\x52\x78\x11\x15\x38\x8e\xfe\x20\xbf\x44\x59\x5e\xfc\x4a\x8a\x82\x64\xed\x96\xe0\xb2\x76\x43\x78\x25\x0c\xb7\xdf\x6a\x01\x35\x4b\xf1\xd0\x4d\xc7\x05\xa7\xd2\xbf\xa2\x0a\x77\x52\x70\xaa\xe0\x8d\x1a\x22\x4c\xa2\xd5\xb6\xe2\x7a\xad\x58\x0b\x08\xbe\x67\x2c\x01\x47\x54\x37\xbe\xcf\xad\x0e\xe9\x26\xec\x35\xfc\xab\x7e\x16\x9a\xcf\x51\x3e\x68\xef\x33\xc4\x73\x88\x8e\xf1\x02\x45\x3c\xa7\x60\xbc\xe6\xb2\x62\x32\x16\xe1\xcf\x2e\xf5\x88\x0d\x3d\x61\x84\xed\x09\x07\xc1\x57\x7e\x46\xc4\x01\x4c\xe0\x9c\x73\xc3\xc7\x04\x5f\x4a\x70\x16\x65\xc8\x15\x83\x8e\xe5\x32\x50\xb1\x25\x14\x07\xb2\xa7\xd2\x1d\xf4\x01\x85\x71\xb4\x98\x8a\x04\x13\x2c\xe0\xa5\xf7\xdb\x32\x12\x43\xe4\xa1\x5b\xcd\x56\x55\x0e\x81\x75\x7c\xbf\x02\x0d\xf1\xd8\x0d\x05\x59\x2c\x2a\xc3\x5b\x1c\x1e\x7f\xee\x00\x58\x8c\xbc\xea\xf8\x57\x05\x59\x54\x46\xa8\x38\x68\x14\xf4\xaa\x20\x8b\x5d\x51\x5e\x4b\xf6\x53\x08\x8c\x5b\x15\xd5\x61\x34\x6c\x4a\xfc\x53\x1e\x60\x77\x37\x5d\x60\xd8\x6b\x3b\x52\x1f\x28\xe4\x80\x45\x2c\x69\xd2\x93\x5d\xc6\x1d\x53\xe8\x6b\xfb\xf2\x2b\x9e\x91\xb8\x92\xa1\x0e\x9b\xf6\x04\xd0\xec\xaa\x1f\x80\xfc\x1e\x44\x4e\x1b\xf6\xb7\xb8\xa1\xd5\x84\xfd\x54\xb8\x79\x62\x1a\xa8\xfe\x67\x0f\xb4\xf6\xe9\x43\x53\xdd\xab\xd0\x6e\xcc\x7f\xe6\xcf\x1d\x32\x6b\xc7\x51\xab\xee\x53\x60\xa4\x17\x59\x24\xb2\x2f\x55\x8b\x0a\x4d\xc3\xda\xe8\xc8\x76\x16\xcf\xa6\x26\x48\x4a\x18\x93\xeb\x29\xf2\x06\x68\x00\x0a\x6e\x23\x18\x49\x1c\x25\x44\x41\xaa\x80\x28\xb3\x38\xf5\xdf\xcb\x7b\xce\x2c\xcd\x02\x92\x3d\x4b\xe3\x34\x13\xb1\x56\x16\x38\xa6\xb7\x87\x1e\x45\xd0\xcb\x99\xd8\xa2\x23\xa6\x24\xfc\x4b\x0a\xc8\xa2\x81\x39\xce\xce\xa3\x84\xc5\x6b\x18\x0c\x3b\x68\x7f\x1f\x5d\xe0\x38\x44\x91\x2f\x25\xfb\x05\x0e\x02\x50\xd6\x78\x7d\xd4\x87\xec\x22\x8e\xe8\x3c\x8f\x91\xb7\xb8\x2e\x75\xe4\xef\x9a\xf0\xfd\xc1\x20\xfd\x75\xba\x78\xc5\x82\x59\x7b\x79\x1a\x47\x81\xd5\xb3\xd7\xe9\x82\x07\xae\x1e\xd8\x38\xcb\x7d\x60\x55\x68\x1f\xea\x50\xd2\xef\x02\xa7\xf8\x32\x8f\x92\xbf\x13\x16\x3d\x62\x38\xd6\x1b\xc2\x31\x84\xea\x2d\xa2\x4b\x02\xa7\xdd\x4b\x63\xfe\xb4\xf8\x35\x78\x96\xa7\xf1\xb2\x50\x01\xff\x21\xf6\x8f\x73\x80\xc6\x66\x38\x1b\xcf\xc7\xb1\xdf\x9a\xf4\xff\x8a\x1e\xa3\x61\x7f\x71\xdd\xf6\xac\xf8\x36\x0c\xa0\xab\x43\xd4\x91\xf8\xab\xc1\x38\xfa\xbc\xf6\xd5\x1d\x6c\xed\x50\x17\xce\xe0\x08\xba\xe3\x3b\x7a\x45\x0a\x19\xd9\x38\xbe\x41\xb3\x1b\x04\x32\x31\x18\xbf\xa2\xc2\xcb\x51\xbe\xe4\x4e\xc4\xd2\x56\x66\x93\x6e\xbd\x05\x86\x47\xe0\x16\x48\xad\x27\xf3\x26\xaf\x64\x0d\x0f\xfb\xfb\xf0\x50\xb6\xf4\x9a\x40\x6d\x52\xeb\x7a\xd7\x1a\x9b\xe5\x86\x6e\xb5\x3a\x8e\xed\xf8\xd3\x6a\x18\x99\x23\x6d\xf3\x08\xd9\xca\x17\x96\x89\xd1\x09\xf1\x8b\x34\xd3\x23\x58\xab\x83\x94\x0e\x7c\xde\xd1\x7f\x0c\x41\x7d\x0a\xfe\x06\x36\xe3\x9d\x22\x6e\x4d\xb4\x3e\x88\xa5\x68\xe7\x71\xad\x30\xe4\x29\x83\xa0\xd3\x1e\x98\x1a\x87\x17\xb7\x0b\xa9\x32\x09\xb6\x9e\xb9\x46\x59\x6b\x2c\xe2\xeb\x32\x74\x6a\xcd\x4a\xb3\x05\xc4\x0a\xd3\xcc\x95\xd5\xca\xb0\x96\x36\xaa\x74\x53\xb8\x5d\x95\x2c\xc6\x98\x12\x53\x95\xf6\x8d\x4d\x76\x7b\x63\x64\xe2\x48\xe8\x98\x23\x4d\x39\x5f\xa8\x84\xbc\xcd\xb0\xbb\xce\x81\x4e\x89\x8d\xda\x06\xbb\x95\x52\xe0\xc8\x98\x6d\x51\xc2\x9c\xed\x56\x8e\xb3\x68\x9e\xd6\xe8\x20\x9d\xb4\xe1\xba\xc3\x3e\x54\x9d\x31\x4f\x64\xc7\x60\x29\x5d\xd9\x5a\xc3\x65\x35\xb1\xed\xd9\x18\x56\x4f\xc7\xaf\x30\x3e\xf5\xd3\x31\xe4\xe6\x93\xe6\xba\x77\x4d\xa3\x5c\x69\x42\xb0\xb3\xb4\xc0\x94\x5a\xba\xd2\x15\xc1\xfc\xf3\x05\x06\xad\x89\x8e\xcb\x64\x11\x08\x4f\xd5\x3e\xd9\xbb\xdd\xdb\x33\x36\x3e\x70\xf4\x80\xdd\x95\x6d\x27\xcd\x92\xa5\x72\x07\xf8\x0f\xeb\x9e\xae\xc6\x3b\xa1\xa6\x27\xa4\x55\xe9\xfe\x1c\x66\x1a\x61\x77\xae\x3f\xbd\x1f\x87\xa9\x46\xd2\xde\xea\xad\x01\x5e\x2d\xb8\xce\x8c\x1a\x16\x58\xbd\x5c\x19\x56\x75\xd0\xd4\x32\xc7\x5a\xe8\xf8\x21\x56\x2b\x49\x35\x45\xa8\x9f\x7e\x9d\x2f\x4e\xa8\x6a\x83\x93\x77\xd8\xa6\xd7\xed\xdb\x13\x6b\xcb\x70\x99\x4f\x4a\xbb\x00\x33\x2d\xd8\xeb\x55\x3f\x17\x40\x70\x5b\xdf\x7a\xd1\x6e\x19\xd4\xb4\x77\x92\x66\x67\x38\xf8\xc2\xf5\x81\x9f\x23\x9a\xfc\x9f\x5f\x4b\x06\x8f\xde\x9e\x45\x99\x1f\x57\x45\x88\x3e\x18\x0e\x5d\xd0\xb5\xe1\xd3\x15\xd8\x27\x0d\x22\x4f\x97\xd1\xef\x5c\xfd\x50\x93\x15\xe9\x60\x38\xaa\xac\x52\x1b\x1e\xdd\x82\xbd\x6f\x6a\xc0\x9a\x2e\x0f\x46\xc3\xc6\x0a\x40\x40\xf3\x39\x34\x7f\xb6\x3e\x4f\x57\xe8\xd0\x3b\x6f\x4c\xc0\xf3\x49\x2a\x0a\xa3\x38\xb6\xf5\x7b\x8b\x2c\x9a\xe3\xec\xe6\xcd\xa4\xdf\x7f\xbb\x6d\xc5\xce\xbf\x2f\x08\xdc\x41\xe1\x89\x65\x5e\x90\x05\x8a\x72\xfe\x2a\xd1\x8c\x7d\x59\x13\xe0\xa0\xac\x90\x01\x81\x96\x5e\x8f\xc3\x34\xd3\xa2\x1a\x30\x95\x8c\xbf\xcc\x8b\x74\x1e\xfd\x81\x99\xd9\xfc\x4e\x8a\x98\xdf\x70\xf6\x9e\x6b\x7b\xc8\x02\xe1\x5c\x0d\x69\x0f\x3d\xcf\xd1\x82\x62\x64\x11\x07\x2e\xa2\x38\x70\x07\x4a\x53\x93\xd0\xb8\x7f\xaf\x2f\x08\xe8\x4b\xc5\xec\xb2\x68\x87\x92\x8e\x98\x4e\x88\x6a\x81\x42\xae\x2b\x03\x33\xb6\xdf\x50\xe8\x80\xca\xdb\x91\x36\x60\x4b\xb8\x8b\xee\x86\x22\xb0\xd5\x36\x72\xc8\x95\xfa\x44\x94\x08\xcd\x48\xe4\x6b\x9a\x13\xfa\x43\x86\xf6\x66\x2f\x66\xa5\x1a\x07\x7e\xae\xd0\xca\x30\xa5\x07\xbc\x1d\x62\x93\x10\xc9\xd1\x65\x81\x0f\x3d\x78\xb3\x60\x7f\x63\x92\xa6\xa7\x87\x58\x93\x74\x2a\x2f\xbb\x46\xb7\x4c\xe3\x90\xa9\xc8\xfd\xb9\xa6\x47\x52\x4f\xa3\xe5\x56\xf3\xba\x69\x4a\x51\xe9\x90\x58\x91\x92\x94\x35\xae\x14\xe1\x30\x29\x72\x6b\xe0\xd3\x72\xab\xde\x1b\x72\x2a\x28\x98\xbc\xcf\xd2\x76\xee\x7c\x95\xdd\xe8\x3a\xda\x60\x0b\x6b\x7c\x93\xda\xf6\x9d\x47\xcc\xe3\x76\x6e\x64\x74\xc0\xd7\xbe\xea\xdc\xab\xed\xc6\xba\xd5\x6c\x7a\xf7\xe0\xd2\xcc\x2e\xae\x1d\xc3\xfb\xe8\x57\xf5\x90\xdd\xf3\x4f\x9e\xdd\x73\x30\x44\xc3\x67\x07\xbd\xf1\x11\x1a\xa2\x21\xe2\x7f\x0c\x86\xf9\x98\xfe\x35\xe8\xcb\xff\xeb\xf2\x82\xee\xa0\xff\x6a\x70\xd8\x9b\x0c\x01\x0c\x0d\xff\x98\x77\x87\x68\x30\x89\xbb\x93\xee\x04\x0d\x7a\xe3\x41\x97\xfe\xcf\xaf\xb4\xce\xb8\x37\x38\x8c\x0f\x7b\x93\xe3\x2e\xfd\x9f\x5f\x07\xc7\xe8\x28\xee\x1e\xa3\x63\x3d\x89\xa8\x79\x6b\x92\xc3\xa9\x15\x7f\x92\x04\xa2\x26\x19\xae\xec\xa1\xe6\x4d\x4c\xfb\xd5\x38\x73\xa8\x56\xa7\xe4\x34\x39\x1c\x3d\xe8\x14\xb6\xaf\x53\x18\xfe\xe9\x95\x0a\x9f\xe4\xae\xff\x27\xdd\x1a\xbf\xa2\xfb\xbc\xeb\x82\xce\xa3\xc7\x8b\xc8\xf7\x86\xcf\x06\x97\x3b\xd7\xbb\xdf\xf3\xd4\x4c\xe4\x7a\x45\xc3\xe7\xa4\x78\x96\x26\x45\x86\xf3\xe2\x35\xb9\x2e\x5a\xd5\x78\xa5\x33\x7f\x98\x26\xc5\xab\xe8\x0f\x22\x50\x15\x37\x8b\xf4\x3c\xc3\x8b\x8b\x9b\x9e\x8f\x21\x58\x5f\x4f\x80\xe8\x55\x7e\xc1\xf3\x28\xbe\x71\x54\x52\x1f\x1f\x54\x13\x3b\xf0\x11\x79\x2d\x74\x0a\xe2\xe2\x05\xe1\xc4\x79\xc2\x03\x45\xa0\xba\x96\xfd\x89\xe5\x7e\xc9\x35\xcd\x84\x27\x1f\xce\x6f\x66\x4f\x05\xe7\xba\xa1\xd7\x41\xfe\x8d\xf8\x2b\xa3\x7f\xf4\xb9\x7c\xb3\x99\xee\x42\xbf\x1e\xdb\x3a\x0c\x39\x1f\x42\xd7\x20\x0a\x1a\x7a\x88\x34\xf4\x33\x71\xaa\x3b\x4e\xd6\xf3\xe1\x30\x6f\xf0\x2b\x72\x34\xdd\x6a\xb6\x77\xa6\x5b\xe1\x34\x38\x9c\x1c\xb6\x21\x06\x56\x1a\xd6\xa5\x64\xd8\xc4\xb4\xce\x47\xcb\xa3\x5b\xa6\xf4\xaa\x73\xaa\x31\x28\x44\x07\x49\x7e\x01\x76\x39\xa0\xf7\x65\x72\x5d\x3c\x81\xd7\x45\x53\xe4\xcd\xa3\x20\x88\x89\xa7\x5e\xa8\x89\xc9\x85\x9f\xa6\x8d\x5e\x67\x92\xcd\x75\x1b\xc3\x7b\xa1\xdc\x18\x6e\x59\xbb\x31\xdc\xba\x49\x97\x62\x14\x93\xf1\x45\x68\x39\x86\x77\x55\x73\x58\xc6\x9b\x5d\xa8\x3b\xc6\x5f\xf8\x8d\xe8\xe1\xd5\xc5\x9f\xf7\xd5\xc5\x15\xce\x12\x1e\x55\xc4\x85\x76\x6c\x03\xd6\xde\xc8\x18\xc8\xa7\xb5\x55\xa7\x71\x8c\x17\x79\x95\x92\x6d\xd4\x3f\x2a\x81\xd6\x5a\xa9\x39\xcc\xd7\xf8\x62\xe4\x5e\xa6\xd2\x6e\x9c\xa4\x99\xce\xf4\x8e\xb3\x34\x7f\x8d\x2f\x6f\xd8\xb3\x88\xd7\xee\x37\x1a\x9d\xb5\xdf\xc4\x30\x18\xe7\x6b\x0f\x5e\x91\xe1\x42\x8f\xab\x30\xf0\xd4\xb4\xd5\xc4\xa8\xc7\x2b\x54\x36\x5d\x5c\x23\x78\xdb\xa2\x3d\xc3\x59\xf5\xee\x27\xc6\x79\xe1\x7a\x2b\x33\x45\x5e\x92\x26\xc4\x70\x41\xd0\xa3\xab\x7f\xd8\xd5\x83\x91\x9f\xaf\x17\x18\xf2\xf1\x5d\xb0\x04\x72\xc6\xfb\x8b\xb5\x6f\xf0\xf7\xfb\x2d\x0a\x34\x5f\xea\xe4\xa6\x39\xea\xee\x9c\x92\x6a\x23\xe7\x57\xbb\x62\x63\xaf\xd7\x6d\x27\xc1\xaa\x4c\x58\xe0\x54\xae\xdc\x8b\x47\x3c\x9b\xb8\x93\xd8\x38\xd8\x02\xfe\x64\x0b\x42\xe4\xe8\x70\x2c\x04\xf1\xe9\x0e\x9d\xb9\x3f\x8e\xe0\x3b\x70\xc0\xb5\x74\x8b\x42\x96\x5b\x91\xc6\xa2\x71\xda\x8f\x27\xc1\x7f\x97\x39\x8b\x51\x29\x53\x42\xc8\x3c\x9b\x2c\x04\x02\x81\xbd\x55\x43\xcf\xf3\x41\xfc\xce\x5c\x9f\x40\x5b\xb8\xd0\x72\x24\x5a\x99\x82\x6a\x29\xbd\x97\xb9\x1e\x36\xda\xd1\xea\xd1\x34\xde\xdf\x3e\x65\xe6\x09\xc3\xc7\xff\x64\x6f\xaf\xf4\x24\x8e\x4e\xbf\xad\x95\xac\xf5\x8e\x5a\xff\x2d\x9c\x8a\x8d\xe9\x0e\x8d\xb9\x9d\xc7\x72\x0d\xdc\xc1\xe8\x8e\x28\xbf\xd2\x1f\xe2\xc3\x6b\x3d\x84\x58\x55\x64\x44\x67\xc4\xcd\x55\x01\x37\x9b\x3e\xe1\x13\x9b\xa7\x84\xe1\x05\x77\x7e\xe3\x07\x73\xe7\xb9\x5f\x6e\x94\x63\x2d\x3a\x5e\xfe\xe9\x8e\x45\x1e\x1d\x34\x2b\x88\x61\x65\x38\x46\xf3\xd1\x84\x27\x7a\x24\x9f\x0f\x36\xd6\x6c\x82\x02\x8b\xdf\xbb\x55\x17\xab\x1f\x89\x75\x90\xf7\x1b\x2e\x48\x16\xe1\xb8\xfb\xcf\xe7\x53\xf4\xbd\x1e\xec\x65\xff\x07\x48\x79\x94\xc4\x37\x28\x20\x79\x74\x9e\x90\x00\x8c\x38\xcb\x9c\xa8\xb3\x4c\x46\x77\xe3\x72\x71\xcf\x6b\xa3\xa9\x8c\x99\xf7\x49\xd4\xe6\xc0\x9e\xc0\xb1\x77\x55\x99\x7f\x9a\x67\x69\xa5\x95\x24\xf5\xe7\xfc\x5f\x84\xbc\x28\xf1\x84\x8f\x9f\x8a\x0a\xe6\xd2\xae\x3b\xa2\x92\x3a\xcf\x93\x9a\xe0\x94\x4b\x16\x0b\xfd\x85\x48\x8b\x98\x2d\x45\x7c\xb2\x5b\x7b\x63\x72\xa8\xe3\x39\xb7\x7c\x1e\x2f\xc3\x86\x87\x7c\x65\xad\x87\x03\xf7\x7e\x1c\xb8\x0d\x8d\x2a\x9d\xf5\xaf\x8a\x0f\x57\xc1\xbb\x5f\x05\x3f\x9b\xa3\xee\xb6\x1f\x27\x6e\xd9\xf3\x97\x1f\xf1\x5b\xc0\x24\x4f\xfc\xed\x60\xfb\xd2\xdf\x60\x36\x1a\x05\x43\xf0\xaa\x39\x1c\xd6\xc7\xa7\x89\x6e\x0f\xc7\xc6\xe7\x3c\x36\xdc\xcf\x71\x41\x1c\x71\x3c\xc6\x35\x84\x05\x69\xdb\xd1\xbd\x23\x5c\x82\x81\xc7\xe2\x47\xdd\xf1\x51\x6e\xc1\x62\xad\xee\xc2\x58\x3c\xb9\x8f\xbe\xf1\x7e\x3a\x9f\x57\xfb\x1d\x1e\x0d\x9a\x44\x59\x64\x38\x76\x11\x62\x91\x61\xae\x8c\x12\xc9\xd3\x2f\xb8\xec\x8f\x87\x8d\x62\x76\xb2\xa0\xf9\x5b\x27\x9b\x72\x7c\x15\xcd\x8b\x28\x79\x5f\x49\x74\xa3\xe1\xa6\x18\x76\x41\x35\xc5\x5b\x4d\xf6\x32\x5b\xd4\x3c\x1a\x6e\x14\xde\x95\xe1\xd8\x09\xe9\x80\xb9\x92\xf8\x80\x90\xc5\xef\xf5\x1d\x68\x14\x4e\x54\xe1\xd9\x45\x27\x14\xf6\xca\x8e\x44\x49\x10\x9d\xa7\x95\xec\xd3\x6f\xd2\x09\x86\x63\x17\x1d\x60\x98\x2b\x89\x9f\xc5\xcb\xea\xf1\x3f\x6a\x42\x3a\xc5\xb0\x0b\xc2\x29\xde\x4a\xb2\xe3\xe8\xfc\xa2\x78\x5a\x47\x7b\xa3\xc0\xcc\x12\xcd\x2e\x3a\x20\x91\x57\xf6\xc2\xbf\xc1\x95\x0f\xe4\x47\x8d\xf8\x86\x62\xd8\xc9\x1e\x7f\x83\xab\x77\xf8\x82\xe0\xaa\x10\xc0\x07\xa3\x46\xbb\x25\xc5\xb0\x0b\xb2\x29\xde\x4a\xb2\xcf\x33\x42\xaa\x87\xbb\xd1\xd1\x04\x28\x76\x41\x38\x20\xae\xe7\xf6\xbf\xd5\x92\x3f\x6a\xcc\xee\x7f\xdb\x55\x1f\x14\xf6\x9a\x8e\xcc\x2b\x57\xec\xa8\x51\x18\x6c\x8a\x61\x37\xc4\xcf\xab\xd7\xe9\x0d\x89\xe3\xf4\xaa\x92\xf0\x49\x13\xc2\x19\x8e\x5d\x90\xce\x30\x57\x12\x8f\xe7\xb3\xca\xf0\xf5\x07\xa3\x46\x32\x02\xa0\xd8\x05\xe9\x80\xb8\x92\xf2\x34\xc3\xc9\x79\x35\xbf\x34\x92\x0e\x18\x8e\x5d\xd0\xce\x30\xd7\x8a\x37\x2f\xea\x3b\xd0\xe8\x78\x55\x78\x76\x25\xde\xbc\xa8\xef\xc8\x2c\x4b\xaf\xaa\xf7\x9d\x46\xc7\x2c\xa0\xd8\x89\x8c\x40\x11\xd7\x6d\xf8\x37\x95\x97\xa8\x46\xc7\x2b\xc5\xb0\xa3\xed\xfe\xa6\x56\x24\xfb\x5b\x35\xe9\x07\xe3\x46\xa4\x0b\x2c\xbb\x12\xcd\xfe\x56\xd1\x85\x4f\x1d\x63\xff\xe0\x7e\x5d\xe0\xf7\xf7\xd1\xbf\x71\x54\xa0\x8b\xa2\x58\xe4\xd3\xfd\xfd\xf3\xa8\xb8\x58\xce\x7a\x7e\x3a\xdf\x0f\xb1\x4f\x66\x69\xfa\x7e\x3f\x8c\xd3\xab\xfd\x28\xcf\x97\x24\xdf\x1f\x1d\xf5\x51\x91\xa2\x19\x41\x61\x74\x4d\x02\xda\x27\x92\xc7\x51\x52\x74\xf9\xfb\x3c\x44\xa1\x8b\x9b\x05\xd9\xe7\x94\x77\x2f\x71\x1c\x05\xdd\x30\x8a\x49\x17\x27\x49\xca\x55\x85\xdf\xed\x33\xf6\x91\x77\x42\x4a\xdd\xa4\x3f\x45\xde\xff\x13\x8e\xc8\x24\x9c\x80\x69\x6e\xd0\x87\x12\x32\x98\x11\x72\x08\x25\x43\x56\xe2\x93\xe3\x51\x70\x04\x25\x23\x56\x32\xc3\x07\x47\x3e\x2b\x19\xb3\x12\x3c\x1b\x1f\xce\x7c\x28\x99\xb0\x92\x63\x7f\x78\x38\xeb\x43\xc9\x01\x2b\x39\x22\xc3\x31\xc6\x50\x72\xc8\x4a\x0e\x67\x83\x10\x0f\xa1\xe4\x88\x95\x1c\xe0\xc1\xec\x98\xc1\x1c\xb3\x92\x31\x1e\x8c\x8f\x18\xe6\x27\x82\x44\x7c\xd4\x0f\x79\x11\xa7\x91\xf4\xc7\xfd\x70\xc6\x8a\x38\x49\xc1\xa4\xdf\x0f\x8f\x59\x11\x6f\x0f\xe3\x7e\x3f\x0c\xa1\xc8\xe7\xaf\x0d\x39\xef\xf1\x70\xe4\x4c\x0c\xaa\x52\x4a\xb1\xf1\x2b\xbf\xb3\x3e\x7c\xe0\x33\x83\xcf\x8c\xeb\xbb\xe2\x35\x12\x90\xc3\xf0\x40\xe7\xb5\x60\xe0\x8f\xc9\xb1\xce\x6b\xb3\xd1\x71\x10\xcc\x74\x5e\x3b\x9e\x1c\x4e\xfc\x40\xe7\xb5\x43\x32\x39\xf4\x87\x3a\xaf\x1d\x1c\x8e\xf0\xec\x50\xe7\xb5\x09\x19\x4d\x66\x03\x9d\xd7\x26\x83\x61\x80\x8f\x74\x5e\x1b\x4f\x86\x87\xb8\xaf\xf3\xda\x68\x30\x98\x1d\x0f\x0d\x5e\x9b\x8d\x8e\x8e\x38\xcb\x08\x5e\x3b\xf4\xc7\x81\x28\xe2\x24\x1d\x4c\x06\xa1\x28\xe2\xed\x1d\x0c\xfb\x7d\x82\x37\xe6\x35\x35\x86\x65\x7e\x3b\x7a\xe0\x37\x83\xdf\xb8\xa2\x42\xe3\xb4\x51\x38\x0c\x03\x9d\xd3\x66\xb3\x80\xf0\xfd\x81\xcf\xe2\x71\xdf\xc7\x7c\x7b\xe0\x9c\x76\x30\x9e\x4d\x38\x7f\xf2\x69\x1d\x0f\xb1\xd8\x1d\x39\xa7\x0d\x07\xc7\x07\xe1\x48\xe7\xb4\x01\x39\x3a\x22\x13\x9d\xd3\x06\xc7\x87\x07\x81\xb1\xab\x0d\x26\x07\x13\xdf\xe0\xb4\x7e\x30\x3e\xc4\x03\x83\xd3\x8e\x86\xb3\x81\xc5\x69\xe3\xf1\x11\xb6\x38\x6d\x78\x7c\x78\x6c\x71\xda\xf0\xf8\x60\x78\x87\x5d\x8d\x8e\x5e\x99\xc7\xee\x59\xc2\xad\xcf\xce\x63\xba\x56\x49\x63\xb4\x41\x38\x09\x89\xc1\x68\xf4\x40\xf5\x75\x46\x3b\x1a\x04\xe3\x10\xeb\x8c\x36\x0e\xfd\x51\x78\xa8\x33\xda\xf0\x78\x76\xc0\x59\x8f\x33\x5a\x7f\x84\x8f\xc3\xb1\xce\x68\xfd\xd1\xf1\xcc\x64\xb4\xfe\xf0\xe8\x28\x18\xe8\x8c\xd6\x1f\x1e\x1e\xce\x02\x83\xd1\x06\x93\xc3\xe3\x99\xc9\x68\xfd\xc0\xde\xd2\xc6\x7d\x7f\x6c\x31\x5a\xbf\x3f\xeb\x5b\x8c\xd6\xef\x1f\x0f\xea\xb7\xb4\x00\x67\xef\xab\xf8\x4c\x8e\x60\x89\xd9\x46\xdb\x4c\x86\xf4\x25\x30\x1b\x57\xfe\x69\x7c\xd6\x0f\x0f\x39\x0f\x09\x3e\x1b\x92\x59\x38\x34\xf8\xac\x1f\x10\x62\xf2\x59\x10\xf4\xc9\xc0\xe0\xb3\x03\xff\x20\xc0\x06\x9f\xf5\x67\x7e\x60\xf2\x59\x1f\xfb\xbe\x71\x74\xf6\xfb\xc7\x87\xf8\xd0\xe0\xb3\xfe\xd1\xe8\x28\x34\xf8\xac\x7f\xd0\x3f\x18\x9b\x7c\x36\x0e\x43\x8b\xcf\x06\x47\xaa\x48\xf2\x19\x99\x94\xf8\x6c\x76\xc4\x69\xda\x80\xcf\xe8\xe0\x95\x59\x6c\x9b\xf1\x75\xbf\x04\x16\xe3\x8a\x5a\x83\xc5\x86\xe1\xc0\x64\xb1\x20\x0c\x66\x26\x8b\xf9\x33\x7f\x6c\xb2\xd8\xec\x00\xfb\x26\x8b\xe1\x83\x63\x8b\xc5\x8e\x0f\x8e\x8e\x4c\x16\x3b\x3a\x3e\x9c\x99\x2c\x76\x78\x7c\x30\x33\x59\xec\xe0\x78\xe2\x9b\x2c\x36\x0e\xc6\x7d\x83\xc5\xf0\x61\x18\x92\x99\xc1\x62\x07\xe3\x30\xe4\x2c\x2e\x58\x6c\x10\x90\xe3\xd9\x81\xcd\x62\x21\x9e\x6c\xca\x62\x74\xf0\xca\x2c\x76\xcf\x62\xa9\x7d\x76\x16\x13\x4a\x75\x8d\xc7\x8e\xc2\x09\x97\xf7\xf9\x04\xfa\x47\xe4\xc0\x37\x6e\x00\x78\x12\x1c\xf0\xcd\x66\x24\x0e\x50\xff\xf0\x68\xac\xf3\xd8\xc1\xc1\x6c\x76\x60\xf0\xd8\xd8\xc7\xe1\xc4\xb8\x6d\x8e\x47\xb8\x3f\x3e\xd4\x79\x6c\x74\x74\x44\x46\xbe\xce\x63\x43\x72\x18\x8c\x86\x3a\x8f\x0d\x66\x13\x32\x34\x79\x6c\x76\x1c\x1e\xf8\xd8\xe4\xb1\xe3\xb0\x8f\x89\xbd\x8d\x1d\x1c\xda\x3c\xe6\x1f\x4d\x46\x9b\xf2\x18\x8c\x5e\x99\xc9\xb6\x19\xd3\xeb\x4b\x60\x32\xc3\xfe\xa1\xe9\x35\x06\xe1\x91\xc9\x69\x81\x4f\x02\xae\xb3\x10\x7a\x8d\x09\x19\xf0\x3d\x80\x73\x1a\x26\xc1\xe4\xc8\x38\x30\x8f\x7d\xdf\x3f\x30\x6e\x00\x47\x33\x7f\x34\xc6\x3a\xa7\x1d\xfa\xb3\xd1\x78\xa8\x73\xda\xc1\xd1\x71\x38\x32\xee\x9a\x93\xc9\xd1\x6c\x68\x1c\x98\xa3\xd1\xc1\xf1\x80\x18\x9c\xe6\xfb\x61\x78\xdc\x37\x38\x6d\x36\x0c\xc3\xc9\xb1\xc1\x69\x87\x07\x61\xd8\x1f\x99\x77\xcd\x71\x10\x0c\x0e\xef\x24\x98\xfd\xcd\xcd\x6e\xdb\x0c\x98\xf0\x65\xb0\xdb\xdc\x52\xa0\x1d\x87\x33\xae\x2e\xe3\xb3\x18\xf6\xc3\xb1\x3f\xd2\x19\x8d\x1c\x10\x72\xec\xeb\x8c\x16\xf8\xe4\xf0\x70\xa2\x33\x5a\x30\x26\x83\xc9\xa1\xce\x68\x7e\x10\xf8\xa3\x63\x9d\xd1\xfc\xbe\x8f\x47\x23\x9d\xd1\x70\x38\x1b\x0f\x8d\x63\xf3\x98\x1c\x07\xc3\xb1\xce\x68\x47\xc3\xc3\x43\xce\x1c\x82\xd1\xc2\x71\x18\x72\x3e\x97\x0a\x34\x12\x86\xe3\x81\xc1\x68\x3e\x65\xb4\xbe\xa9\x40\x23\x04\xf3\xa2\x8d\x18\x6d\xee\x10\xfe\xef\x99\x9b\xd5\x67\x67\x31\x69\x51\xd4\x98\x2c\x0c\x03\x8b\xc9\xc2\xf0\x98\x4b\x62\x43\x59\x32\x39\x0e\x74\x26\x0b\xc3\x70\x70\x68\xe8\x33\xc2\x90\x90\xc9\x91\xce\x64\x54\x7c\x1a\xcd\x74\x26\x0b\x83\xe0\x68\x64\x5c\x33\xc3\x99\xdf\x1f\x06\x3a\x93\x85\xc7\xf8\x68\x38\xd1\x99\x2c\x9c\x1c\x86\x36\x93\x85\x61\x78\x14\x18\x4c\x46\x8b\x04\x47\x29\x92\xb0\xc5\x64\x61\x18\x1c\x6c\xce\x64\x6c\xf8\xca\x6c\xf6\x60\x0c\x30\xd9\x4c\xd8\x7e\x0d\x2e\x3b\x22\x03\x93\xcb\x88\x3f\x1b\x99\x5c\x46\xfa\x47\x43\x93\xcb\x82\xc9\x38\x34\xb9\xcc\xc7\x43\x8b\xcb\xfc\x41\xdf\xd0\xcf\x86\xe1\x6c\xc4\xe7\x58\xce\x3a\xee\xf3\x12\xc1\x65\xe1\x91\xe0\x16\xc1\x65\xe1\x81\xe4\x1f\x45\xe2\xe4\x30\xb4\xb8\x2c\x38\x1c\xdb\x5c\xe6\x8f\x4b\x5c\x86\x67\x9b\x73\x19\x8c\x5e\x99\xc9\x1e\x2c\x01\x26\x93\x49\x33\xbd\xc1\x65\x23\xd2\xb7\xb8\xac\x3f\x1b\x9a\x5c\xe6\xfb\x47\x7d\x93\xcb\x66\x87\xe3\xc0\xe4\x32\x7c\x38\x3c\x30\xb9\xec\xf8\xa8\x6f\xdc\x01\xc2\xd9\x91\x6f\x71\xd9\xe4\xd0\x37\xb9\x8c\x84\x07\xbe\xc9\x65\xe4\x60\x32\x28\x71\x59\x30\x38\xea\x5b\x5c\x86\x67\x25\x2e\x3b\x1e\x94\xb8\xec\x20\xd8\x9c\xcb\xd8\xf0\x95\xd9\xec\xc1\x00\x50\x36\x38\xbd\x70\xb0\xda\x8c\x1c\xdb\xc7\xa6\xef\xcf\x7c\x93\xd5\xf0\xec\x78\x60\xb2\xda\x11\x3e\x98\x98\xac\x76\xd8\x1f\x8f\x4c\x56\x9b\x1c\x0e\x87\x06\xab\x8d\x27\x03\x2e\xce\x1f\x0a\x36\x1a\xe3\xc1\xb1\xce\x6a\xc1\xd1\x78\x34\x30\x8e\xcd\x59\x38\x3a\xe8\xfb\x16\xab\x1d\x93\x12\xab\x1d\x90\x12\xab\x8d\x02\x8b\xd5\x82\x60\xe8\xd7\xb3\xda\x4a\x83\xd3\x8b\x0a\x7e\x7b\x30\x06\x58\x06\x27\xee\xf7\xa2\x69\x36\x42\x32\xb3\xee\x9b\x87\xbe\x6f\xde\x37\x67\x3e\xc6\xd8\xd0\x9e\xe1\xc1\xd1\xd1\xa1\x71\x76\x1e\x05\x07\xe4\xc0\x60\xb5\xc3\xe3\xc9\x64\x6c\x68\xcf\x0e\x82\xb1\x3f\x36\x6d\x9b\xc1\xb8\x3f\x32\x14\xb4\x63\x32\x1a\x0f\x89\x71\xdf\x24\xc3\xc3\xe1\xc8\x60\x35\x8d\xc4\x27\x65\x1a\x9f\x94\x49\x7a\x52\x6e\x6f\x23\x8b\x13\x1d\xbe\x12\x97\x8d\x1f\xac\x00\x65\xb3\x26\x77\xf6\xd1\x18\xcd\x27\xa1\xa9\xa6\xf5\xc3\xe0\x28\x30\xf6\xb4\x59\x7f\x46\x7c\x43\xb1\x71\xdc\xc7\x63\xae\xb0\x12\x5a\x84\xa3\xe3\xfe\xb1\xe1\xb0\x71\xd0\x3f\x0c\x8e\x8c\xab\xc0\x64\x7c\x40\x0e\x0d\x87\x8d\xf1\x64\x82\xb9\x96\x9f\x33\xda\xe8\x70\x7c\x38\x36\x14\x1b\xc3\x83\xd1\x90\x2b\x3f\x9e\x94\x49\x7c\x52\xa6\xf1\x49\x99\xa4\x27\xe5\xf6\x36\x35\x6d\xd2\x11\x2c\xf3\xda\x3d\x33\x07\xf0\x58\xe8\x57\x51\xe1\x5f\x54\xfa\x76\x35\x72\x43\xe6\x9d\xdf\x85\x6b\x17\x23\xef\x1e\x38\x76\x8d\xb7\xa9\x69\xbf\x8f\x61\x3c\x3f\x7d\xa4\xcd\x9d\x06\x0e\xbd\x77\x61\x3c\xd1\xfe\x3e\x42\x57\x04\xbf\x7f\x48\xe5\x60\xb5\xe1\x4a\xe5\x00\xcb\xfe\x29\xae\x8c\xec\x39\x38\x1a\x39\x80\x6b\x33\x3a\x48\xa8\xaf\x3b\xf2\xe6\xee\x52\x34\x46\x49\x1c\x25\xa4\x1b\xc6\xe4\x1a\x4e\x4f\xfa\xdf\x55\x14\x14\x17\x53\x74\x30\xec\x58\xb1\xc0\xa7\xc8\xcb\x48\x8c\x59\x94\x1e\x91\x2a\x21\x26\xd7\xaf\x2e\xb2\x28\x79\x3f\x45\x7d\x3d\xce\xe2\x0c\x67\x76\x48\xc6\x97\x38\x88\x96\xf9\x14\x1d\x76\x4a\x74\xb0\x54\x91\x8e\x06\xf1\x2c\x4f\xe3\x65\x41\x6c\xea\x46\x63\x51\x70\x41\x58\x7c\xc9\x81\x2c\x29\xd2\xc5\x14\x79\x93\xfe\x5f\x65\x25\x2d\x26\x66\x57\xb6\x1e\xb3\x08\x91\x65\x38\x16\x3a\xb2\x3b\x90\x90\xfa\xc3\x65\x9e\x0f\x42\x96\xe4\x3c\xb8\x4c\xeb\x8d\x97\x2e\xb0\x1f\x15\x37\x5e\x07\x79\x33\xec\xbf\x3f\xcf\xd2\x65\x12\x74\x7d\x2a\x81\x78\x6f\x3b\x5a\x74\x99\x40\x45\x3d\x29\x61\x13\xdf\x7a\xf9\x45\x9a\x15\x24\x2f\x44\x28\x18\x99\xd0\x42\xe1\xe6\xc2\x8d\x19\x24\x93\xb2\x16\x7b\xd5\xce\x64\x1e\xf4\x23\xd8\x18\xfb\x1e\xe2\x6a\x15\xd9\x5b\x4e\x6f\x03\x04\xfd\xde\xe8\x08\x4d\xe9\x3f\xfa\x14\xb3\x34\x8f\x6a\x8e\xaf\x5f\x5d\xe0\x20\xbd\x92\xa1\x3e\xe1\x57\xfe\x66\xf0\xb6\x92\x72\xcf\x5f\x66\x19\x49\x98\x94\x66\x4f\xf1\xb0\x6f\x4f\xb1\x2a\x31\x19\x0a\xe6\x50\xa7\x6c\x7f\x1f\xfd\x92\x66\x48\xed\x1f\x50\x2a\x97\xbc\x20\xf9\x8f\xe7\x49\x40\xae\xa7\x68\xd0\x91\x81\xb9\x9a\x0d\xa8\x95\x94\x24\x23\x37\x6f\x26\xfd\xb7\xa8\x94\xad\x84\x7e\x18\xf7\xfb\x6f\xd7\x62\x24\x16\xe8\x20\x4c\xb3\xb9\x77\x77\xa6\xd1\x47\xc5\xbf\x20\xfe\x7b\x3d\xf7\xaa\xb3\xbb\x7a\x12\x15\x83\x6e\x4a\xd1\x94\x87\x61\x88\x71\x41\xfe\x57\x6b\x30\x5e\x5c\xb7\xe5\xb4\x79\x8f\xd0\x63\xf4\x97\x19\xce\xbc\xa9\x46\xf6\x0a\x6e\x75\xb5\xa6\x71\x66\xbf\x37\x11\x5d\xd1\x7b\x22\x12\xcf\xac\xe8\x4a\xb3\x99\xa3\x13\xe4\x9e\xba\x23\x8d\xa8\x8d\x7a\xd7\x7c\x2d\xae\xb7\x1a\x07\x43\x58\x8d\x03\x73\x6c\xcc\x60\xb6\xc6\x79\x0c\x71\x12\xb4\x43\x57\xc5\x49\x68\x6f\x21\xf6\xed\xf3\x10\x9d\x51\xb1\xf5\xac\xc3\x23\x35\x8a\x24\x33\x51\x2e\x98\x4e\x8f\x0c\xcb\xb9\xb0\x2a\x44\x4d\x42\x5e\x84\xb4\xd5\xd6\x9b\xba\xc0\x42\xf5\x01\x69\xde\xb6\x2b\xf2\xd7\x16\xa9\x38\x75\x58\x84\xd0\x7a\x7a\x69\xcf\x30\x62\x28\xe9\xc7\x45\x96\x5e\x46\x01\x09\x3a\x28\x2a\xd0\x55\x14\xc7\xf4\x1a\xbf\x94\x61\x27\xc3\x34\x29\x50\x1c\x9d\xe3\x62\x99\x91\x52\x8f\x9f\x6f\x90\x15\xf7\xce\x31\x90\xb6\x19\x91\xc8\x1c\xd2\x7f\xe6\x24\x5c\xc6\x74\x40\x99\x20\xcf\xb3\x01\xdf\xc4\x04\x61\x1e\x70\xb5\x48\xdd\x09\x88\xef\x4d\xec\x5a\xbe\x0a\x9e\xad\x60\xc9\x72\xcc\x57\x8b\xe3\x73\x76\x23\x17\x1c\x21\xb6\x27\xd5\x65\xb5\x61\x6d\xda\x44\x16\x2d\x16\x31\x41\x24\x0c\x89\x5f\xac\x6e\xe9\x25\x80\x6f\x92\xe1\x79\xe5\x0a\x59\x26\x3b\x58\x23\x9b\xa4\x8c\xbe\xc7\x8b\x43\xdd\x28\xf5\xc5\x40\x87\xf2\x2c\x4a\x16\xcb\xe2\x0c\x11\x16\x8c\x50\x1b\x01\x5a\x0e\xdb\xeb\x5a\x0b\xe3\x9f\x39\x41\xc5\x05\x2e\x8c\x98\xb7\x0b\x9c\xd3\xb1\xce\x48\x88\x7c\x1c\xc7\xf4\x94\x12\xed\xb3\xc8\x6d\xac\x35\x57\x30\x5c\xf8\xf0\x92\x84\x4d\x82\xf6\xba\x17\x55\xb2\xee\xaa\x7c\x26\x48\x0c\x21\xe8\x91\xe4\xba\xbc\xc0\x05\x61\x7b\x32\x4e\xce\x05\xbf\xf1\x46\x17\x38\xc3\x73\xf4\x81\x0d\xc9\x2d\x22\x97\x94\x3b\x29\x13\xb3\xbf\xf2\x74\x99\xf9\x44\xc6\x0e\xe6\x2d\x98\x75\xe9\x22\x20\x38\xb9\x15\x1b\x34\x54\x3f\xe3\x3f\xce\x98\x3e\x46\x60\x60\x2b\x5c\xf6\x31\x4d\x9e\x01\x4d\x6b\x84\x36\xb6\x87\xa9\xc0\x33\x2e\x7e\x6e\x7c\x10\xb2\xa4\x68\x1b\x1c\x85\x46\xd7\x1c\x4c\xc0\x55\x51\xb5\x78\xed\x18\xbd\x30\x40\xa5\xc4\xe7\x0d\x73\x82\x55\x87\xd2\xdd\x34\x9a\xac\x1e\x16\x56\x86\xb1\x7b\xdb\x96\x21\x51\x79\xbe\xf5\x15\x29\xd7\x20\x1e\xa9\x3b\xaf\x16\x20\xb8\xbd\x43\x84\xd3\xcd\x73\xa1\xd3\x2a\x6d\x2d\x63\x58\x4d\xa3\x4a\xe6\xeb\x54\x86\x54\xe5\x23\xcd\xb6\x60\x3d\xf5\xbc\x3c\xa8\xb5\x5b\x88\xb8\x43\x09\xb2\x8c\xdc\x66\xc6\x2d\x43\xa6\x6d\x67\x05\x0a\x42\x1d\x86\x12\x89\x9e\x48\xd2\x08\x7b\xaa\x49\x4e\x32\xb3\x84\x0c\xf6\xda\x28\xda\x6b\xdd\x1c\xce\x70\xc6\xee\x48\x3c\x9c\x2a\x0c\xd6\xe7\x89\xa4\xfa\xc9\xc4\xe2\x2f\x47\x1e\xfd\x62\xc2\x62\x9a\x62\xe8\x76\x62\x50\x8a\x25\xb5\x55\x6c\x4c\xaa\xfc\x8c\x69\xfb\xef\x15\xff\x35\xee\xa9\x94\xec\xb6\xc5\x81\x42\x48\xdb\x4e\x60\xcd\x64\x8b\xac\x2c\x04\xa3\x2d\x85\xfc\xe4\x32\x52\xcd\xb8\x6d\x4b\x48\x6a\x4a\x12\x88\x46\x0d\x46\x4b\x8f\x8b\xb9\x7e\xdc\x4a\x7a\x5e\x31\x39\xda\xfb\x6d\x19\xb1\x73\xc9\x43\xb7\x6d\x7e\x9e\xef\x26\x92\xe5\xf8\x9e\x3d\x1a\x61\xa6\xa2\xd7\xe0\x13\x51\x65\xec\x6e\x14\xf1\x69\x87\xc6\x6e\xa0\xae\x32\x0e\x0b\x7c\x7d\x9a\x06\xd5\x81\x58\x1a\x05\x7e\x92\x68\x76\xd6\x03\x8a\xbc\xbe\x17\xcf\x48\x5c\x15\xb1\x6d\xd4\x6f\x14\xc2\x47\xa2\xd9\x59\x2f\x28\xf2\xfa\x5e\xfc\x92\xa6\x45\x75\x28\xab\x71\xa3\x50\x56\x1a\xa2\x9d\xf5\x84\xa1\xaf\xef\xcb\xdf\x09\xae\x0a\x93\x7a\x30\x6e\x14\xd9\x4a\xa2\xd9\x59\x3f\x28\xf2\xfa\x5e\xfc\x8e\xcf\xa3\xa4\x2e\xf5\xde\xc1\xb8\x51\x90\x2b\x0b\xd9\xce\x7a\xa4\x9a\xa8\xef\xd7\xcb\xea\x68\x6f\x93\x46\xd1\x97\x04\x96\x9d\xf5\xe4\x65\x4d\xc4\x37\x00\x78\x95\x66\x85\xc8\x9b\xe3\xee\x48\xa3\x48\x8d\x26\xae\x9d\x75\x47\xb6\x70\x1f\x3c\x8f\xee\xd9\x7b\xb8\xcf\x9c\x11\xf8\x5e\x39\xf6\x9c\x13\x5a\x5c\xa4\x54\x8e\x7f\x11\x56\x90\x70\x54\x01\x5e\xe7\xad\x62\x42\x9a\x4e\x3b\xcf\x70\x1c\xc3\xf5\xae\xaa\xcf\xc7\x15\xf0\x75\x5d\xb5\x30\x2b\x0c\xa0\xff\x78\x46\xbf\x56\x35\x37\xe8\xbb\xa0\x6b\x1b\xd3\x90\xaa\xe8\xd1\x69\x9e\x47\xf4\xe0\x4d\x93\xbc\xc8\x96\x7e\x91\x66\x2f\x61\x09\x55\xb6\x3b\x58\x5d\xb7\x8e\x8a\xea\x06\xb5\x58\xca\x17\x24\x8b\x8a\xea\xae\x97\x41\xeb\x5a\x94\xe8\xda\x3b\xcd\xea\xac\xeb\x9c\xdc\x57\x8b\x12\x64\x1d\x72\x09\xf4\x25\xb9\x99\x7d\xbd\x0e\x60\x0d\xf1\x71\x95\xe7\x6b\x70\x19\xb8\x23\x6d\x3a\xae\xcf\xe1\xa3\x16\xa6\x49\xf1\x0b\x9e\x47\xb1\xf4\x88\x28\x6e\x16\xe9\x79\x86\x17\x17\x37\x3d\xf5\xd1\xf2\x19\xf2\x06\x7d\xcd\x9d\x8b\x79\x09\x89\x4c\x13\x53\xe4\xf9\xfc\x4f\x0b\xe2\x15\x4b\x4a\x3c\x45\xd2\xbf\x28\xbd\x24\x59\x18\xa7\x57\x53\xe4\x5d\x44\x41\x40\x12\xcf\xe5\x62\x71\x17\x9f\x89\xd7\x5a\x4a\x4b\x6e\x88\x29\xa8\x18\xd3\x41\x49\x9a\xcd\x21\x95\xe9\x99\x14\xa1\x49\x76\x86\x70\x12\xf0\x12\x7a\x59\x3b\xbb\x07\xa9\x76\x1f\x7c\x0b\xca\x13\x2a\xec\xe4\x60\xf0\x0e\xd3\x8c\xd9\xee\xd3\xb4\x40\x49\x1a\x70\x7b\x37\xfa\x39\x02\xa3\x96\xb4\x9a\x17\x29\xe4\xf4\xc3\xe8\xa7\x17\xbf\x09\xc3\x30\x4a\x29\x80\xc3\x36\x27\x8b\xd6\x9d\x6f\x63\x77\xd8\x70\xda\x75\x1c\xdb\x99\x7d\x0d\x63\x5b\x2e\x2c\xa1\xf3\x91\x5b\x47\xeb\x1d\xd4\xff\xcb\x33\xd1\x79\xb6\x7f\x80\x1a\x4d\x9e\xe2\x4a\x89\xf6\x9a\xad\xa4\x52\x25\x30\xd6\x49\xa4\x00\x25\xef\x18\xca\x02\xa7\x84\x2f\x85\xb1\xb8\x88\xf2\x0e\xab\xd1\x3e\xd1\xef\x24\x50\xad\x5a\x96\xb1\x31\x30\xd2\x7a\xef\xe8\x00\x14\xe9\xbb\x77\x74\x6f\x05\x14\x96\x9c\x69\xf5\xa5\xdd\xee\x51\xc6\xbf\xe1\x58\x70\x76\xbe\xa4\xa3\x96\xb7\xdb\xec\x92\x23\xc6\x42\x17\xe6\x4a\xc3\xf1\x86\x75\xf4\x3d\xb9\x99\x22\xef\x9c\x14\xcf\xe8\xc6\x01\xb9\x71\xae\x0b\xbe\x23\xf2\x8b\x83\x7e\x09\xd3\xa1\xe4\x60\x81\x8b\xa5\xf9\x6c\xa9\x1b\x47\x09\x61\x6b\xa7\x3b\x27\xc5\x45\x1a\xe4\xdd\x65\x4e\xba\x94\x62\x5e\xc7\xd8\xee\xc1\xaf\x90\x5d\x00\x3f\xdc\x0a\xc3\xdf\x89\xda\x66\x85\xef\x23\x23\x37\x23\x49\x40\xb2\x0a\x2a\xd9\x47\x8d\x38\x29\x28\xd1\x6d\x97\x12\xd0\x63\x76\x61\xd9\xb0\x9e\xa2\xf5\x9d\xd3\x34\x8d\x1c\xd9\x5e\xdf\x55\xd8\xa8\x91\x99\x3a\xf6\x9d\x3b\x77\x2c\xfd\x4f\xb2\xa2\x85\x51\x14\xeb\xb0\x6b\x5a\xbe\xdf\xd5\x9b\xbe\xed\x14\xaa\xa2\x45\x61\x13\x17\xc3\xb6\x49\xaa\x50\x47\xce\x4f\xfd\xd6\xde\x24\x19\xa7\x35\x34\x6a\x1c\xee\x94\x07\x14\xd9\xa9\x33\xc1\xd2\x2b\x59\xec\x2d\xfc\xe0\x64\xc2\x22\x39\xd9\xbb\x6d\xd9\xf4\x1a\xdb\x07\x5b\xbe\x8e\xe4\x56\xda\xb6\xec\x01\x5b\xb3\xc7\x66\xbc\x82\xaf\x2d\x22\x21\xe6\x7f\xd8\x93\x0b\x40\x13\xea\x65\xb3\x6c\xc6\x37\xcc\x7b\x65\xda\x0f\x80\x06\x30\x1f\x88\x0d\xcc\xd6\x57\xdc\xb3\xe0\x2a\x0f\xfa\x8a\x07\x7d\xc5\x83\xbe\xe2\x41\x5f\xf1\xa0\xaf\x78\xd0\x57\xfc\x89\xf4\x15\xaf\xa2\x3f\x88\x43\x5b\xb1\xb8\x7e\x9d\xbe\x24\xf3\xd6\x60\xd4\xae\x7f\x68\x44\xae\x0b\xf1\x20\xe6\x13\xa8\x1b\x94\xd0\x69\xab\x1c\x5e\xa6\x57\x0f\xfa\x85\x07\xfd\xc2\x17\xae\x5f\xe0\x7e\x19\x77\xd2\x31\x50\x1c\xcd\xf4\x0c\x14\x72\x7d\x5d\x03\xf8\x65\xdc\x5d\xdf\x40\xd1\xac\xad\x73\x80\xb6\xef\xae\x77\x60\x43\x74\x7f\x75\x0f\xda\x8d\x7b\x96\x06\x37\xfc\x16\x22\x8a\x1e\x34\x13\x0f\x9a\x89\x7b\xa1\x99\xa0\xcb\xa8\x99\x76\x02\x16\xfb\x2a\x0d\x05\x65\x75\x5d\x43\x01\x95\xee\x81\x96\x02\xbc\xdc\xa4\xa6\x82\x6f\x7f\xb6\xb6\xe2\x9e\xc5\xe8\x7c\xd0\x56\x3c\x68\x2b\x1e\xb4\x15\x0f\xda\x8a\x07\x6d\xc5\x83\xb6\xe2\x0b\xd2\x56\x0c\x1b\x68\x2b\x72\xe2\xa7\x49\xf0\xa0\xaf\x78\xd0\x57\x3c\xe8\x2b\x76\xad\xaf\x90\x6f\x17\xee\xa4\xb1\x60\x58\x9a\xe9\x2c\x18\xec\xfa\x5a\x0b\xfe\x7a\xe1\xee\x7a\x0b\x86\x68\x6d\xcd\x05\x6f\xff\xee\xba\x0b\x31\x58\x7f\x0a\xed\x45\x08\xc4\x3e\xe8\x2f\xee\x97\xfe\xe2\x53\x6b\x1c\x36\xd3\x8c\xdc\x59\x3d\xc1\x56\x4a\x33\x05\x05\x5f\xd5\xab\x54\x14\x94\x9f\x75\x15\x05\xaf\x76\x0f\x94\x14\xfc\xf1\x97\x54\x53\xc8\xfd\xce\x56\x54\xdc\xb3\x3c\x0f\x0f\x8a\x8a\x07\x45\xc5\x83\xa2\xe2\x41\x51\xf1\xa0\xa8\x78\x50\x54\x7c\x91\x8a\x0a\x0a\xfd\x6f\x1e\x2c\xd6\xf9\x68\x84\x7d\xfc\x8d\x04\xd1\x72\xfe\xa0\xdd\x78\xd0\x6e\x3c\x68\x37\xee\x8b\x76\x83\x47\x33\xb8\x93\x6e\x83\xe2\x68\xa6\xd9\xa0\x90\xeb\xeb\x35\x20\x9a\xc1\xdd\xb5\x1a\x14\xcd\xda\x3a\x0d\x68\xfb\xee\x1a\x0d\x36\x44\x7f\x0a\x7d\xc6\x05\xc1\xc1\x83\x36\xe3\x7e\x69\x33\xd4\xb0\x7d\xdd\xde\x18\x74\x19\x35\x53\x76\xc0\x62\x5f\xa5\xea\xa0\xac\xae\xab\x3a\xa0\xd2\x3d\x50\x74\x40\x6c\x18\xa9\xe6\xe0\xdb\x9f\xad\xe4\xb8\x67\x59\x06\x1f\x94\x1c\x0f\x4a\x8e\x07\x25\xc7\x7d\x56\x72\x7c\x8a\x6c\x44\xcf\xfd\x34\x79\xba\x2c\x8a\xca\xb0\x52\x83\x51\xdf\x01\x5c\xd7\x8a\x82\x52\x15\x21\x8a\x76\x55\x03\x03\x13\xae\x16\x37\x05\x90\xe0\xbf\x91\x64\x59\xa5\x9e\x39\x56\xab\xe7\x15\x89\x49\xe5\xec\x8c\xfa\x23\x0b\xb0\x36\xd3\x12\x40\xc8\x0a\x0d\x23\xbe\x99\xb0\x75\xf8\x55\x78\x36\x59\x2d\x4d\xe3\x19\xae\x0a\xc5\x36\x38\x3a\xb2\x21\x6b\xd1\x33\x10\x55\x45\xde\xfa\xab\xf6\xf8\xbe\x03\xb6\xb6\x05\x09\x25\x2b\xfe\x4f\x72\x33\x4b\x71\x16\x3c\xc9\xb2\xf4\xea\x57\x12\x56\xce\x84\xb6\x01\x95\xea\xd4\xb5\x59\x02\x76\xa3\x79\x19\x9d\x5f\x54\xb7\x3d\xa8\xa9\xd4\xb8\x71\x80\xfe\x6a\x75\x6f\xfb\xfb\xe8\x7f\xf0\xad\x91\x04\x52\xc2\x43\x92\xa7\xbf\x5a\xe5\xdc\xfe\x3e\x7a\x9e\xd0\xc3\x12\x72\x10\x10\x94\x2f\x88\x1f\x85\x91\x1f\xb1\x2c\x04\xe9\x25\xc9\xb2\x28\x20\x6a\xa4\x7a\xbc\xa2\xf7\x68\x1a\xe3\xbc\xe8\x82\x88\x6b\x24\xd4\x59\xe0\x20\x60\xa1\x58\xf6\xf4\x2b\x1f\x8f\x08\x5e\xb0\x75\xae\x2a\x88\xcc\x50\x93\x03\x99\xc2\x2b\x4a\xfe\x5e\x2a\xe4\x58\x5f\xf2\x34\x52\x3a\xca\x7c\x81\x7d\xa2\x61\x0c\x63\x72\x3d\x45\xde\x00\x0d\x10\xc4\x92\xd1\x61\x7d\xbc\x60\x19\x98\x74\x60\x67\xf6\x33\x08\xd0\xeb\xd2\x62\x7a\x9c\x91\x0c\xbc\x39\xec\xbe\x2f\x8d\xb1\x65\xa9\xc8\x5e\xea\xba\xcc\x9c\x85\xa9\xe9\x2d\x93\xa8\x40\xdf\xa1\x71\x19\x85\x5d\x9d\x65\x32\x2b\xd7\xae\x4c\xa6\x46\xef\x1a\x4f\xe2\xe8\x1c\x72\xbd\x41\xbe\xa1\x8a\x21\x1c\xae\xa1\x3d\xb5\xd3\x78\x8d\x64\xe5\x38\x4a\x88\x98\x2d\x6f\x34\x5c\x5c\x1b\xc3\x82\x81\x25\xf3\x8a\xe1\xde\x80\x80\xfa\x41\x41\xdf\xa1\x21\x4f\x37\xb5\x99\xaa\x17\xa2\x0f\xfe\xc4\x72\xa7\x90\xe0\x65\x7a\x95\x3f\xc9\xce\xc5\xad\x2d\xcc\xd2\x79\xa5\x0e\x8d\xc5\x28\xb6\x22\xc2\x17\xe9\x7a\xf0\x7e\xba\xa4\xb7\xc9\x75\xaa\x2c\x70\x4d\x0a\x8b\x52\x0d\x3a\x1e\x77\xd5\x7c\x7f\x5a\x5d\xef\x83\x96\xf6\xce\x5a\xda\x15\xca\xf3\x34\x7e\xb5\xc0\xc9\x0a\x1e\x2a\x4f\x4a\x91\x16\x38\x46\xec\x2b\x4a\x43\x94\xa5\x57\xfa\x54\xaf\xcb\xc9\x6e\x0e\xf3\x97\x79\x91\xce\xa3\x3f\xd8\xe1\x14\x88\x85\x09\x8d\xa1\x98\x0e\x85\x6a\x32\x2e\xad\xdd\x35\x52\xbb\x54\x35\x09\x0d\x2d\x48\x06\xeb\x8c\xb7\x88\x9e\x27\x97\xe9\x7b\x12\x20\x7a\x69\x41\x18\x9d\x7d\x80\xad\xa1\x83\x8a\xb4\xc3\x3a\xde\x61\xe0\xb7\x67\x0c\x39\xcf\x16\x61\x52\x4a\x09\xfc\x9d\x64\xbf\xc3\xfa\xfd\x62\x0c\x41\x55\x89\x80\x60\x3c\xb4\x3c\x40\xe6\x18\x16\x57\xa9\x52\x85\xc3\xc6\xce\x73\x00\x61\xb6\xbd\x30\xdc\x80\xa3\x48\x51\x7e\x91\x5e\xa9\xc1\x14\xe1\xea\x7f\xaf\xdb\x08\xe9\x38\x55\xb2\x5b\x15\xcd\x26\x6f\x2b\x2e\x58\xa3\x1b\xac\x01\xe8\x4b\x99\x62\x83\x03\x36\x21\x9c\x2e\xc3\x3f\x48\x96\x76\x67\x98\xee\x8b\x51\x12\x90\x6b\x69\x8c\x64\x69\x39\x81\x62\xd5\xf4\x7a\xa7\x45\xb9\xb5\x8a\x21\x51\x0d\x64\x0d\xfa\xb4\xa2\x9d\x67\x62\x01\xe6\xd0\x91\x14\x04\xb6\x5c\xf4\xcb\x9c\x0a\x26\x33\xa1\x30\x22\x71\xe0\x24\xe2\xc5\x82\x0b\x20\x55\x92\x75\x96\xe1\x9b\x17\x61\xab\x96\xd4\x15\x3b\x28\xc8\x21\x2b\x0e\x35\x29\x88\xbc\xcb\x48\x08\x0a\x9c\x5a\x55\x39\x57\x37\xc8\xd4\x3c\xf4\xa6\xc5\x2c\x33\xff\x4c\x02\x92\x51\xa1\x8b\xe9\x4b\xd1\xad\xa6\xc2\x09\xc7\xab\x11\x3b\xae\x90\xaa\x95\x64\xa9\x5d\xef\x33\x12\x4e\xd6\xc4\x07\xd7\xe1\x6a\x74\x07\xdb\x45\x77\xb8\xa5\xde\xc2\xc4\x7e\x87\x9e\x68\xc6\x7a\xc4\x56\x94\x12\x3c\xa8\xcc\xb1\x88\x41\xd2\x44\x51\x92\xd3\x2b\xd1\x99\xe6\x38\x78\xc6\x00\x64\x60\xf1\xde\x1e\x65\x0d\x69\x19\x35\x22\xa4\xdf\xc9\x3e\xaa\x30\x35\xb3\x92\x2a\x78\x69\x33\x13\xc3\xc7\x8d\x37\xf0\xb3\x20\xf3\x45\x07\xbd\x63\x46\xc9\x77\x19\x29\xf8\xc7\xc6\x76\x55\x2d\xa6\x3a\xaf\x4a\x07\xa4\x05\xc8\x63\x30\x95\xc9\x8d\xb1\x17\x93\xe4\xbc\xb8\x00\xe3\x27\x15\x2e\x9f\xd0\x25\xd8\xa2\x50\xed\x0e\x7a\xf7\x9e\xdc\xa0\x53\xd4\x3f\x61\x7f\x7d\x0f\xb5\xd9\x8f\xc7\x8f\x95\xd5\x8f\x56\x7d\x43\x0b\xdf\xea\x98\x59\x89\xb0\xfa\xec\x99\x86\x29\xb0\x9f\x40\x47\xd9\x1f\x17\x51\x2e\x2c\x2a\x6b\x58\x7f\x79\x8e\x28\xab\xcf\x6b\x9b\x82\xb5\xe1\x6a\x43\xaa\x0f\x6e\x15\x66\x19\x4a\xde\xd0\xc6\xde\xf6\xfc\x34\xf1\x71\xd1\xa2\x7d\x6d\xb7\xdb\x7c\x7a\xc4\xbf\xbd\x0b\x9c\x04\x31\x79\x8a\xfd\xf7\x4c\xa3\xf9\x2c\x8e\xfc\xf7\x06\x7b\xc1\xb1\xa3\xc6\xec\x9d\xb2\x8e\xf6\xf4\x43\x93\xc1\x75\x8c\xef\xb0\xb9\x76\xd1\x40\x98\xd0\xcc\x46\xff\x41\xae\x8b\x5d\x35\xfa\xd8\x6c\x94\xcc\x17\x22\xad\x4b\x93\x59\xd2\x38\xb8\xb9\x41\x5d\x5f\x53\x86\x59\x5d\x2e\xff\x7f\x47\x71\xfc\x92\xf8\x24\xba\x24\x3c\x09\x90\xd3\x38\x5d\x09\x0f\xf3\x3a\x34\x8d\xd6\x20\x28\xb2\x1d\x2c\x1c\xf6\x98\xd8\xa8\x9b\x84\xb5\xc1\x92\x50\x7a\xa1\x0e\xac\x1d\x78\x12\x56\x2b\x33\xac\xbe\x09\xb9\xfa\x15\xe7\x05\x87\xfd\x0d\x17\x17\xbd\x39\xbe\xa6\x63\x04\x7f\xfb\x24\x8a\x5b\x8c\xb6\x7d\x1d\x6f\x5b\x63\x07\x84\xa2\x10\xb5\xec\x99\xfb\x41\x47\xdd\xd6\x14\x42\xc6\xbc\xd3\x4d\xb7\x63\x40\x9e\x98\x6a\xa2\x7b\xe2\x10\xa0\x94\x84\xf5\xa6\x7b\x7e\x7d\xb2\x8d\xfc\x50\x68\xc2\x2d\x4d\x5c\xd6\x7c\x97\x6f\x2f\x0a\xb8\xfc\xad\x54\xf3\xa5\xc9\x01\x5a\x3d\xed\x4b\x1d\x7f\x95\x97\xa8\x0b\xda\xd9\x8c\xe3\xa3\x5e\x77\x61\x00\x2f\xea\x59\x97\x01\x65\x6e\x4c\x65\xb9\xce\x59\x85\x7f\xd3\x6b\x82\x88\xa6\x80\xe1\xe7\xd6\x1d\x30\xa4\x9f\x05\xfc\x00\x0e\x60\x7f\x2e\x59\x59\x79\x1a\x65\xa9\x36\x74\x9e\x96\x82\xcb\xfe\x6d\x81\x2d\xf8\xbf\x99\x59\x5c\x1e\x0a\x5a\x0a\x7d\x36\x1e\xb4\xb0\x5d\x08\xe8\x44\xa7\xe8\x32\x8d\x02\xd4\x97\x5b\x05\x5d\xe1\xda\x1a\x38\x3d\xd5\xcd\x44\xd2\x25\xe1\xe3\x47\x64\x02\x79\x45\xe0\xe9\x6b\x5f\xe1\xd7\x17\xca\xc7\x8f\x68\xd0\xef\xf7\x4f\xd0\xfe\x3e\x2d\xef\xe6\x14\x24\xbd\x24\x19\xbd\x2a\x65\x37\xc5\x45\x94\x9c\xcb\x5d\xe1\x6e\x2e\x26\x1b\xb8\x97\x28\x67\x17\xa1\x1a\x11\xbd\x70\xf8\x9c\x34\xa4\x07\x29\x23\x58\x39\xdf\x26\x72\xa7\xb6\xe4\xaa\x72\x95\x4b\x73\x75\x7b\x75\x99\x32\x99\x9a\x1c\x9c\x3e\x9a\xa2\xd3\x00\x91\x61\x66\x73\xf5\x81\xf6\x82\x4a\x3b\xf4\xe0\x64\x5a\x76\xaf\xe3\xa2\x83\x7f\x34\xbb\x55\xde\xc6\xb4\x8f\x1b\x53\xcc\xad\xa6\x15\xd4\x1a\xbf\xf4\x54\xa9\xdc\x46\x22\x07\x4e\xea\xf6\x3b\x52\x49\x6f\x7e\xb3\xfb\x82\x10\xdc\xdf\x9e\xc5\xa5\xe4\xab\xe2\x3f\xb3\x05\xb0\x35\x58\x30\x25\x94\xdc\x20\x01\x17\x48\xfb\x1b\x3f\x15\x2b\xf6\x4d\x84\xf4\x74\xc7\x8e\xcd\x64\xaf\xa6\xe1\xf2\x6e\xd2\x9b\xe3\x45\x4b\x49\x7c\x25\x80\x76\xa9\xbf\xeb\xad\x5d\xf1\x1f\x18\xd1\x7b\xf4\x7f\x9e\x17\x64\x6e\x77\x88\xb2\x1b\xc8\x07\xa5\xf6\x3b\x8e\xe1\x78\xe1\xe4\x39\x67\xff\x2c\x08\x29\x9f\xf0\xd1\x69\x6f\x83\x31\x3f\xc1\x52\x32\x0e\x9a\x96\x3d\x23\xcc\x96\xc1\x85\x92\xd3\x53\xd4\x47\x3f\xa2\x3e\x9a\xb2\xc3\xfa\x3b\xe3\x54\x7e\x8c\x06\xf6\xa8\x15\xe9\x94\x4b\x8e\x51\xd2\xe2\x1a\xcf\x96\x14\xdf\xcd\xfa\x6d\xbb\x32\x57\x0d\x97\x24\x20\x84\x84\x7e\x6a\x51\x62\xc9\x6d\x0c\xba\x96\xb7\x59\x8d\xb2\x63\x50\xb9\xcd\xca\x1e\xd4\xb5\x98\x57\xf7\x47\x71\x4f\x30\x6d\x9c\xdf\x9f\xa6\xa8\xfa\x42\xd7\xd1\x52\x2d\x33\x41\x0a\x26\xab\xc4\xc7\xcc\x16\x16\x44\x19\x61\xab\x12\xce\xe2\xac\x88\x3d\xf4\x23\xd7\x0c\xb1\x9d\x63\x62\xd4\x6b\xef\xba\x8b\xa5\xd5\xe6\xea\xb2\x75\x9d\x2c\x2f\x51\x6b\x08\x7e\x38\x6d\x70\x55\x59\xb5\x9b\xae\x1a\xb0\x03\x3e\x60\x87\xe6\x80\xed\xb9\xfe\x16\x7f\xd5\x3b\x9c\xaa\x6b\x66\x33\xb7\x53\x4d\xbd\x50\xef\x7c\xea\x10\xcc\x3a\x4e\x2b\x83\xf7\x52\x57\x9e\x4e\xbd\x4e\x85\xd5\x44\xee\xed\x8e\x8d\x84\x8e\xc9\x91\xae\x4a\xa2\x3b\x09\xbf\x74\x1e\xf5\xc0\x0e\x22\xc7\xa5\x48\xe5\x87\x22\xd5\xdc\x74\xb5\x9b\xef\x11\xbb\x09\x19\x1e\xf9\x80\xf1\x31\xf2\xba\x1e\x7a\x4c\x71\x3c\x46\x1e\x4a\x43\x44\x7f\x49\x60\x98\x4f\x97\x9e\xf7\xcd\xa4\x83\x06\xfd\x0e\x1a\x4e\xde\xee\x6d\x9c\xb7\x95\x7e\x7e\xcd\xb4\xba\x90\xd9\xce\x76\xaa\xd5\x92\x14\x4a\xd7\x5a\x53\x03\x66\x39\xd8\x1e\x6f\xd1\xc1\xb6\x26\x6d\xac\xc2\xcd\x93\x9e\x43\xf5\x4f\xe0\x8f\x6b\xe2\xae\xf2\x65\x3c\x6c\xbb\xe1\xeb\x1c\x1a\x2d\xcc\xf7\xd3\x49\x77\xa7\xee\xc8\x19\x09\xe1\xa2\x84\xae\x08\x7e\xbf\x4b\xa7\xce\x87\x87\xa5\x7f\x4e\xe7\xb6\xad\x3a\x86\x55\xdd\x92\xf9\xee\xbd\x48\xf3\x88\x39\x50\x79\x19\x89\x71\x11\x5d\xaa\x4c\x5c\xdc\x3c\x3f\x45\x5e\x18\x93\x6b\x59\x8c\xe3\xe8\x3c\xa1\x12\x7c\x4e\xc5\x59\x42\xe7\x45\xf8\x08\xf1\x53\x78\x1e\x5d\x47\x89\xbc\xef\x72\xa1\xe4\x7c\x59\x14\x24\xcb\xa7\x26\x0c\x2f\x6d\x7d\x00\x91\x70\x4b\x6f\x39\x3f\xb1\x47\x0b\xbf\xd6\xcb\x47\x43\x68\x99\x2f\xe1\xb1\x28\x46\xf3\xe8\xba\x58\x66\x84\x1e\x77\x67\x4a\xbe\x3a\xeb\xa0\x33\xfe\x17\xcf\x21\x26\xaf\x0f\x5f\xf6\xb3\xd2\xed\x3c\xf4\x7c\x1e\xa2\x33\x7a\x96\x9d\x49\x61\x3a\xe7\xdc\x25\x5c\xe2\xd4\x20\x72\x80\xbf\x09\xe6\xab\x68\x66\x96\xa6\x31\x7b\xec\xa3\xcc\x6d\x6c\x5a\x5b\xa0\x1a\x6c\xf3\x73\x34\xd3\x1f\x8b\xb9\xdf\x8a\x29\x65\xb4\x53\x17\x6d\x3f\x4c\xab\x78\x97\x66\xd2\x2d\xe1\xcc\x62\x99\x1a\x6f\x3d\x6d\xa7\x52\x76\xea\xaf\xca\x2a\x5e\x9e\x99\x2d\x4a\x7d\xe3\xa6\xef\xcd\xea\x13\xfa\x7f\xb8\xed\xc8\x6b\x1b\xdf\x19\x3a\xe8\x1b\x93\x84\xb6\xf3\xd1\x5a\x73\x8d\x84\x76\x6d\xbc\xd3\x03\x35\xed\x71\x5a\xfb\x64\xef\x76\x6f\x8f\x33\x4c\x4f\x0f\x18\xc1\xc5\xb6\x1e\x49\x2e\x7b\xff\x78\xf1\xd3\xcf\xef\x7e\xfe\xc7\xbf\xd0\x37\xa7\xa7\xe8\xdb\x45\x96\x06\x4b\xe0\xb4\x6f\xd1\x8f\xd2\x0e\xf9\xa1\xf1\x1e\x64\x38\x01\xae\x1a\x57\x66\x86\xd4\xe6\xb8\x16\x75\xbb\x29\x3a\xc5\x3e\x7f\xe2\x1d\xaa\x71\x6f\xb5\x55\x51\xbb\x59\x35\x45\x68\xad\xac\x4a\xac\x74\x6f\x6a\x83\x0d\x34\x6c\x53\x31\xe6\xf6\x44\xb2\x9a\xe3\x1e\x69\x6f\x78\x21\x8e\x73\xb2\x9d\xe7\x87\xac\x51\x76\x43\x92\xaf\x3b\x6a\x6e\x2f\xb7\x60\x09\x6f\xd5\x5d\x87\x5a\xa3\x76\xbb\x6d\xdf\xae\x26\xfd\x2f\xfc\x76\xb5\xd3\xeb\xc5\x57\x7e\x75\x63\x8e\x30\x0f\xe1\x80\x1e\x6e\x6d\x9f\xff\x71\xcf\x17\x7d\xb1\x14\x37\x48\xfe\xd8\x43\xbe\xa2\x29\xdf\x1e\xe1\x75\x7c\x37\x4b\xaf\x3c\xfb\xd9\xc9\xf8\x48\x94\x78\x8f\xa6\x61\xea\x2f\x73\xe3\xe5\x51\xba\x2c\x98\x67\xa4\x97\xa4\x09\xf1\xf6\x2c\xd5\xef\x25\x5d\xfb\x3e\x8e\xc5\xeb\x98\x79\x14\x04\x31\x31\xde\xab\xb0\x80\x15\xe5\xa7\x49\x3a\x8c\x08\xd2\x59\x0f\x75\x91\x5e\xea\x40\xde\xa3\x29\x94\x18\xf4\xce\xb0\xff\xfe\x3c\x4b\x97\x49\x60\x3f\x7e\x51\x5f\x7a\x3c\xc8\xd0\x2f\x19\x9e\x13\xd3\x53\x46\x7f\x36\x44\x34\xb2\x1b\xa1\xc5\x8b\xc5\x53\x9c\x29\x7d\xf5\xda\x37\x69\x1e\xd6\xc0\x8a\x68\xd0\x58\x04\xbd\xfb\x3b\x94\x57\x17\xe9\x32\x0e\xd0\x8c\xd0\x13\x35\x0a\xd0\xd9\xf7\x45\xf6\xc3\x99\xba\x70\xe5\x4b\xff\x02\xe1\x9c\xfb\x69\x3e\x23\x71\xfc\x65\x5f\x96\x1f\x62\x30\x3d\xbc\xee\xd1\x75\x1d\x32\x1f\x3d\xca\xd2\x2b\x74\x15\xc5\x31\xca\x2f\x70\x40\x50\x9a\xb0\xdd\x49\x0d\x0f\xdf\xac\x6a\x2e\x14\xeb\xb4\x72\x81\x2f\xf9\x63\x52\xbe\x35\x41\xbb\x86\x9a\x45\x6d\x5a\x2b\x15\x2c\xdc\x3b\xfb\xdf\x14\x33\x5e\x16\xe9\x1c\xc3\x26\x1e\xdf\xa0\x9c\x14\x28\xb8\x49\xf0\x3c\xf2\xa1\x71\xb6\x11\x53\x60\xe6\xbd\x9d\xb2\x67\x1c\x73\x5c\x90\x2c\xc2\x31\x27\x53\xb0\xca\x02\xc3\xfb\x88\xd6\x05\x84\x53\x9a\x41\x8a\x2b\x52\xf8\x6d\xe6\xba\x6d\x7a\x51\xbf\x4c\xaf\x84\x16\xc4\x67\xdb\x9e\x52\xf0\xbc\x93\x9c\x9f\x9f\x18\x9a\x8e\x3b\xeb\x74\x56\xaa\x8e\x74\x1f\xc5\x0a\x17\x45\x98\x59\xf9\x19\x7e\x89\x4f\x72\x76\xc4\x57\x51\x70\x67\x35\xd1\x5a\x41\x89\x3a\xc8\x63\x27\x63\x07\x79\x82\x02\x8f\x59\x4f\xe9\x50\x16\x3c\x8f\x3c\x1f\xf7\x5e\xc1\x72\x3c\xdf\x49\xa7\xa4\x4d\x19\x3d\x54\x56\xab\x43\x14\xbc\xd2\x37\x31\xbe\x61\xe4\x3d\x7a\xc4\xfe\x80\xc2\xd5\xf7\x79\x17\xba\x90\xc7\x29\xb7\x10\xb2\xe2\xcd\x50\xb2\xd9\x56\x18\xe1\xf7\x66\xa8\x24\x6b\x28\x6c\xa2\xa8\xdd\xd1\x97\xc0\x5d\xb5\x6d\x96\xdf\xde\x96\x35\x6e\x7c\x2d\x7f\x7a\x95\x5b\xe7\x1e\x9d\x41\x1a\x59\x77\xae\x3f\xbd\x1f\x67\xa0\x35\xd2\xab\x8f\x33\xab\x42\xa3\xe3\xc8\x9e\xce\x2f\x41\x82\xfc\x6c\xaa\xe0\x6d\x2b\x47\xf5\xf3\xe4\x4b\x93\xf0\x9a\x8e\x81\x38\x46\xeb\xf5\xc2\x8d\x50\xc9\x83\x78\x2d\x2d\xb3\xd8\x5e\x1d\x6a\x66\xbe\x24\x41\xbb\x6c\xae\x38\x59\x64\x84\xd3\xcb\x58\x2c\x3d\x89\xd2\xff\xac\x41\xf4\x5e\xa6\x57\xca\xd1\xe7\x65\x7a\xb5\x23\x3d\xf6\xe0\x41\x8f\xfd\xa0\xc7\xbe\x8b\x1e\xbb\x22\xcc\x11\xf3\x1d\x78\x8a\x73\xf2\xe0\x3e\x54\xab\x88\x86\x8a\x6a\xb4\xaa\xf8\x74\xe2\x80\xad\x6b\x44\x41\xc9\x8a\xf0\x20\xf9\xa7\xf4\x2a\xb9\xc2\x59\x50\xd5\x97\xc9\xd0\x0d\x5f\xd7\x96\x01\x78\xdf\x94\xeb\x7f\x72\xcd\xf5\x32\xcb\x41\x75\xbd\x48\x61\x28\x1d\xaa\xeb\x28\x89\xa3\x84\x74\x0d\xff\xa7\xff\x2e\xf3\x22\x0a\x6f\x9e\x31\x3d\x2e\xf7\x8e\xea\xe6\x05\xce\x94\xf2\x9b\x16\xfd\x24\x7c\x91\x1d\xca\x71\x97\x0f\x55\xa7\x4e\xb5\x5c\x1d\x52\x69\x91\x45\x73\x11\x0f\x5f\x53\x8e\x3b\x15\xea\x8d\xb1\xe8\x0a\x69\xec\x17\xd1\x25\x29\x29\xfc\xab\x91\x28\x12\xd0\x5f\x22\x3f\x4d\x4c\x9d\xfe\x02\xfb\x51\x71\x33\x95\x1e\xdd\x46\x5b\x14\xbc\xac\x89\x1f\x1c\x98\xe1\xa2\x78\xc4\xab\xb1\x2b\x88\x94\x2c\x94\x0d\xc9\xb0\x54\x45\x86\x13\xe1\xed\xc6\x53\x11\xc8\x92\x9c\x5f\x5e\x5b\x6f\x3c\x5e\x11\xde\xd8\xd1\xef\x61\x9a\xcd\xbd\xb7\x1d\xad\x0f\xc1\x32\xc3\x55\x68\xc4\xb7\x5e\x7e\x91\x66\x05\xc9\x44\x2f\xa5\x6b\xfe\x32\x27\xd9\x2b\xfe\xea\x88\xd9\x35\xac\xd0\x5f\x03\xc3\xee\x10\x90\xdc\x57\x23\x22\x09\x9a\x22\x2f\x4b\x0b\x4a\x70\x3f\x20\xe7\x6d\x33\x48\xd7\x8a\x1a\x83\x23\xbd\xce\x46\xc6\x82\x9f\x94\x9f\x7d\xe5\x05\x22\x21\x2f\xc2\xd6\x1b\x0f\xe7\x3e\xf8\x11\x91\xdc\x67\xde\x43\x77\xb5\x13\x58\xca\x4a\xf0\x69\xb7\x14\x95\x8c\x65\x61\x37\x88\x92\x73\xd4\xca\xa5\x69\x01\x62\x6c\x08\x95\x74\x4e\x67\x28\xa0\x0c\xbd\x9c\x27\x6d\xa5\xcd\x14\x1c\xdf\x58\x7f\x0a\x61\xc6\x44\xfa\x88\x9c\xd1\x85\x33\xa9\x40\x9d\x81\xc6\x9e\x24\x01\x09\x4c\x95\xe7\x83\xfd\xe2\x3e\xda\x2f\x78\xa4\x1d\xca\x1d\x48\x3e\x28\xd1\x5d\x0a\xe5\xbe\xbe\x16\xeb\x1b\xea\xef\x27\x68\xc6\x42\xe1\x32\xd5\x36\x63\xe2\xca\xa0\x24\x60\xec\x82\xcf\x8c\x57\x81\x36\xa6\x80\x2f\xe9\xb6\x5f\xa5\x59\x01\xfc\x68\x7b\x2e\xf2\x45\x21\xb4\xc3\xec\xe7\x76\xbd\x16\x57\x6a\xb8\xb5\xf7\x39\xd2\xa3\x91\x97\xdc\x55\x4b\xcd\xfa\x53\xe7\xca\xa8\xeb\xab\x65\xb3\x22\x88\xfe\xee\x1d\x1a\xf9\x80\xf3\x79\x70\x2b\x56\x29\x15\xf4\x0c\x7c\xb6\x16\x25\xb4\xc6\x1a\x94\xbc\x91\x9d\x7f\xdb\x41\xdf\x7c\x23\x7f\xb5\xd7\x55\xee\xea\xe2\xb2\xf9\x64\x6c\x2d\x3d\x6f\xc7\x50\x15\xe4\xec\x99\x3d\xf7\x63\x7b\x19\x2d\x16\xb1\x8c\x8d\xe4\xd6\x07\xb3\x5f\x2b\x22\x07\xfd\xff\xec\xfd\x7b\x73\x1b\x37\xb2\x00\x8a\xff\x6d\x55\xed\x77\x80\xf3\xdb\x9f\x49\xc6\x24\xf5\x70\xec\x64\xa5\xd5\xfa\xc8\xb6\xbc\xd6\x3d\xb6\xe5\x92\x94\x64\xf7\xfa\xa8\x22\x90\x04\xc5\x59\x0f\x07\x3c\x33\x43\x51\x8a\xad\xef\x7e\x0b\xdd\x78\x34\x30\x18\x3e\x24\xd9\x71\x4e\x92\xaa\x5d\x8b\x03\xa0\xf1\x6a\x34\x1a\xfd\xf4\x19\x6e\x1a\x88\x89\x0c\xc9\x5f\x7a\x30\x49\x27\x92\x66\x7b\xb2\x6e\x2d\x6f\x5e\xe2\x82\x09\xa5\x93\x37\x91\x50\xdf\x94\x52\xdd\xc4\xb6\xd4\x1e\xbf\x3b\x90\x56\xfd\x01\x0d\x4b\xbf\x62\x51\xac\x23\x95\xf5\x23\x8c\xa2\x51\x4c\x9c\xe8\xce\x50\x44\xa8\x68\x8e\x85\x15\x21\x12\x04\x46\xa0\x77\x27\x02\xb4\x03\x71\x82\x40\xfb\xe9\x33\x89\x03\xb7\xbe\xae\xac\x1c\x9f\xd3\x48\x72\x9a\xd7\xc9\x05\xb6\x7e\xf0\x6a\xcd\xb5\x8d\x9c\xe6\x4e\xc0\x72\x7c\x71\x7e\xd0\xaf\x7d\x6f\x6c\x3d\x0e\x2b\xce\x0d\xad\x8f\x55\xbe\x88\x34\x45\xf3\x7b\x9a\x3d\x65\x1d\x06\xfd\x64\x3c\xf5\xcc\x5a\x74\x70\x39\x7d\x45\x2c\x88\x09\x32\xe1\xe5\x08\x82\x82\x0c\x14\x3e\x6f\x6d\xb0\xcd\xad\xb4\xb3\xd9\xfd\x6e\x13\xfe\xef\xf5\xe6\x23\xb6\xf9\xa4\xbb\xf9\xfd\x4f\xdf\x8d\x3a\x5b\x17\x9b\x5b\xdd\xcd\xef\xd3\xce\xe3\xee\xe3\x1f\xd4\xff\xfd\xed\xf5\x77\xaa\xfa\x0f\xec\x07\xf6\x43\xe7\x87\x5f\x1b\x2e\xde\x60\x28\xc1\xb2\x2b\xe3\x15\x50\xa6\x72\x05\x46\xc1\x6c\x8a\xcf\x25\x90\x40\x4e\x6a\xe6\xfa\xb6\xdd\x59\x5b\x0b\xc7\x82\xf1\xc2\x14\xba\xb8\x93\x1d\x0a\xc6\xbc\xdf\xdd\xf1\x34\xd1\xec\x53\x43\xf7\xdd\x88\x52\x0e\xaf\x55\xc5\xcf\xf7\xf1\xa3\xaf\xf1\xc8\x9e\xf0\x5e\xad\xb8\xf4\x31\x08\xdd\x17\x74\xd4\xd0\xf3\x6f\x60\x2f\x22\x9b\x8e\x45\x8e\xda\x17\x70\x8f\x5e\x63\xec\x5c\x94\x7e\xa6\x31\x1b\x91\xcb\xec\x7a\x7d\x5a\x89\xa2\x65\x16\x18\x43\xb6\x79\x23\xaf\x1b\xf8\x93\xad\x65\x06\x7e\xc2\x7b\x9f\x69\xd0\xb1\x31\x7f\x09\xe2\x40\xb1\xed\xbb\x3f\xf5\x45\xff\x47\xb2\x3c\x25\xc5\x5b\x5e\x7b\x57\x7d\xff\xc8\xaf\x37\xef\xaa\x82\x0a\x7f\x26\x8f\xfa\x33\x79\xd4\xdd\x24\x8f\xfa\xf2\x4a\xd5\xcf\x93\xae\x8a\xe7\x59\x92\x9d\xd7\x81\xfd\x2e\xac\x38\x57\x63\x88\x55\xbe\xa8\xda\x13\x66\xb3\x7f\x21\xb2\xf2\x75\x52\x94\x22\x13\x75\x49\x97\xbe\x7b\x34\xa7\xcd\xc2\xf5\xf2\x6a\x93\x3d\xed\xc9\x69\xd6\xaf\x63\xd0\x1f\x6f\x55\x6a\xce\xeb\xc8\xd4\xf1\xc7\x79\xdc\xcf\x65\x9a\xf6\x78\x7e\x9c\xfc\x5a\xd7\xd1\x93\xc7\x8f\xe7\x34\x5a\x38\x39\xaf\xb6\x05\x84\x89\x9a\x93\x5f\x05\x16\xcf\xc9\x01\xf5\xe4\xb1\x43\xf3\x02\x2a\xd7\x56\xfc\x21\xa8\x38\x6f\x6c\x58\xe3\x8b\x2a\xb8\x4f\x78\xef\x20\x1b\x24\x7d\x5e\xca\x3a\x3c\x7a\xb4\xf9\x28\x5a\x7d\x41\x82\x30\x5b\x8f\x36\xc6\x95\x9d\x9b\xc9\xed\xc9\x93\xcd\xba\x16\x0b\x7a\xa4\x55\xbf\x36\x6d\xb7\x35\xc0\x98\xe3\x4c\xa6\x43\xfc\x7f\xcd\x0e\x60\x4b\xc2\xb3\x7b\x0f\xd8\x36\x07\xaf\x96\x1d\x60\x00\xf0\xb7\xd0\xf8\xcb\x0b\x91\x0f\x53\x39\xdb\x66\x8d\x51\x32\x18\x88\xcc\xea\x5e\x49\x8e\x2a\xe7\x94\xf6\xb3\xe8\x7d\x48\xca\x43\xdd\x08\x51\x13\x32\x61\x35\x4a\x39\xed\x8f\x1a\x6c\x7d\x9d\xed\x0d\x06\x2c\x39\x3c\x66\x63\xa9\x9e\xbb\xd3\x31\x2b\x4c\xb5\xae\xe7\x64\x96\x8a\xcb\xe7\x32\x2b\x79\x92\x51\x37\xb2\x20\xc4\x8a\xe7\x07\x66\xe0\x44\x9a\x2d\x17\xb5\x45\x1b\x2f\xf4\x52\xd9\xff\xe0\x59\x26\xe8\x64\x5a\x7c\x5a\x4a\xa7\x7c\x1e\x25\xa5\x38\x9e\xf0\x3e\xba\xdb\xcd\x72\x3e\xf1\x86\x33\x4c\x2e\xa9\x4f\x9a\x59\xc9\x7f\x55\x97\x52\xab\xb1\x1b\x95\x5c\x5d\x38\x23\x3f\xab\x34\x85\x83\xe5\x7e\x7a\x2f\x30\x8d\xa0\x1d\x57\xac\x2f\xfc\x08\x34\xf0\x0f\xaa\xd6\xf6\xa6\xa5\xdc\x5e\x42\x2b\x82\x3a\xfc\x5e\x2e\xf8\x07\x30\x04\x29\xba\x03\x39\xcb\x9a\x8d\x62\xdc\x68\xb5\x23\x3b\xe5\x7c\x11\xef\x32\x66\xcd\xc9\x48\xb0\xe7\xc7\xc7\x28\xe8\x07\x61\xa5\xc9\x90\xa1\x2f\x27\xad\x2f\xd4\xee\x2e\x44\x5b\xda\xd3\xa1\xf6\x6e\x19\x4a\x45\x3b\xfe\x14\x56\x65\x6d\xd6\xbe\x6b\x06\x98\x14\x20\xb1\x51\x4b\xc8\x92\x02\x04\x59\xa0\xd2\x1e\xca\x9c\xa5\x3c\x3f\x17\xec\x22\x11\x5e\xd2\x20\xbb\x7b\x4b\x6b\xd2\xd1\x81\x0c\xf6\xd6\x66\x3e\x89\xb8\x7f\xfd\xa9\x2d\xff\x1a\xb4\xe5\xb5\xd8\x73\x9e\xcb\x99\x75\xe8\x4b\x53\xb4\x87\xb8\xe0\x09\x1c\x7e\xcc\xef\xb7\x14\x56\x15\x63\xd5\x1a\xb0\xaa\xcd\xd2\xe4\x03\xf8\xba\x8d\x65\x2f\x49\x49\x8a\x9a\xe1\x34\x4d\x7f\x46\x9a\xb3\x12\x9a\xc5\x4f\x5b\x62\x39\x29\x7d\xd2\x5c\x47\xb6\xe8\x66\x67\xed\x85\x28\x45\x3e\x4e\x32\x9d\x07\x07\xcc\xa8\x2a\xbd\xc6\x7a\x43\x7b\xab\x79\xaa\x17\x85\x5e\xcd\xf7\x8b\x94\x33\xfd\x3e\x26\x8d\x5f\xa8\xc6\xd1\x76\x5c\xf3\xaa\xe2\x04\x4f\x97\xcc\x16\x05\xa2\x22\x9d\x64\x49\x63\xae\xc6\xc3\x09\xcf\xf9\x98\x7d\x44\x1c\xbd\xd6\x59\xa2\x4e\x6c\xbe\xa8\x42\x4e\xf3\xbe\xdd\x9b\xbe\x06\xef\xb7\xc5\x9c\x3e\xd7\xba\x93\x9f\x85\xe1\xf2\x14\x02\xea\xb5\x25\x69\x94\x14\xe5\x58\x0b\x33\x37\xdd\x30\x5d\x53\x3e\x55\xd0\x2f\xe4\x07\x51\xb8\xeb\xda\x60\x73\x22\x0a\x08\xee\xc5\xd3\x54\xce\x00\x9b\x47\x32\x4f\x7e\x55\x97\x39\x38\x3b\x9a\xfa\x08\xab\xa9\xb0\x7d\x96\x4c\xd4\x4b\xd4\x1c\x26\xd6\xe3\x04\x1f\xe8\xed\xb9\x34\x9e\x5b\x9c\x63\x3d\x31\xe2\x17\x09\x62\x9c\x77\xa3\x14\x7a\x9b\xd4\xe1\xe5\xb9\x00\x2f\xcc\x52\xea\x3a\x08\xe5\x4c\x71\x0a\x67\x78\xb4\x65\x96\x5e\xb1\x49\x2e\x0a\xb5\x3d\xea\xea\x84\x23\x29\x06\xc9\x74\x0c\xd3\x85\x8b\x20\x87\x33\x0b\x2c\x9b\x86\x20\x33\xdd\x9e\xa7\x33\x7e\x55\x78\x10\x4c\x95\xe1\x50\xd7\xc9\xc4\x85\xc8\xab\x55\xdc\x2a\xe0\xfb\x60\x0e\xc9\x33\x28\x0f\x1c\x0e\x6b\x80\xee\xb2\x21\x87\xc3\x46\x88\xb1\x11\x87\xe5\x52\xea\x24\x14\xd5\xdb\x97\x50\xdd\xe0\xad\xb2\xea\x4d\x14\xbc\x25\x6e\x78\x25\xf9\x50\xee\xe6\x6e\xf2\x60\xb6\x96\x27\x61\x67\x27\xbc\x47\x1c\xf2\x4b\x71\x59\x2e\x41\xb9\x1c\x5d\x6a\x33\x4b\x77\xda\xce\x60\x36\xdc\xaf\x9b\xe4\xea\xaa\xee\x38\x92\x0a\x3f\xb3\x1a\x38\x20\x6b\x0f\x5a\x32\x17\x75\xc9\x5d\xc9\x29\x1b\xc8\xac\x51\xb2\x19\x87\x24\x76\x61\xd5\x36\x54\xe9\xf3\x0c\x4f\x8f\x77\xa7\x95\x92\x9d\x81\x42\x9b\x2c\x4e\x98\xf4\x04\x7e\x1b\x53\x26\xf5\x4f\x60\x16\xa3\x7e\x1a\x55\x46\x32\x64\xcd\xfb\x5a\x58\x3f\x31\x32\xdb\xee\x88\x17\x87\xb3\xcc\x70\xb8\xa8\xa1\x0e\xe0\xb5\x5c\x1c\xf7\x72\xa4\x2e\xe8\x4c\xcc\xd8\x7e\x9e\xcb\xbc\xd9\x00\xb3\xae\xb3\x06\x7b\x68\x6b\xb3\x87\xac\x71\xc6\x46\xbc\x00\xc4\x66\xff\xd3\xe0\xd9\xd5\xff\x34\xda\xea\x20\xb0\x19\x2f\x58\x26\x4b\x55\xf7\x22\x19\xe0\x91\x39\xc3\x70\xbe\x64\xc0\x00\xa1\xcb\xde\xa9\x1b\xd6\xaa\x02\xc0\xa3\x3f\xbb\xd2\x56\x5e\x30\xef\x6e\x83\xc6\x59\x5e\x31\x92\xc4\x09\xef\x15\x6f\x44\xc9\xad\x23\x67\x02\xe9\x7a\xe6\x71\x03\xd1\xb4\xab\x85\x15\x17\xdd\xb4\xdd\x5b\x23\x79\xaa\x67\x77\xe7\x40\x58\x79\xc8\x6b\x90\xeb\xf9\x39\xcc\xf7\x48\xf4\xcb\x35\xc6\xd2\x95\x47\x9f\xe3\x8b\x77\xd9\x26\xf6\xa1\xa3\x35\x90\xb7\xc8\x7c\x56\x2c\x93\xee\xac\xf8\x9c\x39\xce\x8a\x3f\x4a\x62\xb3\x62\xc5\x6c\x66\xc5\x8d\x53\x98\x15\x25\x2f\x85\x3e\x89\x40\xaa\x3c\x89\x0f\xf5\x02\x40\x54\xdd\x70\x31\xc4\xb5\xd0\xc0\xa6\x18\xb7\x41\x0d\xe0\x74\x88\x2a\x04\xb4\xf9\x7f\x26\xcb\x52\x8e\x63\xed\x46\x98\x6e\x10\xef\x68\x62\x52\x64\x0a\xc1\x87\x20\x5a\x3a\x96\xd3\xcc\x79\x32\x6a\xb9\x82\x9e\xe1\xb9\x28\x9f\xcb\x6c\x00\xc2\x17\x9e\x6a\x1b\x07\xff\x28\x04\x99\xab\x54\xb3\xbf\x9a\xf4\x55\xbf\x2c\xcc\x5f\xe5\xaa\xc7\x92\x58\x05\x4f\xfd\xa0\x41\x50\x4a\x1b\x3a\xe6\x31\x68\xe3\x0a\xaa\xd5\x35\x97\x15\x6d\xa1\xcb\x68\xa3\x80\x23\xd2\x96\xc2\xb4\x69\x50\x23\x9a\xd0\x89\x54\x87\x6f\x3b\x7e\x76\xa3\xd8\xda\x7f\xbc\x36\x29\x3d\x22\xe5\x7a\xbc\x5a\x4f\x40\xd4\x2d\x64\x49\x9e\x2e\x32\x1e\x8d\xa8\x27\x88\x05\xa9\x9d\x86\xcc\x5e\x4b\xae\xc8\x3f\x49\x86\xe0\xb5\xc2\xd7\x46\x9b\x34\xb0\xef\x8f\xf9\x4d\x0c\x7a\xb7\xd8\x36\xa4\xb9\xf4\x56\x45\xa1\xf3\x71\xb0\x63\x64\x76\x0f\x1e\xb0\x66\xb0\xa1\x8a\xdd\x04\xde\x58\x11\x84\x48\x99\xcc\x1a\x2d\xdb\x45\xfd\xa2\x62\x1b\xad\x63\xa9\x8e\x62\xd1\xb2\x46\x10\xc6\xf3\xb2\x71\xc6\x7f\xf3\x92\x3b\xe8\xa4\xf8\x6c\x9b\x35\x14\x55\x69\x78\xab\x8b\xb9\x29\xe8\xe2\x3a\xa2\x10\x24\xa7\xb8\x48\x80\xb4\x6e\x53\x5a\xd6\xf5\xc9\x08\x49\x79\xe0\x24\x00\xf5\xe6\xd9\xcb\x9b\x86\x3b\x81\x65\x3b\xb6\x1d\xb0\x55\xad\x76\x78\xfc\x5b\xb5\x58\xb1\x68\xcb\x80\xf8\xfd\x96\x7b\x06\x3b\xa5\xb6\x0c\x37\x6f\xc1\x9e\x11\x5a\xbd\xec\xa6\x91\x26\xbf\x9b\x5d\xd3\x2c\x40\x64\xf3\x76\x2a\xb7\x10\xe1\x7b\xdd\xd5\x03\xec\x74\xdb\x6d\x82\x7f\x15\x95\xae\x89\xc9\x0d\x87\x85\xea\x45\x81\x80\x55\x15\x9a\xed\x49\x35\x53\xb0\xec\xd5\xa5\x2a\xa8\xee\x9f\xc9\x69\x36\x48\xb2\x73\xc7\x7f\x36\x49\x5e\xa5\xf5\x75\x86\x58\xc3\x38\x3c\x32\xf0\x19\x86\x39\xb5\x5d\x0b\x2d\x7c\xc3\xbb\xf1\x21\xe1\xa4\x2d\x9c\xd2\x67\xee\xdd\x36\x52\x26\xdf\x8e\x4b\xe1\xae\x1b\x24\xa9\xc4\x3c\x4e\x23\xe0\xf5\x6b\x9a\xbb\x3a\xf5\xad\x3d\x8e\x9f\xc2\x01\x14\x8a\x68\xa2\xd5\xca\xb9\x46\xee\x7b\x8b\x2c\xbf\xb7\x7d\xd1\xae\x17\x4c\x9c\x54\x0a\xdb\x23\xd7\xa5\xa0\x77\xd5\x9f\xb4\x48\xbf\x04\xa0\x2c\xc7\xb0\x5b\xfa\xbf\x6b\x97\xcf\xd3\x47\xa6\x25\x70\x49\xdd\x3d\xf8\xd6\xbe\xbf\xbb\x8b\xfc\x54\x88\x5e\xbf\x10\x9f\x21\xba\x7d\xfa\xeb\xfb\x8d\x53\xfb\xb7\x3d\x28\xba\x1b\xf3\x5d\xf3\xe9\xec\x1f\x6c\xc3\x4f\x55\xa6\x07\xaa\x20\x5b\x78\xd8\x07\x0c\xea\x44\x1e\x64\x03\x71\xf9\x1e\x7e\x9c\x9e\xd2\xbc\x60\x4b\x3b\x75\x80\xe1\xb9\x36\x32\x71\x54\xe2\x99\x94\xa9\xe0\x59\xb3\xe4\xbd\x56\x9b\x35\xde\xe8\x88\x65\x9d\x1f\x0f\xb6\x89\x3c\xd4\x3e\x9f\xe1\xed\x8c\xdf\xe0\xd5\x0d\x62\x70\x08\x82\xd8\x50\x38\xe0\xaf\xb0\x3e\x18\x7a\xf5\xd5\xf4\x9e\xaa\xff\xaf\x3b\x95\x96\xc8\xd8\xfd\x5c\xf3\xff\x35\xea\x52\x7b\xda\xb6\xed\x5f\x6d\xd3\xd1\xb6\xed\xf1\x3a\x20\x45\x25\xbe\x04\xed\xfb\xde\x7c\xa7\x0b\xac\x63\x72\x79\x14\x5d\x14\x68\x18\xa2\xa9\xad\xb6\x33\x71\x2b\x18\xe3\xa7\x11\xc0\x74\x32\xe0\xa5\x20\xca\x64\x5e\x8a\x26\x61\xac\x2d\x1d\xa2\xd5\xe9\x9d\x85\x2d\x5c\x52\xe2\xcd\x27\x4f\x82\x24\xcc\x01\x8f\x50\xc3\xde\xd7\x93\x4d\xfc\x3a\x96\x17\x42\x91\x69\x84\xd4\xec\xc4\x89\x53\x98\x2e\xb7\x3d\xf7\xe6\xbb\x9b\xa1\xdc\x64\x24\x11\xa6\xd4\x97\x00\x54\x33\x22\x5b\xce\x1b\x35\xeb\x36\x93\x71\xf0\xdd\x1e\x6b\x7d\x87\x8b\x12\x77\xc8\x4d\xa2\xf6\x11\x18\x3e\x03\x3b\x01\xe8\x2a\xd2\xc7\x13\x60\xbb\xb5\xb9\x05\x4a\x2e\x8b\x63\xfe\x66\x78\x8b\x38\x10\x69\xc9\x83\x5b\x9b\x3e\x8c\xba\xfe\xc3\x68\xa9\xfb\x7b\x3c\x4d\xcb\x64\x92\x26\xf0\xe8\x99\xc7\x94\x75\x36\xd9\x36\xdb\xdc\xf1\x1a\x67\xe2\xb2\xf4\x2d\xa9\xa2\x57\xe4\x43\x06\x23\x67\xdf\x92\xde\x3c\x76\xe0\x65\x72\x09\x72\x96\xfd\x01\xc9\x04\x08\xce\x8e\xd9\x85\xc8\xcb\xb9\x23\x53\xef\x97\xba\x0b\x75\x20\x4a\x61\x5e\x66\x20\xaf\x6e\xb6\x74\x4b\x71\x21\xf2\x42\xc4\xe6\x65\x8c\xb8\x2c\x87\xab\xee\x42\xef\x06\xd6\x83\xfa\x36\x98\x7e\xdd\x01\x41\x78\xc7\x5a\x22\x7c\x90\x95\xf2\xa7\x44\xcc\x96\x13\x0a\x6c\xd5\x4b\x05\x22\x4f\xe2\xad\x6a\xa6\x63\xbc\x36\x82\x5a\xf0\xd1\x7b\x23\x62\xb1\xcf\x38\x56\x98\x49\xc3\x40\x06\x7b\xe1\x65\x15\x2c\x83\xf6\x14\x66\xd7\x5e\x1c\xd1\xbb\x2a\x5a\x5f\xfd\xeb\x25\x29\xbe\x6f\x1a\x7c\xfa\xc4\xee\x1b\x80\x14\xa9\xf1\xc2\xaa\x70\x25\x90\xc2\x1c\x9b\xc2\x8e\xb2\xbf\xdb\xb1\xc2\x6f\x0a\x62\x7d\x1d\x78\x21\x06\x2e\xd6\x72\x68\x6c\x2b\x92\x82\xc9\x29\xd8\x1d\x5c\x24\x62\x36\xff\x20\x58\xd8\xde\x31\xf0\x47\xd0\x09\x46\xb0\x0a\x0e\xd6\xa1\x1e\x13\x69\x21\xbc\xc9\x02\xbb\xc6\xfe\xe1\xfa\x82\x0f\xc1\x74\xb1\xd2\xf2\xf3\xfd\x65\xd5\x09\x63\x07\x9d\x70\x14\xab\x4c\xf9\x97\xe5\x8e\x5b\x0d\xb5\x5d\xee\xbc\x3d\xaa\x3f\x6f\x75\x32\xb2\x47\xab\x0b\xc9\x1e\xd5\x4b\xc9\x22\xa7\xfa\xd1\x7c\x82\x0e\xc1\x39\x3d\x71\x8e\xdf\xf3\x7d\x90\xd8\x0c\x87\x8d\x0a\x6b\x0d\x5d\x68\x0e\x8d\x2c\x34\x19\x8d\xdd\x16\x7c\x2f\xec\x92\x36\xf4\x21\x11\x34\xa1\x6f\x2b\xaf\x09\x29\x20\xcc\x3a\xb1\x9c\xd5\xb8\x74\xbb\x07\x52\x48\x9e\x2a\x5d\x79\x42\x9b\x05\xb7\x9e\x37\xff\x7f\xf8\x73\x7b\xe8\x0d\x7b\xdb\xfb\xf5\x0f\x92\x5b\x9d\xf4\x4b\x18\xb6\xe5\x3a\x36\xc0\x1c\xf8\xc5\x43\x09\x1f\x42\xc1\x84\x15\x42\xd4\x0b\xb1\xc0\xf0\x32\x1c\x6a\xac\x09\x29\xf7\x9f\x55\x21\x9f\x56\x11\xb6\x07\x03\x6a\x57\x05\xee\x95\x01\x5c\xb7\xea\x5e\x28\x70\xee\xc5\x78\x62\xdc\x95\x97\xd1\x81\x10\xa5\x50\x0b\xfd\xb9\x8c\x36\x8a\x7a\x8c\x84\x0a\xa9\xf7\x38\x49\x48\x42\xed\x02\x50\xbe\x48\x06\x6f\x30\xe3\xff\x1a\x63\x55\xd5\x6d\xa5\x1e\xa1\x3d\xeb\xeb\x4c\x14\x69\x92\x95\x1d\x1d\xcd\xa0\xa3\x28\x5c\x27\x4d\x32\xc1\x40\xca\xb6\x9e\xc9\xce\x20\x19\x74\x40\xe5\xd0\x29\x44\xd9\x81\xe5\x5f\x33\xa4\xc2\x5f\x66\xab\x98\xc0\x60\x08\x76\xc5\xea\x9f\x45\x91\x57\xd1\x52\x0c\x2b\x24\x64\x65\x75\xcb\xf1\x23\xb4\x5e\x62\x3d\xb0\x62\x73\x92\x8b\x8b\x77\x46\x17\x2d\x2e\xa0\x2b\xaa\x8b\x9e\x3f\x20\xb7\x96\x27\xd6\x98\x67\x0c\x97\x0d\x84\xfb\x41\xa3\xa2\x01\xe3\x25\x9a\x6b\xf0\xb1\x60\x65\x32\x46\xfb\x30\x6c\xf7\xb3\x60\x99\xd0\xf6\x73\x23\xd1\xff\xc0\xf8\x39\x4f\xd0\x30\x09\x6f\x2d\x67\xf3\x65\x0c\x6b\xbb\xab\x2d\x2d\x65\x41\xdc\x21\xf2\xd5\x5f\x70\xc6\xec\xfc\x83\x42\x7a\xc0\xe6\xf0\x94\xcd\xf0\x4e\x9c\xb3\x51\x3f\x27\x69\xfa\x63\x36\x5e\x06\x75\x49\xd5\x66\xb0\x31\xf4\xb9\xde\xed\xf3\xac\x2f\xd2\xa6\x8f\x4b\xe1\x0b\x2a\xa8\x15\x19\x62\x6c\x3d\x6b\x86\x18\x5d\x7a\xe2\x82\xcc\x82\x57\x12\x79\x1f\xc5\x98\x64\x2c\x8e\x70\xc7\x3e\x63\x7c\x5b\xbe\x78\x05\x96\x78\x1e\x37\xac\x46\x96\xe2\x85\xb9\xb1\x13\x61\x73\x75\x54\xf1\x0a\x83\x8c\x9a\xb2\xdc\x45\xda\x99\x77\x0d\x45\xd8\x3a\x77\x03\xb3\x87\xae\x9c\xde\x46\x9d\xb0\x99\x11\x37\x46\xa0\x39\xba\x9e\x5a\x46\xb2\x96\x45\x06\x1b\x12\x33\xf2\xa8\xe0\x31\x09\xdd\x12\x42\xa5\xb2\x2f\xd9\x5c\x5f\x67\x6f\xf8\x15\xeb\x09\x36\xcb\x65\x76\xce\xa6\x59\x99\xa0\x3d\xea\x50\x66\xa5\xe2\x80\x53\xc9\x07\xda\xc8\x19\xfe\xd3\x9a\x68\xb3\xc6\x4f\xed\x78\x67\x46\xa4\x6a\x86\xe5\xed\x49\xd3\x1f\x18\xce\x46\x1d\xf9\x5a\x82\x80\x55\x3e\x7d\x0a\xa6\xa4\xfb\x99\xdf\x14\xea\xb4\x14\x02\xdc\x47\x23\x0b\xf0\x23\x75\x17\x5a\xa4\xa7\xe5\x6b\x23\xf0\x2a\x49\x72\x37\x51\xa8\xd8\x0f\x36\xe5\x7a\x31\x99\x42\x0b\xbb\x9a\x53\x8f\x85\x21\x13\xef\x82\xd2\x3f\x6a\x87\xdc\xc8\x96\x3e\xb5\xfe\xa9\x36\x6a\xf7\x38\xbf\x1f\x51\xa6\x2f\xd4\xa3\x1b\x8b\x76\x57\xd9\x7c\xa9\xd1\xe7\xd7\xaa\xf2\x8d\x40\xda\xa8\xc9\xe3\xf1\xb2\x58\x24\xf6\xd6\x2f\x35\xc1\xb7\xd4\x7f\xd6\x16\xda\xd5\xb3\x9f\x68\xbd\xaa\x29\xb3\x6b\x50\x2d\x8b\xb7\x04\xe3\xbf\x48\x2b\xf5\x9d\xb6\x30\x4a\x6e\x57\xd7\x7c\xa9\x7f\x7d\xad\x64\x9c\x70\x33\xbb\x84\xc5\x26\x09\xc6\x82\xd1\xd5\xb6\x9f\xa2\x2f\xba\x05\x97\xcf\x2f\xe4\xf6\xf1\xd6\x67\xb5\x80\x67\xbf\xd8\x88\x67\x01\x9e\x42\x88\x33\x8d\x8d\x61\x18\xb4\x30\xd1\xab\xa9\x6f\x91\x03\x6d\x2e\xc3\x8d\xf7\xbf\xaa\x89\xa3\x35\x2d\x6e\x1f\x64\xf8\xb0\x5b\xe4\x7e\xe9\x3d\x68\x60\xbc\x06\xba\xbc\x10\x53\xd3\xac\x21\xfc\x50\x8b\xa5\xfe\x80\x55\xb1\xd9\x65\xcd\x09\xbe\x49\x40\xb6\x30\xaa\x9a\x83\x66\xc4\xc8\xab\x05\x57\xab\xfa\x61\xf9\x19\x47\x1e\xad\x9a\x72\xe4\x11\x49\x12\x92\x5c\x8a\x41\x9b\xdd\x77\xab\xb8\x4a\x3a\x0f\x02\x88\x9c\x14\xe6\x01\xa3\xd5\x5b\xde\x6a\x94\xbc\x77\x50\x8a\xb1\x9d\xd5\x6a\xab\xe2\xf9\xb3\xad\x12\x05\xcf\xd2\x4b\x47\x4b\xd5\xbd\x44\x06\xdd\xda\x89\xde\xf7\x0b\xe3\xe2\xf8\x8e\xad\x31\xfb\x9c\x02\x6f\xab\xda\x6b\x35\x6a\x29\x30\x8f\x1c\xea\x50\xb8\xfe\x11\x21\xaa\x06\xca\x27\x57\x34\x62\x74\x33\xe0\x80\x9a\xa2\x8d\x4a\x89\x56\x8f\x06\xd3\x7f\x6e\xf4\x9f\x63\x3e\x69\xd2\xfb\xa4\x4d\x24\x61\xf0\x9d\xde\xe5\x20\x63\x0d\x41\x25\xc5\x4f\x3c\x4d\x06\x66\x29\xb1\x91\xff\xea\xd7\x7a\xc2\x50\x99\xe8\x73\x9d\xaa\xdd\x4f\x9a\xde\xc1\x8f\x2e\x21\x7a\x8a\xd7\x71\x13\x25\x92\x41\xb8\xc1\x7d\x9d\xac\x83\x74\x6a\x40\x05\xad\xe0\x44\xbb\x94\x47\xb4\xeb\xdd\x5d\xe6\xf3\xf8\x8c\x2e\xf0\xc3\x5d\xaa\x0d\xa8\x0b\x62\x94\xca\x4c\x78\xcb\xd1\xf6\x56\x83\x38\x1d\xcd\xbf\x60\xb7\xdd\x20\x15\x9e\xeb\xb9\x22\xf6\xe9\x07\xbd\x2a\xb0\xf5\xbd\x9b\xce\x26\x55\x08\x53\x39\x31\xcf\x78\x2c\x76\x9f\x12\xfb\xfb\xe8\xad\xa5\x79\x2e\xb7\x6c\x6e\x4f\x1d\xf7\xd6\x5a\xc2\xfa\x6e\x8e\x5d\x24\x79\xbe\x2f\x1f\x2b\x8a\xf9\x39\xba\xd9\x6d\xb3\x06\xb1\xc5\xb1\x21\x23\xa1\x15\x68\x80\xc8\x92\xe7\x10\x59\xa8\x31\x4b\xb2\x81\x9c\x35\xda\x4c\x66\xf8\x22\xde\xae\x3e\x92\x49\xa4\xe7\x15\xec\x11\x97\x1d\x2a\xd9\xc0\x60\x8d\x18\xab\x2e\x47\x48\xa7\x9d\x79\xec\xfc\xc1\x39\xbb\x3e\x8f\xd1\x5e\x76\x64\x91\xb1\x31\xef\xf0\x30\x9f\xc2\x56\xee\xe5\x76\x50\xb7\x4a\xb7\x3d\x8d\x70\x58\x3d\x17\x43\xef\x31\x31\x6c\x66\x72\x20\x5a\x95\x21\x58\xca\xa3\x45\xe4\xaa\xd6\x4e\x50\xe7\xba\x02\x5c\xaa\xa1\x40\x4e\xd3\xa4\x28\x1b\x61\xb1\xcc\x8c\x88\x33\x2a\x1c\x59\x9b\x03\x7b\x85\xf5\x8d\xae\x70\x80\x01\xf5\xf7\x7b\x65\x4e\x24\xb1\x96\xfb\xaf\xe5\xd7\x22\x8b\x1f\x23\x5b\x6b\x35\x0d\x97\xb2\x44\xb4\xf5\x8d\x6d\x1c\x95\x1d\x61\xea\x38\x4d\x3f\xd4\x4a\xee\xac\x5d\x37\x2b\x57\x21\x75\x22\x00\x9b\xf7\x48\x78\x49\xe7\x8e\x6c\xed\xbd\x29\x19\x37\xdf\x42\xc7\x4b\xeb\xa0\x14\x38\xe1\xb9\xdc\x37\x94\xeb\xdd\xd6\x86\x7f\xed\x98\x8f\x58\x25\x18\x06\x8d\x87\x47\x28\xb6\x75\x7f\x5a\xbb\xde\xb9\x61\xb8\x4b\x55\x7c\x82\xce\x51\x10\x1e\xcd\x8f\x7f\x59\x98\xa8\x97\xc5\x67\x8a\x75\xf9\xf8\x6b\x0c\x9c\xb7\x5c\x54\x9a\x27\xf1\xfa\x73\x03\x4a\xd2\x8a\x5f\x24\x6c\x49\x15\x29\x7e\x89\xdb\xa7\x57\x63\x1a\x3e\xf9\x2d\xb7\xe6\x5e\x7c\x67\xfe\x0c\x6c\xf6\x67\x60\xb3\x5b\x05\x36\xfb\x7d\xe6\xfa\xff\x4d\xe3\x80\x95\xa3\x5c\x96\xe5\x9c\xd0\x3e\x5b\x95\xaa\xf3\x7a\x32\x75\xbe\x58\xd4\x26\x1b\x0b\xe8\xe3\xda\x3d\x12\x73\x66\x72\xd9\x68\xaf\xdd\x33\xa9\x63\xdc\x17\x12\x33\x87\xf7\x0a\x99\x4e\x41\xe9\x74\xaf\x94\x93\x6d\xd6\xe8\x6c\x6e\xa8\xff\xb0\x26\x89\x12\xa4\x43\xd2\xb4\xd7\xee\x8d\x0b\x1b\x07\x08\xb9\xd1\x86\x65\xe4\x1b\xd6\x2f\x32\xbc\x60\x88\x79\xa4\xe7\x1a\x79\xaf\xce\x33\xd2\x03\xd0\x66\xbf\x78\x7c\xcd\x3d\x0b\xce\xab\x06\x72\xf2\x7b\xf7\x88\x8b\xa4\xfe\x11\x73\x90\xbc\x77\x6f\x19\xf7\xc8\xca\x7d\x76\xef\xde\x67\xf2\x92\xbc\x77\xef\xde\x7c\x17\xc9\x7b\xf7\xae\x55\xf7\x9f\xc9\x3d\xd2\x9b\xe8\x2a\x7e\x92\xfe\x0a\xdd\xd8\x61\x52\x94\x6f\x04\x2f\xa6\x79\x8d\x1f\xe1\xbd\x7b\xf7\xa8\x89\xa1\x67\x4a\x0b\xdf\x21\x9f\xba\x1c\x0e\x0b\x51\xea\x92\x0e\x2d\x41\x9d\x9d\x31\xb3\xad\x42\xf3\x4c\x78\x28\x30\xa3\xe6\xab\xc0\xd2\xb6\x3d\xf7\xee\xcd\x35\xe8\xb6\xf4\xa2\xce\x7a\xf6\x1e\xa2\x28\x55\x0d\x10\xfb\x56\xf3\x59\xf1\x17\xba\xe6\x24\x17\x17\xc1\xdc\x2b\x66\xc4\xa4\xaa\x3f\x31\x7f\xbe\x74\x21\xfc\xf5\x6f\xb6\xa0\x2c\x19\xb2\x26\xe9\x8f\xd8\xc6\x04\xbb\xf0\xe9\x13\xe9\x2c\x52\x0d\xcd\xaa\x71\xba\xf7\xcc\xa4\x9a\x1f\x43\xc3\xe8\xed\x38\xf8\x36\xf3\x01\x55\xaa\x61\xbf\xd7\x38\xe8\x6b\xdc\x13\x63\x68\x7c\x2b\x83\x19\x38\x72\x73\xcc\x65\x02\x2a\xf5\x5e\x4d\xb0\xde\x6a\xe6\xde\xbd\xe5\x6c\x66\x2c\x4e\xbc\x96\x7c\xe0\x69\xed\xba\xf8\x4d\xa3\x83\xda\x1e\xfc\x60\x96\x76\xce\x5e\xde\xc3\x9a\xb1\x45\x5f\x6e\xcd\x17\x2d\xf9\xda\x3d\xd0\x6c\x56\x16\xc0\x37\xbf\x98\xb3\x06\xa1\xf1\x85\x99\x4f\x8d\xe5\x45\xb5\x4b\xab\x4a\xbd\x77\x6f\x7d\x9d\x3d\x97\x79\x2e\x8a\x89\xcc\x06\x05\x2b\x25\xdb\xdc\x60\xc3\x1c\x82\x99\xf2\x92\x3d\xd9\x60\xaf\x7e\xed\xae\x45\x46\x43\x34\xae\xf7\xcc\xed\xe1\xab\x55\xab\x27\xb6\xfe\xc0\x2e\x27\xec\x53\xbb\xa3\xc5\x18\xea\xcf\x6c\x9a\xa6\x6d\xef\xa4\x2c\xe9\x97\x7b\x77\x82\x3b\xed\x2b\x83\xa3\x58\x10\x84\x1f\x06\xae\xf1\xef\x9e\x16\x50\xe9\xd7\x37\x7e\xab\x97\x42\x41\xf1\x3d\x2d\x7b\xca\x30\xf6\x23\xca\x9e\xa0\xe0\x1a\xfe\xb9\x6e\xa9\x7f\xec\x86\x9f\xaa\xbf\xf4\xba\x7a\xc7\xcf\x49\x43\x7c\x21\x88\x7f\xb3\x55\xa4\x21\xf7\x8c\xaf\xb2\x9e\xb0\x13\x26\xab\x0f\x71\xb1\x43\xd0\x6f\xf8\xae\xfc\xfe\x0e\xdf\x95\x7f\x59\xf1\x5d\x49\x1f\xfc\xea\x78\xfe\x65\x6d\x7d\x9d\x3d\x83\xd4\x5a\x32\x63\xa3\xb2\x9c\x14\xdb\xeb\xeb\xe7\x49\x39\x9a\xf6\xba\x7d\x39\x5e\x87\x15\xeb\xf4\xa4\x2c\x8b\x32\xe7\x93\xf5\x81\x1c\x77\x46\x22\x9d\x88\xbc\x58\xef\xa5\xb2\xb7\x3e\xe6\x45\x29\xf2\xf5\x22\xef\xaf\x4f\xcb\x24\x5d\x4f\xb2\x17\x87\x6f\xba\xff\x29\xfe\xb2\x86\x5a\xa9\x17\x87\x6f\xd8\x2e\xbb\x7f\xbf\xa9\xe3\xfe\x20\x8a\xa1\x31\xae\xf5\x86\x02\xe7\x05\x2c\xe9\x0e\x64\x1f\x38\x9b\xc8\x27\x1f\xb7\xd4\xe8\x41\xdc\xce\xfb\x23\x31\x50\x0f\x86\x9d\xbf\x10\x8e\xba\x10\xc4\xdf\x01\x7a\x6f\xb1\x8f\x7f\x01\x79\x99\x6b\xa1\x8e\x27\x36\xbc\xfe\x8b\xdd\x49\xbf\xa9\xba\x1d\xbd\x0f\xc1\xa2\x95\x23\xc1\xfe\xf3\xbf\x53\x91\x5f\xb1\x09\x84\x61\x89\x2d\xa3\x2c\x47\xb9\x10\xeb\x58\xaf\x9b\x97\xa9\xf6\xc0\xe9\xa8\xde\xc9\xa8\x43\x3f\x8d\xa6\x1d\xb3\xa2\xe6\x6e\xdc\xf6\x33\x23\xfe\xb0\x74\x1d\x40\x2c\xe8\x5a\xde\xc7\x8d\xf8\xf4\x89\xdd\x0f\xd7\xb4\x27\x07\x57\x31\x70\x8d\x24\x1b\xe8\x30\x46\xbc\x14\x0d\x1f\xa6\x5a\xf7\xc1\x74\x3c\x56\x4c\xeb\xdc\x4d\x42\x02\xd0\xd2\xad\xa1\x49\x17\x73\xfc\x81\x56\xae\x19\xb4\x3a\x11\x97\xe5\x5b\x39\x10\xcd\xc6\xde\xb3\xe7\x2f\x1a\x2d\xbf\xe1\x20\x51\xef\x3e\xb0\xc8\xf2\xbe\x03\x3d\xe9\x0e\x65\x56\xea\xf7\x44\x63\xf3\xbb\xc9\x65\xac\xce\x4c\xf3\x3b\x8d\x9a\xf2\x91\x61\x9d\x1a\x9b\xf1\x0a\xe6\x75\xa4\xaa\xd8\xe7\x51\xa4\x5e\x09\xc6\x13\xf8\x5e\x8a\x43\x32\xaf\x27\x55\x4d\x3f\x9f\x4c\x2d\xba\x35\xfe\x6a\xa9\xf6\x66\x4d\x3c\x2c\xb6\x8e\x3c\x3b\x6e\xd3\x75\x6f\x9e\xf9\xb4\xb7\xd3\x3e\x04\x93\xec\xc2\xdf\x69\x70\xa3\x20\x6d\x2a\x40\x77\xd9\xe6\xce\x5f\x3c\xad\x69\xb5\xca\xee\x6e\xd0\x73\xb5\xf7\x4c\x9c\x63\x7c\x56\x02\xec\xda\x1b\x89\xbf\x2c\xb9\x18\xcb\x0b\x11\x59\x96\xd8\x69\x20\x87\x3b\x3c\x61\x6c\xb7\x72\xe8\x6a\xa8\x62\x51\xf2\xfe\x07\xb3\x6b\x70\xaa\xf9\xfa\xd6\x77\x8f\xfe\xf6\xdd\xa3\xef\x9f\x90\x23\x5c\x63\x9a\xdf\xd4\x61\x12\x7d\xb7\x73\x77\x9a\xbc\x15\x35\x21\x15\x89\x75\x20\xd6\x5c\x5f\x67\xef\x44\x3e\x94\xf9\xd8\x04\xfa\xeb\x4f\x53\xc8\xa3\x5a\x60\xc4\x39\x88\x51\xe7\x2c\x18\x93\x82\xe5\x25\x44\xcb\xe4\xe0\x1d\x3b\x16\x45\x91\x64\xe7\x6c\x3a\xc1\x9c\xa0\x65\xce\x7a\x1c\x03\xde\x11\xbc\xb1\xcd\xef\x1b\x03\xc8\x18\x81\xa8\x0c\x8e\xd0\x86\x32\xbe\xb2\xcd\x16\x41\xcf\xd2\x46\x74\xf3\x29\x4d\xac\xaf\xb7\x18\x62\xe9\x2d\x7f\xeb\xf7\x55\xcc\x92\xb2\x3f\x62\x3e\x79\x47\xe4\x2a\x04\x41\xaa\x6d\x1f\xf5\x34\x54\x7f\x99\xcd\x5b\xce\x7c\xf5\xdd\x0a\x2a\xb3\x75\xbd\x98\xa3\x77\xdb\x4e\x3a\xb5\x4b\x1a\x5b\x71\x82\xd3\x35\x28\xc7\x76\xeb\x90\x91\x5e\x94\xc5\x22\x7c\x75\xbd\xc6\x70\xf7\xab\xc0\xc8\xea\x79\xb1\xa1\x5d\x82\x1d\xd3\x4e\x71\x9f\x1b\x61\xef\x04\x4b\xa3\xb3\x8a\x23\x4e\x0c\xc9\x6a\x70\x56\xfd\x07\x41\x9c\x97\xc5\xe3\xb9\xc3\xb8\x11\x56\xd7\x0d\xc3\x08\x30\x97\xe8\x7f\x29\x98\xd7\xde\x29\xa9\x41\x74\x05\xac\xf6\x94\x54\x98\xf7\x1f\x6e\xc5\xbc\x43\x9c\x10\x5e\xa7\xb7\x79\xf2\xf8\x6f\x2d\x22\x13\xd6\x11\x35\xc1\x8c\xbf\xcd\xec\x71\x2c\x65\x9b\xc9\x09\x1c\xb0\xb6\x8d\xf4\xea\xb2\xd7\x42\x7e\x75\xb6\xcb\x1e\x66\x62\xc6\x5e\xa0\x93\x8c\xfa\x3e\xcc\xe5\xd8\xed\xdb\x7b\x05\xf4\xd4\xa4\x73\x85\x47\x73\x0a\xe6\x41\x18\xcb\x4b\x17\x08\x85\x16\xbb\x2c\xc9\x0e\xa7\xe5\x71\x92\x19\x50\x26\x75\x37\xdb\x65\x8f\x1e\x6f\xa8\xca\xe6\x74\xc8\xa1\x19\x5a\x10\xaa\xd3\x18\x15\x98\xf1\xb2\x5d\x53\x71\x0d\xd5\xd7\xc8\x66\x40\x1d\x0b\xc1\xfe\xf5\xe9\x13\xfb\x88\x16\xd2\x7a\x44\xba\xa0\x0b\x3f\x3f\x7d\x82\xcf\x9a\xc1\xb2\x43\x33\x75\xec\xa7\x4f\x9f\x6c\x71\x38\x16\xfb\xe7\xa7\x4f\xbe\x64\xf1\xda\x38\x45\xa9\x19\xe2\x12\xee\xee\xb2\x52\x06\xf9\xb2\x4c\x7b\x63\x7d\x40\x22\x46\x6a\x3e\x98\xf1\x34\x17\x7c\x70\x05\xfe\x37\xf0\xdc\x36\xfb\x6b\x38\xca\x86\xb5\x07\x08\xf7\x08\xf5\xfd\xd7\x5e\xd4\x3f\xdc\x33\xe7\xc0\x49\xf7\x10\x74\x86\x61\x03\x9e\x25\x63\x5e\x0a\xd6\x2c\x93\xb1\x28\x4a\x3e\x9e\xd0\x40\x99\xb6\xb9\xb3\xfe\xa8\x99\x9a\x37\x39\xed\x94\x66\x5b\x37\x88\x4d\x43\x75\x16\xc6\x6e\xe1\xda\x05\x27\xcc\x80\xff\xa5\xb8\xaa\xc9\x71\x02\xf6\x95\x6f\x78\x39\xea\x8e\x93\xac\xb9\xd9\x66\xcd\xa6\xaa\xdc\x41\x04\x6f\xb1\x75\xbb\x99\xad\x96\x6d\x26\x80\x67\xdb\x85\x7f\x61\xa2\xad\xb5\xb5\xca\x58\xd8\x2e\x6b\x62\xc5\x6f\x59\xb3\x94\xac\x03\x67\xa3\xd5\x62\x0f\xe1\x0f\x6c\x01\x03\xf8\x3b\xdb\x64\x4f\xd5\x81\x6d\xea\xd5\x6b\xb1\x6d\xf8\x19\x73\xa0\xb5\x0b\x05\x92\x02\xbf\x4b\x3d\x6f\xbb\x8d\x14\x24\x49\x25\x8c\xeb\xb8\x76\x4d\x88\x80\x3d\x7b\xac\x99\x79\x69\x1b\xba\x8f\xd5\xf0\x37\x59\x07\x17\xa9\x2f\x8b\x26\xfc\xf1\xee\x80\x7d\xcb\xd4\x9a\x5c\xaf\xad\x21\x5d\xea\x6a\xb2\xa4\xad\x3b\x40\x91\xe3\x26\xb0\x0c\x5d\x09\x18\x90\xa6\x7e\xaf\x9c\xc8\x49\x63\x21\x61\x5a\xd3\xf6\x3b\xe8\x74\x72\x27\xfd\xbe\x86\xf0\x65\xcb\x74\xac\x16\x21\xa4\xe0\x7f\xbb\x35\x05\x3f\x4f\x65\x8f\xd7\x66\xc1\x79\xb2\xd1\xb2\xd9\x2c\xcf\xd4\x77\x51\x94\x7b\xb0\xd7\x89\xcc\x5e\xe6\x7c\x2c\x9a\xad\x33\xc8\x64\x89\xd7\x01\xd6\x50\xbc\x1a\x80\xed\x46\x9b\xac\x31\x45\x9a\x74\x8d\x19\xa4\xdb\x38\x5a\x58\x6f\x2c\x7f\x9d\x53\x69\x68\x82\x84\xaf\x19\x65\x80\x77\x12\xed\x4e\x99\x7a\xac\x39\xcc\xdc\x35\xd3\x9f\xe6\x79\xe4\x96\x19\x17\xf6\xd4\xf2\xcb\xe6\x46\x9b\x6d\x3e\x61\x1d\xd6\x84\xda\x1d\xe8\x04\x4e\xab\x9e\x38\x5e\xbd\x27\xc9\x58\xc8\x69\xd9\x1c\x66\x6d\x36\x2e\x5a\x0e\xc5\xf5\x98\x54\xe3\xb6\xaa\xbe\xe6\xd2\x84\x9e\xe1\x51\x99\xb3\xae\x9a\x40\xda\x65\x8d\x35\x88\xac\xea\xf3\x45\xd5\xc6\xf2\xd7\xfa\x3a\xfd\x54\xf0\x5c\xcf\x67\x6d\x4d\x11\xd6\x97\x7a\x19\x49\x08\xe2\x5e\x92\x0d\xcc\x51\x36\x7b\xaf\xff\x82\xb2\x26\xf6\xa4\x16\xc2\x4e\x02\xff\xf0\x8b\x9d\x75\x0b\xdb\x65\x95\xa3\xae\x21\x5a\xee\x27\x00\x55\x39\x17\x4f\x36\x6e\x75\x2e\x96\x4a\xa3\xa8\x47\xce\x3e\xaa\x0d\x9a\x25\xd9\x0e\xae\x51\x55\x32\xf8\x8d\x95\x0c\x7e\x63\x28\xc1\x2c\xc9\xac\xac\x69\x67\x8d\x86\x77\xc0\xd6\xfa\x50\xce\x6d\x8d\x75\x62\xad\x0b\x91\x0e\x2b\x6d\x69\x53\x55\xc1\x36\xa4\x05\x1f\xaf\x77\xa2\xa4\x16\xa7\x77\x4b\x93\xb1\xef\x36\x23\x36\x63\x4f\x36\xff\x8f\xa7\xbf\xfc\xf2\xc9\xf7\xfe\x38\x09\x37\x73\x31\x7c\xb4\xa3\x1e\xed\x6c\x26\xf8\x87\xcf\x69\x14\xf4\x25\xf2\x03\x7e\x89\xac\x71\x68\x81\xfa\x0c\x1f\x1e\x51\xec\x78\x1c\xa9\x3b\xaf\x13\x57\xcb\x36\xfc\x6f\x71\xd5\x93\x3c\x1f\x40\x9a\xe5\x39\xc9\xf8\x1e\x11\xdb\xb7\x4a\x9b\x79\x7d\x56\x2a\xc7\xc1\x98\x80\xa7\xf1\xbe\x37\xe7\x34\x5a\xba\xf3\x23\x1d\xef\xe6\x0b\x1b\x3f\xdd\x51\x66\xb4\x7e\x60\x78\x1c\xa4\x0b\xdb\x60\x1b\xac\xc1\x1e\x6a\x4f\xf2\x62\xc2\xfb\x49\x76\xde\x9d\x66\x49\xc9\xbe\x65\xdf\xb3\x87\xac\x31\x31\xd9\xcb\xee\x2e\x25\xd6\xef\x31\x25\xd2\xcf\xa3\xa4\x3f\x22\x62\xc1\x62\x24\xa7\x29\x8e\xdc\x04\x5d\x42\xf3\x72\xf1\xd4\xf6\x44\x82\xe6\x2e\x48\x95\x81\x01\x8e\x4d\xd4\xdc\xd3\x56\x6d\x6a\x1a\x9b\x88\x07\x16\x4f\xf4\xa7\xa5\x80\xf8\x6b\x7a\x0c\x93\x5c\x14\x64\xb9\x5c\xd0\xdd\xfa\x2c\x38\x3e\xfc\xe3\xca\xb4\x7a\xc2\x26\x6c\x91\x39\x64\x69\x63\x7d\x99\x15\xd3\xb1\x97\xef\x09\x92\x5f\xd8\x98\xbd\xf5\x59\x6c\x2c\xfe\x2c\x95\x11\x3f\x42\x32\x9c\x19\x80\x7a\xb6\xd2\x6b\x62\x6b\x45\x70\x48\x05\xaa\xf0\x96\x4e\xec\x4f\x33\x1a\x50\xe3\x7f\x1a\xc7\xc2\x3a\xbb\xc2\x11\x8e\x3a\x8d\x87\x6e\xe0\x35\x5e\xe0\x24\xca\x83\xae\x62\xbf\x98\x2a\x7a\xbb\x6d\x05\xfd\xdb\x14\xeb\xfd\x71\xe1\x32\xf0\xb7\x6d\xbd\x9a\xbb\xb2\xf5\x56\xa6\xee\xc8\xd4\xbf\xd8\x0e\x4f\xbb\x16\xab\xa1\x80\x47\x30\x76\x6b\x7d\x82\xef\xca\x1f\x58\x0b\xbd\xee\x6b\xf8\x61\x86\xf8\xa5\xac\x3e\x6a\x1c\xcf\x5c\xac\xa1\xe5\xdd\xdd\xe8\xdd\x4a\xbd\x41\x56\xf4\x7a\x6b\xbb\x43\x6c\xb6\x13\x3c\x80\xb2\x81\xa2\xdf\x9d\xcd\xd0\x2b\x2e\x08\x06\x82\xf1\xb8\x9f\xe2\x71\xdb\xc6\x73\xb2\x06\x7e\x38\xd7\xe0\x4f\x43\xf1\xb6\x4b\xcd\xa2\x97\x0e\x94\x0b\x1c\x9a\xcd\xd2\xb2\x0c\x79\xf6\x12\x8f\x2c\x74\x8b\x56\xe0\x3d\xa7\xf7\xb9\xb0\x17\xbb\x59\x53\x78\x1a\x55\xe7\x5e\x03\x4b\x43\xa4\xf8\x7e\x73\x72\xbf\x74\x77\xee\x44\xcd\x21\xee\x4b\x43\x33\x87\xb2\x16\x9a\x22\xde\xad\x36\xf2\xe3\x2d\xc5\xc0\x5c\xef\x54\xf0\x27\xe2\x9a\x65\xef\x04\x7c\x4e\xed\xc4\x1c\x5c\x96\xf1\x7a\xf2\x9c\x9c\xbc\xc8\x03\xda\xdf\x29\xc8\x2f\xfc\x19\x5c\x9f\x9e\x6c\x7d\x5d\xae\x4f\x8b\xdf\xa5\x1f\xc4\x55\xdd\x3b\xe3\x91\xf3\x3b\x50\xb5\xe6\x31\xc3\xaa\xfc\xeb\x7c\x1b\xfe\xe9\x5c\xf4\xa7\x73\xd1\xad\x9c\x8b\x7e\x33\xc1\xcd\xa3\x65\x05\x37\xdf\x2d\x16\xdc\x3c\xfa\xbc\xbe\x52\x7f\x8a\x45\x56\x10\x8b\x68\x4b\xd3\xba\x95\x72\xdb\x7b\xd0\xaf\xcd\xb1\xff\x37\xbf\xd6\xbc\x11\xa8\xf2\xaf\x2d\x99\xbe\xd1\x1f\xdf\x36\xed\xbd\x81\xb3\x20\x9d\xfc\xfa\x3a\xfb\x2f\x7d\xb0\xc5\xc0\x1a\x4a\x33\xb7\x37\x77\x2b\x56\xa1\xbc\xfb\x77\xb1\x74\xe3\xe5\xd5\x44\x9e\xe7\x7c\x32\xba\xd2\xe1\xc6\x16\xc6\xd0\xd1\xcf\xaf\x31\xbf\xd4\x9e\x09\x5b\x4f\xbe\x33\x6f\xb2\x79\xf9\xe0\xc7\x49\xa6\x1b\x7c\xbf\x65\xeb\xf3\xc1\x00\x12\xd9\xdb\xf4\x20\xa3\x4a\xf2\x7b\x2d\xf9\x81\x6c\xe7\xf6\xed\x57\xc9\x9f\x8f\x32\x9f\x58\x12\xf5\xe9\xa4\xd9\x18\x0f\x68\x0a\x75\x37\x92\xcd\x27\x1b\x5a\x73\xac\x9f\x23\x6a\xd5\x5e\xab\x0d\x57\xa8\xea\xa4\x52\x66\x54\xdf\x6f\xe9\x7e\x6c\xe5\x3d\xf0\xc9\xaf\xc8\xaf\x70\x18\x13\x9e\x8a\xb2\x14\x10\xae\xab\x5b\x88\xbe\xcc\x06\x3c\xbf\x8a\x83\x38\xb6\x31\x56\xe6\x82\xb2\x50\xba\x7b\x5b\x1b\x1b\x71\x50\x2f\x30\xc8\xeb\x22\x50\x30\x2a\x1d\x10\x76\x10\x42\x7a\x87\x29\x50\x6f\x35\x31\x0d\x63\xc9\x99\xe9\xa4\xab\xef\x1f\x6f\x6c\x9c\xd6\x40\xba\x8b\x89\x1d\xe0\xe1\x5b\x2c\x71\x94\x13\xde\x4f\xca\xab\x6d\xb6\xd1\xfd\xbe\x06\x48\x75\x66\xb6\xd1\x66\x4d\x93\xea\x14\x48\x3f\xdf\xd1\x46\x24\x24\xc4\x47\x72\x14\xfe\x99\x2b\xb4\xf7\xc0\xcf\x72\x3e\x99\x88\xdc\xd5\x1b\x24\xc5\x24\xe5\x57\x30\xa9\x34\xc9\x44\x47\x35\xb4\x13\xe3\x69\x72\x9e\x1d\x94\x62\x5c\x6c\x9b\x40\x6d\xb6\xec\x3f\xd3\xa2\x4c\x86\x57\xcf\x31\xf3\x7d\xb5\x9c\xf8\xb7\xfe\xff\x3d\xd9\xec\x0b\x27\x3b\x6c\xf4\x65\x3a\x1d\xdb\x23\x09\xff\xa4\xea\x4c\xd9\x10\x20\xdb\x4b\xd2\x18\x4d\x1e\x4e\xe4\x64\x9b\x3d\x09\x68\x86\x49\xb5\x11\x7e\xc7\x74\x4a\x9b\x21\x89\x39\xc2\x03\xbc\xb9\xb5\x0a\xa1\xf0\x40\x46\x45\xce\x8f\xe2\xdd\xc4\xeb\x6a\x52\x43\x56\x64\xd9\x85\x30\xa6\xf7\xdb\x55\xaa\x3d\xb9\x3c\x91\x47\x62\xdc\xac\x14\x98\x36\xd6\x64\x68\x36\x4a\x4a\x71\x3c\xe1\x7d\x01\xe4\x34\x1f\xf3\x74\x25\xb2\x79\x9b\x41\xb0\x0e\xdb\x6c\x55\xe7\xff\x33\x60\xee\x60\xe1\x32\x44\x47\x38\x90\xb3\xec\x8e\xc7\xb8\x45\x0d\x89\xfe\xb8\xca\x83\x83\x21\x3b\x53\xef\xf6\xb3\xb6\x4d\x01\x0f\xf9\xd0\x7b\x82\x19\xb2\xda\x25\x5a\x03\x43\xd1\x96\xce\x06\x1f\x8e\x92\x90\xba\xa5\x61\x40\x10\x6e\xc5\x95\x1a\xf3\x55\x35\x6a\xce\x70\x3a\x0c\x13\x5f\x43\x56\xab\x36\x4b\x4a\x3b\x7c\x48\xac\xce\x0b\xc6\x31\xec\x6e\x9a\x9c\xf3\x72\x9a\x13\xa5\x40\xd2\x5f\xa4\xfe\x00\xb3\xe5\xf7\xf3\x57\x73\xc5\x24\xec\x96\x07\xbd\x61\xfa\x75\xd3\xfe\x6e\x12\xaf\x1b\xf7\xaf\x79\x29\xcf\xd9\x4b\x99\xb3\x42\xe4\x17\x22\xc7\x64\x1e\xe8\xb8\xa9\x96\xbe\x2f\x33\xf5\x05\x6d\x07\xdb\x6c\x26\x58\x2a\x74\x4c\x74\x13\x80\xae\xe4\x3d\x84\x42\xf2\xdb\xdb\x68\x47\x64\x2f\x5c\xec\xba\x3f\x37\x24\xb2\x21\xea\x08\x00\x19\xb5\x67\xc0\x2e\x9d\xbe\x5d\xfe\x5c\xb6\x05\x78\xac\xb5\x8e\x26\xf9\xed\xb2\x6a\xc7\x08\x88\x15\x15\x97\x21\x04\x17\x62\xf1\xc6\x54\x54\x3b\xff\xde\xe2\xb6\x20\x91\xbf\x6e\x8c\x39\x46\x67\xa0\x83\x95\x9d\xb6\x16\x6a\x17\x34\xe3\xbf\x4c\x55\xc3\xa3\xcf\xa9\x8a\x98\x1b\xee\xf9\xbf\xe5\x94\xf5\x79\x66\x2e\x05\x76\x25\xa7\x39\x93\xb3\x4c\x67\xfe\x67\x87\xe5\x48\xe4\xb3\xa4\x10\x40\xb0\x86\x44\x6b\x0d\x4e\x37\xa3\x24\x1d\xd8\xc7\x2d\xe6\x7e\x20\x7a\xe4\xc0\x87\x1d\x7e\x1b\x7d\xa3\xfa\x07\xf5\x62\xf6\x8a\x87\xe4\xab\xc4\x36\xfc\xbe\x16\xad\x3b\x0b\xc6\x11\x2f\x0e\x67\x99\x61\x84\x50\xfe\x1f\xc0\x6b\xd1\xfc\x08\xb9\x9c\x51\xab\x71\x50\xcc\x42\x2e\x47\x53\x1b\xd3\x39\x8e\x78\x81\x7e\x38\xff\xd3\xe0\xd9\xd5\xff\x34\x20\x25\x2c\x9b\xf1\x82\x65\xb2\x74\x59\x20\x4b\x89\x8d\xbd\x01\x03\x84\x2e\x7b\xc7\x8b\xc2\x09\xee\x99\xcc\x19\xcf\xae\xb4\x2a\x16\x97\xb2\x41\x63\xe6\xd1\x44\xfd\xb7\xcb\xd3\xbf\x4c\x9a\xfe\xcf\x99\xa5\xff\x8f\x92\xa4\x7f\xc5\x1c\xfd\x77\x96\xa2\x1f\xdf\xb0\x83\x13\x71\x59\x46\x13\xde\x63\x84\x84\x48\xbe\x47\x71\x61\xd1\x87\xad\x92\xeb\x3e\x0c\xf9\xf2\xd7\xfa\x90\xf0\x91\xd4\x76\x91\xe8\xe9\xd6\x98\x21\x00\xa7\xbe\xfa\x29\xb5\x4c\x1f\x2d\x2f\x65\xbb\x8e\xca\x02\xf3\x69\x63\x9f\xad\x68\x72\x39\x0d\x33\x68\xad\x3e\xe9\xc5\xa8\xc9\x57\x86\xac\x42\x24\x47\x2a\x24\xa3\x51\x2b\xaf\x9e\x63\x0b\x33\x7b\x02\x98\x4a\x8a\x2f\xb2\x7f\x76\xcd\xa1\x26\x84\xe4\xb5\x79\x60\x8b\x66\xcb\x65\xc9\x25\xd1\x8f\x1d\x78\x0c\xed\x49\xc1\x41\x40\x1b\xf2\x61\x41\x12\x28\x0f\x93\xbc\x71\xfd\xe6\xb9\x9d\x3e\x43\x6a\xa7\xea\x06\xfe\x26\xc9\x93\x82\x8c\x43\x1e\x36\x78\xe9\x86\x6a\xf6\x51\x5f\xd4\xf8\xdf\xb7\x6c\xaf\x64\x7d\x91\x97\x90\x1d\x49\xc1\xe0\x19\x3c\x1a\x18\xa2\x4e\xd1\x66\x9c\xa5\x3c\x3f\x17\x39\x3e\xe3\x20\x6c\xca\x98\x5f\xc1\xde\xc3\xa5\x3d\x93\x2c\x4d\x32\x51\xb0\xd9\x28\x49\x05\xbe\x3e\xc6\x3c\x4d\x45\x4e\xbb\x71\x8d\x8b\x52\x3d\x10\xc1\x9f\x56\x73\x13\x05\x93\x99\x00\x20\x5d\xc6\x4e\x14\x59\xc5\x9c\x4d\xf0\x92\x54\xf3\x01\xa7\x33\xc5\x0c\x0c\x93\x2c\x29\xcd\x0b\x88\xa5\x52\x4e\xbc\x3e\x72\x99\x31\xd9\xef\x4f\x73\x7c\x98\x66\xac\x1c\xf1\x92\x15\x7d\x91\xf1\x3c\x91\x5d\x52\x77\xdd\xfe\x5d\xbf\xab\x77\x9b\xca\x84\xc6\xd6\xf1\x42\x2c\xbb\x68\xfd\x5b\xab\xa4\x32\x59\x2a\xe1\xc8\x0a\x69\x44\x8c\x6c\xc1\x55\x33\x5f\x6e\x94\x6c\xa4\x1f\x66\xdd\x50\x5f\xa2\xd1\xd2\x23\xf9\x44\xbc\x04\xe6\xf0\x02\xf1\x40\xc1\xa7\x1b\xa4\x1b\x71\x91\xe3\x4d\xfe\x90\x48\x88\x75\x60\xed\xfd\xfe\x8a\x30\xe2\xf4\xb2\x69\x42\x3e\x5b\x1a\x90\x7a\xc3\x3a\xdc\xb2\x6a\x9e\x8f\x3e\x1a\xdb\xd9\x25\x56\x3f\x60\x1d\x2b\xd9\x3d\xf4\x9a\xc0\xdf\x6a\xe2\x95\x04\x1e\xf1\xbc\x1d\x09\xaa\x2d\x4d\xe2\x72\x42\xac\x2c\x2e\xa8\xdb\xc5\xde\x88\x5e\x7e\x02\xad\xf2\x9c\x9f\xa1\xc0\xc0\x69\xb1\xa7\x0e\xbf\xb6\x97\x8f\xa1\x8d\x3a\x53\xdf\xe0\x0e\xff\xc3\x80\x48\x55\xec\xb5\x9f\xaa\xdc\x81\x9a\xb2\xb9\xe5\x23\x73\x76\x58\x5b\x3b\x69\xd3\xfa\x8e\xa3\xbf\xfb\xe2\x7f\x3f\xf0\xf7\x2a\xe1\xdc\x8b\x09\xcf\x96\x8f\xe7\xbe\xd8\x32\x13\x0f\xed\x0a\x59\x43\xa8\xd4\xba\xcd\xe2\x37\x5e\xab\x75\xeb\x40\xf0\x66\x1b\xa2\x91\xe0\xbd\xdf\x41\x0c\x75\xbb\xc5\xe4\x6b\x6b\x01\xc6\xdc\xc4\x98\x95\xa6\x7f\xd9\x5a\x35\xf1\xcc\x96\x5d\xcf\xf7\x0d\x05\x4e\x3d\x36\xa1\xb1\x36\x47\xe8\xf6\xf9\x24\x29\x21\x5a\xc0\xcb\x24\x2f\xca\xd7\xa2\x2c\x45\xde\x6a\xda\x03\xdf\x3a\x6d\x83\x5d\xd9\x2a\x49\x6a\x6e\xdf\xa9\x7a\x02\x1b\xf5\x5d\xe3\xb4\x6d\x2f\xa7\x2f\x3f\x0a\xa3\x77\x54\xa3\x30\xa4\xf1\x66\xa3\xe8\x7a\x0a\xef\x36\x12\xbd\x07\x0f\x10\x8f\x6e\x08\xd2\xdd\xbd\xee\x66\xf6\x33\x00\x6d\xb5\xa2\xe6\xd0\x06\x21\x0b\x93\x51\xcf\xcf\x6c\xe7\x2e\x38\x08\x52\xa2\x05\x4c\x90\x7c\xd0\x2f\x31\x52\xa2\x56\x98\x72\xa7\xdb\xd7\xf7\xa3\x6d\x50\x39\x10\xa6\x6f\x98\x38\x98\x1a\x06\xe6\x9d\xe4\xfd\xb2\xc1\x9e\xce\x33\xb0\xc0\x1b\xda\xdd\xdd\x2d\xb6\xed\x7e\xdc\x30\x21\x49\xbd\x95\x36\x0b\x2c\xb5\xbf\xab\x6a\x11\x19\xc8\x2f\xfa\xd3\xe2\x28\x99\x4c\x8c\x91\x6b\x94\x35\xa3\x06\xdd\x21\x1b\xa2\x27\x41\xbf\xbb\x5c\x14\x1e\x71\x6e\xf0\x3c\xe1\x1d\x7b\x77\xc7\xb3\xc7\x38\xf5\x91\xa7\xb1\x47\xda\x86\xcc\x88\x9f\xf1\xc6\xca\x5a\x2b\x72\x01\xd7\x70\xe9\x94\x2b\x74\xb4\x95\xcb\x25\x7a\x95\x69\x65\xbb\x4f\x78\x43\x3e\x12\x8e\x8f\x23\xbb\xae\x28\xcc\x53\x31\x2f\xc1\xc4\x32\xf9\x25\x62\x36\xcc\x6e\x45\x51\x8e\x72\xe3\xd4\x0d\x9e\x11\xb3\x31\x5c\x6e\x55\x02\x2e\x3e\x79\xf4\x75\x19\x1a\xa3\x2d\x9a\xba\x89\x5f\x26\x22\x1d\xd4\xc6\x11\x00\xbb\xb5\x05\xbd\xd9\xa0\x6d\xd8\x95\xc8\xa6\x63\x91\xf3\x1e\x3d\x3c\x10\xd9\x93\x46\x27\x6b\x86\xae\x1c\x35\xd6\x70\x76\x84\x2d\x97\x23\x01\x64\xa6\x5f\xc4\x44\x2e\xd8\xc3\xef\x7e\xd7\x3e\xcf\x7f\x3c\x2f\xe3\xcf\x60\x39\x3b\xe3\x79\x96\x64\xe7\x75\x60\xbf\x0b\x2b\xce\x35\x68\xc5\x2a\xce\x32\x34\x9b\x4c\x6b\x07\xfc\x68\xd3\xaf\x37\xd7\x84\x54\x55\xb0\xd5\x5f\xca\x1c\x12\x0b\xe5\xb2\x2e\x5c\xc8\xd6\xdf\x1e\xc5\x6a\xcf\xeb\x82\x54\xf3\x9a\xbe\x02\x16\xcd\x48\x38\xa3\x7d\x7d\x57\xd3\x60\x51\x77\xae\xa6\xcb\xf9\x02\x77\x65\x9d\x3b\xc4\xc6\x77\x41\xc5\xb9\x59\x61\xa0\xc6\x97\xa1\x2a\x71\xf3\x56\xb2\xa4\x2b\x59\xd4\xbc\xc5\xa0\xc4\xb7\xb3\xcc\x05\x20\x0b\xcc\x72\x57\x19\x94\x49\x77\x08\x1a\x9e\x5b\x8f\xce\x87\x76\x87\xc3\x8c\x5a\x23\x81\x20\x73\xa2\x29\x2c\x53\x8f\x8e\x82\x4d\x0b\x91\x43\x8c\xee\x61\x92\xa6\x6c\x28\xf3\x71\xc1\x86\x10\x75\xb8\xcd\x44\x31\x11\xfd\x84\xa7\xe9\x15\x93\x19\x1b\xcb\x5e\x92\x0a\x36\x10\x17\x49\x5f\x68\x4b\x25\xb0\x42\x50\x9c\x02\xe8\x57\x7b\x82\xf5\x65\x36\x9c\x16\x60\xfb\x91\x94\x8d\x82\x8d\x65\x2e\x58\x9a\x7c\x10\x8c\x67\x8c\x4f\x4b\xa9\xba\xe9\xfa\x6a\xd9\x54\xf0\x3c\x63\xbc\x27\xa7\x25\x5a\xeb\x94\x23\x14\x93\xf2\xbc\x4c\xfa\xa9\xb6\x39\x31\x81\x42\x07\xe2\x42\xa4\x12\x9e\x4b\xe7\x52\x9e\x03\x5f\x3f\x5e\x9f\x89\xde\x3a\xa6\x69\x2f\xd6\xb7\x36\x36\x1f\xaf\x6f\x3c\x59\x07\x11\xaa\x9c\x96\x1d\x9c\x4f\x47\x01\xee\x98\x31\x58\x05\xae\xfa\xa0\x70\x35\x15\xe5\xad\xec\xa4\x12\x20\x72\xc6\xd4\x08\x38\x6d\x31\x60\x83\x29\x08\x7e\x21\xd5\xb7\x7a\xd2\x31\x08\xb1\xde\xf5\x7a\x7f\xa9\xea\xde\x42\xf5\x6f\x12\xa7\x6d\xaf\x68\xb0\x11\xa0\xf2\x0d\xcd\x36\x7c\x28\x77\x63\xbc\xe1\xc1\x5c\x60\xc0\x71\x33\x23\x37\x85\xb7\x86\x1f\x46\x99\xa8\x1c\xc2\x2e\x9d\xc1\x1d\x73\x56\x35\xaa\xd1\xb5\x7f\x42\xe6\xe3\xae\xf0\xe4\x4e\x2c\xea\x82\x1e\x50\x7e\x44\x7a\x98\xa4\xfc\x4a\x0c\x58\x92\xa9\x43\x28\xf2\x5c\x42\x20\xc3\x92\x18\xbe\xc1\xc7\x15\x7a\x74\x6c\x09\xb5\x63\x84\xf5\xf3\x6f\xb4\xc8\x42\xfa\x15\x80\x50\xad\x64\xb7\x52\xbf\x9e\x25\xff\x20\x4c\xa8\xd3\xe1\x34\x4d\xd1\x60\x59\xed\x6c\x52\x16\x8a\x34\xa1\x04\xd2\x0d\xe5\xa6\xa6\x87\x28\xaf\x41\xed\x54\x1f\xad\xa5\x1d\xd0\x91\x9d\xdb\xaa\x07\x12\x2f\xbc\x1b\x9e\x43\x68\x7c\x37\xc7\x4f\x81\x8a\x58\x9b\x3d\x3f\x3e\xc6\xd3\x86\x14\x5f\x1f\x18\xba\x16\x95\xbd\x76\x6b\xf1\xfc\xc6\xc7\x34\x19\xd8\xb3\x99\xd4\x9c\xcd\xa4\xfe\xb4\xd4\x41\x8d\x4f\xa6\xbe\x07\xf5\xfd\xe6\x73\xa8\xe9\xad\x8e\xd6\x1c\xdc\xbc\xb7\x39\x27\x13\xa0\x82\xb8\xaf\xae\xcb\xd7\x46\x80\xbc\xda\x89\x9c\xd3\xe7\xdc\xf5\xbc\xd3\x9e\xe6\xae\xe5\xea\x3d\xfd\x58\x08\x64\x42\x2c\xbf\x54\x4a\x36\x51\x3b\xc8\x59\x2e\x86\x2e\xa8\xa9\xee\x3f\x03\x7f\x27\x4d\x8d\x68\xec\x0d\x3a\xe1\x23\x31\x5c\xc1\x4a\xd0\x59\x78\x56\x68\x8c\xb6\xf0\xfc\x03\x90\x97\x79\x26\xae\x37\x3b\x21\xe4\xfe\xe0\x40\xb6\x78\x2e\xb8\xe9\xc1\x5e\x9b\xa8\x32\x87\x5b\xb3\x28\x05\x07\x1a\x04\x0a\xff\xc9\x94\x0c\x63\x3c\x4d\xcb\x24\x4d\xb2\xf9\x71\x64\xfc\xfe\x41\xd9\xc2\xcb\x32\x4f\x7a\xd3\x72\x31\xe5\xc9\x56\x9d\x9f\x8d\xba\x33\x4c\xd4\xf8\x21\x42\xb8\xea\x01\xd9\x1c\x30\x65\xe0\xd9\xb9\x61\x39\x34\x53\x35\xe1\x39\x1f\xb3\x8f\x78\x12\xae\x19\x1a\x38\xa8\x5d\xc1\xbf\x0a\x39\xcd\xfb\x76\xac\x06\xf7\xd7\x6e\x61\x44\xab\x60\x17\x23\x99\x97\x6c\x94\x64\xa5\xcf\xa5\xb8\x6b\xbd\x27\x86\xea\x01\xa1\x3e\xa8\x87\x0a\x03\x7f\x24\x75\x04\xd1\xdc\xd0\x0e\x60\x92\xf2\xbe\x18\xc9\x74\x20\xea\xb9\x98\x25\x78\x33\x44\xb6\xa4\x20\xc3\xe1\x85\xb1\x09\x21\x3c\x9a\xf9\xb2\xc2\xae\xaf\x4a\x4f\x72\x29\xa3\x74\x44\x7d\x5f\x8d\x8c\x60\x74\x7f\xb5\x77\xb9\x9c\xc1\x53\x4f\xcf\x0e\x51\xc3\xa2\xb0\x8e\xf2\xaa\xa6\x5f\x88\x12\xc6\x91\xd3\x35\x56\xad\xef\xc0\xa8\xbc\xa6\x38\x83\x51\x86\x96\xbb\x6f\xf8\x65\x32\x9e\x8e\x59\x76\x87\x73\x78\xc3\x2f\xbf\xf4\x34\x8e\xd0\x3a\x88\xb3\x33\x94\xc6\x9c\x39\x72\x03\x16\x4a\x0a\x0f\xcc\x33\x31\xb8\xc8\xc0\x20\xd7\xb4\xe2\x85\xa5\x13\x70\x60\x45\x69\xb8\x59\x85\xc9\x60\xfe\xe9\x2f\xc0\x95\x9c\xb2\xf1\xb4\x28\x11\xd3\x14\x78\x13\xf5\x5b\x1f\x65\x54\xca\x28\xc0\xe6\x15\xe9\x16\x0b\xcb\xee\xe6\x55\x10\xcc\xdb\x75\x82\x05\xab\xdf\xcf\x90\x5d\xa4\x4a\x45\x03\x2e\x80\x1d\x94\x26\xf8\x59\x4f\x20\xd9\x48\x06\xec\xd5\xc9\x9b\xd7\x8f\x35\x85\x01\x93\x6b\x3b\x1a\xf5\x6b\x65\xe6\x6e\xde\xfb\xb1\x6d\x69\x05\x18\x0f\x73\xb8\xca\x21\x6b\xfc\x20\x76\xba\x2f\xe6\xbe\x2e\x3f\x13\x76\x2a\x22\x38\x10\x59\x21\xce\x98\xcc\xd9\x19\x3a\x07\x9e\xb5\xf1\x2a\xe4\x03\x88\xa2\x76\xa1\xf6\xb5\xcf\x53\xa6\xdd\x1a\x71\xba\x49\x01\xc6\x79\xe6\x65\x35\x88\x7a\xb2\x8d\x79\x7e\x9e\x2c\x8e\x2a\x87\x2e\xde\xac\x01\x23\x51\x7f\x68\x27\xc5\xd3\x16\xd8\x91\x93\x00\x66\x46\x73\x12\x86\x2e\xa3\x92\x1c\x1b\x37\x8c\x7e\xb4\x3e\xb0\x46\xe8\xe2\xd5\x82\x2f\x36\xce\x99\x3e\x0d\x2e\xc4\x99\xfe\x50\x09\x84\x36\x27\x08\x1a\x91\x18\xb8\x38\x68\xe4\xa3\x8b\x96\x66\x0d\xdd\xe2\x76\x6e\xf8\x66\x37\xa5\xf0\xcb\x14\x25\xae\x55\x62\xeb\xfb\xaf\x15\x57\xc1\xfb\x6c\x2a\x1f\xc4\x2b\x1f\x44\x2b\x3b\xbe\xdd\x0b\x00\xe7\x3e\x7b\x50\x8d\x14\x92\x40\xf4\x2a\x19\xa6\xd8\x87\x73\x24\x86\xa6\x82\x31\x85\x89\x58\xd9\xf9\x1c\xa0\x5f\x27\x3e\x47\xf7\xba\xf1\x87\xe4\xbe\xbb\x38\x04\x44\xd8\x8f\x35\xdd\xa7\x6a\xa5\xea\x28\x22\x65\xa6\x59\x44\xfc\x61\x9b\x45\xca\xac\x9b\x35\x31\x73\xac\xb1\x72\xb4\x94\xc6\xd4\x30\x1f\x4c\x05\x9d\x86\x45\x9b\x07\x5e\x4d\xec\x98\xdc\xfd\x69\x4a\xed\x17\x53\x25\xa3\xd3\xcb\xc8\x7c\x88\xa5\x63\xdc\xd0\x91\xf0\x66\xb6\x0e\xf9\x66\x47\x8f\x8c\x8d\x1b\x3c\xfe\x76\xc5\xb3\x82\x94\xcd\x0a\x5a\xf0\x86\x5f\x7a\x65\x6f\xf8\xa5\x29\x2e\x8c\x26\x85\xda\x57\x9a\x42\x72\xf9\xd8\x1a\xe4\x9b\x8d\x45\xe8\x9d\x60\xcf\x66\xf2\xa6\x71\x08\x29\x59\x52\xc4\xce\x12\x20\x30\xa0\xd4\xb4\xa6\x6a\x4c\x49\x88\x47\x68\x5c\x09\x54\x01\x0c\x2a\x07\x68\x56\x49\x8f\xaf\xfa\x72\x50\xf9\xe2\x4e\xad\x2d\xb7\xbf\xcc\x49\xf4\xac\x32\xfd\xc3\x65\x1b\xb9\x03\xa4\x3e\x39\xdc\xf7\x7f\x79\xed\x22\x98\x5e\xb1\x10\x35\xe8\x0b\xe6\x9e\x57\x13\x68\x67\xf1\x12\x6e\x08\x0d\x8c\x1a\x8b\x12\xcc\x02\x18\x88\x45\xf8\xe7\xac\x30\xff\xbe\xe1\x97\xce\xb2\x54\xfd\x45\x76\xbd\x6a\x50\x8a\xb9\x16\x09\x3d\xf3\xa9\xa0\x8d\xe6\xe8\xaf\xb9\xf5\xf2\xa2\x2d\xeb\xc2\x29\x86\xb7\xca\x76\x40\xc3\xd1\x50\xa4\x4d\x80\x39\xb7\x83\xa5\xa3\x1f\x82\xd5\x87\x56\xdf\xba\xbe\xef\xeb\x23\xf2\xe9\x13\x7b\x26\x65\x2a\x78\xd6\x34\x08\xd8\x6a\xb3\xc6\x1b\x5e\x8a\x3c\xe1\x69\xe7\xc7\x83\x6d\x76\x66\x4a\xce\x90\xad\xec\x21\xef\x6a\x9e\x99\x53\xc7\xc5\xda\x5b\xfa\xcc\x31\x05\xa8\xda\x39\xc3\xfe\xce\xba\x8d\x16\xdb\xa6\x96\xaa\x6a\x99\x11\x49\x6d\x83\x85\x41\x52\x51\x65\xec\xe2\xa2\xce\x5d\x5f\x5f\xd5\x53\xe5\x0c\x88\x32\x26\x60\x08\xc8\xbe\xc4\xee\x45\x5f\x37\x50\xbd\xe2\xab\x66\x4e\xf8\x9d\x88\x0f\x02\x82\x8b\xaf\x7e\x47\x67\xf1\xf1\xe5\xe8\x9e\x7d\xc8\x78\xe4\x0e\xd9\x57\x47\xd9\x35\x3b\x49\x28\x56\x32\xd8\x66\x86\x4f\xa0\x32\xb8\xf0\x02\x77\xe2\x2a\xff\x4a\x76\x2f\x7d\x9f\xcc\x7b\x0f\x70\xf2\x03\x1d\x15\x1c\x69\x69\xa1\xb1\xdf\x0a\x91\x49\xa9\xde\x7e\xb9\xd0\xa4\xe1\x8d\xb9\xcd\x2a\x57\xe5\x3c\x5b\x37\xad\x0b\xf1\xb8\x2c\xf7\xe0\x37\x7f\x99\x03\x19\xd8\xa8\x81\xb1\xaf\x26\x3a\x58\x85\x46\xbc\x60\x0f\x1e\x2c\x67\x92\x86\x78\x4d\xd8\x13\x33\x90\xda\x70\xac\xa3\x72\x9c\xbe\x54\xe3\x4e\x06\x6d\x3a\xbd\x80\x4d\x32\x9b\xe1\x48\x76\xcb\x63\xa8\xe0\x6f\xfd\x49\xd3\x85\x45\xf9\x8f\xcd\x90\xb5\x29\x42\x68\x98\x58\x3b\x62\x40\xac\xed\xf0\xc4\x5f\xb7\xe9\xad\xdc\x0a\xf9\x71\x1c\x1f\x0b\x9b\x61\x35\xc2\xb6\x2d\xbd\xd0\x81\xa9\xc6\xd2\xa3\x27\x4b\x1c\x63\x04\xaf\xdb\x31\x46\xaf\x55\xe5\x1d\x71\x42\x2e\xca\xad\x21\x9b\x37\x8a\x6f\xbb\x92\x71\x80\x0e\x8b\x6a\x3b\x8c\x18\x13\x3a\xb4\x07\x63\xc2\x36\x11\x0a\x58\xeb\xc2\x88\x79\xa1\x85\xf9\x79\x42\x9b\x3e\xfe\x2a\x2d\x0e\xa5\x4c\xcb\x64\x52\x6b\x6f\xf8\xe4\xb7\xb6\x37\xc4\xf1\x7d\x0d\xd6\x86\x4f\x7e\xd7\xd6\x86\x8b\x23\xd9\xfe\x71\x2c\x11\xbf\x7c\x48\xd2\x3f\xa3\xe8\xfe\x19\x45\xf7\x56\x51\x74\x3f\x8b\xf1\x2c\xfc\x7a\x01\x29\x40\xe3\xa6\xa1\x7e\xcd\xfd\x0b\x91\x95\xaf\x93\xa2\x14\x19\x08\x0f\xa2\x54\xe2\xd1\x9c\x36\x0b\x47\xe6\xd5\x26\xc7\xaf\x27\xa7\x59\xbf\xce\xa8\xf2\xf1\x56\xa5\xe6\xbc\x8e\x4c\x9d\x2f\x62\x42\xfc\x25\x02\xfb\xc2\xca\xbd\x93\xe0\xe0\x51\x77\x8d\x7f\xbf\x7a\xf4\xdc\xbe\x1c\x8f\x6b\xe3\xe7\x6e\xfe\xb0\x19\x54\x9c\x3b\x68\xa8\xe1\xa8\x5b\x2e\x6a\x4d\x50\x7f\xd8\xf0\xaa\xcd\x25\x7d\xb9\xb8\xfa\x52\xd1\x8d\xbf\xa6\xe0\xbf\x5f\xca\xbe\x98\xad\x7f\xcb\x44\x91\x26\x59\xd9\xd1\xcf\x7f\x06\xa8\xb6\x9e\xc9\x0e\x3c\xfb\x3b\x7d\x39\x9e\xb4\x59\x26\x3b\x8a\x97\xc8\x8b\xbe\xcc\x45\x67\xc0\xb3\xf3\x54\x40\xc6\xc5\xaf\x38\xa2\xf1\xda\xfa\x3a\xa8\xb6\xb9\x36\xdd\x70\xb2\x9e\x42\xb2\x19\x9a\x05\x9f\x8b\x12\x95\xdc\x22\x17\x59\x5f\x74\x75\x4c\xa0\xfc\x5c\x94\xcf\x9d\x9a\xe5\xe6\xe1\x81\x28\xa0\x25\x22\x05\xd1\xea\x96\x7b\x5e\x2e\x10\x10\x6d\xaa\x9d\xb7\x34\xa6\xae\x1a\x73\xc7\x87\xb5\x5a\xdc\x1d\x6f\x14\x2d\x1d\x7d\x07\xe1\xda\xb0\x41\xad\x25\xa3\x92\xf8\x6b\xf7\xfe\xe6\x11\x25\xf4\x3a\xb8\xc8\x10\x5d\xad\x01\xad\xf7\x71\xa3\x7d\x2f\x74\x77\xfb\x1c\xe9\xc6\xc2\x48\xb9\xb5\x31\x6d\x8d\x4f\x29\x5b\x5f\x67\x6f\xf8\x07\x81\xaa\x74\xe3\x0c\x08\x36\xee\x65\xce\xb3\x62\xc2\x73\xa3\xce\x35\x2e\x82\x13\xe9\x47\xe7\xfd\x55\x27\xc3\xc1\x40\xa4\xf8\xab\x5b\xe2\xe3\xac\xda\xee\x79\x2a\x0b\xe1\x1a\x43\xec\x53\x91\xc3\xed\x5e\x98\xb0\xd8\xb4\x95\x06\xb4\x6c\x64\xd9\x1e\xef\x7f\x38\xcf\xe5\x34\x1b\x6c\xeb\x6b\xc2\xd4\x79\xff\xfd\xc6\xc6\xa9\x59\x8e\x9e\xcc\x07\x22\x3f\xe2\x83\x64\x5a\x6c\x33\x1b\x5c\x57\xc7\x4e\x36\xf7\x96\xdd\x37\x90\xb6\x8d\x12\xa7\x6f\x1d\xca\xac\x7c\xc9\xc7\x49\x7a\x15\x89\xcc\xea\x0a\x69\xf5\x05\x61\x5c\x37\xbf\xb3\xa2\x94\x71\x92\xbd\x12\x73\x02\xef\xda\xf0\xe4\x6a\x87\x4d\xcd\xc6\xa3\xad\xc9\x65\x24\xd8\x73\x10\xd0\x17\x72\xce\xd5\x64\x9c\xc3\x6c\x73\x56\xb5\xa6\xb6\x7f\x28\xf3\xf1\x36\x6b\x14\x7d\x9e\x8a\xe6\x46\xcb\x2f\xd4\xa1\xd1\xf5\x94\xec\x97\x42\xcb\xa5\x9a\xef\x1b\x7a\x18\xa0\xee\x30\xe0\x1a\xa7\xd4\xff\xd5\x24\xe5\x8e\x81\x31\x65\x5d\xb0\xaa\x12\x45\xa9\x5b\x5d\xb7\x8c\xa8\x32\x1e\xe6\xb7\x18\x07\xd1\xd1\xcd\x1a\x6d\x6d\x45\x57\x6e\x8b\xae\xdc\xca\xeb\xb4\xcc\xde\x6e\xf8\xb1\x82\x35\x4e\x63\x1c\xe6\xe5\xf0\xda\x2e\xdf\x61\x9e\x80\xed\x01\x26\x2f\x62\x41\x3c\x6b\x63\x99\x50\x3f\xf8\x6f\xd9\x23\x2f\xad\xe0\x92\x8b\xe8\xe0\x6e\x7e\x67\xdb\xfa\xd3\xd1\xb1\xa2\x6f\x3a\x9f\x54\x0c\xbf\xaa\xe9\x40\x94\xee\x9b\x4e\x06\xe7\xc1\x7a\x10\xd4\xbb\x32\x9d\x79\xf3\x60\x1b\x37\x9b\x89\x9a\x87\x6d\xeb\xcf\xc4\x84\x16\xbf\xe5\x64\x4a\x39\xf9\xad\x67\x72\x38\x11\x59\x34\xd2\xfc\xdf\xea\xa9\xd6\x66\xeb\x56\x09\x34\x53\xde\x9f\xc7\x7e\x12\x73\x1f\xdc\xec\x8e\xc8\x40\xbd\xab\x7f\x15\x25\xcf\x4b\xf7\x1b\x54\xce\x62\x58\x9a\x5a\xf0\xb7\xad\xe3\xe5\x25\x33\x55\xf0\x87\xad\x83\x39\xcb\x14\x41\x95\x13\x53\x45\xfd\x69\x2b\xa8\x6d\x3a\xf5\x1e\x26\xc3\x34\x99\xd8\x79\x34\x27\xe6\x2f\x64\x26\x8a\x59\x52\xf6\x47\x2c\xfc\xcc\x58\x9f\x17\x82\xd1\x49\x6d\xfb\x7c\x91\x3f\xc3\x9d\x6a\x1b\x2c\xa8\x69\xa5\x00\xd2\x36\x66\x36\x61\x75\x37\xb5\xb0\x76\x1c\xbc\x81\xb3\x43\xb5\x98\x41\x25\x3b\xd5\x1d\x93\xf3\xff\xd6\x6e\x88\x5a\x54\x6e\x5f\x04\x31\x4b\xb8\x9b\x3a\xb5\xdd\x51\x14\x62\x92\xe4\xee\x56\x6d\xb7\x7f\xdb\xe8\xc7\xb5\xa9\x59\x7f\x8f\x81\xe9\x5f\x48\x08\x55\x9b\x8b\x62\x22\x33\x18\x1f\x78\x59\xa2\x89\x7a\x51\xf1\xa0\x3b\xc9\x93\xf3\x73\x91\xaf\xea\x5d\x59\xed\x65\x24\x2f\x44\xbe\xa0\x97\x57\xaa\xce\xad\x7a\x49\x65\x76\x8e\x29\x71\x59\x29\xa7\xfd\xd1\x82\x0e\x4f\x54\x9d\x15\xdd\xd6\x30\x2b\x8f\xcc\x8a\x51\x32\x61\x3d\x51\xce\x84\x76\x0d\xd0\x17\x06\x46\x5a\x24\x2f\x1b\xdc\xff\x4c\x94\x2c\xc1\x30\xc1\xfd\x54\xf0\x9c\x0d\x73\x39\x86\x7a\x2f\x0e\xdf\x68\xf3\xe3\x67\x57\x3a\x84\x70\x02\x20\x88\x9f\x71\xdb\x88\x01\xa6\x85\x60\x10\x13\x66\x20\x8a\x7e\x9e\xf4\xc4\xa0\x07\x46\xf0\x85\x4c\x2f\xd0\xc4\x9f\xf7\xfb\x42\xbd\xa0\x93\x34\x29\xaf\x58\x52\x14\xd4\x74\x7b\x45\x1f\xaf\x3a\x2f\x88\xd2\x12\x9f\xff\x9d\x8a\xa2\x04\x5b\xf2\x9e\x60\x7d\xf5\xd0\xba\x5b\x97\x88\x23\xec\x41\x3f\xe1\x96\x36\xd7\x5f\x71\xe0\x72\x62\x4c\xb6\xef\x76\xd8\xc8\x3c\x2c\x3d\xea\x30\x69\x84\x1e\x6c\x52\xb0\x62\x24\x67\xc4\xa8\x5c\xce\x83\x1b\x41\x5b\x0d\xa8\x4c\xca\x94\xda\x69\xab\x9f\x5f\xdc\xff\xe9\x46\x97\x42\xd8\x70\xe9\x1b\xe1\xae\x3d\xae\x6a\xef\x02\xf0\xe1\xb7\x0e\x16\xe3\x24\x4d\x13\xcc\xea\x04\x38\x36\xe3\x89\xf5\xc3\x51\x7b\x69\x2c\xbc\xf4\x16\x13\x1f\x62\xc5\xf7\xbe\x10\x20\x50\x99\x6b\x7f\x7e\xd3\xde\x47\x09\x3c\x36\xe3\xbd\xa7\x82\x5f\x88\x1b\xf4\xae\xf1\xcb\x72\x39\x6b\x9e\x4b\xd1\x18\xf2\x20\xfd\x9e\x58\xd9\xa5\x3d\x32\x50\xd1\x11\xf1\xc8\xc0\x82\xd5\x3d\x32\x2a\xf9\x04\xd4\x33\x66\x01\x04\x17\x22\xde\x9a\x4f\xd4\xcb\x81\xb7\x16\x08\x82\x11\x44\x55\x02\xbc\x15\x8a\x80\xb1\xe2\xb2\x01\xe3\xb7\x56\x8f\x18\xaf\x6d\x2d\x7e\x3f\x51\xe3\xb7\x6e\x11\x36\x5e\x9f\xc4\x55\x44\xd8\x7a\x7d\x56\x0c\x1f\xbf\x65\xff\x70\x01\xe4\xaf\xed\x27\x20\x3f\x27\xc9\x18\x94\x77\x10\x3e\xd5\xc6\xd3\x54\xa4\x21\x5a\x02\x8c\x56\xb4\x24\x29\x9e\x3b\x47\x9d\xa0\x6c\x62\x54\x84\xde\x57\xe2\x31\xe2\x43\x82\x53\xf1\x56\x66\xc0\xb1\xa1\xe8\x56\xa1\x39\x18\x54\x99\x4a\x18\xc8\xee\x48\x40\x38\xea\x5d\x23\x7b\xd0\x3a\x58\xb7\x70\x73\x63\xb3\x9b\x81\xd1\xc0\x87\x5e\x41\xf7\x17\xfd\x6f\xd1\x1f\x89\xc1\x34\x15\x3a\xb8\x77\x35\x64\xfc\xe6\x93\x27\xad\xca\xd8\x2c\x5b\xb0\x28\x02\x3f\x59\x09\xd3\xbf\xe7\x42\xe3\xc7\x75\xc4\x2b\xdc\xb6\x81\x18\x8e\xc8\xd0\x35\xc2\x38\xf3\xa6\x92\x79\x55\xa2\xc2\xa0\x6b\xb5\x28\x32\x4b\xaf\x9c\xed\x32\xf6\x6a\x3b\xc3\xee\x60\xb8\x5d\x74\x84\x00\x4e\x00\x6c\xee\xd9\x83\x07\x3e\xf0\xae\xcc\xe0\xdd\xe0\x47\x69\x8d\x56\x09\xc2\xee\x93\x68\x92\xf1\x1e\xc7\x72\x5a\x08\xf5\x5a\x88\xf6\xfa\x46\x95\x1e\x5e\xf8\xbb\x58\xed\xd9\x56\x8b\xf4\x1e\x8c\x82\xe0\x47\x14\x15\x1f\x3c\x60\x64\x88\xb0\xfc\x70\x2c\xf0\x5e\xa1\xc3\x40\x0a\x52\x09\x9a\x09\x6f\x02\x75\x88\xe4\xb4\x6c\x56\x8e\x9c\x1d\x1a\xc5\x53\xd4\x0f\x59\x7e\x81\xfd\x83\x6d\x44\xb0\xd6\x3b\xb7\x85\x28\x4d\x1f\xb1\x53\x40\x9a\xe5\x0e\x53\xab\xab\xd3\x66\x35\x63\x70\x87\x80\x89\xb4\x10\xd5\xd1\xd4\x83\xf5\x33\x2d\x78\x35\xe7\x1d\x15\xc8\xfe\x12\x21\x37\x91\x95\x20\x09\x0e\x90\x7f\x56\xac\x36\xc9\x68\x10\xdb\x6c\xe3\x8c\x43\x0e\x6e\x8c\x32\x54\x6b\x99\x24\x14\x10\x63\xb7\x6e\x8e\x1e\x51\x80\x27\xce\xff\x25\xaa\xd0\x4b\xa7\xf1\xe3\xf9\x2c\x9d\x2e\x38\x99\xaa\xc6\x8d\x48\x02\x60\x7b\x3d\x4d\x78\xad\x8a\x97\x20\x0a\x50\x6f\x31\x55\xb8\xe9\xa1\x75\x6c\xf6\x9d\x1f\x58\xc0\xa2\x85\x27\x96\x0c\x60\xc9\x13\x1b\x83\x5b\x73\x64\x17\x22\xf2\x12\x77\xba\x87\xc7\x37\x3d\xdf\x00\x69\xb5\x03\x0e\x63\x5f\x7c\xc2\xc9\x6a\xb4\xb1\x9b\x05\x67\x1c\xa6\x78\xac\x2e\x83\x9b\x2f\x8c\x22\x25\x3b\xbf\x13\x5a\x10\x9e\x2a\x37\xff\xf9\xa7\xcf\xd5\xbb\xd9\xe9\x73\xbc\xa8\x6d\x89\x74\x62\x22\xf2\x22\x29\x4a\xc7\xa6\xc5\x98\xd7\x85\xa7\xad\x8e\x99\x0b\x0f\x46\x9b\x6d\x8a\x47\x26\x30\x71\x0c\x15\xf6\xb3\xc1\xef\x99\xd4\x47\xb7\x6d\x3f\x1b\x2c\xb1\xb9\xfb\xd9\xe0\xce\xb6\x76\x49\xfa\x3b\x1f\x03\x56\xa3\xb7\x4b\x50\xc5\x36\xdb\x7c\xbc\xb1\xc1\x1e\x2e\x20\xb9\x37\x4e\x98\xb4\xb5\x4a\xc6\x24\xf3\x9c\x8f\x67\x4d\xfa\x39\x49\xd3\xa5\xd2\x26\xd9\x8a\x41\xfa\x9b\x6a\x2e\x1b\x97\x3d\x04\xbe\x05\x4f\x40\x4d\x47\x27\x1a\x45\xa9\xd5\xbf\xc3\xae\xfb\x95\x96\x5e\x9e\xa3\x75\x14\xa2\xdb\xc2\x36\x08\xc5\xc1\xa6\x27\xe3\x29\x06\xe5\xb3\xb5\x83\xd4\x56\x04\x3b\xc9\x1d\xe1\x10\x71\x71\x8a\xa0\xbb\xc8\x38\x75\x5b\x5f\x53\x9d\xdb\x48\x9f\xf5\x4f\x9f\x98\xff\xc5\x46\x3e\x60\x9f\x3e\xad\xd9\x45\xfb\xeb\xcb\x54\xce\x5e\x26\x97\x6f\xcc\x74\x83\x46\x25\x3f\x7f\xcb\xc7\xa2\x5b\xca\xd7\x72\x26\xf2\xe7\xbc\x10\xcd\x96\xe6\xe4\x20\x62\x7e\xa3\xcd\xde\xfb\x8e\xac\x57\x72\xca\x78\x2e\xac\xd2\xe2\x9c\x71\x17\x86\x01\x1b\x39\x92\xa4\x45\x66\x46\x46\xe5\xb4\x95\x8d\x36\x6b\xec\xb9\x76\x26\x64\xcb\x00\x95\x3b\xc3\x24\x17\x46\x8b\xa3\x6a\x3e\x9b\x96\x1e\x9c\x4c\x08\x14\x72\xa6\x60\xa8\xed\xe5\x9b\x54\xdd\x1a\x70\x08\x82\x06\xbd\x01\x09\x28\x48\xc4\x15\x5c\xf5\x3f\xd0\x58\x33\xce\xce\x06\xc9\xc5\x19\x03\x85\x55\x29\x27\x46\xcc\x6f\x64\x7c\x8d\xd3\xee\x7f\x64\x92\x35\x1b\xff\x93\x35\x5a\xd4\xfb\x76\x11\xc6\xa8\x43\xf4\x63\x36\x5e\xf6\xbc\xe9\xaa\x04\x6f\x3c\x7a\x07\xbb\xe7\xe4\x35\x71\xa2\x88\x49\xe4\xaa\x24\x91\x04\xfe\x47\x79\x49\xb7\xcf\xb3\xbe\x48\xe7\x64\x3e\xbb\x61\x6e\xac\x47\x9a\x3a\xac\x94\x03\x8b\x5c\x1c\x24\xbd\x55\x10\x3c\x84\xad\x9a\x2d\x6b\xb9\x4c\x59\x54\xe3\x59\x49\x9a\x45\x0b\xeb\xdb\x82\x1e\xb3\xae\x2d\x14\xd6\xb7\x85\x4b\xb2\xae\x2d\x14\xd2\xb6\xe4\xf9\x6f\x9b\xb8\x6f\x5e\x7e\x05\x92\x1f\x2b\xf1\xd2\x47\xb8\x9b\x89\xa4\xe2\xb2\xdf\xda\x01\xc9\xf4\xf7\x44\x7d\xf1\x6a\x64\xc1\x6b\xf6\x97\x18\xe7\x1c\x6d\xa1\x5f\xfa\x61\x83\xc3\xa0\x07\x10\x88\x93\xfc\x5c\xea\xa7\x57\xae\x4e\x34\x29\x57\x3f\xbd\x44\x1b\x7c\xe6\x19\xd8\x90\x50\x1a\x63\xeb\x03\x8b\xff\x61\xd9\x5f\x89\x28\xdf\x35\x20\x1f\x2d\x3f\x51\x5f\xdd\xff\x48\x2f\x3e\xf6\x94\x7d\xbc\x66\xdb\x91\x7a\x94\xd5\x7f\xa7\xed\x58\x43\x44\xa6\xf5\xbb\x41\x25\x3a\x13\x2c\x3a\xbc\x49\x5a\x32\xda\x85\xba\x00\x82\x5e\x40\x59\x42\x76\xf3\xc6\x99\xcf\xc2\x68\x1d\xf5\x59\xd0\xe8\x19\xac\x7e\x86\xe3\x55\xfd\x0c\x27\x07\x22\x7c\xd8\xd3\xe1\xc2\x7c\x38\x6c\x87\x40\x18\x13\x1c\x86\x8f\xb3\xde\x97\x43\x5d\x05\xb0\x0f\xfe\x50\x68\x66\x23\x67\x28\x44\x82\xfb\xc4\x2d\x5d\x25\xaf\xda\x84\x20\x21\xda\xaa\x0d\x8c\xad\x34\x5e\xba\x79\x99\x36\xd8\xd3\xc0\x92\x8a\x62\xaf\xba\x7a\xe8\x6f\x8a\x30\x12\x0f\x53\x95\x05\x7b\xea\x0e\xf1\x36\x4d\xbe\xa5\xbe\xc6\x1e\x97\xd6\xf6\xc8\x25\x12\xf2\x8a\xde\x37\x42\x6b\x84\xc6\x29\xdb\x65\x49\xc0\xd1\x45\x36\x83\xf2\x74\xf5\xcf\x40\x33\x89\xf0\x19\xbd\x33\xbf\x2d\xbe\xaf\xc2\x96\xfb\xd9\x20\x2a\x0b\xb8\x1f\x41\xa1\x79\xc3\xb3\x82\x63\xbf\x0f\x82\x1c\xf5\xc3\x73\xf2\xa5\x68\x63\xc0\xb5\x65\x06\x59\x91\xac\x47\xe5\xea\x37\x18\xe0\xb3\x74\x1a\x9f\x57\xfd\xd0\x82\xd7\xe7\x3b\x93\x1f\xcf\xbc\x40\x43\x79\x5c\x97\xc4\x1c\xc3\xff\x6e\xcb\x11\x57\xa1\x6b\xca\x1f\x63\x59\x47\x6a\xf1\x7b\x42\x64\x1e\xe3\x7a\x06\x0d\xce\xbc\xd0\x92\x2e\x73\xb9\x1c\xb2\xbf\x1b\x96\x73\xfd\x1f\xc0\x31\x1e\x89\xb1\x04\x9b\x9b\xa4\xd0\xb7\x8e\x6d\x8a\xc9\xbf\x6b\xc6\x84\x99\xc4\x65\x5e\xc7\x0e\xcf\x63\x2f\xc9\xc2\xaf\x98\xf5\x2a\xe2\xff\x58\xcd\x7e\xf5\x91\x95\xe0\x50\xb2\xcd\x1a\xb3\x24\x1b\xc8\x59\xa3\x0d\x17\x74\xa1\x8d\xcd\x03\xa6\x91\x66\x70\x5a\x3e\x5d\x23\xf1\x10\xec\xbe\xe1\x19\x3f\xf7\xd9\xa1\x65\x82\x45\x2c\x9b\x63\xaf\xef\xc2\x08\x99\x28\x23\xde\x75\xb5\x42\xe2\x44\x6f\xd8\xe8\x76\xd3\xf6\x2a\x84\xc9\x26\x19\x55\xc2\xe7\x62\xb8\x55\x4d\x56\xa8\x08\x2d\x2e\x38\x91\xc5\x0c\xb7\xba\xe4\x5b\x98\xba\x70\xa9\x5d\x0f\x3d\x92\xaa\x49\x12\xf5\x5b\xc6\x1a\xff\xd4\x1f\xdd\x48\xe0\x92\x54\x66\xb6\x2b\xda\xb0\xed\xd3\x12\x85\xbb\x5e\x71\x65\x14\xcb\x27\x75\xd4\x82\x97\x47\x54\x41\x0c\x48\x60\x9c\x86\xbb\xc3\x24\x1b\xbc\x38\x7c\x03\x46\x3a\x08\x26\x5c\x3a\xf5\x1f\x59\xd9\xae\xea\x2f\x80\x1a\x69\x73\x1d\x7c\xb9\x0e\xea\xd0\xf2\x3b\xc1\x2d\xfc\xc7\x5f\xac\x05\x41\x7a\xcc\x7f\xc4\xda\x26\xca\xd0\x32\x23\x0c\x2b\xf6\x33\x1d\x4a\x29\x64\xe0\xd9\xaa\xf9\x3f\x51\x1b\xbe\x4a\x02\x50\xe2\x94\xd5\x66\xf7\xd5\x00\x5a\xed\x90\xc3\x6d\xf9\x6b\xdc\xa6\x1c\x6c\x15\x9f\x57\x4c\x0e\xfa\x88\x18\x1f\x2c\xce\x0e\x1a\xa4\x22\x5d\x61\x5b\x23\xa9\x5d\x59\x24\xdd\xaa\x1f\x4f\xca\x9b\x97\x4e\x0a\x88\x77\x44\x05\x90\x49\x0f\x38\x4a\x06\x03\x91\x35\xb6\x71\x31\xab\xb5\x56\xda\xcf\xd2\x48\x0c\x97\xdf\x50\xe2\x29\xd1\x66\x7a\x3f\x6d\x8a\x4e\x33\xf8\x25\xb3\x74\x5a\xbc\xed\x16\x93\x34\x29\x9b\x8d\x4e\xa3\xf5\x7e\xe3\xb4\x75\xda\x0a\x77\x29\x9c\x27\xdc\xad\xde\x37\xda\x84\x64\x70\xd5\x7f\xd5\xe7\x0d\xc4\x11\x2f\xce\x1d\xa8\x6d\x76\xea\xf3\x07\xfa\xc6\xd3\x36\xfa\x4f\xd4\xe8\xb9\xa6\x54\x5b\x28\xdb\x52\x6a\x1f\x08\x8e\x76\xd4\x64\x0f\x3e\x10\x22\x60\xcc\xe6\xee\x24\x7f\xa1\x41\x42\x88\x3f\x77\x82\x66\x69\x5a\x83\xde\x74\xb6\x5a\x9f\x23\x54\xd1\xf7\x5f\x57\xa8\x22\xb3\x92\x7b\x79\x2e\x67\xc4\x8f\xd6\x06\x3d\x30\x1f\xf0\x1a\x26\x1f\x34\xb7\x13\x0b\x77\xa3\x8b\xea\x22\x76\x3c\x79\xe2\xc2\xb1\xe8\xaa\xf3\x22\x76\x18\x68\x2e\xb0\x12\x0c\xa5\x1e\xfa\xdf\x82\x9a\xf3\x80\x6b\x58\xb6\x05\xce\xbb\x16\xf6\xf7\x1b\x41\xcd\x79\xb0\x35\x2c\xdb\x02\xd6\xb8\x1e\x74\x50\x71\x1e\x64\x84\xf4\x45\xa2\x27\x54\xb7\xdb\xee\x99\x0b\x1c\x55\x41\x12\xb3\xf2\xd5\x2a\x2e\x9a\x86\x5e\xc0\x6a\x15\x83\x8b\x7a\x1d\x5c\x85\xf0\x2c\xfd\xf0\x75\x9d\xa5\x4a\xfc\x1d\x4f\x2b\xaa\xb6\xc1\xfe\xf2\x3a\x49\x44\xd1\x44\x5e\xae\xcd\xcc\x63\xd2\x99\x88\x26\x68\xf2\x99\xb0\xbf\x9b\x78\xc6\x60\x22\xba\xc3\x12\x30\xfa\x04\xbe\x1b\x25\x16\x93\xd2\x85\x84\x7e\x9f\x9c\xee\x90\xcf\x5d\x17\x39\x8c\xed\xd6\x7c\xff\xf4\x49\x9b\x2b\xd0\xf2\xbe\xcc\x86\xc9\xf9\xd4\xb4\x04\xb5\x3d\x3c\x93\xbf\x81\xd9\x7f\xc3\x92\x8c\x54\x6f\xd1\xa6\xb3\x3c\x29\xbd\x66\xf1\x05\x36\x33\x27\x2d\x3f\x88\x2b\xfa\xbb\xb5\xc3\xae\xd9\xb5\xc1\x61\xb7\xa2\x44\xb9\x08\x0b\x57\x4a\x2d\xd8\x2b\x4a\x5e\x26\xfd\x77\x66\x29\xd5\x70\x5d\x71\xab\xba\xf8\x04\x50\x77\x62\xec\x53\x29\xc8\x16\xce\xd9\x83\x3b\x0f\x8a\x3f\x84\x1d\x33\x74\x52\x63\x07\x8e\x57\xf3\xf3\x06\x21\xa2\x01\x03\xe3\x46\xd7\x95\x9a\xf3\x80\xdb\x4a\x5f\x84\xf0\xb8\x0e\x6a\x44\xaf\xaa\x8b\x36\xfb\x20\xae\x0a\x73\x0c\x4a\x43\x7e\x3e\x5e\xef\xd0\x03\x94\xc0\x00\x0c\x2a\xa8\x16\xdd\x24\x1b\x88\xcb\xc3\x61\x33\x69\xb1\x7f\xec\xb2\x8d\x16\xa8\x60\x93\xcc\x60\xf7\x7d\x8d\xab\x16\x1b\xba\x23\x5e\x1c\xce\x32\x83\xb5\x78\xfb\xc3\x00\x92\x16\x6d\x8c\x43\x78\x9f\x9c\xb2\x5d\xd5\x27\x1c\x43\x8b\xba\x58\x18\xcc\xce\xb7\x1c\x6f\x26\x59\x51\xf2\xac\x2f\xda\x14\x5b\xcc\xd0\xef\xdb\x62\x66\xfe\x90\x43\xaf\xa2\xaa\x59\x8e\x14\xfd\xcc\xc4\x0c\x52\x22\xec\xe7\xb9\xcc\x9b\xdf\x3c\xe7\x19\x68\x9a\x79\x9a\xda\xd0\x2c\xbc\x60\xdc\x9e\xa7\x6f\xf0\x98\xd1\xa1\xd5\x6a\xf1\x9b\x85\x48\x87\x6d\x00\x66\x87\xa6\x3e\xf9\xbd\x1f\x19\x6f\x4e\x3d\x04\x10\x2e\x8d\x78\x91\x35\x4a\x94\x58\x25\x59\x52\x26\x3c\x4d\x0a\x31\x60\x1d\x56\x4c\x27\xa0\x75\xa3\x35\x54\x0f\x62\x80\x43\xd3\x8b\x08\x33\x78\xf0\xc0\x09\xea\xd4\xef\xdd\xdd\x5d\xf6\x0d\xe2\xc9\x37\x8a\x90\x55\xca\xdc\x2c\xd9\x53\xfc\x0c\xe9\xc7\x87\xc1\x66\x18\x27\x82\x66\x31\xed\x01\x09\x6f\xe3\xb0\xe0\x6f\x33\x55\x0d\xdc\x15\xa0\x70\xcf\x76\xa1\x46\x17\x14\x66\x53\x5c\xa9\xe8\xd6\x1c\xab\xba\xea\xbe\xca\x45\x51\xa8\x61\x40\x20\x65\x91\x80\xfa\xa1\x27\xa0\x31\x83\x54\x11\xa6\x8b\x36\x68\x93\xbf\x61\x0f\x59\x65\x2c\xb0\x54\x66\xf4\x0e\x7f\xd9\xae\x21\xbf\x3a\xb8\x04\x19\xa0\x37\x5c\x4a\x00\x3f\x2a\xc4\x36\x3b\xbf\x0d\x87\x0c\x6e\x3c\xb7\x38\x34\x20\xa5\xb6\x5f\x37\x64\x5f\x47\xa8\x64\xf4\x06\x31\x4c\x36\xbb\x36\x14\x95\x2c\xae\x1e\x5f\xe1\xc7\xf3\x7b\x1a\xff\x5e\xb3\x41\x6e\x6c\xc4\xfb\x60\x97\x54\xb1\x11\xa1\x1c\x3f\x43\x24\x5b\x41\x80\x21\x87\x0e\x46\xb4\xc7\x7e\xa9\x8b\x22\xa4\x6b\x2c\xeb\x42\xe2\x79\x90\x84\x34\x00\x2b\x68\x88\xbf\x23\x9f\x11\x50\xe5\xd5\xd2\x0c\xdf\x49\x44\xcf\xce\x77\x12\xd1\x5b\xed\xbb\x89\x98\xc5\x5f\xd5\x39\xc4\xfc\xdb\xfd\xa5\x10\x25\xf2\xa3\x3a\xbe\x97\xdb\x71\x5f\xb4\xa2\xab\x97\xb4\xae\x13\xaa\x5c\x5b\x78\xe7\xb5\xf0\x2a\xd1\x8f\x2a\x20\x2b\xf6\x52\x73\x56\x8c\x60\x8a\x33\x90\xa2\x0c\xa6\xc3\x4b\xcf\x24\xca\xc8\x4b\x9f\xcb\xac\x84\xa0\xfb\x51\x33\x87\xa0\x56\x75\xec\x44\xa3\x01\xac\xba\xee\x6c\xdb\x13\xfa\x78\x6b\xab\xc5\xea\xfe\x82\x53\xd9\xc6\x79\xac\xb6\xf7\xd1\x99\x2f\x19\x1d\xc1\x5d\x1a\x71\xcc\x37\xd5\x28\xf9\x39\x51\xb6\xf3\xf3\x98\x19\xc7\x7c\x13\x8e\x5c\x14\x4e\xfc\x5d\xc7\xb7\x38\x45\x71\xc9\xcf\xbd\xec\x0e\xa7\x2d\xdf\x10\x92\x9f\xc3\xed\x81\x46\xb9\x15\xbf\x0b\x22\x34\xf6\x25\x77\x2d\xd5\xb2\xed\x06\xe3\x64\xd9\xf5\x16\xd2\xe6\x76\xb5\x06\x99\x74\x17\xac\x5c\xc9\x09\x96\x34\x32\x38\xc1\x92\x2f\x4f\x32\xc7\xbb\x4f\x30\xcc\xb0\xa2\xaa\xd3\x00\xa3\x08\x03\x6a\xe5\x53\xb8\x7c\xc4\x47\x75\xed\x7a\xc7\xc2\xa5\xac\xad\x82\x57\xf2\xf3\x1a\x28\x24\x43\x52\xa4\xd8\xa6\x47\x8a\x94\xf5\xa4\x4c\x31\xd7\x90\xe9\x35\x22\x1d\x83\x8e\x41\x34\x1a\x17\x4c\xd9\x75\x0a\x1f\xaf\x7f\xfb\x1a\x1f\xaf\x5a\x2c\xef\xb8\x05\x5e\x14\xc9\x39\x98\xe5\x39\x22\x87\xc4\xac\xf2\x48\xdd\xc4\x47\x6a\x78\x2f\x79\x0f\x55\xed\x6b\x4e\xef\x18\xc5\x21\x5b\x38\xea\x8e\x4a\x32\x5d\xcd\xf0\x5b\x4b\xf1\xe2\xd8\x04\xde\x03\xc8\x04\x23\x23\xae\xaf\x34\x2c\x85\x5f\xf8\x98\xac\xf2\xe4\x7f\xbe\xc4\xfe\x98\x2f\x31\x17\x7a\x92\xde\xe4\xf8\xc5\x64\xe7\xe9\x23\x01\x73\x89\xc5\xb4\x39\x51\x9f\xa4\x25\xd1\x97\x82\x9f\x7f\x80\x31\x5a\xa5\xda\x2a\xb0\x9e\x02\x3a\xe2\x0c\xa8\x2a\xc0\x92\x2c\x13\xb9\x9f\x1d\x0b\x3f\x84\x49\x11\x6a\x93\x94\x2d\x75\x41\x39\x43\x26\x33\x00\xcc\xff\x83\x7d\xc5\x6e\x2c\x30\x02\xa2\x24\x9d\xed\x9a\x45\xeb\x7a\xdf\x6d\x6d\xdc\x01\x9c\x8b\x5d\x75\xfb\xd1\x63\xcc\x3c\x00\x5d\x8f\xb7\xa0\xca\x51\xf2\x34\x73\xeb\xe4\xc5\x76\x20\x9e\x76\xba\x02\x6d\xaf\x03\x5c\xad\xc5\x9d\x10\xe2\x90\xaa\x4a\xef\x8f\xa8\xc0\x73\xd3\xbb\xf6\xa2\x82\x1a\x78\xcd\x8f\xb4\xdd\x36\xfd\x41\x2e\xee\x6d\xb2\x5f\xd7\x8e\x05\x04\x9b\x26\xb3\x35\x76\x37\x35\xed\x06\x6d\x96\x6d\xd6\xaa\x4c\xc8\x43\xbe\xd0\xad\xc2\x87\xda\x45\x56\xdd\xce\x05\x06\x40\x19\x87\xa0\x3a\x41\x4f\xbf\x0d\xe1\x1b\xea\x79\x16\x87\xed\x01\x5c\x8f\x7d\x51\x3b\x84\xfb\xdf\xed\xdf\x1d\x5b\x61\x40\x86\x6c\x85\x1d\xc8\x8d\x98\x0b\x85\x5c\x71\xd6\x42\x21\x12\x1a\x1b\x9a\x35\x8b\x77\x80\x61\x55\x68\xec\xab\xcf\x30\x8c\xba\x9c\x1d\x48\x23\x43\xc6\xe5\xfb\x8d\x3f\x19\x97\xaf\x92\x71\xf9\x53\xf1\xf0\xa7\xe2\xe1\x0f\xa0\x78\xd0\xc9\x26\xe6\xc5\xe4\xff\x7e\x33\xa8\x38\x17\x38\x86\xc8\xf8\xb2\x8c\x74\x80\x8a\x86\x7f\x6e\x23\x75\x23\xfc\x31\xe1\x98\xe3\x58\xec\x9a\x7e\xf4\x93\xbb\x55\x93\x05\x45\x44\xb1\xa1\xb8\x16\x04\xb3\xe6\x8a\x07\xb6\x59\xd3\x21\x80\x49\x18\x68\xd9\xfb\xcf\x1f\xe0\x6d\xf0\xa7\x96\xe6\x4f\x2d\xcd\x9f\x5a\x9a\xdf\x50\x4b\x93\x49\xe9\x45\x00\x53\xbf\x9b\x5e\x14\x7f\xb5\xec\x2e\x2a\xb1\xb5\x2e\x59\x46\xa9\xa3\x8d\x53\xeb\x75\x3a\x58\xe1\x0e\x55\x3a\xef\xec\x5d\xf3\x7f\x50\xa3\xa3\x4d\x7e\x97\x50\xe8\xe8\x65\xb8\xa9\x3e\xa7\x12\xea\x0b\x14\x0e\x60\x2c\xb4\x9c\x82\x87\x93\xaa\x77\xa2\xdf\x89\x8a\x3a\xba\x1e\x98\x66\x2b\xd2\xcb\xe1\x70\x58\x88\xd2\x67\xd7\x07\xbc\xe4\x95\x6e\xf4\x3a\xaa\x4b\x11\x2a\x74\x25\xb6\x6c\x75\xc7\x7c\x42\xbc\xfb\xd5\x23\xa2\x2a\xd4\xa7\x2d\xde\x3b\x04\x70\xf6\xdf\x6e\x50\x49\xf1\x82\x97\xfc\x45\x92\x97\x57\x73\x46\x65\x63\x8e\x68\x87\x2b\xbf\xd4\xf6\xfb\xff\x1c\x1f\xbe\xd5\x12\xf6\x64\x78\xd5\xac\xcc\xbb\x0a\xa3\x05\x74\x78\x61\x3b\xac\xbb\x48\x97\x41\x63\x8c\x5c\x07\xf3\x9c\x42\xa0\x33\x70\xa4\x7f\x23\x07\xc9\x30\x01\xaa\x61\x40\x08\x63\x51\x6e\x92\x2c\xaa\xff\x20\xe5\xc5\x36\xfb\xdb\x86\xcd\x09\x31\xcc\x88\xc2\x69\x98\x35\xc3\x65\x70\xcb\x44\xd7\x55\x8f\xbe\x1a\xf7\x86\x06\x7d\x51\x75\xb6\xe1\xff\x3d\x23\xfd\xeb\xd8\xd6\xd6\xcd\x51\x9d\x3a\x40\x48\xb0\x89\xad\xc1\x63\x78\xc5\xa9\x6e\x76\x59\xb8\x1b\x56\x17\xb5\xbe\xce\x0e\x86\x86\xb6\x26\x70\xef\x23\x63\x53\x26\xbc\x14\x83\x36\x1b\x25\x03\x8c\xd7\x8b\x07\x40\x8b\x74\x5c\xeb\x52\x32\x0e\x9e\x3f\xc3\x94\x17\x23\x26\x87\x6c\x9a\x81\x5d\xee\x00\xa5\x84\x59\x59\x0d\x91\x63\x62\xd3\x41\x48\x80\x1a\x04\xa3\x4b\x38\x91\x26\xa1\x46\x83\xf7\x0a\x99\x4e\x4b\xe1\x19\x99\x47\x33\xa5\xf8\x0e\xc1\x26\x1c\xbe\x5b\xee\x8a\xa3\x12\xe6\x42\xe3\x25\xff\xab\x3e\x4f\x7f\xb5\x4f\x11\x7a\xca\x8c\x27\x01\x55\x2e\xa2\xab\x71\xa4\x6d\xb7\xf4\xfd\x49\x20\x93\x43\x4d\x55\x55\xd6\x8e\xcc\xba\xae\xbe\x29\x77\xfe\x9a\x86\x70\x59\x71\xe1\x5a\x75\x05\xcd\x5f\x66\xf6\x6d\x9c\x5c\x61\x92\x76\xd5\xe0\x19\xf5\x45\x9e\x43\x33\xef\xdf\x0f\x31\x8d\x3d\xad\x20\x9f\xf3\x62\x66\xdb\xd4\xc2\xb8\xa6\xeb\x57\xc9\x22\x4a\x1d\xe9\xf5\xc1\x83\x6a\xb7\x80\xca\x4f\x59\xa3\xb1\xa0\x5b\xb8\x6e\xe6\x1d\x2c\x82\xc9\xa4\x4b\x85\xcc\x95\x3e\x0d\xd2\xc0\xbd\x14\x43\xf3\xeb\x5a\x52\x67\x43\x13\xfc\x15\xe0\xfd\xd5\xe2\x40\xe4\x3c\xfb\xfd\xf8\x2e\x07\x1a\x3b\x63\x90\x42\xf4\x74\x08\x1a\xad\xad\x0a\x49\x84\x1d\x33\x05\xd5\xc3\xb6\xfa\xbf\x36\x34\xdf\x46\x20\xd7\x11\xda\x75\x07\x66\x11\x86\xb3\xfb\x12\x56\x11\x15\x73\x08\xcb\x88\x10\x6b\x08\xfb\x2d\x30\x86\x70\x58\x44\x8c\x21\xdc\xc7\x15\x8c\x21\xee\x22\x94\x0b\xbd\x1a\x0d\xef\xbb\x54\x87\x18\x36\x74\x89\x1e\x75\x7c\xd1\x94\x1b\xf5\x84\x77\x5c\xec\x67\x72\xf8\x15\x3f\xe0\xac\x35\x48\xc1\xa7\x4f\xcc\xd5\xf7\x1c\xc1\xc2\x36\x5e\x21\x3d\x5e\xf5\xf3\x0d\x7d\x82\xe9\x7d\xf4\xe0\x01\xe9\xd8\x0b\x52\x45\xfa\xb4\x1a\x8b\x4a\x77\xcb\x45\x5c\xfd\x9c\x91\x57\x70\x1c\x03\x51\x94\xb9\xbc\x5a\xb8\xcf\xde\xfa\xd4\x74\x18\xac\xe1\x32\x3d\xd1\x85\x0d\x1d\xdc\xf0\x2b\x1e\xe8\xea\xbe\xd4\x8d\x93\xd6\xaf\x1b\xa7\x0f\x73\x15\xdb\xa0\xc9\x92\x71\x36\x7c\x4c\x74\x71\x4c\xe8\x67\x2f\x7c\xcc\x58\xb3\x9f\x15\x1d\x1e\xc1\x26\x5b\x87\xba\x0b\xc2\xbb\x49\xd3\x8e\x8f\x8e\x65\xd5\x81\x02\xdd\x98\x08\xab\xbb\xcd\x6a\xb9\x5f\xf2\x22\xa8\xec\x8f\x7d\x2f\xd1\x4d\xb2\x63\xc2\xeb\x84\x70\xcf\xcc\xf3\xc9\xf5\x21\xcc\x61\xad\xbc\x43\xb6\x0b\xe2\x17\x23\xbe\x35\x5a\xa9\x66\xe4\x7d\xd6\x6c\xe9\xa5\xfa\x05\xf5\x5c\x84\x3e\xcf\xf5\x20\x0d\x7c\x47\xbd\x9f\xed\xea\x2c\xb7\xdd\x9f\xd5\xa5\x5a\x5f\x67\xe6\x3c\x33\x9e\xe9\x15\x57\x5c\xef\x98\x7f\x10\xac\x98\x62\xd4\xa7\xfc\xaa\x1c\x25\xd9\xb9\xa2\xfb\x85\x65\xb1\x80\x05\xce\x73\xd1\x27\xec\x32\x1f\x42\xf2\x2b\xa1\x2a\x53\x46\x3b\xb2\x50\x35\x74\x24\x76\x3e\xbc\x63\x58\x77\x40\x82\xb3\xea\x91\x67\xda\x6f\x2d\x5d\xd3\x00\x96\x38\xb0\x37\x8c\xc1\xb4\x55\x1f\x83\x69\xab\x3e\x08\x53\xc5\x0a\x63\xab\x6a\xaa\xc1\x7c\x0b\x0b\x53\x2f\xb4\xb1\x88\x53\x83\xad\x55\xc8\xc1\x56\xb7\x06\xdd\x98\x4f\x0e\x74\x65\x77\xfc\xe9\x94\x42\x83\xc4\xad\xdb\x5a\x24\x6e\xcd\x35\xf9\xf0\x82\xc1\x78\xc3\x57\x1f\xec\x10\xeb\xec\x19\x9d\x85\x48\x60\xf3\x61\x3f\x56\xfc\x9c\x75\xc8\x41\x38\xd7\x15\xf7\xe6\x55\xac\x3d\x58\x8d\xc5\x07\xab\x72\x56\x74\xa0\x86\xbb\x8f\xbd\xa6\x1d\x7e\xbb\xfa\xef\xbc\x28\x38\xf1\x97\x51\xac\x9d\x7e\xbb\x44\x5e\x34\xcd\xd6\xdc\xc0\x98\xf5\xf3\x25\xba\xaf\x77\x41\xc8\x4b\x32\x5e\x8d\x16\xcd\x5f\xfc\xdf\x1f\x3d\xf4\x19\x6e\xbb\x2d\xa2\x88\x55\xe0\xcd\x43\x96\xca\xad\x69\xc5\xd9\xda\xeb\xa2\xcd\x1a\xea\xb9\xd0\xa1\x18\x15\xac\x60\x6b\x39\x08\x97\x1d\x39\x2d\x3b\x72\xd8\xe9\xc9\x69\x36\xe0\x79\x02\x81\x96\xdc\xaa\xe2\x3b\xc2\x36\x23\xdb\x5e\x31\xc7\xf1\xde\xd4\x24\xdd\x05\xed\x35\x76\xac\x88\x89\x8e\xb7\x3a\x1e\x59\xde\x66\x21\x07\x39\x87\x86\xbb\x65\xac\x32\xa3\x2b\x58\xfe\xd0\x9b\x50\xef\x55\xbc\x22\x3e\xeb\xdb\x74\x27\x49\x98\x80\x70\xab\xb6\xc3\xad\x0a\xab\xc6\xf6\x64\x9b\xec\x49\x0d\xa3\xb1\x8c\x75\x12\xab\xb3\x50\xb2\x08\x5a\xfb\x4e\xae\xb7\x54\xaa\xb6\x0d\x24\x25\xb7\xb5\x58\x62\x71\x03\x6a\x3c\xe5\x75\xf6\xd3\x5a\x98\x7e\x87\x26\x4e\x06\xe2\x5c\x83\xec\xd5\xe1\x7d\xad\x16\x53\x34\x59\x4f\xdd\x38\x9a\x21\x7f\xe9\xee\xf0\x02\xba\x0a\x78\xc4\x3a\x23\x71\x55\x95\x30\x8a\xf5\x4b\xf8\x45\x4c\xb9\xde\x19\x46\xac\x62\xab\x4e\xf6\xc6\x06\xf3\x88\x44\x58\x88\xcc\xdc\xc8\xc1\xc9\x2c\x3f\x5e\xc7\x0d\xde\x0d\x5e\x87\x66\x63\x9b\xf3\xcc\xc6\x9c\x19\x87\x06\xf8\xcb\x2f\xcb\x9a\x90\xc5\xcd\x22\xa2\x00\x03\x63\x32\x6a\x4a\x06\xf4\x68\x4e\xbc\x07\x37\xe4\xf3\x54\xf6\x78\xda\x62\x1f\xd7\xbf\xfd\xf6\xfe\x1a\xfb\x96\xfd\xd7\x30\x49\x21\x80\xda\x45\x22\x66\xec\xbf\x93\xfe\x07\x5e\x14\x2c\x4d\x7a\x39\xcf\x21\xf0\x16\x52\x0d\x48\xa5\x07\xab\xad\xcf\x5a\xc1\x32\xc1\x21\x70\x56\x92\x93\xcc\x97\xfa\xe5\x54\x74\x01\xf6\x85\xc8\x41\xd9\xbc\xd9\xdd\xdc\xea\xfe\x00\x9f\xd2\xa4\x2f\xb2\x42\xa8\xbf\x9f\xcb\xc9\x15\xe6\x31\x6e\xf6\x5b\x6c\x6b\x63\xf3\x09\x7b\x29\x06\x22\x4f\xfa\x92\xfd\xbf\xc9\x85\x4c\x25\xf4\x0a\xe1\x85\x93\xde\xb4\x94\xea\xf1\xf2\xad\x6a\xf9\x4e\xe4\xe3\x04\xf5\xd8\x49\xc1\x46\x22\x17\xbd\x2b\x76\x9e\xf3\x0c\xe4\xf9\xc3\x5c\x40\x42\xb8\xfe\x48\x3d\xb3\xda\x20\xbf\xcf\xae\x98\x1a\xb4\xcc\x98\xec\x95\x3c\xc9\x30\xd0\x58\x5f\x4e\xae\x14\x3c\x08\x2b\x9b\x14\xac\x90\xc3\x72\xc6\x73\x9c\x2d\x2f\x0a\xd9\x87\x97\x0b\x1b\xc8\x3e\x68\x20\x39\xea\x4a\x92\x54\x14\xea\x41\x21\xd8\x37\xc7\xba\xc5\x37\x2d\xe8\x67\x20\x78\xaa\x00\x26\x98\xe3\xce\x94\x42\xa0\x0e\x39\x85\xfc\x88\xb0\xf3\xa0\x5f\x4f\xb2\x7e\x3a\x85\x90\x67\xa6\x38\x4d\xc6\x89\xee\x44\x35\x87\xc5\x51\x73\x56\xa0\xa7\x05\x28\xba\x27\x57\x6d\xc4\x63\xf5\xaf\x80\xf9\x4d\xa6\xbd\x34\x29\x46\x6d\x36\x48\x0a\x5c\x29\xd1\x66\x85\xfa\x08\x4b\xdd\x56\xb3\x59\x97\x39\x2b\x44\x0a\x83\xeb\xcb\x49\x22\x0a\x13\x4b\xd7\x8c\xb1\x8d\xd9\x12\xa5\x5a\xa7\x71\x52\xea\xe5\xc2\xa4\x65\x23\x9d\x1f\xd1\xce\x27\x81\x51\x0d\xa7\x79\x96\x14\x23\x4c\xc2\x35\x90\xac\x90\xd0\xaf\xc2\x68\x13\xb2\x6d\x28\xd3\x14\x73\xac\xf5\x65\x36\xc0\xd4\xde\xdb\x7a\x17\x4f\x46\x82\xf1\x9e\xbc\x10\x30\x2d\xc4\x84\x4c\x96\x49\x5f\xe8\xc4\x8d\x49\x81\x83\xc1\x9d\xd6\x45\xc5\x88\xa7\x29\xeb\x09\xbd\x7c\x62\xa0\x16\x9b\xfb\x33\xcb\xd5\x30\xf4\xcb\x33\x65\xea\x04\xa9\x7e\xc3\x19\x77\xcd\x38\x5e\xed\xb3\xe3\xc3\x97\x27\x3f\xef\x1d\xed\xb3\x83\x63\xf6\xee\xe8\xf0\xa7\x83\x17\xfb\x2f\xd8\x37\x7b\xc7\xec\xe0\xf8\x9b\x36\xfb\xf9\xe0\xe4\xd5\xe1\x8f\x27\xec\xe7\xbd\xa3\xa3\xbd\xb7\x27\xff\x66\x87\x2f\xd9\xde\xdb\x7f\xb3\xff\x3e\x78\xfb\xa2\xcd\xf6\xff\xf5\xee\x68\xff\xf8\x98\x1d\x1e\x29\x68\x07\x6f\xde\xbd\x3e\xd8\x7f\xd1\x66\x07\x6f\x9f\xbf\xfe\xf1\xc5\xc1\xdb\x7f\xb2\x67\x3f\x9e\xb0\xb7\x87\x27\xec\xf5\xc1\x9b\x83\x93\xfd\x17\xec\xe4\x10\xfa\xd4\xd0\x0e\xf6\x8f\x15\xbc\x37\xfb\x47\xcf\x5f\xed\xbd\x3d\xd9\x7b\x76\xf0\xfa\xe0\xe4\xdf\x6d\x05\xeb\xe5\xc1\xc9\x5b\x05\xf9\xe5\xe1\x11\xdb\x63\xef\xf6\x8e\x4e\x0e\x9e\xff\xf8\x7a\xef\x88\xbd\xfb\xf1\xe8\xdd\xe1\xf1\x3e\xdb\x7b\xfb\x82\xbd\x3d\x7c\x7b\xf0\xf6\xe5\xd1\xc1\xdb\x7f\xee\xbf\xd9\x7f\x7b\xd2\x65\x07\x6f\xd9\xdb\x43\xb6\xff\xd3\xfe\xdb\x13\x76\xfc\x6a\xef\xf5\x6b\xd5\x9b\x02\xb7\xf7\xe3\xc9\xab\xc3\x23\x35\x50\xf6\xfc\xf0\xdd\xbf\x8f\x0e\xfe\xf9\xea\x84\xbd\x3a\x7c\xfd\x62\xff\xe8\x98\x3d\xdb\x67\xaf\x0f\xf6\x9e\xbd\xde\xc7\xde\xde\xfe\x9b\x3d\x7f\xbd\x77\xf0\xa6\xcd\x5e\xec\xbd\xd9\xfb\xe7\x3e\xb4\x3a\x3c\x79\xb5\x0f\x93\x54\x35\x71\x98\xec\xe7\x57\xfb\xea\xab\xea\x75\xef\x2d\xdb\x43\x92\x73\xf8\x92\x3d\x3f\x7c\x7b\x72\xb4\xf7\xfc\xa4\xcd\x4e\x0e\x8f\x4e\x6c\xeb\x9f\x0f\x8e\xf7\xdb\x6c\xef\xe8\xe0\x58\xad\xcc\xcb\xa3\xc3\x37\x30\x53\xb5\xba\x87\x2f\x55\xad\x83\xb7\xaa\xe9\x5b\x4d\xbb\xd4\xca\xfb\x1b\x74\x78\x04\xbf\x7f\x3c\xde\xb7\x30\xd9\x8b\xfd\xbd\xd7\x07\x6f\xff\x79\xac\x1a\xeb\xb9\x9a\xfa\x6a\x93\xd7\xc1\xba\x22\x29\x9e\xe5\x72\x56\x60\xa8\x48\x64\xd8\x30\xb2\x1e\x46\x59\xb3\xea\x12\x88\x91\xa8\x2b\x98\x83\x1f\x56\xd9\x01\x88\xa9\xcc\xce\x85\x09\xf0\xac\x81\xab\xdb\xea\x7d\x63\x7f\x70\x0e\x31\x48\x4f\xf2\x64\xa0\x1f\x9d\x2f\x93\x5c\x0c\xe5\x65\xe3\x14\xdb\x96\xd8\xea\x85\xce\x72\x0f\x36\x11\x6b\x31\xeb\xd5\x68\x27\xce\x9a\x95\x3d\xdc\x65\x9b\xc8\x62\x2a\x4e\xd4\x4d\xf2\xc1\x03\x96\xf1\x8b\xe4\x9c\x97\x32\xef\x4e\x0b\x91\xef\x9d\x43\x2e\x5f\x6d\x94\x16\x05\xfb\x3e\x39\x35\xb6\x6a\xc8\x7c\x56\x47\xb9\x89\x2c\x21\x64\xf3\xb6\x19\x94\xed\x73\x78\x9c\xf4\x73\x59\xf2\xe2\xc3\x0b\x9d\xec\xab\x39\xcc\x9c\xdf\x09\x5a\x5a\xb9\xc4\x22\xac\x6a\x9c\x6a\x3a\x86\xd4\x06\xdc\x0f\x38\x4f\xf3\x35\xe1\xc3\xd7\x02\x74\xca\x72\xdc\xd2\xee\xbb\x5c\x8e\x93\x42\x74\x73\x01\xe9\x58\x9b\xad\x6e\x39\x12\x59\x34\x93\x40\x75\x54\x0c\xb4\xe3\x56\x1a\x85\x6a\x9a\x1d\x6f\xa2\xb5\x73\x34\xaf\xa1\xe5\xa7\x79\xdf\x36\x71\x63\xa2\x50\xa8\x21\xc0\xc2\xa4\x08\xd1\xee\xc3\x19\x61\x56\x76\x7f\x6b\x7d\x37\x12\x6d\xc0\x54\x4c\x27\xc0\x7e\xbc\x51\xdb\x7a\xc2\x8b\x0f\x0a\xbb\x3d\x14\xf3\x97\x1b\xf9\xa6\xb5\x6f\xd9\x73\xcd\x34\x30\x93\xf4\x6d\xc0\x0c\x2f\x20\x87\x8c\xb3\xb1\x28\x47\x72\xd0\x66\xe5\x88\x97\x8d\x82\xf1\xe2\x2a\xeb\x8f\x72\x99\xc9\x69\x91\x5e\xb1\x81\x62\x27\x14\xa3\xfe\x2d\xeb\x4d\x4b\xb3\x41\xfa\x4e\x1d\x27\x59\x32\x9e\x8e\x61\xfc\xcc\xa8\xd9\xba\x6b\xaa\xd7\xff\x42\xb0\xf8\xd7\xb8\x27\x72\x69\xf4\xfe\xdd\x1f\xcb\x24\x2d\x54\x81\x31\x26\x62\x1f\x5f\xea\x05\xbc\x66\xc3\x4c\x95\xe0\x26\x15\xa4\x60\x4d\x53\x0e\x33\x09\xb4\xf2\x0a\x57\xe4\x69\x15\xeb\xd9\xb6\x87\x20\x7a\x59\x14\xcb\x33\x12\xfd\x0f\x6a\xd7\xd5\x4c\xce\x93\x0b\x91\x29\xa4\x49\xc0\xde\x3b\xa1\x96\x92\xc0\x2b\xe9\xe9\xb0\xda\xf9\x30\x6f\x42\x7b\xd9\xd5\xb5\x05\x70\x22\xb1\xaf\x8e\xeb\x40\x31\x73\xea\x1b\x34\xb3\xb3\x7d\x26\x65\x2a\x78\x76\xcd\x78\x56\xcc\x20\xcc\xfe\xb6\x3f\x94\xa7\x40\x41\x2d\xba\x25\x85\x59\x9f\x66\xd0\x97\x3b\x04\xe7\x02\x5e\x67\x3a\x58\x71\x05\xff\xcd\xd8\x1e\x3c\x30\x35\xbb\xa5\x3c\x86\xd7\x32\x1a\xbd\x56\x00\xc3\x7b\xfa\x3d\x3e\x43\x98\xe9\xff\xb4\x01\x88\xaa\x97\xf6\x9f\xa2\x64\xcf\x8f\x8f\xe1\x99\x30\x55\x4c\x9b\x0d\x01\x2b\xe9\x72\x0b\x63\xdd\xb1\xfa\xfa\xee\x43\xcb\x6b\x0f\x84\x2b\xc5\xf1\x5f\xdb\x6e\xfd\x55\x3b\x17\x25\xc8\x26\x9e\xeb\xd1\x39\x5f\x11\x04\xd6\xb6\xed\x1c\x2d\x37\x59\x0e\xd4\xb3\xe9\xc4\x24\xb3\xdb\x34\xa7\x5d\xaf\xe9\xfb\x53\xa4\xc2\x20\x7a\x7f\x7b\x78\xb2\xbf\xcd\x36\xd9\x8b\xc3\x37\x3a\xf9\x34\x30\xc7\x86\xfc\x82\x6b\xc5\xb9\x28\xcd\x20\x50\x16\x68\x47\x00\x06\xa4\x64\xbb\xec\x02\x3e\x55\x4d\xdf\x9b\x9f\xa7\x6c\x5b\xfd\xa6\x6b\x7f\xa4\x91\x09\x8c\x68\x78\x2e\x32\xb4\x3d\xd3\x81\x75\x47\xb2\x28\x83\xcc\x0d\x37\x5a\xfe\x34\xb2\xfe\x16\x8d\x6d\x29\xf6\x5f\x59\xfd\x77\x76\x58\x66\xc2\xf1\x85\xc6\xa0\xee\x0a\xdd\x5e\x9d\xbc\x79\xdd\x08\x56\x5b\xd7\x34\x4b\xee\x7f\xed\x92\xa9\x7f\xfa\x64\xbf\xaa\xe9\xd7\x2d\x56\xd1\xcf\x65\x9a\x2a\xf6\x18\xdb\xde\x1d\xae\x2e\xb7\x58\xd8\x7f\xdd\x9a\x1d\x43\x29\xae\x9c\xbf\x6a\xeb\xeb\x7a\x1a\xac\x27\x07\x57\x6d\x76\x66\x6b\x9f\xb1\x59\x92\xa6\xac\xe4\x1f\x04\xeb\xab\xa7\x42\x29\x15\x28\x8c\xdf\x8c\xaa\x22\x76\x86\xdd\x9e\xc8\xc9\x19\xe6\x5e\x4f\x4a\xbd\x13\xf7\xbd\x5e\x9c\x9d\x98\x66\xc3\xba\xaa\x37\x6b\x34\x51\xcc\x92\xb2\x3f\xaa\x6e\x9f\x75\x07\xe4\x85\xd0\xdb\xb8\x4d\x3e\x3c\x3b\x7c\xf1\x6f\xfd\xa1\xb2\x83\x72\x96\x89\xfc\x45\xd8\x9b\x69\xf9\xff\x33\xe3\xa8\x6b\xee\x0d\x6f\x7d\x9d\x69\x9e\x8f\xcd\x78\x56\xb2\x69\x61\x29\x30\x3b\xeb\x5c\x9e\xc1\x23\xe7\xac\x73\x75\x86\x14\x1a\x9f\x28\xbc\x60\x33\xf5\x4c\x33\x9e\xba\x31\xba\x81\x87\x78\x2e\x39\xb1\x22\x50\x79\x21\xf2\x61\x8a\x01\xe9\x62\x8d\xba\xa6\x42\xd8\xe0\x5f\x0b\x5b\xfc\x2b\x6c\xf2\xef\x85\x4d\xfe\x6d\xfd\x39\xd7\x9b\x7c\x5a\xca\x4f\x88\x08\xad\xf5\x6e\x29\x8a\xb2\x69\x07\xfb\x90\xc0\x74\x7f\xff\xab\x35\xef\x34\xba\xe3\x18\x62\x6e\xfc\xf4\xb7\xea\xce\x24\xda\x19\xfd\x46\x07\xd2\xeb\xbc\x72\x20\xd1\x82\xb4\xe6\x40\xce\x27\xfe\x92\x34\x65\xbb\x36\x17\xcf\x83\x07\x0e\xf7\x49\x8d\x1d\xdd\xca\x51\x44\x1f\xc0\x83\x07\xde\x6f\x7b\xf4\xec\xfe\xde\xb7\x2d\x3f\x7d\x62\x3e\x5d\x85\xf3\x57\xfd\xec\x91\x5b\x42\x95\x2b\x26\x4c\xf1\xb3\x6a\x8e\xe6\x7e\x4a\x32\x30\xf8\x46\xe2\x83\x39\x75\xcd\x89\xf5\x56\x01\x49\x99\xb1\xc7\x55\x04\x2c\x95\x85\x28\x4a\x76\xf2\x42\xdd\x6d\x27\xf0\x5a\x4e\x32\xa0\x0e\x6b\x3a\x1d\x96\xbf\x4e\x49\xc1\x26\xb9\x28\xe0\x7a\x3d\x60\x23\xd0\xab\x8f\x92\x82\xfd\x47\xf6\xba\xdd\xae\x5e\xab\xf7\x8d\x93\x17\xf0\x58\x54\xf0\x1a\xa7\xf6\x89\x16\x5d\x61\xb4\x31\xee\x6c\x6a\xe6\x29\x4e\x05\x68\xcb\x36\x6b\x18\x6d\x7d\xa3\x65\x14\x13\xbc\x4c\xfa\xe1\xdd\x16\xe2\x17\x05\xd2\x0a\xcf\x98\x8f\x2c\xf4\x65\x94\x14\x08\xe5\xb9\xcc\x4a\x9e\x64\x22\xf7\x37\x32\xc0\xaa\x90\x76\x5b\x04\x8a\xe0\x4c\x30\x5e\xfb\xbc\x21\x37\x71\x04\xa5\x14\xa6\xd5\x1c\x9d\xee\x30\xc9\x0b\x83\x05\x60\x37\x87\x0b\x64\xe9\x8a\x23\x10\x2f\x13\x48\xe0\x3f\x12\x2c\x97\xb2\x84\x7e\x58\xd3\xe0\x51\x9b\x15\x23\x3e\x90\x33\x75\xf2\x54\x71\xeb\xee\xa9\x46\x06\xd6\x27\x51\x92\x61\x07\x54\x21\x17\x47\x52\x96\x44\x2f\x6d\x96\x95\xf2\x29\xc4\x71\x28\xc0\x05\xdb\x98\x54\xaf\xa0\x01\x6a\xb5\x63\xcb\xe4\x53\xd1\xbe\x1c\x8f\xa5\xcd\x08\x56\xce\xa4\xce\xf7\x20\x06\x00\xa2\xb8\x0b\x8a\xba\xb9\xa0\x7c\xab\x66\xfd\xf4\xd8\xe6\x50\xde\x61\x92\x0d\x9e\x43\xad\x18\x16\x6d\xb6\x6d\x0f\x96\x16\x9f\xa8\x43\x8e\x57\x7d\x52\x40\x62\x34\x14\x92\xa2\x1d\xb9\xc8\x73\x99\x17\x86\x72\x30\x99\x89\x80\x3d\x2e\xb4\x9d\xba\x89\xad\x31\x94\x39\x88\xb0\x73\xc1\x0b\xb0\x6b\xa6\xbc\xd2\x26\x98\xe5\x9a\x1f\xee\xb5\x40\xbe\x6e\x79\x3f\x6c\x95\x3a\x2e\x6b\x0e\x7d\x7c\x25\x72\xc1\x66\x82\x98\x06\x29\xfe\x2e\xb9\x10\x8a\x73\xf9\x06\x72\x6c\x7f\x43\x67\x02\x2f\x7c\xb5\xc4\xa2\x60\x70\xda\xcc\x33\xfe\xc5\xe1\x1b\x73\x33\xe5\x03\x8c\xd5\x6c\x66\xa0\x5e\x70\x3c\x17\x86\xb4\xbf\xd3\xd4\xab\xe9\x56\xf9\x01\x53\xd8\xd8\x7d\x71\xf8\xfc\xc7\x37\xfb\x6f\x4f\x7e\x79\x77\x78\x7c\x70\x72\x70\xf8\xf6\x97\x97\x87\xaf\x5f\x1f\xfe\x7c\xf0\xf6\x9f\xe6\x02\x2b\x74\xe6\x1a\xec\xe4\xa9\xed\x84\x6d\xdb\x4d\x33\x55\x05\x24\xaa\x09\x2a\x6e\xb9\x8a\x9b\x3b\x7a\x0d\xd4\x4b\x53\x23\x0d\xcf\xfa\xa2\x28\x65\x0e\x4a\x0a\xa0\x76\x1a\x58\xce\xb3\x73\xf0\x19\x37\x6b\x8a\x6a\x94\x23\xf5\x19\xc5\x30\x50\x43\x3b\x4d\xe4\x65\x13\x06\xda\x66\x1b\x7e\x19\xa4\xe8\xcc\x06\xe6\xbb\x56\xa0\x8f\x65\xb6\xa7\x3b\xb6\x54\x96\xed\xea\x56\x35\xe5\x66\xf0\xcf\x64\x39\xc2\x33\x07\xf9\x02\x93\xac\x48\x06\x82\x59\xce\x76\xcd\x7f\x12\x6d\x02\x81\xa8\xeb\xd2\x31\x0f\x5b\x73\xeb\x7d\xfa\x84\xfb\xd0\xd5\xab\x54\xa8\x39\xb5\xe8\x5d\x5f\xbd\x34\x6a\x60\xb5\x2a\xec\x40\xed\x7c\xab\x0c\x40\x78\x0d\xd4\xf5\x41\x11\x9e\x1c\x4e\x5c\xb5\xa4\x30\x8b\x66\x89\x7e\x1b\x28\x04\x9b\x8d\x92\xfe\x48\x35\x30\x08\xa5\xd7\x10\x08\xf4\xae\xa5\xa9\xe6\x33\x74\x43\xd7\x5a\xd5\x83\xd7\x62\x78\xd1\xcd\x27\x3f\xb6\x19\xa1\x43\x95\x58\x27\xcb\x81\x6a\x87\x83\xdc\x6a\xe1\x80\xac\xa4\xd7\x09\x5b\xe8\x03\x16\x75\x91\xd1\x5b\xcf\x9c\x77\xfc\x08\xeb\xd6\x2c\xe5\x04\x1e\x3f\xa9\x18\x96\xad\x3b\x63\xa6\xab\xa2\x18\xe8\xed\xac\x54\xcf\x4c\x99\xb3\x33\xd5\xdd\x99\x7f\x09\x64\x53\xd5\xd9\x35\xe3\x60\x65\xac\x26\x80\x13\x12\x03\x36\x49\x2e\x05\x74\x1c\x7b\x13\x57\x79\x9a\x02\xcd\xa0\x42\x2f\x48\xf6\x0f\x06\xac\x9a\xf3\x61\xdc\x3c\xf5\xf3\xad\xb2\xa7\x7e\x21\x64\x99\x98\x34\x6c\xa8\xa1\x29\xd8\xb5\x20\x74\xec\x44\xb1\x36\xaa\x0a\x7b\xca\x1a\xf6\x25\xdd\x50\x0d\xf1\xd7\x6b\x31\x2c\x1b\x11\x0e\x7e\x15\x5e\x6b\x01\x7f\xae\x20\x8f\xca\x71\x4a\xa0\x2e\xc1\x8e\xa3\x7c\x5c\x4b\x3c\x74\x49\x2d\x84\x4a\xc5\x4f\x9f\xa0\x4b\x2f\x20\x51\x58\xe9\xbd\x5d\xad\xd3\x90\x55\x11\x91\x1a\x80\xd0\xa0\x2d\x9a\x8e\xb5\xd6\xb0\xcc\x79\xbf\xf4\x6e\x30\x8a\xe2\x05\x6b\x82\xe7\x07\xaa\x4a\x27\x2d\x14\x5f\x70\x8d\xdd\x20\xdc\x40\x21\xe5\xf2\x58\x3d\xe1\x39\x1f\xb3\x8f\x68\x08\x70\x8d\x30\x3a\xec\xc8\x81\x82\x44\x59\x20\x41\x00\xf1\x81\x22\xf2\xb4\xa1\xda\x97\xf0\x3c\xb0\x0e\x28\x57\xcd\x2f\x18\x24\x68\x63\x9d\x81\x2a\x1f\x54\x0f\xb0\x37\x20\x2b\x17\xb6\x8b\xd2\x61\x8a\x41\x52\x3c\x5c\x3e\x15\x0a\x71\xe8\xc0\xbc\xa5\xab\x02\x35\xee\x27\xc1\x34\xd5\x28\x8d\x55\x46\xb0\x7c\x54\xe4\x8c\x9a\x5e\x7d\xf4\x54\x35\x4b\xea\xc8\x01\x34\x03\x88\x1e\xc2\x2d\xff\x10\x6e\xcd\x3b\x84\x5b\xea\x10\xba\xdc\xf7\x0e\x6b\x4f\xac\xec\xc5\x23\x02\x6d\x3c\x8e\xf6\x86\x76\xa7\xb0\xa6\xb6\x42\x21\x57\x7d\xec\x3c\x38\xed\x1c\x9e\xaa\x17\xde\x36\x2a\xdb\xd4\x7c\xbb\x8a\x64\x3e\xdc\x25\xe3\xf8\xd6\xb6\xb3\x75\xd0\x00\x66\x61\x35\x40\x60\x5b\x09\x86\x19\xa9\x85\xea\xf8\xf9\xd5\x60\x4b\x55\x6d\x72\x92\x5e\x41\x52\x19\xb4\x85\x28\xd5\x86\xf6\x80\xa3\x2a\x50\xef\x73\xc3\x07\x91\x46\xc9\xe7\xc7\xc7\xf0\xde\x7d\x21\xfa\x29\x47\xb5\xd5\x35\x5a\x07\x16\x28\xc4\x29\xa6\x29\x10\xf1\xb3\xba\x97\xf1\x19\x93\x59\xcd\xcb\x4c\xf7\x61\xee\x0e\x7e\x99\x14\xac\xc3\xce\x2e\xf1\xee\xb8\x3a\xf3\xd0\xd8\xdc\x1b\x66\x72\x88\xc9\xe6\x17\x24\x64\xf3\x2e\x43\x05\x0d\x70\xda\xbb\x4b\x9e\x61\xfd\xe3\xe4\x57\x61\x13\xbd\xa8\x9a\xfe\xad\xb2\xa7\x30\x5a\x8d\x06\xc8\xf0\x25\x90\x7d\x20\xf1\x8a\xe2\x9f\xc0\x55\xe1\x2a\x3f\xd3\xb7\xc4\x1e\xd6\xc6\x7a\x4f\x59\xe3\x48\x6d\x27\xb4\x78\x86\x66\x52\xd4\x98\x6f\xc2\xf3\x42\xbc\x4c\x25\x2f\xf5\x30\xde\x37\x70\x2a\x0d\xf6\x50\x43\x7b\xc8\x1a\x3f\x27\x83\x72\xd4\x38\x6d\xb3\xcd\x8d\x16\x7b\xb8\xb8\xd1\xb3\xb0\x11\x7d\x28\x9e\x88\x34\x2d\x0c\x0d\x51\x8c\x68\x3e\xcd\xc0\x28\xe7\x00\x92\x87\x8b\x92\xed\x5f\x4e\x52\x99\x8b\x9c\x6d\x6e\x2c\x8f\x28\x55\xad\x56\x52\x1c\xec\x03\x04\x63\x04\xa0\x7e\x46\xd2\xbe\x60\xc1\x5f\x37\x23\xfe\x90\xc8\xa0\x62\x3b\x4a\x34\x2c\x03\x6b\x60\x3a\x7d\x3b\x9f\x4c\x7e\x42\x7d\xa7\x95\xe6\x34\xde\x1c\x1f\xec\xb3\xcd\x8d\x86\x91\xe0\x04\xa2\x0b\x84\x82\xc1\x20\x3c\x86\x43\x61\x87\xda\xff\xb6\x96\xb5\xab\x4b\xb0\x6d\xd5\x5c\x68\xf1\x4a\x63\x4a\xbc\xe1\xe5\xa8\x3b\xe6\x97\x4d\x55\xfd\x7d\x03\xdf\xb5\x6a\x53\x14\x90\x53\x84\xf2\x5e\xb3\x0a\xe4\xb3\x02\xfb\xbe\xd1\x4f\x13\x91\x95\x95\xcf\x15\x20\xf8\xb9\x02\xc4\xac\x62\xb3\xc5\x9e\xc6\x9b\xb2\x87\xfe\xd0\xdf\x37\xc6\x3c\x3f\x4f\x32\xc8\x4a\xe5\xd0\xfc\x95\x40\x84\x7d\x8a\x28\xae\x10\x17\x70\xb9\x75\x03\x00\x1a\xe3\x15\x0c\x3c\x06\x2d\x45\xe0\x35\x3e\xd2\xa5\xfe\x19\x94\xd9\x6a\xc1\x8b\xa6\x3b\x83\x6a\xbd\xe8\x4b\xce\x08\xf9\x09\x0f\x34\xef\xe5\x6c\x8c\x9e\xed\x80\x41\x85\x6e\x97\x09\xc5\x78\xbe\x46\x4e\x41\xf5\xac\x6d\x11\xcf\x46\x30\xa5\x6d\x8b\x14\x66\x8e\xf3\x10\xa3\xad\x8d\x22\x06\xe5\x88\x34\xc4\x53\x39\xaf\x9d\x67\x06\xe0\x47\x03\xf1\x4e\x48\x5d\x28\x21\x23\xa3\x58\x26\x98\x10\x5a\x9a\xdc\x34\xa0\x10\xbe\x4c\xf4\x29\x9e\x13\x45\x8e\x86\x46\x59\x18\x47\x0e\x86\xb4\x6c\x2c\x39\x62\xdd\x1e\x8f\x28\xa7\x2b\xdc\x30\xae\x5c\xb5\x75\x2c\xba\x1c\xb1\x46\x5f\x3d\xc6\x9c\x6e\x7c\xf3\x48\x73\xce\x76\x64\x2d\x66\xee\xb2\x64\xc8\x39\x2b\x0e\xb8\x6d\xd8\x39\x0b\xe8\xa6\xa1\xe7\xe8\x1b\x83\x86\x9f\xd3\xc7\x02\x3c\x5b\xd4\x7f\xb8\xe7\x74\xb9\x3c\xb4\xab\x46\x46\xd3\xe7\xc2\x8b\x8d\xb6\x56\xbf\xf6\x24\x3e\x9a\xc5\x32\x12\x25\x4d\x7f\xab\xc4\x4a\x33\x96\x4d\xd5\x88\x69\xba\xc4\x0f\xa0\x44\xcd\x9c\xa8\xd0\xa0\x12\x41\x2d\x54\x02\xf4\xfe\xe3\x82\x17\xad\x18\xc4\x72\x8d\xad\x14\xc6\xd2\xbd\x1f\xa3\xa1\x2c\x83\x90\x44\x61\x3c\x4b\x72\x38\x6e\x12\xd5\xd2\xf9\x0a\xd6\x46\xb7\xac\xba\x0b\x92\x75\xd2\x31\xd9\x60\xa9\x8c\x00\xc5\x93\x91\xe8\xd0\x06\x6d\x76\x2e\x32\x91\xa3\xb9\x35\x93\xd3\x72\x32\x2d\x59\x91\x8c\x93\x94\xe7\x5a\x8f\xfe\x4c\x4e\xb3\x41\x92\x9d\x3f\x87\x7b\xfa\x68\xa5\x97\xa6\x13\x90\x98\x57\x98\xee\xd7\x67\x9d\x4c\xa1\xeb\x82\xa5\xc9\x07\xa1\xc7\x53\x11\x88\xb8\x6a\x4d\x13\xd6\x87\x72\x23\x9e\xd7\x8e\x9d\xa7\x16\x4a\xe1\x7d\x66\x02\x3b\xe0\xc3\xc4\xfe\x84\x4b\x0b\x11\x16\x5f\x36\xae\x26\xbc\x86\xec\x2f\xbc\x17\xd7\x10\x85\x7d\x83\xa0\x9e\x5e\x2e\x86\x7c\x8d\x7e\x62\x0e\x6f\xf9\x0e\x89\x3d\xb9\xa3\xaf\x5c\xd2\x6b\x65\xdd\xaa\x3b\x59\x15\x2a\xc1\x70\x6d\xc6\xf7\xf5\x75\x06\x8c\xe6\xe6\x06\x7b\x79\xf0\xaf\x6d\xf6\x2e\x15\xbc\x10\x6d\x36\x90\x59\xa3\x64\xbc\xf8\xd0\xf6\xe4\x16\xa0\x42\xc0\x66\x7d\x09\x12\xcb\x1c\xad\xe8\x5e\x1c\xbe\xc1\xd3\x31\x16\xac\x9f\xe4\xfd\xe9\x18\x6f\xe6\x02\x55\x92\x46\x7d\x81\x2a\x88\x5c\x60\xda\xef\x04\x4c\xd4\x32\x1c\x01\x48\xe8\xcb\xa4\x97\xa4\x49\x79\xa5\x1e\x85\xf0\xdc\x39\xd8\xdf\xdc\xf4\xd8\x65\xc5\xe0\xd8\xfb\x3d\xbf\x22\x92\xdb\x3e\x95\xfb\xc4\x17\xc3\x73\x35\x5c\xfa\xfd\xed\x37\x58\xea\x0d\x6e\x46\x54\x79\x63\x7b\x85\xd5\x57\xb3\x57\x1c\x79\x7b\x7b\xe5\x91\xe7\xb4\xbe\x34\x59\x9f\xa3\x15\x4b\xae\xf8\xa6\xeb\xaa\xe0\x76\xd9\xb5\xb2\xc1\xb5\x73\x7c\x07\x1b\x57\x48\x0c\x58\x62\x27\x81\x27\x0a\xe2\x99\x98\x59\x7b\x4c\x22\x19\x6e\x27\x6c\x65\x38\x50\x3a\xe5\x8e\x05\x63\x23\x90\xaf\xaf\x3b\x49\x06\xce\xb7\x07\xcf\xd3\x5f\x05\x8a\xa2\xd4\x5f\x85\x7d\xb4\xfe\x0a\xde\x57\x73\x6c\xb0\xd8\xd3\x2a\x73\xbe\xad\x2d\x0b\x15\x08\x18\x38\xbc\x7b\x7f\x15\x9a\x6c\x50\xfb\x2b\x3c\x84\x3f\x9b\xcf\xb8\x3a\x64\x86\xf0\x33\xd5\x1b\x02\x4c\x3d\xcc\xd2\x02\xd4\x3f\x2b\x10\x5f\xd9\xef\x1a\x06\x59\x10\xf8\x5d\x2a\x1c\x30\x30\x65\x9e\xfc\x7a\x6c\xd7\x62\x37\xb0\xba\xc0\xd1\x75\x70\x2a\x66\x1c\x17\x22\x2f\xeb\x9b\xe8\xee\x3b\x7a\xb8\x66\xe1\x93\xa1\xba\x3b\x46\x57\x13\x59\x8e\x44\x99\xf4\x79\x4a\xb6\x20\x29\xb4\x54\x46\x0c\xda\xa0\xc5\x9b\x16\x25\xeb\x69\x45\x5e\x52\x36\x0a\x88\xf9\xc8\xd9\x19\xbe\xe4\xcf\x10\xa4\x51\xf7\x95\x4e\xa9\x69\x9d\x39\x78\x0a\xb7\xee\x44\xe4\x43\x99\x8f\x81\xd1\x47\x25\x65\xa1\x29\x41\x30\xf1\x4f\x9f\xfc\x69\x79\x57\x3b\x88\x11\x96\xb1\x6e\xc2\xa3\x13\x80\xee\xec\xd6\xc9\x54\x1a\x97\xe6\xa4\xfb\x4b\x3a\xa7\xc5\x55\xc3\x78\x78\xea\xcd\x44\xb4\xea\xec\x06\xbd\xee\xd0\x3a\x1a\x53\x3a\xbb\x7e\x3f\x11\xfb\x24\x72\x76\xb1\x6d\xf5\x31\x8a\x0a\x1a\x55\xe5\x48\xa4\xbc\x4c\x2e\xc4\x89\xdc\xcb\x7b\x49\x99\xf3\xfc\x0a\x2c\x99\xac\xc3\xbc\x56\x5a\xbb\x7b\xc3\x4a\x24\x1c\x1d\xde\xb1\x45\xea\x4c\xa9\xd7\x89\x6f\x57\x42\xce\x9b\x7d\xb5\x6a\xf8\x47\x48\x82\xe2\xa4\xc7\x73\x15\x05\xef\x6c\x80\x3b\xb7\xcd\xc4\xd9\x94\x38\x5a\x6d\x4d\x93\x42\xf3\x2d\xd2\xc3\xda\xb2\x88\x12\xf4\x80\xe8\x7c\x22\x27\x3f\x6b\x52\x51\x11\x5e\x75\xfd\x2a\x5a\x5e\x45\x5b\x2b\x92\xbd\xa8\xb9\xad\xa3\xdb\x7b\xb6\x57\xc6\xf8\xd6\xad\xc3\x47\x47\x8a\xe9\x5a\xc3\x45\xd4\x21\x0b\xa9\x3f\x04\x43\x24\xc4\xdd\x6b\x0d\x37\x95\xd7\x5c\x7f\x09\xc7\x48\xa9\xbe\x07\x81\x70\x5e\x86\xe2\x7b\xe5\x1e\xc3\xc5\x2c\x1f\x86\x72\x18\xbc\xa4\x37\xaa\x05\xfa\x32\xde\x30\x94\xea\xd8\x5c\x11\x58\x0c\x12\xe2\x40\x7e\x62\x4d\x24\x80\x36\x61\x48\x91\x69\x21\x06\x8c\x17\xd6\x50\x43\x53\xa8\x81\x44\xfa\x24\xb3\xf4\x8a\xc9\x8c\x01\x96\xf7\x44\x9f\x4f\x4d\x73\xb0\x4a\x51\xa5\x9e\x69\x42\x4f\x8c\xf8\x05\xdc\x46\xeb\xeb\x6c\x90\x0c\xc1\x91\xb1\x4c\xaf\xd8\x6c\x24\x32\x3b\x34\xf0\x09\x9c\x4c\xd2\x04\xcd\x38\x92\xb2\x8b\xaa\x0b\x52\x4c\xdc\xd1\x10\x58\x09\x12\xe1\x4b\x23\x08\x0e\xa6\xd6\x36\x8a\x51\x09\x21\x78\xd5\x2c\x81\xfa\x1a\xa3\xb0\xfb\xfa\x0c\x3f\x78\xa0\x8f\x2c\xa5\x94\x74\xa5\xab\xb8\x68\x4b\x2d\x16\xd3\x56\x7a\x1b\xea\x9a\xa9\x62\x87\xbd\xcc\x63\xb9\x3b\xbb\xe1\x49\xea\xb8\xa1\xec\x78\xd5\xcd\x5d\xb8\x7c\x0b\x44\xd2\xdd\xca\x69\xeb\x90\x71\xfb\x2d\x72\x43\x6d\xe7\x37\x81\x36\xeb\xeb\x6c\xaf\x2c\x79\x7f\x44\xd6\x8e\x67\x03\xba\x26\x16\x59\x62\xac\x31\x5e\x82\x57\x60\xca\xa3\xb6\x6d\xec\x8d\x84\xee\x47\xcd\xf4\xbc\xc5\xf7\x67\x74\xbd\xe6\x0b\x99\x9f\x1a\xda\x6c\xcd\x25\x28\x85\x54\xbc\x8f\xb6\xaa\x52\x24\xdb\x23\x9e\x0f\x1e\x78\xbf\x1d\x71\xbf\x5f\x31\xa2\x73\x34\xc9\xd7\xae\xd9\x27\xda\x64\x9e\xe1\x5f\x51\xb9\xae\x7e\x4a\xc4\x6c\x22\xf3\x9a\x6b\xab\xa4\xf7\x56\xe5\x99\xb3\xaa\x26\x19\x99\x5c\x84\x8e\xfd\x21\x69\x5d\x7c\x65\x5a\xfe\x5f\x8b\x58\x7d\x06\xd2\x4a\xce\x55\x29\xe5\x1b\xdb\xc6\xcf\x09\xbc\xf7\x2d\x2b\xe9\xae\x08\xcb\x32\xc6\x40\x20\xa7\xe6\xc3\x70\xcc\x23\xb9\x27\xe2\xaf\x1c\x6f\xa8\x35\xef\x1a\x14\xe1\xda\x47\x8d\x77\xef\xd8\x87\x00\x5c\x34\xae\x8f\x4e\xb0\x86\xfa\x55\x1d\x7c\x74\xc4\x84\xdc\x37\x64\x14\x15\x28\xfa\x15\x1f\x05\xf3\xda\xbe\x24\xf4\xb5\x13\xb9\x69\xdc\xe5\xb2\x53\xcb\x33\xe1\xc4\xbc\xd7\x7e\xc4\xb3\xca\x3d\x84\xd9\x30\xb9\x14\x03\x26\x73\x62\xbd\xc3\xf5\x47\x6b\xf0\x77\xd7\x56\x28\xce\xc0\x70\x5a\x94\x72\xfc\xdc\x59\x88\xcd\x77\xbf\x62\xdf\x24\xc5\x4b\x35\xb4\xa7\xdf\x54\x3c\xaf\xd4\xe7\x15\xed\x69\x6f\x6a\xe2\x11\xb3\xb2\x55\x90\x16\x7b\x32\x55\xec\x8d\x61\xa1\x43\xc0\x46\xf0\xec\xa9\xc0\x70\x82\x4b\x18\xec\x9b\xde\xf5\x2d\x6b\x62\xb5\xa0\x07\x7d\x01\xa4\xdd\xd9\x6d\x8f\x6f\x27\xe1\xc1\x80\x07\xb5\xc5\x36\xf8\x01\xad\x61\x14\xc4\x13\x3e\x50\xcc\x6f\x6d\x63\x37\xf4\x7d\x6b\xba\x61\xfe\x02\x4e\x07\x14\xe9\xc3\x24\x13\xc1\x4c\x6b\x64\x76\x52\xe6\x83\x24\xe3\xa5\xf3\xef\xf7\x9a\x44\x44\x50\x50\xd4\xd4\x11\x7f\xdd\x64\xda\x66\xe8\xed\xea\x18\x97\x74\x39\x20\xdb\xb2\x6b\x42\xa8\x6e\x98\x00\xaa\x1b\xcc\xbe\xdf\x03\xd7\x84\x1a\x1b\xb5\xca\x08\x5b\x86\x91\x7c\xc5\xb3\x41\x2a\xd8\x85\xbe\x81\x8c\x39\xbe\x42\xd6\xea\xf2\x02\x42\x9a\xaa\x16\x27\xbd\xa1\xae\x76\x9b\x55\xcd\xe4\xa9\xf8\xc6\x0d\x8f\xf2\x79\x3d\xae\xb6\x56\xa2\x28\x4e\xd0\xed\xe6\x85\xb7\x61\x2c\x5c\x49\x1d\xd3\x1d\xcc\x88\x37\x9c\x9e\xa3\x66\x9e\x94\x19\x20\x71\x88\x2a\xe0\xe6\x7b\xcc\xb8\x15\xf7\xa2\x5f\xfa\x50\xba\x73\x0c\xf6\xa3\x7d\xea\xe8\x51\x4b\x98\x8d\x59\xb1\x3a\x2e\xec\x9c\xf9\xe2\x0d\x3b\x6f\xa6\xcb\xf7\x1a\x04\x61\xaa\x40\xaa\x0c\xc1\xb3\x38\xad\x3c\xfb\x16\xf3\x26\x7e\x0f\x6d\x16\x20\x96\x41\xa7\x03\x63\x35\x3e\x84\x37\x0e\xc8\x71\x80\x2b\xe5\xee\xf9\xa2\x95\xb9\xdc\x46\xc1\x5e\xb8\x5f\x28\x68\x7b\xf0\x80\xdd\x37\x44\xd8\xeb\x3e\x88\x64\xe8\x8b\xe3\x70\x82\x9e\x7c\x8e\x06\x13\xb3\xbc\x51\xd0\x4c\x3f\x23\x69\x55\xc3\x88\x85\x35\xb5\x58\xac\xb2\x15\x46\x64\xeb\x3d\x52\xaa\x5c\xf9\x4e\xb5\xa1\x7e\x9f\xec\x9a\xd1\x3d\xa4\x30\x22\xf5\x8d\xf8\xd7\x7f\xad\x44\xb8\xfb\x48\xdb\x5c\xcf\x1f\x67\xf7\xd0\x83\x11\xc5\xb5\xf5\x75\xb4\xf8\x4f\x53\xf2\x42\x24\xa4\xa2\x68\x9b\xb7\x2e\x78\x8d\x9f\x4b\x39\xa8\xf4\x6a\x3d\xb6\x8a\x40\x39\xab\x5e\x42\x83\x81\xa1\xee\x8a\xc6\x44\xa6\xa9\x4b\x77\xd6\x62\xab\x1d\x2f\xb4\xaf\xb1\x78\xb1\x7b\x10\xda\x72\x77\xf1\xbb\x7a\x95\x77\xc5\x5e\x2e\x38\xa4\xd7\x70\xec\x8e\xc5\x92\x5c\x0c\xa9\xac\x82\xa2\x9a\x2a\x22\x82\x51\xdd\x0f\xb6\xfc\xd6\x8a\x4c\x1d\x3f\xa1\x38\x80\xa4\xbc\xb2\x77\x6e\x99\xf3\xac\x18\xca\x1c\xed\x26\xcf\xf8\xb4\x94\x67\x24\x6e\xa6\x76\x64\x71\x1f\x66\x49\x39\x62\x63\x99\x03\x13\xc0\x2f\x78\x92\x82\x7e\xbd\x98\xf0\xbe\xe8\xde\x46\x45\x07\x71\xd7\xd1\xbc\x0c\xfe\xd4\x36\xa1\x46\x51\x38\x60\xbd\x2b\x13\xb1\x95\xf4\x10\x51\xf5\x4d\xd0\xc1\xb4\xc3\xde\xd8\x18\x9d\x56\x3f\x0c\x8b\xad\x78\x26\x5d\x2b\xce\x5c\x04\x63\x30\x2e\xeb\xe9\x95\x31\x0b\x1c\xf8\x1c\x86\xb6\x28\xd9\x9b\x96\xd2\x45\x90\x74\x71\x46\xd5\x4d\x7e\x84\x70\xaa\xcc\x47\x0d\xcf\x81\x02\x46\xc0\x9f\xb8\x9d\xe7\x63\xdf\xce\xf3\xf1\x3c\x3b\xcf\xc7\x60\x06\x64\xad\xa0\xed\xc8\x9c\xc9\x96\xda\x76\xcd\xc4\x76\x42\xc7\x7b\x5b\xdd\xd3\xbd\x84\x8c\xc4\x8d\x59\xac\x9d\x35\xa2\x03\x2c\xfc\x37\x9c\xa1\x13\xfa\x11\x45\x4e\x59\xe4\x34\x6c\x9b\x75\xb6\x52\x44\x7a\x9e\x91\x36\xb4\xa9\x3a\xb6\x1e\xba\xd3\x99\x20\xc0\x9c\xd2\x6f\xd3\x1b\xa9\x6f\x9f\x72\xb6\x0b\xa3\xc8\x5d\x71\x06\x11\x3a\x62\x07\x81\x1f\x68\x27\xc8\x60\x06\x5d\x98\xea\x56\x16\xea\xd1\xbc\x25\x27\x61\x5f\xa5\x68\x89\x90\x97\x62\xa0\xe8\x13\xb1\x79\x80\x1c\x37\xb0\x65\x73\x92\xdb\xd4\x25\xb1\x80\xc8\xc2\x1f\xc4\x95\x9e\x0c\x6e\x3d\xd8\x17\x38\xfb\x0f\x9e\x0b\xbe\x6d\x09\xa3\xab\xd1\xa2\x46\x1c\xad\xae\x1a\x1c\xe9\x9c\xb7\x59\x2f\xe8\xbd\xd7\x55\xa0\x58\x87\x71\xf8\x63\x67\xcd\x46\xb5\x54\x93\x1b\x26\x69\x29\x72\x37\x3d\x32\xd9\x2e\x96\x11\xe8\x8a\xda\x6e\x51\xf9\x24\xa5\xd0\x5b\xfe\x96\x06\x44\x7a\xcb\x52\x69\x32\x34\x6c\xfe\x0f\xcb\xad\x51\x0d\xde\x83\x07\x06\x40\x58\xfe\xca\x02\x22\xf3\x30\x56\x6d\x5e\x72\x0f\x3a\x37\x47\x3a\x36\xd8\x53\xbf\xe8\xfd\xc6\xa9\xda\x4f\xb6\x4d\x67\xaf\x3f\xda\x0e\xac\xef\xbe\x62\x2e\x2d\x05\x29\x26\x69\x52\x36\x1b\x9d\x46\xeb\xfd\xe6\x29\xbd\x81\xaa\xe3\x79\x08\x26\x2b\x1a\xc6\x53\xd6\xe8\x34\xd8\x43\x02\x75\x9b\x35\x1a\x15\xb3\x06\xc3\x59\xea\x6b\xa8\x12\x7e\xef\xc6\xde\x07\x90\x0e\x83\x16\x04\x8f\x60\xd6\x21\x89\x72\x62\xe6\xd3\xd5\x57\xb1\x6e\x52\x19\x23\x06\xd0\xd3\x90\xc0\xd1\xba\x27\xac\xd4\x08\x67\x96\x14\xad\xf8\x4d\xb4\x97\x99\x7b\x50\x8b\x48\xd5\x7d\xe0\xbc\x4e\x0b\xed\x8a\x65\xa0\x12\xc9\xbd\xeb\xb3\xea\x2d\x6b\x46\x68\xf2\x34\xc1\x62\x44\x6e\x27\x12\xd0\xaa\xf2\x4c\x5d\xed\xfd\x5a\xf5\x4c\x9b\xf7\x40\x20\x17\x47\xb5\xe3\x0a\x8e\xc0\x72\x4c\x4b\x61\x54\xec\x51\xe7\x2c\xcd\xe5\xa3\x6e\xfe\xa1\xd1\x67\xdc\x9d\x4f\x56\x65\xe7\xaa\xdb\x86\x87\x5d\x31\x1f\xfa\x5c\x4f\xac\x81\x5e\x35\xfe\x81\x9a\x0f\x3e\x31\xaa\xfe\x1f\x44\x29\x18\x0d\x70\x63\x65\xa8\x97\xf3\xb5\x26\x51\xe3\x76\x5d\x8c\xa6\xc4\x16\xd2\xd5\x02\x45\xca\x3c\x50\x60\x8a\xdc\xda\x89\xdb\x6c\xe8\x4b\x2b\x66\x24\xf0\x90\x5d\xf9\x02\xd3\xa8\x59\xc0\x43\x76\xb9\xa6\xc3\x82\x5b\x3f\x0d\xd5\x43\x14\x4b\x26\x20\xb0\xa3\xec\xac\x87\x2c\xe0\xd1\xb8\x3a\x42\xd8\x80\x48\x06\xaa\x8f\x11\xa6\x78\x98\x26\x93\x89\x18\x78\xd5\x82\x5d\xd7\xe3\x8b\x30\x91\x44\x87\xc0\x8b\x11\x88\x99\xf0\xf6\x6f\xe4\xda\x34\x5a\x33\x35\x28\x1a\x6f\x5b\x06\x04\x2c\x86\xda\xc8\x4e\x99\xc8\xb1\xde\x72\x39\x5a\x9e\x0b\xf8\xbb\xb9\xae\x40\x7c\x02\x78\x9f\xb0\xc5\xa7\x52\x4e\xd6\xcf\xdb\xc4\xbc\x71\xcc\xcb\xfe\xc8\x79\x06\x68\x58\x6a\x6c\xef\x75\xd1\xe9\x4e\xd4\x50\x2d\xa0\xe8\x44\xe4\x78\x13\x32\x6e\xf3\x6a\x75\x20\x24\x96\xfd\xa9\x40\xbf\x23\x14\xf7\x5c\x94\x86\x38\x2e\x90\x7e\x2e\x24\xfc\xce\xb1\xcb\xa7\xa2\x15\xf2\x6f\x66\xba\x3c\xf9\x0f\x3c\x73\x1c\x96\x76\xa8\x77\xee\x05\x4f\x93\x01\x45\xe1\x79\x4f\x19\xec\xd7\x0d\xf1\xb3\x5c\x28\xef\x68\x27\x55\xfa\x7f\x68\x35\x6d\x3e\x36\xd3\xec\x0c\x51\x8e\x62\xe3\x94\x7a\xa2\xeb\x25\x84\x88\x14\xd4\xb0\xca\x44\x06\x37\x76\x18\x84\x76\x4e\x48\x22\x4f\x23\x0e\xd0\x28\xd2\xae\xd2\xe3\x52\x32\x39\x75\xd2\x2c\xe3\xa0\x47\x3a\x71\x89\x20\x3d\xea\xe5\x46\x10\xb3\x28\x20\xa5\x81\xca\x67\x7d\x9d\x0d\xc4\x44\xa0\xe1\x66\xef\x8a\x22\x1e\x79\x70\x0b\x36\xe2\x88\x29\x9a\xa7\x62\x89\x1a\x9d\x1e\x4a\x91\x2a\x90\xe9\x15\x55\xe9\x3b\x0b\x18\x99\x27\xbf\x42\x9c\x4e\x43\x25\x90\x3c\xb8\xd0\x2b\x64\x4b\x9c\xb3\x0e\xea\xd0\x93\x4c\x3b\xe3\x1a\x38\x4f\xb5\x37\xae\x21\x32\x56\x55\x27\xfa\x52\x3d\x22\xae\xaa\xf5\x53\xe3\xbe\x55\x12\xf7\xad\xb1\xe0\xc5\x34\x37\x3b\x4f\x6a\x8f\x84\x75\xde\x82\x75\xac\xf6\xf0\xc6\x6b\x7a\x7f\x7e\x5b\x1b\x2e\x5d\x6f\xdb\x7b\x33\xa7\x53\xb6\x5b\xc1\x4e\x52\xf8\x30\x52\xe8\xfa\x3d\x65\xeb\x6c\x8b\x75\xc8\xb6\x56\x4a\x77\xc2\x87\x36\x2a\xb0\xe9\x32\x19\xc2\xe9\x0f\xd0\xab\x12\x1d\x65\x50\xc3\x1b\x46\x6c\x95\x4e\x2b\x82\xfa\x55\x7b\x8c\xde\x4b\xfe\x5c\x2a\x2e\xc8\x5e\x1f\xf4\x06\x78\x93\x8c\x93\x3e\x5a\xa8\x9c\x29\xf6\xf1\x4c\xcb\x72\x14\x6d\x83\xf4\xb9\x37\x0a\x07\xa9\x1a\x5e\x33\x9e\xe7\x7e\x81\xe2\xaf\xfc\x2f\x60\xdc\xef\x11\x4a\x38\x07\x4c\xe6\xac\xb3\x59\x0d\x85\xd2\xe4\x79\xde\x46\x43\x40\xab\x09\x9a\x16\x82\x65\x48\xbb\x21\x16\x42\x32\x34\xa1\x32\x21\xf1\x8f\xda\x76\x18\x0f\x31\xbc\x57\xf5\x82\x8b\x92\xe7\x39\x7c\x6e\x22\x70\x1a\x87\x41\x75\x70\x86\xcf\xb3\x33\x20\x49\x10\xc6\x1b\xbd\x8d\xf9\x58\xa0\x1d\x4f\x22\x73\x70\xff\x84\x35\x5c\x0b\xc0\xc2\xa3\x15\x01\x03\x09\x0d\xa3\x7f\x01\x2c\x3d\x71\xbc\x52\xe0\xca\x56\x44\x68\x55\x9f\xee\x2f\xb0\x09\x07\xaa\x10\x77\x42\xc1\xf2\x3c\x4c\xaa\xfb\x01\xb5\x97\xdd\x14\xa8\x5c\xb3\x33\xd8\xad\x63\x78\xfa\xd3\xbc\x1a\x91\x63\x9a\x43\xb0\xc8\x53\x38\xdf\xd6\x73\xc4\x4a\x27\xfc\x1d\x55\xd8\xfe\x90\x9d\x69\xca\x7b\xa6\x46\x75\x66\x7b\x3a\xd3\x56\xe8\x74\xd8\x48\x86\xcb\xfe\x48\xbf\xb5\x70\x11\x3c\xa7\x9b\x60\xf0\xb2\xf7\x9f\xd8\x80\xae\xe9\x0b\x4c\x4d\xd0\x50\x7f\x80\xee\xb1\x68\xaf\xa5\x9c\xb0\x32\x97\xd3\xf3\x11\x60\x46\x9a\x60\x48\x4b\x97\xef\x08\x34\xce\x53\x54\x37\x83\x6b\x4f\x3e\x80\x0c\xaa\xdf\x32\xc1\xfb\x23\x8d\x51\x63\x1d\x1c\x71\xa4\x9e\x60\x83\x04\xd9\x6f\x22\x52\x5d\x41\x52\xac\x99\x22\xd5\x98\x8a\x8a\x69\x99\xc6\x3d\x92\xf9\xab\xca\x4c\x81\xc7\x4e\x87\x1d\x4e\xb4\x31\xaf\x75\x46\xcf\xd4\xa1\x32\x2a\xc9\xa2\x74\xfc\xa8\xe5\xa5\x48\xd7\x3e\x7a\xe6\xd3\xcc\xca\x98\x9b\x24\xf9\x9b\x6a\xd0\x86\x1e\x1d\xdb\x6e\x8b\x4f\xe4\xd1\x34\x63\xbb\x38\xa0\xdd\x40\x66\xeb\x96\x99\x24\x32\xeb\x16\x69\xd2\x17\xcd\x8d\x36\x39\x0f\xa4\xb7\x86\x9a\x41\x43\xf7\x87\xbc\x8e\xdf\x59\x77\x28\xf3\x7d\xde\x1f\x11\x6c\x36\x15\xa8\x2f\x9a\xf9\xf6\xde\xe5\x2a\x3a\x6d\x51\x55\x8d\x28\xd2\x24\x2b\x3b\x83\xa4\xe0\xbd\x54\x74\xd2\x24\x13\x6c\x20\xcb\x4e\x26\x89\x02\x0e\x9c\xb1\x0a\x99\x8a\xee\x8c\xe7\x59\xb3\x71\x66\xc0\x76\x0d\xd4\x33\xb4\xce\x9e\xe4\xa2\x8f\x69\x89\xe1\x7c\xb8\x6a\xd9\xd9\xfd\x06\x71\xb4\xd3\x62\x3a\xb5\x64\xb1\x11\xb2\x4f\x9f\x18\x69\xbb\xb3\xf4\x40\xe9\x94\xbb\x3a\x2d\x1f\x1a\x21\xba\xb0\xbf\x59\xcb\x5b\x00\xe0\x1f\xed\xa3\x1d\x88\xb3\x7b\xcd\x68\xcb\x71\x31\x86\x74\x0b\xe3\x49\x2a\x4a\xa1\xfd\x62\x8e\x68\xbc\x07\x03\x8c\x98\x72\xf6\xc4\x50\xe6\x02\xcf\x8f\xc5\x4b\x2f\x2d\x1d\x70\x86\xb9\xb8\x48\xe4\x14\xb5\x61\x03\x29\xb4\xd7\x8b\x06\x37\x16\x45\x81\xca\x99\x72\x24\x0a\x61\x43\x52\xc0\x7f\x91\x9c\xc7\x15\x1b\xdd\x48\x1d\xab\x05\xf7\xca\xdc\x0b\x67\x2e\x88\xc0\x7c\xc1\x80\x51\xb4\x0c\x53\x70\xb7\xed\x5c\xa9\x5b\xa5\xe7\x0e\x8c\xe9\xad\x89\xf2\x0a\xf4\x3f\x3a\xfc\xae\x79\xeb\xe9\x3b\xcc\x3c\x3b\x90\x49\x36\xcf\x9a\x4c\xcc\xec\x26\x41\xae\x8b\xc9\x24\xbd\xd2\x76\x2a\xa6\x1c\xa4\x15\xdd\xbf\xf7\x72\xb6\xfe\x0f\xf5\xfd\x1d\x0c\x9d\x9d\xf9\xf9\x9e\xce\x20\x3c\x27\x3b\x9b\xea\x5f\xc6\x8a\x52\x0e\x63\x4e\x01\x8b\x08\x9c\x4f\x48\xa6\x3a\x2b\xa0\xb9\xd4\x92\xa1\x79\x07\xc0\x51\x81\x54\x7d\xea\xa4\xa0\x03\x94\xee\x0e\x02\xa5\x0d\xa7\x39\x28\x4d\xa7\x26\x27\x95\xcd\x00\x88\x09\x85\x93\xe2\x85\x69\xee\xdf\x15\x9e\x32\x47\x6f\x8c\xa6\x05\xda\x7f\x19\xb3\x61\xe1\x5b\x06\x05\x3a\xdb\xec\xa3\xd6\x3c\x70\x9b\xfb\x96\x7e\x2c\x75\x52\x0e\xf2\x4d\x0b\x3d\x74\x98\x91\x36\xb5\xc8\xdc\xd6\x4e\x40\xe6\x29\x64\x5e\x37\x55\x01\xaa\xf5\xde\x9b\x8b\x88\x15\xb1\xa6\x5b\x06\x93\xa5\x53\xa3\x08\xfc\xa8\x9a\xd7\x98\x01\xf0\x69\x29\x49\x2a\x4a\x75\x29\xe4\x54\x66\xa4\xed\xea\x82\x2b\xad\x8d\x40\x1c\x05\xb7\x6f\x68\x1d\x92\x1c\xee\xc1\x33\x0b\x06\x18\x00\x0c\x98\x87\x2d\xd1\x94\x6b\x88\x47\x5f\xe6\xc9\x79\x92\xf1\xf4\x1d\xd5\xc4\x7e\xc8\xe4\x0c\x1f\xeb\xba\xd4\xf0\x52\x2c\x48\xc5\xbd\x1b\x57\x49\xc2\xbc\xb5\xb8\x80\xe4\x41\xac\x59\xd5\xb9\x8b\xa6\x7f\x1b\x60\xee\xae\x52\x1b\xde\xad\x68\xf9\xe6\x57\xd7\xda\x41\xbb\x11\xb8\xe0\x18\x48\xd9\xc4\x38\x0f\x57\xff\xac\xb2\x42\x67\x16\x3f\x2a\x6b\xb7\x1b\x2c\x50\xb8\xe3\xe4\xe1\x5d\x83\x6b\x94\x68\xfa\xe2\x0e\x6f\x91\xea\x56\xd2\xef\x1e\xe8\x5d\x04\x7c\x97\xa4\x89\x77\xd9\xf1\xcd\x60\x35\xd3\xe5\x25\x38\xd5\x07\xd7\x63\x44\x60\x40\x01\x37\x62\x97\x16\x82\x23\x41\x78\x42\x4b\xc8\x00\x4f\x21\xf2\xc0\x99\xcc\x30\x9f\xc1\x19\xfc\xee\xf1\xfe\x07\xd7\x0a\x8d\x33\x64\x26\x0a\xbf\x85\xa1\x8e\xa4\x05\x98\xf5\x7b\x44\x08\xc1\x0e\x5c\x0c\x84\x6a\x99\xe7\xa2\xef\x61\x8b\x19\x55\x53\xcf\x24\x78\xd0\x06\x75\x75\x86\x55\x57\x97\xdc\x1f\x3a\x66\x8f\xb1\x7d\x80\xf3\xe4\x59\xd2\xda\xdb\x37\x29\x4c\xaa\xde\x15\x58\xd5\x8a\xad\x6b\x68\xd6\x6a\x36\x49\x27\xec\xa2\x5c\x9c\xf9\xd3\xc5\xf5\xd6\x77\x20\x61\x03\xe5\x58\x04\xca\x48\xaa\x8b\xcc\xd0\x30\x16\x2c\x42\xd4\xdf\x24\x87\xae\xcb\x6b\xaa\x0a\x85\x49\x6f\x4c\x5e\x0e\x84\x01\xca\x8c\xad\x14\x1d\x52\x5c\x98\xab\xd9\x12\xb4\x2f\xb6\x4f\x17\x17\x4f\x5f\x81\xba\x95\x44\xdd\x00\x6a\xf6\xf9\x58\xa4\xcf\x79\x21\x5a\x71\xe1\xba\x1d\x45\xa4\x89\x7a\x59\xbe\xe3\x45\x9f\xc3\xaf\x36\x91\xb9\x69\x49\xf1\x85\xc8\x06\x32\xd7\x30\x5a\xd5\x48\x78\x66\x62\xc6\x02\x58\x2d\x48\xd3\x4f\x63\x00\x32\x42\x1c\x03\x24\xc6\xc1\xeb\x8e\x35\xc6\x90\x69\xf5\x67\xd1\xfb\x90\x80\xf8\xed\x8d\xfc\x55\xfd\x73\xd8\x38\xdd\xa1\x61\xef\x74\xb4\xf3\x89\x75\xce\x1f\xf1\x7c\xaf\x6c\x6e\xb4\xba\xa5\xfc\x51\x55\x50\x23\x6f\x82\x96\xc5\x54\xc1\x47\xc1\x26\x9e\xec\x78\x04\x0f\x1c\x8e\x51\xfc\x76\x20\xf4\x80\x1f\x64\x00\xeb\x40\xcf\x58\xd9\x46\xf1\x80\xd4\x3d\xd2\xc4\x41\xd1\xf5\x9e\xb2\x46\x03\xc6\x00\xbf\x1e\x92\xb1\x6f\xdb\x81\x39\x5b\xcd\x20\xb5\x10\xc4\x93\xc1\x2c\x96\xef\x35\xe4\xd3\x30\xdd\x50\xe5\x89\xad\x2b\x52\xd3\x2e\x17\x93\x77\x9a\xa6\x14\x23\x35\xa7\xb3\xbc\x5e\xc1\xdf\x69\x9b\x12\x19\xc6\x10\xe7\xa1\x2c\x91\xd2\x74\x51\x4e\xfb\x23\x30\x58\x03\x7f\x2b\xf5\xa2\x77\xe9\xbe\xcf\x62\xd4\xc4\x3a\xc0\x84\xa4\x20\xa4\xda\x0d\x07\xa8\xd1\xf2\xe8\xa6\xbe\x2b\x72\x31\x96\x17\x62\xcf\xf0\x5c\xcd\xc6\x25\x49\xff\xd9\xda\xa9\xd4\x47\x2e\x37\x45\x87\x8a\x46\xa3\xae\x02\xbd\x82\x6a\x2b\x95\x80\xad\xb5\xe5\xef\x6b\x0f\x4d\xc3\x9a\x9b\x35\x5a\xa7\x16\x04\xf0\xa1\x00\x45\x3f\xd9\xf6\x2f\x44\x56\xbe\x4e\x8a\x52\x64\xea\x46\xb3\xb7\x17\xce\x99\x5e\xd7\xc9\x50\x51\xf3\x9c\x89\xcb\x49\x9a\xf4\x93\xf2\x8a\xf1\xe2\x83\x0e\x24\x0c\x0c\x9a\x48\x05\xbe\x12\xec\x06\x6b\xc1\xbb\x04\x17\x60\x78\x7b\x22\x58\xc7\xd2\x1f\xec\x6f\x6e\x9a\x17\x96\x21\x6b\x2e\x75\x83\x77\xdf\x60\xd3\xc3\x4c\x63\x48\x6c\xa3\x5c\x54\x69\x5d\x1b\x02\x70\x53\xbe\xa1\x15\xb8\x07\x60\xde\xec\x2a\xa9\xd5\x59\xbc\x48\xbe\x3e\xf3\xe0\x5b\xe4\x99\x11\x55\x55\xa3\xe1\xe9\x75\x85\xde\xe1\xf7\xaa\xe2\xd9\xb3\x25\xae\x73\x63\x22\x92\x26\xbf\xfe\x53\x16\xd8\x22\x63\x2a\xca\x9f\x12\x31\x63\xdb\x7a\x6a\xbe\x51\x24\x07\x3f\xb6\x13\x49\x2d\xb6\x7d\x17\xb1\x36\x26\xc0\x6c\x5b\xe6\xa3\xed\xb9\x85\x15\xd4\x51\xf8\x19\x46\xb7\x8a\xbb\x8d\x39\x53\x6e\x43\x96\x31\x94\x09\x66\x81\x52\x2d\x9f\xfa\x2d\xe7\xcd\x85\x56\x54\xe0\x10\x54\x97\x0f\x06\x1e\x5e\x37\x2b\x63\xff\xc8\x26\xbc\x28\x92\x0b\x9a\xec\xd2\x79\x49\xaa\x61\x18\xfc\x8a\x2f\x4d\x68\xdd\xae\x3b\x26\x61\xcd\x17\x2e\x98\xc1\x44\xef\x6b\x77\x32\x2d\x46\x26\xa2\x0d\x45\xcc\x63\x51\x4e\x27\x26\xea\x37\x40\x06\x81\x21\x9c\x5a\xcb\x65\x99\x34\xfb\x44\xb9\xa5\x69\xcc\x0a\x42\xc0\x3c\xb9\x40\x83\x1d\x82\xaa\x85\xea\x3d\x20\x15\x84\xe7\xd6\x47\x14\x03\x1e\x89\xb6\x1e\x07\xd8\x29\x92\xdc\x2e\x60\x10\xe2\x0f\x5d\xd1\x0a\xc4\x47\xb5\x10\x70\x05\x90\xb6\x6c\x97\x42\x52\xeb\xe5\x8e\x8c\x7b\x53\x56\x77\xbb\x91\x43\x5f\x8d\x76\x15\x64\xed\xce\xaf\xaf\x33\xdc\xd0\xc8\x08\xbd\x8c\x36\x85\xe7\x35\xe7\x22\xce\x86\x18\xe1\xdb\xe4\xcc\x3b\x60\xf6\xe1\x66\x62\xdf\x45\xc7\x8d\x9f\xaa\x28\x44\xbf\xbb\xd1\x78\xbf\x5d\xb5\x30\xf9\xbe\xbd\x61\x4d\xec\x5b\x55\x8b\xa2\xdd\x81\x4e\x58\xc1\x07\xea\xc5\xac\x56\x75\xbd\x20\xcb\x84\x92\x1e\x0c\x88\x9e\x8b\x3e\x4f\xfb\xd3\x94\x97\x5a\xe8\x13\x17\x1b\x59\x51\x03\x38\x43\x97\x23\x71\x05\xae\xce\x65\x9e\x9c\x9f\x8b\x7c\xf1\x23\xc0\x47\x4c\xbc\xeb\xc3\x4b\xcc\xc5\x8a\x23\xbc\x85\x37\xf7\xea\xf3\x48\x2d\x5a\x04\xcb\xe7\xbd\xc5\xdb\xac\x22\xf7\xf0\x05\x59\x95\x57\xd1\x11\xde\xaa\x5f\xfc\xfc\xe2\x6d\x58\x7f\x80\x61\x0a\xe4\xa8\xc2\x28\xf3\x85\x27\x36\x7a\x1c\x23\x7d\xcd\x3b\x91\xf6\xf8\xe9\x5e\x8b\xa5\x4f\x61\xe4\x44\x44\xe4\xef\x34\x3a\x98\xbd\x20\xa2\x63\xac\x3f\x7d\x2d\x62\x01\x8a\xa4\x4c\x94\xc6\xae\x31\x4a\xb6\x90\x5f\x8e\x0e\x51\x3d\x59\x4e\xeb\x0f\xae\xdf\x32\x3c\xaf\x61\xf6\xc7\xda\xf3\x9a\xd3\x2d\x8c\x1c\xd9\x99\xc4\x40\x4c\xe6\xc8\x46\x11\xae\xee\x84\xaa\x5e\x78\x5a\x48\x0d\x45\x17\x30\x23\x10\xb0\x37\x1e\xe3\xd9\xd5\x58\xe6\x02\x54\x56\xd3\x2c\x15\x45\x01\xb1\x59\x51\x9e\x61\x84\x22\x5a\x2d\x3d\xe6\xd9\x94\xa7\xe9\xd5\x6a\xe7\xbf\x86\x8b\xb5\x04\x60\xd1\xf9\xef\xf3\xac\x2f\xd2\xbd\x2c\x19\x83\xba\xe2\x65\xae\x58\xe7\xba\x93\x1c\x90\x8b\xe8\xa1\x8a\xd2\x0b\x3c\x5e\x21\x31\xb0\xf1\x6a\x4d\x0c\xe3\x24\x9b\x4c\x4b\x4c\x94\x88\xbe\x9e\x2b\xab\xee\xbe\xbd\xd6\x40\x22\x79\x19\xeb\x65\x25\x6f\xa7\x63\x91\x27\xfd\x66\xe6\x49\x43\x32\x7c\x31\x1a\x0f\xae\xb7\xfc\x6d\x93\xd8\x1d\x66\xad\x96\x56\xe1\x24\x59\x52\x8a\x66\x16\x72\x2b\xa8\x46\x87\xe0\xa4\xda\xa4\x09\x27\xb9\xaa\x19\x5a\x3d\x8b\x4d\xdc\x5a\x4b\x89\xea\x06\xaf\xd3\x1a\xaf\x15\x17\xdc\x19\xbf\x20\x67\xcf\xad\xfe\x95\xa8\x9d\xd4\x49\xd1\x31\xda\xe7\x1a\x6b\x39\x9e\xdf\xe7\x99\x50\x6c\xef\xbc\x98\xb1\x6b\x5c\x65\x6a\xdc\xaf\xbf\x47\xa8\x97\x1a\x0c\x95\x22\x4c\xb3\x84\x3e\x2a\xd7\xd7\xe1\x66\x86\xaf\x89\xb5\x59\x9b\x82\x0b\x57\x86\xbb\x0a\x93\xd0\x8e\x5d\xfa\x22\xb6\x09\xb4\xad\xfc\xe0\xbd\xb6\xe4\x69\x5b\xeb\x9e\xb6\x31\x67\x74\xf6\x4c\x26\x19\x7e\xd5\xb2\x09\x06\xe9\x72\x48\x39\x8c\xd2\x51\x9c\x41\x51\x4e\x14\x7c\x66\x16\x93\xcb\x06\xd5\x3e\x9a\x57\x0e\xbe\x6c\xb5\x76\x9d\x51\x18\xec\x21\xb4\xad\x8a\xc8\x0c\xc2\x39\xc5\xc8\x97\xc6\x3a\xaf\xe7\xdf\x1e\xf5\xac\xb4\x82\xa0\x9f\x1b\x62\x15\x05\x49\xd9\x12\x68\x88\x48\xb6\x4b\x20\xe2\xfe\x38\x89\x14\xd6\x50\x38\x01\x77\x96\xdb\x7b\xbb\xc9\x64\x8c\x4d\x34\x37\x09\xa1\xb5\xa2\x9e\x8c\x06\x40\x28\x95\x81\x31\xfa\xea\x4d\x87\x1f\xff\x15\x24\xc1\xd5\xfb\xfe\xc6\xb3\x63\xb8\x99\xa7\x5c\x70\x91\xcd\x81\xd4\xd5\xf6\xe4\x1d\xf6\x5a\x6f\x38\x92\x2a\xb2\xed\x1d\xb3\xe9\x0e\xb7\x64\xcc\x42\xb6\xa6\x03\x82\x84\xae\x13\xfb\xf1\x6e\x3a\xba\x23\xaf\x3f\xb0\xb0\x22\x8b\xea\x63\xb0\x13\xc9\xa1\x7a\xc1\xb0\xa6\x3c\xbb\x72\x72\x67\x9d\x06\x8f\x25\x19\x3b\x23\xeb\x7b\x36\xdf\xa6\x56\x6b\x0f\x13\x14\xfe\xb0\x19\xbf\x62\x33\xc5\xb3\x64\xd6\xae\x80\x3d\xca\x21\x86\x47\x79\x45\x8d\x71\x06\x03\x1d\x75\xc3\xb8\x05\x40\xd0\x26\x9d\x01\x49\x30\x3e\xe3\xb9\x68\x93\x06\x7d\x39\x4d\x07\xa0\xc9\xce\x8d\x0e\x93\xac\xbf\x31\x44\xd1\xf6\x66\xc6\xe2\x00\xc1\xa5\x49\x66\xbc\x2b\x92\xc2\x82\xbc\xbf\xc6\xc8\xa5\x02\x13\x36\x0a\x64\x5f\x2b\xa6\xaf\x13\xc3\xae\xce\x5f\x33\x87\x32\xcb\xad\x1b\xf0\x83\xa6\xa2\xe2\x83\x79\x81\x81\xb1\x08\xee\x85\x89\x79\x03\x82\x34\x67\xe8\x84\x0c\xd1\xe8\x83\x79\x2e\x67\xfb\x2e\xf4\x8a\x59\x3c\x30\x33\x70\xfa\x71\x36\xe2\x05\xc6\x59\xa2\xfe\x1e\x40\x8e\x10\x38\x05\xf3\xe0\x81\x47\xff\x5c\x85\x63\x7d\x19\xa3\x2c\xdf\x10\xae\x60\xe1\x29\x28\x33\x74\xd2\x38\xb4\xd2\x0c\xad\x2b\xcc\x75\x45\x04\xc9\xe4\x98\x1a\x23\x95\x0b\x91\x5f\x95\x60\x2c\x08\x04\xd0\x45\x1e\xd3\xb8\xd5\x43\x6b\x2a\x30\xb0\x90\x80\xa0\x26\x78\x98\xb7\x71\xf6\x6b\x26\xc4\x00\xca\x7a\xc0\xa3\x23\xe3\x3f\x20\xd9\x74\x15\x24\x93\x50\xd7\x57\xd2\x2e\x54\xcd\x45\x2d\xc2\xe2\x31\x4d\x34\x41\xad\x1a\x1f\x98\x67\xb0\xe7\x5b\xb0\x20\x52\x8a\x75\x25\x50\x20\x01\x0f\xc3\xd8\x17\x5a\x36\x1c\x73\x2c\x70\xa4\x4c\xcf\xe2\x3f\x05\x21\x5c\x51\x72\x74\x98\xbd\x96\x7c\x40\xdf\xce\x06\x7f\xad\x50\xc0\x2c\xc5\xa1\x27\x15\xb3\x24\x6c\x19\xe3\x0b\x74\xdf\x09\xbc\x1e\xe2\xa6\x17\xb5\x1e\x65\xff\x07\x6c\x2d\x40\x6f\xb6\xc8\xd4\x22\x62\x65\x11\xf1\x87\xa8\x3a\x4a\x2f\x6f\x50\xb1\x8c\x2d\x85\x51\xca\x50\xae\xc6\xd3\x13\x51\x9f\x0c\xeb\x25\x01\x17\xef\x99\xc1\xf7\x33\x72\x07\x6b\x1a\xc0\xb3\x08\x05\xd0\x01\x0a\x93\x72\x24\xa7\xa5\x6f\xa1\x65\x28\x37\xde\x68\x8d\x92\x9d\x4f\x79\xce\xb3\x52\xb8\x4c\xd9\x24\x8e\x47\xe1\xdd\x28\x66\x8d\x3e\x5a\x70\xdb\xc4\x36\x22\xb0\x17\xd3\x6b\xf2\x55\xf1\x58\xbf\x5d\x3c\x02\xc7\xa9\x58\x6c\x71\x0a\x91\x4b\xb6\x6b\x51\xe8\xd2\x98\x0a\x5c\x91\x8f\x36\xf5\x87\x35\x7d\x89\x58\xac\x04\x62\x32\xe0\x0c\x52\x71\xce\xfb\x57\x4e\x6f\x96\x11\x3a\x76\xb1\x65\x4c\xce\xb0\xd6\x3f\x27\xd3\xbd\x7e\x5f\xa4\x02\x97\x02\x89\x93\x31\x77\xf6\x6f\x64\xa2\x1b\xad\xb7\x63\x0d\x6c\x26\xba\xd6\x96\x81\xaa\x53\xb5\xe7\xf8\xb9\xdf\xb7\x71\xda\x98\x37\xb0\xfb\xb1\xac\x38\xbe\xbd\xeb\xcf\x7b\x47\x6f\x0f\xde\xfe\x73\x9b\x9d\x05\xf0\xcf\xf4\xca\x32\xb5\x52\x70\xa3\x9c\xd1\x7d\x22\xda\x62\x10\x85\x29\x82\x96\x49\x1d\xb4\xd8\x18\x56\x24\x19\x1b\x4e\xcb\x69\x2e\xd8\x05\x26\xdd\x01\xae\xc6\x2e\xaf\xb6\x9b\xbd\xd6\x4b\x1c\x0c\x80\xed\xce\x5d\xf4\x30\x7c\xc4\xbc\xba\xdb\x16\x4b\x2a\x8b\x18\x0f\x75\x15\x26\xa4\x8c\x31\x5b\xad\x58\x98\xac\xb9\xe1\x75\xab\x81\x83\xd6\xd7\xd9\xb1\x7e\xce\xfa\xbe\xb2\xc6\xf7\xc5\x90\x90\xc0\xe0\x8a\xda\x21\x0e\x53\x29\x31\xc7\x54\xe1\x32\xd9\xf6\xd2\x69\x9e\x5f\xb1\x52\x5c\x96\x95\x58\xb7\x34\xfa\x38\x84\x45\x04\x08\x9a\x72\x81\xc6\xbd\x45\x62\x91\x57\x6b\x94\x72\xd2\xf2\xa3\x46\x54\xeb\x60\x49\xcb\x8b\x5f\x51\xad\x05\x05\x2d\x3f\x78\x83\x4e\xac\x75\x89\xc7\xc0\x78\x80\x12\x5f\xae\x9e\xc9\x93\xe5\x27\xd7\xba\xc2\x06\xb9\xcd\x2e\x64\x7d\xb9\xf0\x13\xe1\x84\x43\x44\x4b\x0a\x93\x40\xef\xac\xcc\xa7\xe2\x0c\xb3\x08\xda\x40\x33\xaa\xd8\xa0\xb4\xbe\xc9\xd5\xd5\x00\xaa\x78\xa8\xa5\x38\xc0\x47\x83\x33\x5f\x94\xe1\xf8\x2f\x8f\x8d\x9c\xe9\x8b\x47\x31\x12\x63\x0e\x71\xc0\x53\x88\x6e\x83\x52\x37\x62\x93\xa4\x0d\x84\xf4\xc9\xf1\x38\x02\x62\xbd\x33\x20\xf9\x4d\x96\x32\x63\x30\xeb\x90\xc9\x59\x9b\xa5\xa2\x6c\x14\xf8\x64\xe3\xac\x28\xc5\x84\x69\x91\xf3\x80\xa5\x52\x7e\x60\xbc\xd4\xc1\xc5\xe5\x40\x27\x59\x4f\xaf\x58\x73\x56\x0e\x9f\xb6\x74\xde\x83\xa1\xb6\x7b\xcc\x4a\xe2\x9e\xac\xe7\x7a\x9e\xcb\x59\xc1\x24\x24\x19\xc2\x38\xc1\x20\x44\xc2\x75\x11\x83\xb6\x7d\xf9\x8d\xf9\x15\x1b\xf1\xc9\x04\x24\xe5\xbc\xf4\x60\x28\x9c\x1d\x27\x05\xdc\xfb\x03\x6a\xc5\x6c\xcc\xa1\x75\xdf\x3a\x2b\xec\x85\xc8\x87\x28\x97\x03\xb7\xc3\x48\x04\x06\xc8\xa3\x60\xce\x09\xcc\x6e\x92\xcb\x5e\x2a\xc6\x10\xb1\x4b\xa7\xbf\x86\x54\xd8\xe6\x2a\x6c\x5e\xc2\x8a\x5c\xb5\xda\x5a\x8c\xc4\xd3\x14\x54\x37\xda\xd4\x50\x51\xd4\xe9\xd8\x24\xd7\xb3\x31\x01\xb5\x0b\x3f\x32\x64\x5d\xbb\x5e\x33\xca\x69\xd8\x17\x82\xc2\x93\x09\xe6\xe2\xab\x8c\xb9\x6d\xde\xd6\x85\xd0\xe3\x3f\xbb\x3c\x43\x74\x95\x93\x33\x6a\xcc\x4f\x57\x9e\x95\x72\xc6\xf3\x41\x01\xeb\xa0\x80\x2b\xfa\x25\xf8\x80\xc9\xa1\x3e\x09\x65\xa1\x4f\x70\xd7\x5e\x72\x60\x6d\x83\x41\xec\xcc\x25\x8b\xc6\x33\x2e\xb0\x1d\xa4\xef\x71\x99\xec\xf4\x71\x6c\xb9\x38\x38\x6c\x97\x75\x42\x9a\xd8\xad\x84\xf3\xc2\x76\x55\xeb\x48\x68\x1f\xc4\xfc\xba\x26\xdd\x3e\xa3\xe7\xbc\x45\x88\x59\xb4\xdb\x30\xb4\x57\x6e\x43\x91\xd0\x4e\x75\xf3\x30\xfe\x97\x8d\xac\x19\xd0\x8b\x07\x0f\x2a\xa7\xcf\xbe\x70\x8d\x9c\xd5\x2f\x06\xdb\x21\x42\x2b\x9a\x0d\xf6\x90\xe9\x80\xac\x8d\xc9\x65\x9b\xa9\xdf\x18\xe6\x15\x7e\x6e\xb4\xb4\x4c\x57\xc3\x83\xf5\x3e\x35\xe1\xbb\xbd\xcf\xcf\x2a\x9f\xbb\xea\x32\x7e\x3e\xd2\x89\xae\xc9\xd9\x8f\x05\x41\x94\xe5\x68\x26\xf2\xa4\x10\x6d\x43\xd3\x50\xfa\xcf\x15\xff\x3e\x40\x0c\x6b\xeb\x14\xbd\x6d\x76\x86\xbb\x86\x14\xf2\x0c\x16\xf3\xcc\x97\x13\x68\xf3\x95\xec\x42\xe4\x25\x06\xcc\xad\xe2\x8a\x97\x45\x93\x36\xd0\xe1\x73\x2b\xdb\x1c\x34\x08\x17\xa5\x84\x7c\x9a\xb6\xcf\xf8\x12\xa5\x98\x28\xd3\x75\x54\xbf\x64\x36\xb3\x22\xee\x0b\x80\xa0\x0e\x72\x4e\x0a\xa3\xcf\x0d\x91\xda\x98\xeb\xd5\x7b\xb6\x6c\x07\x06\xd5\xf4\xfa\xd6\xea\x3e\x90\x23\x9d\x11\x48\x46\xd1\x11\xca\x67\x8c\x29\xb6\xd7\xa7\x97\xcc\x87\xc2\xa8\xca\x83\x98\x27\x45\x0d\x9a\x9a\x34\x0b\xbe\x04\x8c\x55\x64\x33\x61\x3b\x8f\xd5\x86\x7a\x51\x79\x4e\xbd\x2c\x67\x79\x4b\x67\xb4\x86\x2d\x74\x82\xdf\xcc\x9a\x79\x13\x87\x98\x83\x12\xf5\x76\x85\x01\xa1\x2d\x7e\xa8\x7d\x23\x28\xc5\x51\xf8\xb5\xba\xe1\x74\x8d\x1f\x1f\xeb\x54\xfd\x0f\x63\xbe\x7d\xb9\xf8\xdf\xa9\x28\xca\x24\x3b\x07\x63\xae\x0e\x9a\x30\xcb\x21\x29\xb0\x00\xe6\xb4\x17\x83\x78\x73\x32\xd3\xd5\xcc\xbc\x8f\xc4\xff\x4e\x93\xdc\xb7\xf3\xf6\xc7\xda\xf6\xfb\xa6\x09\x91\xec\xc8\xf5\x6b\x28\xfa\xfe\x59\x64\x03\xee\xd9\x78\xdb\xc7\x90\x3f\x86\x20\x90\x54\x52\x98\x61\xb3\x5d\x76\xff\x3e\x19\xc8\x83\x07\xf5\xc6\xe8\x4b\x3f\xc4\xfc\xb5\x26\x20\xa9\x0f\x9e\xfd\x06\xce\xa5\xec\xef\x64\xc4\xf8\x89\x8c\x59\x5b\xc7\x99\x41\xd3\xd5\xf8\xc5\x5b\xc5\xc6\x59\x03\x5c\xfb\x3d\x5c\x79\xa8\x3e\x3b\xb2\xe9\x76\x3c\xa8\xaf\xc7\x4b\xaa\x7b\xcf\x3e\xd7\xee\x21\x6b\x78\xe7\x22\x37\x8b\xd9\xbb\x02\xe2\x47\xc7\xe4\xd7\xd5\xae\xb4\xea\xb8\xce\x64\xfe\xa1\x6d\xf3\xd5\x94\xd2\x84\xae\x67\x49\x69\x64\x30\x11\x58\xe4\xf9\x67\xe3\x4c\x9b\x65\xf9\x42\x22\x91\xaf\x34\x40\x23\x50\xcd\x3a\x49\xc8\x2f\xea\xfb\x5f\x35\xb1\xfd\x2b\x54\xb5\x4a\x0a\xf5\xc3\x52\x48\x99\xb1\x0f\x42\x4c\x4e\xe4\xb9\x00\x22\x19\xee\x98\x43\xc6\x0a\x01\xa8\x15\x65\x34\xa0\x0b\x75\x31\x52\xd0\xce\xe2\xdb\x23\xef\xc4\x63\xcf\xd3\x1a\x38\xa1\x8d\x48\x3d\xff\xa6\x88\x96\x42\x3d\x4b\x72\x08\xc5\x08\x6f\x23\x93\x33\x84\x43\xfc\x9c\x42\xa4\xa2\x5f\xca\x7c\xcd\x33\xe0\xf7\xfb\x82\x70\xcb\x00\xc2\x72\x8b\xc1\x60\x62\x8f\xfb\xee\xff\x4e\x45\x7e\x75\xac\xe1\x37\x69\x0b\x12\xf2\x37\x32\xde\x4c\x96\x6c\x88\xc6\x86\xe8\xfd\x18\xba\x41\x59\xe5\xee\x7d\x0f\x68\xe8\x48\x60\x56\x50\xeb\x61\x03\xae\x4d\xdf\x6b\x41\xe7\x90\x6d\x8e\xc1\xc8\xed\xd2\xd8\x6c\x52\x98\x1f\xca\x3c\xaf\x0c\x20\xfd\xdc\x19\x80\x53\x00\x84\xaa\x81\x54\x52\x49\x0a\x21\x2e\xd4\x0b\x81\x84\xb1\x71\x43\x8f\x2e\x99\xcd\x8a\xe1\x4d\xcc\xcd\xac\x4e\xf0\x04\xd5\x0d\x2a\x9c\xd9\xdc\x57\xb1\x51\xe8\x4a\xf7\x69\x82\xb8\xd8\x72\xad\x45\xe4\xde\x3e\x0b\x16\xc6\xed\x89\x9c\xad\x40\x84\x68\xde\x43\x56\xbe\xe8\x55\xee\x3a\xfd\x1e\x0e\xcb\xf9\x7a\xfa\xf5\x6c\x09\xb9\xc1\x7e\x52\xec\x73\x9f\xa7\x10\xfa\x46\x07\xc4\xd2\xac\xef\xdc\xd0\x37\xf6\xd9\x96\x81\xe1\xb7\x05\x33\x37\x36\x4d\x32\x10\xcf\xf9\x24\x29\x79\x9a\xfc\x0a\x17\x87\xdf\xd0\xcb\xea\x4c\x1b\x69\xc6\x98\xb4\xed\x96\xf2\xb5\x9c\x19\x67\x1f\x53\x97\xa7\xa5\x0d\xac\x43\x01\x47\x63\xeb\xc8\x49\xb4\x6e\xcf\x65\x86\x36\xd2\x9b\x2a\x1d\x39\x4e\x7e\x15\x95\x10\x4a\x1e\xee\xbd\x4f\x45\x66\x62\x32\x21\x85\x31\xb9\x50\x3d\xc2\x68\x43\x94\x8c\xf9\x07\x75\x37\x39\x17\x76\xdc\x6a\x30\xfe\x29\x0b\xe3\xd3\x61\x76\x16\xc2\x1c\x89\x0c\x62\x4f\x4c\x92\x4b\x91\x16\x90\x16\x49\x66\xff\x99\xea\xeb\x4a\x75\x6b\x3c\x6f\x26\x10\xa6\x0c\x96\x50\x93\x2b\x0b\xe9\x3d\xae\xc2\x29\xeb\x54\xe7\xf7\x77\x3d\x08\x78\xc8\xd8\xf8\x06\x11\xd1\x36\x56\x80\x38\xce\xde\xef\xe5\xfa\xb1\x37\xf1\xfa\xba\x96\x09\xac\x63\x50\xd9\xe8\x78\x0b\x1d\x77\xa8\x32\xda\x7f\x98\xce\x75\x4f\x8b\xc7\xfb\x90\x84\xf0\xa9\x87\xdb\x09\xe0\x9a\xd1\xde\x3c\x50\x80\xaf\xd6\xeb\x8b\xac\x04\x3d\xad\xa7\x2d\xc5\x50\x92\x58\x14\x1b\xa6\xfb\xa2\xf0\x4c\xc7\x59\xaa\x8c\x1d\x02\x2c\x61\x77\xcf\x89\xff\xae\x02\xf2\x13\xd8\xf7\x4c\x0b\xe3\xfd\x8f\xec\xc8\xa0\xea\xdb\xab\x30\x88\x7f\x08\x74\xd1\x0a\xdb\x78\xbf\x2f\xa7\x99\xcb\x91\x04\x51\x1a\xd4\x3d\x80\x31\xb8\x20\x5d\x68\x36\x94\x2e\xf2\xb5\x99\x55\x31\x37\x4d\xdb\x5c\x79\x37\xfe\x7c\x03\x63\xd0\xa7\x97\xd8\x34\xf6\x8b\x82\x66\x7e\x0f\x48\xc6\xa9\x97\xc0\x0d\x21\x61\x9e\xbf\x1a\x48\x98\x42\x2a\x02\x49\x71\x90\x98\x2e\xdd\x87\xe9\xd6\x75\xd7\xec\x5d\x67\xde\x79\xa9\x4e\xa7\x53\x19\x97\xd9\xbf\x49\x8e\x16\xd5\xde\xbd\x0b\x0f\x51\x4c\x81\xa6\x85\x94\x90\x1a\x5d\x66\x65\x72\x3e\x95\xd3\x02\xad\x82\xdc\x25\xb6\xc6\xbc\x31\xda\xc4\x44\xf8\x47\x92\x69\xe1\x38\xe2\x54\x15\x9f\xda\xae\x75\xab\x6d\x92\x14\x55\x2d\x33\x76\xbd\x86\x15\x07\x6e\xe4\x14\x77\x59\x33\xc2\x4d\x42\x62\xdb\x76\x90\x3e\x3b\x56\x11\x87\xd2\xc6\x29\xe4\x8a\xe9\x69\xba\xb1\xb5\x96\x83\xa0\x6f\x8b\x36\x6b\x34\x5a\xed\x18\x6f\x3b\x57\x6c\x30\x27\x52\xa6\x8b\xd4\xfb\x59\x62\x66\x3a\xf8\x4b\x46\xcf\xf4\x1a\xc4\xe3\x68\xfe\x64\x6a\xb8\xc0\xc3\xce\x08\x9b\xc4\x33\x56\x2c\xad\xc8\x2a\x89\x7b\x1a\xe0\x42\x42\xa5\x7c\x91\x76\xff\x1f\x7b\x6f\xbb\xde\xc6\xad\x24\x0c\xfe\xd7\x55\x94\x3d\xe7\x98\xa4\xd4\xfc\x94\x3f\xa9\xc8\x1e\xc5\x56\x12\xcf\xd8\x96\x5f\xdb\x49\x4e\x46\xd1\x4a\x50\x13\x14\x3b\x6e\x76\xf3\x74\x37\x25\x32\xb6\xf6\x99\xbf\xfb\x7f\xff\xbc\x17\xb0\x7b\x61\x73\x25\xfb\xa0\x0a\x9f\xfd\x41\x91\x22\x9d\x78\x76\xe2\x79\x26\x47\x44\x03\x85\x42\xa1\x50\x28\x14\x0a\x55\x54\x27\xdf\x52\x40\xcb\x9d\xc5\x74\x3b\x27\xdc\x92\xf2\x86\xf3\x7d\x3e\x71\xe2\x1c\xe0\xdd\x93\x90\x40\x2c\x55\x4e\x71\x92\xee\xb6\x5b\x03\xe9\xfd\x96\xa9\xe6\x27\x37\x38\x24\x66\xec\xeb\x8b\x0f\x4d\x19\xdb\x5f\xfe\x9d\xc5\x13\xf5\x27\x59\x1d\xe5\x0f\x69\x8f\x94\xbf\xd0\x4a\xb9\x05\x88\xea\x21\xf3\x47\x16\xf5\x7d\x16\x91\x4c\x64\x16\x67\xe0\xd2\xa5\x4b\xe0\x20\xcd\x54\xbf\x4d\xa4\x91\x82\xd9\xe4\x18\xb2\x6c\x9b\xb0\x95\x2d\x55\x66\xc1\x8c\x27\x93\x84\x0b\x42\x70\x96\x06\xf4\xa4\x76\x1e\x4f\x05\xcc\xe8\xa3\x8e\x2d\xc5\x28\x02\x0c\xee\xff\x59\x4c\xd7\x61\xf8\x34\x20\x09\xb2\x8c\x47\x10\xb2\xe8\x62\xca\x2e\x78\xda\x02\x8c\x0f\x28\xf4\xe8\x30\x9c\x43\x9d\xec\xfb\x68\x6b\x95\x03\x6d\x78\x70\x46\xe8\xa1\x11\x4b\x40\xc4\xcf\x12\x49\x3c\xc1\x0b\xf0\x36\x89\xa5\x5e\x85\x00\x91\x42\xb6\xf5\xd6\x05\x98\xc9\xec\x7b\x08\x4f\x14\xe8\xfb\x01\xf2\xb8\x8a\xc7\x2a\x9e\x27\x9f\xb1\xf1\x04\xcd\x93\x66\xc2\xb2\x78\x82\xd4\x82\xba\xb9\xce\xb0\x7c\x45\x48\xa1\x60\x61\x70\x11\xf1\x41\xc3\x9e\x4d\x49\x71\x6c\x47\xb5\xdc\x96\x88\x96\xdb\x4e\x19\xa2\x45\x13\xfa\xdb\x93\xe2\xde\xd4\x11\x0c\xd4\x94\x46\xea\xba\xf4\x84\x42\x4d\x56\x27\x85\xa0\x3c\x10\x66\x77\xf4\xa8\x1b\xe4\x18\x75\x8c\x3e\x9f\x5b\x4e\x27\x92\x10\xff\x9a\x66\x2c\x0b\x7c\xfc\x53\x9c\x3a\x95\x2d\x10\x0b\x78\x34\x35\xc6\x3a\x29\x1d\xd8\x20\x8e\x42\x3b\x5a\xa0\xc5\xf3\x95\x0f\x34\x9c\x13\x0c\xbe\x79\xc1\xc4\x07\x44\x2d\x71\x44\xc0\x34\x08\xf2\x7f\x05\xe5\xa5\xc3\xb9\xa9\x20\xbd\xcf\xe5\xc4\xe8\x53\x85\xa9\xa0\xfd\xd2\xa9\x5c\x56\x22\x82\xba\xbf\xac\x72\xdd\x5a\x70\x93\xaa\xa5\x8e\x2d\x58\x46\x35\x84\xea\x2d\x83\xa1\x26\x01\x1e\xe5\x64\xbe\x8e\x33\x33\x0c\xc9\x8c\x6a\x04\x67\x5b\xd2\x33\x3a\x30\x91\xd8\x53\x3b\xde\xaa\x8a\x2e\xb6\xdb\xc8\xe7\xec\x67\x42\x21\x0a\xb2\x80\x85\xe0\x78\x31\x91\x60\x56\x39\x5b\xd2\xe9\x79\xca\xff\x39\xc5\x50\x7f\xce\x0c\xf8\x61\xec\x7f\xbc\x0a\x52\x0e\xf5\x38\x01\xd4\xaa\x78\xd2\xd4\xa5\x0d\xb5\x06\xd6\xdf\x39\x9a\x70\x50\x08\x8a\x5b\x0f\x32\x29\x54\x53\x23\x9f\x64\x98\x5d\x03\x4b\xe7\xa4\x93\xe8\x41\x93\x9c\x20\x63\x7a\x85\x99\xc5\x70\xc5\xc2\x8f\x6e\x06\x94\x54\x55\xd6\x43\x71\x37\x2c\x69\xc4\xb6\xea\x93\xf1\x4e\xea\xa4\x81\x15\x49\x3f\xe7\xcf\xa7\x01\x96\x85\x7d\x56\x18\x96\x26\x03\xe9\xba\xc9\x40\xba\x8b\x92\x81\x74\x4f\xa0\xaf\x9e\x6c\xa9\x03\x33\x06\x4d\xdc\xcf\xb3\x49\xc9\x49\xd9\x3a\x36\x96\xd4\x27\x4e\x22\x68\x3b\xd0\x6d\xb4\xfc\x38\xf2\x59\x56\x2f\xaf\xd7\xf1\xa8\xe3\x86\x1d\x9d\x50\x0d\xf3\x19\xc6\x29\x14\xea\x61\x82\x81\x2f\xfa\xe2\x37\xee\x9c\xa2\xfb\x6f\x0f\x7f\x38\xf8\xe9\xe5\xd1\xbb\xf7\xf2\x7a\xe8\xbb\x57\x2f\xdf\xf6\xa1\x26\x74\x84\x9a\xb7\x05\xf0\xfc\xd5\xd1\xf3\x7f\xff\xf9\xe5\xfb\xc3\x3e\xd4\x34\x55\xe9\xcb\xd1\x8f\x6f\x3e\x1c\xbe\x73\x2a\xe4\xa6\xb3\xb6\x75\xbd\xf7\x3f\xd8\x56\x2a\x88\x58\x66\x2a\x25\x2b\xd9\x19\x26\xf5\x2c\x0d\x6d\xe1\x19\xff\x3e\x75\xed\x79\x26\x80\x9d\xd9\xa6\xba\xf2\xe0\x17\xd5\xe6\x51\xec\x6e\xb1\x39\x54\x7b\x52\x2b\x15\xf1\xde\xbd\x42\x3c\xac\xfd\xfd\x8a\xd0\x50\x0d\x63\x03\x4c\x39\x1f\x0b\xc5\xe5\x23\x47\x1a\xe0\xf6\x9d\xcc\x71\xd9\xc6\x10\xc6\xf1\x04\x49\x77\xce\xce\xc9\x21\x25\xe1\x32\x8b\xbc\xb4\x58\xd0\xce\x87\x33\x32\xd7\x6f\x9a\x04\x46\x94\x1f\x29\x18\xc8\xeb\xdc\x2a\x8b\xee\x82\x84\x3a\x0b\x5c\xd3\x75\x69\x89\x0f\xa9\x4e\xba\xa3\x0a\x16\x24\xdf\x59\xd5\xb0\xa7\x3f\x2b\x5d\x5b\x1a\x8e\x16\x44\xb0\xdf\x2b\x49\x24\x52\xdd\x55\x17\x23\x3b\xd6\x6a\x26\x51\x4b\x18\x4c\x8e\xd0\xdc\x4e\x6f\x55\xc5\xb1\xef\x2a\xc8\xfc\x11\x68\x67\x5b\x65\x77\x32\xef\x28\x53\x6e\x64\x45\x0b\xa5\x84\xb4\x27\x3a\xd0\xac\xed\xad\x30\xae\x13\x9d\xe7\x2c\xe1\x4c\xc6\xa1\xc9\xc1\x35\xc2\xa4\x04\x78\x99\x50\x5f\x02\x64\x5e\x4c\x2d\x07\xd9\xc3\x7d\xab\x0c\xbe\x8c\x50\x51\x06\x27\x4f\x3d\xcd\x95\xba\x52\xc9\xdb\xab\x34\xe3\x13\x25\xbf\xad\x18\xa2\x86\x8d\xc4\x06\x84\x0e\x50\x9f\x3f\x5b\x80\xe4\x8e\x25\xd6\xa3\xd9\x26\x16\x99\xea\xc9\x6d\x6f\x05\xe6\x84\xdb\xb1\xa6\x89\x88\x94\x0b\xf4\x5e\xea\xf4\x6a\xae\x0b\x87\x15\x35\x5d\xab\xb4\x0c\x03\x2c\x64\x09\x79\x17\x2a\xf3\x52\x79\xc6\x80\x31\x9b\xab\xf0\xfc\x30\xe0\x7e\x30\x66\x21\xe6\xe5\x16\x67\x24\x21\x71\x2e\x62\x29\x95\xfc\x18\xdd\xe3\x13\x95\x8c\x54\xad\x14\xd1\xc5\xbe\xe5\x1f\x68\x30\x8e\x2f\x79\x12\xb2\x49\xfa\x8e\x0f\x6d\x2d\x90\xce\xb2\x64\x51\xbe\x77\x0f\x6c\xa7\xc2\x23\xdb\xd3\xa7\x01\x4f\xe5\x47\x33\x74\xf2\x70\x14\xf3\x9c\x03\x27\x7d\x4d\x2a\xe0\x51\xab\x6f\x8a\xe0\x64\x47\x45\x78\xe8\xb0\x58\x01\x4d\xfa\x47\x96\xa1\x97\xc5\x93\x32\x68\xca\x24\x5e\x01\x10\x5b\x95\x60\x77\xae\x12\xa3\x38\x24\x1d\x86\xf1\x55\x2a\xbd\x6d\x6e\x1e\x6c\x2e\x27\x57\x63\xaf\x08\xeb\x9d\x4c\x1d\xb5\xc4\x4c\xe4\xf3\x96\x95\x81\x23\xcf\xa1\x1b\xc7\xe9\xa6\x4c\x2b\x03\xf4\xad\x4a\x27\xb9\xcc\x24\x14\xb2\x99\x95\x92\xed\x5b\x7b\xe3\xab\xe2\x48\x97\xc8\x8b\x78\x2d\x47\xc2\x6a\x36\x72\x88\xb3\x90\x3f\x72\xa3\x37\x4b\x1a\xf5\x04\x7a\xdf\xac\xf6\xb4\x60\xa8\xaf\xfc\x8d\x33\x96\x7b\x21\x25\x0f\x91\xb2\x83\x1b\x72\x31\x98\xcd\x6f\xc2\x07\x3f\x59\x5b\xe7\x9d\x3b\x4a\x70\x8b\x8f\x96\x25\xe5\xde\x3d\xa1\x62\xe9\x1e\xef\xdd\x83\x52\x93\x55\x29\x55\x17\xb6\x13\x07\xd3\x72\x0a\xdf\x59\xb5\x3f\x49\xf2\xc5\xed\x0a\xfd\x7d\xeb\x30\x91\xd8\x6f\x6c\x71\xf6\xf9\x73\x29\x4f\xc9\xfd\xc7\xa6\x9e\x13\xd4\x99\x22\x30\xd3\x41\x90\x1c\x4e\x33\xa1\xaa\x63\x70\x5d\x31\xbd\x42\xf3\xb3\xc3\x20\x2b\x2d\xd3\x8a\x53\xb3\x3c\x36\x76\xa2\x60\x7b\x57\xd3\x3b\xe4\xb1\xde\x16\xb5\xe2\x71\x6d\x77\x51\x3d\x14\x70\x14\xab\x1b\xac\xa0\x05\xd8\x85\x00\xb2\x93\x15\xf3\xb6\xe5\x08\xea\x26\x99\x49\xad\xe7\x44\x78\x4c\xb8\x62\xf4\xca\x0a\x1f\x7e\x26\x97\xe8\xd8\xc2\xc2\x18\xb3\x64\x65\x23\x03\x4b\xcc\x82\xd0\x62\x33\x0a\xda\xae\x1f\x8c\x5e\x71\xdc\x24\xd9\x40\xbf\x55\xa5\x77\x11\xf6\x68\x0a\xd7\x58\xd5\x1e\x76\x4a\xa5\x2e\x04\x77\x5d\xa0\x79\xdf\x1c\xe5\xb5\x10\xf8\xda\x09\xd3\x5a\x79\xe6\xa1\xb3\x17\x1d\x66\x73\x4f\xc7\x2b\xed\xf6\xff\xf3\x8e\xa9\xf6\x85\xb3\xf5\x1a\xfb\x4f\x73\x3a\x58\xf5\x00\x55\xae\xa4\xad\xbb\x5b\x58\xbe\x05\xae\x03\x40\xa2\xbd\x17\x72\xcf\x3d\x2a\x1c\x06\x96\x4a\xdc\x63\x37\x20\xa7\x08\xd1\x42\x7a\x4a\x98\x74\xb3\xf6\xf5\xa0\xa5\x51\xb9\x77\xe8\x8d\x45\x57\xdb\xea\x9e\x7d\xbf\xb2\xb5\xb9\xd1\x1e\xe7\x93\xdf\xb8\x68\x28\x50\x4f\x0b\xa0\xd2\x35\xd0\xa0\xb6\x37\x3d\xb0\x7e\x1e\xa3\xb3\xb4\x71\xc2\xb2\x93\x70\x51\x6c\x8a\x1d\x19\x36\x25\xca\x62\x60\x30\x99\xc9\x62\x2b\xf2\x4e\xf9\x4a\xff\xa4\x05\xc8\xff\x49\x48\x5f\xe7\xe2\x6e\x95\x99\x50\xd3\x2c\x81\x26\xfc\x64\x77\x4c\x78\x55\xd4\xb7\xe7\xbf\x09\x67\x34\xd1\x67\x10\x27\x70\x86\xd3\x7f\x56\x21\x1e\x1c\x2d\xb1\xa2\x4e\xfe\x75\xac\x2b\x25\xde\xe0\xf8\x3f\x5b\x77\x00\x84\x75\x10\x49\x4f\x11\x4f\x60\xa1\x9f\xea\x4a\xea\x06\x43\x88\x62\x1d\xb0\x84\x27\x1c\xf8\x2c\x4b\x98\x9f\xe5\x85\x49\x16\x23\xb8\x7a\x9a\x25\x9e\x3d\x4a\xcf\x45\xbd\xf8\x86\x57\x9b\xc6\x52\x3e\x61\x42\x64\xca\xf9\xc2\x8b\x30\x41\x50\xb5\x26\x85\x08\xc0\xb0\x31\x49\x0b\x93\xae\xd4\xdb\xf5\xfa\xb3\xfe\xaf\xcd\xcf\xbf\xee\x34\x9e\xfd\x3a\xd8\xfe\xb5\x25\xfe\xdb\xa8\xb7\xb6\x1b\x6d\xcb\x52\x42\x57\xda\x3b\xd8\xfc\xb8\x6b\x62\x06\x53\xa8\x1a\x2a\xee\xe9\x2c\x69\x2f\x87\xe4\xcc\x27\xce\x88\x2a\x5a\x93\x74\xef\x8b\x40\x48\x53\x96\xc5\x89\x07\x2f\xe1\x62\xca\x53\x15\x84\xe0\x8e\x95\x4f\xc7\x0a\xe1\x95\x38\xf6\x35\xd1\xa1\xc9\x16\xfd\x77\x99\x2a\xba\x63\x3b\xdb\x72\x7d\x51\x6e\x9e\xb6\x18\x13\x8d\x00\x60\x79\xae\xb1\x94\x43\xed\xef\x93\x5a\x5f\x2b\x2f\xa6\x79\x2e\x79\x94\xaa\x60\x19\x33\x34\x00\xdd\x5e\xfe\x4e\x74\x41\xce\xde\x61\xc3\xcf\xcf\xa1\x63\x6a\x50\x89\xa8\x0b\x5e\x2f\x76\x6e\x4d\x2b\xd5\x64\x31\xfb\x57\xb7\xd3\x81\x6d\x2b\xf7\x8e\xb9\x39\xa6\x59\x13\x9a\xed\xe5\xa8\x26\x14\x44\xab\xe0\xaa\xd6\x70\xbc\x11\xd1\x53\xf3\x72\x24\xb8\xfa\xf2\x4a\x5a\x56\x55\x50\x34\xba\x76\xfb\x9d\xc3\x39\x4b\xf9\x40\x07\xb1\x0e\xf8\xd5\x24\x4e\x32\x3d\x8c\x94\xdc\xb9\xec\xd9\x28\x60\x61\xa6\x44\xd6\xd6\xde\x13\x3a\x6a\xb3\xfa\x43\x9a\x0c\x9d\x1c\xc4\x9e\x8c\xba\xd7\x42\x33\xad\xcc\xc8\xf9\xf9\x33\x74\xca\x83\xe4\xac\xd8\x07\x7a\xa3\xb8\x5d\x50\x66\x50\xbb\x07\x87\x6b\xc9\x3d\xa8\x7c\x06\xf2\xd4\x8d\x74\xcc\x60\x12\x21\x38\x1b\x48\xe9\x0b\x73\xbf\x86\x4e\x44\x82\x60\x42\x7f\x11\x2a\x87\x89\x66\x55\x00\x17\x8c\x25\x38\x02\x84\xeb\x6e\x32\xf3\xe8\x39\x2f\x57\x38\xfe\x36\x4d\xb3\x1c\x10\xed\x20\xa0\x10\xb6\xb6\x8c\xb7\x2c\x49\xb9\x80\x7e\x46\x62\xfd\x4c\xc9\xb6\x2c\x26\x61\x36\x89\x91\x27\xce\x66\xf2\xe2\x6f\x7e\xa6\x63\x6c\x39\x51\x32\x36\xb8\x6d\x50\xcd\x4d\xcb\xfa\x62\x3f\x82\xbd\xdf\x96\xe7\x54\x55\xd9\xc6\xf0\x59\xa1\x8f\x21\xeb\x98\x28\xa2\x9b\x68\xf9\xbc\x50\xdb\xd3\x82\x48\x0a\xc3\xdc\x85\x1b\xfa\x46\x11\x0e\xf2\x2d\xf1\x8d\x02\xdf\x73\xb1\xb2\x82\x23\x6b\x75\xf3\xb8\xe3\x81\xc9\x5c\xf9\x63\xca\x55\x7e\xc9\x60\x68\x07\xb6\x90\xde\x06\x71\xa2\xee\xf1\xa3\x81\xb4\x89\x06\x29\x74\x28\xdd\x02\x5e\x9f\xa2\x1b\x9a\xe0\xfb\x62\x88\x20\x93\xcd\x41\xbe\x8d\xc4\x67\xe3\x53\xe2\x18\x36\x0b\xe8\xb1\x13\xca\x0b\x4c\xd8\x47\xde\x3a\x14\xa7\x41\x56\x74\x52\x3b\xa8\xed\x25\xe5\x3f\xa8\xdc\xe5\xd5\xa9\x23\x73\x84\xb0\x7c\x68\xdb\x6d\x78\x8f\x1b\x9e\xf5\x6a\xd3\xb0\xad\x4c\x68\x67\x02\x8c\xc9\x0d\x9a\x8e\x08\x3c\x61\xd1\x40\xba\xe8\x51\x40\x96\x0b\x3e\x13\x07\xbd\x84\xa7\x29\xd7\xbe\x30\x3a\xf0\xf5\x24\x9c\xa6\x82\x88\xe3\x20\x9a\xa6\x90\x06\x17\xe8\xc6\x37\x4c\xe2\x28\x83\xfa\x4e\xb7\xe3\x41\xb3\xd7\xf1\x80\x67\x7e\x43\x69\xde\x09\xbb\x50\xd7\xe0\x84\x9c\xd4\xd0\xdb\xf5\x5f\x77\x3e\xff\xda\x6c\xb4\xf3\x19\xed\x45\x8b\xdc\x06\x29\x8a\x5a\x59\x12\x8c\xeb\xb9\x30\x9c\x2f\xc8\x7c\x20\x1d\xca\xdd\xc1\xeb\xd3\x30\x83\x09\x0b\x12\x6b\xec\x71\x22\x74\xc2\x20\xba\x08\xb9\x99\x23\x0c\x6a\xa4\x83\xea\x28\x0d\x03\x0f\x65\x7e\x3c\x1e\x33\xd1\x0a\x6f\x9d\x54\x16\x9f\xe0\x32\x20\x93\xbe\x1e\xa2\x9e\x2c\x7c\x42\xa4\x8b\xed\x27\x44\x55\x83\x4b\x39\x4b\x84\x9e\xe2\x7d\xfe\x35\x6d\xdb\x67\x8c\xeb\x86\x79\x78\xa3\x21\x1e\xcb\xce\x4f\xd0\x9e\x5a\x28\x35\xba\x83\x27\x75\x87\x66\xb7\x3c\x7e\x82\xb2\xa7\x3b\xc3\xbd\x1a\x05\x99\xf4\x2d\xa9\xa7\x0d\xb4\x83\xe7\x13\x88\x31\x49\x93\xba\xd7\x50\x0f\x73\x5b\x35\x27\x0d\xdf\xcb\xa1\xa6\x50\x90\xaa\x37\x05\x57\x5c\x16\x3a\xd9\xee\x4a\x38\x12\x4d\x43\x58\x53\x4f\xce\x58\xa0\x16\xe3\x04\xff\x03\xeb\xfe\xd2\xb2\xd5\xbd\x77\xc8\xb9\xfb\xd0\xfe\x35\xdd\xf6\x7e\x4d\xb7\x3f\xff\x9a\xee\xb4\xcd\xb1\x0b\x4f\xa6\x12\x1f\x19\xa5\xf0\x19\x1c\x9b\x99\xd3\x97\xe4\xb2\x92\xbe\x4d\x3f\x2e\x21\x2f\x31\xb0\xe9\x56\x9c\x34\x4f\x1a\x1e\x2c\x57\xb7\x7b\x72\xa2\x80\xe7\xfb\x57\x18\xee\x40\xb7\xd1\x38\x81\xbe\x05\xf1\xc4\x78\xe1\xe2\xb1\xc6\xec\x6a\x72\x79\x8a\x7d\x90\x42\x28\xc8\x70\x2d\xca\xab\x5b\x14\x85\x61\x7c\x85\xe9\x76\x73\x91\x5f\x88\x30\xf1\x24\xcd\xad\xc1\x38\x7f\xdd\xd4\x6e\xc3\xeb\x38\xcd\xec\x5d\x3a\x85\x84\x87\x73\xa5\x10\xc5\x89\x50\x22\x1c\x97\x45\xed\x30\x5a\x76\x9e\x95\x8e\x0b\x82\x39\xc5\x54\xdc\x31\x52\xb0\x6f\x24\x62\xa3\xf2\x2d\x80\x02\x99\x5c\xf0\x9f\x83\x6c\xf4\x56\x65\x6b\xb3\xe2\xe3\x5a\x71\x6a\xd4\x10\x3e\x08\x51\xce\x2e\x2e\x12\x7e\x81\x99\xcd\x58\x34\x87\xb3\x1d\x3a\x53\x35\xcf\x48\x9e\xe1\x1b\x13\x96\xf0\xa8\x96\xe9\x1b\x1f\x3e\xd0\x0a\x7d\xaa\x60\xf1\xd6\x45\xab\x0f\xdd\x0e\xec\xc0\xce\x03\xd8\x7f\x0a\xc7\x42\xfc\xed\x78\xb0\xf3\xe0\x04\xeb\xb4\x12\x3e\x98\xfa\xf6\xb3\x3d\xe6\xc1\xb9\xd1\x01\xc5\x8a\x66\xc7\xcc\x4a\x18\x42\x89\x24\x29\xdc\xea\x71\x6d\x47\xec\x02\x4d\x7b\x0b\x50\x72\xc1\x36\x43\x16\x20\xc0\xb9\xd1\xe2\xcb\xe8\x63\xd2\xfe\x58\x24\x62\xda\x44\x69\x14\xe8\x42\xe3\x45\xdd\xee\xdc\xd8\xaf\x35\x2f\x0b\x3a\xfe\x54\xa8\xa0\xd6\xca\xb9\x65\x46\xc5\xff\x7a\x70\x7c\xd2\x50\xb3\xf1\x83\x38\x6f\x5e\x61\x30\x03\xbd\x3a\xe4\x3e\x20\x17\x09\x1e\xf2\xe5\x29\x4d\x16\xd5\xc5\x81\x76\x46\x30\x72\x0b\x20\xcd\x8a\x09\x48\x6f\x7f\x6e\x95\xda\x73\x6e\xf3\xca\x67\xff\xd4\x99\xf3\x84\x6e\x45\xf2\x90\xcf\xb8\xaf\x5c\xee\x89\x03\xcd\xc2\x2d\xb9\x27\x2e\x2c\xdb\x78\x52\x52\x4b\xc8\x14\x59\xaf\xe7\xb2\xa3\x89\xda\x8a\xfb\x94\x3d\xe1\x12\x39\xb2\x98\xe3\x7c\x8b\x2a\xb0\x2d\x3a\xa5\xc2\x9e\xc5\xc2\x4d\xf3\xe8\x3d\x3f\x6d\x9a\x08\x66\x7d\x16\x33\x17\xff\xb7\xb3\xb0\x1a\x18\xae\xf1\x44\xdf\xf7\xd3\x20\xf7\x3b\x18\xf5\xd9\xe8\x2a\x64\x74\x60\x98\x77\xd0\x4f\x82\x73\x13\x0e\xd2\x7a\x32\x2e\xbe\x4c\x8a\xce\xda\xb7\x35\xe6\x52\xd7\xd2\xeb\xc8\xbc\x69\x36\x7a\xb5\x7a\xd3\x4c\xbf\x0a\x4e\x28\x05\x9b\xab\xb2\xe0\xfe\x29\xa6\x60\x47\x31\xbe\x21\xb7\xbd\x7b\x74\x70\x83\x82\x18\xde\xdf\xa1\x2a\x9a\xfd\xad\xc3\xc6\x8e\x3a\xb8\x74\x8a\xa9\xbe\x4d\xb5\xea\x93\x8e\x13\x7d\xce\x55\xe9\x1d\x0b\x50\x6e\x50\xfa\x72\xd6\x4d\x64\x8e\x99\x81\x76\x74\xe4\x0f\xe3\x93\x61\x62\x21\x41\xd3\x7c\xee\x9e\xe4\x4c\x24\x25\xbd\xb8\x81\x49\x96\xef\x66\x67\xb5\x6e\xb2\x78\x92\xef\x24\x0f\x26\xd7\x8b\xc0\x61\xc5\xb1\xe4\x62\xbb\x2c\xdf\x4f\x71\x30\xfa\x95\x8a\x66\x5f\xe3\x9c\xf2\xc7\x5f\x12\x7d\xb5\xa1\xf0\xe4\x0b\xa3\x23\x79\x15\x5b\xf5\x06\xbc\xe0\x19\x67\xfb\x45\x15\xbe\x7d\xfe\xbc\x6c\x40\x33\x7d\xf2\x70\xe2\xa1\x05\x69\xce\xf1\xc7\x8e\x4b\x94\x70\x7c\x5a\x20\x6f\x48\x09\xc0\x45\x8c\x91\xd2\xd1\x9f\x6a\x4a\x2f\x0a\xd4\xd9\x3d\xe2\xb3\xcc\x85\xce\xec\x28\x4d\x0a\x82\x8c\xce\xa4\x23\x1b\x59\x11\x7c\x75\xb6\x62\x8a\x9b\x85\x09\x11\x74\xc0\x2a\x74\x87\x3c\x4f\xe2\x8f\x3c\xb2\x5d\x2d\x8b\x6e\x87\xc8\xe0\x45\x07\x43\xc9\xe9\x65\xf4\xcd\x93\xb0\xcc\x3b\xf1\x8f\xf1\x8f\x2c\xef\xb9\x38\xff\x60\x8f\xd0\x88\xef\x9c\x1f\xdd\x24\x09\xe2\x24\xc8\x96\x8f\x9f\x88\xee\xdd\x32\xd1\x9e\x14\x0c\x49\x30\x66\xc9\xbc\x0f\x16\x1f\x63\x49\xde\x33\x1c\x72\xa1\xcf\xe5\x45\x95\xae\xa5\x9d\x08\xac\x1b\x30\xf3\x11\xbe\xb1\xc6\x63\x97\xdf\xbb\x07\xda\xbb\x84\xa7\x3e\x9b\xa0\xea\xac\xa3\xbc\xba\x4e\x07\xb9\x67\x77\x85\x5e\xbc\xf2\x4e\x72\x5a\x98\x91\x5a\xee\x23\xb7\x4f\xd7\x9e\xfd\xfc\x80\x2e\x2b\xa4\xf6\x2a\x73\x13\xa3\x69\xcb\x25\x97\x2e\xab\x22\xd8\x98\x99\xb7\x96\xa5\x9e\x44\x65\x77\xa0\x15\xd4\x56\xb0\x6e\x20\xf6\xd3\x4d\x13\xdb\x3c\x6d\xd4\x18\x54\xd0\x1a\x9a\xb6\x6b\xa6\x3b\x4c\xb9\xcb\x50\x60\x2f\x1d\x18\x91\x8e\xb8\x8d\x15\x26\x49\xe1\x90\x9b\x23\x1d\x9a\x29\xae\xf0\x24\x2d\x4c\x90\x75\x87\x6d\x1e\xef\x8b\x29\x58\x70\xf7\x2d\xa6\x4b\x2e\x11\x9c\x31\x3d\xff\x35\x7b\x2b\xcd\xfb\x80\x28\x49\x81\x8b\x8f\xee\x70\xeb\x8e\xfb\x86\x3e\x1b\x95\x3b\x94\x58\x6b\xf8\xaf\x2d\xd7\xac\xbd\x51\x30\xcc\x72\x2e\x19\xd5\x9a\xfa\xde\xaa\x4a\xb3\x64\x10\xd1\x89\xed\xf0\x54\xe1\x44\x6e\x45\x42\xc1\x26\xf9\x86\x41\x0a\xe9\x84\xfb\x38\x0c\xaf\x2c\xb6\x08\x86\xc9\x73\xda\x38\x11\x86\x96\x38\x5f\x2c\x75\x78\x30\x95\x17\x1e\x47\x2c\xff\xc9\x9c\x9b\x88\x79\x54\xe6\x2e\x95\x0a\x2b\x7d\x6e\xa1\xdd\xe0\xfc\x71\x5b\xf7\x0f\x6b\xae\x8e\x72\xe1\x52\x81\x12\xb4\xf5\xcb\x44\x09\xbd\x82\xce\x7b\x57\x28\x12\xf1\x68\xb0\x7c\x2b\x27\xaa\x80\x73\x53\x5b\xea\x30\x42\x96\x97\x6b\x89\xfc\x12\x6e\x64\x4a\x84\xd8\x63\x3c\x76\xf9\xe5\x66\xbf\x90\xff\x76\xb6\x85\xb5\x65\xc4\x28\x18\xd8\x39\x34\x56\x0f\x9b\x24\x00\x08\x66\xcf\xe9\xf7\x37\x07\x4e\x4a\xf8\x50\xc6\x14\xae\xf2\xd7\xb7\xd4\xcd\x2f\x12\x89\x3a\x8f\x32\x6d\x33\xad\x9c\x66\x29\x03\x84\x60\xd0\x4d\x5a\xdb\x4a\x5b\xc3\x03\xe1\xe7\xcf\x6a\x24\x74\x7c\x94\xca\x05\x79\x80\xdb\x5f\x45\x65\xf5\x51\xc2\xb1\xbe\x52\x75\x05\x98\xbc\xd4\xb5\x79\xfd\x00\xcf\x0c\xd3\x28\xe2\x3e\x4f\x53\x96\xcc\x31\xa8\x11\xf3\xc5\x2f\x81\xdf\x65\x90\x06\xe7\x41\x18\x64\x73\x18\x31\x0c\x96\xe4\x63\xc4\xc7\x81\xf6\x35\x40\xba\x8d\x50\xc4\xec\x93\x9d\xf7\xe6\xc7\x1e\x56\x1b\xcb\x32\x9c\x8b\xbb\x78\x5c\x9b\x35\xe3\x69\xd6\x8c\x87\x4d\x43\xb7\x9a\x95\x51\x38\x77\xe7\xbf\xe9\xa1\xe4\xd2\x07\x2d\x33\x16\xcb\xda\xbc\xf4\x60\x74\x9b\x3f\x49\x7a\x7c\xb5\x3a\x06\x3a\x83\x7c\x69\x1d\xe3\x4f\x0a\x5e\x85\x21\x0b\x16\x46\xae\xaa\xbe\x79\xc7\xed\x76\x7a\x8e\x4e\x6e\xaf\xe4\x5b\x2b\xe3\x43\xba\xf8\x02\x7f\xdf\x80\x91\x3b\xa3\xc2\x25\xaf\x12\x9c\x38\xd1\x7b\x1c\x30\x78\xd4\xc8\x61\xf0\xac\x04\x5e\x41\x5f\x38\x81\xbe\x13\x7c\xc5\x9e\xcd\x25\x1e\x16\x2e\x13\xb8\xc8\xb6\xca\x54\xac\x25\xc5\xc0\x5a\xb0\x7b\xc0\x99\x3f\xb2\x6c\x25\x26\xec\x85\x65\xbd\x26\x83\x0a\x06\x2e\x60\x69\x8a\x71\x15\x64\xfe\x9b\x20\x4b\xe1\x6c\x18\x9d\x99\xbc\xfd\x26\x90\xc4\x87\x11\x4f\xb9\x06\x63\x92\x98\xf8\x2c\x0c\xc9\xaf\x0b\xfb\xa6\x35\xe8\x49\xa3\x0d\x67\x51\x4a\x37\x82\xf3\x78\x8a\xb1\xdd\x04\x28\xb4\xea\xa8\x30\x5b\x94\x19\x73\xc2\x93\x61\x9c\x8c\x59\xa4\x5f\xa8\xea\x60\xf6\xfa\x93\xcf\x31\xd6\x43\xc8\x23\xee\x7f\x4c\xf5\x8b\x7c\x3d\x32\x45\x8e\xef\xa2\xdc\xd2\x17\x74\xfb\xaa\x04\x89\x8d\xd0\x92\xc2\x24\x3f\xe7\x14\x83\x64\x12\x4e\x31\x2d\x91\x8a\x9c\xcb\xc2\x8c\x53\x2a\x79\x1d\xd5\x2c\xc6\x98\x24\xca\xb0\x93\x5a\x33\x6a\x12\x5d\x4c\x53\x8e\x6e\xbe\x1c\x2f\xa8\x9f\x58\x31\x6d\xf1\xd5\x03\xc5\x44\x57\x31\x14\xce\x59\x1a\xf8\x9a\x11\x58\x18\x50\xec\xe7\x6d\x15\x67\xf7\x7c\x2e\xbd\x13\xce\x13\x96\xcc\xd5\x34\xfd\x98\x62\x6a\x52\xe4\x03\x8a\x51\xa5\x5e\x55\x38\xe9\xbd\xce\xf0\xe0\x7d\xe6\x11\x1b\xa2\x8f\x58\x8c\xe9\x82\x88\x27\xc9\x3d\xec\x40\x62\x42\x9e\x40\x76\xc6\xbf\x84\xbb\x53\x20\x99\x4f\xbb\xa5\x64\x57\x9c\x7d\x54\xc1\x7e\x85\x92\x43\xef\xa0\xed\x78\xbd\x14\x78\xc3\x50\x80\x8e\x00\x48\x7d\xb0\xd7\x9c\x22\x39\x1d\xd4\xac\x78\x71\x2a\xd4\x08\x66\x74\x8e\x13\x71\x02\x50\x71\x0c\xb5\x18\x22\x58\x2a\x0d\x9f\x9a\x12\x70\xb2\xcf\xb2\x41\xee\xb1\x56\x49\x44\x9d\xc2\x3a\x95\x20\xc4\xc2\x3f\x47\xe7\x1c\xe0\x01\x52\x89\x22\xd9\xd0\x4d\x3d\x85\xde\x68\x51\x6d\xb3\x07\x5b\x54\xc0\x0f\xb8\x6d\xe1\xdf\xed\x2d\xa0\x71\xf6\x95\x92\xb2\x8d\x7e\x77\xf1\x04\x3e\xd1\x95\xf0\x35\x59\x4c\xf6\xbb\x9d\x0e\x34\xe1\x25\xfa\x26\x28\x0a\xd9\x41\xf1\xd1\xfa\x18\x0f\xe5\xc5\xac\x18\x15\x02\x97\x06\x97\x3e\x74\x3b\x32\xf2\xbc\xd5\x83\x8e\x7b\x21\x9f\xee\xef\x63\xb8\x8b\x26\xfc\x3c\xa2\x00\x7e\xce\x6d\x9f\x79\xe1\x2f\xc6\x1a\xc5\x99\xea\x40\x96\x52\xca\xf2\x42\x1f\x46\x76\x5c\xab\x06\xc3\xa8\x4f\x83\xde\x42\xe3\x9d\xcd\x04\x1f\x90\x53\xa5\x8b\xa3\x23\x6d\x89\x1b\xac\x05\x07\x14\xa1\x66\x84\xf3\xcf\x66\x41\x4a\x64\xd7\x33\xa5\xc2\x7e\x38\x49\x45\xc9\x3f\xa4\x4f\x95\x9a\x70\x36\x99\xe1\xcc\x89\xd2\x90\xa7\xa9\xe7\xc4\x1e\x62\xa9\xf4\x54\xd1\xd5\xff\x4e\xf3\xfc\x77\xb1\x8e\x26\x3c\xf1\x79\x94\xb1\x0b\x0e\x09\x0f\x59\x16\x5c\xea\x64\xb2\xd2\xff\x40\xb2\x55\x59\xae\x04\x09\x6e\xb2\x0a\x9c\x7c\x02\x44\x09\xe4\xf2\xea\xcc\xc3\xa8\xad\xca\xf3\x97\xbc\x04\x95\xdb\xb9\xac\x34\xca\x57\x92\xce\x88\xba\x16\x55\xfd\x2e\x4e\x54\xaf\x18\xe2\x4e\x9c\x70\x39\x2d\x97\x31\x7a\xeb\xcd\x30\x96\xb1\x8b\xa6\xd9\xa3\x1d\x4c\x9d\xa5\xf3\x21\xb7\x6b\x49\xc7\x38\xc7\x11\x92\xc2\x32\x09\x02\xcb\x28\x44\x9e\x4d\x05\xb5\x2d\xca\x28\xab\xdb\xea\xb1\x41\x0b\x5e\x46\xe4\xf8\x1d\x0f\x65\xa8\x2a\x84\x41\x01\x8a\x3c\x08\x32\xbb\xa9\x1c\xb7\xcd\x2b\xbf\x60\xd6\xe7\xc8\x88\x63\xe5\x81\x47\x66\xd6\x3a\x4b\xe1\x8c\xee\xce\x09\x30\x5d\xa0\x9f\x35\x3c\x72\xd7\x73\x5d\xf8\x08\xa4\x68\x22\xab\x49\xbf\x2d\x94\xde\xcc\x38\xec\x09\x01\x52\x8f\x13\x8c\x96\xd4\xb0\x1d\xdb\xd2\x1c\xd9\x38\x84\x2c\xcb\x68\xfd\x31\xcb\xdd\x4d\xa5\xa6\xb6\x12\xef\x85\x9c\x91\x83\x9a\x90\xd4\xd3\x54\x6d\x94\x72\xf4\x04\x90\x12\x93\xe2\x5d\xfe\x65\xcf\xe9\xea\x40\xbf\xaf\x0b\xe7\x48\x35\xb5\x80\xd4\xc3\x3b\x99\x4f\x5f\x2a\x75\x58\x70\xce\xb3\x2b\xce\x23\x18\x04\x43\xe4\x71\xe2\x27\xb9\x12\xe1\x4d\x8c\x0e\x22\x2c\x83\xf1\x34\xcc\x82\x49\x18\xf8\xcc\x00\x12\x74\x49\x55\xcc\x2f\xb1\x6d\xe9\x24\x2d\xf6\xe4\xfc\x54\x16\x15\x0b\x67\xff\xec\x8c\xfe\xe8\x76\xe8\x7f\x6b\xdd\xce\xdf\x6b\xfa\x4f\x0f\xba\x1d\xf3\xeb\xef\xee\x4f\xd8\x01\xa7\x32\x34\xe1\xc1\xe5\x08\x76\x60\x57\x17\x36\xbb\x9d\xc9\x0c\x76\x44\xb9\x07\x0f\x26\x33\x68\xc2\x43\xf5\x51\x77\xfd\x14\xb6\xb7\xdf\x7c\xbb\xbd\xdd\x87\x97\x14\x9f\x6c\xc0\xd3\x80\x22\x75\x53\xc2\x1a\x75\x68\xc8\x62\x47\x55\xc0\x08\x93\xd2\x73\x57\x50\x87\xcd\x75\xa6\x91\xb1\x7a\x9a\xaf\x7a\x50\x1e\xae\x41\x52\x76\x51\x38\x8d\x86\x71\x92\x4d\x23\x96\x71\x31\x6b\x02\x07\x9c\x6e\x0a\x53\x19\xab\x14\xe4\x65\x51\x58\x5a\xaa\x87\xd7\x71\xc2\x69\x6f\x0d\x52\x38\x16\xdb\x23\xc5\x28\x12\x02\x20\x4d\xa7\xfc\xa4\x3e\xca\xb2\x49\xda\x6f\xb7\x2f\x82\x6c\x34\x3d\x6f\xf9\xf1\xb8\xfd\x1d\xff\xfd\xa7\x84\xa5\x19\x6b\x4f\x94\xb2\xd3\xc6\xda\x69\x7b\xf7\xd1\x6e\xc3\x9a\xc1\x65\xb7\x41\xa2\xd5\x8d\xfb\x60\x6f\xcd\x7d\xb0\xf7\x75\xed\x83\xd2\x0b\x23\x5f\x3b\xef\xab\xa3\x7d\x74\x40\x8b\x85\x5b\xfa\xe9\x80\xa2\xb7\xa1\x78\xa7\xb8\x0f\x17\x94\x31\x15\xa2\xd3\xda\x88\xec\x00\x9d\x3a\xf9\x10\xc4\xd3\x4c\xa7\x6a\x94\x66\x8c\xb9\xbd\xa0\x0f\x22\x48\x7d\x1e\xb1\x24\x88\x81\xcf\x82\x34\x4b\xe1\x6a\xc4\x93\x7c\x0c\x8c\x20\x4b\x79\x38\x54\x91\xbf\xc5\x22\x90\xa3\xb2\x82\x09\xd8\xd2\xeb\x67\x99\xc9\x87\xcd\x85\xe8\x1a\xb1\x14\xee\xd2\x25\xda\x20\xd7\xea\x2e\xfc\xd7\x7f\xfe\xdf\x62\xe6\xf0\x05\x86\xaa\x74\xd7\xd5\xf3\xe4\x62\xc0\x5d\xe5\x8a\xf2\x5c\x10\x9f\xf9\x18\xe6\xce\x62\x0b\x49\x8b\x74\x84\x8a\x30\xa9\x84\x7d\x6b\xb8\x4d\x18\xf0\x4c\x1c\xdf\x64\x4c\x44\x7b\x8c\x94\x7d\x12\xf7\xd5\xbb\x59\xc2\x26\x02\x0f\x28\x0c\x53\x6c\x33\x0a\x56\x20\xb4\x5d\xd5\x59\x70\x11\xc5\x89\x4b\x68\x04\x29\xc7\x44\x92\xc3\x51\x8e\xef\x5a\x88\xfd\x3c\xe2\x11\x9c\x95\x5c\x34\x9e\x99\xbc\x5d\x56\xda\x2e\x6b\x66\x52\xcb\x53\x80\x60\xa9\x39\xa7\xcc\x47\x06\x71\x3b\x3f\x97\x90\x4a\xea\x25\xbc\x0c\x05\xa7\xdd\x0d\x42\xce\x2e\x39\xc9\x8c\xdc\xe0\x9d\xe0\xfa\x92\x56\x2c\x13\x04\xb5\xb2\x8c\x0f\x2e\x78\x41\xd7\x6a\xdd\x42\x02\xe5\x2c\xb2\x37\x8a\xa2\xdd\x35\x45\xd1\xee\xd7\x25\x8a\x72\xc3\xd7\xcd\x94\xd0\x91\xad\xe5\x9b\x9b\x63\xe5\xdf\xb0\xaf\x0c\x54\xea\x85\x08\x99\x99\xf4\x4b\xe5\x13\xd5\xfe\xad\xc5\x09\x59\x32\xb7\xa5\x8a\x66\x0c\xa3\xa8\x67\x68\x15\x91\x9d\x08\x4e\x38\x9f\xab\xd7\x7c\x9e\x82\x98\x8d\x78\xe4\x99\x94\xc3\x1a\x8a\x3c\x28\xea\x30\x9e\x26\x6c\x26\xee\x83\x05\x3f\x8f\x33\x47\x2c\xaa\x81\xf5\x0b\xa6\x37\x13\xf9\x51\x0d\xae\x8a\x48\x8a\x51\xa4\x6f\xc9\xfe\x03\xf5\xfd\x60\x8c\x71\xa5\xe3\xa1\x7a\x6d\xe6\xf2\x0d\x83\x71\x10\x05\xe3\xe9\x58\xec\xdc\x19\x59\x66\xa4\x8e\xe5\x2e\x0c\x05\x4f\x3d\xec\x91\xcb\x8c\x8c\x43\xec\x23\x4f\x0b\xd1\xd6\x85\x4c\x64\xe1\x15\x3a\xf0\x42\x18\x64\x59\xc8\x15\x7a\x0a\x98\xdd\x95\x58\x55\xa9\x3a\x5e\xcb\x17\x2b\xd2\x67\x5e\x13\x8a\x5a\xf7\xe1\x41\x15\x19\x68\xff\xfa\xec\x24\x45\x2e\x50\x7f\xbf\x96\xfa\x49\x1c\x86\xe4\xff\x53\x53\x20\xac\xd8\x1d\x48\x24\x69\xfd\x50\xcc\xef\xa9\xa3\xf8\x99\xdd\xfa\xcc\x13\xc7\x82\x68\x10\x5f\x9d\x69\x2e\x39\x53\x67\x1e\x54\xdf\x59\x44\x46\x7f\x65\x22\x70\x46\x54\xc0\xad\x0f\x05\xe4\x6e\xda\x29\x1d\x1b\x5c\x4e\xda\x5b\x29\x17\xd2\x8c\xcd\x21\xe2\x2c\x41\xeb\x1e\x1a\x5c\xa4\x54\x52\xb9\x73\x85\x54\x14\x2b\x41\x60\x7c\xc1\x26\xce\xec\x64\x57\x71\x0b\x0e\x67\x13\xee\x07\x2a\xd1\xe1\x70\x1a\x8a\x9d\x29\x32\x19\x2c\x20\x90\x10\x95\x90\xc0\xe7\x70\x42\x45\x94\x06\x22\x96\x22\x9e\x01\xc5\xe0\x88\x03\x2a\x2d\xcd\xef\xd7\xb2\x2c\x20\x89\x60\x8c\x28\x9c\x03\x3b\x57\x39\x7e\xe9\xf5\x99\x38\x1d\x92\x12\x8a\x7b\x71\xa6\x35\x51\xa5\xf7\x52\x80\x58\x0c\x09\xbe\x55\xe0\x38\x37\x2b\x40\x25\x0a\xcb\x4a\x73\x3b\x32\xc4\x8d\xa2\xfc\xfe\x9a\xa2\xfc\xfe\xd7\x25\xca\xed\xb1\x97\x19\x59\x6c\xb7\xbf\xc0\x18\x39\x65\xf2\x5e\x2e\x73\x87\x28\xe9\x98\x33\x40\x48\x1e\x27\x58\x8a\x81\x82\xd4\x56\x02\xed\x69\x2d\xa6\x12\xcf\xad\x84\x02\x87\xb9\x66\xba\x78\x2a\x4e\xbf\xf8\xa6\x57\x09\x70\x17\x3b\x4c\xaf\x62\x22\xf6\x8c\xe2\x2b\x18\xb3\x48\xaa\x26\xf2\xa9\x51\x3c\xb4\x12\x48\x50\x00\x35\xb4\xa9\xe6\x6c\x46\x42\x46\x46\x31\xf0\xe1\x50\x3e\xde\x8b\xe2\x7c\x6f\x94\xd7\x12\x8f\xf4\x2b\x32\x24\xc2\xb9\x91\x13\x1f\xac\xc9\x89\x0f\xbe\x2e\x4e\xa4\x70\xf4\xf9\xca\x65\xfb\x02\x57\xbb\xc1\xf1\xac\x89\xad\x4e\x6a\x18\x87\x57\xe6\xdb\x89\x29\x57\x8e\xce\x9c\x4f\x12\x4e\xa1\xa6\xa5\xb5\x69\xbc\x84\xa8\xd6\x71\xbb\x88\x13\x6b\xa9\x65\x8f\x42\x51\x8a\x91\x30\x58\x42\x27\x78\x79\x30\x97\x29\x4b\xd0\x96\x52\x2a\xa1\xe8\xa3\x74\x5e\x48\xa5\x65\xd9\xd5\xad\x2c\xdb\xa6\xcc\xe3\x85\xc1\x3e\xdc\x3c\x52\x36\xb4\xed\xed\x37\x47\x1f\x0e\xfb\xdb\xdb\x39\x9f\x5d\x5c\x2a\x68\xb3\x4c\xa6\x13\x12\xc5\xfe\x34\x21\x4b\x0c\xb9\x7c\xf8\x73\x3f\xe4\xda\x0e\xa4\x10\x27\x1b\x7a\x90\xc9\x13\x05\x2d\x9d\x54\x27\xf5\x73\x89\xa3\xaf\x47\x57\xe3\x77\x01\xe0\x46\x76\x7f\xb8\x26\xbb\x3f\xfc\xba\xd8\x5d\x8c\xf9\x06\x65\x48\xea\xcf\xea\x1a\x69\x9f\x22\x3c\xd9\x27\x7b\x7d\xc3\xa4\x08\x42\x4e\x08\x15\x9c\xda\xca\x5d\x4b\x60\x1a\x5a\x52\x7c\xd0\xe0\xe3\xc1\x99\x0e\x11\x8a\x3f\x72\x71\x8e\xa5\x56\x64\x3f\x9c\x77\xde\x64\x07\x03\x05\xcf\x8a\x65\x5d\xc7\x7a\x74\x05\xc7\x42\x3b\xb4\x76\x4e\xa1\x92\x43\xb1\xa3\x32\xaf\xa4\x2f\x7f\xc8\x1d\x21\x29\x24\x2f\x32\xed\x28\x90\x1c\xab\x55\xd5\xa5\xb4\xfb\x4d\x29\xad\x4a\xab\x74\xa6\x4e\x6d\x71\x94\xcf\x18\x31\xb6\xb8\xd9\x3a\xd7\xba\x5b\xaa\xda\x3a\xed\x93\x8d\x33\xec\x88\x5f\xa2\xac\x50\xa9\x50\xd4\x89\x5b\x82\x51\x01\xbe\x8b\xe7\x83\x3a\x9f\xf9\x7c\x82\xeb\xdc\x4d\x5a\xa7\xd9\xbe\x71\xa3\x06\x6c\x8f\x74\x29\xed\xd7\x36\x12\x85\x3a\x63\x32\x16\xa3\x88\xa8\xbc\x19\x91\x12\xe6\x5b\x73\xd4\x53\x2a\x6d\x4e\x63\x91\x76\xcd\x41\xd1\xc6\x50\xa0\x91\x31\x2b\xac\xab\x51\xe2\xaf\x1b\x25\xda\xa3\x35\x25\xda\xa3\x65\x24\x1a\x7a\x04\xdd\x5e\xa4\x61\xf3\x65\x65\x9a\x22\xc2\x4d\x53\x3f\x52\x66\x3f\x35\x1d\xb4\x83\x96\x68\xf2\x02\x43\x97\x83\xa5\xb2\x46\x0d\x2d\x13\x9f\x56\x07\x53\x9e\x01\x83\xb3\x12\x0f\x29\x2b\xb9\xaf\x5c\x76\x3e\xd3\xa7\x0b\x17\x39\x29\xdc\xec\x14\x87\x37\x20\xac\x4e\x50\xe2\x9c\x13\x0f\x6d\xcc\xbe\xc0\x56\xbf\x34\x23\x8a\xc1\xdc\xc8\x87\x8f\xd7\xe4\xc3\xc7\x5f\xd7\xce\x3a\xa2\xa5\x9c\x63\x42\x99\x61\x2b\x95\x8e\x01\xf3\x50\x5e\x38\x29\x51\xc0\x26\x93\x30\x30\xa6\x42\xf7\xc4\x21\x4a\x2f\xb8\xd2\xe6\xb4\x77\x88\x39\xc7\xd8\x93\x6c\x2e\xb3\x4a\x34\x30\x31\xb8\x2c\x9e\xfa\xf4\x5c\xfa\xc5\xd1\x6b\xb4\x4a\xa1\x85\x79\x92\xf0\x09\x4b\x6c\x0c\x65\x7f\x69\x4c\xe0\xce\xf0\xaa\x08\xf3\x85\xe5\xae\xbc\xe9\x0e\x29\xc8\x5a\x74\x62\x93\xa1\x30\xa4\xbb\x3a\x9d\xf8\x09\x54\x20\x2f\x40\xc5\xc9\x5b\xa9\x6f\x09\x47\x31\xe8\x82\x97\x0b\xc0\x9f\xa6\x59\x3c\xc6\x48\x45\x48\x08\x04\x6a\x0f\xd6\x3d\x21\x8a\x53\xd1\xd9\xe3\x07\x9d\x33\xbc\xd7\x24\x3f\x12\x79\xef\x80\x12\x3f\xa0\x10\xd5\xe7\xcc\xff\x88\x72\xde\x8f\xc7\x13\x96\x49\x47\x4a\x63\xd3\x40\x6b\x1f\xbe\xb9\xbf\xe4\x09\xdd\xfc\x99\x14\x1f\xbf\xa5\xd2\x9e\x91\x39\x4c\x94\x12\x37\x62\xe6\x66\xe9\x32\x04\xe4\x51\x25\x75\xa2\x20\x92\x21\x3f\x61\xcc\x7e\x8b\x13\x07\xb4\xeb\x2c\xb3\xb2\x39\x58\x26\xb1\x43\xd2\xdd\xbc\xda\x1e\xac\xb9\xda\x1e\x7c\x55\xab\xcd\x1e\x7b\x95\x9e\xa4\xd1\xcb\xe5\xf1\x47\x34\x55\xdd\x97\x43\xea\x57\xac\x07\x74\x86\x12\x48\x0b\x01\xbc\x3b\x00\x9d\x41\x9f\xc9\xe8\x7b\x7a\xe9\xd9\x5e\x04\x0a\xd2\x91\x8a\x84\x64\xae\xf4\x75\x7e\x09\x93\xcf\x89\xee\xff\x8d\xe7\x92\xab\x8e\xe6\x30\xcd\xd1\x24\x37\xbe\x54\x5e\xbe\x1d\xcf\xf6\xb5\xbd\x57\x55\xf9\x99\xae\xac\x62\x60\x91\x3f\x92\xbb\xc8\x3f\xc8\x3b\xa2\xae\x73\x28\xc5\x09\x61\xd6\x68\xc1\xc1\xbf\x1f\xc0\x3f\xd4\x95\x1d\xc5\x27\xd4\x03\x7b\xae\xb4\xfb\x20\x95\x79\xae\x92\xdc\xb5\xd2\x05\x1a\xf3\x22\x60\x30\x08\x12\x4e\x36\x0c\x73\xe5\x8e\x37\x4b\x26\x63\x97\x35\xdc\x99\x89\xf3\xb9\xcc\x20\xc9\x2f\x74\xd1\x10\x7f\x51\x43\xcc\xbb\x59\xc8\x21\xfe\xf2\x45\x87\xa8\x32\x94\x59\x23\x9c\xeb\x4c\xa6\xc5\xbd\xe1\x00\x65\x3f\x71\x9c\xe4\xe7\x81\x4a\xfe\x5f\xba\x1f\x38\xd7\x94\xd2\x13\xee\xc5\xd1\x6b\x18\xb3\x28\x98\x4c\x43\x2b\x43\x59\x18\x8c\x83\x4c\x6d\x2b\x96\xa8\x94\x92\x5a\x8b\x67\x25\x99\x09\xa6\x6d\x7a\x15\x67\xf6\x0b\x8c\x14\x69\x9c\x05\x03\x8c\xe9\x02\x0c\x86\x09\x1b\x73\xa1\x17\x60\xdc\xbf\x80\x5f\x29\x31\xa6\x2c\xb8\x52\xa8\x4a\x58\x03\x1e\x62\xd8\x18\xed\x48\x58\x44\x1a\xcd\xba\xe5\xdb\x99\x4c\xad\x66\x3c\x05\xac\xf1\x78\xda\xbb\x34\x67\xd6\x2e\xf3\x45\x12\xdb\x04\x99\xf5\xe4\x22\xa6\x4b\x44\x38\x53\x71\x7f\xce\x94\x06\x64\x86\x2c\xb6\xb9\x01\x99\x9c\xc5\x78\xef\x58\x18\xfe\x9b\xe8\xb5\x14\x2b\x72\x1f\x21\xe1\x2a\xf0\x8b\xaf\x50\x78\x30\x7f\x14\x70\x69\xc0\x24\x47\x8c\x81\xb4\xe4\xdd\x46\xfa\x9b\x6d\xf3\x46\xd9\xff\x64\x4d\x4d\xeb\xc9\xd7\xa5\x69\x99\x91\x17\x5a\x7c\x27\x7d\x53\x75\x7d\x72\x21\xb5\xdb\x1c\x61\x49\x51\xdc\x58\x9e\x4b\x69\x20\x54\x6b\xb9\x53\x43\xb7\xd5\xed\xb4\x3a\xf2\x20\xa7\x02\x7b\x93\x93\x92\x60\x1e\x7b\x27\x3a\x73\xb3\x7d\xff\xff\x6b\x2b\xd2\x69\xba\x28\xf4\xa3\xc9\x3d\x85\x3e\x91\xc6\xb1\xf9\x4c\xc6\x99\x74\x43\xab\xe3\x45\x91\x5c\xfe\x41\xa4\x47\x62\xee\xce\xf4\x9a\x43\x8f\x74\x2b\x36\xfb\x05\xcf\x60\xc2\x52\x7d\x05\xa0\xbd\xa0\x23\xad\x36\x9f\xc5\xd1\xf3\x84\xa3\xe3\xb6\x74\x1c\xfe\x51\xfa\x71\xfb\x2c\x0c\x85\xde\x97\x1a\xc7\x5f\x30\xa8\x6e\xa9\x19\xc2\x39\x75\x9e\x9c\xe8\x67\x54\x38\x3c\x47\x06\x62\x71\xae\xa9\x72\x84\xc9\xbd\x09\x30\xaf\x38\x2c\x45\x5f\x45\xf7\xaa\x06\x50\x48\xff\x64\x01\x52\xdf\xc2\xb9\xb6\xaa\xc4\x94\x01\x2f\x07\x51\xf3\x9c\x93\x0e\xe0\x83\x58\xa6\xc1\xd0\xbe\x74\x3d\xe7\x3c\xd2\x79\x4b\xcf\x65\x3a\x01\xc3\xc8\x0b\x80\xe2\xa1\x55\x41\x2c\xbf\x4b\xa1\x93\xb4\x7b\x36\xf5\xd4\xee\x93\xc5\xf0\x31\x8a\xaf\xa4\x0d\xa5\x70\x42\x6f\xe5\x3a\x77\x2c\x5e\xc5\xd4\xb7\x6f\x8a\xe6\xf7\xf3\xb9\xfc\xa3\x62\x38\xce\x8c\xcb\xad\xf7\x20\x9a\xe3\xaa\xd3\xb5\x14\x99\x51\xdf\x58\x78\x70\xc3\xe5\xc6\xf1\x94\x40\xab\xf7\xdf\xd8\x25\x7b\x8f\xbe\x4d\x10\xc5\x63\x1e\xf9\x21\xc3\xb3\x40\x9d\x5f\xb4\xe0\x8c\x2e\x1a\xbf\x95\x19\x3e\x17\xa1\x86\x83\x78\xbf\x36\x7e\xf2\xb6\xe3\x4b\x61\x69\x99\x0f\xd5\x33\x5a\xd7\x8c\x68\x9b\xff\xaa\xc1\x28\xa7\x44\xb1\xf0\xac\x47\xaf\x08\xac\x10\x0c\x08\x17\x3c\xcd\xb1\x64\xb9\x34\xcf\x36\x65\xc0\xd5\xdb\x1b\x14\x87\x9e\x94\x85\x9e\x72\xd9\xf5\x4c\xd0\x70\xe5\x35\x7b\x33\x44\x83\xd2\x06\x81\xd2\x5d\x51\x51\x6a\xab\xe7\x5d\x74\xcf\x4d\x66\x75\x72\xcf\x54\x0c\x90\x53\x4e\x3b\xce\x5b\x92\x17\x64\xbd\xd4\x2f\x59\xd4\x8d\xa1\x60\x17\x4b\xf9\x89\xa3\x34\x4b\xa6\x7e\x16\x27\x85\xe7\x40\xca\xa0\x2f\x9f\x70\x44\x56\x36\xf3\x33\x09\xf5\x4c\x67\x73\x74\xcf\xd1\x16\x28\xeb\x0d\x08\x86\xfe\xa6\xa7\x4c\xa9\x38\xf8\xcf\x51\xe8\x8b\xa5\xbc\x9b\x0c\x0c\x24\xb3\xb1\xe8\xd0\xaa\x29\x1b\xa3\x38\x26\x5c\x05\xe3\xaa\x97\x4e\xea\x61\x8d\x74\xcf\xc5\x7c\xb5\xe8\x1c\xbb\x0d\x11\xbf\x92\x28\xd5\x13\x3e\xc4\x07\xd2\x9e\xd0\xa3\xb6\x01\xcc\x1e\xd3\x57\x25\x65\xbe\x57\x39\x6b\x25\x5c\x53\x55\xfc\x9f\xeb\x86\xd5\x95\xcc\x14\x2b\xe7\x37\x9f\x46\xb6\x2a\x01\xac\x9c\xa2\xc2\x33\x94\xb7\x85\x0b\x96\x2d\x5b\xd3\x90\x64\x36\x57\x21\x56\x8a\x4f\x7d\x4c\xd4\x4a\xa4\xfe\x64\x1f\xc4\xec\xde\x94\x3a\x87\x83\x4f\xa1\x9e\xf0\x94\x72\x91\xa3\xd3\x49\x43\xa6\x43\xc6\xec\xab\xe1\x5c\x51\x64\xab\x54\xf5\x21\x10\x87\x96\xba\xa8\xd1\x70\x3e\x29\x65\xd0\x46\xc3\xce\x76\x2a\xcf\x03\xda\x47\x64\x9a\xc5\x42\x97\xa0\x4c\xc7\xe4\x3e\x9e\x37\x9a\x9a\xe3\x8d\xaf\x74\x90\xb3\x01\x4f\xb3\x24\x9e\xab\xa7\x5e\xad\x72\xa4\x09\xde\x51\xf4\x82\x6a\x93\x5d\x5b\xe3\x9d\xfb\xaa\xed\xd6\x8e\x05\x50\x6a\x20\xea\xb9\x9c\x76\x81\x91\xf8\x05\x29\xf8\xa8\xbb\x0c\x1c\x17\x4f\xfb\x8a\x41\xfb\x3b\x42\x14\x37\xe3\x89\xeb\x15\x4f\x6f\x83\x8b\x0a\x0a\xad\x8f\x33\x47\x97\x39\x73\x47\xa9\xb4\xa6\x6b\x3d\x20\x55\x62\x85\xa8\x51\x45\xf5\x06\x7c\xca\x1b\x37\x6f\x1e\x1a\x5d\xf2\x0e\x3c\xe5\xaf\x2a\x1b\x48\xb7\x59\x6a\x27\x2d\xd8\x91\xd4\x0d\x91\x99\x82\xdf\x51\x3d\x6c\x23\x69\x0a\x91\x51\x3d\x38\x17\x3a\x05\x89\x3e\x2b\xb5\x2f\x41\xa2\x3e\xd3\x3f\x81\x9c\xa4\x75\xda\xe4\xa4\x12\x87\x9c\x54\x54\x42\x4e\x95\x64\xdd\xa8\xb8\x53\x5b\xe9\x25\xf7\x32\xb5\x39\xca\x93\xaa\x7e\x46\x59\xba\xdf\xb7\x94\xb5\x94\xcf\xf5\xeb\x91\xb1\x15\x8c\x36\xf7\x94\xcf\x11\xd3\xce\xd0\x34\x4a\x66\x6c\x96\x90\x34\x07\x55\x3b\x23\xad\x9e\x6c\xc5\x41\xb4\xdf\xb1\x84\x8d\x8b\x0f\x33\x9d\xdd\xc9\x6e\x4a\xd4\x5a\xa2\x69\x1b\x28\x0b\x73\xbb\x0d\xaf\x71\x45\xa7\x28\x46\xdf\xaa\x37\xb6\x26\x04\x42\xc3\x15\xa8\x84\x1c\x30\x6b\x4b\x70\x15\x7d\xa4\x83\x1f\x32\xcd\x17\x8a\x34\x84\x8f\xa5\x95\x7e\x36\xf1\x4b\xf3\x21\xe4\xe5\xcb\xd3\xa2\x82\xac\x1d\xd8\x8b\xe7\xb9\xca\x7e\x54\xf8\x7a\x09\x54\x7c\x71\xe1\xb1\xd4\xe5\x00\x05\xa3\xf8\x82\xf5\x17\x8c\x6d\x4c\xf6\x76\x55\x9a\x7f\x9a\x19\x47\x3c\xd5\x5a\x66\x10\xc1\xb1\xda\x9b\x4e\xea\xff\x22\x57\x55\x2a\xbd\xa3\xe5\x4b\x57\xd3\x93\x5e\x3f\x84\xaa\x79\x6d\x5b\x41\x69\x74\xcc\x50\x53\x65\x36\x68\x15\x13\x4d\xbe\x8d\xb6\x43\xdb\xa0\x64\xd9\x47\x01\x63\xa7\xed\x93\x63\x29\xcd\x43\xdd\x73\xf3\x50\xf7\x16\xe5\xa1\xee\x9d\x40\x1f\x3e\x5d\xcb\xf4\xa7\x82\x0b\x84\xd8\x7b\x3e\xe2\xfe\xc7\xba\xe8\xd3\x93\x58\xaa\x2c\x5a\xa2\xac\x95\xfa\x23\x3e\x98\x86\x9c\xb8\xb7\x84\xfb\xc0\x4e\xce\xf1\xcf\x29\x4f\xb3\x83\x28\xa0\x23\xf1\x77\x09\x1b\xf3\x3a\x0e\xab\x45\xa2\x4c\xc5\xa8\x32\x09\xfd\xd0\xd8\x35\x55\x82\x64\xc0\x85\x62\xed\x0b\x31\xab\x2e\x6d\x02\x29\x1e\x93\x69\x94\x02\xcb\xe4\xaa\x8f\x7c\xde\x9c\xf0\xa4\x99\x05\xfe\x47\x83\xec\x54\x21\xa9\xe0\xd4\xad\xe2\xd6\x79\x10\x0d\xb0\x40\xe7\x09\xc3\xb0\xfc\xd9\x08\x3e\x5d\x63\xdc\x60\x7b\xf9\xe4\x55\x33\x35\x0b\xd2\x72\x48\x4f\xf9\xa8\x57\x33\x41\x4e\xa0\x1a\xc9\x16\x8a\xc3\x4c\x0c\x44\xd3\x79\x40\x09\x80\x50\x2c\x68\x82\x67\x34\x04\x1d\x93\x37\x95\x7b\x72\xee\x36\x59\x7c\xa1\x05\x9f\x2f\xb7\xdd\x68\xd3\x3e\x1c\x9f\xe4\x69\x8e\xe9\x36\x9c\x63\x87\x6b\x64\x4c\xa1\x4e\xd1\xc2\x7f\xfb\x5f\x53\x9e\xcc\xe1\x0a\x5f\x4c\x24\xb4\x32\x08\x4b\x3b\xc0\x82\xf9\xfb\xde\x3d\xeb\x59\xc0\x6f\xff\xc4\xc6\xcf\xac\xc0\x05\x1d\xc1\x81\x4e\xe0\x17\x09\x2e\x17\xe0\x4b\x00\x52\x8f\x9d\x14\x14\x19\xd1\x00\x41\x38\xa1\x99\x30\x05\x00\x9f\x50\xc0\x69\xfb\x3a\x4b\xbd\x5a\xcf\xcd\x53\xcb\x79\x17\x2d\x97\x03\x2d\xf2\xd6\x47\x3e\x4f\xeb\x8b\x66\xd1\x0e\x45\x53\x80\xd7\x68\x94\x44\x5b\x8b\xd8\xd8\x8a\x5b\x72\x5a\x8e\xc9\xb1\xa8\x75\x72\x03\x07\x15\xaa\x7f\xfe\x2c\x76\xde\x22\x1e\xf0\xac\x58\x26\x9b\x08\x01\x60\x85\xa2\x56\x04\x7c\xc7\x87\x4c\x1c\x8e\xf0\xf6\x4f\x35\xa9\x91\x6f\x52\x9d\x68\x03\xfb\x4f\x01\x1d\xaa\x2c\x2e\xb0\x29\x69\x53\xb0\x7c\x90\xf9\x24\x0f\x2e\x65\xa4\x0c\x31\x04\x90\xe5\x00\xa2\x5e\x1f\xff\x2b\x8b\xae\xbd\xc5\x74\xd4\x03\x54\xc3\x4b\xe3\x24\x7f\xd9\x79\x3e\x27\x9b\x30\x56\x69\x89\x0a\x95\x41\xda\x75\x14\x72\x32\x2f\x37\xe1\x9c\xfe\x2a\x92\xd1\x80\xa7\x57\x81\x23\x0e\x4c\x06\xb9\xc1\xec\x31\x14\xc8\x9b\x25\xe7\x41\x86\x77\x0c\x7e\x4c\x6f\x9c\x22\x6b\x0f\x11\x8b\x53\xc8\x05\x19\x09\x47\x60\x3f\xf5\x47\x54\x35\x48\x15\x10\xfd\xf4\x4c\x1c\x19\x8d\xdd\x3b\xc8\x52\xd7\x70\xeb\x26\xb5\x60\x83\x01\x0a\x37\x2b\xdc\x00\x69\x59\x81\xd9\x66\x9c\xd8\x03\x0a\xc6\xb7\x87\x70\xf0\xf3\xc1\xbb\xc3\xbe\x8c\x7b\x20\x00\x59\x7b\xec\x59\x61\x22\x30\xfa\xd2\x19\x2a\xb7\xe2\xbb\x2a\x3f\x92\xe7\xe9\x3b\x25\x3c\x54\xb2\x76\x72\xcd\xdc\x40\xe5\xb9\x8f\x2d\x65\x97\xbf\x77\x0f\x82\x54\x99\xcf\x0b\xb5\xc8\x8c\xee\x84\x35\x2f\xaf\x22\xf7\x2d\x6b\xc7\x3e\xb5\x44\x55\x8e\x03\xbd\x3c\x10\xf5\x1d\xa5\x79\x49\xf8\x73\x45\xd8\x61\x20\xaf\x79\xc8\xad\x5f\x6e\x60\xe5\x4a\x94\x9a\x72\x0a\x21\x85\x07\xde\xfc\xd6\x57\xb7\xf3\xfd\x3a\x67\x51\xa9\x57\xe8\x25\xe3\x7c\x34\xb9\xaa\x9c\x62\x27\x6b\x6b\xca\xb3\xe9\x84\x60\xa2\x5c\x10\xea\x0f\x3d\x3c\x9b\xcb\x87\x46\x62\x27\xf7\x19\x19\x2d\xd4\x40\x10\x79\x39\x92\x20\x52\x91\xff\x7c\x48\x83\x6c\xca\x8c\x7c\x96\x83\xa0\x29\x3c\x14\x7d\xbc\x52\x5d\xd4\x1b\x4e\x80\x27\x43\xd5\x56\x7e\x7c\x85\x21\xa9\x3c\x24\xf4\x62\xb1\x86\x1a\x25\x29\x3e\xf6\x0a\xb0\x32\x83\xcf\x25\x7b\x8b\x35\x88\x63\x54\xcb\x8c\xe0\xe8\xa6\x59\x4c\x91\x67\xa2\x01\x25\x49\x83\x34\x9b\x0e\x87\x14\xba\xf7\x7d\x10\x89\x93\x5c\x36\x3d\x4f\xb7\x44\xff\xa4\x55\x3c\x17\x4d\xeb\x6f\x25\xef\x1c\x13\x5d\x3f\xf2\x79\x1f\x6a\x44\x2a\x79\x6d\x8c\xf6\x34\xeb\x90\x45\x1f\xff\xf6\xb7\x6e\x51\xdb\x92\x5a\x8d\x38\x61\x90\x56\x63\xc5\xff\xf4\xc0\xee\x41\x1a\x08\x2a\xba\x90\x5f\x4b\xfb\x90\xdf\x96\xe9\xa4\x6c\xee\x2a\x7a\x2c\xab\x5a\xda\x7d\x59\xc5\xa5\x06\x4c\x77\x99\x4b\x21\x53\x5a\xb7\x9c\x18\x65\x35\x4b\xd0\xc9\x5f\xc8\xbd\x97\x2a\x34\xb0\x48\x87\x16\x52\x97\x59\xc9\x34\x52\xf6\x02\x8c\x2b\xfd\xe3\x4b\xb5\x74\xd8\x25\x0b\x42\xd1\x9f\xbe\x80\x93\x61\x08\x5c\x8d\xdc\xfa\x9a\xb3\xbe\xc9\x1b\xb0\x02\x3a\xcf\xe3\x30\xe4\x3a\x8e\xd2\x34\x0b\xe4\x91\xd9\x7e\xd8\x74\x95\x04\x19\xe6\x4f\xa2\xe3\x94\x91\xd1\x7a\x4c\x19\x4b\xb0\x06\x9a\x64\xcd\x05\xe3\x23\x1d\x35\x09\x71\x0d\x52\x33\x0e\x52\xe3\xc9\xe6\xa5\xc0\x04\x91\x1f\x4e\x07\x1c\xce\x48\xc2\x35\x05\x36\x69\xeb\xb7\x54\xdf\x5f\x9f\xe9\x37\xef\x67\xaa\x6f\xd5\x76\x7b\xfb\xc5\xe1\xdb\x77\x87\xcf\x0f\x3e\xbc\x3c\x7a\xb3\xbd\xdd\x27\x87\x00\x7c\xea\x1f\xab\x40\x73\x44\x0b\x3c\x4e\xa3\x2f\xab\xbe\x19\x55\x40\xac\xa8\x0d\x6e\xc0\x86\x3b\x98\x47\x2c\xd3\x37\x66\x04\x63\x1c\xe3\x44\x92\xe3\x84\x18\x8d\xcc\x7b\xa4\xc0\xbd\x98\xea\x50\x1d\xa3\xe0\x62\x44\x07\x42\xa9\x01\x48\x4b\x05\x51\xc6\x3c\xf4\xc3\xfe\x10\xba\x4c\x3a\x18\xd5\x32\x05\xee\x62\xca\x12\x16\x65\x5c\xc6\x2b\xc8\x62\xf9\x6a\x13\x52\x3e\xbe\xe4\x49\x4b\xe1\x38\x06\x26\x03\xb6\xc4\x57\x11\x24\x41\x4a\xd7\xfb\x60\x1b\x68\x41\x59\x41\x64\xa2\x39\xf9\x3b\x67\xd1\x85\x1b\xaf\x90\x1f\xe7\x38\x4e\x1a\x2b\x6e\x64\x43\x80\xeb\x13\x3b\xe3\xc7\x5b\xa9\xc3\x5f\xe3\x9e\x65\x5f\xc0\xe6\x4c\x0f\xb9\x5b\x58\x3c\x14\x4a\x13\x10\x65\x01\x8c\x32\x9e\x0c\x99\xcf\xb5\x37\x5c\x28\x6d\x5c\xce\x45\x2c\x06\x58\xe7\x59\x8a\xc6\x53\x19\xc6\x03\x03\xb7\x3b\x31\x55\x18\x46\x83\x47\xb7\x8e\x28\x1e\x70\xcb\xc2\xaf\x62\x97\xd0\x56\x61\x58\xdc\xde\xab\x99\xda\xa9\x55\xdc\x96\x90\x98\x51\x45\xa5\xf2\xe3\x38\x19\x04\x11\xcb\xe8\xca\xc4\x76\x26\xa4\x8d\x47\x06\x3a\x53\xdd\x8b\xc6\x98\x6a\x2b\x75\x9e\x5b\x6f\x57\x5a\xff\x6d\xba\x29\x13\xc3\x9b\x78\x80\x1a\x88\x6a\x22\xfe\x7a\xf3\xad\x5c\x2e\x43\x4e\x17\x64\x41\xea\xc4\x05\x11\xa8\xbd\x14\x74\x8d\x78\x06\x87\xb3\x49\x18\x27\x3c\xc1\xf8\x1f\xea\xea\x39\xd7\x59\xee\x06\xc8\x78\x2f\xa0\x99\x51\x05\x8f\x0f\xa2\x0b\x13\x1d\x0e\xa3\x60\x19\x39\x8c\xf3\xaa\xa2\x8b\x95\x51\xac\x30\xbd\x28\x34\x29\x3c\xce\x59\x69\x0f\x96\x45\xdc\xc1\x4e\xf9\x94\x20\x6e\x56\xe6\xcb\x2d\x0a\x9a\x70\xf8\xfe\xa1\xd0\x00\x28\x0a\x19\xd3\x8f\xe4\x28\xff\xcf\x48\xa6\x06\x54\xcb\xf9\x32\x48\xb2\x29\x0b\x4b\x3d\xde\x6f\xea\x94\x12\x5c\x2d\xd9\xab\x8c\x22\xb4\x4c\xb7\x42\xe8\x4b\xde\x27\xb1\xb5\x0f\x75\xb1\xce\xe3\xa1\x4c\xed\x89\x46\xa2\x9a\xb6\x12\xd5\xe0\x99\xfa\xd0\x87\x8b\x30\x3e\x67\x61\xa3\x65\x89\xbd\xbd\xad\xc2\x5d\x8c\x1d\xcb\xd1\x7c\xb7\x6e\x7a\xd4\x9f\xb8\xb6\x61\xc4\x92\x71\x1c\x69\xcb\x35\xf0\x19\x46\x46\xda\x6e\xc3\xe9\xe9\x15\x3f\x9f\x30\xff\xe3\x29\x95\xa5\xa7\xa7\xc7\x77\x65\xb5\xbb\xe2\x44\x5c\xd7\x46\xa9\x76\xfb\x5f\x20\x8d\xa7\x89\xcf\x5f\xb3\xc9\x24\x88\x2e\x7e\x7c\xf7\x6a\x5f\xef\x0f\xe2\x70\x89\x7d\xfd\x7c\xf8\xed\xdb\x83\xe7\xff\x0e\x3f\x1d\xbc\x83\x97\x6f\xfe\xed\xf0\xb9\xd8\x1f\x60\xbb\x7d\x4d\x5b\x75\x49\x87\x9e\x85\x45\x42\x1e\xe6\xa7\xa7\xf5\xfb\xdd\x46\xa3\x81\x92\x69\xbb\x0d\xd7\x0d\x4f\xc0\x7e\xf8\xa8\x27\xc8\x4b\x65\xfa\xa0\x52\xa7\x6d\xc1\x93\xc3\x4a\x4b\xe1\x09\x75\x62\xeb\xae\x58\xcd\x69\x96\x04\x7e\x76\x77\x6f\x6b\x6b\x4b\x1e\x9a\x73\xb1\x95\x35\x98\xbb\xa7\xa7\x3c\x7d\x8d\xc0\xef\x7a\x32\xec\x26\x6a\x2f\x78\xe7\x84\xe7\x08\x34\x1c\xca\x33\xb3\x39\x85\x53\x4c\x44\xf8\xfc\xd9\x32\xd7\x65\x2c\xb9\xe0\x59\x03\x3e\xc1\x30\x4e\xa0\x8e\xa1\x2f\x61\x1f\xba\x7b\x10\xc0\x37\x05\xdb\xe2\x1e\x04\x3b\x3b\xa2\x32\x06\xb8\x44\xaa\xdb\x16\xc8\xe3\xe0\x64\xcf\xc0\xf9\xc8\xe7\xa8\xdd\x63\x35\xd1\x48\x1c\x25\x24\x2a\x5a\x5d\x6e\x8d\x58\x7a\x74\x15\xa9\x51\xd2\x6c\x50\x13\x4f\x40\x10\x67\x32\x20\x24\x8f\x3f\xf2\xb9\x98\x7b\xfa\x8a\xbf\xf6\xe0\x1a\xff\x4f\xad\x08\xac\xb7\x87\x56\x2d\x24\x41\xc2\x19\xc6\x18\x2e\x9b\xc9\x6e\xc3\xa9\xd5\x13\xd5\x70\xd7\x88\x27\xf2\x41\x81\xe4\xd6\x3a\x55\xd0\xd5\xc5\xea\xfd\x30\x9f\x60\x1e\x8a\x32\xc0\x9d\x62\xcd\x45\xc0\x75\x25\xd1\x4c\x4f\x4c\x45\xed\xf8\xfc\x37\x41\x10\x95\x1f\xeb\xfc\x37\x71\xb0\x8d\xcf\x7f\x6b\x19\x9e\x80\x67\x58\xde\x87\x4f\x3a\xfb\x32\x16\x5c\xef\x09\x2d\xd4\x74\x40\x3b\xe7\xcf\xf4\xd8\xfd\xad\x3e\xf9\x88\x2e\x90\xf2\xa9\x9a\x67\xa2\x2a\x99\xc5\x6c\x2e\x09\x10\x01\x35\xb1\xa2\x85\x0e\x69\x1a\x34\xe0\x29\xe6\xa5\x16\xfa\x4c\x10\x4d\xf9\x1e\xc5\x96\x5e\x6a\xf6\x11\x81\xa0\x61\x37\x96\x0c\x10\x88\xe9\x8f\xcf\x7f\x43\x3e\x2b\xce\x3a\x51\xfd\x00\x9d\x25\x2c\x93\x34\x16\xd4\x31\xc8\xa2\x87\x30\xf9\xcc\x4a\x18\x8b\xf4\x4f\xff\x26\xb6\x91\x38\x92\xf1\x68\x31\x1e\xa3\x2e\x51\x16\x54\xbb\x4a\xb1\x55\xce\xc0\x5e\x4b\x27\x2c\xaa\x41\xbf\x50\x53\xdb\x69\xa3\x88\x27\xef\xf8\x50\xf7\xa7\x0a\x74\x77\xa3\x20\x1c\x24\x3c\x32\x08\xc9\x02\x13\xce\x36\xc5\x79\x43\x3e\xac\x9a\x4d\x39\xec\xe3\x9a\x46\xa0\xe6\x41\x4d\xf5\x25\xfe\x56\x60\x6b\x27\x0d\x1d\xbb\x56\x5b\x5e\x25\xb9\xf2\x69\x52\xd0\x6d\x83\x90\xd7\x64\x56\x65\x75\xa1\xa3\xe4\x52\x2b\xa5\x3c\xc3\x59\x10\x5a\x07\x7d\x37\xc6\x05\xb9\x07\x19\x7a\x88\x5d\x48\x41\xb5\x32\x63\xab\x0a\x76\x7b\x99\xd6\xc2\x42\x0a\x9d\x88\xb4\xc9\x58\xe8\x18\x07\xba\xb8\x6e\x12\xa6\xca\x4e\x0d\x8d\x4b\x3b\xd5\x50\x15\x99\xcd\xd9\x6f\xd8\xd7\x03\xd6\x16\x76\x72\x56\x35\x68\x28\x0b\xbb\x75\x5a\x54\x1d\xd6\x3f\x59\x80\xfb\xd6\xdf\x9e\x99\xd6\xbe\x35\xc3\xd7\x6e\x12\x1e\x3d\x99\x7a\xfe\x6d\x0b\xb1\x6e\xa6\xce\xbf\x12\x33\xa7\x92\x41\xd3\x6a\x40\x3e\x62\x0d\x93\x70\xc3\xa6\x95\xc3\xeb\x35\x72\x5c\xaf\x99\xec\xb1\x36\x46\xad\x04\x79\x43\x51\xa8\x10\x0a\x3c\x57\xdb\x5a\x0b\x4e\x13\x2b\x42\x70\xbd\xe3\x49\x41\xdd\x22\xdb\x89\x4a\x11\x54\x37\x2b\x2b\x07\xd6\xd3\xd4\x6e\xec\xe1\xcd\x2d\x72\x42\x4b\xb2\xb4\x92\xe0\x9f\x74\x9c\xe5\xbe\x2d\xb0\x5b\x52\x76\xb6\x68\x61\xb5\x82\x54\x45\xc3\xb7\x40\xd9\x3b\xc1\xa7\x2d\x6b\x58\x15\xa0\x22\x7e\x34\x14\x65\xf5\xe3\xb2\xcf\x82\xaf\xbd\xd2\x86\x82\x31\x29\xf1\x82\xa2\x54\x79\x07\xa2\x9e\xa8\xa5\xc6\xfd\x45\xd0\xc0\xf1\x4b\x65\x44\x7d\x82\x7d\x92\xb2\x7b\x05\xcd\x68\x77\x83\x9a\xd1\x02\x35\xce\xc0\x96\x9a\xaa\x68\xbd\x21\x3d\xea\xcb\x28\x11\xe2\x7c\x55\x0e\xb3\xf7\xd8\xa9\xb5\x50\x77\x98\x26\x5c\x57\x7e\x7f\x79\xf1\xd2\xc7\x24\x2c\xa5\x50\x1f\xe4\x2b\x2e\x02\x2c\xab\xfc\x21\x2a\x89\xc0\x49\xf6\xf7\x9c\x2c\x4b\xfb\xf2\xbc\xd1\x3a\x3d\x7d\xfd\xe3\x4b\x85\xcc\xe9\xa9\x50\x5d\x35\xf6\x8a\xf7\xcc\x04\x0c\x29\x3d\xa5\x98\x07\xcd\xb3\x8e\xb0\xa8\xd7\x26\x2c\x1b\xd5\x3c\x81\x47\x1f\x6a\xaf\xbb\x0f\x5a\xf7\xbb\xf0\xa8\x75\xbf\xfb\xaa\x7b\x1f\x1e\x86\xcd\x87\x40\xff\xd7\x6d\xdd\xef\x36\xbb\x58\xde\x69\x3d\xde\x85\x6e\xef\xf7\x1a\x68\x8e\x78\x3e\xe2\x97\x49\x1c\xbd\xe2\xc3\xcc\xde\x00\xad\x62\xda\x76\x49\x36\xaa\x2b\xac\x85\x88\xa1\x54\x74\x88\x40\xbb\x0a\x6d\xdf\xf8\xa7\x18\xe0\x16\x80\x94\x65\x2e\x0e\x28\x1d\x91\x59\x14\xfc\x46\xdd\xaa\xd1\xd8\xb3\xeb\xb7\xc6\xd3\xe0\x0d\xa6\xc1\x80\x9a\xec\xb2\x56\xba\xa4\xad\x36\x0b\x17\x9f\x3c\x43\x2d\x5a\xcd\x15\xe7\xa6\xfb\x7f\xee\xb9\xa9\x6a\xc5\x5b\xd6\xf9\xbc\x6f\x83\x6d\x21\xb7\xba\x11\xaa\x16\xe9\xa1\x14\xe6\x3c\x2d\x9c\xa8\x3a\x74\xa2\x22\x55\xae\xe4\x34\xa5\x82\x44\xc6\x89\x52\xf8\x50\xcb\x35\xc5\x2d\x1e\x4d\xc7\x3c\x41\xa3\xe9\x7e\x45\xb9\x38\xda\x61\xae\x0a\xfb\xbb\xbe\xbb\xa3\x96\x98\xcc\x03\x37\xf6\xbb\x38\x7a\x0c\x79\x68\xaa\x37\xec\xa6\x57\x49\x90\x39\xcd\xca\x49\xac\x46\x6e\xb5\xfc\xc8\xe7\xf6\xef\xc6\x9e\x7d\x4e\x33\x14\x7d\x6e\x5c\x70\x3d\xba\x43\x91\x5b\x37\x19\x28\xdf\x2a\x52\x62\x2a\x37\xfd\xb9\x51\x24\xbe\x05\xc8\x1c\x2f\x6c\x90\x0d\x1a\xb3\x03\x77\x11\x14\x17\x85\x3d\x85\xba\x55\x63\x0f\xe5\x57\xfd\x0b\xef\x13\x5f\xf0\xb0\x49\xbc\x2e\xb8\x1c\x03\xc6\x57\x6d\x1c\x25\x55\x17\x75\x61\x6a\xe9\x86\xf2\xe5\x41\x39\xfc\x07\x66\xbb\x3b\x98\x4c\xbe\x65\x49\xe5\xb6\x78\x3f\x57\x71\x11\x16\x54\x43\x37\xf8\x10\xc7\xe1\x79\x25\xe8\xee\xe3\xc7\xf9\x9a\x8b\x60\xcb\x2a\xa6\xc9\x7c\x12\x5f\x24\x6c\x32\x9a\x57\xc0\xbf\xdf\x29\xa9\xbb\xb0\x07\x5d\x4b\x37\x14\x62\xfa\xdb\x69\x96\x55\x6e\xf0\xdd\xdd\x4e\x49\xe5\x45\xbd\x98\x5a\xba\xe1\x6b\x1e\x4d\x2b\xe0\x3f\x7c\xf4\xc0\xa9\xb6\x08\xb2\xf8\xae\x2b\x3f\x8f\xc7\xe3\x4a\xac\x9f\x3c\xf8\x83\xcd\x1e\x39\x17\x37\xe5\x9c\xe7\xd9\x2b\x5b\x49\x9c\x3b\xfa\xb3\x76\xe2\x8b\x87\x4e\x45\xb4\x4e\x8d\x92\xf8\x0a\x4d\xee\x62\x65\x1d\x26\x49\x9c\xd4\xef\x3e\x67\x91\xf2\x00\x06\x26\xef\x88\x59\x6a\xa5\x2b\xb9\x4b\x22\xd1\x46\x6d\x12\xa7\x69\x70\x1e\x72\xab\x83\x77\x38\xe2\x7a\xca\xc3\xa1\x87\xc0\x34\x6a\xa2\xc8\xed\x5d\x47\x90\x95\x28\xe0\x7d\x84\x4c\xa3\x84\x6f\xa0\x94\xef\x71\xca\x07\xd0\x84\x74\x3a\xe1\x49\xbd\xe1\xd4\x20\x87\x65\x42\x4d\x9d\x58\xc5\x08\xee\xdd\x33\xc7\x40\xf1\x5b\x9c\x00\xef\xd2\xc9\xe8\xae\xd8\x74\x0a\xdf\xcc\x28\xe1\x19\x15\xf7\x41\x60\x9c\x9b\x8c\x20\x1a\xf1\x24\xc8\xd2\x7a\x3a\x3d\xc7\xed\xd6\x23\xb4\xf0\x6f\x35\x54\x09\xdc\x7c\x40\x43\xb5\xe9\x42\x60\x97\xfb\x18\x4d\x89\x52\xa5\x53\xf3\x7e\x8a\x5e\x6d\xb3\x49\xc2\x53\xbc\xbe\xc2\xf7\xb5\x32\x9b\xc4\x39\xc7\xc6\x14\x5a\xde\x64\x9f\x11\x73\x79\x17\x76\xa0\x80\x0b\x92\x4a\x61\x6f\x76\x1e\x63\x74\x25\x5d\xa2\x6e\x21\xe8\xa0\x6b\x6f\x56\x9f\xec\x17\x29\x7d\xd4\x0b\x50\x3b\x31\xc4\x31\x5b\xbd\xf2\xee\x03\xb5\x45\xcb\x67\x05\x60\xef\xf6\x54\x26\xd8\x4c\xed\x7e\x16\x71\x25\x7e\x29\x17\xa7\x65\x42\xe1\x68\x08\xcf\xca\xcb\x2b\x26\xc8\xe0\xd6\x3a\x3d\xc5\x91\x9c\x9e\xc2\xbe\x55\x45\x50\xa7\xdd\x86\xe7\xf1\x64\x4e\x0e\x2a\xbd\x4e\xf7\x11\x79\xca\xc6\x4d\x7c\x7a\xc1\xa7\x63\x38\x98\x66\xa3\x38\x41\xdf\x66\xba\x7f\x0a\x42\x74\x6b\x9a\x60\xa2\x11\xba\xdb\xb0\xeb\xeb\xa0\x12\xed\x36\xb5\x29\xfd\x2c\x20\x0c\x13\xce\x21\x8d\x87\xd9\x15\x4b\x78\x5f\x87\xc6\x4c\xf8\x20\x48\x55\xd0\x9a\x00\x23\x22\xb6\x63\x99\x1b\x65\x2e\x40\x06\x19\x5a\xf3\xe8\x9d\x6f\xc6\x93\xb1\x7e\xea\xf5\xfd\x9b\x1f\xe1\x15\x4f\x53\x9e\xc0\xf7\xe8\xec\x1b\xc2\xdb\xe9\x79\x18\xf8\xf0\x2a\xf0\x79\x44\xf7\x72\x13\x51\x92\x8e\xf0\xbd\xe1\x16\x79\x5b\xc1\x77\x02\x95\xf7\x12\x15\xf8\x0e\x9f\x8a\xc9\xd4\x46\xc4\x7a\xea\x36\x75\x57\x75\x25\x01\x62\x00\xea\x76\x1b\xea\xfa\x3a\x17\xbd\x75\x1a\x18\x98\x34\x64\x99\x69\xba\x04\x41\xcc\xb8\xb5\xb3\xd8\x28\x9e\x70\xed\x55\xab\xae\xbd\xe9\xde\xdf\x13\xd0\xce\xa7\x19\xfc\xfc\xf2\xc3\x0f\x47\x3f\x7e\x80\x83\x37\xbf\xc0\xcf\x07\xef\xde\x1d\xbc\xf9\xf0\xcb\x9e\x8e\x94\xca\x2f\xe5\xc3\x88\x60\x4c\x5e\xfa\x57\x2c\x49\x58\x84\xd7\xdb\xe8\xb0\x7e\xf8\xee\xf9\x0f\x07\x6f\x3e\x1c\x7c\xfb\xf2\xd5\xcb\x0f\xbf\x88\xc5\xf5\xdd\xcb\x0f\x6f\x0e\xdf\xbf\x87\xef\x8e\xde\xc1\x01\xbc\x3d\x78\xf7\xe1\xe5\xf3\x1f\x5f\x1d\xbc\x83\xb7\x3f\xbe\x7b\x7b\xf4\xfe\xb0\x05\xef\xe9\x82\x5b\xb4\xbf\x99\xe6\x43\x99\xca\x01\xa3\x7d\x07\x61\xaa\x28\xf1\x4b\x3c\x55\x11\x0e\xf0\x16\x35\xe1\x3e\x0f\x2e\xf9\x00\x53\x41\x4c\xe6\x4b\x4f\xaa\x80\xc5\xc2\x38\xba\x30\x97\x8c\x65\x0c\x09\x2f\x87\x42\x54\x78\x90\x72\x0e\xdf\x8c\xb2\x6c\xd2\x6f\xb7\xaf\xae\xae\x5a\x17\xd1\xb4\x15\x27\x17\xed\x90\xc0\xa5\xed\xa7\x2d\xf4\xe9\x97\x6f\x1e\x87\x32\xbe\xc3\x0f\x9c\x0d\xb8\x65\xde\x6b\xe1\x0e\xaa\xd5\x27\x93\xdb\x15\x4b\xea\xd9\x88\x1b\x67\x49\xe5\x99\xae\x3d\xd8\x18\xaa\x40\x7d\xab\x84\x2c\xb2\x74\x2d\xdd\x87\x9a\x8a\x0b\x50\xf3\x9c\x1a\xf8\x16\x5b\xd6\xc1\x1e\x5a\xa6\x24\x55\xf2\xec\xb8\x46\xef\x26\x6b\x9e\x4a\x22\x76\xe2\xe5\x7a\x12\xff\x38\x4b\x31\xd8\x5b\x11\x0e\x7d\x69\xa5\x23\x96\x4c\xbc\x42\xbb\xc1\x54\x47\x08\x29\xb4\x54\xdf\x5a\x32\x40\xef\x7b\x3f\xe1\x3c\x72\x40\x48\x27\x4f\x30\xd9\xa9\x0d\x41\xde\xdb\xe9\x7e\xd4\x3f\x1a\x8c\x38\xe9\xf6\x95\xc2\xd2\x7a\xf1\xee\xe0\xe7\xc3\x77\xa7\x3f\xbf\x7c\xf1\xe1\x07\x17\x43\x1c\x70\x1f\x6a\x3e\x0b\xfd\x7a\xb7\xd3\xf9\x3b\x34\xa1\x06\x3b\xa5\x2d\x61\x07\x6a\x93\x59\xe3\xcf\xa4\x31\x67\x29\x3f\x9a\x66\xb7\xa4\x32\x17\x1a\xd9\x2a\x64\x1e\xf3\x68\x4a\x6a\xe5\x22\x2a\x77\x7b\x5e\xc9\xb7\x77\x62\x93\xe8\x43\xaf\x53\x06\xd8\x0e\xbb\xa5\x87\x10\xa4\x93\x90\xcd\xfb\x50\x8b\xe2\x88\xd7\x4c\x33\x65\x7c\xc7\x27\x3b\x6d\xb5\xb2\x12\x2e\xa4\xba\xd0\xc3\x46\x58\xe0\xa9\x90\x65\xe4\x77\x83\x3e\x06\xc1\x80\x9f\xe3\x0b\x0b\x21\x09\x20\xf0\xe3\x48\xbd\xfc\x62\xf8\xde\xdb\x0f\xe3\x94\x0f\x5a\xa4\xdd\x4a\xb8\xb6\x95\x40\x70\x01\x2d\x5f\xb5\x34\x8d\x9e\xf3\x83\xec\xd5\xaa\x23\x7d\x33\x75\x7b\xaa\x52\xb7\x7d\x51\xf3\x4a\x2b\xbd\xcb\xa0\x8a\xaa\x3d\x58\xde\xd2\xd5\x8a\x24\xb5\x94\x68\x58\x7b\xf6\xe7\xcf\x6a\xdf\xbf\x70\xf7\x7d\xd9\x49\xa3\x85\x11\x26\x64\x7b\x7d\xe1\xdb\x70\xdd\xdb\x6c\xc3\x89\x1e\xea\xb1\x19\x07\xf9\xe1\xd1\x1c\x58\x0b\x22\xef\x7c\x47\x15\x1c\x0a\x00\xb9\x9b\x8a\x8d\x0d\x69\xc1\x53\xf3\x3e\x1c\x13\x25\x09\xdc\xe9\x79\xbf\x10\xd0\x24\x56\xeb\x2a\x18\xa6\xee\x27\xd1\xad\xa5\xe3\xab\xbc\x59\xa3\xc2\xbd\xad\x2d\xa7\xfe\xf2\x96\x3b\xfb\x9f\x3a\x9c\xb6\xdc\x68\xf9\xd6\xbf\x4f\x84\xc5\x1b\xf4\x60\x47\xd3\x9d\x75\xb2\x36\x06\x3c\x89\x55\x8b\xc4\x96\x67\x23\x8c\xbc\x89\x4e\xcd\x6e\x25\x94\x6d\x0d\x7b\xcd\x68\xac\x56\x1b\x04\x36\x51\x47\xe1\xea\x91\xd0\x68\xa4\x0b\xe4\xf7\xd3\x2c\xc3\xf7\x72\x77\x8a\x98\x96\x60\x74\x4b\xac\xb0\x99\x75\xbe\x5d\x8c\x1c\x22\x58\xf9\x05\xf0\x2a\x2a\xc4\xf0\xa8\x42\x02\x24\x2c\xcd\x6a\xd5\x80\xc4\xbf\x1a\x4b\x02\xd6\x0c\xd9\x39\x0f\x6b\x7d\xa8\x89\xe1\xc1\x20\x61\x57\x0e\x43\x97\xfd\x8b\xa3\xe7\x61\xe0\x7f\xec\xe7\xa7\x71\x71\xab\x95\x18\xc5\x08\xde\x1b\x98\x45\x08\xd2\x46\x65\xbf\x15\x73\x05\x37\xce\x17\x99\x05\xf4\x84\xd0\x29\xac\x14\x56\x63\xb3\xec\x60\x19\x55\x96\x60\x07\x3c\xc4\xf5\xa1\x96\x05\x59\xc8\x6b\x9e\xe6\x00\x29\xa4\x6b\xe2\xb4\xf7\x73\xc2\x26\xea\xf4\x54\x0d\xaa\xf6\x7d\x0c\x87\x4a\x07\x7c\xc1\xd2\xd1\x79\xcc\x92\x41\xad\x7c\xc8\x85\x52\xb7\x44\x3f\x07\xd0\x7b\xd7\x89\x12\xed\x52\x0e\x91\x40\xdd\xdb\xba\x96\x36\xc2\x96\xb3\x87\x48\x91\x9e\xbf\x92\x04\x35\xe9\x4b\xde\x6e\xd2\x60\x89\x65\xca\x9b\x9c\xc7\x71\x58\xda\xa0\xfa\x4e\x32\x7f\x7b\x5a\xbc\x6a\x40\xe6\x26\xad\xb6\x65\x04\x78\xa3\x9e\xca\xff\x35\x7b\x5d\xee\x06\xe1\xc1\x5f\xf7\x8b\x7f\xdd\x2f\x7e\xad\xf7\x8b\xbb\xd0\x7d\x3c\xea\x3e\xbe\x6c\xf6\x7e\xd8\xbd\xec\xfd\x3e\xee\x34\x1f\xb8\x3f\x1f\x5d\xf6\x46\xdd\xc7\x3f\x3d\xfc\x61\xd7\xbe\x5f\x94\x46\x58\x93\xfe\x97\x47\xd3\x2f\x7f\xa3\x28\x7b\x2d\xbb\x4a\x94\xe6\x5c\xf1\x3f\x4b\x5f\x1e\x8a\xca\x5f\xe8\xd6\xf0\xe1\x5f\xb7\x86\x7f\xdd\x1a\xfe\x75\x6b\xf8\xd7\xad\xe1\xd2\xf7\x4b\x58\xef\x87\x78\x5c\xb5\x25\x3e\x7c\xf4\xc8\xa9\xb6\x08\x53\xf1\xfd\x0f\xbe\xb3\xca\x2d\x1c\xe5\xa1\xeb\x91\x20\xb2\x3c\x70\x2d\x9f\xdc\xf2\x35\x67\x9a\xea\xdb\x05\xfc\x1f\xf7\x6a\xa1\xea\x26\x21\x7f\xdb\x80\xf7\x0a\xca\xb1\x0f\x1d\x73\xa5\x8b\x36\xc2\xb4\x2e\x91\xe2\xf3\xdf\xfe\xba\x86\xfb\xeb\x1a\xee\xaf\x6b\xb8\xbf\xae\xe1\xfe\xba\x86\xfb\xeb\x1a\xee\xab\xbb\x86\x7b\x1e\x47\x19\x8f\xb2\xf7\x57\x41\xe6\x8f\xc0\x1f\xc5\x71\xca\x53\x99\x77\x97\x2e\x0c\x4c\x74\x64\x98\xb0\x0b\x4e\x0f\x23\xd4\x05\x9d\xdb\x7c\xd9\xbb\x00\xa7\xd5\xc2\x2b\x01\xa7\xe6\x12\x37\x03\x4e\xfd\x5b\x5d\x10\x38\x10\x96\xb9\x27\x70\xbb\xbc\xc5\x75\x41\x8e\x1a\x1b\xbb\x35\x48\x69\x52\xea\x96\x41\x94\xf9\x59\x70\xc9\xf3\x15\xd1\x56\xc6\x52\xae\x6f\xf1\x3e\x1c\x7c\xff\xbe\x35\x8a\xc7\xbc\x15\x0c\xfa\xa5\x36\xbd\xa5\x0e\xe2\xa4\x50\x1a\xab\xe8\x27\x18\xf3\x71\x9c\xcc\x1d\x4b\x30\x15\x79\x90\x25\x6c\x38\x0c\x7c\xe7\x9b\x2c\xf3\xe4\x0a\x52\x21\xf7\xac\x1a\xf6\x07\xb8\xb6\x2c\x89\xd5\xe3\xf2\x47\x2c\x88\x6e\x1a\x98\xd8\x82\x97\x01\x86\xf7\x86\xcc\xa7\x8b\xc3\x0d\xc1\x8c\x78\x86\x99\x79\xaa\xc0\xb5\xdb\x70\x14\x85\x73\xba\x3a\xe7\x69\x16\x44\x17\xad\x4d\xf4\x9b\xce\xd3\x8c\x8f\x37\x35\x8a\x30\xbe\xb8\x91\x22\xb7\xb4\x7a\xd7\x06\xc1\xe5\x82\x3b\x07\x81\x61\xf5\x57\x8b\x79\x10\x45\x37\x06\x53\x18\x5f\x78\x80\x6f\xf9\xca\x16\xc9\xe6\x86\xb0\xe4\x50\xd4\xbf\x4f\x24\x0a\x10\xb1\x45\x66\x79\xf5\x2f\x8c\x2f\x16\xd6\x29\x59\x28\xea\xdf\x75\xc5\xbd\x85\xdb\xe2\xba\xec\xba\xd0\x65\x8d\x0a\x5b\xbe\x23\xed\xaa\x4c\xfa\xae\x10\x2e\x5a\xf6\x49\x8e\x95\x9b\xdd\xe9\x79\x56\xc1\x4e\xef\x8a\x90\xe5\xdf\x3b\xb5\xdb\xca\x0b\x45\xdf\x94\x9b\x7c\x4a\xda\x7d\xe5\x35\x0b\xa2\x0d\x39\xaf\xc8\xfd\xb5\x5f\x38\xfc\x7e\x2a\xf5\xc4\xe8\x76\x3a\x7f\xaf\x95\x39\x14\x90\xb3\x41\xf3\x66\x9f\x8e\x61\xc8\x67\xdf\x63\x82\xd8\xae\xfb\xe1\x9c\xf9\x1f\x2f\x12\xa1\x27\x3e\xa7\x8b\x22\xf2\x95\x98\xb0\x90\x67\x19\x6f\x99\xcf\xe5\x57\x4f\x3a\xdf\x21\x35\x4b\x27\xcc\x17\x13\x33\x8d\x82\x0c\xb6\x61\xf7\x16\x6e\x21\xc6\x2b\xe4\x2b\xf2\xb7\x29\xa3\xfd\x87\x78\xd2\x87\x07\x0f\xdd\x4f\xb1\x8e\x30\x5d\x63\xd3\x2c\xb6\x3c\x36\x3c\xd9\x37\x06\x4f\xc2\x6c\xd8\x69\x6b\x3a\xa9\xd7\xd2\x71\xad\x91\x1f\xab\x66\x8f\x22\x09\x28\x24\x42\xce\x3b\xe7\xe1\xfd\xa2\x0f\x4e\x0e\xd1\x87\xf7\x2b\xd6\xb6\x3d\x38\xd9\xef\x8d\x3e\x44\x9d\x3f\x7a\x5e\xff\x10\x1f\x9f\x9c\x4f\x0d\x2e\x77\xe3\x51\x63\x1e\x88\x2a\x79\xe0\x6a\xca\x74\xb7\x21\xda\x94\x6b\xc8\xbd\xa2\x8a\x2c\x6a\xdb\x9a\x71\xaf\xa0\x1a\x8b\x1a\x4b\x68\xc4\xa2\xda\xad\x14\x61\xd1\x70\x19\xfd\x17\x3b\xb8\x85\xda\x4b\x23\xfc\x9f\xe6\x23\x53\x1b\x33\xc1\xe8\xeb\x7a\xc6\x48\xd6\xba\xc1\xdb\xc1\x5e\xb3\xb7\xf0\x8d\xc9\x1d\x4c\xca\xf5\x21\xb5\x15\x17\x4e\x19\xe5\x5a\x4a\xf5\x09\xa0\xb4\xfa\xa2\x53\x41\x69\x03\xa1\xd3\xf5\xf3\x4a\x5e\x79\xd5\xa5\x0e\x15\x85\x96\xd7\xab\x3a\x2f\x08\x3e\xaf\xd2\x73\x70\x8d\xfd\x49\x8e\x0b\x7f\xa0\x0e\xb5\xba\xd7\x83\x92\x5a\xb9\xfb\xcf\x47\x7f\xdd\x7f\xfe\x75\xff\xf9\xd7\xfd\xe7\x9f\x79\xff\xf9\x7d\x12\x0c\xaa\x6e\x3e\x9f\x3c\x72\xaa\x2d\x02\x2c\xbe\x5b\x63\xf4\x47\x2c\xc9\xaa\x70\x7e\xf8\xe8\xf1\x97\xb8\x1a\xfd\xeb\xe9\xdd\x5f\x77\x7e\x7f\xdd\xf9\xfd\x75\xe7\xf7\xd7\x9d\xdf\x5f\x77\x7e\xff\xb3\xee\xfc\xc4\x66\x8b\xfb\xb8\x31\x61\x5c\x88\x9f\x2a\x06\x6f\x82\x43\x4b\x78\x3a\x89\xa3\x34\xb8\xe4\x40\xdb\x73\x4b\x4d\xb3\x0e\x1e\x26\x98\xea\x9d\xda\xbc\xb5\x15\x24\x05\x0a\xb7\x25\xe6\x44\x21\xfe\x5a\xb0\x4c\xc0\xc2\xe6\x8f\x2f\x6b\x29\xcc\xcc\x01\x5d\xde\x23\x6a\x94\x96\xbe\x43\x54\x2d\x16\xdf\x1f\xaa\x5a\xcb\xdc\x1d\xaa\xba\xb7\xbb\x37\x54\xad\x97\xba\x33\xd4\x5d\xdd\xe6\xbe\xd0\x8c\x7c\x63\xd6\x93\x5b\x3e\xf8\x41\x2d\x6f\xe1\x73\x1f\xc5\x51\x6a\xa7\x90\x56\x60\xf7\xbc\x4d\x65\xcb\x18\x28\x9e\x4b\xce\xc3\x6b\x1b\xdb\x46\xa3\x22\x04\x5a\xdc\x83\x65\x55\xd7\x38\xeb\x5d\xdf\xdc\x34\x70\x43\x80\x20\xe3\x63\x35\xf6\x59\xda\xa7\xa5\x23\x91\x9e\xa5\xb7\x7f\x71\xb2\xf0\x7a\x47\x2b\xd4\xad\x77\x7a\x0d\x3f\x57\x33\xb1\xf8\xf6\xe8\x53\xee\x62\x41\x1b\x95\x6d\xc4\x65\xec\xdd\x1b\x2e\xa2\x0a\x03\x08\xe3\x48\xe3\x8f\xe0\xd0\x5d\x9c\x65\xcc\x85\x4e\x39\x34\x73\x17\x73\xca\xdf\xef\xc6\xab\x2f\xb0\xee\x54\x1c\x47\x3f\x15\x8f\x70\xd1\xbf\xeb\x46\xd5\xfd\x17\x94\x3e\x64\x81\xf2\xbb\xb4\x95\x6d\x44\x7a\x49\x57\x5e\x88\x69\xe9\x52\xb4\x16\xe9\x25\x55\x1a\xd3\x0e\xc3\x2c\x97\x5c\x6a\xa1\x4f\xa8\xed\xe3\x31\x12\x05\xd6\x15\x16\x3d\xf2\x24\xcf\xd1\x25\x8d\xd6\xa2\xf6\x62\xa3\xb5\xa8\xb1\xcc\x03\x4f\xe9\x69\x9a\x9b\xd0\x25\x9e\x77\xc6\x63\xbe\xd4\xe3\x4e\xd1\xc1\x6d\x9e\x76\xe2\x08\x0b\x62\x97\x76\x7b\x3d\xee\x1f\xed\x14\x16\x50\x22\x85\x4b\xeb\xd7\x23\x3e\xcb\xde\x9a\xc7\x0e\xe6\x9f\x1c\xfe\x1d\xb4\x9a\xc9\xfb\xbc\x20\x7d\x33\x0d\xc3\xa3\xe4\x47\x15\x7a\xb5\x61\xda\x3b\x16\xcc\x63\x7d\x03\x78\xf0\xe1\xe0\xf4\xdf\x0f\x7f\x79\x2f\x2d\xae\x27\x0d\x41\x9f\x8d\x01\x95\x66\xd9\x93\x22\xb7\xdb\xa6\xe3\xf5\xb6\x29\x0c\xca\x3b\xe2\xc8\x93\xb6\x45\x58\x14\xed\x6d\x15\xaa\xd2\x38\xf1\xf2\x12\x1b\xd8\xb7\x97\x93\x24\x18\xb3\x64\x7e\xbc\xdb\xe9\x9c\xec\x15\x3b\xa1\xc1\x94\x37\x4d\xb9\x1f\x47\x03\xd3\x78\x03\x3b\xa9\xd9\xd3\x4b\x36\x51\xbd\xc0\x7b\xf7\x37\xf5\xc0\x55\x6f\x10\x07\x09\x67\xd8\x79\xd5\x13\x57\xb1\x69\x3d\x34\xdb\xc0\x6e\xa7\x23\x9d\xaf\xd3\x12\x23\xfe\xed\x5e\xbb\x1a\x6c\x7e\x39\x98\x89\xa5\x88\x27\xe9\xf5\x20\x89\x71\x79\xe6\xc5\xe3\x38\x8e\xe2\x2c\x8e\x78\xcd\xc3\x0d\xe7\xdf\x91\x0b\x71\x18\x35\x0f\xd2\x2c\x89\x3f\xf2\xbe\xcd\x2e\x9e\x38\x0e\x86\x4e\x51\xd9\xce\x50\x82\xe4\x5a\xb3\xf1\x2a\x88\xf8\x26\x66\x43\xb2\xef\xba\xd3\x21\xd0\x59\x95\x88\xf6\xca\xf1\x60\x10\x67\x3a\x8b\xf2\x7f\x1f\xf2\x7d\x6d\xcc\xfc\x9c\x25\x19\x4f\x03\x16\x91\xd6\xff\x49\x13\xbb\xf6\x2f\x9c\x1b\xe2\xbf\x60\xe9\x48\x9c\x81\xc5\xb4\x3c\x80\x07\xb5\x82\x73\xc2\x1f\x31\xff\xce\x22\xfa\x63\xa7\x7f\x53\xb2\x6c\x43\xab\xe7\x96\xb3\xe6\xc1\x25\x4f\x30\xeb\xb5\x21\xdd\x1f\x2f\x0b\xdd\x65\x4c\xc2\xd0\xd9\x14\xcb\xe6\x73\x45\xad\x57\x28\x53\x95\x8f\xba\x85\x22\x57\xd4\x75\x71\x23\x5e\xe9\x5e\xf4\xcb\xdd\x59\x7e\x40\x37\xae\x7a\xa3\xae\xb4\xd5\xdc\x65\xe5\xe3\x45\x97\x95\xcb\xa6\xdd\x28\xb9\xb8\x2c\xbf\x53\x2b\x05\x98\xbb\xc2\xb4\xaf\x2f\xd1\x5b\xd6\x4a\x45\x12\x8c\x55\x0a\x12\xbc\x3f\x39\x95\x8f\x57\x4f\x5f\xbe\x7e\x7b\xf4\xee\xc3\xe1\x8b\xd3\xd7\x47\x2f\x7e\x7c\x75\x78\xda\x39\x3d\x9d\xc4\xe1\x5c\x70\x04\x9a\x5d\xcb\x2f\x6c\x9e\xdc\x0e\x78\xf7\xf4\x54\x5b\x0c\x4e\xdf\x4f\x31\x8d\x51\x65\x2f\x4f\x1e\xba\x9d\x24\x5c\xa6\x51\xa9\x9f\x07\x98\xf9\xa6\xe1\x26\x54\xd1\x2d\x5b\x83\x0a\x6a\xc9\x1e\xef\x1a\x2b\x42\xdd\xba\x01\x5a\x15\xed\xe3\xbb\xec\xee\xc9\xde\x6d\xe9\xdc\xb3\x61\xbe\x62\x73\x9e\x54\x12\xa2\xfb\x64\xd3\x84\xc0\xfe\x56\x26\x43\x19\xca\xeb\x11\x61\x57\x40\x94\x52\xe1\xf4\x15\xbf\xe0\xd1\x60\x01\x15\x1e\x6d\x9c\x0c\xd8\xe3\xca\x74\x28\xc5\x7a\x3d\x42\xdc\xb7\x41\x7e\x88\xe3\x30\x0b\x26\xd5\x94\xd8\x7d\xbc\x69\x4a\xc8\x2e\x57\x26\x45\x39\xde\xeb\xd1\xe2\x81\x0d\xb3\xc4\xc0\x55\x49\x97\xc7\xbb\x1b\xe7\x90\x92\xee\x57\xa6\xd1\xcd\xe3\x59\x8f\x5e\x0f\x6d\xf8\xcf\xf9\x02\xb9\xdd\xed\xec\x6e\x9a\x40\xa2\xbf\x95\x29\x52\x82\xf1\x7a\x24\x78\xe4\xb0\x21\x9f\x65\xd5\x5b\xd7\xe6\x97\x0e\x9f\x65\x2b\x53\xa0\x04\xe1\xf5\x28\xf0\xd8\x91\x49\xec\x9c\x57\x73\xc1\x83\x07\x9b\xdf\x4e\xce\xf9\xea\x5c\x50\x86\xf2\x7a\x44\x78\x52\x80\xf8\x2a\x48\xab\x79\xe1\x51\xf7\x8b\x10\x42\xf4\xb9\x32\x31\xaa\x50\x5f\x8f\x20\xdd\xce\xe9\x69\x3a\x62\x13\x7e\xfa\x9e\xfb\x59\xbc\x40\xc5\x78\xd0\xd9\xb8\xb2\x85\x3d\xae\xae\x6b\x15\x50\x5e\x93\x04\x5d\x05\xef\xf9\x34\xb9\xac\xd6\x36\x1f\x6f\x5e\x34\x8a\xfe\x56\x1f\x7f\x1e\xdf\x35\x87\xdf\x53\xe0\xde\x71\x3f\x63\xd1\x45\xb8\x80\x04\xbd\xcd\x6f\x9f\xb2\xcf\xd5\xc9\x50\x86\xf7\x9a\xa4\xd8\x55\x20\xdf\xc6\xe1\xfc\x02\xc3\x22\x55\x38\xba\xf5\x36\x2e\x22\x65\x97\xab\xd3\xa1\x88\xf4\x9a\x54\xb8\xaf\x00\xbe\x88\x17\x88\xc6\x8d\x8b\x83\x17\xf1\xea\x42\x31\x87\xeb\x9a\x03\x7f\xa0\x17\x56\x12\xa7\x69\xe5\xd0\x77\x9f\xdc\xdf\xb8\x24\x10\x1d\xae\x3e\xfa\x3c\xc2\x6b\x8e\xff\xa1\x16\xac\xf3\xf1\x79\x1c\x56\x53\xa0\xfb\x64\xe3\x4a\x92\xec\x72\x75\x1a\x14\x91\x5e\x93\x0a\x8f\xd0\xbe\xc1\x12\xb1\x9e\x58\xf2\x7d\x12\x54\x9f\x38\x9f\x6c\xfe\x3c\xa1\x3b\x5d\x9d\x12\x65\x88\xaf\x49\x8b\xc7\x0e\xc8\x77\x6c\x10\x4c\xd3\x83\x59\xb0\x80\x33\x1e\x6c\x5c\x65\xca\x75\xbd\x3a\x5d\xaa\x07\xb1\x26\x75\x9e\x38\x80\x0f\xc4\x16\x74\x03\x71\x36\xbe\x7f\xba\x3d\xaf\x4e\x9b\xca\x21\xac\x69\xbb\xea\x68\xb8\x41\xb5\x3a\xb1\xbb\x79\x03\xde\xdb\x60\x75\x4d\x22\x87\xec\x9a\x23\xef\x2a\x60\xef\xd8\x80\x55\xeb\xd3\xbb\x9b\x37\x56\x61\x87\xab\x8f\x3e\x8f\xf0\x9a\xe3\xef\x59\xe0\x02\x16\x7e\xbb\x90\x06\x1b\xdf\x46\x74\xa7\xab\xd3\xa1\x0c\xf1\x35\x69\xb1\x7b\x7a\xea\xab\x3b\xa0\xd3\x6f\x93\x69\x3a\x5a\x40\x8b\x8d\xdb\x70\xb1\xc3\xd5\xe9\x50\x86\xf4\x9a\x74\xb8\x6f\x83\xd4\x0f\x06\x5e\x05\xd1\x22\xd9\xf0\x05\xce\x1a\x56\xc7\xab\xd3\x65\xd1\x20\xd6\xa4\xcf\x83\x52\xd0\x8b\xd4\xef\xdd\x27\x1b\xdf\x67\xed\x7e\x57\xa7\xce\x82\x21\xac\x49\x9c\x87\xa5\x90\x0f\x12\xce\x16\x50\x67\xe3\x67\x75\xa7\xe3\xd5\xc9\xb3\x68\x10\x6b\xd2\xe7\x91\x0d\x5a\x5f\x39\x2f\x54\x44\xee\x77\x36\xce\x3d\x4e\xc7\xab\xd3\x67\xd1\x20\xd6\xa4\xcf\xe3\x52\xd0\x8b\xf5\xfa\xfb\x1b\x17\x3e\x4e\xc7\xab\xd3\x67\xd1\x20\xd6\xa4\xcf\x13\x1b\xf4\x42\x99\xdc\xeb\x6d\x5c\x5f\xbb\x9d\x28\x2e\x41\x79\xcd\x6b\xc6\x8e\x0d\x71\xa1\x6c\xe9\xf5\x36\xae\xb8\xdd\x4a\xa4\x94\xa1\xbc\x26\x11\xba\xce\xce\xbf\x40\x71\xeb\xf5\x36\xae\xb8\xdd\x46\x65\x2b\x41\x78\x4d\x0a\xf4\x6c\x80\xef\x7d\x96\x65\x0b\x6e\x13\x7b\xbd\x8d\xab\x6c\xb2\xcb\xd5\x29\x51\x8e\xf8\x9a\xd4\x70\x34\xc1\x7f\x2c\xdc\x51\x1e\x6f\xdc\x24\xf6\x8f\x5b\x6d\x24\xa5\x38\xaf\x49\x06\x47\xf1\xfb\x65\x31\x19\x36\x6e\x16\xfe\xe5\x76\x64\x28\xc3\x79\x4d\x32\x38\x1a\xde\x7f\xdc\x60\xe8\xd8\xb8\xfe\xf5\x1f\xb7\xa3\x43\x19\xd2\x6b\xd2\xc1\x51\xe5\xf0\x71\xef\x22\x51\xd9\xed\x6c\x5c\x48\xa8\x3e\x57\xa7\x46\x05\xea\x6b\x12\x44\xe8\x6e\x23\x96\x64\xa7\xda\xfb\x76\x81\x62\xb5\x71\xc6\xd0\x9d\xae\x4e\x8e\x32\xc4\xd7\xa4\xc5\x63\x05\xf2\x5b\x96\xdc\x44\x8a\x8d\x2b\x53\xaa\xcf\xd5\x29\x51\x82\xf6\x9a\x84\x78\xa2\x20\xbe\x0d\x6e\xe4\x89\xcd\x1b\xd1\x83\xdb\xb2\x44\x09\xda\x6b\xfa\x6d\x75\x14\xc4\x0f\x09\xe7\x63\x56\xed\xb4\xf5\xe4\xfe\xe6\x3d\x4f\xa8\xcb\xd5\x9d\xb6\x8a\x48\xaf\x49\x85\xae\x02\xf8\x9e\x45\x1f\xf9\x7c\x01\x11\x36\xaf\x53\x61\x8f\xab\xd3\xa0\x80\xf2\x9a\x24\xe8\x29\x78\x68\x67\xbd\x61\x4d\x6c\xfe\xa6\xc0\xf4\xba\x3a\x29\x4a\x51\x5f\x93\x1c\xbb\x9a\xbc\xa4\xad\xde\x44\x90\x8d\x6f\x1c\x76\xbf\xab\x93\xa4\x02\xfd\x35\x89\x72\x5f\x41\xd5\x2f\x19\x16\x50\x64\xe3\x2a\xb7\xee\x74\x75\x72\x94\x21\xbe\x26\x2d\x1e\x58\x4c\x47\xf6\xf8\x9b\x08\xb2\x71\xe5\xdb\xed\x79\x75\xaa\x54\x0e\x61\x4d\xd2\x3c\x54\x70\xf1\xc5\x44\xca\x07\x37\x51\x66\xe3\xaa\x86\xd3\xf1\xea\x84\xa9\x1a\x80\x45\x97\x2f\xfc\x2f\xf7\x54\xe3\xc9\x17\x7a\xaa\x71\xab\xf7\x15\x7e\x9c\xf0\xd3\xdf\xd2\x53\x9e\x3e\x3c\x1d\xb3\xac\xfa\xd2\xe8\xe1\xe3\xce\x6d\xdf\x70\x14\xfb\x38\x35\x0f\x5d\xca\x38\x21\xaa\xaf\x06\x8e\xde\xc3\x00\x4f\xc3\x20\xca\x20\x8a\x9b\xf8\x24\xbb\x0f\x1d\x41\x69\x7c\x61\xcb\xd3\x8c\x5e\xb2\xc0\x3e\x7c\xba\xde\xdb\xda\xa2\xe0\x57\xe5\x11\x82\x3e\x7f\xb6\x1a\x98\x07\xde\x8d\x86\xcc\x2e\x98\x40\xc4\xb2\xe0\x92\x7f\xef\x36\xdb\x2f\x7f\xfe\x8d\xcf\x90\x4a\xbf\x38\x6f\xdd\xe9\x61\x90\x7a\x83\x2c\xd0\x8b\xf3\xfd\xeb\xf7\xc9\x26\x4a\x98\x53\xc1\x79\x49\xae\xc2\x64\x97\x60\x4a\x19\xe1\x08\x25\x4f\x42\xc1\x07\x54\xd7\x7b\x5b\xd7\x79\x76\x7d\xdc\x59\x2b\x0c\x62\x39\x2b\x75\x1b\x7b\xe5\x5f\xf0\x32\xa5\xfc\xcb\xfd\xca\x2f\x0f\x2a\xbf\x3c\xac\xfc\xf2\xa8\xf2\xcb\xe3\xca\x2f\x4f\x2a\xbe\x3c\xea\x54\x8d\xe7\x51\xa7\x57\xf9\xa5\x6a\xa4\x8f\x3a\x55\x23\x7d\xd4\xa9\x1a\xe9\xa3\x4e\xd5\x48\x1f\x75\xaa\x46\xfa\xa8\x53\x35\xd2\x47\x68\x47\xa0\x29\x6e\xc9\x19\xae\xf4\xce\xea\x34\x5a\xaf\x59\x36\xda\x2b\xc8\xb9\xc7\xdd\xb5\x18\xa7\xdd\x86\x5e\xa7\xd5\x6b\xf5\x5a\xbb\x20\x3a\x68\x31\x3f\x4e\x47\xf5\x59\x03\x17\xf4\xdf\xe4\xa6\x52\x61\x2d\x15\xf3\x21\xaa\x85\xf1\x45\x77\x52\x75\x71\xd7\x7d\x20\x6b\xa5\xff\x44\x48\xd8\x8b\xf8\x9b\x4a\xff\x86\x1d\xaa\x72\xfc\xb1\xb7\xb5\x25\x3b\xae\xcb\xff\x6d\xbd\x87\x1d\x85\x4c\xeb\x3b\xd8\x86\x3b\x75\x6a\xb7\x85\x41\x82\x7f\x7a\x0c\xe7\xd3\x8b\x3e\x8c\xb2\x6c\x92\xf6\xdb\x6d\x3f\x1e\xf0\xd6\x45\x1c\x5f\x84\xbc\xe5\xc7\xe3\xf6\xa4\x7d\xf9\xb8\x1d\xa4\xe9\x94\xa7\x6d\x8a\xeb\xf4\x2c\x18\xec\xef\x3e\xe8\x3c\xd9\x02\xb8\x77\x8f\xba\x1e\x86\x71\x9c\x48\xb0\xf5\x37\x14\x62\xe3\xf5\xc1\x3f\x4e\x7f\x3a\x78\xf5\xe3\x61\xa3\x01\xfb\xfb\xf0\xa8\xdb\xa1\x0e\x3f\xc4\x09\x7c\x9b\xc4\x57\x29\x4f\xa8\x67\x8b\x74\x2f\xa3\x61\x10\x05\xd9\xbc\x01\xcd\xa7\xf0\x86\xbd\xa1\x2e\xfe\x96\xff\xb8\xbf\x0f\xea\xc7\x56\xc3\x83\xda\x6b\x99\x6b\x73\x0b\x00\xab\x5a\x81\x13\xd4\x94\xb8\xd1\xe5\xeb\x33\xd8\x87\x9d\x59\x03\xbe\x81\x2e\x3c\x13\x3d\x41\x1f\x66\xf0\x14\x9e\xdc\x7f\xd2\x79\xd8\x7b\xf8\xa0\xf5\xb0\x77\xbf\xf7\xa0\xfb\xe0\xa1\x14\x67\xcf\x08\xcb\x30\xbe\x10\xb0\x76\xe8\xd7\xab\x37\x3d\xf9\xb9\x4f\xd3\x58\x9f\x41\x13\xba\xb0\x83\xd3\x45\x3f\x1a\xb0\xad\x7e\xed\x40\x97\x42\x69\x5c\x53\xa8\xd4\x3c\x33\xf6\xd6\x62\x46\xc1\x0f\x2c\xd2\x3b\x48\xb9\x50\xdb\x95\xec\xf4\xf2\xf0\xf1\xe9\x8b\xa3\xd7\xa7\x2f\x0e\xbf\x7b\xf9\xe6\xb0\xb2\xfa\x7d\x59\x3d\x8b\xdf\x26\xc1\x38\x10\x62\xba\xb2\xee\x43\x59\x77\xf0\xd6\xec\x32\xee\x93\x4c\xeb\x11\xe9\xb0\x72\xad\xf6\x1a\x26\xfa\x9d\xdb\x1c\xfa\x15\xb1\x63\xe7\xf5\x23\x0f\xde\x7a\x70\x90\xc9\xa0\x6a\x32\x5e\x88\xa2\x46\xfd\x08\xa9\x2e\xf0\xb2\x06\x52\x7f\xeb\xe1\xbb\x4f\xfc\xa6\xab\x5a\x30\x44\xb9\xd8\xe3\x5c\x5a\x35\x20\x4b\xe6\x2e\x33\x0d\xde\x16\x11\xc0\x69\x06\x9f\x61\xc2\x19\xcc\xcb\x27\x36\xff\xf1\x24\x9b\x0b\x6d\xe4\x5a\x82\xae\x5d\xf0\xac\x06\x41\x64\xb5\x14\x3b\x7b\x2d\x2d\x14\x37\x64\x14\x45\x13\x41\xb1\x76\xe0\xfb\x3c\x4d\xe3\x24\xc5\xb8\x88\xe9\x74\x22\x48\xcb\x07\x77\x6a\x1a\x73\xf9\x88\x39\x0f\xe9\xe8\xf8\xed\x09\xec\x5b\x45\x14\x61\x68\xcf\xe4\x93\x3d\xa2\xc0\xee\x79\x06\xdd\x5d\x9b\x41\x83\x74\x21\x83\x76\xd1\x8d\xa3\x20\xd5\x8d\x06\x12\x48\xed\x03\x55\x23\x05\x4c\x94\x16\xe9\x13\x64\xb0\x03\x35\x08\x88\x3c\x4c\xa9\x22\x92\x3c\x72\xa0\x41\x56\x3e\xd2\xfb\x6b\x8d\xb4\x30\x80\x3b\x95\xbc\x7e\xef\x5e\xc5\xc7\xdd\xdd\x46\xdd\x09\x9c\x6c\xcd\xce\x0d\xef\x9d\xed\x55\xf9\xa0\x51\xc7\x94\x2a\x42\x4a\x32\x4c\x47\x7c\xc1\xb3\x7e\x2e\x24\xb3\x84\xfb\x08\x63\xa1\x36\x5a\x0c\xee\xec\xc3\xa3\xbd\x72\x21\xb5\x5e\x96\xed\xa5\x79\x00\x25\x49\xec\x63\x00\xa2\xaa\x8a\x8f\x9f\x34\x5a\xaa\xce\x1e\x06\x78\xa4\xb8\xa0\xaa\xcc\x7d\xff\x2f\x38\xa1\x46\x3c\x80\x2b\x22\x0e\x07\xf0\xf2\x50\x62\x04\xfb\x1a\xad\xba\x6a\x8e\x93\x53\x28\x75\x81\x2e\xc7\xad\x8a\xd9\x52\x78\x56\x81\x1c\x56\xed\xa3\xda\x5f\xc6\x8e\xeb\xa5\x39\x6e\xb7\xe1\x51\xab\xdb\xea\xc2\x07\x4b\xfa\x05\xd1\x64\x9a\xc1\xb1\x07\x6f\x13\x3e\xe4\x49\xc2\x07\x62\xe9\x9c\x34\x96\x9f\xa2\x76\x1b\xe3\xf1\x72\x36\x50\x01\x1c\x0f\xdf\x3f\x84\x74\xc2\x7d\x15\x09\xd3\x83\x2b\x0e\x83\x60\x10\xd5\x32\x0c\x4a\x49\xf3\xf0\xaf\xff\x6a\x6f\x27\x3e\x93\x71\x1d\xa3\x01\xe5\x91\xc1\x58\x42\x3a\xf8\x14\x34\x61\x18\xb2\x0b\x68\xc2\x44\xe1\x89\xd3\x2c\x88\xc9\x80\xc2\xb2\x2f\x9e\x02\x0f\xde\x57\xca\x0c\x4b\x0a\xd0\xa1\x69\x18\x61\x00\x0c\x25\x40\xdf\x0b\x16\x90\x5c\x55\x1f\x46\x82\x4b\xb2\x56\x16\xbf\xc7\x6e\x51\x0d\xa9\xa9\xae\x6a\xb8\x94\x35\xf8\x4b\x16\x0a\x3c\x22\x3a\xc7\x88\xce\x74\x6f\x16\xfc\x3c\x68\x94\xc3\x47\xc3\x0d\x40\xbe\xf3\x25\x51\xcf\x8b\xda\xbb\xcf\x99\x98\x62\x3f\x8e\x2e\x79\x92\x49\x41\x0b\x59\x0c\x13\x3d\xcd\x14\x29\xbd\x51\xce\xde\xcb\x44\xb1\x2f\x17\xac\x66\xa2\xcf\x83\x6c\xcc\x26\x26\x0f\xee\x56\x2e\x93\x90\x1d\xb4\xf7\x8e\xac\x0d\xf7\xa0\x2b\x43\x89\xb8\x01\x7b\xad\x0a\x3d\x59\xc1\x44\xf8\xb5\x3e\xde\x97\x1f\xed\xb0\x7a\x5b\x3a\x2f\x4a\x7e\x98\x0b\xe3\x5f\x2c\x25\x3a\x29\x57\xfd\x02\x79\x48\x82\x73\x14\x0c\xaa\xf4\xb4\xdd\xae\xd2\xe9\x46\xac\x32\xbc\xb8\x06\xf4\xfe\xdd\xf3\xaa\x3a\x4f\x3a\x8d\x7a\x2d\x4d\xfc\x9a\xac\xfa\xe1\xe8\xf4\xfd\x87\x77\x2f\xdf\x7c\x0f\xfb\x50\x53\x7c\x56\x93\xc7\x14\xf5\x1b\xf6\xe1\x3b\x39\xf0\x63\xdd\xe0\x44\x02\x78\xfb\x0a\xf6\xa1\x5e\xab\x89\xd3\x8a\x66\xd4\x56\x3a\x09\x83\xac\xae\x2b\x8b\x2d\xa9\xf2\x90\x17\x44\x42\xfa\x64\xef\xe3\x69\xe2\xf3\x45\x92\x58\xc3\xd7\x3c\x4e\x33\x56\x5f\xc0\x60\x47\x26\xd1\xb2\x07\x29\x1b\x72\x63\x6a\x09\x52\x35\x2a\xa1\x62\xd2\x9a\xc3\x55\x64\x2f\x32\xb5\x32\x4d\x65\x8c\xfa\x5d\x47\x78\xb5\x88\x8d\x79\x0d\xe3\xcf\x89\xc9\xb3\x0b\xb1\x5b\xad\xd2\x1d\xc9\xbc\xca\xfb\x98\x59\x59\x2d\xcc\x85\xb0\xdf\xbf\x7b\x9e\x03\xfc\xfe\xdd\x73\x0f\x24\xa4\x67\x80\x14\x97\xbf\xfa\x62\x1a\x5a\xbf\xc5\x41\x54\x27\x02\xd5\x45\xe7\x0d\xd3\x3d\xf6\x4c\x6c\xa8\x8e\x54\x47\x56\xaa\x67\x52\x7b\x31\x0b\x34\xc5\x47\xd7\x74\x02\x18\xf0\x90\x67\x5c\x56\x27\x3b\x10\xa2\x64\x11\xb6\x91\x6b\x4f\x75\x6f\xe8\xe8\xd3\x02\x50\xb8\xb3\x0c\x06\x30\x64\x1f\xb9\x66\xbd\x7f\xd1\xec\x38\x8c\x13\xf0\xe3\x24\x11\xe2\xea\x2a\x4e\x3e\xc2\x55\xc2\x26\x13\x3e\x80\x31\xcf\x46\xf1\x20\x85\xb6\x1d\x0c\x3c\xa5\xe8\xbd\xea\x5b\x18\x7c\xe4\xf0\x2a\x7e\xc1\xd2\x11\x04\xe9\x1b\x34\x62\x6d\x5d\x37\xea\xaa\x1b\x3b\xa8\xb8\xe6\x5f\x2b\x1e\xab\xc2\xc2\x55\xee\x24\xfb\x60\xd8\xf8\x82\x90\x16\xa5\xc7\xef\xdf\x3d\x3f\x11\xf3\x99\x63\x62\xf1\xad\x51\xa1\xb4\x2d\x34\xe7\xda\x02\x56\x0a\x86\xa3\xab\x48\x9f\xba\xf6\xe1\xd3\x75\xcb\x2d\xbb\x41\xe9\x21\x8e\xb5\x07\xe5\x36\x57\x8b\x4e\x71\x76\x89\xac\x7c\xb2\x8c\x45\xcf\x68\x94\x03\xcc\x0f\x82\x7f\x4f\x66\xca\x1c\x92\xb0\x68\x10\x8f\xeb\x8b\x55\xb4\x3c\xa6\x35\x7a\x36\x57\xaf\xb5\xfc\x38\xf2\x59\x86\xa9\xd4\x05\xcf\x4f\x55\x04\x48\x5a\x31\x7d\x62\xb4\x5a\xe3\xb4\xe6\x41\x7d\x67\x27\x18\xc0\x0e\x4c\x66\x0d\xbd\xc5\xd6\x77\x1f\x36\x2a\xc6\xb6\xb6\xd1\x89\x42\x8f\xb3\x10\xda\x90\xa2\x5e\x45\x99\xb5\x66\x19\xc8\xfb\x0b\x32\x06\x58\x42\xa9\x5c\x84\xf7\x16\xd3\x46\x28\x43\xd9\x88\x65\x1e\x50\xba\x15\x79\xaa\x56\x60\xeb\xc3\x48\xcb\x05\x0c\x5c\xee\x90\x49\xeb\x0c\x43\x94\x4e\x2a\xf7\xaa\x0d\x49\x66\xc9\xec\xf6\x8b\x69\x4d\x58\xc1\x90\xac\xf4\x11\x42\x88\xa9\x90\xa4\x7b\x06\x4e\xaf\x0c\x8e\x07\xe7\x37\x81\x12\x55\x8a\xd0\x76\x2b\xa0\x79\xe0\x2f\x01\x50\xd4\xb2\x60\x5e\x1b\x06\x33\xd0\xda\xdb\xd0\x6a\xb5\x58\x72\x91\xc2\x76\x3b\x67\x9f\x1a\x46\x3a\x14\x2b\x82\xd4\xa1\x58\xf7\x2a\xd5\x8b\x27\xcb\x98\x8f\x6e\xd2\xa2\xec\xf3\xb5\x94\x44\x41\x26\x8e\x83\x46\x0e\xdd\x78\xd2\xd6\xe0\x96\x3a\x6a\x3f\x59\xcf\xa8\x60\x4c\xb0\x0f\xa4\x1d\x31\x0d\xa2\x55\x4d\xb0\x7f\xc3\x46\xda\x8c\x2a\x7e\xd8\xe9\x50\x14\x48\x5b\x4e\xdc\x09\xd2\xef\x82\x28\xc8\xb8\xb6\x24\x7e\xfe\x0c\x33\x21\xb1\x3b\xf0\x0c\x66\x68\x4d\xfc\x06\xff\x6e\x52\xf3\xe6\x4c\x1c\xf0\x8c\x11\x51\xd9\x10\xa5\x6d\x70\x1b\xb4\x7d\xf0\x1a\x47\x55\x61\x25\x45\x58\x1d\x34\x8f\x36\x3b\x4b\x59\x7a\x71\x68\xf7\xee\x41\x17\xda\x72\xa0\xa2\xfd\x53\xe8\xd8\x86\x53\x1a\x63\x9f\xfe\x07\xca\xf6\x90\x27\xeb\x99\x44\xcc\x3c\x3d\x92\x23\xc9\xd8\x2d\xe6\x49\x34\xd2\xf3\x24\x7e\xec\x2d\x22\x16\x76\xd1\x24\x6a\x2d\x47\x2c\x84\xaf\x89\xa5\xdb\x7f\xe3\x52\x4b\x48\x41\xf1\xcd\x36\x33\xcb\xe1\x54\x98\x99\x2d\xbe\xd0\x2c\x50\xef\xc2\x0e\xcc\x1a\xd0\x86\x7a\x17\x9a\x30\x6b\x88\x3f\x7b\xd5\xf6\xe1\x27\xeb\x99\x5e\xcc\x0c\x3c\x21\x1c\xfc\x73\xc1\x79\x2b\x4d\x40\x1a\x5c\x54\xed\x26\x5d\xbc\x16\x2b\x12\xd9\x25\x9b\xe8\xd3\xa2\x9a\x44\xc1\x25\x9a\xe8\x44\x13\x6e\x9b\x70\x9d\xc4\x57\x75\x9a\xd3\xf3\xb4\x3e\x6b\x78\x38\x41\xbb\x0b\x8c\xe9\x4f\xd6\x36\x99\x48\x62\x75\xbb\x92\x5a\xe1\xef\xbb\xbd\x15\xc8\x75\x23\x25\x04\x3c\x9b\x14\x12\x7e\x81\x81\x9e\x3e\x7d\xba\x0f\x9d\x06\x3c\x83\x5d\xc1\x26\xd6\x75\x8b\x23\x4c\x3a\xad\x07\x9a\x5a\xaf\x8e\xbe\xef\x1d\x0a\x71\xb3\xbb\x88\x9d\xd6\xcb\x1d\x67\x51\xa8\x27\x29\xb4\xfa\xdd\x17\x9f\x4d\xd4\x6a\xe6\xb3\xc9\x12\x44\x73\xef\x76\xca\xaf\x76\xf8\x6c\xa2\xd9\x67\x47\x74\x21\x64\xef\x4d\x6b\x6b\xbd\xb3\xb9\x45\x8c\xfb\x7a\x38\xe3\xee\xaa\xe2\x0d\x1b\x55\xae\xaf\xfb\xa5\x5c\x95\x13\x62\x75\x09\xe4\xce\xbe\x85\x87\x23\xe9\xb1\xa4\xaf\x3a\x2b\x25\xc6\x32\xc7\x85\xa5\x88\xf1\x50\xb2\x2b\x26\x45\xde\xd4\xe2\x01\x02\xd7\xaf\x88\xc3\xd2\x69\x94\x0d\xea\x51\x67\x3d\x1f\x81\x9b\x06\x75\xa3\x64\xc4\xb3\x49\x7c\xa5\xd8\x7d\x12\x5f\x51\xd9\xe1\xdb\xf7\x2f\x5f\x1d\xbd\x81\x7d\xf1\xb5\xde\xf3\xa0\x89\xbe\x8e\xd6\xa7\xdd\x9e\xf5\xb1\xa7\x60\xbd\x3e\xf8\x87\xfd\xa1\xdb\x7b\x24\x96\x7f\xbd\x07\x4d\xd3\x4e\x55\x7d\xe9\xc2\xe8\xe2\xbb\x35\xfc\x84\x63\xf8\x10\xf0\xf4\x43\x7c\x78\xc9\xdd\x74\xbc\x91\xa3\xf0\x44\x42\x3d\x81\xb6\xc6\xb7\x69\xff\x22\xcd\xae\xa0\x57\x5a\x74\xc2\xcc\x8a\x0a\xb4\x26\x9d\xb6\xa0\xfc\x8d\x9d\xeb\x06\x24\xe2\x95\x45\xf6\x6f\x92\xb2\xb4\x2b\xe8\x62\xe6\x41\xc2\xd3\x69\x98\xa9\x13\x08\x42\xf8\x86\xc6\xaa\xcf\x1e\xd4\x78\x3b\x3f\x4c\xaa\xdc\x96\x84\x69\x5b\x04\x13\x12\x14\x0b\xb7\x4d\x21\xde\x0f\xc2\x3e\xe0\x7e\x6d\xe6\x44\x37\x13\x8d\x04\x40\xd2\x75\x53\x72\x19\x62\xd0\x84\xba\xf8\x8f\xf8\x82\x58\xb7\xdb\xd2\xf9\xa7\x39\x08\x52\x76\x1e\xf2\x66\xc4\x67\x59\x33\x0c\x22\x0e\x51\xdc\x4c\x79\x38\x6c\xfa\xf1\x78\xc2\x12\x2e\x87\x24\x81\x3d\x95\x73\xfd\xf9\xb3\x02\x7f\x67\x5f\xfe\x55\x18\xa8\xba\x15\xb7\xf4\x6e\x4d\x03\x49\xae\xa2\x0e\xfe\xa8\xb3\x29\x37\x88\xae\x54\xee\x46\xf3\x49\x9c\xd5\x8f\xd1\x1e\xda\x3d\x96\x46\xd9\xde\xb1\x07\xff\xf5\x9f\xff\x2f\x9c\x9c\x9c\xac\x24\x16\x5d\xd6\xb8\x79\x93\xc0\xce\xad\x5d\x82\x90\x21\x5c\x14\x2a\x78\x21\x5b\x98\x10\x35\x17\xd3\x68\x9a\xf2\x41\xf3\x92\x25\xa9\x34\xef\x26\x90\x4e\xc7\x64\x64\x50\x05\x81\xfb\x93\xbd\xc2\xe5\xa3\x4f\x6a\x2a\x45\xa9\xae\x10\xb2\xe4\x22\xd7\x24\xb9\xf0\x60\x10\x5c\x52\xc9\xd5\x28\x08\x39\xd4\x03\xf8\x06\x61\x99\x43\x26\xb5\x13\xab\x42\x03\x3f\x0e\x76\x76\x4c\x5e\x09\xc1\x2b\x08\xfd\x1b\x51\xd7\x4e\x11\x31\x08\x2e\x61\x9f\x7a\x6e\x8b\x6f\x26\x02\x35\x0d\x47\xfc\x77\x1b\x6b\xd1\x7f\x77\xa0\x6b\xaa\x48\x84\xad\x66\x96\x65\x4e\x7c\x13\x67\x88\x42\x67\xd4\x57\x58\xe8\x6c\x67\xdf\xf4\x93\x83\x27\x3f\xeb\x26\xd7\xf6\x76\x4e\x58\x58\x0e\x1f\xf0\xcc\xfc\xd9\xa7\xcf\xdb\xd6\x51\x2a\x9d\x8e\xab\xd5\xc2\x47\x9d\xf5\x7c\x2c\x2c\x4e\x7f\x4c\x7d\x06\xe3\x69\x58\x9f\x79\x30\x5f\x6d\xa7\x17\xcd\x14\x53\x8b\xbf\xe9\x18\x93\xc6\x63\x0e\x3f\xf3\xf3\x7f\x0f\x32\x75\x85\x96\xc2\x90\x05\xa1\xb4\x3c\x9e\x07\x17\x40\xf9\x6b\x52\x8f\x2a\x8f\x58\x0a\x57\x49\x1c\x5d\x00\x4b\x82\x6c\x7e\xa3\x7a\xb0\xea\x55\x33\x22\x5a\xef\xcc\x86\xf2\x9f\x07\x0f\x1a\x42\xfc\x34\x1f\xa0\x05\x52\x7c\x95\x8c\x2e\x4a\x7b\x7b\x5b\xd7\xb9\x73\x92\xa8\x61\xad\x45\x43\x2e\x9d\x3f\x38\x81\x1f\x5f\xbe\xf9\xd0\x7d\x28\xd6\x06\xf6\x63\x16\xc8\x2c\x42\x35\xce\x14\xcc\xb1\x60\x6e\xd5\x10\x54\x94\xed\xef\xc1\x2c\xb2\xaa\x3a\x5f\xe6\xf2\x8b\x1c\x56\x07\x3e\x8b\xa6\xdb\xa2\xd6\x0e\xd4\xeb\x16\x04\xa1\x6f\x43\xf7\x61\x43\x7d\xc4\x6a\x75\x0b\x90\xae\xf0\xcd\x37\xd0\x7d\x88\xbf\x3a\x8b\x38\x6e\x53\xf6\x8d\x5e\x57\x1f\x1d\xbb\x9d\x0d\x1e\x44\x10\x9e\x35\x45\x0a\xbe\xab\x55\xdb\xde\x4f\xe6\x94\xd1\xed\x1c\x2e\x18\xf9\xa6\x2c\x06\xbd\x8e\x19\xf9\x64\x63\x5a\x24\x42\x2b\x57\x22\x77\xbb\x0f\x2a\x94\xc8\x4d\x1d\xc1\x7b\x3d\x3d\xa4\x4d\x1e\x2a\x05\x38\x77\x2a\x8b\x47\x4a\x7b\x26\xdb\xda\x8f\x6d\xc1\x34\x6e\xea\x24\xdd\x93\x22\x53\x6a\x72\x9b\x99\x45\x01\xac\x7c\x12\x85\xda\x5d\x3e\x89\x9b\x3a\xf8\xee\x76\xd4\x80\x56\xb6\x64\xdd\x7c\xd2\x2b\x3d\x1e\x93\xbb\x66\xc4\x31\x41\x64\x12\x8f\x83\xe9\x18\x76\x1f\xe3\x2e\xc0\x60\x92\xc4\xe7\x21\x1f\xd3\x56\x71\xc9\x93\x39\xa4\x63\x16\x86\x6a\xc7\xd8\xf8\xde\x70\xc7\x0c\xbe\xd9\xe3\xcd\xee\x23\xda\x19\xf0\xcf\xe2\x46\x40\xf6\x45\x93\xf0\x2b\x28\x31\x97\x19\xf5\xdf\x78\x67\x6a\xff\xcb\xba\x3a\x52\x43\x93\xc8\xa7\x8f\xf5\xda\x07\x53\x1e\xfd\xd1\xeb\xb2\x29\x4f\xfe\xf8\x0b\x8f\x46\x08\xfd\x50\x34\x58\x24\xae\x37\x65\x08\xd8\x95\x2e\xc1\xb7\x30\x73\xde\x92\x39\x6e\x90\x0d\x39\x83\xa5\x6b\xaf\x44\x75\x14\xf6\x25\x61\x25\xf9\xcd\x66\x7a\xae\x3f\x35\x55\xb1\x9c\x32\x06\xae\x6a\xd6\x85\xbe\xa8\xed\x94\x35\x45\x21\x1e\x86\xce\xd1\xda\x89\xb3\x64\xdb\x66\x16\x4c\xc7\xa6\x4c\x11\xbb\xd2\x2e\x93\x25\xd3\xc8\xdf\xa0\xc4\x45\x78\x36\x59\x11\x7e\x90\xe5\x8d\x52\x81\x38\xc7\x75\x94\x1b\x31\xda\xef\x94\x2d\xd8\xe7\x41\xd8\x20\x1f\x84\x2a\x32\x74\xd7\x33\x5e\x90\x8f\x02\xb9\x65\x57\xf2\xd5\x43\x99\xb1\x65\x0b\xb6\x01\x53\x0f\xa6\x42\xd1\x3f\xc3\xf3\xd2\x19\x04\x29\x9c\xbd\x61\x6f\xce\x5a\x5b\x80\x35\xb6\xb7\xdf\xc4\x19\xef\x6f\x6f\x53\xae\x68\xba\x13\x17\xb5\xce\x59\xca\x07\x10\x47\xa2\xd2\xf1\xd9\x1b\x95\x6d\x51\xb4\x3d\xa9\x2b\x1f\xf3\xf1\x20\x6a\x05\x71\x9b\xbe\xb6\xf1\x6b\x03\x3d\xc0\xe4\x1d\x12\x3a\x82\xb1\x31\x07\x96\x0a\x38\xd2\xed\xe5\xf8\xac\x02\x8e\x04\x70\x35\x0a\xfc\x91\xa4\x78\x0a\x67\x59\x22\x10\x1f\xc6\x89\x00\x71\xa6\x2f\x26\xcf\xb0\xa3\x18\x93\x3d\x47\x71\xd4\x24\xf1\x28\xd3\x1e\xa9\xe1\xfd\x6b\x9a\xb1\x2c\xf0\xf1\xcf\x31\x17\x15\x8e\x86\x70\x4a\x5f\x82\xc8\xe7\xd0\x69\x75\x5b\x1d\xfc\xed\xb3\x8c\x5f\xc4\xc9\x1c\x5e\xb1\xe8\x02\x4b\x26\x2c\x61\x63\xf8\xb4\x7d\x2d\xf3\x6c\x7e\x18\x49\xff\x27\xc8\x62\xf0\x05\x69\x5b\x58\x4f\x61\xfa\xe9\x3c\x8e\x43\xce\xa2\x6b\x78\xe7\xe2\x5e\x42\x7f\x8f\x8e\x4c\x67\x98\x08\xe9\x8c\xe0\xf0\x19\x1b\x4f\x42\x2e\x51\x3f\x25\x6a\xd7\x05\x49\xf6\x44\x41\xbb\x0d\xfb\x4f\xd1\xd5\x39\x57\x23\xe2\x57\x40\x53\x80\x95\x2b\x6a\x53\x5d\x73\xaf\xbb\x18\x66\x69\x3d\x44\x76\x4b\xb0\xb0\x39\x08\x60\x6d\xcb\x59\xab\xdd\x86\x83\x88\xc6\x68\xb9\x8d\x05\x94\x8a\x33\x8e\xc2\xb9\x22\x21\xa6\xc8\x26\x36\xe1\xff\x9c\xb2\x50\x10\x35\xc8\x52\x1e\x0e\x5b\x04\xe6\x2d\x4f\x86\x71\x32\xc6\x86\x67\xea\x3a\xfe\x03\xbb\x38\x23\xda\xc3\x30\x48\x52\xf4\x4e\x63\x97\x71\x30\x00\x9e\x24\xda\xb5\x43\x9c\xa9\x24\x2e\xbe\xe8\xff\x1f\xd2\x97\x2d\x85\x20\x82\x97\x87\x2d\xdb\x97\x53\x52\x4e\x0e\xe1\xde\x3d\x89\xdf\x9d\x7d\xd8\x91\xee\xd4\xd7\x25\x26\x31\x1c\x77\xc9\x02\x5f\x68\x81\xf9\xa3\x1f\xdc\x61\xfa\xa9\xea\x10\x1e\xb7\x7d\x63\x27\xc1\xae\xf5\xb0\x4e\xc2\xb8\x6d\x36\xa5\x49\x12\x4f\x4e\xb3\xf9\x84\x57\x07\x6b\xb9\xe5\x13\x42\x17\xf6\x1a\x63\x74\x01\xdd\x36\x57\x12\x66\x91\x8d\xd8\x78\xc1\x40\x7b\x9b\x80\xbd\xc6\x40\x5d\x40\xb7\xce\x87\x34\xcd\x82\xf0\xf4\xed\x34\xe1\xef\x30\x45\xea\x82\x20\x3c\x6b\x64\x1a\xba\x6d\x0a\xae\x15\x52\xf8\xdc\x32\xd4\xf8\x0a\x49\x6f\x90\x52\xef\xc4\x02\xfa\x31\x0b\x16\xf5\xa1\xee\x18\x4e\x29\x6d\x7d\x6a\x1e\xf4\xb0\x14\xad\xc9\xb6\x31\xbf\x9e\xb1\xe4\x82\x0b\x85\x07\xdd\xe9\xea\xca\x36\xda\xdd\x83\x80\x2c\x92\xae\x41\x14\x82\x9d\x9d\x06\xa6\x5e\x4b\x20\x55\x9e\x9a\x96\x65\xf3\x64\xcf\xc0\xf9\xc8\xe7\x42\xf2\x52\x35\xd1\x08\x9d\x02\x09\x15\xed\x5d\xd7\x2a\xf3\x2e\xa3\x26\xe4\x61\x26\x1a\x12\x92\xca\x81\x90\xbe\x92\x23\x22\x5c\xe3\xff\x29\xf7\x3b\xac\xb7\x07\xd7\xf2\x82\xc4\x4e\x76\xec\xdc\x8e\xe0\x78\x4b\x9f\x23\x05\x3c\x95\x34\xf1\x30\xa9\x7f\x5a\x20\x4d\x87\x48\x43\xc9\x15\x4b\xc8\x32\xe0\xa9\x9f\x04\x93\x0c\x53\xed\x62\x2d\x24\x8b\x29\x6e\x19\x6f\x66\xd8\xaf\x28\x17\x73\x24\xf6\x5d\xa7\x9d\xed\xe6\x0c\xfb\xb8\x81\xef\x21\x51\xef\x92\x83\xb6\xa0\xb6\xa9\xde\xb0\x9b\x2a\x07\x68\xdd\xac\xfc\x19\x8a\x1a\xb9\xd5\x12\x3d\xe5\x2c\xa8\x7b\x36\xc1\x0d\x45\xad\x1c\xd6\x48\xb8\x2c\xc6\x34\xcb\x1e\x90\x2e\xa6\x12\x41\x23\xba\xe6\x73\xa3\x48\x7c\x0b\x90\xed\x83\x69\xb5\xa1\x31\x3b\x70\x17\x41\x71\x51\xd8\xd3\x49\xca\x4d\x0d\xc1\x30\x70\x5d\x6f\x68\xae\x11\xfc\xe2\xc9\xff\xed\x79\x70\x9a\xf1\xf1\xc4\xf6\x29\x3a\xcd\x91\x2d\x3e\xff\xcd\xf8\xae\x4e\x35\xaf\xcb\x05\x10\x9f\xff\x26\x4a\xca\x29\x6e\x9a\xba\xf9\xdd\x3d\xc7\xe7\x9d\x32\xee\xbb\x6e\xee\x54\x66\x3c\xdb\x55\x1a\x44\xed\x59\x2b\x3a\xb6\x9c\x6e\xc5\xac\x5f\x5b\x2f\xbb\xf7\xe0\xda\x1e\x52\x2e\x73\x79\x10\xa5\x19\x8b\xc4\x22\xb4\x08\xa5\x06\x76\x47\x7f\x06\xf5\x47\x3c\x74\x2a\xe2\xaa\x45\x4f\x33\xa1\xa7\xba\x8f\x0d\x84\xf2\x27\x96\x39\x30\xc0\x4e\x01\x0d\x20\x0a\x93\xbb\xc4\x61\x36\x6a\xd5\x79\xd2\x85\xe2\xe8\x21\x30\x8d\x9a\x28\x72\x7b\xd7\x11\x6a\x25\x0a\xe8\x9d\x3b\x62\x69\x54\xcb\xe0\x9c\xf3\x08\xc4\x51\x37\x60\x61\x20\xce\x3e\x4d\x48\xa7\x13\xcc\xd5\x6d\xd7\x10\x3d\xf0\x01\xa1\x26\x29\x88\x23\xb8\x77\x4f\x7b\xda\xe1\xef\xfd\xfd\x7d\xb8\x4b\x5a\xe7\x5d\x7c\xe5\x9f\xff\x66\x46\x09\xcf\xa8\xb8\x0f\x02\xe3\xdc\x64\xe8\x1c\xf4\xe9\xf4\xfc\x39\x71\x23\xa2\x85\x7f\xab\xa1\x4a\xe0\xe6\x03\xdc\x71\xba\x10\xd8\xe5\x3e\x62\xf6\xde\xaa\xa9\x79\x2f\xea\x8a\xf3\x68\xc2\xd3\x54\xa0\x31\x9e\xa6\x19\xf0\x00\x0f\x5b\xe7\x1c\x1b\x43\x9c\x58\x73\xe5\xa1\x22\x7f\x17\x76\xa0\x80\x0b\x92\x4a\x61\x6f\x16\xb2\xd9\x8c\x48\x34\xd7\x2d\x04\x1d\x74\xed\xb5\xff\xc9\xf6\xe3\xee\x9b\x85\x62\x88\x63\xaf\x15\x94\x9b\xf9\x85\x51\xb6\x78\xf0\xbd\x9c\x14\x26\x16\x71\xcb\x43\x36\x3c\x2b\x2f\xaf\x98\x20\x83\x9b\x95\xbe\x7f\xdf\xaa\x82\xf3\x2d\xcf\xeb\xff\x3a\x0c\x42\x7e\x74\xc9\x93\xcb\x80\x5f\xc1\x0b\xa9\x92\x51\xa6\x45\xb1\xa8\x32\x1e\x65\x78\xfe\x52\xff\xf0\x71\xc7\xcb\xff\x38\x84\x7d\xf4\x11\xc2\x27\xc1\xcf\x8f\xde\x9c\x7e\xf8\xe5\xed\xe1\x7b\x54\x0b\x56\xd1\x23\x8e\xef\x9e\xdf\x85\xf6\x36\xbc\x3a\xfc\xfe\xf0\xcd\x0b\x09\x64\xbb\x7d\xd2\x1a\x06\x61\xc6\x13\xcb\x80\x28\x86\x5c\x70\x77\x47\xbe\xaa\x45\x71\xc4\x6b\xd2\x7f\x5d\xe0\x23\x47\x41\x83\x90\x63\xd0\x73\xbf\x40\xad\x2c\x53\x09\x8f\xef\x32\x44\x50\x29\xab\xdb\xed\x93\x46\x9d\xe4\x15\xec\x43\x1d\xa5\xb3\x18\x35\x89\x6b\x67\x9f\x3f\x35\x59\x78\x11\x6f\xb3\xb0\xca\x10\xf4\xe0\xd4\xc9\xda\x0b\x06\x52\x59\x75\x9d\xcf\x3f\x2f\x3b\x85\x80\xf1\x4a\x9b\xe4\x52\x06\x2f\x90\x6c\x04\xa3\x14\x4d\x8b\xa5\x3e\x7f\x2e\x0f\xfc\x51\xda\xae\xd1\xd0\x6e\xc9\x02\xb6\x71\x4b\x96\xb6\x2b\x41\x1f\x4b\x61\xaa\x20\xd1\x31\x8d\xf9\x23\xe6\x59\x4e\x70\x8a\x5e\xfa\x71\x54\xf3\xb6\x68\x68\xc8\xd4\xe2\xdf\x36\xd0\x04\xe2\x51\x7e\xc2\xb2\x11\xc4\x43\x08\xfc\x38\x52\x9f\x95\xa9\x85\x46\x70\x8d\xe9\x9b\xe1\x85\xf8\x4f\x3c\x04\xce\xfc\x11\x84\xb4\x06\x82\x8c\x8f\x75\x23\xf5\x2e\x8c\x2c\x03\xd7\xf0\x56\x40\xe6\xf4\x3a\x51\x56\x6a\xdb\xcf\xba\xf4\x14\x1a\x5c\xeb\xa2\x27\x73\xf9\x8d\x8a\x5d\xc4\xd0\x66\x40\xd9\xa0\xf7\xed\xfc\xd9\xce\x27\x39\x7f\xd4\x68\xc4\xc2\xe1\xfb\xe0\x77\x21\xd4\x70\x39\x4a\x27\x35\xed\x74\x10\xcc\xb2\x91\xfb\xfd\xa1\xfd\x3d\x1b\x05\xc9\xc0\xfd\xbe\x6b\x7f\xf7\x25\x2e\x02\x5b\x8d\x05\x3c\xcb\xe1\xda\xa7\xef\xbe\x83\x9d\x90\x69\x58\x4c\x32\x57\xac\xd0\x30\x88\x78\xcd\xbe\xf1\xbf\x31\xb0\x51\xe1\xcc\xdf\x62\xb9\x77\xaf\xb5\x89\xb1\xa5\x6a\x77\x01\x4c\xb9\xfd\x73\x30\xc8\x46\x7d\xb8\x6f\xa7\xfa\xa6\xb4\xdb\x24\x2a\xbc\x42\x8b\x3e\x8d\xd7\xfe\x30\xe8\x43\xed\x75\xc7\xab\xc1\x8e\x21\xf5\x0e\xd4\x46\xa2\xc0\x10\x6f\x07\x6a\xbf\x46\x60\xfd\x3b\x10\xdf\x0d\xf1\x77\xa0\xe6\x15\x4b\x3a\x5e\xd7\xeb\x62\x79\x0f\xb6\x5d\x68\x85\x0e\x5d\xf0\x3f\x88\xcf\x38\x5f\x3b\x50\x7b\x7d\x1b\x08\x2b\x22\x58\x0d\xda\x26\x16\xca\xa0\x37\x6c\xcc\x71\x59\x52\xae\xf4\x26\x2d\xa0\xa6\x58\x75\x35\x93\xbf\xbc\x51\xe2\x12\x92\xe3\x96\x84\xfb\xd9\x1f\xc7\x2d\x65\x5c\x41\xdc\xb2\x88\x27\xe4\x9a\x79\xac\x79\x42\x4d\xca\xa5\xfe\xb1\x0d\xbb\xd0\x86\xfb\xba\x46\x53\x55\xf9\xbd\xb6\x36\xed\xb6\xb6\x36\x46\x99\x55\x4c\x0b\x25\xbb\xa1\x4d\xd2\x52\xb2\xf9\xb3\x7e\x09\xcf\xf8\xf3\xb2\xd2\x34\xf8\x9d\xf7\x91\x7a\x6e\xd9\x07\x4a\xb7\x3f\x08\xd8\x98\x67\x3c\xb1\xe8\x47\x89\xf8\x35\x03\x6d\xb9\x94\xba\x2e\x6c\x0b\x2f\x12\x76\x85\x32\x3d\x15\x82\x9e\xc8\x5c\x10\xef\xa8\xa1\x48\xfa\x5c\xc3\x4b\x51\x5b\x4b\x77\xb1\x5b\xa9\x31\x3b\xfb\x90\xa8\x55\xf3\x16\x49\x7f\x51\xa3\xee\x8a\xfe\x53\x21\xeb\x7b\x52\xe6\x3b\xf2\x1d\x6d\x79\xa9\xb3\x1b\xd8\x5c\x33\x61\xf3\x30\x66\x03\xa1\x7a\xd0\x4e\x21\x0b\xec\x3a\x82\x7b\xa4\x88\x97\x95\x54\x89\x5d\x2b\x64\xf3\x78\x9a\x99\x3a\xf4\xdb\x59\x0d\x71\x32\xc6\xd0\x8c\xa6\x92\x2e\x72\x70\x16\x3a\xe4\xb7\xf1\x0c\xf6\xe1\x13\xcc\xfa\xd0\xf1\x60\x8e\xff\xbd\x22\x81\x8c\xf3\x0a\x23\x1e\x5c\x8c\x32\xfa\xa5\xde\x4d\xc9\x7d\x30\xe3\xe3\xf7\xd9\x1c\x0d\x05\xb6\x73\x58\x3a\x09\xd9\xbc\xaf\x11\x15\x22\x62\x14\x27\xc1\xef\x71\x94\xb1\xb0\x06\xcf\xa0\x16\x44\x62\x87\x69\x9e\x87\xb1\xff\xb1\x06\x7d\xa8\xd1\x5f\x66\x10\x63\x96\x5c\x04\xd1\x3b\xea\x19\xc3\x09\x81\x79\xb5\x25\x77\xcc\xcb\x0b\xdd\xb9\xe9\xd4\x05\xed\xc1\xa5\x38\xe3\xfb\x2c\x3c\x08\xd1\x7d\xa0\x36\x0e\x06\x83\x90\xd7\x3c\xb7\x87\xfb\x68\x05\x72\x96\xa8\x9c\x9f\xd6\x98\x4d\x2c\xad\x96\x47\x59\x32\xf7\x20\xb0\xa5\x9d\x31\x03\x08\xa9\x60\xb8\x42\xc6\x19\x08\x22\x16\x7e\x67\xcd\x08\x82\x30\x13\x82\xd6\x1b\x33\x3b\x76\x53\x0d\x73\xa1\x9a\x5e\x6e\xa5\xad\x37\xea\x75\x0b\x29\x67\x86\xa0\x44\x70\x65\x7c\x5c\xeb\xcb\x6b\x1e\xf9\xef\xda\x2b\xd8\x2e\x2c\x88\x1e\xd4\xac\xb6\x4d\x21\x30\x03\x19\x66\xe7\xa6\x76\x4a\x27\xa9\x79\x92\x18\xaa\xa0\xe1\xd9\x84\x6c\x34\x2c\x52\x8a\x6d\x87\x2a\x9b\x7d\x07\xb7\x81\x86\x33\x30\xe5\xc2\x3c\x0d\x43\x43\xcb\xeb\xad\x4d\xee\x4c\x36\x19\xc3\xc0\xd9\x1a\x94\x15\xb5\x6e\xa3\xe4\xec\x18\xfa\x4f\xcf\xa9\x91\x0a\x46\xee\x9b\x05\xe5\x7e\x25\xb1\x55\xa0\xb6\x55\xe7\xda\xbb\xf9\xb4\x54\x7e\x9c\x1b\xe2\xfe\x40\xa7\xb7\xc3\x4b\xa1\xe1\x1f\x0d\x9f\x8f\x82\x70\x20\x4f\x4e\x28\xef\xa4\x38\x03\xcd\xfd\x0d\x67\xd4\x9b\x21\xe6\x22\x40\xe5\x96\xf9\xb2\xdd\xcd\x01\xf8\x49\x49\x32\x2d\x47\xb5\x34\x33\x25\x52\x08\xf6\xd5\x1f\x9e\x9a\x0d\x2d\x60\xae\x5d\xa8\x92\x26\xd6\x11\x01\xe9\xd2\xb0\x2a\x7d\x19\xfa\xd4\xd2\x09\x8b\x6a\xf9\x21\x2e\xd4\x47\x04\xb3\x64\x7c\x96\xd5\xf2\x83\xc8\x89\xa5\x67\xb9\x02\xb9\xd6\xb4\x75\x51\x49\xbd\x3e\x58\x1f\xec\x01\xeb\xbf\x8d\xce\xd3\x30\x3e\xbe\xa5\x3b\xf0\xc2\xcd\x37\xbf\xef\x22\x07\xf6\x96\xde\x5e\x7b\x65\xfb\x6b\x6e\xe7\xec\x95\x6c\x9d\x2c\x94\xaf\x3b\x64\x0d\xfc\xbd\xb7\x65\x1f\x95\xee\xa8\xbe\x3e\x7f\x06\xf5\x77\xcb\x7d\xec\x0c\xe5\x92\xe8\xda\xde\x7b\x91\xde\xc5\xdd\x73\xc2\x06\x83\x20\xba\x10\xdb\x70\x6e\x33\x74\x8a\xc4\x9c\xca\x2d\xad\x7a\x9b\xa5\xc1\xa0\xe8\x18\x66\x35\xb3\x87\x6e\x4e\x17\xd5\xf8\xd4\xa6\xa1\xc5\x98\x15\x4c\x29\xa1\x48\xe6\xac\xe9\x85\x66\x91\xc2\xe2\x52\x9c\x68\x47\x13\xdb\x72\x38\x0c\xf9\xea\x84\xf6\x08\x39\x94\x32\x23\xc4\xde\xd6\xf5\x32\xd7\xcc\xc7\x77\xb5\x35\xe7\xee\x89\xde\x87\x7a\x2d\xa9\x58\xc8\x5d\xb8\xf6\x4a\xa1\xae\xbe\x0b\x3e\x11\xda\xae\xda\x61\x7d\xea\xb5\xbf\xf2\xfd\x71\x8b\xb5\xa4\x61\x42\x90\x40\x89\xa7\x5b\xc1\x21\x3f\x17\x05\x86\x74\xf1\x5b\x80\x89\x23\x7e\x34\xac\x1b\x63\x21\x0a\x35\xe2\xb6\x35\xe0\x1d\xdb\x4c\xea\x41\x4d\x29\x68\xb5\x13\x84\xcf\x42\xe9\xe6\x79\x6b\xf0\x3e\x8f\xf0\xc8\x21\xd9\xde\x83\x5a\x22\x44\xbe\x84\x9f\xd3\x07\xd7\xe8\x27\x8b\x27\x02\xf8\x79\x9c\x65\xf1\x58\xfc\x25\x55\x4b\xea\x47\x0a\x86\x5b\xf5\xc0\x92\x84\xcd\x8f\x86\x4b\x7b\x0e\x58\x4d\xf1\xfc\x57\xff\x64\x0b\xd6\xdb\x20\x10\xcd\x69\x1d\x06\xb7\x1c\x80\x6a\x9f\xad\xc7\x7b\x9b\xb1\x4d\x0b\xb9\x71\x4d\x2a\x8b\x63\x0d\xbb\x15\x62\x14\x87\x4c\xc0\xd2\x4a\xfb\xad\xe0\x88\xed\x4e\x40\x89\xa3\xd7\xf1\x34\xe5\x87\xd1\x86\x00\xbd\xe2\xec\xf2\x76\x24\x37\x80\x9e\x87\x81\xff\xf1\xd6\x30\xb6\xae\x2d\xe9\x49\x5f\xde\xca\xa3\xf1\x27\x47\xb2\x75\xef\xdb\x02\xc5\x11\x0b\x46\x10\xe8\xe5\x5c\x5c\xbb\xfa\x2c\x57\x9c\xd8\xda\xbf\xf8\xbe\x5f\x43\x4c\x32\x3e\x9e\x34\x30\x66\x03\x21\x45\xc1\xb9\x95\x4f\x85\x52\x1d\xa5\x7b\xa8\x13\x0b\x5e\x7b\x60\x61\x6c\x76\xd8\x2f\x37\xb0\x4b\x5f\x4a\xdb\xc3\x6b\xe1\xcb\xa3\x3f\xda\xc3\x6b\xb0\x7b\x3a\x59\x14\x49\x3d\x9f\x8d\x79\x79\x2f\xa8\x53\xbc\x68\x63\x51\xb5\xff\xd8\xc3\x5b\xfa\xc8\xf4\x4e\x17\x47\x7f\x47\xcf\x18\xf1\xcf\x04\x65\x48\xfc\x97\x51\xc4\x65\x8e\xf3\xfa\xc0\xb9\x79\x1a\xb4\x02\xf3\x0d\x9d\xf5\xec\x76\x47\xd3\xac\xb2\x5d\x6c\xbe\x15\xda\xbd\xcf\x58\x92\x61\xde\xf0\x42\xb3\x54\x7f\x2a\xb4\x3a\x8c\x06\xe5\x6d\xb8\xfc\x50\x68\xf1\x96\x95\xb7\x80\x7b\xf7\x60\xd0\x9a\xc8\xaf\x7b\xd0\x6e\x03\x3a\xea\xea\x98\x41\x77\x1c\x48\x81\x58\x46\xa9\x38\x22\xce\x3a\x1e\xcc\x3b\x1e\xcc\xba\x1e\xcc\xbb\x1e\xcc\x7a\x1e\xcc\x7b\x1e\xcc\x76\x3d\x98\xef\x9a\x97\xba\xb3\x6e\x07\xf6\x61\x86\x11\x2b\x44\x13\xfc\x39\x17\x3f\xe7\x5a\x13\x9d\xe1\x73\xe3\xd9\xae\xa8\x23\xc0\xe0\xcf\xb9\xf8\x39\xef\xa9\x3a\x42\xe3\xae\xcf\xf0\xa5\x6d\x7d\xde\xc1\x4f\x0d\xf1\x5f\x2a\x99\x75\xb0\x2d\xfa\xf7\xd7\xa9\x4c\x74\xdc\x04\x6a\x31\xef\x76\xec\xd0\x32\xc7\xb3\x0e\xec\x40\x46\x95\xc4\x30\xe4\xaf\x79\xb7\x73\xa2\xe2\xa9\x08\x45\x6e\x9a\x71\x98\xf0\x64\xc2\xa3\x41\xe0\x4f\x43\x96\x40\x3c\x1c\xa6\x3c\x03\x7c\xf8\x89\x96\x44\x7c\xca\x96\xf8\x2d\xd1\x64\x94\x65\x93\x7e\xbb\x2d\x98\xee\x2a\x4e\xc2\x41\xeb\x2a\x0e\x87\x09\x1b\x63\x58\xec\xe7\x41\xe2\x87\xbc\xf9\x2a\x88\xf8\x4b\x45\xc4\x20\x8e\x5a\xa3\x6c\x1c\x6e\x59\x11\x0a\x92\x88\x27\x1f\x58\x74\x21\x0e\xd1\x05\x22\x27\xe2\xff\x7d\x0f\xfc\x2b\x8b\xc0\x9d\xae\x20\x1e\x0e\xb6\xab\xa8\x35\xc7\x42\xa2\x93\x2e\x0c\x63\x41\x43\xff\x0a\x9e\x41\xe2\x43\x1f\x9a\x89\x2f\xe8\x75\xe3\x99\x5f\x2f\xa4\xe3\xbb\x21\xee\x8d\x18\x5c\x1c\x4f\xf6\xa2\xf3\x6d\x44\x61\x07\xfb\xdc\x16\xff\xd5\xe7\x56\x34\x0a\x86\x31\x95\xea\xc2\x39\xec\x43\x13\x4b\x67\xa6\x74\xd6\x95\xa3\xd8\x81\x78\xa6\x47\xd1\x95\xa3\xd8\x81\x78\x6e\x6a\x4a\x86\x72\x6b\x4a\xb6\x72\x6a\x76\x3a\xc8\x34\x5d\x0c\x9c\xd2\xed\xe0\xe3\x0f\x43\x21\xfc\x38\xc7\x8f\xf3\xdc\xc7\xc1\x0c\xbb\x20\x9a\x6a\x1c\x07\x73\xec\x83\x88\x6a\x4a\x05\xb3\x0e\x66\xb0\x2d\xfe\xb3\x23\x2a\x6d\xc3\x40\xe3\x90\xc0\x3e\x24\x82\xdb\x13\x5f\x15\xbd\x40\xd8\x5d\xe2\x37\xec\xa1\x83\x7f\x1b\x88\x02\xb1\xc1\x5c\xc5\x03\xea\x42\x9f\xc2\x82\xaf\x33\x51\xab\xb4\x1d\x61\xdb\x31\x9b\x51\xd3\x8e\x07\x09\x6c\xe3\xff\x0f\x7a\xd0\x84\x17\xb0\x0d\x2f\x8c\xf1\xc6\x9f\x21\x21\x5f\xe0\xb0\xa1\x29\x49\x21\xc8\x39\xd0\xf4\xf4\xe7\x58\xa7\xf9\x82\xa8\xd4\x94\x54\xca\x55\x9a\x75\x2d\x40\x3b\x15\x80\xba\x36\xa0\x9d\x52\x40\x03\xc4\xc8\xa7\x25\xd1\xe9\x98\xe9\xc3\x62\x5a\x14\x56\x31\x76\xeb\x4b\x09\x65\xd5\xc6\x62\x29\xa9\x3a\x78\x40\x6c\xb7\xe1\x6d\xe0\x7f\xc4\xeb\x65\x3f\x8c\x53\x9e\xa8\x48\xb6\xd9\x55\x6c\x64\xa3\x58\xc8\x93\x38\x88\xb2\x54\x7a\x98\x7f\x38\x7a\x71\x04\x2f\xd1\x35\x3d\xe1\xc0\x60\xc8\xd2\x8c\x27\x70\xc5\xe6\x90\xc5\x30\xe0\x19\x4f\xc6\x42\xa2\xd0\x83\x04\x07\x4e\x16\xc3\x34\xe5\xcf\xe4\x0b\x7f\x31\xb2\x6d\x1c\xdf\x0e\x0e\x67\x1b\xff\xfb\x14\xc7\xb0\x8d\xff\xdd\x41\xc4\x45\x79\xb7\x21\xa7\xc6\x17\xd2\xc3\x97\x83\xef\xda\x27\x5d\x19\x54\x6d\xd6\x17\x35\x65\x5c\xd3\x79\x5f\xd4\xa5\x1f\xb3\x4e\xb7\x0f\x4d\xb5\xca\xe6\xf4\x4b\xb2\xf6\xac\xdb\xc5\x66\x42\xfa\x26\x5d\x68\x43\x82\x2f\xa7\x64\x55\xfc\x38\xcf\x7f\xb4\xd2\x71\x00\xbd\x99\x5f\xa0\x42\xe1\xe6\x4e\xb5\xf4\xe6\x2d\x6b\x9d\xea\x77\x38\x75\x3b\x71\x8e\x8a\xae\x69\xb6\x69\xf4\x14\xb5\xf7\x74\x2d\x84\xcc\x96\x4c\x75\xac\xfd\x5b\xf3\x1a\xca\x62\x5d\xe9\xc6\x15\xe4\xe8\x32\xa5\x1e\x24\x1d\xbd\x68\x26\x6c\xa0\x01\x47\xd3\x30\x54\xe5\x66\xcf\x27\xb4\x8c\x7a\xa0\x6a\xa8\x1d\x9e\xbe\x2b\x45\xc0\x82\x6b\x7d\x55\x9b\xbe\x19\x11\x45\xfd\xdb\x97\x06\x25\xdb\xdd\x84\x25\x7e\xdd\x7e\xdd\x75\x3e\x1d\x0e\xb9\x75\xa1\x67\xff\x29\x58\x69\xc7\x22\x73\x85\x93\x87\xd5\x42\xac\xa5\x1d\x8b\xe8\x37\xb6\x60\xa2\x0f\x43\x8d\x8a\xfa\xd0\x5c\x46\xff\x3b\xbe\x7b\x81\x73\x31\x62\xe1\xf0\x6d\xe0\x1a\x78\x59\x17\x2f\x53\x06\x5f\xb6\x97\x01\x5b\x86\x81\x2c\x50\xc4\x3c\xec\x3c\x25\xc6\x61\x42\x0a\xb1\x8e\x45\x1f\xff\x4a\x4c\x71\x17\x9e\x02\xeb\x48\x5b\x1c\x9a\x15\xe5\x14\x37\xac\xb9\xa6\x99\x5c\x06\x01\x4b\xcf\x57\x28\xa0\x17\x0d\xe2\xa0\xee\x51\xda\x6d\x38\x8c\xd2\x69\x22\x9f\xd6\xe0\x73\x1b\x31\xb1\x90\x10\x43\x07\x29\xb0\xf0\x8a\xcd\x53\x8c\xb5\x80\xce\x38\x2c\xc2\x6a\xc8\x31\xb2\x5a\x4b\xa3\x9c\x74\xe1\x1b\x48\x3a\x0d\xb9\x55\x7a\xc4\x2c\x89\xd8\x75\x04\x0f\x24\xa6\xdb\x97\x29\x04\x19\x30\x92\xad\xcf\xcc\x98\x05\x88\xa7\xcb\x4d\x11\x5d\x54\xf0\x49\x1a\x84\x71\x84\xe3\xd2\x94\x6a\x8d\xe3\x4b\xfe\x21\x16\xdb\x5d\xc7\x1a\xeb\x11\x86\x7b\xc7\x7e\x7d\x54\xe1\xd0\x1f\x31\x8a\xa6\xe1\x34\x25\x1c\x2c\x87\x86\x65\xd1\x18\x23\x1a\x19\x9b\x0a\x14\x96\x65\xaf\x22\xee\xda\xe2\x9b\x1b\x42\xd2\x5d\x51\x5b\xe0\x08\xda\x8f\x15\xbb\x75\x1a\x38\x0d\xab\x01\xf9\x48\x2a\x47\x10\x69\x20\xda\x8a\xaf\xf0\x13\x42\x46\xd0\x97\x34\x59\xd6\xf1\x80\x75\x3d\xb8\xe3\x5f\x39\xb1\x49\x92\xce\xed\xa7\xd3\x32\x82\xe7\x89\xd2\x59\x93\x28\xdd\x06\xb2\xe4\x7a\x44\xe9\x1a\xa2\x94\x92\x45\x92\x44\x90\xc6\xa2\xca\xb5\xb4\x55\x57\x30\x25\x1d\x4d\x24\x5b\xb2\x04\x84\xf2\x10\x27\x16\x77\xda\x97\x20\x0c\x8f\x06\xac\xe3\x5c\x58\xa0\xa2\xcd\xba\x4e\x19\x2a\xc8\xf9\x7a\x9d\x42\xbd\x01\x8a\xea\x01\x73\xcb\xba\x85\x32\x36\x81\x7d\xbd\x3f\x55\x49\x5a\x4b\x07\xc7\x7d\x43\xb4\xa9\xb3\xc9\x1a\xfc\x70\xef\x1e\xd4\xcd\x6e\xfb\x0c\x76\xf4\x8f\x2a\x1c\xfa\x6b\x29\xda\xc8\x21\x89\x50\xd0\x70\x01\x25\x5d\xf7\x9a\x33\xf1\x57\xdc\x09\x02\x52\xc6\x15\x03\xad\xb1\x89\xd0\x31\x44\x1e\x74\x60\xc7\x56\x6f\xaa\xbc\x34\x5d\xcc\x51\x1c\xfb\x6e\x59\xb7\x50\x96\x39\x1c\x93\x75\xf5\x4d\x51\xbb\x0d\x07\xa2\x1b\x75\x3b\xf5\x0c\x2d\x0d\xb4\x8b\xd0\x23\xd9\xa4\x0b\xff\xf5\x7f\xfd\x3f\xb8\x08\x04\x07\x89\xbf\x07\xac\xd3\xb2\x45\xc3\x3a\xac\xe0\x3a\x5b\x4c\x3a\x2b\xce\x84\x4f\xe4\xd4\x6b\x39\x99\x08\xc5\x76\x5d\x81\x30\x71\xa9\x0c\x30\xe9\x6e\x04\xaf\x75\xa5\xf7\xc4\x16\x54\x82\xf4\x75\xb1\xd0\x9b\xfb\x82\x6e\xdb\xd0\x6b\xac\x31\x0f\x02\x82\x32\x44\x88\xc3\x6d\x53\x48\x56\x21\x6e\x76\x04\x74\x0f\xa5\x0c\x76\x64\x10\x40\x29\x46\x92\xa6\xe3\x29\xd1\x84\xc2\xa8\xce\xc4\x5a\x63\xdd\x86\xed\x0b\xab\x31\xee\x22\xa0\xee\xda\x18\x77\x4b\x31\xee\x22\xc6\x42\x5c\x77\x65\x47\x05\x8c\xbb\x0a\x63\x12\xb0\xdd\x2a\x8c\x9d\x5b\x5d\x32\xe9\xac\xbf\x8b\x77\x1d\xd6\x9a\xdf\x0e\x6a\x61\x5b\x77\xa1\x92\x39\x66\xfd\xcd\xb5\xe3\xe2\x7a\x3b\xa8\x85\xdd\xb6\xd3\x28\x8a\x1f\x0c\xee\xc7\x07\xf2\x7c\x27\x95\x38\x29\x5e\xfc\x8d\x89\x17\x32\x68\xad\x3d\x87\xdd\x6e\x4e\x3c\xcc\x6f\x07\xb7\x40\x99\x3c\x5c\x32\x96\xad\x3d\x8f\x9d\x4e\x1e\xdf\xdb\xc1\x2d\x70\x5d\xc7\xf6\xe3\x6a\xb7\xe1\x1d\xa7\x1b\x0d\x32\xc6\xe0\x54\xaa\x13\x08\xf3\xfd\x38\x11\x3b\x0c\x64\xb1\xca\x11\x94\xa1\x7a\x24\x34\x0f\x47\x44\x0c\x18\x7c\xb3\xdc\x84\xff\x46\xc7\xa1\x20\x3f\xd7\x34\xdb\xb1\x8f\xfa\xce\xed\x15\x57\x74\xb2\x37\xb6\xf5\xae\x87\x26\x53\x34\x48\xa1\xb1\x0a\xed\x90\x68\x24\x94\x36\xeb\x6e\x47\x68\x2a\xc7\xea\x47\xce\x67\x09\x80\xa1\x09\xb3\x23\xf6\xfc\xd8\x3f\x2e\xf9\x8e\xc6\x4c\xf5\xbd\x5b\xf8\x7e\x3e\x93\x66\xca\x8a\xf6\xe7\x64\x0c\xad\x6c\xff\x51\x50\xa4\xbb\xa2\x79\x39\x37\xeb\xab\x34\xa5\x5b\x5b\xa6\x39\xb1\xce\x66\xb0\x2d\x46\xb1\x23\x86\xba\x0d\xe7\x73\xbc\x1b\x58\x47\xb5\x43\x88\x4c\x43\x64\xf3\x75\x8d\xb2\xe7\x1a\xc5\x73\x89\x22\x05\x28\x6a\xe4\x89\x19\xae\xaa\x35\xe6\x7b\xc2\x29\x84\x6d\x9a\x4a\xd8\xa1\x29\xa3\xdf\xdd\x13\x6b\xa3\x57\x6a\xde\x1a\x1a\x6a\xe2\x7b\x78\x84\x6b\x42\x88\xd7\x0b\xf5\x8f\x3e\xc5\x54\xda\x2b\x28\x8e\x6b\xf7\xd2\x75\x7a\xd9\x71\x7b\xb9\xce\x6f\xad\x64\x42\xb0\x04\x82\x1f\x87\x21\x9b\xa4\x7c\x80\xd1\x3d\xf0\x56\xc7\xde\x0d\xee\xa0\x02\xb1\x39\xcb\x82\x5a\xd6\xce\x9e\xf4\x22\xe6\x36\x4e\xff\xf5\x9f\xff\x3b\x55\xf6\x14\x21\xc1\x46\xec\x92\x57\xed\x58\xda\xf0\x20\xa8\xb9\x89\x7d\x2b\x43\x1b\x71\xfe\x0a\x4a\x4b\x20\x2d\x95\xe8\x1a\xaa\xeb\x1c\x51\x85\xaa\x5f\xd2\xba\x20\xb5\xf2\xad\xab\x8e\xeb\x59\xa7\xe5\x8b\x95\x91\x75\x5a\xd8\xb1\xf8\x3d\xa7\xdf\x0e\x09\x91\x88\x3f\x08\x2a\x99\x8d\x20\x85\x31\x4f\x2e\xf8\xe0\x99\x23\xeb\x05\x95\xbe\x81\xc4\x6f\x38\xe7\x6e\xec\x47\x82\x97\x78\xad\xc2\x96\x03\x12\x3b\x19\x8b\x7a\xc4\x98\x84\x9f\x27\xf1\x6e\xac\x0b\xad\x2b\xa1\x75\x25\xb4\x3b\x2e\xd1\xda\x6d\x38\xca\x46\x3c\xb9\x0a\x52\xee\xc1\x20\x61\x57\xfa\x3a\x42\x91\x42\x25\xca\xc3\xcc\x3f\xae\x7a\x6a\xef\x62\xff\x8d\x68\xd2\x69\x21\x47\x09\x68\x5d\x43\x93\xf2\xa1\x18\x6b\xd3\xba\x7d\x6a\xee\x93\x7d\x6b\xee\xec\x6e\x62\x96\x09\x7a\x57\x42\xef\x4a\xe8\xdd\x25\x46\x88\x95\xa9\xcd\x66\x26\xcb\x20\xb1\x99\xa1\x95\x31\xf0\x22\x19\x4d\xc6\x2d\xcb\xae\x2c\xe4\xe0\x6f\xd3\xd4\xb1\x76\xb1\xc4\x77\xc4\x60\x95\xa8\xf5\x2a\x6d\x8f\x74\x6c\xcb\xad\x28\xbd\x45\x24\x1c\xa2\x58\x59\xac\x83\xe8\xc2\xa3\x70\x63\x19\xca\x67\x0b\x0f\xdb\xd4\xa6\xb0\x9f\xf0\x64\xc4\x26\xa9\xae\x1d\xe5\x0c\x73\xd6\xbe\x33\xa0\x20\x5f\xca\x22\xe2\x6c\x3e\x6b\x99\x41\x3f\x7f\x86\x3b\xf5\x75\x14\x52\x6b\xfb\x12\xfb\xa2\xa0\xa9\xd2\x3b\x6f\xda\xbe\x0c\xd5\xa0\x1e\x27\x64\xae\x6f\x2c\xbb\x93\x6d\xc6\xf6\x5b\xba\x93\xe9\x1d\xc8\xec\x4a\x49\xc7\x83\x66\xe2\x77\x96\xd9\xca\x4a\x94\xf2\x5c\xf3\xc2\x5e\x26\x29\xf7\x25\xf6\xb2\xce\x12\x7b\x59\xe7\xeb\x92\xdb\x5f\xc5\x5e\xf6\x95\xd1\xe4\x16\x7b\xd9\x06\x46\xf0\x67\xee\x65\x2b\x6c\x65\x6b\x8f\xf4\xeb\xd9\xca\x2c\x99\xb8\xec\x56\x96\xbf\x15\x22\xc3\xa7\x45\x40\xd9\x93\xaa\x8f\x1e\x29\x6f\x59\x36\xd2\x57\xb5\x42\x52\xd0\xed\xaf\x4e\xfc\xe0\xba\x00\x78\xea\x72\x78\x07\xee\x62\xf4\x18\xf5\xd0\x04\x41\xb3\xc4\x6f\xf9\x3c\xca\x92\x18\x13\x26\xe6\x5c\x2d\xc8\xf0\x91\xc0\x3e\xd4\x97\xf0\x05\x80\x9d\x65\xee\xff\x73\x17\x40\x98\x45\x63\xe7\x66\x2f\x80\x1d\xd8\xb9\xe1\x0a\x1f\x01\x2f\x7b\xd1\x6a\x9b\x7a\x8c\x8d\x56\xf9\x0e\xae\x63\x1d\x6b\xc0\x36\x24\xab\xb1\x61\xde\x10\x86\x20\x4e\x64\x5a\x3f\x39\x49\xae\xc7\x8b\x9e\xa7\xd3\x5c\x50\xd9\x7c\x68\x35\x78\x06\x75\xb7\xa9\x8c\xa9\x73\x9a\x8b\x1c\x04\xcf\xe0\x74\x99\x6b\xb1\x9b\x3d\x60\x76\x4e\x1b\x62\x5a\xfc\x06\xf4\xc1\x71\xa7\xb5\x87\xe3\x3a\xe7\xac\x34\x1c\xb7\xe9\x1f\x3a\x1c\xc7\xcb\xd7\x1e\x4e\xce\x8f\x68\xa5\xf1\xe4\xda\xfe\xa1\x03\xb2\xfb\x76\x47\x64\x7b\x2f\xad\x34\x1c\xbb\xa1\x18\x04\x05\x78\x7a\x46\xff\xd3\xff\x63\x87\xa7\x71\x71\xc7\xe6\x78\x60\xad\x34\x38\xa7\xe5\x1f\x3a\x14\xdb\x53\xdc\x1e\x8b\xe5\x2b\xb6\xd2\x48\xac\x76\x7f\xe8\x38\x8c\xf7\x7a\x8e\xdb\x6e\x35\x0a\xab\xdd\x1f\xcd\x58\x25\xa3\x30\x1b\xef\x4a\x83\xa8\x9b\x76\x25\x0b\xc6\x59\xad\x58\xcf\x74\xaa\x81\xfa\xa5\x49\x9e\x1f\x75\x17\x26\x1a\x59\xe3\x81\x09\x5e\xae\x07\x2a\xd6\xfc\xdb\x97\xf2\x11\x17\x9b\xc2\x3e\xc6\xad\x99\x04\x54\xa2\x8e\x6e\xfb\xd0\xe5\xcd\x87\xba\xd6\xa1\x2e\x16\x4d\x9a\xaa\x9a\x1d\x0c\x91\x94\x1c\x8a\xa7\x3e\x0a\xd2\xd6\x29\xfa\xb9\xd2\x9f\xe8\xe7\xda\x6e\xd3\x9a\x80\x78\x08\xfe\x34\x49\x78\x94\x41\x3a\x3d\x9f\xb0\x6c\x64\xda\x74\x4d\x9b\xae\x72\x89\xc4\x24\x4f\xd1\x60\x51\x3b\xd8\x87\xbb\x77\xdd\xf7\x15\x13\x83\x8f\x7a\xb0\xcb\xaf\x10\x4b\xac\xf7\x16\x13\xb8\x59\xf1\xe8\x26\xf9\x02\xf9\xe6\xd3\x04\x9c\x13\x4d\x04\x45\xc8\x9c\x61\xde\x35\x3b\xb9\x70\x24\x3e\x3b\xfb\x70\xf7\xf5\x5d\xd8\x81\x7a\x81\x18\x38\x46\xca\x6b\x78\xd7\xb3\xaa\xcc\x3b\xee\xd8\x77\x28\x61\x3c\xbe\x9b\xd5\x6a\x64\xbf\xa8\xf1\x51\xea\x66\x09\xd9\x8a\xee\x27\x35\xb6\x02\x61\x67\x1d\xcf\xee\x46\x75\xbe\xe7\xd4\xc7\x01\xfc\xc7\x5d\xfb\x9d\xf7\x16\x00\x1d\x9d\x6f\x1e\xf9\x2b\x7b\xe4\x55\xc3\xcd\x8f\xf1\x9f\x53\x36\x48\x58\x16\xf8\xcf\xa7\x49\x9e\xc0\xea\x3d\x4b\x79\x77\xff\x0b\xc1\xee\xcc\xba\x56\x27\x3b\xf3\x6e\xa1\xcb\xa5\x51\x39\xe7\xbf\x07\x3c\x59\x80\x87\x7a\x57\x53\x8e\xcf\xf3\x1b\xf1\xd9\x99\xf5\x9c\x6f\xbd\xdb\xe3\xca\x12\x7f\x21\x8e\x89\x42\x50\x42\xc4\xcf\x08\x03\x2b\x61\x19\x56\xc5\x32\xd1\x40\xfc\x91\x58\xe9\x99\x6c\xd6\x35\xe7\x00\x87\x5d\x4d\xf1\xac\x87\x6f\x46\x7a\xce\xcb\x17\x80\x39\x16\xcf\x7b\xce\xdb\x17\x28\x7f\x27\x53\xf1\x52\x06\x20\xec\x74\x4f\x7b\xf2\x06\xb5\xf0\xc0\xc5\x71\x49\x45\x7b\x04\x29\x35\x11\xbf\xc0\xac\xfe\xcf\x00\xe3\x5b\x5a\x3e\xae\x98\x11\xd8\x8a\x81\x29\xe3\x5f\xaa\x06\x12\x40\x1f\x03\x5b\x26\x8d\x1c\xfc\x20\x25\x37\x5c\x3e\x9e\x64\xf3\x67\xf0\x3a\xbe\x44\xa3\xa1\x20\xff\xbc\xdb\x68\x15\x57\xe6\x7e\xc5\xca\x2c\x8a\x0a\x24\x49\x91\x7b\x71\xd6\xe6\xdd\x5c\x3c\x25\x71\x9e\xf5\xc4\x81\x56\xf6\x0c\x7e\x1c\x44\x7e\x30\x10\x52\x12\xc3\xe1\xd7\x67\x1d\x6f\xde\x69\x3c\x83\x17\x31\x44\x71\x36\xd2\x56\x1a\x6d\xdf\xbb\x53\x27\xc2\x3e\x55\x62\xbd\xd1\x80\x4f\x2e\x7c\x96\x70\x05\xc8\xd3\x3d\xb1\x68\x00\xf5\x59\xcf\x13\xdc\xeb\xc7\xa1\x10\x0e\x4c\x5a\x5d\xdb\x6d\x38\xfc\xe7\x34\xb8\x64\x21\x8f\xb2\x70\x7e\x03\x82\x08\xe2\x59\x6e\x3c\xd6\x14\xfe\xce\x93\xf8\x19\xbc\x0a\xa2\x22\x89\xad\x41\xe8\xc4\x33\xc4\x12\x82\x11\x9b\xc8\x77\xc8\x2a\x0d\x6b\x78\x68\x88\x4d\x4a\x27\xa2\x20\xb9\x56\x99\x88\x9c\xa1\x8c\xe1\x46\x7f\x67\xab\x60\x0e\xc3\x55\xd5\xeb\xe8\x75\xe2\x38\xe7\xcd\xf1\x03\xad\x14\xe7\x43\xd8\x93\xdc\xdf\x53\xc3\xdb\x91\xc3\x9b\xf7\xba\x6e\xc5\x8e\xac\xd8\xc1\x8a\x1d\xac\x88\xef\x99\x7a\x79\x88\x4a\x23\xc0\xb4\x7b\xd8\x83\x73\xcf\x1d\x76\x72\x35\x3a\x85\x1a\xb0\x8f\xaf\x90\x54\x9e\x9c\x7a\x7d\x12\xa8\x0c\xc7\xcc\x8f\xd3\x3a\x41\x85\x1d\xb9\x7a\x9b\x84\x1e\x5e\x0f\x0b\xc5\x23\xc4\x11\x84\x9d\x6e\xd9\x35\x7b\x86\xdd\x87\xd0\x16\x15\x9c\x0f\x3d\xfd\xa1\xe7\x38\x33\xbe\xa4\xa7\x3f\xa4\x68\x64\x64\x26\x56\x99\x26\x2a\x56\x86\x47\x2f\x07\xb3\xd8\xf6\x69\xd4\xcc\x94\xa1\x37\x86\xcb\x3e\x96\x49\x3b\xcf\x39\xf8\xda\x27\xeb\x68\xa6\xd3\xac\x33\x37\x1f\xc8\xbc\x4c\x00\xb4\x61\xca\x82\x74\x80\x02\x47\x37\xa5\xbf\x3a\x5e\x47\x6e\x16\x9a\xbf\x3b\xf0\x54\x8a\xc2\x79\xaf\xd3\x28\xdf\x41\x08\x1f\xc5\x31\x55\xac\xac\xeb\xcc\x7b\xdd\x46\x6e\xcf\x67\x89\x9f\xdb\xf0\x3d\x48\x8c\x9f\xb8\xaf\x9e\x3d\x02\x50\xc6\x21\x0f\xe6\xb8\x93\x14\x37\x12\x7c\xc0\xa7\x79\x45\xf0\x86\xf3\x7a\x02\x5f\xf2\xe9\xcf\x69\x10\xb9\x9f\x71\x1b\xc2\xd7\x65\xb3\xdc\x26\x84\xef\xd2\xe6\xb9\x67\x18\x5d\xf8\x3f\x04\x6e\xb9\xe7\x1e\x3e\x7a\x0b\x32\xb1\xb1\xb0\x2e\xf4\x41\xbe\xe1\xf8\x5a\xf6\x0e\xe4\xc7\x5b\xed\x1d\xf8\xfa\x8c\xa6\x56\xa9\x72\x25\x3b\x04\xc2\x2f\x5d\x0b\x18\x9c\x35\xe1\x97\x41\x3c\x4d\xe5\x5b\x0e\x4b\xe0\x5a\x78\x69\x81\x6b\x56\x88\xc2\x52\x48\x32\x6b\x9d\x08\x29\x9b\xab\x24\x1f\xee\x95\x2e\xa6\xfc\x52\x5a\x38\x22\x45\x46\x96\xf8\x8a\x8a\x3f\xf3\xff\xfa\xcf\xff\x9d\x70\x18\xc4\x11\x37\x24\xbc\xa3\xad\xac\x66\x0e\xf4\xf5\x18\xfa\x9e\xc1\x05\xf9\xa3\x51\x06\xce\x2b\x36\x7f\x06\xdf\x85\xc1\x04\xcb\x06\x41\x22\x5f\x04\x6b\x80\xe8\x9c\xd6\x69\x10\x3b\x0d\x18\xfc\x1d\x4f\x44\x3b\xe2\xbf\xc5\x59\x66\xe0\xc7\xe3\x49\xc8\x33\x2e\xdf\xa9\x3c\xa3\xa8\x87\xd9\x55\x2c\x50\x4f\x31\x97\x90\xaa\x81\xd7\x4b\x58\xcb\xe9\xed\xa9\x75\xfe\x2a\xa5\x56\x85\xb8\xe8\xe2\x2f\xff\xca\x2c\x79\x7c\xe3\x69\x6b\x94\xf8\x32\x74\x8e\x05\x4b\x03\xb1\x65\x4b\xa7\x42\x9e\x74\x0a\x5b\xa3\x3d\x5f\x51\x1c\x35\xe5\x9c\xbd\x28\xdd\x26\xf5\xc0\x17\xf1\x48\x05\xc2\x52\x44\x8a\xe6\xfb\x30\x09\x2c\xa9\x58\x35\x08\x6c\x6c\xcb\xa4\x6e\x51\x94\xd2\xb0\xec\x9a\x28\x9e\xb4\x67\x93\x16\x96\x82\x5d\x0a\xd2\xf2\xca\x83\xd1\x17\x39\x1e\x8a\x2a\x23\x1a\xf1\x15\xfe\xb8\xa4\x1f\x23\xeb\x4b\x93\xbe\xd0\x51\x0e\x71\x54\xd9\x94\x4a\x8e\x92\x2a\x9e\x37\xf6\x22\x33\x99\xad\x13\x55\x43\x48\xb9\x32\x2b\xc7\xc2\xa4\xa2\x7f\x74\x18\x8d\x2f\x17\xec\xa2\x7b\x7a\x3a\xe0\xa9\xcf\xa3\x41\x10\x5d\x54\x42\x7f\x74\xdb\xa4\x36\xbd\xd3\x53\x94\xe0\x41\x36\x5f\x00\xfc\x96\xb8\xef\x2e\x1b\xa8\xe3\xcb\xbe\x1b\xa6\x7c\x5c\x8b\x83\x64\x5a\x54\x58\x10\x37\x30\x8d\x93\xec\x27\xcc\x0f\xb7\x10\x5c\x6e\xce\x6e\x00\xb8\xe8\xa5\xf0\x12\x2f\x3b\x97\x7f\x9b\x6c\x59\x7f\x37\x00\x77\x89\x69\xcf\xbd\x87\x6c\x94\x3c\x66\xde\xc8\x00\xdd\x07\xcf\x93\x80\x3b\x51\xd9\xf1\xe9\xb8\xd1\xe1\x22\x15\x06\x9d\x6c\xb1\xe6\xc3\x6f\xe6\xcf\x8f\xe6\x4f\x99\xee\xdd\x14\x04\xd1\x80\x0b\x25\x54\x68\x6c\x07\x49\xc2\xe6\xf5\xc8\x7e\xde\x2c\x76\xe4\xca\x8f\xf8\xbe\xfa\xc6\x6b\xcf\x9c\xbe\x89\x7b\xc5\x38\x58\x94\x41\xab\x8a\xe2\x9e\x6c\xcc\x66\xf5\xe6\x6d\x5a\xdf\xfc\x7e\x9a\x75\xec\x67\x4e\xf6\x03\xc2\x89\x8d\xba\xd6\xe1\x06\x4c\x9c\xd0\x22\xef\xa6\x07\x83\x16\xd0\x89\x20\xc2\x04\xb6\x95\xde\x64\x42\x67\x98\x3a\x97\x52\x6f\xc2\xec\x4a\x56\x66\xa5\x68\x0f\x76\x76\xac\x70\xbc\xf8\x7a\x88\xb2\xd3\xfb\xe9\x31\x4e\xe5\x71\x20\xb6\x19\xfc\x0f\xe5\xeb\x43\xe6\x39\x0e\x4e\x3c\x08\x3c\xe4\x94\x46\x23\x9f\xe1\x5e\x26\xaa\xbf\xac\x7c\xc6\x29\x63\xec\x84\x73\x5a\xe1\xa8\x28\x0a\xce\x38\x9f\x6b\x0d\x39\x9c\x37\x7d\x0a\x45\x33\x90\x39\x27\x21\x4e\x44\x05\x64\x4e\xad\xbd\x59\x22\xe7\x8e\x52\xe0\x11\xef\x96\xf8\x62\xc4\x5d\xe0\x01\xa6\x06\x92\xdb\xaf\x69\x56\xa7\xa1\x9e\x78\x34\xe6\xdf\x4e\x1a\x7b\x3a\xf8\xa6\x56\x95\x10\xcb\x55\xe1\x1b\x42\xe1\x1f\x1a\xb2\xa2\x82\x8a\xb4\xa3\x46\x7f\x07\x3e\x8c\xf8\x1c\xed\x40\x69\x16\x27\x7c\x00\x01\xbd\x1f\x8f\x93\xe0\x22\x88\x58\x88\x70\x6a\x82\x0e\x03\x2e\x0f\x4a\x66\x42\x3d\xf8\x88\x69\x4f\xc6\xf0\x0c\x39\xa1\x09\x11\x6c\xc3\x04\xf9\x49\x94\xf6\xdd\x39\xf7\x68\xb5\xb1\xae\x99\xb7\xdf\xc4\x3c\xcb\x29\xf7\x40\x73\xc1\x6f\x82\x34\xf4\x74\x56\x28\x3b\x97\x32\x3f\xeb\x25\x6c\xc3\x47\x01\x55\xe8\x3e\x13\xa6\xc9\xe7\x46\xb3\x66\x19\xeb\xab\xe1\xe7\x64\x44\xdf\x96\x3a\x2a\x1f\x93\x25\x58\xb4\x18\xe8\x3b\x8f\x71\xd5\x9a\xeb\xbb\xab\x89\xa9\xd2\x89\xe2\x39\x47\x3f\x36\x97\x42\xa9\x76\xf3\x98\x04\xbc\xa5\xf6\xbe\x95\xee\xa6\x54\xa3\x35\x6f\xd7\x6e\x16\xdd\x78\xbb\x36\x09\x78\x03\x64\xaa\x2a\x73\xcb\x25\x90\x77\xb6\xdb\xd5\xae\x6c\x9d\x8d\xda\x73\xf6\x59\xd5\xa1\xa9\x53\xec\xf5\x36\xfd\x99\x9e\x74\xcf\x85\xfe\x72\x3d\x7d\x15\x57\xd2\xab\x4d\x53\xd9\x95\xb4\x18\xcb\x9f\x7f\x25\xbd\xda\x38\x8a\x57\xd2\x62\x14\x7f\xfe\x95\xf4\x6a\xa3\x28\x5e\x49\xab\xf8\xf4\x01\xaf\xb8\x1d\x7e\xf0\xe5\xcf\x4d\xab\x1d\xf0\x34\x12\xcc\x83\x73\xe7\xb2\xf5\x1c\xbe\x01\xa6\xb6\xfb\x73\x78\x8a\x3f\xe4\xdf\xfb\xf8\xa3\x03\x7d\xc0\x3c\xba\xa5\x43\x7d\xf8\xd5\x0e\x35\x17\xac\xaf\x02\xff\x47\x5f\xd7\x11\x77\x9a\x5c\xf2\xd3\x84\x0d\x02\x16\x56\x1e\xe9\x76\xbb\xb7\x0f\x18\xc9\x12\xce\x16\x00\xbe\x7d\xb4\xc8\x30\x88\xf8\xbb\x9b\xf0\x56\x67\xd1\x2f\x7a\x14\x5d\x2a\x5c\x90\x26\x45\xe9\xf2\x6f\xb4\x70\x22\x6e\x10\x21\xce\x5c\x29\x38\x58\x4a\x84\x78\x85\x17\x6d\xce\xa9\xcc\x17\x2a\x10\x01\x37\x81\xf6\xb0\x4c\xd0\xef\x1f\x26\xa8\x63\xd7\x14\x5a\x71\x09\x75\xe1\x2f\x1d\x13\xbc\xcf\x14\xd2\x0d\x0b\x6b\x31\x15\xc5\xaa\x35\xf3\x60\xc0\xd1\x6a\xc9\x5a\xb3\x3d\xfc\xe8\x46\xc9\x6a\xcd\x3a\x76\x95\x0e\xd5\xb1\xe3\x64\xb5\x66\x5d\xbb\x46\x97\x6a\x24\x3a\xfc\x57\x6b\x6e\x7d\x9e\xd3\xd7\x5c\x14\xb1\xd6\xdc\xee\x64\x2e\x3b\xc9\x85\x11\x6b\xcd\xed\x7e\xe6\xb2\x1f\x31\xae\xf7\xa5\x5b\xb8\xa5\x28\x2f\xe3\x12\x6a\xf3\xa7\x9a\x2b\x53\xa6\x02\x32\xd6\x1b\x42\xbf\xb6\xf0\xa0\x69\x31\xb8\x1c\x96\x6c\xc1\x5f\x02\x93\x6e\x39\x26\x16\x55\x5e\x96\xfb\xad\x7e\x01\x64\xe6\xe5\x64\xf9\xc5\x22\xcb\x51\xb9\xd7\xe9\x97\x40\xa6\x9c\x32\x9a\xf7\x71\x6d\xad\xa8\x5a\xf8\x37\xbf\x6c\x2e\x59\xef\xe7\x25\xf6\x9a\x06\x7a\x93\xd5\x1b\x2d\xaa\x5d\x74\x28\xab\xd8\x85\x1e\x7f\xb9\x5d\x28\x27\x68\xa5\xe8\x0c\x83\xe8\xe3\x0f\x3a\xdc\x33\xf5\xbe\xa0\xea\x4f\x32\xee\xf3\x8d\x15\xf5\x54\x7d\x75\xa1\x92\x31\xa4\x7b\xf5\xde\xd4\xbb\x65\x2a\xfa\xde\x17\xb4\x4b\xef\x9e\x9e\xe2\x15\x5f\x75\x56\x79\xbc\xa1\xbe\x5d\x9e\x75\x84\x7c\xe3\x8e\xfd\x44\x59\x8f\x8d\xc3\x9e\x98\xe6\xf7\x98\xd3\xbb\x18\x75\x19\x8b\x5d\xff\x3e\x51\xfd\x03\xe6\xa9\x2e\x54\x97\xf9\xbf\x0b\xd5\xeb\xb8\x78\xcc\x8e\xae\x33\x97\x9b\xae\x75\x64\x63\x04\x21\x3f\x51\x37\x7a\x0f\x5d\x68\x3f\x36\xb4\x55\x92\x66\x66\x1b\x8d\xe7\x4b\x37\x26\x31\x30\xb7\x1b\x2f\x0a\x15\x89\xe3\x2b\x89\x15\x29\xe4\xd2\xe5\x4d\x16\x6f\xc9\xc3\x0a\xe3\x34\x0c\x7c\x8e\xb9\x5f\x31\x0d\xbb\x65\xdd\x84\x54\x27\x5e\xcf\x1b\xff\x2e\x1b\x1e\xc6\x83\x26\xca\x15\xbf\xee\x99\x3b\xd9\x2f\x1a\x0f\x11\x09\x85\x5a\x96\x84\xee\xc1\xce\xcc\x41\x47\x0c\xe8\xf2\xb8\x83\x39\xe4\x25\x72\x0d\x0f\x76\xe6\x65\x23\xaa\x6e\x9a\x2d\x6e\x6a\x8d\x77\x8d\xd7\x3e\x62\x56\x5b\x9a\x4d\x57\x34\x6b\xc8\x56\xa7\xe8\xe0\xf2\x91\xcc\x18\xb4\x8e\xd4\xee\x81\xe0\x35\xab\xaf\x04\x5e\xb7\xb2\xc0\xab\x75\xe7\x80\x9f\xad\x0a\x79\xb6\xfe\x41\xbc\xb7\xdc\x41\x5c\xe1\x3d\xcb\xa1\x3c\x5f\x15\xe5\xf9\x1f\x8e\xf2\x3c\x87\xf2\x17\xf3\x64\x57\x1d\x56\xb9\xb2\x8b\xef\xae\xa4\xc5\xc5\x67\x74\x00\xb3\x0c\xdd\xc0\xe9\x0d\x93\x54\xc7\x7e\x22\xee\x29\xf7\x01\xf5\xc5\xf1\xc5\xad\x53\x5c\x6b\xf4\x0d\x99\x75\x65\xd4\x3c\x84\xd9\x91\x5e\xaf\x04\xbb\x04\x23\xa5\x6a\x6c\x1a\x1f\x8f\xce\x4f\x75\x8c\x88\x3e\x57\x38\x21\xcc\xce\x22\x7c\x68\x8b\x5c\x8c\xcd\xf2\x21\xf1\xf2\x1b\x6f\x29\x07\xc9\xd1\xe8\xab\xbc\xa5\xc2\xbd\xac\x00\x39\x4f\x06\xd3\x53\x6f\x73\x3d\x75\xdd\x31\xec\x6e\x16\x72\xd7\x99\x6b\xc9\x05\x93\xce\x71\xe7\xc4\x83\x49\x47\xc5\xe5\x29\xe7\x85\x49\x97\xaa\x75\x8f\xbb\xe2\x7f\x7a\xf4\xab\x47\xbf\x76\xe9\xd7\x2e\x81\xc8\x6b\x26\xd6\x72\x71\x74\x19\xa3\xb5\x98\x1a\x25\xcd\x35\x6f\x57\x34\x56\xdf\x4b\x9a\x4a\x36\x34\xfc\x16\x4a\xa5\xa7\x6e\x71\x29\x0e\x3a\xd4\xe7\xff\xd0\x3a\xff\x87\x74\xfe\x0f\xcd\xc9\x3d\xb4\x4e\xee\xff\x1f\x7b\x6f\xbf\xde\x44\xae\x24\x0e\xff\xcf\x55\x08\xce\xf9\xc5\x6d\x70\x1c\xdb\x01\x86\x49\xc6\x93\x65\x02\x33\xc3\xee\xf0\xf1\x10\xe6\xcc\xee\x06\x1f\xa7\x63\x2b\x71\x13\xbb\xdb\xdb\xdd\x06\x3c\x24\xef\xfd\xbc\xd7\xf1\xde\xd8\xfb\xa8\x4a\x1f\x25\xb5\xba\xdd\x8e\x03\x87\xf9\x2d\xb3\xcf\x1e\xe2\x96\x54\x2a\x95\x4a\xa5\x52\xa9\x54\x35\xc5\x93\xbb\x42\x08\xba\x77\xcf\x28\xdf\x7f\xe9\x33\x4a\x86\x39\x74\xbf\xc6\xc3\x04\xa2\x36\x44\x37\xb0\x8a\x43\xc5\x35\xd5\xf3\x9e\xe9\x21\x4d\xb2\xac\xa2\x83\xde\xb5\x4f\x16\xb2\x83\x71\x14\xce\x92\x78\x5c\xd1\xc5\xee\xb5\x8f\x18\xb2\x8b\x2c\x0f\xd3\x0a\xf8\xf7\xaf\x07\xff\x81\x81\xff\x3f\x8b\x30\xad\x9a\x85\x6b\xfa\xed\x3c\xd4\x3d\xe4\x69\x04\x6b\xaa\xa2\x8f\x6b\x1e\xf1\xbe\xd3\x7d\x7c\x58\x56\x81\xbf\x26\xab\x3e\xaa\x7b\x3a\x35\xff\xc1\x81\x4b\xae\xbc\x3e\x3b\xbe\x55\x95\x3d\xb3\xb8\x12\x4a\xfc\x70\xd6\x60\xf5\xb5\x21\x78\x78\x79\x6d\x18\x45\x66\x5a\x1b\x84\xcb\xef\x6b\x03\xf0\xb1\xdb\xda\x40\x1c\x7e\xf2\xb4\xbf\x35\xd8\xc4\x53\xd0\x63\x6f\x97\xcf\xf0\x56\x6e\xee\x8f\x36\x70\x77\xaa\xc5\x68\x5a\xd9\xc8\x30\x83\xf7\x0d\x60\xf4\xf0\x7e\xb3\xce\xa1\x1e\x71\xf3\x1c\xeb\xbf\xe4\x61\x5a\xcc\x43\x89\xa7\x4f\x7b\x9c\x86\x1f\xc8\x39\x5b\x10\xa8\xcc\x29\xe8\x46\xce\xc3\x48\x10\x99\x28\x7a\xcd\x03\x2b\xb6\xd9\xf0\x98\x56\x83\xd9\x9a\x2d\x89\x66\x53\xbe\x9e\x37\x67\x26\x89\xbe\xe4\xa3\xf5\x8e\xf3\xd8\xe6\xb3\xa3\x7f\xcf\xc6\x5f\x74\x5b\xc0\xff\x9a\x87\xcd\xea\xb3\x26\xed\xb5\xec\xb0\x89\x35\xfc\xb6\xee\x5e\xe7\xab\xba\x71\x8d\x93\x64\x5e\xba\x35\x76\x77\xaf\xa9\x3a\x74\x87\xc3\xd3\x30\x8b\xca\x35\xb7\xee\xae\xdc\x75\xb5\x0c\xf9\x49\xd4\x3f\x9c\x26\x19\x1f\x07\x5a\x56\x98\x57\xda\x66\x52\x34\xd1\xaf\x6e\xdd\x22\x8d\x0a\x6f\xa2\xc3\x94\x87\x70\x75\x56\x95\x47\x52\x53\xa0\x64\xa7\x11\x40\x9e\xc6\x95\x39\x48\x57\x81\xd0\x57\x78\x1e\x47\x76\xbf\x57\xbd\xfc\xb3\x67\xfe\xdc\x35\x7f\xde\x67\x7d\xd2\xd4\xf5\xb6\x97\x7f\x9a\xa6\x4b\xd3\x74\x79\x9f\xf5\xd1\x93\xc1\xb4\x87\xe3\x26\xf8\x32\xd2\xb7\xd3\x30\xe2\x02\xb2\xd9\x87\x28\x1f\x4d\x94\x9f\xbf\x8c\xcc\xa6\xb3\x88\x84\x19\x67\xdd\xbd\xc2\x9b\x33\x37\x32\xa7\x1c\x9a\x7e\xda\xdd\xa3\x91\xd3\xac\x16\x56\x48\x22\x55\xe5\x34\xe5\xe1\x85\xed\x12\x29\xfb\xee\xad\xec\x5b\x77\xce\xee\x41\x2c\x01\x45\xdb\x26\xdb\x61\xbb\x2d\xfd\x7e\xc1\x2e\x5e\x62\x71\x29\x96\x32\x4a\x5b\xa0\x27\xca\x82\xdd\x73\x60\xdb\xc5\xcb\x5e\x35\xec\x35\x29\xb0\x5b\xa0\x00\xcc\x51\x0d\x9a\x5b\xf5\x76\x5b\x66\xe8\x55\xf5\xee\xeb\x7a\xf7\xab\xd1\xd3\xaf\x4e\xa0\x79\xc9\xab\x7c\xfb\x51\xde\x7e\x4d\x86\xeb\xec\x39\x7c\xdc\xdd\xa7\xab\xe7\x63\x8b\x2e\x88\xe5\xbe\x8d\x9d\x62\x59\x1b\x42\x6f\x9f\x2e\x3a\x03\x61\xb7\x0c\x42\xcf\x85\xb0\xbb\x4f\xd6\x2a\x81\x70\x1f\x21\x54\xf2\x66\x87\xdd\x63\xf7\x0d\xff\x40\xf2\x41\xc1\x24\x0f\x5b\xe4\x7d\x0d\xad\x02\x8f\x22\x21\x3c\xf5\xc3\xa6\x83\x9d\x94\x43\xf5\x62\x94\x48\x71\xad\x32\x42\xe0\x58\x30\x74\x19\x68\x48\x30\x57\x56\x07\x57\x65\x12\xac\x45\x65\xd9\xc7\xfd\x32\x69\x65\x45\x77\x58\xde\xc0\x2b\x1e\xcd\x57\xd6\xf6\x41\x82\x6a\xf8\xb6\x98\x92\x4d\xba\xfb\x55\x6d\xd2\xf5\xf6\x52\x7b\x2b\x7d\x39\xe7\xf1\x9a\x1b\xa9\x68\x52\xb5\x8d\x96\x6c\x5f\xf0\x2c\x99\x6e\x21\x7a\xd3\xac\x6e\x20\xb7\xa2\xab\x6b\x6d\x92\x15\x7b\xe0\x06\x5b\x9c\x79\xcd\x0a\x38\x5e\x5e\x5a\x3f\x6f\xf7\xfb\xac\xc3\xb6\xb6\x6c\xc0\xfd\x3e\xdb\x6d\x36\x57\x89\x6e\x6b\xe4\x5d\xb6\x4d\x3e\xec\x7f\x59\xf9\x58\x4f\x06\xd6\x93\x73\x3a\xee\x46\x0d\xf9\xb5\x24\xf5\xca\x85\xd8\x3e\xa5\xd4\x81\x7f\xb3\x95\xf7\x03\x6c\xcf\x2f\x4b\xd5\x65\x88\x67\x0c\xbb\xee\x18\xee\x43\xd4\x9e\x79\x9a\x8c\x38\x1f\xaf\x2d\x37\x3b\xff\x8b\xe4\xa6\x25\x4f\x4a\xa4\xe6\x57\x95\x76\x7c\x6d\xa9\xb9\x88\xc7\x53\x72\x1b\x7f\xca\xd5\xfb\x2e\xa4\x37\x80\x93\xef\xae\xea\xb1\x04\x1e\x07\x80\x7a\x82\x25\x08\xf5\x34\x4c\x9e\x87\xac\x0f\x5d\xa1\x18\x06\x1c\x0a\x32\xb8\x86\x74\x64\x7d\x76\x3c\xb0\x78\xa6\xf0\x05\xf0\x32\x1e\x85\x41\xb3\x86\x40\x84\x05\x6e\x78\x94\x44\x34\x30\x1c\x49\x9e\xb7\x09\xc6\x55\x27\xe9\x6d\xd6\x25\xa1\x44\xdf\xd9\xef\x9b\xb4\xe0\xf8\xe8\xa4\x07\xc1\x48\x09\xce\x47\x4c\xa9\x7c\xfc\x6e\x50\x88\x42\x82\x69\x95\xb1\xc4\x0e\x43\x12\xb1\x3e\xdb\xb6\x83\x71\xe8\x00\x1c\x1f\x26\xd1\x94\xb3\xe0\xde\xbd\x88\xfd\xd0\x87\x37\x47\x46\xcf\x65\x7d\x16\xb1\x1d\xf6\xce\x55\xca\x91\x7a\xa8\x01\x53\xa0\x66\x1e\xef\x32\x78\xe8\x75\x8f\x05\x46\xbe\x23\x13\xdd\x95\x57\xc1\x39\x24\xda\xb5\x43\x87\xd0\xf6\xcb\xf2\xf6\x3a\xcf\xf8\x78\xd9\xd4\xcd\xfd\x39\xfe\x0c\x47\x18\x4e\x50\xd6\xa9\x22\x2f\x3c\x8d\xc7\x84\x13\xaa\xb6\x20\x09\xb7\x3d\x5f\x64\x93\xe0\xde\x47\x6b\x63\x5b\xca\xaf\x32\xe0\x93\x12\x48\x37\xe4\xe5\x1c\x90\x2b\xe9\x2c\x4f\x66\x81\x5a\x9b\xd4\x08\x79\x6a\xad\x5f\xc7\xce\x83\x0b\xad\x2f\xb6\xde\x83\x1b\x58\xc1\x6c\x0f\x05\xa3\x4f\x64\x68\x23\x20\x22\xd4\x96\x6b\x5c\x93\xd4\xc8\x15\x8d\x9d\x1c\xd5\x3d\xd3\x9e\x5a\x93\x10\x8e\x10\xb9\x41\xa7\xfd\xe8\x41\xd3\x27\x79\x3f\x57\x3c\xbe\x6b\xba\xf1\x87\xe9\x38\x8a\xc3\x29\xea\xda\x15\xd7\x3a\x8f\xae\x6d\x5e\xfa\x3c\x76\xab\x9e\xc0\x3d\x9f\x2d\xa6\xd3\xd7\xc9\xac\xc2\xed\xb0\x27\xaf\x8c\x34\xf3\x1d\xea\x56\xf6\xf9\xa2\xc5\xc2\xe9\x7c\x12\xae\x50\xc0\x55\x11\xd4\x65\x7d\x6c\x03\x1b\x82\x0b\xf7\x7a\x56\xae\xee\xe6\x56\xae\x55\x20\x6e\xde\xca\xa5\xfe\x7c\xb0\x99\xc1\x4b\xfe\xf9\xa0\x78\x30\x98\x76\xba\xc3\x50\xd7\x98\x76\x7b\xf4\x57\x6f\x57\xfc\x72\x6a\xf7\xec\xea\x3d\xbb\x7e\xcf\x6e\xf0\x2f\x32\xad\x55\x98\x6f\x3e\x83\x69\x4d\x25\x29\xf8\x6c\x7d\xaf\x30\x6a\x6d\x66\xac\x2a\xd6\x7b\xa0\xeb\x3d\xf8\x0c\x46\x2d\xe7\x8c\xe9\xcc\x33\x86\x5b\xdb\xa5\x4b\x63\x9b\x7d\xb4\x63\xae\xed\x52\x96\xdf\x66\x4b\x3b\x1a\xa6\xe4\x5a\x12\x08\xcd\xe6\x4e\x2c\x98\x27\x1f\x02\xd1\xcf\x5d\xe8\xed\x1e\x40\xbd\x2b\xfe\xb7\x45\xc5\x50\xd3\x0e\x8e\xb3\x91\x2d\xae\xa6\x25\xad\xdc\x16\xe7\x67\x75\x8f\x79\xcd\x7b\xea\xab\xb0\xd0\x3d\xb0\x40\x3c\xf0\x60\x56\xff\x34\xe8\x6c\x1e\xfa\xa2\xb2\xce\x91\xb0\x5a\x2c\xb5\xca\x65\x94\x2b\xd0\x0a\x22\xaa\x55\x25\xb0\xf6\x6b\x9d\x45\x15\x3b\xb6\x2c\xdb\x6a\xbd\x03\xaa\x62\x56\xc7\x12\xfb\x25\x94\x44\xbd\xf3\x52\x2d\xd1\xcc\x50\x89\xa6\x88\x7b\x30\x2a\x89\x2b\x77\xf5\xbd\xd5\xba\xa4\xab\x0b\x29\xb6\x38\xb4\xbe\x53\xed\x12\x73\xc8\x4b\xae\x30\xf8\xb6\x95\x76\x60\x1e\xb3\x1a\xd5\xa2\xa0\x4a\x62\x59\x41\x97\x34\xe0\xa4\x3e\xe9\x57\x27\xbf\xb2\xc0\x47\x92\x54\x2f\xe7\x3c\xae\x50\x26\xbf\xbf\xb6\x32\xb9\x8e\xce\xe7\x51\xf9\xa8\x69\xe4\xe6\x14\xbe\xbf\x92\x35\x96\x08\x86\x7a\xba\xda\xd7\xab\x8a\xfd\x75\x4c\xc0\xff\xeb\xb4\x89\x9b\xb4\x5c\x93\xc9\x28\xb1\x32\xbb\xbb\xde\xb2\x57\x6a\x71\xf6\x54\xfd\x02\xd6\xe7\xee\x37\x7d\xe3\xff\x5a\x7d\xc3\xbb\xa5\xac\xa1\x6d\xe0\x56\xe9\xea\x1a\xe2\xeb\x57\xa6\x69\x7c\x81\x50\x21\x37\xeb\x0d\x45\x34\x00\x0c\x70\xb0\xae\xcf\x12\x6d\xf5\x17\x76\x5a\xba\xde\x9e\x2a\x45\x7d\xe5\x4e\x79\xad\xbb\xd0\x15\x5d\xa8\x9b\x43\x10\x85\xd0\x00\xe2\x92\x39\x5b\x4c\xcb\x2f\xde\x75\xab\xcf\x7d\xd1\xe6\x65\xa8\x92\xbb\xb6\x2f\x10\x78\x46\x8e\x2a\x88\x66\xb3\x45\x1e\x9e\x4e\x79\x73\xc5\x08\x67\x49\x9c\xe4\x49\xcc\xff\xf3\xba\x60\x4e\x2d\x30\xff\xb5\x6f\xd6\x5a\x16\x9d\xc7\xc1\x47\x8b\x62\x1f\xad\x48\x7d\xb0\xb6\x76\x76\xd8\x61\x38\x1d\x2d\xa6\xa1\x8c\x09\x97\x4d\x93\x39\xcf\x58\x82\xe1\xd6\x65\xa0\xf5\x8c\x05\xbf\xf2\x74\x16\xe5\x7c\x1b\x96\x1e\x24\xcf\x9f\x27\xd3\x50\xf4\xd4\x64\xa7\xa1\xd8\x1e\x92\x58\x40\x13\xad\xce\x92\xe9\x34\xf9\x10\xc5\xe7\x6c\x1e\xce\x79\xba\xc7\x8e\x72\x7e\x76\xc6\xe3\x16\x7b\xde\x66\xdd\xef\xbf\xef\xb4\xd9\x63\x76\x14\xcd\xe6\x53\xce\x9e\xf3\x7c\x92\x8c\x21\xa4\xdc\x73\x1c\x45\x34\x12\x70\x9e\xd1\x2e\x58\x14\xb3\x97\x31\x67\x4f\xa2\x19\x8f\xb3\x28\x89\xdb\xec\x71\x96\xa7\x49\x9c\xcc\x96\x90\xad\x00\x7e\xcd\x27\xcb\x2c\x1a\x65\x2d\xf6\x8f\x64\xda\x66\xbd\xdd\xef\x5b\xec\xc5\xcb\xb6\x00\xf6\xe2\xe5\x3f\x82\x67\xcf\x9a\x2d\xf6\xaa\xcd\xee\xdf\xdf\x6d\x21\x12\x84\x56\x62\xd0\xbb\x41\x3e\x09\x73\x95\x5f\xc3\xb8\xab\x4f\x70\xeb\x0c\x73\x19\x0b\x5b\xfe\xa9\xef\xce\x26\x3a\x2f\x86\xaa\xa4\xdd\xca\xe5\x05\xbe\xf8\xba\x34\x4d\x97\x1d\x08\x92\x3f\xe9\x08\x5d\x79\xd2\x85\x49\xd9\xda\x62\xdb\xe6\xf1\x5b\xd6\x85\x17\x77\x06\x26\xbe\xbb\x0b\x26\x5d\x68\xd2\xf1\x34\x99\x8b\x16\x59\x87\xdd\x15\x10\xef\x09\x08\x77\xd9\x44\x77\x74\x8f\x4d\xf0\x01\x9c\xe4\x84\x00\xb8\x23\x83\x30\x7a\xf8\x67\xb7\xd9\x54\x21\x90\xad\xd8\x90\x59\xa7\xd9\x32\xd1\xbe\xb3\x6e\xb3\xc5\x3a\xed\x07\xaa\xaa\xf8\x36\x6f\x42\xde\x85\x4e\x91\x9f\x42\x96\xc4\x7c\x3b\x8b\xc6\x7c\x8c\x24\x76\x49\xde\x93\x24\xcf\x09\xb5\xfd\xc4\x26\xb8\x83\xcb\xb1\x50\x99\xcb\x28\x3b\x11\xbf\x31\x07\xe1\x1e\xcb\x15\x5a\x8f\x47\xa3\x44\x6c\xea\xe7\x2c\x4f\xd8\x24\xcf\xe7\xd9\xde\xce\x0e\x8f\xdb\x1f\xa2\x8b\x68\xce\xc7\x51\xd8\x4e\xd2\xf3\x1d\xf1\x6b\xe7\x70\x71\x1a\x8d\x86\x92\xe3\x87\xd9\x5c\xc8\xc2\xbf\xbd\xe6\xf3\x94\x67\x3c\xce\x81\x23\x33\x01\xf2\xce\x32\x59\xb0\x51\x18\x8b\x05\x9b\xf2\x2c\x63\x23\xd1\x90\xc9\x86\xf6\x2a\x81\xb0\x8a\x3c\x9d\x65\x98\xed\x48\xd4\xfb\xe9\xff\xfb\x7f\xff\x8c\x78\x8a\xaf\x46\x01\x20\x44\x6c\x4f\x79\x36\xe7\xa3\x5c\xa0\x89\x8b\x69\x91\xaa\x58\x94\xf3\x4e\x8b\xcd\xc5\x6c\xce\x3a\xe8\x26\x39\x17\x63\x9f\x75\xd5\x8f\x3b\x84\xc0\xca\x4a\x0b\xf4\xed\xb4\x58\x4e\x9e\x9e\x7e\x24\x2c\xdd\xb1\xa2\x05\x29\x3a\x5a\x71\x85\x5c\xbe\x5e\x9a\x8f\x26\x8b\x0b\x5c\x39\x07\x3a\x5a\xfc\x0e\xdb\xc5\x53\xbb\xa8\x55\xfa\xe4\x17\x82\xfe\xb3\x25\xfe\xc1\xee\x02\xa2\x00\x02\x3e\xe3\x1f\xe2\x73\xd9\x03\xe0\xe7\x4a\x7e\xd6\xd7\x26\x74\x93\xbf\x8a\xa9\xa0\xdc\x3e\x40\x4a\x20\x05\xf3\x67\x75\x55\xee\xb9\x47\x39\xfb\xd4\x47\x0e\x15\x65\x47\x39\x73\x6f\xd0\xd2\x58\xb7\x8c\x20\xa0\x9f\x9b\x3e\x0f\xa0\x6b\x1a\x1a\xba\x9f\xdf\xd0\x00\xaf\x9a\xb4\x27\x5d\xa5\xca\xf5\x11\x70\xd2\xb3\xbb\xb5\x25\x6a\xf4\xcd\xac\xea\xac\x06\x10\x5d\xff\x3c\x4e\x52\x4e\x73\x3a\x00\x16\x59\x7b\xe3\x1b\x86\x4a\x6f\x31\x18\x59\x99\xaf\x58\xe1\x6c\xbc\xb1\x65\x81\xf2\x85\xcd\x0d\x82\xa4\x7a\x6f\xd6\x27\xf3\x26\x08\xb3\xb2\x5b\x07\x3f\x97\x95\x81\x2a\x3f\xe5\xdf\x8c\xa7\x99\xb5\x3e\xf3\xae\xd4\x89\x3d\x12\xec\xbf\xaa\x25\x98\x50\x76\x5f\xf3\xb3\x29\x1f\xe5\x87\xf8\x91\xaa\xbb\xb7\x6e\x05\x1a\x8e\x25\xd6\xd0\x24\xd2\x1e\xa5\x3c\xcc\x79\xe0\x11\x7d\xcd\x66\x5b\xcd\x84\x87\xb3\x3d\x0d\xb0\x3a\xc6\x8f\x41\x42\x2e\x5b\xec\xa3\x40\x82\xe6\x0c\x2c\x41\x75\xa5\x70\xb6\xdb\x15\x24\x74\x59\x82\x3e\x3f\xab\x22\x62\x95\x79\xf6\x2a\x04\x43\x75\x62\x3c\xff\xca\xa1\x3d\xae\x99\x6a\xce\x01\x68\xef\x94\x3a\x00\x46\x4f\xb6\x93\xfd\xd8\x44\x9f\xf9\x37\x43\x72\x5c\x2a\x6e\x97\xf6\x76\x3a\xf3\x33\xa3\x07\xc2\x7f\xd9\x10\xdc\xb3\xd6\xe7\x0a\x92\xa9\x31\x7d\x11\xe6\x8b\xd4\x44\xd9\x58\xcd\x59\xb2\xc1\xd7\xbb\xe9\x57\xf8\x23\xde\xa8\xcb\x61\x4c\x5c\x0e\x89\x49\xbc\x90\x8c\xa5\x72\x87\x80\x98\x17\xcb\xe3\xce\xa0\x7c\x9f\x30\x55\x94\x88\x86\x6e\x60\xb3\xeb\x35\x57\xf9\x47\x7c\x84\xe0\x1a\x4b\x15\x97\x03\xa4\xb3\x9d\x6b\x4d\x06\x51\xf9\x28\xe7\x39\x4d\xa6\xaf\x60\x6f\x0c\x6c\x77\x41\xc6\xe6\xcb\x42\x95\x25\x71\x55\x80\x60\xe6\x90\x8e\xa0\x83\x11\xcd\xa3\x2e\x6e\x94\x51\x57\xc7\x2d\xef\xb4\xc4\xff\x76\x29\xd6\x2e\xde\x4e\xc4\x10\x31\xfc\xe3\x08\x22\x83\x2c\xcd\x9f\x62\x54\xfa\xab\xfa\xf3\xe3\x71\x84\x63\x8d\xc8\x60\x69\x86\x7b\xb2\x35\xd5\x54\x81\xe2\x1b\x52\x7c\xaa\x5d\x23\x6f\xde\xff\x71\x87\x1d\x71\xae\x0f\x67\x1f\x3e\x7c\x68\xcf\xc3\x34\x8f\x46\x53\x1e\xc5\x23\x3e\x9d\xb6\x47\xc9\x6c\xa7\xd7\xe9\xf6\x76\x90\xdc\xdb\x78\x36\xcb\x76\x60\x16\xc7\x3c\x8d\xde\xc3\x61\x8b\x1c\x83\x5c\xde\xd0\x67\x20\x1d\x07\x3e\x76\x7c\x70\xd5\xf7\x99\xfa\x23\x2c\xc9\x1d\x71\x5a\xf2\x3d\x75\xbe\x8b\x01\x86\x18\x5b\xac\xd3\x62\xa7\xf8\x57\xaf\xc5\x52\xfc\x4b\xb0\x8a\x7c\xe5\x26\xf8\x43\xd4\xd6\x01\xf6\xbb\x32\x7a\x3e\xf8\x06\x63\xd6\x84\x10\x73\x23\x74\x05\x24\xf8\xeb\xbe\x80\x84\x7f\x19\x8f\x5a\x84\x16\xb1\x7b\x0c\x21\x86\xc7\x00\x43\xf6\x7c\x6a\x7e\x7d\x27\x5a\xeb\x5f\x8f\xa0\x99\xfc\x79\x4f\xfc\xe9\xc7\x47\xe2\x32\x63\x7d\xc4\x67\x47\x20\x03\xad\x24\x5a\xdb\x7d\x36\x93\x78\x89\x3f\xd9\x5d\xf1\x37\x54\x70\xb0\xd1\x9d\xef\x68\xac\xac\x1e\xc5\xa7\x9e\xe8\xf5\x47\xc8\x1f\xb1\xbd\x6d\x48\x10\x20\x78\xf1\x13\xc6\xd9\x44\x34\xa0\x3d\x19\x61\x20\x46\xc1\xee\xe9\x4e\xc1\x32\x60\xf5\xd1\x29\x52\x59\xd2\x96\x92\x91\xf4\x44\xac\x11\xc7\x61\x8b\x9d\x0e\xd0\xc8\xf0\xd9\xcc\x9c\xee\x6e\x57\x62\xe1\xfc\x8c\x41\x41\xaf\x61\x9a\x1c\xc1\xe0\xb2\x9c\xcf\x7f\xe2\x67\x49\xca\x37\x33\x71\x0a\x38\x8f\xcf\x72\x9e\x12\x25\xe0\x28\xe7\x73\x73\x33\xb3\x4a\x09\xd0\xaa\xb8\x10\x66\x30\x61\xa2\xfd\x57\xad\x10\x18\x99\xbb\xe1\x13\xad\x0e\xfb\x41\x8f\x5e\x1f\x91\x73\xf6\x03\xeb\xfa\x4e\xcc\xbd\x92\xcb\x00\xa5\x60\x28\xbc\x9a\xee\x4d\xc2\x4d\x9f\xcb\x1d\xc8\x42\x04\x34\xc9\x2c\x9a\x0d\x2b\x6f\xdd\xb8\xb3\xc0\x5f\xe3\x84\x5d\x7e\x1b\x6e\x54\x15\x43\xc5\x9c\xfd\xd0\xb7\x93\xe6\x54\xbb\xa7\x9a\xcb\x9f\x2a\x55\xcd\xae\x55\x50\xd3\xa4\x82\x4a\xee\xa9\xd9\x5d\xfa\x62\x23\x6f\x8a\x9d\x46\x3f\x6d\xcb\x57\x77\xd8\x75\x39\x70\x45\xe5\xa5\x47\xad\x2a\xf5\x51\xa5\xeb\xcf\xb0\xfa\x97\x7a\x39\x66\x8b\xb4\x4e\xfb\x81\x92\xf5\xc6\x70\xae\x05\x6a\x5d\x20\xce\x21\x4f\x4b\xd2\x9a\xed\xbb\xfe\x23\xde\x67\x8c\xee\x76\x8d\x7b\xe8\xcf\x14\xac\xb9\xfb\x19\x83\x35\xf7\x86\xc3\xe4\xec\x2c\xe3\xf9\x30\x4e\xe2\xf2\x50\x5e\xdf\x5f\xd3\x4b\x6f\x77\x38\x84\x94\x4d\xd5\xd0\xbb\x9d\x8e\x0a\xe6\x45\x18\x24\x1c\x5d\xfc\x03\xb3\x6e\xb5\xd8\x05\x5f\xda\x51\x98\x8f\x2f\xf8\xf2\xa6\x14\x1e\xa3\x8e\x5f\xf0\x65\x56\x33\x0f\xc3\x8a\x40\x37\xc7\x26\xae\x13\x10\x60\x55\x60\x66\x4a\xa5\x8a\xac\x80\x38\x57\xab\x32\x16\x5a\x33\x5a\x01\x4d\x65\x73\x32\xb4\x76\x02\x44\x89\xef\x85\x8c\x79\x17\x7f\xb2\x3e\x50\x6a\x65\x92\x3a\x92\xe5\x6a\x56\x96\x5b\x4f\x1c\x7c\x2e\xfe\x2c\x7c\xce\xfe\x2c\xcd\x95\x97\xfc\x59\x33\xa5\x9b\x3e\x54\x5f\x44\xd0\x09\x24\xf7\xca\xc4\xdf\xd9\x9f\xa8\x59\x9b\x0e\x66\xcd\x16\xbc\x83\xec\x88\x1a\xef\xf6\xd9\x3b\xf6\x03\x9b\x09\x78\xd6\x33\xc3\x2c\xc2\x34\x5f\x59\x24\xea\x1e\x8b\x13\x39\x49\x0c\xf7\x6e\xd0\x62\x17\x51\x8b\xbd\x93\xc9\xe1\x06\xfb\xa4\xe1\xbb\xb6\xf8\x26\xa9\x70\xfc\x6e\xe0\x3e\x9b\xc8\xa2\xf6\x05\x17\x12\xfe\x22\xb2\xec\xc0\x34\xcd\x59\x22\x88\x02\x9c\x12\x64\x7f\x36\xfd\x83\xce\xfe\x3c\x4e\xc4\xe8\x06\x6d\x95\x8e\xd0\x86\x87\xbc\x11\x64\x7f\x0a\x70\x72\x4b\x52\xf1\x8f\xfe\xd4\x5e\x45\x30\xf3\x6d\xb9\x1c\xd6\x0a\xc3\x24\xdb\x6c\x18\x49\x6a\xf5\x02\xab\x23\x88\x4b\x22\x8e\x0f\x9b\xcd\x16\x8e\x50\xa8\x3f\x02\x61\xe3\x06\x85\x03\xff\x57\xe6\x46\x5b\x3d\x74\x0c\xa2\xa5\xf0\x77\xb2\xa3\xe1\x00\x94\xcc\x59\x6b\x00\x5a\x50\x91\xf8\x59\x9b\x08\x2d\x19\xa0\xec\xaf\xc1\x06\x30\x96\x02\x19\x95\xb8\x5d\x8f\x8e\x5a\x48\xd7\x22\x64\x0d\x81\x2d\x23\x98\x69\x5c\xa1\x7a\xc1\x77\x0f\xca\xfd\xa7\xf2\xdd\xaf\x2d\x7c\xd9\x2a\x5d\xe3\x26\xf6\xf5\x8c\xa7\x11\xcf\x5a\x38\xb5\x38\x6f\x10\xd3\x30\x08\xc4\xa6\x83\xa5\x72\xda\x30\x8f\xa7\x49\xe6\x4e\x2d\xb2\x2d\x16\xeb\xbd\x61\xa6\x1b\x1e\x77\x06\x6a\xd3\x62\x4b\xdf\x7e\x01\x00\x96\xf0\x2e\xbd\xb0\x43\x2d\xd9\x3d\x0d\x27\x1a\x1c\xbf\x1b\x1c\x77\x07\xd2\x7d\x45\x9d\x95\x96\xcd\xd2\xfd\xcd\x6d\xb8\xa3\x8f\x05\xac\x56\xf0\x8b\x52\x36\x6b\x3a\x24\x2b\xe1\xa5\xcf\x18\x65\xe7\xa6\xf3\x6b\xad\xc9\x02\xdd\x52\x16\x90\xf3\x3f\x6e\xb1\xf1\xb2\xc5\x96\xf3\x16\x5b\xc6\xc0\x18\x84\x23\xa0\x93\xe3\xce\x40\x31\x46\x39\x57\xcc\xc5\x49\x2e\x96\x96\xfe\x15\x39\x69\x21\x56\x42\x30\x76\xbb\x89\x06\x62\xfa\x9b\xc7\x60\x12\x1c\xc3\x25\xc8\x8f\xce\xb1\x7a\x8c\xa6\x5d\x81\xec\xf8\xb8\x8b\x7f\x0a\xc6\x1b\x2f\x9d\xdb\x0c\x48\x89\xbf\x64\x3f\xb8\xcd\xb1\x4d\xdc\xd2\x90\x62\x6f\x73\x4f\x8f\x9e\x57\x97\x7e\x5e\xfa\xba\x62\x8f\xfc\x95\xe4\x92\xd2\x56\x3b\x1e\x06\x34\x9c\xd9\x59\xc5\x8b\xc0\xdf\x08\x6a\xb9\xb6\xa0\xca\x3a\xf2\x93\xa8\x05\x7f\xc3\xfc\x6f\x2f\x95\x75\xfb\x4b\x89\xa4\xaf\x2b\x90\xc2\x57\xca\x46\x62\xe2\x6e\x07\xc1\x4c\x3a\x69\x16\xd9\xa6\xb9\x9a\xeb\x96\xc8\x2a\xef\xf0\xf2\x27\x13\x5b\x62\x4b\x70\xcb\x6a\xee\x02\x77\x52\xf1\x6f\xaf\x5c\xe0\x41\x14\xef\xc8\x23\xea\xe8\x65\x6a\x16\xbd\x03\xe4\x23\xc2\x8e\x4e\x79\x57\x96\xc3\x55\x8b\xb7\xce\x2e\x10\x41\x40\xda\x86\x06\xfa\x3e\xc6\x3e\x38\x22\xaa\x17\xec\x07\x16\x09\x54\x2f\x9a\xce\xcd\x6f\x76\xe1\x22\x7b\x61\x23\xcb\x58\x76\x81\xe8\x5e\x94\xa0\x0b\x35\xba\xb2\x86\x85\x30\x39\x3e\xee\xc2\x0a\xbb\x40\x74\x2f\xde\x75\x0b\xa7\xc7\x2e\x54\x88\xde\x21\x81\xc5\xdf\xbb\xec\x2e\x7c\xa0\xce\x6b\x62\x8d\xea\x2e\xe4\x9a\xc5\xdf\x28\xb7\x8d\xfa\x91\x75\xc5\xe2\xdf\xee\x0b\x68\x3b\x2c\xeb\xaa\xc5\x5c\x07\xc2\x97\x58\xf0\x5f\xd7\x53\xd7\x30\x1b\xf1\x78\x1c\xc5\xe7\x15\x0f\x51\x77\xd5\xb2\xff\x3c\x3a\x8e\x65\x1e\xab\x33\x03\x04\xe7\x8a\x69\x68\xb6\x53\xfe\x9e\xa7\x19\x0f\xca\x66\xe2\x6b\x7b\x0a\xb4\xd2\xce\x78\xcd\x44\x7c\xb5\xa7\xf8\x73\xcf\xb1\x68\x5a\x90\xf0\x4a\xa2\x68\x93\xdb\x3b\xed\xc6\xbf\x98\x65\xa6\xf6\x2c\x9c\xaf\xc8\x2f\x4b\xd9\x02\xb3\xc4\x65\x8b\x99\x15\xa8\x5e\xd9\x09\x6e\x64\x9d\x37\x21\xab\x7a\x21\xd5\xb3\x3e\xd3\x2e\x66\xd9\xf1\xa9\xd0\x71\xe1\xaf\x70\xb0\x0f\x9c\x87\x88\xe4\xc9\x1c\xf6\x14\xe5\x0a\x91\xe4\x79\x32\xa3\x5f\xf2\x64\x0e\xe9\x20\x06\x76\x95\x4c\x3a\x35\xf9\xae\xdf\xad\x1d\xe9\x9d\xb2\xb7\xc9\x0b\x7d\x79\x8d\x95\xcc\xd9\x0f\x12\x14\x71\x58\x4a\x40\xb9\x06\x34\x8d\x79\x4f\x60\x80\x4e\x26\xef\xd4\x5b\x5a\x5b\x69\x96\x48\x17\x5b\x4a\x54\x9d\xc6\xca\x40\xa7\x82\x4c\xc9\x4a\x7a\x91\xb6\x47\x49\x3c\x0a\x73\x81\x63\x56\xb6\x62\xbf\xc0\x1b\xa4\x9b\x5d\xb1\x5f\x93\xd8\xac\xc1\xd0\xab\x24\x66\xa5\x5f\xa2\xa4\x7a\x39\xcd\xc5\x30\x8f\xf2\x70\x74\x51\x76\xcd\xb4\xdb\x95\x0b\x84\xff\xcf\x22\x9c\x82\x79\x3b\x2b\xad\xbb\x4b\xeb\xfe\xb4\x7c\x13\x9e\x97\x54\xfd\xee\xe1\x77\xb4\x2a\x92\xaa\x0c\xee\x77\xdf\x29\x1c\xce\x79\x5e\x01\xf3\xd1\x03\x59\x2d\xca\x00\xcf\x32\x2e\x78\xa4\xab\xfd\xa4\x92\x4f\xf8\x87\x63\x2a\xbe\x59\xce\xf9\xb8\x0a\xe8\xee\x2e\x28\xe2\x3b\x77\xef\xb2\xdf\x05\x63\xe5\x09\x1b\x25\xb3\x79\x92\x71\x76\x1a\xe5\xb3\x30\xbb\xc8\x40\x3a\xa0\x59\x57\x14\x85\x69\x94\x25\x71\xd6\x16\xd3\x27\x66\xe1\xf0\xe5\xf3\x57\x8f\x5f\x3f\x1d\xbe\x7a\xfc\xfa\xcd\xb3\xc7\xbf\x0d\x7f\xfe\xed\xf1\x2f\x70\xf9\x8e\x50\x4f\x90\x46\x7f\xcb\x93\xa3\x3c\x8d\xe2\xf3\x13\x96\xf2\x4c\x30\x4b\xca\xcf\x78\xca\xe3\x11\x37\xa0\xc2\xf4\x3c\x43\x3a\x35\x8e\x13\x68\xc6\x1e\x2b\xcb\xe2\xa0\x81\x63\x02\x6b\x66\xa1\x52\x1a\x2e\x55\x05\xfc\xe6\xd4\x40\x24\x06\x0d\x3a\x54\x31\xac\xd3\x45\x34\xcd\xb7\xa3\x98\xcd\xf0\xed\x9b\x07\x29\x84\xf0\x2a\x4d\xf2\xc4\x78\x71\x6b\x4f\x15\x97\x76\x13\x3e\xba\x90\x4d\x90\x70\xc9\x87\x98\xcd\xd3\x64\xce\xd3\x3c\x22\x50\x27\x61\xf6\xf2\x43\xfc\x0a\x0b\xc4\xe4\x90\x6e\xda\x76\x21\x76\x71\x8b\xdd\x65\x8f\x59\x36\xe7\xa3\x28\x9c\x46\x7f\xf2\x31\x13\xcb\x2b\x4a\x62\x96\x9c\xb1\x93\xd3\x30\xe3\xcf\xb2\xa7\x82\x27\x4f\xa0\xdb\x10\x19\x3e\x8c\xc7\x1a\x9b\x0f\x93\x68\x34\x61\x73\x9e\x9e\x25\xe9\x2c\x13\xf0\xc6\x9c\xcf\xe9\x9c\x42\xf5\x3c\x0d\x47\x17\x99\xf8\x07\xd6\xaf\x69\xcf\xe3\xf0\x74\x1a\xc5\xe7\x06\x60\x94\x4f\xd8\x28\x4a\x47\x8b\x69\x98\x0a\x78\x86\x7a\x82\x16\xa7\x8a\x5f\xf8\xb8\x7d\x8b\xc1\x00\xfe\x6d\x0e\x6e\x81\x1c\xff\x0e\xd3\x70\xc6\x3e\x21\x45\xaf\x24\x54\xf6\x66\xc2\xd5\x9f\x92\x17\xc3\x94\xb7\xbd\x0d\xf2\x09\x4f\xb1\x3e\xfc\x55\xdd\x2a\x5e\xcc\x4e\x79\x7a\xa5\xb8\x1a\xda\xa9\xbf\xcf\xa6\xe1\x79\xd6\x06\x87\xc7\x22\x25\x67\x49\xca\xd9\x98\xe7\x61\x34\xcd\x2c\x88\x3f\x4b\xa1\x75\x25\x5f\x93\x47\x7f\x4a\x74\xf4\xcd\xa1\x40\x45\x15\x59\x6b\xc7\x0f\x06\x44\x8a\xf8\x59\x80\x32\xe6\x39\x4f\x67\x51\xcc\x45\x9d\xe8\x7d\x38\x85\x87\xa0\xc9\x99\x7c\x8c\xe6\x25\xcf\x31\x18\xc2\x07\xec\x8d\x3b\x9f\x27\x48\xa8\x13\x98\xed\x13\xa0\xdd\x89\x9a\x53\x84\x84\x1b\x41\xc6\x3e\x9d\x26\xc9\x94\x87\xf1\x15\x7b\x2d\xbf\x9c\xe4\xe9\x82\x9f\x88\xfd\x3f\xd7\xf3\x94\xb1\x30\xa5\x88\xb5\x70\x6b\x3f\x39\x0b\xa7\x19\x3f\x11\x10\x77\xcc\x85\x36\x21\xef\x13\xce\xe7\x01\x82\x68\xe1\x14\xb6\xd4\x8c\xb4\x08\x49\x5b\x86\x2e\xda\xf8\xaf\x14\xc0\xe4\xf4\xdd\x33\x21\x33\x59\x5f\xc9\x4e\x09\xd0\x68\x69\xf9\xa4\x50\x43\x74\x65\x2a\x9c\xbe\x43\x59\xa1\x61\x1d\x18\x19\xb3\x27\x25\xb7\x07\xaa\x6c\xa4\xc0\x7b\x1b\x41\x47\xa0\x60\xd1\x5e\xe0\x8f\xbe\x16\x76\x07\x44\x62\xed\xc9\x72\xa1\xe6\xd0\x3e\xaa\x9b\x40\x39\x74\xa3\x69\xf2\xf2\xf4\x9d\xd5\x99\xae\x6f\xd1\x45\xd6\xd2\xf0\x0b\xb5\xa2\xec\x28\x9c\x71\x17\x73\xd2\xa1\x50\x04\x4d\xa5\xad\x2d\xbd\x37\x29\x8a\x51\xcf\xb7\xdb\xa6\x10\x28\x63\xb4\x46\xa9\x79\x00\xc7\xd0\x93\x3a\x99\x5f\xc1\x78\xfb\xe6\x23\xa2\xae\x1b\x5c\xf9\x70\xb9\xad\x6a\xea\x97\x75\xa0\x30\x5c\x5e\xb2\x20\x93\xaa\x03\xba\xd8\x08\x9e\xb2\xee\x80\x03\xdd\xf1\xe5\xa5\xb5\x8b\xea\x61\x49\xc4\x0f\xa8\x7a\x71\x3d\x66\x96\x90\xf6\x88\xf2\xe1\x02\x42\xd2\xd7\x05\x48\xe9\x71\x3b\x50\x32\x6e\xcb\xbb\x51\x37\xa9\x4b\x03\x0c\xfa\x8f\x34\x9c\xcf\xf9\x58\x2d\x08\x41\xe7\xad\x2d\x67\xbb\xc2\x9b\x43\x85\x64\x63\x38\xfc\x80\x8d\x86\xc3\x06\xf5\x50\x10\x2c\x46\xc0\x29\x8e\x2b\x03\x87\x63\xb5\xa1\x91\x57\x11\x16\x76\x97\x97\x16\x78\xdb\x76\x96\x9c\xbe\xfb\x3d\xfe\x60\x8f\x43\x35\x54\x4b\x07\x2f\xb7\x83\x26\x2e\x39\x31\x0e\x62\x8c\x4a\xf2\x89\x05\x80\x0e\xe4\x00\x27\x85\xb6\x17\xbf\x75\x78\xe6\xd5\x3c\xa6\xb9\x4c\xcf\x5c\x40\x31\x6e\x59\xdd\x97\x4c\x7a\x46\xe0\x5d\xd1\xf9\xd6\x0b\xc0\xb9\xa1\xb5\x56\xca\x2a\x1c\x29\x7e\x52\xc5\xbd\x1e\x6f\x83\x6b\x12\xea\xf4\x6d\xa9\xd2\xb3\xbe\xbb\x07\x78\xce\x06\x95\xde\xd3\x12\x10\x1c\x03\xa4\x62\xf4\x9a\xcf\x92\xf7\x3c\x63\xe1\x74\xca\x2e\xf8\x72\x1b\xb5\x55\x1e\xe7\xe2\x28\xc2\xce\xd2\x64\x06\xfb\xd5\x34\xca\x72\x36\x0a\x47\x13\xee\x55\x48\xe2\x70\xc6\xd9\x68\xca\x51\x99\xf9\xb7\x19\x17\x1a\xc3\xcb\x33\xf6\x5b\x94\xe5\x87\xa2\x95\xbd\x95\x4d\xd5\xe7\x43\xd1\x24\xa0\x2e\xcf\xc3\x71\x98\x87\x70\x9c\xc3\x57\x43\xf0\x55\x66\x17\xeb\xf8\x89\x62\x43\xf3\xd0\xa4\xd2\xc9\xaf\xd6\x79\x29\xcc\xb2\x64\xf4\x2c\x1e\xf3\x8f\x2f\xcf\xca\xce\x18\xf7\x3b\xcd\x6b\xe8\xc8\xb0\xf7\x29\x15\x19\x84\x61\x41\x43\xfe\x49\x41\xc1\xb9\xf1\x00\xc9\xe6\xe0\x99\xd0\x27\xd0\xda\xf8\x6d\xbf\x30\xd1\x27\x17\x7c\x89\x0a\x4c\x94\x67\x12\xe4\x5a\xd3\x8c\xb9\x73\xcb\xe7\x59\xab\x53\x19\x9c\x5a\xae\x04\x5b\x81\x5a\x26\xfe\x95\x11\x39\xb0\xdb\x3c\x61\x29\x60\xb5\x9e\xee\x24\x98\x73\xc9\x3e\x84\x99\x6c\x3d\xae\x54\x9b\x34\x77\x3c\x01\xbc\x03\xed\x09\x28\x08\x27\x5d\xaa\x2c\xd6\xd3\x3b\xb8\x74\x7f\xa2\x73\x0f\x7e\x5a\xe8\x4d\x68\x36\x71\xa8\x47\xee\x3e\x7d\x72\x03\x52\x17\x87\x59\xfe\x4c\x02\x25\xae\x6c\x18\x31\x9f\xc2\xea\xf7\x4d\x5d\x05\x14\x1a\xcc\x93\xb9\x8c\x95\x43\x6d\x40\x38\xd3\xb8\x15\x20\x7e\x00\x06\x7d\x5e\xb1\xfb\xed\x6d\xbd\x8e\x88\x94\x42\xc5\xa0\x72\x49\x21\xd1\x8a\x6b\xea\x7e\xa5\x3f\xc8\xcd\xaf\x29\xc1\x20\xbf\xf0\x3c\x73\xb8\x54\xf1\x6f\x92\x22\x5f\x97\x73\xed\x39\xcf\x6f\x88\x65\xcf\x79\xee\xf0\xeb\x5d\xc3\xa9\x86\x3f\xa1\x7e\x19\x2f\xfe\xc2\xf3\x9b\x65\x44\x39\xa3\x9a\x17\xd9\x01\x5b\xc4\x63\x7e\x16\xc5\x7c\xcc\xf6\xd0\x67\x10\x0a\x07\xf0\x38\xab\x72\xce\x7f\xe1\xb9\x67\xc2\x2b\x9d\x36\x3e\xcf\x84\x1f\x4e\xb8\x38\x7f\x45\x67\x2c\xac\x98\x73\xc6\x3f\x46\x19\x9e\xbf\xfc\x53\x3f\x09\xb3\xcd\xa6\x1e\x27\x54\xd9\x28\xea\x0b\xab\x30\x96\x4d\x5d\x5c\xeb\x09\xac\x5f\xc3\x2c\x70\xfd\x96\x2d\x1e\xb0\xb9\x05\x7d\x9c\x7f\x64\xdb\xdd\x15\xf3\xfb\x6b\x98\x79\xe6\xb7\xd2\x91\xe2\xf3\xcc\xef\x91\x67\x41\x23\x99\xf2\x84\x9d\xc0\x34\x57\xac\xe8\xec\xc6\x56\x74\xa6\x56\xb4\x6c\x73\xf7\x4a\x96\xbd\xf1\xd6\xd2\x53\xaf\xec\x05\x74\xf1\x93\xa1\x44\xe0\x78\x38\x2a\x15\x02\x47\x28\x04\x5a\xd8\xc5\x67\xde\x94\xee\xdd\xb3\x76\x00\xb5\xa1\x2c\xb2\x49\x70\x6c\x90\x18\x14\x77\x17\x5b\x74\xb0\x3e\xf1\x17\x25\x3b\xc9\x24\xca\x56\x70\xdd\x91\x57\xaa\x54\xfa\x5d\xd4\xe2\x3a\x3d\xeb\xa5\xe1\xfb\xbe\x6f\x16\xb5\xa0\x15\xea\x2e\x7a\x6f\xae\xa3\xe9\xc2\x11\xc0\x9e\x68\x00\x52\xa5\xe1\x62\xec\x37\x89\x7e\x4d\x65\xd7\x00\xf5\x50\xb3\xf2\x52\xbb\x42\xf9\xaf\xd4\x09\x57\xd0\xc2\xa7\x0e\x2a\x62\x7c\x65\xaa\x20\x8c\x64\x5d\x35\x50\xda\xdc\xa5\xdf\x7d\x03\x87\xdb\x18\x04\x7a\xb9\xd1\x49\x83\x45\xe5\x68\x59\x08\xa0\x62\x36\x4b\x75\xac\xca\x9b\x71\xcf\x74\x6a\x05\x09\xcf\xa6\xd7\xd7\x8d\xae\x35\x7f\x1b\xe8\x45\x80\xaf\xa5\x13\x11\xb9\xa2\x67\xa4\x7d\x2e\x6b\x54\xd0\xd2\xaf\xbb\x54\x5e\x58\x7a\x08\x49\x15\x0f\x2f\x2d\xd7\xd7\x39\xd6\x21\xe9\x97\xd5\x37\x60\x80\x3e\x5d\xc3\x26\xfe\x44\xd6\xa8\x20\xbe\x5f\xb1\xd8\xfc\xb6\xb2\x8e\x88\xc7\xe5\xfa\x3c\x9c\x97\x3a\x57\x3c\x34\x75\xaa\x80\xf5\x3a\xdf\x59\xe7\xf8\x50\x2e\x29\xb1\xc0\xf3\x04\xaf\x72\x38\x9b\x86\xe9\x39\xc7\xe3\x36\x4b\xe6\x79\x34\x8b\xfe\xc4\x88\x7a\xfa\x4c\xfe\xdb\xe3\xd7\xbf\x3c\x1d\x3e\x7e\xfd\xfa\xf1\x7f\x0d\x8f\x9e\xfd\xf7\x53\xd6\x67\xbd\x4e\xc7\xa3\xfc\x20\x83\x6d\xa0\xf7\x5c\x6b\xb5\xde\xa4\xce\x83\x23\xa8\x54\x7a\xa0\xca\x3a\x0a\x8f\x3a\x11\x43\x99\x02\x9a\x10\x25\x8f\x9a\x5f\xe7\x61\x94\x66\x4a\xfc\x52\x08\xd2\xb4\x27\xd8\xe2\xf2\x92\x05\x50\x4f\x1d\xbb\x7f\x28\x4e\xd1\x36\x38\x70\x2b\x83\x28\xd6\xf6\xab\x48\x8c\xd9\x82\xff\xde\x3d\x4b\xf4\x13\x33\x00\xaa\x46\xc6\x30\xef\x1b\xac\xd4\x05\x14\x67\x22\x9e\xfa\xf0\x8e\x90\x6d\xda\xb9\xda\x82\x6f\xe3\x29\x57\xca\xd4\x6c\x78\x56\x6b\x1d\xfb\x61\xf5\x6a\x8d\x32\x75\x2f\x57\xb6\x5c\x1f\xea\x4b\xf6\xe7\x61\x76\x01\x86\x62\xef\xed\xfe\xfd\xef\x75\x45\x64\xbb\xb2\x9b\x78\x75\x6b\x9f\x27\x47\xc9\x22\x1d\x95\x2d\xed\xdd\xdd\x1e\x51\x05\xd5\xc5\xf3\x2c\xcc\x47\x13\x76\xf2\x9a\x9f\x3f\xfd\x38\x3f\x11\x25\xc7\xd9\x32\xce\xc3\x8f\x6c\x34\x09\xd3\x70\x94\xf3\x34\x1b\x04\x93\x3c\x9f\xef\xed\xec\xf0\xd1\x2c\xdc\x86\x90\x98\x31\xac\xf7\x70\x0a\x01\x37\xe1\x73\xef\x61\x6f\xe7\xbb\x76\x67\xe7\x6f\x19\x1f\x6d\xcf\xc3\x5c\x54\xca\x9a\xb8\x10\x04\x61\x52\x8e\x7d\x1c\x4e\xc2\x94\xf5\xd9\xce\xf1\xdb\xb7\xff\xfc\x7b\xfb\xee\xbd\x83\xa0\x79\xfc\x76\xf0\xe9\xea\x72\xb0\x73\xee\x5c\x8a\x8f\x79\x2e\x86\x3d\x49\xc4\xa1\x22\x89\xb3\x3c\x5d\x8c\xf2\x24\xcd\x58\x70\x14\x9e\x85\x69\xd4\x6c\x1b\xe0\xcf\xb2\x5f\x93\x2c\x3f\xcc\x13\x00\xfe\xcf\xb7\xea\x02\xbf\x7d\xef\xe0\xd0\x34\x7d\x3b\xf8\xfb\xce\x35\xcc\x94\x82\x15\x94\x95\x52\x4d\xaf\x31\x54\x52\xf7\x81\x9a\xd7\xfd\x29\xcf\x92\xe9\x7b\x8c\xd6\x3b\xe6\xa3\x64\x36\x8f\xa6\x7c\xcc\x32\x9c\xbf\xe4\x4c\x5f\xe2\xda\x38\xbc\x91\xbe\x10\xf2\x49\x15\x9a\x3a\x95\x83\xc4\x17\xf3\x28\x70\xe7\x07\x14\x05\x49\xbc\x28\x63\x82\x35\xde\x73\x6b\x6a\x5e\xc0\x27\xd6\x67\xc8\x02\x41\xe3\x9f\x0d\x76\x4f\x3e\x95\x55\x63\x42\x0b\x9e\xdd\x5f\xb3\x9d\xf2\xf9\x34\x1c\xf1\x80\x72\x4f\x8b\x35\xde\xbe\xfd\xfb\x56\xa3\x79\x8b\x31\x5d\x61\xc7\x6e\x79\xa9\x97\x6f\xb3\x7d\xf7\x20\x38\xe8\xbf\x7d\xfb\x36\x68\x5e\x02\x1d\xda\xf7\xe4\x87\x41\x73\xe7\xbc\xc5\x1a\x7f\xef\xb6\xef\x1e\x34\x9a\xec\x1e\x6b\xfc\xbd\x71\x8b\xac\x11\xb8\xea\x0f\x33\xce\x20\xcc\xf1\x4c\xc5\x8d\x05\xc7\x89\x61\x3b\x92\xc3\x3a\x01\x7f\x86\x64\x91\xb3\xd3\x70\xcc\xb2\x49\x34\x43\xda\xfb\xf5\xa3\xca\x0d\x67\x4d\x8d\x47\x6e\x96\x82\xe8\xa1\x24\xbb\x66\x9c\x96\x80\xb2\xfa\x42\x1d\x87\x10\x90\x2d\x49\xde\x06\x49\x67\x2e\x59\x00\xb7\x99\x28\xae\xe4\xa7\x55\xe6\x5e\x29\x01\xe0\xfa\x5c\x2d\x19\x05\xed\x80\x32\xc5\x9e\xb5\x78\x89\x00\x97\x10\xda\x39\xcf\xf2\x40\xc9\x36\xd5\x7b\xd5\x05\x11\x02\xf6\x48\xf7\xcd\x6f\x42\x46\x49\xca\xff\x3d\x7b\x82\x9b\x98\x57\x6a\x3f\xe8\xb8\x6e\x51\x72\x95\xe0\x02\xc9\xd8\x2c\xcc\xfe\x67\xc1\xd3\x10\xc2\x18\x87\x85\xe5\x32\x0b\xb3\x8b\xa3\x74\xf4\x1f\xf0\x98\xd9\xf7\xc8\x7e\x11\x8d\x41\x7c\xfe\xb3\x3d\xb8\xf7\xf7\x9d\x36\xff\xc8\x47\x01\x41\x6b\x6b\x8b\x20\x89\x4f\x90\x8b\x9f\xda\xcf\x9e\x0e\x5f\xbd\x7e\xf9\xe6\xa5\x98\xd8\x46\x83\xde\xdd\x09\xf0\x07\x2c\x68\x1c\x2d\x67\xa7\xc9\x34\xc8\xd2\x51\x73\xd8\x6d\x37\xd8\x3d\x51\xd2\x64\x7b\xac\xd1\xd8\xbf\x75\x15\x34\xbd\x86\xca\x13\x81\xef\x89\x90\x28\x70\x94\x96\xe2\x6c\x06\x7c\x53\xb5\x1a\x8c\x2b\xcb\x99\xcf\x8b\x65\xdd\x65\x81\x58\x44\x99\xec\xb9\x52\xff\xd7\x6c\x2d\xbe\x58\x07\x80\xdb\xb7\xc9\x5c\x6c\x6d\xb1\x80\xfc\x8c\x62\x40\xb0\x84\x0d\x15\xcc\x22\x0b\x3e\xd8\xfc\xe2\x20\x4d\x92\x52\x4d\xa0\xe0\x92\x27\x79\x2f\x79\xcf\xd3\x94\x87\xa3\x89\xe0\x39\xc1\x0b\xdb\xef\x32\x90\x54\x66\x17\xb0\x38\x5b\xf4\x71\xdc\x18\x0e\x65\xd5\x61\x36\x09\x53\xb8\x57\x1f\xec\x7b\x86\x6b\x9a\x7a\x06\x5c\xc7\x70\xee\x3d\xc5\xa3\x50\x0c\x73\x79\x36\x10\x32\x57\xfa\x1f\xd5\x71\x0a\x93\xdb\xff\xc0\x71\x0b\x13\x2b\x6f\xd9\xae\x79\x5a\x98\xab\x2d\xb1\xce\xf1\x5e\x57\xf6\x9d\xf0\xcf\x79\x8e\xb1\x38\xd4\x65\xb8\x7b\xd8\x94\x18\x9a\xf7\xce\xf4\xfa\x02\x0b\x4d\xc8\x8e\xc2\x04\x28\xf0\x1e\xf2\x6f\x6e\xd7\xfe\x35\xcc\x26\xa5\xc2\x4e\xf9\xbf\xde\xd4\x19\x75\x6d\x53\xe5\x2c\x9c\xaf\x65\xa8\x54\x87\x0c\x7b\x7e\x66\xf2\x6b\xc1\x5c\x69\xac\x91\x45\xfb\x25\xee\x7f\x8d\x49\x98\x4d\x1a\x98\xa4\x46\x90\x0a\x47\xd9\x98\x85\x73\xf9\x31\x90\xc7\x2f\x73\x74\x93\x55\x90\xf3\x48\x53\x7c\x90\xee\x9b\x60\x0b\x3f\xcf\x2c\x6f\x6e\x47\x16\xa3\x00\xe8\xa5\x53\x7d\x5f\xe2\x2d\x6a\xa2\xcd\xae\xb4\xea\x03\x52\xf5\x17\x5e\x26\xad\xbe\x7b\xf0\x90\xd4\xfb\x35\x2c\xf5\x86\x7e\xf0\x1d\xa9\x77\x54\x01\xef\x11\xdd\x94\x20\x5c\xb2\x50\x8c\x44\x2b\xe5\xbc\xe3\x63\x15\x72\xb2\xa0\x82\x01\xbc\x11\xae\xd8\xb1\x64\xb9\x81\x92\x0e\x92\x13\xf1\xd0\x2d\x36\x27\xe5\x2f\x40\xf8\x49\xcc\x66\x20\x1b\x92\x68\x95\xf2\xf6\xc2\x24\x68\x97\x67\xf1\xbe\xe6\x6b\x23\x00\x3a\x6c\x4f\x7d\xa5\x81\x5e\x81\x09\x47\xc8\xa6\x82\x29\x4d\x52\x77\x79\xe5\xa1\x9e\x20\x1a\xf3\x00\x1a\xc5\x74\x1f\xf2\x36\x83\x44\xa2\x13\x87\x6b\xa8\x04\xe1\x5e\xf1\x2f\x19\xc6\xf4\x4a\x25\x5e\x18\x8f\xb5\x02\x93\x27\xec\x44\x0c\xf0\xa4\x7d\x4b\xfc\x43\xc2\x4a\x8f\x24\x03\x69\x66\xda\x77\x6a\x18\x03\xb2\xac\xa5\x8c\xbf\x0e\xa0\x73\x98\x64\xc9\x3e\x85\xd2\x09\xb0\x8a\x64\x9a\x42\x69\xa6\xdb\xe2\x11\xbf\xb0\x98\x44\x7d\xcf\x1a\xaa\x73\x7b\x50\xbd\x86\x50\x93\x43\xc6\x2b\xbd\x01\xec\xae\x2f\xe3\xc4\x58\xd6\x12\x72\x28\x4c\x28\x43\xea\x19\x29\xbb\x8b\xa1\xa8\x1f\x58\x3f\x03\xc1\x90\x42\xf1\xfb\x74\x55\xf3\x92\x86\x4c\x7f\x81\xca\xeb\x1a\xf5\x6b\xdd\xd1\x54\x13\xc8\x77\x45\x23\x29\x54\x50\x1b\x40\x56\xbc\x91\x20\xc1\x3c\x92\x8c\xa3\xb3\xda\x1a\xc3\x17\xbc\xcd\x31\xab\xc7\xbe\xcc\xd1\x17\x36\x30\x51\xca\x6c\x2d\xf4\x57\xa4\x83\x3d\xf5\x52\xa9\xa0\xd3\xba\xdd\x57\x30\x0e\x58\x97\xed\xb1\x4e\xcd\xcb\x1c\xba\x9c\x0b\xd3\x5e\xe7\x0a\xe2\x06\x17\x97\xd6\x7f\xb3\x3c\x8c\xc7\xdb\x42\x5b\x4f\x52\x76\xa2\x95\xaa\x13\x9c\x5f\xe9\x04\xaf\x54\xe0\x5f\x1f\x1f\xfd\x3a\xfc\xfd\xc5\x93\xa7\x3f\x3f\x7b\xf1\xf4\x09\xeb\xb3\xc6\x70\x38\x4d\xc6\x61\x36\x19\x8a\xea\x43\xdd\x7c\x38\xfc\x8b\xbf\x07\xd1\x4a\xb6\x21\xc3\xb5\x6e\xca\xdc\x65\xf4\x99\x2f\xca\xe4\x86\xb0\xfa\xf6\x52\x99\xcf\x29\xd3\xd0\x2d\xd1\xbe\xd5\x54\x6b\xc0\x61\x73\x08\xba\xe4\xf0\x84\xad\x98\xab\xe5\x60\x39\x03\xf8\x5c\x94\x8d\x8b\x02\x3b\x30\x7d\xb2\x3d\x03\xad\x7c\x4d\x79\xef\xf4\x1e\x6c\x7e\xad\x74\x8d\x05\xf5\xd7\x63\x74\x7a\x95\xe9\xe3\xf5\xf5\x6f\x32\xd7\x60\xf9\x2f\x7b\x91\x29\xf5\xa1\x7a\x8b\x43\x05\x0a\xb5\xb7\xfd\xc0\xb0\xe6\xed\x7e\xdf\x30\xa7\xd8\xfd\xab\xd9\xba\x9c\x7d\xbd\xb7\xa2\x0f\x36\xbf\x67\xf9\x2a\xf7\x03\xeb\x66\x13\x40\x6e\x70\xb1\x79\x1d\xe1\x7a\x93\xf7\x9a\x80\x7f\xc9\x85\xa6\x54\xaf\xd7\xba\xcf\x34\x2a\xc6\x3d\x57\x3b\xc1\xe3\x0e\xf8\x01\x1b\x16\xec\xdb\xf2\x5b\xa8\x30\x32\x46\xa0\xcd\x9b\x07\xee\x44\x91\xa0\x7e\x2b\xef\x02\xcd\x39\xc1\x65\xd1\xcd\x8d\xc5\xe7\x3c\x7f\x1e\xce\x2b\x8c\xc5\xdd\xfb\x3d\xcf\x69\xa0\x52\xd5\xad\xb4\x77\xf8\x34\x5d\x62\xf0\xf8\xca\x34\x58\x65\xd4\xa8\xd4\x62\x0d\x0d\x65\xa0\x54\x51\xad\xe0\x87\x74\x13\xfa\xab\x8d\x4e\x91\x21\x1e\xd6\x31\xdd\xfa\xdd\x68\xc8\x3d\x4d\xb6\x88\x20\x54\x3e\x08\xa0\x45\xc6\x59\x98\xb1\x45\x1c\xfd\xcf\x42\x5b\x29\x2f\xf8\xf2\x4b\x5e\x1c\x29\x84\x56\x18\xc9\xff\x83\x2f\x45\xad\xc0\x59\xeb\x32\xe6\xbe\x8c\x53\xe9\x2e\xbb\x00\x8b\xfb\xda\xd6\xc5\x2e\x2f\x99\xfe\x86\x0f\x6b\xed\x6f\x19\xdc\x3a\xd8\xdf\xe4\x38\x1a\xf8\xe0\x4d\x47\x0a\x15\x3b\x54\x63\x38\x04\xbd\x62\x38\x94\xa5\x7b\x3a\x8e\xa8\xb4\xa4\x94\x5a\xe8\xe5\x80\x3c\xf3\xbc\xb9\xab\xf7\x9a\x0b\x5f\x6b\xe3\xb3\x70\xbe\x81\x32\x7e\xdd\x95\xbe\x81\x42\xae\xd6\x8c\xcf\x79\xcd\xbb\x72\x57\x38\xb1\x11\x78\x9e\x89\xd9\xdc\x96\xbd\xe6\xc4\x50\xed\xd1\x33\x37\xeb\x2b\x8f\x6b\x4e\xd1\x97\x55\x20\x15\xf1\x7d\xce\x70\xfe\xc9\xac\x76\x8a\x23\xf0\x3c\x93\xb9\xb9\xc9\x7a\xcd\xc9\x3c\xa2\xab\x6c\x03\xb5\xec\xba\xcb\xec\x26\x55\x33\x31\x84\x4a\x87\x33\x45\xfb\x15\x3a\x9a\x77\x5a\x75\xe4\xa3\x82\x6f\x55\x2d\x6f\xac\x7b\xa4\x89\x90\xdf\xf0\x2f\x51\xf0\x56\xaa\x64\x04\x77\x0f\xdf\xac\xe3\xe4\xfd\x25\xd5\xfe\xc7\xe3\x71\xa6\xf7\x55\x99\xf6\x17\x1d\x24\x57\x3c\x28\x0c\xc7\x63\xc7\xa1\x91\x93\x77\x1c\xe1\x34\x0a\x33\x36\x5f\xd8\x47\x81\x12\x25\x40\x75\xb4\x82\x7b\xaa\x5d\x15\x65\xef\x8f\xc7\x63\xba\xd9\xdb\xde\xb0\x82\x01\xa0\xb0\xe5\x50\xab\x59\xcf\x01\xcf\xf4\xe1\x99\xe1\x75\x4d\xc4\x5e\x3d\x2b\x8a\xeb\xcf\x40\xd1\x5b\x99\x17\x5f\xd2\x94\x2d\xd7\x30\x1d\x4d\x04\x5b\x39\x74\x57\x51\x43\x2a\x75\xaf\xb3\x64\x11\xaf\xf0\xd9\xe7\xe6\x31\x14\x99\x8d\x52\x17\x65\xb5\x20\xab\xa8\xee\x97\xc7\xeb\x3a\x89\x97\x87\x94\x19\xb6\xb3\x64\xc6\xad\x68\x32\xca\x41\x2a\x5b\xcc\x21\x90\x94\x28\x8a\x72\x9e\x86\x39\x07\x22\x67\x93\x24\xcd\x27\x61\x3c\xae\xf4\x99\x52\x37\x72\x00\x14\xef\xe3\x70\x7e\xf3\x44\x41\x03\x4f\x87\x92\x28\x29\xf3\x94\x8f\xa3\x91\xa8\x64\xf9\x97\x44\xf1\xfb\xe4\x82\x8f\xd9\x9c\x2b\x9c\x20\xf9\x5c\xfd\xbd\x76\xc9\x38\x3a\x87\xb1\x79\x98\x65\x5c\xb9\x03\xa8\xce\x60\xef\x5e\xe9\x8d\x05\x03\x39\x4a\x66\x3c\x80\xbf\x5a\x06\x40\xad\xfb\x43\xa4\x83\x7d\x7b\x08\xdf\xe8\xdd\xe1\x8a\xbb\xc2\xe8\x8c\x05\xba\x57\x44\x43\xde\x15\xea\x27\xb5\xf0\xb1\x18\x7e\xc3\x84\xd8\xb8\xb2\x6d\xa1\xd2\x2b\xcc\xc7\x8d\x7a\xc0\x1e\x5e\xbc\x81\x08\x5f\x70\x8e\x28\x0b\x21\xab\xbc\x16\x7e\x8f\xe2\xfc\x51\x55\x90\xab\xef\x1e\x3e\xd2\x51\xbb\x4a\xbd\x16\x1e\x5c\x23\x5e\xd8\x2c\x9c\xbf\x49\xaa\x7b\x56\x0e\x13\x19\xcf\x57\x54\xfd\xae\xe0\x72\x76\x43\x91\xb8\x10\x01\x55\xfa\xfb\x8b\x97\xaf\x9f\x3c\x7d\xfd\xf4\x89\x2a\xef\x5d\x23\x52\x97\x58\x49\x4e\x88\xad\x9f\x70\x71\xa9\x30\x5c\xe3\x30\xe7\x4e\x8d\x27\x61\xce\x55\x31\x4f\xd3\x24\x75\xca\x9f\x8a\x6f\xaa\x82\x20\xad\x5d\xfc\x3c\x9c\xab\x42\x14\xcb\x4e\xf9\x0b\xf8\xa8\xaa\xa4\xfc\x9c\x7f\x74\x41\xa0\xf3\xa9\xaa\x92\x71\x37\x4c\xd8\x11\xcf\x75\x21\xd0\xc0\x2d\x87\x8f\xba\x0a\x70\xa7\x5b\x05\x3e\x42\xa4\x31\x1d\x19\x01\xa3\xde\xf8\x82\x96\x61\x09\xa1\x59\xf8\x8f\x88\x7f\x28\xd2\x0d\x3e\xdb\xe1\xcb\x80\x3f\xe2\xf7\x3c\xcd\x25\x22\x70\xa5\x3f\x4f\xa3\x59\x94\x47\x70\x1d\x1d\x8f\xe5\x28\x48\x8c\x05\xa8\xa9\x6c\xfa\x72\x79\x1d\xc8\x3f\x48\xfe\x3d\x72\xa5\x41\xc7\x0a\xee\x49\xf0\x2e\x96\x02\x3a\xa0\xbf\x30\x30\xca\xcb\x33\xfb\x56\x64\xad\x08\x66\x4f\x38\x9f\xe3\xbe\x23\xb9\x9c\xc4\x1c\x4b\xce\x6e\x41\x7a\x32\xce\x32\xb1\xe7\x9f\x28\x66\x7d\x13\x9e\x6b\xed\xff\xee\xdd\x17\x49\xce\xf7\xee\xde\x65\x6f\x26\x62\x7b\x56\xc2\x39\x89\xa7\x4b\xb5\x77\x65\x04\x36\x2a\x8e\x18\xce\x2c\x0f\xcf\x55\x27\x27\x92\xa3\x4f\x5a\xec\x44\xb0\xae\xf8\x17\x58\x54\xfc\x81\xcc\x26\xfe\x92\x2e\xf7\x2d\x26\x74\x52\xb9\x72\xbe\x82\x78\x67\xea\x2c\x93\x87\xe7\xd0\xc6\xa2\x94\x3a\xd5\x28\xaa\x7e\x8b\x99\x86\x24\xc6\x37\x40\x5f\x57\xc4\xb4\xf2\xb0\x50\x79\xfd\x98\x50\xb0\xd5\xeb\x14\x8a\x26\x3a\x10\x24\x33\x24\x62\x67\x4f\xbd\xd0\x3e\x63\x81\xec\xae\x7d\xba\xcc\xf9\x6f\xa8\xa1\xdc\xee\xcb\xe8\x47\xe6\x5b\x93\x5d\x5e\x92\xd0\x49\xb4\xd1\x4b\xcc\x00\x63\x35\xc2\x6f\x4d\x1a\x41\xbc\x18\xfc\xcb\x44\xf4\x56\x0e\x95\xca\xf1\xeb\x14\xe4\xe5\xbe\x09\x62\x06\x51\x30\x25\x78\x59\x66\x06\x66\x0b\xdf\x8d\xc7\x76\xdb\x04\x6c\x8a\xf9\x07\xa2\x76\xe8\xf0\x70\xcc\xfd\x8e\x71\xce\xea\x8e\xd6\xd2\xc3\xcc\x30\xe4\x66\xbb\x67\xcd\x18\xb7\xbf\xe8\x1d\x51\x8d\x72\x67\x87\x1d\x26\x3c\x1d\x61\x73\x1e\xc6\xe8\xf1\xd5\x3d\x01\x39\xd5\x41\x5e\x1e\x83\x6f\x5d\x9e\xb0\x59\x34\x9d\x46\x19\x1f\x25\xa8\xbb\x2b\x08\xcf\xe2\xf7\xe1\x34\x52\xf5\x04\xd3\x8e\x00\x26\xec\x3e\x27\x2f\xc2\x17\x27\x6d\x37\xa4\x55\x70\x4f\x71\xe9\x3d\x12\xff\x4e\x62\xa9\x76\xfd\x3d\xbb\x95\x9c\x0c\x38\xc5\xf5\xd5\x34\xc0\xaf\xad\x2d\x55\x38\xe3\x59\x16\x9e\x93\x72\xf9\x81\x82\xd7\x7b\x3e\x21\x8c\xde\xc7\x8b\x84\x81\xea\x38\x7e\xb9\x4f\xca\x00\x98\x3c\xcc\xd5\x97\x96\xbb\xa3\xca\x15\xdc\x32\xd0\xc2\x0c\xd7\x5b\x5b\x67\xcc\x96\x09\xb3\x6b\x3f\xb3\x42\xbc\x89\xf3\x5b\x9e\x60\xf7\xa6\x13\x8f\x54\x2d\x52\x50\x10\x07\x79\x8e\xdd\xc3\xf7\x00\x86\x0e\xa8\x4f\xed\x91\x30\x69\x4a\x7b\xe8\x13\x35\x96\xb6\x40\xf5\x88\xb6\x88\xb2\x57\x61\x9a\x47\xa1\xd0\xc8\xab\xe3\xca\xe9\x64\xa9\xb2\x8f\xcb\x4b\x16\x98\xfe\x8c\x2e\xdc\xd4\x71\xd3\x64\x88\x37\x31\xd5\x60\x6a\xd2\xcb\x11\x7e\x6d\x6d\xb1\xdb\xba\xf7\xba\xcb\x69\x67\x87\x3d\xce\xb2\xc5\x8c\xb3\xd1\x72\x34\x8d\x46\x6a\xa3\x97\xc2\x37\x9c\xb6\xc9\xd8\x40\x4e\xc2\x2b\x3e\x0c\x15\x70\xce\x73\xb5\xac\x69\xd2\x7c\x59\xcd\x83\x82\x06\xd0\x57\x11\xe1\x6c\x6c\x14\xc1\x2e\xfb\x25\xaa\xb8\x26\xc5\xce\x0e\x7b\xcd\x47\x8b\x34\x8b\xde\xf3\xe9\x52\xed\xcc\x7a\xef\x08\xb2\x45\x36\xe2\xf3\x3c\x3a\x9d\x4a\x7b\xd1\x74\x2a\x77\xae\xa9\x60\x55\x78\xad\xc7\x98\x8a\x45\x07\x56\x1e\x6b\xe7\xd0\x03\xb2\xae\xe8\x68\x20\x43\x39\x55\x46\xae\xe9\x0f\x18\x3b\x73\x8d\x48\x84\x1a\x0f\x72\xdb\xe7\xd0\xd5\xb9\xd5\x23\x1c\xa8\x14\x6c\x2a\xba\x2d\x4d\xd4\x37\x0f\xb4\x9c\x46\x2a\x6c\x82\x19\xd3\x53\x6a\xd1\xa4\xfe\xd1\xd7\x6c\xcc\x9e\xb3\xef\xe6\x9e\x11\xb5\x1e\x88\xac\x8e\xaa\x66\x1d\x8e\x05\xcc\xb6\xf9\xe2\x73\xab\xb5\x4a\xdd\x51\xd5\xb9\x4c\xb7\x6c\x7a\xc8\x36\x19\x3b\x99\x85\xf3\x13\x34\xf0\x64\xae\xf7\x75\x1d\x65\x79\x16\xce\x41\xc1\x13\xff\x9a\x83\x8f\xa3\x7b\x49\xc3\x12\xb5\x91\x7a\xba\xb2\xcd\xeb\x52\x0e\x05\xb3\x70\x5e\x65\xa1\xd1\xab\x44\xd7\x06\xb9\x84\xe2\x4b\xfc\x3a\x4b\xd2\xa7\xe1\x68\x62\xa8\x22\xed\xaa\xfa\x06\x46\xc1\x38\x96\x76\x9b\x01\xeb\x33\xfa\x20\x1b\xdc\xcf\x9a\xf5\x2f\xb9\x8d\xc0\x76\x26\xe9\xbb\xb5\x2f\xb8\xf5\x24\x65\x3c\x87\x49\x0a\x63\x15\x14\xe0\xcc\x38\x2f\xd4\x9a\x27\xa1\xef\x89\x79\x12\xff\xae\x33\x4f\xa6\x07\xdb\x6a\xaa\xa6\x47\xe8\x8c\xf5\xa7\x27\xe3\x39\x99\x1e\xf1\xcb\x3f\x3d\xe5\x33\x63\xc2\x03\xd5\x9d\x12\x83\xac\x67\x4a\x6e\xe4\x2e\xfa\xf1\x74\xfa\x1f\xbc\xd4\x28\xf5\xdd\x77\xbd\xcf\x1b\xc8\xfd\x2f\xea\x3a\xb8\xa6\xc5\xc1\x8a\x6d\x4e\xec\xdc\x02\xd4\x5c\x2a\x3f\x6e\xd8\xf4\xaf\xe0\xb4\xff\xed\xa4\xfe\xb5\x9c\xd4\x37\x8a\x97\x6b\x44\x5c\x6d\x4d\x9b\xc4\x31\x17\xcc\x2f\xdf\x11\x4a\x59\x51\x88\x5b\x7e\xfa\xee\x37\x75\xd7\xa0\x1a\x38\xa9\x73\x92\x7c\xe2\x83\x63\xc7\x4c\xcf\x27\x06\x8c\xac\x4f\x6f\x28\xa4\x2e\x6f\x1d\xac\xe5\x0f\xaf\x22\x5f\xf6\xf8\x5c\x09\x7a\x0d\x8b\x3c\x95\x82\xb2\xed\x6d\x2b\x25\x37\x5f\x92\x71\x59\x0f\xa4\x30\x16\xb6\xa1\xea\x01\x54\x8e\x62\xb9\xb8\xfc\x7e\xb1\x72\xea\xc4\x16\xbe\x32\x56\xb9\xf8\xff\x5a\xe7\x8d\x1a\x67\x0d\x72\xce\x10\xf4\x22\x75\xac\xb0\xe9\x15\xe7\x8e\xab\xc2\x2b\x12\x79\xb5\x53\x75\x22\x20\x65\x3a\xec\x38\xa2\xa4\xd0\xbe\x88\xe6\x32\x32\x87\xa6\xa4\xf7\xf1\x9a\x9e\x2f\x85\x6a\xc5\xcc\xc8\xed\xe2\x1f\x32\x6d\x34\x79\x24\x6b\x45\x12\xd7\xe5\x02\x35\xe9\xea\xaf\x67\xd6\xac\x29\x3b\x10\xb8\x4a\x3f\x41\x11\xd6\x40\x0f\xc8\x52\x0c\x54\x0f\x2d\x8d\x0b\xcc\x3b\x8d\xc0\x0e\xd4\xb2\x42\xb6\x33\xb6\x67\xc1\xd0\x2d\x0d\x34\x84\x61\x8b\x02\x37\x76\xf7\x8d\x1d\xf8\x90\xc9\xcd\xa0\xa9\x7f\x2d\x31\x63\x1d\xb0\xc0\x10\x1c\xb9\x06\x7f\x5c\x5e\xda\x21\xc9\x0b\xa3\xa9\x08\x45\xde\x24\x1d\xec\x69\xc2\xeb\x8f\xd6\xfa\x91\x3c\x69\x9d\xd9\x4f\x53\x1e\x5e\x58\x49\xfa\x14\xb3\x41\x98\x72\xc3\x79\xc0\x4a\x7d\xd6\x20\xcf\x3d\x1b\x56\xc8\x7b\x09\x5f\x08\x1a\xd5\xcc\x09\x72\x2f\x21\x49\x6b\x03\x01\x64\x71\x9c\xaa\x05\x46\x08\x52\x49\xf2\xdd\xce\x0e\x7b\x91\xc4\xea\xd2\x4c\x6d\x32\xda\x1d\x43\x6a\x10\xe3\xe8\x0c\x94\x23\x27\xf0\x8d\x98\xdd\x38\xc9\xa9\x15\x42\xca\x4c\xe8\x15\x25\x26\xfc\xb9\xb5\xa5\x71\x0a\xac\x31\x83\xf0\xc2\x3e\xb7\xb6\x58\xb1\x08\x96\x35\x6d\x7e\x3b\x90\xee\x9d\x9a\x02\x7d\xd6\x50\x7b\x57\x43\x5a\xda\xa0\x80\x04\xaa\x52\x9f\x08\x1c\xa6\xdc\x44\x35\x8d\x0a\x70\x64\x01\x85\x83\x9f\x56\xb0\xc1\x15\x8d\x4f\xef\xb7\x17\x14\x8a\xb4\xf8\xaa\xa1\xa3\xd3\x0d\xda\xa3\xa5\x6f\xee\x98\x28\xd4\xab\x5f\x56\x6b\xea\xbb\x26\x2d\xd4\x91\xbc\xba\x2b\xab\xaa\x9e\x6b\x5f\x94\xc3\xeb\x75\xbc\x0f\xa6\xc9\x19\x4e\xe8\xd3\x3c\x5e\xcc\x78\x0a\x3e\xcb\x3a\xc6\x41\x1c\xce\xd4\x3d\xa1\x44\x63\xcd\xf0\x0c\x5e\xad\x96\x04\x67\xa8\x3a\xf2\x69\xec\xca\xd1\x29\x86\x5f\x70\xf4\x1a\xea\x45\x63\xd3\x9e\x86\x68\xc8\x5a\x84\xd2\x25\x5e\x35\x06\xb6\x87\x31\x36\x77\x72\xc4\x90\xf6\x8b\xd2\x10\x0c\xbb\xbb\x0f\xeb\xe6\x00\xab\x17\xd7\xc8\x8c\x47\xea\xc2\xe6\xc3\xb3\xf8\x44\xe6\x82\x5a\x64\x1c\x5c\xa6\x4e\x04\x91\x7e\x86\x68\x2b\x50\x57\x92\x1f\xbf\xa0\x6b\xb1\x74\x64\xad\xe0\x21\x70\x00\xfa\x3c\x6c\x54\x38\x4b\x28\x7c\x0b\x47\x09\x85\x29\x2c\x17\x07\x0b\x0f\x1c\x32\xd0\x52\x50\x25\x63\xba\x69\xe6\xae\x60\x5f\x79\x42\x30\xb8\x7a\x1e\x58\xa8\x7a\x54\x56\xaa\x70\xea\x76\x66\x24\x08\xdb\x04\xad\xf6\x0c\x5b\xca\x5d\xd3\xea\x45\xe7\xba\x29\x0f\xd2\xf4\x4b\xd5\xaa\xd9\xfc\x25\x3e\xa0\xf7\x73\x34\xcd\x2b\x72\xdd\xa9\xa0\x12\x59\xbe\x38\xad\x76\xaf\x79\xf0\xd9\x1e\x41\xae\xb6\xc2\x2a\x36\x78\x96\x3d\x35\x6b\xc8\x36\x60\xf8\xaa\x00\x7c\x03\xbe\x80\x26\x8c\x22\x9f\x24\x19\x97\xde\x0b\xca\x2f\x02\x5d\x52\x33\x79\xbc\x39\x41\xbf\xd7\x13\x15\xfb\x41\xa3\x85\x0f\xb3\x7e\xa1\xdb\x90\x1c\xe2\x39\xcf\xc9\x79\x48\x16\x57\xef\x32\x70\x6a\xb6\x77\x9a\x7f\xe5\xb6\x62\x2d\x33\x69\x42\x33\xc3\xbc\x5d\x18\xfa\x01\x61\xa1\x3d\x2d\x09\xac\x9d\xc6\xdc\x51\x29\x1f\x3d\xe7\x2c\x86\xd9\x5e\xae\x6e\x91\x8b\x6b\x19\x80\xad\xb8\x2c\x09\x73\x07\x2e\x32\xe6\xe2\xc5\x24\xea\x84\x12\xa7\x3f\x1f\xcf\xd8\xc9\x99\x64\x33\x65\xca\xbc\xf2\x99\xfc\x0d\x61\x3c\xab\x78\x5d\x37\x5e\x70\xb9\xd1\x8c\x8a\xf3\x12\xc2\xbd\x38\x9f\xcd\xf3\xa5\x74\x67\x54\x4c\x90\x89\x2d\x6b\x64\xbb\xed\x0e\xb1\x24\x8a\x47\x9c\xdd\x6f\x77\x77\xdb\x1d\xf8\x30\x0a\x73\x7e\x9e\xa4\x4b\xf6\x7b\x1e\x4d\x57\xb2\x81\xa7\x43\xf6\x6f\xfc\x63\x28\x76\x4a\xd9\xb9\x96\x30\xa0\x58\xb5\xf3\x68\xc6\xb3\xa0\xd7\x62\xc3\xb6\x66\x04\x41\x37\xa8\x2b\xd4\xeb\x64\xca\xdb\xd3\xe4\x1c\x5d\x2a\x21\xb0\xe9\x5d\x71\x0a\xe8\xff\xc8\x8e\x8f\x07\x2d\x76\x3c\x18\x94\x56\x86\xb4\xe0\x7d\xe9\x2d\x99\xc9\xa8\x2c\xaa\x35\x28\xc0\x6e\xa0\x59\x89\x40\x60\xa9\x38\xc7\x25\x81\xa3\x74\x75\xcf\xfc\x6d\x1e\xb2\x41\x08\xfa\x37\x82\x38\xa5\x92\xf5\x3b\xa2\xbb\xc8\x74\x9d\xa5\xba\xea\xf7\x9f\x2d\xd7\xa9\xca\x4a\xe3\xed\xb7\xdb\xb9\x7e\x4e\xd4\xbf\x9e\xd1\xbb\x4c\x3c\x97\x2b\x70\xb2\x02\xd4\xde\x9e\x46\x17\xbc\xf2\x49\x4d\xa5\x33\x7d\x51\x71\xd3\xa6\xd6\x28\x9e\xf0\x34\xca\xf9\x98\x1d\xcd\xf9\x28\x3a\x5b\x4a\xce\x8e\xe2\x73\x52\x66\xa3\x76\x6d\x65\xcb\xe7\x9a\xfd\x5b\x74\xc1\x41\xbf\x92\xd7\x73\xba\x53\x6a\x7a\xb5\xd3\x45\xe2\x4d\x91\xc9\x88\xf8\x38\x3d\x17\xfb\x07\x56\x83\x8c\x87\x9a\xe9\x0b\x75\x05\xef\x5a\x95\x6f\x63\x7b\x9a\x28\xd1\x6d\xf3\x06\xdf\x62\xfa\xda\xc8\x04\x8a\xd8\x9c\x24\x25\xb4\x41\x64\x17\xd1\x1c\xd6\x02\xcf\xd4\x30\x30\xf0\xa7\x80\x02\x7f\x00\x10\x9d\xd9\xb0\x70\x89\x46\x01\x1c\x98\xe5\x8f\xdd\x28\x73\xb1\xf4\x85\x6d\xb2\x3d\x92\x58\x5c\x3b\xb2\x23\x2c\x6a\x13\x86\x14\xe3\xca\x4a\xab\x54\x25\xea\xb3\x1e\x18\x06\xb8\xbc\xf4\xda\x63\xc9\x95\xaa\x63\xd9\xa0\x18\x6f\x6d\xb1\x80\x18\x2b\x84\x90\xc5\x30\xc3\xec\x7b\x88\x68\x49\xd6\xc0\x49\xa8\x66\x4e\x62\x7a\x22\x30\xc3\x4c\xde\x6c\x96\x8c\x79\x9b\x02\x52\x96\x27\xac\xda\xb0\x7d\xc3\xd0\x1e\x34\xe6\xed\x77\x19\xeb\xb4\xbb\x1d\xb7\xab\x38\x89\xb7\xd1\x3c\x6a\xd6\x38\x13\x6a\x3f\x30\x41\x66\x75\x14\x98\x69\x0e\x54\xa7\x09\xf8\xcd\xc1\x8b\x5a\xf5\x69\x1e\xa6\x3c\xce\x1b\xcd\x66\x11\x93\x57\x93\x30\xce\x93\xd9\xbf\x1f\xb1\x5e\x5d\x44\x84\x8c\x1a\xcb\x0d\xca\xc5\x06\x58\x92\x62\x83\x58\x5b\xd8\x18\xaf\xb9\xc2\x67\xf4\xf9\xf3\x22\x7a\x74\x11\xcd\x99\x8b\x8e\xd5\xbd\x94\xeb\xf8\x50\x4d\xbe\x74\x20\x66\x45\xd7\xa0\x84\x91\xce\xd5\x73\xf2\x82\x3b\x47\x95\x75\xc8\x12\x10\x9e\x9d\xb4\xce\x73\x06\x5b\x13\xaa\x0a\x3b\x0c\xea\xc6\x49\xe5\x93\x1a\xf2\x9e\x46\xc0\x4b\x52\x36\x0b\x3f\x4a\x69\x27\x57\xda\xea\x08\xc5\xea\x66\x30\x06\x7c\xf0\x17\x48\x7b\xd8\xd1\xf3\x44\x3e\x9c\x61\x27\xaa\xd7\xb2\xb3\xb2\xc6\x6a\xed\x67\x37\x55\x22\x1b\x27\xc4\x77\x18\x46\x99\x13\xb7\x74\xc7\x6b\x38\x00\xc4\x4d\xff\x4b\x99\xd8\xb9\xf1\xd7\xf7\xfd\xaa\x0f\xbc\x56\x6a\xee\xd7\xe7\x1a\x8d\xaa\x87\x63\x36\x77\x02\x92\x87\xec\xf2\xe4\xf1\x3a\x74\xa7\x0a\xf5\x2c\x18\xb8\xa4\xee\xfd\xfb\xcd\x1b\x4f\xca\x5e\x3f\xca\xb6\x6e\x74\x0d\x95\x62\x83\x80\xda\x31\x91\xf2\x27\x26\xd7\x6b\x31\x84\xb6\xbb\x8b\x53\xc5\x9b\x12\x57\x15\x6f\x6d\x91\xd9\x51\x1f\x4d\x92\xe6\xaa\xc8\xd6\xba\x2b\x0f\xcf\xac\xeb\x62\xe5\x3b\x6f\x91\xeb\xe9\x1b\x3c\x65\x15\x09\x6e\xba\x71\xcf\x56\x85\xe3\xd4\xcf\xa2\xaa\x75\x66\x82\xc6\x2d\x3c\xfd\x0c\x8a\xc7\x1f\x68\x60\x1f\x7f\x2a\x7c\xf1\x74\x8b\x22\x45\x1f\x6d\x1e\xab\x79\x9d\x55\xa8\x2f\xc6\xfd\xc7\x90\xee\xbf\x76\xb9\x62\xe7\x3a\x55\xb9\xfb\x1c\x49\x55\xf8\xfc\xcf\xbb\x20\x65\x80\x5d\xae\xb6\x9a\x9b\x7a\x01\x66\x72\xa4\x93\x2a\x48\xc9\x2f\xf8\x48\xec\x03\x0f\x2f\x9e\x17\x46\xf2\x07\x7e\xfd\x4c\xcf\xc4\x24\x89\xa7\x49\x98\xef\xf6\x5c\x2a\xe3\x57\x6b\xba\xa1\xe6\xc3\xfb\xbe\x9a\x0f\xef\x5b\x35\xa3\x38\x7f\xe4\x54\x7b\xa6\xfc\x45\x49\x9d\xee\xc3\x62\xa5\xee\x43\xb7\x56\x01\xb7\x67\xb1\x8b\xd9\xc2\xd3\xa1\xf1\x50\xb5\x6a\x1d\x4e\xc3\xd9\x9c\x8f\x7d\x95\x65\x51\xa1\x4d\x01\xcd\xdf\xa3\x02\x9e\x0b\x1f\xa2\xbf\x47\x04\x53\xe7\x64\x1f\x8d\x79\x9c\x8b\xa3\xad\xfd\xe2\x4a\xfa\x82\x08\xcd\x8b\x6a\xda\x6a\xd9\xe6\xfa\x34\xf7\x26\x3c\x17\x12\xed\xd3\xd5\xfe\x2d\xfb\xe3\xb1\x99\xd0\x81\x0c\xd6\xe3\x16\xc2\x1c\x0e\x58\xdf\x6d\x29\xa9\xe8\x69\xa6\xa8\xe0\x6f\x54\xd6\xd9\xc2\x00\x74\x5b\x39\x73\x51\xd2\xb8\xac\xcf\x85\xd5\x29\x38\xad\x38\x35\xa4\x7c\xf3\xc0\x55\x52\xcd\x03\xd6\x5e\x5e\x9e\xb6\x52\xe0\x79\x9a\x92\xc5\xe6\x69\x27\xc5\xa0\xa7\x9d\x92\x80\xbe\xa9\x42\xd9\xe7\x69\x84\x22\xcf\xd3\x44\x8b\x3b\x4f\x23\x2d\xe7\x3c\xed\xb4\x80\xf3\xb4\x43\xc9\xe6\x69\xa4\xa5\x9a\xa7\x91\x11\x67\x03\x73\x77\x5f\x57\x05\x34\x26\x0b\x73\xf0\x51\x87\x66\x3b\xff\xd8\x17\x4d\xb9\x42\x16\x64\xa5\x7f\x1f\x2a\x6f\x05\xbb\xcb\x6a\x45\xd1\x52\x0d\x2c\x33\x0a\xa8\x91\xb7\x6f\xbb\xdc\xe8\xea\x95\x25\x76\x5f\x17\x21\x8f\xf2\xb3\x99\xe7\xf1\xce\x5d\xf6\xc7\xd3\x9f\x5e\x3d\x3e\xfc\x0f\xf6\x8f\xc7\xaf\xd9\xb3\x17\xff\xfe\xf4\xf0\xcd\xb3\x97\x2f\xd8\xdd\x1d\x17\x5a\x93\x7d\x82\xf4\x46\x29\xe7\xbf\x4c\x93\xd3\xb0\xec\xd5\x7e\xef\x91\xf6\x53\x7e\x82\x59\x2d\x44\x13\x71\xac\x8b\xd0\x26\x23\x91\x3a\x31\x19\x93\x52\xce\x9f\xea\x31\x4b\xe7\x13\x4d\x84\x3e\x6b\xe0\x02\x00\xd7\x13\xf5\x59\x50\x55\xfe\xdd\x8e\x93\x31\x57\x16\x0c\xf9\xad\x12\x01\x1c\x8f\xdd\xff\x73\xf8\x26\x38\x9e\x20\xb3\xb5\xa5\xb0\x99\xc9\x62\x1b\x19\xf9\x55\xe0\x22\xa7\x8e\xa2\x82\x9f\x6c\x4c\x20\xe4\x44\x32\x5f\x4c\xc3\x94\x1d\x26\xb3\x59\x12\xff\xfb\x11\xe3\x1f\x73\x1e\x83\xd7\xf2\x89\xcd\x01\x06\x45\xfc\x6e\x88\x44\x50\xde\xda\x22\xbf\x0c\xef\xf4\xad\xa1\x54\xd2\x63\x9e\x26\x23\x9e\x65\x27\x18\xbd\x50\xae\x57\x8b\x3a\xaf\xb0\x06\xeb\x3b\x88\xc8\xbe\x91\x1f\xda\x12\x8e\xb3\x5d\x86\x23\x68\x7a\x16\x66\x39\x4f\xb5\x34\x98\xf0\xe9\x9c\xa7\xe4\xa2\x32\x19\x73\x71\x22\xf1\x24\xd3\xc9\xd3\xa5\xe3\x46\x4a\x30\x92\x18\xc8\x9f\xed\xd3\x28\x86\x7c\x3d\xfe\xcf\x41\x63\x91\x47\x53\xe9\x4d\xc6\x46\x90\x51\x2d\x10\x8c\x7d\xa5\x32\xe5\x14\x56\xa0\xc2\x6b\xbf\x72\xad\x5c\xa1\xfd\xb2\x6a\xb9\x05\xdd\xef\xee\x37\xd5\x52\x6a\x36\x0b\xeb\x78\x73\xdf\xa4\x28\x7b\xa5\x9f\xf7\x97\x5c\xe4\x3c\x52\xc7\x18\xbc\x8f\xac\xf2\x61\x7a\x74\xff\x2f\x7e\x45\x52\xbd\x57\x5d\x80\xe3\x0c\x7a\xc9\x8c\x13\x9e\xc5\x8d\x5c\xbd\x0b\x9d\x87\xa9\x7a\x5a\x9c\xb1\x30\x63\x63\x1e\x67\xfe\xa8\x44\x9f\xdf\x59\xca\xb3\x41\x15\xdc\xa3\x64\x22\x30\x3d\xf9\xda\xad\xc3\x5e\x35\x66\xca\xe9\x5d\x75\xc1\x91\x18\x6f\xb8\x5d\x63\xbe\x7d\xc9\x4d\xad\xfa\x5e\xbf\x6a\xe3\xdb\x02\xfb\x9f\x00\x72\xdb\x75\xe9\xbc\x39\xbb\xae\xa2\x8a\x67\x77\xac\xe3\xd8\x65\x47\x21\xbb\x41\x46\x2f\x0d\x7a\x35\x8d\x2e\xf8\x74\xc9\x42\x66\xe2\x71\x48\x5f\xd5\x2f\xaa\x16\x99\xc4\x88\xd5\x31\x45\x0d\x67\x39\xd1\xe9\xa4\x07\x2d\x22\xa3\xc2\xfe\xfa\xfc\x6d\xe7\x92\x4e\xca\x43\xd5\xef\x56\x2a\xbe\x1a\x1a\x42\x32\x3b\x42\x66\x30\xf8\x4a\x6e\x30\xb1\x43\xe7\x58\xe4\x8f\x1d\xfa\x8a\xcc\x87\xcb\x19\x9b\x3b\x2f\x25\xef\x79\x8a\x77\x85\xde\x3b\xe6\xfb\x32\xda\xcf\x67\xf7\xee\x91\x52\x5c\xa2\x13\x48\x5e\x44\xb7\xc8\x97\xda\xc3\xbf\xb8\xb3\xe9\xc6\x1e\xea\xd4\x71\x0a\xa9\xa6\x8e\x32\x56\x94\xee\x2f\x0f\xd7\x48\x86\xfc\x2a\x4d\x66\x51\x56\xbe\xad\x29\xff\x84\x8a\xa4\x43\x8f\x94\x1f\x81\xb4\xcc\x94\xd6\x53\xfe\x0b\xf5\x6d\x82\xb5\xf3\xb9\xae\x65\xe7\xab\xb4\x8e\xd5\x30\x7d\xcd\x91\x66\x4e\x1d\x49\xc9\x5a\xc6\xaf\x7a\x96\xad\x75\x63\x1a\xa9\x34\x8b\xe1\x3c\x6b\x89\xfe\xb3\x16\x38\x4d\x8a\xce\xc4\x37\x3d\x7e\x05\x57\x48\x05\x9d\x4d\x55\xa7\x97\x54\xe0\x4d\x9c\x2e\x7f\xbd\xe7\xe1\xbc\x69\xd1\xc3\x5f\x4d\x92\xc5\x84\xf2\xf2\x57\x3b\xe2\xea\xa9\x95\xa4\x8d\xbf\x9a\x24\x91\x2f\x74\x70\x21\x4a\xcf\x4d\x78\x61\x68\xc9\xaf\x62\x02\x51\xcd\xa2\x10\x41\x49\x3b\xcb\xe1\x8c\x19\x3e\xdf\x87\x14\x52\x3f\x87\xd3\xe9\x69\x38\xba\x00\xe1\x04\xf1\x47\xdf\x47\xfc\x43\xd6\xf2\xce\x18\x7c\x14\x0a\xc2\xb3\xa7\xac\xdb\x85\xcf\x92\xce\xf0\x55\x69\xfb\x3f\xb0\x87\xed\x5b\xe0\x03\xa0\xc5\xc2\xd6\x96\x44\x01\x42\xad\xa8\xcf\xf0\x83\x58\x44\x83\x6e\xb3\xd9\x14\xba\x03\xe1\x32\x7d\xcb\x0c\x19\xdb\x6c\x38\x82\xea\xa2\x3a\x2e\x1e\x53\x53\x09\x10\x53\x5b\x7e\x69\xcb\x0c\xbf\x01\x76\x63\x16\x8d\x69\x2b\x84\x8a\xdd\x8b\x60\x03\x51\x1b\x57\x8f\xa9\xa9\x44\x8b\x5d\x5b\x71\x83\x68\x61\x96\x94\x54\xa2\xf4\x34\xf8\x1f\x2e\x5b\xaa\x59\xc1\x6a\x60\x9e\xb3\xc8\x9d\x58\x27\x44\x21\x02\xe2\xa0\xb8\x2d\x17\xa3\x7f\x89\xff\x46\x94\x97\x01\xe0\x81\x61\x69\x7c\x65\x83\x59\x45\xcd\xb3\x2c\xdd\xc2\x68\x73\x2a\x06\x91\xaf\xcc\x09\x47\x64\x16\xcf\x9e\xda\xd8\xc9\x34\xef\xdb\x8d\xac\x15\xae\xeb\xe3\x3c\x3b\x55\x0b\x2b\x7d\x8f\xb8\x53\xca\xe9\x75\x9a\x58\x2b\x5e\x57\xcf\xe4\xb2\xb0\xaa\x16\x56\xbe\xae\x6e\x26\xd7\x0e\x0d\x72\x45\xd5\x70\x92\x8b\xa6\xf4\xa1\x82\x37\xe2\xc4\xa3\xcd\x1d\xfd\xce\x79\xae\x33\x3c\xfb\x76\xaa\x87\x6a\x1f\xad\x11\x9a\xa2\x4a\xad\xc9\x27\x61\x0e\x4f\xa0\xde\xf3\x34\x3a\x8b\x50\xee\x9f\x72\x37\x85\x2e\x51\x11\x34\x66\x81\xe8\xba\xc5\x1a\xaa\xac\xe1\xd5\x5d\x54\xa9\x87\x4a\x9b\xc7\xa4\xfc\xca\xa8\x64\x74\x9f\x02\x91\x64\x91\x9f\x46\xb2\xd0\x43\xa2\xcd\xbd\x16\xbe\x32\x12\xa1\xda\x57\x20\xcf\x11\xcf\xfd\xa4\xf1\x46\xac\x7e\x74\x23\x89\x44\xbe\x26\xb2\x18\x4d\xb7\x40\x1a\x59\xe4\x27\x8f\x2c\x2c\x92\xe8\xfb\xcd\x6e\xda\xef\x2c\x64\xb8\xae\x51\x7e\x47\x00\x97\x27\x15\xdc\x88\x94\x05\xc1\x18\xd1\xee\x0c\x87\x3c\x43\xb3\xe6\x9d\x96\x3c\x73\x4e\x17\x7c\x0f\xae\x8d\x6e\x5d\x35\xa5\xfe\x39\x94\x67\x4a\x6d\x39\x56\x31\x65\xfb\x7d\x76\x47\x21\x79\x87\xd8\x72\x65\x2c\x4c\xf4\x08\x82\x73\x68\x9f\xdd\x41\x37\xfa\x3b\xec\xc0\x78\x3e\x05\xc9\xe9\xbb\x26\xfb\xa4\x83\xb6\xe9\xc7\x95\xfb\xec\x8a\x3c\x20\x70\xeb\x25\xa7\xef\x0a\x9d\x79\x90\x49\x4e\xdf\x59\x5b\xb2\xa8\x21\x2b\x63\x29\x24\xce\x28\xc4\xed\x3c\x30\xa8\xee\xd9\x28\xed\xdf\xba\xa5\x0c\xe2\x63\x7e\x16\xa2\xca\x30\x02\x3f\xe1\xc7\x71\x34\x0b\x73\xfe\x3c\x8c\xc3\x73\x08\xa0\x07\x74\xcb\x78\xfe\x3a\x3c\x7b\x13\xcd\x78\xb2\x28\x3d\x36\x7d\xdf\x6d\x7a\xeb\xf7\x44\x03\x08\x7d\x96\xcc\x5f\x63\xf5\x27\xd8\x6b\x60\x57\x14\xcd\x35\xa9\x4a\x5a\x78\x09\x28\x08\x64\x38\x80\x1d\xc0\xf7\x3d\xf6\x89\xc9\xd1\x41\xbe\x65\x76\xb5\xcf\xae\x68\x07\xb9\x8c\x27\x13\xa6\x29\x01\x09\xdf\xda\xca\xe1\x17\xca\x0e\x58\x98\x0a\x45\x08\x8b\xce\xd2\x64\x06\xdf\x6d\x70\x3e\xf2\x91\x14\xef\xa3\x45\x9a\x1e\xe5\x4b\xb8\x37\xc0\xac\x9b\x68\xad\x8c\xc7\x53\x7e\x38\x09\xe3\x73\x4e\x14\x3b\xeb\x7b\xe0\x1a\xe7\x16\xd3\xa9\xd4\x09\xe4\x53\xfc\x49\xb2\x98\x8e\x8f\xf2\x64\x4e\x6e\xe1\x64\x11\xcf\x55\xa7\x34\x92\x0e\x7c\x0b\x86\x99\xf8\x87\x1a\xe8\x0c\x24\x37\xc4\x81\x32\xb4\xe9\xaa\x36\x99\x24\x28\xd3\x0a\x0c\x8d\xf8\xb5\x6d\x87\xa4\x76\x61\x6a\xa8\x2a\x1c\xc2\x72\x8a\xaf\x0b\xe0\xaf\x7d\x5a\x36\x34\x85\x6a\xee\xf0\x0b\xd1\x6e\x19\x50\x5a\xb7\xcf\x8e\x3b\x03\x5a\x98\xf2\x0c\x47\x6f\xba\xc8\xda\xd9\x34\x1a\xf1\xa0\x6b\xc7\x9f\x93\x0b\x06\xa1\x91\xdc\x36\x74\x1c\x41\xa7\xe5\xf2\xba\x5a\x50\xcd\x40\xd1\x19\x6e\x14\x20\xe3\x6a\x8b\x74\xdf\x6c\x01\x68\xd3\x67\x29\x55\xf4\x7c\xc9\xfa\x9b\x77\xed\x04\x5b\x2b\xcc\xad\x1a\x3b\xd2\x07\x47\xaf\x0f\x01\x0d\x76\x60\xfd\xda\x53\x52\xd5\x30\x41\x9f\xdc\x7d\x19\x72\xd1\x15\xa0\x26\x17\x4b\x2c\x6e\xd7\xd5\x9a\x05\xbc\x3c\x68\x69\xa3\xa0\xe9\x07\x8b\x03\x6a\x1b\xa6\xf6\xc0\x4f\xd2\x59\x27\x99\x13\xb9\x2c\x7e\x06\xe4\x60\x42\x57\x14\x89\x84\xae\x1c\x7d\xc2\x34\xb7\x1a\x87\x69\x1e\x58\x8b\x89\x79\x17\xa5\x33\x9f\x19\x1d\xa5\x04\xbd\x38\xcd\x46\x69\x74\xca\x29\x78\xf5\x2d\x18\x52\x42\x99\xae\x1c\x21\x62\xd5\xd2\xec\xa5\xee\xc3\xf4\x4e\x44\xf9\x78\x2d\x31\x64\xc1\x53\xc2\x48\xf2\xac\x66\x5e\x8b\xf8\x57\x05\xe5\x60\xb3\x9b\xe8\x1b\x57\x0e\x8a\x9b\xa1\xb5\xb2\xd4\xae\x96\x86\x67\xa5\x16\x5c\xb3\xf7\xa5\xe1\x59\xd5\x8e\x97\x86\x67\x5f\x76\x9f\xb3\x86\x12\x8c\xa4\xc9\x86\xe4\xfb\xd2\xbb\xba\xfb\x02\x82\xfd\xc8\xba\xa2\x5b\xfd\xfd\xb8\xeb\x64\x91\x84\xad\x91\x14\x42\x6a\x36\xb2\xe3\x89\x5e\xc1\x37\xdb\xec\x48\xb0\x2e\x7e\x9f\x8f\x31\xc7\xa3\xc1\x92\x7c\x0f\xe2\xe4\x03\xdd\x96\x34\xa4\x1f\x58\xc7\x96\x27\x12\x7e\x9c\x7c\x28\x08\x8b\x38\xf9\xc0\xb6\x4d\xa5\x1f\xd5\x38\x09\x00\x49\x0a\xe8\x6e\xbf\x08\x75\xbb\x2b\x81\xe2\x95\xc7\x27\x2a\x79\xc5\x24\x13\x79\x4b\x90\x2f\xc8\x9d\xd5\xf5\x8b\xeb\x63\xb3\x1b\xde\x5a\x9e\x1a\xf2\x06\xbe\xc9\x3e\xed\xec\xb0\x5f\x78\x0c\x3e\xef\x63\x76\xba\x64\x87\xc9\xd9\x19\xe7\x47\xa3\x34\x9a\xe7\xac\xdb\xee\xf6\xda\xbd\x5b\xee\x45\xbb\x3e\xc2\xc4\xc9\x11\x46\x0a\x6e\xb1\x49\x2a\x48\xdc\x62\xd3\x24\x1c\xbf\x81\xbf\x10\xe3\xdf\xf4\xef\x38\x19\x93\x5f\x8b\xb9\xf8\x57\x07\x89\x52\xe2\x7d\xce\xd3\xb3\x24\x9d\x85\xf1\x08\x13\xc2\xdd\xd1\xdc\x06\xca\xb0\x5b\x8c\x2f\x6f\xed\x82\x36\x61\xa0\xc2\x91\xc5\x19\x09\x11\x66\x0e\x04\xbd\x85\xa0\x0f\x00\x30\x81\x85\xa8\xf4\x2b\xf0\x21\x49\x8a\x0c\x82\xd2\xc3\x00\xe9\x74\x0d\xfc\x02\x9b\xe2\x41\x93\x6d\x5b\x24\x6d\xb2\x1d\xd6\xe5\x0f\x09\xd6\x4c\x4e\x0a\xeb\x3b\xbd\x63\xa1\x0d\xcf\xdf\x37\xa8\xa9\x3a\x80\xed\x44\xa8\x56\x08\x22\x70\x63\xb6\x4e\xd2\xe3\xce\x80\xdd\x65\x5d\xfe\x3d\xbb\x27\x7e\x75\x07\x16\x2a\x36\x37\xa8\xa3\x26\x19\x0e\x56\x43\xb6\x20\x18\x2f\xe6\xd8\x1d\x82\xc6\x4a\x74\xd8\xda\xd5\x44\x7f\xd8\xd6\xbc\x65\x4d\xdc\x93\x30\xbf\x2e\x6b\xa8\xa6\x40\x73\xc5\xe0\xd6\xe8\xa6\x06\x1b\x53\x99\x20\xb0\x76\x97\xd2\xd6\xcd\x03\xc8\xb0\xf7\x06\x49\xb0\xba\x73\x5f\x33\xbc\xbd\xbf\x75\xd5\xc4\x3b\xf7\x7c\x12\x65\x60\x39\xd8\xf9\x1b\xcb\xc0\x66\xfb\x3c\x9c\xcf\xa3\xf8\xfc\xf7\xd7\xbf\xf5\xc9\x22\xd8\x8e\x93\x0f\xed\x77\x59\x7b\x16\xce\x37\x76\x69\xd9\xf5\x38\xb2\x7c\xbf\x59\x2c\x95\xcf\xa6\x06\x64\x93\x70\x3a\x4d\x3e\x40\x64\x44\xd6\xb7\x52\x57\xc0\x0e\x1f\x65\xaf\xa6\x61\x14\x63\x7f\xbd\x52\x95\xa0\xd7\xf4\x36\xd8\xad\x50\x0e\x6c\xc8\xa4\x3d\xe0\x52\xd6\xd5\xfd\x87\x6e\xcd\xea\x3e\x10\x18\x69\x03\x67\xa9\x32\xe8\x18\x66\x86\xd6\xac\x86\x8e\xc0\xbe\x99\x5c\x0a\x26\x97\x2f\xa8\xf2\x11\x06\x16\x60\x1f\x43\xdc\xb9\x9f\xac\xc0\x15\x8f\x31\xde\x9b\xfe\x5c\xc8\xfc\x74\xe5\x6e\xcc\xba\x51\x9d\xc3\xa0\xa8\x0c\xf7\x64\xc4\x0d\x12\x9d\x34\x1e\xeb\x44\xae\x10\xce\xcd\x00\xff\x69\x1d\xe0\x3f\xf9\x81\xff\x64\xb2\xc4\x96\xc6\x93\xbc\xa5\x23\x44\x66\x8f\x8d\x43\xce\x85\xf4\x76\x7a\xdc\xdc\x27\x15\x7e\x2a\x56\xf8\xa9\xa9\x55\x16\x00\xa1\x94\x65\x81\x0d\x34\x71\x0c\x1e\xa5\x08\x9c\xfe\xea\xfa\xaa\x39\x0e\x52\x70\x7a\x97\x3d\x12\x3f\xab\x88\xf5\x59\x67\x9f\x45\xec\x07\x46\x11\xd8\x67\xd1\xbd\x7b\x4e\x08\xcc\xc7\x32\x1a\xd0\xe3\xe3\x88\xc6\x48\x14\xc3\x3c\x16\xc5\x03\xcd\x04\xf8\x93\x28\xc7\x49\x9c\x47\xb1\xc9\x01\x06\xff\xec\xec\xa8\x00\xba\x10\xcc\x0e\x3d\x51\x30\x7a\x42\x92\x4a\x3a\x19\x2b\x82\xd0\x7b\x95\xc4\x30\xba\xaf\xe9\xdb\x35\x17\x95\x37\xd0\xd8\x49\x0e\xc2\x9f\x94\xf0\xa6\x52\xa9\xb9\xc9\xc9\x0b\x60\xd4\x02\xd5\x31\x4a\x4e\x1f\xa6\x2d\x4a\xa2\x7a\x19\x07\xa8\xbe\x88\xe0\xe9\x16\xb0\x06\x39\x4a\x9b\x51\xa2\x7c\xee\x21\xdc\x76\x78\x35\x50\x4c\x65\x4d\x09\x7c\x19\x58\xf3\x81\x9f\x56\x07\x4c\xbd\xe5\x88\x1f\x8f\x34\x3b\xc4\x38\x92\x81\x8a\x24\xd8\x62\x31\xff\x98\x43\x10\x51\xfc\xf3\x28\xd7\xa9\xf5\x24\xac\xdb\x96\x20\xd4\xd9\x31\xe7\xa6\x0d\x34\x47\x12\xfa\xeb\x66\x02\x28\x85\xef\xe2\x26\x4e\x72\x02\xb5\x24\xe6\x71\xae\xce\xaf\xab\x10\x73\x86\x84\x89\x5a\xbd\xad\x44\x77\x3b\x77\x19\xcf\xa6\x51\x9c\x6f\x8f\xa3\x4c\x3e\xdc\xdf\x06\x87\x8f\xed\x94\x87\x59\x16\x9d\xc7\x96\x1b\xde\x7c\x91\xf2\xd7\x3c\x1e\xf3\xf4\x09\x1f\x25\xb0\x8d\x42\x24\x50\x40\x11\xf1\xd0\x3f\x49\xa2\x11\xef\x58\x58\xdf\x3f\x46\x81\x57\x89\xbe\x44\x7f\xfa\x6c\x2b\x1e\xf4\xf6\x0b\xaa\xe1\x17\xf3\xb9\xab\x13\xb1\xeb\x9c\xe7\xd4\x5f\xda\x71\x9f\xa3\xa5\x2f\xcf\x2a\x1d\xe9\x68\x55\xcf\x9d\xd9\xe6\xae\x74\xe0\x1b\x5c\xee\xb2\xd6\xbd\x7f\x9f\xb8\xac\x3d\x13\x6a\x48\xc6\x91\x69\xca\x2e\x75\x1e\x92\x06\xaf\x79\x56\x7a\x17\xa9\x21\x8f\xc2\x2c\x7f\xac\xc2\x27\xbc\x54\xa1\xaf\x7c\x6d\x1e\x75\x3b\x2b\x82\x55\xca\x34\xfa\xf2\xbd\x9c\xbe\xcb\x8c\xe2\xd1\x74\x31\xe6\x63\x16\xc5\x2c\x9c\x4e\xd9\x79\xf4\x9e\xcb\x56\x10\x1d\x61\x91\x45\xf1\x39\x3b\x3e\x39\x0a\x67\x1c\xc2\xd5\xfe\x37\x4f\x93\x93\x41\x20\xf3\xf1\xd4\xce\xc5\x93\x85\x33\x0e\x7d\xff\xc9\xd3\xa4\x29\x20\x8b\x4d\x18\x22\x87\x46\xf9\xd2\x0e\x9c\x0f\xae\xdc\xe9\x98\xa7\xe0\xd9\x44\x6e\x60\x75\x60\x03\x12\x02\x5a\x80\xd2\x91\xce\xc1\xe8\x92\x4f\x38\x3b\x8b\xd2\x2c\x5f\x33\x28\x56\xa7\xdd\x75\x5f\x6b\x03\xf1\xa9\x53\x58\xbb\xdd\xb6\xf2\xac\x66\x24\xd1\xaa\x0c\xfb\x20\xb6\xf5\x1a\xa9\x19\xc4\xe1\xd2\x64\x83\xd0\xec\xa3\xf3\xe6\xf9\x9f\x7f\x47\x84\xcf\x82\xe3\x5e\x8b\x75\x07\x2d\x26\xfe\xdd\xb5\x62\x5f\x1d\xf7\x06\xda\xe5\x2c\xb2\x59\x53\x31\x9f\x59\x15\x32\xf0\x96\x36\x46\xcd\xc2\xf9\x1c\x82\x3b\xab\x15\x20\x6b\xb4\x7c\xfc\x48\x43\xaf\x05\xd8\x52\x29\x13\x5b\x5b\x12\x94\x13\xa6\xab\x33\xc0\x48\x23\x07\x85\x95\x23\x01\x60\xf1\x1e\xc6\xe5\xf2\x2e\x7e\x3a\x26\xcf\xe2\xdf\xdc\x67\x47\xe5\x38\x2e\x75\x2e\x55\x4b\x14\xc6\xf4\x0c\x17\x51\xe9\xab\x8e\xef\xbf\xf3\xd5\xfe\x23\x2a\x7d\xd0\xfe\xa8\xd3\xa3\x2d\xea\x4a\xa1\xdf\xe3\x30\x2d\x8b\xbe\xd5\xeb\xf6\xb4\x54\xc1\x34\xc7\xa5\x63\x7b\xf0\x85\x5c\xa8\x9f\x47\x82\x21\x9f\x87\xf9\xa4\x3d\x8b\xe2\x5a\x6f\x48\x24\x20\x86\xa1\xb4\xec\xf5\x70\xd2\x72\xc3\xbe\x28\x31\xe3\x89\xfc\xd2\x92\x22\x70\x34\xe2\xf3\xdc\x96\x94\xde\xc5\xbc\x22\xeb\xb2\x6c\x53\x21\x0b\x0a\x81\x5f\x8e\x15\x56\x28\x42\x34\x8e\x34\xf4\x8b\x4c\x9d\x5c\x06\x01\xa5\xa6\xd8\xf5\x11\x86\xf9\x5d\x0e\xa5\xb6\x4c\xca\x26\x10\xee\xdc\x9b\x42\xa6\xb0\x70\x95\x84\x50\xa3\x68\x11\x5c\x68\x80\x19\xbd\x4e\x08\xaa\x07\x9e\x65\xb1\x67\x7f\xf3\x67\x74\x16\xa2\xa4\x98\x66\xe1\x37\xbb\x4e\xb1\x82\x0a\x68\xa7\xeb\xb6\xf4\x2d\xc6\x68\x02\xc8\xe9\x2c\x83\x32\xdc\xbe\xaa\x30\x0b\x3f\x6a\xe8\xcf\xe2\xb3\x28\x8e\xf2\x65\x21\x54\xce\xf1\x80\x06\xc9\x51\xfd\xd9\x29\x15\x64\x42\x6a\x35\x0c\x55\x89\x64\x55\xd0\x78\x6e\x6d\x39\x91\x7a\xb4\x54\x28\x48\xe8\x96\x11\x02\x81\x6e\x63\x45\xc4\xa7\x03\xd0\x6b\x30\xa0\xa9\xb0\x5b\xa6\x8e\x6c\x89\x54\x31\x38\xb2\x3e\xbb\x4d\x66\x6f\x6b\x8b\xe9\xce\xc0\x0a\xa1\x2e\xbc\xfa\xac\xdb\xeb\xe0\x9d\x97\x01\x2f\x3f\xeb\xb8\xf6\x07\x4c\x7a\xf6\x82\xb4\xb5\x46\x8d\xd9\xb4\x65\x3d\x2b\xeb\x2d\x8e\xc6\xa1\x61\x67\xa0\x2f\xc6\x8a\x71\x8c\x32\xce\x85\xa8\x91\x43\x91\x55\x93\x45\xce\xd3\xbd\xf2\xcc\xdf\x02\x09\x2b\xe0\x1a\xfb\x81\x10\x87\xcc\xa6\x7c\x17\xc3\xac\xa4\xe0\xfa\x54\x28\x68\xb5\xc8\x31\x5b\x82\xa2\xd3\x81\x89\x8c\x24\x1d\x8f\xf7\x54\x6e\x24\x09\x15\x21\x06\x84\xd0\x97\x97\xf2\xb3\x38\x14\x76\x9a\xca\xc3\x18\x2f\x0a\xcd\x51\x57\x0c\x95\x5c\x2e\x1f\x68\x71\x0f\x25\x2d\x8d\x8e\x9d\x59\x40\xad\x4c\x1d\xb0\x58\x55\xb3\x16\xb2\x6e\x42\x8e\xbd\xbe\x05\xa5\x0e\xbf\x92\xb0\xdb\xdb\xaa\x12\x3d\x2d\xc3\xc5\xa6\xdc\x63\x5d\x1e\x33\xf7\xe0\x32\xf9\x82\x28\x27\x08\x3b\x23\x83\x3f\xfc\x43\x73\x86\xe7\x2e\xb8\x92\x81\xda\x10\xec\xeb\x7a\x65\xce\x41\xfe\x21\x37\xf6\xb7\xec\x7f\xc1\x0b\x88\xf3\x98\xb6\x16\xbf\xf1\xc9\x9d\xc6\xb5\x98\xac\xd4\xbc\xcb\x43\xde\xb8\xd6\xcb\xbc\x67\xd5\x1a\xd2\xe6\xfe\xba\xd8\xc9\x98\x7f\x7c\x59\x76\x93\xff\xdd\xf7\x34\xaa\x7a\x79\xc2\x28\xb1\x8b\xe3\xf4\x60\xee\x24\xb9\x81\x7a\x42\xb8\x41\x2c\x74\x8c\x70\x29\x14\xe5\x30\x96\x4b\x3d\x4f\x58\xc6\xc3\x74\x34\x81\xb7\xd4\x35\xb6\x6b\x54\xde\x89\xee\x5e\xb6\x5d\xdf\xbd\x62\x79\x98\x9e\xcb\xf4\x6b\xfa\x15\x88\xea\x2d\x49\xd7\x78\x04\x88\x80\xe0\x15\xe0\x59\xb2\x88\xc7\x95\xef\xff\xac\xed\x4f\x89\x77\xe7\x21\xa0\xbd\x1b\xaa\xd8\xc9\xec\x80\x75\xd4\xfe\xa9\x23\x45\x1a\x3b\xce\x6d\x23\xdc\xc8\x14\x5a\x3d\xb4\x84\x78\xf9\x11\x2e\xed\x4b\x03\xfa\x29\xd4\x3c\xbc\x75\x33\xe1\xd9\x7e\x8e\xe2\x71\x55\xe8\xd9\xef\xbe\xa7\x4f\xc6\x9e\x65\x2f\xc2\x17\xa5\xca\x74\xa7\x69\xe2\x0a\x8d\xf2\x6a\xae\x7d\xd4\xe9\xd6\xcc\x05\x20\xf8\x16\x20\x99\xa8\x1b\x27\x82\xff\x00\xfe\x09\x3b\x15\x73\x9c\xd5\x08\x25\x48\x55\xc8\x5a\x1c\xe9\x79\x96\xe4\x32\xa4\x13\xa5\x50\xa3\x85\xaa\x66\xc9\xa2\x21\x7c\xac\x1a\x52\xed\x10\x9b\xc9\x88\xb6\xb3\x30\x1f\x4d\x94\x7a\xa8\x38\x79\xbb\xeb\x8d\xed\xe1\x65\x31\x8d\x92\x65\xcd\x33\x4f\x4c\xe1\x2f\x79\x4e\xb4\xe6\xad\x14\x8e\x3c\x35\x5a\xcc\x43\x15\x23\xe0\x11\xda\xa0\x4a\x7a\x42\x57\x1e\xe6\x5e\x3f\x8e\x5c\x15\x03\x9d\x29\x3c\x65\x86\x08\xfc\xf2\x5b\x98\xe5\xf2\xab\x64\x2c\x10\x7c\xd5\xa1\x2c\x6f\x8e\xc3\xcc\x01\x63\x9e\xf2\x71\x34\x0a\xf3\xfa\xc1\x29\xaf\xc9\x77\x6e\x40\xe3\x63\x51\xf4\x3a\x3a\x9f\xe4\x03\x1d\xd2\x58\xf6\x14\x9f\x63\xc0\x8c\x54\x94\x0a\x60\x53\x7e\xe6\x1e\x6d\x6e\x92\x7b\x0b\xac\xa4\x89\x42\x58\x09\xff\x04\x84\xcb\xc4\xb3\x73\x0e\x51\x3a\xaa\xa1\xd0\x3d\x16\x68\x20\xec\x80\x75\xd9\x1e\xdb\xee\x5a\x01\x37\xad\x72\x99\xa8\x8d\xed\x31\x57\x6f\xb5\x02\x05\x68\x6c\x03\x4b\x3b\xc5\xe6\x2d\xa9\x64\x17\x2e\x15\xa0\xd4\xab\x77\x94\x6d\x0a\x16\xa9\x0a\xeb\xe6\x51\x67\xdd\xec\xa9\xab\x62\x1e\xbd\x08\x5f\xf8\xa3\xbc\xaa\x50\xac\x18\xdf\xe2\x4b\x3e\xed\x87\xc4\xed\x35\x22\x1d\xbd\x08\x5f\x78\x42\x1c\x19\xdd\x5e\x1e\x04\xca\x23\x13\xbd\x08\x5f\x78\x28\x5c\xc7\x11\x94\x52\xb8\x5a\x21\x53\x1b\x1b\x84\xea\x90\x8e\x2c\x99\x8a\xe1\xac\xcc\xb6\x18\x95\x5f\x5b\x6e\x4d\x6e\xc9\x16\x8b\xda\xbc\xcd\x4e\xfa\xfd\x7e\xe5\x1b\xdb\xff\x9b\xb7\xbe\x7a\x9b\x56\x21\xf8\xae\xc1\x77\x9b\x75\xfd\x76\x0f\x1a\xff\xbb\xe4\xec\x4a\x45\x00\x5d\xf8\x66\x6b\xbd\x81\x35\x6f\x8d\xd0\xc3\x91\x75\x5c\x2f\x0b\x31\x57\x49\x04\x0c\x69\xe5\xb3\xf4\xcd\x13\xc6\x3f\x8e\xf8\x3c\x47\xf3\x5d\x44\x2c\x78\xe4\xfc\xf6\x2f\x38\x01\x14\xd3\xbb\x9a\x93\xfb\xda\xa6\xb9\xcf\x73\x8a\xf8\x23\xca\x27\x0e\x1f\xfa\x8d\x74\xae\xf5\x64\x8d\x73\x46\x3d\x8e\x34\xdd\xaa\xe0\xf3\x94\x47\x8b\xdb\x11\x79\x37\x50\x3b\x8d\x7c\x61\xe8\x1e\x06\xbd\x81\x04\x64\xf3\xf9\xb4\xcc\xe2\xfe\xa8\x73\xff\x4b\x19\xd2\xc3\x8f\xda\x90\x1e\x7e\xac\x9b\xa4\xf9\x35\xcf\x72\x25\xe1\xf3\x34\x8c\x33\x94\xf1\x02\x85\x94\x17\x6e\xcf\x3c\x4b\xc9\x30\xfb\x99\x2f\xd3\x17\xd2\x26\x44\x60\xd0\x84\xe7\x3c\x65\x79\xe2\x95\xd3\xc7\xf0\xf6\xa3\x2f\x00\x48\x6e\xda\xee\xe2\xf2\x84\x02\x36\x4f\xb2\x48\x69\x00\x1a\x45\x0d\xb5\x64\x11\xea\x61\x01\x20\x33\x2a\x53\xe0\xac\x3c\xd3\xd4\xb5\x8b\xab\x91\x39\x2b\x2c\x79\xcf\x53\x7d\x9d\xd6\x42\x5c\x5b\x06\x3c\xb2\x32\x8e\xa0\x6f\x66\x2b\x90\x5f\x9c\x07\x00\x01\x19\xbd\x10\xff\x4d\xb6\xa7\x20\x76\xe8\x45\x5b\xc1\xd3\x55\x45\x28\xa6\x2f\x0f\x8c\x05\xb2\xb8\xa2\xc9\x9a\x36\x38\x09\x00\xa6\x73\xdd\xaf\x69\xa3\x2c\xae\x68\x1e\x9f\x2a\x23\xf1\x2d\x62\xea\x2b\x5b\xf5\x8c\xd9\xbb\x10\x60\x8b\x53\xce\xee\x31\x9a\xb8\x16\xed\x60\x06\x65\x92\xce\x56\x2c\x85\xc7\x38\x4a\xf5\x64\x0d\xdb\x77\xa5\x8d\xac\x80\x04\x54\xb0\x6c\x95\x08\xc1\xc1\xa3\xd8\xbf\xa9\x09\x20\x30\x6c\xaa\x9c\x53\x94\xa1\xb2\x4b\x95\x75\x4a\xf0\xba\xe4\x01\x74\x41\xd1\x10\x9a\x15\x51\x07\x14\xf7\x78\x64\x53\x1d\xaf\x0d\x5b\x9d\x93\xb1\xfe\xc2\xa9\xbc\x8d\x7f\x0f\x1b\xd5\x89\x62\xe9\xbf\x01\x8e\x27\x88\x9f\x7b\x98\xcb\xd8\x89\xf8\x72\x22\x20\x69\x41\x74\x22\x6a\x9e\x30\x15\xdd\x4f\xc8\x0d\xf1\xe5\x71\x7a\x8e\xc7\x55\x8c\xa0\xa6\x32\x13\x89\x62\x41\xcd\x4a\x85\x6f\x85\xc8\x40\x64\x0a\xfb\x2f\x76\x0a\xb5\x3d\x38\x01\xe2\x6d\xaf\x5a\x79\xae\xae\xe4\x14\x92\x24\x31\x03\x34\x83\xc1\x3a\x32\xe0\xae\xbd\xf8\xe5\xc5\x8e\xd5\x13\xdd\x62\x9d\x99\x7f\x9c\x9e\xb7\xa0\x67\xb9\xf4\x65\x60\x0e\xb2\xb8\x14\x3f\x42\x5c\x8b\xce\x1e\x5d\xd4\xc6\xa9\xfc\x71\x7a\xae\xef\x5f\x32\xce\xba\xe5\xd5\xb0\xb7\xe3\xce\x80\xd6\xef\xd5\xa8\x2f\xff\xe8\x5a\x0d\x77\xd7\x69\x28\xff\xe8\x0d\xdc\xcc\x0e\xd0\x16\x29\x63\xd3\xa4\x64\xaf\x16\x35\x3d\x6b\x60\x73\x27\x1e\xb1\xcf\x1d\xf1\xfc\x4d\xa2\x43\xac\xf8\x77\x6a\xe5\x9a\x03\xf6\x94\x97\xa5\x0f\xb3\x1f\x75\xbe\x27\xc6\xc1\xa3\x42\x78\x21\xb5\x41\x1b\x6e\x11\x1c\x27\x89\x72\x82\x71\x82\x36\x59\x1f\xb3\x64\x1c\x9d\x95\x65\xef\x44\xf0\x72\x95\x38\xa1\xae\x56\x6e\x73\x94\xb7\xe5\x73\x67\x42\x34\x45\x96\xc0\xa1\xa7\xd7\x39\x83\x34\xf5\xcc\xe9\xe6\xbe\x19\xe0\x4c\x1e\xc6\xe5\x73\xa4\xbc\x2d\xec\xe7\x0b\xa5\xd5\x75\xaa\x33\x88\x30\x5e\x51\xb1\xa6\x5d\x98\x8c\xdf\x6f\xa2\x98\x24\x39\x9b\x26\xc9\x1c\xc9\x1a\xc5\xe7\x7f\x09\x8e\x28\x2e\xa5\xdb\x0e\x81\x0f\x0c\x09\x49\xa6\x47\xa5\x18\x99\xa0\x44\x2a\xea\x90\xfd\xba\x04\xeb\x35\x14\x9e\x8d\x96\x14\x93\x8d\x51\x12\x9f\x45\xe7\x0b\xc8\xb3\xd4\xc0\x37\x26\x38\x61\x0d\x93\x7f\xa9\xb1\x87\x67\x01\x59\x00\xa7\x8a\xc6\x9e\x66\x95\x40\x76\x2f\x8b\x3f\xa4\x51\x4e\xa0\x55\x25\x71\x74\x46\xed\x61\xe8\x75\xf3\x17\x69\xe7\x3c\x32\x8f\xe2\x2c\xab\xb3\x8c\x38\xa1\xc9\x56\xb9\xad\xf5\xda\xf7\x4b\x93\x8c\x54\x1a\x4e\x74\x5c\xdf\x64\xe6\xd5\x72\x6b\xa9\xc5\x7a\x31\xda\x2d\x8b\x29\x21\x55\xc0\x59\x27\x27\xa4\x9e\xa1\x4f\xac\x11\x36\xf6\x58\x97\x5d\x35\xbd\xe9\x21\x65\x7b\xcb\xcb\xcd\xb4\x69\x31\xf3\xb7\x2f\x5f\xa4\x6c\xad\x3c\xd1\xd4\x4f\x3b\x63\x24\xf2\x02\xdd\xdc\x35\x76\x45\x7b\x5d\x41\x07\xa7\x76\xbc\x0a\x95\x4f\x81\xf4\x70\xd2\x17\x89\x10\xa4\xe2\x07\xba\xb2\xb1\x3c\xfe\x33\x84\xa3\x16\xb2\x87\x46\xb4\x79\x29\x83\xcd\x36\x6c\x40\x0d\xa9\x4b\x88\xfa\xc1\xa7\xab\x16\x6b\x88\x75\x7c\x65\x2b\xcb\xa2\x70\x8d\x60\xd0\x76\x0f\x1e\xba\xad\x73\x27\xe3\x06\x44\x14\xb2\x58\xb5\xc9\xd8\xe9\x92\xa4\xf2\x12\xba\x0f\x5e\x43\x47\x31\x0b\x59\x36\x0f\xd1\x05\x2d\x9a\x4e\xa3\x0c\x1f\x5a\xea\x73\xf8\xaf\x2f\xdf\x0c\x0f\x5f\xfe\xfe\xe2\x0d\xeb\xb3\x47\x9d\x0e\xca\x19\xf1\xf1\xe8\xd5\xe3\x17\xac\xcf\xba\x0f\xbf\x8c\x25\xe0\x45\xf2\x81\xbc\x9a\xf4\x78\x04\xdb\x42\xa7\x31\x9d\xe2\x26\xc4\xc4\x1e\x25\x74\x7a\x9d\xb6\x4c\x4a\xf2\x13\x16\xc5\x59\xce\x43\xc8\x43\x6e\xb4\x9a\x0f\x13\x1e\xb3\x28\x6f\x64\x40\x25\x3e\x66\x27\x9a\x02\x27\x90\x51\x2d\x49\xb9\xcc\x85\x16\xc5\x58\x28\x28\x01\xe7\x0b\x8b\x80\xd7\xdf\xf9\xc4\x69\x3e\x8d\x0a\xae\xb6\xe5\xa2\x0a\x06\x0a\x3e\xff\x25\x67\x79\xad\xe5\x9c\x59\xc9\xc0\x47\xc9\x02\x94\x8d\x8e\xb6\x87\x85\x59\x7e\x88\xc3\xee\xcb\x57\xfa\x55\x07\xf3\x2c\x0f\x67\x73\x7d\xd2\x7e\x91\x7c\x08\xc8\x99\x3a\xe5\xb3\x30\x8a\x71\x3f\xd5\xfc\xb2\xcd\x02\x6c\xb4\x4d\xfa\x52\x27\x6d\xab\x77\xa8\x66\xdc\x7f\x0c\xb4\x1f\xe9\xfb\x7e\x51\x74\xef\x1e\x8e\xe3\xc7\xbe\x61\x56\xcf\xe3\x15\x13\x83\xa0\x33\xf0\xbe\x61\x31\xaf\x9a\x24\x55\xe8\xb1\xb9\xa8\xfe\x9b\x88\x87\x06\x74\xd5\x89\x58\xcd\x41\x71\x99\x77\x37\x4f\x38\x25\x5f\x44\xd5\xf0\xa6\xa7\x3e\x00\x87\x61\x96\xeb\x6d\x19\x0c\x5b\x31\xcd\x81\x2c\xa8\x0b\x2b\x21\x4e\x72\xe3\x47\x0a\xa6\xeb\xeb\x86\x97\xae\x70\x22\xbf\x54\x61\xcf\x29\x77\x8f\x42\x65\xd8\xda\x76\xfa\xa5\x7b\x59\xd1\x79\xdb\x9b\x69\xa3\xa4\x8e\x71\x37\x2b\x4b\x97\xec\xe9\xc0\x33\x8b\x9b\xc5\x2b\x71\x66\xb1\xcc\x2b\xba\x73\x9d\x7c\x60\x6e\xda\xb7\x88\xb8\x19\x9b\x2e\x8b\x17\x10\xd3\x4c\xde\x1a\xd2\x80\xe3\x02\x18\xe6\xc9\x73\x98\x60\x75\xd2\xb8\x8e\xab\xce\xfd\x16\xc6\xe7\x9f\x35\x26\x79\x5c\x64\x9e\x96\x00\x54\xb8\x5a\xf0\x3c\x48\x28\xf0\xcb\x71\xb7\xc5\x0a\x0f\x12\xa4\x6a\x55\xd6\x66\x9c\x8c\x40\x34\xb4\x4f\x93\xf1\xb2\x3d\x9a\x44\xd3\x71\xca\xe3\x35\x00\x34\xc2\xd3\x51\xc3\x97\xfd\xbb\xac\xc1\xb0\x1d\x27\xc9\x7c\x45\xbe\xf0\xd2\xc5\xb0\x3a\x87\x21\x69\xaa\xdd\xf8\xfc\xe1\xd2\x57\x2f\x99\xcd\x42\x98\x7c\xa6\xf8\x7f\x67\x90\x62\xbf\xec\xa5\xfb\xa3\xee\xae\x53\xb3\xea\xa5\xbb\x84\xa5\x5b\x40\x6a\x16\x88\xa2\x21\x91\x95\x2f\xf3\x2e\x2f\xc9\x63\x74\xbc\x08\x6b\xb2\x4f\xf6\x73\xde\x2e\x3e\xe7\x75\x03\xf0\xa8\x27\xbd\xb8\x23\xab\xc0\xe1\x66\xb7\x8b\x06\xfb\x85\xf4\x0b\x58\x4d\x34\x12\x1b\xa8\x9b\x6d\xa0\xed\xcb\xc1\x80\x4d\x54\x32\xe5\x4f\xf2\xea\xf0\xf8\x82\x2f\x07\x62\x73\x83\x52\xf8\xb5\xcf\xae\xe0\xff\xd4\x0d\x17\xd4\xc3\xc7\xed\x18\x9f\x6d\x1a\x8d\xf8\xf8\x4d\xa2\x12\xaa\x5b\xd1\xa6\x48\xac\x1f\x51\xed\x99\x7c\xe0\x1f\x84\x69\xda\x62\x91\x1a\xe5\x30\x84\xe8\x6d\xc7\x83\x7d\xfc\x19\xab\x08\x5c\xf8\x73\xac\xa3\x69\xe1\x6f\x6e\xc5\x67\x40\xfd\xdf\x90\x64\x18\xe1\x9d\xda\xb1\x13\x54\x60\x10\x34\x5b\x6c\x98\xed\xb3\xdb\x01\x74\x10\x0c\xe1\x88\x17\xb5\x63\xfe\x31\x0f\x9a\xcd\xf6\x38\x89\x79\x73\xdf\xf4\x2e\xb0\x13\x98\xa1\x87\xeb\x30\x6b\xcb\xd5\x01\x34\x8e\xc4\xd2\x81\x52\x75\x3f\xd1\xef\x8b\x01\x9d\xa6\x3c\xbc\x40\x92\xa9\x23\x03\x46\x1a\x84\x51\xe0\xa0\x60\x00\x3c\x4d\x45\xb5\xb3\x28\x0e\xa7\x53\x31\x00\x1c\x06\xc6\xd0\x8b\x01\x7a\x74\x7c\x07\x89\x7e\x67\xd0\xb4\x7e\x05\x4d\xbb\xa9\x68\x34\x1c\x37\x59\x3e\x49\x93\x0f\x6c\xc8\xf7\xe9\x84\x09\x24\xf7\xcd\x4f\x33\x3d\x66\x0e\x8a\xb1\xfd\xc2\x34\x6d\x92\xb8\x04\x12\x84\x7e\x1a\xec\xc6\x6b\x30\x19\x40\x9c\x86\xde\x59\xd7\xa0\x3e\x49\x8c\x85\xce\xfb\x66\x39\xe7\x90\x20\x32\xb8\xf3\x2c\x7e\x1f\x4e\xa3\x31\x0b\xf3\x5c\x68\x2f\x78\x06\xc2\xa8\x0c\x8b\x54\x26\xb0\xce\x65\x36\x6b\xf5\x66\xf7\x0e\x40\xbd\xda\x67\x57\x41\xf3\x73\x84\xee\x82\xaa\x0b\x4c\x40\xe4\x7f\xde\xb4\xfb\xc5\x23\x59\x1e\x26\x71\xb6\x98\x09\x32\x58\x31\x2d\xcb\x67\xd3\x8e\x26\x00\x77\xd9\x3d\x7d\x45\x65\x78\xb9\xa9\x04\x53\xea\x8a\x24\xd1\xe0\x38\x1a\xc8\x05\x16\x0d\x08\x5f\x89\x22\x32\xb1\x56\x60\x4d\x1a\x3d\xd3\x1e\x84\x23\xdb\x93\xd3\x77\x20\x91\x8c\x03\xb1\x0a\xb9\x20\x58\x4c\x12\xcf\xbf\x2d\x98\xa6\x9f\xd4\x3e\xa0\xdc\x5e\xb4\xed\x4d\x9a\xe4\x18\xb5\xd3\xa9\x6f\xca\xd2\x86\xbf\xd9\x15\xe5\xd2\xe4\xf4\x9d\x12\x8c\x68\x34\x31\xc3\xc6\x40\x1f\xf2\x8a\x7d\x3a\x9f\x84\x54\x02\xc2\x87\xe0\x94\x9f\x47\xb1\x40\x63\xdc\x62\x17\xd6\x8e\x0c\x25\xec\x1e\x0b\x78\x3c\x66\xdb\xf8\xb3\xc9\xee\xb2\x0b\x30\xf1\xc1\x59\x99\xf3\xf1\xa1\x72\xe3\x27\x90\xe9\xf7\x60\x98\xf2\x33\x73\x08\x04\x2b\x59\x9f\x89\x8f\x40\x78\x75\x82\x83\x04\x2b\xf0\x35\x4f\xe8\x0d\xad\xa8\x7e\xbb\xdf\x67\x90\x26\x05\xf4\x4b\x50\x9f\xc6\x3c\x83\x60\x60\x51\x12\xef\x89\xa3\x33\x1a\xdd\x44\x65\xd4\xe3\xc4\x11\xfc\x3d\x9f\x26\xa3\x28\x87\xc9\xe1\xe1\x68\xc2\xb2\x9c\xcf\xe7\x3c\x25\xaa\x9d\x60\xe3\x63\x08\x7a\xa8\x66\x6a\x20\x3e\x01\x62\x2c\x4f\x5a\x06\x86\xe0\x0c\x65\x22\x18\x85\xd3\x23\x04\xf5\x8f\x70\x4a\x23\x26\x39\x25\x01\x0f\xb3\x28\x3e\x07\x57\x47\xf1\xbb\x05\x18\x90\x17\xa2\xf8\xa6\x9e\xcf\x25\x18\x88\x98\x20\x56\x71\x7b\x16\xce\xe5\xb3\xd0\xc0\x48\x44\xc5\x79\xd4\x03\xc4\xa2\xb4\x28\xb3\xa3\x64\x0d\x11\x03\x21\xd0\xe1\x0f\x51\x05\xc9\x2e\x00\xb5\x61\x84\xe1\xb4\xad\x46\x69\x05\x2d\x95\x6d\x41\xfa\x58\xbb\x68\x30\x54\xe3\xea\x59\x0d\x62\xfe\xe1\x3f\x45\x65\xd9\xce\x09\x73\x1a\xf3\x0f\xff\xa0\xa5\xdd\x81\x1b\x08\x52\xa9\x2b\x60\xef\x7a\x1f\x4e\x5b\xe4\x54\x2d\x70\xde\x83\x1e\x0c\x4c\x85\x35\x7c\xff\x87\x3a\x63\xdb\x31\x3a\x8d\x31\x11\xce\xca\x7a\x2a\x4c\xc0\x14\x98\x12\xf6\x03\xeb\x3a\xf6\xc7\x35\x27\x63\xe5\x74\xd4\x1a\x26\x1d\x14\x2e\x4f\x3a\x3d\x2d\x8b\x61\x60\xcd\x93\x32\xe4\x2d\x4a\x72\x24\x9a\x81\x83\x13\x5f\x84\x81\xdf\xb1\xbd\x79\x86\xd3\x2c\x84\x7d\xb5\x89\xe9\x90\xd3\x0e\x99\x51\xb2\x10\x68\xdf\xb2\x47\xf0\xcf\x90\x6b\x7b\x47\xcb\x3e\xce\x16\x18\xeb\x41\x51\xdc\x17\x1e\xda\xcc\x86\x59\xb0\xaa\xa7\xf1\x02\xdd\xa9\x5b\x2c\x85\xb8\x0e\xd4\x2f\x2b\xe7\xa9\xcc\x3a\x64\x26\xf9\x9c\xe7\xf4\xa9\x8f\x28\x6f\x6a\xb0\x3a\xfe\x4e\x1e\xcd\xa2\xf8\x5c\x85\x8c\xd5\x90\xda\x29\x1f\x2f\x46\x9c\xb0\x47\xca\x33\x99\x40\xcc\x62\x2a\x6b\xee\xa1\x8e\xbb\xc7\x88\x02\xe0\x2d\x70\xdd\x86\xf9\x11\x18\xc0\x1f\x03\x7c\x84\x78\x25\x2d\xc1\x2a\x7c\x25\xd2\xf9\x8b\x20\xa5\x38\x15\x39\xcb\x60\x78\xcb\x65\xde\x8e\x91\xeb\x7b\x0a\x7d\xe4\x19\x7b\x0c\xea\xf9\xda\xd9\xb3\xb1\xf6\x52\x11\x5f\xe6\x29\x97\xc1\xe3\xde\x27\xd1\x18\x8d\x63\x70\x79\x26\x36\x21\x6f\xc9\xa2\x10\xbf\x13\xbf\x54\xc4\xaa\x36\x41\x23\x0f\x49\x20\x60\xdd\x9e\x7e\x77\xa1\xac\x2d\x1d\xcc\xda\x81\xe5\xa6\x17\x10\x9d\xbd\x66\x49\x0c\x6d\x8c\xe0\x8d\x61\x07\x9c\x30\x2f\x56\xb1\x8b\x24\x86\xe0\x91\xc7\x46\x12\xea\x93\x74\xd9\xb2\xf6\xea\x26\x79\xe7\x84\xf4\xd9\xd9\x51\x18\x4a\xde\x37\x08\x80\x91\x23\x9b\xa7\x51\x7c\x6e\x73\xa2\x27\x92\x2a\x2d\x70\x43\xa9\xde\x96\x73\x6d\x68\x65\x26\x9f\x44\x51\x55\x5b\xda\x98\x4f\xf3\xd0\x14\xb3\x6d\x55\x7d\x9f\x18\x8a\x85\x5c\xe9\x93\xaa\x3b\x52\x2e\xb4\xc7\xb9\xdc\x75\x9c\x55\x53\x22\xaf\x6c\x52\xa1\x84\xc4\x7e\x76\x76\x04\x7f\xb0\x45\x2c\xe3\xd9\x82\xc6\x11\x8e\xc7\xe8\x0a\x9a\x47\x42\xfb\x9f\xa7\xfc\x2c\xfa\x28\x67\x44\x08\xa1\xc0\x5a\x6a\x46\x68\x59\x9c\x66\x71\x44\x53\x59\xab\x1d\x9a\x18\xea\x79\xf9\x80\x46\x94\xc5\xa5\xe5\x09\xf9\xba\xf0\x07\x87\xdd\xd9\x61\x39\xeb\xff\x28\x58\xd5\x3f\xe7\xa3\xc5\x69\x34\xda\x3e\xe5\x7f\x46\x42\x97\x22\x72\xb1\x38\xf1\xf4\x7b\x61\xde\xf5\x5a\x36\xd8\xd2\xe5\xed\x46\xd0\x85\x7e\xc4\x48\x70\xd6\x49\xeb\x1d\x2d\xed\x0d\x0f\xd0\xd0\xde\xd7\x5d\xac\xb0\x73\x16\xed\xef\x9e\xb3\x8d\x68\xdd\x1e\x25\xf1\x28\xcc\x83\x63\xa9\x6a\xe5\xcd\x81\x7e\x34\xde\xa2\x3b\x87\x9a\xd2\x1b\x65\x21\x13\xa3\xbc\x49\xb8\x23\xa7\x8a\xcd\x1a\xcc\x60\x5f\x51\x80\xde\x2e\x8e\xf3\xd7\x26\xe8\x0d\x91\xb4\x6b\x48\x5a\x46\xd4\x55\x74\x32\xe3\x68\x16\x38\x5f\x6f\x21\x52\x58\x44\x99\x94\x09\xf0\x74\x8e\xca\xb6\x3d\x8b\xb3\xd5\xb2\x51\x56\x05\xf0\xa6\x0c\xb5\xd0\x46\x33\x78\xf1\x72\xcb\x04\x3c\xaf\x9a\x0f\xc5\x2a\x1a\x78\x32\xf7\xc1\xae\x0c\xa7\xae\xe0\xb7\x47\x61\x3c\xe2\xd3\x66\x00\x8c\x60\xc5\x12\x56\xa7\x2b\xcb\x60\x7a\x03\x7e\xdd\x62\x2e\x7f\x86\x1d\xa8\x34\x4c\xca\x77\xe4\xfd\x69\x65\xd5\x47\x5d\x2b\x54\x94\x7a\xbb\x57\x76\x77\xd1\xd3\x77\x17\xca\xf8\x57\x1e\x4b\x54\x5e\x5b\x48\x98\x19\x38\x94\xaa\x47\x05\xe8\x92\x39\x4a\xa6\x53\x1d\x1f\x05\x69\x2d\xdf\x4e\x9b\x80\x27\xd3\xa9\x6e\x23\xa0\x9d\xe8\x47\x63\x27\xda\x2b\x25\x4f\x17\xf9\x64\x09\xef\x1d\xe0\xda\xc1\x3c\x0d\x8c\x32\xfd\xa2\x41\x5e\x5c\xa7\x1c\xee\xb8\xb4\x71\x75\x8f\x29\x37\x7f\x70\xb4\xbd\x84\x75\x66\xf0\x6a\xaa\xbb\x91\xbb\x77\x5f\x24\x39\xdf\xbb\x7b\x97\xfd\x1e\xab\x9b\x97\x94\xcf\x92\xf7\x5c\x79\xad\xea\x5b\x73\x44\x2a\x34\x11\x4b\x36\x89\xf2\x74\xa8\x51\x29\x38\x91\xea\xeb\x36\x83\xae\x7c\xce\xa1\x7f\xe6\x89\x7a\x8e\x09\xd4\x2f\x8b\xd5\xa2\x09\xd6\x1f\xb6\xd5\xe5\xfa\xa0\xf6\xbb\xca\x55\x51\x5b\x50\x59\x52\xe9\xf6\xb1\x4d\xc6\x39\x13\x04\xc4\x50\x92\x5e\xa7\x9c\x45\xc6\x53\xa1\x71\x1c\xc3\x6d\x0f\xfb\xc4\x1a\xe2\x4b\x63\x8f\x35\x4e\xc3\x34\xe6\xcb\x46\x8b\x35\xc2\x73\xde\xd8\x63\xbb\x0f\xc5\x9f\xa3\x3c\x7a\xaf\xbc\xa6\x20\xd1\x82\xd3\xea\x2c\xe5\xe3\x46\x8b\x31\xd5\xea\x7e\x87\xb6\x02\x6b\x33\xd8\x23\xd8\x60\x5f\xdf\xcd\x20\xea\x01\xa0\xd2\x32\x37\xe8\x09\xb1\xe8\xdd\x4e\xda\x08\x64\x1f\x8f\x77\xea\xca\x86\x26\xb1\x3e\xc6\xce\x95\xf3\xcf\xce\x0e\xba\xbd\x0d\xdb\xf8\x5c\x2b\x3b\xf1\x3c\x9a\x6d\xfb\x30\xf8\x54\x35\xe4\xf2\xde\x25\xc1\x4a\xfb\x57\x87\x92\xda\x78\x1c\xab\xbe\x5b\x48\xb8\xc1\xda\x23\x9f\xaf\xdb\xa5\xea\xb1\xd6\x28\xc9\x3d\x99\x84\x62\x16\x05\x79\x25\x4b\x4c\x68\xe8\x43\xa4\xcc\xa7\x44\x00\xa8\x10\x40\x52\x8a\xee\x11\x91\xea\xbc\x7a\xb0\xfa\xa0\xd2\x34\x20\xcf\x72\x77\x9b\x25\x97\x6d\x67\x12\x64\x61\xc3\xd8\x3c\x44\xa2\xc0\xe5\x69\x38\x2a\x0b\xe8\xb5\x7b\xff\x41\xed\xa8\x02\x88\xa5\xdf\x75\xf4\x3a\x0f\xbf\x6f\x4c\x86\xad\xff\x1c\x7c\x7d\xb1\x55\x78\x7d\x5d\x87\xb3\x9c\x34\xea\x6a\x2e\xac\x66\x7a\x5a\xe9\x56\x64\x6d\x43\xde\x57\xd3\xa5\xb5\x9b\xde\x4c\xea\x85\x88\x2d\xf4\xd9\xce\xaa\x98\x2d\x3f\x97\xb1\xe7\xcd\xf8\xc1\xff\x9c\x94\x2b\x28\xca\xff\xfd\x02\xed\x4b\xfe\xbc\xd0\x8f\xea\xb3\x70\x92\xbe\xfc\x10\xdf\x08\x0b\x57\xa6\xf9\xaf\xc1\xb4\xba\xbb\xb5\x79\xd6\xf5\xb4\x39\xc1\x7e\xbd\x41\x02\x60\xbc\x3a\x03\xbf\x1d\xb0\xcb\xdc\x69\x08\xac\x65\xdc\x95\x9f\x93\xb4\x50\x1d\x8c\x55\x65\x6f\x24\x4c\x37\x1e\x06\xb9\x01\xa7\x7a\x70\x10\xfc\x69\x05\x9b\x7c\x57\x93\x03\x0c\xb2\xea\x81\x61\x64\x69\xa8\x8a\x94\x02\x8e\xdc\xa5\x22\x9e\x49\x4a\x61\x14\xcf\x13\x41\x8b\x9f\xc1\xd9\xd0\xf8\x25\x66\xec\x44\x11\x0b\x63\x05\xc1\xfd\x88\xda\xe7\xda\x44\x15\xe6\xc4\xab\x73\x16\x2e\x19\xff\x18\xe5\x66\xa6\x19\x0f\xd3\xe9\x52\x74\xc3\x3f\xce\xa7\xd1\x28\xca\xa7\x4b\xa2\x1c\x13\x8f\x97\xaf\x86\x2d\x0b\x10\x14\x7d\x0a\x8e\x91\xe2\x70\x2e\x04\x2c\xac\x65\x31\x1b\x84\x6f\x6b\xb3\xb7\x2d\x34\x2c\xee\x08\xbc\x5e\xba\xb2\xb2\x87\x39\xaf\xef\x20\x0f\xec\x65\xb4\x8c\x24\x2d\xc4\x7f\x3c\x4b\xd2\x67\xb1\x09\x9e\x82\x2c\x57\x35\x6f\x37\x15\x62\xa4\xdc\xcd\xd4\x42\xda\xf5\xc1\xb3\xe8\xe8\xc4\x0c\x71\x7d\x48\xfd\xe2\xe1\x67\xed\x9b\x5a\xf6\x5c\x9b\x31\x7d\x8f\xaf\x1c\x68\x24\x2c\x72\xcb\x02\x81\xbb\x65\x48\x7b\x01\xb2\x58\x43\xbf\x10\x85\xaa\xf4\x85\xb7\x7e\x68\x29\xdf\xe9\x6e\xdb\x97\x77\x17\x7c\xa9\x5a\x1d\xd3\x88\x25\x12\xa0\x0e\x58\xa2\xfd\x4b\xc1\xf3\x43\xe9\x71\x0a\x77\x79\x85\x00\x67\x45\xf5\x0d\xf3\xe1\xc1\xe2\xa4\x36\x1a\xf4\x0e\xb1\x9d\x55\xa9\x69\x21\x91\x8e\x55\xe5\x3e\xf9\x74\x5a\x3c\x1c\xbc\xb9\x63\x7e\x3d\x9f\x45\x9f\xbf\xf6\x89\xd2\x66\xc0\xaf\x5a\xff\x02\xa2\x9e\x58\x7c\xb6\xda\x8f\x5a\x48\x4b\xaf\xc8\xa0\x02\x0b\x22\x29\x28\x35\xe7\xb3\x84\xe7\xd9\x74\xed\x80\x6e\xa7\xc6\x52\x08\xbd\xe3\x2e\x23\xaa\x04\xba\x91\x34\x31\x18\x81\x56\x83\x9d\x7c\x17\xe6\x56\x50\x57\xb1\xde\x28\x9f\xb1\xe0\x36\xf5\xf3\x2b\xd1\x0e\x01\x84\x42\xd7\x8f\x8e\x7b\x59\xa0\xd7\x1e\x99\x09\x3b\x7e\x90\x1d\x41\xa8\xb0\xc4\xaa\xa5\x01\x41\xd4\x5e\xd0\xeb\x46\x18\x2a\x5b\xbb\x4e\x94\xa1\x0d\xd7\xaf\x4d\xfe\x95\x6b\x58\xb0\x87\x67\x11\x6f\x9e\x68\x1a\xa3\xef\x3c\x07\x07\xb4\x12\x0d\xa9\xa7\xde\xcb\x9f\xf3\x1c\x2a\x3e\x09\xf3\xb0\xb4\xb2\xf2\x52\x96\x26\x82\x23\x70\xd2\xc4\x4c\x06\x72\xc2\xfc\x67\xc9\xba\x6a\x18\x31\x7e\xa0\x16\x36\x4e\x78\x16\x37\x72\x36\x9a\x26\x31\x67\x27\xe8\x8f\x58\x4b\xcf\x91\x2e\x93\x44\xcf\xc1\xb4\x6d\xf8\x7c\x48\x45\x95\x4f\x70\x28\xf5\x9f\x64\xcc\xf9\xa8\x6c\xbd\x8b\x41\x3d\x47\xf4\x03\xed\x89\xa9\x43\x94\x1b\xd2\x52\x4a\xab\x8a\xfb\xd2\x49\x42\xd7\x33\xfe\x84\x98\x87\x51\x17\x1c\x77\x06\xc7\xbd\x81\x73\x01\x59\x32\x1f\x81\xd5\xaa\x33\x68\xd9\x60\xba\xde\x67\xd0\x64\x2b\x77\x7a\x91\x74\x14\x4b\x42\x52\xf7\xf2\x92\xf2\x98\x56\x00\x94\x53\xa9\xee\xad\xea\x01\x05\x21\x5b\x71\x11\xf4\x36\x7f\x43\x71\x94\x87\xa3\x8b\x52\x9b\x78\xd7\x8a\xc9\xa8\xd2\x58\xf8\x8f\x93\xca\xef\x5e\x3f\xc9\x82\x4c\x1a\x19\x67\xa7\x51\x3e\x0b\xb3\x0b\xb4\x39\xa1\x5f\x94\x95\x1f\x40\xaa\xa7\x87\x2f\x9f\xbf\x7a\xfc\xfa\xe9\xf0\xd5\xe3\xd7\x6f\x9e\x3d\xfe\x6d\xf8\xf3\x6f\x8f\x7f\x61\x7d\x15\x34\x49\x95\xfe\xfe\xe2\xe5\xeb\x27\x4f\x5f\x3f\x7d\xa2\xca\x7b\xb5\xa3\x3b\xe2\x34\x7c\x81\x53\xac\x27\xec\xd0\x06\xeb\xce\x0e\x82\x60\x96\x0a\x9a\xed\x65\xcb\x38\x9c\xf1\xac\xa5\xc3\x75\x09\x05\x1a\x69\xcc\xd9\xd9\x34\x3c\x2f\x81\x49\x63\x8f\x2f\xb2\x3c\x99\x45\x7f\xf2\x74\x50\x50\x27\x74\x99\x35\x6f\xf5\x9f\x26\xc8\x93\x08\xbc\x4d\x40\x2c\x6a\x84\x55\x5b\xb1\x66\x5a\x06\x2b\x4f\xb0\x23\x57\x50\x14\x42\x1f\xe1\x4e\x26\xbf\xc6\xc9\xa1\x86\x05\xe1\xb0\xf5\x2f\xed\x9e\xa5\x17\xb7\x2f\x83\xd6\x6d\xe2\xae\x70\x8b\x69\x41\xe0\x28\xeb\xfb\x26\x98\x52\x54\x0c\x21\x3e\x46\xe9\x67\x24\x50\xe4\x44\x10\x0f\x2c\x2c\xb7\xb6\xa0\x85\x90\x75\xc4\xd3\xea\x00\x3f\x76\x75\xa6\x21\x3e\xca\x8f\xc7\x28\xcf\x06\xa4\xde\x1e\xbb\x1d\xc8\xcf\xd2\x65\x54\x20\xa8\x2b\xac\x4e\x4a\xb4\x32\x40\x4c\xe5\x70\xcc\xa9\x42\x22\x61\x94\x9b\xe4\xf4\xdd\x3f\x64\xb0\x6c\x89\x3e\x75\xec\x61\x2c\x4b\x47\xaa\x5c\x0e\x75\x9f\x26\xb6\xf5\x53\xc8\xd2\x6e\x4c\x0f\x56\xb4\x9e\xad\x2d\x76\x9b\xb8\xd0\x0a\x7a\xac\x95\x0b\x8a\x9e\x98\x32\x29\x53\x21\x16\xba\xf8\x9b\x9e\x8c\x5c\xb6\x35\xcd\xb4\xd9\xd3\x54\xd1\xd8\xb6\xf4\xc8\xe5\x19\xca\x5d\x18\xd0\x67\x21\xfa\x34\x86\xdb\x56\x80\xe9\x80\x09\x37\xe8\xd4\x1d\x28\xe0\x03\xd3\x93\xe9\xdd\x2b\x9c\x2f\x4b\xa4\x32\x5d\x9b\x0a\x33\xab\xbf\x3d\x39\x56\xf2\xb1\x2e\xb5\xed\x1d\x59\xa7\xc4\x2a\x09\xad\x08\x42\xc4\xb3\x6f\xde\xc4\xab\xb5\xda\xea\xdd\xda\xc6\xd8\x5f\x54\x20\x92\xfa\xe2\xdd\xb1\x0b\x5d\x6b\xdf\xfa\x9f\x05\x4f\x97\xab\x0d\xfd\xb0\xa6\x71\x81\x3b\xbd\x12\x19\x6e\x69\x71\x54\x5d\xb2\x18\x5d\x25\x0e\xa4\x96\x0a\x2d\xa2\xad\x58\xfd\x34\x14\x9d\x6b\xa6\x30\xe2\x04\x9b\x1c\x63\x05\x22\x35\xde\x17\x45\xca\xbe\x72\xcc\xa5\x2d\x58\x9f\x1d\x1b\xc7\xfa\x96\x67\x92\xe5\x8d\xc0\x60\xbf\x7e\xf8\x76\x4a\x0a\x0f\x2b\x6e\xf6\x1a\xcc\x9c\x63\x56\x29\x67\xfa\x1c\x53\xca\xa7\x2a\x70\xca\x24\xcc\x9e\x95\x65\xbd\x7a\xd4\xd3\xe1\x55\xb2\xff\xe0\xe5\xc9\x69\x76\x75\xad\xb5\x97\xc9\xfa\xa7\x27\x6c\x97\x27\xe5\x08\x75\xf5\x7d\xdd\xd7\xaa\x9d\x16\xae\x95\xfd\x27\x3c\x29\x9a\x2b\x17\x39\x06\x47\xb9\x62\xf3\x30\x9f\xa0\x96\x28\xfe\x90\x71\xf6\xb4\x48\x41\xcb\xb2\x1b\x9b\x4b\xef\xaf\xd6\x5b\xd4\xcf\x72\x0a\xd4\x6e\xbd\x02\x3d\xb3\xbf\x35\x75\x2a\x56\xe0\x30\x28\x95\x4f\x30\x0b\x8b\x51\xb7\xa9\x79\xe0\x03\x16\x41\x88\xa4\xc3\x7a\xa7\x3c\x19\xf4\x44\x69\x1f\xe7\x3c\xd7\xca\x29\x00\xb4\x42\x62\x54\x68\x19\x56\x89\xc6\xe1\x96\xda\x88\x61\xf1\xd9\x90\x6f\xa9\x4d\xf3\x46\x37\xe9\x9a\x87\xce\xf2\x38\x1d\xbd\xcd\xdd\xb2\x66\x7c\x96\x44\x7f\xf2\x43\x95\xa1\xcc\x2f\x71\x0a\x07\x4b\xdc\x81\xec\xcd\x51\x05\xf6\xd0\x5f\x05\xe9\xcc\xf2\x4d\xf9\x6f\x3c\x1c\x47\xf1\xf9\x93\x44\x08\xc0\x9d\x7f\xbe\x6d\xef\xb4\xe4\x8c\x89\x21\xbe\x08\xc1\xd9\x73\xe7\xf8\x9f\xed\xe3\xb7\x83\xc1\xbd\xcb\xb7\xc7\xc1\xc1\x5e\xb0\x7d\xf0\x76\x7c\x2f\x38\xd8\x7b\xdb\x7e\x3b\xbe\xd7\x3c\x68\x5e\x06\xc7\x77\x1a\x83\x66\x20\xca\x0e\x6e\xbf\xed\x35\x8f\xff\xf9\xf6\xed\xe0\xf2\xed\xdb\x76\xf3\xee\x41\xf3\x6d\xaf\xf9\x76\x70\x19\x1c\xf4\xa1\xc5\xe5\xdb\xe3\xb7\x83\xa6\xf9\xf3\xf2\xef\xcd\xe6\xce\xb9\x77\x28\xa7\xe1\xe8\x22\x9b\x86\xd9\x04\xe3\x6b\x94\x8e\xe1\x69\x36\x0a\xe7\xfc\x70\x12\x8a\x63\xca\xce\xdb\xb7\xc1\xdb\xb7\xcd\x03\x05\x13\xec\xcc\x49\xfc\x9e\x8b\x39\x54\xc1\xc9\x20\xbe\x81\x0d\x70\x75\x20\x50\x25\x40\x48\xbc\x29\xf9\x27\xc8\x4d\xe8\x62\xb5\x9e\x50\xd2\xa9\x8c\x47\x06\xf0\xde\x24\xaf\x42\xd8\xeb\x2d\x46\x30\xcc\x44\xa3\x4c\x79\x1c\x03\x30\x44\x86\x99\xd8\x76\xce\x33\x1d\x1b\xca\x88\x04\x73\x9d\xdf\x68\xe8\xc5\x8e\xb5\xda\x29\x9f\x4f\xc3\x11\x0f\x0c\x17\x10\xd7\x02\x79\x54\xc5\x10\x32\x2d\xf6\x3f\x8b\x24\xe7\x76\xe8\x2b\x1b\x3c\x54\x90\xf9\x0d\x2c\xd8\x66\xde\x5a\xac\xf1\xf7\x6e\xa3\xc9\xf6\x58\x20\x23\xd3\x5c\x5e\x22\x13\xc8\x07\x09\x5e\x07\x03\x7f\x5c\x36\x42\x42\xcf\xea\xdc\xdc\x07\x46\x4e\x4a\xe9\xba\xb4\xb7\xd4\x50\x69\x87\x1f\xa3\xd9\x62\xa6\x1b\x63\x4a\xa0\x2c\xfa\x93\x6b\x3e\x7e\xfe\xf8\x3f\x87\xcf\x9f\x3e\x7f\xf9\xec\xbf\x9f\x0e\x8f\x9e\xfd\xf7\x53\xd6\x67\x0f\x3a\x9d\x7a\xa9\x65\x24\x58\xb5\x3d\x8e\xa6\x3c\x4c\x65\xc7\x58\x32\xd6\xd3\xd7\x00\xe7\x47\xec\x5f\xc6\xb7\x81\x58\x0f\x7c\x9c\xb1\x13\x17\x87\x4d\xa2\xf8\x4d\xc2\xf7\x9c\x45\x79\xc6\x92\x45\x3e\x5f\xe4\x1a\x93\xda\x1b\x66\x01\x75\x67\xd3\x2c\xae\x0e\xcf\x92\x90\x95\x64\xdc\x35\x3d\xe3\xe4\x9d\x0d\x9c\x3e\x05\x39\xda\x19\x4c\x6b\xbf\x5f\x98\x0a\xea\xa3\x2d\x2a\x02\x7d\x83\xa6\x27\x26\xcc\x05\x5f\x2a\x7e\xbd\x65\x27\x7f\x92\x2b\x02\x7e\xd6\xf4\x96\xb1\x06\xe8\xe1\xe5\xcd\x1d\x66\x9e\x87\xf3\xaa\x04\x90\xbd\x8e\xb2\xc1\x33\x78\x5e\xcd\x66\x3c\xcb\xc2\x73\xae\xc3\x7b\x19\x29\xfc\xf3\xef\x2f\x0e\x87\x4f\x5f\xbf\x7e\xf9\x7a\xf8\xe6\xe9\x7f\xbe\x61\x7d\xd6\x78\xfa\x71\xce\x47\xb9\x58\x03\x86\xf9\x56\xc6\x6a\x52\x83\x2e\x89\x4a\xca\x9e\x9d\xb1\x93\x94\x67\xc9\xf4\x3d\x4f\x4f\x58\x94\x49\xdf\x8a\xf7\xd1\x98\x8f\x5b\x82\x97\x75\x96\x54\x15\x34\x66\x84\x4e\x02\xa0\xc8\x66\x79\x82\x02\xdb\xc0\x16\x9b\xfa\x98\x41\xef\xb6\x3f\xaf\x06\x2b\x98\xd9\xbb\x94\xda\xec\xa7\xa5\x7a\x67\xdd\xb2\x12\xb2\x22\x08\x8a\x5b\x29\x10\x16\x65\x6c\x61\x49\x8a\xb9\x41\x1a\xbd\x90\x4d\xd0\xda\xa2\x17\xb2\x2f\x56\xac\x1f\xd9\x82\xfb\xf1\x1b\x4d\x9e\x28\x03\x76\x21\x58\x9c\x40\xc1\x89\xd9\xad\x90\x40\x1a\xac\x80\x64\xc8\xf0\x2c\xcf\xf0\x66\x0a\x96\x65\xb8\x64\xa7\xdc\xd8\x3a\xc0\xcf\x05\x85\xbe\x22\xbd\x91\x58\x6d\x60\xbf\x13\x15\xc8\x0e\xde\xe9\x27\x29\x0e\x4e\xa8\xf6\x1f\x20\x54\x98\x7a\xa8\x9f\x99\x43\x82\x9a\xae\xe3\x93\xe7\xe1\xfc\x1a\x99\x7a\x8d\x3f\xce\x76\x72\xb6\x9d\x4f\xf8\xf6\x2c\x9c\x6f\xeb\xb0\x17\xdb\xda\xf8\x77\x57\x07\xca\x11\x50\xcf\xc2\x11\x47\x87\x73\x21\x02\x4e\x5a\xec\x64\xcc\xa7\x3c\xe7\xe2\xaf\x73\x9e\x8b\x7f\x26\x61\x76\x82\xb6\x88\x93\x8c\xe7\xf5\x23\x1c\x7a\x5c\xb6\x95\x6c\xbc\x31\xa9\x5b\x34\x70\xab\xb5\x54\x34\x6f\xcb\x12\x7b\x15\x6d\x26\xbc\xcb\x23\x26\xb2\xbe\x0e\x6d\xd8\x62\x8d\xd3\xc6\x1e\xeb\xc1\xd3\x87\xbb\x26\x26\x36\x56\x19\x35\xf6\xd8\x6e\x8b\x35\xc6\x8d\x3d\x76\x1f\xab\xa8\x5a\xf2\x9a\xa0\xcf\x34\x77\x05\x43\x8c\xbb\x21\xe3\x29\xe2\xdf\xc4\xf0\xac\x43\x2c\x76\x5b\xac\x37\xd0\xa0\xb0\x96\xe8\xd3\xaa\xb4\xdb\x62\xf7\x55\x25\x19\xee\x28\xc4\xb3\x6c\x6d\xd8\x3b\x3b\xec\x39\x84\x32\xa5\x12\x08\xf7\x14\x03\xa4\x2d\x77\x23\x72\x94\x3a\x6e\x84\x0d\xa0\xcb\x60\xd5\x48\x74\x45\xd3\xe3\x6b\x54\xb8\x8a\xab\x4e\x7a\x47\x5b\x1f\x59\x9f\xfd\xc1\xc3\x8b\xe7\xe1\x7c\xdf\xbb\xdb\xca\x8d\x54\xb1\x8d\x39\x96\x8a\x55\x93\x9c\x21\x53\xde\xee\xb3\x86\x16\xf9\x90\x2e\x53\xd5\x17\x45\x90\x56\x61\x6b\x8b\xc9\x16\xb4\xc8\xb4\xd2\x8a\xaa\x2f\xca\x87\xb3\xd9\x68\xed\x95\xa8\x67\x63\xf2\xd0\xad\x66\x00\x79\x6d\x2c\x43\x74\x0e\xf4\x9f\x24\xc6\xb3\x0a\x7a\xbd\xa7\xa3\x44\xeb\xe6\x6a\xa3\xd7\x2b\x4e\x6e\xf5\x8e\x92\x31\x09\xb3\x40\xc6\xcd\x71\xdc\x2f\xa0\x58\x1c\xa0\x45\xb1\xeb\x2b\xa1\x15\x9a\x33\x3b\xe8\xb4\x8e\x38\x0d\x36\x22\xab\x6b\x95\x71\x12\x38\x09\xec\x77\x08\xa4\x29\x66\x44\xeb\x21\x05\x4d\x44\xbe\x39\x2a\xc0\x12\x53\x10\xd8\xbc\x72\x79\xa9\x35\x08\xaa\xa0\xab\xa6\xa0\xd5\xec\xec\xb0\xa7\xb0\xb7\xb0\x13\x55\xf7\xa4\x7d\xcb\xe5\x39\x55\xe4\xd3\xe8\x65\x5d\x8f\x02\xb4\xb9\x43\xa8\xd8\xfd\x57\x85\xcd\xee\x51\x47\x04\x73\x94\x24\x91\xf2\xd4\xd1\x86\x3d\x56\x31\xf3\xe4\xc1\x30\x22\xde\x9e\x42\xff\x38\x11\xbc\x0f\xbb\x1d\xec\x0f\xda\x02\x72\xa2\x96\x3e\x9e\x2a\xa3\x73\x54\xec\xb7\x3b\x70\x3b\x38\x4f\x79\xc6\xd3\xf7\x28\xc4\x6b\xed\x25\xd7\x0f\xaf\xe6\x3d\xc6\xaa\x93\xaf\x15\x8d\x0f\x6b\xf2\xb1\x1a\xbc\x47\xbe\x0f\xdb\x2a\xce\x71\x00\xf7\x83\x44\x50\x35\x1a\xc5\x3a\xdb\x1d\xab\xc6\x76\xc7\x53\xc7\x1b\x77\xad\xd1\x6d\xf5\x5a\xbb\x0d\x5b\x60\xe9\x26\x65\x59\xa8\x4c\x86\x97\x46\x43\x9a\x91\xde\xd8\x6d\xfc\x6a\x79\x5e\x1a\x25\xb9\xb7\x79\xc2\x51\x8c\x8e\x54\xc2\x8a\xdf\xef\xae\x9b\x2f\x7d\xe5\xeb\x3a\x6d\x8f\xae\xea\xf7\xbb\xef\xdc\x33\xad\x13\xd1\xf5\x7d\x98\x46\xc9\x22\x63\x27\x2f\xe0\xf4\x7e\xe2\x39\x20\x3c\x7b\xf1\xf3\xb3\x17\xcf\xde\xfc\x17\xeb\xb3\x2e\xdb\x61\x9d\x82\xdd\x19\xd8\x89\x65\x80\x07\x5c\xcc\xcf\xd3\x68\x16\xe5\xd1\x7b\x71\x48\x88\x15\x9b\x19\x80\x58\xf3\x95\xd0\xd8\x58\x5f\xd1\xed\x40\xfe\x61\x02\x98\xd1\xa4\xca\x32\xfa\x3d\xd4\xa0\x71\xdf\x09\xa4\x03\xfa\x4b\xb3\x9d\x9d\x99\xb9\x9e\xe9\xda\x84\x22\x77\x6c\xd6\x72\xa4\x82\xf7\xa2\x6c\x62\xb6\x73\x31\x66\x2a\x3d\xae\x91\xd6\x6d\x9e\x26\x23\x9e\xb9\x4e\x08\xbe\xe5\x6b\x16\xad\x63\x86\x7e\xe3\x59\x36\x20\xc3\xa3\x5c\xfa\x93\xe3\x41\x0a\x30\x04\xe9\x07\x91\x1e\x42\x95\x3e\x4d\xe8\xe9\x6c\x12\xe5\x18\x5a\x6e\xc6\x19\x8f\xdf\x47\x69\x12\x63\x98\x3a\x5b\x59\xd0\xeb\xb0\x81\xf0\x1a\xa5\x51\xa6\xb5\xed\x5b\x3f\x3f\x26\xe6\x6d\xd0\x71\x46\x8b\x34\x8b\xde\xf3\xe9\x52\x13\x58\x52\x35\xc8\x16\xd9\x88\xcf\xf1\xc5\xb6\xe0\xb4\x70\x3a\x95\x77\xd1\x53\xc1\x60\x59\xb3\x4d\xfb\xd4\xc9\xc6\xe5\x65\x17\xa5\x49\x93\xdd\x63\x8d\x86\x8d\x10\xf2\x9b\x83\x91\x7a\x0e\x6c\x73\xda\x81\xf3\x01\x83\xe9\xe9\xd4\xd8\x06\xb2\xb5\xe1\x63\x05\xe8\x99\x6e\xb2\xe6\xfa\x9a\x35\x3a\x0d\x48\x50\x2e\xd6\x95\x84\xd6\xef\xb3\x6d\xb5\xe2\x9a\x42\xc2\x6d\x77\x1a\xfa\x7e\xb9\xdc\xba\x5d\x1e\x00\xbe\x77\x33\xf9\x6e\x7f\xad\xbc\x44\xfb\xde\x5c\xb5\x49\x0b\xa8\xb7\xde\x2e\xcd\x51\x70\x68\x62\x92\xce\xc3\x7c\x22\xdd\x69\xc6\x51\x0a\x5e\x44\x29\x8b\xe2\x09\x4f\x23\xb1\x4f\x99\xb3\xac\xe7\x56\xf8\x1a\x3b\x2a\xde\x1a\x5f\xe7\x1e\xd9\x7a\xb7\xe6\xbf\x97\xba\x46\xa8\x53\x1c\x3e\xff\x18\x65\x62\x26\x56\x05\x35\xb5\xce\x5e\xc3\x36\x3a\x96\xaa\xf8\xf4\xf4\xb7\x3c\x8c\x35\xe5\xb3\x50\xdc\x8f\xed\xfb\x98\x46\xd8\x28\x8d\x62\xea\xd6\x6c\x9f\xd6\xad\xeb\x1e\x7a\x56\x03\x3f\xf5\x06\x47\x25\x02\xce\x73\x8d\xe4\x79\xbc\x44\xce\x28\x92\x13\xad\x26\x2d\xc3\xc9\x25\x1a\x02\x74\xe3\x59\x43\x37\x9b\x56\x17\x7a\xf1\xfb\xed\x8d\x39\x9f\xcb\x6b\x92\x1a\x6e\x0f\xc7\x38\xba\xc1\x9a\x0c\x2b\xce\x4b\x6f\xa4\x71\xed\x1a\xec\x7a\xc1\x97\xe5\xdc\xea\x6c\x4a\xbf\x5a\xf3\xa6\x8d\xb7\xa5\xd3\x26\x3d\x96\x5c\x4f\xb3\x32\xb1\xf7\xab\x7f\xbe\x76\x37\xf7\x23\x1d\x85\x59\x5e\x21\xca\x76\x1f\x74\x88\xa2\xa6\x0c\x8f\x65\xc6\xd8\xef\xd7\x55\xea\xaa\x32\x8b\xf7\xba\xa6\xeb\xdf\x94\x73\x89\xbf\x62\x77\x2d\x57\x02\xaf\x50\xc6\x79\x66\x49\x7c\xa3\xfe\x38\x6b\xcb\xd1\x82\xfd\x6b\x12\xfa\x5f\x97\x41\x1b\xf2\x68\xef\xc6\xc4\xb0\x2d\x8c\x3c\xb2\x45\x62\x84\x0c\x3e\x47\xd6\x51\x5c\x24\x7d\x02\x34\x3f\xaf\xce\x65\x29\x1a\x38\xce\x9e\xc6\x92\x80\x7e\x64\xab\xbd\x16\x8d\x27\x91\xf1\x14\x50\x59\x2c\x8d\x27\xa6\x71\xa8\xf3\xcb\x51\xf2\xfe\x4a\x46\x0e\x26\x91\x85\xcc\xdb\x08\x99\x99\x4e\xed\x4c\x96\x6f\x92\xd1\xbb\x64\x57\x97\x97\xfa\xd5\xc6\xed\xbe\x83\x75\xd1\xac\x71\x8b\x10\xc6\xf6\x5c\x95\x59\x3e\xa5\x55\xcf\xf8\xad\x2a\x4f\x56\xe9\xca\x8a\xfe\x16\xb8\x5a\x54\x66\x40\xfc\x86\xb9\xb3\xc1\xc8\x62\xbe\x03\x1a\x5a\x67\x55\x7e\x13\x97\x97\x74\xb1\xab\xcf\xe5\x3b\x89\xff\x22\x73\x77\x73\x5f\x3d\x21\xf9\x56\xa5\x8d\xda\xed\x11\x57\x77\x55\xf9\x89\xd8\x5d\xca\x1a\xec\xae\xe5\x08\xb5\x86\x48\x59\x91\x50\x28\xd7\xe7\xa0\x30\x57\x8b\x30\x39\x63\x21\x3b\x8f\xde\xf3\xb5\xe3\xd3\xd7\x48\x37\x54\x25\x75\xaa\xbc\x8a\x6a\x18\xcf\xc3\x91\x38\xc5\x25\xe9\x1a\xe9\x86\x4c\x6c\x13\xa1\xbf\x19\xb5\x8d\xc6\x2f\x21\x25\x5d\x19\x32\x95\x86\x28\x99\x85\x73\x95\x41\xa8\xc5\x4c\x5c\x8d\x00\x75\x36\xcb\xca\xdc\x6b\xb1\xee\xc0\x6a\x38\x6c\x67\x49\x9a\xff\xb4\xf4\x42\x20\x9a\x5c\xd3\xa3\x03\x6a\x13\x39\x11\x8e\x73\xea\x06\xe5\x84\xa2\x37\xfe\x4f\x07\x16\x5f\x52\x47\xa6\xa6\xb4\xe8\x50\x9e\x0d\xa4\x47\x92\x6f\xa1\xcd\x4b\x1d\x7a\x76\xd7\x4f\xf0\x5c\xa5\xb5\x99\x70\x25\xd7\x57\xdc\x7c\x1a\xd8\xe7\x60\x39\x47\x0b\xd3\x74\x76\x15\xb0\x9a\x2f\x80\x94\xa8\x35\x8e\x5f\x7b\x05\xf9\x5e\xae\xa4\x95\xbb\x5c\xed\x6e\xee\x72\x25\x3a\xf8\xa5\xc2\x09\x94\x26\x44\xac\xce\x37\xec\xba\x2a\xca\xd9\xcd\x6a\x4e\xed\x97\x96\x2a\x25\x53\x6c\x96\x4b\xfd\x79\x96\x34\x2c\xfa\xff\xd5\x98\x54\xd1\x9f\x67\x62\x37\xf3\xd6\xf9\x4c\x39\x21\xf0\x68\x7c\x38\x0d\xb3\xac\x3c\x65\x81\xd5\x49\xc4\x33\x99\xc8\xa1\x85\x2f\xc6\x8b\x01\xd5\x31\x6c\xba\xf5\x08\x9d\xe6\x72\x50\x11\xb5\x21\x4e\x01\x3e\x3a\x8f\x06\xfb\xe4\x73\xdb\x44\x2a\x87\xd8\x9a\xbe\xef\x97\x97\x2a\x15\x02\x29\xa7\xf1\xcc\x75\x96\x01\xa1\x62\xdd\x81\xd1\xdf\x11\xe7\x28\x53\xbd\x49\x9b\xaa\xb0\xe7\xba\x99\x9f\xc0\x6a\xe4\xa4\x25\x28\x4a\x04\xaa\x95\x74\xc0\x50\xf4\xd0\xb8\x04\x00\xe1\xf2\x44\x00\x85\xd8\xc4\x62\xfb\x7e\xa5\x48\x89\xc1\x6c\x54\x71\xb3\x48\x7c\x02\xc8\x58\x86\x29\x48\x99\x99\xc1\x82\x5b\x05\xc5\x46\x61\x5f\xa1\x4e\x6a\xec\x3b\x09\x05\x46\x82\x5f\x5a\x6c\x98\xf3\xd9\x5c\xa7\x0f\xe0\x61\x69\x76\x26\x92\x64\x40\xd4\xaa\x4c\x33\x20\x2a\xe8\xea\x6f\xd2\x30\xc6\x24\xe2\xbf\xa4\xc9\xa2\x4c\x51\xeb\x3d\x7a\x58\xd6\xa2\xaa\x2b\xa7\xaa\x06\x21\x58\xf2\xcd\x72\xce\xcb\x0e\xaf\x9d\x62\xcd\xaa\x6e\x74\x25\xdd\x0c\xc3\xa7\x72\xe8\xf5\x70\x12\x4d\x4b\xfd\x62\x77\x1f\x94\xb7\xa9\xea\xb2\x50\xf9\x0b\xa7\x64\x00\xfe\x38\x0c\xa7\x53\x38\x3b\x07\xca\xe5\xa5\x45\x79\x4a\xf1\xfa\x6d\x5d\xac\x5d\x63\x92\x33\xab\x62\xb3\x2c\x3f\xc6\x61\x18\xc7\x49\x8e\x46\xf0\x90\x41\xa7\x2c\xa4\x5a\xf5\x9d\x62\xa2\x85\x79\x92\x65\xd1\xe9\x94\x93\x0e\x70\x6f\x09\x32\x3e\x3d\x6b\x01\x30\x8d\x9a\xf8\x64\xf7\xfe\x5a\xdd\x15\x49\x14\x20\xc6\xe1\x24\x84\xcb\x90\x53\xce\x63\x16\xc5\x51\x2e\xb6\xd3\x8c\x8f\xd9\xb6\xd8\x30\x79\x1a\x34\xad\x1a\x98\x7e\x0f\x51\x33\x31\xcc\xe1\x64\xa9\xee\x12\xe0\x77\xbf\xdf\x67\x77\x70\xff\xb9\x23\xc4\x5d\xa1\xcc\x8c\x92\x1d\xe0\xe7\x3d\x26\x30\x76\x26\x43\x1a\x8d\xb3\x20\x5b\x9c\x1e\xe2\xc2\x05\xb4\xe0\x6f\x35\x54\x09\xdc\x14\xc0\xf3\x42\xd3\x85\xc0\xce\x29\x94\xaf\x24\xfd\x53\x73\x24\xea\x8a\x5d\x2d\xe5\x19\xa8\x14\xb3\x45\x96\x33\x1e\x81\xf3\xcb\x29\x47\xed\x29\x49\xc9\x5c\xb5\x20\x1b\xdb\x1d\x76\x8f\x15\x70\x01\x52\x29\xec\xc9\x6d\x98\x4e\x36\x24\x0d\xbc\x04\x41\x0b\x5d\x2a\x26\x3f\x51\xdf\xac\x3d\x93\x23\xc3\x10\x87\xa6\xc9\xc0\x0c\xb5\x4e\x4e\x0c\x5f\xde\x0c\xc1\x66\x4a\xee\x12\xe2\x4a\xfc\x32\x9e\xbf\x52\x28\xbc\x3c\x63\x07\xfe\xef\x25\x13\x64\x70\x6b\x0f\x87\x30\x92\xe1\x90\xf5\x49\x15\x9d\x77\x83\x2e\x7b\x48\xec\x23\xe4\xb3\x10\x13\xa3\xc2\xfe\x3e\x3c\x4c\x66\xf3\x24\xe6\xb1\x54\x7c\x0c\x97\x50\x20\x2d\x46\xea\x81\x75\x45\x43\xa0\xd5\xb4\x4f\x8a\xbb\xf0\xd1\xa9\x83\x56\x6d\xee\x5b\xd9\x12\x2a\x96\x23\xb6\xb5\xd0\x21\xe3\xbf\xbc\x54\x34\x3c\xb7\x69\x68\x75\xd6\x74\x9d\x4b\x64\x36\x43\x93\x44\x80\x2a\x40\xce\xd0\x8f\x3f\xa9\x27\x7d\x7b\xac\x81\xa1\x7e\x1b\xad\x5b\xfa\xad\x99\xc9\x97\xac\xe2\x00\x3b\x09\x31\x54\xbc\x1e\xd1\x39\x9c\x94\x32\x9a\x31\x61\xa4\xe8\x2a\xe6\x07\x55\x25\xfd\xc9\xaa\x27\x33\xab\x91\x6a\xf2\x0b\xad\x15\xce\xe7\x1c\x5e\x0c\xc8\x3a\xf8\x9b\xd6\xe0\xb1\x8c\x76\x8b\x15\xe0\x27\x2d\x9f\xf2\x10\x73\xd0\x2a\xb5\x2d\x7c\x0f\x5e\x2a\x96\x5b\x8f\xdc\xbe\x55\xec\x60\xb9\xee\x9e\xe2\xc1\x30\xd0\xd0\x0a\x9b\xb0\x6a\x60\x3a\xfc\x64\x08\xb0\x47\x68\x71\x65\x6a\x60\x5f\xed\x43\x39\x5a\x38\x98\xeb\xa1\x13\x4e\x86\x6f\x32\x6e\x49\xd3\x4a\x70\xb1\x1e\xd2\xd0\x67\x71\x97\x2d\xa2\x0e\xe8\x5b\xbf\x14\xfd\x5f\x42\x96\x98\x6c\x8f\x15\xc9\xaf\xa7\x40\xd7\x29\xcc\x80\x9e\x05\x5d\x05\x7e\xb9\x55\x90\x1f\x61\xd4\xdb\x0d\x76\x0f\x07\x6e\xd5\xb9\xb2\x9b\x40\x55\xfa\x0c\x77\x5f\xff\xb8\x52\x0f\x8f\x68\xfc\xc3\x41\x93\xe6\x47\xa5\x14\xd9\xbf\x75\x15\xa8\x69\xd1\x62\xa1\x25\x57\x7d\x9b\xaa\x4d\x82\x3e\x48\x84\x3d\xaa\x25\xe9\x39\xd0\x19\x0b\x91\x0c\xab\x2a\x01\x21\xaa\x2b\xdd\x32\x4b\xa5\xa4\x62\xcc\x5f\x9e\x89\x6f\xc1\xb1\xaf\x18\xae\xca\x5b\xde\x96\x32\xd0\xf2\x00\xcc\x7c\x84\x6d\xbd\x60\xe2\xe5\xad\x2b\x4d\x12\xf9\xf5\x95\x94\x04\x9f\xec\xf6\x8d\x6c\x1e\xc6\x0d\xa8\x2e\x04\x75\x73\xdf\x93\x78\xc4\x26\xbf\x7b\xa4\xdc\xcc\x69\xfe\x33\x1d\x29\xa3\x0c\x1d\x67\xca\x12\x0d\x76\xbf\x7f\x58\xa8\x5b\x95\x6a\x50\xc3\xfb\x96\x6c\xd0\x24\x1b\xfc\x76\x6e\xff\x76\x6e\xdf\xec\xdc\xde\xfb\x42\x07\xf7\x32\x37\x3c\xdf\x91\xbd\xde\x69\xfd\x8b\x1f\xd4\x4b\x63\x27\x75\xdc\x9a\x35\x0e\xe5\x5f\xf8\x28\x8e\xfb\xe3\x1f\x68\x9e\x27\x7c\xa4\xd2\x04\x66\x6a\x75\xe3\x0a\x11\xbb\xd4\xd5\x3e\x95\x0b\x26\xdf\xa0\xcc\x40\x98\xb5\x41\xe5\x78\x79\x16\x44\x4d\xf6\x63\x9f\x75\x9a\xe2\x3c\x04\x59\x7d\x90\x81\x6f\xd7\x12\x85\x80\x40\xd4\xa4\x8d\xa5\x34\x84\xbc\x8a\xc9\xe9\x3b\x3b\xaf\xa2\x16\x81\xdf\x0c\x0d\xdf\x0c\x0d\xdf\x0c\x0d\xff\x52\x43\xc3\x3c\x4c\x33\xfe\x44\x66\x42\x7a\x79\x76\x14\xc5\xe7\x53\x6e\x89\x7c\x73\xf7\x59\x5d\x35\x30\xcf\x5c\x13\x3c\xf6\x50\xb5\x4b\xc5\x00\xfc\x91\x75\x04\xa1\x8d\x3a\xd6\xc1\xf0\x57\xe6\xf2\xed\xc0\x2e\xdc\x13\x52\xec\x96\x9d\xa3\x4b\xc2\x6f\xc3\x6f\x75\x44\x52\xe9\x9c\x48\xb9\xc9\xf0\x64\x27\x6e\x14\x33\x2d\xfe\x68\x7b\x5d\x33\xb0\xc8\x97\x08\x0f\x1e\x54\xf2\x38\x4f\x97\x85\x67\x32\xd2\xf3\xe3\x1e\x0b\x20\x6f\x8e\xd6\x86\x4d\x72\x1e\x68\xa7\x51\x02\x07\x0d\xfb\x13\xd0\xe6\xc0\xfd\xb8\xc7\x3a\x26\x21\x54\xc7\x98\x3b\x20\xca\x58\x49\x57\xba\x13\x67\x64\x34\xe3\x15\x4d\xbc\xd8\xc1\x44\x3e\xae\xe1\x49\x19\xb4\xd1\xfa\xd4\xdb\xc4\xfc\x74\x88\x47\xfb\x5a\x36\x28\xa8\x6b\x3d\x8e\x1a\xa6\xfc\x6c\xdf\x24\xf4\x02\x74\x84\xee\x03\xb6\xa0\x61\xca\x55\x7e\xb6\xd5\x46\x2b\x6d\x42\x17\xd5\x4d\x7e\xed\x29\x58\x65\x5c\x66\x6d\xa9\x57\x59\x32\x83\xe9\x94\xc7\xe2\x8c\x8c\x3e\x47\x9d\x7d\xfc\xeb\x07\x68\x8d\x3f\x40\xc1\x96\x7c\x01\x0f\xb1\x86\xf2\x38\x60\x38\x7a\xa8\xae\x94\xdd\x6c\xa3\x62\x18\xd4\xd2\x17\xc0\xf0\xc0\x8c\xb3\xca\xb0\x26\xc8\xe3\x1c\x30\x61\x9c\xeb\x1a\xd9\x90\x38\x4d\xd8\xd4\xa5\xb9\x4d\x80\x6e\xb1\x63\xd1\xd1\x40\x25\xd6\x82\x97\x5d\xcd\xa6\x9c\x00\xf5\x6f\x5b\x68\xb0\x5c\x1e\x8d\x19\xba\x03\x42\x42\x93\x3d\xe5\xf1\x8a\x2c\x8c\x95\x27\x61\x3c\x9e\xf2\xa7\xd2\x92\x65\xb8\x29\x4e\xc6\x10\xc9\xe9\x31\x58\x1c\x48\xe4\x06\x35\xf3\x93\x28\xfb\xbb\x32\xc7\x0d\xfd\xf6\x38\xcb\x82\xa3\xaa\xfd\x9d\x5a\xd3\x64\x59\xc1\xa8\xe6\x6f\x43\x8b\x8c\x1d\x8d\x8e\x03\x52\x83\xe1\x68\x03\x82\xbb\x10\x65\x16\x2e\x7b\x56\x37\x66\x59\x5b\x34\xf9\x18\xe5\xee\x39\x70\x45\x97\x84\x0e\x6d\x6a\x76\xa2\x1d\xf0\xd9\x5c\xcc\x54\x39\x2f\x91\xd5\x54\xc3\xa6\x2a\xd7\xb3\x65\x58\x2d\x20\x56\x62\x63\x2d\x0e\x00\x92\x29\xdb\x81\xff\x9c\x4f\x72\x5f\x89\x75\xba\xc2\xa7\xf1\x18\xa2\x6a\x2c\xa7\xbc\xed\x7c\x3e\xf0\x12\x8f\x41\xfe\xc6\x62\xf5\x80\x1a\xd1\xd8\x9e\x4c\xf5\xa9\x3f\x21\x6b\xf3\xfc\x48\x70\xb7\x9d\x1f\x2e\xc3\x04\x8f\xb4\x03\x1b\xf4\x9e\xf3\x9b\xf2\x9b\x59\x1d\xe8\x39\xae\xcd\x78\x4d\x4f\x08\x3d\xd5\x09\xd2\x19\xf6\xe1\x37\xd1\x8c\x27\x8b\xbc\x84\xc4\xb4\xca\x7a\xc6\xec\xc2\xe2\x59\x73\xdd\x14\x97\x4c\xc1\x34\x5d\xa8\x4d\xbf\x16\x0c\xd5\xab\xb4\x0e\x0b\xb3\x26\xbb\xb7\xb2\x81\xb5\x04\x6b\xd4\xf7\xad\xa8\xe2\xa4\x5c\xe3\x56\x41\x4c\x40\x4f\x4e\x84\xe6\x38\x33\x45\xbd\xf2\x0b\x07\xf7\x22\xa1\x57\x71\x93\xe0\x52\xbb\xb7\xe6\x5c\xf6\xd6\x9b\xcc\x9e\x35\x9b\xb4\xba\x96\xda\x65\xe7\x58\x09\xa0\xc5\x8e\x1b\x6a\x38\x90\x02\x8d\xa2\x2b\x3e\x50\x7c\xc4\x6f\xda\x61\x63\xd0\x2c\x64\x08\x5f\xfb\xa6\xc3\x73\x53\x60\x2d\x7c\x9c\x10\x67\xe1\x3f\x45\xeb\xb7\xbb\xbb\xb5\xec\x4a\x1f\xa3\xdc\xae\xf3\x31\xb2\xee\x23\x72\x5c\xb3\xb2\x8e\xbd\x8c\x89\x90\x30\x4d\x88\x95\x54\xe3\x0f\xb2\xea\xa6\x2e\x50\x4a\xae\x4d\x90\x7b\x71\xd3\x77\x4a\x9c\xdb\x9e\x24\x9e\x2e\xf5\x75\x4f\xb3\xe4\xf6\x62\xad\xcb\x0b\x00\x7d\x9d\x1b\x0c\x7d\x1d\x53\xe3\x22\xa3\x66\x5d\xfb\x9a\xa7\xba\x6e\xf5\xad\x86\xbc\x9b\xd0\x97\x08\xbd\x95\xb7\x08\x92\x0e\xee\x55\x42\xe5\xf3\x73\x63\xfd\x92\xb0\x87\xc3\xba\xd7\x0a\x3b\x77\xd9\x24\x4c\x67\x49\xbc\x64\xd1\x0c\x5c\x43\xef\xee\xa0\xbc\x1a\xfe\xf1\xf4\xa7\x57\x8f\x0f\xff\x63\xf8\xec\xf9\xab\x97\xaf\xdf\x3c\x7d\x32\x7c\xfe\xf2\xc9\xef\xbf\x3d\x1d\x76\x86\xd3\x64\x1c\x66\x93\xa1\xf4\x36\x87\x53\x68\x69\x42\xcd\x1b\xe9\x60\x68\x68\xe5\xe9\xa8\x1d\x07\xeb\x00\xbb\x1e\x52\x5d\xe4\xcb\xf2\xc1\x6e\x08\x76\x83\x21\x6a\x18\xd7\x43\xa1\x07\x8c\x3b\x14\x67\x87\xac\x74\x78\x9d\x9b\x80\xbd\xc1\x18\x6d\x40\xd7\x43\x66\x77\x08\xa9\x8a\x87\xaf\x16\x29\x7f\x0d\xbb\x77\xf9\x6c\x3e\xb8\x5e\x17\xf7\x65\x17\x4f\xc2\x3c\xfc\x3d\x8f\xa6\xe5\x04\x85\xcc\x5f\x0c\xdc\x7c\x6b\xfe\x77\x97\xfd\xdb\x59\x34\xe5\x2f\xdf\xf3\xf4\x7d\xc4\x3f\x30\x69\x8d\x66\x6f\x92\x64\x9a\x47\x73\x76\x98\xc4\x39\x44\x82\xaa\x0b\x6f\xe7\xdb\x7d\xdd\xb7\xfb\xba\x6f\xf7\x75\x9b\xdf\xd7\xc1\xbf\x3d\xe3\x70\xfb\xed\x02\xe4\xdb\x05\xc8\xb7\x0b\x90\x7f\xd1\x05\x08\xfc\x87\xf2\x15\xf6\xc7\x9f\x93\x74\x16\xe6\x8e\x4d\xd2\x2d\xf3\x04\xee\xb9\x8e\x7e\x1a\x34\x15\xa0\xad\x2d\xf5\x22\x7c\x2d\x65\xe1\xf8\x0e\xbf\xc3\x76\xee\x32\xb0\xff\xbf\x4c\x8f\xf2\x94\xdd\xdd\x19\x48\xa8\xc7\x9d\xc1\x67\x02\xdc\x1d\x88\x95\x03\x7f\xb7\xdf\x25\x51\x1c\x34\xd8\xff\xc3\x20\x46\xae\x0c\x8b\xa2\x36\x4a\xa9\x73\x48\x95\x43\x6a\x1c\x26\xcf\xca\x7a\xba\xd7\xf1\x9d\x10\x70\x52\x5a\x21\x20\xa4\x6f\x23\x1c\xf7\xd8\x5e\xcd\x0b\x0a\x2f\x86\x15\x97\x14\xde\xfa\x2b\x3c\x66\xbd\x6d\xd6\x76\x9d\xf5\x42\xa9\x63\xde\xf7\x77\xbf\xa6\x33\x6d\x09\x9d\x3c\x5e\xb5\xb2\xac\xd2\x0c\xe6\xd2\xad\x96\x59\x72\x1e\x2e\xa7\x49\x38\x36\x36\x43\xf9\x81\xd6\xc9\xf8\x3c\x4c\x43\xd4\x91\x64\x2d\xfd\x89\xd6\x3b\x23\xab\x5c\xd6\xd3\x9f\x2c\x13\x6d\xce\x67\x60\xa5\x36\xf5\xf4\xa7\x42\xbd\x24\xb5\x00\x9a\x6f\xc6\xa0\x09\x6a\x8a\x1c\xc7\xd6\x96\x1a\x92\x73\x07\xa9\xe8\x31\x8d\xb2\x5c\x75\xfe\x89\xcd\xc3\xf1\x38\x8a\xcf\xf7\x58\xa7\xc5\x66\x61\x7a\x1e\xc5\x7b\xac\x03\x2a\x29\x6d\x23\x3a\x85\x47\xa3\x12\x72\x96\xa4\x79\x60\x30\x69\x82\xe3\xad\x59\x18\x70\xd1\xd8\x62\x91\x6d\x29\x82\x64\xf1\x51\x1c\x4e\x9f\xd1\xe1\x6b\xf3\x97\x75\x64\x18\x47\xd9\x7c\x1a\x8a\xe9\x3f\x9d\x26\xa3\x8b\x86\x6d\x08\x92\x48\xbf\x49\xe6\x7b\xec\xbe\xb7\xe8\xa7\x24\xcf\x93\x59\xa1\x74\x94\x4c\xc5\x36\x83\x17\xa1\xf0\x43\x30\x78\xe3\x6f\x9d\x4e\xa7\x41\x2a\x5e\xb5\xcc\x14\x11\x5b\x12\x0e\x61\x12\x66\x32\x4a\xfc\x4d\x8a\x40\x44\x29\x0e\x67\xc5\x0e\x81\x66\x74\x03\xc1\xba\x86\xd9\x84\xfa\x4d\x7f\xb8\xfb\x0a\x99\xcc\x1a\x1b\x4b\xc1\x18\xd0\x0e\xab\xac\x79\x8d\x69\xe4\xcc\xce\x27\xd4\xfd\x04\x91\x60\xf9\x8e\x26\x61\x9a\x67\xdb\x39\x2e\xf2\x6d\x41\xd9\x46\x4b\x2e\x6e\xfa\x11\x3d\x95\xe5\xed\xc7\x9e\xcb\x2a\x8e\xc3\xb2\x9a\x85\x83\x9b\x1b\x09\x93\xce\xb6\xae\x33\x75\x8d\xf1\x6c\x8b\x89\x6b\xb8\x38\x32\x66\x66\xd5\x2a\x68\xca\xdb\xa0\xaf\x7a\x48\x5a\xc2\x79\xc6\xa5\xcb\x6a\x0c\xeb\xab\x18\x0c\x6c\x18\x9e\x81\x38\x6b\xeb\xc0\xf9\x20\x97\xa5\x8c\x8c\x66\x66\x53\xfe\x0d\x22\x4e\x89\x13\xa8\x64\xd3\xe3\x2b\x24\xc4\x22\x8e\xf2\x52\x46\x15\x85\x20\x10\x1b\xf6\x38\xca\x1e\x06\x10\xc1\x72\xb3\x62\xa5\xb1\x98\x5a\xa3\xab\x33\x32\xb1\xaf\x35\xb4\xf4\x30\xbb\xdc\x95\xbb\xa3\x66\xb7\x0a\x83\xb9\x72\x6e\x76\xf0\xaa\x96\xdd\xd8\x85\xdc\x8a\x6b\xb7\x69\x78\xca\xa7\xb6\x42\xd0\x6b\x9b\x8f\x85\xaa\x6e\xad\x42\x85\x9f\x0b\x8a\x88\xac\xf9\xb3\x4f\x1d\xf9\x90\x86\xf3\x39\x4f\x5d\x04\xe8\x67\xeb\x16\x11\xd6\x48\xc5\x06\xae\xf5\x08\x92\x97\x5c\xa9\x19\x5d\xf2\xf1\x34\x1c\x5d\x9c\xa7\xc9\x22\x1e\x1f\xe2\xbe\xdc\xf8\xdb\xd9\xd9\x19\x99\xf8\xd3\x24\x1d\x73\xf1\xbd\x3b\xff\xc8\xb2\x64\x1a\x8d\xd9\xdf\x46\xa3\x11\xa9\xf1\x61\x12\xe5\xfc\x68\x1e\x8e\x04\x5f\xc4\x89\x40\x59\xf1\xee\x55\xcb\x1a\x98\x9e\x6b\x3d\x82\xdf\x2c\xaa\x57\x0c\xc3\x00\x34\x73\x62\x81\x9b\x84\xd9\x6f\x72\x5e\x6e\x52\x27\x80\xde\x4a\xf0\xc6\x50\x39\xf8\xe7\x81\xe4\x0a\x8c\xa8\x48\x74\x42\x5d\x63\x6b\xcb\xe1\x0b\xaa\x99\x59\x40\xed\x6a\x0e\x0a\xee\x32\xb9\x91\xd5\xde\x18\x47\xef\x1b\xd6\xa3\x2f\xdf\x52\x97\x60\xd4\x92\x6f\xd8\x6a\x42\x61\xa5\xdf\x94\x1c\x9a\xaf\x23\x86\x80\x58\x0e\x66\x84\xc9\x2c\x41\x64\x0a\x8d\x34\x6a\xd9\xbe\x21\xce\xa1\x66\xe5\x45\xa6\xf7\x30\x05\x97\x99\xab\x89\x71\x7c\x47\x1f\x4d\xef\x0c\xf4\x65\x67\xaf\x2d\xf5\x70\xa9\xf0\x36\xbc\x5d\x34\x4c\x75\xf7\x72\x54\xeb\x09\x7b\x6b\x5f\xcf\xb4\xc3\x36\x06\x05\x11\x54\xd1\xea\xed\xb5\xe0\x40\x04\xf7\x5b\xb6\x9c\xbb\x16\x20\x73\xe1\xaa\x8f\x07\x1b\xc2\x31\x02\xe5\x26\x00\xfd\x7c\x23\x64\x02\x50\xd7\x82\x10\xc6\xcb\xd6\x2d\x7d\xa4\xbe\x1e\x88\x34\x0d\x97\x2f\xcf\x6a\x5f\xc2\x51\x76\x99\x84\x73\x2e\xe5\x77\x0c\x4b\xf4\xfa\x43\xd0\x1b\xfb\x75\x26\x85\x3c\x22\x5c\xbf\xb5\xca\x32\x75\xfd\xf5\x72\x6d\xb2\x0f\xa4\x04\x12\x6a\xe0\x75\x89\x07\xb9\x80\x9a\x7a\x89\x80\x79\xe0\xda\xdc\x68\x5e\x49\xf6\x7c\xcf\x24\x89\x74\x69\x88\xcd\xcf\x59\x98\x9f\xae\xdc\x15\xf6\xe9\xca\x3c\xa4\x84\xb8\x74\x08\x1c\x1c\x1d\xf4\x2d\xab\x32\x04\xa2\x17\x03\xbb\xbb\xe3\xf3\x6c\x38\xbe\x13\xde\x19\xb0\x7e\x89\xfd\xac\x59\x74\x9d\xa8\x0c\x94\xfe\x2f\x72\x9d\x18\xf3\xd3\x64\x11\x8f\x78\xe9\xf5\xf0\x83\xde\x86\xbe\x13\xa6\x87\x9b\x70\x9e\x30\xd0\xbe\x79\x4f\xfc\xaf\xf5\x9e\x80\x15\x0b\xa9\x1e\x4b\x07\x7a\x4d\xae\xb5\x61\x6f\x30\x50\x1b\xd0\x75\x7d\x38\x90\x21\x52\x9e\x45\x7f\xf2\xe1\x98\xe7\x7c\x94\x27\xe5\xbe\x22\x8f\x76\xaf\xe9\xe7\x54\xda\xd1\x06\x04\x28\x85\x79\x3d\x14\x1f\xac\xe7\xcf\x72\x8d\x1e\x1e\xca\x1e\x7e\x4b\xce\xab\x3b\xd8\x7d\x00\xaf\x5d\xbf\xf9\x6b\x7c\xf3\xd7\xb8\xa1\xb8\x68\xdf\xdc\x34\xbe\xb9\x69\x7c\x73\xd3\xf8\x17\xb9\x69\xc8\x00\xa7\xb6\x4b\xe3\x1f\x68\x26\x20\x11\x87\x20\x41\xf3\x05\x67\x68\xef\x61\xe1\x38\x9c\xe7\x2a\xbf\x25\xe4\x50\x4d\xce\xd8\x3c\x4c\x45\xd5\xbb\xec\xc9\xcb\xe7\x10\x66\xf4\x16\xf1\x02\x79\xcd\xb3\x79\x12\x67\xd1\x7b\xb1\x82\xf2\x30\x8a\xc1\x32\x7b\xbd\xd8\x5b\x1e\x58\x15\x9e\x05\x9e\xda\x81\xda\x79\x2a\x9c\x0b\x3c\xcd\x9a\xd6\x3b\xc9\xba\x2f\x08\x3d\x80\xea\x78\x17\xf8\xfa\xc7\xe7\x83\x12\x30\x8e\x41\xe1\x84\xef\xd4\x16\xf3\x71\x98\xf3\x27\xd1\x8c\xc7\x62\xf5\x64\xcf\x66\x33\x3e\x8e\xf0\xed\xa0\xef\xe1\x16\x48\x2b\x6c\x3a\x4b\x16\x71\xce\xc7\xd4\x2c\x8a\x52\xa6\x60\xfa\x14\xc3\x8f\xf9\x87\x23\x99\x11\x19\x5a\x9f\xf3\x5c\xa3\x29\x0a\x82\xa6\x65\x86\x95\xd5\xdd\x8b\x78\x7c\x09\xa8\x1e\x37\x92\xa7\x8e\xf6\xe5\x4c\x32\x1d\xff\x11\x8d\x31\x5b\x81\x69\x21\xb6\x6b\xec\x10\x0a\x0b\x4d\x7e\xe5\xd1\xf9\x24\x2f\x6b\x83\xa5\xfb\x16\x3a\x36\x40\xcc\x7f\x27\xd0\xae\xec\xc9\x81\xe8\x6b\xa5\xfa\x32\x77\x45\x90\x1b\xd0\xee\x4d\x88\x46\x3d\xd0\xcb\xcb\x02\x5c\x59\x8e\xbf\x6c\xb7\x82\xa1\xfd\x90\xee\x93\x33\x90\x3d\xe7\x77\xcb\x85\xbd\x57\xe8\xec\xca\xf3\x7e\x44\xbe\x99\xb3\xf8\xcd\x7d\x97\xea\x76\x6c\xd2\x13\x14\xba\xdc\xee\x7a\xe0\xe1\xc3\x9d\xd7\x1c\xd3\x32\x4b\x1d\x50\x1d\x7a\xe5\x1b\xee\x6b\x1d\xba\x83\x66\xb0\x62\x85\xb4\x9c\xde\x84\x00\x5d\xd1\xc4\xca\xa5\x38\xc4\xa7\x66\x72\x9d\xec\xdc\x65\x3c\x9b\x46\x71\xbe\x3d\x8e\x32\x50\x0c\x19\x1c\x08\x76\xe2\x64\x7b\x1c\x8d\xb7\x61\xb5\x6d\x67\x3c\xdf\x46\x12\x82\xb4\x74\x5c\x83\xbc\x62\xce\x72\x0c\xd2\xf2\xf9\x49\x34\x7e\x2e\x20\x96\x5c\xc9\x15\xea\x11\x11\x40\x17\xbf\xd2\x5e\xe9\x4a\x97\x53\x51\x67\x95\x67\xce\x12\xb7\xd9\x12\x4a\x57\x3e\xc0\xd4\xa8\xfe\x11\x4d\xa7\xbf\xc7\xb3\x3a\xa3\x22\x55\xcb\x07\x26\x53\x5f\x94\x74\xeb\x8e\xac\xa4\xcb\x22\x01\x6c\x51\x0a\x7d\x6a\x56\x2f\xca\x52\x72\xad\x5a\xbc\x4b\x32\x95\xdd\x65\x64\x83\x6d\x8f\xa6\x11\x8c\xda\x92\x45\x85\x05\xe6\x6d\x84\x85\x0a\x81\x15\x17\xbc\x87\x62\xb3\xaf\xf6\x37\x13\x35\xdc\xab\x5e\x25\x14\xfc\xe2\xbc\x20\x64\x87\xab\xa4\x79\x51\xc2\xba\x4d\x5c\x01\xeb\x11\xaf\x3f\xb0\x8e\x4f\xaa\xfe\xc0\x3a\x75\x67\xa9\xce\x03\xdf\x6c\x2e\x93\x6b\xc9\x97\xbd\xf0\xdb\xba\x68\x56\x83\xc6\x0a\x1f\xdc\xb1\x4e\xf4\x10\xb1\x02\xfe\xa6\x35\x66\x51\xfc\x87\x0d\x44\x7d\x71\x6a\xfd\xea\x80\xd2\x9f\xac\x7a\xe1\xc7\x42\x3d\xf5\xa9\x5e\x7c\x4d\x43\xf5\x95\x17\xbf\x45\x1b\x83\x72\x3d\xfd\x10\xa6\x31\xde\xf8\xae\x04\xe2\x31\x85\x1c\xdf\x39\x97\xb7\xc7\xaf\x78\x3a\x02\x1d\x54\x80\x02\xe2\x36\x8d\x86\x75\x23\x40\x71\x42\x9a\x2d\xd6\x78\x33\xe1\x38\x9d\xc1\xff\xc9\x9a\x90\xae\x12\xcb\xf0\x67\xca\xd9\x69\x92\x4f\xd8\x59\xf4\x91\x8f\x19\x5e\x69\x64\xad\xb7\xb1\xa6\xfb\xf2\x94\xb3\x65\xb2\x60\xe3\x24\x7e\xdb\xc8\x59\xcc\x31\x29\xe6\x22\xe3\x2c\xf4\x29\x9f\xed\x46\x0b\xbb\x6b\xc9\x7e\x8c\xec\xbd\x11\xc2\xdf\x96\xcc\x7b\x79\xa9\xd8\xf8\x47\xd6\x91\xc3\xc4\x0f\x30\x30\x38\x8f\x9d\x72\x76\x0e\x1b\x55\xca\xf2\x49\x18\xb3\x3f\x79\x9a\x08\xfc\xb0\x5e\xd3\xda\x3f\x46\xe1\x74\xb4\x98\x86\x39\xd7\x3a\xdc\xcd\x4f\xf1\x81\x2b\x55\xf6\x90\x54\xfb\x5e\x3c\x34\xc3\xdf\x3c\x5b\x50\x4c\x64\x37\x7b\x72\xba\xac\x9d\x52\x52\x78\x6b\x8b\xd0\x9a\xca\xa1\x9d\x1d\xf6\x4a\x66\x00\x86\x23\xd6\x98\x67\x51\x0a\x69\x58\xa1\x36\xbc\xa7\x37\x92\xbf\x38\x32\x97\xe8\x3b\xb2\xe5\x3e\xed\x21\x3a\x23\xcb\x3f\xca\x58\xc6\xf3\x16\x4b\xde\xf3\x54\x1c\x5b\xb9\x28\x2e\x40\x8e\x32\x7b\xe2\x75\x7b\x4b\xb3\x35\x50\xb7\xb6\x8a\x30\x7e\x34\xad\x6c\x35\xd6\x33\x0e\x5d\xd3\xa7\x8e\xde\x24\xf7\xbb\x04\xfb\x51\x6e\x17\x45\xe4\x3b\xab\x96\x7e\x72\x86\xa7\x64\x96\x4d\x92\xc5\x74\x5c\x58\x2c\x1d\x23\x05\xe6\x53\x1e\x66\x5c\x66\x1e\xc3\x14\xad\xcb\x29\x9c\xa5\x47\x46\xe3\x4b\x52\x9d\x02\x24\x2b\xed\xd5\xc0\x4c\x52\x16\x8e\xc7\x2c\xd4\x1b\x05\x22\x95\x9a\x2d\x41\x7d\x00\x51\x63\x56\x36\x66\xe4\xcd\xd3\x64\x2a\xfa\xd3\xf0\xe4\x8e\x24\xba\x83\xce\xc5\x3a\x77\xa8\xd5\x2a\xd0\xc9\x11\x55\x2d\x8d\x4c\xcb\xa0\x51\x14\x17\xd7\xf3\xa9\x99\x26\xb1\x76\x5c\x31\x91\x8f\x0d\x63\x7d\x90\x67\x20\x07\xe7\x5b\xf6\x96\xbb\x57\x18\x83\xe2\xb3\xaf\x23\x2e\x45\x61\xdb\xef\xd5\xdc\xf7\x7b\xfe\x8d\xff\x83\x03\x6c\x95\x26\xd2\xf3\xa9\x22\x05\xe5\xa1\xe7\xd7\x1e\xa2\x31\xa9\x11\x59\x0f\x0b\xb4\x3b\x11\x0d\xb8\xa1\xbe\xd9\x07\x11\xed\xb1\x2f\x67\xd4\x62\xb1\xbd\x02\xab\xed\xf9\x98\x6e\x8f\xf2\x9f\xc6\x75\x8f\x0c\xe5\x6a\x43\x76\xac\xe7\xe2\x65\x11\x67\x8f\x95\xd0\xa4\xca\x6d\xc0\x7f\x57\x17\x34\x03\xe3\x95\x95\x6a\x2d\x62\x5b\xcb\x13\xb1\x7a\x15\x78\xcb\x3b\x57\xba\x6c\x65\xae\xbb\x65\xca\xcf\x2c\xae\x3e\x83\x38\x52\x4d\x27\xb6\xb7\x0c\x59\x31\x22\xb6\x3d\x51\x8d\x3a\xf2\x5f\x19\x11\xee\x77\xf3\xc2\xb3\xc4\xcd\x78\xb0\x6d\x70\xdb\xd7\x0e\x5b\xec\x93\x0c\xa4\xa4\xce\x5f\x60\xbd\xc5\x4f\xfa\x78\x05\xdf\x92\x18\x8d\x15\x56\xe0\x11\x69\xbf\xa8\x11\x36\xdc\xa3\xe7\x6d\xe4\xae\xe6\x7a\xab\x79\xe0\x37\xca\xe3\x78\x80\x38\xbe\x96\xab\x8a\x74\xd9\xb9\xa5\xa5\xed\x17\x77\x1a\xda\xc0\xf3\x07\x91\x47\xd7\x1f\x25\x4c\xfe\xaa\xf8\x13\x41\xf7\x17\x1e\xc2\x1f\x7f\x6d\x26\x22\xfb\xca\x5f\x75\x08\x24\x9c\xce\x35\x00\x25\x63\xde\x8e\x32\x19\xad\x19\xb6\x36\x65\x55\xdd\x50\xba\x44\xd7\x73\xa9\xfc\x3a\x48\x5a\x67\x57\xff\x7a\x87\x50\x9d\xaf\x41\x8a\xfd\x46\xb7\xd3\xf9\x3f\x0d\x2a\x48\xcd\x17\xc3\x02\x1d\x9a\xcc\x61\x03\xcf\xc3\x92\x2b\x3a\xc7\xef\xf0\xd1\xd7\x98\xfd\x01\x55\x84\x27\x52\xf9\x28\xf5\x68\xfa\xbe\xa4\x41\x55\x00\x75\xbb\xe6\x17\x89\xa3\x5e\x0c\xa5\xe5\xe2\xab\x8a\x8a\xd3\x53\x27\x41\xfe\x17\x9f\x9e\x6f\xa1\x78\x86\xd9\x34\x1a\xf1\xf1\x9b\x44\xe5\x9d\x2f\x71\xee\x82\x6a\xcf\x72\x0e\x5e\xc8\x41\x98\xa6\xf8\xe8\x19\xcf\xb4\x61\x2a\x58\xfb\x78\xb0\x8f\x3f\x63\xed\x1d\x05\x3f\xcd\xad\x0c\xfe\x16\xf4\xd0\xa1\xaa\xf7\x59\x9e\x2e\x29\x69\x87\x11\x90\x2b\x3d\x3e\x5a\xce\x4e\x93\x69\x3b\x92\x7d\x0e\x02\xa1\xfd\x66\xfb\xec\x76\x00\x1d\x04\x43\xb8\x96\x8f\xda\x31\xff\x98\x07\xcd\x66\x7b\x9c\xc4\xbc\xb9\x6f\x7a\x17\xd8\x09\xcc\xda\xf3\x45\x36\x09\x86\x19\x3e\x5b\x94\x4e\x18\x91\x60\x7d\x28\x55\x69\xc3\xfb\x7d\x31\x20\xcc\x56\x0e\x04\x1b\x85\xf9\x68\xc2\x02\x9e\x82\x2b\xd2\x50\x5f\x9a\xe1\x00\x78\x9a\x8a\x6a\xf0\xb8\x65\x2a\x06\x80\xc3\xc0\x8b\xf6\x18\xa0\x47\xc7\x77\x90\xe8\x77\x06\x4d\xeb\x57\xd0\xb4\x9b\x8a\x46\xc3\x71\x53\x7a\xca\x0c\xb9\xe5\x1a\x26\x90\xdc\xf7\x79\x8a\x99\x39\x10\xed\x61\xfa\xda\x2a\x21\x79\x98\xa2\x5b\x94\x6c\x24\x41\x40\xc2\x7a\x51\xd9\x21\xad\x60\x41\x69\x5d\x73\x1a\x7a\x67\x5d\x83\x2a\xf1\xed\x79\x16\xbf\x0f\xa7\xd1\x98\x85\xb9\x10\xfd\xe0\x3e\x32\xe6\xe8\x33\xb1\x48\x39\x8b\x93\x78\x1b\x7a\x3e\x9d\x1a\x97\x2e\xe9\x89\x65\xbb\x8f\x7d\x73\x3a\xfc\xe6\x74\xb8\xb6\xd3\xe1\x67\xc9\xdf\xf2\xd9\x53\xab\xa4\xd6\x36\x0a\x8f\x38\xca\xfa\x7a\x74\xbf\xf3\x2d\x7f\xe9\x37\x77\xcd\x6f\xee\x9a\xff\x37\xbb\x6b\x4a\x57\x4a\xfb\xec\x50\xd3\x67\x92\x34\xaa\x76\x97\x24\x15\x57\x44\x60\x2a\x9e\x35\xd8\x75\xfc\x23\x09\x8c\x9a\xae\x91\xb4\x57\xe2\x15\xe9\xb8\x43\xba\xee\x69\xfc\xe3\x3c\x8c\xc7\x10\xda\x57\x19\x68\xf4\x63\x7c\x52\x26\xcd\x4f\x4e\xd1\xd1\x28\x4d\xa6\xd3\xdf\xf8\x59\xb1\x15\x16\x41\x30\x1e\x5d\x92\x4d\xd2\x28\xbe\x58\x55\xe2\x80\x9b\x86\x59\xee\xf6\x2e\xbe\x69\x6c\x3d\x3e\x73\x29\xcf\xb8\x76\x73\xc4\x5f\xed\xd3\x28\x1e\xff\xff\xec\xfd\x7b\x97\x1b\xc9\x71\x20\x8a\xff\xcd\x3e\x67\xbe\x43\x10\xbf\x15\x51\xd5\x28\x00\x55\xe8\x37\x9a\x20\x3d\xe2\x70\x24\xfe\xa4\x99\xe1\x1d\x8e\x5e\x8b\x69\x37\x0b\x40\x02\x28\x36\x50\x85\xa9\x2a\x74\xa3\x39\xec\x7b\xb4\x5e\xc9\x6b\xef\xca\x2b\x9d\xb5\xe5\x87\xec\x6b\xdf\xdd\xb5\xd7\x7b\xbc\x6b\x49\xbb\xf6\xda\x1a\x59\xb2\xbe\xcb\x9e\x21\x67\xf4\x97\xbf\xc2\x3d\x19\xf9\xae\x07\x1a\xdd\x6c\xf2\x52\xbe\xd3\x73\x86\xa8\xca\xca\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x64\x0e\x6f\xdc\xf6\x6c\x5c\x6f\x80\x35\xcb\x12\x7a\x62\xbe\x60\xa1\x77\x5b\xd6\x4d\xcd\xe0\xac\x62\x0f\xb5\xaf\x05\x93\xc9\x4a\x2e\x6a\x32\x63\xd6\x95\x6b\x18\xc5\x7d\xf2\x15\xf4\xc5\xb3\xca\xf7\xe4\xae\xc2\x25\x8e\x69\x99\xba\x9f\x97\xd8\x96\xeb\x9b\xce\x5f\xfa\x3e\x89\x59\x00\x67\x79\x63\x09\x65\x99\x19\x1c\x68\xd9\x85\xfb\x71\x26\x98\xae\x7b\x50\xbc\x29\x97\xc9\xe6\x1d\xc8\x6d\x2b\xc5\x06\x56\xd6\x5f\x44\xcb\xc0\x34\x5d\xb1\x7d\x51\x98\xb3\x80\xba\x6c\x4b\x5b\x8a\x0e\xd6\x1b\x25\x14\x2e\xcc\x6b\xd1\x55\x19\x57\x22\xe9\x63\x26\x9c\xba\x58\x8c\x4a\x0c\xd9\x14\x24\xca\xe0\xfc\xa8\x06\xb6\xf8\x86\x40\x56\xe2\x88\xa5\x08\xe7\x33\x66\x59\x90\x8d\xf6\x46\x22\x87\xae\xe0\x0b\xe3\xc3\xd7\x74\xd7\x93\xfc\xe7\xf7\xa2\x59\x61\xb1\x2f\x9a\x6e\x22\xac\x9d\x28\x2a\x0a\x2a\x34\x3e\xe4\x2b\x34\x3e\x6b\x15\x1a\xe9\xba\x67\x45\x21\xdd\xce\xf7\x87\xec\x97\x38\x43\xf2\x7e\xec\x6a\xac\xa6\x6d\xa8\xd1\x69\x3b\xe3\x9d\xc8\xce\x0e\xf0\xdd\xbb\x46\x34\x1c\x26\x84\x3b\x38\x42\x0e\x86\xf2\x2d\x59\x01\x08\xcb\x7c\xb0\x64\x0f\x3f\x21\xe5\x3e\x8e\x74\x10\x9d\xe3\x3c\x6d\x7a\x80\x72\xa5\xe6\x24\x08\x07\xd1\x09\xea\x6f\x55\x69\xd2\xa8\xae\xe8\x5b\xcf\xcf\x51\x64\x45\x8e\xd9\x3c\x63\x6b\x7c\x16\xc9\x1b\xc5\xaa\x6c\x5d\x54\xdd\xd7\x90\x62\x05\x1b\xfd\x79\x4c\x7f\x1f\x64\x6f\x7f\xd1\x4a\x17\xe4\x6c\x88\xcf\x12\x57\x65\x2f\x60\xcd\x64\x6e\xc1\xd3\xd9\x3c\x25\x83\x65\xc0\x4b\x72\x73\xf4\xec\x7c\x45\x7a\x13\x24\x98\x8e\x6a\xa3\x51\x0f\xc3\x3c\x31\x50\xa6\xf4\x88\xc9\xc4\xc7\x0b\x73\x72\xb4\xce\x78\xcd\x4b\x50\x05\x5a\x82\x3e\x5a\x75\xbe\x82\x9a\x11\xce\x27\xaf\x43\xe4\x0b\xb2\x11\x60\x96\xd3\xa6\xfd\x32\x37\x58\x5d\x0b\xc8\x70\xe0\xf9\x8e\x2a\xfa\x14\xbf\xfc\xe2\x20\xcc\x62\x91\xab\x65\x6a\xd2\x98\xc5\xe4\x98\x0a\x56\xe1\xa4\xb0\x2f\xbf\x24\x69\x34\xa3\xb2\xdd\x1f\xe1\x1d\x31\x96\x9d\xf1\xf9\xc8\xba\x12\x9b\x4e\x33\x86\xfc\xd9\xb8\xf0\x2c\xbd\x79\xde\x2c\xbd\xb1\xda\x34\xbd\xb9\xda\x34\xbd\xa9\x4f\xd3\x6c\xfc\x88\x93\x1f\xcc\xa1\x59\xf2\x01\x9d\xe8\xc6\xea\xdc\x87\xfa\x9a\xf7\x9b\x5b\x75\x36\xcf\x32\x7e\xb9\x86\xf0\x82\x3d\x9d\x0a\xfb\x54\xfb\xce\x55\xea\x5c\x54\xaa\x33\xa7\xd8\x1c\xd2\xd0\x46\xdd\x83\xec\xb5\x51\x7c\x5f\x8a\x11\x30\x3b\x3c\xf3\x3e\x60\xb9\x7c\xb9\x11\x96\xf1\x0d\x5a\xed\xce\x97\x5c\x80\x27\xee\x6c\x53\xdc\x1e\x26\xca\x78\x53\xf2\xee\x37\xab\xf8\xde\x98\x8e\x37\x46\x58\xa8\x55\x6f\xa9\xc9\xe0\x7c\x31\xac\xa3\x90\x49\x12\xc3\x2d\x86\x25\xad\xd4\x24\xd9\x28\xd6\x15\xd9\x16\x65\xda\x74\x5e\xab\x58\x53\x54\x03\x74\x0e\x3b\x53\xa1\xfd\xec\x5f\x59\x2a\x31\xb5\xee\x8a\xa9\x54\xdc\x00\x56\x95\x1a\x6c\x06\x01\x57\xf1\x77\xd2\x40\x16\x5e\x33\xb4\x5f\xb4\x9d\x98\x2d\xb7\xb6\x96\xb1\x1a\x64\x7d\x99\x0c\xf7\xad\xa2\x1b\x81\x7a\x51\x84\x41\x03\x4d\xa7\xae\x65\x39\x95\xab\x57\x51\x2e\x16\xac\x67\x3f\x87\x58\xc1\x5e\xb9\x81\x1b\x33\x3d\xe5\x10\x91\xc9\xaa\x56\xc9\x0b\x52\xcc\x93\xcc\x15\xa4\x84\x2d\xd0\xcf\x72\x9b\xac\x9b\xee\xab\xb5\xc9\xaa\xb4\x5c\x21\xe6\x45\x97\x9b\xa9\xb4\xac\xd0\xe5\xda\x50\xf5\x7b\x49\x34\x99\xf3\xf5\xdb\x44\x59\x4e\x52\x69\x5e\x89\x35\xa3\x4e\x8f\x07\x40\xc6\x97\xe8\x98\xc4\xc3\x49\x74\x42\x95\xa1\x60\x30\x20\x2c\x74\xe8\xe3\x7b\xe1\x80\x2c\xc4\x31\xc5\xe3\x20\x09\x7a\xc1\x24\x48\x4f\x55\x2e\x19\x71\x3d\xc7\xf7\x0a\xe7\x82\x4f\x17\x46\x5c\xf8\x4f\xb4\x72\xfe\x13\x98\x22\xd1\xc8\xce\x75\x1a\x1a\x05\x9f\x2e\x8d\x46\x89\x1b\x47\x11\x6b\x79\xcf\xc5\x5a\xfc\xf8\x39\xdf\x77\x18\x90\x19\xd5\x25\xc2\x7e\x40\x12\x3c\x41\x4e\x9b\xdc\xf3\x27\x7e\xd8\xc7\x33\x7c\xc5\xdb\x1e\x2d\x1b\xf3\xb1\x4b\x85\xdf\xe4\x28\xdc\xf1\x99\x89\xab\xb0\xc4\x06\x2b\x31\x25\x8b\x59\x69\x9e\x2d\x5b\x62\x87\xa6\x4b\x3f\x4c\x35\xa4\xde\x7a\xfd\xeb\x87\x0f\xde\x7b\xfd\xce\x97\xa0\x03\x9e\xeb\x42\xb3\xa9\xb9\xfb\x93\x30\x9a\x8f\xc6\xb8\xc1\xe8\x43\x82\x77\x1e\xa2\x77\xb9\x65\x37\x1a\x0d\x2c\xfe\xf6\xdd\x07\xef\xdd\x7d\xe3\xf0\xce\xeb\x5f\xbe\x73\xf8\xee\x5d\xe8\x40\xd3\x7a\xbf\xf6\xe4\xfd\xfa\x93\xf7\xd7\x9f\xbc\xff\xfe\x93\xee\xaf\xfb\xf5\xc7\x07\x4f\x6c\xeb\xfd\x64\xdd\xb6\xde\xb7\xec\xe6\x48\x22\xf3\x85\x49\xd4\xf3\x27\x54\x53\x0a\xfc\xde\x44\x43\x29\x49\xfd\xfe\x91\xcc\x76\x77\x31\x8b\x12\xc2\x89\x72\xe7\xc1\x83\x3b\xfe\xa4\x0f\xb3\xc9\x7c\x14\x84\x6b\xc0\x8e\xfc\xa3\x71\xfd\x43\x41\xb0\x33\x04\xc4\x3a\xae\xc1\xfb\x0d\x3a\x26\x00\x09\xfd\x5d\x4c\x85\x3b\x0f\x1e\xf0\x86\x41\x10\xd2\xb6\x72\x37\xa3\x93\x31\x09\xc9\x31\x89\x21\x48\xab\x09\x08\x0b\xb0\xa8\x77\xe6\xc7\xfe\x14\x3e\x7c\x80\x99\xcf\x98\x70\x80\x7e\x92\x40\x10\xce\xe6\x29\xa2\xa1\xcd\x7b\x5a\xf5\x16\x8f\x42\x3c\x20\xfd\x60\xea\x4f\xee\xc7\xa4\x1f\x24\x78\xdf\x33\xc6\x42\xa3\xed\x87\x0e\xda\x48\xb3\x39\xa0\x03\x6f\xf9\xe9\xb8\x31\x8b\x4e\x2c\xcf\xcd\x43\xc0\x45\x8d\x7e\x4d\xf6\x16\xb4\xf3\xd5\xe0\xc1\xde\x26\xbc\x3e\x99\x44\x27\xa2\xdd\xb8\xe7\x31\x49\x83\xd9\x84\xc0\x24\x08\x69\x7f\xf0\x16\x75\xf8\x45\x0e\x31\x99\x4d\xfc\x3e\xb1\x9a\xef\x87\xb5\xe6\xc8\x81\x0a\x54\x18\x24\x76\xe7\xd4\x3a\xdc\xa5\xf9\xfc\x94\x24\xe0\x87\xda\x5e\x0a\x7e\x64\x39\xb2\x24\xcb\x64\x82\x5f\x63\x13\x40\x22\x73\xac\xb1\x7b\xa5\x34\xb3\x3e\xe1\x95\xdc\x55\x7b\x35\x96\x02\xe3\xc8\x8c\xf7\x06\x24\x4c\x83\x61\x40\x62\xb9\x49\x86\x53\x0c\xdf\x9d\xed\x1f\xd5\x6a\x70\x4b\xb1\xbf\x52\x49\x74\xf2\x03\x2e\x32\xc4\x7e\x91\xdc\xc6\x9b\x4c\x78\x2e\x21\x8d\x71\x88\x54\xa0\xc6\x6a\xe2\x4a\x83\xac\x4e\xdb\x56\xc2\x8d\xb0\x8a\x6e\x8d\x33\x81\xe7\xb1\x87\x1a\x54\x2c\xbb\x0d\x55\x01\x9e\x26\x54\xd9\xfe\x14\xd7\x94\xc1\x47\x9f\x03\x0c\xa0\x9b\xcc\xfc\x3e\xe1\xfc\x5b\x31\x30\xd1\xb1\x90\x54\x7c\x9b\x24\x29\x19\x28\x5a\x1a\xa4\x64\x8d\x91\x3b\x21\xf3\x30\xc0\x91\x34\x22\xe9\x57\xe8\xe3\xbd\xb0\xb0\x1c\x2f\xd1\x6c\xc2\xbd\x21\x1e\xf8\xd1\x2a\xe6\x08\x27\x8a\xd5\x18\xd0\x28\xc6\x21\x28\x65\x81\x23\x40\xa4\x63\x12\xc2\x84\xa4\x59\x40\x3d\x02\x56\xd0\x20\x0d\xe8\xc5\xd1\x49\x42\x62\xce\xc5\xb6\xa4\x39\xc2\x55\xf7\xc9\x7b\x74\x21\xaa\xca\x37\x02\x3a\x5f\xbe\x33\xb4\x2a\xc7\x7e\x6c\x55\x6c\xb8\x05\x75\x2f\x67\xf5\x2b\xe9\x0c\xda\x11\x1a\x2a\x35\xa8\xd8\x15\x9d\xd0\x82\x56\xe8\x05\x14\xb0\x0b\xea\x9f\x3c\x81\x4a\x65\xcd\xc0\x8e\xf1\xc2\xe7\x34\x66\x68\x36\xa9\x84\x3e\x26\x71\x0a\x33\x76\x26\xcf\x1f\x91\x04\xd2\x48\x1e\xbb\xa4\xcf\x4c\xbf\xd2\x30\x48\x60\x12\x1c\x91\x36\x6c\xb9\x9f\x83\x75\xfc\xd7\x3a\x09\x26\x13\xe8\x91\x7e\x34\x25\x6d\x68\x6d\x7d\xce\x6e\xab\x2a\xfa\x51\x98\x44\x13\xd2\x98\x44\x23\xa3\xd7\x58\x06\x93\x4b\x14\xc1\xd4\xe0\xef\x75\xdd\xfa\xde\xfb\x8d\x83\xda\xe7\xa8\x10\x90\x33\x25\xc7\xb8\xe0\x10\x32\x5e\x50\xfa\xe6\x24\xf2\x53\x91\xa9\x81\xa6\x0a\xcb\x75\x28\xd5\x6d\x58\x07\xb7\xe1\x7a\x72\x6d\xaa\xd3\xb2\xd9\x84\x77\xc9\x34\x3a\x16\x8c\x12\xe8\x82\xa5\x2d\xc9\x9d\x46\x42\xf6\x14\x63\xcd\xb6\xc2\x47\x77\x17\x33\x24\xbd\x03\x95\x51\x50\xb1\x1d\x3a\x14\x25\x0c\x76\x39\x3f\xab\x16\x7d\x9d\x24\x33\x24\x4c\x77\xa7\xb3\x6c\x83\x0e\x1c\x4b\x55\x67\xcb\x05\x02\x48\x7f\xaa\xab\xe2\xa3\x66\x13\xf0\xba\xd9\x61\x14\x4f\x31\xc0\x36\xed\x7d\x5f\x63\x0d\x8e\x5a\xfb\x1c\xb6\xe2\x0d\x58\xc7\x09\x3e\x53\x81\x3f\x78\x44\x05\x09\x46\xee\x0e\xc2\x11\x24\xe3\x20\x15\xdf\x2c\xb7\xe1\x61\xdf\xb4\x10\xa6\xdb\x70\x5b\xae\xf9\xb7\xa9\xc6\x5b\xbe\x8d\x62\xf0\x3d\x79\x02\x4b\xf1\xe2\x33\x1a\xa2\x60\x09\x5c\x0b\xa6\xc6\x66\x2e\x2d\xd3\x96\xd7\x07\x03\xac\x69\x4d\x03\x5e\x63\x63\xd0\xb8\x49\x87\x77\xb4\x0c\x70\x91\x9b\xbd\x42\x14\x8a\xfa\x08\x7b\x31\x53\xd8\xf9\xc2\x97\xd3\x4a\x8d\x02\x2a\x06\xfb\xa8\x01\xf9\x71\x0a\xc3\x38\x9a\x16\x60\x4b\xf9\x84\x84\xc9\x3c\x26\xa2\x74\x8f\x60\x04\x79\x29\x2c\xa3\xe9\xcc\x4f\xf9\x1a\xa1\x60\x72\x28\x18\xf6\x96\x75\xbb\xfd\x7e\xbd\x4b\xd5\xb9\xda\xfb\x75\xfb\x36\x45\xc2\x46\x2d\x40\x1b\x42\xa2\x61\x83\xfb\x14\x3b\x3a\xd3\xc9\x4f\x61\x14\xde\xcd\x7c\x35\x29\x87\xb9\xa6\x74\x08\x11\x16\xd5\xff\x64\x1c\x4c\x08\x58\x16\x4f\x83\x4e\x46\xd9\x6c\x90\x05\xe9\x5b\x59\xb8\xb6\x6d\x9a\x7c\x79\xe9\xae\x7b\xc0\x64\x7e\xf6\x80\xb2\x89\x72\xad\x93\x43\xb4\x91\xcc\x7b\x6c\x3a\xb5\xf0\x5e\x1d\x13\x9c\x5d\xb4\xef\x21\x14\x7d\xda\xb3\xd0\x91\xaf\x56\xc5\xaa\x38\x74\x90\x3b\xcb\x2a\x51\xa0\x6d\xad\x19\x3a\xc8\x46\x2f\x1a\x9c\xe6\x34\x89\x02\x45\xa5\x9a\x97\x30\x17\x52\x1c\x32\xcd\x92\xa4\xd2\xf4\x07\x8d\x79\x73\x28\x52\xde\x30\x94\x88\x02\x6a\x1b\x85\x66\x31\xa1\x08\x8b\x3c\xbc\x4c\x01\xe7\x98\xa5\xa2\x24\xd5\x25\x81\xb0\x21\x98\x55\xe5\xc0\x88\xf1\x2f\x85\x42\x76\xd1\x25\x94\xf4\x62\xd6\x7f\xdf\x6a\x3a\x05\x54\xb0\xd7\x54\x28\x32\xf4\x2f\x49\xe0\x64\xec\xa7\x7c\xf6\xf2\x63\x02\xf3\x84\x0c\x70\x91\x61\xaa\xc8\x85\x2b\x0a\x23\x83\x26\x59\xd0\xc2\xcf\xd6\x39\x6b\x7a\x48\x97\xa5\x6a\x19\x37\x60\xa0\x6e\xf2\xc1\x9c\x7c\x85\x6b\x73\xdd\x03\x23\xf9\xcb\xd1\x09\x89\xef\xf8\x49\xe1\xf7\x14\xe7\x50\xba\xca\xeb\xbe\xdf\x70\xeb\x7b\x07\x56\xf7\x73\x48\x16\xbb\x39\x0a\xd6\x8c\x21\xcc\x95\x1f\x2c\xc0\x46\x6a\x46\x43\xe4\xc3\x9b\x67\xd7\xb5\xf3\xeb\x02\xc4\x93\x27\x20\x9e\xf1\x46\x39\x3d\x38\x53\x10\xf2\x1b\x5a\xce\x0c\xad\x2a\xd7\x02\xa9\xe9\x29\x40\x8d\x34\x92\x79\x2c\xdb\xc6\x91\xa4\x6b\x7f\x1a\x7d\x98\x6b\xb5\x86\x83\x91\x25\x53\x53\x26\x6f\xa6\x1a\x1d\xd9\x95\x68\x64\xf2\xa7\x86\x14\x65\xb1\xac\xf1\xa2\xb5\x82\xf1\x02\xed\x14\xb9\x75\xb1\x18\x4b\xfb\x8a\x93\xa4\xc0\xf2\x1d\xe8\x39\x54\x26\x30\xe2\x60\xc0\x07\xdd\xeb\x91\xa9\x54\x36\xf8\x18\xe1\xe0\xb4\x47\xde\xa2\x0d\xa3\xc5\x68\x99\x7d\x5e\xa4\x57\x54\xa4\x67\x16\xe9\x89\x22\x9c\x8b\xa8\xdc\x8c\xfd\x70\x44\x34\x1c\x74\xfb\x6b\x0c\x37\x6e\xf0\x0e\x4b\x52\x3f\x4e\xdb\x10\xcb\xad\x2b\x12\x0e\xe8\xab\xc7\x5f\x67\x31\x9e\x06\x8e\x95\xd2\x49\xb3\x72\x1b\x39\x95\x53\xfa\x57\xfa\x09\x6a\xe0\x73\xe5\xc5\x41\x38\x3c\x2f\x15\x34\x66\x5e\x8f\xe6\xed\x89\xcb\xd9\xd6\xd0\xa1\x49\xf7\x65\xd4\x1a\x18\x93\x91\x46\x49\x1c\x28\xd0\x41\x60\x53\xf1\x1d\x09\xc6\xdb\x37\x85\xdb\x30\xa5\xb8\xb4\x79\x0c\x9f\xb3\xb5\x35\xd1\x2d\x0d\x24\x8c\x20\x90\xd6\x6f\x59\x82\xc9\xaa\x7a\x64\x94\x38\xf4\x5f\x07\xad\x65\x0e\x33\x2f\x3a\x5c\x13\xda\xe7\xb9\xfc\x80\x63\x24\x86\x8c\x6f\x8b\x4f\xbd\xec\xa7\x9e\x43\xb3\xd7\xc0\x93\x59\xf0\x54\x43\x80\x7d\x84\x7c\x12\xc0\xad\x0e\xb8\xb4\x9b\x7a\x81\x3e\xe9\x52\x5c\xd8\x59\x0a\x7c\x9d\x30\x5f\x10\x0a\x9b\x7b\xab\xaf\xe9\xb3\xbf\x82\x72\x9d\x21\x6b\xce\xee\x01\x74\x68\xad\xfa\x2c\x48\xe1\xb3\xa1\x18\x68\xb1\xdf\xf2\x6d\x73\x40\xe1\x0f\xa6\x37\x00\x82\x90\xc7\x26\xc0\x33\xd7\x34\x5c\x69\xed\xf2\x9a\xa2\x99\x65\x3b\xb4\x8d\x07\x19\x48\x06\x4a\x74\xa0\xc9\xec\x0a\x2d\x5e\x1b\xdc\x44\x3a\x98\xdb\x22\x9c\x32\x3d\x32\xd2\xf7\x42\x62\xbe\x21\xdb\x0b\xf4\x48\x22\xaa\xaa\x82\x8e\xca\xb4\x53\xee\xdb\x62\x87\xc1\x4d\x5a\xe6\xc6\x0d\x10\x1d\x76\x9b\x3e\xb5\x25\x7c\x4d\xbc\x6a\x64\x29\x50\xe2\xbb\x3a\x6b\x81\xee\xa7\x62\xcc\xb2\x8c\xe1\x0a\x24\xd8\xc6\x73\x9a\x5f\x9f\xdb\xfa\xba\x69\x67\x6d\x8e\x0f\xf3\x4a\xc1\xc3\x4b\xd8\x1c\xf5\xf2\xb2\x8a\xaf\xf9\x93\x23\xaa\xb0\xcd\x47\x63\xf0\x27\x13\x5d\x7d\x57\x7a\x05\x55\xf7\xa7\x18\xb1\x24\x08\x13\x12\xa7\xec\x3d\x08\x79\xbc\xd2\x01\xe9\x4f\x7c\x0c\xa1\x93\x55\x20\x98\x82\x60\xae\x60\xd4\x57\xb6\xed\x71\x96\x29\xaf\xeb\x12\x05\xda\x90\x30\x89\x8a\x3c\xef\xde\x65\xba\x1d\x5d\x98\x2a\x49\xc3\xbc\xbd\xb9\x1a\xa9\xfa\x7d\x44\x52\x1d\x58\x52\x00\xcd\x6e\xb0\x4a\x55\xe7\x8b\x3c\xcc\xd1\x5f\xd7\xed\xd8\x17\xb9\x38\x89\x7a\x8f\x1a\x4b\xd6\xd8\xf4\x33\x9f\x71\x99\xea\x5c\x63\x4a\x38\xa5\xb2\xd1\xc4\x6c\x46\xac\xba\x00\xb2\x6a\x38\x7b\x32\x9a\x61\x33\xa7\x03\x86\xa2\xae\x0e\xde\xf7\xe3\x84\x24\xc6\x3a\x0d\x35\x70\x7e\xd9\x5c\xb9\x49\xb9\x44\xf7\x83\x5f\xf3\x67\x01\xcc\xe2\xe0\xd8\x4f\x49\x5e\x17\x34\xe9\x9d\x43\x53\xf6\x98\x8e\x0f\x6a\x7b\x3c\x7d\x18\xa2\x3d\x9f\xbb\xcc\xa8\x92\x6c\xe1\xc1\xd7\x09\x70\x1b\x34\xd3\x4a\xe5\xfd\xf7\x7b\x48\x71\x2d\x37\xa5\xf5\xfb\xef\x5b\x15\x1b\xda\x5a\xf2\x1a\xc0\x20\xe2\x7d\x8a\x26\x7f\xe2\xc7\xfd\x31\xce\x94\xd0\xc1\xaa\x99\x3e\xa4\xcc\xa9\xfc\x7c\x83\xcc\x96\x33\xb2\x64\x56\xeb\xdc\x26\x83\xd6\x5e\x55\x8a\xce\xd8\x86\x85\xbc\xdc\x12\x5b\x79\x2b\x48\x92\x20\x1c\xe1\x48\x1b\x06\x31\xae\x9a\xe6\xb3\x89\x16\x21\x78\x4c\x92\x00\x17\xdb\x23\x6e\xa0\x94\xf4\x0f\x14\x17\x06\x21\x98\x24\xd1\x4d\x46\x8c\xd0\x74\xc0\x18\x38\x2a\xba\x50\xdd\x06\xf7\xf6\xcc\x3c\x4c\xbc\x67\x97\xcd\xc5\x6b\x4d\x4a\x43\x6d\x7d\xa9\x40\xda\xf6\x5a\xa1\xce\x2d\x86\x00\xe6\x64\x6e\x3b\x1a\x76\xee\x81\x98\x1a\xeb\xfa\xcc\xa8\xc8\xf7\xe0\x34\x4c\xfd\x05\x37\x67\x87\xc2\x7c\x3d\xe5\xd4\xec\x4f\x22\xfc\xad\xda\x55\x4a\x1a\x4a\x35\xb6\xcb\x60\xda\xb7\xcb\x4c\xd7\x7c\x6a\xff\x90\xe3\xd8\x16\xc8\x16\xd9\xfd\xdb\x30\x0c\xb9\x35\x91\x8b\x25\xd1\x32\xbe\x64\x3c\x53\xcb\x10\x64\xb9\x94\x24\x29\x63\x39\x5b\x9b\xb3\x74\xc6\x52\xa3\xb9\x74\xaf\xe3\x42\x0b\x39\x69\x22\x5a\x3a\x9a\xb3\x82\x0a\x72\xe2\x73\x45\xd9\x84\xbd\xd5\x6c\xd2\x09\x27\x3a\x81\x98\xf4\xe7\x71\x12\x1c\x33\x1b\x90\x76\xb4\x87\x96\xb6\x2e\x3a\x05\x2c\xd9\x79\x29\x9a\xee\x37\x3f\x5b\xb0\x7c\xb6\x60\xf9\x6c\xc1\xf2\xd9\x82\xe5\x57\x76\xc1\xb2\xf5\x5c\x0b\x16\xf4\xbd\x20\x8b\x59\xa7\x78\x31\xb2\x6d\xef\xbf\xb6\x46\xbf\x6b\x51\x12\x86\x51\x3c\x9d\x4f\x7c\x3a\xf3\x64\x8f\x8b\xbf\xb6\x76\xcd\xf0\x6d\x7a\x6d\xed\x9a\xf4\xa4\xe8\x74\x0f\x9c\x59\x34\xf3\xe8\x3f\x2d\xfa\xcf\x86\xf8\x3c\x08\x92\x59\xa7\x7b\x20\x5e\x53\x32\x9d\x75\xaa\x55\xf1\xea\xc7\x71\x07\xdd\xf9\x70\x7e\xa6\xa9\xc3\x28\x66\xe7\xcc\x3b\xee\x7e\x70\x53\xc5\x16\xd8\x0f\x6a\x35\x9b\xe2\x70\x2d\x18\x5a\x7e\x1c\x77\x83\x83\x06\xc5\xb8\xd3\xe9\x78\x4f\x9e\x98\x09\x1b\x2c\xe3\x35\x5a\x37\x9f\xcb\x99\x53\x55\x26\xdb\x6d\xfe\x9e\x8c\xa3\x13\xf1\x8d\x19\x64\x69\x8e\xb6\x77\x46\x09\x74\xed\xda\x19\xfd\x87\x8f\x83\x6c\xd5\xe7\x55\x45\x41\xaf\x0c\xcd\xd5\x80\x75\x11\x22\x6b\x7b\xdd\x3b\xe8\xe4\xc1\xd6\x2c\xed\xe5\x7a\xa7\x52\xaf\xdc\xae\x58\x95\x76\xa5\x62\xd7\x0a\x00\xb0\x86\x15\x95\xb1\xb1\x0c\x43\xd2\x3d\x3b\x0f\xc7\x9d\xf3\x71\xb4\x8a\xaa\xa7\xc5\xaf\x77\xbc\x55\x50\x5c\x5a\x9c\x61\x5b\xcb\x91\x77\xe7\x5c\xcc\x3d\x41\x5e\xca\xa8\x1d\xd6\x61\x28\x78\x44\x62\x2b\x97\xa8\x60\xd0\x8a\x3a\x9d\x4e\xf5\x7e\x55\x32\x9b\x48\xba\x53\xb5\x73\xbd\x5f\xb9\x99\xcc\x67\xb7\x2a\x35\x0a\x95\x37\xab\x72\xb3\xc9\xd2\xf4\x2e\xa4\xf9\x7a\x2c\x9f\xa7\xe7\xeb\xdd\xaa\x70\xae\x71\x39\xdb\xb0\x46\xe5\x2a\xb2\xb0\x86\x2c\x71\xb5\x6a\x33\x19\x38\xf9\x34\xfc\xbc\x0c\x7e\x2b\x73\x6b\x2b\x3b\xec\xf6\x2e\x4c\xdf\xab\x6a\x8e\x31\x2a\xb0\x4d\x05\x20\x3c\x0d\x84\x97\x05\xc1\x5a\xad\xb5\x67\x85\xb1\xdf\xba\x70\x7b\xa9\x60\x3c\x9f\x08\x06\x83\x58\xd8\x49\x1b\xa2\x93\x1c\x93\xa7\x1c\xb3\x0b\x6d\xd1\x7b\x2d\x0d\x7d\xfa\x3f\x9f\x69\x70\x64\xb9\x07\x52\xda\xd2\x31\x63\xea\xbe\x1d\x3a\x1f\xe4\xfd\x16\xb7\x5f\xe4\x3c\xb4\x53\x30\x0f\x51\xb5\x72\x18\x2c\x72\xf3\xd0\x57\x12\x12\xbf\x21\x97\xd5\xaf\xad\x5d\xab\xaa\x29\x09\x67\x15\x2d\x43\x47\x7b\x7e\xf2\xe4\xc3\xb3\xcc\xe7\xc6\xfd\x7b\x1d\xf4\x0a\xb8\x7f\x2f\xfb\xe5\x2e\xfb\x70\xf7\x05\xcd\x71\xa8\x3c\x46\xd1\xa4\x23\x0e\x0b\xe9\x75\x87\xd7\x3b\x9d\x8a\xb4\x1d\x54\xec\xcb\x4e\x8a\x9c\x39\x11\xf5\x22\xf6\xba\xd8\x44\xb7\x51\x0a\x4e\xc3\xbd\xab\x83\x3e\xb8\xf0\xb4\x17\x0c\x65\xc8\x05\x5a\x4b\x97\xd5\x65\xce\x01\x1d\x93\x38\xac\xe0\xb5\xe2\xfc\xcc\xa3\x10\x71\x65\x15\xf2\x01\x77\xa6\xe4\xe9\x92\x82\x1d\xbd\x31\xd6\x92\x8c\xe7\xb6\x6f\xe7\x9f\x79\xfb\x76\x75\x39\xc8\x19\x24\x23\x08\x73\xa9\x3a\x1f\x31\x3e\x71\xf2\xdc\x69\x29\x51\xe7\x28\x31\x67\xaf\x20\x9a\xdd\x4b\xa0\xa4\xba\x47\xce\x31\xc5\xbd\xa1\xb0\xea\xe0\x63\x3f\x0a\xfb\x7e\x8a\xd3\x0a\x07\xa5\x65\x29\xe8\x1f\xbd\xf1\x34\x63\xbe\xdb\xb4\x73\x84\x72\xb2\xca\xe0\x02\x0a\x19\xaf\x31\x0f\x93\x71\x30\x4c\x75\x68\xec\xc3\xb9\x95\x7b\xb9\xca\x3f\xcc\x65\xbb\x5c\x07\x81\xf6\x77\xf6\x5c\xaa\xc4\x55\xf6\x1f\x64\xfe\x74\x47\xc5\x0c\xf5\x5a\xcb\x7b\xf7\xff\xab\xfd\x2a\x80\xae\xac\x19\x15\x74\x54\x9e\x0a\xd7\xcb\xa9\xd0\xe9\xd2\x7f\x0f\xf4\xf6\x14\x33\x00\x6a\x57\x97\x97\x34\x1b\xaa\xc1\xa2\xed\x21\x39\x41\xc5\x85\x51\x74\x15\xc1\xb3\xa1\x64\x3d\x9d\xe1\xed\x02\xaa\xaf\x34\x6d\x6e\x9c\x95\x08\x73\x06\x84\x17\x39\x30\xb5\x3c\xe9\x76\xce\x45\xf8\x2d\x8f\x13\x12\x0d\xe7\x96\x68\x4d\x83\x2c\xfa\x64\x86\x2a\x5c\xe5\x2b\x61\xdf\x9f\x8f\xc6\x29\xb7\xa8\x03\x89\xe3\x28\xae\xd8\x08\x57\x53\x1c\xd9\xf4\x20\x34\xc7\x5b\x5e\xc6\x47\xf3\x76\xe5\x5e\x38\x0c\xc2\x20\x3d\xad\xb4\x35\x4f\x5c\xb3\x54\x23\x8d\xde\x0c\x16\x64\x60\x79\x5b\x08\xff\x4c\x68\x7d\xe4\xd8\x9f\x74\xf4\x1d\x39\x27\x8d\x8e\x48\x98\x38\x51\xef\x11\x12\x50\x63\x18\xf6\xa5\x70\xcc\xe8\xe1\x30\x26\x64\x41\x01\xd9\x8d\x34\xba\xcf\x34\x49\xcb\xd6\x75\x4a\x4b\x36\x30\x3b\x2e\xa3\xde\xa3\x42\xe8\x39\x1c\x38\x8d\xb3\x8c\x8b\xdd\x55\x80\x0a\x6f\xd3\x39\x18\x21\x3a\x65\x20\xca\xcb\x72\xd8\x7a\x9b\x4a\x28\x72\x2e\x1a\x94\xe6\x17\x59\x19\x2c\xbd\xa8\xfe\xdc\x95\xc1\x6b\x72\x7b\x69\xc9\xfa\x60\x97\x22\xf4\xda\xda\xb5\xcc\x12\x41\xb6\xa0\xc0\x50\x95\x5b\x16\x5c\xe3\x91\x1f\x52\xaa\xc5\x93\x09\x99\xd2\x61\x3e\x23\x03\x67\x16\x93\x19\xfd\x87\x26\xf2\x59\x4b\x57\xf9\xc5\x7a\xde\xe2\x2b\xab\x4d\x9a\xb7\xed\x9e\x1d\x48\xa0\x79\xf5\xfe\x9a\x0a\x96\xd8\x91\xf1\x4d\xe3\x4c\xa0\xc4\x8c\x7d\xa1\xd4\x94\x95\x4d\xa0\x12\xe6\x5a\xb3\x19\x70\x36\x84\x20\xe1\x8e\xfb\x4e\x9f\x1f\xbc\x72\xa2\x18\x42\xeb\x64\x1c\xf4\xc7\xf4\xab\x3f\x49\x22\xf0\x21\x99\x91\x7e\xe0\x4f\x40\xe4\x82\x20\x84\x68\x1e\x43\xdf\x4f\x88\xcd\x84\x54\xc1\x1a\x82\x7d\xb8\xa6\x0b\xa8\xce\xdb\x58\x9d\xa5\xa7\xa9\xb9\x29\x49\x97\x2b\xa4\xb9\x3a\x36\x0b\x44\xe4\xca\x85\xb7\x44\x61\x34\x8c\x5b\x16\xeb\x53\x7d\x0e\xb0\xc5\xec\x22\xeb\xd1\x90\x64\xd9\x05\xf2\x67\xe7\x56\xe7\x79\x57\x5f\x5f\x66\xde\x56\xdf\x35\x44\x38\x24\xca\xb6\x5c\x6b\x17\xf4\x8e\x49\x87\xa6\x36\x66\x31\xd9\x97\x99\x3a\x85\xca\xbc\x2a\x32\xa3\x65\xb4\x22\xb8\x41\x3c\xf1\x47\x98\xcc\xfa\xb8\x53\x15\x27\xc0\xaa\x37\x6e\x60\x0d\xb9\xf4\x7d\xc9\x34\xb3\x98\xdc\xa2\x60\x6d\xad\x29\xb4\x8c\x2d\x51\x52\x6d\xe0\x94\xa3\xd9\x6f\x75\x66\x31\xb9\x71\xe3\x3a\xad\xfa\xc9\x13\xfa\xef\x8d\x1b\xb3\x98\xdc\x44\x50\x22\xfb\xb5\x3c\x89\xf7\xc5\xa7\xf3\x9a\x5a\x4e\xfa\x42\x32\x5c\xbb\x26\x88\x50\xd0\x5a\xa4\x42\x29\x11\x44\x5f\x5e\x2b\xa1\xc0\x59\x46\x6d\x12\x37\xe7\x29\xf5\x22\x49\x99\xf4\xe6\x22\x68\x25\xd1\xfb\x7c\xb1\xba\xcf\x11\xba\x7b\xcc\xf0\x20\x9d\x0d\xc2\x3e\x46\xae\x3d\xf6\xb9\x4e\xb3\xd4\x24\x81\xcd\x65\x9c\x5a\xeb\x1c\xfb\x93\x7d\xad\xd1\x7e\x1c\x8b\x79\x8a\x9d\xaa\x39\x22\x61\xa7\x5b\x4d\x82\xb0\xea\x54\xfb\x51\x52\x75\xaa\xa9\x4f\x9f\x67\x41\xd5\xa9\x5a\x55\xa7\x6a\x57\x9d\xea\xfd\xaa\x53\xbd\x53\x75\x28\x1c\x80\xaa\xcf\x72\xfb\x2c\xbb\xcf\xf2\xef\x54\x9d\xea\x6e\xd5\xa9\xee\x55\x9d\x6a\x10\xa6\x32\x73\x3f\x4a\xc6\x3c\x33\xfd\x9d\xd0\xbc\xbf\x5e\x75\xaa\x71\x14\xa5\x55\xa7\xba\x59\x75\xaa\x5b\x55\xa7\xba\x5d\x75\xaa\xcd\xaa\x53\xbd\x2e\x0b\xa6\x7e\x38\xe6\xe0\xe9\xef\x5b\xd1\xa0\xea\x54\xbd\xaa\x53\x6d\x55\x9d\xea\x46\xd5\xa9\xae\xcb\xac\x49\xc0\xb2\xf2\x5f\x42\xeb\x89\x46\x55\xa7\xea\x56\x9d\x6a\xa3\xea\x54\x6b\x55\xa7\x5a\xaf\x3a\xf8\xdf\x83\x60\x34\xf5\xab\x4e\x95\x22\x72\x9f\x36\x92\x72\x92\xb4\x1e\xa1\x59\xb9\x88\x1e\x37\x66\xc1\x7e\x31\x45\xce\xa7\xc7\x3d\x41\x8f\x2c\x35\x60\x19\x39\x6e\x0c\x82\xe3\x60\x40\xf6\x15\x55\xb2\x34\x81\xb7\xa2\x01\x64\xa8\x72\x23\x0d\xa6\x24\xd9\xe7\x05\x0a\x28\x03\xe5\xa4\xb9\x81\xb4\xd9\xe7\xc4\xb9\x71\x1f\x5b\x6c\x90\x87\x1c\xfb\x9d\x2e\x6a\x02\x53\x3a\x08\x93\x20\x74\xd4\x5b\x3f\x4a\xb4\xb7\xd4\x0f\x9d\xea\xfd\x7b\x8a\x66\xea\xd3\x7d\xed\xf9\x0e\x22\xaa\xde\x7d\x13\xa6\x6f\x02\xf5\x11\xaa\x46\x5b\x94\x05\xc3\x49\x14\xc5\x19\x38\x94\xc2\x19\x38\x63\x96\x7b\x12\x8d\x1c\x21\x42\xd8\x43\xf2\x41\x9c\x1a\xb4\x57\xe5\x06\xc1\xb1\xf6\x36\xf4\xfb\x69\xa6\x1e\xda\x15\x19\x04\xf5\xf7\x69\x34\x30\xfa\x47\xfb\x32\x9f\x64\x40\xd1\x4e\x72\x4c\x4a\x8c\x9d\xea\x5d\xbd\x10\xc5\x5d\x74\x9d\x96\x73\x30\xd0\xde\x92\x79\x0f\xbb\x53\x07\x3c\x9a\xfa\xd8\xa9\x5a\x1f\x04\x92\x08\xb2\x77\x67\x31\xe9\x93\x41\xe7\x43\xb7\xed\x79\x8e\xd7\x76\x9d\x56\x7b\xc3\xd9\x68\xbb\xce\x66\xdb\x75\xb6\xda\xae\xb3\xdd\x76\x9d\x1d\xfa\x71\x97\xfe\xb3\xd7\xf6\x1c\xcf\x6d\x7b\xae\xe3\xd1\xcc\x5e\x0b\x8b\x6d\xf0\x6d\x2c\x14\x2f\x74\xe6\xee\xba\x0e\xfd\x6f\xc3\xd9\x74\xb6\x1c\x9a\xd9\xc5\x76\xb3\x54\x0f\xff\x33\x52\x54\x72\xcb\xd9\x91\x1f\x5a\x32\x4d\xa4\x6c\x60\xbe\x6d\x67\xcf\xd9\x73\x68\xc5\x2d\xc7\xdb\xa0\xff\xee\x62\x7b\xa0\xb9\xfe\xda\xda\x35\x57\xf3\x49\x83\x93\x20\x1d\x43\xc2\x56\x5a\x22\xf1\x30\xf4\xa7\xc4\xa2\x94\x48\x0e\xc9\x62\x46\x65\xa7\x87\x0e\x0e\x78\x1a\xf3\xb5\xb5\x6b\x2d\xdc\x78\x0e\xfd\xf8\x14\xa2\x19\x0b\x22\xce\x4e\x63\xc2\x3a\x34\x71\x00\xe2\xa6\xb8\x9f\x24\x51\x1f\x6f\x2f\xf7\xc3\x01\x24\xfe\x94\x70\x6a\x92\xb0\x4f\x57\x03\x1b\xd0\xc6\x43\x70\x4a\x03\xc4\xd9\x8c\x83\x22\xce\x2c\x70\xee\xc4\xf3\xb0\x3f\x26\x31\xf8\x21\xad\x78\x13\xda\xb4\xc6\x30\x08\x47\xd0\x8b\xfd\xfe\x11\x49\x5f\x5b\xbb\xb6\x05\x6d\xe9\x60\xa5\x52\xb7\xd5\x11\xf0\xd7\xd6\xae\xed\x94\x35\x1a\xdb\x89\xcd\x34\x9a\xff\xda\xda\xb5\xdd\x95\xc9\x44\x8b\x7b\x8e\x78\x6a\x51\x82\xed\xe5\x49\xc4\x9a\x55\x73\xea\x94\x9e\x6e\xc9\xe7\xfb\x70\x07\xa2\x18\x7e\x9d\xe6\xf1\xda\x40\x3b\xd6\x6b\x65\x11\x71\x20\x21\x58\x8a\x0c\x20\x1d\xc7\x84\x00\x3a\x5e\x91\x94\x75\x8f\xb7\xd1\x96\x67\x8a\x21\x1a\x02\x4a\x30\x09\x82\xf2\xc1\x7a\x53\x63\x46\x97\x32\x37\x46\xcc\xf5\xd8\xcf\x06\xfb\xd9\x64\x3f\xdb\xec\x67\x97\xfd\xec\xf1\x9c\x2d\xfe\xcb\xf2\x9e\x39\xcd\x26\x05\xc5\x53\xe9\xe3\xa6\x7a\xdc\x53\x8f\x9e\xa7\x9e\x5b\xfa\x73\xeb\xb5\xb5\x6b\x98\x21\x8b\x4c\xab\x08\xa7\x2d\x03\xb5\x9d\x42\x0c\x05\x18\x6f\x29\xc6\x1b\x0a\x87\x2d\xf5\xb8\xa3\x61\xb6\xc1\x31\x3b\x54\xa8\x99\xc8\xec\x96\x54\x40\x97\xbd\xd3\x59\x7a\xda\xf9\x10\x9f\x11\xc6\xc6\x45\x68\x5d\x82\xf2\xa1\x86\xe8\xa1\x86\xe9\xa1\x44\x75\xbb\xf3\xa1\xa7\x90\x08\xc9\xc9\xeb\x71\xa7\xdb\x3d\x40\x29\x71\xad\x5b\xf1\x2a\x4e\xa5\x55\x71\x2a\x1b\x15\xa7\xb2\x53\x71\x2a\xbb\x15\xa7\xb2\x57\x71\x2a\x9b\x15\xa7\xb2\x55\x71\x2a\xdb\x15\xa7\x52\xab\x38\x95\x7a\xc5\xa9\xac\x57\x9c\x4a\xb3\xe2\xd0\xd5\x66\xc5\xae\x38\x95\x5f\xaf\x38\x95\xeb\x15\xa7\x72\xbf\xe2\x54\xee\x54\x9c\x0a\xa9\x38\x15\xb7\xe2\x54\x1a\x15\x07\xff\x0b\x2b\xb2\x9a\x59\x50\x71\x2a\x93\x90\x66\x0e\x54\x6a\x12\xd0\x94\x7e\x94\x54\x9c\x4a\xea\xd3\xe7\x37\xc8\xa4\xe2\x54\x82\x30\xad\x38\x95\xb7\xa2\x01\x2d\x14\x8d\x2a\x4e\x65\x16\x9d\xa8\x62\x3e\x2b\xe7\xb3\x82\x3e\x2b\x49\xe7\xaf\x8a\x53\xa1\x7a\x02\x83\x46\xdf\xe8\x0c\xa1\x95\xe3\x79\x7c\xfe\x15\x27\x90\x8a\x53\xc1\x31\x51\x39\x38\x30\x54\x4a\xe6\xe2\x95\xa4\xb1\xe7\x24\x69\xdc\x72\x02\x67\x61\xaa\x96\xc3\x8e\xbb\x3f\xbc\xb9\xd8\x1f\x8a\x4d\x2e\x6e\xe0\x8a\xbd\x6e\x50\x1b\x1e\x5c\xef\x74\x68\xb9\xee\xf0\x80\x2f\x53\xc5\x49\x68\xbc\x35\x20\xab\x6b\x63\xcc\x7f\xae\x77\xe2\x1c\xe4\x0f\x06\xef\xa1\xee\x29\x55\x67\x6e\x1a\x91\x38\x30\xd5\xd6\xb0\xf6\xa8\x0d\xb7\x6b\x8b\x0e\xfb\x82\xeb\x43\xfa\x24\xb2\xe0\x57\xb9\x0f\x58\xf7\x98\xf1\xe2\xda\xb5\x66\x13\x79\x03\xd7\xe4\x62\x39\x3e\x39\xc5\xdb\x6a\x47\x21\x19\xc0\xc0\x4f\x31\x28\x08\xbf\xe1\x21\x08\x81\xad\xe1\xbd\x37\xa8\xce\xec\x9f\x82\x9f\xc2\x24\xea\xfb\x3c\xac\x11\x0a\x9b\xd6\x80\x7f\x1b\xfb\x09\xb0\x90\x11\x31\x15\xcc\x28\xb8\xb8\xb3\x96\x07\x2d\xf6\xde\x62\x33\x43\x04\x54\x2c\x49\x7a\x2e\x6e\x22\x5a\xc2\x87\xe9\x5a\xb3\x89\x1d\x83\x37\x9c\xe2\x55\xab\xba\xa9\x21\x26\x88\xf3\x78\x3e\x62\xd3\x4c\x18\xa5\x40\x16\x41\x92\x06\xe1\x48\xac\xa2\xae\x31\xf3\x04\x46\xa1\xa7\x00\xc8\x00\x82\x14\x58\xb4\x80\x98\xf8\x47\xb4\x65\x21\x59\xa4\x18\x01\x04\xfc\x44\x0b\x25\x82\xfe\x59\x0c\x0e\xed\x80\xd3\x8e\xbb\x7f\xca\xd0\xeb\x2e\x84\x4b\xf0\xfe\xa9\xec\x02\x6e\x95\x33\xbb\xa1\xd3\xe9\x88\x12\xdd\xd3\x03\xb5\x90\xc4\xde\x60\x1d\x25\xdc\xc0\xf4\x7c\x72\x11\xc8\x2e\x2f\x31\xd7\x75\x67\xca\x6e\x4d\xa1\x74\x3a\x75\x4f\x9a\xa8\x19\x48\x5c\xf2\x65\x30\x11\x30\xd9\x86\x76\x26\xc3\xe9\x4c\x5a\x4d\x02\x8e\x09\x6f\xe0\xcd\x12\xc6\x12\xc6\x18\x86\x75\x71\x9e\x03\xbe\x0d\x7d\x5e\xb6\xa5\xf8\x92\x63\x3f\xfb\xdd\xb0\xf2\xd0\x15\x4a\x36\x03\x4d\x2b\x35\x5c\x60\xb6\x2e\x25\xdd\x41\xb6\x6d\x1a\x89\xf2\x19\x4e\x67\x44\xa1\x94\xfb\xac\xec\x6d\x0c\xa5\x5c\x06\x9a\x98\xd9\xb0\x40\xbd\x10\x87\xff\x84\x2c\xd4\xc8\x0f\xc2\x99\xa3\x8f\xfe\x42\xeb\x61\x92\xc6\x9d\xee\x87\xdc\x0a\xa8\xcc\x82\xe8\x3c\x46\x1f\xb2\x86\xc1\x59\xda\xa7\xbd\x71\xad\xd9\xbc\x6f\x7a\xf2\x53\xed\x89\xd0\xd1\x9c\x8e\x09\xf4\xc8\x28\x08\x51\xc5\xa2\x72\x61\x98\x92\x18\xc7\x36\x62\x23\x20\x05\xe1\xec\x41\x1a\x77\x82\x70\x26\x81\x1f\x91\x53\x6d\x8f\x0d\xab\xeb\x47\xf3\x30\x25\x71\xc7\x55\xa6\xc9\xc9\x24\x3a\x21\x83\x0e\xea\x1d\x32\x95\x2a\x6d\xef\x45\x77\x28\x12\x7a\xde\x24\x25\x71\xd0\x3f\xea\xe0\x2c\xaa\x1a\x11\x93\xe3\x2f\x91\x53\xee\xce\xc0\xb0\x71\x16\x0e\xcb\xa0\x76\xdc\x18\xf1\x32\xb6\x70\x24\xbd\x21\x6b\x75\x43\x35\xc2\x8a\x7a\x8f\x3a\xcc\x31\x43\x93\xb8\xac\xb9\x79\x89\x8b\xbe\xad\xf8\xad\x1b\x1c\x74\x3a\x55\xa8\xca\x41\x28\x4e\xeb\xea\x1c\x78\xa4\xd0\xbe\x96\x90\x7e\x9b\x56\xb0\xe8\x58\x06\xf4\x7a\x70\xcb\x18\x7b\xf5\x96\x7d\xdb\x78\xf7\xda\x99\xfc\xf6\xfe\xe2\x96\xbb\xbf\xa8\xd7\x85\x64\x59\x5d\x50\xb1\x09\x8f\xc1\x73\x34\xd9\x83\x33\x9f\x12\x54\x14\x6f\xed\xab\x29\x98\x20\x21\xfd\x42\xe1\xc4\x45\x54\xad\x73\x44\x4e\x25\xf2\x72\x63\x94\xc2\xec\x74\xaa\x55\x51\x4b\xf9\x86\xd0\x1d\x3f\xac\xa6\x28\x92\x63\xba\x4a\x18\x70\x9e\xac\xd4\x38\x1d\x98\x97\x77\x60\xdb\xc6\x68\x67\x5c\x3a\x20\x8b\x8c\x84\x3d\x22\xa7\xb6\x9a\x10\xfb\x6c\xc2\x65\xbc\x2b\xd3\xe8\x0a\x0d\xc7\x3f\x16\x3a\xd0\x3e\xdd\x3d\xee\xd0\x81\x9f\x4b\xbf\x1f\x93\x0e\x5b\xdb\x74\xb1\xb8\xfa\x76\xad\xff\x60\x1c\x9d\x74\x50\x1c\x64\x8b\xcd\x62\x42\x15\x86\xae\xf2\xaa\x96\xa6\x42\xda\x87\x8f\x3a\xb3\xb4\x2f\xba\xee\x51\xbd\xbe\x8f\x76\xf6\x49\x14\xcd\x30\x02\x13\x1d\xce\xca\xe2\x99\xf6\xbb\x8f\x0e\x34\xd7\x15\x4c\xed\xd2\x35\xe2\x86\xb3\xa5\xad\x06\x0f\x24\x25\x10\x51\xfb\x3a\x4e\x1d\xb2\xab\x83\xa1\xc5\xc7\x28\x6f\xc8\xf5\x4e\x07\x6f\xdd\x92\x39\xca\x7b\xea\x88\x9c\xd6\x2a\x68\xfe\x8f\x52\x31\xd2\x65\x67\xf1\x61\x6b\xab\x69\x4d\x58\x28\xaf\xd1\xe6\x1b\xae\x8a\xc2\x69\x6c\x8b\x49\x30\x2e\xd0\xec\xca\x99\x2a\xac\x0b\x12\x4f\xa5\x0a\x91\xc1\x94\x6d\x99\x1e\x84\x7d\x4a\x21\xa7\xee\xd9\xa6\xc5\xb6\x88\x61\xcf\xa1\xc0\x95\x34\x5f\x55\xc5\x31\xe6\x75\x75\xcc\xba\x18\x2b\xb6\x38\xb6\x94\xfb\x0c\x5b\x89\x48\x47\x0e\xab\x70\x2b\x57\x45\xa4\x52\x9e\x14\x24\x08\x3a\x41\x5d\x0d\x43\x4c\x04\x8e\x04\x0a\x3c\x46\xf8\xfe\xdd\x63\x46\x78\xac\x17\x89\x4f\xa1\x30\xfa\x63\x2d\x67\x72\xfc\x32\xd4\x34\x7e\xcb\x8b\x76\xad\x3f\x94\x08\x57\x9d\xd1\xb2\x59\xaf\xb7\x94\xbf\x00\xe7\x03\xbe\xe3\x57\xc8\x1b\x99\x6d\x2f\x39\xd9\x15\xec\x4e\x6b\x58\x4a\x0e\x67\x9b\x03\x59\x97\x34\xb4\xbe\x73\x97\xc5\x4e\xff\xee\xb1\x60\x0f\x81\xaa\x97\xd9\x21\x31\xf6\x0f\x8a\xd0\x3e\xcb\xd3\xc4\xcb\xd2\x84\x2d\x2a\x97\x61\xdd\x7a\x0e\xda\x96\xd3\xb4\xb8\xae\x0d\xfb\xc3\x66\x53\x18\x62\xca\xfb\xe3\xfc\x16\x6d\x2c\xab\x65\xb3\xc8\xe3\x45\xe8\x09\x35\x5d\xde\x15\x64\x63\xda\x0b\xab\x53\x53\x19\x6a\xb5\x02\xdc\x96\x52\x69\x65\xa2\x6c\x69\x6c\x73\x5d\xab\x52\xb2\xcd\x92\x59\x8b\x1b\xa4\xf4\x33\x93\x7e\x4c\x60\x1a\xc5\x04\xd2\xb1\x1f\x4a\x43\x56\x14\x12\x07\x4e\xfc\x20\x85\xaf\x8d\xfd\xf4\xfa\xf5\xeb\x15\x5b\x63\xa3\x2c\x15\xf8\x6e\x15\x27\x19\x9d\xf4\xf3\x73\x02\x6e\x19\x5f\x42\xb4\xf2\x72\x05\xb5\x66\x54\x39\x83\xfe\xf5\xfa\x45\x79\x63\xf5\x0e\xd8\xce\x8c\xdb\xb1\x9f\xbc\x41\xfa\x2b\x90\xff\xbd\x93\x48\x58\xff\x18\xdd\x75\xa1\x1c\xb0\xd5\x2a\x33\x68\x1a\xd4\xce\x88\x88\xeb\x19\x11\x21\x04\xa5\xcb\x3d\x49\xb9\x86\x4d\x35\xea\x19\xad\x83\x90\x01\xea\xd3\x3d\x02\xfd\xb1\x1f\x8e\xe8\x04\x90\xc8\xb5\x26\x55\xae\x27\x7e\xc2\xcd\x9c\x10\x46\x27\x3c\x6f\xe2\x0f\x71\x75\x3d\xf1\x53\x0c\x53\x35\x20\x59\xd1\x32\x8b\xe5\x5a\x47\x9f\xcc\xca\xa5\xcd\x76\x46\x20\xc8\xbc\x85\x03\xa2\x50\xfa\x29\x7a\x77\x84\xa9\xa2\xac\x9b\x76\x8a\x04\xd5\x72\x16\xc8\x21\x56\xca\x13\x5a\x3d\xbb\x97\x16\x88\x9b\x7c\xb2\xd9\x7c\x09\x93\xcd\x5e\xf1\x64\xb3\xa7\x6b\x66\x92\xe2\x9d\x4e\xc7\xd8\xb4\xd0\xf6\x99\x65\x16\x6d\x46\xc2\x54\xdc\x90\xc3\xf9\x38\xa7\xe1\x78\x59\xd5\x46\x62\x57\x5c\x63\x32\xef\xdd\xb8\xc1\x14\x88\x4e\xa7\x5a\xaf\x16\x55\x6f\xe0\x97\x47\xa4\x5a\xab\x9e\x8f\x86\x3e\x71\x9a\x03\x6c\x0b\xf7\xd8\xc5\xdb\x8e\xf1\xe6\x19\x6f\x1b\xe6\x37\x36\x63\xe1\x30\xc3\xcb\x7d\xa3\x70\x72\x8a\xa1\x6b\x21\x24\x23\xbc\x33\x84\x2a\x63\xc3\x68\x1e\x0e\x14\xdd\xb9\xc2\xcf\xdb\xda\x6c\x0e\x22\x2a\x19\xc6\x54\x0e\x0f\xa3\x18\x6a\x6a\x99\xcb\xff\x68\x16\xba\xfe\xf0\x07\x03\x66\xb3\xa2\xa3\xd8\xef\x45\xc7\xe8\xa3\x85\x17\x0e\x4c\x49\x98\xd2\x71\x9e\x8e\x7d\x3e\xd2\xe3\x39\x3b\xe3\x2d\x9c\xe4\x78\x1e\x79\x84\x9e\x16\x8d\x42\xb8\xc3\xac\x58\xb5\x22\xa5\xd6\xcd\x2b\xb5\x3a\x5f\x2f\x51\xa3\xf2\x7c\xac\xed\x00\x22\xb9\x1e\x04\xa3\x90\x9f\xae\x42\xc6\x6e\x79\x9c\xb3\xeb\xba\x8a\x7d\xe1\xd1\x50\xd4\xd9\xcb\x94\xa4\xbc\xb6\x52\x20\xc8\x96\x8d\xee\x12\x5d\xef\x79\x54\xd2\x8b\x4e\x50\xca\x01\xe7\xea\xb5\x0f\xef\xf2\xfa\xdf\x36\x67\x8a\xed\xe7\x11\x77\xe7\xa8\xd4\x1b\x17\x17\xfa\xe5\x32\x3e\x3b\xa7\x09\x2b\x8f\x58\x99\x63\x36\x61\x86\x5f\x75\x61\x9c\x5b\x17\x97\xb4\xdb\xae\x48\x3d\x48\xd7\x8e\xa4\xc7\x6b\xd9\xfa\x51\xb9\xcf\xe0\x51\x6a\xbe\x6a\xdc\x92\x2b\x46\xbe\x44\x28\xd7\x52\xfa\xd1\x74\x36\x21\x2c\xe2\x8d\x16\x2d\x41\xa8\x24\x08\x9a\x29\x7c\x86\xbe\xc5\xec\x58\x17\x6b\x06\x2d\xa2\x4a\xf0\xcf\x05\x05\x55\xcf\x37\x9b\x45\x2e\xe9\x78\xc2\xff\xb5\x02\x8f\x21\xf1\x61\x99\xc3\xd0\x6b\xf9\xf3\xc4\xab\xdc\x1f\x8f\xde\x41\xd7\xa4\x7b\x90\x0a\xbe\xeb\xc7\x09\xe1\x33\xa6\x72\x78\xec\xb0\x64\xd6\xe6\x33\xcd\x51\x93\x4a\xc0\x0e\x73\x9d\x4d\xde\x20\xa3\x98\x10\xb6\x79\x06\xcd\xe6\x34\x1a\xe0\xee\x45\xdf\x9f\xf4\xe7\x13\x3f\x8d\x62\x9a\xcd\xef\x47\x49\x5b\xd6\xc6\xf7\x82\x44\xc3\x2d\x25\x55\x05\xb8\xdb\xde\xae\xdb\xe4\x07\xb8\xd6\xdf\x12\x2e\x16\xd6\xc2\x6e\xeb\x2f\xbc\x6f\x71\x87\xca\x1f\x0c\x54\x05\xbe\xd3\x33\xab\xf0\x6b\x3d\x3d\x6f\x12\x84\xcf\x89\x4d\x12\x84\x0a\x1b\xf6\x62\x60\x93\xfa\xcf\x5b\x43\xea\x6b\x35\xb0\x17\xa3\x86\x7e\x94\x8c\x4b\xab\x10\xae\x28\xd6\xa2\x26\x7d\x50\xac\xc5\xfa\xa2\xee\x99\x40\x92\x20\xbc\x38\x90\x9a\x97\x6b\xeb\x0a\x40\x2c\xaf\xb6\xb0\x9b\x96\x57\x37\xdb\x71\x47\x95\x0c\x9d\x98\x97\x65\x26\xbd\xa8\xe3\x39\x51\x3a\x26\x71\x27\xac\xc7\x4e\x7f\x1c\x05\x7d\xd2\x89\x95\xdd\x04\x13\x6e\x62\x0e\x5e\x8e\xe7\xc1\x24\x96\x8f\x95\x8f\x75\x09\xa9\xbc\xdb\x58\xf6\x9a\xb7\x1f\xdc\xec\x84\xca\xb9\xed\xda\x2c\x8e\xd6\x3b\xc1\xbe\xde\x8c\x59\x1c\x35\x4d\x4f\x1d\x8b\x55\xac\x35\x45\xa9\x04\xa5\xd4\xa8\x2f\xf4\xfc\x45\x63\x22\x18\x16\xb0\x87\xbd\xd0\x54\xc7\x34\x7a\xd7\x1f\x04\xc8\x10\xfb\x39\x4a\xb3\x81\x61\x56\x52\xde\x39\x96\xbc\x0b\x80\x9d\x89\x74\x16\x76\x2d\x9b\x54\xf7\xd6\x17\xb6\xdd\x6c\x69\x30\x07\xc1\x71\xc1\x58\x13\x43\xad\xa9\x0f\x35\x4a\x29\xad\x87\xa5\xc3\xbd\x15\x7e\xce\xbb\x4e\xe7\x12\x5e\xaa\xf2\xf6\xeb\x6f\x57\xf6\xcd\xce\xdf\xcf\x74\x57\x6b\xb5\x7e\xd2\x6a\x0f\xc2\x63\x12\x27\xa4\xb4\xfd\x5e\x53\xef\x8f\x49\x34\x52\x39\x83\x12\x36\x0e\xec\xa6\x7c\xf6\x5c\x9d\xd2\xd3\xa8\x48\x02\x09\xaa\x7c\x4e\xa7\xca\x74\x3e\x59\x92\x75\x5d\xcf\x7a\x3f\x33\x3e\x32\xd4\x01\x45\x1e\xe5\xac\x66\x85\x76\x5d\x7b\x8b\x6d\xc6\xe2\x46\x06\x8d\x8c\x06\x1d\x33\x94\xd4\x10\x09\x14\x26\x93\xe8\xc4\x19\x07\xa3\xb1\x43\x16\xd9\x11\x9b\xed\xb4\x49\x74\x42\xeb\xa6\xb9\xb5\xed\x1e\x56\x25\xf7\x36\x27\x0b\xe3\x94\xc2\x87\x61\x3b\x38\x33\xcd\xbb\x85\x9d\x3b\x8b\x4e\x3c\x77\xa1\x90\x22\x1a\x2a\x0b\x81\x08\x9b\xf3\xe9\x4c\xff\xe1\x62\xbd\xe3\xb9\xfb\x06\x40\xbd\xf7\xd1\x8d\xed\xbc\x26\x26\xf3\xa9\x30\xdc\x9c\xdb\xc4\x64\x3e\xad\x5d\xb8\x89\xc9\x7c\x6a\xe0\x54\x20\x4a\x9e\x53\x42\xb0\xc9\xca\xac\xe4\x42\x12\xa2\xbe\x82\x84\x48\xe6\xbd\x25\x0c\x5e\xd7\x19\xbc\x70\xa6\x7c\xce\x36\xa6\x7e\xa6\x8d\xcb\xa7\x28\x0a\x94\x52\xc1\xb7\x16\x36\x93\xf2\x54\x6a\xfa\x19\x10\xbc\xc2\x52\x30\x8b\x75\x3e\x81\x37\xbd\x5d\x57\x6a\x9d\x6a\x57\x5a\x6a\xab\x4a\xed\x9a\x92\x24\xf1\x47\x44\xd3\xbb\x78\x4a\x87\xff\x9e\xa7\x06\x66\x95\xc0\xad\xe7\xbb\xdf\x8a\x9f\x79\xf1\x4f\xef\xcf\x93\x71\x49\xa0\xcb\x8d\x8d\x6d\x1e\x1e\x2a\x48\xde\x9c\xf8\x69\x4a\x42\x74\x8f\x2b\x09\x8b\xb9\xe5\xd9\xfb\x32\xe8\xd9\x7b\x63\x02\x3d\x9f\xae\x7e\xa8\xb6\x4e\x57\xf2\xdc\xe3\x65\x08\x0f\x0f\x1b\x43\x06\xed\x21\xf7\x11\x9c\xcf\x28\xb6\x68\x4c\x88\x09\xdb\xb0\x47\xe3\x02\xcb\x15\x84\xa3\x86\x0c\x96\x26\xa3\x9e\x65\x03\x58\x32\x07\x1a\x5a\x2d\x7b\x4a\x23\x51\xbe\xa1\xe7\x66\xf6\xcb\x33\x18\x90\x59\x3a\xc6\xec\x53\x7f\x11\x4c\xe7\x53\x11\xe3\x2c\x0a\xd9\x37\xa3\x54\x2f\x8a\x26\xc4\x0f\xcf\xa0\x3b\x8b\xc9\x20\xe8\xfb\x29\xe9\x18\x34\x39\x40\x50\x9a\x9f\xfd\x71\x74\x44\x06\x30\xc3\xfb\x80\x08\x0b\x9c\x59\x02\x31\x48\x1e\x60\x8b\x0f\xe0\x5d\xde\x76\x8a\x3b\xf7\xea\x44\xf3\xc8\xcc\x4f\x12\x78\x28\x6b\x7e\xc8\x1c\x72\x92\x46\x01\x15\xba\x2c\x0a\x51\xa7\x7b\xc0\x30\x0a\xc2\x20\x0d\xfc\x89\x08\x65\xc4\x4e\xf0\x15\x45\x89\x84\x77\xf9\x3b\x5d\x55\xd1\xf5\x09\x27\x1e\xe1\xae\x49\x0d\xf3\x8e\x22\xda\xb5\xbc\xf9\x16\x7e\x77\x18\xd5\x1c\x90\x68\x3a\x20\x5a\x26\x82\x71\xa9\xa0\x5d\x01\x8f\x53\xc8\x2e\x21\x63\x11\xa1\x58\x48\x2a\x5e\x9b\x16\x2f\x4b\x02\x84\x27\x4f\xc0\x52\x6f\x1d\x93\x2b\x79\x84\x31\x6c\x26\xcd\xa8\x82\x37\xf1\xeb\xf8\x78\xd4\xad\x5a\x8d\x55\x7e\x13\xcc\x70\x4f\x14\x2d\x71\x89\x11\xe2\x20\x76\x9e\x65\x8c\x28\xc6\x32\xb7\x58\xc8\x2e\x89\x07\x8b\xfd\x9e\xb9\x4a\x40\x64\x35\xc2\x6b\xe1\xd5\x0c\x2c\x8e\x1e\x99\x9c\x0a\x02\xb3\xca\x12\xb0\x92\x79\x82\x52\x83\x8e\xb0\x34\x62\x71\x08\xd9\xd5\x41\x93\x60\x1a\xa4\x89\xdd\x50\x91\xb0\x34\xea\xcb\xfb\xa1\x66\x2c\xce\xe2\xf2\x1e\x28\x8d\xe3\x25\x65\x01\x27\x9c\x03\xdc\x59\x48\x86\xd6\x02\x33\x90\xd8\x75\x01\x3b\x1b\x2f\x8b\xb3\xa0\xf0\x51\x12\x77\x42\xe9\x41\xb3\x8a\x62\x66\x15\x04\xef\x93\x8d\xdc\xcf\x2d\x81\xb7\x9e\xef\x0a\x36\xda\xd9\x0f\x4e\xa7\xbd\xa8\xec\xbe\xb4\xbd\x0d\x29\xf9\x5e\x8f\x47\x73\x2a\xbf\x92\x92\xac\x2d\x77\x4f\xcb\x4b\x45\x4f\x71\x3e\x6f\x97\x8b\x47\xf8\xfc\x3c\x98\xa4\xf5\x20\xe4\xfc\x16\x93\x21\x89\x49\xd8\x27\x49\x43\xde\x6b\x36\x8b\x89\x3f\xa0\x6c\x2d\xb1\xe4\x0f\xb7\xf9\x43\x23\x48\xee\xe0\x91\xf6\x07\x32\x2b\xb4\x95\x0f\xde\x7e\xf6\x6a\x81\x60\x08\x0f\xb1\xba\x87\xcc\x73\x71\xa8\xc9\xf3\x87\xbe\x68\xe2\x43\x88\x30\xe0\x2f\x44\xb1\x1a\xf6\x65\x82\x77\x5d\xdc\x63\xf6\x9e\x8c\xcc\x29\xbc\x0d\x33\x22\x46\x0a\x3b\x21\x64\x1e\xa6\x31\x62\x62\x20\xa5\xa1\xe4\x30\x3e\x7b\x88\x4e\xa0\x0f\x33\xb2\xc7\x18\xf6\x7c\xf8\x21\x0f\x72\xa6\xe2\xdd\x20\xbe\x3c\x79\xa2\x77\xa2\x4a\xc5\x2e\xbb\x7e\xdd\xca\xd1\xfa\xc6\x0d\xde\x1a\xf1\xd0\xcd\x66\xa1\x12\xa5\x88\x65\x0d\xcc\x0a\x98\x76\x95\xd0\xfb\x2b\x4c\xd9\x6f\xf9\x65\x57\xf8\x79\x9b\x9b\x22\xf8\xa3\x9f\x90\x7b\x38\xf3\x90\xb2\x09\xdb\x73\x5b\x5a\xe6\x72\xa0\xbb\x5b\x1b\x5a\xbe\x07\x51\x9c\x7e\xbe\x8c\xc7\x77\xb7\xf4\xfa\xbf\x82\xbe\xfa\x25\xa3\xc6\x13\x95\xe3\x0d\x33\x31\x79\x4b\x5c\xf3\x55\x06\x79\x4b\x8c\x32\x8c\x19\x9a\x96\xa2\xe0\xae\xac\x85\x44\xf1\x80\xc4\x9f\x3f\x65\x5a\x48\x34\x4f\xd9\x89\x00\x18\xcd\xfd\x78\x90\x9c\xab\x72\x3c\x11\xb1\xb1\xfb\xd1\x64\x42\x18\x6b\xd2\xfa\xb4\xd7\x34\xe2\xb3\x3f\x41\x1b\xab\x31\x61\x8b\x70\xa9\xdd\x03\x0e\xa8\x7b\xf0\x84\xb9\xfd\x76\x0f\xce\x44\x31\x92\xb0\x59\x5c\xbe\xa5\x11\x24\x54\x55\xea\x9d\x1a\xc0\x54\x41\x6c\x13\x2b\x85\x19\xf9\x3b\x6d\xb0\x84\xf2\x70\x35\x0d\x80\x96\x5f\x32\xfd\xbf\xc3\xa8\x67\xa9\xf6\x3a\x0a\x51\x87\x57\x5c\x34\xe5\x63\xec\x54\xd9\xa2\x8e\xe4\x69\x4b\x26\x8a\x00\x95\xb7\xb5\x7c\x6d\xe8\x8a\x9e\x3f\x70\x14\x7b\x59\x3a\xa3\xdb\x5a\x90\x55\x31\xfd\x73\xde\x36\xd0\x94\x63\x8f\x4f\x9e\x47\xe4\xd4\xd1\xfa\x4d\x57\x09\xfa\x31\x45\x21\xf0\x0b\xf1\xd4\x20\x89\xb4\x5c\xb0\x69\xf1\xc1\xd2\xe7\x53\x71\x6f\x3d\xcf\xf3\x21\x54\x45\x3d\xd5\xb6\xac\xd2\x81\x2a\x12\xad\xda\x06\xae\xb4\x38\x50\x45\x28\xd5\x36\x97\x50\x67\x78\xfb\xad\x11\x3d\x56\x8d\x51\x39\x93\x4b\x24\x99\x70\x77\x80\xd9\xb3\xcc\x40\xe9\x99\x61\x68\xe6\x95\xdd\x29\xea\x2b\x9b\xb0\x39\x53\x14\xc8\xbe\xe7\x0b\xda\xcf\xc2\xf2\x27\xe4\xae\xdf\x2f\x5d\xad\x6c\x6e\x99\xf3\xf0\x97\x83\xa3\x72\xd1\xb7\xfa\x5a\x65\xea\xcf\x94\x84\xd0\x97\x2a\xa2\x67\x21\x19\x47\x71\x3a\xf6\xc3\x97\x27\x34\x94\x80\x58\x79\xdd\x71\xde\x68\x9f\xfa\xb3\xd9\x92\xd1\x9e\x1d\x42\x26\xbf\x17\xeb\xf4\x72\x0c\x6a\x1d\x62\xe9\xc3\xec\x36\xb0\x99\x5a\xa5\xc9\x18\xac\x6d\x8c\xa2\xbb\x06\xb2\xd7\x2f\x33\x80\xb9\x42\xca\x47\x0f\x55\x45\xcd\xd1\x98\x2f\x28\xf8\x7b\x65\x0d\xf5\x2d\x7f\x56\xc0\xec\x2b\x87\xac\x5e\x89\x03\x13\x1c\xce\x0f\xf9\x41\x92\x79\x42\x12\x78\xc8\x87\x6b\xfc\x90\xf2\x0b\x53\xfa\x68\x57\x52\x60\x4a\xee\x63\x79\xec\xd1\x87\x78\xce\x83\xdf\x82\x90\x28\xa9\xc6\x46\x79\x22\x77\xe9\x83\x18\xfa\x51\x1c\x93\x64\x16\xe1\x2d\x7f\x14\x1e\x5b\x8a\x5e\x6e\x09\x4e\x71\x29\xe1\x60\xd1\x02\x93\x83\x55\x6b\x54\x33\x96\x33\x30\x6f\x60\x01\xcf\x72\x31\xc8\xd7\xa7\xa2\x3e\xc5\xb1\xe5\x6b\x4e\x96\x40\x31\xb0\x64\xb1\x7d\xb5\x86\xe4\x7e\xc7\x75\xc1\x67\x6c\xbd\xa8\x16\x3c\xc6\x7b\x43\x2e\x7f\xb4\x85\x0f\xe6\x28\xe7\x2a\x86\x79\x01\x63\x3d\x7f\x24\x61\xde\x9e\xd7\x93\x3e\x61\xf7\x38\x96\xe9\x5b\xdb\x9a\x84\xfc\x4a\x42\x06\xd0\x3b\x35\x94\x26\xaa\xeb\x33\x58\xea\x8a\xd6\x19\xbb\x18\x3d\x20\xa8\x71\xf8\x6a\x55\xe0\x87\x38\x8f\x50\x58\x78\x7a\x29\xc5\x85\x07\x76\x71\x3a\x26\x53\xc1\x5c\xf7\x86\xf0\x90\xcd\x34\xb8\x22\x98\x87\x78\xc0\x6a\x18\x90\x81\x83\xe7\xa2\xb8\x55\x84\xd6\xc9\xb5\x93\x20\x04\x5f\x36\x85\x71\x0b\xbc\x43\xab\x3a\x09\xf0\x32\xf9\x75\x76\x46\x6b\x78\x0a\x7e\xa8\x06\x45\x65\x40\x92\x7e\x05\xa5\x38\x7d\x92\xc5\xa1\xe2\x8b\x74\x05\x55\x31\x22\x05\x17\x0d\xcd\x11\xb2\xc2\xf0\x10\x32\x9f\xaf\xad\x28\xbf\xf3\x47\x45\xc3\x46\x61\x01\xda\x10\x96\x1f\x9f\x96\x97\xe2\xab\x2c\x43\x8f\xd4\xd4\x41\xd6\x78\xa5\x40\x62\x2b\x09\x9d\x4f\x79\xaf\x9d\x66\xc6\x99\x30\x95\xe9\x33\x85\x26\x5b\x82\x10\xad\x0c\x51\x8c\x80\x1e\x32\xdc\xb2\xc3\x70\x35\xad\x62\xc9\x1c\x12\xf5\x1e\xdd\x51\x2a\x18\x2b\xde\x90\x1a\x92\xc8\x94\x8e\xf5\x4c\x14\x76\x2e\x8f\x1c\xec\x1a\x44\x11\x09\x5f\x80\x41\x6c\xbe\x2c\x33\xe2\xab\x2e\x16\x56\x30\x21\xc9\x39\x2f\x3b\xce\x2c\xad\x5e\x6e\x5a\x72\x74\xc4\x79\x9a\xad\xec\x4d\x85\x41\xe1\xd9\xc5\x94\x1d\x03\xd7\x82\x8b\x74\x55\xf4\x7b\x65\xbc\x61\x08\xb2\xce\x13\x00\x0c\x23\x57\xa6\x34\xac\x83\xc5\x73\x77\xa0\x4a\xc7\x49\x15\x6e\x43\xdd\x83\xb6\x0c\xb9\x2e\xcc\x39\xcd\x26\xbc\x19\x2c\xd8\x0d\x17\x0f\x51\x3e\xff\xff\x28\xa7\x3c\x84\xde\x7c\x24\xee\xee\xf8\xff\x3f\x00\x12\x8e\xa8\x64\x27\xd3\x1e\x19\x0c\xd8\xe0\x7d\x7d\x10\xf5\x08\xf8\xb3\xd9\x24\x60\x67\x22\x93\x35\x7e\x9b\xb3\x9f\x42\xdf\xc7\xc9\x2e\x48\x1d\x76\x94\x05\xfa\x24\xc6\xcb\x28\xfb\x41\xdc\x9f\x4f\xd9\xc5\x0b\xec\xaa\xe3\x59\x1c\x1d\x07\x03\xe6\x14\x82\xa7\xe6\x99\xe8\x19\x46\x31\x83\x27\xf8\x13\xc5\xcf\x43\x64\x91\x87\x0d\x78\x40\x08\x8c\xd3\x74\x96\xb4\x9b\xcd\x51\x90\x8e\xe7\xbd\x46\x3f\x9a\x36\x1f\xf9\xc9\xf8\x88\x84\x7e\xd2\x64\x27\x68\xfa\x51\x4c\x9a\xb3\xf9\x64\xd2\xf4\x5a\x9b\x3b\x0c\x20\x65\x7a\xf4\x4b\x1e\x90\xd4\x0f\x26\x54\x00\x40\xb3\xc9\xbe\xbd\x37\x16\x11\x9b\xd8\xdd\xaa\x78\x54\x54\x13\x79\x41\x08\x5f\xdd\x45\x4c\xd8\xb8\x66\x74\xe1\x20\x0c\xa4\x7a\xf3\x51\xd2\xe8\x8f\xe3\x68\x1a\xcc\xa7\x8d\x28\x1e\x35\x67\xcd\xe3\xdd\x66\x90\x24\x73\x92\x34\x59\xd5\xb7\x83\x41\x67\xcf\x2d\x44\x88\xf7\x27\x1f\x36\x8c\x79\xea\x7c\x80\xe0\x5b\xf1\x14\x94\x19\xb5\x05\xf3\xd0\xf3\x47\x12\x0e\x92\xa5\x06\xb8\x9d\x1d\x6d\xfa\xb9\xc3\xf0\x49\xa4\x55\x3c\x52\x53\x47\xd1\x0c\x70\x71\xa3\x55\x81\x38\x5d\xcf\xcb\xdf\xe2\xfc\x97\x14\x98\xcc\xf0\x55\x2c\x2f\x95\xd4\xe0\x7a\xaa\xb6\x62\xa3\x62\x80\x21\x72\xbd\xd3\x31\x97\x72\xdc\x86\x7d\x2f\xe1\x21\x09\x85\xed\x15\x73\x4a\xdb\xa0\xa3\x1d\x38\x9c\xdc\x4b\xde\x9e\xe3\x85\x37\xdc\xf6\xdd\xe9\xe0\xa5\x1c\x99\x3c\xef\x92\xe1\x84\x2c\x82\x63\x62\x64\x64\xb8\x99\x39\x65\xa7\x8a\xfe\x95\xeb\x5e\x89\x61\x94\x8e\x75\x0c\x19\x69\x4b\x30\xc4\xbc\x1c\x43\x96\x31\x8f\x21\xe6\xd1\x31\x54\x19\xd9\x34\x63\xe6\xcc\x63\xc8\xdd\x3b\xd4\x6d\x10\xd6\x75\x55\xef\x8d\x1b\x70\x5d\x2f\x47\xdf\xf5\x96\x4a\x6b\xe1\x2d\xd1\x17\xdc\xb4\x48\xff\xac\x4c\x4e\xa3\xe9\xe2\x5d\xa1\x2e\xeb\x2a\xaa\xb9\x00\xb0\xc8\xb6\x1c\xac\x59\xf0\xba\xc1\x20\xcb\x33\x5f\x37\x3b\x3f\x67\xdb\xf0\xf6\x33\xf7\x67\x71\xe8\x12\xfd\x4c\xf3\xb3\x84\x64\x84\xbb\x59\x44\xb8\x7c\x4e\x03\xe9\x0c\x57\xca\xba\x8a\x6a\x2e\x00\x2c\xb2\x2d\x07\x9b\x21\x5c\x96\xca\x4b\x32\x5f\xcf\x12\x35\x43\xb8\xba\x57\xb8\x1d\xe2\x2e\x15\xc7\x52\x28\x14\xc8\xe3\xe7\x8b\xdf\x28\xad\x2b\x8b\x34\x26\xd3\xf9\xb4\xd4\xba\xbc\xad\x59\x77\xbf\x90\x96\x19\x62\xa4\x11\xf8\x22\xa6\x5a\x2a\xe3\xe7\x29\x61\x52\x53\xec\xc9\x32\x06\x51\xab\xd8\x06\xae\x10\xf8\x8a\x36\x48\x00\xdd\x78\xa9\xde\x8e\x1b\x05\xa7\xa8\xef\x3f\x94\x62\xe4\x21\x8b\x75\x40\x49\x4b\x06\x72\x52\x48\xe8\xda\xba\xcf\x1e\x83\xb0\x4f\xc0\x6d\x78\x0d\x17\xdf\xa7\x54\x33\x89\xdf\x19\xc2\x21\xbe\xf6\xfd\x94\x8c\xa2\xf8\x14\x3d\x0d\x56\x5b\xef\xe6\x2d\x37\x72\x76\x58\x37\x27\x06\xa3\x89\x2c\x2b\x59\xf8\x74\xf9\xcf\x11\x3d\x6c\x4c\xfd\x85\xd5\xdd\x74\xa0\xe5\xc0\xae\x03\xdb\xa8\x1b\xae\x53\x0d\xa1\x73\x0b\x76\xcd\x5c\xc6\x37\x49\x00\x73\x6e\xa1\x19\x11\x51\x63\xb7\x84\x25\xe1\x2d\x39\xda\x2a\x98\xdd\x85\x76\xdb\xe0\x0a\xb1\x90\x16\xbd\xea\x70\x36\x60\x79\x8d\xcd\xa7\x22\x2e\x9e\xfa\x8b\x02\xc6\x7d\xbe\xe8\x77\xc6\x4d\x36\x6b\x6b\x6b\x6c\xe1\xd4\x60\x78\xdc\xe7\xcb\x1a\x4b\x82\xa9\x1c\x1e\x92\x84\xdd\xfc\x59\x71\xf8\xa2\x63\x32\x27\x6d\x0c\x2b\xb2\x86\x76\x54\x3a\x14\x0e\x47\x24\x7d\x3b\xe8\x93\xf7\x82\xfe\xd1\x57\x99\xc6\x51\xb6\x48\xde\xa3\x65\xce\xa9\xb5\x3a\x22\xa9\x02\x55\x65\x15\x93\x70\x3e\x25\x31\x55\x09\x59\xed\x74\xc0\x8c\x48\xaa\x45\x2d\x1a\x91\xd4\xca\xd8\x68\xf3\x88\x35\x0c\xd8\xcc\xc8\x40\xdb\xb1\x02\x4a\x26\xa0\xab\x47\xcb\x4c\xb9\x10\x6a\xaa\x18\x86\x1a\x7e\x23\x9a\xfa\x41\xf8\x22\x09\xa7\x55\xa3\x10\xcd\xb2\xea\x2a\x5e\xd7\x2f\x91\x55\x79\xd6\xd2\x86\x40\x07\x0a\xb3\x98\xe9\x39\x3e\xd7\xb7\x90\x71\x30\x60\xa8\x80\xc1\x7b\x91\xd8\xdb\x36\x82\xf4\xaa\x37\xcc\xc6\x36\x62\x22\x0c\x2b\xeb\x40\x40\x33\x20\x0c\x3f\x8e\xd9\xbd\x68\xec\x95\xe2\x86\xc7\xe3\xd8\x2b\xd5\x02\x59\xb8\x1f\xf6\x4e\x0c\x34\x20\x8d\x4f\x69\x45\x22\x1a\xef\x61\xc0\x2c\x6c\x5d\xb1\x11\xce\xeb\x3c\xb0\x6c\x07\x0e\x93\x7d\xb8\x6e\x61\x05\xd6\x21\x0e\xdb\xa0\x11\x92\x45\x6a\xd9\x76\x63\x10\x85\xc4\xde\x57\xb5\x53\xec\x28\x66\xcc\xbd\xff\x30\x11\xe1\x51\xf8\xed\x6b\x37\x6e\xb0\xaf\xf2\xb2\xb4\x0e\x6d\x10\x8b\x2b\x03\x67\x70\x06\x7d\x0c\xb0\x63\x91\x38\x46\x48\x03\xd9\x28\x6c\x00\x89\x63\x9a\x6d\x18\x84\x18\x6b\xe7\x43\xde\x0c\x74\x9d\x38\x0c\x11\x7a\xd0\xad\x30\xfe\xac\x1c\xd8\xc6\x9b\x65\x9b\x45\x69\xa1\xc3\x81\xcd\x6f\xce\x3c\x24\xac\x7e\xc1\xdb\x3e\xab\x49\xc4\x4d\x92\xdd\xa3\xfa\x80\x96\xc7\xee\x6b\x88\xbd\x71\x3f\x8e\x6d\xfa\x45\x8b\xe6\xa9\x3b\x77\x64\x48\x4b\xd7\x58\x8c\x5f\xb3\x05\x0b\x7b\x5d\x82\xfa\x50\xbb\xeb\xf3\xbd\xd3\x19\xe1\xd7\xa5\xde\x0b\x8f\xfd\x49\x30\x00\x3f\x4d\xe9\x04\xce\x6c\xbe\x2a\x64\x52\x18\x85\x75\xac\x99\xae\x97\xc5\xf5\x8a\x15\x84\x7a\xb6\x0f\x67\x94\x38\xa8\x33\x7c\xf6\xf7\xd9\xdf\x2b\xf9\xb7\x0e\xbf\x36\x0c\x26\xe4\x9d\x63\x12\x1f\x07\xe4\x44\x1e\x90\x21\x90\x06\xfd\x23\x61\xc4\x88\x86\x90\xf4\x7d\xaa\xee\x7d\xf6\xf7\xd9\xdf\x2b\xf9\xb7\x0e\xbf\xe6\xcf\xd3\x71\x14\xc3\x22\x98\x90\x6d\xcf\x73\xc0\x8f\xfb\xe9\x78\x1e\x7f\xc6\xb4\x9f\xfd\xbd\xa2\x7f\xeb\xf0\x6b\x03\x2a\x6b\x5b\xae\xb7\x55\x77\xf7\xea\xde\xce\x67\xcc\xfa\xd9\xdf\x2b\xfa\xb7\xde\xe4\xab\xac\x79\x1a\x4c\xca\xcc\x0c\x1b\x5b\x3b\xd2\x34\xe1\xc7\x41\x3a\x9e\x92\x34\xe8\x97\xd9\x24\xb6\xdd\x82\xcc\x2d\x5c\x0a\x85\x29\x89\xa3\xd9\xbb\x2c\xef\x1b\x64\xe8\xcf\x27\xa9\xa5\xe5\xa2\x05\xe5\xfa\xa1\x24\x7b\xd4\x7b\xa4\xe9\xff\x51\xef\x11\xda\x90\x7b\x8f\x1a\x6a\xc1\x0a\xb7\x31\xbd\x0d\x1f\xc2\x80\x95\x6a\x63\x02\xd5\xde\xf5\x0a\xd2\xe8\x4e\x14\x26\xf3\x29\x55\xf4\xd5\xb2\x64\xe9\x7a\x45\xdd\xc9\x02\x1d\x70\xe9\x74\x14\xd3\xa6\xc9\x4c\xc2\x7c\x55\x76\x5f\x0b\x16\xe8\x06\xdc\x49\xa3\x1b\x1c\x68\x2b\x27\xfa\x49\x5b\xba\xf0\x54\x86\xc7\x30\x8e\xd0\xfe\xc5\x56\x21\xca\x68\x29\x35\x3b\x1f\x90\x5c\xc7\xfe\x84\x79\x3e\x4c\x83\x50\xb3\x60\x62\x04\x3e\xd3\xe4\x67\x5e\xff\x0f\x1f\xbe\xcd\x37\x8f\xa6\x41\xc8\x79\x03\x0f\xa7\xe8\x60\x8a\xf3\xfb\x0b\x3d\x7f\xa6\x0a\x61\x7f\x94\x36\xcb\xd7\x43\x89\xa8\x69\x1d\x1c\x91\xf4\xab\x74\x55\x76\x8f\x7f\xb5\x0e\x63\x32\x54\x3b\xf3\xf4\x0d\x99\xc8\x30\x07\x60\x26\x07\x84\x2b\x2f\x20\xf6\x1d\x96\x59\xde\x59\x0f\x88\xa3\x48\xf5\x0e\xa4\x8f\x26\xae\x02\xdf\xc2\x12\xd3\x20\x74\xe4\x26\x35\x4d\xc5\x12\xcc\x64\x88\x9b\xa2\x64\xc1\xce\xdc\x8a\x3b\xd8\x69\x45\xb7\x68\x06\xb5\xf7\xa5\x80\xd1\x62\x59\x50\xc2\xb2\xa3\x2c\x9f\x5d\x51\xc4\x91\x19\x0f\xd0\x74\x99\xeb\x5c\xdc\xc8\x4b\xc9\x0c\xe4\x75\x3c\xc4\x4f\xd0\xde\xab\x45\x58\xec\x91\xf4\x84\x90\x10\x75\xfc\xc4\x61\x91\xc9\x3d\xd7\x81\x16\xfd\x7f\xab\xac\xbb\x21\x8e\xe6\xa3\xf1\x03\x0a\x5c\xeb\x46\x4c\x64\x55\xca\xc5\x03\x3a\xe0\x0c\xc8\x71\x80\x1b\x9d\xdc\xd7\x6b\x10\x0c\xf9\xe1\x01\xfa\x95\xe2\x49\xab\xbf\x13\xcd\xc3\xd4\xa8\xee\xf3\xc2\x03\x1f\x03\x2e\xbc\x21\x82\x3c\x01\xc0\xeb\x34\x41\x96\x14\x91\x98\x64\x18\xa8\x28\x86\x30\x32\x61\x51\x0e\x19\x51\xdc\xd1\x0f\x06\xb9\xe7\x4d\xbf\x9f\x46\x31\xbc\xae\x25\xc1\x10\xd3\x0c\x1e\x94\x8d\x7e\xef\x42\x04\x3d\x89\x18\x6e\x39\x86\x7d\x33\x8a\xa7\x7e\x4a\x89\x67\x49\x32\x3a\x66\x13\x9d\x1c\x96\x6a\x17\x55\x91\xfe\x66\x47\x5d\xe2\xaf\xf6\x62\x38\xbb\xb0\xbb\x61\x47\x41\x8a\x64\xa5\x8c\xac\xc9\xd5\x06\x97\x70\x8d\x11\x49\xdf\x90\x99\x14\x68\x74\x94\x40\x97\x00\x02\xe8\x8e\xa9\x9a\x65\xf6\x33\x6d\x31\xf2\xd9\xd4\x9f\x4c\x48\x92\xf2\x48\x5b\x9c\x42\x18\x18\x1a\x7a\xc1\x68\x44\xb8\x43\x83\xf4\x65\x9a\xfa\xa3\x30\x48\xe7\x03\x76\x5a\x2c\x0b\x97\xe3\x4f\x1f\xdf\xc5\xea\x3b\x1a\xc7\x35\x41\x1e\xf0\xa4\x9c\xaa\x1a\x29\xb0\xfe\xda\x98\x84\xe0\x33\x91\x31\xc2\x1b\x05\x06\x78\x76\x24\xf2\x53\xe1\xf4\x85\xbe\x59\x18\xdf\xa7\xdf\x9f\xc7\x7e\xff\x94\xe2\xc4\x1d\x48\xa6\xfe\x29\x65\xa6\x93\x38\x0a\x47\x1c\x11\x7f\x4a\xc2\xc1\x03\x0d\x1b\x8d\xb2\xd7\x3b\x1d\xf0\xe0\x76\x31\x7d\x79\x75\xa7\xec\x28\x6a\x9f\x04\x13\x4b\x35\xaa\x09\x6e\xc3\xdd\xb2\xa1\x96\xeb\x6d\x87\x7f\x69\x5f\x12\xaa\x57\x06\xd4\x53\xbe\xe6\x43\xc9\x86\x65\xcc\x21\xab\x31\x9b\xef\x94\xd2\xdf\x70\xe9\x36\xc7\xec\x6d\xbd\xbe\x36\x28\xc4\x55\xb2\xad\x8b\xb1\xbe\x21\xc6\xd8\x20\xc7\x88\x4f\x69\x76\x7e\x01\xf2\xc1\x9c\xd6\x90\x46\xf9\x1d\xaa\x52\xf9\xc5\x4a\x42\xc9\x9c\x35\x27\x60\x5e\x61\x56\x04\xb8\x40\xb4\x48\x29\x26\xa1\x62\x30\x3d\xca\x5b\x42\x14\x9c\x2b\xdc\x56\x97\x6c\x99\x39\x32\xfb\x57\x2c\x7c\xde\x0b\xfa\x47\xef\x0c\x1f\x04\xe1\x68\x42\xd0\x7a\x2e\x7c\x35\x24\xee\x19\x51\xa4\xb9\xb9\x25\x6f\x4e\x4a\x05\x09\xfd\x18\xf9\xa9\x76\x5e\x40\x0c\x60\xe8\xb0\x1d\xf7\x66\x33\xd3\xa9\xd3\x60\x30\x98\x10\xb5\x5b\xca\x11\xc6\x82\xfc\x9b\x3c\x85\xc7\x65\x1f\x43\xe1\xc6\x8d\x22\x14\xf9\x48\xed\x25\x5f\xc5\x6b\xbb\x59\x5c\x92\x5e\x62\x7a\x72\x60\xf4\x1e\x96\xe5\xa6\x7e\xce\x91\xcb\x3a\xc4\x37\x19\x47\xf3\x09\x15\xe4\x52\x68\x48\xa1\xc6\xf9\x4f\x9b\xbf\x82\x84\xcb\xbe\x98\xc9\x31\x8f\x03\xe4\x2d\x37\x46\xca\x0a\x12\x98\x9f\xf3\xaa\x83\x27\x30\x06\x45\x8b\x15\x64\x01\x8b\x9e\xc0\x48\xda\x44\x24\x6c\x87\xfd\xec\x67\x8f\x42\x72\x32\xdc\xca\x90\xe1\x5d\x71\x6f\xa3\xe2\x78\x21\x47\xe5\x98\x30\x5a\xcc\x0f\x77\x30\xea\x88\x97\x20\x81\x51\x4c\x30\xc8\xa1\x41\x16\xd9\x96\x2c\xb6\xba\x6b\x9e\xc2\x51\x79\xed\xc8\x89\xae\x08\x82\xa5\x06\x1e\xa5\x1c\x34\xa1\xc5\x7c\xe2\xb5\x83\x9f\x85\x1c\xb3\x1c\x1d\x39\x8f\xb2\x6c\xf7\xb8\x9b\xe7\xb9\x15\x0b\x01\x8b\xfb\x39\xb4\xdf\x71\x99\xd4\xe8\x47\xd3\x59\x94\x10\xdb\xd2\xd2\xa6\xfe\xcc\xb6\xd4\xe6\x47\x98\xdd\x01\x2c\xea\xf1\x64\x3e\xb5\x18\x46\x25\x2c\x25\x59\x22\x84\xba\x8e\x3b\xe7\x04\x7e\x5c\x40\xe2\x10\x53\x0d\xd5\x10\xdd\xc3\x90\xa2\x28\xdb\x66\x2f\xd7\x2f\x4b\x85\xac\x5a\x14\x94\xad\x0d\x70\xd5\x61\xe8\xf6\x45\x60\xe4\x5a\xa1\x6c\xc9\xb0\x0c\x4c\x89\x70\xbe\xb4\x7c\xbe\x94\xf2\x29\xdb\x72\x61\xe5\x53\x38\x55\x4b\xf1\xe4\xe4\x29\xc8\x75\xf7\x1c\x49\x0a\x66\x00\x29\x81\x51\xfd\xa4\xeb\x17\x5a\x6c\x15\xe9\x9f\xc3\x9c\xae\x45\xf9\xf1\x54\xb1\xdb\x78\x0b\x36\x99\x4b\x06\x4f\xef\x6e\x1e\x98\x2e\x72\x70\xdb\xfc\xd8\xa6\x0a\xeb\x9a\x29\x7e\x2f\xa8\x5c\xeb\xf3\x8c\xa9\x5c\x5b\x94\x71\xe8\x00\x08\xe9\xc0\xcc\x0c\xd5\xf3\x15\x6e\x81\xd8\xeb\x30\x25\x83\xc0\x9f\x9c\x37\x51\x45\xc1\x40\xb5\x06\x55\x50\x97\xb6\x22\x08\x13\xe1\xe1\x2b\xf8\xd3\x01\xd7\x98\x64\x28\x3c\x6d\x81\x48\xd5\x7a\x4a\x46\x8a\xfe\xad\x22\xc9\xe7\x6a\xb2\x8d\x7d\x5a\x3a\xb7\xae\x9d\x3f\x89\xb0\xbb\xf6\xac\x25\xe2\x86\x31\x8a\xed\x70\xc9\x8a\x55\x4e\x83\x70\x9e\xb0\xb0\x1f\xd1\xca\x55\x61\xa1\x73\xe4\x17\x42\x94\x79\x94\xd0\xc2\x5a\x93\x34\x0e\x66\x2b\x54\x84\xf9\x24\x10\x6f\xdb\x14\xe9\x3d\x32\x89\x4e\xc4\xd2\x48\x69\xa3\x3c\xbf\x62\x1b\x39\x77\xd2\x42\xf3\x59\x51\x09\xce\x65\xb4\x5c\xae\x04\xee\x95\x89\x42\x5a\x9d\x35\x09\xab\x46\xb5\x23\xde\xfb\x5a\xee\x5b\x9a\xf8\x55\x9d\x8c\x6c\xc5\xe2\x4a\xa3\xe4\x09\x09\x19\x30\xcf\xde\x63\x9c\x69\x75\x1e\xcb\xe8\x32\x6c\x15\xd6\x30\x0e\x4f\x5e\x50\x18\xe4\x07\x09\xc5\x3e\x3b\xd3\x6a\x8d\xb8\x59\xde\x88\x09\x49\x12\xde\x88\xbe\x1f\x16\x36\xe0\x84\x08\xf4\xfd\xc1\x00\x92\x68\x4a\xe8\x43\x40\x6b\xf7\x27\x72\x10\x82\xd6\x2b\x38\x62\xc0\x85\xdb\x1a\x75\x8d\x71\xaf\x70\xa3\x6b\x2b\x9e\x89\x71\x96\xc1\x10\x0a\x90\x96\xdc\x36\x3b\xb0\x0c\x70\xd6\x60\xc3\xda\x4d\x7b\xa3\xcd\x04\xf8\x9a\xd0\xce\xdf\x0a\xc2\xb2\x05\xde\x0a\x83\x44\x4c\xf2\x0a\x29\x31\x54\xb4\x1a\xfc\x45\x49\x0d\xab\x2b\x11\x9c\x4a\x02\x38\x6d\x1d\xd5\x07\x0a\xd5\x01\xd6\xa1\xb9\xd9\xb8\x54\x3d\x70\xd4\xe4\x3e\xa5\xc4\xc8\x29\x08\x98\xa1\x5d\x62\x24\x7c\xd5\xd6\x5f\xc5\x2b\x2e\xd3\x57\xe9\xcd\x10\xad\x8f\x1b\xa6\x8d\x72\xb3\xd8\x46\xb9\x51\x6c\xa4\xdc\x2c\x34\x52\x6e\xea\x46\x4a\x45\x89\xc2\x69\xda\x33\xa7\x69\x6f\xd9\x34\xed\xd1\x69\x7a\x5b\x08\x34\x93\x58\x85\xc0\x5b\x26\xf0\xd6\x32\xe0\x2d\x0a\x1c\xfd\x8f\xf8\xc4\xf9\x96\x0c\x9a\x2f\xe7\x78\x4d\x88\x31\x92\x4b\x8d\x44\x93\xc5\x53\x7f\x61\x69\x72\x4b\x53\xc3\x0f\xb3\x36\x62\xa6\x28\x98\x66\xe3\xae\x60\xc6\x03\x49\xef\x5c\xb9\x22\x43\x72\x36\x8f\xde\x61\xfd\x28\xe6\x7d\x96\x83\xa4\x75\x20\xcd\xc5\xfa\x30\x9f\x8b\x77\x28\x95\xaa\x02\x58\xa7\xc3\x4b\x64\x56\x0a\x85\x4b\x7b\x56\x68\x89\x76\x27\x65\x55\xb3\x09\x5f\x20\xa9\x32\x19\xe7\x15\x2d\x41\x4d\x63\xd2\x80\x4e\x66\x12\x11\x35\x32\x1c\x1d\xd6\x47\xd9\x5a\x1d\x73\x8d\x6c\x82\x6c\x28\x19\x29\xa5\x64\x3e\x13\xff\x60\xe4\x63\x54\x2c\xc8\xc7\xed\xf1\x32\x56\x52\x52\xa6\x32\xe0\x4a\x08\xdb\x21\xe0\x4b\xc8\x35\x70\x1b\x1e\xac\x73\x15\x9c\xcf\xf1\x4a\xc8\x4b\xc3\x3e\xdc\xd6\x97\x7c\x31\xc1\xf8\x8e\x36\x5b\x54\x26\x74\xd2\x39\xe6\x8e\xa5\xfa\x9e\x92\xe9\x0c\xc9\x24\xc4\x96\x29\x21\xb6\x8b\x25\xc4\x56\xb1\x84\xd8\x2e\x94\x10\xdb\x9f\x49\x88\xd5\x24\xc4\xc6\x65\x45\x44\x91\x1c\xcf\x01\x5f\x4d\x46\x6c\xae\x24\x23\x36\x5f\xa2\x8c\x28\x5f\x68\x71\xfc\xea\xbc\x39\xb8\xdc\xea\x97\x2f\xb5\xdc\x2b\xb5\x91\xf0\x56\xd7\x20\xe4\xc3\xb3\xdc\xbc\x61\x48\x00\x66\xe4\x40\x34\xed\xc6\x30\x98\xa4\x24\xd6\x6a\x21\x61\x1a\x9f\x66\x6a\xc2\x34\xba\x24\xe3\x55\xde\xb8\xc1\x93\x6e\x0a\x82\xe7\x03\x9b\x5c\xa5\x60\x50\x5e\xd2\x5c\x46\xec\x38\x59\x05\x5b\x88\x8b\xdd\x62\x71\xb1\x53\x2c\x2e\x76\x0b\xc5\xc5\xae\x2e\x2e\x5e\xa1\x51\x9d\x1b\x04\x5b\x97\x1d\xae\x45\x42\x35\x07\x7c\xb5\xe1\xba\xbd\xd2\x70\xdd\xbe\xc8\x70\xed\xb2\x0c\x07\xc6\x00\x3c\x4f\xa4\x5d\xf1\x30\xcd\x8c\x99\xee\x41\xa3\x8f\xf1\xdb\xac\x02\x37\x88\x73\xa6\x54\x53\x35\x80\x3a\xb8\x8d\xbd\x3d\x73\x46\xb5\x1d\xd6\x68\x7f\x71\xf0\xfc\x83\x88\x22\x5e\x74\x54\x60\xd9\x31\x02\x5d\xea\x90\x69\x14\x3c\x26\xb6\x55\xa0\xc2\xdb\xfb\x02\x7a\x19\xe4\x55\xa0\x9e\x07\x71\x85\x53\x11\x66\x96\xf3\xeb\xd1\x25\x48\xfe\xac\xc8\xf6\xf3\x05\x67\x7d\x41\xc7\x9a\x56\xf0\x31\xe2\x6b\xd1\x67\xff\xf6\xdf\xfe\xf2\xf7\xfe\xe8\xd3\x1f\xfd\xe8\x93\x1f\x7c\xeb\xd9\xf7\x7f\xfc\xec\x77\x7e\xf8\xe9\xcf\xff\xfb\xb3\xbf\xfe\xcf\x18\x4f\x03\xad\x41\x6e\xc3\xdd\x33\xff\x76\xed\x8e\xdb\xf0\xf4\x63\x72\x62\x7d\x1a\xce\xa7\xdc\x50\xfc\xe9\x3f\xfe\xee\xd3\x6f\xff\xc5\xd3\x6f\xfe\xac\x28\xdb\x2c\x26\xfd\x00\x03\xb0\x7e\xf2\x3f\xff\xf1\xe9\x4f\xff\x4b\xa1\xeb\xc0\xb3\xef\xff\x98\x15\xd7\x96\x86\x0c\xa3\x70\x3e\x55\x92\x5b\xc1\xba\x1a\x9d\xcc\x6b\xe9\xa3\xa8\x86\xb7\x25\xb0\x6d\xba\x70\x3e\x6d\xa4\xd1\x7d\x51\x9f\x25\x6b\xb6\x0d\x63\xff\xd3\xdf\xfa\xf3\x67\xbf\xff\xd7\x8c\x96\xcf\xfe\xf0\x47\x4f\xbf\xf7\x5f\x3e\xfe\xc9\x4f\x9f\xfd\xaf\x1f\x7e\xf2\x1b\x1f\x7d\xf2\x3f\xfe\xe1\xe9\x9f\xfe\x3b\x73\x71\x6f\xd0\xce\xa4\x9a\xa0\x88\x5c\x75\x33\x70\xcf\xfe\xf0\x47\x19\x70\x4d\x51\xb7\xe9\x8d\xfe\xf1\x4f\xbe\xf9\xf1\x4f\xff\xf8\xe9\xb7\xff\xfb\x27\xbf\xf7\x5f\x3f\xf9\xc1\xb7\x3e\xfd\xc5\xf7\x3e\xf9\xe1\x1f\x3c\xfb\xfd\x8f\x9e\xfd\xcd\xf7\xd7\xf2\x1e\xbf\x6b\x85\xfe\x94\xd9\x70\x8c\x9c\x10\xe6\xc1\xc2\xe6\xaf\x5b\xdd\x5a\xfd\xe0\xb6\xfd\xfe\x60\xfd\xfd\xc6\xfb\x83\xda\xbf\x68\x36\x52\x92\xb0\x9c\x6b\x00\x06\x7d\x3e\xfd\xf7\x7f\xff\xf4\xbb\xbf\xcf\x7a\xf7\x93\x1f\x7c\xeb\xe3\x9f\xff\xce\xb3\xef\xff\x18\x09\xf7\xed\xbf\xfb\xf8\x27\x7f\xfd\xc9\x3f\xfc\x5f\x4f\x7f\xf4\xd1\xd3\x6f\xfe\xec\xe9\xff\xf8\xd3\x8f\x7f\xfa\xef\x9f\x7e\xe7\xa7\xbf\xfc\x83\xbf\xed\xba\x0d\xcf\x01\xcf\xfe\xa7\x9f\x7d\x07\x9e\xfe\xe3\x1f\x3c\xfd\xad\x1f\x7f\xf2\x83\x6f\x3d\xfd\xe6\xcf\x3e\xfe\xc9\x4f\xf1\x3c\x67\x59\x21\xd7\x63\x1b\xf8\xff\xf4\xb3\xef\xc8\x62\xac\xc2\x8f\x7f\xf2\x53\xa8\x7b\x4b\xcb\xb2\xc2\x6e\x69\xe9\x56\x99\x95\x86\x19\xbd\x25\xff\xaa\x8e\x94\x46\x17\xd9\x68\xd3\xec\x91\xdf\xd4\x14\x5c\xee\xf7\x92\xa2\xfd\xd9\x4c\x24\x12\xcd\x9e\x5e\xb2\x13\x28\xb3\x7a\x39\x7b\xb8\xfc\xa4\xed\xd5\xc9\xa8\xf8\x7e\x2f\xb1\x85\x13\x09\x8f\x92\x6f\x33\x33\xac\x69\xb8\x53\x41\xb4\x44\x6f\xff\xf0\x3f\x52\xa6\x13\xbd\xfd\xf4\xc7\xdf\x7d\xf6\xfd\x1f\x7f\xf2\x1b\x1f\x3d\xfd\xde\xbf\x37\x3a\x3f\x47\x44\x9f\x13\x90\x12\xff\xbb\x3f\xfa\xf4\x5f\xff\x9c\x8e\xa2\xef\xff\xed\xb3\xef\xff\xf8\x9f\x7e\xf6\x9d\x8f\x3f\xfa\x33\x95\x88\x63\x41\x80\xc9\x91\x1a\x4a\x89\xcd\x26\x6d\x8d\xe6\xbe\xa2\x77\x92\xe2\x66\x0d\xdc\x86\x6a\x15\x6a\xe0\x43\x1b\xaa\x55\xa1\x77\x25\xfd\x80\x84\x69\x30\x0c\xfa\x10\x46\x2c\x7e\x97\x30\x46\xa7\xb1\xbc\x40\xb6\x4a\xaa\xb6\xb1\x17\xa1\x07\x33\xa7\x9d\x88\xa2\xe5\x5e\x98\x62\x29\x76\x4d\x6f\xae\x7c\x0d\x95\x0c\x4a\x6d\x11\x56\x8a\xc5\x06\x3d\x85\x0e\x60\xb1\xd9\x24\x48\xad\x6a\xa3\x6a\xba\x91\xc4\xa7\xba\x04\xa4\x32\xee\xb4\xeb\x89\x7b\x8e\xd9\x0e\x92\xec\xa1\x8f\x3f\xfa\xc3\x67\x7f\xf3\x7d\x26\x1c\xfe\xe9\x67\xdf\xf9\xf4\x2f\xff\xf3\xd3\xdf\xfc\x9b\x8f\x7f\xfa\x9b\x8f\x12\x96\xf6\xc9\x0f\xbe\xc5\xa4\xf4\x2f\xff\xe0\x87\xbf\xfc\x4f\x7f\x58\xd2\x59\x9f\xfe\xa7\xff\x46\x01\x95\x74\x66\x0f\xb4\x8f\x39\x1f\x31\xf8\xe4\x2f\x7f\x94\x39\xc0\x2c\xbd\x68\x1c\xe8\xe9\x41\x83\xd2\xd7\xa1\x03\x92\x70\x16\xeb\x1c\xbb\xc1\xc3\x9d\x51\x42\x38\x50\xad\x32\x92\xed\xab\x52\x9f\xcf\x97\xea\x9d\x53\x4a\x28\x8d\x65\x9c\x52\x2b\xfe\xd2\x33\x3a\x02\x11\x5e\x67\x18\x64\x5c\xb0\xfa\x72\x97\x58\xcc\x1b\xff\xf6\xff\xbe\x9a\x7e\xa0\x80\x4a\xfb\x41\xfb\x98\xef\x87\xa7\xff\xe1\x3b\x99\xf9\x76\x3e\xcd\x74\x41\x4e\x97\x2e\xa1\x8f\x53\x46\x1e\x46\x1f\x03\x4c\x96\x24\x6a\x62\xd1\xf9\x80\x7d\x85\x9a\x62\x8e\x9e\x48\xa4\xa2\xa9\xcf\xb6\x25\x14\x39\xff\xcd\x77\xaf\x88\x9c\xff\xe6\xbb\x4b\xc8\xa9\x3e\x16\x90\xf3\xef\x7f\x98\x61\x6b\xdc\xa2\x50\x04\x55\xf7\x43\xd0\xc4\x7a\x4f\x67\x87\x5f\xfe\xd1\x9f\x5f\x0d\xfe\x14\x50\x29\xfe\xda\xc7\x82\x61\xf9\x0f\xbf\xfb\xec\x4f\xff\xc4\x6c\x02\xdf\xf5\xcc\x30\x85\x5f\x3e\x50\xe4\x78\xea\x95\xe5\xe9\xe9\x23\xf5\x25\x8c\xef\xcc\xf0\x6c\x32\x00\xeb\x19\x5e\xec\xd1\x35\x9f\x6f\x9b\xb6\x05\xbe\xcb\x6a\xb6\x7e\x1a\x0d\xf4\xb9\x99\x4b\x00\x3a\x1d\xf4\x8a\xdc\x4d\x7d\x73\x6d\x1a\x66\xa6\x5c\x1f\x9a\x14\x62\x76\x2d\xc7\xf8\x46\xb2\xfe\x34\x1a\x38\xb4\xac\xa9\x7a\x3e\xfb\xce\x6f\x7f\xf2\xed\xbf\x7c\xfa\xc7\x3f\x7d\xfa\xc3\x1f\x50\x7d\xfe\xaf\xff\xe2\x97\xdf\xff\x05\xd3\xb7\xba\x49\xea\xc7\xa9\x03\x24\x1c\xd8\x9f\xfe\xe2\x8f\x3e\xfe\xc9\x5f\x31\x45\x47\xaa\xfd\x38\x66\x3e\xfa\xbb\x8f\x7f\xf2\x7b\xbf\xfc\x93\x6f\x7e\xfa\x5f\xfe\xd5\xd3\x3f\xff\xd6\x27\xdf\xa3\xdc\x86\x13\x38\x63\xb5\x4f\x7e\xf0\x2d\xc9\x6d\x85\x0c\x85\x95\xc0\xa7\xff\xeb\xef\x3f\xf9\x8d\x8f\x0a\x33\x90\x70\x80\x8c\xf5\x5b\x9f\xfc\xc6\x47\x74\x1e\xff\xc9\xef\x3c\xfd\xce\xb7\x9f\x7e\xef\xbf\x7d\xfa\xa3\xcc\x5a\x41\x87\x49\x66\x00\xac\x2d\x4b\x7c\xf8\x3e\xfd\x77\x7f\xf1\xf4\xa3\xff\x59\xb4\x68\x50\xcb\x69\x45\x03\xbe\x78\x96\x7d\x18\x62\x28\x14\xfc\x9e\xd3\xaa\x78\x78\x52\x1e\x12\x8e\xe6\xbc\x89\x64\x34\xf4\x26\x76\xb4\x9c\xea\xbb\xdc\x07\x8d\x43\x9c\x4f\x69\xa2\xe6\x4f\xb6\x54\x5b\x7a\xfa\xa3\x8f\x58\x0b\x3e\xfd\xc5\x1f\x7f\xfa\x1f\xbf\xf3\xc9\x4f\x7f\xf1\xec\x9b\x7f\xf9\xec\xbb\xff\x81\xb5\xa9\x64\x8c\xc3\xd3\x1f\xfe\xe0\xe3\x8f\x7e\xfb\xe9\x9f\xfd\x19\xed\xcc\x3f\xfd\x57\x65\xb4\xef\xad\x9c\x33\x05\xe8\xba\x0e\x78\x07\x4f\x7f\xf3\xdb\x34\xe7\x9f\x7d\x8f\xf2\x4b\x46\x99\x55\x72\x42\x81\xcd\xe7\x67\x51\xee\x71\x5f\x73\x16\x4d\xfc\x94\xb0\x62\x19\x0b\xe6\x3c\x8e\x4f\x75\x7b\x25\x1d\x60\x0e\x68\xf6\xb9\x90\x9c\x50\xc9\x50\xf3\xf7\x55\x02\x1d\xf4\xb5\x9e\x3e\x4e\x30\x57\x0d\x30\x9e\x1d\x66\xa8\x63\x12\x1d\x23\xf6\xbe\xa0\xb1\x4e\x54\xca\xd0\xdf\xfc\x4d\x26\x50\xcb\x09\xbc\x32\x7d\x57\xcc\xb8\x80\xa7\xdf\xfd\xd1\xc7\xff\xf0\x17\x9f\xfe\xf0\xcf\xa9\xfe\xfa\x87\x3f\x62\xc8\x70\x95\xf8\x27\xdf\xfc\xf8\x27\x7f\x45\x17\x82\xff\xe6\xa7\xe5\x24\x7f\xfa\xf3\xdf\x5d\x3c\xfd\x93\xff\x0a\x3e\xfc\x9f\xd0\x63\xe3\xf9\xd3\xef\xfc\xeb\xa7\x7f\xfc\xb7\x4f\x7f\xf3\xdb\xcf\xfe\xe0\xef\xe8\x84\xf1\x8b\xdf\x7b\xfa\xc7\x7f\x2a\x97\x35\xac\x3f\x65\x87\xcc\xc3\xcb\x75\xc9\x42\x75\xc9\x20\x18\x0e\xa1\x03\x54\x4e\xd2\x6e\x59\x03\x91\x82\x3f\x4f\x9e\xc0\xbd\x70\x18\x84\x41\x7a\xaa\xf7\x90\xb5\x80\x3a\xf8\x74\xbe\xa6\xb9\x56\xea\x17\xba\x00\x40\xb9\xf4\xec\x4f\x7e\xfb\xd9\x6f\xfd\xd5\xb3\xdf\xff\x6b\x4a\xdd\xdf\xfd\x9d\x8f\x7f\xfe\x27\xbf\xea\x5d\xc6\x44\xf0\xf2\x2e\xfb\xa7\x9f\x7d\x07\x25\xc3\xcf\x7f\x77\x41\xa5\x65\x11\x00\x56\xfa\xe3\x9f\xfd\x80\x91\xe7\xe9\x6f\xfd\x98\xe5\x01\x3d\x53\x71\xd7\xbf\x17\xcf\x43\x16\x8d\xf1\xa5\x74\xbf\xd4\x1a\x5d\xee\x10\x3f\x0d\x42\xcb\x73\x32\x6c\x61\xf3\x01\x2b\x03\x9f\x70\xc3\x28\x74\x98\xd6\x24\xe4\x79\x5b\x3d\x3a\x6b\x20\xcc\x13\x6d\xf1\xc0\xe3\xc5\x28\x4d\xa3\x6d\xbe\x8a\xef\x59\x85\xa4\x5d\x98\xea\xd0\x66\x24\xf3\x69\x9b\xfe\x43\x8b\xe2\xa4\xdc\x66\x3f\xf8\xce\xe7\xe6\xb6\x7c\x72\x90\x28\x54\x5f\x6a\xf3\x5f\xcc\x87\x3a\x44\x9b\xff\xd2\x14\xb4\x6a\xb5\xd9\x0f\x56\x93\x1b\x9b\xed\x7c\x12\x2d\x58\x30\x8a\xdb\x45\x89\xb9\xbc\xaa\xdb\xdb\x65\x1f\xd6\xce\xf2\xb6\xce\xa5\x57\xb1\x28\x5b\x23\xef\xb6\xc3\xc3\x55\xed\x9e\xcd\x75\x18\xfb\xf1\x34\x0a\x4f\xb9\xc5\x14\xac\x60\x3a\x9d\x63\x1c\x4d\x1b\xd6\x9b\x45\xb0\xbb\x15\xbf\x72\x80\x41\x94\xc3\xc1\x65\x21\xf4\x10\xc2\x2c\x0a\xe8\xca\x41\x03\x11\x4c\x11\xc4\x7a\x93\xed\x9d\x1c\x7e\xed\xee\xe7\xef\xbf\x7e\xe7\x4b\x87\xf7\xde\xba\xff\xce\xbb\xef\xdd\x7d\xe3\xf0\xad\x77\xde\xf8\xca\x97\xef\x1e\xba\x87\x83\x8d\x43\x8c\x95\x75\x78\x58\x62\x6d\xdd\xdc\xb1\x2f\x05\xda\x3b\x3c\x8c\xe2\x41\x10\xfa\x93\x52\xd0\x1b\x3b\xe8\xf0\xbe\xa6\x87\xc2\x0e\x07\x96\x66\xc4\xe8\xfb\xe8\xea\xc7\x03\xba\xac\x56\x19\xa5\x2b\x34\xd7\xc5\x79\x4e\x58\x6f\x1e\xd8\x96\xdd\x98\x87\x47\x61\x74\x12\x5a\xd2\x72\x2a\xf7\x77\x06\xc2\x94\x8e\xd5\x35\xd8\xab\x16\x68\x97\x82\x7d\x97\x8e\x53\x99\x05\x47\xad\x0c\x1d\xcf\x3f\x31\x69\xa7\xbb\x39\x88\x67\xda\xaa\x93\x60\xa0\xa2\xf7\xc6\xd1\x3c\x94\x91\x84\x44\xe2\xcc\x1f\x0c\x82\x70\x74\x2f\x0c\x71\x2a\x73\x33\xe9\xef\xcc\x53\x33\xdd\x9f\x04\x23\x8a\xb5\xdb\xd8\x62\xd2\x8b\xe0\x55\xc3\x0c\x43\xde\x5a\xfc\xa0\xf4\x48\x82\x1f\x2d\xfd\xe8\x04\x85\xc0\x5a\x6c\xd9\x99\x18\xc3\x54\xe8\xe1\x5e\x0b\x74\x58\x23\xbb\xde\x01\xdc\xe4\x8f\x6a\xe3\x0b\xb8\xd2\x2c\x32\x89\x42\x75\x30\xf3\x44\x33\x05\x07\xea\x02\x36\x8f\xe7\xcb\xf7\xae\x2c\xcc\x56\x67\x10\xa5\xbd\x8e\xca\x5b\xcf\x81\x10\xea\x26\x91\x6a\x26\x6d\xd6\xa5\x9b\x2a\x3f\x31\x47\x55\x5c\xfd\x48\x06\x5b\x9f\x68\x07\x23\x18\xe2\xb5\x4c\xbd\xf8\x4b\x66\xa8\x83\x65\xaa\xb4\x6d\x58\x67\x84\xe7\xfe\x83\xa2\x67\x51\xf7\x66\x65\xbc\x6c\x99\x02\x9c\x18\xbd\x10\x29\x4c\x63\x8a\xbd\xed\x18\x00\xb5\xcf\x32\xd9\xde\xd7\xa3\xa7\xb2\x9d\xa6\x73\x47\x87\x3e\xca\xbb\x15\x82\xa3\x83\x71\x2d\x8e\x8d\xd0\x6e\x4c\xfd\x99\xa5\x5d\x32\xaa\x05\x4d\x62\x14\x12\x8d\x0b\xf6\xb3\xf7\x81\xe8\xe3\xc3\x12\x5d\x7f\x5b\x44\x1a\xe7\x09\x96\xda\xa5\x53\x4b\x08\x7d\xb4\x69\xb1\xba\xac\xc3\xec\x72\x33\xbb\x27\x72\x1b\x2c\xce\xb1\x87\xb6\xa3\x98\x9a\xd6\x21\x38\x79\x9f\x39\x2c\xca\x5a\xc4\x18\xbd\x50\x25\x72\x60\xd7\x0e\x29\xbb\x43\xed\xb0\xeb\x1d\x1c\x64\x6a\xc4\x4c\xdc\xf8\x59\x5c\xed\xbb\x62\xb0\x97\xd5\x5d\x5a\x0f\x2f\xc8\x2e\xb1\x96\xb5\x66\x2b\xd1\x59\x46\xd6\x91\xa9\x42\xe6\xc9\x16\xe6\xc3\xa3\xac\x9c\xf4\xac\xd0\x1b\x75\x5e\x7b\x0a\x69\xc9\x0b\x5d\xbf\x7e\x98\x25\x20\xfd\x92\xad\x83\x8f\x9f\x8b\xd6\x92\x11\xa1\x19\xc9\x59\xa6\xbb\x1d\xda\x59\x36\xd2\xe1\x94\xa0\x26\xea\x78\x1e\xfc\xae\x14\x21\xd1\xca\xcb\x20\x74\x69\x0a\x61\xc1\x2c\x42\x62\x62\xba\x10\x26\xa2\xd0\xea\x28\x48\x31\xac\xd7\xdd\x8f\x66\xa7\xe7\x8c\x03\xcb\x96\x93\x12\x97\x3e\x42\x9c\xd8\xda\x97\x98\x09\x34\x74\x23\xd2\x52\x51\x1a\x33\x31\xae\x52\xf5\xde\x31\xfa\x38\x9f\x07\x09\x66\x90\x5d\xcb\x83\x2d\x62\x94\xd0\x46\xb9\x32\xb5\x88\xf1\xaf\x1b\xf4\x50\xf7\x0b\x92\x31\xf3\xc0\xd7\xcd\xdc\x48\x08\x45\x95\xc2\xd1\x95\xe7\xa0\xfd\xac\x26\x91\x65\xbd\xa2\x8f\xbc\xe4\xaa\xbd\x20\x71\xa6\xf9\x2c\x3b\xdf\x56\x84\x52\xd0\x4e\xcb\xb0\x3a\x4b\x30\xac\x57\xcd\x6e\xf0\xb8\x61\x31\xbb\x02\x58\x7a\xaf\xdd\xd5\xac\x00\x56\x57\xbe\x0f\x67\x7e\x10\x27\xe5\xfa\xf1\x36\xd3\x8f\x9b\xeb\x30\x0f\xe7\x09\x19\xc8\x2a\x84\x6e\xcb\x97\x0a\xa2\x2a\x96\x4b\x42\xe2\xb9\x78\x63\xa8\x7a\x65\x5e\x46\x94\xb8\xfc\xea\xcc\xc4\xa3\x63\x6b\x30\xef\x6b\x0c\x14\xba\xe2\x20\x6e\xe2\x66\x14\xc3\xd0\x93\x9f\xbc\xcc\x27\xa9\x94\x84\xe4\x84\x87\x3a\x09\x5d\x58\x87\xd0\x93\xea\x76\x20\x35\xd8\x40\x5e\x9d\x11\x18\xe5\xd5\x06\x30\x43\x0a\x78\x1c\x75\x1b\xc4\xfb\x4a\x54\x15\x0b\x01\xfa\x4a\x35\x1d\xa6\x0c\x47\x31\x58\x01\x6d\x1b\x86\x65\xd9\x87\xc0\x85\x9b\x10\xba\xfb\x50\xab\x05\xd2\xd2\xcd\x63\xb7\x50\x5c\x14\x15\xba\x01\x9d\x9d\x03\x8f\x97\xf3\x68\x39\x0f\xcb\x79\x0e\xfd\x57\x9d\xa8\x65\x05\x58\xec\x16\x86\x32\x07\x26\xe9\xdd\x0d\xbc\x03\xe3\x62\x0a\xc5\xd6\xd2\x9b\xc9\xce\xc7\x20\xde\x5e\x7a\x35\xd9\xf3\xb1\xef\x55\xb3\x58\x6e\x97\xa8\x07\x37\x71\x43\x1a\xaf\xe5\xe8\xc1\x2d\x7c\xe1\xcf\x6c\xab\xda\x85\x36\xbc\xed\xbf\x5d\xd2\xf6\xa5\x37\x55\xbd\xf4\xa1\xbb\x7c\xd5\xbc\xb1\xbd\x75\xe9\x65\x73\x2f\x48\x48\x3f\x2d\x07\x8d\x91\x9c\x2f\x01\xba\x75\x78\xd8\x8f\x30\x46\x69\x39\xf0\xdd\xcb\xe2\xbd\x71\x78\x48\x16\x29\x59\x02\x7a\x63\x7b\xf3\x72\xa0\x37\x0f\x0f\x45\x1c\xef\x25\x78\x6f\x5f\x0e\xf8\xd6\xe1\x21\x4e\xf2\x4b\xd0\xbe\x24\xe4\xed\xc3\x43\xf4\x68\x5d\x02\xf9\x92\xa6\x95\x9d\xc3\xc3\x74\x1c\x93\x64\x1c\x4d\x06\x87\x49\x3a\x8f\x47\x64\x59\x2d\xbb\xcc\xc8\xc2\xfe\x5e\xc0\x40\x57\x73\x86\xb8\x94\x7a\xc5\xbe\x2c\xb0\xd4\xe4\x6c\x32\x2b\x71\xdc\x12\x40\x92\x50\x4b\x61\x15\x53\xb4\x00\xac\x69\x50\x19\x07\x49\x1a\x8d\x62\x7f\x6a\x0d\xfc\xd4\xd7\xcd\x2a\x81\xb2\x7c\xa0\x85\xc5\x4f\xb3\x37\x38\x01\x2c\x8c\xfb\x48\x72\xd3\xa6\xd8\x87\x63\x33\x16\x9f\x74\xe8\x9c\xb3\x5f\x3e\xd9\xe0\x33\x22\xd3\x0d\xe8\x5c\xe5\x60\xcd\x72\xa2\x91\xe8\x2d\x1e\x2b\xb3\x0f\x5f\x97\x6b\x78\xd1\x39\x6f\xf1\xd8\x30\xf1\x2c\x3c\x96\xe6\x69\x69\x29\x05\x22\xc9\xc6\xe1\x38\xb0\x70\x1d\x58\xc8\x48\x16\xcd\x26\xdc\x89\xc2\x63\x12\xcb\x80\x1a\xd1\x50\x15\x4a\x20\x08\xf1\xb0\x77\x30\x8c\xe2\xa9\x96\xde\x90\x36\x93\xeb\x66\x74\xb5\xf4\xb1\x76\x7f\x39\x62\x70\xae\xf9\x43\x0d\xc4\x6e\xa5\x8f\x1d\x4a\x5f\xf1\x24\x13\xda\x3f\x18\xc2\x0e\xa4\x8f\xe5\x15\xe2\xab\x01\x56\xb2\xa3\xd0\xe6\xa8\x8e\x0b\x2f\x5c\x68\x52\xf0\xb0\x0e\xe9\x63\x47\x37\x46\x2d\x3c\xe3\x0b\x45\x81\x87\x10\x9b\xcc\x93\xe0\x98\xe8\x1d\x87\x71\x3a\xa6\xd1\x31\x01\x3f\x3c\xd5\x69\x18\xcd\x53\x79\xdc\x9c\x75\x6a\x43\xf6\xf4\x94\xf6\xd1\x63\x79\x33\x18\x4d\xe6\xfb\xc0\x29\xed\x61\xb8\xd9\x81\x85\x6b\xd3\x2c\xc9\x38\x18\xa6\x96\xed\x40\xbd\x3e\xcd\x66\x9c\x42\x1d\xbc\x03\xb8\x45\x3b\x96\xe6\x9d\x45\x33\x99\x53\x56\xd5\x0b\x42\x93\x85\xa7\xcc\xfb\x4b\x32\x4c\x2f\x08\x15\x57\xdc\x63\xd7\xfd\x07\x8f\x09\x16\x6c\x14\xf1\x7a\x07\xa6\x19\x66\xef\xa1\x50\xa0\x05\x18\xc3\x77\xe5\x7d\x60\xbd\x20\x6c\x2c\x98\x5e\xc7\x0e\xf1\xa6\x8f\xbb\x01\x43\xbb\x0d\x0b\xd7\xc8\xe6\x61\xb6\x9b\x30\xe5\xd9\x30\x8b\xb7\x9f\x21\xf6\xeb\x49\x42\xd7\xa4\x74\x04\xe1\x81\x50\xda\xbc\xde\xa9\x38\xa2\x1a\x8c\xc2\x28\xa6\xab\x28\xda\x19\x65\x3d\x70\xde\xd8\x5d\x48\xed\xb2\x1b\xc8\x96\x50\xae\x5f\xb8\xd8\x33\x70\xe3\x06\x2c\xf0\xc9\xb8\x9e\x1f\xdb\xbf\x8a\x51\x5c\xa8\x12\x85\xfc\x49\x19\x6e\xe1\x80\xeb\xc0\xd4\x3e\x60\xdb\xff\x5c\x72\x64\xaf\xd2\x5f\x33\xd6\xd0\x41\x98\x48\x23\x9e\x94\x80\x0d\x21\xfb\x2f\xb4\xea\x17\x85\xd2\xd3\x19\x89\x86\x70\x88\xbe\x9e\x15\x01\xa2\x02\xb7\xe1\x10\xda\xe7\x0f\x44\x43\xb3\x29\x6c\xeb\xa1\xed\x28\x5c\xa5\x35\x52\x2d\x3c\x55\x3b\x9e\xc7\x20\xf9\x32\x5a\xd2\x65\x46\x42\xb4\x11\x66\x1b\x35\x50\xd7\x42\x64\x5a\xa5\x49\x8b\x0b\xb6\x4c\x9f\x40\x97\x37\xce\x14\xd4\x87\x36\xdc\xbe\x92\x9e\x5b\x41\x09\xef\x56\x7a\x58\x10\xcd\xb0\xb4\x58\xa3\xef\x4f\x26\xd6\x21\xda\x89\x5e\x04\xf7\x48\xa2\xe4\x4c\x17\x32\x5b\xc9\x22\x66\xe9\xad\xa8\x57\xb3\x88\xc9\x2b\x74\x4b\x76\x1f\x15\x12\x0b\x63\xb1\x56\x66\xbb\x59\xf0\x16\x17\x36\x6e\xe9\x55\x7b\xaf\x50\xe3\x16\x25\xf8\x2f\xbd\x9a\xea\x9f\xd1\x0a\x53\x5e\x42\x58\xbe\x9e\xf2\x2e\xbd\xc6\x64\x6a\x5e\x29\x64\xcf\xbd\xe4\x32\x70\xe3\xf0\xf0\x83\xb9\x1f\xa6\xc1\xa4\x7c\xb1\xd6\xf2\xb6\xc4\x62\xe7\x85\x19\xcd\x1c\x19\xc3\xc2\x56\x07\x98\x92\xf3\x6c\x52\x52\x52\x31\xf1\x32\xf5\x67\x4a\x4e\x09\xb8\x2b\x91\xb5\x48\x40\xb1\xeb\x9f\x57\xed\xf2\x22\x08\xfb\x19\x17\x17\x33\xca\x0d\x3b\x35\xd8\x82\x75\xb0\xce\x95\xa6\x46\x37\x15\x4a\x53\xd1\x5c\xb7\xb1\xb3\x65\x43\xfd\x7c\x01\x7d\x11\x90\xad\x2d\xdc\xa3\x95\xae\xb0\x7c\x23\x92\xaf\xbd\xa0\x4e\xf5\xed\x0d\x5b\x3a\xe8\x64\x25\xc0\xd2\x3b\xbe\x5e\xba\x04\x18\x90\xe3\x00\x7d\x59\x96\x48\x81\xd6\x8b\x35\x11\x67\xb9\xfd\x3c\x26\xd9\x68\x6c\xc1\xfa\x2a\x5b\xd2\x7a\xe3\x96\xf4\xe9\xf3\x74\xe6\xd2\x5b\xb0\x5e\x2d\x63\xa9\x20\x36\xfe\x46\x5a\x30\xeb\x50\xae\x10\x32\xf6\x83\xc0\xb8\x7b\xda\xb8\xdf\x54\xc4\xa2\x96\x47\xa8\xa2\xa1\x32\xa1\x7f\xa8\x2f\xed\x6a\x35\x5c\x95\xd8\xf0\x21\xbb\x17\x99\x07\xf6\x1d\x06\x71\x92\xf2\xbb\x1c\xf1\x6a\x23\x71\xf3\x9f\x5c\x9f\x48\xcd\x5d\xae\x5e\x6c\xb8\xce\xaa\xd0\xae\x19\xe5\x9f\xf5\xa5\x0b\x3b\x23\x2d\xb5\x6f\xf6\x57\x88\x0d\xbf\x49\x97\x05\x09\x26\x54\xb1\x35\xae\x30\x97\x7f\xab\xa3\xa3\xc7\xe0\x5e\x8a\x8f\xba\x86\x5a\x3d\x9d\x99\xc6\x7a\xed\xdc\xd9\xd5\xd2\x32\x1a\x5a\xb2\x11\x68\xc1\xe1\xe3\xe0\x15\xa2\xef\x45\x50\xbc\x4a\x9a\x8b\xc3\x04\x7e\x89\xfe\xb6\xb3\xf4\x28\xf3\x4b\x97\xde\x2b\x29\x42\x2f\x54\x74\xaf\x2e\x4d\xa6\xd0\x81\x70\x05\xd1\x92\xe0\xa1\x00\xf7\xc2\xe2\x45\x63\xf7\xeb\x41\xf2\xb6\xff\xb6\xe4\xa8\x55\xa6\x8a\x65\xba\x8f\x62\x45\xdb\xb6\x11\xbf\x5a\x86\xb7\x70\xa8\x4a\xa3\xd6\x4a\x23\xf8\x45\xa3\x5b\x3a\x82\x2e\xd6\x04\x0c\x1e\x69\x6b\xa7\xb0\xa0\x09\x25\x0b\xcf\x9d\x97\xe0\xfa\x7a\x91\xb5\xcd\x0b\x5b\x81\x78\x2f\x6e\x05\xd2\xba\xd0\x0a\xe4\x95\x18\xd7\x4b\x86\x32\xa3\x52\xa2\xce\x07\xbd\xa4\xf1\xec\x5d\x64\x3c\xab\x89\x83\xa3\xcb\xec\x94\x7a\xf4\xe8\x0b\x4d\xcd\x2f\x1a\xef\x65\x03\xfb\x32\x6d\xe1\x43\x7b\x15\x1b\xd6\x39\x4b\x24\x51\xe7\x39\x4b\x45\xf7\xdc\xa5\x22\x5d\x65\x6d\x95\xa8\xdc\x3b\x2f\xd0\xbd\xe6\xca\xfd\x13\xe8\x8a\x3c\x31\xc7\x10\x4b\xcb\xce\x8d\xc5\x83\xe9\x91\xee\x8c\x3d\x25\xf1\x88\x0c\xa4\x6b\x36\x05\xa3\x9f\xb9\x93\x0c\xf8\x88\x8a\x76\x56\x4b\x37\x38\xd0\xb6\x65\x18\x00\x63\xfb\xe4\x91\xad\x83\xa8\xd7\x43\xe3\x30\xbe\xcf\xef\xb8\xe5\xc0\x42\xbe\x7d\x30\x15\x49\x45\x5b\x3e\xf5\xfa\xd4\x80\x21\xaa\xed\xd6\xeb\x8f\x0e\x44\xc1\xee\xf4\xa0\xd8\x31\x85\xe5\x2d\xe9\xf8\x5f\x25\xc7\x14\x7e\x37\x78\x38\x20\x0b\xa2\x5f\x75\x00\x1d\x91\x28\x97\x98\x33\x12\x4f\xf1\xaa\x77\xbd\x63\x02\x1c\xad\x9c\xa6\x41\xbd\x6e\xcb\x6c\xf2\xba\x26\xff\xb4\xcb\x41\x75\x83\x83\x03\xcd\xba\x22\x72\x96\x90\xf1\x15\xf3\x71\x59\x6d\x96\x7e\xa1\x73\x1d\x5b\x39\x11\x75\x15\xce\x75\x2b\x37\xdb\xd9\x42\x07\x92\x87\x2b\xf5\x21\xeb\x16\x8e\xd8\x85\xdc\xa2\x5f\x3c\x52\x0b\xc7\x47\x7a\xa4\x2e\xb6\x3e\x92\x53\xa1\x4c\x58\x99\x68\x65\x0e\x04\xc5\xd3\x92\x56\xa9\xb5\x08\xf4\xc5\xac\x03\x8b\x47\x36\xdc\x04\x17\x9e\x3c\x01\x99\xe5\x11\x4b\xbe\xde\x31\x46\x34\xb6\x66\x11\x38\xd8\xda\xa0\x40\x61\xcc\x96\xe7\xe1\x55\x38\x7f\x3e\x2a\x61\xcc\x17\xb8\x6f\xf1\xa2\xc6\xb7\xeb\x40\xe0\x69\xa7\xdc\x69\xa6\xc0\x13\xfd\x89\x41\x45\x94\x9c\x84\x36\x66\xae\x0b\xe7\x40\x57\xcb\xe7\x42\x1b\x6a\x81\x2b\x77\xb2\x53\xc9\x5d\x7a\x6f\x4e\x65\x3f\xca\xb3\x1b\x7e\x38\x88\xa6\x96\x0d\xeb\x30\xad\xd7\xe1\x09\xf0\x5d\xe8\x54\x89\x5a\xa8\x41\xe0\x72\x79\x6b\x24\x29\x31\x92\xcf\x12\xc8\x2c\x69\xf6\x40\x36\x9f\x79\x0a\xbb\xf0\x05\xee\xce\xbc\xd2\x8a\xee\x15\xac\x59\x85\x92\x58\xd3\xec\x4b\xc6\x3a\x0d\x9a\x4d\x78\x3b\x4a\x49\x1b\x1e\x93\x38\xc2\xcb\xa7\x90\x79\xa8\xbc\xa0\xa4\x3b\xf6\x27\x24\x4c\x1b\x97\x52\x54\xcd\xca\xcb\x8d\x2f\xf9\x85\x63\x76\x06\x4f\xe6\x65\xab\xc3\x57\x6b\xe7\x2b\x8d\xfd\x30\x99\x45\xc9\x12\xaf\xbc\x1d\xf7\x45\x4d\x3c\x86\x9d\x7b\x95\xe5\xbe\x86\x6d\xa1\xe6\x2d\x77\xd5\xcb\x94\xe6\x57\x6b\xd3\x21\x89\xfb\x87\x21\x49\x96\xf8\x88\xee\x70\x07\xd4\x0c\xe5\x63\xc2\xa9\x49\x4b\xb3\x26\x5d\x66\xf5\x4e\xeb\x4f\xc8\x92\xea\x77\xdd\xe5\xd5\x27\xe4\xb2\xb5\xb7\x58\xed\x53\x7f\xb6\x64\x7d\x9f\x71\x07\x95\xd5\x5a\xbd\x00\xa7\xfd\xcc\x69\x5d\x59\xb4\x31\xb0\x0a\xfb\xb2\xe2\x57\x1c\x63\xbb\x5d\xde\x03\xb4\x12\x9e\xb8\xd7\xcd\x8e\xe5\x5d\x6e\x53\x95\x42\x3a\x22\xa7\xe5\x1e\xa4\xbb\xc2\x14\x53\x46\x70\x5a\xfa\x92\x14\xdf\x64\xf5\x33\x19\xb6\x04\x83\xd6\x72\x0c\xf8\x1e\xec\xe5\x70\xd8\x62\x38\x90\x30\x8d\x83\xa5\x48\x6c\x2c\x47\x82\x03\xc0\x8b\x72\xa5\xb7\xad\x31\xd0\x5f\xe0\x86\xd4\x25\x06\xfa\xf9\x6c\xfe\x82\xdd\x85\x91\x6f\x3a\xd0\x55\x87\xa6\xa3\x38\xfd\x52\x51\x22\x8b\x64\xaa\x8e\x4f\x4f\x26\x73\x79\xba\x9a\x4a\x1b\xd3\x2d\xd7\x9f\x61\xc4\x2d\xa6\x06\x0e\xc8\x8c\x2e\xe4\xfa\x78\x31\xd9\xbb\x18\xaf\xc6\xa1\x22\x82\x3d\xea\xba\x37\xe6\xa4\xeb\x63\x8a\x97\x58\x59\x18\x33\xb1\x42\x45\xec\x74\xd8\x5c\x89\x44\xab\x8a\xfa\x2c\xcd\x39\xe2\xf0\x16\x62\x2c\xb7\x47\x6e\xf3\x04\x86\x23\x1e\x66\x63\x7a\x1b\x98\x6e\xba\xa6\x52\x03\xca\x44\x91\xf3\x25\x3e\x22\xa7\xc0\x10\xef\x62\x33\x6a\xb5\x03\xe3\xe3\x57\x75\x85\x28\xa3\x1f\x09\x17\x86\xcf\x9f\x7e\x09\xa1\xac\x32\xe7\x49\xd1\x93\x3f\x69\x9f\x05\xab\x1f\x27\xe7\x01\x89\xf4\xce\xb0\x84\xa7\xf0\xb9\x2a\x50\x22\x75\x3f\xc4\xb4\x31\x22\xa9\x25\x9a\xc6\x1a\x2f\x55\x25\xae\x27\x1f\xd8\x50\x83\x4a\xc5\xb0\xbd\x71\xed\xb1\xc8\xf4\xa6\x2b\x64\x19\xb2\x34\x12\xad\x32\x07\xef\xe3\x9d\x93\x12\x3f\x49\xbd\x18\xf1\xfb\xe3\xbc\x5a\x7b\x44\x4e\x15\x4a\x92\x17\xad\x98\x73\xe7\x11\x39\x75\x38\x13\x8b\x12\xe7\x70\xb1\xf0\xf0\x16\xb4\xcc\x84\x67\xe2\xa8\xc9\x01\xc2\x25\x95\x35\xf5\x67\x1c\xb4\x3e\x0e\x6a\x35\x3e\x12\xcc\x81\x20\x77\xdf\x66\xea\x0c\x3a\x1f\x63\x7c\xdc\x42\x47\x8e\x60\xc6\x85\xe8\x7e\xab\x1f\x7f\x37\x46\xc1\x8d\x1b\x50\x3c\xe4\x84\x69\x6b\xea\xcf\x1a\x02\x55\xde\x42\xec\x21\xf1\xbd\x7b\xe0\xb0\x3c\x26\x91\x1d\x38\xe2\xd7\x67\xfb\xa7\xac\x9f\x3f\x3c\x22\xa7\x6d\x38\x12\xba\x72\x5b\x12\xe0\x58\x34\xff\xcc\xce\x9d\x6c\x17\x8d\xba\x9e\x59\x2f\xe2\x50\xcf\x9e\x72\xca\x14\xb2\xfc\x06\x76\x62\x8f\xfe\x20\x68\x7d\x8c\x9f\x19\x11\x9f\x12\x11\x16\x06\x20\xc2\x91\xd7\x06\x73\x29\xab\x81\x37\x24\x9b\x2b\xf8\x81\x0d\x58\xe4\x07\xf6\x48\x6b\x64\xc3\x6e\xea\xcf\x2e\x0c\xee\x2d\xca\x15\x09\x49\xdf\xf2\x67\x0a\x10\xa7\xd8\x12\x60\x82\xa6\xe7\x03\xc5\x28\xe3\x02\x30\x76\x8d\x04\x3a\xa0\x00\x91\x19\x98\x3f\xb2\xbd\xaf\x13\x4a\x16\x12\x6c\xa6\x95\xc4\x4b\x86\x69\x69\xc9\x82\x1a\x4f\x31\x3f\xf0\x0e\xbb\x89\xb8\x1c\xe4\x57\x39\x7b\x14\x03\x95\xa1\xbd\x97\x40\x61\x2c\xae\x41\x18\x22\x85\x18\xe3\x77\x60\x98\x2d\xa5\x39\x53\xaa\xeb\xfa\xb4\x4e\x35\x57\x23\x1f\x9e\x99\x87\x62\x65\x87\x5b\x11\x67\x01\xe4\x3a\xcd\x29\x80\xa5\x53\x52\x1c\xa8\x2d\xf7\xb3\x5c\x65\x6f\xf9\xb3\x8b\xaf\x7b\x96\xcc\x01\x39\x34\x69\x05\x28\x6d\xb2\x08\xd2\xf1\xcb\x65\xab\x48\x2f\x3a\xb7\xbb\xfb\x6a\x6d\xed\xaf\xa2\x3a\xc9\xe6\x3f\x20\xd8\x8d\x3c\x3a\xfd\x2c\x8e\xd2\xe8\x3c\x1b\x62\x19\x69\x1b\x58\x3a\x3d\x9d\x91\xfd\xb5\xb5\x07\x24\x55\xef\x54\xf6\x66\xde\x3f\xc4\x30\xa5\x61\x92\xc6\xf3\x7e\x1a\xc5\x6d\x8a\x08\xe5\xd2\xb1\x9f\xb4\x19\x1a\x8d\xb1\x8f\xd3\xb3\x3f\x18\x68\x2c\x6b\xf8\x94\xb0\x19\xb5\xd6\x81\x4a\x85\x1b\xaf\xc6\x41\xd2\x5d\x05\x79\xe6\x92\x3d\x8b\xc9\x30\x58\x50\xdc\xa1\xc6\x80\x1d\x98\xbe\x1f\xb1\xb8\x7a\x36\x60\xa7\x0a\x1c\x64\xc2\x69\x74\x4c\x04\x92\xec\x8d\xa6\xf7\x27\xc4\x8f\x45\x32\xbe\x38\xd2\x01\x53\x24\xd3\x51\x8f\x31\xa9\x82\xc7\x12\x02\x7d\xa6\x69\x64\x3a\x4b\x4f\x45\x22\xbe\x60\xaa\xdf\x1f\xcb\x44\xbf\x3f\xc6\xc0\x51\x3a\xf3\xca\xd1\xa5\x19\xa2\xe8\x22\x93\xed\x09\x3c\x20\xa9\x88\xab\x7c\x27\x9a\x9d\xea\x24\x6f\x70\x8b\x13\x2b\x0f\x01\x3a\x99\xf7\x49\x34\xa4\x85\x6c\x3e\x38\x8b\x74\x04\x14\x39\x24\x6d\xf8\x83\x81\x50\x52\xc4\xe4\xde\x6c\xc2\x3b\xe9\x98\xc4\x27\x41\x42\x1c\xf0\x93\x64\x3e\x25\x10\xa4\xff\xfb\x9b\x7f\x94\x80\xcf\x0d\x80\x0d\x61\x5c\x52\x95\x1b\x87\xd3\x98\x5a\x89\xea\x24\xc7\x41\xdf\x2c\xa2\x85\x34\xeb\x58\x56\x2f\x13\x78\x71\xd1\x22\x4f\x8b\x60\x85\x65\x99\x87\x2a\x3b\x1a\xad\x38\x52\xb9\x80\x92\x09\x49\x79\x3c\xd0\xab\x5a\x77\x24\x24\x2d\xb0\xb9\xec\xbe\x40\x77\x88\xab\x5e\x30\x4d\xfd\x59\xc1\x9a\x69\x7f\x4d\x1e\x53\xc7\x54\x08\x50\x37\xb3\xb5\xd9\x13\x75\x0f\x45\x5b\xfa\xa1\xd8\x02\xb5\xfb\x2b\xb4\x6d\x6b\x50\x43\xae\x0b\x96\xd0\x43\x57\xf8\xa7\xfe\x0c\xe7\x42\x9d\x2c\xcb\xce\xdb\xef\xfe\x0a\x6d\x6b\x1a\x84\x11\xb6\x88\xa5\x94\xe1\x99\x0c\x1d\x59\x4e\xc3\x6d\x10\xc4\x3a\xd3\xa9\xc5\xcb\x94\x90\xeb\x25\x6c\x5f\x5e\x38\xbe\x9e\x38\x6f\xfc\x62\x8e\x61\x6c\x5f\xf2\x30\xbe\x77\x78\x38\x09\x42\xe2\x2f\x73\x53\xba\xe4\x01\x8f\xf3\xcf\x60\x6c\xec\xba\xdc\x49\x49\x5d\x8d\xc1\xa9\xa4\x99\x67\xe4\x99\x36\x16\xd9\xce\xb4\xb1\xb0\x60\x34\xd9\xdb\x8b\x6a\x8b\x4c\x78\xaf\x80\x1d\xfd\xed\x88\x90\x2e\xf9\xb8\x5f\xcf\x11\xa0\x6b\x85\x43\xe2\xe7\x9c\xbc\x38\x7c\x8e\x43\x17\x0e\xf0\x90\x3b\xe2\xdc\x5d\x59\x14\xb0\x73\xa2\xe1\x28\xca\x9b\xe1\x88\xf2\x61\x71\x56\x71\x51\x12\x4c\x25\xf4\x2f\xf6\x1e\x24\x63\xa6\x99\x33\x94\x0b\x35\xec\x97\x70\x32\xed\xc2\x63\x77\xe2\xf7\x8a\x64\x25\x87\xf3\x65\xbf\x97\x31\xf9\x5e\x38\x74\xe6\xb8\x3f\x59\x52\xc1\x17\xfb\x93\x4b\xda\x94\xf1\x7c\xc3\x30\x08\x97\x39\x0a\x5e\x5e\x72\xf4\xa3\x49\x54\x3e\xba\x5b\xde\xee\xa5\x05\xc7\xd4\x4f\xc7\x4b\x36\xdd\x5a\x5c\x6c\x50\x38\x5f\xa2\x23\xcf\xdb\x65\xeb\xde\xaf\xb3\x48\x94\x7b\x5b\xee\xe6\x8e\xeb\x50\x25\xf5\x8d\xed\x2d\xc0\xfb\xdb\xfd\x78\x00\x31\x19\x92\x98\x84\x29\xe6\xfd\x06\x16\x64\xe5\xfe\x25\x3e\x37\xdc\xdd\xdd\xdd\x0d\xee\x9a\x91\xba\xd0\x81\x4d\x68\x42\x6b\x8f\x27\x78\xd0\x81\x6d\x3d\xa1\x05\x1d\xd8\x80\x75\xfa\x85\xfe\xc3\x53\x37\xa0\x23\x52\xf0\x1f\x5d\x8b\x9f\xf8\x3d\x1e\x86\xc0\x8a\x94\x2b\x49\xa4\xab\xe4\x5f\xf6\x7b\xb6\x16\x87\x9b\xbe\x5b\x51\x63\xe2\x40\xd4\xf0\xe9\x3f\x3d\xfa\x4f\x34\xf3\xfb\x41\xca\xd4\xaa\x1c\x84\x2f\xf6\x27\xba\x9a\x3d\xa6\xea\x75\x63\x0c\xeb\xab\x90\x5c\x49\x98\x51\x2b\xf6\x07\xcc\x55\x44\x93\x12\x06\x46\xec\xf4\x4d\x94\x58\x63\x1b\xd6\x21\x6a\xf4\x79\x52\x12\x84\x5a\x92\x89\xed\x99\x74\x9f\x31\x70\x5e\x85\xcf\x84\x2c\x79\x77\xd4\x43\x29\x62\x43\xb4\xa2\xc3\xa4\x04\x30\x66\x41\x27\x47\xa2\x17\x98\x34\x8a\xe4\x15\x08\x3d\xe8\xd0\xaf\xad\xc5\xe9\x63\x2b\x6a\xc4\xd2\x88\xec\x1b\xe9\x23\x99\x3e\x31\xd2\x7b\x32\x7d\x01\x1d\x58\x9c\x3e\x6e\x4d\xfc\x9e\x65\xb9\x8d\x4d\xaf\xb5\xb9\xb5\xbd\x09\xeb\xd0\xc3\xcb\x5c\x37\xb6\x76\xb6\x76\xb6\x29\x7b\xf8\xec\x72\xd7\x5d\x77\x73\x63\x67\x0b\xd6\x61\x62\x43\x13\xbe\x1e\x4a\x40\xa7\x26\xa0\x96\xd7\xda\xde\x69\xed\x49\x40\x3b\xde\x96\xb7\xd5\x6a\x49\x40\xee\x4e\xcb\xdb\xd9\x72\x05\xa0\x6f\x28\x40\x8f\x4d\x40\xae\xb7\xb7\xb1\xb1\xa1\x00\x79\xde\x9e\xb7\xd7\x72\x25\xa0\xbd\x2d\x77\xc3\xdd\xf4\x04\xa0\x7f\x19\xea\xca\x97\x60\x02\xcf\xdb\x86\x75\x38\x85\x3a\x78\xdb\x0e\x6c\xb9\xb4\x38\x46\xa0\x3e\xb5\x1d\x68\xb1\x57\xfa\xf5\xb1\x6d\x72\xc1\x99\x39\x22\xac\x89\x03\x2c\x2c\xb6\xc8\xa2\x9b\x80\x72\x33\x6e\xa7\xd3\xc1\xbb\x78\xb4\xb1\x34\xa1\xb3\x9f\xc0\x2a\x0b\x4d\xf3\xa0\xf1\xa0\x0d\xc5\x68\x14\x15\x64\x68\xa4\xe3\x20\x69\xd0\x7e\xae\x4d\xf6\xc5\xab\x2f\x43\xe8\xe3\x6b\x8f\x07\xd0\xe7\xaf\xb2\x5e\xa8\xf1\x47\xac\x6b\xb5\xc3\x68\x4c\x58\x17\x9a\xb3\xbe\xec\xf7\x1c\xda\x6a\x67\xc5\x73\x6d\x02\x14\x1b\x35\x18\xa4\x66\x70\xde\x61\x76\x7d\xb0\x30\x14\xee\xd0\x57\x0c\x65\x83\xe4\xe8\xc5\xc1\x68\x9c\x92\x58\x33\xd4\x1c\x65\x34\x09\xd1\x11\x9c\x72\x35\x2a\xa2\xd7\xc1\x3a\xca\x74\xc4\x91\xed\x70\x6a\xf2\xdf\x9e\x63\xd0\xcf\x96\x76\x98\x81\x1f\x1f\x5d\xa4\xc6\xfa\x73\xd7\x18\x8f\x7a\xed\xbc\xa6\x44\x25\x04\xed\x56\xd5\x32\x6f\x9b\x8e\x0e\xcf\xdb\xd6\x42\xd4\x50\x5d\x1f\x5d\xba\x59\x55\x36\xdc\x86\x53\x68\xc3\x29\xd4\x04\xf3\x34\xe9\x58\x51\x25\x1e\x9b\x25\x7a\xaa\x44\x5d\xf0\x57\x93\x0e\x27\x26\x88\x29\x02\xdf\xa0\xcd\x9b\xf8\x4c\xee\x9c\x72\xc3\x07\xad\xf8\xeb\xfa\x87\x05\xff\x40\xe1\xff\x4b\xfd\xc3\x63\x3b\x27\xd3\x2f\x21\x7f\x2d\x21\xeb\x4e\x1f\xb7\xe2\x51\xcf\x82\x8d\x46\x6b\xd3\xdd\xdc\xda\xa4\xe2\x88\x4a\x01\xaf\xb1\xb5\xb1\xe3\x6d\x50\x8d\x0e\xdb\xe2\x36\x36\xf7\x76\xb7\x36\x3c\x2a\x07\xa9\x48\xe0\xb3\x73\xfd\x16\x24\xef\x7e\xe1\xf3\x19\x68\x75\xb7\xb1\xb7\xbd\xd7\xda\xde\x76\x11\x5a\x0d\xbc\xc6\xee\xce\xb6\xeb\xb9\xbb\x08\x0d\x85\xdd\xa6\xb7\xb5\x85\xdf\x1f\x2b\xc1\x2b\x90\x71\x1b\xee\xd6\xd6\xf6\xe6\xc6\x26\x47\xc6\x6d\xb4\xdc\x4d\xb7\xb5\xb5\xc7\x8b\x7b\x0d\x77\x6b\xa7\xd5\xda\x6a\x19\xc5\x75\x6e\xc0\x24\x3e\x67\x9d\xd9\x86\x69\x5c\x08\xd2\xd4\x90\x54\x29\xdc\xa2\xb3\xff\x6d\x75\x50\x34\x75\x80\x9d\x0d\x85\x36\xa4\xd0\xa4\x1a\x43\x0d\x52\x37\x27\x01\xb1\x57\x0a\x80\x51\x31\x97\x52\x25\x02\xff\x6f\xd3\xf2\xeb\x60\xa5\x94\x2f\xdc\x8c\x00\x13\x0d\x37\xcf\xc7\xb6\xb6\xb6\x98\x4c\xbe\x49\xd5\x22\xd7\xdd\xf0\x36\xdc\x5d\x3a\x1a\x5a\x8d\x3d\xd6\x4d\x6d\xa4\xc4\x96\x7e\xbc\x75\xc1\xb0\x6e\x35\x36\x6d\x24\x9c\xbb\xb5\x95\xa9\x4c\x4c\x79\x66\x65\xd6\x02\x9a\x1d\x5a\xa5\xcd\xab\xa3\xdc\x00\xb7\x61\x41\x87\x08\x56\xd8\x56\x95\x58\xec\x5a\x73\x0a\x9b\x7e\xa6\x0f\x0e\x56\x69\xd6\x34\xee\x4f\xce\x53\x98\x50\xdd\xd1\x58\xf9\x8b\xfd\x89\x15\x35\xc6\x8e\xd0\x3e\x26\x45\x0a\xd3\xf5\xbc\xd2\xc5\xd4\x09\x43\x43\x13\x6a\x81\x0c\x83\xed\xa7\x7e\xd8\xb2\xb8\x12\xe6\xdb\xab\xea\x54\x3d\x1e\xeb\x7a\xd0\x1a\x90\x91\xd0\xa9\x32\x28\x8f\xd1\xb1\xf6\x36\x8c\xa1\x06\x1b\xdb\x2e\xb4\x61\x2c\xd4\xa9\x0f\x28\x32\x0d\x1f\x15\x2a\x3a\x3d\x47\x8d\x1e\x3e\xf7\xec\x82\xf6\x65\xa8\x67\x8d\x1d\xe8\x3b\x30\xb9\xe0\xe4\xaa\xd1\x7d\x2c\x26\xd7\x2f\x16\x40\x5b\x69\x72\x2d\x2a\xa8\x4d\xae\x94\xba\xb5\xb1\x9c\x3e\xfb\xf4\xb5\xbf\x5f\x32\xf5\xbe\xa8\xc9\xf5\x8b\xfd\x89\x43\x5b\xfd\xab\x30\xb9\x52\x7a\x32\xca\xf1\xf9\xab\xef\xc0\xaa\x93\xed\xe5\x26\xd7\x25\x35\x9e\x3b\xd9\xae\x38\xb9\xf2\xda\xb4\xf1\x47\x4b\xdb\x0d\x2a\xd4\x0c\x29\x9c\x35\x18\xbc\x84\x68\x2f\x17\x36\x18\xf4\xe7\x3d\x32\x26\x93\x60\xb1\x64\x55\x7f\x47\xe4\xf9\x6c\x6d\x5f\xb6\xb6\x7f\x1d\x3a\x50\x77\x1b\xde\xe6\xee\x36\x5f\x5d\xe3\x5d\x55\x5e\x63\x67\xb7\xb5\xb3\xc3\x52\xee\xb0\x3c\xad\xbd\x56\x8b\xa7\xbc\xc1\x52\xf6\xdc\xed\x4d\xbe\x52\xbf\xcb\x4a\xed\xed\xb4\xf6\x36\x79\x0a\xcd\x74\x17\xd6\xe1\x0d\xfe\xfe\x79\xfe\xfe\x79\x5e\xcf\x9d\xc3\x37\x68\xed\x9f\x87\x75\xb8\x03\x75\x78\x03\xd6\xe1\x75\x63\x77\x5c\xf4\xde\x79\xd3\x93\xec\x66\x63\x92\x92\xa9\x62\xaa\x4a\x56\x9d\xaa\x5e\x91\x95\x72\x8c\x56\x85\x98\xea\x09\x5b\x5b\x42\x7d\x1a\x61\xe2\xc8\x4c\xec\x61\x62\xcf\x4c\xa4\x52\xdd\x62\x44\x66\x4b\xd0\xbb\x94\xc2\x31\xd4\x69\x4f\xac\xc3\x08\x83\x78\xb0\xef\xf8\x8d\xa6\x4b\x2d\xad\x37\xe1\x17\x26\x4d\x44\xca\x11\x05\x47\xbb\xcf\x1a\xd1\x64\xaa\xb7\xdc\xa1\x80\x71\xf1\xfa\x86\x74\xe1\x13\xd3\x38\xce\xa8\x47\xb0\x0e\x47\x50\xa3\xd0\x44\x4e\x04\x31\x11\xb7\x67\x4c\x6c\xa6\xa4\xbe\xed\xbf\x4d\x3b\x62\xd2\x71\x21\x8a\x61\xd2\xf1\x38\x38\xbc\x6d\x43\xa8\x7b\x4c\x33\x38\x72\x10\xd2\x65\xd5\x02\xaa\x34\xb7\x64\xf4\x61\x28\x66\x98\x42\x45\x21\x61\x73\x6b\x89\x1e\xd0\x57\x85\x65\xd6\x8b\x68\x03\x39\x66\x97\x3a\xc1\x9d\x52\xc8\x2b\x69\x06\xe5\xc5\xcb\xf5\x03\xda\x8b\xb5\xe4\x65\xeb\x07\x12\x53\x47\x51\xe3\x95\xd5\x15\xe8\x70\xd0\xe7\xe3\xd5\xaa\x61\x41\x49\x05\x5c\xe4\x47\x4d\x61\xbf\x2c\x0c\x07\x8e\xf2\xcb\x4d\xd5\xef\x86\x56\x91\x48\xad\x62\x1d\x8e\x2e\xae\xb0\x5c\xae\xd9\x03\xd6\xd9\x08\xf5\x72\x8d\xce\x42\xb8\xf2\x26\x97\x9b\x23\xc6\xa6\xed\x60\x6c\xf3\x73\x62\xfc\x95\x2e\x74\x5b\xee\xca\x02\x29\x67\xfb\x55\x46\x0a\x1c\x66\x0c\x53\x95\xe8\x9b\xb5\x27\xa2\x76\x3e\x4e\x0d\x59\xaa\x4a\xf5\xa3\x44\x2e\xa8\x98\xf5\x58\xbb\x9f\x29\x08\xe5\x37\x66\x46\xbe\x4a\x53\x05\x5f\x0e\x4f\xf0\x26\xf2\x75\xb0\xe8\xe4\x83\xd8\xd4\x70\xa2\xa7\x95\xdb\x12\x99\x6c\xe6\x3b\x2a\xf3\x1b\xe7\x66\xbe\xcb\x33\xdb\x2b\x9a\x16\xb2\x4a\xed\x4b\x38\x08\x75\xc9\x10\x86\xb9\x78\xfa\xcc\x18\xea\xd0\x09\xb9\x03\xbe\x76\x86\x24\xcd\xa8\xf6\xda\x45\x52\x74\x15\x4b\xd7\xb0\xa9\xbd\x24\x8e\xe3\xee\x0b\x3c\x90\x54\xac\x92\x1b\x17\xf8\xf9\x61\x32\x8c\xe2\xe9\x9d\x44\x1c\xe8\x58\xbd\xcc\x83\xe3\xd1\xe5\x95\xfa\xf3\xc2\x86\x3c\xc7\x4d\x78\x78\xb5\xf3\x92\x93\x25\x7b\x99\x7b\xf0\x8a\xda\xc6\xae\xdb\x77\x60\xb6\xb8\x13\x4d\xa7\x3e\x7d\xb8\xef\xc7\x24\x74\xa8\xdc\xc0\x27\xa4\xb8\xb6\x47\x3f\x8b\x66\x56\x92\xe1\x05\x6d\xff\x3c\x61\x61\x9c\xa1\x06\x15\xa8\x40\x9b\x7b\xf8\x99\x9e\xe2\x78\xb6\x8d\xa2\x61\x2d\x7c\x07\x4e\x7d\x07\x16\x3d\x07\x4e\x7b\xa8\x34\x7c\xa0\x7b\x8d\x2f\x7c\x3c\x89\xbc\xe8\xc1\x93\x27\x70\xca\x5e\x4e\x7b\x7a\x98\x72\xe6\x78\xc6\xdd\x4d\x2a\x0a\x72\xc5\xc1\x79\x43\x6b\x99\x78\x65\xad\x12\x4e\xf6\x1f\x70\x47\x95\xa0\x0d\x01\xd4\x61\xd3\x81\xc5\x0a\xd1\x5d\xcf\x8b\xc7\xb3\xc0\x36\xd9\x67\x0e\x08\xc0\xad\xab\x01\x4c\x89\x75\xda\xb3\x85\x57\xf9\x99\xf2\xc8\xe3\x34\xd2\x88\x53\x40\x14\xa8\x51\x5a\xd6\x04\x51\xa0\x06\xa7\xec\x55\x27\xca\x59\xae\xc3\xe2\x28\xa5\xc5\xd9\x7e\x4a\xb6\x8f\x58\xaf\xf4\xcc\xb3\x15\x3e\xd4\xf1\x36\x0e\x6f\xd7\xb5\xe9\x8a\xa0\x43\x95\xdb\x7d\x85\x2d\xd5\xf7\x7d\xf1\xdd\x97\xdf\x9b\x4d\x48\xc6\x51\x9c\x92\x24\x85\x99\x9f\x8e\xf3\x9d\xc4\x1b\xc5\xb9\xb0\x06\x15\x8e\x9b\xec\x6f\xc5\xb7\x57\x46\x74\x14\x92\x05\x24\xcf\xd3\x3a\x8f\x16\x8a\xc6\x9a\xc2\xaa\x8c\xc4\xc9\x11\x39\xf9\xfa\xaa\x14\x5e\x46\x0f\x06\xe8\x55\x23\x07\xc7\x6a\x65\x6a\x30\x47\xa0\xab\x95\x0e\x1a\x36\x08\x5e\xd2\xa8\xe2\xa8\x47\xbb\xf2\xcf\x52\x34\x5c\xc7\xb5\x1f\x0a\x08\xf6\xbc\xac\xaf\x18\x75\x84\xac\xa8\x38\x15\x21\x27\x14\x75\xb2\x87\xc0\x0b\x14\x0a\xee\xd2\xcc\x8f\xd4\xd0\x91\x9d\x62\x68\x7b\x11\x16\x3b\xc1\x03\xed\xb3\x89\xdf\x27\xe3\x68\x32\x20\x71\x22\xf5\xc6\x0f\x98\x8b\x21\x2d\xc4\xef\x77\x50\x73\x57\xc4\xf3\xf9\x78\x17\x5f\x9c\x10\xcb\xb7\x1d\x34\x4b\xb0\xb7\x1e\xc7\x50\x49\x3d\xbf\x21\x9f\xbf\xee\x80\xf6\xf6\x0d\x07\x7a\xc6\xb7\x9e\xf1\x0d\xd9\x8d\x2b\xac\x5c\x00\x36\xd8\x03\xcd\x29\x9e\xb4\x5c\x7c\x0c\x37\xf0\x97\xe6\xe1\x0f\x7a\x16\xa4\xad\xdf\xc0\x5f\xc4\x06\x9f\x10\x13\x91\xd6\x93\x69\x5a\x41\x1f\x8d\x24\x6c\x31\x84\x84\x19\xf5\xf5\x19\x38\xaf\xa6\xe5\xbd\xb2\x3f\x90\x01\x68\x22\xc1\xe2\x39\xcf\xea\xae\x15\xd1\x9c\xdd\xe0\xc0\x6e\x60\xd8\x99\xa8\xb1\xb0\xd2\xec\xc9\xc3\xa4\xf1\x28\x0a\x42\xab\x22\xb9\x41\xe8\x7d\x6b\xd9\x7b\xed\x0d\xc5\xab\x53\xac\x82\xac\xa2\xe4\xa8\x6b\xb7\xe2\x84\x30\x25\xee\xc0\x81\xca\x6c\x41\x47\x2f\xfd\xb5\xe9\xcf\x80\x8c\x90\x43\xcb\x90\xa0\x9a\xdc\x73\x21\xd1\x53\x48\x30\xad\xf0\x80\xd5\x8f\x82\x43\x48\x8f\x9c\xe6\xfb\x12\x4e\xe8\x5e\xd8\xa6\x2d\x08\xf9\x9c\x97\x44\x73\x4a\x5c\x3e\x16\x71\x3f\x9a\x2e\x8d\xc9\xb0\xbb\xc7\xbc\x4a\xf1\xfa\xc1\x24\x79\x3b\x1a\xf0\x23\xa6\xfd\x24\x79\x37\x8a\x52\xf9\xf2\xd5\x80\x9c\xf0\x43\x57\xc7\x23\x9a\x4d\xb7\xef\x8a\xd6\xea\xc7\x50\xb4\x28\x18\x9d\x0e\x54\xc2\x28\x24\x15\xfb\xfc\x63\xf2\x26\xd6\x82\x25\x84\xbf\xa5\xd8\x0e\x44\x53\x2f\xc7\xd7\x16\x88\xe3\xf5\x38\x7d\x34\xca\x35\xd8\x11\xa9\xbb\x13\x42\xdf\xac\xca\x1b\xf7\xbe\x5a\xb1\x1d\xd1\x28\x3d\xa3\x78\xe0\x59\x1d\xd1\x56\x23\x0f\x9b\x07\x68\x32\xad\x9c\x57\xd7\x48\xd2\xd3\x09\x61\x22\x0d\x6f\xc2\xd1\x8e\xc8\x88\x33\xad\x1c\x58\x63\x44\xd2\x3b\xd1\x74\x36\x4f\xc9\xe0\x01\x2d\x65\x71\x4c\x1a\xfe\x6c\x46\xc2\xc1\x9d\x71\x30\x19\x58\xa2\x3d\x6c\xb2\xb4\x69\xa1\xfb\x71\x34\x23\x71\xca\x8e\xb0\x72\x55\x93\xd6\xc5\x24\x83\x00\xc2\x0e\xdb\x98\x40\x74\x2c\x58\xf4\x5a\xe6\xe9\xba\xe3\x40\xdd\xb3\x1b\xc9\x6c\x12\xa4\x56\xc5\xa9\xe8\xae\x4a\xab\x19\xe8\xb4\xce\x29\x98\x26\x59\xc0\x13\x76\x27\x2e\x7b\xf4\xd4\x63\x4b\x3d\x6e\xa8\xc7\x4d\xf5\xb8\x75\x90\xbd\x2a\x93\x8f\x80\x32\xce\x92\x77\x0c\x5e\x1d\x5b\x71\xfe\xb6\x05\xa3\x97\xb2\xd5\xdb\x0f\xac\xca\x38\x4d\x67\xed\x66\xf3\xe4\xe4\xa4\x71\xb2\xd1\x88\xe2\x51\xb3\xe5\xba\x6e\x33\x39\x1e\x51\x79\x35\x62\xe4\xe5\x80\x1a\x09\x49\x5f\x4f\xd3\x38\xe8\xcd\x53\xa3\x33\xd5\x21\x3a\xb1\x89\x21\x7a\x4e\x94\x94\x79\x1b\x3d\x3f\x21\x5f\xf5\x27\x0d\x3a\xcd\x47\x93\x60\x40\xe7\x4d\xdb\xbe\x32\x0a\x98\x2c\x33\xf5\xd3\x38\x58\x5c\x31\x87\x30\xd0\x3e\x6f\x74\xa3\x27\x1e\xfa\xe2\x61\x20\x1e\x88\x78\x18\x16\x7a\x3f\xef\xbd\x84\xf3\x85\xcf\x1b\x27\xa4\x57\x12\x27\x44\x1e\x70\xc0\x23\x62\xe8\xb9\x4f\x46\x31\xc1\xd3\x1f\xde\xae\x2b\x6e\x51\xbf\x7f\x6f\x9f\xcf\xf9\xa2\x9f\xd8\x11\x41\xa5\x55\xb5\x59\x74\x34\xa5\x58\xf1\x04\xa6\x3f\xf1\x17\x54\x94\xc4\x33\xaa\x41\x6d\xe6\xcc\xcb\x34\xa1\x36\x78\x78\x7e\xee\x6a\xec\x5d\xe8\xbb\x30\x70\x80\x98\x67\xef\xb8\xf6\x25\x75\x2f\x8a\x92\x60\x78\xf6\xd1\xd8\x70\xf2\xb9\x77\x65\x0f\xd6\xa1\x67\xd3\x45\x6c\xb3\x23\x81\xf4\xd4\x8b\x04\x41\xe1\x41\x07\x0d\x8a\x7d\x5e\x6e\x60\x43\x1f\xed\x6c\xb0\x0e\x5c\x57\x1c\xd0\xf7\x9e\x78\x37\xea\xff\x86\x51\x7f\x9f\xc3\x19\x20\x1c\x0a\x48\x54\xf9\x0d\x0a\x45\x7b\x61\x35\xcb\x04\x01\x93\x56\x3a\x80\x9b\x58\x59\xdf\x46\x05\xb3\xee\x33\x4d\xba\xde\x13\xa5\x3a\x50\x17\x4a\xac\x20\x41\x5d\xb5\x4b\x9c\x20\x36\x15\xee\xaf\xb7\x81\xcf\xd1\x7a\xa7\x0f\x1d\x4d\x93\x6e\xeb\xdb\x6c\x3d\x07\xd0\xf9\x86\x33\x98\xa3\x74\x69\x2d\x1b\xa3\x5f\x3e\x1b\x67\x16\x4e\x78\x95\xf6\x0d\x9e\xf6\x8d\x72\x8b\xe4\xde\x8b\x3a\xae\x87\x3b\xaa\xe3\x48\x74\xd7\x83\xff\xe3\xdd\xf7\x5a\xbc\xf5\xe3\xa8\x05\x1d\x50\x6f\x9b\xd0\x01\xbe\x89\x4d\x66\x49\x30\x89\x42\xfa\xdd\x23\x75\xaf\x65\xec\x4f\x47\xc9\x38\xeb\x9f\x65\x2d\x44\x05\x64\x31\xb3\x16\x36\x5d\xbb\x79\xd0\x84\x85\x0d\x4d\x68\x65\x0e\x4b\x07\xe1\x0a\xe5\xeb\xa5\xe5\x53\xff\xbc\xf2\xe8\x7f\xc6\x60\xe0\xde\x2b\x3a\xf9\x31\xa9\xd8\x6c\xc2\xcc\xa5\x2b\xba\xf9\xc2\x75\x60\x7e\xea\x3a\x70\xe2\x1e\x60\xb2\xc7\x92\x3d\x9a\xec\x39\x70\xe2\x1d\xbc\x88\x43\x6c\x33\xd7\x81\x99\x16\xb4\x6f\x8e\x57\xba\xcd\x5c\x54\x02\xe6\xa7\xfc\x85\xaa\x01\x27\xfc\xb9\x25\xf7\x4a\xe6\x78\xaf\xdb\xcc\xe3\x79\xf9\x0b\xe6\xe5\xcf\x2a\xef\x80\x52\x84\x16\xa8\xd3\x2a\x64\x2a\x95\x89\xb4\x64\x1d\xdb\x2e\x52\x69\x3f\x0f\x16\x94\x9f\x29\xa9\x06\xa7\xf4\xe9\x34\x77\x75\xf1\x03\x71\x3c\xf7\xc1\x8c\xf4\x03\x7f\x02\x7d\x3f\x21\x78\xf0\x6e\xee\xc2\xff\xfe\xed\x6f\xc3\xdc\x13\xe7\x81\x07\x2d\xb8\x29\x99\x48\xac\x02\x1f\x88\x3e\x9a\x44\x23\xeb\x84\x76\xef\x89\x4b\xfb\x27\x1e\xf3\x35\x60\xa0\x1f\x22\xd2\x16\x8f\xbc\x97\xbb\x72\x4d\x4e\x89\x56\x43\xdf\xc5\x81\x76\xc7\x24\xa5\x1e\x4f\x3d\x55\xa9\x27\xae\xf0\x40\xa4\xac\x41\x87\x02\xf3\x7a\x7c\x20\xee\x25\xcf\x06\x83\x6d\x36\xe1\x0b\x24\x24\x31\x6f\x60\xc3\x8c\x63\x87\xb3\x8f\x67\x48\xbf\x41\x4b\xbf\x02\x90\xf6\x1a\x6d\xdd\x3a\xed\x94\x3a\xab\xfe\x84\x22\x86\x23\x6c\x1d\x06\x2d\x79\xd7\x0c\x7e\xc3\x61\xb8\x0e\x03\xe3\x1e\x41\xaf\x18\x48\xbd\x08\x88\x57\x02\x24\x76\x75\x7a\x2b\x74\x7b\x14\x58\xcf\xc5\x31\x01\x75\xe8\xb9\x7a\x19\xaf\xa4\x0c\xad\xa4\xe7\xc9\x32\x1e\x5f\x6c\xd3\x2e\xb5\x62\x8a\x62\xbc\x5a\x57\x0a\x33\x0c\xf6\x80\xaa\x97\x6d\xdd\x21\xc6\x28\x5e\x62\x1d\x29\x80\x39\x74\x68\xf3\x9b\x60\xa9\x86\xc2\x3a\x58\xbc\xd0\x3a\x93\x09\xac\x6f\x13\x4a\x6a\x97\x62\x89\x82\x26\x76\xed\xac\xc5\x20\xcb\x47\xf3\x42\x3e\x9a\x17\xf1\x11\xaf\xb0\xc9\xb1\xd4\x2b\x2c\xe1\xa6\xa0\x31\x98\xc7\x78\x0b\x0c\x74\xe0\x01\xac\x83\xe7\xba\xae\x7e\xe6\x2d\x28\x99\x10\x5e\xde\x89\x65\x2e\xa5\xc6\xc9\xe4\xcb\x51\x78\xf9\xed\xa5\xc1\xc6\x39\xae\x5d\x5b\x97\xbc\x67\xf8\x5c\x9f\x31\xcf\xdd\xc9\x6c\x2f\x8d\x93\x89\x35\x16\x4b\xa0\xac\x59\x2a\x49\xfd\x38\x75\x80\x84\x83\xec\x7e\xf7\x78\x4e\x2c\xf6\x79\xb5\x28\x51\xaa\xc9\x62\xab\x7e\x9c\x4c\xf8\x39\x44\x0a\xc5\xb6\x1b\x63\x07\x2c\x12\x0e\x9e\x1b\x1e\xc5\xd6\x6e\x18\x1b\xda\x17\x75\xbc\x2a\x58\x5e\x20\x96\x8d\x04\x89\xd1\xd0\xaf\xc8\x9d\x5c\x19\xf0\x09\x03\xae\x6f\xd3\x2b\x4f\x9a\xab\xa9\x82\xc3\x63\x15\xe9\x2e\x0e\x4b\x4d\x92\xac\x2c\x76\xbb\x66\x55\xe4\x14\xa1\xcb\xc9\x5c\x2a\x25\xca\x24\x97\xaa\x5a\xc3\x9f\x0a\x6c\x94\xc8\x52\x35\x19\x62\xe4\x8c\x6f\xd0\x5f\x65\x18\x08\xca\xf2\x17\xf1\xa4\x19\xcf\x09\xf3\xe0\x63\x3a\xa2\x18\xfd\x1d\x58\x1d\x50\xd1\x2d\x6b\x39\x39\xf6\xf2\x02\x0c\x70\x5a\x28\x7c\x7e\xf5\xe5\xd8\xc4\xef\xe5\xc4\x15\xad\xe4\x2a\x86\xe7\x65\x05\x1d\x61\xc7\xae\xfd\x9e\x29\xe8\x26\x97\x15\x74\x19\x78\x4c\xd0\x4d\x8c\x03\x92\x57\x23\x26\x7c\x26\x20\x7c\x5b\xf7\x1f\xbd\x1a\xd0\x3d\x06\x5a\x1d\xd3\x7c\x69\x22\xae\x54\xc0\x15\x89\x2c\x4e\x07\xba\xf2\xcf\xa4\x51\x52\xf4\x32\x69\xe5\x82\xad\x50\xac\x9d\x15\x9a\x9d\x5e\x60\xc0\x8c\x12\x35\xa6\xff\xcf\x48\x8d\xe9\xbf\x74\x35\x86\x4f\x0e\xfd\xab\x52\x63\x32\xf0\xf2\x6a\x4c\xff\xca\xc6\x48\x9f\x8d\x8e\xfe\x67\x6a\x8c\x48\xa5\xb4\xed\xff\x8a\xa9\x31\xfd\xe7\x53\x63\xfa\x52\x8d\x59\x19\xd0\x4a\x6a\xcc\x4b\x0c\x1e\x72\xd5\x61\xb6\xa5\x57\x39\xa5\xcc\xa5\x03\x69\xbf\x5a\x92\x51\x3b\x77\x90\x91\x8f\x56\x3e\xcf\x17\xfc\xe9\xd4\xb7\x64\x44\x5a\x74\xe1\x3f\xe5\x81\x64\x0b\x20\xe6\x05\xeb\xd5\x88\x56\xb6\x89\xd4\xd7\x0e\x67\x5d\x85\x80\x2d\x84\x9a\x17\xb3\x2f\x78\xbd\xf8\x82\x45\xed\x4b\x15\xb6\x4b\xc5\x6d\x99\xc0\x2d\x5b\x39\x9a\x42\x57\x3f\xbf\x7d\x6a\xe7\x32\x2d\x93\xc1\xa5\x52\x98\xcb\x61\x19\x9d\x59\xb2\x42\x63\x44\xf9\x5e\x3f\x33\x88\x03\xc1\x8c\xa0\xac\x9d\x27\x04\x38\xb3\x2d\x61\x27\xbf\x32\x81\xae\xc6\xd5\x73\x88\x75\x43\x84\xe9\x2d\xba\x4a\x11\xff\x2b\x74\x7d\x8c\xee\x82\xe6\x88\x58\xe2\x68\x5b\xf5\xa7\xb3\x49\xe6\x36\x2f\xe6\xda\x28\x03\xe4\xe1\x8d\x51\xfb\x80\x5e\x56\xfb\x50\xab\x05\xb6\x28\xc5\x2e\xf7\xd2\x61\x5b\x01\x34\xc1\x0a\x71\x27\x45\x5f\x6e\xf0\x02\x25\xa6\xcb\x57\xea\xae\x95\xc1\xc6\x39\x01\xee\x2e\xef\xf5\x3e\xd8\x38\x1c\x46\xf1\xd4\x2f\xbf\xca\x63\x83\x5f\x1f\x76\x05\xbb\xc5\x2c\x66\x9a\x03\xfd\x68\x1e\xa6\x0e\x24\x33\xd2\x0f\x86\x01\x06\x6f\x16\x7d\xcf\xa7\x25\x96\xb3\xeb\xaa\x0b\x06\xd2\x68\xa6\xd2\x79\x2c\x37\x2d\x6e\xb4\xca\x47\x66\x2b\x4f\x40\x32\xea\xdc\x08\xc7\x56\x1a\xf4\x8f\x1e\xd0\xf2\x4a\xc6\x3a\x58\x31\xc7\x58\x3f\xb4\xe7\x42\x9b\x25\x4a\x09\x3f\x8b\x49\x3f\x48\x82\x08\xef\x37\x93\x4d\x5b\x4d\xd8\x6b\xbd\x20\xa4\x07\x7b\x7f\x20\xe1\x30\x9c\x14\x58\x89\x4a\xc5\x19\x56\xa0\xad\x11\x13\xeb\x3f\x09\xd2\xfe\x18\x54\x81\x46\x7a\x3a\x93\xf1\x82\x71\xd3\xab\x92\x54\xda\x86\x6e\x20\x5c\x41\x50\xc0\x4f\xfd\x05\x93\xf4\x7e\x2f\xe1\x13\x3c\x0f\xb8\xc0\x12\xa2\x99\x12\xfd\xb8\xa3\x2e\x2b\x92\x74\x90\x38\xde\xb8\x01\xfc\x1e\x4f\xed\xdb\x85\xc9\x42\x44\xa8\x62\x06\xe1\xbe\x8c\x59\x4c\xbb\x8a\xcc\x84\x4f\x8d\x6d\x43\x21\x2e\x66\xff\x68\xb3\xc7\x45\xf1\xe8\x69\xdd\x63\x20\x21\x6a\xd5\xbd\x7b\xc4\xad\x03\x8c\xe2\x95\xb6\xf6\x42\x8c\xb7\x91\xf1\x36\x33\xde\x62\xad\xa3\x5e\x0e\xad\x87\x26\xad\xdf\x8d\xe6\xe2\x4c\x26\x23\xf5\xca\x2c\xb2\x42\x77\x40\x3d\xcb\xa6\xcc\x81\x90\x28\xcf\xf1\x5e\x4c\xfc\xa3\x3c\x39\x87\x06\x95\x3e\xf7\xd2\xa9\x34\x30\xa9\xf4\x66\xb0\x20\x1a\x95\x9e\xa3\xe9\x9f\xab\xd8\xb0\x0e\xad\x92\xe6\x9f\x5d\x28\xd8\xa4\x81\xb1\xaf\xf1\x6e\x86\x6b\x4b\xee\xbd\xda\x7b\x09\xf7\x5e\xbd\xa8\x45\x23\x6b\x67\x6e\xb5\xf8\xa2\x5c\xbc\x74\x91\x20\x2b\x7d\x31\xf6\xfd\xc3\x49\xd4\xf7\x97\x5c\x70\xbd\xb1\xdb\x92\x5e\xbe\x2c\x2b\xd3\x41\x39\x45\xb4\x67\x8e\xee\xda\x1a\x47\xe9\xcb\x98\xdb\xa2\x03\x69\x40\xfa\xc1\xd4\x9f\xb4\xa1\xd2\xa8\xa0\xcb\xd9\x38\x9a\x27\x7e\x38\x48\xda\x78\xc2\x63\x0d\x60\x14\x47\xf3\x59\x10\x8e\xda\xd0\xdd\xc0\x19\xb8\x3f\x8f\x63\x12\xf6\x4f\xdb\xd0\xad\xfc\x8b\x8a\x03\x95\xca\x41\xe6\xde\x04\xb3\x1a\x3c\xfd\x1d\xd0\x0f\x6c\x6a\x62\xb8\xae\x78\xbd\x8d\xa0\x41\xe1\x0a\x49\x83\xcc\x35\x47\xca\xf2\x1d\x5e\x43\x43\x10\x02\x4c\x41\x9e\xf9\x2e\x88\xa3\xe2\xaf\x70\x5a\x16\x18\x89\x5f\x82\x53\xfa\x25\xb5\x2e\xd1\x4b\x8e\xea\xc1\x62\x6b\x2c\xbb\x70\x08\x4e\x82\x81\xba\x6b\x46\x68\xdb\xcc\x2f\x33\x7b\xa3\x51\x6a\x5c\x02\x95\xb9\xbc\x95\x45\xbc\x10\xb5\x6b\xba\x1c\x80\x88\xa0\xc0\x2f\x7c\x54\xf7\xf4\xc2\x2d\x70\xa9\x74\x1e\xd1\x07\xf3\x08\x1c\x2f\x53\x83\x11\x3a\x66\xdd\x12\x78\x8e\x74\x95\xc5\xe3\xe8\x43\x9d\xd7\x21\xe7\x90\x54\xbb\x4d\xa8\x91\xcc\x7b\xec\xf4\x8c\x15\x40\xbd\x03\x23\x07\x02\x0a\xd8\x54\x69\x64\x8d\x1d\x56\xa5\xad\xea\xd4\x24\x72\xa6\x95\x94\x02\xd6\x23\x96\xfd\x73\x32\x99\x13\xee\xc0\x58\xe4\x8a\x58\x66\x8d\x98\x1c\x93\x38\x21\x96\xcd\x8e\x81\xa8\x5e\x2a\x3f\xfe\xbb\xe7\xbe\x04\x5f\xd8\x4b\xf2\x5b\x38\x9f\x92\xd8\x9f\x2c\x63\xb2\xcc\x79\x57\xd6\x29\x31\xc1\xc3\x4b\x56\xb3\xeb\xd6\xf7\x0e\x9a\x23\x4d\xca\x06\x39\x47\x2a\x51\x49\xb7\x16\x08\xaa\x2e\x25\xd7\x0b\xbc\x4a\xe0\x39\xc9\xb5\x70\x80\xc7\x84\xc7\xb8\xa8\x8d\x34\xba\x2f\xf4\x03\x6b\xc6\xae\x93\x88\xe6\x69\x5b\x2d\x7e\x43\xcc\x26\xce\x1e\x05\x18\xa7\x17\xef\xc2\xc5\x93\x49\x81\x67\xae\x8b\xf9\x4e\x1a\x5f\x0f\x2c\xf0\xbe\x2d\x41\x4b\xa6\x38\x35\x2a\x6d\x56\x3c\xf0\xf0\x36\x62\x93\xbb\x59\x1e\x97\xe6\x19\xb2\x7b\x77\xd9\x55\xc4\xac\xc4\xfe\xb2\x42\xa4\xd2\x66\xc9\xb4\x01\xe2\x13\xa7\x92\x04\x77\x4b\x02\x73\xf7\xf3\x9a\x8e\xe6\x63\x84\x59\xe1\x36\x2c\xf8\xc1\x06\x97\x36\xda\x86\x9a\x4c\x08\xb8\x6f\x57\x1b\x16\x25\x4c\xf0\x02\xfd\x91\x2e\x31\x87\xb3\x39\xe6\x0d\x36\xcb\x96\x07\x93\x6a\xb5\xc4\x25\x7f\x57\xc6\x68\xe8\x00\xb8\xe2\x2c\x9b\xc1\xb2\xf8\x0c\x26\x85\x2c\x0f\x33\x0c\xe4\xe1\x84\x85\x34\xf1\xa1\x01\x2c\x22\xc3\x61\xd0\x0f\x48\x88\x2b\x7c\x6d\x42\xa0\x48\x87\x22\xd9\xd3\xe3\xff\xc9\x2f\x2c\xaa\x4f\xc5\x6d\x54\xa0\xa6\xd9\x85\xea\x22\x03\x97\x9d\x15\xb7\x42\x59\x42\xab\x8a\x57\xd1\xd6\xd3\x84\xe1\xe0\x96\x82\x5f\x63\xa1\x7c\xb4\x3c\x92\xcb\xf4\x3c\x78\xa0\x13\x71\xc8\x67\x35\xf2\x15\x55\x6b\x60\x2e\x73\xd7\x8b\x30\xab\x41\x4b\x6b\x51\x09\x3b\xbf\x40\xb7\x94\xe7\x65\x35\x43\xf6\x97\x0d\xc7\x57\xeb\x1e\x7d\xd1\x21\x4b\x62\x4b\xec\x5d\xd1\x48\xc4\xe5\xa1\x4e\x21\xa9\xbf\xb8\x0e\xd4\x57\x19\x95\x0a\xd9\xc2\x01\xa9\xad\xc2\x71\x21\x5a\xd2\x01\x2f\x61\x43\xf0\xd5\xed\x00\xe3\x86\xb3\x82\x7e\x90\xcf\xf5\x5d\xf1\x12\x84\x96\x78\x1e\x4e\xa2\x28\xb6\xae\xa0\xab\x38\x12\x4d\xd8\xb0\x6d\xba\xea\xdf\x80\xfa\x4a\x72\xf9\x6a\x38\xe0\x25\x84\x87\x7c\x95\x39\x60\xea\x73\x49\xc5\xcd\xc6\x26\xd5\xf0\xbb\x9e\x8a\xd9\xeb\x98\x79\xbf\x98\x69\xae\xa0\xe7\x78\x25\x57\x00\x89\x75\x3d\x9d\x8e\x4a\x7a\xff\x25\x6c\x72\x5c\xfc\x36\x91\xe8\xb2\xa7\x9f\x5f\x81\x5d\x92\xcb\xc5\xfc\x14\x11\x1c\x96\xe8\x80\x97\x04\xbe\x71\x78\x18\x06\xfd\x65\x76\xa2\x4b\xba\x3b\x6c\x22\xd6\x69\x10\xce\xa3\x79\xf9\x6d\xdc\xde\xe6\x2e\x8f\x57\x6a\x58\x80\xb4\x80\x01\xf9\x80\x59\x56\x4f\x3f\xbe\xd1\x83\x26\xf8\xb6\xd0\xa6\x6e\x83\xa1\x61\x18\x03\x90\xe6\x5e\x60\x6e\x68\x42\x6f\x9f\x1b\x8a\xa9\x06\x76\xee\x48\x32\xba\xa0\x70\x24\xf5\xb2\x21\xbe\x97\xb7\xc1\xa7\xea\x6a\x1e\xe7\x54\xc3\xb9\x2e\xb7\xd1\xeb\x3d\x07\x52\x5b\x0f\x31\x5e\xf7\x1d\xf0\xa0\x0e\x78\x45\xac\x6c\x46\x21\x18\x59\x26\x07\x44\x87\x91\x39\x62\x1d\x9d\x78\x6e\x46\x45\x0b\x92\x37\x83\x30\x48\xf1\xb2\xa8\xdb\x50\xb3\x2a\x1e\xc1\x80\x25\xb8\x9a\xe2\xca\xb7\xcb\x57\x56\x26\xa8\x99\xd5\xf3\x13\x73\x16\xa5\x09\x2c\x3a\x26\x2d\x86\xd5\xc9\x56\xc8\x6f\x88\xe8\x5d\x11\x20\x94\x2c\x66\xf9\x86\xe6\xfa\x18\x1b\xea\x27\xc4\x81\x45\xbe\x59\x93\x68\xb4\x0c\x17\xb3\xbe\x49\x34\xca\xa3\xe4\xa1\xe9\x49\x7c\x97\x48\x3f\x79\xa2\xb2\xb4\xf4\x1c\x2d\x95\xc1\x62\x39\x34\xc6\xa5\x88\x38\xe7\xf1\x2b\xf2\xaa\x9f\x10\x66\x2e\x36\x39\x6c\x38\xa1\x5c\x3b\x2c\xb6\xa2\x64\xef\xf4\xaa\x0f\xad\xfa\xc2\x56\x2e\xac\x3a\x55\xac\xcc\xa1\xdc\x55\x16\x7e\x99\xf1\x2d\x76\xbd\x32\x26\x56\x6d\x10\x38\xe6\x98\x90\xd7\x64\x75\x3d\x07\x3c\xf7\x40\xee\x92\x66\xae\x14\xe3\x3b\xc2\x62\xa3\x83\x11\xd1\x93\x26\xc4\x49\x34\x4a\xd8\x9c\x30\xb3\x3c\x75\x9e\x6a\x16\x9d\xd0\x64\xe4\x3e\xcf\xb5\xcd\x4b\xcf\x62\xc2\x82\xc2\x08\x0a\xe9\x30\x78\xaf\xe8\xe5\x31\x89\x1f\xf8\x1a\x8a\xeb\xca\x2c\xbb\xeb\x1e\x50\xb6\xb7\x45\x71\xd1\x1f\xf4\x55\x41\x10\xa9\xf4\x35\xe3\x57\xcc\x0c\xc5\xc6\x3d\x6b\xbc\x79\x17\xba\x3e\x8d\x97\xa9\x1d\x3a\xaa\x61\x36\x67\xda\xfd\xcc\x1d\x66\x92\xb6\x97\xb8\xa0\xcd\x3a\xb4\x33\x35\x08\x4a\x64\x6b\x49\x83\xfe\x51\xa2\x57\xc2\xb6\xc1\xf5\xb3\x85\x72\xa3\x5e\xbf\x68\x7e\x9e\x59\xf4\x03\x1c\x63\xca\xa0\x68\x1b\x1f\x20\xe6\x96\x61\xbc\x93\x1c\x3a\x70\x0c\x37\x61\x6e\xa3\xb9\x6b\xee\x20\xb0\x63\x07\x21\x04\xfb\xe6\x5d\xfc\xb4\x87\xac\xb9\x6d\x1a\xa5\x31\xf1\x58\x4b\x9c\x69\x37\xef\x6b\xf6\x6c\xf3\x1a\xff\xc2\x5d\xff\x1a\xf3\x5e\x90\x19\x1f\xf3\xfb\x1b\x25\xb6\xd7\x59\xa7\x7d\x0e\x3c\x9b\x4a\x8b\x47\x50\x87\xec\x6d\xf9\x42\x52\xb0\x78\x8f\x01\x1e\xf3\x75\x10\x51\x2d\xf9\x11\x57\xdd\x78\x99\x21\x58\x73\x66\x2d\x43\x4b\x20\xb3\xf2\x3d\x32\xac\x7c\xf4\x0f\x3f\x1e\x31\xa3\xe0\x8c\x31\x79\x62\x05\xf6\x3e\x1c\xc1\x4d\x2e\x6b\x6a\xb5\x23\xbd\x04\x33\xe3\xcf\x60\x1d\x8e\xf6\xb5\x44\x5a\x61\xca\x88\xce\x45\x01\xc9\x7f\xbe\x05\xc7\x19\x6b\x38\x92\x84\xd9\xda\x75\xc7\x2f\x31\x8f\xf1\x30\x5a\xab\x35\x01\xe9\x58\x2f\x68\xc9\xad\x0e\x78\xfb\x50\xaf\xff\xbf\xd8\x8e\x35\xad\x35\x02\x87\xc7\x17\xf7\x3c\x19\x4b\xcf\x93\x84\x49\xd5\xc0\x81\x47\xda\x7a\x13\xb9\xc7\x81\xd0\xb6\x1b\x53\x7f\xa6\x0b\x1a\x73\x17\x21\x86\xdb\xf0\x58\xed\x24\x40\x1b\x1e\x17\x0d\xdc\x37\xc5\x3e\x98\x39\x7a\x73\xbe\x38\x99\x2d\x74\x15\x78\x45\x77\x6c\x31\xe7\xf9\x4a\xc3\x25\x18\xa1\xd2\xa9\x28\x71\x9a\x9e\xce\x48\x34\xd4\x4a\x5d\xef\x74\xa0\x22\x2a\xaf\xd8\xcf\xe5\x28\xb3\x7c\x37\x5b\xa0\x20\x06\x71\x07\xee\x85\xb8\x27\x78\x2a\xed\x93\x32\x7b\x3e\x37\x6f\x2e\x7f\x05\x8f\xdf\x2f\x84\xb7\xb3\x66\x36\x9c\x90\x0c\xeb\x3c\x6b\x53\x97\x92\x96\xdd\x10\xbb\x50\xd0\x6c\xc2\x7b\xef\xbc\xf1\x0e\x0c\xfd\x24\x05\x92\xa4\xc1\xd4\x4f\xc9\xed\x42\xcf\xf8\x41\x3e\xe6\xd8\x00\x9a\x8c\xff\x35\xf9\x80\x32\x6d\x60\x9b\x9b\x56\x01\xac\x33\x84\x6e\x8a\xd1\xe3\x36\xb6\xa8\xd8\x5c\xef\xc8\x39\x43\xab\x33\x80\x9b\x1d\x38\x82\xdb\x8a\x14\xb4\xf6\x76\xc6\x3d\x5e\x63\x22\xba\x9c\x58\x72\x4f\x26\x17\xfb\xe7\xf6\xa4\x5c\x98\x14\x6f\xde\x8a\xc9\x43\xd2\x01\xcd\x2d\x25\xaa\xa1\xa2\x0b\x33\xca\x20\x5d\x16\x94\x2e\xe2\xc2\x7f\x80\x3e\x09\x26\xe7\x16\xa7\x99\x8c\xd2\x7c\x5f\xe9\xa2\x97\x85\x5e\x5c\xbb\x62\x34\x40\xb0\xea\x06\x50\x87\x29\x6f\xa8\x36\x30\x35\x25\x7f\xdb\x68\x52\xb2\x1f\xbd\xe7\xbe\x44\xbf\x8d\xd5\x83\xa4\x45\x27\xcf\x17\x1f\x2d\xf9\x20\x4e\x2f\x6b\x5c\x7a\x71\xab\xec\x17\x7b\x4d\xf0\x85\xd6\xd9\x4a\x0b\xf6\x83\x84\x58\x0b\xb5\x7b\x61\x5a\xe4\xf9\x92\x4e\x5b\x85\x1a\x59\xdb\xc6\x7d\x57\x32\x3d\xb7\xf8\xd3\x96\x16\xda\x1e\x8e\x27\x9d\x31\x57\x5d\x6e\xb4\x9e\x77\xb9\xb1\x74\x79\x61\xae\x0f\xca\xec\x0f\xa6\x05\x82\xd1\xaf\xa7\x13\xa5\x0e\x96\x2f\xbf\xf8\xda\x17\x69\x9f\x28\xb5\x50\x58\x05\xdd\x51\xcf\x99\x2a\x56\x32\x56\xb8\x2b\x19\x2b\x72\x11\x87\x4b\x1b\x7d\xe1\xc6\x96\x9f\xe6\x92\xba\x08\x2b\x24\xa2\x98\xb3\x0b\xd3\x14\x13\x89\x33\x57\x52\x9c\x6a\xac\x73\xa1\x95\x8b\x56\x8e\xae\x8f\x8c\x8b\x99\x31\x46\x5a\x5b\xd6\x7a\xd5\x12\x3c\xc7\xb0\x25\x12\x1c\xc7\x88\x6c\xa0\x65\x52\xf1\x05\xde\x1b\xad\x22\x15\x7d\x10\xa7\x96\x31\xf6\x33\x28\x51\xf5\xa0\x70\x02\x79\x15\xa3\x6c\x7e\x30\xf7\xc3\x34\xa0\x33\xde\xab\x66\x21\x5e\xe5\x06\x7a\x5d\x3e\x8b\x96\x14\x5e\xe5\x2e\x97\xc1\xe2\xc6\x75\x95\x92\x8e\x63\x92\x8c\xa3\xc9\x20\x51\xcb\xce\x52\xd3\x87\x3c\x2a\xc1\x02\xd6\xea\x4a\x2b\x42\x6e\x18\x3e\x52\x06\x68\xed\xe8\x05\x9e\x9c\xd8\xd7\xdd\xb4\x64\x7c\x5b\x55\xa4\x1b\xe0\xfa\xfd\xe2\x0b\x20\xe6\x44\x2b\xc8\xa1\xeb\x7f\x0e\x04\xd0\x84\x70\x99\x5d\x25\x1b\xe0\x5a\x5f\xbc\x70\x07\xdf\x05\x95\x0e\x0b\x15\x30\x11\x1b\xde\xbd\x20\x92\x6c\xb8\xf5\x82\x84\xf4\xb9\x90\x55\x2d\x77\x60\x61\x1f\xec\x17\xdd\xa8\x7f\x77\x91\x66\xa4\xda\x69\xb6\x67\x58\x37\x04\xe1\x80\x2c\xde\x19\x5a\x99\xa3\xb2\x01\x9f\xa5\xbb\x6f\xfb\x6f\x3b\xf0\xb6\xff\xf6\x01\xb4\x65\xe4\x9f\x80\xbb\xc3\xe4\xbb\xa0\x9d\x3f\x3d\x41\x21\xa9\x8c\x4a\x84\xea\x85\xb5\x82\xf9\xe3\x15\x08\xe7\xe0\x02\x06\x27\xec\x81\xac\xd0\xb6\xcd\x65\x82\x7e\x17\x3f\xe8\xec\xcf\x12\xcc\xd3\x3e\x8c\x85\x0f\xa5\xdf\xd3\xc0\x74\x73\x42\xdb\x1d\xcd\xd0\x0d\x0e\x1c\x18\xc0\xf5\x9c\xa7\x37\xfd\x5a\x1b\xfc\x3f\xec\xbd\x79\x77\xdc\x36\xb2\x38\xfa\xbf\x3f\x05\xe2\xdf\xbb\x51\xb7\xdd\x6e\x03\xe0\x2e\x8d\x26\xd7\x71\x9c\xc4\xef\x3a\x76\x8e\xad\x4c\xc6\x3f\x3f\x1f\x05\xc4\x62\x71\xdc\x22\x35\x24\x65\xab\x27\xd6\x77\x7f\x07\x1b\x09\xb2\xc9\xee\x56\x4b\x56\x32\x73\x1d\xe7\x40\x4d\x2c\x05\xa0\x50\x55\x28\x6c\x55\xd3\xa9\xad\x5c\x2d\xed\x59\xa7\xf2\x79\x55\x94\xdb\x13\x85\x16\xf9\xa4\xa2\x5c\xdd\x23\x36\x4f\xb2\xdc\x35\xb9\x65\xc7\x3e\xde\x2c\x5b\x5f\x69\xb6\xb3\x85\xb6\x91\x42\x96\x62\x15\x82\x65\xc3\xe6\x94\x2c\x16\xab\x7b\x7c\x9a\xfc\x9c\x61\x70\x5b\x69\x79\xb2\x5a\x33\x51\x3a\x44\x35\x02\x65\xc3\x4c\xdb\xca\xc1\x46\x09\x9a\x77\x26\x72\x27\x5e\xb5\x56\xe3\xe1\x0a\x2b\x21\x74\x8b\x56\x43\xaf\x38\x91\xfd\xeb\xdf\x74\x22\xdb\x6d\x21\xb3\xd5\x1a\x69\x60\x92\xfc\x97\x3b\x49\x2a\x53\x83\xcd\xf9\x80\x32\x26\xd8\x2c\x37\x72\xf7\xa3\x15\x27\x70\x1e\xac\x4e\xa8\x70\x06\x50\x6f\xf6\x1c\x98\x43\x94\x6b\xe0\x8b\x9b\x9e\x3b\xec\xf4\x76\x31\x53\x62\xcd\x99\x3d\x36\xce\xe4\x0f\x50\x4f\x58\xf6\x9f\x48\xae\xce\xd1\x46\xa6\xab\x77\x91\x93\x49\xa6\x6f\xb1\xdd\x03\xca\xac\xe2\x44\x4e\x19\xb9\xfa\x54\xb6\xef\x26\xb9\x31\x33\x39\x3a\xe3\x5e\xe7\xa4\x41\x8d\xdd\xfd\x63\x65\xfa\x51\x8d\xdc\xfd\x63\x65\xf9\xb1\x23\x92\xde\x5c\x40\x99\xba\x32\xd7\xec\x24\x33\x73\x65\xdb\xef\x26\x04\xe7\xd4\x99\x0d\xaf\x22\x44\x3f\x97\x26\xe0\x2c\x19\x65\x22\x92\x89\x12\x73\xcd\xd4\xdf\xcd\xf1\xd7\x43\x90\xcb\x2c\x26\x39\xd7\x87\x2d\x12\xcf\x4e\x36\x9b\x9a\x99\xd4\x86\x72\x56\x06\x63\x2b\xa1\xfe\xaf\x21\xa1\x6e\x87\x77\x5b\xb1\xbe\xcd\x4a\x6c\xfb\x65\x51\x7f\x6a\xb8\x85\x5b\xe1\x57\x9e\x1a\x9a\x29\xf5\xdf\x73\x6e\x70\xe5\x77\xd3\x95\xc1\x55\xce\xb8\x5c\xee\x08\xf4\x3f\x9d\x90\xbe\xfe\x61\xeb\xf5\xb5\xb8\x76\x39\xd7\x28\x4a\x8d\x66\xec\x2e\xed\xd4\xda\xcd\x18\x9b\x6e\x0f\x75\xc7\x84\xd5\x1f\xa9\x97\xee\xda\xa3\x5b\x90\xbe\x37\x26\x17\x1d\x7e\xf8\x6c\xda\xee\xad\xdb\x5c\x3d\xcd\x16\x0b\xc9\x37\x45\xce\xaa\xdd\x1f\x34\xaa\xed\xc9\x0f\xeb\xde\x41\x84\xcd\x8b\x46\xa7\xc6\x2d\x1f\x31\xb4\xd0\x07\x77\x4c\x7b\xe3\xf5\xf0\x21\xc8\x8b\xe2\xec\xce\xa5\x73\x7f\x87\x69\xe7\x44\xcd\xc5\x6d\xf9\x3d\xaf\x78\x7d\x94\x9d\xf2\xc9\x7d\xf9\x05\xee\xeb\xe4\x83\x4e\xb9\xbe\x21\x1e\xfb\xae\x21\x67\xea\x22\x29\x29\x6b\x73\x37\xf3\xe1\x43\xf0\x28\x07\xc5\x59\x9d\x9d\x66\xff\xe2\x4c\xe2\x4e\x7b\x9d\xd0\x86\x77\xe5\x62\xb8\x3e\xc9\x2a\x50\xa9\x04\x63\xd6\xd9\xc1\xc4\x9c\x7f\xe0\x65\x87\xf8\xcc\xe1\x78\x73\x5c\xa9\x4f\xc7\xde\xb7\x0f\x35\x9a\x4b\x5f\xef\xa7\xe0\xd3\x27\xf0\xd5\xe4\xbd\xba\x5f\xd0\xba\xe2\x3e\x5f\x2c\x9a\xcc\x2a\x11\xb5\x89\x4e\xd5\x07\x57\xf3\x17\xb1\xed\x60\x48\xa4\x5a\x06\xea\xa0\xdb\xe9\x8d\x42\xfc\x43\xf0\x5e\xaa\xb0\xef\x8d\x4b\xd8\xf1\x41\x5b\x33\x6c\x83\xe5\x57\xad\x28\xd9\xfd\x7c\x67\xfc\xa4\xde\xfc\x5e\x5b\x9e\x39\xb8\x9e\x57\x05\x07\xa5\xc6\x66\x4c\x87\xb7\x0e\xdd\x4f\x2d\x1e\x56\xef\xf4\xa2\x5b\xb7\x55\x7a\x4b\xac\xbf\x9b\xc2\x62\x0d\x57\x8f\x2b\x43\xe6\xe4\x4c\xdd\x8e\xfb\x1c\x22\xa5\xa5\xe2\x0d\x34\xbc\x65\x3f\x1a\x87\xca\x26\xe6\x95\x6e\xb4\xac\x74\xad\x23\xe3\x6d\x81\x1c\xec\x26\xf6\x3e\x43\xdd\x23\xa2\xb3\xcf\x7b\xd7\xae\x76\xb5\xc7\x9d\xfa\x54\x97\xdf\xf1\xfa\x97\xa3\xc7\xba\x4c\x35\xb1\xaf\x29\x76\xe6\xf4\x0e\x93\xb7\xfc\xbd\x81\xb5\x6f\xdd\x0e\xe9\x69\x96\x9f\xd7\xfc\x3f\x81\xb5\x75\x4f\xfe\xf4\xac\x4d\x3b\x24\xfa\x93\x6e\xf4\x55\x59\x7b\x14\xc8\x2d\xb0\xf6\x96\x75\xdf\x34\x6b\x8f\x55\xbb\x25\x6b\xeb\x02\x37\xc0\xd7\x9a\xcc\x9a\xc9\x5b\x73\xcf\xa1\xf9\x35\xca\xd7\x9f\xf1\x19\xde\x88\x7d\xe1\xe2\xbc\xfc\x4f\xe0\x6a\xd9\x8f\xcf\xc6\xd3\xb2\x82\x42\x88\x8a\xab\x67\xc9\x86\x52\x24\x73\xfc\xab\xc8\xf9\x0b\x95\x30\xb9\x11\xbe\x04\xff\xb5\x3d\x8c\xb4\x03\xe3\x47\xd9\x7f\xc7\x95\x9d\x69\xae\xba\xb7\x6e\x7e\xdf\xdf\xb0\x30\xdf\x0e\xf8\x98\x7c\x33\x72\xe2\x81\xa9\xed\x4a\x3c\x3b\x5c\xdb\x95\x30\x3a\x0c\x02\xdc\xb7\xcd\xb9\x05\x81\x37\xd2\x8b\xcf\x2b\xee\xc6\x06\x6a\x2b\x61\x27\xb3\xdf\x80\xa8\x93\xbc\x67\x0d\x16\x2b\x71\x72\xa8\xfe\x8e\x0a\xb9\xdb\xb3\x4c\x69\x6d\x2c\x91\xe5\x7f\x82\x8c\x63\x64\x2b\x83\xb1\xd7\x52\x5b\x34\x49\x40\xb5\xd3\x29\xff\xdf\x92\x71\xbe\x23\x35\x9f\x58\xb2\x52\x1f\xd3\x2b\x6d\x82\xb8\xf4\x0f\x1e\xa8\xcf\x41\x19\x6b\xb2\x0c\xa5\xdd\x8c\x62\x74\x15\xde\x23\x1d\x20\xdf\x91\xe5\x15\x58\xcf\xe0\xe8\x41\xf3\x20\x77\x67\xee\x63\x64\x69\xdd\x48\x4a\x32\x97\x13\xd4\x72\x94\xf5\x6e\xf1\x99\xef\x4d\xdb\x54\xab\xce\x73\x46\x96\x37\x6e\xc2\x6d\xcc\x62\xdc\x69\xd1\xa9\x6e\x58\xb0\xd4\xe7\xbc\x62\x6a\xdc\xc7\xf3\x7c\xe4\x2c\x77\x73\xdd\x54\xc3\xe9\x48\xc3\xeb\x93\xf3\xb2\xda\xdc\x74\x51\x66\x9b\x5a\x5e\x91\xfa\xbc\xdc\x98\x49\x0d\x4b\xb5\x36\x8f\xc6\xe5\xfa\x3c\x06\x95\xeb\x33\x35\xb8\xdc\x00\xcb\xa0\x60\x7d\x2e\x8d\x81\xf5\x79\x2c\x0a\xfe\xdd\xa7\x8f\xe6\xd0\xec\x23\xe7\xef\x19\x59\x5a\x33\x5a\xb7\xb4\x57\x3b\x34\x3d\x3c\x00\x4e\xcc\x52\xcd\x17\x11\x78\x00\xb2\x29\xf8\x2f\x10\xd9\xbb\x58\xe3\xb3\xd2\xb6\xdb\xbb\xe3\x33\x13\xb8\x67\xea\xb9\xf2\x3e\xef\xbf\xcd\x0c\xc5\x3b\x40\x7e\xe5\xfc\xbd\x55\xe3\xcd\x23\x63\xb5\xe9\xa4\x38\x18\x1c\x36\xb4\x01\xed\xaa\xb5\xe8\x25\x20\x93\x60\xc5\x5e\x9b\x82\x4d\x4a\x2b\xec\xda\x34\xcf\x96\x32\x5c\xe9\x24\xf9\x26\xc9\x08\xa3\x36\x21\xb0\x1b\x62\x56\x04\xb5\x49\xea\xf0\xa7\x6d\xb7\xda\x2c\x53\xbf\xec\xa4\xd7\x36\x5d\x2d\xb8\x8b\x7e\x5a\x23\x69\x0e\xed\x4f\x37\xd5\x11\x31\x87\xed\x47\xa7\x7c\x23\x5d\x0e\x9b\xdf\x6e\xba\x95\x2b\x87\xe6\x97\x9b\xd6\xca\x93\xc3\xe6\xf7\xe8\x64\xfd\x19\xdf\xed\x8c\xca\xe9\xfa\xe4\xb6\x4e\xee\x64\x5d\x9f\x5d\x9d\x55\x0c\xaf\x6f\x31\x5d\x53\xc3\xfd\x49\xb6\xb7\x11\x24\xfa\xeb\x6a\x3a\xae\x91\x18\xb6\xa8\x23\x28\x5a\x68\x56\xac\x7c\x7f\xbe\x58\xbc\xe6\xa4\xec\xe6\x6b\x63\xa5\x28\x41\x78\xdb\x3d\x2d\x0d\xfe\xda\x3b\x5a\x12\x4c\x2b\x1a\x24\xa5\x1c\xea\x1f\xa3\x14\xfc\x19\x1f\x0e\x0c\x53\xf0\x92\x93\xcf\xbf\x9d\xa5\x09\x58\x56\xf5\xd9\xe9\x57\x0f\x1d\x9c\x81\x1b\xa1\xe1\x86\x7e\x2c\x65\x38\x64\xb6\x03\x25\x6f\x22\xd2\x2d\xc9\xb3\x53\x60\xe7\xf3\x6f\x39\x1c\xa3\x07\xdf\xa6\x46\xe7\x98\xbb\x7f\x12\xde\x39\xf6\x06\xdf\xe8\x1b\xe3\xdb\xbd\xc1\xba\x8e\x62\xd4\xf4\xbd\x77\x52\xd0\x43\x6f\xe7\x58\x7b\x94\x3a\x6e\x44\x5f\xda\x4c\x23\xed\xf9\xf8\x75\x4f\xb9\xe5\x98\x19\x81\xa2\x19\xf7\x50\xfd\x1d\x13\x27\xf8\x33\x5e\xdf\x1e\x16\x27\xe7\x35\xfd\xe9\x3f\xe6\xe0\xab\xe9\xcc\x67\x97\x5a\xce\xf9\xe8\x15\xa4\xd3\xff\xc2\xd3\xa6\x5f\x8e\x1e\xdf\xd8\x81\x53\x33\xbc\x86\xa3\x1c\xda\x3d\x6c\x3f\x46\x79\xeb\x33\xde\x7f\x1d\xe5\xad\x1f\xff\x43\x0e\x9f\x4c\x57\x6e\x83\xaf\x2c\xb9\x5c\x6d\xe2\xff\x5f\x76\xae\xf1\xcb\xd1\xe3\x1b\x3a\xda\x30\x23\xdb\xb2\xd4\x8f\xe6\x80\xc3\xfc\x1c\x65\xa7\x5b\xbf\x7b\x79\x5e\xd3\xef\xfe\xfd\xf7\xa9\x0c\x96\xbf\xbb\x85\x93\x8e\x86\x48\xae\xac\x46\xff\x72\xf4\xb8\xb3\xab\x64\xbf\x77\x3f\xf2\xb8\xb5\x63\x87\xb6\xa9\x37\x70\xf2\xa0\x07\xaa\xe5\x8d\xef\xf4\xbe\x86\xfe\x35\xca\x19\xb7\x60\xaa\xfa\x73\x1d\x41\x9c\xd7\xf4\xd5\xed\x9e\x42\xc8\x79\x7b\x9b\x83\x88\xf3\x9a\x1e\x6d\x71\x16\x71\x5e\xd3\x5f\x6f\xf9\x38\x42\xb6\x6c\xbb\x13\x89\xf3\x9a\x7e\xbf\xf9\x50\x42\x8e\xc1\x36\xe7\x12\xcd\x58\xad\xdf\xe0\x6f\x10\xbc\x31\xdb\xd1\x36\x07\x14\x2e\x82\x37\x43\xdc\xea\x98\xa2\x41\xcb\xc6\x6c\xaf\xfe\xd3\x0e\x2b\x14\x36\xff\x88\xf3\x8a\x71\x09\xef\x9c\x5a\xa8\xc8\x0d\x07\x17\xc3\x93\xcc\xb6\x6b\xf1\x4d\x13\xcd\xee\x27\x18\x37\x7f\x8a\xd0\xf0\x9b\x9e\x01\x7e\xed\x9d\x25\x34\x7c\xd6\x4d\x46\x6d\xf2\x51\x73\xa8\xe0\xa4\xe3\x36\xfd\x57\xe7\x68\xc1\xc9\xe1\x39\x10\xda\x03\x06\x27\x83\xdf\x66\xf8\xde\x1e\x33\x38\xc9\x41\x9b\xfc\xaa\x3d\x6c\x70\x32\x34\xe7\x0d\x8e\x44\x39\x6c\x3f\xdc\xdd\x7d\x47\x98\x1c\xb6\x1f\xbd\x1c\x47\xed\xf1\x43\xfb\xd5\xcb\xf3\xab\x7b\x08\xe1\x7e\xf7\x61\x39\x47\x11\xce\x67\x2f\xd7\xf7\xcd\x81\x44\xf3\xd1\xcb\xf1\xca\x39\x96\x70\x3e\x47\xe7\xf0\x5b\xbf\x7e\xac\x91\x79\x6b\x87\x13\xb6\xba\xdb\x50\x42\x07\x8e\x28\xae\xa5\x9a\x76\x0f\x2a\x9a\x88\x9d\x76\x78\x9d\xd2\xce\x0e\x6f\x07\xe6\xa4\xcd\x3a\xbc\x1f\xdc\x49\xb8\xd2\xb9\x45\x5b\xcf\x4d\xec\x8d\x38\xa7\x17\x2d\x35\x1d\x36\xbf\x47\x69\xfd\xd6\xaf\xe4\x9e\xd7\xf4\xf5\xed\x1d\x63\x98\xda\x6e\x65\xef\x62\xf8\x30\xe3\x5a\xd4\xbe\xb2\x5d\xdd\xa5\xc3\xdd\x68\x7e\x0b\x42\xde\x9e\x84\x6f\xe6\x78\xc3\x0c\xd3\xbf\xdf\x09\x87\x8b\x81\x81\x43\x8e\x2e\xb6\x47\xce\x39\x56\x69\xe7\x06\x35\xac\xad\x28\xe8\xe6\xce\x3c\xcc\x40\xb6\x92\xe8\xb5\x39\xf9\xb0\x23\x3c\x26\x87\xfe\x5c\xfe\x59\xb2\xaa\xf8\x7e\x83\x1b\x8c\x04\xee\xbe\x54\xe0\x8e\x6b\xd0\x35\x56\x3a\xfd\xde\x82\xe1\x8c\x94\x15\x7f\x5a\x15\xcf\x49\x9d\x7d\xe0\x13\xed\xd8\xd1\x31\x38\x40\xd4\xe1\x47\xce\x3f\x02\x35\xeb\x9a\xf4\x03\xd7\xf9\x81\xb2\x0f\xa5\xe8\xb8\x61\x11\xf9\xd9\xe8\xb9\xb6\x0a\x70\x08\xee\x37\x80\xee\x62\x08\xe1\x03\x88\x1e\x40\x74\x04\xe1\xbe\xfa\x7f\x0e\x21\xfc\xbf\x77\xf5\x2b\xee\x6f\x7a\x2d\xbb\x03\xb6\xb3\xf0\xb8\x8a\x0a\x7b\xe4\x70\x5e\xd3\x9f\x25\x48\xcd\x81\xdb\x0e\x95\x65\xdf\xac\x2a\xba\xee\xc4\x35\x45\xdf\x90\x5f\x7f\xdb\xd7\x01\x3f\x33\xf8\x4f\xe5\x4c\xff\xb8\xce\x4e\xd7\x79\x44\xb9\x8e\x93\x18\x05\x7a\xa3\xa7\x98\x78\x57\x13\x4a\xb6\x86\x71\xde\xf0\x8c\x09\xa5\xeb\x3b\x48\xba\xf2\xd2\x5b\xb7\xac\xb1\x84\x49\x16\x3c\x67\xa4\xdc\x44\xaa\x4e\xa7\xde\xdc\xfd\x60\xa9\x5c\x29\x27\xf7\x1e\xbe\x9d\x6d\x87\x8e\x37\x77\xff\x69\x4b\x6a\x0d\xfe\x2a\x45\xcf\x6d\x51\xbb\xc6\xdd\xba\xe4\xc2\x96\x34\xdb\xb1\x5b\x17\x3c\xb5\x05\xed\x11\xc7\xd6\x25\x8b\xa6\x9f\xcd\xa9\xe3\xd6\x65\x4b\x5b\xb6\x7d\xfa\xba\x75\xd9\xbc\xad\xb7\xb5\xbd\xb0\x01\xc0\x2a\x47\xd8\x13\x1e\xb9\x22\x6d\xad\xb6\x37\xa6\x81\xa4\x54\x9d\xff\x72\xf4\x78\x22\x05\xab\x9a\xd5\xd1\x74\x06\x56\x63\xf1\xf4\xed\x88\x3f\x33\x7c\x0b\x56\xaf\xaf\x64\x72\x7a\x51\x94\x6b\xcc\x36\xc3\xf8\x7a\xde\xcc\xb6\x33\x16\xac\xdb\x30\xa8\xc4\xdd\x45\x22\x8a\x52\x5f\x88\x48\x40\x8e\x29\x81\x98\xb2\x10\x47\x38\x4e\xfc\x30\x4a\x59\x4c\x83\xd0\x4f\xb9\x17\x45\x14\x47\x42\xfe\x4b\x69\xca\x30\x46\x51\xca\xa9\xb8\x3b\x1d\x1a\x81\x5b\x30\x1b\xfb\x1f\x35\x02\x5e\xe2\xa5\x51\x12\xe0\xc0\x27\x5e\x98\x86\x9c\x8a\x84\x26\x9c\xf1\xd0\x8b\x12\x2f\x89\x29\xc1\x01\x4e\x03\x2a\xc2\x94\x72\x96\x26\x34\xa6\x21\xf3\x50\xca\x12\xee\x25\x3c\x4a\x49\x80\x79\x44\xd3\xc4\x8f\x7d\x8f\x7a\x09\x61\x7e\xe2\x13\x16\x86\x28\x4c\x79\x94\x84\x09\x8d\x52\x1f\x45\x1e\x09\x02\x94\xf8\x94\x87\x2c\x65\x8c\x27\x9c\x85\x83\xa3\xe7\xdd\x82\xad\xc4\xff\xac\xd1\x43\x31\x4e\x59\x98\x12\xce\xc2\x84\x53\xc2\x11\x0d\x59\xca\x05\x0f\x83\x00\x32\xc1\x62\xe6\x51\xc1\x08\x0f\x53\xc1\x18\x24\xd8\x43\xc4\x0b\xfc\xc8\xa7\x7e\x14\x12\xc4\x92\x24\xa5\x11\x4f\x28\x8c\x82\x30\x4d\x51\xc2\x13\x42\x63\xc9\x63\x8c\x32\xc2\x08\x4f\x43\x4f\xfe\x4b\x42\xf9\x2f\x65\xf2\x1f\x4b\xe4\xbf\xe1\xd1\xbb\x05\x73\x66\xff\x51\xa3\xa7\xa5\x1f\xe1\x34\xe2\xb1\x96\x81\x42\xa4\x69\x14\x6b\x49\x98\xc4\x4c\xc4\x44\xcb\x43\x21\x92\x38\x09\xb5\x54\xa4\x41\x0a\x59\xa0\x65\x23\xf5\x13\x9a\xf8\x5a\x42\x8a\x28\x0d\x99\x91\x93\x34\x92\xff\xb4\xb4\x94\xc3\x16\x33\x2d\x33\x13\xce\x08\x0f\x86\x47\xef\x4f\xe5\x9d\x9a\x79\x1a\x77\xa3\xc3\x17\xec\x7c\x26\xc4\xbc\x63\xc7\x18\xfd\x1a\xfa\xd0\xfb\x55\x9f\x91\x40\x56\xdb\x62\x35\x14\x27\xf2\xf1\x79\xca\x4f\xf8\x22\xbb\x78\x56\x18\x23\xbf\xdb\x50\x5e\x8b\x3f\x0b\x92\x5a\x38\x1a\x86\xa7\x94\x99\x79\x20\x03\x38\xdd\xca\x73\xe8\x46\x98\x0f\xb0\x6f\x81\xa2\x39\x9c\x0e\x52\xd9\xbf\xc1\x49\xfc\xd8\xa9\xf2\x47\x52\x9e\xde\xda\x21\x3c\x2d\x8a\xc5\x4a\x65\xff\x96\xfc\xa3\x1e\xb8\x90\xf2\x74\x6b\x0f\x4b\x7f\x10\x47\x3c\x40\x9a\x25\x22\xc5\x13\x5e\x70\x43\x4c\x11\xcb\x75\xc4\x3c\x50\xa0\xe3\xa9\x3d\xd7\x93\xc3\xfb\x67\x47\x08\x0e\x6f\x0f\x1f\x25\xc9\xf2\xb4\xf8\xb8\xb5\xfd\xfe\xf5\x75\xec\x76\x6e\x93\xf6\xb6\x20\x8c\xcf\x1a\xeb\xc0\x0d\x82\x4f\x9f\x40\xad\xac\xd0\x81\x1a\x3c\xe8\xec\x74\x6b\x17\x6d\xea\xa1\x56\xe5\x7a\x6c\xae\x8d\x03\x2c\xb5\xdb\xa7\xbb\x38\x3f\x01\x87\xc0\x0b\x21\xb8\x27\xa1\x00\x04\xa1\x9b\x28\x4b\xa3\x79\x20\x13\xe6\x81\xcc\x52\xb9\xa9\x92\x64\xe0\x3c\x56\x40\x93\x36\xb5\x71\x7b\xa2\x50\x78\x5f\x79\xcf\x1a\x5a\x9e\x7a\xb7\xe0\xf1\xfe\x73\x09\xdf\x53\xf2\xee\x94\xdc\xb8\xf4\x1d\xbb\x74\x95\xe5\x82\x97\x79\x71\xe3\xf5\xb1\x91\xfa\xce\x16\xa4\x1a\xe8\xde\xcd\x6b\xbb\xad\x85\x6f\x72\x7a\x66\xac\x7b\x36\x5b\xd5\x79\x63\x89\x54\xdb\x3a\x3d\x18\xf0\xfc\x5a\xf7\x2e\x78\x68\x73\xb7\xab\x8e\xeb\xb3\x5c\x7b\xee\xe8\xf8\xab\xaf\xc1\x3d\x90\x4f\xa7\xd3\xb7\xad\xa7\xd8\x9d\xb5\x2b\xd5\x81\xeb\xeb\xe0\xbe\x0f\x51\xe0\xfb\x3e\xc4\x41\xe8\x07\xd0\x0f\x22\x3f\x80\x41\x90\xf8\x21\x8c\x02\xe2\x87\x30\x0e\xa8\x1f\x42\x12\x30\x3f\x84\x69\xc0\xfd\x08\xb2\x10\xfa\x11\xe4\x21\xf2\x23\x04\x43\xcf\x8f\x10\x0a\x7d\x3f\x42\x5e\x18\xf8\x31\xf2\xc3\xc8\x8f\x51\x18\xc6\x7e\x8c\xa2\x30\xf1\x63\x14\x87\xc4\x8f\x11\x09\xa9\x1f\xa3\x34\x64\x7e\x8c\x68\xc8\xfd\x18\xb1\x50\xf8\x31\x12\x11\xf4\x63\x0c\x23\xe4\xc7\x18\x45\x9e\x1f\x63\x2f\xf2\xfd\x18\xfb\x51\xe0\xc7\x38\x88\x42\x3f\xc6\x61\x14\xf9\x31\x8e\xa3\xd8\x8f\x71\x12\x25\x7e\x84\x49\x44\xfc\x08\x53\x15\xb2\x28\xf5\x23\xb9\x0c\xf7\x23\x2c\x22\xe6\x87\x1e\x8c\xb8\x1f\x7a\x58\x85\x5e\x24\xfc\xd0\xf3\x63\xe8\x07\x5e\x10\x23\x3f\xf0\x22\x15\xc6\x31\xf6\x7d\x2f\x89\x3d\xdf\xf7\x88\x0a\xd3\xd8\xf7\x3d\x8f\xa9\x90\xc7\x81\x8f\x3d\x21\x43\x1f\xc6\xa1\x8f\x7d\x14\x87\x3e\xf2\x71\x1c\xf9\xc8\xf7\xe3\xc8\x87\x7e\x10\xc7\x3e\xf4\xc3\x38\xf6\x84\x1f\xa9\x30\x8e\x13\x8f\xfb\x89\x0a\x89\x0a\x69\x4c\x3c\xe6\x33\x15\xf2\x98\x78\xd4\x17\x32\x0c\x60\x9c\x7a\x69\x80\x54\x88\xe3\xd4\x23\x81\xa7\x42\x3f\xa6\x5e\x12\x04\x2a\x0c\x63\xea\xc5\x41\xac\xc2\x24\xa6\x5e\x14\x10\x15\xa6\x31\xf3\xc2\x80\xaa\x50\xae\x70\x83\x80\xab\x50\xc4\xcc\x93\x03\x26\x43\x14\x33\xcf\x0b\xb1\x0a\xbd\x98\x79\x38\xf4\x63\xee\xe1\x30\x88\xb9\x27\x07\x47\x86\x91\x0a\xe3\x98\x7b\x30\x4c\x54\x48\x62\x8e\x45\x98\xaa\x90\xc6\x1c\xf3\x90\xa9\x90\xab\x50\xc4\x1c\xb3\x08\xaa\x10\xc5\x1c\x53\x13\x62\x15\x7a\x31\xc7\x69\xe4\xab\x30\x88\x39\x26\x51\xa8\xc2\x48\x85\x71\xcc\xe5\xc8\xa9\x90\xa8\x50\xd6\x12\x47\x54\x85\xb2\x96\x28\xe2\x2a\x94\xb5\x44\xb1\xac\x25\x8c\x91\x0a\x71\x13\x06\xb1\xa7\x42\x5f\x85\xb2\x16\x3f\x0e\x55\x28\x6b\xf1\xe2\x58\x85\x89\x0a\x49\xcc\x30\x8e\x53\x15\x52\x15\xb2\x98\x61\x14\x73\x15\x0a\x19\x26\x50\x85\x28\xa6\x18\x26\xd8\x09\xbd\x98\x22\x91\xf8\x2a\x0c\xe2\x14\x89\x24\x54\x61\xa4\xc2\x58\x85\x49\x4c\x90\x48\x48\x4c\x10\x4f\x52\x15\xd2\x38\x41\x3c\x61\x71\x82\x44\xc2\x55\x28\xe2\x18\x09\x02\x55\x88\x4c\x18\x21\x41\x70\x1c\x61\x48\xbc\x38\xc4\x90\xf8\x71\x88\x11\x09\xe2\x00\x23\x12\xc6\x01\x96\xc8\x92\x61\x1c\xfb\xd8\x23\x49\xec\x61\x9f\x90\xd8\xc3\x01\x49\x63\x8c\x03\x42\x63\x8c\x43\xc2\x62\x84\x23\x15\xc6\x84\xc7\x10\x27\x44\x44\x02\x93\x14\x46\x02\xd3\x14\x45\x1c\xb3\x14\x47\x0c\xf3\xd4\x93\x4b\xe3\xd4\x8f\xa8\x87\xd2\x20\x4a\x3d\x9c\x86\x11\xf1\xfc\x34\x8c\x12\x2f\x48\xa3\x28\xf1\xa2\x34\x8e\x62\x2f\x4e\x93\x28\xf2\x48\x4a\xa2\xd0\x4b\xd3\x34\x0a\x3c\x96\xd2\xc8\xf7\x44\x4a\x23\xcf\x87\x29\x8b\xb0\x8f\x53\x1e\x21\xdf\x4f\x25\xcf\x86\x14\x4a\xfe\xa5\x28\xe4\x3e\xa1\x28\x64\x3e\xa5\x38\xa4\x3e\xa7\x5e\x98\x06\x90\xfa\x21\x09\x30\x0d\xc2\x24\xf0\x69\x10\xc6\x41\x48\xc3\x30\x0a\x62\x1a\x85\x81\xec\x44\xe8\x07\x94\xc6\xa1\x17\x70\x9a\x84\x38\x84\x94\x84\x30\xf4\x68\x1a\x88\x30\xa0\x69\xc0\xc3\x88\xd2\x80\x86\x09\x65\x41\x1a\x52\xca\x02\x12\x72\xca\x83\x38\x82\x54\x04\x51\xe4\x31\x18\x84\x51\xc0\x60\xe0\x47\x11\x43\x81\x17\x11\x86\x02\x14\x51\x86\x03\x18\x09\xe6\xf9\x3c\x46\xcc\xf3\x59\xec\x33\xdf\x4f\xe3\x90\x05\x92\x2f\x59\xe0\xc7\x71\xca\x42\x3f\x8c\x39\x0b\xfd\x20\x81\x2c\xf2\xbd\xc4\x63\x91\x8f\x92\x80\xc5\x3e\x4c\x62\x16\x7b\x3c\x49\x59\xe2\xd1\x84\xb1\xc4\x4b\x09\x64\xc4\x4b\x08\x66\xc4\x8b\x48\xc0\x52\x2f\x24\x31\x4b\x3d\x9f\x10\x46\x3d\x4c\x18\xa3\x1e\x4c\x21\x63\x58\xa4\x98\x31\xcc\xd2\x80\x71\x9c\xa6\x31\xe3\x38\x49\x09\xe3\x38\x4e\x19\x13\x38\xa4\x90\x09\x1c\x50\xcc\x04\xf6\x68\xc0\x21\x46\x34\xe6\x10\x43\x4a\x38\x42\x82\x32\x8e\x10\x63\x90\x23\x44\x19\xe6\x18\xa5\x2c\xe0\x18\x11\xc9\x1a\x28\x61\x84\x7b\x28\x61\x8c\x7b\x28\x66\x42\x86\x1c\x73\x1f\xc5\x3c\xe0\x3e\x4a\x78\xa4\x42\xc2\x03\x44\x24\x92\x50\xca\x05\x0f\x10\x15\x88\x07\x88\x09\x9f\x87\x88\x8b\x90\x87\x18\x8a\x98\x87\x18\x89\x94\x47\xd8\x13\x8c\x47\x38\xb8\x3b\x6d\x74\x50\xa5\x62\xa8\x29\xf0\x46\x66\x16\x28\xff\xf3\x21\x82\x10\x06\x10\x41\x04\x43\x15\xc6\x10\x43\x04\x13\x88\x21\x86\xa9\x0a\x19\xf4\xa0\x07\x85\x0c\x11\x86\x3e\xf4\x91\x0f\x03\xe8\xa3\x10\x86\x30\x40\xb1\x0a\x09\x8c\x60\x88\x28\x8c\x61\x84\x38\x4c\x60\x84\x21\x24\x30\xc6\x12\x46\x82\x7d\x48\x61\x82\x43\xc8\x20\xc1\x09\xe4\x30\xc5\x29\x82\x30\xc5\x0c\x21\x48\xb1\x40\x18\x32\x0f\x21\x0f\x32\x4f\xc2\xe6\x5e\x88\x02\xc8\xbd\x18\x85\x50\x78\x29\x8a\xa1\xf0\x18\x4a\x10\xf4\x04\x22\x08\xfa\x18\x51\x04\x7d\x1f\x31\x24\x67\x38\x8e\x90\x9f\x60\x88\x90\x9f\x62\x84\x90\xcf\x31\x46\x28\x80\xd8\x47\x38\xf0\x70\x80\x70\x10\xe0\x08\xe1\x20\xc6\x09\x42\x01\xc1\x04\xa1\x80\x62\x8a\x50\x20\x64\xfd\x21\xc2\x02\xa1\xd0\xf3\x10\x42\x61\xe0\x79\x08\x86\x91\xe7\x23\x18\x26\x5e\x88\x60\x98\x7a\x31\x82\x21\xf5\x12\x28\x42\xee\xa5\x50\x44\xd0\x63\x50\x44\xc8\x13\x50\x44\xd8\x87\x50\x44\xbe\x8f\xa1\x88\x02\xdf\x87\x22\x0a\xfd\x00\xc1\x28\x92\x33\x6f\x14\xfb\x89\x0a\x09\x82\x51\xe2\x53\x84\x22\xe2\x73\x84\xa2\xd4\x17\x08\x47\x69\x80\x10\x8e\x68\x80\x91\x17\xd1\xc0\x47\x5e\xc4\x02\x39\x65\xb3\x20\x42\x41\xc4\x83\x44\x85\x04\x85\x11\x0f\x28\x0a\x23\x11\x30\x14\x45\x22\x10\x28\x8e\x44\x08\x51\x1c\xc3\x10\xa3\x24\x86\xa1\x8f\x48\x0c\xc3\x40\x85\x11\x4a\x63\x18\xc6\x88\xc6\x28\x24\x2a\x4c\x11\x8b\x51\xc8\x54\xc8\x11\x8f\x51\x04\x91\x88\x51\x84\x55\xe8\x61\x18\xa3\x28\xc0\x48\x2a\x03\x2a\x8c\x31\x8e\x51\x94\x60\x1c\xe3\x28\xc5\x5e\x8c\x23\xaa\x42\x29\xc5\x71\x0c\x25\x22\x63\x89\x4e\x14\x7b\x6a\x06\xf0\x55\x18\xe2\x28\x46\x71\xac\xc2\x04\xc7\x31\x8a\x53\x9c\xc4\x52\x72\x27\x6a\x96\x20\x31\x4a\xa0\x0a\x11\x4e\x63\x94\x78\x38\x8d\x61\xe2\x63\x1a\xc3\x24\x54\x61\x8c\x59\x0c\x93\x44\x85\x29\xe6\x91\x48\xa8\x0a\x39\x16\x91\x20\x50\x85\x48\x6a\x0e\xc4\x53\x61\xe0\xa1\x88\x93\xd0\x43\x11\x93\xe2\x37\x62\x84\x78\x5e\xc4\x48\xea\x79\x11\x25\xcc\xf3\x23\x4a\xb8\xe7\x47\x69\x0a\xbd\x20\x4a\x53\xac\x42\xcf\x0b\x23\x92\x06\x2a\x8c\xbc\x28\x4a\xd2\x58\x85\xc4\x8b\xa3\x38\xa5\x9e\x9c\x42\x98\x97\x44\x51\x2a\x3c\x12\x45\x14\x7a\x24\x0a\x29\xf6\xd2\x28\xa0\xbe\x47\xa3\x80\x06\x1e\x8d\x7c\x1a\x79\x2c\xf2\x68\xec\xf1\xc8\xa3\xc4\xe3\x11\xa6\xd4\x13\x11\xa2\xcc\x87\x11\xa2\xc2\x87\x11\x64\x92\x45\x04\xc3\x3e\x0e\xa5\xbc\xf3\x42\xce\x02\xdf\x0f\x99\x94\x6b\x21\x65\xb1\x0a\x13\x3f\x0c\x53\x96\xfa\x51\x48\x18\xf5\xe3\x30\x61\xdc\x4f\xc2\x98\x09\x9f\x84\x31\x87\x3e\x0d\x25\xe2\x59\x18\x72\xcf\xe7\x61\xc0\x7d\x5f\x84\x3e\x0f\x02\x18\xfa\x3c\x0a\x70\x28\x15\x21\x2f\xc4\x3c\x09\xfc\x10\x73\x12\x84\x21\xe2\x69\x10\x85\x90\xd3\x20\x0e\x21\x67\x01\x09\x04\xe7\x41\x1a\x70\x2e\x02\x16\x70\x01\x03\x11\x70\x81\x42\x18\x48\xa1\x87\x55\xe8\x07\x54\x78\x61\x10\x50\xe1\x87\x91\x0a\x93\x80\x8a\x20\x54\x07\x2b\x21\x55\x21\x0f\xa8\x88\x22\xa8\x42\x1c\x50\x11\x47\xbe\x0a\xc3\x80\xca\x89\x37\x60\x22\x89\x12\x15\xa6\x01\x13\x24\x92\x75\x91\x48\xd6\x45\x62\x14\x08\x91\xc6\x9e\x0a\x83\x10\x8a\x34\x8e\x42\x24\x68\x9c\xa8\x90\x84\x58\xd0\x98\x86\x9e\xa0\x31\x0f\x7d\x41\x13\x18\x06\x82\x25\x38\x0c\x85\x44\x50\x24\x58\x12\x86\xb1\x60\x49\x1c\x26\x82\x25\x24\x24\x82\x25\x69\x98\x0a\x9e\xb0\x90\x0a\x9e\x88\x90\x09\x4e\x50\xc8\x05\x27\x5e\x28\x04\x27\x41\x84\x04\x27\x51\x84\x05\x27\x49\xe4\x09\x4e\x48\xe4\x0b\x4e\x68\x14\x0a\x4e\x78\x14\x09\x9e\xc2\x28\x16\x3c\xc5\x11\x11\x3c\xf5\xa3\x54\xf0\x34\x8c\xa8\xe0\x69\x14\x71\xc1\xd3\x24\x12\x82\xa7\x69\x8c\x04\x4f\x59\x8c\x05\x4f\x45\xec\x0b\x4e\x51\x1c\x08\x4e\x71\x1c\x09\x4e\xfd\x38\x16\x9c\x86\x31\x11\x9c\xc6\x31\x15\x9c\x12\x29\xfe\x29\x8d\x85\xe0\x94\x25\x50\x70\x2a\x12\x2c\x38\x43\x89\x2f\x38\xf3\x92\x40\x70\x16\x24\x91\xe0\x2c\x4a\x12\xc1\x59\x9c\x10\xc1\x18\x49\xa8\x60\x8c\x26\x5c\x30\xc6\x09\x14\x8c\x43\x82\x04\xe3\x98\xc8\x59\xc0\x23\x81\x60\x3c\x20\x91\x9c\x11\x48\x22\x18\x4f\x08\x11\x8c\xa7\x84\x0a\xca\x29\xe1\x82\x72\x9e\x42\x41\x05\x4c\xb1\xa0\x02\xa7\xbe\xa0\xc2\x4f\x43\x41\xa5\xb2\x28\xa8\x88\xd2\x44\x50\x91\xa4\xa9\xa0\x22\x4d\x99\xa0\x82\xa5\xe6\x7c\x52\x79\x78\xd0\xab\xc9\x5b\x9a\x5a\x88\x9a\x54\xa8\x0a\x39\xf4\x20\x46\x32\xaf\x9e\x5a\x3c\x33\xb5\x44\x30\x84\x3e\x4a\x60\x04\x03\x94\xc2\x18\x06\x88\xc1\x04\x86\x48\x40\x02\x23\x35\xa9\x44\x6a\x52\x89\xd5\xa4\x12\xab\x49\x25\x51\x93\x4a\xa2\x26\x15\xe2\x41\x24\x35\x38\x8c\x7c\x98\x7a\x3e\x0a\x60\xea\x45\x28\x84\xa9\x97\xa0\x18\x52\x8f\xa2\x04\x52\x8f\xa3\x14\x52\x1f\x21\x0a\xa9\xef\x21\x0e\xa9\x1f\x20\x01\xa9\x5c\xe8\x40\xea\x13\xec\x41\xea\x53\x59\x8f\x2f\xa4\x06\x14\x20\x1c\xc3\x34\xf0\x70\x02\xd3\x20\xc0\x29\x4c\x83\x08\x33\x98\x06\x09\x16\x90\x04\xa9\x87\x20\x09\xa8\x87\x21\x09\xb8\xe7\x43\x12\x08\x2f\x84\x49\x88\x3c\x25\xe3\xbc\x04\x26\xa1\xe7\xa5\x30\x09\x7d\x8f\xc1\x24\x0c\x3c\x0e\x93\x30\xf4\x21\x24\x61\xe4\x63\x48\xc2\xd8\xf7\x55\x18\x40\x12\x26\x7e\x04\xd3\x90\xf8\x89\x0a\x09\xa4\x61\xea\x53\x15\x32\xc8\x42\xea\x0b\x19\x06\x08\xf2\x90\x06\x18\x72\xa9\x3f\x41\x11\xb2\x20\x50\xa1\x5c\xf8\xc9\x29\x44\x86\x04\x21\xc9\xbc\x08\x87\x3c\x60\x2a\x14\xc8\x0b\x79\x88\x54\x88\x91\x1f\xf2\xd0\x47\x41\xc8\xc3\x40\x85\x11\x0a\x43\x1e\x26\x2a\x24\x28\x0a\x79\x48\x51\x1c\xf2\x90\xa9\x50\xa0\x24\xe4\x11\x52\xa1\xd4\x88\x79\xe4\xab\x30\x40\x69\xc8\xa3\x08\xd1\x90\x45\xb1\x0a\x09\x62\x21\x8b\xa8\x0a\x19\xe2\x21\x8b\x04\xe2\x21\x8d\x21\x92\x8b\x17\x8c\x61\x48\x63\x1f\xc3\x30\x95\xaa\x75\x98\xc6\x91\x0a\x95\xf6\x1c\x13\x15\x52\xec\x85\x49\xcc\x54\x28\xb0\x1f\x26\x89\x5c\x05\xc7\x09\x56\xa1\x87\xc3\x30\x4a\x02\x15\x46\x38\x0a\xc3\x24\x56\x21\xc1\x71\x18\x24\x29\x4e\x42\x3f\x61\x2a\x14\x98\x84\x1e\x81\x2a\xc4\x38\x0d\x31\xf1\x30\x0d\x91\xd4\x7f\x43\x48\x42\xcc\x42\x48\x62\xcc\x03\x41\x12\xcc\x03\x4e\x52\x2c\x02\x4e\x98\x07\x03\xa9\xd7\xc1\x80\xa6\xd0\x43\x41\x9a\x22\xa5\xe5\x7b\x2a\xf4\x3d\x2f\x48\xd2\xd0\xf3\x83\x38\x8d\xbc\x20\x88\xd2\xc4\x0b\x82\x30\x25\x52\x8e\xa6\x72\x19\xe8\xa7\xcc\x8b\x03\x2f\x15\x5e\x12\x60\x39\x91\x04\x88\x22\x8f\x04\x90\x7a\x9e\xe4\x50\xdf\x93\xca\x78\x28\x97\x9f\x34\x92\x4b\x51\x2a\x97\xa8\x29\x25\x3e\xf4\x09\x4d\x7d\xe4\x27\x94\xfa\xd8\x8f\x29\xf7\xe5\x6c\x26\x7c\x39\x7b\x40\x3f\xf0\x03\x86\xfd\xd0\xf7\xe5\x1c\xe7\x7b\xcc\xf7\x63\x1f\xb3\xc0\x27\x3e\x62\x91\x9f\x7a\x82\xc5\x3e\xf5\x38\x4b\x7c\xe6\x31\x46\x7c\xee\x51\x96\x06\xd0\x4b\x19\x0b\x90\x47\x18\x0f\xb0\x17\x33\x11\x78\x5e\xc4\x61\x10\x78\x21\x47\x81\xd4\xf3\x71\x10\x79\x3e\xf7\x82\xc4\xf3\xb8\x1f\x10\x0f\xf1\x20\xa0\x1e\xe4\x61\xc0\xb0\xe0\x51\xc0\x31\xe7\x71\x08\x31\xe3\x49\x88\x70\x2a\xe7\x5e\x4c\x78\x1a\xfa\x38\xe1\x69\x18\xe2\x98\xd3\x30\xc2\x21\x67\x61\x82\x03\xce\x43\x82\x7d\x2e\xe4\xdc\x29\x75\x5b\x8c\x04\x0c\x05\x86\x02\x45\x08\x09\x81\x22\x0f\x31\x81\x23\x1f\x51\xe1\x45\x21\x4a\x85\x5c\xf5\x27\xc2\x8f\x12\x14\x8b\x20\x4a\x51\x24\x02\xb9\x6e\x10\x61\xc4\x91\x2f\xc2\x18\x22\x4f\x44\x31\x46\x58\x44\xb1\x8f\xa0\x88\xe3\x00\x0a\x11\xc7\x11\xe4\x22\x8e\x13\x48\x45\x12\xa7\x30\x15\x49\x4c\x21\x11\x49\xcc\x61\x22\x48\x02\x61\x2c\x07\x15\x46\x82\x24\x3e\x8c\x44\x9a\x84\x30\x14\x69\x12\xa9\x30\x51\x61\xaa\x42\x06\x23\x41\x13\x21\x43\x82\x60\x2c\x28\xf1\x60\x22\x28\x09\x20\x11\x72\xed\x43\x05\x25\x31\x64\x82\x12\x02\x85\xa0\x84\xca\x35\x01\xe1\x08\x0b\x9a\x42\xe4\x0b\x9a\x62\x14\x0a\x39\x6c\xb1\x48\xd3\x10\x11\x21\xe7\x0e\x26\xd2\x94\x20\x21\xd2\x94\x4a\xb5\x3e\xe5\xd8\x13\x84\x42\x1c\x0a\x42\x31\x8e\x05\xa1\x3e\x26\x82\xd0\x10\x33\x91\xd0\x08\x0b\x91\xd0\xc4\xc3\x22\xa1\xa9\x17\x88\x98\x32\x2f\x12\x31\x15\x1e\x11\x11\x43\x1e\x13\x11\xf3\x34\x9b\xfb\x9e\x08\x59\xe4\x87\x22\x60\x89\x9f\x88\x80\xa5\x3e\x15\x3e\x63\xbe\x10\xbe\x1c\x5b\xe1\xcb\x51\x15\x1e\xf7\x02\x22\x3c\x1e\xc8\x69\x9e\x87\x21\x12\x98\xc7\x61\x20\x30\x27\x61\x22\x10\xa7\x21\x13\x88\xb3\x08\x09\xc4\x45\x14\x08\x24\x50\x94\x08\x2c\x70\xc4\x04\x16\x7e\x8c\x85\x27\x82\x38\x14\x9e\x90\x93\x9c\x2f\xe2\x98\x8b\x40\x24\x09\x16\xa1\x20\x49\x28\x62\x91\x26\x44\x24\x82\x26\x4c\x10\xc1\x08\x12\x54\x08\xe2\xb7\x53\x8b\xde\x38\xbc\xc1\x99\x85\xc1\x38\x8e\x10\x84\x51\x1c\x4b\x6d\x30\x4e\x50\x08\xa3\x98\xa0\x04\x86\x31\x45\x29\x0c\x63\x86\x18\x0c\x63\x8e\x21\x0c\x63\x21\xc5\x4c\x02\xb1\x0f\xc3\x04\xe1\x10\x06\x89\x94\xe1\x41\x82\x31\x81\x41\xe2\x61\x0a\x83\xc4\xc7\x1c\x06\x49\x80\x05\x0c\x92\xd0\x43\x30\x48\x22\xcf\x53\x61\x00\xfd\x24\xf6\x22\xe8\x27\x89\x17\x43\x3f\x21\x1e\x51\x21\x85\x7e\x92\x7a\x1c\xfa\x09\xf5\x84\x0c\x7d\x04\xfd\x84\xf9\x1e\xf4\x12\xee\xfb\x2a\x0c\xa1\x97\x08\x3f\x56\x61\x02\x65\xc1\x14\x7a\x04\xf9\x14\x62\x82\x7c\x0e\x31\xc1\x01\x54\x21\x82\x98\x78\x81\xa7\xc2\x00\x62\xe2\x07\x21\x44\xc4\x0f\x62\x15\x26\x10\x91\x20\x48\x55\x48\x21\x22\x61\xc0\x65\x18\x42\x15\x22\x08\x49\x14\x7a\x2a\xf4\x55\x18\xaa\x30\x82\x90\xc4\x61\xa2\x42\xa2\x42\xaa\x42\xae\x42\x21\x43\x89\x44\x12\x47\x18\x22\x12\x47\xbe\x0a\x03\x15\x46\x2a\x8c\x55\x28\x85\x66\x1c\xa5\x2a\x64\xd0\x23\x71\xc4\x65\x18\x43\xe8\x93\x38\x46\xd0\x27\x51\xec\xc1\x80\x44\xb1\xaf\xc2\x10\x86\x24\x8c\x23\x18\x91\x30\x8e\x61\x4c\xc2\x98\xc0\x84\x04\x71\x0a\x09\x09\x62\x06\x53\x12\xc4\x1c\x52\xe2\xc7\x02\x32\x22\xd7\x47\x9c\x78\x09\x86\x82\x78\x89\x8f\xe4\xea\x30\x40\x88\x20\x39\x69\x12\x94\xc4\xc8\x27\x30\x49\x50\x90\x88\x84\xa0\x30\x11\x09\x45\x51\xc2\x13\x86\xe2\x84\x25\x1c\x25\x09\x23\x10\x91\x84\x12\x84\xd2\x24\x25\x18\xb1\x84\x48\xc1\x95\x10\x12\x20\x91\x24\x24\xc4\x30\x89\x49\x84\x51\x12\x91\x18\xe3\x24\x24\x04\x7b\x49\x40\x52\xec\x27\x3e\xa1\x38\x4c\x7c\xc2\x70\x94\x78\x84\xe3\x38\xc1\x29\xc4\x49\x82\x52\x84\x49\x02\x53\x8c\xd3\x58\xa4\x1e\xa6\x31\x4f\x7d\xcc\x63\x96\x06\x58\xc4\x34\x0d\x3d\x18\xa7\x69\xe4\xa1\x98\xa4\xb1\x87\x63\xb9\x78\xf0\xe2\x38\x4d\x3d\x3f\x96\x4b\x88\x20\x8e\x52\xe6\x45\x71\x98\x72\x2f\x8e\x03\x29\xff\x63\x5f\xca\xff\xd8\xa3\xc8\x4b\x63\x4c\xb1\x47\x63\x44\x3d\x8f\xc5\x52\xf1\xe0\x91\xa0\x81\x0f\x23\x4e\x43\x1f\x45\x8c\x46\x3e\x8e\x28\x8d\x7d\x2f\x4a\x69\xe2\xfb\x11\xa1\xc4\x0f\x22\x39\x23\x84\x91\x9c\x11\xa2\x28\xa6\xd4\x4f\xa2\x88\x32\x5f\x2e\x4e\xb8\x9f\x2a\x9d\x9d\x46\x3e\x83\x3e\x8b\x3c\x86\x7c\x1e\x61\x86\x7d\x11\x21\xe6\x05\x28\x42\xcc\x0f\x70\x04\x99\x14\xf6\x82\x05\x81\x2f\x85\x74\x10\x84\x8c\x45\x41\x28\x97\x22\x41\x14\xa6\x2c\x09\xe2\x90\x30\x12\x10\x15\xa6\x61\xc2\xd2\x80\x86\x31\xa3\x01\x0b\x23\xc6\x02\x1e\x86\x8c\x07\x22\x0c\x18\x0f\x51\xe8\x33\x11\xca\xe5\x07\x0c\xbd\xd0\xe3\x28\x94\xcb\x0f\x1c\x06\x21\xe2\x38\x0c\x43\xb9\x86\x97\x7a\xb2\x5c\x48\x70\x1e\x84\x24\x60\x5c\x2e\x27\x18\x57\xcb\x09\x1e\x85\x3c\x48\x79\x14\x8a\x80\xf0\x38\x82\x41\xc2\x93\x08\x05\x31\x4f\x22\x1c\x44\x9c\x44\x7e\x10\xf1\x34\x0a\x82\x90\xa7\x51\x18\x04\x9c\x46\x51\xe0\x4b\x9d\x39\xf0\x38\x8b\x48\x80\x39\x97\x0b\x68\x2e\x22\xaa\x42\x1e\x40\x29\xba\x7d\x21\x60\x0c\x7d\x2e\x50\x8c\x7c\x26\x50\xec\xf9\x54\xe0\xd8\xf7\x53\xe1\xc5\x81\x0a\x23\x9f\x08\x3f\x8e\x7d\xc9\x9c\x89\x1f\x8b\x20\x4e\xfd\x48\x04\x31\xf5\x43\x11\xc6\xcc\x0f\x44\x18\x0b\xdf\x17\x51\x02\x55\x88\x7c\x4f\x44\x89\xe7\x63\x11\x27\xbe\x8f\x44\x9c\x48\x45\x2b\x91\x6b\x0a\x91\x24\xb1\xc7\x25\x99\x79\x5c\x90\x24\xf5\x98\x20\x09\xf5\xa8\x20\x09\xf7\x52\x91\x26\x52\x6e\xa7\x04\x79\x89\x48\x09\xf6\xd4\x9c\xa2\xc2\xc0\x93\xb3\x4c\xe8\x85\x72\x4e\xf1\x02\x41\x49\xe2\xf9\x42\x2d\x5d\x05\x23\x54\x85\xdc\xc3\x82\x11\xe1\x21\xc1\x52\xe4\x41\xc1\x52\x8c\x85\x60\xa9\xaf\xc2\x00\xcb\x25\x4a\x84\x99\xe0\x92\xa0\x04\x4f\x89\x0a\x53\x2c\x97\x31\x0c\xcb\x25\x0d\x97\x21\x85\x38\x11\x8c\x62\x15\x7a\x38\x16\x8c\x06\x38\x12\x8c\x86\x2a\x8c\x55\x48\xe4\x0a\x95\xa6\x38\x14\x94\x32\x1c\x08\x4a\xb9\x0c\x19\x54\x21\xc6\x81\x48\x99\x87\x7d\x91\xb2\x40\x85\x11\xf6\x05\x61\xb1\x0a\x09\xf6\x45\xc2\xa8\x0a\x65\xd9\x98\x09\x19\x72\x84\x03\x11\x71\xac\x42\x1f\x07\x6a\x7b\x2b\x14\x21\x8f\x71\x28\x02\x9e\xa8\x30\xc5\x91\xf0\x39\xc3\x91\xf0\x38\x97\xa1\x80\x38\x92\xb3\x0f\x8e\x04\x12\x72\xdd\x8c\x44\x80\x03\xbd\xd3\x22\xa0\x48\x30\x1a\xbe\x1a\xf4\x19\x9f\xa3\xed\xec\xa7\xb2\xe2\xff\x3c\xe7\x79\x9d\x91\xc5\xae\x47\x66\x5b\x3a\x04\x6e\x7d\x3f\x36\x35\x4e\xda\xc3\xf7\xa2\xdc\xce\x39\x30\x5d\x90\xd3\x33\x70\x08\x04\x59\x54\x7c\xad\x4f\x49\x75\x8a\x0c\x0e\xc1\xe4\x02\x3c\xb0\x7e\x71\x95\xb7\xdc\x0b\xd8\xf3\xca\xea\x34\x62\xa2\xe1\x7f\x03\x06\x4f\xe2\xd0\x0c\xd4\xca\x57\xac\x3e\xa7\xfe\x6c\x9e\x74\x1b\xaf\x88\x63\x5e\x74\x1b\x2c\x5c\xa5\x36\x5b\xe8\xab\xaf\x8e\x9d\x2a\x54\xec\xaa\xc3\xc5\x16\x25\x57\xad\xa6\x57\xd6\xad\xcb\x4d\xba\xa2\xcf\xc5\x31\xa2\x59\x71\x48\xab\x71\xa3\x3b\xbb\x83\x1f\x5a\x78\x0d\x3f\xb4\xde\xda\x67\x5e\x86\xf3\x14\xfb\x3e\xbc\x77\xef\x0e\xb8\x07\x7e\xe0\x75\x05\xea\x13\x0e\x16\xa4\xaa\x01\xd7\x2f\x09\x41\x21\xc0\x6f\xca\xd1\xe6\x6f\xf3\x3b\x40\xe5\xfb\xef\xaa\x26\x75\x46\xd5\xcf\x53\x7e\x9a\xf2\xf2\x85\x00\xc7\x3a\x25\xcb\x29\x07\x70\x8e\xe6\x50\x7d\x53\x52\xf3\x77\x45\xb9\xd4\xde\xa4\x55\xd4\x19\x29\xc9\x29\xf8\x5d\x45\x5c\x02\x05\x19\x1c\x9d\x70\xf3\xab\x2e\xc0\x3f\xcf\x79\xb9\x9c\xab\xbc\x1a\x4d\x15\xf8\xfd\xde\x25\x78\x69\x7e\x6f\x68\x20\xf8\x6f\x7e\x41\x4e\xcf\x16\xdc\x34\xf6\x78\x2e\x33\x4f\xde\xa0\x19\xc0\x33\xe0\x29\x67\xfa\xf7\xc0\xc3\x87\xe0\xf0\xaf\xc0\xbb\x23\x31\xd4\x70\xac\xca\xa8\x20\xb5\xcc\x6f\x08\xe9\xd0\x34\xef\xf0\x50\xbf\xe4\xfa\x06\x40\xb0\xaf\xe3\x56\x4f\xd5\x1b\xe2\x53\xe9\x6f\x5a\x0f\xa3\x6f\xc1\x3e\x38\xcf\x19\x17\x59\xce\x99\x1a\x32\x3d\x1a\x73\x33\x18\xe0\x50\xb5\x61\x40\x54\xff\xa9\xde\x3a\x95\x9c\xd0\xf1\x97\x48\x68\xd7\xcb\x0e\x06\xac\x7d\x05\x36\x0c\x7e\x9e\xaf\xe5\x16\x03\x63\xd7\x4b\x70\x67\x65\x71\x76\x5c\x2f\xcf\xf8\xf8\x95\x8b\x9d\x5f\x22\xba\xb0\xaf\xd1\xc7\x2e\xa0\x9d\xdd\xe6\x9f\xd7\xd9\xe2\xf8\xe7\xf3\x92\xbf\xe4\x39\xe3\x6b\xa6\xcb\x60\xb7\x2a\x3c\x5b\x45\xb1\x20\xe5\x2f\x75\xb6\x18\xc7\xa8\xb7\x63\x15\xbe\xa9\xe2\xa5\x1c\xf3\xf5\x55\x20\x6b\xda\xe3\x98\x5f\xd4\x5c\xbb\xc5\xd3\xb2\x77\x4e\xaa\x2a\x7b\x97\x83\x4f\x9f\xda\x99\x7b\x52\x93\xf2\x1d\xaf\xa7\xe0\x77\xf5\x82\x7a\x62\xdd\xf9\xa2\x03\xe5\x15\xbd\x3f\xcb\x1c\x80\xec\xfe\x7d\x99\x59\x59\xe5\x2e\xce\x4b\xca\x95\xbc\x30\xb9\xde\x64\x6f\x0f\x5a\x38\xef\xf9\x12\x64\xb9\xc9\x26\x0b\x65\xc2\x5e\x29\x9e\x9f\x95\x45\x5d\xc8\x81\x9d\x9f\x90\xea\xc5\xc7\xfc\xe7\xb2\x38\xe3\x65\xbd\xd4\xee\x8c\x75\x91\x99\x84\x30\x95\x05\x75\x23\xdf\xbc\xe7\x4b\xa5\x37\xa9\x54\xf5\x75\x00\x2e\xd5\x3f\xeb\xc4\x41\xe5\x3b\x50\x13\x8f\x42\x01\x2d\x39\xa9\xf9\xe3\x05\xa9\x2a\x67\x86\x03\xea\xe2\x52\xf3\xa5\x85\x94\x69\x41\xc6\x2b\x83\x93\x19\x90\xd4\x57\xad\xa0\x06\x6a\xd4\xa8\xc4\x21\xb4\x30\x5e\xd1\x32\x3b\xd3\x73\xb0\xca\xa5\xd0\xd2\x46\xcf\x79\x7e\x7e\xca\x4b\xa9\x22\x82\xc3\x91\x78\x39\x46\x4a\xcf\x72\xd3\x69\x91\x8b\xec\xdd\xb9\x2d\x59\x97\xe7\xfc\x40\x21\xf5\xee\x07\xb2\x38\xe7\x77\x25\xb6\xdb\xec\x53\xb7\xe8\xc7\x32\xab\x3b\xc5\xcc\x38\x74\xfa\xbe\x6c\x7a\xee\x94\x7c\xcf\x97\xee\xf7\xf4\xc0\x45\x78\x8b\xd1\xc7\x45\x5e\xd5\xe5\x39\xad\x8b\x52\x21\xae\x2e\x24\xd0\x6a\x06\xf4\x04\xfa\xb3\x45\xa5\x6c\x6e\x9b\x3c\x5d\x45\xbe\x03\xa8\xa5\x12\x17\xe4\x54\xf7\xb9\x03\x77\x1d\x94\x6e\x13\x0e\x6c\xd3\x9d\x1c\x92\x60\xc0\xe5\x64\xda\x50\x8d\xa4\x97\x99\xf9\x8b\x67\xe0\xb8\xe6\x52\x51\x6b\x67\x4f\x9d\xf2\x98\x2c\x16\x8f\x4f\x38\x7d\x3f\xc9\xf2\xaa\x26\xb9\xa4\x58\x07\xaa\xed\xed\x57\x4d\x32\xb0\x3f\x0a\xd1\xc9\xa8\x48\xfc\xa4\x2c\x3e\xaa\x37\xd6\x47\xcb\x33\xfe\xa4\x2c\x8b\x72\x72\xf7\x31\xc9\xf3\xa2\x06\x92\x27\x00\x01\xaa\x52\x40\x2a\x40\x1a\xbc\xdf\xd5\xc3\xe1\x36\xed\xac\xa8\xaa\x2c\x5d\x70\xa7\x02\xad\x4e\x4c\x2a\xbe\x10\x33\x05\xac\x69\x9a\x8c\xea\xd6\xfe\x92\x0b\x5e\xf2\x9c\xda\x26\x28\x9b\x0a\x27\xa4\xca\xf7\x6a\x90\x72\x2e\x75\xf6\x4c\xea\x82\x59\xc5\x95\x59\xa4\xf3\x33\x5e\x4e\xa6\x9d\x1c\xb2\x06\xce\x74\xd3\xec\x5d\x70\xd9\x83\xaf\xbf\x06\x13\x39\x98\x85\xd0\xdf\x87\x87\x87\xe0\x6e\xa1\xe8\xf0\xae\xba\x99\xda\x4f\x6b\x7b\x09\xbe\xd1\xd1\xfb\x40\xb6\xf8\xa0\xdb\xe3\x2c\x3f\xe1\x65\x56\x57\x93\xea\x3c\x7d\xac\x87\x4e\x35\x4b\xfd\xb6\x5d\x35\xc0\xdb\x04\xf0\x55\xa7\x0a\xd9\xba\x5e\xa2\xd4\x7e\x46\x87\xe6\x95\xcc\x2b\x35\xcb\x92\x57\x95\x6c\xc6\xe9\xb9\xd4\xd3\xb2\xfa\x84\x97\x20\xe5\x5a\x75\x2a\x4a\x67\xac\x66\x40\x8e\xe5\x5d\x70\x1f\xac\xb4\x45\xa1\xca\xb6\xbe\xa5\xfa\x56\x72\x6b\x39\x36\x71\x1a\xd8\x69\xae\xcb\x28\xbf\x03\xda\x8e\xfc\xbe\x92\x49\x8b\x73\xbe\x0f\x5a\xe4\xb4\x62\x66\x5f\x0b\x99\x19\xb0\xe2\x61\x5f\x49\x87\x19\x70\x25\x8d\x8e\x93\x64\x66\x39\xcf\x41\xae\x69\x5f\xc5\xeb\x9f\x6d\x13\x5e\x08\xf0\xcd\x70\xfc\xc8\x00\xb5\x6d\x9b\x1f\x1f\xab\x9e\xa8\xc9\xad\xcd\xa2\xc6\xdb\x28\xee\xff\x2d\xb2\x05\x7f\xf1\x81\x97\x1f\x32\xfe\x11\xa8\x29\x17\xfc\x50\x66\x4c\xa9\xb7\xfa\x3f\xc9\xc3\x2a\x41\xc6\x6f\x73\x1f\x7b\x48\x47\x18\xdc\x5c\xd6\x7c\x2f\x57\xb6\x4a\x24\xc8\x19\x58\xcb\x88\xce\xe4\x72\xfc\xb8\x38\x3d\x2b\x72\x9e\x9b\x9b\xa6\x2d\x81\x36\xad\x9a\x01\x27\x53\x77\x2d\xdd\xe4\x69\xd6\x61\x7d\x69\x23\x59\x72\xd6\xe6\xd3\xe5\x1b\x8d\x7c\x8d\x00\xd0\x05\xdb\x56\x38\xe8\xfe\xf4\xc9\x0e\xd9\xbb\xee\x90\xb5\xd5\x4c\xe7\xe4\xec\x6c\xb1\x34\x50\x9a\x39\x7f\xda\x2e\xc8\xdd\xe9\xd6\xed\xeb\x1b\xdd\x8f\xf7\x7c\xb9\x0f\xf6\x24\xfc\x62\xb1\x7c\x57\xe4\x3f\x93\xfa\x64\x6f\x66\x76\x0c\x14\x8d\x36\x48\xe8\x66\x9a\x94\x84\x65\xe7\x95\xc5\x87\x5e\xad\x28\xdd\x50\x3b\x13\xc9\x14\x03\x9c\x55\xb3\xc6\xf7\x3f\x00\xf4\x42\x8e\x8e\x9e\xa4\xe9\x45\x27\x65\xe9\xa4\x2c\xdd\x14\xb9\xb2\x2d\x1f\xe5\xef\x16\xca\xf8\xb3\xc9\xe2\x44\xca\xc5\x4a\xdb\x80\x33\xa2\x16\x4b\x7b\x7b\x07\x36\xd6\xc9\x3a\x17\x45\xf9\x84\xd0\x93\x49\x4b\x16\x44\x26\xcc\x40\xd6\x76\xc3\xc0\x29\xb2\xbc\xde\x86\x4c\x87\xf4\x4c\x6b\x66\x4e\x55\x7d\x54\x3c\x26\x65\xcd\xab\x8c\xe4\x9a\x5e\xe9\xc5\x0c\xd0\xe5\x0c\x68\xfc\xcd\x80\x6a\xc2\xb4\x69\xaf\x7e\x19\xd0\x69\x10\xd0\xdd\xba\x7f\x08\xf6\x9e\x81\x3d\x70\x5f\xb7\x6e\x7e\x01\xee\x83\xbd\x59\xfb\xbd\x3c\x68\x4a\x5c\x02\xbe\xa8\xf8\x30\x88\x9f\xb6\x04\x61\x7e\x5d\x4e\x6d\x5c\x03\xe1\xff\xb6\xd8\xb5\x17\xcd\x89\x5e\x80\xda\x62\x4a\x2e\xc8\xff\xee\x81\xef\x4a\xf2\x11\x90\x8b\xac\x92\xeb\x64\xd9\x67\xb2\x50\x5b\x08\x36\xdd\xac\xb1\xc1\xef\x6f\x24\x71\xbf\xbd\x54\x6b\x71\x99\xa1\x32\x39\x1e\xde\xd1\x26\x70\x5c\x7a\x2d\x95\x40\xf8\xb9\x1d\xda\x11\x92\x5d\xc9\x37\x19\xa2\x57\xbc\x0d\xc1\xe2\x71\x8a\xc5\x3d\x92\xcd\xf2\x9c\x97\x2f\xd5\xf0\x3a\x79\x9c\x58\x37\x73\x71\x5e\x0f\x64\x76\x62\x37\x31\x03\x1e\xe6\x06\xa5\x4a\xb8\xf9\x3f\x7d\x02\xee\xb7\xd1\x92\x5d\x3a\x33\x23\x21\x67\x49\x3b\xe6\x97\x2e\x6f\x19\xde\xb6\x6b\x98\x49\x5b\xb2\xaa\xcb\xe2\x3d\xdf\x07\x7b\xff\x87\x52\xba\x67\xcb\x6e\xf1\xb2\x67\x68\x0d\xf5\xe6\xee\x7b\xc5\x3e\x4a\xe8\xf1\xca\x5a\x93\x7a\x54\xd7\x65\x96\x1a\x07\x06\x6f\xa7\x93\x76\xc4\xa6\xd3\x3e\x3d\x5e\x61\x99\x3f\x27\x66\x22\x7f\xa2\xb7\x73\x26\x4d\xa7\xf6\xde\xed\xb5\xb8\xff\x5d\x6b\x7a\xcf\xc9\x29\x57\xf4\x47\x4f\x48\x59\x57\x0f\x14\x42\x1f\xbc\x2b\x33\xf6\x40\xf1\xf1\x1e\xb8\x6c\xcb\xb8\xd8\x3e\x25\x67\x8e\xd8\xe1\x79\x5d\x2e\x7b\x62\x47\x23\x59\x3b\xe5\xfa\xac\x82\xc7\x25\x44\xa0\x5a\x32\x3d\xe8\xb5\x82\xe7\x5b\xcd\xd1\xbb\xb7\xc1\xa5\xef\xa6\x0d\x4e\x23\x6e\x60\x1c\xf7\xa4\x10\xd9\x9b\x39\xe4\x7a\x69\x56\x8f\xb3\x0e\xd6\xad\x4c\x91\xd9\x1f\x48\x51\x98\xcd\x3a\xa9\x17\x68\xdf\x18\x4e\xbb\xe8\x26\x2c\x9b\x84\x65\xaf\x04\xde\x57\x16\xd8\xfa\xf9\x4d\xf4\xd2\x89\xbd\x9c\x3a\xb8\xbf\x9c\x9a\x9f\xd3\x75\xb2\x94\x16\x39\x95\x18\xcb\x28\xa0\x59\x49\x17\x8d\xa0\x6c\xb6\x36\x9f\x9f\x9f\xa6\xbc\xbc\x34\x33\x8c\x12\xa8\xe6\xa7\xd4\xe4\x55\x99\xb1\x22\x59\xce\xf8\x05\x50\x45\xf4\xcf\xd1\x12\x9a\x38\x2e\x01\xbf\xa8\x4b\xa2\x96\x71\xe0\x89\xfc\xa9\x51\xbc\x22\xdd\x15\x83\x9b\xa1\xb9\xec\x82\x1c\x17\xf0\x8f\x9b\xae\x3e\x56\x05\xd6\x4a\xf9\x7e\xe6\x89\x9d\x60\x55\x47\x66\x4e\x43\x87\xe6\x00\x6f\x9b\x39\xc0\x1b\x9f\x03\xbc\x39\x5d\x1e\xdc\xf9\xb7\x90\x96\x2e\xf9\x8b\x6c\xb1\xd8\x07\x7b\x79\x91\x73\xa7\x21\x0e\xaa\x6e\x52\xb2\xee\x51\x33\x8a\x1b\x78\x72\x93\xa4\x6d\x39\xe0\x01\x75\xe9\xa2\x25\x1f\x1d\xad\xb9\x59\x8d\x7e\x0b\xfb\x62\x1f\xb8\x83\x48\x97\xfb\xc0\x9d\xbd\xcb\x7d\xc3\x2b\x77\x7a\x0c\xba\x91\x19\xcf\xb4\x6e\xbc\x89\x1b\xe5\x7f\x5d\x8e\x34\x05\x37\xb0\xa4\x2d\xd7\xb0\xe5\x48\xb1\x6b\xf1\x65\x17\xe6\x36\x8c\x69\x56\x04\x5b\x72\xa6\xc9\xbd\x2d\x6b\x7e\xe1\xa1\x55\x1e\x3a\x53\x0b\xb4\x9b\xe3\xa0\xb3\xce\x00\xb6\x03\x2d\xeb\x19\x62\x20\xb6\xaf\xe5\xe4\xf0\x6a\x70\x95\x6b\x36\xb1\x8d\x5c\x1a\x6c\xa0\xca\xc7\x23\xb9\xeb\x82\x15\xe0\x85\x31\x3e\xaa\xce\xe5\x72\x72\x7a\x95\x59\x65\xcd\x62\x77\x28\x6b\x7f\xf1\x20\xf1\x60\xd7\x0e\x1d\xd9\xaf\xa7\x04\x7f\x74\x4a\x51\x23\xd1\xd3\xf9\xfd\xb9\x13\xeb\x66\x96\x03\x76\xa4\x37\x9e\x6c\x4e\x1b\x35\xa4\xed\x1b\xb0\x8d\xb6\xaf\xbf\xb7\xd5\xf6\xff\x78\x35\xba\x25\x8d\x55\x5d\xda\xf4\x65\x1b\x5d\xda\xf4\xa0\x45\xde\xe1\xa1\x9d\x16\xf6\xc0\x37\x66\xec\xe6\x23\x9a\x43\x0b\x72\x7f\x2c\xa7\x95\x64\x4d\xd6\xf5\x6a\xdc\x20\x21\xae\x25\xbd\x1e\xb1\x75\x97\x89\x2d\x59\xb9\x2b\xc5\x2e\x39\xb8\x25\xfe\x72\x08\xe0\x9f\x7f\xec\x3b\x03\xae\xba\x38\xb0\x7e\x1f\xcc\xd1\xe7\xd3\x81\x01\x78\x3b\x75\x2f\x3e\x34\x1b\x61\x07\x77\x2e\xb7\x39\xd0\x7d\x73\xb7\xd9\x1a\xbc\xfb\x76\xda\x1c\x43\xcc\x59\x56\x9d\x2d\xc8\x52\xf6\x09\x1c\x82\xbd\x06\xec\x5e\x9b\x45\x0e\x93\x24\xc1\xee\x44\x76\xb9\xce\xc6\xe0\xf0\x1c\xa5\xad\xa5\xfe\xfc\xf2\xc9\xab\x27\xcf\x8f\x1e\x1d\x3d\x7d\xf1\xfc\xf8\xd1\xd1\xd1\xcb\xa7\xdf\xfe\x72\xf4\xe4\x95\x36\x5b\x28\x47\x58\x6a\x38\x57\x3d\x07\x9e\x93\x79\xae\xd4\x0d\x89\x5d\xa9\x12\x5d\x0b\x80\xb3\xc0\xbc\x26\x24\x87\x86\xaf\x05\xe9\x4e\x67\x31\xbe\x13\x28\x75\x97\xe2\x85\xd8\xfa\x64\x7c\xa5\x15\x8a\x72\x1d\x31\xf6\x07\xb6\xc2\x4a\xc5\x9d\x9a\xa0\xbc\x80\x4f\xde\xec\x35\x8a\x43\x23\x57\xdf\x4e\xef\x5c\xba\xbc\xa1\x8b\xfc\x6c\x94\x38\x4b\x9b\xd0\xd2\x18\x5c\xa1\x15\xb8\x32\xe6\xb0\xdb\xdc\xa6\xd2\x3b\x97\xe6\x04\x50\xdb\x02\xd7\x55\x5e\xc7\x96\x75\x67\xe7\xbe\x77\xf9\x65\xad\xf9\x4d\x03\x6a\xfc\xc2\x8b\x94\xde\x29\xa9\xb8\xd4\xc2\xf9\xe9\xf9\xe9\xd8\x15\x01\x3f\x34\xb2\x4d\x66\x7e\x5a\xf3\x92\xd4\x9c\x8f\x5e\x22\xc4\x4e\xe6\x67\x23\xf7\x38\x26\x9e\x32\xc7\x64\x4f\x69\x8e\x4e\xb2\x0a\x9c\xf2\xfa\xa4\x60\x20\xab\xc0\x22\x7b\xcf\xc1\x6f\xc7\xf3\xd3\x2c\xff\x0d\xf0\x0b\xca\xcf\x6a\x50\x9f\x90\x1a\x64\x35\x20\x54\x7e\x56\xe0\xb7\xcc\xb4\xe3\x37\xf0\xf1\x24\xa3\x27\x40\x6a\x5f\xf7\x40\x96\x7f\x28\xde\x73\xa6\x8e\xe0\x39\xa1\x27\xcd\x55\xa8\x2c\xb7\x57\xa1\x40\x5d\x80\x77\x3c\x57\xa5\x95\x6a\x46\x4b\x09\x4b\xce\x6f\xe9\x52\x03\x93\x90\x64\x8a\x9a\xff\x64\x8b\x4a\x92\xbf\xe7\x6c\xae\x97\x39\x16\x01\x59\xd5\x54\xf7\x31\xab\x4f\x40\x91\xf3\xe6\x9c\x63\x1f\x4c\x54\xe1\xe9\xd6\x37\xc3\xfc\x39\xec\xdf\x0c\xfb\x89\xd4\x27\xdb\x5d\x0c\x33\x6d\x02\xc5\x07\x5e\xce\xdd\x22\xdf\x1b\xa2\xb8\x04\x6f\x6c\xbb\x0f\x8f\xe7\x19\xe3\x79\x9d\xd5\xcb\xb7\xbd\x0e\x99\xde\xa8\xa3\x4a\x8d\xb7\xf5\x97\xcd\x4e\xb3\x3c\x93\x74\xa3\xba\x3a\x74\xc5\x4c\xe9\x07\x6a\xdd\x23\xf9\xec\xcd\xef\x60\x2f\xdf\xdb\x07\x48\x29\x1d\xfa\x37\x06\x97\x6f\x0f\x9a\x0b\x69\xa7\x59\xfe\xed\x72\x62\x4a\x38\x96\x63\x0a\xc7\x74\x4c\x31\xcf\xb5\xdd\x98\xe6\xb2\x5a\x0b\xd6\x00\x7a\xf8\x50\x75\xec\xb7\x63\x35\xc5\xf1\xb2\x5e\xfe\xd6\xf6\xb2\x3a\x29\xca\xfa\x84\xe4\x6c\x3e\x58\xe7\x5e\xbe\x37\x0a\xdb\xb9\x11\xa7\x4b\xa9\x01\x98\x35\xb0\xbb\xae\xe7\xf4\xe8\x7c\xfd\x75\xe7\x32\x9c\x35\x55\xee\xf2\x9d\x05\xe3\xb2\xd7\xc4\xc2\x9c\x01\x3c\x9d\x19\x66\xd2\x85\x37\xde\x94\x53\x6d\x1b\xb8\x2a\xb7\xd6\x54\xec\xd6\xd2\xe2\x25\xc9\xdf\x8d\x71\x7f\xe2\x43\xc3\xfd\x59\x65\x7b\xf2\x58\x1d\xd0\x8f\x48\x01\xcf\x64\xaf\x0b\xed\x51\x61\x14\x2e\x72\xc4\xc5\x63\xa5\xd2\x55\x80\xc8\x11\x56\xf6\x78\x7e\x03\x45\xd9\x7c\xbc\xcc\xde\x9d\xd4\xbf\x35\xc4\xd3\x70\xe0\x59\x99\x7d\x20\x35\x77\xd9\x23\x2d\x8a\x05\x27\x92\x3b\x44\x59\x9c\xaa\x82\x6f\x81\x36\xda\xbe\x34\xa3\x9a\xe5\xef\x80\x4c\x04\xa5\x4c\x95\xcc\xb6\xe0\xa2\xcf\x17\x2d\x9b\xb9\xec\x91\xf3\x8f\xda\x5c\x50\xa7\x2d\x0e\x11\x69\xdd\x54\x21\x74\xd2\x34\xa0\x43\x44\x03\xee\x34\xba\x3e\x16\xf4\xdd\x16\x7e\x26\xe9\xcc\x5e\x14\x90\x9f\x5f\x1d\x82\x3d\x3d\xaf\xee\xc9\xa4\xee\x70\xac\x42\x6b\x55\x70\xbd\xc1\xae\x60\x1c\xba\x84\x06\xda\x9d\xa6\x87\xe0\x49\x5e\x9d\x97\x5a\x7a\xaa\x3b\x62\x85\x00\xbf\x3d\x80\xbf\x49\x91\x78\x56\xf2\x8a\x97\x1f\xb8\x64\x2f\xb5\x1b\xa2\x4f\x0d\xec\x00\xeb\xaa\x8d\xfa\x2b\x1b\xaf\xea\x3b\x74\xaa\x5a\x6d\x0a\x29\x6b\xbb\x16\xb0\xe0\xa0\x69\x50\xf7\x34\x51\x17\x68\xaa\xe2\x39\xeb\x6c\x91\x99\x4e\xe9\x3f\x6e\x95\xe0\x1b\xa0\xdb\x05\xfe\xa2\x60\x7c\x03\x10\xd8\x07\x0f\x90\xba\x41\xde\x36\x9c\x9f\x75\xef\xa3\x37\xdc\xb0\x82\xcf\x19\x68\x87\xb3\x35\xfd\xb4\xc2\xa8\xce\xf8\xaf\xb2\xab\xbf\xd6\x36\x70\xf7\x92\x32\xf8\xf6\x3c\x5b\xd4\x0f\xb2\xdc\xce\xa2\xa5\xbd\x97\x53\x19\x57\x27\x45\xc5\xf5\x2c\xa5\xc6\x4c\x2e\x0a\x72\x19\x90\x0a\x14\xea\x0e\xca\x6f\x8b\x82\x91\xea\xe4\x37\x03\xa0\x9a\xcb\xca\x95\x8d\x2c\xe5\x4b\xe1\x31\xcf\x16\xd6\xce\x1b\xe5\xd9\x42\x73\xad\x4e\xfb\x89\x5c\xd8\xa4\x53\x72\xe1\xce\xea\x5c\xa1\xa8\xef\x7b\x45\x12\x4b\xc3\xb7\x24\x67\x7d\xc6\xd5\xf3\x39\x2b\x78\x95\xef\xd5\x12\x10\x2d\x78\x49\xb9\x73\xbb\x70\x0d\x47\xe7\x66\x6f\x52\x0f\xa7\x6c\x82\xfe\x55\x08\xd5\x73\x6d\xed\x6b\xa8\x80\x1c\x77\x99\x5d\xfe\xdd\x98\x59\x91\xd0\x51\xa3\x21\xc8\x19\x38\xa7\xa5\xb9\x74\x5d\x02\xc6\xed\x47\xba\x9c\x7f\x0e\x79\x63\x34\x01\x57\xd8\x68\x41\x53\x08\xa0\xdb\x58\xf5\x44\xcd\x76\xb4\xda\x5c\xee\xd6\x7b\xb9\x87\xe0\x41\xf3\x9e\xa3\xb9\xee\xdd\x0c\xfa\xa4\x25\x8d\x49\xdf\xed\x9d\x96\x49\x9f\x3e\x01\x34\x9d\xce\x00\x6c\xd6\xc6\x25\xaf\xf4\xe5\x5e\xd5\x83\x89\x99\x13\xd5\xfa\xf7\xe3\x49\xb6\xe0\xc0\x44\x3d\x78\xd0\x3e\x2b\x90\x25\x5a\x7c\x81\x6f\x6c\x53\xf6\xc1\xfd\xfb\xaa\x9d\x6f\xbb\x52\x42\x0f\xf8\x7d\xcd\xe8\xfa\xb6\x49\x6b\xbd\x4d\x41\x1b\xe6\xc6\x06\x45\x03\xbc\xb8\xd6\xd2\xf3\x56\x53\x67\x5d\xe8\x6d\xf3\x31\x57\x12\xb1\x67\x66\x38\xf0\x4b\xc5\x99\x64\xcc\x1e\x0f\x7f\x20\x65\x56\x9c\x57\xe0\x37\x0d\xe7\x37\x7d\x71\x8b\x48\x7e\xb0\xbc\xfa\xf4\xf9\xf7\x4f\x9f\x3f\x3d\x7a\x0d\x0e\x01\x02\x0f\xed\xcb\x9c\x9f\x1e\xfd\xfd\xf8\xe9\xf3\xa3\x27\x3f\x3c\x79\xa9\x8c\x2d\x46\x49\x14\x26\x1e\xf2\xfc\x38\xc4\x1e\x0a\x22\x7e\xdf\x83\xb1\x33\xbb\x16\xf9\x07\x2e\x31\xf2\x9b\x22\x6e\xa5\x2f\x13\x20\xf4\xf4\xac\x89\xeb\x0a\x4a\x2d\xc2\x7d\xad\xf6\x19\xc9\xdf\xb9\x3c\x71\xef\xd2\x70\x51\x87\x9f\xa8\x6e\x45\x8f\xee\x2d\xff\xb9\x84\x6f\x72\x72\xe6\x34\x6e\xf5\xa9\x43\x23\xc6\xbd\x39\xee\x3c\x74\x98\xe3\xd5\x3c\x1a\xc3\xf3\x9f\x9e\x3e\x3f\xfe\xdb\xa3\x67\xbf\x3c\x71\x0b\x04\xfc\x81\x87\xfd\xd5\x32\x4f\x73\x85\xa2\xa5\x9b\x77\x04\xd7\xab\x85\xf7\xbc\x39\xde\x5b\x6d\x96\xc3\xbf\x4d\x56\xbd\xac\x68\x0c\x75\x7e\xe5\x7c\x37\x54\xae\xb1\x28\xa7\x38\x08\xbe\x31\x5f\xfb\x7a\xce\xbc\xbc\x03\x6c\x72\x43\x92\x06\xe6\x81\x01\xd9\x96\x6e\xe8\xe9\xd3\x27\x07\xe6\x03\x1b\xed\x3e\xe0\x52\x6a\xc0\xa1\x2d\xfc\x17\x55\xf1\x03\x39\x8b\xa2\xee\x9c\xa9\xf2\xdd\x73\x69\xb2\xc7\xa1\x6d\x3d\xfa\x57\xa7\xfd\x43\x6c\x6b\x31\x33\xc0\xb5\x7f\x2a\x0b\xdf\x7a\x82\x3d\xce\x2a\xab\x2c\x8e\xdf\xc9\xdf\xd1\x54\xf1\x60\x1d\xd7\x7a\x34\x32\x00\x6f\xd7\x47\x1e\x9f\xe5\x69\x0c\xba\x81\xa7\x31\xe8\x7a\x4f\x63\xf0\x67\x7c\x1a\x83\x6f\xea\x69\x0c\xbe\x81\xa7\x31\xde\xe7\x7f\x1a\x73\xd5\x77\x2b\x77\xbe\xbc\x5c\xf9\xf2\x72\xe5\xcb\xcb\x95\xcf\xf8\x72\x45\x6f\x8b\xfd\x9a\xd5\x27\xc5\x79\xed\x54\x5b\xa4\xff\x50\x54\x5b\x59\x62\xd0\x08\x05\x87\xe0\xf7\xcb\x03\x97\x8c\xb2\x1c\x14\xe9\x3f\x2c\x42\x64\x89\xb9\xd2\xd9\x5f\x88\x49\x36\x05\x7f\x55\xa7\x7f\xb4\xc8\xeb\x2c\xb7\x63\xfc\xd5\x56\x9c\xa3\x1a\x90\x4d\xdd\xc2\x86\x79\x32\xc9\x3a\x45\xfa\x0f\x45\x8c\xab\x1c\xf3\xe5\x5d\xce\x97\x77\x39\x5f\xde\xe5\xfc\xb9\xde\xe5\xb4\x57\x71\x07\xde\xe6\x34\x89\xdb\xbe\xcf\x19\x52\x54\x3e\xcb\xfb\x9c\x4e\xcb\xd6\xbc\xd1\xe9\xe4\xdb\xf0\x4e\xa7\x93\xf7\xca\x6f\x75\x3a\xa5\xb7\x79\xaf\xd3\xad\xee\x8a\x6f\x76\x7a\xfd\x7f\xb3\x7a\x8f\xe4\x59\x96\xf3\xa7\x35\x3f\x5d\x7b\x9f\xc4\x66\x9a\x14\x67\x9a\xc1\xce\x56\xef\xdb\x2d\x4c\x1e\x70\x08\x3e\x14\x19\x93\x6b\x41\xe7\x42\xc9\x15\x16\x08\x73\x32\xcf\xaa\xbf\x91\x45\xc6\xec\x95\x10\x5d\xeb\xd4\xbd\x84\xe2\xd4\x76\x35\xd0\x74\x51\xe4\xbc\x0b\xd8\x76\xa7\xb9\xcd\xa2\xb7\xac\xd7\x37\x7b\xed\x4a\x6e\x32\xdd\xd0\x66\x9d\x3a\x19\xac\xb7\xfb\x98\x48\xd9\x32\xd1\x0a\xde\x05\xea\xdf\x21\x6f\x92\x96\xa8\x7f\x8b\xbc\x2d\x85\xfb\x37\xc9\xdb\x52\xbd\x24\xa9\x25\xdb\x34\xa9\x6b\x75\x12\xd5\x26\xb4\xba\x87\x32\xa6\x71\x98\x9b\x84\x6f\xf6\x2e\xd0\xde\x0c\xec\x2d\x55\x78\x81\xd5\x6f\x15\xbe\xe7\xcb\xbd\xb7\xee\x5d\xfd\xdd\x47\x71\xf3\x6d\xfd\xcf\x79\x99\x53\xe3\x62\xda\x7d\x0b\x70\x81\xf6\x41\x77\x88\x96\x68\x1f\x74\x47\xe6\x02\xef\x83\xee\x80\x2c\xf1\x3e\xe8\x8e\x83\x7b\x25\xd4\x8d\x57\x5c\xfb\x9e\x2f\x9d\xbb\x62\xd3\xb1\x0b\x58\x16\xb1\x6b\x2f\x52\xd6\x27\x1c\x9c\x14\x65\xf6\xaf\x22\xaf\xc9\x42\xdd\x94\xe8\x3c\x9e\xea\x9f\x6a\xb7\x79\x7f\x2e\xb2\xbc\xae\xec\x24\x7c\x46\x2a\xa9\xa3\x64\xb9\x54\x99\xf4\xb5\xdb\xa2\x6c\x0e\xf0\x99\xde\x2b\xb7\x12\x65\xe5\xba\xe6\x0f\x65\x71\x7e\x76\x09\x7e\x6c\x1b\xb2\xdd\x03\xae\xb6\xc0\x5a\xd1\xd5\x66\x9b\xf4\xdb\x7f\xb5\x1b\x99\xa3\x17\x32\x9d\x77\x89\x9d\x0b\xfe\x1f\x33\xa6\x76\xe3\x4d\x9a\xfa\x74\xd3\x1d\xd4\x37\x99\xda\xb8\xde\xf5\xcc\x15\xdc\x7f\xfa\x04\x56\x22\xaf\x78\x51\x53\xa9\xff\x35\x3f\x95\x5d\x5b\x01\xb5\xf9\x9e\xe4\xf0\x25\x6b\x75\xb7\x46\xdd\x7a\x1c\x78\x2e\xa3\x58\xa4\xcf\x21\x1a\x76\x9f\x49\xc0\x7d\xb0\x82\x31\xfd\x08\xa6\x97\x7b\xdd\x03\x1c\xb5\x8e\xd9\x07\x99\xc3\x32\x8e\xf4\xb1\x73\xb6\x7b\x49\xb3\x99\xe9\x5a\x84\xac\x4c\x0f\x57\xb8\x93\xbd\x59\x76\x5d\xe9\xba\x23\xb5\xd3\xb9\xbe\xee\xda\xb6\xb1\x73\xfb\x51\x8d\x69\xff\x16\xe3\xa0\x04\xf8\x20\x25\x37\xdd\x86\xf7\x6d\xce\xcf\xc0\xf9\x7f\xb3\x8d\xd8\x8e\xef\x6d\xf6\xb5\x5c\x6f\x33\x4d\xba\xed\x1e\xe0\x78\x6f\x9c\xe3\xc7\x9f\x76\xba\xcf\x37\x3b\xc4\x78\xc2\xd5\x01\x58\x9b\xaa\x23\xdc\x2c\x0d\xce\xdb\x4c\x36\xaa\xc7\xf3\x3d\x9c\x4b\x8e\xef\x46\x5d\x83\xdf\x7b\x80\xae\xcb\xed\xde\x18\xb7\xaf\xb0\xab\x9a\x13\xfb\xdc\xbe\x9a\x4b\xce\x8a\xe0\x3e\x58\x45\xdf\xcd\xb0\xbb\xd7\x67\x77\x8b\x8f\x3f\x2f\xb3\xdb\x16\x6e\x66\xf5\x11\xc6\xf9\x96\xd0\xf7\xef\xca\xe2\x3c\x67\x6b\x59\xa7\xcd\xd6\xbb\x45\x2e\xf5\x92\xee\xf5\x71\x19\xd3\xa3\x59\x95\xe9\xd3\x27\x93\xf9\xf0\xd0\xe8\x31\x57\x21\xd1\x4d\x6f\xea\x24\xe8\x17\x67\x84\x66\xb5\xfb\x82\xce\x89\x1d\x9e\x9c\xbd\xee\xec\xec\x96\x5d\x8e\x4f\xdb\xde\xc0\xbc\xdd\xe5\x71\xcf\xf0\x78\x8b\x88\x1b\x20\x14\x49\x05\xf5\x9e\xcb\x4e\x17\x9d\x99\x73\xd9\x61\x22\xd5\xc4\xfd\xfe\x7c\xa9\x9b\xb5\xbf\xc2\x43\xcd\xeb\xa7\x9e\x86\xa9\xf5\x4e\x19\x76\xe3\x0c\x56\xf7\xc1\x20\x8a\xb7\x21\xdd\xf4\xdd\x9e\xc3\x4e\x6b\x89\xf4\x2a\xcf\x1a\x36\xbd\x94\xb9\x70\x5e\xbd\x8c\x8c\xbd\xbf\x6e\xec\xfd\x8d\x63\xef\x0f\xc8\xf7\x01\xb5\xce\x77\xf4\xba\xb5\x53\x81\xdf\x4c\x05\xc3\x10\x1f\x17\x45\xc9\xb2\x9c\xd4\xbc\xfa\x41\x4f\xb2\xda\x2e\xe4\x4a\x2d\x43\x19\x87\x6a\xde\x00\x70\x5d\xb6\x0e\xa6\x1f\x5d\x64\xee\x6b\x24\xf5\xdd\xc1\x78\x2f\xc3\xb2\x9f\xa1\x10\xa2\xe2\x2e\x62\x75\x44\xe7\xc1\xac\xa4\xad\x5f\x7b\x23\xd4\x46\xae\x64\xfd\xb1\x3f\x56\x4e\x6c\x57\x6a\xe9\x61\xff\xcb\xa1\xf6\xa7\x69\xc6\xd8\x7e\x5e\xa8\x2d\xca\xfb\x17\xf2\xf7\x52\xff\x5e\x5e\x5d\x9c\x05\xa3\x54\xba\xa2\xd9\xdb\x06\x07\xf3\x7e\xd2\xd0\x08\xae\x14\xea\x26\x74\x3b\xba\xfb\x76\xc6\x7a\xd2\xea\x6c\x73\x0c\x74\x68\x7d\xe9\xc9\xef\x9a\x3e\xf6\xf5\x9f\x99\x95\x67\xc3\x63\x6b\xc5\x9a\x33\x9a\x33\x43\x3e\xfb\x96\x8c\x2e\x57\x17\xc6\xd7\xeb\xfe\x3a\x46\xe8\x74\x7e\x65\x58\xd6\x95\x9c\xfc\xae\x39\x67\x5f\xff\xf9\x3c\x1d\xff\x63\xd5\x96\xb1\x67\x59\xae\x96\x31\x1b\x20\x1d\x75\x59\xb6\xcd\xbe\x6e\x15\x3f\x5b\x41\x7e\xaf\xf0\xd8\x62\x60\x40\x6f\xea\x3e\xf4\xea\xec\x9e\xae\x7f\xec\x85\xae\xf8\xd8\xab\x03\xfa\x0f\x7c\xf0\xb5\xf6\xbd\xd7\xf0\xe5\x86\xce\x23\xab\xb5\xcf\xbd\xb6\x28\x6f\x28\xfe\x5a\x30\x2c\x63\x5c\x0f\x48\x43\x56\x3b\x01\x52\x0f\x9b\xe4\xc0\x4d\xde\xec\x52\x5a\xed\x55\xae\x1b\xe4\xd1\xa2\xe6\x15\xc8\x4e\x65\xa5\x7a\xb5\x53\xc1\xb4\x28\x16\x6f\x15\xe3\x59\x96\xfa\x82\xb4\x2b\x20\xad\x2f\xc2\x76\x42\xde\xe6\xd7\x7c\x1b\xa8\xbe\x33\x7e\x7f\x78\x43\xd6\xab\x08\x3b\x35\x4c\x8d\xd4\x9d\xf5\xca\xee\xb5\x00\x9b\xc9\x7b\x77\xda\xbd\x03\xac\xe6\x73\x2d\x18\x56\x09\xb8\x16\x90\x56\xe9\xb8\xa6\x24\x75\xf4\x93\x6b\x40\xda\xf4\x1a\xd4\x3e\x06\xb5\x6f\x41\xcd\x44\x02\xdd\x09\x01\xf6\x05\xbb\x3a\x73\xef\x48\x2d\x1b\x63\xde\xa3\x35\x04\x02\x0a\x31\x7a\x36\xb2\xca\xbe\x6f\xde\x3a\x30\x48\x5a\xd1\xac\xaa\x88\x82\x31\xbc\xc3\xda\xe7\x3a\x59\xfe\x4e\xdf\x2e\x89\x04\xd9\x31\x0f\x72\xd3\xcf\x56\x57\x0e\xb2\x7b\x77\x73\xbd\x3f\xd3\xdd\xdc\x63\xbb\xab\xfc\x58\xdf\x52\x57\x0c\x2d\x29\x6d\xf4\xfe\x61\x10\xed\x7a\x63\xf5\xb8\xd1\x61\x8f\x9f\x65\x39\x1f\xad\x01\xe3\x1d\xaf\x01\x63\xb7\x8a\xbf\x4b\x09\x30\x5a\x47\xec\xef\x7c\x17\xb4\xad\xe2\xf5\xfa\x2a\xae\x79\x17\xb4\xa1\xa3\x0d\xf7\x41\x91\xbe\x63\x3b\x70\xbb\x44\x62\x19\xa8\xd1\x74\x6e\x96\xec\x4c\xd7\xdb\x38\xa6\x18\xa7\xa6\xc1\x7b\x28\xbf\x5b\xb9\x66\x56\x3b\xb2\xc1\x2a\xbf\xe2\xd2\x1f\x4a\x72\x76\xa2\x41\x64\x0b\xb6\xfe\x61\xfc\x0a\x6d\x0d\xd4\x27\x61\x92\x8b\xac\x6a\x56\x12\x52\x44\xfc\xae\xa2\xcc\x53\x76\x35\xf3\xec\xcd\xc0\x23\x93\x6b\xbd\xa0\x5d\x25\xb6\x81\x4a\xf5\x8b\x5f\xa7\x8e\xe5\x15\xea\x18\xa2\xb6\xc1\x3a\x54\xdf\x44\x51\x9e\x92\x5a\xe6\xfa\x89\xac\x05\x3b\x46\x61\x16\x74\x07\x90\xac\xe0\x8e\x3a\x13\xef\x0b\x32\xff\xf6\x7c\x05\xa5\x59\xce\xb2\xfc\x5d\xcf\x53\x50\x7b\x05\x9c\x4d\x06\xeb\xbb\x9b\xde\x9d\x75\xfc\xb5\xd8\x25\x28\xff\xc0\xf3\xfa\x31\xcf\x6b\x5e\xea\x27\xd5\x37\x58\x27\x19\xa9\xf3\xd5\xeb\xe7\x8f\x8f\x9f\xfc\xed\xc9\xf3\xa3\x95\x2a\xb7\x97\xd7\xaa\xe1\xe3\xc2\x20\xf1\x77\x14\x3a\x2d\xe4\x6b\x3d\x9b\xb0\x40\x9a\x2b\xea\x0e\xa2\xc1\xa1\xba\x83\x78\x95\x36\xcc\x89\xba\xb2\xab\x5e\xcb\xb6\x80\xe6\x15\xaf\x7f\x22\x17\xcf\xb2\xaa\x96\xe2\xc6\x1c\x3f\xae\xc9\x30\x51\x22\xf2\xd2\x34\xa9\x1d\x07\x70\xd8\x6e\xb0\xcc\xab\x65\x4e\x7f\x2a\xce\x2b\xfe\x44\x35\x62\x6f\x95\xde\xd7\xfa\xc6\xea\x3c\x4b\x7d\x08\x1e\x17\x67\x4b\xfd\x8e\xf1\xff\x2d\x96\x6a\x4d\xf4\x34\xa7\x73\xf5\xe8\x53\x3f\x3b\x7d\x5e\x30\xf5\x82\x4b\xdf\x80\x29\xca\x6a\x7e\xe7\xe1\x43\x59\xf2\x67\x5e\x9e\x66\xfa\x4a\x66\x56\x81\x13\x5e\xf2\x74\x09\xde\x95\x24\xaf\x39\x9b\x01\x51\x72\xf5\xd6\x51\x36\xfa\x1d\x9f\xa9\x27\x6a\xf9\x12\x9c\xf1\xb2\x2a\x72\x50\xa4\x35\xc9\xf2\x2c\x7f\x07\x88\x04\xa5\x1c\x16\xa9\x27\x9d\x59\x05\xaa\x42\xd4\x1f\x49\xc9\x55\x1b\x48\x55\x15\x34\x53\x87\xc9\xac\xa0\xe7\xed\x13\x55\x39\x7f\x54\x60\x52\x9f\x70\x09\xe0\xee\x2b\x53\xe8\xee\x54\x55\xc5\x38\x59\x80\x2c\x57\x57\x5c\x6c\x92\x7a\x5c\x5b\x9c\xd7\xa0\xe4\x9a\x83\xd5\xd5\xaf\x2c\xa7\x8b\x73\xc9\x3e\x12\x8c\xcd\xb1\xc8\x4e\x33\x53\x8f\x7a\xb8\x29\xf1\x53\x49\xb8\xe7\x95\xba\xb3\x79\xb6\x9c\x81\xd3\x82\x65\x42\xfe\xe5\xaa\x7f\x67\xe7\xe9\x22\xab\x4e\x66\x12\x0c\xcb\x2a\x73\x5f\x68\x06\x2a\x19\x4f\x79\x2e\x0b\x92\x9c\x3d\x2c\x4a\x50\xf1\xc5\x42\x02\xc9\xb4\x9a\xe9\xb6\x51\xe5\x91\x15\x9d\x49\xe4\xd6\x12\x98\xc6\x98\xaa\xfd\xe3\x49\x71\xda\xed\x52\x56\x01\x71\x5e\xe6\x59\x75\xc2\x55\x31\x56\x80\xaa\x50\x95\xca\x29\x50\xc6\x18\x04\x89\x62\xb1\x28\x3e\x4a\x84\xd3\x22\x67\x99\xec\x5a\xb5\x6f\x06\x52\x2b\xad\xc5\x07\xae\x7a\xa6\x89\x21\x2f\xea\x8c\xea\x21\x50\x83\x72\xd6\x0e\xb6\x49\xaa\x4e\xc8\x62\x01\x52\x6e\x30\xc8\x99\x04\x95\xe5\x80\x38\x9d\x2b\x65\x4b\xd4\x0b\xc8\x8c\x2c\x80\xa4\x3b\x59\x6f\xbf\xd3\x96\xa0\x8e\x7e\x7c\x02\x5e\xbd\xf8\xfe\xe8\xd7\x47\x2f\x9f\x80\xa7\xaf\xc0\xcf\x2f\x5f\xfc\xed\xe9\x77\x4f\xbe\x03\x77\x1f\xbd\x02\x4f\x5f\xdd\x9d\x81\x5f\x9f\x1e\xfd\xf8\xe2\x97\x23\xf0\xeb\xa3\x97\x2f\x1f\x3d\x3f\x7a\x0d\x5e\x7c\x0f\x1e\x3d\x7f\x0d\xfe\xe7\xe9\xf3\xef\x66\xe0\xc9\xdf\x7f\x7e\xf9\xe4\xd5\x2b\x09\xea\xc5\x4b\xf0\xf4\xa7\x9f\x9f\x3d\x7d\xf2\xdd\x0c\x3c\x7d\xfe\xf8\xd9\x2f\xdf\x3d\x7d\xfe\x03\xf8\xf6\x97\x23\xf0\xfc\xc5\x11\x78\xf6\xf4\xa7\xa7\x47\x4f\xbe\x03\x47\x2f\x54\x9d\x06\xda\xd3\x27\xaf\xc0\x8b\xef\x65\xe9\x9f\x9e\xbc\x7c\xfc\xe3\xa3\xe7\x47\x8f\xbe\x7d\xfa\xec\xe9\xd1\xeb\x19\xf8\xfe\xe9\xd1\xf3\x27\xaf\x5e\x81\xef\x5f\xbc\x04\x8f\xc0\xcf\x8f\x5e\x1e\x3d\x7d\xfc\xcb\xb3\x47\x2f\xc1\xcf\xbf\xbc\xfc\xf9\xc5\xab\x27\xe0\xd1\xf3\xef\xc0\xf3\x17\xcf\x9f\x3e\xff\xfe\xe5\xd3\xe7\x3f\x3c\xf9\xe9\xc9\xf3\xa3\x39\x78\xfa\x5c\x02\x7b\xfe\x02\x68\x1e\x7e\xf5\xe3\xa3\x67\xcf\x54\x85\x8f\x7e\x39\xfa\xf1\xc5\xcb\x57\xb2\x95\x8f\x5f\xfc\xfc\xfa\xe5\xd3\x1f\x7e\x3c\x02\x3f\xbe\x78\xf6\xdd\x93\x97\xaf\xc0\xb7\x4f\xc0\xb3\xa7\x8f\xbe\x7d\xf6\x44\xd7\xf6\xfc\x35\x78\xfc\xec\xd1\xd3\x9f\x14\x61\x7d\xf7\xe8\xa7\x47\x3f\x3c\x51\x05\x5f\x1c\xfd\xf8\xe4\xa5\xca\x69\xda\xf8\xeb\x8f\x4f\x54\xd4\xd3\xe7\xe0\xd1\x73\xf0\xe8\xf1\xd1\xd3\x17\xcf\x25\x7e\x1e\xbf\x78\x7e\xf4\xf2\xd1\xe3\xa3\x19\x38\x7a\xf1\xf2\x08\xbc\x78\xa9\xf0\x23\xb3\xfe\xfa\xf4\xd5\x93\x19\x78\xf4\xf2\xe9\x2b\x89\x9c\xef\x5f\xbe\xf8\x69\x06\x24\x76\x5f\x7c\xaf\xf0\xf7\x5c\x16\x7d\xfe\x44\x03\x92\x98\xef\x0e\xd0\x8b\x97\xf2\x5b\x02\xfb\xe5\xd5\x93\xb6\x45\xdf\x3d\x79\xf4\xec\xe9\xf3\x1f\x5e\xc9\xf2\x6e\xfe\xb9\x73\x91\x5c\x09\xae\x27\xa7\x59\x5d\x37\x67\x7a\x6a\xbb\xd6\x88\x55\x7b\x54\x62\x3f\x3f\x7d\x02\xbf\x5f\x1e\x34\x99\x4e\x1d\x81\xd9\x64\xed\x44\x7e\xfa\xd4\xb5\xbf\xb1\xf2\x20\xd1\x6d\xc0\x81\x12\x83\xdf\x12\xfa\xfe\x23\x29\x59\xf5\x80\x16\xa7\x67\xa4\xd6\x2f\xf1\x73\x29\xfb\xe0\x1c\xc1\xf9\xc5\x1d\xb7\xcc\xdc\xfd\x58\x85\xd7\xc9\xda\x3e\x92\x68\xbb\xe7\xb4\x6e\x2c\x6f\xaf\x97\x4e\x09\xd5\xdc\x56\x27\x76\x01\x54\xe0\x63\xb6\x58\x80\xb3\x32\xcb\x6b\x40\xc0\x47\x52\x2a\x19\x9b\x09\x70\x5a\x28\x63\x10\x24\x07\x08\x82\x45\x03\x98\x94\x4a\x3a\x10\xc6\xb4\xfc\xc8\xea\xb9\x36\xf5\x93\x55\x80\x48\x69\x27\xce\x17\x4d\x4d\xfa\xd5\xff\x09\x5f\x9c\x55\x40\x68\x9d\x03\x9c\xf2\xd3\xa2\x5c\x82\x05\x27\xef\xab\x79\xb7\x33\xa6\xd8\x4f\xdd\x8e\x20\xa8\x7b\xf0\x22\xfd\x90\x15\xe7\xd5\x62\xa9\x2e\xeb\x4b\xa1\xd1\xf4\xa1\x3a\x29\xce\x17\x4c\x8a\x16\x25\x87\x75\xcb\x10\x34\x2d\x6b\xa8\x88\x48\x89\x56\x49\x58\xca\xf2\x50\x5d\x18\x61\x54\x72\x52\x71\x36\x07\xaf\xb8\x8a\xfc\x17\x2f\x0b\xf5\xdc\xe5\x3c\x37\xe0\xe6\x63\x48\xef\xcd\xc6\xae\x0b\xbd\xdc\x79\xcf\x9b\x55\xe6\x51\x6e\xae\x16\xe2\xb9\x7a\x4b\xfb\xe9\x13\xc8\xaa\xe7\xe4\xf9\x24\x9f\xea\x83\x05\xfd\x98\xa1\x7d\xc8\xb0\x67\x5e\x2e\xa4\x1c\x10\x70\x56\x54\x59\x9d\x7d\xb0\xaf\xb5\xd5\xc3\xe2\x61\xf2\xce\x1d\xdf\x6c\xfa\x9e\xd2\xe5\x38\x85\xf1\xd3\xac\x76\x5b\x2d\x23\x5b\x8b\x01\xbc\x9c\x81\x13\x92\xb3\x85\xfc\xb1\xe0\xb9\xba\x3f\x5e\xcd\x40\x36\x6b\x29\x42\x1d\x7f\xa8\x5e\xba\x2c\x68\x7b\xd4\xe1\xd1\xdf\xb5\x37\xc0\x87\x0f\xc1\x53\x25\xcf\xf5\x74\x94\x17\x60\x8f\xcb\x0e\xef\x69\x45\xa7\x01\x2d\xb3\xe4\x1a\x2b\x73\x53\x47\xdd\x18\x57\xd4\x25\x5c\x8b\x29\x9d\xfa\xe7\x2a\x1d\x7c\xfa\xd4\x1c\xf5\x4c\xb2\xca\x2c\xf3\x56\xf3\x4d\xc1\xd7\x5f\x83\x81\xf2\xf6\xba\x94\x63\xbe\xa4\xec\x3c\x19\xd4\xce\x21\x6d\x0b\x78\xe9\x3e\x23\x7a\xa2\x21\xff\xee\x1c\x66\xc9\xf1\x95\x6a\xb9\x14\x81\xb9\x46\x2c\xeb\x76\xde\x9e\xc5\xf5\x2f\x76\x3f\x7c\x08\x1e\xd5\x92\x69\xaa\x1a\xbc\x93\x64\x50\x15\xa7\x1c\xbc\xcf\xb4\x61\x0b\xa9\x6c\xf1\x0b\x3b\x7b\x4b\x2e\x2c\x3b\xd7\xb0\x78\x69\x55\x54\x43\x59\xbf\xe4\x94\x9c\xab\xe3\xc0\xf3\xbc\x52\xa6\x2a\x32\xce\xc0\x5d\xd5\x92\xbb\xba\x25\x73\x30\xd9\x03\xf7\x65\x87\xef\x83\xbd\xe9\x9e\x63\x71\x92\x97\xea\x35\x9f\xaa\xf1\x50\xf6\x67\xa5\x87\x65\xd7\xa0\xff\xa5\x7d\x69\x60\x68\xa9\x27\xae\xb5\x2b\x86\x86\x8e\xb2\xea\x17\x2b\xba\x26\xa6\x80\x61\x10\xfb\x6e\xaf\xf1\x3e\xaa\xb3\xdb\xf3\xd7\x36\xb7\x41\x5c\xf5\x31\xab\xe9\x09\x98\xf4\x1f\x82\xb6\x83\x22\xf5\x1c\x89\x52\x4a\x2a\x7b\x91\x50\xfd\x06\x68\xbf\x3d\x62\xd4\x50\xf5\x13\x35\xd9\x6e\x07\x15\x69\xc9\xc9\xfb\x03\xb7\x20\x5e\x53\x70\xd6\xa1\x9c\xb5\x60\xbc\xad\xc1\xb8\x5f\x78\x14\xe8\xc3\x87\xa0\x5a\x14\x1f\x1b\xba\x30\xa2\xb6\xad\x45\x32\xb6\x35\xe1\xe1\x0a\x38\xa9\x8a\xea\xaa\x9b\x6a\x66\xcd\xfb\x7f\xb7\x79\xbd\x57\x26\x95\x7b\x48\xda\x3e\x8f\x68\x98\xb0\x3f\x56\x3b\xd5\xbf\x70\xc4\x9e\x6d\x87\x2a\x31\xb1\x19\x78\x0e\x0e\xdb\x6c\x8e\xf3\x4a\xa0\x1f\x34\x3a\x6f\x62\x17\x3c\xd7\x4f\x61\x4d\xd7\x9a\x52\x6f\xb2\xb7\xc3\xbd\xbb\x74\x4e\x7e\xd5\xc3\xd4\x75\x92\x96\x30\x66\xa5\x74\x5f\xe0\xb6\xd2\xb4\x15\xbd\xa7\xad\x5c\x75\x28\xbc\xc9\x37\x32\x63\x34\xa2\xb3\x9d\x38\x6c\x4d\x7b\xd3\x9d\x24\xf5\x51\x01\x88\x7a\x9d\x53\x72\x7a\x5e\xea\xb5\x9b\x5e\xe3\x28\x3a\xd5\x13\xa9\x95\xca\x77\x73\xfe\xd1\x76\xf2\xee\x57\xe0\x5b\x2e\x8a\x92\x6b\x38\x84\xa9\xd9\x3f\x6b\x84\x54\x83\xde\x19\x10\x59\x59\xd5\x40\x4d\x45\x1d\x08\x8d\xd4\x77\x05\xb3\x93\xc1\x69\xba\x2c\x3c\xd9\x73\xd2\xf6\x66\xaa\x59\xdd\x17\x29\x00\x0c\xe0\x72\xde\x22\xff\x9b\x5e\xee\x95\x2c\x60\xbf\x1d\xaa\x61\x74\x6a\x61\xa6\x5b\x26\x95\x16\xd7\x5e\xb4\xc2\x58\x21\x94\x51\xc1\x06\x34\xf8\xae\xc8\xf7\x6a\x90\x73\xa9\xb5\x9c\x70\x6d\xc9\xdb\x58\x01\xd4\x67\x2d\xf3\x95\x11\xd2\x95\x38\x94\x2d\xa9\x71\x95\xc7\x06\xda\xd5\x34\xec\xa9\x00\x1f\xf9\xde\x07\x0e\xc8\xa2\xe4\x84\x2d\xc1\x3b\xa9\x54\xe5\xc0\x98\xad\xfb\x87\xa4\x1f\x72\x76\xc6\x73\x36\x56\xfd\xfc\xec\xbc\x3a\x99\x38\xe8\xd0\x4d\xb0\x15\x3c\xd2\x03\xae\x4c\x53\x71\xb9\x84\x04\xcd\x19\xaa\xee\x6b\x21\x57\xfa\xf9\x3b\x65\x19\x46\x5b\xd3\x1b\xef\xe7\x9b\xd5\xd8\x96\x69\xde\x5a\x5a\x55\x6f\xee\x14\x5f\x37\xe3\x25\xd5\xcc\x66\xa2\x18\x47\xcb\xca\xfc\x6f\xba\x28\xf5\xe1\xd6\x7a\x99\xe1\xc6\x76\x7a\x5a\xd5\xbf\x1c\x55\xe1\x74\x70\xa9\x31\x68\xe3\xec\xb4\xb7\x22\x18\xd2\x84\x3b\xd7\xf2\x65\x4b\x4e\x65\xa3\x4f\xc1\x5f\x01\x6c\x6e\xaf\x74\x1b\x6f\x4c\x2a\xfd\x15\x9c\xb6\x8d\x1a\xed\xa3\x7d\x5b\x6f\x27\xa1\x22\xaf\x0a\xb9\x02\xd2\x72\x65\x22\xd7\x35\x53\xbb\x3c\xd8\x07\xf6\xd1\x62\xa7\xd5\x56\xb5\xdf\x03\xf7\x7b\x7c\xa4\xff\xdb\x93\x83\x01\x18\xaf\x39\x95\x3a\x35\xf8\x2f\xe6\xae\x2b\xe4\x82\x62\x3e\x5e\xf6\x97\x8a\x2b\x09\x31\xb4\x07\x36\x6d\x8c\x75\x49\x06\x53\x3a\xfb\x7c\xaf\xcf\xf9\xa3\xfd\x6f\xec\x55\x19\x09\xd1\xbe\x48\xb6\x48\xa8\x4b\x42\x8d\xda\xd9\x4a\xd3\xae\x72\x26\x97\x24\xd5\xf9\x99\x5c\x2e\xea\xe7\x0d\x4f\x9f\x00\x04\xdb\x3b\xaf\x2e\xa4\xc9\x74\x44\x3d\xda\x56\x69\x2f\xf2\x3e\xbd\x0c\x4e\x33\xeb\x00\x28\xd3\x17\x6b\x27\xa1\x9b\x9f\x7a\xf4\x95\xf0\x52\xd1\xda\x80\x07\xf9\x77\xcd\x65\x5d\x73\x13\xeb\xb4\xf8\xc0\x6d\x5f\x4c\x13\xdf\xd9\xcb\xf5\xe6\xea\x78\xe9\x9a\x16\xb4\xb0\x5d\x3a\x6e\xc4\xec\xf0\x23\xd8\x83\xee\x00\xbc\x6b\x05\x7d\x57\xb6\xaa\x16\x35\x88\x7a\xd7\xb9\xf3\xd5\x0e\xd7\xc3\x87\x8a\x44\xe5\x42\x78\xaf\xdb\x7c\xbb\xb4\xc9\x84\xe8\x4c\x7e\xe0\xa3\xb2\x09\x26\xb3\xb2\xb1\xc1\xea\x42\xda\x46\x77\x90\x31\x33\xb3\x62\x2c\xf2\x99\xb1\xad\x36\x03\xd9\x6d\xe9\x14\xea\xe5\xc9\xd8\xac\xd8\x41\xdb\x1d\x3d\x44\x23\x2b\x02\xc7\x42\x9d\xcc\xe5\xa8\x6f\xb6\x73\xca\x9c\x5d\xd3\x08\x0d\xea\xb0\x1d\xbb\x76\x01\x38\xe9\xf5\xd8\x99\xf5\xbf\xfe\x1a\x74\x62\x3a\x10\x1a\x81\xce\xf8\x82\x2b\xe3\xc2\x43\xcd\x1c\xd0\x53\xba\xc3\x36\x75\xe5\xaf\x56\x56\x7a\x14\x62\xf4\x95\x9e\x7e\x31\xa4\x3a\xcb\x1c\x4d\xb3\x1a\x2d\xb6\x31\xe6\xf2\xe0\x81\x9c\x13\x0e\x5a\xbe\xb0\x98\x51\x56\x34\x06\x91\xa3\x10\x64\xb2\xb4\x68\x30\x78\xe9\xc4\x0d\xa2\x06\x80\xce\x80\x64\x23\x6b\x90\xcb\xfe\x0c\xd6\x94\xf9\x0b\x80\xd3\xee\xe5\x53\xe7\x81\x95\x6d\xbe\x9d\xcf\x64\x13\x50\x5b\x75\x27\xc9\xda\x10\xdd\x38\x5c\xbd\x09\x58\x01\xa9\xce\xd4\xd2\xa1\xe5\x1b\x34\x5d\x99\x74\x6f\x7a\x88\xaf\x28\xf9\x35\xc0\x47\x8b\xc5\xe0\x96\x53\x77\xf3\x46\xd9\xbe\xd9\x6a\x9b\xa6\x8f\x73\x33\x9f\xe9\xb2\xca\x76\x65\x51\x82\x6e\x5f\x66\x20\x2f\x1a\x3d\x4e\x76\x76\x08\x7a\x1f\x41\x8e\x1a\xd5\x5f\x92\x6b\xc3\x76\xd3\x01\x2d\xc5\xac\x46\x64\x74\xc3\x0a\x63\xa2\x65\xe3\xb0\x77\x7a\x6a\x70\x6f\xa4\x76\xaf\x83\xaa\xcf\x64\xb1\x70\x54\x14\xbd\x83\xa8\x25\x79\x75\x67\x6d\x3f\x5c\xe6\x34\x96\xa4\x3a\x68\xef\xf0\xa6\x7a\x44\x7f\x78\xb8\x32\x67\x38\x76\x70\x5c\xbc\xac\xd2\x80\x84\xd0\x31\x8a\x3b\x96\x6f\xa5\x86\x83\xb1\xc5\xdf\x18\xb2\x16\x2b\xfb\xe8\x23\x7b\x38\x2b\xd3\x4b\xab\x1a\x8f\x4f\xef\x6d\xde\x83\xae\xec\x5b\x74\x0f\x44\xd5\xa0\x3d\x7b\xfa\xfd\x0b\x50\x94\xcc\xec\x69\x58\x53\xa3\xbd\xb5\xfe\x74\x15\x75\x63\x95\xbe\xe9\x97\x05\x0f\x80\xd9\xa6\x91\x68\x5d\x43\x5a\x57\xe0\xe0\xc5\x66\xc6\x2d\x79\x7d\xb0\xcb\xac\x2a\xd7\x49\x6f\x7b\x2b\xc1\x66\x18\x46\xd7\x82\xa6\xe0\x6a\xfa\xdb\xce\x8a\x4e\x67\x1b\x50\x9f\x9d\xfd\x96\xc6\x1e\x6b\xbd\x15\x0a\x1e\x17\xe7\xf9\xc8\xe6\x73\x9f\xc9\x5d\xab\x94\xfc\x83\xa3\xa4\x8d\x8c\xc6\x0a\x15\xb6\x85\xa6\xbd\x99\x06\xf5\x64\x8b\x93\xb3\x9b\xb1\x4d\x70\xf4\x10\xc7\xc8\x25\x1c\xe8\xf4\x68\x57\xcd\x52\x46\xcf\x08\x1d\xeb\xe0\x7c\xa8\xa8\x46\x8d\xae\xa0\x51\x98\x9d\xee\x91\xf2\x5d\x07\x88\x59\xc0\x90\xf2\x5d\x6f\xd9\xa2\xee\x0a\x38\x10\xcc\xb9\xc4\xa6\xf2\xe6\xd0\xa1\x5f\xda\x28\x24\x9b\x4a\xeb\x6d\x8c\x3d\x6d\x36\xff\x5d\x63\xc0\xa9\x0f\xad\x5d\x57\xf7\x01\x5a\x48\xd6\x4c\xcc\xe5\xaa\x59\xd0\xf0\xcb\xd5\xc3\xe3\x6f\xc9\xb8\xf9\x46\x8c\xe3\x2f\x37\x0f\x6f\xe2\xe6\xe1\xb7\xa4\xfc\xb7\xba\x78\xf8\x2d\x29\xaf\x7d\xef\x50\x11\xd6\x97\x6b\x87\x9f\xfd\xda\x61\xf4\x67\x12\x62\x9f\xcf\x04\x2e\xbc\x29\x13\xb8\xf0\x06\x4c\xe0\xa2\x5b\x94\xd6\xf8\xf8\x58\xb9\xe4\x3a\x6e\x7d\xcc\xad\x95\x76\x28\xc0\x3b\x4b\x54\xa7\x22\xed\xde\x6a\x43\x4d\x3b\x5a\x6b\xf6\x07\x9c\x72\x8f\x7a\x86\xd9\xad\x8a\xa0\xe9\x4c\x36\x7e\xb3\xde\x4b\xc2\x31\x89\xfd\x73\xb6\x7a\x55\xfc\x33\x8a\xec\xb5\x04\xb5\x95\xc8\xfe\x39\xdb\xe9\xaa\x78\x17\x4f\x23\xe2\x5a\xa9\xca\x46\x70\x66\xd6\x8a\xdf\x82\xbf\xe3\x39\x7b\x5c\xe4\xb5\x72\x73\xb5\x47\x65\x55\x25\xd7\x6e\x5a\xd7\x0b\x78\x62\x89\x78\x7b\x21\x3f\xcc\x02\xdb\x48\xfa\xb2\x21\xe4\xed\xc5\xfd\x08\x1f\xdc\xa0\xd0\xef\xfa\xa3\x4f\x87\x05\xfe\xec\x4e\x73\xe8\xae\x1e\x25\xed\x9b\x15\xcd\x82\x2c\x8b\x73\x85\x73\xe3\x86\x54\x9f\x5b\x28\x7f\x17\x0a\x3b\xfb\xd6\xe5\x03\xcf\x99\x89\xf0\x42\x13\x45\x2f\xf6\xc1\x5e\x00\xff\xcb\x14\xa2\xcb\xce\xe7\xaa\xb3\xbb\x9e\xbb\xbb\xbd\x18\xfe\xd7\x9e\xb2\xab\x71\x07\x80\xe6\x1d\x71\xbf\x65\x57\x95\xe3\x8e\xd3\x3e\xdb\xa7\xb7\xd3\xd5\x5e\xed\x00\xb6\x7d\x31\xe6\x62\xe3\x9a\x80\xd6\x3b\xb0\x5c\xdf\xc5\x4d\x2f\x51\x37\x35\x60\x97\x8a\xe5\xa4\x9e\xbf\xb3\x18\x5d\xef\x3d\xf3\xcf\xde\xfa\x2d\x5d\x77\xfe\xd9\xbb\xb1\xa5\xdf\xd0\x3f\x6f\x37\xd4\x46\xc6\xa0\x46\xba\xd6\x19\xe5\x17\x6f\x1b\x5f\xbc\x6d\x7c\xf1\xb6\x71\x15\xad\x5c\xe3\xa9\x3a\x2d\x8a\xfa\x64\x5c\x95\xdd\x79\x1b\xa5\x0b\xfe\x1a\xbd\xed\x83\xda\x75\x6d\xa0\x5e\x1c\xe7\xe4\x74\xcd\xc0\xee\xb8\xc2\xe9\xc2\xbe\x46\x57\xbb\x80\x76\x5e\xa1\xd0\x22\xaf\x49\x96\xf3\xf2\xf8\xd5\x79\x29\x08\x1d\x5f\xa9\x24\x3b\xca\xa6\xd0\xad\xe4\x19\x59\xae\xf3\xd5\x92\xec\x56\x45\x74\x7c\x5c\x9d\x90\x33\x7e\xfc\x92\xd3\x5a\x69\xf6\xe3\x1b\x71\x3b\x8e\x5b\x7c\x45\x77\x30\x3b\x54\x91\x48\x44\x99\xf5\xca\xf1\x51\x51\x2c\xea\xec\x6c\x4d\x25\x3b\xee\x8b\x22\xf8\xf9\x7d\xe7\x20\x64\xf7\x95\xe4\x72\x70\x3d\xb6\x30\x6e\x9d\xe7\x7c\xf1\x1c\xf3\xc5\x73\xcc\x0d\x79\x8e\xc1\x07\x5f\x1c\x32\x7d\xf1\x9e\xf3\xc5\x7b\xce\x17\xef\x39\x5f\xbc\xe7\xdc\xa2\xf7\x9c\xa3\x92\xf3\x53\x72\xb6\xb2\x6d\xdd\xba\xd0\x91\x2a\xce\x79\xcd\xd5\x63\x7b\x67\x8e\x77\xa2\x27\xc7\x25\x17\xed\xb5\x12\xc6\xcf\xb4\x21\xd4\x92\x8b\xb9\xfa\xb0\x57\xa4\x73\x0d\x43\x25\xc8\xdf\x36\xde\x3a\x0c\x56\x09\xea\xc3\xa6\x28\xd4\xff\x8f\x72\xfe\xa1\x12\xed\xf7\x81\xa9\xcb\x6e\x20\x83\x43\x05\x7c\x6e\xbf\x9b\x7b\xc0\x2a\xe2\x3b\xd3\x22\xdd\xb2\xfb\xfa\x2a\x86\xd3\x37\xf6\xb8\x05\xd3\x40\xfc\xfa\xeb\xe6\xb7\xbd\xa6\xf3\x4d\x1b\xd3\x35\x4b\xae\xa2\x1d\xb3\xe4\x96\x69\x1d\x1c\xfd\xae\x6b\xdf\x77\x5a\x34\x53\x6d\x36\x31\xb3\xc6\x46\xf8\xac\xe9\xf5\x7e\xdb\x7f\x6d\x3e\xf3\x52\x8e\xb5\xb5\xe7\x2a\x3b\x60\xbd\xb1\x3a\x7e\x6d\x24\x81\xad\xe9\x44\x7b\xc3\x45\x97\xec\xa3\x60\x5e\x72\x76\x4e\xb9\xd3\x39\xed\xf6\x78\xa6\x01\xb5\x37\xca\x3a\x4e\x91\xc1\x7d\x9d\xac\x07\xc8\x5c\x11\x9b\x01\xe8\xde\xaf\xea\xd6\x6b\x9e\xa4\x16\x8c\xbf\xb1\x9d\x7c\xab\x1f\xad\x76\xa2\xb4\xb1\xdb\x6f\x00\x94\x1d\xef\xa4\xf4\xef\x34\x76\x6c\x52\x2a\xea\x32\x35\x5a\x04\xec\xaf\xf4\xb5\x63\xd1\x59\xfd\x99\xd9\x51\xd2\x74\xdb\x8c\x89\xfc\x73\x47\x1b\x89\xb6\x6e\x13\x45\xb6\xa8\x79\x29\x17\x30\x2e\x5b\xb4\xb1\xe6\x29\x83\x73\xbb\xe4\x77\x70\xa1\x3b\x31\xbf\x98\x81\xa5\xf9\xb9\x6c\x6c\xab\xaa\x4f\x6d\xd7\xb9\xb1\x13\xa6\xe2\x8c\xd9\xdf\xcb\xe6\xf2\xf7\x63\xdd\x0f\x75\xc3\x9b\x94\x9c\xa8\x59\x9f\x13\x7a\xa2\xfb\xaa\x9c\x51\x33\x50\x58\x7f\xb8\x5f\x83\x8a\x92\x05\x9f\xab\x66\xbf\xe3\xf5\xa3\x92\x93\x17\xc2\xa1\xf9\xf6\x6a\x7c\x3f\xb1\xa1\xa4\x99\xaa\xe8\x6f\x12\xde\x4b\x52\x67\x85\x73\x8b\x4c\x7e\x2a\x75\xca\x4d\x37\x5e\x7c\xe5\xb0\x75\x13\xdc\x4b\x6c\xeb\xb8\xc9\xbd\x89\xa5\xfa\x78\xe8\x52\x18\xb8\xa7\xeb\xed\xf9\xb8\x72\x49\xc0\x70\x95\x25\x57\x09\x63\xdf\x50\x9d\xfc\xad\x68\x4d\x01\x76\x28\x4c\x7e\x6b\xda\x35\xec\xd6\x47\xb9\xf6\x1a\x5d\xd1\xa2\xe4\xc6\x37\x3e\x07\xed\xbb\xd6\xb2\xf8\x38\x93\xea\x85\x8c\xfd\x58\x94\x55\x0d\x88\x4c\xac\x75\x5b\x1b\xfc\xff\x2a\x93\x5e\x29\x18\x5d\xdc\xb7\x09\x13\x05\xea\x8c\x94\x3c\xaf\x5f\x65\xff\xe2\x33\x03\xa9\x87\x7b\x9d\xe1\x91\x46\x4f\x9b\x1b\xdc\x73\x3e\xac\xa8\x28\x8b\x8f\x26\x63\x59\x7c\x9c\xab\x9e\xdf\x6b\x7e\x36\xf2\xf2\xb8\x2c\x3e\xfe\x3f\x5a\x04\x98\x9c\xdb\xc9\x03\x4b\xe2\xf6\xa1\x51\x96\xef\x1b\xaf\xfe\x59\x6e\x4a\xc8\x9f\xa6\x94\xaa\xb3\x31\x8f\x7b\x4a\x2e\x6c\x66\x72\xd1\x64\x26\x17\x9d\xcc\x7a\x58\x0e\x8c\x75\x76\x5d\x81\x75\x9b\x3d\xd3\x20\xa0\xda\x4e\x6e\x1a\xa0\xe6\x8c\xa6\x37\xaa\xf6\xb6\xc2\x7e\x22\xb9\x70\x09\xd3\xe2\xea\x9b\xb6\x59\x0e\xaa\xef\x29\x00\xf7\xdc\x21\x01\x0f\x6d\x99\x59\x53\xf8\x21\xe8\x15\xca\xf2\x6e\xa1\xa9\x94\xe6\xb6\x0f\xad\x60\x71\x8d\xf8\x35\x77\xdd\x1b\xf4\xaf\xa6\xae\xd2\x8a\xfe\xfd\x52\xd9\x20\xcd\xaa\xef\x17\xe7\xd5\x89\xc3\xaf\xc5\xc7\xc6\xfe\xb8\x43\x32\xa6\xab\xda\xf0\x71\x43\x21\x0f\x9d\x2c\x53\xed\x46\xbb\xbd\x79\x2b\xe1\x4a\x2e\x6a\x21\xfe\xd5\xa9\xda\x88\xad\x86\x40\x56\xaa\x75\x32\x35\xb2\x5c\x4d\xca\xe7\xe5\xdf\xbb\x99\x2e\x3a\xd3\xbd\x33\xdd\x81\xde\xd6\xc1\xcc\x3c\xc4\x95\xed\x6f\x96\x7e\xee\x93\x5b\x77\x4a\xd0\xf9\xe4\x5a\xa5\x8d\x9b\x4b\xc2\x90\x0d\x70\xe3\x96\xdd\xd6\x2c\xdd\xb4\xc6\xec\x7e\xd3\x3f\x37\xd5\x5a\xed\x6f\x39\xa1\xc1\x42\x07\xdf\x2d\x9d\x6b\x42\xfa\xd1\xa0\x6e\x5f\x76\xc9\x45\x04\xb8\xef\x7e\x6a\xf0\x0f\x54\x83\xcd\x15\x6b\x85\xbc\xfb\x87\x6e\xfd\xf6\xfa\xe8\xc3\x87\xe0\xe3\x09\xa9\xf7\x2a\xf0\xaf\x3b\xb6\x81\xff\x72\x9e\x31\xe9\xc7\xb3\xda\xac\x10\x3f\x25\x59\x0e\x2e\x9a\x37\xb4\xa4\xaa\xd5\x6b\xd2\x42\xc8\xe6\xdd\xe9\xf6\xef\xfe\xe1\x96\x6d\x3c\x18\x9b\xae\x5d\x82\xd5\x23\xb4\xdc\xef\xa0\x1c\xdc\x6f\xd1\xa2\xb9\xd8\xce\x90\x2b\xb4\x04\x1e\xb4\x59\x7b\x53\x76\x6b\xdc\x72\x95\xaf\xfa\x69\x57\xe7\x2a\xeb\x00\xe0\xc6\x98\x4a\x03\xfc\xeb\x0a\x36\x1d\x96\xea\xd6\xd9\x66\xe9\x33\xd4\xeb\x01\x12\xbe\x3d\x86\xea\xb3\xb2\xcb\x58\xb2\x71\x43\x2c\x63\x3b\x37\xc8\x6c\x2e\x3f\x69\x14\xac\x65\xa7\x5f\x35\xd6\xfa\xdc\xb4\xec\x52\x6a\x43\x3e\xb2\x49\x2d\x3b\xbd\x6e\xd9\xc9\x15\x56\x2e\x07\x99\x47\x86\xbd\x66\x76\xd9\x62\x5d\x65\x57\xe0\x8b\x8b\xfd\x3e\xaf\xd9\xfe\x69\xb6\x30\xba\xe4\x00\x03\xda\x7c\x3d\x9e\x38\x1b\xe0\x85\xb3\xab\xf3\x80\xda\x77\x6c\x09\xff\xf0\x70\x95\x26\x7b\xaa\xc2\xae\x13\x59\x5f\xef\xdf\x8d\x71\x1b\xc5\xee\xa5\x36\x37\xf0\x81\x2f\x96\xea\x75\x78\xfe\xce\x2a\x79\x8d\x5a\x27\x95\xf0\xbd\xaa\x5d\x19\x66\x79\x5d\x80\xea\x9f\xe7\xa4\x6c\xd4\xbe\x4a\x2b\x77\x26\x72\xe9\x22\xd3\xc6\x4d\xf4\x9a\x64\x50\x8f\x5b\xbb\x8c\xdd\x7a\x41\x57\x82\xd2\xac\x46\x7a\x8b\x90\x83\x36\x43\xf1\xb1\x79\xbd\xa1\x63\x52\xae\x5e\x45\x36\x6a\x08\x50\x56\x8b\xb8\x8e\x97\xd9\xb5\xb2\x5b\x15\x40\x90\xb2\x29\xd5\x95\x1b\x8e\x07\x1f\xa3\xd5\x1a\x79\x62\x81\xd1\xf3\x52\x0e\x41\x0b\xaf\x01\x54\x29\x6a\x71\x55\x45\x4b\x2e\x33\xd5\x1b\xab\x45\x28\x50\x66\xe7\x0c\x14\x65\x66\xad\xed\xb5\x80\xe4\x12\xc7\x59\xd3\xac\x5b\xca\xb4\x95\x48\x15\xd8\x61\xc7\x87\x1a\xfd\x6a\x89\xe1\x60\xad\xe6\xa7\x67\x0e\xe8\x4e\x55\xed\xbb\x14\x2b\x93\xe7\x66\xb9\x62\xdd\xcc\x9a\x07\x43\x2e\x90\xf6\xc9\x3c\xec\xd8\x88\x91\xf8\x51\x46\x2a\xec\x1a\xbb\xf8\xa8\xad\x1f\x58\x7c\xbb\x40\xde\xc0\xd6\x0a\x4b\x53\x6d\x23\xab\x1a\xad\xde\x1d\x96\x81\x35\x46\xb5\xb2\xba\x70\x1f\xa8\xeb\x82\x7f\x39\x54\xe4\xd0\x7b\x8a\x6e\xb7\x7f\xb5\x41\x32\xb5\xcd\xd9\x1f\x18\xf5\x20\xca\xed\x77\x75\x92\x89\x7a\xe2\x1a\x8f\xd1\xe4\xa7\xea\x19\xf5\x36\x2b\x35\x93\xb4\x28\x6b\x63\x83\xb0\x5c\x02\x02\x58\x26\xd4\x3e\x6b\x3d\x58\x69\x83\x8f\x07\x7a\xee\x3a\x2b\xce\x26\x53\x83\x93\x26\x8f\x66\x96\xae\xb0\xd3\xe8\x28\x95\xac\x50\x62\xdd\x69\xeb\xd6\xb4\xda\x69\x46\xf3\x64\xb4\x4b\x1a\x3d\x04\xb4\xcb\x00\x83\x83\xfe\x83\xd0\x16\x94\xbb\x05\xb3\xa1\x07\x52\xb5\xeb\xd0\xc8\x9a\xc6\x5c\x8e\x2f\xa5\xcd\x6e\x8a\xb3\x93\xd2\x65\x81\xde\xf2\x7d\xc0\x07\x51\x23\x04\xe9\x30\xad\x5d\x4e\xed\x92\xdb\x91\xec\xb2\xda\x76\xa2\x32\x3b\x95\xdb\x38\xf1\x1e\x3c\x32\xdd\xc6\x8b\x37\xbe\xb2\x1b\x6f\xd3\xaa\x35\x0e\xbc\x4d\x8e\x89\x2b\xa7\x8f\x4b\x2e\xb0\xe1\x4e\xed\xef\x91\x9f\x9e\x19\x87\x85\x33\x99\x5a\x9b\xc4\x61\x3f\xdf\x06\xa4\x95\x39\x8d\xca\x76\xac\x95\xb5\xfe\xf1\xd7\xac\x63\xf4\x68\x22\x73\x4d\x67\xe0\x58\xfb\x54\x86\x07\xfa\xd7\x5f\x54\x69\xfd\xd1\xea\x75\xda\x5e\xd2\x9b\x63\x73\x86\xd5\x1e\x99\xa9\x98\x41\xc2\xd1\x0f\xf8\x1a\xaf\xe8\x13\xd5\x29\xe5\x05\x6a\x93\x03\x72\x85\x15\x70\x68\xbb\xb7\x8d\x0b\x72\x8b\x89\xa9\x3a\x9a\x32\xc6\x17\x14\x9c\x99\x7e\x6a\xf8\x76\x4e\x8b\x9c\x12\xf5\x76\xac\x9a\x4e\xa7\x06\xc9\xf6\xef\xbc\xaa\x49\xad\xf6\xa4\xd5\x97\x3e\x25\xf8\x4e\x53\xc8\x2b\x99\x34\x99\x5a\xd3\xf6\xb3\x75\x3d\x70\x46\x6e\xc4\xdf\x79\x43\x28\x1d\x4f\xe7\xcd\xfd\x81\x5f\xb3\xc5\xe2\x25\xa7\x3c\xfb\xa0\x8e\x59\xab\x11\x6f\x73\xa3\xf9\x27\x39\xbf\xa8\x7f\xee\xfa\x3e\x97\x62\xa3\x89\x9e\x33\x52\x13\x75\x2a\xe3\xb8\x49\x94\x71\x5d\xcb\x71\x12\x25\xdc\x74\x7d\x14\x25\x03\x76\x45\x3a\x1e\x5c\x35\x52\x2a\xcb\x6a\x52\x1a\x55\xbc\x06\x1a\xd7\x76\xdb\xac\x36\xfc\xac\x2e\xa4\xcf\x6d\xd1\xc6\x05\xab\x1e\xef\x4b\xf0\xeb\x49\xb1\xe0\xea\xec\x48\x15\x37\xf9\x86\x9c\xb0\xae\xb6\x74\x0c\x89\x03\x5d\xea\x6f\x6b\xb7\x38\xc9\x2a\x73\xb5\xe3\x11\xad\xb3\x0f\xcd\x89\x4f\x93\x4e\x54\xf4\x73\xb5\x93\x9f\x9f\x2f\x16\x16\x35\xa3\xee\x04\xb5\x01\x31\x6d\x27\x39\xaf\x47\x1d\x0b\xf6\xb3\x19\xfd\x91\x0f\x79\x1a\x1c\x75\xe1\x56\xe4\x2d\x80\xd6\x97\xb3\x1b\xdb\x75\x4e\xd7\xe8\x38\x26\x67\x47\x11\xb5\x75\xd6\x1a\x1f\xc6\x3d\xfa\x46\x69\x3c\x74\x13\xe7\xcd\xdd\x4c\x5f\x5f\xcf\x72\xbd\x1b\xff\xed\xf2\x68\x79\xc6\xb5\x50\x6e\x15\xb5\xab\xde\xbd\x19\x92\xf1\x1d\x67\xff\x4e\xd3\xc7\xe9\xde\xf5\x14\xbb\x32\xfa\xd6\x2d\xc7\xe0\xf0\x17\x8c\x37\x49\x97\xb3\xee\x85\x18\x17\xa8\x00\x13\x77\x0c\xba\xa9\xdd\x51\x6b\x86\xfd\xc0\xc9\x72\xd9\xd6\xd2\xf7\xd1\xbf\x0e\xf6\x5a\xb8\x97\x5b\xd0\xeb\x33\x4e\x3e\x8c\x71\x55\x3f\xdb\x3a\x7a\x1d\xf7\x5f\x6c\x9a\xa8\x20\x38\x7e\x88\xdd\xe8\xb5\x14\x8b\xbf\x90\xec\x26\x81\x35\x2a\xb2\xb6\xa5\x59\x35\x0a\x23\x34\xdb\x1d\xfa\xab\xd3\xec\x0a\xec\xb5\x70\x37\xd0\xec\xe3\x45\x46\xdf\xaf\x25\x57\x95\xc3\x39\xa9\xb3\xf4\x52\xe4\x2a\xa5\xeb\x54\xd8\x44\x76\x1d\x57\x9a\xc8\x6e\x93\x1d\xb0\x1b\x9b\xaa\x3d\x01\x3e\xca\xb3\x53\x52\x73\xf6\xd4\x3e\x95\x1a\xf3\x34\xeb\x66\x9c\x50\xfd\x92\x4a\x6b\xe8\xe6\x42\x58\x56\x3d\xe3\x44\x0c\xf8\x13\xc7\xe3\xfe\xc4\xc7\x5d\x1a\x67\x95\xae\x30\x2b\x72\x4d\x4e\x8e\x77\xe1\x95\xb4\x0e\x8d\xd9\xa4\x6f\xf9\xbb\x2c\x77\x4a\x75\x13\x06\x8b\x7c\x77\x5e\x12\xb3\x27\xb5\x52\xca\xa6\x0d\x16\x7c\x42\xaa\x2c\x7f\x37\x54\x4c\xa7\x74\x7b\xf6\xcb\x19\x23\x35\x5f\xd7\xbf\xc1\x1c\x07\x0e\xfa\xec\x6e\x65\x83\xff\x35\x8e\x79\xdb\x3c\xab\xae\x79\x2f\x3a\xe9\x2b\x2e\x81\xdb\xa4\x65\x57\xac\x95\x24\xaf\x16\xa4\xe6\xe6\xc0\xa4\xe2\x4f\xf3\x7a\x32\xd1\x5b\xa1\x24\x67\xc5\xe9\x64\x0a\xee\x01\x0c\x1e\x00\x24\x7f\x98\xc5\x2a\x82\x53\xb7\x13\xda\x64\x58\x63\x8c\x13\x34\x56\x2d\xba\x84\x04\xda\x8c\x23\x1a\xc6\xbe\x26\xa2\xbe\xe6\x32\x4f\xb3\x9c\x19\x25\xbf\xe9\xc9\x74\x4c\xea\xaf\x02\x51\xd1\xdb\x00\x51\x6c\xd7\x29\xaf\x62\x86\x8b\xb6\xe2\xe8\xb3\x3a\x26\xbd\xfa\x35\xfa\x39\x71\x3c\x99\x3a\xfd\x13\x65\x71\xba\xaf\x2f\x11\xe8\xfb\x03\xed\xd5\x81\xde\xad\x01\x7b\x61\xc0\xc5\x4e\x5d\xec\x5e\x96\x19\x9e\xdb\x5f\x65\x51\x37\x1b\x57\x3c\xb6\xdf\x67\xc7\x9e\x38\x31\x93\xd2\x08\x73\x39\x53\x51\xf3\xd3\x59\x87\x97\x5c\x78\xdd\x99\xc7\x1c\x70\xa8\x23\x43\x95\xdc\xe5\x1e\xa0\x37\xf1\xd5\x01\x88\x4e\x5e\x0e\x25\x37\xce\x9b\x55\x96\x15\x1e\xb6\xd9\x5a\xc7\xcd\x2a\xdf\x89\x73\xe0\x77\xf3\x94\x73\x7d\xea\xe9\x53\x50\x4b\x45\x7b\x8d\xe4\x50\xc6\xb7\x1d\x39\x72\x1f\xec\x9d\x5d\xcc\xc0\x50\xec\x74\xc5\xd6\xa5\x24\x2a\x07\x14\x9c\x01\xb8\x9a\x89\xd4\xc6\xe5\x88\x79\x75\xac\xf2\x8b\xa2\x3c\x5d\xc9\x99\xca\x19\x61\x1f\x8c\xcf\x10\x60\x3b\x2a\x03\x3d\x4a\x5b\x33\x4d\x81\xf5\xe4\xdd\xc9\x79\x39\xdb\x72\x6c\xae\x38\xc8\xeb\x40\x0d\x3d\xc6\x18\x79\x71\xdd\x41\x92\x94\xd4\xfd\x48\xad\x05\x18\xd7\xc3\xe6\x11\x76\x57\x8d\x58\xd9\xf5\x33\x3a\x45\x9f\x88\x06\xf4\x82\x2d\xf0\x3c\x3a\xe7\xee\x83\xaf\x46\x52\x56\x41\x58\x47\xd4\x96\x69\x57\x73\x34\xde\xa8\x1b\x86\x5d\xcd\x73\xa1\x93\xff\xbe\x9a\xb2\xd4\x29\xaf\x7b\x09\x97\xd3\x69\x27\xc6\xfd\x72\xd4\x5c\xab\xe4\x4e\x47\x57\xff\x2b\xd8\x5f\xab\xed\x0d\x8e\x52\x3b\x87\x75\xb6\x7a\xae\x46\x8f\x59\xf5\x37\xb2\xc8\x98\x25\x48\x03\x7c\x3a\xb0\x77\x7b\x45\x3a\x5f\x14\x39\xef\x41\x75\x9b\x3c\xa0\xfa\xef\xee\xfc\x7c\x4d\xab\x4d\xd2\x64\xa0\xe6\x1b\x9c\xe6\xaf\xf6\xc4\x69\x88\x71\x1d\x9e\x6b\x27\x3c\xed\x5b\xf3\xff\x08\x21\x1c\x19\xd9\xfa\xe0\x84\x10\xee\xd9\xce\xb8\xb8\xdd\x44\x75\x72\xc5\xb7\x96\xdc\xd4\x4d\xd5\xb2\x28\x6a\xbb\xe7\x9f\x0d\xac\x23\xbc\xa1\x75\x84\x41\x77\x77\xc1\x64\x22\x3b\x19\x9b\xd6\xf6\xdd\x88\xef\xb8\x28\x7f\xaf\x30\xaa\xb6\x85\x79\x65\xcf\x81\x1e\xd9\x29\xa7\xd2\xcb\xf3\xb6\x4d\xd3\xf6\x34\x43\xf6\x73\x5f\x85\xce\x8a\x54\xdd\x7c\x50\x8a\x2f\x38\x04\x5f\x75\x0e\x63\x95\x59\xbc\x4e\x4c\x63\x9f\xed\x56\xf5\xc6\x2b\x4f\x09\xbf\x37\x44\x60\x1c\xe1\x9b\xad\xd7\x07\xb2\x33\x0f\xe4\x4c\x9f\xcd\x86\x3d\xe6\xdb\x8c\xea\x36\xac\xca\xa9\xfa\xaf\xef\x51\x0f\xbb\xcf\xdf\x76\x7d\xda\x16\xee\x22\xf9\xeb\xaf\xc1\x10\x8e\xc1\x37\xbd\xe8\xe1\x0b\xd8\x39\xe3\x17\x5d\xfd\xd0\x8e\x89\xa2\xdc\xb9\x43\xe6\x9a\x0c\x3a\x05\x1d\x39\x6e\x2f\x5a\x6f\x29\xcf\x1f\x2d\x16\x12\xe8\xd8\xb6\x7d\x37\xd3\x64\x68\x4b\xcc\x1f\x5d\x82\xdb\x35\xa6\xc9\xb7\x66\x85\x69\x73\xac\xae\x2f\xd5\xe6\x7f\x9b\x41\x7e\xf6\x93\xcd\x2d\x7b\x27\xc7\xff\xf0\x8e\xae\xec\x5e\x77\x6c\x33\x3a\xb1\xed\xc6\x88\xbe\x6a\x50\xd4\xed\xfd\x72\x7d\x07\xbe\x81\x66\x6e\x59\xc3\x2e\x15\xec\x77\xce\x18\x55\x23\xb5\x37\x65\xed\x4b\x79\xeb\x15\x8b\xb9\xb5\xed\x40\x6f\x6f\xd4\x9b\x8e\x59\xf1\x39\xed\x08\x27\x6d\x4d\xe5\xa5\x6e\x79\x73\x66\xa9\x05\x62\xf7\xd8\xb2\xcb\xf1\x0e\xfd\xab\x8e\xb6\x70\x66\xc0\xfd\x0d\x37\xd1\x91\xd9\xb9\x5b\x4b\x46\x26\xcf\x20\x15\x05\xa3\x54\xb4\xb2\x53\x1a\x34\xbc\xe4\x66\xcb\xc9\x29\x77\x29\x21\x98\x9b\x98\xff\x94\xed\xd4\xaf\x46\xf6\x53\xed\x99\xb3\x79\x5c\x01\x5c\x45\xa1\xc5\x6f\xb8\x25\x97\x86\x1b\xb9\x34\x1c\xe1\x52\x17\xf9\xa1\x65\x43\x77\x76\x3a\xb6\x47\x96\xed\xf9\x65\x77\x85\xdd\xd9\xfd\x95\xb0\x54\x9e\x79\x2f\x61\x78\x3f\xb8\xcd\xde\xc6\x75\x46\xfe\x43\xc6\x3f\x7e\x5b\x5c\x80\x43\xbd\x99\xb0\x25\x6b\x1e\x74\x34\x05\xeb\xca\x1c\x1c\xba\x35\x7f\xe3\x0c\xc6\xc5\xbe\x93\xa2\x6e\xb9\x39\x9f\x1a\xd3\x0f\x01\x6e\xbb\xb0\xec\xe4\x5f\x76\xf3\x37\x77\x7b\x70\xa3\x7a\xee\x77\xc6\x59\xdf\xa4\x5f\x2e\x0a\xc2\xd4\xc3\x94\x2e\x02\xbf\xfe\xba\xdb\xca\x37\x8e\x2d\x72\x5d\xc8\xad\xdc\x11\x68\x6a\x2e\xdd\x7c\x57\x61\xe8\xe9\xf5\x9b\xbb\x1f\xad\x5a\xa3\x5e\x4e\x7c\xbb\xfc\xce\x90\x86\x62\x0f\xa7\x3a\xcb\xb0\x33\xb0\xb7\x37\xed\xc9\xbb\x5b\xa8\xdd\xd0\xa7\x5d\x0d\x5d\xbe\x05\xfb\xea\x76\xd9\xb5\x14\x22\x77\x05\xe1\x70\xab\xbb\x0c\x35\x64\xb8\x6f\x7f\xf4\x8f\x63\xf7\xfb\xc3\xd8\x66\x68\xe9\x6f\xdf\xf9\xdd\xa6\x2f\x48\xca\xa5\xf6\xed\x68\xde\xcd\x38\x9b\x1f\xce\xe4\x01\xd6\x49\xf3\xb5\x62\x7c\xd2\x5d\xbd\x7d\xb5\xa3\x14\xfd\xa7\x1a\xaa\x0f\x72\x2d\x47\x6a\xae\x96\xc4\x66\x97\xaa\xd1\x7c\x87\x96\x47\x1b\xe4\x5c\xb4\xa5\x9c\x8b\x36\xca\xb9\x68\x40\xce\x35\xba\xa6\x93\xab\x89\x73\x33\x56\xf5\x72\xe1\x66\x52\xdf\x6b\x67\xb5\x68\x70\x56\x53\xfe\x82\xd5\x8a\x63\xec\x55\xb5\x29\x3d\x03\x6f\xf6\x54\x8f\xf6\x66\x60\x4f\x37\x5c\xfe\x6a\x1a\x27\x3f\x54\x23\x54\xac\xb5\x5e\xf7\xb6\xab\x45\x90\xba\x2e\xab\xdd\xe7\xc5\xad\x56\x34\xba\x47\x2b\x8a\xc8\x8d\x2c\x3d\xf6\x58\xf6\x61\x6f\x78\x0f\xda\x59\x25\x5c\xd5\x64\xca\x64\x3a\x69\x17\x16\x1f\x4b\x72\x76\xa6\x3c\x15\x34\x10\xa7\x2b\x03\xbf\xdf\x5d\x20\xea\xc1\x07\xbf\x37\xf7\xdd\x14\x9f\x2d\x88\x64\x6f\x09\xe8\xbc\xac\x8a\x72\x1f\xec\x99\xfa\xf6\x36\x4d\x4a\xce\x09\xc0\x6c\x8b\x65\xd7\x95\x36\xf5\xae\x6a\xc2\x65\xc3\x96\x5e\x07\x0f\x8a\xbc\x24\x1e\x36\x74\xaf\xb3\xfb\xef\x2c\xd0\x9a\x55\x88\x9b\x61\x47\x5a\x7d\x67\x74\xb8\x45\xcd\xcb\x57\x1f\xde\x19\x4c\x54\x5d\x2d\xae\x45\xf4\x74\x70\xc9\xd8\x28\xb4\x03\x8b\xad\xb7\x1d\x17\x38\xe6\x12\xd5\xc1\x9d\xcb\x6d\x76\xbb\xde\xdc\x6d\xee\xe4\xdd\x7d\x3b\x6d\x0c\x4e\xcc\x59\x56\x9d\x2d\xc8\xd2\x08\xa0\x3d\x03\x74\xaf\xcd\xd0\x98\x28\x34\x67\x5d\x06\xd1\x57\xb5\xfe\xd4\x31\x00\x68\x87\xe7\x5a\x40\xe4\x74\xbb\x13\x08\xed\x6d\xed\x4e\xcb\x58\x57\x07\xa1\x25\xa7\x32\xd4\xd9\xae\x84\xae\xd9\x1f\x6a\x2d\x81\xee\xd2\x9e\x6d\x8c\xd9\x8d\x96\x6e\x7c\xc4\xed\x50\x56\x4e\xe4\xda\x24\x9f\xde\xa8\xdb\x01\x84\x36\x88\xa7\x07\x44\xef\xea\x5d\x0b\xc8\x56\x62\x79\x0b\x38\x46\x99\xfc\x03\xc6\xc3\xb4\xe1\x1a\xe4\x74\xbd\x91\x34\x8a\xec\xff\xc2\x9e\xb7\x1b\x2e\xb7\xde\x75\x25\x95\x5e\x88\xad\xad\xe1\xb9\x5d\x2f\x18\x9f\xee\x86\xb4\x82\x71\xd9\xf3\x3b\xfd\xbb\x0b\x3b\x62\x71\x76\xa7\x7f\x7f\xe1\x5a\x80\xcc\x1d\x86\x9d\x61\xdc\x19\x3c\x9b\xdb\x01\x5c\x5a\x14\x8b\xd9\x9d\x35\x67\x76\xd7\x80\xd9\x3d\xe1\xbd\xe6\x24\xb2\x72\x68\x7b\x53\xf0\x9e\x98\x93\xe6\x5d\xf9\x62\xf2\x66\x8f\x93\x4a\x2d\x15\xe4\xdf\x07\x59\xde\xfc\x2c\xce\x6b\x27\xda\x7e\x2e\xb2\x9c\x93\x72\xef\xed\xf4\xce\xa5\xa3\xad\x38\xc6\x9c\x8d\x3e\xd2\x08\xab\x3d\xb5\xb4\xdc\x5b\x99\x94\xe1\x3c\x00\xf7\xc0\x04\x81\xfb\xfa\xb5\x4a\xf5\xcf\xb2\x9e\x04\xd3\xe9\x6c\x98\x3a\x76\x5d\x7b\xe6\x4a\xfb\xcb\xaa\x57\x55\xa9\x35\xbe\xe9\x5a\x82\xb9\xd9\x6a\xfa\x34\x04\x47\x68\x01\x05\x10\x0e\x0e\xab\x45\xb7\x42\xb6\x7a\xfd\x31\x55\x46\x21\x34\xe2\x0f\xae\x61\xba\xdd\x79\x9f\xd1\x33\x73\x9b\x7c\x31\x73\xfb\xa7\x31\x73\x6b\x40\x55\xe7\xa7\xdf\x2e\xc7\x8d\x68\x06\x3b\x1a\x84\xed\xc3\xbf\x96\xd9\xdb\x2e\xa8\x5d\x2d\xd4\x1a\x28\xa7\xd9\xf8\x40\x7b\xc1\x8e\x16\x24\xbb\xd0\xaf\x65\xff\xd6\x05\xb4\xab\x81\x5a\x0b\x83\x5c\xac\x19\x5b\x2f\xd9\xb1\xb3\x7d\xf8\xd7\x32\x80\xdb\x05\xb5\xab\x91\xda\xcf\x62\xb3\xd9\xbf\x01\x9b\xcd\xfe\xf5\x6c\x36\x07\x9f\xd1\x66\x73\x70\x53\x36\x9b\x83\x1b\xb0\xd9\x1c\x7e\x46\x1b\xc6\xe1\x4d\xd9\x30\x0e\x6f\xc0\x86\x71\x74\x1b\x36\x8c\xe3\xcf\x6f\xc3\xf8\xf6\xac\xff\x7e\x6e\x53\xc9\xcd\x21\xd0\xe7\xb4\x30\x8c\x3f\xbf\x3d\x66\xe4\x5d\xd9\x8a\xf1\x17\x43\xc6\x5f\x0c\x19\xdf\xb0\x21\xe3\x2f\x76\x8c\xbf\xd8\x31\xfe\x62\xc7\xf8\x8b\x1d\xe3\x2f\x76\x8c\x6f\xc1\x8e\xf1\x7a\xfb\xc5\x7a\x96\x55\xca\xee\xe3\xe6\xa6\xc7\x0b\x61\x94\xb5\xde\x1d\x26\x60\x0d\x8d\x64\x79\xcd\xcb\xb3\x62\xa1\x36\x8b\x7e\xd0\x1e\xf6\xd4\x1c\xdd\xba\x10\x1e\xcc\x31\x21\x33\x90\x3a\x6e\xf1\x09\x38\x04\xf7\x89\xb5\xb4\xf6\x3e\x05\x87\x20\x05\x0f\xc0\x7b\xe2\xb8\xb0\x76\x66\x82\x9e\x79\xac\xf7\x04\xdc\x97\x85\xee\x01\x6d\x70\x4c\x19\x42\x51\xf7\xa7\xb8\xac\xfd\x75\xc7\x16\xb3\x8e\x5a\xb5\x38\x9b\xdb\xeb\x50\xfa\xda\xee\x12\x3c\x04\xb8\x01\x64\xaf\xf7\xf4\x8c\x90\xaa\xb8\x09\xcf\xeb\x72\xd9\xf5\x17\x2d\x63\x24\xb5\xa9\x1f\xc6\x0c\xeb\xa7\x4f\xc6\x1d\xb5\x01\xf8\xea\xfc\xf4\x85\x78\xca\xaa\x1e\x4c\x1b\x3d\x59\x64\xf9\xfb\x6a\x06\x32\x56\x75\x60\x67\xac\x1a\xb7\x33\x9a\xf5\x8d\x8c\x36\x26\x87\x9b\xd6\x2a\xb0\x6f\x32\x66\x9c\xa8\xeb\x8b\x96\x9d\x56\xc9\xf9\xe7\x57\x75\x04\xcb\xd9\x2b\x3b\x73\xf6\x9a\xb8\x9a\x67\x52\x97\x5c\x79\x6e\xbf\x4e\xab\x65\x23\x24\x04\x70\x08\x9a\x76\xb6\xb6\xa5\xf4\x74\x6a\xee\xde\xc9\xea\xde\xc8\x4c\x73\x1d\xfd\xb6\x6b\xdf\xb6\xb5\xb5\x6c\x06\xbc\x2d\x3c\x05\xf7\x76\x45\xc7\x91\x9d\x77\xd7\xa0\x43\xe7\xb9\x05\x74\xe8\x49\x76\x05\x1d\x3a\x7a\x13\x3a\xda\xc2\x5b\xa3\x83\x54\x94\xe7\x2c\xcb\xdf\x75\x18\xaa\x8d\x75\x98\xda\xfa\x08\x9f\x2f\xc1\x03\x90\xce\x1d\x8b\xad\x15\x27\x25\x3d\xd1\x38\xaa\x1e\xe5\x86\x78\x3a\x4c\x30\x92\xa5\x65\x88\x56\x70\xb4\x83\x5a\x35\xb6\xda\xda\xf8\x67\xb2\x40\x27\xbe\xed\xf5\x50\xbc\x9b\x7f\xd4\xbc\xa3\x6a\xc5\x5a\x03\x8f\xab\xa3\xe6\x3a\xc0\x77\x48\x56\x4d\xd8\x99\x63\x27\xdc\x69\x9e\xb6\x65\xe6\x0c\x68\x73\xe3\xde\x69\xab\xce\x94\x4d\x3b\xc6\x85\x9a\x4a\xac\x92\xd8\xab\xc4\xc1\x99\x53\x89\xd1\x7d\x0f\x3a\x99\x06\x2b\xe9\x1a\x9e\xfa\xdd\x85\xb7\xef\x7e\xcc\x5c\x20\xfb\xee\xc7\xcc\xed\xc3\xbe\xfb\x31\x73\x51\xb0\xdf\x19\xae\xcb\x96\x86\xce\xd5\x99\x89\xb2\x0b\xff\x42\x18\x3a\x71\x09\x68\x28\xdd\xf0\x23\x3d\x2f\x9f\x37\x92\x7f\x95\x22\x4c\xf2\xdc\x89\x5d\x43\x0a\xee\x70\x6d\x22\x88\x46\x63\x57\x8c\xea\x94\x7c\x93\xbd\x75\xc9\xa3\x59\xe5\x74\x46\x7b\x6e\x1d\x05\x34\x36\x96\x6d\x4b\x1b\x3b\xfd\xb3\x4e\xd6\xf6\xb6\xdb\x1a\x64\x74\x08\x4b\x0f\xac\x45\xb1\x6d\x9d\xd4\x19\x7a\xe2\xae\x89\x57\x4f\x8c\x67\xf6\x4e\x95\x9c\x36\x7f\x6d\x6d\x57\xda\xf7\x4b\x95\xeb\xc4\xa0\xb9\x1d\xb9\x30\x9c\xa6\x52\xd4\x47\x63\x55\xbb\xd6\x35\xaa\xec\xbd\x97\x2b\x6a\x36\xed\xbd\x5c\xd1\xa6\x1c\x2b\xbd\x47\xb7\x49\x72\x98\x97\x2b\xae\x60\xec\x5c\x17\x33\x15\x58\x41\xdc\xbe\x19\x50\xca\x60\x83\xfb\x81\x59\xda\x58\xe2\x76\x88\x7c\x3a\x1b\x9a\xcd\x4d\x3e\x87\xe4\xa7\xcd\x45\x2f\xfb\xd0\x43\x0f\x47\x63\x55\x7d\x9c\xfc\x4a\xce\x37\xd2\x5d\xee\x4c\x0f\x1d\x39\xa4\x9f\x67\xb9\xc2\xa0\x6f\x32\x6f\x0d\xe5\x38\xe6\x3a\x2e\x8d\x89\x57\x59\xd9\x29\xb9\xb0\xfe\x23\xae\x7e\x22\x30\x99\x1a\xe0\xbd\x01\xef\x69\x34\x5a\xa5\x52\xb8\xd2\x18\xb2\xbf\x8d\xf9\xcf\xa6\x0d\x7f\x3d\x04\xc8\xc5\x84\xba\xbc\x61\x1f\xaf\x4f\xac\xa9\x57\x87\x6c\x1f\x36\xed\xd7\x3d\x6b\x6d\xc5\x19\xb4\x1f\x0f\xe0\xfd\x38\x6b\xcd\xc1\x65\xae\x31\x38\x55\xd0\xc5\xfe\x71\xf6\xb6\xfb\xba\x42\xa5\xce\x57\x85\x88\x7b\x05\xf9\xd8\x79\x44\x76\xd8\x6b\x5f\xfb\x84\x56\xe7\x52\x86\xda\x9d\xfc\xf7\x9c\x2e\x1f\x74\x72\x32\x6b\x43\xc3\x49\x5b\x15\xec\xb2\xd5\xfb\x40\x8f\x89\xad\x79\xbf\x1d\x63\x47\x20\xbf\xe3\xb5\x8a\x1b\x90\x16\x4d\xbc\x1a\x5c\xc7\x08\xb4\xe5\xd9\xb5\x93\xed\x35\x49\x5c\x57\xf2\xa6\xc5\xc9\x5b\xd7\x78\x59\x3f\xcd\xb1\xf6\xda\xd8\xe9\xeb\xe7\xd1\x93\x61\x43\xfe\x2e\xc2\x74\xe6\xfe\x2c\xf5\xfa\x85\xe8\x63\xa5\x93\x30\x61\x16\x41\xf6\x5a\xaa\x79\x01\x48\x18\x53\x77\x9d\x94\xe0\x68\xf1\xb6\x6c\x1e\x95\x5d\xf1\x7c\x71\x32\x6d\xab\xea\xc9\x55\x25\x6b\x7b\x6c\x36\x69\xac\x2e\xeb\x64\xfb\xb6\xd0\x58\x47\x71\x9a\x28\x19\xe7\xea\x67\xbb\x93\xa9\x86\x3b\x6b\x74\x4f\x23\xf0\x7a\x12\x8f\x69\x72\x70\x24\x4b\xdb\x0b\x4b\x18\x0c\xfc\xa5\x65\x0d\xc0\x5a\xea\x18\x26\xaa\x06\xc0\x1b\xf6\x76\x2d\x71\x75\xc8\xcb\x2d\xf5\xc6\x61\x65\xb3\x6e\x3c\x04\xd9\x81\x1b\xc3\xac\x2d\x9a\xc6\x09\xc7\xd2\x3c\xfc\x1b\x62\x36\xad\x54\x76\x47\x45\xc6\xf5\x06\xa5\x33\x59\xc9\xf4\x19\xf8\x1d\xb0\xe5\x7e\x57\x7f\x9f\x36\x95\xf5\x7c\x73\x18\xbe\x2b\x16\x1f\xf8\xe3\x62\xb1\xc8\xaa\xac\xc8\x3b\x8a\xd3\x4a\xe2\x06\xea\xd4\xcd\xdb\x80\xe5\xad\xf8\xb7\xea\x60\x38\x73\x56\x39\x79\xa3\x0c\x74\x5e\x10\x3f\x7c\x08\x5e\x15\x65\x0d\xd2\xa5\xb2\x90\xa8\x91\x5c\x08\xa0\x5f\x2b\xea\x02\x55\x51\xd6\x93\x76\x7d\x32\x75\xac\x88\x2e\x61\x6b\xcd\xb5\x69\xff\x3f\xf4\x49\xc4\x3f\xc0\x5f\x40\x7e\x00\xfe\x31\x42\x08\x0a\xf6\x9b\x7f\xbc\x75\x9f\x44\xa9\xd1\x5e\x42\x33\x9f\x38\x96\x87\xa4\x18\x62\xcb\xae\xf1\xe2\x86\x66\xee\x1f\x02\xb6\x5c\x79\x59\xa2\x9a\xb6\xb2\x1b\x71\xdf\xc5\x7b\x47\x48\xa9\xfc\xd6\x8e\xfa\x6a\xae\x76\x16\x93\xdd\xcb\x25\x03\x1f\xc8\xdf\x7f\xd5\xf6\x4c\xff\xf1\xe0\xc1\xc0\x9c\x85\x9b\x7e\x1e\x77\x3b\x7a\xac\x7a\xaa\xf3\xa8\xf6\x99\x9f\xfd\x16\x82\x07\x60\x09\x3b\x58\x38\x5e\x45\x43\x03\xe6\xc1\xa1\x04\xdc\x3e\x29\x56\x5d\xb2\xa9\xa3\xa6\x8e\xd3\x92\x93\xf7\x03\x36\xc3\x1c\x5a\x5f\x90\x8b\x67\x5c\xd4\x47\xc5\x4b\xf3\xd0\xc6\x21\xf5\x6e\x9a\xd1\x3d\x1c\x7a\x37\x1a\x1b\x59\x9c\x9d\x90\x61\x42\x5f\x2b\x94\xb2\x8e\x50\xda\x8a\xe4\x07\xa8\xd1\x72\x53\x87\x03\x14\x85\x2a\x4e\xda\x4c\xa3\xce\x08\x38\x0a\xdf\x33\x67\x11\xeb\x8e\x48\xbb\x76\x7e\x75\x7e\xaa\x8d\x60\xf7\x35\xd8\x3e\x14\xe7\x25\xb8\xb2\xf2\x65\x37\x85\x9c\xf2\x9b\x36\x8b\x36\x80\x94\x14\xe7\x82\x7d\xd8\x36\xb1\xe9\x9f\xcb\x53\x93\x25\x78\xd0\xdd\xe7\x93\x12\x51\x8d\xe3\x08\xb5\x34\xc4\xa2\x48\xe1\xa8\x90\x74\xb1\x42\x2c\x4e\xda\x95\x89\xa5\x4f\x1e\x9a\x0b\x33\xc3\x84\x59\xcb\x83\x7f\x2c\x71\xb8\x5b\x0b\xc3\xc4\xa1\x73\xac\x27\x0e\x77\x71\x73\x35\xe2\x18\xda\x3a\xdb\x00\x72\x95\x38\x9a\x26\xde\x20\x71\x34\x2a\x9b\xdd\x22\x5a\x55\xe6\x54\x8a\xdb\xf4\x75\x93\xe3\x4e\x7a\x6d\xc3\xa0\xcb\x76\xee\x52\x63\xb2\x74\x2c\xe8\xaf\x8c\xa3\x9a\x04\x5b\xad\xa2\xdd\xa3\x03\xce\x9b\x7c\xbb\x79\x58\xbd\x21\x6f\xed\x06\xa2\xda\xbb\x73\x52\x52\x27\xe5\xc0\x59\xa3\x82\x15\xfe\xdd\xa1\x4e\xb3\x87\x3b\x50\x67\x93\xd2\xd6\x39\xc8\x0a\xf5\xb3\xd6\x27\xc4\x2a\x1d\x6b\xb6\x90\x79\x06\xf8\xa2\xb3\x59\xd7\x07\xf0\xe6\x1f\x6f\xbb\x9c\xe2\xea\x65\xc0\xec\x65\xcc\xd5\x98\x54\xce\x14\x56\x29\x6a\x53\x69\x6c\xd8\x52\xbd\x33\x31\x63\xdd\x85\xca\xe9\xc2\xaa\x9c\x3e\x50\x19\xff\xa2\x72\xa9\xdf\x2b\xab\xcd\xd5\x7e\x38\x50\xde\x1c\xff\x03\xf7\x7a\x72\xdc\xef\xca\xb1\xde\x37\x94\x7d\xa9\x9d\xbe\xd4\xaa\x2f\xc7\x23\x9d\x71\x67\x5c\x63\xc1\xe2\x3b\x6d\x42\xa3\xef\x00\x53\x46\x6b\x8b\xe3\x8e\x07\x4c\x63\x6d\x43\xc6\x76\x6c\x6d\x7c\x74\xcc\xcc\xe1\xee\xd3\xd9\x13\xd7\xb4\x1c\xee\x3d\x9a\xcd\x6a\xae\xaf\x33\x57\x4d\x86\x36\x6a\xe6\xa8\xe8\xbf\x76\x2a\x68\x62\xdc\x2c\x56\x99\x71\x33\x39\xca\x95\xa5\x1d\x25\xac\x49\x4d\x7a\x3b\x59\xc7\xbd\x4d\xb4\xce\xde\x99\xb6\xd8\xb1\xb2\x77\x66\x6b\x37\xbb\x60\x1d\x10\x73\x19\xd9\x40\x67\xce\x82\x7b\x75\x9d\x6d\x9b\x97\xf3\x8f\x56\x64\xed\xb2\xec\x34\x0f\x0a\xaf\xb8\x2a\x68\xda\xa8\xc4\xaa\xba\xa3\xd1\x97\x84\xfa\xd6\xc6\xa1\x33\x5a\x1d\xf1\xb7\x79\xc2\xb5\x1d\x33\x73\x2e\xb8\x77\x08\xe0\x3c\x49\xda\xdd\xbd\x5d\xda\x0c\xb6\x50\x0b\x7b\x15\x5f\xa3\x42\x23\x09\x06\x67\x10\x5b\x4b\xe7\x49\xe7\xef\x7a\xea\xb6\x7b\x32\x0b\xbd\x7d\xde\x0c\x71\x77\x43\x66\xf8\x14\xd7\xdd\x9a\x19\xc8\x31\xe1\x8b\x99\x3a\x69\x6f\x3d\x15\xe9\x33\xf5\xc3\x43\xb0\x27\x2b\xdf\xeb\x3b\x31\x04\x17\xfb\x80\x2f\x94\xdd\x09\xbe\x70\xec\x4d\x80\xa5\x8a\x5f\xea\xf8\xd6\xae\x84\xf1\x4b\xe8\xf6\x4a\xc1\xbb\xd8\x07\x13\xbe\x30\x02\xeb\xef\xba\x94\x96\xc2\x7f\x9f\xb6\x06\x2c\x96\x6e\xae\xd7\x6e\xae\xd7\x53\x63\xb5\xa2\x8b\x85\x9f\xb5\x15\x82\x31\x14\xf4\x93\x9b\xfe\x37\xc6\x22\x5c\x07\x92\xd6\xec\x05\x5f\xcc\xcd\x47\xb3\xeb\xb8\x1e\x4b\x8d\x1d\x8c\xc6\x3a\x02\x5f\x34\x72\x66\x4b\xdb\x17\x43\x17\xf6\x36\x58\x9f\x30\xb5\x0d\x1b\xbe\xd8\xda\xec\xc5\x75\x2a\x36\x8f\x6e\x8c\x47\xca\xb7\xd6\x1d\x98\xf6\x80\xa5\xf2\xd8\xa3\xb0\xaf\xbf\xb6\xc8\x99\x77\x8f\x40\x9c\x63\x3e\xfd\x08\xf9\x73\xb6\x78\x6e\xef\x73\xb9\x18\x5b\x39\x71\xbd\x85\x76\xd8\x4b\x83\xdd\x76\x5c\x8d\xa6\x1c\xac\xdd\x07\x7b\xe0\x81\x36\x54\xda\x74\xe1\x8f\x27\x84\x56\x06\xbc\x79\xdb\x72\xed\x2b\x92\x6b\x77\x2b\xdb\x5b\x64\xb9\xaa\xef\x9a\x2b\xbb\xae\xd1\x6d\x5a\xe3\xb9\x46\x67\x98\x9c\xb9\xa6\x26\x87\x1d\xd2\xe8\x9c\xd3\x8e\x47\x9b\x6d\xbd\xbe\xe8\xb2\xdb\x38\x7b\x31\xb5\x68\x5f\x2f\xa6\xf8\x99\x35\x7c\xa8\x5b\xb7\x9d\x4f\x97\x33\xc7\x1e\xa4\x6b\x1f\x6e\xd8\x73\x8b\xc5\xd3\xed\x39\x6e\xf9\xb0\xd9\xb1\x47\xc7\xa0\xdb\x8a\x3d\xb7\xae\x91\x96\x8d\x36\x5a\x06\x4c\xb4\x9c\x92\xd2\x35\xdb\x3e\xd7\xdf\x1d\x43\x53\x1d\x9d\x54\xe7\x5a\x55\x4a\x57\x14\x53\x9d\x71\x45\x33\x1d\xd0\x4e\xdb\x9c\x56\x81\x73\xf3\xf6\xec\x94\xad\x98\x29\x1b\x71\x7e\xa3\x7e\x7c\xfa\x04\xda\x24\x8d\x2b\x99\xa6\x7f\x75\x12\x0d\xa2\x64\xaa\xf9\xf9\xe9\xd3\x16\xef\x18\x47\x98\x38\x55\x4c\x5c\x9d\x90\xc5\xa2\xf8\xf8\xe4\x9f\xe7\x64\xa1\x39\xb9\xad\xcf\xa0\xd9\xa0\x7f\xda\x6d\x8c\x83\x71\xd9\x20\xe7\xb3\x93\xad\x45\xb7\xba\xbb\xd8\x7c\xad\x64\xb2\xb8\xb6\xd9\xec\x77\x37\xa3\x41\xb4\xca\xe4\xaa\x0f\x46\xa7\xdf\xca\x63\x90\x63\x7f\xf3\x46\x7c\x07\x55\x5a\x9c\xf6\x5c\x07\x9d\x91\x92\x9c\x82\xd6\x75\x90\xe6\xa0\x23\xe5\xbf\xb6\xe6\x55\xad\x23\x9a\xec\x7f\x8c\xa7\xa1\xb3\x55\x56\x37\xbc\xbc\x9e\x95\x37\x71\xf2\x46\x46\xde\x8a\x8f\xb7\x65\xe3\xad\xb9\x78\x85\x89\x87\xac\xc6\x5a\xa8\xf6\xfc\x7a\x62\x1a\xfd\xf5\xd7\xa6\xf9\xf3\x05\x17\x8a\xf5\xe0\x74\x30\xb9\xb4\xac\xd9\x75\x6c\x60\xc0\x37\x56\xdb\xdb\xe3\xbf\x15\x08\x75\x71\xb6\x06\x7e\x5a\xd4\x75\x71\x6a\x2b\x70\xa5\x74\x77\x73\xc0\xdd\x13\x70\x8c\x5d\x2a\xab\x2d\xdd\x81\xb5\x66\xac\x1d\x04\xb4\x89\x8d\x05\x6b\xb7\xfd\x8e\x79\xcb\x66\x78\xf6\x9d\xdf\xce\x8a\x7b\xbf\xfd\xd9\x59\x9f\xed\xbb\x1f\x96\x0d\x3b\x66\x80\x9a\x3b\x2c\x4e\x4f\xf4\x0e\x40\x7f\x88\x57\x72\xe5\xcd\xc5\x22\x30\xe4\x46\x4b\xdb\x65\x33\x06\x82\xb4\xfd\xbd\xbe\xd1\x36\x93\x78\xb4\x3c\xe3\xfd\x0c\x9b\x7c\xda\x98\x35\xa4\x39\x7d\x35\x8b\x48\xf5\xc7\x76\xf3\xc6\xdd\x71\xb5\xab\xaa\xdd\x5c\x1c\x75\x7d\x72\xe1\xed\x9d\x72\xdd\x8c\x8b\xa3\xc1\x07\x59\xff\x36\x3e\x8e\x7a\xd4\xc4\x17\xab\xe6\x2c\x3b\xd4\xa4\x06\xca\x15\x7a\x43\x6e\xbd\x9a\xf4\x9b\x72\xdd\xe5\x92\xc8\x4d\xbb\xef\x1a\x82\x7d\xe3\x2e\xbc\x36\xd0\xf8\xb8\xdb\xa0\x41\x37\x5e\xde\xf6\x6e\xbc\xbc\x2f\x34\x3e\x22\xf3\xae\x48\xa4\x9b\x7d\x75\x5d\x8f\x48\xd7\xfb\xeb\xba\x12\x91\x6a\x63\x70\xcf\xb2\xfc\xfd\x46\xb7\x08\x36\xd3\xa4\x38\xd3\x0f\x6a\xce\xae\xe2\x0e\x61\xe5\x59\xfb\xaa\x3b\x04\x0d\xf7\x6a\xde\x10\x86\xc0\x76\x6c\x99\x76\x1b\x7b\xa3\x8e\x10\xc6\xdb\xab\x53\x26\x67\xc3\x2e\x10\xda\x8d\xa8\xbf\x37\xca\x9a\xf9\xee\x98\x63\x34\x7b\x93\xdd\x2c\xaf\x57\xb3\x3c\x2e\xf2\xba\x2c\x16\x7d\x60\x36\xba\x63\x92\x50\x6f\x84\x36\x39\xcd\xf7\x6a\x96\xd7\xbd\x2c\xaf\x57\xb3\xac\x54\xdb\x8d\xee\x6b\x38\x5d\x2d\xb6\x89\xb9\x9a\xc5\x50\x2d\xf3\xc0\x9b\x3d\x83\x2f\x65\x1a\x54\xe3\xa5\xfd\x69\x5b\x20\x63\x4c\x07\xdb\x9f\xaf\xdb\x9f\x6e\xbe\xa6\x3d\xae\x5d\xd1\xdd\xa8\xaf\x63\x9e\x72\xef\x8c\x28\xbb\xa6\x03\x0e\x27\x06\x8d\xff\xeb\x45\xd6\x03\xd9\x1c\xc7\x1a\x28\xdb\x07\x7b\xff\x5f\xde\x22\xea\xa7\x3d\x70\x1f\xb4\x3b\xdc\x7b\xb3\xf6\xfb\xb5\xfc\x76\xf3\x3e\x6e\xd3\x9a\x11\x1b\x28\xe2\xec\xe9\xad\x64\xb3\x24\xd1\xcd\x36\x98\xde\xd6\xec\x34\xdf\xb8\xd6\xc8\x8b\x9c\x0f\xba\xd6\xf0\x3c\x6f\x25\xde\xe8\xd4\x03\x74\xa2\xd3\x5f\x9c\x11\x9a\xd5\x52\x84\xc1\x39\x76\x1c\x73\xec\x3a\x3f\x5d\xc5\x00\xec\x46\x9f\x1f\xea\x18\x65\xa3\x30\xed\x5c\x76\xe8\xef\x44\x6d\x70\x1e\x38\xee\xb9\x40\xc2\x7c\x7c\x5e\x7e\x20\xf5\x79\xc9\x1d\x9f\x01\x9d\xf8\x95\x02\x8d\x27\x11\x37\xfb\x9a\xbd\x29\xdf\x2c\x6a\x7b\x9a\xc2\x99\xba\x5b\xdc\x59\xdc\xb9\x6b\xc3\x85\xbe\x0e\xd3\x5f\x5f\xde\x24\xc3\x35\x4d\xbe\x9a\x9d\x8a\x0d\xbe\x3c\x36\xf1\x6a\xb5\x37\xeb\xfb\xfb\xe8\xa4\xba\xd6\x6e\xc7\xae\x68\x76\x1c\xbf\x80\xce\x3c\xf1\xd2\x58\xdc\x7d\x6d\x0e\xe5\xe7\xd5\x8a\x43\x35\xcd\x83\x2b\x19\xeb\x95\x8c\xae\x2c\x6e\x0e\xe2\x07\x6b\x6d\x6e\xf8\x74\x1f\xc7\x75\xb3\x36\xcf\x51\x9c\xac\xcd\xc3\xb1\x21\xa8\x7f\x6f\x9e\xb3\xab\xb3\x3e\xf3\x93\xc9\xdf\x92\x20\x86\xe1\xff\xbd\x79\x24\x33\x1f\xcb\xd8\x79\x1f\x2a\xe7\x6b\x70\x38\xf6\x66\xd4\x4e\xb6\x16\xf8\x74\xb8\xa5\xce\x04\xb7\x02\x7c\xd2\x61\xa7\x15\x00\x2b\x33\xe4\x2a\x00\x04\x1e\x80\xf5\x40\x5a\x05\xc0\x20\x69\xd9\xe0\xab\x1d\xe7\xfb\xce\x80\x3e\x04\x58\x4a\xe3\xe2\x6c\xb8\x39\xaf\x5b\x24\x2e\x1b\xa9\xbd\x11\x52\x0f\x94\xcc\xb3\xea\x4a\xa8\x43\x63\x06\xbd\xf6\xdc\xa8\xc5\xb3\x7d\x87\xd5\xf3\x00\x66\xfa\x69\xf3\xbf\xb6\xf9\x5f\xdb\xfc\xaf\x87\xf2\x5b\xe4\xee\xf7\xbe\x67\x3d\xe4\xef\x83\x71\xbd\x04\xf4\xd1\xb9\xdf\x8f\x98\xf5\xd1\xb4\xdf\x8f\xe8\xc2\x6b\x50\x38\x38\x75\x81\xd6\x4f\x4a\xd6\x8d\x6d\xce\xde\x06\x6f\x66\xeb\x46\xd9\xc6\xd9\x36\xd9\xa6\xb8\x56\xb5\x3f\xff\x1c\xe8\x4c\x17\xd3\x15\x92\x55\x2e\xf0\xaa\x9e\xb7\xd2\x15\x9b\x9f\xda\x25\xde\xb0\xc7\x52\x9d\x38\x6b\xe9\xcc\x28\x67\xff\x3f\x7b\xd7\xd6\xdb\x36\x8e\x85\xdf\xfd\x2b\xce\x3e\xb4\x8e\x9b\xac\xe3\xf8\x92\x7a\xdd\xcd\x16\x49\x11\x2c\x0a\xcc\xb4\x45\x9a\x19\xcc\x4c\x11\xd8\xac\xc5\xc4\x44\x6d\xc9\x90\xe4\x24\x9e\x20\xff\x7d\x20\x5e\x24\x4a\x22\xa9\xab\x33\x4e\xc6\x2f\x81\x22\x8b\x87\x3c\xe4\xe1\xe1\xc7\xc3\xcb\xd7\x6c\x1d\x68\xa7\x53\x2a\x91\x12\x7f\xa9\x5e\xa4\x5c\x6d\x31\x4b\xaf\x73\x20\x82\x7a\x07\x23\x88\x5d\x4d\xce\x47\x1d\xaa\x0e\xec\x03\x09\x9a\x9f\x35\x42\xa2\xbe\x62\x3c\x84\xe1\x54\x4e\x6a\x4c\xa9\x7e\x74\x3c\x7b\xaa\xbb\xc2\x75\x94\x67\x99\xd3\x49\xf1\xd1\x6e\x3a\x59\x71\x3a\x59\x83\xad\x16\xbc\x0a\x2b\x2f\xa5\x9e\x09\x35\xd9\x11\x2d\x1e\x48\xec\x7b\x9d\xce\x70\x78\x9d\xfc\x41\xc6\xfa\x43\x09\xeb\x2f\x73\x13\xf0\x99\xc1\x38\xbb\x9a\x5f\x87\xc2\x95\xd4\x7b\x59\xcc\x4f\x81\xb0\x24\xa8\x1e\xd0\x70\xbd\x01\x54\x0f\x76\xa0\x5a\x36\x0f\x3d\xa8\x66\xbf\xca\xa0\x5a\x75\xca\xd7\x4e\xb2\x29\x8a\x1a\x13\x87\x16\xd3\xac\xc5\xe1\x59\xab\x14\x6c\x0e\x4f\x3a\xb6\xad\x54\xaa\xe8\x88\x96\x02\x4b\xdb\xa5\xb9\x17\xab\x8c\xd2\x92\xfd\xb5\x92\x54\xb2\xf7\x23\x10\x20\x3a\xae\xc9\x7a\x04\x6b\x06\xfb\xe2\xef\xf9\xba\x59\x52\x71\xb1\x62\x66\xad\x0b\x21\x9c\xa0\x68\xf2\xc0\x5b\x01\x44\xf4\x4c\x20\xa2\x17\x63\x40\xe4\xdb\xe9\x32\x41\x44\xcf\x04\x22\x94\x22\x5f\x0c\x88\xa0\xea\x64\x83\x08\x99\xd0\x91\x0e\xe0\x92\xad\x29\xb9\xde\xcb\x81\x88\xaa\xac\x7c\x7a\xd6\xb8\xd4\xc2\xc7\xb1\x92\xbf\xa8\x0e\x72\xb9\xe4\x8e\x99\xe3\x3a\x98\xfd\xb6\x6a\x85\xa5\x34\xb5\xdf\xa6\x18\xf5\x78\xd7\x49\x92\xea\xf1\xd7\xc6\x25\x4b\x4d\x9a\xe0\xa7\xcd\xf3\xf1\x89\x72\xbf\xd7\xed\xa8\x8e\xeb\x91\x2e\x7d\x0b\x46\x86\x8b\xb7\xd4\xbc\x7b\x8a\xac\x53\x3b\x99\xb3\xf2\x95\x76\x38\x17\xe3\xa1\xcb\x04\xdb\x3b\x1e\xba\xac\x3e\xbf\x23\xa2\xdb\x3a\x22\x3a\xe6\x41\xba\x5a\xcf\x16\xee\xf6\x61\xdf\x19\x36\xfa\xf0\x0f\xe2\x7b\x7c\x6e\x8b\x70\xdd\xd5\xb0\xd6\xb1\x91\x69\x44\x55\xb2\x3b\xf5\xdd\xda\xcf\x9d\xec\xae\x10\x1c\x2c\x7a\xd7\xf7\xa6\xc9\xee\xca\xda\x62\x3e\x32\xbb\xd8\xea\x73\x44\x62\xa7\x58\x45\xd3\x7c\x29\x4f\xf1\xc3\x2f\xaa\x32\xe3\xb1\x4d\xea\x66\x62\xbc\x7e\x41\x62\x3c\x26\x53\xc3\x8b\x17\x6b\xa5\xc2\x55\x3d\xa5\x55\xfd\xe5\xe2\xfc\xeb\xf9\xa7\xcb\xd3\xcb\x8f\x9f\x3f\x8d\x4f\x2f\x2f\x2f\x3e\x9e\xfd\x72\x79\xfe\x95\x07\x71\x8a\xca\x64\x46\x75\xfe\xeb\xf9\xa7\xcb\x94\xb0\x87\x46\x3e\x76\x33\x35\x25\x40\x5e\xa2\x2b\x6d\xea\x6c\x8e\x2f\x6d\xd2\x6c\x8e\x2f\x6d\xd2\x42\xec\x66\x2f\x54\xf3\x4c\xea\xc6\xac\xec\x73\x51\x37\xe6\x10\x92\x45\xdd\xa8\xaf\xc1\x19\x5a\x8a\x8d\x61\x7c\x9b\x6b\x09\x29\x21\x01\x24\x88\xdd\xb1\x65\x85\x18\xf9\xda\x72\x69\x01\xe1\xa2\x51\xa5\x1a\x85\x70\xcd\xac\x06\x41\x1c\x1b\x97\x96\xc3\xfc\x72\xab\xd5\x60\x3b\xaa\x1b\x10\xdf\x77\x5d\xa9\x7c\xd2\xbe\xee\x4a\x72\x62\x4b\xbc\x15\x65\xc9\x7b\xd0\x2b\x08\xe2\xda\xfd\x0d\x8e\x89\xd3\x99\x96\xc9\x38\x07\x77\x68\x0e\xcf\x14\xb4\xc6\x3f\x4f\xef\x3c\x14\xb4\x59\x65\xcf\x4b\x78\x9a\x35\x28\xe5\x24\xbf\xdc\x50\x43\x54\x70\xa6\x76\x16\xf9\xa5\x31\x25\x33\x3f\xb6\x46\x53\x79\x44\xf2\x9d\x65\x65\xef\xeb\xd6\x30\xbc\x02\xb0\x33\x3a\x95\xc5\xcc\xf1\x75\x95\xb2\x50\xff\xdf\x78\x6c\x19\xf9\x1b\x63\x43\xc3\x51\x27\xe1\xe3\xf9\x0b\x01\x56\x9b\x36\x9d\xee\x6b\x68\x1f\x13\x3e\xbd\xd3\x1e\x24\xbd\x73\xaf\x2b\x37\xf7\x03\x6b\xb1\xc1\x81\xa8\xf5\xc1\x41\x58\x73\x83\x03\xae\xfd\x00\x1e\x43\x52\xc4\xba\x38\x11\xa3\x23\xc2\x71\x4a\xc4\x41\xc7\x44\x89\xc8\xe5\xe8\x69\x10\x6f\x91\x0b\xdf\x91\x87\x3f\x52\x8d\xd9\xfd\x22\x2a\x4a\xa1\x4e\x97\xcf\xb0\x82\x8f\xd9\x55\x4d\x6a\xba\xbf\x23\x5e\xc4\x06\xbc\x81\xcb\x19\xf1\x60\x81\xfd\x99\x63\x01\xf1\x60\x4e\x7e\x60\x98\x8c\xdb\xde\x6a\x31\x01\x7c\x3f\xc5\x4b\x1f\xfc\x19\xf2\x81\xf8\x80\xa6\xc1\xbf\x1e\x4c\x08\x2f\xc8\x04\xee\x66\x64\x3a\x03\xe2\x05\x92\x88\x7d\xeb\xfc\xc0\x16\x3d\xc0\x88\xd1\x74\x06\xdc\x97\x02\xb1\x61\x42\x3d\xc1\x04\x7c\x07\x6e\xd8\xbe\x30\x2c\x5d\xff\xe7\x3b\xf0\x1d\x83\xb7\x5a\x2c\xb0\xd5\x66\x85\xc2\x20\x32\x09\x4a\x25\x44\xdf\x11\x7f\x06\x8e\x8d\x43\x3e\x98\x11\xec\x51\x11\xad\x20\x19\x65\x4c\x60\xfc\x36\xf4\x71\x81\x03\x6b\xfd\x7c\x0d\x63\xf6\x0b\xb1\xa7\x18\xfa\xed\x4e\xbb\x43\xff\x9f\x22\x1f\xdf\x38\xee\x9a\xde\x0f\xdc\x88\x0e\x57\x3e\x9c\x06\x65\x7d\x04\x5a\x64\x5a\x14\xf6\xe4\x3b\xa2\x4c\xe0\xdc\x62\xb7\x2d\x27\x11\x3b\x0c\x1e\xe1\x9b\x28\xf7\xc9\xb8\x4d\x2c\x6c\xfb\xc4\x5f\x5f\x25\x14\xe2\xda\x50\x4e\x0d\x56\x47\x4c\x98\xcb\xcf\x85\x3e\xb0\x7e\xf6\x18\x1e\x14\xa5\xe7\x41\x57\x0b\xf6\x15\xbe\x47\x8b\xe5\x1c\x73\x85\x03\xe3\x60\x63\x06\xbd\x01\xfd\x01\x9a\x76\x73\x04\x7d\x1a\x24\x65\xcf\x5d\xe9\x79\x28\x3d\x1f\xb3\xf3\xfc\x54\x0a\x6d\xf0\xb3\xf5\x1e\x97\x14\x1d\xbb\xd8\x73\x5a\xf0\x10\x6e\x8c\x68\xdb\xef\x58\x24\xf6\x0d\x1c\x1e\xc2\xc9\xff\xa0\xdb\xe1\x02\x0e\x0f\xa9\x8e\x93\x31\x9d\x40\x63\xd7\x5f\x4f\x22\x85\xbd\x99\xe3\xfa\x33\x64\xb3\xc6\x4d\xe5\xd5\xb4\x9b\x29\x99\x87\x11\xe5\x09\xfb\x9a\x81\xfb\x50\x66\xec\xba\x7a\xf6\x23\xbc\x7e\xcd\x5a\x4a\x5c\x81\x46\xfb\xc2\x7b\xd1\x1b\x84\x04\xb9\x27\xed\x09\x71\x07\xd0\x6d\xb1\xef\x47\x94\xec\xa1\xd1\x60\xbd\xb3\xcd\x3b\x27\x65\xe8\x58\x9c\xad\xdf\x35\x52\x7d\xfb\x28\x47\xdf\xa6\xdd\x38\xec\x70\x98\x96\x01\x48\xd0\x8a\x0b\x11\x0f\x04\xe7\x3a\xec\x77\xc8\xb6\xf8\xf3\xd9\x7a\x42\x8d\xde\x59\xf9\xe0\xad\x96\xd4\x09\x5d\x3b\x2e\xed\x6e\xa9\xda\xf5\xc2\x4e\xb0\x74\xc9\x2d\x3d\xde\x5b\x93\x51\x87\x79\x05\x09\x25\x8a\x90\xc8\x8e\x43\x6f\x9c\xdf\x92\xa5\x26\x4e\x34\x51\xbc\x91\xa3\x5b\x87\xc5\x44\x86\xae\x78\xc3\x09\xfc\xfb\x48\xbc\xe1\xb7\xf3\x9d\xc4\x0c\x80\xc6\x8e\xee\x66\x64\x8e\x61\x6f\x7f\x9f\x25\xfa\x2f\xc4\xef\xc7\xa3\xab\x43\x2b\xd7\x65\x4b\x58\x22\x63\x56\x90\x6f\x34\xc9\x15\x0f\x48\x91\x6b\xd8\x13\x5f\xfe\xeb\xe4\x04\x56\x36\x23\xda\xb2\x92\x57\x13\xc3\x49\xf8\x20\x7f\x06\xef\xc3\x8c\x46\x82\x33\x02\xf6\xc5\xbb\xc4\xa5\xdc\xc9\xab\x89\x15\xf6\xc8\xeb\x4c\x61\x91\xdd\x6d\x22\xe0\xdd\x1c\xb5\x65\xa7\x2e\x6a\xcb\x4e\x0d\xd4\x96\x47\xe3\xb1\x18\xd8\x3e\xb0\x71\x85\x4c\xd1\x9c\xde\xb8\xa2\xd5\x7b\xf0\xb6\x2c\x0f\xed\x78\xe9\xcc\x91\x3b\xbe\x40\x16\xd2\xd3\x18\xf6\xfe\x53\x52\x7e\x4f\xc8\xff\x12\xfc\x3d\xb5\x6f\xe6\xf8\xf4\x9e\x18\xb8\x0c\x07\x25\x49\x19\xfb\xb1\x8c\x2e\x90\x45\x56\x5e\x46\x4e\x25\x59\x5e\x07\xe2\xae\x8a\x20\x23\x33\x6b\x62\x8f\xb1\x3f\x46\xfc\x4b\x9f\x6f\xb1\x7b\x4b\xf0\x1d\xd0\xea\x86\x14\x0d\x53\x69\xb8\x98\x1d\xc3\x37\x19\x95\xf2\xbe\x9c\x07\x3a\xdf\x43\xae\xcf\xf7\x79\xd1\x22\xd3\x04\x14\x49\xff\xdf\x45\xcb\x19\x93\x41\xe6\x96\x99\xf5\x3d\x6e\x63\x9a\xf5\x0c\x74\x4f\xbc\x30\xce\xee\x8d\x02\xfc\x11\xbc\x62\x07\x92\x9b\x48\x98\x4e\xf3\x00\x4e\xf9\x97\xa6\x4c\xb5\x86\xa7\xc8\x9d\x01\x19\x29\x33\x37\x34\x9f\x9c\xb9\xe9\xad\x4f\x99\x1d\xd5\xf7\xda\x71\x17\xc8\x0f\xbe\xfa\x19\x65\x4c\x0a\xd3\x06\x27\x2e\x47\x89\x09\x11\x35\x29\x4f\xa1\x46\x7c\x44\x99\xa3\xb5\xb3\xf2\x47\xd0\x9c\x62\x3b\x70\xc2\x7c\x0d\xcf\xf3\x91\xeb\xd3\xda\xe1\x8c\xf0\x00\xd8\xb6\xf8\x8b\xde\x31\x7f\x35\xbd\x1f\x41\x73\xd0\x79\xc5\x13\x4d\xd7\xb1\x7f\x89\x6d\x63\xae\x73\x28\xc4\x59\xf9\xd1\xbb\xe6\xb0\xf3\xaa\xd9\xe0\x4b\x69\xe1\xa2\x48\xb2\x64\x45\xbd\xb3\x88\x28\xec\x7d\x0b\x75\xba\x6a\xa5\xb5\x2a\x21\x56\x9e\xdf\x46\xb5\x51\x51\x50\x50\x87\x65\x55\xcc\x0a\x9a\x64\x15\xa0\x4c\xc6\x2c\xe8\x23\x6a\x74\x6a\x5c\x0c\xd9\xf6\xd2\xc7\x2c\xf4\xf9\xaa\x11\xeb\x54\xcf\x51\x0d\x76\x4f\x6c\x4b\x11\xd5\xe8\x6d\x13\xce\x7c\x3a\xf8\x75\x34\x1e\x4f\x91\xeb\x63\x8f\x20\x7b\xfc\x75\x8a\x7c\xdf\xc0\x25\xdd\xed\x96\xa4\xde\xee\xca\xb9\xfc\x66\x44\x45\xc3\x7e\x69\x9c\x17\x65\xf1\xbb\x39\x8b\x92\x94\xd8\x7d\x39\x8b\x3f\x32\xb0\x5d\x49\x4a\x6c\x31\xd4\x7e\x10\x19\x65\x30\x6f\x1f\x75\x74\x00\x8f\x37\xe6\x53\x42\x3c\xa3\xe1\xe6\x82\x78\xbc\xd0\x65\x40\x9e\xda\x92\x35\x50\x8f\xee\x50\xe6\x58\xcb\x23\xc1\xf0\xda\xcc\x46\x80\xf7\x05\xf0\x98\xca\xe2\xf3\x00\xbf\x75\x31\x84\x99\x32\xf9\x3c\x79\xfc\x59\x0c\x57\xa6\x6c\xbe\x46\x44\x99\x34\x73\x21\x3a\x85\x2a\xd5\x4e\xbb\xbf\x73\xda\xe3\x53\x17\x23\x83\xc7\x2e\x3f\x2d\x7f\x19\x1e\xbb\x26\x6f\x1a\xd4\x72\xca\x95\x6e\xb3\x27\x0d\x0a\x5c\xd9\x8d\x32\xdb\x2a\x35\x5d\x7e\xb6\xce\xb2\x98\x23\xd3\x59\x58\x41\x47\x36\xd8\x26\x47\xb6\x8b\x72\x6e\x2e\xca\xb9\xe9\x28\x64\xef\xc9\xa2\x90\xfd\xc2\x51\xc8\x32\x60\x38\x8c\xdb\x11\x34\x3f\x33\xc6\x87\x87\xe6\x48\xe7\xd9\x33\x8c\x76\x32\x9d\xcb\x78\x71\x55\xcd\x69\xdc\xf8\x1c\xdf\x60\xdb\xe2\x67\xf0\x46\xd2\xd9\x84\xfa\x43\xa2\xda\x5e\xb0\x91\x90\xa8\xbe\x2b\xd4\xe8\xf7\xeb\x09\x89\xba\xb4\x95\x5e\x54\x44\x94\xab\xb4\x0b\x88\xee\x02\xa2\xbb\x80\xe8\xf6\xaa\xa1\x0f\x88\x1e\x6f\x13\x24\x7d\xb9\x73\x6b\x13\xa8\xe9\x76\x87\x35\x4c\xad\x7f\x22\x36\x36\x64\x71\x5c\x43\x30\x74\x63\x81\xe3\xc1\xe6\xc3\x10\xc7\x9b\x0f\x43\xbc\x7d\x82\xc0\xf1\xb0\xb6\x50\x07\xc5\x7b\x1e\xb6\xd2\x70\x79\xcb\x43\x1e\xa2\xe0\x7a\xc0\x6c\x70\xb2\x8a\x2e\xa3\xbe\xaa\xa8\x6a\xe4\xa4\x90\x63\x28\x28\x40\xdd\x29\x15\x42\x6a\x0e\xe0\xa8\xba\x69\xdd\x01\x1c\x55\x3f\xad\x3b\xda\xad\xea\xa8\x35\x4c\x16\x74\x7d\x33\x6f\x90\x88\x3e\xd0\xe7\xab\xd6\xbb\xbf\x02\x00\x00\xff\xff\xae\xc3\xe9\x8b\xa5\x1d\x33\x00")
+//nolint:misspell
+var _indexHtml = []byte(`
+
+    
+        
+        
+        
 
-func publicBundleJsBytes() ([]byte, error) {
-	return bindataRead(
-		_publicBundleJs,
-		"public/bundle.js",
-	)
+        Go Ethereum Dashboard
+        
+        
+    
+    
+        

+        
+    
+
+`)
+
+func indexHtmlBytes() ([]byte, error) {
+	return _indexHtml, nil
 }
 
-func publicBundleJs() (*asset, error) {
-	bytes, err := publicBundleJsBytes()
+func indexHtml() (*asset, error) {
+	bytes, err := indexHtmlBytes()
 	if err != nil {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "public/bundle.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info}
+	info := bindataFileInfo{name: "index.html", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
+	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6b, 0xd9, 0xa6, 0xeb, 0x32, 0x49, 0x9b, 0xe5, 0x3a, 0xcb, 0x99, 0xd3, 0xb6, 0x69, 0x7f, 0xde, 0x35, 0x9d, 0x5, 0x96, 0x84, 0xc0, 0x14, 0xef, 0xbe, 0x58, 0x10, 0x5e, 0x40, 0xf2, 0x12, 0x97}}
 	return a, nil
 }
 
-var _publicDashboardHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x52\x4d\x8b\xdb\x30\x10\xbd\xe7\x57\xcc\x0e\x14\x5a\xa8\xd6\xd9\x5b\x49\x2d\x43\xd9\xa4\xa5\xa7\x94\x92\x85\xf6\x28\x5b\xb3\xd6\x34\xfa\x70\xa5\xb1\xb7\xf9\xf7\xc5\xce\x2e\x09\xfd\x38\x8d\x86\xf7\xde\xf0\x34\x6f\xea\x9b\xed\xfe\xfe\xf0\xfd\xcb\x0e\x9c\x04\xdf\xac\xea\xb9\x80\x37\xb1\xd7\x48\x11\xa1\xc8\xc9\x93\x46\x47\xdc\x3b\xd9\xc0\xdd\x7a\xfd\x0a\x9b\x15\x00\x40\xed\xc8\xd8\xf3\x73\x69\x03\x89\x81\xce\x99\x5c\x48\x34\x3e\x1c\x3e\xaa\x77\xf8\x27\xec\x44\x06\x45\x3f\x47\x9e\x34\x7e\x53\x0f\x1f\xd4\x7d\x0a\x83\x11\x6e\x3d\x21\x74\x29\x0a\x45\xd1\xf8\x79\xa7\xc9\xf6\xf4\x97\x3a\x9a\x40\x1a\x27\xa6\xa7\x21\x65\xb9\x12\x3c\xb1\x15\xa7\x2d\x4d\xdc\x91\x5a\x9a\xb7\xc0\x91\x85\x8d\x57\xa5\x33\x9e\xf4\x1d\x36\xab\xcb\x34\x61\xf1\xd4\x7c\x4a\xb0\x13\x47\x99\xc6\x00\x5b\x53\x5c\x9b\x4c\xb6\x75\x75\x06\x2f\x64\xcf\xf1\x08\x99\xbc\xc6\xe2\x52\x96\x6e\x14\xe0\x2e\x45\x04\x39\x0d\xa4\x91\x83\xe9\xa9\xe2\x2e\x21\xb8\x4c\x8f\x1a\xe7\x3f\x96\x4d\x55\xd1\xf3\xec\xdb\x94\xfb\xea\xd1\x4c\xb3\xe8\x76\xe6\x55\xd7\x56\x6e\x94\x82\xc3\x7e\xbb\x87\xd7\xc7\x31\x1f\x53\xe0\xc2\x6f\x36\xf0\x95\x64\xcc\x11\x24\x81\x38\x02\xfa\x25\x94\xa3\xf1\xe0\xb9\xcd\x26\x33\x95\x19\x29\x03\x91\x85\x71\x58\x28\xed\x18\xad\xe7\xd8\x83\x1d\xf3\x52\x68\x22\x9f\x86\x40\x51\x40\xa9\xe7\xc0\xaa\x4b\x62\x75\x9b\xec\xe9\x5f\xe1\xbe\x87\x60\x72\xcf\x71\x03\xeb\xeb\xfd\x5b\x9e\x80\xad\x46\xfb\xb2\xa7\xff\x5c\x46\x5d\x59\x9e\xae\x74\xa5\xcb\x3c\x08\x94\xdc\x69\x5c\x3c\xd2\xed\x8f\x32\xd3\xce\xc0\x8b\xb1\xd9\x4d\xb3\xaa\xab\xf3\x0d\xfe\x0e\x00\x00\xff\xff\x58\x5e\xc8\x63\x94\x02\x00\x00")
+//nolint:misspell
+var _bundleJs = []byte((((((((((`!function(modules) {
+    function __webpack_require__(moduleId) {
+        if (installedModules[moduleId]) return installedModules[moduleId].exports;
+        var module = installedModules[moduleId] = {
+            i: moduleId,
+            l: !1,
+            exports: {}
+        };
+        return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), 
+        module.l = !0, module.exports;
+    }
+    var installedModules = {};
+    __webpack_require__.m = modules, __webpack_require__.c = installedModules, __webpack_require__.d = function(exports, name, getter) {
+        __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {
+            configurable: !1,
+            enumerable: !0,
+            get: getter
+        });
+    }, __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module.default;
+        } : function() {
+            return module;
+        };
+        return __webpack_require__.d(getter, "a", getter), getter;
+    }, __webpack_require__.o = function(object, property) {
+        return Object.prototype.hasOwnProperty.call(object, property);
+    }, __webpack_require__.p = "", __webpack_require__(__webpack_require__.s = 336);
+}([ function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        "production" === process.env.NODE_ENV ? module.exports = __webpack_require__(337) : module.exports = __webpack_require__(338);
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    (function(process) {
+        if ("production" !== process.env.NODE_ENV) {
+            var REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, isValidElement = function(object) {
+                return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+            };
+            module.exports = __webpack_require__(379)(isValidElement, !0);
+        } else module.exports = __webpack_require__(380)();
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports) {
+    function defaultSetTimout() {
+        throw new Error("setTimeout has not been defined");
+    }
+    function defaultClearTimeout() {
+        throw new Error("clearTimeout has not been defined");
+    }
+    function runTimeout(fun) {
+        if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0);
+        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) return cachedSetTimeout = setTimeout, 
+        setTimeout(fun, 0);
+        try {
+            return cachedSetTimeout(fun, 0);
+        } catch (e) {
+            try {
+                return cachedSetTimeout.call(null, fun, 0);
+            } catch (e) {
+                return cachedSetTimeout.call(this, fun, 0);
+            }
+        }
+    }
+    function runClearTimeout(marker) {
+        if (cachedClearTimeout === clearTimeout) return clearTimeout(marker);
+        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) return cachedClearTimeout = clearTimeout, 
+        clearTimeout(marker);
+        try {
+            return cachedClearTimeout(marker);
+        } catch (e) {
+            try {
+                return cachedClearTimeout.call(null, marker);
+            } catch (e) {
+                return cachedClearTimeout.call(this, marker);
+            }
+        }
+    }
+    function cleanUpNextTick() {
+        draining && currentQueue && (draining = !1, currentQueue.length ? queue = currentQueue.concat(queue) : queueIndex = -1, 
+        queue.length && drainQueue());
+    }
+    function drainQueue() {
+        if (!draining) {
+            var timeout = runTimeout(cleanUpNextTick);
+            draining = !0;
+            for (var len = queue.length; len; ) {
+                for (currentQueue = queue, queue = []; ++queueIndex < len; ) currentQueue && currentQueue[queueIndex].run();
+                queueIndex = -1, len = queue.length;
+            }
+            currentQueue = null, draining = !1, runClearTimeout(timeout);
+        }
+    }
+    function Item(fun, array) {
+        this.fun = fun, this.array = array;
+    }
+    function noop() {}
+    var cachedSetTimeout, cachedClearTimeout, process = module.exports = {};
+    !function() {
+        try {
+            cachedSetTimeout = "function" == typeof setTimeout ? setTimeout : defaultSetTimout;
+        } catch (e) {
+            cachedSetTimeout = defaultSetTimout;
+        }
+        try {
+            cachedClearTimeout = "function" == typeof clearTimeout ? clearTimeout : defaultClearTimeout;
+        } catch (e) {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    }();
+    var currentQueue, queue = [], draining = !1, queueIndex = -1;
+    process.nextTick = function(fun) {
+        var args = new Array(arguments.length - 1);
+        if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
+        queue.push(new Item(fun, args)), 1 !== queue.length || draining || runTimeout(drainQueue);
+    }, Item.prototype.run = function() {
+        this.fun.apply(null, this.array);
+    }, process.title = "browser", process.browser = !0, process.env = {}, process.argv = [], 
+    process.version = "", process.versions = {}, process.on = noop, process.addListener = noop, 
+    process.once = noop, process.off = noop, process.removeListener = noop, process.removeAllListeners = noop, 
+    process.emit = noop, process.prependListener = noop, process.prependOnceListener = noop, 
+    process.listeners = function(name) {
+        return [];
+    }, process.binding = function(name) {
+        throw new Error("process.binding is not supported");
+    }, process.cwd = function() {
+        return "/";
+    }, process.chdir = function(dir) {
+        throw new Error("process.chdir is not supported");
+    }, process.umask = function() {
+        return 0;
+    };
+}, function(module, exports, __webpack_require__) {
+    var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
+    !function() {
+        "use strict";
+        function classNames() {
+            for (var classes = [], i = 0; i < arguments.length; i++) {
+                var arg = arguments[i];
+                if (arg) {
+                    var argType = typeof arg;
+                    if ("string" === argType || "number" === argType) classes.push(arg); else if (Array.isArray(arg)) classes.push(classNames.apply(null, arg)); else if ("object" === argType) for (var key in arg) hasOwn.call(arg, key) && arg[key] && classes.push(key);
+                }
+            }
+            return classes.join(" ");
+        }
+        var hasOwn = {}.hasOwnProperty;
+        void 0 !== module && module.exports ? module.exports = classNames : (__WEBPACK_AMD_DEFINE_ARRAY__ = [], 
+        void 0 !== (__WEBPACK_AMD_DEFINE_RESULT__ = function() {
+            return classNames;
+        }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+    }();
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+            return arr2;
+        }
+        return Array.from(arr);
+    }
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    __webpack_require__.d(__webpack_exports__, "c", function() {
+        return PRESENTATION_ATTRIBUTES;
+    }), __webpack_require__.d(__webpack_exports__, "a", function() {
+        return EVENT_ATTRIBUTES;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return SCALE_TYPES;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return LEGEND_TYPES;
+    }), __webpack_require__.d(__webpack_exports__, "j", function() {
+        return getDisplayName;
+    }), __webpack_require__.d(__webpack_exports__, "h", function() {
+        return findAllByType;
+    }), __webpack_require__.d(__webpack_exports__, "i", function() {
+        return findChildByType;
+    }), __webpack_require__.d(__webpack_exports__, "k", function() {
+        return getPresentationAttributes;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return filterEventAttributes;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return filterEventsOfChild;
+    }), __webpack_require__.d(__webpack_exports__, "q", function() {
+        return validateWidthHeight;
+    }), __webpack_require__.d(__webpack_exports__, "n", function() {
+        return isSsr;
+    }), __webpack_require__.d(__webpack_exports__, "g", function() {
+        return filterSvgElements;
+    }), __webpack_require__.d(__webpack_exports__, "m", function() {
+        return isChildrenEqual;
+    }), __webpack_require__.d(__webpack_exports__, "p", function() {
+        return renderByOrder;
+    }), __webpack_require__.d(__webpack_exports__, "l", function() {
+        return getReactEventByType;
+    }), __webpack_require__.d(__webpack_exports__, "o", function() {
+        return parseChildIndex;
+    });
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1_lodash_isString__ = __webpack_require__(163), __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isString__), __WEBPACK_IMPORTED_MODULE_2_lodash_isObject__ = __webpack_require__(31), __WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__), __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__), __WEBPACK_IMPORTED_MODULE_7__DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_8__PureRender__ = __webpack_require__(5), PRESENTATION_ATTRIBUTES = {
+        alignmentBaseline: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        angle: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        baselineShift: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        clip: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        clipPath: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        clipRule: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        color: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        colorInterpolation: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        colorInterpolationFilters: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        colorProfile: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        colorRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        cursor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        direction: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "ltr", "rtl", "inherit" ]),
+        display: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        dominantBaseline: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        enableBackground: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        fill: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        fillOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number ]),
+        fillRule: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "nonzero", "evenodd", "inherit" ]),
+        filter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        floodColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        floodOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number ]),
+        font: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        fontFamily: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        fontSize: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        fontSizeAdjust: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        fontStretch: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "wider", "narrower", "ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded", "inherit" ]),
+        fontStyle: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "italic", "oblique", "inherit" ]),
+        fontVariant: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "small-caps", "inherit" ]),
+        fontWeight: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "bold", "bolder", "lighter", 100, 200, 300, 400, 500, 600, 700, 800, 900, "inherit" ]),
+        glyphOrientationHorizontal: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        glyphOrientationVertical: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        imageRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "optimizeQuality", "inherit" ]),
+        kerning: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        letterSpacing: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        lightingColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        markerEnd: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        markerMid: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        markerStart: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        mask: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        opacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        overflow: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visible", "hidden", "scroll", "auto", "inherit" ]),
+        pointerEvents: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visiblePainted", "visibleFill", "visibleStroke", "visible", "painted", "fill", "stroke", "all", "none", "inherit" ]),
+        shapeRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "crispEdges", "geometricPrecision", "inherit" ]),
+        stopColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        stopOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        stroke: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        strokeDasharray: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        strokeDashoffset: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        strokeLinecap: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "butt", "round", "square", "inherit" ]),
+        strokeLinejoin: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "miter", "round", "bevel", "inherit" ]),
+        strokeMiterlimit: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        strokeOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        strokeWidth: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        textAnchor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "start", "middle", "end", "inherit" ]),
+        textDecoration: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "none", "underline", "overline", "line-through", "blink", "inherit" ]),
+        textRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision", "inherit" ]),
+        unicodeBidi: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "embed", "bidi-override", "inherit" ]),
+        visibility: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visible", "hidden", "collapse", "inherit" ]),
+        wordSpacing: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+        writingMode: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "lr-tb", "rl-tb", "tb-rl", "lr", "rl", "tb", "inherit" ]),
+        transform: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        style: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object,
+        width: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        height: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        dx: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        dy: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        x: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        y: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        r: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+        radius: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.array ])
+    }, EVENT_ATTRIBUTES = {
+        onClick: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseDown: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseUp: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseOver: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseMove: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseOut: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseEnter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onMouseLeave: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onTouchEnd: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onTouchMove: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onTouchStart: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        onTouchCancel: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func
+    }, REACT_BROWSER_EVENT_MAP = {
+        click: "onClick",
+        mousedown: "onMouseDown",
+        mouseup: "onMouseUp",
+        mouseover: "onMouseOver",
+        mousemove: "onMouseMove",
+        mouseout: "onMouseOut",
+        mouseenter: "onMouseEnter",
+        mouseleave: "onMouseLeave",
+        touchcancel: "onTouchCancel",
+        touchend: "onTouchEnd",
+        touchmove: "onTouchMove",
+        touchstart: "onTouchStart"
+    }, SCALE_TYPES = [ "auto", "linear", "pow", "sqrt", "log", "identity", "time", "band", "point", "ordinal", "quantile", "quantize", "utcTime", "sequential", "threshold" ], LEGEND_TYPES = [ "plainline", "line", "square", "rect", "circle", "cross", "diamond", "star", "triangle", "wye", "none" ], getDisplayName = function(Comp) {
+        return Comp ? "string" == typeof Comp ? Comp : Comp.displayName || Comp.name || "Component" : "";
+    }, findAllByType = function(children, type) {
+        var result = [], types = [];
+        return types = __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(type) ? type.map(function(t) {
+            return getDisplayName(t);
+        }) : [ getDisplayName(type) ], __WEBPACK_IMPORTED_MODULE_5_react___default.a.Children.forEach(children, function(child) {
+            var childType = child && child.type && (child.type.displayName || child.type.name);
+            -1 !== types.indexOf(childType) && result.push(child);
+        }), result;
+    }, findChildByType = function(children, type) {
+        var result = findAllByType(children, type);
+        return result && result[0];
+    }, getPresentationAttributes = function(el) {
+        if (!el || __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(el)) return null;
+        var props = __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(el) ? el.props : el;
+        if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null;
+        var out = null;
+        for (var i in props) ({}).hasOwnProperty.call(props, i) && PRESENTATION_ATTRIBUTES[i] && (out || (out = {}), 
+        out[i] = props[i]);
+        return out;
+    }, getEventHandlerOfElement = function(originalHandler, props) {
+        return function(e) {
+            return originalHandler(props, e), null;
+        };
+    }, filterEventAttributes = function(el, newHandler) {
+        var wrapCallback = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
+        if (!el || __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(el)) return null;
+        var props = __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(el) ? el.props : el;
+        if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null;
+        var out = null;
+        for (var i in props) ({}).hasOwnProperty.call(props, i) && EVENT_ATTRIBUTES[i] && (out || (out = {}), 
+        out[i] = newHandler || (wrapCallback ? getEventHandlerOfElement(props[i], props) : props[i]));
+        return out;
+    }, getEventHandlerOfChild = function(originalHandler, data, index) {
+        return function(e) {
+            return originalHandler(data, index, e), null;
+        };
+    }, filterEventsOfChild = function(props, data, index) {
+        if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null;
+        var out = null;
+        for (var i in props) ({}).hasOwnProperty.call(props, i) && EVENT_ATTRIBUTES[i] && __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(props[i]) && (out || (out = {}), 
+        out[i] = getEventHandlerOfChild(props[i], data, index));
+        return out;
+    }, validateWidthHeight = function(el) {
+        if (!el || !el.props) return !1;
+        var _el$props = el.props, width = _el$props.width, height = _el$props.height;
+        return !(!Object(__WEBPACK_IMPORTED_MODULE_7__DataUtils__.h)(width) || width <= 0 || !Object(__WEBPACK_IMPORTED_MODULE_7__DataUtils__.h)(height) || height <= 0);
+    }, isSsr = function() {
+        return !("undefined" != typeof window && window.document && window.document.createElement && window.setTimeout);
+    }, SVG_TAGS = [ "a", "altGlyph", "altGlyphDef", "altGlyphItem", "animate", "animateColor", "animateMotion", "animateTransform", "circle", "clipPath", "color-profile", "cursor", "defs", "desc", "ellipse", "feBlend", "feColormatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "filter", "font", "font-face", "font-face-format", "font-face-name", "font-face-url", "foreignObject", "g", "glyph", "glyphRef", "hkern", "image", "line", "lineGradient", "marker", "mask", "metadata", "missing-glyph", "mpath", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "script", "set", "stop", "style", "svg", "switch", "symbol", "text", "textPath", "title", "tref", "tspan", "use", "view", "vkern" ], isSvgElement = function(child) {
+        return child && child.type && __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default()(child.type) && SVG_TAGS.indexOf(child.type) >= 0;
+    }, filterSvgElements = function(children) {
+        var svgElements = [];
+        return __WEBPACK_IMPORTED_MODULE_5_react___default.a.Children.forEach(children, function(entry) {
+            entry && entry.type && __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default()(entry.type) && SVG_TAGS.indexOf(entry.type) >= 0 && svgElements.push(entry);
+        }), svgElements;
+    }, isSingleChildEqual = function(nextChild, prevChild) {
+        if (__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(nextChild) && __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(prevChild)) return !0;
+        if (!__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(nextChild) && !__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(prevChild)) {
+            var _ref = nextChild.props || {}, nextChildren = _ref.children, nextProps = _objectWithoutProperties(_ref, [ "children" ]), _ref2 = prevChild.props || {}, prevChildren = _ref2.children, prevProps = _objectWithoutProperties(_ref2, [ "children" ]);
+            return nextChildren && prevChildren ? Object(__WEBPACK_IMPORTED_MODULE_8__PureRender__.b)(nextProps, prevProps) && isChildrenEqual(nextChildren, prevChildren) : !nextChildren && !prevChildren && Object(__WEBPACK_IMPORTED_MODULE_8__PureRender__.b)(nextProps, prevProps);
+        }
+        return !1;
+    }, isChildrenEqual = function isChildrenEqual(nextChildren, prevChildren) {
+        if (nextChildren === prevChildren) return !0;
+        if (__WEBPACK_IMPORTED_MODULE_5_react__.Children.count(nextChildren) !== __WEBPACK_IMPORTED_MODULE_5_react__.Children.count(prevChildren)) return !1;
+        var count = __WEBPACK_IMPORTED_MODULE_5_react__.Children.count(nextChildren);
+        if (0 === count) return !0;
+        if (1 === count) return isSingleChildEqual(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(nextChildren) ? nextChildren[0] : nextChildren, __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(prevChildren) ? prevChildren[0] : prevChildren);
+        for (var i = 0; i < count; i++) {
+            var nextChild = nextChildren[i], prevChild = prevChildren[i];
+            if (__WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(nextChild) || __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(prevChild)) {
+                if (!isChildrenEqual(nextChild, prevChild)) return !1;
+            } else if (!isSingleChildEqual(nextChild, prevChild)) return !1;
+        }
+        return !0;
+    }, renderByOrder = function(children, renderMap) {
+        var elements = [], record = {};
+        return __WEBPACK_IMPORTED_MODULE_5_react__.Children.forEach(children, function(child, index) {
+            if (child && isSvgElement(child)) elements.push(child); else if (child && renderMap[getDisplayName(child.type)]) {
+                var displayName = getDisplayName(child.type), _renderMap$displayNam = renderMap[displayName], handler = _renderMap$displayNam.handler, once = _renderMap$displayNam.once;
+                if (once && !record[displayName] || !once) {
+                    var results = handler(child, displayName, index);
+                    __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(results) ? elements = [ elements ].concat(_toConsumableArray(results)) : elements.push(results), 
+                    record[displayName] = !0;
+                }
+            }
+        }), elements;
+    }, getReactEventByType = function(e) {
+        var type = e && e.type;
+        return type && REACT_BROWSER_EVENT_MAP[type] ? REACT_BROWSER_EVENT_MAP[type] : null;
+    }, parseChildIndex = function(child, children) {
+        var result = -1;
+        return __WEBPACK_IMPORTED_MODULE_5_react__.Children.forEach(children, function(entry, index) {
+            entry === child && (result = index);
+        }), result;
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function shallowEqual(a, b) {
+        for (var key in a) if ({}.hasOwnProperty.call(a, key) && (!{}.hasOwnProperty.call(b, key) || a[key] !== b[key])) return !1;
+        for (var _key in b) if ({}.hasOwnProperty.call(b, _key) && !{}.hasOwnProperty.call(a, _key)) return !1;
+        return !0;
+    }
+    function shouldComponentUpdate(props, state) {
+        return !shallowEqual(props, this.props) || !shallowEqual(state, this.state);
+    }
+    function pureRenderDecorator(component) {
+        component.prototype.shouldComponentUpdate = shouldComponentUpdate;
+    }
+    __webpack_exports__.b = shallowEqual, __webpack_exports__.a = pureRenderDecorator;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0;
+    var _assign = __webpack_require__(204), _assign2 = function(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }(_assign);
+    exports.default = _assign2.default || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0, exports.default = function(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    };
+}, function(module, exports, __webpack_require__) {
+    function isFunction(value) {
+        if (!isObject(value)) return !1;
+        var tag = baseGetTag(value);
+        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    var baseGetTag = __webpack_require__(41), isObject = __webpack_require__(31), asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+    module.exports = isFunction;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_require__.d(__webpack_exports__, "j", function() {
+        return mathSign;
+    }), __webpack_require__.d(__webpack_exports__, "i", function() {
+        return isPercent;
+    }), __webpack_require__.d(__webpack_exports__, "h", function() {
+        return isNumber;
+    }), __webpack_require__.d(__webpack_exports__, "g", function() {
+        return isNumOrStr;
+    }), __webpack_require__.d(__webpack_exports__, "k", function() {
+        return uniqueId;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return getPercentValue;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return getAnyElementOfObject;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return hasDuplicate;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return interpolateNumber;
+    }), __webpack_require__.d(__webpack_exports__, "a", function() {
+        return findEntryInArray;
+    }), __webpack_require__.d(__webpack_exports__, "c", function() {
+        return getLinearRegression;
+    });
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_get__ = __webpack_require__(164), __WEBPACK_IMPORTED_MODULE_0_lodash_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_get__), __WEBPACK_IMPORTED_MODULE_1_lodash_isArray__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_1_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__ = __webpack_require__(116), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__), __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber__ = __webpack_require__(169), __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isNumber__), __WEBPACK_IMPORTED_MODULE_4_lodash_isString__ = __webpack_require__(163), __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isString__), mathSign = function(value) {
+        return 0 === value ? 0 : value > 0 ? 1 : -1;
+    }, isPercent = function(value) {
+        return __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(value) && value.indexOf("%") === value.length - 1;
+    }, isNumber = function(value) {
+        return __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber___default()(value) && !__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(value);
+    }, isNumOrStr = function(value) {
+        return isNumber(value) || __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(value);
+    }, idCounter = 0, uniqueId = function(prefix) {
+        var id = ++idCounter;
+        return "" + (prefix || "") + id;
+    }, getPercentValue = function(percent, totalValue) {
+        var defaultValue = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0, validate = arguments.length > 3 && void 0 !== arguments[3] && arguments[3];
+        if (!isNumber(percent) && !__WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(percent)) return defaultValue;
+        var value = void 0;
+        if (isPercent(percent)) {
+            var index = percent.indexOf("%");
+            value = totalValue * parseFloat(percent.slice(0, index)) / 100;
+        } else value = +percent;
+        return __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(value) && (value = defaultValue), 
+        validate && value > totalValue && (value = totalValue), value;
+    }, getAnyElementOfObject = function(obj) {
+        if (!obj) return null;
+        var keys = Object.keys(obj);
+        return keys && keys.length ? obj[keys[0]] : null;
+    }, hasDuplicate = function(ary) {
+        if (!__WEBPACK_IMPORTED_MODULE_1_lodash_isArray___default()(ary)) return !1;
+        for (var len = ary.length, cache = {}, i = 0; i < len; i++) {
+            if (cache[ary[i]]) return !0;
+            cache[ary[i]] = !0;
+        }
+        return !1;
+    }, interpolateNumber = function(numberA, numberB) {
+        return isNumber(numberA) && isNumber(numberB) ? function(t) {
+            return numberA + t * (numberB - numberA);
+        } : function() {
+            return numberB;
+        };
+    }, findEntryInArray = function(ary, specifiedKey, specifiedValue) {
+        return ary && ary.length ? ary.find(function(entry) {
+            return entry && __WEBPACK_IMPORTED_MODULE_0_lodash_get___default()(entry, specifiedKey) === specifiedValue;
+        }) : null;
+    }, getLinearRegression = function(data) {
+        if (!data || !data.length) return null;
+        for (var len = data.length, xsum = 0, ysum = 0, xysum = 0, xxsum = 0, xmin = 1 / 0, xmax = -1 / 0, i = 0; i < len; i++) xsum += data[i].cx, 
+        ysum += data[i].cy, xysum += data[i].cx * data[i].cy, xxsum += data[i].cx * data[i].cx, 
+        xmin = Math.min(xmin, data[i].cx), xmax = Math.max(xmax, data[i].cx);
+        var a = len * xxsum != xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
+        return {
+            xmin: xmin,
+            xmax: xmax,
+            a: a,
+            b: (ysum - a * xsum) / len
+        };
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        function _interopRequireDefault(obj) {
+            return obj && obj.__esModule ? obj : {
+                default: obj
+            };
+        }
+        function getDefaultTheme() {
+            return defaultTheme || (defaultTheme = (0, _createMuiTheme2.default)());
+        }
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.sheetsManager = void 0;
+        var _keys = __webpack_require__(50), _keys2 = _interopRequireDefault(_keys), _extends2 = __webpack_require__(6), _extends3 = _interopRequireDefault(_extends2), _getPrototypeOf = __webpack_require__(26), _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf), _classCallCheck2 = __webpack_require__(27), _classCallCheck3 = _interopRequireDefault(_classCallCheck2), _createClass2 = __webpack_require__(28), _createClass3 = _interopRequireDefault(_createClass2), _possibleConstructorReturn2 = __webpack_require__(29), _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2), _inherits2 = __webpack_require__(30), _inherits3 = _interopRequireDefault(_inherits2), _objectWithoutProperties2 = __webpack_require__(7), _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2), _map = __webpack_require__(401), _map2 = _interopRequireDefault(_map), _minSafeInteger = __webpack_require__(417), _minSafeInteger2 = _interopRequireDefault(_minSafeInteger), _react = __webpack_require__(0), _react2 = _interopRequireDefault(_react), _propTypes = __webpack_require__(1), _propTypes2 = _interopRequireDefault(_propTypes), _warning = __webpack_require__(12), _warning2 = _interopRequireDefault(_warning), _hoistNonReactStatics = __webpack_require__(151), _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics), _getDisplayName = __webpack_require__(226), _getDisplayName2 = _interopRequireDefault(_getDisplayName), _wrapDisplayName = __webpack_require__(75), _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName), _contextTypes = __webpack_require__(420), _contextTypes2 = _interopRequireDefault(_contextTypes), _jss = __webpack_require__(228), _ns = __webpack_require__(227), ns = function(obj) {
+            if (obj && obj.__esModule) return obj;
+            var newObj = {};
+            if (null != obj) for (var key in obj) Object.prototype.hasOwnProperty.call(obj, key) && (newObj[key] = obj[key]);
+            return newObj.default = obj, newObj;
+        }(_ns), _jssPreset = __webpack_require__(442), _jssPreset2 = _interopRequireDefault(_jssPreset), _createMuiTheme = __webpack_require__(150), _createMuiTheme2 = _interopRequireDefault(_createMuiTheme), _themeListener = __webpack_require__(149), _themeListener2 = _interopRequireDefault(_themeListener), _createGenerateClassName = __webpack_require__(455), _createGenerateClassName2 = _interopRequireDefault(_createGenerateClassName), _getStylesCreator = __webpack_require__(456), _getStylesCreator2 = _interopRequireDefault(_getStylesCreator), jss = (0, 
+        _jss.create)((0, _jssPreset2.default)()), generateClassName = (0, _createGenerateClassName2.default)(), indexCounter = _minSafeInteger2.default, sheetsManager = exports.sheetsManager = new _map2.default(), noopTheme = {}, defaultTheme = void 0, withStyles = function(stylesOrCreator) {
+            var options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
+            return function(Component) {
+                var _options$withTheme = options.withTheme, withTheme = void 0 !== _options$withTheme && _options$withTheme, _options$flip = options.flip, flip = void 0 === _options$flip ? null : _options$flip, name = options.name, styleSheetOptions = (0, 
+                _objectWithoutProperties3.default)(options, [ "withTheme", "flip", "name" ]), stylesCreator = (0, 
+                _getStylesCreator2.default)(stylesOrCreator), listenToTheme = stylesCreator.themingEnabled || withTheme || "string" == typeof name;
+                indexCounter += 1, stylesCreator.options.index = indexCounter, "production" !== process.env.NODE_ENV && (0, 
+                _warning2.default)(indexCounter < 0, [ "Material-UI: you might have a memory leak.", "The indexCounter is not supposed to grow that much." ].join(" "));
+                var WithStyles = function(_React$Component) {
+                    function WithStyles(props, context) {
+                        (0, _classCallCheck3.default)(this, WithStyles);
+                        var _this = (0, _possibleConstructorReturn3.default)(this, (WithStyles.__proto__ || (0, 
+                        _getPrototypeOf2.default)(WithStyles)).call(this, props, context));
+                        _this.state = {}, _this.disableStylesGeneration = !1, _this.jss = null, _this.sheetOptions = null, 
+                        _this.sheetsManager = sheetsManager, _this.stylesCreatorSaved = null, _this.theme = null, 
+                        _this.unsubscribeId = null, _this.jss = _this.context[ns.jss] || jss;
+                        var muiThemeProviderOptions = _this.context.muiThemeProviderOptions;
+                        return muiThemeProviderOptions && (muiThemeProviderOptions.sheetsManager && (_this.sheetsManager = muiThemeProviderOptions.sheetsManager), 
+                        _this.disableStylesGeneration = muiThemeProviderOptions.disableStylesGeneration), 
+                        _this.stylesCreatorSaved = stylesCreator, _this.sheetOptions = (0, _extends3.default)({
+                            generateClassName: generateClassName
+                        }, _this.context[ns.sheetOptions]), _this.theme = listenToTheme ? _themeListener2.default.initial(context) || getDefaultTheme() : noopTheme, 
+                        _this;
+                    }
+                    return (0, _inherits3.default)(WithStyles, _React$Component), (0, _createClass3.default)(WithStyles, [ {
+                        key: "componentWillMount",
+                        value: function() {
+                            this.attach(this.theme);
+                        }
+                    }, {
+                        key: "componentDidMount",
+                        value: function() {
+                            var _this2 = this;
+                            listenToTheme && (this.unsubscribeId = _themeListener2.default.subscribe(this.context, function(theme) {
+                                var oldTheme = _this2.theme;
+                                _this2.theme = theme, _this2.attach(_this2.theme), _this2.setState({}, function() {
+                                    _this2.detach(oldTheme);
+                                });
+                            }));
+                        }
+                    }, {
+                        key: "componentWillReceiveProps",
+                        value: function() {
+                            this.stylesCreatorSaved !== stylesCreator && "production" !== process.env.NODE_ENV && (this.detach(this.theme), 
+                            this.stylesCreatorSaved = stylesCreator, this.attach(this.theme));
+                        }
+                    }, {
+                        key: "componentWillUnmount",
+                        value: function() {
+                            this.detach(this.theme), null !== this.unsubscribeId && _themeListener2.default.unsubscribe(this.context, this.unsubscribeId);
+                        }
+                    }, {
+                        key: "attach",
+                        value: function(theme) {
+                            if (!this.disableStylesGeneration) {
+                                var stylesCreatorSaved = this.stylesCreatorSaved, sheetManager = this.sheetsManager.get(stylesCreatorSaved);
+                                sheetManager || (sheetManager = new _map2.default(), this.sheetsManager.set(stylesCreatorSaved, sheetManager));
+                                var sheetManagerTheme = sheetManager.get(theme);
+                                if (sheetManagerTheme || (sheetManagerTheme = {
+                                    refs: 0,
+                                    sheet: null
+                                }, sheetManager.set(theme, sheetManagerTheme)), 0 === sheetManagerTheme.refs) {
+                                    var styles = stylesCreatorSaved.create(theme, name), meta = name;
+                                    "production" === process.env.NODE_ENV || meta || (meta = (0, _getDisplayName2.default)(Component));
+                                    var sheet = this.jss.createStyleSheet(styles, (0, _extends3.default)({
+                                        meta: meta,
+                                        classNamePrefix: meta,
+                                        flip: "boolean" == typeof flip ? flip : "rtl" === theme.direction,
+                                        link: !1
+                                    }, this.sheetOptions, stylesCreatorSaved.options, {
+                                        name: name
+                                    }, styleSheetOptions));
+                                    sheetManagerTheme.sheet = sheet, sheet.attach();
+                                    var sheetsRegistry = this.context[ns.sheetsRegistry];
+                                    sheetsRegistry && sheetsRegistry.add(sheet);
+                                }
+                                sheetManagerTheme.refs += 1;
+                            }
+                        }
+                    }, {
+                        key: "detach",
+                        value: function(theme) {
+                            if (!this.disableStylesGeneration) {
+                                var stylesCreatorSaved = this.stylesCreatorSaved, sheetManager = this.sheetsManager.get(stylesCreatorSaved), sheetManagerTheme = sheetManager.get(theme);
+                                if (sheetManagerTheme.refs -= 1, 0 === sheetManagerTheme.refs) {
+                                    sheetManager.delete(theme), this.jss.removeStyleSheet(sheetManagerTheme.sheet);
+                                    var sheetsRegistry = this.context[ns.sheetsRegistry];
+                                    sheetsRegistry && sheetsRegistry.remove(sheetManagerTheme.sheet);
+                                }
+                            }
+                        }
+                    }, {
+                        key: "render",
+                        value: function() {
+                            var _this3 = this, _props = this.props, classesProp = _props.classes, innerRef = _props.innerRef, other = (0, 
+                            _objectWithoutProperties3.default)(_props, [ "classes", "innerRef" ]), classes = void 0, renderedClasses = {};
+                            if (!this.disableStylesGeneration) {
+                                var sheetManager = this.sheetsManager.get(this.stylesCreatorSaved), sheetsManagerTheme = sheetManager.get(this.theme);
+                                renderedClasses = sheetsManagerTheme.sheet.classes;
+                            }
+                            classes = classesProp ? (0, _extends3.default)({}, renderedClasses, (0, _keys2.default)(classesProp).reduce(function(accumulator, key) {
+                                return "production" !== process.env.NODE_ENV && (0, _warning2.default)(renderedClasses[key] || _this3.disableStylesGeneration, [ "Material-UI: the key ` + "`") + (`" + key + "` + ("`" + ` provided to the classes property is not implemented in " + (0, 
+                                _getDisplayName2.default)(Component) + ".", "You can only override one of the following: " + (0, 
+                                _keys2.default)(renderedClasses).join(",") ].join("\n")), "production" !== process.env.NODE_ENV && (0, 
+                                _warning2.default)(!classesProp[key] || "string" == typeof classesProp[key], [ "Material-UI: the key `))) + (("`" + (`" + key + "` + "`")) + (` provided to the classes property is not valid for " + (0, 
+                                _getDisplayName2.default)(Component) + ".", "You need to provide a non empty string instead of: " + classesProp[key] + "." ].join("\n")), 
+                                classesProp[key] && (accumulator[key] = renderedClasses[key] + " " + classesProp[key]), 
+                                accumulator;
+                            }, {})) : renderedClasses;
+                            var more = {};
+                            return withTheme && (more.theme = this.theme), _react2.default.createElement(Component, (0, 
+                            _extends3.default)({
+                                classes: classes
+                            }, more, other, {
+                                ref: innerRef
+                            }));
+                        }
+                    } ]), WithStyles;
+                }(_react2.default.Component);
+                return WithStyles.propTypes = "production" !== process.env.NODE_ENV ? {
+                    classes: _propTypes2.default.object,
+                    innerRef: _propTypes2.default.func
+                } : {}, WithStyles.contextTypes = (0, _extends3.default)({
+                    muiThemeProviderOptions: _propTypes2.default.object
+                }, _contextTypes2.default, listenToTheme ? _themeListener2.default.contextTypes : {}), 
+                "production" !== process.env.NODE_ENV && (WithStyles.displayName = (0, _wrapDisplayName2.default)(Component, "WithStyles")), 
+                (0, _hoistNonReactStatics2.default)(WithStyles, Component), "production" !== process.env.NODE_ENV && (WithStyles.Naked = Component, 
+                WithStyles.options = options), WithStyles;
+            };
+        };
+        exports.default = withStyles;
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports) {
+    var isArray = Array.isArray;
+    module.exports = isArray;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        var warning = function() {};
+        "production" !== process.env.NODE_ENV && (warning = function(condition, format, args) {
+            var len = arguments.length;
+            args = new Array(len > 2 ? len - 2 : 0);
+            for (var key = 2; key < len; key++) args[key - 2] = arguments[key];
+            if (void 0 === format) throw new Error("` + ("`" + `warning(condition, format, ...args)`)))) + ((("`" + (` requires a warning message argument");
+            if (format.length < 10 || /^[s\W]*$/.test(format)) throw new Error("The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: " + format);
+            if (!condition) {
+                var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
+                    return args[argIndex++];
+                });
+                "undefined" != typeof console && console.error(message);
+                try {
+                    throw new Error(message);
+                } catch (x) {}
+            }
+        }), module.exports = warning;
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0;
+    var _defineProperty = __webpack_require__(142), _defineProperty2 = function(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }(_defineProperty);
+    exports.default = function(obj, key, value) {
+        return key in obj ? (0, _defineProperty2.default)(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function Layer(props) {
+        var children = props.children, className = props.className, others = _objectWithoutProperties(props, [ "children", "className" ]), layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-layer", className);
+        return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("g", _extends({
+            className: layerClass
+        }, others), children);
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, propTypes = {
+        className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node ])
+    };
+    Layer.propTypes = propTypes, __webpack_exports__.a = Layer;
+}, function(module, exports, __webpack_require__) {
+    var global = __webpack_require__(157), core = __webpack_require__(158), hide = __webpack_require__(245), redefine = __webpack_require__(536), ctx = __webpack_require__(539), $export = function(type, name, source) {
+        var key, own, out, exp, IS_FORCED = type & $export.F, IS_GLOBAL = type & $export.G, IS_STATIC = type & $export.S, IS_PROTO = type & $export.P, IS_BIND = type & $export.B, target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {}).prototype, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}), expProto = exports.prototype || (exports.prototype = {});
+        IS_GLOBAL && (source = name);
+        for (key in source) own = !IS_FORCED && target && void 0 !== target[key], out = (own ? target : source)[key], 
+        exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && "function" == typeof out ? ctx(Function.call, out) : out, 
+        target && redefine(target, key, out, type & $export.U), exports[key] != out && hide(exports, key, exp), 
+        IS_PROTO && expProto[key] != out && (expProto[key] = out);
+    };
+    global.core = core, $export.F = 1, $export.G = 2, $export.S = 4, $export.P = 8, 
+    $export.B = 16, $export.W = 32, $export.U = 64, $export.R = 128, module.exports = $export;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _defineProperty(obj, key, value) {
+        return key in obj ? Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    }
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+            return arr2;
+        }
+        return Array.from(arr);
+    }
+    __webpack_require__.d(__webpack_exports__, "w", function() {
+        return getValueByDataKey;
+    }), __webpack_require__.d(__webpack_exports__, "n", function() {
+        return getDomainOfDataByKey;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return calculateActiveTickIndex;
+    }), __webpack_require__.d(__webpack_exports__, "r", function() {
+        return getMainColorOfGraphicItem;
+    }), __webpack_require__.d(__webpack_exports__, "q", function() {
+        return getLegendProps;
+    }), __webpack_require__.d(__webpack_exports__, "i", function() {
+        return getBarSizeList;
+    }), __webpack_require__.d(__webpack_exports__, "h", function() {
+        return getBarPosition;
+    }), __webpack_require__.d(__webpack_exports__, "a", function() {
+        return appendOffsetOfLegend;
+    }), __webpack_require__.d(__webpack_exports__, "z", function() {
+        return parseErrorBarsOfAxis;
+    }), __webpack_require__.d(__webpack_exports__, "o", function() {
+        return getDomainOfItemsWithSameAxis;
+    }), __webpack_require__.d(__webpack_exports__, "x", function() {
+        return isCategorialAxis;
+    }), __webpack_require__.d(__webpack_exports__, "m", function() {
+        return getCoordinatesOfGrid;
+    }), __webpack_require__.d(__webpack_exports__, "u", function() {
+        return getTicksOfAxis;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return combineEventHandlers;
+    }), __webpack_require__.d(__webpack_exports__, "A", function() {
+        return parseScale;
+    }), __webpack_require__.d(__webpack_exports__, "c", function() {
+        return checkDomainOfScale;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return findPositionOfBar;
+    }), __webpack_require__.d(__webpack_exports__, "C", function() {
+        return truncateByDomain;
+    }), __webpack_require__.d(__webpack_exports__, "s", function() {
+        return getStackGroupsByAxisId;
+    }), __webpack_require__.d(__webpack_exports__, "v", function() {
+        return getTicksOfScale;
+    }), __webpack_require__.d(__webpack_exports__, "l", function() {
+        return getCateCoordinateOfLine;
+    }), __webpack_require__.d(__webpack_exports__, "k", function() {
+        return getCateCoordinateOfBar;
+    }), __webpack_require__.d(__webpack_exports__, "j", function() {
+        return getBaseValueOfBar;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return detectReferenceElementsDomain;
+    }), __webpack_require__.d(__webpack_exports__, "t", function() {
+        return getStackedDataOfItem;
+    }), __webpack_require__.d(__webpack_exports__, "p", function() {
+        return getDomainOfStackGroups;
+    }), __webpack_require__.d(__webpack_exports__, "B", function() {
+        return parseSpecifiedDomain;
+    }), __webpack_require__.d(__webpack_exports__, "D", function() {
+        return validateCoordinateInRange;
+    }), __webpack_require__.d(__webpack_exports__, "g", function() {
+        return getBandSizeOfAxis;
+    }), __webpack_require__.d(__webpack_exports__, "y", function() {
+        return parseDomainOfCategoryAxis;
+    });
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual__ = __webpack_require__(34), __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isEqual__), __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy__ = __webpack_require__(284), __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_sortBy__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__ = __webpack_require__(116), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__), __WEBPACK_IMPORTED_MODULE_3_lodash_isString__ = __webpack_require__(163), __WEBPACK_IMPORTED_MODULE_3_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isString__), __WEBPACK_IMPORTED_MODULE_4_lodash_max__ = __webpack_require__(700), __WEBPACK_IMPORTED_MODULE_4_lodash_max___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_max__), __WEBPACK_IMPORTED_MODULE_5_lodash_min__ = __webpack_require__(289), __WEBPACK_IMPORTED_MODULE_5_lodash_min___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_lodash_min__), __WEBPACK_IMPORTED_MODULE_6_lodash_isArray__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_7_lodash_flatMap__ = __webpack_require__(701), __WEBPACK_IMPORTED_MODULE_7_lodash_flatMap___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_lodash_flatMap__), __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_9_lodash_get__ = __webpack_require__(164), __WEBPACK_IMPORTED_MODULE_9_lodash_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_lodash_get__), __WEBPACK_IMPORTED_MODULE_10_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_11_recharts_scale__ = __webpack_require__(703), __WEBPACK_IMPORTED_MODULE_12_d3_scale__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_11_recharts_scale__), 
+    __webpack_require__(292)), __WEBPACK_IMPORTED_MODULE_13_d3_shape__ = __webpack_require__(172), __WEBPACK_IMPORTED_MODULE_14__DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_15__cartesian_ReferenceDot__ = __webpack_require__(325), __WEBPACK_IMPORTED_MODULE_16__cartesian_ReferenceLine__ = __webpack_require__(326), __WEBPACK_IMPORTED_MODULE_17__cartesian_ReferenceArea__ = __webpack_require__(327), __WEBPACK_IMPORTED_MODULE_18__cartesian_ErrorBar__ = __webpack_require__(92), __WEBPACK_IMPORTED_MODULE_19__component_Legend__ = __webpack_require__(170), __WEBPACK_IMPORTED_MODULE_20__ReactUtils__ = __webpack_require__(4), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, getValueByDataKey = function(obj, dataKey, defaultValue) {
+        return __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(obj) || __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(dataKey) ? defaultValue : Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.g)(dataKey) ? __WEBPACK_IMPORTED_MODULE_9_lodash_get___default()(obj, dataKey, defaultValue) : __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(dataKey) ? dataKey(obj) : defaultValue;
+    }, getDomainOfDataByKey = function(data, key, type, filterNil) {
+        var flattenData = __WEBPACK_IMPORTED_MODULE_7_lodash_flatMap___default()(data, function(entry) {
+            return getValueByDataKey(entry, key);
+        });
+        if ("number" === type) {
+            var domain = flattenData.filter(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h);
+            return [ Math.min.apply(null, domain), Math.max.apply(null, domain) ];
+        }
+        return (filterNil ? flattenData.filter(function(entry) {
+            return !__WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(entry);
+        }) : flattenData).map(function(entry) {
+            return Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.g)(entry) ? entry : "";
+        });
+    }, calculateActiveTickIndex = function(coordinate, ticks, unsortedTicks, axis) {
+        var index = -1, len = ticks.length;
+        if (len > 1) {
+            if (axis && "angleAxis" === axis.axisType && Math.abs(Math.abs(axis.range[1] - axis.range[0]) - 360) <= 1e-6) for (var range = axis.range, i = 0; i < len; i++) {
+                var before = i > 0 ? unsortedTicks[i - 1].coordinate : unsortedTicks[len - 1].coordinate, cur = unsortedTicks[i].coordinate, after = i >= len - 1 ? unsortedTicks[0].coordinate : unsortedTicks[i + 1].coordinate, sameDirectionCoord = void 0;
+                if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.j)(cur - before) !== Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.j)(after - cur)) {
+                    var diffInterval = [];
+                    if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.j)(after - cur) === Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.j)(range[1] - range[0])) {
+                        sameDirectionCoord = after;
+                        var curInRange = cur + range[1] - range[0];
+                        diffInterval[0] = Math.min(curInRange, (curInRange + before) / 2), diffInterval[1] = Math.max(curInRange, (curInRange + before) / 2);
+                    } else {
+                        sameDirectionCoord = before;
+                        var afterInRange = after + range[1] - range[0];
+                        diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2), diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
+                    }
+                    var sameInterval = [ Math.min(cur, (sameDirectionCoord + cur) / 2), Math.max(cur, (sameDirectionCoord + cur) / 2) ];
+                    if (coordinate > sameInterval[0] && coordinate <= sameInterval[1] || coordinate >= diffInterval[0] && coordinate <= diffInterval[1]) {
+                        index = unsortedTicks[i].index;
+                        break;
+                    }
+                } else {
+                    var min = Math.min(before, after), max = Math.max(before, after);
+                    if (coordinate > (min + cur) / 2 && coordinate <= (max + cur) / 2) {
+                        index = unsortedTicks[i].index;
+                        break;
+                    }
+                }
+            } else for (var _i = 0; _i < len; _i++) if (0 === _i && coordinate <= (ticks[_i].coordinate + ticks[_i + 1].coordinate) / 2 || _i > 0 && _i < len - 1 && coordinate > (ticks[_i].coordinate + ticks[_i - 1].coordinate) / 2 && coordinate <= (ticks[_i].coordinate + ticks[_i + 1].coordinate) / 2 || _i === len - 1 && coordinate > (ticks[_i].coordinate + ticks[_i - 1].coordinate) / 2) {
+                index = ticks[_i].index;
+                break;
+            }
+        } else index = 0;
+        return index;
+    }, getMainColorOfGraphicItem = function(item) {
+        var displayName = item.type.displayName, result = void 0;
+        switch (displayName) {
+          case "Line":
+          case "Area":
+          case "Radar":
+            result = item.props.stroke;
+            break;
 
-func publicDashboardHtmlBytes() ([]byte, error) {
-	return bindataRead(
-		_publicDashboardHtml,
-		"public/dashboard.html",
-	)
+          default:
+            result = item.props.fill;
+        }
+        return result;
+    }, getLegendProps = function(_ref) {
+        var children = _ref.children, formatedGraphicalItems = _ref.formatedGraphicalItems, legendWidth = _ref.legendWidth, legendContent = _ref.legendContent, legendItem = Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_19__component_Legend__.a);
+        if (!legendItem) return null;
+        var legendData = void 0;
+        return legendData = legendItem.props && legendItem.props.payload ? legendItem.props && legendItem.props.payload : "children" === legendContent ? (formatedGraphicalItems || []).reduce(function(result, _ref2) {
+            var item = _ref2.item, props = _ref2.props, data = props.sectors || props.data || [];
+            return result.concat(data.map(function(entry) {
+                return {
+                    type: legendItem.props.iconType || item.props.legendType,
+                    value: entry.name,
+                    color: entry.fill,
+                    payload: entry
+                };
+            }));
+        }, []) : (formatedGraphicalItems || []).map(function(_ref3) {
+            var item = _ref3.item, _item$props = item.props, dataKey = _item$props.dataKey, name = _item$props.name, legendType = _item$props.legendType;
+            return {
+                inactive: _item$props.hide,
+                dataKey: dataKey,
+                type: legendItem.props.iconType || legendType || "square",
+                color: getMainColorOfGraphicItem(item),
+                value: name || dataKey,
+                payload: item.props
+            };
+        }), _extends({}, legendItem.props, __WEBPACK_IMPORTED_MODULE_19__component_Legend__.a.getWithHeight(legendItem, legendWidth), {
+            payload: legendData,
+            item: legendItem
+        });
+    }, getBarSizeList = function(_ref4) {
+        var globalSize = _ref4.barSize, _ref4$stackGroups = _ref4.stackGroups, stackGroups = void 0 === _ref4$stackGroups ? {} : _ref4$stackGroups;
+        if (!stackGroups) return {};
+        for (var result = {}, numericAxisIds = Object.keys(stackGroups), i = 0, len = numericAxisIds.length; i < len; i++) for (var sgs = stackGroups[numericAxisIds[i]].stackGroups, stackIds = Object.keys(sgs), j = 0, sLen = stackIds.length; j < sLen; j++) {
+            var _sgs$stackIds$j = sgs[stackIds[j]], items = _sgs$stackIds$j.items, cateAxisId = _sgs$stackIds$j.cateAxisId, barItems = items.filter(function(item) {
+                return Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.j)(item.type).indexOf("Bar") >= 0;
+            });
+            if (barItems && barItems.length) {
+                var selfSize = barItems[0].props.barSize, cateId = barItems[0].props[cateAxisId];
+                result[cateId] || (result[cateId] = []), result[cateId].push({
+                    item: barItems[0],
+                    stackList: barItems.slice(1),
+                    barSize: __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(selfSize) ? globalSize : selfSize
+                });
+            }
+        }
+        return result;
+    }, getBarPosition = function(_ref5) {
+        var barGap = _ref5.barGap, barCategoryGap = _ref5.barCategoryGap, bandSize = _ref5.bandSize, _ref5$sizeList = _ref5.sizeList, sizeList = void 0 === _ref5$sizeList ? [] : _ref5$sizeList, maxBarSize = _ref5.maxBarSize, len = sizeList.length;
+        if (len < 1) return null;
+        var realBarGap = Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.d)(barGap, bandSize, 0, !0), result = void 0;
+        if (sizeList[0].barSize === +sizeList[0].barSize) {
+            var useFull = !1, fullBarSize = bandSize / len, sum = sizeList.reduce(function(res, entry) {
+                return res + entry.barSize || 0;
+            }, 0);
+            sum += (len - 1) * realBarGap, sum >= bandSize && (sum -= (len - 1) * realBarGap, 
+            realBarGap = 0), sum >= bandSize && fullBarSize > 0 && (useFull = !0, fullBarSize *= .9, 
+            sum = len * fullBarSize);
+            var offset = (bandSize - sum) / 2 >> 0, prev = {
+                offset: offset - realBarGap,
+                size: 0
+            };
+            result = sizeList.reduce(function(res, entry) {
+                var newRes = [].concat(_toConsumableArray(res), [ {
+                    item: entry.item,
+                    position: {
+                        offset: prev.offset + prev.size + realBarGap,
+                        size: useFull ? fullBarSize : entry.barSize
+                    }
+                } ]);
+                return prev = newRes[newRes.length - 1].position, entry.stackList && entry.stackList.length && entry.stackList.forEach(function(item) {
+                    newRes.push({
+                        item: item,
+                        position: prev
+                    });
+                }), newRes;
+            }, []);
+        } else {
+            var _offset = Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.d)(barCategoryGap, bandSize, 0, !0);
+            bandSize - 2 * _offset - (len - 1) * realBarGap <= 0 && (realBarGap = 0);
+            var originalSize = (bandSize - 2 * _offset - (len - 1) * realBarGap) / len;
+            originalSize > 1 && (originalSize >>= 0);
+            var size = maxBarSize === +maxBarSize ? Math.min(originalSize, maxBarSize) : originalSize;
+            result = sizeList.reduce(function(res, entry, i) {
+                var newRes = [].concat(_toConsumableArray(res), [ {
+                    item: entry.item,
+                    position: {
+                        offset: _offset + (originalSize + realBarGap) * i + (originalSize - size) / 2,
+                        size: size
+                    }
+                } ]);
+                return entry.stackList && entry.stackList.length && entry.stackList.forEach(function(item) {
+                    newRes.push({
+                        item: item,
+                        position: newRes[newRes.length - 1].position
+                    });
+                }), newRes;
+            }, []);
+        }
+        return result;
+    }, appendOffsetOfLegend = function(offset, items, props, legendBox) {
+        var children = props.children, width = props.width, height = props.height, margin = props.margin, legendWidth = width - (margin.left || 0) - (margin.right || 0), legendHeight = height - (margin.top || 0) - (margin.bottom || 0), legendProps = getLegendProps({
+            children: children,
+            items: items,
+            legendWidth: legendWidth,
+            legendHeight: legendHeight
+        }), newOffset = offset;
+        if (legendProps) {
+            var box = legendBox || {}, align = legendProps.align, verticalAlign = legendProps.verticalAlign, layout = legendProps.layout;
+            ("vertical" === layout || "horizontal" === layout && "center" === verticalAlign) && Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(offset[align]) && (newOffset = _extends({}, offset, _defineProperty({}, align, newOffset[align] + (box.width || 0)))), 
+            ("horizontal" === layout || "vertical" === layout && "center" === align) && Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(offset[verticalAlign]) && (newOffset = _extends({}, offset, _defineProperty({}, verticalAlign, newOffset[verticalAlign] + (box.height || 0))));
+        }
+        return newOffset;
+    }, getDomainOfErrorBars = function(data, item, dataKey, axisType) {
+        var children = item.props.children, errorBars = Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_18__cartesian_ErrorBar__.a).filter(function(errorBarChild) {
+            var direction = errorBarChild.props.direction;
+            return !(!__WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(direction) && !__WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(axisType)) || axisType.indexOf(direction) >= 0;
+        });
+        if (errorBars && errorBars.length) {
+            var keys = errorBars.map(function(errorBarChild) {
+                return errorBarChild.props.dataKey;
+            });
+            return data.reduce(function(result, entry) {
+                var entryValue = getValueByDataKey(entry, dataKey, 0), mainValue = __WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(entryValue) ? [ __WEBPACK_IMPORTED_MODULE_5_lodash_min___default()(entryValue), __WEBPACK_IMPORTED_MODULE_4_lodash_max___default()(entryValue) ] : [ entryValue, entryValue ], errorDomain = keys.reduce(function(prevErrorArr, k) {
+                    var errorValue = getValueByDataKey(entry, k, 0), lowerValue = mainValue[0] - Math.abs(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(errorValue) ? errorValue[0] : errorValue), upperValue = mainValue[1] + Math.abs(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(errorValue) ? errorValue[1] : errorValue);
+                    return [ Math.min(lowerValue, prevErrorArr[0]), Math.max(upperValue, prevErrorArr[1]) ];
+                }, [ 1 / 0, -1 / 0 ]);
+                return [ Math.min(errorDomain[0], result[0]), Math.max(errorDomain[1], result[1]) ];
+            }, [ 1 / 0, -1 / 0 ]);
+        }
+        return null;
+    }, parseErrorBarsOfAxis = function(data, items, dataKey, axisType) {
+        var domains = items.map(function(item) {
+            return getDomainOfErrorBars(data, item, dataKey, axisType);
+        }).filter(function(entry) {
+            return !__WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(entry);
+        });
+        return domains && domains.length ? domains.reduce(function(result, entry) {
+            return [ Math.min(result[0], entry[0]), Math.max(result[1], entry[1]) ];
+        }, [ 1 / 0, -1 / 0 ]) : null;
+    }, getDomainOfItemsWithSameAxis = function(data, items, type, filterNil) {
+        var domains = items.map(function(item) {
+            var dataKey = item.props.dataKey;
+            return "number" === type && dataKey ? getDomainOfErrorBars(data, item, dataKey) || getDomainOfDataByKey(data, dataKey, type, filterNil) : getDomainOfDataByKey(data, dataKey, type, filterNil);
+        });
+        if ("number" === type) return domains.reduce(function(result, entry) {
+            return [ Math.min(result[0], entry[0]), Math.max(result[1], entry[1]) ];
+        }, [ 1 / 0, -1 / 0 ]);
+        var tag = {};
+        return domains.reduce(function(result, entry) {
+            for (var i = 0, len = entry.length; i < len; i++) tag[entry[i]] || (tag[entry[i]] = !0, 
+            result.push(entry[i]));
+            return result;
+        }, []);
+    }, isCategorialAxis = function(layout, axisType) {
+        return "horizontal" === layout && "xAxis" === axisType || "vertical" === layout && "yAxis" === axisType || "centric" === layout && "angleAxis" === axisType || "radial" === layout && "radiusAxis" === axisType;
+    }, getCoordinatesOfGrid = function(ticks, min, max) {
+        var hasMin = void 0, hasMax = void 0, values = ticks.map(function(entry) {
+            return entry.coordinate === min && (hasMin = !0), entry.coordinate === max && (hasMax = !0), 
+            entry.coordinate;
+        });
+        return hasMin || values.push(min), hasMax || values.push(max), values;
+    }, getTicksOfAxis = function(axis, isGrid, isAll) {
+        if (!axis) return null;
+        var scale = axis.scale, duplicateDomain = axis.duplicateDomain, type = axis.type, range = axis.range, offset = (isGrid || isAll) && "category" === type && scale.bandwidth ? scale.bandwidth() / 2 : 0;
+        return offset = "angleAxis" === axis.axisType ? 2 * Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.j)(range[0] - range[1]) * offset : offset, 
+        isGrid && (axis.ticks || axis.niceTicks) ? (axis.ticks || axis.niceTicks).map(function(entry) {
+            var scaleContent = duplicateDomain ? duplicateDomain.indexOf(entry) : entry;
+            return {
+                coordinate: scale(scaleContent) + offset,
+                value: entry,
+                offset: offset
+            };
+        }) : axis.isCategorial && axis.categoricalDomain ? axis.categoricalDomain.map(function(entry, index) {
+            return {
+                coordinate: scale(entry),
+                value: entry,
+                index: index,
+                offset: offset
+            };
+        }) : scale.ticks && !isAll ? scale.ticks(axis.tickCount).map(function(entry) {
+            return {
+                coordinate: scale(entry) + offset,
+                value: entry,
+                offset: offset
+            };
+        }) : scale.domain().map(function(entry, index) {
+            return {
+                coordinate: scale(entry) + offset,
+                value: duplicateDomain ? duplicateDomain[entry] : entry,
+                index: index,
+                offset: offset
+            };
+        });
+    }, combineEventHandlers = function(defaultHandler, parentHandler, childHandler) {
+        var customizedHandler = void 0;
+        return __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(childHandler) ? customizedHandler = childHandler : __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(parentHandler) && (customizedHandler = parentHandler), 
+        __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(defaultHandler) || customizedHandler ? function(arg1, arg2, arg3, arg4) {
+            __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(defaultHandler) && defaultHandler(arg1, arg2, arg3, arg4), 
+            __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(customizedHandler) && customizedHandler(arg1, arg2, arg3, arg4);
+        } : null;
+    }, parseScale = function(axis, chartType) {
+        var scale = axis.scale, type = axis.type, layout = axis.layout, axisType = axis.axisType;
+        if ("auto" === scale) return "radial" === layout && "radiusAxis" === axisType ? {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scaleBand(),
+            realScaleType: "band"
+        } : "radial" === layout && "angleAxis" === axisType ? {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scaleLinear(),
+            realScaleType: "linear"
+        } : "category" === type && chartType && (chartType.indexOf("LineChart") >= 0 || chartType.indexOf("AreaChart") >= 0) ? {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scalePoint(),
+            realScaleType: "point"
+        } : "category" === type ? {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scaleBand(),
+            realScaleType: "band"
+        } : {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scaleLinear(),
+            realScaleType: "linear"
+        };
+        if (__WEBPACK_IMPORTED_MODULE_3_lodash_isString___default()(scale)) {
+            var name = "scale" + scale.slice(0, 1).toUpperCase() + scale.slice(1);
+            return {
+                scale: (__WEBPACK_IMPORTED_MODULE_12_d3_scale__[name] || __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scalePoint)(),
+                realScaleType: __WEBPACK_IMPORTED_MODULE_12_d3_scale__[name] ? name : "point"
+            };
+        }
+        return __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(scale) ? {
+            scale: scale
+        } : {
+            scale: __WEBPACK_IMPORTED_MODULE_12_d3_scale__.scalePoint(),
+            realScaleType: "point"
+        };
+    }, checkDomainOfScale = function(scale) {
+        var domain = scale.domain();
+        if (domain && !(domain.length <= 2)) {
+            var len = domain.length, range = scale.range(), min = Math.min(range[0], range[1]) - 1e-4, max = Math.max(range[0], range[1]) + 1e-4, first = scale(domain[0]), last = scale(domain[len - 1]);
+            (first < min || first > max || last < min || last > max) && scale.domain([ domain[0], domain[len - 1] ]);
+        }
+    }, findPositionOfBar = function(barPosition, child) {
+        if (!barPosition) return null;
+        for (var i = 0, len = barPosition.length; i < len; i++) if (barPosition[i].item === child) return barPosition[i].position;
+        return null;
+    }, truncateByDomain = function(value, domain) {
+        if (!domain || 2 !== domain.length || !Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(domain[0]) || !Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(domain[1])) return value;
+        var min = Math.min(domain[0], domain[1]), max = Math.max(domain[0], domain[1]), result = [ value[0], value[1] ];
+        return (!Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(value[0]) || value[0] < min) && (result[0] = min), 
+        (!Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(value[1]) || value[1] > max) && (result[1] = max), 
+        result[0] > max && (result[0] = max), result[1] < min && (result[1] = min), result;
+    }, offsetSign = function(series) {
+        var n = series.length;
+        if (!(n <= 0)) for (var j = 0, m = series[0].length; j < m; ++j) for (var positive = 0, negative = 0, i = 0; i < n; ++i) {
+            var value = __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(series[i][j][1]) ? series[i][j][0] : series[i][j][1];
+            value >= 0 ? (series[i][j][0] = positive, series[i][j][1] = positive + value, positive = series[i][j][1]) : (series[i][j][0] = negative, 
+            series[i][j][1] = negative + value, negative = series[i][j][1]);
+        }
+    }, STACK_OFFSET_MAP = {
+        sign: offsetSign,
+        expand: __WEBPACK_IMPORTED_MODULE_13_d3_shape__.o,
+        none: __WEBPACK_IMPORTED_MODULE_13_d3_shape__.p,
+        silhouette: __WEBPACK_IMPORTED_MODULE_13_d3_shape__.q,
+        wiggle: __WEBPACK_IMPORTED_MODULE_13_d3_shape__.r
+    }, getStackedData = function(data, stackItems, offsetType) {
+        var dataKeys = stackItems.map(function(item) {
+            return item.props.dataKey;
+        });
+        return Object(__WEBPACK_IMPORTED_MODULE_13_d3_shape__.n)().keys(dataKeys).value(function(d, key) {
+            return +getValueByDataKey(d, key, 0);
+        }).order(__WEBPACK_IMPORTED_MODULE_13_d3_shape__.s).offset(STACK_OFFSET_MAP[offsetType])(data);
+    }, getStackGroupsByAxisId = function(data, _items, numericAxisId, cateAxisId, offsetType, reverseStackOrder) {
+        if (!data) return null;
+        var items = reverseStackOrder ? _items.reverse() : _items, stackGroups = items.reduce(function(result, item) {
+            var _item$props2 = item.props, stackId = _item$props2.stackId;
+            if (_item$props2.hide) return result;
+            var axisId = item.props[numericAxisId], parentGroup = result[axisId] || {
+                hasStack: !1,
+                stackGroups: {}
+            };
+            if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.g)(stackId)) {
+                var childGroup = parentGroup.stackGroups[stackId] || {
+                    numericAxisId: numericAxisId,
+                    cateAxisId: cateAxisId,
+                    items: []
+                };
+                childGroup.items.push(item), parentGroup.hasStack = !0, parentGroup.stackGroups[stackId] = childGroup;
+            } else parentGroup.stackGroups[Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.k)("_stackId_")] = {
+                numericAxisId: numericAxisId,
+                cateAxisId: cateAxisId,
+                items: [ item ]
+            };
+            return _extends({}, result, _defineProperty({}, axisId, parentGroup));
+        }, {});
+        return Object.keys(stackGroups).reduce(function(result, axisId) {
+            var group = stackGroups[axisId];
+            return group.hasStack && (group.stackGroups = Object.keys(group.stackGroups).reduce(function(res, stackId) {
+                var g = group.stackGroups[stackId];
+                return _extends({}, res, _defineProperty({}, stackId, {
+                    numericAxisId: numericAxisId,
+                    cateAxisId: cateAxisId,
+                    items: g.items,
+                    stackedData: getStackedData(data, g.items, offsetType)
+                }));
+            }, {})), _extends({}, result, _defineProperty({}, axisId, group));
+        }, {});
+    }, calculateDomainOfTicks = function(ticks, type) {
+        return "number" === type ? [ Math.min.apply(null, ticks), Math.max.apply(null, ticks) ] : ticks;
+    }, getTicksOfScale = function(scale, opts) {
+        var realScaleType = opts.realScaleType, type = opts.type, tickCount = opts.tickCount, originalDomain = opts.originalDomain, allowDecimals = opts.allowDecimals, scaleType = realScaleType || opts.scale;
+        if ("auto" !== scaleType && "linear" !== scaleType) return null;
+        if (tickCount && "number" === type && originalDomain && ("auto" === originalDomain[0] || "auto" === originalDomain[1])) {
+            var domain = scale.domain(), tickValues = Object(__WEBPACK_IMPORTED_MODULE_11_recharts_scale__.getNiceTickValues)(domain, tickCount, allowDecimals);
+            return scale.domain(calculateDomainOfTicks(tickValues, type)), {
+                niceTicks: tickValues
+            };
+        }
+        if (tickCount && "number" === type) {
+            var _domain = scale.domain();
+            return {
+                niceTicks: Object(__WEBPACK_IMPORTED_MODULE_11_recharts_scale__.getTickValuesFixedDomain)(_domain, tickCount, allowDecimals)
+            };
+        }
+        return null;
+    }, getCateCoordinateOfLine = function(_ref6) {
+        var axis = _ref6.axis, ticks = _ref6.ticks, bandSize = _ref6.bandSize, entry = _ref6.entry, index = _ref6.index;
+        if ("category" === axis.type) {
+            if (!axis.allowDuplicatedCategory && axis.dataKey && !__WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(entry[axis.dataKey])) {
+                var matchedTick = Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.a)(ticks, "value", entry[axis.dataKey]);
+                if (matchedTick) return matchedTick.coordinate + bandSize / 2;
+            }
+            return ticks[index] ? ticks[index].coordinate + bandSize / 2 : null;
+        }
+        var value = getValueByDataKey(entry, axis.dataKey);
+        return __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(value) ? null : axis.scale(value);
+    }, getCateCoordinateOfBar = function(_ref7) {
+        var axis = _ref7.axis, ticks = _ref7.ticks, offset = _ref7.offset, bandSize = _ref7.bandSize, entry = _ref7.entry, index = _ref7.index;
+        if ("category" === axis.type) return ticks[index] ? ticks[index].coordinate + offset : null;
+        var value = getValueByDataKey(entry, axis.dataKey, axis.domain[index]);
+        return __WEBPACK_IMPORTED_MODULE_10_lodash_isNil___default()(value) ? null : axis.scale(value) - bandSize / 2 + offset;
+    }, getBaseValueOfBar = function(_ref8) {
+        var numericAxis = _ref8.numericAxis, domain = numericAxis.scale.domain();
+        if ("number" === numericAxis.type) {
+            var min = Math.min(domain[0], domain[1]), max = Math.max(domain[0], domain[1]);
+            return min <= 0 && max >= 0 ? 0 : max < 0 ? max : min;
+        }
+        return domain[0];
+    }, detectReferenceElementsDomain = function(children, domain, axisId, axisType, specifiedTicks) {
+        var lines = Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_16__cartesian_ReferenceLine__.a), dots = Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_15__cartesian_ReferenceDot__.a), elements = lines.concat(dots), areas = Object(__WEBPACK_IMPORTED_MODULE_20__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_17__cartesian_ReferenceArea__.a), idKey = axisType + "Id", valueKey = axisType[0], finalDomain = domain;
+        if (elements.length && (finalDomain = elements.reduce(function(result, el) {
+            if (el.props[idKey] === axisId && el.props.alwaysShow && Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(el.props[valueKey])) {
+                var value = el.props[valueKey];
+                return [ Math.min(result[0], value), Math.max(result[1], value) ];
+            }
+            return result;
+        }, finalDomain)), areas.length) {
+            var key1 = valueKey + "1", key2 = valueKey + "2";
+            finalDomain = areas.reduce(function(result, el) {
+                if (el.props[idKey] === axisId && el.props.alwaysShow && Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(el.props[key1]) && Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(el.props[key2])) {
+                    var value1 = el.props[key1], value2 = el.props[key2];
+                    return [ Math.min(result[0], value1, value2), Math.max(result[1], value1, value2) ];
+                }
+                return result;
+            }, finalDomain);
+        }
+        return specifiedTicks && specifiedTicks.length && (finalDomain = specifiedTicks.reduce(function(result, tick) {
+            return Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(tick) ? [ Math.min(result[0], tick), Math.max(result[1], tick) ] : result;
+        }, finalDomain)), finalDomain;
+    }, getStackedDataOfItem = function(item, stackGroups) {
+        var stackId = item.props.stackId;
+        if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.g)(stackId)) {
+            var group = stackGroups[stackId];
+            if (group && group.items.length) {
+                for (var itemIndex = -1, i = 0, len = group.items.length; i < len; i++) if (group.items[i] === item) {
+                    itemIndex = i;
+                    break;
+                }
+                return itemIndex >= 0 ? group.stackedData[itemIndex] : null;
+            }
+        }
+        return null;
+    }, getDomainOfSingle = function(data) {
+        return data.reduce(function(result, entry) {
+            return [ Math.min.apply(null, entry.concat([ result[0] ]).filter(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)), Math.max.apply(null, entry.concat([ result[1] ]).filter(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)) ];
+        }, [ 1 / 0, -1 / 0 ]);
+    }, getDomainOfStackGroups = function(stackGroups, startIndex, endIndex) {
+        return Object.keys(stackGroups).reduce(function(result, stackId) {
+            var group = stackGroups[stackId], stackedData = group.stackedData, domain = stackedData.reduce(function(res, entry) {
+                var s = getDomainOfSingle(entry.slice(startIndex, endIndex + 1));
+                return [ Math.min(res[0], s[0]), Math.max(res[1], s[1]) ];
+            }, [ 1 / 0, -1 / 0 ]);
+            return [ Math.min(domain[0], result[0]), Math.max(domain[1], result[1]) ];
+        }, [ 1 / 0, -1 / 0 ]).map(function(result) {
+            return result === 1 / 0 || result === -1 / 0 ? 0 : result;
+        });
+    }, MIN_VALUE_REG = /^dataMin[\s]*-[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/, MAX_VALUE_REG = /^dataMax[\s]*\+[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/, parseSpecifiedDomain = function(specifiedDomain, dataDomain, allowDataOverflow) {
+        if (!__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(specifiedDomain)) return dataDomain;
+        var domain = [];
+        if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(specifiedDomain[0])) domain[0] = allowDataOverflow ? specifiedDomain[0] : Math.min(specifiedDomain[0], dataDomain[0]); else if (MIN_VALUE_REG.test(specifiedDomain[0])) {
+            var value = +MIN_VALUE_REG.exec(specifiedDomain[0])[1];
+            domain[0] = dataDomain[0] - value;
+        } else __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(specifiedDomain[0]) ? domain[0] = specifiedDomain[0](dataDomain[0]) : domain[0] = dataDomain[0];
+        if (Object(__WEBPACK_IMPORTED_MODULE_14__DataUtils__.h)(specifiedDomain[1])) domain[1] = allowDataOverflow ? specifiedDomain[1] : Math.max(specifiedDomain[1], dataDomain[1]); else if (MAX_VALUE_REG.test(specifiedDomain[1])) {
+            var _value = +MAX_VALUE_REG.exec(specifiedDomain[1])[1];
+            domain[1] = dataDomain[1] + _value;
+        } else __WEBPACK_IMPORTED_MODULE_8_lodash_isFunction___default()(specifiedDomain[1]) ? domain[1] = specifiedDomain[1](dataDomain[1]) : domain[1] = dataDomain[1];
+        return domain;
+    }, validateCoordinateInRange = function(coordinate, scale) {
+        if (!scale) return !1;
+        var range = scale.range(), first = range[0], last = range[range.length - 1];
+        return first <= last ? coordinate >= first && coordinate <= last : coordinate >= last && coordinate <= first;
+    }, getBandSizeOfAxis = function(axis, ticks) {
+        if (axis && axis.scale && axis.scale.bandwidth) return axis.scale.bandwidth();
+        if (axis && ticks && ticks.length >= 2) {
+            for (var orderedTicks = __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy___default()(ticks, function(o) {
+                return o.coordinate;
+            }), bandSize = 1 / 0, i = 1, len = orderedTicks.length; i < len; i++) {
+                var cur = orderedTicks[i], prev = orderedTicks[i - 1];
+                bandSize = Math.min((cur.coordinate || 0) - (prev.coordinate || 0), bandSize);
+            }
+            return bandSize === 1 / 0 ? 0 : bandSize;
+        }
+        return 0;
+    }, parseDomainOfCategoryAxis = function(specifiedDomain, calculatedDomain, axisChild) {
+        return specifiedDomain && specifiedDomain.length ? __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual___default()(specifiedDomain, __WEBPACK_IMPORTED_MODULE_9_lodash_get___default()(axisChild, "type.defaultProps.domain")) ? calculatedDomain : specifiedDomain : calculatedDomain;
+    };
+}, function(module, exports) {
+    var core = module.exports = {
+        version: "2.5.3"
+    };
+    "number" == typeof __e && (__e = core);
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function newInterval(floori, offseti, count, field) {
+        function interval(date) {
+            return floori(date = new Date(+date)), date;
+        }
+        return interval.floor = interval, interval.ceil = function(date) {
+            return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date;
+        }, interval.round = function(date) {
+            var d0 = interval(date), d1 = interval.ceil(date);
+            return date - d0 < d1 - date ? d0 : d1;
+        }, interval.offset = function(date, step) {
+            return offseti(date = new Date(+date), null == step ? 1 : Math.floor(step)), date;
+        }, interval.range = function(start, stop, step) {
+            var previous, range = [];
+            if (start = interval.ceil(start), step = null == step ? 1 : Math.floor(step), !(start < stop && step > 0)) return range;
+            do {
+                range.push(previous = new Date(+start)), offseti(start, step), floori(start);
+            } while (previous < start && start < stop);
+            return range;
+        }, interval.filter = function(test) {
+            return newInterval(function(date) {
+                if (date >= date) for (;floori(date), !test(date); ) date.setTime(date - 1);
+            }, function(date, step) {
+                if (date >= date) if (step < 0) for (;++step <= 0; ) for (;offseti(date, -1), !test(date); ) ; else for (;--step >= 0; ) for (;offseti(date, 1), 
+                !test(date); ) ;
+            });
+        }, count && (interval.count = function(start, end) {
+            return t0.setTime(+start), t1.setTime(+end), floori(t0), floori(t1), Math.floor(count(t0, t1));
+        }, interval.every = function(step) {
+            return step = Math.floor(step), isFinite(step) && step > 0 ? step > 1 ? interval.filter(field ? function(d) {
+                return field(d) % step == 0;
+            } : function(d) {
+                return interval.count(0, d) % step == 0;
+            }) : interval : null;
+        }), interval;
+    }
+    __webpack_exports__.a = newInterval;
+    var t0 = new Date(), t1 = new Date();
+}, function(module, exports, __webpack_require__) {
+    var global = __webpack_require__(24), core = __webpack_require__(17), ctx = __webpack_require__(46), hide = __webpack_require__(40), $export = function(type, name, source) {
+        var key, own, out, IS_FORCED = type & $export.F, IS_GLOBAL = type & $export.G, IS_STATIC = type & $export.S, IS_PROTO = type & $export.P, IS_BIND = type & $export.B, IS_WRAP = type & $export.W, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}), expProto = exports.prototype, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {}).prototype;
+        IS_GLOBAL && (source = name);
+        for (key in source) (own = !IS_FORCED && target && void 0 !== target[key]) && key in exports || (out = own ? target[key] : source[key], 
+        exports[key] = IS_GLOBAL && "function" != typeof target[key] ? source[key] : IS_BIND && own ? ctx(out, global) : IS_WRAP && target[key] == out ? function(C) {
+            var F = function(a, b, c) {
+                if (this instanceof C) {
+                    switch (arguments.length) {
+                      case 0:
+                        return new C();
+
+                      case 1:
+                        return new C(a);
+
+                      case 2:
+                        return new C(a, b);
+                    }
+                    return new C(a, b, c);
+                }
+                return C.apply(this, arguments);
+            };
+            return F.prototype = C.prototype, F;
+        }(out) : IS_PROTO && "function" == typeof out ? ctx(Function.call, out) : out, IS_PROTO && ((exports.virtual || (exports.virtual = {}))[key] = out, 
+        type & $export.R && expProto && !expProto[key] && hide(expProto, key, out)));
+    };
+    $export.F = 1, $export.G = 2, $export.S = 4, $export.P = 8, $export.B = 16, $export.W = 32, 
+    $export.U = 64, $export.R = 128, module.exports = $export;
+}, function(module, exports) {
+    function isNil(value) {
+        return null == value;
+    }
+    module.exports = isNil;
+}, function(module, exports, __webpack_require__) {
+    var store = __webpack_require__(139)("wks"), uid = __webpack_require__(99), Symbol = __webpack_require__(24).Symbol, USE_SYMBOL = "function" == typeof Symbol;
+    (module.exports = function(name) {
+        return store[name] || (store[name] = USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)("Symbol." + name));
+    }).store = store;
+}, function(module, exports, __webpack_require__) {
+    var anObject = __webpack_require__(47), IE8_DOM_DEFINE = __webpack_require__(206), toPrimitive = __webpack_require__(133), dP = Object.defineProperty;
+    exports.f = __webpack_require__(25) ? Object.defineProperty : function(O, P, Attributes) {
+        if (anObject(O), P = toPrimitive(P, !0), anObject(Attributes), IE8_DOM_DEFINE) try {
+            return dP(O, P, Attributes);
+        } catch (e) {}
+        if ("get" in Attributes || "set" in Attributes) throw TypeError("Accessors not supported!");
+        return "value" in Attributes && (O[P] = Attributes.value), O;
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _defineProperty(obj, key, value) {
+        return key in obj ? Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    }
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return RADIAN;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return polarToCartesian;
+    }), __webpack_require__.d(__webpack_exports__, "c", function() {
+        return getMaxRadius;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return formatAxisMap;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return inRangeOfSector;
+    });
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1__DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_2__ChartUtils__ = __webpack_require__(16), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, RADIAN = Math.PI / 180, radianToDegree = function(angleInRadian) {
+        return 180 * angleInRadian / Math.PI;
+    }, polarToCartesian = function(cx, cy, radius, angle) {
+        return {
+            x: cx + Math.cos(-RADIAN * angle) * radius,
+            y: cy + Math.sin(-RADIAN * angle) * radius
+        };
+    }, getMaxRadius = function(width, height) {
+        var offset = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {
+            top: 0,
+            right: 0,
+            bottom: 0,
+            left: 0
+        };
+        return Math.min(Math.abs(width - (offset.left || 0) - (offset.right || 0)), Math.abs(height - (offset.top || 0) - (offset.bottom || 0))) / 2;
+    }, formatAxisMap = function(props, axisMap, offset, axisType, chartName) {
+        var width = props.width, height = props.height, startAngle = props.startAngle, endAngle = props.endAngle, cx = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.d)(props.cx, width, width / 2), cy = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.d)(props.cy, height, height / 2), maxRadius = getMaxRadius(width, height, offset), innerRadius = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.d)(props.innerRadius, maxRadius, 0), outerRadius = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.d)(props.outerRadius, maxRadius, .8 * maxRadius);
+        return Object.keys(axisMap).reduce(function(result, id) {
+            var axis = axisMap[id], domain = axis.domain, reversed = axis.reversed, range = void 0;
+            __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(axis.range) ? ("angleAxis" === axisType ? range = [ startAngle, endAngle ] : "radiusAxis" === axisType && (range = [ innerRadius, outerRadius ]), 
+            reversed && (range = [ range[1], range[0] ])) : (range = axis.range, startAngle = range[0], 
+            endAngle = range[1]);
+            var _parseScale = Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.A)(axis, chartName), realScaleType = _parseScale.realScaleType, scale = _parseScale.scale;
+            scale.domain(domain).range(range), Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.c)(scale);
+            var ticks = Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.v)(scale, _extends({}, axis, {
+                realScaleType: realScaleType
+            })), finalAxis = _extends({}, axis, ticks, {
+                range: range,
+                radius: outerRadius,
+                realScaleType: realScaleType,
+                scale: scale,
+                cx: cx,
+                cy: cy,
+                innerRadius: innerRadius,
+                outerRadius: outerRadius,
+                startAngle: startAngle,
+                endAngle: endAngle
+            });
+            return _extends({}, result, _defineProperty({}, id, finalAxis));
+        }, {});
+    }, distanceBetweenPoints = function(point, anotherPoint) {
+        var x1 = point.x, y1 = point.y, x2 = anotherPoint.x, y2 = anotherPoint.y;
+        return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
+    }, getAngleOfPoint = function(_ref, _ref2) {
+        var x = _ref.x, y = _ref.y, cx = _ref2.cx, cy = _ref2.cy, radius = distanceBetweenPoints({
+            x: x,
+            y: y
+        }, {
+            x: cx,
+            y: cy
+        });
+        if (radius <= 0) return {
+            radius: radius
+        };
+        var cos = (x - cx) / radius, angleInRadian = Math.acos(cos);
+        return y > cy && (angleInRadian = 2 * Math.PI - angleInRadian), {
+            radius: radius,
+            angle: radianToDegree(angleInRadian),
+            angleInRadian: angleInRadian
+        };
+    }, formatAngleOfSector = function(_ref3) {
+        var startAngle = _ref3.startAngle, endAngle = _ref3.endAngle, startCnt = Math.floor(startAngle / 360), endCnt = Math.floor(endAngle / 360), min = Math.min(startCnt, endCnt);
+        return {
+            startAngle: startAngle - 360 * min,
+            endAngle: endAngle - 360 * min
+        };
+    }, reverseFormatAngleOfSetor = function(angle, _ref4) {
+        var startAngle = _ref4.startAngle, endAngle = _ref4.endAngle, startCnt = Math.floor(startAngle / 360), endCnt = Math.floor(endAngle / 360);
+        return angle + 360 * Math.min(startCnt, endCnt);
+    }, inRangeOfSector = function(_ref5, sector) {
+        var x = _ref5.x, y = _ref5.y, _getAngleOfPoint = getAngleOfPoint({
+            x: x,
+            y: y
+        }, sector), radius = _getAngleOfPoint.radius, angle = _getAngleOfPoint.angle, innerRadius = sector.innerRadius, outerRadius = sector.outerRadius;
+        if (radius < innerRadius || radius > outerRadius) return !1;
+        if (0 === radius) return !0;
+        var _formatAngleOfSector = formatAngleOfSector(sector), startAngle = _formatAngleOfSector.startAngle, endAngle = _formatAngleOfSector.endAngle, formatAngle = angle, inRange = void 0;
+        if (startAngle <= endAngle) {
+            for (;formatAngle > endAngle; ) formatAngle -= 360;
+            for (;formatAngle < startAngle; ) formatAngle += 360;
+            inRange = formatAngle >= startAngle && formatAngle <= endAngle;
+        } else {
+            for (;formatAngle > startAngle; ) formatAngle -= 360;
+            for (;formatAngle < endAngle; ) formatAngle += 360;
+            inRange = formatAngle >= endAngle && formatAngle <= startAngle;
+        }
+        return inRange ? _extends({}, sector, {
+            radius: radius,
+            angle: reverseFormatAngleOfSetor(formatAngle, sector)
+        }) : null;
+    };
+}, function(module, exports) {
+    var global = module.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")();
+    "number" == typeof __g && (__g = global);
+}, function(module, exports, __webpack_require__) {
+    module.exports = !__webpack_require__(48)(function() {
+        return 7 != Object.defineProperty({}, "a", {
+            get: function() {
+                return 7;
+            }
+        }).a;
+    });
+}, function(module, exports, __webpack_require__) {
+    module.exports = {
+        default: __webpack_require__(355),
+        __esModule: !0
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0, exports.default = function(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0;
+    var _defineProperty = __webpack_require__(142), _defineProperty2 = function(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }(_defineProperty);
+    exports.default = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), (0, _defineProperty2.default)(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }();
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0;
+    var _typeof2 = __webpack_require__(101), _typeof3 = function(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }(_typeof2);
+    exports.default = function(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" !== (void 0 === call ? "undefined" : (0, _typeof3.default)(call)) && "function" != typeof call ? self : call;
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    exports.__esModule = !0;
+    var _setPrototypeOf = __webpack_require__(372), _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf), _create = __webpack_require__(376), _create2 = _interopRequireDefault(_create), _typeof2 = __webpack_require__(101), _typeof3 = _interopRequireDefault(_typeof2);
+    exports.default = function(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + (void 0 === superClass ? "undefined" : (0, 
+        _typeof3.default)(superClass)));
+        subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (_setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass);
+    };
+}, function(module, exports) {
+    function isObject(value) {
+        var type = typeof value;
+        return null != value && ("object" == type || "function" == type);
+    }
+    module.exports = isObject;
+}, function(module, exports, __webpack_require__) {
+    var freeGlobal = __webpack_require__(243), freeSelf = "object" == typeof self && self && self.Object === Object && self, root = freeGlobal || freeSelf || Function("return this")();
+    module.exports = root;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    Object.defineProperty(exports, "__esModule", {
+        value: !0
+    }), exports.translateStyle = exports.AnimateGroup = exports.configBezier = exports.configSpring = void 0;
+    var _Animate = __webpack_require__(264), _Animate2 = _interopRequireDefault(_Animate), _easing = __webpack_require__(277), _util = __webpack_require__(122), _AnimateGroup = __webpack_require__(681), _AnimateGroup2 = _interopRequireDefault(_AnimateGroup);
+    exports.configSpring = _easing.configSpring, exports.configBezier = _easing.configBezier, 
+    exports.AnimateGroup = _AnimateGroup2.default, exports.translateStyle = _util.translateStyle, 
+    exports.default = _Animate2.default;
+}, function(module, exports, __webpack_require__) {
+    function isEqual(value, other) {
+        return baseIsEqual(value, other);
+    }
+    var baseIsEqual = __webpack_require__(177);
+    module.exports = isEqual;
+}, function(module, exports) {
+    module.exports = function(it) {
+        return "object" == typeof it ? null !== it : "function" == typeof it;
+    };
+}, function(module, exports) {
+    function isObjectLike(value) {
+        return null != value && "object" == typeof value;
+    }
+    module.exports = isObjectLike;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    var __WEBPACK_IMPORTED_MODULE_0__src_bisect__ = __webpack_require__(293);
+    __webpack_require__.d(__webpack_exports__, "b", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_bisect__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_1__src_ascending__ = __webpack_require__(64);
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return __WEBPACK_IMPORTED_MODULE_1__src_ascending__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_2__src_bisector__ = __webpack_require__(294);
+    __webpack_require__.d(__webpack_exports__, "c", function() {
+        return __WEBPACK_IMPORTED_MODULE_2__src_bisector__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_18__src_quantile__ = (__webpack_require__(707), __webpack_require__(708), 
+    __webpack_require__(296), __webpack_require__(298), __webpack_require__(709), __webpack_require__(712), 
+    __webpack_require__(713), __webpack_require__(302), __webpack_require__(714), __webpack_require__(715), 
+    __webpack_require__(716), __webpack_require__(717), __webpack_require__(303), __webpack_require__(295), 
+    __webpack_require__(718), __webpack_require__(184));
+    __webpack_require__.d(__webpack_exports__, "d", function() {
+        return __WEBPACK_IMPORTED_MODULE_18__src_quantile__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_19__src_range__ = __webpack_require__(300);
+    __webpack_require__.d(__webpack_exports__, "e", function() {
+        return __WEBPACK_IMPORTED_MODULE_19__src_range__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_23__src_ticks__ = (__webpack_require__(719), __webpack_require__(720), 
+    __webpack_require__(721), __webpack_require__(301));
+    __webpack_require__.d(__webpack_exports__, "h", function() {
+        return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.a;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.b;
+    }), __webpack_require__.d(__webpack_exports__, "g", function() {
+        return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.c;
+    });
+    __webpack_require__(304), __webpack_require__(297), __webpack_require__(722);
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_require__.d(__webpack_exports__, "d", function() {
+        return durationSecond;
+    }), __webpack_require__.d(__webpack_exports__, "c", function() {
+        return durationMinute;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return durationHour;
+    }), __webpack_require__.d(__webpack_exports__, "a", function() {
+        return durationDay;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return durationWeek;
+    });
+    var durationSecond = 1e3, durationMinute = 6e4, durationHour = 36e5, durationDay = 864e5, durationWeek = 6048e5;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function makeEmptyFunction(arg) {
+        return function() {
+            return arg;
+        };
+    }
+    var emptyFunction = function() {};
+    emptyFunction.thatReturns = makeEmptyFunction, emptyFunction.thatReturnsFalse = makeEmptyFunction(!1), 
+    emptyFunction.thatReturnsTrue = makeEmptyFunction(!0), emptyFunction.thatReturnsNull = makeEmptyFunction(null), 
+    emptyFunction.thatReturnsThis = function() {
+        return this;
+    }, emptyFunction.thatReturnsArgument = function(arg) {
+        return arg;
+    }, module.exports = emptyFunction;
+}, function(module, exports, __webpack_require__) {
+    var dP = __webpack_require__(22), createDesc = __webpack_require__(71);
+    module.exports = __webpack_require__(25) ? function(object, key, value) {
+        return dP.f(object, key, createDesc(1, value));
+    } : function(object, key, value) {
+        return object[key] = value, object;
+    };
+}, function(module, exports, __webpack_require__) {
+    function baseGetTag(value) {
+        return null == value ? void 0 === value ? undefinedTag : nullTag : symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    var Symbol = __webpack_require__(78), getRawTag = __webpack_require__(522), objectToString = __webpack_require__(523), nullTag = "[object Null]", undefinedTag = "[object Undefined]", symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    module.exports = baseGetTag;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+            return arr2;
+        }
+        return Array.from(arr);
+    }
+    function Label(props) {
+        var viewBox = props.viewBox, position = props.position, value = props.value, children = props.children, content = props.content, _props$className = props.className, className = void 0 === _props$className ? "" : _props$className;
+        if (!viewBox || __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(value) && __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(children) && !Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(content) && !__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(content)) return null;
+        if (Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(content)) return Object(__WEBPACK_IMPORTED_MODULE_3_react__.cloneElement)(content, props);
+        var label = void 0;
+        if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(content)) {
+            if (label = content(props), Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(label)) return label;
+        } else label = getLabel(props);
+        var isPolarLabel = isPolar(viewBox), attrs = Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.k)(props);
+        if (isPolarLabel && ("insideStart" === position || "insideEnd" === position || "end" === position)) return renderRadialLabel(props, label, attrs);
+        var positionAttrs = isPolarLabel ? getAttrsOfPolarLabel(props) : getAttrsOfCartesianLabel(props);
+        return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_6__Text__.a, _extends({
+            className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-label", className)
+        }, attrs, positionAttrs), label);
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_isObject__ = __webpack_require__(31), __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_3_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_3_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react__), __WEBPACK_IMPORTED_MODULE_4_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_4_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_prop_types__), __WEBPACK_IMPORTED_MODULE_5_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_5_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_classnames__), __WEBPACK_IMPORTED_MODULE_6__Text__ = __webpack_require__(54), __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_8__util_DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__ = __webpack_require__(23), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, cartesianViewBoxShape = __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.shape({
+        x: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        y: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        width: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        height: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number
+    }), polarViewBoxShape = __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.shape({
+        cx: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        cy: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        innerRadius: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        outerRadius: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        startAngle: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        endAngle: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number
+    }), propTypes = {
+        viewBox: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ cartesianViewBoxShape, polarViewBoxShape ]),
+        formatter: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func,
+        value: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string ]),
+        offset: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number,
+        position: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOf([ "top", "left", "right", "bottom", "inside", "outside", "insideLeft", "insideRight", "insideTop", "insideBottom", "insideTopLeft", "insideBottomLeft", "insideTopRight", "insideBottomRight", "insideStart", "insideEnd", "end", "center" ]),
+        children: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.node ]),
+        className: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string,
+        content: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.element, __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func ])
+    }, defaultProps = {
+        offset: 5
+    }, getLabel = function(props) {
+        var value = props.value, formatter = props.formatter, label = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(props.children) ? value : props.children;
+        return __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(formatter) ? formatter(label) : label;
+    }, getDeltaAngle = function(startAngle, endAngle) {
+        return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.j)(endAngle - startAngle) * Math.min(Math.abs(endAngle - startAngle), 360);
+    }, renderRadialLabel = function(labelProps, label, attrs) {
+        var position = labelProps.position, viewBox = labelProps.viewBox, offset = labelProps.offset, className = labelProps.className, cx = viewBox.cx, cy = viewBox.cy, innerRadius = viewBox.innerRadius, outerRadius = viewBox.outerRadius, startAngle = viewBox.startAngle, endAngle = viewBox.endAngle, clockWise = viewBox.clockWise, radius = (innerRadius + outerRadius) / 2, deltaAngle = getDeltaAngle(startAngle, endAngle), sign = deltaAngle >= 0 ? 1 : -1, labelAngle = void 0, direction = void 0;
+        "insideStart" === position ? (labelAngle = startAngle + sign * offset, direction = clockWise) : "insideEnd" === position ? (labelAngle = endAngle - sign * offset, 
+        direction = !clockWise) : "end" === position && (labelAngle = endAngle + sign * offset, 
+        direction = clockWise), direction = deltaAngle <= 0 ? direction : !direction;
+        var startPoint = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, radius, labelAngle), endPoint = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, radius, labelAngle + 359 * (direction ? 1 : -1)), path = "M" + startPoint.x + "," + startPoint.y + "\n    A" + radius + "," + radius + ",0,1," + (direction ? 0 : 1) + ",\n    " + endPoint.x + "," + endPoint.y, id = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(labelProps.id) ? Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.k)("recharts-radial-line-") : labelProps.id;
+        return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("text", _extends({}, attrs, {
+            dominantBaseline: "central",
+            className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-radial-bar-label", className)
+        }), __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("defs", null, __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("path", {
+            id: id,
+            d: path
+        })), __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("textPath", {
+            xlinkHref: "#" + id
+        }, label));
+    }, getAttrsOfPolarLabel = function(props) {
+        var viewBox = props.viewBox, offset = props.offset, position = props.position, cx = viewBox.cx, cy = viewBox.cy, innerRadius = viewBox.innerRadius, outerRadius = viewBox.outerRadius, startAngle = viewBox.startAngle, endAngle = viewBox.endAngle, midAngle = (startAngle + endAngle) / 2;
+        if ("outside" === position) {
+            var _polarToCartesian = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, outerRadius + offset, midAngle), _x = _polarToCartesian.x;
+            return {
+                x: _x,
+                y: _polarToCartesian.y,
+                textAnchor: _x >= cx ? "start" : "end",
+                verticalAnchor: "middle"
+            };
+        }
+        if ("center" === position) return {
+            x: cx,
+            y: cy,
+            textAnchor: "middle",
+            verticalAnchor: "middle"
+        };
+        var r = (innerRadius + outerRadius) / 2, _polarToCartesian2 = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, r, midAngle);
+        return {
+            x: _polarToCartesian2.x,
+            y: _polarToCartesian2.y,
+            textAnchor: "middle",
+            verticalAnchor: "middle"
+        };
+    }, getAttrsOfCartesianLabel = function(props) {
+        var viewBox = props.viewBox, offset = props.offset, position = props.position, x = viewBox.x, y = viewBox.y, width = viewBox.width, height = viewBox.height, sign = height >= 0 ? 1 : -1;
+        return "top" === position ? {
+            x: x + width / 2,
+            y: y - sign * offset,
+            textAnchor: "middle",
+            verticalAnchor: "end"
+        } : "bottom" === position ? {
+            x: x + width / 2,
+            y: y + height + sign * offset,
+            textAnchor: "middle",
+            verticalAnchor: "start"
+        } : "left" === position ? {
+            x: x - offset,
+            y: y + height / 2,
+            textAnchor: "end",
+            verticalAnchor: "middle"
+        } : "right" === position ? {
+            x: x + width + offset,
+            y: y + height / 2,
+            textAnchor: "start",
+            verticalAnchor: "middle"
+        } : "insideLeft" === position ? {
+            x: x + offset,
+            y: y + height / 2,
+            textAnchor: "start",
+            verticalAnchor: "middle"
+        } : "insideRight" === position ? {
+            x: x + width - offset,
+            y: y + height / 2,
+            textAnchor: "end",
+            verticalAnchor: "middle"
+        } : "insideTop" === position ? {
+            x: x + width / 2,
+            y: y + sign * offset,
+            textAnchor: "middle",
+            verticalAnchor: "start"
+        } : "insideBottom" === position ? {
+            x: x + width / 2,
+            y: y + height - sign * offset,
+            textAnchor: "middle",
+            verticalAnchor: "end"
+        } : "insideTopLeft" === position ? {
+            x: x + offset,
+            y: y + sign * offset,
+            textAnchor: "start",
+            verticalAnchor: "start"
+        } : "insideTopRight" === position ? {
+            x: x + width - offset,
+            y: y + sign * offset,
+            textAnchor: "end",
+            verticalAnchor: "start"
+        } : "insideBottomLeft" === position ? {
+            x: x + offset,
+            y: y + height - sign * offset,
+            textAnchor: "start",
+            verticalAnchor: "end"
+        } : "insideBottomRight" === position ? {
+            x: x + width - offset,
+            y: y + height - sign * offset,
+            textAnchor: "end",
+            verticalAnchor: "end"
+        } : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(position) && (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(position.x) || Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.i)(position.x)) && (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(position.y) || Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.i)(position.y)) ? {
+            x: x + Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.d)(position.x, width),
+            y: y + Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.d)(position.y, height),
+            textAnchor: "end",
+            verticalAnchor: "end"
+        } : {
+            x: x + width / 2,
+            y: y + height / 2,
+            textAnchor: "middle",
+            verticalAnchor: "middle"
+        };
+    }, isPolar = function(viewBox) {
+        return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(viewBox.cx);
+    };
+    Label.displayName = "Label", Label.defaultProps = defaultProps, Label.propTypes = propTypes;
+    var parseViewBox = function(props) {
+        var cx = props.cx, cy = props.cy, angle = props.angle, startAngle = props.startAngle, endAngle = props.endAngle, r = props.r, radius = props.radius, innerRadius = props.innerRadius, outerRadius = props.outerRadius, x = props.x, y = props.y, top = props.top, left = props.left, width = props.width, height = props.height, clockWise = props.clockWise;
+        if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(width) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(height)) {
+            if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(x) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(y)) return {
+                x: x,
+                y: y,
+                width: width,
+                height: height
+            };
+            if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(top) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(left)) return {
+                x: top,
+                y: left,
+                width: width,
+                height: height
+            };
+        }
+        return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(x) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(y) ? {
+            x: x,
+            y: y,
+            width: 0,
+            height: 0
+        } : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(cx) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(cy) ? {
+            cx: cx,
+            cy: cy,
+            startAngle: startAngle || angle || 0,
+            endAngle: endAngle || angle || 0,
+            innerRadius: innerRadius || 0,
+            outerRadius: outerRadius || radius || r || 0,
+            clockWise: clockWise
+        } : props.viewBox ? props.viewBox : {};
+    }, parseLabel = function(label, viewBox) {
+        return label ? !0 === label ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, {
+            key: "label-implicit",
+            viewBox: viewBox
+        }) : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, {
+            key: "label-implicit",
+            viewBox: viewBox,
+            value: label
+        }) : Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(label) || __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, {
+            key: "label-implicit",
+            content: label,
+            viewBox: viewBox
+        }) : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, _extends({
+            viewBox: viewBox
+        }, label, {
+            key: "label-implicit"
+        })) : null : null;
+    }, renderCallByParent = function(parentProps, viewBox) {
+        var ckeckPropsLabel = !(arguments.length > 2 && void 0 !== arguments[2]) || arguments[2];
+        if (!parentProps || !parentProps.children && ckeckPropsLabel && !parentProps.label) return null;
+        var children = parentProps.children, parentViewBox = parseViewBox(parentProps), explicitChilren = Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.h)(children, Label).map(function(child, index) {
+            return Object(__WEBPACK_IMPORTED_MODULE_3_react__.cloneElement)(child, {
+                viewBox: viewBox || parentViewBox,
+                key: "label-" + index
+            });
+        });
+        return ckeckPropsLabel ? [ parseLabel(parentProps.label, viewBox || parentViewBox) ].concat(_toConsumableArray(explicitChilren)) : explicitChilren;
+    };
+    Label.parseViewBox = parseViewBox, Label.renderCallByParent = renderCallByParent, 
+    __webpack_exports__.a = Label;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    var __WEBPACK_IMPORTED_MODULE_0__src_color__ = __webpack_require__(187);
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_color__.e;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_color__.g;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_color__.f;
+    });
+    var __WEBPACK_IMPORTED_MODULE_1__src_lab__ = __webpack_require__(730);
+    __webpack_require__.d(__webpack_exports__, "e", function() {
+        return __WEBPACK_IMPORTED_MODULE_1__src_lab__.a;
+    }), __webpack_require__.d(__webpack_exports__, "c", function() {
+        return __WEBPACK_IMPORTED_MODULE_1__src_lab__.b;
+    });
+    var __WEBPACK_IMPORTED_MODULE_2__src_cubehelix__ = __webpack_require__(731);
+    __webpack_require__.d(__webpack_exports__, "b", function() {
+        return __WEBPACK_IMPORTED_MODULE_2__src_cubehelix__.a;
+    });
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+            return arr2;
+        }
+        return Array.from(arr);
+    }
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function LabelList(props) {
+        var data = props.data, valueAccessor = props.valueAccessor, dataKey = props.dataKey, clockWise = props.clockWise, id = props.id, others = _objectWithoutProperties(props, [ "data", "valueAccessor", "dataKey", "clockWise", "id" ]);
+        return data && data.length ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__container_Layer__.a, {
+            className: "recharts-label-list"
+        }, data.map(function(entry, index) {
+            var value = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(dataKey) ? valueAccessor(entry, index) : Object(__WEBPACK_IMPORTED_MODULE_10__util_ChartUtils__.w)(entry && entry.payload, dataKey), idProps = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(id) ? {} : {
+                id: id + "-" + index
+            };
+            return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_7__Label__.a, _extends({}, Object(__WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__.k)(entry), others, idProps, {
+                index: index,
+                value: value,
+                viewBox: __WEBPACK_IMPORTED_MODULE_7__Label__.a.parseViewBox(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(clockWise) ? entry : _extends({}, entry, {
+                    clockWise: clockWise
+                })),
+                key: "label-" + index
+            }));
+        })) : null;
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_isObject__ = __webpack_require__(31), __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_3_lodash_last__ = __webpack_require__(781), __WEBPACK_IMPORTED_MODULE_3_lodash_last___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_last__), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__), __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__), __WEBPACK_IMPORTED_MODULE_7__Label__ = __webpack_require__(42), __WEBPACK_IMPORTED_MODULE_8__container_Layer__ = __webpack_require__(14), __WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_10__util_ChartUtils__ = __webpack_require__(16), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, propTypes = {
+        id: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+        data: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object),
+        valueAccessor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+        clockWise: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
+        dataKey: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func ])
+    }, defaultProps = {
+        valueAccessor: function(entry) {
+            return __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(entry.value) ? __WEBPACK_IMPORTED_MODULE_3_lodash_last___default()(entry.value) : entry.value;
+        }
+    };
+    LabelList.propTypes = propTypes, LabelList.displayName = "LabelList";
+    var parseLabelList = function(label, data) {
+        return label ? !0 === label ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, {
+            key: "labelList-implicit",
+            data: data
+        }) : __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(label) || __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(label) ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, {
+            key: "labelList-implicit",
+            data: data,
+            content: label
+        }) : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(label) ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, _extends({
+            data: data
+        }, label, {
+            key: "labelList-implicit"
+        })) : null : null;
+    }, renderCallByParent = function(parentProps, data) {
+        var ckeckPropsLabel = !(arguments.length > 2 && void 0 !== arguments[2]) || arguments[2];
+        if (!parentProps || !parentProps.children && ckeckPropsLabel && !parentProps.label) return null;
+        var children = parentProps.children, explicitChilren = Object(__WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__.h)(children, LabelList).map(function(child, index) {
+            return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(child, {
+                data: data,
+                key: "labelList-" + index
+            });
+        });
+        return ckeckPropsLabel ? [ parseLabelList(parentProps.label, data) ].concat(_toConsumableArray(explicitChilren)) : explicitChilren;
+    };
+    LabelList.renderCallByParent = renderCallByParent, LabelList.defaultProps = defaultProps, 
+    __webpack_exports__.a = LabelList;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function _defineProperty(obj, key, value) {
+        return key in obj ? Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    }
+    function _toConsumableArray(arr) {
+        if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+            return arr2;
+        }
+        return Array.from(arr);
+    }
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy__ = __webpack_require__(284), __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_sortBy__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_range__ = __webpack_require__(334), __WEBPACK_IMPORTED_MODULE_2_lodash_range___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_range__), __WEBPACK_IMPORTED_MODULE_3_lodash_throttle__ = __webpack_require__(790), __WEBPACK_IMPORTED_MODULE_3_lodash_throttle___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_throttle__), __WEBPACK_IMPORTED_MODULE_4_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__), __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__), __WEBPACK_IMPORTED_MODULE_7_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_7_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_classnames__), __WEBPACK_IMPORTED_MODULE_8__container_Surface__ = __webpack_require__(79), __WEBPACK_IMPORTED_MODULE_9__container_Layer__ = __webpack_require__(14), __WEBPACK_IMPORTED_MODULE_10__component_Tooltip__ = __webpack_require__(121), __WEBPACK_IMPORTED_MODULE_11__component_Legend__ = __webpack_require__(170), __WEBPACK_IMPORTED_MODULE_12__shape_Curve__ = __webpack_require__(66), __WEBPACK_IMPORTED_MODULE_13__shape_Cross__ = __webpack_require__(328), __WEBPACK_IMPORTED_MODULE_14__shape_Sector__ = __webpack_require__(127), __WEBPACK_IMPORTED_MODULE_15__shape_Dot__ = __webpack_require__(56), __WEBPACK_IMPORTED_MODULE_16__shape_Rectangle__ = __webpack_require__(65), __WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__ = __webpack_require__(335), __WEBPACK_IMPORTED_MODULE_19__cartesian_Brush__ = __webpack_require__(333), __WEBPACK_IMPORTED_MODULE_20__util_DOMUtils__ = __webpack_require__(183), __WEBPACK_IMPORTED_MODULE_21__util_DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__ = __webpack_require__(23), __WEBPACK_IMPORTED_MODULE_24__util_PureRender__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_25__util_Events__ = __webpack_require__(791), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), ORIENT_MAP = {
+        xAxis: [ "bottom", "top" ],
+        yAxis: [ "left", "right" ]
+    }, originCoordinate = {
+        x: 0,
+        y: 0
+    }, generateCategoricalChart = function(_ref) {
+        var _class, _temp, _initialiseProps, chartName = _ref.chartName, GraphicalChild = _ref.GraphicalChild, _ref$eventType = _ref.eventType, eventType = void 0 === _ref$eventType ? "axis" : _ref$eventType, axisComponents = _ref.axisComponents, legendContent = _ref.legendContent, formatAxisMap = _ref.formatAxisMap, defaultProps = _ref.defaultProps, propTypes = _ref.propTypes;
+        return _temp = _class = function(_Component) {
+            function CategoricalChartWrapper(props) {
+                _classCallCheck(this, CategoricalChartWrapper);
+                var _this = _possibleConstructorReturn(this, (CategoricalChartWrapper.__proto__ || Object.getPrototypeOf(CategoricalChartWrapper)).call(this, props));
+                _initialiseProps.call(_this);
+                var defaultState = _this.constructor.createDefaultState(props);
+                return _this.state = _extends({}, defaultState, {
+                    updateId: 0
+                }, _this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({
+                    props: props
+                }, defaultState, {
+                    updateId: 0
+                }))), _this.uniqueChartId = __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(props.id) ? Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.k)("recharts") : props.id, 
+                props.throttleDelay && (_this.triggeredAfterMouseMove = __WEBPACK_IMPORTED_MODULE_3_lodash_throttle___default()(_this.triggeredAfterMouseMove, props.throttleDelay)), 
+                _this;
+            }
+            return _inherits(CategoricalChartWrapper, _Component), _createClass(CategoricalChartWrapper, [ {
+                key: "componentDidMount",
+                value: function() {
+                    __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(this.props.syncId) || this.addListener();
+                }
+            }, {
+                key: "componentWillReceiveProps",
+                value: function(nextProps) {
+                    var _props = this.props, data = _props.data, children = _props.children, width = _props.width, height = _props.height, layout = _props.layout, stackOffset = _props.stackOffset, margin = _props.margin, updateId = this.state.updateId;
+                    if (nextProps.data === data && nextProps.width === width && nextProps.height === height && nextProps.layout === layout && nextProps.stackOffset === stackOffset && Object(__WEBPACK_IMPORTED_MODULE_24__util_PureRender__.b)(nextProps.margin, margin)) {
+                        if (!Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.m)(nextProps.children, children)) {
+                            var hasGlobalData = !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(nextProps.data), newUpdateId = hasGlobalData ? updateId : updateId + 1, _state = this.state, dataStartIndex = _state.dataStartIndex, dataEndIndex = _state.dataEndIndex, _defaultState = _extends({}, this.constructor.createDefaultState(nextProps), {
+                                dataEndIndex: dataEndIndex,
+                                dataStartIndex: dataStartIndex
+                            });
+                            this.setState(_extends({}, _defaultState, {
+                                updateId: newUpdateId
+                            }, this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({
+                                props: nextProps
+                            }, _defaultState, {
+                                updateId: newUpdateId
+                            }))));
+                        }
+                    } else {
+                        var defaultState = this.constructor.createDefaultState(nextProps);
+                        this.setState(_extends({}, defaultState, {
+                            updateId: updateId + 1
+                        }, this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({
+                            props: nextProps
+                        }, defaultState, {
+                            updateId: updateId + 1
+                        }))));
+                    }
+                    __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(this.props.syncId) && !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(nextProps.syncId) && this.addListener(), 
+                    !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(this.props.syncId) && __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(nextProps.syncId) && this.removeListener();
+                }
+            }, {
+                key: "componentWillUnmount",
+                value: function() {
+                    __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(this.props.syncId) || this.removeListener(), 
+                    "function" == typeof this.triggeredAfterMouseMove.cancel && this.triggeredAfterMouseMove.cancel();
+                }
+            }, {
+                key: "getAxisMap",
+                value: function(props, _ref2) {
+                    var _ref2$axisType = _ref2.axisType, axisType = void 0 === _ref2$axisType ? "xAxis" : _ref2$axisType, AxisComp = _ref2.AxisComp, graphicalItems = _ref2.graphicalItems, stackGroups = _ref2.stackGroups, dataStartIndex = _ref2.dataStartIndex, dataEndIndex = _ref2.dataEndIndex, children = props.children, axisIdKey = axisType + "Id", axes = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.h)(children, AxisComp), axisMap = {};
+                    return axes && axes.length ? axisMap = this.getAxisMapByAxes(props, {
+                        axes: axes,
+                        graphicalItems: graphicalItems,
+                        axisType: axisType,
+                        axisIdKey: axisIdKey,
+                        stackGroups: stackGroups,
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex
+                    }) : graphicalItems && graphicalItems.length && (axisMap = this.getAxisMapByItems(props, {
+                        Axis: AxisComp,
+                        graphicalItems: graphicalItems,
+                        axisType: axisType,
+                        axisIdKey: axisIdKey,
+                        stackGroups: stackGroups,
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex
+                    })), axisMap;
+                }
+            }, {
+                key: "getAxisMapByAxes",
+                value: function(props, _ref3) {
+                    var _this2 = this, axes = _ref3.axes, graphicalItems = _ref3.graphicalItems, axisType = _ref3.axisType, axisIdKey = _ref3.axisIdKey, stackGroups = _ref3.stackGroups, dataStartIndex = _ref3.dataStartIndex, dataEndIndex = _ref3.dataEndIndex, layout = props.layout, children = props.children, stackOffset = props.stackOffset, isCategorial = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.x)(layout, axisType);
+                    return axes.reduce(function(result, child) {
+                        var _child$props = child.props, type = _child$props.type, dataKey = _child$props.dataKey, allowDataOverflow = _child$props.allowDataOverflow, allowDuplicatedCategory = _child$props.allowDuplicatedCategory, scale = _child$props.scale, ticks = _child$props.ticks, axisId = child.props[axisIdKey], displayedData = _this2.constructor.getDisplayedData(props, {
+                            graphicalItems: graphicalItems.filter(function(item) {
+                                return item.props[axisIdKey] === axisId;
+                            }),
+                            dataStartIndex: dataStartIndex,
+                            dataEndIndex: dataEndIndex
+                        }), len = displayedData.length;
+                        if (!result[axisId]) {
+                            var domain = void 0, duplicateDomain = void 0, categoricalDomain = void 0;
+                            if (dataKey) {
+                                if (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.n)(displayedData, dataKey, type), 
+                                "category" === type && isCategorial) {
+                                    var duplicate = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.e)(domain);
+                                    allowDuplicatedCategory && duplicate ? (duplicateDomain = domain, domain = __WEBPACK_IMPORTED_MODULE_2_lodash_range___default()(0, len)) : allowDuplicatedCategory || (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.y)(child.props.domain, domain, child).reduce(function(finalDomain, entry) {
+                                        return finalDomain.indexOf(entry) >= 0 ? finalDomain : [].concat(_toConsumableArray(finalDomain), [ entry ]);
+                                    }, []));
+                                } else if ("category" === type) domain = allowDuplicatedCategory ? domain.filter(function(entry) {
+                                    return "" !== entry && !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(entry);
+                                }) : Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.y)(child.props.domain, domain, child).reduce(function(finalDomain, entry) {
+                                    return finalDomain.indexOf(entry) >= 0 || "" === entry || __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(entry) ? finalDomain : [].concat(_toConsumableArray(finalDomain), [ entry ]);
+                                }, []); else if ("number" === type) {
+                                    var errorBarsDomain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.z)(displayedData, graphicalItems.filter(function(item) {
+                                        return item.props[axisIdKey] === axisId && !item.props.hide;
+                                    }), dataKey, axisType);
+                                    errorBarsDomain && (domain = errorBarsDomain);
+                                }
+                                !isCategorial || "number" !== type && "auto" === scale || (categoricalDomain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.n)(displayedData, dataKey, "category"));
+                            } else domain = isCategorial ? __WEBPACK_IMPORTED_MODULE_2_lodash_range___default()(0, len) : stackGroups && stackGroups[axisId] && stackGroups[axisId].hasStack && "number" === type ? "expand" === stackOffset ? [ 0, 1 ] : Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.p)(stackGroups[axisId].stackGroups, dataStartIndex, dataEndIndex) : Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.o)(displayedData, graphicalItems.filter(function(item) {
+                                return item.props[axisIdKey] === axisId && !item.props.hide;
+                            }), type, !0);
+                            return "number" === type && (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.e)(children, domain, axisId, axisType, ticks), 
+                            child.props.domain && (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.B)(child.props.domain, domain, allowDataOverflow))), 
+                            _extends({}, result, _defineProperty({}, axisId, _extends({}, child.props, {
+                                axisType: axisType,
+                                domain: domain,
+                                categoricalDomain: categoricalDomain,
+                                duplicateDomain: duplicateDomain,
+                                originalDomain: child.props.domain,
+                                isCategorial: isCategorial,
+                                layout: layout
+                            })));
+                        }
+                        return result;
+                    }, {});
+                }
+            }, {
+                key: "getAxisMapByItems",
+                value: function(props, _ref4) {
+                    var graphicalItems = _ref4.graphicalItems, Axis = _ref4.Axis, axisType = _ref4.axisType, axisIdKey = _ref4.axisIdKey, stackGroups = _ref4.stackGroups, dataStartIndex = _ref4.dataStartIndex, dataEndIndex = _ref4.dataEndIndex, layout = props.layout, children = props.children, displayedData = this.constructor.getDisplayedData(props, {
+                        graphicalItems: graphicalItems,
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex
+                    }), len = displayedData.length, isCategorial = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.x)(layout, axisType), index = -1;
+                    return graphicalItems.reduce(function(result, child) {
+                        var axisId = child.props[axisIdKey];
+                        if (!result[axisId]) {
+                            index++;
+                            var domain = void 0;
+                            return isCategorial ? domain = __WEBPACK_IMPORTED_MODULE_2_lodash_range___default()(0, len) : stackGroups && stackGroups[axisId] && stackGroups[axisId].hasStack ? (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.p)(stackGroups[axisId].stackGroups, dataStartIndex, dataEndIndex), 
+                            domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.e)(children, domain, axisId, axisType)) : (domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.B)(Axis.defaultProps.domain, Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.o)(displayedData, graphicalItems.filter(function(item) {
+                                return item.props[axisIdKey] === axisId && !item.props.hide;
+                            }), "number"), Axis.defaultProps.allowDataOverflow), domain = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.e)(children, domain, axisId, axisType)), 
+                            _extends({}, result, _defineProperty({}, axisId, _extends({
+                                axisType: axisType
+                            }, Axis.defaultProps, {
+                                hide: !0,
+                                orientation: ORIENT_MAP[axisType] && ORIENT_MAP[axisType][index % 2],
+                                domain: domain,
+                                originalDomain: Axis.defaultProps.domain,
+                                isCategorial: isCategorial,
+                                layout: layout
+                            })));
+                        }
+                        return result;
+                    }, {});
+                }
+            }, {
+                key: "getActiveCoordinate",
+                value: function(tooltipTicks, activeIndex, rangeObj) {
+                    var layout = this.props.layout, entry = tooltipTicks.find(function(tick) {
+                        return tick && tick.index === activeIndex;
+                    });
+                    if (entry) {
+                        if ("horizontal" === layout) return {
+                            x: entry.coordinate,
+                            y: rangeObj.y
+                        };
+                        if ("vertical" === layout) return {
+                            x: rangeObj.x,
+                            y: entry.coordinate
+                        };
+                        if ("centric" === layout) {
+                            var _angle = entry.coordinate, _radius = rangeObj.radius;
+                            return _extends({}, rangeObj, Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(rangeObj.cx, rangeObj.cy, _radius, _angle), {
+                                angle: _angle,
+                                radius: _radius
+                            });
+                        }
+                        var radius = entry.coordinate, angle = rangeObj.angle;
+                        return _extends({}, rangeObj, Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(rangeObj.cx, rangeObj.cy, radius, angle), {
+                            angle: angle,
+                            radius: radius
+                        });
+                    }
+                    return originCoordinate;
+                }
+            }, {
+                key: "getMouseInfo",
+                value: function(event) {
+                    if (!this.container) return null;
+                    var containerOffset = Object(__WEBPACK_IMPORTED_MODULE_20__util_DOMUtils__.b)(this.container), e = Object(__WEBPACK_IMPORTED_MODULE_20__util_DOMUtils__.a)(event, containerOffset), rangeObj = this.inRange(e.chartX, e.chartY);
+                    if (!rangeObj) return null;
+                    var _state2 = this.state, xAxisMap = _state2.xAxisMap, yAxisMap = _state2.yAxisMap;
+                    if ("axis" !== eventType && xAxisMap && yAxisMap) {
+                        var xScale = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(xAxisMap).scale, yScale = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(yAxisMap).scale, xValue = xScale && xScale.invert ? xScale.invert(e.chartX) : null, yValue = yScale && yScale.invert ? yScale.invert(e.chartY) : null;
+                        return _extends({}, e, {
+                            xValue: xValue,
+                            yValue: yValue
+                        });
+                    }
+                    var _state3 = this.state, ticks = _state3.orderedTooltipTicks, axis = _state3.tooltipAxis, tooltipTicks = _state3.tooltipTicks, pos = this.calculateTooltipPos(rangeObj), activeIndex = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.b)(pos, ticks, tooltipTicks, axis);
+                    if (activeIndex >= 0 && tooltipTicks) {
+                        var activeLabel = tooltipTicks[activeIndex] && tooltipTicks[activeIndex].value, activePayload = this.getTooltipContent(activeIndex, activeLabel), activeCoordinate = this.getActiveCoordinate(ticks, activeIndex, rangeObj);
+                        return _extends({}, e, {
+                            activeTooltipIndex: activeIndex,
+                            activeLabel: activeLabel,
+                            activePayload: activePayload,
+                            activeCoordinate: activeCoordinate
+                        });
+                    }
+                    return null;
+                }
+            }, {
+                key: "getTooltipContent",
+                value: function(activeIndex, activeLabel) {
+                    var _state4 = this.state, graphicalItems = _state4.graphicalItems, tooltipAxis = _state4.tooltipAxis, displayedData = this.constructor.getDisplayedData(this.props, this.state);
+                    return activeIndex < 0 || !graphicalItems || !graphicalItems.length || activeIndex >= displayedData.length ? null : graphicalItems.reduce(function(result, child) {
+                        if (child.props.hide) return result;
+                        var _child$props2 = child.props, dataKey = _child$props2.dataKey, name = _child$props2.name, unit = _child$props2.unit, formatter = _child$props2.formatter, data = _child$props2.data, payload = void 0;
+                        return payload = tooltipAxis.dataKey && !tooltipAxis.allowDuplicatedCategory ? Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.a)(data || displayedData, tooltipAxis.dataKey, activeLabel) : displayedData[activeIndex], 
+                        payload ? [].concat(_toConsumableArray(result), [ _extends({}, Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.k)(child), {
+                            dataKey: dataKey,
+                            unit: unit,
+                            formatter: formatter,
+                            name: name || dataKey,
+                            color: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.r)(child),
+                            value: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.w)(payload, dataKey),
+                            payload: payload
+                        }) ]) : result;
+                    }, []);
+                }
+            }, {
+                key: "getFormatItems",
+                value: function(props, currentState) {
+                    var _this3 = this, graphicalItems = currentState.graphicalItems, stackGroups = currentState.stackGroups, offset = currentState.offset, updateId = currentState.updateId, dataStartIndex = currentState.dataStartIndex, dataEndIndex = currentState.dataEndIndex, barSize = props.barSize, layout = props.layout, barGap = props.barGap, barCategoryGap = props.barCategoryGap, globalMaxBarSize = props.maxBarSize, _getAxisNameByLayout = this.getAxisNameByLayout(layout), numericAxisName = _getAxisNameByLayout.numericAxisName, cateAxisName = _getAxisNameByLayout.cateAxisName, hasBar = this.constructor.hasBar(graphicalItems), sizeList = hasBar && Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.i)({
+                        barSize: barSize,
+                        stackGroups: stackGroups
+                    }), formatedItems = [];
+                    return graphicalItems.forEach(function(item, index) {
+                        var displayedData = _this3.constructor.getDisplayedData(props, {
+                            dataStartIndex: dataStartIndex,
+                            dataEndIndex: dataEndIndex
+                        }, item), _item$props = item.props, dataKey = _item$props.dataKey, childMaxBarSize = _item$props.maxBarSize, numericAxisId = item.props[numericAxisName + "Id"], cateAxisId = item.props[cateAxisName + "Id"], axisObj = axisComponents.reduce(function(result, entry) {
+                            var _extends4, axisMap = currentState[entry.axisType + "Map"], id = item.props[entry.axisType + "Id"], axis = axisMap && axisMap[id];
+                            return _extends({}, result, (_extends4 = {}, _defineProperty(_extends4, entry.axisType, axis), 
+                            _defineProperty(_extends4, entry.axisType + "Ticks", Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(axis)), 
+                            _extends4));
+                        }, {}), cateAxis = axisObj[cateAxisName], cateTicks = axisObj[cateAxisName + "Ticks"], stackedData = stackGroups && stackGroups[numericAxisId] && stackGroups[numericAxisId].hasStack && Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.t)(item, stackGroups[numericAxisId].stackGroups), bandSize = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.g)(cateAxis, cateTicks), maxBarSize = __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize, barPosition = hasBar && Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.h)({
+                            barGap: barGap,
+                            barCategoryGap: barCategoryGap,
+                            bandSize: bandSize,
+                            sizeList: sizeList[cateAxisId],
+                            maxBarSize: maxBarSize
+                        }), componsedFn = item && item.type && item.type.getComposedData;
+                        if (componsedFn) {
+                            var _extends5;
+                            formatedItems.push({
+                                props: _extends({}, componsedFn(_extends({}, axisObj, {
+                                    displayedData: displayedData,
+                                    props: props,
+                                    dataKey: dataKey,
+                                    item: item,
+                                    bandSize: bandSize,
+                                    barPosition: barPosition,
+                                    offset: offset,
+                                    stackedData: stackedData,
+                                    layout: layout,
+                                    dataStartIndex: dataStartIndex,
+                                    dataEndIndex: dataEndIndex,
+                                    onItemMouseLeave: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.d)(_this3.handleItemMouseLeave, null, item.props.onMouseLeave),
+                                    onItemMouseEnter: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.d)(_this3.handleItemMouseEnter, null, item.props.onMouseEnter)
+                                })), (_extends5 = {
+                                    key: item.key || "item-" + index
+                                }, _defineProperty(_extends5, numericAxisName, axisObj[numericAxisName]), _defineProperty(_extends5, cateAxisName, axisObj[cateAxisName]), 
+                                _defineProperty(_extends5, "animationId", updateId), _extends5)),
+                                childIndex: Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.o)(item, props.children),
+                                item: item
+                            });
+                        }
+                    }), formatedItems;
+                }
+            }, {
+                key: "getCursorRectangle",
+                value: function() {
+                    var layout = this.props.layout, _state5 = this.state, activeCoordinate = _state5.activeCoordinate, offset = _state5.offset, tooltipAxisBandSize = _state5.tooltipAxisBandSize, halfSize = tooltipAxisBandSize / 2;
+                    return {
+                        stroke: "none",
+                        fill: "#ccc",
+                        x: "horizontal" === layout ? activeCoordinate.x - halfSize : offset.left + .5,
+                        y: "horizontal" === layout ? offset.top + .5 : activeCoordinate.y - halfSize,
+                        width: "horizontal" === layout ? tooltipAxisBandSize : offset.width - 1,
+                        height: "horizontal" === layout ? offset.height - 1 : tooltipAxisBandSize
+                    };
+                }
+            }, {
+                key: "getCursorPoints",
+                value: function() {
+                    var layout = this.props.layout, _state6 = this.state, activeCoordinate = _state6.activeCoordinate, offset = _state6.offset, x1 = void 0, y1 = void 0, x2 = void 0, y2 = void 0;
+                    if ("horizontal" === layout) x1 = activeCoordinate.x, x2 = x1, y1 = offset.top, 
+                    y2 = offset.top + offset.height; else if ("vertical" === layout) y1 = activeCoordinate.y, 
+                    y2 = y1, x1 = offset.left, x2 = offset.left + offset.width; else if (!__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(activeCoordinate.cx) || !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(activeCoordinate.cy)) {
+                        if ("centric" !== layout) {
+                            var _cx = activeCoordinate.cx, _cy = activeCoordinate.cy, radius = activeCoordinate.radius, startAngle = activeCoordinate.startAngle, endAngle = activeCoordinate.endAngle, startPoint = Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(_cx, _cy, radius, startAngle), endPoint = Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(_cx, _cy, radius, endAngle);
+                            return {
+                                points: [ startPoint, endPoint ],
+                                cx: _cx,
+                                cy: _cy,
+                                radius: radius,
+                                startAngle: startAngle,
+                                endAngle: endAngle
+                            };
+                        }
+                        var cx = activeCoordinate.cx, cy = activeCoordinate.cy, innerRadius = activeCoordinate.innerRadius, outerRadius = activeCoordinate.outerRadius, angle = activeCoordinate.angle, innerPoint = Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(cx, cy, innerRadius, angle), outerPoint = Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.e)(cx, cy, outerRadius, angle);
+                        x1 = innerPoint.x, y1 = innerPoint.y, x2 = outerPoint.x, y2 = outerPoint.y;
+                    }
+                    return [ {
+                        x: x1,
+                        y: y1
+                    }, {
+                        x: x2,
+                        y: y2
+                    } ];
+                }
+            }, {
+                key: "getAxisNameByLayout",
+                value: function(layout) {
+                    return "horizontal" === layout ? {
+                        numericAxisName: "yAxis",
+                        cateAxisName: "xAxis"
+                    } : "vertical" === layout ? {
+                        numericAxisName: "xAxis",
+                        cateAxisName: "yAxis"
+                    } : "centric" === layout ? {
+                        numericAxisName: "radiusAxis",
+                        cateAxisName: "angleAxis"
+                    } : {
+                        numericAxisName: "angleAxis",
+                        cateAxisName: "radiusAxis"
+                    };
+                }
+            }, {
+                key: "calculateTooltipPos",
+                value: function(rangeObj) {
+                    var layout = this.props.layout;
+                    return "horizontal" === layout ? rangeObj.x : "vertical" === layout ? rangeObj.y : "centric" === layout ? rangeObj.angle : rangeObj.radius;
+                }
+            }, {
+                key: "inRange",
+                value: function(x, y) {
+                    var layout = this.props.layout;
+                    if ("horizontal" === layout || "vertical" === layout) {
+                        var offset = this.state.offset;
+                        return x >= offset.left && x <= offset.left + offset.width && y >= offset.top && y <= offset.top + offset.height ? {
+                            x: x,
+                            y: y
+                        } : null;
+                    }
+                    var _state7 = this.state, angleAxisMap = _state7.angleAxisMap, radiusAxisMap = _state7.radiusAxisMap;
+                    if (angleAxisMap && radiusAxisMap) {
+                        var angleAxis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(angleAxisMap);
+                        return Object(__WEBPACK_IMPORTED_MODULE_23__util_PolarUtils__.d)({
+                            x: x,
+                            y: y
+                        }, angleAxis);
+                    }
+                    return null;
+                }
+            }, {
+                key: "parseEventsOfWrapper",
+                value: function() {
+                    var children = this.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_10__component_Tooltip__.a), tooltipEvents = tooltipItem && "axis" === eventType ? {
+                        onMouseEnter: this.handleMouseEnter,
+                        onMouseMove: this.handleMouseMove,
+                        onMouseLeave: this.handleMouseLeave,
+                        onTouchMove: this.handleTouchMove
+                    } : {}, outerEvents = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.e)(this.props, this.handleOuterEvent);
+                    return _extends({}, outerEvents, tooltipEvents);
+                }
+            }, {
+                key: "updateStateOfAxisMapsOffsetAndStackGroups",
+                value: function(_ref5) {
+                    var _this4 = this, props = _ref5.props, dataStartIndex = _ref5.dataStartIndex, dataEndIndex = _ref5.dataEndIndex, updateId = _ref5.updateId;
+                    if (!Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.q)({
+                        props: props
+                    })) return null;
+                    var children = props.children, layout = props.layout, stackOffset = props.stackOffset, data = props.data, reverseStackOrder = props.reverseStackOrder, _getAxisNameByLayout2 = this.getAxisNameByLayout(layout), numericAxisName = _getAxisNameByLayout2.numericAxisName, cateAxisName = _getAxisNameByLayout2.cateAxisName, graphicalItems = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.h)(children, GraphicalChild), stackGroups = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.s)(data, graphicalItems, numericAxisName + "Id", cateAxisName + "Id", stackOffset, reverseStackOrder), axisObj = axisComponents.reduce(function(result, entry) {
+                        var name = entry.axisType + "Map";
+                        return _extends({}, result, _defineProperty({}, name, _this4.getAxisMap(props, _extends({}, entry, {
+                            graphicalItems: graphicalItems,
+                            stackGroups: entry.axisType === numericAxisName && stackGroups,
+                            dataStartIndex: dataStartIndex,
+                            dataEndIndex: dataEndIndex
+                        }))));
+                    }, {}), offset = this.calculateOffset(_extends({}, axisObj, {
+                        props: props,
+                        graphicalItems: graphicalItems
+                    }));
+                    Object.keys(axisObj).forEach(function(key) {
+                        axisObj[key] = formatAxisMap(props, axisObj[key], offset, key.replace("Map", ""), chartName);
+                    });
+                    var cateAxisMap = axisObj[cateAxisName + "Map"], ticksObj = this.tooltipTicksGenerator(cateAxisMap), formatedGraphicalItems = this.getFormatItems(props, _extends({}, axisObj, {
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex,
+                        updateId: updateId,
+                        graphicalItems: graphicalItems,
+                        stackGroups: stackGroups,
+                        offset: offset
+                    }));
+                    return _extends({
+                        formatedGraphicalItems: formatedGraphicalItems,
+                        graphicalItems: graphicalItems,
+                        offset: offset,
+                        stackGroups: stackGroups
+                    }, ticksObj, axisObj);
+                }
+            }, {
+                key: "addListener",
+                value: function() {
+                    __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.on(__WEBPACK_IMPORTED_MODULE_25__util_Events__.a, this.handleReceiveSyncEvent), 
+                    __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.setMaxListeners && __WEBPACK_IMPORTED_MODULE_25__util_Events__.b._maxListeners && __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.setMaxListeners(__WEBPACK_IMPORTED_MODULE_25__util_Events__.b._maxListeners + 1);
+                }
+            }, {
+                key: "removeListener",
+                value: function() {
+                    __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.removeListener(__WEBPACK_IMPORTED_MODULE_25__util_Events__.a, this.handleReceiveSyncEvent), 
+                    __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.setMaxListeners && __WEBPACK_IMPORTED_MODULE_25__util_Events__.b._maxListeners && __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.setMaxListeners(__WEBPACK_IMPORTED_MODULE_25__util_Events__.b._maxListeners - 1);
+                }
+            }, {
+                key: "calculateOffset",
+                value: function(_ref6) {
+                    var props = _ref6.props, graphicalItems = _ref6.graphicalItems, _ref6$xAxisMap = _ref6.xAxisMap, xAxisMap = void 0 === _ref6$xAxisMap ? {} : _ref6$xAxisMap, _ref6$yAxisMap = _ref6.yAxisMap, yAxisMap = void 0 === _ref6$yAxisMap ? {} : _ref6$yAxisMap, width = props.width, height = props.height, children = props.children, margin = props.margin || {}, brushItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_19__cartesian_Brush__.a), legendItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_11__component_Legend__.a), offsetH = Object.keys(yAxisMap).reduce(function(result, id) {
+                        var entry = yAxisMap[id], orientation = entry.orientation;
+                        return entry.mirror || entry.hide ? result : _extends({}, result, _defineProperty({}, orientation, result[orientation] + entry.width));
+                    }, {
+                        left: margin.left || 0,
+                        right: margin.right || 0
+                    }), offsetV = Object.keys(xAxisMap).reduce(function(result, id) {
+                        var entry = xAxisMap[id], orientation = entry.orientation;
+                        return entry.mirror || entry.hide ? result : _extends({}, result, _defineProperty({}, orientation, result[orientation] + entry.height));
+                    }, {
+                        top: margin.top || 0,
+                        bottom: margin.bottom || 0
+                    }), offset = _extends({}, offsetV, offsetH), brushBottom = offset.bottom;
+                    if (brushItem && (offset.bottom += brushItem.props.height || __WEBPACK_IMPORTED_MODULE_19__cartesian_Brush__.a.defaultProps.height), 
+                    legendItem && this.legendInstance) {
+                        var legendBox = this.legendInstance.getBBox();
+                        offset = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.a)(offset, graphicalItems, props, legendBox);
+                    }
+                    return _extends({
+                        brushBottom: brushBottom
+                    }, offset, {
+                        width: width - offset.left - offset.right,
+                        height: height - offset.top - offset.bottom
+                    });
+                }
+            }, {
+                key: "triggerSyncEvent",
+                value: function(data) {
+                    var syncId = this.props.syncId;
+                    __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(syncId) || __WEBPACK_IMPORTED_MODULE_25__util_Events__.b.emit(__WEBPACK_IMPORTED_MODULE_25__util_Events__.a, syncId, this.uniqueChartId, data);
+                }
+            }, {
+                key: "filterFormatItem",
+                value: function(item, displayName, childIndex) {
+                    for (var formatedGraphicalItems = this.state.formatedGraphicalItems, i = 0, len = formatedGraphicalItems.length; i < len; i++) {
+                        var entry = formatedGraphicalItems[i];
+                        if (entry.item === item || entry.props.key === item.key || displayName === Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.j)(entry.item.type) && childIndex === entry.childIndex) return entry;
+                    }
+                    return null;
+                }
+            }, {
+                key: "renderAxis",
+                value: function(axisOptions, element, displayName, index) {
+                    var _props2 = this.props, width = _props2.width, height = _props2.height;
+                    return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__.a, _extends({}, axisOptions, {
+                        className: "recharts-" + axisOptions.axisType + " " + axisOptions.axisType,
+                        key: element.key || displayName + "-" + index,
+                        viewBox: {
+                            x: 0,
+                            y: 0,
+                            width: width,
+                            height: height
+                        },
+                        ticksGenerator: this.axesTicksGenerator
+                    }));
+                }
+            }, {
+                key: "renderLegend",
+                value: function() {
+                    var _this5 = this, formatedGraphicalItems = this.state.formatedGraphicalItems, _props3 = this.props, children = _props3.children, width = _props3.width, height = _props3.height, margin = this.props.margin || {}, legendWidth = width - (margin.left || 0) - (margin.right || 0), legendHeight = height - (margin.top || 0) - (margin.bottom || 0), props = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.q)({
+                        children: children,
+                        formatedGraphicalItems: formatedGraphicalItems,
+                        legendWidth: legendWidth,
+                        legendHeight: legendHeight,
+                        legendContent: legendContent
+                    });
+                    if (!props) return null;
+                    var item = props.item, otherProps = _objectWithoutProperties(props, [ "item" ]);
+                    return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(item, _extends({}, otherProps, {
+                        chartWidth: width,
+                        chartHeight: height,
+                        margin: margin,
+                        ref: function(legend) {
+                            _this5.legendInstance = legend;
+                        },
+                        onBBoxUpdate: this.handleLegendBBoxUpdate
+                    }));
+                }
+            }, {
+                key: "renderTooltip",
+                value: function() {
+                    var children = this.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_10__component_Tooltip__.a);
+                    if (!tooltipItem) return null;
+                    var _state8 = this.state, isTooltipActive = _state8.isTooltipActive, activeCoordinate = _state8.activeCoordinate, activePayload = _state8.activePayload, activeLabel = _state8.activeLabel, offset = _state8.offset;
+                    return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(tooltipItem, {
+                        viewBox: _extends({}, offset, {
+                            x: offset.left,
+                            y: offset.top
+                        }),
+                        active: isTooltipActive,
+                        label: activeLabel,
+                        payload: isTooltipActive ? activePayload : [],
+                        coordinate: activeCoordinate
+                    });
+                }
+            }, {
+                key: "renderActiveDot",
+                value: function(option, props) {
+                    var dot = void 0;
+                    return dot = Object(__WEBPACK_IMPORTED_MODULE_5_react__.isValidElement)(option) ? Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(option, props) : __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(option) ? option(props) : __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_15__shape_Dot__.a, props), 
+                    __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__container_Layer__.a, {
+                        className: "recharts-active-dot",
+                        key: props.key
+                    }, dot);
+                }
+            }, {
+                key: "renderActivePoints",
+                value: function(_ref7) {
+                    var item = _ref7.item, activePoint = _ref7.activePoint, basePoint = _ref7.basePoint, childIndex = _ref7.childIndex, isRange = _ref7.isRange, result = [], key = item.props.key, _item$item$props = item.item.props, activeDot = _item$item$props.activeDot, dataKey = _item$item$props.dataKey, dotProps = _extends({
+                        index: childIndex,
+                        dataKey: dataKey,
+                        cx: activePoint.x,
+                        cy: activePoint.y,
+                        r: 4,
+                        fill: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.r)(item.item),
+                        strokeWidth: 2,
+                        stroke: "#fff",
+                        payload: activePoint.payload,
+                        value: activePoint.value,
+                        key: key + "-activePoint-" + childIndex
+                    }, Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.k)(activeDot), Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.e)(activeDot));
+                    return result.push(this.renderActiveDot(activeDot, dotProps, childIndex)), basePoint ? result.push(this.renderActiveDot(activeDot, _extends({}, dotProps, {
+                        cx: basePoint.x,
+                        cy: basePoint.y,
+                        key: key + "-basePoint-" + childIndex
+                    }), childIndex)) : isRange && result.push(null), result;
+                }
+            }, {
+                key: "render",
+                value: function() {
+                    var _this6 = this;
+                    if (!Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.q)(this)) return null;
+                    var _props4 = this.props, children = _props4.children, className = _props4.className, width = _props4.width, height = _props4.height, style = _props4.style, compact = _props4.compact, others = _objectWithoutProperties(_props4, [ "children", "className", "width", "height", "style", "compact" ]), attrs = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.k)(others), map = {
+                        CartesianGrid: {
+                            handler: this.renderGrid,
+                            once: !0
+                        },
+                        ReferenceArea: {
+                            handler: this.renderReferenceElement
+                        },
+                        ReferenceLine: {
+                            handler: this.renderReferenceElement
+                        },
+                        ReferenceDot: {
+                            handler: this.renderReferenceElement
+                        },
+                        XAxis: {
+                            handler: this.renderXAxis
+                        },
+                        YAxis: {
+                            handler: this.renderYAxis
+                        },
+                        Brush: {
+                            handler: this.renderBrush,
+                            once: !0
+                        },
+                        Bar: {
+                            handler: this.renderGraphicChild
+                        },
+                        Line: {
+                            handler: this.renderGraphicChild
+                        },
+                        Area: {
+                            handler: this.renderGraphicChild
+                        },
+                        Radar: {
+                            handler: this.renderGraphicChild
+                        },
+                        RadialBar: {
+                            handler: this.renderGraphicChild
+                        },
+                        Scatter: {
+                            handler: this.renderGraphicChild
+                        },
+                        Pie: {
+                            handler: this.renderGraphicChild
+                        },
+                        Tooltip: {
+                            handler: this.renderCursor,
+                            once: !0
+                        },
+                        PolarGrid: {
+                            handler: this.renderPolarGrid,
+                            once: !0
+                        },
+                        PolarAngleAxis: {
+                            handler: this.renderPolarAxis
+                        },
+                        PolarRadiusAxis: {
+                            handler: this.renderPolarAxis
+                        }
+                    };
+                    if (compact) return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__container_Surface__.a, _extends({}, attrs, {
+                        width: width,
+                        height: height
+                    }), Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.p)(children, map));
+                    var events = this.parseEventsOfWrapper();
+                    return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement("div", _extends({
+                        className: __WEBPACK_IMPORTED_MODULE_7_classnames___default()("recharts-wrapper", className),
+                        style: _extends({}, style, {
+                            position: "relative",
+                            cursor: "default",
+                            width: width,
+                            height: height
+                        })
+                    }, events, {
+                        ref: function(node) {
+                            _this6.container = node;
+                        }
+                    }), __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__container_Surface__.a, _extends({}, attrs, {
+                        width: width,
+                        height: height
+                    }), Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.p)(children, map)), this.renderLegend(), this.renderTooltip());
+                }
+            } ]), CategoricalChartWrapper;
+        }(__WEBPACK_IMPORTED_MODULE_5_react__.Component), _class.displayName = chartName, 
+        _class.propTypes = _extends({
+            syncId: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number ]),
+            compact: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
+            width: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+            height: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+            data: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object),
+            layout: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "horizontal", "vertical" ]),
+            stackOffset: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "sign", "expand", "none", "wiggle", "silhouette" ]),
+            throttleDelay: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+            margin: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.shape({
+                top: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+                right: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+                bottom: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+                left: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number
+            }),
+            barCategoryGap: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+            barGap: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+            barSize: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]),
+            maxBarSize: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number,
+            style: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object,
+            className: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string,
+            children: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.node ]),
+            onClick: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            onMouseLeave: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            onMouseEnter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            onMouseMove: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            onMouseDown: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            onMouseUp: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func,
+            reverseStackOrder: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool,
+            id: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string
+        }, propTypes), _class.defaultProps = _extends({
+            layout: "horizontal",
+            stackOffset: "none",
+            barCategoryGap: "10%",
+            barGap: 4,
+            margin: {
+                top: 5,
+                right: 5,
+                bottom: 5,
+                left: 5
+            },
+            reverseStackOrder: !1
+        }, defaultProps), _class.createDefaultState = function(props) {
+            var children = props.children, brushItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_19__cartesian_Brush__.a);
+            return {
+                chartX: 0,
+                chartY: 0,
+                dataStartIndex: brushItem && brushItem.props && brushItem.props.startIndex || 0,
+                dataEndIndex: brushItem && brushItem.props && brushItem.props.endIndex || props.data && props.data.length - 1 || 0,
+                activeTooltipIndex: -1,
+                isTooltipActive: !1
+            };
+        }, _class.hasBar = function(graphicalItems) {
+            return !(!graphicalItems || !graphicalItems.length) && graphicalItems.some(function(item) {
+                var name = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.j)(item && item.type);
+                return name && name.indexOf("Bar") >= 0;
+            });
+        }, _class.getDisplayedData = function(props, _ref8, item) {
+            var graphicalItems = _ref8.graphicalItems, dataStartIndex = _ref8.dataStartIndex, dataEndIndex = _ref8.dataEndIndex, itemsData = (graphicalItems || []).reduce(function(result, child) {
+                var itemData = child.props.data;
+                return itemData && itemData.length ? [].concat(_toConsumableArray(result), _toConsumableArray(itemData)) : result;
+            }, []);
+            if (itemsData && itemsData.length > 0) return itemsData;
+            if (item && item.props && item.props.data && item.props.data.length > 0) return item.props.data;
+            var data = props.data;
+            return data && data.length && Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(dataStartIndex) && Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(dataEndIndex) ? data.slice(dataStartIndex, dataEndIndex + 1) : [];
+        }, _initialiseProps = function() {
+            var _this7 = this;
+            this.handleLegendBBoxUpdate = function(box) {
+                if (box && _this7.legendInstance) {
+                    var _state9 = _this7.state, dataStartIndex = _state9.dataStartIndex, dataEndIndex = _state9.dataEndIndex, updateId = _state9.updateId;
+                    _this7.setState(_this7.updateStateOfAxisMapsOffsetAndStackGroups({
+                        props: _this7.props,
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex,
+                        updateId: updateId
+                    }));
+                }
+            }, this.handleReceiveSyncEvent = function(cId, chartId, data) {
+                var _props5 = _this7.props, syncId = _props5.syncId, layout = _props5.layout, updateId = _this7.state.updateId;
+                if (syncId === cId && chartId !== _this7.uniqueChartId) {
+                    var dataStartIndex = data.dataStartIndex, dataEndIndex = data.dataEndIndex;
+                    if (__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(data.dataStartIndex) && __WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(data.dataEndIndex)) if (__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(data.activeTooltipIndex)) _this7.setState(data); else {
+                        var chartX = data.chartX, chartY = data.chartY, activeTooltipIndex = data.activeTooltipIndex, _state10 = _this7.state, offset = _state10.offset, tooltipTicks = _state10.tooltipTicks;
+                        if (!offset) return;
+                        var viewBox = _extends({}, offset, {
+                            x: offset.left,
+                            y: offset.top
+                        }), validateChartX = Math.min(chartX, viewBox.x + viewBox.width), validateChartY = Math.min(chartY, viewBox.y + viewBox.height), activeLabel = tooltipTicks[activeTooltipIndex] && tooltipTicks[activeTooltipIndex].value, activePayload = _this7.getTooltipContent(activeTooltipIndex), activeCoordinate = tooltipTicks[activeTooltipIndex] ? {
+                            x: "horizontal" === layout ? tooltipTicks[activeTooltipIndex].coordinate : validateChartX,
+                            y: "horizontal" === layout ? validateChartY : tooltipTicks[activeTooltipIndex].coordinate
+                        } : originCoordinate;
+                        _this7.setState(_extends({}, data, {
+                            activeLabel: activeLabel,
+                            activeCoordinate: activeCoordinate,
+                            activePayload: activePayload
+                        }));
+                    } else _this7.setState(_extends({
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex
+                    }, _this7.updateStateOfAxisMapsOffsetAndStackGroups({
+                        props: _this7.props,
+                        dataStartIndex: dataStartIndex,
+                        dataEndIndex: dataEndIndex,
+                        updateId: updateId
+                    })));
+                }
+            }, this.handleBrushChange = function(_ref9) {
+                var startIndex = _ref9.startIndex, endIndex = _ref9.endIndex;
+                if (startIndex !== _this7.state.dataStartIndex || endIndex !== _this7.state.dataEndIndex) {
+                    var updateId = _this7.state.updateId;
+                    _this7.setState(function() {
+                        return _extends({
+                            dataStartIndex: startIndex,
+                            dataEndIndex: endIndex
+                        }, _this7.updateStateOfAxisMapsOffsetAndStackGroups({
+                            props: _this7.props,
+                            dataStartIndex: startIndex,
+                            dataEndIndex: endIndex,
+                            updateId: updateId
+                        }));
+                    }), _this7.triggerSyncEvent({
+                        dataStartIndex: startIndex,
+                        dataEndIndex: endIndex
+                    });
+                }
+            }, this.handleMouseEnter = function(e) {
+                var onMouseEnter = _this7.props.onMouseEnter, mouse = _this7.getMouseInfo(e);
+                if (mouse) {
+                    var nextState = _extends({}, mouse, {
+                        isTooltipActive: !0
+                    });
+                    _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseEnter) && onMouseEnter(nextState, e);
+                }
+            }, this.triggeredAfterMouseMove = function(e) {
+                var onMouseMove = _this7.props.onMouseMove, mouse = _this7.getMouseInfo(e), nextState = mouse ? _extends({}, mouse, {
+                    isTooltipActive: !0
+                }) : {
+                    isTooltipActive: !1
+                };
+                _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseMove) && onMouseMove(nextState, e);
+            }, this.handleItemMouseEnter = function(el) {
+                _this7.setState(function() {
+                    return {
+                        isTooltipActive: !0,
+                        activeItem: el,
+                        activePayload: el.tooltipPayload,
+                        activeCoordinate: el.tooltipPosition || {
+                            x: el.cx,
+                            y: el.cy
+                        }
+                    };
+                });
+            }, this.handleItemMouseLeave = function() {
+                _this7.setState(function() {
+                    return {
+                        isTooltipActive: !1
+                    };
+                });
+            }, this.handleMouseMove = function(e) {
+                e && __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(e.persist) && e.persist(), 
+                _this7.triggeredAfterMouseMove(e);
+            }, this.handleMouseLeave = function(e) {
+                var onMouseLeave = _this7.props.onMouseLeave, nextState = {
+                    isTooltipActive: !1
+                };
+                _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseLeave) && onMouseLeave(nextState, e);
+            }, this.handleOuterEvent = function(e) {
+                var eventName = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.l)(e);
+                if (eventName && __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(_this7.props[eventName])) {
+                    var mouse = _this7.getMouseInfo(e);
+                    (0, _this7.props[eventName])(mouse, e);
+                }
+            }, this.handleClick = function(e) {
+                var onClick = _this7.props.onClick;
+                if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onClick)) {
+                    onClick(_this7.getMouseInfo(e), e);
+                }
+            }, this.handleMouseDown = function(e) {
+                var onMouseDown = _this7.props.onMouseDown;
+                if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseDown)) {
+                    onMouseDown(_this7.getMouseInfo(e), e);
+                }
+            }, this.handleMouseUp = function(e) {
+                var onMouseUp = _this7.props.onMouseUp;
+                if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseUp)) {
+                    onMouseUp(_this7.getMouseInfo(e), e);
+                }
+            }, this.handleTouchMove = function(e) {
+                null != e.changedTouches && e.changedTouches.length > 0 && _this7.handleMouseMove(e.changedTouches[0]);
+            }, this.verticalCoordinatesGenerator = function(_ref10) {
+                var xAxis = _ref10.xAxis, width = _ref10.width, height = _ref10.height, offset = _ref10.offset;
+                return Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.m)(__WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__.a.getTicks(_extends({}, __WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__.a.defaultProps, xAxis, {
+                    ticks: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(xAxis, !0),
+                    viewBox: {
+                        x: 0,
+                        y: 0,
+                        width: width,
+                        height: height
+                    }
+                })), offset.left, offset.left + offset.width);
+            }, this.horizontalCoordinatesGenerator = function(_ref11) {
+                var yAxis = _ref11.yAxis, width = _ref11.width, height = _ref11.height, offset = _ref11.offset;
+                return Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.m)(__WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__.a.getTicks(_extends({}, __WEBPACK_IMPORTED_MODULE_18__cartesian_CartesianAxis__.a.defaultProps, yAxis, {
+                    ticks: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(yAxis, !0),
+                    viewBox: {
+                        x: 0,
+                        y: 0,
+                        width: width,
+                        height: height
+                    }
+                })), offset.top, offset.top + offset.height);
+            }, this.axesTicksGenerator = function(axis) {
+                return Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(axis, !0);
+            }, this.tooltipTicksGenerator = function(axisMap) {
+                var axis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(axisMap), tooltipTicks = Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(axis, !1, !0);
+                return {
+                    tooltipTicks: tooltipTicks,
+                    orderedTooltipTicks: __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy___default()(tooltipTicks, function(o) {
+                        return o.coordinate;
+                    }),
+                    tooltipAxis: axis,
+                    tooltipAxisBandSize: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.g)(axis)
+                };
+            }, this.renderCursor = function(element) {
+                var _state11 = _this7.state, isTooltipActive = _state11.isTooltipActive, activeCoordinate = _state11.activeCoordinate, activePayload = _state11.activePayload, offset = _state11.offset;
+                if (!(element && element.props.cursor && isTooltipActive && activeCoordinate)) return null;
+                var layout = _this7.props.layout, restProps = void 0, cursorComp = __WEBPACK_IMPORTED_MODULE_12__shape_Curve__.a;
+                if ("ScatterChart" === chartName) restProps = activeCoordinate, cursorComp = __WEBPACK_IMPORTED_MODULE_13__shape_Cross__.a; else if ("BarChart" === chartName) restProps = _this7.getCursorRectangle(), 
+                cursorComp = __WEBPACK_IMPORTED_MODULE_16__shape_Rectangle__.a; else if ("radial" === layout) {
+                    var _getCursorPoints = _this7.getCursorPoints(), cx = _getCursorPoints.cx, cy = _getCursorPoints.cy, radius = _getCursorPoints.radius, startAngle = _getCursorPoints.startAngle, endAngle = _getCursorPoints.endAngle;
+                    restProps = {
+                        cx: cx,
+                        cy: cy,
+                        startAngle: startAngle,
+                        endAngle: endAngle,
+                        innerRadius: radius,
+                        outerRadius: radius
+                    }, cursorComp = __WEBPACK_IMPORTED_MODULE_14__shape_Sector__.a;
+                } else restProps = {
+                    points: _this7.getCursorPoints()
+                }, cursorComp = __WEBPACK_IMPORTED_MODULE_12__shape_Curve__.a;
+                var key = element.key || "_recharts-cursor", cursorProps = _extends({
+                    stroke: "#ccc"
+                }, offset, restProps, Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.k)(element.props.cursor), {
+                    payload: activePayload,
+                    key: key,
+                    className: "recharts-tooltip-cursor"
+                });
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.isValidElement)(element.props.cursor) ? Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element.props.cursor, cursorProps) : Object(__WEBPACK_IMPORTED_MODULE_5_react__.createElement)(cursorComp, cursorProps);
+            }, this.renderPolarAxis = function(element, displayName, index) {
+                var axisType = element.type.axisType, axisMap = _this7.state[axisType + "Map"], axisOption = axisMap[element.props[axisType + "Id"]];
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, _extends({}, axisOption, {
+                    className: axisType,
+                    key: element.key || displayName + "-" + index,
+                    ticks: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(axisOption, !0)
+                }));
+            }, this.renderXAxis = function(element, displayName, index) {
+                var xAxisMap = _this7.state.xAxisMap, axisObj = xAxisMap[element.props.xAxisId];
+                return _this7.renderAxis(axisObj, element, displayName, index);
+            }, this.renderYAxis = function(element, displayName, index) {
+                var yAxisMap = _this7.state.yAxisMap, axisObj = yAxisMap[element.props.yAxisId];
+                return _this7.renderAxis(axisObj, element, displayName, index);
+            }, this.renderGrid = function(element) {
+                var _state12 = _this7.state, xAxisMap = _state12.xAxisMap, yAxisMap = _state12.yAxisMap, offset = _state12.offset, _props6 = _this7.props, width = _props6.width, height = _props6.height, xAxis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(xAxisMap), yAxis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(yAxisMap), props = element.props || {};
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, {
+                    key: element.key || "grid",
+                    x: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(props.x) ? props.x : offset.left,
+                    y: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(props.y) ? props.y : offset.top,
+                    width: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(props.width) ? props.width : offset.width,
+                    height: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(props.height) ? props.height : offset.height,
+                    xAxis: xAxis,
+                    yAxis: yAxis,
+                    offset: offset,
+                    chartWidth: width,
+                    chartHeight: height,
+                    verticalCoordinatesGenerator: _this7.verticalCoordinatesGenerator,
+                    horizontalCoordinatesGenerator: _this7.horizontalCoordinatesGenerator
+                });
+            }, this.renderPolarGrid = function(element) {
+                var _state13 = _this7.state, radiusAxisMap = _state13.radiusAxisMap, angleAxisMap = _state13.angleAxisMap, radiusAxis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(radiusAxisMap), angleAxis = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.b)(angleAxisMap), cx = angleAxis.cx, cy = angleAxis.cy, innerRadius = angleAxis.innerRadius, outerRadius = angleAxis.outerRadius;
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, {
+                    polarAngles: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(angleAxis, !0).map(function(entry) {
+                        return entry.coordinate;
+                    }),
+                    polarRadius: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.u)(radiusAxis, !0).map(function(entry) {
+                        return entry.coordinate;
+                    }),
+                    cx: cx,
+                    cy: cy,
+                    innerRadius: innerRadius,
+                    outerRadius: outerRadius,
+                    key: element.key || "polar-grid"
+                });
+            }, this.renderBrush = function(element) {
+                var _props7 = _this7.props, margin = _props7.margin, data = _props7.data, _state14 = _this7.state, offset = _state14.offset, dataStartIndex = _state14.dataStartIndex, dataEndIndex = _state14.dataEndIndex, updateId = _state14.updateId;
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, {
+                    key: element.key || "_recharts-brush",
+                    onChange: Object(__WEBPACK_IMPORTED_MODULE_22__util_ChartUtils__.d)(_this7.handleBrushChange, null, element.props.onChange),
+                    data: data,
+                    x: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(element.props.x) ? element.props.x : offset.left,
+                    y: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(element.props.y) ? element.props.y : offset.top + offset.height + offset.brushBottom - (margin.bottom || 0),
+                    width: Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.h)(element.props.width) ? element.props.width : offset.width,
+                    startIndex: dataStartIndex,
+                    endIndex: dataEndIndex,
+                    updateId: "brush-" + updateId
+                });
+            }, this.renderReferenceElement = function(element, displayName, index) {
+                if (!element) return null;
+                var _state15 = _this7.state, xAxisMap = _state15.xAxisMap, yAxisMap = _state15.yAxisMap, offset = _state15.offset, _element$props = element.props, xAxisId = _element$props.xAxisId, yAxisId = _element$props.yAxisId;
+                return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, {
+                    key: element.key || displayName + "-" + index,
+                    xAxis: xAxisMap[xAxisId],
+                    yAxis: yAxisMap[yAxisId],
+                    viewBox: {
+                        x: offset.left,
+                        y: offset.top,
+                        width: offset.width,
+                        height: offset.height
+                    }
+                });
+            }, this.renderGraphicChild = function(element, displayName, index) {
+                var item = _this7.filterFormatItem(element, displayName, index);
+                if (!item) return null;
+                var graphicalItem = Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(element, item.props), _state16 = _this7.state, isTooltipActive = _state16.isTooltipActive, tooltipAxis = _state16.tooltipAxis, activeTooltipIndex = _state16.activeTooltipIndex, activeLabel = _state16.activeLabel, children = _this7.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_17__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_10__component_Tooltip__.a), _item$props2 = item.props, points = _item$props2.points, isRange = _item$props2.isRange, baseLine = _item$props2.baseLine, _item$item$props2 = item.item.props, activeDot = _item$item$props2.activeDot;
+                if (!_item$item$props2.hide && isTooltipActive && tooltipItem && activeDot && activeTooltipIndex >= 0) {
+                    var activePoint = void 0, basePoint = void 0;
+                    if (tooltipAxis.dataKey && !tooltipAxis.allowDuplicatedCategory ? (activePoint = Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.a)(points, "payload." + tooltipAxis.dataKey, activeLabel), 
+                    basePoint = isRange && baseLine && Object(__WEBPACK_IMPORTED_MODULE_21__util_DataUtils__.a)(baseLine, "payload." + tooltipAxis.dataKey, activeLabel)) : (activePoint = points[activeTooltipIndex], 
+                    basePoint = isRange && baseLine && baseLine[activeTooltipIndex]), !__WEBPACK_IMPORTED_MODULE_4_lodash_isNil___default()(activePoint)) return [ graphicalItem ].concat(_toConsumableArray(_this7.renderActivePoints({
+                        item: item,
+                        activePoint: activePoint,
+                        basePoint: basePoint,
+                        childIndex: activeTooltipIndex,
+                        isRange: isRange
+                    })));
+                }
+                return isRange ? [ graphicalItem, null, null ] : [ graphicalItem, null ];
+            };
+        }, _temp;
+    };
+    __webpack_exports__.a = generateCategoricalChart;
+}, function(module, exports, __webpack_require__) {
+    var aFunction = __webpack_require__(205);
+    module.exports = function(fn, that, length) {
+        if (aFunction(fn), void 0 === that) return fn;
+        switch (length) {
+          case 1:
+            return function(a) {
+                return fn.call(that, a);
+            };
+
+          case 2:
+            return function(a, b) {
+                return fn.call(that, a, b);
+            };
+
+          case 3:
+            return function(a, b, c) {
+                return fn.call(that, a, b, c);
+            };
+        }
+        return function() {
+            return fn.apply(that, arguments);
+        };
+    };
+}, function(module, exports, __webpack_require__) {
+    var isObject = __webpack_require__(35);
+    module.exports = function(it) {
+        if (!isObject(it)) throw TypeError(it + " is not an object!");
+        return it;
+    };
+}, function(module, exports) {
+    module.exports = function(exec) {
+        try {
+            return !!exec();
+        } catch (e) {
+            return !0;
+        }
+    };
+}, function(module, exports) {
+    var hasOwnProperty = {}.hasOwnProperty;
+    module.exports = function(it, key) {
+        return hasOwnProperty.call(it, key);
+    };
+}, function(module, exports, __webpack_require__) {
+    module.exports = {
+        default: __webpack_require__(382),
+        __esModule: !0
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        function _interopRequireDefault(obj) {
+            return obj && obj.__esModule ? obj : {
+                default: obj
+            };
+        }
+        function capitalize(string) {
+            if ("production" !== process.env.NODE_ENV && "string" != typeof string) throw new Error("Material-UI: capitalize(string) expects a string argument.");
+            return string.charAt(0).toUpperCase() + string.slice(1);
+        }
+        function contains(obj, pred) {
+            return (0, _keys2.default)(pred).every(function(key) {
+                return obj.hasOwnProperty(key) && obj[key] === pred[key];
+            });
+        }
+        function findIndex(arr, pred) {
+            for (var predType = void 0 === pred ? "undefined" : (0, _typeof3.default)(pred), i = 0; i < arr.length; i += 1) {
+                if ("function" === predType && !0 == !!pred(arr[i], i, arr)) return i;
+                if ("object" === predType && contains(arr[i], pred)) return i;
+                if (-1 !== [ "string", "number", "boolean" ].indexOf(predType)) return arr.indexOf(pred);
+            }
+            return -1;
+        }
+        function find(arr, pred) {
+            var index = findIndex(arr, pred);
+            return index > -1 ? arr[index] : void 0;
+        }
+        function createChainedFunction() {
+            for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) funcs[_key] = arguments[_key];
+            return funcs.filter(function(func) {
+                return null != func;
+            }).reduce(function(acc, func) {
+                return "production" !== process.env.NODE_ENV && (0, _warning2.default)("function" == typeof func, "Material-UI: invalid Argument Type, must only provide functions, undefined, or null."), 
+                function() {
+                    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];
+                    acc.apply(this, args), func.apply(this, args);
+                };
+            }, function() {});
+        }
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        });
+        var _typeof2 = __webpack_require__(101), _typeof3 = _interopRequireDefault(_typeof2), _keys = __webpack_require__(50), _keys2 = _interopRequireDefault(_keys);
+        exports.capitalize = capitalize, exports.contains = contains, exports.findIndex = findIndex, 
+        exports.find = find, exports.createChainedFunction = createChainedFunction;
+        var _warning = __webpack_require__(12), _warning2 = _interopRequireDefault(_warning);
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    function getNative(object, key) {
+        var value = getValue(object, key);
+        return baseIsNative(value) ? value : void 0;
+    }
+    var baseIsNative = __webpack_require__(564), getValue = __webpack_require__(567);
+    module.exports = getNative;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(x) {
+        return function() {
+            return x;
+        };
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _temp2, __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(20), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__), __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__), __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc__ = __webpack_require__(688), __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_reduce_css_calc__), __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__), __WEBPACK_IMPORTED_MODULE_5__util_DataUtils__ = __webpack_require__(9), __WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__ = __webpack_require__(183), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), BREAKING_SPACES = /[ \f\n\r\t\v\u2028\u2029]+/, calculateWordWidths = function(props) {
+        try {
+            return {
+                wordsWithComputedWidth: (__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(props.children) ? [] : props.children.toString().split(BREAKING_SPACES)).map(function(word) {
+                    return {
+                        word: word,
+                        width: Object(__WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__.c)(word, props.style).width
+                    };
+                }),
+                spaceWidth: Object(__WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__.c)(" ", props.style).width
+            };
+        } catch (e) {
+            return null;
+        }
+    }, Text = (_temp2 = _class = function(_Component) {
+        function Text() {
+            var _ref, _temp, _this, _ret;
+            _classCallCheck(this, Text);
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+            return _temp = _this = _possibleConstructorReturn(this, (_ref = Text.__proto__ || Object.getPrototypeOf(Text)).call.apply(_ref, [ this ].concat(args))), 
+            _this.state = {
+                wordsByLines: []
+            }, _ret = _temp, _possibleConstructorReturn(_this, _ret);
+        }
+        return _inherits(Text, _Component), _createClass(Text, [ {
+            key: "componentWillMount",
+            value: function() {
+                this.updateWordsByLines(this.props, !0);
+            }
+        }, {
+            key: "componentWillReceiveProps",
+            value: function(nextProps) {
+                var needCalculate = this.props.children !== nextProps.children || this.props.style !== nextProps.style;
+                this.updateWordsByLines(nextProps, needCalculate);
+            }
+        }, {
+            key: "updateWordsByLines",
+            value: function(props, needCalculate) {
+                if (!props.width && !props.scaleToFit || Object(__WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.n)()) this.updateWordsWithoutCalculate(props); else {
+                    if (needCalculate) {
+                        var wordWidths = calculateWordWidths(props);
+                        if (!wordWidths) return void this.updateWordsWithoutCalculate(props);
+                        var wordsWithComputedWidth = wordWidths.wordsWithComputedWidth, spaceWidth = wordWidths.spaceWidth;
+                        this.wordsWithComputedWidth = wordsWithComputedWidth, this.spaceWidth = spaceWidth;
+                    }
+                    var wordsByLines = this.calculateWordsByLines(this.wordsWithComputedWidth, this.spaceWidth, props.width);
+                    this.setState({
+                        wordsByLines: wordsByLines
+                    });
+                }
+            }
+        }, {
+            key: "updateWordsWithoutCalculate",
+            value: function(props) {
+                var words = __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(props.children) ? [] : props.children.toString().split(BREAKING_SPACES);
+                this.setState({
+                    wordsByLines: [ {
+                        words: words
+                    } ]
+                });
+            }
+        }, {
+            key: "calculateWordsByLines",
+            value: function(wordsWithComputedWidth, spaceWidth, lineWidth) {
+                var scaleToFit = this.props.scaleToFit;
+                return wordsWithComputedWidth.reduce(function(result, _ref2) {
+                    var word = _ref2.word, width = _ref2.width, currentLine = result[result.length - 1];
+                    if (currentLine && (null == lineWidth || scaleToFit || currentLine.width + width + spaceWidth < lineWidth)) currentLine.words.push(word), 
+                    currentLine.width += width + spaceWidth; else {
+                        var newLine = {
+                            words: [ word ],
+                            width: width
+                        };
+                        result.push(newLine);
+                    }
+                    return result;
+                }, []);
+            }
+        }, {
+            key: "render",
+            value: function() {
+                var _props = this.props, dx = _props.dx, dy = _props.dy, textAnchor = _props.textAnchor, verticalAnchor = _props.verticalAnchor, scaleToFit = _props.scaleToFit, angle = _props.angle, lineHeight = _props.lineHeight, capHeight = _props.capHeight, className = _props.className, textProps = _objectWithoutProperties(_props, [ "dx", "dy", "textAnchor", "verticalAnchor", "scaleToFit", "angle", "lineHeight", "capHeight", "className" ]), wordsByLines = this.state.wordsByLines;
+                if (!Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.g)(textProps.x) || !Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.g)(textProps.y)) return null;
+                var x = textProps.x + (Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.h)(dx) ? dx : 0), y = textProps.y + (Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.h)(dy) ? dy : 0), startDy = void 0;
+                switch (verticalAnchor) {
+                  case "start":
+                    startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + capHeight + ")");
+                    break;
+
+                  case "middle":
+                    startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + (wordsByLines.length - 1) / 2 + " * -" + lineHeight + " + (" + capHeight + " / 2))");
+                    break;
+
+                  default:
+                    startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + (wordsByLines.length - 1) + " * -" + lineHeight + ")");
+                }
+                var transforms = [];
+                if (scaleToFit) {
+                    var lineWidth = wordsByLines[0].width;
+                    transforms.push("scale(" + this.props.width / lineWidth + ")");
+                }
+                return angle && transforms.push("rotate(" + angle + ", " + x + ", " + y + ")"), 
+                transforms.length && (textProps.transform = transforms.join(" ")), __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement("text", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.k)(textProps), {
+                    x: x,
+                    y: y,
+                    className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()("recharts-text", className),
+                    textAnchor: textAnchor
+                }), wordsByLines.map(function(line, index) {
+                    return __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement("tspan", {
+                        x: x,
+                        dy: 0 === index ? startDy : lineHeight,
+                        key: index
+                    }, line.words.join(" "));
+                }));
+            }
+        } ]), Text;
+    }(__WEBPACK_IMPORTED_MODULE_1_react__.Component), _class.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.c, {
+        scaleToFit: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool,
+        angle: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.number,
+        textAnchor: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOf([ "start", "middle", "end", "inherit" ]),
+        verticalAnchor: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOf([ "start", "middle", "end" ]),
+        style: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object
+    }), _class.defaultProps = {
+        x: 0,
+        y: 0,
+        lineHeight: "1em",
+        capHeight: "0.71em",
+        scaleToFit: !1,
+        textAnchor: "start",
+        verticalAnchor: "end"
+    }, _temp2);
+    __webpack_exports__.a = Text;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return map;
+    }), __webpack_require__.d(__webpack_exports__, "b", function() {
+        return slice;
+    });
+    var array = Array.prototype, map = array.map, slice = array.slice;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3__util_PureRender__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__ = __webpack_require__(4), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), Dot = Object(__WEBPACK_IMPORTED_MODULE_3__util_PureRender__.a)((_temp = _class2 = function(_Component) {
+        function Dot() {
+            return _classCallCheck(this, Dot), _possibleConstructorReturn(this, (Dot.__proto__ || Object.getPrototypeOf(Dot)).apply(this, arguments));
+        }
+        return _inherits(Dot, _Component), _createClass(Dot, [ {
+            key: "render",
+            value: function() {
+                var _props = this.props, cx = _props.cx, cy = _props.cy, r = _props.r, className = _props.className, layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-dot", className);
+                return cx === +cx && cy === +cy && r === +r ? __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("circle", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__.e)(this.props, null, !0), {
+                    className: layerClass,
+                    cx: cx,
+                    cy: cy,
+                    r: r
+                })) : null;
+            }
+        } ]), Dot;
+    }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "Dot", _class2.propTypes = {
+        className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        cx: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        cy: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        r: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number
+    }, _class = _temp)) || _class;
+    __webpack_exports__.a = Dot;
+}, function(module, exports, __webpack_require__) {
+    var IObject = __webpack_require__(134), defined = __webpack_require__(136);
+    module.exports = function(it) {
+        return IObject(defined(it));
+    };
+}, function(module, exports, __webpack_require__) {
+    var defined = __webpack_require__(136);
+    module.exports = function(it) {
+        return Object(defined(it));
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    Object.defineProperty(exports, "__esModule", {
+        value: !0
+    });
+    var _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
+        return typeof obj;
+    } : function(obj) {
+        return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), _warning = __webpack_require__(12), _warning2 = _interopRequireDefault(_warning), _toCss = __webpack_require__(152), _toCss2 = _interopRequireDefault(_toCss), _toCssValue = __webpack_require__(106), _toCssValue2 = _interopRequireDefault(_toCssValue), StyleRule = function() {
+        function StyleRule(key, style, options) {
+            _classCallCheck(this, StyleRule), this.type = "style", this.isProcessed = !1;
+            var sheet = options.sheet, Renderer = options.Renderer, selector = options.selector;
+            this.key = key, this.options = options, this.style = style, selector && (this.selectorText = selector), 
+            this.renderer = sheet ? sheet.renderer : new Renderer();
+        }
+        return _createClass(StyleRule, [ {
+            key: "prop",
+            value: function(name, value) {
+                if (void 0 === value) return this.style[name];
+                if (this.style[name] === value) return this;
+                value = this.options.jss.plugins.onChangeValue(value, name, this);
+                var isEmpty = null == value || !1 === value, isDefined = name in this.style;
+                if (isEmpty && !isDefined) return this;
+                var remove = isEmpty && isDefined;
+                if (remove ? delete this.style[name] : this.style[name] = value, this.renderable) return remove ? this.renderer.removeProperty(this.renderable, name) : this.renderer.setProperty(this.renderable, name, value), 
+                this;
+                var sheet = this.options.sheet;
+                return sheet && sheet.attached && (0, _warning2.default)(!1, 'Rule is not linked. Missing sheet option "link: true".'), 
+                this;
+            }
+        }, {
+            key: "applyTo",
+            value: function(renderable) {
+                var json = this.toJSON();
+                for (var prop in json) this.renderer.setProperty(renderable, prop, json[prop]);
+                return this;
+            }
+        }, {
+            key: "toJSON",
+            value: function() {
+                var json = {};
+                for (var prop in this.style) {
+                    var value = this.style[prop];
+                    "object" !== (void 0 === value ? "undefined" : _typeof(value)) ? json[prop] = value : Array.isArray(value) && (json[prop] = (0, 
+                    _toCssValue2.default)(value));
+                }
+                return json;
+            }
+        }, {
+            key: "toString",
+            value: function(options) {
+                var sheet = this.options.sheet, link = !!sheet && sheet.options.link, opts = link ? _extends({}, options, {
+                    allowEmpty: !0
+                }) : options;
+                return (0, _toCss2.default)(this.selector, this.style, opts);
+            }
+        }, {
+            key: "selector",
+            set: function(selector) {
+                if (selector !== this.selectorText && (this.selectorText = selector, this.renderable)) {
+                    if (!this.renderer.setSelector(this.renderable, selector) && this.renderable) {
+                        var renderable = this.renderer.replaceRule(this.renderable, this);
+                        renderable && (this.renderable = renderable);
+                    }
+                }
+            },
+            get: function() {
+                return this.selectorText;
+            }
+        } ]), StyleRule;
+    }();
+    exports.default = StyleRule;
+}, function(module, exports) {
+    var g;
+    g = function() {
+        return this;
+    }();
+    try {
+        g = g || Function("return this")() || (0, eval)("this");
+    } catch (e) {
+        "object" == typeof window && (g = window);
+    }
+    module.exports = g;
+}, function(module, exports, __webpack_require__) {
+    function isSymbol(value) {
+        return "symbol" == typeof value || isObjectLike(value) && baseGetTag(value) == symbolTag;
+    }
+    var baseGetTag = __webpack_require__(41), isObjectLike = __webpack_require__(36), symbolTag = "[object Symbol]";
+    module.exports = isSymbol;
+}, function(module, exports) {
+    function identity(value) {
+        return value;
+    }
+    module.exports = identity;
+}, function(module, exports, __webpack_require__) {
+    function baseIteratee(value) {
+        return "function" == typeof value ? value : null == value ? identity : "object" == typeof value ? isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value) : property(value);
+    }
+    var baseMatches = __webpack_require__(671), baseMatchesProperty = __webpack_require__(674), identity = __webpack_require__(62), isArray = __webpack_require__(11), property = __webpack_require__(678);
+    module.exports = baseIteratee;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(a, b) {
+        return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _class2, _temp2, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3_react_smooth__ = __webpack_require__(33), __WEBPACK_IMPORTED_MODULE_3_react_smooth___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react_smooth__), __WEBPACK_IMPORTED_MODULE_4__util_PureRender__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__ = __webpack_require__(4), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), getRectangePath = function(x, y, width, height, radius) {
+        var maxRadius = Math.min(Math.abs(width) / 2, Math.abs(height) / 2), sign = height >= 0 ? 1 : -1, clockWise = height >= 0 ? 1 : 0, path = void 0;
+        if (maxRadius > 0 && radius instanceof Array) {
+            for (var newRadius = [], i = 0; i < 4; i++) newRadius[i] = radius[i] > maxRadius ? maxRadius : radius[i];
+            path = "M" + x + "," + (y + sign * newRadius[0]), newRadius[0] > 0 && (path += "A " + newRadius[0] + "," + newRadius[0] + ",0,0," + clockWise + "," + (x + newRadius[0]) + "," + y), 
+            path += "L " + (x + width - newRadius[1]) + "," + y, newRadius[1] > 0 && (path += "A " + newRadius[1] + "," + newRadius[1] + ",0,0," + clockWise + ",\n        " + (x + width) + "," + (y + sign * newRadius[1])), 
+            path += "L " + (x + width) + "," + (y + height - sign * newRadius[2]), newRadius[2] > 0 && (path += "A " + newRadius[2] + "," + newRadius[2] + ",0,0," + clockWise + ",\n        " + (x + width - newRadius[2]) + "," + (y + height)), 
+            path += "L " + (x + newRadius[3]) + "," + (y + height), newRadius[3] > 0 && (path += "A " + newRadius[3] + "," + newRadius[3] + ",0,0," + clockWise + ",\n        " + x + "," + (y + height - sign * newRadius[3])), 
+            path += "Z";
+        } else if (maxRadius > 0 && radius === +radius && radius > 0) {
+            var _newRadius = Math.min(maxRadius, radius);
+            path = "M " + x + "," + (y + sign * _newRadius) + "\n            A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + _newRadius) + "," + y + "\n            L " + (x + width - _newRadius) + "," + y + "\n            A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + width) + "," + (y + sign * _newRadius) + "\n            L " + (x + width) + "," + (y + height - sign * _newRadius) + "\n            A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + width - _newRadius) + "," + (y + height) + "\n            L " + (x + _newRadius) + "," + (y + height) + "\n            A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + x + "," + (y + height - sign * _newRadius) + " Z";
+        } else path = "M " + x + "," + y + " h " + width + " v " + height + " h " + -width + " Z";
+        return path;
+    }, Rectangle = Object(__WEBPACK_IMPORTED_MODULE_4__util_PureRender__.a)((_temp2 = _class2 = function(_Component) {
+        function Rectangle() {
+            var _ref, _temp, _this, _ret;
+            _classCallCheck(this, Rectangle);
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+            return _temp = _this = _possibleConstructorReturn(this, (_ref = Rectangle.__proto__ || Object.getPrototypeOf(Rectangle)).call.apply(_ref, [ this ].concat(args))), 
+            _this.state = {
+                totalLength: -1
+            }, _ret = _temp, _possibleConstructorReturn(_this, _ret);
+        }
+        return _inherits(Rectangle, _Component), _createClass(Rectangle, [ {
+            key: "componentDidMount",
+            value: function() {
+                if (this.node && this.node.getTotalLength) try {
+                    var totalLength = this.node.getTotalLength();
+                    totalLength && this.setState({
+                        totalLength: totalLength
+                    });
+                } catch (err) {}
+            }
+        }, {
+            key: "render",
+            value: function() {
+                var _this2 = this, _props = this.props, x = _props.x, y = _props.y, width = _props.width, height = _props.height, radius = _props.radius, className = _props.className, totalLength = this.state.totalLength, _props2 = this.props, animationEasing = _props2.animationEasing, animationDuration = _props2.animationDuration, animationBegin = _props2.animationBegin, isAnimationActive = _props2.isAnimationActive, isUpdateAnimationActive = _props2.isUpdateAnimationActive;
+                if (x !== +x || y !== +y || width !== +width || height !== +height || 0 === width || 0 === height) return null;
+                var layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-rectangle", className);
+                return isUpdateAnimationActive ? __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3_react_smooth___default.a, {
+                    canBegin: totalLength > 0,
+                    from: {
+                        width: width,
+                        height: height,
+                        x: x,
+                        y: y
+                    },
+                    to: {
+                        width: width,
+                        height: height,
+                        x: x,
+                        y: y
+                    },
+                    duration: animationDuration,
+                    animationEasing: animationEasing,
+                    isActive: isUpdateAnimationActive
+                }, function(_ref2) {
+                    var currWidth = _ref2.width, currHeight = _ref2.height, currX = _ref2.x, currY = _ref2.y;
+                    return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3_react_smooth___default.a, {
+                        canBegin: totalLength > 0,
+                        from: "0px " + (-1 === totalLength ? 1 : totalLength) + "px",
+                        to: totalLength + "px 0px",
+                        attributeName: "strokeDasharray",
+                        begin: animationBegin,
+                        duration: animationDuration,
+                        isActive: isAnimationActive,
+                        easing: animationEasing
+                    }, __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.k)(_this2.props), Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.e)(_this2.props), {
+                        className: layerClass,
+                        d: getRectangePath(currX, currY, currWidth, currHeight, radius),
+                        ref: function(node) {
+                            _this2.node = node;
+                        }
+                    })));
+                }) : __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.e)(this.props), {
+                    className: layerClass,
+                    d: getRectangePath(x, y, width, height, radius)
+                }));
+            }
+        } ]), Rectangle;
+    }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "Rectangle", 
+    _class2.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.c, __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.a, {
+        className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        x: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        y: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        radius: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array ]),
+        isAnimationActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        isUpdateAnimationActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        animationBegin: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        animationDuration: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        animationEasing: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "ease", "ease-in", "ease-out", "ease-in-out", "linear" ])
+    }), _class2.defaultProps = {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        radius: 0,
+        isAnimationActive: !1,
+        isUpdateAnimationActive: !1,
+        animationBegin: 0,
+        animationDuration: 1500,
+        animationEasing: "ease"
+    }, _class = _temp2)) || _class;
+    __webpack_exports__.a = Rectangle;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_lodash_isArray__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_0_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__), __WEBPACK_IMPORTED_MODULE_3_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_3_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_prop_types__), __WEBPACK_IMPORTED_MODULE_4_d3_shape__ = __webpack_require__(172), __WEBPACK_IMPORTED_MODULE_5_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_5_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_classnames__), __WEBPACK_IMPORTED_MODULE_6__util_PureRender__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_8__util_DataUtils__ = __webpack_require__(9), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), CURVE_FACTORIES = {
+        curveBasisClosed: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.c,
+        curveBasisOpen: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.d,
+        curveBasis: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.b,
+        curveLinearClosed: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.f,
+        curveLinear: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.e,
+        curveMonotoneX: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.g,
+        curveMonotoneY: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.h,
+        curveNatural: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.i,
+        curveStep: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.j,
+        curveStepAfter: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.k,
+        curveStepBefore: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.l
+    }, defined = function(p) {
+        return p.x === +p.x && p.y === +p.y;
+    }, getX = function(p) {
+        return p.x;
+    }, getY = function(p) {
+        return p.y;
+    }, getCurveFactory = function(type, layout) {
+        if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(type)) return type;
+        var name = "curve" + type.slice(0, 1).toUpperCase() + type.slice(1);
+        return "curveMonotone" === name && layout ? CURVE_FACTORIES[name + ("vertical" === layout ? "Y" : "X")] : CURVE_FACTORIES[name] || __WEBPACK_IMPORTED_MODULE_4_d3_shape__.e;
+    }, Curve = Object(__WEBPACK_IMPORTED_MODULE_6__util_PureRender__.a)((_temp = _class2 = function(_Component) {
+        function Curve() {
+            return _classCallCheck(this, Curve), _possibleConstructorReturn(this, (Curve.__proto__ || Object.getPrototypeOf(Curve)).apply(this, arguments));
+        }
+        return _inherits(Curve, _Component), _createClass(Curve, [ {
+            key: "getPath",
+            value: function() {
+                var _props = this.props, type = _props.type, points = _props.points, baseLine = _props.baseLine, layout = _props.layout, connectNulls = _props.connectNulls, curveFactory = getCurveFactory(type, layout), formatPoints = connectNulls ? points.filter(function(entry) {
+                    return defined(entry);
+                }) : points, lineFunction = void 0;
+                if (__WEBPACK_IMPORTED_MODULE_0_lodash_isArray___default()(baseLine)) {
+                    var areaPoints = formatPoints.map(function(entry, index) {
+                        return _extends({}, entry, {
+                            base: baseLine[index]
+                        });
+                    });
+                    return lineFunction = "vertical" === layout ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().y(getY).x1(getX).x0(function(d) {
+                        return d.base.x;
+                    }) : Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().x(getX).y1(getY).y0(function(d) {
+                        return d.base.y;
+                    }), lineFunction.defined(defined).curve(curveFactory), lineFunction(areaPoints);
+                }
+                return lineFunction = "vertical" === layout && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(baseLine) ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().y(getY).x1(getX).x0(baseLine) : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(baseLine) ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().x(getX).y1(getY).y0(baseLine) : Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.m)().x(getX).y(getY), 
+                lineFunction.defined(defined).curve(curveFactory), lineFunction(formatPoints);
+            }
+        }, {
+            key: "render",
+            value: function() {
+                var _props2 = this.props, className = _props2.className, points = _props2.points, path = _props2.path, pathRef = _props2.pathRef;
+                if (!(points && points.length || path)) return null;
+                var realPath = points && points.length ? this.getPath() : path;
+                return __WEBPACK_IMPORTED_MODULE_2_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.e)(this.props, null, !0), {
+                    className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-curve", className),
+                    d: realPath,
+                    ref: pathRef
+                }));
+            }
+        } ]), Curve;
+    }(__WEBPACK_IMPORTED_MODULE_2_react__.Component), _class2.displayName = "Curve", 
+    _class2.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.c, {
+        className: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string,
+        type: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOf([ "basis", "basisClosed", "basisOpen", "linear", "linearClosed", "natural", "monotoneX", "monotoneY", "monotone", "step", "stepBefore", "stepAfter" ]), __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.func ]),
+        layout: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOf([ "horizontal", "vertical" ]),
+        baseLine: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.array ]),
+        points: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object),
+        connectNulls: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool,
+        path: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string,
+        pathRef: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.func
+    }), _class2.defaultProps = {
+        type: "linear",
+        points: [],
+        connectNulls: !1
+    }, _class = _temp)) || _class;
+    __webpack_exports__.a = Curve;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), 
+    __webpack_require__(1)), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__util_PureRender__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(4), _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), XAxis = Object(__WEBPACK_IMPORTED_MODULE_2__util_PureRender__.a)((_temp = _class2 = function(_Component) {
+        function XAxis() {
+            return _classCallCheck(this, XAxis), _possibleConstructorReturn(this, (XAxis.__proto__ || Object.getPrototypeOf(XAxis)).apply(this, arguments));
+        }
+        return _inherits(XAxis, _Component), _createClass(XAxis, [ {
+            key: "render",
+            value: function() {
+                return null;
+            }
+        } ]), XAxis;
+    }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "XAxis", 
+    _class2.propTypes = {
+        allowDecimals: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        allowDuplicatedCategory: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        hide: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        name: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        unit: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        xAxisId: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        domain: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "dataMin", "dataMax" ]) ])),
+        dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]),
+        width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        mirror: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        orientation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "top", "bottom" ]),
+        type: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "number", "category" ]),
+        ticks: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array,
+        tickCount: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        tickFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func,
+        padding: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({
+            left: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+            right: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number
+        }),
+        allowDataOverflow: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        scale: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.d), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]),
+        tick: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.element ]),
+        axisLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]),
+        tickLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]),
+        minTickGap: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        tickSize: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        interval: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "preserveStart", "preserveEnd", "preserveStartEnd" ]) ]),
+        reversed: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool
+    }, _class2.defaultProps = {
+        allowDecimals: !0,
+        hide: !1,
+        orientation: "bottom",
+        width: 0,
+        height: 30,
+        mirror: !1,
+        xAxisId: 0,
+        tickCount: 5,
+        type: "category",
+        domain: [ 0, "auto" ],
+        padding: {
+            left: 0,
+            right: 0
+        },
+        allowDataOverflow: !1,
+        scale: "auto",
+        reversed: !1,
+        allowDuplicatedCategory: !0
+    }, _class = _temp)) || _class;
+    __webpack_exports__.a = XAxis;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), 
+    __webpack_require__(1)), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__util_PureRender__ = __webpack_require__(5), _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), YAxis = Object(__WEBPACK_IMPORTED_MODULE_2__util_PureRender__.a)((_temp = _class2 = function(_Component) {
+        function YAxis() {
+            return _classCallCheck(this, YAxis), _possibleConstructorReturn(this, (YAxis.__proto__ || Object.getPrototypeOf(YAxis)).apply(this, arguments));
+        }
+        return _inherits(YAxis, _Component), _createClass(YAxis, [ {
+            key: "render",
+            value: function() {
+                return null;
+            }
+        } ]), YAxis;
+    }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "YAxis", 
+    _class2.propTypes = {
+        allowDecimals: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        allowDuplicatedCategory: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        hide: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        name: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        unit: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        yAxisId: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]),
+        domain: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "dataMin", "dataMax" ]) ])),
+        dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]),
+        ticks: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array,
+        tickCount: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        tickFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func,
+        width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        mirror: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        orientation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "left", "right" ]),
+        type: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "number", "category" ]),
+        padding: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({
+            top: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+            bottom: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number
+        }),
+        allowDataOverflow: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool,
+        scale: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "linear", "pow", "sqrt", "log", "identity", "time", "band", "point", "ordinal", "quantile", "quantize", "utcTime", "sequential", "threshold" ]), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]),
+        tick: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.element ]),
+        axisLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]),
+        tickLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]),
+        minTickGap: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        tickSize: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        interval: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "preserveStart", "preserveEnd", "preserveStartEnd" ]) ]),
+        reversed: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool
+    }, _class2.defaultProps = {
+        allowDuplicatedCategory: !0,
+        allowDecimals: !0,
+        hide: !1,
+        orientation: "left",
+        width: 60,
+        height: 0,
+        mirror: !1,
+        yAxisId: 0,
+        tickCount: 5,
+        type: "number",
+        domain: [ 0, "auto" ],
+        padding: {
+            top: 0,
+            bottom: 0
+        },
+        allowDataOverflow: !1,
+        scale: "auto",
+        reversed: !1
+    }, _class = _temp)) || _class;
+    __webpack_exports__.a = YAxis;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function toObject(val) {
+        if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined");
+        return Object(val);
+    }
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols, hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    module.exports = function() {
+        try {
+            if (!Object.assign) return !1;
+            var test1 = new String("abc");
+            if (test1[5] = "de", "5" === Object.getOwnPropertyNames(test1)[0]) return !1;
+            for (var test2 = {}, i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
+            if ("0123456789" !== Object.getOwnPropertyNames(test2).map(function(n) {
+                return test2[n];
+            }).join("")) return !1;
+            var test3 = {};
+            return "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+                test3[letter] = letter;
+            }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, test3)).join("");
+        } catch (err) {
+            return !1;
+        }
+    }() ? Object.assign : function(target, source) {
+        for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) {
+            from = Object(arguments[s]);
+            for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]);
+            if (getOwnPropertySymbols) {
+                symbols = getOwnPropertySymbols(from);
+                for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]);
+            }
+        }
+        return to;
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        function invariant(condition, format, a, b, c, d, e, f) {
+            if (validateFormat(format), !condition) {
+                var error;
+                if (void 0 === format) error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); else {
+                    var args = [ a, b, c, d, e, f ], argIndex = 0;
+                    error = new Error(format.replace(/%s/g, function() {
+                        return args[argIndex++];
+                    })), error.name = "Invariant Violation";
+                }
+                throw error.framesToPop = 1, error;
+            }
+        }
+        var validateFormat = function(format) {};
+        "production" !== process.env.NODE_ENV && (validateFormat = function(format) {
+            if (void 0 === format) throw new Error("invariant requires an error message argument");
+        }), module.exports = invariant;
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports) {
+    module.exports = function(bitmap, value) {
+        return {
+            enumerable: !(1 & bitmap),
+            configurable: !(2 & bitmap),
+            writable: !(4 & bitmap),
+            value: value
+        };
+    };
+}, function(module, exports, __webpack_require__) {
+    var $keys = __webpack_require__(208), enumBugKeys = __webpack_require__(140);
+    module.exports = Object.keys || function(O) {
+        return $keys(O, enumBugKeys);
+    };
+}, function(module, exports) {
+    module.exports = {};
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    function createBreakpoints(breakpoints) {
+        function up(key) {
+            return "@media (min-width:" + ("number" == typeof values[key] ? values[key] : key) + unit + ")";
+        }
+        function down(key) {
+            var endIndex = keys.indexOf(key) + 1, upperbound = values[keys[endIndex]];
+            return endIndex === keys.length ? up("xs") : "@media (max-width:" + (("number" == typeof upperbound && endIndex > 0 ? upperbound : key) - step / 100) + unit + ")";
+        }
+        function between(start, end) {
+            var endIndex = keys.indexOf(end) + 1;
+            return endIndex === keys.length ? up(start) : "@media (min-width:" + values[start] + unit + ") and (max-width:" + (values[keys[endIndex]] - step / 100) + unit + ")";
+        }
+        function only(key) {
+            return between(key, key);
+        }
+        function width(key) {
+            return values[key];
+        }
+        var _breakpoints$values = breakpoints.values, values = void 0 === _breakpoints$values ? {
+            xs: 0,
+            sm: 600,
+            md: 960,
+            lg: 1280,
+            xl: 1920
+        } : _breakpoints$values, _breakpoints$unit = breakpoints.unit, unit = void 0 === _breakpoints$unit ? "px" : _breakpoints$unit, _breakpoints$step = breakpoints.step, step = void 0 === _breakpoints$step ? 5 : _breakpoints$step, other = (0, 
+        _objectWithoutProperties3.default)(breakpoints, [ "values", "unit", "step" ]);
+        return (0, _extends3.default)({
+            keys: keys,
+            values: values,
+            up: up,
+            down: down,
+            between: between,
+            only: only,
+            width: width
+        }, other);
+    }
+    Object.defineProperty(exports, "__esModule", {
+        value: !0
+    }), exports.keys = void 0;
+    var _extends2 = __webpack_require__(6), _extends3 = _interopRequireDefault(_extends2), _objectWithoutProperties2 = __webpack_require__(7), _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
+    exports.default = createBreakpoints;
+    var keys = exports.keys = [ "xs", "sm", "md", "lg", "xl" ];
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    exports.__esModule = !0;
+    var _getDisplayName = __webpack_require__(226), _getDisplayName2 = function(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }(_getDisplayName), wrapDisplayName = function(BaseComponent, hocName) {
+        return hocName + "(" + (0, _getDisplayName2.default)(BaseComponent) + ")";
+    };
+    exports.default = wrapDisplayName;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    Object.defineProperty(exports, "__esModule", {
+        value: !0
+    });
+    var _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), _createRule = __webpack_require__(107), _createRule2 = _interopRequireDefault(_createRule), _linkRule = __webpack_require__(231), _linkRule2 = _interopRequireDefault(_linkRule), _StyleRule = __webpack_require__(59), _StyleRule2 = _interopRequireDefault(_StyleRule), _escape = __webpack_require__(428), _escape2 = _interopRequireDefault(_escape), RuleList = function() {
+        function RuleList(options) {
+            _classCallCheck(this, RuleList), this.map = {}, this.raw = {}, this.index = [], 
+            this.options = options, this.classes = options.classes;
+        }
+        return _createClass(RuleList, [ {
+            key: "add",
+            value: function(name, decl, options) {
+                var _options = this.options, parent = _options.parent, sheet = _options.sheet, jss = _options.jss, Renderer = _options.Renderer, generateClassName = _options.generateClassName;
+                options = _extends({
+                    classes: this.classes,
+                    parent: parent,
+                    sheet: sheet,
+                    jss: jss,
+                    Renderer: Renderer,
+                    generateClassName: generateClassName
+                }, options), !options.selector && this.classes[name] && (options.selector = "." + (0, 
+                _escape2.default)(this.classes[name])), this.raw[name] = decl;
+                var rule = (0, _createRule2.default)(name, decl, options), className = void 0;
+                !options.selector && rule instanceof _StyleRule2.default && (className = generateClassName(rule, sheet), 
+                rule.selector = "." + (0, _escape2.default)(className)), this.register(rule, className);
+                var index = void 0 === options.index ? this.index.length : options.index;
+                return this.index.splice(index, 0, rule), rule;
+            }
+        }, {
+            key: "get",
+            value: function(name) {
+                return this.map[name];
+            }
+        }, {
+            key: "remove",
+            value: function(rule) {
+                this.unregister(rule), this.index.splice(this.indexOf(rule), 1);
+            }
+        }, {
+            key: "indexOf",
+            value: function(rule) {
+                return this.index.indexOf(rule);
+            }
+        }, {
+            key: "process",
+            value: function() {
+                var plugins = this.options.jss.plugins;
+                this.index.slice(0).forEach(plugins.onProcessRule, plugins);
+            }
+        }, {
+            key: "register",
+            value: function(rule, className) {
+                this.map[rule.key] = rule, rule instanceof _StyleRule2.default && (this.map[rule.selector] = rule, 
+                className && (this.classes[rule.key] = className));
+            }
+        }, {
+            key: "unregister",
+            value: function(rule) {
+                delete this.map[rule.key], rule instanceof _StyleRule2.default && (delete this.map[rule.selector], 
+                delete this.classes[rule.key]);
+            }
+        }, {
+            key: "update",
+            value: function(name, data) {
+                var _options2 = this.options, plugins = _options2.jss.plugins, sheet = _options2.sheet;
+                if ("string" == typeof name) return void plugins.onUpdate(data, this.get(name), sheet);
+                for (var index = 0; index < this.index.length; index++) plugins.onUpdate(name, this.index[index], sheet);
+            }
+        }, {
+            key: "link",
+            value: function(cssRules) {
+                for (var map = this.options.sheet.renderer.getUnescapedKeysMap(this.index), i = 0; i < cssRules.length; i++) {
+                    var cssRule = cssRules[i], _key = this.options.sheet.renderer.getKey(cssRule);
+                    map[_key] && (_key = map[_key]);
+                    var rule = this.map[_key];
+                    rule && (0, _linkRule2.default)(rule, cssRule);
+                }
+            }
+        }, {
+            key: "toString",
+            value: function(options) {
+                for (var str = "", sheet = this.options.sheet, link = !!sheet && sheet.options.link, index = 0; index < this.index.length; index++) {
+                    var rule = this.index[index], css = rule.toString(options);
+                    (css || link) && (str && (str += "\n"), str += css);
+                }
+                return str;
+            }
+        } ]), RuleList;
+    }();
+    exports.default = RuleList;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: !0
+    });
+    var _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, menuSkeletons = [ {
+        id: "home",
+        menu: {
+            title: "Home",
+            icon: "home"
+        }
+    }, {
+        id: "chain",
+        menu: {
+            title: "Chain",
+            icon: "link"
+        }
+    }, {
+        id: "txpool",
+        menu: {
+            title: "TxPool",
+            icon: "credit-card"
+        }
+    }, {
+        id: "network",
+        menu: {
+            title: "Network",
+            icon: "globe"
+        }
+    }, {
+        id: "system",
+        menu: {
+            title: "System",
+            icon: "tachometer"
+        }
+    }, {
+        id: "logs",
+        menu: {
+            title: "Logs",
+            icon: "list"
+        }
+    } ];
+    exports.MENU = new Map(menuSkeletons.map(function(_ref) {
+        var id = _ref.id, menu = _ref.menu;
+        return [ id, _extends({
+            id: id
+        }, menu) ];
+    })), exports.DURATION = 200, exports.styles = {
+        light: {
+            color: "rgba(255, 255, 255, 0.54)"
+        }
+    };
+}, function(module, exports, __webpack_require__) {
+    var root = __webpack_require__(32), Symbol = root.Symbol;
+    module.exports = Symbol;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function Surface(props) {
+        var children = props.children, width = props.width, height = props.height, viewBox = props.viewBox, className = props.className, style = props.style, others = _objectWithoutProperties(props, [ "children", "width", "height", "viewBox", "className", "style" ]), svgView = viewBox || {
+            width: width,
+            height: height,
+            x: 0,
+            y: 0
+        }, layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-surface", className), attrs = Object(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.k)(others);
+        return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("svg", _extends({}, attrs, {
+            className: layerClass,
+            width: width,
+            height: height,
+            style: style,
+            viewBox: svgView.x + " " + svgView.y + " " + svgView.width + " " + svgView.height,
+            version: "1.1"
+        }), children);
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(3), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(4), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, propTypes = {
+        width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number.isRequired,
+        height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number.isRequired,
+        viewBox: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({
+            x: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+            y: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+            width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+            height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number
+        }),
+        className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        style: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
+        children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node ])
+    };
+    Surface.propTypes = propTypes, __webpack_exports__.a = Surface;
+}, function(module, exports) {
+    function arrayMap(array, iteratee) {
+        for (var index = -1, length = null == array ? 0 : array.length, result = Array(length); ++index < length; ) result[index] = iteratee(array[index], index, array);
+        return result;
+    }
+    module.exports = arrayMap;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    var __WEBPACK_IMPORTED_MODULE_0__src_path__ = __webpack_require__(586);
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_path__.a;
+    });
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function acos(x) {
+        return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+    }
+    function asin(x) {
+        return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x);
+    }
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return abs;
+    }), __webpack_require__.d(__webpack_exports__, "d", function() {
+        return atan2;
+    }), __webpack_require__.d(__webpack_exports__, "e", function() {
+        return cos;
+    }), __webpack_require__.d(__webpack_exports__, "h", function() {
+        return max;
+    }), __webpack_require__.d(__webpack_exports__, "i", function() {
+        return min;
+    }), __webpack_require__.d(__webpack_exports__, "k", function() {
+        return sin;
+    }), __webpack_require__.d(__webpack_exports__, "l", function() {
+        return sqrt;
+    }), __webpack_require__.d(__webpack_exports__, "f", function() {
+        return epsilon;
+    }), __webpack_require__.d(__webpack_exports__, "j", function() {
+        return pi;
+    }), __webpack_require__.d(__webpack_exports__, "g", function() {
+        return halfPi;
+    }), __webpack_require__.d(__webpack_exports__, "m", function() {
+        return tau;
+    }), __webpack_exports__.b = acos, __webpack_exports__.c = asin;
+    var abs = Math.abs, atan2 = Math.atan2, cos = Math.cos, max = Math.max, min = Math.min, sin = Math.sin, sqrt = Math.sqrt, epsilon = 1e-12, pi = Math.PI, halfPi = pi / 2, tau = 2 * pi;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(series, order) {
+        if ((n = series.length) > 1) for (var j, s0, n, i = 1, s1 = series[order[0]], m = s1.length; i < n; ++i) for (s0 = s1, 
+        s1 = series[order[i]], j = 0; j < m; ++j) s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1];
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(series) {
+        for (var n = series.length, o = new Array(n); --n >= 0; ) o[n] = n;
+        return o;
+    };
+}, function(module, exports, __webpack_require__) {
+    function isArrayLike(value) {
+        return null != value && isLength(value.length) && !isFunction(value);
+    }
+    var isFunction = __webpack_require__(8), isLength = __webpack_require__(181);
+    module.exports = isArrayLike;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function Cell() {
+        return null;
+    }
+    var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__util_ReactUtils__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), 
+    __webpack_require__(4)), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    };
+    Cell.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_1__util_ReactUtils__.c), 
+    Cell.displayName = "Cell", __webpack_exports__.a = Cell;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(x) {
+        return null === x ? NaN : +x;
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function linearish(scale) {
+        var domain = scale.domain;
+        return scale.ticks = function(count) {
+            var d = domain();
+            return Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.h)(d[0], d[d.length - 1], null == count ? 10 : count);
+        }, scale.tickFormat = function(count, specifier) {
+            return Object(__WEBPACK_IMPORTED_MODULE_3__tickFormat__.a)(domain(), count, specifier);
+        }, scale.nice = function(count) {
+            null == count && (count = 10);
+            var step, d = domain(), i0 = 0, i1 = d.length - 1, start = d[i0], stop = d[i1];
+            return stop < start && (step = start, start = stop, stop = step, step = i0, i0 = i1, 
+            i1 = step), step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count), 
+            step > 0 ? (start = Math.floor(start / step) * step, stop = Math.ceil(stop / step) * step, 
+            step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count)) : step < 0 && (start = Math.ceil(start * step) / step, 
+            stop = Math.floor(stop * step) / step, step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count)), 
+            step > 0 ? (d[i0] = Math.floor(start / step) * step, d[i1] = Math.ceil(stop / step) * step, 
+            domain(d)) : step < 0 && (d[i0] = Math.ceil(start * step) / step, d[i1] = Math.floor(stop * step) / step, 
+            domain(d)), scale;
+        }, scale;
+    }
+    function linear() {
+        var scale = Object(__WEBPACK_IMPORTED_MODULE_2__continuous__.b)(__WEBPACK_IMPORTED_MODULE_2__continuous__.c, __WEBPACK_IMPORTED_MODULE_1_d3_interpolate__.c);
+        return scale.copy = function() {
+            return Object(__WEBPACK_IMPORTED_MODULE_2__continuous__.a)(scale, linear());
+        }, linearish(scale);
+    }
+    __webpack_exports__.b = linearish, __webpack_exports__.a = linear;
+    var __WEBPACK_IMPORTED_MODULE_0_d3_array__ = __webpack_require__(37), __WEBPACK_IMPORTED_MODULE_1_d3_interpolate__ = __webpack_require__(89), __WEBPACK_IMPORTED_MODULE_2__continuous__ = __webpack_require__(125), __WEBPACK_IMPORTED_MODULE_3__tickFormat__ = __webpack_require__(742);
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    var __WEBPACK_IMPORTED_MODULE_0__src_value__ = __webpack_require__(186);
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return __WEBPACK_IMPORTED_MODULE_0__src_value__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_5__src_number__ = (__webpack_require__(310), __webpack_require__(189), 
+    __webpack_require__(308), __webpack_require__(311), __webpack_require__(124));
+    __webpack_require__.d(__webpack_exports__, "c", function() {
+        return __WEBPACK_IMPORTED_MODULE_5__src_number__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_7__src_round__ = (__webpack_require__(312), __webpack_require__(732));
+    __webpack_require__.d(__webpack_exports__, "d", function() {
+        return __WEBPACK_IMPORTED_MODULE_7__src_round__.a;
+    });
+    var __WEBPACK_IMPORTED_MODULE_15__src_cubehelix__ = (__webpack_require__(313), __webpack_require__(733), 
+    __webpack_require__(736), __webpack_require__(307), __webpack_require__(737), __webpack_require__(738), 
+    __webpack_require__(739), __webpack_require__(740));
+    __webpack_require__.d(__webpack_exports__, "b", function() {
+        return __WEBPACK_IMPORTED_MODULE_15__src_cubehelix__.a;
+    });
+    __webpack_require__(741);
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function linear(a, d) {
+        return function(t) {
+            return a + t * d;
+        };
+    }
+    function exponential(a, b, y) {
+        return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) {
+            return Math.pow(a + t * b, y);
+        };
+    }
+    function hue(a, b) {
+        var d = b - a;
+        return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a);
+    }
+    function gamma(y) {
+        return 1 == (y = +y) ? nogamma : function(a, b) {
+            return b - a ? exponential(a, b, y) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a);
+        };
+    }
+    function nogamma(a, b) {
+        var d = b - a;
+        return d ? linear(a, d) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a);
+    }
+    __webpack_exports__.c = hue, __webpack_exports__.b = gamma, __webpack_exports__.a = nogamma;
+    var __WEBPACK_IMPORTED_MODULE_0__constant__ = __webpack_require__(309);
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    __webpack_exports__.a = function(s) {
+        return s.match(/.{6}/g).map(function(x) {
+            return "#" + x;
+        });
+    };
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _objectWithoutProperties(obj, keys) {
+        var target = {};
+        for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]);
+        return target;
+    }
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var _class, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__container_Layer__ = __webpack_require__(14), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(4), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, _createClass = function() {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, 
+                "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+        return function(Constructor, protoProps, staticProps) {
+            return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), 
+            Constructor;
+        };
+    }(), ErrorBar = (_temp = _class = function(_Component) {
+        function ErrorBar() {
+            return _classCallCheck(this, ErrorBar), _possibleConstructorReturn(this, (ErrorBar.__proto__ || Object.getPrototypeOf(ErrorBar)).apply(this, arguments));
+        }
+        return _inherits(ErrorBar, _Component), _createClass(ErrorBar, [ {
+            key: "renderErrorBars",
+            value: function() {
+                var _props = this.props, offset = _props.offset, layout = _props.layout, width = _props.width, dataKey = _props.dataKey, data = _props.data, dataPointFormatter = _props.dataPointFormatter, xAxis = _props.xAxis, yAxis = _props.yAxis, others = _objectWithoutProperties(_props, [ "offset", "layout", "width", "dataKey", "data", "dataPointFormatter", "xAxis", "yAxis" ]), props = Object(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.k)(others);
+                return data.map(function(entry, i) {
+                    var _dataPointFormatter = dataPointFormatter(entry, dataKey), x = _dataPointFormatter.x, y = _dataPointFormatter.y, value = _dataPointFormatter.value, errorVal = _dataPointFormatter.errorVal;
+                    if (!errorVal) return null;
+                    var xMid = void 0, yMid = void 0, xMin = void 0, yMin = void 0, xMax = void 0, yMax = void 0, scale = void 0, coordsTop = void 0, coordsMid = void 0, coordsBot = void 0, lowBound = void 0, highBound = void 0;
+                    return Array.isArray(errorVal) ? (lowBound = errorVal[0], highBound = errorVal[1]) : (lowBound = errorVal, 
+                    highBound = errorVal), "vertical" === layout ? (scale = xAxis.scale, xMid = value, 
+                    yMid = y + offset, xMin = scale(xMid - lowBound), yMin = yMid + width, xMax = scale(xMid + highBound), 
+                    yMax = yMid - width, coordsTop = {
+                        x1: xMax,
+                        y1: yMin,
+                        x2: xMax,
+                        y2: yMax
+                    }, coordsMid = {
+                        x1: xMin,
+                        y1: yMid,
+                        x2: xMax,
+                        y2: yMid
+                    }, coordsBot = {
+                        x1: xMin,
+                        y1: yMin,
+                        x2: xMin,
+                        y2: yMax
+                    }) : "horizontal" === layout && (scale = yAxis.scale, xMid = x + offset, yMid = value, 
+                    xMin = xMid - width, xMax = xMid + width, yMin = scale(yMid - lowBound), yMax = scale(yMid + highBound), 
+                    coordsTop = {
+                        x1: xMin,
+                        y1: yMax,
+                        x2: xMax,
+                        y2: yMax
+                    }, coordsMid = {
+                        x1: xMid,
+                        y1: yMin,
+                        x2: xMid,
+                        y2: yMax
+                    }, coordsBot = {
+                        x1: xMin,
+                        y1: yMin,
+                        x2: xMax,
+                        y2: yMin
+                    }), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__container_Layer__.a, _extends({
+                        className: "recharts-errorBar",
+                        key: i
+                    }, props), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsTop), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsMid), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsBot));
+                });
+            }
+        }, {
+            key: "render",
+            value: function() {
+                return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__container_Layer__.a, {
+                    className: "recharts-errorBars"
+                }, this.renderErrorBars());
+            }
+        } ]), ErrorBar;
+    }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class.propTypes = {
+        dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]).isRequired,
+        data: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array,
+        xAxis: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
+        yAxis: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object,
+        layout: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        dataPointFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func,
+        stroke: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string,
+        strokeWidth: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number,
+        offset: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number
+    }, _class.defaultProps = {
+        stroke: "black",
+        strokeWidth: 1.5,
+        width: 5,
+        offset: 0,
+        layout: "horizontal"
+    }, _temp);
+    __webpack_exports__.a = ErrorBar;
+}, function(module, __webpack_exports__, __webpack_require__) {
+    "use strict";
+    function _defineProperty(obj, key, value) {
+        return key in obj ? Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : obj[key] = value, obj;
+    }
+    __webpack_require__.d(__webpack_exports__, "a", function() {
+        return formatAxisMap;
+    });
+    var __WEBPACK_IMPORTED_MODULE_0__ChartUtils__ = __webpack_require__(16), _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+            var source = arguments[i];
+            for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
+        }
+        return target;
+    }, formatAxisMap = function(props, axisMap, offset, axisType, chartName) {
+        var width = props.width, height = props.height, layout = props.layout, ids = Object.keys(axisMap), steps = {
+            left: offset.left,
+            leftMirror: offset.left,
+            right: width - offset.right,
+            rightMirror: width - offset.right,
+            top: offset.top,
+            topMirror: offset.top,
+            bottom: height - offset.bottom,
+            bottomMirror: height - offset.bottom
+        };
+        return ids.reduce(function(result, id) {
+            var axis = axisMap[id], orientation = axis.orientation, domain = axis.domain, _axis$padding = axis.padding, padding = void 0 === _axis$padding ? {} : _axis$padding, mirror = axis.mirror, reversed = axis.reversed, offsetKey = orientation + (mirror ? "Mirror" : ""), range = void 0, x = void 0, y = void 0, needSpace = void 0;
+            range = "xAxis" === axisType ? [ offset.left + (padding.left || 0), offset.left + offset.width - (padding.right || 0) ] : "yAxis" === axisType ? "horizontal" === layout ? [ offset.top + offset.height - (padding.bottom || 0), offset.top + (padding.top || 0) ] : [ offset.top + (padding.top || 0), offset.top + offset.height - (padding.bottom || 0) ] : axis.range, 
+            reversed && (range = [ range[1], range[0] ]);
+            var _parseScale = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.A)(axis, chartName), scale = _parseScale.scale, realScaleType = _parseScale.realScaleType;
+            scale.domain(domain).range(range), Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.c)(scale);
+            var ticks = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.v)(scale, _extends({}, axis, {
+                realScaleType: realScaleType
+            }));
+            "xAxis" === axisType ? (needSpace = "top" === orientation && !mirror || "bottom" === orientation && mirror, 
+            x = offset.left, y = steps[offsetKey] - needSpace * axis.height) : "yAxis" === axisType && (needSpace = "left" === orientation && !mirror || "right" === orientation && mirror, 
+            x = steps[offsetKey] - needSpace * axis.width, y = offset.top);
+            var finalAxis = _extends({}, axis, ticks, {
+                realScaleType: realScaleType,
+                x: x,
+                y: y,
+                scale: scale,
+                width: "xAxis" === axisType ? offset.width : axis.width,
+                height: "yAxis" === axisType ? offset.height : axis.height
+            });
+            return finalAxis.bandSize = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.g)(finalAxis, ticks), 
+            axis.hide || "xAxis" !== axisType ? axis.hide || (steps[offsetKey] += (needSpace ? -1 : 1) * finalAxis.width) : steps[offsetKey] += (needSpace ? -1 : 1) * finalAxis.height, 
+            _extends({}, result, _defineProperty({}, id, finalAxis));
+        }, {});
+    };
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        var emptyObject = {};
+        "production" !== process.env.NODE_ENV && Object.freeze(emptyObject), module.exports = emptyObject;
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        var emptyFunction = __webpack_require__(39), warning = emptyFunction;
+        if ("production" !== process.env.NODE_ENV) {
+            var printWarning = function(format) {
+                for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
+                var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
+                    return args[argIndex++];
+                });
+                "undefined" != typeof console && console.error(message);
+                try {
+                    throw new Error(message);
+                } catch (x) {}
+            };
+            warning = function(condition, format) {
+                if (void 0 === format) throw new Error("` + "`")) + (`warning(condition, format, ...args)` + ("`" + ` requires a warning message argument");
+                if (0 !== format.indexOf("Failed Composite propType: ") && !condition) {
+                    for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2];
+                    printWarning.apply(void 0, [ format ].concat(args));
+                }
+            };
+        }
+        module.exports = warning;
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    (function(process) {
+        function checkDCE() {
+            if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE) {
+                if ("production" !== process.env.NODE_ENV) throw new Error("^_^");
+                try {
+                    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
+                } catch (err) {
+                    console.error(err);
+                }
+            }
+        }
+        "production" === process.env.NODE_ENV ? (checkDCE(), module.exports = __webpack_require__(339)) : module.exports = __webpack_require__(342);
+    }).call(exports, __webpack_require__(2));
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function is(x, y) {
+        return x === y ? 0 !== x || 0 !== y || 1 / x == 1 / y : x !== x && y !== y;
+    }
+    function shallowEqual(objA, objB) {
+        if (is(objA, objB)) return !0;
+        if ("object" != typeof objA || null === objA || "object" != typeof objB || null === objB) return !1;
+        var keysA = Object.keys(objA), keysB = Object.keys(objB);
+        if (keysA.length !== keysB.length) return !1;
+        for (var i = 0; i < keysA.length; i++) if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) return !1;
+        return !0;
+    }
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    module.exports = shallowEqual;
+}, function(module, exports, __webpack_require__) {
+    var toInteger = __webpack_require__(137), min = Math.min;
+    module.exports = function(it) {
+        return it > 0 ? min(toInteger(it), 9007199254740991) : 0;
+    };
+}, function(module, exports) {
+    var id = 0, px = Math.random();
+    module.exports = function(key) {
+        return "Symbol(".concat(void 0 === key ? "" : key, ")_", (++id + px).toString(36));
+    };
+}, function(module, exports) {
+    exports.f = {}.propertyIsEnumerable;
+}, function(module, exports, __webpack_require__) {
+    "use strict";
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    exports.__esModule = !0;
+    var _iterator = __webpack_require__(357), _iterator2 = _interopRequireDefault(_iterator), _symbol = __webpack_require__(365), _symbol2 = _interopRequireDefault(_symbol), _typeof = "function" == typeof _symbol2.default && "symbol" == typeof _iterator2.default ? function(obj) {
+        return typeof obj;
+    } : function(obj) {
+        return obj && "function" == typeof _symbol2.default && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj;
+    };
+    exports.default = "function" == typeof _symbol2.default && "symbol" === _typeof(_iterator2.default) ? function(obj) {
+        return void 0 === obj ? "undefined" : _typeof(obj);
+    } : function(obj) {
+        return obj && "function" == typeof _symbol2.default && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : void 0 === obj ? "undefined" : _typeof(obj);
+    };
+}, function(module, exports, __webpack_require__) {
+    var anObject = __webpack_require__(47), dPs = __webpack_require__(361), enumBugKeys = __webpack_require__(140), IE_PROTO = __webpack_require__(138)("IE_PROTO"), Empty = function() {}, createDict = function() {
+        var iframeDocument, iframe = __webpack_require__(207)("iframe"), i = enumBugKeys.length;
+        for (iframe.style.display = "none", __webpack_require__(362).appendChild(iframe), 
+        iframe.src = "javascript:", iframeDocument = iframe.contentWindow.document, iframeDocument.open(), 
+        iframeDocument.write("`, "/"+uriCopy.String())
+			},
+		}}
+}
+
+//ValidateCaseErrors is a method that process the request object through certain validators
+//that assert if certain conditions are met for further information to log as an error
+func ValidateCaseErrors(r *Request) string {
+	for _, err := range caseErrors {
+		if err.Validator(r) {
+			return err.Msg(r)
+		}
+	}
+
+	return ""
 }
 
 //ShowMultipeChoices is used when a user requests a resource in a manifest which results
@@ -75,10 +113,10 @@ func initErrHandling() {
 //For example, if the user requests bzz://read and that manifest contains entries
 //"readme.md" and "readinglist.txt", a HTML page is returned with this two links.
 //This only applies if the manifest has no default entry
-func ShowMultipleChoices(w http.ResponseWriter, r *http.Request, list api.ManifestList) {
+func ShowMultipleChoices(w http.ResponseWriter, r *Request, list api.ManifestList) {
 	msg := ""
 	if list.Entries == nil {
-		ShowError(w, r, "Internal Server Error", http.StatusInternalServerError)
+		ShowError(w, r, "Could not resolve", http.StatusInternalServerError)
 		return
 	}
 	//make links relative
@@ -95,7 +133,7 @@ func ShowMultipleChoices(w http.ResponseWriter, r *http.Request, list api.Manife
 		//create clickable link for each entry
 		msg += "" + e.Path + "
"
 	}
-	respond(w, r, &ErrorParams{
+	respond(w, &r.Request, &ErrorParams{
 		Code:      http.StatusMultipleChoices,
 		Details:   template.HTML(msg),
 		Timestamp: time.Now().Format(time.RFC1123),
@@ -108,13 +146,15 @@ func ShowMultipleChoices(w http.ResponseWriter, r *http.Request, list api.Manife
 //The function just takes a string message which will be displayed in the error page.
 //The code is used to evaluate which template will be displayed
 //(and return the correct HTTP status code)
-func ShowError(w http.ResponseWriter, r *http.Request, msg string, code int) {
+func ShowError(w http.ResponseWriter, r *Request, msg string, code int) {
+	additionalMessage := ValidateCaseErrors(r)
 	if code == http.StatusInternalServerError {
 		log.Error(msg)
 	}
-	respond(w, r, &ErrorParams{
+	respond(w, &r.Request, &ErrorParams{
 		Code:      code,
 		Msg:       msg,
+		Details:   template.HTML(additionalMessage),
 		Timestamp: time.Now().Format(time.RFC1123),
 		template:  getTemplate(code),
 	})
@@ -132,6 +172,7 @@ func respond(w http.ResponseWriter, r *http.Request, params *ErrorParams) {
 
 //return a HTML page
 func respondHtml(w http.ResponseWriter, params *ErrorParams) {
+	htmlCounter.Inc(1)
 	err := params.template.Execute(w, params)
 	if err != nil {
 		log.Error(err.Error())
@@ -140,6 +181,7 @@ func respondHtml(w http.ResponseWriter, params *ErrorParams) {
 
 //return JSON
 func respondJson(w http.ResponseWriter, params *ErrorParams) {
+	jsonCounter.Inc(1)
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(params)
 }
diff --git a/swarm/api/http/error_templates.go b/swarm/api/http/error_templates.go
index 2c20ba8f99..cc9b996ba4 100644
--- a/swarm/api/http/error_templates.go
+++ b/swarm/api/http/error_templates.go
@@ -37,7 +37,7 @@ func GetGenericErrorPage() string {
     
     
     
-
+		
     
+    Swarm :: Welcome to Swarm
+  
+  
+
+
+      

+        

+          
+        

+        

+          
Welcome to Swarm

+        

+      

+
+			
+				
+
+	            
Enter the hash or ENS of a Swarm-hosted file below:

+								
+								
+
+				
+      

+        

+          Swarm: Serverless Hosting Incentivised Peer-To-Peer Storage And Content Distribution

+          Swarm
+        

+      

+
+  
+
+`[1:]))
diff --git a/swarm/api/uri.go b/swarm/api/uri.go
index af1dc74453..d8aafedf41 100644
--- a/swarm/api/uri.go
+++ b/swarm/api/uri.go
@@ -36,6 +36,8 @@ type URI struct {
 	// * bzzr - raw swarm content
 	// * bzzi - immutable URI of an entry in a swarm manifest
 	//          (address is not resolved)
+	// * bzz-hash - hash of swarm content
+	//
 	Scheme string
 
 	// Addr is either a hexadecimal storage key or it an address which
@@ -56,7 +58,7 @@ type URI struct {
 // * ://
 // * :///
 //
-// with scheme one of bzz, bzz-raw, bzz-immutable or bzz-list
+// with scheme one of bzz, bzz-raw, bzz-immutable, bzz-list or bzz-hash
 // or deprecated ones bzzr and bzzi
 func Parse(rawuri string) (*URI, error) {
 	u, err := url.Parse(rawuri)
@@ -67,7 +69,7 @@ func Parse(rawuri string) (*URI, error) {
 
 	// check the scheme is valid
 	switch uri.Scheme {
-	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzzr", "bzzi":
+	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi":
 	default:
 		return nil, fmt.Errorf("unknown scheme %q", u.Scheme)
 	}
@@ -110,6 +112,10 @@ func (u *URI) DeprecatedImmutable() bool {
 	return u.Scheme == "bzzi"
 }
 
+func (u *URI) Hash() bool {
+	return u.Scheme == "bzz-hash"
+}
+
 func (u *URI) String() string {
 	return u.Scheme + ":/" + u.Addr + "/" + u.Path
 }
diff --git a/swarm/api/uri_test.go b/swarm/api/uri_test.go
index babb2834e9..137b4505d4 100644
--- a/swarm/api/uri_test.go
+++ b/swarm/api/uri_test.go
@@ -29,6 +29,7 @@ func TestParseURI(t *testing.T) {
 		expectRaw                 bool
 		expectImmutable           bool
 		expectList                bool
+		expectHash                bool
 		expectDeprecatedRaw       bool
 		expectDeprecatedImmutable bool
 	}
@@ -98,6 +99,16 @@ func TestParseURI(t *testing.T) {
 			uri:       "bzz://abc123/path/to/entry",
 			expectURI: &URI{Scheme: "bzz", Addr: "abc123", Path: "path/to/entry"},
 		},
+		{
+			uri:        "bzz-hash:",
+			expectURI:  &URI{Scheme: "bzz-hash"},
+			expectHash: true,
+		},
+		{
+			uri:        "bzz-hash:/",
+			expectURI:  &URI{Scheme: "bzz-hash"},
+			expectHash: true,
+		},
 		{
 			uri:        "bzz-list:",
 			expectURI:  &URI{Scheme: "bzz-list"},
@@ -152,6 +163,9 @@ func TestParseURI(t *testing.T) {
 		if actual.List() != x.expectList {
 			t.Fatalf("expected %s list to be %t, got %t", x.uri, x.expectList, actual.List())
 		}
+		if actual.Hash() != x.expectHash {
+			t.Fatalf("expected %s hash to be %t, got %t", x.uri, x.expectHash, actual.Hash())
+		}
 		if actual.DeprecatedRaw() != x.expectDeprecatedRaw {
 			t.Fatalf("expected %s deprecated raw to be %t, got %t", x.uri, x.expectDeprecatedRaw, actual.DeprecatedRaw())
 		}
diff --git a/swarm/fuse/fuse_dir.go b/swarm/fuse/fuse_dir.go
index 91b236ae8a..a7701985eb 100644
--- a/swarm/fuse/fuse_dir.go
+++ b/swarm/fuse/fuse_dir.go
@@ -19,12 +19,13 @@
 package fuse
 
 import (
-	"bazil.org/fuse"
-	"bazil.org/fuse/fs"
-	"golang.org/x/net/context"
 	"os"
 	"path/filepath"
 	"sync"
+
+	"bazil.org/fuse"
+	"bazil.org/fuse/fs"
+	"golang.org/x/net/context"
 )
 
 var (
diff --git a/swarm/fuse/swarmfs.go b/swarm/fuse/swarmfs.go
index 2493bdab19..e56d0ad4e3 100644
--- a/swarm/fuse/swarmfs.go
+++ b/swarm/fuse/swarmfs.go
@@ -17,9 +17,10 @@
 package fuse
 
 import (
-	"github.com/ethereum/go-ethereum/swarm/api"
 	"sync"
 	"time"
+
+	"github.com/ethereum/go-ethereum/swarm/api"
 )
 
 const (
diff --git a/swarm/fuse/swarmfs_util.go b/swarm/fuse/swarmfs_util.go
index d39966c0e3..169b674876 100644
--- a/swarm/fuse/swarmfs_util.go
+++ b/swarm/fuse/swarmfs_util.go
@@ -47,7 +47,6 @@ func externalUnmount(mountPoint string) error {
 }
 
 func addFileToSwarm(sf *SwarmFile, content []byte, size int) error {
-
 	fkey, mhash, err := sf.mountInfo.swarmApi.AddFile(sf.mountInfo.LatestManifest, sf.path, sf.name, content, true)
 	if err != nil {
 		return err
@@ -64,11 +63,9 @@ func addFileToSwarm(sf *SwarmFile, content []byte, size int) error {
 
 	log.Info("Added new file:", "fname", sf.name, "New Manifest hash", mhash)
 	return nil
-
 }
 
 func removeFileFromSwarm(sf *SwarmFile) error {
-
 	mkey, err := sf.mountInfo.swarmApi.RemoveFile(sf.mountInfo.LatestManifest, sf.path, sf.name, true)
 	if err != nil {
 		return err
@@ -83,7 +80,6 @@ func removeFileFromSwarm(sf *SwarmFile) error {
 }
 
 func removeDirectoryFromSwarm(sd *SwarmDir) error {
-
 	if len(sd.directories) == 0 && len(sd.files) == 0 {
 		return nil
 	}
@@ -103,11 +99,9 @@ func removeDirectoryFromSwarm(sd *SwarmDir) error {
 	}
 
 	return nil
-
 }
 
 func appendToExistingFileInSwarm(sf *SwarmFile, content []byte, offset int64, length int64) error {
-
 	fkey, mhash, err := sf.mountInfo.swarmApi.AppendFile(sf.mountInfo.LatestManifest, sf.path, sf.name, sf.fileSize, content, sf.key, offset, length, true)
 	if err != nil {
 		return err
@@ -124,5 +118,4 @@ func appendToExistingFileInSwarm(sf *SwarmFile, content []byte, offset int64, le
 
 	log.Info("Appended file:", "fname", sf.name, "New Manifest hash", mhash)
 	return nil
-
 }
diff --git a/swarm/metrics/flags.go b/swarm/metrics/flags.go
new file mode 100644
index 0000000000..48b231b219
--- /dev/null
+++ b/swarm/metrics/flags.go
@@ -0,0 +1,91 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package metrics
+
+import (
+	"time"
+
+	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/log"
+	gethmetrics "github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethereum/go-ethereum/metrics/influxdb"
+	"gopkg.in/urfave/cli.v1"
+)
+
+var (
+	metricsEnableInfluxDBExportFlag = cli.BoolFlag{
+		Name:  "metrics.influxdb.export",
+		Usage: "Enable metrics export/push to an external InfluxDB database",
+	}
+	metricsInfluxDBEndpointFlag = cli.StringFlag{
+		Name:  "metrics.influxdb.endpoint",
+		Usage: "Metrics InfluxDB endpoint",
+		Value: "http://127.0.0.1:8086",
+	}
+	metricsInfluxDBDatabaseFlag = cli.StringFlag{
+		Name:  "metrics.influxdb.database",
+		Usage: "Metrics InfluxDB database",
+		Value: "metrics",
+	}
+	metricsInfluxDBUsernameFlag = cli.StringFlag{
+		Name:  "metrics.influxdb.username",
+		Usage: "Metrics InfluxDB username",
+		Value: "",
+	}
+	metricsInfluxDBPasswordFlag = cli.StringFlag{
+		Name:  "metrics.influxdb.password",
+		Usage: "Metrics InfluxDB password",
+		Value: "",
+	}
+	// The `host` tag is part of every measurement sent to InfluxDB. Queries on tags are faster in InfluxDB.
+	// It is used so that we can group all nodes and average a measurement across all of them, but also so
+	// that we can select a specific node and inspect its measurements.
+	// https://docs.influxdata.com/influxdb/v1.4/concepts/key_concepts/#tag-key
+	metricsInfluxDBHostTagFlag = cli.StringFlag{
+		Name:  "metrics.influxdb.host.tag",
+		Usage: "Metrics InfluxDB `host` tag attached to all measurements",
+		Value: "localhost",
+	}
+)
+
+// Flags holds all command-line flags required for metrics collection.
+var Flags = []cli.Flag{
+	utils.MetricsEnabledFlag,
+	metricsEnableInfluxDBExportFlag,
+	metricsInfluxDBEndpointFlag, metricsInfluxDBDatabaseFlag, metricsInfluxDBUsernameFlag, metricsInfluxDBPasswordFlag, metricsInfluxDBHostTagFlag,
+}
+
+func Setup(ctx *cli.Context) {
+	if gethmetrics.Enabled {
+		log.Info("Enabling swarm metrics collection")
+		var (
+			enableExport = ctx.GlobalBool(metricsEnableInfluxDBExportFlag.Name)
+			endpoint     = ctx.GlobalString(metricsInfluxDBEndpointFlag.Name)
+			database     = ctx.GlobalString(metricsInfluxDBDatabaseFlag.Name)
+			username     = ctx.GlobalString(metricsInfluxDBUsernameFlag.Name)
+			password     = ctx.GlobalString(metricsInfluxDBPasswordFlag.Name)
+			hosttag      = ctx.GlobalString(metricsInfluxDBHostTagFlag.Name)
+		)
+
+		if enableExport {
+			log.Info("Enabling swarm metrics export to InfluxDB")
+			go influxdb.InfluxDBWithTags(gethmetrics.DefaultRegistry, 10*time.Second, endpoint, database, username, password, "swarm.", map[string]string{
+				"host": hosttag,
+			})
+		}
+	}
+}
diff --git a/swarm/network/depo.go b/swarm/network/depo.go
index 17540d2f9f..5ffbf8be11 100644
--- a/swarm/network/depo.go
+++ b/swarm/network/depo.go
@@ -23,9 +23,19 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/swarm/storage"
 )
 
+//metrics variables
+var (
+	syncReceiveCount  = metrics.NewRegisteredCounter("network.sync.recv.count", nil)
+	syncReceiveIgnore = metrics.NewRegisteredCounter("network.sync.recv.ignore", nil)
+	syncSendCount     = metrics.NewRegisteredCounter("network.sync.send.count", nil)
+	syncSendRefused   = metrics.NewRegisteredCounter("network.sync.send.refused", nil)
+	syncSendNotFound  = metrics.NewRegisteredCounter("network.sync.send.notfound", nil)
+)
+
 // Handler for storage/retrieval related protocol requests
 // implements the StorageHandler interface used by the bzz protocol
 type Depo struct {
@@ -107,6 +117,7 @@ func (self *Depo) HandleStoreRequestMsg(req *storeRequestMsgData, p *peer) {
 		log.Trace(fmt.Sprintf("Depo.handleStoreRequest: %v not found locally. create new chunk/request", req.Key))
 		// not found in memory cache, ie., a genuine store request
 		// create chunk
+		syncReceiveCount.Inc(1)
 		chunk = storage.NewChunk(req.Key, nil)
 
 	case chunk.SData == nil:
@@ -116,6 +127,7 @@ func (self *Depo) HandleStoreRequestMsg(req *storeRequestMsgData, p *peer) {
 	default:
 		// data is found, store request ignored
 		// this should update access count?
+		syncReceiveIgnore.Inc(1)
 		log.Trace(fmt.Sprintf("Depo.HandleStoreRequest: %v found locally. ignore.", req))
 		islocal = true
 		//return
@@ -172,11 +184,14 @@ func (self *Depo) HandleRetrieveRequestMsg(req *retrieveRequestMsgData, p *peer)
 				SData:          chunk.SData,
 				requestTimeout: req.timeout, //
 			}
+			syncSendCount.Inc(1)
 			p.syncer.addRequest(sreq, DeliverReq)
 		} else {
+			syncSendRefused.Inc(1)
 			log.Trace(fmt.Sprintf("Depo.HandleRetrieveRequest: %v - content found, not wanted", req.Key.Log()))
 		}
 	} else {
+		syncSendNotFound.Inc(1)
 		log.Trace(fmt.Sprintf("Depo.HandleRetrieveRequest: %v - content not found locally. asked swarm for help. will get back", req.Key.Log()))
 	}
 }
diff --git a/swarm/network/hive.go b/swarm/network/hive.go
index 2504a46100..8404ffcc2a 100644
--- a/swarm/network/hive.go
+++ b/swarm/network/hive.go
@@ -24,6 +24,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/netutil"
 	"github.com/ethereum/go-ethereum/swarm/network/kademlia"
@@ -39,6 +40,12 @@ import (
 // connections and disconnections are reported and relayed
 // to keep the nodetable uptodate
 
+var (
+	peersNumGauge     = metrics.NewRegisteredGauge("network.peers.num", nil)
+	addPeerCounter    = metrics.NewRegisteredCounter("network.addpeer.count", nil)
+	removePeerCounter = metrics.NewRegisteredCounter("network.removepeer.count", nil)
+)
+
 type Hive struct {
 	listenAddr   func() string
 	callInterval uint64
@@ -192,6 +199,7 @@ func (self *Hive) Start(id discover.NodeID, listenAddr func() string, connectPee
 func (self *Hive) keepAlive() {
 	alarm := time.NewTicker(time.Duration(self.callInterval)).C
 	for {
+		peersNumGauge.Update(int64(self.kad.Count()))
 		select {
 		case <-alarm:
 			if self.kad.DBCount() > 0 {
@@ -223,6 +231,7 @@ func (self *Hive) Stop() error {
 
 // called at the end of a successful protocol handshake
 func (self *Hive) addPeer(p *peer) error {
+	addPeerCounter.Inc(1)
 	defer func() {
 		select {
 		case self.more <- true:
@@ -247,6 +256,7 @@ func (self *Hive) addPeer(p *peer) error {
 
 // called after peer disconnected
 func (self *Hive) removePeer(p *peer) {
+	removePeerCounter.Inc(1)
 	log.Debug(fmt.Sprintf("bee %v removed", p))
 	self.kad.Off(p, saveSync)
 	select {
diff --git a/swarm/network/kademlia/address.go b/swarm/network/kademlia/address.go
index 4c38a846f9..ef82d2e8b8 100644
--- a/swarm/network/kademlia/address.go
+++ b/swarm/network/kademlia/address.go
@@ -51,7 +51,7 @@ func (a Address) Bin() string {
 /*
 Proximity(x, y) returns the proximity order of the MSB distance between x and y
 
-The distance metric MSB(x, y) of two equal length byte sequences x an y is the
+The distance metric MSB(x, y) of two equal length byte sequences x and y is the
 value of the binary integer cast of the x^y, ie., x and y bitwise xor-ed.
 the binary cast is big endian: most significant bit first (=MSB).
 
diff --git a/swarm/network/kademlia/kademlia.go b/swarm/network/kademlia/kademlia.go
index 0abc42a19c..b5999b52d4 100644
--- a/swarm/network/kademlia/kademlia.go
+++ b/swarm/network/kademlia/kademlia.go
@@ -24,6 +24,16 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+//metrics variables
+//For metrics, we want to count how many times peers are added/removed
+//at a certain index. Thus we do that with an array of counters with
+//entry for each index
+var (
+	bucketAddIndexCount []metrics.Counter
+	bucketRmIndexCount  []metrics.Counter
 )
 
 const (
@@ -88,12 +98,14 @@ type Node interface {
 // params is KadParams configuration
 func New(addr Address, params *KadParams) *Kademlia {
 	buckets := make([][]Node, params.MaxProx+1)
-	return &Kademlia{
+	kad := &Kademlia{
 		addr:      addr,
 		KadParams: params,
 		buckets:   buckets,
 		db:        newKadDb(addr, params),
 	}
+	kad.initMetricsVariables()
+	return kad
 }
 
 // accessor for KAD base address
@@ -138,6 +150,7 @@ func (self *Kademlia) On(node Node, cb func(*NodeRecord, Node) error) (err error
 	// TODO: give priority to peers with active traffic
 	if len(bucket) < self.BucketSize { // >= allows us to add peers beyond the bucketsize limitation
 		self.buckets[index] = append(bucket, node)
+		bucketAddIndexCount[index].Inc(1)
 		log.Debug(fmt.Sprintf("add node %v to table", node))
 		self.setProxLimit(index, true)
 		record.node = node
@@ -178,6 +191,7 @@ func (self *Kademlia) Off(node Node, cb func(*NodeRecord, Node)) (err error) {
 	defer self.lock.Unlock()
 
 	index := self.proximityBin(node.Addr())
+	bucketRmIndexCount[index].Inc(1)
 	bucket := self.buckets[index]
 	for i := 0; i < len(bucket); i++ {
 		if node.Addr() == bucket[i].Addr() {
@@ -426,3 +440,15 @@ func (self *Kademlia) String() string {
 	rows = append(rows, "=========================================================================")
 	return strings.Join(rows, "\n")
 }
+
+//We have to build up the array of counters for each index
+func (self *Kademlia) initMetricsVariables() {
+	//create the arrays
+	bucketAddIndexCount = make([]metrics.Counter, self.MaxProx+1)
+	bucketRmIndexCount = make([]metrics.Counter, self.MaxProx+1)
+	//at each index create a metrics counter
+	for i := 0; i < (self.KadParams.MaxProx + 1); i++ {
+		bucketAddIndexCount[i] = metrics.NewRegisteredCounter(fmt.Sprintf("network.kademlia.bucket.add.%d.index", i), nil)
+		bucketRmIndexCount[i] = metrics.NewRegisteredCounter(fmt.Sprintf("network.kademlia.bucket.rm.%d.index", i), nil)
+	}
+}
diff --git a/swarm/network/protocol.go b/swarm/network/protocol.go
index a418c1dbbd..1cbe00a973 100644
--- a/swarm/network/protocol.go
+++ b/swarm/network/protocol.go
@@ -39,12 +39,26 @@ import (
 
 	"github.com/ethereum/go-ethereum/contracts/chequebook"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/p2p"
 	bzzswap "github.com/ethereum/go-ethereum/swarm/services/swap"
 	"github.com/ethereum/go-ethereum/swarm/services/swap/swap"
 	"github.com/ethereum/go-ethereum/swarm/storage"
 )
 
+//metrics variables
+var (
+	storeRequestMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.storerequest.count", nil)
+	retrieveRequestMsgCounter = metrics.NewRegisteredCounter("network.protocol.msg.retrieverequest.count", nil)
+	peersMsgCounter           = metrics.NewRegisteredCounter("network.protocol.msg.peers.count", nil)
+	syncRequestMsgCounter     = metrics.NewRegisteredCounter("network.protocol.msg.syncrequest.count", nil)
+	unsyncedKeysMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.unsyncedkeys.count", nil)
+	deliverRequestMsgCounter  = metrics.NewRegisteredCounter("network.protocol.msg.deliverrequest.count", nil)
+	paymentMsgCounter         = metrics.NewRegisteredCounter("network.protocol.msg.payment.count", nil)
+	invalidMsgCounter         = metrics.NewRegisteredCounter("network.protocol.msg.invalid.count", nil)
+	handleStatusMsgCounter    = metrics.NewRegisteredCounter("network.protocol.msg.handlestatus.count", nil)
+)
+
 const (
 	Version            = 0
 	ProtocolLength     = uint64(8)
@@ -206,6 +220,7 @@ func (self *bzz) handle() error {
 
 	case storeRequestMsg:
 		// store requests are dispatched to netStore
+		storeRequestMsgCounter.Inc(1)
 		var req storeRequestMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<- %v: %v", msg, err)
@@ -221,6 +236,7 @@ func (self *bzz) handle() error {
 
 	case retrieveRequestMsg:
 		// retrieve Requests are dispatched to netStore
+		retrieveRequestMsgCounter.Inc(1)
 		var req retrieveRequestMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<- %v: %v", msg, err)
@@ -241,6 +257,7 @@ func (self *bzz) handle() error {
 	case peersMsg:
 		// response to lookups and immediate response to retrieve requests
 		// dispatches new peer data to the hive that adds them to KADDB
+		peersMsgCounter.Inc(1)
 		var req peersMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<- %v: %v", msg, err)
@@ -250,6 +267,7 @@ func (self *bzz) handle() error {
 		self.hive.HandlePeersMsg(&req, &peer{bzz: self})
 
 	case syncRequestMsg:
+		syncRequestMsgCounter.Inc(1)
 		var req syncRequestMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<- %v: %v", msg, err)
@@ -260,6 +278,7 @@ func (self *bzz) handle() error {
 
 	case unsyncedKeysMsg:
 		// coming from parent node offering
+		unsyncedKeysMsgCounter.Inc(1)
 		var req unsyncedKeysMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<- %v: %v", msg, err)
@@ -274,6 +293,7 @@ func (self *bzz) handle() error {
 	case deliveryRequestMsg:
 		// response to syncKeysMsg hashes filtered not existing in db
 		// also relays the last synced state to the source
+		deliverRequestMsgCounter.Inc(1)
 		var req deliveryRequestMsgData
 		if err := msg.Decode(&req); err != nil {
 			return fmt.Errorf("<-msg %v: %v", msg, err)
@@ -287,6 +307,7 @@ func (self *bzz) handle() error {
 
 	case paymentMsg:
 		// swap protocol message for payment, Units paid for, Cheque paid with
+		paymentMsgCounter.Inc(1)
 		if self.swapEnabled {
 			var req paymentMsgData
 			if err := msg.Decode(&req); err != nil {
@@ -298,6 +319,7 @@ func (self *bzz) handle() error {
 
 	default:
 		// no other message is allowed
+		invalidMsgCounter.Inc(1)
 		return fmt.Errorf("invalid message code: %v", msg.Code)
 	}
 	return nil
@@ -332,6 +354,8 @@ func (self *bzz) handleStatus() (err error) {
 		return fmt.Errorf("first msg has code %x (!= %x)", msg.Code, statusMsg)
 	}
 
+	handleStatusMsgCounter.Inc(1)
+
 	if msg.Size > ProtocolMaxMsgSize {
 		return fmt.Errorf("message too long: %v > %v", msg.Size, ProtocolMaxMsgSize)
 	}
diff --git a/swarm/services/swap/swap.go b/swarm/services/swap/swap.go
index 1f9b22b904..1eac111be5 100644
--- a/swarm/services/swap/swap.go
+++ b/swarm/services/swap/swap.go
@@ -19,6 +19,7 @@ package swap
 import (
 	"context"
 	"crypto/ecdsa"
+	"errors"
 	"fmt"
 	"math/big"
 	"os"
@@ -134,6 +135,11 @@ func NewSwap(local *SwapParams, remote *SwapProfile, backend chequebook.Backend,
 		out *chequebook.Outbox
 	)
 
+	remotekey, err := crypto.UnmarshalPubkey(common.FromHex(remote.PublicKey))
+	if err != nil {
+		return nil, errors.New("invalid remote public key")
+	}
+
 	// check if remote chequebook is valid
 	// insolvent chequebooks suicide so will signal as invalid
 	// TODO: monitoring a chequebooks events
@@ -142,7 +148,7 @@ func NewSwap(local *SwapParams, remote *SwapProfile, backend chequebook.Backend,
 		log.Info(fmt.Sprintf("invalid contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err))
 	} else {
 		// remote contract valid, create inbox
-		in, err = chequebook.NewInbox(local.privateKey, remote.Contract, local.Beneficiary, crypto.ToECDSAPub(common.FromHex(remote.PublicKey)), backend)
+		in, err = chequebook.NewInbox(local.privateKey, remote.Contract, local.Beneficiary, remotekey, backend)
 		if err != nil {
 			log.Warn(fmt.Sprintf("unable to set up inbox for chequebook contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err))
 		}
diff --git a/swarm/storage/chunker.go b/swarm/storage/chunker.go
index 98cd6e75ea..2b397f8010 100644
--- a/swarm/storage/chunker.go
+++ b/swarm/storage/chunker.go
@@ -23,6 +23,8 @@ import (
 	"io"
 	"sync"
 	"time"
+
+	"github.com/ethereum/go-ethereum/metrics"
 )
 
 /*
@@ -63,6 +65,11 @@ var (
 	errOperationTimedOut    = errors.New("operation timed out")
 )
 
+//metrics variables
+var (
+	newChunkCounter = metrics.NewRegisteredCounter("storage.chunks.new", nil)
+)
+
 type TreeChunker struct {
 	branches int64
 	hashFunc SwarmHasher
@@ -298,6 +305,13 @@ func (self *TreeChunker) hashChunk(hasher SwarmHash, job *hashJob, chunkC chan *
 	job.parentWg.Done()
 
 	if chunkC != nil {
+		//NOTE: this increases the chunk count even if the local node already has this chunk;
+		//on file upload the node will increase this counter even if the same file has already been uploaded
+		//So it should be evaluated whether it is worth keeping this counter
+		//and/or actually better track when the chunk is Put to the local database
+		//(which may question the need for disambiguation when a completely new chunk has been created
+		//and/or a chunk is being put to the local DB; for chunk tracking it may be worth distinguishing
+		newChunkCounter.Inc(1)
 		chunkC <- newChunk
 	}
 }
diff --git a/swarm/storage/chunker_test.go b/swarm/storage/chunker_test.go
index 6178a7bb1c..c8bd12299a 100644
--- a/swarm/storage/chunker_test.go
+++ b/swarm/storage/chunker_test.go
@@ -60,7 +60,7 @@ func (self *chunkerTester) Split(chunker Splitter, data io.Reader, size int64, c
 			for {
 				select {
 				case <-timeout:
-					return errors.New(("Split timeout error"))
+					return errors.New("Split timeout error")
 				case <-quitC:
 					return nil
 				case chunk := <-chunkC:
@@ -97,7 +97,7 @@ func (self *chunkerTester) Append(chunker Splitter, rootKey Key, data io.Reader,
 			for {
 				select {
 				case <-timeout:
-					return errors.New(("Append timeout error"))
+					return errors.New("Append timeout error")
 				case <-quitC:
 					return nil
 				case chunk := <-chunkC:
@@ -146,7 +146,7 @@ func (self *chunkerTester) Join(chunker Chunker, key Key, c int, chunkC chan *Ch
 		for {
 			select {
 			case <-timeout:
-				return errors.New(("Join timeout error"))
+				return errors.New("Join timeout error")
 			case chunk, ok := <-chunkC:
 				if !ok {
 					close(quitC)
@@ -155,7 +155,7 @@ func (self *chunkerTester) Join(chunker Chunker, key Key, c int, chunkC chan *Ch
 				// this just mocks the behaviour of a chunk store retrieval
 				stored, success := self.chunks[chunk.Key.String()]
 				if !success {
-					return errors.New(("Not found"))
+					return errors.New("Not found")
 				}
 				chunk.SData = stored.SData
 				chunk.Size = int64(binary.LittleEndian.Uint64(chunk.SData[0:8]))
@@ -363,7 +363,7 @@ func TestRandomData(t *testing.T) {
 
 }
 
-func TestRandomBrokenData(t *testing.T) {
+func XTestRandomBrokenData(t *testing.T) {
 	sizes := []int{1, 60, 83, 179, 253, 1024, 4095, 4096, 4097, 8191, 8192, 8193, 12287, 12288, 12289, 123456, 2345678}
 	tester := &chunkerTester{t: t}
 	chunker := NewTreeChunker(NewChunkerParams())
diff --git a/swarm/storage/database.go b/swarm/storage/database.go
index 2532490cc9..f2ceb94e46 100644
--- a/swarm/storage/database.go
+++ b/swarm/storage/database.go
@@ -22,7 +22,6 @@ package storage
 import (
 	"fmt"
 
-	"github.com/ethereum/go-ethereum/compression/rle"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 	"github.com/syndtr/goleveldb/leveldb/opt"
@@ -31,8 +30,7 @@ import (
 const openFileLimit = 128
 
 type LDBDatabase struct {
-	db   *leveldb.DB
-	comp bool
+	db *leveldb.DB
 }
 
 func NewLDBDatabase(file string) (*LDBDatabase, error) {
@@ -42,16 +40,12 @@ func NewLDBDatabase(file string) (*LDBDatabase, error) {
 		return nil, err
 	}
 
-	database := &LDBDatabase{db: db, comp: false}
+	database := &LDBDatabase{db: db}
 
 	return database, nil
 }
 
 func (self *LDBDatabase) Put(key []byte, value []byte) {
-	if self.comp {
-		value = rle.Compress(value)
-	}
-
 	err := self.db.Put(key, value, nil)
 	if err != nil {
 		fmt.Println("Error put", err)
@@ -63,11 +57,6 @@ func (self *LDBDatabase) Get(key []byte) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	if self.comp {
-		return rle.Decompress(dat)
-	}
-
 	return dat, nil
 }
 
diff --git a/swarm/storage/dbstore.go b/swarm/storage/dbstore.go
index 46a5c16ccc..1ff42a0c05 100644
--- a/swarm/storage/dbstore.go
+++ b/swarm/storage/dbstore.go
@@ -33,11 +33,18 @@ import (
 	"sync"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 )
 
+//metrics variables
+var (
+	gcCounter            = metrics.NewRegisteredCounter("storage.db.dbstore.gc.count", nil)
+	dbStoreDeleteCounter = metrics.NewRegisteredCounter("storage.db.dbstore.rm.count", nil)
+)
+
 const (
 	defaultDbCapacity = 5000000
 	defaultRadius     = 0 // not yet used
@@ -47,7 +54,6 @@ const (
 
 	// key prefixes for leveldb storage
 	kpIndex = 0
-	kpData  = 1
 )
 
 var (
@@ -255,6 +261,7 @@ func (s *DbStore) collectGarbage(ratio float32) {
 	// actual gc
 	for i := 0; i < gcnt; i++ {
 		if s.gcArray[i].value <= cutval {
+			gcCounter.Inc(1)
 			s.delete(s.gcArray[i].idx, s.gcArray[i].idxKey)
 		}
 	}
@@ -383,6 +390,7 @@ func (s *DbStore) delete(idx uint64, idxKey []byte) {
 	batch := new(leveldb.Batch)
 	batch.Delete(idxKey)
 	batch.Delete(getDataKey(idx))
+	dbStoreDeleteCounter.Inc(1)
 	s.entryCnt--
 	batch.Put(keyEntryCnt, U64ToBytes(s.entryCnt))
 	s.db.Write(batch)
diff --git a/swarm/storage/localstore.go b/swarm/storage/localstore.go
index b442e6cc54..ece0c86155 100644
--- a/swarm/storage/localstore.go
+++ b/swarm/storage/localstore.go
@@ -18,6 +18,13 @@ package storage
 
 import (
 	"encoding/binary"
+
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+//metrics variables
+var (
+	dbStorePutCounter = metrics.NewRegisteredCounter("storage.db.dbstore.put.count", nil)
 )
 
 // LocalStore is a combination of inmemory db over a disk persisted db
@@ -39,6 +46,14 @@ func NewLocalStore(hash SwarmHasher, params *StoreParams) (*LocalStore, error) {
 	}, nil
 }
 
+func (self *LocalStore) CacheCounter() uint64 {
+	return uint64(self.memStore.(*MemStore).Counter())
+}
+
+func (self *LocalStore) DbCounter() uint64 {
+	return self.DbStore.(*DbStore).Counter()
+}
+
 // LocalStore is itself a chunk store
 // unsafe, in that the data is not integrity checked
 func (self *LocalStore) Put(chunk *Chunk) {
@@ -48,6 +63,7 @@ func (self *LocalStore) Put(chunk *Chunk) {
 		chunk.wg.Add(1)
 	}
 	go func() {
+		dbStorePutCounter.Inc(1)
 		self.DbStore.Put(chunk)
 		if chunk.wg != nil {
 			chunk.wg.Done()
diff --git a/swarm/storage/memstore.go b/swarm/storage/memstore.go
index 3cb25ac625..d6be542203 100644
--- a/swarm/storage/memstore.go
+++ b/swarm/storage/memstore.go
@@ -23,6 +23,13 @@ import (
 	"sync"
 
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+//metrics variables
+var (
+	memstorePutCounter    = metrics.NewRegisteredCounter("storage.db.memstore.put.count", nil)
+	memstoreRemoveCounter = metrics.NewRegisteredCounter("storage.db.memstore.rm.count", nil)
 )
 
 const (
@@ -130,6 +137,10 @@ func (s *MemStore) setCapacity(c uint) {
 	s.capacity = c
 }
 
+func (s *MemStore) Counter() uint {
+	return s.entryCnt
+}
+
 // entry (not its copy) is going to be in MemStore
 func (s *MemStore) Put(entry *Chunk) {
 	if s.capacity == 0 {
@@ -145,6 +156,8 @@ func (s *MemStore) Put(entry *Chunk) {
 
 	s.accessCnt++
 
+	memstorePutCounter.Inc(1)
+
 	node := s.memtree
 	bitpos := uint(0)
 	for node.entry == nil {
@@ -289,6 +302,7 @@ func (s *MemStore) removeOldest() {
 	}
 
 	if node.entry.SData != nil {
+		memstoreRemoveCounter.Inc(1)
 		node.entry = nil
 		s.entryCnt--
 	}
diff --git a/swarm/storage/netstore.go b/swarm/storage/netstore.go
index 5d4f17deb1..0552b84efa 100644
--- a/swarm/storage/netstore.go
+++ b/swarm/storage/netstore.go
@@ -83,11 +83,6 @@ func NewNetStore(hash SwarmHasher, lstore *LocalStore, cloud CloudStore, params
 	}
 }
 
-const (
-	// maximum number of peers that a retrieved message is delivered to
-	requesterCount = 3
-)
-
 var (
 	// timeout interval before retrieval is timed out
 	searchTimeout = 3 * time.Second
diff --git a/swarm/storage/pyramid.go b/swarm/storage/pyramid.go
index f2e85cb5b0..19d493405a 100644
--- a/swarm/storage/pyramid.go
+++ b/swarm/storage/pyramid.go
@@ -338,7 +338,7 @@ func (self *PyramidChunker) loadTree(chunkLevel [][]*TreeEntry, key Key, chunkC
 	chunkLevel[depth-1] = append(chunkLevel[depth-1], newEntry)
 
 	// Add the rest of the tree
-	for lvl := (depth - 1); lvl >= 1; lvl-- {
+	for lvl := depth - 1; lvl >= 1; lvl-- {
 
 		//TODO(jmozah): instead of loading finished branches and then trim in the end,
 		//avoid loading them in the first place
diff --git a/swarm/swarm.go b/swarm/swarm.go
index 3be3660b58..0a120db1fa 100644
--- a/swarm/swarm.go
+++ b/swarm/swarm.go
@@ -21,7 +21,11 @@ import (
 	"context"
 	"crypto/ecdsa"
 	"fmt"
+	"math/big"
 	"net"
+	"strings"
+	"time"
+	"unicode"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -30,9 +34,11 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/discover"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethereum/go-ethereum/swarm/api"
 	httpapi "github.com/ethereum/go-ethereum/swarm/api/http"
@@ -41,6 +47,16 @@ import (
 	"github.com/ethereum/go-ethereum/swarm/storage"
 )
 
+var (
+	startTime          time.Time
+	updateGaugesPeriod = 5 * time.Second
+	startCounter       = metrics.NewRegisteredCounter("stack,start", nil)
+	stopCounter        = metrics.NewRegisteredCounter("stack,stop", nil)
+	uptimeGauge        = metrics.NewRegisteredGauge("stack.uptime", nil)
+	dbSizeGauge        = metrics.NewRegisteredGauge("storage.db.chunks.size", nil)
+	cacheSizeGauge     = metrics.NewRegisteredGauge("storage.db.cache.size", nil)
+)
+
 // the swarm stack
 type Swarm struct {
 	config      *api.Config            // swarm configuration
@@ -76,7 +92,7 @@ func (self *Swarm) API() *SwarmAPI {
 
 // creates a new swarm service instance
 // implements node.Service
-func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *ethclient.Client, config *api.Config, swapEnabled, syncEnabled bool, cors string) (self *Swarm, err error) {
+func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.Config) (self *Swarm, err error) {
 	if bytes.Equal(common.FromHex(config.PublicKey), storage.ZeroKey) {
 		return nil, fmt.Errorf("empty public key")
 	}
@@ -86,10 +102,10 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *e
 
 	self = &Swarm{
 		config:      config,
-		swapEnabled: swapEnabled,
+		swapEnabled: config.SwapEnabled,
 		backend:     backend,
 		privateKey:  config.Swap.PrivateKey(),
-		corsString:  cors,
+		corsString:  config.Cors,
 	}
 	log.Debug(fmt.Sprintf("Setting up Swarm service components"))
 
@@ -109,8 +125,8 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *e
 	self.hive = network.NewHive(
 		common.HexToHash(self.config.BzzKey), // key to hive (kademlia base address)
 		config.HiveParams,                    // configuration parameters
-		swapEnabled,                          // SWAP enabled
-		syncEnabled,                          // syncronisation enabled
+		config.SwapEnabled,                   // SWAP enabled
+		config.SyncEnabled,                   // syncronisation enabled
 	)
 	log.Debug(fmt.Sprintf("Set up swarm network with Kademlia hive"))
 
@@ -133,18 +149,18 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *e
 	self.dpa = storage.NewDPA(dpaChunkStore, self.config.ChunkerParams)
 	log.Debug(fmt.Sprintf("-> Content Store API"))
 
-	// set up high level api
-	transactOpts := bind.NewKeyedTransactor(self.privateKey)
-
-	if ensClient == nil {
-		log.Warn("No ENS, please specify non-empty --ens-api to use domain name resolution")
-	} else {
-		self.dns, err = ens.NewENS(transactOpts, config.EnsRoot, ensClient)
-		if err != nil {
-			return nil, err
+	if len(config.EnsAPIs) > 0 {
+		opts := []api.MultiResolverOption{}
+		for _, c := range config.EnsAPIs {
+			tld, endpoint, addr := parseEnsAPIAddress(c)
+			r, err := newEnsClient(endpoint, addr, config)
+			if err != nil {
+				return nil, err
+			}
+			opts = append(opts, api.MultiResolverOptionWithResolver(r, tld))
 		}
+		self.dns = api.NewMultiResolver(opts...)
 	}
-	log.Debug(fmt.Sprintf("-> Swarm Domain Name Registrar @ address %v", config.EnsRoot.Hex()))
 
 	self.api = api.NewApi(self.dpa, self.dns)
 	// Manifests for Smart Hosting
@@ -156,6 +172,95 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *e
 	return self, nil
 }
 
+// parseEnsAPIAddress parses string according to format
+// [tld:][contract-addr@]url and returns ENSClientConfig structure
+// with endpoint, contract address and TLD.
+func parseEnsAPIAddress(s string) (tld, endpoint string, addr common.Address) {
+	isAllLetterString := func(s string) bool {
+		for _, r := range s {
+			if !unicode.IsLetter(r) {
+				return false
+			}
+		}
+		return true
+	}
+	endpoint = s
+	if i := strings.Index(endpoint, ":"); i > 0 {
+		if isAllLetterString(endpoint[:i]) && len(endpoint) > i+2 && endpoint[i+1:i+3] != "//" {
+			tld = endpoint[:i]
+			endpoint = endpoint[i+1:]
+		}
+	}
+	if i := strings.Index(endpoint, "@"); i > 0 {
+		addr = common.HexToAddress(endpoint[:i])
+		endpoint = endpoint[i+1:]
+	}
+	return
+}
+
+// newEnsClient creates a new ENS client for that is a consumer of
+// a ENS API on a specific endpoint. It is used as a helper function
+// for creating multiple resolvers in NewSwarm function.
+func newEnsClient(endpoint string, addr common.Address, config *api.Config) (*ens.ENS, error) {
+	log.Info("connecting to ENS API", "url", endpoint)
+	client, err := rpc.Dial(endpoint)
+	if err != nil {
+		return nil, fmt.Errorf("error connecting to ENS API %s: %s", endpoint, err)
+	}
+	ensClient := ethclient.NewClient(client)
+
+	ensRoot := config.EnsRoot
+	if addr != (common.Address{}) {
+		ensRoot = addr
+	} else {
+		a, err := detectEnsAddr(client)
+		if err == nil {
+			ensRoot = a
+		} else {
+			log.Warn(fmt.Sprintf("could not determine ENS contract address, using default %s", ensRoot), "err", err)
+		}
+	}
+	transactOpts := bind.NewKeyedTransactor(config.Swap.PrivateKey())
+	dns, err := ens.NewENS(transactOpts, ensRoot, ensClient)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(fmt.Sprintf("-> Swarm Domain Name Registrar %v @ address %v", endpoint, ensRoot.Hex()))
+	return dns, err
+}
+
+// detectEnsAddr determines the ENS contract address by getting both the
+// version and genesis hash using the client and matching them to either
+// mainnet or testnet addresses
+func detectEnsAddr(client *rpc.Client) (common.Address, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	var version string
+	if err := client.CallContext(ctx, &version, "net_version"); err != nil {
+		return common.Address{}, err
+	}
+
+	block, err := ethclient.NewClient(client).BlockByNumber(ctx, big.NewInt(0))
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	switch {
+
+	case version == "1" && block.Hash() == params.MainnetGenesisHash:
+		log.Info("using Mainnet ENS contract address", "addr", ens.MainNetAddress)
+		return ens.MainNetAddress, nil
+
+	case version == "3" && block.Hash() == params.TestnetGenesisHash:
+		log.Info("using Testnet ENS contract address", "addr", ens.TestNetAddress)
+		return ens.TestNetAddress, nil
+
+	default:
+		return common.Address{}, fmt.Errorf("unknown version and genesis hash: %s %s", version, block.Hash())
+	}
+}
+
 /*
 Start is called when the stack is started
 * starts the network kademlia hive peer management
@@ -168,6 +273,7 @@ Start is called when the stack is started
 */
 // implements the node.Service interface
 func (self *Swarm) Start(srv *p2p.Server) error {
+	startTime = time.Now()
 	connectPeer := func(url string) error {
 		node, err := discover.ParseNode(url)
 		if err != nil {
@@ -213,9 +319,28 @@ func (self *Swarm) Start(srv *p2p.Server) error {
 		}
 	}
 
+	self.periodicallyUpdateGauges()
+
+	startCounter.Inc(1)
 	return nil
 }
 
+func (self *Swarm) periodicallyUpdateGauges() {
+	ticker := time.NewTicker(updateGaugesPeriod)
+
+	go func() {
+		for range ticker.C {
+			self.updateGauges()
+		}
+	}()
+}
+
+func (self *Swarm) updateGauges() {
+	dbSizeGauge.Update(int64(self.lstore.DbCounter()))
+	cacheSizeGauge.Update(int64(self.lstore.CacheCounter()))
+	uptimeGauge.Update(time.Since(startTime).Nanoseconds())
+}
+
 // implements the node.Service interface
 // stops all component services.
 func (self *Swarm) Stop() error {
@@ -230,6 +355,7 @@ func (self *Swarm) Stop() error {
 		self.lstore.DbStore.Close()
 	}
 	self.sfs.Stop()
+	stopCounter.Inc(1)
 	return err
 }
 
diff --git a/swarm/swarm_test.go b/swarm/swarm_test.go
new file mode 100644
index 0000000000..8b1ae28884
--- /dev/null
+++ b/swarm/swarm_test.go
@@ -0,0 +1,119 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package swarm
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+func TestParseEnsAPIAddress(t *testing.T) {
+	for _, x := range []struct {
+		description string
+		value       string
+		tld         string
+		endpoint    string
+		addr        common.Address
+	}{
+		{
+			description: "IPC endpoint",
+			value:       "/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+		},
+		{
+			description: "HTTP endpoint",
+			value:       "http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+		},
+		{
+			description: "WS endpoint",
+			value:       "ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+		},
+		{
+			description: "IPC Endpoint and TLD",
+			value:       "test:/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			tld:         "test",
+		},
+		{
+			description: "HTTP endpoint and TLD",
+			value:       "test:http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			tld:         "test",
+		},
+		{
+			description: "WS endpoint and TLD",
+			value:       "test:ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			tld:         "test",
+		},
+		{
+			description: "IPC Endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "HTTP endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "WS endpoint and contract address",
+			value:       "314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+		},
+		{
+			description: "IPC Endpoint, TLD and contract address",
+			value:       "test:314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/geth.ipc",
+			endpoint:    "/data/testnet/geth.ipc",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "test",
+		},
+		{
+			description: "HTTP endpoint, TLD and contract address",
+			value:       "eth:314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
+			endpoint:    "http://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "eth",
+		},
+		{
+			description: "WS endpoint, TLD and contract address",
+			value:       "eth:314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
+			endpoint:    "ws://127.0.0.1:1234",
+			addr:        common.HexToAddress("314159265dD8dbb310642f98f50C066173C1259b"),
+			tld:         "eth",
+		},
+	} {
+		t.Run(x.description, func(t *testing.T) {
+			tld, endpoint, addr := parseEnsAPIAddress(x.value)
+			if endpoint != x.endpoint {
+				t.Errorf("expected Endpoint %q, got %q", x.endpoint, endpoint)
+			}
+			if addr != x.addr {
+				t.Errorf("expected ContractAddress %q, got %q", x.addr.String(), addr.String())
+			}
+			if tld != x.tld {
+				t.Errorf("expected TLD %q, got %q", x.tld, tld)
+			}
+		})
+	}
+}
diff --git a/tests/block_test_util.go b/tests/block_test_util.go
index a789e6d887..2db47da57f 100644
--- a/tests/block_test_util.go
+++ b/tests/block_test_util.go
@@ -42,6 +42,7 @@ type BlockTest struct {
 	json btJSON
 }
 
+// UnmarshalJSON implements json.Unmarshaler interface.
 func (t *BlockTest) UnmarshalJSON(in []byte) error {
 	return json.Unmarshal(in, &t.json)
 }
@@ -77,8 +78,8 @@ type btHeader struct {
 	UncleHash        common.Hash
 	ExtraData        []byte
 	Difficulty       *big.Int
-	GasLimit         *big.Int
-	GasUsed          *big.Int
+	GasLimit         uint64
+	GasUsed          uint64
 	Timestamp        *big.Int
 }
 
@@ -86,8 +87,8 @@ type btHeaderMarshaling struct {
 	ExtraData  hexutil.Bytes
 	Number     *math.HexOrDecimal256
 	Difficulty *math.HexOrDecimal256
-	GasLimit   *math.HexOrDecimal256
-	GasUsed    *math.HexOrDecimal256
+	GasLimit   math.HexOrDecimal64
+	GasUsed    math.HexOrDecimal64
 	Timestamp  *math.HexOrDecimal256
 }
 
@@ -98,19 +99,19 @@ func (t *BlockTest) Run() error {
 	}
 
 	// import pre accounts & construct test genesis block & state root
-	db, _ := ethdb.NewMemDatabase()
+	db := ethdb.NewMemDatabase()
 	gblock, err := t.genesis(config).Commit(db)
 	if err != nil {
 		return err
 	}
 	if gblock.Hash() != t.json.Genesis.Hash {
-		return fmt.Errorf("genesis block hash doesn't match test: computed=%x, test=%x\n", gblock.Hash().Bytes()[:6], t.json.Genesis.Hash[:6])
+		return fmt.Errorf("genesis block hash doesn't match test: computed=%x, test=%x", gblock.Hash().Bytes()[:6], t.json.Genesis.Hash[:6])
 	}
 	if gblock.Root() != t.json.Genesis.StateRoot {
 		return fmt.Errorf("genesis block state root does not match test: computed=%x, test=%x", gblock.Root().Bytes()[:6], t.json.Genesis.StateRoot[:6])
 	}
 
-	chain, err := core.NewBlockChain(db, config, ethash.NewShared(), vm.Config{})
+	chain, err := core.NewBlockChain(db, nil, config, ethash.NewShared(), vm.Config{})
 	if err != nil {
 		return err
 	}
@@ -120,7 +121,7 @@ func (t *BlockTest) Run() error {
 	if err != nil {
 		return err
 	}
-	cmlast := chain.LastBlockHash()
+	cmlast := chain.CurrentBlock().Hash()
 	if common.Hash(t.json.BestBlock) != cmlast {
 		return fmt.Errorf("last block hash validation mismatch: want: %x, have: %x", t.json.BestBlock, cmlast)
 	}
@@ -141,8 +142,8 @@ func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis {
 		Timestamp:  t.json.Genesis.Timestamp.Uint64(),
 		ParentHash: t.json.Genesis.ParentHash,
 		ExtraData:  t.json.Genesis.ExtraData,
-		GasLimit:   t.json.Genesis.GasLimit.Uint64(),
-		GasUsed:    t.json.Genesis.GasUsed.Uint64(),
+		GasLimit:   t.json.Genesis.GasLimit,
+		GasUsed:    t.json.Genesis.GasUsed,
 		Difficulty: t.json.Genesis.Difficulty,
 		Mixhash:    t.json.Genesis.MixHash,
 		Coinbase:   t.json.Genesis.Coinbase,
@@ -234,11 +235,11 @@ func validateHeader(h *btHeader, h2 *types.Header) error {
 	if h.Difficulty.Cmp(h2.Difficulty) != 0 {
 		return fmt.Errorf("Difficulty: want: %v have: %v", h.Difficulty, h2.Difficulty)
 	}
-	if h.GasLimit.Cmp(h2.GasLimit) != 0 {
-		return fmt.Errorf("GasLimit: want: %v have: %v", h.GasLimit, h2.GasLimit)
+	if h.GasLimit != h2.GasLimit {
+		return fmt.Errorf("GasLimit: want: %d have: %d", h.GasLimit, h2.GasLimit)
 	}
-	if h.GasUsed.Cmp(h2.GasUsed) != 0 {
-		return fmt.Errorf("GasUsed: want: %v have: %v", h.GasUsed, h2.GasUsed)
+	if h.GasUsed != h2.GasUsed {
+		return fmt.Errorf("GasUsed: want: %d have: %d", h.GasUsed, h2.GasUsed)
 	}
 	if h.Timestamp.Cmp(h2.Time) != 0 {
 		return fmt.Errorf("Timestamp: want: %v have: %v", h.Timestamp, h2.Time)
diff --git a/tests/difficulty_test.go b/tests/difficulty_test.go
index a449b1cfa6..20294cc9d5 100644
--- a/tests/difficulty_test.go
+++ b/tests/difficulty_test.go
@@ -13,7 +13,6 @@
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see .
-//
 
 package tests
 
@@ -28,7 +27,7 @@ import (
 
 var (
 	mainnetChainConfig = params.ChainConfig{
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(1150000),
 		DAOForkBlock:   big.NewInt(1920000),
 		DAOForkSupport: true,
diff --git a/tests/difficulty_test_util.go b/tests/difficulty_test_util.go
index 7541477933..00d699cf75 100644
--- a/tests/difficulty_test_util.go
+++ b/tests/difficulty_test_util.go
@@ -13,7 +13,6 @@
 //
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see .
-//
 
 package tests
 
diff --git a/tests/gen_btheader.go b/tests/gen_btheader.go
index 5d65e0dbce..5cfd4bd0ae 100644
--- a/tests/gen_btheader.go
+++ b/tests/gen_btheader.go
@@ -29,8 +29,8 @@ func (b btHeader) MarshalJSON() ([]byte, error) {
 		UncleHash        common.Hash
 		ExtraData        hexutil.Bytes
 		Difficulty       *math.HexOrDecimal256
-		GasLimit         *math.HexOrDecimal256
-		GasUsed          *math.HexOrDecimal256
+		GasLimit         math.HexOrDecimal64
+		GasUsed          math.HexOrDecimal64
 		Timestamp        *math.HexOrDecimal256
 	}
 	var enc btHeader
@@ -47,8 +47,8 @@ func (b btHeader) MarshalJSON() ([]byte, error) {
 	enc.UncleHash = b.UncleHash
 	enc.ExtraData = b.ExtraData
 	enc.Difficulty = (*math.HexOrDecimal256)(b.Difficulty)
-	enc.GasLimit = (*math.HexOrDecimal256)(b.GasLimit)
-	enc.GasUsed = (*math.HexOrDecimal256)(b.GasUsed)
+	enc.GasLimit = math.HexOrDecimal64(b.GasLimit)
+	enc.GasUsed = math.HexOrDecimal64(b.GasUsed)
 	enc.Timestamp = (*math.HexOrDecimal256)(b.Timestamp)
 	return json.Marshal(&enc)
 }
@@ -66,10 +66,10 @@ func (b *btHeader) UnmarshalJSON(input []byte) error {
 		StateRoot        *common.Hash
 		TransactionsTrie *common.Hash
 		UncleHash        *common.Hash
-		ExtraData        hexutil.Bytes
+		ExtraData        *hexutil.Bytes
 		Difficulty       *math.HexOrDecimal256
-		GasLimit         *math.HexOrDecimal256
-		GasUsed          *math.HexOrDecimal256
+		GasLimit         *math.HexOrDecimal64
+		GasUsed          *math.HexOrDecimal64
 		Timestamp        *math.HexOrDecimal256
 	}
 	var dec btHeader
@@ -110,16 +110,16 @@ func (b *btHeader) UnmarshalJSON(input []byte) error {
 		b.UncleHash = *dec.UncleHash
 	}
 	if dec.ExtraData != nil {
-		b.ExtraData = dec.ExtraData
+		b.ExtraData = *dec.ExtraData
 	}
 	if dec.Difficulty != nil {
 		b.Difficulty = (*big.Int)(dec.Difficulty)
 	}
 	if dec.GasLimit != nil {
-		b.GasLimit = (*big.Int)(dec.GasLimit)
+		b.GasLimit = uint64(*dec.GasLimit)
 	}
 	if dec.GasUsed != nil {
-		b.GasUsed = (*big.Int)(dec.GasUsed)
+		b.GasUsed = uint64(*dec.GasUsed)
 	}
 	if dec.Timestamp != nil {
 		b.Timestamp = (*big.Int)(dec.Timestamp)
diff --git a/tests/gen_stenv.go b/tests/gen_stenv.go
index c780524bc3..1d4baf2fd7 100644
--- a/tests/gen_stenv.go
+++ b/tests/gen_stenv.go
@@ -17,14 +17,14 @@ func (s stEnv) MarshalJSON() ([]byte, error) {
 	type stEnv struct {
 		Coinbase   common.UnprefixedAddress `json:"currentCoinbase"   gencodec:"required"`
 		Difficulty *math.HexOrDecimal256    `json:"currentDifficulty" gencodec:"required"`
-		GasLimit   *math.HexOrDecimal256    `json:"currentGasLimit"   gencodec:"required"`
+		GasLimit   math.HexOrDecimal64      `json:"currentGasLimit"   gencodec:"required"`
 		Number     math.HexOrDecimal64      `json:"currentNumber"     gencodec:"required"`
 		Timestamp  math.HexOrDecimal64      `json:"currentTimestamp"  gencodec:"required"`
 	}
 	var enc stEnv
 	enc.Coinbase = common.UnprefixedAddress(s.Coinbase)
 	enc.Difficulty = (*math.HexOrDecimal256)(s.Difficulty)
-	enc.GasLimit = (*math.HexOrDecimal256)(s.GasLimit)
+	enc.GasLimit = math.HexOrDecimal64(s.GasLimit)
 	enc.Number = math.HexOrDecimal64(s.Number)
 	enc.Timestamp = math.HexOrDecimal64(s.Timestamp)
 	return json.Marshal(&enc)
@@ -34,7 +34,7 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	type stEnv struct {
 		Coinbase   *common.UnprefixedAddress `json:"currentCoinbase"   gencodec:"required"`
 		Difficulty *math.HexOrDecimal256     `json:"currentDifficulty" gencodec:"required"`
-		GasLimit   *math.HexOrDecimal256     `json:"currentGasLimit"   gencodec:"required"`
+		GasLimit   *math.HexOrDecimal64      `json:"currentGasLimit"   gencodec:"required"`
 		Number     *math.HexOrDecimal64      `json:"currentNumber"     gencodec:"required"`
 		Timestamp  *math.HexOrDecimal64      `json:"currentTimestamp"  gencodec:"required"`
 	}
@@ -53,7 +53,7 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'currentGasLimit' for stEnv")
 	}
-	s.GasLimit = (*big.Int)(dec.GasLimit)
+	s.GasLimit = uint64(*dec.GasLimit)
 	if dec.Number == nil {
 		return errors.New("missing required field 'currentNumber' for stEnv")
 	}
diff --git a/tests/gen_sttransaction.go b/tests/gen_sttransaction.go
index 5a489d00b8..451ffcbf43 100644
--- a/tests/gen_sttransaction.go
+++ b/tests/gen_sttransaction.go
@@ -46,7 +46,7 @@ func (s *stTransaction) UnmarshalJSON(input []byte) error {
 		Data       []string              `json:"data"`
 		GasLimit   []math.HexOrDecimal64 `json:"gasLimit"`
 		Value      []string              `json:"value"`
-		PrivateKey hexutil.Bytes         `json:"secretKey"`
+		PrivateKey *hexutil.Bytes        `json:"secretKey"`
 	}
 	var dec stTransaction
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -74,7 +74,7 @@ func (s *stTransaction) UnmarshalJSON(input []byte) error {
 		s.Value = dec.Value
 	}
 	if dec.PrivateKey != nil {
-		s.PrivateKey = dec.PrivateKey
+		s.PrivateKey = *dec.PrivateKey
 	}
 	return nil
 }
diff --git a/tests/gen_tttransaction.go b/tests/gen_tttransaction.go
index b6759be912..2948842d97 100644
--- a/tests/gen_tttransaction.go
+++ b/tests/gen_tttransaction.go
@@ -17,7 +17,7 @@ var _ = (*ttTransactionMarshaling)(nil)
 func (t ttTransaction) MarshalJSON() ([]byte, error) {
 	type ttTransaction struct {
 		Data     hexutil.Bytes         `gencodec:"required"`
-		GasLimit *math.HexOrDecimal256 `gencodec:"required"`
+		GasLimit math.HexOrDecimal64   `gencodec:"required"`
 		GasPrice *math.HexOrDecimal256 `gencodec:"required"`
 		Nonce    math.HexOrDecimal64   `gencodec:"required"`
 		Value    *math.HexOrDecimal256 `gencodec:"required"`
@@ -28,7 +28,7 @@ func (t ttTransaction) MarshalJSON() ([]byte, error) {
 	}
 	var enc ttTransaction
 	enc.Data = t.Data
-	enc.GasLimit = (*math.HexOrDecimal256)(t.GasLimit)
+	enc.GasLimit = math.HexOrDecimal64(t.GasLimit)
 	enc.GasPrice = (*math.HexOrDecimal256)(t.GasPrice)
 	enc.Nonce = math.HexOrDecimal64(t.Nonce)
 	enc.Value = (*math.HexOrDecimal256)(t.Value)
@@ -41,8 +41,8 @@ func (t ttTransaction) MarshalJSON() ([]byte, error) {
 
 func (t *ttTransaction) UnmarshalJSON(input []byte) error {
 	type ttTransaction struct {
-		Data     hexutil.Bytes         `gencodec:"required"`
-		GasLimit *math.HexOrDecimal256 `gencodec:"required"`
+		Data     *hexutil.Bytes        `gencodec:"required"`
+		GasLimit *math.HexOrDecimal64  `gencodec:"required"`
 		GasPrice *math.HexOrDecimal256 `gencodec:"required"`
 		Nonce    *math.HexOrDecimal64  `gencodec:"required"`
 		Value    *math.HexOrDecimal256 `gencodec:"required"`
@@ -58,11 +58,11 @@ func (t *ttTransaction) UnmarshalJSON(input []byte) error {
 	if dec.Data == nil {
 		return errors.New("missing required field 'data' for ttTransaction")
 	}
-	t.Data = dec.Data
+	t.Data = *dec.Data
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'gasLimit' for ttTransaction")
 	}
-	t.GasLimit = (*big.Int)(dec.GasLimit)
+	t.GasLimit = uint64(*dec.GasLimit)
 	if dec.GasPrice == nil {
 		return errors.New("missing required field 'gasPrice' for ttTransaction")
 	}
diff --git a/tests/gen_vmexec.go b/tests/gen_vmexec.go
index dd2d3d94e7..a5f01cf456 100644
--- a/tests/gen_vmexec.go
+++ b/tests/gen_vmexec.go
@@ -42,8 +42,8 @@ func (v *vmExec) UnmarshalJSON(input []byte) error {
 		Address  *common.UnprefixedAddress `json:"address"  gencodec:"required"`
 		Caller   *common.UnprefixedAddress `json:"caller"   gencodec:"required"`
 		Origin   *common.UnprefixedAddress `json:"origin"   gencodec:"required"`
-		Code     hexutil.Bytes             `json:"code"     gencodec:"required"`
-		Data     hexutil.Bytes             `json:"data"     gencodec:"required"`
+		Code     *hexutil.Bytes            `json:"code"     gencodec:"required"`
+		Data     *hexutil.Bytes            `json:"data"     gencodec:"required"`
 		Value    *math.HexOrDecimal256     `json:"value"    gencodec:"required"`
 		GasLimit *math.HexOrDecimal64      `json:"gas"      gencodec:"required"`
 		GasPrice *math.HexOrDecimal256     `json:"gasPrice" gencodec:"required"`
@@ -67,11 +67,11 @@ func (v *vmExec) UnmarshalJSON(input []byte) error {
 	if dec.Code == nil {
 		return errors.New("missing required field 'code' for vmExec")
 	}
-	v.Code = dec.Code
+	v.Code = *dec.Code
 	if dec.Data == nil {
 		return errors.New("missing required field 'data' for vmExec")
 	}
-	v.Data = dec.Data
+	v.Data = *dec.Data
 	if dec.Value == nil {
 		return errors.New("missing required field 'value' for vmExec")
 	}
diff --git a/tests/init.go b/tests/init.go
index 9e884efe39..af65f92069 100644
--- a/tests/init.go
+++ b/tests/init.go
@@ -1,4 +1,4 @@
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2015 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -23,29 +23,29 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
-// This table defines supported forks and their chain config.
+// Forks table defines supported forks and their chain config.
 var Forks = map[string]*params.ChainConfig{
 	"Frontier": {
-		ChainId: big.NewInt(1),
+		ChainID: big.NewInt(1),
 	},
 	"Homestead": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 	},
 	"EIP150": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		EIP150Block:    big.NewInt(0),
 	},
 	"EIP158": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		EIP150Block:    big.NewInt(0),
 		EIP155Block:    big.NewInt(0),
 		EIP158Block:    big.NewInt(0),
 	},
 	"Byzantium": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		EIP150Block:    big.NewInt(0),
 		EIP155Block:    big.NewInt(0),
@@ -54,22 +54,22 @@ var Forks = map[string]*params.ChainConfig{
 		ByzantiumBlock: big.NewInt(0),
 	},
 	"FrontierToHomesteadAt5": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(5),
 	},
 	"HomesteadToEIP150At5": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		EIP150Block:    big.NewInt(5),
 	},
 	"HomesteadToDaoAt5": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		DAOForkBlock:   big.NewInt(5),
 		DAOForkSupport: true,
 	},
 	"EIP158ToByzantiumAt5": {
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 		HomesteadBlock: big.NewInt(0),
 		EIP150Block:    big.NewInt(0),
 		EIP155Block:    big.NewInt(0),
diff --git a/tests/init_test.go b/tests/init_test.go
index ebb0d32c34..26e919d24b 100644
--- a/tests/init_test.go
+++ b/tests/init_test.go
@@ -1,4 +1,4 @@
-// Copyright 2015 The go-ethereum Authors
+// Copyright 2017 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -42,7 +42,7 @@ var (
 	difficultyTestDir  = filepath.Join(baseDir, "BasicTests")
 )
 
-func readJson(reader io.Reader, value interface{}) error {
+func readJSON(reader io.Reader, value interface{}) error {
 	data, err := ioutil.ReadAll(reader)
 	if err != nil {
 		return fmt.Errorf("error reading JSON file: %v", err)
@@ -57,14 +57,14 @@ func readJson(reader io.Reader, value interface{}) error {
 	return nil
 }
 
-func readJsonFile(fn string, value interface{}) error {
+func readJSONFile(fn string, value interface{}) error {
 	file, err := os.Open(fn)
 	if err != nil {
 		return err
 	}
 	defer file.Close()
 
-	err = readJson(file, value)
+	err = readJSON(file, value)
 	if err != nil {
 		return fmt.Errorf("%s in file %s", err.Error(), fn)
 	}
@@ -169,9 +169,8 @@ func (tm *testMatcher) checkFailure(t *testing.T, name string, err error) error
 		if err != nil {
 			t.Logf("error: %v", err)
 			return nil
-		} else {
-			return fmt.Errorf("test succeeded unexpectedly")
 		}
+		return fmt.Errorf("test succeeded unexpectedly")
 	}
 	return err
 }
@@ -213,7 +212,7 @@ func (tm *testMatcher) runTestFile(t *testing.T, path, name string, runTest inte
 
 	// Load the file as map[string].
 	m := makeMapFromTestFunc(runTest)
-	if err := readJsonFile(path, m.Addr().Interface()); err != nil {
+	if err := readJSONFile(path, m.Addr().Interface()); err != nil {
 		t.Fatal(err)
 	}
 
diff --git a/tests/state_test.go b/tests/state_test.go
index 5a67b290db..adec4feb2b 100644
--- a/tests/state_test.go
+++ b/tests/state_test.go
@@ -1,4 +1,4 @@
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2015 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -36,19 +36,8 @@ func TestState(t *testing.T) {
 	st.skipLoad(`^stTransactionTest/zeroSigTransa[^/]*\.json`) // EIP-86 is not supported yet
 	// Expected failures:
 	st.fails(`^stRevertTest/RevertPrecompiledTouch\.json/EIP158`, "bug in test")
-	st.fails(`^stRevertTest/RevertPrefoundEmptyOOG\.json/EIP158`, "bug in test")
 	st.fails(`^stRevertTest/RevertPrecompiledTouch\.json/Byzantium`, "bug in test")
-	st.fails(`^stRevertTest/RevertPrefoundEmptyOOG\.json/Byzantium`, "bug in test")
-	st.fails(`^stRandom/randomStatetest645\.json/EIP150/.*`, "known bug #15119")
-	st.fails(`^stRandom/randomStatetest645\.json/Frontier/.*`, "known bug #15119")
-	st.fails(`^stRandom/randomStatetest645\.json/Homestead/.*`, "known bug #15119")
-	st.fails(`^stRandom/randomStatetest644\.json/EIP150/.*`, "known bug #15119")
-	st.fails(`^stRandom/randomStatetest644\.json/Frontier/.*`, "known bug #15119")
-	st.fails(`^stRandom/randomStatetest644\.json/Homestead/.*`, "known bug #15119")
-	st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/EIP158/2`, "known bug ")
-	st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/EIP158/3`, "known bug ")
-	st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/Byzantium/2`, "known bug ")
-	st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/Byzantium/3`, "known bug ")
+
 	st.walk(t, stateTestDir, func(t *testing.T, name string, test *StateTest) {
 		for _, subtest := range test.Subtests() {
 			subtest := subtest
@@ -68,8 +57,7 @@ func TestState(t *testing.T) {
 }
 
 // Transactions with gasLimit above this value will not get a VM trace on failure.
-//const traceErrorLimit = 400000
-const traceErrorLimit = 0
+const traceErrorLimit = 400000
 
 func withTrace(t *testing.T, gasLimit uint64, test func(vm.Config) error) {
 	err := test(vm.Config{})
@@ -93,4 +81,6 @@ func withTrace(t *testing.T, gasLimit uint64, test func(vm.Config) error) {
 	} else {
 		t.Log("EVM operation log:\n" + buf.String())
 	}
+	t.Logf("EVM output: 0x%x", tracer.Output())
+	t.Logf("EVM error: %v", tracer.Error())
 }
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 352f840d9f..84581fae18 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -1,4 +1,4 @@
-// Copyright 2017 The go-ethereum Authors
+// Copyright 2015 The go-ethereum Authors
 // This file is part of the go-ethereum library.
 //
 // The go-ethereum library is free software: you can redistribute it and/or modify
@@ -76,7 +76,7 @@ type stPostState struct {
 type stEnv struct {
 	Coinbase   common.Address `json:"currentCoinbase"   gencodec:"required"`
 	Difficulty *big.Int       `json:"currentDifficulty" gencodec:"required"`
-	GasLimit   *big.Int       `json:"currentGasLimit"   gencodec:"required"`
+	GasLimit   uint64         `json:"currentGasLimit"   gencodec:"required"`
 	Number     uint64         `json:"currentNumber"     gencodec:"required"`
 	Timestamp  uint64         `json:"currentTimestamp"  gencodec:"required"`
 }
@@ -84,7 +84,7 @@ type stEnv struct {
 type stEnvMarshaling struct {
 	Coinbase   common.UnprefixedAddress
 	Difficulty *math.HexOrDecimal256
-	GasLimit   *math.HexOrDecimal256
+	GasLimit   math.HexOrDecimal64
 	Number     math.HexOrDecimal64
 	Timestamp  math.HexOrDecimal64
 }
@@ -125,9 +125,8 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config) (*state.StateD
 	if !ok {
 		return nil, UnsupportedForkError{subtest.Fork}
 	}
-	block, _ := t.genesis(config).ToBlock()
-	db, _ := ethdb.NewMemDatabase()
-	statedb := makePreState(db, t.json.Pre)
+	block := t.genesis(config).ToBlock(nil)
+	statedb := MakePreState(ethdb.NewMemDatabase(), t.json.Pre)
 
 	post := t.json.Post[subtest.Fork][subtest.Index]
 	msg, err := t.json.Tx.toMessage(post)
@@ -147,7 +146,7 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config) (*state.StateD
 	if logs := rlpHash(statedb.Logs()); logs != common.Hash(post.Logs) {
 		return statedb, fmt.Errorf("post state logs hash mismatch: got %x, want %x", logs, post.Logs)
 	}
-	root, _ := statedb.CommitTo(db, config.IsEIP158(block.Number()))
+	root, _ := statedb.Commit(config.IsEIP158(block.Number()))
 	if root != common.Hash(post.Root) {
 		return statedb, fmt.Errorf("post state root mismatch: got %x, want %x", root, post.Root)
 	}
@@ -158,7 +157,7 @@ func (t *StateTest) gasLimit(subtest StateSubtest) uint64 {
 	return t.json.Tx.GasLimit[t.json.Post[subtest.Fork][subtest.Index].Indexes.Gas]
 }
 
-func makePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB {
+func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB {
 	sdb := state.NewDatabase(db)
 	statedb, _ := state.New(common.Hash{}, sdb)
 	for addr, a := range accounts {
@@ -170,7 +169,7 @@ func makePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB
 		}
 	}
 	// Commit and re-open to start with a clean state.
-	root, _ := statedb.CommitTo(db, false)
+	root, _ := statedb.Commit(false)
 	statedb, _ = state.New(root, sdb)
 	return statedb
 }
@@ -180,7 +179,7 @@ func (t *StateTest) genesis(config *params.ChainConfig) *core.Genesis {
 		Config:     config,
 		Coinbase:   t.json.Env.Coinbase,
 		Difficulty: t.json.Env.Difficulty,
-		GasLimit:   t.json.Env.GasLimit.Uint64(),
+		GasLimit:   t.json.Env.GasLimit,
 		Number:     t.json.Env.Number,
 		Timestamp:  t.json.Env.Timestamp,
 		Alloc:      t.json.Pre,
@@ -233,7 +232,7 @@ func (tx *stTransaction) toMessage(ps stPostState) (core.Message, error) {
 		return nil, fmt.Errorf("invalid tx data %q", dataHex)
 	}
 
-	msg := types.NewMessage(from, to, tx.Nonce, value, new(big.Int).SetUint64(gasLimit), tx.GasPrice, data, true)
+	msg := types.NewMessage(from, to, tx.Nonce, value, gasLimit, tx.GasPrice, data, true)
 	return msg, nil
 }
 
diff --git a/tests/testdata b/tests/testdata
index 37f555fbc0..2bb0c3da3b 160000
--- a/tests/testdata
+++ b/tests/testdata
@@ -1 +1 @@
-Subproject commit 37f555fbc091fbf761aa6f02227132fb31f0681c
+Subproject commit 2bb0c3da3bbb15c528bcef2a7e5ac4bd73f81f87
diff --git a/tests/transaction_test.go b/tests/transaction_test.go
index c743996c2a..42ad81877e 100644
--- a/tests/transaction_test.go
+++ b/tests/transaction_test.go
@@ -35,7 +35,7 @@ func TestTransaction(t *testing.T) {
 		EIP150Block:    big.NewInt(0),
 		EIP155Block:    big.NewInt(0),
 		EIP158Block:    big.NewInt(0),
-		ChainId:        big.NewInt(1),
+		ChainID:        big.NewInt(1),
 	})
 	txt.config(`^Byzantium/`, params.ChainConfig{
 		HomesteadBlock: big.NewInt(0),
diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go
index 472b3d6f24..8c3dac088c 100644
--- a/tests/transaction_test_util.go
+++ b/tests/transaction_test_util.go
@@ -46,7 +46,7 @@ type ttJSON struct {
 
 type ttTransaction struct {
 	Data     []byte         `gencodec:"required"`
-	GasLimit *big.Int       `gencodec:"required"`
+	GasLimit uint64         `gencodec:"required"`
 	GasPrice *big.Int       `gencodec:"required"`
 	Nonce    uint64         `gencodec:"required"`
 	Value    *big.Int       `gencodec:"required"`
@@ -58,7 +58,7 @@ type ttTransaction struct {
 
 type ttTransactionMarshaling struct {
 	Data     hexutil.Bytes
-	GasLimit *math.HexOrDecimal256
+	GasLimit math.HexOrDecimal64
 	GasPrice *math.HexOrDecimal256
 	Nonce    math.HexOrDecimal64
 	Value    *math.HexOrDecimal256
@@ -72,9 +72,8 @@ func (tt *TransactionTest) Run(config *params.ChainConfig) error {
 	if err := rlp.DecodeBytes(tt.json.RLP, tx); err != nil {
 		if tt.json.Transaction == nil {
 			return nil
-		} else {
-			return fmt.Errorf("RLP decoding failed: %v", err)
 		}
+		return fmt.Errorf("RLP decoding failed: %v", err)
 	}
 	// Check sender derivation.
 	signer := types.MakeSigner(config, new(big.Int).SetUint64(uint64(tt.json.BlockNumber)))
@@ -100,8 +99,8 @@ func (tt *ttTransaction) verify(signer types.Signer, tx *types.Transaction) erro
 	if !bytes.Equal(tx.Data(), tt.Data) {
 		return fmt.Errorf("Tx input data mismatch: got %x want %x", tx.Data(), tt.Data)
 	}
-	if tx.Gas().Cmp(tt.GasLimit) != 0 {
-		return fmt.Errorf("GasLimit mismatch: got %v, want %v", tx.Gas(), tt.GasLimit)
+	if tx.Gas() != tt.GasLimit {
+		return fmt.Errorf("GasLimit mismatch: got %d, want %d", tx.Gas(), tt.GasLimit)
 	}
 	if tx.GasPrice().Cmp(tt.GasPrice) != 0 {
 		return fmt.Errorf("GasPrice mismatch: got %v, want %v", tx.GasPrice(), tt.GasPrice)
diff --git a/tests/vm_test_util.go b/tests/vm_test_util.go
index 0aa37955ce..cb81c5b94e 100644
--- a/tests/vm_test_util.go
+++ b/tests/vm_test_util.go
@@ -79,8 +79,7 @@ type vmExecMarshaling struct {
 }
 
 func (t *VMTest) Run(vmconfig vm.Config) error {
-	db, _ := ethdb.NewMemDatabase()
-	statedb := makePreState(db, t.json.Pre)
+	statedb := MakePreState(ethdb.NewMemDatabase(), t.json.Pre)
 	ret, gasRemaining, err := t.exec(statedb, vmconfig)
 
 	if t.json.GasRemaining == nil {
diff --git a/trie/database.go b/trie/database.go
new file mode 100644
index 0000000000..468c139df4
--- /dev/null
+++ b/trie/database.go
@@ -0,0 +1,517 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package trie
+
+import (
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+)
+
+var (
+	memcacheFlushTimeTimer  = metrics.NewRegisteredResettingTimer("trie/memcache/flush/time", nil)
+	memcacheFlushNodesMeter = metrics.NewRegisteredMeter("trie/memcache/flush/nodes", nil)
+	memcacheFlushSizeMeter  = metrics.NewRegisteredMeter("trie/memcache/flush/size", nil)
+
+	memcacheGCTimeTimer  = metrics.NewRegisteredResettingTimer("trie/memcache/gc/time", nil)
+	memcacheGCNodesMeter = metrics.NewRegisteredMeter("trie/memcache/gc/nodes", nil)
+	memcacheGCSizeMeter  = metrics.NewRegisteredMeter("trie/memcache/gc/size", nil)
+
+	memcacheCommitTimeTimer  = metrics.NewRegisteredResettingTimer("trie/memcache/commit/time", nil)
+	memcacheCommitNodesMeter = metrics.NewRegisteredMeter("trie/memcache/commit/nodes", nil)
+	memcacheCommitSizeMeter  = metrics.NewRegisteredMeter("trie/memcache/commit/size", nil)
+)
+
+// secureKeyPrefix is the database key prefix used to store trie node preimages.
+var secureKeyPrefix = []byte("secure-key-")
+
+// secureKeyLength is the length of the above prefix + 32byte hash.
+const secureKeyLength = 11 + 32
+
+// DatabaseReader wraps the Get and Has method of a backing store for the trie.
+type DatabaseReader interface {
+	// Get retrieves the value associated with key form the database.
+	Get(key []byte) (value []byte, err error)
+
+	// Has retrieves whether a key is present in the database.
+	Has(key []byte) (bool, error)
+}
+
+// Database is an intermediate write layer between the trie data structures and
+// the disk database. The aim is to accumulate trie writes in-memory and only
+// periodically flush a couple tries to disk, garbage collecting the remainder.
+type Database struct {
+	diskdb ethdb.Database // Persistent storage for matured trie nodes
+
+	nodes  map[common.Hash]*cachedNode // Data and references relationships of a node
+	oldest common.Hash                 // Oldest tracked node, flush-list head
+	newest common.Hash                 // Newest tracked node, flush-list tail
+
+	preimages map[common.Hash][]byte // Preimages of nodes from the secure trie
+	seckeybuf [secureKeyLength]byte  // Ephemeral buffer for calculating preimage keys
+
+	gctime  time.Duration      // Time spent on garbage collection since last commit
+	gcnodes uint64             // Nodes garbage collected since last commit
+	gcsize  common.StorageSize // Data storage garbage collected since last commit
+
+	flushtime  time.Duration      // Time spent on data flushing since last commit
+	flushnodes uint64             // Nodes flushed since last commit
+	flushsize  common.StorageSize // Data storage flushed since last commit
+
+	nodesSize     common.StorageSize // Storage size of the nodes cache (exc. flushlist)
+	preimagesSize common.StorageSize // Storage size of the preimages cache
+
+	lock sync.RWMutex
+}
+
+// cachedNode is all the information we know about a single cached node in the
+// memory database write layer.
+type cachedNode struct {
+	blob     []byte              // Cached data block of the trie node
+	parents  int                 // Number of live nodes referencing this one
+	children map[common.Hash]int // Children referenced by this nodes
+
+	flushPrev common.Hash // Previous node in the flush-list
+	flushNext common.Hash // Next node in the flush-list
+}
+
+// NewDatabase creates a new trie database to store ephemeral trie content before
+// its written out to disk or garbage collected.
+func NewDatabase(diskdb ethdb.Database) *Database {
+	return &Database{
+		diskdb: diskdb,
+		nodes: map[common.Hash]*cachedNode{
+			{}: {children: make(map[common.Hash]int)},
+		},
+		preimages: make(map[common.Hash][]byte),
+	}
+}
+
+// DiskDB retrieves the persistent storage backing the trie database.
+func (db *Database) DiskDB() DatabaseReader {
+	return db.diskdb
+}
+
+// Insert writes a new trie node to the memory database if it's yet unknown. The
+// method will make a copy of the slice.
+func (db *Database) Insert(hash common.Hash, blob []byte) {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	db.insert(hash, blob)
+}
+
+// insert is the private locked version of Insert.
+func (db *Database) insert(hash common.Hash, blob []byte) {
+	// If the node's already cached, skip
+	if _, ok := db.nodes[hash]; ok {
+		return
+	}
+	db.nodes[hash] = &cachedNode{
+		blob:      common.CopyBytes(blob),
+		children:  make(map[common.Hash]int),
+		flushPrev: db.newest,
+	}
+	// Update the flush-list endpoints
+	if db.oldest == (common.Hash{}) {
+		db.oldest, db.newest = hash, hash
+	} else {
+		db.nodes[db.newest].flushNext, db.newest = hash, hash
+	}
+	db.nodesSize += common.StorageSize(common.HashLength + len(blob))
+}
+
+// insertPreimage writes a new trie node pre-image to the memory database if it's
+// yet unknown. The method will make a copy of the slice.
+//
+// Note, this method assumes that the database's lock is held!
+func (db *Database) insertPreimage(hash common.Hash, preimage []byte) {
+	if _, ok := db.preimages[hash]; ok {
+		return
+	}
+	db.preimages[hash] = common.CopyBytes(preimage)
+	db.preimagesSize += common.StorageSize(common.HashLength + len(preimage))
+}
+
+// Node retrieves a cached trie node from memory. If it cannot be found cached,
+// the method queries the persistent database for the content.
+func (db *Database) Node(hash common.Hash) ([]byte, error) {
+	// Retrieve the node from cache if available
+	db.lock.RLock()
+	node := db.nodes[hash]
+	db.lock.RUnlock()
+
+	if node != nil {
+		return node.blob, nil
+	}
+	// Content unavailable in memory, attempt to retrieve from disk
+	return db.diskdb.Get(hash[:])
+}
+
+// preimage retrieves a cached trie node pre-image from memory. If it cannot be
+// found cached, the method queries the persistent database for the content.
+func (db *Database) preimage(hash common.Hash) ([]byte, error) {
+	// Retrieve the node from cache if available
+	db.lock.RLock()
+	preimage := db.preimages[hash]
+	db.lock.RUnlock()
+
+	if preimage != nil {
+		return preimage, nil
+	}
+	// Content unavailable in memory, attempt to retrieve from disk
+	return db.diskdb.Get(db.secureKey(hash[:]))
+}
+
+// secureKey returns the database key for the preimage of key, as an ephemeral
+// buffer. The caller must not hold onto the return value because it will become
+// invalid on the next call.
+func (db *Database) secureKey(key []byte) []byte {
+	buf := append(db.seckeybuf[:0], secureKeyPrefix...)
+	buf = append(buf, key...)
+	return buf
+}
+
+// Nodes retrieves the hashes of all the nodes cached within the memory database.
+// This method is extremely expensive and should only be used to validate internal
+// states in test code.
+func (db *Database) Nodes() []common.Hash {
+	db.lock.RLock()
+	defer db.lock.RUnlock()
+
+	var hashes = make([]common.Hash, 0, len(db.nodes))
+	for hash := range db.nodes {
+		if hash != (common.Hash{}) { // Special case for "root" references/nodes
+			hashes = append(hashes, hash)
+		}
+	}
+	return hashes
+}
+
+// Reference adds a new reference from a parent node to a child node.
+func (db *Database) Reference(child common.Hash, parent common.Hash) {
+	db.lock.RLock()
+	defer db.lock.RUnlock()
+
+	db.reference(child, parent)
+}
+
+// reference is the private locked version of Reference.
+func (db *Database) reference(child common.Hash, parent common.Hash) {
+	// If the node does not exist, it's a node pulled from disk, skip
+	node, ok := db.nodes[child]
+	if !ok {
+		return
+	}
+	// If the reference already exists, only duplicate for roots
+	if _, ok = db.nodes[parent].children[child]; ok && parent != (common.Hash{}) {
+		return
+	}
+	node.parents++
+	db.nodes[parent].children[child]++
+}
+
+// Dereference removes an existing reference from a parent node to a child node.
+func (db *Database) Dereference(child common.Hash, parent common.Hash) {
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	nodes, storage, start := len(db.nodes), db.nodesSize, time.Now()
+	db.dereference(child, parent)
+
+	db.gcnodes += uint64(nodes - len(db.nodes))
+	db.gcsize += storage - db.nodesSize
+	db.gctime += time.Since(start)
+
+	memcacheGCTimeTimer.Update(time.Since(start))
+	memcacheGCSizeMeter.Mark(int64(storage - db.nodesSize))
+	memcacheGCNodesMeter.Mark(int64(nodes - len(db.nodes)))
+
+	log.Debug("Dereferenced trie from memory database", "nodes", nodes-len(db.nodes), "size", storage-db.nodesSize, "time", time.Since(start),
+		"gcnodes", db.gcnodes, "gcsize", db.gcsize, "gctime", db.gctime, "livenodes", len(db.nodes), "livesize", db.nodesSize)
+}
+
+// dereference is the private locked version of Dereference.
+func (db *Database) dereference(child common.Hash, parent common.Hash) {
+	// Dereference the parent-child
+	node := db.nodes[parent]
+
+	node.children[child]--
+	if node.children[child] == 0 {
+		delete(node.children, child)
+	}
+	// If the child does not exist, it's a previously committed node.
+	node, ok := db.nodes[child]
+	if !ok {
+		return
+	}
+	// If there are no more references to the child, delete it and cascade
+	node.parents--
+	if node.parents == 0 {
+		// Remove the node from the flush-list
+		if child == db.oldest {
+			db.oldest = node.flushNext
+		} else {
+			db.nodes[node.flushPrev].flushNext = node.flushNext
+			db.nodes[node.flushNext].flushPrev = node.flushPrev
+		}
+		// Dereference all children and delete the node
+		for hash := range node.children {
+			db.dereference(hash, child)
+		}
+		delete(db.nodes, child)
+		db.nodesSize -= common.StorageSize(common.HashLength + len(node.blob))
+	}
+}
+
+// Cap iteratively flushes old but still referenced trie nodes until the total
+// memory usage goes below the given threshold.
+func (db *Database) Cap(limit common.StorageSize) error {
+	// Create a database batch to flush persistent data out. It is important that
+	// outside code doesn't see an inconsistent state (referenced data removed from
+	// memory cache during commit but not yet in persistent storage). This is ensured
+	// by only uncaching existing data when the database write finalizes.
+	db.lock.RLock()
+
+	nodes, storage, start := len(db.nodes), db.nodesSize, time.Now()
+	batch := db.diskdb.NewBatch()
+
+	// db.nodesSize only contains the useful data in the cache, but when reporting
+	// the total memory consumption, the maintenance metadata is also needed to be
+	// counted. For every useful node, we track 2 extra hashes as the flushlist.
+	size := db.nodesSize + common.StorageSize((len(db.nodes)-1)*2*common.HashLength)
+
+	// If the preimage cache got large enough, push to disk. If it's still small
+	// leave for later to deduplicate writes.
+	flushPreimages := db.preimagesSize > 4*1024*1024
+	if flushPreimages {
+		for hash, preimage := range db.preimages {
+			if err := batch.Put(db.secureKey(hash[:]), preimage); err != nil {
+				log.Error("Failed to commit preimage from trie database", "err", err)
+				db.lock.RUnlock()
+				return err
+			}
+			if batch.ValueSize() > ethdb.IdealBatchSize {
+				if err := batch.Write(); err != nil {
+					db.lock.RUnlock()
+					return err
+				}
+				batch.Reset()
+			}
+		}
+	}
+	// Keep committing nodes from the flush-list until we're below allowance
+	oldest := db.oldest
+	for size > limit && oldest != (common.Hash{}) {
+		// Fetch the oldest referenced node and push into the batch
+		node := db.nodes[oldest]
+		if err := batch.Put(oldest[:], node.blob); err != nil {
+			db.lock.RUnlock()
+			return err
+		}
+		// If we exceeded the ideal batch size, commit and reset
+		if batch.ValueSize() >= ethdb.IdealBatchSize {
+			if err := batch.Write(); err != nil {
+				log.Error("Failed to write flush list to disk", "err", err)
+				db.lock.RUnlock()
+				return err
+			}
+			batch.Reset()
+		}
+		// Iterate to the next flush item, or abort if the size cap was achieved. Size
+		// is the total size, including both the useful cached data (hash -> blob), as
+		// well as the flushlist metadata (2*hash). When flushing items from the cache,
+		// we need to reduce both.
+		size -= common.StorageSize(3*common.HashLength + len(node.blob))
+		oldest = node.flushNext
+	}
+	// Flush out any remainder data from the last batch
+	if err := batch.Write(); err != nil {
+		log.Error("Failed to write flush list to disk", "err", err)
+		db.lock.RUnlock()
+		return err
+	}
+	db.lock.RUnlock()
+
+	// Write successful, clear out the flushed data
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	if flushPreimages {
+		db.preimages = make(map[common.Hash][]byte)
+		db.preimagesSize = 0
+	}
+	for db.oldest != oldest {
+		node := db.nodes[db.oldest]
+		delete(db.nodes, db.oldest)
+		db.oldest = node.flushNext
+
+		db.nodesSize -= common.StorageSize(common.HashLength + len(node.blob))
+	}
+	if db.oldest != (common.Hash{}) {
+		db.nodes[db.oldest].flushPrev = common.Hash{}
+	}
+	db.flushnodes += uint64(nodes - len(db.nodes))
+	db.flushsize += storage - db.nodesSize
+	db.flushtime += time.Since(start)
+
+	memcacheFlushTimeTimer.Update(time.Since(start))
+	memcacheFlushSizeMeter.Mark(int64(storage - db.nodesSize))
+	memcacheFlushNodesMeter.Mark(int64(nodes - len(db.nodes)))
+
+	log.Debug("Persisted nodes from memory database", "nodes", nodes-len(db.nodes), "size", storage-db.nodesSize, "time", time.Since(start),
+		"flushnodes", db.flushnodes, "flushsize", db.flushsize, "flushtime", db.flushtime, "livenodes", len(db.nodes), "livesize", db.nodesSize)
+
+	return nil
+}
+
+// Commit iterates over all the children of a particular node, writes them out
+// to disk, forcefully tearing down all references in both directions.
+//
+// As a side effect, all pre-images accumulated up to this point are also written.
+func (db *Database) Commit(node common.Hash, report bool) error {
+	// Create a database batch to flush persistent data out. It is important that
+	// outside code doesn't see an inconsistent state (referenced data removed from
+	// memory cache during commit but not yet in persistent storage). This is ensured
+	// by only uncaching existing data when the database write finalizes.
+	db.lock.RLock()
+
+	start := time.Now()
+	batch := db.diskdb.NewBatch()
+
+	// Move all of the accumulated preimages into a write batch
+	for hash, preimage := range db.preimages {
+		if err := batch.Put(db.secureKey(hash[:]), preimage); err != nil {
+			log.Error("Failed to commit preimage from trie database", "err", err)
+			db.lock.RUnlock()
+			return err
+		}
+		if batch.ValueSize() > ethdb.IdealBatchSize {
+			if err := batch.Write(); err != nil {
+				return err
+			}
+			batch.Reset()
+		}
+	}
+	// Move the trie itself into the batch, flushing if enough data is accumulated
+	nodes, storage := len(db.nodes), db.nodesSize
+	if err := db.commit(node, batch); err != nil {
+		log.Error("Failed to commit trie from trie database", "err", err)
+		db.lock.RUnlock()
+		return err
+	}
+	// Write batch ready, unlock for readers during persistence
+	if err := batch.Write(); err != nil {
+		log.Error("Failed to write trie to disk", "err", err)
+		db.lock.RUnlock()
+		return err
+	}
+	db.lock.RUnlock()
+
+	// Write successful, clear out the flushed data
+	db.lock.Lock()
+	defer db.lock.Unlock()
+
+	db.preimages = make(map[common.Hash][]byte)
+	db.preimagesSize = 0
+
+	db.uncache(node)
+
+	memcacheCommitTimeTimer.Update(time.Since(start))
+	memcacheCommitSizeMeter.Mark(int64(storage - db.nodesSize))
+	memcacheCommitNodesMeter.Mark(int64(nodes - len(db.nodes)))
+
+	logger := log.Info
+	if !report {
+		logger = log.Debug
+	}
+	logger("Persisted trie from memory database", "nodes", nodes-len(db.nodes)+int(db.flushnodes), "size", storage-db.nodesSize+db.flushsize, "time", time.Since(start)+db.flushtime,
+		"gcnodes", db.gcnodes, "gcsize", db.gcsize, "gctime", db.gctime, "livenodes", len(db.nodes), "livesize", db.nodesSize)
+
+	// Reset the garbage collection statistics
+	db.gcnodes, db.gcsize, db.gctime = 0, 0, 0
+	db.flushnodes, db.flushsize, db.flushtime = 0, 0, 0
+
+	return nil
+}
+
+// commit is the private locked version of Commit.
+func (db *Database) commit(hash common.Hash, batch ethdb.Batch) error {
+	// If the node does not exist, it's a previously committed node
+	node, ok := db.nodes[hash]
+	if !ok {
+		return nil
+	}
+	for child := range node.children {
+		if err := db.commit(child, batch); err != nil {
+			return err
+		}
+	}
+	if err := batch.Put(hash[:], node.blob); err != nil {
+		return err
+	}
+	// If we've reached an optimal batch size, commit and start over
+	if batch.ValueSize() >= ethdb.IdealBatchSize {
+		if err := batch.Write(); err != nil {
+			return err
+		}
+		batch.Reset()
+	}
+	return nil
+}
+
+// uncache is the post-processing step of a commit operation where the already
+// persisted trie is removed from the cache. The reason behind the two-phase
+// commit is to ensure consistent data availability while moving from memory
+// to disk.
+func (db *Database) uncache(hash common.Hash) {
+	// If the node does not exist, we're done on this path
+	node, ok := db.nodes[hash]
+	if !ok {
+		return
+	}
+	// Node still exists, remove it from the flush-list
+	if hash == db.oldest {
+		db.oldest = node.flushNext
+	} else {
+		db.nodes[node.flushPrev].flushNext = node.flushNext
+		db.nodes[node.flushNext].flushPrev = node.flushPrev
+	}
+	// Uncache the node's subtries and remove the node itself too
+	for child := range node.children {
+		db.uncache(child)
+	}
+	delete(db.nodes, hash)
+	db.nodesSize -= common.StorageSize(common.HashLength + len(node.blob))
+}
+
+// Size returns the current storage size of the memory cache in front of the
+// persistent database layer.
+func (db *Database) Size() (common.StorageSize, common.StorageSize) {
+	db.lock.RLock()
+	defer db.lock.RUnlock()
+
+	// db.nodesSize only contains the useful data in the cache, but when reporting
+	// the total memory consumption, the maintenance metadata is also needed to be
+	// counted. For every useful node, we track 2 extra hashes as the flushlist.
+	var flushlistSize = common.StorageSize((len(db.nodes) - 1) * 2 * common.HashLength)
+	return db.nodesSize + flushlistSize, db.preimagesSize
+}
diff --git a/trie/encoding.go b/trie/encoding.go
index e96a786e40..5f120de638 100644
--- a/trie/encoding.go
+++ b/trie/encoding.go
@@ -53,10 +53,9 @@ func hexToCompact(hex []byte) []byte {
 
 func compactToHex(compact []byte) []byte {
 	base := keybytesToHex(compact)
-	base = base[:len(base)-1]
-	// apply terminator flag
-	if base[0] >= 2 {
-		base = append(base, 16)
+	// delete terminator flag
+	if base[0] < 2 {
+		base = base[:len(base)-1]
 	}
 	// apply odd flag
 	chop := 2 - base[0]&1
@@ -83,7 +82,7 @@ func hexToKeybytes(hex []byte) []byte {
 	if len(hex)&1 != 0 {
 		panic("can't convert hex key of odd length")
 	}
-	key := make([]byte, (len(hex)+1)/2)
+	key := make([]byte, len(hex)/2)
 	decodeNibbles(hex, key)
 	return key
 }
diff --git a/trie/hasher.go b/trie/hasher.go
index 5186d76698..47c6dd8f9d 100644
--- a/trie/hasher.go
+++ b/trie/hasher.go
@@ -17,7 +17,6 @@
 package trie
 
 import (
-	"bytes"
 	"hash"
 	"sync"
 
@@ -26,51 +25,56 @@ import (
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
-// calculator is a utility used by the hasher to calculate the hash value of the tree node.
-type calculator struct {
-	sha    hash.Hash
-	buffer *bytes.Buffer
+type hasher struct {
+	tmp        sliceBuffer
+	sha        keccakState
+	cachegen   uint16
+	cachelimit uint16
+	onleaf     LeafCallback
 }
 
-// calculatorPool is a set of temporary calculators that may be individually saved and retrieved.
-var calculatorPool = sync.Pool{
+// keccakState wraps sha3.state. In addition to the usual hash methods, it also supports
+// Read to get a variable amount of data from the hash state. Read is faster than Sum
+// because it doesn't copy the internal state, but also modifies the internal state.
+type keccakState interface {
+	hash.Hash
+	Read([]byte) (int, error)
+}
+
+type sliceBuffer []byte
+
+func (b *sliceBuffer) Write(data []byte) (n int, err error) {
+	*b = append(*b, data...)
+	return len(data), nil
+}
+
+func (b *sliceBuffer) Reset() {
+	*b = (*b)[:0]
+}
+
+// hashers live in a global db.
+var hasherPool = sync.Pool{
 	New: func() interface{} {
-		return &calculator{buffer: new(bytes.Buffer), sha: sha3.NewKeccak256()}
+		return &hasher{
+			tmp: make(sliceBuffer, 0, 550), // cap is as large as a full fullNode.
+			sha: sha3.NewKeccak256().(keccakState),
+		}
 	},
 }
 
-// hasher hasher is used to calculate the hash value of the whole tree.
-type hasher struct {
-	cachegen   uint16
-	cachelimit uint16
-	threaded   bool
-	mu         sync.Mutex
-}
-
-func newHasher(cachegen, cachelimit uint16) *hasher {
-	h := &hasher{
-		cachegen:   cachegen,
-		cachelimit: cachelimit,
-	}
+func newHasher(cachegen, cachelimit uint16, onleaf LeafCallback) *hasher {
+	h := hasherPool.Get().(*hasher)
+	h.cachegen, h.cachelimit, h.onleaf = cachegen, cachelimit, onleaf
 	return h
 }
 
-// newCalculator retrieves a cleaned calculator from calculator pool.
-func (h *hasher) newCalculator() *calculator {
-	calculator := calculatorPool.Get().(*calculator)
-	calculator.buffer.Reset()
-	calculator.sha.Reset()
-	return calculator
-}
-
-// returnCalculator returns a no longer used calculator to the pool.
-func (h *hasher) returnCalculator(calculator *calculator) {
-	calculatorPool.Put(calculator)
+func returnHasherToPool(h *hasher) {
+	hasherPool.Put(h)
 }
 
 // hash collapses a node down into a hash node, also returning a copy of the
 // original node initialized with the computed hash to replace the original one.
-func (h *hasher) hash(n node, db DatabaseWriter, force bool) (node, node, error) {
+func (h *hasher) hash(n node, db *Database, force bool) (node, node, error) {
 	// If we're not storing the node, just hashing, use available cached data
 	if hash, dirty := n.cache(); hash != nil {
 		if db == nil {
@@ -117,7 +121,7 @@ func (h *hasher) hash(n node, db DatabaseWriter, force bool) (node, node, error)
 // hashChildren replaces the children of a node with their hashes if the encoded
 // size of the child is larger than a hash, returning the collapsed node as well
 // as a replacement for the original node with the child hashes cached in.
-func (h *hasher) hashChildren(original node, db DatabaseWriter) (node, node, error) {
+func (h *hasher) hashChildren(original node, db *Database) (node, node, error) {
 	var err error
 
 	switch n := original.(type) {
@@ -142,48 +146,15 @@ func (h *hasher) hashChildren(original node, db DatabaseWriter) (node, node, err
 		// Hash the full node's children, caching the newly hashed subtrees
 		collapsed, cached := n.copy(), n.copy()
 
-		// hashChild is a helper to hash a single child, which is called either on the
-		// same thread as the caller or in a goroutine for the toplevel branching.
-		hashChild := func(index int, wg *sync.WaitGroup) {
-			if wg != nil {
-				defer wg.Done()
+		for i := 0; i < 16; i++ {
+			if n.Children[i] != nil {
+				collapsed.Children[i], cached.Children[i], err = h.hash(n.Children[i], db, false)
+				if err != nil {
+					return original, original, err
+				}
+			} else {
+				collapsed.Children[i] = valueNode(nil) // Ensure that nil children are encoded as empty strings.
 			}
-			// Ensure that nil children are encoded as empty strings.
-			if collapsed.Children[index] == nil {
-				collapsed.Children[index] = valueNode(nil)
-				return
-			}
-			// Hash all other children properly
-			var herr error
-			collapsed.Children[index], cached.Children[index], herr = h.hash(n.Children[index], db, false)
-			if herr != nil {
-				h.mu.Lock() // rarely if ever locked, no congenstion
-				err = herr
-				h.mu.Unlock()
-			}
-		}
-		// If we're not running in threaded mode yet, span a goroutine for each child
-		if !h.threaded {
-			// Disable further threading
-			h.threaded = true
-
-			// Hash all the children concurrently
-			var wg sync.WaitGroup
-			for i := 0; i < 16; i++ {
-				wg.Add(1)
-				go hashChild(i, &wg)
-			}
-			wg.Wait()
-
-			// Reenable threading for subsequent hash calls
-			h.threaded = false
-		} else {
-			for i := 0; i < 16; i++ {
-				hashChild(i, nil)
-			}
-		}
-		if err != nil {
-			return original, original, err
 		}
 		cached.Children[16] = n.Children[16]
 		if collapsed.Children[16] == nil {
@@ -197,34 +168,71 @@ func (h *hasher) hashChildren(original node, db DatabaseWriter) (node, node, err
 	}
 }
 
-func (h *hasher) store(n node, db DatabaseWriter, force bool) (node, error) {
+// store hashes the node n and if we have a storage layer specified, it writes
+// the key/value pair to it and tracks any node->child references as well as any
+// node->external trie references.
+func (h *hasher) store(n node, db *Database, force bool) (node, error) {
 	// Don't store hashes or empty nodes.
 	if _, isHash := n.(hashNode); n == nil || isHash {
 		return n, nil
 	}
-	calculator := h.newCalculator()
-	defer h.returnCalculator(calculator)
-
 	// Generate the RLP encoding of the node
-	if err := rlp.Encode(calculator.buffer, n); err != nil {
+	h.tmp.Reset()
+	if err := rlp.Encode(&h.tmp, n); err != nil {
 		panic("encode error: " + err.Error())
 	}
-	if calculator.buffer.Len() < 32 && !force {
+	if len(h.tmp) < 32 && !force {
 		return n, nil // Nodes smaller than 32 bytes are stored inside their parent
 	}
 	// Larger nodes are replaced by their hash and stored in the database.
 	hash, _ := n.cache()
 	if hash == nil {
-		calculator.sha.Write(calculator.buffer.Bytes())
-		hash = hashNode(calculator.sha.Sum(nil))
+		hash = h.makeHashNode(h.tmp)
 	}
-	if db != nil {
-		// db might be a leveldb batch, which is not safe for concurrent writes
-		h.mu.Lock()
-		err := db.Put(hash, calculator.buffer.Bytes())
-		h.mu.Unlock()
 
-		return hash, err
+	if db != nil {
+		// We are pooling the trie nodes into an intermediate memory cache
+		db.lock.Lock()
+		hash := common.BytesToHash(hash)
+		db.insert(hash, h.tmp)
+		// Track all direct parent->child node references
+		switch n := n.(type) {
+		case *shortNode:
+			if child, ok := n.Val.(hashNode); ok {
+				db.reference(common.BytesToHash(child), hash)
+			}
+		case *fullNode:
+			for i := 0; i < 16; i++ {
+				if child, ok := n.Children[i].(hashNode); ok {
+					db.reference(common.BytesToHash(child), hash)
+				}
+			}
+		}
+		db.lock.Unlock()
+
+		// Track external references from account->storage trie
+		if h.onleaf != nil {
+			switch n := n.(type) {
+			case *shortNode:
+				if child, ok := n.Val.(valueNode); ok && child != nil {
+					h.onleaf(child, hash)
+				}
+			case *fullNode:
+				for i := 0; i < 16; i++ {
+					if child, ok := n.Children[i].(valueNode); ok && child != nil {
+						h.onleaf(child, hash)
+					}
+				}
+			}
+		}
 	}
 	return hash, nil
 }
+
+func (h *hasher) makeHashNode(data []byte) hashNode {
+	n := make(hashNode, h.sha.Size())
+	h.sha.Reset()
+	h.sha.Write(data)
+	h.sha.Read(n)
+	return n
+}
diff --git a/trie/iterator.go b/trie/iterator.go
index 76146c0d64..00b890eb89 100644
--- a/trie/iterator.go
+++ b/trie/iterator.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rlp"
 )
 
 // Iterator is a key-value trie iterator that traverses a Trie.
@@ -55,31 +56,50 @@ func (it *Iterator) Next() bool {
 	return false
 }
 
+// Prove generates the Merkle proof for the leaf node the iterator is currently
+// positioned on.
+func (it *Iterator) Prove() [][]byte {
+	return it.nodeIt.LeafProof()
+}
+
 // NodeIterator is an iterator to traverse the trie pre-order.
 type NodeIterator interface {
 	// Next moves the iterator to the next node. If the parameter is false, any child
 	// nodes will be skipped.
 	Next(bool) bool
+
 	// Error returns the error status of the iterator.
 	Error() error
 
 	// Hash returns the hash of the current node.
 	Hash() common.Hash
+
 	// Parent returns the hash of the parent of the current node. The hash may be the one
 	// grandparent if the immediate parent is an internal node with no hash.
 	Parent() common.Hash
+
 	// Path returns the hex-encoded path to the current node.
 	// Callers must not retain references to the return value after calling Next.
 	// For leaf nodes, the last element of the path is the 'terminator symbol' 0x10.
 	Path() []byte
 
 	// Leaf returns true iff the current node is a leaf node.
-	// LeafBlob, LeafKey return the contents and key of the leaf node. These
-	// method panic if the iterator is not positioned at a leaf.
-	// Callers must not retain references to their return value after calling Next
 	Leaf() bool
-	LeafBlob() []byte
+
+	// LeafKey returns the key of the leaf. The method panics if the iterator is not
+	// positioned at a leaf. Callers must not retain references to the value after
+	// calling Next.
 	LeafKey() []byte
+
+	// LeafBlob returns the content of the leaf. The method panics if the iterator
+	// is not positioned at a leaf. Callers must not retain references to the value
+	// after calling Next.
+	LeafBlob() []byte
+
+	// LeafProof returns the Merkle proof of the leaf. The method panics if the
+	// iterator is not positioned at a leaf. Callers must not retain references
+	// to the value after calling Next.
+	LeafProof() [][]byte
 }
 
 // nodeIteratorState represents the iteration state at one particular node of the
@@ -99,8 +119,8 @@ type nodeIterator struct {
 	err   error                // Failure set in case of an internal error in the iterator
 }
 
-// iteratorEnd is stored in nodeIterator.err when iteration is done.
-var iteratorEnd = errors.New("end of iteration")
+// errIteratorEnd is stored in nodeIterator.err when iteration is done.
+var errIteratorEnd = errors.New("end of iteration")
 
 // seekError is stored in nodeIterator.err if the initial seek has failed.
 type seekError struct {
@@ -139,6 +159,15 @@ func (it *nodeIterator) Leaf() bool {
 	return hasTerm(it.path)
 }
 
+func (it *nodeIterator) LeafKey() []byte {
+	if len(it.stack) > 0 {
+		if _, ok := it.stack[len(it.stack)-1].node.(valueNode); ok {
+			return hexToKeybytes(it.path)
+		}
+	}
+	panic("not at leaf")
+}
+
 func (it *nodeIterator) LeafBlob() []byte {
 	if len(it.stack) > 0 {
 		if node, ok := it.stack[len(it.stack)-1].node.(valueNode); ok {
@@ -148,10 +177,22 @@ func (it *nodeIterator) LeafBlob() []byte {
 	panic("not at leaf")
 }
 
-func (it *nodeIterator) LeafKey() []byte {
+func (it *nodeIterator) LeafProof() [][]byte {
 	if len(it.stack) > 0 {
 		if _, ok := it.stack[len(it.stack)-1].node.(valueNode); ok {
-			return hexToKeybytes(it.path)
+			hasher := newHasher(0, 0, nil)
+			proofs := make([][]byte, 0, len(it.stack))
+
+			for i, item := range it.stack[:len(it.stack)-1] {
+				// Gather nodes that end up as hash nodes (or the root)
+				node, _, _ := hasher.hashChildren(item.node, nil)
+				hashed, _ := hasher.store(node, nil, false)
+				if _, ok := hashed.(hashNode); ok || i == 0 {
+					enc, _ := rlp.EncodeToBytes(node)
+					proofs = append(proofs, enc)
+				}
+			}
+			return proofs
 		}
 	}
 	panic("not at leaf")
@@ -162,7 +203,7 @@ func (it *nodeIterator) Path() []byte {
 }
 
 func (it *nodeIterator) Error() error {
-	if it.err == iteratorEnd {
+	if it.err == errIteratorEnd {
 		return nil
 	}
 	if seek, ok := it.err.(seekError); ok {
@@ -176,7 +217,7 @@ func (it *nodeIterator) Error() error {
 // sets the Error field to the encountered failure. If `descend` is false,
 // skips iterating over any subnodes of the current node.
 func (it *nodeIterator) Next(descend bool) bool {
-	if it.err == iteratorEnd {
+	if it.err == errIteratorEnd {
 		return false
 	}
 	if seek, ok := it.err.(seekError); ok {
@@ -201,8 +242,8 @@ func (it *nodeIterator) seek(prefix []byte) error {
 	// Move forward until we're just before the closest match to key.
 	for {
 		state, parentIndex, path, err := it.peek(bytes.HasPrefix(key, it.path))
-		if err == iteratorEnd {
-			return iteratorEnd
+		if err == errIteratorEnd {
+			return errIteratorEnd
 		} else if err != nil {
 			return seekError{prefix, err}
 		} else if bytes.Compare(path, key) >= 0 {
@@ -246,7 +287,7 @@ func (it *nodeIterator) peek(descend bool) (*nodeIteratorState, *int, []byte, er
 		// No more child nodes, move back up.
 		it.pop()
 	}
-	return nil, nil, nil, iteratorEnd
+	return nil, nil, nil, errIteratorEnd
 }
 
 func (st *nodeIteratorState) resolve(tr *Trie, path []byte) error {
@@ -303,7 +344,7 @@ func (it *nodeIterator) push(state *nodeIteratorState, parentIndex *int, path []
 	it.path = path
 	it.stack = append(it.stack, state)
 	if parentIndex != nil {
-		*parentIndex += 1
+		*parentIndex++
 	}
 }
 
@@ -361,12 +402,16 @@ func (it *differenceIterator) Leaf() bool {
 	return it.b.Leaf()
 }
 
+func (it *differenceIterator) LeafKey() []byte {
+	return it.b.LeafKey()
+}
+
 func (it *differenceIterator) LeafBlob() []byte {
 	return it.b.LeafBlob()
 }
 
-func (it *differenceIterator) LeafKey() []byte {
-	return it.b.LeafKey()
+func (it *differenceIterator) LeafProof() [][]byte {
+	return it.b.LeafProof()
 }
 
 func (it *differenceIterator) Path() []byte {
@@ -380,7 +425,7 @@ func (it *differenceIterator) Next(bool) bool {
 	if !it.b.Next(true) {
 		return false
 	}
-	it.count += 1
+	it.count++
 
 	if it.eof {
 		// a has reached eof, so we just return all elements from b
@@ -395,7 +440,7 @@ func (it *differenceIterator) Next(bool) bool {
 				it.eof = true
 				return true
 			}
-			it.count += 1
+			it.count++
 		case 1:
 			// b is before a
 			return true
@@ -405,12 +450,12 @@ func (it *differenceIterator) Next(bool) bool {
 			if !it.b.Next(hasHash) {
 				return false
 			}
-			it.count += 1
+			it.count++
 			if !it.a.Next(hasHash) {
 				it.eof = true
 				return true
 			}
-			it.count += 1
+			it.count++
 		}
 	}
 }
@@ -464,12 +509,16 @@ func (it *unionIterator) Leaf() bool {
 	return (*it.items)[0].Leaf()
 }
 
+func (it *unionIterator) LeafKey() []byte {
+	return (*it.items)[0].LeafKey()
+}
+
 func (it *unionIterator) LeafBlob() []byte {
 	return (*it.items)[0].LeafBlob()
 }
 
-func (it *unionIterator) LeafKey() []byte {
-	return (*it.items)[0].LeafKey()
+func (it *unionIterator) LeafProof() [][]byte {
+	return (*it.items)[0].LeafProof()
 }
 
 func (it *unionIterator) Path() []byte {
@@ -504,17 +553,15 @@ func (it *unionIterator) Next(descend bool) bool {
 		skipped := heap.Pop(it.items).(NodeIterator)
 		// Skip the whole subtree if the nodes have hashes; otherwise just skip this node
 		if skipped.Next(skipped.Hash() == common.Hash{}) {
-			it.count += 1
+			it.count++
 			// If there are more elements, push the iterator back on the heap
 			heap.Push(it.items, skipped)
 		}
 	}
-
 	if least.Next(descend) {
-		it.count += 1
+		it.count++
 		heap.Push(it.items, least)
 	}
-
 	return len(*it.items) > 0
 }
 
diff --git a/trie/iterator_test.go b/trie/iterator_test.go
index 4808d8b0c6..2a510b1c2d 100644
--- a/trie/iterator_test.go
+++ b/trie/iterator_test.go
@@ -42,7 +42,7 @@ func TestIterator(t *testing.T) {
 		all[val.k] = val.v
 		trie.Update([]byte(val.k), []byte(val.v))
 	}
-	trie.Commit()
+	trie.Commit(nil)
 
 	found := make(map[string]string)
 	it := NewIterator(trie.NodeIterator(nil))
@@ -109,11 +109,18 @@ func TestNodeIteratorCoverage(t *testing.T) {
 	}
 	// Cross check the hashes and the database itself
 	for hash := range hashes {
-		if _, err := db.Get(hash.Bytes()); err != nil {
+		if _, err := db.Node(hash); err != nil {
 			t.Errorf("failed to retrieve reported node %x: %v", hash, err)
 		}
 	}
-	for _, key := range db.(*ethdb.MemDatabase).Keys() {
+	for hash, obj := range db.nodes {
+		if obj != nil && hash != (common.Hash{}) {
+			if _, ok := hashes[hash]; !ok {
+				t.Errorf("state entry not reported %x", hash)
+			}
+		}
+	}
+	for _, key := range db.diskdb.(*ethdb.MemDatabase).Keys() {
 		if _, ok := hashes[common.BytesToHash(key)]; !ok {
 			t.Errorf("state entry not reported %x", key)
 		}
@@ -191,13 +198,13 @@ func TestDifferenceIterator(t *testing.T) {
 	for _, val := range testdata1 {
 		triea.Update([]byte(val.k), []byte(val.v))
 	}
-	triea.Commit()
+	triea.Commit(nil)
 
 	trieb := newEmpty()
 	for _, val := range testdata2 {
 		trieb.Update([]byte(val.k), []byte(val.v))
 	}
-	trieb.Commit()
+	trieb.Commit(nil)
 
 	found := make(map[string]string)
 	di, _ := NewDifferenceIterator(triea.NodeIterator(nil), trieb.NodeIterator(nil))
@@ -227,13 +234,13 @@ func TestUnionIterator(t *testing.T) {
 	for _, val := range testdata1 {
 		triea.Update([]byte(val.k), []byte(val.v))
 	}
-	triea.Commit()
+	triea.Commit(nil)
 
 	trieb := newEmpty()
 	for _, val := range testdata2 {
 		trieb.Update([]byte(val.k), []byte(val.v))
 	}
-	trieb.Commit()
+	trieb.Commit(nil)
 
 	di, _ := NewUnionIterator([]NodeIterator{triea.NodeIterator(nil), trieb.NodeIterator(nil)})
 	it := NewIterator(di)
@@ -278,43 +285,75 @@ func TestIteratorNoDups(t *testing.T) {
 }
 
 // This test checks that nodeIterator.Next can be retried after inserting missing trie nodes.
-func TestIteratorContinueAfterError(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	tr, _ := New(common.Hash{}, db)
+func TestIteratorContinueAfterErrorDisk(t *testing.T)    { testIteratorContinueAfterError(t, false) }
+func TestIteratorContinueAfterErrorMemonly(t *testing.T) { testIteratorContinueAfterError(t, true) }
+
+func testIteratorContinueAfterError(t *testing.T, memonly bool) {
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+
+	tr, _ := New(common.Hash{}, triedb)
 	for _, val := range testdata1 {
 		tr.Update([]byte(val.k), []byte(val.v))
 	}
-	tr.Commit()
+	tr.Commit(nil)
+	if !memonly {
+		triedb.Commit(tr.Hash(), true)
+	}
 	wantNodeCount := checkIteratorNoDups(t, tr.NodeIterator(nil), nil)
-	keys := db.Keys()
-	t.Log("node count", wantNodeCount)
 
+	var (
+		diskKeys [][]byte
+		memKeys  []common.Hash
+	)
+	if memonly {
+		memKeys = triedb.Nodes()
+	} else {
+		diskKeys = diskdb.Keys()
+	}
 	for i := 0; i < 20; i++ {
 		// Create trie that will load all nodes from DB.
-		tr, _ := New(tr.Hash(), db)
+		tr, _ := New(tr.Hash(), triedb)
 
 		// Remove a random node from the database. It can't be the root node
 		// because that one is already loaded.
-		var rkey []byte
+		var (
+			rkey common.Hash
+			rval []byte
+			robj *cachedNode
+		)
 		for {
-			if rkey = keys[rand.Intn(len(keys))]; !bytes.Equal(rkey, tr.Hash().Bytes()) {
+			if memonly {
+				rkey = memKeys[rand.Intn(len(memKeys))]
+			} else {
+				copy(rkey[:], diskKeys[rand.Intn(len(diskKeys))])
+			}
+			if rkey != tr.Hash() {
 				break
 			}
 		}
-		rval, _ := db.Get(rkey)
-		db.Delete(rkey)
-
+		if memonly {
+			robj = triedb.nodes[rkey]
+			delete(triedb.nodes, rkey)
+		} else {
+			rval, _ = diskdb.Get(rkey[:])
+			diskdb.Delete(rkey[:])
+		}
 		// Iterate until the error is hit.
 		seen := make(map[string]bool)
 		it := tr.NodeIterator(nil)
 		checkIteratorNoDups(t, it, seen)
 		missing, ok := it.Error().(*MissingNodeError)
-		if !ok || !bytes.Equal(missing.NodeHash[:], rkey) {
+		if !ok || missing.NodeHash != rkey {
 			t.Fatal("didn't hit missing node, got", it.Error())
 		}
 
 		// Add the node back and continue iteration.
-		db.Put(rkey, rval)
+		if memonly {
+			triedb.nodes[rkey] = robj
+		} else {
+			diskdb.Put(rkey[:], rval)
+		}
 		checkIteratorNoDups(t, it, seen)
 		if it.Error() != nil {
 			t.Fatal("unexpected error", it.Error())
@@ -328,21 +367,41 @@ func TestIteratorContinueAfterError(t *testing.T) {
 // Similar to the test above, this one checks that failure to create nodeIterator at a
 // certain key prefix behaves correctly when Next is called. The expectation is that Next
 // should retry seeking before returning true for the first time.
-func TestIteratorContinueAfterSeekError(t *testing.T) {
+func TestIteratorContinueAfterSeekErrorDisk(t *testing.T) {
+	testIteratorContinueAfterSeekError(t, false)
+}
+func TestIteratorContinueAfterSeekErrorMemonly(t *testing.T) {
+	testIteratorContinueAfterSeekError(t, true)
+}
+
+func testIteratorContinueAfterSeekError(t *testing.T, memonly bool) {
 	// Commit test trie to db, then remove the node containing "bars".
-	db, _ := ethdb.NewMemDatabase()
-	ctr, _ := New(common.Hash{}, db)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+
+	ctr, _ := New(common.Hash{}, triedb)
 	for _, val := range testdata1 {
 		ctr.Update([]byte(val.k), []byte(val.v))
 	}
-	root, _ := ctr.Commit()
+	root, _ := ctr.Commit(nil)
+	if !memonly {
+		triedb.Commit(root, true)
+	}
 	barNodeHash := common.HexToHash("05041990364eb72fcb1127652ce40d8bab765f2bfe53225b1170d276cc101c2e")
-	barNode, _ := db.Get(barNodeHash[:])
-	db.Delete(barNodeHash[:])
-
+	var (
+		barNodeBlob []byte
+		barNodeObj  *cachedNode
+	)
+	if memonly {
+		barNodeObj = triedb.nodes[barNodeHash]
+		delete(triedb.nodes, barNodeHash)
+	} else {
+		barNodeBlob, _ = diskdb.Get(barNodeHash[:])
+		diskdb.Delete(barNodeHash[:])
+	}
 	// Create a new iterator that seeks to "bars". Seeking can't proceed because
 	// the node is missing.
-	tr, _ := New(root, db)
+	tr, _ := New(root, triedb)
 	it := tr.NodeIterator([]byte("bars"))
 	missing, ok := it.Error().(*MissingNodeError)
 	if !ok {
@@ -350,10 +409,12 @@ func TestIteratorContinueAfterSeekError(t *testing.T) {
 	} else if missing.NodeHash != barNodeHash {
 		t.Fatal("wrong node missing")
 	}
-
 	// Reinsert the missing node.
-	db.Put(barNodeHash[:], barNode[:])
-
+	if memonly {
+		triedb.nodes[barNodeHash] = barNodeObj
+	} else {
+		diskdb.Put(barNodeHash[:], barNodeBlob)
+	}
 	// Check that iteration produces the right set of values.
 	if err := checkIteratorOrder(testdata1[2:], NewIterator(it)); err != nil {
 		t.Fatal(err)
diff --git a/trie/node.go b/trie/node.go
index a7697fc0c6..02815042c6 100644
--- a/trie/node.go
+++ b/trie/node.go
@@ -123,17 +123,17 @@ func decodeNode(hash, buf []byte, cachegen uint16) (node, error) {
 	}
 	switch c, _ := rlp.CountValues(elems); c {
 	case 2:
-		n, err := decodeShort(hash, buf, elems, cachegen)
+		n, err := decodeShort(hash, elems, cachegen)
 		return n, wrapError(err, "short")
 	case 17:
-		n, err := decodeFull(hash, buf, elems, cachegen)
+		n, err := decodeFull(hash, elems, cachegen)
 		return n, wrapError(err, "full")
 	default:
 		return nil, fmt.Errorf("invalid number of list elements: %v", c)
 	}
 }
 
-func decodeShort(hash, buf, elems []byte, cachegen uint16) (node, error) {
+func decodeShort(hash, elems []byte, cachegen uint16) (node, error) {
 	kbuf, rest, err := rlp.SplitString(elems)
 	if err != nil {
 		return nil, err
@@ -155,7 +155,7 @@ func decodeShort(hash, buf, elems []byte, cachegen uint16) (node, error) {
 	return &shortNode{key, r, flag}, nil
 }
 
-func decodeFull(hash, buf, elems []byte, cachegen uint16) (*fullNode, error) {
+func decodeFull(hash, elems []byte, cachegen uint16) (*fullNode, error) {
 	n := &fullNode{flags: nodeFlag{hash: hash, gen: cachegen}}
 	for i := 0; i < 16; i++ {
 		cld, rest, err := decodeRef(elems, cachegen)
diff --git a/trie/proof.go b/trie/proof.go
index 5e886a2598..6cb8f4d5f7 100644
--- a/trie/proof.go
+++ b/trie/proof.go
@@ -22,20 +22,19 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
 )
 
-// Prove constructs a merkle proof for key. The result contains all
-// encoded nodes on the path to the value at key. The value itself is
-// also included in the last node and can be retrieved by verifying
-// the proof.
+// Prove constructs a merkle proof for key. The result contains all encoded nodes
+// on the path to the value at key. The value itself is also included in the last
+// node and can be retrieved by verifying the proof.
 //
-// If the trie does not contain a value for key, the returned proof
-// contains all nodes of the longest existing prefix of the key
-// (at least the root node), ending with the node that proves the
-// absence of the key.
-func (t *Trie) Prove(key []byte, fromLevel uint, proofDb DatabaseWriter) error {
+// If the trie does not contain a value for key, the returned proof contains all
+// nodes of the longest existing prefix of the key (at least the root node), ending
+// with the node that proves the absence of the key.
+func (t *Trie) Prove(key []byte, fromLevel uint, proofDb ethdb.Putter) error {
 	// Collect all nodes on the path to key.
 	key = keybytesToHex(key)
 	nodes := []node{}
@@ -66,7 +65,7 @@ func (t *Trie) Prove(key []byte, fromLevel uint, proofDb DatabaseWriter) error {
 			panic(fmt.Sprintf("%T: invalid node: %v", tn, tn))
 		}
 	}
-	hasher := newHasher(0, 0)
+	hasher := newHasher(0, 0, nil)
 	for i, n := range nodes {
 		// Don't bother checking for errors here since hasher panics
 		// if encoding doesn't work and we're not writing to any database.
@@ -89,32 +88,42 @@ func (t *Trie) Prove(key []byte, fromLevel uint, proofDb DatabaseWriter) error {
 	return nil
 }
 
-// VerifyProof checks merkle proofs. The given proof must contain the
-// value for key in a trie with the given root hash. VerifyProof
-// returns an error if the proof contains invalid trie nodes or the
-// wrong value.
-func VerifyProof(rootHash common.Hash, key []byte, proofDb DatabaseReader) (value []byte, err error, nodes int) {
+// Prove constructs a merkle proof for key. The result contains all encoded nodes
+// on the path to the value at key. The value itself is also included in the last
+// node and can be retrieved by verifying the proof.
+//
+// If the trie does not contain a value for key, the returned proof contains all
+// nodes of the longest existing prefix of the key (at least the root node), ending
+// with the node that proves the absence of the key.
+func (t *SecureTrie) Prove(key []byte, fromLevel uint, proofDb ethdb.Putter) error {
+	return t.trie.Prove(key, fromLevel, proofDb)
+}
+
+// VerifyProof checks merkle proofs. The given proof must contain the value for
+// key in a trie with the given root hash. VerifyProof returns an error if the
+// proof contains invalid trie nodes or the wrong value.
+func VerifyProof(rootHash common.Hash, key []byte, proofDb DatabaseReader) (value []byte, nodes int, err error) {
 	key = keybytesToHex(key)
-	wantHash := rootHash[:]
+	wantHash := rootHash
 	for i := 0; ; i++ {
-		buf, _ := proofDb.Get(wantHash)
+		buf, _ := proofDb.Get(wantHash[:])
 		if buf == nil {
-			return nil, fmt.Errorf("proof node %d (hash %064x) missing", i, wantHash[:]), i
+			return nil, i, fmt.Errorf("proof node %d (hash %064x) missing", i, wantHash)
 		}
-		n, err := decodeNode(wantHash, buf, 0)
+		n, err := decodeNode(wantHash[:], buf, 0)
 		if err != nil {
-			return nil, fmt.Errorf("bad proof node %d: %v", i, err), i
+			return nil, i, fmt.Errorf("bad proof node %d: %v", i, err)
 		}
 		keyrest, cld := get(n, key)
 		switch cld := cld.(type) {
 		case nil:
 			// The trie doesn't contain the key.
-			return nil, nil, i
+			return nil, i, nil
 		case hashNode:
 			key = keyrest
-			wantHash = cld
+			copy(wantHash[:], cld)
 		case valueNode:
-			return cld, nil, i + 1
+			return cld, i + 1, nil
 		}
 	}
 }
diff --git a/trie/proof_test.go b/trie/proof_test.go
index fff313d7fd..996f874781 100644
--- a/trie/proof_test.go
+++ b/trie/proof_test.go
@@ -32,20 +32,46 @@ func init() {
 	mrand.Seed(time.Now().Unix())
 }
 
+// makeProvers creates Merkle trie provers based on different implementations to
+// test all variations.
+func makeProvers(trie *Trie) []func(key []byte) *ethdb.MemDatabase {
+	var provers []func(key []byte) *ethdb.MemDatabase
+
+	// Create a direct trie based Merkle prover
+	provers = append(provers, func(key []byte) *ethdb.MemDatabase {
+		proof := ethdb.NewMemDatabase()
+		trie.Prove(key, 0, proof)
+		return proof
+	})
+	// Create a leaf iterator based Merkle prover
+	provers = append(provers, func(key []byte) *ethdb.MemDatabase {
+		proof := ethdb.NewMemDatabase()
+		if it := NewIterator(trie.NodeIterator(key)); it.Next() && bytes.Equal(key, it.Key) {
+			for _, p := range it.Prove() {
+				proof.Put(crypto.Keccak256(p), p)
+			}
+		}
+		return proof
+	})
+	return provers
+}
+
 func TestProof(t *testing.T) {
 	trie, vals := randomTrie(500)
 	root := trie.Hash()
-	for _, kv := range vals {
-		proofs, _ := ethdb.NewMemDatabase()
-		if trie.Prove(kv.k, 0, proofs) != nil {
-			t.Fatalf("missing key %x while constructing proof", kv.k)
-		}
-		val, err, _ := VerifyProof(root, kv.k, proofs)
-		if err != nil {
-			t.Fatalf("VerifyProof error for key %x: %v\nraw proof: %v", kv.k, err, proofs)
-		}
-		if !bytes.Equal(val, kv.v) {
-			t.Fatalf("VerifyProof returned wrong value for key %x: got %x, want %x", kv.k, val, kv.v)
+	for i, prover := range makeProvers(trie) {
+		for _, kv := range vals {
+			proof := prover(kv.k)
+			if proof == nil {
+				t.Fatalf("prover %d: missing key %x while constructing proof", i, kv.k)
+			}
+			val, _, err := VerifyProof(root, kv.k, proof)
+			if err != nil {
+				t.Fatalf("prover %d: failed to verify proof for key %x: %v\nraw proof: %x", i, kv.k, err, proof)
+			}
+			if !bytes.Equal(val, kv.v) {
+				t.Fatalf("prover %d: verified value mismatch for key %x: have %x, want %x", i, kv.k, val, kv.v)
+			}
 		}
 	}
 }
@@ -53,37 +79,66 @@ func TestProof(t *testing.T) {
 func TestOneElementProof(t *testing.T) {
 	trie := new(Trie)
 	updateString(trie, "k", "v")
-	proofs, _ := ethdb.NewMemDatabase()
-	trie.Prove([]byte("k"), 0, proofs)
-	if len(proofs.Keys()) != 1 {
-		t.Error("proof should have one element")
-	}
-	val, err, _ := VerifyProof(trie.Hash(), []byte("k"), proofs)
-	if err != nil {
-		t.Fatalf("VerifyProof error: %v\nproof hashes: %v", err, proofs.Keys())
-	}
-	if !bytes.Equal(val, []byte("v")) {
-		t.Fatalf("VerifyProof returned wrong value: got %x, want 'k'", val)
+	for i, prover := range makeProvers(trie) {
+		proof := prover([]byte("k"))
+		if proof == nil {
+			t.Fatalf("prover %d: nil proof", i)
+		}
+		if proof.Len() != 1 {
+			t.Errorf("prover %d: proof should have one element", i)
+		}
+		val, _, err := VerifyProof(trie.Hash(), []byte("k"), proof)
+		if err != nil {
+			t.Fatalf("prover %d: failed to verify proof: %v\nraw proof: %x", i, err, proof)
+		}
+		if !bytes.Equal(val, []byte("v")) {
+			t.Fatalf("prover %d: verified value mismatch: have %x, want 'k'", i, val)
+		}
 	}
 }
 
-func TestVerifyBadProof(t *testing.T) {
+func TestBadProof(t *testing.T) {
 	trie, vals := randomTrie(800)
 	root := trie.Hash()
-	for _, kv := range vals {
-		proofs, _ := ethdb.NewMemDatabase()
-		trie.Prove(kv.k, 0, proofs)
-		if len(proofs.Keys()) == 0 {
-			t.Fatal("zero length proof")
+	for i, prover := range makeProvers(trie) {
+		for _, kv := range vals {
+			proof := prover(kv.k)
+			if proof == nil {
+				t.Fatalf("prover %d: nil proof", i)
+			}
+			key := proof.Keys()[mrand.Intn(proof.Len())]
+			val, _ := proof.Get(key)
+			proof.Delete(key)
+
+			mutateByte(val)
+			proof.Put(crypto.Keccak256(val), val)
+
+			if _, _, err := VerifyProof(root, kv.k, proof); err == nil {
+				t.Fatalf("prover %d: expected proof to fail for key %x", i, kv.k)
+			}
 		}
-		keys := proofs.Keys()
-		key := keys[mrand.Intn(len(keys))]
-		node, _ := proofs.Get(key)
-		proofs.Delete(key)
-		mutateByte(node)
-		proofs.Put(crypto.Keccak256(node), node)
-		if _, err, _ := VerifyProof(root, kv.k, proofs); err == nil {
-			t.Fatalf("expected proof to fail for key %x", kv.k)
+	}
+}
+
+// Tests that missing keys can also be proven. The test explicitly uses a single
+// entry trie and checks for missing keys both before and after the single entry.
+func TestMissingKeyProof(t *testing.T) {
+	trie := new(Trie)
+	updateString(trie, "k", "v")
+
+	for i, key := range []string{"a", "j", "l", "z"} {
+		proof := ethdb.NewMemDatabase()
+		trie.Prove([]byte(key), 0, proof)
+
+		if proof.Len() != 1 {
+			t.Errorf("test %d: proof should have one element", i)
+		}
+		val, _, err := VerifyProof(trie.Hash(), []byte(key), proof)
+		if err != nil {
+			t.Fatalf("test %d: failed to verify proof: %v\nraw proof: %x", i, err, proof)
+		}
+		if val != nil {
+			t.Fatalf("test %d: verified value mismatch: have %x, want nil", i, val)
 		}
 	}
 }
@@ -109,7 +164,7 @@ func BenchmarkProve(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		kv := vals[keys[i%len(keys)]]
-		proofs, _ := ethdb.NewMemDatabase()
+		proofs := ethdb.NewMemDatabase()
 		if trie.Prove(kv.k, 0, proofs); len(proofs.Keys()) == 0 {
 			b.Fatalf("zero length proof for %x", kv.k)
 		}
@@ -123,7 +178,7 @@ func BenchmarkVerifyProof(b *testing.B) {
 	var proofs []*ethdb.MemDatabase
 	for k := range vals {
 		keys = append(keys, k)
-		proof, _ := ethdb.NewMemDatabase()
+		proof := ethdb.NewMemDatabase()
 		trie.Prove([]byte(k), 0, proof)
 		proofs = append(proofs, proof)
 	}
@@ -131,7 +186,7 @@ func BenchmarkVerifyProof(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		im := i % len(keys)
-		if _, err, _ := VerifyProof(root, []byte(keys[im]), proofs[im]); err != nil {
+		if _, _, err := VerifyProof(root, []byte(keys[im]), proofs[im]); err != nil {
 			b.Fatalf("key %x: %v", keys[im], err)
 		}
 	}
diff --git a/trie/secure_trie.go b/trie/secure_trie.go
index 1fde45165e..6a50cfd5a6 100644
--- a/trie/secure_trie.go
+++ b/trie/secure_trie.go
@@ -23,10 +23,6 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
-var secureKeyPrefix = []byte("secure-key-")
-
-const secureKeyLength = 11 + 32 // Length of the above prefix + 32byte hash
-
 // SecureTrie wraps a trie with key hashing. In a secure trie, all
 // access operations hash the key using keccak256. This prevents
 // calling code from creating long chains of nodes that
@@ -39,25 +35,25 @@ const secureKeyLength = 11 + 32 // Length of the above prefix + 32byte hash
 // SecureTrie is not safe for concurrent use.
 type SecureTrie struct {
 	trie             Trie
-	hashKeyBuf       [secureKeyLength]byte
-	secKeyBuf        [200]byte
+	hashKeyBuf       [common.HashLength]byte
 	secKeyCache      map[string][]byte
 	secKeyCacheOwner *SecureTrie // Pointer to self, replace the key cache on mismatch
 }
 
-// NewSecure creates a trie with an existing root node from db.
+// NewSecure creates a trie with an existing root node from a backing database
+// and optional intermediate in-memory node pool.
 //
 // If root is the zero hash or the sha3 hash of an empty string, the
 // trie is initially empty. Otherwise, New will panic if db is nil
 // and returns MissingNodeError if the root node cannot be found.
 //
-// Accessing the trie loads nodes from db on demand.
+// Accessing the trie loads nodes from the database or node pool on demand.
 // Loaded nodes are kept around until their 'cache generation' expires.
 // A new cache generation is created by each call to Commit.
 // cachelimit sets the number of past cache generations to keep.
-func NewSecure(root common.Hash, db Database, cachelimit uint16) (*SecureTrie, error) {
+func NewSecure(root common.Hash, db *Database, cachelimit uint16) (*SecureTrie, error) {
 	if db == nil {
-		panic("NewSecure called with nil database")
+		panic("trie.NewSecure called without a database")
 	}
 	trie, err := New(root, db)
 	if err != nil {
@@ -135,7 +131,7 @@ func (t *SecureTrie) GetKey(shaKey []byte) []byte {
 	if key, ok := t.getSecKeyCache()[string(shaKey)]; ok {
 		return key
 	}
-	key, _ := t.trie.db.Get(t.secKey(shaKey))
+	key, _ := t.trie.db.preimage(common.BytesToHash(shaKey))
 	return key
 }
 
@@ -144,18 +140,34 @@ func (t *SecureTrie) GetKey(shaKey []byte) []byte {
 //
 // Committing flushes nodes from memory. Subsequent Get calls will load nodes
 // from the database.
-func (t *SecureTrie) Commit() (root common.Hash, err error) {
-	return t.CommitTo(t.trie.db)
+func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
+	// Write all the pre-images to the actual disk database
+	if len(t.getSecKeyCache()) > 0 {
+		t.trie.db.lock.Lock()
+		for hk, key := range t.secKeyCache {
+			t.trie.db.insertPreimage(common.BytesToHash([]byte(hk)), key)
+		}
+		t.trie.db.lock.Unlock()
+
+		t.secKeyCache = make(map[string][]byte)
+	}
+	// Commit the trie to its intermediate node database
+	return t.trie.Commit(onleaf)
 }
 
+// Hash returns the root hash of SecureTrie. It does not write to the
+// database and can be used even if the trie doesn't have one.
 func (t *SecureTrie) Hash() common.Hash {
 	return t.trie.Hash()
 }
 
+// Root returns the root hash of SecureTrie.
+// Deprecated: use Hash instead.
 func (t *SecureTrie) Root() []byte {
 	return t.trie.Root()
 }
 
+// Copy returns a copy of SecureTrie.
 func (t *SecureTrie) Copy() *SecureTrie {
 	cpy := *t
 	return &cpy
@@ -167,42 +179,15 @@ func (t *SecureTrie) NodeIterator(start []byte) NodeIterator {
 	return t.trie.NodeIterator(start)
 }
 
-// CommitTo writes all nodes and the secure hash pre-images to the given database.
-// Nodes are stored with their sha3 hash as the key.
-//
-// Committing flushes nodes from memory. Subsequent Get calls will load nodes from
-// the trie's database. Calling code must ensure that the changes made to db are
-// written back to the trie's attached database before using the trie.
-func (t *SecureTrie) CommitTo(db DatabaseWriter) (root common.Hash, err error) {
-	if len(t.getSecKeyCache()) > 0 {
-		for hk, key := range t.secKeyCache {
-			if err := db.Put(t.secKey([]byte(hk)), key); err != nil {
-				return common.Hash{}, err
-			}
-		}
-		t.secKeyCache = make(map[string][]byte)
-	}
-	return t.trie.CommitTo(db)
-}
-
-// secKey returns the database key for the preimage of key, as an ephemeral buffer.
-// The caller must not hold onto the return value because it will become
-// invalid on the next call to hashKey or secKey.
-func (t *SecureTrie) secKey(key []byte) []byte {
-	buf := append(t.secKeyBuf[:0], secureKeyPrefix...)
-	buf = append(buf, key...)
-	return buf
-}
-
 // hashKey returns the hash of key as an ephemeral buffer.
 // The caller must not hold onto the return value because it will become
 // invalid on the next call to hashKey or secKey.
 func (t *SecureTrie) hashKey(key []byte) []byte {
-	h := newHasher(0, 0)
-	calculator := h.newCalculator()
-	calculator.sha.Write(key)
-	buf := calculator.sha.Sum(t.hashKeyBuf[:0])
-	h.returnCalculator(calculator)
+	h := newHasher(0, 0, nil)
+	h.sha.Reset()
+	h.sha.Write(key)
+	buf := h.sha.Sum(t.hashKeyBuf[:0])
+	returnHasherToPool(h)
 	return buf
 }
 
diff --git a/trie/secure_trie_test.go b/trie/secure_trie_test.go
index d74102e2a2..d16d999684 100644
--- a/trie/secure_trie_test.go
+++ b/trie/secure_trie_test.go
@@ -28,16 +28,16 @@ import (
 )
 
 func newEmptySecure() *SecureTrie {
-	db, _ := ethdb.NewMemDatabase()
-	trie, _ := NewSecure(common.Hash{}, db, 0)
+	trie, _ := NewSecure(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()), 0)
 	return trie
 }
 
 // makeTestSecureTrie creates a large enough secure trie for testing.
-func makeTestSecureTrie() (ethdb.Database, *SecureTrie, map[string][]byte) {
+func makeTestSecureTrie() (*Database, *SecureTrie, map[string][]byte) {
 	// Create an empty trie
-	db, _ := ethdb.NewMemDatabase()
-	trie, _ := NewSecure(common.Hash{}, db, 0)
+	triedb := NewDatabase(ethdb.NewMemDatabase())
+
+	trie, _ := NewSecure(common.Hash{}, triedb, 0)
 
 	// Fill it with some arbitrary data
 	content := make(map[string][]byte)
@@ -58,10 +58,10 @@ func makeTestSecureTrie() (ethdb.Database, *SecureTrie, map[string][]byte) {
 			trie.Update(key, val)
 		}
 	}
-	trie.Commit()
+	trie.Commit(nil)
 
 	// Return the generated trie
-	return db, trie, content
+	return triedb, trie, content
 }
 
 func TestSecureDelete(t *testing.T) {
@@ -137,7 +137,7 @@ func TestSecureTrieConcurrency(t *testing.T) {
 					tries[index].Update(key, val)
 				}
 			}
-			tries[index].Commit()
+			tries[index].Commit(nil)
 		}(i)
 	}
 	// Wait for all threads to finish
diff --git a/trie/sync.go b/trie/sync.go
index fea10051f4..ccec80c9e3 100644
--- a/trie/sync.go
+++ b/trie/sync.go
@@ -21,6 +21,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"gopkg.in/karalabe/cookiejar.v2/collections/prque"
 )
 
@@ -42,7 +43,7 @@ type request struct {
 	depth   int        // Depth level within the trie the node is located to prioritise DFS
 	deps    int        // Number of dependencies before allowed to commit this node
 
-	callback TrieSyncLeafCallback // Callback to invoke if a leaf node it reached on this branch
+	callback LeafCallback // Callback to invoke if a leaf node it reached on this branch
 }
 
 // SyncResult is a simple list to return missing nodes along with their request
@@ -67,24 +68,19 @@ func newSyncMemBatch() *syncMemBatch {
 	}
 }
 
-// TrieSyncLeafCallback is a callback type invoked when a trie sync reaches a
-// leaf node. It's used by state syncing to check if the leaf node requires some
-// further data syncing.
-type TrieSyncLeafCallback func(leaf []byte, parent common.Hash) error
-
-// TrieSync is the main state trie synchronisation scheduler, which provides yet
+// Sync is the main state trie synchronisation scheduler, which provides yet
 // unknown trie hashes to retrieve, accepts node data associated with said hashes
 // and reconstructs the trie step by step until all is done.
-type TrieSync struct {
+type Sync struct {
 	database DatabaseReader           // Persistent database to check for existing entries
 	membatch *syncMemBatch            // Memory buffer to avoid frequest database writes
 	requests map[common.Hash]*request // Pending requests pertaining to a key hash
 	queue    *prque.Prque             // Priority queue with the pending requests
 }
 
-// NewTrieSync creates a new trie data download scheduler.
-func NewTrieSync(root common.Hash, database DatabaseReader, callback TrieSyncLeafCallback) *TrieSync {
-	ts := &TrieSync{
+// NewSync creates a new trie data download scheduler.
+func NewSync(root common.Hash, database DatabaseReader, callback LeafCallback) *Sync {
+	ts := &Sync{
 		database: database,
 		membatch: newSyncMemBatch(),
 		requests: make(map[common.Hash]*request),
@@ -95,7 +91,7 @@ func NewTrieSync(root common.Hash, database DatabaseReader, callback TrieSyncLea
 }
 
 // AddSubTrie registers a new trie to the sync code, rooted at the designated parent.
-func (s *TrieSync) AddSubTrie(root common.Hash, depth int, parent common.Hash, callback TrieSyncLeafCallback) {
+func (s *Sync) AddSubTrie(root common.Hash, depth int, parent common.Hash, callback LeafCallback) {
 	// Short circuit if the trie is empty or already known
 	if root == emptyRoot {
 		return
@@ -130,7 +126,7 @@ func (s *TrieSync) AddSubTrie(root common.Hash, depth int, parent common.Hash, c
 // interpreted as a trie node, but rather accepted and stored into the database
 // as is. This method's goal is to support misc state metadata retrievals (e.g.
 // contract code).
-func (s *TrieSync) AddRawEntry(hash common.Hash, depth int, parent common.Hash) {
+func (s *Sync) AddRawEntry(hash common.Hash, depth int, parent common.Hash) {
 	// Short circuit if the entry is empty or already known
 	if hash == emptyState {
 		return
@@ -160,7 +156,7 @@ func (s *TrieSync) AddRawEntry(hash common.Hash, depth int, parent common.Hash)
 }
 
 // Missing retrieves the known missing nodes from the trie for retrieval.
-func (s *TrieSync) Missing(max int) []common.Hash {
+func (s *Sync) Missing(max int) []common.Hash {
 	requests := []common.Hash{}
 	for !s.queue.Empty() && (max == 0 || len(requests) < max) {
 		requests = append(requests, s.queue.PopItem().(common.Hash))
@@ -171,7 +167,7 @@ func (s *TrieSync) Missing(max int) []common.Hash {
 // Process injects a batch of retrieved trie nodes data, returning if something
 // was committed to the database and also the index of an entry if processing of
 // it failed.
-func (s *TrieSync) Process(results []SyncResult) (bool, int, error) {
+func (s *Sync) Process(results []SyncResult) (bool, int, error) {
 	committed := false
 
 	for i, item := range results {
@@ -216,8 +212,8 @@ func (s *TrieSync) Process(results []SyncResult) (bool, int, error) {
 }
 
 // Commit flushes the data stored in the internal membatch out to persistent
-// storage, returning th enumber of items written and any occurred error.
-func (s *TrieSync) Commit(dbw DatabaseWriter) (int, error) {
+// storage, returning the number of items written and any occurred error.
+func (s *Sync) Commit(dbw ethdb.Putter) (int, error) {
 	// Dump the membatch into a database dbw
 	for i, key := range s.membatch.order {
 		if err := dbw.Put(key[:], s.membatch.batch[key]); err != nil {
@@ -232,14 +228,14 @@ func (s *TrieSync) Commit(dbw DatabaseWriter) (int, error) {
 }
 
 // Pending returns the number of state entries currently pending for download.
-func (s *TrieSync) Pending() int {
+func (s *Sync) Pending() int {
 	return len(s.requests)
 }
 
 // schedule inserts a new state retrieval request into the fetch queue. If there
 // is already a pending request for this node, the new request will be discarded
 // and only a parent reference added to the old one.
-func (s *TrieSync) schedule(req *request) {
+func (s *Sync) schedule(req *request) {
 	// If we're already requesting this node, add a new reference and stop
 	if old, ok := s.requests[req.hash]; ok {
 		old.parents = append(old.parents, req.parents...)
@@ -252,7 +248,7 @@ func (s *TrieSync) schedule(req *request) {
 
 // children retrieves all the missing children of a state trie entry for future
 // retrieval scheduling.
-func (s *TrieSync) children(req *request, object node) ([]*request, error) {
+func (s *Sync) children(req *request, object node) ([]*request, error) {
 	// Gather all the children of the node, irrelevant whether known or not
 	type child struct {
 		node  node
@@ -314,7 +310,7 @@ func (s *TrieSync) children(req *request, object node) ([]*request, error) {
 // commit finalizes a retrieval request and stores it into the membatch. If any
 // of the referencing parent requests complete due to this commit, they are also
 // committed themselves.
-func (s *TrieSync) commit(req *request) (err error) {
+func (s *Sync) commit(req *request) (err error) {
 	// Write the node content to the membatch
 	s.membatch.batch[req.hash] = req.data
 	s.membatch.order = append(s.membatch.order, req.hash)
diff --git a/trie/sync_test.go b/trie/sync_test.go
index ec16a25bd9..c76779e5c7 100644
--- a/trie/sync_test.go
+++ b/trie/sync_test.go
@@ -25,10 +25,10 @@ import (
 )
 
 // makeTestTrie create a sample test trie to test node-wise reconstruction.
-func makeTestTrie() (ethdb.Database, *Trie, map[string][]byte) {
+func makeTestTrie() (*Database, *Trie, map[string][]byte) {
 	// Create an empty trie
-	db, _ := ethdb.NewMemDatabase()
-	trie, _ := New(common.Hash{}, db)
+	triedb := NewDatabase(ethdb.NewMemDatabase())
+	trie, _ := New(common.Hash{}, triedb)
 
 	// Fill it with some arbitrary data
 	content := make(map[string][]byte)
@@ -49,15 +49,15 @@ func makeTestTrie() (ethdb.Database, *Trie, map[string][]byte) {
 			trie.Update(key, val)
 		}
 	}
-	trie.Commit()
+	trie.Commit(nil)
 
 	// Return the generated trie
-	return db, trie, content
+	return triedb, trie, content
 }
 
 // checkTrieContents cross references a reconstructed trie with an expected data
 // content map.
-func checkTrieContents(t *testing.T, db Database, root []byte, content map[string][]byte) {
+func checkTrieContents(t *testing.T, db *Database, root []byte, content map[string][]byte) {
 	// Check root availability and trie contents
 	trie, err := New(common.BytesToHash(root), db)
 	if err != nil {
@@ -74,7 +74,7 @@ func checkTrieContents(t *testing.T, db Database, root []byte, content map[strin
 }
 
 // checkTrieConsistency checks that all nodes in a trie are indeed present.
-func checkTrieConsistency(db Database, root common.Hash) error {
+func checkTrieConsistency(db *Database, root common.Hash) error {
 	// Create and iterate a trie rooted in a subnode
 	trie, err := New(root, db)
 	if err != nil {
@@ -87,13 +87,14 @@ func checkTrieConsistency(db Database, root common.Hash) error {
 }
 
 // Tests that an empty trie is not scheduled for syncing.
-func TestEmptyTrieSync(t *testing.T) {
-	emptyA, _ := New(common.Hash{}, nil)
-	emptyB, _ := New(emptyRoot, nil)
+func TestEmptySync(t *testing.T) {
+	dbA := NewDatabase(ethdb.NewMemDatabase())
+	dbB := NewDatabase(ethdb.NewMemDatabase())
+	emptyA, _ := New(common.Hash{}, dbA)
+	emptyB, _ := New(emptyRoot, dbB)
 
 	for i, trie := range []*Trie{emptyA, emptyB} {
-		db, _ := ethdb.NewMemDatabase()
-		if req := NewTrieSync(common.BytesToHash(trie.Root()), db, nil).Missing(1); len(req) != 0 {
+		if req := NewSync(trie.Hash(), ethdb.NewMemDatabase(), nil).Missing(1); len(req) != 0 {
 			t.Errorf("test %d: content requested for empty trie: %v", i, req)
 		}
 	}
@@ -101,22 +102,23 @@ func TestEmptyTrieSync(t *testing.T) {
 
 // Tests that given a root hash, a trie can sync iteratively on a single thread,
 // requesting retrieval tasks and returning all of them in one go.
-func TestIterativeTrieSyncIndividual(t *testing.T) { testIterativeTrieSync(t, 1) }
-func TestIterativeTrieSyncBatched(t *testing.T)    { testIterativeTrieSync(t, 100) }
+func TestIterativeSyncIndividual(t *testing.T) { testIterativeSync(t, 1) }
+func TestIterativeSyncBatched(t *testing.T)    { testIterativeSync(t, 100) }
 
-func testIterativeTrieSync(t *testing.T, batch int) {
+func testIterativeSync(t *testing.T, batch int) {
 	// Create a random trie to copy
 	srcDb, srcTrie, srcData := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	queue := append([]common.Hash{}, sched.Missing(batch)...)
 	for len(queue) > 0 {
 		results := make([]SyncResult, len(queue))
 		for i, hash := range queue {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -125,31 +127,32 @@ func testIterativeTrieSync(t *testing.T, batch int) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		queue = append(queue[:0], sched.Missing(batch)...)
 	}
 	// Cross check that the two tries are in sync
-	checkTrieContents(t, dstDb, srcTrie.Root(), srcData)
+	checkTrieContents(t, triedb, srcTrie.Root(), srcData)
 }
 
 // Tests that the trie scheduler can correctly reconstruct the state even if only
 // partial results are returned, and the others sent only later.
-func TestIterativeDelayedTrieSync(t *testing.T) {
+func TestIterativeDelayedSync(t *testing.T) {
 	// Create a random trie to copy
 	srcDb, srcTrie, srcData := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	queue := append([]common.Hash{}, sched.Missing(10000)...)
 	for len(queue) > 0 {
 		// Sync only half of the scheduled nodes
 		results := make([]SyncResult, len(queue)/2+1)
 		for i, hash := range queue[:len(results)] {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -158,28 +161,29 @@ func TestIterativeDelayedTrieSync(t *testing.T) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		queue = append(queue[len(results):], sched.Missing(10000)...)
 	}
 	// Cross check that the two tries are in sync
-	checkTrieContents(t, dstDb, srcTrie.Root(), srcData)
+	checkTrieContents(t, triedb, srcTrie.Root(), srcData)
 }
 
 // Tests that given a root hash, a trie can sync iteratively on a single thread,
 // requesting retrieval tasks and returning all of them in one go, however in a
 // random order.
-func TestIterativeRandomTrieSyncIndividual(t *testing.T) { testIterativeRandomTrieSync(t, 1) }
-func TestIterativeRandomTrieSyncBatched(t *testing.T)    { testIterativeRandomTrieSync(t, 100) }
+func TestIterativeRandomSyncIndividual(t *testing.T) { testIterativeRandomSync(t, 1) }
+func TestIterativeRandomSyncBatched(t *testing.T)    { testIterativeRandomSync(t, 100) }
 
-func testIterativeRandomTrieSync(t *testing.T, batch int) {
+func testIterativeRandomSync(t *testing.T, batch int) {
 	// Create a random trie to copy
 	srcDb, srcTrie, srcData := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	queue := make(map[common.Hash]struct{})
 	for _, hash := range sched.Missing(batch) {
@@ -189,7 +193,7 @@ func testIterativeRandomTrieSync(t *testing.T, batch int) {
 		// Fetch all the queued nodes in a random order
 		results := make([]SyncResult, 0, len(queue))
 		for hash := range queue {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -199,7 +203,7 @@ func testIterativeRandomTrieSync(t *testing.T, batch int) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		queue = make(map[common.Hash]struct{})
@@ -208,18 +212,19 @@ func testIterativeRandomTrieSync(t *testing.T, batch int) {
 		}
 	}
 	// Cross check that the two tries are in sync
-	checkTrieContents(t, dstDb, srcTrie.Root(), srcData)
+	checkTrieContents(t, triedb, srcTrie.Root(), srcData)
 }
 
 // Tests that the trie scheduler can correctly reconstruct the state even if only
 // partial results are returned (Even those randomly), others sent only later.
-func TestIterativeRandomDelayedTrieSync(t *testing.T) {
+func TestIterativeRandomDelayedSync(t *testing.T) {
 	// Create a random trie to copy
 	srcDb, srcTrie, srcData := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	queue := make(map[common.Hash]struct{})
 	for _, hash := range sched.Missing(10000) {
@@ -229,7 +234,7 @@ func TestIterativeRandomDelayedTrieSync(t *testing.T) {
 		// Sync only half of the scheduled nodes, even those in random order
 		results := make([]SyncResult, 0, len(queue)/2+1)
 		for hash := range queue {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -243,7 +248,7 @@ func TestIterativeRandomDelayedTrieSync(t *testing.T) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		for _, result := range results {
@@ -254,18 +259,19 @@ func TestIterativeRandomDelayedTrieSync(t *testing.T) {
 		}
 	}
 	// Cross check that the two tries are in sync
-	checkTrieContents(t, dstDb, srcTrie.Root(), srcData)
+	checkTrieContents(t, triedb, srcTrie.Root(), srcData)
 }
 
 // Tests that a trie sync will not request nodes multiple times, even if they
 // have such references.
-func TestDuplicateAvoidanceTrieSync(t *testing.T) {
+func TestDuplicateAvoidanceSync(t *testing.T) {
 	// Create a random trie to copy
 	srcDb, srcTrie, srcData := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	queue := append([]common.Hash{}, sched.Missing(0)...)
 	requested := make(map[common.Hash]struct{})
@@ -273,7 +279,7 @@ func TestDuplicateAvoidanceTrieSync(t *testing.T) {
 	for len(queue) > 0 {
 		results := make([]SyncResult, len(queue))
 		for i, hash := range queue {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -287,24 +293,25 @@ func TestDuplicateAvoidanceTrieSync(t *testing.T) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		queue = append(queue[:0], sched.Missing(0)...)
 	}
 	// Cross check that the two tries are in sync
-	checkTrieContents(t, dstDb, srcTrie.Root(), srcData)
+	checkTrieContents(t, triedb, srcTrie.Root(), srcData)
 }
 
 // Tests that at any point in time during a sync, only complete sub-tries are in
 // the database.
-func TestIncompleteTrieSync(t *testing.T) {
+func TestIncompleteSync(t *testing.T) {
 	// Create a random trie to copy
 	srcDb, srcTrie, _ := makeTestTrie()
 
 	// Create a destination trie and sync with the scheduler
-	dstDb, _ := ethdb.NewMemDatabase()
-	sched := NewTrieSync(common.BytesToHash(srcTrie.Root()), dstDb, nil)
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+	sched := NewSync(srcTrie.Hash(), diskdb, nil)
 
 	added := []common.Hash{}
 	queue := append([]common.Hash{}, sched.Missing(1)...)
@@ -312,7 +319,7 @@ func TestIncompleteTrieSync(t *testing.T) {
 		// Fetch a batch of trie nodes
 		results := make([]SyncResult, len(queue))
 		for i, hash := range queue {
-			data, err := srcDb.Get(hash.Bytes())
+			data, err := srcDb.Node(hash)
 			if err != nil {
 				t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
 			}
@@ -322,7 +329,7 @@ func TestIncompleteTrieSync(t *testing.T) {
 		if _, index, err := sched.Process(results); err != nil {
 			t.Fatalf("failed to process result #%d: %v", index, err)
 		}
-		if index, err := sched.Commit(dstDb); err != nil {
+		if index, err := sched.Commit(diskdb); err != nil {
 			t.Fatalf("failed to commit data #%d: %v", index, err)
 		}
 		for _, result := range results {
@@ -330,7 +337,7 @@ func TestIncompleteTrieSync(t *testing.T) {
 		}
 		// Check that all known sub-tries in the synced trie are complete
 		for _, root := range added {
-			if err := checkTrieConsistency(dstDb, root); err != nil {
+			if err := checkTrieConsistency(triedb, root); err != nil {
 				t.Fatalf("trie inconsistent: %v", err)
 			}
 		}
@@ -340,12 +347,12 @@ func TestIncompleteTrieSync(t *testing.T) {
 	// Sanity check that removing any node from the database is detected
 	for _, node := range added[1:] {
 		key := node.Bytes()
-		value, _ := dstDb.Get(key)
+		value, _ := diskdb.Get(key)
 
-		dstDb.Delete(key)
-		if err := checkTrieConsistency(dstDb, added[0]); err == nil {
+		diskdb.Delete(key)
+		if err := checkTrieConsistency(triedb, added[0]); err == nil {
 			t.Fatalf("trie inconsistency not caught, missing: %x", key)
 		}
-		dstDb.Put(key, value)
+		diskdb.Put(key, value)
 	}
 }
diff --git a/trie/trie.go b/trie/trie.go
index c211e75549..30543c5496 100644
--- a/trie/trie.go
+++ b/trie/trie.go
@@ -22,16 +22,17 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto/sha3"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/rcrowley/go-metrics"
+	"github.com/ethereum/go-ethereum/metrics"
 )
 
 var (
-	// This is the known root hash of an empty trie.
+	// emptyRoot is the known root hash of an empty trie.
 	emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
-	// This is the known hash of an empty state trie entry.
-	emptyState common.Hash
+
+	// emptyState is the known hash of an empty state trie entry.
+	emptyState = crypto.Keccak256Hash(nil)
 )
 
 var (
@@ -53,29 +54,10 @@ func CacheUnloads() int64 {
 	return cacheUnloadCounter.Count()
 }
 
-func init() {
-	sha3.NewKeccak256().Sum(emptyState[:0])
-}
-
-// Database must be implemented by backing stores for the trie.
-type Database interface {
-	DatabaseReader
-	DatabaseWriter
-}
-
-// DatabaseReader wraps the Get method of a backing store for the trie.
-type DatabaseReader interface {
-	Get(key []byte) (value []byte, err error)
-	Has(key []byte) (bool, error)
-}
-
-// DatabaseWriter wraps the Put method of a backing store for the trie.
-type DatabaseWriter interface {
-	// Put stores the mapping key->value in the database.
-	// Implementations must not hold onto the value bytes, the trie
-	// will reuse the slice across calls to Put.
-	Put(key, value []byte) error
-}
+// LeafCallback is a callback type invoked when a trie operation reaches a leaf
+// node. It's used by state sync and commit to allow handling external references
+// between account and storage tries.
+type LeafCallback func(leaf []byte, parent common.Hash) error
 
 // Trie is a Merkle Patricia Trie.
 // The zero value is an empty trie with no database.
@@ -83,8 +65,8 @@ type DatabaseWriter interface {
 //
 // Trie is not safe for concurrent use.
 type Trie struct {
+	db           *Database
 	root         node
-	db           Database
 	originalRoot common.Hash
 
 	// Cache generation values.
@@ -111,12 +93,15 @@ func (t *Trie) newFlag() nodeFlag {
 // trie is initially empty and does not require a database. Otherwise,
 // New will panic if db is nil and returns a MissingNodeError if root does
 // not exist in the database. Accessing the trie loads nodes from db on demand.
-func New(root common.Hash, db Database) (*Trie, error) {
-	trie := &Trie{db: db, originalRoot: root}
-	if (root != common.Hash{}) && root != emptyRoot {
-		if db == nil {
-			panic("trie.New: cannot use existing root without a database")
-		}
+func New(root common.Hash, db *Database) (*Trie, error) {
+	if db == nil {
+		panic("trie.New called without a database")
+	}
+	trie := &Trie{
+		db:           db,
+		originalRoot: root,
+	}
+	if root != (common.Hash{}) && root != emptyRoot {
 		rootnode, err := trie.resolveHash(root[:], nil)
 		if err != nil {
 			return nil, err
@@ -447,12 +432,13 @@ func (t *Trie) resolve(n node, prefix []byte) (node, error) {
 func (t *Trie) resolveHash(n hashNode, prefix []byte) (node, error) {
 	cacheMissCounter.Inc(1)
 
-	enc, err := t.db.Get(n)
+	hash := common.BytesToHash(n)
+
+	enc, err := t.db.Node(hash)
 	if err != nil || enc == nil {
-		return nil, &MissingNodeError{NodeHash: common.BytesToHash(n), Path: prefix}
+		return nil, &MissingNodeError{NodeHash: hash, Path: prefix}
 	}
-	dec := mustDecodeNode(n, enc, t.cachegen)
-	return dec, nil
+	return mustDecodeNode(n, enc, t.cachegen), nil
 }
 
 // Root returns the root hash of the trie.
@@ -462,44 +448,31 @@ func (t *Trie) Root() []byte { return t.Hash().Bytes() }
 // Hash returns the root hash of the trie. It does not write to the
 // database and can be used even if the trie doesn't have one.
 func (t *Trie) Hash() common.Hash {
-	hash, cached, _ := t.hashRoot(nil)
+	hash, cached, _ := t.hashRoot(nil, nil)
 	t.root = cached
 	return common.BytesToHash(hash.(hashNode))
 }
 
-// Commit writes all nodes to the trie's database.
-// Nodes are stored with their sha3 hash as the key.
-//
-// Committing flushes nodes from memory.
-// Subsequent Get calls will load nodes from the database.
-func (t *Trie) Commit() (root common.Hash, err error) {
+// Commit writes all nodes to the trie's memory database, tracking the internal
+// and external (for account tries) references.
+func (t *Trie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
 	if t.db == nil {
-		panic("Commit called on trie with nil database")
+		panic("commit called on trie with nil database")
 	}
-	return t.CommitTo(t.db)
-}
-
-// CommitTo writes all nodes to the given database.
-// Nodes are stored with their sha3 hash as the key.
-//
-// Committing flushes nodes from memory. Subsequent Get calls will
-// load nodes from the trie's database. Calling code must ensure that
-// the changes made to db are written back to the trie's attached
-// database before using the trie.
-func (t *Trie) CommitTo(db DatabaseWriter) (root common.Hash, err error) {
-	hash, cached, err := t.hashRoot(db)
+	hash, cached, err := t.hashRoot(t.db, onleaf)
 	if err != nil {
-		return (common.Hash{}), err
+		return common.Hash{}, err
 	}
 	t.root = cached
 	t.cachegen++
 	return common.BytesToHash(hash.(hashNode)), nil
 }
 
-func (t *Trie) hashRoot(db DatabaseWriter) (node, node, error) {
+func (t *Trie) hashRoot(db *Database, onleaf LeafCallback) (node, node, error) {
 	if t.root == nil {
 		return hashNode(emptyRoot.Bytes()), nil, nil
 	}
-	h := newHasher(t.cachegen, t.cachelimit)
+	h := newHasher(t.cachegen, t.cachelimit, onleaf)
+	defer returnHasherToPool(h)
 	return h.hash(t.root, db, true)
 }
diff --git a/trie/trie_test.go b/trie/trie_test.go
index 1e28c3bc48..f8e5fd12a1 100644
--- a/trie/trie_test.go
+++ b/trie/trie_test.go
@@ -43,8 +43,7 @@ func init() {
 
 // Used for testing
 func newEmpty() *Trie {
-	db, _ := ethdb.NewMemDatabase()
-	trie, _ := New(common.Hash{}, db)
+	trie, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
 	return trie
 }
 
@@ -68,8 +67,7 @@ func TestNull(t *testing.T) {
 }
 
 func TestMissingRoot(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	trie, err := New(common.HexToHash("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), db)
+	trie, err := New(common.HexToHash("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), NewDatabase(ethdb.NewMemDatabase()))
 	if trie != nil {
 		t.Error("New returned non-nil trie for invalid root")
 	}
@@ -78,70 +76,75 @@ func TestMissingRoot(t *testing.T) {
 	}
 }
 
-func TestMissingNode(t *testing.T) {
-	db, _ := ethdb.NewMemDatabase()
-	trie, _ := New(common.Hash{}, db)
+func TestMissingNodeDisk(t *testing.T)    { testMissingNode(t, false) }
+func TestMissingNodeMemonly(t *testing.T) { testMissingNode(t, true) }
+
+func testMissingNode(t *testing.T, memonly bool) {
+	diskdb := ethdb.NewMemDatabase()
+	triedb := NewDatabase(diskdb)
+
+	trie, _ := New(common.Hash{}, triedb)
 	updateString(trie, "120000", "qwerqwerqwerqwerqwerqwerqwerqwer")
 	updateString(trie, "123456", "asdfasdfasdfasdfasdfasdfasdfasdf")
-	root, _ := trie.Commit()
+	root, _ := trie.Commit(nil)
+	if !memonly {
+		triedb.Commit(root, true)
+	}
 
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err := trie.TryGet([]byte("120000"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err = trie.TryGet([]byte("120099"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err = trie.TryGet([]byte("123456"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	err = trie.TryUpdate([]byte("120099"), []byte("zxcvzxcvzxcvzxcvzxcvzxcvzxcvzxcv"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	err = trie.TryDelete([]byte("123456"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
 
-	db.Delete(common.FromHex("e1d943cc8f061a0c0b98162830b970395ac9315654824bf21b73b891365262f9"))
+	hash := common.HexToHash("0xe1d943cc8f061a0c0b98162830b970395ac9315654824bf21b73b891365262f9")
+	if memonly {
+		delete(triedb.nodes, hash)
+	} else {
+		diskdb.Delete(hash[:])
+	}
 
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err = trie.TryGet([]byte("120000"))
 	if _, ok := err.(*MissingNodeError); !ok {
 		t.Errorf("Wrong error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err = trie.TryGet([]byte("120099"))
 	if _, ok := err.(*MissingNodeError); !ok {
 		t.Errorf("Wrong error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	_, err = trie.TryGet([]byte("123456"))
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	err = trie.TryUpdate([]byte("120099"), []byte("zxcv"))
 	if _, ok := err.(*MissingNodeError); !ok {
 		t.Errorf("Wrong error: %v", err)
 	}
-
-	trie, _ = New(root, db)
+	trie, _ = New(root, triedb)
 	err = trie.TryDelete([]byte("123456"))
 	if _, ok := err.(*MissingNodeError); !ok {
 		t.Errorf("Wrong error: %v", err)
@@ -165,7 +168,7 @@ func TestInsert(t *testing.T) {
 	updateString(trie, "A", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
 
 	exp = common.HexToHash("d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab")
-	root, err := trie.Commit()
+	root, err := trie.Commit(nil)
 	if err != nil {
 		t.Fatalf("commit error: %v", err)
 	}
@@ -194,7 +197,7 @@ func TestGet(t *testing.T) {
 		if i == 1 {
 			return
 		}
-		trie.Commit()
+		trie.Commit(nil)
 	}
 }
 
@@ -263,7 +266,7 @@ func TestReplication(t *testing.T) {
 	for _, val := range vals {
 		updateString(trie, val.k, val.v)
 	}
-	exp, err := trie.Commit()
+	exp, err := trie.Commit(nil)
 	if err != nil {
 		t.Fatalf("commit error: %v", err)
 	}
@@ -278,7 +281,7 @@ func TestReplication(t *testing.T) {
 			t.Errorf("trie2 doesn't have %q => %q", kv.k, kv.v)
 		}
 	}
-	hash, err := trie2.Commit()
+	hash, err := trie2.Commit(nil)
 	if err != nil {
 		t.Fatalf("commit error: %v", err)
 	}
@@ -314,7 +317,7 @@ func TestLargeValue(t *testing.T) {
 }
 
 type countingDB struct {
-	Database
+	ethdb.Database
 	gets map[string]int
 }
 
@@ -332,19 +335,20 @@ func TestCacheUnload(t *testing.T) {
 	key2 := "---some other branch"
 	updateString(trie, key1, "this is the branch of key1.")
 	updateString(trie, key2, "this is the branch of key2.")
-	root, _ := trie.Commit()
+
+	root, _ := trie.Commit(nil)
+	trie.db.Commit(root, true)
 
 	// Commit the trie repeatedly and access key1.
 	// The branch containing it is loaded from DB exactly two times:
 	// in the 0th and 6th iteration.
-	db := &countingDB{Database: trie.db, gets: make(map[string]int)}
-	trie, _ = New(root, db)
+	db := &countingDB{Database: trie.db.diskdb, gets: make(map[string]int)}
+	trie, _ = New(root, NewDatabase(db))
 	trie.SetCacheLimit(5)
 	for i := 0; i < 12; i++ {
 		getString(trie, key1)
-		trie.Commit()
+		trie.Commit(nil)
 	}
-
 	// Check that it got loaded two times.
 	for dbkey, count := range db.gets {
 		if count != 2 {
@@ -407,8 +411,9 @@ func (randTest) Generate(r *rand.Rand, size int) reflect.Value {
 }
 
 func runRandTest(rt randTest) bool {
-	db, _ := ethdb.NewMemDatabase()
-	tr, _ := New(common.Hash{}, db)
+	triedb := NewDatabase(ethdb.NewMemDatabase())
+
+	tr, _ := New(common.Hash{}, triedb)
 	values := make(map[string]string) // tracks content of the trie
 
 	for i, step := range rt {
@@ -426,23 +431,23 @@ func runRandTest(rt randTest) bool {
 				rt[i].err = fmt.Errorf("mismatch for key 0x%x, got 0x%x want 0x%x", step.key, v, want)
 			}
 		case opCommit:
-			_, rt[i].err = tr.Commit()
+			_, rt[i].err = tr.Commit(nil)
 		case opHash:
 			tr.Hash()
 		case opReset:
-			hash, err := tr.Commit()
+			hash, err := tr.Commit(nil)
 			if err != nil {
 				rt[i].err = err
 				return false
 			}
-			newtr, err := New(hash, db)
+			newtr, err := New(hash, triedb)
 			if err != nil {
 				rt[i].err = err
 				return false
 			}
 			tr = newtr
 		case opItercheckhash:
-			checktr, _ := New(common.Hash{}, nil)
+			checktr, _ := New(common.Hash{}, triedb)
 			it := NewIterator(tr.NodeIterator(nil))
 			for it.Next() {
 				checktr.Update(it.Key, it.Value)
@@ -524,7 +529,7 @@ func benchGet(b *testing.B, commit bool) {
 	}
 	binary.LittleEndian.PutUint64(k, benchElemCount/2)
 	if commit {
-		trie.Commit()
+		trie.Commit(nil)
 	}
 
 	b.ResetTimer()
@@ -534,7 +539,7 @@ func benchGet(b *testing.B, commit bool) {
 	b.StopTimer()
 
 	if commit {
-		ldb := trie.db.(*ethdb.LDBDatabase)
+		ldb := trie.db.diskdb.(*ethdb.LDBDatabase)
 		ldb.Close()
 		os.RemoveAll(ldb.Path())
 	}
@@ -585,16 +590,16 @@ func BenchmarkHash(b *testing.B) {
 	trie.Hash()
 }
 
-func tempDB() (string, Database) {
+func tempDB() (string, *Database) {
 	dir, err := ioutil.TempDir("", "trie-bench")
 	if err != nil {
 		panic(fmt.Sprintf("can't create temporary directory: %v", err))
 	}
-	db, err := ethdb.NewLDBDatabase(dir, 256, 0)
+	diskdb, err := ethdb.NewLDBDatabase(dir, 256, 0)
 	if err != nil {
 		panic(fmt.Sprintf("can't create temporary database: %v", err))
 	}
-	return dir, db
+	return dir, NewDatabase(diskdb)
 }
 
 func getString(trie *Trie, k string) []byte {
diff --git a/vendor/github.com/StackExchange/wmi/LICENSE b/vendor/github.com/StackExchange/wmi/LICENSE
new file mode 100644
index 0000000000..ae80b67209
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Stack Exchange
+
+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/vendor/github.com/StackExchange/wmi/README.md b/vendor/github.com/StackExchange/wmi/README.md
new file mode 100644
index 0000000000..426d1a46b4
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/README.md
@@ -0,0 +1,6 @@
+wmi
+===
+
+Package wmi provides a WQL interface to Windows WMI.
+
+Note: It interfaces with WMI on the local machine, therefore it only runs on Windows.
diff --git a/vendor/github.com/StackExchange/wmi/swbemservices.go b/vendor/github.com/StackExchange/wmi/swbemservices.go
new file mode 100644
index 0000000000..9765a53f74
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/swbemservices.go
@@ -0,0 +1,260 @@
+// +build windows
+
+package wmi
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"sync"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+// SWbemServices is used to access wmi. See https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx
+type SWbemServices struct {
+	//TODO: track namespace. Not sure if we can re connect to a different namespace using the same instance
+	cWMIClient            *Client //This could also be an embedded struct, but then we would need to branch on Client vs SWbemServices in the Query method
+	sWbemLocatorIUnknown  *ole.IUnknown
+	sWbemLocatorIDispatch *ole.IDispatch
+	queries               chan *queryRequest
+	closeError            chan error
+	lQueryorClose         sync.Mutex
+}
+
+type queryRequest struct {
+	query    string
+	dst      interface{}
+	args     []interface{}
+	finished chan error
+}
+
+// InitializeSWbemServices will return a new SWbemServices object that can be used to query WMI
+func InitializeSWbemServices(c *Client, connectServerArgs ...interface{}) (*SWbemServices, error) {
+	//fmt.Println("InitializeSWbemServices: Starting")
+	//TODO: implement connectServerArgs as optional argument for init with connectServer call
+	s := new(SWbemServices)
+	s.cWMIClient = c
+	s.queries = make(chan *queryRequest)
+	initError := make(chan error)
+	go s.process(initError)
+
+	err, ok := <-initError
+	if ok {
+		return nil, err //Send error to caller
+	}
+	//fmt.Println("InitializeSWbemServices: Finished")
+	return s, nil
+}
+
+// Close will clear and release all of the SWbemServices resources
+func (s *SWbemServices) Close() error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+	//fmt.Println("Close: sending close request")
+	var result error
+	ce := make(chan error)
+	s.closeError = ce //Race condition if multiple callers to close. May need to lock here
+	close(s.queries)  //Tell background to shut things down
+	s.lQueryorClose.Unlock()
+	err, ok := <-ce
+	if ok {
+		result = err
+	}
+	//fmt.Println("Close: finished")
+	return result
+}
+
+func (s *SWbemServices) process(initError chan error) {
+	//fmt.Println("process: starting background thread initialization")
+	//All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine
+	runtime.LockOSThread()
+	defer runtime.LockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			initError <- fmt.Errorf("ole.CoInitializeEx error: %v", err)
+			return
+		}
+	}
+	defer ole.CoUninitialize()
+
+	unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		initError <- fmt.Errorf("CreateObject SWbemLocator error: %v", err)
+		return
+	} else if unknown == nil {
+		initError <- ErrNilCreateObject
+		return
+	}
+	defer unknown.Release()
+	s.sWbemLocatorIUnknown = unknown
+
+	dispatch, err := s.sWbemLocatorIUnknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		initError <- fmt.Errorf("SWbemLocator QueryInterface error: %v", err)
+		return
+	}
+	defer dispatch.Release()
+	s.sWbemLocatorIDispatch = dispatch
+
+	// we can't do the ConnectServer call outside the loop unless we find a way to track and re-init the connectServerArgs
+	//fmt.Println("process: initialized. closing initError")
+	close(initError)
+	//fmt.Println("process: waiting for queries")
+	for q := range s.queries {
+		//fmt.Printf("process: new query: len(query)=%d\n", len(q.query))
+		errQuery := s.queryBackground(q)
+		//fmt.Println("process: s.queryBackground finished")
+		if errQuery != nil {
+			q.finished <- errQuery
+		}
+		close(q.finished)
+	}
+	//fmt.Println("process: queries channel closed")
+	s.queries = nil //set channel to nil so we know it is closed
+	//TODO: I think the Release/Clear calls can panic if things are in a bad state.
+	//TODO: May need to recover from panics and send error to method caller instead.
+	close(s.closeError)
+}
+
+// Query runs the WQL query using a SWbemServices instance and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+func (s *SWbemServices) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+
+	//fmt.Println("Query: Sending query request")
+	qr := queryRequest{
+		query:    query,
+		dst:      dst,
+		args:     connectServerArgs,
+		finished: make(chan error),
+	}
+	s.queries <- &qr
+	s.lQueryorClose.Unlock()
+	err, ok := <-qr.finished
+	if ok {
+		//fmt.Println("Query: Finished with error")
+		return err //Send error to caller
+	}
+	//fmt.Println("Query: Finished")
+	return nil
+}
+
+func (s *SWbemServices) queryBackground(q *queryRequest) error {
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	wmi := s.sWbemLocatorIDispatch //Should just rename in the code, but this will help as we break things apart
+	//fmt.Println("queryBackground: Starting")
+
+	dv := reflect.ValueOf(q.dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	// service is a SWbemServices
+	serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", q.args...)
+	if err != nil {
+		return err
+	}
+	service := serviceRaw.ToIDispatch()
+	defer serviceRaw.Clear()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", q.query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = s.cWMIClient.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	//fmt.Println("queryBackground: Finished")
+	return errFieldMismatch
+}
diff --git a/vendor/github.com/StackExchange/wmi/wmi.go b/vendor/github.com/StackExchange/wmi/wmi.go
new file mode 100644
index 0000000000..a951b1258b
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/wmi.go
@@ -0,0 +1,486 @@
+// +build windows
+
+/*
+Package wmi provides a WQL interface for WMI on Windows.
+
+Example code to print names of running processes:
+
+	type Win32_Process struct {
+		Name string
+	}
+
+	func main() {
+		var dst []Win32_Process
+		q := wmi.CreateQuery(&dst, "")
+		err := wmi.Query(q, &dst)
+		if err != nil {
+			log.Fatal(err)
+		}
+		for i, v := range dst {
+			println(i, v.Name)
+		}
+	}
+
+*/
+package wmi
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+var l = log.New(os.Stdout, "", log.LstdFlags)
+
+var (
+	ErrInvalidEntityType = errors.New("wmi: invalid entity type")
+	// ErrNilCreateObject is the error returned if CreateObject returns nil even
+	// if the error was nil.
+	ErrNilCreateObject = errors.New("wmi: create object returned nil")
+	lock               sync.Mutex
+)
+
+// S_FALSE is returned by CoInitializeEx if it was already called on this thread.
+const S_FALSE = 0x00000001
+
+// QueryNamespace invokes Query with the given namespace on the local machine.
+func QueryNamespace(query string, dst interface{}, namespace string) error {
+	return Query(query, dst, nil, namespace)
+}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+//
+// Query is a wrapper around DefaultClient.Query.
+func Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	if DefaultClient.SWbemServicesClient == nil {
+		return DefaultClient.Query(query, dst, connectServerArgs...)
+	}
+	return DefaultClient.SWbemServicesClient.Query(query, dst, connectServerArgs...)
+}
+
+// A Client is an WMI query client.
+//
+// Its zero value (DefaultClient) is a usable client.
+type Client struct {
+	// NonePtrZero specifies if nil values for fields which aren't pointers
+	// should be returned as the field types zero value.
+	//
+	// Setting this to true allows stucts without pointer fields to be used
+	// without the risk failure should a nil value returned from WMI.
+	NonePtrZero bool
+
+	// PtrNil specifies if nil values for pointer fields should be returned
+	// as nil.
+	//
+	// Setting this to true will set pointer fields to nil where WMI
+	// returned nil, otherwise the types zero value will be returned.
+	PtrNil bool
+
+	// AllowMissingFields specifies that struct fields not present in the
+	// query result should not result in an error.
+	//
+	// Setting this to true allows custom queries to be used with full
+	// struct definitions instead of having to define multiple structs.
+	AllowMissingFields bool
+
+	// SWbemServiceClient is an optional SWbemServices object that can be
+	// initialized and then reused across multiple queries. If it is null
+	// then the method will initialize a new temporary client each time.
+	SWbemServicesClient *SWbemServices
+}
+
+// DefaultClient is the default Client and is used by Query, QueryNamespace
+var DefaultClient = &Client{}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	dv := reflect.ValueOf(dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	lock.Lock()
+	defer lock.Unlock()
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			return err
+		}
+	}
+	defer ole.CoUninitialize()
+
+	unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		return err
+	} else if unknown == nil {
+		return ErrNilCreateObject
+	}
+	defer unknown.Release()
+
+	wmi, err := unknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		return err
+	}
+	defer wmi.Release()
+
+	// service is a SWbemServices
+	serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...)
+	if err != nil {
+		return err
+	}
+	service := serviceRaw.ToIDispatch()
+	defer serviceRaw.Clear()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = c.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	return errFieldMismatch
+}
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument.
+type ErrFieldMismatch struct {
+	StructType reflect.Type
+	FieldName  string
+	Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+	return fmt.Sprintf("wmi: cannot load field %q into a %q: %s",
+		e.FieldName, e.StructType, e.Reason)
+}
+
+var timeType = reflect.TypeOf(time.Time{})
+
+// loadEntity loads a SWbemObject into a struct pointer.
+func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) {
+	v := reflect.ValueOf(dst).Elem()
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		of := f
+		isPtr := f.Kind() == reflect.Ptr
+		if isPtr {
+			ptr := reflect.New(f.Type().Elem())
+			f.Set(ptr)
+			f = f.Elem()
+		}
+		n := v.Type().Field(i).Name
+		if !f.CanSet() {
+			return &ErrFieldMismatch{
+				StructType: of.Type(),
+				FieldName:  n,
+				Reason:     "CanSet() is false",
+			}
+		}
+		prop, err := oleutil.GetProperty(src, n)
+		if err != nil {
+			if !c.AllowMissingFields {
+				errFieldMismatch = &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "no such struct field",
+				}
+			}
+			continue
+		}
+		defer prop.Clear()
+
+		switch val := prop.Value().(type) {
+		case int8, int16, int32, int64, int:
+			v := reflect.ValueOf(val).Int()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(v)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(uint64(v))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case uint8, uint16, uint32, uint64:
+			v := reflect.ValueOf(val).Uint()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(int64(v))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(v)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case string:
+			switch f.Kind() {
+			case reflect.String:
+				f.SetString(val)
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				iv, err := strconv.ParseInt(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetInt(iv)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				uv, err := strconv.ParseUint(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetUint(uv)
+			case reflect.Struct:
+				switch f.Type() {
+				case timeType:
+					if len(val) == 25 {
+						mins, err := strconv.Atoi(val[22:])
+						if err != nil {
+							return err
+						}
+						val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60)
+					}
+					t, err := time.Parse("20060102150405.000000-0700", val)
+					if err != nil {
+						return err
+					}
+					f.Set(reflect.ValueOf(t))
+				}
+			}
+		case bool:
+			switch f.Kind() {
+			case reflect.Bool:
+				f.SetBool(val)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a bool",
+				}
+			}
+		case float32:
+			switch f.Kind() {
+			case reflect.Float32:
+				f.SetFloat(float64(val))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a Float32",
+				}
+			}
+		default:
+			if f.Kind() == reflect.Slice {
+				switch f.Type().Elem().Kind() {
+				case reflect.String:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetString(v.(string))
+						}
+						f.Set(fArr)
+					}
+				case reflect.Uint8:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetUint(reflect.ValueOf(v).Uint())
+						}
+						f.Set(fArr)
+					}
+				default:
+					return &ErrFieldMismatch{
+						StructType: of.Type(),
+						FieldName:  n,
+						Reason:     fmt.Sprintf("unsupported slice type (%T)", val),
+					}
+				}
+			} else {
+				typeof := reflect.TypeOf(val)
+				if typeof == nil && (isPtr || c.NonePtrZero) {
+					if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) {
+						of.Set(reflect.Zero(of.Type()))
+					}
+					break
+				}
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     fmt.Sprintf("unsupported type (%T)", val),
+				}
+			}
+		}
+	}
+	return errFieldMismatch
+}
+
+type multiArgType int
+
+const (
+	multiArgTypeInvalid multiArgType = iota
+	multiArgTypeStruct
+	multiArgTypeStructPtr
+)
+
+// checkMultiArg checks that v has type []S, []*S for some struct type S.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+	if v.Kind() != reflect.Slice {
+		return multiArgTypeInvalid, nil
+	}
+	elemType = v.Type().Elem()
+	switch elemType.Kind() {
+	case reflect.Struct:
+		return multiArgTypeStruct, elemType
+	case reflect.Ptr:
+		elemType = elemType.Elem()
+		if elemType.Kind() == reflect.Struct {
+			return multiArgTypeStructPtr, elemType
+		}
+	}
+	return multiArgTypeInvalid, nil
+}
+
+func oleInt64(item *ole.IDispatch, prop string) (int64, error) {
+	v, err := oleutil.GetProperty(item, prop)
+	if err != nil {
+		return 0, err
+	}
+	defer v.Clear()
+
+	i := int64(v.Val)
+	return i, nil
+}
+
+// CreateQuery returns a WQL query string that queries all columns of src. where
+// is an optional string that is appended to the query, to be used with WHERE
+// clauses. In such a case, the "WHERE" string should appear at the beginning.
+func CreateQuery(src interface{}, where string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT ")
+	s := reflect.Indirect(reflect.ValueOf(src))
+	t := s.Type()
+	if s.Kind() == reflect.Slice {
+		t = t.Elem()
+	}
+	if t.Kind() != reflect.Struct {
+		return ""
+	}
+	var fields []string
+	for i := 0; i < t.NumField(); i++ {
+		fields = append(fields, t.Field(i).Name)
+	}
+	b.WriteString(strings.Join(fields, ", "))
+	b.WriteString(" FROM ")
+	b.WriteString(t.Name())
+	b.WriteString(" " + where)
+	return b.String()
+}
diff --git a/vendor/github.com/elastic/gosigar/CHANGELOG.md b/vendor/github.com/elastic/gosigar/CHANGELOG.md
new file mode 100644
index 0000000000..45262e7b8d
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/CHANGELOG.md
@@ -0,0 +1,113 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+### Fixed
+
+- Added missing runtime import for FreeBSD. #104
+
+### Changed
+
+### Deprecated
+
+## [0.9.0]
+
+### Added
+- Added support for huge TLB pages on Linux #97  
+- Added support for big endian platform #100 
+
+### Fixed
+- Add missing method for OpenBSD #99
+
+## [0.8.0]
+
+### Added
+- Added partial `getrusage` support for Windows to retrieve system CPU time and user CPU time. #95
+- Added full `getrusage` support for Unix. #95
+
+## [0.7.0]
+
+### Added
+- Added method stubs for process handling for operating system that are not supported
+  by gosigar. All methods return `ErrNotImplemented` on such systems. #88
+
+### Fixed
+- Fix freebsd build by using the common version of Get(pid). #91
+
+### Changed
+- Fixed issues in cgroup package by adding missing error checks and closing
+  file handles. #92
+
+## [0.6.0]
+
+### Added
+- Added method stubs to enable compilation for operating systems that are not
+  supported by gosigar. All methods return `ErrNotImplemented` on these unsupported
+  operating systems. #83
+- FreeBSD returns `ErrNotImplemented` for `ProcTime.Get`. #83
+
+### Changed
+- OpenBSD returns `ErrNotImplemented` for `ProcTime.Get` instead of `nil`. #83
+- Fixed incorrect `Mem.Used` calculation under linux. #82
+- Fixed `ProcState` on Linux and FreeBSD when process names contain parentheses. #81
+
+### Removed
+- Remove NetBSD build from sigar_unix.go as it is not supported by gosigar. #83
+
+## [0.5.0]
+
+### Changed
+- Fixed Trim environment variables when comparing values in the test suite. #79
+- Make `kern_procargs` more robust under darwin when we cannot retrieve
+  all the information about a process. #78
+
+## [0.4.0]
+
+### Changed
+- Fixed Windows issue that caused a hang during `init()` if WMI wasn't ready. #74
+
+## [0.3.0]
+
+### Added
+- Read `MemAvailable` value for kernel 3.14+ #71
+
+## [0.2.0]
+
+### Added
+- Added `ErrCgroupsMissing` to indicate that /proc/cgroups is missing which is
+  an indicator that cgroups were disabled at compile time. #64
+
+### Changed
+- Changed `cgroup.SupportedSubsystems()` to honor the "enabled" column in the
+  /proc/cgroups file. #64
+
+## [0.1.0]
+
+### Added
+- Added `CpuList` implementation for Windows that returns CPU timing information
+  on a per CPU basis. #55
+- Added `Uptime` implementation for Windows. #55
+- Added `Swap` implementation for Windows based on page file metrics. #55
+- Added support to `github.com/gosigar/sys/windows` for querying and enabling
+  privileges in a process token.
+- Added utility code for interfacing with linux NETLINK_INET_DIAG. #60
+- Added `ProcEnv` for getting a process's environment variables. #61
+
+### Changed
+- Changed several `OpenProcess` calls on Windows to request the lowest possible
+  access privileges. #50
+- Removed cgo usage from Windows code.
+- Added OS version checks to `ProcArgs.Get` on Windows because the
+  `Win32_Process` WMI query is not available prior to Windows vista. On XP and
+  Windows 2003, this method returns `ErrNotImplemented`. #55
+
+### Fixed
+- Fixed value of `Mem.ActualFree` and `Mem.ActualUsed` on Windows. #49
+- Fixed `ProcTime.StartTime` on Windows to report value in milliseconds since
+  Unix epoch. #51
+- Fixed `ProcStatus.PPID` value is wrong on Windows. #55
+- Fixed `ProcStatus.Username` error on Windows XP #56
diff --git a/vendor/github.com/elastic/gosigar/LICENSE b/vendor/github.com/elastic/gosigar/LICENSE
new file mode 100644
index 0000000000..11069edd79
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/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/vendor/github.com/elastic/gosigar/NOTICE b/vendor/github.com/elastic/gosigar/NOTICE
new file mode 100644
index 0000000000..fda553b5c3
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/NOTICE
@@ -0,0 +1,9 @@
+Copyright (c) [2009-2011] VMware, Inc. All Rights Reserved. 
+
+This product is licensed to you under the Apache License, Version 2.0 (the "License").  
+You may not use this product except in compliance with the License.  
+
+This product includes a number of subcomponents with
+separate copyright notices and license terms. Your use of these
+subcomponents is subject to the terms and conditions of the 
+subcomponent's license, as noted in the LICENSE file.
\ No newline at end of file
diff --git a/vendor/github.com/elastic/gosigar/README.md b/vendor/github.com/elastic/gosigar/README.md
new file mode 100644
index 0000000000..ecdfc1c3c5
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/README.md
@@ -0,0 +1,58 @@
+# Go sigar [![Build Status](https://travis-ci.org/elastic/gosigar.svg?branch=master)](https://travis-ci.org/elastic/gosigar) [![Build status](https://ci.appveyor.com/api/projects/status/4yh6sa7u97ek5uib/branch/master?svg=true)](https://ci.appveyor.com/project/elastic-beats/gosigar/branch/master)
+
+
+## Overview
+
+Go sigar is a golang implementation of the
+[sigar API](https://github.com/hyperic/sigar).  The Go version of
+sigar has a very similar interface, but is being written from scratch
+in pure go/cgo, rather than cgo bindings for libsigar.
+
+## Test drive
+
+    $ go get github.com/elastic/gosigar
+    $ cd $GOPATH/src/github.com/elastic/gosigar/examples/ps
+    $ go build
+    $ ./ps
+
+## Supported platforms
+
+The features vary by operating system.
+
+| Feature         | Linux | Darwin | Windows | OpenBSD | FreeBSD |
+|-----------------|:-----:|:------:|:-------:|:-------:|:-------:|
+| Cpu             |   X   |    X   |    X    |    X    |    X    |
+| CpuList         |   X   |    X   |         |    X    |    X    |
+| FDUsage         |   X   |        |         |         |    X    |
+| FileSystemList  |   X   |    X   |    X    |    X    |    X    |
+| FileSystemUsage |   X   |    X   |    X    |    X    |    X    |
+| HugeTLBPages    |   X   |        |         |         |         |
+| LoadAverage     |   X   |    X   |         |    X    |    X    |
+| Mem             |   X   |    X   |    X    |    X    |    X    |
+| ProcArgs        |   X   |    X   |    X    |         |    X    |
+| ProcEnv         |   X   |    X   |         |         |    X    |
+| ProcExe         |   X   |    X   |         |         |    X    |
+| ProcFDUsage     |   X   |        |         |         |    X    |
+| ProcList        |   X   |    X   |    X    |         |    X    |
+| ProcMem         |   X   |    X   |    X    |         |    X    |
+| ProcState       |   X   |    X   |    X    |         |    X    |
+| ProcTime        |   X   |    X   |    X    |         |    X    |
+| Swap            |   X   |    X   |         |    X    |    X    |
+| Uptime          |   X   |    X   |         |    X    |    X    |
+
+## OS Specific Notes
+
+### FreeBSD
+
+Mount both `linprocfs` and `procfs` for compatability. Consider adding these
+mounts to your `/etc/fstab` file so they are mounted automatically at boot.
+
+```
+sudo mount -t procfs proc /proc
+sudo mkdir -p /compat/linux/proc
+sudo mount -t linprocfs /dev/null /compat/linux/proc
+```
+
+## License
+
+Apache 2.0
diff --git a/vendor/github.com/elastic/gosigar/Vagrantfile b/vendor/github.com/elastic/gosigar/Vagrantfile
new file mode 100644
index 0000000000..6fd990c141
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/Vagrantfile
@@ -0,0 +1,25 @@
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = "hashicorp/precise64"
+  config.vm.provision "shell", inline: "mkdir -p /home/vagrant/go"
+  config.vm.synced_folder ".", "/home/vagrant/go/src/github.com/cloudfoundry/gosigar"
+  config.vm.provision "shell", inline: "chown -R vagrant:vagrant /home/vagrant/go"
+  install_go = <<-BASH
+  set -e
+
+if [ ! -d "/usr/local/go" ]; then
+	cd /tmp && wget https://storage.googleapis.com/golang/go1.3.3.linux-amd64.tar.gz
+	cd /usr/local
+	tar xvzf /tmp/go1.3.3.linux-amd64.tar.gz
+	echo 'export GOPATH=/home/vagrant/go; export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin' >> /home/vagrant/.bashrc
+fi
+export GOPATH=/home/vagrant/go
+export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin
+/usr/local/go/bin/go get -u github.com/onsi/ginkgo/ginkgo
+/usr/local/go/bin/go get -u github.com/onsi/gomega;
+BASH
+  config.vm.provision "shell", inline: 'apt-get install -y git-core'
+  config.vm.provision "shell", inline: install_go
+end
diff --git a/vendor/github.com/elastic/gosigar/codecov.yml b/vendor/github.com/elastic/gosigar/codecov.yml
new file mode 100644
index 0000000000..76ade0fdb0
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/codecov.yml
@@ -0,0 +1,21 @@
+# Enable coverage report message for diff on commit
+coverage:
+  status:
+    project: off
+    patch:
+      default:
+        # basic
+        target: auto
+        threshold: null
+        base: auto
+        # advanced
+        branches: null
+        if_no_uploads: error
+        if_not_found: success
+        if_ci_failed: error
+        only_pulls: false
+        flags: null
+        paths: null
+
+# Disable comments on Pull Requests
+comment: false
diff --git a/vendor/github.com/elastic/gosigar/concrete_sigar.go b/vendor/github.com/elastic/gosigar/concrete_sigar.go
new file mode 100644
index 0000000000..e3ee80a980
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/concrete_sigar.go
@@ -0,0 +1,89 @@
+package gosigar
+
+import (
+	"time"
+)
+
+type ConcreteSigar struct{}
+
+func (c *ConcreteSigar) CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{}) {
+	// samplesCh is buffered to 1 value to immediately return first CPU sample
+	samplesCh := make(chan Cpu, 1)
+
+	stopCh := make(chan struct{})
+
+	go func() {
+		var cpuUsage Cpu
+
+		// Immediately provide non-delta value.
+		// samplesCh is buffered to 1 value, so it will not block.
+		cpuUsage.Get()
+		samplesCh <- cpuUsage
+
+		ticker := time.NewTicker(collectionInterval)
+
+		for {
+			select {
+			case <-ticker.C:
+				previousCpuUsage := cpuUsage
+
+				cpuUsage.Get()
+
+				select {
+				case samplesCh <- cpuUsage.Delta(previousCpuUsage):
+				default:
+					// Include default to avoid channel blocking
+				}
+
+			case <-stopCh:
+				return
+			}
+		}
+	}()
+
+	return samplesCh, stopCh
+}
+
+func (c *ConcreteSigar) GetLoadAverage() (LoadAverage, error) {
+	l := LoadAverage{}
+	err := l.Get()
+	return l, err
+}
+
+func (c *ConcreteSigar) GetMem() (Mem, error) {
+	m := Mem{}
+	err := m.Get()
+	return m, err
+}
+
+func (c *ConcreteSigar) GetSwap() (Swap, error) {
+	s := Swap{}
+	err := s.Get()
+	return s, err
+}
+
+func (c *ConcreteSigar) GetHugeTLBPages() (HugeTLBPages, error) {
+	p := HugeTLBPages{}
+	err := p.Get()
+	return p, err
+}
+
+func (c *ConcreteSigar) GetFileSystemUsage(path string) (FileSystemUsage, error) {
+	f := FileSystemUsage{}
+	err := f.Get(path)
+	return f, err
+}
+
+func (c *ConcreteSigar) GetFDUsage() (FDUsage, error) {
+	fd := FDUsage{}
+	err := fd.Get()
+	return fd, err
+}
+
+// GetRusage return the resource usage of the process
+// Possible params: 0 = RUSAGE_SELF, 1 = RUSAGE_CHILDREN, 2 = RUSAGE_THREAD
+func (c *ConcreteSigar) GetRusage(who int) (Rusage, error) {
+	r := Rusage{}
+	err := r.Get(who)
+	return r, err
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_darwin.go b/vendor/github.com/elastic/gosigar/sigar_darwin.go
new file mode 100644
index 0000000000..a90b998c2e
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_darwin.go
@@ -0,0 +1,498 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+/*
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+*/
+import "C"
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os/user"
+	"runtime"
+	"strconv"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+func (self *LoadAverage) Get() error {
+	avg := []C.double{0, 0, 0}
+
+	C.getloadavg(&avg[0], C.int(len(avg)))
+
+	self.One = float64(avg[0])
+	self.Five = float64(avg[1])
+	self.Fifteen = float64(avg[2])
+
+	return nil
+}
+
+func (self *Uptime) Get() error {
+	tv := syscall.Timeval32{}
+
+	if err := sysctlbyname("kern.boottime", &tv); err != nil {
+		return err
+	}
+
+	self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+	var vmstat C.vm_statistics_data_t
+
+	if err := sysctlbyname("hw.memsize", &self.Total); err != nil {
+		return err
+	}
+
+	if err := vm_info(&vmstat); err != nil {
+		return err
+	}
+
+	kern := uint64(vmstat.inactive_count) << 12
+	self.Free = uint64(vmstat.free_count) << 12
+
+	self.Used = self.Total - self.Free
+	self.ActualFree = self.Free + kern
+	self.ActualUsed = self.Used - kern
+
+	return nil
+}
+
+type xsw_usage struct {
+	Total, Avail, Used uint64
+}
+
+func (self *Swap) Get() error {
+	sw_usage := xsw_usage{}
+
+	if err := sysctlbyname("vm.swapusage", &sw_usage); err != nil {
+		return err
+	}
+
+	self.Total = sw_usage.Total
+	self.Used = sw_usage.Used
+	self.Free = sw_usage.Avail
+
+	return nil
+}
+
+func (self *HugeTLBPages) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Cpu) Get() error {
+	var count C.mach_msg_type_number_t = C.HOST_CPU_LOAD_INFO_COUNT
+	var cpuload C.host_cpu_load_info_data_t
+
+	status := C.host_statistics(C.host_t(C.mach_host_self()),
+		C.HOST_CPU_LOAD_INFO,
+		C.host_info_t(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_statistics error=%d", status)
+	}
+
+	self.User = uint64(cpuload.cpu_ticks[C.CPU_STATE_USER])
+	self.Sys = uint64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM])
+	self.Idle = uint64(cpuload.cpu_ticks[C.CPU_STATE_IDLE])
+	self.Nice = uint64(cpuload.cpu_ticks[C.CPU_STATE_NICE])
+
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	var count C.mach_msg_type_number_t
+	var cpuload *C.processor_cpu_load_info_data_t
+	var ncpu C.natural_t
+
+	status := C.host_processor_info(C.host_t(C.mach_host_self()),
+		C.PROCESSOR_CPU_LOAD_INFO,
+		&ncpu,
+		(*C.processor_info_array_t)(unsafe.Pointer(&cpuload)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_processor_info error=%d", status)
+	}
+
+	// jump through some cgo casting hoops and ensure we properly free
+	// the memory that cpuload points to
+	target := C.vm_map_t(C.mach_task_self_)
+	address := C.vm_address_t(uintptr(unsafe.Pointer(cpuload)))
+	defer C.vm_deallocate(target, address, C.vm_size_t(ncpu))
+
+	// the body of struct processor_cpu_load_info
+	// aka processor_cpu_load_info_data_t
+	var cpu_ticks [C.CPU_STATE_MAX]uint32
+
+	// copy the cpuload array to a []byte buffer
+	// where we can binary.Read the data
+	size := int(ncpu) * binary.Size(cpu_ticks)
+	buf := C.GoBytes(unsafe.Pointer(cpuload), C.int(size))
+
+	bbuf := bytes.NewBuffer(buf)
+
+	self.List = make([]Cpu, 0, ncpu)
+
+	for i := 0; i < int(ncpu); i++ {
+		cpu := Cpu{}
+
+		err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks)
+		if err != nil {
+			return err
+		}
+
+		cpu.User = uint64(cpu_ticks[C.CPU_STATE_USER])
+		cpu.Sys = uint64(cpu_ticks[C.CPU_STATE_SYSTEM])
+		cpu.Idle = uint64(cpu_ticks[C.CPU_STATE_IDLE])
+		cpu.Nice = uint64(cpu_ticks[C.CPU_STATE_NICE])
+
+		self.List = append(self.List, cpu)
+	}
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemList) Get() error {
+	num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]syscall.Statfs_t, num)
+
+	_, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	fslist := make([]FileSystem, 0, num)
+
+	for i := 0; i < num; i++ {
+		fs := FileSystem{}
+
+		fs.DirName = bytePtrToString(&buf[i].Mntonname[0])
+		fs.DevName = bytePtrToString(&buf[i].Mntfromname[0])
+		fs.SysTypeName = bytePtrToString(&buf[i].Fstypename[0])
+
+		fslist = append(fslist, fs)
+	}
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *ProcList) Get() error {
+	n := C.proc_listpids(C.PROC_ALL_PIDS, 0, nil, 0)
+	if n <= 0 {
+		return syscall.EINVAL
+	}
+	buf := make([]byte, n)
+	n = C.proc_listpids(C.PROC_ALL_PIDS, 0, unsafe.Pointer(&buf[0]), n)
+	if n <= 0 {
+		return syscall.ENOMEM
+	}
+
+	var pid int32
+	num := int(n) / binary.Size(pid)
+	list := make([]int, 0, num)
+	bbuf := bytes.NewBuffer(buf)
+
+	for i := 0; i < num; i++ {
+		if err := binary.Read(bbuf, binary.LittleEndian, &pid); err != nil {
+			return err
+		}
+		if pid == 0 {
+			continue
+		}
+
+		list = append(list, int(pid))
+	}
+
+	self.List = list
+
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.Name = C.GoString(&info.pbsd.pbi_comm[0])
+
+	switch info.pbsd.pbi_status {
+	case C.SIDL:
+		self.State = RunStateIdle
+	case C.SRUN:
+		self.State = RunStateRun
+	case C.SSLEEP:
+		self.State = RunStateSleep
+	case C.SSTOP:
+		self.State = RunStateStop
+	case C.SZOMB:
+		self.State = RunStateZombie
+	default:
+		self.State = RunStateUnknown
+	}
+
+	self.Ppid = int(info.pbsd.pbi_ppid)
+
+	self.Pgid = int(info.pbsd.pbi_pgid)
+
+	self.Tty = int(info.pbsd.e_tdev)
+
+	self.Priority = int(info.ptinfo.pti_priority)
+
+	self.Nice = int(info.pbsd.pbi_nice)
+
+	// Get process username. Fallback to UID if username is not available.
+	uid := strconv.Itoa(int(info.pbsd.pbi_uid))
+	user, err := user.LookupId(uid)
+	if err == nil && user.Username != "" {
+		self.Username = user.Username
+	} else {
+		self.Username = uid
+	}
+
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.Size = uint64(info.ptinfo.pti_virtual_size)
+	self.Resident = uint64(info.ptinfo.pti_resident_size)
+	self.PageFaults = uint64(info.ptinfo.pti_faults)
+
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	info := C.struct_proc_taskallinfo{}
+
+	if err := task_info(pid, &info); err != nil {
+		return err
+	}
+
+	self.User =
+		uint64(info.ptinfo.pti_total_user) / uint64(time.Millisecond)
+
+	self.Sys =
+		uint64(info.ptinfo.pti_total_system) / uint64(time.Millisecond)
+
+	self.Total = self.User + self.Sys
+
+	self.StartTime = (uint64(info.pbsd.pbi_start_tvsec) * 1000) +
+		(uint64(info.pbsd.pbi_start_tvusec) / 1000)
+
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	var args []string
+
+	argv := func(arg string) {
+		args = append(args, arg)
+	}
+
+	err := kern_procargs(pid, nil, argv, nil)
+
+	self.List = args
+
+	return err
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	if self.Vars == nil {
+		self.Vars = map[string]string{}
+	}
+
+	env := func(k, v string) {
+		self.Vars[k] = v
+	}
+
+	return kern_procargs(pid, nil, nil, env)
+}
+
+func (self *ProcExe) Get(pid int) error {
+	exe := func(arg string) {
+		self.Name = arg
+	}
+
+	return kern_procargs(pid, exe, nil, nil)
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+// wrapper around sysctl KERN_PROCARGS2
+// callbacks params are optional,
+// up to the caller as to which pieces of data they want
+func kern_procargs(pid int,
+	exe func(string),
+	argv func(string),
+	env func(string, string)) error {
+
+	mib := []C.int{C.CTL_KERN, C.KERN_PROCARGS2, C.int(pid)}
+	argmax := uintptr(C.ARG_MAX)
+	buf := make([]byte, argmax)
+	err := sysctl(mib, &buf[0], &argmax, nil, 0)
+	if err != nil {
+		return nil
+	}
+
+	bbuf := bytes.NewBuffer(buf)
+	bbuf.Truncate(int(argmax))
+
+	var argc int32
+	binary.Read(bbuf, binary.LittleEndian, &argc)
+
+	path, err := bbuf.ReadBytes(0)
+	if err != nil {
+		return fmt.Errorf("Error reading the argv[0]: %v", err)
+	}
+	if exe != nil {
+		exe(string(chop(path)))
+	}
+
+	// skip trailing \0's
+	for {
+		c, err := bbuf.ReadByte()
+		if err != nil {
+			return fmt.Errorf("Error skipping nils: %v", err)
+		}
+		if c != 0 {
+			bbuf.UnreadByte()
+			break // start of argv[0]
+		}
+	}
+
+	for i := 0; i < int(argc); i++ {
+		arg, err := bbuf.ReadBytes(0)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("Error reading args: %v", err)
+		}
+		if argv != nil {
+			argv(string(chop(arg)))
+		}
+	}
+
+	if env == nil {
+		return nil
+	}
+
+	delim := []byte{61} // "="
+
+	for {
+		line, err := bbuf.ReadBytes(0)
+		if err == io.EOF || line[0] == 0 {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("Error reading args: %v", err)
+		}
+		pair := bytes.SplitN(chop(line), delim, 2)
+
+		if len(pair) != 2 {
+			return fmt.Errorf("Error reading process information for PID: %d", pid)
+		}
+
+		env(string(pair[0]), string(pair[1]))
+	}
+
+	return nil
+}
+
+// XXX copied from zsyscall_darwin_amd64.go
+func sysctl(mib []C.int, old *byte, oldlen *uintptr,
+	new *byte, newlen uintptr) (err error) {
+	var p0 unsafe.Pointer
+	p0 = unsafe.Pointer(&mib[0])
+	_, _, e1 := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p0),
+		uintptr(len(mib)),
+		uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)),
+		uintptr(unsafe.Pointer(new)), uintptr(newlen))
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func vm_info(vmstat *C.vm_statistics_data_t) error {
+	var count C.mach_msg_type_number_t = C.HOST_VM_INFO_COUNT
+
+	status := C.host_statistics(
+		C.host_t(C.mach_host_self()),
+		C.HOST_VM_INFO,
+		C.host_info_t(unsafe.Pointer(vmstat)),
+		&count)
+
+	if status != C.KERN_SUCCESS {
+		return fmt.Errorf("host_statistics=%d", status)
+	}
+
+	return nil
+}
+
+// generic Sysctl buffer unmarshalling
+func sysctlbyname(name string, data interface{}) (err error) {
+	val, err := syscall.Sysctl(name)
+	if err != nil {
+		return err
+	}
+
+	buf := []byte(val)
+
+	switch v := data.(type) {
+	case *uint64:
+		*v = *(*uint64)(unsafe.Pointer(&buf[0]))
+		return
+	}
+
+	bbuf := bytes.NewBuffer([]byte(val))
+	return binary.Read(bbuf, binary.LittleEndian, data)
+}
+
+func task_info(pid int, info *C.struct_proc_taskallinfo) error {
+	size := C.int(unsafe.Sizeof(*info))
+	ptr := unsafe.Pointer(info)
+
+	n := C.proc_pidinfo(C.int(pid), C.PROC_PIDTASKALLINFO, 0, ptr, size)
+	if n != size {
+		return fmt.Errorf("Could not read process info for pid %d", pid)
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_format.go b/vendor/github.com/elastic/gosigar/sigar_format.go
new file mode 100644
index 0000000000..ac56c9873c
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_format.go
@@ -0,0 +1,126 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+// Go version of apr_strfsize
+func FormatSize(size uint64) string {
+	ord := []string{"K", "M", "G", "T", "P", "E"}
+	o := 0
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+
+	if size < 973 {
+		fmt.Fprintf(w, "%3d ", size)
+		w.Flush()
+		return buf.String()
+	}
+
+	for {
+		remain := size & 1023
+		size >>= 10
+
+		if size >= 973 {
+			o++
+			continue
+		}
+
+		if size < 9 || (size == 9 && remain < 973) {
+			remain = ((remain * 5) + 256) / 512
+			if remain >= 10 {
+				size++
+				remain = 0
+			}
+
+			fmt.Fprintf(w, "%d.%d%s", size, remain, ord[o])
+			break
+		}
+
+		if remain >= 512 {
+			size++
+		}
+
+		fmt.Fprintf(w, "%3d%s", size, ord[o])
+		break
+	}
+
+	w.Flush()
+	return buf.String()
+}
+
+func FormatPercent(percent float64) string {
+	return strconv.FormatFloat(percent, 'f', -1, 64) + "%"
+}
+
+func (self *FileSystemUsage) UsePercent() float64 {
+	b_used := (self.Total - self.Free) / 1024
+	b_avail := self.Avail / 1024
+	utotal := b_used + b_avail
+	used := b_used
+
+	if utotal != 0 {
+		u100 := used * 100
+		pct := u100 / utotal
+		if u100%utotal != 0 {
+			pct += 1
+		}
+		return (float64(pct) / float64(100)) * 100.0
+	}
+
+	return 0.0
+}
+
+func (self *Uptime) Format() string {
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+	uptime := uint64(self.Length)
+
+	days := uptime / (60 * 60 * 24)
+
+	if days != 0 {
+		s := ""
+		if days > 1 {
+			s = "s"
+		}
+		fmt.Fprintf(w, "%d day%s, ", days, s)
+	}
+
+	minutes := uptime / 60
+	hours := minutes / 60
+	hours %= 24
+	minutes %= 60
+
+	fmt.Fprintf(w, "%2d:%02d", hours, minutes)
+
+	w.Flush()
+	return buf.String()
+}
+
+func (self *ProcTime) FormatStartTime() string {
+	if self.StartTime == 0 {
+		return "00:00"
+	}
+	start := time.Unix(int64(self.StartTime)/1000, 0)
+	format := "Jan02"
+	if time.Since(start).Seconds() < (60 * 60 * 24) {
+		format = "15:04"
+	}
+	return start.Format(format)
+}
+
+func (self *ProcTime) FormatTotal() string {
+	t := self.Total / 1000
+	ss := t % 60
+	t /= 60
+	mm := t % 60
+	t /= 60
+	hh := t % 24
+	return fmt.Sprintf("%02d:%02d:%02d", hh, mm, ss)
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_freebsd.go b/vendor/github.com/elastic/gosigar/sigar_freebsd.go
new file mode 100644
index 0000000000..9b2af639b6
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_freebsd.go
@@ -0,0 +1,113 @@
+// Copied and modified from sigar_linux.go.
+
+package gosigar
+
+import (
+	"io/ioutil"
+	"runtime"
+	"strconv"
+	"strings"
+	"unsafe"
+)
+
+/*
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+*/
+import "C"
+
+func init() {
+	system.ticks = uint64(C.sysconf(C._SC_CLK_TCK))
+
+	Procd = "/compat/linux/proc"
+
+	getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+	return Procd + "/mtab"
+}
+
+func (self *Uptime) Get() error {
+	ts := C.struct_timespec{}
+
+	if _, err := C.clock_gettime(C.CLOCK_UPTIME, &ts); err != nil {
+		return err
+	}
+
+	self.Length = float64(ts.tv_sec) + 1e-9*float64(ts.tv_nsec)
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	val := C.uint32_t(0)
+	sc := C.size_t(4)
+
+	name := C.CString("kern.openfiles")
+	_, err := C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+	C.free(unsafe.Pointer(name))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(val)
+
+	name = C.CString("kern.maxfiles")
+	_, err = C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+	C.free(unsafe.Pointer(name))
+	if err != nil {
+		return err
+	}
+	self.Max = uint64(val)
+
+	self.Unused = self.Max - self.Open
+
+	return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	err := readFile("/proc/"+strconv.Itoa(pid)+"/rlimit", func(line string) bool {
+		if strings.HasPrefix(line, "nofile") {
+			fields := strings.Fields(line)
+			if len(fields) == 3 {
+				self.SoftLimit, _ = strconv.ParseUint(fields[1], 10, 64)
+				self.HardLimit, _ = strconv.ParseUint(fields[2], 10, 64)
+			}
+			return false
+		}
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	// linprocfs only provides this information for this process (self).
+	fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(len(fds))
+
+	return nil
+}
+
+func (self *HugeTLBPages) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+	fields := strings.Fields(line)
+
+	self.User, _ = strtoull(fields[1])
+	self.Nice, _ = strtoull(fields[2])
+	self.Sys, _ = strtoull(fields[3])
+	self.Idle, _ = strtoull(fields[4])
+	return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_interface.go b/vendor/github.com/elastic/gosigar/sigar_interface.go
new file mode 100644
index 0000000000..df79ae08d2
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_interface.go
@@ -0,0 +1,207 @@
+package gosigar
+
+import (
+	"time"
+)
+
+type ErrNotImplemented struct {
+	OS string
+}
+
+func (e ErrNotImplemented) Error() string {
+	return "not implemented on " + e.OS
+}
+
+func IsNotImplemented(err error) bool {
+	switch err.(type) {
+	case ErrNotImplemented, *ErrNotImplemented:
+		return true
+	default:
+		return false
+	}
+}
+
+type Sigar interface {
+	CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{})
+	GetLoadAverage() (LoadAverage, error)
+	GetMem() (Mem, error)
+	GetSwap() (Swap, error)
+	GetHugeTLBPages(HugeTLBPages, error)
+	GetFileSystemUsage(string) (FileSystemUsage, error)
+	GetFDUsage() (FDUsage, error)
+	GetRusage(who int) (Rusage, error)
+}
+
+type Cpu struct {
+	User    uint64
+	Nice    uint64
+	Sys     uint64
+	Idle    uint64
+	Wait    uint64
+	Irq     uint64
+	SoftIrq uint64
+	Stolen  uint64
+}
+
+func (cpu *Cpu) Total() uint64 {
+	return cpu.User + cpu.Nice + cpu.Sys + cpu.Idle +
+		cpu.Wait + cpu.Irq + cpu.SoftIrq + cpu.Stolen
+}
+
+func (cpu Cpu) Delta(other Cpu) Cpu {
+	return Cpu{
+		User:    cpu.User - other.User,
+		Nice:    cpu.Nice - other.Nice,
+		Sys:     cpu.Sys - other.Sys,
+		Idle:    cpu.Idle - other.Idle,
+		Wait:    cpu.Wait - other.Wait,
+		Irq:     cpu.Irq - other.Irq,
+		SoftIrq: cpu.SoftIrq - other.SoftIrq,
+		Stolen:  cpu.Stolen - other.Stolen,
+	}
+}
+
+type LoadAverage struct {
+	One, Five, Fifteen float64
+}
+
+type Uptime struct {
+	Length float64
+}
+
+type Mem struct {
+	Total      uint64
+	Used       uint64
+	Free       uint64
+	ActualFree uint64
+	ActualUsed uint64
+}
+
+type Swap struct {
+	Total uint64
+	Used  uint64
+	Free  uint64
+}
+
+type HugeTLBPages struct {
+	Total              uint64
+	Free               uint64
+	Reserved           uint64
+	Surplus            uint64
+	DefaultSize        uint64
+	TotalAllocatedSize uint64
+}
+
+type CpuList struct {
+	List []Cpu
+}
+
+type FDUsage struct {
+	Open   uint64
+	Unused uint64
+	Max    uint64
+}
+
+type FileSystem struct {
+	DirName     string
+	DevName     string
+	TypeName    string
+	SysTypeName string
+	Options     string
+	Flags       uint32
+}
+
+type FileSystemList struct {
+	List []FileSystem
+}
+
+type FileSystemUsage struct {
+	Total     uint64
+	Used      uint64
+	Free      uint64
+	Avail     uint64
+	Files     uint64
+	FreeFiles uint64
+}
+
+type ProcList struct {
+	List []int
+}
+
+type RunState byte
+
+const (
+	RunStateSleep   = 'S'
+	RunStateRun     = 'R'
+	RunStateStop    = 'T'
+	RunStateZombie  = 'Z'
+	RunStateIdle    = 'D'
+	RunStateUnknown = '?'
+)
+
+type ProcState struct {
+	Name      string
+	Username  string
+	State     RunState
+	Ppid      int
+	Pgid      int
+	Tty       int
+	Priority  int
+	Nice      int
+	Processor int
+}
+
+type ProcMem struct {
+	Size        uint64
+	Resident    uint64
+	Share       uint64
+	MinorFaults uint64
+	MajorFaults uint64
+	PageFaults  uint64
+}
+
+type ProcTime struct {
+	StartTime uint64
+	User      uint64
+	Sys       uint64
+	Total     uint64
+}
+
+type ProcArgs struct {
+	List []string
+}
+
+type ProcEnv struct {
+	Vars map[string]string
+}
+
+type ProcExe struct {
+	Name string
+	Cwd  string
+	Root string
+}
+
+type ProcFDUsage struct {
+	Open      uint64
+	SoftLimit uint64
+	HardLimit uint64
+}
+
+type Rusage struct {
+	Utime    time.Duration
+	Stime    time.Duration
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_linux.go b/vendor/github.com/elastic/gosigar/sigar_linux.go
new file mode 100644
index 0000000000..09f2e30b2f
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_linux.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+func init() {
+	system.ticks = 100 // C.sysconf(C._SC_CLK_TCK)
+
+	Procd = "/proc"
+
+	getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+	return "/etc/mtab"
+}
+
+func (self *Uptime) Get() error {
+	sysinfo := syscall.Sysinfo_t{}
+
+	if err := syscall.Sysinfo(&sysinfo); err != nil {
+		return err
+	}
+
+	self.Length = float64(sysinfo.Uptime)
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return readFile(Procd+"/sys/fs/file-nr", func(line string) bool {
+		fields := strings.Fields(line)
+		if len(fields) == 3 {
+			self.Open, _ = strconv.ParseUint(fields[0], 10, 64)
+			self.Unused, _ = strconv.ParseUint(fields[1], 10, 64)
+			self.Max, _ = strconv.ParseUint(fields[2], 10, 64)
+		}
+		return false
+	})
+}
+
+func (self *HugeTLBPages) Get() error {
+	table, err := parseMeminfo()
+	if err != nil {
+		return err
+	}
+
+	self.Total, _ = table["HugePages_Total"]
+	self.Free, _ = table["HugePages_Free"]
+	self.Reserved, _ = table["HugePages_Rsvd"]
+	self.Surplus, _ = table["HugePages_Surp"]
+	self.DefaultSize, _ = table["Hugepagesize"]
+
+	if totalSize, found := table["Hugetlb"]; found {
+		self.TotalAllocatedSize = totalSize
+	} else {
+		// If Hugetlb is not present, or huge pages of different sizes
+		// are used, this figure can be unaccurate.
+		// TODO (jsoriano): Extract information from /sys/kernel/mm/hugepages too
+		self.TotalAllocatedSize = (self.Total - self.Free + self.Reserved) * self.DefaultSize
+	}
+
+	return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	err := readFile(procFileName(pid, "limits"), func(line string) bool {
+		if strings.HasPrefix(line, "Max open files") {
+			fields := strings.Fields(line)
+			if len(fields) == 6 {
+				self.SoftLimit, _ = strconv.ParseUint(fields[3], 10, 64)
+				self.HardLimit, _ = strconv.ParseUint(fields[4], 10, 64)
+			}
+			return false
+		}
+		return true
+	})
+	if err != nil {
+		return err
+	}
+	fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+	if err != nil {
+		return err
+	}
+	self.Open = uint64(len(fds))
+	return nil
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+	fields := strings.Fields(line)
+
+	self.User, _ = strtoull(fields[1])
+	self.Nice, _ = strtoull(fields[2])
+	self.Sys, _ = strtoull(fields[3])
+	self.Idle, _ = strtoull(fields[4])
+	self.Wait, _ = strtoull(fields[5])
+	self.Irq, _ = strtoull(fields[6])
+	self.SoftIrq, _ = strtoull(fields[7])
+	self.Stolen, _ = strtoull(fields[8])
+
+	return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_linux_common.go b/vendor/github.com/elastic/gosigar/sigar_linux_common.go
new file mode 100644
index 0000000000..7ca6497622
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_linux_common.go
@@ -0,0 +1,482 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build freebsd linux
+
+package gosigar
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+var system struct {
+	ticks uint64
+	btime uint64
+}
+
+var Procd string
+
+func getLinuxBootTime() {
+	// grab system boot time
+	readFile(Procd+"/stat", func(line string) bool {
+		if strings.HasPrefix(line, "btime") {
+			system.btime, _ = strtoull(line[6:])
+			return false // stop reading
+		}
+		return true
+	})
+}
+
+func (self *LoadAverage) Get() error {
+	line, err := ioutil.ReadFile(Procd + "/loadavg")
+	if err != nil {
+		return nil
+	}
+
+	fields := strings.Fields(string(line))
+
+	self.One, _ = strconv.ParseFloat(fields[0], 64)
+	self.Five, _ = strconv.ParseFloat(fields[1], 64)
+	self.Fifteen, _ = strconv.ParseFloat(fields[2], 64)
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+
+	table, err := parseMeminfo()
+	if err != nil {
+		return err
+	}
+
+	self.Total, _ = table["MemTotal"]
+	self.Free, _ = table["MemFree"]
+	buffers, _ := table["Buffers"]
+	cached, _ := table["Cached"]
+
+	if available, ok := table["MemAvailable"]; ok {
+		// MemAvailable is in /proc/meminfo (kernel 3.14+)
+		self.ActualFree = available
+	} else {
+		self.ActualFree = self.Free + buffers + cached
+	}
+
+	self.Used = self.Total - self.Free
+	self.ActualUsed = self.Total - self.ActualFree
+
+	return nil
+}
+
+func (self *Swap) Get() error {
+
+	table, err := parseMeminfo()
+	if err != nil {
+		return err
+	}
+	self.Total, _ = table["SwapTotal"]
+	self.Free, _ = table["SwapFree"]
+
+	self.Used = self.Total - self.Free
+	return nil
+}
+
+func (self *Cpu) Get() error {
+	return readFile(Procd+"/stat", func(line string) bool {
+		if len(line) > 4 && line[0:4] == "cpu " {
+			parseCpuStat(self, line)
+			return false
+		}
+		return true
+
+	})
+}
+
+func (self *CpuList) Get() error {
+	capacity := len(self.List)
+	if capacity == 0 {
+		capacity = 4
+	}
+	list := make([]Cpu, 0, capacity)
+
+	err := readFile(Procd+"/stat", func(line string) bool {
+		if len(line) > 3 && line[0:3] == "cpu" && line[3] != ' ' {
+			cpu := Cpu{}
+			parseCpuStat(&cpu, line)
+			list = append(list, cpu)
+		}
+		return true
+	})
+
+	self.List = list
+
+	return err
+}
+
+func (self *FileSystemList) Get() error {
+	capacity := len(self.List)
+	if capacity == 0 {
+		capacity = 10
+	}
+	fslist := make([]FileSystem, 0, capacity)
+
+	err := readFile(getMountTableFileName(), func(line string) bool {
+		fields := strings.Fields(line)
+
+		fs := FileSystem{}
+		fs.DevName = fields[0]
+		fs.DirName = fields[1]
+		fs.SysTypeName = fields[2]
+		fs.Options = fields[3]
+
+		fslist = append(fslist, fs)
+
+		return true
+	})
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *ProcList) Get() error {
+	dir, err := os.Open(Procd)
+	if err != nil {
+		return err
+	}
+	defer dir.Close()
+
+	const readAllDirnames = -1 // see os.File.Readdirnames doc
+
+	names, err := dir.Readdirnames(readAllDirnames)
+	if err != nil {
+		return err
+	}
+
+	capacity := len(names)
+	list := make([]int, 0, capacity)
+
+	for _, name := range names {
+		if name[0] < '0' || name[0] > '9' {
+			continue
+		}
+		pid, err := strconv.Atoi(name)
+		if err == nil {
+			list = append(list, pid)
+		}
+	}
+
+	self.List = list
+
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	data, err := readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	// Extract the comm value with is surrounded by parentheses.
+	lIdx := bytes.Index(data, []byte("("))
+	rIdx := bytes.LastIndex(data, []byte(")"))
+	if lIdx < 0 || rIdx < 0 || lIdx >= rIdx || rIdx+2 >= len(data) {
+		return fmt.Errorf("failed to extract comm for pid %d from '%v'", pid, string(data))
+	}
+	self.Name = string(data[lIdx+1 : rIdx])
+
+	// Extract the rest of the fields that we are interested in.
+	fields := bytes.Fields(data[rIdx+2:])
+	if len(fields) <= 36 {
+		return fmt.Errorf("expected more stat fields for pid %d from '%v'", pid, string(data))
+	}
+
+	interests := bytes.Join([][]byte{
+		fields[0],  // state
+		fields[1],  // ppid
+		fields[2],  // pgrp
+		fields[4],  // tty_nr
+		fields[15], // priority
+		fields[16], // nice
+		fields[36], // processor (last processor executed on)
+	}, []byte(" "))
+
+	var state string
+	_, err = fmt.Fscan(bytes.NewBuffer(interests),
+		&state,
+		&self.Ppid,
+		&self.Pgid,
+		&self.Tty,
+		&self.Priority,
+		&self.Nice,
+		&self.Processor,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to parse stat fields for pid %d from '%v': %v", pid, string(data), err)
+	}
+	self.State = RunState(state[0])
+
+	// Read /proc/[pid]/status to get the uid, then lookup uid to get username.
+	status, err := getProcStatus(pid)
+	if err != nil {
+		return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+	}
+	uids, err := getUIDs(status)
+	if err != nil {
+		return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+	}
+	user, err := user.LookupId(uids[0])
+	if err == nil {
+		self.Username = user.Username
+	} else {
+		self.Username = uids[0]
+	}
+
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	contents, err := readProcFile(pid, "statm")
+	if err != nil {
+		return err
+	}
+
+	fields := strings.Fields(string(contents))
+
+	size, _ := strtoull(fields[0])
+	self.Size = size << 12
+
+	rss, _ := strtoull(fields[1])
+	self.Resident = rss << 12
+
+	share, _ := strtoull(fields[2])
+	self.Share = share << 12
+
+	contents, err = readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	fields = strings.Fields(string(contents))
+
+	self.MinorFaults, _ = strtoull(fields[10])
+	self.MajorFaults, _ = strtoull(fields[12])
+	self.PageFaults = self.MinorFaults + self.MajorFaults
+
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	contents, err := readProcFile(pid, "stat")
+	if err != nil {
+		return err
+	}
+
+	fields := strings.Fields(string(contents))
+
+	user, _ := strtoull(fields[13])
+	sys, _ := strtoull(fields[14])
+	// convert to millis
+	self.User = user * (1000 / system.ticks)
+	self.Sys = sys * (1000 / system.ticks)
+	self.Total = self.User + self.Sys
+
+	// convert to millis
+	self.StartTime, _ = strtoull(fields[21])
+	self.StartTime /= system.ticks
+	self.StartTime += system.btime
+	self.StartTime *= 1000
+
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	contents, err := readProcFile(pid, "cmdline")
+	if err != nil {
+		return err
+	}
+
+	bbuf := bytes.NewBuffer(contents)
+
+	var args []string
+
+	for {
+		arg, err := bbuf.ReadBytes(0)
+		if err == io.EOF {
+			break
+		}
+		args = append(args, string(chop(arg)))
+	}
+
+	self.List = args
+
+	return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	contents, err := readProcFile(pid, "environ")
+	if err != nil {
+		return err
+	}
+
+	if self.Vars == nil {
+		self.Vars = map[string]string{}
+	}
+
+	pairs := bytes.Split(contents, []byte{0})
+	for _, kv := range pairs {
+		parts := bytes.SplitN(kv, []byte{'='}, 2)
+		if len(parts) != 2 {
+			continue
+		}
+
+		key := string(bytes.TrimSpace(parts[0]))
+		if key == "" {
+			continue
+		}
+
+		self.Vars[key] = string(bytes.TrimSpace(parts[1]))
+	}
+
+	return nil
+}
+
+func (self *ProcExe) Get(pid int) error {
+	fields := map[string]*string{
+		"exe":  &self.Name,
+		"cwd":  &self.Cwd,
+		"root": &self.Root,
+	}
+
+	for name, field := range fields {
+		val, err := os.Readlink(procFileName(pid, name))
+
+		if err != nil {
+			return err
+		}
+
+		*field = val
+	}
+
+	return nil
+}
+
+func parseMeminfo() (map[string]uint64, error) {
+	table := map[string]uint64{}
+
+	err := readFile(Procd+"/meminfo", func(line string) bool {
+		fields := strings.Split(line, ":")
+
+		if len(fields) != 2 {
+			return true // skip on errors
+		}
+
+		valueUnit := strings.Fields(fields[1])
+		value, err := strtoull(valueUnit[0])
+		if err != nil {
+			return true // skip on errors
+		}
+
+		if len(valueUnit) > 1 && valueUnit[1] == "kB" {
+			value *= 1024
+		}
+		table[fields[0]] = value
+
+		return true
+	})
+	return table, err
+}
+
+func readFile(file string, handler func(string) bool) error {
+	contents, err := ioutil.ReadFile(file)
+	if err != nil {
+		return err
+	}
+
+	reader := bufio.NewReader(bytes.NewBuffer(contents))
+
+	for {
+		line, _, err := reader.ReadLine()
+		if err == io.EOF {
+			break
+		}
+		if !handler(string(line)) {
+			break
+		}
+	}
+
+	return nil
+}
+
+func strtoull(val string) (uint64, error) {
+	return strconv.ParseUint(val, 10, 64)
+}
+
+func procFileName(pid int, name string) string {
+	return Procd + "/" + strconv.Itoa(pid) + "/" + name
+}
+
+func readProcFile(pid int, name string) (content []byte, err error) {
+	path := procFileName(pid, name)
+
+	// Panics have been reported when reading proc files, let's recover and
+	// report the path if this happens
+	// See https://github.com/elastic/beats/issues/6692
+	defer func() {
+		if r := recover(); r != nil {
+			content = nil
+			err = fmt.Errorf("recovered panic when reading proc file '%s': %v", path, r)
+		}
+	}()
+	contents, err := ioutil.ReadFile(path)
+
+	if err != nil {
+		if perr, ok := err.(*os.PathError); ok {
+			if perr.Err == syscall.ENOENT {
+				return nil, syscall.ESRCH
+			}
+		}
+	}
+
+	return contents, err
+}
+
+// getProcStatus reads /proc/[pid]/status which contains process status
+// information in human readable form.
+func getProcStatus(pid int) (map[string]string, error) {
+	status := make(map[string]string, 42)
+	path := filepath.Join(Procd, strconv.Itoa(pid), "status")
+	err := readFile(path, func(line string) bool {
+		fields := strings.SplitN(line, ":", 2)
+		if len(fields) == 2 {
+			status[fields[0]] = strings.TrimSpace(fields[1])
+		}
+
+		return true
+	})
+	return status, err
+}
+
+// getUIDs reads the "Uid" value from status and splits it into four values --
+// real, effective, saved set, and  file system UIDs.
+func getUIDs(status map[string]string) ([]string, error) {
+	uidLine, ok := status["Uid"]
+	if !ok {
+		return nil, fmt.Errorf("Uid not found in proc status")
+	}
+
+	uidStrs := strings.Fields(uidLine)
+	if len(uidStrs) != 4 {
+		return nil, fmt.Errorf("Uid line ('%s') did not contain four values", uidLine)
+	}
+
+	return uidStrs, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_openbsd.go b/vendor/github.com/elastic/gosigar/sigar_openbsd.go
new file mode 100644
index 0000000000..e4371b8b68
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_openbsd.go
@@ -0,0 +1,426 @@
+// Copyright (c) 2016 Jasper Lievisse Adriaanse .
+
+// +build openbsd
+
+package gosigar
+
+/*
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+#include 
+*/
+import "C"
+
+//import "github.com/davecgh/go-spew/spew"
+
+import (
+	"runtime"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+type Uvmexp struct {
+	pagesize           uint32
+	pagemask           uint32
+	pageshift          uint32
+	npages             uint32
+	free               uint32
+	active             uint32
+	inactive           uint32
+	paging             uint32
+	wired              uint32
+	zeropages          uint32
+	reserve_pagedaemon uint32
+	reserve_kernel     uint32
+	anonpages          uint32
+	vnodepages         uint32
+	vtextpages         uint32
+	freemin            uint32
+	freetarg           uint32
+	inactarg           uint32
+	wiredmax           uint32
+	anonmin            uint32
+	vtextmin           uint32
+	vnodemin           uint32
+	anonminpct         uint32
+	vtextmi            uint32
+	npct               uint32
+	vnodeminpct        uint32
+	nswapdev           uint32
+	swpages            uint32
+	swpginuse          uint32
+	swpgonly           uint32
+	nswget             uint32
+	nanon              uint32
+	nanonneeded        uint32
+	nfreeanon          uint32
+	faults             uint32
+	traps              uint32
+	intrs              uint32
+	swtch              uint32
+	softs              uint32
+	syscalls           uint32
+	pageins            uint32
+	obsolete_swapins   uint32
+	obsolete_swapouts  uint32
+	pgswapin           uint32
+	pgswapout          uint32
+	forks              uint32
+	forks_ppwait       uint32
+	forks_sharevm      uint32
+	pga_zerohit        uint32
+	pga_zeromiss       uint32
+	zeroaborts         uint32
+	fltnoram           uint32
+	fltnoanon          uint32
+	fltpgwait          uint32
+	fltpgrele          uint32
+	fltrelck           uint32
+	fltrelckok         uint32
+	fltanget           uint32
+	fltanretry         uint32
+	fltamcopy          uint32
+	fltnamap           uint32
+	fltnomap           uint32
+	fltlget            uint32
+	fltget             uint32
+	flt_anon           uint32
+	flt_acow           uint32
+	flt_obj            uint32
+	flt_prcopy         uint32
+	flt_przero         uint32
+	pdwoke             uint32
+	pdrevs             uint32
+	pdswout            uint32
+	pdfreed            uint32
+	pdscans            uint32
+	pdanscan           uint32
+	pdobscan           uint32
+	pdreact            uint32
+	pdbusy             uint32
+	pdpageouts         uint32
+	pdpending          uint32
+	pddeact            uint32
+	pdreanon           uint32
+	pdrevnode          uint32
+	pdrevtext          uint32
+	fpswtch            uint32
+	kmapent            uint32
+}
+
+type Bcachestats struct {
+	numbufs        uint64
+	numbufpages    uint64
+	numdirtypages  uint64
+	numcleanpages  uint64
+	pendingwrites  uint64
+	pendingreads   uint64
+	numwrites      uint64
+	numreads       uint64
+	cachehits      uint64
+	busymapped     uint64
+	dmapages       uint64
+	highpages      uint64
+	delwribufs     uint64
+	kvaslots       uint64
+	kvaslots_avail uint64
+}
+
+type Swapent struct {
+	se_dev      C.dev_t
+	se_flags    int32
+	se_nblks    int32
+	se_inuse    int32
+	se_priority int32
+	sw_path     []byte
+}
+
+func (self *FileSystemList) Get() error {
+	num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]syscall.Statfs_t, num)
+
+	_, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+	if err != nil {
+		return err
+	}
+
+	fslist := make([]FileSystem, 0, num)
+
+	for i := 0; i < num; i++ {
+		fs := FileSystem{}
+
+		fs.DirName = bytePtrToString(&buf[i].F_mntonname[0])
+		fs.DevName = bytePtrToString(&buf[i].F_mntfromname[0])
+		fs.SysTypeName = bytePtrToString(&buf[i].F_fstypename[0])
+
+		fslist = append(fslist, fs)
+	}
+
+	self.List = fslist
+
+	return err
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	stat := syscall.Statfs_t{}
+	err := syscall.Statfs(path, &stat)
+	if err != nil {
+		return err
+	}
+
+	self.Total = uint64(stat.F_blocks) * uint64(stat.F_bsize)
+	self.Free = uint64(stat.F_bfree) * uint64(stat.F_bsize)
+	self.Avail = uint64(stat.F_bavail) * uint64(stat.F_bsize)
+	self.Used = self.Total - self.Free
+	self.Files = stat.F_files
+	self.FreeFiles = stat.F_ffree
+
+	return nil
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *LoadAverage) Get() error {
+	avg := []C.double{0, 0, 0}
+
+	C.getloadavg(&avg[0], C.int(len(avg)))
+
+	self.One = float64(avg[0])
+	self.Five = float64(avg[1])
+	self.Fifteen = float64(avg[2])
+
+	return nil
+}
+
+func (self *Uptime) Get() error {
+	tv := syscall.Timeval{}
+	mib := [2]int32{C.CTL_KERN, C.KERN_BOOTTIME}
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	// Now perform the actual sysctl(3) call, storing the result in tv
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&tv)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+	return nil
+}
+
+func (self *Mem) Get() error {
+	n := uintptr(0)
+
+	var uvmexp Uvmexp
+	mib := [2]int32{C.CTL_VM, C.VM_UVMEXP}
+	n = uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&uvmexp)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	var bcachestats Bcachestats
+	mib3 := [3]int32{C.CTL_VFS, C.VFS_GENERIC, C.VFS_BCACHESTAT}
+	n = uintptr(0)
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, uintptr(unsafe.Pointer(&bcachestats)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.Total = uint64(uvmexp.npages) << uvmexp.pageshift
+	self.Used = uint64(uvmexp.npages-uvmexp.free) << uvmexp.pageshift
+	self.Free = uint64(uvmexp.free) << uvmexp.pageshift
+
+	self.ActualFree = self.Free + (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+	self.ActualUsed = self.Used - (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+
+	return nil
+}
+
+func (self *Swap) Get() error {
+	nswap := C.swapctl(C.SWAP_NSWAP, unsafe.Pointer(uintptr(0)), 0)
+
+	// If there are no swap devices, nothing to do here.
+	if nswap == 0 {
+		return nil
+	}
+
+	swdev := make([]Swapent, nswap)
+
+	rnswap := C.swapctl(C.SWAP_STATS, unsafe.Pointer(&swdev[0]), nswap)
+	if rnswap == 0 {
+		return nil
+	}
+
+	for i := 0; i < int(nswap); i++ {
+		if swdev[i].se_flags&C.SWF_ENABLE == 2 {
+			self.Used = self.Used + uint64(swdev[i].se_inuse/(1024/C.DEV_BSIZE))
+			self.Total = self.Total + uint64(swdev[i].se_nblks/(1024/C.DEV_BSIZE))
+		}
+	}
+
+	self.Free = self.Total - self.Used
+
+	return nil
+}
+
+func (self *HugeTLBPages) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Cpu) Get() error {
+	load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+	mib := [2]int32{C.CTL_KERN, C.KERN_CPTIME}
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	self.User = uint64(load[0])
+	self.Nice = uint64(load[1])
+	self.Sys = uint64(load[2])
+	self.Irq = uint64(load[3])
+	self.Idle = uint64(load[4])
+
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	mib := [2]int32{C.CTL_HW, C.HW_NCPU}
+	var ncpu int
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	// Now perform the actual sysctl(3) call, storing the result in ncpu
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&ncpu)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+	self.List = make([]Cpu, ncpu)
+	for curcpu := range self.List {
+		sysctlCptime(ncpu, curcpu, &load)
+		fillCpu(&self.List[curcpu], load)
+	}
+
+	return nil
+}
+
+func (self *ProcList) Get() error {
+	return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcState) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+	return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Rusage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func fillCpu(cpu *Cpu, load [C.CPUSTATES]C.long) {
+	cpu.User = uint64(load[0])
+	cpu.Nice = uint64(load[1])
+	cpu.Sys = uint64(load[2])
+	cpu.Irq = uint64(load[3])
+	cpu.Idle = uint64(load[4])
+}
+
+func sysctlCptime(ncpu int, curcpu int, load *[C.CPUSTATES]C.long) error {
+	var mib []int32
+
+	// Use the correct mib based on the number of CPUs and fill out the
+	// current CPU number in case of SMP. (0 indexed cf. self.List)
+	if ncpu == 0 {
+		mib = []int32{C.CTL_KERN, C.KERN_CPTIME}
+	} else {
+		mib = []int32{C.CTL_KERN, C.KERN_CPTIME2, int32(curcpu)}
+	}
+
+	len := len(mib)
+
+	n := uintptr(0)
+	// First we determine how much memory we'll need to pass later on (via `n`)
+	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	_, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), uintptr(unsafe.Pointer(load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errno != 0 || n == 0 {
+		return nil
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_stub.go b/vendor/github.com/elastic/gosigar/sigar_stub.go
new file mode 100644
index 0000000000..de9565aec4
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_stub.go
@@ -0,0 +1,75 @@
+// +build !darwin,!freebsd,!linux,!openbsd,!windows
+
+package gosigar
+
+import (
+	"runtime"
+)
+
+func (c *Cpu) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (l *LoadAverage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (m *Mem) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (s *Swap) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (s *HugeTLBPages) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (f *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcTime) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *CpuList) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcState) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcExe) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcMem) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcFDUsage) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcEnv) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcList) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcArgs) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Rusage) Get(int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_unix.go b/vendor/github.com/elastic/gosigar/sigar_unix.go
new file mode 100644
index 0000000000..3f3a9f7ff2
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_unix.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build darwin freebsd linux
+
+package gosigar
+
+import (
+	"syscall"
+	"time"
+
+	"golang.org/x/sys/unix"
+)
+
+func (self *FileSystemUsage) Get(path string) error {
+	stat := syscall.Statfs_t{}
+	err := syscall.Statfs(path, &stat)
+	if err != nil {
+		return err
+	}
+
+	self.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
+	self.Free = uint64(stat.Bfree) * uint64(stat.Bsize)
+	self.Avail = uint64(stat.Bavail) * uint64(stat.Bsize)
+	self.Used = self.Total - self.Free
+	self.Files = stat.Files
+	self.FreeFiles = uint64(stat.Ffree)
+
+	return nil
+}
+
+func (r *Rusage) Get(who int) error {
+	ru, err := getResourceUsage(who)
+	if err != nil {
+		return err
+	}
+
+	uTime := convertRtimeToDur(ru.Utime)
+	sTime := convertRtimeToDur(ru.Stime)
+
+	r.Utime = uTime
+	r.Stime = sTime
+	r.Maxrss = int64(ru.Maxrss)
+	r.Ixrss = int64(ru.Ixrss)
+	r.Idrss = int64(ru.Idrss)
+	r.Isrss = int64(ru.Isrss)
+	r.Minflt = int64(ru.Minflt)
+	r.Majflt = int64(ru.Majflt)
+	r.Nswap = int64(ru.Nswap)
+	r.Inblock = int64(ru.Inblock)
+	r.Oublock = int64(ru.Oublock)
+	r.Msgsnd = int64(ru.Msgsnd)
+	r.Msgrcv = int64(ru.Msgrcv)
+	r.Nsignals = int64(ru.Nsignals)
+	r.Nvcsw = int64(ru.Nvcsw)
+	r.Nivcsw = int64(ru.Nivcsw)
+
+	return nil
+}
+
+func getResourceUsage(who int) (unix.Rusage, error) {
+	r := unix.Rusage{}
+	err := unix.Getrusage(who, &r)
+
+	return r, err
+}
+
+func convertRtimeToDur(t unix.Timeval) time.Duration {
+	return time.Duration(t.Nano())
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_util.go b/vendor/github.com/elastic/gosigar/sigar_util.go
new file mode 100644
index 0000000000..bf93b02b24
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_util.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"unsafe"
+)
+
+func bytePtrToString(ptr *int8) string {
+	bytes := (*[10000]byte)(unsafe.Pointer(ptr))
+
+	n := 0
+	for bytes[n] != 0 {
+		n++
+	}
+
+	return string(bytes[0:n])
+}
+
+func chop(buf []byte) []byte {
+	return buf[0 : len(buf)-1]
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_windows.go b/vendor/github.com/elastic/gosigar/sigar_windows.go
new file mode 100644
index 0000000000..c2b54d8d7f
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_windows.go
@@ -0,0 +1,441 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/StackExchange/wmi"
+	"github.com/elastic/gosigar/sys/windows"
+	"github.com/pkg/errors"
+)
+
+// Win32_Process represents a process on the Windows operating system. If
+// additional fields are added here (that match the Windows struct) they will
+// automatically be populated when calling getWin32Process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394372(v=vs.85).aspx
+type Win32_Process struct {
+	CommandLine string
+}
+
+// Win32_OperatingSystem WMI class represents a Windows-based operating system
+// installed on a computer.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394239(v=vs.85).aspx
+type Win32_OperatingSystem struct {
+	LastBootUpTime time.Time
+}
+
+var (
+	// version is Windows version of the host OS.
+	version = windows.GetWindowsVersion()
+
+	// processQueryLimitedInfoAccess is set to PROCESS_QUERY_INFORMATION for Windows
+	// 2003 and XP where PROCESS_QUERY_LIMITED_INFORMATION is unknown. For all newer
+	// OS versions it is set to PROCESS_QUERY_LIMITED_INFORMATION.
+	processQueryLimitedInfoAccess = windows.PROCESS_QUERY_LIMITED_INFORMATION
+
+	// bootTime is the time when the OS was last booted. This value may be nil
+	// on operating systems that do not support the WMI query used to obtain it.
+	bootTime     *time.Time
+	bootTimeLock sync.Mutex
+)
+
+func init() {
+	if !version.IsWindowsVistaOrGreater() {
+		// PROCESS_QUERY_LIMITED_INFORMATION cannot be used on 2003 or XP.
+		processQueryLimitedInfoAccess = syscall.PROCESS_QUERY_INFORMATION
+	}
+}
+
+func (self *LoadAverage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FDUsage) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcEnv) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Uptime) Get() error {
+	// Minimum supported OS is Windows Vista.
+	if !version.IsWindowsVistaOrGreater() {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	bootTimeLock.Lock()
+	defer bootTimeLock.Unlock()
+	if bootTime == nil {
+		os, err := getWin32OperatingSystem()
+		if err != nil {
+			return errors.Wrap(err, "failed to get boot time using WMI")
+		}
+		bootTime = &os.LastBootUpTime
+	}
+
+	self.Length = time.Since(*bootTime).Seconds()
+	return nil
+}
+
+func (self *Mem) Get() error {
+	memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+	if err != nil {
+		return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	self.Total = memoryStatusEx.TotalPhys
+	self.Free = memoryStatusEx.AvailPhys
+	self.Used = self.Total - self.Free
+	self.ActualFree = self.Free
+	self.ActualUsed = self.Used
+	return nil
+}
+
+func (self *Swap) Get() error {
+	memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+	if err != nil {
+		return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	self.Total = memoryStatusEx.TotalPageFile
+	self.Free = memoryStatusEx.AvailPageFile
+	self.Used = self.Total - self.Free
+	return nil
+}
+
+func (self *HugeTLBPages) Get() error {
+	return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Cpu) Get() error {
+	idle, kernel, user, err := windows.GetSystemTimes()
+	if err != nil {
+		return errors.Wrap(err, "GetSystemTimes failed")
+	}
+
+	// CPU times are reported in milliseconds by gosigar.
+	self.Idle = uint64(idle / time.Millisecond)
+	self.Sys = uint64(kernel / time.Millisecond)
+	self.User = uint64(user / time.Millisecond)
+	return nil
+}
+
+func (self *CpuList) Get() error {
+	cpus, err := windows.NtQuerySystemProcessorPerformanceInformation()
+	if err != nil {
+		return errors.Wrap(err, "NtQuerySystemProcessorPerformanceInformation failed")
+	}
+
+	self.List = make([]Cpu, 0, len(cpus))
+	for _, cpu := range cpus {
+		self.List = append(self.List, Cpu{
+			Idle: uint64(cpu.IdleTime / time.Millisecond),
+			Sys:  uint64(cpu.KernelTime / time.Millisecond),
+			User: uint64(cpu.UserTime / time.Millisecond),
+		})
+	}
+	return nil
+}
+
+func (self *FileSystemList) Get() error {
+	drives, err := windows.GetLogicalDriveStrings()
+	if err != nil {
+		return errors.Wrap(err, "GetLogicalDriveStrings failed")
+	}
+
+	for _, drive := range drives {
+		dt, err := windows.GetDriveType(drive)
+		if err != nil {
+			return errors.Wrapf(err, "GetDriveType failed")
+		}
+
+		self.List = append(self.List, FileSystem{
+			DirName:  drive,
+			DevName:  drive,
+			TypeName: dt.String(),
+		})
+	}
+	return nil
+}
+
+// Get retrieves a list of all process identifiers (PIDs) in the system.
+func (self *ProcList) Get() error {
+	pids, err := windows.EnumProcesses()
+	if err != nil {
+		return errors.Wrap(err, "EnumProcesses failed")
+	}
+
+	// Convert uint32 PIDs to int.
+	self.List = make([]int, 0, len(pids))
+	for _, pid := range pids {
+		self.List = append(self.List, int(pid))
+	}
+	return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+	var errs []error
+
+	var err error
+	self.Name, err = getProcName(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcName failed"))
+	}
+
+	self.State, err = getProcStatus(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcStatus failed"))
+	}
+
+	self.Ppid, err = getParentPid(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getParentPid failed"))
+	}
+
+	self.Username, err = getProcCredName(pid)
+	if err != nil {
+		errs = append(errs, errors.Wrap(err, "getProcCredName failed"))
+	}
+
+	if len(errs) > 0 {
+		errStrs := make([]string, 0, len(errs))
+		for _, e := range errs {
+			errStrs = append(errStrs, e.Error())
+		}
+		return errors.New(strings.Join(errStrs, "; "))
+	}
+	return nil
+}
+
+// getProcName returns the process name associated with the PID.
+func getProcName(pid int) (string, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	filename, err := windows.GetProcessImageFileName(handle)
+	if err != nil {
+		return "", errors.Wrapf(err, "GetProcessImageFileName failed for pid=%v", pid)
+	}
+
+	return filepath.Base(filename), nil
+}
+
+// getProcStatus returns the status of a process.
+func getProcStatus(pid int) (RunState, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	var exitCode uint32
+	err = syscall.GetExitCodeProcess(handle, &exitCode)
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "GetExitCodeProcess failed for pid=%v")
+	}
+
+	if exitCode == 259 { //still active
+		return RunStateRun, nil
+	}
+	return RunStateSleep, nil
+}
+
+// getParentPid returns the parent process ID of a process.
+func getParentPid(pid int) (int, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	procInfo, err := windows.NtQueryProcessBasicInformation(handle)
+	if err != nil {
+		return 0, errors.Wrapf(err, "NtQueryProcessBasicInformation failed for pid=%v", pid)
+	}
+
+	return int(procInfo.InheritedFromUniqueProcessID), nil
+}
+
+func getProcCredName(pid int) (string, error) {
+	handle, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	// Find process token via win32.
+	var token syscall.Token
+	err = syscall.OpenProcessToken(handle, syscall.TOKEN_QUERY, &token)
+	if err != nil {
+		return "", errors.Wrapf(err, "OpenProcessToken failed for pid=%v", pid)
+	}
+
+	// Find the token user.
+	tokenUser, err := token.GetTokenUser()
+	if err != nil {
+		return "", errors.Wrapf(err, "GetTokenInformation failed for pid=%v", pid)
+	}
+
+	// Close token to prevent handle leaks.
+	err = token.Close()
+	if err != nil {
+		return "", errors.Wrapf(err, "failed while closing process token handle for pid=%v", pid)
+	}
+
+	// Look up domain account by SID.
+	account, domain, _, err := tokenUser.User.Sid.LookupAccount("")
+	if err != nil {
+		sid, sidErr := tokenUser.User.Sid.String()
+		if sidErr != nil {
+			return "", errors.Wrapf(err, "failed while looking up account name for pid=%v", pid)
+		}
+		return "", errors.Wrapf(err, "failed while looking up account name for SID=%v of pid=%v", sid, pid)
+	}
+
+	return fmt.Sprintf(`%s\%s`, domain, account), nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess|windows.PROCESS_VM_READ, false, uint32(pid))
+	if err != nil {
+		return errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	counters, err := windows.GetProcessMemoryInfo(handle)
+	if err != nil {
+		return errors.Wrapf(err, "GetProcessMemoryInfo failed for pid=%v", pid)
+	}
+
+	self.Resident = uint64(counters.WorkingSetSize)
+	self.Size = uint64(counters.PrivateUsage)
+	return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+	cpu, err := getProcTimes(pid)
+	if err != nil {
+		return err
+	}
+
+	// Windows epoch times are expressed as time elapsed since midnight on
+	// January 1, 1601 at Greenwich, England. This converts the Filetime to
+	// unix epoch in milliseconds.
+	self.StartTime = uint64(cpu.CreationTime.Nanoseconds() / 1e6)
+
+	// Convert to millis.
+	self.User = uint64(windows.FiletimeToDuration(&cpu.UserTime).Nanoseconds() / 1e6)
+	self.Sys = uint64(windows.FiletimeToDuration(&cpu.KernelTime).Nanoseconds() / 1e6)
+	self.Total = self.User + self.Sys
+
+	return nil
+}
+
+func getProcTimes(pid int) (*syscall.Rusage, error) {
+	handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+	if err != nil {
+		return nil, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+	}
+	defer syscall.CloseHandle(handle)
+
+	var cpu syscall.Rusage
+	if err := syscall.GetProcessTimes(handle, &cpu.CreationTime, &cpu.ExitTime, &cpu.KernelTime, &cpu.UserTime); err != nil {
+		return nil, errors.Wrapf(err, "GetProcessTimes failed for pid=%v", pid)
+	}
+
+	return &cpu, nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+	// The minimum supported client for Win32_Process is Windows Vista.
+	if !version.IsWindowsVistaOrGreater() {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	process, err := getWin32Process(int32(pid))
+	if err != nil {
+		return errors.Wrapf(err, "ProcArgs failed for pid=%v", pid)
+	}
+
+	self.List = []string{process.CommandLine}
+	return nil
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+	freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, err := windows.GetDiskFreeSpaceEx(path)
+	if err != nil {
+		return errors.Wrap(err, "GetDiskFreeSpaceEx failed")
+	}
+
+	self.Total = totalNumberOfBytes
+	self.Free = totalNumberOfFreeBytes
+	self.Used = self.Total - self.Free
+	self.Avail = freeBytesAvailable
+	return nil
+}
+
+// getWin32Process gets information about the process with the given process ID.
+// It uses a WMI query to get the information from the local system.
+func getWin32Process(pid int32) (Win32_Process, error) {
+	var dst []Win32_Process
+	query := fmt.Sprintf("WHERE ProcessId = %d", pid)
+	q := wmi.CreateQuery(&dst, query)
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return Win32_Process{}, fmt.Errorf("could not get Win32_Process %s: %v", query, err)
+	}
+	if len(dst) < 1 {
+		return Win32_Process{}, fmt.Errorf("could not get Win32_Process %s: Process not found", query)
+	}
+	return dst[0], nil
+}
+
+func getWin32OperatingSystem() (Win32_OperatingSystem, error) {
+	var dst []Win32_OperatingSystem
+	q := wmi.CreateQuery(&dst, "")
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return Win32_OperatingSystem{}, errors.Wrap(err, "wmi query for Win32_OperatingSystem failed")
+	}
+	if len(dst) != 1 {
+		return Win32_OperatingSystem{}, errors.New("wmi query for Win32_OperatingSystem failed")
+	}
+	return dst[0], nil
+}
+
+func (self *Rusage) Get(who int) error {
+	if who != 0 {
+		return ErrNotImplemented{runtime.GOOS}
+	}
+
+	pid := os.Getpid()
+	cpu, err := getProcTimes(pid)
+	if err != nil {
+		return err
+	}
+
+	self.Utime = windows.FiletimeToDuration(&cpu.UserTime)
+	self.Stime = windows.FiletimeToDuration(&cpu.KernelTime)
+
+	return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/doc.go b/vendor/github.com/elastic/gosigar/sys/windows/doc.go
new file mode 100644
index 0000000000..dda57aa830
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/doc.go
@@ -0,0 +1,2 @@
+// Package windows contains various Windows system call.
+package windows
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go b/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go
new file mode 100644
index 0000000000..85de365e1a
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go
@@ -0,0 +1,132 @@
+// +build windows
+
+package windows
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"runtime"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/pkg/errors"
+)
+
+// On both 32-bit and 64-bit systems NtQuerySystemInformation expects the
+// size of SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION to be 48.
+const sizeofSystemProcessorPerformanceInformation = 48
+
+// ProcessBasicInformation is an equivalent representation of
+// PROCESS_BASIC_INFORMATION in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+type ProcessBasicInformation struct {
+	ExitStatus                   uint
+	PebBaseAddress               uintptr
+	AffinityMask                 uint
+	BasePriority                 uint
+	UniqueProcessID              uint
+	InheritedFromUniqueProcessID uint
+}
+
+// NtQueryProcessBasicInformation queries basic information about the process
+// associated with the given handle (provided by OpenProcess). It uses the
+// NtQueryInformationProcess function to collect the data.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+func NtQueryProcessBasicInformation(handle syscall.Handle) (ProcessBasicInformation, error) {
+	var processBasicInfo ProcessBasicInformation
+	processBasicInfoPtr := (*byte)(unsafe.Pointer(&processBasicInfo))
+	size := uint32(unsafe.Sizeof(processBasicInfo))
+	ntStatus, _ := _NtQueryInformationProcess(handle, 0, processBasicInfoPtr, size, nil)
+	if ntStatus != 0 {
+		return ProcessBasicInformation{}, errors.Errorf("NtQueryInformationProcess failed, NTSTATUS=0x%X", ntStatus)
+	}
+
+	return processBasicInfo, nil
+}
+
+// SystemProcessorPerformanceInformation contains CPU performance information
+// for a single CPU.
+type SystemProcessorPerformanceInformation struct {
+	IdleTime   time.Duration // Amount of time spent idle.
+	KernelTime time.Duration // Kernel time does NOT include time spent in idle.
+	UserTime   time.Duration // Amount of time spent executing in user mode.
+}
+
+// _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION is an equivalent representation of
+// SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION in the Windows API. This struct is
+// used internally with NtQuerySystemInformation call and is not exported. The
+// exported equivalent is SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+type _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION struct {
+	IdleTime   int64
+	KernelTime int64
+	UserTime   int64
+	Reserved1  [2]int64
+	Reserved2  uint32
+}
+
+// NtQuerySystemProcessorPerformanceInformation queries CPU performance
+// information for each CPU. It uses the NtQuerySystemInformation function to
+// collect the SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func NtQuerySystemProcessorPerformanceInformation() ([]SystemProcessorPerformanceInformation, error) {
+	// NTSTATUS code for success.
+	// https://msdn.microsoft.com/en-us/library/cc704588.aspx
+	const STATUS_SUCCESS = 0
+
+	// From the _SYSTEM_INFORMATION_CLASS enum.
+	// http://processhacker.sourceforge.net/doc/ntexapi_8h.html#ad5d815b48e8f4da1ef2eb7a2f18a54e0
+	const systemProcessorPerformanceInformation = 8
+
+	// Create a buffer large enough to hold an entry for each processor.
+	b := make([]byte, runtime.NumCPU()*sizeofSystemProcessorPerformanceInformation)
+
+	// Query the performance information. Note that this function uses 0 to
+	// indicate success. Most other Windows functions use non-zero for success.
+	var returnLength uint32
+	ntStatus, _ := _NtQuerySystemInformation(systemProcessorPerformanceInformation, &b[0], uint32(len(b)), &returnLength)
+	if ntStatus != STATUS_SUCCESS {
+		return nil, errors.Errorf("NtQuerySystemInformation failed, NTSTATUS=0x%X, bufLength=%v, returnLength=%v", ntStatus, len(b), returnLength)
+	}
+
+	return readSystemProcessorPerformanceInformationBuffer(b)
+}
+
+// readSystemProcessorPerformanceInformationBuffer reads from a buffer
+// containing SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION data. The buffer should
+// contain one entry for each CPU.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func readSystemProcessorPerformanceInformationBuffer(b []byte) ([]SystemProcessorPerformanceInformation, error) {
+	n := len(b) / sizeofSystemProcessorPerformanceInformation
+	r := bytes.NewReader(b)
+
+	rtn := make([]SystemProcessorPerformanceInformation, 0, n)
+	for i := 0; i < n; i++ {
+		_, err := r.Seek(int64(i*sizeofSystemProcessorPerformanceInformation), io.SeekStart)
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to seek to cpuN=%v in buffer", i)
+		}
+
+		times := make([]uint64, 3)
+		for j := range times {
+			err := binary.Read(r, binary.LittleEndian, ×[j])
+			if err != nil {
+				return nil, errors.Wrapf(err, "failed reading cpu times for cpuN=%v", i)
+			}
+		}
+
+		idleTime := time.Duration(times[0] * 100)
+		kernelTime := time.Duration(times[1] * 100)
+		userTime := time.Duration(times[2] * 100)
+
+		rtn = append(rtn, SystemProcessorPerformanceInformation{
+			IdleTime:   idleTime,
+			KernelTime: kernelTime - idleTime, // Subtract out idle time from kernel time.
+			UserTime:   userTime,
+		})
+	}
+
+	return rtn, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/privileges.go b/vendor/github.com/elastic/gosigar/sys/windows/privileges.go
new file mode 100644
index 0000000000..28c78fd228
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/privileges.go
@@ -0,0 +1,272 @@
+// +build windows
+
+package windows
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+
+	"github.com/pkg/errors"
+	"golang.org/x/sys/windows"
+)
+
+// Cache of privilege names to LUIDs.
+var (
+	privNames     = make(map[string]int64)
+	privNameMutex sync.Mutex
+)
+
+const (
+	// SeDebugPrivilege is the name of the privilege used to debug programs.
+	SeDebugPrivilege = "SeDebugPrivilege"
+)
+
+// Errors returned by AdjustTokenPrivileges.
+const (
+	ERROR_NOT_ALL_ASSIGNED syscall.Errno = 1300
+)
+
+// Attribute bits for privileges.
+const (
+	_SE_PRIVILEGE_ENABLED_BY_DEFAULT uint32 = 0x00000001
+	_SE_PRIVILEGE_ENABLED            uint32 = 0x00000002
+	_SE_PRIVILEGE_REMOVED            uint32 = 0x00000004
+	_SE_PRIVILEGE_USED_FOR_ACCESS    uint32 = 0x80000000
+)
+
+// Privilege contains information about a single privilege associated with a
+// Token.
+type Privilege struct {
+	LUID             int64  `json:"-"` // Locally unique identifier (guaranteed only until the system is restarted).
+	Name             string `json:"-"`
+	EnabledByDefault bool   `json:"enabled_by_default,omitempty"`
+	Enabled          bool   `json:"enabled"`
+	Removed          bool   `json:"removed,omitempty"`
+	Used             bool   `json:"used,omitempty"`
+}
+
+func (p Privilege) String() string {
+	var buf bytes.Buffer
+	buf.WriteString(p.Name)
+	buf.WriteString("=(")
+
+	opts := make([]string, 0, 4)
+	if p.EnabledByDefault {
+		opts = append(opts, "Default")
+	}
+	if p.Enabled {
+		opts = append(opts, "Enabled")
+	}
+	if !p.EnabledByDefault && !p.Enabled {
+		opts = append(opts, "Disabled")
+	}
+	if p.Removed {
+		opts = append(opts, "Removed")
+	}
+	if p.Used {
+		opts = append(opts, "Used")
+	}
+
+	buf.WriteString(strings.Join(opts, ", "))
+	buf.WriteString(")")
+
+	// Example: SeDebugPrivilege=(Default, Enabled)
+	return buf.String()
+}
+
+// User represent the information about a Windows account.
+type User struct {
+	SID     string
+	Account string
+	Domain  string
+	Type    uint32
+}
+
+func (u User) String() string {
+	return fmt.Sprintf(`User:%v\%v, SID:%v, Type:%v`, u.Domain, u.Account, u.SID, u.Type)
+}
+
+// DebugInfo contains general debug info about the current process.
+type DebugInfo struct {
+	OSVersion    Version              // OS version info.
+	Arch         string               // Architecture of the machine.
+	NumCPU       int                  // Number of CPUs.
+	User         User                 // User that this process is running as.
+	ProcessPrivs map[string]Privilege // Privileges held by the process.
+}
+
+func (d DebugInfo) String() string {
+	bytes, _ := json.Marshal(d)
+	return string(bytes)
+}
+
+// LookupPrivilegeName looks up a privilege name given a LUID value.
+func LookupPrivilegeName(systemName string, luid int64) (string, error) {
+	buf := make([]uint16, 256)
+	bufSize := uint32(len(buf))
+	err := _LookupPrivilegeName(systemName, &luid, &buf[0], &bufSize)
+	if err != nil {
+		return "", errors.Wrapf(err, "LookupPrivilegeName failed for luid=%v", luid)
+	}
+
+	return syscall.UTF16ToString(buf), nil
+}
+
+// mapPrivileges maps privilege names to LUID values.
+func mapPrivileges(names []string) ([]int64, error) {
+	var privileges []int64
+	privNameMutex.Lock()
+	defer privNameMutex.Unlock()
+	for _, name := range names {
+		p, ok := privNames[name]
+		if !ok {
+			err := _LookupPrivilegeValue("", name, &p)
+			if err != nil {
+				return nil, errors.Wrapf(err, "LookupPrivilegeValue failed on '%v'", name)
+			}
+			privNames[name] = p
+		}
+		privileges = append(privileges, p)
+	}
+	return privileges, nil
+}
+
+// EnableTokenPrivileges enables the specified privileges in the given
+// Token. The token must have TOKEN_ADJUST_PRIVILEGES access. If the token
+// does not already contain the privilege it cannot be enabled.
+func EnableTokenPrivileges(token syscall.Token, privileges ...string) error {
+	privValues, err := mapPrivileges(privileges)
+	if err != nil {
+		return err
+	}
+
+	var b bytes.Buffer
+	binary.Write(&b, binary.LittleEndian, uint32(len(privValues)))
+	for _, p := range privValues {
+		binary.Write(&b, binary.LittleEndian, p)
+		binary.Write(&b, binary.LittleEndian, uint32(_SE_PRIVILEGE_ENABLED))
+	}
+
+	success, err := _AdjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(b.Len()), nil, nil)
+	if !success {
+		return err
+	}
+	if err == ERROR_NOT_ALL_ASSIGNED {
+		return errors.Wrap(err, "error not all privileges were assigned")
+	}
+
+	return nil
+}
+
+// GetTokenPrivileges returns a list of privileges associated with a token.
+// The provided token must have at a minimum TOKEN_QUERY access. This is a
+// wrapper around the GetTokenInformation function.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
+func GetTokenPrivileges(token syscall.Token) (map[string]Privilege, error) {
+	// Determine the required buffer size.
+	var size uint32
+	syscall.GetTokenInformation(token, syscall.TokenPrivileges, nil, 0, &size)
+
+	// This buffer will receive a TOKEN_PRIVILEGE structure.
+	b := bytes.NewBuffer(make([]byte, size))
+	err := syscall.GetTokenInformation(token, syscall.TokenPrivileges, &b.Bytes()[0], uint32(b.Len()), &size)
+	if err != nil {
+		return nil, errors.Wrap(err, "GetTokenInformation failed")
+	}
+
+	var privilegeCount uint32
+	err = binary.Read(b, binary.LittleEndian, &privilegeCount)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read PrivilegeCount")
+	}
+
+	rtn := make(map[string]Privilege, privilegeCount)
+	for i := 0; i < int(privilegeCount); i++ {
+		var luid int64
+		err = binary.Read(b, binary.LittleEndian, &luid)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read LUID value")
+		}
+
+		var attributes uint32
+		err = binary.Read(b, binary.LittleEndian, &attributes)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read attributes")
+		}
+
+		name, err := LookupPrivilegeName("", luid)
+		if err != nil {
+			return nil, errors.Wrapf(err, "LookupPrivilegeName failed for LUID=%v", luid)
+		}
+
+		rtn[name] = Privilege{
+			LUID:             luid,
+			Name:             name,
+			EnabledByDefault: (attributes & _SE_PRIVILEGE_ENABLED_BY_DEFAULT) > 0,
+			Enabled:          (attributes & _SE_PRIVILEGE_ENABLED) > 0,
+			Removed:          (attributes & _SE_PRIVILEGE_REMOVED) > 0,
+			Used:             (attributes & _SE_PRIVILEGE_USED_FOR_ACCESS) > 0,
+		}
+	}
+
+	return rtn, nil
+}
+
+// GetTokenUser returns the User associated with the given Token.
+func GetTokenUser(token syscall.Token) (User, error) {
+	tokenUser, err := token.GetTokenUser()
+	if err != nil {
+		return User{}, errors.Wrap(err, "GetTokenUser failed")
+	}
+
+	var user User
+	user.SID, err = tokenUser.User.Sid.String()
+	if err != nil {
+		return user, errors.Wrap(err, "ConvertSidToStringSid failed")
+	}
+
+	user.Account, user.Domain, user.Type, err = tokenUser.User.Sid.LookupAccount("")
+	if err != nil {
+		return user, errors.Wrap(err, "LookupAccountSid failed")
+	}
+
+	return user, nil
+}
+
+// GetDebugInfo returns general debug info about the current process.
+func GetDebugInfo() (*DebugInfo, error) {
+	h, err := windows.GetCurrentProcess()
+	if err != nil {
+		return nil, err
+	}
+
+	var token syscall.Token
+	err = syscall.OpenProcessToken(syscall.Handle(h), syscall.TOKEN_QUERY, &token)
+	if err != nil {
+		return nil, err
+	}
+
+	privs, err := GetTokenPrivileges(token)
+	if err != nil {
+		return nil, err
+	}
+
+	user, err := GetTokenUser(token)
+	if err != nil {
+		return nil, err
+	}
+
+	return &DebugInfo{
+		User:         user,
+		ProcessPrivs: privs,
+		OSVersion:    GetWindowsVersion(),
+		Arch:         runtime.GOARCH,
+		NumCPU:       runtime.NumCPU(),
+	}, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go b/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go
new file mode 100644
index 0000000000..88df0febfa
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go
@@ -0,0 +1,385 @@
+package windows
+
+import (
+	"fmt"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	sizeofUint32                  = 4
+	sizeofProcessEntry32          = uint32(unsafe.Sizeof(ProcessEntry32{}))
+	sizeofProcessMemoryCountersEx = uint32(unsafe.Sizeof(ProcessMemoryCountersEx{}))
+	sizeofMemoryStatusEx          = uint32(unsafe.Sizeof(MemoryStatusEx{}))
+)
+
+// Process-specific access rights. Others are declared in the syscall package.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
+const (
+	PROCESS_QUERY_LIMITED_INFORMATION uint32 = 0x1000
+	PROCESS_VM_READ                   uint32 = 0x0010
+)
+
+// MAX_PATH is the maximum length for a path in Windows.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+const MAX_PATH = 260
+
+// DriveType represents a type of drive (removable, fixed, CD-ROM, RAM disk, or
+// network drive).
+type DriveType uint32
+
+// Drive types as returned by GetDriveType.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939(v=vs.85).aspx
+const (
+	DRIVE_UNKNOWN DriveType = iota
+	DRIVE_NO_ROOT_DIR
+	DRIVE_REMOVABLE
+	DRIVE_FIXED
+	DRIVE_REMOTE
+	DRIVE_CDROM
+	DRIVE_RAMDISK
+)
+
+func (dt DriveType) String() string {
+	names := map[DriveType]string{
+		DRIVE_UNKNOWN:     "unknown",
+		DRIVE_NO_ROOT_DIR: "invalid",
+		DRIVE_REMOVABLE:   "removable",
+		DRIVE_FIXED:       "fixed",
+		DRIVE_REMOTE:      "remote",
+		DRIVE_CDROM:       "cdrom",
+		DRIVE_RAMDISK:     "ramdisk",
+	}
+
+	name, found := names[dt]
+	if !found {
+		return "unknown DriveType value"
+	}
+	return name
+}
+
+// Flags that can be used with CreateToolhelp32Snapshot.
+const (
+	TH32CS_INHERIT      uint32 = 0x80000000 // Indicates that the snapshot handle is to be inheritable.
+	TH32CS_SNAPHEAPLIST uint32 = 0x00000001 // Includes all heaps of the process specified in th32ProcessID in the snapshot.
+	TH32CS_SNAPMODULE   uint32 = 0x00000008 // Includes all modules of the process specified in th32ProcessID in the snapshot.
+	TH32CS_SNAPMODULE32 uint32 = 0x00000010 // Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit process.
+	TH32CS_SNAPPROCESS  uint32 = 0x00000002 // Includes all processes in the system in the snapshot.
+	TH32CS_SNAPTHREAD   uint32 = 0x00000004 // Includes all threads in the system in the snapshot.
+)
+
+// ProcessEntry32 is an equivalent representation of PROCESSENTRY32 in the
+// Windows API. It contains a process's information. Do not modify or reorder.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684839(v=vs.85).aspx
+type ProcessEntry32 struct {
+	size              uint32
+	CntUsage          uint32
+	ProcessID         uint32
+	DefaultHeapID     uintptr
+	ModuleID          uint32
+	CntThreads        uint32
+	ParentProcessID   uint32
+	PriorityClassBase int32
+	Flags             uint32
+	exeFile           [MAX_PATH]uint16
+}
+
+// ExeFile returns the name of the executable file for the process. It does
+// not contain the full path.
+func (p ProcessEntry32) ExeFile() string {
+	return syscall.UTF16ToString(p.exeFile[:])
+}
+
+func (p ProcessEntry32) String() string {
+	return fmt.Sprintf("{CntUsage:%v ProcessID:%v DefaultHeapID:%v ModuleID:%v "+
+		"CntThreads:%v ParentProcessID:%v PriorityClassBase:%v Flags:%v ExeFile:%v",
+		p.CntUsage, p.ProcessID, p.DefaultHeapID, p.ModuleID, p.CntThreads,
+		p.ParentProcessID, p.PriorityClassBase, p.Flags, p.ExeFile())
+}
+
+// MemoryStatusEx is an equivalent representation of MEMORYSTATUSEX in the
+// Windows API. It contains information about the current state of both physical
+// and virtual memory, including extended memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366770
+type MemoryStatusEx struct {
+	length               uint32
+	MemoryLoad           uint32
+	TotalPhys            uint64
+	AvailPhys            uint64
+	TotalPageFile        uint64
+	AvailPageFile        uint64
+	TotalVirtual         uint64
+	AvailVirtual         uint64
+	AvailExtendedVirtual uint64
+}
+
+// ProcessMemoryCountersEx is an equivalent representation of
+// PROCESS_MEMORY_COUNTERS_EX in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx
+type ProcessMemoryCountersEx struct {
+	cb                         uint32
+	PageFaultCount             uint32
+	PeakWorkingSetSize         uintptr
+	WorkingSetSize             uintptr
+	QuotaPeakPagedPoolUsage    uintptr
+	QuotaPagedPoolUsage        uintptr
+	QuotaPeakNonPagedPoolUsage uintptr
+	QuotaNonPagedPoolUsage     uintptr
+	PagefileUsage              uintptr
+	PeakPagefileUsage          uintptr
+	PrivateUsage               uintptr
+}
+
+// GetLogicalDriveStrings returns a list of drives in the system.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364975(v=vs.85).aspx
+func GetLogicalDriveStrings() ([]string, error) {
+	// Determine the size of the buffer required to receive all drives.
+	bufferLength, err := _GetLogicalDriveStringsW(0, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed to get buffer length")
+	}
+	if bufferLength < 0 {
+		return nil, errors.New("GetLogicalDriveStringsW returned an invalid buffer length")
+	}
+
+	buffer := make([]uint16, bufferLength)
+	_, err = _GetLogicalDriveStringsW(uint32(len(buffer)), &buffer[0])
+	if err != nil {
+		return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed")
+	}
+
+	// Split the uint16 slice at null-terminators.
+	var startIdx int
+	var drivesUTF16 [][]uint16
+	for i, value := range buffer {
+		if value == 0 {
+			drivesUTF16 = append(drivesUTF16, buffer[startIdx:i])
+			startIdx = i + 1
+		}
+	}
+
+	// Convert the utf16 slices to strings.
+	drives := make([]string, 0, len(drivesUTF16))
+	for _, driveUTF16 := range drivesUTF16 {
+		if len(driveUTF16) > 0 {
+			drives = append(drives, syscall.UTF16ToString(driveUTF16))
+		}
+	}
+
+	return drives, nil
+}
+
+// GlobalMemoryStatusEx retrieves information about the system's current usage
+// of both physical and virtual memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366589(v=vs.85).aspx
+func GlobalMemoryStatusEx() (MemoryStatusEx, error) {
+	memoryStatusEx := MemoryStatusEx{length: sizeofMemoryStatusEx}
+	err := _GlobalMemoryStatusEx(&memoryStatusEx)
+	if err != nil {
+		return MemoryStatusEx{}, errors.Wrap(err, "GlobalMemoryStatusEx failed")
+	}
+
+	return memoryStatusEx, nil
+}
+
+// GetProcessMemoryInfo retrieves information about the memory usage of the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
+func GetProcessMemoryInfo(handle syscall.Handle) (ProcessMemoryCountersEx, error) {
+	processMemoryCountersEx := ProcessMemoryCountersEx{cb: sizeofProcessMemoryCountersEx}
+	err := _GetProcessMemoryInfo(handle, &processMemoryCountersEx, processMemoryCountersEx.cb)
+	if err != nil {
+		return ProcessMemoryCountersEx{}, errors.Wrap(err, "GetProcessMemoryInfo failed")
+	}
+
+	return processMemoryCountersEx, nil
+}
+
+// GetProcessImageFileName Retrieves the name of the executable file for the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683217(v=vs.85).aspx
+func GetProcessImageFileName(handle syscall.Handle) (string, error) {
+	buffer := make([]uint16, MAX_PATH)
+	_, err := _GetProcessImageFileName(handle, &buffer[0], uint32(len(buffer)))
+	if err != nil {
+		return "", errors.Wrap(err, "GetProcessImageFileName failed")
+	}
+
+	return syscall.UTF16ToString(buffer), nil
+}
+
+// GetSystemTimes retrieves system timing information. On a multiprocessor
+// system, the values returned are the sum of the designated times across all
+// processors. The returned kernel time does not include the system idle time.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724400(v=vs.85).aspx
+func GetSystemTimes() (idle, kernel, user time.Duration, err error) {
+	var idleTime, kernelTime, userTime syscall.Filetime
+	err = _GetSystemTimes(&idleTime, &kernelTime, &userTime)
+	if err != nil {
+		return 0, 0, 0, errors.Wrap(err, "GetSystemTimes failed")
+	}
+
+	idle = FiletimeToDuration(&idleTime)
+	kernel = FiletimeToDuration(&kernelTime) // Kernel time includes idle time so we subtract it out.
+	user = FiletimeToDuration(&userTime)
+
+	return idle, kernel - idle, user, nil
+}
+
+// FiletimeToDuration converts a Filetime to a time.Duration. Do not use this
+// method to convert a Filetime to an actual clock time, for that use
+// Filetime.Nanosecond().
+func FiletimeToDuration(ft *syscall.Filetime) time.Duration {
+	n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
+	return time.Duration(n * 100)
+}
+
+// GetDriveType Determines whether a disk drive is a removable, fixed, CD-ROM,
+// RAM disk, or network drive. A trailing backslash is required on the
+// rootPathName.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939
+func GetDriveType(rootPathName string) (DriveType, error) {
+	rootPathNamePtr, err := syscall.UTF16PtrFromString(rootPathName)
+	if err != nil {
+		return DRIVE_UNKNOWN, errors.Wrapf(err, "UTF16PtrFromString failed for rootPathName=%v", rootPathName)
+	}
+
+	dt, err := _GetDriveType(rootPathNamePtr)
+	if err != nil {
+		return DRIVE_UNKNOWN, errors.Wrapf(err, "GetDriveType failed for rootPathName=%v", rootPathName)
+	}
+
+	return dt, nil
+}
+
+// EnumProcesses retrieves the process identifier for each process object in the
+// system. This function can return a max of 65536 PIDs. If there are more
+// processes than that then this will not return them all.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682629(v=vs.85).aspx
+func EnumProcesses() ([]uint32, error) {
+	enumProcesses := func(size int) ([]uint32, error) {
+		var (
+			pids         = make([]uint32, size)
+			sizeBytes    = len(pids) * sizeofUint32
+			bytesWritten uint32
+		)
+
+		err := _EnumProcesses(&pids[0], uint32(sizeBytes), &bytesWritten)
+
+		pidsWritten := int(bytesWritten) / sizeofUint32
+		if int(bytesWritten)%sizeofUint32 != 0 || pidsWritten > len(pids) {
+			return nil, errors.Errorf("EnumProcesses returned an invalid bytesWritten value of %v", bytesWritten)
+		}
+		pids = pids[:pidsWritten]
+
+		return pids, err
+	}
+
+	// Retry the EnumProcesses call with larger arrays if needed.
+	size := 2048
+	var pids []uint32
+	for tries := 0; tries < 5; tries++ {
+		var err error
+		pids, err = enumProcesses(size)
+		if err != nil {
+			return nil, errors.Wrap(err, "EnumProcesses failed")
+		}
+
+		if len(pids) < size {
+			break
+		}
+
+		// Increase the size the pids array and retry the enumProcesses call
+		// because the array wasn't large enough to hold all of the processes.
+		size *= 2
+	}
+
+	return pids, nil
+}
+
+// GetDiskFreeSpaceEx retrieves information about the amount of space that is
+// available on a disk volume, which is the total amount of space, the total
+// amount of free space, and the total amount of free space available to the
+// user that is associated with the calling thread.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364937(v=vs.85).aspx
+func GetDiskFreeSpaceEx(directoryName string) (freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes uint64, err error) {
+	directoryNamePtr, err := syscall.UTF16PtrFromString(directoryName)
+	if err != nil {
+		return 0, 0, 0, errors.Wrapf(err, "UTF16PtrFromString failed for directoryName=%v", directoryName)
+	}
+
+	err = _GetDiskFreeSpaceEx(directoryNamePtr, &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	return freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, nil
+}
+
+// CreateToolhelp32Snapshot takes a snapshot of the specified processes, as well
+// as the heaps, modules, and threads used by these processes.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682489(v=vs.85).aspx
+func CreateToolhelp32Snapshot(flags, pid uint32) (syscall.Handle, error) {
+	h, err := _CreateToolhelp32Snapshot(flags, pid)
+	if err != nil {
+		return syscall.InvalidHandle, err
+	}
+	if h == syscall.InvalidHandle {
+		return syscall.InvalidHandle, syscall.GetLastError()
+	}
+
+	return h, nil
+}
+
+// Process32First retrieves information about the first process encountered in a
+// system snapshot.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684834
+func Process32First(handle syscall.Handle) (ProcessEntry32, error) {
+	processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+	err := _Process32First(handle, &processEntry32)
+	if err != nil {
+		return ProcessEntry32{}, errors.Wrap(err, "Process32First failed")
+	}
+
+	return processEntry32, nil
+}
+
+// Process32Next retrieves information about the next process recorded in a
+// system snapshot. When there are no more processes to iterate then
+// syscall.ERROR_NO_MORE_FILES is returned (use errors.Cause() to unwrap).
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684836
+func Process32Next(handle syscall.Handle) (ProcessEntry32, error) {
+	processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+	err := _Process32Next(handle, &processEntry32)
+	if err != nil {
+		return ProcessEntry32{}, errors.Wrap(err, "Process32Next failed")
+	}
+
+	return processEntry32, nil
+}
+
+// Use "GOOS=windows go generate -v -x ." to generate the source.
+
+// Add -trace to enable debug prints around syscalls.
+//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go
+
+// Windows API calls
+//sys   _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) = kernel32.GlobalMemoryStatusEx
+//sys   _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) = kernel32.GetLogicalDriveStringsW
+//sys   _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) = psapi.GetProcessMemoryInfo
+//sys   _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) = psapi.GetProcessImageFileNameW
+//sys   _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) = kernel32.GetSystemTimes
+//sys   _GetDriveType(rootPathName *uint16) (dt DriveType, err error) = kernel32.GetDriveTypeW
+//sys   _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses
+//sys   _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) = kernel32.GetDiskFreeSpaceExW
+//sys   _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32FirstW
+//sys   _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32NextW
+//sys   _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) = kernel32.CreateToolhelp32Snapshot
+//sys   _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQuerySystemInformation
+//sys   _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQueryInformationProcess
+//sys   _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
+//sys   _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) = advapi32.LookupPrivilegeValueW
+//sys   _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/version.go b/vendor/github.com/elastic/gosigar/sys/windows/version.go
new file mode 100644
index 0000000000..d0bca89c14
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/version.go
@@ -0,0 +1,43 @@
+// +build windows
+
+package windows
+
+import (
+	"fmt"
+	"syscall"
+)
+
+// Version identifies a Windows version by major, minor, and build number.
+type Version struct {
+	Major int
+	Minor int
+	Build int
+}
+
+// GetWindowsVersion returns the Windows version information. Applications not
+// manifested for Windows 8.1 or Windows 10 will return the Windows 8 OS version
+// value (6.2).
+//
+// For a table of version numbers see:
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx
+func GetWindowsVersion() Version {
+	// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724439(v=vs.85).aspx
+	ver, err := syscall.GetVersion()
+	if err != nil {
+		// GetVersion should never return an error.
+		panic(fmt.Errorf("GetVersion failed: %v", err))
+	}
+
+	return Version{
+		Major: int(ver & 0xFF),
+		Minor: int(ver >> 8 & 0xFF),
+		Build: int(ver >> 16),
+	}
+}
+
+// IsWindowsVistaOrGreater returns true if the Windows version is Vista or
+// greater.
+func (v Version) IsWindowsVistaOrGreater() bool {
+	// Vista is 6.0.
+	return v.Major >= 6 && v.Minor >= 0
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go b/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go
new file mode 100644
index 0000000000..53fae4e3ba
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go
@@ -0,0 +1,260 @@
+// MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT
+
+package windows
+
+import "unsafe"
+import "syscall"
+
+var _ unsafe.Pointer
+
+var (
+	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+	modpsapi    = syscall.NewLazyDLL("psapi.dll")
+	modntdll    = syscall.NewLazyDLL("ntdll.dll")
+	modadvapi32 = syscall.NewLazyDLL("advapi32.dll")
+
+	procGlobalMemoryStatusEx      = modkernel32.NewProc("GlobalMemoryStatusEx")
+	procGetLogicalDriveStringsW   = modkernel32.NewProc("GetLogicalDriveStringsW")
+	procGetProcessMemoryInfo      = modpsapi.NewProc("GetProcessMemoryInfo")
+	procGetProcessImageFileNameW  = modpsapi.NewProc("GetProcessImageFileNameW")
+	procGetSystemTimes            = modkernel32.NewProc("GetSystemTimes")
+	procGetDriveTypeW             = modkernel32.NewProc("GetDriveTypeW")
+	procEnumProcesses             = modpsapi.NewProc("EnumProcesses")
+	procGetDiskFreeSpaceExW       = modkernel32.NewProc("GetDiskFreeSpaceExW")
+	procProcess32FirstW           = modkernel32.NewProc("Process32FirstW")
+	procProcess32NextW            = modkernel32.NewProc("Process32NextW")
+	procCreateToolhelp32Snapshot  = modkernel32.NewProc("CreateToolhelp32Snapshot")
+	procNtQuerySystemInformation  = modntdll.NewProc("NtQuerySystemInformation")
+	procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess")
+	procLookupPrivilegeNameW      = modadvapi32.NewProc("LookupPrivilegeNameW")
+	procLookupPrivilegeValueW     = modadvapi32.NewProc("LookupPrivilegeValueW")
+	procAdjustTokenPrivileges     = modadvapi32.NewProc("AdjustTokenPrivileges")
+)
+
+func _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) {
+	r1, _, e1 := syscall.Syscall(procGlobalMemoryStatusEx.Addr(), 1, uintptr(unsafe.Pointer(buffer)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procGetLogicalDriveStringsW.Addr(), 2, uintptr(bufferLength), uintptr(unsafe.Pointer(buffer)), 0)
+	length = uint32(r0)
+	if length == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetProcessMemoryInfo.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(psmemCounters)), uintptr(cb))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) {
+	r0, _, e1 := syscall.Syscall(procGetProcessImageFileNameW.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(outImageFileName)), uintptr(size))
+	length = uint32(r0)
+	if length == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetSystemTimes.Addr(), 3, uintptr(unsafe.Pointer(idleTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetDriveType(rootPathName *uint16) (dt DriveType, err error) {
+	r0, _, e1 := syscall.Syscall(procGetDriveTypeW.Addr(), 1, uintptr(unsafe.Pointer(rootPathName)), 0, 0)
+	dt = DriveType(r0)
+	if dt == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall(procEnumProcesses.Addr(), 3, uintptr(unsafe.Pointer(processIds)), uintptr(sizeBytes), uintptr(unsafe.Pointer(bytesReturned)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) {
+	r1, _, e1 := syscall.Syscall6(procGetDiskFreeSpaceExW.Addr(), 4, uintptr(unsafe.Pointer(directoryName)), uintptr(unsafe.Pointer(freeBytesAvailable)), uintptr(unsafe.Pointer(totalNumberOfBytes)), uintptr(unsafe.Pointer(totalNumberOfFreeBytes)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+	r1, _, e1 := syscall.Syscall(procProcess32FirstW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+	r1, _, e1 := syscall.Syscall(procProcess32NextW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) {
+	r0, _, e1 := syscall.Syscall(procCreateToolhelp32Snapshot.Addr(), 2, uintptr(flags), uintptr(processID), 0)
+	handle = syscall.Handle(r0)
+	if handle == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+	r0, _, e1 := syscall.Syscall6(procNtQuerySystemInformation.Addr(), 4, uintptr(systemInformationClass), uintptr(unsafe.Pointer(systemInformation)), uintptr(systemInformationLength), uintptr(unsafe.Pointer(returnLength)), 0, 0)
+	ntstatus = uint32(r0)
+	if ntstatus == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+	r0, _, e1 := syscall.Syscall6(procNtQueryInformationProcess.Addr(), 5, uintptr(processHandle), uintptr(processInformationClass), uintptr(unsafe.Pointer(processInformation)), uintptr(processInformationLength), uintptr(unsafe.Pointer(returnLength)), 0)
+	ntstatus = uint32(r0)
+	if ntstatus == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) {
+	var _p0 *uint16
+	_p0, err = syscall.UTF16PtrFromString(systemName)
+	if err != nil {
+		return
+	}
+	return __LookupPrivilegeName(_p0, luid, buffer, size)
+}
+
+func __LookupPrivilegeName(systemName *uint16, luid *int64, buffer *uint16, size *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall6(procLookupPrivilegeNameW.Addr(), 4, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), 0, 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) {
+	var _p0 *uint16
+	_p0, err = syscall.UTF16PtrFromString(systemName)
+	if err != nil {
+		return
+	}
+	var _p1 *uint16
+	_p1, err = syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return
+	}
+	return __LookupPrivilegeValue(_p0, _p1, luid)
+}
+
+func __LookupPrivilegeValue(systemName *uint16, name *uint16, luid *int64) (err error) {
+	r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
+	var _p0 uint32
+	if releaseAll {
+		_p0 = 1
+	} else {
+		_p0 = 0
+	}
+	r0, _, e1 := syscall.Syscall6(procAdjustTokenPrivileges.Addr(), 6, uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(input)), uintptr(outputSize), uintptr(unsafe.Pointer(output)), uintptr(unsafe.Pointer(requiredSize)))
+	success = r0 != 0
+	if true {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
diff --git a/vendor/github.com/fjl/memsize/LICENSE b/vendor/github.com/fjl/memsize/LICENSE
new file mode 100644
index 0000000000..8b80456419
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Felix Lange
+
+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/vendor/github.com/fjl/memsize/bitmap.go b/vendor/github.com/fjl/memsize/bitmap.go
new file mode 100644
index 0000000000..47799ea8d3
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/bitmap.go
@@ -0,0 +1,119 @@
+package memsize
+
+import (
+	"math/bits"
+)
+
+const (
+	uintptrBits  = 32 << (uint64(^uintptr(0)) >> 63)
+	uintptrBytes = uintptrBits / 8
+	bmBlockRange = 1 * 1024 * 1024 // bytes covered by bmBlock
+	bmBlockWords = bmBlockRange / uintptrBits
+)
+
+// bitmap is a sparse bitmap.
+type bitmap struct {
+	blocks map[uintptr]*bmBlock
+}
+
+func newBitmap() *bitmap {
+	return &bitmap{make(map[uintptr]*bmBlock)}
+}
+
+// markRange sets n consecutive bits starting at addr.
+func (b *bitmap) markRange(addr, n uintptr) {
+	for end := addr + n; addr < end; {
+		block, baddr := b.block(addr)
+		for i := baddr; i < bmBlockRange && addr < end; i++ {
+			block.mark(i)
+			addr++
+		}
+	}
+}
+
+// isMarked returns the value of the bit at the given address.
+func (b *bitmap) isMarked(addr uintptr) bool {
+	block, baddr := b.block(addr)
+	return block.isMarked(baddr)
+}
+
+// countRange returns the number of set bits in the range (addr,addr+n).
+func (b *bitmap) countRange(addr, n uintptr) uintptr {
+	c := uintptr(0)
+	for end := addr + n; addr < end; {
+		block, baddr := b.block(addr)
+		bend := uintptr(bmBlockRange - 1)
+		if baddr+(end-addr) < bmBlockRange {
+			bend = baddr + (end - addr)
+		}
+		c += uintptr(block.count(baddr, bend))
+		// Move addr to next block.
+		addr += bmBlockRange - baddr
+	}
+	return c
+}
+
+// block finds the block corresponding to the given memory address.
+// It also returns the block's starting address.
+func (b *bitmap) block(addr uintptr) (*bmBlock, uintptr) {
+	index := addr / bmBlockRange
+	block := b.blocks[index]
+	if block == nil {
+		block = new(bmBlock)
+		b.blocks[index] = block
+	}
+	return block, addr % bmBlockRange
+}
+
+// size returns the sum of the byte sizes of all blocks.
+func (b *bitmap) size() uintptr {
+	return uintptr(len(b.blocks)) * bmBlockWords * uintptrBytes
+}
+
+// utilization returns the mean percentage of one bits across all blocks.
+func (b *bitmap) utilization() float32 {
+	var avg float32
+	for _, block := range b.blocks {
+		avg += float32(block.count(0, bmBlockRange-1)) / float32(bmBlockRange)
+	}
+	return avg / float32(len(b.blocks))
+}
+
+// bmBlock is a bitmap block.
+type bmBlock [bmBlockWords]uintptr
+
+// mark sets the i'th bit to one.
+func (b *bmBlock) mark(i uintptr) {
+	b[i/uintptrBits] |= 1 << (i % uintptrBits)
+}
+
+// isMarked returns the value of the i'th bit.
+func (b *bmBlock) isMarked(i uintptr) bool {
+	return (b[i/uintptrBits] & (1 << (i % uintptrBits))) != 0
+}
+
+// count returns the number of set bits in the range (start,end).
+func (b *bmBlock) count(start, end uintptr) (count int) {
+	br := b[start/uintptrBits : end/uintptrBits+1]
+	for i, w := range br {
+		if i == 0 {
+			w &= blockmask(start)
+		}
+		if i == len(br)-1 {
+			w &^= blockmask(end)
+		}
+		count += onesCountPtr(w)
+	}
+	return count
+}
+
+func blockmask(x uintptr) uintptr {
+	return ^uintptr(0) << (x % uintptrBits)
+}
+
+func onesCountPtr(x uintptr) int {
+	if uintptrBits == 64 {
+		return bits.OnesCount64(uint64(x))
+	}
+	return bits.OnesCount32(uint32(x))
+}
diff --git a/vendor/github.com/fjl/memsize/doc.go b/vendor/github.com/fjl/memsize/doc.go
new file mode 100644
index 0000000000..640cfba5eb
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/doc.go
@@ -0,0 +1,16 @@
+/*
+Package memsize computes the size of your object graph.
+
+So you made a spiffy algorithm and it works really well, but geez it's using
+way too much memory. Where did it all go? memsize to the rescue!
+
+To get started, find a value that references all your objects and scan it.
+This traverses the graph, counting sizes per type.
+
+    sizes := memsize.Scan(myValue)
+    fmt.Println(sizes.Total)
+
+memsize can handle cycles just fine and tracks both private and public struct fields.
+Unfortunately function closures cannot be inspected in any way.
+*/
+package memsize
diff --git a/vendor/github.com/fjl/memsize/memsize.go b/vendor/github.com/fjl/memsize/memsize.go
new file mode 100644
index 0000000000..2664e87c46
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/memsize.go
@@ -0,0 +1,243 @@
+package memsize
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"text/tabwriter"
+	"unsafe"
+)
+
+// Scan traverses all objects reachable from v and counts how much memory
+// is used per type. The value must be a non-nil pointer to any value.
+func Scan(v interface{}) Sizes {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Ptr || rv.IsNil() {
+		panic("value to scan must be non-nil pointer")
+	}
+
+	stopTheWorld("memsize scan")
+	defer startTheWorld()
+
+	ctx := newContext()
+	ctx.scan(invalidAddr, rv, false)
+	ctx.s.BitmapSize = ctx.seen.size()
+	ctx.s.BitmapUtilization = ctx.seen.utilization()
+	return *ctx.s
+}
+
+// Sizes is the result of a scan.
+type Sizes struct {
+	Total  uintptr
+	ByType map[reflect.Type]*TypeSize
+	// Internal stats (for debugging)
+	BitmapSize        uintptr
+	BitmapUtilization float32
+}
+
+type TypeSize struct {
+	Total uintptr
+	Count uintptr
+}
+
+func newSizes() *Sizes {
+	return &Sizes{ByType: make(map[reflect.Type]*TypeSize)}
+}
+
+// Report returns a human-readable report.
+func (s Sizes) Report() string {
+	type typLine struct {
+		name  string
+		count uintptr
+		total uintptr
+	}
+	tab := []typLine{{"ALL", 0, s.Total}}
+	for _, typ := range s.ByType {
+		tab[0].count += typ.Count
+	}
+	maxname := 0
+	for typ, s := range s.ByType {
+		line := typLine{typ.String(), s.Count, s.Total}
+		tab = append(tab, line)
+		if len(line.name) > maxname {
+			maxname = len(line.name)
+		}
+	}
+	sort.Slice(tab, func(i, j int) bool { return tab[i].total > tab[j].total })
+
+	buf := new(bytes.Buffer)
+	w := tabwriter.NewWriter(buf, 0, 0, 0, ' ', tabwriter.AlignRight)
+	for _, line := range tab {
+		namespace := strings.Repeat(" ", maxname-len(line.name))
+		fmt.Fprintf(w, "%s%s\t  %v\t  %s\t\n", line.name, namespace, line.count, HumanSize(line.total))
+	}
+	w.Flush()
+	return buf.String()
+}
+
+// addValue is called during scan and adds the memory of given object.
+func (s *Sizes) addValue(v reflect.Value, size uintptr) {
+	s.Total += size
+	rs := s.ByType[v.Type()]
+	if rs == nil {
+		rs = new(TypeSize)
+		s.ByType[v.Type()] = rs
+	}
+	rs.Total += size
+	rs.Count++
+}
+
+type context struct {
+	// We track previously scanned objects to prevent infinite loops
+	// when scanning cycles and to prevent counting objects more than once.
+	seen *bitmap
+	tc   typCache
+	s    *Sizes
+}
+
+func newContext() *context {
+	return &context{seen: newBitmap(), tc: make(typCache), s: newSizes()}
+}
+
+// scan walks all objects below v, determining their size. All scan* functions return the
+// amount of 'extra' memory (e.g. slice data) that is referenced by the object.
+func (c *context) scan(addr address, v reflect.Value, add bool) (extraSize uintptr) {
+	size := v.Type().Size()
+	var marked uintptr
+	if addr.valid() {
+		marked = c.seen.countRange(uintptr(addr), size)
+		if marked == size {
+			return 0 // Skip if we have already seen the whole object.
+		}
+		c.seen.markRange(uintptr(addr), size)
+	}
+	// fmt.Printf("%v: %v ⮑ (marked %d)\n", addr, v.Type(), marked)
+	if c.tc.needScan(v.Type()) {
+		extraSize = c.scanContent(addr, v)
+	}
+	// fmt.Printf("%v: %v %d (add %v, size %d, marked %d, extra %d)\n", addr, v.Type(), size+extraSize, add, v.Type().Size(), marked, extraSize)
+	if add {
+		size -= marked
+		size += extraSize
+		c.s.addValue(v, size)
+	}
+	return extraSize
+}
+
+func (c *context) scanContent(addr address, v reflect.Value) uintptr {
+	switch v.Kind() {
+	case reflect.Array:
+		return c.scanArray(addr, v)
+	case reflect.Chan:
+		return c.scanChan(v)
+	case reflect.Func:
+		// can't do anything here
+		return 0
+	case reflect.Interface:
+		return c.scanInterface(v)
+	case reflect.Map:
+		return c.scanMap(v)
+	case reflect.Ptr:
+		if !v.IsNil() {
+			c.scan(address(v.Pointer()), v.Elem(), true)
+		}
+		return 0
+	case reflect.Slice:
+		return c.scanSlice(v)
+	case reflect.String:
+		return uintptr(v.Len())
+	case reflect.Struct:
+		return c.scanStruct(addr, v)
+	default:
+		unhandledKind(v.Kind())
+		return 0
+	}
+}
+
+func (c *context) scanChan(v reflect.Value) uintptr {
+	etyp := v.Type().Elem()
+	extra := uintptr(0)
+	if c.tc.needScan(etyp) {
+		// Scan the channel buffer. This is unsafe but doesn't race because
+		// the world is stopped during scan.
+		hchan := unsafe.Pointer(v.Pointer())
+		for i := uint(0); i < uint(v.Cap()); i++ {
+			addr := chanbuf(hchan, i)
+			elem := reflect.NewAt(etyp, addr).Elem()
+			extra += c.scanContent(address(addr), elem)
+		}
+	}
+	return uintptr(v.Cap())*etyp.Size() + extra
+}
+
+func (c *context) scanStruct(base address, v reflect.Value) uintptr {
+	extra := uintptr(0)
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Type().Field(i)
+		if c.tc.needScan(f.Type) {
+			addr := base.addOffset(f.Offset)
+			extra += c.scanContent(addr, v.Field(i))
+		}
+	}
+	return extra
+}
+
+func (c *context) scanArray(addr address, v reflect.Value) uintptr {
+	esize := v.Type().Elem().Size()
+	extra := uintptr(0)
+	for i := 0; i < v.Len(); i++ {
+		extra += c.scanContent(addr, v.Index(i))
+		addr = addr.addOffset(esize)
+	}
+	return extra
+}
+
+func (c *context) scanSlice(v reflect.Value) uintptr {
+	slice := v.Slice(0, v.Cap())
+	esize := slice.Type().Elem().Size()
+	base := slice.Pointer()
+	// Add size of the unscanned portion of the backing array to extra.
+	blen := uintptr(slice.Len()) * esize
+	marked := c.seen.countRange(base, blen)
+	extra := blen - marked
+	c.seen.markRange(uintptr(base), blen)
+	if c.tc.needScan(slice.Type().Elem()) {
+		// Elements may contain pointers, scan them individually.
+		addr := address(base)
+		for i := 0; i < slice.Len(); i++ {
+			extra += c.scanContent(addr, slice.Index(i))
+			addr = addr.addOffset(esize)
+		}
+	}
+	return extra
+}
+
+func (c *context) scanMap(v reflect.Value) uintptr {
+	var (
+		typ   = v.Type()
+		len   = uintptr(v.Len())
+		extra = uintptr(0)
+	)
+	if c.tc.needScan(typ.Key()) || c.tc.needScan(typ.Elem()) {
+		for _, k := range v.MapKeys() {
+			extra += c.scan(invalidAddr, k, false)
+			extra += c.scan(invalidAddr, v.MapIndex(k), false)
+		}
+	}
+	return len*typ.Key().Size() + len*typ.Elem().Size() + extra
+}
+
+func (c *context) scanInterface(v reflect.Value) uintptr {
+	elem := v.Elem()
+	if !elem.IsValid() {
+		return 0 // nil interface
+	}
+	c.scan(invalidAddr, elem, false)
+	if !c.tc.isPointer(elem.Type()) {
+		// Account for non-pointer size of the value.
+		return elem.Type().Size()
+	}
+	return 0
+}
diff --git a/vendor/github.com/fjl/memsize/memsizeui/template.go b/vendor/github.com/fjl/memsize/memsizeui/template.go
new file mode 100644
index 0000000000..b60fe6ba54
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/memsizeui/template.go
@@ -0,0 +1,106 @@
+package memsizeui
+
+import (
+	"html/template"
+	"strconv"
+	"sync"
+
+	"github.com/fjl/memsize"
+)
+
+var (
+	base         *template.Template // the "base" template
+	baseInitOnce sync.Once
+)
+
+func baseInit() {
+	base = template.Must(template.New("base").Parse(`
+
+	
+		
+		memsize
+		
+	
+	
+		{{template "content" .}}
+	
+`))
+
+	base.Funcs(template.FuncMap{
+		"quote":     strconv.Quote,
+		"humansize": memsize.HumanSize,
+	})
+
+	template.Must(base.New("rootbuttons").Parse(`
+Overview
+{{- range $root := .Roots -}}
+

+	
+

+{{- end -}}`))
+}
+
+func contentTemplate(source string) *template.Template {
+	baseInitOnce.Do(baseInit)
+	t := template.Must(base.Clone())
+	template.Must(t.New("content").Parse(source))
+	return t
+}
+
+var rootTemplate = contentTemplate(`
+
Memsize

+{{template "rootbuttons" .}}
+

+
Reports

+
+`)
+
+var notFoundTemplate = contentTemplate(`
+
{{.Data}}

+{{template "rootbuttons" .}}
+`)
+
+var reportTemplate = contentTemplate(`
+{{- $report := .Data -}}
+
Memsize Report {{$report.ID}}

+

+	Overview
+	
+

+
+Root: {{quote $report.RootName}}
+Date: {{$report.Date}}
+Duration: {{$report.Duration}}
+Bitmap Size: {{$report.Sizes.BitmapSize | humansize}}
+Bitmap Utilization: {{$report.Sizes.BitmapUtilization}}
+

+

+
+{{$report.Sizes.Report}}
+

+`)
diff --git a/vendor/github.com/fjl/memsize/memsizeui/ui.go b/vendor/github.com/fjl/memsize/memsizeui/ui.go
new file mode 100644
index 0000000000..c48fc53f7f
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/memsizeui/ui.go
@@ -0,0 +1,153 @@
+package memsizeui
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"net/http"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/fjl/memsize"
+)
+
+type Handler struct {
+	init     sync.Once
+	mux      http.ServeMux
+	mu       sync.Mutex
+	reports  map[int]Report
+	roots    map[string]interface{}
+	reportID int
+}
+
+type Report struct {
+	ID       int
+	Date     time.Time
+	Duration time.Duration
+	RootName string
+	Sizes    memsize.Sizes
+}
+
+type templateInfo struct {
+	Roots     []string
+	Reports   map[int]Report
+	PathDepth int
+	Data      interface{}
+}
+
+func (ti *templateInfo) Link(path ...string) string {
+	prefix := strings.Repeat("../", ti.PathDepth)
+	return prefix + strings.Join(path, "")
+}
+
+func (h *Handler) Add(name string, v interface{}) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Ptr || rv.IsNil() {
+		panic("root must be non-nil pointer")
+	}
+	h.mu.Lock()
+	if h.roots == nil {
+		h.roots = make(map[string]interface{})
+	}
+	h.roots[name] = v
+	h.mu.Unlock()
+}
+
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	h.init.Do(func() {
+		h.reports = make(map[int]Report)
+		h.mux.HandleFunc("/", h.handleRoot)
+		h.mux.HandleFunc("/scan", h.handleScan)
+		h.mux.HandleFunc("/report/", h.handleReport)
+	})
+	h.mux.ServeHTTP(w, r)
+}
+
+func (h *Handler) templateInfo(r *http.Request, data interface{}) *templateInfo {
+	h.mu.Lock()
+	roots := make([]string, 0, len(h.roots))
+	for name := range h.roots {
+		roots = append(roots, name)
+	}
+	h.mu.Unlock()
+	sort.Strings(roots)
+
+	return &templateInfo{
+		Roots:     roots,
+		Reports:   h.reports,
+		PathDepth: strings.Count(r.URL.Path, "/") - 1,
+		Data:      data,
+	}
+}
+
+func (h *Handler) handleRoot(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+	serveHTML(w, rootTemplate, http.StatusOK, h.templateInfo(r, nil))
+}
+
+func (h *Handler) handleScan(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "invalid HTTP method, want POST", http.StatusMethodNotAllowed)
+		return
+	}
+	ti := h.templateInfo(r, "Unknown root")
+	id, ok := h.scan(r.URL.Query().Get("root"))
+	if !ok {
+		serveHTML(w, notFoundTemplate, http.StatusNotFound, ti)
+		return
+	}
+	w.Header().Add("Location", ti.Link(fmt.Sprintf("report/%d", id)))
+	w.WriteHeader(http.StatusSeeOther)
+}
+
+func (h *Handler) handleReport(w http.ResponseWriter, r *http.Request) {
+	var id int
+	fmt.Sscan(strings.TrimPrefix(r.URL.Path, "/report/"), &id)
+	h.mu.Lock()
+	report, ok := h.reports[id]
+	h.mu.Unlock()
+
+	if !ok {
+		serveHTML(w, notFoundTemplate, http.StatusNotFound, h.templateInfo(r, "Report not found"))
+	} else {
+		serveHTML(w, reportTemplate, http.StatusOK, h.templateInfo(r, report))
+	}
+}
+
+func (h *Handler) scan(root string) (int, bool) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	val, ok := h.roots[root]
+	if !ok {
+		return 0, false
+	}
+	id := h.reportID
+	start := time.Now()
+	sizes := memsize.Scan(val)
+	h.reports[id] = Report{
+		ID:       id,
+		RootName: root,
+		Date:     start.Truncate(1 * time.Second),
+		Duration: time.Since(start),
+		Sizes:    sizes,
+	}
+	h.reportID++
+	return id, true
+}
+
+func serveHTML(w http.ResponseWriter, tpl *template.Template, status int, ti *templateInfo) {
+	w.Header().Set("content-type", "text/html")
+	var buf bytes.Buffer
+	if err := tpl.Execute(&buf, ti); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	buf.WriteTo(w)
+}
diff --git a/vendor/github.com/fjl/memsize/runtimefunc.go b/vendor/github.com/fjl/memsize/runtimefunc.go
new file mode 100644
index 0000000000..912a3e768d
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/runtimefunc.go
@@ -0,0 +1,14 @@
+package memsize
+
+import "unsafe"
+
+var _ = unsafe.Pointer(nil)
+
+//go:linkname stopTheWorld runtime.stopTheWorld
+func stopTheWorld(reason string)
+
+//go:linkname startTheWorld runtime.startTheWorld
+func startTheWorld()
+
+//go:linkname chanbuf runtime.chanbuf
+func chanbuf(ch unsafe.Pointer, i uint) unsafe.Pointer
diff --git a/vendor/github.com/fjl/memsize/runtimefunc.s b/vendor/github.com/fjl/memsize/runtimefunc.s
new file mode 100644
index 0000000000..a091e2fa72
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/runtimefunc.s
@@ -0,0 +1 @@
+// This file is required to make stub function declarations work.
diff --git a/vendor/github.com/fjl/memsize/type.go b/vendor/github.com/fjl/memsize/type.go
new file mode 100644
index 0000000000..5d6f59e9ff
--- /dev/null
+++ b/vendor/github.com/fjl/memsize/type.go
@@ -0,0 +1,119 @@
+package memsize
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// address is a memory location.
+//
+// Code dealing with uintptr is oblivious to the zero address.
+// Code dealing with address is not: it treats the zero address
+// as invalid. Offsetting an invalid address doesn't do anything.
+//
+// This distinction is useful because there are objects that we can't
+// get the pointer to.
+type address uintptr
+
+const invalidAddr = address(0)
+
+func (a address) valid() bool {
+	return a != 0
+}
+
+func (a address) addOffset(off uintptr) address {
+	if !a.valid() {
+		return invalidAddr
+	}
+	return a + address(off)
+}
+
+func (a address) String() string {
+	if uintptrBits == 32 {
+		return fmt.Sprintf("%#0.8x", uintptr(a))
+	}
+	return fmt.Sprintf("%#0.16x", uintptr(a))
+}
+
+type typCache map[reflect.Type]typInfo
+
+type typInfo struct {
+	isPointer bool
+	needScan  bool
+}
+
+// isPointer returns true for pointer-ish values. The notion of
+// pointer includes everything but plain values, i.e. slices, maps
+// channels, interfaces are 'pointer', too.
+func (tc *typCache) isPointer(typ reflect.Type) bool {
+	return tc.info(typ).isPointer
+}
+
+// needScan reports whether a value of the type needs to be scanned
+// recursively because it may contain pointers.
+func (tc *typCache) needScan(typ reflect.Type) bool {
+	return tc.info(typ).needScan
+}
+
+func (tc *typCache) info(typ reflect.Type) typInfo {
+	info, found := (*tc)[typ]
+	switch {
+	case found:
+		return info
+	case isPointer(typ):
+		info = typInfo{true, true}
+	default:
+		info = typInfo{false, tc.checkNeedScan(typ)}
+	}
+	(*tc)[typ] = info
+	return info
+}
+
+func (tc *typCache) checkNeedScan(typ reflect.Type) bool {
+	switch k := typ.Kind(); k {
+	case reflect.Struct:
+		// Structs don't need scan if none of their fields need it.
+		for i := 0; i < typ.NumField(); i++ {
+			if tc.needScan(typ.Field(i).Type) {
+				return true
+			}
+		}
+	case reflect.Array:
+		// Arrays don't need scan if their element type doesn't.
+		return tc.needScan(typ.Elem())
+	}
+	return false
+}
+
+func isPointer(typ reflect.Type) bool {
+	k := typ.Kind()
+	switch {
+	case k <= reflect.Complex128:
+		return false
+	case k == reflect.Array:
+		return false
+	case k >= reflect.Chan && k <= reflect.String:
+		return true
+	case k == reflect.Struct || k == reflect.UnsafePointer:
+		return false
+	default:
+		unhandledKind(k)
+		return false
+	}
+}
+
+func unhandledKind(k reflect.Kind) {
+	panic("unhandled kind " + k.String())
+}
+
+// HumanSize formats the given number of bytes as a readable string.
+func HumanSize(bytes uintptr) string {
+	switch {
+	case bytes < 1024:
+		return fmt.Sprintf("%d B", bytes)
+	case bytes < 1024*1024:
+		return fmt.Sprintf("%.3f KB", float64(bytes)/1024)
+	default:
+		return fmt.Sprintf("%.3f MB", float64(bytes)/1024/1024)
+	}
+}
diff --git a/vendor/github.com/go-ole/go-ole/ChangeLog.md b/vendor/github.com/go-ole/go-ole/ChangeLog.md
new file mode 100644
index 0000000000..4ba6a8c64d
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ChangeLog.md
@@ -0,0 +1,49 @@
+# Version 1.x.x
+
+* **Add more test cases and reference new test COM server project.** (Placeholder for future additions)
+
+# Version 1.2.0-alphaX
+
+**Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.**
+
+ * Added CI configuration for Travis-CI and AppVeyor.
+ * Added test InterfaceID and ClassID for the COM Test Server project.
+ * Added more inline documentation (#83).
+ * Added IEnumVARIANT implementation (#88).
+ * Added IEnumVARIANT test cases (#99, #100, #101).
+ * Added support for retrieving `time.Time` from VARIANT (#92).
+ * Added test case for IUnknown (#64).
+ * Added test case for IDispatch (#64).
+ * Added test cases for scalar variants (#64, #76).
+
+# Version 1.1.1
+
+ * Fixes for Linux build.
+ * Fixes for Windows build.
+
+# Version 1.1.0
+
+The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes.
+
+ * Move GUID out of variables.go into its own file to make new documentation available.
+ * Move OleError out of ole.go into its own file to make new documentation available.
+ * Add documentation to utility functions.
+ * Add documentation to variant receiver functions.
+ * Add documentation to ole structures.
+ * Make variant available to other systems outside of Windows.
+ * Make OLE structures available to other systems outside of Windows.
+
+## New Features
+
+ * Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows.
+ * More functions are now documented and available on godoc.org.
+
+# Version 1.0.1
+
+ 1. Fix package references from repository location change.
+
+# Version 1.0.0
+
+This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface.
+
+There is no changelog for this version. Check commits for history.
diff --git a/vendor/github.com/go-ole/go-ole/LICENSE b/vendor/github.com/go-ole/go-ole/LICENSE
new file mode 100644
index 0000000000..623ec06f91
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2013-2017 Yasuhiro Matsumoto, 
+
+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/vendor/github.com/go-ole/go-ole/README.md b/vendor/github.com/go-ole/go-ole/README.md
new file mode 100644
index 0000000000..0ea9db33c7
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/README.md
@@ -0,0 +1,46 @@
+#Go OLE
+
+[![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28)
+[![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole)
+[![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole)
+
+Go bindings for Windows COM using shared libraries instead of cgo.
+
+By Yasuhiro Matsumoto.
+
+## Install
+
+To experiment with go-ole, you can just compile and run the example program:
+
+```
+go get github.com/go-ole/go-ole
+cd /path/to/go-ole/
+go test
+
+cd /path/to/go-ole/example/excel
+go run excel.go
+```
+
+## Continuous Integration
+
+Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run.
+
+**Travis-CI**
+
+Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server.
+
+**AppVeyor**
+
+AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server.
+
+The tests currently do run and do pass and this should be maintained with commits.
+
+##Versioning
+
+Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. 
+
+This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed.
+
+##LICENSE
+
+Under the MIT License: http://mattn.mit-license.org/2013
diff --git a/vendor/github.com/go-ole/go-ole/appveyor.yml b/vendor/github.com/go-ole/go-ole/appveyor.yml
new file mode 100644
index 0000000000..0d557ac2ff
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/appveyor.yml
@@ -0,0 +1,54 @@
+# Notes:
+#   - Minimal appveyor.yml file is an empty file. All sections are optional.
+#   - Indent each level of configuration with 2 spaces. Do not use tabs!
+#   - All section names are case-sensitive.
+#   - Section names should be unique on each level.
+
+version: "1.3.0.{build}-alpha-{branch}"
+
+os: Windows Server 2012 R2
+
+branches:
+  only:
+    - master
+    - v1.2
+    - v1.1
+    - v1.0
+
+skip_tags: true
+
+clone_folder: c:\gopath\src\github.com\go-ole\go-ole
+
+environment:
+  GOPATH: c:\gopath
+  matrix:
+  - GOARCH: amd64
+    GOVERSION: 1.5
+    GOROOT: c:\go
+    DOWNLOADPLATFORM: "x64"
+
+install:
+  - choco install mingw
+  - SET PATH=c:\tools\mingw64\bin;%PATH%
+  # - Download COM Server
+  - ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip"
+  - 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL
+  - c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat
+  # - set
+  - go version
+  - go env
+  - go get -u golang.org/x/tools/cmd/cover
+  - go get -u golang.org/x/tools/cmd/godoc
+  - go get -u golang.org/x/tools/cmd/stringer
+
+build_script:
+  - cd c:\gopath\src\github.com\go-ole\go-ole
+  - go get -v -t ./...
+  - go build
+  - go test -v -cover ./...
+
+# disable automatic tests
+test: off
+
+# disable deployment
+deploy: off
diff --git a/vendor/github.com/go-ole/go-ole/com.go b/vendor/github.com/go-ole/go-ole/com.go
new file mode 100644
index 0000000000..75ebbf13f6
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/com.go
@@ -0,0 +1,329 @@
+// +build windows
+
+package ole
+
+import (
+	"errors"
+	"syscall"
+	"time"
+	"unicode/utf16"
+	"unsafe"
+)
+
+var (
+	procCoInitialize, _            = modole32.FindProc("CoInitialize")
+	procCoInitializeEx, _          = modole32.FindProc("CoInitializeEx")
+	procCoUninitialize, _          = modole32.FindProc("CoUninitialize")
+	procCoCreateInstance, _        = modole32.FindProc("CoCreateInstance")
+	procCoTaskMemFree, _           = modole32.FindProc("CoTaskMemFree")
+	procCLSIDFromProgID, _         = modole32.FindProc("CLSIDFromProgID")
+	procCLSIDFromString, _         = modole32.FindProc("CLSIDFromString")
+	procStringFromCLSID, _         = modole32.FindProc("StringFromCLSID")
+	procStringFromIID, _           = modole32.FindProc("StringFromIID")
+	procIIDFromString, _           = modole32.FindProc("IIDFromString")
+	procGetUserDefaultLCID, _      = modkernel32.FindProc("GetUserDefaultLCID")
+	procCopyMemory, _              = modkernel32.FindProc("RtlMoveMemory")
+	procVariantInit, _             = modoleaut32.FindProc("VariantInit")
+	procVariantClear, _            = modoleaut32.FindProc("VariantClear")
+	procVariantTimeToSystemTime, _ = modoleaut32.FindProc("VariantTimeToSystemTime")
+	procSysAllocString, _          = modoleaut32.FindProc("SysAllocString")
+	procSysAllocStringLen, _       = modoleaut32.FindProc("SysAllocStringLen")
+	procSysFreeString, _           = modoleaut32.FindProc("SysFreeString")
+	procSysStringLen, _            = modoleaut32.FindProc("SysStringLen")
+	procCreateDispTypeInfo, _      = modoleaut32.FindProc("CreateDispTypeInfo")
+	procCreateStdDispatch, _       = modoleaut32.FindProc("CreateStdDispatch")
+	procGetActiveObject, _         = modoleaut32.FindProc("GetActiveObject")
+
+	procGetMessageW, _      = moduser32.FindProc("GetMessageW")
+	procDispatchMessageW, _ = moduser32.FindProc("DispatchMessageW")
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
+	// Suggests that no value should be passed to CoInitialized.
+	// Could just be Call() since the parameter is optional. <-- Needs testing to be sure.
+	hr, _, _ := procCoInitialize.Call(uintptr(0))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx
+	// Suggests that the first parameter is not only optional but should always be NULL.
+	hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) (err error) {
+	// p is ignored and won't be used.
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitialize()
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) (err error) {
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitializeEx(coinit)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {
+	procCoUninitialize.Call()
+}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {
+	procCoTaskMemFree.Call(memptr)
+}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str)))
+	hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procCoCreateInstance.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		0,
+		CLSCTX_SERVER,
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procGetActiveObject.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) (err error) {
+	hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) (err error) {
+	hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) (ss *int16) {
+	pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) (ss *int16) {
+	utf16 := utf16.Encode([]rune(v + "\x00"))
+	ptr := &utf16[0]
+
+	pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) (err error) {
+	hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
+	return uint32(l)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) {
+	hr, _, _ := procCreateStdDispatch.Call(
+		uintptr(unsafe.Pointer(unk)),
+		v,
+		uintptr(unsafe.Pointer(ptinfo)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) {
+	hr, _, _ := procCreateDispTypeInfo.Call(
+		uintptr(unsafe.Pointer(idata)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&pptinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {
+	procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length))
+}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() (lcid uint32) {
+	ret, _, _ := procGetUserDefaultLCID.Call()
+	lcid = uint32(ret)
+	return
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) {
+	r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax))
+	ret = int32(r0)
+	return
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) (ret int32) {
+	r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg)))
+	ret = int32(r0)
+	return
+}
+
+// GetVariantDate converts COM Variant Time value to Go time.Time.
+func GetVariantDate(value float64) (time.Time, error) {
+	var st syscall.Systemtime
+	r, _, _ := procVariantTimeToSystemTime.Call(uintptr(value), uintptr(unsafe.Pointer(&st)))
+	if r != 0 {
+		return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil
+	}
+	return time.Now(), errors.New("Could not convert to time, passing current time.")
+}
diff --git a/vendor/github.com/go-ole/go-ole/com_func.go b/vendor/github.com/go-ole/go-ole/com_func.go
new file mode 100644
index 0000000000..425aad3233
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/com_func.go
@@ -0,0 +1,174 @@
+// +build !windows
+
+package ole
+
+import (
+	"time"
+	"unsafe"
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() error {
+	return NewError(E_NOTIMPL)
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	return uint32(0)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() uint32 {
+	return uint32(0)
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) {
+	return int32(0), NewError(E_NOTIMPL)
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) int32 {
+	return int32(0)
+}
+
+func GetVariantDate(value float64) (time.Time, error) {
+	return time.Now(), NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/connect.go b/vendor/github.com/go-ole/go-ole/connect.go
new file mode 100644
index 0000000000..b2ac2ec67a
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/connect.go
@@ -0,0 +1,192 @@
+package ole
+
+// Connection contains IUnknown for fluent interface interaction.
+//
+// Deprecated. Use oleutil package instead.
+type Connection struct {
+	Object *IUnknown // Access COM
+}
+
+// Initialize COM.
+func (*Connection) Initialize() (err error) {
+	return coInitialize()
+}
+
+// Uninitialize COM.
+func (*Connection) Uninitialize() {
+	CoUninitialize()
+}
+
+// Create IUnknown object based first on ProgId and then from String.
+func (c *Connection) Create(progId string) (err error) {
+	var clsid *GUID
+	clsid, err = CLSIDFromProgID(progId)
+	if err != nil {
+		clsid, err = CLSIDFromString(progId)
+		if err != nil {
+			return
+		}
+	}
+
+	unknown, err := CreateInstance(clsid, IID_IUnknown)
+	if err != nil {
+		return
+	}
+	c.Object = unknown
+
+	return
+}
+
+// Release IUnknown object.
+func (c *Connection) Release() {
+	c.Object.Release()
+}
+
+// Load COM object from list of programIDs or strings.
+func (c *Connection) Load(names ...string) (errors []error) {
+	var tempErrors []error = make([]error, len(names))
+	var numErrors int = 0
+	for _, name := range names {
+		err := c.Create(name)
+		if err != nil {
+			tempErrors = append(tempErrors, err)
+			numErrors += 1
+			continue
+		}
+		break
+	}
+
+	copy(errors, tempErrors[0:numErrors])
+	return
+}
+
+// Dispatch returns Dispatch object.
+func (c *Connection) Dispatch() (object *Dispatch, err error) {
+	dispatch, err := c.Object.QueryInterface(IID_IDispatch)
+	if err != nil {
+		return
+	}
+	object = &Dispatch{dispatch}
+	return
+}
+
+// Dispatch stores IDispatch object.
+type Dispatch struct {
+	Object *IDispatch // Dispatch object.
+}
+
+// Call method on IDispatch with parameters.
+func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(method)
+	if err != nil {
+		return
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	return
+}
+
+// MustCall method on IDispatch with parameters.
+func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(method)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	if err != nil {
+		panic(err)
+	}
+
+	return
+}
+
+// Get property on IDispatch with parameters.
+func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	return
+}
+
+// MustGet property on IDispatch with parameters.
+func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Set property on IDispatch with parameters.
+func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	return
+}
+
+// MustSet property on IDispatch with parameters.
+func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// GetId retrieves ID of name on IDispatch.
+func (d *Dispatch) GetId(name string) (id int32, err error) {
+	var dispid []int32
+	dispid, err = d.Object.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	id = dispid[0]
+	return
+}
+
+// GetIds retrieves all IDs of names on IDispatch.
+func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) {
+	dispid, err = d.Object.GetIDsOfName(names)
+	return
+}
+
+// Invoke IDispatch on DisplayID of dispatch type with parameters.
+//
+// There have been problems where if send cascading params..., it would error
+// out because the parameters would be empty.
+func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	if len(params) < 1 {
+		result, err = d.Object.Invoke(id, dispatch)
+	} else {
+		result, err = d.Object.Invoke(id, dispatch, params...)
+	}
+	return
+}
+
+// Release IDispatch object.
+func (d *Dispatch) Release() {
+	d.Object.Release()
+}
+
+// Connect initializes COM and attempts to load IUnknown based on given names.
+func Connect(names ...string) (connection *Connection) {
+	connection.Initialize()
+	connection.Load(names...)
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/constants.go b/vendor/github.com/go-ole/go-ole/constants.go
new file mode 100644
index 0000000000..fd0c6d74b0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/constants.go
@@ -0,0 +1,153 @@
+package ole
+
+const (
+	CLSCTX_INPROC_SERVER   = 1
+	CLSCTX_INPROC_HANDLER  = 2
+	CLSCTX_LOCAL_SERVER    = 4
+	CLSCTX_INPROC_SERVER16 = 8
+	CLSCTX_REMOTE_SERVER   = 16
+	CLSCTX_ALL             = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER
+	CLSCTX_INPROC          = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+	CLSCTX_SERVER          = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+)
+
+const (
+	COINIT_APARTMENTTHREADED = 0x2
+	COINIT_MULTITHREADED     = 0x0
+	COINIT_DISABLE_OLE1DDE   = 0x4
+	COINIT_SPEED_OVER_MEMORY = 0x8
+)
+
+const (
+	DISPATCH_METHOD         = 1
+	DISPATCH_PROPERTYGET    = 2
+	DISPATCH_PROPERTYPUT    = 4
+	DISPATCH_PROPERTYPUTREF = 8
+)
+
+const (
+	S_OK           = 0x00000000
+	E_UNEXPECTED   = 0x8000FFFF
+	E_NOTIMPL      = 0x80004001
+	E_OUTOFMEMORY  = 0x8007000E
+	E_INVALIDARG   = 0x80070057
+	E_NOINTERFACE  = 0x80004002
+	E_POINTER      = 0x80004003
+	E_HANDLE       = 0x80070006
+	E_ABORT        = 0x80004004
+	E_FAIL         = 0x80004005
+	E_ACCESSDENIED = 0x80070005
+	E_PENDING      = 0x8000000A
+
+	CO_E_CLASSSTRING = 0x800401F3
+)
+
+const (
+	CC_FASTCALL = iota
+	CC_CDECL
+	CC_MSCPASCAL
+	CC_PASCAL = CC_MSCPASCAL
+	CC_MACPASCAL
+	CC_STDCALL
+	CC_FPFASTCALL
+	CC_SYSCALL
+	CC_MPWCDECL
+	CC_MPWPASCAL
+	CC_MAX = CC_MPWPASCAL
+)
+
+type VT uint16
+
+const (
+	VT_EMPTY           VT = 0x0
+	VT_NULL            VT = 0x1
+	VT_I2              VT = 0x2
+	VT_I4              VT = 0x3
+	VT_R4              VT = 0x4
+	VT_R8              VT = 0x5
+	VT_CY              VT = 0x6
+	VT_DATE            VT = 0x7
+	VT_BSTR            VT = 0x8
+	VT_DISPATCH        VT = 0x9
+	VT_ERROR           VT = 0xa
+	VT_BOOL            VT = 0xb
+	VT_VARIANT         VT = 0xc
+	VT_UNKNOWN         VT = 0xd
+	VT_DECIMAL         VT = 0xe
+	VT_I1              VT = 0x10
+	VT_UI1             VT = 0x11
+	VT_UI2             VT = 0x12
+	VT_UI4             VT = 0x13
+	VT_I8              VT = 0x14
+	VT_UI8             VT = 0x15
+	VT_INT             VT = 0x16
+	VT_UINT            VT = 0x17
+	VT_VOID            VT = 0x18
+	VT_HRESULT         VT = 0x19
+	VT_PTR             VT = 0x1a
+	VT_SAFEARRAY       VT = 0x1b
+	VT_CARRAY          VT = 0x1c
+	VT_USERDEFINED     VT = 0x1d
+	VT_LPSTR           VT = 0x1e
+	VT_LPWSTR          VT = 0x1f
+	VT_RECORD          VT = 0x24
+	VT_INT_PTR         VT = 0x25
+	VT_UINT_PTR        VT = 0x26
+	VT_FILETIME        VT = 0x40
+	VT_BLOB            VT = 0x41
+	VT_STREAM          VT = 0x42
+	VT_STORAGE         VT = 0x43
+	VT_STREAMED_OBJECT VT = 0x44
+	VT_STORED_OBJECT   VT = 0x45
+	VT_BLOB_OBJECT     VT = 0x46
+	VT_CF              VT = 0x47
+	VT_CLSID           VT = 0x48
+	VT_BSTR_BLOB       VT = 0xfff
+	VT_VECTOR          VT = 0x1000
+	VT_ARRAY           VT = 0x2000
+	VT_BYREF           VT = 0x4000
+	VT_RESERVED        VT = 0x8000
+	VT_ILLEGAL         VT = 0xffff
+	VT_ILLEGALMASKED   VT = 0xfff
+	VT_TYPEMASK        VT = 0xfff
+)
+
+const (
+	DISPID_UNKNOWN     = -1
+	DISPID_VALUE       = 0
+	DISPID_PROPERTYPUT = -3
+	DISPID_NEWENUM     = -4
+	DISPID_EVALUATE    = -5
+	DISPID_CONSTRUCTOR = -6
+	DISPID_DESTRUCTOR  = -7
+	DISPID_COLLECT     = -8
+)
+
+const (
+	TKIND_ENUM      = 1
+	TKIND_RECORD    = 2
+	TKIND_MODULE    = 3
+	TKIND_INTERFACE = 4
+	TKIND_DISPATCH  = 5
+	TKIND_COCLASS   = 6
+	TKIND_ALIAS     = 7
+	TKIND_UNION     = 8
+	TKIND_MAX       = 9
+)
+
+// Safe Array Feature Flags
+
+const (
+	FADF_AUTO        = 0x0001
+	FADF_STATIC      = 0x0002
+	FADF_EMBEDDED    = 0x0004
+	FADF_FIXEDSIZE   = 0x0010
+	FADF_RECORD      = 0x0020
+	FADF_HAVEIID     = 0x0040
+	FADF_HAVEVARTYPE = 0x0080
+	FADF_BSTR        = 0x0100
+	FADF_UNKNOWN     = 0x0200
+	FADF_DISPATCH    = 0x0400
+	FADF_VARIANT     = 0x0800
+	FADF_RESERVED    = 0xF008
+)
diff --git a/vendor/github.com/go-ole/go-ole/error.go b/vendor/github.com/go-ole/go-ole/error.go
new file mode 100644
index 0000000000..096b456d3a
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error.go
@@ -0,0 +1,51 @@
+package ole
+
+// OleError stores COM errors.
+type OleError struct {
+	hr          uintptr
+	description string
+	subError    error
+}
+
+// NewError creates new error with HResult.
+func NewError(hr uintptr) *OleError {
+	return &OleError{hr: hr}
+}
+
+// NewErrorWithDescription creates new COM error with HResult and description.
+func NewErrorWithDescription(hr uintptr, description string) *OleError {
+	return &OleError{hr: hr, description: description}
+}
+
+// NewErrorWithSubError creates new COM error with parent error.
+func NewErrorWithSubError(hr uintptr, description string, err error) *OleError {
+	return &OleError{hr: hr, description: description, subError: err}
+}
+
+// Code is the HResult.
+func (v *OleError) Code() uintptr {
+	return uintptr(v.hr)
+}
+
+// String description, either manually set or format message with error code.
+func (v *OleError) String() string {
+	if v.description != "" {
+		return errstr(int(v.hr)) + " (" + v.description + ")"
+	}
+	return errstr(int(v.hr))
+}
+
+// Error implements error interface.
+func (v *OleError) Error() string {
+	return v.String()
+}
+
+// Description retrieves error summary, if there is one.
+func (v *OleError) Description() string {
+	return v.description
+}
+
+// SubError returns parent error, if there is one.
+func (v *OleError) SubError() error {
+	return v.subError
+}
diff --git a/vendor/github.com/go-ole/go-ole/error_func.go b/vendor/github.com/go-ole/go-ole/error_func.go
new file mode 100644
index 0000000000..8a2ffaa272
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error_func.go
@@ -0,0 +1,8 @@
+// +build !windows
+
+package ole
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	return ""
+}
diff --git a/vendor/github.com/go-ole/go-ole/error_windows.go b/vendor/github.com/go-ole/go-ole/error_windows.go
new file mode 100644
index 0000000000..d0e8e68595
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error_windows.go
@@ -0,0 +1,24 @@
+// +build windows
+
+package ole
+
+import (
+	"fmt"
+	"syscall"
+	"unicode/utf16"
+)
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	// ask windows for the remaining errors
+	var flags uint32 = syscall.FORMAT_MESSAGE_FROM_SYSTEM | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS
+	b := make([]uint16, 300)
+	n, err := syscall.FormatMessage(flags, 0, uint32(errno), 0, b, nil)
+	if err != nil {
+		return fmt.Sprintf("error %d (FormatMessage failed with: %v)", errno, err)
+	}
+	// trim terminating \r and \n
+	for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
+	}
+	return string(utf16.Decode(b[:n]))
+}
diff --git a/vendor/github.com/go-ole/go-ole/guid.go b/vendor/github.com/go-ole/go-ole/guid.go
new file mode 100644
index 0000000000..8d20f68fbf
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/guid.go
@@ -0,0 +1,284 @@
+package ole
+
+var (
+	// IID_NULL is null Interface ID, used when no other Interface ID is known.
+	IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}")
+
+	// IID_IUnknown is for IUnknown interfaces.
+	IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}")
+
+	// IID_IDispatch is for IDispatch interfaces.
+	IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}")
+
+	// IID_IEnumVariant is for IEnumVariant interfaces
+	IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}")
+
+	// IID_IConnectionPointContainer is for IConnectionPointContainer interfaces.
+	IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IConnectionPoint is for IConnectionPoint interfaces.
+	IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IInspectable is for IInspectable interfaces.
+	IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}")
+
+	// IID_IProvideClassInfo is for IProvideClassInfo interfaces.
+	IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}")
+)
+
+// These are for testing and not part of any library.
+var (
+	// IID_ICOMTestString is for ICOMTestString interfaces.
+	//
+	// {E0133EB4-C36F-469A-9D3D-C66B84BE19ED}
+	IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}")
+
+	// IID_ICOMTestInt8 is for ICOMTestInt8 interfaces.
+	//
+	// {BEB06610-EB84-4155-AF58-E2BFF53680B4}
+	IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}")
+
+	// IID_ICOMTestInt16 is for ICOMTestInt16 interfaces.
+	//
+	// {DAA3F9FA-761E-4976-A860-8364CE55F6FC}
+	IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}")
+
+	// IID_ICOMTestInt32 is for ICOMTestInt32 interfaces.
+	//
+	// {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}
+	IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}")
+
+	// IID_ICOMTestInt64 is for ICOMTestInt64 interfaces.
+	//
+	// {8D437CBC-B3ED-485C-BC32-C336432A1623}
+	IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}")
+
+	// IID_ICOMTestFloat is for ICOMTestFloat interfaces.
+	//
+	// {BF1ED004-EA02-456A-AA55-2AC8AC6B054C}
+	IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}")
+
+	// IID_ICOMTestDouble is for ICOMTestDouble interfaces.
+	//
+	// {BF908A81-8687-4E93-999F-D86FAB284BA0}
+	IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}")
+
+	// IID_ICOMTestBoolean is for ICOMTestBoolean interfaces.
+	//
+	// {D530E7A6-4EE8-40D1-8931-3D63B8605010}
+	IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}")
+
+	// IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces.
+	//
+	// {6485B1EF-D780-4834-A4FE-1EBB51746CA3}
+	IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}")
+
+	// IID_ICOMTestTypes is for ICOMTestTypes interfaces.
+	//
+	// {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}
+	IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}")
+
+	// CLSID_COMEchoTestObject is for COMEchoTestObject class.
+	//
+	// {3C24506A-AE9E-4D50-9157-EF317281F1B0}
+	CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}")
+
+	// CLSID_COMTestScalarClass is for COMTestScalarClass class.
+	//
+	// {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}
+	CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}")
+)
+
+const hextable = "0123456789ABCDEF"
+const emptyGUID = "{00000000-0000-0000-0000-000000000000}"
+
+// GUID is Windows API specific GUID type.
+//
+// This exists to match Windows GUID type for direct passing for COM.
+// Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx.
+type GUID struct {
+	Data1 uint32
+	Data2 uint16
+	Data3 uint16
+	Data4 [8]byte
+}
+
+// NewGUID converts the given string into a globally unique identifier that is
+// compliant with the Windows API.
+//
+// The supplied string may be in any of these formats:
+//
+//  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+//  XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// The conversion of the supplied string is not case-sensitive.
+func NewGUID(guid string) *GUID {
+	d := []byte(guid)
+	var d1, d2, d3, d4a, d4b []byte
+
+	switch len(d) {
+	case 38:
+		if d[0] != '{' || d[37] != '}' {
+			return nil
+		}
+		d = d[1:37]
+		fallthrough
+	case 36:
+		if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' {
+			return nil
+		}
+		d1 = d[0:8]
+		d2 = d[9:13]
+		d3 = d[14:18]
+		d4a = d[19:23]
+		d4b = d[24:36]
+	case 32:
+		d1 = d[0:8]
+		d2 = d[8:12]
+		d3 = d[12:16]
+		d4a = d[16:20]
+		d4b = d[20:32]
+	default:
+		return nil
+	}
+
+	var g GUID
+	var ok1, ok2, ok3, ok4 bool
+	g.Data1, ok1 = decodeHexUint32(d1)
+	g.Data2, ok2 = decodeHexUint16(d2)
+	g.Data3, ok3 = decodeHexUint16(d3)
+	g.Data4, ok4 = decodeHexByte64(d4a, d4b)
+	if ok1 && ok2 && ok3 && ok4 {
+		return &g
+	}
+	return nil
+}
+
+func decodeHexUint32(src []byte) (value uint32, ok bool) {
+	var b1, b2, b3, b4 byte
+	var ok1, ok2, ok3, ok4 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	b3, ok3 = decodeHexByte(src[4], src[5])
+	b4, ok4 = decodeHexByte(src[6], src[7])
+	value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4)
+	ok = ok1 && ok2 && ok3 && ok4
+	return
+}
+
+func decodeHexUint16(src []byte) (value uint16, ok bool) {
+	var b1, b2 byte
+	var ok1, ok2 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	value = (uint16(b1) << 8) | uint16(b2)
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) {
+	var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool
+	value[0], ok1 = decodeHexByte(s1[0], s1[1])
+	value[1], ok2 = decodeHexByte(s1[2], s1[3])
+	value[2], ok3 = decodeHexByte(s2[0], s2[1])
+	value[3], ok4 = decodeHexByte(s2[2], s2[3])
+	value[4], ok5 = decodeHexByte(s2[4], s2[5])
+	value[5], ok6 = decodeHexByte(s2[6], s2[7])
+	value[6], ok7 = decodeHexByte(s2[8], s2[9])
+	value[7], ok8 = decodeHexByte(s2[10], s2[11])
+	ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8
+	return
+}
+
+func decodeHexByte(c1, c2 byte) (value byte, ok bool) {
+	var n1, n2 byte
+	var ok1, ok2 bool
+	n1, ok1 = decodeHexChar(c1)
+	n2, ok2 = decodeHexChar(c2)
+	value = (n1 << 4) | n2
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+// String converts the GUID to string form. It will adhere to this pattern:
+//
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// If the GUID is nil, the string representation of an empty GUID is returned:
+//
+//  {00000000-0000-0000-0000-000000000000}
+func (guid *GUID) String() string {
+	if guid == nil {
+		return emptyGUID
+	}
+
+	var c [38]byte
+	c[0] = '{'
+	putUint32Hex(c[1:9], guid.Data1)
+	c[9] = '-'
+	putUint16Hex(c[10:14], guid.Data2)
+	c[14] = '-'
+	putUint16Hex(c[15:19], guid.Data3)
+	c[19] = '-'
+	putByteHex(c[20:24], guid.Data4[0:2])
+	c[24] = '-'
+	putByteHex(c[25:37], guid.Data4[2:8])
+	c[37] = '}'
+	return string(c[:])
+}
+
+func putUint32Hex(b []byte, v uint32) {
+	b[0] = hextable[byte(v>>24)>>4]
+	b[1] = hextable[byte(v>>24)&0x0f]
+	b[2] = hextable[byte(v>>16)>>4]
+	b[3] = hextable[byte(v>>16)&0x0f]
+	b[4] = hextable[byte(v>>8)>>4]
+	b[5] = hextable[byte(v>>8)&0x0f]
+	b[6] = hextable[byte(v)>>4]
+	b[7] = hextable[byte(v)&0x0f]
+}
+
+func putUint16Hex(b []byte, v uint16) {
+	b[0] = hextable[byte(v>>8)>>4]
+	b[1] = hextable[byte(v>>8)&0x0f]
+	b[2] = hextable[byte(v)>>4]
+	b[3] = hextable[byte(v)&0x0f]
+}
+
+func putByteHex(dst, src []byte) {
+	for i := 0; i < len(src); i++ {
+		dst[i*2] = hextable[src[i]>>4]
+		dst[i*2+1] = hextable[src[i]&0x0f]
+	}
+}
+
+// IsEqualGUID compares two GUID.
+//
+// Not constant time comparison.
+func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
+	return guid1.Data1 == guid2.Data1 &&
+		guid1.Data2 == guid2.Data2 &&
+		guid1.Data3 == guid2.Data3 &&
+		guid1.Data4[0] == guid2.Data4[0] &&
+		guid1.Data4[1] == guid2.Data4[1] &&
+		guid1.Data4[2] == guid2.Data4[2] &&
+		guid1.Data4[3] == guid2.Data4[3] &&
+		guid1.Data4[4] == guid2.Data4[4] &&
+		guid1.Data4[5] == guid2.Data4[5] &&
+		guid1.Data4[6] == guid2.Data4[6] &&
+		guid1.Data4[7] == guid2.Data4[7]
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint.go
new file mode 100644
index 0000000000..9e6c49f41f
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint.go
@@ -0,0 +1,20 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPoint struct {
+	IUnknown
+}
+
+type IConnectionPointVtbl struct {
+	IUnknownVtbl
+	GetConnectionInterface      uintptr
+	GetConnectionPointContainer uintptr
+	Advise                      uintptr
+	Unadvise                    uintptr
+	EnumConnections             uintptr
+}
+
+func (v *IConnectionPoint) VTable() *IConnectionPointVtbl {
+	return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go
new file mode 100644
index 0000000000..5414dc3cd3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go
@@ -0,0 +1,21 @@
+// +build !windows
+
+package ole
+
+import "unsafe"
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	return int32(0)
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) {
+	return NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go
new file mode 100644
index 0000000000..32bc183248
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go
@@ -0,0 +1,43 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	// XXX: This doesn't look like it does what it's supposed to
+	return release((*IUnknown)(unsafe.Pointer(v)))
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Advise,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(unknown)),
+		uintptr(unsafe.Pointer(&cookie)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Unadvise,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(cookie),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go
new file mode 100644
index 0000000000..165860d199
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go
@@ -0,0 +1,17 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPointContainer struct {
+	IUnknown
+}
+
+type IConnectionPointContainerVtbl struct {
+	IUnknownVtbl
+	EnumConnectionPoints uintptr
+	FindConnectionPoint  uintptr
+}
+
+func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl {
+	return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go
new file mode 100644
index 0000000000..5dfa42aaeb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go
@@ -0,0 +1,11 @@
+// +build !windows
+
+package ole
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error {
+	return NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go
new file mode 100644
index 0000000000..ad30d79efc
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go
@@ -0,0 +1,25 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().FindConnectionPoint,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(point)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch.go b/vendor/github.com/go-ole/go-ole/idispatch.go
new file mode 100644
index 0000000000..d4af124092
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch.go
@@ -0,0 +1,94 @@
+package ole
+
+import "unsafe"
+
+type IDispatch struct {
+	IUnknown
+}
+
+type IDispatchVtbl struct {
+	IUnknownVtbl
+	GetTypeInfoCount uintptr
+	GetTypeInfo      uintptr
+	GetIDsOfNames    uintptr
+	Invoke           uintptr
+}
+
+func (v *IDispatch) VTable() *IDispatchVtbl {
+	return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
+	dispid, err = getIDsOfName(v, names)
+	return
+}
+
+func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	result, err = invoke(v, dispid, dispatch, params...)
+	return
+}
+
+func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
+	c, err = getTypeInfoCount(v)
+	return
+}
+
+func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
+	tinfo, err = getTypeInfo(v)
+	return
+}
+
+// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
+//
+// This replaces the common pattern of attempting to get a single name from the list of available
+// IDs. It gives the first ID, if it is available.
+func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
+	var displayIDs []int32
+	displayIDs, err = v.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	displayID = displayIDs[0]
+	return
+}
+
+// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
+//
+// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
+//
+// Passing params as an array is a workaround that could be fixed in later versions of Go that
+// prevent passing empty params. During testing it was discovered that this is an acceptable way of
+// getting around not being able to pass params normally.
+func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	displayID, err := v.GetSingleIDOfName(name)
+	if err != nil {
+		return
+	}
+
+	if len(params) < 1 {
+		result, err = v.Invoke(displayID, dispatch)
+	} else {
+		result, err = v.Invoke(displayID, dispatch, params...)
+	}
+
+	return
+}
+
+// CallMethod invokes named function with arguments on object.
+func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
+}
+
+// GetProperty retrieves the property with the name with the ability to pass arguments.
+//
+// Most of the time you will not need to pass arguments as most objects do not allow for this
+// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
+// and this is provided for those edge cases.
+func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
+}
+
+// PutProperty attempts to mutate a property in the object.
+func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch_func.go b/vendor/github.com/go-ole/go-ole/idispatch_func.go
new file mode 100644
index 0000000000..b8fbbe319f
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch_func.go
@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) {
+	return []int32{}, NewError(E_NOTIMPL)
+}
+
+func getTypeInfoCount(disp *IDispatch) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch_windows.go b/vendor/github.com/go-ole/go-ole/idispatch_windows.go
new file mode 100644
index 0000000000..020e4f51b0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch_windows.go
@@ -0,0 +1,197 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) {
+	wnames := make([]*uint16, len(names))
+	for i := 0; i < len(names); i++ {
+		wnames[i] = syscall.StringToUTF16Ptr(names[i])
+	}
+	dispid = make([]int32, len(names))
+	namelen := uint32(len(names))
+	hr, _, _ := syscall.Syscall6(
+		disp.VTable().GetIDsOfNames,
+		6,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(unsafe.Pointer(&wnames[0])),
+		uintptr(namelen),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&dispid[0])))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfoCount(disp *IDispatch) (c uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfoCount,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&c)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfo,
+		3,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&tinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	var dispparams DISPPARAMS
+
+	if dispatch&DISPATCH_PROPERTYPUT != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	} else if dispatch&DISPATCH_PROPERTYPUTREF != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	}
+	var vargs []VARIANT
+	if len(params) > 0 {
+		vargs = make([]VARIANT, len(params))
+		for i, v := range params {
+			//n := len(params)-i-1
+			n := len(params) - i - 1
+			VariantInit(&vargs[n])
+			switch vv := v.(type) {
+			case bool:
+				if vv {
+					vargs[n] = NewVariant(VT_BOOL, 0xffff)
+				} else {
+					vargs[n] = NewVariant(VT_BOOL, 0)
+				}
+			case *bool:
+				vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool)))))
+			case uint8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(uint8)))
+			case *uint8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(int8)))
+			case *int8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int16:
+				vargs[n] = NewVariant(VT_I2, int64(v.(int16)))
+			case *int16:
+				vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16)))))
+			case uint16:
+				vargs[n] = NewVariant(VT_UI2, int64(v.(uint16)))
+			case *uint16:
+				vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16)))))
+			case int32:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int32)))
+			case *int32:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32)))))
+			case uint32:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint32)))
+			case *uint32:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32)))))
+			case int64:
+				vargs[n] = NewVariant(VT_I8, int64(v.(int64)))
+			case *int64:
+				vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64)))))
+			case uint64:
+				vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64))))
+			case *uint64:
+				vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64)))))
+			case int:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int)))
+			case *int:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int)))))
+			case uint:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint)))
+			case *uint:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint)))))
+			case float32:
+				vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv)))
+			case *float32:
+				vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32)))))
+			case float64:
+				vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv)))
+			case *float64:
+				vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64)))))
+			case string:
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string))))))
+			case *string:
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string)))))
+			case time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s)))))
+			case *time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s))))
+			case *IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch)))))
+			case **IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch)))))
+			case nil:
+				vargs[n] = NewVariant(VT_NULL, 0)
+			case *VARIANT:
+				vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT)))))
+			case []byte:
+				safeByteArray := safeArrayFromByteSlice(v.([]byte))
+				vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			case []string:
+				safeByteArray := safeArrayFromStringSlice(v.([]string))
+				vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			default:
+				panic("unknown type")
+			}
+		}
+		dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
+		dispparams.cArgs = uint32(len(params))
+	}
+
+	result = new(VARIANT)
+	var excepInfo EXCEPINFO
+	VariantInit(result)
+	hr, _, _ := syscall.Syscall9(
+		disp.VTable().Invoke,
+		9,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(dispid),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(dispatch),
+		uintptr(unsafe.Pointer(&dispparams)),
+		uintptr(unsafe.Pointer(result)),
+		uintptr(unsafe.Pointer(&excepInfo)),
+		0)
+	if hr != 0 {
+		err = NewErrorWithSubError(hr, BstrToString(excepInfo.bstrDescription), excepInfo)
+	}
+	for i, varg := range vargs {
+		n := len(params) - i - 1
+		if varg.VT == VT_BSTR && varg.Val != 0 {
+			SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
+		}
+		if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 {
+			*(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val))))
+		}
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant.go b/vendor/github.com/go-ole/go-ole/ienumvariant.go
new file mode 100644
index 0000000000..2433897544
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant.go
@@ -0,0 +1,19 @@
+package ole
+
+import "unsafe"
+
+type IEnumVARIANT struct {
+	IUnknown
+}
+
+type IEnumVARIANTVtbl struct {
+	IUnknownVtbl
+	Next  uintptr
+	Skip  uintptr
+	Reset uintptr
+	Clone uintptr
+}
+
+func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl {
+	return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable))
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant_func.go b/vendor/github.com/go-ole/go-ole/ienumvariant_func.go
new file mode 100644
index 0000000000..c14848199c
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant_func.go
@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Reset() error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) {
+	return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go b/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go
new file mode 100644
index 0000000000..4781f3b8b0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go
@@ -0,0 +1,63 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Clone,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(unsafe.Pointer(&cloned)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Reset() (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Reset,
+		1,
+		uintptr(unsafe.Pointer(enum)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Skip,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) {
+	hr, _, _ := syscall.Syscall6(
+		enum.VTable().Next,
+		4,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		uintptr(unsafe.Pointer(&array)),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable.go b/vendor/github.com/go-ole/go-ole/iinspectable.go
new file mode 100644
index 0000000000..f4a19e253a
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable.go
@@ -0,0 +1,18 @@
+package ole
+
+import "unsafe"
+
+type IInspectable struct {
+	IUnknown
+}
+
+type IInspectableVtbl struct {
+	IUnknownVtbl
+	GetIIds             uintptr
+	GetRuntimeClassName uintptr
+	GetTrustLevel       uintptr
+}
+
+func (v *IInspectable) VTable() *IInspectableVtbl {
+	return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable_func.go b/vendor/github.com/go-ole/go-ole/iinspectable_func.go
new file mode 100644
index 0000000000..348829bf06
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable_func.go
@@ -0,0 +1,15 @@
+// +build !windows
+
+package ole
+
+func (v *IInspectable) GetIids() ([]*GUID, error) {
+	return []*GUID{}, NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetRuntimeClassName() (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetTrustLevel() (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable_windows.go b/vendor/github.com/go-ole/go-ole/iinspectable_windows.go
new file mode 100644
index 0000000000..4519a4aa44
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable_windows.go
@@ -0,0 +1,72 @@
+// +build windows
+
+package ole
+
+import (
+	"bytes"
+	"encoding/binary"
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func (v *IInspectable) GetIids() (iids []*GUID, err error) {
+	var count uint32
+	var array uintptr
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetIIds,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&count)),
+		uintptr(unsafe.Pointer(&array)))
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	defer CoTaskMemFree(array)
+
+	iids = make([]*GUID, count)
+	byteCount := count * uint32(unsafe.Sizeof(GUID{}))
+	slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)}
+	byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr))
+	reader := bytes.NewReader(byteSlice)
+	for i := range iids {
+		guid := GUID{}
+		err = binary.Read(reader, binary.LittleEndian, &guid)
+		if err != nil {
+			return
+		}
+		iids[i] = &guid
+	}
+	return
+}
+
+func (v *IInspectable) GetRuntimeClassName() (s string, err error) {
+	var hstring HString
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetRuntimeClassName,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&hstring)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	s = hstring.String()
+	DeleteHString(hstring)
+	return
+}
+
+func (v *IInspectable) GetTrustLevel() (level uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetTrustLevel,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&level)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go
new file mode 100644
index 0000000000..25f3a6f24a
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go
@@ -0,0 +1,21 @@
+package ole
+
+import "unsafe"
+
+type IProvideClassInfo struct {
+	IUnknown
+}
+
+type IProvideClassInfoVtbl struct {
+	IUnknownVtbl
+	GetClassInfo uintptr
+}
+
+func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl {
+	return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) {
+	cinfo, err = getClassInfo(v)
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go
new file mode 100644
index 0000000000..7e3cb63ea7
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go
@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go
new file mode 100644
index 0000000000..2ad0163949
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go
@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetClassInfo,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&tinfo)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo.go b/vendor/github.com/go-ole/go-ole/itypeinfo.go
new file mode 100644
index 0000000000..dd3c5e21bb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo.go
@@ -0,0 +1,34 @@
+package ole
+
+import "unsafe"
+
+type ITypeInfo struct {
+	IUnknown
+}
+
+type ITypeInfoVtbl struct {
+	IUnknownVtbl
+	GetTypeAttr          uintptr
+	GetTypeComp          uintptr
+	GetFuncDesc          uintptr
+	GetVarDesc           uintptr
+	GetNames             uintptr
+	GetRefTypeOfImplType uintptr
+	GetImplTypeFlags     uintptr
+	GetIDsOfNames        uintptr
+	Invoke               uintptr
+	GetDocumentation     uintptr
+	GetDllEntry          uintptr
+	GetRefTypeInfo       uintptr
+	AddressOfMember      uintptr
+	CreateInstance       uintptr
+	GetMops              uintptr
+	GetContainingTypeLib uintptr
+	ReleaseTypeAttr      uintptr
+	ReleaseFuncDesc      uintptr
+	ReleaseVarDesc       uintptr
+}
+
+func (v *ITypeInfo) VTable() *ITypeInfoVtbl {
+	return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo_func.go b/vendor/github.com/go-ole/go-ole/itypeinfo_func.go
new file mode 100644
index 0000000000..8364a659ba
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo_func.go
@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
+	return nil, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go b/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go
new file mode 100644
index 0000000000..54782b3da5
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go
@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) {
+	hr, _, _ := syscall.Syscall(
+		uintptr(v.VTable().GetTypeAttr),
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&tattr)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown.go b/vendor/github.com/go-ole/go-ole/iunknown.go
new file mode 100644
index 0000000000..108f28ea61
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown.go
@@ -0,0 +1,57 @@
+package ole
+
+import "unsafe"
+
+type IUnknown struct {
+	RawVTable *interface{}
+}
+
+type IUnknownVtbl struct {
+	QueryInterface uintptr
+	AddRef         uintptr
+	Release        uintptr
+}
+
+type UnknownLike interface {
+	QueryInterface(iid *GUID) (disp *IDispatch, err error)
+	AddRef() int32
+	Release() int32
+}
+
+func (v *IUnknown) VTable() *IUnknownVtbl {
+	return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error {
+	return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj)
+}
+
+func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) {
+	err = v.PutQueryInterface(interfaceID, &dispatch)
+	return
+}
+
+func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) {
+	err = v.PutQueryInterface(interfaceID, &enum)
+	return
+}
+
+func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) {
+	return queryInterface(v, iid)
+}
+
+func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) {
+	unk, err := queryInterface(v, iid)
+	if err != nil {
+		panic(err)
+	}
+	return unk
+}
+
+func (v *IUnknown) AddRef() int32 {
+	return addRef(v)
+}
+
+func (v *IUnknown) Release() int32 {
+	return release(v)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown_func.go b/vendor/github.com/go-ole/go-ole/iunknown_func.go
new file mode 100644
index 0000000000..d0a62cfd73
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown_func.go
@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	return NewError(E_NOTIMPL)
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func addRef(unk *IUnknown) int32 {
+	return 0
+}
+
+func release(unk *IUnknown) int32 {
+	return 0
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown_windows.go b/vendor/github.com/go-ole/go-ole/iunknown_windows.go
new file mode 100644
index 0000000000..ede5bb8c17
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown_windows.go
@@ -0,0 +1,58 @@
+// +build windows
+
+package ole
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	selfValue := reflect.ValueOf(self).Elem()
+	objValue := reflect.ValueOf(obj).Elem()
+
+	hr, _, _ := syscall.Syscall(
+		method,
+		3,
+		selfValue.UnsafeAddr(),
+		uintptr(unsafe.Pointer(interfaceID)),
+		objValue.Addr().Pointer())
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	hr, _, _ := syscall.Syscall(
+		unk.VTable().QueryInterface,
+		3,
+		uintptr(unsafe.Pointer(unk)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func addRef(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().AddRef,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}
+
+func release(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().Release,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}
diff --git a/vendor/github.com/go-ole/go-ole/ole.go b/vendor/github.com/go-ole/go-ole/ole.go
new file mode 100644
index 0000000000..e2ae4f4bbf
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ole.go
@@ -0,0 +1,157 @@
+package ole
+
+import (
+	"fmt"
+	"strings"
+)
+
+// DISPPARAMS are the arguments that passed to methods or property.
+type DISPPARAMS struct {
+	rgvarg            uintptr
+	rgdispidNamedArgs uintptr
+	cArgs             uint32
+	cNamedArgs        uint32
+}
+
+// EXCEPINFO defines exception info.
+type EXCEPINFO struct {
+	wCode             uint16
+	wReserved         uint16
+	bstrSource        *uint16
+	bstrDescription   *uint16
+	bstrHelpFile      *uint16
+	dwHelpContext     uint32
+	pvReserved        uintptr
+	pfnDeferredFillIn uintptr
+	scode             uint32
+}
+
+// WCode return wCode in EXCEPINFO.
+func (e EXCEPINFO) WCode() uint16 {
+	return e.wCode
+}
+
+// SCODE return scode in EXCEPINFO.
+func (e EXCEPINFO) SCODE() uint32 {
+	return e.scode
+}
+
+// String convert EXCEPINFO to string.
+func (e EXCEPINFO) String() string {
+	var src, desc, hlp string
+	if e.bstrSource == nil {
+		src = ""
+	} else {
+		src = BstrToString(e.bstrSource)
+	}
+
+	if e.bstrDescription == nil {
+		desc = ""
+	} else {
+		desc = BstrToString(e.bstrDescription)
+	}
+
+	if e.bstrHelpFile == nil {
+		hlp = ""
+	} else {
+		hlp = BstrToString(e.bstrHelpFile)
+	}
+
+	return fmt.Sprintf(
+		"wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x",
+		e.wCode, src, desc, hlp, e.dwHelpContext, e.scode,
+	)
+}
+
+// Error implements error interface and returns error string.
+func (e EXCEPINFO) Error() string {
+	if e.bstrDescription != nil {
+		return strings.TrimSpace(BstrToString(e.bstrDescription))
+	}
+
+	src := "Unknown"
+	if e.bstrSource != nil {
+		src = BstrToString(e.bstrSource)
+	}
+
+	code := e.scode
+	if e.wCode != 0 {
+		code = uint32(e.wCode)
+	}
+
+	return fmt.Sprintf("%v: %#x", src, code)
+}
+
+// PARAMDATA defines parameter data type.
+type PARAMDATA struct {
+	Name *int16
+	Vt   uint16
+}
+
+// METHODDATA defines method info.
+type METHODDATA struct {
+	Name     *uint16
+	Data     *PARAMDATA
+	Dispid   int32
+	Meth     uint32
+	CC       int32
+	CArgs    uint32
+	Flags    uint16
+	VtReturn uint32
+}
+
+// INTERFACEDATA defines interface info.
+type INTERFACEDATA struct {
+	MethodData *METHODDATA
+	CMembers   uint32
+}
+
+// Point is 2D vector type.
+type Point struct {
+	X int32
+	Y int32
+}
+
+// Msg is message between processes.
+type Msg struct {
+	Hwnd    uint32
+	Message uint32
+	Wparam  int32
+	Lparam  int32
+	Time    uint32
+	Pt      Point
+}
+
+// TYPEDESC defines data type.
+type TYPEDESC struct {
+	Hreftype uint32
+	VT       uint16
+}
+
+// IDLDESC defines IDL info.
+type IDLDESC struct {
+	DwReserved uint32
+	WIDLFlags  uint16
+}
+
+// TYPEATTR defines type info.
+type TYPEATTR struct {
+	Guid             GUID
+	Lcid             uint32
+	dwReserved       uint32
+	MemidConstructor int32
+	MemidDestructor  int32
+	LpstrSchema      *uint16
+	CbSizeInstance   uint32
+	Typekind         int32
+	CFuncs           uint16
+	CVars            uint16
+	CImplTypes       uint16
+	CbSizeVft        uint16
+	CbAlignment      uint16
+	WTypeFlags       uint16
+	WMajorVerNum     uint16
+	WMinorVerNum     uint16
+	TdescAlias       TYPEDESC
+	IdldescType      IDLDESC
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection.go b/vendor/github.com/go-ole/go-ole/oleutil/connection.go
new file mode 100644
index 0000000000..60df73cda0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection.go
@@ -0,0 +1,100 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+type stdDispatch struct {
+	lpVtbl  *stdDispatchVtbl
+	ref     int32
+	iid     *ole.GUID
+	iface   interface{}
+	funcMap map[string]int32
+}
+
+type stdDispatchVtbl struct {
+	pQueryInterface   uintptr
+	pAddRef           uintptr
+	pRelease          uintptr
+	pGetTypeInfoCount uintptr
+	pGetTypeInfo      uintptr
+	pGetIDsOfNames    uintptr
+	pInvoke           uintptr
+}
+
+func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	*punk = nil
+	if ole.IsEqualGUID(iid, ole.IID_IUnknown) ||
+		ole.IsEqualGUID(iid, ole.IID_IDispatch) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	if ole.IsEqualGUID(iid, pthis.iid) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	return ole.E_NOINTERFACE
+}
+
+func dispAddRef(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref++
+	return pthis.ref
+}
+
+func dispRelease(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref--
+	return pthis.ref
+}
+
+func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	names := make([]string, len(wnames))
+	for i := 0; i < len(names); i++ {
+		names[i] = ole.LpOleStrToString(wnames[i])
+	}
+	for n := 0; n < namelen; n++ {
+		if id, ok := pthis.funcMap[names[n]]; ok {
+			pdisp[n] = id
+		}
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfoCount(pcount *int) uintptr {
+	if pcount != nil {
+		*pcount = 0
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfo(ptypeif *uintptr) uintptr {
+	return ole.E_NOTIMPL
+}
+
+func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	found := ""
+	for name, id := range pthis.funcMap {
+		if id == dispid {
+			found = name
+		}
+	}
+	if found != "" {
+		rv := reflect.ValueOf(pthis.iface).Elem()
+		rm := rv.MethodByName(found)
+		rr := rm.Call([]reflect.Value{})
+		println(len(rr))
+		return ole.S_OK
+	}
+	return ole.E_NOTIMPL
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go b/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go
new file mode 100644
index 0000000000..8818fb8275
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go
@@ -0,0 +1,10 @@
+// +build !windows
+
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) {
+	return 0, ole.NewError(ole.E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go b/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go
new file mode 100644
index 0000000000..ab9c0d8dcb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go
@@ -0,0 +1,58 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) {
+	unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer)
+	if err != nil {
+		return
+	}
+
+	container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown))
+	var point *ole.IConnectionPoint
+	err = container.FindConnectionPoint(iid, &point)
+	if err != nil {
+		return
+	}
+	if edisp, ok := idisp.(*ole.IUnknown); ok {
+		cookie, err = point.Advise(edisp)
+		container.Release()
+		if err != nil {
+			return
+		}
+	}
+	rv := reflect.ValueOf(disp).Elem()
+	if rv.Type().Kind() == reflect.Struct {
+		dest := &stdDispatch{}
+		dest.lpVtbl = &stdDispatchVtbl{}
+		dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface)
+		dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef)
+		dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease)
+		dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount)
+		dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo)
+		dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames)
+		dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke)
+		dest.iface = disp
+		dest.iid = iid
+		cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest)))
+		container.Release()
+		if err != nil {
+			point.Release()
+			return
+		}
+		return
+	}
+
+	container.Release()
+
+	return 0, ole.NewError(ole.E_INVALIDARG)
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/go-get.go b/vendor/github.com/go-ole/go-ole/oleutil/go-get.go
new file mode 100644
index 0000000000..58347628f2
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/go-get.go
@@ -0,0 +1,6 @@
+// This file is here so go get succeeds as without it errors with:
+// no buildable Go source files in ...
+//
+// +build !windows
+
+package oleutil
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go b/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go
new file mode 100644
index 0000000000..f7803c1e30
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go
@@ -0,0 +1,127 @@
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ClassIDFrom retrieves class ID whether given is program ID or application string.
+func ClassIDFrom(programID string) (classID *ole.GUID, err error) {
+	return ole.ClassIDFrom(programID)
+}
+
+// CreateObject creates object from programID based on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func CreateObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetActiveObject retrieves active object for program ID and interface ID based
+// on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// CallMethod calls method on IDispatch with parameters.
+func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params)
+}
+
+// MustCallMethod calls method on IDispatch with parameters or panics.
+func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := CallMethod(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// GetProperty retrieves property from IDispatch.
+func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params)
+}
+
+// MustGetProperty retrieves property from IDispatch or panics.
+func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := GetProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutProperty mutates property.
+func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params)
+}
+
+// MustPutProperty mutates property or panics.
+func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutPropertyRef mutates property reference.
+func PutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUTREF, params)
+}
+
+// MustPutPropertyRef mutates property reference or panics.
+func MustPutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutPropertyRef(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error {
+	newEnum, err := disp.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer newEnum.Clear()
+
+	enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	defer enum.Release()
+
+	for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+		if ferr := f(&item); ferr != nil {
+			return ferr
+		}
+	}
+	return nil
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearray.go b/vendor/github.com/go-ole/go-ole/safearray.go
new file mode 100644
index 0000000000..a5201b56c3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray.go
@@ -0,0 +1,27 @@
+// Package is meant to retrieve and process safe array data returned from COM.
+
+package ole
+
+// SafeArrayBound defines the SafeArray boundaries.
+type SafeArrayBound struct {
+	Elements   uint32
+	LowerBound int32
+}
+
+// SafeArray is how COM handles arrays.
+type SafeArray struct {
+	Dimensions   uint16
+	FeaturesFlag uint16
+	ElementsSize uint32
+	LocksAmount  uint32
+	Data         uint32
+	Bounds       [16]byte
+}
+
+// SAFEARRAY is obsolete, exists for backwards compatibility.
+// Use SafeArray
+type SAFEARRAY SafeArray
+
+// SAFEARRAYBOUND is obsolete, exists for backwards compatibility.
+// Use SafeArrayBound
+type SAFEARRAYBOUND SafeArrayBound
diff --git a/vendor/github.com/go-ole/go-ole/safearray_func.go b/vendor/github.com/go-ole/go-ole/safearray_func.go
new file mode 100644
index 0000000000..8ff0baa41d
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray_func.go
@@ -0,0 +1,211 @@
+// +build !windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+func safeArrayAccessData(safearray *SafeArray) (uintptr, error) {
+	return uintptr(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int64) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int64, error) {
+	return int64(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int64, error) {
+	return int64(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (uint16, error) {
+	return uint16(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error {
+	return NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearray_windows.go b/vendor/github.com/go-ole/go-ole/safearray_windows.go
new file mode 100644
index 0000000000..b27936e24e
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray_windows.go
@@ -0,0 +1,337 @@
+// +build windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+var (
+	procSafeArrayAccessData, _        = modoleaut32.FindProc("SafeArrayAccessData")
+	procSafeArrayAllocData, _         = modoleaut32.FindProc("SafeArrayAllocData")
+	procSafeArrayAllocDescriptor, _   = modoleaut32.FindProc("SafeArrayAllocDescriptor")
+	procSafeArrayAllocDescriptorEx, _ = modoleaut32.FindProc("SafeArrayAllocDescriptorEx")
+	procSafeArrayCopy, _              = modoleaut32.FindProc("SafeArrayCopy")
+	procSafeArrayCopyData, _          = modoleaut32.FindProc("SafeArrayCopyData")
+	procSafeArrayCreate, _            = modoleaut32.FindProc("SafeArrayCreate")
+	procSafeArrayCreateEx, _          = modoleaut32.FindProc("SafeArrayCreateEx")
+	procSafeArrayCreateVector, _      = modoleaut32.FindProc("SafeArrayCreateVector")
+	procSafeArrayCreateVectorEx, _    = modoleaut32.FindProc("SafeArrayCreateVectorEx")
+	procSafeArrayDestroy, _           = modoleaut32.FindProc("SafeArrayDestroy")
+	procSafeArrayDestroyData, _       = modoleaut32.FindProc("SafeArrayDestroyData")
+	procSafeArrayDestroyDescriptor, _ = modoleaut32.FindProc("SafeArrayDestroyDescriptor")
+	procSafeArrayGetDim, _            = modoleaut32.FindProc("SafeArrayGetDim")
+	procSafeArrayGetElement, _        = modoleaut32.FindProc("SafeArrayGetElement")
+	procSafeArrayGetElemsize, _       = modoleaut32.FindProc("SafeArrayGetElemsize")
+	procSafeArrayGetIID, _            = modoleaut32.FindProc("SafeArrayGetIID")
+	procSafeArrayGetLBound, _         = modoleaut32.FindProc("SafeArrayGetLBound")
+	procSafeArrayGetUBound, _         = modoleaut32.FindProc("SafeArrayGetUBound")
+	procSafeArrayGetVartype, _        = modoleaut32.FindProc("SafeArrayGetVartype")
+	procSafeArrayLock, _              = modoleaut32.FindProc("SafeArrayLock")
+	procSafeArrayPtrOfIndex, _        = modoleaut32.FindProc("SafeArrayPtrOfIndex")
+	procSafeArrayUnaccessData, _      = modoleaut32.FindProc("SafeArrayUnaccessData")
+	procSafeArrayUnlock, _            = modoleaut32.FindProc("SafeArrayUnlock")
+	procSafeArrayPutElement, _        = modoleaut32.FindProc("SafeArrayPutElement")
+	//procSafeArrayRedim, _             = modoleaut32.FindProc("SafeArrayRedim") // TODO
+	//procSafeArraySetIID, _            = modoleaut32.FindProc("SafeArraySetIID") // TODO
+	procSafeArrayGetRecordInfo, _ = modoleaut32.FindProc("SafeArrayGetRecordInfo")
+	procSafeArraySetRecordInfo, _ = modoleaut32.FindProc("SafeArraySetRecordInfo")
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+// Todo: Test
+func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) {
+	err = convertHresultToError(
+		procSafeArrayAccessData.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&element))))
+	return
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptorEx.Call(
+			uintptr(variantType),
+			uintptr(dimensions),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayCopy.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) {
+	err = convertHresultToError(
+		procSafeArrayCopyData.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(duplicate))))
+	return
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreate.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)))
+	safearray = (*SafeArray)(unsafe.Pointer(&sa))
+	return
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateEx.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVector.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length))
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVectorEx.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) {
+	l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray)))
+	dimensions = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) {
+	l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray)))
+	length = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error {
+	return convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(pv)))
+}
+
+// safeArrayGetElementString retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int64) (str string, err error) {
+	var element *int16
+	err = convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(&element))))
+	str = BstrToString(*(**uint16)(unsafe.Pointer(&element)))
+	SysFreeString(element)
+	return
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetIID.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&guid))))
+	return
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int64, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetLBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&lowerBound))))
+	return
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int64, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetUBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&upperBound))))
+	return
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetVartype.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&varType))))
+	return
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) {
+	err = convertHresultToError(
+		procSafeArrayPutElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(element))))
+	return
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) {
+	err = convertHresultToError(
+		procSafeArraySetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearrayconversion.go b/vendor/github.com/go-ole/go-ole/safearrayconversion.go
new file mode 100644
index 0000000000..ffeb2b97b0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearrayconversion.go
@@ -0,0 +1,140 @@
+// Helper for converting SafeArray to array of objects.
+
+package ole
+
+import (
+	"unsafe"
+)
+
+type SafeArrayConversion struct {
+	Array *SafeArray
+}
+
+func (sac *SafeArrayConversion) ToStringArray() (strings []string) {
+	totalElements, _ := sac.TotalElements(0)
+	strings = make([]string, totalElements)
+
+	for i := int64(0); i < totalElements; i++ {
+		strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i)
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) {
+	totalElements, _ := sac.TotalElements(0)
+	bytes = make([]byte, totalElements)
+
+	for i := int64(0); i < totalElements; i++ {
+		safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)]))
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) {
+	totalElements, _ := sac.TotalElements(0)
+	values = make([]interface{}, totalElements)
+	vt, _ := safeArrayGetVartype(sac.Array)
+
+	for i := 0; i < int(totalElements); i++ {
+		switch VT(vt) {
+		case VT_BOOL:
+			var v bool
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I1:
+			var v int8
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I2:
+			var v int16
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I4:
+			var v int32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I8:
+			var v int64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI1:
+			var v uint8
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI2:
+			var v uint16
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI4:
+			var v uint32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI8:
+			var v uint64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R4:
+			var v float32
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R8:
+			var v float64
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_BSTR:
+			var v string
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v
+		case VT_VARIANT:
+			var v VARIANT
+			safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v))
+			values[i] = v.Value()
+		default:
+			// TODO
+		}
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) GetType() (varType uint16, err error) {
+	return safeArrayGetVartype(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) {
+	return safeArrayGetDim(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) {
+	return safeArrayGetElementSize(sac.Array)
+}
+
+func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int64, err error) {
+	if index < 1 {
+		index = 1
+	}
+
+	// Get array bounds
+	var LowerBounds int64
+	var UpperBounds int64
+
+	LowerBounds, err = safeArrayGetLBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	UpperBounds, err = safeArrayGetUBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	totalElements = UpperBounds - LowerBounds + 1
+	return
+}
+
+// Release Safe Array memory
+func (sac *SafeArrayConversion) Release() {
+	safeArrayDestroy(sac.Array)
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearrayslices.go b/vendor/github.com/go-ole/go-ole/safearrayslices.go
new file mode 100644
index 0000000000..a9fa885f1d
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearrayslices.go
@@ -0,0 +1,33 @@
+// +build windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+func safeArrayFromByteSlice(slice []byte) *SafeArray {
+	array, _ := safeArrayCreateVector(VT_UI1, 0, uint32(len(slice)))
+
+	if array == nil {
+		panic("Could not convert []byte to SAFEARRAY")
+	}
+
+	for i, v := range slice {
+		safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(&v)))
+	}
+	return array
+}
+
+func safeArrayFromStringSlice(slice []string) *SafeArray {
+	array, _ := safeArrayCreateVector(VT_BSTR, 0, uint32(len(slice)))
+
+	if array == nil {
+		panic("Could not convert []string to SAFEARRAY")
+	}
+	// SysAllocStringLen(s)
+	for i, v := range slice {
+		safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(SysAllocStringLen(v))))
+	}
+	return array
+}
diff --git a/vendor/github.com/go-ole/go-ole/utility.go b/vendor/github.com/go-ole/go-ole/utility.go
new file mode 100644
index 0000000000..99ee82dc34
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/utility.go
@@ -0,0 +1,101 @@
+package ole
+
+import (
+	"unicode/utf16"
+	"unsafe"
+)
+
+// ClassIDFrom retrieves class ID whether given is program ID or application string.
+//
+// Helper that provides check against both Class ID from Program ID and Class ID from string. It is
+// faster, if you know which you are using, to use the individual functions, but this will check
+// against available functions for you.
+func ClassIDFrom(programID string) (classID *GUID, err error) {
+	classID, err = CLSIDFromProgID(programID)
+	if err != nil {
+		classID, err = CLSIDFromString(programID)
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+// BytePtrToString converts byte pointer to a Go string.
+func BytePtrToString(p *byte) string {
+	a := (*[10000]uint8)(unsafe.Pointer(p))
+	i := 0
+	for a[i] != 0 {
+		i++
+	}
+	return string(a[:i])
+}
+
+// UTF16PtrToString is alias for LpOleStrToString.
+//
+// Kept for compatibility reasons.
+func UTF16PtrToString(p *uint16) string {
+	return LpOleStrToString(p)
+}
+
+// LpOleStrToString converts COM Unicode to Go string.
+func LpOleStrToString(p *uint16) string {
+	if p == nil {
+		return ""
+	}
+
+	length := lpOleStrLen(p)
+	a := make([]uint16, length)
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; i < int(length); i++ {
+		a[i] = *(*uint16)(ptr)
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+
+	return string(utf16.Decode(a))
+}
+
+// BstrToString converts COM binary string to Go string.
+func BstrToString(p *uint16) string {
+	if p == nil {
+		return ""
+	}
+	length := SysStringLen((*int16)(unsafe.Pointer(p)))
+	a := make([]uint16, length)
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; i < int(length); i++ {
+		a[i] = *(*uint16)(ptr)
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+	return string(utf16.Decode(a))
+}
+
+// lpOleStrLen returns the length of Unicode string.
+func lpOleStrLen(p *uint16) (length int64) {
+	if p == nil {
+		return 0
+	}
+
+	ptr := unsafe.Pointer(p)
+
+	for i := 0; ; i++ {
+		if 0 == *(*uint16)(ptr) {
+			length = int64(i)
+			break
+		}
+		ptr = unsafe.Pointer(uintptr(ptr) + 2)
+	}
+	return
+}
+
+// convertHresultToError converts syscall to error, if call is unsuccessful.
+func convertHresultToError(hr uintptr, r2 uintptr, ignore error) (err error) {
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
diff --git a/vendor/github.com/go-ole/go-ole/variables.go b/vendor/github.com/go-ole/go-ole/variables.go
new file mode 100644
index 0000000000..ebe00f1cfc
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variables.go
@@ -0,0 +1,16 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+)
+
+var (
+	modcombase     = syscall.NewLazyDLL("combase.dll")
+	modkernel32, _ = syscall.LoadDLL("kernel32.dll")
+	modole32, _    = syscall.LoadDLL("ole32.dll")
+	modoleaut32, _ = syscall.LoadDLL("oleaut32.dll")
+	modmsvcrt, _   = syscall.LoadDLL("msvcrt.dll")
+	moduser32, _   = syscall.LoadDLL("user32.dll")
+)
diff --git a/vendor/github.com/go-ole/go-ole/variant.go b/vendor/github.com/go-ole/go-ole/variant.go
new file mode 100644
index 0000000000..36969725eb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant.go
@@ -0,0 +1,105 @@
+package ole
+
+import "unsafe"
+
+// NewVariant returns new variant based on type and value.
+func NewVariant(vt VT, val int64) VARIANT {
+	return VARIANT{VT: vt, Val: val}
+}
+
+// ToIUnknown converts Variant to Unknown object.
+func (v *VARIANT) ToIUnknown() *IUnknown {
+	if v.VT != VT_UNKNOWN {
+		return nil
+	}
+	return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
+}
+
+// ToIDispatch converts variant to dispatch object.
+func (v *VARIANT) ToIDispatch() *IDispatch {
+	if v.VT != VT_DISPATCH {
+		return nil
+	}
+	return (*IDispatch)(unsafe.Pointer(uintptr(v.Val)))
+}
+
+// ToArray converts variant to SafeArray helper.
+func (v *VARIANT) ToArray() *SafeArrayConversion {
+	if v.VT != VT_SAFEARRAY {
+		if v.VT&VT_ARRAY == 0 {
+			return nil
+		}
+	}
+	var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val)))
+	return &SafeArrayConversion{safeArray}
+}
+
+// ToString converts variant to Go string.
+func (v *VARIANT) ToString() string {
+	if v.VT != VT_BSTR {
+		return ""
+	}
+	return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val)))
+}
+
+// Clear the memory of variant object.
+func (v *VARIANT) Clear() error {
+	return VariantClear(v)
+}
+
+// Value returns variant value based on its type.
+//
+// Currently supported types: 2- and 4-byte integers, strings, bools.
+// Note that 64-bit integers, datetimes, and other types are stored as strings
+// and will be returned as strings.
+//
+// Needs to be further converted, because this returns an interface{}.
+func (v *VARIANT) Value() interface{} {
+	switch v.VT {
+	case VT_I1:
+		return int8(v.Val)
+	case VT_UI1:
+		return uint8(v.Val)
+	case VT_I2:
+		return int16(v.Val)
+	case VT_UI2:
+		return uint16(v.Val)
+	case VT_I4:
+		return int32(v.Val)
+	case VT_UI4:
+		return uint32(v.Val)
+	case VT_I8:
+		return int64(v.Val)
+	case VT_UI8:
+		return uint64(v.Val)
+	case VT_INT:
+		return int(v.Val)
+	case VT_UINT:
+		return uint(v.Val)
+	case VT_INT_PTR:
+		return uintptr(v.Val) // TODO
+	case VT_UINT_PTR:
+		return uintptr(v.Val)
+	case VT_R4:
+		return *(*float32)(unsafe.Pointer(&v.Val))
+	case VT_R8:
+		return *(*float64)(unsafe.Pointer(&v.Val))
+	case VT_BSTR:
+		return v.ToString()
+	case VT_DATE:
+		// VT_DATE type will either return float64 or time.Time.
+		d := float64(v.Val)
+		date, err := GetVariantDate(d)
+		if err != nil {
+			return d
+		}
+		return date
+	case VT_UNKNOWN:
+		return v.ToIUnknown()
+	case VT_DISPATCH:
+		return v.ToIDispatch()
+	case VT_BOOL:
+		return v.Val != 0
+	}
+	return nil
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_386.go b/vendor/github.com/go-ole/go-ole/variant_386.go
new file mode 100644
index 0000000000..e73736bf39
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_386.go
@@ -0,0 +1,11 @@
+// +build 386
+
+package ole
+
+type VARIANT struct {
+	VT         VT     //  2
+	wReserved1 uint16 //  4
+	wReserved2 uint16 //  6
+	wReserved3 uint16 //  8
+	Val        int64  // 16
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_amd64.go b/vendor/github.com/go-ole/go-ole/variant_amd64.go
new file mode 100644
index 0000000000..dccdde1323
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_amd64.go
@@ -0,0 +1,12 @@
+// +build amd64
+
+package ole
+
+type VARIANT struct {
+	VT         VT      //  2
+	wReserved1 uint16  //  4
+	wReserved2 uint16  //  6
+	wReserved3 uint16  //  8
+	Val        int64   // 16
+	_          [8]byte // 24
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_s390x.go b/vendor/github.com/go-ole/go-ole/variant_s390x.go
new file mode 100644
index 0000000000..9874ca66b4
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_s390x.go
@@ -0,0 +1,12 @@
+// +build s390x
+
+package ole
+
+type VARIANT struct {
+	VT         VT      //  2
+	wReserved1 uint16  //  4
+	wReserved2 uint16  //  6
+	wReserved3 uint16  //  8
+	Val        int64   // 16
+	_          [8]byte // 24
+}
diff --git a/vendor/github.com/go-ole/go-ole/vt_string.go b/vendor/github.com/go-ole/go-ole/vt_string.go
new file mode 100644
index 0000000000..729b4a04dd
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/vt_string.go
@@ -0,0 +1,58 @@
+// generated by stringer -output vt_string.go -type VT; DO NOT EDIT
+
+package ole
+
+import "fmt"
+
+const (
+	_VT_name_0 = "VT_EMPTYVT_NULLVT_I2VT_I4VT_R4VT_R8VT_CYVT_DATEVT_BSTRVT_DISPATCHVT_ERRORVT_BOOLVT_VARIANTVT_UNKNOWNVT_DECIMAL"
+	_VT_name_1 = "VT_I1VT_UI1VT_UI2VT_UI4VT_I8VT_UI8VT_INTVT_UINTVT_VOIDVT_HRESULTVT_PTRVT_SAFEARRAYVT_CARRAYVT_USERDEFINEDVT_LPSTRVT_LPWSTR"
+	_VT_name_2 = "VT_RECORDVT_INT_PTRVT_UINT_PTR"
+	_VT_name_3 = "VT_FILETIMEVT_BLOBVT_STREAMVT_STORAGEVT_STREAMED_OBJECTVT_STORED_OBJECTVT_BLOB_OBJECTVT_CFVT_CLSID"
+	_VT_name_4 = "VT_BSTR_BLOBVT_VECTOR"
+	_VT_name_5 = "VT_ARRAY"
+	_VT_name_6 = "VT_BYREF"
+	_VT_name_7 = "VT_RESERVED"
+	_VT_name_8 = "VT_ILLEGAL"
+)
+
+var (
+	_VT_index_0 = [...]uint8{0, 8, 15, 20, 25, 30, 35, 40, 47, 54, 65, 73, 80, 90, 100, 110}
+	_VT_index_1 = [...]uint8{0, 5, 11, 17, 23, 28, 34, 40, 47, 54, 64, 70, 82, 91, 105, 113, 122}
+	_VT_index_2 = [...]uint8{0, 9, 19, 30}
+	_VT_index_3 = [...]uint8{0, 11, 18, 27, 37, 55, 71, 85, 90, 98}
+	_VT_index_4 = [...]uint8{0, 12, 21}
+	_VT_index_5 = [...]uint8{0, 8}
+	_VT_index_6 = [...]uint8{0, 8}
+	_VT_index_7 = [...]uint8{0, 11}
+	_VT_index_8 = [...]uint8{0, 10}
+)
+
+func (i VT) String() string {
+	switch {
+	case 0 <= i && i <= 14:
+		return _VT_name_0[_VT_index_0[i]:_VT_index_0[i+1]]
+	case 16 <= i && i <= 31:
+		i -= 16
+		return _VT_name_1[_VT_index_1[i]:_VT_index_1[i+1]]
+	case 36 <= i && i <= 38:
+		i -= 36
+		return _VT_name_2[_VT_index_2[i]:_VT_index_2[i+1]]
+	case 64 <= i && i <= 72:
+		i -= 64
+		return _VT_name_3[_VT_index_3[i]:_VT_index_3[i+1]]
+	case 4095 <= i && i <= 4096:
+		i -= 4095
+		return _VT_name_4[_VT_index_4[i]:_VT_index_4[i+1]]
+	case i == 8192:
+		return _VT_name_5
+	case i == 16384:
+		return _VT_name_6
+	case i == 32768:
+		return _VT_name_7
+	case i == 65535:
+		return _VT_name_8
+	default:
+		return fmt.Sprintf("VT(%d)", i)
+	}
+}
diff --git a/vendor/github.com/go-ole/go-ole/winrt.go b/vendor/github.com/go-ole/go-ole/winrt.go
new file mode 100644
index 0000000000..4e9eca7324
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/winrt.go
@@ -0,0 +1,99 @@
+// +build windows
+
+package ole
+
+import (
+	"reflect"
+	"syscall"
+	"unicode/utf8"
+	"unsafe"
+)
+
+var (
+	procRoInitialize              = modcombase.NewProc("RoInitialize")
+	procRoActivateInstance        = modcombase.NewProc("RoActivateInstance")
+	procRoGetActivationFactory    = modcombase.NewProc("RoGetActivationFactory")
+	procWindowsCreateString       = modcombase.NewProc("WindowsCreateString")
+	procWindowsDeleteString       = modcombase.NewProc("WindowsDeleteString")
+	procWindowsGetStringRawBuffer = modcombase.NewProc("WindowsGetStringRawBuffer")
+)
+
+func RoInitialize(thread_type uint32) (err error) {
+	hr, _, _ := procRoInitialize.Call(uintptr(thread_type))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func RoActivateInstance(clsid string) (ins *IInspectable, err error) {
+	hClsid, err := NewHString(clsid)
+	if err != nil {
+		return nil, err
+	}
+	defer DeleteHString(hClsid)
+
+	hr, _, _ := procRoActivateInstance.Call(
+		uintptr(unsafe.Pointer(hClsid)),
+		uintptr(unsafe.Pointer(&ins)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) {
+	hClsid, err := NewHString(clsid)
+	if err != nil {
+		return nil, err
+	}
+	defer DeleteHString(hClsid)
+
+	hr, _, _ := procRoGetActivationFactory.Call(
+		uintptr(unsafe.Pointer(hClsid)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&ins)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// HString is handle string for pointers.
+type HString uintptr
+
+// NewHString returns a new HString for Go string.
+func NewHString(s string) (hstring HString, err error) {
+	u16 := syscall.StringToUTF16Ptr(s)
+	len := uint32(utf8.RuneCountInString(s))
+	hr, _, _ := procWindowsCreateString.Call(
+		uintptr(unsafe.Pointer(u16)),
+		uintptr(len),
+		uintptr(unsafe.Pointer(&hstring)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// DeleteHString deletes HString.
+func DeleteHString(hstring HString) (err error) {
+	hr, _, _ := procWindowsDeleteString.Call(uintptr(hstring))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// String returns Go string value of HString.
+func (h HString) String() string {
+	var u16buf uintptr
+	var u16len uint32
+	u16buf, _, _ = procWindowsGetStringRawBuffer.Call(
+		uintptr(h),
+		uintptr(unsafe.Pointer(&u16len)))
+
+	u16hdr := reflect.SliceHeader{Data: u16buf, Len: int(u16len), Cap: int(u16len)}
+	u16 := *(*[]uint16)(unsafe.Pointer(&u16hdr))
+	return syscall.UTF16ToString(u16)
+}
diff --git a/vendor/github.com/go-ole/go-ole/winrt_doc.go b/vendor/github.com/go-ole/go-ole/winrt_doc.go
new file mode 100644
index 0000000000..52e6d74c9a
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/winrt_doc.go
@@ -0,0 +1,36 @@
+// +build !windows
+
+package ole
+
+// RoInitialize
+func RoInitialize(thread_type uint32) (err error) {
+	return NewError(E_NOTIMPL)
+}
+
+// RoActivateInstance
+func RoActivateInstance(clsid string) (ins *IInspectable, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// RoGetActivationFactory
+func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// HString is handle string for pointers.
+type HString uintptr
+
+// NewHString returns a new HString for Go string.
+func NewHString(s string) (hstring HString, err error) {
+	return HString(uintptr(0)), NewError(E_NOTIMPL)
+}
+
+// DeleteHString deletes HString.
+func DeleteHString(hstring HString) (err error) {
+	return NewError(E_NOTIMPL)
+}
+
+// String returns Go string value of HString.
+func (h HString) String() string {
+	return ""
+}
diff --git a/vendor/github.com/influxdata/influxdb/LICENSE b/vendor/github.com/influxdata/influxdb/LICENSE
new file mode 100644
index 0000000000..63cef79ba6
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2016 Errplane Inc.
+
+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/vendor/github.com/influxdata/influxdb/LICENSE_OF_DEPENDENCIES.md b/vendor/github.com/influxdata/influxdb/LICENSE_OF_DEPENDENCIES.md
new file mode 100644
index 0000000000..ea6fc69f30
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/LICENSE_OF_DEPENDENCIES.md
@@ -0,0 +1,62 @@
+- # List
+- bootstrap 3.3.5 [MIT LICENSE](https://github.com/twbs/bootstrap/blob/master/LICENSE)
+- collectd.org [ISC LICENSE](https://github.com/collectd/go-collectd/blob/master/LICENSE)
+- github.com/BurntSushi/toml [MIT LICENSE](https://github.com/BurntSushi/toml/blob/master/COPYING)
+- github.com/RoaringBitmap/roaring [APACHE LICENSE](https://github.com/RoaringBitmap/roaring/blob/master/LICENSE)
+- github.com/beorn7/perks [MIT LICENSE](https://github.com/beorn7/perks/blob/master/LICENSE)
+- github.com/bmizerany/pat [MIT LICENSE](https://github.com/bmizerany/pat#license)
+- github.com/boltdb/bolt [MIT LICENSE](https://github.com/boltdb/bolt/blob/master/LICENSE)
+- github.com/cespare/xxhash [MIT LICENSE](https://github.com/cespare/xxhash/blob/master/LICENSE.txt)
+- github.com/clarkduvall/hyperloglog [MIT LICENSE](https://github.com/clarkduvall/hyperloglog/blob/master/LICENSE)
+- github.com/davecgh/go-spew/spew [ISC LICENSE](https://github.com/davecgh/go-spew/blob/master/LICENSE)
+- github.com/dgrijalva/jwt-go [MIT LICENSE](https://github.com/dgrijalva/jwt-go/blob/master/LICENSE)
+- github.com/dgryski/go-bits [MIT LICENSE](https://github.com/dgryski/go-bits/blob/master/LICENSE)
+- github.com/dgryski/go-bitstream [MIT LICENSE](https://github.com/dgryski/go-bitstream/blob/master/LICENSE)
+- github.com/glycerine/go-unsnap-stream [MIT LICENSE](https://github.com/glycerine/go-unsnap-stream/blob/master/LICENSE)
+- github.com/gogo/protobuf/proto [BSD LICENSE](https://github.com/gogo/protobuf/blob/master/LICENSE)
+- github.com/golang/protobuf [BSD LICENSE](https://github.com/golang/protobuf/blob/master/LICENSE)
+- github.com/golang/snappy [BSD LICENSE](https://github.com/golang/snappy/blob/master/LICENSE)
+- github.com/google/go-cmp [BSD LICENSE](https://github.com/google/go-cmp/blob/master/LICENSE)
+- github.com/influxdata/influxql [MIT LICENSE](https://github.com/influxdata/influxql/blob/master/LICENSE)
+- github.com/influxdata/usage-client [MIT LICENSE](https://github.com/influxdata/usage-client/blob/master/LICENSE.txt)
+- github.com/influxdata/yamux [MOZILLA PUBLIC LICENSE](https://github.com/influxdata/yamux/blob/master/LICENSE)
+- github.com/influxdata/yarpc [MIT LICENSE](https://github.com/influxdata/yarpc/blob/master/LICENSE)
+- github.com/jsternberg/zap-logfmt [MIT LICENSE](https://github.com/jsternberg/zap-logfmt/blob/master/LICENSE)
+- github.com/jwilder/encoding [MIT LICENSE](https://github.com/jwilder/encoding/blob/master/LICENSE)
+- github.com/mattn/go-isatty [MIT LICENSE](https://github.com/mattn/go-isatty/blob/master/LICENSE)
+- github.com/matttproud/golang_protobuf_extensions [APACHE LICENSE](https://github.com/matttproud/golang_protobuf_extensions/blob/master/LICENSE)
+- github.com/opentracing/opentracing-go [MIT LICENSE](https://github.com/opentracing/opentracing-go/blob/master/LICENSE)
+- github.com/paulbellamy/ratecounter [MIT LICENSE](https://github.com/paulbellamy/ratecounter/blob/master/LICENSE)
+- github.com/peterh/liner [MIT LICENSE](https://github.com/peterh/liner/blob/master/COPYING)
+- github.com/philhofer/fwd [MIT LICENSE](https://github.com/philhofer/fwd/blob/master/LICENSE.md)
+- github.com/prometheus/client_golang [MIT LICENSE](https://github.com/prometheus/client_golang/blob/master/LICENSE)
+- github.com/prometheus/client_model [MIT LICENSE](https://github.com/prometheus/client_model/blob/master/LICENSE)
+- github.com/prometheus/common [APACHE LICENSE](https://github.com/prometheus/common/blob/master/LICENSE)
+- github.com/prometheus/procfs [APACHE LICENSE](https://github.com/prometheus/procfs/blob/master/LICENSE)
+- github.com/rakyll/statik [APACHE LICENSE](https://github.com/rakyll/statik/blob/master/LICENSE)
+- github.com/retailnext/hllpp [BSD LICENSE](https://github.com/retailnext/hllpp/blob/master/LICENSE)
+- github.com/tinylib/msgp [MIT LICENSE](https://github.com/tinylib/msgp/blob/master/LICENSE)
+- go.uber.org/atomic [MIT LICENSE](https://github.com/uber-go/atomic/blob/master/LICENSE.txt)
+- go.uber.org/multierr [MIT LICENSE](https://github.com/uber-go/multierr/blob/master/LICENSE.txt)
+- go.uber.org/zap [MIT LICENSE](https://github.com/uber-go/zap/blob/master/LICENSE.txt)
+- golang.org/x/crypto [BSD LICENSE](https://github.com/golang/crypto/blob/master/LICENSE)
+- golang.org/x/net [BSD LICENSE](https://github.com/golang/net/blob/master/LICENSE)
+- golang.org/x/sys [BSD LICENSE](https://github.com/golang/sys/blob/master/LICENSE)
+- golang.org/x/text [BSD LICENSE](https://github.com/golang/text/blob/master/LICENSE)
+- golang.org/x/time [BSD LICENSE](https://github.com/golang/time/blob/master/LICENSE)
+- jquery 2.1.4 [MIT LICENSE](https://github.com/jquery/jquery/blob/master/LICENSE.txt)
+- github.com/xlab/treeprint [MIT LICENSE](https://github.com/xlab/treeprint/blob/master/LICENSE)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/vendor/github.com/influxdata/influxdb/client/README.md b/vendor/github.com/influxdata/influxdb/client/README.md
new file mode 100644
index 0000000000..773a111228
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/client/README.md
@@ -0,0 +1,306 @@
+# InfluxDB Client
+
+[![GoDoc](https://godoc.org/github.com/influxdata/influxdb?status.svg)](http://godoc.org/github.com/influxdata/influxdb/client/v2)
+
+## Description
+
+**NOTE:** The Go client library now has a "v2" version, with the old version
+being deprecated. The new version can be imported at
+`import "github.com/influxdata/influxdb/client/v2"`. It is not backwards-compatible.
+
+A Go client library written and maintained by the **InfluxDB** team.
+This package provides convenience functions to read and write time series data.
+It uses the HTTP protocol to communicate with your **InfluxDB** cluster.
+
+
+## Getting Started
+
+### Connecting To Your Database
+
+Connecting to an **InfluxDB** database is straightforward. You will need a host
+name, a port and the cluster user credentials if applicable. The default port is
+8086. You can customize these settings to your specific installation via the
+**InfluxDB** configuration file.
+
+Though not necessary for experimentation, you may want to create a new user
+and authenticate the connection to your database.
+
+For more information please check out the
+[Admin Docs](https://docs.influxdata.com/influxdb/latest/administration/).
+
+For the impatient, you can create a new admin user _bubba_ by firing off the
+[InfluxDB CLI](https://github.com/influxdata/influxdb/blob/master/cmd/influx/main.go).
+
+```shell
+influx
+> create user bubba with password 'bumblebeetuna'
+> grant all privileges to bubba
+```
+
+And now for good measure set the credentials in you shell environment.
+In the example below we will use $INFLUX_USER and $INFLUX_PWD
+
+Now with the administrivia out of the way, let's connect to our database.
+
+NOTE: If you've opted out of creating a user, you can omit Username and Password in
+the configuration below.
+
+```go
+package main
+
+import (
+	"log"
+	"time"
+
+	"github.com/influxdata/influxdb/client/v2"
+)
+
+const (
+	MyDB = "square_holes"
+	username = "bubba"
+	password = "bumblebeetuna"
+)
+
+
+func main() {
+	// Create a new HTTPClient
+	c, err := client.NewHTTPClient(client.HTTPConfig{
+		Addr:     "http://localhost:8086",
+		Username: username,
+		Password: password,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a new point batch
+	bp, err := client.NewBatchPoints(client.BatchPointsConfig{
+		Database:  MyDB,
+		Precision: "s",
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create a point and add to batch
+	tags := map[string]string{"cpu": "cpu-total"}
+	fields := map[string]interface{}{
+		"idle":   10.1,
+		"system": 53.3,
+		"user":   46.6,
+	}
+
+	pt, err := client.NewPoint("cpu_usage", tags, fields, time.Now())
+	if err != nil {
+		log.Fatal(err)
+	}
+	bp.AddPoint(pt)
+
+	// Write the batch
+	if err := c.Write(bp); err != nil {
+		log.Fatal(err)
+	}
+}
+
+```
+
+### Inserting Data
+
+Time series data aka *points* are written to the database using batch inserts.
+The mechanism is to create one or more points and then create a batch aka
+*batch points* and write these to a given database and series. A series is a
+combination of a measurement (time/values) and a set of tags.
+
+In this sample we will create a batch of a 1,000 points. Each point has a time and
+a single value as well as 2 tags indicating a shape and color. We write these points
+to a database called _square_holes_ using a measurement named _shapes_.
+
+NOTE: You can specify a RetentionPolicy as part of the batch points. If not
+provided InfluxDB will use the database _default_ retention policy.
+
+```go
+
+func writePoints(clnt client.Client) {
+	sampleSize := 1000
+
+	bp, err := client.NewBatchPoints(client.BatchPointsConfig{
+		Database:  "systemstats",
+		Precision: "us",
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+    rand.Seed(time.Now().UnixNano())
+	for i := 0; i < sampleSize; i++ {
+		regions := []string{"us-west1", "us-west2", "us-west3", "us-east1"}
+		tags := map[string]string{
+			"cpu":    "cpu-total",
+			"host":   fmt.Sprintf("host%d", rand.Intn(1000)),
+			"region": regions[rand.Intn(len(regions))],
+		}
+
+		idle := rand.Float64() * 100.0
+		fields := map[string]interface{}{
+			"idle": idle,
+			"busy": 100.0 - idle,
+		}
+
+		pt, err := client.NewPoint(
+			"cpu_usage",
+			tags,
+			fields,
+			time.Now(),
+		)
+		if err != nil {
+			log.Fatal(err)
+		}
+		bp.AddPoint(pt)
+	}
+
+	if err := clnt.Write(bp); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+#### Uint64 Support
+
+The `uint64` data type is supported if your server is version `1.4.0` or
+greater. To write a data point as an unsigned integer, you must insert
+the point as `uint64`. You cannot use `uint` or any of the other
+derivatives because previous versions of the client have supported
+writing those types as an integer.
+
+### Querying Data
+
+One nice advantage of using **InfluxDB** the ability to query your data using familiar
+SQL constructs. In this example we can create a convenience function to query the database
+as follows:
+
+```go
+// queryDB convenience function to query the database
+func queryDB(clnt client.Client, cmd string) (res []client.Result, err error) {
+	q := client.Query{
+		Command:  cmd,
+		Database: MyDB,
+	}
+	if response, err := clnt.Query(q); err == nil {
+		if response.Error() != nil {
+			return res, response.Error()
+		}
+		res = response.Results
+	} else {
+		return res, err
+	}
+	return res, nil
+}
+```
+
+#### Creating a Database
+
+```go
+_, err := queryDB(clnt, fmt.Sprintf("CREATE DATABASE %s", MyDB))
+if err != nil {
+	log.Fatal(err)
+}
+```
+
+#### Count Records
+
+```go
+q := fmt.Sprintf("SELECT count(%s) FROM %s", "value", MyMeasurement)
+res, err := queryDB(clnt, q)
+if err != nil {
+	log.Fatal(err)
+}
+count := res[0].Series[0].Values[0][1]
+log.Printf("Found a total of %v records\n", count)
+```
+
+#### Find the last 10 _shapes_ records
+
+```go
+q := fmt.Sprintf("SELECT * FROM %s LIMIT %d", MyMeasurement, 10)
+res, err = queryDB(clnt, q)
+if err != nil {
+	log.Fatal(err)
+}
+
+for i, row := range res[0].Series[0].Values {
+	t, err := time.Parse(time.RFC3339, row[0].(string))
+	if err != nil {
+		log.Fatal(err)
+	}
+	val := row[1].(string)
+	log.Printf("[%2d] %s: %s\n", i, t.Format(time.Stamp), val)
+}
+```
+
+### Using the UDP Client
+
+The **InfluxDB** client also supports writing over UDP.
+
+```go
+func WriteUDP() {
+	// Make client
+	c, err := client.NewUDPClient("localhost:8089")
+	if err != nil {
+		panic(err.Error())
+	}
+	
+	// Create a new point batch
+	bp, _ := client.NewBatchPoints(client.BatchPointsConfig{
+		Precision: "s",
+	})
+
+	// Create a point and add to batch
+	tags := map[string]string{"cpu": "cpu-total"}
+	fields := map[string]interface{}{
+		"idle":   10.1,
+		"system": 53.3,
+		"user":   46.6,
+	}
+	pt, err := client.NewPoint("cpu_usage", tags, fields, time.Now())
+	if err != nil {
+		panic(err.Error())
+	}
+	bp.AddPoint(pt)
+
+	// Write the batch
+	c.Write(bp)
+}
+```
+
+### Point Splitting
+
+The UDP client now supports splitting single points that exceed the configured
+payload size. The logic for processing each point is listed here, starting with
+an empty payload.
+
+1. If adding the point to the current (non-empty) payload would exceed the
+   configured size, send the current payload. Otherwise, add it to the current
+   payload.
+1. If the point is smaller than the configured size, add it to the payload.
+1. If the point has no timestamp, just try to send the entire point as a single
+   UDP payload, and process the next point.
+1. Since the point has a timestamp, re-use the existing measurement name,
+   tagset, and timestamp and create multiple new points by splitting up the
+   fields. The per-point length will be kept close to the configured size,
+   staying under it if possible. This does mean that one large field, maybe a
+   long string, could be sent as a larger-than-configured payload.
+
+The above logic attempts to respect configured payload sizes, but not sacrifice
+any data integrity. Points without a timestamp can't be split, as that may
+cause fields to have differing timestamps when processed by the server.
+
+## Go Docs
+
+Please refer to
+[http://godoc.org/github.com/influxdata/influxdb/client/v2](http://godoc.org/github.com/influxdata/influxdb/client/v2)
+for documentation.
+
+## See Also
+
+You can also examine how the client library is used by the
+[InfluxDB CLI](https://github.com/influxdata/influxdb/blob/master/cmd/influx/main.go).
diff --git a/vendor/github.com/influxdata/influxdb/client/influxdb.go b/vendor/github.com/influxdata/influxdb/client/influxdb.go
new file mode 100644
index 0000000000..98d362d50a
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/client/influxdb.go
@@ -0,0 +1,840 @@
+// Package client implements a now-deprecated client for InfluxDB;
+// use github.com/influxdata/influxdb/client/v2 instead.
+package client // import "github.com/influxdata/influxdb/client"
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/influxdata/influxdb/models"
+)
+
+const (
+	// DefaultHost is the default host used to connect to an InfluxDB instance
+	DefaultHost = "localhost"
+
+	// DefaultPort is the default port used to connect to an InfluxDB instance
+	DefaultPort = 8086
+
+	// DefaultTimeout is the default connection timeout used to connect to an InfluxDB instance
+	DefaultTimeout = 0
+)
+
+// Query is used to send a command to the server. Both Command and Database are required.
+type Query struct {
+	Command  string
+	Database string
+
+	// Chunked tells the server to send back chunked responses. This places
+	// less load on the server by sending back chunks of the response rather
+	// than waiting for the entire response all at once.
+	Chunked bool
+
+	// ChunkSize sets the maximum number of rows that will be returned per
+	// chunk. Chunks are either divided based on their series or if they hit
+	// the chunk size limit.
+	//
+	// Chunked must be set to true for this option to be used.
+	ChunkSize int
+}
+
+// ParseConnectionString will parse a string to create a valid connection URL
+func ParseConnectionString(path string, ssl bool) (url.URL, error) {
+	var host string
+	var port int
+
+	h, p, err := net.SplitHostPort(path)
+	if err != nil {
+		if path == "" {
+			host = DefaultHost
+		} else {
+			host = path
+		}
+		// If they didn't specify a port, always use the default port
+		port = DefaultPort
+	} else {
+		host = h
+		port, err = strconv.Atoi(p)
+		if err != nil {
+			return url.URL{}, fmt.Errorf("invalid port number %q: %s\n", path, err)
+		}
+	}
+
+	u := url.URL{
+		Scheme: "http",
+	}
+	if ssl {
+		u.Scheme = "https"
+	}
+
+	u.Host = net.JoinHostPort(host, strconv.Itoa(port))
+
+	return u, nil
+}
+
+// Config is used to specify what server to connect to.
+// URL: The URL of the server connecting to.
+// Username/Password are optional. They will be passed via basic auth if provided.
+// UserAgent: If not provided, will default "InfluxDBClient",
+// Timeout: If not provided, will default to 0 (no timeout)
+type Config struct {
+	URL              url.URL
+	UnixSocket       string
+	Username         string
+	Password         string
+	UserAgent        string
+	Timeout          time.Duration
+	Precision        string
+	WriteConsistency string
+	UnsafeSsl        bool
+}
+
+// NewConfig will create a config to be used in connecting to the client
+func NewConfig() Config {
+	return Config{
+		Timeout: DefaultTimeout,
+	}
+}
+
+// Client is used to make calls to the server.
+type Client struct {
+	url        url.URL
+	unixSocket string
+	username   string
+	password   string
+	httpClient *http.Client
+	userAgent  string
+	precision  string
+}
+
+const (
+	// ConsistencyOne requires at least one data node acknowledged a write.
+	ConsistencyOne = "one"
+
+	// ConsistencyAll requires all data nodes to acknowledge a write.
+	ConsistencyAll = "all"
+
+	// ConsistencyQuorum requires a quorum of data nodes to acknowledge a write.
+	ConsistencyQuorum = "quorum"
+
+	// ConsistencyAny allows for hinted hand off, potentially no write happened yet.
+	ConsistencyAny = "any"
+)
+
+// NewClient will instantiate and return a connected client to issue commands to the server.
+func NewClient(c Config) (*Client, error) {
+	tlsConfig := &tls.Config{
+		InsecureSkipVerify: c.UnsafeSsl,
+	}
+
+	tr := &http.Transport{
+		TLSClientConfig: tlsConfig,
+	}
+
+	if c.UnixSocket != "" {
+		// No need for compression in local communications.
+		tr.DisableCompression = true
+
+		tr.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) {
+			return net.Dial("unix", c.UnixSocket)
+		}
+	}
+
+	client := Client{
+		url:        c.URL,
+		unixSocket: c.UnixSocket,
+		username:   c.Username,
+		password:   c.Password,
+		httpClient: &http.Client{Timeout: c.Timeout, Transport: tr},
+		userAgent:  c.UserAgent,
+		precision:  c.Precision,
+	}
+	if client.userAgent == "" {
+		client.userAgent = "InfluxDBClient"
+	}
+	return &client, nil
+}
+
+// SetAuth will update the username and passwords
+func (c *Client) SetAuth(u, p string) {
+	c.username = u
+	c.password = p
+}
+
+// SetPrecision will update the precision
+func (c *Client) SetPrecision(precision string) {
+	c.precision = precision
+}
+
+// Query sends a command to the server and returns the Response
+func (c *Client) Query(q Query) (*Response, error) {
+	return c.QueryContext(context.Background(), q)
+}
+
+// QueryContext sends a command to the server and returns the Response
+// It uses a context that can be cancelled by the command line client
+func (c *Client) QueryContext(ctx context.Context, q Query) (*Response, error) {
+	u := c.url
+
+	u.Path = "query"
+	values := u.Query()
+	values.Set("q", q.Command)
+	values.Set("db", q.Database)
+	if q.Chunked {
+		values.Set("chunked", "true")
+		if q.ChunkSize > 0 {
+			values.Set("chunk_size", strconv.Itoa(q.ChunkSize))
+		}
+	}
+	if c.precision != "" {
+		values.Set("epoch", c.precision)
+	}
+	u.RawQuery = values.Encode()
+
+	req, err := http.NewRequest("POST", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", c.userAgent)
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	req = req.WithContext(ctx)
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var response Response
+	if q.Chunked {
+		cr := NewChunkedResponse(resp.Body)
+		for {
+			r, err := cr.NextResponse()
+			if err != nil {
+				// If we got an error while decoding the response, send that back.
+				return nil, err
+			}
+
+			if r == nil {
+				break
+			}
+
+			response.Results = append(response.Results, r.Results...)
+			if r.Err != nil {
+				response.Err = r.Err
+				break
+			}
+		}
+	} else {
+		dec := json.NewDecoder(resp.Body)
+		dec.UseNumber()
+		if err := dec.Decode(&response); err != nil {
+			// Ignore EOF errors if we got an invalid status code.
+			if !(err == io.EOF && resp.StatusCode != http.StatusOK) {
+				return nil, err
+			}
+		}
+	}
+
+	// If we don't have an error in our json response, and didn't get StatusOK,
+	// then send back an error.
+	if resp.StatusCode != http.StatusOK && response.Error() == nil {
+		return &response, fmt.Errorf("received status code %d from server", resp.StatusCode)
+	}
+	return &response, nil
+}
+
+// Write takes BatchPoints and allows for writing of multiple points with defaults
+// If successful, error is nil and Response is nil
+// If an error occurs, Response may contain additional information if populated.
+func (c *Client) Write(bp BatchPoints) (*Response, error) {
+	u := c.url
+	u.Path = "write"
+
+	var b bytes.Buffer
+	for _, p := range bp.Points {
+		err := checkPointTypes(p)
+		if err != nil {
+			return nil, err
+		}
+		if p.Raw != "" {
+			if _, err := b.WriteString(p.Raw); err != nil {
+				return nil, err
+			}
+		} else {
+			for k, v := range bp.Tags {
+				if p.Tags == nil {
+					p.Tags = make(map[string]string, len(bp.Tags))
+				}
+				p.Tags[k] = v
+			}
+
+			if _, err := b.WriteString(p.MarshalString()); err != nil {
+				return nil, err
+			}
+		}
+
+		if err := b.WriteByte('\n'); err != nil {
+			return nil, err
+		}
+	}
+
+	req, err := http.NewRequest("POST", u.String(), &b)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "")
+	req.Header.Set("User-Agent", c.userAgent)
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	precision := bp.Precision
+	if precision == "" {
+		precision = "ns"
+	}
+
+	params := req.URL.Query()
+	params.Set("db", bp.Database)
+	params.Set("rp", bp.RetentionPolicy)
+	params.Set("precision", precision)
+	params.Set("consistency", bp.WriteConsistency)
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var response Response
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
+		var err = fmt.Errorf(string(body))
+		response.Err = err
+		return &response, err
+	}
+
+	return nil, nil
+}
+
+// WriteLineProtocol takes a string with line returns to delimit each write
+// If successful, error is nil and Response is nil
+// If an error occurs, Response may contain additional information if populated.
+func (c *Client) WriteLineProtocol(data, database, retentionPolicy, precision, writeConsistency string) (*Response, error) {
+	u := c.url
+	u.Path = "write"
+
+	r := strings.NewReader(data)
+
+	req, err := http.NewRequest("POST", u.String(), r)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "")
+	req.Header.Set("User-Agent", c.userAgent)
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+	params := req.URL.Query()
+	params.Set("db", database)
+	params.Set("rp", retentionPolicy)
+	params.Set("precision", precision)
+	params.Set("consistency", writeConsistency)
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var response Response
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
+		err := fmt.Errorf(string(body))
+		response.Err = err
+		return &response, err
+	}
+
+	return nil, nil
+}
+
+// Ping will check to see if the server is up
+// Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
+func (c *Client) Ping() (time.Duration, string, error) {
+	now := time.Now()
+	u := c.url
+	u.Path = "ping"
+
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return 0, "", err
+	}
+	req.Header.Set("User-Agent", c.userAgent)
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return 0, "", err
+	}
+	defer resp.Body.Close()
+
+	version := resp.Header.Get("X-Influxdb-Version")
+	return time.Since(now), version, nil
+}
+
+// Structs
+
+// Message represents a user message.
+type Message struct {
+	Level string `json:"level,omitempty"`
+	Text  string `json:"text,omitempty"`
+}
+
+// Result represents a resultset returned from a single statement.
+type Result struct {
+	Series   []models.Row
+	Messages []*Message
+	Err      error
+}
+
+// MarshalJSON encodes the result into JSON.
+func (r *Result) MarshalJSON() ([]byte, error) {
+	// Define a struct that outputs "error" as a string.
+	var o struct {
+		Series   []models.Row `json:"series,omitempty"`
+		Messages []*Message   `json:"messages,omitempty"`
+		Err      string       `json:"error,omitempty"`
+	}
+
+	// Copy fields to output struct.
+	o.Series = r.Series
+	o.Messages = r.Messages
+	if r.Err != nil {
+		o.Err = r.Err.Error()
+	}
+
+	return json.Marshal(&o)
+}
+
+// UnmarshalJSON decodes the data into the Result struct
+func (r *Result) UnmarshalJSON(b []byte) error {
+	var o struct {
+		Series   []models.Row `json:"series,omitempty"`
+		Messages []*Message   `json:"messages,omitempty"`
+		Err      string       `json:"error,omitempty"`
+	}
+
+	dec := json.NewDecoder(bytes.NewBuffer(b))
+	dec.UseNumber()
+	err := dec.Decode(&o)
+	if err != nil {
+		return err
+	}
+	r.Series = o.Series
+	r.Messages = o.Messages
+	if o.Err != "" {
+		r.Err = errors.New(o.Err)
+	}
+	return nil
+}
+
+// Response represents a list of statement results.
+type Response struct {
+	Results []Result
+	Err     error
+}
+
+// MarshalJSON encodes the response into JSON.
+func (r *Response) MarshalJSON() ([]byte, error) {
+	// Define a struct that outputs "error" as a string.
+	var o struct {
+		Results []Result `json:"results,omitempty"`
+		Err     string   `json:"error,omitempty"`
+	}
+
+	// Copy fields to output struct.
+	o.Results = r.Results
+	if r.Err != nil {
+		o.Err = r.Err.Error()
+	}
+
+	return json.Marshal(&o)
+}
+
+// UnmarshalJSON decodes the data into the Response struct
+func (r *Response) UnmarshalJSON(b []byte) error {
+	var o struct {
+		Results []Result `json:"results,omitempty"`
+		Err     string   `json:"error,omitempty"`
+	}
+
+	dec := json.NewDecoder(bytes.NewBuffer(b))
+	dec.UseNumber()
+	err := dec.Decode(&o)
+	if err != nil {
+		return err
+	}
+	r.Results = o.Results
+	if o.Err != "" {
+		r.Err = errors.New(o.Err)
+	}
+	return nil
+}
+
+// Error returns the first error from any statement.
+// Returns nil if no errors occurred on any statements.
+func (r *Response) Error() error {
+	if r.Err != nil {
+		return r.Err
+	}
+	for _, result := range r.Results {
+		if result.Err != nil {
+			return result.Err
+		}
+	}
+	return nil
+}
+
+// duplexReader reads responses and writes it to another writer while
+// satisfying the reader interface.
+type duplexReader struct {
+	r io.Reader
+	w io.Writer
+}
+
+func (r *duplexReader) Read(p []byte) (n int, err error) {
+	n, err = r.r.Read(p)
+	if err == nil {
+		r.w.Write(p[:n])
+	}
+	return n, err
+}
+
+// ChunkedResponse represents a response from the server that
+// uses chunking to stream the output.
+type ChunkedResponse struct {
+	dec    *json.Decoder
+	duplex *duplexReader
+	buf    bytes.Buffer
+}
+
+// NewChunkedResponse reads a stream and produces responses from the stream.
+func NewChunkedResponse(r io.Reader) *ChunkedResponse {
+	resp := &ChunkedResponse{}
+	resp.duplex = &duplexReader{r: r, w: &resp.buf}
+	resp.dec = json.NewDecoder(resp.duplex)
+	resp.dec.UseNumber()
+	return resp
+}
+
+// NextResponse reads the next line of the stream and returns a response.
+func (r *ChunkedResponse) NextResponse() (*Response, error) {
+	var response Response
+	if err := r.dec.Decode(&response); err != nil {
+		if err == io.EOF {
+			return nil, nil
+		}
+		// A decoding error happened. This probably means the server crashed
+		// and sent a last-ditch error message to us. Ensure we have read the
+		// entirety of the connection to get any remaining error text.
+		io.Copy(ioutil.Discard, r.duplex)
+		return nil, errors.New(strings.TrimSpace(r.buf.String()))
+	}
+	r.buf.Reset()
+	return &response, nil
+}
+
+// Point defines the fields that will be written to the database
+// Measurement, Time, and Fields are required
+// Precision can be specified if the time is in epoch format (integer).
+// Valid values for Precision are n, u, ms, s, m, and h
+type Point struct {
+	Measurement string
+	Tags        map[string]string
+	Time        time.Time
+	Fields      map[string]interface{}
+	Precision   string
+	Raw         string
+}
+
+// MarshalJSON will format the time in RFC3339Nano
+// Precision is also ignored as it is only used for writing, not reading
+// Or another way to say it is we always send back in nanosecond precision
+func (p *Point) MarshalJSON() ([]byte, error) {
+	point := struct {
+		Measurement string                 `json:"measurement,omitempty"`
+		Tags        map[string]string      `json:"tags,omitempty"`
+		Time        string                 `json:"time,omitempty"`
+		Fields      map[string]interface{} `json:"fields,omitempty"`
+		Precision   string                 `json:"precision,omitempty"`
+	}{
+		Measurement: p.Measurement,
+		Tags:        p.Tags,
+		Fields:      p.Fields,
+		Precision:   p.Precision,
+	}
+	// Let it omit empty if it's really zero
+	if !p.Time.IsZero() {
+		point.Time = p.Time.UTC().Format(time.RFC3339Nano)
+	}
+	return json.Marshal(&point)
+}
+
+// MarshalString renders string representation of a Point with specified
+// precision. The default precision is nanoseconds.
+func (p *Point) MarshalString() string {
+	pt, err := models.NewPoint(p.Measurement, models.NewTags(p.Tags), p.Fields, p.Time)
+	if err != nil {
+		return "# ERROR: " + err.Error() + " " + p.Measurement
+	}
+	if p.Precision == "" || p.Precision == "ns" || p.Precision == "n" {
+		return pt.String()
+	}
+	return pt.PrecisionString(p.Precision)
+}
+
+// UnmarshalJSON decodes the data into the Point struct
+func (p *Point) UnmarshalJSON(b []byte) error {
+	var normal struct {
+		Measurement string                 `json:"measurement"`
+		Tags        map[string]string      `json:"tags"`
+		Time        time.Time              `json:"time"`
+		Precision   string                 `json:"precision"`
+		Fields      map[string]interface{} `json:"fields"`
+	}
+	var epoch struct {
+		Measurement string                 `json:"measurement"`
+		Tags        map[string]string      `json:"tags"`
+		Time        *int64                 `json:"time"`
+		Precision   string                 `json:"precision"`
+		Fields      map[string]interface{} `json:"fields"`
+	}
+
+	if err := func() error {
+		var err error
+		dec := json.NewDecoder(bytes.NewBuffer(b))
+		dec.UseNumber()
+		if err = dec.Decode(&epoch); err != nil {
+			return err
+		}
+		// Convert from epoch to time.Time, but only if Time
+		// was actually set.
+		var ts time.Time
+		if epoch.Time != nil {
+			ts, err = EpochToTime(*epoch.Time, epoch.Precision)
+			if err != nil {
+				return err
+			}
+		}
+		p.Measurement = epoch.Measurement
+		p.Tags = epoch.Tags
+		p.Time = ts
+		p.Precision = epoch.Precision
+		p.Fields = normalizeFields(epoch.Fields)
+		return nil
+	}(); err == nil {
+		return nil
+	}
+
+	dec := json.NewDecoder(bytes.NewBuffer(b))
+	dec.UseNumber()
+	if err := dec.Decode(&normal); err != nil {
+		return err
+	}
+	normal.Time = SetPrecision(normal.Time, normal.Precision)
+	p.Measurement = normal.Measurement
+	p.Tags = normal.Tags
+	p.Time = normal.Time
+	p.Precision = normal.Precision
+	p.Fields = normalizeFields(normal.Fields)
+
+	return nil
+}
+
+// Remove any notion of json.Number
+func normalizeFields(fields map[string]interface{}) map[string]interface{} {
+	newFields := map[string]interface{}{}
+
+	for k, v := range fields {
+		switch v := v.(type) {
+		case json.Number:
+			jv, e := v.Float64()
+			if e != nil {
+				panic(fmt.Sprintf("unable to convert json.Number to float64: %s", e))
+			}
+			newFields[k] = jv
+		default:
+			newFields[k] = v
+		}
+	}
+	return newFields
+}
+
+// BatchPoints is used to send batched data in a single write.
+// Database and Points are required
+// If no retention policy is specified, it will use the databases default retention policy.
+// If tags are specified, they will be "merged" with all points. If a point already has that tag, it will be ignored.
+// If time is specified, it will be applied to any point with an empty time.
+// Precision can be specified if the time is in epoch format (integer).
+// Valid values for Precision are n, u, ms, s, m, and h
+type BatchPoints struct {
+	Points           []Point           `json:"points,omitempty"`
+	Database         string            `json:"database,omitempty"`
+	RetentionPolicy  string            `json:"retentionPolicy,omitempty"`
+	Tags             map[string]string `json:"tags,omitempty"`
+	Time             time.Time         `json:"time,omitempty"`
+	Precision        string            `json:"precision,omitempty"`
+	WriteConsistency string            `json:"-"`
+}
+
+// UnmarshalJSON decodes the data into the BatchPoints struct
+func (bp *BatchPoints) UnmarshalJSON(b []byte) error {
+	var normal struct {
+		Points          []Point           `json:"points"`
+		Database        string            `json:"database"`
+		RetentionPolicy string            `json:"retentionPolicy"`
+		Tags            map[string]string `json:"tags"`
+		Time            time.Time         `json:"time"`
+		Precision       string            `json:"precision"`
+	}
+	var epoch struct {
+		Points          []Point           `json:"points"`
+		Database        string            `json:"database"`
+		RetentionPolicy string            `json:"retentionPolicy"`
+		Tags            map[string]string `json:"tags"`
+		Time            *int64            `json:"time"`
+		Precision       string            `json:"precision"`
+	}
+
+	if err := func() error {
+		var err error
+		if err = json.Unmarshal(b, &epoch); err != nil {
+			return err
+		}
+		// Convert from epoch to time.Time
+		var ts time.Time
+		if epoch.Time != nil {
+			ts, err = EpochToTime(*epoch.Time, epoch.Precision)
+			if err != nil {
+				return err
+			}
+		}
+		bp.Points = epoch.Points
+		bp.Database = epoch.Database
+		bp.RetentionPolicy = epoch.RetentionPolicy
+		bp.Tags = epoch.Tags
+		bp.Time = ts
+		bp.Precision = epoch.Precision
+		return nil
+	}(); err == nil {
+		return nil
+	}
+
+	if err := json.Unmarshal(b, &normal); err != nil {
+		return err
+	}
+	normal.Time = SetPrecision(normal.Time, normal.Precision)
+	bp.Points = normal.Points
+	bp.Database = normal.Database
+	bp.RetentionPolicy = normal.RetentionPolicy
+	bp.Tags = normal.Tags
+	bp.Time = normal.Time
+	bp.Precision = normal.Precision
+
+	return nil
+}
+
+// utility functions
+
+// Addr provides the current url as a string of the server the client is connected to.
+func (c *Client) Addr() string {
+	if c.unixSocket != "" {
+		return c.unixSocket
+	}
+	return c.url.String()
+}
+
+// checkPointTypes ensures no unsupported types are submitted to influxdb, returning error if they are found.
+func checkPointTypes(p Point) error {
+	for _, v := range p.Fields {
+		switch v.(type) {
+		case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64, bool, string, nil:
+			return nil
+		default:
+			return fmt.Errorf("unsupported point type: %T", v)
+		}
+	}
+	return nil
+}
+
+// helper functions
+
+// EpochToTime takes a unix epoch time and uses precision to return back a time.Time
+func EpochToTime(epoch int64, precision string) (time.Time, error) {
+	if precision == "" {
+		precision = "s"
+	}
+	var t time.Time
+	switch precision {
+	case "h":
+		t = time.Unix(0, epoch*int64(time.Hour))
+	case "m":
+		t = time.Unix(0, epoch*int64(time.Minute))
+	case "s":
+		t = time.Unix(0, epoch*int64(time.Second))
+	case "ms":
+		t = time.Unix(0, epoch*int64(time.Millisecond))
+	case "u":
+		t = time.Unix(0, epoch*int64(time.Microsecond))
+	case "n":
+		t = time.Unix(0, epoch)
+	default:
+		return time.Time{}, fmt.Errorf("Unknown precision %q", precision)
+	}
+	return t, nil
+}
+
+// SetPrecision will round a time to the specified precision
+func SetPrecision(t time.Time, precision string) time.Time {
+	switch precision {
+	case "n":
+	case "u":
+		return t.Round(time.Microsecond)
+	case "ms":
+		return t.Round(time.Millisecond)
+	case "s":
+		return t.Round(time.Second)
+	case "m":
+		return t.Round(time.Minute)
+	case "h":
+		return t.Round(time.Hour)
+	}
+	return t
+}
diff --git a/vendor/github.com/influxdata/influxdb/client/v2/client.go b/vendor/github.com/influxdata/influxdb/client/v2/client.go
new file mode 100644
index 0000000000..77d44f2b34
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/client/v2/client.go
@@ -0,0 +1,635 @@
+// Package client (v2) is the current official Go client for InfluxDB.
+package client // import "github.com/influxdata/influxdb/client/v2"
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/influxdata/influxdb/models"
+)
+
+// HTTPConfig is the config data needed to create an HTTP Client.
+type HTTPConfig struct {
+	// Addr should be of the form "http://host:port"
+	// or "http://[ipv6-host%zone]:port".
+	Addr string
+
+	// Username is the influxdb username, optional.
+	Username string
+
+	// Password is the influxdb password, optional.
+	Password string
+
+	// UserAgent is the http User Agent, defaults to "InfluxDBClient".
+	UserAgent string
+
+	// Timeout for influxdb writes, defaults to no timeout.
+	Timeout time.Duration
+
+	// InsecureSkipVerify gets passed to the http client, if true, it will
+	// skip https certificate verification. Defaults to false.
+	InsecureSkipVerify bool
+
+	// TLSConfig allows the user to set their own TLS config for the HTTP
+	// Client. If set, this option overrides InsecureSkipVerify.
+	TLSConfig *tls.Config
+}
+
+// BatchPointsConfig is the config data needed to create an instance of the BatchPoints struct.
+type BatchPointsConfig struct {
+	// Precision is the write precision of the points, defaults to "ns".
+	Precision string
+
+	// Database is the database to write points to.
+	Database string
+
+	// RetentionPolicy is the retention policy of the points.
+	RetentionPolicy string
+
+	// Write consistency is the number of servers required to confirm write.
+	WriteConsistency string
+}
+
+// Client is a client interface for writing & querying the database.
+type Client interface {
+	// Ping checks that status of cluster, and will always return 0 time and no
+	// error for UDP clients.
+	Ping(timeout time.Duration) (time.Duration, string, error)
+
+	// Write takes a BatchPoints object and writes all Points to InfluxDB.
+	Write(bp BatchPoints) error
+
+	// Query makes an InfluxDB Query on the database. This will fail if using
+	// the UDP client.
+	Query(q Query) (*Response, error)
+
+	// Close releases any resources a Client may be using.
+	Close() error
+}
+
+// NewHTTPClient returns a new Client from the provided config.
+// Client is safe for concurrent use by multiple goroutines.
+func NewHTTPClient(conf HTTPConfig) (Client, error) {
+	if conf.UserAgent == "" {
+		conf.UserAgent = "InfluxDBClient"
+	}
+
+	u, err := url.Parse(conf.Addr)
+	if err != nil {
+		return nil, err
+	} else if u.Scheme != "http" && u.Scheme != "https" {
+		m := fmt.Sprintf("Unsupported protocol scheme: %s, your address"+
+			" must start with http:// or https://", u.Scheme)
+		return nil, errors.New(m)
+	}
+
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: conf.InsecureSkipVerify,
+		},
+	}
+	if conf.TLSConfig != nil {
+		tr.TLSClientConfig = conf.TLSConfig
+	}
+	return &client{
+		url:       *u,
+		username:  conf.Username,
+		password:  conf.Password,
+		useragent: conf.UserAgent,
+		httpClient: &http.Client{
+			Timeout:   conf.Timeout,
+			Transport: tr,
+		},
+		transport: tr,
+	}, nil
+}
+
+// Ping will check to see if the server is up with an optional timeout on waiting for leader.
+// Ping returns how long the request took, the version of the server it connected to, and an error if one occurred.
+func (c *client) Ping(timeout time.Duration) (time.Duration, string, error) {
+	now := time.Now()
+	u := c.url
+	u.Path = "ping"
+
+	req, err := http.NewRequest("GET", u.String(), nil)
+	if err != nil {
+		return 0, "", err
+	}
+
+	req.Header.Set("User-Agent", c.useragent)
+
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	if timeout > 0 {
+		params := req.URL.Query()
+		params.Set("wait_for_leader", fmt.Sprintf("%.0fs", timeout.Seconds()))
+		req.URL.RawQuery = params.Encode()
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return 0, "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return 0, "", err
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		var err = fmt.Errorf(string(body))
+		return 0, "", err
+	}
+
+	version := resp.Header.Get("X-Influxdb-Version")
+	return time.Since(now), version, nil
+}
+
+// Close releases the client's resources.
+func (c *client) Close() error {
+	c.transport.CloseIdleConnections()
+	return nil
+}
+
+// client is safe for concurrent use as the fields are all read-only
+// once the client is instantiated.
+type client struct {
+	// N.B - if url.UserInfo is accessed in future modifications to the
+	// methods on client, you will need to syncronise access to url.
+	url        url.URL
+	username   string
+	password   string
+	useragent  string
+	httpClient *http.Client
+	transport  *http.Transport
+}
+
+// BatchPoints is an interface into a batched grouping of points to write into
+// InfluxDB together. BatchPoints is NOT thread-safe, you must create a separate
+// batch for each goroutine.
+type BatchPoints interface {
+	// AddPoint adds the given point to the Batch of points.
+	AddPoint(p *Point)
+	// AddPoints adds the given points to the Batch of points.
+	AddPoints(ps []*Point)
+	// Points lists the points in the Batch.
+	Points() []*Point
+
+	// Precision returns the currently set precision of this Batch.
+	Precision() string
+	// SetPrecision sets the precision of this batch.
+	SetPrecision(s string) error
+
+	// Database returns the currently set database of this Batch.
+	Database() string
+	// SetDatabase sets the database of this Batch.
+	SetDatabase(s string)
+
+	// WriteConsistency returns the currently set write consistency of this Batch.
+	WriteConsistency() string
+	// SetWriteConsistency sets the write consistency of this Batch.
+	SetWriteConsistency(s string)
+
+	// RetentionPolicy returns the currently set retention policy of this Batch.
+	RetentionPolicy() string
+	// SetRetentionPolicy sets the retention policy of this Batch.
+	SetRetentionPolicy(s string)
+}
+
+// NewBatchPoints returns a BatchPoints interface based on the given config.
+func NewBatchPoints(conf BatchPointsConfig) (BatchPoints, error) {
+	if conf.Precision == "" {
+		conf.Precision = "ns"
+	}
+	if _, err := time.ParseDuration("1" + conf.Precision); err != nil {
+		return nil, err
+	}
+	bp := &batchpoints{
+		database:         conf.Database,
+		precision:        conf.Precision,
+		retentionPolicy:  conf.RetentionPolicy,
+		writeConsistency: conf.WriteConsistency,
+	}
+	return bp, nil
+}
+
+type batchpoints struct {
+	points           []*Point
+	database         string
+	precision        string
+	retentionPolicy  string
+	writeConsistency string
+}
+
+func (bp *batchpoints) AddPoint(p *Point) {
+	bp.points = append(bp.points, p)
+}
+
+func (bp *batchpoints) AddPoints(ps []*Point) {
+	bp.points = append(bp.points, ps...)
+}
+
+func (bp *batchpoints) Points() []*Point {
+	return bp.points
+}
+
+func (bp *batchpoints) Precision() string {
+	return bp.precision
+}
+
+func (bp *batchpoints) Database() string {
+	return bp.database
+}
+
+func (bp *batchpoints) WriteConsistency() string {
+	return bp.writeConsistency
+}
+
+func (bp *batchpoints) RetentionPolicy() string {
+	return bp.retentionPolicy
+}
+
+func (bp *batchpoints) SetPrecision(p string) error {
+	if _, err := time.ParseDuration("1" + p); err != nil {
+		return err
+	}
+	bp.precision = p
+	return nil
+}
+
+func (bp *batchpoints) SetDatabase(db string) {
+	bp.database = db
+}
+
+func (bp *batchpoints) SetWriteConsistency(wc string) {
+	bp.writeConsistency = wc
+}
+
+func (bp *batchpoints) SetRetentionPolicy(rp string) {
+	bp.retentionPolicy = rp
+}
+
+// Point represents a single data point.
+type Point struct {
+	pt models.Point
+}
+
+// NewPoint returns a point with the given timestamp. If a timestamp is not
+// given, then data is sent to the database without a timestamp, in which case
+// the server will assign local time upon reception. NOTE: it is recommended to
+// send data with a timestamp.
+func NewPoint(
+	name string,
+	tags map[string]string,
+	fields map[string]interface{},
+	t ...time.Time,
+) (*Point, error) {
+	var T time.Time
+	if len(t) > 0 {
+		T = t[0]
+	}
+
+	pt, err := models.NewPoint(name, models.NewTags(tags), fields, T)
+	if err != nil {
+		return nil, err
+	}
+	return &Point{
+		pt: pt,
+	}, nil
+}
+
+// String returns a line-protocol string of the Point.
+func (p *Point) String() string {
+	return p.pt.String()
+}
+
+// PrecisionString returns a line-protocol string of the Point,
+// with the timestamp formatted for the given precision.
+func (p *Point) PrecisionString(precison string) string {
+	return p.pt.PrecisionString(precison)
+}
+
+// Name returns the measurement name of the point.
+func (p *Point) Name() string {
+	return string(p.pt.Name())
+}
+
+// Tags returns the tags associated with the point.
+func (p *Point) Tags() map[string]string {
+	return p.pt.Tags().Map()
+}
+
+// Time return the timestamp for the point.
+func (p *Point) Time() time.Time {
+	return p.pt.Time()
+}
+
+// UnixNano returns timestamp of the point in nanoseconds since Unix epoch.
+func (p *Point) UnixNano() int64 {
+	return p.pt.UnixNano()
+}
+
+// Fields returns the fields for the point.
+func (p *Point) Fields() (map[string]interface{}, error) {
+	return p.pt.Fields()
+}
+
+// NewPointFrom returns a point from the provided models.Point.
+func NewPointFrom(pt models.Point) *Point {
+	return &Point{pt: pt}
+}
+
+func (c *client) Write(bp BatchPoints) error {
+	var b bytes.Buffer
+
+	for _, p := range bp.Points() {
+		if _, err := b.WriteString(p.pt.PrecisionString(bp.Precision())); err != nil {
+			return err
+		}
+
+		if err := b.WriteByte('\n'); err != nil {
+			return err
+		}
+	}
+
+	u := c.url
+	u.Path = "write"
+	req, err := http.NewRequest("POST", u.String(), &b)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "")
+	req.Header.Set("User-Agent", c.useragent)
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	params := req.URL.Query()
+	params.Set("db", bp.Database())
+	params.Set("rp", bp.RetentionPolicy())
+	params.Set("precision", bp.Precision())
+	params.Set("consistency", bp.WriteConsistency())
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
+		var err = fmt.Errorf(string(body))
+		return err
+	}
+
+	return nil
+}
+
+// Query defines a query to send to the server.
+type Query struct {
+	Command    string
+	Database   string
+	Precision  string
+	Chunked    bool
+	ChunkSize  int
+	Parameters map[string]interface{}
+}
+
+// NewQuery returns a query object.
+// The database and precision arguments can be empty strings if they are not needed for the query.
+func NewQuery(command, database, precision string) Query {
+	return Query{
+		Command:    command,
+		Database:   database,
+		Precision:  precision,
+		Parameters: make(map[string]interface{}),
+	}
+}
+
+// NewQueryWithParameters returns a query object.
+// The database and precision arguments can be empty strings if they are not needed for the query.
+// parameters is a map of the parameter names used in the command to their values.
+func NewQueryWithParameters(command, database, precision string, parameters map[string]interface{}) Query {
+	return Query{
+		Command:    command,
+		Database:   database,
+		Precision:  precision,
+		Parameters: parameters,
+	}
+}
+
+// Response represents a list of statement results.
+type Response struct {
+	Results []Result
+	Err     string `json:"error,omitempty"`
+}
+
+// Error returns the first error from any statement.
+// It returns nil if no errors occurred on any statements.
+func (r *Response) Error() error {
+	if r.Err != "" {
+		return fmt.Errorf(r.Err)
+	}
+	for _, result := range r.Results {
+		if result.Err != "" {
+			return fmt.Errorf(result.Err)
+		}
+	}
+	return nil
+}
+
+// Message represents a user message.
+type Message struct {
+	Level string
+	Text  string
+}
+
+// Result represents a resultset returned from a single statement.
+type Result struct {
+	Series   []models.Row
+	Messages []*Message
+	Err      string `json:"error,omitempty"`
+}
+
+// Query sends a command to the server and returns the Response.
+func (c *client) Query(q Query) (*Response, error) {
+	u := c.url
+	u.Path = "query"
+
+	jsonParameters, err := json.Marshal(q.Parameters)
+
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "")
+	req.Header.Set("User-Agent", c.useragent)
+
+	if c.username != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	params := req.URL.Query()
+	params.Set("q", q.Command)
+	params.Set("db", q.Database)
+	params.Set("params", string(jsonParameters))
+	if q.Chunked {
+		params.Set("chunked", "true")
+		if q.ChunkSize > 0 {
+			params.Set("chunk_size", strconv.Itoa(q.ChunkSize))
+		}
+	}
+
+	if q.Precision != "" {
+		params.Set("epoch", q.Precision)
+	}
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// If we lack a X-Influxdb-Version header, then we didn't get a response from influxdb
+	// but instead some other service. If the error code is also a 500+ code, then some
+	// downstream loadbalancer/proxy/etc had an issue and we should report that.
+	if resp.Header.Get("X-Influxdb-Version") == "" && resp.StatusCode >= http.StatusInternalServerError {
+		body, err := ioutil.ReadAll(resp.Body)
+		if err != nil || len(body) == 0 {
+			return nil, fmt.Errorf("received status code %d from downstream server", resp.StatusCode)
+		}
+
+		return nil, fmt.Errorf("received status code %d from downstream server, with response body: %q", resp.StatusCode, body)
+	}
+
+	// If we get an unexpected content type, then it is also not from influx direct and therefore
+	// we want to know what we received and what status code was returned for debugging purposes.
+	if cType, _, _ := mime.ParseMediaType(resp.Header.Get("Content-Type")); cType != "application/json" {
+		// Read up to 1kb of the body to help identify downstream errors and limit the impact of things
+		// like downstream serving a large file
+		body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1024))
+		if err != nil || len(body) == 0 {
+			return nil, fmt.Errorf("expected json response, got empty body, with status: %v", resp.StatusCode)
+		}
+
+		return nil, fmt.Errorf("expected json response, got %q, with status: %v and response body: %q", cType, resp.StatusCode, body)
+	}
+
+	var response Response
+	if q.Chunked {
+		cr := NewChunkedResponse(resp.Body)
+		for {
+			r, err := cr.NextResponse()
+			if err != nil {
+				// If we got an error while decoding the response, send that back.
+				return nil, err
+			}
+
+			if r == nil {
+				break
+			}
+
+			response.Results = append(response.Results, r.Results...)
+			if r.Err != "" {
+				response.Err = r.Err
+				break
+			}
+		}
+	} else {
+		dec := json.NewDecoder(resp.Body)
+		dec.UseNumber()
+		decErr := dec.Decode(&response)
+
+		// ignore this error if we got an invalid status code
+		if decErr != nil && decErr.Error() == "EOF" && resp.StatusCode != http.StatusOK {
+			decErr = nil
+		}
+		// If we got a valid decode error, send that back
+		if decErr != nil {
+			return nil, fmt.Errorf("unable to decode json: received status code %d err: %s", resp.StatusCode, decErr)
+		}
+	}
+
+	// If we don't have an error in our json response, and didn't get statusOK
+	// then send back an error
+	if resp.StatusCode != http.StatusOK && response.Error() == nil {
+		return &response, fmt.Errorf("received status code %d from server", resp.StatusCode)
+	}
+	return &response, nil
+}
+
+// duplexReader reads responses and writes it to another writer while
+// satisfying the reader interface.
+type duplexReader struct {
+	r io.Reader
+	w io.Writer
+}
+
+func (r *duplexReader) Read(p []byte) (n int, err error) {
+	n, err = r.r.Read(p)
+	if err == nil {
+		r.w.Write(p[:n])
+	}
+	return n, err
+}
+
+// ChunkedResponse represents a response from the server that
+// uses chunking to stream the output.
+type ChunkedResponse struct {
+	dec    *json.Decoder
+	duplex *duplexReader
+	buf    bytes.Buffer
+}
+
+// NewChunkedResponse reads a stream and produces responses from the stream.
+func NewChunkedResponse(r io.Reader) *ChunkedResponse {
+	resp := &ChunkedResponse{}
+	resp.duplex = &duplexReader{r: r, w: &resp.buf}
+	resp.dec = json.NewDecoder(resp.duplex)
+	resp.dec.UseNumber()
+	return resp
+}
+
+// NextResponse reads the next line of the stream and returns a response.
+func (r *ChunkedResponse) NextResponse() (*Response, error) {
+	var response Response
+
+	if err := r.dec.Decode(&response); err != nil {
+		if err == io.EOF {
+			return nil, nil
+		}
+		// A decoding error happened. This probably means the server crashed
+		// and sent a last-ditch error message to us. Ensure we have read the
+		// entirety of the connection to get any remaining error text.
+		io.Copy(ioutil.Discard, r.duplex)
+		return nil, errors.New(strings.TrimSpace(r.buf.String()))
+	}
+
+	r.buf.Reset()
+	return &response, nil
+}
diff --git a/vendor/github.com/influxdata/influxdb/client/v2/udp.go b/vendor/github.com/influxdata/influxdb/client/v2/udp.go
new file mode 100644
index 0000000000..779a28b33f
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/client/v2/udp.go
@@ -0,0 +1,112 @@
+package client
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"time"
+)
+
+const (
+	// UDPPayloadSize is a reasonable default payload size for UDP packets that
+	// could be travelling over the internet.
+	UDPPayloadSize = 512
+)
+
+// UDPConfig is the config data needed to create a UDP Client.
+type UDPConfig struct {
+	// Addr should be of the form "host:port"
+	// or "[ipv6-host%zone]:port".
+	Addr string
+
+	// PayloadSize is the maximum size of a UDP client message, optional
+	// Tune this based on your network. Defaults to UDPPayloadSize.
+	PayloadSize int
+}
+
+// NewUDPClient returns a client interface for writing to an InfluxDB UDP
+// service from the given config.
+func NewUDPClient(conf UDPConfig) (Client, error) {
+	var udpAddr *net.UDPAddr
+	udpAddr, err := net.ResolveUDPAddr("udp", conf.Addr)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.DialUDP("udp", nil, udpAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	payloadSize := conf.PayloadSize
+	if payloadSize == 0 {
+		payloadSize = UDPPayloadSize
+	}
+
+	return &udpclient{
+		conn:        conn,
+		payloadSize: payloadSize,
+	}, nil
+}
+
+// Close releases the udpclient's resources.
+func (uc *udpclient) Close() error {
+	return uc.conn.Close()
+}
+
+type udpclient struct {
+	conn        io.WriteCloser
+	payloadSize int
+}
+
+func (uc *udpclient) Write(bp BatchPoints) error {
+	var b = make([]byte, 0, uc.payloadSize) // initial buffer size, it will grow as needed
+	var d, _ = time.ParseDuration("1" + bp.Precision())
+
+	var delayedError error
+
+	var checkBuffer = func(n int) {
+		if len(b) > 0 && len(b)+n > uc.payloadSize {
+			if _, err := uc.conn.Write(b); err != nil {
+				delayedError = err
+			}
+			b = b[:0]
+		}
+	}
+
+	for _, p := range bp.Points() {
+		p.pt.Round(d)
+		pointSize := p.pt.StringSize() + 1 // include newline in size
+		//point := p.pt.RoundedString(d) + "\n"
+
+		checkBuffer(pointSize)
+
+		if p.Time().IsZero() || pointSize <= uc.payloadSize {
+			b = p.pt.AppendString(b)
+			b = append(b, '\n')
+			continue
+		}
+
+		points := p.pt.Split(uc.payloadSize - 1) // account for newline character
+		for _, sp := range points {
+			checkBuffer(sp.StringSize() + 1)
+			b = sp.AppendString(b)
+			b = append(b, '\n')
+		}
+	}
+
+	if len(b) > 0 {
+		if _, err := uc.conn.Write(b); err != nil {
+			return err
+		}
+	}
+	return delayedError
+}
+
+func (uc *udpclient) Query(q Query) (*Response, error) {
+	return nil, fmt.Errorf("Querying via UDP is not supported")
+}
+
+func (uc *udpclient) Ping(timeout time.Duration) (time.Duration, string, error) {
+	return 0, "", nil
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/consistency.go b/vendor/github.com/influxdata/influxdb/models/consistency.go
new file mode 100644
index 0000000000..2a3269bca1
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/consistency.go
@@ -0,0 +1,48 @@
+package models
+
+import (
+	"errors"
+	"strings"
+)
+
+// ConsistencyLevel represent a required replication criteria before a write can
+// be returned as successful.
+//
+// The consistency level is handled in open-source InfluxDB but only applicable to clusters.
+type ConsistencyLevel int
+
+const (
+	// ConsistencyLevelAny allows for hinted handoff, potentially no write happened yet.
+	ConsistencyLevelAny ConsistencyLevel = iota
+
+	// ConsistencyLevelOne requires at least one data node acknowledged a write.
+	ConsistencyLevelOne
+
+	// ConsistencyLevelQuorum requires a quorum of data nodes to acknowledge a write.
+	ConsistencyLevelQuorum
+
+	// ConsistencyLevelAll requires all data nodes to acknowledge a write.
+	ConsistencyLevelAll
+)
+
+var (
+	// ErrInvalidConsistencyLevel is returned when parsing the string version
+	// of a consistency level.
+	ErrInvalidConsistencyLevel = errors.New("invalid consistency level")
+)
+
+// ParseConsistencyLevel converts a consistency level string to the corresponding ConsistencyLevel const.
+func ParseConsistencyLevel(level string) (ConsistencyLevel, error) {
+	switch strings.ToLower(level) {
+	case "any":
+		return ConsistencyLevelAny, nil
+	case "one":
+		return ConsistencyLevelOne, nil
+	case "quorum":
+		return ConsistencyLevelQuorum, nil
+	case "all":
+		return ConsistencyLevelAll, nil
+	default:
+		return 0, ErrInvalidConsistencyLevel
+	}
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/inline_fnv.go b/vendor/github.com/influxdata/influxdb/models/inline_fnv.go
new file mode 100644
index 0000000000..eec1ae8b01
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/inline_fnv.go
@@ -0,0 +1,32 @@
+package models // import "github.com/influxdata/influxdb/models"
+
+// from stdlib hash/fnv/fnv.go
+const (
+	prime64  = 1099511628211
+	offset64 = 14695981039346656037
+)
+
+// InlineFNV64a is an alloc-free port of the standard library's fnv64a.
+// See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function.
+type InlineFNV64a uint64
+
+// NewInlineFNV64a returns a new instance of InlineFNV64a.
+func NewInlineFNV64a() InlineFNV64a {
+	return offset64
+}
+
+// Write adds data to the running hash.
+func (s *InlineFNV64a) Write(data []byte) (int, error) {
+	hash := uint64(*s)
+	for _, c := range data {
+		hash ^= uint64(c)
+		hash *= prime64
+	}
+	*s = InlineFNV64a(hash)
+	return len(data), nil
+}
+
+// Sum64 returns the uint64 of the current resulting hash.
+func (s *InlineFNV64a) Sum64() uint64 {
+	return uint64(*s)
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/inline_strconv_parse.go b/vendor/github.com/influxdata/influxdb/models/inline_strconv_parse.go
new file mode 100644
index 0000000000..8db4837384
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/inline_strconv_parse.go
@@ -0,0 +1,44 @@
+package models // import "github.com/influxdata/influxdb/models"
+
+import (
+	"reflect"
+	"strconv"
+	"unsafe"
+)
+
+// parseIntBytes is a zero-alloc wrapper around strconv.ParseInt.
+func parseIntBytes(b []byte, base int, bitSize int) (i int64, err error) {
+	s := unsafeBytesToString(b)
+	return strconv.ParseInt(s, base, bitSize)
+}
+
+// parseUintBytes is a zero-alloc wrapper around strconv.ParseUint.
+func parseUintBytes(b []byte, base int, bitSize int) (i uint64, err error) {
+	s := unsafeBytesToString(b)
+	return strconv.ParseUint(s, base, bitSize)
+}
+
+// parseFloatBytes is a zero-alloc wrapper around strconv.ParseFloat.
+func parseFloatBytes(b []byte, bitSize int) (float64, error) {
+	s := unsafeBytesToString(b)
+	return strconv.ParseFloat(s, bitSize)
+}
+
+// parseBoolBytes is a zero-alloc wrapper around strconv.ParseBool.
+func parseBoolBytes(b []byte) (bool, error) {
+	return strconv.ParseBool(unsafeBytesToString(b))
+}
+
+// unsafeBytesToString converts a []byte to a string without a heap allocation.
+//
+// It is unsafe, and is intended to prepare input to short-lived functions
+// that require strings.
+func unsafeBytesToString(in []byte) string {
+	src := *(*reflect.SliceHeader)(unsafe.Pointer(&in))
+	dst := reflect.StringHeader{
+		Data: src.Data,
+		Len:  src.Len,
+	}
+	s := *(*string)(unsafe.Pointer(&dst))
+	return s
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/points.go b/vendor/github.com/influxdata/influxdb/models/points.go
new file mode 100644
index 0000000000..ad80a816bf
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/points.go
@@ -0,0 +1,2337 @@
+// Package models implements basic objects used throughout the TICK stack.
+package models // import "github.com/influxdata/influxdb/models"
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/influxdata/influxdb/pkg/escape"
+)
+
+var (
+	measurementEscapeCodes = map[byte][]byte{
+		',': []byte(`\,`),
+		' ': []byte(`\ `),
+	}
+
+	tagEscapeCodes = map[byte][]byte{
+		',': []byte(`\,`),
+		' ': []byte(`\ `),
+		'=': []byte(`\=`),
+	}
+
+	// ErrPointMustHaveAField is returned when operating on a point that does not have any fields.
+	ErrPointMustHaveAField = errors.New("point without fields is unsupported")
+
+	// ErrInvalidNumber is returned when a number is expected but not provided.
+	ErrInvalidNumber = errors.New("invalid number")
+
+	// ErrInvalidPoint is returned when a point cannot be parsed correctly.
+	ErrInvalidPoint = errors.New("point is invalid")
+)
+
+const (
+	// MaxKeyLength is the largest allowed size of the combined measurement and tag keys.
+	MaxKeyLength = 65535
+)
+
+// enableUint64Support will enable uint64 support if set to true.
+var enableUint64Support = false
+
+// EnableUintSupport manually enables uint support for the point parser.
+// This function will be removed in the future and only exists for unit tests during the
+// transition.
+func EnableUintSupport() {
+	enableUint64Support = true
+}
+
+// Point defines the values that will be written to the database.
+type Point interface {
+	// Name return the measurement name for the point.
+	Name() []byte
+
+	// SetName updates the measurement name for the point.
+	SetName(string)
+
+	// Tags returns the tag set for the point.
+	Tags() Tags
+
+	// AddTag adds or replaces a tag value for a point.
+	AddTag(key, value string)
+
+	// SetTags replaces the tags for the point.
+	SetTags(tags Tags)
+
+	// HasTag returns true if the tag exists for the point.
+	HasTag(tag []byte) bool
+
+	// Fields returns the fields for the point.
+	Fields() (Fields, error)
+
+	// Time return the timestamp for the point.
+	Time() time.Time
+
+	// SetTime updates the timestamp for the point.
+	SetTime(t time.Time)
+
+	// UnixNano returns the timestamp of the point as nanoseconds since Unix epoch.
+	UnixNano() int64
+
+	// HashID returns a non-cryptographic checksum of the point's key.
+	HashID() uint64
+
+	// Key returns the key (measurement joined with tags) of the point.
+	Key() []byte
+
+	// String returns a string representation of the point. If there is a
+	// timestamp associated with the point then it will be specified with the default
+	// precision of nanoseconds.
+	String() string
+
+	// MarshalBinary returns a binary representation of the point.
+	MarshalBinary() ([]byte, error)
+
+	// PrecisionString returns a string representation of the point. If there
+	// is a timestamp associated with the point then it will be specified in the
+	// given unit.
+	PrecisionString(precision string) string
+
+	// RoundedString returns a string representation of the point. If there
+	// is a timestamp associated with the point, then it will be rounded to the
+	// given duration.
+	RoundedString(d time.Duration) string
+
+	// Split will attempt to return multiple points with the same timestamp whose
+	// string representations are no longer than size. Points with a single field or
+	// a point without a timestamp may exceed the requested size.
+	Split(size int) []Point
+
+	// Round will round the timestamp of the point to the given duration.
+	Round(d time.Duration)
+
+	// StringSize returns the length of the string that would be returned by String().
+	StringSize() int
+
+	// AppendString appends the result of String() to the provided buffer and returns
+	// the result, potentially reducing string allocations.
+	AppendString(buf []byte) []byte
+
+	// FieldIterator retuns a FieldIterator that can be used to traverse the
+	// fields of a point without constructing the in-memory map.
+	FieldIterator() FieldIterator
+}
+
+// FieldType represents the type of a field.
+type FieldType int
+
+const (
+	// Integer indicates the field's type is integer.
+	Integer FieldType = iota
+
+	// Float indicates the field's type is float.
+	Float
+
+	// Boolean indicates the field's type is boolean.
+	Boolean
+
+	// String indicates the field's type is string.
+	String
+
+	// Empty is used to indicate that there is no field.
+	Empty
+
+	// Unsigned indicates the field's type is an unsigned integer.
+	Unsigned
+)
+
+// FieldIterator provides a low-allocation interface to iterate through a point's fields.
+type FieldIterator interface {
+	// Next indicates whether there any fields remaining.
+	Next() bool
+
+	// FieldKey returns the key of the current field.
+	FieldKey() []byte
+
+	// Type returns the FieldType of the current field.
+	Type() FieldType
+
+	// StringValue returns the string value of the current field.
+	StringValue() string
+
+	// IntegerValue returns the integer value of the current field.
+	IntegerValue() (int64, error)
+
+	// UnsignedValue returns the unsigned value of the current field.
+	UnsignedValue() (uint64, error)
+
+	// BooleanValue returns the boolean value of the current field.
+	BooleanValue() (bool, error)
+
+	// FloatValue returns the float value of the current field.
+	FloatValue() (float64, error)
+
+	// Reset resets the iterator to its initial state.
+	Reset()
+}
+
+// Points represents a sortable list of points by timestamp.
+type Points []Point
+
+// Len implements sort.Interface.
+func (a Points) Len() int { return len(a) }
+
+// Less implements sort.Interface.
+func (a Points) Less(i, j int) bool { return a[i].Time().Before(a[j].Time()) }
+
+// Swap implements sort.Interface.
+func (a Points) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// point is the default implementation of Point.
+type point struct {
+	time time.Time
+
+	// text encoding of measurement and tags
+	// key must always be stored sorted by tags, if the original line was not sorted,
+	// we need to resort it
+	key []byte
+
+	// text encoding of field data
+	fields []byte
+
+	// text encoding of timestamp
+	ts []byte
+
+	// cached version of parsed fields from data
+	cachedFields map[string]interface{}
+
+	// cached version of parsed name from key
+	cachedName string
+
+	// cached version of parsed tags
+	cachedTags Tags
+
+	it fieldIterator
+}
+
+// type assertions
+var (
+	_ Point         = (*point)(nil)
+	_ FieldIterator = (*point)(nil)
+)
+
+const (
+	// the number of characters for the largest possible int64 (9223372036854775807)
+	maxInt64Digits = 19
+
+	// the number of characters for the smallest possible int64 (-9223372036854775808)
+	minInt64Digits = 20
+
+	// the number of characters for the largest possible uint64 (18446744073709551615)
+	maxUint64Digits = 20
+
+	// the number of characters required for the largest float64 before a range check
+	// would occur during parsing
+	maxFloat64Digits = 25
+
+	// the number of characters required for smallest float64 before a range check occur
+	// would occur during parsing
+	minFloat64Digits = 27
+)
+
+// ParsePoints returns a slice of Points from a text representation of a point
+// with each point separated by newlines.  If any points fail to parse, a non-nil error
+// will be returned in addition to the points that parsed successfully.
+func ParsePoints(buf []byte) ([]Point, error) {
+	return ParsePointsWithPrecision(buf, time.Now().UTC(), "n")
+}
+
+// ParsePointsString is identical to ParsePoints but accepts a string.
+func ParsePointsString(buf string) ([]Point, error) {
+	return ParsePoints([]byte(buf))
+}
+
+// ParseKey returns the measurement name and tags from a point.
+//
+// NOTE: to minimize heap allocations, the returned Tags will refer to subslices of buf.
+// This can have the unintended effect preventing buf from being garbage collected.
+func ParseKey(buf []byte) (string, Tags) {
+	meas, tags := ParseKeyBytes(buf)
+	return string(meas), tags
+}
+
+func ParseKeyBytes(buf []byte) ([]byte, Tags) {
+	// Ignore the error because scanMeasurement returns "missing fields" which we ignore
+	// when just parsing a key
+	state, i, _ := scanMeasurement(buf, 0)
+
+	var tags Tags
+	if state == tagKeyState {
+		tags = parseTags(buf)
+		// scanMeasurement returns the location of the comma if there are tags, strip that off
+		return buf[:i-1], tags
+	}
+	return buf[:i], tags
+}
+
+func ParseTags(buf []byte) Tags {
+	return parseTags(buf)
+}
+
+func ParseName(buf []byte) ([]byte, error) {
+	// Ignore the error because scanMeasurement returns "missing fields" which we ignore
+	// when just parsing a key
+	state, i, _ := scanMeasurement(buf, 0)
+	if state == tagKeyState {
+		return buf[:i-1], nil
+	}
+	return buf[:i], nil
+}
+
+// ParsePointsWithPrecision is similar to ParsePoints, but allows the
+// caller to provide a precision for time.
+//
+// NOTE: to minimize heap allocations, the returned Points will refer to subslices of buf.
+// This can have the unintended effect preventing buf from being garbage collected.
+func ParsePointsWithPrecision(buf []byte, defaultTime time.Time, precision string) ([]Point, error) {
+	points := make([]Point, 0, bytes.Count(buf, []byte{'\n'})+1)
+	var (
+		pos    int
+		block  []byte
+		failed []string
+	)
+	for pos < len(buf) {
+		pos, block = scanLine(buf, pos)
+		pos++
+
+		if len(block) == 0 {
+			continue
+		}
+
+		// lines which start with '#' are comments
+		start := skipWhitespace(block, 0)
+
+		// If line is all whitespace, just skip it
+		if start >= len(block) {
+			continue
+		}
+
+		if block[start] == '#' {
+			continue
+		}
+
+		// strip the newline if one is present
+		if block[len(block)-1] == '\n' {
+			block = block[:len(block)-1]
+		}
+
+		pt, err := parsePoint(block[start:], defaultTime, precision)
+		if err != nil {
+			failed = append(failed, fmt.Sprintf("unable to parse '%s': %v", string(block[start:]), err))
+		} else {
+			points = append(points, pt)
+		}
+
+	}
+	if len(failed) > 0 {
+		return points, fmt.Errorf("%s", strings.Join(failed, "\n"))
+	}
+	return points, nil
+
+}
+
+func parsePoint(buf []byte, defaultTime time.Time, precision string) (Point, error) {
+	// scan the first block which is measurement[,tag1=value1,tag2=value=2...]
+	pos, key, err := scanKey(buf, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	// measurement name is required
+	if len(key) == 0 {
+		return nil, fmt.Errorf("missing measurement")
+	}
+
+	if len(key) > MaxKeyLength {
+		return nil, fmt.Errorf("max key length exceeded: %v > %v", len(key), MaxKeyLength)
+	}
+
+	// scan the second block is which is field1=value1[,field2=value2,...]
+	pos, fields, err := scanFields(buf, pos)
+	if err != nil {
+		return nil, err
+	}
+
+	// at least one field is required
+	if len(fields) == 0 {
+		return nil, fmt.Errorf("missing fields")
+	}
+
+	var maxKeyErr error
+	walkFields(fields, func(k, v []byte) bool {
+		if sz := seriesKeySize(key, k); sz > MaxKeyLength {
+			maxKeyErr = fmt.Errorf("max key length exceeded: %v > %v", sz, MaxKeyLength)
+			return false
+		}
+		return true
+	})
+
+	if maxKeyErr != nil {
+		return nil, maxKeyErr
+	}
+
+	// scan the last block which is an optional integer timestamp
+	pos, ts, err := scanTime(buf, pos)
+	if err != nil {
+		return nil, err
+	}
+
+	pt := &point{
+		key:    key,
+		fields: fields,
+		ts:     ts,
+	}
+
+	if len(ts) == 0 {
+		pt.time = defaultTime
+		pt.SetPrecision(precision)
+	} else {
+		ts, err := parseIntBytes(ts, 10, 64)
+		if err != nil {
+			return nil, err
+		}
+		pt.time, err = SafeCalcTime(ts, precision)
+		if err != nil {
+			return nil, err
+		}
+
+		// Determine if there are illegal non-whitespace characters after the
+		// timestamp block.
+		for pos < len(buf) {
+			if buf[pos] != ' ' {
+				return nil, ErrInvalidPoint
+			}
+			pos++
+		}
+	}
+	return pt, nil
+}
+
+// GetPrecisionMultiplier will return a multiplier for the precision specified.
+func GetPrecisionMultiplier(precision string) int64 {
+	d := time.Nanosecond
+	switch precision {
+	case "u":
+		d = time.Microsecond
+	case "ms":
+		d = time.Millisecond
+	case "s":
+		d = time.Second
+	case "m":
+		d = time.Minute
+	case "h":
+		d = time.Hour
+	}
+	return int64(d)
+}
+
+// scanKey scans buf starting at i for the measurement and tag portion of the point.
+// It returns the ending position and the byte slice of key within buf.  If there
+// are tags, they will be sorted if they are not already.
+func scanKey(buf []byte, i int) (int, []byte, error) {
+	start := skipWhitespace(buf, i)
+
+	i = start
+
+	// Determines whether the tags are sort, assume they are
+	sorted := true
+
+	// indices holds the indexes within buf of the start of each tag.  For example,
+	// a buf of 'cpu,host=a,region=b,zone=c' would have indices slice of [4,11,20]
+	// which indicates that the first tag starts at buf[4], seconds at buf[11], and
+	// last at buf[20]
+	indices := make([]int, 100)
+
+	// tracks how many commas we've seen so we know how many values are indices.
+	// Since indices is an arbitrarily large slice,
+	// we need to know how many values in the buffer are in use.
+	commas := 0
+
+	// First scan the Point's measurement.
+	state, i, err := scanMeasurement(buf, i)
+	if err != nil {
+		return i, buf[start:i], err
+	}
+
+	// Optionally scan tags if needed.
+	if state == tagKeyState {
+		i, commas, indices, err = scanTags(buf, i, indices)
+		if err != nil {
+			return i, buf[start:i], err
+		}
+	}
+
+	// Now we know where the key region is within buf, and the location of tags, we
+	// need to determine if duplicate tags exist and if the tags are sorted. This iterates
+	// over the list comparing each tag in the sequence with each other.
+	for j := 0; j < commas-1; j++ {
+		// get the left and right tags
+		_, left := scanTo(buf[indices[j]:indices[j+1]-1], 0, '=')
+		_, right := scanTo(buf[indices[j+1]:indices[j+2]-1], 0, '=')
+
+		// If left is greater than right, the tags are not sorted. We do not have to
+		// continue because the short path no longer works.
+		// If the tags are equal, then there are duplicate tags, and we should abort.
+		// If the tags are not sorted, this pass may not find duplicate tags and we
+		// need to do a more exhaustive search later.
+		if cmp := bytes.Compare(left, right); cmp > 0 {
+			sorted = false
+			break
+		} else if cmp == 0 {
+			return i, buf[start:i], fmt.Errorf("duplicate tags")
+		}
+	}
+
+	// If the tags are not sorted, then sort them.  This sort is inline and
+	// uses the tag indices we created earlier.  The actual buffer is not sorted, the
+	// indices are using the buffer for value comparison.  After the indices are sorted,
+	// the buffer is reconstructed from the sorted indices.
+	if !sorted && commas > 0 {
+		// Get the measurement name for later
+		measurement := buf[start : indices[0]-1]
+
+		// Sort the indices
+		indices := indices[:commas]
+		insertionSort(0, commas, buf, indices)
+
+		// Create a new key using the measurement and sorted indices
+		b := make([]byte, len(buf[start:i]))
+		pos := copy(b, measurement)
+		for _, i := range indices {
+			b[pos] = ','
+			pos++
+			_, v := scanToSpaceOr(buf, i, ',')
+			pos += copy(b[pos:], v)
+		}
+
+		// Check again for duplicate tags now that the tags are sorted.
+		for j := 0; j < commas-1; j++ {
+			// get the left and right tags
+			_, left := scanTo(buf[indices[j]:], 0, '=')
+			_, right := scanTo(buf[indices[j+1]:], 0, '=')
+
+			// If the tags are equal, then there are duplicate tags, and we should abort.
+			// If the tags are not sorted, this pass may not find duplicate tags and we
+			// need to do a more exhaustive search later.
+			if bytes.Equal(left, right) {
+				return i, b, fmt.Errorf("duplicate tags")
+			}
+		}
+
+		return i, b, nil
+	}
+
+	return i, buf[start:i], nil
+}
+
+// The following constants allow us to specify which state to move to
+// next, when scanning sections of a Point.
+const (
+	tagKeyState = iota
+	tagValueState
+	fieldsState
+)
+
+// scanMeasurement examines the measurement part of a Point, returning
+// the next state to move to, and the current location in the buffer.
+func scanMeasurement(buf []byte, i int) (int, int, error) {
+	// Check first byte of measurement, anything except a comma is fine.
+	// It can't be a space, since whitespace is stripped prior to this
+	// function call.
+	if i >= len(buf) || buf[i] == ',' {
+		return -1, i, fmt.Errorf("missing measurement")
+	}
+
+	for {
+		i++
+		if i >= len(buf) {
+			// cpu
+			return -1, i, fmt.Errorf("missing fields")
+		}
+
+		if buf[i-1] == '\\' {
+			// Skip character (it's escaped).
+			continue
+		}
+
+		// Unescaped comma; move onto scanning the tags.
+		if buf[i] == ',' {
+			return tagKeyState, i + 1, nil
+		}
+
+		// Unescaped space; move onto scanning the fields.
+		if buf[i] == ' ' {
+			// cpu value=1.0
+			return fieldsState, i, nil
+		}
+	}
+}
+
+// scanTags examines all the tags in a Point, keeping track of and
+// returning the updated indices slice, number of commas and location
+// in buf where to start examining the Point fields.
+func scanTags(buf []byte, i int, indices []int) (int, int, []int, error) {
+	var (
+		err    error
+		commas int
+		state  = tagKeyState
+	)
+
+	for {
+		switch state {
+		case tagKeyState:
+			// Grow our indices slice if we have too many tags.
+			if commas >= len(indices) {
+				newIndics := make([]int, cap(indices)*2)
+				copy(newIndics, indices)
+				indices = newIndics
+			}
+			indices[commas] = i
+			commas++
+
+			i, err = scanTagsKey(buf, i)
+			state = tagValueState // tag value always follows a tag key
+		case tagValueState:
+			state, i, err = scanTagsValue(buf, i)
+		case fieldsState:
+			indices[commas] = i + 1
+			return i, commas, indices, nil
+		}
+
+		if err != nil {
+			return i, commas, indices, err
+		}
+	}
+}
+
+// scanTagsKey scans each character in a tag key.
+func scanTagsKey(buf []byte, i int) (int, error) {
+	// First character of the key.
+	if i >= len(buf) || buf[i] == ' ' || buf[i] == ',' || buf[i] == '=' {
+		// cpu,{'', ' ', ',', '='}
+		return i, fmt.Errorf("missing tag key")
+	}
+
+	// Examine each character in the tag key until we hit an unescaped
+	// equals (the tag value), or we hit an error (i.e., unescaped
+	// space or comma).
+	for {
+		i++
+
+		// Either we reached the end of the buffer or we hit an
+		// unescaped comma or space.
+		if i >= len(buf) ||
+			((buf[i] == ' ' || buf[i] == ',') && buf[i-1] != '\\') {
+			// cpu,tag{'', ' ', ','}
+			return i, fmt.Errorf("missing tag value")
+		}
+
+		if buf[i] == '=' && buf[i-1] != '\\' {
+			// cpu,tag=
+			return i + 1, nil
+		}
+	}
+}
+
+// scanTagsValue scans each character in a tag value.
+func scanTagsValue(buf []byte, i int) (int, int, error) {
+	// Tag value cannot be empty.
+	if i >= len(buf) || buf[i] == ',' || buf[i] == ' ' {
+		// cpu,tag={',', ' '}
+		return -1, i, fmt.Errorf("missing tag value")
+	}
+
+	// Examine each character in the tag value until we hit an unescaped
+	// comma (move onto next tag key), an unescaped space (move onto
+	// fields), or we error out.
+	for {
+		i++
+		if i >= len(buf) {
+			// cpu,tag=value
+			return -1, i, fmt.Errorf("missing fields")
+		}
+
+		// An unescaped equals sign is an invalid tag value.
+		if buf[i] == '=' && buf[i-1] != '\\' {
+			// cpu,tag={'=', 'fo=o'}
+			return -1, i, fmt.Errorf("invalid tag format")
+		}
+
+		if buf[i] == ',' && buf[i-1] != '\\' {
+			// cpu,tag=foo,
+			return tagKeyState, i + 1, nil
+		}
+
+		// cpu,tag=foo value=1.0
+		// cpu, tag=foo\= value=1.0
+		if buf[i] == ' ' && buf[i-1] != '\\' {
+			return fieldsState, i, nil
+		}
+	}
+}
+
+func insertionSort(l, r int, buf []byte, indices []int) {
+	for i := l + 1; i < r; i++ {
+		for j := i; j > l && less(buf, indices, j, j-1); j-- {
+			indices[j], indices[j-1] = indices[j-1], indices[j]
+		}
+	}
+}
+
+func less(buf []byte, indices []int, i, j int) bool {
+	// This grabs the tag names for i & j, it ignores the values
+	_, a := scanTo(buf, indices[i], '=')
+	_, b := scanTo(buf, indices[j], '=')
+	return bytes.Compare(a, b) < 0
+}
+
+// scanFields scans buf, starting at i for the fields section of a point.  It returns
+// the ending position and the byte slice of the fields within buf.
+func scanFields(buf []byte, i int) (int, []byte, error) {
+	start := skipWhitespace(buf, i)
+	i = start
+	quoted := false
+
+	// tracks how many '=' we've seen
+	equals := 0
+
+	// tracks how many commas we've seen
+	commas := 0
+
+	for {
+		// reached the end of buf?
+		if i >= len(buf) {
+			break
+		}
+
+		// escaped characters?
+		if buf[i] == '\\' && i+1 < len(buf) {
+			i += 2
+			continue
+		}
+
+		// If the value is quoted, scan until we get to the end quote
+		// Only quote values in the field value since quotes are not significant
+		// in the field key
+		if buf[i] == '"' && equals > commas {
+			quoted = !quoted
+			i++
+			continue
+		}
+
+		// If we see an =, ensure that there is at least on char before and after it
+		if buf[i] == '=' && !quoted {
+			equals++
+
+			// check for "... =123" but allow "a\ =123"
+			if buf[i-1] == ' ' && buf[i-2] != '\\' {
+				return i, buf[start:i], fmt.Errorf("missing field key")
+			}
+
+			// check for "...a=123,=456" but allow "a=123,a\,=456"
+			if buf[i-1] == ',' && buf[i-2] != '\\' {
+				return i, buf[start:i], fmt.Errorf("missing field key")
+			}
+
+			// check for "... value="
+			if i+1 >= len(buf) {
+				return i, buf[start:i], fmt.Errorf("missing field value")
+			}
+
+			// check for "... value=,value2=..."
+			if buf[i+1] == ',' || buf[i+1] == ' ' {
+				return i, buf[start:i], fmt.Errorf("missing field value")
+			}
+
+			if isNumeric(buf[i+1]) || buf[i+1] == '-' || buf[i+1] == 'N' || buf[i+1] == 'n' {
+				var err error
+				i, err = scanNumber(buf, i+1)
+				if err != nil {
+					return i, buf[start:i], err
+				}
+				continue
+			}
+			// If next byte is not a double-quote, the value must be a boolean
+			if buf[i+1] != '"' {
+				var err error
+				i, _, err = scanBoolean(buf, i+1)
+				if err != nil {
+					return i, buf[start:i], err
+				}
+				continue
+			}
+		}
+
+		if buf[i] == ',' && !quoted {
+			commas++
+		}
+
+		// reached end of block?
+		if buf[i] == ' ' && !quoted {
+			break
+		}
+		i++
+	}
+
+	if quoted {
+		return i, buf[start:i], fmt.Errorf("unbalanced quotes")
+	}
+
+	// check that all field sections had key and values (e.g. prevent "a=1,b"
+	if equals == 0 || commas != equals-1 {
+		return i, buf[start:i], fmt.Errorf("invalid field format")
+	}
+
+	return i, buf[start:i], nil
+}
+
+// scanTime scans buf, starting at i for the time section of a point. It
+// returns the ending position and the byte slice of the timestamp within buf
+// and and error if the timestamp is not in the correct numeric format.
+func scanTime(buf []byte, i int) (int, []byte, error) {
+	start := skipWhitespace(buf, i)
+	i = start
+
+	for {
+		// reached the end of buf?
+		if i >= len(buf) {
+			break
+		}
+
+		// Reached end of block or trailing whitespace?
+		if buf[i] == '\n' || buf[i] == ' ' {
+			break
+		}
+
+		// Handle negative timestamps
+		if i == start && buf[i] == '-' {
+			i++
+			continue
+		}
+
+		// Timestamps should be integers, make sure they are so we don't need
+		// to actually  parse the timestamp until needed.
+		if buf[i] < '0' || buf[i] > '9' {
+			return i, buf[start:i], fmt.Errorf("bad timestamp")
+		}
+		i++
+	}
+	return i, buf[start:i], nil
+}
+
+func isNumeric(b byte) bool {
+	return (b >= '0' && b <= '9') || b == '.'
+}
+
+// scanNumber returns the end position within buf, start at i after
+// scanning over buf for an integer, or float.  It returns an
+// error if a invalid number is scanned.
+func scanNumber(buf []byte, i int) (int, error) {
+	start := i
+	var isInt, isUnsigned bool
+
+	// Is negative number?
+	if i < len(buf) && buf[i] == '-' {
+		i++
+		// There must be more characters now, as just '-' is illegal.
+		if i == len(buf) {
+			return i, ErrInvalidNumber
+		}
+	}
+
+	// how many decimal points we've see
+	decimal := false
+
+	// indicates the number is float in scientific notation
+	scientific := false
+
+	for {
+		if i >= len(buf) {
+			break
+		}
+
+		if buf[i] == ',' || buf[i] == ' ' {
+			break
+		}
+
+		if buf[i] == 'i' && i > start && !(isInt || isUnsigned) {
+			isInt = true
+			i++
+			continue
+		} else if buf[i] == 'u' && i > start && !(isInt || isUnsigned) {
+			isUnsigned = true
+			i++
+			continue
+		}
+
+		if buf[i] == '.' {
+			// Can't have more than 1 decimal (e.g. 1.1.1 should fail)
+			if decimal {
+				return i, ErrInvalidNumber
+			}
+			decimal = true
+		}
+
+		// `e` is valid for floats but not as the first char
+		if i > start && (buf[i] == 'e' || buf[i] == 'E') {
+			scientific = true
+			i++
+			continue
+		}
+
+		// + and - are only valid at this point if they follow an e (scientific notation)
+		if (buf[i] == '+' || buf[i] == '-') && (buf[i-1] == 'e' || buf[i-1] == 'E') {
+			i++
+			continue
+		}
+
+		// NaN is an unsupported value
+		if i+2 < len(buf) && (buf[i] == 'N' || buf[i] == 'n') {
+			return i, ErrInvalidNumber
+		}
+
+		if !isNumeric(buf[i]) {
+			return i, ErrInvalidNumber
+		}
+		i++
+	}
+
+	if (isInt || isUnsigned) && (decimal || scientific) {
+		return i, ErrInvalidNumber
+	}
+
+	numericDigits := i - start
+	if isInt {
+		numericDigits--
+	}
+	if decimal {
+		numericDigits--
+	}
+	if buf[start] == '-' {
+		numericDigits--
+	}
+
+	if numericDigits == 0 {
+		return i, ErrInvalidNumber
+	}
+
+	// It's more common that numbers will be within min/max range for their type but we need to prevent
+	// out or range numbers from being parsed successfully.  This uses some simple heuristics to decide
+	// if we should parse the number to the actual type.  It does not do it all the time because it incurs
+	// extra allocations and we end up converting the type again when writing points to disk.
+	if isInt {
+		// Make sure the last char is an 'i' for integers (e.g. 9i10 is not valid)
+		if buf[i-1] != 'i' {
+			return i, ErrInvalidNumber
+		}
+		// Parse the int to check bounds the number of digits could be larger than the max range
+		// We subtract 1 from the index to remove the `i` from our tests
+		if len(buf[start:i-1]) >= maxInt64Digits || len(buf[start:i-1]) >= minInt64Digits {
+			if _, err := parseIntBytes(buf[start:i-1], 10, 64); err != nil {
+				return i, fmt.Errorf("unable to parse integer %s: %s", buf[start:i-1], err)
+			}
+		}
+	} else if isUnsigned {
+		// Return an error if uint64 support has not been enabled.
+		if !enableUint64Support {
+			return i, ErrInvalidNumber
+		}
+		// Make sure the last char is a 'u' for unsigned
+		if buf[i-1] != 'u' {
+			return i, ErrInvalidNumber
+		}
+		// Make sure the first char is not a '-' for unsigned
+		if buf[start] == '-' {
+			return i, ErrInvalidNumber
+		}
+		// Parse the uint to check bounds the number of digits could be larger than the max range
+		// We subtract 1 from the index to remove the `u` from our tests
+		if len(buf[start:i-1]) >= maxUint64Digits {
+			if _, err := parseUintBytes(buf[start:i-1], 10, 64); err != nil {
+				return i, fmt.Errorf("unable to parse unsigned %s: %s", buf[start:i-1], err)
+			}
+		}
+	} else {
+		// Parse the float to check bounds if it's scientific or the number of digits could be larger than the max range
+		if scientific || len(buf[start:i]) >= maxFloat64Digits || len(buf[start:i]) >= minFloat64Digits {
+			if _, err := parseFloatBytes(buf[start:i], 10); err != nil {
+				return i, fmt.Errorf("invalid float")
+			}
+		}
+	}
+
+	return i, nil
+}
+
+// scanBoolean returns the end position within buf, start at i after
+// scanning over buf for boolean. Valid values for a boolean are
+// t, T, true, TRUE, f, F, false, FALSE.  It returns an error if a invalid boolean
+// is scanned.
+func scanBoolean(buf []byte, i int) (int, []byte, error) {
+	start := i
+
+	if i < len(buf) && (buf[i] != 't' && buf[i] != 'f' && buf[i] != 'T' && buf[i] != 'F') {
+		return i, buf[start:i], fmt.Errorf("invalid boolean")
+	}
+
+	i++
+	for {
+		if i >= len(buf) {
+			break
+		}
+
+		if buf[i] == ',' || buf[i] == ' ' {
+			break
+		}
+		i++
+	}
+
+	// Single char bool (t, T, f, F) is ok
+	if i-start == 1 {
+		return i, buf[start:i], nil
+	}
+
+	// length must be 4 for true or TRUE
+	if (buf[start] == 't' || buf[start] == 'T') && i-start != 4 {
+		return i, buf[start:i], fmt.Errorf("invalid boolean")
+	}
+
+	// length must be 5 for false or FALSE
+	if (buf[start] == 'f' || buf[start] == 'F') && i-start != 5 {
+		return i, buf[start:i], fmt.Errorf("invalid boolean")
+	}
+
+	// Otherwise
+	valid := false
+	switch buf[start] {
+	case 't':
+		valid = bytes.Equal(buf[start:i], []byte("true"))
+	case 'f':
+		valid = bytes.Equal(buf[start:i], []byte("false"))
+	case 'T':
+		valid = bytes.Equal(buf[start:i], []byte("TRUE")) || bytes.Equal(buf[start:i], []byte("True"))
+	case 'F':
+		valid = bytes.Equal(buf[start:i], []byte("FALSE")) || bytes.Equal(buf[start:i], []byte("False"))
+	}
+
+	if !valid {
+		return i, buf[start:i], fmt.Errorf("invalid boolean")
+	}
+
+	return i, buf[start:i], nil
+
+}
+
+// skipWhitespace returns the end position within buf, starting at i after
+// scanning over spaces in tags.
+func skipWhitespace(buf []byte, i int) int {
+	for i < len(buf) {
+		if buf[i] != ' ' && buf[i] != '\t' && buf[i] != 0 {
+			break
+		}
+		i++
+	}
+	return i
+}
+
+// scanLine returns the end position in buf and the next line found within
+// buf.
+func scanLine(buf []byte, i int) (int, []byte) {
+	start := i
+	quoted := false
+	fields := false
+
+	// tracks how many '=' and commas we've seen
+	// this duplicates some of the functionality in scanFields
+	equals := 0
+	commas := 0
+	for {
+		// reached the end of buf?
+		if i >= len(buf) {
+			break
+		}
+
+		// skip past escaped characters
+		if buf[i] == '\\' && i+2 < len(buf) {
+			i += 2
+			continue
+		}
+
+		if buf[i] == ' ' {
+			fields = true
+		}
+
+		// If we see a double quote, makes sure it is not escaped
+		if fields {
+			if !quoted && buf[i] == '=' {
+				i++
+				equals++
+				continue
+			} else if !quoted && buf[i] == ',' {
+				i++
+				commas++
+				continue
+			} else if buf[i] == '"' && equals > commas {
+				i++
+				quoted = !quoted
+				continue
+			}
+		}
+
+		if buf[i] == '\n' && !quoted {
+			break
+		}
+
+		i++
+	}
+
+	return i, buf[start:i]
+}
+
+// scanTo returns the end position in buf and the next consecutive block
+// of bytes, starting from i and ending with stop byte, where stop byte
+// has not been escaped.
+//
+// If there are leading spaces, they are skipped.
+func scanTo(buf []byte, i int, stop byte) (int, []byte) {
+	start := i
+	for {
+		// reached the end of buf?
+		if i >= len(buf) {
+			break
+		}
+
+		// Reached unescaped stop value?
+		if buf[i] == stop && (i == 0 || buf[i-1] != '\\') {
+			break
+		}
+		i++
+	}
+
+	return i, buf[start:i]
+}
+
+// scanTo returns the end position in buf and the next consecutive block
+// of bytes, starting from i and ending with stop byte.  If there are leading
+// spaces, they are skipped.
+func scanToSpaceOr(buf []byte, i int, stop byte) (int, []byte) {
+	start := i
+	if buf[i] == stop || buf[i] == ' ' {
+		return i, buf[start:i]
+	}
+
+	for {
+		i++
+		if buf[i-1] == '\\' {
+			continue
+		}
+
+		// reached the end of buf?
+		if i >= len(buf) {
+			return i, buf[start:i]
+		}
+
+		// reached end of block?
+		if buf[i] == stop || buf[i] == ' ' {
+			return i, buf[start:i]
+		}
+	}
+}
+
+func scanTagValue(buf []byte, i int) (int, []byte) {
+	start := i
+	for {
+		if i >= len(buf) {
+			break
+		}
+
+		if buf[i] == ',' && buf[i-1] != '\\' {
+			break
+		}
+		i++
+	}
+	if i > len(buf) {
+		return i, nil
+	}
+	return i, buf[start:i]
+}
+
+func scanFieldValue(buf []byte, i int) (int, []byte) {
+	start := i
+	quoted := false
+	for i < len(buf) {
+		// Only escape char for a field value is a double-quote and backslash
+		if buf[i] == '\\' && i+1 < len(buf) && (buf[i+1] == '"' || buf[i+1] == '\\') {
+			i += 2
+			continue
+		}
+
+		// Quoted value? (e.g. string)
+		if buf[i] == '"' {
+			i++
+			quoted = !quoted
+			continue
+		}
+
+		if buf[i] == ',' && !quoted {
+			break
+		}
+		i++
+	}
+	return i, buf[start:i]
+}
+
+func EscapeMeasurement(in []byte) []byte {
+	for b, esc := range measurementEscapeCodes {
+		in = bytes.Replace(in, []byte{b}, esc, -1)
+	}
+	return in
+}
+
+func unescapeMeasurement(in []byte) []byte {
+	for b, esc := range measurementEscapeCodes {
+		in = bytes.Replace(in, esc, []byte{b}, -1)
+	}
+	return in
+}
+
+func escapeTag(in []byte) []byte {
+	for b, esc := range tagEscapeCodes {
+		if bytes.IndexByte(in, b) != -1 {
+			in = bytes.Replace(in, []byte{b}, esc, -1)
+		}
+	}
+	return in
+}
+
+func unescapeTag(in []byte) []byte {
+	if bytes.IndexByte(in, '\\') == -1 {
+		return in
+	}
+
+	for b, esc := range tagEscapeCodes {
+		if bytes.IndexByte(in, b) != -1 {
+			in = bytes.Replace(in, esc, []byte{b}, -1)
+		}
+	}
+	return in
+}
+
+// escapeStringFieldReplacer replaces double quotes and backslashes
+// with the same character preceded by a backslash.
+// As of Go 1.7 this benchmarked better in allocations and CPU time
+// compared to iterating through a string byte-by-byte and appending to a new byte slice,
+// calling strings.Replace twice, and better than (*Regex).ReplaceAllString.
+var escapeStringFieldReplacer = strings.NewReplacer(`"`, `\"`, `\`, `\\`)
+
+// EscapeStringField returns a copy of in with any double quotes or
+// backslashes with escaped values.
+func EscapeStringField(in string) string {
+	return escapeStringFieldReplacer.Replace(in)
+}
+
+// unescapeStringField returns a copy of in with any escaped double-quotes
+// or backslashes unescaped.
+func unescapeStringField(in string) string {
+	if strings.IndexByte(in, '\\') == -1 {
+		return in
+	}
+
+	var out []byte
+	i := 0
+	for {
+		if i >= len(in) {
+			break
+		}
+		// unescape backslashes
+		if in[i] == '\\' && i+1 < len(in) && in[i+1] == '\\' {
+			out = append(out, '\\')
+			i += 2
+			continue
+		}
+		// unescape double-quotes
+		if in[i] == '\\' && i+1 < len(in) && in[i+1] == '"' {
+			out = append(out, '"')
+			i += 2
+			continue
+		}
+		out = append(out, in[i])
+		i++
+
+	}
+	return string(out)
+}
+
+// NewPoint returns a new point with the given measurement name, tags, fields and timestamp.  If
+// an unsupported field value (NaN) or out of range time is passed, this function returns an error.
+func NewPoint(name string, tags Tags, fields Fields, t time.Time) (Point, error) {
+	key, err := pointKey(name, tags, fields, t)
+	if err != nil {
+		return nil, err
+	}
+
+	return &point{
+		key:    key,
+		time:   t,
+		fields: fields.MarshalBinary(),
+	}, nil
+}
+
+// pointKey checks some basic requirements for valid points, and returns the
+// key, along with an possible error.
+func pointKey(measurement string, tags Tags, fields Fields, t time.Time) ([]byte, error) {
+	if len(fields) == 0 {
+		return nil, ErrPointMustHaveAField
+	}
+
+	if !t.IsZero() {
+		if err := CheckTime(t); err != nil {
+			return nil, err
+		}
+	}
+
+	for key, value := range fields {
+		switch value := value.(type) {
+		case float64:
+			// Ensure the caller validates and handles invalid field values
+			if math.IsNaN(value) {
+				return nil, fmt.Errorf("NaN is an unsupported value for field %s", key)
+			}
+		case float32:
+			// Ensure the caller validates and handles invalid field values
+			if math.IsNaN(float64(value)) {
+				return nil, fmt.Errorf("NaN is an unsupported value for field %s", key)
+			}
+		}
+		if len(key) == 0 {
+			return nil, fmt.Errorf("all fields must have non-empty names")
+		}
+	}
+
+	key := MakeKey([]byte(measurement), tags)
+	for field := range fields {
+		sz := seriesKeySize(key, []byte(field))
+		if sz > MaxKeyLength {
+			return nil, fmt.Errorf("max key length exceeded: %v > %v", sz, MaxKeyLength)
+		}
+	}
+
+	return key, nil
+}
+
+func seriesKeySize(key, field []byte) int {
+	// 4 is the length of the tsm1.fieldKeySeparator constant.  It's inlined here to avoid a circular
+	// dependency.
+	return len(key) + 4 + len(field)
+}
+
+// NewPointFromBytes returns a new Point from a marshalled Point.
+func NewPointFromBytes(b []byte) (Point, error) {
+	p := &point{}
+	if err := p.UnmarshalBinary(b); err != nil {
+		return nil, err
+	}
+
+	// This does some basic validation to ensure there are fields and they
+	// can be unmarshalled as well.
+	iter := p.FieldIterator()
+	var hasField bool
+	for iter.Next() {
+		if len(iter.FieldKey()) == 0 {
+			continue
+		}
+		hasField = true
+		switch iter.Type() {
+		case Float:
+			_, err := iter.FloatValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+		case Integer:
+			_, err := iter.IntegerValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+		case Unsigned:
+			_, err := iter.UnsignedValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+		case String:
+			// Skip since this won't return an error
+		case Boolean:
+			_, err := iter.BooleanValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+		}
+	}
+
+	if !hasField {
+		return nil, ErrPointMustHaveAField
+	}
+
+	return p, nil
+}
+
+// MustNewPoint returns a new point with the given measurement name, tags, fields and timestamp.  If
+// an unsupported field value (NaN) is passed, this function panics.
+func MustNewPoint(name string, tags Tags, fields Fields, time time.Time) Point {
+	pt, err := NewPoint(name, tags, fields, time)
+	if err != nil {
+		panic(err.Error())
+	}
+	return pt
+}
+
+// Key returns the key (measurement joined with tags) of the point.
+func (p *point) Key() []byte {
+	return p.key
+}
+
+func (p *point) name() []byte {
+	_, name := scanTo(p.key, 0, ',')
+	return name
+}
+
+func (p *point) Name() []byte {
+	return escape.Unescape(p.name())
+}
+
+// SetName updates the measurement name for the point.
+func (p *point) SetName(name string) {
+	p.cachedName = ""
+	p.key = MakeKey([]byte(name), p.Tags())
+}
+
+// Time return the timestamp for the point.
+func (p *point) Time() time.Time {
+	return p.time
+}
+
+// SetTime updates the timestamp for the point.
+func (p *point) SetTime(t time.Time) {
+	p.time = t
+}
+
+// Round will round the timestamp of the point to the given duration.
+func (p *point) Round(d time.Duration) {
+	p.time = p.time.Round(d)
+}
+
+// Tags returns the tag set for the point.
+func (p *point) Tags() Tags {
+	if p.cachedTags != nil {
+		return p.cachedTags
+	}
+	p.cachedTags = parseTags(p.key)
+	return p.cachedTags
+}
+
+func (p *point) HasTag(tag []byte) bool {
+	if len(p.key) == 0 {
+		return false
+	}
+
+	var exists bool
+	walkTags(p.key, func(key, value []byte) bool {
+		if bytes.Equal(tag, key) {
+			exists = true
+			return false
+		}
+		return true
+	})
+
+	return exists
+}
+
+func walkTags(buf []byte, fn func(key, value []byte) bool) {
+	if len(buf) == 0 {
+		return
+	}
+
+	pos, name := scanTo(buf, 0, ',')
+
+	// it's an empty key, so there are no tags
+	if len(name) == 0 {
+		return
+	}
+
+	hasEscape := bytes.IndexByte(buf, '\\') != -1
+	i := pos + 1
+	var key, value []byte
+	for {
+		if i >= len(buf) {
+			break
+		}
+		i, key = scanTo(buf, i, '=')
+		i, value = scanTagValue(buf, i+1)
+
+		if len(value) == 0 {
+			continue
+		}
+
+		if hasEscape {
+			if !fn(unescapeTag(key), unescapeTag(value)) {
+				return
+			}
+		} else {
+			if !fn(key, value) {
+				return
+			}
+		}
+
+		i++
+	}
+}
+
+// walkFields walks each field key and value via fn.  If fn returns false, the iteration
+// is stopped.  The values are the raw byte slices and not the converted types.
+func walkFields(buf []byte, fn func(key, value []byte) bool) {
+	var i int
+	var key, val []byte
+	for len(buf) > 0 {
+		i, key = scanTo(buf, 0, '=')
+		buf = buf[i+1:]
+		i, val = scanFieldValue(buf, 0)
+		buf = buf[i:]
+		if !fn(key, val) {
+			break
+		}
+
+		// slice off comma
+		if len(buf) > 0 {
+			buf = buf[1:]
+		}
+	}
+}
+
+func parseTags(buf []byte) Tags {
+	if len(buf) == 0 {
+		return nil
+	}
+
+	tags := make(Tags, bytes.Count(buf, []byte(",")))
+	p := 0
+	walkTags(buf, func(key, value []byte) bool {
+		tags[p].Key = key
+		tags[p].Value = value
+		p++
+		return true
+	})
+	return tags
+}
+
+// MakeKey creates a key for a set of tags.
+func MakeKey(name []byte, tags Tags) []byte {
+	// unescape the name and then re-escape it to avoid double escaping.
+	// The key should always be stored in escaped form.
+	return append(EscapeMeasurement(unescapeMeasurement(name)), tags.HashKey()...)
+}
+
+// SetTags replaces the tags for the point.
+func (p *point) SetTags(tags Tags) {
+	p.key = MakeKey(p.Name(), tags)
+	p.cachedTags = tags
+}
+
+// AddTag adds or replaces a tag value for a point.
+func (p *point) AddTag(key, value string) {
+	tags := p.Tags()
+	tags = append(tags, Tag{Key: []byte(key), Value: []byte(value)})
+	sort.Sort(tags)
+	p.cachedTags = tags
+	p.key = MakeKey(p.Name(), tags)
+}
+
+// Fields returns the fields for the point.
+func (p *point) Fields() (Fields, error) {
+	if p.cachedFields != nil {
+		return p.cachedFields, nil
+	}
+	cf, err := p.unmarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+	p.cachedFields = cf
+	return p.cachedFields, nil
+}
+
+// SetPrecision will round a time to the specified precision.
+func (p *point) SetPrecision(precision string) {
+	switch precision {
+	case "n":
+	case "u":
+		p.SetTime(p.Time().Truncate(time.Microsecond))
+	case "ms":
+		p.SetTime(p.Time().Truncate(time.Millisecond))
+	case "s":
+		p.SetTime(p.Time().Truncate(time.Second))
+	case "m":
+		p.SetTime(p.Time().Truncate(time.Minute))
+	case "h":
+		p.SetTime(p.Time().Truncate(time.Hour))
+	}
+}
+
+// String returns the string representation of the point.
+func (p *point) String() string {
+	if p.Time().IsZero() {
+		return string(p.Key()) + " " + string(p.fields)
+	}
+	return string(p.Key()) + " " + string(p.fields) + " " + strconv.FormatInt(p.UnixNano(), 10)
+}
+
+// AppendString appends the string representation of the point to buf.
+func (p *point) AppendString(buf []byte) []byte {
+	buf = append(buf, p.key...)
+	buf = append(buf, ' ')
+	buf = append(buf, p.fields...)
+
+	if !p.time.IsZero() {
+		buf = append(buf, ' ')
+		buf = strconv.AppendInt(buf, p.UnixNano(), 10)
+	}
+
+	return buf
+}
+
+// StringSize returns the length of the string that would be returned by String().
+func (p *point) StringSize() int {
+	size := len(p.key) + len(p.fields) + 1
+
+	if !p.time.IsZero() {
+		digits := 1 // even "0" has one digit
+		t := p.UnixNano()
+		if t < 0 {
+			// account for negative sign, then negate
+			digits++
+			t = -t
+		}
+		for t > 9 { // already accounted for one digit
+			digits++
+			t /= 10
+		}
+		size += digits + 1 // digits and a space
+	}
+
+	return size
+}
+
+// MarshalBinary returns a binary representation of the point.
+func (p *point) MarshalBinary() ([]byte, error) {
+	if len(p.fields) == 0 {
+		return nil, ErrPointMustHaveAField
+	}
+
+	tb, err := p.time.MarshalBinary()
+	if err != nil {
+		return nil, err
+	}
+
+	b := make([]byte, 8+len(p.key)+len(p.fields)+len(tb))
+	i := 0
+
+	binary.BigEndian.PutUint32(b[i:], uint32(len(p.key)))
+	i += 4
+
+	i += copy(b[i:], p.key)
+
+	binary.BigEndian.PutUint32(b[i:i+4], uint32(len(p.fields)))
+	i += 4
+
+	i += copy(b[i:], p.fields)
+
+	copy(b[i:], tb)
+	return b, nil
+}
+
+// UnmarshalBinary decodes a binary representation of the point into a point struct.
+func (p *point) UnmarshalBinary(b []byte) error {
+	var n int
+
+	// Read key length.
+	if len(b) < 4 {
+		return io.ErrShortBuffer
+	}
+	n, b = int(binary.BigEndian.Uint32(b[:4])), b[4:]
+
+	// Read key.
+	if len(b) < n {
+		return io.ErrShortBuffer
+	}
+	p.key, b = b[:n], b[n:]
+
+	// Read fields length.
+	if len(b) < 4 {
+		return io.ErrShortBuffer
+	}
+	n, b = int(binary.BigEndian.Uint32(b[:4])), b[4:]
+
+	// Read fields.
+	if len(b) < n {
+		return io.ErrShortBuffer
+	}
+	p.fields, b = b[:n], b[n:]
+
+	// Read timestamp.
+	if err := p.time.UnmarshalBinary(b); err != nil {
+		return err
+	}
+	return nil
+}
+
+// PrecisionString returns a string representation of the point. If there
+// is a timestamp associated with the point then it will be specified in the
+// given unit.
+func (p *point) PrecisionString(precision string) string {
+	if p.Time().IsZero() {
+		return fmt.Sprintf("%s %s", p.Key(), string(p.fields))
+	}
+	return fmt.Sprintf("%s %s %d", p.Key(), string(p.fields),
+		p.UnixNano()/GetPrecisionMultiplier(precision))
+}
+
+// RoundedString returns a string representation of the point. If there
+// is a timestamp associated with the point, then it will be rounded to the
+// given duration.
+func (p *point) RoundedString(d time.Duration) string {
+	if p.Time().IsZero() {
+		return fmt.Sprintf("%s %s", p.Key(), string(p.fields))
+	}
+	return fmt.Sprintf("%s %s %d", p.Key(), string(p.fields),
+		p.time.Round(d).UnixNano())
+}
+
+func (p *point) unmarshalBinary() (Fields, error) {
+	iter := p.FieldIterator()
+	fields := make(Fields, 8)
+	for iter.Next() {
+		if len(iter.FieldKey()) == 0 {
+			continue
+		}
+		switch iter.Type() {
+		case Float:
+			v, err := iter.FloatValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+			fields[string(iter.FieldKey())] = v
+		case Integer:
+			v, err := iter.IntegerValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+			fields[string(iter.FieldKey())] = v
+		case Unsigned:
+			v, err := iter.UnsignedValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+			fields[string(iter.FieldKey())] = v
+		case String:
+			fields[string(iter.FieldKey())] = iter.StringValue()
+		case Boolean:
+			v, err := iter.BooleanValue()
+			if err != nil {
+				return nil, fmt.Errorf("unable to unmarshal field %s: %s", string(iter.FieldKey()), err)
+			}
+			fields[string(iter.FieldKey())] = v
+		}
+	}
+	return fields, nil
+}
+
+// HashID returns a non-cryptographic checksum of the point's key.
+func (p *point) HashID() uint64 {
+	h := NewInlineFNV64a()
+	h.Write(p.key)
+	sum := h.Sum64()
+	return sum
+}
+
+// UnixNano returns the timestamp of the point as nanoseconds since Unix epoch.
+func (p *point) UnixNano() int64 {
+	return p.Time().UnixNano()
+}
+
+// Split will attempt to return multiple points with the same timestamp whose
+// string representations are no longer than size. Points with a single field or
+// a point without a timestamp may exceed the requested size.
+func (p *point) Split(size int) []Point {
+	if p.time.IsZero() || p.StringSize() <= size {
+		return []Point{p}
+	}
+
+	// key string, timestamp string, spaces
+	size -= len(p.key) + len(strconv.FormatInt(p.time.UnixNano(), 10)) + 2
+
+	var points []Point
+	var start, cur int
+
+	for cur < len(p.fields) {
+		end, _ := scanTo(p.fields, cur, '=')
+		end, _ = scanFieldValue(p.fields, end+1)
+
+		if cur > start && end-start > size {
+			points = append(points, &point{
+				key:    p.key,
+				time:   p.time,
+				fields: p.fields[start : cur-1],
+			})
+			start = cur
+		}
+
+		cur = end + 1
+	}
+
+	points = append(points, &point{
+		key:    p.key,
+		time:   p.time,
+		fields: p.fields[start:],
+	})
+
+	return points
+}
+
+// Tag represents a single key/value tag pair.
+type Tag struct {
+	Key   []byte
+	Value []byte
+}
+
+// NewTag returns a new Tag.
+func NewTag(key, value []byte) Tag {
+	return Tag{
+		Key:   key,
+		Value: value,
+	}
+}
+
+// Size returns the size of the key and value.
+func (t Tag) Size() int { return len(t.Key) + len(t.Value) }
+
+// Clone returns a shallow copy of Tag.
+//
+// Tags associated with a Point created by ParsePointsWithPrecision will hold references to the byte slice that was parsed.
+// Use Clone to create a Tag with new byte slices that do not refer to the argument to ParsePointsWithPrecision.
+func (t Tag) Clone() Tag {
+	other := Tag{
+		Key:   make([]byte, len(t.Key)),
+		Value: make([]byte, len(t.Value)),
+	}
+
+	copy(other.Key, t.Key)
+	copy(other.Value, t.Value)
+
+	return other
+}
+
+// String returns the string reprsentation of the tag.
+func (t *Tag) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('{')
+	buf.WriteString(string(t.Key))
+	buf.WriteByte(' ')
+	buf.WriteString(string(t.Value))
+	buf.WriteByte('}')
+	return buf.String()
+}
+
+// Tags represents a sorted list of tags.
+type Tags []Tag
+
+// NewTags returns a new Tags from a map.
+func NewTags(m map[string]string) Tags {
+	if len(m) == 0 {
+		return nil
+	}
+	a := make(Tags, 0, len(m))
+	for k, v := range m {
+		a = append(a, NewTag([]byte(k), []byte(v)))
+	}
+	sort.Sort(a)
+	return a
+}
+
+// Keys returns the list of keys for a tag set.
+func (a Tags) Keys() []string {
+	if len(a) == 0 {
+		return nil
+	}
+	keys := make([]string, len(a))
+	for i, tag := range a {
+		keys[i] = string(tag.Key)
+	}
+	return keys
+}
+
+// Values returns the list of values for a tag set.
+func (a Tags) Values() []string {
+	if len(a) == 0 {
+		return nil
+	}
+	values := make([]string, len(a))
+	for i, tag := range a {
+		values[i] = string(tag.Value)
+	}
+	return values
+}
+
+// String returns the string representation of the tags.
+func (a Tags) String() string {
+	var buf bytes.Buffer
+	buf.WriteByte('[')
+	for i := range a {
+		buf.WriteString(a[i].String())
+		if i < len(a)-1 {
+			buf.WriteByte(' ')
+		}
+	}
+	buf.WriteByte(']')
+	return buf.String()
+}
+
+// Size returns the number of bytes needed to store all tags. Note, this is
+// the number of bytes needed to store all keys and values and does not account
+// for data structures or delimiters for example.
+func (a Tags) Size() int {
+	var total int
+	for _, t := range a {
+		total += t.Size()
+	}
+	return total
+}
+
+// Clone returns a copy of the slice where the elements are a result of calling `Clone` on the original elements
+//
+// Tags associated with a Point created by ParsePointsWithPrecision will hold references to the byte slice that was parsed.
+// Use Clone to create Tags with new byte slices that do not refer to the argument to ParsePointsWithPrecision.
+func (a Tags) Clone() Tags {
+	if len(a) == 0 {
+		return nil
+	}
+
+	others := make(Tags, len(a))
+	for i := range a {
+		others[i] = a[i].Clone()
+	}
+
+	return others
+}
+
+func (a Tags) Len() int           { return len(a) }
+func (a Tags) Less(i, j int) bool { return bytes.Compare(a[i].Key, a[j].Key) == -1 }
+func (a Tags) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// Equal returns true if a equals other.
+func (a Tags) Equal(other Tags) bool {
+	if len(a) != len(other) {
+		return false
+	}
+	for i := range a {
+		if !bytes.Equal(a[i].Key, other[i].Key) || !bytes.Equal(a[i].Value, other[i].Value) {
+			return false
+		}
+	}
+	return true
+}
+
+// CompareTags returns -1 if a < b, 1 if a > b, and 0 if a == b.
+func CompareTags(a, b Tags) int {
+	// Compare each key & value until a mismatch.
+	for i := 0; i < len(a) && i < len(b); i++ {
+		if cmp := bytes.Compare(a[i].Key, b[i].Key); cmp != 0 {
+			return cmp
+		}
+		if cmp := bytes.Compare(a[i].Value, b[i].Value); cmp != 0 {
+			return cmp
+		}
+	}
+
+	// If all tags are equal up to this point then return shorter tagset.
+	if len(a) < len(b) {
+		return -1
+	} else if len(a) > len(b) {
+		return 1
+	}
+
+	// All tags are equal.
+	return 0
+}
+
+// Get returns the value for a key.
+func (a Tags) Get(key []byte) []byte {
+	// OPTIMIZE: Use sort.Search if tagset is large.
+
+	for _, t := range a {
+		if bytes.Equal(t.Key, key) {
+			return t.Value
+		}
+	}
+	return nil
+}
+
+// GetString returns the string value for a string key.
+func (a Tags) GetString(key string) string {
+	return string(a.Get([]byte(key)))
+}
+
+// Set sets the value for a key.
+func (a *Tags) Set(key, value []byte) {
+	for i, t := range *a {
+		if bytes.Equal(t.Key, key) {
+			(*a)[i].Value = value
+			return
+		}
+	}
+	*a = append(*a, Tag{Key: key, Value: value})
+	sort.Sort(*a)
+}
+
+// SetString sets the string value for a string key.
+func (a *Tags) SetString(key, value string) {
+	a.Set([]byte(key), []byte(value))
+}
+
+// Delete removes a tag by key.
+func (a *Tags) Delete(key []byte) {
+	for i, t := range *a {
+		if bytes.Equal(t.Key, key) {
+			copy((*a)[i:], (*a)[i+1:])
+			(*a)[len(*a)-1] = Tag{}
+			*a = (*a)[:len(*a)-1]
+			return
+		}
+	}
+}
+
+// Map returns a map representation of the tags.
+func (a Tags) Map() map[string]string {
+	m := make(map[string]string, len(a))
+	for _, t := range a {
+		m[string(t.Key)] = string(t.Value)
+	}
+	return m
+}
+
+// Merge merges the tags combining the two. If both define a tag with the
+// same key, the merged value overwrites the old value.
+// A new map is returned.
+func (a Tags) Merge(other map[string]string) Tags {
+	merged := make(map[string]string, len(a)+len(other))
+	for _, t := range a {
+		merged[string(t.Key)] = string(t.Value)
+	}
+	for k, v := range other {
+		merged[k] = v
+	}
+	return NewTags(merged)
+}
+
+// HashKey hashes all of a tag's keys.
+func (a Tags) HashKey() []byte {
+	// Empty maps marshal to empty bytes.
+	if len(a) == 0 {
+		return nil
+	}
+
+	// Type invariant: Tags are sorted
+
+	escaped := make(Tags, 0, len(a))
+	sz := 0
+	for _, t := range a {
+		ek := escapeTag(t.Key)
+		ev := escapeTag(t.Value)
+
+		if len(ev) > 0 {
+			escaped = append(escaped, Tag{Key: ek, Value: ev})
+			sz += len(ek) + len(ev)
+		}
+	}
+
+	sz += len(escaped) + (len(escaped) * 2) // separators
+
+	// Generate marshaled bytes.
+	b := make([]byte, sz)
+	buf := b
+	idx := 0
+	for _, k := range escaped {
+		buf[idx] = ','
+		idx++
+		copy(buf[idx:idx+len(k.Key)], k.Key)
+		idx += len(k.Key)
+		buf[idx] = '='
+		idx++
+		copy(buf[idx:idx+len(k.Value)], k.Value)
+		idx += len(k.Value)
+	}
+	return b[:idx]
+}
+
+// CopyTags returns a shallow copy of tags.
+func CopyTags(a Tags) Tags {
+	other := make(Tags, len(a))
+	copy(other, a)
+	return other
+}
+
+// DeepCopyTags returns a deep copy of tags.
+func DeepCopyTags(a Tags) Tags {
+	// Calculate size of keys/values in bytes.
+	var n int
+	for _, t := range a {
+		n += len(t.Key) + len(t.Value)
+	}
+
+	// Build single allocation for all key/values.
+	buf := make([]byte, n)
+
+	// Copy tags to new set.
+	other := make(Tags, len(a))
+	for i, t := range a {
+		copy(buf, t.Key)
+		other[i].Key, buf = buf[:len(t.Key)], buf[len(t.Key):]
+
+		copy(buf, t.Value)
+		other[i].Value, buf = buf[:len(t.Value)], buf[len(t.Value):]
+	}
+
+	return other
+}
+
+// Fields represents a mapping between a Point's field names and their
+// values.
+type Fields map[string]interface{}
+
+// FieldIterator retuns a FieldIterator that can be used to traverse the
+// fields of a point without constructing the in-memory map.
+func (p *point) FieldIterator() FieldIterator {
+	p.Reset()
+	return p
+}
+
+type fieldIterator struct {
+	start, end  int
+	key, keybuf []byte
+	valueBuf    []byte
+	fieldType   FieldType
+}
+
+// Next indicates whether there any fields remaining.
+func (p *point) Next() bool {
+	p.it.start = p.it.end
+	if p.it.start >= len(p.fields) {
+		return false
+	}
+
+	p.it.end, p.it.key = scanTo(p.fields, p.it.start, '=')
+	if escape.IsEscaped(p.it.key) {
+		p.it.keybuf = escape.AppendUnescaped(p.it.keybuf[:0], p.it.key)
+		p.it.key = p.it.keybuf
+	}
+
+	p.it.end, p.it.valueBuf = scanFieldValue(p.fields, p.it.end+1)
+	p.it.end++
+
+	if len(p.it.valueBuf) == 0 {
+		p.it.fieldType = Empty
+		return true
+	}
+
+	c := p.it.valueBuf[0]
+
+	if c == '"' {
+		p.it.fieldType = String
+		return true
+	}
+
+	if strings.IndexByte(`0123456789-.nNiIu`, c) >= 0 {
+		if p.it.valueBuf[len(p.it.valueBuf)-1] == 'i' {
+			p.it.fieldType = Integer
+			p.it.valueBuf = p.it.valueBuf[:len(p.it.valueBuf)-1]
+		} else if p.it.valueBuf[len(p.it.valueBuf)-1] == 'u' {
+			p.it.fieldType = Unsigned
+			p.it.valueBuf = p.it.valueBuf[:len(p.it.valueBuf)-1]
+		} else {
+			p.it.fieldType = Float
+		}
+		return true
+	}
+
+	// to keep the same behavior that currently exists, default to boolean
+	p.it.fieldType = Boolean
+	return true
+}
+
+// FieldKey returns the key of the current field.
+func (p *point) FieldKey() []byte {
+	return p.it.key
+}
+
+// Type returns the FieldType of the current field.
+func (p *point) Type() FieldType {
+	return p.it.fieldType
+}
+
+// StringValue returns the string value of the current field.
+func (p *point) StringValue() string {
+	return unescapeStringField(string(p.it.valueBuf[1 : len(p.it.valueBuf)-1]))
+}
+
+// IntegerValue returns the integer value of the current field.
+func (p *point) IntegerValue() (int64, error) {
+	n, err := parseIntBytes(p.it.valueBuf, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("unable to parse integer value %q: %v", p.it.valueBuf, err)
+	}
+	return n, nil
+}
+
+// UnsignedValue returns the unsigned value of the current field.
+func (p *point) UnsignedValue() (uint64, error) {
+	n, err := parseUintBytes(p.it.valueBuf, 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("unable to parse unsigned value %q: %v", p.it.valueBuf, err)
+	}
+	return n, nil
+}
+
+// BooleanValue returns the boolean value of the current field.
+func (p *point) BooleanValue() (bool, error) {
+	b, err := parseBoolBytes(p.it.valueBuf)
+	if err != nil {
+		return false, fmt.Errorf("unable to parse bool value %q: %v", p.it.valueBuf, err)
+	}
+	return b, nil
+}
+
+// FloatValue returns the float value of the current field.
+func (p *point) FloatValue() (float64, error) {
+	f, err := parseFloatBytes(p.it.valueBuf, 64)
+	if err != nil {
+		return 0, fmt.Errorf("unable to parse floating point value %q: %v", p.it.valueBuf, err)
+	}
+	return f, nil
+}
+
+// Reset resets the iterator to its initial state.
+func (p *point) Reset() {
+	p.it.fieldType = Empty
+	p.it.key = nil
+	p.it.valueBuf = nil
+	p.it.start = 0
+	p.it.end = 0
+}
+
+// MarshalBinary encodes all the fields to their proper type and returns the binary
+// represenation
+// NOTE: uint64 is specifically not supported due to potential overflow when we decode
+// again later to an int64
+// NOTE2: uint is accepted, and may be 64 bits, and is for some reason accepted...
+func (p Fields) MarshalBinary() []byte {
+	var b []byte
+	keys := make([]string, 0, len(p))
+
+	for k := range p {
+		keys = append(keys, k)
+	}
+
+	// Not really necessary, can probably be removed.
+	sort.Strings(keys)
+
+	for i, k := range keys {
+		if i > 0 {
+			b = append(b, ',')
+		}
+		b = appendField(b, k, p[k])
+	}
+
+	return b
+}
+
+func appendField(b []byte, k string, v interface{}) []byte {
+	b = append(b, []byte(escape.String(k))...)
+	b = append(b, '=')
+
+	// check popular types first
+	switch v := v.(type) {
+	case float64:
+		b = strconv.AppendFloat(b, v, 'f', -1, 64)
+	case int64:
+		b = strconv.AppendInt(b, v, 10)
+		b = append(b, 'i')
+	case string:
+		b = append(b, '"')
+		b = append(b, []byte(EscapeStringField(v))...)
+		b = append(b, '"')
+	case bool:
+		b = strconv.AppendBool(b, v)
+	case int32:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case int16:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case int8:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case int:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case uint64:
+		b = strconv.AppendUint(b, v, 10)
+		b = append(b, 'u')
+	case uint32:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case uint16:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case uint8:
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case uint:
+		// TODO: 'uint' should be converted to writing as an unsigned integer,
+		// but we cannot since that would break backwards compatibility.
+		b = strconv.AppendInt(b, int64(v), 10)
+		b = append(b, 'i')
+	case float32:
+		b = strconv.AppendFloat(b, float64(v), 'f', -1, 32)
+	case []byte:
+		b = append(b, v...)
+	case nil:
+		// skip
+	default:
+		// Can't determine the type, so convert to string
+		b = append(b, '"')
+		b = append(b, []byte(EscapeStringField(fmt.Sprintf("%v", v)))...)
+		b = append(b, '"')
+
+	}
+
+	return b
+}
+
+type byteSlices [][]byte
+
+func (a byteSlices) Len() int           { return len(a) }
+func (a byteSlices) Less(i, j int) bool { return bytes.Compare(a[i], a[j]) == -1 }
+func (a byteSlices) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/vendor/github.com/influxdata/influxdb/models/rows.go b/vendor/github.com/influxdata/influxdb/models/rows.go
new file mode 100644
index 0000000000..c087a4882d
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/rows.go
@@ -0,0 +1,62 @@
+package models
+
+import (
+	"sort"
+)
+
+// Row represents a single row returned from the execution of a statement.
+type Row struct {
+	Name    string            `json:"name,omitempty"`
+	Tags    map[string]string `json:"tags,omitempty"`
+	Columns []string          `json:"columns,omitempty"`
+	Values  [][]interface{}   `json:"values,omitempty"`
+	Partial bool              `json:"partial,omitempty"`
+}
+
+// SameSeries returns true if r contains values for the same series as o.
+func (r *Row) SameSeries(o *Row) bool {
+	return r.tagsHash() == o.tagsHash() && r.Name == o.Name
+}
+
+// tagsHash returns a hash of tag key/value pairs.
+func (r *Row) tagsHash() uint64 {
+	h := NewInlineFNV64a()
+	keys := r.tagsKeys()
+	for _, k := range keys {
+		h.Write([]byte(k))
+		h.Write([]byte(r.Tags[k]))
+	}
+	return h.Sum64()
+}
+
+// tagKeys returns a sorted list of tag keys.
+func (r *Row) tagsKeys() []string {
+	a := make([]string, 0, len(r.Tags))
+	for k := range r.Tags {
+		a = append(a, k)
+	}
+	sort.Strings(a)
+	return a
+}
+
+// Rows represents a collection of rows. Rows implements sort.Interface.
+type Rows []*Row
+
+// Len implements sort.Interface.
+func (p Rows) Len() int { return len(p) }
+
+// Less implements sort.Interface.
+func (p Rows) Less(i, j int) bool {
+	// Sort by name first.
+	if p[i].Name != p[j].Name {
+		return p[i].Name < p[j].Name
+	}
+
+	// Sort by tag set hash. Tags don't have a meaningful sort order so we
+	// just compute a hash and sort by that instead. This allows the tests
+	// to receive rows in a predictable order every time.
+	return p[i].tagsHash() < p[j].tagsHash()
+}
+
+// Swap implements sort.Interface.
+func (p Rows) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
diff --git a/vendor/github.com/influxdata/influxdb/models/statistic.go b/vendor/github.com/influxdata/influxdb/models/statistic.go
new file mode 100644
index 0000000000..553e9d09fb
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/statistic.go
@@ -0,0 +1,42 @@
+package models
+
+// Statistic is the representation of a statistic used by the monitoring service.
+type Statistic struct {
+	Name   string                 `json:"name"`
+	Tags   map[string]string      `json:"tags"`
+	Values map[string]interface{} `json:"values"`
+}
+
+// NewStatistic returns an initialized Statistic.
+func NewStatistic(name string) Statistic {
+	return Statistic{
+		Name:   name,
+		Tags:   make(map[string]string),
+		Values: make(map[string]interface{}),
+	}
+}
+
+// StatisticTags is a map that can be merged with others without causing
+// mutations to either map.
+type StatisticTags map[string]string
+
+// Merge creates a new map containing the merged contents of tags and t.
+// If both tags and the receiver map contain the same key, the value in tags
+// is used in the resulting map.
+//
+// Merge always returns a usable map.
+func (t StatisticTags) Merge(tags map[string]string) map[string]string {
+	// Add everything in tags to the result.
+	out := make(map[string]string, len(tags))
+	for k, v := range tags {
+		out[k] = v
+	}
+
+	// Only add values from t that don't appear in tags.
+	for k, v := range t {
+		if _, ok := tags[k]; !ok {
+			out[k] = v
+		}
+	}
+	return out
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/time.go b/vendor/github.com/influxdata/influxdb/models/time.go
new file mode 100644
index 0000000000..e98f2cb336
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/time.go
@@ -0,0 +1,74 @@
+package models
+
+// Helper time methods since parsing time can easily overflow and we only support a
+// specific time range.
+
+import (
+	"fmt"
+	"math"
+	"time"
+)
+
+const (
+	// MinNanoTime is the minumum time that can be represented.
+	//
+	// 1677-09-21 00:12:43.145224194 +0000 UTC
+	//
+	// The two lowest minimum integers are used as sentinel values.  The
+	// minimum value needs to be used as a value lower than any other value for
+	// comparisons and another separate value is needed to act as a sentinel
+	// default value that is unusable by the user, but usable internally.
+	// Because these two values need to be used for a special purpose, we do
+	// not allow users to write points at these two times.
+	MinNanoTime = int64(math.MinInt64) + 2
+
+	// MaxNanoTime is the maximum time that can be represented.
+	//
+	// 2262-04-11 23:47:16.854775806 +0000 UTC
+	//
+	// The highest time represented by a nanosecond needs to be used for an
+	// exclusive range in the shard group, so the maximum time needs to be one
+	// less than the possible maximum number of nanoseconds representable by an
+	// int64 so that we don't lose a point at that one time.
+	MaxNanoTime = int64(math.MaxInt64) - 1
+)
+
+var (
+	minNanoTime = time.Unix(0, MinNanoTime).UTC()
+	maxNanoTime = time.Unix(0, MaxNanoTime).UTC()
+
+	// ErrTimeOutOfRange gets returned when time is out of the representable range using int64 nanoseconds since the epoch.
+	ErrTimeOutOfRange = fmt.Errorf("time outside range %d - %d", MinNanoTime, MaxNanoTime)
+)
+
+// SafeCalcTime safely calculates the time given. Will return error if the time is outside the
+// supported range.
+func SafeCalcTime(timestamp int64, precision string) (time.Time, error) {
+	mult := GetPrecisionMultiplier(precision)
+	if t, ok := safeSignedMult(timestamp, mult); ok {
+		tme := time.Unix(0, t).UTC()
+		return tme, CheckTime(tme)
+	}
+
+	return time.Time{}, ErrTimeOutOfRange
+}
+
+// CheckTime checks that a time is within the safe range.
+func CheckTime(t time.Time) error {
+	if t.Before(minNanoTime) || t.After(maxNanoTime) {
+		return ErrTimeOutOfRange
+	}
+	return nil
+}
+
+// Perform the multiplication and check to make sure it didn't overflow.
+func safeSignedMult(a, b int64) (int64, bool) {
+	if a == 0 || b == 0 || a == 1 || b == 1 {
+		return a * b, true
+	}
+	if a == MinNanoTime || b == MaxNanoTime {
+		return 0, false
+	}
+	c := a * b
+	return c, c/b == a
+}
diff --git a/vendor/github.com/influxdata/influxdb/models/uint_support.go b/vendor/github.com/influxdata/influxdb/models/uint_support.go
new file mode 100644
index 0000000000..18d1ca06e2
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/models/uint_support.go
@@ -0,0 +1,7 @@
+// +build uint uint64
+
+package models
+
+func init() {
+	EnableUintSupport()
+}
diff --git a/vendor/github.com/influxdata/influxdb/pkg/escape/bytes.go b/vendor/github.com/influxdata/influxdb/pkg/escape/bytes.go
new file mode 100644
index 0000000000..f3b31f42d3
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/pkg/escape/bytes.go
@@ -0,0 +1,115 @@
+// Package escape contains utilities for escaping parts of InfluxQL
+// and InfluxDB line protocol.
+package escape // import "github.com/influxdata/influxdb/pkg/escape"
+
+import (
+	"bytes"
+	"strings"
+)
+
+// Codes is a map of bytes to be escaped.
+var Codes = map[byte][]byte{
+	',': []byte(`\,`),
+	'"': []byte(`\"`),
+	' ': []byte(`\ `),
+	'=': []byte(`\=`),
+}
+
+// Bytes escapes characters on the input slice, as defined by Codes.
+func Bytes(in []byte) []byte {
+	for b, esc := range Codes {
+		in = bytes.Replace(in, []byte{b}, esc, -1)
+	}
+	return in
+}
+
+const escapeChars = `," =`
+
+// IsEscaped returns whether b has any escaped characters,
+// i.e. whether b seems to have been processed by Bytes.
+func IsEscaped(b []byte) bool {
+	for len(b) > 0 {
+		i := bytes.IndexByte(b, '\\')
+		if i < 0 {
+			return false
+		}
+
+		if i+1 < len(b) && strings.IndexByte(escapeChars, b[i+1]) >= 0 {
+			return true
+		}
+		b = b[i+1:]
+	}
+	return false
+}
+
+// AppendUnescaped appends the unescaped version of src to dst
+// and returns the resulting slice.
+func AppendUnescaped(dst, src []byte) []byte {
+	var pos int
+	for len(src) > 0 {
+		next := bytes.IndexByte(src[pos:], '\\')
+		if next < 0 || pos+next+1 >= len(src) {
+			return append(dst, src...)
+		}
+
+		if pos+next+1 < len(src) && strings.IndexByte(escapeChars, src[pos+next+1]) >= 0 {
+			if pos+next > 0 {
+				dst = append(dst, src[:pos+next]...)
+			}
+			src = src[pos+next+1:]
+			pos = 0
+		} else {
+			pos += next + 1
+		}
+	}
+
+	return dst
+}
+
+// Unescape returns a new slice containing the unescaped version of in.
+func Unescape(in []byte) []byte {
+	if len(in) == 0 {
+		return nil
+	}
+
+	if bytes.IndexByte(in, '\\') == -1 {
+		return in
+	}
+
+	i := 0
+	inLen := len(in)
+
+	// The output size will be no more than inLen. Preallocating the
+	// capacity of the output is faster and uses less memory than
+	// letting append() do its own (over)allocation.
+	out := make([]byte, 0, inLen)
+
+	for {
+		if i >= inLen {
+			break
+		}
+		if in[i] == '\\' && i+1 < inLen {
+			switch in[i+1] {
+			case ',':
+				out = append(out, ',')
+				i += 2
+				continue
+			case '"':
+				out = append(out, '"')
+				i += 2
+				continue
+			case ' ':
+				out = append(out, ' ')
+				i += 2
+				continue
+			case '=':
+				out = append(out, '=')
+				i += 2
+				continue
+			}
+		}
+		out = append(out, in[i])
+		i += 1
+	}
+	return out
+}
diff --git a/vendor/github.com/influxdata/influxdb/pkg/escape/strings.go b/vendor/github.com/influxdata/influxdb/pkg/escape/strings.go
new file mode 100644
index 0000000000..db98033b0d
--- /dev/null
+++ b/vendor/github.com/influxdata/influxdb/pkg/escape/strings.go
@@ -0,0 +1,21 @@
+package escape
+
+import "strings"
+
+var (
+	escaper   = strings.NewReplacer(`,`, `\,`, `"`, `\"`, ` `, `\ `, `=`, `\=`)
+	unescaper = strings.NewReplacer(`\,`, `,`, `\"`, `"`, `\ `, ` `, `\=`, `=`)
+)
+
+// UnescapeString returns unescaped version of in.
+func UnescapeString(in string) string {
+	if strings.IndexByte(in, '\\') == -1 {
+		return in
+	}
+	return unescaper.Replace(in)
+}
+
+// String returns the escaped version of in.
+func String(in string) string {
+	return escaper.Replace(in)
+}
diff --git a/vendor/github.com/naoina/toml/encode.go b/vendor/github.com/naoina/toml/encode.go
index ae6bfd575f..15602f005a 100644
--- a/vendor/github.com/naoina/toml/encode.go
+++ b/vendor/github.com/naoina/toml/encode.go
@@ -61,20 +61,26 @@ func (cfg *Config) NewEncoder(w io.Writer) *Encoder {
 // Encode writes the TOML of v to the stream.
 // See the documentation for Marshal for details about the conversion of Go values to TOML.
 func (e *Encoder) Encode(v interface{}) error {
-	rv := reflect.ValueOf(v)
+	var (
+		buf = &tableBuf{typ: ast.TableTypeNormal}
+		rv  = reflect.ValueOf(v)
+		err error
+	)
+
 	for rv.Kind() == reflect.Ptr {
 		if rv.IsNil() {
 			return &marshalNilError{rv.Type()}
 		}
 		rv = rv.Elem()
 	}
-	buf := &tableBuf{typ: ast.TableTypeNormal}
-	var err error
+
 	switch rv.Kind() {
 	case reflect.Struct:
 		err = buf.structFields(e.cfg, rv)
 	case reflect.Map:
 		err = buf.mapFields(e.cfg, rv)
+	case reflect.Interface:
+		return e.Encode(rv.Interface())
 	default:
 		err = &marshalTableError{rv.Type()}
 	}
diff --git a/vendor/github.com/naoina/toml/parse.go b/vendor/github.com/naoina/toml/parse.go
index e6f95001e5..de9108566b 100644
--- a/vendor/github.com/naoina/toml/parse.go
+++ b/vendor/github.com/naoina/toml/parse.go
@@ -97,6 +97,7 @@ type toml struct {
 	currentTable *ast.Table
 	s            string
 	key          string
+	tableKeys    []string
 	val          ast.Value
 	arr          *array
 	stack        []*stack
@@ -180,12 +181,12 @@ func (p *tomlParser) SetArray(begin, end int) {
 }
 
 func (p *toml) SetTable(buf []rune, begin, end int) {
-	p.setTable(p.table, buf, begin, end)
+	rawName := string(buf[begin:end])
+	p.setTable(p.table, rawName, p.tableKeys)
+	p.tableKeys = nil
 }
 
-func (p *toml) setTable(parent *ast.Table, buf []rune, begin, end int) {
-	name := string(buf[begin:end])
-	names := splitTableKey(name)
+func (p *toml) setTable(parent *ast.Table, name string, names []string) {
 	parent, err := p.lookupTable(parent, names[:len(names)-1])
 	if err != nil {
 		p.Error(err)
@@ -230,12 +231,12 @@ func (p *tomlParser) SetTableString(begin, end int) {
 }
 
 func (p *toml) SetArrayTable(buf []rune, begin, end int) {
-	p.setArrayTable(p.table, buf, begin, end)
+	rawName := string(buf[begin:end])
+	p.setArrayTable(p.table, rawName, p.tableKeys)
+	p.tableKeys = nil
 }
 
-func (p *toml) setArrayTable(parent *ast.Table, buf []rune, begin, end int) {
-	name := string(buf[begin:end])
-	names := splitTableKey(name)
+func (p *toml) setArrayTable(parent *ast.Table, name string, names []string) {
 	parent, err := p.lookupTable(parent, names[:len(names)-1])
 	if err != nil {
 		p.Error(err)
@@ -260,11 +261,11 @@ func (p *toml) setArrayTable(parent *ast.Table, buf []rune, begin, end int) {
 func (p *toml) StartInlineTable() {
 	p.skip = false
 	p.stack = append(p.stack, &stack{p.key, p.currentTable})
-	buf := []rune(p.key)
+	names := []string{p.key}
 	if p.arr == nil {
-		p.setTable(p.currentTable, buf, 0, len(buf))
+		p.setTable(p.currentTable, names[0], names)
 	} else {
-		p.setArrayTable(p.currentTable, buf, 0, len(buf))
+		p.setArrayTable(p.currentTable, names[0], names)
 	}
 }
 
@@ -282,6 +283,13 @@ func (p *toml) AddLineCount(i int) {
 
 func (p *toml) SetKey(buf []rune, begin, end int) {
 	p.key = string(buf[begin:end])
+	if len(p.key) > 0 && p.key[0] == '"' {
+		p.key = p.unquote(p.key)
+	}
+}
+
+func (p *toml) AddTableKey() {
+	p.tableKeys = append(p.tableKeys, p.key)
 }
 
 func (p *toml) AddKeyValue() {
@@ -352,25 +360,3 @@ func (p *toml) lookupTable(t *ast.Table, keys []string) (*ast.Table, error) {
 	}
 	return t, nil
 }
-
-func splitTableKey(tk string) []string {
-	key := make([]byte, 0, 1)
-	keys := make([]string, 0, 1)
-	inQuote := false
-	for i := 0; i < len(tk); i++ {
-		k := tk[i]
-		switch {
-		case k == tableSeparator && !inQuote:
-			keys = append(keys, string(key))
-			key = key[:0] // reuse buffer.
-		case k == '"':
-			inQuote = !inQuote
-		case (k == ' ' || k == '\t') && !inQuote:
-			// skip.
-		default:
-			key = append(key, k)
-		}
-	}
-	keys = append(keys, string(key))
-	return keys
-}
diff --git a/vendor/github.com/naoina/toml/parse.peg b/vendor/github.com/naoina/toml/parse.peg
index da31dae309..860ada3732 100644
--- a/vendor/github.com/naoina/toml/parse.peg
+++ b/vendor/github.com/naoina/toml/parse.peg
@@ -29,7 +29,7 @@ key <- bareKey / quotedKey
 
 bareKey <- <[0-9A-Za-z\-_]+> { p.SetKey(p.buffer, begin, end) }
 
-quotedKey <- '"'  '"' { p.SetKey(p.buffer, begin-1, end+1) }
+quotedKey <- < '"' basicChar* '"' > { p.SetKey(p.buffer, begin, end) }
 
 val <- (
         { p.SetTime(begin, end) }
@@ -55,7 +55,9 @@ inlineTable <- (
 
 inlineTableKeyValues <- (keyval inlineTableValSep?)*
 
-tableKey <- key (tableKeySep key)*
+tableKey <- tableKeyComp (tableKeySep tableKeyComp)*
+
+tableKeyComp <- key { p.AddTableKey() }
 
 tableKeySep <- ws '.' ws
 
@@ -117,7 +119,7 @@ timeNumoffset <- [\-+] timeHour ':' timeMinute
 timeOffset <- 'Z' / timeNumoffset
 partialTime <- timeHour ':' timeMinute ':' timeSecond timeSecfrac?
 fullDate <- dateFullYear '-' dateMonth '-' dateMDay
-fullTime <- partialTime timeOffset
+fullTime <- partialTime timeOffset?
 datetime <- (fullDate ('T' fullTime)?) / partialTime
 
 digit <- [0-9]
diff --git a/vendor/github.com/naoina/toml/parse.peg.go b/vendor/github.com/naoina/toml/parse.peg.go
index d7de73b19c..fa377b19bd 100644
--- a/vendor/github.com/naoina/toml/parse.peg.go
+++ b/vendor/github.com/naoina/toml/parse.peg.go
@@ -31,6 +31,7 @@ const (
 	ruleinlineTable
 	ruleinlineTableKeyValues
 	ruletableKey
+	ruletableKeyComp
 	ruletableKeySep
 	ruleinlineTableValSep
 	ruleinteger
@@ -99,6 +100,7 @@ const (
 	ruleAction22
 	ruleAction23
 	ruleAction24
+	ruleAction25
 )
 
 var rul3s = [...]string{
@@ -120,6 +122,7 @@ var rul3s = [...]string{
 	"inlineTable",
 	"inlineTableKeyValues",
 	"tableKey",
+	"tableKeyComp",
 	"tableKeySep",
 	"inlineTableValSep",
 	"integer",
@@ -188,6 +191,7 @@ var rul3s = [...]string{
 	"Action22",
 	"Action23",
 	"Action24",
+	"Action25",
 }
 
 type token32 struct {
@@ -304,7 +308,7 @@ type tomlParser struct {
 
 	Buffer string
 	buffer []rune
-	rules  [86]func() bool
+	rules  [88]func() bool
 	parse  func(rule ...int) error
 	reset  func()
 	Pretty bool
@@ -409,7 +413,7 @@ func (p *tomlParser) Execute() {
 		case ruleAction5:
 			p.SetKey(p.buffer, begin, end)
 		case ruleAction6:
-			p.SetKey(p.buffer, begin-1, end+1)
+			p.SetKey(p.buffer, begin, end)
 		case ruleAction7:
 			p.SetTime(begin, end)
 		case ruleAction8:
@@ -431,21 +435,23 @@ func (p *tomlParser) Execute() {
 		case ruleAction16:
 			p.EndInlineTable()
 		case ruleAction17:
-			p.SetBasicString(p.buffer, begin, end)
+			p.AddTableKey()
 		case ruleAction18:
-			p.SetMultilineString()
+			p.SetBasicString(p.buffer, begin, end)
 		case ruleAction19:
-			p.AddMultilineBasicBody(p.buffer, begin, end)
+			p.SetMultilineString()
 		case ruleAction20:
-			p.SetLiteralString(p.buffer, begin, end)
+			p.AddMultilineBasicBody(p.buffer, begin, end)
 		case ruleAction21:
-			p.SetMultilineLiteralString(p.buffer, begin, end)
+			p.SetLiteralString(p.buffer, begin, end)
 		case ruleAction22:
-			p.StartArray()
+			p.SetMultilineLiteralString(p.buffer, begin, end)
 		case ruleAction23:
-			p.AddArrayVal()
+			p.StartArray()
 		case ruleAction24:
 			p.AddArrayVal()
+		case ruleAction25:
+			p.AddArrayVal()
 
 		}
 	}
@@ -1069,15 +1075,12 @@ func (p *tomlParser) Init() {
 					position, tokenIndex = position72, tokenIndex72
 					{
 						position81 := position
-						if buffer[position] != rune('"') {
-							goto l70
-						}
-						position++
 						{
 							position82 := position
-							if !_rules[rulebasicChar]() {
+							if buffer[position] != rune('"') {
 								goto l70
 							}
+							position++
 						l83:
 							{
 								position84, tokenIndex84 := position, tokenIndex
@@ -1088,12 +1091,12 @@ func (p *tomlParser) Init() {
 							l84:
 								position, tokenIndex = position84, tokenIndex84
 							}
+							if buffer[position] != rune('"') {
+								goto l70
+							}
+							position++
 							add(rulePegText, position82)
 						}
-						if buffer[position] != rune('"') {
-							goto l70
-						}
-						position++
 						{
 							add(ruleAction6, position)
 						}
@@ -1110,7 +1113,7 @@ func (p *tomlParser) Init() {
 		},
 		/* 8 bareKey <- <(<((&('_') '_') | (&('-') '-') | (&('a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z') [a-z]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z') [A-Z]))+> Action5)> */
 		nil,
-		/* 9 quotedKey <- <('"'  '"' Action6)> */
+		/* 9 quotedKey <- <(<('"' basicChar* '"')> Action6)> */
 		nil,
 		/* 10 val <- <(( Action7) / ( Action8) / ((&('{') inlineTable) | (&('[') ( Action12)) | (&('f' | 't') ( Action11)) | (&('"' | '\'') ( Action10)) | (&('+' | '-' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') ( Action9))))> */
 		func() bool {
@@ -1177,49 +1180,56 @@ func (p *tomlParser) Init() {
 											goto l101
 										}
 										{
-											position104 := position
+											position104, tokenIndex104 := position, tokenIndex
 											{
-												position105, tokenIndex105 := position, tokenIndex
-												if buffer[position] != rune('Z') {
-													goto l106
-												}
-												position++
-												goto l105
-											l106:
-												position, tokenIndex = position105, tokenIndex105
+												position106 := position
 												{
-													position107 := position
-													{
-														position108, tokenIndex108 := position, tokenIndex
-														if buffer[position] != rune('-') {
-															goto l109
-														}
-														position++
+													position107, tokenIndex107 := position, tokenIndex
+													if buffer[position] != rune('Z') {
 														goto l108
-													l109:
-														position, tokenIndex = position108, tokenIndex108
-														if buffer[position] != rune('+') {
-															goto l101
-														}
-														position++
-													}
-												l108:
-													if !_rules[ruletimeHour]() {
-														goto l101
-													}
-													if buffer[position] != rune(':') {
-														goto l101
 													}
 													position++
-													if !_rules[ruletimeMinute]() {
-														goto l101
+													goto l107
+												l108:
+													position, tokenIndex = position107, tokenIndex107
+													{
+														position109 := position
+														{
+															position110, tokenIndex110 := position, tokenIndex
+															if buffer[position] != rune('-') {
+																goto l111
+															}
+															position++
+															goto l110
+														l111:
+															position, tokenIndex = position110, tokenIndex110
+															if buffer[position] != rune('+') {
+																goto l104
+															}
+															position++
+														}
+													l110:
+														if !_rules[ruletimeHour]() {
+															goto l104
+														}
+														if buffer[position] != rune(':') {
+															goto l104
+														}
+														position++
+														if !_rules[ruletimeMinute]() {
+															goto l104
+														}
+														add(ruletimeNumoffset, position109)
 													}
-													add(ruletimeNumoffset, position107)
 												}
+											l107:
+												add(ruletimeOffset, position106)
 											}
-										l105:
-											add(ruletimeOffset, position104)
+											goto l105
+										l104:
+											position, tokenIndex = position104, tokenIndex104
 										}
+									l105:
 										add(rulefullTime, position103)
 									}
 									goto l102
@@ -1246,33 +1256,20 @@ func (p *tomlParser) Init() {
 				l91:
 					position, tokenIndex = position90, tokenIndex90
 					{
-						position112 := position
+						position114 := position
 						{
-							position113 := position
+							position115 := position
 							if !_rules[ruleinteger]() {
-								goto l111
+								goto l113
 							}
 							{
-								position114, tokenIndex114 := position, tokenIndex
+								position116, tokenIndex116 := position, tokenIndex
 								if !_rules[rulefrac]() {
-									goto l115
-								}
-								{
-									position116, tokenIndex116 := position, tokenIndex
-									if !_rules[ruleexp]() {
-										goto l116
-									}
 									goto l117
-								l116:
-									position, tokenIndex = position116, tokenIndex116
 								}
-							l117:
-								goto l114
-							l115:
-								position, tokenIndex = position114, tokenIndex114
 								{
 									position118, tokenIndex118 := position, tokenIndex
-									if !_rules[rulefrac]() {
+									if !_rules[ruleexp]() {
 										goto l118
 									}
 									goto l119
@@ -1280,26 +1277,39 @@ func (p *tomlParser) Init() {
 									position, tokenIndex = position118, tokenIndex118
 								}
 							l119:
+								goto l116
+							l117:
+								position, tokenIndex = position116, tokenIndex116
+								{
+									position120, tokenIndex120 := position, tokenIndex
+									if !_rules[rulefrac]() {
+										goto l120
+									}
+									goto l121
+								l120:
+									position, tokenIndex = position120, tokenIndex120
+								}
+							l121:
 								if !_rules[ruleexp]() {
-									goto l111
+									goto l113
 								}
 							}
-						l114:
-							add(rulefloat, position113)
+						l116:
+							add(rulefloat, position115)
 						}
-						add(rulePegText, position112)
+						add(rulePegText, position114)
 					}
 					{
 						add(ruleAction8, position)
 					}
 					goto l90
-				l111:
+				l113:
 					position, tokenIndex = position90, tokenIndex90
 					{
 						switch buffer[position] {
 						case '{':
 							{
-								position122 := position
+								position124 := position
 								if buffer[position] != rune('{') {
 									goto l88
 								}
@@ -1311,39 +1321,39 @@ func (p *tomlParser) Init() {
 									goto l88
 								}
 								{
-									position124 := position
-								l125:
+									position126 := position
+								l127:
 									{
-										position126, tokenIndex126 := position, tokenIndex
+										position128, tokenIndex128 := position, tokenIndex
 										if !_rules[rulekeyval]() {
-											goto l126
+											goto l128
 										}
 										{
-											position127, tokenIndex127 := position, tokenIndex
+											position129, tokenIndex129 := position, tokenIndex
 											{
-												position129 := position
+												position131 := position
 												if !_rules[rulews]() {
-													goto l127
+													goto l129
 												}
 												if buffer[position] != rune(',') {
-													goto l127
+													goto l129
 												}
 												position++
 												if !_rules[rulews]() {
-													goto l127
+													goto l129
 												}
-												add(ruleinlineTableValSep, position129)
+												add(ruleinlineTableValSep, position131)
 											}
-											goto l128
-										l127:
-											position, tokenIndex = position127, tokenIndex127
+											goto l130
+										l129:
+											position, tokenIndex = position129, tokenIndex129
 										}
+									l130:
+										goto l127
 									l128:
-										goto l125
-									l126:
-										position, tokenIndex = position126, tokenIndex126
+										position, tokenIndex = position128, tokenIndex128
 									}
-									add(ruleinlineTableKeyValues, position124)
+									add(ruleinlineTableKeyValues, position126)
 								}
 								if !_rules[rulews]() {
 									goto l88
@@ -1355,58 +1365,39 @@ func (p *tomlParser) Init() {
 								{
 									add(ruleAction16, position)
 								}
-								add(ruleinlineTable, position122)
+								add(ruleinlineTable, position124)
 							}
 							break
 						case '[':
 							{
-								position131 := position
+								position133 := position
 								{
-									position132 := position
+									position134 := position
 									if buffer[position] != rune('[') {
 										goto l88
 									}
 									position++
 									{
-										add(ruleAction22, position)
+										add(ruleAction23, position)
 									}
 									if !_rules[rulewsnl]() {
 										goto l88
 									}
 									{
-										position134, tokenIndex134 := position, tokenIndex
+										position136, tokenIndex136 := position, tokenIndex
 										{
-											position136 := position
+											position138 := position
 											if !_rules[ruleval]() {
-												goto l134
+												goto l136
 											}
 											{
-												add(ruleAction23, position)
+												add(ruleAction24, position)
 											}
-										l138:
+										l140:
 											{
-												position139, tokenIndex139 := position, tokenIndex
+												position141, tokenIndex141 := position, tokenIndex
 												if !_rules[rulewsnl]() {
-													goto l139
-												}
-												{
-													position140, tokenIndex140 := position, tokenIndex
-													if !_rules[rulecomment]() {
-														goto l140
-													}
 													goto l141
-												l140:
-													position, tokenIndex = position140, tokenIndex140
-												}
-											l141:
-												if !_rules[rulewsnl]() {
-													goto l139
-												}
-												if !_rules[rulearraySep]() {
-													goto l139
-												}
-												if !_rules[rulewsnl]() {
-													goto l139
 												}
 												{
 													position142, tokenIndex142 := position, tokenIndex
@@ -1419,37 +1410,43 @@ func (p *tomlParser) Init() {
 												}
 											l143:
 												if !_rules[rulewsnl]() {
-													goto l139
+													goto l141
 												}
-												if !_rules[ruleval]() {
-													goto l139
+												if !_rules[rulearraySep]() {
+													goto l141
+												}
+												if !_rules[rulewsnl]() {
+													goto l141
 												}
 												{
-													add(ruleAction24, position)
-												}
-												goto l138
-											l139:
-												position, tokenIndex = position139, tokenIndex139
-											}
-											if !_rules[rulewsnl]() {
-												goto l134
-											}
-											{
-												position145, tokenIndex145 := position, tokenIndex
-												if !_rules[rulearraySep]() {
+													position144, tokenIndex144 := position, tokenIndex
+													if !_rules[rulecomment]() {
+														goto l144
+													}
 													goto l145
+												l144:
+													position, tokenIndex = position144, tokenIndex144
 												}
-												goto l146
 											l145:
-												position, tokenIndex = position145, tokenIndex145
+												if !_rules[rulewsnl]() {
+													goto l141
+												}
+												if !_rules[ruleval]() {
+													goto l141
+												}
+												{
+													add(ruleAction25, position)
+												}
+												goto l140
+											l141:
+												position, tokenIndex = position141, tokenIndex141
 											}
-										l146:
 											if !_rules[rulewsnl]() {
-												goto l134
+												goto l136
 											}
 											{
 												position147, tokenIndex147 := position, tokenIndex
-												if !_rules[rulecomment]() {
+												if !_rules[rulearraySep]() {
 													goto l147
 												}
 												goto l148
@@ -1457,13 +1454,26 @@ func (p *tomlParser) Init() {
 												position, tokenIndex = position147, tokenIndex147
 											}
 										l148:
-											add(rulearrayValues, position136)
+											if !_rules[rulewsnl]() {
+												goto l136
+											}
+											{
+												position149, tokenIndex149 := position, tokenIndex
+												if !_rules[rulecomment]() {
+													goto l149
+												}
+												goto l150
+											l149:
+												position, tokenIndex = position149, tokenIndex149
+											}
+										l150:
+											add(rulearrayValues, position138)
 										}
-										goto l135
-									l134:
-										position, tokenIndex = position134, tokenIndex134
+										goto l137
+									l136:
+										position, tokenIndex = position136, tokenIndex136
 									}
-								l135:
+								l137:
 									if !_rules[rulewsnl]() {
 										goto l88
 									}
@@ -1471,9 +1481,9 @@ func (p *tomlParser) Init() {
 										goto l88
 									}
 									position++
-									add(rulearray, position132)
+									add(rulearray, position134)
 								}
-								add(rulePegText, position131)
+								add(rulePegText, position133)
 							}
 							{
 								add(ruleAction12, position)
@@ -1481,30 +1491,30 @@ func (p *tomlParser) Init() {
 							break
 						case 'f', 't':
 							{
-								position150 := position
+								position152 := position
 								{
-									position151 := position
+									position153 := position
 									{
-										position152, tokenIndex152 := position, tokenIndex
+										position154, tokenIndex154 := position, tokenIndex
 										if buffer[position] != rune('t') {
-											goto l153
+											goto l155
 										}
 										position++
 										if buffer[position] != rune('r') {
-											goto l153
+											goto l155
 										}
 										position++
 										if buffer[position] != rune('u') {
-											goto l153
+											goto l155
 										}
 										position++
 										if buffer[position] != rune('e') {
-											goto l153
+											goto l155
 										}
 										position++
-										goto l152
-									l153:
-										position, tokenIndex = position152, tokenIndex152
+										goto l154
+									l155:
+										position, tokenIndex = position154, tokenIndex154
 										if buffer[position] != rune('f') {
 											goto l88
 										}
@@ -1526,10 +1536,10 @@ func (p *tomlParser) Init() {
 										}
 										position++
 									}
-								l152:
-									add(ruleboolean, position151)
+								l154:
+									add(ruleboolean, position153)
 								}
-								add(rulePegText, position150)
+								add(rulePegText, position152)
 							}
 							{
 								add(ruleAction11, position)
@@ -1537,278 +1547,278 @@ func (p *tomlParser) Init() {
 							break
 						case '"', '\'':
 							{
-								position155 := position
+								position157 := position
 								{
-									position156 := position
+									position158 := position
 									{
-										position157, tokenIndex157 := position, tokenIndex
+										position159, tokenIndex159 := position, tokenIndex
 										{
-											position159 := position
+											position161 := position
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											{
-												position160 := position
+												position162 := position
 												{
-													position161 := position
-												l162:
+													position163 := position
+												l164:
 													{
-														position163, tokenIndex163 := position, tokenIndex
+														position165, tokenIndex165 := position, tokenIndex
 														{
-															position164, tokenIndex164 := position, tokenIndex
+															position166, tokenIndex166 := position, tokenIndex
 															if buffer[position] != rune('\'') {
-																goto l164
+																goto l166
 															}
 															position++
 															if buffer[position] != rune('\'') {
-																goto l164
+																goto l166
 															}
 															position++
 															if buffer[position] != rune('\'') {
-																goto l164
+																goto l166
 															}
 															position++
-															goto l163
-														l164:
-															position, tokenIndex = position164, tokenIndex164
+															goto l165
+														l166:
+															position, tokenIndex = position166, tokenIndex166
 														}
 														{
-															position165, tokenIndex165 := position, tokenIndex
+															position167, tokenIndex167 := position, tokenIndex
 															{
-																position167 := position
+																position169 := position
 																{
-																	position168, tokenIndex168 := position, tokenIndex
+																	position170, tokenIndex170 := position, tokenIndex
 																	if buffer[position] != rune('\t') {
-																		goto l169
+																		goto l171
 																	}
 																	position++
-																	goto l168
-																l169:
-																	position, tokenIndex = position168, tokenIndex168
+																	goto l170
+																l171:
+																	position, tokenIndex = position170, tokenIndex170
 																	if c := buffer[position]; c < rune(' ') || c > rune('\U0010ffff') {
-																		goto l166
+																		goto l168
 																	}
 																	position++
 																}
-															l168:
-																add(rulemlLiteralChar, position167)
+															l170:
+																add(rulemlLiteralChar, position169)
 															}
-															goto l165
-														l166:
-															position, tokenIndex = position165, tokenIndex165
+															goto l167
+														l168:
+															position, tokenIndex = position167, tokenIndex167
 															if !_rules[rulenewline]() {
-																goto l163
+																goto l165
 															}
 														}
+													l167:
+														goto l164
 													l165:
-														goto l162
-													l163:
-														position, tokenIndex = position163, tokenIndex163
+														position, tokenIndex = position165, tokenIndex165
 													}
-													add(rulemlLiteralBody, position161)
+													add(rulemlLiteralBody, position163)
 												}
-												add(rulePegText, position160)
+												add(rulePegText, position162)
 											}
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											if buffer[position] != rune('\'') {
-												goto l158
+												goto l160
 											}
 											position++
 											{
-												add(ruleAction21, position)
+												add(ruleAction22, position)
 											}
-											add(rulemlLiteralString, position159)
+											add(rulemlLiteralString, position161)
 										}
-										goto l157
-									l158:
-										position, tokenIndex = position157, tokenIndex157
+										goto l159
+									l160:
+										position, tokenIndex = position159, tokenIndex159
 										{
-											position172 := position
+											position174 := position
 											if buffer[position] != rune('\'') {
-												goto l171
+												goto l173
 											}
 											position++
 											{
-												position173 := position
-											l174:
+												position175 := position
+											l176:
 												{
-													position175, tokenIndex175 := position, tokenIndex
+													position177, tokenIndex177 := position, tokenIndex
 													{
-														position176 := position
+														position178 := position
 														{
 															switch buffer[position] {
 															case '\t':
 																if buffer[position] != rune('\t') {
-																	goto l175
+																	goto l177
 																}
 																position++
 																break
 															case ' ', '!', '"', '#', '$', '%', '&':
 																if c := buffer[position]; c < rune(' ') || c > rune('&') {
-																	goto l175
+																	goto l177
 																}
 																position++
 																break
 															default:
 																if c := buffer[position]; c < rune('(') || c > rune('\U0010ffff') {
-																	goto l175
+																	goto l177
 																}
 																position++
 																break
 															}
 														}
 
-														add(ruleliteralChar, position176)
+														add(ruleliteralChar, position178)
 													}
-													goto l174
-												l175:
-													position, tokenIndex = position175, tokenIndex175
+													goto l176
+												l177:
+													position, tokenIndex = position177, tokenIndex177
 												}
-												add(rulePegText, position173)
+												add(rulePegText, position175)
 											}
 											if buffer[position] != rune('\'') {
-												goto l171
+												goto l173
 											}
 											position++
 											{
-												add(ruleAction20, position)
+												add(ruleAction21, position)
 											}
-											add(ruleliteralString, position172)
+											add(ruleliteralString, position174)
 										}
-										goto l157
-									l171:
-										position, tokenIndex = position157, tokenIndex157
+										goto l159
+									l173:
+										position, tokenIndex = position159, tokenIndex159
 										{
-											position180 := position
+											position182 := position
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
 											{
-												position181 := position
-											l182:
+												position183 := position
+											l184:
 												{
-													position183, tokenIndex183 := position, tokenIndex
+													position185, tokenIndex185 := position, tokenIndex
 													{
-														position184, tokenIndex184 := position, tokenIndex
+														position186, tokenIndex186 := position, tokenIndex
 														{
-															position186 := position
+															position188 := position
 															{
-																position187, tokenIndex187 := position, tokenIndex
+																position189, tokenIndex189 := position, tokenIndex
 																if !_rules[rulebasicChar]() {
-																	goto l188
+																	goto l190
 																}
-																goto l187
-															l188:
-																position, tokenIndex = position187, tokenIndex187
+																goto l189
+															l190:
+																position, tokenIndex = position189, tokenIndex189
 																if !_rules[rulenewline]() {
-																	goto l185
+																	goto l187
 																}
 															}
-														l187:
-															add(rulePegText, position186)
+														l189:
+															add(rulePegText, position188)
 														}
 														{
-															add(ruleAction19, position)
+															add(ruleAction20, position)
 														}
-														goto l184
-													l185:
-														position, tokenIndex = position184, tokenIndex184
+														goto l186
+													l187:
+														position, tokenIndex = position186, tokenIndex186
 														if !_rules[ruleescape]() {
-															goto l183
+															goto l185
 														}
 														if !_rules[rulenewline]() {
-															goto l183
+															goto l185
 														}
 														if !_rules[rulewsnl]() {
-															goto l183
+															goto l185
 														}
 													}
-												l184:
-													goto l182
-												l183:
-													position, tokenIndex = position183, tokenIndex183
+												l186:
+													goto l184
+												l185:
+													position, tokenIndex = position185, tokenIndex185
 												}
-												add(rulemlBasicBody, position181)
+												add(rulemlBasicBody, position183)
 											}
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
 											if buffer[position] != rune('"') {
-												goto l179
+												goto l181
 											}
 											position++
+											{
+												add(ruleAction19, position)
+											}
+											add(rulemlBasicString, position182)
+										}
+										goto l159
+									l181:
+										position, tokenIndex = position159, tokenIndex159
+										{
+											position193 := position
+											{
+												position194 := position
+												if buffer[position] != rune('"') {
+													goto l88
+												}
+												position++
+											l195:
+												{
+													position196, tokenIndex196 := position, tokenIndex
+													if !_rules[rulebasicChar]() {
+														goto l196
+													}
+													goto l195
+												l196:
+													position, tokenIndex = position196, tokenIndex196
+												}
+												if buffer[position] != rune('"') {
+													goto l88
+												}
+												position++
+												add(rulePegText, position194)
+											}
 											{
 												add(ruleAction18, position)
 											}
-											add(rulemlBasicString, position180)
-										}
-										goto l157
-									l179:
-										position, tokenIndex = position157, tokenIndex157
-										{
-											position191 := position
-											{
-												position192 := position
-												if buffer[position] != rune('"') {
-													goto l88
-												}
-												position++
-											l193:
-												{
-													position194, tokenIndex194 := position, tokenIndex
-													if !_rules[rulebasicChar]() {
-														goto l194
-													}
-													goto l193
-												l194:
-													position, tokenIndex = position194, tokenIndex194
-												}
-												if buffer[position] != rune('"') {
-													goto l88
-												}
-												position++
-												add(rulePegText, position192)
-											}
-											{
-												add(ruleAction17, position)
-											}
-											add(rulebasicString, position191)
+											add(rulebasicString, position193)
 										}
 									}
-								l157:
-									add(rulestring, position156)
+								l159:
+									add(rulestring, position158)
 								}
-								add(rulePegText, position155)
+								add(rulePegText, position157)
 							}
 							{
 								add(ruleAction10, position)
@@ -1816,11 +1826,11 @@ func (p *tomlParser) Init() {
 							break
 						default:
 							{
-								position197 := position
+								position199 := position
 								if !_rules[ruleinteger]() {
 									goto l88
 								}
-								add(rulePegText, position197)
+								add(rulePegText, position199)
 							}
 							{
 								add(ruleAction9, position)
@@ -1848,708 +1858,728 @@ func (p *tomlParser) Init() {
 		nil,
 		/* 15 inlineTableKeyValues <- <(keyval inlineTableValSep?)*> */
 		nil,
-		/* 16 tableKey <- <(key (tableKeySep key)*)> */
+		/* 16 tableKey <- <(tableKeyComp (tableKeySep tableKeyComp)*)> */
 		func() bool {
-			position204, tokenIndex204 := position, tokenIndex
+			position206, tokenIndex206 := position, tokenIndex
 			{
-				position205 := position
-				if !_rules[rulekey]() {
-					goto l204
+				position207 := position
+				if !_rules[ruletableKeyComp]() {
+					goto l206
 				}
-			l206:
+			l208:
 				{
-					position207, tokenIndex207 := position, tokenIndex
+					position209, tokenIndex209 := position, tokenIndex
 					{
-						position208 := position
+						position210 := position
 						if !_rules[rulews]() {
-							goto l207
+							goto l209
 						}
 						if buffer[position] != rune('.') {
-							goto l207
+							goto l209
 						}
 						position++
 						if !_rules[rulews]() {
-							goto l207
+							goto l209
 						}
-						add(ruletableKeySep, position208)
+						add(ruletableKeySep, position210)
 					}
-					if !_rules[rulekey]() {
-						goto l207
+					if !_rules[ruletableKeyComp]() {
+						goto l209
 					}
-					goto l206
-				l207:
-					position, tokenIndex = position207, tokenIndex207
+					goto l208
+				l209:
+					position, tokenIndex = position209, tokenIndex209
 				}
-				add(ruletableKey, position205)
+				add(ruletableKey, position207)
 			}
 			return true
-		l204:
-			position, tokenIndex = position204, tokenIndex204
+		l206:
+			position, tokenIndex = position206, tokenIndex206
 			return false
 		},
-		/* 17 tableKeySep <- <(ws '.' ws)> */
-		nil,
-		/* 18 inlineTableValSep <- <(ws ',' ws)> */
-		nil,
-		/* 19 integer <- <(('-' / '+')? int)> */
+		/* 17 tableKeyComp <- <(key Action17)> */
 		func() bool {
 			position211, tokenIndex211 := position, tokenIndex
 			{
 				position212 := position
-				{
-					position213, tokenIndex213 := position, tokenIndex
-					{
-						position215, tokenIndex215 := position, tokenIndex
-						if buffer[position] != rune('-') {
-							goto l216
-						}
-						position++
-						goto l215
-					l216:
-						position, tokenIndex = position215, tokenIndex215
-						if buffer[position] != rune('+') {
-							goto l213
-						}
-						position++
-					}
-				l215:
-					goto l214
-				l213:
-					position, tokenIndex = position213, tokenIndex213
+				if !_rules[rulekey]() {
+					goto l211
 				}
-			l214:
 				{
-					position217 := position
-					{
-						position218, tokenIndex218 := position, tokenIndex
-						if c := buffer[position]; c < rune('1') || c > rune('9') {
-							goto l219
-						}
-						position++
-						{
-							position222, tokenIndex222 := position, tokenIndex
-							if !_rules[ruledigit]() {
-								goto l223
-							}
-							goto l222
-						l223:
-							position, tokenIndex = position222, tokenIndex222
-							if buffer[position] != rune('_') {
-								goto l219
-							}
-							position++
-							if !_rules[ruledigit]() {
-								goto l219
-							}
-						}
-					l222:
-					l220:
-						{
-							position221, tokenIndex221 := position, tokenIndex
-							{
-								position224, tokenIndex224 := position, tokenIndex
-								if !_rules[ruledigit]() {
-									goto l225
-								}
-								goto l224
-							l225:
-								position, tokenIndex = position224, tokenIndex224
-								if buffer[position] != rune('_') {
-									goto l221
-								}
-								position++
-								if !_rules[ruledigit]() {
-									goto l221
-								}
-							}
-						l224:
-							goto l220
-						l221:
-							position, tokenIndex = position221, tokenIndex221
-						}
-						goto l218
-					l219:
-						position, tokenIndex = position218, tokenIndex218
-						if !_rules[ruledigit]() {
-							goto l211
-						}
-					}
-				l218:
-					add(ruleint, position217)
+					add(ruleAction17, position)
 				}
-				add(ruleinteger, position212)
+				add(ruletableKeyComp, position212)
 			}
 			return true
 		l211:
 			position, tokenIndex = position211, tokenIndex211
 			return false
 		},
-		/* 20 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
+		/* 18 tableKeySep <- <(ws '.' ws)> */
 		nil,
-		/* 21 float <- <(integer ((frac exp?) / (frac? exp)))> */
+		/* 19 inlineTableValSep <- <(ws ',' ws)> */
 		nil,
-		/* 22 frac <- <('.' digit (digit / ('_' digit))*)> */
+		/* 20 integer <- <(('-' / '+')? int)> */
 		func() bool {
-			position228, tokenIndex228 := position, tokenIndex
+			position216, tokenIndex216 := position, tokenIndex
 			{
-				position229 := position
+				position217 := position
+				{
+					position218, tokenIndex218 := position, tokenIndex
+					{
+						position220, tokenIndex220 := position, tokenIndex
+						if buffer[position] != rune('-') {
+							goto l221
+						}
+						position++
+						goto l220
+					l221:
+						position, tokenIndex = position220, tokenIndex220
+						if buffer[position] != rune('+') {
+							goto l218
+						}
+						position++
+					}
+				l220:
+					goto l219
+				l218:
+					position, tokenIndex = position218, tokenIndex218
+				}
+			l219:
+				{
+					position222 := position
+					{
+						position223, tokenIndex223 := position, tokenIndex
+						if c := buffer[position]; c < rune('1') || c > rune('9') {
+							goto l224
+						}
+						position++
+						{
+							position227, tokenIndex227 := position, tokenIndex
+							if !_rules[ruledigit]() {
+								goto l228
+							}
+							goto l227
+						l228:
+							position, tokenIndex = position227, tokenIndex227
+							if buffer[position] != rune('_') {
+								goto l224
+							}
+							position++
+							if !_rules[ruledigit]() {
+								goto l224
+							}
+						}
+					l227:
+					l225:
+						{
+							position226, tokenIndex226 := position, tokenIndex
+							{
+								position229, tokenIndex229 := position, tokenIndex
+								if !_rules[ruledigit]() {
+									goto l230
+								}
+								goto l229
+							l230:
+								position, tokenIndex = position229, tokenIndex229
+								if buffer[position] != rune('_') {
+									goto l226
+								}
+								position++
+								if !_rules[ruledigit]() {
+									goto l226
+								}
+							}
+						l229:
+							goto l225
+						l226:
+							position, tokenIndex = position226, tokenIndex226
+						}
+						goto l223
+					l224:
+						position, tokenIndex = position223, tokenIndex223
+						if !_rules[ruledigit]() {
+							goto l216
+						}
+					}
+				l223:
+					add(ruleint, position222)
+				}
+				add(ruleinteger, position217)
+			}
+			return true
+		l216:
+			position, tokenIndex = position216, tokenIndex216
+			return false
+		},
+		/* 21 int <- <(([1-9] (digit / ('_' digit))+) / digit)> */
+		nil,
+		/* 22 float <- <(integer ((frac exp?) / (frac? exp)))> */
+		nil,
+		/* 23 frac <- <('.' digit (digit / ('_' digit))*)> */
+		func() bool {
+			position233, tokenIndex233 := position, tokenIndex
+			{
+				position234 := position
 				if buffer[position] != rune('.') {
-					goto l228
+					goto l233
 				}
 				position++
 				if !_rules[ruledigit]() {
-					goto l228
+					goto l233
 				}
-			l230:
-				{
-					position231, tokenIndex231 := position, tokenIndex
-					{
-						position232, tokenIndex232 := position, tokenIndex
-						if !_rules[ruledigit]() {
-							goto l233
-						}
-						goto l232
-					l233:
-						position, tokenIndex = position232, tokenIndex232
-						if buffer[position] != rune('_') {
-							goto l231
-						}
-						position++
-						if !_rules[ruledigit]() {
-							goto l231
-						}
-					}
-				l232:
-					goto l230
-				l231:
-					position, tokenIndex = position231, tokenIndex231
-				}
-				add(rulefrac, position229)
-			}
-			return true
-		l228:
-			position, tokenIndex = position228, tokenIndex228
-			return false
-		},
-		/* 23 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
-		func() bool {
-			position234, tokenIndex234 := position, tokenIndex
-			{
-				position235 := position
+			l235:
 				{
 					position236, tokenIndex236 := position, tokenIndex
-					if buffer[position] != rune('e') {
-						goto l237
-					}
-					position++
-					goto l236
-				l237:
-					position, tokenIndex = position236, tokenIndex236
-					if buffer[position] != rune('E') {
-						goto l234
-					}
-					position++
-				}
-			l236:
-				{
-					position238, tokenIndex238 := position, tokenIndex
 					{
-						position240, tokenIndex240 := position, tokenIndex
-						if buffer[position] != rune('-') {
-							goto l241
-						}
-						position++
-						goto l240
-					l241:
-						position, tokenIndex = position240, tokenIndex240
-						if buffer[position] != rune('+') {
+						position237, tokenIndex237 := position, tokenIndex
+						if !_rules[ruledigit]() {
 							goto l238
 						}
+						goto l237
+					l238:
+						position, tokenIndex = position237, tokenIndex237
+						if buffer[position] != rune('_') {
+							goto l236
+						}
 						position++
+						if !_rules[ruledigit]() {
+							goto l236
+						}
 					}
-				l240:
-					goto l239
-				l238:
-					position, tokenIndex = position238, tokenIndex238
+				l237:
+					goto l235
+				l236:
+					position, tokenIndex = position236, tokenIndex236
 				}
-			l239:
-				if !_rules[ruledigit]() {
-					goto l234
+				add(rulefrac, position234)
+			}
+			return true
+		l233:
+			position, tokenIndex = position233, tokenIndex233
+			return false
+		},
+		/* 24 exp <- <(('e' / 'E') ('-' / '+')? digit (digit / ('_' digit))*)> */
+		func() bool {
+			position239, tokenIndex239 := position, tokenIndex
+			{
+				position240 := position
+				{
+					position241, tokenIndex241 := position, tokenIndex
+					if buffer[position] != rune('e') {
+						goto l242
+					}
+					position++
+					goto l241
+				l242:
+					position, tokenIndex = position241, tokenIndex241
+					if buffer[position] != rune('E') {
+						goto l239
+					}
+					position++
 				}
-			l242:
+			l241:
 				{
 					position243, tokenIndex243 := position, tokenIndex
 					{
-						position244, tokenIndex244 := position, tokenIndex
-						if !_rules[ruledigit]() {
-							goto l245
+						position245, tokenIndex245 := position, tokenIndex
+						if buffer[position] != rune('-') {
+							goto l246
 						}
-						goto l244
-					l245:
-						position, tokenIndex = position244, tokenIndex244
-						if buffer[position] != rune('_') {
+						position++
+						goto l245
+					l246:
+						position, tokenIndex = position245, tokenIndex245
+						if buffer[position] != rune('+') {
 							goto l243
 						}
 						position++
-						if !_rules[ruledigit]() {
-							goto l243
-						}
 					}
-				l244:
-					goto l242
+				l245:
+					goto l244
 				l243:
 					position, tokenIndex = position243, tokenIndex243
 				}
-				add(ruleexp, position235)
+			l244:
+				if !_rules[ruledigit]() {
+					goto l239
+				}
+			l247:
+				{
+					position248, tokenIndex248 := position, tokenIndex
+					{
+						position249, tokenIndex249 := position, tokenIndex
+						if !_rules[ruledigit]() {
+							goto l250
+						}
+						goto l249
+					l250:
+						position, tokenIndex = position249, tokenIndex249
+						if buffer[position] != rune('_') {
+							goto l248
+						}
+						position++
+						if !_rules[ruledigit]() {
+							goto l248
+						}
+					}
+				l249:
+					goto l247
+				l248:
+					position, tokenIndex = position248, tokenIndex248
+				}
+				add(ruleexp, position240)
 			}
 			return true
-		l234:
-			position, tokenIndex = position234, tokenIndex234
+		l239:
+			position, tokenIndex = position239, tokenIndex239
 			return false
 		},
-		/* 24 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
+		/* 25 string <- <(mlLiteralString / literalString / mlBasicString / basicString)> */
 		nil,
-		/* 25 basicString <- <(<('"' basicChar* '"')> Action17)> */
+		/* 26 basicString <- <(<('"' basicChar* '"')> Action18)> */
 		nil,
-		/* 26 basicChar <- <(basicUnescaped / escaped)> */
+		/* 27 basicChar <- <(basicUnescaped / escaped)> */
 		func() bool {
-			position248, tokenIndex248 := position, tokenIndex
+			position253, tokenIndex253 := position, tokenIndex
 			{
-				position249 := position
+				position254 := position
 				{
-					position250, tokenIndex250 := position, tokenIndex
+					position255, tokenIndex255 := position, tokenIndex
 					{
-						position252 := position
+						position257 := position
 						{
 							switch buffer[position] {
 							case ' ', '!':
 								if c := buffer[position]; c < rune(' ') || c > rune('!') {
-									goto l251
+									goto l256
 								}
 								position++
 								break
 							case '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[':
 								if c := buffer[position]; c < rune('#') || c > rune('[') {
-									goto l251
+									goto l256
 								}
 								position++
 								break
 							default:
 								if c := buffer[position]; c < rune(']') || c > rune('\U0010ffff') {
-									goto l251
+									goto l256
 								}
 								position++
 								break
 							}
 						}
 
-						add(rulebasicUnescaped, position252)
+						add(rulebasicUnescaped, position257)
 					}
-					goto l250
-				l251:
-					position, tokenIndex = position250, tokenIndex250
+					goto l255
+				l256:
+					position, tokenIndex = position255, tokenIndex255
 					{
-						position254 := position
+						position259 := position
 						if !_rules[ruleescape]() {
-							goto l248
+							goto l253
 						}
 						{
 							switch buffer[position] {
 							case 'U':
 								if buffer[position] != rune('U') {
-									goto l248
+									goto l253
 								}
 								position++
 								if !_rules[rulehexQuad]() {
-									goto l248
+									goto l253
 								}
 								if !_rules[rulehexQuad]() {
-									goto l248
+									goto l253
 								}
 								break
 							case 'u':
 								if buffer[position] != rune('u') {
-									goto l248
+									goto l253
 								}
 								position++
 								if !_rules[rulehexQuad]() {
-									goto l248
+									goto l253
 								}
 								break
 							case '\\':
 								if buffer[position] != rune('\\') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case '/':
 								if buffer[position] != rune('/') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case '"':
 								if buffer[position] != rune('"') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case 'r':
 								if buffer[position] != rune('r') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case 'f':
 								if buffer[position] != rune('f') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case 'n':
 								if buffer[position] != rune('n') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							case 't':
 								if buffer[position] != rune('t') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							default:
 								if buffer[position] != rune('b') {
-									goto l248
+									goto l253
 								}
 								position++
 								break
 							}
 						}
 
-						add(ruleescaped, position254)
+						add(ruleescaped, position259)
 					}
 				}
-			l250:
-				add(rulebasicChar, position249)
+			l255:
+				add(rulebasicChar, position254)
 			}
 			return true
-		l248:
-			position, tokenIndex = position248, tokenIndex248
+		l253:
+			position, tokenIndex = position253, tokenIndex253
 			return false
 		},
-		/* 27 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
+		/* 28 escaped <- <(escape ((&('U') ('U' hexQuad hexQuad)) | (&('u') ('u' hexQuad)) | (&('\\') '\\') | (&('/') '/') | (&('"') '"') | (&('r') 'r') | (&('f') 'f') | (&('n') 'n') | (&('t') 't') | (&('b') 'b')))> */
 		nil,
-		/* 28 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[') [#-[]) | (&(']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') []-\U0010ffff]))> */
+		/* 29 basicUnescaped <- <((&(' ' | '!') [ -!]) | (&('#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[') [#-[]) | (&(']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') []-\U0010ffff]))> */
 		nil,
-		/* 29 escape <- <'\\'> */
+		/* 30 escape <- <'\\'> */
 		func() bool {
-			position258, tokenIndex258 := position, tokenIndex
+			position263, tokenIndex263 := position, tokenIndex
 			{
-				position259 := position
+				position264 := position
 				if buffer[position] != rune('\\') {
-					goto l258
+					goto l263
 				}
 				position++
-				add(ruleescape, position259)
+				add(ruleescape, position264)
 			}
 			return true
-		l258:
-			position, tokenIndex = position258, tokenIndex258
+		l263:
+			position, tokenIndex = position263, tokenIndex263
 			return false
 		},
-		/* 30 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action18)> */
+		/* 31 mlBasicString <- <('"' '"' '"' mlBasicBody ('"' '"' '"') Action19)> */
 		nil,
-		/* 31 mlBasicBody <- <((<(basicChar / newline)> Action19) / (escape newline wsnl))*> */
+		/* 32 mlBasicBody <- <((<(basicChar / newline)> Action20) / (escape newline wsnl))*> */
 		nil,
-		/* 32 literalString <- <('\''  '\'' Action20)> */
+		/* 33 literalString <- <('\''  '\'' Action21)> */
 		nil,
-		/* 33 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') [(-\U0010ffff]))> */
+		/* 34 literalChar <- <((&('\t') '\t') | (&(' ' | '!' | '"' | '#' | '$' | '%' | '&') [ -&]) | (&('(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' | '[' | '\\' | ']' | '^' | '_' | '`' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | '{' | '|' | '}' | '~' | '\u007f' | '\u0080' | '\u0081' | '\u0082' | '\u0083' | '\u0084' | '\u0085' | '\u0086' | '\u0087' | '\u0088' | '\u0089' | '\u008a' | '\u008b' | '\u008c' | '\u008d' | '\u008e' | '\u008f' | '\u0090' | '\u0091' | '\u0092' | '\u0093' | '\u0094' | '\u0095' | '\u0096' | '\u0097' | '\u0098' | '\u0099' | '\u009a' | '\u009b' | '\u009c' | '\u009d' | '\u009e' | '\u009f' | '\u00a0' | '¡' | '¢' | '£' | '¤' | '¥' | '¦' | '§' | '¨' | '©' | 'ª' | '«' | '¬' | '\u00ad' | '®' | '¯' | '°' | '±' | '²' | '³' | '´' | 'µ' | '¶' | '·' | '¸' | '¹' | 'º' | '»' | '¼' | '½' | '¾' | '¿' | 'À' | 'Á' | 'Â' | 'Ã' | 'Ä' | 'Å' | 'Æ' | 'Ç' | 'È' | 'É' | 'Ê' | 'Ë' | 'Ì' | 'Í' | 'Î' | 'Ï' | 'Ð' | 'Ñ' | 'Ò' | 'Ó' | 'Ô' | 'Õ' | 'Ö' | '×' | 'Ø' | 'Ù' | 'Ú' | 'Û' | 'Ü' | 'Ý' | 'Þ' | 'ß' | 'à' | 'á' | 'â' | 'ã' | 'ä' | 'å' | 'æ' | 'ç' | 'è' | 'é' | 'ê' | 'ë' | 'ì' | 'í' | 'î' | 'ï' | 'ð' | 'ñ' | 'ò' | 'ó' | 'ô' | 'õ' | 'ö' | '÷' | 'ø' | 'ù' | 'ú' | 'û' | 'ü' | 'ý' | 'þ' | 'ÿ') [(-\U0010ffff]))> */
 		nil,
-		/* 34 mlLiteralString <- <('\'' '\'' '\''  ('\'' '\'' '\'') Action21)> */
+		/* 35 mlLiteralString <- <('\'' '\'' '\''  ('\'' '\'' '\'') Action22)> */
 		nil,
-		/* 35 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
+		/* 36 mlLiteralBody <- <(!('\'' '\'' '\'') (mlLiteralChar / newline))*> */
 		nil,
-		/* 36 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
+		/* 37 mlLiteralChar <- <('\t' / [ -\U0010ffff])> */
 		nil,
-		/* 37 hexdigit <- <((&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))> */
+		/* 38 hexdigit <- <((&('a' | 'b' | 'c' | 'd' | 'e' | 'f') [a-f]) | (&('A' | 'B' | 'C' | 'D' | 'E' | 'F') [A-F]) | (&('0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9') [0-9]))> */
 		func() bool {
-			position267, tokenIndex267 := position, tokenIndex
+			position272, tokenIndex272 := position, tokenIndex
 			{
-				position268 := position
+				position273 := position
 				{
 					switch buffer[position] {
 					case 'a', 'b', 'c', 'd', 'e', 'f':
 						if c := buffer[position]; c < rune('a') || c > rune('f') {
-							goto l267
+							goto l272
 						}
 						position++
 						break
 					case 'A', 'B', 'C', 'D', 'E', 'F':
 						if c := buffer[position]; c < rune('A') || c > rune('F') {
-							goto l267
+							goto l272
 						}
 						position++
 						break
 					default:
 						if c := buffer[position]; c < rune('0') || c > rune('9') {
-							goto l267
+							goto l272
 						}
 						position++
 						break
 					}
 				}
 
-				add(rulehexdigit, position268)
+				add(rulehexdigit, position273)
 			}
 			return true
-		l267:
-			position, tokenIndex = position267, tokenIndex267
+		l272:
+			position, tokenIndex = position272, tokenIndex272
 			return false
 		},
-		/* 38 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
+		/* 39 hexQuad <- <(hexdigit hexdigit hexdigit hexdigit)> */
 		func() bool {
-			position270, tokenIndex270 := position, tokenIndex
+			position275, tokenIndex275 := position, tokenIndex
 			{
-				position271 := position
+				position276 := position
 				if !_rules[rulehexdigit]() {
-					goto l270
+					goto l275
 				}
 				if !_rules[rulehexdigit]() {
-					goto l270
+					goto l275
 				}
 				if !_rules[rulehexdigit]() {
-					goto l270
+					goto l275
 				}
 				if !_rules[rulehexdigit]() {
-					goto l270
+					goto l275
 				}
-				add(rulehexQuad, position271)
+				add(rulehexQuad, position276)
 			}
 			return true
-		l270:
-			position, tokenIndex = position270, tokenIndex270
+		l275:
+			position, tokenIndex = position275, tokenIndex275
 			return false
 		},
-		/* 39 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
+		/* 40 boolean <- <(('t' 'r' 'u' 'e') / ('f' 'a' 'l' 's' 'e'))> */
 		nil,
-		/* 40 dateFullYear <-  */
+		/* 41 dateFullYear <-  */
 		nil,
-		/* 41 dateMonth <-  */
+		/* 42 dateMonth <-  */
 		nil,
-		/* 42 dateMDay <-  */
+		/* 43 dateMDay <-  */
 		nil,
-		/* 43 timeHour <-  */
+		/* 44 timeHour <-  */
 		func() bool {
-			position276, tokenIndex276 := position, tokenIndex
+			position281, tokenIndex281 := position, tokenIndex
 			{
-				position277 := position
+				position282 := position
 				if !_rules[ruledigitDual]() {
-					goto l276
+					goto l281
 				}
-				add(ruletimeHour, position277)
+				add(ruletimeHour, position282)
 			}
 			return true
-		l276:
-			position, tokenIndex = position276, tokenIndex276
+		l281:
+			position, tokenIndex = position281, tokenIndex281
 			return false
 		},
-		/* 44 timeMinute <-  */
+		/* 45 timeMinute <-  */
 		func() bool {
-			position278, tokenIndex278 := position, tokenIndex
+			position283, tokenIndex283 := position, tokenIndex
 			{
-				position279 := position
+				position284 := position
 				if !_rules[ruledigitDual]() {
-					goto l278
+					goto l283
 				}
-				add(ruletimeMinute, position279)
+				add(ruletimeMinute, position284)
 			}
 			return true
-		l278:
-			position, tokenIndex = position278, tokenIndex278
+		l283:
+			position, tokenIndex = position283, tokenIndex283
 			return false
 		},
-		/* 45 timeSecond <-  */
+		/* 46 timeSecond <-  */
 		nil,
-		/* 46 timeSecfrac <- <('.' digit+)> */
+		/* 47 timeSecfrac <- <('.' digit+)> */
 		nil,
-		/* 47 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
+		/* 48 timeNumoffset <- <(('-' / '+') timeHour ':' timeMinute)> */
 		nil,
-		/* 48 timeOffset <- <('Z' / timeNumoffset)> */
+		/* 49 timeOffset <- <('Z' / timeNumoffset)> */
 		nil,
-		/* 49 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
+		/* 50 partialTime <- <(timeHour ':' timeMinute ':' timeSecond timeSecfrac?)> */
 		func() bool {
-			position284, tokenIndex284 := position, tokenIndex
+			position289, tokenIndex289 := position, tokenIndex
 			{
-				position285 := position
+				position290 := position
 				if !_rules[ruletimeHour]() {
-					goto l284
+					goto l289
 				}
 				if buffer[position] != rune(':') {
-					goto l284
+					goto l289
 				}
 				position++
 				if !_rules[ruletimeMinute]() {
-					goto l284
+					goto l289
 				}
 				if buffer[position] != rune(':') {
-					goto l284
+					goto l289
 				}
 				position++
 				{
-					position286 := position
+					position291 := position
 					if !_rules[ruledigitDual]() {
-						goto l284
+						goto l289
 					}
-					add(ruletimeSecond, position286)
+					add(ruletimeSecond, position291)
 				}
 				{
-					position287, tokenIndex287 := position, tokenIndex
+					position292, tokenIndex292 := position, tokenIndex
 					{
-						position289 := position
+						position294 := position
 						if buffer[position] != rune('.') {
-							goto l287
+							goto l292
 						}
 						position++
 						if !_rules[ruledigit]() {
-							goto l287
+							goto l292
 						}
-					l290:
+					l295:
 						{
-							position291, tokenIndex291 := position, tokenIndex
+							position296, tokenIndex296 := position, tokenIndex
 							if !_rules[ruledigit]() {
-								goto l291
+								goto l296
 							}
-							goto l290
-						l291:
-							position, tokenIndex = position291, tokenIndex291
+							goto l295
+						l296:
+							position, tokenIndex = position296, tokenIndex296
 						}
-						add(ruletimeSecfrac, position289)
+						add(ruletimeSecfrac, position294)
 					}
-					goto l288
-				l287:
-					position, tokenIndex = position287, tokenIndex287
+					goto l293
+				l292:
+					position, tokenIndex = position292, tokenIndex292
 				}
-			l288:
-				add(rulepartialTime, position285)
+			l293:
+				add(rulepartialTime, position290)
 			}
 			return true
-		l284:
-			position, tokenIndex = position284, tokenIndex284
+		l289:
+			position, tokenIndex = position289, tokenIndex289
 			return false
 		},
-		/* 50 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
+		/* 51 fullDate <- <(dateFullYear '-' dateMonth '-' dateMDay)> */
 		nil,
-		/* 51 fullTime <- <(partialTime timeOffset)> */
+		/* 52 fullTime <- <(partialTime timeOffset?)> */
 		nil,
-		/* 52 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
+		/* 53 datetime <- <((fullDate ('T' fullTime)?) / partialTime)> */
 		nil,
-		/* 53 digit <- <[0-9]> */
+		/* 54 digit <- <[0-9]> */
 		func() bool {
-			position295, tokenIndex295 := position, tokenIndex
+			position300, tokenIndex300 := position, tokenIndex
 			{
-				position296 := position
+				position301 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l295
+					goto l300
 				}
 				position++
-				add(ruledigit, position296)
+				add(ruledigit, position301)
 			}
 			return true
-		l295:
-			position, tokenIndex = position295, tokenIndex295
+		l300:
+			position, tokenIndex = position300, tokenIndex300
 			return false
 		},
-		/* 54 digitDual <- <(digit digit)> */
-		func() bool {
-			position297, tokenIndex297 := position, tokenIndex
-			{
-				position298 := position
-				if !_rules[ruledigit]() {
-					goto l297
-				}
-				if !_rules[ruledigit]() {
-					goto l297
-				}
-				add(ruledigitDual, position298)
-			}
-			return true
-		l297:
-			position, tokenIndex = position297, tokenIndex297
-			return false
-		},
-		/* 55 digitQuad <- <(digitDual digitDual)> */
-		nil,
-		/* 56 array <- <('[' Action22 wsnl arrayValues? wsnl ']')> */
-		nil,
-		/* 57 arrayValues <- <(val Action23 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action24)* wsnl arraySep? wsnl comment?)> */
-		nil,
-		/* 58 arraySep <- <','> */
+		/* 55 digitDual <- <(digit digit)> */
 		func() bool {
 			position302, tokenIndex302 := position, tokenIndex
 			{
 				position303 := position
-				if buffer[position] != rune(',') {
+				if !_rules[ruledigit]() {
 					goto l302
 				}
-				position++
-				add(rulearraySep, position303)
+				if !_rules[ruledigit]() {
+					goto l302
+				}
+				add(ruledigitDual, position303)
 			}
 			return true
 		l302:
 			position, tokenIndex = position302, tokenIndex302
 			return false
 		},
-		/* 60 Action0 <- <{ _ = buffer }> */
+		/* 56 digitQuad <- <(digitDual digitDual)> */
+		nil,
+		/* 57 array <- <('[' Action23 wsnl arrayValues? wsnl ']')> */
+		nil,
+		/* 58 arrayValues <- <(val Action24 (wsnl comment? wsnl arraySep wsnl comment? wsnl val Action25)* wsnl arraySep? wsnl comment?)> */
+		nil,
+		/* 59 arraySep <- <','> */
+		func() bool {
+			position307, tokenIndex307 := position, tokenIndex
+			{
+				position308 := position
+				if buffer[position] != rune(',') {
+					goto l307
+				}
+				position++
+				add(rulearraySep, position308)
+			}
+			return true
+		l307:
+			position, tokenIndex = position307, tokenIndex307
+			return false
+		},
+		/* 61 Action0 <- <{ _ = buffer }> */
 		nil,
 		nil,
-		/* 62 Action1 <- <{ p.SetTableString(begin, end) }> */
+		/* 63 Action1 <- <{ p.SetTableString(begin, end) }> */
 		nil,
-		/* 63 Action2 <- <{ p.AddLineCount(end - begin) }> */
+		/* 64 Action2 <- <{ p.AddLineCount(end - begin) }> */
 		nil,
-		/* 64 Action3 <- <{ p.AddLineCount(end - begin) }> */
+		/* 65 Action3 <- <{ p.AddLineCount(end - begin) }> */
 		nil,
-		/* 65 Action4 <- <{ p.AddKeyValue() }> */
+		/* 66 Action4 <- <{ p.AddKeyValue() }> */
 		nil,
-		/* 66 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
+		/* 67 Action5 <- <{ p.SetKey(p.buffer, begin, end) }> */
 		nil,
-		/* 67 Action6 <- <{ p.SetKey(p.buffer, begin-1, end+1) }> */
+		/* 68 Action6 <- <{ p.SetKey(p.buffer, begin, end) }> */
 		nil,
-		/* 68 Action7 <- <{ p.SetTime(begin, end) }> */
+		/* 69 Action7 <- <{ p.SetTime(begin, end) }> */
 		nil,
-		/* 69 Action8 <- <{ p.SetFloat64(begin, end) }> */
+		/* 70 Action8 <- <{ p.SetFloat64(begin, end) }> */
 		nil,
-		/* 70 Action9 <- <{ p.SetInt64(begin, end) }> */
+		/* 71 Action9 <- <{ p.SetInt64(begin, end) }> */
 		nil,
-		/* 71 Action10 <- <{ p.SetString(begin, end) }> */
+		/* 72 Action10 <- <{ p.SetString(begin, end) }> */
 		nil,
-		/* 72 Action11 <- <{ p.SetBool(begin, end) }> */
+		/* 73 Action11 <- <{ p.SetBool(begin, end) }> */
 		nil,
-		/* 73 Action12 <- <{ p.SetArray(begin, end) }> */
+		/* 74 Action12 <- <{ p.SetArray(begin, end) }> */
 		nil,
-		/* 74 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
+		/* 75 Action13 <- <{ p.SetTable(p.buffer, begin, end) }> */
 		nil,
-		/* 75 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
+		/* 76 Action14 <- <{ p.SetArrayTable(p.buffer, begin, end) }> */
 		nil,
-		/* 76 Action15 <- <{ p.StartInlineTable() }> */
+		/* 77 Action15 <- <{ p.StartInlineTable() }> */
 		nil,
-		/* 77 Action16 <- <{ p.EndInlineTable() }> */
+		/* 78 Action16 <- <{ p.EndInlineTable() }> */
 		nil,
-		/* 78 Action17 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
+		/* 79 Action17 <- <{ p.AddTableKey() }> */
 		nil,
-		/* 79 Action18 <- <{ p.SetMultilineString() }> */
+		/* 80 Action18 <- <{ p.SetBasicString(p.buffer, begin, end) }> */
 		nil,
-		/* 80 Action19 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
+		/* 81 Action19 <- <{ p.SetMultilineString() }> */
 		nil,
-		/* 81 Action20 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
+		/* 82 Action20 <- <{ p.AddMultilineBasicBody(p.buffer, begin, end) }> */
 		nil,
-		/* 82 Action21 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
+		/* 83 Action21 <- <{ p.SetLiteralString(p.buffer, begin, end) }> */
 		nil,
-		/* 83 Action22 <- <{ p.StartArray() }> */
+		/* 84 Action22 <- <{ p.SetMultilineLiteralString(p.buffer, begin, end) }> */
 		nil,
-		/* 84 Action23 <- <{ p.AddArrayVal() }> */
+		/* 85 Action23 <- <{ p.StartArray() }> */
 		nil,
-		/* 85 Action24 <- <{ p.AddArrayVal() }> */
+		/* 86 Action24 <- <{ p.AddArrayVal() }> */
+		nil,
+		/* 87 Action25 <- <{ p.AddArrayVal() }> */
 		nil,
 	}
 	p.rules = _rules
diff --git a/vendor/github.com/pkg/errors/LICENSE b/vendor/github.com/pkg/errors/LICENSE
new file mode 100644
index 0000000000..835ba3e755
--- /dev/null
+++ b/vendor/github.com/pkg/errors/LICENSE
@@ -0,0 +1,23 @@
+Copyright (c) 2015, Dave Cheney 
+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.
+
+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 HOLDER 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/vendor/github.com/pkg/errors/README.md b/vendor/github.com/pkg/errors/README.md
new file mode 100644
index 0000000000..6483ba2afb
--- /dev/null
+++ b/vendor/github.com/pkg/errors/README.md
@@ -0,0 +1,52 @@
+# errors [![Travis-CI](https://travis-ci.org/pkg/errors.svg)](https://travis-ci.org/pkg/errors) [![AppVeyor](https://ci.appveyor.com/api/projects/status/b98mptawhudj53ep/branch/master?svg=true)](https://ci.appveyor.com/project/davecheney/errors/branch/master) [![GoDoc](https://godoc.org/github.com/pkg/errors?status.svg)](http://godoc.org/github.com/pkg/errors) [![Report card](https://goreportcard.com/badge/github.com/pkg/errors)](https://goreportcard.com/report/github.com/pkg/errors) [![Sourcegraph](https://sourcegraph.com/github.com/pkg/errors/-/badge.svg)](https://sourcegraph.com/github.com/pkg/errors?badge)
+
+Package errors provides simple error handling primitives.
+
+`go get github.com/pkg/errors`
+
+The traditional error handling idiom in Go is roughly akin to
+```go
+if err != nil {
+        return err
+}
+```
+which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
+
+## Adding context to an error
+
+The errors.Wrap function returns a new error that adds context to the original error. For example
+```go
+_, err := ioutil.ReadAll(r)
+if err != nil {
+        return errors.Wrap(err, "read failed")
+}
+```
+## Retrieving the cause of an error
+
+Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
+```go
+type causer interface {
+        Cause() error
+}
+```
+`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
+```go
+switch err := errors.Cause(err).(type) {
+case *MyError:
+        // handle specifically
+default:
+        // unknown error
+}
+```
+
+[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
+
+## Contributing
+
+We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
+
+Before proposing a change, please discuss your change by raising an issue.
+
+## License
+
+BSD-2-Clause
diff --git a/vendor/github.com/pkg/errors/appveyor.yml b/vendor/github.com/pkg/errors/appveyor.yml
new file mode 100644
index 0000000000..a932eade02
--- /dev/null
+++ b/vendor/github.com/pkg/errors/appveyor.yml
@@ -0,0 +1,32 @@
+version: build-{build}.{branch}
+
+clone_folder: C:\gopath\src\github.com\pkg\errors
+shallow_clone: true # for startup speed
+
+environment:
+  GOPATH: C:\gopath
+
+platform:
+  - x64
+
+# http://www.appveyor.com/docs/installed-software
+install:
+  # some helpful output for debugging builds
+  - go version
+  - go env
+  # pre-installed MinGW at C:\MinGW is 32bit only
+  # but MSYS2 at C:\msys64 has mingw64
+  - set PATH=C:\msys64\mingw64\bin;%PATH%
+  - gcc --version
+  - g++ --version
+
+build_script:
+  - go install -v ./...
+
+test_script:
+  - set PATH=C:\gopath\bin;%PATH%
+  - go test -v ./...
+
+#artifacts:
+#  - path: '%GOPATH%\bin\*.exe'
+deploy: off
diff --git a/vendor/github.com/pkg/errors/errors.go b/vendor/github.com/pkg/errors/errors.go
new file mode 100644
index 0000000000..842ee80456
--- /dev/null
+++ b/vendor/github.com/pkg/errors/errors.go
@@ -0,0 +1,269 @@
+// Package errors provides simple error handling primitives.
+//
+// The traditional error handling idiom in Go is roughly akin to
+//
+//     if err != nil {
+//             return err
+//     }
+//
+// which applied recursively up the call stack results in error reports
+// without context or debugging information. The errors package allows
+// programmers to add context to the failure path in their code in a way
+// that does not destroy the original value of the error.
+//
+// Adding context to an error
+//
+// The errors.Wrap function returns a new error that adds context to the
+// original error by recording a stack trace at the point Wrap is called,
+// and the supplied message. For example
+//
+//     _, err := ioutil.ReadAll(r)
+//     if err != nil {
+//             return errors.Wrap(err, "read failed")
+//     }
+//
+// If additional control is required the errors.WithStack and errors.WithMessage
+// functions destructure errors.Wrap into its component operations of annotating
+// an error with a stack trace and an a message, respectively.
+//
+// Retrieving the cause of an error
+//
+// Using errors.Wrap constructs a stack of errors, adding context to the
+// preceding error. Depending on the nature of the error it may be necessary
+// to reverse the operation of errors.Wrap to retrieve the original error
+// for inspection. Any error value which implements this interface
+//
+//     type causer interface {
+//             Cause() error
+//     }
+//
+// can be inspected by errors.Cause. errors.Cause will recursively retrieve
+// the topmost error which does not implement causer, which is assumed to be
+// the original cause. For example:
+//
+//     switch err := errors.Cause(err).(type) {
+//     case *MyError:
+//             // handle specifically
+//     default:
+//             // unknown error
+//     }
+//
+// causer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// Formatted printing of errors
+//
+// All error values returned from this package implement fmt.Formatter and can
+// be formatted by the fmt package. The following verbs are supported
+//
+//     %s    print the error. If the error has a Cause it will be
+//           printed recursively
+//     %v    see %s
+//     %+v   extended format. Each Frame of the error's StackTrace will
+//           be printed in detail.
+//
+// Retrieving the stack trace of an error or wrapper
+//
+// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
+// invoked. This information can be retrieved with the following interface.
+//
+//     type stackTracer interface {
+//             StackTrace() errors.StackTrace
+//     }
+//
+// Where errors.StackTrace is defined as
+//
+//     type StackTrace []Frame
+//
+// The Frame type represents a call site in the stack trace. Frame supports
+// the fmt.Formatter interface that can be used for printing information about
+// the stack trace of this error. For example:
+//
+//     if err, ok := err.(stackTracer); ok {
+//             for _, f := range err.StackTrace() {
+//                     fmt.Printf("%+s:%d", f)
+//             }
+//     }
+//
+// stackTracer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// See the documentation for Frame.Format for more details.
+package errors
+
+import (
+	"fmt"
+	"io"
+)
+
+// New returns an error with the supplied message.
+// New also records the stack trace at the point it was called.
+func New(message string) error {
+	return &fundamental{
+		msg:   message,
+		stack: callers(),
+	}
+}
+
+// Errorf formats according to a format specifier and returns the string
+// as a value that satisfies error.
+// Errorf also records the stack trace at the point it was called.
+func Errorf(format string, args ...interface{}) error {
+	return &fundamental{
+		msg:   fmt.Sprintf(format, args...),
+		stack: callers(),
+	}
+}
+
+// fundamental is an error that has a message and a stack, but no caller.
+type fundamental struct {
+	msg string
+	*stack
+}
+
+func (f *fundamental) Error() string { return f.msg }
+
+func (f *fundamental) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			io.WriteString(s, f.msg)
+			f.stack.Format(s, verb)
+			return
+		}
+		fallthrough
+	case 's':
+		io.WriteString(s, f.msg)
+	case 'q':
+		fmt.Fprintf(s, "%q", f.msg)
+	}
+}
+
+// WithStack annotates err with a stack trace at the point WithStack was called.
+// If err is nil, WithStack returns nil.
+func WithStack(err error) error {
+	if err == nil {
+		return nil
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+type withStack struct {
+	error
+	*stack
+}
+
+func (w *withStack) Cause() error { return w.error }
+
+func (w *withStack) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			fmt.Fprintf(s, "%+v", w.Cause())
+			w.stack.Format(s, verb)
+			return
+		}
+		fallthrough
+	case 's':
+		io.WriteString(s, w.Error())
+	case 'q':
+		fmt.Fprintf(s, "%q", w.Error())
+	}
+}
+
+// Wrap returns an error annotating err with a stack trace
+// at the point Wrap is called, and the supplied message.
+// If err is nil, Wrap returns nil.
+func Wrap(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+	err = &withMessage{
+		cause: err,
+		msg:   message,
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+// Wrapf returns an error annotating err with a stack trace
+// at the point Wrapf is call, and the format specifier.
+// If err is nil, Wrapf returns nil.
+func Wrapf(err error, format string, args ...interface{}) error {
+	if err == nil {
+		return nil
+	}
+	err = &withMessage{
+		cause: err,
+		msg:   fmt.Sprintf(format, args...),
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+// WithMessage annotates err with a new message.
+// If err is nil, WithMessage returns nil.
+func WithMessage(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+	return &withMessage{
+		cause: err,
+		msg:   message,
+	}
+}
+
+type withMessage struct {
+	cause error
+	msg   string
+}
+
+func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
+func (w *withMessage) Cause() error  { return w.cause }
+
+func (w *withMessage) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			fmt.Fprintf(s, "%+v\n", w.Cause())
+			io.WriteString(s, w.msg)
+			return
+		}
+		fallthrough
+	case 's', 'q':
+		io.WriteString(s, w.Error())
+	}
+}
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+	type causer interface {
+		Cause() error
+	}
+
+	for err != nil {
+		cause, ok := err.(causer)
+		if !ok {
+			break
+		}
+		err = cause.Cause()
+	}
+	return err
+}
diff --git a/vendor/github.com/pkg/errors/stack.go b/vendor/github.com/pkg/errors/stack.go
new file mode 100644
index 0000000000..b485761a7c
--- /dev/null
+++ b/vendor/github.com/pkg/errors/stack.go
@@ -0,0 +1,187 @@
+package errors
+
+import (
+	"fmt"
+	"io"
+	"path"
+	"runtime"
+	"strings"
+)
+
+// Frame represents a program counter inside a stack frame.
+type Frame uintptr
+
+// pc returns the program counter for this frame;
+// multiple frames may have the same PC value.
+func (f Frame) pc() uintptr { return uintptr(f) - 1 }
+
+// file returns the full path to the file that contains the
+// function for this Frame's pc.
+func (f Frame) file() string {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return "unknown"
+	}
+	file, _ := fn.FileLine(f.pc())
+	return file
+}
+
+// line returns the line number of source code of the
+// function for this Frame's pc.
+func (f Frame) line() int {
+	fn := runtime.FuncForPC(f.pc())
+	if fn == nil {
+		return 0
+	}
+	_, line := fn.FileLine(f.pc())
+	return line
+}
+
+// Format formats the frame according to the fmt.Formatter interface.
+//
+//    %s    source file
+//    %d    source line
+//    %n    function name
+//    %v    equivalent to %s:%d
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+//    %+s   function name and path of source file relative to the compile time
+//          GOPATH separated by \n\t (\n\t)
+//    %+v   equivalent to %+s:%d
+func (f Frame) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 's':
+		switch {
+		case s.Flag('+'):
+			pc := f.pc()
+			fn := runtime.FuncForPC(pc)
+			if fn == nil {
+				io.WriteString(s, "unknown")
+			} else {
+				file, _ := fn.FileLine(pc)
+				fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
+			}
+		default:
+			io.WriteString(s, path.Base(f.file()))
+		}
+	case 'd':
+		fmt.Fprintf(s, "%d", f.line())
+	case 'n':
+		name := runtime.FuncForPC(f.pc()).Name()
+		io.WriteString(s, funcname(name))
+	case 'v':
+		f.Format(s, 's')
+		io.WriteString(s, ":")
+		f.Format(s, 'd')
+	}
+}
+
+// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
+type StackTrace []Frame
+
+// Format formats the stack of Frames according to the fmt.Formatter interface.
+//
+//    %s	lists source files for each Frame in the stack
+//    %v	lists the source file and line number for each Frame in the stack
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+//    %+v   Prints filename, function, and line number for each Frame in the stack.
+func (st StackTrace) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		switch {
+		case s.Flag('+'):
+			for _, f := range st {
+				fmt.Fprintf(s, "\n%+v", f)
+			}
+		case s.Flag('#'):
+			fmt.Fprintf(s, "%#v", []Frame(st))
+		default:
+			fmt.Fprintf(s, "%v", []Frame(st))
+		}
+	case 's':
+		fmt.Fprintf(s, "%s", []Frame(st))
+	}
+}
+
+// stack represents a stack of program counters.
+type stack []uintptr
+
+func (s *stack) Format(st fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		switch {
+		case st.Flag('+'):
+			for _, pc := range *s {
+				f := Frame(pc)
+				fmt.Fprintf(st, "\n%+v", f)
+			}
+		}
+	}
+}
+
+func (s *stack) StackTrace() StackTrace {
+	f := make([]Frame, len(*s))
+	for i := 0; i < len(f); i++ {
+		f[i] = Frame((*s)[i])
+	}
+	return f
+}
+
+func callers() *stack {
+	const depth = 32
+	var pcs [depth]uintptr
+	n := runtime.Callers(3, pcs[:])
+	var st stack = pcs[0:n]
+	return &st
+}
+
+// funcname removes the path prefix component of a function's name reported by func.Name().
+func funcname(name string) string {
+	i := strings.LastIndex(name, "/")
+	name = name[i+1:]
+	i = strings.Index(name, ".")
+	return name[i+1:]
+}
+
+func trimGOPATH(name, file string) string {
+	// Here we want to get the source file path relative to the compile time
+	// GOPATH. As of Go 1.6.x there is no direct way to know the compiled
+	// GOPATH at runtime, but we can infer the number of path segments in the
+	// GOPATH. We note that fn.Name() returns the function name qualified by
+	// the import path, which does not include the GOPATH. Thus we can trim
+	// segments from the beginning of the file path until the number of path
+	// separators remaining is one more than the number of path separators in
+	// the function name. For example, given:
+	//
+	//    GOPATH     /home/user
+	//    file       /home/user/src/pkg/sub/file.go
+	//    fn.Name()  pkg/sub.Type.Method
+	//
+	// We want to produce:
+	//
+	//    pkg/sub/file.go
+	//
+	// From this we can easily see that fn.Name() has one less path separator
+	// than our desired output. We count separators from the end of the file
+	// path until it finds two more than in the function name and then move
+	// one character forward to preserve the initial path segment without a
+	// leading separator.
+	const sep = "/"
+	goal := strings.Count(name, sep) + 2
+	i := len(file)
+	for n := 0; n < goal; n++ {
+		i = strings.LastIndex(file[:i], sep)
+		if i == -1 {
+			// not enough separators found, set i so that the slice expression
+			// below leaves file unmodified
+			i = -len(sep)
+			break
+		}
+	}
+	// get back to 0 or trim the leading separator
+	file = file[i+len(sep):]
+	return file
+}
diff --git a/vendor/github.com/rcrowley/go-metrics/json.go b/vendor/github.com/rcrowley/go-metrics/json.go
deleted file mode 100644
index 2fdcbcfbf1..0000000000
--- a/vendor/github.com/rcrowley/go-metrics/json.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package metrics
-
-import (
-	"encoding/json"
-	"io"
-	"time"
-)
-
-// MarshalJSON returns a byte slice containing a JSON representation of all
-// the metrics in the Registry.
-func (r *StandardRegistry) MarshalJSON() ([]byte, error) {
-	data := make(map[string]map[string]interface{})
-	r.Each(func(name string, i interface{}) {
-		values := make(map[string]interface{})
-		switch metric := i.(type) {
-		case Counter:
-			values["count"] = metric.Count()
-		case Gauge:
-			values["value"] = metric.Value()
-		case GaugeFloat64:
-			values["value"] = metric.Value()
-		case Healthcheck:
-			values["error"] = nil
-			metric.Check()
-			if err := metric.Error(); nil != err {
-				values["error"] = metric.Error().Error()
-			}
-		case Histogram:
-			h := metric.Snapshot()
-			ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			values["count"] = h.Count()
-			values["min"] = h.Min()
-			values["max"] = h.Max()
-			values["mean"] = h.Mean()
-			values["stddev"] = h.StdDev()
-			values["median"] = ps[0]
-			values["75%"] = ps[1]
-			values["95%"] = ps[2]
-			values["99%"] = ps[3]
-			values["99.9%"] = ps[4]
-		case Meter:
-			m := metric.Snapshot()
-			values["count"] = m.Count()
-			values["1m.rate"] = m.Rate1()
-			values["5m.rate"] = m.Rate5()
-			values["15m.rate"] = m.Rate15()
-			values["mean.rate"] = m.RateMean()
-		case Timer:
-			t := metric.Snapshot()
-			ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
-			values["count"] = t.Count()
-			values["min"] = t.Min()
-			values["max"] = t.Max()
-			values["mean"] = t.Mean()
-			values["stddev"] = t.StdDev()
-			values["median"] = ps[0]
-			values["75%"] = ps[1]
-			values["95%"] = ps[2]
-			values["99%"] = ps[3]
-			values["99.9%"] = ps[4]
-			values["1m.rate"] = t.Rate1()
-			values["5m.rate"] = t.Rate5()
-			values["15m.rate"] = t.Rate15()
-			values["mean.rate"] = t.RateMean()
-		}
-		data[name] = values
-	})
-	return json.Marshal(data)
-}
-
-// WriteJSON writes metrics from the given registry  periodically to the
-// specified io.Writer as JSON.
-func WriteJSON(r Registry, d time.Duration, w io.Writer) {
-	for _ = range time.Tick(d) {
-		WriteJSONOnce(r, w)
-	}
-}
-
-// WriteJSONOnce writes metrics from the given registry to the specified
-// io.Writer as JSON.
-func WriteJSONOnce(r Registry, w io.Writer) {
-	json.NewEncoder(w).Encode(r)
-}
-
-func (p *PrefixedRegistry) MarshalJSON() ([]byte, error) {
-	return json.Marshal(p.underlying)
-}
diff --git a/vendor/github.com/rcrowley/go-metrics/metrics.go b/vendor/github.com/rcrowley/go-metrics/metrics.go
deleted file mode 100644
index b97a49ed12..0000000000
--- a/vendor/github.com/rcrowley/go-metrics/metrics.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// Go port of Coda Hale's Metrics library
-//
-// 
-//
-// Coda Hale's original work: 
-package metrics
-
-// UseNilMetrics is checked by the constructor functions for all of the
-// standard metrics.  If it is true, the metric returned is a stub.
-//
-// This global kill-switch helps quantify the observer effect and makes
-// for less cluttered pprof profiles.
-var UseNilMetrics bool = false
diff --git a/vendor/github.com/rjeczalik/notify/README.md b/vendor/github.com/rjeczalik/notify/README.md
index a728d1dd04..02a5f32908 100644
--- a/vendor/github.com/rjeczalik/notify/README.md
+++ b/vendor/github.com/rjeczalik/notify/README.md
@@ -18,4 +18,4 @@ Filesystem event notification library on steroids. (under active development)
 - [github.com/rjeczalik/cmd/notify](https://godoc.org/github.com/rjeczalik/cmd/notify)
 - [github.com/cortesi/devd](https://github.com/cortesi/devd)
 - [github.com/cortesi/modd](https://github.com/cortesi/modd)
-
+- [github.com/syncthing/syncthing-inotify](https://github.com/syncthing/syncthing-inotify)
diff --git a/vendor/github.com/rjeczalik/notify/appveyor.yml b/vendor/github.com/rjeczalik/notify/appveyor.yml
index 8e762d05cb..a495bd7c73 100644
--- a/vendor/github.com/rjeczalik/notify/appveyor.yml
+++ b/vendor/github.com/rjeczalik/notify/appveyor.yml
@@ -16,7 +16,7 @@ install:
 build_script:
  - go tool vet -all .
  - go build ./...
- - go test -v -race ./...
+ - go test -v -timeout 60s -race ./...
 
 test: off
 
diff --git a/vendor/github.com/rjeczalik/notify/debug.go b/vendor/github.com/rjeczalik/notify/debug.go
index bd9bc468df..2a3eb33700 100644
--- a/vendor/github.com/rjeczalik/notify/debug.go
+++ b/vendor/github.com/rjeczalik/notify/debug.go
@@ -2,10 +2,52 @@
 // Use of this source code is governed by the MIT license that can be
 // found in the LICENSE file.
 
-// +build !debug
-
 package notify
 
-func dbgprint(...interface{}) {}
+import (
+	"log"
+	"os"
+	"runtime"
+	"strings"
+)
 
-func dbgprintf(string, ...interface{}) {}
+var dbgprint func(...interface{})
+
+var dbgprintf func(string, ...interface{})
+
+var dbgcallstack func(max int) []string
+
+func init() {
+	if _, ok := os.LookupEnv("NOTIFY_DEBUG"); ok || debugTag {
+		log.SetOutput(os.Stdout)
+		log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
+		dbgprint = func(v ...interface{}) {
+			v = append([]interface{}{"[D] "}, v...)
+			log.Println(v...)
+		}
+		dbgprintf = func(format string, v ...interface{}) {
+			format = "[D] " + format
+			log.Printf(format, v...)
+		}
+		dbgcallstack = func(max int) []string {
+			pc, stack := make([]uintptr, max), make([]string, 0, max)
+			runtime.Callers(2, pc)
+			for _, pc := range pc {
+				if f := runtime.FuncForPC(pc); f != nil {
+					fname := f.Name()
+					idx := strings.LastIndex(fname, string(os.PathSeparator))
+					if idx != -1 {
+						stack = append(stack, fname[idx+1:])
+					} else {
+						stack = append(stack, fname)
+					}
+				}
+			}
+			return stack
+		}
+		return
+	}
+	dbgprint = func(v ...interface{}) {}
+	dbgprintf = func(format string, v ...interface{}) {}
+	dbgcallstack = func(max int) []string { return nil }
+}
diff --git a/vendor/github.com/rjeczalik/notify/debug_debug.go b/vendor/github.com/rjeczalik/notify/debug_debug.go
index f0622917f5..6fca891ab3 100644
--- a/vendor/github.com/rjeczalik/notify/debug_debug.go
+++ b/vendor/github.com/rjeczalik/notify/debug_debug.go
@@ -6,38 +6,4 @@
 
 package notify
 
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-)
-
-func dbgprint(v ...interface{}) {
-	fmt.Printf("[D] ")
-	fmt.Print(v...)
-	fmt.Printf("\n\n")
-}
-
-func dbgprintf(format string, v ...interface{}) {
-	fmt.Printf("[D] ")
-	fmt.Printf(format, v...)
-	fmt.Printf("\n\n")
-}
-
-func dbgcallstack(max int) []string {
-	pc, stack := make([]uintptr, max), make([]string, 0, max)
-	runtime.Callers(2, pc)
-	for _, pc := range pc {
-		if f := runtime.FuncForPC(pc); f != nil {
-			fname := f.Name()
-			idx := strings.LastIndex(fname, string(os.PathSeparator))
-			if idx != -1 {
-				stack = append(stack, fname[idx+1:])
-			} else {
-				stack = append(stack, fname)
-			}
-		}
-	}
-	return stack
-}
+var debugTag bool = true
diff --git a/vendor/github.com/rjeczalik/notify/debug_nodebug.go b/vendor/github.com/rjeczalik/notify/debug_nodebug.go
new file mode 100644
index 0000000000..be391a2769
--- /dev/null
+++ b/vendor/github.com/rjeczalik/notify/debug_nodebug.go
@@ -0,0 +1,9 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !debug
+
+package notify
+
+var debugTag bool = false
diff --git a/vendor/github.com/rjeczalik/notify/doc.go b/vendor/github.com/rjeczalik/notify/doc.go
index 8a99ddda62..60543c0838 100644
--- a/vendor/github.com/rjeczalik/notify/doc.go
+++ b/vendor/github.com/rjeczalik/notify/doc.go
@@ -12,11 +12,14 @@
 // source file.
 //
 // On top of filesystem watchers notify maintains a watchpoint tree, which provides
-// strategy for creating and closing filesystem watches and dispatching filesystem
+// a strategy for creating and closing filesystem watches and dispatching filesystem
 // events to user channels.
 //
 // An event set is just an event list joint using bitwise OR operator
 // into a single event value.
+// Both the platform-independent (see Constants) and specific events can be used.
+// Refer to the event_*.go source files for information about the available
+// events.
 //
 // A filesystem watch or just a watch is platform-specific entity which represents
 // a single path registered for notifications for specific event set. Setting a watch
@@ -35,6 +38,6 @@
 // A watchpoint is a list of user channel and event set pairs for particular
 // path (watchpoint tree's node). A single watchpoint can contain multiple
 // different user channels registered to listen for one or more events. A single
-// user channel can be registered in one or more watchpoints, recurisve and
+// user channel can be registered in one or more watchpoints, recursive and
 // non-recursive ones as well.
 package notify
diff --git a/vendor/github.com/rjeczalik/notify/event.go b/vendor/github.com/rjeczalik/notify/event.go
index e045edcecc..c128841972 100644
--- a/vendor/github.com/rjeczalik/notify/event.go
+++ b/vendor/github.com/rjeczalik/notify/event.go
@@ -73,7 +73,7 @@ func (e Event) String() string {
 //
 //    https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags
 //
-// Under Linux (inotify) Sys() always returns a non-nil *syscall.InotifyEvent
+// Under Linux (inotify) Sys() always returns a non-nil *unix.InotifyEvent
 // value, defined as:
 //
 //   type InotifyEvent struct {
diff --git a/vendor/github.com/rjeczalik/notify/event_inotify.go b/vendor/github.com/rjeczalik/notify/event_inotify.go
index 82954a9b38..1f32bb73e0 100644
--- a/vendor/github.com/rjeczalik/notify/event_inotify.go
+++ b/vendor/github.com/rjeczalik/notify/event_inotify.go
@@ -6,7 +6,7 @@
 
 package notify
 
-import "syscall"
+import "golang.org/x/sys/unix"
 
 // Platform independent event values.
 const (
@@ -25,18 +25,18 @@ const (
 // Inotify specific masks are legal, implemented events that are guaranteed to
 // work with notify package on linux-based systems.
 const (
-	InAccess       = Event(syscall.IN_ACCESS)        // File was accessed
-	InModify       = Event(syscall.IN_MODIFY)        // File was modified
-	InAttrib       = Event(syscall.IN_ATTRIB)        // Metadata changed
-	InCloseWrite   = Event(syscall.IN_CLOSE_WRITE)   // Writtable file was closed
-	InCloseNowrite = Event(syscall.IN_CLOSE_NOWRITE) // Unwrittable file closed
-	InOpen         = Event(syscall.IN_OPEN)          // File was opened
-	InMovedFrom    = Event(syscall.IN_MOVED_FROM)    // File was moved from X
-	InMovedTo      = Event(syscall.IN_MOVED_TO)      // File was moved to Y
-	InCreate       = Event(syscall.IN_CREATE)        // Subfile was created
-	InDelete       = Event(syscall.IN_DELETE)        // Subfile was deleted
-	InDeleteSelf   = Event(syscall.IN_DELETE_SELF)   // Self was deleted
-	InMoveSelf     = Event(syscall.IN_MOVE_SELF)     // Self was moved
+	InAccess       = Event(unix.IN_ACCESS)        // File was accessed
+	InModify       = Event(unix.IN_MODIFY)        // File was modified
+	InAttrib       = Event(unix.IN_ATTRIB)        // Metadata changed
+	InCloseWrite   = Event(unix.IN_CLOSE_WRITE)   // Writtable file was closed
+	InCloseNowrite = Event(unix.IN_CLOSE_NOWRITE) // Unwrittable file closed
+	InOpen         = Event(unix.IN_OPEN)          // File was opened
+	InMovedFrom    = Event(unix.IN_MOVED_FROM)    // File was moved from X
+	InMovedTo      = Event(unix.IN_MOVED_TO)      // File was moved to Y
+	InCreate       = Event(unix.IN_CREATE)        // Subfile was created
+	InDelete       = Event(unix.IN_DELETE)        // Subfile was deleted
+	InDeleteSelf   = Event(unix.IN_DELETE_SELF)   // Self was deleted
+	InMoveSelf     = Event(unix.IN_MOVE_SELF)     // Self was moved
 )
 
 var osestr = map[Event]string{
@@ -56,15 +56,15 @@ var osestr = map[Event]string{
 
 // Inotify behavior events are not **currently** supported by notify package.
 const (
-	inDontFollow = Event(syscall.IN_DONT_FOLLOW)
-	inExclUnlink = Event(syscall.IN_EXCL_UNLINK)
-	inMaskAdd    = Event(syscall.IN_MASK_ADD)
-	inOneshot    = Event(syscall.IN_ONESHOT)
-	inOnlydir    = Event(syscall.IN_ONLYDIR)
+	inDontFollow = Event(unix.IN_DONT_FOLLOW)
+	inExclUnlink = Event(unix.IN_EXCL_UNLINK)
+	inMaskAdd    = Event(unix.IN_MASK_ADD)
+	inOneshot    = Event(unix.IN_ONESHOT)
+	inOnlydir    = Event(unix.IN_ONLYDIR)
 )
 
 type event struct {
-	sys   syscall.InotifyEvent
+	sys   unix.InotifyEvent
 	path  string
 	event Event
 }
@@ -72,4 +72,4 @@ type event struct {
 func (e *event) Event() Event         { return e.event }
 func (e *event) Path() string         { return e.path }
 func (e *event) Sys() interface{}     { return &e.sys }
-func (e *event) isDir() (bool, error) { return e.sys.Mask&syscall.IN_ISDIR != 0, nil }
+func (e *event) isDir() (bool, error) { return e.sys.Mask&unix.IN_ISDIR != 0, nil }
diff --git a/vendor/github.com/rjeczalik/notify/event_readdcw.go b/vendor/github.com/rjeczalik/notify/event_readdcw.go
index 11ead9e297..f7b82de0c4 100644
--- a/vendor/github.com/rjeczalik/notify/event_readdcw.go
+++ b/vendor/github.com/rjeczalik/notify/event_readdcw.go
@@ -27,7 +27,11 @@ const (
 	dirmarker
 )
 
-// ReadDirectoryChangesW filters.
+// ReadDirectoryChangesW filters
+// On Windows the following events can be passed to Watch. A different set of
+// events (see actions below) are received on the channel passed to Watch.
+// For more information refer to
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx
 const (
 	FileNotifyChangeFileName   = Event(syscall.FILE_NOTIFY_CHANGE_FILE_NAME)
 	FileNotifyChangeDirName    = Event(syscall.FILE_NOTIFY_CHANGE_DIR_NAME)
@@ -48,7 +52,13 @@ const (
 // this flag should be declared in: http://golang.org/src/pkg/syscall/ztypes_windows.go
 const syscallFileNotifyChangeSecurity = 0x00000100
 
-// ReadDirectoryChangesW actions.
+// ReadDirectoryChangesW actions
+// The following events are returned on the channel passed to Watch, but cannot
+// be passed to Watch itself (see filters above). You can find a table showing
+// the relation between actions and filteres at
+// https://github.com/rjeczalik/notify/issues/10#issuecomment-66179535
+// The msdn documentation on actions is part of
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364391(v=vs.85).aspx
 const (
 	FileActionAdded          = Event(syscall.FILE_ACTION_ADDED) << 12
 	FileActionRemoved        = Event(syscall.FILE_ACTION_REMOVED) << 12
diff --git a/vendor/github.com/rjeczalik/notify/node.go b/vendor/github.com/rjeczalik/notify/node.go
index 29c1bb20af..aced8b9c44 100644
--- a/vendor/github.com/rjeczalik/notify/node.go
+++ b/vendor/github.com/rjeczalik/notify/node.go
@@ -6,7 +6,6 @@ package notify
 
 import (
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -71,7 +70,11 @@ Traverse:
 		case errSkip:
 			continue Traverse
 		default:
-			return fmt.Errorf("error while traversing %q: %v", nd.Name, err)
+			return &os.PathError{
+				Op:   "error while traversing",
+				Path: nd.Name,
+				Err:  err,
+			}
 		}
 		// TODO(rjeczalik): tolerate open failures - add failed names to
 		// AddDirError and notify users which names are not added to the tree.
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fen.go b/vendor/github.com/rjeczalik/notify/watcher_fen.go
index dd069f2a26..dfe77f2f1d 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fen.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fen.go
@@ -33,14 +33,7 @@ type fen struct {
 
 // watched is a data structure representing watched file/directory.
 type watched struct {
-	// p is a path to watched file/directory
-	p string
-	// fi provides information about watched file/dir
-	fi os.FileInfo
-	// eDir represents events watched directly
-	eDir Event
-	// eNonDir represents events watched indirectly
-	eNonDir Event
+	trgWatched
 }
 
 // Stop implements trigger.
@@ -55,7 +48,7 @@ func (f *fen) Close() (err error) {
 
 // NewWatched implements trigger.
 func (*fen) NewWatched(p string, fi os.FileInfo) (*watched, error) {
-	return &watched{p: p, fi: fi}, nil
+	return &watched{trgWatched{p: p, fi: fi}}, nil
 }
 
 // Record implements trigger.
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
index 9062c17c7f..7d9b97b65d 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
@@ -12,8 +12,6 @@ import (
 	"sync/atomic"
 )
 
-// TODO(rjeczalik): get rid of calls to canonical, it's tree responsibility
-
 const (
 	failure = uint32(FSEventsMustScanSubDirs | FSEventsUserDropped | FSEventsKernelDropped)
 	filter  = uint32(FSEventsCreated | FSEventsRemoved | FSEventsRenamed |
@@ -189,9 +187,6 @@ func newWatcher(c chan<- EventInfo) watcher {
 }
 
 func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) {
-	if path, err = canonical(path); err != nil {
-		return err
-	}
 	if _, ok := fse.watches[path]; ok {
 		return errAlreadyWatched
 	}
@@ -211,9 +206,6 @@ func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) {
 }
 
 func (fse *fsevents) unwatch(path string) (err error) {
-	if path, err = canonical(path); err != nil {
-		return
-	}
 	w, ok := fse.watches[path]
 	if !ok {
 		return errNotWatched
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
index 5be64632e8..a2b332a2e0 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
@@ -26,9 +26,9 @@ import "C"
 import (
 	"errors"
 	"os"
+	"runtime"
 	"sync"
 	"sync/atomic"
-	"time"
 	"unsafe"
 )
 
@@ -63,6 +63,10 @@ var (
 func init() {
 	wg.Add(1)
 	go func() {
+		// There is exactly one run loop per thread. Lock this goroutine to its
+		// thread to ensure that it's not rescheduled on a different thread while
+		// setting up the run loop.
+		runtime.LockOSThread()
 		runloop = C.CFRunLoopGetCurrent()
 		C.CFRunLoopAddSource(runloop, source, C.kCFRunLoopDefaultMode)
 		C.CFRunLoopRun()
@@ -73,7 +77,6 @@ func init() {
 
 //export gosource
 func gosource(unsafe.Pointer) {
-	time.Sleep(time.Second)
 	wg.Done()
 }
 
diff --git a/vendor/github.com/rjeczalik/notify/watcher_inotify.go b/vendor/github.com/rjeczalik/notify/watcher_inotify.go
index 3ceaa8f3ab..d082baca0f 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_inotify.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_inotify.go
@@ -13,14 +13,15 @@ import (
 	"runtime"
 	"sync"
 	"sync/atomic"
-	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 // eventBufferSize defines the size of the buffer given to read(2) function. One
 // should not depend on this value, since it was arbitrary chosen and may be
 // changed in the future.
-const eventBufferSize = 64 * (syscall.SizeofInotifyEvent + syscall.PathMax + 1)
+const eventBufferSize = 64 * (unix.SizeofInotifyEvent + unix.PathMax + 1)
 
 // consumersCount defines the number of consumers in producer-consumer based
 // implementation. Each consumer is run in a separate goroutine and has read
@@ -43,7 +44,7 @@ type inotify struct {
 	fd           int32                 // inotify file descriptor
 	pipefd       []int                 // pipe's read and write descriptors
 	epfd         int                   // epoll descriptor
-	epes         []syscall.EpollEvent  // epoll events
+	epes         []unix.EpollEvent     // epoll events
 	buffer       [eventBufferSize]byte // inotify event buffer
 	wg           sync.WaitGroup        // wait group used to close main loop
 	c            chan<- EventInfo      // event dispatcher channel
@@ -56,13 +57,13 @@ func newWatcher(c chan<- EventInfo) watcher {
 		fd:     invalidDescriptor,
 		pipefd: []int{invalidDescriptor, invalidDescriptor},
 		epfd:   invalidDescriptor,
-		epes:   make([]syscall.EpollEvent, 0),
+		epes:   make([]unix.EpollEvent, 0),
 		c:      c,
 	}
 	runtime.SetFinalizer(i, func(i *inotify) {
 		i.epollclose()
 		if i.fd != invalidDescriptor {
-			syscall.Close(int(i.fd))
+			unix.Close(int(i.fd))
 		}
 	})
 	return i
@@ -82,13 +83,13 @@ func (i *inotify) Rewatch(path string, _, newevent Event) error {
 // one. If called for the first time, this function initializes inotify filesystem
 // monitor and starts producer-consumers goroutines.
 func (i *inotify) watch(path string, e Event) (err error) {
-	if e&^(All|Event(syscall.IN_ALL_EVENTS)) != 0 {
+	if e&^(All|Event(unix.IN_ALL_EVENTS)) != 0 {
 		return errors.New("notify: unknown event")
 	}
 	if err = i.lazyinit(); err != nil {
 		return
 	}
-	iwd, err := syscall.InotifyAddWatch(int(i.fd), path, encode(e))
+	iwd, err := unix.InotifyAddWatch(int(i.fd), path, encode(e))
 	if err != nil {
 		return
 	}
@@ -119,13 +120,13 @@ func (i *inotify) lazyinit() error {
 		i.Lock()
 		defer i.Unlock()
 		if atomic.LoadInt32(&i.fd) == invalidDescriptor {
-			fd, err := syscall.InotifyInit()
+			fd, err := unix.InotifyInit1(unix.IN_CLOEXEC)
 			if err != nil {
 				return err
 			}
 			i.fd = int32(fd)
 			if err = i.epollinit(); err != nil {
-				_, _ = i.epollclose(), syscall.Close(int(fd)) // Ignore errors.
+				_, _ = i.epollclose(), unix.Close(int(fd)) // Ignore errors.
 				i.fd = invalidDescriptor
 				return err
 			}
@@ -145,33 +146,33 @@ func (i *inotify) lazyinit() error {
 // with inotify event queue and the read end of the pipe are added to epoll set.
 // Note that `fd` member must be set before this function is called.
 func (i *inotify) epollinit() (err error) {
-	if i.epfd, err = syscall.EpollCreate1(0); err != nil {
+	if i.epfd, err = unix.EpollCreate1(0); err != nil {
 		return
 	}
-	if err = syscall.Pipe(i.pipefd); err != nil {
+	if err = unix.Pipe(i.pipefd); err != nil {
 		return
 	}
-	i.epes = []syscall.EpollEvent{
-		{Events: syscall.EPOLLIN, Fd: i.fd},
-		{Events: syscall.EPOLLIN, Fd: int32(i.pipefd[0])},
+	i.epes = []unix.EpollEvent{
+		{Events: unix.EPOLLIN, Fd: i.fd},
+		{Events: unix.EPOLLIN, Fd: int32(i.pipefd[0])},
 	}
-	if err = syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil {
+	if err = unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil {
 		return
 	}
-	return syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1])
+	return unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1])
 }
 
 // epollclose closes the file descriptor created by the call to epoll_create(2)
 // and two file descriptors opened by pipe(2) function.
 func (i *inotify) epollclose() (err error) {
 	if i.epfd != invalidDescriptor {
-		if err = syscall.Close(i.epfd); err == nil {
+		if err = unix.Close(i.epfd); err == nil {
 			i.epfd = invalidDescriptor
 		}
 	}
 	for n, fd := range i.pipefd {
 		if fd != invalidDescriptor {
-			switch e := syscall.Close(fd); {
+			switch e := unix.Close(fd); {
 			case e != nil && err == nil:
 				err = e
 			case e == nil:
@@ -187,10 +188,10 @@ func (i *inotify) epollclose() (err error) {
 // one of the event's consumers. If pipe fd became ready, loop function closes
 // all file descriptors opened by lazyinit method and returns afterwards.
 func (i *inotify) loop(esch chan<- []*event) {
-	epes := make([]syscall.EpollEvent, 1)
+	epes := make([]unix.EpollEvent, 1)
 	fd := atomic.LoadInt32(&i.fd)
 	for {
-		switch _, err := syscall.EpollWait(i.epfd, epes, -1); err {
+		switch _, err := unix.EpollWait(i.epfd, epes, -1); err {
 		case nil:
 			switch epes[0].Fd {
 			case fd:
@@ -199,17 +200,17 @@ func (i *inotify) loop(esch chan<- []*event) {
 			case int32(i.pipefd[0]):
 				i.Lock()
 				defer i.Unlock()
-				if err = syscall.Close(int(fd)); err != nil && err != syscall.EINTR {
+				if err = unix.Close(int(fd)); err != nil && err != unix.EINTR {
 					panic("notify: close(2) error " + err.Error())
 				}
 				atomic.StoreInt32(&i.fd, invalidDescriptor)
-				if err = i.epollclose(); err != nil && err != syscall.EINTR {
+				if err = i.epollclose(); err != nil && err != unix.EINTR {
 					panic("notify: epollclose error " + err.Error())
 				}
 				close(esch)
 				return
 			}
-		case syscall.EINTR:
+		case unix.EINTR:
 			continue
 		default: // We should never reach this line.
 			panic("notify: epoll_wait(2) error " + err.Error())
@@ -220,22 +221,22 @@ func (i *inotify) loop(esch chan<- []*event) {
 // read reads events from an inotify file descriptor. It does not handle errors
 // returned from read(2) function since they are not critical to watcher logic.
 func (i *inotify) read() (es []*event) {
-	n, err := syscall.Read(int(i.fd), i.buffer[:])
-	if err != nil || n < syscall.SizeofInotifyEvent {
+	n, err := unix.Read(int(i.fd), i.buffer[:])
+	if err != nil || n < unix.SizeofInotifyEvent {
 		return
 	}
-	var sys *syscall.InotifyEvent
-	nmin := n - syscall.SizeofInotifyEvent
+	var sys *unix.InotifyEvent
+	nmin := n - unix.SizeofInotifyEvent
 	for pos, path := 0, ""; pos <= nmin; {
-		sys = (*syscall.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
-		pos += syscall.SizeofInotifyEvent
+		sys = (*unix.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
+		pos += unix.SizeofInotifyEvent
 		if path = ""; sys.Len > 0 {
 			endpos := pos + int(sys.Len)
 			path = string(bytes.TrimRight(i.buffer[pos:endpos], "\x00"))
 			pos = endpos
 		}
 		es = append(es, &event{
-			sys: syscall.InotifyEvent{
+			sys: unix.InotifyEvent{
 				Wd:     sys.Wd,
 				Mask:   sys.Mask,
 				Cookie: sys.Cookie,
@@ -268,7 +269,7 @@ func (i *inotify) transform(es []*event) []*event {
 	var multi []*event
 	i.RLock()
 	for idx, e := range es {
-		if e.sys.Mask&(syscall.IN_IGNORED|syscall.IN_Q_OVERFLOW) != 0 {
+		if e.sys.Mask&(unix.IN_IGNORED|unix.IN_Q_OVERFLOW) != 0 {
 			es[idx] = nil
 			continue
 		}
@@ -317,7 +318,7 @@ func encode(e Event) uint32 {
 // can be nil when the event should not be passed on.
 func decode(mask Event, e *event) (syse *event) {
 	if sysmask := uint32(mask) & e.sys.Mask; sysmask != 0 {
-		syse = &event{sys: syscall.InotifyEvent{
+		syse = &event{sys: unix.InotifyEvent{
 			Wd:     e.sys.Wd,
 			Mask:   e.sys.Mask,
 			Cookie: e.sys.Cookie,
@@ -357,7 +358,7 @@ func (i *inotify) Unwatch(path string) (err error) {
 		return errors.New("notify: path " + path + " is already watched")
 	}
 	fd := atomic.LoadInt32(&i.fd)
-	if _, err = syscall.InotifyRmWatch(int(fd), uint32(iwd)); err != nil {
+	if err = removeInotifyWatch(fd, iwd); err != nil {
 		return
 	}
 	i.Lock()
@@ -377,12 +378,12 @@ func (i *inotify) Close() (err error) {
 		return nil
 	}
 	for iwd := range i.m {
-		if _, e := syscall.InotifyRmWatch(int(i.fd), uint32(iwd)); e != nil && err == nil {
+		if e := removeInotifyWatch(i.fd, iwd); e != nil && err == nil {
 			err = e
 		}
 		delete(i.m, iwd)
 	}
-	switch _, errwrite := syscall.Write(i.pipefd[1], []byte{0x00}); {
+	switch _, errwrite := unix.Write(i.pipefd[1], []byte{0x00}); {
 	case errwrite != nil && err == nil:
 		err = errwrite
 		fallthrough
@@ -394,3 +395,11 @@ func (i *inotify) Close() (err error) {
 	}
 	return
 }
+
+// if path was removed, notify already removed the watch and returns EINVAL error
+func removeInotifyWatch(fd int32, iwd int32) (err error) {
+	if _, err = unix.InotifyRmWatch(int(fd), uint32(iwd)); err != nil && err != unix.EINVAL {
+		return
+	}
+	return nil
+}
diff --git a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
index 6d500b700d..22e3c2c4a4 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
@@ -36,16 +36,9 @@ type kq struct {
 
 // watched is a data structure representing watched file/directory.
 type watched struct {
-	// p is a path to watched file/directory.
-	p string
+	trgWatched
 	// fd is a file descriptor for watched file/directory.
 	fd int
-	// fi provides information about watched file/dir.
-	fi os.FileInfo
-	// eDir represents events watched directly.
-	eDir Event
-	// eNonDir represents events watched indirectly.
-	eNonDir Event
 }
 
 // Stop implements trigger.
@@ -66,7 +59,10 @@ func (*kq) NewWatched(p string, fi os.FileInfo) (*watched, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &watched{fd: fd, p: p, fi: fi}, nil
+	return &watched{
+		trgWatched: trgWatched{p: p, fi: fi},
+		fd:         fd,
+	}, nil
 }
 
 // Record implements trigger.
diff --git a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
index 5923bfddae..1494fcd799 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
@@ -284,16 +284,18 @@ func (r *readdcw) watch(path string, event Event, recursive bool) (err error) {
 			return
 		}
 		r.Lock()
+		defer r.Unlock()
 		if wd, ok = r.m[path]; ok {
-			r.Unlock()
+			dbgprint("watch: exists already")
 			return
 		}
 		if wd, err = newWatched(r.cph, uint32(event), recursive, path); err != nil {
-			r.Unlock()
 			return
 		}
 		r.m[path] = wd
-		r.Unlock()
+		dbgprint("watch: new watch added")
+	} else {
+		dbgprint("watch: exists already")
 	}
 	return nil
 }
@@ -337,33 +339,32 @@ func (r *readdcw) loop() {
 			continue
 		}
 		overEx := (*overlappedEx)(unsafe.Pointer(overlapped))
-		if n == 0 {
-			r.loopstate(overEx)
-		} else {
+		if n != 0 {
 			r.loopevent(n, overEx)
 			if err = overEx.parent.readDirChanges(); err != nil {
 				// TODO: error handling
 			}
 		}
+		r.loopstate(overEx)
 	}
 }
 
 // TODO(pknap) : doc
 func (r *readdcw) loopstate(overEx *overlappedEx) {
-	filter := atomic.LoadUint32(&overEx.parent.parent.filter)
+	r.Lock()
+	defer r.Unlock()
+	filter := overEx.parent.parent.filter
 	if filter&onlyMachineStates == 0 {
 		return
 	}
 	if overEx.parent.parent.count--; overEx.parent.parent.count == 0 {
 		switch filter & onlyMachineStates {
 		case stateRewatch:
-			r.Lock()
+			dbgprint("loopstate rewatch")
 			overEx.parent.parent.recreate(r.cph)
-			r.Unlock()
 		case stateUnwatch:
-			r.Lock()
+			dbgprint("loopstate unwatch")
 			delete(r.m, syscall.UTF16ToString(overEx.parent.pathw))
-			r.Unlock()
 		case stateCPClose:
 		default:
 			panic(`notify: windows loopstate logic error`)
@@ -450,8 +451,8 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool
 	}
 	var wd *watched
 	r.Lock()
-	if wd, err = r.nonStateWatched(path); err != nil {
-		r.Unlock()
+	defer r.Unlock()
+	if wd, err = r.nonStateWatchedLocked(path); err != nil {
 		return
 	}
 	if wd.filter&(onlyNotifyChanges|onlyNGlobalEvents) != oldevent {
@@ -462,21 +463,19 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool
 	if err = wd.closeHandle(); err != nil {
 		wd.filter = oldevent
 		wd.recursive = recursive
-		r.Unlock()
 		return
 	}
-	r.Unlock()
 	return
 }
 
 // TODO : pknap
-func (r *readdcw) nonStateWatched(path string) (wd *watched, err error) {
+func (r *readdcw) nonStateWatchedLocked(path string) (wd *watched, err error) {
 	wd, ok := r.m[path]
 	if !ok || wd == nil {
 		err = errors.New(`notify: ` + path + ` path is unwatched`)
 		return
 	}
-	if filter := atomic.LoadUint32(&wd.filter); filter&onlyMachineStates != 0 {
+	if wd.filter&onlyMachineStates != 0 {
 		err = errors.New(`notify: another re/unwatching operation in progress`)
 		return
 	}
@@ -497,17 +496,26 @@ func (r *readdcw) RecursiveUnwatch(path string) error {
 func (r *readdcw) unwatch(path string) (err error) {
 	var wd *watched
 	r.Lock()
-	if wd, err = r.nonStateWatched(path); err != nil {
-		r.Unlock()
+	defer r.Unlock()
+	if wd, err = r.nonStateWatchedLocked(path); err != nil {
 		return
 	}
 	wd.filter |= stateUnwatch
 	if err = wd.closeHandle(); err != nil {
 		wd.filter &^= stateUnwatch
-		r.Unlock()
 		return
 	}
-	r.Unlock()
+	if _, attrErr := syscall.GetFileAttributes(&wd.pathw[0]); attrErr != nil {
+		for _, g := range wd.digrip {
+			if g != nil {
+				dbgprint("unwatch: posting")
+				if err = syscall.PostQueuedCompletionStatus(r.cph, 0, 0, (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped))); err != nil {
+					wd.filter &^= stateUnwatch
+					return
+				}
+			}
+		}
+	}
 	return
 }
 
diff --git a/vendor/github.com/rjeczalik/notify/watcher_trigger.go b/vendor/github.com/rjeczalik/notify/watcher_trigger.go
index d079d59b0a..78151f909b 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_trigger.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_trigger.go
@@ -23,6 +23,7 @@
 package notify
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -56,6 +57,19 @@ type trigger interface {
 	IsStop(n interface{}, err error) bool
 }
 
+// trgWatched is a the base data structure representing watched file/directory.
+// The platform specific full data structure (watched) must embed this type.
+type trgWatched struct {
+	// p is a path to watched file/directory.
+	p string
+	// fi provides information about watched file/dir.
+	fi os.FileInfo
+	// eDir represents events watched directly.
+	eDir Event
+	// eNonDir represents events watched indirectly.
+	eNonDir Event
+}
+
 // encode Event to native representation. Implementation is to be provided by
 // platform specific implementation.
 var encode func(Event, bool) int64
@@ -117,6 +131,9 @@ func (t *trg) Close() (err error) {
 		dbgprintf("trg: closing native watch failed: %q\n", e)
 		err = nonil(err, e)
 	}
+	if remaining := len(t.pthLkp); remaining != 0 {
+		err = nonil(err, fmt.Errorf("Not all watches were removed: len(t.pthLkp) == %v", len(t.pthLkp)))
+	}
 	t.Unlock()
 	return
 }
@@ -175,7 +192,7 @@ func decode(o int64, w Event) (e Event) {
 func (t *trg) watch(p string, e Event, fi os.FileInfo) error {
 	if err := t.singlewatch(p, e, dir, fi); err != nil {
 		if err != errAlreadyWatched {
-			return nil
+			return err
 		}
 	}
 	if fi.IsDir() {
@@ -361,7 +378,7 @@ func (t *trg) singleunwatch(p string, direct mode) error {
 	}
 	if w.eNonDir|w.eDir != 0 {
 		mod := dir
-		if w.eNonDir == 0 {
+		if w.eNonDir != 0 {
 			mod = ndir
 		}
 		if err := t.singlewatch(p, w.eNonDir|w.eDir, mod,
diff --git a/vendor/github.com/syndtr/goleveldb/.travis.yml b/vendor/github.com/syndtr/goleveldb/.travis.yml
deleted file mode 100644
index 82de37735d..0000000000
--- a/vendor/github.com/syndtr/goleveldb/.travis.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-language: go
-
-go:
-  - 1.4
-  - 1.5
-  - 1.6
-  - 1.7
-  - tip
-
-script:
-  - go test -timeout 1h ./...
-  - go test -timeout 30m -race -run "TestDB_(Concurrent|GoleveldbIssue74)" ./leveldb
diff --git a/vendor/github.com/syndtr/goleveldb/README.md b/vendor/github.com/syndtr/goleveldb/README.md
index 259286f550..41a47614ca 100644
--- a/vendor/github.com/syndtr/goleveldb/README.md
+++ b/vendor/github.com/syndtr/goleveldb/README.md
@@ -10,13 +10,15 @@ Installation
 Requirements
 -----------
 
-* Need at least `go1.4` or newer.
+* Need at least `go1.5` or newer.
 
 Usage
 -----------
 
 Create or open a database:
 ```go
+// The returned DB instance is safe for concurrent use. Which mean that all
+// DB's methods may be called concurrently from multiple goroutine.
 db, err := leveldb.OpenFile("path/to/db", nil)
 ...
 defer db.Close()
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db.go b/vendor/github.com/syndtr/goleveldb/leveldb/db.go
index b0cdcb3d0a..e7ac065418 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/db.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db.go
@@ -32,6 +32,12 @@ type DB struct {
 	// Need 64-bit alignment.
 	seq uint64
 
+	// Stats. Need 64-bit alignment.
+	cWriteDelay            int64 // The cumulative duration of write delays
+	cWriteDelayN           int32 // The cumulative number of write delays
+	inWritePaused          int32 // The indicator whether write operation is paused by compaction
+	aliveSnaps, aliveIters int32
+
 	// Session.
 	s *session
 
@@ -49,9 +55,6 @@ type DB struct {
 	snapsMu   sync.Mutex
 	snapsList *list.List
 
-	// Stats.
-	aliveSnaps, aliveIters int32
-
 	// Write.
 	batchPool    sync.Pool
 	writeMergeC  chan writeMerge
@@ -321,7 +324,7 @@ func recoverTable(s *session, o *opt.Options) error {
 			}
 		}
 		err = iter.Error()
-		if err != nil {
+		if err != nil && !errors.IsCorrupted(err) {
 			return
 		}
 		err = tw.Close()
@@ -392,7 +395,7 @@ func recoverTable(s *session, o *opt.Options) error {
 			}
 			imax = append(imax[:0], key...)
 		}
-		if err := iter.Error(); err != nil {
+		if err := iter.Error(); err != nil && !errors.IsCorrupted(err) {
 			iter.Release()
 			return err
 		}
@@ -904,6 +907,10 @@ func (db *DB) GetSnapshot() (*Snapshot, error) {
 //		Returns the number of files at level 'n'.
 //	leveldb.stats
 //		Returns statistics of the underlying DB.
+//	leveldb.iostats
+//		Returns statistics of effective disk read and write.
+//	leveldb.writedelay
+//		Returns cumulative write delay caused by compaction.
 //	leveldb.sstables
 //		Returns sstables list for each level.
 //	leveldb.blockpool
@@ -955,6 +962,14 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 				level, len(tables), float64(tables.size())/1048576.0, duration.Seconds(),
 				float64(read)/1048576.0, float64(write)/1048576.0)
 		}
+	case p == "iostats":
+		value = fmt.Sprintf("Read(MB):%.5f Write(MB):%.5f",
+			float64(db.s.stor.reads())/1048576.0,
+			float64(db.s.stor.writes())/1048576.0)
+	case p == "writedelay":
+		writeDelayN, writeDelay := atomic.LoadInt32(&db.cWriteDelayN), time.Duration(atomic.LoadInt64(&db.cWriteDelay))
+		paused := atomic.LoadInt32(&db.inWritePaused) == 1
+		value = fmt.Sprintf("DelayN:%d Delay:%s Paused:%t", writeDelayN, writeDelay, paused)
 	case p == "sstables":
 		for level, tables := range v.levels {
 			value += fmt.Sprintf("--- level %d ---\n", level)
@@ -983,6 +998,75 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 	return
 }
 
+// DBStats is database statistics.
+type DBStats struct {
+	WriteDelayCount    int32
+	WriteDelayDuration time.Duration
+	WritePaused        bool
+
+	AliveSnapshots int32
+	AliveIterators int32
+
+	IOWrite uint64
+	IORead  uint64
+
+	BlockCacheSize    int
+	OpenedTablesCount int
+
+	LevelSizes        []int64
+	LevelTablesCounts []int
+	LevelRead         []int64
+	LevelWrite        []int64
+	LevelDurations    []time.Duration
+}
+
+// Stats populates s with database statistics.
+func (db *DB) Stats(s *DBStats) error {
+	err := db.ok()
+	if err != nil {
+		return err
+	}
+
+	s.IORead = db.s.stor.reads()
+	s.IOWrite = db.s.stor.writes()
+	s.WriteDelayCount = atomic.LoadInt32(&db.cWriteDelayN)
+	s.WriteDelayDuration = time.Duration(atomic.LoadInt64(&db.cWriteDelay))
+	s.WritePaused = atomic.LoadInt32(&db.inWritePaused) == 1
+
+	s.OpenedTablesCount = db.s.tops.cache.Size()
+	if db.s.tops.bcache != nil {
+		s.BlockCacheSize = db.s.tops.bcache.Size()
+	} else {
+		s.BlockCacheSize = 0
+	}
+
+	s.AliveIterators = atomic.LoadInt32(&db.aliveIters)
+	s.AliveSnapshots = atomic.LoadInt32(&db.aliveSnaps)
+
+	s.LevelDurations = s.LevelDurations[:0]
+	s.LevelRead = s.LevelRead[:0]
+	s.LevelWrite = s.LevelWrite[:0]
+	s.LevelSizes = s.LevelSizes[:0]
+	s.LevelTablesCounts = s.LevelTablesCounts[:0]
+
+	v := db.s.version()
+	defer v.release()
+
+	for level, tables := range v.levels {
+		duration, read, write := db.compStats.getStat(level)
+		if len(tables) == 0 && duration == 0 {
+			continue
+		}
+		s.LevelDurations = append(s.LevelDurations, duration)
+		s.LevelRead = append(s.LevelRead, read)
+		s.LevelWrite = append(s.LevelWrite, write)
+		s.LevelSizes = append(s.LevelSizes, tables.size())
+		s.LevelTablesCounts = append(s.LevelTablesCounts, len(tables))
+	}
+
+	return nil
+}
+
 // SizeOf calculates approximate sizes of the given key ranges.
 // The length of the returned sizes are equal with the length of the given
 // ranges. The returned sizes measure storage space usage, so if the user
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go b/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go
index 5b6cb487dc..db0c1bece1 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/db_write.go
@@ -7,6 +7,7 @@
 package leveldb
 
 import (
+	"sync/atomic"
 	"time"
 
 	"github.com/syndtr/goleveldb/leveldb/memdb"
@@ -88,7 +89,11 @@ func (db *DB) flush(n int) (mdb *memDB, mdbFree int, err error) {
 			return false
 		case tLen >= pauseTrigger:
 			delayed = true
+			// Set the write paused flag explicitly.
+			atomic.StoreInt32(&db.inWritePaused, 1)
 			err = db.compTriggerWait(db.tcompCmdC)
+			// Unset the write paused flag.
+			atomic.StoreInt32(&db.inWritePaused, 0)
 			if err != nil {
 				return false
 			}
@@ -117,6 +122,8 @@ func (db *DB) flush(n int) (mdb *memDB, mdbFree int, err error) {
 		db.writeDelayN++
 	} else if db.writeDelayN > 0 {
 		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
+		atomic.AddInt32(&db.cWriteDelayN, int32(db.writeDelayN))
+		atomic.AddInt64(&db.cWriteDelay, int64(db.writeDelay))
 		db.writeDelay = 0
 		db.writeDelayN = 0
 	}
@@ -143,7 +150,7 @@ func (db *DB) unlockWrite(overflow bool, merged int, err error) {
 	}
 }
 
-// ourBatch if defined should equal with batch.
+// ourBatch is batch that we can modify.
 func (db *DB) writeLocked(batch, ourBatch *Batch, merge, sync bool) error {
 	// Try to flush memdb. This method would also trying to throttle writes
 	// if it is too fast and compaction cannot catch-up.
@@ -212,6 +219,11 @@ func (db *DB) writeLocked(batch, ourBatch *Batch, merge, sync bool) error {
 		}
 	}
 
+	// Release ourBatch if any.
+	if ourBatch != nil {
+		defer db.batchPool.Put(ourBatch)
+	}
+
 	// Seq number.
 	seq := db.seq + 1
 
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
index 3b55532746..b16e3a7045 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/iterator/iter.go
@@ -88,7 +88,7 @@ type Iterator interface {
 	// its contents may change on the next call to any 'seeks method'.
 	Key() []byte
 
-	// Value returns the key of the current key/value pair, or nil if done.
+	// Value returns the value of the current key/value pair, or nil if done.
 	// The caller should not modify the contents of the returned slice, and
 	// its contents may change on the next call to any 'seeks method'.
 	Value() []byte
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go b/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
index 18a19ed424..b661c08a93 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go
@@ -329,7 +329,7 @@ func (p *DB) Delete(key []byte) error {
 
 	h := p.nodeData[node+nHeight]
 	for i, n := range p.prevNode[:h] {
-		m := n + 4 + i
+		m := n + nNext + i
 		p.nodeData[m] = p.nodeData[p.nodeData[m]+nNext+i]
 	}
 
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/session.go b/vendor/github.com/syndtr/goleveldb/leveldb/session.go
index ad68a87039..3f391f9346 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/session.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/session.go
@@ -42,7 +42,7 @@ type session struct {
 	stTempFileNum    int64
 	stSeqNum         uint64 // last mem compacted seq; need external synchronization
 
-	stor     storage.Storage
+	stor     *iStorage
 	storLock storage.Locker
 	o        *cachedOptions
 	icmp     *iComparer
@@ -68,7 +68,7 @@ func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
 		return
 	}
 	s = &session{
-		stor:     stor,
+		stor:     newIStorage(stor),
 		storLock: storLock,
 		fileRef:  make(map[int64]int),
 	}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage.go
new file mode 100644
index 0000000000..d45fb5dfeb
--- /dev/null
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage.go
@@ -0,0 +1,63 @@
+package leveldb
+
+import (
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"sync/atomic"
+)
+
+type iStorage struct {
+	storage.Storage
+	read  uint64
+	write uint64
+}
+
+func (c *iStorage) Open(fd storage.FileDesc) (storage.Reader, error) {
+	r, err := c.Storage.Open(fd)
+	return &iStorageReader{r, c}, err
+}
+
+func (c *iStorage) Create(fd storage.FileDesc) (storage.Writer, error) {
+	w, err := c.Storage.Create(fd)
+	return &iStorageWriter{w, c}, err
+}
+
+func (c *iStorage) reads() uint64 {
+	return atomic.LoadUint64(&c.read)
+}
+
+func (c *iStorage) writes() uint64 {
+	return atomic.LoadUint64(&c.write)
+}
+
+// newIStorage returns the given storage wrapped by iStorage.
+func newIStorage(s storage.Storage) *iStorage {
+	return &iStorage{s, 0, 0}
+}
+
+type iStorageReader struct {
+	storage.Reader
+	c *iStorage
+}
+
+func (r *iStorageReader) Read(p []byte) (n int, err error) {
+	n, err = r.Reader.Read(p)
+	atomic.AddUint64(&r.c.read, uint64(n))
+	return n, err
+}
+
+func (r *iStorageReader) ReadAt(p []byte, off int64) (n int, err error) {
+	n, err = r.Reader.ReadAt(p, off)
+	atomic.AddUint64(&r.c.read, uint64(n))
+	return n, err
+}
+
+type iStorageWriter struct {
+	storage.Writer
+	c *iStorage
+}
+
+func (w *iStorageWriter) Write(p []byte) (n int, err error) {
+	n, err = w.Writer.Write(p)
+	atomic.AddUint64(&w.c.write, uint64(n))
+	return n, err
+}
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
index bab62bfcee..b829798012 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/file_storage_plan9.go
@@ -8,7 +8,6 @@ package storage
 
 import (
 	"os"
-	"path/filepath"
 )
 
 type plan9FileLock struct {
@@ -48,8 +47,7 @@ func rename(oldpath, newpath string) error {
 		}
 	}
 
-	_, fname := filepath.Split(newpath)
-	return os.Rename(oldpath, fname)
+	return os.Rename(oldpath, newpath)
 }
 
 func syncDir(name string) error {
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go b/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
index 9b0421f035..838f1bee1b 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go
@@ -12,7 +12,11 @@ import (
 	"sync"
 )
 
-const typeShift = 3
+const typeShift = 4
+
+// Verify at compile-time that typeShift is large enough to cover all FileType
+// values by confirming that 0 == 0.
+var _ [0]struct{} = [TypeAll >> typeShift]struct{}{}
 
 type memStorageLock struct {
 	ms *memStorage
@@ -143,7 +147,7 @@ func (ms *memStorage) Remove(fd FileDesc) error {
 }
 
 func (ms *memStorage) Rename(oldfd, newfd FileDesc) error {
-	if FileDescOk(oldfd) || FileDescOk(newfd) {
+	if !FileDescOk(oldfd) || !FileDescOk(newfd) {
 		return ErrInvalidFile
 	}
 	if oldfd == newfd {
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util.go b/vendor/github.com/syndtr/goleveldb/leveldb/util.go
index e572a329e9..0e2b519e5c 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/util.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util.go
@@ -20,7 +20,7 @@ func shorten(str string) string {
 	return str[:3] + ".." + str[len(str)-3:]
 }
 
-var bunits = [...]string{"", "Ki", "Mi", "Gi"}
+var bunits = [...]string{"", "Ki", "Mi", "Gi", "Ti"}
 
 func shortenb(bytes int) string {
 	i := 0
diff --git a/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go b/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go
index f35976865b..80614afc58 100644
--- a/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go
+++ b/vendor/github.com/syndtr/goleveldb/leveldb/util/util.go
@@ -19,7 +19,7 @@ var (
 // Releaser is the interface that wraps the basic Release method.
 type Releaser interface {
 	// Release releases associated resources. Release should always success
-	// and can be called multipe times without causing error.
+	// and can be called multiple times without causing error.
 	Release()
 }
 
diff --git a/vendor/golang.org/x/net/idna/idna.go b/vendor/golang.org/x/net/idna/idna.go
new file mode 100644
index 0000000000..346fe4423e
--- /dev/null
+++ b/vendor/golang.org/x/net/idna/idna.go
@@ -0,0 +1,732 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 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 idna implements IDNA2008 using the compatibility processing
+// defined by UTS (Unicode Technical Standard) #46, which defines a standard to
+// deal with the transition from IDNA2003.
+//
+// IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC
+// 5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894.
+// UTS #46 is defined in http://www.unicode.org/reports/tr46.
+// See http://unicode.org/cldr/utility/idna.jsp for a visualization of the
+// differences between these two standards.
+package idna // import "golang.org/x/net/idna"
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/secure/bidirule"
+	"golang.org/x/text/unicode/bidi"
+	"golang.org/x/text/unicode/norm"
+)
+
+// NOTE: Unlike common practice in Go APIs, the functions will return a
+// sanitized domain name in case of errors. Browsers sometimes use a partially
+// evaluated string as lookup.
+// TODO: the current error handling is, in my opinion, the least opinionated.
+// Other strategies are also viable, though:
+// Option 1) Return an empty string in case of error, but allow the user to
+//    specify explicitly which errors to ignore.
+// Option 2) Return the partially evaluated string if it is itself a valid
+//    string, otherwise return the empty string in case of error.
+// Option 3) Option 1 and 2.
+// Option 4) Always return an empty string for now and implement Option 1 as
+//    needed, and document that the return string may not be empty in case of
+//    error in the future.
+// I think Option 1 is best, but it is quite opinionated.
+
+// ToASCII is a wrapper for Punycode.ToASCII.
+func ToASCII(s string) (string, error) {
+	return Punycode.process(s, true)
+}
+
+// ToUnicode is a wrapper for Punycode.ToUnicode.
+func ToUnicode(s string) (string, error) {
+	return Punycode.process(s, false)
+}
+
+// An Option configures a Profile at creation time.
+type Option func(*options)
+
+// Transitional sets a Profile to use the Transitional mapping as defined in UTS
+// #46. This will cause, for example, "ß" to be mapped to "ss". Using the
+// transitional mapping provides a compromise between IDNA2003 and IDNA2008
+// compatibility. It is used by most browsers when resolving domain names. This
+// option is only meaningful if combined with MapForLookup.
+func Transitional(transitional bool) Option {
+	return func(o *options) { o.transitional = true }
+}
+
+// VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
+// are longer than allowed by the RFC.
+func VerifyDNSLength(verify bool) Option {
+	return func(o *options) { o.verifyDNSLength = verify }
+}
+
+// RemoveLeadingDots removes leading label separators. Leading runes that map to
+// dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
+//
+// This is the behavior suggested by the UTS #46 and is adopted by some
+// browsers.
+func RemoveLeadingDots(remove bool) Option {
+	return func(o *options) { o.removeLeadingDots = remove }
+}
+
+// ValidateLabels sets whether to check the mandatory label validation criteria
+// as defined in Section 5.4 of RFC 5891. This includes testing for correct use
+// of hyphens ('-'), normalization, validity of runes, and the context rules.
+func ValidateLabels(enable bool) Option {
+	return func(o *options) {
+		// Don't override existing mappings, but set one that at least checks
+		// normalization if it is not set.
+		if o.mapping == nil && enable {
+			o.mapping = normalize
+		}
+		o.trie = trie
+		o.validateLabels = enable
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// StrictDomainName limits the set of permissible ASCII characters to those
+// allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
+// hyphen). This is set by default for MapForLookup and ValidateForRegistration.
+//
+// This option is useful, for instance, for browsers that allow characters
+// outside this range, for example a '_' (U+005F LOW LINE). See
+// http://www.rfc-editor.org/std/std3.txt for more details This option
+// corresponds to the UseSTD3ASCIIRules option in UTS #46.
+func StrictDomainName(use bool) Option {
+	return func(o *options) {
+		o.trie = trie
+		o.useSTD3Rules = use
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// NOTE: the following options pull in tables. The tables should not be linked
+// in as long as the options are not used.
+
+// BidiRule enables the Bidi rule as defined in RFC 5893. Any application
+// that relies on proper validation of labels should include this rule.
+func BidiRule() Option {
+	return func(o *options) { o.bidirule = bidirule.ValidString }
+}
+
+// ValidateForRegistration sets validation options to verify that a given IDN is
+// properly formatted for registration as defined by Section 4 of RFC 5891.
+func ValidateForRegistration() Option {
+	return func(o *options) {
+		o.mapping = validateRegistration
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+		VerifyDNSLength(true)(o)
+		BidiRule()(o)
+	}
+}
+
+// MapForLookup sets validation and mapping options such that a given IDN is
+// transformed for domain name lookup according to the requirements set out in
+// Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894,
+// RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option
+// to add this check.
+//
+// The mappings include normalization and mapping case, width and other
+// compatibility mappings.
+func MapForLookup() Option {
+	return func(o *options) {
+		o.mapping = validateAndMap
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+	}
+}
+
+type options struct {
+	transitional      bool
+	useSTD3Rules      bool
+	validateLabels    bool
+	verifyDNSLength   bool
+	removeLeadingDots bool
+
+	trie *idnaTrie
+
+	// fromPuny calls validation rules when converting A-labels to U-labels.
+	fromPuny func(p *Profile, s string) error
+
+	// mapping implements a validation and mapping step as defined in RFC 5895
+	// or UTS 46, tailored to, for example, domain registration or lookup.
+	mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)
+
+	// bidirule, if specified, checks whether s conforms to the Bidi Rule
+	// defined in RFC 5893.
+	bidirule func(s string) bool
+}
+
+// A Profile defines the configuration of an IDNA mapper.
+type Profile struct {
+	options
+}
+
+func apply(o *options, opts []Option) {
+	for _, f := range opts {
+		f(o)
+	}
+}
+
+// New creates a new Profile.
+//
+// With no options, the returned Profile is the most permissive and equals the
+// Punycode Profile. Options can be passed to further restrict the Profile. The
+// MapForLookup and ValidateForRegistration options set a collection of options,
+// for lookup and registration purposes respectively, which can be tailored by
+// adding more fine-grained options, where later options override earlier
+// options.
+func New(o ...Option) *Profile {
+	p := &Profile{}
+	apply(&p.options, o)
+	return p
+}
+
+// ToASCII converts a domain or domain label to its ASCII form. For example,
+// ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and
+// ToASCII("golang") is "golang". If an error is encountered it will return
+// an error and a (partially) processed result.
+func (p *Profile) ToASCII(s string) (string, error) {
+	return p.process(s, true)
+}
+
+// ToUnicode converts a domain or domain label to its Unicode form. For example,
+// ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and
+// ToUnicode("golang") is "golang". If an error is encountered it will return
+// an error and a (partially) processed result.
+func (p *Profile) ToUnicode(s string) (string, error) {
+	pp := *p
+	pp.transitional = false
+	return pp.process(s, false)
+}
+
+// String reports a string with a description of the profile for debugging
+// purposes. The string format may change with different versions.
+func (p *Profile) String() string {
+	s := ""
+	if p.transitional {
+		s = "Transitional"
+	} else {
+		s = "NonTransitional"
+	}
+	if p.useSTD3Rules {
+		s += ":UseSTD3Rules"
+	}
+	if p.validateLabels {
+		s += ":ValidateLabels"
+	}
+	if p.verifyDNSLength {
+		s += ":VerifyDNSLength"
+	}
+	return s
+}
+
+var (
+	// Punycode is a Profile that does raw punycode processing with a minimum
+	// of validation.
+	Punycode *Profile = punycode
+
+	// Lookup is the recommended profile for looking up domain names, according
+	// to Section 5 of RFC 5891. The exact configuration of this profile may
+	// change over time.
+	Lookup *Profile = lookup
+
+	// Display is the recommended profile for displaying domain names.
+	// The configuration of this profile may change over time.
+	Display *Profile = display
+
+	// Registration is the recommended profile for checking whether a given
+	// IDN is valid for registration, according to Section 4 of RFC 5891.
+	Registration *Profile = registration
+
+	punycode = &Profile{}
+	lookup   = &Profile{options{
+		transitional:   true,
+		useSTD3Rules:   true,
+		validateLabels: true,
+		trie:           trie,
+		fromPuny:       validateFromPunycode,
+		mapping:        validateAndMap,
+		bidirule:       bidirule.ValidString,
+	}}
+	display = &Profile{options{
+		useSTD3Rules:   true,
+		validateLabels: true,
+		trie:           trie,
+		fromPuny:       validateFromPunycode,
+		mapping:        validateAndMap,
+		bidirule:       bidirule.ValidString,
+	}}
+	registration = &Profile{options{
+		useSTD3Rules:    true,
+		validateLabels:  true,
+		verifyDNSLength: true,
+		trie:            trie,
+		fromPuny:        validateFromPunycode,
+		mapping:         validateRegistration,
+		bidirule:        bidirule.ValidString,
+	}}
+
+	// TODO: profiles
+	// Register: recommended for approving domain names: don't do any mappings
+	// but rather reject on invalid input. Bundle or block deviation characters.
+)
+
+type labelError struct{ label, code_ string }
+
+func (e labelError) code() string { return e.code_ }
+func (e labelError) Error() string {
+	return fmt.Sprintf("idna: invalid label %q", e.label)
+}
+
+type runeError rune
+
+func (e runeError) code() string { return "P1" }
+func (e runeError) Error() string {
+	return fmt.Sprintf("idna: disallowed rune %U", e)
+}
+
+// process implements the algorithm described in section 4 of UTS #46,
+// see http://www.unicode.org/reports/tr46.
+func (p *Profile) process(s string, toASCII bool) (string, error) {
+	var err error
+	var isBidi bool
+	if p.mapping != nil {
+		s, isBidi, err = p.mapping(p, s)
+	}
+	// Remove leading empty labels.
+	if p.removeLeadingDots {
+		for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
+		}
+	}
+	// TODO: allow for a quick check of the tables data.
+	// It seems like we should only create this error on ToASCII, but the
+	// UTS 46 conformance tests suggests we should always check this.
+	if err == nil && p.verifyDNSLength && s == "" {
+		err = &labelError{s, "A4"}
+	}
+	labels := labelIter{orig: s}
+	for ; !labels.done(); labels.next() {
+		label := labels.label()
+		if label == "" {
+			// Empty labels are not okay. The label iterator skips the last
+			// label if it is empty.
+			if err == nil && p.verifyDNSLength {
+				err = &labelError{s, "A4"}
+			}
+			continue
+		}
+		if strings.HasPrefix(label, acePrefix) {
+			u, err2 := decode(label[len(acePrefix):])
+			if err2 != nil {
+				if err == nil {
+					err = err2
+				}
+				// Spec says keep the old label.
+				continue
+			}
+			isBidi = isBidi || bidirule.DirectionString(u) != bidi.LeftToRight
+			labels.set(u)
+			if err == nil && p.validateLabels {
+				err = p.fromPuny(p, u)
+			}
+			if err == nil {
+				// This should be called on NonTransitional, according to the
+				// spec, but that currently does not have any effect. Use the
+				// original profile to preserve options.
+				err = p.validateLabel(u)
+			}
+		} else if err == nil {
+			err = p.validateLabel(label)
+		}
+	}
+	if isBidi && p.bidirule != nil && err == nil {
+		for labels.reset(); !labels.done(); labels.next() {
+			if !p.bidirule(labels.label()) {
+				err = &labelError{s, "B"}
+				break
+			}
+		}
+	}
+	if toASCII {
+		for labels.reset(); !labels.done(); labels.next() {
+			label := labels.label()
+			if !ascii(label) {
+				a, err2 := encode(acePrefix, label)
+				if err == nil {
+					err = err2
+				}
+				label = a
+				labels.set(a)
+			}
+			n := len(label)
+			if p.verifyDNSLength && err == nil && (n == 0 || n > 63) {
+				err = &labelError{label, "A4"}
+			}
+		}
+	}
+	s = labels.result()
+	if toASCII && p.verifyDNSLength && err == nil {
+		// Compute the length of the domain name minus the root label and its dot.
+		n := len(s)
+		if n > 0 && s[n-1] == '.' {
+			n--
+		}
+		if len(s) < 1 || n > 253 {
+			err = &labelError{s, "A4"}
+		}
+	}
+	return s, err
+}
+
+func normalize(p *Profile, s string) (mapped string, isBidi bool, err error) {
+	// TODO: consider first doing a quick check to see if any of these checks
+	// need to be done. This will make it slower in the general case, but
+	// faster in the common case.
+	mapped = norm.NFC.String(s)
+	isBidi = bidirule.DirectionString(mapped) == bidi.RightToLeft
+	return mapped, isBidi, nil
+}
+
+func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error) {
+	// TODO: filter need for normalization in loop below.
+	if !norm.NFC.IsNormalString(s) {
+		return s, false, &labelError{s, "V1"}
+	}
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			return s, bidi, runeError(utf8.RuneError)
+		}
+		bidi = bidi || info(v).isBidi(s[i:])
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		// TODO: handle the NV8 defined in the Unicode idna data set to allow
+		// for strict conformance to IDNA2008.
+		case valid, deviation:
+		case disallowed, mapped, unknown, ignored:
+			r, _ := utf8.DecodeRuneInString(s[i:])
+			return s, bidi, runeError(r)
+		}
+		i += sz
+	}
+	return s, bidi, nil
+}
+
+func (c info) isBidi(s string) bool {
+	if !c.isMapped() {
+		return c&attributesMask == rtl
+	}
+	// TODO: also store bidi info for mapped data. This is possible, but a bit
+	// cumbersome and not for the common case.
+	p, _ := bidi.LookupString(s)
+	switch p.Class() {
+	case bidi.R, bidi.AL, bidi.AN:
+		return true
+	}
+	return false
+}
+
+func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error) {
+	var (
+		b []byte
+		k int
+	)
+	// combinedInfoBits contains the or-ed bits of all runes. We use this
+	// to derive the mayNeedNorm bit later. This may trigger normalization
+	// overeagerly, but it will not do so in the common case. The end result
+	// is another 10% saving on BenchmarkProfile for the common case.
+	var combinedInfoBits info
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			b = append(b, s[k:i]...)
+			b = append(b, "\ufffd"...)
+			k = len(s)
+			if err == nil {
+				err = runeError(utf8.RuneError)
+			}
+			break
+		}
+		combinedInfoBits |= info(v)
+		bidi = bidi || info(v).isBidi(s[i:])
+		start := i
+		i += sz
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		case valid:
+			continue
+		case disallowed:
+			if err == nil {
+				r, _ := utf8.DecodeRuneInString(s[start:])
+				err = runeError(r)
+			}
+			continue
+		case mapped, deviation:
+			b = append(b, s[k:start]...)
+			b = info(v).appendMapping(b, s[start:i])
+		case ignored:
+			b = append(b, s[k:start]...)
+			// drop the rune
+		case unknown:
+			b = append(b, s[k:start]...)
+			b = append(b, "\ufffd"...)
+		}
+		k = i
+	}
+	if k == 0 {
+		// No changes so far.
+		if combinedInfoBits&mayNeedNorm != 0 {
+			s = norm.NFC.String(s)
+		}
+	} else {
+		b = append(b, s[k:]...)
+		if norm.NFC.QuickSpan(b) != len(b) {
+			b = norm.NFC.Bytes(b)
+		}
+		// TODO: the punycode converters require strings as input.
+		s = string(b)
+	}
+	return s, bidi, err
+}
+
+// A labelIter allows iterating over domain name labels.
+type labelIter struct {
+	orig     string
+	slice    []string
+	curStart int
+	curEnd   int
+	i        int
+}
+
+func (l *labelIter) reset() {
+	l.curStart = 0
+	l.curEnd = 0
+	l.i = 0
+}
+
+func (l *labelIter) done() bool {
+	return l.curStart >= len(l.orig)
+}
+
+func (l *labelIter) result() string {
+	if l.slice != nil {
+		return strings.Join(l.slice, ".")
+	}
+	return l.orig
+}
+
+func (l *labelIter) label() string {
+	if l.slice != nil {
+		return l.slice[l.i]
+	}
+	p := strings.IndexByte(l.orig[l.curStart:], '.')
+	l.curEnd = l.curStart + p
+	if p == -1 {
+		l.curEnd = len(l.orig)
+	}
+	return l.orig[l.curStart:l.curEnd]
+}
+
+// next sets the value to the next label. It skips the last label if it is empty.
+func (l *labelIter) next() {
+	l.i++
+	if l.slice != nil {
+		if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" {
+			l.curStart = len(l.orig)
+		}
+	} else {
+		l.curStart = l.curEnd + 1
+		if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' {
+			l.curStart = len(l.orig)
+		}
+	}
+}
+
+func (l *labelIter) set(s string) {
+	if l.slice == nil {
+		l.slice = strings.Split(l.orig, ".")
+	}
+	l.slice[l.i] = s
+}
+
+// acePrefix is the ASCII Compatible Encoding prefix.
+const acePrefix = "xn--"
+
+func (p *Profile) simplify(cat category) category {
+	switch cat {
+	case disallowedSTD3Mapped:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = mapped
+		}
+	case disallowedSTD3Valid:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = valid
+		}
+	case deviation:
+		if !p.transitional {
+			cat = valid
+		}
+	case validNV8, validXV8:
+		// TODO: handle V2008
+		cat = valid
+	}
+	return cat
+}
+
+func validateFromPunycode(p *Profile, s string) error {
+	if !norm.NFC.IsNormalString(s) {
+		return &labelError{s, "V1"}
+	}
+	// TODO: detect whether string may have to be normalized in the following
+	// loop.
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if sz == 0 {
+			return runeError(utf8.RuneError)
+		}
+		if c := p.simplify(info(v).category()); c != valid && c != deviation {
+			return &labelError{s, "V6"}
+		}
+		i += sz
+	}
+	return nil
+}
+
+const (
+	zwnj = "\u200c"
+	zwj  = "\u200d"
+)
+
+type joinState int8
+
+const (
+	stateStart joinState = iota
+	stateVirama
+	stateBefore
+	stateBeforeVirama
+	stateAfter
+	stateFAIL
+)
+
+var joinStates = [][numJoinTypes]joinState{
+	stateStart: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateVirama,
+	},
+	stateVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+	},
+	stateBefore: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joiningT:   stateBefore,
+		joinZWNJ:   stateAfter,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateBeforeVirama,
+	},
+	stateBeforeVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+		joiningT: stateBefore,
+	},
+	stateAfter: {
+		joiningL:   stateFAIL,
+		joiningD:   stateBefore,
+		joiningT:   stateAfter,
+		joiningR:   stateStart,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateAfter, // no-op as we can't accept joiners here
+	},
+	stateFAIL: {
+		0:          stateFAIL,
+		joiningL:   stateFAIL,
+		joiningD:   stateFAIL,
+		joiningT:   stateFAIL,
+		joiningR:   stateFAIL,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateFAIL,
+	},
+}
+
+// validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are
+// already implicitly satisfied by the overall implementation.
+func (p *Profile) validateLabel(s string) (err error) {
+	if s == "" {
+		if p.verifyDNSLength {
+			return &labelError{s, "A4"}
+		}
+		return nil
+	}
+	if !p.validateLabels {
+		return nil
+	}
+	trie := p.trie // p.validateLabels is only set if trie is set.
+	if len(s) > 4 && s[2] == '-' && s[3] == '-' {
+		return &labelError{s, "V2"}
+	}
+	if s[0] == '-' || s[len(s)-1] == '-' {
+		return &labelError{s, "V3"}
+	}
+	// TODO: merge the use of this in the trie.
+	v, sz := trie.lookupString(s)
+	x := info(v)
+	if x.isModifier() {
+		return &labelError{s, "V5"}
+	}
+	// Quickly return in the absence of zero-width (non) joiners.
+	if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 {
+		return nil
+	}
+	st := stateStart
+	for i := 0; ; {
+		jt := x.joinType()
+		if s[i:i+sz] == zwj {
+			jt = joinZWJ
+		} else if s[i:i+sz] == zwnj {
+			jt = joinZWNJ
+		}
+		st = joinStates[st][jt]
+		if x.isViramaModifier() {
+			st = joinStates[st][joinVirama]
+		}
+		if i += sz; i == len(s) {
+			break
+		}
+		v, sz = trie.lookupString(s[i:])
+		x = info(v)
+	}
+	if st == stateFAIL || st == stateAfter {
+		return &labelError{s, "C"}
+	}
+	return nil
+}
+
+func ascii(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] >= utf8.RuneSelf {
+			return false
+		}
+	}
+	return true
+}
diff --git a/vendor/golang.org/x/net/idna/punycode.go b/vendor/golang.org/x/net/idna/punycode.go
new file mode 100644
index 0000000000..02c7d59af3
--- /dev/null
+++ b/vendor/golang.org/x/net/idna/punycode.go
@@ -0,0 +1,203 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 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 idna
+
+// This file implements the Punycode algorithm from RFC 3492.
+
+import (
+	"math"
+	"strings"
+	"unicode/utf8"
+)
+
+// These parameter values are specified in section 5.
+//
+// All computation is done with int32s, so that overflow behavior is identical
+// regardless of whether int is 32-bit or 64-bit.
+const (
+	base        int32 = 36
+	damp        int32 = 700
+	initialBias int32 = 72
+	initialN    int32 = 128
+	skew        int32 = 38
+	tmax        int32 = 26
+	tmin        int32 = 1
+)
+
+func punyError(s string) error { return &labelError{s, "A3"} }
+
+// decode decodes a string as specified in section 6.2.
+func decode(encoded string) (string, error) {
+	if encoded == "" {
+		return "", nil
+	}
+	pos := 1 + strings.LastIndex(encoded, "-")
+	if pos == 1 {
+		return "", punyError(encoded)
+	}
+	if pos == len(encoded) {
+		return encoded[:len(encoded)-1], nil
+	}
+	output := make([]rune, 0, len(encoded))
+	if pos != 0 {
+		for _, r := range encoded[:pos-1] {
+			output = append(output, r)
+		}
+	}
+	i, n, bias := int32(0), initialN, initialBias
+	for pos < len(encoded) {
+		oldI, w := i, int32(1)
+		for k := base; ; k += base {
+			if pos == len(encoded) {
+				return "", punyError(encoded)
+			}
+			digit, ok := decodeDigit(encoded[pos])
+			if !ok {
+				return "", punyError(encoded)
+			}
+			pos++
+			i += digit * w
+			if i < 0 {
+				return "", punyError(encoded)
+			}
+			t := k - bias
+			if t < tmin {
+				t = tmin
+			} else if t > tmax {
+				t = tmax
+			}
+			if digit < t {
+				break
+			}
+			w *= base - t
+			if w >= math.MaxInt32/base {
+				return "", punyError(encoded)
+			}
+		}
+		x := int32(len(output) + 1)
+		bias = adapt(i-oldI, x, oldI == 0)
+		n += i / x
+		i %= x
+		if n > utf8.MaxRune || len(output) >= 1024 {
+			return "", punyError(encoded)
+		}
+		output = append(output, 0)
+		copy(output[i+1:], output[i:])
+		output[i] = n
+		i++
+	}
+	return string(output), nil
+}
+
+// encode encodes a string as specified in section 6.3 and prepends prefix to
+// the result.
+//
+// The "while h < length(input)" line in the specification becomes "for
+// remaining != 0" in the Go code, because len(s) in Go is in bytes, not runes.
+func encode(prefix, s string) (string, error) {
+	output := make([]byte, len(prefix), len(prefix)+1+2*len(s))
+	copy(output, prefix)
+	delta, n, bias := int32(0), initialN, initialBias
+	b, remaining := int32(0), int32(0)
+	for _, r := range s {
+		if r < 0x80 {
+			b++
+			output = append(output, byte(r))
+		} else {
+			remaining++
+		}
+	}
+	h := b
+	if b > 0 {
+		output = append(output, '-')
+	}
+	for remaining != 0 {
+		m := int32(0x7fffffff)
+		for _, r := range s {
+			if m > r && r >= n {
+				m = r
+			}
+		}
+		delta += (m - n) * (h + 1)
+		if delta < 0 {
+			return "", punyError(s)
+		}
+		n = m
+		for _, r := range s {
+			if r < n {
+				delta++
+				if delta < 0 {
+					return "", punyError(s)
+				}
+				continue
+			}
+			if r > n {
+				continue
+			}
+			q := delta
+			for k := base; ; k += base {
+				t := k - bias
+				if t < tmin {
+					t = tmin
+				} else if t > tmax {
+					t = tmax
+				}
+				if q < t {
+					break
+				}
+				output = append(output, encodeDigit(t+(q-t)%(base-t)))
+				q = (q - t) / (base - t)
+			}
+			output = append(output, encodeDigit(q))
+			bias = adapt(delta, h+1, h == b)
+			delta = 0
+			h++
+			remaining--
+		}
+		delta++
+		n++
+	}
+	return string(output), nil
+}
+
+func decodeDigit(x byte) (digit int32, ok bool) {
+	switch {
+	case '0' <= x && x <= '9':
+		return int32(x - ('0' - 26)), true
+	case 'A' <= x && x <= 'Z':
+		return int32(x - 'A'), true
+	case 'a' <= x && x <= 'z':
+		return int32(x - 'a'), true
+	}
+	return 0, false
+}
+
+func encodeDigit(digit int32) byte {
+	switch {
+	case 0 <= digit && digit < 26:
+		return byte(digit + 'a')
+	case 26 <= digit && digit < 36:
+		return byte(digit + ('0' - 26))
+	}
+	panic("idna: internal error in punycode encoding")
+}
+
+// adapt is the bias adaptation function specified in section 6.1.
+func adapt(delta, numPoints int32, firstTime bool) int32 {
+	if firstTime {
+		delta /= damp
+	} else {
+		delta /= 2
+	}
+	delta += delta / numPoints
+	k := int32(0)
+	for delta > ((base-tmin)*tmax)/2 {
+		delta /= base - tmin
+		k += base
+	}
+	return k + (base-tmin+1)*delta/(delta+skew)
+}
diff --git a/vendor/golang.org/x/net/idna/tables.go b/vendor/golang.org/x/net/idna/tables.go
new file mode 100644
index 0000000000..f910b26914
--- /dev/null
+++ b/vendor/golang.org/x/net/idna/tables.go
@@ -0,0 +1,4557 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package idna
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "10.0.0"
+
+var mappings string = "" + // Size: 8176 bytes
+	"\x00\x01 \x03 ̈\x01a\x03 ̄\x012\x013\x03 ́\x03 ̧\x011\x01o\x051⁄4\x051⁄2" +
+	"\x053⁄4\x03i̇\x03l·\x03ʼn\x01s\x03dž\x03ⱥ\x03ⱦ\x01h\x01j\x01r\x01w\x01y" +
+	"\x03 ̆\x03 ̇\x03 ̊\x03 ̨\x03 ̃\x03 ̋\x01l\x01x\x04̈́\x03 ι\x01;\x05 ̈́" +
+	"\x04եւ\x04اٴ\x04وٴ\x04ۇٴ\x04يٴ\x06क़\x06ख़\x06ग़\x06ज़\x06ड़\x06ढ़\x06फ़" +
+	"\x06य़\x06ড়\x06ঢ়\x06য়\x06ਲ਼\x06ਸ਼\x06ਖ਼\x06ਗ਼\x06ਜ਼\x06ਫ਼\x06ଡ଼\x06ଢ଼" +
+	"\x06ํา\x06ໍາ\x06ຫນ\x06ຫມ\x06གྷ\x06ཌྷ\x06དྷ\x06བྷ\x06ཛྷ\x06ཀྵ\x06ཱི\x06ཱུ" +
+	"\x06ྲྀ\x09ྲཱྀ\x06ླྀ\x09ླཱྀ\x06ཱྀ\x06ྒྷ\x06ྜྷ\x06ྡྷ\x06ྦྷ\x06ྫྷ\x06ྐྵ\x02" +
+	"в\x02д\x02о\x02с\x02т\x02ъ\x02ѣ\x02æ\x01b\x01d\x01e\x02ǝ\x01g\x01i\x01k" +
+	"\x01m\x01n\x02ȣ\x01p\x01t\x01u\x02ɐ\x02ɑ\x02ə\x02ɛ\x02ɜ\x02ŋ\x02ɔ\x02ɯ" +
+	"\x01v\x02β\x02γ\x02δ\x02φ\x02χ\x02ρ\x02н\x02ɒ\x01c\x02ɕ\x02ð\x01f\x02ɟ" +
+	"\x02ɡ\x02ɥ\x02ɨ\x02ɩ\x02ɪ\x02ʝ\x02ɭ\x02ʟ\x02ɱ\x02ɰ\x02ɲ\x02ɳ\x02ɴ\x02ɵ" +
+	"\x02ɸ\x02ʂ\x02ʃ\x02ƫ\x02ʉ\x02ʊ\x02ʋ\x02ʌ\x01z\x02ʐ\x02ʑ\x02ʒ\x02θ\x02ss" +
+	"\x02ά\x02έ\x02ή\x02ί\x02ό\x02ύ\x02ώ\x05ἀι\x05ἁι\x05ἂι\x05ἃι\x05ἄι\x05ἅι" +
+	"\x05ἆι\x05ἇι\x05ἠι\x05ἡι\x05ἢι\x05ἣι\x05ἤι\x05ἥι\x05ἦι\x05ἧι\x05ὠι\x05ὡι" +
+	"\x05ὢι\x05ὣι\x05ὤι\x05ὥι\x05ὦι\x05ὧι\x05ὰι\x04αι\x04άι\x05ᾶι\x02ι\x05 ̈͂" +
+	"\x05ὴι\x04ηι\x04ήι\x05ῆι\x05 ̓̀\x05 ̓́\x05 ̓͂\x02ΐ\x05 ̔̀\x05 ̔́\x05 ̔͂" +
+	"\x02ΰ\x05 ̈̀\x01`\x05ὼι\x04ωι\x04ώι\x05ῶι\x06′′\x09′′′\x06‵‵\x09‵‵‵\x02!" +
+	"!\x02??\x02?!\x02!?\x0c′′′′\x010\x014\x015\x016\x017\x018\x019\x01+\x01=" +
+	"\x01(\x01)\x02rs\x02ħ\x02no\x01q\x02sm\x02tm\x02ω\x02å\x02א\x02ב\x02ג" +
+	"\x02ד\x02π\x051⁄7\x051⁄9\x061⁄10\x051⁄3\x052⁄3\x051⁄5\x052⁄5\x053⁄5\x054" +
+	"⁄5\x051⁄6\x055⁄6\x051⁄8\x053⁄8\x055⁄8\x057⁄8\x041⁄\x02ii\x02iv\x02vi" +
+	"\x04viii\x02ix\x02xi\x050⁄3\x06∫∫\x09∫∫∫\x06∮∮\x09∮∮∮\x0210\x0211\x0212" +
+	"\x0213\x0214\x0215\x0216\x0217\x0218\x0219\x0220\x04(10)\x04(11)\x04(12)" +
+	"\x04(13)\x04(14)\x04(15)\x04(16)\x04(17)\x04(18)\x04(19)\x04(20)\x0c∫∫∫∫" +
+	"\x02==\x05⫝̸\x02ɫ\x02ɽ\x02ȿ\x02ɀ\x01.\x04 ゙\x04 ゚\x06より\x06コト\x05(ᄀ)\x05" +
+	"(ᄂ)\x05(ᄃ)\x05(ᄅ)\x05(ᄆ)\x05(ᄇ)\x05(ᄉ)\x05(ᄋ)\x05(ᄌ)\x05(ᄎ)\x05(ᄏ)\x05(ᄐ" +
+	")\x05(ᄑ)\x05(ᄒ)\x05(가)\x05(나)\x05(다)\x05(라)\x05(마)\x05(바)\x05(사)\x05(아)" +
+	"\x05(자)\x05(차)\x05(카)\x05(타)\x05(파)\x05(하)\x05(주)\x08(오전)\x08(오후)\x05(一)" +
+	"\x05(二)\x05(三)\x05(四)\x05(五)\x05(六)\x05(七)\x05(八)\x05(九)\x05(十)\x05(月)" +
+	"\x05(火)\x05(水)\x05(木)\x05(金)\x05(土)\x05(日)\x05(株)\x05(有)\x05(社)\x05(名)" +
+	"\x05(特)\x05(財)\x05(祝)\x05(労)\x05(代)\x05(呼)\x05(学)\x05(監)\x05(企)\x05(資)" +
+	"\x05(協)\x05(祭)\x05(休)\x05(自)\x05(至)\x0221\x0222\x0223\x0224\x0225\x0226" +
+	"\x0227\x0228\x0229\x0230\x0231\x0232\x0233\x0234\x0235\x06참고\x06주의\x0236" +
+	"\x0237\x0238\x0239\x0240\x0241\x0242\x0243\x0244\x0245\x0246\x0247\x0248" +
+	"\x0249\x0250\x041月\x042月\x043月\x044月\x045月\x046月\x047月\x048月\x049月\x0510" +
+	"月\x0511月\x0512月\x02hg\x02ev\x0cアパート\x0cアルファ\x0cアンペア\x09アール\x0cイニング\x09" +
+	"インチ\x09ウォン\x0fエスクード\x0cエーカー\x09オンス\x09オーム\x09カイリ\x0cカラット\x0cカロリー\x09ガロ" +
+	"ン\x09ガンマ\x06ギガ\x09ギニー\x0cキュリー\x0cギルダー\x06キロ\x0fキログラム\x12キロメートル\x0fキロワッ" +
+	"ト\x09グラム\x0fグラムトン\x0fクルゼイロ\x0cクローネ\x09ケース\x09コルナ\x09コーポ\x0cサイクル\x0fサンチ" +
+	"ーム\x0cシリング\x09センチ\x09セント\x09ダース\x06デシ\x06ドル\x06トン\x06ナノ\x09ノット\x09ハイツ" +
+	"\x0fパーセント\x09パーツ\x0cバーレル\x0fピアストル\x09ピクル\x06ピコ\x06ビル\x0fファラッド\x0cフィート" +
+	"\x0fブッシェル\x09フラン\x0fヘクタール\x06ペソ\x09ペニヒ\x09ヘルツ\x09ペンス\x09ページ\x09ベータ\x0cポイ" +
+	"ント\x09ボルト\x06ホン\x09ポンド\x09ホール\x09ホーン\x0cマイクロ\x09マイル\x09マッハ\x09マルク\x0fマ" +
+	"ンション\x0cミクロン\x06ミリ\x0fミリバール\x06メガ\x0cメガトン\x0cメートル\x09ヤード\x09ヤール\x09ユアン" +
+	"\x0cリットル\x06リラ\x09ルピー\x0cルーブル\x06レム\x0fレントゲン\x09ワット\x040点\x041点\x042点" +
+	"\x043点\x044点\x045点\x046点\x047点\x048点\x049点\x0510点\x0511点\x0512点\x0513点" +
+	"\x0514点\x0515点\x0516点\x0517点\x0518点\x0519点\x0520点\x0521点\x0522点\x0523点" +
+	"\x0524点\x02da\x02au\x02ov\x02pc\x02dm\x02iu\x06平成\x06昭和\x06大正\x06明治\x0c株" +
+	"式会社\x02pa\x02na\x02ma\x02ka\x02kb\x02mb\x02gb\x04kcal\x02pf\x02nf\x02m" +
+	"g\x02kg\x02hz\x02ml\x02dl\x02kl\x02fm\x02nm\x02mm\x02cm\x02km\x02m2\x02m" +
+	"3\x05m∕s\x06m∕s2\x07rad∕s\x08rad∕s2\x02ps\x02ns\x02ms\x02pv\x02nv\x02mv" +
+	"\x02kv\x02pw\x02nw\x02mw\x02kw\x02bq\x02cc\x02cd\x06c∕kg\x02db\x02gy\x02" +
+	"ha\x02hp\x02in\x02kk\x02kt\x02lm\x02ln\x02lx\x02ph\x02pr\x02sr\x02sv\x02" +
+	"wb\x05v∕m\x05a∕m\x041日\x042日\x043日\x044日\x045日\x046日\x047日\x048日\x049日" +
+	"\x0510日\x0511日\x0512日\x0513日\x0514日\x0515日\x0516日\x0517日\x0518日\x0519日" +
+	"\x0520日\x0521日\x0522日\x0523日\x0524日\x0525日\x0526日\x0527日\x0528日\x0529日" +
+	"\x0530日\x0531日\x02ь\x02ɦ\x02ɬ\x02ʞ\x02ʇ\x02œ\x04𤋮\x04𢡊\x04𢡄\x04𣏕\x04𥉉" +
+	"\x04𥳐\x04𧻓\x02ff\x02fi\x02fl\x02st\x04մն\x04մե\x04մի\x04վն\x04մխ\x04יִ" +
+	"\x04ײַ\x02ע\x02ה\x02כ\x02ל\x02ם\x02ר\x02ת\x04שׁ\x04שׂ\x06שּׁ\x06שּׂ\x04א" +
+	"ַ\x04אָ\x04אּ\x04בּ\x04גּ\x04דּ\x04הּ\x04וּ\x04זּ\x04טּ\x04יּ\x04ךּ\x04" +
+	"כּ\x04לּ\x04מּ\x04נּ\x04סּ\x04ףּ\x04פּ\x04צּ\x04קּ\x04רּ\x04שּ\x04תּ" +
+	"\x04וֹ\x04בֿ\x04כֿ\x04פֿ\x04אל\x02ٱ\x02ٻ\x02پ\x02ڀ\x02ٺ\x02ٿ\x02ٹ\x02ڤ" +
+	"\x02ڦ\x02ڄ\x02ڃ\x02چ\x02ڇ\x02ڍ\x02ڌ\x02ڎ\x02ڈ\x02ژ\x02ڑ\x02ک\x02گ\x02ڳ" +
+	"\x02ڱ\x02ں\x02ڻ\x02ۀ\x02ہ\x02ھ\x02ے\x02ۓ\x02ڭ\x02ۇ\x02ۆ\x02ۈ\x02ۋ\x02ۅ" +
+	"\x02ۉ\x02ې\x02ى\x04ئا\x04ئە\x04ئو\x04ئۇ\x04ئۆ\x04ئۈ\x04ئې\x04ئى\x02ی\x04" +
+	"ئج\x04ئح\x04ئم\x04ئي\x04بج\x04بح\x04بخ\x04بم\x04بى\x04بي\x04تج\x04تح" +
+	"\x04تخ\x04تم\x04تى\x04تي\x04ثج\x04ثم\x04ثى\x04ثي\x04جح\x04جم\x04حج\x04حم" +
+	"\x04خج\x04خح\x04خم\x04سج\x04سح\x04سخ\x04سم\x04صح\x04صم\x04ضج\x04ضح\x04ضخ" +
+	"\x04ضم\x04طح\x04طم\x04ظم\x04عج\x04عم\x04غج\x04غم\x04فج\x04فح\x04فخ\x04فم" +
+	"\x04فى\x04في\x04قح\x04قم\x04قى\x04قي\x04كا\x04كج\x04كح\x04كخ\x04كل\x04كم" +
+	"\x04كى\x04كي\x04لج\x04لح\x04لخ\x04لم\x04لى\x04لي\x04مج\x04مح\x04مخ\x04مم" +
+	"\x04مى\x04مي\x04نج\x04نح\x04نخ\x04نم\x04نى\x04ني\x04هج\x04هم\x04هى\x04هي" +
+	"\x04يج\x04يح\x04يخ\x04يم\x04يى\x04يي\x04ذٰ\x04رٰ\x04ىٰ\x05 ٌّ\x05 ٍّ\x05" +
+	" َّ\x05 ُّ\x05 ِّ\x05 ّٰ\x04ئر\x04ئز\x04ئن\x04بر\x04بز\x04بن\x04تر\x04تز" +
+	"\x04تن\x04ثر\x04ثز\x04ثن\x04ما\x04نر\x04نز\x04نن\x04ير\x04يز\x04ين\x04ئخ" +
+	"\x04ئه\x04به\x04ته\x04صخ\x04له\x04نه\x04هٰ\x04يه\x04ثه\x04سه\x04شم\x04شه" +
+	"\x06ـَّ\x06ـُّ\x06ـِّ\x04طى\x04طي\x04عى\x04عي\x04غى\x04غي\x04سى\x04سي" +
+	"\x04شى\x04شي\x04حى\x04حي\x04جى\x04جي\x04خى\x04خي\x04صى\x04صي\x04ضى\x04ضي" +
+	"\x04شج\x04شح\x04شخ\x04شر\x04سر\x04صر\x04ضر\x04اً\x06تجم\x06تحج\x06تحم" +
+	"\x06تخم\x06تمج\x06تمح\x06تمخ\x06جمح\x06حمي\x06حمى\x06سحج\x06سجح\x06سجى" +
+	"\x06سمح\x06سمج\x06سمم\x06صحح\x06صمم\x06شحم\x06شجي\x06شمخ\x06شمم\x06ضحى" +
+	"\x06ضخم\x06طمح\x06طمم\x06طمي\x06عجم\x06عمم\x06عمى\x06غمم\x06غمي\x06غمى" +
+	"\x06فخم\x06قمح\x06قمم\x06لحم\x06لحي\x06لحى\x06لجج\x06لخم\x06لمح\x06محج" +
+	"\x06محم\x06محي\x06مجح\x06مجم\x06مخج\x06مخم\x06مجخ\x06همج\x06همم\x06نحم" +
+	"\x06نحى\x06نجم\x06نجى\x06نمي\x06نمى\x06يمم\x06بخي\x06تجي\x06تجى\x06تخي" +
+	"\x06تخى\x06تمي\x06تمى\x06جمي\x06جحى\x06جمى\x06سخى\x06صحي\x06شحي\x06ضحي" +
+	"\x06لجي\x06لمي\x06يحي\x06يجي\x06يمي\x06ممي\x06قمي\x06نحي\x06عمي\x06كمي" +
+	"\x06نجح\x06مخي\x06لجم\x06كمم\x06جحي\x06حجي\x06مجي\x06فمي\x06بحي\x06سخي" +
+	"\x06نجي\x06صلے\x06قلے\x08الله\x08اكبر\x08محمد\x08صلعم\x08رسول\x08عليه" +
+	"\x08وسلم\x06صلى!صلى الله عليه وسلم\x0fجل جلاله\x08ریال\x01,\x01:\x01!" +
+	"\x01?\x01_\x01{\x01}\x01[\x01]\x01#\x01&\x01*\x01-\x01<\x01>\x01\\\x01$" +
+	"\x01%\x01@\x04ـً\x04ـَ\x04ـُ\x04ـِ\x04ـّ\x04ـْ\x02ء\x02آ\x02أ\x02ؤ\x02إ" +
+	"\x02ئ\x02ا\x02ب\x02ة\x02ت\x02ث\x02ج\x02ح\x02خ\x02د\x02ذ\x02ر\x02ز\x02س" +
+	"\x02ش\x02ص\x02ض\x02ط\x02ظ\x02ع\x02غ\x02ف\x02ق\x02ك\x02ل\x02م\x02ن\x02ه" +
+	"\x02و\x02ي\x04لآ\x04لأ\x04لإ\x04لا\x01\x22\x01'\x01/\x01^\x01|\x01~\x02¢" +
+	"\x02£\x02¬\x02¦\x02¥\x08𝅗𝅥\x08𝅘𝅥\x0c𝅘𝅥𝅮\x0c𝅘𝅥𝅯\x0c𝅘𝅥𝅰\x0c𝅘𝅥𝅱\x0c𝅘𝅥𝅲\x08𝆹" +
+	"𝅥\x08𝆺𝅥\x0c𝆹𝅥𝅮\x0c𝆺𝅥𝅮\x0c𝆹𝅥𝅯\x0c𝆺𝅥𝅯\x02ı\x02ȷ\x02α\x02ε\x02ζ\x02η\x02" +
+	"κ\x02λ\x02μ\x02ν\x02ξ\x02ο\x02σ\x02τ\x02υ\x02ψ\x03∇\x03∂\x02ϝ\x02ٮ\x02ڡ" +
+	"\x02ٯ\x020,\x021,\x022,\x023,\x024,\x025,\x026,\x027,\x028,\x029,\x03(a)" +
+	"\x03(b)\x03(c)\x03(d)\x03(e)\x03(f)\x03(g)\x03(h)\x03(i)\x03(j)\x03(k)" +
+	"\x03(l)\x03(m)\x03(n)\x03(o)\x03(p)\x03(q)\x03(r)\x03(s)\x03(t)\x03(u)" +
+	"\x03(v)\x03(w)\x03(x)\x03(y)\x03(z)\x07〔s〕\x02wz\x02hv\x02sd\x03ppv\x02w" +
+	"c\x02mc\x02md\x02dj\x06ほか\x06ココ\x03サ\x03手\x03字\x03双\x03デ\x03二\x03多\x03解" +
+	"\x03天\x03交\x03映\x03無\x03料\x03前\x03後\x03再\x03新\x03初\x03終\x03生\x03販\x03声" +
+	"\x03吹\x03演\x03投\x03捕\x03一\x03三\x03遊\x03左\x03中\x03右\x03指\x03走\x03打\x03禁" +
+	"\x03空\x03合\x03満\x03有\x03月\x03申\x03割\x03営\x03配\x09〔本〕\x09〔三〕\x09〔二〕\x09〔安" +
+	"〕\x09〔点〕\x09〔打〕\x09〔盗〕\x09〔勝〕\x09〔敗〕\x03得\x03可\x03丽\x03丸\x03乁\x03你\x03" +
+	"侮\x03侻\x03倂\x03偺\x03備\x03僧\x03像\x03㒞\x03免\x03兔\x03兤\x03具\x03㒹\x03內\x03" +
+	"冗\x03冤\x03仌\x03冬\x03况\x03凵\x03刃\x03㓟\x03刻\x03剆\x03剷\x03㔕\x03勇\x03勉\x03" +
+	"勤\x03勺\x03包\x03匆\x03北\x03卉\x03卑\x03博\x03即\x03卽\x03卿\x03灰\x03及\x03叟\x03" +
+	"叫\x03叱\x03吆\x03咞\x03吸\x03呈\x03周\x03咢\x03哶\x03唐\x03啓\x03啣\x03善\x03喙\x03" +
+	"喫\x03喳\x03嗂\x03圖\x03嘆\x03圗\x03噑\x03噴\x03切\x03壮\x03城\x03埴\x03堍\x03型\x03" +
+	"堲\x03報\x03墬\x03売\x03壷\x03夆\x03夢\x03奢\x03姬\x03娛\x03娧\x03姘\x03婦\x03㛮\x03" +
+	"嬈\x03嬾\x03寃\x03寘\x03寧\x03寳\x03寿\x03将\x03尢\x03㞁\x03屠\x03屮\x03峀\x03岍\x03" +
+	"嵃\x03嵮\x03嵫\x03嵼\x03巡\x03巢\x03㠯\x03巽\x03帨\x03帽\x03幩\x03㡢\x03㡼\x03庰\x03" +
+	"庳\x03庶\x03廊\x03廾\x03舁\x03弢\x03㣇\x03形\x03彫\x03㣣\x03徚\x03忍\x03志\x03忹\x03" +
+	"悁\x03㤺\x03㤜\x03悔\x03惇\x03慈\x03慌\x03慎\x03慺\x03憎\x03憲\x03憤\x03憯\x03懞\x03" +
+	"懲\x03懶\x03成\x03戛\x03扝\x03抱\x03拔\x03捐\x03挽\x03拼\x03捨\x03掃\x03揤\x03搢\x03" +
+	"揅\x03掩\x03㨮\x03摩\x03摾\x03撝\x03摷\x03㩬\x03敏\x03敬\x03旣\x03書\x03晉\x03㬙\x03" +
+	"暑\x03㬈\x03㫤\x03冒\x03冕\x03最\x03暜\x03肭\x03䏙\x03朗\x03望\x03朡\x03杞\x03杓\x03" +
+	"㭉\x03柺\x03枅\x03桒\x03梅\x03梎\x03栟\x03椔\x03㮝\x03楂\x03榣\x03槪\x03檨\x03櫛\x03" +
+	"㰘\x03次\x03歔\x03㱎\x03歲\x03殟\x03殺\x03殻\x03汎\x03沿\x03泍\x03汧\x03洖\x03派\x03" +
+	"海\x03流\x03浩\x03浸\x03涅\x03洴\x03港\x03湮\x03㴳\x03滋\x03滇\x03淹\x03潮\x03濆\x03" +
+	"瀹\x03瀞\x03瀛\x03㶖\x03灊\x03災\x03灷\x03炭\x03煅\x03熜\x03爨\x03爵\x03牐\x03犀\x03" +
+	"犕\x03獺\x03王\x03㺬\x03玥\x03㺸\x03瑇\x03瑜\x03瑱\x03璅\x03瓊\x03㼛\x03甤\x03甾\x03" +
+	"異\x03瘐\x03㿼\x03䀈\x03直\x03眞\x03真\x03睊\x03䀹\x03瞋\x03䁆\x03䂖\x03硎\x03碌\x03" +
+	"磌\x03䃣\x03祖\x03福\x03秫\x03䄯\x03穀\x03穊\x03穏\x03䈂\x03篆\x03築\x03䈧\x03糒\x03" +
+	"䊠\x03糨\x03糣\x03紀\x03絣\x03䌁\x03緇\x03縂\x03繅\x03䌴\x03䍙\x03罺\x03羕\x03翺\x03" +
+	"者\x03聠\x03聰\x03䏕\x03育\x03脃\x03䐋\x03脾\x03媵\x03舄\x03辞\x03䑫\x03芑\x03芋\x03" +
+	"芝\x03劳\x03花\x03芳\x03芽\x03苦\x03若\x03茝\x03荣\x03莭\x03茣\x03莽\x03菧\x03著\x03" +
+	"荓\x03菊\x03菌\x03菜\x03䔫\x03蓱\x03蓳\x03蔖\x03蕤\x03䕝\x03䕡\x03䕫\x03虐\x03虜\x03" +
+	"虧\x03虩\x03蚩\x03蚈\x03蜎\x03蛢\x03蝹\x03蜨\x03蝫\x03螆\x03蟡\x03蠁\x03䗹\x03衠\x03" +
+	"衣\x03裗\x03裞\x03䘵\x03裺\x03㒻\x03䚾\x03䛇\x03誠\x03諭\x03變\x03豕\x03貫\x03賁\x03" +
+	"贛\x03起\x03跋\x03趼\x03跰\x03軔\x03輸\x03邔\x03郱\x03鄑\x03鄛\x03鈸\x03鋗\x03鋘\x03" +
+	"鉼\x03鏹\x03鐕\x03開\x03䦕\x03閷\x03䧦\x03雃\x03嶲\x03霣\x03䩮\x03䩶\x03韠\x03䪲\x03" +
+	"頋\x03頩\x03飢\x03䬳\x03餩\x03馧\x03駂\x03駾\x03䯎\x03鬒\x03鱀\x03鳽\x03䳎\x03䳭\x03" +
+	"鵧\x03䳸\x03麻\x03䵖\x03黹\x03黾\x03鼅\x03鼏\x03鼖\x03鼻"
+
+var xorData string = "" + // Size: 4855 bytes
+	"\x02\x0c\x09\x02\xb0\xec\x02\xad\xd8\x02\xad\xd9\x02\x06\x07\x02\x0f\x12" +
+	"\x02\x0f\x1f\x02\x0f\x1d\x02\x01\x13\x02\x0f\x16\x02\x0f\x0b\x02\x0f3" +
+	"\x02\x0f7\x02\x0f?\x02\x0f/\x02\x0f*\x02\x0c&\x02\x0c*\x02\x0c;\x02\x0c9" +
+	"\x02\x0c%\x02\xab\xed\x02\xab\xe2\x02\xab\xe3\x02\xa9\xe0\x02\xa9\xe1" +
+	"\x02\xa9\xe6\x02\xa3\xcb\x02\xa3\xc8\x02\xa3\xc9\x02\x01#\x02\x01\x08" +
+	"\x02\x0e>\x02\x0e'\x02\x0f\x03\x02\x03\x0d\x02\x03\x09\x02\x03\x17\x02" +
+	"\x03\x0e\x02\x02\x03\x02\x011\x02\x01\x00\x02\x01\x10\x02\x03<\x02\x07" +
+	"\x0d\x02\x02\x0c\x02\x0c0\x02\x01\x03\x02\x01\x01\x02\x01 \x02\x01\x22" +
+	"\x02\x01)\x02\x01\x0a\x02\x01\x0c\x02\x02\x06\x02\x02\x02\x02\x03\x10" +
+	"\x03\x037 \x03\x0b+\x03\x02\x01\x04\x02\x01\x02\x02\x019\x02\x03\x1c\x02" +
+	"\x02$\x03\x80p$\x02\x03:\x02\x03\x0a\x03\xc1r.\x03\xc1r,\x03\xc1r\x02" +
+	"\x02\x02:\x02\x02>\x02\x02,\x02\x02\x10\x02\x02\x00\x03\xc1s<\x03\xc1s*" +
+	"\x03\xc2L$\x03\xc2L;\x02\x09)\x02\x0a\x19\x03\x83\xab\xe3\x03\x83\xab" +
+	"\xf2\x03 4\xe0\x03\x81\xab\xea\x03\x81\xab\xf3\x03 4\xef\x03\x96\xe1\xcd" +
+	"\x03\x84\xe5\xc3\x02\x0d\x11\x03\x8b\xec\xcb\x03\x94\xec\xcf\x03\x9a\xec" +
+	"\xc2\x03\x8b\xec\xdb\x03\x94\xec\xdf\x03\x9a\xec\xd2\x03\x01\x0c!\x03" +
+	"\x01\x0c#\x03ʠ\x9d\x03ʣ\x9c\x03ʢ\x9f\x03ʥ\x9e\x03ʤ\x91\x03ʧ\x90\x03ʦ\x93" +
+	"\x03ʩ\x92\x03ʨ\x95\x03\xca\xf3\xb5\x03\xca\xf0\xb4\x03\xca\xf1\xb7\x03" +
+	"\xca\xf6\xb6\x03\xca\xf7\x89\x03\xca\xf4\x88\x03\xca\xf5\x8b\x03\xca\xfa" +
+	"\x8a\x03\xca\xfb\x8d\x03\xca\xf8\x8c\x03\xca\xf9\x8f\x03\xca\xfe\x8e\x03" +
+	"\xca\xff\x81\x03\xca\xfc\x80\x03\xca\xfd\x83\x03\xca\xe2\x82\x03\xca\xe3" +
+	"\x85\x03\xca\xe0\x84\x03\xca\xe1\x87\x03\xca\xe6\x86\x03\xca\xe7\x99\x03" +
+	"\xca\xe4\x98\x03\xca\xe5\x9b\x03\xca\xea\x9a\x03\xca\xeb\x9d\x03\xca\xe8" +
+	"\x9c\x03ؓ\x89\x03ߔ\x8b\x02\x010\x03\x03\x04\x1e\x03\x04\x15\x12\x03\x0b" +
+	"\x05,\x03\x06\x04\x00\x03\x06\x04)\x03\x06\x044\x03\x06\x04<\x03\x06\x05" +
+	"\x1d\x03\x06\x06\x00\x03\x06\x06\x0a\x03\x06\x06'\x03\x06\x062\x03\x0786" +
+	"\x03\x079/\x03\x079 \x03\x07:\x0e\x03\x07:\x1b\x03\x07:%\x03\x07;/\x03" +
+	"\x07;%\x03\x074\x11\x03\x076\x09\x03\x077*\x03\x070\x01\x03\x070\x0f\x03" +
+	"\x070.\x03\x071\x16\x03\x071\x04\x03\x0710\x03\x072\x18\x03\x072-\x03" +
+	"\x073\x14\x03\x073>\x03\x07'\x09\x03\x07 \x00\x03\x07\x1f\x0b\x03\x07" +
+	"\x18#\x03\x07\x18(\x03\x07\x186\x03\x07\x18\x03\x03\x07\x19\x16\x03\x07" +
+	"\x116\x03\x07\x12'\x03\x07\x13\x10\x03\x07\x0c&\x03\x07\x0c\x08\x03\x07" +
+	"\x0c\x13\x03\x07\x0d\x02\x03\x07\x0d\x1c\x03\x07\x0b5\x03\x07\x0b\x0a" +
+	"\x03\x07\x0b\x01\x03\x07\x0b\x0f\x03\x07\x05\x00\x03\x07\x05\x09\x03\x07" +
+	"\x05\x0b\x03\x07\x07\x01\x03\x07\x07\x08\x03\x07\x00<\x03\x07\x00+\x03" +
+	"\x07\x01)\x03\x07\x01\x1b\x03\x07\x01\x08\x03\x07\x03?\x03\x0445\x03\x04" +
+	"4\x08\x03\x0454\x03\x04)/\x03\x04)5\x03\x04+\x05\x03\x04+\x14\x03\x04+ " +
+	"\x03\x04+<\x03\x04*&\x03\x04*\x22\x03\x04&8\x03\x04!\x01\x03\x04!\x22" +
+	"\x03\x04\x11+\x03\x04\x10.\x03\x04\x104\x03\x04\x13=\x03\x04\x12\x04\x03" +
+	"\x04\x12\x0a\x03\x04\x0d\x1d\x03\x04\x0d\x07\x03\x04\x0d \x03\x05<>\x03" +
+	"\x055<\x03\x055!\x03\x055#\x03\x055&\x03\x054\x1d\x03\x054\x02\x03\x054" +
+	"\x07\x03\x0571\x03\x053\x1a\x03\x053\x16\x03\x05.<\x03\x05.\x07\x03\x05)" +
+	":\x03\x05)<\x03\x05)\x0c\x03\x05)\x15\x03\x05+-\x03\x05+5\x03\x05$\x1e" +
+	"\x03\x05$\x14\x03\x05'\x04\x03\x05'\x14\x03\x05&\x02\x03\x05\x226\x03" +
+	"\x05\x22\x0c\x03\x05\x22\x1c\x03\x05\x19\x0a\x03\x05\x1b\x09\x03\x05\x1b" +
+	"\x0c\x03\x05\x14\x07\x03\x05\x16?\x03\x05\x16\x0c\x03\x05\x0c\x05\x03" +
+	"\x05\x0e\x0f\x03\x05\x01\x0e\x03\x05\x00(\x03\x05\x030\x03\x05\x03\x06" +
+	"\x03\x0a==\x03\x0a=1\x03\x0a=,\x03\x0a=\x0c\x03\x0a??\x03\x0a<\x08\x03" +
+	"\x0a9!\x03\x0a9)\x03\x0a97\x03\x0a99\x03\x0a6\x0a\x03\x0a6\x1c\x03\x0a6" +
+	"\x17\x03\x0a7'\x03\x0a78\x03\x0a73\x03\x0a'\x01\x03\x0a'&\x03\x0a\x1f" +
+	"\x0e\x03\x0a\x1f\x03\x03\x0a\x1f3\x03\x0a\x1b/\x03\x0a\x18\x19\x03\x0a" +
+	"\x19\x01\x03\x0a\x16\x14\x03\x0a\x0e\x22\x03\x0a\x0f\x10\x03\x0a\x0f\x02" +
+	"\x03\x0a\x0f \x03\x0a\x0c\x04\x03\x0a\x0b>\x03\x0a\x0b+\x03\x0a\x08/\x03" +
+	"\x0a\x046\x03\x0a\x05\x14\x03\x0a\x00\x04\x03\x0a\x00\x10\x03\x0a\x00" +
+	"\x14\x03\x0b<3\x03\x0b;*\x03\x0b9\x22\x03\x0b9)\x03\x0b97\x03\x0b+\x10" +
+	"\x03\x0b((\x03\x0b&5\x03\x0b$\x1c\x03\x0b$\x12\x03\x0b%\x04\x03\x0b#<" +
+	"\x03\x0b#0\x03\x0b#\x0d\x03\x0b#\x19\x03\x0b!:\x03\x0b!\x1f\x03\x0b!\x00" +
+	"\x03\x0b\x1e5\x03\x0b\x1c\x1d\x03\x0b\x1d-\x03\x0b\x1d(\x03\x0b\x18.\x03" +
+	"\x0b\x18 \x03\x0b\x18\x16\x03\x0b\x14\x13\x03\x0b\x15$\x03\x0b\x15\x22" +
+	"\x03\x0b\x12\x1b\x03\x0b\x12\x10\x03\x0b\x132\x03\x0b\x13=\x03\x0b\x12" +
+	"\x18\x03\x0b\x0c&\x03\x0b\x061\x03\x0b\x06:\x03\x0b\x05#\x03\x0b\x05<" +
+	"\x03\x0b\x04\x0b\x03\x0b\x04\x04\x03\x0b\x04\x1b\x03\x0b\x042\x03\x0b" +
+	"\x041\x03\x0b\x03\x03\x03\x0b\x03\x1d\x03\x0b\x03/\x03\x0b\x03+\x03\x0b" +
+	"\x02\x1b\x03\x0b\x02\x00\x03\x0b\x01\x1e\x03\x0b\x01\x08\x03\x0b\x015" +
+	"\x03\x06\x0d9\x03\x06\x0d=\x03\x06\x0d?\x03\x02\x001\x03\x02\x003\x03" +
+	"\x02\x02\x19\x03\x02\x006\x03\x02\x02\x1b\x03\x02\x004\x03\x02\x00<\x03" +
+	"\x02\x02\x0a\x03\x02\x02\x0e\x03\x02\x01\x1a\x03\x02\x01\x07\x03\x02\x01" +
+	"\x05\x03\x02\x01\x0b\x03\x02\x01%\x03\x02\x01\x0c\x03\x02\x01\x04\x03" +
+	"\x02\x01\x1c\x03\x02\x00.\x03\x02\x002\x03\x02\x00>\x03\x02\x00\x12\x03" +
+	"\x02\x00\x16\x03\x02\x011\x03\x02\x013\x03\x02\x02 \x03\x02\x02%\x03\x02" +
+	"\x02$\x03\x02\x028\x03\x02\x02;\x03\x02\x024\x03\x02\x012\x03\x02\x022" +
+	"\x03\x02\x02/\x03\x02\x01,\x03\x02\x01\x13\x03\x02\x01\x16\x03\x02\x01" +
+	"\x11\x03\x02\x01\x1e\x03\x02\x01\x15\x03\x02\x01\x17\x03\x02\x01\x0f\x03" +
+	"\x02\x01\x08\x03\x02\x00?\x03\x02\x03\x07\x03\x02\x03\x0d\x03\x02\x03" +
+	"\x13\x03\x02\x03\x1d\x03\x02\x03\x1f\x03\x02\x00\x03\x03\x02\x00\x0d\x03" +
+	"\x02\x00\x01\x03\x02\x00\x1b\x03\x02\x00\x19\x03\x02\x00\x18\x03\x02\x00" +
+	"\x13\x03\x02\x00/\x03\x07>\x12\x03\x07<\x1f\x03\x07>\x1d\x03\x06\x1d\x0e" +
+	"\x03\x07>\x1c\x03\x07>:\x03\x07>\x13\x03\x04\x12+\x03\x07?\x03\x03\x07>" +
+	"\x02\x03\x06\x224\x03\x06\x1a.\x03\x07<%\x03\x06\x1c\x0b\x03\x0609\x03" +
+	"\x05\x1f\x01\x03\x04'\x08\x03\x93\xfd\xf5\x03\x02\x0d \x03\x02\x0d#\x03" +
+	"\x02\x0d!\x03\x02\x0d&\x03\x02\x0d\x22\x03\x02\x0d/\x03\x02\x0d,\x03\x02" +
+	"\x0d$\x03\x02\x0d'\x03\x02\x0d%\x03\x02\x0d;\x03\x02\x0d=\x03\x02\x0d?" +
+	"\x03\x099.\x03\x08\x0b7\x03\x08\x02\x14\x03\x08\x14\x0d\x03\x08.:\x03" +
+	"\x089'\x03\x0f\x0b\x18\x03\x0f\x1c1\x03\x0f\x17&\x03\x0f9\x1f\x03\x0f0" +
+	"\x0c\x03\x0e\x0a9\x03\x0e\x056\x03\x0e\x1c#\x03\x0f\x13\x0e\x03\x072\x00" +
+	"\x03\x070\x0d\x03\x072\x0b\x03\x06\x11\x18\x03\x070\x10\x03\x06\x0f(\x03" +
+	"\x072\x05\x03\x06\x0f,\x03\x073\x15\x03\x06\x07\x08\x03\x05\x16\x02\x03" +
+	"\x04\x0b \x03\x05:8\x03\x05\x16%\x03\x0a\x0d\x1f\x03\x06\x16\x10\x03\x05" +
+	"\x1d5\x03\x05*;\x03\x05\x16\x1b\x03\x04.-\x03\x06\x1a\x19\x03\x04\x03," +
+	"\x03\x0b87\x03\x04/\x0a\x03\x06\x00,\x03\x04-\x01\x03\x04\x1e-\x03\x06/(" +
+	"\x03\x0a\x0b5\x03\x06\x0e7\x03\x06\x07.\x03\x0597\x03\x0a*%\x03\x0760" +
+	"\x03\x06\x0c;\x03\x05'\x00\x03\x072.\x03\x072\x08\x03\x06=\x01\x03\x06" +
+	"\x05\x1b\x03\x06\x06\x12\x03\x06$=\x03\x06'\x0d\x03\x04\x11\x0f\x03\x076" +
+	",\x03\x06\x07;\x03\x06.,\x03\x86\xf9\xea\x03\x8f\xff\xeb\x02\x092\x02" +
+	"\x095\x02\x094\x02\x09;\x02\x09>\x02\x098\x02\x09*\x02\x09/\x02\x09,\x02" +
+	"\x09%\x02\x09&\x02\x09#\x02\x09 \x02\x08!\x02\x08%\x02\x08$\x02\x08+\x02" +
+	"\x08.\x02\x08*\x02\x08&\x02\x088\x02\x08>\x02\x084\x02\x086\x02\x080\x02" +
+	"\x08\x10\x02\x08\x17\x02\x08\x12\x02\x08\x1d\x02\x08\x1f\x02\x08\x13\x02" +
+	"\x08\x15\x02\x08\x14\x02\x08\x0c\x03\x8b\xfd\xd0\x03\x81\xec\xc6\x03\x87" +
+	"\xe0\x8a\x03-2\xe3\x03\x80\xef\xe4\x03-2\xea\x03\x88\xe6\xeb\x03\x8e\xe6" +
+	"\xe8\x03\x84\xe6\xe9\x03\x97\xe6\xee\x03-2\xf9\x03-2\xf6\x03\x8e\xe3\xad" +
+	"\x03\x80\xe3\x92\x03\x88\xe3\x90\x03\x8e\xe3\x90\x03\x80\xe3\x97\x03\x88" +
+	"\xe3\x95\x03\x88\xfe\xcb\x03\x8e\xfe\xca\x03\x84\xfe\xcd\x03\x91\xef\xc9" +
+	"\x03-2\xc1\x03-2\xc0\x03-2\xcb\x03\x88@\x09\x03\x8e@\x08\x03\x8f\xe0\xf5" +
+	"\x03\x8e\xe6\xf9\x03\x8e\xe0\xfa\x03\x93\xff\xf4\x03\x84\xee\xd3\x03\x0b" +
+	"(\x04\x023 \x021;\x02\x01*\x03\x0b#\x10\x03\x0b 0\x03\x0b!\x10\x03\x0b!0" +
+	"\x03\x07\x15\x08\x03\x09?5\x03\x07\x1f\x08\x03\x07\x17\x0b\x03\x09\x1f" +
+	"\x15\x03\x0b\x1c7\x03\x0a+#\x03\x06\x1a\x1b\x03\x06\x1a\x14\x03\x0a\x01" +
+	"\x18\x03\x06#\x1b\x03\x0a2\x0c\x03\x0a\x01\x04\x03\x09#;\x03\x08='\x03" +
+	"\x08\x1a\x0a\x03\x07\x03\x0a\x111\x03\x09\x1b\x09\x03\x073.\x03\x07\x01\x00" +
+	"\x03\x09/,\x03\x07#>\x03\x07\x048\x03\x0a\x1f\x22\x03\x098>\x03\x09\x11" +
+	"\x00\x03\x08/\x17\x03\x06'\x22\x03\x0b\x1a+\x03\x0a\x22\x19\x03\x0a/1" +
+	"\x03\x0974\x03\x09\x0f\x22\x03\x08,\x22\x03\x08?\x14\x03\x07$5\x03\x07<3" +
+	"\x03\x07=*\x03\x07\x13\x18\x03\x068\x0a\x03\x06\x09\x16\x03\x06\x13\x00" +
+	"\x03\x08\x067\x03\x08\x01\x03\x03\x08\x12\x1d\x03\x07+7\x03\x06(;\x03" +
+	"\x06\x1c?\x03\x07\x0e\x17\x03\x0a\x06\x1d\x03\x0a\x19\x07\x03\x08\x14$" +
+	"\x03\x07$;\x03\x08,$\x03\x08\x06\x0d\x03\x07\x16\x0a\x03\x06>>\x03\x0a" +
+	"\x06\x12\x03\x0a\x14)\x03\x09\x0d\x1f\x03\x09\x12\x17\x03\x09\x19\x01" +
+	"\x03\x08\x11 \x03\x08\x1d'\x03\x06<\x1a\x03\x0a.\x00\x03\x07'\x18\x03" +
+	"\x0a\x22\x08\x03\x08\x0d\x0a\x03\x08\x13)\x03\x07*)\x03\x06<,\x03\x07" +
+	"\x0b\x1a\x03\x09.\x14\x03\x09\x0d\x1e\x03\x07\x0e#\x03\x0b\x1d'\x03\x0a" +
+	"\x0a8\x03\x09%2\x03\x08+&\x03\x080\x12\x03\x0a)4\x03\x08\x06\x1f\x03\x0b" +
+	"\x1b\x1a\x03\x0a\x1b\x0f\x03\x0b\x1d*\x03\x09\x16$\x03\x090\x11\x03\x08" +
+	"\x11\x08\x03\x0a*(\x03\x0a\x042\x03\x089,\x03\x074'\x03\x07\x0f\x05\x03" +
+	"\x09\x0b\x0a\x03\x07\x1b\x01\x03\x09\x17:\x03\x09.\x0d\x03\x07.\x11\x03" +
+	"\x09+\x15\x03\x080\x13\x03\x0b\x1f\x19\x03\x0a \x11\x03\x0a\x220\x03\x09" +
+	"\x07;\x03\x08\x16\x1c\x03\x07,\x13\x03\x07\x0e/\x03\x06\x221\x03\x0a." +
+	"\x0a\x03\x0a7\x02\x03\x0a\x032\x03\x0a\x1d.\x03\x091\x06\x03\x09\x19:" +
+	"\x03\x08\x02/\x03\x060+\x03\x06\x0f-\x03\x06\x1c\x1f\x03\x06\x1d\x07\x03" +
+	"\x0a,\x11\x03\x09=\x0d\x03\x09\x0b;\x03\x07\x1b/\x03\x0a\x1f:\x03\x09 " +
+	"\x1f\x03\x09.\x10\x03\x094\x0b\x03\x09\x1a1\x03\x08#\x1a\x03\x084\x1d" +
+	"\x03\x08\x01\x1f\x03\x08\x11\x22\x03\x07'8\x03\x07\x1a>\x03\x0757\x03" +
+	"\x06&9\x03\x06+\x11\x03\x0a.\x0b\x03\x0a,>\x03\x0a4#\x03\x08%\x17\x03" +
+	"\x07\x05\x22\x03\x07\x0c\x0b\x03\x0a\x1d+\x03\x0a\x19\x16\x03\x09+\x1f" +
+	"\x03\x09\x08\x0b\x03\x08\x16\x18\x03\x08+\x12\x03\x0b\x1d\x0c\x03\x0a=" +
+	"\x10\x03\x0a\x09\x0d\x03\x0a\x10\x11\x03\x09&0\x03\x08(\x1f\x03\x087\x07" +
+	"\x03\x08\x185\x03\x07'6\x03\x06.\x05\x03\x06=\x04\x03\x06;;\x03\x06\x06," +
+	"\x03\x0b\x18>\x03\x08\x00\x18\x03\x06 \x03\x03\x06<\x00\x03\x09%\x18\x03" +
+	"\x0b\x1c<\x03\x0a%!\x03\x0a\x09\x12\x03\x0a\x16\x02\x03\x090'\x03\x09" +
+	"\x0e=\x03\x08 \x0e\x03\x08>\x03\x03\x074>\x03\x06&?\x03\x06\x19\x09\x03" +
+	"\x06?(\x03\x0a-\x0e\x03\x09:3\x03\x098:\x03\x09\x12\x0b\x03\x09\x1d\x17" +
+	"\x03\x087\x05\x03\x082\x14\x03\x08\x06%\x03\x08\x13\x1f\x03\x06\x06\x0e" +
+	"\x03\x0a\x22<\x03\x09/<\x03\x06>+\x03\x0a'?\x03\x0a\x13\x0c\x03\x09\x10<" +
+	"\x03\x07\x1b=\x03\x0a\x19\x13\x03\x09\x22\x1d\x03\x09\x07\x0d\x03\x08)" +
+	"\x1c\x03\x06=\x1a\x03\x0a/4\x03\x0a7\x11\x03\x0a\x16:\x03\x09?3\x03\x09:" +
+	"/\x03\x09\x05\x0a\x03\x09\x14\x06\x03\x087\x22\x03\x080\x07\x03\x08\x1a" +
+	"\x1f\x03\x07\x04(\x03\x07\x04\x09\x03\x06 %\x03\x06<\x08\x03\x0a+\x14" +
+	"\x03\x09\x1d\x16\x03\x0a70\x03\x08 >\x03\x0857\x03\x070\x0a\x03\x06=\x12" +
+	"\x03\x06\x16%\x03\x06\x1d,\x03\x099#\x03\x09\x10>\x03\x07 \x1e\x03\x08" +
+	"\x0c<\x03\x08\x0b\x18\x03\x08\x15+\x03\x08,:\x03\x08%\x22\x03\x07\x0a$" +
+	"\x03\x0b\x1c=\x03\x07+\x08\x03\x0a/\x05\x03\x0a \x07\x03\x0a\x12'\x03" +
+	"\x09#\x11\x03\x08\x1b\x15\x03\x0a\x06\x01\x03\x09\x1c\x1b\x03\x0922\x03" +
+	"\x07\x14<\x03\x07\x09\x04\x03\x061\x04\x03\x07\x0e\x01\x03\x0a\x13\x18" +
+	"\x03\x0a-\x0c\x03\x0a?\x0d\x03\x0a\x09\x0a\x03\x091&\x03\x0a/\x0b\x03" +
+	"\x08$<\x03\x083\x1d\x03\x08\x0c$\x03\x08\x0d\x07\x03\x08\x0d?\x03\x08" +
+	"\x0e\x14\x03\x065\x0a\x03\x08\x1a#\x03\x08\x16#\x03\x0702\x03\x07\x03" +
+	"\x1a\x03\x06(\x1d\x03\x06+\x1b\x03\x06\x0b\x05\x03\x06\x0b\x17\x03\x06" +
+	"\x0c\x04\x03\x06\x1e\x19\x03\x06+0\x03\x062\x18\x03\x0b\x16\x1e\x03\x0a+" +
+	"\x16\x03\x0a-?\x03\x0a#:\x03\x0a#\x10\x03\x0a%$\x03\x0a>+\x03\x0a01\x03" +
+	"\x0a1\x10\x03\x0a\x099\x03\x0a\x0a\x12\x03\x0a\x19\x1f\x03\x0a\x19\x12" +
+	"\x03\x09*)\x03\x09-\x16\x03\x09.1\x03\x09.2\x03\x09<\x0e\x03\x09> \x03" +
+	"\x093\x12\x03\x09\x0b\x01\x03\x09\x1c2\x03\x09\x11\x1c\x03\x09\x15%\x03" +
+	"\x08,&\x03\x08!\x22\x03\x089(\x03\x08\x0b\x1a\x03\x08\x0d2\x03\x08\x0c" +
+	"\x04\x03\x08\x0c\x06\x03\x08\x0c\x1f\x03\x08\x0c\x0c\x03\x08\x0f\x1f\x03" +
+	"\x08\x0f\x1d\x03\x08\x00\x14\x03\x08\x03\x14\x03\x08\x06\x16\x03\x08\x1e" +
+	"#\x03\x08\x11\x11\x03\x08\x10\x18\x03\x08\x14(\x03\x07)\x1e\x03\x07.1" +
+	"\x03\x07 $\x03\x07 '\x03\x078\x08\x03\x07\x0d0\x03\x07\x0f7\x03\x07\x05#" +
+	"\x03\x07\x05\x1a\x03\x07\x1a7\x03\x07\x1d-\x03\x07\x17\x10\x03\x06)\x1f" +
+	"\x03\x062\x0b\x03\x066\x16\x03\x06\x09\x11\x03\x09(\x1e\x03\x07!5\x03" +
+	"\x0b\x11\x16\x03\x0a/\x04\x03\x0a,\x1a\x03\x0b\x173\x03\x0a,1\x03\x0a/5" +
+	"\x03\x0a\x221\x03\x0a\x22\x0d\x03\x0a?%\x03\x0a<,\x03\x0a?#\x03\x0a>\x19" +
+	"\x03\x0a\x08&\x03\x0a\x0b\x0e\x03\x0a\x0c:\x03\x0a\x0c+\x03\x0a\x03\x22" +
+	"\x03\x0a\x06)\x03\x0a\x11\x10\x03\x0a\x11\x1a\x03\x0a\x17-\x03\x0a\x14(" +
+	"\x03\x09)\x1e\x03\x09/\x09\x03\x09.\x00\x03\x09,\x07\x03\x09/*\x03\x09-9" +
+	"\x03\x09\x228\x03\x09%\x09\x03\x09:\x12\x03\x09;\x1d\x03\x09?\x06\x03" +
+	"\x093%\x03\x096\x05\x03\x096\x08\x03\x097\x02\x03\x09\x07,\x03\x09\x04," +
+	"\x03\x09\x1f\x16\x03\x09\x11\x03\x03\x09\x11\x12\x03\x09\x168\x03\x08*" +
+	"\x05\x03\x08/2\x03\x084:\x03\x08\x22+\x03\x08 0\x03\x08&\x0a\x03\x08;" +
+	"\x10\x03\x08>$\x03\x08>\x18\x03\x0829\x03\x082:\x03\x081,\x03\x081<\x03" +
+	"\x081\x1c\x03\x087#\x03\x087*\x03\x08\x09'\x03\x08\x00\x1d\x03\x08\x05-" +
+	"\x03\x08\x1f4\x03\x08\x1d\x04\x03\x08\x16\x0f\x03\x07*7\x03\x07'!\x03" +
+	"\x07%\x1b\x03\x077\x0c\x03\x07\x0c1\x03\x07\x0c.\x03\x07\x00\x06\x03\x07" +
+	"\x01\x02\x03\x07\x010\x03\x07\x06=\x03\x07\x01\x03\x03\x07\x01\x13\x03" +
+	"\x07\x06\x06\x03\x07\x05\x0a\x03\x07\x1f\x09\x03\x07\x17:\x03\x06*1\x03" +
+	"\x06-\x1d\x03\x06\x223\x03\x062:\x03\x060$\x03\x066\x1e\x03\x064\x12\x03" +
+	"\x0645\x03\x06\x0b\x00\x03\x06\x0b7\x03\x06\x07\x1f\x03\x06\x15\x12\x03" +
+	"\x0c\x05\x0f\x03\x0b+\x0b\x03\x0b+-\x03\x06\x16\x1b\x03\x06\x15\x17\x03" +
+	"\x89\xca\xea\x03\x89\xca\xe8\x03\x0c8\x10\x03\x0c8\x01\x03\x0c8\x0f\x03" +
+	"\x0d8%\x03\x0d8!\x03\x0c8-\x03\x0c8/\x03\x0c8+\x03\x0c87\x03\x0c85\x03" +
+	"\x0c9\x09\x03\x0c9\x0d\x03\x0c9\x0f\x03\x0c9\x0b\x03\xcfu\x0c\x03\xcfu" +
+	"\x0f\x03\xcfu\x0e\x03\xcfu\x09\x03\x0c9\x10\x03\x0d9\x0c\x03\xcf`;\x03" +
+	"\xcf`>\x03\xcf`9\x03\xcf`8\x03\xcf`7\x03\xcf`*\x03\xcf`-\x03\xcf`,\x03" +
+	"\x0d\x1b\x1a\x03\x0d\x1b&\x03\x0c=.\x03\x0c=%\x03\x0c>\x1e\x03\x0c>\x14" +
+	"\x03\x0c?\x06\x03\x0c?\x0b\x03\x0c?\x0c\x03\x0c?\x0d\x03\x0c?\x02\x03" +
+	"\x0c>\x0f\x03\x0c>\x08\x03\x0c>\x09\x03\x0c>,\x03\x0c>\x0c\x03\x0c?\x13" +
+	"\x03\x0c?\x16\x03\x0c?\x15\x03\x0c?\x1c\x03\x0c?\x1f\x03\x0c?\x1d\x03" +
+	"\x0c?\x1a\x03\x0c?\x17\x03\x0c?\x08\x03\x0c?\x09\x03\x0c?\x0e\x03\x0c?" +
+	"\x04\x03\x0c?\x05\x03\x0c" +
+	"\x03\x0c=2\x03\x0c=6\x03\x0c<\x07\x03\x0c<\x05\x03\x0e:!\x03\x0e:#\x03" +
+	"\x0e8\x09\x03\x0e:&\x03\x0e8\x0b\x03\x0e:$\x03\x0e:,\x03\x0e8\x1a\x03" +
+	"\x0e8\x1e\x03\x0e:*\x03\x0e:7\x03\x0e:5\x03\x0e:;\x03\x0e:\x15\x03\x0e:<" +
+	"\x03\x0e:4\x03\x0e:'\x03\x0e:-\x03\x0e:%\x03\x0e:?\x03\x0e:=\x03\x0e:)" +
+	"\x03\x0e:/\x03\xcfs'\x03\x0d=\x0f\x03\x0d+*\x03\x0d99\x03\x0d9;\x03\x0d9" +
+	"?\x03\x0d)\x0d\x03\x0d(%\x02\x01\x18\x02\x01(\x02\x01\x1e\x03\x0f$!\x03" +
+	"\x0f87\x03\x0f4\x0e\x03\x0f5\x1d\x03\x06'\x03\x03\x0f\x08\x18\x03\x0f" +
+	"\x0d\x1b\x03\x0e2=\x03\x0e;\x08\x03\x0e:\x0b\x03\x0e\x06$\x03\x0e\x0d)" +
+	"\x03\x0e\x16\x1f\x03\x0e\x16\x1b\x03\x0d$\x0a\x03\x05,\x1d\x03\x0d. \x03" +
+	"\x0d.#\x03\x0c(/\x03\x09%\x02\x03\x0d90\x03\x0d\x0e4\x03\x0d\x0d\x0f\x03" +
+	"\x0c#\x00\x03\x0c,\x1e\x03\x0c2\x0e\x03\x0c\x01\x17\x03\x0c\x09:\x03\x0e" +
+	"\x173\x03\x0c\x08\x03\x03\x0c\x11\x07\x03\x0c\x10\x18\x03\x0c\x1f\x1c" +
+	"\x03\x0c\x19\x0e\x03\x0c\x1a\x1f\x03\x0f0>\x03\x0b->\x03\x0b<+\x03\x0b8" +
+	"\x13\x03\x0b\x043\x03\x0b\x14\x03\x03\x0b\x16%\x03\x0d\x22&\x03\x0b\x1a" +
+	"\x1a\x03\x0b\x1a\x04\x03\x0a%9\x03\x0a&2\x03\x0a&0\x03\x0a!\x1a\x03\x0a!" +
+	"7\x03\x0a5\x10\x03\x0a=4\x03\x0a?\x0e\x03\x0a>\x10\x03\x0a\x00 \x03\x0a" +
+	"\x0f:\x03\x0a\x0f9\x03\x0a\x0b\x0a\x03\x0a\x17%\x03\x0a\x1b-\x03\x09-" +
+	"\x1a\x03\x09,4\x03\x09.,\x03\x09)\x09\x03\x096!\x03\x091\x1f\x03\x093" +
+	"\x16\x03\x0c+\x1f\x03\x098 \x03\x098=\x03\x0c(\x1a\x03\x0c(\x16\x03\x09" +
+	"\x0a+\x03\x09\x16\x12\x03\x09\x13\x0e\x03\x09\x153\x03\x08)!\x03\x09\x1a" +
+	"\x01\x03\x09\x18\x01\x03\x08%#\x03\x08>\x22\x03\x08\x05%\x03\x08\x02*" +
+	"\x03\x08\x15;\x03\x08\x1b7\x03\x0f\x07\x1d\x03\x0f\x04\x03\x03\x070\x0c" +
+	"\x03\x07;\x0b\x03\x07\x08\x17\x03\x07\x12\x06\x03\x06/-\x03\x0671\x03" +
+	"\x065+\x03\x06>7\x03\x06\x049\x03\x05+\x1e\x03\x05,\x17\x03\x05 \x1d\x03" +
+	"\x05\x22\x05\x03\x050\x1d"
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *idnaTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return idnaValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = idnaIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = idnaIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = idnaIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *idnaTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return idnaValues[c0]
+	}
+	i := idnaIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = idnaIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = idnaIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *idnaTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return idnaValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = idnaIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := idnaIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = idnaIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = idnaIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *idnaTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return idnaValues[c0]
+	}
+	i := idnaIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = idnaIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = idnaIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// idnaTrie. Total size: 29052 bytes (28.37 KiB). Checksum: ef06e7ecc26f36dd.
+type idnaTrie struct{}
+
+func newIdnaTrie(i int) *idnaTrie {
+	return &idnaTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *idnaTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 125:
+		return uint16(idnaValues[n<<6+uint32(b)])
+	default:
+		n -= 125
+		return uint16(idnaSparse.lookup(n, b))
+	}
+}
+
+// idnaValues: 127 blocks, 8128 entries, 16256 bytes
+// The third block is the zero block.
+var idnaValues = [8128]uint16{
+	// Block 0x0, offset 0x0
+	0x00: 0x0080, 0x01: 0x0080, 0x02: 0x0080, 0x03: 0x0080, 0x04: 0x0080, 0x05: 0x0080,
+	0x06: 0x0080, 0x07: 0x0080, 0x08: 0x0080, 0x09: 0x0080, 0x0a: 0x0080, 0x0b: 0x0080,
+	0x0c: 0x0080, 0x0d: 0x0080, 0x0e: 0x0080, 0x0f: 0x0080, 0x10: 0x0080, 0x11: 0x0080,
+	0x12: 0x0080, 0x13: 0x0080, 0x14: 0x0080, 0x15: 0x0080, 0x16: 0x0080, 0x17: 0x0080,
+	0x18: 0x0080, 0x19: 0x0080, 0x1a: 0x0080, 0x1b: 0x0080, 0x1c: 0x0080, 0x1d: 0x0080,
+	0x1e: 0x0080, 0x1f: 0x0080, 0x20: 0x0080, 0x21: 0x0080, 0x22: 0x0080, 0x23: 0x0080,
+	0x24: 0x0080, 0x25: 0x0080, 0x26: 0x0080, 0x27: 0x0080, 0x28: 0x0080, 0x29: 0x0080,
+	0x2a: 0x0080, 0x2b: 0x0080, 0x2c: 0x0080, 0x2d: 0x0008, 0x2e: 0x0008, 0x2f: 0x0080,
+	0x30: 0x0008, 0x31: 0x0008, 0x32: 0x0008, 0x33: 0x0008, 0x34: 0x0008, 0x35: 0x0008,
+	0x36: 0x0008, 0x37: 0x0008, 0x38: 0x0008, 0x39: 0x0008, 0x3a: 0x0080, 0x3b: 0x0080,
+	0x3c: 0x0080, 0x3d: 0x0080, 0x3e: 0x0080, 0x3f: 0x0080,
+	// Block 0x1, offset 0x40
+	0x40: 0x0080, 0x41: 0xe105, 0x42: 0xe105, 0x43: 0xe105, 0x44: 0xe105, 0x45: 0xe105,
+	0x46: 0xe105, 0x47: 0xe105, 0x48: 0xe105, 0x49: 0xe105, 0x4a: 0xe105, 0x4b: 0xe105,
+	0x4c: 0xe105, 0x4d: 0xe105, 0x4e: 0xe105, 0x4f: 0xe105, 0x50: 0xe105, 0x51: 0xe105,
+	0x52: 0xe105, 0x53: 0xe105, 0x54: 0xe105, 0x55: 0xe105, 0x56: 0xe105, 0x57: 0xe105,
+	0x58: 0xe105, 0x59: 0xe105, 0x5a: 0xe105, 0x5b: 0x0080, 0x5c: 0x0080, 0x5d: 0x0080,
+	0x5e: 0x0080, 0x5f: 0x0080, 0x60: 0x0080, 0x61: 0x0008, 0x62: 0x0008, 0x63: 0x0008,
+	0x64: 0x0008, 0x65: 0x0008, 0x66: 0x0008, 0x67: 0x0008, 0x68: 0x0008, 0x69: 0x0008,
+	0x6a: 0x0008, 0x6b: 0x0008, 0x6c: 0x0008, 0x6d: 0x0008, 0x6e: 0x0008, 0x6f: 0x0008,
+	0x70: 0x0008, 0x71: 0x0008, 0x72: 0x0008, 0x73: 0x0008, 0x74: 0x0008, 0x75: 0x0008,
+	0x76: 0x0008, 0x77: 0x0008, 0x78: 0x0008, 0x79: 0x0008, 0x7a: 0x0008, 0x7b: 0x0080,
+	0x7c: 0x0080, 0x7d: 0x0080, 0x7e: 0x0080, 0x7f: 0x0080,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x0040, 0xc1: 0x0040, 0xc2: 0x0040, 0xc3: 0x0040, 0xc4: 0x0040, 0xc5: 0x0040,
+	0xc6: 0x0040, 0xc7: 0x0040, 0xc8: 0x0040, 0xc9: 0x0040, 0xca: 0x0040, 0xcb: 0x0040,
+	0xcc: 0x0040, 0xcd: 0x0040, 0xce: 0x0040, 0xcf: 0x0040, 0xd0: 0x0040, 0xd1: 0x0040,
+	0xd2: 0x0040, 0xd3: 0x0040, 0xd4: 0x0040, 0xd5: 0x0040, 0xd6: 0x0040, 0xd7: 0x0040,
+	0xd8: 0x0040, 0xd9: 0x0040, 0xda: 0x0040, 0xdb: 0x0040, 0xdc: 0x0040, 0xdd: 0x0040,
+	0xde: 0x0040, 0xdf: 0x0040, 0xe0: 0x000a, 0xe1: 0x0018, 0xe2: 0x0018, 0xe3: 0x0018,
+	0xe4: 0x0018, 0xe5: 0x0018, 0xe6: 0x0018, 0xe7: 0x0018, 0xe8: 0x001a, 0xe9: 0x0018,
+	0xea: 0x0039, 0xeb: 0x0018, 0xec: 0x0018, 0xed: 0x03c0, 0xee: 0x0018, 0xef: 0x004a,
+	0xf0: 0x0018, 0xf1: 0x0018, 0xf2: 0x0069, 0xf3: 0x0079, 0xf4: 0x008a, 0xf5: 0x0005,
+	0xf6: 0x0018, 0xf7: 0x0008, 0xf8: 0x00aa, 0xf9: 0x00c9, 0xfa: 0x00d9, 0xfb: 0x0018,
+	0xfc: 0x00e9, 0xfd: 0x0119, 0xfe: 0x0149, 0xff: 0x0018,
+	// Block 0x4, offset 0x100
+	0x100: 0xe00d, 0x101: 0x0008, 0x102: 0xe00d, 0x103: 0x0008, 0x104: 0xe00d, 0x105: 0x0008,
+	0x106: 0xe00d, 0x107: 0x0008, 0x108: 0xe00d, 0x109: 0x0008, 0x10a: 0xe00d, 0x10b: 0x0008,
+	0x10c: 0xe00d, 0x10d: 0x0008, 0x10e: 0xe00d, 0x10f: 0x0008, 0x110: 0xe00d, 0x111: 0x0008,
+	0x112: 0xe00d, 0x113: 0x0008, 0x114: 0xe00d, 0x115: 0x0008, 0x116: 0xe00d, 0x117: 0x0008,
+	0x118: 0xe00d, 0x119: 0x0008, 0x11a: 0xe00d, 0x11b: 0x0008, 0x11c: 0xe00d, 0x11d: 0x0008,
+	0x11e: 0xe00d, 0x11f: 0x0008, 0x120: 0xe00d, 0x121: 0x0008, 0x122: 0xe00d, 0x123: 0x0008,
+	0x124: 0xe00d, 0x125: 0x0008, 0x126: 0xe00d, 0x127: 0x0008, 0x128: 0xe00d, 0x129: 0x0008,
+	0x12a: 0xe00d, 0x12b: 0x0008, 0x12c: 0xe00d, 0x12d: 0x0008, 0x12e: 0xe00d, 0x12f: 0x0008,
+	0x130: 0x0179, 0x131: 0x0008, 0x132: 0x0035, 0x133: 0x004d, 0x134: 0xe00d, 0x135: 0x0008,
+	0x136: 0xe00d, 0x137: 0x0008, 0x138: 0x0008, 0x139: 0xe01d, 0x13a: 0x0008, 0x13b: 0xe03d,
+	0x13c: 0x0008, 0x13d: 0xe01d, 0x13e: 0x0008, 0x13f: 0x0199,
+	// Block 0x5, offset 0x140
+	0x140: 0x0199, 0x141: 0xe01d, 0x142: 0x0008, 0x143: 0xe03d, 0x144: 0x0008, 0x145: 0xe01d,
+	0x146: 0x0008, 0x147: 0xe07d, 0x148: 0x0008, 0x149: 0x01b9, 0x14a: 0xe00d, 0x14b: 0x0008,
+	0x14c: 0xe00d, 0x14d: 0x0008, 0x14e: 0xe00d, 0x14f: 0x0008, 0x150: 0xe00d, 0x151: 0x0008,
+	0x152: 0xe00d, 0x153: 0x0008, 0x154: 0xe00d, 0x155: 0x0008, 0x156: 0xe00d, 0x157: 0x0008,
+	0x158: 0xe00d, 0x159: 0x0008, 0x15a: 0xe00d, 0x15b: 0x0008, 0x15c: 0xe00d, 0x15d: 0x0008,
+	0x15e: 0xe00d, 0x15f: 0x0008, 0x160: 0xe00d, 0x161: 0x0008, 0x162: 0xe00d, 0x163: 0x0008,
+	0x164: 0xe00d, 0x165: 0x0008, 0x166: 0xe00d, 0x167: 0x0008, 0x168: 0xe00d, 0x169: 0x0008,
+	0x16a: 0xe00d, 0x16b: 0x0008, 0x16c: 0xe00d, 0x16d: 0x0008, 0x16e: 0xe00d, 0x16f: 0x0008,
+	0x170: 0xe00d, 0x171: 0x0008, 0x172: 0xe00d, 0x173: 0x0008, 0x174: 0xe00d, 0x175: 0x0008,
+	0x176: 0xe00d, 0x177: 0x0008, 0x178: 0x0065, 0x179: 0xe01d, 0x17a: 0x0008, 0x17b: 0xe03d,
+	0x17c: 0x0008, 0x17d: 0xe01d, 0x17e: 0x0008, 0x17f: 0x01d9,
+	// Block 0x6, offset 0x180
+	0x180: 0x0008, 0x181: 0x007d, 0x182: 0xe00d, 0x183: 0x0008, 0x184: 0xe00d, 0x185: 0x0008,
+	0x186: 0x007d, 0x187: 0xe07d, 0x188: 0x0008, 0x189: 0x0095, 0x18a: 0x00ad, 0x18b: 0xe03d,
+	0x18c: 0x0008, 0x18d: 0x0008, 0x18e: 0x00c5, 0x18f: 0x00dd, 0x190: 0x00f5, 0x191: 0xe01d,
+	0x192: 0x0008, 0x193: 0x010d, 0x194: 0x0125, 0x195: 0x0008, 0x196: 0x013d, 0x197: 0x013d,
+	0x198: 0xe00d, 0x199: 0x0008, 0x19a: 0x0008, 0x19b: 0x0008, 0x19c: 0x010d, 0x19d: 0x0155,
+	0x19e: 0x0008, 0x19f: 0x016d, 0x1a0: 0xe00d, 0x1a1: 0x0008, 0x1a2: 0xe00d, 0x1a3: 0x0008,
+	0x1a4: 0xe00d, 0x1a5: 0x0008, 0x1a6: 0x0185, 0x1a7: 0xe07d, 0x1a8: 0x0008, 0x1a9: 0x019d,
+	0x1aa: 0x0008, 0x1ab: 0x0008, 0x1ac: 0xe00d, 0x1ad: 0x0008, 0x1ae: 0x0185, 0x1af: 0xe0fd,
+	0x1b0: 0x0008, 0x1b1: 0x01b5, 0x1b2: 0x01cd, 0x1b3: 0xe03d, 0x1b4: 0x0008, 0x1b5: 0xe01d,
+	0x1b6: 0x0008, 0x1b7: 0x01e5, 0x1b8: 0xe00d, 0x1b9: 0x0008, 0x1ba: 0x0008, 0x1bb: 0x0008,
+	0x1bc: 0xe00d, 0x1bd: 0x0008, 0x1be: 0x0008, 0x1bf: 0x0008,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x0008, 0x1c1: 0x0008, 0x1c2: 0x0008, 0x1c3: 0x0008, 0x1c4: 0x01e9, 0x1c5: 0x01e9,
+	0x1c6: 0x01e9, 0x1c7: 0x01fd, 0x1c8: 0x0215, 0x1c9: 0x022d, 0x1ca: 0x0245, 0x1cb: 0x025d,
+	0x1cc: 0x0275, 0x1cd: 0xe01d, 0x1ce: 0x0008, 0x1cf: 0xe0fd, 0x1d0: 0x0008, 0x1d1: 0xe01d,
+	0x1d2: 0x0008, 0x1d3: 0xe03d, 0x1d4: 0x0008, 0x1d5: 0xe01d, 0x1d6: 0x0008, 0x1d7: 0xe07d,
+	0x1d8: 0x0008, 0x1d9: 0xe01d, 0x1da: 0x0008, 0x1db: 0xe03d, 0x1dc: 0x0008, 0x1dd: 0x0008,
+	0x1de: 0xe00d, 0x1df: 0x0008, 0x1e0: 0xe00d, 0x1e1: 0x0008, 0x1e2: 0xe00d, 0x1e3: 0x0008,
+	0x1e4: 0xe00d, 0x1e5: 0x0008, 0x1e6: 0xe00d, 0x1e7: 0x0008, 0x1e8: 0xe00d, 0x1e9: 0x0008,
+	0x1ea: 0xe00d, 0x1eb: 0x0008, 0x1ec: 0xe00d, 0x1ed: 0x0008, 0x1ee: 0xe00d, 0x1ef: 0x0008,
+	0x1f0: 0x0008, 0x1f1: 0x028d, 0x1f2: 0x02a5, 0x1f3: 0x02bd, 0x1f4: 0xe00d, 0x1f5: 0x0008,
+	0x1f6: 0x02d5, 0x1f7: 0x02ed, 0x1f8: 0xe00d, 0x1f9: 0x0008, 0x1fa: 0xe00d, 0x1fb: 0x0008,
+	0x1fc: 0xe00d, 0x1fd: 0x0008, 0x1fe: 0xe00d, 0x1ff: 0x0008,
+	// Block 0x8, offset 0x200
+	0x200: 0xe00d, 0x201: 0x0008, 0x202: 0xe00d, 0x203: 0x0008, 0x204: 0xe00d, 0x205: 0x0008,
+	0x206: 0xe00d, 0x207: 0x0008, 0x208: 0xe00d, 0x209: 0x0008, 0x20a: 0xe00d, 0x20b: 0x0008,
+	0x20c: 0xe00d, 0x20d: 0x0008, 0x20e: 0xe00d, 0x20f: 0x0008, 0x210: 0xe00d, 0x211: 0x0008,
+	0x212: 0xe00d, 0x213: 0x0008, 0x214: 0xe00d, 0x215: 0x0008, 0x216: 0xe00d, 0x217: 0x0008,
+	0x218: 0xe00d, 0x219: 0x0008, 0x21a: 0xe00d, 0x21b: 0x0008, 0x21c: 0xe00d, 0x21d: 0x0008,
+	0x21e: 0xe00d, 0x21f: 0x0008, 0x220: 0x0305, 0x221: 0x0008, 0x222: 0xe00d, 0x223: 0x0008,
+	0x224: 0xe00d, 0x225: 0x0008, 0x226: 0xe00d, 0x227: 0x0008, 0x228: 0xe00d, 0x229: 0x0008,
+	0x22a: 0xe00d, 0x22b: 0x0008, 0x22c: 0xe00d, 0x22d: 0x0008, 0x22e: 0xe00d, 0x22f: 0x0008,
+	0x230: 0xe00d, 0x231: 0x0008, 0x232: 0xe00d, 0x233: 0x0008, 0x234: 0x0008, 0x235: 0x0008,
+	0x236: 0x0008, 0x237: 0x0008, 0x238: 0x0008, 0x239: 0x0008, 0x23a: 0x0209, 0x23b: 0xe03d,
+	0x23c: 0x0008, 0x23d: 0x031d, 0x23e: 0x0229, 0x23f: 0x0008,
+	// Block 0x9, offset 0x240
+	0x240: 0x0008, 0x241: 0x0008, 0x242: 0x0018, 0x243: 0x0018, 0x244: 0x0018, 0x245: 0x0018,
+	0x246: 0x0008, 0x247: 0x0008, 0x248: 0x0008, 0x249: 0x0008, 0x24a: 0x0008, 0x24b: 0x0008,
+	0x24c: 0x0008, 0x24d: 0x0008, 0x24e: 0x0008, 0x24f: 0x0008, 0x250: 0x0008, 0x251: 0x0008,
+	0x252: 0x0018, 0x253: 0x0018, 0x254: 0x0018, 0x255: 0x0018, 0x256: 0x0018, 0x257: 0x0018,
+	0x258: 0x029a, 0x259: 0x02ba, 0x25a: 0x02da, 0x25b: 0x02fa, 0x25c: 0x031a, 0x25d: 0x033a,
+	0x25e: 0x0018, 0x25f: 0x0018, 0x260: 0x03ad, 0x261: 0x0359, 0x262: 0x01d9, 0x263: 0x0369,
+	0x264: 0x03c5, 0x265: 0x0018, 0x266: 0x0018, 0x267: 0x0018, 0x268: 0x0018, 0x269: 0x0018,
+	0x26a: 0x0018, 0x26b: 0x0018, 0x26c: 0x0008, 0x26d: 0x0018, 0x26e: 0x0008, 0x26f: 0x0018,
+	0x270: 0x0018, 0x271: 0x0018, 0x272: 0x0018, 0x273: 0x0018, 0x274: 0x0018, 0x275: 0x0018,
+	0x276: 0x0018, 0x277: 0x0018, 0x278: 0x0018, 0x279: 0x0018, 0x27a: 0x0018, 0x27b: 0x0018,
+	0x27c: 0x0018, 0x27d: 0x0018, 0x27e: 0x0018, 0x27f: 0x0018,
+	// Block 0xa, offset 0x280
+	0x280: 0x03dd, 0x281: 0x03dd, 0x282: 0x3308, 0x283: 0x03f5, 0x284: 0x0379, 0x285: 0x040d,
+	0x286: 0x3308, 0x287: 0x3308, 0x288: 0x3308, 0x289: 0x3308, 0x28a: 0x3308, 0x28b: 0x3308,
+	0x28c: 0x3308, 0x28d: 0x3308, 0x28e: 0x3308, 0x28f: 0x33c0, 0x290: 0x3308, 0x291: 0x3308,
+	0x292: 0x3308, 0x293: 0x3308, 0x294: 0x3308, 0x295: 0x3308, 0x296: 0x3308, 0x297: 0x3308,
+	0x298: 0x3308, 0x299: 0x3308, 0x29a: 0x3308, 0x29b: 0x3308, 0x29c: 0x3308, 0x29d: 0x3308,
+	0x29e: 0x3308, 0x29f: 0x3308, 0x2a0: 0x3308, 0x2a1: 0x3308, 0x2a2: 0x3308, 0x2a3: 0x3308,
+	0x2a4: 0x3308, 0x2a5: 0x3308, 0x2a6: 0x3308, 0x2a7: 0x3308, 0x2a8: 0x3308, 0x2a9: 0x3308,
+	0x2aa: 0x3308, 0x2ab: 0x3308, 0x2ac: 0x3308, 0x2ad: 0x3308, 0x2ae: 0x3308, 0x2af: 0x3308,
+	0x2b0: 0xe00d, 0x2b1: 0x0008, 0x2b2: 0xe00d, 0x2b3: 0x0008, 0x2b4: 0x0425, 0x2b5: 0x0008,
+	0x2b6: 0xe00d, 0x2b7: 0x0008, 0x2b8: 0x0040, 0x2b9: 0x0040, 0x2ba: 0x03a2, 0x2bb: 0x0008,
+	0x2bc: 0x0008, 0x2bd: 0x0008, 0x2be: 0x03c2, 0x2bf: 0x043d,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x0040, 0x2c1: 0x0040, 0x2c2: 0x0040, 0x2c3: 0x0040, 0x2c4: 0x008a, 0x2c5: 0x03d2,
+	0x2c6: 0xe155, 0x2c7: 0x0455, 0x2c8: 0xe12d, 0x2c9: 0xe13d, 0x2ca: 0xe12d, 0x2cb: 0x0040,
+	0x2cc: 0x03dd, 0x2cd: 0x0040, 0x2ce: 0x046d, 0x2cf: 0x0485, 0x2d0: 0x0008, 0x2d1: 0xe105,
+	0x2d2: 0xe105, 0x2d3: 0xe105, 0x2d4: 0xe105, 0x2d5: 0xe105, 0x2d6: 0xe105, 0x2d7: 0xe105,
+	0x2d8: 0xe105, 0x2d9: 0xe105, 0x2da: 0xe105, 0x2db: 0xe105, 0x2dc: 0xe105, 0x2dd: 0xe105,
+	0x2de: 0xe105, 0x2df: 0xe105, 0x2e0: 0x049d, 0x2e1: 0x049d, 0x2e2: 0x0040, 0x2e3: 0x049d,
+	0x2e4: 0x049d, 0x2e5: 0x049d, 0x2e6: 0x049d, 0x2e7: 0x049d, 0x2e8: 0x049d, 0x2e9: 0x049d,
+	0x2ea: 0x049d, 0x2eb: 0x049d, 0x2ec: 0x0008, 0x2ed: 0x0008, 0x2ee: 0x0008, 0x2ef: 0x0008,
+	0x2f0: 0x0008, 0x2f1: 0x0008, 0x2f2: 0x0008, 0x2f3: 0x0008, 0x2f4: 0x0008, 0x2f5: 0x0008,
+	0x2f6: 0x0008, 0x2f7: 0x0008, 0x2f8: 0x0008, 0x2f9: 0x0008, 0x2fa: 0x0008, 0x2fb: 0x0008,
+	0x2fc: 0x0008, 0x2fd: 0x0008, 0x2fe: 0x0008, 0x2ff: 0x0008,
+	// Block 0xc, offset 0x300
+	0x300: 0x0008, 0x301: 0x0008, 0x302: 0xe00f, 0x303: 0x0008, 0x304: 0x0008, 0x305: 0x0008,
+	0x306: 0x0008, 0x307: 0x0008, 0x308: 0x0008, 0x309: 0x0008, 0x30a: 0x0008, 0x30b: 0x0008,
+	0x30c: 0x0008, 0x30d: 0x0008, 0x30e: 0x0008, 0x30f: 0xe0c5, 0x310: 0x04b5, 0x311: 0x04cd,
+	0x312: 0xe0bd, 0x313: 0xe0f5, 0x314: 0xe0fd, 0x315: 0xe09d, 0x316: 0xe0b5, 0x317: 0x0008,
+	0x318: 0xe00d, 0x319: 0x0008, 0x31a: 0xe00d, 0x31b: 0x0008, 0x31c: 0xe00d, 0x31d: 0x0008,
+	0x31e: 0xe00d, 0x31f: 0x0008, 0x320: 0xe00d, 0x321: 0x0008, 0x322: 0xe00d, 0x323: 0x0008,
+	0x324: 0xe00d, 0x325: 0x0008, 0x326: 0xe00d, 0x327: 0x0008, 0x328: 0xe00d, 0x329: 0x0008,
+	0x32a: 0xe00d, 0x32b: 0x0008, 0x32c: 0xe00d, 0x32d: 0x0008, 0x32e: 0xe00d, 0x32f: 0x0008,
+	0x330: 0x04e5, 0x331: 0xe185, 0x332: 0xe18d, 0x333: 0x0008, 0x334: 0x04fd, 0x335: 0x03dd,
+	0x336: 0x0018, 0x337: 0xe07d, 0x338: 0x0008, 0x339: 0xe1d5, 0x33a: 0xe00d, 0x33b: 0x0008,
+	0x33c: 0x0008, 0x33d: 0x0515, 0x33e: 0x052d, 0x33f: 0x052d,
+	// Block 0xd, offset 0x340
+	0x340: 0x0008, 0x341: 0x0008, 0x342: 0x0008, 0x343: 0x0008, 0x344: 0x0008, 0x345: 0x0008,
+	0x346: 0x0008, 0x347: 0x0008, 0x348: 0x0008, 0x349: 0x0008, 0x34a: 0x0008, 0x34b: 0x0008,
+	0x34c: 0x0008, 0x34d: 0x0008, 0x34e: 0x0008, 0x34f: 0x0008, 0x350: 0x0008, 0x351: 0x0008,
+	0x352: 0x0008, 0x353: 0x0008, 0x354: 0x0008, 0x355: 0x0008, 0x356: 0x0008, 0x357: 0x0008,
+	0x358: 0x0008, 0x359: 0x0008, 0x35a: 0x0008, 0x35b: 0x0008, 0x35c: 0x0008, 0x35d: 0x0008,
+	0x35e: 0x0008, 0x35f: 0x0008, 0x360: 0xe00d, 0x361: 0x0008, 0x362: 0xe00d, 0x363: 0x0008,
+	0x364: 0xe00d, 0x365: 0x0008, 0x366: 0xe00d, 0x367: 0x0008, 0x368: 0xe00d, 0x369: 0x0008,
+	0x36a: 0xe00d, 0x36b: 0x0008, 0x36c: 0xe00d, 0x36d: 0x0008, 0x36e: 0xe00d, 0x36f: 0x0008,
+	0x370: 0xe00d, 0x371: 0x0008, 0x372: 0xe00d, 0x373: 0x0008, 0x374: 0xe00d, 0x375: 0x0008,
+	0x376: 0xe00d, 0x377: 0x0008, 0x378: 0xe00d, 0x379: 0x0008, 0x37a: 0xe00d, 0x37b: 0x0008,
+	0x37c: 0xe00d, 0x37d: 0x0008, 0x37e: 0xe00d, 0x37f: 0x0008,
+	// Block 0xe, offset 0x380
+	0x380: 0xe00d, 0x381: 0x0008, 0x382: 0x0018, 0x383: 0x3308, 0x384: 0x3308, 0x385: 0x3308,
+	0x386: 0x3308, 0x387: 0x3308, 0x388: 0x3318, 0x389: 0x3318, 0x38a: 0xe00d, 0x38b: 0x0008,
+	0x38c: 0xe00d, 0x38d: 0x0008, 0x38e: 0xe00d, 0x38f: 0x0008, 0x390: 0xe00d, 0x391: 0x0008,
+	0x392: 0xe00d, 0x393: 0x0008, 0x394: 0xe00d, 0x395: 0x0008, 0x396: 0xe00d, 0x397: 0x0008,
+	0x398: 0xe00d, 0x399: 0x0008, 0x39a: 0xe00d, 0x39b: 0x0008, 0x39c: 0xe00d, 0x39d: 0x0008,
+	0x39e: 0xe00d, 0x39f: 0x0008, 0x3a0: 0xe00d, 0x3a1: 0x0008, 0x3a2: 0xe00d, 0x3a3: 0x0008,
+	0x3a4: 0xe00d, 0x3a5: 0x0008, 0x3a6: 0xe00d, 0x3a7: 0x0008, 0x3a8: 0xe00d, 0x3a9: 0x0008,
+	0x3aa: 0xe00d, 0x3ab: 0x0008, 0x3ac: 0xe00d, 0x3ad: 0x0008, 0x3ae: 0xe00d, 0x3af: 0x0008,
+	0x3b0: 0xe00d, 0x3b1: 0x0008, 0x3b2: 0xe00d, 0x3b3: 0x0008, 0x3b4: 0xe00d, 0x3b5: 0x0008,
+	0x3b6: 0xe00d, 0x3b7: 0x0008, 0x3b8: 0xe00d, 0x3b9: 0x0008, 0x3ba: 0xe00d, 0x3bb: 0x0008,
+	0x3bc: 0xe00d, 0x3bd: 0x0008, 0x3be: 0xe00d, 0x3bf: 0x0008,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x0040, 0x3c1: 0xe01d, 0x3c2: 0x0008, 0x3c3: 0xe03d, 0x3c4: 0x0008, 0x3c5: 0xe01d,
+	0x3c6: 0x0008, 0x3c7: 0xe07d, 0x3c8: 0x0008, 0x3c9: 0xe01d, 0x3ca: 0x0008, 0x3cb: 0xe03d,
+	0x3cc: 0x0008, 0x3cd: 0xe01d, 0x3ce: 0x0008, 0x3cf: 0x0008, 0x3d0: 0xe00d, 0x3d1: 0x0008,
+	0x3d2: 0xe00d, 0x3d3: 0x0008, 0x3d4: 0xe00d, 0x3d5: 0x0008, 0x3d6: 0xe00d, 0x3d7: 0x0008,
+	0x3d8: 0xe00d, 0x3d9: 0x0008, 0x3da: 0xe00d, 0x3db: 0x0008, 0x3dc: 0xe00d, 0x3dd: 0x0008,
+	0x3de: 0xe00d, 0x3df: 0x0008, 0x3e0: 0xe00d, 0x3e1: 0x0008, 0x3e2: 0xe00d, 0x3e3: 0x0008,
+	0x3e4: 0xe00d, 0x3e5: 0x0008, 0x3e6: 0xe00d, 0x3e7: 0x0008, 0x3e8: 0xe00d, 0x3e9: 0x0008,
+	0x3ea: 0xe00d, 0x3eb: 0x0008, 0x3ec: 0xe00d, 0x3ed: 0x0008, 0x3ee: 0xe00d, 0x3ef: 0x0008,
+	0x3f0: 0xe00d, 0x3f1: 0x0008, 0x3f2: 0xe00d, 0x3f3: 0x0008, 0x3f4: 0xe00d, 0x3f5: 0x0008,
+	0x3f6: 0xe00d, 0x3f7: 0x0008, 0x3f8: 0xe00d, 0x3f9: 0x0008, 0x3fa: 0xe00d, 0x3fb: 0x0008,
+	0x3fc: 0xe00d, 0x3fd: 0x0008, 0x3fe: 0xe00d, 0x3ff: 0x0008,
+	// Block 0x10, offset 0x400
+	0x400: 0xe00d, 0x401: 0x0008, 0x402: 0xe00d, 0x403: 0x0008, 0x404: 0xe00d, 0x405: 0x0008,
+	0x406: 0xe00d, 0x407: 0x0008, 0x408: 0xe00d, 0x409: 0x0008, 0x40a: 0xe00d, 0x40b: 0x0008,
+	0x40c: 0xe00d, 0x40d: 0x0008, 0x40e: 0xe00d, 0x40f: 0x0008, 0x410: 0xe00d, 0x411: 0x0008,
+	0x412: 0xe00d, 0x413: 0x0008, 0x414: 0xe00d, 0x415: 0x0008, 0x416: 0xe00d, 0x417: 0x0008,
+	0x418: 0xe00d, 0x419: 0x0008, 0x41a: 0xe00d, 0x41b: 0x0008, 0x41c: 0xe00d, 0x41d: 0x0008,
+	0x41e: 0xe00d, 0x41f: 0x0008, 0x420: 0xe00d, 0x421: 0x0008, 0x422: 0xe00d, 0x423: 0x0008,
+	0x424: 0xe00d, 0x425: 0x0008, 0x426: 0xe00d, 0x427: 0x0008, 0x428: 0xe00d, 0x429: 0x0008,
+	0x42a: 0xe00d, 0x42b: 0x0008, 0x42c: 0xe00d, 0x42d: 0x0008, 0x42e: 0xe00d, 0x42f: 0x0008,
+	0x430: 0x0040, 0x431: 0x03f5, 0x432: 0x03f5, 0x433: 0x03f5, 0x434: 0x03f5, 0x435: 0x03f5,
+	0x436: 0x03f5, 0x437: 0x03f5, 0x438: 0x03f5, 0x439: 0x03f5, 0x43a: 0x03f5, 0x43b: 0x03f5,
+	0x43c: 0x03f5, 0x43d: 0x03f5, 0x43e: 0x03f5, 0x43f: 0x03f5,
+	// Block 0x11, offset 0x440
+	0x440: 0x0840, 0x441: 0x0840, 0x442: 0x0840, 0x443: 0x0840, 0x444: 0x0840, 0x445: 0x0840,
+	0x446: 0x0018, 0x447: 0x0018, 0x448: 0x0818, 0x449: 0x0018, 0x44a: 0x0018, 0x44b: 0x0818,
+	0x44c: 0x0018, 0x44d: 0x0818, 0x44e: 0x0018, 0x44f: 0x0018, 0x450: 0x3308, 0x451: 0x3308,
+	0x452: 0x3308, 0x453: 0x3308, 0x454: 0x3308, 0x455: 0x3308, 0x456: 0x3308, 0x457: 0x3308,
+	0x458: 0x3308, 0x459: 0x3308, 0x45a: 0x3308, 0x45b: 0x0818, 0x45c: 0x0b40, 0x45d: 0x0040,
+	0x45e: 0x0818, 0x45f: 0x0818, 0x460: 0x0a08, 0x461: 0x0808, 0x462: 0x0c08, 0x463: 0x0c08,
+	0x464: 0x0c08, 0x465: 0x0c08, 0x466: 0x0a08, 0x467: 0x0c08, 0x468: 0x0a08, 0x469: 0x0c08,
+	0x46a: 0x0a08, 0x46b: 0x0a08, 0x46c: 0x0a08, 0x46d: 0x0a08, 0x46e: 0x0a08, 0x46f: 0x0c08,
+	0x470: 0x0c08, 0x471: 0x0c08, 0x472: 0x0c08, 0x473: 0x0a08, 0x474: 0x0a08, 0x475: 0x0a08,
+	0x476: 0x0a08, 0x477: 0x0a08, 0x478: 0x0a08, 0x479: 0x0a08, 0x47a: 0x0a08, 0x47b: 0x0a08,
+	0x47c: 0x0a08, 0x47d: 0x0a08, 0x47e: 0x0a08, 0x47f: 0x0a08,
+	// Block 0x12, offset 0x480
+	0x480: 0x0818, 0x481: 0x0a08, 0x482: 0x0a08, 0x483: 0x0a08, 0x484: 0x0a08, 0x485: 0x0a08,
+	0x486: 0x0a08, 0x487: 0x0a08, 0x488: 0x0c08, 0x489: 0x0a08, 0x48a: 0x0a08, 0x48b: 0x3308,
+	0x48c: 0x3308, 0x48d: 0x3308, 0x48e: 0x3308, 0x48f: 0x3308, 0x490: 0x3308, 0x491: 0x3308,
+	0x492: 0x3308, 0x493: 0x3308, 0x494: 0x3308, 0x495: 0x3308, 0x496: 0x3308, 0x497: 0x3308,
+	0x498: 0x3308, 0x499: 0x3308, 0x49a: 0x3308, 0x49b: 0x3308, 0x49c: 0x3308, 0x49d: 0x3308,
+	0x49e: 0x3308, 0x49f: 0x3308, 0x4a0: 0x0808, 0x4a1: 0x0808, 0x4a2: 0x0808, 0x4a3: 0x0808,
+	0x4a4: 0x0808, 0x4a5: 0x0808, 0x4a6: 0x0808, 0x4a7: 0x0808, 0x4a8: 0x0808, 0x4a9: 0x0808,
+	0x4aa: 0x0018, 0x4ab: 0x0818, 0x4ac: 0x0818, 0x4ad: 0x0818, 0x4ae: 0x0a08, 0x4af: 0x0a08,
+	0x4b0: 0x3308, 0x4b1: 0x0c08, 0x4b2: 0x0c08, 0x4b3: 0x0c08, 0x4b4: 0x0808, 0x4b5: 0x0429,
+	0x4b6: 0x0451, 0x4b7: 0x0479, 0x4b8: 0x04a1, 0x4b9: 0x0a08, 0x4ba: 0x0a08, 0x4bb: 0x0a08,
+	0x4bc: 0x0a08, 0x4bd: 0x0a08, 0x4be: 0x0a08, 0x4bf: 0x0a08,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x0c08, 0x4c1: 0x0a08, 0x4c2: 0x0a08, 0x4c3: 0x0c08, 0x4c4: 0x0c08, 0x4c5: 0x0c08,
+	0x4c6: 0x0c08, 0x4c7: 0x0c08, 0x4c8: 0x0c08, 0x4c9: 0x0c08, 0x4ca: 0x0c08, 0x4cb: 0x0c08,
+	0x4cc: 0x0a08, 0x4cd: 0x0c08, 0x4ce: 0x0a08, 0x4cf: 0x0c08, 0x4d0: 0x0a08, 0x4d1: 0x0a08,
+	0x4d2: 0x0c08, 0x4d3: 0x0c08, 0x4d4: 0x0818, 0x4d5: 0x0c08, 0x4d6: 0x3308, 0x4d7: 0x3308,
+	0x4d8: 0x3308, 0x4d9: 0x3308, 0x4da: 0x3308, 0x4db: 0x3308, 0x4dc: 0x3308, 0x4dd: 0x0840,
+	0x4de: 0x0018, 0x4df: 0x3308, 0x4e0: 0x3308, 0x4e1: 0x3308, 0x4e2: 0x3308, 0x4e3: 0x3308,
+	0x4e4: 0x3308, 0x4e5: 0x0808, 0x4e6: 0x0808, 0x4e7: 0x3308, 0x4e8: 0x3308, 0x4e9: 0x0018,
+	0x4ea: 0x3308, 0x4eb: 0x3308, 0x4ec: 0x3308, 0x4ed: 0x3308, 0x4ee: 0x0c08, 0x4ef: 0x0c08,
+	0x4f0: 0x0008, 0x4f1: 0x0008, 0x4f2: 0x0008, 0x4f3: 0x0008, 0x4f4: 0x0008, 0x4f5: 0x0008,
+	0x4f6: 0x0008, 0x4f7: 0x0008, 0x4f8: 0x0008, 0x4f9: 0x0008, 0x4fa: 0x0a08, 0x4fb: 0x0a08,
+	0x4fc: 0x0a08, 0x4fd: 0x0808, 0x4fe: 0x0808, 0x4ff: 0x0a08,
+	// Block 0x14, offset 0x500
+	0x500: 0x0818, 0x501: 0x0818, 0x502: 0x0818, 0x503: 0x0818, 0x504: 0x0818, 0x505: 0x0818,
+	0x506: 0x0818, 0x507: 0x0818, 0x508: 0x0818, 0x509: 0x0818, 0x50a: 0x0818, 0x50b: 0x0818,
+	0x50c: 0x0818, 0x50d: 0x0818, 0x50e: 0x0040, 0x50f: 0x0b40, 0x510: 0x0c08, 0x511: 0x3308,
+	0x512: 0x0a08, 0x513: 0x0a08, 0x514: 0x0a08, 0x515: 0x0c08, 0x516: 0x0c08, 0x517: 0x0c08,
+	0x518: 0x0c08, 0x519: 0x0c08, 0x51a: 0x0a08, 0x51b: 0x0a08, 0x51c: 0x0a08, 0x51d: 0x0a08,
+	0x51e: 0x0c08, 0x51f: 0x0a08, 0x520: 0x0a08, 0x521: 0x0a08, 0x522: 0x0a08, 0x523: 0x0a08,
+	0x524: 0x0a08, 0x525: 0x0a08, 0x526: 0x0a08, 0x527: 0x0a08, 0x528: 0x0c08, 0x529: 0x0a08,
+	0x52a: 0x0c08, 0x52b: 0x0a08, 0x52c: 0x0c08, 0x52d: 0x0a08, 0x52e: 0x0a08, 0x52f: 0x0c08,
+	0x530: 0x3308, 0x531: 0x3308, 0x532: 0x3308, 0x533: 0x3308, 0x534: 0x3308, 0x535: 0x3308,
+	0x536: 0x3308, 0x537: 0x3308, 0x538: 0x3308, 0x539: 0x3308, 0x53a: 0x3308, 0x53b: 0x3308,
+	0x53c: 0x3308, 0x53d: 0x3308, 0x53e: 0x3308, 0x53f: 0x3308,
+	// Block 0x15, offset 0x540
+	0x540: 0x0c08, 0x541: 0x0a08, 0x542: 0x0a08, 0x543: 0x0a08, 0x544: 0x0a08, 0x545: 0x0a08,
+	0x546: 0x0c08, 0x547: 0x0c08, 0x548: 0x0a08, 0x549: 0x0c08, 0x54a: 0x0a08, 0x54b: 0x0a08,
+	0x54c: 0x0a08, 0x54d: 0x0a08, 0x54e: 0x0a08, 0x54f: 0x0a08, 0x550: 0x0a08, 0x551: 0x0a08,
+	0x552: 0x0a08, 0x553: 0x0a08, 0x554: 0x0c08, 0x555: 0x0a08, 0x556: 0x0808, 0x557: 0x0808,
+	0x558: 0x0808, 0x559: 0x3308, 0x55a: 0x3308, 0x55b: 0x3308, 0x55c: 0x0040, 0x55d: 0x0040,
+	0x55e: 0x0818, 0x55f: 0x0040, 0x560: 0x0a08, 0x561: 0x0808, 0x562: 0x0a08, 0x563: 0x0a08,
+	0x564: 0x0a08, 0x565: 0x0a08, 0x566: 0x0808, 0x567: 0x0c08, 0x568: 0x0a08, 0x569: 0x0c08,
+	0x56a: 0x0c08, 0x56b: 0x0040, 0x56c: 0x0040, 0x56d: 0x0040, 0x56e: 0x0040, 0x56f: 0x0040,
+	0x570: 0x0040, 0x571: 0x0040, 0x572: 0x0040, 0x573: 0x0040, 0x574: 0x0040, 0x575: 0x0040,
+	0x576: 0x0040, 0x577: 0x0040, 0x578: 0x0040, 0x579: 0x0040, 0x57a: 0x0040, 0x57b: 0x0040,
+	0x57c: 0x0040, 0x57d: 0x0040, 0x57e: 0x0040, 0x57f: 0x0040,
+	// Block 0x16, offset 0x580
+	0x580: 0x3008, 0x581: 0x3308, 0x582: 0x3308, 0x583: 0x3308, 0x584: 0x3308, 0x585: 0x3308,
+	0x586: 0x3308, 0x587: 0x3308, 0x588: 0x3308, 0x589: 0x3008, 0x58a: 0x3008, 0x58b: 0x3008,
+	0x58c: 0x3008, 0x58d: 0x3b08, 0x58e: 0x3008, 0x58f: 0x3008, 0x590: 0x0008, 0x591: 0x3308,
+	0x592: 0x3308, 0x593: 0x3308, 0x594: 0x3308, 0x595: 0x3308, 0x596: 0x3308, 0x597: 0x3308,
+	0x598: 0x04c9, 0x599: 0x0501, 0x59a: 0x0539, 0x59b: 0x0571, 0x59c: 0x05a9, 0x59d: 0x05e1,
+	0x59e: 0x0619, 0x59f: 0x0651, 0x5a0: 0x0008, 0x5a1: 0x0008, 0x5a2: 0x3308, 0x5a3: 0x3308,
+	0x5a4: 0x0018, 0x5a5: 0x0018, 0x5a6: 0x0008, 0x5a7: 0x0008, 0x5a8: 0x0008, 0x5a9: 0x0008,
+	0x5aa: 0x0008, 0x5ab: 0x0008, 0x5ac: 0x0008, 0x5ad: 0x0008, 0x5ae: 0x0008, 0x5af: 0x0008,
+	0x5b0: 0x0018, 0x5b1: 0x0008, 0x5b2: 0x0008, 0x5b3: 0x0008, 0x5b4: 0x0008, 0x5b5: 0x0008,
+	0x5b6: 0x0008, 0x5b7: 0x0008, 0x5b8: 0x0008, 0x5b9: 0x0008, 0x5ba: 0x0008, 0x5bb: 0x0008,
+	0x5bc: 0x0008, 0x5bd: 0x0008, 0x5be: 0x0008, 0x5bf: 0x0008,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x0008, 0x5c1: 0x3308, 0x5c2: 0x3008, 0x5c3: 0x3008, 0x5c4: 0x0040, 0x5c5: 0x0008,
+	0x5c6: 0x0008, 0x5c7: 0x0008, 0x5c8: 0x0008, 0x5c9: 0x0008, 0x5ca: 0x0008, 0x5cb: 0x0008,
+	0x5cc: 0x0008, 0x5cd: 0x0040, 0x5ce: 0x0040, 0x5cf: 0x0008, 0x5d0: 0x0008, 0x5d1: 0x0040,
+	0x5d2: 0x0040, 0x5d3: 0x0008, 0x5d4: 0x0008, 0x5d5: 0x0008, 0x5d6: 0x0008, 0x5d7: 0x0008,
+	0x5d8: 0x0008, 0x5d9: 0x0008, 0x5da: 0x0008, 0x5db: 0x0008, 0x5dc: 0x0008, 0x5dd: 0x0008,
+	0x5de: 0x0008, 0x5df: 0x0008, 0x5e0: 0x0008, 0x5e1: 0x0008, 0x5e2: 0x0008, 0x5e3: 0x0008,
+	0x5e4: 0x0008, 0x5e5: 0x0008, 0x5e6: 0x0008, 0x5e7: 0x0008, 0x5e8: 0x0008, 0x5e9: 0x0040,
+	0x5ea: 0x0008, 0x5eb: 0x0008, 0x5ec: 0x0008, 0x5ed: 0x0008, 0x5ee: 0x0008, 0x5ef: 0x0008,
+	0x5f0: 0x0008, 0x5f1: 0x0040, 0x5f2: 0x0008, 0x5f3: 0x0040, 0x5f4: 0x0040, 0x5f5: 0x0040,
+	0x5f6: 0x0008, 0x5f7: 0x0008, 0x5f8: 0x0008, 0x5f9: 0x0008, 0x5fa: 0x0040, 0x5fb: 0x0040,
+	0x5fc: 0x3308, 0x5fd: 0x0008, 0x5fe: 0x3008, 0x5ff: 0x3008,
+	// Block 0x18, offset 0x600
+	0x600: 0x3008, 0x601: 0x3308, 0x602: 0x3308, 0x603: 0x3308, 0x604: 0x3308, 0x605: 0x0040,
+	0x606: 0x0040, 0x607: 0x3008, 0x608: 0x3008, 0x609: 0x0040, 0x60a: 0x0040, 0x60b: 0x3008,
+	0x60c: 0x3008, 0x60d: 0x3b08, 0x60e: 0x0008, 0x60f: 0x0040, 0x610: 0x0040, 0x611: 0x0040,
+	0x612: 0x0040, 0x613: 0x0040, 0x614: 0x0040, 0x615: 0x0040, 0x616: 0x0040, 0x617: 0x3008,
+	0x618: 0x0040, 0x619: 0x0040, 0x61a: 0x0040, 0x61b: 0x0040, 0x61c: 0x0689, 0x61d: 0x06c1,
+	0x61e: 0x0040, 0x61f: 0x06f9, 0x620: 0x0008, 0x621: 0x0008, 0x622: 0x3308, 0x623: 0x3308,
+	0x624: 0x0040, 0x625: 0x0040, 0x626: 0x0008, 0x627: 0x0008, 0x628: 0x0008, 0x629: 0x0008,
+	0x62a: 0x0008, 0x62b: 0x0008, 0x62c: 0x0008, 0x62d: 0x0008, 0x62e: 0x0008, 0x62f: 0x0008,
+	0x630: 0x0008, 0x631: 0x0008, 0x632: 0x0018, 0x633: 0x0018, 0x634: 0x0018, 0x635: 0x0018,
+	0x636: 0x0018, 0x637: 0x0018, 0x638: 0x0018, 0x639: 0x0018, 0x63a: 0x0018, 0x63b: 0x0018,
+	0x63c: 0x0008, 0x63d: 0x0018, 0x63e: 0x0040, 0x63f: 0x0040,
+	// Block 0x19, offset 0x640
+	0x640: 0x0040, 0x641: 0x3308, 0x642: 0x3308, 0x643: 0x3008, 0x644: 0x0040, 0x645: 0x0008,
+	0x646: 0x0008, 0x647: 0x0008, 0x648: 0x0008, 0x649: 0x0008, 0x64a: 0x0008, 0x64b: 0x0040,
+	0x64c: 0x0040, 0x64d: 0x0040, 0x64e: 0x0040, 0x64f: 0x0008, 0x650: 0x0008, 0x651: 0x0040,
+	0x652: 0x0040, 0x653: 0x0008, 0x654: 0x0008, 0x655: 0x0008, 0x656: 0x0008, 0x657: 0x0008,
+	0x658: 0x0008, 0x659: 0x0008, 0x65a: 0x0008, 0x65b: 0x0008, 0x65c: 0x0008, 0x65d: 0x0008,
+	0x65e: 0x0008, 0x65f: 0x0008, 0x660: 0x0008, 0x661: 0x0008, 0x662: 0x0008, 0x663: 0x0008,
+	0x664: 0x0008, 0x665: 0x0008, 0x666: 0x0008, 0x667: 0x0008, 0x668: 0x0008, 0x669: 0x0040,
+	0x66a: 0x0008, 0x66b: 0x0008, 0x66c: 0x0008, 0x66d: 0x0008, 0x66e: 0x0008, 0x66f: 0x0008,
+	0x670: 0x0008, 0x671: 0x0040, 0x672: 0x0008, 0x673: 0x0731, 0x674: 0x0040, 0x675: 0x0008,
+	0x676: 0x0769, 0x677: 0x0040, 0x678: 0x0008, 0x679: 0x0008, 0x67a: 0x0040, 0x67b: 0x0040,
+	0x67c: 0x3308, 0x67d: 0x0040, 0x67e: 0x3008, 0x67f: 0x3008,
+	// Block 0x1a, offset 0x680
+	0x680: 0x3008, 0x681: 0x3308, 0x682: 0x3308, 0x683: 0x0040, 0x684: 0x0040, 0x685: 0x0040,
+	0x686: 0x0040, 0x687: 0x3308, 0x688: 0x3308, 0x689: 0x0040, 0x68a: 0x0040, 0x68b: 0x3308,
+	0x68c: 0x3308, 0x68d: 0x3b08, 0x68e: 0x0040, 0x68f: 0x0040, 0x690: 0x0040, 0x691: 0x3308,
+	0x692: 0x0040, 0x693: 0x0040, 0x694: 0x0040, 0x695: 0x0040, 0x696: 0x0040, 0x697: 0x0040,
+	0x698: 0x0040, 0x699: 0x07a1, 0x69a: 0x07d9, 0x69b: 0x0811, 0x69c: 0x0008, 0x69d: 0x0040,
+	0x69e: 0x0849, 0x69f: 0x0040, 0x6a0: 0x0040, 0x6a1: 0x0040, 0x6a2: 0x0040, 0x6a3: 0x0040,
+	0x6a4: 0x0040, 0x6a5: 0x0040, 0x6a6: 0x0008, 0x6a7: 0x0008, 0x6a8: 0x0008, 0x6a9: 0x0008,
+	0x6aa: 0x0008, 0x6ab: 0x0008, 0x6ac: 0x0008, 0x6ad: 0x0008, 0x6ae: 0x0008, 0x6af: 0x0008,
+	0x6b0: 0x3308, 0x6b1: 0x3308, 0x6b2: 0x0008, 0x6b3: 0x0008, 0x6b4: 0x0008, 0x6b5: 0x3308,
+	0x6b6: 0x0040, 0x6b7: 0x0040, 0x6b8: 0x0040, 0x6b9: 0x0040, 0x6ba: 0x0040, 0x6bb: 0x0040,
+	0x6bc: 0x0040, 0x6bd: 0x0040, 0x6be: 0x0040, 0x6bf: 0x0040,
+	// Block 0x1b, offset 0x6c0
+	0x6c0: 0x0040, 0x6c1: 0x3308, 0x6c2: 0x3308, 0x6c3: 0x3008, 0x6c4: 0x0040, 0x6c5: 0x0008,
+	0x6c6: 0x0008, 0x6c7: 0x0008, 0x6c8: 0x0008, 0x6c9: 0x0008, 0x6ca: 0x0008, 0x6cb: 0x0008,
+	0x6cc: 0x0008, 0x6cd: 0x0008, 0x6ce: 0x0040, 0x6cf: 0x0008, 0x6d0: 0x0008, 0x6d1: 0x0008,
+	0x6d2: 0x0040, 0x6d3: 0x0008, 0x6d4: 0x0008, 0x6d5: 0x0008, 0x6d6: 0x0008, 0x6d7: 0x0008,
+	0x6d8: 0x0008, 0x6d9: 0x0008, 0x6da: 0x0008, 0x6db: 0x0008, 0x6dc: 0x0008, 0x6dd: 0x0008,
+	0x6de: 0x0008, 0x6df: 0x0008, 0x6e0: 0x0008, 0x6e1: 0x0008, 0x6e2: 0x0008, 0x6e3: 0x0008,
+	0x6e4: 0x0008, 0x6e5: 0x0008, 0x6e6: 0x0008, 0x6e7: 0x0008, 0x6e8: 0x0008, 0x6e9: 0x0040,
+	0x6ea: 0x0008, 0x6eb: 0x0008, 0x6ec: 0x0008, 0x6ed: 0x0008, 0x6ee: 0x0008, 0x6ef: 0x0008,
+	0x6f0: 0x0008, 0x6f1: 0x0040, 0x6f2: 0x0008, 0x6f3: 0x0008, 0x6f4: 0x0040, 0x6f5: 0x0008,
+	0x6f6: 0x0008, 0x6f7: 0x0008, 0x6f8: 0x0008, 0x6f9: 0x0008, 0x6fa: 0x0040, 0x6fb: 0x0040,
+	0x6fc: 0x3308, 0x6fd: 0x0008, 0x6fe: 0x3008, 0x6ff: 0x3008,
+	// Block 0x1c, offset 0x700
+	0x700: 0x3008, 0x701: 0x3308, 0x702: 0x3308, 0x703: 0x3308, 0x704: 0x3308, 0x705: 0x3308,
+	0x706: 0x0040, 0x707: 0x3308, 0x708: 0x3308, 0x709: 0x3008, 0x70a: 0x0040, 0x70b: 0x3008,
+	0x70c: 0x3008, 0x70d: 0x3b08, 0x70e: 0x0040, 0x70f: 0x0040, 0x710: 0x0008, 0x711: 0x0040,
+	0x712: 0x0040, 0x713: 0x0040, 0x714: 0x0040, 0x715: 0x0040, 0x716: 0x0040, 0x717: 0x0040,
+	0x718: 0x0040, 0x719: 0x0040, 0x71a: 0x0040, 0x71b: 0x0040, 0x71c: 0x0040, 0x71d: 0x0040,
+	0x71e: 0x0040, 0x71f: 0x0040, 0x720: 0x0008, 0x721: 0x0008, 0x722: 0x3308, 0x723: 0x3308,
+	0x724: 0x0040, 0x725: 0x0040, 0x726: 0x0008, 0x727: 0x0008, 0x728: 0x0008, 0x729: 0x0008,
+	0x72a: 0x0008, 0x72b: 0x0008, 0x72c: 0x0008, 0x72d: 0x0008, 0x72e: 0x0008, 0x72f: 0x0008,
+	0x730: 0x0018, 0x731: 0x0018, 0x732: 0x0040, 0x733: 0x0040, 0x734: 0x0040, 0x735: 0x0040,
+	0x736: 0x0040, 0x737: 0x0040, 0x738: 0x0040, 0x739: 0x0008, 0x73a: 0x3308, 0x73b: 0x3308,
+	0x73c: 0x3308, 0x73d: 0x3308, 0x73e: 0x3308, 0x73f: 0x3308,
+	// Block 0x1d, offset 0x740
+	0x740: 0x0040, 0x741: 0x3308, 0x742: 0x3008, 0x743: 0x3008, 0x744: 0x0040, 0x745: 0x0008,
+	0x746: 0x0008, 0x747: 0x0008, 0x748: 0x0008, 0x749: 0x0008, 0x74a: 0x0008, 0x74b: 0x0008,
+	0x74c: 0x0008, 0x74d: 0x0040, 0x74e: 0x0040, 0x74f: 0x0008, 0x750: 0x0008, 0x751: 0x0040,
+	0x752: 0x0040, 0x753: 0x0008, 0x754: 0x0008, 0x755: 0x0008, 0x756: 0x0008, 0x757: 0x0008,
+	0x758: 0x0008, 0x759: 0x0008, 0x75a: 0x0008, 0x75b: 0x0008, 0x75c: 0x0008, 0x75d: 0x0008,
+	0x75e: 0x0008, 0x75f: 0x0008, 0x760: 0x0008, 0x761: 0x0008, 0x762: 0x0008, 0x763: 0x0008,
+	0x764: 0x0008, 0x765: 0x0008, 0x766: 0x0008, 0x767: 0x0008, 0x768: 0x0008, 0x769: 0x0040,
+	0x76a: 0x0008, 0x76b: 0x0008, 0x76c: 0x0008, 0x76d: 0x0008, 0x76e: 0x0008, 0x76f: 0x0008,
+	0x770: 0x0008, 0x771: 0x0040, 0x772: 0x0008, 0x773: 0x0008, 0x774: 0x0040, 0x775: 0x0008,
+	0x776: 0x0008, 0x777: 0x0008, 0x778: 0x0008, 0x779: 0x0008, 0x77a: 0x0040, 0x77b: 0x0040,
+	0x77c: 0x3308, 0x77d: 0x0008, 0x77e: 0x3008, 0x77f: 0x3308,
+	// Block 0x1e, offset 0x780
+	0x780: 0x3008, 0x781: 0x3308, 0x782: 0x3308, 0x783: 0x3308, 0x784: 0x3308, 0x785: 0x0040,
+	0x786: 0x0040, 0x787: 0x3008, 0x788: 0x3008, 0x789: 0x0040, 0x78a: 0x0040, 0x78b: 0x3008,
+	0x78c: 0x3008, 0x78d: 0x3b08, 0x78e: 0x0040, 0x78f: 0x0040, 0x790: 0x0040, 0x791: 0x0040,
+	0x792: 0x0040, 0x793: 0x0040, 0x794: 0x0040, 0x795: 0x0040, 0x796: 0x3308, 0x797: 0x3008,
+	0x798: 0x0040, 0x799: 0x0040, 0x79a: 0x0040, 0x79b: 0x0040, 0x79c: 0x0881, 0x79d: 0x08b9,
+	0x79e: 0x0040, 0x79f: 0x0008, 0x7a0: 0x0008, 0x7a1: 0x0008, 0x7a2: 0x3308, 0x7a3: 0x3308,
+	0x7a4: 0x0040, 0x7a5: 0x0040, 0x7a6: 0x0008, 0x7a7: 0x0008, 0x7a8: 0x0008, 0x7a9: 0x0008,
+	0x7aa: 0x0008, 0x7ab: 0x0008, 0x7ac: 0x0008, 0x7ad: 0x0008, 0x7ae: 0x0008, 0x7af: 0x0008,
+	0x7b0: 0x0018, 0x7b1: 0x0008, 0x7b2: 0x0018, 0x7b3: 0x0018, 0x7b4: 0x0018, 0x7b5: 0x0018,
+	0x7b6: 0x0018, 0x7b7: 0x0018, 0x7b8: 0x0040, 0x7b9: 0x0040, 0x7ba: 0x0040, 0x7bb: 0x0040,
+	0x7bc: 0x0040, 0x7bd: 0x0040, 0x7be: 0x0040, 0x7bf: 0x0040,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x0040, 0x7c1: 0x0040, 0x7c2: 0x3308, 0x7c3: 0x0008, 0x7c4: 0x0040, 0x7c5: 0x0008,
+	0x7c6: 0x0008, 0x7c7: 0x0008, 0x7c8: 0x0008, 0x7c9: 0x0008, 0x7ca: 0x0008, 0x7cb: 0x0040,
+	0x7cc: 0x0040, 0x7cd: 0x0040, 0x7ce: 0x0008, 0x7cf: 0x0008, 0x7d0: 0x0008, 0x7d1: 0x0040,
+	0x7d2: 0x0008, 0x7d3: 0x0008, 0x7d4: 0x0008, 0x7d5: 0x0008, 0x7d6: 0x0040, 0x7d7: 0x0040,
+	0x7d8: 0x0040, 0x7d9: 0x0008, 0x7da: 0x0008, 0x7db: 0x0040, 0x7dc: 0x0008, 0x7dd: 0x0040,
+	0x7de: 0x0008, 0x7df: 0x0008, 0x7e0: 0x0040, 0x7e1: 0x0040, 0x7e2: 0x0040, 0x7e3: 0x0008,
+	0x7e4: 0x0008, 0x7e5: 0x0040, 0x7e6: 0x0040, 0x7e7: 0x0040, 0x7e8: 0x0008, 0x7e9: 0x0008,
+	0x7ea: 0x0008, 0x7eb: 0x0040, 0x7ec: 0x0040, 0x7ed: 0x0040, 0x7ee: 0x0008, 0x7ef: 0x0008,
+	0x7f0: 0x0008, 0x7f1: 0x0008, 0x7f2: 0x0008, 0x7f3: 0x0008, 0x7f4: 0x0008, 0x7f5: 0x0008,
+	0x7f6: 0x0008, 0x7f7: 0x0008, 0x7f8: 0x0008, 0x7f9: 0x0008, 0x7fa: 0x0040, 0x7fb: 0x0040,
+	0x7fc: 0x0040, 0x7fd: 0x0040, 0x7fe: 0x3008, 0x7ff: 0x3008,
+	// Block 0x20, offset 0x800
+	0x800: 0x3308, 0x801: 0x3008, 0x802: 0x3008, 0x803: 0x3008, 0x804: 0x3008, 0x805: 0x0040,
+	0x806: 0x3308, 0x807: 0x3308, 0x808: 0x3308, 0x809: 0x0040, 0x80a: 0x3308, 0x80b: 0x3308,
+	0x80c: 0x3308, 0x80d: 0x3b08, 0x80e: 0x0040, 0x80f: 0x0040, 0x810: 0x0040, 0x811: 0x0040,
+	0x812: 0x0040, 0x813: 0x0040, 0x814: 0x0040, 0x815: 0x3308, 0x816: 0x3308, 0x817: 0x0040,
+	0x818: 0x0008, 0x819: 0x0008, 0x81a: 0x0008, 0x81b: 0x0040, 0x81c: 0x0040, 0x81d: 0x0040,
+	0x81e: 0x0040, 0x81f: 0x0040, 0x820: 0x0008, 0x821: 0x0008, 0x822: 0x3308, 0x823: 0x3308,
+	0x824: 0x0040, 0x825: 0x0040, 0x826: 0x0008, 0x827: 0x0008, 0x828: 0x0008, 0x829: 0x0008,
+	0x82a: 0x0008, 0x82b: 0x0008, 0x82c: 0x0008, 0x82d: 0x0008, 0x82e: 0x0008, 0x82f: 0x0008,
+	0x830: 0x0040, 0x831: 0x0040, 0x832: 0x0040, 0x833: 0x0040, 0x834: 0x0040, 0x835: 0x0040,
+	0x836: 0x0040, 0x837: 0x0040, 0x838: 0x0018, 0x839: 0x0018, 0x83a: 0x0018, 0x83b: 0x0018,
+	0x83c: 0x0018, 0x83d: 0x0018, 0x83e: 0x0018, 0x83f: 0x0018,
+	// Block 0x21, offset 0x840
+	0x840: 0x0008, 0x841: 0x3308, 0x842: 0x3008, 0x843: 0x3008, 0x844: 0x0040, 0x845: 0x0008,
+	0x846: 0x0008, 0x847: 0x0008, 0x848: 0x0008, 0x849: 0x0008, 0x84a: 0x0008, 0x84b: 0x0008,
+	0x84c: 0x0008, 0x84d: 0x0040, 0x84e: 0x0008, 0x84f: 0x0008, 0x850: 0x0008, 0x851: 0x0040,
+	0x852: 0x0008, 0x853: 0x0008, 0x854: 0x0008, 0x855: 0x0008, 0x856: 0x0008, 0x857: 0x0008,
+	0x858: 0x0008, 0x859: 0x0008, 0x85a: 0x0008, 0x85b: 0x0008, 0x85c: 0x0008, 0x85d: 0x0008,
+	0x85e: 0x0008, 0x85f: 0x0008, 0x860: 0x0008, 0x861: 0x0008, 0x862: 0x0008, 0x863: 0x0008,
+	0x864: 0x0008, 0x865: 0x0008, 0x866: 0x0008, 0x867: 0x0008, 0x868: 0x0008, 0x869: 0x0040,
+	0x86a: 0x0008, 0x86b: 0x0008, 0x86c: 0x0008, 0x86d: 0x0008, 0x86e: 0x0008, 0x86f: 0x0008,
+	0x870: 0x0008, 0x871: 0x0008, 0x872: 0x0008, 0x873: 0x0008, 0x874: 0x0040, 0x875: 0x0008,
+	0x876: 0x0008, 0x877: 0x0008, 0x878: 0x0008, 0x879: 0x0008, 0x87a: 0x0040, 0x87b: 0x0040,
+	0x87c: 0x3308, 0x87d: 0x0008, 0x87e: 0x3008, 0x87f: 0x3308,
+	// Block 0x22, offset 0x880
+	0x880: 0x3008, 0x881: 0x3008, 0x882: 0x3008, 0x883: 0x3008, 0x884: 0x3008, 0x885: 0x0040,
+	0x886: 0x3308, 0x887: 0x3008, 0x888: 0x3008, 0x889: 0x0040, 0x88a: 0x3008, 0x88b: 0x3008,
+	0x88c: 0x3308, 0x88d: 0x3b08, 0x88e: 0x0040, 0x88f: 0x0040, 0x890: 0x0040, 0x891: 0x0040,
+	0x892: 0x0040, 0x893: 0x0040, 0x894: 0x0040, 0x895: 0x3008, 0x896: 0x3008, 0x897: 0x0040,
+	0x898: 0x0040, 0x899: 0x0040, 0x89a: 0x0040, 0x89b: 0x0040, 0x89c: 0x0040, 0x89d: 0x0040,
+	0x89e: 0x0008, 0x89f: 0x0040, 0x8a0: 0x0008, 0x8a1: 0x0008, 0x8a2: 0x3308, 0x8a3: 0x3308,
+	0x8a4: 0x0040, 0x8a5: 0x0040, 0x8a6: 0x0008, 0x8a7: 0x0008, 0x8a8: 0x0008, 0x8a9: 0x0008,
+	0x8aa: 0x0008, 0x8ab: 0x0008, 0x8ac: 0x0008, 0x8ad: 0x0008, 0x8ae: 0x0008, 0x8af: 0x0008,
+	0x8b0: 0x0040, 0x8b1: 0x0008, 0x8b2: 0x0008, 0x8b3: 0x0040, 0x8b4: 0x0040, 0x8b5: 0x0040,
+	0x8b6: 0x0040, 0x8b7: 0x0040, 0x8b8: 0x0040, 0x8b9: 0x0040, 0x8ba: 0x0040, 0x8bb: 0x0040,
+	0x8bc: 0x0040, 0x8bd: 0x0040, 0x8be: 0x0040, 0x8bf: 0x0040,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x3008, 0x8c1: 0x3308, 0x8c2: 0x3308, 0x8c3: 0x3308, 0x8c4: 0x3308, 0x8c5: 0x0040,
+	0x8c6: 0x3008, 0x8c7: 0x3008, 0x8c8: 0x3008, 0x8c9: 0x0040, 0x8ca: 0x3008, 0x8cb: 0x3008,
+	0x8cc: 0x3008, 0x8cd: 0x3b08, 0x8ce: 0x0008, 0x8cf: 0x0018, 0x8d0: 0x0040, 0x8d1: 0x0040,
+	0x8d2: 0x0040, 0x8d3: 0x0040, 0x8d4: 0x0008, 0x8d5: 0x0008, 0x8d6: 0x0008, 0x8d7: 0x3008,
+	0x8d8: 0x0018, 0x8d9: 0x0018, 0x8da: 0x0018, 0x8db: 0x0018, 0x8dc: 0x0018, 0x8dd: 0x0018,
+	0x8de: 0x0018, 0x8df: 0x0008, 0x8e0: 0x0008, 0x8e1: 0x0008, 0x8e2: 0x3308, 0x8e3: 0x3308,
+	0x8e4: 0x0040, 0x8e5: 0x0040, 0x8e6: 0x0008, 0x8e7: 0x0008, 0x8e8: 0x0008, 0x8e9: 0x0008,
+	0x8ea: 0x0008, 0x8eb: 0x0008, 0x8ec: 0x0008, 0x8ed: 0x0008, 0x8ee: 0x0008, 0x8ef: 0x0008,
+	0x8f0: 0x0018, 0x8f1: 0x0018, 0x8f2: 0x0018, 0x8f3: 0x0018, 0x8f4: 0x0018, 0x8f5: 0x0018,
+	0x8f6: 0x0018, 0x8f7: 0x0018, 0x8f8: 0x0018, 0x8f9: 0x0018, 0x8fa: 0x0008, 0x8fb: 0x0008,
+	0x8fc: 0x0008, 0x8fd: 0x0008, 0x8fe: 0x0008, 0x8ff: 0x0008,
+	// Block 0x24, offset 0x900
+	0x900: 0x0040, 0x901: 0x0008, 0x902: 0x0008, 0x903: 0x0040, 0x904: 0x0008, 0x905: 0x0040,
+	0x906: 0x0040, 0x907: 0x0008, 0x908: 0x0008, 0x909: 0x0040, 0x90a: 0x0008, 0x90b: 0x0040,
+	0x90c: 0x0040, 0x90d: 0x0008, 0x90e: 0x0040, 0x90f: 0x0040, 0x910: 0x0040, 0x911: 0x0040,
+	0x912: 0x0040, 0x913: 0x0040, 0x914: 0x0008, 0x915: 0x0008, 0x916: 0x0008, 0x917: 0x0008,
+	0x918: 0x0040, 0x919: 0x0008, 0x91a: 0x0008, 0x91b: 0x0008, 0x91c: 0x0008, 0x91d: 0x0008,
+	0x91e: 0x0008, 0x91f: 0x0008, 0x920: 0x0040, 0x921: 0x0008, 0x922: 0x0008, 0x923: 0x0008,
+	0x924: 0x0040, 0x925: 0x0008, 0x926: 0x0040, 0x927: 0x0008, 0x928: 0x0040, 0x929: 0x0040,
+	0x92a: 0x0008, 0x92b: 0x0008, 0x92c: 0x0040, 0x92d: 0x0008, 0x92e: 0x0008, 0x92f: 0x0008,
+	0x930: 0x0008, 0x931: 0x3308, 0x932: 0x0008, 0x933: 0x0929, 0x934: 0x3308, 0x935: 0x3308,
+	0x936: 0x3308, 0x937: 0x3308, 0x938: 0x3308, 0x939: 0x3308, 0x93a: 0x0040, 0x93b: 0x3308,
+	0x93c: 0x3308, 0x93d: 0x0008, 0x93e: 0x0040, 0x93f: 0x0040,
+	// Block 0x25, offset 0x940
+	0x940: 0x0008, 0x941: 0x0008, 0x942: 0x0008, 0x943: 0x09d1, 0x944: 0x0008, 0x945: 0x0008,
+	0x946: 0x0008, 0x947: 0x0008, 0x948: 0x0040, 0x949: 0x0008, 0x94a: 0x0008, 0x94b: 0x0008,
+	0x94c: 0x0008, 0x94d: 0x0a09, 0x94e: 0x0008, 0x94f: 0x0008, 0x950: 0x0008, 0x951: 0x0008,
+	0x952: 0x0a41, 0x953: 0x0008, 0x954: 0x0008, 0x955: 0x0008, 0x956: 0x0008, 0x957: 0x0a79,
+	0x958: 0x0008, 0x959: 0x0008, 0x95a: 0x0008, 0x95b: 0x0008, 0x95c: 0x0ab1, 0x95d: 0x0008,
+	0x95e: 0x0008, 0x95f: 0x0008, 0x960: 0x0008, 0x961: 0x0008, 0x962: 0x0008, 0x963: 0x0008,
+	0x964: 0x0008, 0x965: 0x0008, 0x966: 0x0008, 0x967: 0x0008, 0x968: 0x0008, 0x969: 0x0ae9,
+	0x96a: 0x0008, 0x96b: 0x0008, 0x96c: 0x0008, 0x96d: 0x0040, 0x96e: 0x0040, 0x96f: 0x0040,
+	0x970: 0x0040, 0x971: 0x3308, 0x972: 0x3308, 0x973: 0x0b21, 0x974: 0x3308, 0x975: 0x0b59,
+	0x976: 0x0b91, 0x977: 0x0bc9, 0x978: 0x0c19, 0x979: 0x0c51, 0x97a: 0x3308, 0x97b: 0x3308,
+	0x97c: 0x3308, 0x97d: 0x3308, 0x97e: 0x3308, 0x97f: 0x3008,
+	// Block 0x26, offset 0x980
+	0x980: 0x3308, 0x981: 0x0ca1, 0x982: 0x3308, 0x983: 0x3308, 0x984: 0x3b08, 0x985: 0x0018,
+	0x986: 0x3308, 0x987: 0x3308, 0x988: 0x0008, 0x989: 0x0008, 0x98a: 0x0008, 0x98b: 0x0008,
+	0x98c: 0x0008, 0x98d: 0x3308, 0x98e: 0x3308, 0x98f: 0x3308, 0x990: 0x3308, 0x991: 0x3308,
+	0x992: 0x3308, 0x993: 0x0cd9, 0x994: 0x3308, 0x995: 0x3308, 0x996: 0x3308, 0x997: 0x3308,
+	0x998: 0x0040, 0x999: 0x3308, 0x99a: 0x3308, 0x99b: 0x3308, 0x99c: 0x3308, 0x99d: 0x0d11,
+	0x99e: 0x3308, 0x99f: 0x3308, 0x9a0: 0x3308, 0x9a1: 0x3308, 0x9a2: 0x0d49, 0x9a3: 0x3308,
+	0x9a4: 0x3308, 0x9a5: 0x3308, 0x9a6: 0x3308, 0x9a7: 0x0d81, 0x9a8: 0x3308, 0x9a9: 0x3308,
+	0x9aa: 0x3308, 0x9ab: 0x3308, 0x9ac: 0x0db9, 0x9ad: 0x3308, 0x9ae: 0x3308, 0x9af: 0x3308,
+	0x9b0: 0x3308, 0x9b1: 0x3308, 0x9b2: 0x3308, 0x9b3: 0x3308, 0x9b4: 0x3308, 0x9b5: 0x3308,
+	0x9b6: 0x3308, 0x9b7: 0x3308, 0x9b8: 0x3308, 0x9b9: 0x0df1, 0x9ba: 0x3308, 0x9bb: 0x3308,
+	0x9bc: 0x3308, 0x9bd: 0x0040, 0x9be: 0x0018, 0x9bf: 0x0018,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x0008, 0x9c1: 0x0008, 0x9c2: 0x0008, 0x9c3: 0x0008, 0x9c4: 0x0008, 0x9c5: 0x0008,
+	0x9c6: 0x0008, 0x9c7: 0x0008, 0x9c8: 0x0008, 0x9c9: 0x0008, 0x9ca: 0x0008, 0x9cb: 0x0008,
+	0x9cc: 0x0008, 0x9cd: 0x0008, 0x9ce: 0x0008, 0x9cf: 0x0008, 0x9d0: 0x0008, 0x9d1: 0x0008,
+	0x9d2: 0x0008, 0x9d3: 0x0008, 0x9d4: 0x0008, 0x9d5: 0x0008, 0x9d6: 0x0008, 0x9d7: 0x0008,
+	0x9d8: 0x0008, 0x9d9: 0x0008, 0x9da: 0x0008, 0x9db: 0x0008, 0x9dc: 0x0008, 0x9dd: 0x0008,
+	0x9de: 0x0008, 0x9df: 0x0008, 0x9e0: 0x0008, 0x9e1: 0x0008, 0x9e2: 0x0008, 0x9e3: 0x0008,
+	0x9e4: 0x0008, 0x9e5: 0x0008, 0x9e6: 0x0008, 0x9e7: 0x0008, 0x9e8: 0x0008, 0x9e9: 0x0008,
+	0x9ea: 0x0008, 0x9eb: 0x0008, 0x9ec: 0x0039, 0x9ed: 0x0ed1, 0x9ee: 0x0ee9, 0x9ef: 0x0008,
+	0x9f0: 0x0ef9, 0x9f1: 0x0f09, 0x9f2: 0x0f19, 0x9f3: 0x0f31, 0x9f4: 0x0249, 0x9f5: 0x0f41,
+	0x9f6: 0x0259, 0x9f7: 0x0f51, 0x9f8: 0x0359, 0x9f9: 0x0f61, 0x9fa: 0x0f71, 0x9fb: 0x0008,
+	0x9fc: 0x00d9, 0x9fd: 0x0f81, 0x9fe: 0x0f99, 0x9ff: 0x0269,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0fa9, 0xa01: 0x0fb9, 0xa02: 0x0279, 0xa03: 0x0039, 0xa04: 0x0fc9, 0xa05: 0x0fe1,
+	0xa06: 0x059d, 0xa07: 0x0ee9, 0xa08: 0x0ef9, 0xa09: 0x0f09, 0xa0a: 0x0ff9, 0xa0b: 0x1011,
+	0xa0c: 0x1029, 0xa0d: 0x0f31, 0xa0e: 0x0008, 0xa0f: 0x0f51, 0xa10: 0x0f61, 0xa11: 0x1041,
+	0xa12: 0x00d9, 0xa13: 0x1059, 0xa14: 0x05b5, 0xa15: 0x05b5, 0xa16: 0x0f99, 0xa17: 0x0fa9,
+	0xa18: 0x0fb9, 0xa19: 0x059d, 0xa1a: 0x1071, 0xa1b: 0x1089, 0xa1c: 0x05cd, 0xa1d: 0x1099,
+	0xa1e: 0x10b1, 0xa1f: 0x10c9, 0xa20: 0x10e1, 0xa21: 0x10f9, 0xa22: 0x0f41, 0xa23: 0x0269,
+	0xa24: 0x0fb9, 0xa25: 0x1089, 0xa26: 0x1099, 0xa27: 0x10b1, 0xa28: 0x1111, 0xa29: 0x10e1,
+	0xa2a: 0x10f9, 0xa2b: 0x0008, 0xa2c: 0x0008, 0xa2d: 0x0008, 0xa2e: 0x0008, 0xa2f: 0x0008,
+	0xa30: 0x0008, 0xa31: 0x0008, 0xa32: 0x0008, 0xa33: 0x0008, 0xa34: 0x0008, 0xa35: 0x0008,
+	0xa36: 0x0008, 0xa37: 0x0008, 0xa38: 0x1129, 0xa39: 0x0008, 0xa3a: 0x0008, 0xa3b: 0x0008,
+	0xa3c: 0x0008, 0xa3d: 0x0008, 0xa3e: 0x0008, 0xa3f: 0x0008,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x0008, 0xa41: 0x0008, 0xa42: 0x0008, 0xa43: 0x0008, 0xa44: 0x0008, 0xa45: 0x0008,
+	0xa46: 0x0008, 0xa47: 0x0008, 0xa48: 0x0008, 0xa49: 0x0008, 0xa4a: 0x0008, 0xa4b: 0x0008,
+	0xa4c: 0x0008, 0xa4d: 0x0008, 0xa4e: 0x0008, 0xa4f: 0x0008, 0xa50: 0x0008, 0xa51: 0x0008,
+	0xa52: 0x0008, 0xa53: 0x0008, 0xa54: 0x0008, 0xa55: 0x0008, 0xa56: 0x0008, 0xa57: 0x0008,
+	0xa58: 0x0008, 0xa59: 0x0008, 0xa5a: 0x0008, 0xa5b: 0x1141, 0xa5c: 0x1159, 0xa5d: 0x1169,
+	0xa5e: 0x1181, 0xa5f: 0x1029, 0xa60: 0x1199, 0xa61: 0x11a9, 0xa62: 0x11c1, 0xa63: 0x11d9,
+	0xa64: 0x11f1, 0xa65: 0x1209, 0xa66: 0x1221, 0xa67: 0x05e5, 0xa68: 0x1239, 0xa69: 0x1251,
+	0xa6a: 0xe17d, 0xa6b: 0x1269, 0xa6c: 0x1281, 0xa6d: 0x1299, 0xa6e: 0x12b1, 0xa6f: 0x12c9,
+	0xa70: 0x12e1, 0xa71: 0x12f9, 0xa72: 0x1311, 0xa73: 0x1329, 0xa74: 0x1341, 0xa75: 0x1359,
+	0xa76: 0x1371, 0xa77: 0x1389, 0xa78: 0x05fd, 0xa79: 0x13a1, 0xa7a: 0x13b9, 0xa7b: 0x13d1,
+	0xa7c: 0x13e1, 0xa7d: 0x13f9, 0xa7e: 0x1411, 0xa7f: 0x1429,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0xe00d, 0xa81: 0x0008, 0xa82: 0xe00d, 0xa83: 0x0008, 0xa84: 0xe00d, 0xa85: 0x0008,
+	0xa86: 0xe00d, 0xa87: 0x0008, 0xa88: 0xe00d, 0xa89: 0x0008, 0xa8a: 0xe00d, 0xa8b: 0x0008,
+	0xa8c: 0xe00d, 0xa8d: 0x0008, 0xa8e: 0xe00d, 0xa8f: 0x0008, 0xa90: 0xe00d, 0xa91: 0x0008,
+	0xa92: 0xe00d, 0xa93: 0x0008, 0xa94: 0xe00d, 0xa95: 0x0008, 0xa96: 0xe00d, 0xa97: 0x0008,
+	0xa98: 0xe00d, 0xa99: 0x0008, 0xa9a: 0xe00d, 0xa9b: 0x0008, 0xa9c: 0xe00d, 0xa9d: 0x0008,
+	0xa9e: 0xe00d, 0xa9f: 0x0008, 0xaa0: 0xe00d, 0xaa1: 0x0008, 0xaa2: 0xe00d, 0xaa3: 0x0008,
+	0xaa4: 0xe00d, 0xaa5: 0x0008, 0xaa6: 0xe00d, 0xaa7: 0x0008, 0xaa8: 0xe00d, 0xaa9: 0x0008,
+	0xaaa: 0xe00d, 0xaab: 0x0008, 0xaac: 0xe00d, 0xaad: 0x0008, 0xaae: 0xe00d, 0xaaf: 0x0008,
+	0xab0: 0xe00d, 0xab1: 0x0008, 0xab2: 0xe00d, 0xab3: 0x0008, 0xab4: 0xe00d, 0xab5: 0x0008,
+	0xab6: 0xe00d, 0xab7: 0x0008, 0xab8: 0xe00d, 0xab9: 0x0008, 0xaba: 0xe00d, 0xabb: 0x0008,
+	0xabc: 0xe00d, 0xabd: 0x0008, 0xabe: 0xe00d, 0xabf: 0x0008,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0xe00d, 0xac1: 0x0008, 0xac2: 0xe00d, 0xac3: 0x0008, 0xac4: 0xe00d, 0xac5: 0x0008,
+	0xac6: 0xe00d, 0xac7: 0x0008, 0xac8: 0xe00d, 0xac9: 0x0008, 0xaca: 0xe00d, 0xacb: 0x0008,
+	0xacc: 0xe00d, 0xacd: 0x0008, 0xace: 0xe00d, 0xacf: 0x0008, 0xad0: 0xe00d, 0xad1: 0x0008,
+	0xad2: 0xe00d, 0xad3: 0x0008, 0xad4: 0xe00d, 0xad5: 0x0008, 0xad6: 0x0008, 0xad7: 0x0008,
+	0xad8: 0x0008, 0xad9: 0x0008, 0xada: 0x0615, 0xadb: 0x0635, 0xadc: 0x0008, 0xadd: 0x0008,
+	0xade: 0x1441, 0xadf: 0x0008, 0xae0: 0xe00d, 0xae1: 0x0008, 0xae2: 0xe00d, 0xae3: 0x0008,
+	0xae4: 0xe00d, 0xae5: 0x0008, 0xae6: 0xe00d, 0xae7: 0x0008, 0xae8: 0xe00d, 0xae9: 0x0008,
+	0xaea: 0xe00d, 0xaeb: 0x0008, 0xaec: 0xe00d, 0xaed: 0x0008, 0xaee: 0xe00d, 0xaef: 0x0008,
+	0xaf0: 0xe00d, 0xaf1: 0x0008, 0xaf2: 0xe00d, 0xaf3: 0x0008, 0xaf4: 0xe00d, 0xaf5: 0x0008,
+	0xaf6: 0xe00d, 0xaf7: 0x0008, 0xaf8: 0xe00d, 0xaf9: 0x0008, 0xafa: 0xe00d, 0xafb: 0x0008,
+	0xafc: 0xe00d, 0xafd: 0x0008, 0xafe: 0xe00d, 0xaff: 0x0008,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x0008, 0xb01: 0x0008, 0xb02: 0x0008, 0xb03: 0x0008, 0xb04: 0x0008, 0xb05: 0x0008,
+	0xb06: 0x0040, 0xb07: 0x0040, 0xb08: 0xe045, 0xb09: 0xe045, 0xb0a: 0xe045, 0xb0b: 0xe045,
+	0xb0c: 0xe045, 0xb0d: 0xe045, 0xb0e: 0x0040, 0xb0f: 0x0040, 0xb10: 0x0008, 0xb11: 0x0008,
+	0xb12: 0x0008, 0xb13: 0x0008, 0xb14: 0x0008, 0xb15: 0x0008, 0xb16: 0x0008, 0xb17: 0x0008,
+	0xb18: 0x0040, 0xb19: 0xe045, 0xb1a: 0x0040, 0xb1b: 0xe045, 0xb1c: 0x0040, 0xb1d: 0xe045,
+	0xb1e: 0x0040, 0xb1f: 0xe045, 0xb20: 0x0008, 0xb21: 0x0008, 0xb22: 0x0008, 0xb23: 0x0008,
+	0xb24: 0x0008, 0xb25: 0x0008, 0xb26: 0x0008, 0xb27: 0x0008, 0xb28: 0xe045, 0xb29: 0xe045,
+	0xb2a: 0xe045, 0xb2b: 0xe045, 0xb2c: 0xe045, 0xb2d: 0xe045, 0xb2e: 0xe045, 0xb2f: 0xe045,
+	0xb30: 0x0008, 0xb31: 0x1459, 0xb32: 0x0008, 0xb33: 0x1471, 0xb34: 0x0008, 0xb35: 0x1489,
+	0xb36: 0x0008, 0xb37: 0x14a1, 0xb38: 0x0008, 0xb39: 0x14b9, 0xb3a: 0x0008, 0xb3b: 0x14d1,
+	0xb3c: 0x0008, 0xb3d: 0x14e9, 0xb3e: 0x0040, 0xb3f: 0x0040,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x1501, 0xb41: 0x1531, 0xb42: 0x1561, 0xb43: 0x1591, 0xb44: 0x15c1, 0xb45: 0x15f1,
+	0xb46: 0x1621, 0xb47: 0x1651, 0xb48: 0x1501, 0xb49: 0x1531, 0xb4a: 0x1561, 0xb4b: 0x1591,
+	0xb4c: 0x15c1, 0xb4d: 0x15f1, 0xb4e: 0x1621, 0xb4f: 0x1651, 0xb50: 0x1681, 0xb51: 0x16b1,
+	0xb52: 0x16e1, 0xb53: 0x1711, 0xb54: 0x1741, 0xb55: 0x1771, 0xb56: 0x17a1, 0xb57: 0x17d1,
+	0xb58: 0x1681, 0xb59: 0x16b1, 0xb5a: 0x16e1, 0xb5b: 0x1711, 0xb5c: 0x1741, 0xb5d: 0x1771,
+	0xb5e: 0x17a1, 0xb5f: 0x17d1, 0xb60: 0x1801, 0xb61: 0x1831, 0xb62: 0x1861, 0xb63: 0x1891,
+	0xb64: 0x18c1, 0xb65: 0x18f1, 0xb66: 0x1921, 0xb67: 0x1951, 0xb68: 0x1801, 0xb69: 0x1831,
+	0xb6a: 0x1861, 0xb6b: 0x1891, 0xb6c: 0x18c1, 0xb6d: 0x18f1, 0xb6e: 0x1921, 0xb6f: 0x1951,
+	0xb70: 0x0008, 0xb71: 0x0008, 0xb72: 0x1981, 0xb73: 0x19b1, 0xb74: 0x19d9, 0xb75: 0x0040,
+	0xb76: 0x0008, 0xb77: 0x1a01, 0xb78: 0xe045, 0xb79: 0xe045, 0xb7a: 0x064d, 0xb7b: 0x1459,
+	0xb7c: 0x19b1, 0xb7d: 0x0666, 0xb7e: 0x1a31, 0xb7f: 0x0686,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x06a6, 0xb81: 0x1a4a, 0xb82: 0x1a79, 0xb83: 0x1aa9, 0xb84: 0x1ad1, 0xb85: 0x0040,
+	0xb86: 0x0008, 0xb87: 0x1af9, 0xb88: 0x06c5, 0xb89: 0x1471, 0xb8a: 0x06dd, 0xb8b: 0x1489,
+	0xb8c: 0x1aa9, 0xb8d: 0x1b2a, 0xb8e: 0x1b5a, 0xb8f: 0x1b8a, 0xb90: 0x0008, 0xb91: 0x0008,
+	0xb92: 0x0008, 0xb93: 0x1bb9, 0xb94: 0x0040, 0xb95: 0x0040, 0xb96: 0x0008, 0xb97: 0x0008,
+	0xb98: 0xe045, 0xb99: 0xe045, 0xb9a: 0x06f5, 0xb9b: 0x14a1, 0xb9c: 0x0040, 0xb9d: 0x1bd2,
+	0xb9e: 0x1c02, 0xb9f: 0x1c32, 0xba0: 0x0008, 0xba1: 0x0008, 0xba2: 0x0008, 0xba3: 0x1c61,
+	0xba4: 0x0008, 0xba5: 0x0008, 0xba6: 0x0008, 0xba7: 0x0008, 0xba8: 0xe045, 0xba9: 0xe045,
+	0xbaa: 0x070d, 0xbab: 0x14d1, 0xbac: 0xe04d, 0xbad: 0x1c7a, 0xbae: 0x03d2, 0xbaf: 0x1caa,
+	0xbb0: 0x0040, 0xbb1: 0x0040, 0xbb2: 0x1cb9, 0xbb3: 0x1ce9, 0xbb4: 0x1d11, 0xbb5: 0x0040,
+	0xbb6: 0x0008, 0xbb7: 0x1d39, 0xbb8: 0x0725, 0xbb9: 0x14b9, 0xbba: 0x0515, 0xbbb: 0x14e9,
+	0xbbc: 0x1ce9, 0xbbd: 0x073e, 0xbbe: 0x075e, 0xbbf: 0x0040,
+	// Block 0x2f, offset 0xbc0
+	0xbc0: 0x000a, 0xbc1: 0x000a, 0xbc2: 0x000a, 0xbc3: 0x000a, 0xbc4: 0x000a, 0xbc5: 0x000a,
+	0xbc6: 0x000a, 0xbc7: 0x000a, 0xbc8: 0x000a, 0xbc9: 0x000a, 0xbca: 0x000a, 0xbcb: 0x03c0,
+	0xbcc: 0x0003, 0xbcd: 0x0003, 0xbce: 0x0340, 0xbcf: 0x0b40, 0xbd0: 0x0018, 0xbd1: 0xe00d,
+	0xbd2: 0x0018, 0xbd3: 0x0018, 0xbd4: 0x0018, 0xbd5: 0x0018, 0xbd6: 0x0018, 0xbd7: 0x077e,
+	0xbd8: 0x0018, 0xbd9: 0x0018, 0xbda: 0x0018, 0xbdb: 0x0018, 0xbdc: 0x0018, 0xbdd: 0x0018,
+	0xbde: 0x0018, 0xbdf: 0x0018, 0xbe0: 0x0018, 0xbe1: 0x0018, 0xbe2: 0x0018, 0xbe3: 0x0018,
+	0xbe4: 0x0040, 0xbe5: 0x0040, 0xbe6: 0x0040, 0xbe7: 0x0018, 0xbe8: 0x0040, 0xbe9: 0x0040,
+	0xbea: 0x0340, 0xbeb: 0x0340, 0xbec: 0x0340, 0xbed: 0x0340, 0xbee: 0x0340, 0xbef: 0x000a,
+	0xbf0: 0x0018, 0xbf1: 0x0018, 0xbf2: 0x0018, 0xbf3: 0x1d69, 0xbf4: 0x1da1, 0xbf5: 0x0018,
+	0xbf6: 0x1df1, 0xbf7: 0x1e29, 0xbf8: 0x0018, 0xbf9: 0x0018, 0xbfa: 0x0018, 0xbfb: 0x0018,
+	0xbfc: 0x1e7a, 0xbfd: 0x0018, 0xbfe: 0x079e, 0xbff: 0x0018,
+	// Block 0x30, offset 0xc00
+	0xc00: 0x0018, 0xc01: 0x0018, 0xc02: 0x0018, 0xc03: 0x0018, 0xc04: 0x0018, 0xc05: 0x0018,
+	0xc06: 0x0018, 0xc07: 0x1e92, 0xc08: 0x1eaa, 0xc09: 0x1ec2, 0xc0a: 0x0018, 0xc0b: 0x0018,
+	0xc0c: 0x0018, 0xc0d: 0x0018, 0xc0e: 0x0018, 0xc0f: 0x0018, 0xc10: 0x0018, 0xc11: 0x0018,
+	0xc12: 0x0018, 0xc13: 0x0018, 0xc14: 0x0018, 0xc15: 0x0018, 0xc16: 0x0018, 0xc17: 0x1ed9,
+	0xc18: 0x0018, 0xc19: 0x0018, 0xc1a: 0x0018, 0xc1b: 0x0018, 0xc1c: 0x0018, 0xc1d: 0x0018,
+	0xc1e: 0x0018, 0xc1f: 0x000a, 0xc20: 0x03c0, 0xc21: 0x0340, 0xc22: 0x0340, 0xc23: 0x0340,
+	0xc24: 0x03c0, 0xc25: 0x0040, 0xc26: 0x0040, 0xc27: 0x0040, 0xc28: 0x0040, 0xc29: 0x0040,
+	0xc2a: 0x0340, 0xc2b: 0x0340, 0xc2c: 0x0340, 0xc2d: 0x0340, 0xc2e: 0x0340, 0xc2f: 0x0340,
+	0xc30: 0x1f41, 0xc31: 0x0f41, 0xc32: 0x0040, 0xc33: 0x0040, 0xc34: 0x1f51, 0xc35: 0x1f61,
+	0xc36: 0x1f71, 0xc37: 0x1f81, 0xc38: 0x1f91, 0xc39: 0x1fa1, 0xc3a: 0x1fb2, 0xc3b: 0x07bd,
+	0xc3c: 0x1fc2, 0xc3d: 0x1fd2, 0xc3e: 0x1fe2, 0xc3f: 0x0f71,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x1f41, 0xc41: 0x00c9, 0xc42: 0x0069, 0xc43: 0x0079, 0xc44: 0x1f51, 0xc45: 0x1f61,
+	0xc46: 0x1f71, 0xc47: 0x1f81, 0xc48: 0x1f91, 0xc49: 0x1fa1, 0xc4a: 0x1fb2, 0xc4b: 0x07d5,
+	0xc4c: 0x1fc2, 0xc4d: 0x1fd2, 0xc4e: 0x1fe2, 0xc4f: 0x0040, 0xc50: 0x0039, 0xc51: 0x0f09,
+	0xc52: 0x00d9, 0xc53: 0x0369, 0xc54: 0x0ff9, 0xc55: 0x0249, 0xc56: 0x0f51, 0xc57: 0x0359,
+	0xc58: 0x0f61, 0xc59: 0x0f71, 0xc5a: 0x0f99, 0xc5b: 0x01d9, 0xc5c: 0x0fa9, 0xc5d: 0x0040,
+	0xc5e: 0x0040, 0xc5f: 0x0040, 0xc60: 0x0018, 0xc61: 0x0018, 0xc62: 0x0018, 0xc63: 0x0018,
+	0xc64: 0x0018, 0xc65: 0x0018, 0xc66: 0x0018, 0xc67: 0x0018, 0xc68: 0x1ff1, 0xc69: 0x0018,
+	0xc6a: 0x0018, 0xc6b: 0x0018, 0xc6c: 0x0018, 0xc6d: 0x0018, 0xc6e: 0x0018, 0xc6f: 0x0018,
+	0xc70: 0x0018, 0xc71: 0x0018, 0xc72: 0x0018, 0xc73: 0x0018, 0xc74: 0x0018, 0xc75: 0x0018,
+	0xc76: 0x0018, 0xc77: 0x0018, 0xc78: 0x0018, 0xc79: 0x0018, 0xc7a: 0x0018, 0xc7b: 0x0018,
+	0xc7c: 0x0018, 0xc7d: 0x0018, 0xc7e: 0x0018, 0xc7f: 0x0018,
+	// Block 0x32, offset 0xc80
+	0xc80: 0x07ee, 0xc81: 0x080e, 0xc82: 0x1159, 0xc83: 0x082d, 0xc84: 0x0018, 0xc85: 0x084e,
+	0xc86: 0x086e, 0xc87: 0x1011, 0xc88: 0x0018, 0xc89: 0x088d, 0xc8a: 0x0f31, 0xc8b: 0x0249,
+	0xc8c: 0x0249, 0xc8d: 0x0249, 0xc8e: 0x0249, 0xc8f: 0x2009, 0xc90: 0x0f41, 0xc91: 0x0f41,
+	0xc92: 0x0359, 0xc93: 0x0359, 0xc94: 0x0018, 0xc95: 0x0f71, 0xc96: 0x2021, 0xc97: 0x0018,
+	0xc98: 0x0018, 0xc99: 0x0f99, 0xc9a: 0x2039, 0xc9b: 0x0269, 0xc9c: 0x0269, 0xc9d: 0x0269,
+	0xc9e: 0x0018, 0xc9f: 0x0018, 0xca0: 0x2049, 0xca1: 0x08ad, 0xca2: 0x2061, 0xca3: 0x0018,
+	0xca4: 0x13d1, 0xca5: 0x0018, 0xca6: 0x2079, 0xca7: 0x0018, 0xca8: 0x13d1, 0xca9: 0x0018,
+	0xcaa: 0x0f51, 0xcab: 0x2091, 0xcac: 0x0ee9, 0xcad: 0x1159, 0xcae: 0x0018, 0xcaf: 0x0f09,
+	0xcb0: 0x0f09, 0xcb1: 0x1199, 0xcb2: 0x0040, 0xcb3: 0x0f61, 0xcb4: 0x00d9, 0xcb5: 0x20a9,
+	0xcb6: 0x20c1, 0xcb7: 0x20d9, 0xcb8: 0x20f1, 0xcb9: 0x0f41, 0xcba: 0x0018, 0xcbb: 0x08cd,
+	0xcbc: 0x2109, 0xcbd: 0x10b1, 0xcbe: 0x10b1, 0xcbf: 0x2109,
+	// Block 0x33, offset 0xcc0
+	0xcc0: 0x08ed, 0xcc1: 0x0018, 0xcc2: 0x0018, 0xcc3: 0x0018, 0xcc4: 0x0018, 0xcc5: 0x0ef9,
+	0xcc6: 0x0ef9, 0xcc7: 0x0f09, 0xcc8: 0x0f41, 0xcc9: 0x0259, 0xcca: 0x0018, 0xccb: 0x0018,
+	0xccc: 0x0018, 0xccd: 0x0018, 0xcce: 0x0008, 0xccf: 0x0018, 0xcd0: 0x2121, 0xcd1: 0x2151,
+	0xcd2: 0x2181, 0xcd3: 0x21b9, 0xcd4: 0x21e9, 0xcd5: 0x2219, 0xcd6: 0x2249, 0xcd7: 0x2279,
+	0xcd8: 0x22a9, 0xcd9: 0x22d9, 0xcda: 0x2309, 0xcdb: 0x2339, 0xcdc: 0x2369, 0xcdd: 0x2399,
+	0xcde: 0x23c9, 0xcdf: 0x23f9, 0xce0: 0x0f41, 0xce1: 0x2421, 0xce2: 0x0905, 0xce3: 0x2439,
+	0xce4: 0x1089, 0xce5: 0x2451, 0xce6: 0x0925, 0xce7: 0x2469, 0xce8: 0x2491, 0xce9: 0x0369,
+	0xcea: 0x24a9, 0xceb: 0x0945, 0xcec: 0x0359, 0xced: 0x1159, 0xcee: 0x0ef9, 0xcef: 0x0f61,
+	0xcf0: 0x0f41, 0xcf1: 0x2421, 0xcf2: 0x0965, 0xcf3: 0x2439, 0xcf4: 0x1089, 0xcf5: 0x2451,
+	0xcf6: 0x0985, 0xcf7: 0x2469, 0xcf8: 0x2491, 0xcf9: 0x0369, 0xcfa: 0x24a9, 0xcfb: 0x09a5,
+	0xcfc: 0x0359, 0xcfd: 0x1159, 0xcfe: 0x0ef9, 0xcff: 0x0f61,
+	// Block 0x34, offset 0xd00
+	0xd00: 0x0018, 0xd01: 0x0018, 0xd02: 0x0018, 0xd03: 0x0018, 0xd04: 0x0018, 0xd05: 0x0018,
+	0xd06: 0x0018, 0xd07: 0x0018, 0xd08: 0x0018, 0xd09: 0x0018, 0xd0a: 0x0018, 0xd0b: 0x0040,
+	0xd0c: 0x0040, 0xd0d: 0x0040, 0xd0e: 0x0040, 0xd0f: 0x0040, 0xd10: 0x0040, 0xd11: 0x0040,
+	0xd12: 0x0040, 0xd13: 0x0040, 0xd14: 0x0040, 0xd15: 0x0040, 0xd16: 0x0040, 0xd17: 0x0040,
+	0xd18: 0x0040, 0xd19: 0x0040, 0xd1a: 0x0040, 0xd1b: 0x0040, 0xd1c: 0x0040, 0xd1d: 0x0040,
+	0xd1e: 0x0040, 0xd1f: 0x0040, 0xd20: 0x00c9, 0xd21: 0x0069, 0xd22: 0x0079, 0xd23: 0x1f51,
+	0xd24: 0x1f61, 0xd25: 0x1f71, 0xd26: 0x1f81, 0xd27: 0x1f91, 0xd28: 0x1fa1, 0xd29: 0x2601,
+	0xd2a: 0x2619, 0xd2b: 0x2631, 0xd2c: 0x2649, 0xd2d: 0x2661, 0xd2e: 0x2679, 0xd2f: 0x2691,
+	0xd30: 0x26a9, 0xd31: 0x26c1, 0xd32: 0x26d9, 0xd33: 0x26f1, 0xd34: 0x0a06, 0xd35: 0x0a26,
+	0xd36: 0x0a46, 0xd37: 0x0a66, 0xd38: 0x0a86, 0xd39: 0x0aa6, 0xd3a: 0x0ac6, 0xd3b: 0x0ae6,
+	0xd3c: 0x0b06, 0xd3d: 0x270a, 0xd3e: 0x2732, 0xd3f: 0x275a,
+	// Block 0x35, offset 0xd40
+	0xd40: 0x2782, 0xd41: 0x27aa, 0xd42: 0x27d2, 0xd43: 0x27fa, 0xd44: 0x2822, 0xd45: 0x284a,
+	0xd46: 0x2872, 0xd47: 0x289a, 0xd48: 0x0040, 0xd49: 0x0040, 0xd4a: 0x0040, 0xd4b: 0x0040,
+	0xd4c: 0x0040, 0xd4d: 0x0040, 0xd4e: 0x0040, 0xd4f: 0x0040, 0xd50: 0x0040, 0xd51: 0x0040,
+	0xd52: 0x0040, 0xd53: 0x0040, 0xd54: 0x0040, 0xd55: 0x0040, 0xd56: 0x0040, 0xd57: 0x0040,
+	0xd58: 0x0040, 0xd59: 0x0040, 0xd5a: 0x0040, 0xd5b: 0x0040, 0xd5c: 0x0b26, 0xd5d: 0x0b46,
+	0xd5e: 0x0b66, 0xd5f: 0x0b86, 0xd60: 0x0ba6, 0xd61: 0x0bc6, 0xd62: 0x0be6, 0xd63: 0x0c06,
+	0xd64: 0x0c26, 0xd65: 0x0c46, 0xd66: 0x0c66, 0xd67: 0x0c86, 0xd68: 0x0ca6, 0xd69: 0x0cc6,
+	0xd6a: 0x0ce6, 0xd6b: 0x0d06, 0xd6c: 0x0d26, 0xd6d: 0x0d46, 0xd6e: 0x0d66, 0xd6f: 0x0d86,
+	0xd70: 0x0da6, 0xd71: 0x0dc6, 0xd72: 0x0de6, 0xd73: 0x0e06, 0xd74: 0x0e26, 0xd75: 0x0e46,
+	0xd76: 0x0039, 0xd77: 0x0ee9, 0xd78: 0x1159, 0xd79: 0x0ef9, 0xd7a: 0x0f09, 0xd7b: 0x1199,
+	0xd7c: 0x0f31, 0xd7d: 0x0249, 0xd7e: 0x0f41, 0xd7f: 0x0259,
+	// Block 0x36, offset 0xd80
+	0xd80: 0x0f51, 0xd81: 0x0359, 0xd82: 0x0f61, 0xd83: 0x0f71, 0xd84: 0x00d9, 0xd85: 0x0f99,
+	0xd86: 0x2039, 0xd87: 0x0269, 0xd88: 0x01d9, 0xd89: 0x0fa9, 0xd8a: 0x0fb9, 0xd8b: 0x1089,
+	0xd8c: 0x0279, 0xd8d: 0x0369, 0xd8e: 0x0289, 0xd8f: 0x13d1, 0xd90: 0x0039, 0xd91: 0x0ee9,
+	0xd92: 0x1159, 0xd93: 0x0ef9, 0xd94: 0x0f09, 0xd95: 0x1199, 0xd96: 0x0f31, 0xd97: 0x0249,
+	0xd98: 0x0f41, 0xd99: 0x0259, 0xd9a: 0x0f51, 0xd9b: 0x0359, 0xd9c: 0x0f61, 0xd9d: 0x0f71,
+	0xd9e: 0x00d9, 0xd9f: 0x0f99, 0xda0: 0x2039, 0xda1: 0x0269, 0xda2: 0x01d9, 0xda3: 0x0fa9,
+	0xda4: 0x0fb9, 0xda5: 0x1089, 0xda6: 0x0279, 0xda7: 0x0369, 0xda8: 0x0289, 0xda9: 0x13d1,
+	0xdaa: 0x1f41, 0xdab: 0x0018, 0xdac: 0x0018, 0xdad: 0x0018, 0xdae: 0x0018, 0xdaf: 0x0018,
+	0xdb0: 0x0018, 0xdb1: 0x0018, 0xdb2: 0x0018, 0xdb3: 0x0018, 0xdb4: 0x0018, 0xdb5: 0x0018,
+	0xdb6: 0x0018, 0xdb7: 0x0018, 0xdb8: 0x0018, 0xdb9: 0x0018, 0xdba: 0x0018, 0xdbb: 0x0018,
+	0xdbc: 0x0018, 0xdbd: 0x0018, 0xdbe: 0x0018, 0xdbf: 0x0018,
+	// Block 0x37, offset 0xdc0
+	0xdc0: 0x0008, 0xdc1: 0x0008, 0xdc2: 0x0008, 0xdc3: 0x0008, 0xdc4: 0x0008, 0xdc5: 0x0008,
+	0xdc6: 0x0008, 0xdc7: 0x0008, 0xdc8: 0x0008, 0xdc9: 0x0008, 0xdca: 0x0008, 0xdcb: 0x0008,
+	0xdcc: 0x0008, 0xdcd: 0x0008, 0xdce: 0x0008, 0xdcf: 0x0008, 0xdd0: 0x0008, 0xdd1: 0x0008,
+	0xdd2: 0x0008, 0xdd3: 0x0008, 0xdd4: 0x0008, 0xdd5: 0x0008, 0xdd6: 0x0008, 0xdd7: 0x0008,
+	0xdd8: 0x0008, 0xdd9: 0x0008, 0xdda: 0x0008, 0xddb: 0x0008, 0xddc: 0x0008, 0xddd: 0x0008,
+	0xdde: 0x0008, 0xddf: 0x0040, 0xde0: 0xe00d, 0xde1: 0x0008, 0xde2: 0x2971, 0xde3: 0x0ebd,
+	0xde4: 0x2989, 0xde5: 0x0008, 0xde6: 0x0008, 0xde7: 0xe07d, 0xde8: 0x0008, 0xde9: 0xe01d,
+	0xdea: 0x0008, 0xdeb: 0xe03d, 0xdec: 0x0008, 0xded: 0x0fe1, 0xdee: 0x1281, 0xdef: 0x0fc9,
+	0xdf0: 0x1141, 0xdf1: 0x0008, 0xdf2: 0xe00d, 0xdf3: 0x0008, 0xdf4: 0x0008, 0xdf5: 0xe01d,
+	0xdf6: 0x0008, 0xdf7: 0x0008, 0xdf8: 0x0008, 0xdf9: 0x0008, 0xdfa: 0x0008, 0xdfb: 0x0008,
+	0xdfc: 0x0259, 0xdfd: 0x1089, 0xdfe: 0x29a1, 0xdff: 0x29b9,
+	// Block 0x38, offset 0xe00
+	0xe00: 0xe00d, 0xe01: 0x0008, 0xe02: 0xe00d, 0xe03: 0x0008, 0xe04: 0xe00d, 0xe05: 0x0008,
+	0xe06: 0xe00d, 0xe07: 0x0008, 0xe08: 0xe00d, 0xe09: 0x0008, 0xe0a: 0xe00d, 0xe0b: 0x0008,
+	0xe0c: 0xe00d, 0xe0d: 0x0008, 0xe0e: 0xe00d, 0xe0f: 0x0008, 0xe10: 0xe00d, 0xe11: 0x0008,
+	0xe12: 0xe00d, 0xe13: 0x0008, 0xe14: 0xe00d, 0xe15: 0x0008, 0xe16: 0xe00d, 0xe17: 0x0008,
+	0xe18: 0xe00d, 0xe19: 0x0008, 0xe1a: 0xe00d, 0xe1b: 0x0008, 0xe1c: 0xe00d, 0xe1d: 0x0008,
+	0xe1e: 0xe00d, 0xe1f: 0x0008, 0xe20: 0xe00d, 0xe21: 0x0008, 0xe22: 0xe00d, 0xe23: 0x0008,
+	0xe24: 0x0008, 0xe25: 0x0018, 0xe26: 0x0018, 0xe27: 0x0018, 0xe28: 0x0018, 0xe29: 0x0018,
+	0xe2a: 0x0018, 0xe2b: 0xe03d, 0xe2c: 0x0008, 0xe2d: 0xe01d, 0xe2e: 0x0008, 0xe2f: 0x3308,
+	0xe30: 0x3308, 0xe31: 0x3308, 0xe32: 0xe00d, 0xe33: 0x0008, 0xe34: 0x0040, 0xe35: 0x0040,
+	0xe36: 0x0040, 0xe37: 0x0040, 0xe38: 0x0040, 0xe39: 0x0018, 0xe3a: 0x0018, 0xe3b: 0x0018,
+	0xe3c: 0x0018, 0xe3d: 0x0018, 0xe3e: 0x0018, 0xe3f: 0x0018,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x26fd, 0xe41: 0x271d, 0xe42: 0x273d, 0xe43: 0x275d, 0xe44: 0x277d, 0xe45: 0x279d,
+	0xe46: 0x27bd, 0xe47: 0x27dd, 0xe48: 0x27fd, 0xe49: 0x281d, 0xe4a: 0x283d, 0xe4b: 0x285d,
+	0xe4c: 0x287d, 0xe4d: 0x289d, 0xe4e: 0x28bd, 0xe4f: 0x28dd, 0xe50: 0x28fd, 0xe51: 0x291d,
+	0xe52: 0x293d, 0xe53: 0x295d, 0xe54: 0x297d, 0xe55: 0x299d, 0xe56: 0x0040, 0xe57: 0x0040,
+	0xe58: 0x0040, 0xe59: 0x0040, 0xe5a: 0x0040, 0xe5b: 0x0040, 0xe5c: 0x0040, 0xe5d: 0x0040,
+	0xe5e: 0x0040, 0xe5f: 0x0040, 0xe60: 0x0040, 0xe61: 0x0040, 0xe62: 0x0040, 0xe63: 0x0040,
+	0xe64: 0x0040, 0xe65: 0x0040, 0xe66: 0x0040, 0xe67: 0x0040, 0xe68: 0x0040, 0xe69: 0x0040,
+	0xe6a: 0x0040, 0xe6b: 0x0040, 0xe6c: 0x0040, 0xe6d: 0x0040, 0xe6e: 0x0040, 0xe6f: 0x0040,
+	0xe70: 0x0040, 0xe71: 0x0040, 0xe72: 0x0040, 0xe73: 0x0040, 0xe74: 0x0040, 0xe75: 0x0040,
+	0xe76: 0x0040, 0xe77: 0x0040, 0xe78: 0x0040, 0xe79: 0x0040, 0xe7a: 0x0040, 0xe7b: 0x0040,
+	0xe7c: 0x0040, 0xe7d: 0x0040, 0xe7e: 0x0040, 0xe7f: 0x0040,
+	// Block 0x3a, offset 0xe80
+	0xe80: 0x000a, 0xe81: 0x0018, 0xe82: 0x29d1, 0xe83: 0x0018, 0xe84: 0x0018, 0xe85: 0x0008,
+	0xe86: 0x0008, 0xe87: 0x0008, 0xe88: 0x0018, 0xe89: 0x0018, 0xe8a: 0x0018, 0xe8b: 0x0018,
+	0xe8c: 0x0018, 0xe8d: 0x0018, 0xe8e: 0x0018, 0xe8f: 0x0018, 0xe90: 0x0018, 0xe91: 0x0018,
+	0xe92: 0x0018, 0xe93: 0x0018, 0xe94: 0x0018, 0xe95: 0x0018, 0xe96: 0x0018, 0xe97: 0x0018,
+	0xe98: 0x0018, 0xe99: 0x0018, 0xe9a: 0x0018, 0xe9b: 0x0018, 0xe9c: 0x0018, 0xe9d: 0x0018,
+	0xe9e: 0x0018, 0xe9f: 0x0018, 0xea0: 0x0018, 0xea1: 0x0018, 0xea2: 0x0018, 0xea3: 0x0018,
+	0xea4: 0x0018, 0xea5: 0x0018, 0xea6: 0x0018, 0xea7: 0x0018, 0xea8: 0x0018, 0xea9: 0x0018,
+	0xeaa: 0x3308, 0xeab: 0x3308, 0xeac: 0x3308, 0xead: 0x3308, 0xeae: 0x3018, 0xeaf: 0x3018,
+	0xeb0: 0x0018, 0xeb1: 0x0018, 0xeb2: 0x0018, 0xeb3: 0x0018, 0xeb4: 0x0018, 0xeb5: 0x0018,
+	0xeb6: 0xe125, 0xeb7: 0x0018, 0xeb8: 0x29bd, 0xeb9: 0x29dd, 0xeba: 0x29fd, 0xebb: 0x0018,
+	0xebc: 0x0008, 0xebd: 0x0018, 0xebe: 0x0018, 0xebf: 0x0018,
+	// Block 0x3b, offset 0xec0
+	0xec0: 0x2b3d, 0xec1: 0x2b5d, 0xec2: 0x2b7d, 0xec3: 0x2b9d, 0xec4: 0x2bbd, 0xec5: 0x2bdd,
+	0xec6: 0x2bdd, 0xec7: 0x2bdd, 0xec8: 0x2bfd, 0xec9: 0x2bfd, 0xeca: 0x2bfd, 0xecb: 0x2bfd,
+	0xecc: 0x2c1d, 0xecd: 0x2c1d, 0xece: 0x2c1d, 0xecf: 0x2c3d, 0xed0: 0x2c5d, 0xed1: 0x2c5d,
+	0xed2: 0x2a7d, 0xed3: 0x2a7d, 0xed4: 0x2c5d, 0xed5: 0x2c5d, 0xed6: 0x2c7d, 0xed7: 0x2c7d,
+	0xed8: 0x2c5d, 0xed9: 0x2c5d, 0xeda: 0x2a7d, 0xedb: 0x2a7d, 0xedc: 0x2c5d, 0xedd: 0x2c5d,
+	0xede: 0x2c3d, 0xedf: 0x2c3d, 0xee0: 0x2c9d, 0xee1: 0x2c9d, 0xee2: 0x2cbd, 0xee3: 0x2cbd,
+	0xee4: 0x0040, 0xee5: 0x2cdd, 0xee6: 0x2cfd, 0xee7: 0x2d1d, 0xee8: 0x2d1d, 0xee9: 0x2d3d,
+	0xeea: 0x2d5d, 0xeeb: 0x2d7d, 0xeec: 0x2d9d, 0xeed: 0x2dbd, 0xeee: 0x2ddd, 0xeef: 0x2dfd,
+	0xef0: 0x2e1d, 0xef1: 0x2e3d, 0xef2: 0x2e3d, 0xef3: 0x2e5d, 0xef4: 0x2e7d, 0xef5: 0x2e7d,
+	0xef6: 0x2e9d, 0xef7: 0x2ebd, 0xef8: 0x2e5d, 0xef9: 0x2edd, 0xefa: 0x2efd, 0xefb: 0x2edd,
+	0xefc: 0x2e5d, 0xefd: 0x2f1d, 0xefe: 0x2f3d, 0xeff: 0x2f5d,
+	// Block 0x3c, offset 0xf00
+	0xf00: 0x2f7d, 0xf01: 0x2f9d, 0xf02: 0x2cfd, 0xf03: 0x2cdd, 0xf04: 0x2fbd, 0xf05: 0x2fdd,
+	0xf06: 0x2ffd, 0xf07: 0x301d, 0xf08: 0x303d, 0xf09: 0x305d, 0xf0a: 0x307d, 0xf0b: 0x309d,
+	0xf0c: 0x30bd, 0xf0d: 0x30dd, 0xf0e: 0x30fd, 0xf0f: 0x0040, 0xf10: 0x0018, 0xf11: 0x0018,
+	0xf12: 0x311d, 0xf13: 0x313d, 0xf14: 0x315d, 0xf15: 0x317d, 0xf16: 0x319d, 0xf17: 0x31bd,
+	0xf18: 0x31dd, 0xf19: 0x31fd, 0xf1a: 0x321d, 0xf1b: 0x323d, 0xf1c: 0x315d, 0xf1d: 0x325d,
+	0xf1e: 0x327d, 0xf1f: 0x329d, 0xf20: 0x0008, 0xf21: 0x0008, 0xf22: 0x0008, 0xf23: 0x0008,
+	0xf24: 0x0008, 0xf25: 0x0008, 0xf26: 0x0008, 0xf27: 0x0008, 0xf28: 0x0008, 0xf29: 0x0008,
+	0xf2a: 0x0008, 0xf2b: 0x0008, 0xf2c: 0x0008, 0xf2d: 0x0008, 0xf2e: 0x0008, 0xf2f: 0x0008,
+	0xf30: 0x0008, 0xf31: 0x0008, 0xf32: 0x0008, 0xf33: 0x0008, 0xf34: 0x0008, 0xf35: 0x0008,
+	0xf36: 0x0008, 0xf37: 0x0008, 0xf38: 0x0008, 0xf39: 0x0008, 0xf3a: 0x0008, 0xf3b: 0x0040,
+	0xf3c: 0x0040, 0xf3d: 0x0040, 0xf3e: 0x0040, 0xf3f: 0x0040,
+	// Block 0x3d, offset 0xf40
+	0xf40: 0x36a2, 0xf41: 0x36d2, 0xf42: 0x3702, 0xf43: 0x3732, 0xf44: 0x32bd, 0xf45: 0x32dd,
+	0xf46: 0x32fd, 0xf47: 0x331d, 0xf48: 0x0018, 0xf49: 0x0018, 0xf4a: 0x0018, 0xf4b: 0x0018,
+	0xf4c: 0x0018, 0xf4d: 0x0018, 0xf4e: 0x0018, 0xf4f: 0x0018, 0xf50: 0x333d, 0xf51: 0x3761,
+	0xf52: 0x3779, 0xf53: 0x3791, 0xf54: 0x37a9, 0xf55: 0x37c1, 0xf56: 0x37d9, 0xf57: 0x37f1,
+	0xf58: 0x3809, 0xf59: 0x3821, 0xf5a: 0x3839, 0xf5b: 0x3851, 0xf5c: 0x3869, 0xf5d: 0x3881,
+	0xf5e: 0x3899, 0xf5f: 0x38b1, 0xf60: 0x335d, 0xf61: 0x337d, 0xf62: 0x339d, 0xf63: 0x33bd,
+	0xf64: 0x33dd, 0xf65: 0x33dd, 0xf66: 0x33fd, 0xf67: 0x341d, 0xf68: 0x343d, 0xf69: 0x345d,
+	0xf6a: 0x347d, 0xf6b: 0x349d, 0xf6c: 0x34bd, 0xf6d: 0x34dd, 0xf6e: 0x34fd, 0xf6f: 0x351d,
+	0xf70: 0x353d, 0xf71: 0x355d, 0xf72: 0x357d, 0xf73: 0x359d, 0xf74: 0x35bd, 0xf75: 0x35dd,
+	0xf76: 0x35fd, 0xf77: 0x361d, 0xf78: 0x363d, 0xf79: 0x365d, 0xf7a: 0x367d, 0xf7b: 0x369d,
+	0xf7c: 0x38c9, 0xf7d: 0x3901, 0xf7e: 0x36bd, 0xf7f: 0x0018,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x36dd, 0xf81: 0x36fd, 0xf82: 0x371d, 0xf83: 0x373d, 0xf84: 0x375d, 0xf85: 0x377d,
+	0xf86: 0x379d, 0xf87: 0x37bd, 0xf88: 0x37dd, 0xf89: 0x37fd, 0xf8a: 0x381d, 0xf8b: 0x383d,
+	0xf8c: 0x385d, 0xf8d: 0x387d, 0xf8e: 0x389d, 0xf8f: 0x38bd, 0xf90: 0x38dd, 0xf91: 0x38fd,
+	0xf92: 0x391d, 0xf93: 0x393d, 0xf94: 0x395d, 0xf95: 0x397d, 0xf96: 0x399d, 0xf97: 0x39bd,
+	0xf98: 0x39dd, 0xf99: 0x39fd, 0xf9a: 0x3a1d, 0xf9b: 0x3a3d, 0xf9c: 0x3a5d, 0xf9d: 0x3a7d,
+	0xf9e: 0x3a9d, 0xf9f: 0x3abd, 0xfa0: 0x3add, 0xfa1: 0x3afd, 0xfa2: 0x3b1d, 0xfa3: 0x3b3d,
+	0xfa4: 0x3b5d, 0xfa5: 0x3b7d, 0xfa6: 0x127d, 0xfa7: 0x3b9d, 0xfa8: 0x3bbd, 0xfa9: 0x3bdd,
+	0xfaa: 0x3bfd, 0xfab: 0x3c1d, 0xfac: 0x3c3d, 0xfad: 0x3c5d, 0xfae: 0x239d, 0xfaf: 0x3c7d,
+	0xfb0: 0x3c9d, 0xfb1: 0x3939, 0xfb2: 0x3951, 0xfb3: 0x3969, 0xfb4: 0x3981, 0xfb5: 0x3999,
+	0xfb6: 0x39b1, 0xfb7: 0x39c9, 0xfb8: 0x39e1, 0xfb9: 0x39f9, 0xfba: 0x3a11, 0xfbb: 0x3a29,
+	0xfbc: 0x3a41, 0xfbd: 0x3a59, 0xfbe: 0x3a71, 0xfbf: 0x3a89,
+	// Block 0x3f, offset 0xfc0
+	0xfc0: 0x3aa1, 0xfc1: 0x3ac9, 0xfc2: 0x3af1, 0xfc3: 0x3b19, 0xfc4: 0x3b41, 0xfc5: 0x3b69,
+	0xfc6: 0x3b91, 0xfc7: 0x3bb9, 0xfc8: 0x3be1, 0xfc9: 0x3c09, 0xfca: 0x3c39, 0xfcb: 0x3c69,
+	0xfcc: 0x3c99, 0xfcd: 0x3cbd, 0xfce: 0x3cb1, 0xfcf: 0x3cdd, 0xfd0: 0x3cfd, 0xfd1: 0x3d15,
+	0xfd2: 0x3d2d, 0xfd3: 0x3d45, 0xfd4: 0x3d5d, 0xfd5: 0x3d5d, 0xfd6: 0x3d45, 0xfd7: 0x3d75,
+	0xfd8: 0x07bd, 0xfd9: 0x3d8d, 0xfda: 0x3da5, 0xfdb: 0x3dbd, 0xfdc: 0x3dd5, 0xfdd: 0x3ded,
+	0xfde: 0x3e05, 0xfdf: 0x3e1d, 0xfe0: 0x3e35, 0xfe1: 0x3e4d, 0xfe2: 0x3e65, 0xfe3: 0x3e7d,
+	0xfe4: 0x3e95, 0xfe5: 0x3e95, 0xfe6: 0x3ead, 0xfe7: 0x3ead, 0xfe8: 0x3ec5, 0xfe9: 0x3ec5,
+	0xfea: 0x3edd, 0xfeb: 0x3ef5, 0xfec: 0x3f0d, 0xfed: 0x3f25, 0xfee: 0x3f3d, 0xfef: 0x3f3d,
+	0xff0: 0x3f55, 0xff1: 0x3f55, 0xff2: 0x3f55, 0xff3: 0x3f6d, 0xff4: 0x3f85, 0xff5: 0x3f9d,
+	0xff6: 0x3fb5, 0xff7: 0x3f9d, 0xff8: 0x3fcd, 0xff9: 0x3fe5, 0xffa: 0x3f6d, 0xffb: 0x3ffd,
+	0xffc: 0x4015, 0xffd: 0x4015, 0xffe: 0x4015, 0xfff: 0x0040,
+	// Block 0x40, offset 0x1000
+	0x1000: 0x3cc9, 0x1001: 0x3d31, 0x1002: 0x3d99, 0x1003: 0x3e01, 0x1004: 0x3e51, 0x1005: 0x3eb9,
+	0x1006: 0x3f09, 0x1007: 0x3f59, 0x1008: 0x3fd9, 0x1009: 0x4041, 0x100a: 0x4091, 0x100b: 0x40e1,
+	0x100c: 0x4131, 0x100d: 0x4199, 0x100e: 0x4201, 0x100f: 0x4251, 0x1010: 0x42a1, 0x1011: 0x42d9,
+	0x1012: 0x4329, 0x1013: 0x4391, 0x1014: 0x43f9, 0x1015: 0x4431, 0x1016: 0x44b1, 0x1017: 0x4549,
+	0x1018: 0x45c9, 0x1019: 0x4619, 0x101a: 0x4699, 0x101b: 0x4719, 0x101c: 0x4781, 0x101d: 0x47d1,
+	0x101e: 0x4821, 0x101f: 0x4871, 0x1020: 0x48d9, 0x1021: 0x4959, 0x1022: 0x49c1, 0x1023: 0x4a11,
+	0x1024: 0x4a61, 0x1025: 0x4ab1, 0x1026: 0x4ae9, 0x1027: 0x4b21, 0x1028: 0x4b59, 0x1029: 0x4b91,
+	0x102a: 0x4be1, 0x102b: 0x4c31, 0x102c: 0x4cb1, 0x102d: 0x4d01, 0x102e: 0x4d69, 0x102f: 0x4de9,
+	0x1030: 0x4e39, 0x1031: 0x4e71, 0x1032: 0x4ea9, 0x1033: 0x4f29, 0x1034: 0x4f91, 0x1035: 0x5011,
+	0x1036: 0x5061, 0x1037: 0x50e1, 0x1038: 0x5119, 0x1039: 0x5169, 0x103a: 0x51b9, 0x103b: 0x5209,
+	0x103c: 0x5259, 0x103d: 0x52a9, 0x103e: 0x5311, 0x103f: 0x5361,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x5399, 0x1041: 0x53e9, 0x1042: 0x5439, 0x1043: 0x5489, 0x1044: 0x54f1, 0x1045: 0x5541,
+	0x1046: 0x5591, 0x1047: 0x55e1, 0x1048: 0x5661, 0x1049: 0x56c9, 0x104a: 0x5701, 0x104b: 0x5781,
+	0x104c: 0x57b9, 0x104d: 0x5821, 0x104e: 0x5889, 0x104f: 0x58d9, 0x1050: 0x5929, 0x1051: 0x5979,
+	0x1052: 0x59e1, 0x1053: 0x5a19, 0x1054: 0x5a69, 0x1055: 0x5ad1, 0x1056: 0x5b09, 0x1057: 0x5b89,
+	0x1058: 0x5bd9, 0x1059: 0x5c01, 0x105a: 0x5c29, 0x105b: 0x5c51, 0x105c: 0x5c79, 0x105d: 0x5ca1,
+	0x105e: 0x5cc9, 0x105f: 0x5cf1, 0x1060: 0x5d19, 0x1061: 0x5d41, 0x1062: 0x5d69, 0x1063: 0x5d99,
+	0x1064: 0x5dc9, 0x1065: 0x5df9, 0x1066: 0x5e29, 0x1067: 0x5e59, 0x1068: 0x5e89, 0x1069: 0x5eb9,
+	0x106a: 0x5ee9, 0x106b: 0x5f19, 0x106c: 0x5f49, 0x106d: 0x5f79, 0x106e: 0x5fa9, 0x106f: 0x5fd9,
+	0x1070: 0x6009, 0x1071: 0x402d, 0x1072: 0x6039, 0x1073: 0x6051, 0x1074: 0x404d, 0x1075: 0x6069,
+	0x1076: 0x6081, 0x1077: 0x6099, 0x1078: 0x406d, 0x1079: 0x406d, 0x107a: 0x60b1, 0x107b: 0x60c9,
+	0x107c: 0x6101, 0x107d: 0x6139, 0x107e: 0x6171, 0x107f: 0x61a9,
+	// Block 0x42, offset 0x1080
+	0x1080: 0x6211, 0x1081: 0x6229, 0x1082: 0x408d, 0x1083: 0x6241, 0x1084: 0x6259, 0x1085: 0x6271,
+	0x1086: 0x6289, 0x1087: 0x62a1, 0x1088: 0x40ad, 0x1089: 0x62b9, 0x108a: 0x62e1, 0x108b: 0x62f9,
+	0x108c: 0x40cd, 0x108d: 0x40cd, 0x108e: 0x6311, 0x108f: 0x6329, 0x1090: 0x6341, 0x1091: 0x40ed,
+	0x1092: 0x410d, 0x1093: 0x412d, 0x1094: 0x414d, 0x1095: 0x416d, 0x1096: 0x6359, 0x1097: 0x6371,
+	0x1098: 0x6389, 0x1099: 0x63a1, 0x109a: 0x63b9, 0x109b: 0x418d, 0x109c: 0x63d1, 0x109d: 0x63e9,
+	0x109e: 0x6401, 0x109f: 0x41ad, 0x10a0: 0x41cd, 0x10a1: 0x6419, 0x10a2: 0x41ed, 0x10a3: 0x420d,
+	0x10a4: 0x422d, 0x10a5: 0x6431, 0x10a6: 0x424d, 0x10a7: 0x6449, 0x10a8: 0x6479, 0x10a9: 0x6211,
+	0x10aa: 0x426d, 0x10ab: 0x428d, 0x10ac: 0x42ad, 0x10ad: 0x42cd, 0x10ae: 0x64b1, 0x10af: 0x64f1,
+	0x10b0: 0x6539, 0x10b1: 0x6551, 0x10b2: 0x42ed, 0x10b3: 0x6569, 0x10b4: 0x6581, 0x10b5: 0x6599,
+	0x10b6: 0x430d, 0x10b7: 0x65b1, 0x10b8: 0x65c9, 0x10b9: 0x65b1, 0x10ba: 0x65e1, 0x10bb: 0x65f9,
+	0x10bc: 0x432d, 0x10bd: 0x6611, 0x10be: 0x6629, 0x10bf: 0x6611,
+	// Block 0x43, offset 0x10c0
+	0x10c0: 0x434d, 0x10c1: 0x436d, 0x10c2: 0x0040, 0x10c3: 0x6641, 0x10c4: 0x6659, 0x10c5: 0x6671,
+	0x10c6: 0x6689, 0x10c7: 0x0040, 0x10c8: 0x66c1, 0x10c9: 0x66d9, 0x10ca: 0x66f1, 0x10cb: 0x6709,
+	0x10cc: 0x6721, 0x10cd: 0x6739, 0x10ce: 0x6401, 0x10cf: 0x6751, 0x10d0: 0x6769, 0x10d1: 0x6781,
+	0x10d2: 0x438d, 0x10d3: 0x6799, 0x10d4: 0x6289, 0x10d5: 0x43ad, 0x10d6: 0x43cd, 0x10d7: 0x67b1,
+	0x10d8: 0x0040, 0x10d9: 0x43ed, 0x10da: 0x67c9, 0x10db: 0x67e1, 0x10dc: 0x67f9, 0x10dd: 0x6811,
+	0x10de: 0x6829, 0x10df: 0x6859, 0x10e0: 0x6889, 0x10e1: 0x68b1, 0x10e2: 0x68d9, 0x10e3: 0x6901,
+	0x10e4: 0x6929, 0x10e5: 0x6951, 0x10e6: 0x6979, 0x10e7: 0x69a1, 0x10e8: 0x69c9, 0x10e9: 0x69f1,
+	0x10ea: 0x6a21, 0x10eb: 0x6a51, 0x10ec: 0x6a81, 0x10ed: 0x6ab1, 0x10ee: 0x6ae1, 0x10ef: 0x6b11,
+	0x10f0: 0x6b41, 0x10f1: 0x6b71, 0x10f2: 0x6ba1, 0x10f3: 0x6bd1, 0x10f4: 0x6c01, 0x10f5: 0x6c31,
+	0x10f6: 0x6c61, 0x10f7: 0x6c91, 0x10f8: 0x6cc1, 0x10f9: 0x6cf1, 0x10fa: 0x6d21, 0x10fb: 0x6d51,
+	0x10fc: 0x6d81, 0x10fd: 0x6db1, 0x10fe: 0x6de1, 0x10ff: 0x440d,
+	// Block 0x44, offset 0x1100
+	0x1100: 0xe00d, 0x1101: 0x0008, 0x1102: 0xe00d, 0x1103: 0x0008, 0x1104: 0xe00d, 0x1105: 0x0008,
+	0x1106: 0xe00d, 0x1107: 0x0008, 0x1108: 0xe00d, 0x1109: 0x0008, 0x110a: 0xe00d, 0x110b: 0x0008,
+	0x110c: 0xe00d, 0x110d: 0x0008, 0x110e: 0xe00d, 0x110f: 0x0008, 0x1110: 0xe00d, 0x1111: 0x0008,
+	0x1112: 0xe00d, 0x1113: 0x0008, 0x1114: 0xe00d, 0x1115: 0x0008, 0x1116: 0xe00d, 0x1117: 0x0008,
+	0x1118: 0xe00d, 0x1119: 0x0008, 0x111a: 0xe00d, 0x111b: 0x0008, 0x111c: 0xe00d, 0x111d: 0x0008,
+	0x111e: 0xe00d, 0x111f: 0x0008, 0x1120: 0xe00d, 0x1121: 0x0008, 0x1122: 0xe00d, 0x1123: 0x0008,
+	0x1124: 0xe00d, 0x1125: 0x0008, 0x1126: 0xe00d, 0x1127: 0x0008, 0x1128: 0xe00d, 0x1129: 0x0008,
+	0x112a: 0xe00d, 0x112b: 0x0008, 0x112c: 0xe00d, 0x112d: 0x0008, 0x112e: 0x0008, 0x112f: 0x3308,
+	0x1130: 0x3318, 0x1131: 0x3318, 0x1132: 0x3318, 0x1133: 0x0018, 0x1134: 0x3308, 0x1135: 0x3308,
+	0x1136: 0x3308, 0x1137: 0x3308, 0x1138: 0x3308, 0x1139: 0x3308, 0x113a: 0x3308, 0x113b: 0x3308,
+	0x113c: 0x3308, 0x113d: 0x3308, 0x113e: 0x0018, 0x113f: 0x0008,
+	// Block 0x45, offset 0x1140
+	0x1140: 0xe00d, 0x1141: 0x0008, 0x1142: 0xe00d, 0x1143: 0x0008, 0x1144: 0xe00d, 0x1145: 0x0008,
+	0x1146: 0xe00d, 0x1147: 0x0008, 0x1148: 0xe00d, 0x1149: 0x0008, 0x114a: 0xe00d, 0x114b: 0x0008,
+	0x114c: 0xe00d, 0x114d: 0x0008, 0x114e: 0xe00d, 0x114f: 0x0008, 0x1150: 0xe00d, 0x1151: 0x0008,
+	0x1152: 0xe00d, 0x1153: 0x0008, 0x1154: 0xe00d, 0x1155: 0x0008, 0x1156: 0xe00d, 0x1157: 0x0008,
+	0x1158: 0xe00d, 0x1159: 0x0008, 0x115a: 0xe00d, 0x115b: 0x0008, 0x115c: 0x0ea1, 0x115d: 0x6e11,
+	0x115e: 0x3308, 0x115f: 0x3308, 0x1160: 0x0008, 0x1161: 0x0008, 0x1162: 0x0008, 0x1163: 0x0008,
+	0x1164: 0x0008, 0x1165: 0x0008, 0x1166: 0x0008, 0x1167: 0x0008, 0x1168: 0x0008, 0x1169: 0x0008,
+	0x116a: 0x0008, 0x116b: 0x0008, 0x116c: 0x0008, 0x116d: 0x0008, 0x116e: 0x0008, 0x116f: 0x0008,
+	0x1170: 0x0008, 0x1171: 0x0008, 0x1172: 0x0008, 0x1173: 0x0008, 0x1174: 0x0008, 0x1175: 0x0008,
+	0x1176: 0x0008, 0x1177: 0x0008, 0x1178: 0x0008, 0x1179: 0x0008, 0x117a: 0x0008, 0x117b: 0x0008,
+	0x117c: 0x0008, 0x117d: 0x0008, 0x117e: 0x0008, 0x117f: 0x0008,
+	// Block 0x46, offset 0x1180
+	0x1180: 0x0018, 0x1181: 0x0018, 0x1182: 0x0018, 0x1183: 0x0018, 0x1184: 0x0018, 0x1185: 0x0018,
+	0x1186: 0x0018, 0x1187: 0x0018, 0x1188: 0x0018, 0x1189: 0x0018, 0x118a: 0x0018, 0x118b: 0x0018,
+	0x118c: 0x0018, 0x118d: 0x0018, 0x118e: 0x0018, 0x118f: 0x0018, 0x1190: 0x0018, 0x1191: 0x0018,
+	0x1192: 0x0018, 0x1193: 0x0018, 0x1194: 0x0018, 0x1195: 0x0018, 0x1196: 0x0018, 0x1197: 0x0008,
+	0x1198: 0x0008, 0x1199: 0x0008, 0x119a: 0x0008, 0x119b: 0x0008, 0x119c: 0x0008, 0x119d: 0x0008,
+	0x119e: 0x0008, 0x119f: 0x0008, 0x11a0: 0x0018, 0x11a1: 0x0018, 0x11a2: 0xe00d, 0x11a3: 0x0008,
+	0x11a4: 0xe00d, 0x11a5: 0x0008, 0x11a6: 0xe00d, 0x11a7: 0x0008, 0x11a8: 0xe00d, 0x11a9: 0x0008,
+	0x11aa: 0xe00d, 0x11ab: 0x0008, 0x11ac: 0xe00d, 0x11ad: 0x0008, 0x11ae: 0xe00d, 0x11af: 0x0008,
+	0x11b0: 0x0008, 0x11b1: 0x0008, 0x11b2: 0xe00d, 0x11b3: 0x0008, 0x11b4: 0xe00d, 0x11b5: 0x0008,
+	0x11b6: 0xe00d, 0x11b7: 0x0008, 0x11b8: 0xe00d, 0x11b9: 0x0008, 0x11ba: 0xe00d, 0x11bb: 0x0008,
+	0x11bc: 0xe00d, 0x11bd: 0x0008, 0x11be: 0xe00d, 0x11bf: 0x0008,
+	// Block 0x47, offset 0x11c0
+	0x11c0: 0xe00d, 0x11c1: 0x0008, 0x11c2: 0xe00d, 0x11c3: 0x0008, 0x11c4: 0xe00d, 0x11c5: 0x0008,
+	0x11c6: 0xe00d, 0x11c7: 0x0008, 0x11c8: 0xe00d, 0x11c9: 0x0008, 0x11ca: 0xe00d, 0x11cb: 0x0008,
+	0x11cc: 0xe00d, 0x11cd: 0x0008, 0x11ce: 0xe00d, 0x11cf: 0x0008, 0x11d0: 0xe00d, 0x11d1: 0x0008,
+	0x11d2: 0xe00d, 0x11d3: 0x0008, 0x11d4: 0xe00d, 0x11d5: 0x0008, 0x11d6: 0xe00d, 0x11d7: 0x0008,
+	0x11d8: 0xe00d, 0x11d9: 0x0008, 0x11da: 0xe00d, 0x11db: 0x0008, 0x11dc: 0xe00d, 0x11dd: 0x0008,
+	0x11de: 0xe00d, 0x11df: 0x0008, 0x11e0: 0xe00d, 0x11e1: 0x0008, 0x11e2: 0xe00d, 0x11e3: 0x0008,
+	0x11e4: 0xe00d, 0x11e5: 0x0008, 0x11e6: 0xe00d, 0x11e7: 0x0008, 0x11e8: 0xe00d, 0x11e9: 0x0008,
+	0x11ea: 0xe00d, 0x11eb: 0x0008, 0x11ec: 0xe00d, 0x11ed: 0x0008, 0x11ee: 0xe00d, 0x11ef: 0x0008,
+	0x11f0: 0xe0fd, 0x11f1: 0x0008, 0x11f2: 0x0008, 0x11f3: 0x0008, 0x11f4: 0x0008, 0x11f5: 0x0008,
+	0x11f6: 0x0008, 0x11f7: 0x0008, 0x11f8: 0x0008, 0x11f9: 0xe01d, 0x11fa: 0x0008, 0x11fb: 0xe03d,
+	0x11fc: 0x0008, 0x11fd: 0x442d, 0x11fe: 0xe00d, 0x11ff: 0x0008,
+	// Block 0x48, offset 0x1200
+	0x1200: 0xe00d, 0x1201: 0x0008, 0x1202: 0xe00d, 0x1203: 0x0008, 0x1204: 0xe00d, 0x1205: 0x0008,
+	0x1206: 0xe00d, 0x1207: 0x0008, 0x1208: 0x0008, 0x1209: 0x0018, 0x120a: 0x0018, 0x120b: 0xe03d,
+	0x120c: 0x0008, 0x120d: 0x11d9, 0x120e: 0x0008, 0x120f: 0x0008, 0x1210: 0xe00d, 0x1211: 0x0008,
+	0x1212: 0xe00d, 0x1213: 0x0008, 0x1214: 0x0008, 0x1215: 0x0008, 0x1216: 0xe00d, 0x1217: 0x0008,
+	0x1218: 0xe00d, 0x1219: 0x0008, 0x121a: 0xe00d, 0x121b: 0x0008, 0x121c: 0xe00d, 0x121d: 0x0008,
+	0x121e: 0xe00d, 0x121f: 0x0008, 0x1220: 0xe00d, 0x1221: 0x0008, 0x1222: 0xe00d, 0x1223: 0x0008,
+	0x1224: 0xe00d, 0x1225: 0x0008, 0x1226: 0xe00d, 0x1227: 0x0008, 0x1228: 0xe00d, 0x1229: 0x0008,
+	0x122a: 0x6e29, 0x122b: 0x1029, 0x122c: 0x11c1, 0x122d: 0x6e41, 0x122e: 0x1221, 0x122f: 0x0040,
+	0x1230: 0x6e59, 0x1231: 0x6e71, 0x1232: 0x1239, 0x1233: 0x444d, 0x1234: 0xe00d, 0x1235: 0x0008,
+	0x1236: 0xe00d, 0x1237: 0x0008, 0x1238: 0x0040, 0x1239: 0x0040, 0x123a: 0x0040, 0x123b: 0x0040,
+	0x123c: 0x0040, 0x123d: 0x0040, 0x123e: 0x0040, 0x123f: 0x0040,
+	// Block 0x49, offset 0x1240
+	0x1240: 0x64d5, 0x1241: 0x64f5, 0x1242: 0x6515, 0x1243: 0x6535, 0x1244: 0x6555, 0x1245: 0x6575,
+	0x1246: 0x6595, 0x1247: 0x65b5, 0x1248: 0x65d5, 0x1249: 0x65f5, 0x124a: 0x6615, 0x124b: 0x6635,
+	0x124c: 0x6655, 0x124d: 0x6675, 0x124e: 0x0008, 0x124f: 0x0008, 0x1250: 0x6695, 0x1251: 0x0008,
+	0x1252: 0x66b5, 0x1253: 0x0008, 0x1254: 0x0008, 0x1255: 0x66d5, 0x1256: 0x66f5, 0x1257: 0x6715,
+	0x1258: 0x6735, 0x1259: 0x6755, 0x125a: 0x6775, 0x125b: 0x6795, 0x125c: 0x67b5, 0x125d: 0x67d5,
+	0x125e: 0x67f5, 0x125f: 0x0008, 0x1260: 0x6815, 0x1261: 0x0008, 0x1262: 0x6835, 0x1263: 0x0008,
+	0x1264: 0x0008, 0x1265: 0x6855, 0x1266: 0x6875, 0x1267: 0x0008, 0x1268: 0x0008, 0x1269: 0x0008,
+	0x126a: 0x6895, 0x126b: 0x68b5, 0x126c: 0x68d5, 0x126d: 0x68f5, 0x126e: 0x6915, 0x126f: 0x6935,
+	0x1270: 0x6955, 0x1271: 0x6975, 0x1272: 0x6995, 0x1273: 0x69b5, 0x1274: 0x69d5, 0x1275: 0x69f5,
+	0x1276: 0x6a15, 0x1277: 0x6a35, 0x1278: 0x6a55, 0x1279: 0x6a75, 0x127a: 0x6a95, 0x127b: 0x6ab5,
+	0x127c: 0x6ad5, 0x127d: 0x6af5, 0x127e: 0x6b15, 0x127f: 0x6b35,
+	// Block 0x4a, offset 0x1280
+	0x1280: 0x7a95, 0x1281: 0x7ab5, 0x1282: 0x7ad5, 0x1283: 0x7af5, 0x1284: 0x7b15, 0x1285: 0x7b35,
+	0x1286: 0x7b55, 0x1287: 0x7b75, 0x1288: 0x7b95, 0x1289: 0x7bb5, 0x128a: 0x7bd5, 0x128b: 0x7bf5,
+	0x128c: 0x7c15, 0x128d: 0x7c35, 0x128e: 0x7c55, 0x128f: 0x6ec9, 0x1290: 0x6ef1, 0x1291: 0x6f19,
+	0x1292: 0x7c75, 0x1293: 0x7c95, 0x1294: 0x7cb5, 0x1295: 0x6f41, 0x1296: 0x6f69, 0x1297: 0x6f91,
+	0x1298: 0x7cd5, 0x1299: 0x7cf5, 0x129a: 0x0040, 0x129b: 0x0040, 0x129c: 0x0040, 0x129d: 0x0040,
+	0x129e: 0x0040, 0x129f: 0x0040, 0x12a0: 0x0040, 0x12a1: 0x0040, 0x12a2: 0x0040, 0x12a3: 0x0040,
+	0x12a4: 0x0040, 0x12a5: 0x0040, 0x12a6: 0x0040, 0x12a7: 0x0040, 0x12a8: 0x0040, 0x12a9: 0x0040,
+	0x12aa: 0x0040, 0x12ab: 0x0040, 0x12ac: 0x0040, 0x12ad: 0x0040, 0x12ae: 0x0040, 0x12af: 0x0040,
+	0x12b0: 0x0040, 0x12b1: 0x0040, 0x12b2: 0x0040, 0x12b3: 0x0040, 0x12b4: 0x0040, 0x12b5: 0x0040,
+	0x12b6: 0x0040, 0x12b7: 0x0040, 0x12b8: 0x0040, 0x12b9: 0x0040, 0x12ba: 0x0040, 0x12bb: 0x0040,
+	0x12bc: 0x0040, 0x12bd: 0x0040, 0x12be: 0x0040, 0x12bf: 0x0040,
+	// Block 0x4b, offset 0x12c0
+	0x12c0: 0x6fb9, 0x12c1: 0x6fd1, 0x12c2: 0x6fe9, 0x12c3: 0x7d15, 0x12c4: 0x7d35, 0x12c5: 0x7001,
+	0x12c6: 0x7001, 0x12c7: 0x0040, 0x12c8: 0x0040, 0x12c9: 0x0040, 0x12ca: 0x0040, 0x12cb: 0x0040,
+	0x12cc: 0x0040, 0x12cd: 0x0040, 0x12ce: 0x0040, 0x12cf: 0x0040, 0x12d0: 0x0040, 0x12d1: 0x0040,
+	0x12d2: 0x0040, 0x12d3: 0x7019, 0x12d4: 0x7041, 0x12d5: 0x7069, 0x12d6: 0x7091, 0x12d7: 0x70b9,
+	0x12d8: 0x0040, 0x12d9: 0x0040, 0x12da: 0x0040, 0x12db: 0x0040, 0x12dc: 0x0040, 0x12dd: 0x70e1,
+	0x12de: 0x3308, 0x12df: 0x7109, 0x12e0: 0x7131, 0x12e1: 0x20a9, 0x12e2: 0x20f1, 0x12e3: 0x7149,
+	0x12e4: 0x7161, 0x12e5: 0x7179, 0x12e6: 0x7191, 0x12e7: 0x71a9, 0x12e8: 0x71c1, 0x12e9: 0x1fb2,
+	0x12ea: 0x71d9, 0x12eb: 0x7201, 0x12ec: 0x7229, 0x12ed: 0x7261, 0x12ee: 0x7299, 0x12ef: 0x72c1,
+	0x12f0: 0x72e9, 0x12f1: 0x7311, 0x12f2: 0x7339, 0x12f3: 0x7361, 0x12f4: 0x7389, 0x12f5: 0x73b1,
+	0x12f6: 0x73d9, 0x12f7: 0x0040, 0x12f8: 0x7401, 0x12f9: 0x7429, 0x12fa: 0x7451, 0x12fb: 0x7479,
+	0x12fc: 0x74a1, 0x12fd: 0x0040, 0x12fe: 0x74c9, 0x12ff: 0x0040,
+	// Block 0x4c, offset 0x1300
+	0x1300: 0x74f1, 0x1301: 0x7519, 0x1302: 0x0040, 0x1303: 0x7541, 0x1304: 0x7569, 0x1305: 0x0040,
+	0x1306: 0x7591, 0x1307: 0x75b9, 0x1308: 0x75e1, 0x1309: 0x7609, 0x130a: 0x7631, 0x130b: 0x7659,
+	0x130c: 0x7681, 0x130d: 0x76a9, 0x130e: 0x76d1, 0x130f: 0x76f9, 0x1310: 0x7721, 0x1311: 0x7721,
+	0x1312: 0x7739, 0x1313: 0x7739, 0x1314: 0x7739, 0x1315: 0x7739, 0x1316: 0x7751, 0x1317: 0x7751,
+	0x1318: 0x7751, 0x1319: 0x7751, 0x131a: 0x7769, 0x131b: 0x7769, 0x131c: 0x7769, 0x131d: 0x7769,
+	0x131e: 0x7781, 0x131f: 0x7781, 0x1320: 0x7781, 0x1321: 0x7781, 0x1322: 0x7799, 0x1323: 0x7799,
+	0x1324: 0x7799, 0x1325: 0x7799, 0x1326: 0x77b1, 0x1327: 0x77b1, 0x1328: 0x77b1, 0x1329: 0x77b1,
+	0x132a: 0x77c9, 0x132b: 0x77c9, 0x132c: 0x77c9, 0x132d: 0x77c9, 0x132e: 0x77e1, 0x132f: 0x77e1,
+	0x1330: 0x77e1, 0x1331: 0x77e1, 0x1332: 0x77f9, 0x1333: 0x77f9, 0x1334: 0x77f9, 0x1335: 0x77f9,
+	0x1336: 0x7811, 0x1337: 0x7811, 0x1338: 0x7811, 0x1339: 0x7811, 0x133a: 0x7829, 0x133b: 0x7829,
+	0x133c: 0x7829, 0x133d: 0x7829, 0x133e: 0x7841, 0x133f: 0x7841,
+	// Block 0x4d, offset 0x1340
+	0x1340: 0x7841, 0x1341: 0x7841, 0x1342: 0x7859, 0x1343: 0x7859, 0x1344: 0x7871, 0x1345: 0x7871,
+	0x1346: 0x7889, 0x1347: 0x7889, 0x1348: 0x78a1, 0x1349: 0x78a1, 0x134a: 0x78b9, 0x134b: 0x78b9,
+	0x134c: 0x78d1, 0x134d: 0x78d1, 0x134e: 0x78e9, 0x134f: 0x78e9, 0x1350: 0x78e9, 0x1351: 0x78e9,
+	0x1352: 0x7901, 0x1353: 0x7901, 0x1354: 0x7901, 0x1355: 0x7901, 0x1356: 0x7919, 0x1357: 0x7919,
+	0x1358: 0x7919, 0x1359: 0x7919, 0x135a: 0x7931, 0x135b: 0x7931, 0x135c: 0x7931, 0x135d: 0x7931,
+	0x135e: 0x7949, 0x135f: 0x7949, 0x1360: 0x7961, 0x1361: 0x7961, 0x1362: 0x7961, 0x1363: 0x7961,
+	0x1364: 0x7979, 0x1365: 0x7979, 0x1366: 0x7991, 0x1367: 0x7991, 0x1368: 0x7991, 0x1369: 0x7991,
+	0x136a: 0x79a9, 0x136b: 0x79a9, 0x136c: 0x79a9, 0x136d: 0x79a9, 0x136e: 0x79c1, 0x136f: 0x79c1,
+	0x1370: 0x79d9, 0x1371: 0x79d9, 0x1372: 0x0818, 0x1373: 0x0818, 0x1374: 0x0818, 0x1375: 0x0818,
+	0x1376: 0x0818, 0x1377: 0x0818, 0x1378: 0x0818, 0x1379: 0x0818, 0x137a: 0x0818, 0x137b: 0x0818,
+	0x137c: 0x0818, 0x137d: 0x0818, 0x137e: 0x0818, 0x137f: 0x0818,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x0818, 0x1381: 0x0818, 0x1382: 0x0040, 0x1383: 0x0040, 0x1384: 0x0040, 0x1385: 0x0040,
+	0x1386: 0x0040, 0x1387: 0x0040, 0x1388: 0x0040, 0x1389: 0x0040, 0x138a: 0x0040, 0x138b: 0x0040,
+	0x138c: 0x0040, 0x138d: 0x0040, 0x138e: 0x0040, 0x138f: 0x0040, 0x1390: 0x0040, 0x1391: 0x0040,
+	0x1392: 0x0040, 0x1393: 0x79f1, 0x1394: 0x79f1, 0x1395: 0x79f1, 0x1396: 0x79f1, 0x1397: 0x7a09,
+	0x1398: 0x7a09, 0x1399: 0x7a21, 0x139a: 0x7a21, 0x139b: 0x7a39, 0x139c: 0x7a39, 0x139d: 0x0479,
+	0x139e: 0x7a51, 0x139f: 0x7a51, 0x13a0: 0x7a69, 0x13a1: 0x7a69, 0x13a2: 0x7a81, 0x13a3: 0x7a81,
+	0x13a4: 0x7a99, 0x13a5: 0x7a99, 0x13a6: 0x7a99, 0x13a7: 0x7a99, 0x13a8: 0x7ab1, 0x13a9: 0x7ab1,
+	0x13aa: 0x7ac9, 0x13ab: 0x7ac9, 0x13ac: 0x7af1, 0x13ad: 0x7af1, 0x13ae: 0x7b19, 0x13af: 0x7b19,
+	0x13b0: 0x7b41, 0x13b1: 0x7b41, 0x13b2: 0x7b69, 0x13b3: 0x7b69, 0x13b4: 0x7b91, 0x13b5: 0x7b91,
+	0x13b6: 0x7bb9, 0x13b7: 0x7bb9, 0x13b8: 0x7bb9, 0x13b9: 0x7be1, 0x13ba: 0x7be1, 0x13bb: 0x7be1,
+	0x13bc: 0x7c09, 0x13bd: 0x7c09, 0x13be: 0x7c09, 0x13bf: 0x7c09,
+	// Block 0x4f, offset 0x13c0
+	0x13c0: 0x85f9, 0x13c1: 0x8621, 0x13c2: 0x8649, 0x13c3: 0x8671, 0x13c4: 0x8699, 0x13c5: 0x86c1,
+	0x13c6: 0x86e9, 0x13c7: 0x8711, 0x13c8: 0x8739, 0x13c9: 0x8761, 0x13ca: 0x8789, 0x13cb: 0x87b1,
+	0x13cc: 0x87d9, 0x13cd: 0x8801, 0x13ce: 0x8829, 0x13cf: 0x8851, 0x13d0: 0x8879, 0x13d1: 0x88a1,
+	0x13d2: 0x88c9, 0x13d3: 0x88f1, 0x13d4: 0x8919, 0x13d5: 0x8941, 0x13d6: 0x8969, 0x13d7: 0x8991,
+	0x13d8: 0x89b9, 0x13d9: 0x89e1, 0x13da: 0x8a09, 0x13db: 0x8a31, 0x13dc: 0x8a59, 0x13dd: 0x8a81,
+	0x13de: 0x8aaa, 0x13df: 0x8ada, 0x13e0: 0x8b0a, 0x13e1: 0x8b3a, 0x13e2: 0x8b6a, 0x13e3: 0x8b9a,
+	0x13e4: 0x8bc9, 0x13e5: 0x8bf1, 0x13e6: 0x7c71, 0x13e7: 0x8c19, 0x13e8: 0x7be1, 0x13e9: 0x7c99,
+	0x13ea: 0x8c41, 0x13eb: 0x8c69, 0x13ec: 0x7d39, 0x13ed: 0x8c91, 0x13ee: 0x7d61, 0x13ef: 0x7d89,
+	0x13f0: 0x8cb9, 0x13f1: 0x8ce1, 0x13f2: 0x7e29, 0x13f3: 0x8d09, 0x13f4: 0x7e51, 0x13f5: 0x7e79,
+	0x13f6: 0x8d31, 0x13f7: 0x8d59, 0x13f8: 0x7ec9, 0x13f9: 0x8d81, 0x13fa: 0x7ef1, 0x13fb: 0x7f19,
+	0x13fc: 0x83a1, 0x13fd: 0x83c9, 0x13fe: 0x8441, 0x13ff: 0x8469,
+	// Block 0x50, offset 0x1400
+	0x1400: 0x8491, 0x1401: 0x8531, 0x1402: 0x8559, 0x1403: 0x8581, 0x1404: 0x85a9, 0x1405: 0x8649,
+	0x1406: 0x8671, 0x1407: 0x8699, 0x1408: 0x8da9, 0x1409: 0x8739, 0x140a: 0x8dd1, 0x140b: 0x8df9,
+	0x140c: 0x8829, 0x140d: 0x8e21, 0x140e: 0x8851, 0x140f: 0x8879, 0x1410: 0x8a81, 0x1411: 0x8e49,
+	0x1412: 0x8e71, 0x1413: 0x89b9, 0x1414: 0x8e99, 0x1415: 0x89e1, 0x1416: 0x8a09, 0x1417: 0x7c21,
+	0x1418: 0x7c49, 0x1419: 0x8ec1, 0x141a: 0x7c71, 0x141b: 0x8ee9, 0x141c: 0x7cc1, 0x141d: 0x7ce9,
+	0x141e: 0x7d11, 0x141f: 0x7d39, 0x1420: 0x8f11, 0x1421: 0x7db1, 0x1422: 0x7dd9, 0x1423: 0x7e01,
+	0x1424: 0x7e29, 0x1425: 0x8f39, 0x1426: 0x7ec9, 0x1427: 0x7f41, 0x1428: 0x7f69, 0x1429: 0x7f91,
+	0x142a: 0x7fb9, 0x142b: 0x7fe1, 0x142c: 0x8031, 0x142d: 0x8059, 0x142e: 0x8081, 0x142f: 0x80a9,
+	0x1430: 0x80d1, 0x1431: 0x80f9, 0x1432: 0x8f61, 0x1433: 0x8121, 0x1434: 0x8149, 0x1435: 0x8171,
+	0x1436: 0x8199, 0x1437: 0x81c1, 0x1438: 0x81e9, 0x1439: 0x8239, 0x143a: 0x8261, 0x143b: 0x8289,
+	0x143c: 0x82b1, 0x143d: 0x82d9, 0x143e: 0x8301, 0x143f: 0x8329,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x8351, 0x1441: 0x8379, 0x1442: 0x83f1, 0x1443: 0x8419, 0x1444: 0x84b9, 0x1445: 0x84e1,
+	0x1446: 0x8509, 0x1447: 0x8531, 0x1448: 0x8559, 0x1449: 0x85d1, 0x144a: 0x85f9, 0x144b: 0x8621,
+	0x144c: 0x8649, 0x144d: 0x8f89, 0x144e: 0x86c1, 0x144f: 0x86e9, 0x1450: 0x8711, 0x1451: 0x8739,
+	0x1452: 0x87b1, 0x1453: 0x87d9, 0x1454: 0x8801, 0x1455: 0x8829, 0x1456: 0x8fb1, 0x1457: 0x88a1,
+	0x1458: 0x88c9, 0x1459: 0x8fd9, 0x145a: 0x8941, 0x145b: 0x8969, 0x145c: 0x8991, 0x145d: 0x89b9,
+	0x145e: 0x9001, 0x145f: 0x7c71, 0x1460: 0x8ee9, 0x1461: 0x7d39, 0x1462: 0x8f11, 0x1463: 0x7e29,
+	0x1464: 0x8f39, 0x1465: 0x7ec9, 0x1466: 0x9029, 0x1467: 0x80d1, 0x1468: 0x9051, 0x1469: 0x9079,
+	0x146a: 0x90a1, 0x146b: 0x8531, 0x146c: 0x8559, 0x146d: 0x8649, 0x146e: 0x8829, 0x146f: 0x8fb1,
+	0x1470: 0x89b9, 0x1471: 0x9001, 0x1472: 0x90c9, 0x1473: 0x9101, 0x1474: 0x9139, 0x1475: 0x9171,
+	0x1476: 0x9199, 0x1477: 0x91c1, 0x1478: 0x91e9, 0x1479: 0x9211, 0x147a: 0x9239, 0x147b: 0x9261,
+	0x147c: 0x9289, 0x147d: 0x92b1, 0x147e: 0x92d9, 0x147f: 0x9301,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x9329, 0x1481: 0x9351, 0x1482: 0x9379, 0x1483: 0x93a1, 0x1484: 0x93c9, 0x1485: 0x93f1,
+	0x1486: 0x9419, 0x1487: 0x9441, 0x1488: 0x9469, 0x1489: 0x9491, 0x148a: 0x94b9, 0x148b: 0x94e1,
+	0x148c: 0x9079, 0x148d: 0x9509, 0x148e: 0x9531, 0x148f: 0x9559, 0x1490: 0x9581, 0x1491: 0x9171,
+	0x1492: 0x9199, 0x1493: 0x91c1, 0x1494: 0x91e9, 0x1495: 0x9211, 0x1496: 0x9239, 0x1497: 0x9261,
+	0x1498: 0x9289, 0x1499: 0x92b1, 0x149a: 0x92d9, 0x149b: 0x9301, 0x149c: 0x9329, 0x149d: 0x9351,
+	0x149e: 0x9379, 0x149f: 0x93a1, 0x14a0: 0x93c9, 0x14a1: 0x93f1, 0x14a2: 0x9419, 0x14a3: 0x9441,
+	0x14a4: 0x9469, 0x14a5: 0x9491, 0x14a6: 0x94b9, 0x14a7: 0x94e1, 0x14a8: 0x9079, 0x14a9: 0x9509,
+	0x14aa: 0x9531, 0x14ab: 0x9559, 0x14ac: 0x9581, 0x14ad: 0x9491, 0x14ae: 0x94b9, 0x14af: 0x94e1,
+	0x14b0: 0x9079, 0x14b1: 0x9051, 0x14b2: 0x90a1, 0x14b3: 0x8211, 0x14b4: 0x8059, 0x14b5: 0x8081,
+	0x14b6: 0x80a9, 0x14b7: 0x9491, 0x14b8: 0x94b9, 0x14b9: 0x94e1, 0x14ba: 0x8211, 0x14bb: 0x8239,
+	0x14bc: 0x95a9, 0x14bd: 0x95a9, 0x14be: 0x0018, 0x14bf: 0x0018,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x0040, 0x14c1: 0x0040, 0x14c2: 0x0040, 0x14c3: 0x0040, 0x14c4: 0x0040, 0x14c5: 0x0040,
+	0x14c6: 0x0040, 0x14c7: 0x0040, 0x14c8: 0x0040, 0x14c9: 0x0040, 0x14ca: 0x0040, 0x14cb: 0x0040,
+	0x14cc: 0x0040, 0x14cd: 0x0040, 0x14ce: 0x0040, 0x14cf: 0x0040, 0x14d0: 0x95d1, 0x14d1: 0x9609,
+	0x14d2: 0x9609, 0x14d3: 0x9641, 0x14d4: 0x9679, 0x14d5: 0x96b1, 0x14d6: 0x96e9, 0x14d7: 0x9721,
+	0x14d8: 0x9759, 0x14d9: 0x9759, 0x14da: 0x9791, 0x14db: 0x97c9, 0x14dc: 0x9801, 0x14dd: 0x9839,
+	0x14de: 0x9871, 0x14df: 0x98a9, 0x14e0: 0x98a9, 0x14e1: 0x98e1, 0x14e2: 0x9919, 0x14e3: 0x9919,
+	0x14e4: 0x9951, 0x14e5: 0x9951, 0x14e6: 0x9989, 0x14e7: 0x99c1, 0x14e8: 0x99c1, 0x14e9: 0x99f9,
+	0x14ea: 0x9a31, 0x14eb: 0x9a31, 0x14ec: 0x9a69, 0x14ed: 0x9a69, 0x14ee: 0x9aa1, 0x14ef: 0x9ad9,
+	0x14f0: 0x9ad9, 0x14f1: 0x9b11, 0x14f2: 0x9b11, 0x14f3: 0x9b49, 0x14f4: 0x9b81, 0x14f5: 0x9bb9,
+	0x14f6: 0x9bf1, 0x14f7: 0x9bf1, 0x14f8: 0x9c29, 0x14f9: 0x9c61, 0x14fa: 0x9c99, 0x14fb: 0x9cd1,
+	0x14fc: 0x9d09, 0x14fd: 0x9d09, 0x14fe: 0x9d41, 0x14ff: 0x9d79,
+	// Block 0x54, offset 0x1500
+	0x1500: 0xa949, 0x1501: 0xa981, 0x1502: 0xa9b9, 0x1503: 0xa8a1, 0x1504: 0x9bb9, 0x1505: 0x9989,
+	0x1506: 0xa9f1, 0x1507: 0xaa29, 0x1508: 0x0040, 0x1509: 0x0040, 0x150a: 0x0040, 0x150b: 0x0040,
+	0x150c: 0x0040, 0x150d: 0x0040, 0x150e: 0x0040, 0x150f: 0x0040, 0x1510: 0x0040, 0x1511: 0x0040,
+	0x1512: 0x0040, 0x1513: 0x0040, 0x1514: 0x0040, 0x1515: 0x0040, 0x1516: 0x0040, 0x1517: 0x0040,
+	0x1518: 0x0040, 0x1519: 0x0040, 0x151a: 0x0040, 0x151b: 0x0040, 0x151c: 0x0040, 0x151d: 0x0040,
+	0x151e: 0x0040, 0x151f: 0x0040, 0x1520: 0x0040, 0x1521: 0x0040, 0x1522: 0x0040, 0x1523: 0x0040,
+	0x1524: 0x0040, 0x1525: 0x0040, 0x1526: 0x0040, 0x1527: 0x0040, 0x1528: 0x0040, 0x1529: 0x0040,
+	0x152a: 0x0040, 0x152b: 0x0040, 0x152c: 0x0040, 0x152d: 0x0040, 0x152e: 0x0040, 0x152f: 0x0040,
+	0x1530: 0xaa61, 0x1531: 0xaa99, 0x1532: 0xaad1, 0x1533: 0xab19, 0x1534: 0xab61, 0x1535: 0xaba9,
+	0x1536: 0xabf1, 0x1537: 0xac39, 0x1538: 0xac81, 0x1539: 0xacc9, 0x153a: 0xad02, 0x153b: 0xae12,
+	0x153c: 0xae91, 0x153d: 0x0018, 0x153e: 0x0040, 0x153f: 0x0040,
+	// Block 0x55, offset 0x1540
+	0x1540: 0x33c0, 0x1541: 0x33c0, 0x1542: 0x33c0, 0x1543: 0x33c0, 0x1544: 0x33c0, 0x1545: 0x33c0,
+	0x1546: 0x33c0, 0x1547: 0x33c0, 0x1548: 0x33c0, 0x1549: 0x33c0, 0x154a: 0x33c0, 0x154b: 0x33c0,
+	0x154c: 0x33c0, 0x154d: 0x33c0, 0x154e: 0x33c0, 0x154f: 0x33c0, 0x1550: 0xaeda, 0x1551: 0x7d55,
+	0x1552: 0x0040, 0x1553: 0xaeea, 0x1554: 0x03c2, 0x1555: 0xaefa, 0x1556: 0xaf0a, 0x1557: 0x7d75,
+	0x1558: 0x7d95, 0x1559: 0x0040, 0x155a: 0x0040, 0x155b: 0x0040, 0x155c: 0x0040, 0x155d: 0x0040,
+	0x155e: 0x0040, 0x155f: 0x0040, 0x1560: 0x3308, 0x1561: 0x3308, 0x1562: 0x3308, 0x1563: 0x3308,
+	0x1564: 0x3308, 0x1565: 0x3308, 0x1566: 0x3308, 0x1567: 0x3308, 0x1568: 0x3308, 0x1569: 0x3308,
+	0x156a: 0x3308, 0x156b: 0x3308, 0x156c: 0x3308, 0x156d: 0x3308, 0x156e: 0x3308, 0x156f: 0x3308,
+	0x1570: 0x0040, 0x1571: 0x7db5, 0x1572: 0x7dd5, 0x1573: 0xaf1a, 0x1574: 0xaf1a, 0x1575: 0x1fd2,
+	0x1576: 0x1fe2, 0x1577: 0xaf2a, 0x1578: 0xaf3a, 0x1579: 0x7df5, 0x157a: 0x7e15, 0x157b: 0x7e35,
+	0x157c: 0x7df5, 0x157d: 0x7e55, 0x157e: 0x7e75, 0x157f: 0x7e55,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x7e95, 0x1581: 0x7eb5, 0x1582: 0x7ed5, 0x1583: 0x7eb5, 0x1584: 0x7ef5, 0x1585: 0x0018,
+	0x1586: 0x0018, 0x1587: 0xaf4a, 0x1588: 0xaf5a, 0x1589: 0x7f16, 0x158a: 0x7f36, 0x158b: 0x7f56,
+	0x158c: 0x7f76, 0x158d: 0xaf1a, 0x158e: 0xaf1a, 0x158f: 0xaf1a, 0x1590: 0xaeda, 0x1591: 0x7f95,
+	0x1592: 0x0040, 0x1593: 0x0040, 0x1594: 0x03c2, 0x1595: 0xaeea, 0x1596: 0xaf0a, 0x1597: 0xaefa,
+	0x1598: 0x7fb5, 0x1599: 0x1fd2, 0x159a: 0x1fe2, 0x159b: 0xaf2a, 0x159c: 0xaf3a, 0x159d: 0x7e95,
+	0x159e: 0x7ef5, 0x159f: 0xaf6a, 0x15a0: 0xaf7a, 0x15a1: 0xaf8a, 0x15a2: 0x1fb2, 0x15a3: 0xaf99,
+	0x15a4: 0xafaa, 0x15a5: 0xafba, 0x15a6: 0x1fc2, 0x15a7: 0x0040, 0x15a8: 0xafca, 0x15a9: 0xafda,
+	0x15aa: 0xafea, 0x15ab: 0xaffa, 0x15ac: 0x0040, 0x15ad: 0x0040, 0x15ae: 0x0040, 0x15af: 0x0040,
+	0x15b0: 0x7fd6, 0x15b1: 0xb009, 0x15b2: 0x7ff6, 0x15b3: 0x0808, 0x15b4: 0x8016, 0x15b5: 0x0040,
+	0x15b6: 0x8036, 0x15b7: 0xb031, 0x15b8: 0x8056, 0x15b9: 0xb059, 0x15ba: 0x8076, 0x15bb: 0xb081,
+	0x15bc: 0x8096, 0x15bd: 0xb0a9, 0x15be: 0x80b6, 0x15bf: 0xb0d1,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0xb0f9, 0x15c1: 0xb111, 0x15c2: 0xb111, 0x15c3: 0xb129, 0x15c4: 0xb129, 0x15c5: 0xb141,
+	0x15c6: 0xb141, 0x15c7: 0xb159, 0x15c8: 0xb159, 0x15c9: 0xb171, 0x15ca: 0xb171, 0x15cb: 0xb171,
+	0x15cc: 0xb171, 0x15cd: 0xb189, 0x15ce: 0xb189, 0x15cf: 0xb1a1, 0x15d0: 0xb1a1, 0x15d1: 0xb1a1,
+	0x15d2: 0xb1a1, 0x15d3: 0xb1b9, 0x15d4: 0xb1b9, 0x15d5: 0xb1d1, 0x15d6: 0xb1d1, 0x15d7: 0xb1d1,
+	0x15d8: 0xb1d1, 0x15d9: 0xb1e9, 0x15da: 0xb1e9, 0x15db: 0xb1e9, 0x15dc: 0xb1e9, 0x15dd: 0xb201,
+	0x15de: 0xb201, 0x15df: 0xb201, 0x15e0: 0xb201, 0x15e1: 0xb219, 0x15e2: 0xb219, 0x15e3: 0xb219,
+	0x15e4: 0xb219, 0x15e5: 0xb231, 0x15e6: 0xb231, 0x15e7: 0xb231, 0x15e8: 0xb231, 0x15e9: 0xb249,
+	0x15ea: 0xb249, 0x15eb: 0xb261, 0x15ec: 0xb261, 0x15ed: 0xb279, 0x15ee: 0xb279, 0x15ef: 0xb291,
+	0x15f0: 0xb291, 0x15f1: 0xb2a9, 0x15f2: 0xb2a9, 0x15f3: 0xb2a9, 0x15f4: 0xb2a9, 0x15f5: 0xb2c1,
+	0x15f6: 0xb2c1, 0x15f7: 0xb2c1, 0x15f8: 0xb2c1, 0x15f9: 0xb2d9, 0x15fa: 0xb2d9, 0x15fb: 0xb2d9,
+	0x15fc: 0xb2d9, 0x15fd: 0xb2f1, 0x15fe: 0xb2f1, 0x15ff: 0xb2f1,
+	// Block 0x58, offset 0x1600
+	0x1600: 0xb2f1, 0x1601: 0xb309, 0x1602: 0xb309, 0x1603: 0xb309, 0x1604: 0xb309, 0x1605: 0xb321,
+	0x1606: 0xb321, 0x1607: 0xb321, 0x1608: 0xb321, 0x1609: 0xb339, 0x160a: 0xb339, 0x160b: 0xb339,
+	0x160c: 0xb339, 0x160d: 0xb351, 0x160e: 0xb351, 0x160f: 0xb351, 0x1610: 0xb351, 0x1611: 0xb369,
+	0x1612: 0xb369, 0x1613: 0xb369, 0x1614: 0xb369, 0x1615: 0xb381, 0x1616: 0xb381, 0x1617: 0xb381,
+	0x1618: 0xb381, 0x1619: 0xb399, 0x161a: 0xb399, 0x161b: 0xb399, 0x161c: 0xb399, 0x161d: 0xb3b1,
+	0x161e: 0xb3b1, 0x161f: 0xb3b1, 0x1620: 0xb3b1, 0x1621: 0xb3c9, 0x1622: 0xb3c9, 0x1623: 0xb3c9,
+	0x1624: 0xb3c9, 0x1625: 0xb3e1, 0x1626: 0xb3e1, 0x1627: 0xb3e1, 0x1628: 0xb3e1, 0x1629: 0xb3f9,
+	0x162a: 0xb3f9, 0x162b: 0xb3f9, 0x162c: 0xb3f9, 0x162d: 0xb411, 0x162e: 0xb411, 0x162f: 0x7ab1,
+	0x1630: 0x7ab1, 0x1631: 0xb429, 0x1632: 0xb429, 0x1633: 0xb429, 0x1634: 0xb429, 0x1635: 0xb441,
+	0x1636: 0xb441, 0x1637: 0xb469, 0x1638: 0xb469, 0x1639: 0xb491, 0x163a: 0xb491, 0x163b: 0xb4b9,
+	0x163c: 0xb4b9, 0x163d: 0x0040, 0x163e: 0x0040, 0x163f: 0x03c0,
+	// Block 0x59, offset 0x1640
+	0x1640: 0x0040, 0x1641: 0xaefa, 0x1642: 0xb4e2, 0x1643: 0xaf6a, 0x1644: 0xafda, 0x1645: 0xafea,
+	0x1646: 0xaf7a, 0x1647: 0xb4f2, 0x1648: 0x1fd2, 0x1649: 0x1fe2, 0x164a: 0xaf8a, 0x164b: 0x1fb2,
+	0x164c: 0xaeda, 0x164d: 0xaf99, 0x164e: 0x29d1, 0x164f: 0xb502, 0x1650: 0x1f41, 0x1651: 0x00c9,
+	0x1652: 0x0069, 0x1653: 0x0079, 0x1654: 0x1f51, 0x1655: 0x1f61, 0x1656: 0x1f71, 0x1657: 0x1f81,
+	0x1658: 0x1f91, 0x1659: 0x1fa1, 0x165a: 0xaeea, 0x165b: 0x03c2, 0x165c: 0xafaa, 0x165d: 0x1fc2,
+	0x165e: 0xafba, 0x165f: 0xaf0a, 0x1660: 0xaffa, 0x1661: 0x0039, 0x1662: 0x0ee9, 0x1663: 0x1159,
+	0x1664: 0x0ef9, 0x1665: 0x0f09, 0x1666: 0x1199, 0x1667: 0x0f31, 0x1668: 0x0249, 0x1669: 0x0f41,
+	0x166a: 0x0259, 0x166b: 0x0f51, 0x166c: 0x0359, 0x166d: 0x0f61, 0x166e: 0x0f71, 0x166f: 0x00d9,
+	0x1670: 0x0f99, 0x1671: 0x2039, 0x1672: 0x0269, 0x1673: 0x01d9, 0x1674: 0x0fa9, 0x1675: 0x0fb9,
+	0x1676: 0x1089, 0x1677: 0x0279, 0x1678: 0x0369, 0x1679: 0x0289, 0x167a: 0x13d1, 0x167b: 0xaf4a,
+	0x167c: 0xafca, 0x167d: 0xaf5a, 0x167e: 0xb512, 0x167f: 0xaf1a,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x1caa, 0x1681: 0x0039, 0x1682: 0x0ee9, 0x1683: 0x1159, 0x1684: 0x0ef9, 0x1685: 0x0f09,
+	0x1686: 0x1199, 0x1687: 0x0f31, 0x1688: 0x0249, 0x1689: 0x0f41, 0x168a: 0x0259, 0x168b: 0x0f51,
+	0x168c: 0x0359, 0x168d: 0x0f61, 0x168e: 0x0f71, 0x168f: 0x00d9, 0x1690: 0x0f99, 0x1691: 0x2039,
+	0x1692: 0x0269, 0x1693: 0x01d9, 0x1694: 0x0fa9, 0x1695: 0x0fb9, 0x1696: 0x1089, 0x1697: 0x0279,
+	0x1698: 0x0369, 0x1699: 0x0289, 0x169a: 0x13d1, 0x169b: 0xaf2a, 0x169c: 0xb522, 0x169d: 0xaf3a,
+	0x169e: 0xb532, 0x169f: 0x80d5, 0x16a0: 0x80f5, 0x16a1: 0x29d1, 0x16a2: 0x8115, 0x16a3: 0x8115,
+	0x16a4: 0x8135, 0x16a5: 0x8155, 0x16a6: 0x8175, 0x16a7: 0x8195, 0x16a8: 0x81b5, 0x16a9: 0x81d5,
+	0x16aa: 0x81f5, 0x16ab: 0x8215, 0x16ac: 0x8235, 0x16ad: 0x8255, 0x16ae: 0x8275, 0x16af: 0x8295,
+	0x16b0: 0x82b5, 0x16b1: 0x82d5, 0x16b2: 0x82f5, 0x16b3: 0x8315, 0x16b4: 0x8335, 0x16b5: 0x8355,
+	0x16b6: 0x8375, 0x16b7: 0x8395, 0x16b8: 0x83b5, 0x16b9: 0x83d5, 0x16ba: 0x83f5, 0x16bb: 0x8415,
+	0x16bc: 0x81b5, 0x16bd: 0x8435, 0x16be: 0x8455, 0x16bf: 0x8215,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x8475, 0x16c1: 0x8495, 0x16c2: 0x84b5, 0x16c3: 0x84d5, 0x16c4: 0x84f5, 0x16c5: 0x8515,
+	0x16c6: 0x8535, 0x16c7: 0x8555, 0x16c8: 0x84d5, 0x16c9: 0x8575, 0x16ca: 0x84d5, 0x16cb: 0x8595,
+	0x16cc: 0x8595, 0x16cd: 0x85b5, 0x16ce: 0x85b5, 0x16cf: 0x85d5, 0x16d0: 0x8515, 0x16d1: 0x85f5,
+	0x16d2: 0x8615, 0x16d3: 0x85f5, 0x16d4: 0x8635, 0x16d5: 0x8615, 0x16d6: 0x8655, 0x16d7: 0x8655,
+	0x16d8: 0x8675, 0x16d9: 0x8675, 0x16da: 0x8695, 0x16db: 0x8695, 0x16dc: 0x8615, 0x16dd: 0x8115,
+	0x16de: 0x86b5, 0x16df: 0x86d5, 0x16e0: 0x0040, 0x16e1: 0x86f5, 0x16e2: 0x8715, 0x16e3: 0x8735,
+	0x16e4: 0x8755, 0x16e5: 0x8735, 0x16e6: 0x8775, 0x16e7: 0x8795, 0x16e8: 0x87b5, 0x16e9: 0x87b5,
+	0x16ea: 0x87d5, 0x16eb: 0x87d5, 0x16ec: 0x87f5, 0x16ed: 0x87f5, 0x16ee: 0x87d5, 0x16ef: 0x87d5,
+	0x16f0: 0x8815, 0x16f1: 0x8835, 0x16f2: 0x8855, 0x16f3: 0x8875, 0x16f4: 0x8895, 0x16f5: 0x88b5,
+	0x16f6: 0x88b5, 0x16f7: 0x88b5, 0x16f8: 0x88d5, 0x16f9: 0x88d5, 0x16fa: 0x88d5, 0x16fb: 0x88d5,
+	0x16fc: 0x87b5, 0x16fd: 0x87b5, 0x16fe: 0x87b5, 0x16ff: 0x0040,
+	// Block 0x5c, offset 0x1700
+	0x1700: 0x0040, 0x1701: 0x0040, 0x1702: 0x8715, 0x1703: 0x86f5, 0x1704: 0x88f5, 0x1705: 0x86f5,
+	0x1706: 0x8715, 0x1707: 0x86f5, 0x1708: 0x0040, 0x1709: 0x0040, 0x170a: 0x8915, 0x170b: 0x8715,
+	0x170c: 0x8935, 0x170d: 0x88f5, 0x170e: 0x8935, 0x170f: 0x8715, 0x1710: 0x0040, 0x1711: 0x0040,
+	0x1712: 0x8955, 0x1713: 0x8975, 0x1714: 0x8875, 0x1715: 0x8935, 0x1716: 0x88f5, 0x1717: 0x8935,
+	0x1718: 0x0040, 0x1719: 0x0040, 0x171a: 0x8995, 0x171b: 0x89b5, 0x171c: 0x8995, 0x171d: 0x0040,
+	0x171e: 0x0040, 0x171f: 0x0040, 0x1720: 0xb541, 0x1721: 0xb559, 0x1722: 0xb571, 0x1723: 0x89d6,
+	0x1724: 0xb589, 0x1725: 0xb5a1, 0x1726: 0x89f5, 0x1727: 0x0040, 0x1728: 0x8a15, 0x1729: 0x8a35,
+	0x172a: 0x8a55, 0x172b: 0x8a35, 0x172c: 0x8a75, 0x172d: 0x8a95, 0x172e: 0x8ab5, 0x172f: 0x0040,
+	0x1730: 0x0040, 0x1731: 0x0040, 0x1732: 0x0040, 0x1733: 0x0040, 0x1734: 0x0040, 0x1735: 0x0040,
+	0x1736: 0x0040, 0x1737: 0x0040, 0x1738: 0x0040, 0x1739: 0x0340, 0x173a: 0x0340, 0x173b: 0x0340,
+	0x173c: 0x0040, 0x173d: 0x0040, 0x173e: 0x0040, 0x173f: 0x0040,
+	// Block 0x5d, offset 0x1740
+	0x1740: 0x0a08, 0x1741: 0x0a08, 0x1742: 0x0a08, 0x1743: 0x0a08, 0x1744: 0x0a08, 0x1745: 0x0c08,
+	0x1746: 0x0808, 0x1747: 0x0c08, 0x1748: 0x0818, 0x1749: 0x0c08, 0x174a: 0x0c08, 0x174b: 0x0808,
+	0x174c: 0x0808, 0x174d: 0x0908, 0x174e: 0x0c08, 0x174f: 0x0c08, 0x1750: 0x0c08, 0x1751: 0x0c08,
+	0x1752: 0x0c08, 0x1753: 0x0a08, 0x1754: 0x0a08, 0x1755: 0x0a08, 0x1756: 0x0a08, 0x1757: 0x0908,
+	0x1758: 0x0a08, 0x1759: 0x0a08, 0x175a: 0x0a08, 0x175b: 0x0a08, 0x175c: 0x0a08, 0x175d: 0x0c08,
+	0x175e: 0x0a08, 0x175f: 0x0a08, 0x1760: 0x0a08, 0x1761: 0x0c08, 0x1762: 0x0808, 0x1763: 0x0808,
+	0x1764: 0x0c08, 0x1765: 0x3308, 0x1766: 0x3308, 0x1767: 0x0040, 0x1768: 0x0040, 0x1769: 0x0040,
+	0x176a: 0x0040, 0x176b: 0x0a18, 0x176c: 0x0a18, 0x176d: 0x0a18, 0x176e: 0x0a18, 0x176f: 0x0c18,
+	0x1770: 0x0818, 0x1771: 0x0818, 0x1772: 0x0818, 0x1773: 0x0818, 0x1774: 0x0818, 0x1775: 0x0818,
+	0x1776: 0x0818, 0x1777: 0x0040, 0x1778: 0x0040, 0x1779: 0x0040, 0x177a: 0x0040, 0x177b: 0x0040,
+	0x177c: 0x0040, 0x177d: 0x0040, 0x177e: 0x0040, 0x177f: 0x0040,
+	// Block 0x5e, offset 0x1780
+	0x1780: 0x0a08, 0x1781: 0x0c08, 0x1782: 0x0a08, 0x1783: 0x0c08, 0x1784: 0x0c08, 0x1785: 0x0c08,
+	0x1786: 0x0a08, 0x1787: 0x0a08, 0x1788: 0x0a08, 0x1789: 0x0c08, 0x178a: 0x0a08, 0x178b: 0x0a08,
+	0x178c: 0x0c08, 0x178d: 0x0a08, 0x178e: 0x0c08, 0x178f: 0x0c08, 0x1790: 0x0a08, 0x1791: 0x0c08,
+	0x1792: 0x0040, 0x1793: 0x0040, 0x1794: 0x0040, 0x1795: 0x0040, 0x1796: 0x0040, 0x1797: 0x0040,
+	0x1798: 0x0040, 0x1799: 0x0818, 0x179a: 0x0818, 0x179b: 0x0818, 0x179c: 0x0818, 0x179d: 0x0040,
+	0x179e: 0x0040, 0x179f: 0x0040, 0x17a0: 0x0040, 0x17a1: 0x0040, 0x17a2: 0x0040, 0x17a3: 0x0040,
+	0x17a4: 0x0040, 0x17a5: 0x0040, 0x17a6: 0x0040, 0x17a7: 0x0040, 0x17a8: 0x0040, 0x17a9: 0x0c18,
+	0x17aa: 0x0c18, 0x17ab: 0x0c18, 0x17ac: 0x0c18, 0x17ad: 0x0a18, 0x17ae: 0x0a18, 0x17af: 0x0818,
+	0x17b0: 0x0040, 0x17b1: 0x0040, 0x17b2: 0x0040, 0x17b3: 0x0040, 0x17b4: 0x0040, 0x17b5: 0x0040,
+	0x17b6: 0x0040, 0x17b7: 0x0040, 0x17b8: 0x0040, 0x17b9: 0x0040, 0x17ba: 0x0040, 0x17bb: 0x0040,
+	0x17bc: 0x0040, 0x17bd: 0x0040, 0x17be: 0x0040, 0x17bf: 0x0040,
+	// Block 0x5f, offset 0x17c0
+	0x17c0: 0x3308, 0x17c1: 0x3308, 0x17c2: 0x3008, 0x17c3: 0x3008, 0x17c4: 0x0040, 0x17c5: 0x0008,
+	0x17c6: 0x0008, 0x17c7: 0x0008, 0x17c8: 0x0008, 0x17c9: 0x0008, 0x17ca: 0x0008, 0x17cb: 0x0008,
+	0x17cc: 0x0008, 0x17cd: 0x0040, 0x17ce: 0x0040, 0x17cf: 0x0008, 0x17d0: 0x0008, 0x17d1: 0x0040,
+	0x17d2: 0x0040, 0x17d3: 0x0008, 0x17d4: 0x0008, 0x17d5: 0x0008, 0x17d6: 0x0008, 0x17d7: 0x0008,
+	0x17d8: 0x0008, 0x17d9: 0x0008, 0x17da: 0x0008, 0x17db: 0x0008, 0x17dc: 0x0008, 0x17dd: 0x0008,
+	0x17de: 0x0008, 0x17df: 0x0008, 0x17e0: 0x0008, 0x17e1: 0x0008, 0x17e2: 0x0008, 0x17e3: 0x0008,
+	0x17e4: 0x0008, 0x17e5: 0x0008, 0x17e6: 0x0008, 0x17e7: 0x0008, 0x17e8: 0x0008, 0x17e9: 0x0040,
+	0x17ea: 0x0008, 0x17eb: 0x0008, 0x17ec: 0x0008, 0x17ed: 0x0008, 0x17ee: 0x0008, 0x17ef: 0x0008,
+	0x17f0: 0x0008, 0x17f1: 0x0040, 0x17f2: 0x0008, 0x17f3: 0x0008, 0x17f4: 0x0040, 0x17f5: 0x0008,
+	0x17f6: 0x0008, 0x17f7: 0x0008, 0x17f8: 0x0008, 0x17f9: 0x0008, 0x17fa: 0x0040, 0x17fb: 0x0040,
+	0x17fc: 0x3308, 0x17fd: 0x0008, 0x17fe: 0x3008, 0x17ff: 0x3008,
+	// Block 0x60, offset 0x1800
+	0x1800: 0x3308, 0x1801: 0x3008, 0x1802: 0x3008, 0x1803: 0x3008, 0x1804: 0x3008, 0x1805: 0x0040,
+	0x1806: 0x0040, 0x1807: 0x3008, 0x1808: 0x3008, 0x1809: 0x0040, 0x180a: 0x0040, 0x180b: 0x3008,
+	0x180c: 0x3008, 0x180d: 0x3808, 0x180e: 0x0040, 0x180f: 0x0040, 0x1810: 0x0008, 0x1811: 0x0040,
+	0x1812: 0x0040, 0x1813: 0x0040, 0x1814: 0x0040, 0x1815: 0x0040, 0x1816: 0x0040, 0x1817: 0x3008,
+	0x1818: 0x0040, 0x1819: 0x0040, 0x181a: 0x0040, 0x181b: 0x0040, 0x181c: 0x0040, 0x181d: 0x0008,
+	0x181e: 0x0008, 0x181f: 0x0008, 0x1820: 0x0008, 0x1821: 0x0008, 0x1822: 0x3008, 0x1823: 0x3008,
+	0x1824: 0x0040, 0x1825: 0x0040, 0x1826: 0x3308, 0x1827: 0x3308, 0x1828: 0x3308, 0x1829: 0x3308,
+	0x182a: 0x3308, 0x182b: 0x3308, 0x182c: 0x3308, 0x182d: 0x0040, 0x182e: 0x0040, 0x182f: 0x0040,
+	0x1830: 0x3308, 0x1831: 0x3308, 0x1832: 0x3308, 0x1833: 0x3308, 0x1834: 0x3308, 0x1835: 0x0040,
+	0x1836: 0x0040, 0x1837: 0x0040, 0x1838: 0x0040, 0x1839: 0x0040, 0x183a: 0x0040, 0x183b: 0x0040,
+	0x183c: 0x0040, 0x183d: 0x0040, 0x183e: 0x0040, 0x183f: 0x0040,
+	// Block 0x61, offset 0x1840
+	0x1840: 0x0039, 0x1841: 0x0ee9, 0x1842: 0x1159, 0x1843: 0x0ef9, 0x1844: 0x0f09, 0x1845: 0x1199,
+	0x1846: 0x0f31, 0x1847: 0x0249, 0x1848: 0x0f41, 0x1849: 0x0259, 0x184a: 0x0f51, 0x184b: 0x0359,
+	0x184c: 0x0f61, 0x184d: 0x0f71, 0x184e: 0x00d9, 0x184f: 0x0f99, 0x1850: 0x2039, 0x1851: 0x0269,
+	0x1852: 0x01d9, 0x1853: 0x0fa9, 0x1854: 0x0fb9, 0x1855: 0x1089, 0x1856: 0x0279, 0x1857: 0x0369,
+	0x1858: 0x0289, 0x1859: 0x13d1, 0x185a: 0x0039, 0x185b: 0x0ee9, 0x185c: 0x1159, 0x185d: 0x0ef9,
+	0x185e: 0x0f09, 0x185f: 0x1199, 0x1860: 0x0f31, 0x1861: 0x0249, 0x1862: 0x0f41, 0x1863: 0x0259,
+	0x1864: 0x0f51, 0x1865: 0x0359, 0x1866: 0x0f61, 0x1867: 0x0f71, 0x1868: 0x00d9, 0x1869: 0x0f99,
+	0x186a: 0x2039, 0x186b: 0x0269, 0x186c: 0x01d9, 0x186d: 0x0fa9, 0x186e: 0x0fb9, 0x186f: 0x1089,
+	0x1870: 0x0279, 0x1871: 0x0369, 0x1872: 0x0289, 0x1873: 0x13d1, 0x1874: 0x0039, 0x1875: 0x0ee9,
+	0x1876: 0x1159, 0x1877: 0x0ef9, 0x1878: 0x0f09, 0x1879: 0x1199, 0x187a: 0x0f31, 0x187b: 0x0249,
+	0x187c: 0x0f41, 0x187d: 0x0259, 0x187e: 0x0f51, 0x187f: 0x0359,
+	// Block 0x62, offset 0x1880
+	0x1880: 0x0f61, 0x1881: 0x0f71, 0x1882: 0x00d9, 0x1883: 0x0f99, 0x1884: 0x2039, 0x1885: 0x0269,
+	0x1886: 0x01d9, 0x1887: 0x0fa9, 0x1888: 0x0fb9, 0x1889: 0x1089, 0x188a: 0x0279, 0x188b: 0x0369,
+	0x188c: 0x0289, 0x188d: 0x13d1, 0x188e: 0x0039, 0x188f: 0x0ee9, 0x1890: 0x1159, 0x1891: 0x0ef9,
+	0x1892: 0x0f09, 0x1893: 0x1199, 0x1894: 0x0f31, 0x1895: 0x0040, 0x1896: 0x0f41, 0x1897: 0x0259,
+	0x1898: 0x0f51, 0x1899: 0x0359, 0x189a: 0x0f61, 0x189b: 0x0f71, 0x189c: 0x00d9, 0x189d: 0x0f99,
+	0x189e: 0x2039, 0x189f: 0x0269, 0x18a0: 0x01d9, 0x18a1: 0x0fa9, 0x18a2: 0x0fb9, 0x18a3: 0x1089,
+	0x18a4: 0x0279, 0x18a5: 0x0369, 0x18a6: 0x0289, 0x18a7: 0x13d1, 0x18a8: 0x0039, 0x18a9: 0x0ee9,
+	0x18aa: 0x1159, 0x18ab: 0x0ef9, 0x18ac: 0x0f09, 0x18ad: 0x1199, 0x18ae: 0x0f31, 0x18af: 0x0249,
+	0x18b0: 0x0f41, 0x18b1: 0x0259, 0x18b2: 0x0f51, 0x18b3: 0x0359, 0x18b4: 0x0f61, 0x18b5: 0x0f71,
+	0x18b6: 0x00d9, 0x18b7: 0x0f99, 0x18b8: 0x2039, 0x18b9: 0x0269, 0x18ba: 0x01d9, 0x18bb: 0x0fa9,
+	0x18bc: 0x0fb9, 0x18bd: 0x1089, 0x18be: 0x0279, 0x18bf: 0x0369,
+	// Block 0x63, offset 0x18c0
+	0x18c0: 0x0289, 0x18c1: 0x13d1, 0x18c2: 0x0039, 0x18c3: 0x0ee9, 0x18c4: 0x1159, 0x18c5: 0x0ef9,
+	0x18c6: 0x0f09, 0x18c7: 0x1199, 0x18c8: 0x0f31, 0x18c9: 0x0249, 0x18ca: 0x0f41, 0x18cb: 0x0259,
+	0x18cc: 0x0f51, 0x18cd: 0x0359, 0x18ce: 0x0f61, 0x18cf: 0x0f71, 0x18d0: 0x00d9, 0x18d1: 0x0f99,
+	0x18d2: 0x2039, 0x18d3: 0x0269, 0x18d4: 0x01d9, 0x18d5: 0x0fa9, 0x18d6: 0x0fb9, 0x18d7: 0x1089,
+	0x18d8: 0x0279, 0x18d9: 0x0369, 0x18da: 0x0289, 0x18db: 0x13d1, 0x18dc: 0x0039, 0x18dd: 0x0040,
+	0x18de: 0x1159, 0x18df: 0x0ef9, 0x18e0: 0x0040, 0x18e1: 0x0040, 0x18e2: 0x0f31, 0x18e3: 0x0040,
+	0x18e4: 0x0040, 0x18e5: 0x0259, 0x18e6: 0x0f51, 0x18e7: 0x0040, 0x18e8: 0x0040, 0x18e9: 0x0f71,
+	0x18ea: 0x00d9, 0x18eb: 0x0f99, 0x18ec: 0x2039, 0x18ed: 0x0040, 0x18ee: 0x01d9, 0x18ef: 0x0fa9,
+	0x18f0: 0x0fb9, 0x18f1: 0x1089, 0x18f2: 0x0279, 0x18f3: 0x0369, 0x18f4: 0x0289, 0x18f5: 0x13d1,
+	0x18f6: 0x0039, 0x18f7: 0x0ee9, 0x18f8: 0x1159, 0x18f9: 0x0ef9, 0x18fa: 0x0040, 0x18fb: 0x1199,
+	0x18fc: 0x0040, 0x18fd: 0x0249, 0x18fe: 0x0f41, 0x18ff: 0x0259,
+	// Block 0x64, offset 0x1900
+	0x1900: 0x0f51, 0x1901: 0x0359, 0x1902: 0x0f61, 0x1903: 0x0f71, 0x1904: 0x0040, 0x1905: 0x0f99,
+	0x1906: 0x2039, 0x1907: 0x0269, 0x1908: 0x01d9, 0x1909: 0x0fa9, 0x190a: 0x0fb9, 0x190b: 0x1089,
+	0x190c: 0x0279, 0x190d: 0x0369, 0x190e: 0x0289, 0x190f: 0x13d1, 0x1910: 0x0039, 0x1911: 0x0ee9,
+	0x1912: 0x1159, 0x1913: 0x0ef9, 0x1914: 0x0f09, 0x1915: 0x1199, 0x1916: 0x0f31, 0x1917: 0x0249,
+	0x1918: 0x0f41, 0x1919: 0x0259, 0x191a: 0x0f51, 0x191b: 0x0359, 0x191c: 0x0f61, 0x191d: 0x0f71,
+	0x191e: 0x00d9, 0x191f: 0x0f99, 0x1920: 0x2039, 0x1921: 0x0269, 0x1922: 0x01d9, 0x1923: 0x0fa9,
+	0x1924: 0x0fb9, 0x1925: 0x1089, 0x1926: 0x0279, 0x1927: 0x0369, 0x1928: 0x0289, 0x1929: 0x13d1,
+	0x192a: 0x0039, 0x192b: 0x0ee9, 0x192c: 0x1159, 0x192d: 0x0ef9, 0x192e: 0x0f09, 0x192f: 0x1199,
+	0x1930: 0x0f31, 0x1931: 0x0249, 0x1932: 0x0f41, 0x1933: 0x0259, 0x1934: 0x0f51, 0x1935: 0x0359,
+	0x1936: 0x0f61, 0x1937: 0x0f71, 0x1938: 0x00d9, 0x1939: 0x0f99, 0x193a: 0x2039, 0x193b: 0x0269,
+	0x193c: 0x01d9, 0x193d: 0x0fa9, 0x193e: 0x0fb9, 0x193f: 0x1089,
+	// Block 0x65, offset 0x1940
+	0x1940: 0x0279, 0x1941: 0x0369, 0x1942: 0x0289, 0x1943: 0x13d1, 0x1944: 0x0039, 0x1945: 0x0ee9,
+	0x1946: 0x0040, 0x1947: 0x0ef9, 0x1948: 0x0f09, 0x1949: 0x1199, 0x194a: 0x0f31, 0x194b: 0x0040,
+	0x194c: 0x0040, 0x194d: 0x0259, 0x194e: 0x0f51, 0x194f: 0x0359, 0x1950: 0x0f61, 0x1951: 0x0f71,
+	0x1952: 0x00d9, 0x1953: 0x0f99, 0x1954: 0x2039, 0x1955: 0x0040, 0x1956: 0x01d9, 0x1957: 0x0fa9,
+	0x1958: 0x0fb9, 0x1959: 0x1089, 0x195a: 0x0279, 0x195b: 0x0369, 0x195c: 0x0289, 0x195d: 0x0040,
+	0x195e: 0x0039, 0x195f: 0x0ee9, 0x1960: 0x1159, 0x1961: 0x0ef9, 0x1962: 0x0f09, 0x1963: 0x1199,
+	0x1964: 0x0f31, 0x1965: 0x0249, 0x1966: 0x0f41, 0x1967: 0x0259, 0x1968: 0x0f51, 0x1969: 0x0359,
+	0x196a: 0x0f61, 0x196b: 0x0f71, 0x196c: 0x00d9, 0x196d: 0x0f99, 0x196e: 0x2039, 0x196f: 0x0269,
+	0x1970: 0x01d9, 0x1971: 0x0fa9, 0x1972: 0x0fb9, 0x1973: 0x1089, 0x1974: 0x0279, 0x1975: 0x0369,
+	0x1976: 0x0289, 0x1977: 0x13d1, 0x1978: 0x0039, 0x1979: 0x0ee9, 0x197a: 0x0040, 0x197b: 0x0ef9,
+	0x197c: 0x0f09, 0x197d: 0x1199, 0x197e: 0x0f31, 0x197f: 0x0040,
+	// Block 0x66, offset 0x1980
+	0x1980: 0x0f41, 0x1981: 0x0259, 0x1982: 0x0f51, 0x1983: 0x0359, 0x1984: 0x0f61, 0x1985: 0x0040,
+	0x1986: 0x00d9, 0x1987: 0x0040, 0x1988: 0x0040, 0x1989: 0x0040, 0x198a: 0x01d9, 0x198b: 0x0fa9,
+	0x198c: 0x0fb9, 0x198d: 0x1089, 0x198e: 0x0279, 0x198f: 0x0369, 0x1990: 0x0289, 0x1991: 0x0040,
+	0x1992: 0x0039, 0x1993: 0x0ee9, 0x1994: 0x1159, 0x1995: 0x0ef9, 0x1996: 0x0f09, 0x1997: 0x1199,
+	0x1998: 0x0f31, 0x1999: 0x0249, 0x199a: 0x0f41, 0x199b: 0x0259, 0x199c: 0x0f51, 0x199d: 0x0359,
+	0x199e: 0x0f61, 0x199f: 0x0f71, 0x19a0: 0x00d9, 0x19a1: 0x0f99, 0x19a2: 0x2039, 0x19a3: 0x0269,
+	0x19a4: 0x01d9, 0x19a5: 0x0fa9, 0x19a6: 0x0fb9, 0x19a7: 0x1089, 0x19a8: 0x0279, 0x19a9: 0x0369,
+	0x19aa: 0x0289, 0x19ab: 0x13d1, 0x19ac: 0x0039, 0x19ad: 0x0ee9, 0x19ae: 0x1159, 0x19af: 0x0ef9,
+	0x19b0: 0x0f09, 0x19b1: 0x1199, 0x19b2: 0x0f31, 0x19b3: 0x0249, 0x19b4: 0x0f41, 0x19b5: 0x0259,
+	0x19b6: 0x0f51, 0x19b7: 0x0359, 0x19b8: 0x0f61, 0x19b9: 0x0f71, 0x19ba: 0x00d9, 0x19bb: 0x0f99,
+	0x19bc: 0x2039, 0x19bd: 0x0269, 0x19be: 0x01d9, 0x19bf: 0x0fa9,
+	// Block 0x67, offset 0x19c0
+	0x19c0: 0x0fb9, 0x19c1: 0x1089, 0x19c2: 0x0279, 0x19c3: 0x0369, 0x19c4: 0x0289, 0x19c5: 0x13d1,
+	0x19c6: 0x0039, 0x19c7: 0x0ee9, 0x19c8: 0x1159, 0x19c9: 0x0ef9, 0x19ca: 0x0f09, 0x19cb: 0x1199,
+	0x19cc: 0x0f31, 0x19cd: 0x0249, 0x19ce: 0x0f41, 0x19cf: 0x0259, 0x19d0: 0x0f51, 0x19d1: 0x0359,
+	0x19d2: 0x0f61, 0x19d3: 0x0f71, 0x19d4: 0x00d9, 0x19d5: 0x0f99, 0x19d6: 0x2039, 0x19d7: 0x0269,
+	0x19d8: 0x01d9, 0x19d9: 0x0fa9, 0x19da: 0x0fb9, 0x19db: 0x1089, 0x19dc: 0x0279, 0x19dd: 0x0369,
+	0x19de: 0x0289, 0x19df: 0x13d1, 0x19e0: 0x0039, 0x19e1: 0x0ee9, 0x19e2: 0x1159, 0x19e3: 0x0ef9,
+	0x19e4: 0x0f09, 0x19e5: 0x1199, 0x19e6: 0x0f31, 0x19e7: 0x0249, 0x19e8: 0x0f41, 0x19e9: 0x0259,
+	0x19ea: 0x0f51, 0x19eb: 0x0359, 0x19ec: 0x0f61, 0x19ed: 0x0f71, 0x19ee: 0x00d9, 0x19ef: 0x0f99,
+	0x19f0: 0x2039, 0x19f1: 0x0269, 0x19f2: 0x01d9, 0x19f3: 0x0fa9, 0x19f4: 0x0fb9, 0x19f5: 0x1089,
+	0x19f6: 0x0279, 0x19f7: 0x0369, 0x19f8: 0x0289, 0x19f9: 0x13d1, 0x19fa: 0x0039, 0x19fb: 0x0ee9,
+	0x19fc: 0x1159, 0x19fd: 0x0ef9, 0x19fe: 0x0f09, 0x19ff: 0x1199,
+	// Block 0x68, offset 0x1a00
+	0x1a00: 0x0f31, 0x1a01: 0x0249, 0x1a02: 0x0f41, 0x1a03: 0x0259, 0x1a04: 0x0f51, 0x1a05: 0x0359,
+	0x1a06: 0x0f61, 0x1a07: 0x0f71, 0x1a08: 0x00d9, 0x1a09: 0x0f99, 0x1a0a: 0x2039, 0x1a0b: 0x0269,
+	0x1a0c: 0x01d9, 0x1a0d: 0x0fa9, 0x1a0e: 0x0fb9, 0x1a0f: 0x1089, 0x1a10: 0x0279, 0x1a11: 0x0369,
+	0x1a12: 0x0289, 0x1a13: 0x13d1, 0x1a14: 0x0039, 0x1a15: 0x0ee9, 0x1a16: 0x1159, 0x1a17: 0x0ef9,
+	0x1a18: 0x0f09, 0x1a19: 0x1199, 0x1a1a: 0x0f31, 0x1a1b: 0x0249, 0x1a1c: 0x0f41, 0x1a1d: 0x0259,
+	0x1a1e: 0x0f51, 0x1a1f: 0x0359, 0x1a20: 0x0f61, 0x1a21: 0x0f71, 0x1a22: 0x00d9, 0x1a23: 0x0f99,
+	0x1a24: 0x2039, 0x1a25: 0x0269, 0x1a26: 0x01d9, 0x1a27: 0x0fa9, 0x1a28: 0x0fb9, 0x1a29: 0x1089,
+	0x1a2a: 0x0279, 0x1a2b: 0x0369, 0x1a2c: 0x0289, 0x1a2d: 0x13d1, 0x1a2e: 0x0039, 0x1a2f: 0x0ee9,
+	0x1a30: 0x1159, 0x1a31: 0x0ef9, 0x1a32: 0x0f09, 0x1a33: 0x1199, 0x1a34: 0x0f31, 0x1a35: 0x0249,
+	0x1a36: 0x0f41, 0x1a37: 0x0259, 0x1a38: 0x0f51, 0x1a39: 0x0359, 0x1a3a: 0x0f61, 0x1a3b: 0x0f71,
+	0x1a3c: 0x00d9, 0x1a3d: 0x0f99, 0x1a3e: 0x2039, 0x1a3f: 0x0269,
+	// Block 0x69, offset 0x1a40
+	0x1a40: 0x01d9, 0x1a41: 0x0fa9, 0x1a42: 0x0fb9, 0x1a43: 0x1089, 0x1a44: 0x0279, 0x1a45: 0x0369,
+	0x1a46: 0x0289, 0x1a47: 0x13d1, 0x1a48: 0x0039, 0x1a49: 0x0ee9, 0x1a4a: 0x1159, 0x1a4b: 0x0ef9,
+	0x1a4c: 0x0f09, 0x1a4d: 0x1199, 0x1a4e: 0x0f31, 0x1a4f: 0x0249, 0x1a50: 0x0f41, 0x1a51: 0x0259,
+	0x1a52: 0x0f51, 0x1a53: 0x0359, 0x1a54: 0x0f61, 0x1a55: 0x0f71, 0x1a56: 0x00d9, 0x1a57: 0x0f99,
+	0x1a58: 0x2039, 0x1a59: 0x0269, 0x1a5a: 0x01d9, 0x1a5b: 0x0fa9, 0x1a5c: 0x0fb9, 0x1a5d: 0x1089,
+	0x1a5e: 0x0279, 0x1a5f: 0x0369, 0x1a60: 0x0289, 0x1a61: 0x13d1, 0x1a62: 0x0039, 0x1a63: 0x0ee9,
+	0x1a64: 0x1159, 0x1a65: 0x0ef9, 0x1a66: 0x0f09, 0x1a67: 0x1199, 0x1a68: 0x0f31, 0x1a69: 0x0249,
+	0x1a6a: 0x0f41, 0x1a6b: 0x0259, 0x1a6c: 0x0f51, 0x1a6d: 0x0359, 0x1a6e: 0x0f61, 0x1a6f: 0x0f71,
+	0x1a70: 0x00d9, 0x1a71: 0x0f99, 0x1a72: 0x2039, 0x1a73: 0x0269, 0x1a74: 0x01d9, 0x1a75: 0x0fa9,
+	0x1a76: 0x0fb9, 0x1a77: 0x1089, 0x1a78: 0x0279, 0x1a79: 0x0369, 0x1a7a: 0x0289, 0x1a7b: 0x13d1,
+	0x1a7c: 0x0039, 0x1a7d: 0x0ee9, 0x1a7e: 0x1159, 0x1a7f: 0x0ef9,
+	// Block 0x6a, offset 0x1a80
+	0x1a80: 0x0f09, 0x1a81: 0x1199, 0x1a82: 0x0f31, 0x1a83: 0x0249, 0x1a84: 0x0f41, 0x1a85: 0x0259,
+	0x1a86: 0x0f51, 0x1a87: 0x0359, 0x1a88: 0x0f61, 0x1a89: 0x0f71, 0x1a8a: 0x00d9, 0x1a8b: 0x0f99,
+	0x1a8c: 0x2039, 0x1a8d: 0x0269, 0x1a8e: 0x01d9, 0x1a8f: 0x0fa9, 0x1a90: 0x0fb9, 0x1a91: 0x1089,
+	0x1a92: 0x0279, 0x1a93: 0x0369, 0x1a94: 0x0289, 0x1a95: 0x13d1, 0x1a96: 0x0039, 0x1a97: 0x0ee9,
+	0x1a98: 0x1159, 0x1a99: 0x0ef9, 0x1a9a: 0x0f09, 0x1a9b: 0x1199, 0x1a9c: 0x0f31, 0x1a9d: 0x0249,
+	0x1a9e: 0x0f41, 0x1a9f: 0x0259, 0x1aa0: 0x0f51, 0x1aa1: 0x0359, 0x1aa2: 0x0f61, 0x1aa3: 0x0f71,
+	0x1aa4: 0x00d9, 0x1aa5: 0x0f99, 0x1aa6: 0x2039, 0x1aa7: 0x0269, 0x1aa8: 0x01d9, 0x1aa9: 0x0fa9,
+	0x1aaa: 0x0fb9, 0x1aab: 0x1089, 0x1aac: 0x0279, 0x1aad: 0x0369, 0x1aae: 0x0289, 0x1aaf: 0x13d1,
+	0x1ab0: 0x0039, 0x1ab1: 0x0ee9, 0x1ab2: 0x1159, 0x1ab3: 0x0ef9, 0x1ab4: 0x0f09, 0x1ab5: 0x1199,
+	0x1ab6: 0x0f31, 0x1ab7: 0x0249, 0x1ab8: 0x0f41, 0x1ab9: 0x0259, 0x1aba: 0x0f51, 0x1abb: 0x0359,
+	0x1abc: 0x0f61, 0x1abd: 0x0f71, 0x1abe: 0x00d9, 0x1abf: 0x0f99,
+	// Block 0x6b, offset 0x1ac0
+	0x1ac0: 0x2039, 0x1ac1: 0x0269, 0x1ac2: 0x01d9, 0x1ac3: 0x0fa9, 0x1ac4: 0x0fb9, 0x1ac5: 0x1089,
+	0x1ac6: 0x0279, 0x1ac7: 0x0369, 0x1ac8: 0x0289, 0x1ac9: 0x13d1, 0x1aca: 0x0039, 0x1acb: 0x0ee9,
+	0x1acc: 0x1159, 0x1acd: 0x0ef9, 0x1ace: 0x0f09, 0x1acf: 0x1199, 0x1ad0: 0x0f31, 0x1ad1: 0x0249,
+	0x1ad2: 0x0f41, 0x1ad3: 0x0259, 0x1ad4: 0x0f51, 0x1ad5: 0x0359, 0x1ad6: 0x0f61, 0x1ad7: 0x0f71,
+	0x1ad8: 0x00d9, 0x1ad9: 0x0f99, 0x1ada: 0x2039, 0x1adb: 0x0269, 0x1adc: 0x01d9, 0x1add: 0x0fa9,
+	0x1ade: 0x0fb9, 0x1adf: 0x1089, 0x1ae0: 0x0279, 0x1ae1: 0x0369, 0x1ae2: 0x0289, 0x1ae3: 0x13d1,
+	0x1ae4: 0xba81, 0x1ae5: 0xba99, 0x1ae6: 0x0040, 0x1ae7: 0x0040, 0x1ae8: 0xbab1, 0x1ae9: 0x1099,
+	0x1aea: 0x10b1, 0x1aeb: 0x10c9, 0x1aec: 0xbac9, 0x1aed: 0xbae1, 0x1aee: 0xbaf9, 0x1aef: 0x1429,
+	0x1af0: 0x1a31, 0x1af1: 0xbb11, 0x1af2: 0xbb29, 0x1af3: 0xbb41, 0x1af4: 0xbb59, 0x1af5: 0xbb71,
+	0x1af6: 0xbb89, 0x1af7: 0x2109, 0x1af8: 0x1111, 0x1af9: 0x1429, 0x1afa: 0xbba1, 0x1afb: 0xbbb9,
+	0x1afc: 0xbbd1, 0x1afd: 0x10e1, 0x1afe: 0x10f9, 0x1aff: 0xbbe9,
+	// Block 0x6c, offset 0x1b00
+	0x1b00: 0x2079, 0x1b01: 0xbc01, 0x1b02: 0xbab1, 0x1b03: 0x1099, 0x1b04: 0x10b1, 0x1b05: 0x10c9,
+	0x1b06: 0xbac9, 0x1b07: 0xbae1, 0x1b08: 0xbaf9, 0x1b09: 0x1429, 0x1b0a: 0x1a31, 0x1b0b: 0xbb11,
+	0x1b0c: 0xbb29, 0x1b0d: 0xbb41, 0x1b0e: 0xbb59, 0x1b0f: 0xbb71, 0x1b10: 0xbb89, 0x1b11: 0x2109,
+	0x1b12: 0x1111, 0x1b13: 0xbba1, 0x1b14: 0xbba1, 0x1b15: 0xbbb9, 0x1b16: 0xbbd1, 0x1b17: 0x10e1,
+	0x1b18: 0x10f9, 0x1b19: 0xbbe9, 0x1b1a: 0x2079, 0x1b1b: 0xbc21, 0x1b1c: 0xbac9, 0x1b1d: 0x1429,
+	0x1b1e: 0xbb11, 0x1b1f: 0x10e1, 0x1b20: 0x1111, 0x1b21: 0x2109, 0x1b22: 0xbab1, 0x1b23: 0x1099,
+	0x1b24: 0x10b1, 0x1b25: 0x10c9, 0x1b26: 0xbac9, 0x1b27: 0xbae1, 0x1b28: 0xbaf9, 0x1b29: 0x1429,
+	0x1b2a: 0x1a31, 0x1b2b: 0xbb11, 0x1b2c: 0xbb29, 0x1b2d: 0xbb41, 0x1b2e: 0xbb59, 0x1b2f: 0xbb71,
+	0x1b30: 0xbb89, 0x1b31: 0x2109, 0x1b32: 0x1111, 0x1b33: 0x1429, 0x1b34: 0xbba1, 0x1b35: 0xbbb9,
+	0x1b36: 0xbbd1, 0x1b37: 0x10e1, 0x1b38: 0x10f9, 0x1b39: 0xbbe9, 0x1b3a: 0x2079, 0x1b3b: 0xbc01,
+	0x1b3c: 0xbab1, 0x1b3d: 0x1099, 0x1b3e: 0x10b1, 0x1b3f: 0x10c9,
+	// Block 0x6d, offset 0x1b40
+	0x1b40: 0xbac9, 0x1b41: 0xbae1, 0x1b42: 0xbaf9, 0x1b43: 0x1429, 0x1b44: 0x1a31, 0x1b45: 0xbb11,
+	0x1b46: 0xbb29, 0x1b47: 0xbb41, 0x1b48: 0xbb59, 0x1b49: 0xbb71, 0x1b4a: 0xbb89, 0x1b4b: 0x2109,
+	0x1b4c: 0x1111, 0x1b4d: 0xbba1, 0x1b4e: 0xbba1, 0x1b4f: 0xbbb9, 0x1b50: 0xbbd1, 0x1b51: 0x10e1,
+	0x1b52: 0x10f9, 0x1b53: 0xbbe9, 0x1b54: 0x2079, 0x1b55: 0xbc21, 0x1b56: 0xbac9, 0x1b57: 0x1429,
+	0x1b58: 0xbb11, 0x1b59: 0x10e1, 0x1b5a: 0x1111, 0x1b5b: 0x2109, 0x1b5c: 0xbab1, 0x1b5d: 0x1099,
+	0x1b5e: 0x10b1, 0x1b5f: 0x10c9, 0x1b60: 0xbac9, 0x1b61: 0xbae1, 0x1b62: 0xbaf9, 0x1b63: 0x1429,
+	0x1b64: 0x1a31, 0x1b65: 0xbb11, 0x1b66: 0xbb29, 0x1b67: 0xbb41, 0x1b68: 0xbb59, 0x1b69: 0xbb71,
+	0x1b6a: 0xbb89, 0x1b6b: 0x2109, 0x1b6c: 0x1111, 0x1b6d: 0x1429, 0x1b6e: 0xbba1, 0x1b6f: 0xbbb9,
+	0x1b70: 0xbbd1, 0x1b71: 0x10e1, 0x1b72: 0x10f9, 0x1b73: 0xbbe9, 0x1b74: 0x2079, 0x1b75: 0xbc01,
+	0x1b76: 0xbab1, 0x1b77: 0x1099, 0x1b78: 0x10b1, 0x1b79: 0x10c9, 0x1b7a: 0xbac9, 0x1b7b: 0xbae1,
+	0x1b7c: 0xbaf9, 0x1b7d: 0x1429, 0x1b7e: 0x1a31, 0x1b7f: 0xbb11,
+	// Block 0x6e, offset 0x1b80
+	0x1b80: 0xbb29, 0x1b81: 0xbb41, 0x1b82: 0xbb59, 0x1b83: 0xbb71, 0x1b84: 0xbb89, 0x1b85: 0x2109,
+	0x1b86: 0x1111, 0x1b87: 0xbba1, 0x1b88: 0xbba1, 0x1b89: 0xbbb9, 0x1b8a: 0xbbd1, 0x1b8b: 0x10e1,
+	0x1b8c: 0x10f9, 0x1b8d: 0xbbe9, 0x1b8e: 0x2079, 0x1b8f: 0xbc21, 0x1b90: 0xbac9, 0x1b91: 0x1429,
+	0x1b92: 0xbb11, 0x1b93: 0x10e1, 0x1b94: 0x1111, 0x1b95: 0x2109, 0x1b96: 0xbab1, 0x1b97: 0x1099,
+	0x1b98: 0x10b1, 0x1b99: 0x10c9, 0x1b9a: 0xbac9, 0x1b9b: 0xbae1, 0x1b9c: 0xbaf9, 0x1b9d: 0x1429,
+	0x1b9e: 0x1a31, 0x1b9f: 0xbb11, 0x1ba0: 0xbb29, 0x1ba1: 0xbb41, 0x1ba2: 0xbb59, 0x1ba3: 0xbb71,
+	0x1ba4: 0xbb89, 0x1ba5: 0x2109, 0x1ba6: 0x1111, 0x1ba7: 0x1429, 0x1ba8: 0xbba1, 0x1ba9: 0xbbb9,
+	0x1baa: 0xbbd1, 0x1bab: 0x10e1, 0x1bac: 0x10f9, 0x1bad: 0xbbe9, 0x1bae: 0x2079, 0x1baf: 0xbc01,
+	0x1bb0: 0xbab1, 0x1bb1: 0x1099, 0x1bb2: 0x10b1, 0x1bb3: 0x10c9, 0x1bb4: 0xbac9, 0x1bb5: 0xbae1,
+	0x1bb6: 0xbaf9, 0x1bb7: 0x1429, 0x1bb8: 0x1a31, 0x1bb9: 0xbb11, 0x1bba: 0xbb29, 0x1bbb: 0xbb41,
+	0x1bbc: 0xbb59, 0x1bbd: 0xbb71, 0x1bbe: 0xbb89, 0x1bbf: 0x2109,
+	// Block 0x6f, offset 0x1bc0
+	0x1bc0: 0x1111, 0x1bc1: 0xbba1, 0x1bc2: 0xbba1, 0x1bc3: 0xbbb9, 0x1bc4: 0xbbd1, 0x1bc5: 0x10e1,
+	0x1bc6: 0x10f9, 0x1bc7: 0xbbe9, 0x1bc8: 0x2079, 0x1bc9: 0xbc21, 0x1bca: 0xbac9, 0x1bcb: 0x1429,
+	0x1bcc: 0xbb11, 0x1bcd: 0x10e1, 0x1bce: 0x1111, 0x1bcf: 0x2109, 0x1bd0: 0xbab1, 0x1bd1: 0x1099,
+	0x1bd2: 0x10b1, 0x1bd3: 0x10c9, 0x1bd4: 0xbac9, 0x1bd5: 0xbae1, 0x1bd6: 0xbaf9, 0x1bd7: 0x1429,
+	0x1bd8: 0x1a31, 0x1bd9: 0xbb11, 0x1bda: 0xbb29, 0x1bdb: 0xbb41, 0x1bdc: 0xbb59, 0x1bdd: 0xbb71,
+	0x1bde: 0xbb89, 0x1bdf: 0x2109, 0x1be0: 0x1111, 0x1be1: 0x1429, 0x1be2: 0xbba1, 0x1be3: 0xbbb9,
+	0x1be4: 0xbbd1, 0x1be5: 0x10e1, 0x1be6: 0x10f9, 0x1be7: 0xbbe9, 0x1be8: 0x2079, 0x1be9: 0xbc01,
+	0x1bea: 0xbab1, 0x1beb: 0x1099, 0x1bec: 0x10b1, 0x1bed: 0x10c9, 0x1bee: 0xbac9, 0x1bef: 0xbae1,
+	0x1bf0: 0xbaf9, 0x1bf1: 0x1429, 0x1bf2: 0x1a31, 0x1bf3: 0xbb11, 0x1bf4: 0xbb29, 0x1bf5: 0xbb41,
+	0x1bf6: 0xbb59, 0x1bf7: 0xbb71, 0x1bf8: 0xbb89, 0x1bf9: 0x2109, 0x1bfa: 0x1111, 0x1bfb: 0xbba1,
+	0x1bfc: 0xbba1, 0x1bfd: 0xbbb9, 0x1bfe: 0xbbd1, 0x1bff: 0x10e1,
+	// Block 0x70, offset 0x1c00
+	0x1c00: 0x10f9, 0x1c01: 0xbbe9, 0x1c02: 0x2079, 0x1c03: 0xbc21, 0x1c04: 0xbac9, 0x1c05: 0x1429,
+	0x1c06: 0xbb11, 0x1c07: 0x10e1, 0x1c08: 0x1111, 0x1c09: 0x2109, 0x1c0a: 0xbc41, 0x1c0b: 0xbc41,
+	0x1c0c: 0x0040, 0x1c0d: 0x0040, 0x1c0e: 0x1f41, 0x1c0f: 0x00c9, 0x1c10: 0x0069, 0x1c11: 0x0079,
+	0x1c12: 0x1f51, 0x1c13: 0x1f61, 0x1c14: 0x1f71, 0x1c15: 0x1f81, 0x1c16: 0x1f91, 0x1c17: 0x1fa1,
+	0x1c18: 0x1f41, 0x1c19: 0x00c9, 0x1c1a: 0x0069, 0x1c1b: 0x0079, 0x1c1c: 0x1f51, 0x1c1d: 0x1f61,
+	0x1c1e: 0x1f71, 0x1c1f: 0x1f81, 0x1c20: 0x1f91, 0x1c21: 0x1fa1, 0x1c22: 0x1f41, 0x1c23: 0x00c9,
+	0x1c24: 0x0069, 0x1c25: 0x0079, 0x1c26: 0x1f51, 0x1c27: 0x1f61, 0x1c28: 0x1f71, 0x1c29: 0x1f81,
+	0x1c2a: 0x1f91, 0x1c2b: 0x1fa1, 0x1c2c: 0x1f41, 0x1c2d: 0x00c9, 0x1c2e: 0x0069, 0x1c2f: 0x0079,
+	0x1c30: 0x1f51, 0x1c31: 0x1f61, 0x1c32: 0x1f71, 0x1c33: 0x1f81, 0x1c34: 0x1f91, 0x1c35: 0x1fa1,
+	0x1c36: 0x1f41, 0x1c37: 0x00c9, 0x1c38: 0x0069, 0x1c39: 0x0079, 0x1c3a: 0x1f51, 0x1c3b: 0x1f61,
+	0x1c3c: 0x1f71, 0x1c3d: 0x1f81, 0x1c3e: 0x1f91, 0x1c3f: 0x1fa1,
+	// Block 0x71, offset 0x1c40
+	0x1c40: 0xe115, 0x1c41: 0xe115, 0x1c42: 0xe135, 0x1c43: 0xe135, 0x1c44: 0xe115, 0x1c45: 0xe115,
+	0x1c46: 0xe175, 0x1c47: 0xe175, 0x1c48: 0xe115, 0x1c49: 0xe115, 0x1c4a: 0xe135, 0x1c4b: 0xe135,
+	0x1c4c: 0xe115, 0x1c4d: 0xe115, 0x1c4e: 0xe1f5, 0x1c4f: 0xe1f5, 0x1c50: 0xe115, 0x1c51: 0xe115,
+	0x1c52: 0xe135, 0x1c53: 0xe135, 0x1c54: 0xe115, 0x1c55: 0xe115, 0x1c56: 0xe175, 0x1c57: 0xe175,
+	0x1c58: 0xe115, 0x1c59: 0xe115, 0x1c5a: 0xe135, 0x1c5b: 0xe135, 0x1c5c: 0xe115, 0x1c5d: 0xe115,
+	0x1c5e: 0x8b05, 0x1c5f: 0x8b05, 0x1c60: 0x04b5, 0x1c61: 0x04b5, 0x1c62: 0x0a08, 0x1c63: 0x0a08,
+	0x1c64: 0x0a08, 0x1c65: 0x0a08, 0x1c66: 0x0a08, 0x1c67: 0x0a08, 0x1c68: 0x0a08, 0x1c69: 0x0a08,
+	0x1c6a: 0x0a08, 0x1c6b: 0x0a08, 0x1c6c: 0x0a08, 0x1c6d: 0x0a08, 0x1c6e: 0x0a08, 0x1c6f: 0x0a08,
+	0x1c70: 0x0a08, 0x1c71: 0x0a08, 0x1c72: 0x0a08, 0x1c73: 0x0a08, 0x1c74: 0x0a08, 0x1c75: 0x0a08,
+	0x1c76: 0x0a08, 0x1c77: 0x0a08, 0x1c78: 0x0a08, 0x1c79: 0x0a08, 0x1c7a: 0x0a08, 0x1c7b: 0x0a08,
+	0x1c7c: 0x0a08, 0x1c7d: 0x0a08, 0x1c7e: 0x0a08, 0x1c7f: 0x0a08,
+	// Block 0x72, offset 0x1c80
+	0x1c80: 0xb189, 0x1c81: 0xb1a1, 0x1c82: 0xb201, 0x1c83: 0xb249, 0x1c84: 0x0040, 0x1c85: 0xb411,
+	0x1c86: 0xb291, 0x1c87: 0xb219, 0x1c88: 0xb309, 0x1c89: 0xb429, 0x1c8a: 0xb399, 0x1c8b: 0xb3b1,
+	0x1c8c: 0xb3c9, 0x1c8d: 0xb3e1, 0x1c8e: 0xb2a9, 0x1c8f: 0xb339, 0x1c90: 0xb369, 0x1c91: 0xb2d9,
+	0x1c92: 0xb381, 0x1c93: 0xb279, 0x1c94: 0xb2c1, 0x1c95: 0xb1d1, 0x1c96: 0xb1e9, 0x1c97: 0xb231,
+	0x1c98: 0xb261, 0x1c99: 0xb2f1, 0x1c9a: 0xb321, 0x1c9b: 0xb351, 0x1c9c: 0xbc59, 0x1c9d: 0x7949,
+	0x1c9e: 0xbc71, 0x1c9f: 0xbc89, 0x1ca0: 0x0040, 0x1ca1: 0xb1a1, 0x1ca2: 0xb201, 0x1ca3: 0x0040,
+	0x1ca4: 0xb3f9, 0x1ca5: 0x0040, 0x1ca6: 0x0040, 0x1ca7: 0xb219, 0x1ca8: 0x0040, 0x1ca9: 0xb429,
+	0x1caa: 0xb399, 0x1cab: 0xb3b1, 0x1cac: 0xb3c9, 0x1cad: 0xb3e1, 0x1cae: 0xb2a9, 0x1caf: 0xb339,
+	0x1cb0: 0xb369, 0x1cb1: 0xb2d9, 0x1cb2: 0xb381, 0x1cb3: 0x0040, 0x1cb4: 0xb2c1, 0x1cb5: 0xb1d1,
+	0x1cb6: 0xb1e9, 0x1cb7: 0xb231, 0x1cb8: 0x0040, 0x1cb9: 0xb2f1, 0x1cba: 0x0040, 0x1cbb: 0xb351,
+	0x1cbc: 0x0040, 0x1cbd: 0x0040, 0x1cbe: 0x0040, 0x1cbf: 0x0040,
+	// Block 0x73, offset 0x1cc0
+	0x1cc0: 0x0040, 0x1cc1: 0x0040, 0x1cc2: 0xb201, 0x1cc3: 0x0040, 0x1cc4: 0x0040, 0x1cc5: 0x0040,
+	0x1cc6: 0x0040, 0x1cc7: 0xb219, 0x1cc8: 0x0040, 0x1cc9: 0xb429, 0x1cca: 0x0040, 0x1ccb: 0xb3b1,
+	0x1ccc: 0x0040, 0x1ccd: 0xb3e1, 0x1cce: 0xb2a9, 0x1ccf: 0xb339, 0x1cd0: 0x0040, 0x1cd1: 0xb2d9,
+	0x1cd2: 0xb381, 0x1cd3: 0x0040, 0x1cd4: 0xb2c1, 0x1cd5: 0x0040, 0x1cd6: 0x0040, 0x1cd7: 0xb231,
+	0x1cd8: 0x0040, 0x1cd9: 0xb2f1, 0x1cda: 0x0040, 0x1cdb: 0xb351, 0x1cdc: 0x0040, 0x1cdd: 0x7949,
+	0x1cde: 0x0040, 0x1cdf: 0xbc89, 0x1ce0: 0x0040, 0x1ce1: 0xb1a1, 0x1ce2: 0xb201, 0x1ce3: 0x0040,
+	0x1ce4: 0xb3f9, 0x1ce5: 0x0040, 0x1ce6: 0x0040, 0x1ce7: 0xb219, 0x1ce8: 0xb309, 0x1ce9: 0xb429,
+	0x1cea: 0xb399, 0x1ceb: 0x0040, 0x1cec: 0xb3c9, 0x1ced: 0xb3e1, 0x1cee: 0xb2a9, 0x1cef: 0xb339,
+	0x1cf0: 0xb369, 0x1cf1: 0xb2d9, 0x1cf2: 0xb381, 0x1cf3: 0x0040, 0x1cf4: 0xb2c1, 0x1cf5: 0xb1d1,
+	0x1cf6: 0xb1e9, 0x1cf7: 0xb231, 0x1cf8: 0x0040, 0x1cf9: 0xb2f1, 0x1cfa: 0xb321, 0x1cfb: 0xb351,
+	0x1cfc: 0xbc59, 0x1cfd: 0x0040, 0x1cfe: 0xbc71, 0x1cff: 0x0040,
+	// Block 0x74, offset 0x1d00
+	0x1d00: 0xb189, 0x1d01: 0xb1a1, 0x1d02: 0xb201, 0x1d03: 0xb249, 0x1d04: 0xb3f9, 0x1d05: 0xb411,
+	0x1d06: 0xb291, 0x1d07: 0xb219, 0x1d08: 0xb309, 0x1d09: 0xb429, 0x1d0a: 0x0040, 0x1d0b: 0xb3b1,
+	0x1d0c: 0xb3c9, 0x1d0d: 0xb3e1, 0x1d0e: 0xb2a9, 0x1d0f: 0xb339, 0x1d10: 0xb369, 0x1d11: 0xb2d9,
+	0x1d12: 0xb381, 0x1d13: 0xb279, 0x1d14: 0xb2c1, 0x1d15: 0xb1d1, 0x1d16: 0xb1e9, 0x1d17: 0xb231,
+	0x1d18: 0xb261, 0x1d19: 0xb2f1, 0x1d1a: 0xb321, 0x1d1b: 0xb351, 0x1d1c: 0x0040, 0x1d1d: 0x0040,
+	0x1d1e: 0x0040, 0x1d1f: 0x0040, 0x1d20: 0x0040, 0x1d21: 0xb1a1, 0x1d22: 0xb201, 0x1d23: 0xb249,
+	0x1d24: 0x0040, 0x1d25: 0xb411, 0x1d26: 0xb291, 0x1d27: 0xb219, 0x1d28: 0xb309, 0x1d29: 0xb429,
+	0x1d2a: 0x0040, 0x1d2b: 0xb3b1, 0x1d2c: 0xb3c9, 0x1d2d: 0xb3e1, 0x1d2e: 0xb2a9, 0x1d2f: 0xb339,
+	0x1d30: 0xb369, 0x1d31: 0xb2d9, 0x1d32: 0xb381, 0x1d33: 0xb279, 0x1d34: 0xb2c1, 0x1d35: 0xb1d1,
+	0x1d36: 0xb1e9, 0x1d37: 0xb231, 0x1d38: 0xb261, 0x1d39: 0xb2f1, 0x1d3a: 0xb321, 0x1d3b: 0xb351,
+	0x1d3c: 0x0040, 0x1d3d: 0x0040, 0x1d3e: 0x0040, 0x1d3f: 0x0040,
+	// Block 0x75, offset 0x1d40
+	0x1d40: 0x0040, 0x1d41: 0xbca2, 0x1d42: 0xbcba, 0x1d43: 0xbcd2, 0x1d44: 0xbcea, 0x1d45: 0xbd02,
+	0x1d46: 0xbd1a, 0x1d47: 0xbd32, 0x1d48: 0xbd4a, 0x1d49: 0xbd62, 0x1d4a: 0xbd7a, 0x1d4b: 0x0018,
+	0x1d4c: 0x0018, 0x1d4d: 0x0040, 0x1d4e: 0x0040, 0x1d4f: 0x0040, 0x1d50: 0xbd92, 0x1d51: 0xbdb2,
+	0x1d52: 0xbdd2, 0x1d53: 0xbdf2, 0x1d54: 0xbe12, 0x1d55: 0xbe32, 0x1d56: 0xbe52, 0x1d57: 0xbe72,
+	0x1d58: 0xbe92, 0x1d59: 0xbeb2, 0x1d5a: 0xbed2, 0x1d5b: 0xbef2, 0x1d5c: 0xbf12, 0x1d5d: 0xbf32,
+	0x1d5e: 0xbf52, 0x1d5f: 0xbf72, 0x1d60: 0xbf92, 0x1d61: 0xbfb2, 0x1d62: 0xbfd2, 0x1d63: 0xbff2,
+	0x1d64: 0xc012, 0x1d65: 0xc032, 0x1d66: 0xc052, 0x1d67: 0xc072, 0x1d68: 0xc092, 0x1d69: 0xc0b2,
+	0x1d6a: 0xc0d1, 0x1d6b: 0x1159, 0x1d6c: 0x0269, 0x1d6d: 0x6671, 0x1d6e: 0xc111, 0x1d6f: 0x0040,
+	0x1d70: 0x0039, 0x1d71: 0x0ee9, 0x1d72: 0x1159, 0x1d73: 0x0ef9, 0x1d74: 0x0f09, 0x1d75: 0x1199,
+	0x1d76: 0x0f31, 0x1d77: 0x0249, 0x1d78: 0x0f41, 0x1d79: 0x0259, 0x1d7a: 0x0f51, 0x1d7b: 0x0359,
+	0x1d7c: 0x0f61, 0x1d7d: 0x0f71, 0x1d7e: 0x00d9, 0x1d7f: 0x0f99,
+	// Block 0x76, offset 0x1d80
+	0x1d80: 0x2039, 0x1d81: 0x0269, 0x1d82: 0x01d9, 0x1d83: 0x0fa9, 0x1d84: 0x0fb9, 0x1d85: 0x1089,
+	0x1d86: 0x0279, 0x1d87: 0x0369, 0x1d88: 0x0289, 0x1d89: 0x13d1, 0x1d8a: 0xc129, 0x1d8b: 0x65b1,
+	0x1d8c: 0xc141, 0x1d8d: 0x1441, 0x1d8e: 0xc159, 0x1d8f: 0xc179, 0x1d90: 0x0018, 0x1d91: 0x0018,
+	0x1d92: 0x0018, 0x1d93: 0x0018, 0x1d94: 0x0018, 0x1d95: 0x0018, 0x1d96: 0x0018, 0x1d97: 0x0018,
+	0x1d98: 0x0018, 0x1d99: 0x0018, 0x1d9a: 0x0018, 0x1d9b: 0x0018, 0x1d9c: 0x0018, 0x1d9d: 0x0018,
+	0x1d9e: 0x0018, 0x1d9f: 0x0018, 0x1da0: 0x0018, 0x1da1: 0x0018, 0x1da2: 0x0018, 0x1da3: 0x0018,
+	0x1da4: 0x0018, 0x1da5: 0x0018, 0x1da6: 0x0018, 0x1da7: 0x0018, 0x1da8: 0x0018, 0x1da9: 0x0018,
+	0x1daa: 0xc191, 0x1dab: 0xc1a9, 0x1dac: 0x0040, 0x1dad: 0x0040, 0x1dae: 0x0040, 0x1daf: 0x0040,
+	0x1db0: 0x0018, 0x1db1: 0x0018, 0x1db2: 0x0018, 0x1db3: 0x0018, 0x1db4: 0x0018, 0x1db5: 0x0018,
+	0x1db6: 0x0018, 0x1db7: 0x0018, 0x1db8: 0x0018, 0x1db9: 0x0018, 0x1dba: 0x0018, 0x1dbb: 0x0018,
+	0x1dbc: 0x0018, 0x1dbd: 0x0018, 0x1dbe: 0x0018, 0x1dbf: 0x0018,
+	// Block 0x77, offset 0x1dc0
+	0x1dc0: 0xc1d9, 0x1dc1: 0xc211, 0x1dc2: 0xc249, 0x1dc3: 0x0040, 0x1dc4: 0x0040, 0x1dc5: 0x0040,
+	0x1dc6: 0x0040, 0x1dc7: 0x0040, 0x1dc8: 0x0040, 0x1dc9: 0x0040, 0x1dca: 0x0040, 0x1dcb: 0x0040,
+	0x1dcc: 0x0040, 0x1dcd: 0x0040, 0x1dce: 0x0040, 0x1dcf: 0x0040, 0x1dd0: 0xc269, 0x1dd1: 0xc289,
+	0x1dd2: 0xc2a9, 0x1dd3: 0xc2c9, 0x1dd4: 0xc2e9, 0x1dd5: 0xc309, 0x1dd6: 0xc329, 0x1dd7: 0xc349,
+	0x1dd8: 0xc369, 0x1dd9: 0xc389, 0x1dda: 0xc3a9, 0x1ddb: 0xc3c9, 0x1ddc: 0xc3e9, 0x1ddd: 0xc409,
+	0x1dde: 0xc429, 0x1ddf: 0xc449, 0x1de0: 0xc469, 0x1de1: 0xc489, 0x1de2: 0xc4a9, 0x1de3: 0xc4c9,
+	0x1de4: 0xc4e9, 0x1de5: 0xc509, 0x1de6: 0xc529, 0x1de7: 0xc549, 0x1de8: 0xc569, 0x1de9: 0xc589,
+	0x1dea: 0xc5a9, 0x1deb: 0xc5c9, 0x1dec: 0xc5e9, 0x1ded: 0xc609, 0x1dee: 0xc629, 0x1def: 0xc649,
+	0x1df0: 0xc669, 0x1df1: 0xc689, 0x1df2: 0xc6a9, 0x1df3: 0xc6c9, 0x1df4: 0xc6e9, 0x1df5: 0xc709,
+	0x1df6: 0xc729, 0x1df7: 0xc749, 0x1df8: 0xc769, 0x1df9: 0xc789, 0x1dfa: 0xc7a9, 0x1dfb: 0xc7c9,
+	0x1dfc: 0x0040, 0x1dfd: 0x0040, 0x1dfe: 0x0040, 0x1dff: 0x0040,
+	// Block 0x78, offset 0x1e00
+	0x1e00: 0xcaf9, 0x1e01: 0xcb19, 0x1e02: 0xcb39, 0x1e03: 0x8b1d, 0x1e04: 0xcb59, 0x1e05: 0xcb79,
+	0x1e06: 0xcb99, 0x1e07: 0xcbb9, 0x1e08: 0xcbd9, 0x1e09: 0xcbf9, 0x1e0a: 0xcc19, 0x1e0b: 0xcc39,
+	0x1e0c: 0xcc59, 0x1e0d: 0x8b3d, 0x1e0e: 0xcc79, 0x1e0f: 0xcc99, 0x1e10: 0xccb9, 0x1e11: 0xccd9,
+	0x1e12: 0x8b5d, 0x1e13: 0xccf9, 0x1e14: 0xcd19, 0x1e15: 0xc429, 0x1e16: 0x8b7d, 0x1e17: 0xcd39,
+	0x1e18: 0xcd59, 0x1e19: 0xcd79, 0x1e1a: 0xcd99, 0x1e1b: 0xcdb9, 0x1e1c: 0x8b9d, 0x1e1d: 0xcdd9,
+	0x1e1e: 0xcdf9, 0x1e1f: 0xce19, 0x1e20: 0xce39, 0x1e21: 0xce59, 0x1e22: 0xc789, 0x1e23: 0xce79,
+	0x1e24: 0xce99, 0x1e25: 0xceb9, 0x1e26: 0xced9, 0x1e27: 0xcef9, 0x1e28: 0xcf19, 0x1e29: 0xcf39,
+	0x1e2a: 0xcf59, 0x1e2b: 0xcf79, 0x1e2c: 0xcf99, 0x1e2d: 0xcfb9, 0x1e2e: 0xcfd9, 0x1e2f: 0xcff9,
+	0x1e30: 0xd019, 0x1e31: 0xd039, 0x1e32: 0xd039, 0x1e33: 0xd039, 0x1e34: 0x8bbd, 0x1e35: 0xd059,
+	0x1e36: 0xd079, 0x1e37: 0xd099, 0x1e38: 0x8bdd, 0x1e39: 0xd0b9, 0x1e3a: 0xd0d9, 0x1e3b: 0xd0f9,
+	0x1e3c: 0xd119, 0x1e3d: 0xd139, 0x1e3e: 0xd159, 0x1e3f: 0xd179,
+	// Block 0x79, offset 0x1e40
+	0x1e40: 0xd199, 0x1e41: 0xd1b9, 0x1e42: 0xd1d9, 0x1e43: 0xd1f9, 0x1e44: 0xd219, 0x1e45: 0xd239,
+	0x1e46: 0xd239, 0x1e47: 0xd259, 0x1e48: 0xd279, 0x1e49: 0xd299, 0x1e4a: 0xd2b9, 0x1e4b: 0xd2d9,
+	0x1e4c: 0xd2f9, 0x1e4d: 0xd319, 0x1e4e: 0xd339, 0x1e4f: 0xd359, 0x1e50: 0xd379, 0x1e51: 0xd399,
+	0x1e52: 0xd3b9, 0x1e53: 0xd3d9, 0x1e54: 0xd3f9, 0x1e55: 0xd419, 0x1e56: 0xd439, 0x1e57: 0xd459,
+	0x1e58: 0xd479, 0x1e59: 0x8bfd, 0x1e5a: 0xd499, 0x1e5b: 0xd4b9, 0x1e5c: 0xd4d9, 0x1e5d: 0xc309,
+	0x1e5e: 0xd4f9, 0x1e5f: 0xd519, 0x1e60: 0x8c1d, 0x1e61: 0x8c3d, 0x1e62: 0xd539, 0x1e63: 0xd559,
+	0x1e64: 0xd579, 0x1e65: 0xd599, 0x1e66: 0xd5b9, 0x1e67: 0xd5d9, 0x1e68: 0x2040, 0x1e69: 0xd5f9,
+	0x1e6a: 0xd619, 0x1e6b: 0xd619, 0x1e6c: 0x8c5d, 0x1e6d: 0xd639, 0x1e6e: 0xd659, 0x1e6f: 0xd679,
+	0x1e70: 0xd699, 0x1e71: 0x8c7d, 0x1e72: 0xd6b9, 0x1e73: 0xd6d9, 0x1e74: 0x2040, 0x1e75: 0xd6f9,
+	0x1e76: 0xd719, 0x1e77: 0xd739, 0x1e78: 0xd759, 0x1e79: 0xd779, 0x1e7a: 0xd799, 0x1e7b: 0x8c9d,
+	0x1e7c: 0xd7b9, 0x1e7d: 0x8cbd, 0x1e7e: 0xd7d9, 0x1e7f: 0xd7f9,
+	// Block 0x7a, offset 0x1e80
+	0x1e80: 0xd819, 0x1e81: 0xd839, 0x1e82: 0xd859, 0x1e83: 0xd879, 0x1e84: 0xd899, 0x1e85: 0xd8b9,
+	0x1e86: 0xd8d9, 0x1e87: 0xd8f9, 0x1e88: 0xd919, 0x1e89: 0x8cdd, 0x1e8a: 0xd939, 0x1e8b: 0xd959,
+	0x1e8c: 0xd979, 0x1e8d: 0xd999, 0x1e8e: 0xd9b9, 0x1e8f: 0x8cfd, 0x1e90: 0xd9d9, 0x1e91: 0x8d1d,
+	0x1e92: 0x8d3d, 0x1e93: 0xd9f9, 0x1e94: 0xda19, 0x1e95: 0xda19, 0x1e96: 0xda39, 0x1e97: 0x8d5d,
+	0x1e98: 0x8d7d, 0x1e99: 0xda59, 0x1e9a: 0xda79, 0x1e9b: 0xda99, 0x1e9c: 0xdab9, 0x1e9d: 0xdad9,
+	0x1e9e: 0xdaf9, 0x1e9f: 0xdb19, 0x1ea0: 0xdb39, 0x1ea1: 0xdb59, 0x1ea2: 0xdb79, 0x1ea3: 0xdb99,
+	0x1ea4: 0x8d9d, 0x1ea5: 0xdbb9, 0x1ea6: 0xdbd9, 0x1ea7: 0xdbf9, 0x1ea8: 0xdc19, 0x1ea9: 0xdbf9,
+	0x1eaa: 0xdc39, 0x1eab: 0xdc59, 0x1eac: 0xdc79, 0x1ead: 0xdc99, 0x1eae: 0xdcb9, 0x1eaf: 0xdcd9,
+	0x1eb0: 0xdcf9, 0x1eb1: 0xdd19, 0x1eb2: 0xdd39, 0x1eb3: 0xdd59, 0x1eb4: 0xdd79, 0x1eb5: 0xdd99,
+	0x1eb6: 0xddb9, 0x1eb7: 0xddd9, 0x1eb8: 0x8dbd, 0x1eb9: 0xddf9, 0x1eba: 0xde19, 0x1ebb: 0xde39,
+	0x1ebc: 0xde59, 0x1ebd: 0xde79, 0x1ebe: 0x8ddd, 0x1ebf: 0xde99,
+	// Block 0x7b, offset 0x1ec0
+	0x1ec0: 0xe599, 0x1ec1: 0xe5b9, 0x1ec2: 0xe5d9, 0x1ec3: 0xe5f9, 0x1ec4: 0xe619, 0x1ec5: 0xe639,
+	0x1ec6: 0x8efd, 0x1ec7: 0xe659, 0x1ec8: 0xe679, 0x1ec9: 0xe699, 0x1eca: 0xe6b9, 0x1ecb: 0xe6d9,
+	0x1ecc: 0xe6f9, 0x1ecd: 0x8f1d, 0x1ece: 0xe719, 0x1ecf: 0xe739, 0x1ed0: 0x8f3d, 0x1ed1: 0x8f5d,
+	0x1ed2: 0xe759, 0x1ed3: 0xe779, 0x1ed4: 0xe799, 0x1ed5: 0xe7b9, 0x1ed6: 0xe7d9, 0x1ed7: 0xe7f9,
+	0x1ed8: 0xe819, 0x1ed9: 0xe839, 0x1eda: 0xe859, 0x1edb: 0x8f7d, 0x1edc: 0xe879, 0x1edd: 0x8f9d,
+	0x1ede: 0xe899, 0x1edf: 0x2040, 0x1ee0: 0xe8b9, 0x1ee1: 0xe8d9, 0x1ee2: 0xe8f9, 0x1ee3: 0x8fbd,
+	0x1ee4: 0xe919, 0x1ee5: 0xe939, 0x1ee6: 0x8fdd, 0x1ee7: 0x8ffd, 0x1ee8: 0xe959, 0x1ee9: 0xe979,
+	0x1eea: 0xe999, 0x1eeb: 0xe9b9, 0x1eec: 0xe9d9, 0x1eed: 0xe9d9, 0x1eee: 0xe9f9, 0x1eef: 0xea19,
+	0x1ef0: 0xea39, 0x1ef1: 0xea59, 0x1ef2: 0xea79, 0x1ef3: 0xea99, 0x1ef4: 0xeab9, 0x1ef5: 0x901d,
+	0x1ef6: 0xead9, 0x1ef7: 0x903d, 0x1ef8: 0xeaf9, 0x1ef9: 0x905d, 0x1efa: 0xeb19, 0x1efb: 0x907d,
+	0x1efc: 0x909d, 0x1efd: 0x90bd, 0x1efe: 0xeb39, 0x1eff: 0xeb59,
+	// Block 0x7c, offset 0x1f00
+	0x1f00: 0xeb79, 0x1f01: 0x90dd, 0x1f02: 0x90fd, 0x1f03: 0x911d, 0x1f04: 0x913d, 0x1f05: 0xeb99,
+	0x1f06: 0xebb9, 0x1f07: 0xebb9, 0x1f08: 0xebd9, 0x1f09: 0xebf9, 0x1f0a: 0xec19, 0x1f0b: 0xec39,
+	0x1f0c: 0xec59, 0x1f0d: 0x915d, 0x1f0e: 0xec79, 0x1f0f: 0xec99, 0x1f10: 0xecb9, 0x1f11: 0xecd9,
+	0x1f12: 0x917d, 0x1f13: 0xecf9, 0x1f14: 0x919d, 0x1f15: 0x91bd, 0x1f16: 0xed19, 0x1f17: 0xed39,
+	0x1f18: 0xed59, 0x1f19: 0xed79, 0x1f1a: 0xed99, 0x1f1b: 0xedb9, 0x1f1c: 0x91dd, 0x1f1d: 0x91fd,
+	0x1f1e: 0x921d, 0x1f1f: 0x2040, 0x1f20: 0xedd9, 0x1f21: 0x923d, 0x1f22: 0xedf9, 0x1f23: 0xee19,
+	0x1f24: 0xee39, 0x1f25: 0x925d, 0x1f26: 0xee59, 0x1f27: 0xee79, 0x1f28: 0xee99, 0x1f29: 0xeeb9,
+	0x1f2a: 0xeed9, 0x1f2b: 0x927d, 0x1f2c: 0xeef9, 0x1f2d: 0xef19, 0x1f2e: 0xef39, 0x1f2f: 0xef59,
+	0x1f30: 0xef79, 0x1f31: 0xef99, 0x1f32: 0x929d, 0x1f33: 0x92bd, 0x1f34: 0xefb9, 0x1f35: 0x92dd,
+	0x1f36: 0xefd9, 0x1f37: 0x92fd, 0x1f38: 0xeff9, 0x1f39: 0xf019, 0x1f3a: 0xf039, 0x1f3b: 0x931d,
+	0x1f3c: 0x933d, 0x1f3d: 0xf059, 0x1f3e: 0x935d, 0x1f3f: 0xf079,
+	// Block 0x7d, offset 0x1f40
+	0x1f40: 0xf6b9, 0x1f41: 0xf6d9, 0x1f42: 0xf6f9, 0x1f43: 0xf719, 0x1f44: 0xf739, 0x1f45: 0x951d,
+	0x1f46: 0xf759, 0x1f47: 0xf779, 0x1f48: 0xf799, 0x1f49: 0xf7b9, 0x1f4a: 0xf7d9, 0x1f4b: 0x953d,
+	0x1f4c: 0x955d, 0x1f4d: 0xf7f9, 0x1f4e: 0xf819, 0x1f4f: 0xf839, 0x1f50: 0xf859, 0x1f51: 0xf879,
+	0x1f52: 0xf899, 0x1f53: 0x957d, 0x1f54: 0xf8b9, 0x1f55: 0xf8d9, 0x1f56: 0xf8f9, 0x1f57: 0xf919,
+	0x1f58: 0x959d, 0x1f59: 0x95bd, 0x1f5a: 0xf939, 0x1f5b: 0xf959, 0x1f5c: 0xf979, 0x1f5d: 0x95dd,
+	0x1f5e: 0xf999, 0x1f5f: 0xf9b9, 0x1f60: 0x6815, 0x1f61: 0x95fd, 0x1f62: 0xf9d9, 0x1f63: 0xf9f9,
+	0x1f64: 0xfa19, 0x1f65: 0x961d, 0x1f66: 0xfa39, 0x1f67: 0xfa59, 0x1f68: 0xfa79, 0x1f69: 0xfa99,
+	0x1f6a: 0xfab9, 0x1f6b: 0xfad9, 0x1f6c: 0xfaf9, 0x1f6d: 0x963d, 0x1f6e: 0xfb19, 0x1f6f: 0xfb39,
+	0x1f70: 0xfb59, 0x1f71: 0x965d, 0x1f72: 0xfb79, 0x1f73: 0xfb99, 0x1f74: 0xfbb9, 0x1f75: 0xfbd9,
+	0x1f76: 0x7b35, 0x1f77: 0x967d, 0x1f78: 0xfbf9, 0x1f79: 0xfc19, 0x1f7a: 0xfc39, 0x1f7b: 0x969d,
+	0x1f7c: 0xfc59, 0x1f7d: 0x96bd, 0x1f7e: 0xfc79, 0x1f7f: 0xfc79,
+	// Block 0x7e, offset 0x1f80
+	0x1f80: 0xfc99, 0x1f81: 0x96dd, 0x1f82: 0xfcb9, 0x1f83: 0xfcd9, 0x1f84: 0xfcf9, 0x1f85: 0xfd19,
+	0x1f86: 0xfd39, 0x1f87: 0xfd59, 0x1f88: 0xfd79, 0x1f89: 0x96fd, 0x1f8a: 0xfd99, 0x1f8b: 0xfdb9,
+	0x1f8c: 0xfdd9, 0x1f8d: 0xfdf9, 0x1f8e: 0xfe19, 0x1f8f: 0xfe39, 0x1f90: 0x971d, 0x1f91: 0xfe59,
+	0x1f92: 0x973d, 0x1f93: 0x975d, 0x1f94: 0x977d, 0x1f95: 0xfe79, 0x1f96: 0xfe99, 0x1f97: 0xfeb9,
+	0x1f98: 0xfed9, 0x1f99: 0xfef9, 0x1f9a: 0xff19, 0x1f9b: 0xff39, 0x1f9c: 0xff59, 0x1f9d: 0x979d,
+	0x1f9e: 0x0040, 0x1f9f: 0x0040, 0x1fa0: 0x0040, 0x1fa1: 0x0040, 0x1fa2: 0x0040, 0x1fa3: 0x0040,
+	0x1fa4: 0x0040, 0x1fa5: 0x0040, 0x1fa6: 0x0040, 0x1fa7: 0x0040, 0x1fa8: 0x0040, 0x1fa9: 0x0040,
+	0x1faa: 0x0040, 0x1fab: 0x0040, 0x1fac: 0x0040, 0x1fad: 0x0040, 0x1fae: 0x0040, 0x1faf: 0x0040,
+	0x1fb0: 0x0040, 0x1fb1: 0x0040, 0x1fb2: 0x0040, 0x1fb3: 0x0040, 0x1fb4: 0x0040, 0x1fb5: 0x0040,
+	0x1fb6: 0x0040, 0x1fb7: 0x0040, 0x1fb8: 0x0040, 0x1fb9: 0x0040, 0x1fba: 0x0040, 0x1fbb: 0x0040,
+	0x1fbc: 0x0040, 0x1fbd: 0x0040, 0x1fbe: 0x0040, 0x1fbf: 0x0040,
+}
+
+// idnaIndex: 36 blocks, 2304 entries, 4608 bytes
+// Block 0 is the zero block.
+var idnaIndex = [2304]uint16{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x01, 0xc3: 0x7d, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x04, 0xc7: 0x05,
+	0xc8: 0x06, 0xc9: 0x7e, 0xca: 0x7f, 0xcb: 0x07, 0xcc: 0x80, 0xcd: 0x08, 0xce: 0x09, 0xcf: 0x0a,
+	0xd0: 0x81, 0xd1: 0x0b, 0xd2: 0x0c, 0xd3: 0x0d, 0xd4: 0x0e, 0xd5: 0x82, 0xd6: 0x83, 0xd7: 0x84,
+	0xd8: 0x0f, 0xd9: 0x10, 0xda: 0x85, 0xdb: 0x11, 0xdc: 0x12, 0xdd: 0x86, 0xde: 0x87, 0xdf: 0x88,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06, 0xe5: 0x07, 0xe6: 0x07, 0xe7: 0x07,
+	0xe8: 0x07, 0xe9: 0x08, 0xea: 0x09, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x0a, 0xee: 0x0b, 0xef: 0x0c,
+	0xf0: 0x1d, 0xf1: 0x1e, 0xf2: 0x1e, 0xf3: 0x20, 0xf4: 0x21,
+	// Block 0x4, offset 0x100
+	0x120: 0x89, 0x121: 0x13, 0x122: 0x8a, 0x123: 0x8b, 0x124: 0x8c, 0x125: 0x14, 0x126: 0x15, 0x127: 0x16,
+	0x128: 0x17, 0x129: 0x18, 0x12a: 0x19, 0x12b: 0x1a, 0x12c: 0x1b, 0x12d: 0x1c, 0x12e: 0x1d, 0x12f: 0x8d,
+	0x130: 0x8e, 0x131: 0x1e, 0x132: 0x1f, 0x133: 0x20, 0x134: 0x8f, 0x135: 0x21, 0x136: 0x90, 0x137: 0x91,
+	0x138: 0x92, 0x139: 0x93, 0x13a: 0x22, 0x13b: 0x94, 0x13c: 0x95, 0x13d: 0x23, 0x13e: 0x24, 0x13f: 0x96,
+	// Block 0x5, offset 0x140
+	0x140: 0x97, 0x141: 0x98, 0x142: 0x99, 0x143: 0x9a, 0x144: 0x9b, 0x145: 0x9c, 0x146: 0x9d, 0x147: 0x9e,
+	0x148: 0x9f, 0x149: 0xa0, 0x14a: 0xa1, 0x14b: 0xa2, 0x14c: 0xa3, 0x14d: 0xa4, 0x14e: 0xa5, 0x14f: 0xa6,
+	0x150: 0xa7, 0x151: 0x9f, 0x152: 0x9f, 0x153: 0x9f, 0x154: 0x9f, 0x155: 0x9f, 0x156: 0x9f, 0x157: 0x9f,
+	0x158: 0x9f, 0x159: 0xa8, 0x15a: 0xa9, 0x15b: 0xaa, 0x15c: 0xab, 0x15d: 0xac, 0x15e: 0xad, 0x15f: 0xae,
+	0x160: 0xaf, 0x161: 0xb0, 0x162: 0xb1, 0x163: 0xb2, 0x164: 0xb3, 0x165: 0xb4, 0x166: 0xb5, 0x167: 0xb6,
+	0x168: 0xb7, 0x169: 0xb8, 0x16a: 0xb9, 0x16b: 0xba, 0x16c: 0xbb, 0x16d: 0xbc, 0x16e: 0xbd, 0x16f: 0xbe,
+	0x170: 0xbf, 0x171: 0xc0, 0x172: 0xc1, 0x173: 0xc2, 0x174: 0x25, 0x175: 0x26, 0x176: 0x27, 0x177: 0xc3,
+	0x178: 0x28, 0x179: 0x28, 0x17a: 0x29, 0x17b: 0x28, 0x17c: 0xc4, 0x17d: 0x2a, 0x17e: 0x2b, 0x17f: 0x2c,
+	// Block 0x6, offset 0x180
+	0x180: 0x2d, 0x181: 0x2e, 0x182: 0x2f, 0x183: 0xc5, 0x184: 0x30, 0x185: 0x31, 0x186: 0xc6, 0x187: 0x9b,
+	0x188: 0xc7, 0x189: 0xc8, 0x18a: 0x9b, 0x18b: 0x9b, 0x18c: 0xc9, 0x18d: 0x9b, 0x18e: 0x9b, 0x18f: 0x9b,
+	0x190: 0xca, 0x191: 0x32, 0x192: 0x33, 0x193: 0x34, 0x194: 0x9b, 0x195: 0x9b, 0x196: 0x9b, 0x197: 0x9b,
+	0x198: 0x9b, 0x199: 0x9b, 0x19a: 0x9b, 0x19b: 0x9b, 0x19c: 0x9b, 0x19d: 0x9b, 0x19e: 0x9b, 0x19f: 0x9b,
+	0x1a0: 0x9b, 0x1a1: 0x9b, 0x1a2: 0x9b, 0x1a3: 0x9b, 0x1a4: 0x9b, 0x1a5: 0x9b, 0x1a6: 0x9b, 0x1a7: 0x9b,
+	0x1a8: 0xcb, 0x1a9: 0xcc, 0x1aa: 0x9b, 0x1ab: 0xcd, 0x1ac: 0x9b, 0x1ad: 0xce, 0x1ae: 0xcf, 0x1af: 0xd0,
+	0x1b0: 0xd1, 0x1b1: 0x35, 0x1b2: 0x28, 0x1b3: 0x36, 0x1b4: 0xd2, 0x1b5: 0xd3, 0x1b6: 0xd4, 0x1b7: 0xd5,
+	0x1b8: 0xd6, 0x1b9: 0xd7, 0x1ba: 0xd8, 0x1bb: 0xd9, 0x1bc: 0xda, 0x1bd: 0xdb, 0x1be: 0xdc, 0x1bf: 0x37,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x38, 0x1c1: 0xdd, 0x1c2: 0xde, 0x1c3: 0xdf, 0x1c4: 0xe0, 0x1c5: 0x39, 0x1c6: 0x3a, 0x1c7: 0xe1,
+	0x1c8: 0xe2, 0x1c9: 0x3b, 0x1ca: 0x3c, 0x1cb: 0x3d, 0x1cc: 0x3e, 0x1cd: 0x3f, 0x1ce: 0x40, 0x1cf: 0x41,
+	0x1d0: 0x9f, 0x1d1: 0x9f, 0x1d2: 0x9f, 0x1d3: 0x9f, 0x1d4: 0x9f, 0x1d5: 0x9f, 0x1d6: 0x9f, 0x1d7: 0x9f,
+	0x1d8: 0x9f, 0x1d9: 0x9f, 0x1da: 0x9f, 0x1db: 0x9f, 0x1dc: 0x9f, 0x1dd: 0x9f, 0x1de: 0x9f, 0x1df: 0x9f,
+	0x1e0: 0x9f, 0x1e1: 0x9f, 0x1e2: 0x9f, 0x1e3: 0x9f, 0x1e4: 0x9f, 0x1e5: 0x9f, 0x1e6: 0x9f, 0x1e7: 0x9f,
+	0x1e8: 0x9f, 0x1e9: 0x9f, 0x1ea: 0x9f, 0x1eb: 0x9f, 0x1ec: 0x9f, 0x1ed: 0x9f, 0x1ee: 0x9f, 0x1ef: 0x9f,
+	0x1f0: 0x9f, 0x1f1: 0x9f, 0x1f2: 0x9f, 0x1f3: 0x9f, 0x1f4: 0x9f, 0x1f5: 0x9f, 0x1f6: 0x9f, 0x1f7: 0x9f,
+	0x1f8: 0x9f, 0x1f9: 0x9f, 0x1fa: 0x9f, 0x1fb: 0x9f, 0x1fc: 0x9f, 0x1fd: 0x9f, 0x1fe: 0x9f, 0x1ff: 0x9f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9f, 0x201: 0x9f, 0x202: 0x9f, 0x203: 0x9f, 0x204: 0x9f, 0x205: 0x9f, 0x206: 0x9f, 0x207: 0x9f,
+	0x208: 0x9f, 0x209: 0x9f, 0x20a: 0x9f, 0x20b: 0x9f, 0x20c: 0x9f, 0x20d: 0x9f, 0x20e: 0x9f, 0x20f: 0x9f,
+	0x210: 0x9f, 0x211: 0x9f, 0x212: 0x9f, 0x213: 0x9f, 0x214: 0x9f, 0x215: 0x9f, 0x216: 0x9f, 0x217: 0x9f,
+	0x218: 0x9f, 0x219: 0x9f, 0x21a: 0x9f, 0x21b: 0x9f, 0x21c: 0x9f, 0x21d: 0x9f, 0x21e: 0x9f, 0x21f: 0x9f,
+	0x220: 0x9f, 0x221: 0x9f, 0x222: 0x9f, 0x223: 0x9f, 0x224: 0x9f, 0x225: 0x9f, 0x226: 0x9f, 0x227: 0x9f,
+	0x228: 0x9f, 0x229: 0x9f, 0x22a: 0x9f, 0x22b: 0x9f, 0x22c: 0x9f, 0x22d: 0x9f, 0x22e: 0x9f, 0x22f: 0x9f,
+	0x230: 0x9f, 0x231: 0x9f, 0x232: 0x9f, 0x233: 0x9f, 0x234: 0x9f, 0x235: 0x9f, 0x236: 0xb2, 0x237: 0x9b,
+	0x238: 0x9f, 0x239: 0x9f, 0x23a: 0x9f, 0x23b: 0x9f, 0x23c: 0x9f, 0x23d: 0x9f, 0x23e: 0x9f, 0x23f: 0x9f,
+	// Block 0x9, offset 0x240
+	0x240: 0x9f, 0x241: 0x9f, 0x242: 0x9f, 0x243: 0x9f, 0x244: 0x9f, 0x245: 0x9f, 0x246: 0x9f, 0x247: 0x9f,
+	0x248: 0x9f, 0x249: 0x9f, 0x24a: 0x9f, 0x24b: 0x9f, 0x24c: 0x9f, 0x24d: 0x9f, 0x24e: 0x9f, 0x24f: 0x9f,
+	0x250: 0x9f, 0x251: 0x9f, 0x252: 0x9f, 0x253: 0x9f, 0x254: 0x9f, 0x255: 0x9f, 0x256: 0x9f, 0x257: 0x9f,
+	0x258: 0x9f, 0x259: 0x9f, 0x25a: 0x9f, 0x25b: 0x9f, 0x25c: 0x9f, 0x25d: 0x9f, 0x25e: 0x9f, 0x25f: 0x9f,
+	0x260: 0x9f, 0x261: 0x9f, 0x262: 0x9f, 0x263: 0x9f, 0x264: 0x9f, 0x265: 0x9f, 0x266: 0x9f, 0x267: 0x9f,
+	0x268: 0x9f, 0x269: 0x9f, 0x26a: 0x9f, 0x26b: 0x9f, 0x26c: 0x9f, 0x26d: 0x9f, 0x26e: 0x9f, 0x26f: 0x9f,
+	0x270: 0x9f, 0x271: 0x9f, 0x272: 0x9f, 0x273: 0x9f, 0x274: 0x9f, 0x275: 0x9f, 0x276: 0x9f, 0x277: 0x9f,
+	0x278: 0x9f, 0x279: 0x9f, 0x27a: 0x9f, 0x27b: 0x9f, 0x27c: 0x9f, 0x27d: 0x9f, 0x27e: 0x9f, 0x27f: 0x9f,
+	// Block 0xa, offset 0x280
+	0x280: 0x9f, 0x281: 0x9f, 0x282: 0x9f, 0x283: 0x9f, 0x284: 0x9f, 0x285: 0x9f, 0x286: 0x9f, 0x287: 0x9f,
+	0x288: 0x9f, 0x289: 0x9f, 0x28a: 0x9f, 0x28b: 0x9f, 0x28c: 0x9f, 0x28d: 0x9f, 0x28e: 0x9f, 0x28f: 0x9f,
+	0x290: 0x9f, 0x291: 0x9f, 0x292: 0x9f, 0x293: 0x9f, 0x294: 0x9f, 0x295: 0x9f, 0x296: 0x9f, 0x297: 0x9f,
+	0x298: 0x9f, 0x299: 0x9f, 0x29a: 0x9f, 0x29b: 0x9f, 0x29c: 0x9f, 0x29d: 0x9f, 0x29e: 0x9f, 0x29f: 0x9f,
+	0x2a0: 0x9f, 0x2a1: 0x9f, 0x2a2: 0x9f, 0x2a3: 0x9f, 0x2a4: 0x9f, 0x2a5: 0x9f, 0x2a6: 0x9f, 0x2a7: 0x9f,
+	0x2a8: 0x9f, 0x2a9: 0x9f, 0x2aa: 0x9f, 0x2ab: 0x9f, 0x2ac: 0x9f, 0x2ad: 0x9f, 0x2ae: 0x9f, 0x2af: 0x9f,
+	0x2b0: 0x9f, 0x2b1: 0x9f, 0x2b2: 0x9f, 0x2b3: 0x9f, 0x2b4: 0x9f, 0x2b5: 0x9f, 0x2b6: 0x9f, 0x2b7: 0x9f,
+	0x2b8: 0x9f, 0x2b9: 0x9f, 0x2ba: 0x9f, 0x2bb: 0x9f, 0x2bc: 0x9f, 0x2bd: 0x9f, 0x2be: 0x9f, 0x2bf: 0xe3,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x9f, 0x2c1: 0x9f, 0x2c2: 0x9f, 0x2c3: 0x9f, 0x2c4: 0x9f, 0x2c5: 0x9f, 0x2c6: 0x9f, 0x2c7: 0x9f,
+	0x2c8: 0x9f, 0x2c9: 0x9f, 0x2ca: 0x9f, 0x2cb: 0x9f, 0x2cc: 0x9f, 0x2cd: 0x9f, 0x2ce: 0x9f, 0x2cf: 0x9f,
+	0x2d0: 0x9f, 0x2d1: 0x9f, 0x2d2: 0xe4, 0x2d3: 0xe5, 0x2d4: 0x9f, 0x2d5: 0x9f, 0x2d6: 0x9f, 0x2d7: 0x9f,
+	0x2d8: 0xe6, 0x2d9: 0x42, 0x2da: 0x43, 0x2db: 0xe7, 0x2dc: 0x44, 0x2dd: 0x45, 0x2de: 0x46, 0x2df: 0xe8,
+	0x2e0: 0xe9, 0x2e1: 0xea, 0x2e2: 0xeb, 0x2e3: 0xec, 0x2e4: 0xed, 0x2e5: 0xee, 0x2e6: 0xef, 0x2e7: 0xf0,
+	0x2e8: 0xf1, 0x2e9: 0xf2, 0x2ea: 0xf3, 0x2eb: 0xf4, 0x2ec: 0xf5, 0x2ed: 0xf6, 0x2ee: 0xf7, 0x2ef: 0xf8,
+	0x2f0: 0x9f, 0x2f1: 0x9f, 0x2f2: 0x9f, 0x2f3: 0x9f, 0x2f4: 0x9f, 0x2f5: 0x9f, 0x2f6: 0x9f, 0x2f7: 0x9f,
+	0x2f8: 0x9f, 0x2f9: 0x9f, 0x2fa: 0x9f, 0x2fb: 0x9f, 0x2fc: 0x9f, 0x2fd: 0x9f, 0x2fe: 0x9f, 0x2ff: 0x9f,
+	// Block 0xc, offset 0x300
+	0x300: 0x9f, 0x301: 0x9f, 0x302: 0x9f, 0x303: 0x9f, 0x304: 0x9f, 0x305: 0x9f, 0x306: 0x9f, 0x307: 0x9f,
+	0x308: 0x9f, 0x309: 0x9f, 0x30a: 0x9f, 0x30b: 0x9f, 0x30c: 0x9f, 0x30d: 0x9f, 0x30e: 0x9f, 0x30f: 0x9f,
+	0x310: 0x9f, 0x311: 0x9f, 0x312: 0x9f, 0x313: 0x9f, 0x314: 0x9f, 0x315: 0x9f, 0x316: 0x9f, 0x317: 0x9f,
+	0x318: 0x9f, 0x319: 0x9f, 0x31a: 0x9f, 0x31b: 0x9f, 0x31c: 0x9f, 0x31d: 0x9f, 0x31e: 0xf9, 0x31f: 0xfa,
+	// Block 0xd, offset 0x340
+	0x340: 0xba, 0x341: 0xba, 0x342: 0xba, 0x343: 0xba, 0x344: 0xba, 0x345: 0xba, 0x346: 0xba, 0x347: 0xba,
+	0x348: 0xba, 0x349: 0xba, 0x34a: 0xba, 0x34b: 0xba, 0x34c: 0xba, 0x34d: 0xba, 0x34e: 0xba, 0x34f: 0xba,
+	0x350: 0xba, 0x351: 0xba, 0x352: 0xba, 0x353: 0xba, 0x354: 0xba, 0x355: 0xba, 0x356: 0xba, 0x357: 0xba,
+	0x358: 0xba, 0x359: 0xba, 0x35a: 0xba, 0x35b: 0xba, 0x35c: 0xba, 0x35d: 0xba, 0x35e: 0xba, 0x35f: 0xba,
+	0x360: 0xba, 0x361: 0xba, 0x362: 0xba, 0x363: 0xba, 0x364: 0xba, 0x365: 0xba, 0x366: 0xba, 0x367: 0xba,
+	0x368: 0xba, 0x369: 0xba, 0x36a: 0xba, 0x36b: 0xba, 0x36c: 0xba, 0x36d: 0xba, 0x36e: 0xba, 0x36f: 0xba,
+	0x370: 0xba, 0x371: 0xba, 0x372: 0xba, 0x373: 0xba, 0x374: 0xba, 0x375: 0xba, 0x376: 0xba, 0x377: 0xba,
+	0x378: 0xba, 0x379: 0xba, 0x37a: 0xba, 0x37b: 0xba, 0x37c: 0xba, 0x37d: 0xba, 0x37e: 0xba, 0x37f: 0xba,
+	// Block 0xe, offset 0x380
+	0x380: 0xba, 0x381: 0xba, 0x382: 0xba, 0x383: 0xba, 0x384: 0xba, 0x385: 0xba, 0x386: 0xba, 0x387: 0xba,
+	0x388: 0xba, 0x389: 0xba, 0x38a: 0xba, 0x38b: 0xba, 0x38c: 0xba, 0x38d: 0xba, 0x38e: 0xba, 0x38f: 0xba,
+	0x390: 0xba, 0x391: 0xba, 0x392: 0xba, 0x393: 0xba, 0x394: 0xba, 0x395: 0xba, 0x396: 0xba, 0x397: 0xba,
+	0x398: 0xba, 0x399: 0xba, 0x39a: 0xba, 0x39b: 0xba, 0x39c: 0xba, 0x39d: 0xba, 0x39e: 0xba, 0x39f: 0xba,
+	0x3a0: 0xba, 0x3a1: 0xba, 0x3a2: 0xba, 0x3a3: 0xba, 0x3a4: 0xfb, 0x3a5: 0xfc, 0x3a6: 0xfd, 0x3a7: 0xfe,
+	0x3a8: 0x47, 0x3a9: 0xff, 0x3aa: 0x100, 0x3ab: 0x48, 0x3ac: 0x49, 0x3ad: 0x4a, 0x3ae: 0x4b, 0x3af: 0x4c,
+	0x3b0: 0x101, 0x3b1: 0x4d, 0x3b2: 0x4e, 0x3b3: 0x4f, 0x3b4: 0x50, 0x3b5: 0x51, 0x3b6: 0x102, 0x3b7: 0x52,
+	0x3b8: 0x53, 0x3b9: 0x54, 0x3ba: 0x55, 0x3bb: 0x56, 0x3bc: 0x57, 0x3bd: 0x58, 0x3be: 0x59, 0x3bf: 0x5a,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x103, 0x3c1: 0x104, 0x3c2: 0x9f, 0x3c3: 0x105, 0x3c4: 0x106, 0x3c5: 0x9b, 0x3c6: 0x107, 0x3c7: 0x108,
+	0x3c8: 0xba, 0x3c9: 0xba, 0x3ca: 0x109, 0x3cb: 0x10a, 0x3cc: 0x10b, 0x3cd: 0x10c, 0x3ce: 0x10d, 0x3cf: 0x10e,
+	0x3d0: 0x10f, 0x3d1: 0x9f, 0x3d2: 0x110, 0x3d3: 0x111, 0x3d4: 0x112, 0x3d5: 0x113, 0x3d6: 0xba, 0x3d7: 0xba,
+	0x3d8: 0x9f, 0x3d9: 0x9f, 0x3da: 0x9f, 0x3db: 0x9f, 0x3dc: 0x114, 0x3dd: 0x115, 0x3de: 0xba, 0x3df: 0xba,
+	0x3e0: 0x116, 0x3e1: 0x117, 0x3e2: 0x118, 0x3e3: 0x119, 0x3e4: 0x11a, 0x3e5: 0xba, 0x3e6: 0x11b, 0x3e7: 0x11c,
+	0x3e8: 0x11d, 0x3e9: 0x11e, 0x3ea: 0x11f, 0x3eb: 0x5b, 0x3ec: 0x120, 0x3ed: 0x121, 0x3ee: 0x5c, 0x3ef: 0xba,
+	0x3f0: 0x122, 0x3f1: 0x123, 0x3f2: 0x124, 0x3f3: 0x125, 0x3f4: 0xba, 0x3f5: 0xba, 0x3f6: 0xba, 0x3f7: 0xba,
+	0x3f8: 0xba, 0x3f9: 0x126, 0x3fa: 0xba, 0x3fb: 0xba, 0x3fc: 0xba, 0x3fd: 0xba, 0x3fe: 0xba, 0x3ff: 0xba,
+	// Block 0x10, offset 0x400
+	0x400: 0x127, 0x401: 0x128, 0x402: 0x129, 0x403: 0x12a, 0x404: 0x12b, 0x405: 0x12c, 0x406: 0x12d, 0x407: 0x12e,
+	0x408: 0x12f, 0x409: 0xba, 0x40a: 0x130, 0x40b: 0x131, 0x40c: 0x5d, 0x40d: 0x5e, 0x40e: 0xba, 0x40f: 0xba,
+	0x410: 0x132, 0x411: 0x133, 0x412: 0x134, 0x413: 0x135, 0x414: 0xba, 0x415: 0xba, 0x416: 0x136, 0x417: 0x137,
+	0x418: 0x138, 0x419: 0x139, 0x41a: 0x13a, 0x41b: 0x13b, 0x41c: 0x13c, 0x41d: 0xba, 0x41e: 0xba, 0x41f: 0xba,
+	0x420: 0xba, 0x421: 0xba, 0x422: 0x13d, 0x423: 0x13e, 0x424: 0xba, 0x425: 0xba, 0x426: 0xba, 0x427: 0xba,
+	0x428: 0x13f, 0x429: 0x140, 0x42a: 0x141, 0x42b: 0x142, 0x42c: 0xba, 0x42d: 0xba, 0x42e: 0xba, 0x42f: 0xba,
+	0x430: 0x143, 0x431: 0x144, 0x432: 0x145, 0x433: 0xba, 0x434: 0x146, 0x435: 0x147, 0x436: 0xba, 0x437: 0xba,
+	0x438: 0xba, 0x439: 0xba, 0x43a: 0xba, 0x43b: 0xba, 0x43c: 0xba, 0x43d: 0xba, 0x43e: 0xba, 0x43f: 0xba,
+	// Block 0x11, offset 0x440
+	0x440: 0x9f, 0x441: 0x9f, 0x442: 0x9f, 0x443: 0x9f, 0x444: 0x9f, 0x445: 0x9f, 0x446: 0x9f, 0x447: 0x9f,
+	0x448: 0x9f, 0x449: 0x9f, 0x44a: 0x9f, 0x44b: 0x9f, 0x44c: 0x9f, 0x44d: 0x9f, 0x44e: 0x148, 0x44f: 0xba,
+	0x450: 0x9b, 0x451: 0x149, 0x452: 0x9f, 0x453: 0x9f, 0x454: 0x9f, 0x455: 0x14a, 0x456: 0xba, 0x457: 0xba,
+	0x458: 0xba, 0x459: 0xba, 0x45a: 0xba, 0x45b: 0xba, 0x45c: 0xba, 0x45d: 0xba, 0x45e: 0xba, 0x45f: 0xba,
+	0x460: 0xba, 0x461: 0xba, 0x462: 0xba, 0x463: 0xba, 0x464: 0xba, 0x465: 0xba, 0x466: 0xba, 0x467: 0xba,
+	0x468: 0xba, 0x469: 0xba, 0x46a: 0xba, 0x46b: 0xba, 0x46c: 0xba, 0x46d: 0xba, 0x46e: 0xba, 0x46f: 0xba,
+	0x470: 0xba, 0x471: 0xba, 0x472: 0xba, 0x473: 0xba, 0x474: 0xba, 0x475: 0xba, 0x476: 0xba, 0x477: 0xba,
+	0x478: 0xba, 0x479: 0xba, 0x47a: 0xba, 0x47b: 0xba, 0x47c: 0xba, 0x47d: 0xba, 0x47e: 0xba, 0x47f: 0xba,
+	// Block 0x12, offset 0x480
+	0x480: 0x9f, 0x481: 0x9f, 0x482: 0x9f, 0x483: 0x9f, 0x484: 0x9f, 0x485: 0x9f, 0x486: 0x9f, 0x487: 0x9f,
+	0x488: 0x9f, 0x489: 0x9f, 0x48a: 0x9f, 0x48b: 0x9f, 0x48c: 0x9f, 0x48d: 0x9f, 0x48e: 0x9f, 0x48f: 0x9f,
+	0x490: 0x14b, 0x491: 0xba, 0x492: 0xba, 0x493: 0xba, 0x494: 0xba, 0x495: 0xba, 0x496: 0xba, 0x497: 0xba,
+	0x498: 0xba, 0x499: 0xba, 0x49a: 0xba, 0x49b: 0xba, 0x49c: 0xba, 0x49d: 0xba, 0x49e: 0xba, 0x49f: 0xba,
+	0x4a0: 0xba, 0x4a1: 0xba, 0x4a2: 0xba, 0x4a3: 0xba, 0x4a4: 0xba, 0x4a5: 0xba, 0x4a6: 0xba, 0x4a7: 0xba,
+	0x4a8: 0xba, 0x4a9: 0xba, 0x4aa: 0xba, 0x4ab: 0xba, 0x4ac: 0xba, 0x4ad: 0xba, 0x4ae: 0xba, 0x4af: 0xba,
+	0x4b0: 0xba, 0x4b1: 0xba, 0x4b2: 0xba, 0x4b3: 0xba, 0x4b4: 0xba, 0x4b5: 0xba, 0x4b6: 0xba, 0x4b7: 0xba,
+	0x4b8: 0xba, 0x4b9: 0xba, 0x4ba: 0xba, 0x4bb: 0xba, 0x4bc: 0xba, 0x4bd: 0xba, 0x4be: 0xba, 0x4bf: 0xba,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0xba, 0x4c1: 0xba, 0x4c2: 0xba, 0x4c3: 0xba, 0x4c4: 0xba, 0x4c5: 0xba, 0x4c6: 0xba, 0x4c7: 0xba,
+	0x4c8: 0xba, 0x4c9: 0xba, 0x4ca: 0xba, 0x4cb: 0xba, 0x4cc: 0xba, 0x4cd: 0xba, 0x4ce: 0xba, 0x4cf: 0xba,
+	0x4d0: 0x9f, 0x4d1: 0x9f, 0x4d2: 0x9f, 0x4d3: 0x9f, 0x4d4: 0x9f, 0x4d5: 0x9f, 0x4d6: 0x9f, 0x4d7: 0x9f,
+	0x4d8: 0x9f, 0x4d9: 0x14c, 0x4da: 0xba, 0x4db: 0xba, 0x4dc: 0xba, 0x4dd: 0xba, 0x4de: 0xba, 0x4df: 0xba,
+	0x4e0: 0xba, 0x4e1: 0xba, 0x4e2: 0xba, 0x4e3: 0xba, 0x4e4: 0xba, 0x4e5: 0xba, 0x4e6: 0xba, 0x4e7: 0xba,
+	0x4e8: 0xba, 0x4e9: 0xba, 0x4ea: 0xba, 0x4eb: 0xba, 0x4ec: 0xba, 0x4ed: 0xba, 0x4ee: 0xba, 0x4ef: 0xba,
+	0x4f0: 0xba, 0x4f1: 0xba, 0x4f2: 0xba, 0x4f3: 0xba, 0x4f4: 0xba, 0x4f5: 0xba, 0x4f6: 0xba, 0x4f7: 0xba,
+	0x4f8: 0xba, 0x4f9: 0xba, 0x4fa: 0xba, 0x4fb: 0xba, 0x4fc: 0xba, 0x4fd: 0xba, 0x4fe: 0xba, 0x4ff: 0xba,
+	// Block 0x14, offset 0x500
+	0x500: 0xba, 0x501: 0xba, 0x502: 0xba, 0x503: 0xba, 0x504: 0xba, 0x505: 0xba, 0x506: 0xba, 0x507: 0xba,
+	0x508: 0xba, 0x509: 0xba, 0x50a: 0xba, 0x50b: 0xba, 0x50c: 0xba, 0x50d: 0xba, 0x50e: 0xba, 0x50f: 0xba,
+	0x510: 0xba, 0x511: 0xba, 0x512: 0xba, 0x513: 0xba, 0x514: 0xba, 0x515: 0xba, 0x516: 0xba, 0x517: 0xba,
+	0x518: 0xba, 0x519: 0xba, 0x51a: 0xba, 0x51b: 0xba, 0x51c: 0xba, 0x51d: 0xba, 0x51e: 0xba, 0x51f: 0xba,
+	0x520: 0x9f, 0x521: 0x9f, 0x522: 0x9f, 0x523: 0x9f, 0x524: 0x9f, 0x525: 0x9f, 0x526: 0x9f, 0x527: 0x9f,
+	0x528: 0x142, 0x529: 0x14d, 0x52a: 0xba, 0x52b: 0x14e, 0x52c: 0x14f, 0x52d: 0x150, 0x52e: 0x151, 0x52f: 0xba,
+	0x530: 0xba, 0x531: 0xba, 0x532: 0xba, 0x533: 0xba, 0x534: 0xba, 0x535: 0xba, 0x536: 0xba, 0x537: 0xba,
+	0x538: 0xba, 0x539: 0xba, 0x53a: 0xba, 0x53b: 0xba, 0x53c: 0x9f, 0x53d: 0x152, 0x53e: 0x153, 0x53f: 0x154,
+	// Block 0x15, offset 0x540
+	0x540: 0x9f, 0x541: 0x9f, 0x542: 0x9f, 0x543: 0x9f, 0x544: 0x9f, 0x545: 0x9f, 0x546: 0x9f, 0x547: 0x9f,
+	0x548: 0x9f, 0x549: 0x9f, 0x54a: 0x9f, 0x54b: 0x9f, 0x54c: 0x9f, 0x54d: 0x9f, 0x54e: 0x9f, 0x54f: 0x9f,
+	0x550: 0x9f, 0x551: 0x9f, 0x552: 0x9f, 0x553: 0x9f, 0x554: 0x9f, 0x555: 0x9f, 0x556: 0x9f, 0x557: 0x9f,
+	0x558: 0x9f, 0x559: 0x9f, 0x55a: 0x9f, 0x55b: 0x9f, 0x55c: 0x9f, 0x55d: 0x9f, 0x55e: 0x9f, 0x55f: 0x155,
+	0x560: 0x9f, 0x561: 0x9f, 0x562: 0x9f, 0x563: 0x9f, 0x564: 0x9f, 0x565: 0x9f, 0x566: 0x9f, 0x567: 0x9f,
+	0x568: 0x9f, 0x569: 0x9f, 0x56a: 0x9f, 0x56b: 0x156, 0x56c: 0xba, 0x56d: 0xba, 0x56e: 0xba, 0x56f: 0xba,
+	0x570: 0xba, 0x571: 0xba, 0x572: 0xba, 0x573: 0xba, 0x574: 0xba, 0x575: 0xba, 0x576: 0xba, 0x577: 0xba,
+	0x578: 0xba, 0x579: 0xba, 0x57a: 0xba, 0x57b: 0xba, 0x57c: 0xba, 0x57d: 0xba, 0x57e: 0xba, 0x57f: 0xba,
+	// Block 0x16, offset 0x580
+	0x580: 0x9f, 0x581: 0x9f, 0x582: 0x9f, 0x583: 0x9f, 0x584: 0x157, 0x585: 0x158, 0x586: 0x9f, 0x587: 0x9f,
+	0x588: 0x9f, 0x589: 0x9f, 0x58a: 0x9f, 0x58b: 0x159, 0x58c: 0xba, 0x58d: 0xba, 0x58e: 0xba, 0x58f: 0xba,
+	0x590: 0xba, 0x591: 0xba, 0x592: 0xba, 0x593: 0xba, 0x594: 0xba, 0x595: 0xba, 0x596: 0xba, 0x597: 0xba,
+	0x598: 0xba, 0x599: 0xba, 0x59a: 0xba, 0x59b: 0xba, 0x59c: 0xba, 0x59d: 0xba, 0x59e: 0xba, 0x59f: 0xba,
+	0x5a0: 0xba, 0x5a1: 0xba, 0x5a2: 0xba, 0x5a3: 0xba, 0x5a4: 0xba, 0x5a5: 0xba, 0x5a6: 0xba, 0x5a7: 0xba,
+	0x5a8: 0xba, 0x5a9: 0xba, 0x5aa: 0xba, 0x5ab: 0xba, 0x5ac: 0xba, 0x5ad: 0xba, 0x5ae: 0xba, 0x5af: 0xba,
+	0x5b0: 0x9f, 0x5b1: 0x15a, 0x5b2: 0x15b, 0x5b3: 0xba, 0x5b4: 0xba, 0x5b5: 0xba, 0x5b6: 0xba, 0x5b7: 0xba,
+	0x5b8: 0xba, 0x5b9: 0xba, 0x5ba: 0xba, 0x5bb: 0xba, 0x5bc: 0xba, 0x5bd: 0xba, 0x5be: 0xba, 0x5bf: 0xba,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x9b, 0x5c1: 0x9b, 0x5c2: 0x9b, 0x5c3: 0x15c, 0x5c4: 0x15d, 0x5c5: 0x15e, 0x5c6: 0x15f, 0x5c7: 0x160,
+	0x5c8: 0x9b, 0x5c9: 0x161, 0x5ca: 0xba, 0x5cb: 0xba, 0x5cc: 0x9b, 0x5cd: 0x162, 0x5ce: 0xba, 0x5cf: 0xba,
+	0x5d0: 0x5f, 0x5d1: 0x60, 0x5d2: 0x61, 0x5d3: 0x62, 0x5d4: 0x63, 0x5d5: 0x64, 0x5d6: 0x65, 0x5d7: 0x66,
+	0x5d8: 0x67, 0x5d9: 0x68, 0x5da: 0x69, 0x5db: 0x6a, 0x5dc: 0x6b, 0x5dd: 0x6c, 0x5de: 0x6d, 0x5df: 0x6e,
+	0x5e0: 0x9b, 0x5e1: 0x9b, 0x5e2: 0x9b, 0x5e3: 0x9b, 0x5e4: 0x9b, 0x5e5: 0x9b, 0x5e6: 0x9b, 0x5e7: 0x9b,
+	0x5e8: 0x163, 0x5e9: 0x164, 0x5ea: 0x165, 0x5eb: 0xba, 0x5ec: 0xba, 0x5ed: 0xba, 0x5ee: 0xba, 0x5ef: 0xba,
+	0x5f0: 0xba, 0x5f1: 0xba, 0x5f2: 0xba, 0x5f3: 0xba, 0x5f4: 0xba, 0x5f5: 0xba, 0x5f6: 0xba, 0x5f7: 0xba,
+	0x5f8: 0xba, 0x5f9: 0xba, 0x5fa: 0xba, 0x5fb: 0xba, 0x5fc: 0xba, 0x5fd: 0xba, 0x5fe: 0xba, 0x5ff: 0xba,
+	// Block 0x18, offset 0x600
+	0x600: 0x166, 0x601: 0xba, 0x602: 0xba, 0x603: 0xba, 0x604: 0xba, 0x605: 0xba, 0x606: 0xba, 0x607: 0xba,
+	0x608: 0xba, 0x609: 0xba, 0x60a: 0xba, 0x60b: 0xba, 0x60c: 0xba, 0x60d: 0xba, 0x60e: 0xba, 0x60f: 0xba,
+	0x610: 0xba, 0x611: 0xba, 0x612: 0xba, 0x613: 0xba, 0x614: 0xba, 0x615: 0xba, 0x616: 0xba, 0x617: 0xba,
+	0x618: 0xba, 0x619: 0xba, 0x61a: 0xba, 0x61b: 0xba, 0x61c: 0xba, 0x61d: 0xba, 0x61e: 0xba, 0x61f: 0xba,
+	0x620: 0x122, 0x621: 0x122, 0x622: 0x122, 0x623: 0x167, 0x624: 0x6f, 0x625: 0x168, 0x626: 0xba, 0x627: 0xba,
+	0x628: 0xba, 0x629: 0xba, 0x62a: 0xba, 0x62b: 0xba, 0x62c: 0xba, 0x62d: 0xba, 0x62e: 0xba, 0x62f: 0xba,
+	0x630: 0xba, 0x631: 0xba, 0x632: 0xba, 0x633: 0xba, 0x634: 0xba, 0x635: 0xba, 0x636: 0xba, 0x637: 0xba,
+	0x638: 0x70, 0x639: 0x71, 0x63a: 0x72, 0x63b: 0x169, 0x63c: 0xba, 0x63d: 0xba, 0x63e: 0xba, 0x63f: 0xba,
+	// Block 0x19, offset 0x640
+	0x640: 0x16a, 0x641: 0x9b, 0x642: 0x16b, 0x643: 0x16c, 0x644: 0x73, 0x645: 0x74, 0x646: 0x16d, 0x647: 0x16e,
+	0x648: 0x75, 0x649: 0x16f, 0x64a: 0xba, 0x64b: 0xba, 0x64c: 0x9b, 0x64d: 0x9b, 0x64e: 0x9b, 0x64f: 0x9b,
+	0x650: 0x9b, 0x651: 0x9b, 0x652: 0x9b, 0x653: 0x9b, 0x654: 0x9b, 0x655: 0x9b, 0x656: 0x9b, 0x657: 0x9b,
+	0x658: 0x9b, 0x659: 0x9b, 0x65a: 0x9b, 0x65b: 0x170, 0x65c: 0x9b, 0x65d: 0x171, 0x65e: 0x9b, 0x65f: 0x172,
+	0x660: 0x173, 0x661: 0x174, 0x662: 0x175, 0x663: 0xba, 0x664: 0x176, 0x665: 0x177, 0x666: 0x178, 0x667: 0x179,
+	0x668: 0xba, 0x669: 0xba, 0x66a: 0xba, 0x66b: 0xba, 0x66c: 0xba, 0x66d: 0xba, 0x66e: 0xba, 0x66f: 0xba,
+	0x670: 0xba, 0x671: 0xba, 0x672: 0xba, 0x673: 0xba, 0x674: 0xba, 0x675: 0xba, 0x676: 0xba, 0x677: 0xba,
+	0x678: 0xba, 0x679: 0xba, 0x67a: 0xba, 0x67b: 0xba, 0x67c: 0xba, 0x67d: 0xba, 0x67e: 0xba, 0x67f: 0xba,
+	// Block 0x1a, offset 0x680
+	0x680: 0x9f, 0x681: 0x9f, 0x682: 0x9f, 0x683: 0x9f, 0x684: 0x9f, 0x685: 0x9f, 0x686: 0x9f, 0x687: 0x9f,
+	0x688: 0x9f, 0x689: 0x9f, 0x68a: 0x9f, 0x68b: 0x9f, 0x68c: 0x9f, 0x68d: 0x9f, 0x68e: 0x9f, 0x68f: 0x9f,
+	0x690: 0x9f, 0x691: 0x9f, 0x692: 0x9f, 0x693: 0x9f, 0x694: 0x9f, 0x695: 0x9f, 0x696: 0x9f, 0x697: 0x9f,
+	0x698: 0x9f, 0x699: 0x9f, 0x69a: 0x9f, 0x69b: 0x17a, 0x69c: 0x9f, 0x69d: 0x9f, 0x69e: 0x9f, 0x69f: 0x9f,
+	0x6a0: 0x9f, 0x6a1: 0x9f, 0x6a2: 0x9f, 0x6a3: 0x9f, 0x6a4: 0x9f, 0x6a5: 0x9f, 0x6a6: 0x9f, 0x6a7: 0x9f,
+	0x6a8: 0x9f, 0x6a9: 0x9f, 0x6aa: 0x9f, 0x6ab: 0x9f, 0x6ac: 0x9f, 0x6ad: 0x9f, 0x6ae: 0x9f, 0x6af: 0x9f,
+	0x6b0: 0x9f, 0x6b1: 0x9f, 0x6b2: 0x9f, 0x6b3: 0x9f, 0x6b4: 0x9f, 0x6b5: 0x9f, 0x6b6: 0x9f, 0x6b7: 0x9f,
+	0x6b8: 0x9f, 0x6b9: 0x9f, 0x6ba: 0x9f, 0x6bb: 0x9f, 0x6bc: 0x9f, 0x6bd: 0x9f, 0x6be: 0x9f, 0x6bf: 0x9f,
+	// Block 0x1b, offset 0x6c0
+	0x6c0: 0x9f, 0x6c1: 0x9f, 0x6c2: 0x9f, 0x6c3: 0x9f, 0x6c4: 0x9f, 0x6c5: 0x9f, 0x6c6: 0x9f, 0x6c7: 0x9f,
+	0x6c8: 0x9f, 0x6c9: 0x9f, 0x6ca: 0x9f, 0x6cb: 0x9f, 0x6cc: 0x9f, 0x6cd: 0x9f, 0x6ce: 0x9f, 0x6cf: 0x9f,
+	0x6d0: 0x9f, 0x6d1: 0x9f, 0x6d2: 0x9f, 0x6d3: 0x9f, 0x6d4: 0x9f, 0x6d5: 0x9f, 0x6d6: 0x9f, 0x6d7: 0x9f,
+	0x6d8: 0x9f, 0x6d9: 0x9f, 0x6da: 0x9f, 0x6db: 0x9f, 0x6dc: 0x17b, 0x6dd: 0x9f, 0x6de: 0x9f, 0x6df: 0x9f,
+	0x6e0: 0x17c, 0x6e1: 0x9f, 0x6e2: 0x9f, 0x6e3: 0x9f, 0x6e4: 0x9f, 0x6e5: 0x9f, 0x6e6: 0x9f, 0x6e7: 0x9f,
+	0x6e8: 0x9f, 0x6e9: 0x9f, 0x6ea: 0x9f, 0x6eb: 0x9f, 0x6ec: 0x9f, 0x6ed: 0x9f, 0x6ee: 0x9f, 0x6ef: 0x9f,
+	0x6f0: 0x9f, 0x6f1: 0x9f, 0x6f2: 0x9f, 0x6f3: 0x9f, 0x6f4: 0x9f, 0x6f5: 0x9f, 0x6f6: 0x9f, 0x6f7: 0x9f,
+	0x6f8: 0x9f, 0x6f9: 0x9f, 0x6fa: 0x9f, 0x6fb: 0x9f, 0x6fc: 0x9f, 0x6fd: 0x9f, 0x6fe: 0x9f, 0x6ff: 0x9f,
+	// Block 0x1c, offset 0x700
+	0x700: 0x9f, 0x701: 0x9f, 0x702: 0x9f, 0x703: 0x9f, 0x704: 0x9f, 0x705: 0x9f, 0x706: 0x9f, 0x707: 0x9f,
+	0x708: 0x9f, 0x709: 0x9f, 0x70a: 0x9f, 0x70b: 0x9f, 0x70c: 0x9f, 0x70d: 0x9f, 0x70e: 0x9f, 0x70f: 0x9f,
+	0x710: 0x9f, 0x711: 0x9f, 0x712: 0x9f, 0x713: 0x9f, 0x714: 0x9f, 0x715: 0x9f, 0x716: 0x9f, 0x717: 0x9f,
+	0x718: 0x9f, 0x719: 0x9f, 0x71a: 0x9f, 0x71b: 0x9f, 0x71c: 0x9f, 0x71d: 0x9f, 0x71e: 0x9f, 0x71f: 0x9f,
+	0x720: 0x9f, 0x721: 0x9f, 0x722: 0x9f, 0x723: 0x9f, 0x724: 0x9f, 0x725: 0x9f, 0x726: 0x9f, 0x727: 0x9f,
+	0x728: 0x9f, 0x729: 0x9f, 0x72a: 0x9f, 0x72b: 0x9f, 0x72c: 0x9f, 0x72d: 0x9f, 0x72e: 0x9f, 0x72f: 0x9f,
+	0x730: 0x9f, 0x731: 0x9f, 0x732: 0x9f, 0x733: 0x9f, 0x734: 0x9f, 0x735: 0x9f, 0x736: 0x9f, 0x737: 0x9f,
+	0x738: 0x9f, 0x739: 0x9f, 0x73a: 0x17d, 0x73b: 0x9f, 0x73c: 0x9f, 0x73d: 0x9f, 0x73e: 0x9f, 0x73f: 0x9f,
+	// Block 0x1d, offset 0x740
+	0x740: 0x9f, 0x741: 0x9f, 0x742: 0x9f, 0x743: 0x9f, 0x744: 0x9f, 0x745: 0x9f, 0x746: 0x9f, 0x747: 0x9f,
+	0x748: 0x9f, 0x749: 0x9f, 0x74a: 0x9f, 0x74b: 0x9f, 0x74c: 0x9f, 0x74d: 0x9f, 0x74e: 0x9f, 0x74f: 0x9f,
+	0x750: 0x9f, 0x751: 0x9f, 0x752: 0x9f, 0x753: 0x9f, 0x754: 0x9f, 0x755: 0x9f, 0x756: 0x9f, 0x757: 0x9f,
+	0x758: 0x9f, 0x759: 0x9f, 0x75a: 0x9f, 0x75b: 0x9f, 0x75c: 0x9f, 0x75d: 0x9f, 0x75e: 0x9f, 0x75f: 0x9f,
+	0x760: 0x9f, 0x761: 0x9f, 0x762: 0x9f, 0x763: 0x9f, 0x764: 0x9f, 0x765: 0x9f, 0x766: 0x9f, 0x767: 0x9f,
+	0x768: 0x9f, 0x769: 0x9f, 0x76a: 0x9f, 0x76b: 0x9f, 0x76c: 0x9f, 0x76d: 0x9f, 0x76e: 0x9f, 0x76f: 0x17e,
+	0x770: 0xba, 0x771: 0xba, 0x772: 0xba, 0x773: 0xba, 0x774: 0xba, 0x775: 0xba, 0x776: 0xba, 0x777: 0xba,
+	0x778: 0xba, 0x779: 0xba, 0x77a: 0xba, 0x77b: 0xba, 0x77c: 0xba, 0x77d: 0xba, 0x77e: 0xba, 0x77f: 0xba,
+	// Block 0x1e, offset 0x780
+	0x780: 0xba, 0x781: 0xba, 0x782: 0xba, 0x783: 0xba, 0x784: 0xba, 0x785: 0xba, 0x786: 0xba, 0x787: 0xba,
+	0x788: 0xba, 0x789: 0xba, 0x78a: 0xba, 0x78b: 0xba, 0x78c: 0xba, 0x78d: 0xba, 0x78e: 0xba, 0x78f: 0xba,
+	0x790: 0xba, 0x791: 0xba, 0x792: 0xba, 0x793: 0xba, 0x794: 0xba, 0x795: 0xba, 0x796: 0xba, 0x797: 0xba,
+	0x798: 0xba, 0x799: 0xba, 0x79a: 0xba, 0x79b: 0xba, 0x79c: 0xba, 0x79d: 0xba, 0x79e: 0xba, 0x79f: 0xba,
+	0x7a0: 0x76, 0x7a1: 0x77, 0x7a2: 0x78, 0x7a3: 0x17f, 0x7a4: 0x79, 0x7a5: 0x7a, 0x7a6: 0x180, 0x7a7: 0x7b,
+	0x7a8: 0x7c, 0x7a9: 0xba, 0x7aa: 0xba, 0x7ab: 0xba, 0x7ac: 0xba, 0x7ad: 0xba, 0x7ae: 0xba, 0x7af: 0xba,
+	0x7b0: 0xba, 0x7b1: 0xba, 0x7b2: 0xba, 0x7b3: 0xba, 0x7b4: 0xba, 0x7b5: 0xba, 0x7b6: 0xba, 0x7b7: 0xba,
+	0x7b8: 0xba, 0x7b9: 0xba, 0x7ba: 0xba, 0x7bb: 0xba, 0x7bc: 0xba, 0x7bd: 0xba, 0x7be: 0xba, 0x7bf: 0xba,
+	// Block 0x1f, offset 0x7c0
+	0x7d0: 0x0d, 0x7d1: 0x0e, 0x7d2: 0x0f, 0x7d3: 0x10, 0x7d4: 0x11, 0x7d5: 0x0b, 0x7d6: 0x12, 0x7d7: 0x07,
+	0x7d8: 0x13, 0x7d9: 0x0b, 0x7da: 0x0b, 0x7db: 0x14, 0x7dc: 0x0b, 0x7dd: 0x15, 0x7de: 0x16, 0x7df: 0x17,
+	0x7e0: 0x07, 0x7e1: 0x07, 0x7e2: 0x07, 0x7e3: 0x07, 0x7e4: 0x07, 0x7e5: 0x07, 0x7e6: 0x07, 0x7e7: 0x07,
+	0x7e8: 0x07, 0x7e9: 0x07, 0x7ea: 0x18, 0x7eb: 0x19, 0x7ec: 0x1a, 0x7ed: 0x07, 0x7ee: 0x1b, 0x7ef: 0x1c,
+	0x7f0: 0x0b, 0x7f1: 0x0b, 0x7f2: 0x0b, 0x7f3: 0x0b, 0x7f4: 0x0b, 0x7f5: 0x0b, 0x7f6: 0x0b, 0x7f7: 0x0b,
+	0x7f8: 0x0b, 0x7f9: 0x0b, 0x7fa: 0x0b, 0x7fb: 0x0b, 0x7fc: 0x0b, 0x7fd: 0x0b, 0x7fe: 0x0b, 0x7ff: 0x0b,
+	// Block 0x20, offset 0x800
+	0x800: 0x0b, 0x801: 0x0b, 0x802: 0x0b, 0x803: 0x0b, 0x804: 0x0b, 0x805: 0x0b, 0x806: 0x0b, 0x807: 0x0b,
+	0x808: 0x0b, 0x809: 0x0b, 0x80a: 0x0b, 0x80b: 0x0b, 0x80c: 0x0b, 0x80d: 0x0b, 0x80e: 0x0b, 0x80f: 0x0b,
+	0x810: 0x0b, 0x811: 0x0b, 0x812: 0x0b, 0x813: 0x0b, 0x814: 0x0b, 0x815: 0x0b, 0x816: 0x0b, 0x817: 0x0b,
+	0x818: 0x0b, 0x819: 0x0b, 0x81a: 0x0b, 0x81b: 0x0b, 0x81c: 0x0b, 0x81d: 0x0b, 0x81e: 0x0b, 0x81f: 0x0b,
+	0x820: 0x0b, 0x821: 0x0b, 0x822: 0x0b, 0x823: 0x0b, 0x824: 0x0b, 0x825: 0x0b, 0x826: 0x0b, 0x827: 0x0b,
+	0x828: 0x0b, 0x829: 0x0b, 0x82a: 0x0b, 0x82b: 0x0b, 0x82c: 0x0b, 0x82d: 0x0b, 0x82e: 0x0b, 0x82f: 0x0b,
+	0x830: 0x0b, 0x831: 0x0b, 0x832: 0x0b, 0x833: 0x0b, 0x834: 0x0b, 0x835: 0x0b, 0x836: 0x0b, 0x837: 0x0b,
+	0x838: 0x0b, 0x839: 0x0b, 0x83a: 0x0b, 0x83b: 0x0b, 0x83c: 0x0b, 0x83d: 0x0b, 0x83e: 0x0b, 0x83f: 0x0b,
+	// Block 0x21, offset 0x840
+	0x840: 0x181, 0x841: 0x182, 0x842: 0xba, 0x843: 0xba, 0x844: 0x183, 0x845: 0x183, 0x846: 0x183, 0x847: 0x184,
+	0x848: 0xba, 0x849: 0xba, 0x84a: 0xba, 0x84b: 0xba, 0x84c: 0xba, 0x84d: 0xba, 0x84e: 0xba, 0x84f: 0xba,
+	0x850: 0xba, 0x851: 0xba, 0x852: 0xba, 0x853: 0xba, 0x854: 0xba, 0x855: 0xba, 0x856: 0xba, 0x857: 0xba,
+	0x858: 0xba, 0x859: 0xba, 0x85a: 0xba, 0x85b: 0xba, 0x85c: 0xba, 0x85d: 0xba, 0x85e: 0xba, 0x85f: 0xba,
+	0x860: 0xba, 0x861: 0xba, 0x862: 0xba, 0x863: 0xba, 0x864: 0xba, 0x865: 0xba, 0x866: 0xba, 0x867: 0xba,
+	0x868: 0xba, 0x869: 0xba, 0x86a: 0xba, 0x86b: 0xba, 0x86c: 0xba, 0x86d: 0xba, 0x86e: 0xba, 0x86f: 0xba,
+	0x870: 0xba, 0x871: 0xba, 0x872: 0xba, 0x873: 0xba, 0x874: 0xba, 0x875: 0xba, 0x876: 0xba, 0x877: 0xba,
+	0x878: 0xba, 0x879: 0xba, 0x87a: 0xba, 0x87b: 0xba, 0x87c: 0xba, 0x87d: 0xba, 0x87e: 0xba, 0x87f: 0xba,
+	// Block 0x22, offset 0x880
+	0x880: 0x0b, 0x881: 0x0b, 0x882: 0x0b, 0x883: 0x0b, 0x884: 0x0b, 0x885: 0x0b, 0x886: 0x0b, 0x887: 0x0b,
+	0x888: 0x0b, 0x889: 0x0b, 0x88a: 0x0b, 0x88b: 0x0b, 0x88c: 0x0b, 0x88d: 0x0b, 0x88e: 0x0b, 0x88f: 0x0b,
+	0x890: 0x0b, 0x891: 0x0b, 0x892: 0x0b, 0x893: 0x0b, 0x894: 0x0b, 0x895: 0x0b, 0x896: 0x0b, 0x897: 0x0b,
+	0x898: 0x0b, 0x899: 0x0b, 0x89a: 0x0b, 0x89b: 0x0b, 0x89c: 0x0b, 0x89d: 0x0b, 0x89e: 0x0b, 0x89f: 0x0b,
+	0x8a0: 0x1f, 0x8a1: 0x0b, 0x8a2: 0x0b, 0x8a3: 0x0b, 0x8a4: 0x0b, 0x8a5: 0x0b, 0x8a6: 0x0b, 0x8a7: 0x0b,
+	0x8a8: 0x0b, 0x8a9: 0x0b, 0x8aa: 0x0b, 0x8ab: 0x0b, 0x8ac: 0x0b, 0x8ad: 0x0b, 0x8ae: 0x0b, 0x8af: 0x0b,
+	0x8b0: 0x0b, 0x8b1: 0x0b, 0x8b2: 0x0b, 0x8b3: 0x0b, 0x8b4: 0x0b, 0x8b5: 0x0b, 0x8b6: 0x0b, 0x8b7: 0x0b,
+	0x8b8: 0x0b, 0x8b9: 0x0b, 0x8ba: 0x0b, 0x8bb: 0x0b, 0x8bc: 0x0b, 0x8bd: 0x0b, 0x8be: 0x0b, 0x8bf: 0x0b,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0b, 0x8c1: 0x0b, 0x8c2: 0x0b, 0x8c3: 0x0b, 0x8c4: 0x0b, 0x8c5: 0x0b, 0x8c6: 0x0b, 0x8c7: 0x0b,
+	0x8c8: 0x0b, 0x8c9: 0x0b, 0x8ca: 0x0b, 0x8cb: 0x0b, 0x8cc: 0x0b, 0x8cd: 0x0b, 0x8ce: 0x0b, 0x8cf: 0x0b,
+}
+
+// idnaSparseOffset: 264 entries, 528 bytes
+var idnaSparseOffset = []uint16{0x0, 0x8, 0x19, 0x25, 0x27, 0x2c, 0x34, 0x3f, 0x4b, 0x4f, 0x5e, 0x63, 0x6b, 0x77, 0x85, 0x8a, 0x93, 0xa3, 0xb1, 0xbd, 0xc9, 0xda, 0xe4, 0xeb, 0xf8, 0x109, 0x110, 0x11b, 0x12a, 0x138, 0x142, 0x144, 0x149, 0x14c, 0x14f, 0x151, 0x15d, 0x168, 0x170, 0x176, 0x17c, 0x181, 0x186, 0x189, 0x18d, 0x193, 0x198, 0x1a4, 0x1ae, 0x1b4, 0x1c5, 0x1cf, 0x1d2, 0x1da, 0x1dd, 0x1ea, 0x1f2, 0x1f6, 0x1fd, 0x205, 0x215, 0x221, 0x223, 0x22d, 0x239, 0x245, 0x251, 0x259, 0x25e, 0x268, 0x279, 0x27d, 0x288, 0x28c, 0x295, 0x29d, 0x2a3, 0x2a8, 0x2ab, 0x2af, 0x2b5, 0x2b9, 0x2bd, 0x2c3, 0x2ca, 0x2d0, 0x2d8, 0x2df, 0x2ea, 0x2f4, 0x2f8, 0x2fb, 0x301, 0x305, 0x307, 0x30a, 0x30c, 0x30f, 0x319, 0x31c, 0x32b, 0x32f, 0x334, 0x337, 0x33b, 0x340, 0x345, 0x34b, 0x351, 0x360, 0x366, 0x36a, 0x379, 0x37e, 0x386, 0x390, 0x39b, 0x3a3, 0x3b4, 0x3bd, 0x3cd, 0x3da, 0x3e4, 0x3e9, 0x3f6, 0x3fa, 0x3ff, 0x401, 0x405, 0x407, 0x40b, 0x414, 0x41a, 0x41e, 0x42e, 0x438, 0x43d, 0x440, 0x446, 0x44d, 0x452, 0x456, 0x45c, 0x461, 0x46a, 0x46f, 0x475, 0x47c, 0x483, 0x48a, 0x48e, 0x493, 0x496, 0x49b, 0x4a7, 0x4ad, 0x4b2, 0x4b9, 0x4c1, 0x4c6, 0x4ca, 0x4da, 0x4e1, 0x4e5, 0x4e9, 0x4f0, 0x4f2, 0x4f5, 0x4f8, 0x4fc, 0x500, 0x506, 0x50f, 0x51b, 0x522, 0x52b, 0x533, 0x53a, 0x548, 0x555, 0x562, 0x56b, 0x56f, 0x57d, 0x585, 0x590, 0x599, 0x59f, 0x5a7, 0x5b0, 0x5ba, 0x5bd, 0x5c9, 0x5cc, 0x5d1, 0x5de, 0x5e7, 0x5f3, 0x5f6, 0x600, 0x609, 0x615, 0x622, 0x62a, 0x62d, 0x632, 0x635, 0x638, 0x63b, 0x642, 0x649, 0x64d, 0x658, 0x65b, 0x661, 0x666, 0x66a, 0x66d, 0x670, 0x673, 0x676, 0x679, 0x67e, 0x688, 0x68b, 0x68f, 0x69e, 0x6aa, 0x6ae, 0x6b3, 0x6b8, 0x6bc, 0x6c1, 0x6ca, 0x6d5, 0x6db, 0x6e3, 0x6e7, 0x6eb, 0x6f1, 0x6f7, 0x6fc, 0x6ff, 0x70f, 0x716, 0x719, 0x71c, 0x720, 0x726, 0x72b, 0x730, 0x735, 0x738, 0x73d, 0x740, 0x743, 0x747, 0x74b, 0x74e, 0x75e, 0x76f, 0x774, 0x776, 0x778}
+
+// idnaSparseValues: 1915 entries, 7660 bytes
+var idnaSparseValues = [1915]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0000, lo: 0x07},
+	{value: 0xe105, lo: 0x80, hi: 0x96},
+	{value: 0x0018, lo: 0x97, hi: 0x97},
+	{value: 0xe105, lo: 0x98, hi: 0x9e},
+	{value: 0x001f, lo: 0x9f, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xb7},
+	{value: 0x0008, lo: 0xb8, hi: 0xbf},
+	// Block 0x1, offset 0x8
+	{value: 0x0000, lo: 0x10},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0xe01d, lo: 0x81, hi: 0x81},
+	{value: 0x0008, lo: 0x82, hi: 0x82},
+	{value: 0x0335, lo: 0x83, hi: 0x83},
+	{value: 0x034d, lo: 0x84, hi: 0x84},
+	{value: 0x0365, lo: 0x85, hi: 0x85},
+	{value: 0xe00d, lo: 0x86, hi: 0x86},
+	{value: 0x0008, lo: 0x87, hi: 0x87},
+	{value: 0xe00d, lo: 0x88, hi: 0x88},
+	{value: 0x0008, lo: 0x89, hi: 0x89},
+	{value: 0xe00d, lo: 0x8a, hi: 0x8a},
+	{value: 0x0008, lo: 0x8b, hi: 0x8b},
+	{value: 0xe00d, lo: 0x8c, hi: 0x8c},
+	{value: 0x0008, lo: 0x8d, hi: 0x8d},
+	{value: 0xe00d, lo: 0x8e, hi: 0x8e},
+	{value: 0x0008, lo: 0x8f, hi: 0xbf},
+	// Block 0x2, offset 0x19
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0xaf},
+	{value: 0x0249, lo: 0xb0, hi: 0xb0},
+	{value: 0x037d, lo: 0xb1, hi: 0xb1},
+	{value: 0x0259, lo: 0xb2, hi: 0xb2},
+	{value: 0x0269, lo: 0xb3, hi: 0xb3},
+	{value: 0x034d, lo: 0xb4, hi: 0xb4},
+	{value: 0x0395, lo: 0xb5, hi: 0xb5},
+	{value: 0xe1bd, lo: 0xb6, hi: 0xb6},
+	{value: 0x0279, lo: 0xb7, hi: 0xb7},
+	{value: 0x0289, lo: 0xb8, hi: 0xb8},
+	{value: 0x0008, lo: 0xb9, hi: 0xbf},
+	// Block 0x3, offset 0x25
+	{value: 0x0000, lo: 0x01},
+	{value: 0x3308, lo: 0x80, hi: 0xbf},
+	// Block 0x4, offset 0x27
+	{value: 0x0000, lo: 0x04},
+	{value: 0x03f5, lo: 0x80, hi: 0x8f},
+	{value: 0xe105, lo: 0x90, hi: 0x9f},
+	{value: 0x049d, lo: 0xa0, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x5, offset 0x2c
+	{value: 0x0000, lo: 0x07},
+	{value: 0xe185, lo: 0x80, hi: 0x8f},
+	{value: 0x0545, lo: 0x90, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x98},
+	{value: 0x0008, lo: 0x99, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xa0},
+	{value: 0x0008, lo: 0xa1, hi: 0xbf},
+	// Block 0x6, offset 0x34
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0401, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x88},
+	{value: 0x0018, lo: 0x89, hi: 0x8a},
+	{value: 0x0040, lo: 0x8b, hi: 0x8c},
+	{value: 0x0018, lo: 0x8d, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0x90},
+	{value: 0x3308, lo: 0x91, hi: 0xbd},
+	{value: 0x0818, lo: 0xbe, hi: 0xbe},
+	{value: 0x3308, lo: 0xbf, hi: 0xbf},
+	// Block 0x7, offset 0x3f
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0818, lo: 0x80, hi: 0x80},
+	{value: 0x3308, lo: 0x81, hi: 0x82},
+	{value: 0x0818, lo: 0x83, hi: 0x83},
+	{value: 0x3308, lo: 0x84, hi: 0x85},
+	{value: 0x0818, lo: 0x86, hi: 0x86},
+	{value: 0x3308, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0808, lo: 0x90, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xaf},
+	{value: 0x0808, lo: 0xb0, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0x8, offset 0x4b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0a08, lo: 0x80, hi: 0x87},
+	{value: 0x0c08, lo: 0x88, hi: 0x99},
+	{value: 0x0a08, lo: 0x9a, hi: 0xbf},
+	// Block 0x9, offset 0x4f
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x3308, lo: 0x80, hi: 0x8a},
+	{value: 0x0040, lo: 0x8b, hi: 0x8c},
+	{value: 0x0c08, lo: 0x8d, hi: 0x8d},
+	{value: 0x0a08, lo: 0x8e, hi: 0x98},
+	{value: 0x0c08, lo: 0x99, hi: 0x9b},
+	{value: 0x0a08, lo: 0x9c, hi: 0xaa},
+	{value: 0x0c08, lo: 0xab, hi: 0xac},
+	{value: 0x0a08, lo: 0xad, hi: 0xb0},
+	{value: 0x0c08, lo: 0xb1, hi: 0xb1},
+	{value: 0x0a08, lo: 0xb2, hi: 0xb2},
+	{value: 0x0c08, lo: 0xb3, hi: 0xb4},
+	{value: 0x0a08, lo: 0xb5, hi: 0xb7},
+	{value: 0x0c08, lo: 0xb8, hi: 0xb9},
+	{value: 0x0a08, lo: 0xba, hi: 0xbf},
+	// Block 0xa, offset 0x5e
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0808, lo: 0x80, hi: 0xa5},
+	{value: 0x3308, lo: 0xa6, hi: 0xb0},
+	{value: 0x0808, lo: 0xb1, hi: 0xb1},
+	{value: 0x0040, lo: 0xb2, hi: 0xbf},
+	// Block 0xb, offset 0x63
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0808, lo: 0x80, hi: 0x89},
+	{value: 0x0a08, lo: 0x8a, hi: 0xaa},
+	{value: 0x3308, lo: 0xab, hi: 0xb3},
+	{value: 0x0808, lo: 0xb4, hi: 0xb5},
+	{value: 0x0018, lo: 0xb6, hi: 0xb9},
+	{value: 0x0818, lo: 0xba, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbf},
+	// Block 0xc, offset 0x6b
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0808, lo: 0x80, hi: 0x95},
+	{value: 0x3308, lo: 0x96, hi: 0x99},
+	{value: 0x0808, lo: 0x9a, hi: 0x9a},
+	{value: 0x3308, lo: 0x9b, hi: 0xa3},
+	{value: 0x0808, lo: 0xa4, hi: 0xa4},
+	{value: 0x3308, lo: 0xa5, hi: 0xa7},
+	{value: 0x0808, lo: 0xa8, hi: 0xa8},
+	{value: 0x3308, lo: 0xa9, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x0818, lo: 0xb0, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0xd, offset 0x77
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x0040, lo: 0x80, hi: 0x9f},
+	{value: 0x0a08, lo: 0xa0, hi: 0xa9},
+	{value: 0x0c08, lo: 0xaa, hi: 0xac},
+	{value: 0x0808, lo: 0xad, hi: 0xad},
+	{value: 0x0c08, lo: 0xae, hi: 0xae},
+	{value: 0x0a08, lo: 0xaf, hi: 0xb0},
+	{value: 0x0c08, lo: 0xb1, hi: 0xb2},
+	{value: 0x0a08, lo: 0xb3, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xb5},
+	{value: 0x0a08, lo: 0xb6, hi: 0xb8},
+	{value: 0x0c08, lo: 0xb9, hi: 0xb9},
+	{value: 0x0a08, lo: 0xba, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbf},
+	// Block 0xe, offset 0x85
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0040, lo: 0x80, hi: 0x93},
+	{value: 0x3308, lo: 0x94, hi: 0xa1},
+	{value: 0x0840, lo: 0xa2, hi: 0xa2},
+	{value: 0x3308, lo: 0xa3, hi: 0xbf},
+	// Block 0xf, offset 0x8a
+	{value: 0x0000, lo: 0x08},
+	{value: 0x3308, lo: 0x80, hi: 0x82},
+	{value: 0x3008, lo: 0x83, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0xb9},
+	{value: 0x3308, lo: 0xba, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbf},
+	// Block 0x10, offset 0x93
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x3308, lo: 0x80, hi: 0x80},
+	{value: 0x3008, lo: 0x81, hi: 0x82},
+	{value: 0x0040, lo: 0x83, hi: 0x85},
+	{value: 0x3008, lo: 0x86, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x3008, lo: 0x8a, hi: 0x8c},
+	{value: 0x3b08, lo: 0x8d, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x96},
+	{value: 0x3008, lo: 0x97, hi: 0x97},
+	{value: 0x0040, lo: 0x98, hi: 0xa5},
+	{value: 0x0008, lo: 0xa6, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbf},
+	// Block 0x11, offset 0xa3
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x3308, lo: 0x80, hi: 0x80},
+	{value: 0x3008, lo: 0x81, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8d},
+	{value: 0x0008, lo: 0x8e, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x91},
+	{value: 0x0008, lo: 0x92, hi: 0xa8},
+	{value: 0x0040, lo: 0xa9, hi: 0xa9},
+	{value: 0x0008, lo: 0xaa, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbd},
+	{value: 0x3308, lo: 0xbe, hi: 0xbf},
+	// Block 0x12, offset 0xb1
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x3308, lo: 0x80, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8d},
+	{value: 0x0008, lo: 0x8e, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x91},
+	{value: 0x0008, lo: 0x92, hi: 0xba},
+	{value: 0x3b08, lo: 0xbb, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbf},
+	// Block 0x13, offset 0xbd
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0040, lo: 0x80, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x99},
+	{value: 0x0008, lo: 0x9a, hi: 0xb1},
+	{value: 0x0040, lo: 0xb2, hi: 0xb2},
+	{value: 0x0008, lo: 0xb3, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbf},
+	// Block 0x14, offset 0xc9
+	{value: 0x0000, lo: 0x10},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x89},
+	{value: 0x3b08, lo: 0x8a, hi: 0x8a},
+	{value: 0x0040, lo: 0x8b, hi: 0x8e},
+	{value: 0x3008, lo: 0x8f, hi: 0x91},
+	{value: 0x3308, lo: 0x92, hi: 0x94},
+	{value: 0x0040, lo: 0x95, hi: 0x95},
+	{value: 0x3308, lo: 0x96, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x97},
+	{value: 0x3008, lo: 0x98, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xa5},
+	{value: 0x0008, lo: 0xa6, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xb1},
+	{value: 0x3008, lo: 0xb2, hi: 0xb3},
+	{value: 0x0018, lo: 0xb4, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0x15, offset 0xda
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0xb0},
+	{value: 0x3308, lo: 0xb1, hi: 0xb1},
+	{value: 0x0008, lo: 0xb2, hi: 0xb2},
+	{value: 0x08f1, lo: 0xb3, hi: 0xb3},
+	{value: 0x3308, lo: 0xb4, hi: 0xb9},
+	{value: 0x3b08, lo: 0xba, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbe},
+	{value: 0x0018, lo: 0xbf, hi: 0xbf},
+	// Block 0x16, offset 0xe4
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x3308, lo: 0x87, hi: 0x8e},
+	{value: 0x0018, lo: 0x8f, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0x9b},
+	{value: 0x0040, lo: 0x9c, hi: 0xbf},
+	// Block 0x17, offset 0xeb
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x84},
+	{value: 0x0040, lo: 0x85, hi: 0x85},
+	{value: 0x0008, lo: 0x86, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x87},
+	{value: 0x3308, lo: 0x88, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9b},
+	{value: 0x0961, lo: 0x9c, hi: 0x9c},
+	{value: 0x0999, lo: 0x9d, hi: 0x9d},
+	{value: 0x0008, lo: 0x9e, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xbf},
+	// Block 0x18, offset 0xf8
+	{value: 0x0000, lo: 0x10},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x8a},
+	{value: 0x0008, lo: 0x8b, hi: 0x8b},
+	{value: 0xe03d, lo: 0x8c, hi: 0x8c},
+	{value: 0x0018, lo: 0x8d, hi: 0x97},
+	{value: 0x3308, lo: 0x98, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa9},
+	{value: 0x0018, lo: 0xaa, hi: 0xb4},
+	{value: 0x3308, lo: 0xb5, hi: 0xb5},
+	{value: 0x0018, lo: 0xb6, hi: 0xb6},
+	{value: 0x3308, lo: 0xb7, hi: 0xb7},
+	{value: 0x0018, lo: 0xb8, hi: 0xb8},
+	{value: 0x3308, lo: 0xb9, hi: 0xb9},
+	{value: 0x0018, lo: 0xba, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbf},
+	// Block 0x19, offset 0x109
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0018, lo: 0x80, hi: 0x85},
+	{value: 0x3308, lo: 0x86, hi: 0x86},
+	{value: 0x0018, lo: 0x87, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8d},
+	{value: 0x0018, lo: 0x8e, hi: 0x9a},
+	{value: 0x0040, lo: 0x9b, hi: 0xbf},
+	// Block 0x1a, offset 0x110
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0xaa},
+	{value: 0x3008, lo: 0xab, hi: 0xac},
+	{value: 0x3308, lo: 0xad, hi: 0xb0},
+	{value: 0x3008, lo: 0xb1, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb7},
+	{value: 0x3008, lo: 0xb8, hi: 0xb8},
+	{value: 0x3b08, lo: 0xb9, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbc},
+	{value: 0x3308, lo: 0xbd, hi: 0xbe},
+	{value: 0x0008, lo: 0xbf, hi: 0xbf},
+	// Block 0x1b, offset 0x11b
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x0008, lo: 0x80, hi: 0x89},
+	{value: 0x0018, lo: 0x8a, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x95},
+	{value: 0x3008, lo: 0x96, hi: 0x97},
+	{value: 0x3308, lo: 0x98, hi: 0x99},
+	{value: 0x0008, lo: 0x9a, hi: 0x9d},
+	{value: 0x3308, lo: 0x9e, hi: 0xa0},
+	{value: 0x0008, lo: 0xa1, hi: 0xa1},
+	{value: 0x3008, lo: 0xa2, hi: 0xa4},
+	{value: 0x0008, lo: 0xa5, hi: 0xa6},
+	{value: 0x3008, lo: 0xa7, hi: 0xad},
+	{value: 0x0008, lo: 0xae, hi: 0xb0},
+	{value: 0x3308, lo: 0xb1, hi: 0xb4},
+	{value: 0x0008, lo: 0xb5, hi: 0xbf},
+	// Block 0x1c, offset 0x12a
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x0008, lo: 0x80, hi: 0x81},
+	{value: 0x3308, lo: 0x82, hi: 0x82},
+	{value: 0x3008, lo: 0x83, hi: 0x84},
+	{value: 0x3308, lo: 0x85, hi: 0x86},
+	{value: 0x3008, lo: 0x87, hi: 0x8c},
+	{value: 0x3308, lo: 0x8d, hi: 0x8d},
+	{value: 0x0008, lo: 0x8e, hi: 0x8e},
+	{value: 0x3008, lo: 0x8f, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x3008, lo: 0x9a, hi: 0x9c},
+	{value: 0x3308, lo: 0x9d, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xbf},
+	// Block 0x1d, offset 0x138
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0040, lo: 0x80, hi: 0x86},
+	{value: 0x055d, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8c},
+	{value: 0x055d, lo: 0x8d, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xba},
+	{value: 0x0018, lo: 0xbb, hi: 0xbb},
+	{value: 0xe105, lo: 0xbc, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbf},
+	// Block 0x1e, offset 0x142
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0018, lo: 0x80, hi: 0xbf},
+	// Block 0x1f, offset 0x144
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0xa0},
+	{value: 0x2018, lo: 0xa1, hi: 0xb5},
+	{value: 0x0018, lo: 0xb6, hi: 0xbf},
+	// Block 0x20, offset 0x149
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0xa7},
+	{value: 0x2018, lo: 0xa8, hi: 0xbf},
+	// Block 0x21, offset 0x14c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x2018, lo: 0x80, hi: 0x82},
+	{value: 0x0018, lo: 0x83, hi: 0xbf},
+	// Block 0x22, offset 0x14f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0008, lo: 0x80, hi: 0xbf},
+	// Block 0x23, offset 0x151
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0008, lo: 0x8a, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0x98},
+	{value: 0x0040, lo: 0x99, hi: 0x99},
+	{value: 0x0008, lo: 0x9a, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x24, offset 0x15d
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0008, lo: 0x8a, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xb0},
+	{value: 0x0040, lo: 0xb1, hi: 0xb1},
+	{value: 0x0008, lo: 0xb2, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xb7},
+	{value: 0x0008, lo: 0xb8, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0x25, offset 0x168
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x0040, lo: 0x81, hi: 0x81},
+	{value: 0x0008, lo: 0x82, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x87},
+	{value: 0x0008, lo: 0x88, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0xbf},
+	// Block 0x26, offset 0x170
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x91},
+	{value: 0x0008, lo: 0x92, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0xbf},
+	// Block 0x27, offset 0x176
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0x9a},
+	{value: 0x0040, lo: 0x9b, hi: 0x9c},
+	{value: 0x3308, lo: 0x9d, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbf},
+	// Block 0x28, offset 0x17c
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x29, offset 0x181
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xb7},
+	{value: 0xe045, lo: 0xb8, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbf},
+	// Block 0x2a, offset 0x186
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0xbf},
+	// Block 0x2b, offset 0x189
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xac},
+	{value: 0x0018, lo: 0xad, hi: 0xae},
+	{value: 0x0008, lo: 0xaf, hi: 0xbf},
+	// Block 0x2c, offset 0x18d
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0x9c},
+	{value: 0x0040, lo: 0x9d, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x2d, offset 0x193
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xaa},
+	{value: 0x0018, lo: 0xab, hi: 0xb0},
+	{value: 0x0008, lo: 0xb1, hi: 0xb8},
+	{value: 0x0040, lo: 0xb9, hi: 0xbf},
+	// Block 0x2e, offset 0x198
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8d},
+	{value: 0x0008, lo: 0x8e, hi: 0x91},
+	{value: 0x3308, lo: 0x92, hi: 0x93},
+	{value: 0x3b08, lo: 0x94, hi: 0x94},
+	{value: 0x0040, lo: 0x95, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb3},
+	{value: 0x3b08, lo: 0xb4, hi: 0xb4},
+	{value: 0x0018, lo: 0xb5, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0x2f, offset 0x1a4
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x91},
+	{value: 0x3308, lo: 0x92, hi: 0x93},
+	{value: 0x0040, lo: 0x94, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xad},
+	{value: 0x0008, lo: 0xae, hi: 0xb0},
+	{value: 0x0040, lo: 0xb1, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xbf},
+	// Block 0x30, offset 0x1ae
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0xb3},
+	{value: 0x3340, lo: 0xb4, hi: 0xb5},
+	{value: 0x3008, lo: 0xb6, hi: 0xb6},
+	{value: 0x3308, lo: 0xb7, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbf},
+	// Block 0x31, offset 0x1b4
+	{value: 0x0000, lo: 0x10},
+	{value: 0x3008, lo: 0x80, hi: 0x85},
+	{value: 0x3308, lo: 0x86, hi: 0x86},
+	{value: 0x3008, lo: 0x87, hi: 0x88},
+	{value: 0x3308, lo: 0x89, hi: 0x91},
+	{value: 0x3b08, lo: 0x92, hi: 0x92},
+	{value: 0x3308, lo: 0x93, hi: 0x93},
+	{value: 0x0018, lo: 0x94, hi: 0x96},
+	{value: 0x0008, lo: 0x97, hi: 0x97},
+	{value: 0x0018, lo: 0x98, hi: 0x9b},
+	{value: 0x0008, lo: 0x9c, hi: 0x9c},
+	{value: 0x3308, lo: 0x9d, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa9},
+	{value: 0x0040, lo: 0xaa, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0x32, offset 0x1c5
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0018, lo: 0x80, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x86},
+	{value: 0x0218, lo: 0x87, hi: 0x87},
+	{value: 0x0018, lo: 0x88, hi: 0x8a},
+	{value: 0x33c0, lo: 0x8b, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x0208, lo: 0xa0, hi: 0xbf},
+	// Block 0x33, offset 0x1cf
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0208, lo: 0x80, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbf},
+	// Block 0x34, offset 0x1d2
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0x84},
+	{value: 0x3308, lo: 0x85, hi: 0x86},
+	{value: 0x0208, lo: 0x87, hi: 0xa8},
+	{value: 0x3308, lo: 0xa9, hi: 0xa9},
+	{value: 0x0208, lo: 0xaa, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x35, offset 0x1da
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xbf},
+	// Block 0x36, offset 0x1dd
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0x9f},
+	{value: 0x3308, lo: 0xa0, hi: 0xa2},
+	{value: 0x3008, lo: 0xa3, hi: 0xa6},
+	{value: 0x3308, lo: 0xa7, hi: 0xa8},
+	{value: 0x3008, lo: 0xa9, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xaf},
+	{value: 0x3008, lo: 0xb0, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb2},
+	{value: 0x3008, lo: 0xb3, hi: 0xb8},
+	{value: 0x3308, lo: 0xb9, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbf},
+	// Block 0x37, offset 0x1ea
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0018, lo: 0x80, hi: 0x80},
+	{value: 0x0040, lo: 0x81, hi: 0x83},
+	{value: 0x0018, lo: 0x84, hi: 0x85},
+	{value: 0x0008, lo: 0x86, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0x38, offset 0x1f2
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x39, offset 0x1f6
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0008, lo: 0x80, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0028, lo: 0x9a, hi: 0x9a},
+	{value: 0x0040, lo: 0x9b, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0xbf},
+	// Block 0x3a, offset 0x1fd
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0x96},
+	{value: 0x3308, lo: 0x97, hi: 0x98},
+	{value: 0x3008, lo: 0x99, hi: 0x9a},
+	{value: 0x3308, lo: 0x9b, hi: 0x9b},
+	{value: 0x0040, lo: 0x9c, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x3b, offset 0x205
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x0008, lo: 0x80, hi: 0x94},
+	{value: 0x3008, lo: 0x95, hi: 0x95},
+	{value: 0x3308, lo: 0x96, hi: 0x96},
+	{value: 0x3008, lo: 0x97, hi: 0x97},
+	{value: 0x3308, lo: 0x98, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0x9f},
+	{value: 0x3b08, lo: 0xa0, hi: 0xa0},
+	{value: 0x3008, lo: 0xa1, hi: 0xa1},
+	{value: 0x3308, lo: 0xa2, hi: 0xa2},
+	{value: 0x3008, lo: 0xa3, hi: 0xa4},
+	{value: 0x3308, lo: 0xa5, hi: 0xac},
+	{value: 0x3008, lo: 0xad, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbe},
+	{value: 0x3308, lo: 0xbf, hi: 0xbf},
+	// Block 0x3c, offset 0x215
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xa6},
+	{value: 0x0008, lo: 0xa7, hi: 0xa7},
+	{value: 0x0018, lo: 0xa8, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xbd},
+	{value: 0x3318, lo: 0xbe, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0x3d, offset 0x221
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0040, lo: 0x80, hi: 0xbf},
+	// Block 0x3e, offset 0x223
+	{value: 0x0000, lo: 0x09},
+	{value: 0x3308, lo: 0x80, hi: 0x83},
+	{value: 0x3008, lo: 0x84, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0xb3},
+	{value: 0x3308, lo: 0xb4, hi: 0xb4},
+	{value: 0x3008, lo: 0xb5, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbc},
+	{value: 0x3008, lo: 0xbd, hi: 0xbf},
+	// Block 0x3f, offset 0x22d
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x3008, lo: 0x80, hi: 0x81},
+	{value: 0x3308, lo: 0x82, hi: 0x82},
+	{value: 0x3008, lo: 0x83, hi: 0x83},
+	{value: 0x3808, lo: 0x84, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0xaa},
+	{value: 0x3308, lo: 0xab, hi: 0xb3},
+	{value: 0x0018, lo: 0xb4, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbf},
+	// Block 0x40, offset 0x239
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x3308, lo: 0x80, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0xa0},
+	{value: 0x3008, lo: 0xa1, hi: 0xa1},
+	{value: 0x3308, lo: 0xa2, hi: 0xa5},
+	{value: 0x3008, lo: 0xa6, hi: 0xa7},
+	{value: 0x3308, lo: 0xa8, hi: 0xa9},
+	{value: 0x3808, lo: 0xaa, hi: 0xaa},
+	{value: 0x3b08, lo: 0xab, hi: 0xab},
+	{value: 0x3308, lo: 0xac, hi: 0xad},
+	{value: 0x0008, lo: 0xae, hi: 0xbf},
+	// Block 0x41, offset 0x245
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0xa5},
+	{value: 0x3308, lo: 0xa6, hi: 0xa6},
+	{value: 0x3008, lo: 0xa7, hi: 0xa7},
+	{value: 0x3308, lo: 0xa8, hi: 0xa9},
+	{value: 0x3008, lo: 0xaa, hi: 0xac},
+	{value: 0x3308, lo: 0xad, hi: 0xad},
+	{value: 0x3008, lo: 0xae, hi: 0xae},
+	{value: 0x3308, lo: 0xaf, hi: 0xb1},
+	{value: 0x3808, lo: 0xb2, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xbb},
+	{value: 0x0018, lo: 0xbc, hi: 0xbf},
+	// Block 0x42, offset 0x251
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0xa3},
+	{value: 0x3008, lo: 0xa4, hi: 0xab},
+	{value: 0x3308, lo: 0xac, hi: 0xb3},
+	{value: 0x3008, lo: 0xb4, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xba},
+	{value: 0x0018, lo: 0xbb, hi: 0xbf},
+	// Block 0x43, offset 0x259
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0x8c},
+	{value: 0x0008, lo: 0x8d, hi: 0xbd},
+	{value: 0x0018, lo: 0xbe, hi: 0xbf},
+	// Block 0x44, offset 0x25e
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0e29, lo: 0x80, hi: 0x80},
+	{value: 0x0e41, lo: 0x81, hi: 0x81},
+	{value: 0x0e59, lo: 0x82, hi: 0x82},
+	{value: 0x0e71, lo: 0x83, hi: 0x83},
+	{value: 0x0e89, lo: 0x84, hi: 0x85},
+	{value: 0x0ea1, lo: 0x86, hi: 0x86},
+	{value: 0x0eb9, lo: 0x87, hi: 0x87},
+	{value: 0x057d, lo: 0x88, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0xbf},
+	// Block 0x45, offset 0x268
+	{value: 0x0000, lo: 0x10},
+	{value: 0x0018, lo: 0x80, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x3308, lo: 0x90, hi: 0x92},
+	{value: 0x0018, lo: 0x93, hi: 0x93},
+	{value: 0x3308, lo: 0x94, hi: 0xa0},
+	{value: 0x3008, lo: 0xa1, hi: 0xa1},
+	{value: 0x3308, lo: 0xa2, hi: 0xa8},
+	{value: 0x0008, lo: 0xa9, hi: 0xac},
+	{value: 0x3308, lo: 0xad, hi: 0xad},
+	{value: 0x0008, lo: 0xae, hi: 0xb1},
+	{value: 0x3008, lo: 0xb2, hi: 0xb3},
+	{value: 0x3308, lo: 0xb4, hi: 0xb4},
+	{value: 0x0008, lo: 0xb5, hi: 0xb6},
+	{value: 0x3008, lo: 0xb7, hi: 0xb7},
+	{value: 0x3308, lo: 0xb8, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0x46, offset 0x279
+	{value: 0x0000, lo: 0x03},
+	{value: 0x3308, lo: 0x80, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xba},
+	{value: 0x3308, lo: 0xbb, hi: 0xbf},
+	// Block 0x47, offset 0x27d
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0x87},
+	{value: 0xe045, lo: 0x88, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x97},
+	{value: 0xe045, lo: 0x98, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa7},
+	{value: 0xe045, lo: 0xa8, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb7},
+	{value: 0xe045, lo: 0xb8, hi: 0xbf},
+	// Block 0x48, offset 0x288
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0040, lo: 0x80, hi: 0x8f},
+	{value: 0x3318, lo: 0x90, hi: 0xb0},
+	{value: 0x0040, lo: 0xb1, hi: 0xbf},
+	// Block 0x49, offset 0x28c
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0018, lo: 0x80, hi: 0x82},
+	{value: 0x0040, lo: 0x83, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0x84},
+	{value: 0x0018, lo: 0x85, hi: 0x88},
+	{value: 0x24c1, lo: 0x89, hi: 0x89},
+	{value: 0x0018, lo: 0x8a, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xbf},
+	// Block 0x4a, offset 0x295
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0018, lo: 0x80, hi: 0xab},
+	{value: 0x24f1, lo: 0xac, hi: 0xac},
+	{value: 0x2529, lo: 0xad, hi: 0xad},
+	{value: 0x0018, lo: 0xae, hi: 0xae},
+	{value: 0x2579, lo: 0xaf, hi: 0xaf},
+	{value: 0x25b1, lo: 0xb0, hi: 0xb0},
+	{value: 0x0018, lo: 0xb1, hi: 0xbf},
+	// Block 0x4b, offset 0x29d
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x9f},
+	{value: 0x0080, lo: 0xa0, hi: 0xa0},
+	{value: 0x0018, lo: 0xa1, hi: 0xad},
+	{value: 0x0080, lo: 0xae, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xbf},
+	// Block 0x4c, offset 0x2a3
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0xa8},
+	{value: 0x09c5, lo: 0xa9, hi: 0xa9},
+	{value: 0x09e5, lo: 0xaa, hi: 0xaa},
+	{value: 0x0018, lo: 0xab, hi: 0xbf},
+	// Block 0x4d, offset 0x2a8
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xbf},
+	// Block 0x4e, offset 0x2ab
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0x8b},
+	{value: 0x28c1, lo: 0x8c, hi: 0x8c},
+	{value: 0x0018, lo: 0x8d, hi: 0xbf},
+	// Block 0x4f, offset 0x2af
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0xb3},
+	{value: 0x0e66, lo: 0xb4, hi: 0xb4},
+	{value: 0x292a, lo: 0xb5, hi: 0xb5},
+	{value: 0x0e86, lo: 0xb6, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xbf},
+	// Block 0x50, offset 0x2b5
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0x9b},
+	{value: 0x2941, lo: 0x9c, hi: 0x9c},
+	{value: 0x0018, lo: 0x9d, hi: 0xbf},
+	// Block 0x51, offset 0x2b9
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xb5},
+	{value: 0x0018, lo: 0xb6, hi: 0xbf},
+	// Block 0x52, offset 0x2bd
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x97},
+	{value: 0x0018, lo: 0x98, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbc},
+	{value: 0x0018, lo: 0xbd, hi: 0xbf},
+	// Block 0x53, offset 0x2c3
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0018, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0018, lo: 0x8a, hi: 0x92},
+	{value: 0x0040, lo: 0x93, hi: 0xab},
+	{value: 0x0018, lo: 0xac, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+	// Block 0x54, offset 0x2ca
+	{value: 0x0000, lo: 0x05},
+	{value: 0xe185, lo: 0x80, hi: 0x8f},
+	{value: 0x03f5, lo: 0x90, hi: 0x9f},
+	{value: 0x0ea5, lo: 0xa0, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x55, offset 0x2d0
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0xa5},
+	{value: 0x0040, lo: 0xa6, hi: 0xa6},
+	{value: 0x0008, lo: 0xa7, hi: 0xa7},
+	{value: 0x0040, lo: 0xa8, hi: 0xac},
+	{value: 0x0008, lo: 0xad, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x56, offset 0x2d8
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0008, lo: 0x80, hi: 0xa7},
+	{value: 0x0040, lo: 0xa8, hi: 0xae},
+	{value: 0xe075, lo: 0xaf, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb0},
+	{value: 0x0040, lo: 0xb1, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0x57, offset 0x2df
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xa7},
+	{value: 0x0008, lo: 0xa8, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xb7},
+	{value: 0x0008, lo: 0xb8, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0x58, offset 0x2ea
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x87},
+	{value: 0x0008, lo: 0x88, hi: 0x8e},
+	{value: 0x0040, lo: 0x8f, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0x9f},
+	{value: 0x3308, lo: 0xa0, hi: 0xbf},
+	// Block 0x59, offset 0x2f4
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xae},
+	{value: 0x0008, lo: 0xaf, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xbf},
+	// Block 0x5a, offset 0x2f8
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0xbf},
+	// Block 0x5b, offset 0x2fb
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0x9e},
+	{value: 0x0edd, lo: 0x9f, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xbf},
+	// Block 0x5c, offset 0x301
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xb2},
+	{value: 0x0efd, lo: 0xb3, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xbf},
+	// Block 0x5d, offset 0x305
+	{value: 0x0020, lo: 0x01},
+	{value: 0x0f1d, lo: 0x80, hi: 0xbf},
+	// Block 0x5e, offset 0x307
+	{value: 0x0020, lo: 0x02},
+	{value: 0x171d, lo: 0x80, hi: 0x8f},
+	{value: 0x18fd, lo: 0x90, hi: 0xbf},
+	// Block 0x5f, offset 0x30a
+	{value: 0x0020, lo: 0x01},
+	{value: 0x1efd, lo: 0x80, hi: 0xbf},
+	// Block 0x60, offset 0x30c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0xbf},
+	// Block 0x61, offset 0x30f
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x98},
+	{value: 0x3308, lo: 0x99, hi: 0x9a},
+	{value: 0x29e2, lo: 0x9b, hi: 0x9b},
+	{value: 0x2a0a, lo: 0x9c, hi: 0x9c},
+	{value: 0x0008, lo: 0x9d, hi: 0x9e},
+	{value: 0x2a31, lo: 0x9f, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xa0},
+	{value: 0x0008, lo: 0xa1, hi: 0xbf},
+	// Block 0x62, offset 0x319
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xbe},
+	{value: 0x2a69, lo: 0xbf, hi: 0xbf},
+	// Block 0x63, offset 0x31c
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x0040, lo: 0x80, hi: 0x84},
+	{value: 0x0008, lo: 0x85, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xb0},
+	{value: 0x2a1d, lo: 0xb1, hi: 0xb1},
+	{value: 0x2a3d, lo: 0xb2, hi: 0xb2},
+	{value: 0x2a5d, lo: 0xb3, hi: 0xb3},
+	{value: 0x2a7d, lo: 0xb4, hi: 0xb4},
+	{value: 0x2a5d, lo: 0xb5, hi: 0xb5},
+	{value: 0x2a9d, lo: 0xb6, hi: 0xb6},
+	{value: 0x2abd, lo: 0xb7, hi: 0xb7},
+	{value: 0x2add, lo: 0xb8, hi: 0xb9},
+	{value: 0x2afd, lo: 0xba, hi: 0xbb},
+	{value: 0x2b1d, lo: 0xbc, hi: 0xbd},
+	{value: 0x2afd, lo: 0xbe, hi: 0xbf},
+	// Block 0x64, offset 0x32b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xa3},
+	{value: 0x0040, lo: 0xa4, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x65, offset 0x32f
+	{value: 0x0030, lo: 0x04},
+	{value: 0x2aa2, lo: 0x80, hi: 0x9d},
+	{value: 0x305a, lo: 0x9e, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0x9f},
+	{value: 0x30a2, lo: 0xa0, hi: 0xbf},
+	// Block 0x66, offset 0x334
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xbf},
+	// Block 0x67, offset 0x337
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xbf},
+	// Block 0x68, offset 0x33b
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xbd},
+	{value: 0x0018, lo: 0xbe, hi: 0xbf},
+	// Block 0x69, offset 0x340
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x8c},
+	{value: 0x0018, lo: 0x8d, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xbf},
+	// Block 0x6a, offset 0x345
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0xa5},
+	{value: 0x0018, lo: 0xa6, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb1},
+	{value: 0x0018, lo: 0xb2, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbf},
+	// Block 0x6b, offset 0x34b
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0040, lo: 0x80, hi: 0xb6},
+	{value: 0x0008, lo: 0xb7, hi: 0xb7},
+	{value: 0x2009, lo: 0xb8, hi: 0xb8},
+	{value: 0x6e89, lo: 0xb9, hi: 0xb9},
+	{value: 0x0008, lo: 0xba, hi: 0xbf},
+	// Block 0x6c, offset 0x351
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x0008, lo: 0x80, hi: 0x81},
+	{value: 0x3308, lo: 0x82, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0x85},
+	{value: 0x3b08, lo: 0x86, hi: 0x86},
+	{value: 0x0008, lo: 0x87, hi: 0x8a},
+	{value: 0x3308, lo: 0x8b, hi: 0x8b},
+	{value: 0x0008, lo: 0x8c, hi: 0xa2},
+	{value: 0x3008, lo: 0xa3, hi: 0xa4},
+	{value: 0x3308, lo: 0xa5, hi: 0xa6},
+	{value: 0x3008, lo: 0xa7, hi: 0xa7},
+	{value: 0x0018, lo: 0xa8, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0x6d, offset 0x360
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0208, lo: 0x80, hi: 0xb1},
+	{value: 0x0108, lo: 0xb2, hi: 0xb2},
+	{value: 0x0008, lo: 0xb3, hi: 0xb3},
+	{value: 0x0018, lo: 0xb4, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbf},
+	// Block 0x6e, offset 0x366
+	{value: 0x0000, lo: 0x03},
+	{value: 0x3008, lo: 0x80, hi: 0x81},
+	{value: 0x0008, lo: 0x82, hi: 0xb3},
+	{value: 0x3008, lo: 0xb4, hi: 0xbf},
+	// Block 0x6f, offset 0x36a
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x3008, lo: 0x80, hi: 0x83},
+	{value: 0x3b08, lo: 0x84, hi: 0x84},
+	{value: 0x3308, lo: 0x85, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x8d},
+	{value: 0x0018, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x3308, lo: 0xa0, hi: 0xb1},
+	{value: 0x0008, lo: 0xb2, hi: 0xb7},
+	{value: 0x0018, lo: 0xb8, hi: 0xba},
+	{value: 0x0008, lo: 0xbb, hi: 0xbb},
+	{value: 0x0018, lo: 0xbc, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbf},
+	// Block 0x70, offset 0x379
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xa5},
+	{value: 0x3308, lo: 0xa6, hi: 0xad},
+	{value: 0x0018, lo: 0xae, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x71, offset 0x37e
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x3308, lo: 0x87, hi: 0x91},
+	{value: 0x3008, lo: 0x92, hi: 0x92},
+	{value: 0x3808, lo: 0x93, hi: 0x93},
+	{value: 0x0040, lo: 0x94, hi: 0x9e},
+	{value: 0x0018, lo: 0x9f, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbf},
+	// Block 0x72, offset 0x386
+	{value: 0x0000, lo: 0x09},
+	{value: 0x3308, lo: 0x80, hi: 0x82},
+	{value: 0x3008, lo: 0x83, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xb3},
+	{value: 0x3008, lo: 0xb4, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xb9},
+	{value: 0x3008, lo: 0xba, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbc},
+	{value: 0x3008, lo: 0xbd, hi: 0xbf},
+	// Block 0x73, offset 0x390
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x3808, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8e},
+	{value: 0x0008, lo: 0x8f, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa4},
+	{value: 0x3308, lo: 0xa5, hi: 0xa5},
+	{value: 0x0008, lo: 0xa6, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0x74, offset 0x39b
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0xa8},
+	{value: 0x3308, lo: 0xa9, hi: 0xae},
+	{value: 0x3008, lo: 0xaf, hi: 0xb0},
+	{value: 0x3308, lo: 0xb1, hi: 0xb2},
+	{value: 0x3008, lo: 0xb3, hi: 0xb4},
+	{value: 0x3308, lo: 0xb5, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0x75, offset 0x3a3
+	{value: 0x0000, lo: 0x10},
+	{value: 0x0008, lo: 0x80, hi: 0x82},
+	{value: 0x3308, lo: 0x83, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0x8b},
+	{value: 0x3308, lo: 0x8c, hi: 0x8c},
+	{value: 0x3008, lo: 0x8d, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9b},
+	{value: 0x0018, lo: 0x9c, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xb9},
+	{value: 0x0008, lo: 0xba, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbc},
+	{value: 0x3008, lo: 0xbd, hi: 0xbd},
+	{value: 0x0008, lo: 0xbe, hi: 0xbf},
+	// Block 0x76, offset 0x3b4
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0008, lo: 0x80, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb0},
+	{value: 0x0008, lo: 0xb1, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb4},
+	{value: 0x0008, lo: 0xb5, hi: 0xb6},
+	{value: 0x3308, lo: 0xb7, hi: 0xb8},
+	{value: 0x0008, lo: 0xb9, hi: 0xbd},
+	{value: 0x3308, lo: 0xbe, hi: 0xbf},
+	// Block 0x77, offset 0x3bd
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x3308, lo: 0x81, hi: 0x81},
+	{value: 0x0008, lo: 0x82, hi: 0x82},
+	{value: 0x0040, lo: 0x83, hi: 0x9a},
+	{value: 0x0008, lo: 0x9b, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xaa},
+	{value: 0x3008, lo: 0xab, hi: 0xab},
+	{value: 0x3308, lo: 0xac, hi: 0xad},
+	{value: 0x3008, lo: 0xae, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb1},
+	{value: 0x0008, lo: 0xb2, hi: 0xb4},
+	{value: 0x3008, lo: 0xb5, hi: 0xb5},
+	{value: 0x3b08, lo: 0xb6, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0x78, offset 0x3cd
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x88},
+	{value: 0x0008, lo: 0x89, hi: 0x8e},
+	{value: 0x0040, lo: 0x8f, hi: 0x90},
+	{value: 0x0008, lo: 0x91, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xa7},
+	{value: 0x0008, lo: 0xa8, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x79, offset 0x3da
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0x9b},
+	{value: 0x4465, lo: 0x9c, hi: 0x9c},
+	{value: 0x447d, lo: 0x9d, hi: 0x9d},
+	{value: 0x2971, lo: 0x9e, hi: 0x9e},
+	{value: 0xe06d, lo: 0x9f, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa5},
+	{value: 0x0040, lo: 0xa6, hi: 0xaf},
+	{value: 0x4495, lo: 0xb0, hi: 0xbf},
+	// Block 0x7a, offset 0x3e4
+	{value: 0x0000, lo: 0x04},
+	{value: 0x44b5, lo: 0x80, hi: 0x8f},
+	{value: 0x44d5, lo: 0x90, hi: 0x9f},
+	{value: 0x44f5, lo: 0xa0, hi: 0xaf},
+	{value: 0x44d5, lo: 0xb0, hi: 0xbf},
+	// Block 0x7b, offset 0x3e9
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0xa2},
+	{value: 0x3008, lo: 0xa3, hi: 0xa4},
+	{value: 0x3308, lo: 0xa5, hi: 0xa5},
+	{value: 0x3008, lo: 0xa6, hi: 0xa7},
+	{value: 0x3308, lo: 0xa8, hi: 0xa8},
+	{value: 0x3008, lo: 0xa9, hi: 0xaa},
+	{value: 0x0018, lo: 0xab, hi: 0xab},
+	{value: 0x3008, lo: 0xac, hi: 0xac},
+	{value: 0x3b08, lo: 0xad, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0x7c, offset 0x3f6
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xa3},
+	{value: 0x0040, lo: 0xa4, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xbf},
+	// Block 0x7d, offset 0x3fa
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x8a},
+	{value: 0x0018, lo: 0x8b, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbf},
+	// Block 0x7e, offset 0x3ff
+	{value: 0x0020, lo: 0x01},
+	{value: 0x4515, lo: 0x80, hi: 0xbf},
+	// Block 0x7f, offset 0x401
+	{value: 0x0020, lo: 0x03},
+	{value: 0x4d15, lo: 0x80, hi: 0x94},
+	{value: 0x4ad5, lo: 0x95, hi: 0x95},
+	{value: 0x4fb5, lo: 0x96, hi: 0xbf},
+	// Block 0x80, offset 0x405
+	{value: 0x0020, lo: 0x01},
+	{value: 0x54f5, lo: 0x80, hi: 0xbf},
+	// Block 0x81, offset 0x407
+	{value: 0x0020, lo: 0x03},
+	{value: 0x5cf5, lo: 0x80, hi: 0x84},
+	{value: 0x5655, lo: 0x85, hi: 0x85},
+	{value: 0x5d95, lo: 0x86, hi: 0xbf},
+	// Block 0x82, offset 0x40b
+	{value: 0x0020, lo: 0x08},
+	{value: 0x6b55, lo: 0x80, hi: 0x8f},
+	{value: 0x6d15, lo: 0x90, hi: 0x90},
+	{value: 0x6d55, lo: 0x91, hi: 0xab},
+	{value: 0x6ea1, lo: 0xac, hi: 0xac},
+	{value: 0x70b5, lo: 0xad, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xaf},
+	{value: 0x70d5, lo: 0xb0, hi: 0xbf},
+	// Block 0x83, offset 0x414
+	{value: 0x0020, lo: 0x05},
+	{value: 0x72d5, lo: 0x80, hi: 0xad},
+	{value: 0x6535, lo: 0xae, hi: 0xae},
+	{value: 0x7895, lo: 0xaf, hi: 0xb5},
+	{value: 0x6f55, lo: 0xb6, hi: 0xb6},
+	{value: 0x7975, lo: 0xb7, hi: 0xbf},
+	// Block 0x84, offset 0x41a
+	{value: 0x0028, lo: 0x03},
+	{value: 0x7c21, lo: 0x80, hi: 0x82},
+	{value: 0x7be1, lo: 0x83, hi: 0x83},
+	{value: 0x7c99, lo: 0x84, hi: 0xbf},
+	// Block 0x85, offset 0x41e
+	{value: 0x0038, lo: 0x0f},
+	{value: 0x9db1, lo: 0x80, hi: 0x83},
+	{value: 0x9e59, lo: 0x84, hi: 0x85},
+	{value: 0x9e91, lo: 0x86, hi: 0x87},
+	{value: 0x9ec9, lo: 0x88, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x91},
+	{value: 0xa089, lo: 0x92, hi: 0x97},
+	{value: 0xa1a1, lo: 0x98, hi: 0x9c},
+	{value: 0xa281, lo: 0x9d, hi: 0xb3},
+	{value: 0x9d41, lo: 0xb4, hi: 0xb4},
+	{value: 0x9db1, lo: 0xb5, hi: 0xb5},
+	{value: 0xa789, lo: 0xb6, hi: 0xbb},
+	{value: 0xa869, lo: 0xbc, hi: 0xbc},
+	{value: 0xa7f9, lo: 0xbd, hi: 0xbd},
+	{value: 0xa8d9, lo: 0xbe, hi: 0xbf},
+	// Block 0x86, offset 0x42e
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x8c},
+	{value: 0x0008, lo: 0x8d, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xa7},
+	{value: 0x0008, lo: 0xa8, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbb},
+	{value: 0x0008, lo: 0xbc, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbe},
+	{value: 0x0008, lo: 0xbf, hi: 0xbf},
+	// Block 0x87, offset 0x438
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0xbf},
+	// Block 0x88, offset 0x43d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbf},
+	// Block 0x89, offset 0x440
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x82},
+	{value: 0x0040, lo: 0x83, hi: 0x86},
+	{value: 0x0018, lo: 0x87, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xbf},
+	// Block 0x8a, offset 0x446
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0018, lo: 0x80, hi: 0x8e},
+	{value: 0x0040, lo: 0x8f, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0x9b},
+	{value: 0x0040, lo: 0x9c, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xa0},
+	{value: 0x0040, lo: 0xa1, hi: 0xbf},
+	// Block 0x8b, offset 0x44d
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0040, lo: 0x80, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xbc},
+	{value: 0x3308, lo: 0xbd, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbf},
+	// Block 0x8c, offset 0x452
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0x9c},
+	{value: 0x0040, lo: 0x9d, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x8d, offset 0x456
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0x90},
+	{value: 0x0040, lo: 0x91, hi: 0x9f},
+	{value: 0x3308, lo: 0xa0, hi: 0xa0},
+	{value: 0x0018, lo: 0xa1, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbf},
+	// Block 0x8e, offset 0x45c
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xa3},
+	{value: 0x0040, lo: 0xa4, hi: 0xac},
+	{value: 0x0008, lo: 0xad, hi: 0xbf},
+	// Block 0x8f, offset 0x461
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x81},
+	{value: 0x0008, lo: 0x82, hi: 0x89},
+	{value: 0x0018, lo: 0x8a, hi: 0x8a},
+	{value: 0x0040, lo: 0x8b, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbf},
+	// Block 0x90, offset 0x46a
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9e},
+	{value: 0x0018, lo: 0x9f, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x91, offset 0x46f
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x87},
+	{value: 0x0008, lo: 0x88, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0xbf},
+	// Block 0x92, offset 0x475
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe145, lo: 0x80, hi: 0x87},
+	{value: 0xe1c5, lo: 0x88, hi: 0x8f},
+	{value: 0xe145, lo: 0x90, hi: 0x97},
+	{value: 0x8ad5, lo: 0x98, hi: 0x9f},
+	{value: 0x8aed, lo: 0xa0, hi: 0xa7},
+	{value: 0x0008, lo: 0xa8, hi: 0xbf},
+	// Block 0x93, offset 0x47c
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0008, lo: 0x80, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa9},
+	{value: 0x0040, lo: 0xaa, hi: 0xaf},
+	{value: 0x8aed, lo: 0xb0, hi: 0xb7},
+	{value: 0x8ad5, lo: 0xb8, hi: 0xbf},
+	// Block 0x94, offset 0x483
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe145, lo: 0x80, hi: 0x87},
+	{value: 0xe1c5, lo: 0x88, hi: 0x8f},
+	{value: 0xe145, lo: 0x90, hi: 0x93},
+	{value: 0x0040, lo: 0x94, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbf},
+	// Block 0x95, offset 0x48a
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xa7},
+	{value: 0x0040, lo: 0xa8, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x96, offset 0x48e
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xa3},
+	{value: 0x0040, lo: 0xa4, hi: 0xae},
+	{value: 0x0018, lo: 0xaf, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+	// Block 0x97, offset 0x493
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0x98, offset 0x496
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa7},
+	{value: 0x0040, lo: 0xa8, hi: 0xbf},
+	// Block 0x99, offset 0x49b
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0808, lo: 0x80, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x87},
+	{value: 0x0808, lo: 0x88, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0808, lo: 0x8a, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xb6},
+	{value: 0x0808, lo: 0xb7, hi: 0xb8},
+	{value: 0x0040, lo: 0xb9, hi: 0xbb},
+	{value: 0x0808, lo: 0xbc, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbe},
+	{value: 0x0808, lo: 0xbf, hi: 0xbf},
+	// Block 0x9a, offset 0x4a7
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0808, lo: 0x80, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x96},
+	{value: 0x0818, lo: 0x97, hi: 0x9f},
+	{value: 0x0808, lo: 0xa0, hi: 0xb6},
+	{value: 0x0818, lo: 0xb7, hi: 0xbf},
+	// Block 0x9b, offset 0x4ad
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0808, lo: 0x80, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0xa6},
+	{value: 0x0818, lo: 0xa7, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+	// Block 0x9c, offset 0x4b2
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0040, lo: 0x80, hi: 0x9f},
+	{value: 0x0808, lo: 0xa0, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xb3},
+	{value: 0x0808, lo: 0xb4, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xba},
+	{value: 0x0818, lo: 0xbb, hi: 0xbf},
+	// Block 0x9d, offset 0x4b9
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0808, lo: 0x80, hi: 0x95},
+	{value: 0x0818, lo: 0x96, hi: 0x9b},
+	{value: 0x0040, lo: 0x9c, hi: 0x9e},
+	{value: 0x0018, lo: 0x9f, hi: 0x9f},
+	{value: 0x0808, lo: 0xa0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbe},
+	{value: 0x0818, lo: 0xbf, hi: 0xbf},
+	// Block 0x9e, offset 0x4c1
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0808, lo: 0x80, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbb},
+	{value: 0x0818, lo: 0xbc, hi: 0xbd},
+	{value: 0x0808, lo: 0xbe, hi: 0xbf},
+	// Block 0x9f, offset 0x4c6
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0818, lo: 0x80, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0x91},
+	{value: 0x0818, lo: 0x92, hi: 0xbf},
+	// Block 0xa0, offset 0x4ca
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x0808, lo: 0x80, hi: 0x80},
+	{value: 0x3308, lo: 0x81, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x84},
+	{value: 0x3308, lo: 0x85, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x8b},
+	{value: 0x3308, lo: 0x8c, hi: 0x8f},
+	{value: 0x0808, lo: 0x90, hi: 0x93},
+	{value: 0x0040, lo: 0x94, hi: 0x94},
+	{value: 0x0808, lo: 0x95, hi: 0x97},
+	{value: 0x0040, lo: 0x98, hi: 0x98},
+	{value: 0x0808, lo: 0x99, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xb7},
+	{value: 0x3308, lo: 0xb8, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0xa1, offset 0x4da
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0818, lo: 0x80, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0818, lo: 0x90, hi: 0x98},
+	{value: 0x0040, lo: 0x99, hi: 0x9f},
+	{value: 0x0808, lo: 0xa0, hi: 0xbc},
+	{value: 0x0818, lo: 0xbd, hi: 0xbf},
+	// Block 0xa2, offset 0x4e1
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0808, lo: 0x80, hi: 0x9c},
+	{value: 0x0818, lo: 0x9d, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xbf},
+	// Block 0xa3, offset 0x4e5
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0808, lo: 0x80, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xb8},
+	{value: 0x0018, lo: 0xb9, hi: 0xbf},
+	// Block 0xa4, offset 0x4e9
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0808, lo: 0x80, hi: 0x95},
+	{value: 0x0040, lo: 0x96, hi: 0x97},
+	{value: 0x0818, lo: 0x98, hi: 0x9f},
+	{value: 0x0808, lo: 0xa0, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xb7},
+	{value: 0x0818, lo: 0xb8, hi: 0xbf},
+	// Block 0xa5, offset 0x4f0
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0808, lo: 0x80, hi: 0xbf},
+	// Block 0xa6, offset 0x4f2
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0808, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0xbf},
+	// Block 0xa7, offset 0x4f5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x03dd, lo: 0x80, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xbf},
+	// Block 0xa8, offset 0x4f8
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0808, lo: 0x80, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xb9},
+	{value: 0x0818, lo: 0xba, hi: 0xbf},
+	// Block 0xa9, offset 0x4fc
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0040, lo: 0x80, hi: 0x9f},
+	{value: 0x0818, lo: 0xa0, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0xaa, offset 0x500
+	{value: 0x0000, lo: 0x05},
+	{value: 0x3008, lo: 0x80, hi: 0x80},
+	{value: 0x3308, lo: 0x81, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0xb7},
+	{value: 0x3308, lo: 0xb8, hi: 0xbf},
+	// Block 0xab, offset 0x506
+	{value: 0x0000, lo: 0x08},
+	{value: 0x3308, lo: 0x80, hi: 0x85},
+	{value: 0x3b08, lo: 0x86, hi: 0x86},
+	{value: 0x0018, lo: 0x87, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x91},
+	{value: 0x0018, lo: 0x92, hi: 0xa5},
+	{value: 0x0008, lo: 0xa6, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0xac, offset 0x50f
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x3308, lo: 0x80, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0xaf},
+	{value: 0x3008, lo: 0xb0, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xb6},
+	{value: 0x3008, lo: 0xb7, hi: 0xb8},
+	{value: 0x3b08, lo: 0xb9, hi: 0xb9},
+	{value: 0x3308, lo: 0xba, hi: 0xba},
+	{value: 0x0018, lo: 0xbb, hi: 0xbc},
+	{value: 0x0340, lo: 0xbd, hi: 0xbd},
+	{value: 0x0018, lo: 0xbe, hi: 0xbf},
+	// Block 0xad, offset 0x51b
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0018, lo: 0x80, hi: 0x81},
+	{value: 0x0040, lo: 0x82, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xa8},
+	{value: 0x0040, lo: 0xa9, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0xae, offset 0x522
+	{value: 0x0000, lo: 0x08},
+	{value: 0x3308, lo: 0x80, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0xa6},
+	{value: 0x3308, lo: 0xa7, hi: 0xab},
+	{value: 0x3008, lo: 0xac, hi: 0xac},
+	{value: 0x3308, lo: 0xad, hi: 0xb2},
+	{value: 0x3b08, lo: 0xb3, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xb5},
+	{value: 0x0008, lo: 0xb6, hi: 0xbf},
+	// Block 0xaf, offset 0x52b
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0018, lo: 0x80, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xb3},
+	{value: 0x0018, lo: 0xb4, hi: 0xb5},
+	{value: 0x0008, lo: 0xb6, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0xb0, offset 0x533
+	{value: 0x0000, lo: 0x06},
+	{value: 0x3308, lo: 0x80, hi: 0x81},
+	{value: 0x3008, lo: 0x82, hi: 0x82},
+	{value: 0x0008, lo: 0x83, hi: 0xb2},
+	{value: 0x3008, lo: 0xb3, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xbe},
+	{value: 0x3008, lo: 0xbf, hi: 0xbf},
+	// Block 0xb1, offset 0x53a
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x3808, lo: 0x80, hi: 0x80},
+	{value: 0x0008, lo: 0x81, hi: 0x84},
+	{value: 0x0018, lo: 0x85, hi: 0x89},
+	{value: 0x3308, lo: 0x8a, hi: 0x8c},
+	{value: 0x0018, lo: 0x8d, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0x9b},
+	{value: 0x0008, lo: 0x9c, hi: 0x9c},
+	{value: 0x0018, lo: 0x9d, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xa0},
+	{value: 0x0018, lo: 0xa1, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0xb2, offset 0x548
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x91},
+	{value: 0x0040, lo: 0x92, hi: 0x92},
+	{value: 0x0008, lo: 0x93, hi: 0xab},
+	{value: 0x3008, lo: 0xac, hi: 0xae},
+	{value: 0x3308, lo: 0xaf, hi: 0xb1},
+	{value: 0x3008, lo: 0xb2, hi: 0xb3},
+	{value: 0x3308, lo: 0xb4, hi: 0xb4},
+	{value: 0x3808, lo: 0xb5, hi: 0xb5},
+	{value: 0x3308, lo: 0xb6, hi: 0xb7},
+	{value: 0x0018, lo: 0xb8, hi: 0xbd},
+	{value: 0x3308, lo: 0xbe, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0xb3, offset 0x555
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x87},
+	{value: 0x0008, lo: 0x88, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0008, lo: 0x8a, hi: 0x8d},
+	{value: 0x0040, lo: 0x8e, hi: 0x8e},
+	{value: 0x0008, lo: 0x8f, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9e},
+	{value: 0x0008, lo: 0x9f, hi: 0xa8},
+	{value: 0x0018, lo: 0xa9, hi: 0xa9},
+	{value: 0x0040, lo: 0xaa, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0xb4, offset 0x562
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0008, lo: 0x80, hi: 0x9e},
+	{value: 0x3308, lo: 0x9f, hi: 0x9f},
+	{value: 0x3008, lo: 0xa0, hi: 0xa2},
+	{value: 0x3308, lo: 0xa3, hi: 0xa9},
+	{value: 0x3b08, lo: 0xaa, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb9},
+	{value: 0x0040, lo: 0xba, hi: 0xbf},
+	// Block 0xb5, offset 0x56b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xb4},
+	{value: 0x3008, lo: 0xb5, hi: 0xb7},
+	{value: 0x3308, lo: 0xb8, hi: 0xbf},
+	// Block 0xb6, offset 0x56f
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x3008, lo: 0x80, hi: 0x81},
+	{value: 0x3b08, lo: 0x82, hi: 0x82},
+	{value: 0x3308, lo: 0x83, hi: 0x84},
+	{value: 0x3008, lo: 0x85, hi: 0x85},
+	{value: 0x3308, lo: 0x86, hi: 0x86},
+	{value: 0x0008, lo: 0x87, hi: 0x8a},
+	{value: 0x0018, lo: 0x8b, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0x9b},
+	{value: 0x0040, lo: 0x9c, hi: 0x9c},
+	{value: 0x0018, lo: 0x9d, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0xbf},
+	// Block 0xb7, offset 0x57d
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0xaf},
+	{value: 0x3008, lo: 0xb0, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xb8},
+	{value: 0x3008, lo: 0xb9, hi: 0xb9},
+	{value: 0x3308, lo: 0xba, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbe},
+	{value: 0x3308, lo: 0xbf, hi: 0xbf},
+	// Block 0xb8, offset 0x585
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x3308, lo: 0x80, hi: 0x80},
+	{value: 0x3008, lo: 0x81, hi: 0x81},
+	{value: 0x3b08, lo: 0x82, hi: 0x82},
+	{value: 0x3308, lo: 0x83, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0x85},
+	{value: 0x0018, lo: 0x86, hi: 0x86},
+	{value: 0x0008, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0xbf},
+	// Block 0xb9, offset 0x590
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0008, lo: 0x80, hi: 0xae},
+	{value: 0x3008, lo: 0xaf, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xb7},
+	{value: 0x3008, lo: 0xb8, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0xba, offset 0x599
+	{value: 0x0000, lo: 0x05},
+	{value: 0x3308, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x97},
+	{value: 0x0008, lo: 0x98, hi: 0x9b},
+	{value: 0x3308, lo: 0x9c, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0xbf},
+	// Block 0xbb, offset 0x59f
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0008, lo: 0x80, hi: 0xaf},
+	{value: 0x3008, lo: 0xb0, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xba},
+	{value: 0x3008, lo: 0xbb, hi: 0xbc},
+	{value: 0x3308, lo: 0xbd, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0xbc, offset 0x5a7
+	{value: 0x0000, lo: 0x08},
+	{value: 0x3308, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x83},
+	{value: 0x0008, lo: 0x84, hi: 0x84},
+	{value: 0x0040, lo: 0x85, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xbf},
+	// Block 0xbd, offset 0x5b0
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0xaa},
+	{value: 0x3308, lo: 0xab, hi: 0xab},
+	{value: 0x3008, lo: 0xac, hi: 0xac},
+	{value: 0x3308, lo: 0xad, hi: 0xad},
+	{value: 0x3008, lo: 0xae, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb5},
+	{value: 0x3808, lo: 0xb6, hi: 0xb6},
+	{value: 0x3308, lo: 0xb7, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbf},
+	// Block 0xbe, offset 0x5ba
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0xbf},
+	// Block 0xbf, offset 0x5bd
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9c},
+	{value: 0x3308, lo: 0x9d, hi: 0x9f},
+	{value: 0x3008, lo: 0xa0, hi: 0xa1},
+	{value: 0x3308, lo: 0xa2, hi: 0xa5},
+	{value: 0x3008, lo: 0xa6, hi: 0xa6},
+	{value: 0x3308, lo: 0xa7, hi: 0xaa},
+	{value: 0x3b08, lo: 0xab, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xb9},
+	{value: 0x0018, lo: 0xba, hi: 0xbf},
+	// Block 0xc0, offset 0x5c9
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0040, lo: 0x80, hi: 0x9f},
+	{value: 0x049d, lo: 0xa0, hi: 0xbf},
+	// Block 0xc1, offset 0x5cc
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xa9},
+	{value: 0x0018, lo: 0xaa, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xbe},
+	{value: 0x0008, lo: 0xbf, hi: 0xbf},
+	// Block 0xc2, offset 0x5d1
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x3308, lo: 0x81, hi: 0x86},
+	{value: 0x3008, lo: 0x87, hi: 0x88},
+	{value: 0x3308, lo: 0x89, hi: 0x8a},
+	{value: 0x0008, lo: 0x8b, hi: 0xb2},
+	{value: 0x3308, lo: 0xb3, hi: 0xb3},
+	{value: 0x3b08, lo: 0xb4, hi: 0xb4},
+	{value: 0x3308, lo: 0xb5, hi: 0xb8},
+	{value: 0x3008, lo: 0xb9, hi: 0xb9},
+	{value: 0x0008, lo: 0xba, hi: 0xba},
+	{value: 0x3308, lo: 0xbb, hi: 0xbe},
+	{value: 0x0018, lo: 0xbf, hi: 0xbf},
+	// Block 0xc3, offset 0x5de
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0018, lo: 0x80, hi: 0x86},
+	{value: 0x3b08, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x90},
+	{value: 0x3308, lo: 0x91, hi: 0x96},
+	{value: 0x3008, lo: 0x97, hi: 0x98},
+	{value: 0x3308, lo: 0x99, hi: 0x9b},
+	{value: 0x0008, lo: 0x9c, hi: 0xbf},
+	// Block 0xc4, offset 0x5e7
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0x85},
+	{value: 0x0008, lo: 0x86, hi: 0x89},
+	{value: 0x3308, lo: 0x8a, hi: 0x96},
+	{value: 0x3008, lo: 0x97, hi: 0x97},
+	{value: 0x3308, lo: 0x98, hi: 0x98},
+	{value: 0x3b08, lo: 0x99, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0x9c},
+	{value: 0x0040, lo: 0x9d, hi: 0x9d},
+	{value: 0x0018, lo: 0x9e, hi: 0xa2},
+	{value: 0x0040, lo: 0xa3, hi: 0xbf},
+	// Block 0xc5, offset 0x5f3
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xb8},
+	{value: 0x0040, lo: 0xb9, hi: 0xbf},
+	// Block 0xc6, offset 0x5f6
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x89},
+	{value: 0x0008, lo: 0x8a, hi: 0xae},
+	{value: 0x3008, lo: 0xaf, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xb7},
+	{value: 0x3308, lo: 0xb8, hi: 0xbd},
+	{value: 0x3008, lo: 0xbe, hi: 0xbe},
+	{value: 0x3b08, lo: 0xbf, hi: 0xbf},
+	// Block 0xc7, offset 0x600
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0008, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0018, lo: 0x9a, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb1},
+	{value: 0x0008, lo: 0xb2, hi: 0xbf},
+	// Block 0xc8, offset 0x609
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x0008, lo: 0x80, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0x91},
+	{value: 0x3308, lo: 0x92, hi: 0xa7},
+	{value: 0x0040, lo: 0xa8, hi: 0xa8},
+	{value: 0x3008, lo: 0xa9, hi: 0xa9},
+	{value: 0x3308, lo: 0xaa, hi: 0xb0},
+	{value: 0x3008, lo: 0xb1, hi: 0xb1},
+	{value: 0x3308, lo: 0xb2, hi: 0xb3},
+	{value: 0x3008, lo: 0xb4, hi: 0xb4},
+	{value: 0x3308, lo: 0xb5, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xbf},
+	// Block 0xc9, offset 0x615
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x87},
+	{value: 0x0008, lo: 0x88, hi: 0x89},
+	{value: 0x0040, lo: 0x8a, hi: 0x8a},
+	{value: 0x0008, lo: 0x8b, hi: 0xb0},
+	{value: 0x3308, lo: 0xb1, hi: 0xb6},
+	{value: 0x0040, lo: 0xb7, hi: 0xb9},
+	{value: 0x3308, lo: 0xba, hi: 0xba},
+	{value: 0x0040, lo: 0xbb, hi: 0xbb},
+	{value: 0x3308, lo: 0xbc, hi: 0xbd},
+	{value: 0x0040, lo: 0xbe, hi: 0xbe},
+	{value: 0x3308, lo: 0xbf, hi: 0xbf},
+	// Block 0xca, offset 0x622
+	{value: 0x0000, lo: 0x07},
+	{value: 0x3308, lo: 0x80, hi: 0x83},
+	{value: 0x3b08, lo: 0x84, hi: 0x85},
+	{value: 0x0008, lo: 0x86, hi: 0x86},
+	{value: 0x3308, lo: 0x87, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0xbf},
+	// Block 0xcb, offset 0x62a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0xbf},
+	// Block 0xcc, offset 0x62d
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0xcd, offset 0x632
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x83},
+	{value: 0x0040, lo: 0x84, hi: 0xbf},
+	// Block 0xce, offset 0x635
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xbf},
+	// Block 0xcf, offset 0x638
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0xbf},
+	// Block 0xd0, offset 0x63b
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0008, lo: 0x80, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa9},
+	{value: 0x0040, lo: 0xaa, hi: 0xad},
+	{value: 0x0018, lo: 0xae, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+	// Block 0xd1, offset 0x642
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0040, lo: 0x80, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb4},
+	{value: 0x0018, lo: 0xb5, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xbf},
+	// Block 0xd2, offset 0x649
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xaf},
+	{value: 0x3308, lo: 0xb0, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xbf},
+	// Block 0xd3, offset 0x64d
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x0008, lo: 0x80, hi: 0x83},
+	{value: 0x0018, lo: 0x84, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9a},
+	{value: 0x0018, lo: 0x9b, hi: 0xa1},
+	{value: 0x0040, lo: 0xa2, hi: 0xa2},
+	{value: 0x0008, lo: 0xa3, hi: 0xb7},
+	{value: 0x0040, lo: 0xb8, hi: 0xbc},
+	{value: 0x0008, lo: 0xbd, hi: 0xbf},
+	// Block 0xd4, offset 0x658
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0xbf},
+	// Block 0xd5, offset 0x65b
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0008, lo: 0x80, hi: 0x84},
+	{value: 0x0040, lo: 0x85, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x90},
+	{value: 0x3008, lo: 0x91, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0xd6, offset 0x661
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0040, lo: 0x80, hi: 0x8e},
+	{value: 0x3308, lo: 0x8f, hi: 0x92},
+	{value: 0x0008, lo: 0x93, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xbf},
+	// Block 0xd7, offset 0x666
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0040, lo: 0x80, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xa1},
+	{value: 0x0040, lo: 0xa2, hi: 0xbf},
+	// Block 0xd8, offset 0x66a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xbf},
+	// Block 0xd9, offset 0x66d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xb2},
+	{value: 0x0040, lo: 0xb3, hi: 0xbf},
+	// Block 0xda, offset 0x670
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x9e},
+	{value: 0x0040, lo: 0x9f, hi: 0xbf},
+	// Block 0xdb, offset 0x673
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0040, lo: 0x80, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0xdc, offset 0x676
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xbb},
+	{value: 0x0040, lo: 0xbc, hi: 0xbf},
+	// Block 0xdd, offset 0x679
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0008, lo: 0x80, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbc},
+	{value: 0x0040, lo: 0xbd, hi: 0xbf},
+	// Block 0xde, offset 0x67e
+	{value: 0x0000, lo: 0x09},
+	{value: 0x0008, lo: 0x80, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x8f},
+	{value: 0x0008, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9b},
+	{value: 0x0018, lo: 0x9c, hi: 0x9c},
+	{value: 0x3308, lo: 0x9d, hi: 0x9e},
+	{value: 0x0018, lo: 0x9f, hi: 0x9f},
+	{value: 0x03c0, lo: 0xa0, hi: 0xa3},
+	{value: 0x0040, lo: 0xa4, hi: 0xbf},
+	// Block 0xdf, offset 0x688
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xbf},
+	// Block 0xe0, offset 0x68b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xa8},
+	{value: 0x0018, lo: 0xa9, hi: 0xbf},
+	// Block 0xe1, offset 0x68f
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x0018, lo: 0x80, hi: 0x9d},
+	{value: 0xb5b9, lo: 0x9e, hi: 0x9e},
+	{value: 0xb601, lo: 0x9f, hi: 0x9f},
+	{value: 0xb649, lo: 0xa0, hi: 0xa0},
+	{value: 0xb6b1, lo: 0xa1, hi: 0xa1},
+	{value: 0xb719, lo: 0xa2, hi: 0xa2},
+	{value: 0xb781, lo: 0xa3, hi: 0xa3},
+	{value: 0xb7e9, lo: 0xa4, hi: 0xa4},
+	{value: 0x3018, lo: 0xa5, hi: 0xa6},
+	{value: 0x3318, lo: 0xa7, hi: 0xa9},
+	{value: 0x0018, lo: 0xaa, hi: 0xac},
+	{value: 0x3018, lo: 0xad, hi: 0xb2},
+	{value: 0x0340, lo: 0xb3, hi: 0xba},
+	{value: 0x3318, lo: 0xbb, hi: 0xbf},
+	// Block 0xe2, offset 0x69e
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x3318, lo: 0x80, hi: 0x82},
+	{value: 0x0018, lo: 0x83, hi: 0x84},
+	{value: 0x3318, lo: 0x85, hi: 0x8b},
+	{value: 0x0018, lo: 0x8c, hi: 0xa9},
+	{value: 0x3318, lo: 0xaa, hi: 0xad},
+	{value: 0x0018, lo: 0xae, hi: 0xba},
+	{value: 0xb851, lo: 0xbb, hi: 0xbb},
+	{value: 0xb899, lo: 0xbc, hi: 0xbc},
+	{value: 0xb8e1, lo: 0xbd, hi: 0xbd},
+	{value: 0xb949, lo: 0xbe, hi: 0xbe},
+	{value: 0xb9b1, lo: 0xbf, hi: 0xbf},
+	// Block 0xe3, offset 0x6aa
+	{value: 0x0000, lo: 0x03},
+	{value: 0xba19, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0xa8},
+	{value: 0x0040, lo: 0xa9, hi: 0xbf},
+	// Block 0xe4, offset 0x6ae
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x81},
+	{value: 0x3318, lo: 0x82, hi: 0x84},
+	{value: 0x0018, lo: 0x85, hi: 0x85},
+	{value: 0x0040, lo: 0x86, hi: 0xbf},
+	// Block 0xe5, offset 0x6b3
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xb1},
+	{value: 0x0040, lo: 0xb2, hi: 0xbf},
+	// Block 0xe6, offset 0x6b8
+	{value: 0x0000, lo: 0x03},
+	{value: 0x3308, lo: 0x80, hi: 0xb6},
+	{value: 0x0018, lo: 0xb7, hi: 0xba},
+	{value: 0x3308, lo: 0xbb, hi: 0xbf},
+	// Block 0xe7, offset 0x6bc
+	{value: 0x0000, lo: 0x04},
+	{value: 0x3308, lo: 0x80, hi: 0xac},
+	{value: 0x0018, lo: 0xad, hi: 0xb4},
+	{value: 0x3308, lo: 0xb5, hi: 0xb5},
+	{value: 0x0018, lo: 0xb6, hi: 0xbf},
+	// Block 0xe8, offset 0x6c1
+	{value: 0x0000, lo: 0x08},
+	{value: 0x0018, lo: 0x80, hi: 0x83},
+	{value: 0x3308, lo: 0x84, hi: 0x84},
+	{value: 0x0018, lo: 0x85, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x9a},
+	{value: 0x3308, lo: 0x9b, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xa0},
+	{value: 0x3308, lo: 0xa1, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+	// Block 0xe9, offset 0x6ca
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x3308, lo: 0x80, hi: 0x86},
+	{value: 0x0040, lo: 0x87, hi: 0x87},
+	{value: 0x3308, lo: 0x88, hi: 0x98},
+	{value: 0x0040, lo: 0x99, hi: 0x9a},
+	{value: 0x3308, lo: 0x9b, hi: 0xa1},
+	{value: 0x0040, lo: 0xa2, hi: 0xa2},
+	{value: 0x3308, lo: 0xa3, hi: 0xa4},
+	{value: 0x0040, lo: 0xa5, hi: 0xa5},
+	{value: 0x3308, lo: 0xa6, hi: 0xaa},
+	{value: 0x0040, lo: 0xab, hi: 0xbf},
+	// Block 0xea, offset 0x6d5
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0808, lo: 0x80, hi: 0x84},
+	{value: 0x0040, lo: 0x85, hi: 0x86},
+	{value: 0x0818, lo: 0x87, hi: 0x8f},
+	{value: 0x3308, lo: 0x90, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0xbf},
+	// Block 0xeb, offset 0x6db
+	{value: 0x0000, lo: 0x07},
+	{value: 0x0a08, lo: 0x80, hi: 0x83},
+	{value: 0x3308, lo: 0x84, hi: 0x8a},
+	{value: 0x0040, lo: 0x8b, hi: 0x8f},
+	{value: 0x0808, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9d},
+	{value: 0x0818, lo: 0x9e, hi: 0x9f},
+	{value: 0x0040, lo: 0xa0, hi: 0xbf},
+	// Block 0xec, offset 0x6e3
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0040, lo: 0x80, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb1},
+	{value: 0x0040, lo: 0xb2, hi: 0xbf},
+	// Block 0xed, offset 0x6e7
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xbf},
+	// Block 0xee, offset 0x6eb
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x93},
+	{value: 0x0040, lo: 0x94, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xae},
+	{value: 0x0040, lo: 0xaf, hi: 0xb0},
+	{value: 0x0018, lo: 0xb1, hi: 0xbf},
+	// Block 0xef, offset 0x6f1
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0018, lo: 0x81, hi: 0x8f},
+	{value: 0x0040, lo: 0x90, hi: 0x90},
+	{value: 0x0018, lo: 0x91, hi: 0xb5},
+	{value: 0x0040, lo: 0xb6, hi: 0xbf},
+	// Block 0xf0, offset 0x6f7
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x8f},
+	{value: 0xc1c1, lo: 0x90, hi: 0x90},
+	{value: 0x0018, lo: 0x91, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xbf},
+	// Block 0xf1, offset 0x6fc
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0040, lo: 0x80, hi: 0xa5},
+	{value: 0x0018, lo: 0xa6, hi: 0xbf},
+	// Block 0xf2, offset 0x6ff
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xc7e9, lo: 0x80, hi: 0x80},
+	{value: 0xc839, lo: 0x81, hi: 0x81},
+	{value: 0xc889, lo: 0x82, hi: 0x82},
+	{value: 0xc8d9, lo: 0x83, hi: 0x83},
+	{value: 0xc929, lo: 0x84, hi: 0x84},
+	{value: 0xc979, lo: 0x85, hi: 0x85},
+	{value: 0xc9c9, lo: 0x86, hi: 0x86},
+	{value: 0xca19, lo: 0x87, hi: 0x87},
+	{value: 0xca69, lo: 0x88, hi: 0x88},
+	{value: 0x0040, lo: 0x89, hi: 0x8f},
+	{value: 0xcab9, lo: 0x90, hi: 0x90},
+	{value: 0xcad9, lo: 0x91, hi: 0x91},
+	{value: 0x0040, lo: 0x92, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xa5},
+	{value: 0x0040, lo: 0xa6, hi: 0xbf},
+	// Block 0xf3, offset 0x70f
+	{value: 0x0000, lo: 0x06},
+	{value: 0x0018, lo: 0x80, hi: 0x94},
+	{value: 0x0040, lo: 0x95, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xac},
+	{value: 0x0040, lo: 0xad, hi: 0xaf},
+	{value: 0x0018, lo: 0xb0, hi: 0xb8},
+	{value: 0x0040, lo: 0xb9, hi: 0xbf},
+	// Block 0xf4, offset 0x716
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0xb3},
+	{value: 0x0040, lo: 0xb4, hi: 0xbf},
+	// Block 0xf5, offset 0x719
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0x94},
+	{value: 0x0040, lo: 0x95, hi: 0xbf},
+	// Block 0xf6, offset 0x71c
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0018, lo: 0x80, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xbf},
+	// Block 0xf7, offset 0x720
+	{value: 0x0000, lo: 0x05},
+	{value: 0x0018, lo: 0x80, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0x99},
+	{value: 0x0040, lo: 0x9a, hi: 0x9f},
+	{value: 0x0018, lo: 0xa0, hi: 0xbf},
+	// Block 0xf8, offset 0x726
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x87},
+	{value: 0x0040, lo: 0x88, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xad},
+	{value: 0x0040, lo: 0xae, hi: 0xbf},
+	// Block 0xf9, offset 0x72b
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x8b},
+	{value: 0x0040, lo: 0x8c, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xbe},
+	{value: 0x0040, lo: 0xbf, hi: 0xbf},
+	// Block 0xfa, offset 0x730
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x8c},
+	{value: 0x0040, lo: 0x8d, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xab},
+	{value: 0x0040, lo: 0xac, hi: 0xbf},
+	// Block 0xfb, offset 0x735
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0018, lo: 0x80, hi: 0x97},
+	{value: 0x0040, lo: 0x98, hi: 0xbf},
+	// Block 0xfc, offset 0x738
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0018, lo: 0x80, hi: 0x80},
+	{value: 0x0040, lo: 0x81, hi: 0x8f},
+	{value: 0x0018, lo: 0x90, hi: 0xa6},
+	{value: 0x0040, lo: 0xa7, hi: 0xbf},
+	// Block 0xfd, offset 0x73d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0x96},
+	{value: 0x0040, lo: 0x97, hi: 0xbf},
+	// Block 0xfe, offset 0x740
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xb4},
+	{value: 0x0040, lo: 0xb5, hi: 0xbf},
+	// Block 0xff, offset 0x743
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0x9d},
+	{value: 0x0040, lo: 0x9e, hi: 0x9f},
+	{value: 0x0008, lo: 0xa0, hi: 0xbf},
+	// Block 0x100, offset 0x747
+	{value: 0x0000, lo: 0x03},
+	{value: 0x0008, lo: 0x80, hi: 0xa1},
+	{value: 0x0040, lo: 0xa2, hi: 0xaf},
+	{value: 0x0008, lo: 0xb0, hi: 0xbf},
+	// Block 0x101, offset 0x74b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0008, lo: 0x80, hi: 0xa0},
+	{value: 0x0040, lo: 0xa1, hi: 0xbf},
+	// Block 0x102, offset 0x74e
+	{value: 0x0020, lo: 0x0f},
+	{value: 0xdeb9, lo: 0x80, hi: 0x89},
+	{value: 0x8dfd, lo: 0x8a, hi: 0x8a},
+	{value: 0xdff9, lo: 0x8b, hi: 0x9c},
+	{value: 0x8e1d, lo: 0x9d, hi: 0x9d},
+	{value: 0xe239, lo: 0x9e, hi: 0xa2},
+	{value: 0x8e3d, lo: 0xa3, hi: 0xa3},
+	{value: 0xe2d9, lo: 0xa4, hi: 0xab},
+	{value: 0x7ed5, lo: 0xac, hi: 0xac},
+	{value: 0xe3d9, lo: 0xad, hi: 0xaf},
+	{value: 0x8e5d, lo: 0xb0, hi: 0xb0},
+	{value: 0xe439, lo: 0xb1, hi: 0xb6},
+	{value: 0x8e7d, lo: 0xb7, hi: 0xb9},
+	{value: 0xe4f9, lo: 0xba, hi: 0xba},
+	{value: 0x8edd, lo: 0xbb, hi: 0xbb},
+	{value: 0xe519, lo: 0xbc, hi: 0xbf},
+	// Block 0x103, offset 0x75e
+	{value: 0x0020, lo: 0x10},
+	{value: 0x937d, lo: 0x80, hi: 0x80},
+	{value: 0xf099, lo: 0x81, hi: 0x86},
+	{value: 0x939d, lo: 0x87, hi: 0x8a},
+	{value: 0xd9f9, lo: 0x8b, hi: 0x8b},
+	{value: 0xf159, lo: 0x8c, hi: 0x96},
+	{value: 0x941d, lo: 0x97, hi: 0x97},
+	{value: 0xf2b9, lo: 0x98, hi: 0xa3},
+	{value: 0x943d, lo: 0xa4, hi: 0xa6},
+	{value: 0xf439, lo: 0xa7, hi: 0xaa},
+	{value: 0x949d, lo: 0xab, hi: 0xab},
+	{value: 0xf4b9, lo: 0xac, hi: 0xac},
+	{value: 0x94bd, lo: 0xad, hi: 0xad},
+	{value: 0xf4d9, lo: 0xae, hi: 0xaf},
+	{value: 0x94dd, lo: 0xb0, hi: 0xb1},
+	{value: 0xf519, lo: 0xb2, hi: 0xbe},
+	{value: 0x2040, lo: 0xbf, hi: 0xbf},
+	// Block 0x104, offset 0x76f
+	{value: 0x0000, lo: 0x04},
+	{value: 0x0040, lo: 0x80, hi: 0x80},
+	{value: 0x0340, lo: 0x81, hi: 0x81},
+	{value: 0x0040, lo: 0x82, hi: 0x9f},
+	{value: 0x0340, lo: 0xa0, hi: 0xbf},
+	// Block 0x105, offset 0x774
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0340, lo: 0x80, hi: 0xbf},
+	// Block 0x106, offset 0x776
+	{value: 0x0000, lo: 0x01},
+	{value: 0x33c0, lo: 0x80, hi: 0xbf},
+	// Block 0x107, offset 0x778
+	{value: 0x0000, lo: 0x02},
+	{value: 0x33c0, lo: 0x80, hi: 0xaf},
+	{value: 0x0040, lo: 0xb0, hi: 0xbf},
+}
+
+// Total table size 42115 bytes (41KiB); checksum: F4A1FA4E
diff --git a/vendor/golang.org/x/net/idna/trie.go b/vendor/golang.org/x/net/idna/trie.go
new file mode 100644
index 0000000000..c4ef847e7a
--- /dev/null
+++ b/vendor/golang.org/x/net/idna/trie.go
@@ -0,0 +1,72 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// Copyright 2016 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 idna
+
+// appendMapping appends the mapping for the respective rune. isMapped must be
+// true. A mapping is a categorization of a rune as defined in UTS #46.
+func (c info) appendMapping(b []byte, s string) []byte {
+	index := int(c >> indexShift)
+	if c&xorBit == 0 {
+		s := mappings[index:]
+		return append(b, s[1:s[0]+1]...)
+	}
+	b = append(b, s...)
+	if c&inlineXOR == inlineXOR {
+		// TODO: support and handle two-byte inline masks
+		b[len(b)-1] ^= byte(index)
+	} else {
+		for p := len(b) - int(xorData[index]); p < len(b); p++ {
+			index++
+			b[p] ^= xorData[index]
+		}
+	}
+	return b
+}
+
+// Sparse block handling code.
+
+type valueRange struct {
+	value  uint16 // header: value:stride
+	lo, hi byte   // header: lo:n
+}
+
+type sparseBlocks struct {
+	values []valueRange
+	offset []uint16
+}
+
+var idnaSparse = sparseBlocks{
+	values: idnaSparseValues[:],
+	offset: idnaSparseOffset[:],
+}
+
+// Don't use newIdnaTrie to avoid unconditional linking in of the table.
+var trie = &idnaTrie{}
+
+// lookup determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	offset := t.offset[n]
+	header := t.values[offset]
+	lo := offset + 1
+	hi := lo + uint16(header.lo)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := t.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value + uint16(b-r.lo)*header.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
diff --git a/vendor/golang.org/x/net/idna/trieval.go b/vendor/golang.org/x/net/idna/trieval.go
new file mode 100644
index 0000000000..7a8cf889b5
--- /dev/null
+++ b/vendor/golang.org/x/net/idna/trieval.go
@@ -0,0 +1,119 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package idna
+
+// This file contains definitions for interpreting the trie value of the idna
+// trie generated by "go run gen*.go". It is shared by both the generator
+// program and the resultant package. Sharing is achieved by the generator
+// copying gen_trieval.go to trieval.go and changing what's above this comment.
+
+// info holds information from the IDNA mapping table for a single rune. It is
+// the value returned by a trie lookup. In most cases, all information fits in
+// a 16-bit value. For mappings, this value may contain an index into a slice
+// with the mapped string. Such mappings can consist of the actual mapped value
+// or an XOR pattern to be applied to the bytes of the UTF8 encoding of the
+// input rune. This technique is used by the cases packages and reduces the
+// table size significantly.
+//
+// The per-rune values have the following format:
+//
+//   if mapped {
+//     if inlinedXOR {
+//       15..13 inline XOR marker
+//       12..11 unused
+//       10..3  inline XOR mask
+//     } else {
+//       15..3  index into xor or mapping table
+//     }
+//   } else {
+//       15..14 unused
+//       13     mayNeedNorm
+//       12..11 attributes
+//       10..8  joining type
+//        7..3  category type
+//   }
+//      2  use xor pattern
+//   1..0  mapped category
+//
+// See the definitions below for a more detailed description of the various
+// bits.
+type info uint16
+
+const (
+	catSmallMask = 0x3
+	catBigMask   = 0xF8
+	indexShift   = 3
+	xorBit       = 0x4    // interpret the index as an xor pattern
+	inlineXOR    = 0xE000 // These bits are set if the XOR pattern is inlined.
+
+	joinShift = 8
+	joinMask  = 0x07
+
+	// Attributes
+	attributesMask = 0x1800
+	viramaModifier = 0x1800
+	modifier       = 0x1000
+	rtl            = 0x0800
+
+	mayNeedNorm = 0x2000
+)
+
+// A category corresponds to a category defined in the IDNA mapping table.
+type category uint16
+
+const (
+	unknown              category = 0 // not currently defined in unicode.
+	mapped               category = 1
+	disallowedSTD3Mapped category = 2
+	deviation            category = 3
+)
+
+const (
+	valid               category = 0x08
+	validNV8            category = 0x18
+	validXV8            category = 0x28
+	disallowed          category = 0x40
+	disallowedSTD3Valid category = 0x80
+	ignored             category = 0xC0
+)
+
+// join types and additional rune information
+const (
+	joiningL = (iota + 1)
+	joiningD
+	joiningT
+	joiningR
+
+	//the following types are derived during processing
+	joinZWJ
+	joinZWNJ
+	joinVirama
+	numJoinTypes
+)
+
+func (c info) isMapped() bool {
+	return c&0x3 != 0
+}
+
+func (c info) category() category {
+	small := c & catSmallMask
+	if small != 0 {
+		return category(small)
+	}
+	return category(c & catBigMask)
+}
+
+func (c info) joinType() info {
+	if c.isMapped() {
+		return 0
+	}
+	return (c >> joinShift) & joinMask
+}
+
+func (c info) isModifier() bool {
+	return c&(modifier|catSmallMask) == modifier
+}
+
+func (c info) isViramaModifier() bool {
+	return c&(attributesMask|catSmallMask) == viramaModifier
+}
diff --git a/vendor/golang.org/x/text/secure/bidirule/bidirule.go b/vendor/golang.org/x/text/secure/bidirule/bidirule.go
new file mode 100644
index 0000000000..e2b70f76c2
--- /dev/null
+++ b/vendor/golang.org/x/text/secure/bidirule/bidirule.go
@@ -0,0 +1,336 @@
+// Copyright 2016 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 bidirule implements the Bidi Rule defined by RFC 5893.
+//
+// This package is under development. The API may change without notice and
+// without preserving backward compatibility.
+package bidirule
+
+import (
+	"errors"
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/bidi"
+)
+
+// This file contains an implementation of RFC 5893: Right-to-Left Scripts for
+// Internationalized Domain Names for Applications (IDNA)
+//
+// A label is an individual component of a domain name.  Labels are usually
+// shown separated by dots; for example, the domain name "www.example.com" is
+// composed of three labels: "www", "example", and "com".
+//
+// An RTL label is a label that contains at least one character of class R, AL,
+// or AN. An LTR label is any label that is not an RTL label.
+//
+// A "Bidi domain name" is a domain name that contains at least one RTL label.
+//
+//  The following guarantees can be made based on the above:
+//
+//  o  In a domain name consisting of only labels that satisfy the rule,
+//     the requirements of Section 3 are satisfied.  Note that even LTR
+//     labels and pure ASCII labels have to be tested.
+//
+//  o  In a domain name consisting of only LDH labels (as defined in the
+//     Definitions document [RFC5890]) and labels that satisfy the rule,
+//     the requirements of Section 3 are satisfied as long as a label
+//     that starts with an ASCII digit does not come after a
+//     right-to-left label.
+//
+//  No guarantee is given for other combinations.
+
+// ErrInvalid indicates a label is invalid according to the Bidi Rule.
+var ErrInvalid = errors.New("bidirule: failed Bidi Rule")
+
+type ruleState uint8
+
+const (
+	ruleInitial ruleState = iota
+	ruleLTR
+	ruleLTRFinal
+	ruleRTL
+	ruleRTLFinal
+	ruleInvalid
+)
+
+type ruleTransition struct {
+	next ruleState
+	mask uint16
+}
+
+var transitions = [...][2]ruleTransition{
+	// [2.1] The first character must be a character with Bidi property L, R, or
+	// AL. If it has the R or AL property, it is an RTL label; if it has the L
+	// property, it is an LTR label.
+	ruleInitial: {
+		{ruleLTRFinal, 1 << bidi.L},
+		{ruleRTLFinal, 1< 0; count-- {
+						p.openers.Remove(p.openers.Front())
+					}
+					break
+				}
+			}
+			sort.Sort(p.pairPositions)
+			// if we get here, the closing bracket matched no openers
+			// and gets ignored
+		}
+	}
+}
+
+// Bracket pairs within an isolating run sequence are processed as units so
+// that both the opening and the closing paired bracket in a pair resolve to
+// the same direction.
+//
+// N0. Process bracket pairs in an isolating run sequence sequentially in
+// the logical order of the text positions of the opening paired brackets
+// using the logic given below. Within this scope, bidirectional types EN
+// and AN are treated as R.
+//
+// Identify the bracket pairs in the current isolating run sequence
+// according to BD16. For each bracket-pair element in the list of pairs of
+// text positions:
+//
+// a Inspect the bidirectional types of the characters enclosed within the
+// bracket pair.
+//
+// b If any strong type (either L or R) matching the embedding direction is
+// found, set the type for both brackets in the pair to match the embedding
+// direction.
+//
+// o [ e ] o -> o e e e o
+//
+// o [ o e ] -> o e o e e
+//
+// o [ NI e ] -> o e NI e e
+//
+// c Otherwise, if a strong type (opposite the embedding direction) is
+// found, test for adjacent strong types as follows: 1 First, check
+// backwards before the opening paired bracket until the first strong type
+// (L, R, or sos) is found. If that first preceding strong type is opposite
+// the embedding direction, then set the type for both brackets in the pair
+// to that type. 2 Otherwise, set the type for both brackets in the pair to
+// the embedding direction.
+//
+// o [ o ] e -> o o o o e
+//
+// o [ o NI ] o -> o o o NI o o
+//
+// e [ o ] o -> e e o e o
+//
+// e [ o ] e -> e e o e e
+//
+// e ( o [ o ] NI ) e -> e e o o o o NI e e
+//
+// d Otherwise, do not set the type for the current bracket pair. Note that
+// if the enclosed text contains no strong types the paired brackets will
+// both resolve to the same level when resolved individually using rules N1
+// and N2.
+//
+// e ( NI ) o -> e ( NI ) o
+
+// getStrongTypeN0 maps character's directional code to strong type as required
+// by rule N0.
+//
+// TODO: have separate type for "strong" directionality.
+func (p *bracketPairer) getStrongTypeN0(index int) Class {
+	switch p.codesIsolatedRun[index] {
+	// in the scope of N0, number types are treated as R
+	case EN, AN, AL, R:
+		return R
+	case L:
+		return L
+	default:
+		return ON
+	}
+}
+
+// classifyPairContent reports the strong types contained inside a Bracket Pair,
+// assuming the given embedding direction.
+//
+// It returns ON if no strong type is found. If a single strong type is found,
+// it returns this this type. Otherwise it returns the embedding direction.
+//
+// TODO: use separate type for "strong" directionality.
+func (p *bracketPairer) classifyPairContent(loc bracketPair, dirEmbed Class) Class {
+	dirOpposite := ON
+	for i := loc.opener + 1; i < loc.closer; i++ {
+		dir := p.getStrongTypeN0(i)
+		if dir == ON {
+			continue
+		}
+		if dir == dirEmbed {
+			return dir // type matching embedding direction found
+		}
+		dirOpposite = dir
+	}
+	// return ON if no strong type found, or class opposite to dirEmbed
+	return dirOpposite
+}
+
+// classBeforePair determines which strong types are present before a Bracket
+// Pair. Return R or L if strong type found, otherwise ON.
+func (p *bracketPairer) classBeforePair(loc bracketPair) Class {
+	for i := loc.opener - 1; i >= 0; i-- {
+		if dir := p.getStrongTypeN0(i); dir != ON {
+			return dir
+		}
+	}
+	// no strong types found, return sos
+	return p.sos
+}
+
+// assignBracketType implements rule N0 for a single bracket pair.
+func (p *bracketPairer) assignBracketType(loc bracketPair, dirEmbed Class, initialTypes []Class) {
+	// rule "N0, a", inspect contents of pair
+	dirPair := p.classifyPairContent(loc, dirEmbed)
+
+	// dirPair is now L, R, or N (no strong type found)
+
+	// the following logical tests are performed out of order compared to
+	// the statement of the rules but yield the same results
+	if dirPair == ON {
+		return // case "d" - nothing to do
+	}
+
+	if dirPair != dirEmbed {
+		// case "c": strong type found, opposite - check before (c.1)
+		dirPair = p.classBeforePair(loc)
+		if dirPair == dirEmbed || dirPair == ON {
+			// no strong opposite type found before - use embedding (c.2)
+			dirPair = dirEmbed
+		}
+	}
+	// else: case "b", strong type found matching embedding,
+	// no explicit action needed, as dirPair is already set to embedding
+	// direction
+
+	// set the bracket types to the type found
+	p.setBracketsToType(loc, dirPair, initialTypes)
+}
+
+func (p *bracketPairer) setBracketsToType(loc bracketPair, dirPair Class, initialTypes []Class) {
+	p.codesIsolatedRun[loc.opener] = dirPair
+	p.codesIsolatedRun[loc.closer] = dirPair
+
+	for i := loc.opener + 1; i < loc.closer; i++ {
+		index := p.indexes[i]
+		if initialTypes[index] != NSM {
+			break
+		}
+		p.codesIsolatedRun[i] = dirPair
+	}
+
+	for i := loc.closer + 1; i < len(p.indexes); i++ {
+		index := p.indexes[i]
+		if initialTypes[index] != NSM {
+			break
+		}
+		p.codesIsolatedRun[i] = dirPair
+	}
+}
+
+// resolveBrackets implements rule N0 for a list of pairs.
+func (p *bracketPairer) resolveBrackets(dirEmbed Class, initialTypes []Class) {
+	for _, loc := range p.pairPositions {
+		p.assignBracketType(loc, dirEmbed, initialTypes)
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/bidi/core.go b/vendor/golang.org/x/text/unicode/bidi/core.go
new file mode 100644
index 0000000000..d4c1399f0d
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/core.go
@@ -0,0 +1,1058 @@
+// Copyright 2015 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 bidi
+
+import "log"
+
+// This implementation is a port based on the reference implementation found at:
+// http://www.unicode.org/Public/PROGRAMS/BidiReferenceJava/
+//
+// described in Unicode Bidirectional Algorithm (UAX #9).
+//
+// Input:
+// There are two levels of input to the algorithm, since clients may prefer to
+// supply some information from out-of-band sources rather than relying on the
+// default behavior.
+//
+// - Bidi class array
+// - Bidi class array, with externally supplied base line direction
+//
+// Output:
+// Output is separated into several stages:
+//
+//  - levels array over entire paragraph
+//  - reordering array over entire paragraph
+//  - levels array over line
+//  - reordering array over line
+//
+// Note that for conformance to the Unicode Bidirectional Algorithm,
+// implementations are only required to generate correct reordering and
+// character directionality (odd or even levels) over a line. Generating
+// identical level arrays over a line is not required. Bidi explicit format
+// codes (LRE, RLE, LRO, RLO, PDF) and BN can be assigned arbitrary levels and
+// positions as long as the rest of the input is properly reordered.
+//
+// As the algorithm is defined to operate on a single paragraph at a time, this
+// implementation is written to handle single paragraphs. Thus rule P1 is
+// presumed by this implementation-- the data provided to the implementation is
+// assumed to be a single paragraph, and either contains no 'B' codes, or a
+// single 'B' code at the end of the input. 'B' is allowed as input to
+// illustrate how the algorithm assigns it a level.
+//
+// Also note that rules L3 and L4 depend on the rendering engine that uses the
+// result of the bidi algorithm. This implementation assumes that the rendering
+// engine expects combining marks in visual order (e.g. to the left of their
+// base character in RTL runs) and that it adjusts the glyphs used to render
+// mirrored characters that are in RTL runs so that they render appropriately.
+
+// level is the embedding level of a character. Even embedding levels indicate
+// left-to-right order and odd levels indicate right-to-left order. The special
+// level of -1 is reserved for undefined order.
+type level int8
+
+const implicitLevel level = -1
+
+// in returns if x is equal to any of the values in set.
+func (c Class) in(set ...Class) bool {
+	for _, s := range set {
+		if c == s {
+			return true
+		}
+	}
+	return false
+}
+
+// A paragraph contains the state of a paragraph.
+type paragraph struct {
+	initialTypes []Class
+
+	// Arrays of properties needed for paired bracket evaluation in N0
+	pairTypes  []bracketType // paired Bracket types for paragraph
+	pairValues []rune        // rune for opening bracket or pbOpen and pbClose; 0 for pbNone
+
+	embeddingLevel level // default: = implicitLevel;
+
+	// at the paragraph levels
+	resultTypes  []Class
+	resultLevels []level
+
+	// Index of matching PDI for isolate initiator characters. For other
+	// characters, the value of matchingPDI will be set to -1. For isolate
+	// initiators with no matching PDI, matchingPDI will be set to the length of
+	// the input string.
+	matchingPDI []int
+
+	// Index of matching isolate initiator for PDI characters. For other
+	// characters, and for PDIs with no matching isolate initiator, the value of
+	// matchingIsolateInitiator will be set to -1.
+	matchingIsolateInitiator []int
+}
+
+// newParagraph initializes a paragraph. The user needs to supply a few arrays
+// corresponding to the preprocessed text input. The types correspond to the
+// Unicode BiDi classes for each rune. pairTypes indicates the bracket type for
+// each rune. pairValues provides a unique bracket class identifier for each
+// rune (suggested is the rune of the open bracket for opening and matching
+// close brackets, after normalization). The embedding levels are optional, but
+// may be supplied to encode embedding levels of styled text.
+//
+// TODO: return an error.
+func newParagraph(types []Class, pairTypes []bracketType, pairValues []rune, levels level) *paragraph {
+	validateTypes(types)
+	validatePbTypes(pairTypes)
+	validatePbValues(pairValues, pairTypes)
+	validateParagraphEmbeddingLevel(levels)
+
+	p := ¶graph{
+		initialTypes:   append([]Class(nil), types...),
+		embeddingLevel: levels,
+
+		pairTypes:  pairTypes,
+		pairValues: pairValues,
+
+		resultTypes: append([]Class(nil), types...),
+	}
+	p.run()
+	return p
+}
+
+func (p *paragraph) Len() int { return len(p.initialTypes) }
+
+// The algorithm. Does not include line-based processing (Rules L1, L2).
+// These are applied later in the line-based phase of the algorithm.
+func (p *paragraph) run() {
+	p.determineMatchingIsolates()
+
+	// 1) determining the paragraph level
+	// Rule P1 is the requirement for entering this algorithm.
+	// Rules P2, P3.
+	// If no externally supplied paragraph embedding level, use default.
+	if p.embeddingLevel == implicitLevel {
+		p.embeddingLevel = p.determineParagraphEmbeddingLevel(0, p.Len())
+	}
+
+	// Initialize result levels to paragraph embedding level.
+	p.resultLevels = make([]level, p.Len())
+	setLevels(p.resultLevels, p.embeddingLevel)
+
+	// 2) Explicit levels and directions
+	// Rules X1-X8.
+	p.determineExplicitEmbeddingLevels()
+
+	// Rule X9.
+	// We do not remove the embeddings, the overrides, the PDFs, and the BNs
+	// from the string explicitly. But they are not copied into isolating run
+	// sequences when they are created, so they are removed for all
+	// practical purposes.
+
+	// Rule X10.
+	// Run remainder of algorithm one isolating run sequence at a time
+	for _, seq := range p.determineIsolatingRunSequences() {
+		// 3) resolving weak types
+		// Rules W1-W7.
+		seq.resolveWeakTypes()
+
+		// 4a) resolving paired brackets
+		// Rule N0
+		resolvePairedBrackets(seq)
+
+		// 4b) resolving neutral types
+		// Rules N1-N3.
+		seq.resolveNeutralTypes()
+
+		// 5) resolving implicit embedding levels
+		// Rules I1, I2.
+		seq.resolveImplicitLevels()
+
+		// Apply the computed levels and types
+		seq.applyLevelsAndTypes()
+	}
+
+	// Assign appropriate levels to 'hide' LREs, RLEs, LROs, RLOs, PDFs, and
+	// BNs. This is for convenience, so the resulting level array will have
+	// a value for every character.
+	p.assignLevelsToCharactersRemovedByX9()
+}
+
+// determineMatchingIsolates determines the matching PDI for each isolate
+// initiator and vice versa.
+//
+// Definition BD9.
+//
+// At the end of this function:
+//
+//  - The member variable matchingPDI is set to point to the index of the
+//    matching PDI character for each isolate initiator character. If there is
+//    no matching PDI, it is set to the length of the input text. For other
+//    characters, it is set to -1.
+//  - The member variable matchingIsolateInitiator is set to point to the
+//    index of the matching isolate initiator character for each PDI character.
+//    If there is no matching isolate initiator, or the character is not a PDI,
+//    it is set to -1.
+func (p *paragraph) determineMatchingIsolates() {
+	p.matchingPDI = make([]int, p.Len())
+	p.matchingIsolateInitiator = make([]int, p.Len())
+
+	for i := range p.matchingIsolateInitiator {
+		p.matchingIsolateInitiator[i] = -1
+	}
+
+	for i := range p.matchingPDI {
+		p.matchingPDI[i] = -1
+
+		if t := p.resultTypes[i]; t.in(LRI, RLI, FSI) {
+			depthCounter := 1
+			for j := i + 1; j < p.Len(); j++ {
+				if u := p.resultTypes[j]; u.in(LRI, RLI, FSI) {
+					depthCounter++
+				} else if u == PDI {
+					if depthCounter--; depthCounter == 0 {
+						p.matchingPDI[i] = j
+						p.matchingIsolateInitiator[j] = i
+						break
+					}
+				}
+			}
+			if p.matchingPDI[i] == -1 {
+				p.matchingPDI[i] = p.Len()
+			}
+		}
+	}
+}
+
+// determineParagraphEmbeddingLevel reports the resolved paragraph direction of
+// the substring limited by the given range [start, end).
+//
+// Determines the paragraph level based on rules P2, P3. This is also used
+// in rule X5c to find if an FSI should resolve to LRI or RLI.
+func (p *paragraph) determineParagraphEmbeddingLevel(start, end int) level {
+	var strongType Class = unknownClass
+
+	// Rule P2.
+	for i := start; i < end; i++ {
+		if t := p.resultTypes[i]; t.in(L, AL, R) {
+			strongType = t
+			break
+		} else if t.in(FSI, LRI, RLI) {
+			i = p.matchingPDI[i] // skip over to the matching PDI
+			if i > end {
+				log.Panic("assert (i <= end)")
+			}
+		}
+	}
+	// Rule P3.
+	switch strongType {
+	case unknownClass: // none found
+		// default embedding level when no strong types found is 0.
+		return 0
+	case L:
+		return 0
+	default: // AL, R
+		return 1
+	}
+}
+
+const maxDepth = 125
+
+// This stack will store the embedding levels and override and isolated
+// statuses
+type directionalStatusStack struct {
+	stackCounter        int
+	embeddingLevelStack [maxDepth + 1]level
+	overrideStatusStack [maxDepth + 1]Class
+	isolateStatusStack  [maxDepth + 1]bool
+}
+
+func (s *directionalStatusStack) empty()     { s.stackCounter = 0 }
+func (s *directionalStatusStack) pop()       { s.stackCounter-- }
+func (s *directionalStatusStack) depth() int { return s.stackCounter }
+
+func (s *directionalStatusStack) push(level level, overrideStatus Class, isolateStatus bool) {
+	s.embeddingLevelStack[s.stackCounter] = level
+	s.overrideStatusStack[s.stackCounter] = overrideStatus
+	s.isolateStatusStack[s.stackCounter] = isolateStatus
+	s.stackCounter++
+}
+
+func (s *directionalStatusStack) lastEmbeddingLevel() level {
+	return s.embeddingLevelStack[s.stackCounter-1]
+}
+
+func (s *directionalStatusStack) lastDirectionalOverrideStatus() Class {
+	return s.overrideStatusStack[s.stackCounter-1]
+}
+
+func (s *directionalStatusStack) lastDirectionalIsolateStatus() bool {
+	return s.isolateStatusStack[s.stackCounter-1]
+}
+
+// Determine explicit levels using rules X1 - X8
+func (p *paragraph) determineExplicitEmbeddingLevels() {
+	var stack directionalStatusStack
+	var overflowIsolateCount, overflowEmbeddingCount, validIsolateCount int
+
+	// Rule X1.
+	stack.push(p.embeddingLevel, ON, false)
+
+	for i, t := range p.resultTypes {
+		// Rules X2, X3, X4, X5, X5a, X5b, X5c
+		switch t {
+		case RLE, LRE, RLO, LRO, RLI, LRI, FSI:
+			isIsolate := t.in(RLI, LRI, FSI)
+			isRTL := t.in(RLE, RLO, RLI)
+
+			// override if this is an FSI that resolves to RLI
+			if t == FSI {
+				isRTL = (p.determineParagraphEmbeddingLevel(i+1, p.matchingPDI[i]) == 1)
+			}
+			if isIsolate {
+				p.resultLevels[i] = stack.lastEmbeddingLevel()
+				if stack.lastDirectionalOverrideStatus() != ON {
+					p.resultTypes[i] = stack.lastDirectionalOverrideStatus()
+				}
+			}
+
+			var newLevel level
+			if isRTL {
+				// least greater odd
+				newLevel = (stack.lastEmbeddingLevel() + 1) | 1
+			} else {
+				// least greater even
+				newLevel = (stack.lastEmbeddingLevel() + 2) &^ 1
+			}
+
+			if newLevel <= maxDepth && overflowIsolateCount == 0 && overflowEmbeddingCount == 0 {
+				if isIsolate {
+					validIsolateCount++
+				}
+				// Push new embedding level, override status, and isolated
+				// status.
+				// No check for valid stack counter, since the level check
+				// suffices.
+				switch t {
+				case LRO:
+					stack.push(newLevel, L, isIsolate)
+				case RLO:
+					stack.push(newLevel, R, isIsolate)
+				default:
+					stack.push(newLevel, ON, isIsolate)
+				}
+				// Not really part of the spec
+				if !isIsolate {
+					p.resultLevels[i] = newLevel
+				}
+			} else {
+				// This is an invalid explicit formatting character,
+				// so apply the "Otherwise" part of rules X2-X5b.
+				if isIsolate {
+					overflowIsolateCount++
+				} else { // !isIsolate
+					if overflowIsolateCount == 0 {
+						overflowEmbeddingCount++
+					}
+				}
+			}
+
+		// Rule X6a
+		case PDI:
+			if overflowIsolateCount > 0 {
+				overflowIsolateCount--
+			} else if validIsolateCount == 0 {
+				// do nothing
+			} else {
+				overflowEmbeddingCount = 0
+				for !stack.lastDirectionalIsolateStatus() {
+					stack.pop()
+				}
+				stack.pop()
+				validIsolateCount--
+			}
+			p.resultLevels[i] = stack.lastEmbeddingLevel()
+
+		// Rule X7
+		case PDF:
+			// Not really part of the spec
+			p.resultLevels[i] = stack.lastEmbeddingLevel()
+
+			if overflowIsolateCount > 0 {
+				// do nothing
+			} else if overflowEmbeddingCount > 0 {
+				overflowEmbeddingCount--
+			} else if !stack.lastDirectionalIsolateStatus() && stack.depth() >= 2 {
+				stack.pop()
+			}
+
+		case B: // paragraph separator.
+			// Rule X8.
+
+			// These values are reset for clarity, in this implementation B
+			// can only occur as the last code in the array.
+			stack.empty()
+			overflowIsolateCount = 0
+			overflowEmbeddingCount = 0
+			validIsolateCount = 0
+			p.resultLevels[i] = p.embeddingLevel
+
+		default:
+			p.resultLevels[i] = stack.lastEmbeddingLevel()
+			if stack.lastDirectionalOverrideStatus() != ON {
+				p.resultTypes[i] = stack.lastDirectionalOverrideStatus()
+			}
+		}
+	}
+}
+
+type isolatingRunSequence struct {
+	p *paragraph
+
+	indexes []int // indexes to the original string
+
+	types          []Class // type of each character using the index
+	resolvedLevels []level // resolved levels after application of rules
+	level          level
+	sos, eos       Class
+}
+
+func (i *isolatingRunSequence) Len() int { return len(i.indexes) }
+
+func maxLevel(a, b level) level {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// Rule X10, second bullet: Determine the start-of-sequence (sos) and end-of-sequence (eos) types,
+// 			 either L or R, for each isolating run sequence.
+func (p *paragraph) isolatingRunSequence(indexes []int) *isolatingRunSequence {
+	length := len(indexes)
+	types := make([]Class, length)
+	for i, x := range indexes {
+		types[i] = p.resultTypes[x]
+	}
+
+	// assign level, sos and eos
+	prevChar := indexes[0] - 1
+	for prevChar >= 0 && isRemovedByX9(p.initialTypes[prevChar]) {
+		prevChar--
+	}
+	prevLevel := p.embeddingLevel
+	if prevChar >= 0 {
+		prevLevel = p.resultLevels[prevChar]
+	}
+
+	var succLevel level
+	lastType := types[length-1]
+	if lastType.in(LRI, RLI, FSI) {
+		succLevel = p.embeddingLevel
+	} else {
+		// the first character after the end of run sequence
+		limit := indexes[length-1] + 1
+		for ; limit < p.Len() && isRemovedByX9(p.initialTypes[limit]); limit++ {
+
+		}
+		succLevel = p.embeddingLevel
+		if limit < p.Len() {
+			succLevel = p.resultLevels[limit]
+		}
+	}
+	level := p.resultLevels[indexes[0]]
+	return &isolatingRunSequence{
+		p:       p,
+		indexes: indexes,
+		types:   types,
+		level:   level,
+		sos:     typeForLevel(maxLevel(prevLevel, level)),
+		eos:     typeForLevel(maxLevel(succLevel, level)),
+	}
+}
+
+// Resolving weak types Rules W1-W7.
+//
+// Note that some weak types (EN, AN) remain after this processing is
+// complete.
+func (s *isolatingRunSequence) resolveWeakTypes() {
+
+	// on entry, only these types remain
+	s.assertOnly(L, R, AL, EN, ES, ET, AN, CS, B, S, WS, ON, NSM, LRI, RLI, FSI, PDI)
+
+	// Rule W1.
+	// Changes all NSMs.
+	preceedingCharacterType := s.sos
+	for i, t := range s.types {
+		if t == NSM {
+			s.types[i] = preceedingCharacterType
+		} else {
+			if t.in(LRI, RLI, FSI, PDI) {
+				preceedingCharacterType = ON
+			}
+			preceedingCharacterType = t
+		}
+	}
+
+	// Rule W2.
+	// EN does not change at the start of the run, because sos != AL.
+	for i, t := range s.types {
+		if t == EN {
+			for j := i - 1; j >= 0; j-- {
+				if t := s.types[j]; t.in(L, R, AL) {
+					if t == AL {
+						s.types[i] = AN
+					}
+					break
+				}
+			}
+		}
+	}
+
+	// Rule W3.
+	for i, t := range s.types {
+		if t == AL {
+			s.types[i] = R
+		}
+	}
+
+	// Rule W4.
+	// Since there must be values on both sides for this rule to have an
+	// effect, the scan skips the first and last value.
+	//
+	// Although the scan proceeds left to right, and changes the type
+	// values in a way that would appear to affect the computations
+	// later in the scan, there is actually no problem. A change in the
+	// current value can only affect the value to its immediate right,
+	// and only affect it if it is ES or CS. But the current value can
+	// only change if the value to its right is not ES or CS. Thus
+	// either the current value will not change, or its change will have
+	// no effect on the remainder of the analysis.
+
+	for i := 1; i < s.Len()-1; i++ {
+		t := s.types[i]
+		if t == ES || t == CS {
+			prevSepType := s.types[i-1]
+			succSepType := s.types[i+1]
+			if prevSepType == EN && succSepType == EN {
+				s.types[i] = EN
+			} else if s.types[i] == CS && prevSepType == AN && succSepType == AN {
+				s.types[i] = AN
+			}
+		}
+	}
+
+	// Rule W5.
+	for i, t := range s.types {
+		if t == ET {
+			// locate end of sequence
+			runStart := i
+			runEnd := s.findRunLimit(runStart, ET)
+
+			// check values at ends of sequence
+			t := s.sos
+			if runStart > 0 {
+				t = s.types[runStart-1]
+			}
+			if t != EN {
+				t = s.eos
+				if runEnd < len(s.types) {
+					t = s.types[runEnd]
+				}
+			}
+			if t == EN {
+				setTypes(s.types[runStart:runEnd], EN)
+			}
+			// continue at end of sequence
+			i = runEnd
+		}
+	}
+
+	// Rule W6.
+	for i, t := range s.types {
+		if t.in(ES, ET, CS) {
+			s.types[i] = ON
+		}
+	}
+
+	// Rule W7.
+	for i, t := range s.types {
+		if t == EN {
+			// set default if we reach start of run
+			prevStrongType := s.sos
+			for j := i - 1; j >= 0; j-- {
+				t = s.types[j]
+				if t == L || t == R { // AL's have been changed to R
+					prevStrongType = t
+					break
+				}
+			}
+			if prevStrongType == L {
+				s.types[i] = L
+			}
+		}
+	}
+}
+
+// 6) resolving neutral types Rules N1-N2.
+func (s *isolatingRunSequence) resolveNeutralTypes() {
+
+	// on entry, only these types can be in resultTypes
+	s.assertOnly(L, R, EN, AN, B, S, WS, ON, RLI, LRI, FSI, PDI)
+
+	for i, t := range s.types {
+		switch t {
+		case WS, ON, B, S, RLI, LRI, FSI, PDI:
+			// find bounds of run of neutrals
+			runStart := i
+			runEnd := s.findRunLimit(runStart, B, S, WS, ON, RLI, LRI, FSI, PDI)
+
+			// determine effective types at ends of run
+			var leadType, trailType Class
+
+			// Note that the character found can only be L, R, AN, or
+			// EN.
+			if runStart == 0 {
+				leadType = s.sos
+			} else {
+				leadType = s.types[runStart-1]
+				if leadType.in(AN, EN) {
+					leadType = R
+				}
+			}
+			if runEnd == len(s.types) {
+				trailType = s.eos
+			} else {
+				trailType = s.types[runEnd]
+				if trailType.in(AN, EN) {
+					trailType = R
+				}
+			}
+
+			var resolvedType Class
+			if leadType == trailType {
+				// Rule N1.
+				resolvedType = leadType
+			} else {
+				// Rule N2.
+				// Notice the embedding level of the run is used, not
+				// the paragraph embedding level.
+				resolvedType = typeForLevel(s.level)
+			}
+
+			setTypes(s.types[runStart:runEnd], resolvedType)
+
+			// skip over run of (former) neutrals
+			i = runEnd
+		}
+	}
+}
+
+func setLevels(levels []level, newLevel level) {
+	for i := range levels {
+		levels[i] = newLevel
+	}
+}
+
+func setTypes(types []Class, newType Class) {
+	for i := range types {
+		types[i] = newType
+	}
+}
+
+// 7) resolving implicit embedding levels Rules I1, I2.
+func (s *isolatingRunSequence) resolveImplicitLevels() {
+
+	// on entry, only these types can be in resultTypes
+	s.assertOnly(L, R, EN, AN)
+
+	s.resolvedLevels = make([]level, len(s.types))
+	setLevels(s.resolvedLevels, s.level)
+
+	if (s.level & 1) == 0 { // even level
+		for i, t := range s.types {
+			// Rule I1.
+			if t == L {
+				// no change
+			} else if t == R {
+				s.resolvedLevels[i] += 1
+			} else { // t == AN || t == EN
+				s.resolvedLevels[i] += 2
+			}
+		}
+	} else { // odd level
+		for i, t := range s.types {
+			// Rule I2.
+			if t == R {
+				// no change
+			} else { // t == L || t == AN || t == EN
+				s.resolvedLevels[i] += 1
+			}
+		}
+	}
+}
+
+// Applies the levels and types resolved in rules W1-I2 to the
+// resultLevels array.
+func (s *isolatingRunSequence) applyLevelsAndTypes() {
+	for i, x := range s.indexes {
+		s.p.resultTypes[x] = s.types[i]
+		s.p.resultLevels[x] = s.resolvedLevels[i]
+	}
+}
+
+// Return the limit of the run consisting only of the types in validSet
+// starting at index. This checks the value at index, and will return
+// index if that value is not in validSet.
+func (s *isolatingRunSequence) findRunLimit(index int, validSet ...Class) int {
+loop:
+	for ; index < len(s.types); index++ {
+		t := s.types[index]
+		for _, valid := range validSet {
+			if t == valid {
+				continue loop
+			}
+		}
+		return index // didn't find a match in validSet
+	}
+	return len(s.types)
+}
+
+// Algorithm validation. Assert that all values in types are in the
+// provided set.
+func (s *isolatingRunSequence) assertOnly(codes ...Class) {
+loop:
+	for i, t := range s.types {
+		for _, c := range codes {
+			if t == c {
+				continue loop
+			}
+		}
+		log.Panicf("invalid bidi code %v present in assertOnly at position %d", t, s.indexes[i])
+	}
+}
+
+// determineLevelRuns returns an array of level runs. Each level run is
+// described as an array of indexes into the input string.
+//
+// Determines the level runs. Rule X9 will be applied in determining the
+// runs, in the way that makes sure the characters that are supposed to be
+// removed are not included in the runs.
+func (p *paragraph) determineLevelRuns() [][]int {
+	run := []int{}
+	allRuns := [][]int{}
+	currentLevel := implicitLevel
+
+	for i := range p.initialTypes {
+		if !isRemovedByX9(p.initialTypes[i]) {
+			if p.resultLevels[i] != currentLevel {
+				// we just encountered a new run; wrap up last run
+				if currentLevel >= 0 { // only wrap it up if there was a run
+					allRuns = append(allRuns, run)
+					run = nil
+				}
+				// Start new run
+				currentLevel = p.resultLevels[i]
+			}
+			run = append(run, i)
+		}
+	}
+	// Wrap up the final run, if any
+	if len(run) > 0 {
+		allRuns = append(allRuns, run)
+	}
+	return allRuns
+}
+
+// Definition BD13. Determine isolating run sequences.
+func (p *paragraph) determineIsolatingRunSequences() []*isolatingRunSequence {
+	levelRuns := p.determineLevelRuns()
+
+	// Compute the run that each character belongs to
+	runForCharacter := make([]int, p.Len())
+	for i, run := range levelRuns {
+		for _, index := range run {
+			runForCharacter[index] = i
+		}
+	}
+
+	sequences := []*isolatingRunSequence{}
+
+	var currentRunSequence []int
+
+	for _, run := range levelRuns {
+		first := run[0]
+		if p.initialTypes[first] != PDI || p.matchingIsolateInitiator[first] == -1 {
+			currentRunSequence = nil
+			// int run = i;
+			for {
+				// Copy this level run into currentRunSequence
+				currentRunSequence = append(currentRunSequence, run...)
+
+				last := currentRunSequence[len(currentRunSequence)-1]
+				lastT := p.initialTypes[last]
+				if lastT.in(LRI, RLI, FSI) && p.matchingPDI[last] != p.Len() {
+					run = levelRuns[runForCharacter[p.matchingPDI[last]]]
+				} else {
+					break
+				}
+			}
+			sequences = append(sequences, p.isolatingRunSequence(currentRunSequence))
+		}
+	}
+	return sequences
+}
+
+// Assign level information to characters removed by rule X9. This is for
+// ease of relating the level information to the original input data. Note
+// that the levels assigned to these codes are arbitrary, they're chosen so
+// as to avoid breaking level runs.
+func (p *paragraph) assignLevelsToCharactersRemovedByX9() {
+	for i, t := range p.initialTypes {
+		if t.in(LRE, RLE, LRO, RLO, PDF, BN) {
+			p.resultTypes[i] = t
+			p.resultLevels[i] = -1
+		}
+	}
+	// now propagate forward the levels information (could have
+	// propagated backward, the main thing is not to introduce a level
+	// break where one doesn't already exist).
+
+	if p.resultLevels[0] == -1 {
+		p.resultLevels[0] = p.embeddingLevel
+	}
+	for i := 1; i < len(p.initialTypes); i++ {
+		if p.resultLevels[i] == -1 {
+			p.resultLevels[i] = p.resultLevels[i-1]
+		}
+	}
+	// Embedding information is for informational purposes only so need not be
+	// adjusted.
+}
+
+//
+// Output
+//
+
+// getLevels computes levels array breaking lines at offsets in linebreaks.
+// Rule L1.
+//
+// The linebreaks array must include at least one value. The values must be
+// in strictly increasing order (no duplicates) between 1 and the length of
+// the text, inclusive. The last value must be the length of the text.
+func (p *paragraph) getLevels(linebreaks []int) []level {
+	// Note that since the previous processing has removed all
+	// P, S, and WS values from resultTypes, the values referred to
+	// in these rules are the initial types, before any processing
+	// has been applied (including processing of overrides).
+	//
+	// This example implementation has reinserted explicit format codes
+	// and BN, in order that the levels array correspond to the
+	// initial text. Their final placement is not normative.
+	// These codes are treated like WS in this implementation,
+	// so they don't interrupt sequences of WS.
+
+	validateLineBreaks(linebreaks, p.Len())
+
+	result := append([]level(nil), p.resultLevels...)
+
+	// don't worry about linebreaks since if there is a break within
+	// a series of WS values preceding S, the linebreak itself
+	// causes the reset.
+	for i, t := range p.initialTypes {
+		if t.in(B, S) {
+			// Rule L1, clauses one and two.
+			result[i] = p.embeddingLevel
+
+			// Rule L1, clause three.
+			for j := i - 1; j >= 0; j-- {
+				if isWhitespace(p.initialTypes[j]) { // including format codes
+					result[j] = p.embeddingLevel
+				} else {
+					break
+				}
+			}
+		}
+	}
+
+	// Rule L1, clause four.
+	start := 0
+	for _, limit := range linebreaks {
+		for j := limit - 1; j >= start; j-- {
+			if isWhitespace(p.initialTypes[j]) { // including format codes
+				result[j] = p.embeddingLevel
+			} else {
+				break
+			}
+		}
+		start = limit
+	}
+
+	return result
+}
+
+// getReordering returns the reordering of lines from a visual index to a
+// logical index for line breaks at the given offsets.
+//
+// Lines are concatenated from left to right. So for example, the fifth
+// character from the left on the third line is
+//
+// 		getReordering(linebreaks)[linebreaks[1] + 4]
+//
+// (linebreaks[1] is the position after the last character of the second
+// line, which is also the index of the first character on the third line,
+// and adding four gets the fifth character from the left).
+//
+// The linebreaks array must include at least one value. The values must be
+// in strictly increasing order (no duplicates) between 1 and the length of
+// the text, inclusive. The last value must be the length of the text.
+func (p *paragraph) getReordering(linebreaks []int) []int {
+	validateLineBreaks(linebreaks, p.Len())
+
+	return computeMultilineReordering(p.getLevels(linebreaks), linebreaks)
+}
+
+// Return multiline reordering array for a given level array. Reordering
+// does not occur across a line break.
+func computeMultilineReordering(levels []level, linebreaks []int) []int {
+	result := make([]int, len(levels))
+
+	start := 0
+	for _, limit := range linebreaks {
+		tempLevels := make([]level, limit-start)
+		copy(tempLevels, levels[start:])
+
+		for j, order := range computeReordering(tempLevels) {
+			result[start+j] = order + start
+		}
+		start = limit
+	}
+	return result
+}
+
+// Return reordering array for a given level array. This reorders a single
+// line. The reordering is a visual to logical map. For example, the
+// leftmost char is string.charAt(order[0]). Rule L2.
+func computeReordering(levels []level) []int {
+	result := make([]int, len(levels))
+	// initialize order
+	for i := range result {
+		result[i] = i
+	}
+
+	// locate highest level found on line.
+	// Note the rules say text, but no reordering across line bounds is
+	// performed, so this is sufficient.
+	highestLevel := level(0)
+	lowestOddLevel := level(maxDepth + 2)
+	for _, level := range levels {
+		if level > highestLevel {
+			highestLevel = level
+		}
+		if level&1 != 0 && level < lowestOddLevel {
+			lowestOddLevel = level
+		}
+	}
+
+	for level := highestLevel; level >= lowestOddLevel; level-- {
+		for i := 0; i < len(levels); i++ {
+			if levels[i] >= level {
+				// find range of text at or above this level
+				start := i
+				limit := i + 1
+				for limit < len(levels) && levels[limit] >= level {
+					limit++
+				}
+
+				for j, k := start, limit-1; j < k; j, k = j+1, k-1 {
+					result[j], result[k] = result[k], result[j]
+				}
+				// skip to end of level run
+				i = limit
+			}
+		}
+	}
+
+	return result
+}
+
+// isWhitespace reports whether the type is considered a whitespace type for the
+// line break rules.
+func isWhitespace(c Class) bool {
+	switch c {
+	case LRE, RLE, LRO, RLO, PDF, LRI, RLI, FSI, PDI, BN, WS:
+		return true
+	}
+	return false
+}
+
+// isRemovedByX9 reports whether the type is one of the types removed in X9.
+func isRemovedByX9(c Class) bool {
+	switch c {
+	case LRE, RLE, LRO, RLO, PDF, BN:
+		return true
+	}
+	return false
+}
+
+// typeForLevel reports the strong type (L or R) corresponding to the level.
+func typeForLevel(level level) Class {
+	if (level & 0x1) == 0 {
+		return L
+	}
+	return R
+}
+
+// TODO: change validation to not panic
+
+func validateTypes(types []Class) {
+	if len(types) == 0 {
+		log.Panic("types is null")
+	}
+	for i, t := range types[:len(types)-1] {
+		if t == B {
+			log.Panicf("B type before end of paragraph at index: %d", i)
+		}
+	}
+}
+
+func validateParagraphEmbeddingLevel(embeddingLevel level) {
+	if embeddingLevel != implicitLevel &&
+		embeddingLevel != 0 &&
+		embeddingLevel != 1 {
+		log.Panicf("illegal paragraph embedding level: %d", embeddingLevel)
+	}
+}
+
+func validateLineBreaks(linebreaks []int, textLength int) {
+	prev := 0
+	for i, next := range linebreaks {
+		if next <= prev {
+			log.Panicf("bad linebreak: %d at index: %d", next, i)
+		}
+		prev = next
+	}
+	if prev != textLength {
+		log.Panicf("last linebreak was %d, want %d", prev, textLength)
+	}
+}
+
+func validatePbTypes(pairTypes []bracketType) {
+	if len(pairTypes) == 0 {
+		log.Panic("pairTypes is null")
+	}
+	for i, pt := range pairTypes {
+		switch pt {
+		case bpNone, bpOpen, bpClose:
+		default:
+			log.Panicf("illegal pairType value at %d: %v", i, pairTypes[i])
+		}
+	}
+}
+
+func validatePbValues(pairValues []rune, pairTypes []bracketType) {
+	if pairValues == nil {
+		log.Panic("pairValues is null")
+	}
+	if len(pairTypes) != len(pairValues) {
+		log.Panic("pairTypes is different length from pairValues")
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/bidi/prop.go b/vendor/golang.org/x/text/unicode/bidi/prop.go
new file mode 100644
index 0000000000..7c9484e1f5
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/prop.go
@@ -0,0 +1,206 @@
+// Copyright 2016 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 bidi
+
+import "unicode/utf8"
+
+// Properties provides access to BiDi properties of runes.
+type Properties struct {
+	entry uint8
+	last  uint8
+}
+
+var trie = newBidiTrie(0)
+
+// TODO: using this for bidirule reduces the running time by about 5%. Consider
+// if this is worth exposing or if we can find a way to speed up the Class
+// method.
+//
+// // CompactClass is like Class, but maps all of the BiDi control classes
+// // (LRO, RLO, LRE, RLE, PDF, LRI, RLI, FSI, PDI) to the class Control.
+// func (p Properties) CompactClass() Class {
+// 	return Class(p.entry & 0x0F)
+// }
+
+// Class returns the Bidi class for p.
+func (p Properties) Class() Class {
+	c := Class(p.entry & 0x0F)
+	if c == Control {
+		c = controlByteToClass[p.last&0xF]
+	}
+	return c
+}
+
+// IsBracket reports whether the rune is a bracket.
+func (p Properties) IsBracket() bool { return p.entry&0xF0 != 0 }
+
+// IsOpeningBracket reports whether the rune is an opening bracket.
+// IsBracket must return true.
+func (p Properties) IsOpeningBracket() bool { return p.entry&openMask != 0 }
+
+// TODO: find a better API and expose.
+func (p Properties) reverseBracket(r rune) rune {
+	return xorMasks[p.entry>>xorMaskShift] ^ r
+}
+
+var controlByteToClass = [16]Class{
+	0xD: LRO, // U+202D LeftToRightOverride,
+	0xE: RLO, // U+202E RightToLeftOverride,
+	0xA: LRE, // U+202A LeftToRightEmbedding,
+	0xB: RLE, // U+202B RightToLeftEmbedding,
+	0xC: PDF, // U+202C PopDirectionalFormat,
+	0x6: LRI, // U+2066 LeftToRightIsolate,
+	0x7: RLI, // U+2067 RightToLeftIsolate,
+	0x8: FSI, // U+2068 FirstStrongIsolate,
+	0x9: PDI, // U+2069 PopDirectionalIsolate,
+}
+
+// LookupRune returns properties for r.
+func LookupRune(r rune) (p Properties, size int) {
+	var buf [4]byte
+	n := utf8.EncodeRune(buf[:], r)
+	return Lookup(buf[:n])
+}
+
+// TODO: these lookup methods are based on the generated trie code. The returned
+// sizes have slightly different semantics from the generated code, in that it
+// always returns size==1 for an illegal UTF-8 byte (instead of the length
+// of the maximum invalid subsequence). Most Transformers, like unicode/norm,
+// leave invalid UTF-8 untouched, in which case it has performance benefits to
+// do so (without changing the semantics). Bidi requires the semantics used here
+// for the bidirule implementation to be compatible with the Go semantics.
+//  They ultimately should perhaps be adopted by all trie implementations, for
+// convenience sake.
+// This unrolled code also boosts performance of the secure/bidirule package by
+// about 30%.
+// So, to remove this code:
+//   - add option to trie generator to define return type.
+//   - always return 1 byte size for ill-formed UTF-8 runes.
+
+// Lookup returns properties for the first rune in s and the width in bytes of
+// its encoding. The size will be 0 if s does not hold enough bytes to complete
+// the encoding.
+func Lookup(s []byte) (p Properties, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return Properties{entry: bidiValues[c0]}, 1
+	case c0 < 0xC2:
+		return Properties{}, 1
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c1)}, 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c2), last: c2}, 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return Properties{}, 1
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c3)}, 4
+	}
+	// Illegal rune
+	return Properties{}, 1
+}
+
+// LookupString returns properties for the first rune in s and the width in
+// bytes of its encoding. The size will be 0 if s does not hold enough bytes to
+// complete the encoding.
+func LookupString(s string) (p Properties, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return Properties{entry: bidiValues[c0]}, 1
+	case c0 < 0xC2:
+		return Properties{}, 1
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c1)}, 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c2), last: c2}, 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return Properties{}, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return Properties{}, 1
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return Properties{}, 1
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return Properties{}, 1
+		}
+		return Properties{entry: trie.lookupValue(uint32(i), c3)}, 4
+	}
+	// Illegal rune
+	return Properties{}, 1
+}
diff --git a/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go b/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go
new file mode 100644
index 0000000000..2e1ff19599
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/tables10.0.0.go
@@ -0,0 +1,1815 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// +build go1.10
+
+package bidi
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "10.0.0"
+
+// xorMasks contains masks to be xor-ed with brackets to get the reverse
+// version.
+var xorMasks = []int32{ // 8 elements
+	0, 1, 6, 7, 3, 15, 29, 63,
+} // Size: 56 bytes
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *bidiTrie) lookup(s []byte) (v uint8, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return bidiValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *bidiTrie) lookupUnsafe(s []byte) uint8 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return bidiValues[c0]
+	}
+	i := bidiIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *bidiTrie) lookupString(s string) (v uint8, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return bidiValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *bidiTrie) lookupStringUnsafe(s string) uint8 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return bidiValues[c0]
+	}
+	i := bidiIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// bidiTrie. Total size: 16128 bytes (15.75 KiB). Checksum: 8122d83e461996f.
+type bidiTrie struct{}
+
+func newBidiTrie(i int) *bidiTrie {
+	return &bidiTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *bidiTrie) lookupValue(n uint32, b byte) uint8 {
+	switch {
+	default:
+		return uint8(bidiValues[n<<6+uint32(b)])
+	}
+}
+
+// bidiValues: 228 blocks, 14592 entries, 14592 bytes
+// The third block is the zero block.
+var bidiValues = [14592]uint8{
+	// Block 0x0, offset 0x0
+	0x00: 0x000b, 0x01: 0x000b, 0x02: 0x000b, 0x03: 0x000b, 0x04: 0x000b, 0x05: 0x000b,
+	0x06: 0x000b, 0x07: 0x000b, 0x08: 0x000b, 0x09: 0x0008, 0x0a: 0x0007, 0x0b: 0x0008,
+	0x0c: 0x0009, 0x0d: 0x0007, 0x0e: 0x000b, 0x0f: 0x000b, 0x10: 0x000b, 0x11: 0x000b,
+	0x12: 0x000b, 0x13: 0x000b, 0x14: 0x000b, 0x15: 0x000b, 0x16: 0x000b, 0x17: 0x000b,
+	0x18: 0x000b, 0x19: 0x000b, 0x1a: 0x000b, 0x1b: 0x000b, 0x1c: 0x0007, 0x1d: 0x0007,
+	0x1e: 0x0007, 0x1f: 0x0008, 0x20: 0x0009, 0x21: 0x000a, 0x22: 0x000a, 0x23: 0x0004,
+	0x24: 0x0004, 0x25: 0x0004, 0x26: 0x000a, 0x27: 0x000a, 0x28: 0x003a, 0x29: 0x002a,
+	0x2a: 0x000a, 0x2b: 0x0003, 0x2c: 0x0006, 0x2d: 0x0003, 0x2e: 0x0006, 0x2f: 0x0006,
+	0x30: 0x0002, 0x31: 0x0002, 0x32: 0x0002, 0x33: 0x0002, 0x34: 0x0002, 0x35: 0x0002,
+	0x36: 0x0002, 0x37: 0x0002, 0x38: 0x0002, 0x39: 0x0002, 0x3a: 0x0006, 0x3b: 0x000a,
+	0x3c: 0x000a, 0x3d: 0x000a, 0x3e: 0x000a, 0x3f: 0x000a,
+	// Block 0x1, offset 0x40
+	0x40: 0x000a,
+	0x5b: 0x005a, 0x5c: 0x000a, 0x5d: 0x004a,
+	0x5e: 0x000a, 0x5f: 0x000a, 0x60: 0x000a,
+	0x7b: 0x005a,
+	0x7c: 0x000a, 0x7d: 0x004a, 0x7e: 0x000a, 0x7f: 0x000b,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x000b, 0xc1: 0x000b, 0xc2: 0x000b, 0xc3: 0x000b, 0xc4: 0x000b, 0xc5: 0x0007,
+	0xc6: 0x000b, 0xc7: 0x000b, 0xc8: 0x000b, 0xc9: 0x000b, 0xca: 0x000b, 0xcb: 0x000b,
+	0xcc: 0x000b, 0xcd: 0x000b, 0xce: 0x000b, 0xcf: 0x000b, 0xd0: 0x000b, 0xd1: 0x000b,
+	0xd2: 0x000b, 0xd3: 0x000b, 0xd4: 0x000b, 0xd5: 0x000b, 0xd6: 0x000b, 0xd7: 0x000b,
+	0xd8: 0x000b, 0xd9: 0x000b, 0xda: 0x000b, 0xdb: 0x000b, 0xdc: 0x000b, 0xdd: 0x000b,
+	0xde: 0x000b, 0xdf: 0x000b, 0xe0: 0x0006, 0xe1: 0x000a, 0xe2: 0x0004, 0xe3: 0x0004,
+	0xe4: 0x0004, 0xe5: 0x0004, 0xe6: 0x000a, 0xe7: 0x000a, 0xe8: 0x000a, 0xe9: 0x000a,
+	0xeb: 0x000a, 0xec: 0x000a, 0xed: 0x000b, 0xee: 0x000a, 0xef: 0x000a,
+	0xf0: 0x0004, 0xf1: 0x0004, 0xf2: 0x0002, 0xf3: 0x0002, 0xf4: 0x000a,
+	0xf6: 0x000a, 0xf7: 0x000a, 0xf8: 0x000a, 0xf9: 0x0002, 0xfb: 0x000a,
+	0xfc: 0x000a, 0xfd: 0x000a, 0xfe: 0x000a, 0xff: 0x000a,
+	// Block 0x4, offset 0x100
+	0x117: 0x000a,
+	0x137: 0x000a,
+	// Block 0x5, offset 0x140
+	0x179: 0x000a, 0x17a: 0x000a,
+	// Block 0x6, offset 0x180
+	0x182: 0x000a, 0x183: 0x000a, 0x184: 0x000a, 0x185: 0x000a,
+	0x186: 0x000a, 0x187: 0x000a, 0x188: 0x000a, 0x189: 0x000a, 0x18a: 0x000a, 0x18b: 0x000a,
+	0x18c: 0x000a, 0x18d: 0x000a, 0x18e: 0x000a, 0x18f: 0x000a,
+	0x192: 0x000a, 0x193: 0x000a, 0x194: 0x000a, 0x195: 0x000a, 0x196: 0x000a, 0x197: 0x000a,
+	0x198: 0x000a, 0x199: 0x000a, 0x19a: 0x000a, 0x19b: 0x000a, 0x19c: 0x000a, 0x19d: 0x000a,
+	0x19e: 0x000a, 0x19f: 0x000a,
+	0x1a5: 0x000a, 0x1a6: 0x000a, 0x1a7: 0x000a, 0x1a8: 0x000a, 0x1a9: 0x000a,
+	0x1aa: 0x000a, 0x1ab: 0x000a, 0x1ac: 0x000a, 0x1ad: 0x000a, 0x1af: 0x000a,
+	0x1b0: 0x000a, 0x1b1: 0x000a, 0x1b2: 0x000a, 0x1b3: 0x000a, 0x1b4: 0x000a, 0x1b5: 0x000a,
+	0x1b6: 0x000a, 0x1b7: 0x000a, 0x1b8: 0x000a, 0x1b9: 0x000a, 0x1ba: 0x000a, 0x1bb: 0x000a,
+	0x1bc: 0x000a, 0x1bd: 0x000a, 0x1be: 0x000a, 0x1bf: 0x000a,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x000c, 0x1c1: 0x000c, 0x1c2: 0x000c, 0x1c3: 0x000c, 0x1c4: 0x000c, 0x1c5: 0x000c,
+	0x1c6: 0x000c, 0x1c7: 0x000c, 0x1c8: 0x000c, 0x1c9: 0x000c, 0x1ca: 0x000c, 0x1cb: 0x000c,
+	0x1cc: 0x000c, 0x1cd: 0x000c, 0x1ce: 0x000c, 0x1cf: 0x000c, 0x1d0: 0x000c, 0x1d1: 0x000c,
+	0x1d2: 0x000c, 0x1d3: 0x000c, 0x1d4: 0x000c, 0x1d5: 0x000c, 0x1d6: 0x000c, 0x1d7: 0x000c,
+	0x1d8: 0x000c, 0x1d9: 0x000c, 0x1da: 0x000c, 0x1db: 0x000c, 0x1dc: 0x000c, 0x1dd: 0x000c,
+	0x1de: 0x000c, 0x1df: 0x000c, 0x1e0: 0x000c, 0x1e1: 0x000c, 0x1e2: 0x000c, 0x1e3: 0x000c,
+	0x1e4: 0x000c, 0x1e5: 0x000c, 0x1e6: 0x000c, 0x1e7: 0x000c, 0x1e8: 0x000c, 0x1e9: 0x000c,
+	0x1ea: 0x000c, 0x1eb: 0x000c, 0x1ec: 0x000c, 0x1ed: 0x000c, 0x1ee: 0x000c, 0x1ef: 0x000c,
+	0x1f0: 0x000c, 0x1f1: 0x000c, 0x1f2: 0x000c, 0x1f3: 0x000c, 0x1f4: 0x000c, 0x1f5: 0x000c,
+	0x1f6: 0x000c, 0x1f7: 0x000c, 0x1f8: 0x000c, 0x1f9: 0x000c, 0x1fa: 0x000c, 0x1fb: 0x000c,
+	0x1fc: 0x000c, 0x1fd: 0x000c, 0x1fe: 0x000c, 0x1ff: 0x000c,
+	// Block 0x8, offset 0x200
+	0x200: 0x000c, 0x201: 0x000c, 0x202: 0x000c, 0x203: 0x000c, 0x204: 0x000c, 0x205: 0x000c,
+	0x206: 0x000c, 0x207: 0x000c, 0x208: 0x000c, 0x209: 0x000c, 0x20a: 0x000c, 0x20b: 0x000c,
+	0x20c: 0x000c, 0x20d: 0x000c, 0x20e: 0x000c, 0x20f: 0x000c, 0x210: 0x000c, 0x211: 0x000c,
+	0x212: 0x000c, 0x213: 0x000c, 0x214: 0x000c, 0x215: 0x000c, 0x216: 0x000c, 0x217: 0x000c,
+	0x218: 0x000c, 0x219: 0x000c, 0x21a: 0x000c, 0x21b: 0x000c, 0x21c: 0x000c, 0x21d: 0x000c,
+	0x21e: 0x000c, 0x21f: 0x000c, 0x220: 0x000c, 0x221: 0x000c, 0x222: 0x000c, 0x223: 0x000c,
+	0x224: 0x000c, 0x225: 0x000c, 0x226: 0x000c, 0x227: 0x000c, 0x228: 0x000c, 0x229: 0x000c,
+	0x22a: 0x000c, 0x22b: 0x000c, 0x22c: 0x000c, 0x22d: 0x000c, 0x22e: 0x000c, 0x22f: 0x000c,
+	0x234: 0x000a, 0x235: 0x000a,
+	0x23e: 0x000a,
+	// Block 0x9, offset 0x240
+	0x244: 0x000a, 0x245: 0x000a,
+	0x247: 0x000a,
+	// Block 0xa, offset 0x280
+	0x2b6: 0x000a,
+	// Block 0xb, offset 0x2c0
+	0x2c3: 0x000c, 0x2c4: 0x000c, 0x2c5: 0x000c,
+	0x2c6: 0x000c, 0x2c7: 0x000c, 0x2c8: 0x000c, 0x2c9: 0x000c,
+	// Block 0xc, offset 0x300
+	0x30a: 0x000a,
+	0x30d: 0x000a, 0x30e: 0x000a, 0x30f: 0x0004, 0x310: 0x0001, 0x311: 0x000c,
+	0x312: 0x000c, 0x313: 0x000c, 0x314: 0x000c, 0x315: 0x000c, 0x316: 0x000c, 0x317: 0x000c,
+	0x318: 0x000c, 0x319: 0x000c, 0x31a: 0x000c, 0x31b: 0x000c, 0x31c: 0x000c, 0x31d: 0x000c,
+	0x31e: 0x000c, 0x31f: 0x000c, 0x320: 0x000c, 0x321: 0x000c, 0x322: 0x000c, 0x323: 0x000c,
+	0x324: 0x000c, 0x325: 0x000c, 0x326: 0x000c, 0x327: 0x000c, 0x328: 0x000c, 0x329: 0x000c,
+	0x32a: 0x000c, 0x32b: 0x000c, 0x32c: 0x000c, 0x32d: 0x000c, 0x32e: 0x000c, 0x32f: 0x000c,
+	0x330: 0x000c, 0x331: 0x000c, 0x332: 0x000c, 0x333: 0x000c, 0x334: 0x000c, 0x335: 0x000c,
+	0x336: 0x000c, 0x337: 0x000c, 0x338: 0x000c, 0x339: 0x000c, 0x33a: 0x000c, 0x33b: 0x000c,
+	0x33c: 0x000c, 0x33d: 0x000c, 0x33e: 0x0001, 0x33f: 0x000c,
+	// Block 0xd, offset 0x340
+	0x340: 0x0001, 0x341: 0x000c, 0x342: 0x000c, 0x343: 0x0001, 0x344: 0x000c, 0x345: 0x000c,
+	0x346: 0x0001, 0x347: 0x000c, 0x348: 0x0001, 0x349: 0x0001, 0x34a: 0x0001, 0x34b: 0x0001,
+	0x34c: 0x0001, 0x34d: 0x0001, 0x34e: 0x0001, 0x34f: 0x0001, 0x350: 0x0001, 0x351: 0x0001,
+	0x352: 0x0001, 0x353: 0x0001, 0x354: 0x0001, 0x355: 0x0001, 0x356: 0x0001, 0x357: 0x0001,
+	0x358: 0x0001, 0x359: 0x0001, 0x35a: 0x0001, 0x35b: 0x0001, 0x35c: 0x0001, 0x35d: 0x0001,
+	0x35e: 0x0001, 0x35f: 0x0001, 0x360: 0x0001, 0x361: 0x0001, 0x362: 0x0001, 0x363: 0x0001,
+	0x364: 0x0001, 0x365: 0x0001, 0x366: 0x0001, 0x367: 0x0001, 0x368: 0x0001, 0x369: 0x0001,
+	0x36a: 0x0001, 0x36b: 0x0001, 0x36c: 0x0001, 0x36d: 0x0001, 0x36e: 0x0001, 0x36f: 0x0001,
+	0x370: 0x0001, 0x371: 0x0001, 0x372: 0x0001, 0x373: 0x0001, 0x374: 0x0001, 0x375: 0x0001,
+	0x376: 0x0001, 0x377: 0x0001, 0x378: 0x0001, 0x379: 0x0001, 0x37a: 0x0001, 0x37b: 0x0001,
+	0x37c: 0x0001, 0x37d: 0x0001, 0x37e: 0x0001, 0x37f: 0x0001,
+	// Block 0xe, offset 0x380
+	0x380: 0x0005, 0x381: 0x0005, 0x382: 0x0005, 0x383: 0x0005, 0x384: 0x0005, 0x385: 0x0005,
+	0x386: 0x000a, 0x387: 0x000a, 0x388: 0x000d, 0x389: 0x0004, 0x38a: 0x0004, 0x38b: 0x000d,
+	0x38c: 0x0006, 0x38d: 0x000d, 0x38e: 0x000a, 0x38f: 0x000a, 0x390: 0x000c, 0x391: 0x000c,
+	0x392: 0x000c, 0x393: 0x000c, 0x394: 0x000c, 0x395: 0x000c, 0x396: 0x000c, 0x397: 0x000c,
+	0x398: 0x000c, 0x399: 0x000c, 0x39a: 0x000c, 0x39b: 0x000d, 0x39c: 0x000d, 0x39d: 0x000d,
+	0x39e: 0x000d, 0x39f: 0x000d, 0x3a0: 0x000d, 0x3a1: 0x000d, 0x3a2: 0x000d, 0x3a3: 0x000d,
+	0x3a4: 0x000d, 0x3a5: 0x000d, 0x3a6: 0x000d, 0x3a7: 0x000d, 0x3a8: 0x000d, 0x3a9: 0x000d,
+	0x3aa: 0x000d, 0x3ab: 0x000d, 0x3ac: 0x000d, 0x3ad: 0x000d, 0x3ae: 0x000d, 0x3af: 0x000d,
+	0x3b0: 0x000d, 0x3b1: 0x000d, 0x3b2: 0x000d, 0x3b3: 0x000d, 0x3b4: 0x000d, 0x3b5: 0x000d,
+	0x3b6: 0x000d, 0x3b7: 0x000d, 0x3b8: 0x000d, 0x3b9: 0x000d, 0x3ba: 0x000d, 0x3bb: 0x000d,
+	0x3bc: 0x000d, 0x3bd: 0x000d, 0x3be: 0x000d, 0x3bf: 0x000d,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x000d, 0x3c1: 0x000d, 0x3c2: 0x000d, 0x3c3: 0x000d, 0x3c4: 0x000d, 0x3c5: 0x000d,
+	0x3c6: 0x000d, 0x3c7: 0x000d, 0x3c8: 0x000d, 0x3c9: 0x000d, 0x3ca: 0x000d, 0x3cb: 0x000c,
+	0x3cc: 0x000c, 0x3cd: 0x000c, 0x3ce: 0x000c, 0x3cf: 0x000c, 0x3d0: 0x000c, 0x3d1: 0x000c,
+	0x3d2: 0x000c, 0x3d3: 0x000c, 0x3d4: 0x000c, 0x3d5: 0x000c, 0x3d6: 0x000c, 0x3d7: 0x000c,
+	0x3d8: 0x000c, 0x3d9: 0x000c, 0x3da: 0x000c, 0x3db: 0x000c, 0x3dc: 0x000c, 0x3dd: 0x000c,
+	0x3de: 0x000c, 0x3df: 0x000c, 0x3e0: 0x0005, 0x3e1: 0x0005, 0x3e2: 0x0005, 0x3e3: 0x0005,
+	0x3e4: 0x0005, 0x3e5: 0x0005, 0x3e6: 0x0005, 0x3e7: 0x0005, 0x3e8: 0x0005, 0x3e9: 0x0005,
+	0x3ea: 0x0004, 0x3eb: 0x0005, 0x3ec: 0x0005, 0x3ed: 0x000d, 0x3ee: 0x000d, 0x3ef: 0x000d,
+	0x3f0: 0x000c, 0x3f1: 0x000d, 0x3f2: 0x000d, 0x3f3: 0x000d, 0x3f4: 0x000d, 0x3f5: 0x000d,
+	0x3f6: 0x000d, 0x3f7: 0x000d, 0x3f8: 0x000d, 0x3f9: 0x000d, 0x3fa: 0x000d, 0x3fb: 0x000d,
+	0x3fc: 0x000d, 0x3fd: 0x000d, 0x3fe: 0x000d, 0x3ff: 0x000d,
+	// Block 0x10, offset 0x400
+	0x400: 0x000d, 0x401: 0x000d, 0x402: 0x000d, 0x403: 0x000d, 0x404: 0x000d, 0x405: 0x000d,
+	0x406: 0x000d, 0x407: 0x000d, 0x408: 0x000d, 0x409: 0x000d, 0x40a: 0x000d, 0x40b: 0x000d,
+	0x40c: 0x000d, 0x40d: 0x000d, 0x40e: 0x000d, 0x40f: 0x000d, 0x410: 0x000d, 0x411: 0x000d,
+	0x412: 0x000d, 0x413: 0x000d, 0x414: 0x000d, 0x415: 0x000d, 0x416: 0x000d, 0x417: 0x000d,
+	0x418: 0x000d, 0x419: 0x000d, 0x41a: 0x000d, 0x41b: 0x000d, 0x41c: 0x000d, 0x41d: 0x000d,
+	0x41e: 0x000d, 0x41f: 0x000d, 0x420: 0x000d, 0x421: 0x000d, 0x422: 0x000d, 0x423: 0x000d,
+	0x424: 0x000d, 0x425: 0x000d, 0x426: 0x000d, 0x427: 0x000d, 0x428: 0x000d, 0x429: 0x000d,
+	0x42a: 0x000d, 0x42b: 0x000d, 0x42c: 0x000d, 0x42d: 0x000d, 0x42e: 0x000d, 0x42f: 0x000d,
+	0x430: 0x000d, 0x431: 0x000d, 0x432: 0x000d, 0x433: 0x000d, 0x434: 0x000d, 0x435: 0x000d,
+	0x436: 0x000d, 0x437: 0x000d, 0x438: 0x000d, 0x439: 0x000d, 0x43a: 0x000d, 0x43b: 0x000d,
+	0x43c: 0x000d, 0x43d: 0x000d, 0x43e: 0x000d, 0x43f: 0x000d,
+	// Block 0x11, offset 0x440
+	0x440: 0x000d, 0x441: 0x000d, 0x442: 0x000d, 0x443: 0x000d, 0x444: 0x000d, 0x445: 0x000d,
+	0x446: 0x000d, 0x447: 0x000d, 0x448: 0x000d, 0x449: 0x000d, 0x44a: 0x000d, 0x44b: 0x000d,
+	0x44c: 0x000d, 0x44d: 0x000d, 0x44e: 0x000d, 0x44f: 0x000d, 0x450: 0x000d, 0x451: 0x000d,
+	0x452: 0x000d, 0x453: 0x000d, 0x454: 0x000d, 0x455: 0x000d, 0x456: 0x000c, 0x457: 0x000c,
+	0x458: 0x000c, 0x459: 0x000c, 0x45a: 0x000c, 0x45b: 0x000c, 0x45c: 0x000c, 0x45d: 0x0005,
+	0x45e: 0x000a, 0x45f: 0x000c, 0x460: 0x000c, 0x461: 0x000c, 0x462: 0x000c, 0x463: 0x000c,
+	0x464: 0x000c, 0x465: 0x000d, 0x466: 0x000d, 0x467: 0x000c, 0x468: 0x000c, 0x469: 0x000a,
+	0x46a: 0x000c, 0x46b: 0x000c, 0x46c: 0x000c, 0x46d: 0x000c, 0x46e: 0x000d, 0x46f: 0x000d,
+	0x470: 0x0002, 0x471: 0x0002, 0x472: 0x0002, 0x473: 0x0002, 0x474: 0x0002, 0x475: 0x0002,
+	0x476: 0x0002, 0x477: 0x0002, 0x478: 0x0002, 0x479: 0x0002, 0x47a: 0x000d, 0x47b: 0x000d,
+	0x47c: 0x000d, 0x47d: 0x000d, 0x47e: 0x000d, 0x47f: 0x000d,
+	// Block 0x12, offset 0x480
+	0x480: 0x000d, 0x481: 0x000d, 0x482: 0x000d, 0x483: 0x000d, 0x484: 0x000d, 0x485: 0x000d,
+	0x486: 0x000d, 0x487: 0x000d, 0x488: 0x000d, 0x489: 0x000d, 0x48a: 0x000d, 0x48b: 0x000d,
+	0x48c: 0x000d, 0x48d: 0x000d, 0x48e: 0x000d, 0x48f: 0x000d, 0x490: 0x000d, 0x491: 0x000c,
+	0x492: 0x000d, 0x493: 0x000d, 0x494: 0x000d, 0x495: 0x000d, 0x496: 0x000d, 0x497: 0x000d,
+	0x498: 0x000d, 0x499: 0x000d, 0x49a: 0x000d, 0x49b: 0x000d, 0x49c: 0x000d, 0x49d: 0x000d,
+	0x49e: 0x000d, 0x49f: 0x000d, 0x4a0: 0x000d, 0x4a1: 0x000d, 0x4a2: 0x000d, 0x4a3: 0x000d,
+	0x4a4: 0x000d, 0x4a5: 0x000d, 0x4a6: 0x000d, 0x4a7: 0x000d, 0x4a8: 0x000d, 0x4a9: 0x000d,
+	0x4aa: 0x000d, 0x4ab: 0x000d, 0x4ac: 0x000d, 0x4ad: 0x000d, 0x4ae: 0x000d, 0x4af: 0x000d,
+	0x4b0: 0x000c, 0x4b1: 0x000c, 0x4b2: 0x000c, 0x4b3: 0x000c, 0x4b4: 0x000c, 0x4b5: 0x000c,
+	0x4b6: 0x000c, 0x4b7: 0x000c, 0x4b8: 0x000c, 0x4b9: 0x000c, 0x4ba: 0x000c, 0x4bb: 0x000c,
+	0x4bc: 0x000c, 0x4bd: 0x000c, 0x4be: 0x000c, 0x4bf: 0x000c,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x000c, 0x4c1: 0x000c, 0x4c2: 0x000c, 0x4c3: 0x000c, 0x4c4: 0x000c, 0x4c5: 0x000c,
+	0x4c6: 0x000c, 0x4c7: 0x000c, 0x4c8: 0x000c, 0x4c9: 0x000c, 0x4ca: 0x000c, 0x4cb: 0x000d,
+	0x4cc: 0x000d, 0x4cd: 0x000d, 0x4ce: 0x000d, 0x4cf: 0x000d, 0x4d0: 0x000d, 0x4d1: 0x000d,
+	0x4d2: 0x000d, 0x4d3: 0x000d, 0x4d4: 0x000d, 0x4d5: 0x000d, 0x4d6: 0x000d, 0x4d7: 0x000d,
+	0x4d8: 0x000d, 0x4d9: 0x000d, 0x4da: 0x000d, 0x4db: 0x000d, 0x4dc: 0x000d, 0x4dd: 0x000d,
+	0x4de: 0x000d, 0x4df: 0x000d, 0x4e0: 0x000d, 0x4e1: 0x000d, 0x4e2: 0x000d, 0x4e3: 0x000d,
+	0x4e4: 0x000d, 0x4e5: 0x000d, 0x4e6: 0x000d, 0x4e7: 0x000d, 0x4e8: 0x000d, 0x4e9: 0x000d,
+	0x4ea: 0x000d, 0x4eb: 0x000d, 0x4ec: 0x000d, 0x4ed: 0x000d, 0x4ee: 0x000d, 0x4ef: 0x000d,
+	0x4f0: 0x000d, 0x4f1: 0x000d, 0x4f2: 0x000d, 0x4f3: 0x000d, 0x4f4: 0x000d, 0x4f5: 0x000d,
+	0x4f6: 0x000d, 0x4f7: 0x000d, 0x4f8: 0x000d, 0x4f9: 0x000d, 0x4fa: 0x000d, 0x4fb: 0x000d,
+	0x4fc: 0x000d, 0x4fd: 0x000d, 0x4fe: 0x000d, 0x4ff: 0x000d,
+	// Block 0x14, offset 0x500
+	0x500: 0x000d, 0x501: 0x000d, 0x502: 0x000d, 0x503: 0x000d, 0x504: 0x000d, 0x505: 0x000d,
+	0x506: 0x000d, 0x507: 0x000d, 0x508: 0x000d, 0x509: 0x000d, 0x50a: 0x000d, 0x50b: 0x000d,
+	0x50c: 0x000d, 0x50d: 0x000d, 0x50e: 0x000d, 0x50f: 0x000d, 0x510: 0x000d, 0x511: 0x000d,
+	0x512: 0x000d, 0x513: 0x000d, 0x514: 0x000d, 0x515: 0x000d, 0x516: 0x000d, 0x517: 0x000d,
+	0x518: 0x000d, 0x519: 0x000d, 0x51a: 0x000d, 0x51b: 0x000d, 0x51c: 0x000d, 0x51d: 0x000d,
+	0x51e: 0x000d, 0x51f: 0x000d, 0x520: 0x000d, 0x521: 0x000d, 0x522: 0x000d, 0x523: 0x000d,
+	0x524: 0x000d, 0x525: 0x000d, 0x526: 0x000c, 0x527: 0x000c, 0x528: 0x000c, 0x529: 0x000c,
+	0x52a: 0x000c, 0x52b: 0x000c, 0x52c: 0x000c, 0x52d: 0x000c, 0x52e: 0x000c, 0x52f: 0x000c,
+	0x530: 0x000c, 0x531: 0x000d, 0x532: 0x000d, 0x533: 0x000d, 0x534: 0x000d, 0x535: 0x000d,
+	0x536: 0x000d, 0x537: 0x000d, 0x538: 0x000d, 0x539: 0x000d, 0x53a: 0x000d, 0x53b: 0x000d,
+	0x53c: 0x000d, 0x53d: 0x000d, 0x53e: 0x000d, 0x53f: 0x000d,
+	// Block 0x15, offset 0x540
+	0x540: 0x0001, 0x541: 0x0001, 0x542: 0x0001, 0x543: 0x0001, 0x544: 0x0001, 0x545: 0x0001,
+	0x546: 0x0001, 0x547: 0x0001, 0x548: 0x0001, 0x549: 0x0001, 0x54a: 0x0001, 0x54b: 0x0001,
+	0x54c: 0x0001, 0x54d: 0x0001, 0x54e: 0x0001, 0x54f: 0x0001, 0x550: 0x0001, 0x551: 0x0001,
+	0x552: 0x0001, 0x553: 0x0001, 0x554: 0x0001, 0x555: 0x0001, 0x556: 0x0001, 0x557: 0x0001,
+	0x558: 0x0001, 0x559: 0x0001, 0x55a: 0x0001, 0x55b: 0x0001, 0x55c: 0x0001, 0x55d: 0x0001,
+	0x55e: 0x0001, 0x55f: 0x0001, 0x560: 0x0001, 0x561: 0x0001, 0x562: 0x0001, 0x563: 0x0001,
+	0x564: 0x0001, 0x565: 0x0001, 0x566: 0x0001, 0x567: 0x0001, 0x568: 0x0001, 0x569: 0x0001,
+	0x56a: 0x0001, 0x56b: 0x000c, 0x56c: 0x000c, 0x56d: 0x000c, 0x56e: 0x000c, 0x56f: 0x000c,
+	0x570: 0x000c, 0x571: 0x000c, 0x572: 0x000c, 0x573: 0x000c, 0x574: 0x0001, 0x575: 0x0001,
+	0x576: 0x000a, 0x577: 0x000a, 0x578: 0x000a, 0x579: 0x000a, 0x57a: 0x0001, 0x57b: 0x0001,
+	0x57c: 0x0001, 0x57d: 0x0001, 0x57e: 0x0001, 0x57f: 0x0001,
+	// Block 0x16, offset 0x580
+	0x580: 0x0001, 0x581: 0x0001, 0x582: 0x0001, 0x583: 0x0001, 0x584: 0x0001, 0x585: 0x0001,
+	0x586: 0x0001, 0x587: 0x0001, 0x588: 0x0001, 0x589: 0x0001, 0x58a: 0x0001, 0x58b: 0x0001,
+	0x58c: 0x0001, 0x58d: 0x0001, 0x58e: 0x0001, 0x58f: 0x0001, 0x590: 0x0001, 0x591: 0x0001,
+	0x592: 0x0001, 0x593: 0x0001, 0x594: 0x0001, 0x595: 0x0001, 0x596: 0x000c, 0x597: 0x000c,
+	0x598: 0x000c, 0x599: 0x000c, 0x59a: 0x0001, 0x59b: 0x000c, 0x59c: 0x000c, 0x59d: 0x000c,
+	0x59e: 0x000c, 0x59f: 0x000c, 0x5a0: 0x000c, 0x5a1: 0x000c, 0x5a2: 0x000c, 0x5a3: 0x000c,
+	0x5a4: 0x0001, 0x5a5: 0x000c, 0x5a6: 0x000c, 0x5a7: 0x000c, 0x5a8: 0x0001, 0x5a9: 0x000c,
+	0x5aa: 0x000c, 0x5ab: 0x000c, 0x5ac: 0x000c, 0x5ad: 0x000c, 0x5ae: 0x0001, 0x5af: 0x0001,
+	0x5b0: 0x0001, 0x5b1: 0x0001, 0x5b2: 0x0001, 0x5b3: 0x0001, 0x5b4: 0x0001, 0x5b5: 0x0001,
+	0x5b6: 0x0001, 0x5b7: 0x0001, 0x5b8: 0x0001, 0x5b9: 0x0001, 0x5ba: 0x0001, 0x5bb: 0x0001,
+	0x5bc: 0x0001, 0x5bd: 0x0001, 0x5be: 0x0001, 0x5bf: 0x0001,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x0001, 0x5c1: 0x0001, 0x5c2: 0x0001, 0x5c3: 0x0001, 0x5c4: 0x0001, 0x5c5: 0x0001,
+	0x5c6: 0x0001, 0x5c7: 0x0001, 0x5c8: 0x0001, 0x5c9: 0x0001, 0x5ca: 0x0001, 0x5cb: 0x0001,
+	0x5cc: 0x0001, 0x5cd: 0x0001, 0x5ce: 0x0001, 0x5cf: 0x0001, 0x5d0: 0x0001, 0x5d1: 0x0001,
+	0x5d2: 0x0001, 0x5d3: 0x0001, 0x5d4: 0x0001, 0x5d5: 0x0001, 0x5d6: 0x0001, 0x5d7: 0x0001,
+	0x5d8: 0x0001, 0x5d9: 0x000c, 0x5da: 0x000c, 0x5db: 0x000c, 0x5dc: 0x0001, 0x5dd: 0x0001,
+	0x5de: 0x0001, 0x5df: 0x0001, 0x5e0: 0x000d, 0x5e1: 0x000d, 0x5e2: 0x000d, 0x5e3: 0x000d,
+	0x5e4: 0x000d, 0x5e5: 0x000d, 0x5e6: 0x000d, 0x5e7: 0x000d, 0x5e8: 0x000d, 0x5e9: 0x000d,
+	0x5ea: 0x000d, 0x5eb: 0x000d, 0x5ec: 0x000d, 0x5ed: 0x000d, 0x5ee: 0x000d, 0x5ef: 0x000d,
+	0x5f0: 0x0001, 0x5f1: 0x0001, 0x5f2: 0x0001, 0x5f3: 0x0001, 0x5f4: 0x0001, 0x5f5: 0x0001,
+	0x5f6: 0x0001, 0x5f7: 0x0001, 0x5f8: 0x0001, 0x5f9: 0x0001, 0x5fa: 0x0001, 0x5fb: 0x0001,
+	0x5fc: 0x0001, 0x5fd: 0x0001, 0x5fe: 0x0001, 0x5ff: 0x0001,
+	// Block 0x18, offset 0x600
+	0x600: 0x0001, 0x601: 0x0001, 0x602: 0x0001, 0x603: 0x0001, 0x604: 0x0001, 0x605: 0x0001,
+	0x606: 0x0001, 0x607: 0x0001, 0x608: 0x0001, 0x609: 0x0001, 0x60a: 0x0001, 0x60b: 0x0001,
+	0x60c: 0x0001, 0x60d: 0x0001, 0x60e: 0x0001, 0x60f: 0x0001, 0x610: 0x0001, 0x611: 0x0001,
+	0x612: 0x0001, 0x613: 0x0001, 0x614: 0x0001, 0x615: 0x0001, 0x616: 0x0001, 0x617: 0x0001,
+	0x618: 0x0001, 0x619: 0x0001, 0x61a: 0x0001, 0x61b: 0x0001, 0x61c: 0x0001, 0x61d: 0x0001,
+	0x61e: 0x0001, 0x61f: 0x0001, 0x620: 0x000d, 0x621: 0x000d, 0x622: 0x000d, 0x623: 0x000d,
+	0x624: 0x000d, 0x625: 0x000d, 0x626: 0x000d, 0x627: 0x000d, 0x628: 0x000d, 0x629: 0x000d,
+	0x62a: 0x000d, 0x62b: 0x000d, 0x62c: 0x000d, 0x62d: 0x000d, 0x62e: 0x000d, 0x62f: 0x000d,
+	0x630: 0x000d, 0x631: 0x000d, 0x632: 0x000d, 0x633: 0x000d, 0x634: 0x000d, 0x635: 0x000d,
+	0x636: 0x000d, 0x637: 0x000d, 0x638: 0x000d, 0x639: 0x000d, 0x63a: 0x000d, 0x63b: 0x000d,
+	0x63c: 0x000d, 0x63d: 0x000d, 0x63e: 0x000d, 0x63f: 0x000d,
+	// Block 0x19, offset 0x640
+	0x640: 0x000d, 0x641: 0x000d, 0x642: 0x000d, 0x643: 0x000d, 0x644: 0x000d, 0x645: 0x000d,
+	0x646: 0x000d, 0x647: 0x000d, 0x648: 0x000d, 0x649: 0x000d, 0x64a: 0x000d, 0x64b: 0x000d,
+	0x64c: 0x000d, 0x64d: 0x000d, 0x64e: 0x000d, 0x64f: 0x000d, 0x650: 0x000d, 0x651: 0x000d,
+	0x652: 0x000d, 0x653: 0x000d, 0x654: 0x000c, 0x655: 0x000c, 0x656: 0x000c, 0x657: 0x000c,
+	0x658: 0x000c, 0x659: 0x000c, 0x65a: 0x000c, 0x65b: 0x000c, 0x65c: 0x000c, 0x65d: 0x000c,
+	0x65e: 0x000c, 0x65f: 0x000c, 0x660: 0x000c, 0x661: 0x000c, 0x662: 0x0005, 0x663: 0x000c,
+	0x664: 0x000c, 0x665: 0x000c, 0x666: 0x000c, 0x667: 0x000c, 0x668: 0x000c, 0x669: 0x000c,
+	0x66a: 0x000c, 0x66b: 0x000c, 0x66c: 0x000c, 0x66d: 0x000c, 0x66e: 0x000c, 0x66f: 0x000c,
+	0x670: 0x000c, 0x671: 0x000c, 0x672: 0x000c, 0x673: 0x000c, 0x674: 0x000c, 0x675: 0x000c,
+	0x676: 0x000c, 0x677: 0x000c, 0x678: 0x000c, 0x679: 0x000c, 0x67a: 0x000c, 0x67b: 0x000c,
+	0x67c: 0x000c, 0x67d: 0x000c, 0x67e: 0x000c, 0x67f: 0x000c,
+	// Block 0x1a, offset 0x680
+	0x680: 0x000c, 0x681: 0x000c, 0x682: 0x000c,
+	0x6ba: 0x000c,
+	0x6bc: 0x000c,
+	// Block 0x1b, offset 0x6c0
+	0x6c1: 0x000c, 0x6c2: 0x000c, 0x6c3: 0x000c, 0x6c4: 0x000c, 0x6c5: 0x000c,
+	0x6c6: 0x000c, 0x6c7: 0x000c, 0x6c8: 0x000c,
+	0x6cd: 0x000c, 0x6d1: 0x000c,
+	0x6d2: 0x000c, 0x6d3: 0x000c, 0x6d4: 0x000c, 0x6d5: 0x000c, 0x6d6: 0x000c, 0x6d7: 0x000c,
+	0x6e2: 0x000c, 0x6e3: 0x000c,
+	// Block 0x1c, offset 0x700
+	0x701: 0x000c,
+	0x73c: 0x000c,
+	// Block 0x1d, offset 0x740
+	0x741: 0x000c, 0x742: 0x000c, 0x743: 0x000c, 0x744: 0x000c,
+	0x74d: 0x000c,
+	0x762: 0x000c, 0x763: 0x000c,
+	0x772: 0x0004, 0x773: 0x0004,
+	0x77b: 0x0004,
+	// Block 0x1e, offset 0x780
+	0x781: 0x000c, 0x782: 0x000c,
+	0x7bc: 0x000c,
+	// Block 0x1f, offset 0x7c0
+	0x7c1: 0x000c, 0x7c2: 0x000c,
+	0x7c7: 0x000c, 0x7c8: 0x000c, 0x7cb: 0x000c,
+	0x7cc: 0x000c, 0x7cd: 0x000c, 0x7d1: 0x000c,
+	0x7f0: 0x000c, 0x7f1: 0x000c, 0x7f5: 0x000c,
+	// Block 0x20, offset 0x800
+	0x801: 0x000c, 0x802: 0x000c, 0x803: 0x000c, 0x804: 0x000c, 0x805: 0x000c,
+	0x807: 0x000c, 0x808: 0x000c,
+	0x80d: 0x000c,
+	0x822: 0x000c, 0x823: 0x000c,
+	0x831: 0x0004,
+	0x83a: 0x000c, 0x83b: 0x000c,
+	0x83c: 0x000c, 0x83d: 0x000c, 0x83e: 0x000c, 0x83f: 0x000c,
+	// Block 0x21, offset 0x840
+	0x841: 0x000c,
+	0x87c: 0x000c, 0x87f: 0x000c,
+	// Block 0x22, offset 0x880
+	0x881: 0x000c, 0x882: 0x000c, 0x883: 0x000c, 0x884: 0x000c,
+	0x88d: 0x000c,
+	0x896: 0x000c,
+	0x8a2: 0x000c, 0x8a3: 0x000c,
+	// Block 0x23, offset 0x8c0
+	0x8c2: 0x000c,
+	// Block 0x24, offset 0x900
+	0x900: 0x000c,
+	0x90d: 0x000c,
+	0x933: 0x000a, 0x934: 0x000a, 0x935: 0x000a,
+	0x936: 0x000a, 0x937: 0x000a, 0x938: 0x000a, 0x939: 0x0004, 0x93a: 0x000a,
+	// Block 0x25, offset 0x940
+	0x940: 0x000c,
+	0x97e: 0x000c, 0x97f: 0x000c,
+	// Block 0x26, offset 0x980
+	0x980: 0x000c,
+	0x986: 0x000c, 0x987: 0x000c, 0x988: 0x000c, 0x98a: 0x000c, 0x98b: 0x000c,
+	0x98c: 0x000c, 0x98d: 0x000c,
+	0x995: 0x000c, 0x996: 0x000c,
+	0x9a2: 0x000c, 0x9a3: 0x000c,
+	0x9b8: 0x000a, 0x9b9: 0x000a, 0x9ba: 0x000a, 0x9bb: 0x000a,
+	0x9bc: 0x000a, 0x9bd: 0x000a, 0x9be: 0x000a,
+	// Block 0x27, offset 0x9c0
+	0x9cc: 0x000c, 0x9cd: 0x000c,
+	0x9e2: 0x000c, 0x9e3: 0x000c,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x000c, 0xa01: 0x000c,
+	0xa3b: 0x000c,
+	0xa3c: 0x000c,
+	// Block 0x29, offset 0xa40
+	0xa41: 0x000c, 0xa42: 0x000c, 0xa43: 0x000c, 0xa44: 0x000c,
+	0xa4d: 0x000c,
+	0xa62: 0x000c, 0xa63: 0x000c,
+	// Block 0x2a, offset 0xa80
+	0xa8a: 0x000c,
+	0xa92: 0x000c, 0xa93: 0x000c, 0xa94: 0x000c, 0xa96: 0x000c,
+	// Block 0x2b, offset 0xac0
+	0xaf1: 0x000c, 0xaf4: 0x000c, 0xaf5: 0x000c,
+	0xaf6: 0x000c, 0xaf7: 0x000c, 0xaf8: 0x000c, 0xaf9: 0x000c, 0xafa: 0x000c,
+	0xaff: 0x0004,
+	// Block 0x2c, offset 0xb00
+	0xb07: 0x000c, 0xb08: 0x000c, 0xb09: 0x000c, 0xb0a: 0x000c, 0xb0b: 0x000c,
+	0xb0c: 0x000c, 0xb0d: 0x000c, 0xb0e: 0x000c,
+	// Block 0x2d, offset 0xb40
+	0xb71: 0x000c, 0xb74: 0x000c, 0xb75: 0x000c,
+	0xb76: 0x000c, 0xb77: 0x000c, 0xb78: 0x000c, 0xb79: 0x000c, 0xb7b: 0x000c,
+	0xb7c: 0x000c,
+	// Block 0x2e, offset 0xb80
+	0xb88: 0x000c, 0xb89: 0x000c, 0xb8a: 0x000c, 0xb8b: 0x000c,
+	0xb8c: 0x000c, 0xb8d: 0x000c,
+	// Block 0x2f, offset 0xbc0
+	0xbd8: 0x000c, 0xbd9: 0x000c,
+	0xbf5: 0x000c,
+	0xbf7: 0x000c, 0xbf9: 0x000c, 0xbfa: 0x003a, 0xbfb: 0x002a,
+	0xbfc: 0x003a, 0xbfd: 0x002a,
+	// Block 0x30, offset 0xc00
+	0xc31: 0x000c, 0xc32: 0x000c, 0xc33: 0x000c, 0xc34: 0x000c, 0xc35: 0x000c,
+	0xc36: 0x000c, 0xc37: 0x000c, 0xc38: 0x000c, 0xc39: 0x000c, 0xc3a: 0x000c, 0xc3b: 0x000c,
+	0xc3c: 0x000c, 0xc3d: 0x000c, 0xc3e: 0x000c,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x000c, 0xc41: 0x000c, 0xc42: 0x000c, 0xc43: 0x000c, 0xc44: 0x000c,
+	0xc46: 0x000c, 0xc47: 0x000c,
+	0xc4d: 0x000c, 0xc4e: 0x000c, 0xc4f: 0x000c, 0xc50: 0x000c, 0xc51: 0x000c,
+	0xc52: 0x000c, 0xc53: 0x000c, 0xc54: 0x000c, 0xc55: 0x000c, 0xc56: 0x000c, 0xc57: 0x000c,
+	0xc59: 0x000c, 0xc5a: 0x000c, 0xc5b: 0x000c, 0xc5c: 0x000c, 0xc5d: 0x000c,
+	0xc5e: 0x000c, 0xc5f: 0x000c, 0xc60: 0x000c, 0xc61: 0x000c, 0xc62: 0x000c, 0xc63: 0x000c,
+	0xc64: 0x000c, 0xc65: 0x000c, 0xc66: 0x000c, 0xc67: 0x000c, 0xc68: 0x000c, 0xc69: 0x000c,
+	0xc6a: 0x000c, 0xc6b: 0x000c, 0xc6c: 0x000c, 0xc6d: 0x000c, 0xc6e: 0x000c, 0xc6f: 0x000c,
+	0xc70: 0x000c, 0xc71: 0x000c, 0xc72: 0x000c, 0xc73: 0x000c, 0xc74: 0x000c, 0xc75: 0x000c,
+	0xc76: 0x000c, 0xc77: 0x000c, 0xc78: 0x000c, 0xc79: 0x000c, 0xc7a: 0x000c, 0xc7b: 0x000c,
+	0xc7c: 0x000c,
+	// Block 0x32, offset 0xc80
+	0xc86: 0x000c,
+	// Block 0x33, offset 0xcc0
+	0xced: 0x000c, 0xcee: 0x000c, 0xcef: 0x000c,
+	0xcf0: 0x000c, 0xcf2: 0x000c, 0xcf3: 0x000c, 0xcf4: 0x000c, 0xcf5: 0x000c,
+	0xcf6: 0x000c, 0xcf7: 0x000c, 0xcf9: 0x000c, 0xcfa: 0x000c,
+	0xcfd: 0x000c, 0xcfe: 0x000c,
+	// Block 0x34, offset 0xd00
+	0xd18: 0x000c, 0xd19: 0x000c,
+	0xd1e: 0x000c, 0xd1f: 0x000c, 0xd20: 0x000c,
+	0xd31: 0x000c, 0xd32: 0x000c, 0xd33: 0x000c, 0xd34: 0x000c,
+	// Block 0x35, offset 0xd40
+	0xd42: 0x000c, 0xd45: 0x000c,
+	0xd46: 0x000c,
+	0xd4d: 0x000c,
+	0xd5d: 0x000c,
+	// Block 0x36, offset 0xd80
+	0xd9d: 0x000c,
+	0xd9e: 0x000c, 0xd9f: 0x000c,
+	// Block 0x37, offset 0xdc0
+	0xdd0: 0x000a, 0xdd1: 0x000a,
+	0xdd2: 0x000a, 0xdd3: 0x000a, 0xdd4: 0x000a, 0xdd5: 0x000a, 0xdd6: 0x000a, 0xdd7: 0x000a,
+	0xdd8: 0x000a, 0xdd9: 0x000a,
+	// Block 0x38, offset 0xe00
+	0xe00: 0x000a,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x0009,
+	0xe5b: 0x007a, 0xe5c: 0x006a,
+	// Block 0x3a, offset 0xe80
+	0xe92: 0x000c, 0xe93: 0x000c, 0xe94: 0x000c,
+	0xeb2: 0x000c, 0xeb3: 0x000c, 0xeb4: 0x000c,
+	// Block 0x3b, offset 0xec0
+	0xed2: 0x000c, 0xed3: 0x000c,
+	0xef2: 0x000c, 0xef3: 0x000c,
+	// Block 0x3c, offset 0xf00
+	0xf34: 0x000c, 0xf35: 0x000c,
+	0xf37: 0x000c, 0xf38: 0x000c, 0xf39: 0x000c, 0xf3a: 0x000c, 0xf3b: 0x000c,
+	0xf3c: 0x000c, 0xf3d: 0x000c,
+	// Block 0x3d, offset 0xf40
+	0xf46: 0x000c, 0xf49: 0x000c, 0xf4a: 0x000c, 0xf4b: 0x000c,
+	0xf4c: 0x000c, 0xf4d: 0x000c, 0xf4e: 0x000c, 0xf4f: 0x000c, 0xf50: 0x000c, 0xf51: 0x000c,
+	0xf52: 0x000c, 0xf53: 0x000c,
+	0xf5b: 0x0004, 0xf5d: 0x000c,
+	0xf70: 0x000a, 0xf71: 0x000a, 0xf72: 0x000a, 0xf73: 0x000a, 0xf74: 0x000a, 0xf75: 0x000a,
+	0xf76: 0x000a, 0xf77: 0x000a, 0xf78: 0x000a, 0xf79: 0x000a,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x000a, 0xf81: 0x000a, 0xf82: 0x000a, 0xf83: 0x000a, 0xf84: 0x000a, 0xf85: 0x000a,
+	0xf86: 0x000a, 0xf87: 0x000a, 0xf88: 0x000a, 0xf89: 0x000a, 0xf8a: 0x000a, 0xf8b: 0x000c,
+	0xf8c: 0x000c, 0xf8d: 0x000c, 0xf8e: 0x000b,
+	// Block 0x3f, offset 0xfc0
+	0xfc5: 0x000c,
+	0xfc6: 0x000c,
+	0xfe9: 0x000c,
+	// Block 0x40, offset 0x1000
+	0x1020: 0x000c, 0x1021: 0x000c, 0x1022: 0x000c,
+	0x1027: 0x000c, 0x1028: 0x000c,
+	0x1032: 0x000c,
+	0x1039: 0x000c, 0x103a: 0x000c, 0x103b: 0x000c,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x000a, 0x1044: 0x000a, 0x1045: 0x000a,
+	// Block 0x42, offset 0x1080
+	0x109e: 0x000a, 0x109f: 0x000a, 0x10a0: 0x000a, 0x10a1: 0x000a, 0x10a2: 0x000a, 0x10a3: 0x000a,
+	0x10a4: 0x000a, 0x10a5: 0x000a, 0x10a6: 0x000a, 0x10a7: 0x000a, 0x10a8: 0x000a, 0x10a9: 0x000a,
+	0x10aa: 0x000a, 0x10ab: 0x000a, 0x10ac: 0x000a, 0x10ad: 0x000a, 0x10ae: 0x000a, 0x10af: 0x000a,
+	0x10b0: 0x000a, 0x10b1: 0x000a, 0x10b2: 0x000a, 0x10b3: 0x000a, 0x10b4: 0x000a, 0x10b5: 0x000a,
+	0x10b6: 0x000a, 0x10b7: 0x000a, 0x10b8: 0x000a, 0x10b9: 0x000a, 0x10ba: 0x000a, 0x10bb: 0x000a,
+	0x10bc: 0x000a, 0x10bd: 0x000a, 0x10be: 0x000a, 0x10bf: 0x000a,
+	// Block 0x43, offset 0x10c0
+	0x10d7: 0x000c,
+	0x10d8: 0x000c, 0x10db: 0x000c,
+	// Block 0x44, offset 0x1100
+	0x1116: 0x000c,
+	0x1118: 0x000c, 0x1119: 0x000c, 0x111a: 0x000c, 0x111b: 0x000c, 0x111c: 0x000c, 0x111d: 0x000c,
+	0x111e: 0x000c, 0x1120: 0x000c, 0x1122: 0x000c,
+	0x1125: 0x000c, 0x1126: 0x000c, 0x1127: 0x000c, 0x1128: 0x000c, 0x1129: 0x000c,
+	0x112a: 0x000c, 0x112b: 0x000c, 0x112c: 0x000c,
+	0x1133: 0x000c, 0x1134: 0x000c, 0x1135: 0x000c,
+	0x1136: 0x000c, 0x1137: 0x000c, 0x1138: 0x000c, 0x1139: 0x000c, 0x113a: 0x000c, 0x113b: 0x000c,
+	0x113c: 0x000c, 0x113f: 0x000c,
+	// Block 0x45, offset 0x1140
+	0x1170: 0x000c, 0x1171: 0x000c, 0x1172: 0x000c, 0x1173: 0x000c, 0x1174: 0x000c, 0x1175: 0x000c,
+	0x1176: 0x000c, 0x1177: 0x000c, 0x1178: 0x000c, 0x1179: 0x000c, 0x117a: 0x000c, 0x117b: 0x000c,
+	0x117c: 0x000c, 0x117d: 0x000c, 0x117e: 0x000c,
+	// Block 0x46, offset 0x1180
+	0x1180: 0x000c, 0x1181: 0x000c, 0x1182: 0x000c, 0x1183: 0x000c,
+	0x11b4: 0x000c,
+	0x11b6: 0x000c, 0x11b7: 0x000c, 0x11b8: 0x000c, 0x11b9: 0x000c, 0x11ba: 0x000c,
+	0x11bc: 0x000c,
+	// Block 0x47, offset 0x11c0
+	0x11c2: 0x000c,
+	0x11eb: 0x000c, 0x11ec: 0x000c, 0x11ed: 0x000c, 0x11ee: 0x000c, 0x11ef: 0x000c,
+	0x11f0: 0x000c, 0x11f1: 0x000c, 0x11f2: 0x000c, 0x11f3: 0x000c,
+	// Block 0x48, offset 0x1200
+	0x1200: 0x000c, 0x1201: 0x000c,
+	0x1222: 0x000c, 0x1223: 0x000c,
+	0x1224: 0x000c, 0x1225: 0x000c, 0x1228: 0x000c, 0x1229: 0x000c,
+	0x122b: 0x000c, 0x122c: 0x000c, 0x122d: 0x000c,
+	// Block 0x49, offset 0x1240
+	0x1266: 0x000c, 0x1268: 0x000c, 0x1269: 0x000c,
+	0x126d: 0x000c, 0x126f: 0x000c,
+	0x1270: 0x000c, 0x1271: 0x000c,
+	// Block 0x4a, offset 0x1280
+	0x12ac: 0x000c, 0x12ad: 0x000c, 0x12ae: 0x000c, 0x12af: 0x000c,
+	0x12b0: 0x000c, 0x12b1: 0x000c, 0x12b2: 0x000c, 0x12b3: 0x000c,
+	0x12b6: 0x000c, 0x12b7: 0x000c,
+	// Block 0x4b, offset 0x12c0
+	0x12d0: 0x000c, 0x12d1: 0x000c,
+	0x12d2: 0x000c, 0x12d4: 0x000c, 0x12d5: 0x000c, 0x12d6: 0x000c, 0x12d7: 0x000c,
+	0x12d8: 0x000c, 0x12d9: 0x000c, 0x12da: 0x000c, 0x12db: 0x000c, 0x12dc: 0x000c, 0x12dd: 0x000c,
+	0x12de: 0x000c, 0x12df: 0x000c, 0x12e0: 0x000c, 0x12e2: 0x000c, 0x12e3: 0x000c,
+	0x12e4: 0x000c, 0x12e5: 0x000c, 0x12e6: 0x000c, 0x12e7: 0x000c, 0x12e8: 0x000c,
+	0x12ed: 0x000c,
+	0x12f4: 0x000c,
+	0x12f8: 0x000c, 0x12f9: 0x000c,
+	// Block 0x4c, offset 0x1300
+	0x1300: 0x000c, 0x1301: 0x000c, 0x1302: 0x000c, 0x1303: 0x000c, 0x1304: 0x000c, 0x1305: 0x000c,
+	0x1306: 0x000c, 0x1307: 0x000c, 0x1308: 0x000c, 0x1309: 0x000c, 0x130a: 0x000c, 0x130b: 0x000c,
+	0x130c: 0x000c, 0x130d: 0x000c, 0x130e: 0x000c, 0x130f: 0x000c, 0x1310: 0x000c, 0x1311: 0x000c,
+	0x1312: 0x000c, 0x1313: 0x000c, 0x1314: 0x000c, 0x1315: 0x000c, 0x1316: 0x000c, 0x1317: 0x000c,
+	0x1318: 0x000c, 0x1319: 0x000c, 0x131a: 0x000c, 0x131b: 0x000c, 0x131c: 0x000c, 0x131d: 0x000c,
+	0x131e: 0x000c, 0x131f: 0x000c, 0x1320: 0x000c, 0x1321: 0x000c, 0x1322: 0x000c, 0x1323: 0x000c,
+	0x1324: 0x000c, 0x1325: 0x000c, 0x1326: 0x000c, 0x1327: 0x000c, 0x1328: 0x000c, 0x1329: 0x000c,
+	0x132a: 0x000c, 0x132b: 0x000c, 0x132c: 0x000c, 0x132d: 0x000c, 0x132e: 0x000c, 0x132f: 0x000c,
+	0x1330: 0x000c, 0x1331: 0x000c, 0x1332: 0x000c, 0x1333: 0x000c, 0x1334: 0x000c, 0x1335: 0x000c,
+	0x1336: 0x000c, 0x1337: 0x000c, 0x1338: 0x000c, 0x1339: 0x000c, 0x133b: 0x000c,
+	0x133c: 0x000c, 0x133d: 0x000c, 0x133e: 0x000c, 0x133f: 0x000c,
+	// Block 0x4d, offset 0x1340
+	0x137d: 0x000a, 0x137f: 0x000a,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x000a, 0x1381: 0x000a,
+	0x138d: 0x000a, 0x138e: 0x000a, 0x138f: 0x000a,
+	0x139d: 0x000a,
+	0x139e: 0x000a, 0x139f: 0x000a,
+	0x13ad: 0x000a, 0x13ae: 0x000a, 0x13af: 0x000a,
+	0x13bd: 0x000a, 0x13be: 0x000a,
+	// Block 0x4f, offset 0x13c0
+	0x13c0: 0x0009, 0x13c1: 0x0009, 0x13c2: 0x0009, 0x13c3: 0x0009, 0x13c4: 0x0009, 0x13c5: 0x0009,
+	0x13c6: 0x0009, 0x13c7: 0x0009, 0x13c8: 0x0009, 0x13c9: 0x0009, 0x13ca: 0x0009, 0x13cb: 0x000b,
+	0x13cc: 0x000b, 0x13cd: 0x000b, 0x13cf: 0x0001, 0x13d0: 0x000a, 0x13d1: 0x000a,
+	0x13d2: 0x000a, 0x13d3: 0x000a, 0x13d4: 0x000a, 0x13d5: 0x000a, 0x13d6: 0x000a, 0x13d7: 0x000a,
+	0x13d8: 0x000a, 0x13d9: 0x000a, 0x13da: 0x000a, 0x13db: 0x000a, 0x13dc: 0x000a, 0x13dd: 0x000a,
+	0x13de: 0x000a, 0x13df: 0x000a, 0x13e0: 0x000a, 0x13e1: 0x000a, 0x13e2: 0x000a, 0x13e3: 0x000a,
+	0x13e4: 0x000a, 0x13e5: 0x000a, 0x13e6: 0x000a, 0x13e7: 0x000a, 0x13e8: 0x0009, 0x13e9: 0x0007,
+	0x13ea: 0x000e, 0x13eb: 0x000e, 0x13ec: 0x000e, 0x13ed: 0x000e, 0x13ee: 0x000e, 0x13ef: 0x0006,
+	0x13f0: 0x0004, 0x13f1: 0x0004, 0x13f2: 0x0004, 0x13f3: 0x0004, 0x13f4: 0x0004, 0x13f5: 0x000a,
+	0x13f6: 0x000a, 0x13f7: 0x000a, 0x13f8: 0x000a, 0x13f9: 0x000a, 0x13fa: 0x000a, 0x13fb: 0x000a,
+	0x13fc: 0x000a, 0x13fd: 0x000a, 0x13fe: 0x000a, 0x13ff: 0x000a,
+	// Block 0x50, offset 0x1400
+	0x1400: 0x000a, 0x1401: 0x000a, 0x1402: 0x000a, 0x1403: 0x000a, 0x1404: 0x0006, 0x1405: 0x009a,
+	0x1406: 0x008a, 0x1407: 0x000a, 0x1408: 0x000a, 0x1409: 0x000a, 0x140a: 0x000a, 0x140b: 0x000a,
+	0x140c: 0x000a, 0x140d: 0x000a, 0x140e: 0x000a, 0x140f: 0x000a, 0x1410: 0x000a, 0x1411: 0x000a,
+	0x1412: 0x000a, 0x1413: 0x000a, 0x1414: 0x000a, 0x1415: 0x000a, 0x1416: 0x000a, 0x1417: 0x000a,
+	0x1418: 0x000a, 0x1419: 0x000a, 0x141a: 0x000a, 0x141b: 0x000a, 0x141c: 0x000a, 0x141d: 0x000a,
+	0x141e: 0x000a, 0x141f: 0x0009, 0x1420: 0x000b, 0x1421: 0x000b, 0x1422: 0x000b, 0x1423: 0x000b,
+	0x1424: 0x000b, 0x1425: 0x000b, 0x1426: 0x000e, 0x1427: 0x000e, 0x1428: 0x000e, 0x1429: 0x000e,
+	0x142a: 0x000b, 0x142b: 0x000b, 0x142c: 0x000b, 0x142d: 0x000b, 0x142e: 0x000b, 0x142f: 0x000b,
+	0x1430: 0x0002, 0x1434: 0x0002, 0x1435: 0x0002,
+	0x1436: 0x0002, 0x1437: 0x0002, 0x1438: 0x0002, 0x1439: 0x0002, 0x143a: 0x0003, 0x143b: 0x0003,
+	0x143c: 0x000a, 0x143d: 0x009a, 0x143e: 0x008a,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x0002, 0x1441: 0x0002, 0x1442: 0x0002, 0x1443: 0x0002, 0x1444: 0x0002, 0x1445: 0x0002,
+	0x1446: 0x0002, 0x1447: 0x0002, 0x1448: 0x0002, 0x1449: 0x0002, 0x144a: 0x0003, 0x144b: 0x0003,
+	0x144c: 0x000a, 0x144d: 0x009a, 0x144e: 0x008a,
+	0x1460: 0x0004, 0x1461: 0x0004, 0x1462: 0x0004, 0x1463: 0x0004,
+	0x1464: 0x0004, 0x1465: 0x0004, 0x1466: 0x0004, 0x1467: 0x0004, 0x1468: 0x0004, 0x1469: 0x0004,
+	0x146a: 0x0004, 0x146b: 0x0004, 0x146c: 0x0004, 0x146d: 0x0004, 0x146e: 0x0004, 0x146f: 0x0004,
+	0x1470: 0x0004, 0x1471: 0x0004, 0x1472: 0x0004, 0x1473: 0x0004, 0x1474: 0x0004, 0x1475: 0x0004,
+	0x1476: 0x0004, 0x1477: 0x0004, 0x1478: 0x0004, 0x1479: 0x0004, 0x147a: 0x0004, 0x147b: 0x0004,
+	0x147c: 0x0004, 0x147d: 0x0004, 0x147e: 0x0004, 0x147f: 0x0004,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x0004, 0x1481: 0x0004, 0x1482: 0x0004, 0x1483: 0x0004, 0x1484: 0x0004, 0x1485: 0x0004,
+	0x1486: 0x0004, 0x1487: 0x0004, 0x1488: 0x0004, 0x1489: 0x0004, 0x148a: 0x0004, 0x148b: 0x0004,
+	0x148c: 0x0004, 0x148d: 0x0004, 0x148e: 0x0004, 0x148f: 0x0004, 0x1490: 0x000c, 0x1491: 0x000c,
+	0x1492: 0x000c, 0x1493: 0x000c, 0x1494: 0x000c, 0x1495: 0x000c, 0x1496: 0x000c, 0x1497: 0x000c,
+	0x1498: 0x000c, 0x1499: 0x000c, 0x149a: 0x000c, 0x149b: 0x000c, 0x149c: 0x000c, 0x149d: 0x000c,
+	0x149e: 0x000c, 0x149f: 0x000c, 0x14a0: 0x000c, 0x14a1: 0x000c, 0x14a2: 0x000c, 0x14a3: 0x000c,
+	0x14a4: 0x000c, 0x14a5: 0x000c, 0x14a6: 0x000c, 0x14a7: 0x000c, 0x14a8: 0x000c, 0x14a9: 0x000c,
+	0x14aa: 0x000c, 0x14ab: 0x000c, 0x14ac: 0x000c, 0x14ad: 0x000c, 0x14ae: 0x000c, 0x14af: 0x000c,
+	0x14b0: 0x000c,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x000a, 0x14c1: 0x000a, 0x14c3: 0x000a, 0x14c4: 0x000a, 0x14c5: 0x000a,
+	0x14c6: 0x000a, 0x14c8: 0x000a, 0x14c9: 0x000a,
+	0x14d4: 0x000a, 0x14d6: 0x000a, 0x14d7: 0x000a,
+	0x14d8: 0x000a,
+	0x14de: 0x000a, 0x14df: 0x000a, 0x14e0: 0x000a, 0x14e1: 0x000a, 0x14e2: 0x000a, 0x14e3: 0x000a,
+	0x14e5: 0x000a, 0x14e7: 0x000a, 0x14e9: 0x000a,
+	0x14ee: 0x0004,
+	0x14fa: 0x000a, 0x14fb: 0x000a,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x000a, 0x1501: 0x000a, 0x1502: 0x000a, 0x1503: 0x000a, 0x1504: 0x000a,
+	0x150a: 0x000a, 0x150b: 0x000a,
+	0x150c: 0x000a, 0x150d: 0x000a, 0x1510: 0x000a, 0x1511: 0x000a,
+	0x1512: 0x000a, 0x1513: 0x000a, 0x1514: 0x000a, 0x1515: 0x000a, 0x1516: 0x000a, 0x1517: 0x000a,
+	0x1518: 0x000a, 0x1519: 0x000a, 0x151a: 0x000a, 0x151b: 0x000a, 0x151c: 0x000a, 0x151d: 0x000a,
+	0x151e: 0x000a, 0x151f: 0x000a,
+	// Block 0x55, offset 0x1540
+	0x1549: 0x000a, 0x154a: 0x000a, 0x154b: 0x000a,
+	0x1550: 0x000a, 0x1551: 0x000a,
+	0x1552: 0x000a, 0x1553: 0x000a, 0x1554: 0x000a, 0x1555: 0x000a, 0x1556: 0x000a, 0x1557: 0x000a,
+	0x1558: 0x000a, 0x1559: 0x000a, 0x155a: 0x000a, 0x155b: 0x000a, 0x155c: 0x000a, 0x155d: 0x000a,
+	0x155e: 0x000a, 0x155f: 0x000a, 0x1560: 0x000a, 0x1561: 0x000a, 0x1562: 0x000a, 0x1563: 0x000a,
+	0x1564: 0x000a, 0x1565: 0x000a, 0x1566: 0x000a, 0x1567: 0x000a, 0x1568: 0x000a, 0x1569: 0x000a,
+	0x156a: 0x000a, 0x156b: 0x000a, 0x156c: 0x000a, 0x156d: 0x000a, 0x156e: 0x000a, 0x156f: 0x000a,
+	0x1570: 0x000a, 0x1571: 0x000a, 0x1572: 0x000a, 0x1573: 0x000a, 0x1574: 0x000a, 0x1575: 0x000a,
+	0x1576: 0x000a, 0x1577: 0x000a, 0x1578: 0x000a, 0x1579: 0x000a, 0x157a: 0x000a, 0x157b: 0x000a,
+	0x157c: 0x000a, 0x157d: 0x000a, 0x157e: 0x000a, 0x157f: 0x000a,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x000a, 0x1581: 0x000a, 0x1582: 0x000a, 0x1583: 0x000a, 0x1584: 0x000a, 0x1585: 0x000a,
+	0x1586: 0x000a, 0x1587: 0x000a, 0x1588: 0x000a, 0x1589: 0x000a, 0x158a: 0x000a, 0x158b: 0x000a,
+	0x158c: 0x000a, 0x158d: 0x000a, 0x158e: 0x000a, 0x158f: 0x000a, 0x1590: 0x000a, 0x1591: 0x000a,
+	0x1592: 0x000a, 0x1593: 0x000a, 0x1594: 0x000a, 0x1595: 0x000a, 0x1596: 0x000a, 0x1597: 0x000a,
+	0x1598: 0x000a, 0x1599: 0x000a, 0x159a: 0x000a, 0x159b: 0x000a, 0x159c: 0x000a, 0x159d: 0x000a,
+	0x159e: 0x000a, 0x159f: 0x000a, 0x15a0: 0x000a, 0x15a1: 0x000a, 0x15a2: 0x000a, 0x15a3: 0x000a,
+	0x15a4: 0x000a, 0x15a5: 0x000a, 0x15a6: 0x000a, 0x15a7: 0x000a, 0x15a8: 0x000a, 0x15a9: 0x000a,
+	0x15aa: 0x000a, 0x15ab: 0x000a, 0x15ac: 0x000a, 0x15ad: 0x000a, 0x15ae: 0x000a, 0x15af: 0x000a,
+	0x15b0: 0x000a, 0x15b1: 0x000a, 0x15b2: 0x000a, 0x15b3: 0x000a, 0x15b4: 0x000a, 0x15b5: 0x000a,
+	0x15b6: 0x000a, 0x15b7: 0x000a, 0x15b8: 0x000a, 0x15b9: 0x000a, 0x15ba: 0x000a, 0x15bb: 0x000a,
+	0x15bc: 0x000a, 0x15bd: 0x000a, 0x15be: 0x000a, 0x15bf: 0x000a,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0x000a, 0x15c1: 0x000a, 0x15c2: 0x000a, 0x15c3: 0x000a, 0x15c4: 0x000a, 0x15c5: 0x000a,
+	0x15c6: 0x000a, 0x15c7: 0x000a, 0x15c8: 0x000a, 0x15c9: 0x000a, 0x15ca: 0x000a, 0x15cb: 0x000a,
+	0x15cc: 0x000a, 0x15cd: 0x000a, 0x15ce: 0x000a, 0x15cf: 0x000a, 0x15d0: 0x000a, 0x15d1: 0x000a,
+	0x15d2: 0x0003, 0x15d3: 0x0004, 0x15d4: 0x000a, 0x15d5: 0x000a, 0x15d6: 0x000a, 0x15d7: 0x000a,
+	0x15d8: 0x000a, 0x15d9: 0x000a, 0x15da: 0x000a, 0x15db: 0x000a, 0x15dc: 0x000a, 0x15dd: 0x000a,
+	0x15de: 0x000a, 0x15df: 0x000a, 0x15e0: 0x000a, 0x15e1: 0x000a, 0x15e2: 0x000a, 0x15e3: 0x000a,
+	0x15e4: 0x000a, 0x15e5: 0x000a, 0x15e6: 0x000a, 0x15e7: 0x000a, 0x15e8: 0x000a, 0x15e9: 0x000a,
+	0x15ea: 0x000a, 0x15eb: 0x000a, 0x15ec: 0x000a, 0x15ed: 0x000a, 0x15ee: 0x000a, 0x15ef: 0x000a,
+	0x15f0: 0x000a, 0x15f1: 0x000a, 0x15f2: 0x000a, 0x15f3: 0x000a, 0x15f4: 0x000a, 0x15f5: 0x000a,
+	0x15f6: 0x000a, 0x15f7: 0x000a, 0x15f8: 0x000a, 0x15f9: 0x000a, 0x15fa: 0x000a, 0x15fb: 0x000a,
+	0x15fc: 0x000a, 0x15fd: 0x000a, 0x15fe: 0x000a, 0x15ff: 0x000a,
+	// Block 0x58, offset 0x1600
+	0x1600: 0x000a, 0x1601: 0x000a, 0x1602: 0x000a, 0x1603: 0x000a, 0x1604: 0x000a, 0x1605: 0x000a,
+	0x1606: 0x000a, 0x1607: 0x000a, 0x1608: 0x003a, 0x1609: 0x002a, 0x160a: 0x003a, 0x160b: 0x002a,
+	0x160c: 0x000a, 0x160d: 0x000a, 0x160e: 0x000a, 0x160f: 0x000a, 0x1610: 0x000a, 0x1611: 0x000a,
+	0x1612: 0x000a, 0x1613: 0x000a, 0x1614: 0x000a, 0x1615: 0x000a, 0x1616: 0x000a, 0x1617: 0x000a,
+	0x1618: 0x000a, 0x1619: 0x000a, 0x161a: 0x000a, 0x161b: 0x000a, 0x161c: 0x000a, 0x161d: 0x000a,
+	0x161e: 0x000a, 0x161f: 0x000a, 0x1620: 0x000a, 0x1621: 0x000a, 0x1622: 0x000a, 0x1623: 0x000a,
+	0x1624: 0x000a, 0x1625: 0x000a, 0x1626: 0x000a, 0x1627: 0x000a, 0x1628: 0x000a, 0x1629: 0x009a,
+	0x162a: 0x008a, 0x162b: 0x000a, 0x162c: 0x000a, 0x162d: 0x000a, 0x162e: 0x000a, 0x162f: 0x000a,
+	0x1630: 0x000a, 0x1631: 0x000a, 0x1632: 0x000a, 0x1633: 0x000a, 0x1634: 0x000a, 0x1635: 0x000a,
+	// Block 0x59, offset 0x1640
+	0x167b: 0x000a,
+	0x167c: 0x000a, 0x167d: 0x000a, 0x167e: 0x000a, 0x167f: 0x000a,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x000a, 0x1681: 0x000a, 0x1682: 0x000a, 0x1683: 0x000a, 0x1684: 0x000a, 0x1685: 0x000a,
+	0x1686: 0x000a, 0x1687: 0x000a, 0x1688: 0x000a, 0x1689: 0x000a, 0x168a: 0x000a, 0x168b: 0x000a,
+	0x168c: 0x000a, 0x168d: 0x000a, 0x168e: 0x000a, 0x168f: 0x000a, 0x1690: 0x000a, 0x1691: 0x000a,
+	0x1692: 0x000a, 0x1693: 0x000a, 0x1694: 0x000a, 0x1696: 0x000a, 0x1697: 0x000a,
+	0x1698: 0x000a, 0x1699: 0x000a, 0x169a: 0x000a, 0x169b: 0x000a, 0x169c: 0x000a, 0x169d: 0x000a,
+	0x169e: 0x000a, 0x169f: 0x000a, 0x16a0: 0x000a, 0x16a1: 0x000a, 0x16a2: 0x000a, 0x16a3: 0x000a,
+	0x16a4: 0x000a, 0x16a5: 0x000a, 0x16a6: 0x000a, 0x16a7: 0x000a, 0x16a8: 0x000a, 0x16a9: 0x000a,
+	0x16aa: 0x000a, 0x16ab: 0x000a, 0x16ac: 0x000a, 0x16ad: 0x000a, 0x16ae: 0x000a, 0x16af: 0x000a,
+	0x16b0: 0x000a, 0x16b1: 0x000a, 0x16b2: 0x000a, 0x16b3: 0x000a, 0x16b4: 0x000a, 0x16b5: 0x000a,
+	0x16b6: 0x000a, 0x16b7: 0x000a, 0x16b8: 0x000a, 0x16b9: 0x000a, 0x16ba: 0x000a, 0x16bb: 0x000a,
+	0x16bc: 0x000a, 0x16bd: 0x000a, 0x16be: 0x000a, 0x16bf: 0x000a,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x000a, 0x16c1: 0x000a, 0x16c2: 0x000a, 0x16c3: 0x000a, 0x16c4: 0x000a, 0x16c5: 0x000a,
+	0x16c6: 0x000a, 0x16c7: 0x000a, 0x16c8: 0x000a, 0x16c9: 0x000a, 0x16ca: 0x000a, 0x16cb: 0x000a,
+	0x16cc: 0x000a, 0x16cd: 0x000a, 0x16ce: 0x000a, 0x16cf: 0x000a, 0x16d0: 0x000a, 0x16d1: 0x000a,
+	0x16d2: 0x000a, 0x16d3: 0x000a, 0x16d4: 0x000a, 0x16d5: 0x000a, 0x16d6: 0x000a, 0x16d7: 0x000a,
+	0x16d8: 0x000a, 0x16d9: 0x000a, 0x16da: 0x000a, 0x16db: 0x000a, 0x16dc: 0x000a, 0x16dd: 0x000a,
+	0x16de: 0x000a, 0x16df: 0x000a, 0x16e0: 0x000a, 0x16e1: 0x000a, 0x16e2: 0x000a, 0x16e3: 0x000a,
+	0x16e4: 0x000a, 0x16e5: 0x000a, 0x16e6: 0x000a,
+	// Block 0x5c, offset 0x1700
+	0x1700: 0x000a, 0x1701: 0x000a, 0x1702: 0x000a, 0x1703: 0x000a, 0x1704: 0x000a, 0x1705: 0x000a,
+	0x1706: 0x000a, 0x1707: 0x000a, 0x1708: 0x000a, 0x1709: 0x000a, 0x170a: 0x000a,
+	0x1720: 0x000a, 0x1721: 0x000a, 0x1722: 0x000a, 0x1723: 0x000a,
+	0x1724: 0x000a, 0x1725: 0x000a, 0x1726: 0x000a, 0x1727: 0x000a, 0x1728: 0x000a, 0x1729: 0x000a,
+	0x172a: 0x000a, 0x172b: 0x000a, 0x172c: 0x000a, 0x172d: 0x000a, 0x172e: 0x000a, 0x172f: 0x000a,
+	0x1730: 0x000a, 0x1731: 0x000a, 0x1732: 0x000a, 0x1733: 0x000a, 0x1734: 0x000a, 0x1735: 0x000a,
+	0x1736: 0x000a, 0x1737: 0x000a, 0x1738: 0x000a, 0x1739: 0x000a, 0x173a: 0x000a, 0x173b: 0x000a,
+	0x173c: 0x000a, 0x173d: 0x000a, 0x173e: 0x000a, 0x173f: 0x000a,
+	// Block 0x5d, offset 0x1740
+	0x1740: 0x000a, 0x1741: 0x000a, 0x1742: 0x000a, 0x1743: 0x000a, 0x1744: 0x000a, 0x1745: 0x000a,
+	0x1746: 0x000a, 0x1747: 0x000a, 0x1748: 0x0002, 0x1749: 0x0002, 0x174a: 0x0002, 0x174b: 0x0002,
+	0x174c: 0x0002, 0x174d: 0x0002, 0x174e: 0x0002, 0x174f: 0x0002, 0x1750: 0x0002, 0x1751: 0x0002,
+	0x1752: 0x0002, 0x1753: 0x0002, 0x1754: 0x0002, 0x1755: 0x0002, 0x1756: 0x0002, 0x1757: 0x0002,
+	0x1758: 0x0002, 0x1759: 0x0002, 0x175a: 0x0002, 0x175b: 0x0002,
+	// Block 0x5e, offset 0x1780
+	0x17aa: 0x000a, 0x17ab: 0x000a, 0x17ac: 0x000a, 0x17ad: 0x000a, 0x17ae: 0x000a, 0x17af: 0x000a,
+	0x17b0: 0x000a, 0x17b1: 0x000a, 0x17b2: 0x000a, 0x17b3: 0x000a, 0x17b4: 0x000a, 0x17b5: 0x000a,
+	0x17b6: 0x000a, 0x17b7: 0x000a, 0x17b8: 0x000a, 0x17b9: 0x000a, 0x17ba: 0x000a, 0x17bb: 0x000a,
+	0x17bc: 0x000a, 0x17bd: 0x000a, 0x17be: 0x000a, 0x17bf: 0x000a,
+	// Block 0x5f, offset 0x17c0
+	0x17c0: 0x000a, 0x17c1: 0x000a, 0x17c2: 0x000a, 0x17c3: 0x000a, 0x17c4: 0x000a, 0x17c5: 0x000a,
+	0x17c6: 0x000a, 0x17c7: 0x000a, 0x17c8: 0x000a, 0x17c9: 0x000a, 0x17ca: 0x000a, 0x17cb: 0x000a,
+	0x17cc: 0x000a, 0x17cd: 0x000a, 0x17ce: 0x000a, 0x17cf: 0x000a, 0x17d0: 0x000a, 0x17d1: 0x000a,
+	0x17d2: 0x000a, 0x17d3: 0x000a, 0x17d4: 0x000a, 0x17d5: 0x000a, 0x17d6: 0x000a, 0x17d7: 0x000a,
+	0x17d8: 0x000a, 0x17d9: 0x000a, 0x17da: 0x000a, 0x17db: 0x000a, 0x17dc: 0x000a, 0x17dd: 0x000a,
+	0x17de: 0x000a, 0x17df: 0x000a, 0x17e0: 0x000a, 0x17e1: 0x000a, 0x17e2: 0x000a, 0x17e3: 0x000a,
+	0x17e4: 0x000a, 0x17e5: 0x000a, 0x17e6: 0x000a, 0x17e7: 0x000a, 0x17e8: 0x000a, 0x17e9: 0x000a,
+	0x17ea: 0x000a, 0x17eb: 0x000a, 0x17ed: 0x000a, 0x17ee: 0x000a, 0x17ef: 0x000a,
+	0x17f0: 0x000a, 0x17f1: 0x000a, 0x17f2: 0x000a, 0x17f3: 0x000a, 0x17f4: 0x000a, 0x17f5: 0x000a,
+	0x17f6: 0x000a, 0x17f7: 0x000a, 0x17f8: 0x000a, 0x17f9: 0x000a, 0x17fa: 0x000a, 0x17fb: 0x000a,
+	0x17fc: 0x000a, 0x17fd: 0x000a, 0x17fe: 0x000a, 0x17ff: 0x000a,
+	// Block 0x60, offset 0x1800
+	0x1800: 0x000a, 0x1801: 0x000a, 0x1802: 0x000a, 0x1803: 0x000a, 0x1804: 0x000a, 0x1805: 0x000a,
+	0x1806: 0x000a, 0x1807: 0x000a, 0x1808: 0x000a, 0x1809: 0x000a, 0x180a: 0x000a, 0x180b: 0x000a,
+	0x180c: 0x000a, 0x180d: 0x000a, 0x180e: 0x000a, 0x180f: 0x000a, 0x1810: 0x000a, 0x1811: 0x000a,
+	0x1812: 0x000a, 0x1813: 0x000a, 0x1814: 0x000a, 0x1815: 0x000a, 0x1816: 0x000a, 0x1817: 0x000a,
+	0x1818: 0x000a, 0x1819: 0x000a, 0x181a: 0x000a, 0x181b: 0x000a, 0x181c: 0x000a, 0x181d: 0x000a,
+	0x181e: 0x000a, 0x181f: 0x000a, 0x1820: 0x000a, 0x1821: 0x000a, 0x1822: 0x000a, 0x1823: 0x000a,
+	0x1824: 0x000a, 0x1825: 0x000a, 0x1826: 0x000a, 0x1827: 0x000a, 0x1828: 0x003a, 0x1829: 0x002a,
+	0x182a: 0x003a, 0x182b: 0x002a, 0x182c: 0x003a, 0x182d: 0x002a, 0x182e: 0x003a, 0x182f: 0x002a,
+	0x1830: 0x003a, 0x1831: 0x002a, 0x1832: 0x003a, 0x1833: 0x002a, 0x1834: 0x003a, 0x1835: 0x002a,
+	0x1836: 0x000a, 0x1837: 0x000a, 0x1838: 0x000a, 0x1839: 0x000a, 0x183a: 0x000a, 0x183b: 0x000a,
+	0x183c: 0x000a, 0x183d: 0x000a, 0x183e: 0x000a, 0x183f: 0x000a,
+	// Block 0x61, offset 0x1840
+	0x1840: 0x000a, 0x1841: 0x000a, 0x1842: 0x000a, 0x1843: 0x000a, 0x1844: 0x000a, 0x1845: 0x009a,
+	0x1846: 0x008a, 0x1847: 0x000a, 0x1848: 0x000a, 0x1849: 0x000a, 0x184a: 0x000a, 0x184b: 0x000a,
+	0x184c: 0x000a, 0x184d: 0x000a, 0x184e: 0x000a, 0x184f: 0x000a, 0x1850: 0x000a, 0x1851: 0x000a,
+	0x1852: 0x000a, 0x1853: 0x000a, 0x1854: 0x000a, 0x1855: 0x000a, 0x1856: 0x000a, 0x1857: 0x000a,
+	0x1858: 0x000a, 0x1859: 0x000a, 0x185a: 0x000a, 0x185b: 0x000a, 0x185c: 0x000a, 0x185d: 0x000a,
+	0x185e: 0x000a, 0x185f: 0x000a, 0x1860: 0x000a, 0x1861: 0x000a, 0x1862: 0x000a, 0x1863: 0x000a,
+	0x1864: 0x000a, 0x1865: 0x000a, 0x1866: 0x003a, 0x1867: 0x002a, 0x1868: 0x003a, 0x1869: 0x002a,
+	0x186a: 0x003a, 0x186b: 0x002a, 0x186c: 0x003a, 0x186d: 0x002a, 0x186e: 0x003a, 0x186f: 0x002a,
+	0x1870: 0x000a, 0x1871: 0x000a, 0x1872: 0x000a, 0x1873: 0x000a, 0x1874: 0x000a, 0x1875: 0x000a,
+	0x1876: 0x000a, 0x1877: 0x000a, 0x1878: 0x000a, 0x1879: 0x000a, 0x187a: 0x000a, 0x187b: 0x000a,
+	0x187c: 0x000a, 0x187d: 0x000a, 0x187e: 0x000a, 0x187f: 0x000a,
+	// Block 0x62, offset 0x1880
+	0x1880: 0x000a, 0x1881: 0x000a, 0x1882: 0x000a, 0x1883: 0x007a, 0x1884: 0x006a, 0x1885: 0x009a,
+	0x1886: 0x008a, 0x1887: 0x00ba, 0x1888: 0x00aa, 0x1889: 0x009a, 0x188a: 0x008a, 0x188b: 0x007a,
+	0x188c: 0x006a, 0x188d: 0x00da, 0x188e: 0x002a, 0x188f: 0x003a, 0x1890: 0x00ca, 0x1891: 0x009a,
+	0x1892: 0x008a, 0x1893: 0x007a, 0x1894: 0x006a, 0x1895: 0x009a, 0x1896: 0x008a, 0x1897: 0x00ba,
+	0x1898: 0x00aa, 0x1899: 0x000a, 0x189a: 0x000a, 0x189b: 0x000a, 0x189c: 0x000a, 0x189d: 0x000a,
+	0x189e: 0x000a, 0x189f: 0x000a, 0x18a0: 0x000a, 0x18a1: 0x000a, 0x18a2: 0x000a, 0x18a3: 0x000a,
+	0x18a4: 0x000a, 0x18a5: 0x000a, 0x18a6: 0x000a, 0x18a7: 0x000a, 0x18a8: 0x000a, 0x18a9: 0x000a,
+	0x18aa: 0x000a, 0x18ab: 0x000a, 0x18ac: 0x000a, 0x18ad: 0x000a, 0x18ae: 0x000a, 0x18af: 0x000a,
+	0x18b0: 0x000a, 0x18b1: 0x000a, 0x18b2: 0x000a, 0x18b3: 0x000a, 0x18b4: 0x000a, 0x18b5: 0x000a,
+	0x18b6: 0x000a, 0x18b7: 0x000a, 0x18b8: 0x000a, 0x18b9: 0x000a, 0x18ba: 0x000a, 0x18bb: 0x000a,
+	0x18bc: 0x000a, 0x18bd: 0x000a, 0x18be: 0x000a, 0x18bf: 0x000a,
+	// Block 0x63, offset 0x18c0
+	0x18c0: 0x000a, 0x18c1: 0x000a, 0x18c2: 0x000a, 0x18c3: 0x000a, 0x18c4: 0x000a, 0x18c5: 0x000a,
+	0x18c6: 0x000a, 0x18c7: 0x000a, 0x18c8: 0x000a, 0x18c9: 0x000a, 0x18ca: 0x000a, 0x18cb: 0x000a,
+	0x18cc: 0x000a, 0x18cd: 0x000a, 0x18ce: 0x000a, 0x18cf: 0x000a, 0x18d0: 0x000a, 0x18d1: 0x000a,
+	0x18d2: 0x000a, 0x18d3: 0x000a, 0x18d4: 0x000a, 0x18d5: 0x000a, 0x18d6: 0x000a, 0x18d7: 0x000a,
+	0x18d8: 0x003a, 0x18d9: 0x002a, 0x18da: 0x003a, 0x18db: 0x002a, 0x18dc: 0x000a, 0x18dd: 0x000a,
+	0x18de: 0x000a, 0x18df: 0x000a, 0x18e0: 0x000a, 0x18e1: 0x000a, 0x18e2: 0x000a, 0x18e3: 0x000a,
+	0x18e4: 0x000a, 0x18e5: 0x000a, 0x18e6: 0x000a, 0x18e7: 0x000a, 0x18e8: 0x000a, 0x18e9: 0x000a,
+	0x18ea: 0x000a, 0x18eb: 0x000a, 0x18ec: 0x000a, 0x18ed: 0x000a, 0x18ee: 0x000a, 0x18ef: 0x000a,
+	0x18f0: 0x000a, 0x18f1: 0x000a, 0x18f2: 0x000a, 0x18f3: 0x000a, 0x18f4: 0x000a, 0x18f5: 0x000a,
+	0x18f6: 0x000a, 0x18f7: 0x000a, 0x18f8: 0x000a, 0x18f9: 0x000a, 0x18fa: 0x000a, 0x18fb: 0x000a,
+	0x18fc: 0x003a, 0x18fd: 0x002a, 0x18fe: 0x000a, 0x18ff: 0x000a,
+	// Block 0x64, offset 0x1900
+	0x1900: 0x000a, 0x1901: 0x000a, 0x1902: 0x000a, 0x1903: 0x000a, 0x1904: 0x000a, 0x1905: 0x000a,
+	0x1906: 0x000a, 0x1907: 0x000a, 0x1908: 0x000a, 0x1909: 0x000a, 0x190a: 0x000a, 0x190b: 0x000a,
+	0x190c: 0x000a, 0x190d: 0x000a, 0x190e: 0x000a, 0x190f: 0x000a, 0x1910: 0x000a, 0x1911: 0x000a,
+	0x1912: 0x000a, 0x1913: 0x000a, 0x1914: 0x000a, 0x1915: 0x000a, 0x1916: 0x000a, 0x1917: 0x000a,
+	0x1918: 0x000a, 0x1919: 0x000a, 0x191a: 0x000a, 0x191b: 0x000a, 0x191c: 0x000a, 0x191d: 0x000a,
+	0x191e: 0x000a, 0x191f: 0x000a, 0x1920: 0x000a, 0x1921: 0x000a, 0x1922: 0x000a, 0x1923: 0x000a,
+	0x1924: 0x000a, 0x1925: 0x000a, 0x1926: 0x000a, 0x1927: 0x000a, 0x1928: 0x000a, 0x1929: 0x000a,
+	0x192a: 0x000a, 0x192b: 0x000a, 0x192c: 0x000a, 0x192d: 0x000a, 0x192e: 0x000a, 0x192f: 0x000a,
+	0x1930: 0x000a, 0x1931: 0x000a, 0x1932: 0x000a, 0x1933: 0x000a,
+	0x1936: 0x000a, 0x1937: 0x000a, 0x1938: 0x000a, 0x1939: 0x000a, 0x193a: 0x000a, 0x193b: 0x000a,
+	0x193c: 0x000a, 0x193d: 0x000a, 0x193e: 0x000a, 0x193f: 0x000a,
+	// Block 0x65, offset 0x1940
+	0x1940: 0x000a, 0x1941: 0x000a, 0x1942: 0x000a, 0x1943: 0x000a, 0x1944: 0x000a, 0x1945: 0x000a,
+	0x1946: 0x000a, 0x1947: 0x000a, 0x1948: 0x000a, 0x1949: 0x000a, 0x194a: 0x000a, 0x194b: 0x000a,
+	0x194c: 0x000a, 0x194d: 0x000a, 0x194e: 0x000a, 0x194f: 0x000a, 0x1950: 0x000a, 0x1951: 0x000a,
+	0x1952: 0x000a, 0x1953: 0x000a, 0x1954: 0x000a, 0x1955: 0x000a,
+	0x1958: 0x000a, 0x1959: 0x000a, 0x195a: 0x000a, 0x195b: 0x000a, 0x195c: 0x000a, 0x195d: 0x000a,
+	0x195e: 0x000a, 0x195f: 0x000a, 0x1960: 0x000a, 0x1961: 0x000a, 0x1962: 0x000a, 0x1963: 0x000a,
+	0x1964: 0x000a, 0x1965: 0x000a, 0x1966: 0x000a, 0x1967: 0x000a, 0x1968: 0x000a, 0x1969: 0x000a,
+	0x196a: 0x000a, 0x196b: 0x000a, 0x196c: 0x000a, 0x196d: 0x000a, 0x196e: 0x000a, 0x196f: 0x000a,
+	0x1970: 0x000a, 0x1971: 0x000a, 0x1972: 0x000a, 0x1973: 0x000a, 0x1974: 0x000a, 0x1975: 0x000a,
+	0x1976: 0x000a, 0x1977: 0x000a, 0x1978: 0x000a, 0x1979: 0x000a,
+	0x197d: 0x000a, 0x197e: 0x000a, 0x197f: 0x000a,
+	// Block 0x66, offset 0x1980
+	0x1980: 0x000a, 0x1981: 0x000a, 0x1982: 0x000a, 0x1983: 0x000a, 0x1984: 0x000a, 0x1985: 0x000a,
+	0x1986: 0x000a, 0x1987: 0x000a, 0x1988: 0x000a, 0x198a: 0x000a, 0x198b: 0x000a,
+	0x198c: 0x000a, 0x198d: 0x000a, 0x198e: 0x000a, 0x198f: 0x000a, 0x1990: 0x000a, 0x1991: 0x000a,
+	0x1992: 0x000a,
+	0x19ac: 0x000a, 0x19ad: 0x000a, 0x19ae: 0x000a, 0x19af: 0x000a,
+	// Block 0x67, offset 0x19c0
+	0x19e5: 0x000a, 0x19e6: 0x000a, 0x19e7: 0x000a, 0x19e8: 0x000a, 0x19e9: 0x000a,
+	0x19ea: 0x000a, 0x19ef: 0x000c,
+	0x19f0: 0x000c, 0x19f1: 0x000c,
+	0x19f9: 0x000a, 0x19fa: 0x000a, 0x19fb: 0x000a,
+	0x19fc: 0x000a, 0x19fd: 0x000a, 0x19fe: 0x000a, 0x19ff: 0x000a,
+	// Block 0x68, offset 0x1a00
+	0x1a3f: 0x000c,
+	// Block 0x69, offset 0x1a40
+	0x1a60: 0x000c, 0x1a61: 0x000c, 0x1a62: 0x000c, 0x1a63: 0x000c,
+	0x1a64: 0x000c, 0x1a65: 0x000c, 0x1a66: 0x000c, 0x1a67: 0x000c, 0x1a68: 0x000c, 0x1a69: 0x000c,
+	0x1a6a: 0x000c, 0x1a6b: 0x000c, 0x1a6c: 0x000c, 0x1a6d: 0x000c, 0x1a6e: 0x000c, 0x1a6f: 0x000c,
+	0x1a70: 0x000c, 0x1a71: 0x000c, 0x1a72: 0x000c, 0x1a73: 0x000c, 0x1a74: 0x000c, 0x1a75: 0x000c,
+	0x1a76: 0x000c, 0x1a77: 0x000c, 0x1a78: 0x000c, 0x1a79: 0x000c, 0x1a7a: 0x000c, 0x1a7b: 0x000c,
+	0x1a7c: 0x000c, 0x1a7d: 0x000c, 0x1a7e: 0x000c, 0x1a7f: 0x000c,
+	// Block 0x6a, offset 0x1a80
+	0x1a80: 0x000a, 0x1a81: 0x000a, 0x1a82: 0x000a, 0x1a83: 0x000a, 0x1a84: 0x000a, 0x1a85: 0x000a,
+	0x1a86: 0x000a, 0x1a87: 0x000a, 0x1a88: 0x000a, 0x1a89: 0x000a, 0x1a8a: 0x000a, 0x1a8b: 0x000a,
+	0x1a8c: 0x000a, 0x1a8d: 0x000a, 0x1a8e: 0x000a, 0x1a8f: 0x000a, 0x1a90: 0x000a, 0x1a91: 0x000a,
+	0x1a92: 0x000a, 0x1a93: 0x000a, 0x1a94: 0x000a, 0x1a95: 0x000a, 0x1a96: 0x000a, 0x1a97: 0x000a,
+	0x1a98: 0x000a, 0x1a99: 0x000a, 0x1a9a: 0x000a, 0x1a9b: 0x000a, 0x1a9c: 0x000a, 0x1a9d: 0x000a,
+	0x1a9e: 0x000a, 0x1a9f: 0x000a, 0x1aa0: 0x000a, 0x1aa1: 0x000a, 0x1aa2: 0x003a, 0x1aa3: 0x002a,
+	0x1aa4: 0x003a, 0x1aa5: 0x002a, 0x1aa6: 0x003a, 0x1aa7: 0x002a, 0x1aa8: 0x003a, 0x1aa9: 0x002a,
+	0x1aaa: 0x000a, 0x1aab: 0x000a, 0x1aac: 0x000a, 0x1aad: 0x000a, 0x1aae: 0x000a, 0x1aaf: 0x000a,
+	0x1ab0: 0x000a, 0x1ab1: 0x000a, 0x1ab2: 0x000a, 0x1ab3: 0x000a, 0x1ab4: 0x000a, 0x1ab5: 0x000a,
+	0x1ab6: 0x000a, 0x1ab7: 0x000a, 0x1ab8: 0x000a, 0x1ab9: 0x000a, 0x1aba: 0x000a, 0x1abb: 0x000a,
+	0x1abc: 0x000a, 0x1abd: 0x000a, 0x1abe: 0x000a, 0x1abf: 0x000a,
+	// Block 0x6b, offset 0x1ac0
+	0x1ac0: 0x000a, 0x1ac1: 0x000a, 0x1ac2: 0x000a, 0x1ac3: 0x000a, 0x1ac4: 0x000a, 0x1ac5: 0x000a,
+	0x1ac6: 0x000a, 0x1ac7: 0x000a, 0x1ac8: 0x000a, 0x1ac9: 0x000a,
+	// Block 0x6c, offset 0x1b00
+	0x1b00: 0x000a, 0x1b01: 0x000a, 0x1b02: 0x000a, 0x1b03: 0x000a, 0x1b04: 0x000a, 0x1b05: 0x000a,
+	0x1b06: 0x000a, 0x1b07: 0x000a, 0x1b08: 0x000a, 0x1b09: 0x000a, 0x1b0a: 0x000a, 0x1b0b: 0x000a,
+	0x1b0c: 0x000a, 0x1b0d: 0x000a, 0x1b0e: 0x000a, 0x1b0f: 0x000a, 0x1b10: 0x000a, 0x1b11: 0x000a,
+	0x1b12: 0x000a, 0x1b13: 0x000a, 0x1b14: 0x000a, 0x1b15: 0x000a, 0x1b16: 0x000a, 0x1b17: 0x000a,
+	0x1b18: 0x000a, 0x1b19: 0x000a, 0x1b1b: 0x000a, 0x1b1c: 0x000a, 0x1b1d: 0x000a,
+	0x1b1e: 0x000a, 0x1b1f: 0x000a, 0x1b20: 0x000a, 0x1b21: 0x000a, 0x1b22: 0x000a, 0x1b23: 0x000a,
+	0x1b24: 0x000a, 0x1b25: 0x000a, 0x1b26: 0x000a, 0x1b27: 0x000a, 0x1b28: 0x000a, 0x1b29: 0x000a,
+	0x1b2a: 0x000a, 0x1b2b: 0x000a, 0x1b2c: 0x000a, 0x1b2d: 0x000a, 0x1b2e: 0x000a, 0x1b2f: 0x000a,
+	0x1b30: 0x000a, 0x1b31: 0x000a, 0x1b32: 0x000a, 0x1b33: 0x000a, 0x1b34: 0x000a, 0x1b35: 0x000a,
+	0x1b36: 0x000a, 0x1b37: 0x000a, 0x1b38: 0x000a, 0x1b39: 0x000a, 0x1b3a: 0x000a, 0x1b3b: 0x000a,
+	0x1b3c: 0x000a, 0x1b3d: 0x000a, 0x1b3e: 0x000a, 0x1b3f: 0x000a,
+	// Block 0x6d, offset 0x1b40
+	0x1b40: 0x000a, 0x1b41: 0x000a, 0x1b42: 0x000a, 0x1b43: 0x000a, 0x1b44: 0x000a, 0x1b45: 0x000a,
+	0x1b46: 0x000a, 0x1b47: 0x000a, 0x1b48: 0x000a, 0x1b49: 0x000a, 0x1b4a: 0x000a, 0x1b4b: 0x000a,
+	0x1b4c: 0x000a, 0x1b4d: 0x000a, 0x1b4e: 0x000a, 0x1b4f: 0x000a, 0x1b50: 0x000a, 0x1b51: 0x000a,
+	0x1b52: 0x000a, 0x1b53: 0x000a, 0x1b54: 0x000a, 0x1b55: 0x000a, 0x1b56: 0x000a, 0x1b57: 0x000a,
+	0x1b58: 0x000a, 0x1b59: 0x000a, 0x1b5a: 0x000a, 0x1b5b: 0x000a, 0x1b5c: 0x000a, 0x1b5d: 0x000a,
+	0x1b5e: 0x000a, 0x1b5f: 0x000a, 0x1b60: 0x000a, 0x1b61: 0x000a, 0x1b62: 0x000a, 0x1b63: 0x000a,
+	0x1b64: 0x000a, 0x1b65: 0x000a, 0x1b66: 0x000a, 0x1b67: 0x000a, 0x1b68: 0x000a, 0x1b69: 0x000a,
+	0x1b6a: 0x000a, 0x1b6b: 0x000a, 0x1b6c: 0x000a, 0x1b6d: 0x000a, 0x1b6e: 0x000a, 0x1b6f: 0x000a,
+	0x1b70: 0x000a, 0x1b71: 0x000a, 0x1b72: 0x000a, 0x1b73: 0x000a,
+	// Block 0x6e, offset 0x1b80
+	0x1b80: 0x000a, 0x1b81: 0x000a, 0x1b82: 0x000a, 0x1b83: 0x000a, 0x1b84: 0x000a, 0x1b85: 0x000a,
+	0x1b86: 0x000a, 0x1b87: 0x000a, 0x1b88: 0x000a, 0x1b89: 0x000a, 0x1b8a: 0x000a, 0x1b8b: 0x000a,
+	0x1b8c: 0x000a, 0x1b8d: 0x000a, 0x1b8e: 0x000a, 0x1b8f: 0x000a, 0x1b90: 0x000a, 0x1b91: 0x000a,
+	0x1b92: 0x000a, 0x1b93: 0x000a, 0x1b94: 0x000a, 0x1b95: 0x000a,
+	0x1bb0: 0x000a, 0x1bb1: 0x000a, 0x1bb2: 0x000a, 0x1bb3: 0x000a, 0x1bb4: 0x000a, 0x1bb5: 0x000a,
+	0x1bb6: 0x000a, 0x1bb7: 0x000a, 0x1bb8: 0x000a, 0x1bb9: 0x000a, 0x1bba: 0x000a, 0x1bbb: 0x000a,
+	// Block 0x6f, offset 0x1bc0
+	0x1bc0: 0x0009, 0x1bc1: 0x000a, 0x1bc2: 0x000a, 0x1bc3: 0x000a, 0x1bc4: 0x000a,
+	0x1bc8: 0x003a, 0x1bc9: 0x002a, 0x1bca: 0x003a, 0x1bcb: 0x002a,
+	0x1bcc: 0x003a, 0x1bcd: 0x002a, 0x1bce: 0x003a, 0x1bcf: 0x002a, 0x1bd0: 0x003a, 0x1bd1: 0x002a,
+	0x1bd2: 0x000a, 0x1bd3: 0x000a, 0x1bd4: 0x003a, 0x1bd5: 0x002a, 0x1bd6: 0x003a, 0x1bd7: 0x002a,
+	0x1bd8: 0x003a, 0x1bd9: 0x002a, 0x1bda: 0x003a, 0x1bdb: 0x002a, 0x1bdc: 0x000a, 0x1bdd: 0x000a,
+	0x1bde: 0x000a, 0x1bdf: 0x000a, 0x1be0: 0x000a,
+	0x1bea: 0x000c, 0x1beb: 0x000c, 0x1bec: 0x000c, 0x1bed: 0x000c,
+	0x1bf0: 0x000a,
+	0x1bf6: 0x000a, 0x1bf7: 0x000a,
+	0x1bfd: 0x000a, 0x1bfe: 0x000a, 0x1bff: 0x000a,
+	// Block 0x70, offset 0x1c00
+	0x1c19: 0x000c, 0x1c1a: 0x000c, 0x1c1b: 0x000a, 0x1c1c: 0x000a,
+	0x1c20: 0x000a,
+	// Block 0x71, offset 0x1c40
+	0x1c7b: 0x000a,
+	// Block 0x72, offset 0x1c80
+	0x1c80: 0x000a, 0x1c81: 0x000a, 0x1c82: 0x000a, 0x1c83: 0x000a, 0x1c84: 0x000a, 0x1c85: 0x000a,
+	0x1c86: 0x000a, 0x1c87: 0x000a, 0x1c88: 0x000a, 0x1c89: 0x000a, 0x1c8a: 0x000a, 0x1c8b: 0x000a,
+	0x1c8c: 0x000a, 0x1c8d: 0x000a, 0x1c8e: 0x000a, 0x1c8f: 0x000a, 0x1c90: 0x000a, 0x1c91: 0x000a,
+	0x1c92: 0x000a, 0x1c93: 0x000a, 0x1c94: 0x000a, 0x1c95: 0x000a, 0x1c96: 0x000a, 0x1c97: 0x000a,
+	0x1c98: 0x000a, 0x1c99: 0x000a, 0x1c9a: 0x000a, 0x1c9b: 0x000a, 0x1c9c: 0x000a, 0x1c9d: 0x000a,
+	0x1c9e: 0x000a, 0x1c9f: 0x000a, 0x1ca0: 0x000a, 0x1ca1: 0x000a, 0x1ca2: 0x000a, 0x1ca3: 0x000a,
+	// Block 0x73, offset 0x1cc0
+	0x1cdd: 0x000a,
+	0x1cde: 0x000a,
+	// Block 0x74, offset 0x1d00
+	0x1d10: 0x000a, 0x1d11: 0x000a,
+	0x1d12: 0x000a, 0x1d13: 0x000a, 0x1d14: 0x000a, 0x1d15: 0x000a, 0x1d16: 0x000a, 0x1d17: 0x000a,
+	0x1d18: 0x000a, 0x1d19: 0x000a, 0x1d1a: 0x000a, 0x1d1b: 0x000a, 0x1d1c: 0x000a, 0x1d1d: 0x000a,
+	0x1d1e: 0x000a, 0x1d1f: 0x000a,
+	0x1d3c: 0x000a, 0x1d3d: 0x000a, 0x1d3e: 0x000a,
+	// Block 0x75, offset 0x1d40
+	0x1d71: 0x000a, 0x1d72: 0x000a, 0x1d73: 0x000a, 0x1d74: 0x000a, 0x1d75: 0x000a,
+	0x1d76: 0x000a, 0x1d77: 0x000a, 0x1d78: 0x000a, 0x1d79: 0x000a, 0x1d7a: 0x000a, 0x1d7b: 0x000a,
+	0x1d7c: 0x000a, 0x1d7d: 0x000a, 0x1d7e: 0x000a, 0x1d7f: 0x000a,
+	// Block 0x76, offset 0x1d80
+	0x1d8c: 0x000a, 0x1d8d: 0x000a, 0x1d8e: 0x000a, 0x1d8f: 0x000a,
+	// Block 0x77, offset 0x1dc0
+	0x1df7: 0x000a, 0x1df8: 0x000a, 0x1df9: 0x000a, 0x1dfa: 0x000a,
+	// Block 0x78, offset 0x1e00
+	0x1e1e: 0x000a, 0x1e1f: 0x000a,
+	0x1e3f: 0x000a,
+	// Block 0x79, offset 0x1e40
+	0x1e50: 0x000a, 0x1e51: 0x000a,
+	0x1e52: 0x000a, 0x1e53: 0x000a, 0x1e54: 0x000a, 0x1e55: 0x000a, 0x1e56: 0x000a, 0x1e57: 0x000a,
+	0x1e58: 0x000a, 0x1e59: 0x000a, 0x1e5a: 0x000a, 0x1e5b: 0x000a, 0x1e5c: 0x000a, 0x1e5d: 0x000a,
+	0x1e5e: 0x000a, 0x1e5f: 0x000a, 0x1e60: 0x000a, 0x1e61: 0x000a, 0x1e62: 0x000a, 0x1e63: 0x000a,
+	0x1e64: 0x000a, 0x1e65: 0x000a, 0x1e66: 0x000a, 0x1e67: 0x000a, 0x1e68: 0x000a, 0x1e69: 0x000a,
+	0x1e6a: 0x000a, 0x1e6b: 0x000a, 0x1e6c: 0x000a, 0x1e6d: 0x000a, 0x1e6e: 0x000a, 0x1e6f: 0x000a,
+	0x1e70: 0x000a, 0x1e71: 0x000a, 0x1e72: 0x000a, 0x1e73: 0x000a, 0x1e74: 0x000a, 0x1e75: 0x000a,
+	0x1e76: 0x000a, 0x1e77: 0x000a, 0x1e78: 0x000a, 0x1e79: 0x000a, 0x1e7a: 0x000a, 0x1e7b: 0x000a,
+	0x1e7c: 0x000a, 0x1e7d: 0x000a, 0x1e7e: 0x000a, 0x1e7f: 0x000a,
+	// Block 0x7a, offset 0x1e80
+	0x1e80: 0x000a, 0x1e81: 0x000a, 0x1e82: 0x000a, 0x1e83: 0x000a, 0x1e84: 0x000a, 0x1e85: 0x000a,
+	0x1e86: 0x000a,
+	// Block 0x7b, offset 0x1ec0
+	0x1ecd: 0x000a, 0x1ece: 0x000a, 0x1ecf: 0x000a,
+	// Block 0x7c, offset 0x1f00
+	0x1f2f: 0x000c,
+	0x1f30: 0x000c, 0x1f31: 0x000c, 0x1f32: 0x000c, 0x1f33: 0x000a, 0x1f34: 0x000c, 0x1f35: 0x000c,
+	0x1f36: 0x000c, 0x1f37: 0x000c, 0x1f38: 0x000c, 0x1f39: 0x000c, 0x1f3a: 0x000c, 0x1f3b: 0x000c,
+	0x1f3c: 0x000c, 0x1f3d: 0x000c, 0x1f3e: 0x000a, 0x1f3f: 0x000a,
+	// Block 0x7d, offset 0x1f40
+	0x1f5e: 0x000c, 0x1f5f: 0x000c,
+	// Block 0x7e, offset 0x1f80
+	0x1fb0: 0x000c, 0x1fb1: 0x000c,
+	// Block 0x7f, offset 0x1fc0
+	0x1fc0: 0x000a, 0x1fc1: 0x000a, 0x1fc2: 0x000a, 0x1fc3: 0x000a, 0x1fc4: 0x000a, 0x1fc5: 0x000a,
+	0x1fc6: 0x000a, 0x1fc7: 0x000a, 0x1fc8: 0x000a, 0x1fc9: 0x000a, 0x1fca: 0x000a, 0x1fcb: 0x000a,
+	0x1fcc: 0x000a, 0x1fcd: 0x000a, 0x1fce: 0x000a, 0x1fcf: 0x000a, 0x1fd0: 0x000a, 0x1fd1: 0x000a,
+	0x1fd2: 0x000a, 0x1fd3: 0x000a, 0x1fd4: 0x000a, 0x1fd5: 0x000a, 0x1fd6: 0x000a, 0x1fd7: 0x000a,
+	0x1fd8: 0x000a, 0x1fd9: 0x000a, 0x1fda: 0x000a, 0x1fdb: 0x000a, 0x1fdc: 0x000a, 0x1fdd: 0x000a,
+	0x1fde: 0x000a, 0x1fdf: 0x000a, 0x1fe0: 0x000a, 0x1fe1: 0x000a,
+	// Block 0x80, offset 0x2000
+	0x2008: 0x000a,
+	// Block 0x81, offset 0x2040
+	0x2042: 0x000c,
+	0x2046: 0x000c, 0x204b: 0x000c,
+	0x2065: 0x000c, 0x2066: 0x000c, 0x2068: 0x000a, 0x2069: 0x000a,
+	0x206a: 0x000a, 0x206b: 0x000a,
+	0x2078: 0x0004, 0x2079: 0x0004,
+	// Block 0x82, offset 0x2080
+	0x20b4: 0x000a, 0x20b5: 0x000a,
+	0x20b6: 0x000a, 0x20b7: 0x000a,
+	// Block 0x83, offset 0x20c0
+	0x20c4: 0x000c, 0x20c5: 0x000c,
+	0x20e0: 0x000c, 0x20e1: 0x000c, 0x20e2: 0x000c, 0x20e3: 0x000c,
+	0x20e4: 0x000c, 0x20e5: 0x000c, 0x20e6: 0x000c, 0x20e7: 0x000c, 0x20e8: 0x000c, 0x20e9: 0x000c,
+	0x20ea: 0x000c, 0x20eb: 0x000c, 0x20ec: 0x000c, 0x20ed: 0x000c, 0x20ee: 0x000c, 0x20ef: 0x000c,
+	0x20f0: 0x000c, 0x20f1: 0x000c,
+	// Block 0x84, offset 0x2100
+	0x2126: 0x000c, 0x2127: 0x000c, 0x2128: 0x000c, 0x2129: 0x000c,
+	0x212a: 0x000c, 0x212b: 0x000c, 0x212c: 0x000c, 0x212d: 0x000c,
+	// Block 0x85, offset 0x2140
+	0x2147: 0x000c, 0x2148: 0x000c, 0x2149: 0x000c, 0x214a: 0x000c, 0x214b: 0x000c,
+	0x214c: 0x000c, 0x214d: 0x000c, 0x214e: 0x000c, 0x214f: 0x000c, 0x2150: 0x000c, 0x2151: 0x000c,
+	// Block 0x86, offset 0x2180
+	0x2180: 0x000c, 0x2181: 0x000c, 0x2182: 0x000c,
+	0x21b3: 0x000c,
+	0x21b6: 0x000c, 0x21b7: 0x000c, 0x21b8: 0x000c, 0x21b9: 0x000c,
+	0x21bc: 0x000c,
+	// Block 0x87, offset 0x21c0
+	0x21e5: 0x000c,
+	// Block 0x88, offset 0x2200
+	0x2229: 0x000c,
+	0x222a: 0x000c, 0x222b: 0x000c, 0x222c: 0x000c, 0x222d: 0x000c, 0x222e: 0x000c,
+	0x2231: 0x000c, 0x2232: 0x000c, 0x2235: 0x000c,
+	0x2236: 0x000c,
+	// Block 0x89, offset 0x2240
+	0x2243: 0x000c,
+	0x224c: 0x000c,
+	0x227c: 0x000c,
+	// Block 0x8a, offset 0x2280
+	0x22b0: 0x000c, 0x22b2: 0x000c, 0x22b3: 0x000c, 0x22b4: 0x000c,
+	0x22b7: 0x000c, 0x22b8: 0x000c,
+	0x22be: 0x000c, 0x22bf: 0x000c,
+	// Block 0x8b, offset 0x22c0
+	0x22c1: 0x000c,
+	0x22ec: 0x000c, 0x22ed: 0x000c,
+	0x22f6: 0x000c,
+	// Block 0x8c, offset 0x2300
+	0x2325: 0x000c, 0x2328: 0x000c,
+	0x232d: 0x000c,
+	// Block 0x8d, offset 0x2340
+	0x235d: 0x0001,
+	0x235e: 0x000c, 0x235f: 0x0001, 0x2360: 0x0001, 0x2361: 0x0001, 0x2362: 0x0001, 0x2363: 0x0001,
+	0x2364: 0x0001, 0x2365: 0x0001, 0x2366: 0x0001, 0x2367: 0x0001, 0x2368: 0x0001, 0x2369: 0x0003,
+	0x236a: 0x0001, 0x236b: 0x0001, 0x236c: 0x0001, 0x236d: 0x0001, 0x236e: 0x0001, 0x236f: 0x0001,
+	0x2370: 0x0001, 0x2371: 0x0001, 0x2372: 0x0001, 0x2373: 0x0001, 0x2374: 0x0001, 0x2375: 0x0001,
+	0x2376: 0x0001, 0x2377: 0x0001, 0x2378: 0x0001, 0x2379: 0x0001, 0x237a: 0x0001, 0x237b: 0x0001,
+	0x237c: 0x0001, 0x237d: 0x0001, 0x237e: 0x0001, 0x237f: 0x0001,
+	// Block 0x8e, offset 0x2380
+	0x2380: 0x0001, 0x2381: 0x0001, 0x2382: 0x0001, 0x2383: 0x0001, 0x2384: 0x0001, 0x2385: 0x0001,
+	0x2386: 0x0001, 0x2387: 0x0001, 0x2388: 0x0001, 0x2389: 0x0001, 0x238a: 0x0001, 0x238b: 0x0001,
+	0x238c: 0x0001, 0x238d: 0x0001, 0x238e: 0x0001, 0x238f: 0x0001, 0x2390: 0x000d, 0x2391: 0x000d,
+	0x2392: 0x000d, 0x2393: 0x000d, 0x2394: 0x000d, 0x2395: 0x000d, 0x2396: 0x000d, 0x2397: 0x000d,
+	0x2398: 0x000d, 0x2399: 0x000d, 0x239a: 0x000d, 0x239b: 0x000d, 0x239c: 0x000d, 0x239d: 0x000d,
+	0x239e: 0x000d, 0x239f: 0x000d, 0x23a0: 0x000d, 0x23a1: 0x000d, 0x23a2: 0x000d, 0x23a3: 0x000d,
+	0x23a4: 0x000d, 0x23a5: 0x000d, 0x23a6: 0x000d, 0x23a7: 0x000d, 0x23a8: 0x000d, 0x23a9: 0x000d,
+	0x23aa: 0x000d, 0x23ab: 0x000d, 0x23ac: 0x000d, 0x23ad: 0x000d, 0x23ae: 0x000d, 0x23af: 0x000d,
+	0x23b0: 0x000d, 0x23b1: 0x000d, 0x23b2: 0x000d, 0x23b3: 0x000d, 0x23b4: 0x000d, 0x23b5: 0x000d,
+	0x23b6: 0x000d, 0x23b7: 0x000d, 0x23b8: 0x000d, 0x23b9: 0x000d, 0x23ba: 0x000d, 0x23bb: 0x000d,
+	0x23bc: 0x000d, 0x23bd: 0x000d, 0x23be: 0x000d, 0x23bf: 0x000d,
+	// Block 0x8f, offset 0x23c0
+	0x23c0: 0x000d, 0x23c1: 0x000d, 0x23c2: 0x000d, 0x23c3: 0x000d, 0x23c4: 0x000d, 0x23c5: 0x000d,
+	0x23c6: 0x000d, 0x23c7: 0x000d, 0x23c8: 0x000d, 0x23c9: 0x000d, 0x23ca: 0x000d, 0x23cb: 0x000d,
+	0x23cc: 0x000d, 0x23cd: 0x000d, 0x23ce: 0x000d, 0x23cf: 0x000d, 0x23d0: 0x000d, 0x23d1: 0x000d,
+	0x23d2: 0x000d, 0x23d3: 0x000d, 0x23d4: 0x000d, 0x23d5: 0x000d, 0x23d6: 0x000d, 0x23d7: 0x000d,
+	0x23d8: 0x000d, 0x23d9: 0x000d, 0x23da: 0x000d, 0x23db: 0x000d, 0x23dc: 0x000d, 0x23dd: 0x000d,
+	0x23de: 0x000d, 0x23df: 0x000d, 0x23e0: 0x000d, 0x23e1: 0x000d, 0x23e2: 0x000d, 0x23e3: 0x000d,
+	0x23e4: 0x000d, 0x23e5: 0x000d, 0x23e6: 0x000d, 0x23e7: 0x000d, 0x23e8: 0x000d, 0x23e9: 0x000d,
+	0x23ea: 0x000d, 0x23eb: 0x000d, 0x23ec: 0x000d, 0x23ed: 0x000d, 0x23ee: 0x000d, 0x23ef: 0x000d,
+	0x23f0: 0x000d, 0x23f1: 0x000d, 0x23f2: 0x000d, 0x23f3: 0x000d, 0x23f4: 0x000d, 0x23f5: 0x000d,
+	0x23f6: 0x000d, 0x23f7: 0x000d, 0x23f8: 0x000d, 0x23f9: 0x000d, 0x23fa: 0x000d, 0x23fb: 0x000d,
+	0x23fc: 0x000d, 0x23fd: 0x000d, 0x23fe: 0x000a, 0x23ff: 0x000a,
+	// Block 0x90, offset 0x2400
+	0x2400: 0x000d, 0x2401: 0x000d, 0x2402: 0x000d, 0x2403: 0x000d, 0x2404: 0x000d, 0x2405: 0x000d,
+	0x2406: 0x000d, 0x2407: 0x000d, 0x2408: 0x000d, 0x2409: 0x000d, 0x240a: 0x000d, 0x240b: 0x000d,
+	0x240c: 0x000d, 0x240d: 0x000d, 0x240e: 0x000d, 0x240f: 0x000d, 0x2410: 0x000b, 0x2411: 0x000b,
+	0x2412: 0x000b, 0x2413: 0x000b, 0x2414: 0x000b, 0x2415: 0x000b, 0x2416: 0x000b, 0x2417: 0x000b,
+	0x2418: 0x000b, 0x2419: 0x000b, 0x241a: 0x000b, 0x241b: 0x000b, 0x241c: 0x000b, 0x241d: 0x000b,
+	0x241e: 0x000b, 0x241f: 0x000b, 0x2420: 0x000b, 0x2421: 0x000b, 0x2422: 0x000b, 0x2423: 0x000b,
+	0x2424: 0x000b, 0x2425: 0x000b, 0x2426: 0x000b, 0x2427: 0x000b, 0x2428: 0x000b, 0x2429: 0x000b,
+	0x242a: 0x000b, 0x242b: 0x000b, 0x242c: 0x000b, 0x242d: 0x000b, 0x242e: 0x000b, 0x242f: 0x000b,
+	0x2430: 0x000d, 0x2431: 0x000d, 0x2432: 0x000d, 0x2433: 0x000d, 0x2434: 0x000d, 0x2435: 0x000d,
+	0x2436: 0x000d, 0x2437: 0x000d, 0x2438: 0x000d, 0x2439: 0x000d, 0x243a: 0x000d, 0x243b: 0x000d,
+	0x243c: 0x000d, 0x243d: 0x000a, 0x243e: 0x000d, 0x243f: 0x000d,
+	// Block 0x91, offset 0x2440
+	0x2440: 0x000c, 0x2441: 0x000c, 0x2442: 0x000c, 0x2443: 0x000c, 0x2444: 0x000c, 0x2445: 0x000c,
+	0x2446: 0x000c, 0x2447: 0x000c, 0x2448: 0x000c, 0x2449: 0x000c, 0x244a: 0x000c, 0x244b: 0x000c,
+	0x244c: 0x000c, 0x244d: 0x000c, 0x244e: 0x000c, 0x244f: 0x000c, 0x2450: 0x000a, 0x2451: 0x000a,
+	0x2452: 0x000a, 0x2453: 0x000a, 0x2454: 0x000a, 0x2455: 0x000a, 0x2456: 0x000a, 0x2457: 0x000a,
+	0x2458: 0x000a, 0x2459: 0x000a,
+	0x2460: 0x000c, 0x2461: 0x000c, 0x2462: 0x000c, 0x2463: 0x000c,
+	0x2464: 0x000c, 0x2465: 0x000c, 0x2466: 0x000c, 0x2467: 0x000c, 0x2468: 0x000c, 0x2469: 0x000c,
+	0x246a: 0x000c, 0x246b: 0x000c, 0x246c: 0x000c, 0x246d: 0x000c, 0x246e: 0x000c, 0x246f: 0x000c,
+	0x2470: 0x000a, 0x2471: 0x000a, 0x2472: 0x000a, 0x2473: 0x000a, 0x2474: 0x000a, 0x2475: 0x000a,
+	0x2476: 0x000a, 0x2477: 0x000a, 0x2478: 0x000a, 0x2479: 0x000a, 0x247a: 0x000a, 0x247b: 0x000a,
+	0x247c: 0x000a, 0x247d: 0x000a, 0x247e: 0x000a, 0x247f: 0x000a,
+	// Block 0x92, offset 0x2480
+	0x2480: 0x000a, 0x2481: 0x000a, 0x2482: 0x000a, 0x2483: 0x000a, 0x2484: 0x000a, 0x2485: 0x000a,
+	0x2486: 0x000a, 0x2487: 0x000a, 0x2488: 0x000a, 0x2489: 0x000a, 0x248a: 0x000a, 0x248b: 0x000a,
+	0x248c: 0x000a, 0x248d: 0x000a, 0x248e: 0x000a, 0x248f: 0x000a, 0x2490: 0x0006, 0x2491: 0x000a,
+	0x2492: 0x0006, 0x2494: 0x000a, 0x2495: 0x0006, 0x2496: 0x000a, 0x2497: 0x000a,
+	0x2498: 0x000a, 0x2499: 0x009a, 0x249a: 0x008a, 0x249b: 0x007a, 0x249c: 0x006a, 0x249d: 0x009a,
+	0x249e: 0x008a, 0x249f: 0x0004, 0x24a0: 0x000a, 0x24a1: 0x000a, 0x24a2: 0x0003, 0x24a3: 0x0003,
+	0x24a4: 0x000a, 0x24a5: 0x000a, 0x24a6: 0x000a, 0x24a8: 0x000a, 0x24a9: 0x0004,
+	0x24aa: 0x0004, 0x24ab: 0x000a,
+	0x24b0: 0x000d, 0x24b1: 0x000d, 0x24b2: 0x000d, 0x24b3: 0x000d, 0x24b4: 0x000d, 0x24b5: 0x000d,
+	0x24b6: 0x000d, 0x24b7: 0x000d, 0x24b8: 0x000d, 0x24b9: 0x000d, 0x24ba: 0x000d, 0x24bb: 0x000d,
+	0x24bc: 0x000d, 0x24bd: 0x000d, 0x24be: 0x000d, 0x24bf: 0x000d,
+	// Block 0x93, offset 0x24c0
+	0x24c0: 0x000d, 0x24c1: 0x000d, 0x24c2: 0x000d, 0x24c3: 0x000d, 0x24c4: 0x000d, 0x24c5: 0x000d,
+	0x24c6: 0x000d, 0x24c7: 0x000d, 0x24c8: 0x000d, 0x24c9: 0x000d, 0x24ca: 0x000d, 0x24cb: 0x000d,
+	0x24cc: 0x000d, 0x24cd: 0x000d, 0x24ce: 0x000d, 0x24cf: 0x000d, 0x24d0: 0x000d, 0x24d1: 0x000d,
+	0x24d2: 0x000d, 0x24d3: 0x000d, 0x24d4: 0x000d, 0x24d5: 0x000d, 0x24d6: 0x000d, 0x24d7: 0x000d,
+	0x24d8: 0x000d, 0x24d9: 0x000d, 0x24da: 0x000d, 0x24db: 0x000d, 0x24dc: 0x000d, 0x24dd: 0x000d,
+	0x24de: 0x000d, 0x24df: 0x000d, 0x24e0: 0x000d, 0x24e1: 0x000d, 0x24e2: 0x000d, 0x24e3: 0x000d,
+	0x24e4: 0x000d, 0x24e5: 0x000d, 0x24e6: 0x000d, 0x24e7: 0x000d, 0x24e8: 0x000d, 0x24e9: 0x000d,
+	0x24ea: 0x000d, 0x24eb: 0x000d, 0x24ec: 0x000d, 0x24ed: 0x000d, 0x24ee: 0x000d, 0x24ef: 0x000d,
+	0x24f0: 0x000d, 0x24f1: 0x000d, 0x24f2: 0x000d, 0x24f3: 0x000d, 0x24f4: 0x000d, 0x24f5: 0x000d,
+	0x24f6: 0x000d, 0x24f7: 0x000d, 0x24f8: 0x000d, 0x24f9: 0x000d, 0x24fa: 0x000d, 0x24fb: 0x000d,
+	0x24fc: 0x000d, 0x24fd: 0x000d, 0x24fe: 0x000d, 0x24ff: 0x000b,
+	// Block 0x94, offset 0x2500
+	0x2501: 0x000a, 0x2502: 0x000a, 0x2503: 0x0004, 0x2504: 0x0004, 0x2505: 0x0004,
+	0x2506: 0x000a, 0x2507: 0x000a, 0x2508: 0x003a, 0x2509: 0x002a, 0x250a: 0x000a, 0x250b: 0x0003,
+	0x250c: 0x0006, 0x250d: 0x0003, 0x250e: 0x0006, 0x250f: 0x0006, 0x2510: 0x0002, 0x2511: 0x0002,
+	0x2512: 0x0002, 0x2513: 0x0002, 0x2514: 0x0002, 0x2515: 0x0002, 0x2516: 0x0002, 0x2517: 0x0002,
+	0x2518: 0x0002, 0x2519: 0x0002, 0x251a: 0x0006, 0x251b: 0x000a, 0x251c: 0x000a, 0x251d: 0x000a,
+	0x251e: 0x000a, 0x251f: 0x000a, 0x2520: 0x000a,
+	0x253b: 0x005a,
+	0x253c: 0x000a, 0x253d: 0x004a, 0x253e: 0x000a, 0x253f: 0x000a,
+	// Block 0x95, offset 0x2540
+	0x2540: 0x000a,
+	0x255b: 0x005a, 0x255c: 0x000a, 0x255d: 0x004a,
+	0x255e: 0x000a, 0x255f: 0x00fa, 0x2560: 0x00ea, 0x2561: 0x000a, 0x2562: 0x003a, 0x2563: 0x002a,
+	0x2564: 0x000a, 0x2565: 0x000a,
+	// Block 0x96, offset 0x2580
+	0x25a0: 0x0004, 0x25a1: 0x0004, 0x25a2: 0x000a, 0x25a3: 0x000a,
+	0x25a4: 0x000a, 0x25a5: 0x0004, 0x25a6: 0x0004, 0x25a8: 0x000a, 0x25a9: 0x000a,
+	0x25aa: 0x000a, 0x25ab: 0x000a, 0x25ac: 0x000a, 0x25ad: 0x000a, 0x25ae: 0x000a,
+	0x25b0: 0x000b, 0x25b1: 0x000b, 0x25b2: 0x000b, 0x25b3: 0x000b, 0x25b4: 0x000b, 0x25b5: 0x000b,
+	0x25b6: 0x000b, 0x25b7: 0x000b, 0x25b8: 0x000b, 0x25b9: 0x000a, 0x25ba: 0x000a, 0x25bb: 0x000a,
+	0x25bc: 0x000a, 0x25bd: 0x000a, 0x25be: 0x000b, 0x25bf: 0x000b,
+	// Block 0x97, offset 0x25c0
+	0x25c1: 0x000a,
+	// Block 0x98, offset 0x2600
+	0x2600: 0x000a, 0x2601: 0x000a, 0x2602: 0x000a, 0x2603: 0x000a, 0x2604: 0x000a, 0x2605: 0x000a,
+	0x2606: 0x000a, 0x2607: 0x000a, 0x2608: 0x000a, 0x2609: 0x000a, 0x260a: 0x000a, 0x260b: 0x000a,
+	0x260c: 0x000a, 0x2610: 0x000a, 0x2611: 0x000a,
+	0x2612: 0x000a, 0x2613: 0x000a, 0x2614: 0x000a, 0x2615: 0x000a, 0x2616: 0x000a, 0x2617: 0x000a,
+	0x2618: 0x000a, 0x2619: 0x000a, 0x261a: 0x000a, 0x261b: 0x000a,
+	0x2620: 0x000a,
+	// Block 0x99, offset 0x2640
+	0x267d: 0x000c,
+	// Block 0x9a, offset 0x2680
+	0x26a0: 0x000c, 0x26a1: 0x0002, 0x26a2: 0x0002, 0x26a3: 0x0002,
+	0x26a4: 0x0002, 0x26a5: 0x0002, 0x26a6: 0x0002, 0x26a7: 0x0002, 0x26a8: 0x0002, 0x26a9: 0x0002,
+	0x26aa: 0x0002, 0x26ab: 0x0002, 0x26ac: 0x0002, 0x26ad: 0x0002, 0x26ae: 0x0002, 0x26af: 0x0002,
+	0x26b0: 0x0002, 0x26b1: 0x0002, 0x26b2: 0x0002, 0x26b3: 0x0002, 0x26b4: 0x0002, 0x26b5: 0x0002,
+	0x26b6: 0x0002, 0x26b7: 0x0002, 0x26b8: 0x0002, 0x26b9: 0x0002, 0x26ba: 0x0002, 0x26bb: 0x0002,
+	// Block 0x9b, offset 0x26c0
+	0x26f6: 0x000c, 0x26f7: 0x000c, 0x26f8: 0x000c, 0x26f9: 0x000c, 0x26fa: 0x000c,
+	// Block 0x9c, offset 0x2700
+	0x2700: 0x0001, 0x2701: 0x0001, 0x2702: 0x0001, 0x2703: 0x0001, 0x2704: 0x0001, 0x2705: 0x0001,
+	0x2706: 0x0001, 0x2707: 0x0001, 0x2708: 0x0001, 0x2709: 0x0001, 0x270a: 0x0001, 0x270b: 0x0001,
+	0x270c: 0x0001, 0x270d: 0x0001, 0x270e: 0x0001, 0x270f: 0x0001, 0x2710: 0x0001, 0x2711: 0x0001,
+	0x2712: 0x0001, 0x2713: 0x0001, 0x2714: 0x0001, 0x2715: 0x0001, 0x2716: 0x0001, 0x2717: 0x0001,
+	0x2718: 0x0001, 0x2719: 0x0001, 0x271a: 0x0001, 0x271b: 0x0001, 0x271c: 0x0001, 0x271d: 0x0001,
+	0x271e: 0x0001, 0x271f: 0x0001, 0x2720: 0x0001, 0x2721: 0x0001, 0x2722: 0x0001, 0x2723: 0x0001,
+	0x2724: 0x0001, 0x2725: 0x0001, 0x2726: 0x0001, 0x2727: 0x0001, 0x2728: 0x0001, 0x2729: 0x0001,
+	0x272a: 0x0001, 0x272b: 0x0001, 0x272c: 0x0001, 0x272d: 0x0001, 0x272e: 0x0001, 0x272f: 0x0001,
+	0x2730: 0x0001, 0x2731: 0x0001, 0x2732: 0x0001, 0x2733: 0x0001, 0x2734: 0x0001, 0x2735: 0x0001,
+	0x2736: 0x0001, 0x2737: 0x0001, 0x2738: 0x0001, 0x2739: 0x0001, 0x273a: 0x0001, 0x273b: 0x0001,
+	0x273c: 0x0001, 0x273d: 0x0001, 0x273e: 0x0001, 0x273f: 0x0001,
+	// Block 0x9d, offset 0x2740
+	0x2740: 0x0001, 0x2741: 0x0001, 0x2742: 0x0001, 0x2743: 0x0001, 0x2744: 0x0001, 0x2745: 0x0001,
+	0x2746: 0x0001, 0x2747: 0x0001, 0x2748: 0x0001, 0x2749: 0x0001, 0x274a: 0x0001, 0x274b: 0x0001,
+	0x274c: 0x0001, 0x274d: 0x0001, 0x274e: 0x0001, 0x274f: 0x0001, 0x2750: 0x0001, 0x2751: 0x0001,
+	0x2752: 0x0001, 0x2753: 0x0001, 0x2754: 0x0001, 0x2755: 0x0001, 0x2756: 0x0001, 0x2757: 0x0001,
+	0x2758: 0x0001, 0x2759: 0x0001, 0x275a: 0x0001, 0x275b: 0x0001, 0x275c: 0x0001, 0x275d: 0x0001,
+	0x275e: 0x0001, 0x275f: 0x000a, 0x2760: 0x0001, 0x2761: 0x0001, 0x2762: 0x0001, 0x2763: 0x0001,
+	0x2764: 0x0001, 0x2765: 0x0001, 0x2766: 0x0001, 0x2767: 0x0001, 0x2768: 0x0001, 0x2769: 0x0001,
+	0x276a: 0x0001, 0x276b: 0x0001, 0x276c: 0x0001, 0x276d: 0x0001, 0x276e: 0x0001, 0x276f: 0x0001,
+	0x2770: 0x0001, 0x2771: 0x0001, 0x2772: 0x0001, 0x2773: 0x0001, 0x2774: 0x0001, 0x2775: 0x0001,
+	0x2776: 0x0001, 0x2777: 0x0001, 0x2778: 0x0001, 0x2779: 0x0001, 0x277a: 0x0001, 0x277b: 0x0001,
+	0x277c: 0x0001, 0x277d: 0x0001, 0x277e: 0x0001, 0x277f: 0x0001,
+	// Block 0x9e, offset 0x2780
+	0x2780: 0x0001, 0x2781: 0x000c, 0x2782: 0x000c, 0x2783: 0x000c, 0x2784: 0x0001, 0x2785: 0x000c,
+	0x2786: 0x000c, 0x2787: 0x0001, 0x2788: 0x0001, 0x2789: 0x0001, 0x278a: 0x0001, 0x278b: 0x0001,
+	0x278c: 0x000c, 0x278d: 0x000c, 0x278e: 0x000c, 0x278f: 0x000c, 0x2790: 0x0001, 0x2791: 0x0001,
+	0x2792: 0x0001, 0x2793: 0x0001, 0x2794: 0x0001, 0x2795: 0x0001, 0x2796: 0x0001, 0x2797: 0x0001,
+	0x2798: 0x0001, 0x2799: 0x0001, 0x279a: 0x0001, 0x279b: 0x0001, 0x279c: 0x0001, 0x279d: 0x0001,
+	0x279e: 0x0001, 0x279f: 0x0001, 0x27a0: 0x0001, 0x27a1: 0x0001, 0x27a2: 0x0001, 0x27a3: 0x0001,
+	0x27a4: 0x0001, 0x27a5: 0x0001, 0x27a6: 0x0001, 0x27a7: 0x0001, 0x27a8: 0x0001, 0x27a9: 0x0001,
+	0x27aa: 0x0001, 0x27ab: 0x0001, 0x27ac: 0x0001, 0x27ad: 0x0001, 0x27ae: 0x0001, 0x27af: 0x0001,
+	0x27b0: 0x0001, 0x27b1: 0x0001, 0x27b2: 0x0001, 0x27b3: 0x0001, 0x27b4: 0x0001, 0x27b5: 0x0001,
+	0x27b6: 0x0001, 0x27b7: 0x0001, 0x27b8: 0x000c, 0x27b9: 0x000c, 0x27ba: 0x000c, 0x27bb: 0x0001,
+	0x27bc: 0x0001, 0x27bd: 0x0001, 0x27be: 0x0001, 0x27bf: 0x000c,
+	// Block 0x9f, offset 0x27c0
+	0x27c0: 0x0001, 0x27c1: 0x0001, 0x27c2: 0x0001, 0x27c3: 0x0001, 0x27c4: 0x0001, 0x27c5: 0x0001,
+	0x27c6: 0x0001, 0x27c7: 0x0001, 0x27c8: 0x0001, 0x27c9: 0x0001, 0x27ca: 0x0001, 0x27cb: 0x0001,
+	0x27cc: 0x0001, 0x27cd: 0x0001, 0x27ce: 0x0001, 0x27cf: 0x0001, 0x27d0: 0x0001, 0x27d1: 0x0001,
+	0x27d2: 0x0001, 0x27d3: 0x0001, 0x27d4: 0x0001, 0x27d5: 0x0001, 0x27d6: 0x0001, 0x27d7: 0x0001,
+	0x27d8: 0x0001, 0x27d9: 0x0001, 0x27da: 0x0001, 0x27db: 0x0001, 0x27dc: 0x0001, 0x27dd: 0x0001,
+	0x27de: 0x0001, 0x27df: 0x0001, 0x27e0: 0x0001, 0x27e1: 0x0001, 0x27e2: 0x0001, 0x27e3: 0x0001,
+	0x27e4: 0x0001, 0x27e5: 0x000c, 0x27e6: 0x000c, 0x27e7: 0x0001, 0x27e8: 0x0001, 0x27e9: 0x0001,
+	0x27ea: 0x0001, 0x27eb: 0x0001, 0x27ec: 0x0001, 0x27ed: 0x0001, 0x27ee: 0x0001, 0x27ef: 0x0001,
+	0x27f0: 0x0001, 0x27f1: 0x0001, 0x27f2: 0x0001, 0x27f3: 0x0001, 0x27f4: 0x0001, 0x27f5: 0x0001,
+	0x27f6: 0x0001, 0x27f7: 0x0001, 0x27f8: 0x0001, 0x27f9: 0x0001, 0x27fa: 0x0001, 0x27fb: 0x0001,
+	0x27fc: 0x0001, 0x27fd: 0x0001, 0x27fe: 0x0001, 0x27ff: 0x0001,
+	// Block 0xa0, offset 0x2800
+	0x2800: 0x0001, 0x2801: 0x0001, 0x2802: 0x0001, 0x2803: 0x0001, 0x2804: 0x0001, 0x2805: 0x0001,
+	0x2806: 0x0001, 0x2807: 0x0001, 0x2808: 0x0001, 0x2809: 0x0001, 0x280a: 0x0001, 0x280b: 0x0001,
+	0x280c: 0x0001, 0x280d: 0x0001, 0x280e: 0x0001, 0x280f: 0x0001, 0x2810: 0x0001, 0x2811: 0x0001,
+	0x2812: 0x0001, 0x2813: 0x0001, 0x2814: 0x0001, 0x2815: 0x0001, 0x2816: 0x0001, 0x2817: 0x0001,
+	0x2818: 0x0001, 0x2819: 0x0001, 0x281a: 0x0001, 0x281b: 0x0001, 0x281c: 0x0001, 0x281d: 0x0001,
+	0x281e: 0x0001, 0x281f: 0x0001, 0x2820: 0x0001, 0x2821: 0x0001, 0x2822: 0x0001, 0x2823: 0x0001,
+	0x2824: 0x0001, 0x2825: 0x0001, 0x2826: 0x0001, 0x2827: 0x0001, 0x2828: 0x0001, 0x2829: 0x0001,
+	0x282a: 0x0001, 0x282b: 0x0001, 0x282c: 0x0001, 0x282d: 0x0001, 0x282e: 0x0001, 0x282f: 0x0001,
+	0x2830: 0x0001, 0x2831: 0x0001, 0x2832: 0x0001, 0x2833: 0x0001, 0x2834: 0x0001, 0x2835: 0x0001,
+	0x2836: 0x0001, 0x2837: 0x0001, 0x2838: 0x0001, 0x2839: 0x000a, 0x283a: 0x000a, 0x283b: 0x000a,
+	0x283c: 0x000a, 0x283d: 0x000a, 0x283e: 0x000a, 0x283f: 0x000a,
+	// Block 0xa1, offset 0x2840
+	0x2840: 0x0001, 0x2841: 0x0001, 0x2842: 0x0001, 0x2843: 0x0001, 0x2844: 0x0001, 0x2845: 0x0001,
+	0x2846: 0x0001, 0x2847: 0x0001, 0x2848: 0x0001, 0x2849: 0x0001, 0x284a: 0x0001, 0x284b: 0x0001,
+	0x284c: 0x0001, 0x284d: 0x0001, 0x284e: 0x0001, 0x284f: 0x0001, 0x2850: 0x0001, 0x2851: 0x0001,
+	0x2852: 0x0001, 0x2853: 0x0001, 0x2854: 0x0001, 0x2855: 0x0001, 0x2856: 0x0001, 0x2857: 0x0001,
+	0x2858: 0x0001, 0x2859: 0x0001, 0x285a: 0x0001, 0x285b: 0x0001, 0x285c: 0x0001, 0x285d: 0x0001,
+	0x285e: 0x0001, 0x285f: 0x0001, 0x2860: 0x0005, 0x2861: 0x0005, 0x2862: 0x0005, 0x2863: 0x0005,
+	0x2864: 0x0005, 0x2865: 0x0005, 0x2866: 0x0005, 0x2867: 0x0005, 0x2868: 0x0005, 0x2869: 0x0005,
+	0x286a: 0x0005, 0x286b: 0x0005, 0x286c: 0x0005, 0x286d: 0x0005, 0x286e: 0x0005, 0x286f: 0x0005,
+	0x2870: 0x0005, 0x2871: 0x0005, 0x2872: 0x0005, 0x2873: 0x0005, 0x2874: 0x0005, 0x2875: 0x0005,
+	0x2876: 0x0005, 0x2877: 0x0005, 0x2878: 0x0005, 0x2879: 0x0005, 0x287a: 0x0005, 0x287b: 0x0005,
+	0x287c: 0x0005, 0x287d: 0x0005, 0x287e: 0x0005, 0x287f: 0x0001,
+	// Block 0xa2, offset 0x2880
+	0x2881: 0x000c,
+	0x28b8: 0x000c, 0x28b9: 0x000c, 0x28ba: 0x000c, 0x28bb: 0x000c,
+	0x28bc: 0x000c, 0x28bd: 0x000c, 0x28be: 0x000c, 0x28bf: 0x000c,
+	// Block 0xa3, offset 0x28c0
+	0x28c0: 0x000c, 0x28c1: 0x000c, 0x28c2: 0x000c, 0x28c3: 0x000c, 0x28c4: 0x000c, 0x28c5: 0x000c,
+	0x28c6: 0x000c,
+	0x28d2: 0x000a, 0x28d3: 0x000a, 0x28d4: 0x000a, 0x28d5: 0x000a, 0x28d6: 0x000a, 0x28d7: 0x000a,
+	0x28d8: 0x000a, 0x28d9: 0x000a, 0x28da: 0x000a, 0x28db: 0x000a, 0x28dc: 0x000a, 0x28dd: 0x000a,
+	0x28de: 0x000a, 0x28df: 0x000a, 0x28e0: 0x000a, 0x28e1: 0x000a, 0x28e2: 0x000a, 0x28e3: 0x000a,
+	0x28e4: 0x000a, 0x28e5: 0x000a,
+	0x28ff: 0x000c,
+	// Block 0xa4, offset 0x2900
+	0x2900: 0x000c, 0x2901: 0x000c,
+	0x2933: 0x000c, 0x2934: 0x000c, 0x2935: 0x000c,
+	0x2936: 0x000c, 0x2939: 0x000c, 0x293a: 0x000c,
+	// Block 0xa5, offset 0x2940
+	0x2940: 0x000c, 0x2941: 0x000c, 0x2942: 0x000c,
+	0x2967: 0x000c, 0x2968: 0x000c, 0x2969: 0x000c,
+	0x296a: 0x000c, 0x296b: 0x000c, 0x296d: 0x000c, 0x296e: 0x000c, 0x296f: 0x000c,
+	0x2970: 0x000c, 0x2971: 0x000c, 0x2972: 0x000c, 0x2973: 0x000c, 0x2974: 0x000c,
+	// Block 0xa6, offset 0x2980
+	0x29b3: 0x000c,
+	// Block 0xa7, offset 0x29c0
+	0x29c0: 0x000c, 0x29c1: 0x000c,
+	0x29f6: 0x000c, 0x29f7: 0x000c, 0x29f8: 0x000c, 0x29f9: 0x000c, 0x29fa: 0x000c, 0x29fb: 0x000c,
+	0x29fc: 0x000c, 0x29fd: 0x000c, 0x29fe: 0x000c,
+	// Block 0xa8, offset 0x2a00
+	0x2a0a: 0x000c, 0x2a0b: 0x000c,
+	0x2a0c: 0x000c,
+	// Block 0xa9, offset 0x2a40
+	0x2a6f: 0x000c,
+	0x2a70: 0x000c, 0x2a71: 0x000c, 0x2a74: 0x000c,
+	0x2a76: 0x000c, 0x2a77: 0x000c,
+	0x2a7e: 0x000c,
+	// Block 0xaa, offset 0x2a80
+	0x2a9f: 0x000c, 0x2aa3: 0x000c,
+	0x2aa4: 0x000c, 0x2aa5: 0x000c, 0x2aa6: 0x000c, 0x2aa7: 0x000c, 0x2aa8: 0x000c, 0x2aa9: 0x000c,
+	0x2aaa: 0x000c,
+	// Block 0xab, offset 0x2ac0
+	0x2ac0: 0x000c, 0x2ac1: 0x000c,
+	0x2afc: 0x000c,
+	// Block 0xac, offset 0x2b00
+	0x2b00: 0x000c,
+	0x2b26: 0x000c, 0x2b27: 0x000c, 0x2b28: 0x000c, 0x2b29: 0x000c,
+	0x2b2a: 0x000c, 0x2b2b: 0x000c, 0x2b2c: 0x000c,
+	0x2b30: 0x000c, 0x2b31: 0x000c, 0x2b32: 0x000c, 0x2b33: 0x000c, 0x2b34: 0x000c,
+	// Block 0xad, offset 0x2b40
+	0x2b78: 0x000c, 0x2b79: 0x000c, 0x2b7a: 0x000c, 0x2b7b: 0x000c,
+	0x2b7c: 0x000c, 0x2b7d: 0x000c, 0x2b7e: 0x000c, 0x2b7f: 0x000c,
+	// Block 0xae, offset 0x2b80
+	0x2b82: 0x000c, 0x2b83: 0x000c, 0x2b84: 0x000c,
+	0x2b86: 0x000c,
+	// Block 0xaf, offset 0x2bc0
+	0x2bf3: 0x000c, 0x2bf4: 0x000c, 0x2bf5: 0x000c,
+	0x2bf6: 0x000c, 0x2bf7: 0x000c, 0x2bf8: 0x000c, 0x2bfa: 0x000c,
+	0x2bff: 0x000c,
+	// Block 0xb0, offset 0x2c00
+	0x2c00: 0x000c, 0x2c02: 0x000c, 0x2c03: 0x000c,
+	// Block 0xb1, offset 0x2c40
+	0x2c72: 0x000c, 0x2c73: 0x000c, 0x2c74: 0x000c, 0x2c75: 0x000c,
+	0x2c7c: 0x000c, 0x2c7d: 0x000c, 0x2c7f: 0x000c,
+	// Block 0xb2, offset 0x2c80
+	0x2c80: 0x000c,
+	0x2c9c: 0x000c, 0x2c9d: 0x000c,
+	// Block 0xb3, offset 0x2cc0
+	0x2cf3: 0x000c, 0x2cf4: 0x000c, 0x2cf5: 0x000c,
+	0x2cf6: 0x000c, 0x2cf7: 0x000c, 0x2cf8: 0x000c, 0x2cf9: 0x000c, 0x2cfa: 0x000c,
+	0x2cfd: 0x000c, 0x2cff: 0x000c,
+	// Block 0xb4, offset 0x2d00
+	0x2d00: 0x000c,
+	0x2d20: 0x000a, 0x2d21: 0x000a, 0x2d22: 0x000a, 0x2d23: 0x000a,
+	0x2d24: 0x000a, 0x2d25: 0x000a, 0x2d26: 0x000a, 0x2d27: 0x000a, 0x2d28: 0x000a, 0x2d29: 0x000a,
+	0x2d2a: 0x000a, 0x2d2b: 0x000a, 0x2d2c: 0x000a,
+	// Block 0xb5, offset 0x2d40
+	0x2d6b: 0x000c, 0x2d6d: 0x000c,
+	0x2d70: 0x000c, 0x2d71: 0x000c, 0x2d72: 0x000c, 0x2d73: 0x000c, 0x2d74: 0x000c, 0x2d75: 0x000c,
+	0x2d77: 0x000c,
+	// Block 0xb6, offset 0x2d80
+	0x2d9d: 0x000c,
+	0x2d9e: 0x000c, 0x2d9f: 0x000c, 0x2da2: 0x000c, 0x2da3: 0x000c,
+	0x2da4: 0x000c, 0x2da5: 0x000c, 0x2da7: 0x000c, 0x2da8: 0x000c, 0x2da9: 0x000c,
+	0x2daa: 0x000c, 0x2dab: 0x000c,
+	// Block 0xb7, offset 0x2dc0
+	0x2dc1: 0x000c, 0x2dc2: 0x000c, 0x2dc3: 0x000c, 0x2dc4: 0x000c, 0x2dc5: 0x000c,
+	0x2dc6: 0x000c, 0x2dc9: 0x000c, 0x2dca: 0x000c,
+	0x2df3: 0x000c, 0x2df4: 0x000c, 0x2df5: 0x000c,
+	0x2df6: 0x000c, 0x2df7: 0x000c, 0x2df8: 0x000c, 0x2dfb: 0x000c,
+	0x2dfc: 0x000c, 0x2dfd: 0x000c, 0x2dfe: 0x000c,
+	// Block 0xb8, offset 0x2e00
+	0x2e07: 0x000c,
+	0x2e11: 0x000c,
+	0x2e12: 0x000c, 0x2e13: 0x000c, 0x2e14: 0x000c, 0x2e15: 0x000c, 0x2e16: 0x000c,
+	0x2e19: 0x000c, 0x2e1a: 0x000c, 0x2e1b: 0x000c,
+	// Block 0xb9, offset 0x2e40
+	0x2e4a: 0x000c, 0x2e4b: 0x000c,
+	0x2e4c: 0x000c, 0x2e4d: 0x000c, 0x2e4e: 0x000c, 0x2e4f: 0x000c, 0x2e50: 0x000c, 0x2e51: 0x000c,
+	0x2e52: 0x000c, 0x2e53: 0x000c, 0x2e54: 0x000c, 0x2e55: 0x000c, 0x2e56: 0x000c,
+	0x2e58: 0x000c, 0x2e59: 0x000c,
+	// Block 0xba, offset 0x2e80
+	0x2eb0: 0x000c, 0x2eb1: 0x000c, 0x2eb2: 0x000c, 0x2eb3: 0x000c, 0x2eb4: 0x000c, 0x2eb5: 0x000c,
+	0x2eb6: 0x000c, 0x2eb8: 0x000c, 0x2eb9: 0x000c, 0x2eba: 0x000c, 0x2ebb: 0x000c,
+	0x2ebc: 0x000c, 0x2ebd: 0x000c,
+	// Block 0xbb, offset 0x2ec0
+	0x2ed2: 0x000c, 0x2ed3: 0x000c, 0x2ed4: 0x000c, 0x2ed5: 0x000c, 0x2ed6: 0x000c, 0x2ed7: 0x000c,
+	0x2ed8: 0x000c, 0x2ed9: 0x000c, 0x2eda: 0x000c, 0x2edb: 0x000c, 0x2edc: 0x000c, 0x2edd: 0x000c,
+	0x2ede: 0x000c, 0x2edf: 0x000c, 0x2ee0: 0x000c, 0x2ee1: 0x000c, 0x2ee2: 0x000c, 0x2ee3: 0x000c,
+	0x2ee4: 0x000c, 0x2ee5: 0x000c, 0x2ee6: 0x000c, 0x2ee7: 0x000c,
+	0x2eea: 0x000c, 0x2eeb: 0x000c, 0x2eec: 0x000c, 0x2eed: 0x000c, 0x2eee: 0x000c, 0x2eef: 0x000c,
+	0x2ef0: 0x000c, 0x2ef2: 0x000c, 0x2ef3: 0x000c, 0x2ef5: 0x000c,
+	0x2ef6: 0x000c,
+	// Block 0xbc, offset 0x2f00
+	0x2f31: 0x000c, 0x2f32: 0x000c, 0x2f33: 0x000c, 0x2f34: 0x000c, 0x2f35: 0x000c,
+	0x2f36: 0x000c, 0x2f3a: 0x000c,
+	0x2f3c: 0x000c, 0x2f3d: 0x000c, 0x2f3f: 0x000c,
+	// Block 0xbd, offset 0x2f40
+	0x2f40: 0x000c, 0x2f41: 0x000c, 0x2f42: 0x000c, 0x2f43: 0x000c, 0x2f44: 0x000c, 0x2f45: 0x000c,
+	0x2f47: 0x000c,
+	// Block 0xbe, offset 0x2f80
+	0x2fb0: 0x000c, 0x2fb1: 0x000c, 0x2fb2: 0x000c, 0x2fb3: 0x000c, 0x2fb4: 0x000c,
+	// Block 0xbf, offset 0x2fc0
+	0x2ff0: 0x000c, 0x2ff1: 0x000c, 0x2ff2: 0x000c, 0x2ff3: 0x000c, 0x2ff4: 0x000c, 0x2ff5: 0x000c,
+	0x2ff6: 0x000c,
+	// Block 0xc0, offset 0x3000
+	0x300f: 0x000c, 0x3010: 0x000c, 0x3011: 0x000c,
+	0x3012: 0x000c,
+	// Block 0xc1, offset 0x3040
+	0x305d: 0x000c,
+	0x305e: 0x000c, 0x3060: 0x000b, 0x3061: 0x000b, 0x3062: 0x000b, 0x3063: 0x000b,
+	// Block 0xc2, offset 0x3080
+	0x30a7: 0x000c, 0x30a8: 0x000c, 0x30a9: 0x000c,
+	0x30b3: 0x000b, 0x30b4: 0x000b, 0x30b5: 0x000b,
+	0x30b6: 0x000b, 0x30b7: 0x000b, 0x30b8: 0x000b, 0x30b9: 0x000b, 0x30ba: 0x000b, 0x30bb: 0x000c,
+	0x30bc: 0x000c, 0x30bd: 0x000c, 0x30be: 0x000c, 0x30bf: 0x000c,
+	// Block 0xc3, offset 0x30c0
+	0x30c0: 0x000c, 0x30c1: 0x000c, 0x30c2: 0x000c, 0x30c5: 0x000c,
+	0x30c6: 0x000c, 0x30c7: 0x000c, 0x30c8: 0x000c, 0x30c9: 0x000c, 0x30ca: 0x000c, 0x30cb: 0x000c,
+	0x30ea: 0x000c, 0x30eb: 0x000c, 0x30ec: 0x000c, 0x30ed: 0x000c,
+	// Block 0xc4, offset 0x3100
+	0x3100: 0x000a, 0x3101: 0x000a, 0x3102: 0x000c, 0x3103: 0x000c, 0x3104: 0x000c, 0x3105: 0x000a,
+	// Block 0xc5, offset 0x3140
+	0x3140: 0x000a, 0x3141: 0x000a, 0x3142: 0x000a, 0x3143: 0x000a, 0x3144: 0x000a, 0x3145: 0x000a,
+	0x3146: 0x000a, 0x3147: 0x000a, 0x3148: 0x000a, 0x3149: 0x000a, 0x314a: 0x000a, 0x314b: 0x000a,
+	0x314c: 0x000a, 0x314d: 0x000a, 0x314e: 0x000a, 0x314f: 0x000a, 0x3150: 0x000a, 0x3151: 0x000a,
+	0x3152: 0x000a, 0x3153: 0x000a, 0x3154: 0x000a, 0x3155: 0x000a, 0x3156: 0x000a,
+	// Block 0xc6, offset 0x3180
+	0x319b: 0x000a,
+	// Block 0xc7, offset 0x31c0
+	0x31d5: 0x000a,
+	// Block 0xc8, offset 0x3200
+	0x320f: 0x000a,
+	// Block 0xc9, offset 0x3240
+	0x3249: 0x000a,
+	// Block 0xca, offset 0x3280
+	0x3283: 0x000a,
+	0x328e: 0x0002, 0x328f: 0x0002, 0x3290: 0x0002, 0x3291: 0x0002,
+	0x3292: 0x0002, 0x3293: 0x0002, 0x3294: 0x0002, 0x3295: 0x0002, 0x3296: 0x0002, 0x3297: 0x0002,
+	0x3298: 0x0002, 0x3299: 0x0002, 0x329a: 0x0002, 0x329b: 0x0002, 0x329c: 0x0002, 0x329d: 0x0002,
+	0x329e: 0x0002, 0x329f: 0x0002, 0x32a0: 0x0002, 0x32a1: 0x0002, 0x32a2: 0x0002, 0x32a3: 0x0002,
+	0x32a4: 0x0002, 0x32a5: 0x0002, 0x32a6: 0x0002, 0x32a7: 0x0002, 0x32a8: 0x0002, 0x32a9: 0x0002,
+	0x32aa: 0x0002, 0x32ab: 0x0002, 0x32ac: 0x0002, 0x32ad: 0x0002, 0x32ae: 0x0002, 0x32af: 0x0002,
+	0x32b0: 0x0002, 0x32b1: 0x0002, 0x32b2: 0x0002, 0x32b3: 0x0002, 0x32b4: 0x0002, 0x32b5: 0x0002,
+	0x32b6: 0x0002, 0x32b7: 0x0002, 0x32b8: 0x0002, 0x32b9: 0x0002, 0x32ba: 0x0002, 0x32bb: 0x0002,
+	0x32bc: 0x0002, 0x32bd: 0x0002, 0x32be: 0x0002, 0x32bf: 0x0002,
+	// Block 0xcb, offset 0x32c0
+	0x32c0: 0x000c, 0x32c1: 0x000c, 0x32c2: 0x000c, 0x32c3: 0x000c, 0x32c4: 0x000c, 0x32c5: 0x000c,
+	0x32c6: 0x000c, 0x32c7: 0x000c, 0x32c8: 0x000c, 0x32c9: 0x000c, 0x32ca: 0x000c, 0x32cb: 0x000c,
+	0x32cc: 0x000c, 0x32cd: 0x000c, 0x32ce: 0x000c, 0x32cf: 0x000c, 0x32d0: 0x000c, 0x32d1: 0x000c,
+	0x32d2: 0x000c, 0x32d3: 0x000c, 0x32d4: 0x000c, 0x32d5: 0x000c, 0x32d6: 0x000c, 0x32d7: 0x000c,
+	0x32d8: 0x000c, 0x32d9: 0x000c, 0x32da: 0x000c, 0x32db: 0x000c, 0x32dc: 0x000c, 0x32dd: 0x000c,
+	0x32de: 0x000c, 0x32df: 0x000c, 0x32e0: 0x000c, 0x32e1: 0x000c, 0x32e2: 0x000c, 0x32e3: 0x000c,
+	0x32e4: 0x000c, 0x32e5: 0x000c, 0x32e6: 0x000c, 0x32e7: 0x000c, 0x32e8: 0x000c, 0x32e9: 0x000c,
+	0x32ea: 0x000c, 0x32eb: 0x000c, 0x32ec: 0x000c, 0x32ed: 0x000c, 0x32ee: 0x000c, 0x32ef: 0x000c,
+	0x32f0: 0x000c, 0x32f1: 0x000c, 0x32f2: 0x000c, 0x32f3: 0x000c, 0x32f4: 0x000c, 0x32f5: 0x000c,
+	0x32f6: 0x000c, 0x32fb: 0x000c,
+	0x32fc: 0x000c, 0x32fd: 0x000c, 0x32fe: 0x000c, 0x32ff: 0x000c,
+	// Block 0xcc, offset 0x3300
+	0x3300: 0x000c, 0x3301: 0x000c, 0x3302: 0x000c, 0x3303: 0x000c, 0x3304: 0x000c, 0x3305: 0x000c,
+	0x3306: 0x000c, 0x3307: 0x000c, 0x3308: 0x000c, 0x3309: 0x000c, 0x330a: 0x000c, 0x330b: 0x000c,
+	0x330c: 0x000c, 0x330d: 0x000c, 0x330e: 0x000c, 0x330f: 0x000c, 0x3310: 0x000c, 0x3311: 0x000c,
+	0x3312: 0x000c, 0x3313: 0x000c, 0x3314: 0x000c, 0x3315: 0x000c, 0x3316: 0x000c, 0x3317: 0x000c,
+	0x3318: 0x000c, 0x3319: 0x000c, 0x331a: 0x000c, 0x331b: 0x000c, 0x331c: 0x000c, 0x331d: 0x000c,
+	0x331e: 0x000c, 0x331f: 0x000c, 0x3320: 0x000c, 0x3321: 0x000c, 0x3322: 0x000c, 0x3323: 0x000c,
+	0x3324: 0x000c, 0x3325: 0x000c, 0x3326: 0x000c, 0x3327: 0x000c, 0x3328: 0x000c, 0x3329: 0x000c,
+	0x332a: 0x000c, 0x332b: 0x000c, 0x332c: 0x000c,
+	0x3335: 0x000c,
+	// Block 0xcd, offset 0x3340
+	0x3344: 0x000c,
+	0x335b: 0x000c, 0x335c: 0x000c, 0x335d: 0x000c,
+	0x335e: 0x000c, 0x335f: 0x000c, 0x3361: 0x000c, 0x3362: 0x000c, 0x3363: 0x000c,
+	0x3364: 0x000c, 0x3365: 0x000c, 0x3366: 0x000c, 0x3367: 0x000c, 0x3368: 0x000c, 0x3369: 0x000c,
+	0x336a: 0x000c, 0x336b: 0x000c, 0x336c: 0x000c, 0x336d: 0x000c, 0x336e: 0x000c, 0x336f: 0x000c,
+	// Block 0xce, offset 0x3380
+	0x3380: 0x000c, 0x3381: 0x000c, 0x3382: 0x000c, 0x3383: 0x000c, 0x3384: 0x000c, 0x3385: 0x000c,
+	0x3386: 0x000c, 0x3388: 0x000c, 0x3389: 0x000c, 0x338a: 0x000c, 0x338b: 0x000c,
+	0x338c: 0x000c, 0x338d: 0x000c, 0x338e: 0x000c, 0x338f: 0x000c, 0x3390: 0x000c, 0x3391: 0x000c,
+	0x3392: 0x000c, 0x3393: 0x000c, 0x3394: 0x000c, 0x3395: 0x000c, 0x3396: 0x000c, 0x3397: 0x000c,
+	0x3398: 0x000c, 0x339b: 0x000c, 0x339c: 0x000c, 0x339d: 0x000c,
+	0x339e: 0x000c, 0x339f: 0x000c, 0x33a0: 0x000c, 0x33a1: 0x000c, 0x33a3: 0x000c,
+	0x33a4: 0x000c, 0x33a6: 0x000c, 0x33a7: 0x000c, 0x33a8: 0x000c, 0x33a9: 0x000c,
+	0x33aa: 0x000c,
+	// Block 0xcf, offset 0x33c0
+	0x33c0: 0x0001, 0x33c1: 0x0001, 0x33c2: 0x0001, 0x33c3: 0x0001, 0x33c4: 0x0001, 0x33c5: 0x0001,
+	0x33c6: 0x0001, 0x33c7: 0x0001, 0x33c8: 0x0001, 0x33c9: 0x0001, 0x33ca: 0x0001, 0x33cb: 0x0001,
+	0x33cc: 0x0001, 0x33cd: 0x0001, 0x33ce: 0x0001, 0x33cf: 0x0001, 0x33d0: 0x000c, 0x33d1: 0x000c,
+	0x33d2: 0x000c, 0x33d3: 0x000c, 0x33d4: 0x000c, 0x33d5: 0x000c, 0x33d6: 0x000c, 0x33d7: 0x0001,
+	0x33d8: 0x0001, 0x33d9: 0x0001, 0x33da: 0x0001, 0x33db: 0x0001, 0x33dc: 0x0001, 0x33dd: 0x0001,
+	0x33de: 0x0001, 0x33df: 0x0001, 0x33e0: 0x0001, 0x33e1: 0x0001, 0x33e2: 0x0001, 0x33e3: 0x0001,
+	0x33e4: 0x0001, 0x33e5: 0x0001, 0x33e6: 0x0001, 0x33e7: 0x0001, 0x33e8: 0x0001, 0x33e9: 0x0001,
+	0x33ea: 0x0001, 0x33eb: 0x0001, 0x33ec: 0x0001, 0x33ed: 0x0001, 0x33ee: 0x0001, 0x33ef: 0x0001,
+	0x33f0: 0x0001, 0x33f1: 0x0001, 0x33f2: 0x0001, 0x33f3: 0x0001, 0x33f4: 0x0001, 0x33f5: 0x0001,
+	0x33f6: 0x0001, 0x33f7: 0x0001, 0x33f8: 0x0001, 0x33f9: 0x0001, 0x33fa: 0x0001, 0x33fb: 0x0001,
+	0x33fc: 0x0001, 0x33fd: 0x0001, 0x33fe: 0x0001, 0x33ff: 0x0001,
+	// Block 0xd0, offset 0x3400
+	0x3400: 0x0001, 0x3401: 0x0001, 0x3402: 0x0001, 0x3403: 0x0001, 0x3404: 0x000c, 0x3405: 0x000c,
+	0x3406: 0x000c, 0x3407: 0x000c, 0x3408: 0x000c, 0x3409: 0x000c, 0x340a: 0x000c, 0x340b: 0x0001,
+	0x340c: 0x0001, 0x340d: 0x0001, 0x340e: 0x0001, 0x340f: 0x0001, 0x3410: 0x0001, 0x3411: 0x0001,
+	0x3412: 0x0001, 0x3413: 0x0001, 0x3414: 0x0001, 0x3415: 0x0001, 0x3416: 0x0001, 0x3417: 0x0001,
+	0x3418: 0x0001, 0x3419: 0x0001, 0x341a: 0x0001, 0x341b: 0x0001, 0x341c: 0x0001, 0x341d: 0x0001,
+	0x341e: 0x0001, 0x341f: 0x0001, 0x3420: 0x0001, 0x3421: 0x0001, 0x3422: 0x0001, 0x3423: 0x0001,
+	0x3424: 0x0001, 0x3425: 0x0001, 0x3426: 0x0001, 0x3427: 0x0001, 0x3428: 0x0001, 0x3429: 0x0001,
+	0x342a: 0x0001, 0x342b: 0x0001, 0x342c: 0x0001, 0x342d: 0x0001, 0x342e: 0x0001, 0x342f: 0x0001,
+	0x3430: 0x0001, 0x3431: 0x0001, 0x3432: 0x0001, 0x3433: 0x0001, 0x3434: 0x0001, 0x3435: 0x0001,
+	0x3436: 0x0001, 0x3437: 0x0001, 0x3438: 0x0001, 0x3439: 0x0001, 0x343a: 0x0001, 0x343b: 0x0001,
+	0x343c: 0x0001, 0x343d: 0x0001, 0x343e: 0x0001, 0x343f: 0x0001,
+	// Block 0xd1, offset 0x3440
+	0x3440: 0x000d, 0x3441: 0x000d, 0x3442: 0x000d, 0x3443: 0x000d, 0x3444: 0x000d, 0x3445: 0x000d,
+	0x3446: 0x000d, 0x3447: 0x000d, 0x3448: 0x000d, 0x3449: 0x000d, 0x344a: 0x000d, 0x344b: 0x000d,
+	0x344c: 0x000d, 0x344d: 0x000d, 0x344e: 0x000d, 0x344f: 0x000d, 0x3450: 0x000d, 0x3451: 0x000d,
+	0x3452: 0x000d, 0x3453: 0x000d, 0x3454: 0x000d, 0x3455: 0x000d, 0x3456: 0x000d, 0x3457: 0x000d,
+	0x3458: 0x000d, 0x3459: 0x000d, 0x345a: 0x000d, 0x345b: 0x000d, 0x345c: 0x000d, 0x345d: 0x000d,
+	0x345e: 0x000d, 0x345f: 0x000d, 0x3460: 0x000d, 0x3461: 0x000d, 0x3462: 0x000d, 0x3463: 0x000d,
+	0x3464: 0x000d, 0x3465: 0x000d, 0x3466: 0x000d, 0x3467: 0x000d, 0x3468: 0x000d, 0x3469: 0x000d,
+	0x346a: 0x000d, 0x346b: 0x000d, 0x346c: 0x000d, 0x346d: 0x000d, 0x346e: 0x000d, 0x346f: 0x000d,
+	0x3470: 0x000a, 0x3471: 0x000a, 0x3472: 0x000d, 0x3473: 0x000d, 0x3474: 0x000d, 0x3475: 0x000d,
+	0x3476: 0x000d, 0x3477: 0x000d, 0x3478: 0x000d, 0x3479: 0x000d, 0x347a: 0x000d, 0x347b: 0x000d,
+	0x347c: 0x000d, 0x347d: 0x000d, 0x347e: 0x000d, 0x347f: 0x000d,
+	// Block 0xd2, offset 0x3480
+	0x3480: 0x000a, 0x3481: 0x000a, 0x3482: 0x000a, 0x3483: 0x000a, 0x3484: 0x000a, 0x3485: 0x000a,
+	0x3486: 0x000a, 0x3487: 0x000a, 0x3488: 0x000a, 0x3489: 0x000a, 0x348a: 0x000a, 0x348b: 0x000a,
+	0x348c: 0x000a, 0x348d: 0x000a, 0x348e: 0x000a, 0x348f: 0x000a, 0x3490: 0x000a, 0x3491: 0x000a,
+	0x3492: 0x000a, 0x3493: 0x000a, 0x3494: 0x000a, 0x3495: 0x000a, 0x3496: 0x000a, 0x3497: 0x000a,
+	0x3498: 0x000a, 0x3499: 0x000a, 0x349a: 0x000a, 0x349b: 0x000a, 0x349c: 0x000a, 0x349d: 0x000a,
+	0x349e: 0x000a, 0x349f: 0x000a, 0x34a0: 0x000a, 0x34a1: 0x000a, 0x34a2: 0x000a, 0x34a3: 0x000a,
+	0x34a4: 0x000a, 0x34a5: 0x000a, 0x34a6: 0x000a, 0x34a7: 0x000a, 0x34a8: 0x000a, 0x34a9: 0x000a,
+	0x34aa: 0x000a, 0x34ab: 0x000a,
+	0x34b0: 0x000a, 0x34b1: 0x000a, 0x34b2: 0x000a, 0x34b3: 0x000a, 0x34b4: 0x000a, 0x34b5: 0x000a,
+	0x34b6: 0x000a, 0x34b7: 0x000a, 0x34b8: 0x000a, 0x34b9: 0x000a, 0x34ba: 0x000a, 0x34bb: 0x000a,
+	0x34bc: 0x000a, 0x34bd: 0x000a, 0x34be: 0x000a, 0x34bf: 0x000a,
+	// Block 0xd3, offset 0x34c0
+	0x34c0: 0x000a, 0x34c1: 0x000a, 0x34c2: 0x000a, 0x34c3: 0x000a, 0x34c4: 0x000a, 0x34c5: 0x000a,
+	0x34c6: 0x000a, 0x34c7: 0x000a, 0x34c8: 0x000a, 0x34c9: 0x000a, 0x34ca: 0x000a, 0x34cb: 0x000a,
+	0x34cc: 0x000a, 0x34cd: 0x000a, 0x34ce: 0x000a, 0x34cf: 0x000a, 0x34d0: 0x000a, 0x34d1: 0x000a,
+	0x34d2: 0x000a, 0x34d3: 0x000a,
+	0x34e0: 0x000a, 0x34e1: 0x000a, 0x34e2: 0x000a, 0x34e3: 0x000a,
+	0x34e4: 0x000a, 0x34e5: 0x000a, 0x34e6: 0x000a, 0x34e7: 0x000a, 0x34e8: 0x000a, 0x34e9: 0x000a,
+	0x34ea: 0x000a, 0x34eb: 0x000a, 0x34ec: 0x000a, 0x34ed: 0x000a, 0x34ee: 0x000a,
+	0x34f1: 0x000a, 0x34f2: 0x000a, 0x34f3: 0x000a, 0x34f4: 0x000a, 0x34f5: 0x000a,
+	0x34f6: 0x000a, 0x34f7: 0x000a, 0x34f8: 0x000a, 0x34f9: 0x000a, 0x34fa: 0x000a, 0x34fb: 0x000a,
+	0x34fc: 0x000a, 0x34fd: 0x000a, 0x34fe: 0x000a, 0x34ff: 0x000a,
+	// Block 0xd4, offset 0x3500
+	0x3501: 0x000a, 0x3502: 0x000a, 0x3503: 0x000a, 0x3504: 0x000a, 0x3505: 0x000a,
+	0x3506: 0x000a, 0x3507: 0x000a, 0x3508: 0x000a, 0x3509: 0x000a, 0x350a: 0x000a, 0x350b: 0x000a,
+	0x350c: 0x000a, 0x350d: 0x000a, 0x350e: 0x000a, 0x350f: 0x000a, 0x3511: 0x000a,
+	0x3512: 0x000a, 0x3513: 0x000a, 0x3514: 0x000a, 0x3515: 0x000a, 0x3516: 0x000a, 0x3517: 0x000a,
+	0x3518: 0x000a, 0x3519: 0x000a, 0x351a: 0x000a, 0x351b: 0x000a, 0x351c: 0x000a, 0x351d: 0x000a,
+	0x351e: 0x000a, 0x351f: 0x000a, 0x3520: 0x000a, 0x3521: 0x000a, 0x3522: 0x000a, 0x3523: 0x000a,
+	0x3524: 0x000a, 0x3525: 0x000a, 0x3526: 0x000a, 0x3527: 0x000a, 0x3528: 0x000a, 0x3529: 0x000a,
+	0x352a: 0x000a, 0x352b: 0x000a, 0x352c: 0x000a, 0x352d: 0x000a, 0x352e: 0x000a, 0x352f: 0x000a,
+	0x3530: 0x000a, 0x3531: 0x000a, 0x3532: 0x000a, 0x3533: 0x000a, 0x3534: 0x000a, 0x3535: 0x000a,
+	// Block 0xd5, offset 0x3540
+	0x3540: 0x0002, 0x3541: 0x0002, 0x3542: 0x0002, 0x3543: 0x0002, 0x3544: 0x0002, 0x3545: 0x0002,
+	0x3546: 0x0002, 0x3547: 0x0002, 0x3548: 0x0002, 0x3549: 0x0002, 0x354a: 0x0002, 0x354b: 0x000a,
+	0x354c: 0x000a,
+	// Block 0xd6, offset 0x3580
+	0x35aa: 0x000a, 0x35ab: 0x000a,
+	// Block 0xd7, offset 0x35c0
+	0x35e0: 0x000a, 0x35e1: 0x000a, 0x35e2: 0x000a, 0x35e3: 0x000a,
+	0x35e4: 0x000a, 0x35e5: 0x000a,
+	// Block 0xd8, offset 0x3600
+	0x3600: 0x000a, 0x3601: 0x000a, 0x3602: 0x000a, 0x3603: 0x000a, 0x3604: 0x000a, 0x3605: 0x000a,
+	0x3606: 0x000a, 0x3607: 0x000a, 0x3608: 0x000a, 0x3609: 0x000a, 0x360a: 0x000a, 0x360b: 0x000a,
+	0x360c: 0x000a, 0x360d: 0x000a, 0x360e: 0x000a, 0x360f: 0x000a, 0x3610: 0x000a, 0x3611: 0x000a,
+	0x3612: 0x000a, 0x3613: 0x000a, 0x3614: 0x000a,
+	0x3620: 0x000a, 0x3621: 0x000a, 0x3622: 0x000a, 0x3623: 0x000a,
+	0x3624: 0x000a, 0x3625: 0x000a, 0x3626: 0x000a, 0x3627: 0x000a, 0x3628: 0x000a, 0x3629: 0x000a,
+	0x362a: 0x000a, 0x362b: 0x000a, 0x362c: 0x000a,
+	0x3630: 0x000a, 0x3631: 0x000a, 0x3632: 0x000a, 0x3633: 0x000a, 0x3634: 0x000a, 0x3635: 0x000a,
+	0x3636: 0x000a, 0x3637: 0x000a, 0x3638: 0x000a,
+	// Block 0xd9, offset 0x3640
+	0x3640: 0x000a, 0x3641: 0x000a, 0x3642: 0x000a, 0x3643: 0x000a, 0x3644: 0x000a, 0x3645: 0x000a,
+	0x3646: 0x000a, 0x3647: 0x000a, 0x3648: 0x000a, 0x3649: 0x000a, 0x364a: 0x000a, 0x364b: 0x000a,
+	0x364c: 0x000a, 0x364d: 0x000a, 0x364e: 0x000a, 0x364f: 0x000a, 0x3650: 0x000a, 0x3651: 0x000a,
+	0x3652: 0x000a, 0x3653: 0x000a, 0x3654: 0x000a,
+	// Block 0xda, offset 0x3680
+	0x3680: 0x000a, 0x3681: 0x000a, 0x3682: 0x000a, 0x3683: 0x000a, 0x3684: 0x000a, 0x3685: 0x000a,
+	0x3686: 0x000a, 0x3687: 0x000a, 0x3688: 0x000a, 0x3689: 0x000a, 0x368a: 0x000a, 0x368b: 0x000a,
+	0x3690: 0x000a, 0x3691: 0x000a,
+	0x3692: 0x000a, 0x3693: 0x000a, 0x3694: 0x000a, 0x3695: 0x000a, 0x3696: 0x000a, 0x3697: 0x000a,
+	0x3698: 0x000a, 0x3699: 0x000a, 0x369a: 0x000a, 0x369b: 0x000a, 0x369c: 0x000a, 0x369d: 0x000a,
+	0x369e: 0x000a, 0x369f: 0x000a, 0x36a0: 0x000a, 0x36a1: 0x000a, 0x36a2: 0x000a, 0x36a3: 0x000a,
+	0x36a4: 0x000a, 0x36a5: 0x000a, 0x36a6: 0x000a, 0x36a7: 0x000a, 0x36a8: 0x000a, 0x36a9: 0x000a,
+	0x36aa: 0x000a, 0x36ab: 0x000a, 0x36ac: 0x000a, 0x36ad: 0x000a, 0x36ae: 0x000a, 0x36af: 0x000a,
+	0x36b0: 0x000a, 0x36b1: 0x000a, 0x36b2: 0x000a, 0x36b3: 0x000a, 0x36b4: 0x000a, 0x36b5: 0x000a,
+	0x36b6: 0x000a, 0x36b7: 0x000a, 0x36b8: 0x000a, 0x36b9: 0x000a, 0x36ba: 0x000a, 0x36bb: 0x000a,
+	0x36bc: 0x000a, 0x36bd: 0x000a, 0x36be: 0x000a, 0x36bf: 0x000a,
+	// Block 0xdb, offset 0x36c0
+	0x36c0: 0x000a, 0x36c1: 0x000a, 0x36c2: 0x000a, 0x36c3: 0x000a, 0x36c4: 0x000a, 0x36c5: 0x000a,
+	0x36c6: 0x000a, 0x36c7: 0x000a,
+	0x36d0: 0x000a, 0x36d1: 0x000a,
+	0x36d2: 0x000a, 0x36d3: 0x000a, 0x36d4: 0x000a, 0x36d5: 0x000a, 0x36d6: 0x000a, 0x36d7: 0x000a,
+	0x36d8: 0x000a, 0x36d9: 0x000a,
+	0x36e0: 0x000a, 0x36e1: 0x000a, 0x36e2: 0x000a, 0x36e3: 0x000a,
+	0x36e4: 0x000a, 0x36e5: 0x000a, 0x36e6: 0x000a, 0x36e7: 0x000a, 0x36e8: 0x000a, 0x36e9: 0x000a,
+	0x36ea: 0x000a, 0x36eb: 0x000a, 0x36ec: 0x000a, 0x36ed: 0x000a, 0x36ee: 0x000a, 0x36ef: 0x000a,
+	0x36f0: 0x000a, 0x36f1: 0x000a, 0x36f2: 0x000a, 0x36f3: 0x000a, 0x36f4: 0x000a, 0x36f5: 0x000a,
+	0x36f6: 0x000a, 0x36f7: 0x000a, 0x36f8: 0x000a, 0x36f9: 0x000a, 0x36fa: 0x000a, 0x36fb: 0x000a,
+	0x36fc: 0x000a, 0x36fd: 0x000a, 0x36fe: 0x000a, 0x36ff: 0x000a,
+	// Block 0xdc, offset 0x3700
+	0x3700: 0x000a, 0x3701: 0x000a, 0x3702: 0x000a, 0x3703: 0x000a, 0x3704: 0x000a, 0x3705: 0x000a,
+	0x3706: 0x000a, 0x3707: 0x000a,
+	0x3710: 0x000a, 0x3711: 0x000a,
+	0x3712: 0x000a, 0x3713: 0x000a, 0x3714: 0x000a, 0x3715: 0x000a, 0x3716: 0x000a, 0x3717: 0x000a,
+	0x3718: 0x000a, 0x3719: 0x000a, 0x371a: 0x000a, 0x371b: 0x000a, 0x371c: 0x000a, 0x371d: 0x000a,
+	0x371e: 0x000a, 0x371f: 0x000a, 0x3720: 0x000a, 0x3721: 0x000a, 0x3722: 0x000a, 0x3723: 0x000a,
+	0x3724: 0x000a, 0x3725: 0x000a, 0x3726: 0x000a, 0x3727: 0x000a, 0x3728: 0x000a, 0x3729: 0x000a,
+	0x372a: 0x000a, 0x372b: 0x000a, 0x372c: 0x000a, 0x372d: 0x000a,
+	// Block 0xdd, offset 0x3740
+	0x3740: 0x000a, 0x3741: 0x000a, 0x3742: 0x000a, 0x3743: 0x000a, 0x3744: 0x000a, 0x3745: 0x000a,
+	0x3746: 0x000a, 0x3747: 0x000a, 0x3748: 0x000a, 0x3749: 0x000a, 0x374a: 0x000a, 0x374b: 0x000a,
+	0x3750: 0x000a, 0x3751: 0x000a,
+	0x3752: 0x000a, 0x3753: 0x000a, 0x3754: 0x000a, 0x3755: 0x000a, 0x3756: 0x000a, 0x3757: 0x000a,
+	0x3758: 0x000a, 0x3759: 0x000a, 0x375a: 0x000a, 0x375b: 0x000a, 0x375c: 0x000a, 0x375d: 0x000a,
+	0x375e: 0x000a, 0x375f: 0x000a, 0x3760: 0x000a, 0x3761: 0x000a, 0x3762: 0x000a, 0x3763: 0x000a,
+	0x3764: 0x000a, 0x3765: 0x000a, 0x3766: 0x000a, 0x3767: 0x000a, 0x3768: 0x000a, 0x3769: 0x000a,
+	0x376a: 0x000a, 0x376b: 0x000a, 0x376c: 0x000a, 0x376d: 0x000a, 0x376e: 0x000a, 0x376f: 0x000a,
+	0x3770: 0x000a, 0x3771: 0x000a, 0x3772: 0x000a, 0x3773: 0x000a, 0x3774: 0x000a, 0x3775: 0x000a,
+	0x3776: 0x000a, 0x3777: 0x000a, 0x3778: 0x000a, 0x3779: 0x000a, 0x377a: 0x000a, 0x377b: 0x000a,
+	0x377c: 0x000a, 0x377d: 0x000a, 0x377e: 0x000a,
+	// Block 0xde, offset 0x3780
+	0x3780: 0x000a, 0x3781: 0x000a, 0x3782: 0x000a, 0x3783: 0x000a, 0x3784: 0x000a, 0x3785: 0x000a,
+	0x3786: 0x000a, 0x3787: 0x000a, 0x3788: 0x000a, 0x3789: 0x000a, 0x378a: 0x000a, 0x378b: 0x000a,
+	0x378c: 0x000a, 0x3790: 0x000a, 0x3791: 0x000a,
+	0x3792: 0x000a, 0x3793: 0x000a, 0x3794: 0x000a, 0x3795: 0x000a, 0x3796: 0x000a, 0x3797: 0x000a,
+	0x3798: 0x000a, 0x3799: 0x000a, 0x379a: 0x000a, 0x379b: 0x000a, 0x379c: 0x000a, 0x379d: 0x000a,
+	0x379e: 0x000a, 0x379f: 0x000a, 0x37a0: 0x000a, 0x37a1: 0x000a, 0x37a2: 0x000a, 0x37a3: 0x000a,
+	0x37a4: 0x000a, 0x37a5: 0x000a, 0x37a6: 0x000a, 0x37a7: 0x000a, 0x37a8: 0x000a, 0x37a9: 0x000a,
+	0x37aa: 0x000a, 0x37ab: 0x000a,
+	// Block 0xdf, offset 0x37c0
+	0x37c0: 0x000a, 0x37c1: 0x000a, 0x37c2: 0x000a, 0x37c3: 0x000a, 0x37c4: 0x000a, 0x37c5: 0x000a,
+	0x37c6: 0x000a, 0x37c7: 0x000a, 0x37c8: 0x000a, 0x37c9: 0x000a, 0x37ca: 0x000a, 0x37cb: 0x000a,
+	0x37cc: 0x000a, 0x37cd: 0x000a, 0x37ce: 0x000a, 0x37cf: 0x000a, 0x37d0: 0x000a, 0x37d1: 0x000a,
+	0x37d2: 0x000a, 0x37d3: 0x000a, 0x37d4: 0x000a, 0x37d5: 0x000a, 0x37d6: 0x000a, 0x37d7: 0x000a,
+	// Block 0xe0, offset 0x3800
+	0x3800: 0x000a,
+	0x3810: 0x000a, 0x3811: 0x000a,
+	0x3812: 0x000a, 0x3813: 0x000a, 0x3814: 0x000a, 0x3815: 0x000a, 0x3816: 0x000a, 0x3817: 0x000a,
+	0x3818: 0x000a, 0x3819: 0x000a, 0x381a: 0x000a, 0x381b: 0x000a, 0x381c: 0x000a, 0x381d: 0x000a,
+	0x381e: 0x000a, 0x381f: 0x000a, 0x3820: 0x000a, 0x3821: 0x000a, 0x3822: 0x000a, 0x3823: 0x000a,
+	0x3824: 0x000a, 0x3825: 0x000a, 0x3826: 0x000a,
+	// Block 0xe1, offset 0x3840
+	0x387e: 0x000b, 0x387f: 0x000b,
+	// Block 0xe2, offset 0x3880
+	0x3880: 0x000b, 0x3881: 0x000b, 0x3882: 0x000b, 0x3883: 0x000b, 0x3884: 0x000b, 0x3885: 0x000b,
+	0x3886: 0x000b, 0x3887: 0x000b, 0x3888: 0x000b, 0x3889: 0x000b, 0x388a: 0x000b, 0x388b: 0x000b,
+	0x388c: 0x000b, 0x388d: 0x000b, 0x388e: 0x000b, 0x388f: 0x000b, 0x3890: 0x000b, 0x3891: 0x000b,
+	0x3892: 0x000b, 0x3893: 0x000b, 0x3894: 0x000b, 0x3895: 0x000b, 0x3896: 0x000b, 0x3897: 0x000b,
+	0x3898: 0x000b, 0x3899: 0x000b, 0x389a: 0x000b, 0x389b: 0x000b, 0x389c: 0x000b, 0x389d: 0x000b,
+	0x389e: 0x000b, 0x389f: 0x000b, 0x38a0: 0x000b, 0x38a1: 0x000b, 0x38a2: 0x000b, 0x38a3: 0x000b,
+	0x38a4: 0x000b, 0x38a5: 0x000b, 0x38a6: 0x000b, 0x38a7: 0x000b, 0x38a8: 0x000b, 0x38a9: 0x000b,
+	0x38aa: 0x000b, 0x38ab: 0x000b, 0x38ac: 0x000b, 0x38ad: 0x000b, 0x38ae: 0x000b, 0x38af: 0x000b,
+	0x38b0: 0x000b, 0x38b1: 0x000b, 0x38b2: 0x000b, 0x38b3: 0x000b, 0x38b4: 0x000b, 0x38b5: 0x000b,
+	0x38b6: 0x000b, 0x38b7: 0x000b, 0x38b8: 0x000b, 0x38b9: 0x000b, 0x38ba: 0x000b, 0x38bb: 0x000b,
+	0x38bc: 0x000b, 0x38bd: 0x000b, 0x38be: 0x000b, 0x38bf: 0x000b,
+	// Block 0xe3, offset 0x38c0
+	0x38c0: 0x000c, 0x38c1: 0x000c, 0x38c2: 0x000c, 0x38c3: 0x000c, 0x38c4: 0x000c, 0x38c5: 0x000c,
+	0x38c6: 0x000c, 0x38c7: 0x000c, 0x38c8: 0x000c, 0x38c9: 0x000c, 0x38ca: 0x000c, 0x38cb: 0x000c,
+	0x38cc: 0x000c, 0x38cd: 0x000c, 0x38ce: 0x000c, 0x38cf: 0x000c, 0x38d0: 0x000c, 0x38d1: 0x000c,
+	0x38d2: 0x000c, 0x38d3: 0x000c, 0x38d4: 0x000c, 0x38d5: 0x000c, 0x38d6: 0x000c, 0x38d7: 0x000c,
+	0x38d8: 0x000c, 0x38d9: 0x000c, 0x38da: 0x000c, 0x38db: 0x000c, 0x38dc: 0x000c, 0x38dd: 0x000c,
+	0x38de: 0x000c, 0x38df: 0x000c, 0x38e0: 0x000c, 0x38e1: 0x000c, 0x38e2: 0x000c, 0x38e3: 0x000c,
+	0x38e4: 0x000c, 0x38e5: 0x000c, 0x38e6: 0x000c, 0x38e7: 0x000c, 0x38e8: 0x000c, 0x38e9: 0x000c,
+	0x38ea: 0x000c, 0x38eb: 0x000c, 0x38ec: 0x000c, 0x38ed: 0x000c, 0x38ee: 0x000c, 0x38ef: 0x000c,
+	0x38f0: 0x000b, 0x38f1: 0x000b, 0x38f2: 0x000b, 0x38f3: 0x000b, 0x38f4: 0x000b, 0x38f5: 0x000b,
+	0x38f6: 0x000b, 0x38f7: 0x000b, 0x38f8: 0x000b, 0x38f9: 0x000b, 0x38fa: 0x000b, 0x38fb: 0x000b,
+	0x38fc: 0x000b, 0x38fd: 0x000b, 0x38fe: 0x000b, 0x38ff: 0x000b,
+}
+
+// bidiIndex: 24 blocks, 1536 entries, 1536 bytes
+// Block 0 is the zero block.
+var bidiIndex = [1536]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x01, 0xc3: 0x02,
+	0xca: 0x03, 0xcb: 0x04, 0xcc: 0x05, 0xcd: 0x06, 0xce: 0x07, 0xcf: 0x08,
+	0xd2: 0x09, 0xd6: 0x0a, 0xd7: 0x0b,
+	0xd8: 0x0c, 0xd9: 0x0d, 0xda: 0x0e, 0xdb: 0x0f, 0xdc: 0x10, 0xdd: 0x11, 0xde: 0x12, 0xdf: 0x13,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06,
+	0xea: 0x07, 0xef: 0x08,
+	0xf0: 0x11, 0xf1: 0x12, 0xf2: 0x12, 0xf3: 0x14, 0xf4: 0x15,
+	// Block 0x4, offset 0x100
+	0x120: 0x14, 0x121: 0x15, 0x122: 0x16, 0x123: 0x17, 0x124: 0x18, 0x125: 0x19, 0x126: 0x1a, 0x127: 0x1b,
+	0x128: 0x1c, 0x129: 0x1d, 0x12a: 0x1c, 0x12b: 0x1e, 0x12c: 0x1f, 0x12d: 0x20, 0x12e: 0x21, 0x12f: 0x22,
+	0x130: 0x23, 0x131: 0x24, 0x132: 0x1a, 0x133: 0x25, 0x134: 0x26, 0x135: 0x27, 0x137: 0x28,
+	0x138: 0x29, 0x139: 0x2a, 0x13a: 0x2b, 0x13b: 0x2c, 0x13c: 0x2d, 0x13d: 0x2e, 0x13e: 0x2f, 0x13f: 0x30,
+	// Block 0x5, offset 0x140
+	0x140: 0x31, 0x141: 0x32, 0x142: 0x33,
+	0x14d: 0x34, 0x14e: 0x35,
+	0x150: 0x36,
+	0x15a: 0x37, 0x15c: 0x38, 0x15d: 0x39, 0x15e: 0x3a, 0x15f: 0x3b,
+	0x160: 0x3c, 0x162: 0x3d, 0x164: 0x3e, 0x165: 0x3f, 0x167: 0x40,
+	0x168: 0x41, 0x169: 0x42, 0x16a: 0x43, 0x16c: 0x44, 0x16d: 0x45, 0x16e: 0x46, 0x16f: 0x47,
+	0x170: 0x48, 0x173: 0x49, 0x177: 0x4a,
+	0x17e: 0x4b, 0x17f: 0x4c,
+	// Block 0x6, offset 0x180
+	0x180: 0x4d, 0x181: 0x4e, 0x182: 0x4f, 0x183: 0x50, 0x184: 0x51, 0x185: 0x52, 0x186: 0x53, 0x187: 0x54,
+	0x188: 0x55, 0x189: 0x54, 0x18a: 0x54, 0x18b: 0x54, 0x18c: 0x56, 0x18d: 0x57, 0x18e: 0x58, 0x18f: 0x54,
+	0x190: 0x59, 0x191: 0x5a, 0x192: 0x5b, 0x193: 0x5c, 0x194: 0x54, 0x195: 0x54, 0x196: 0x54, 0x197: 0x54,
+	0x198: 0x54, 0x199: 0x54, 0x19a: 0x5d, 0x19b: 0x54, 0x19c: 0x54, 0x19d: 0x5e, 0x19e: 0x54, 0x19f: 0x5f,
+	0x1a4: 0x54, 0x1a5: 0x54, 0x1a6: 0x60, 0x1a7: 0x61,
+	0x1a8: 0x54, 0x1a9: 0x54, 0x1aa: 0x54, 0x1ab: 0x54, 0x1ac: 0x54, 0x1ad: 0x62, 0x1ae: 0x63, 0x1af: 0x64,
+	0x1b3: 0x65, 0x1b5: 0x66, 0x1b7: 0x67,
+	0x1b8: 0x68, 0x1b9: 0x69, 0x1ba: 0x6a, 0x1bb: 0x6b, 0x1bc: 0x54, 0x1bd: 0x54, 0x1be: 0x54, 0x1bf: 0x6c,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x6d, 0x1c2: 0x6e, 0x1c3: 0x6f, 0x1c7: 0x70,
+	0x1c8: 0x71, 0x1c9: 0x72, 0x1ca: 0x73, 0x1cb: 0x74, 0x1cd: 0x75, 0x1cf: 0x76,
+	// Block 0x8, offset 0x200
+	0x237: 0x54,
+	// Block 0x9, offset 0x240
+	0x252: 0x77, 0x253: 0x78,
+	0x258: 0x79, 0x259: 0x7a, 0x25a: 0x7b, 0x25b: 0x7c, 0x25c: 0x7d, 0x25e: 0x7e,
+	0x260: 0x7f, 0x261: 0x80, 0x263: 0x81, 0x264: 0x82, 0x265: 0x83, 0x266: 0x84, 0x267: 0x85,
+	0x268: 0x86, 0x269: 0x87, 0x26a: 0x88, 0x26b: 0x89, 0x26f: 0x8a,
+	// Block 0xa, offset 0x280
+	0x2ac: 0x8b, 0x2ad: 0x8c, 0x2ae: 0x0e, 0x2af: 0x0e,
+	0x2b0: 0x0e, 0x2b1: 0x0e, 0x2b2: 0x0e, 0x2b3: 0x0e, 0x2b4: 0x8d, 0x2b5: 0x0e, 0x2b6: 0x0e, 0x2b7: 0x8e,
+	0x2b8: 0x8f, 0x2b9: 0x90, 0x2ba: 0x0e, 0x2bb: 0x91, 0x2bc: 0x92, 0x2bd: 0x93, 0x2bf: 0x94,
+	// Block 0xb, offset 0x2c0
+	0x2c4: 0x95, 0x2c5: 0x54, 0x2c6: 0x96, 0x2c7: 0x97,
+	0x2cb: 0x98, 0x2cd: 0x99,
+	0x2e0: 0x9a, 0x2e1: 0x9a, 0x2e2: 0x9a, 0x2e3: 0x9a, 0x2e4: 0x9b, 0x2e5: 0x9a, 0x2e6: 0x9a, 0x2e7: 0x9a,
+	0x2e8: 0x9c, 0x2e9: 0x9a, 0x2ea: 0x9a, 0x2eb: 0x9d, 0x2ec: 0x9e, 0x2ed: 0x9a, 0x2ee: 0x9a, 0x2ef: 0x9a,
+	0x2f0: 0x9a, 0x2f1: 0x9a, 0x2f2: 0x9a, 0x2f3: 0x9a, 0x2f4: 0x9a, 0x2f5: 0x9a, 0x2f6: 0x9a, 0x2f7: 0x9a,
+	0x2f8: 0x9a, 0x2f9: 0x9f, 0x2fa: 0x9a, 0x2fb: 0x9a, 0x2fc: 0x9a, 0x2fd: 0x9a, 0x2fe: 0x9a, 0x2ff: 0x9a,
+	// Block 0xc, offset 0x300
+	0x300: 0xa0, 0x301: 0xa1, 0x302: 0xa2, 0x304: 0xa3, 0x305: 0xa4, 0x306: 0xa5, 0x307: 0xa6,
+	0x308: 0xa7, 0x30b: 0xa8, 0x30c: 0xa9, 0x30d: 0xaa,
+	0x310: 0xab, 0x311: 0xac, 0x312: 0xad, 0x313: 0xae, 0x316: 0xaf, 0x317: 0xb0,
+	0x318: 0xb1, 0x319: 0xb2, 0x31a: 0xb3, 0x31c: 0xb4,
+	0x328: 0xb5, 0x329: 0xb6, 0x32a: 0xb7,
+	0x330: 0xb8, 0x332: 0xb9, 0x334: 0xba, 0x335: 0xbb,
+	// Block 0xd, offset 0x340
+	0x36b: 0xbc, 0x36c: 0xbd,
+	0x37e: 0xbe,
+	// Block 0xe, offset 0x380
+	0x3b2: 0xbf,
+	// Block 0xf, offset 0x3c0
+	0x3c5: 0xc0, 0x3c6: 0xc1,
+	0x3c8: 0x54, 0x3c9: 0xc2, 0x3cc: 0x54, 0x3cd: 0xc3,
+	0x3db: 0xc4, 0x3dc: 0xc5, 0x3dd: 0xc6, 0x3de: 0xc7, 0x3df: 0xc8,
+	0x3e8: 0xc9, 0x3e9: 0xca, 0x3ea: 0xcb,
+	// Block 0x10, offset 0x400
+	0x400: 0xcc,
+	0x420: 0x9a, 0x421: 0x9a, 0x422: 0x9a, 0x423: 0xcd, 0x424: 0x9a, 0x425: 0xce, 0x426: 0x9a, 0x427: 0x9a,
+	0x428: 0x9a, 0x429: 0x9a, 0x42a: 0x9a, 0x42b: 0x9a, 0x42c: 0x9a, 0x42d: 0x9a, 0x42e: 0x9a, 0x42f: 0x9a,
+	0x430: 0x9a, 0x431: 0x9a, 0x432: 0x9a, 0x433: 0x9a, 0x434: 0x9a, 0x435: 0x9a, 0x436: 0x9a, 0x437: 0x9a,
+	0x438: 0x0e, 0x439: 0x0e, 0x43a: 0x0e, 0x43b: 0xcf, 0x43c: 0x9a, 0x43d: 0x9a, 0x43e: 0x9a, 0x43f: 0x9a,
+	// Block 0x11, offset 0x440
+	0x440: 0xd0, 0x441: 0x54, 0x442: 0xd1, 0x443: 0xd2, 0x444: 0xd3, 0x445: 0xd4,
+	0x449: 0xd5, 0x44c: 0x54, 0x44d: 0x54, 0x44e: 0x54, 0x44f: 0x54,
+	0x450: 0x54, 0x451: 0x54, 0x452: 0x54, 0x453: 0x54, 0x454: 0x54, 0x455: 0x54, 0x456: 0x54, 0x457: 0x54,
+	0x458: 0x54, 0x459: 0x54, 0x45a: 0x54, 0x45b: 0xd6, 0x45c: 0x54, 0x45d: 0x6b, 0x45e: 0x54, 0x45f: 0xd7,
+	0x460: 0xd8, 0x461: 0xd9, 0x462: 0xda, 0x464: 0xdb, 0x465: 0xdc, 0x466: 0xdd, 0x467: 0xde,
+	0x47f: 0xdf,
+	// Block 0x12, offset 0x480
+	0x4bf: 0xdf,
+	// Block 0x13, offset 0x4c0
+	0x4d0: 0x09, 0x4d1: 0x0a, 0x4d6: 0x0b,
+	0x4db: 0x0c, 0x4dd: 0x0d, 0x4de: 0x0e, 0x4df: 0x0f,
+	0x4ef: 0x10,
+	0x4ff: 0x10,
+	// Block 0x14, offset 0x500
+	0x50f: 0x10,
+	0x51f: 0x10,
+	0x52f: 0x10,
+	0x53f: 0x10,
+	// Block 0x15, offset 0x540
+	0x540: 0xe0, 0x541: 0xe0, 0x542: 0xe0, 0x543: 0xe0, 0x544: 0x05, 0x545: 0x05, 0x546: 0x05, 0x547: 0xe1,
+	0x548: 0xe0, 0x549: 0xe0, 0x54a: 0xe0, 0x54b: 0xe0, 0x54c: 0xe0, 0x54d: 0xe0, 0x54e: 0xe0, 0x54f: 0xe0,
+	0x550: 0xe0, 0x551: 0xe0, 0x552: 0xe0, 0x553: 0xe0, 0x554: 0xe0, 0x555: 0xe0, 0x556: 0xe0, 0x557: 0xe0,
+	0x558: 0xe0, 0x559: 0xe0, 0x55a: 0xe0, 0x55b: 0xe0, 0x55c: 0xe0, 0x55d: 0xe0, 0x55e: 0xe0, 0x55f: 0xe0,
+	0x560: 0xe0, 0x561: 0xe0, 0x562: 0xe0, 0x563: 0xe0, 0x564: 0xe0, 0x565: 0xe0, 0x566: 0xe0, 0x567: 0xe0,
+	0x568: 0xe0, 0x569: 0xe0, 0x56a: 0xe0, 0x56b: 0xe0, 0x56c: 0xe0, 0x56d: 0xe0, 0x56e: 0xe0, 0x56f: 0xe0,
+	0x570: 0xe0, 0x571: 0xe0, 0x572: 0xe0, 0x573: 0xe0, 0x574: 0xe0, 0x575: 0xe0, 0x576: 0xe0, 0x577: 0xe0,
+	0x578: 0xe0, 0x579: 0xe0, 0x57a: 0xe0, 0x57b: 0xe0, 0x57c: 0xe0, 0x57d: 0xe0, 0x57e: 0xe0, 0x57f: 0xe0,
+	// Block 0x16, offset 0x580
+	0x58f: 0x10,
+	0x59f: 0x10,
+	0x5a0: 0x13,
+	0x5af: 0x10,
+	0x5bf: 0x10,
+	// Block 0x17, offset 0x5c0
+	0x5cf: 0x10,
+}
+
+// Total table size 16184 bytes (15KiB); checksum: F50EF68C
diff --git a/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go b/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go
new file mode 100644
index 0000000000..0ca0193ebe
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/tables9.0.0.go
@@ -0,0 +1,1781 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// +build !go1.10
+
+package bidi
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "9.0.0"
+
+// xorMasks contains masks to be xor-ed with brackets to get the reverse
+// version.
+var xorMasks = []int32{ // 8 elements
+	0, 1, 6, 7, 3, 15, 29, 63,
+} // Size: 56 bytes
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *bidiTrie) lookup(s []byte) (v uint8, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return bidiValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *bidiTrie) lookupUnsafe(s []byte) uint8 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return bidiValues[c0]
+	}
+	i := bidiIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *bidiTrie) lookupString(s string) (v uint8, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return bidiValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := bidiIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = bidiIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = bidiIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *bidiTrie) lookupStringUnsafe(s string) uint8 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return bidiValues[c0]
+	}
+	i := bidiIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = bidiIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// bidiTrie. Total size: 15744 bytes (15.38 KiB). Checksum: b4c3b70954803b86.
+type bidiTrie struct{}
+
+func newBidiTrie(i int) *bidiTrie {
+	return &bidiTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *bidiTrie) lookupValue(n uint32, b byte) uint8 {
+	switch {
+	default:
+		return uint8(bidiValues[n<<6+uint32(b)])
+	}
+}
+
+// bidiValues: 222 blocks, 14208 entries, 14208 bytes
+// The third block is the zero block.
+var bidiValues = [14208]uint8{
+	// Block 0x0, offset 0x0
+	0x00: 0x000b, 0x01: 0x000b, 0x02: 0x000b, 0x03: 0x000b, 0x04: 0x000b, 0x05: 0x000b,
+	0x06: 0x000b, 0x07: 0x000b, 0x08: 0x000b, 0x09: 0x0008, 0x0a: 0x0007, 0x0b: 0x0008,
+	0x0c: 0x0009, 0x0d: 0x0007, 0x0e: 0x000b, 0x0f: 0x000b, 0x10: 0x000b, 0x11: 0x000b,
+	0x12: 0x000b, 0x13: 0x000b, 0x14: 0x000b, 0x15: 0x000b, 0x16: 0x000b, 0x17: 0x000b,
+	0x18: 0x000b, 0x19: 0x000b, 0x1a: 0x000b, 0x1b: 0x000b, 0x1c: 0x0007, 0x1d: 0x0007,
+	0x1e: 0x0007, 0x1f: 0x0008, 0x20: 0x0009, 0x21: 0x000a, 0x22: 0x000a, 0x23: 0x0004,
+	0x24: 0x0004, 0x25: 0x0004, 0x26: 0x000a, 0x27: 0x000a, 0x28: 0x003a, 0x29: 0x002a,
+	0x2a: 0x000a, 0x2b: 0x0003, 0x2c: 0x0006, 0x2d: 0x0003, 0x2e: 0x0006, 0x2f: 0x0006,
+	0x30: 0x0002, 0x31: 0x0002, 0x32: 0x0002, 0x33: 0x0002, 0x34: 0x0002, 0x35: 0x0002,
+	0x36: 0x0002, 0x37: 0x0002, 0x38: 0x0002, 0x39: 0x0002, 0x3a: 0x0006, 0x3b: 0x000a,
+	0x3c: 0x000a, 0x3d: 0x000a, 0x3e: 0x000a, 0x3f: 0x000a,
+	// Block 0x1, offset 0x40
+	0x40: 0x000a,
+	0x5b: 0x005a, 0x5c: 0x000a, 0x5d: 0x004a,
+	0x5e: 0x000a, 0x5f: 0x000a, 0x60: 0x000a,
+	0x7b: 0x005a,
+	0x7c: 0x000a, 0x7d: 0x004a, 0x7e: 0x000a, 0x7f: 0x000b,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x000b, 0xc1: 0x000b, 0xc2: 0x000b, 0xc3: 0x000b, 0xc4: 0x000b, 0xc5: 0x0007,
+	0xc6: 0x000b, 0xc7: 0x000b, 0xc8: 0x000b, 0xc9: 0x000b, 0xca: 0x000b, 0xcb: 0x000b,
+	0xcc: 0x000b, 0xcd: 0x000b, 0xce: 0x000b, 0xcf: 0x000b, 0xd0: 0x000b, 0xd1: 0x000b,
+	0xd2: 0x000b, 0xd3: 0x000b, 0xd4: 0x000b, 0xd5: 0x000b, 0xd6: 0x000b, 0xd7: 0x000b,
+	0xd8: 0x000b, 0xd9: 0x000b, 0xda: 0x000b, 0xdb: 0x000b, 0xdc: 0x000b, 0xdd: 0x000b,
+	0xde: 0x000b, 0xdf: 0x000b, 0xe0: 0x0006, 0xe1: 0x000a, 0xe2: 0x0004, 0xe3: 0x0004,
+	0xe4: 0x0004, 0xe5: 0x0004, 0xe6: 0x000a, 0xe7: 0x000a, 0xe8: 0x000a, 0xe9: 0x000a,
+	0xeb: 0x000a, 0xec: 0x000a, 0xed: 0x000b, 0xee: 0x000a, 0xef: 0x000a,
+	0xf0: 0x0004, 0xf1: 0x0004, 0xf2: 0x0002, 0xf3: 0x0002, 0xf4: 0x000a,
+	0xf6: 0x000a, 0xf7: 0x000a, 0xf8: 0x000a, 0xf9: 0x0002, 0xfb: 0x000a,
+	0xfc: 0x000a, 0xfd: 0x000a, 0xfe: 0x000a, 0xff: 0x000a,
+	// Block 0x4, offset 0x100
+	0x117: 0x000a,
+	0x137: 0x000a,
+	// Block 0x5, offset 0x140
+	0x179: 0x000a, 0x17a: 0x000a,
+	// Block 0x6, offset 0x180
+	0x182: 0x000a, 0x183: 0x000a, 0x184: 0x000a, 0x185: 0x000a,
+	0x186: 0x000a, 0x187: 0x000a, 0x188: 0x000a, 0x189: 0x000a, 0x18a: 0x000a, 0x18b: 0x000a,
+	0x18c: 0x000a, 0x18d: 0x000a, 0x18e: 0x000a, 0x18f: 0x000a,
+	0x192: 0x000a, 0x193: 0x000a, 0x194: 0x000a, 0x195: 0x000a, 0x196: 0x000a, 0x197: 0x000a,
+	0x198: 0x000a, 0x199: 0x000a, 0x19a: 0x000a, 0x19b: 0x000a, 0x19c: 0x000a, 0x19d: 0x000a,
+	0x19e: 0x000a, 0x19f: 0x000a,
+	0x1a5: 0x000a, 0x1a6: 0x000a, 0x1a7: 0x000a, 0x1a8: 0x000a, 0x1a9: 0x000a,
+	0x1aa: 0x000a, 0x1ab: 0x000a, 0x1ac: 0x000a, 0x1ad: 0x000a, 0x1af: 0x000a,
+	0x1b0: 0x000a, 0x1b1: 0x000a, 0x1b2: 0x000a, 0x1b3: 0x000a, 0x1b4: 0x000a, 0x1b5: 0x000a,
+	0x1b6: 0x000a, 0x1b7: 0x000a, 0x1b8: 0x000a, 0x1b9: 0x000a, 0x1ba: 0x000a, 0x1bb: 0x000a,
+	0x1bc: 0x000a, 0x1bd: 0x000a, 0x1be: 0x000a, 0x1bf: 0x000a,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x000c, 0x1c1: 0x000c, 0x1c2: 0x000c, 0x1c3: 0x000c, 0x1c4: 0x000c, 0x1c5: 0x000c,
+	0x1c6: 0x000c, 0x1c7: 0x000c, 0x1c8: 0x000c, 0x1c9: 0x000c, 0x1ca: 0x000c, 0x1cb: 0x000c,
+	0x1cc: 0x000c, 0x1cd: 0x000c, 0x1ce: 0x000c, 0x1cf: 0x000c, 0x1d0: 0x000c, 0x1d1: 0x000c,
+	0x1d2: 0x000c, 0x1d3: 0x000c, 0x1d4: 0x000c, 0x1d5: 0x000c, 0x1d6: 0x000c, 0x1d7: 0x000c,
+	0x1d8: 0x000c, 0x1d9: 0x000c, 0x1da: 0x000c, 0x1db: 0x000c, 0x1dc: 0x000c, 0x1dd: 0x000c,
+	0x1de: 0x000c, 0x1df: 0x000c, 0x1e0: 0x000c, 0x1e1: 0x000c, 0x1e2: 0x000c, 0x1e3: 0x000c,
+	0x1e4: 0x000c, 0x1e5: 0x000c, 0x1e6: 0x000c, 0x1e7: 0x000c, 0x1e8: 0x000c, 0x1e9: 0x000c,
+	0x1ea: 0x000c, 0x1eb: 0x000c, 0x1ec: 0x000c, 0x1ed: 0x000c, 0x1ee: 0x000c, 0x1ef: 0x000c,
+	0x1f0: 0x000c, 0x1f1: 0x000c, 0x1f2: 0x000c, 0x1f3: 0x000c, 0x1f4: 0x000c, 0x1f5: 0x000c,
+	0x1f6: 0x000c, 0x1f7: 0x000c, 0x1f8: 0x000c, 0x1f9: 0x000c, 0x1fa: 0x000c, 0x1fb: 0x000c,
+	0x1fc: 0x000c, 0x1fd: 0x000c, 0x1fe: 0x000c, 0x1ff: 0x000c,
+	// Block 0x8, offset 0x200
+	0x200: 0x000c, 0x201: 0x000c, 0x202: 0x000c, 0x203: 0x000c, 0x204: 0x000c, 0x205: 0x000c,
+	0x206: 0x000c, 0x207: 0x000c, 0x208: 0x000c, 0x209: 0x000c, 0x20a: 0x000c, 0x20b: 0x000c,
+	0x20c: 0x000c, 0x20d: 0x000c, 0x20e: 0x000c, 0x20f: 0x000c, 0x210: 0x000c, 0x211: 0x000c,
+	0x212: 0x000c, 0x213: 0x000c, 0x214: 0x000c, 0x215: 0x000c, 0x216: 0x000c, 0x217: 0x000c,
+	0x218: 0x000c, 0x219: 0x000c, 0x21a: 0x000c, 0x21b: 0x000c, 0x21c: 0x000c, 0x21d: 0x000c,
+	0x21e: 0x000c, 0x21f: 0x000c, 0x220: 0x000c, 0x221: 0x000c, 0x222: 0x000c, 0x223: 0x000c,
+	0x224: 0x000c, 0x225: 0x000c, 0x226: 0x000c, 0x227: 0x000c, 0x228: 0x000c, 0x229: 0x000c,
+	0x22a: 0x000c, 0x22b: 0x000c, 0x22c: 0x000c, 0x22d: 0x000c, 0x22e: 0x000c, 0x22f: 0x000c,
+	0x234: 0x000a, 0x235: 0x000a,
+	0x23e: 0x000a,
+	// Block 0x9, offset 0x240
+	0x244: 0x000a, 0x245: 0x000a,
+	0x247: 0x000a,
+	// Block 0xa, offset 0x280
+	0x2b6: 0x000a,
+	// Block 0xb, offset 0x2c0
+	0x2c3: 0x000c, 0x2c4: 0x000c, 0x2c5: 0x000c,
+	0x2c6: 0x000c, 0x2c7: 0x000c, 0x2c8: 0x000c, 0x2c9: 0x000c,
+	// Block 0xc, offset 0x300
+	0x30a: 0x000a,
+	0x30d: 0x000a, 0x30e: 0x000a, 0x30f: 0x0004, 0x310: 0x0001, 0x311: 0x000c,
+	0x312: 0x000c, 0x313: 0x000c, 0x314: 0x000c, 0x315: 0x000c, 0x316: 0x000c, 0x317: 0x000c,
+	0x318: 0x000c, 0x319: 0x000c, 0x31a: 0x000c, 0x31b: 0x000c, 0x31c: 0x000c, 0x31d: 0x000c,
+	0x31e: 0x000c, 0x31f: 0x000c, 0x320: 0x000c, 0x321: 0x000c, 0x322: 0x000c, 0x323: 0x000c,
+	0x324: 0x000c, 0x325: 0x000c, 0x326: 0x000c, 0x327: 0x000c, 0x328: 0x000c, 0x329: 0x000c,
+	0x32a: 0x000c, 0x32b: 0x000c, 0x32c: 0x000c, 0x32d: 0x000c, 0x32e: 0x000c, 0x32f: 0x000c,
+	0x330: 0x000c, 0x331: 0x000c, 0x332: 0x000c, 0x333: 0x000c, 0x334: 0x000c, 0x335: 0x000c,
+	0x336: 0x000c, 0x337: 0x000c, 0x338: 0x000c, 0x339: 0x000c, 0x33a: 0x000c, 0x33b: 0x000c,
+	0x33c: 0x000c, 0x33d: 0x000c, 0x33e: 0x0001, 0x33f: 0x000c,
+	// Block 0xd, offset 0x340
+	0x340: 0x0001, 0x341: 0x000c, 0x342: 0x000c, 0x343: 0x0001, 0x344: 0x000c, 0x345: 0x000c,
+	0x346: 0x0001, 0x347: 0x000c, 0x348: 0x0001, 0x349: 0x0001, 0x34a: 0x0001, 0x34b: 0x0001,
+	0x34c: 0x0001, 0x34d: 0x0001, 0x34e: 0x0001, 0x34f: 0x0001, 0x350: 0x0001, 0x351: 0x0001,
+	0x352: 0x0001, 0x353: 0x0001, 0x354: 0x0001, 0x355: 0x0001, 0x356: 0x0001, 0x357: 0x0001,
+	0x358: 0x0001, 0x359: 0x0001, 0x35a: 0x0001, 0x35b: 0x0001, 0x35c: 0x0001, 0x35d: 0x0001,
+	0x35e: 0x0001, 0x35f: 0x0001, 0x360: 0x0001, 0x361: 0x0001, 0x362: 0x0001, 0x363: 0x0001,
+	0x364: 0x0001, 0x365: 0x0001, 0x366: 0x0001, 0x367: 0x0001, 0x368: 0x0001, 0x369: 0x0001,
+	0x36a: 0x0001, 0x36b: 0x0001, 0x36c: 0x0001, 0x36d: 0x0001, 0x36e: 0x0001, 0x36f: 0x0001,
+	0x370: 0x0001, 0x371: 0x0001, 0x372: 0x0001, 0x373: 0x0001, 0x374: 0x0001, 0x375: 0x0001,
+	0x376: 0x0001, 0x377: 0x0001, 0x378: 0x0001, 0x379: 0x0001, 0x37a: 0x0001, 0x37b: 0x0001,
+	0x37c: 0x0001, 0x37d: 0x0001, 0x37e: 0x0001, 0x37f: 0x0001,
+	// Block 0xe, offset 0x380
+	0x380: 0x0005, 0x381: 0x0005, 0x382: 0x0005, 0x383: 0x0005, 0x384: 0x0005, 0x385: 0x0005,
+	0x386: 0x000a, 0x387: 0x000a, 0x388: 0x000d, 0x389: 0x0004, 0x38a: 0x0004, 0x38b: 0x000d,
+	0x38c: 0x0006, 0x38d: 0x000d, 0x38e: 0x000a, 0x38f: 0x000a, 0x390: 0x000c, 0x391: 0x000c,
+	0x392: 0x000c, 0x393: 0x000c, 0x394: 0x000c, 0x395: 0x000c, 0x396: 0x000c, 0x397: 0x000c,
+	0x398: 0x000c, 0x399: 0x000c, 0x39a: 0x000c, 0x39b: 0x000d, 0x39c: 0x000d, 0x39d: 0x000d,
+	0x39e: 0x000d, 0x39f: 0x000d, 0x3a0: 0x000d, 0x3a1: 0x000d, 0x3a2: 0x000d, 0x3a3: 0x000d,
+	0x3a4: 0x000d, 0x3a5: 0x000d, 0x3a6: 0x000d, 0x3a7: 0x000d, 0x3a8: 0x000d, 0x3a9: 0x000d,
+	0x3aa: 0x000d, 0x3ab: 0x000d, 0x3ac: 0x000d, 0x3ad: 0x000d, 0x3ae: 0x000d, 0x3af: 0x000d,
+	0x3b0: 0x000d, 0x3b1: 0x000d, 0x3b2: 0x000d, 0x3b3: 0x000d, 0x3b4: 0x000d, 0x3b5: 0x000d,
+	0x3b6: 0x000d, 0x3b7: 0x000d, 0x3b8: 0x000d, 0x3b9: 0x000d, 0x3ba: 0x000d, 0x3bb: 0x000d,
+	0x3bc: 0x000d, 0x3bd: 0x000d, 0x3be: 0x000d, 0x3bf: 0x000d,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x000d, 0x3c1: 0x000d, 0x3c2: 0x000d, 0x3c3: 0x000d, 0x3c4: 0x000d, 0x3c5: 0x000d,
+	0x3c6: 0x000d, 0x3c7: 0x000d, 0x3c8: 0x000d, 0x3c9: 0x000d, 0x3ca: 0x000d, 0x3cb: 0x000c,
+	0x3cc: 0x000c, 0x3cd: 0x000c, 0x3ce: 0x000c, 0x3cf: 0x000c, 0x3d0: 0x000c, 0x3d1: 0x000c,
+	0x3d2: 0x000c, 0x3d3: 0x000c, 0x3d4: 0x000c, 0x3d5: 0x000c, 0x3d6: 0x000c, 0x3d7: 0x000c,
+	0x3d8: 0x000c, 0x3d9: 0x000c, 0x3da: 0x000c, 0x3db: 0x000c, 0x3dc: 0x000c, 0x3dd: 0x000c,
+	0x3de: 0x000c, 0x3df: 0x000c, 0x3e0: 0x0005, 0x3e1: 0x0005, 0x3e2: 0x0005, 0x3e3: 0x0005,
+	0x3e4: 0x0005, 0x3e5: 0x0005, 0x3e6: 0x0005, 0x3e7: 0x0005, 0x3e8: 0x0005, 0x3e9: 0x0005,
+	0x3ea: 0x0004, 0x3eb: 0x0005, 0x3ec: 0x0005, 0x3ed: 0x000d, 0x3ee: 0x000d, 0x3ef: 0x000d,
+	0x3f0: 0x000c, 0x3f1: 0x000d, 0x3f2: 0x000d, 0x3f3: 0x000d, 0x3f4: 0x000d, 0x3f5: 0x000d,
+	0x3f6: 0x000d, 0x3f7: 0x000d, 0x3f8: 0x000d, 0x3f9: 0x000d, 0x3fa: 0x000d, 0x3fb: 0x000d,
+	0x3fc: 0x000d, 0x3fd: 0x000d, 0x3fe: 0x000d, 0x3ff: 0x000d,
+	// Block 0x10, offset 0x400
+	0x400: 0x000d, 0x401: 0x000d, 0x402: 0x000d, 0x403: 0x000d, 0x404: 0x000d, 0x405: 0x000d,
+	0x406: 0x000d, 0x407: 0x000d, 0x408: 0x000d, 0x409: 0x000d, 0x40a: 0x000d, 0x40b: 0x000d,
+	0x40c: 0x000d, 0x40d: 0x000d, 0x40e: 0x000d, 0x40f: 0x000d, 0x410: 0x000d, 0x411: 0x000d,
+	0x412: 0x000d, 0x413: 0x000d, 0x414: 0x000d, 0x415: 0x000d, 0x416: 0x000d, 0x417: 0x000d,
+	0x418: 0x000d, 0x419: 0x000d, 0x41a: 0x000d, 0x41b: 0x000d, 0x41c: 0x000d, 0x41d: 0x000d,
+	0x41e: 0x000d, 0x41f: 0x000d, 0x420: 0x000d, 0x421: 0x000d, 0x422: 0x000d, 0x423: 0x000d,
+	0x424: 0x000d, 0x425: 0x000d, 0x426: 0x000d, 0x427: 0x000d, 0x428: 0x000d, 0x429: 0x000d,
+	0x42a: 0x000d, 0x42b: 0x000d, 0x42c: 0x000d, 0x42d: 0x000d, 0x42e: 0x000d, 0x42f: 0x000d,
+	0x430: 0x000d, 0x431: 0x000d, 0x432: 0x000d, 0x433: 0x000d, 0x434: 0x000d, 0x435: 0x000d,
+	0x436: 0x000d, 0x437: 0x000d, 0x438: 0x000d, 0x439: 0x000d, 0x43a: 0x000d, 0x43b: 0x000d,
+	0x43c: 0x000d, 0x43d: 0x000d, 0x43e: 0x000d, 0x43f: 0x000d,
+	// Block 0x11, offset 0x440
+	0x440: 0x000d, 0x441: 0x000d, 0x442: 0x000d, 0x443: 0x000d, 0x444: 0x000d, 0x445: 0x000d,
+	0x446: 0x000d, 0x447: 0x000d, 0x448: 0x000d, 0x449: 0x000d, 0x44a: 0x000d, 0x44b: 0x000d,
+	0x44c: 0x000d, 0x44d: 0x000d, 0x44e: 0x000d, 0x44f: 0x000d, 0x450: 0x000d, 0x451: 0x000d,
+	0x452: 0x000d, 0x453: 0x000d, 0x454: 0x000d, 0x455: 0x000d, 0x456: 0x000c, 0x457: 0x000c,
+	0x458: 0x000c, 0x459: 0x000c, 0x45a: 0x000c, 0x45b: 0x000c, 0x45c: 0x000c, 0x45d: 0x0005,
+	0x45e: 0x000a, 0x45f: 0x000c, 0x460: 0x000c, 0x461: 0x000c, 0x462: 0x000c, 0x463: 0x000c,
+	0x464: 0x000c, 0x465: 0x000d, 0x466: 0x000d, 0x467: 0x000c, 0x468: 0x000c, 0x469: 0x000a,
+	0x46a: 0x000c, 0x46b: 0x000c, 0x46c: 0x000c, 0x46d: 0x000c, 0x46e: 0x000d, 0x46f: 0x000d,
+	0x470: 0x0002, 0x471: 0x0002, 0x472: 0x0002, 0x473: 0x0002, 0x474: 0x0002, 0x475: 0x0002,
+	0x476: 0x0002, 0x477: 0x0002, 0x478: 0x0002, 0x479: 0x0002, 0x47a: 0x000d, 0x47b: 0x000d,
+	0x47c: 0x000d, 0x47d: 0x000d, 0x47e: 0x000d, 0x47f: 0x000d,
+	// Block 0x12, offset 0x480
+	0x480: 0x000d, 0x481: 0x000d, 0x482: 0x000d, 0x483: 0x000d, 0x484: 0x000d, 0x485: 0x000d,
+	0x486: 0x000d, 0x487: 0x000d, 0x488: 0x000d, 0x489: 0x000d, 0x48a: 0x000d, 0x48b: 0x000d,
+	0x48c: 0x000d, 0x48d: 0x000d, 0x48e: 0x000d, 0x48f: 0x000d, 0x490: 0x000d, 0x491: 0x000c,
+	0x492: 0x000d, 0x493: 0x000d, 0x494: 0x000d, 0x495: 0x000d, 0x496: 0x000d, 0x497: 0x000d,
+	0x498: 0x000d, 0x499: 0x000d, 0x49a: 0x000d, 0x49b: 0x000d, 0x49c: 0x000d, 0x49d: 0x000d,
+	0x49e: 0x000d, 0x49f: 0x000d, 0x4a0: 0x000d, 0x4a1: 0x000d, 0x4a2: 0x000d, 0x4a3: 0x000d,
+	0x4a4: 0x000d, 0x4a5: 0x000d, 0x4a6: 0x000d, 0x4a7: 0x000d, 0x4a8: 0x000d, 0x4a9: 0x000d,
+	0x4aa: 0x000d, 0x4ab: 0x000d, 0x4ac: 0x000d, 0x4ad: 0x000d, 0x4ae: 0x000d, 0x4af: 0x000d,
+	0x4b0: 0x000c, 0x4b1: 0x000c, 0x4b2: 0x000c, 0x4b3: 0x000c, 0x4b4: 0x000c, 0x4b5: 0x000c,
+	0x4b6: 0x000c, 0x4b7: 0x000c, 0x4b8: 0x000c, 0x4b9: 0x000c, 0x4ba: 0x000c, 0x4bb: 0x000c,
+	0x4bc: 0x000c, 0x4bd: 0x000c, 0x4be: 0x000c, 0x4bf: 0x000c,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x000c, 0x4c1: 0x000c, 0x4c2: 0x000c, 0x4c3: 0x000c, 0x4c4: 0x000c, 0x4c5: 0x000c,
+	0x4c6: 0x000c, 0x4c7: 0x000c, 0x4c8: 0x000c, 0x4c9: 0x000c, 0x4ca: 0x000c, 0x4cb: 0x000d,
+	0x4cc: 0x000d, 0x4cd: 0x000d, 0x4ce: 0x000d, 0x4cf: 0x000d, 0x4d0: 0x000d, 0x4d1: 0x000d,
+	0x4d2: 0x000d, 0x4d3: 0x000d, 0x4d4: 0x000d, 0x4d5: 0x000d, 0x4d6: 0x000d, 0x4d7: 0x000d,
+	0x4d8: 0x000d, 0x4d9: 0x000d, 0x4da: 0x000d, 0x4db: 0x000d, 0x4dc: 0x000d, 0x4dd: 0x000d,
+	0x4de: 0x000d, 0x4df: 0x000d, 0x4e0: 0x000d, 0x4e1: 0x000d, 0x4e2: 0x000d, 0x4e3: 0x000d,
+	0x4e4: 0x000d, 0x4e5: 0x000d, 0x4e6: 0x000d, 0x4e7: 0x000d, 0x4e8: 0x000d, 0x4e9: 0x000d,
+	0x4ea: 0x000d, 0x4eb: 0x000d, 0x4ec: 0x000d, 0x4ed: 0x000d, 0x4ee: 0x000d, 0x4ef: 0x000d,
+	0x4f0: 0x000d, 0x4f1: 0x000d, 0x4f2: 0x000d, 0x4f3: 0x000d, 0x4f4: 0x000d, 0x4f5: 0x000d,
+	0x4f6: 0x000d, 0x4f7: 0x000d, 0x4f8: 0x000d, 0x4f9: 0x000d, 0x4fa: 0x000d, 0x4fb: 0x000d,
+	0x4fc: 0x000d, 0x4fd: 0x000d, 0x4fe: 0x000d, 0x4ff: 0x000d,
+	// Block 0x14, offset 0x500
+	0x500: 0x000d, 0x501: 0x000d, 0x502: 0x000d, 0x503: 0x000d, 0x504: 0x000d, 0x505: 0x000d,
+	0x506: 0x000d, 0x507: 0x000d, 0x508: 0x000d, 0x509: 0x000d, 0x50a: 0x000d, 0x50b: 0x000d,
+	0x50c: 0x000d, 0x50d: 0x000d, 0x50e: 0x000d, 0x50f: 0x000d, 0x510: 0x000d, 0x511: 0x000d,
+	0x512: 0x000d, 0x513: 0x000d, 0x514: 0x000d, 0x515: 0x000d, 0x516: 0x000d, 0x517: 0x000d,
+	0x518: 0x000d, 0x519: 0x000d, 0x51a: 0x000d, 0x51b: 0x000d, 0x51c: 0x000d, 0x51d: 0x000d,
+	0x51e: 0x000d, 0x51f: 0x000d, 0x520: 0x000d, 0x521: 0x000d, 0x522: 0x000d, 0x523: 0x000d,
+	0x524: 0x000d, 0x525: 0x000d, 0x526: 0x000c, 0x527: 0x000c, 0x528: 0x000c, 0x529: 0x000c,
+	0x52a: 0x000c, 0x52b: 0x000c, 0x52c: 0x000c, 0x52d: 0x000c, 0x52e: 0x000c, 0x52f: 0x000c,
+	0x530: 0x000c, 0x531: 0x000d, 0x532: 0x000d, 0x533: 0x000d, 0x534: 0x000d, 0x535: 0x000d,
+	0x536: 0x000d, 0x537: 0x000d, 0x538: 0x000d, 0x539: 0x000d, 0x53a: 0x000d, 0x53b: 0x000d,
+	0x53c: 0x000d, 0x53d: 0x000d, 0x53e: 0x000d, 0x53f: 0x000d,
+	// Block 0x15, offset 0x540
+	0x540: 0x0001, 0x541: 0x0001, 0x542: 0x0001, 0x543: 0x0001, 0x544: 0x0001, 0x545: 0x0001,
+	0x546: 0x0001, 0x547: 0x0001, 0x548: 0x0001, 0x549: 0x0001, 0x54a: 0x0001, 0x54b: 0x0001,
+	0x54c: 0x0001, 0x54d: 0x0001, 0x54e: 0x0001, 0x54f: 0x0001, 0x550: 0x0001, 0x551: 0x0001,
+	0x552: 0x0001, 0x553: 0x0001, 0x554: 0x0001, 0x555: 0x0001, 0x556: 0x0001, 0x557: 0x0001,
+	0x558: 0x0001, 0x559: 0x0001, 0x55a: 0x0001, 0x55b: 0x0001, 0x55c: 0x0001, 0x55d: 0x0001,
+	0x55e: 0x0001, 0x55f: 0x0001, 0x560: 0x0001, 0x561: 0x0001, 0x562: 0x0001, 0x563: 0x0001,
+	0x564: 0x0001, 0x565: 0x0001, 0x566: 0x0001, 0x567: 0x0001, 0x568: 0x0001, 0x569: 0x0001,
+	0x56a: 0x0001, 0x56b: 0x000c, 0x56c: 0x000c, 0x56d: 0x000c, 0x56e: 0x000c, 0x56f: 0x000c,
+	0x570: 0x000c, 0x571: 0x000c, 0x572: 0x000c, 0x573: 0x000c, 0x574: 0x0001, 0x575: 0x0001,
+	0x576: 0x000a, 0x577: 0x000a, 0x578: 0x000a, 0x579: 0x000a, 0x57a: 0x0001, 0x57b: 0x0001,
+	0x57c: 0x0001, 0x57d: 0x0001, 0x57e: 0x0001, 0x57f: 0x0001,
+	// Block 0x16, offset 0x580
+	0x580: 0x0001, 0x581: 0x0001, 0x582: 0x0001, 0x583: 0x0001, 0x584: 0x0001, 0x585: 0x0001,
+	0x586: 0x0001, 0x587: 0x0001, 0x588: 0x0001, 0x589: 0x0001, 0x58a: 0x0001, 0x58b: 0x0001,
+	0x58c: 0x0001, 0x58d: 0x0001, 0x58e: 0x0001, 0x58f: 0x0001, 0x590: 0x0001, 0x591: 0x0001,
+	0x592: 0x0001, 0x593: 0x0001, 0x594: 0x0001, 0x595: 0x0001, 0x596: 0x000c, 0x597: 0x000c,
+	0x598: 0x000c, 0x599: 0x000c, 0x59a: 0x0001, 0x59b: 0x000c, 0x59c: 0x000c, 0x59d: 0x000c,
+	0x59e: 0x000c, 0x59f: 0x000c, 0x5a0: 0x000c, 0x5a1: 0x000c, 0x5a2: 0x000c, 0x5a3: 0x000c,
+	0x5a4: 0x0001, 0x5a5: 0x000c, 0x5a6: 0x000c, 0x5a7: 0x000c, 0x5a8: 0x0001, 0x5a9: 0x000c,
+	0x5aa: 0x000c, 0x5ab: 0x000c, 0x5ac: 0x000c, 0x5ad: 0x000c, 0x5ae: 0x0001, 0x5af: 0x0001,
+	0x5b0: 0x0001, 0x5b1: 0x0001, 0x5b2: 0x0001, 0x5b3: 0x0001, 0x5b4: 0x0001, 0x5b5: 0x0001,
+	0x5b6: 0x0001, 0x5b7: 0x0001, 0x5b8: 0x0001, 0x5b9: 0x0001, 0x5ba: 0x0001, 0x5bb: 0x0001,
+	0x5bc: 0x0001, 0x5bd: 0x0001, 0x5be: 0x0001, 0x5bf: 0x0001,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x0001, 0x5c1: 0x0001, 0x5c2: 0x0001, 0x5c3: 0x0001, 0x5c4: 0x0001, 0x5c5: 0x0001,
+	0x5c6: 0x0001, 0x5c7: 0x0001, 0x5c8: 0x0001, 0x5c9: 0x0001, 0x5ca: 0x0001, 0x5cb: 0x0001,
+	0x5cc: 0x0001, 0x5cd: 0x0001, 0x5ce: 0x0001, 0x5cf: 0x0001, 0x5d0: 0x0001, 0x5d1: 0x0001,
+	0x5d2: 0x0001, 0x5d3: 0x0001, 0x5d4: 0x0001, 0x5d5: 0x0001, 0x5d6: 0x0001, 0x5d7: 0x0001,
+	0x5d8: 0x0001, 0x5d9: 0x000c, 0x5da: 0x000c, 0x5db: 0x000c, 0x5dc: 0x0001, 0x5dd: 0x0001,
+	0x5de: 0x0001, 0x5df: 0x0001, 0x5e0: 0x0001, 0x5e1: 0x0001, 0x5e2: 0x0001, 0x5e3: 0x0001,
+	0x5e4: 0x0001, 0x5e5: 0x0001, 0x5e6: 0x0001, 0x5e7: 0x0001, 0x5e8: 0x0001, 0x5e9: 0x0001,
+	0x5ea: 0x0001, 0x5eb: 0x0001, 0x5ec: 0x0001, 0x5ed: 0x0001, 0x5ee: 0x0001, 0x5ef: 0x0001,
+	0x5f0: 0x0001, 0x5f1: 0x0001, 0x5f2: 0x0001, 0x5f3: 0x0001, 0x5f4: 0x0001, 0x5f5: 0x0001,
+	0x5f6: 0x0001, 0x5f7: 0x0001, 0x5f8: 0x0001, 0x5f9: 0x0001, 0x5fa: 0x0001, 0x5fb: 0x0001,
+	0x5fc: 0x0001, 0x5fd: 0x0001, 0x5fe: 0x0001, 0x5ff: 0x0001,
+	// Block 0x18, offset 0x600
+	0x600: 0x0001, 0x601: 0x0001, 0x602: 0x0001, 0x603: 0x0001, 0x604: 0x0001, 0x605: 0x0001,
+	0x606: 0x0001, 0x607: 0x0001, 0x608: 0x0001, 0x609: 0x0001, 0x60a: 0x0001, 0x60b: 0x0001,
+	0x60c: 0x0001, 0x60d: 0x0001, 0x60e: 0x0001, 0x60f: 0x0001, 0x610: 0x0001, 0x611: 0x0001,
+	0x612: 0x0001, 0x613: 0x0001, 0x614: 0x0001, 0x615: 0x0001, 0x616: 0x0001, 0x617: 0x0001,
+	0x618: 0x0001, 0x619: 0x0001, 0x61a: 0x0001, 0x61b: 0x0001, 0x61c: 0x0001, 0x61d: 0x0001,
+	0x61e: 0x0001, 0x61f: 0x0001, 0x620: 0x000d, 0x621: 0x000d, 0x622: 0x000d, 0x623: 0x000d,
+	0x624: 0x000d, 0x625: 0x000d, 0x626: 0x000d, 0x627: 0x000d, 0x628: 0x000d, 0x629: 0x000d,
+	0x62a: 0x000d, 0x62b: 0x000d, 0x62c: 0x000d, 0x62d: 0x000d, 0x62e: 0x000d, 0x62f: 0x000d,
+	0x630: 0x000d, 0x631: 0x000d, 0x632: 0x000d, 0x633: 0x000d, 0x634: 0x000d, 0x635: 0x000d,
+	0x636: 0x000d, 0x637: 0x000d, 0x638: 0x000d, 0x639: 0x000d, 0x63a: 0x000d, 0x63b: 0x000d,
+	0x63c: 0x000d, 0x63d: 0x000d, 0x63e: 0x000d, 0x63f: 0x000d,
+	// Block 0x19, offset 0x640
+	0x640: 0x000d, 0x641: 0x000d, 0x642: 0x000d, 0x643: 0x000d, 0x644: 0x000d, 0x645: 0x000d,
+	0x646: 0x000d, 0x647: 0x000d, 0x648: 0x000d, 0x649: 0x000d, 0x64a: 0x000d, 0x64b: 0x000d,
+	0x64c: 0x000d, 0x64d: 0x000d, 0x64e: 0x000d, 0x64f: 0x000d, 0x650: 0x000d, 0x651: 0x000d,
+	0x652: 0x000d, 0x653: 0x000d, 0x654: 0x000c, 0x655: 0x000c, 0x656: 0x000c, 0x657: 0x000c,
+	0x658: 0x000c, 0x659: 0x000c, 0x65a: 0x000c, 0x65b: 0x000c, 0x65c: 0x000c, 0x65d: 0x000c,
+	0x65e: 0x000c, 0x65f: 0x000c, 0x660: 0x000c, 0x661: 0x000c, 0x662: 0x0005, 0x663: 0x000c,
+	0x664: 0x000c, 0x665: 0x000c, 0x666: 0x000c, 0x667: 0x000c, 0x668: 0x000c, 0x669: 0x000c,
+	0x66a: 0x000c, 0x66b: 0x000c, 0x66c: 0x000c, 0x66d: 0x000c, 0x66e: 0x000c, 0x66f: 0x000c,
+	0x670: 0x000c, 0x671: 0x000c, 0x672: 0x000c, 0x673: 0x000c, 0x674: 0x000c, 0x675: 0x000c,
+	0x676: 0x000c, 0x677: 0x000c, 0x678: 0x000c, 0x679: 0x000c, 0x67a: 0x000c, 0x67b: 0x000c,
+	0x67c: 0x000c, 0x67d: 0x000c, 0x67e: 0x000c, 0x67f: 0x000c,
+	// Block 0x1a, offset 0x680
+	0x680: 0x000c, 0x681: 0x000c, 0x682: 0x000c,
+	0x6ba: 0x000c,
+	0x6bc: 0x000c,
+	// Block 0x1b, offset 0x6c0
+	0x6c1: 0x000c, 0x6c2: 0x000c, 0x6c3: 0x000c, 0x6c4: 0x000c, 0x6c5: 0x000c,
+	0x6c6: 0x000c, 0x6c7: 0x000c, 0x6c8: 0x000c,
+	0x6cd: 0x000c, 0x6d1: 0x000c,
+	0x6d2: 0x000c, 0x6d3: 0x000c, 0x6d4: 0x000c, 0x6d5: 0x000c, 0x6d6: 0x000c, 0x6d7: 0x000c,
+	0x6e2: 0x000c, 0x6e3: 0x000c,
+	// Block 0x1c, offset 0x700
+	0x701: 0x000c,
+	0x73c: 0x000c,
+	// Block 0x1d, offset 0x740
+	0x741: 0x000c, 0x742: 0x000c, 0x743: 0x000c, 0x744: 0x000c,
+	0x74d: 0x000c,
+	0x762: 0x000c, 0x763: 0x000c,
+	0x772: 0x0004, 0x773: 0x0004,
+	0x77b: 0x0004,
+	// Block 0x1e, offset 0x780
+	0x781: 0x000c, 0x782: 0x000c,
+	0x7bc: 0x000c,
+	// Block 0x1f, offset 0x7c0
+	0x7c1: 0x000c, 0x7c2: 0x000c,
+	0x7c7: 0x000c, 0x7c8: 0x000c, 0x7cb: 0x000c,
+	0x7cc: 0x000c, 0x7cd: 0x000c, 0x7d1: 0x000c,
+	0x7f0: 0x000c, 0x7f1: 0x000c, 0x7f5: 0x000c,
+	// Block 0x20, offset 0x800
+	0x801: 0x000c, 0x802: 0x000c, 0x803: 0x000c, 0x804: 0x000c, 0x805: 0x000c,
+	0x807: 0x000c, 0x808: 0x000c,
+	0x80d: 0x000c,
+	0x822: 0x000c, 0x823: 0x000c,
+	0x831: 0x0004,
+	// Block 0x21, offset 0x840
+	0x841: 0x000c,
+	0x87c: 0x000c, 0x87f: 0x000c,
+	// Block 0x22, offset 0x880
+	0x881: 0x000c, 0x882: 0x000c, 0x883: 0x000c, 0x884: 0x000c,
+	0x88d: 0x000c,
+	0x896: 0x000c,
+	0x8a2: 0x000c, 0x8a3: 0x000c,
+	// Block 0x23, offset 0x8c0
+	0x8c2: 0x000c,
+	// Block 0x24, offset 0x900
+	0x900: 0x000c,
+	0x90d: 0x000c,
+	0x933: 0x000a, 0x934: 0x000a, 0x935: 0x000a,
+	0x936: 0x000a, 0x937: 0x000a, 0x938: 0x000a, 0x939: 0x0004, 0x93a: 0x000a,
+	// Block 0x25, offset 0x940
+	0x940: 0x000c,
+	0x97e: 0x000c, 0x97f: 0x000c,
+	// Block 0x26, offset 0x980
+	0x980: 0x000c,
+	0x986: 0x000c, 0x987: 0x000c, 0x988: 0x000c, 0x98a: 0x000c, 0x98b: 0x000c,
+	0x98c: 0x000c, 0x98d: 0x000c,
+	0x995: 0x000c, 0x996: 0x000c,
+	0x9a2: 0x000c, 0x9a3: 0x000c,
+	0x9b8: 0x000a, 0x9b9: 0x000a, 0x9ba: 0x000a, 0x9bb: 0x000a,
+	0x9bc: 0x000a, 0x9bd: 0x000a, 0x9be: 0x000a,
+	// Block 0x27, offset 0x9c0
+	0x9cc: 0x000c, 0x9cd: 0x000c,
+	0x9e2: 0x000c, 0x9e3: 0x000c,
+	// Block 0x28, offset 0xa00
+	0xa01: 0x000c,
+	// Block 0x29, offset 0xa40
+	0xa41: 0x000c, 0xa42: 0x000c, 0xa43: 0x000c, 0xa44: 0x000c,
+	0xa4d: 0x000c,
+	0xa62: 0x000c, 0xa63: 0x000c,
+	// Block 0x2a, offset 0xa80
+	0xa8a: 0x000c,
+	0xa92: 0x000c, 0xa93: 0x000c, 0xa94: 0x000c, 0xa96: 0x000c,
+	// Block 0x2b, offset 0xac0
+	0xaf1: 0x000c, 0xaf4: 0x000c, 0xaf5: 0x000c,
+	0xaf6: 0x000c, 0xaf7: 0x000c, 0xaf8: 0x000c, 0xaf9: 0x000c, 0xafa: 0x000c,
+	0xaff: 0x0004,
+	// Block 0x2c, offset 0xb00
+	0xb07: 0x000c, 0xb08: 0x000c, 0xb09: 0x000c, 0xb0a: 0x000c, 0xb0b: 0x000c,
+	0xb0c: 0x000c, 0xb0d: 0x000c, 0xb0e: 0x000c,
+	// Block 0x2d, offset 0xb40
+	0xb71: 0x000c, 0xb74: 0x000c, 0xb75: 0x000c,
+	0xb76: 0x000c, 0xb77: 0x000c, 0xb78: 0x000c, 0xb79: 0x000c, 0xb7b: 0x000c,
+	0xb7c: 0x000c,
+	// Block 0x2e, offset 0xb80
+	0xb88: 0x000c, 0xb89: 0x000c, 0xb8a: 0x000c, 0xb8b: 0x000c,
+	0xb8c: 0x000c, 0xb8d: 0x000c,
+	// Block 0x2f, offset 0xbc0
+	0xbd8: 0x000c, 0xbd9: 0x000c,
+	0xbf5: 0x000c,
+	0xbf7: 0x000c, 0xbf9: 0x000c, 0xbfa: 0x003a, 0xbfb: 0x002a,
+	0xbfc: 0x003a, 0xbfd: 0x002a,
+	// Block 0x30, offset 0xc00
+	0xc31: 0x000c, 0xc32: 0x000c, 0xc33: 0x000c, 0xc34: 0x000c, 0xc35: 0x000c,
+	0xc36: 0x000c, 0xc37: 0x000c, 0xc38: 0x000c, 0xc39: 0x000c, 0xc3a: 0x000c, 0xc3b: 0x000c,
+	0xc3c: 0x000c, 0xc3d: 0x000c, 0xc3e: 0x000c,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x000c, 0xc41: 0x000c, 0xc42: 0x000c, 0xc43: 0x000c, 0xc44: 0x000c,
+	0xc46: 0x000c, 0xc47: 0x000c,
+	0xc4d: 0x000c, 0xc4e: 0x000c, 0xc4f: 0x000c, 0xc50: 0x000c, 0xc51: 0x000c,
+	0xc52: 0x000c, 0xc53: 0x000c, 0xc54: 0x000c, 0xc55: 0x000c, 0xc56: 0x000c, 0xc57: 0x000c,
+	0xc59: 0x000c, 0xc5a: 0x000c, 0xc5b: 0x000c, 0xc5c: 0x000c, 0xc5d: 0x000c,
+	0xc5e: 0x000c, 0xc5f: 0x000c, 0xc60: 0x000c, 0xc61: 0x000c, 0xc62: 0x000c, 0xc63: 0x000c,
+	0xc64: 0x000c, 0xc65: 0x000c, 0xc66: 0x000c, 0xc67: 0x000c, 0xc68: 0x000c, 0xc69: 0x000c,
+	0xc6a: 0x000c, 0xc6b: 0x000c, 0xc6c: 0x000c, 0xc6d: 0x000c, 0xc6e: 0x000c, 0xc6f: 0x000c,
+	0xc70: 0x000c, 0xc71: 0x000c, 0xc72: 0x000c, 0xc73: 0x000c, 0xc74: 0x000c, 0xc75: 0x000c,
+	0xc76: 0x000c, 0xc77: 0x000c, 0xc78: 0x000c, 0xc79: 0x000c, 0xc7a: 0x000c, 0xc7b: 0x000c,
+	0xc7c: 0x000c,
+	// Block 0x32, offset 0xc80
+	0xc86: 0x000c,
+	// Block 0x33, offset 0xcc0
+	0xced: 0x000c, 0xcee: 0x000c, 0xcef: 0x000c,
+	0xcf0: 0x000c, 0xcf2: 0x000c, 0xcf3: 0x000c, 0xcf4: 0x000c, 0xcf5: 0x000c,
+	0xcf6: 0x000c, 0xcf7: 0x000c, 0xcf9: 0x000c, 0xcfa: 0x000c,
+	0xcfd: 0x000c, 0xcfe: 0x000c,
+	// Block 0x34, offset 0xd00
+	0xd18: 0x000c, 0xd19: 0x000c,
+	0xd1e: 0x000c, 0xd1f: 0x000c, 0xd20: 0x000c,
+	0xd31: 0x000c, 0xd32: 0x000c, 0xd33: 0x000c, 0xd34: 0x000c,
+	// Block 0x35, offset 0xd40
+	0xd42: 0x000c, 0xd45: 0x000c,
+	0xd46: 0x000c,
+	0xd4d: 0x000c,
+	0xd5d: 0x000c,
+	// Block 0x36, offset 0xd80
+	0xd9d: 0x000c,
+	0xd9e: 0x000c, 0xd9f: 0x000c,
+	// Block 0x37, offset 0xdc0
+	0xdd0: 0x000a, 0xdd1: 0x000a,
+	0xdd2: 0x000a, 0xdd3: 0x000a, 0xdd4: 0x000a, 0xdd5: 0x000a, 0xdd6: 0x000a, 0xdd7: 0x000a,
+	0xdd8: 0x000a, 0xdd9: 0x000a,
+	// Block 0x38, offset 0xe00
+	0xe00: 0x000a,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x0009,
+	0xe5b: 0x007a, 0xe5c: 0x006a,
+	// Block 0x3a, offset 0xe80
+	0xe92: 0x000c, 0xe93: 0x000c, 0xe94: 0x000c,
+	0xeb2: 0x000c, 0xeb3: 0x000c, 0xeb4: 0x000c,
+	// Block 0x3b, offset 0xec0
+	0xed2: 0x000c, 0xed3: 0x000c,
+	0xef2: 0x000c, 0xef3: 0x000c,
+	// Block 0x3c, offset 0xf00
+	0xf34: 0x000c, 0xf35: 0x000c,
+	0xf37: 0x000c, 0xf38: 0x000c, 0xf39: 0x000c, 0xf3a: 0x000c, 0xf3b: 0x000c,
+	0xf3c: 0x000c, 0xf3d: 0x000c,
+	// Block 0x3d, offset 0xf40
+	0xf46: 0x000c, 0xf49: 0x000c, 0xf4a: 0x000c, 0xf4b: 0x000c,
+	0xf4c: 0x000c, 0xf4d: 0x000c, 0xf4e: 0x000c, 0xf4f: 0x000c, 0xf50: 0x000c, 0xf51: 0x000c,
+	0xf52: 0x000c, 0xf53: 0x000c,
+	0xf5b: 0x0004, 0xf5d: 0x000c,
+	0xf70: 0x000a, 0xf71: 0x000a, 0xf72: 0x000a, 0xf73: 0x000a, 0xf74: 0x000a, 0xf75: 0x000a,
+	0xf76: 0x000a, 0xf77: 0x000a, 0xf78: 0x000a, 0xf79: 0x000a,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x000a, 0xf81: 0x000a, 0xf82: 0x000a, 0xf83: 0x000a, 0xf84: 0x000a, 0xf85: 0x000a,
+	0xf86: 0x000a, 0xf87: 0x000a, 0xf88: 0x000a, 0xf89: 0x000a, 0xf8a: 0x000a, 0xf8b: 0x000c,
+	0xf8c: 0x000c, 0xf8d: 0x000c, 0xf8e: 0x000b,
+	// Block 0x3f, offset 0xfc0
+	0xfc5: 0x000c,
+	0xfc6: 0x000c,
+	0xfe9: 0x000c,
+	// Block 0x40, offset 0x1000
+	0x1020: 0x000c, 0x1021: 0x000c, 0x1022: 0x000c,
+	0x1027: 0x000c, 0x1028: 0x000c,
+	0x1032: 0x000c,
+	0x1039: 0x000c, 0x103a: 0x000c, 0x103b: 0x000c,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x000a, 0x1044: 0x000a, 0x1045: 0x000a,
+	// Block 0x42, offset 0x1080
+	0x109e: 0x000a, 0x109f: 0x000a, 0x10a0: 0x000a, 0x10a1: 0x000a, 0x10a2: 0x000a, 0x10a3: 0x000a,
+	0x10a4: 0x000a, 0x10a5: 0x000a, 0x10a6: 0x000a, 0x10a7: 0x000a, 0x10a8: 0x000a, 0x10a9: 0x000a,
+	0x10aa: 0x000a, 0x10ab: 0x000a, 0x10ac: 0x000a, 0x10ad: 0x000a, 0x10ae: 0x000a, 0x10af: 0x000a,
+	0x10b0: 0x000a, 0x10b1: 0x000a, 0x10b2: 0x000a, 0x10b3: 0x000a, 0x10b4: 0x000a, 0x10b5: 0x000a,
+	0x10b6: 0x000a, 0x10b7: 0x000a, 0x10b8: 0x000a, 0x10b9: 0x000a, 0x10ba: 0x000a, 0x10bb: 0x000a,
+	0x10bc: 0x000a, 0x10bd: 0x000a, 0x10be: 0x000a, 0x10bf: 0x000a,
+	// Block 0x43, offset 0x10c0
+	0x10d7: 0x000c,
+	0x10d8: 0x000c, 0x10db: 0x000c,
+	// Block 0x44, offset 0x1100
+	0x1116: 0x000c,
+	0x1118: 0x000c, 0x1119: 0x000c, 0x111a: 0x000c, 0x111b: 0x000c, 0x111c: 0x000c, 0x111d: 0x000c,
+	0x111e: 0x000c, 0x1120: 0x000c, 0x1122: 0x000c,
+	0x1125: 0x000c, 0x1126: 0x000c, 0x1127: 0x000c, 0x1128: 0x000c, 0x1129: 0x000c,
+	0x112a: 0x000c, 0x112b: 0x000c, 0x112c: 0x000c,
+	0x1133: 0x000c, 0x1134: 0x000c, 0x1135: 0x000c,
+	0x1136: 0x000c, 0x1137: 0x000c, 0x1138: 0x000c, 0x1139: 0x000c, 0x113a: 0x000c, 0x113b: 0x000c,
+	0x113c: 0x000c, 0x113f: 0x000c,
+	// Block 0x45, offset 0x1140
+	0x1170: 0x000c, 0x1171: 0x000c, 0x1172: 0x000c, 0x1173: 0x000c, 0x1174: 0x000c, 0x1175: 0x000c,
+	0x1176: 0x000c, 0x1177: 0x000c, 0x1178: 0x000c, 0x1179: 0x000c, 0x117a: 0x000c, 0x117b: 0x000c,
+	0x117c: 0x000c, 0x117d: 0x000c, 0x117e: 0x000c,
+	// Block 0x46, offset 0x1180
+	0x1180: 0x000c, 0x1181: 0x000c, 0x1182: 0x000c, 0x1183: 0x000c,
+	0x11b4: 0x000c,
+	0x11b6: 0x000c, 0x11b7: 0x000c, 0x11b8: 0x000c, 0x11b9: 0x000c, 0x11ba: 0x000c,
+	0x11bc: 0x000c,
+	// Block 0x47, offset 0x11c0
+	0x11c2: 0x000c,
+	0x11eb: 0x000c, 0x11ec: 0x000c, 0x11ed: 0x000c, 0x11ee: 0x000c, 0x11ef: 0x000c,
+	0x11f0: 0x000c, 0x11f1: 0x000c, 0x11f2: 0x000c, 0x11f3: 0x000c,
+	// Block 0x48, offset 0x1200
+	0x1200: 0x000c, 0x1201: 0x000c,
+	0x1222: 0x000c, 0x1223: 0x000c,
+	0x1224: 0x000c, 0x1225: 0x000c, 0x1228: 0x000c, 0x1229: 0x000c,
+	0x122b: 0x000c, 0x122c: 0x000c, 0x122d: 0x000c,
+	// Block 0x49, offset 0x1240
+	0x1266: 0x000c, 0x1268: 0x000c, 0x1269: 0x000c,
+	0x126d: 0x000c, 0x126f: 0x000c,
+	0x1270: 0x000c, 0x1271: 0x000c,
+	// Block 0x4a, offset 0x1280
+	0x12ac: 0x000c, 0x12ad: 0x000c, 0x12ae: 0x000c, 0x12af: 0x000c,
+	0x12b0: 0x000c, 0x12b1: 0x000c, 0x12b2: 0x000c, 0x12b3: 0x000c,
+	0x12b6: 0x000c, 0x12b7: 0x000c,
+	// Block 0x4b, offset 0x12c0
+	0x12d0: 0x000c, 0x12d1: 0x000c,
+	0x12d2: 0x000c, 0x12d4: 0x000c, 0x12d5: 0x000c, 0x12d6: 0x000c, 0x12d7: 0x000c,
+	0x12d8: 0x000c, 0x12d9: 0x000c, 0x12da: 0x000c, 0x12db: 0x000c, 0x12dc: 0x000c, 0x12dd: 0x000c,
+	0x12de: 0x000c, 0x12df: 0x000c, 0x12e0: 0x000c, 0x12e2: 0x000c, 0x12e3: 0x000c,
+	0x12e4: 0x000c, 0x12e5: 0x000c, 0x12e6: 0x000c, 0x12e7: 0x000c, 0x12e8: 0x000c,
+	0x12ed: 0x000c,
+	0x12f4: 0x000c,
+	0x12f8: 0x000c, 0x12f9: 0x000c,
+	// Block 0x4c, offset 0x1300
+	0x1300: 0x000c, 0x1301: 0x000c, 0x1302: 0x000c, 0x1303: 0x000c, 0x1304: 0x000c, 0x1305: 0x000c,
+	0x1306: 0x000c, 0x1307: 0x000c, 0x1308: 0x000c, 0x1309: 0x000c, 0x130a: 0x000c, 0x130b: 0x000c,
+	0x130c: 0x000c, 0x130d: 0x000c, 0x130e: 0x000c, 0x130f: 0x000c, 0x1310: 0x000c, 0x1311: 0x000c,
+	0x1312: 0x000c, 0x1313: 0x000c, 0x1314: 0x000c, 0x1315: 0x000c, 0x1316: 0x000c, 0x1317: 0x000c,
+	0x1318: 0x000c, 0x1319: 0x000c, 0x131a: 0x000c, 0x131b: 0x000c, 0x131c: 0x000c, 0x131d: 0x000c,
+	0x131e: 0x000c, 0x131f: 0x000c, 0x1320: 0x000c, 0x1321: 0x000c, 0x1322: 0x000c, 0x1323: 0x000c,
+	0x1324: 0x000c, 0x1325: 0x000c, 0x1326: 0x000c, 0x1327: 0x000c, 0x1328: 0x000c, 0x1329: 0x000c,
+	0x132a: 0x000c, 0x132b: 0x000c, 0x132c: 0x000c, 0x132d: 0x000c, 0x132e: 0x000c, 0x132f: 0x000c,
+	0x1330: 0x000c, 0x1331: 0x000c, 0x1332: 0x000c, 0x1333: 0x000c, 0x1334: 0x000c, 0x1335: 0x000c,
+	0x133b: 0x000c,
+	0x133c: 0x000c, 0x133d: 0x000c, 0x133e: 0x000c, 0x133f: 0x000c,
+	// Block 0x4d, offset 0x1340
+	0x137d: 0x000a, 0x137f: 0x000a,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x000a, 0x1381: 0x000a,
+	0x138d: 0x000a, 0x138e: 0x000a, 0x138f: 0x000a,
+	0x139d: 0x000a,
+	0x139e: 0x000a, 0x139f: 0x000a,
+	0x13ad: 0x000a, 0x13ae: 0x000a, 0x13af: 0x000a,
+	0x13bd: 0x000a, 0x13be: 0x000a,
+	// Block 0x4f, offset 0x13c0
+	0x13c0: 0x0009, 0x13c1: 0x0009, 0x13c2: 0x0009, 0x13c3: 0x0009, 0x13c4: 0x0009, 0x13c5: 0x0009,
+	0x13c6: 0x0009, 0x13c7: 0x0009, 0x13c8: 0x0009, 0x13c9: 0x0009, 0x13ca: 0x0009, 0x13cb: 0x000b,
+	0x13cc: 0x000b, 0x13cd: 0x000b, 0x13cf: 0x0001, 0x13d0: 0x000a, 0x13d1: 0x000a,
+	0x13d2: 0x000a, 0x13d3: 0x000a, 0x13d4: 0x000a, 0x13d5: 0x000a, 0x13d6: 0x000a, 0x13d7: 0x000a,
+	0x13d8: 0x000a, 0x13d9: 0x000a, 0x13da: 0x000a, 0x13db: 0x000a, 0x13dc: 0x000a, 0x13dd: 0x000a,
+	0x13de: 0x000a, 0x13df: 0x000a, 0x13e0: 0x000a, 0x13e1: 0x000a, 0x13e2: 0x000a, 0x13e3: 0x000a,
+	0x13e4: 0x000a, 0x13e5: 0x000a, 0x13e6: 0x000a, 0x13e7: 0x000a, 0x13e8: 0x0009, 0x13e9: 0x0007,
+	0x13ea: 0x000e, 0x13eb: 0x000e, 0x13ec: 0x000e, 0x13ed: 0x000e, 0x13ee: 0x000e, 0x13ef: 0x0006,
+	0x13f0: 0x0004, 0x13f1: 0x0004, 0x13f2: 0x0004, 0x13f3: 0x0004, 0x13f4: 0x0004, 0x13f5: 0x000a,
+	0x13f6: 0x000a, 0x13f7: 0x000a, 0x13f8: 0x000a, 0x13f9: 0x000a, 0x13fa: 0x000a, 0x13fb: 0x000a,
+	0x13fc: 0x000a, 0x13fd: 0x000a, 0x13fe: 0x000a, 0x13ff: 0x000a,
+	// Block 0x50, offset 0x1400
+	0x1400: 0x000a, 0x1401: 0x000a, 0x1402: 0x000a, 0x1403: 0x000a, 0x1404: 0x0006, 0x1405: 0x009a,
+	0x1406: 0x008a, 0x1407: 0x000a, 0x1408: 0x000a, 0x1409: 0x000a, 0x140a: 0x000a, 0x140b: 0x000a,
+	0x140c: 0x000a, 0x140d: 0x000a, 0x140e: 0x000a, 0x140f: 0x000a, 0x1410: 0x000a, 0x1411: 0x000a,
+	0x1412: 0x000a, 0x1413: 0x000a, 0x1414: 0x000a, 0x1415: 0x000a, 0x1416: 0x000a, 0x1417: 0x000a,
+	0x1418: 0x000a, 0x1419: 0x000a, 0x141a: 0x000a, 0x141b: 0x000a, 0x141c: 0x000a, 0x141d: 0x000a,
+	0x141e: 0x000a, 0x141f: 0x0009, 0x1420: 0x000b, 0x1421: 0x000b, 0x1422: 0x000b, 0x1423: 0x000b,
+	0x1424: 0x000b, 0x1425: 0x000b, 0x1426: 0x000e, 0x1427: 0x000e, 0x1428: 0x000e, 0x1429: 0x000e,
+	0x142a: 0x000b, 0x142b: 0x000b, 0x142c: 0x000b, 0x142d: 0x000b, 0x142e: 0x000b, 0x142f: 0x000b,
+	0x1430: 0x0002, 0x1434: 0x0002, 0x1435: 0x0002,
+	0x1436: 0x0002, 0x1437: 0x0002, 0x1438: 0x0002, 0x1439: 0x0002, 0x143a: 0x0003, 0x143b: 0x0003,
+	0x143c: 0x000a, 0x143d: 0x009a, 0x143e: 0x008a,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x0002, 0x1441: 0x0002, 0x1442: 0x0002, 0x1443: 0x0002, 0x1444: 0x0002, 0x1445: 0x0002,
+	0x1446: 0x0002, 0x1447: 0x0002, 0x1448: 0x0002, 0x1449: 0x0002, 0x144a: 0x0003, 0x144b: 0x0003,
+	0x144c: 0x000a, 0x144d: 0x009a, 0x144e: 0x008a,
+	0x1460: 0x0004, 0x1461: 0x0004, 0x1462: 0x0004, 0x1463: 0x0004,
+	0x1464: 0x0004, 0x1465: 0x0004, 0x1466: 0x0004, 0x1467: 0x0004, 0x1468: 0x0004, 0x1469: 0x0004,
+	0x146a: 0x0004, 0x146b: 0x0004, 0x146c: 0x0004, 0x146d: 0x0004, 0x146e: 0x0004, 0x146f: 0x0004,
+	0x1470: 0x0004, 0x1471: 0x0004, 0x1472: 0x0004, 0x1473: 0x0004, 0x1474: 0x0004, 0x1475: 0x0004,
+	0x1476: 0x0004, 0x1477: 0x0004, 0x1478: 0x0004, 0x1479: 0x0004, 0x147a: 0x0004, 0x147b: 0x0004,
+	0x147c: 0x0004, 0x147d: 0x0004, 0x147e: 0x0004, 0x147f: 0x0004,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x0004, 0x1481: 0x0004, 0x1482: 0x0004, 0x1483: 0x0004, 0x1484: 0x0004, 0x1485: 0x0004,
+	0x1486: 0x0004, 0x1487: 0x0004, 0x1488: 0x0004, 0x1489: 0x0004, 0x148a: 0x0004, 0x148b: 0x0004,
+	0x148c: 0x0004, 0x148d: 0x0004, 0x148e: 0x0004, 0x148f: 0x0004, 0x1490: 0x000c, 0x1491: 0x000c,
+	0x1492: 0x000c, 0x1493: 0x000c, 0x1494: 0x000c, 0x1495: 0x000c, 0x1496: 0x000c, 0x1497: 0x000c,
+	0x1498: 0x000c, 0x1499: 0x000c, 0x149a: 0x000c, 0x149b: 0x000c, 0x149c: 0x000c, 0x149d: 0x000c,
+	0x149e: 0x000c, 0x149f: 0x000c, 0x14a0: 0x000c, 0x14a1: 0x000c, 0x14a2: 0x000c, 0x14a3: 0x000c,
+	0x14a4: 0x000c, 0x14a5: 0x000c, 0x14a6: 0x000c, 0x14a7: 0x000c, 0x14a8: 0x000c, 0x14a9: 0x000c,
+	0x14aa: 0x000c, 0x14ab: 0x000c, 0x14ac: 0x000c, 0x14ad: 0x000c, 0x14ae: 0x000c, 0x14af: 0x000c,
+	0x14b0: 0x000c,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x000a, 0x14c1: 0x000a, 0x14c3: 0x000a, 0x14c4: 0x000a, 0x14c5: 0x000a,
+	0x14c6: 0x000a, 0x14c8: 0x000a, 0x14c9: 0x000a,
+	0x14d4: 0x000a, 0x14d6: 0x000a, 0x14d7: 0x000a,
+	0x14d8: 0x000a,
+	0x14de: 0x000a, 0x14df: 0x000a, 0x14e0: 0x000a, 0x14e1: 0x000a, 0x14e2: 0x000a, 0x14e3: 0x000a,
+	0x14e5: 0x000a, 0x14e7: 0x000a, 0x14e9: 0x000a,
+	0x14ee: 0x0004,
+	0x14fa: 0x000a, 0x14fb: 0x000a,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x000a, 0x1501: 0x000a, 0x1502: 0x000a, 0x1503: 0x000a, 0x1504: 0x000a,
+	0x150a: 0x000a, 0x150b: 0x000a,
+	0x150c: 0x000a, 0x150d: 0x000a, 0x1510: 0x000a, 0x1511: 0x000a,
+	0x1512: 0x000a, 0x1513: 0x000a, 0x1514: 0x000a, 0x1515: 0x000a, 0x1516: 0x000a, 0x1517: 0x000a,
+	0x1518: 0x000a, 0x1519: 0x000a, 0x151a: 0x000a, 0x151b: 0x000a, 0x151c: 0x000a, 0x151d: 0x000a,
+	0x151e: 0x000a, 0x151f: 0x000a,
+	// Block 0x55, offset 0x1540
+	0x1549: 0x000a, 0x154a: 0x000a, 0x154b: 0x000a,
+	0x1550: 0x000a, 0x1551: 0x000a,
+	0x1552: 0x000a, 0x1553: 0x000a, 0x1554: 0x000a, 0x1555: 0x000a, 0x1556: 0x000a, 0x1557: 0x000a,
+	0x1558: 0x000a, 0x1559: 0x000a, 0x155a: 0x000a, 0x155b: 0x000a, 0x155c: 0x000a, 0x155d: 0x000a,
+	0x155e: 0x000a, 0x155f: 0x000a, 0x1560: 0x000a, 0x1561: 0x000a, 0x1562: 0x000a, 0x1563: 0x000a,
+	0x1564: 0x000a, 0x1565: 0x000a, 0x1566: 0x000a, 0x1567: 0x000a, 0x1568: 0x000a, 0x1569: 0x000a,
+	0x156a: 0x000a, 0x156b: 0x000a, 0x156c: 0x000a, 0x156d: 0x000a, 0x156e: 0x000a, 0x156f: 0x000a,
+	0x1570: 0x000a, 0x1571: 0x000a, 0x1572: 0x000a, 0x1573: 0x000a, 0x1574: 0x000a, 0x1575: 0x000a,
+	0x1576: 0x000a, 0x1577: 0x000a, 0x1578: 0x000a, 0x1579: 0x000a, 0x157a: 0x000a, 0x157b: 0x000a,
+	0x157c: 0x000a, 0x157d: 0x000a, 0x157e: 0x000a, 0x157f: 0x000a,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x000a, 0x1581: 0x000a, 0x1582: 0x000a, 0x1583: 0x000a, 0x1584: 0x000a, 0x1585: 0x000a,
+	0x1586: 0x000a, 0x1587: 0x000a, 0x1588: 0x000a, 0x1589: 0x000a, 0x158a: 0x000a, 0x158b: 0x000a,
+	0x158c: 0x000a, 0x158d: 0x000a, 0x158e: 0x000a, 0x158f: 0x000a, 0x1590: 0x000a, 0x1591: 0x000a,
+	0x1592: 0x000a, 0x1593: 0x000a, 0x1594: 0x000a, 0x1595: 0x000a, 0x1596: 0x000a, 0x1597: 0x000a,
+	0x1598: 0x000a, 0x1599: 0x000a, 0x159a: 0x000a, 0x159b: 0x000a, 0x159c: 0x000a, 0x159d: 0x000a,
+	0x159e: 0x000a, 0x159f: 0x000a, 0x15a0: 0x000a, 0x15a1: 0x000a, 0x15a2: 0x000a, 0x15a3: 0x000a,
+	0x15a4: 0x000a, 0x15a5: 0x000a, 0x15a6: 0x000a, 0x15a7: 0x000a, 0x15a8: 0x000a, 0x15a9: 0x000a,
+	0x15aa: 0x000a, 0x15ab: 0x000a, 0x15ac: 0x000a, 0x15ad: 0x000a, 0x15ae: 0x000a, 0x15af: 0x000a,
+	0x15b0: 0x000a, 0x15b1: 0x000a, 0x15b2: 0x000a, 0x15b3: 0x000a, 0x15b4: 0x000a, 0x15b5: 0x000a,
+	0x15b6: 0x000a, 0x15b7: 0x000a, 0x15b8: 0x000a, 0x15b9: 0x000a, 0x15ba: 0x000a, 0x15bb: 0x000a,
+	0x15bc: 0x000a, 0x15bd: 0x000a, 0x15be: 0x000a, 0x15bf: 0x000a,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0x000a, 0x15c1: 0x000a, 0x15c2: 0x000a, 0x15c3: 0x000a, 0x15c4: 0x000a, 0x15c5: 0x000a,
+	0x15c6: 0x000a, 0x15c7: 0x000a, 0x15c8: 0x000a, 0x15c9: 0x000a, 0x15ca: 0x000a, 0x15cb: 0x000a,
+	0x15cc: 0x000a, 0x15cd: 0x000a, 0x15ce: 0x000a, 0x15cf: 0x000a, 0x15d0: 0x000a, 0x15d1: 0x000a,
+	0x15d2: 0x0003, 0x15d3: 0x0004, 0x15d4: 0x000a, 0x15d5: 0x000a, 0x15d6: 0x000a, 0x15d7: 0x000a,
+	0x15d8: 0x000a, 0x15d9: 0x000a, 0x15da: 0x000a, 0x15db: 0x000a, 0x15dc: 0x000a, 0x15dd: 0x000a,
+	0x15de: 0x000a, 0x15df: 0x000a, 0x15e0: 0x000a, 0x15e1: 0x000a, 0x15e2: 0x000a, 0x15e3: 0x000a,
+	0x15e4: 0x000a, 0x15e5: 0x000a, 0x15e6: 0x000a, 0x15e7: 0x000a, 0x15e8: 0x000a, 0x15e9: 0x000a,
+	0x15ea: 0x000a, 0x15eb: 0x000a, 0x15ec: 0x000a, 0x15ed: 0x000a, 0x15ee: 0x000a, 0x15ef: 0x000a,
+	0x15f0: 0x000a, 0x15f1: 0x000a, 0x15f2: 0x000a, 0x15f3: 0x000a, 0x15f4: 0x000a, 0x15f5: 0x000a,
+	0x15f6: 0x000a, 0x15f7: 0x000a, 0x15f8: 0x000a, 0x15f9: 0x000a, 0x15fa: 0x000a, 0x15fb: 0x000a,
+	0x15fc: 0x000a, 0x15fd: 0x000a, 0x15fe: 0x000a, 0x15ff: 0x000a,
+	// Block 0x58, offset 0x1600
+	0x1600: 0x000a, 0x1601: 0x000a, 0x1602: 0x000a, 0x1603: 0x000a, 0x1604: 0x000a, 0x1605: 0x000a,
+	0x1606: 0x000a, 0x1607: 0x000a, 0x1608: 0x003a, 0x1609: 0x002a, 0x160a: 0x003a, 0x160b: 0x002a,
+	0x160c: 0x000a, 0x160d: 0x000a, 0x160e: 0x000a, 0x160f: 0x000a, 0x1610: 0x000a, 0x1611: 0x000a,
+	0x1612: 0x000a, 0x1613: 0x000a, 0x1614: 0x000a, 0x1615: 0x000a, 0x1616: 0x000a, 0x1617: 0x000a,
+	0x1618: 0x000a, 0x1619: 0x000a, 0x161a: 0x000a, 0x161b: 0x000a, 0x161c: 0x000a, 0x161d: 0x000a,
+	0x161e: 0x000a, 0x161f: 0x000a, 0x1620: 0x000a, 0x1621: 0x000a, 0x1622: 0x000a, 0x1623: 0x000a,
+	0x1624: 0x000a, 0x1625: 0x000a, 0x1626: 0x000a, 0x1627: 0x000a, 0x1628: 0x000a, 0x1629: 0x009a,
+	0x162a: 0x008a, 0x162b: 0x000a, 0x162c: 0x000a, 0x162d: 0x000a, 0x162e: 0x000a, 0x162f: 0x000a,
+	0x1630: 0x000a, 0x1631: 0x000a, 0x1632: 0x000a, 0x1633: 0x000a, 0x1634: 0x000a, 0x1635: 0x000a,
+	// Block 0x59, offset 0x1640
+	0x167b: 0x000a,
+	0x167c: 0x000a, 0x167d: 0x000a, 0x167e: 0x000a, 0x167f: 0x000a,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x000a, 0x1681: 0x000a, 0x1682: 0x000a, 0x1683: 0x000a, 0x1684: 0x000a, 0x1685: 0x000a,
+	0x1686: 0x000a, 0x1687: 0x000a, 0x1688: 0x000a, 0x1689: 0x000a, 0x168a: 0x000a, 0x168b: 0x000a,
+	0x168c: 0x000a, 0x168d: 0x000a, 0x168e: 0x000a, 0x168f: 0x000a, 0x1690: 0x000a, 0x1691: 0x000a,
+	0x1692: 0x000a, 0x1693: 0x000a, 0x1694: 0x000a, 0x1696: 0x000a, 0x1697: 0x000a,
+	0x1698: 0x000a, 0x1699: 0x000a, 0x169a: 0x000a, 0x169b: 0x000a, 0x169c: 0x000a, 0x169d: 0x000a,
+	0x169e: 0x000a, 0x169f: 0x000a, 0x16a0: 0x000a, 0x16a1: 0x000a, 0x16a2: 0x000a, 0x16a3: 0x000a,
+	0x16a4: 0x000a, 0x16a5: 0x000a, 0x16a6: 0x000a, 0x16a7: 0x000a, 0x16a8: 0x000a, 0x16a9: 0x000a,
+	0x16aa: 0x000a, 0x16ab: 0x000a, 0x16ac: 0x000a, 0x16ad: 0x000a, 0x16ae: 0x000a, 0x16af: 0x000a,
+	0x16b0: 0x000a, 0x16b1: 0x000a, 0x16b2: 0x000a, 0x16b3: 0x000a, 0x16b4: 0x000a, 0x16b5: 0x000a,
+	0x16b6: 0x000a, 0x16b7: 0x000a, 0x16b8: 0x000a, 0x16b9: 0x000a, 0x16ba: 0x000a, 0x16bb: 0x000a,
+	0x16bc: 0x000a, 0x16bd: 0x000a, 0x16be: 0x000a, 0x16bf: 0x000a,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x000a, 0x16c1: 0x000a, 0x16c2: 0x000a, 0x16c3: 0x000a, 0x16c4: 0x000a, 0x16c5: 0x000a,
+	0x16c6: 0x000a, 0x16c7: 0x000a, 0x16c8: 0x000a, 0x16c9: 0x000a, 0x16ca: 0x000a, 0x16cb: 0x000a,
+	0x16cc: 0x000a, 0x16cd: 0x000a, 0x16ce: 0x000a, 0x16cf: 0x000a, 0x16d0: 0x000a, 0x16d1: 0x000a,
+	0x16d2: 0x000a, 0x16d3: 0x000a, 0x16d4: 0x000a, 0x16d5: 0x000a, 0x16d6: 0x000a, 0x16d7: 0x000a,
+	0x16d8: 0x000a, 0x16d9: 0x000a, 0x16da: 0x000a, 0x16db: 0x000a, 0x16dc: 0x000a, 0x16dd: 0x000a,
+	0x16de: 0x000a, 0x16df: 0x000a, 0x16e0: 0x000a, 0x16e1: 0x000a, 0x16e2: 0x000a, 0x16e3: 0x000a,
+	0x16e4: 0x000a, 0x16e5: 0x000a, 0x16e6: 0x000a, 0x16e7: 0x000a, 0x16e8: 0x000a, 0x16e9: 0x000a,
+	0x16ea: 0x000a, 0x16eb: 0x000a, 0x16ec: 0x000a, 0x16ed: 0x000a, 0x16ee: 0x000a, 0x16ef: 0x000a,
+	0x16f0: 0x000a, 0x16f1: 0x000a, 0x16f2: 0x000a, 0x16f3: 0x000a, 0x16f4: 0x000a, 0x16f5: 0x000a,
+	0x16f6: 0x000a, 0x16f7: 0x000a, 0x16f8: 0x000a, 0x16f9: 0x000a, 0x16fa: 0x000a, 0x16fb: 0x000a,
+	0x16fc: 0x000a, 0x16fd: 0x000a, 0x16fe: 0x000a,
+	// Block 0x5c, offset 0x1700
+	0x1700: 0x000a, 0x1701: 0x000a, 0x1702: 0x000a, 0x1703: 0x000a, 0x1704: 0x000a, 0x1705: 0x000a,
+	0x1706: 0x000a, 0x1707: 0x000a, 0x1708: 0x000a, 0x1709: 0x000a, 0x170a: 0x000a, 0x170b: 0x000a,
+	0x170c: 0x000a, 0x170d: 0x000a, 0x170e: 0x000a, 0x170f: 0x000a, 0x1710: 0x000a, 0x1711: 0x000a,
+	0x1712: 0x000a, 0x1713: 0x000a, 0x1714: 0x000a, 0x1715: 0x000a, 0x1716: 0x000a, 0x1717: 0x000a,
+	0x1718: 0x000a, 0x1719: 0x000a, 0x171a: 0x000a, 0x171b: 0x000a, 0x171c: 0x000a, 0x171d: 0x000a,
+	0x171e: 0x000a, 0x171f: 0x000a, 0x1720: 0x000a, 0x1721: 0x000a, 0x1722: 0x000a, 0x1723: 0x000a,
+	0x1724: 0x000a, 0x1725: 0x000a, 0x1726: 0x000a,
+	// Block 0x5d, offset 0x1740
+	0x1740: 0x000a, 0x1741: 0x000a, 0x1742: 0x000a, 0x1743: 0x000a, 0x1744: 0x000a, 0x1745: 0x000a,
+	0x1746: 0x000a, 0x1747: 0x000a, 0x1748: 0x000a, 0x1749: 0x000a, 0x174a: 0x000a,
+	0x1760: 0x000a, 0x1761: 0x000a, 0x1762: 0x000a, 0x1763: 0x000a,
+	0x1764: 0x000a, 0x1765: 0x000a, 0x1766: 0x000a, 0x1767: 0x000a, 0x1768: 0x000a, 0x1769: 0x000a,
+	0x176a: 0x000a, 0x176b: 0x000a, 0x176c: 0x000a, 0x176d: 0x000a, 0x176e: 0x000a, 0x176f: 0x000a,
+	0x1770: 0x000a, 0x1771: 0x000a, 0x1772: 0x000a, 0x1773: 0x000a, 0x1774: 0x000a, 0x1775: 0x000a,
+	0x1776: 0x000a, 0x1777: 0x000a, 0x1778: 0x000a, 0x1779: 0x000a, 0x177a: 0x000a, 0x177b: 0x000a,
+	0x177c: 0x000a, 0x177d: 0x000a, 0x177e: 0x000a, 0x177f: 0x000a,
+	// Block 0x5e, offset 0x1780
+	0x1780: 0x000a, 0x1781: 0x000a, 0x1782: 0x000a, 0x1783: 0x000a, 0x1784: 0x000a, 0x1785: 0x000a,
+	0x1786: 0x000a, 0x1787: 0x000a, 0x1788: 0x0002, 0x1789: 0x0002, 0x178a: 0x0002, 0x178b: 0x0002,
+	0x178c: 0x0002, 0x178d: 0x0002, 0x178e: 0x0002, 0x178f: 0x0002, 0x1790: 0x0002, 0x1791: 0x0002,
+	0x1792: 0x0002, 0x1793: 0x0002, 0x1794: 0x0002, 0x1795: 0x0002, 0x1796: 0x0002, 0x1797: 0x0002,
+	0x1798: 0x0002, 0x1799: 0x0002, 0x179a: 0x0002, 0x179b: 0x0002,
+	// Block 0x5f, offset 0x17c0
+	0x17ea: 0x000a, 0x17eb: 0x000a, 0x17ec: 0x000a, 0x17ed: 0x000a, 0x17ee: 0x000a, 0x17ef: 0x000a,
+	0x17f0: 0x000a, 0x17f1: 0x000a, 0x17f2: 0x000a, 0x17f3: 0x000a, 0x17f4: 0x000a, 0x17f5: 0x000a,
+	0x17f6: 0x000a, 0x17f7: 0x000a, 0x17f8: 0x000a, 0x17f9: 0x000a, 0x17fa: 0x000a, 0x17fb: 0x000a,
+	0x17fc: 0x000a, 0x17fd: 0x000a, 0x17fe: 0x000a, 0x17ff: 0x000a,
+	// Block 0x60, offset 0x1800
+	0x1800: 0x000a, 0x1801: 0x000a, 0x1802: 0x000a, 0x1803: 0x000a, 0x1804: 0x000a, 0x1805: 0x000a,
+	0x1806: 0x000a, 0x1807: 0x000a, 0x1808: 0x000a, 0x1809: 0x000a, 0x180a: 0x000a, 0x180b: 0x000a,
+	0x180c: 0x000a, 0x180d: 0x000a, 0x180e: 0x000a, 0x180f: 0x000a, 0x1810: 0x000a, 0x1811: 0x000a,
+	0x1812: 0x000a, 0x1813: 0x000a, 0x1814: 0x000a, 0x1815: 0x000a, 0x1816: 0x000a, 0x1817: 0x000a,
+	0x1818: 0x000a, 0x1819: 0x000a, 0x181a: 0x000a, 0x181b: 0x000a, 0x181c: 0x000a, 0x181d: 0x000a,
+	0x181e: 0x000a, 0x181f: 0x000a, 0x1820: 0x000a, 0x1821: 0x000a, 0x1822: 0x000a, 0x1823: 0x000a,
+	0x1824: 0x000a, 0x1825: 0x000a, 0x1826: 0x000a, 0x1827: 0x000a, 0x1828: 0x000a, 0x1829: 0x000a,
+	0x182a: 0x000a, 0x182b: 0x000a, 0x182d: 0x000a, 0x182e: 0x000a, 0x182f: 0x000a,
+	0x1830: 0x000a, 0x1831: 0x000a, 0x1832: 0x000a, 0x1833: 0x000a, 0x1834: 0x000a, 0x1835: 0x000a,
+	0x1836: 0x000a, 0x1837: 0x000a, 0x1838: 0x000a, 0x1839: 0x000a, 0x183a: 0x000a, 0x183b: 0x000a,
+	0x183c: 0x000a, 0x183d: 0x000a, 0x183e: 0x000a, 0x183f: 0x000a,
+	// Block 0x61, offset 0x1840
+	0x1840: 0x000a, 0x1841: 0x000a, 0x1842: 0x000a, 0x1843: 0x000a, 0x1844: 0x000a, 0x1845: 0x000a,
+	0x1846: 0x000a, 0x1847: 0x000a, 0x1848: 0x000a, 0x1849: 0x000a, 0x184a: 0x000a, 0x184b: 0x000a,
+	0x184c: 0x000a, 0x184d: 0x000a, 0x184e: 0x000a, 0x184f: 0x000a, 0x1850: 0x000a, 0x1851: 0x000a,
+	0x1852: 0x000a, 0x1853: 0x000a, 0x1854: 0x000a, 0x1855: 0x000a, 0x1856: 0x000a, 0x1857: 0x000a,
+	0x1858: 0x000a, 0x1859: 0x000a, 0x185a: 0x000a, 0x185b: 0x000a, 0x185c: 0x000a, 0x185d: 0x000a,
+	0x185e: 0x000a, 0x185f: 0x000a, 0x1860: 0x000a, 0x1861: 0x000a, 0x1862: 0x000a, 0x1863: 0x000a,
+	0x1864: 0x000a, 0x1865: 0x000a, 0x1866: 0x000a, 0x1867: 0x000a, 0x1868: 0x003a, 0x1869: 0x002a,
+	0x186a: 0x003a, 0x186b: 0x002a, 0x186c: 0x003a, 0x186d: 0x002a, 0x186e: 0x003a, 0x186f: 0x002a,
+	0x1870: 0x003a, 0x1871: 0x002a, 0x1872: 0x003a, 0x1873: 0x002a, 0x1874: 0x003a, 0x1875: 0x002a,
+	0x1876: 0x000a, 0x1877: 0x000a, 0x1878: 0x000a, 0x1879: 0x000a, 0x187a: 0x000a, 0x187b: 0x000a,
+	0x187c: 0x000a, 0x187d: 0x000a, 0x187e: 0x000a, 0x187f: 0x000a,
+	// Block 0x62, offset 0x1880
+	0x1880: 0x000a, 0x1881: 0x000a, 0x1882: 0x000a, 0x1883: 0x000a, 0x1884: 0x000a, 0x1885: 0x009a,
+	0x1886: 0x008a, 0x1887: 0x000a, 0x1888: 0x000a, 0x1889: 0x000a, 0x188a: 0x000a, 0x188b: 0x000a,
+	0x188c: 0x000a, 0x188d: 0x000a, 0x188e: 0x000a, 0x188f: 0x000a, 0x1890: 0x000a, 0x1891: 0x000a,
+	0x1892: 0x000a, 0x1893: 0x000a, 0x1894: 0x000a, 0x1895: 0x000a, 0x1896: 0x000a, 0x1897: 0x000a,
+	0x1898: 0x000a, 0x1899: 0x000a, 0x189a: 0x000a, 0x189b: 0x000a, 0x189c: 0x000a, 0x189d: 0x000a,
+	0x189e: 0x000a, 0x189f: 0x000a, 0x18a0: 0x000a, 0x18a1: 0x000a, 0x18a2: 0x000a, 0x18a3: 0x000a,
+	0x18a4: 0x000a, 0x18a5: 0x000a, 0x18a6: 0x003a, 0x18a7: 0x002a, 0x18a8: 0x003a, 0x18a9: 0x002a,
+	0x18aa: 0x003a, 0x18ab: 0x002a, 0x18ac: 0x003a, 0x18ad: 0x002a, 0x18ae: 0x003a, 0x18af: 0x002a,
+	0x18b0: 0x000a, 0x18b1: 0x000a, 0x18b2: 0x000a, 0x18b3: 0x000a, 0x18b4: 0x000a, 0x18b5: 0x000a,
+	0x18b6: 0x000a, 0x18b7: 0x000a, 0x18b8: 0x000a, 0x18b9: 0x000a, 0x18ba: 0x000a, 0x18bb: 0x000a,
+	0x18bc: 0x000a, 0x18bd: 0x000a, 0x18be: 0x000a, 0x18bf: 0x000a,
+	// Block 0x63, offset 0x18c0
+	0x18c0: 0x000a, 0x18c1: 0x000a, 0x18c2: 0x000a, 0x18c3: 0x007a, 0x18c4: 0x006a, 0x18c5: 0x009a,
+	0x18c6: 0x008a, 0x18c7: 0x00ba, 0x18c8: 0x00aa, 0x18c9: 0x009a, 0x18ca: 0x008a, 0x18cb: 0x007a,
+	0x18cc: 0x006a, 0x18cd: 0x00da, 0x18ce: 0x002a, 0x18cf: 0x003a, 0x18d0: 0x00ca, 0x18d1: 0x009a,
+	0x18d2: 0x008a, 0x18d3: 0x007a, 0x18d4: 0x006a, 0x18d5: 0x009a, 0x18d6: 0x008a, 0x18d7: 0x00ba,
+	0x18d8: 0x00aa, 0x18d9: 0x000a, 0x18da: 0x000a, 0x18db: 0x000a, 0x18dc: 0x000a, 0x18dd: 0x000a,
+	0x18de: 0x000a, 0x18df: 0x000a, 0x18e0: 0x000a, 0x18e1: 0x000a, 0x18e2: 0x000a, 0x18e3: 0x000a,
+	0x18e4: 0x000a, 0x18e5: 0x000a, 0x18e6: 0x000a, 0x18e7: 0x000a, 0x18e8: 0x000a, 0x18e9: 0x000a,
+	0x18ea: 0x000a, 0x18eb: 0x000a, 0x18ec: 0x000a, 0x18ed: 0x000a, 0x18ee: 0x000a, 0x18ef: 0x000a,
+	0x18f0: 0x000a, 0x18f1: 0x000a, 0x18f2: 0x000a, 0x18f3: 0x000a, 0x18f4: 0x000a, 0x18f5: 0x000a,
+	0x18f6: 0x000a, 0x18f7: 0x000a, 0x18f8: 0x000a, 0x18f9: 0x000a, 0x18fa: 0x000a, 0x18fb: 0x000a,
+	0x18fc: 0x000a, 0x18fd: 0x000a, 0x18fe: 0x000a, 0x18ff: 0x000a,
+	// Block 0x64, offset 0x1900
+	0x1900: 0x000a, 0x1901: 0x000a, 0x1902: 0x000a, 0x1903: 0x000a, 0x1904: 0x000a, 0x1905: 0x000a,
+	0x1906: 0x000a, 0x1907: 0x000a, 0x1908: 0x000a, 0x1909: 0x000a, 0x190a: 0x000a, 0x190b: 0x000a,
+	0x190c: 0x000a, 0x190d: 0x000a, 0x190e: 0x000a, 0x190f: 0x000a, 0x1910: 0x000a, 0x1911: 0x000a,
+	0x1912: 0x000a, 0x1913: 0x000a, 0x1914: 0x000a, 0x1915: 0x000a, 0x1916: 0x000a, 0x1917: 0x000a,
+	0x1918: 0x003a, 0x1919: 0x002a, 0x191a: 0x003a, 0x191b: 0x002a, 0x191c: 0x000a, 0x191d: 0x000a,
+	0x191e: 0x000a, 0x191f: 0x000a, 0x1920: 0x000a, 0x1921: 0x000a, 0x1922: 0x000a, 0x1923: 0x000a,
+	0x1924: 0x000a, 0x1925: 0x000a, 0x1926: 0x000a, 0x1927: 0x000a, 0x1928: 0x000a, 0x1929: 0x000a,
+	0x192a: 0x000a, 0x192b: 0x000a, 0x192c: 0x000a, 0x192d: 0x000a, 0x192e: 0x000a, 0x192f: 0x000a,
+	0x1930: 0x000a, 0x1931: 0x000a, 0x1932: 0x000a, 0x1933: 0x000a, 0x1934: 0x000a, 0x1935: 0x000a,
+	0x1936: 0x000a, 0x1937: 0x000a, 0x1938: 0x000a, 0x1939: 0x000a, 0x193a: 0x000a, 0x193b: 0x000a,
+	0x193c: 0x003a, 0x193d: 0x002a, 0x193e: 0x000a, 0x193f: 0x000a,
+	// Block 0x65, offset 0x1940
+	0x1940: 0x000a, 0x1941: 0x000a, 0x1942: 0x000a, 0x1943: 0x000a, 0x1944: 0x000a, 0x1945: 0x000a,
+	0x1946: 0x000a, 0x1947: 0x000a, 0x1948: 0x000a, 0x1949: 0x000a, 0x194a: 0x000a, 0x194b: 0x000a,
+	0x194c: 0x000a, 0x194d: 0x000a, 0x194e: 0x000a, 0x194f: 0x000a, 0x1950: 0x000a, 0x1951: 0x000a,
+	0x1952: 0x000a, 0x1953: 0x000a, 0x1954: 0x000a, 0x1955: 0x000a, 0x1956: 0x000a, 0x1957: 0x000a,
+	0x1958: 0x000a, 0x1959: 0x000a, 0x195a: 0x000a, 0x195b: 0x000a, 0x195c: 0x000a, 0x195d: 0x000a,
+	0x195e: 0x000a, 0x195f: 0x000a, 0x1960: 0x000a, 0x1961: 0x000a, 0x1962: 0x000a, 0x1963: 0x000a,
+	0x1964: 0x000a, 0x1965: 0x000a, 0x1966: 0x000a, 0x1967: 0x000a, 0x1968: 0x000a, 0x1969: 0x000a,
+	0x196a: 0x000a, 0x196b: 0x000a, 0x196c: 0x000a, 0x196d: 0x000a, 0x196e: 0x000a, 0x196f: 0x000a,
+	0x1970: 0x000a, 0x1971: 0x000a, 0x1972: 0x000a, 0x1973: 0x000a,
+	0x1976: 0x000a, 0x1977: 0x000a, 0x1978: 0x000a, 0x1979: 0x000a, 0x197a: 0x000a, 0x197b: 0x000a,
+	0x197c: 0x000a, 0x197d: 0x000a, 0x197e: 0x000a, 0x197f: 0x000a,
+	// Block 0x66, offset 0x1980
+	0x1980: 0x000a, 0x1981: 0x000a, 0x1982: 0x000a, 0x1983: 0x000a, 0x1984: 0x000a, 0x1985: 0x000a,
+	0x1986: 0x000a, 0x1987: 0x000a, 0x1988: 0x000a, 0x1989: 0x000a, 0x198a: 0x000a, 0x198b: 0x000a,
+	0x198c: 0x000a, 0x198d: 0x000a, 0x198e: 0x000a, 0x198f: 0x000a, 0x1990: 0x000a, 0x1991: 0x000a,
+	0x1992: 0x000a, 0x1993: 0x000a, 0x1994: 0x000a, 0x1995: 0x000a,
+	0x1998: 0x000a, 0x1999: 0x000a, 0x199a: 0x000a, 0x199b: 0x000a, 0x199c: 0x000a, 0x199d: 0x000a,
+	0x199e: 0x000a, 0x199f: 0x000a, 0x19a0: 0x000a, 0x19a1: 0x000a, 0x19a2: 0x000a, 0x19a3: 0x000a,
+	0x19a4: 0x000a, 0x19a5: 0x000a, 0x19a6: 0x000a, 0x19a7: 0x000a, 0x19a8: 0x000a, 0x19a9: 0x000a,
+	0x19aa: 0x000a, 0x19ab: 0x000a, 0x19ac: 0x000a, 0x19ad: 0x000a, 0x19ae: 0x000a, 0x19af: 0x000a,
+	0x19b0: 0x000a, 0x19b1: 0x000a, 0x19b2: 0x000a, 0x19b3: 0x000a, 0x19b4: 0x000a, 0x19b5: 0x000a,
+	0x19b6: 0x000a, 0x19b7: 0x000a, 0x19b8: 0x000a, 0x19b9: 0x000a,
+	0x19bd: 0x000a, 0x19be: 0x000a, 0x19bf: 0x000a,
+	// Block 0x67, offset 0x19c0
+	0x19c0: 0x000a, 0x19c1: 0x000a, 0x19c2: 0x000a, 0x19c3: 0x000a, 0x19c4: 0x000a, 0x19c5: 0x000a,
+	0x19c6: 0x000a, 0x19c7: 0x000a, 0x19c8: 0x000a, 0x19ca: 0x000a, 0x19cb: 0x000a,
+	0x19cc: 0x000a, 0x19cd: 0x000a, 0x19ce: 0x000a, 0x19cf: 0x000a, 0x19d0: 0x000a, 0x19d1: 0x000a,
+	0x19ec: 0x000a, 0x19ed: 0x000a, 0x19ee: 0x000a, 0x19ef: 0x000a,
+	// Block 0x68, offset 0x1a00
+	0x1a25: 0x000a, 0x1a26: 0x000a, 0x1a27: 0x000a, 0x1a28: 0x000a, 0x1a29: 0x000a,
+	0x1a2a: 0x000a, 0x1a2f: 0x000c,
+	0x1a30: 0x000c, 0x1a31: 0x000c,
+	0x1a39: 0x000a, 0x1a3a: 0x000a, 0x1a3b: 0x000a,
+	0x1a3c: 0x000a, 0x1a3d: 0x000a, 0x1a3e: 0x000a, 0x1a3f: 0x000a,
+	// Block 0x69, offset 0x1a40
+	0x1a7f: 0x000c,
+	// Block 0x6a, offset 0x1a80
+	0x1aa0: 0x000c, 0x1aa1: 0x000c, 0x1aa2: 0x000c, 0x1aa3: 0x000c,
+	0x1aa4: 0x000c, 0x1aa5: 0x000c, 0x1aa6: 0x000c, 0x1aa7: 0x000c, 0x1aa8: 0x000c, 0x1aa9: 0x000c,
+	0x1aaa: 0x000c, 0x1aab: 0x000c, 0x1aac: 0x000c, 0x1aad: 0x000c, 0x1aae: 0x000c, 0x1aaf: 0x000c,
+	0x1ab0: 0x000c, 0x1ab1: 0x000c, 0x1ab2: 0x000c, 0x1ab3: 0x000c, 0x1ab4: 0x000c, 0x1ab5: 0x000c,
+	0x1ab6: 0x000c, 0x1ab7: 0x000c, 0x1ab8: 0x000c, 0x1ab9: 0x000c, 0x1aba: 0x000c, 0x1abb: 0x000c,
+	0x1abc: 0x000c, 0x1abd: 0x000c, 0x1abe: 0x000c, 0x1abf: 0x000c,
+	// Block 0x6b, offset 0x1ac0
+	0x1ac0: 0x000a, 0x1ac1: 0x000a, 0x1ac2: 0x000a, 0x1ac3: 0x000a, 0x1ac4: 0x000a, 0x1ac5: 0x000a,
+	0x1ac6: 0x000a, 0x1ac7: 0x000a, 0x1ac8: 0x000a, 0x1ac9: 0x000a, 0x1aca: 0x000a, 0x1acb: 0x000a,
+	0x1acc: 0x000a, 0x1acd: 0x000a, 0x1ace: 0x000a, 0x1acf: 0x000a, 0x1ad0: 0x000a, 0x1ad1: 0x000a,
+	0x1ad2: 0x000a, 0x1ad3: 0x000a, 0x1ad4: 0x000a, 0x1ad5: 0x000a, 0x1ad6: 0x000a, 0x1ad7: 0x000a,
+	0x1ad8: 0x000a, 0x1ad9: 0x000a, 0x1ada: 0x000a, 0x1adb: 0x000a, 0x1adc: 0x000a, 0x1add: 0x000a,
+	0x1ade: 0x000a, 0x1adf: 0x000a, 0x1ae0: 0x000a, 0x1ae1: 0x000a, 0x1ae2: 0x003a, 0x1ae3: 0x002a,
+	0x1ae4: 0x003a, 0x1ae5: 0x002a, 0x1ae6: 0x003a, 0x1ae7: 0x002a, 0x1ae8: 0x003a, 0x1ae9: 0x002a,
+	0x1aea: 0x000a, 0x1aeb: 0x000a, 0x1aec: 0x000a, 0x1aed: 0x000a, 0x1aee: 0x000a, 0x1aef: 0x000a,
+	0x1af0: 0x000a, 0x1af1: 0x000a, 0x1af2: 0x000a, 0x1af3: 0x000a, 0x1af4: 0x000a, 0x1af5: 0x000a,
+	0x1af6: 0x000a, 0x1af7: 0x000a, 0x1af8: 0x000a, 0x1af9: 0x000a, 0x1afa: 0x000a, 0x1afb: 0x000a,
+	0x1afc: 0x000a, 0x1afd: 0x000a, 0x1afe: 0x000a, 0x1aff: 0x000a,
+	// Block 0x6c, offset 0x1b00
+	0x1b00: 0x000a, 0x1b01: 0x000a, 0x1b02: 0x000a, 0x1b03: 0x000a, 0x1b04: 0x000a,
+	// Block 0x6d, offset 0x1b40
+	0x1b40: 0x000a, 0x1b41: 0x000a, 0x1b42: 0x000a, 0x1b43: 0x000a, 0x1b44: 0x000a, 0x1b45: 0x000a,
+	0x1b46: 0x000a, 0x1b47: 0x000a, 0x1b48: 0x000a, 0x1b49: 0x000a, 0x1b4a: 0x000a, 0x1b4b: 0x000a,
+	0x1b4c: 0x000a, 0x1b4d: 0x000a, 0x1b4e: 0x000a, 0x1b4f: 0x000a, 0x1b50: 0x000a, 0x1b51: 0x000a,
+	0x1b52: 0x000a, 0x1b53: 0x000a, 0x1b54: 0x000a, 0x1b55: 0x000a, 0x1b56: 0x000a, 0x1b57: 0x000a,
+	0x1b58: 0x000a, 0x1b59: 0x000a, 0x1b5b: 0x000a, 0x1b5c: 0x000a, 0x1b5d: 0x000a,
+	0x1b5e: 0x000a, 0x1b5f: 0x000a, 0x1b60: 0x000a, 0x1b61: 0x000a, 0x1b62: 0x000a, 0x1b63: 0x000a,
+	0x1b64: 0x000a, 0x1b65: 0x000a, 0x1b66: 0x000a, 0x1b67: 0x000a, 0x1b68: 0x000a, 0x1b69: 0x000a,
+	0x1b6a: 0x000a, 0x1b6b: 0x000a, 0x1b6c: 0x000a, 0x1b6d: 0x000a, 0x1b6e: 0x000a, 0x1b6f: 0x000a,
+	0x1b70: 0x000a, 0x1b71: 0x000a, 0x1b72: 0x000a, 0x1b73: 0x000a, 0x1b74: 0x000a, 0x1b75: 0x000a,
+	0x1b76: 0x000a, 0x1b77: 0x000a, 0x1b78: 0x000a, 0x1b79: 0x000a, 0x1b7a: 0x000a, 0x1b7b: 0x000a,
+	0x1b7c: 0x000a, 0x1b7d: 0x000a, 0x1b7e: 0x000a, 0x1b7f: 0x000a,
+	// Block 0x6e, offset 0x1b80
+	0x1b80: 0x000a, 0x1b81: 0x000a, 0x1b82: 0x000a, 0x1b83: 0x000a, 0x1b84: 0x000a, 0x1b85: 0x000a,
+	0x1b86: 0x000a, 0x1b87: 0x000a, 0x1b88: 0x000a, 0x1b89: 0x000a, 0x1b8a: 0x000a, 0x1b8b: 0x000a,
+	0x1b8c: 0x000a, 0x1b8d: 0x000a, 0x1b8e: 0x000a, 0x1b8f: 0x000a, 0x1b90: 0x000a, 0x1b91: 0x000a,
+	0x1b92: 0x000a, 0x1b93: 0x000a, 0x1b94: 0x000a, 0x1b95: 0x000a, 0x1b96: 0x000a, 0x1b97: 0x000a,
+	0x1b98: 0x000a, 0x1b99: 0x000a, 0x1b9a: 0x000a, 0x1b9b: 0x000a, 0x1b9c: 0x000a, 0x1b9d: 0x000a,
+	0x1b9e: 0x000a, 0x1b9f: 0x000a, 0x1ba0: 0x000a, 0x1ba1: 0x000a, 0x1ba2: 0x000a, 0x1ba3: 0x000a,
+	0x1ba4: 0x000a, 0x1ba5: 0x000a, 0x1ba6: 0x000a, 0x1ba7: 0x000a, 0x1ba8: 0x000a, 0x1ba9: 0x000a,
+	0x1baa: 0x000a, 0x1bab: 0x000a, 0x1bac: 0x000a, 0x1bad: 0x000a, 0x1bae: 0x000a, 0x1baf: 0x000a,
+	0x1bb0: 0x000a, 0x1bb1: 0x000a, 0x1bb2: 0x000a, 0x1bb3: 0x000a,
+	// Block 0x6f, offset 0x1bc0
+	0x1bc0: 0x000a, 0x1bc1: 0x000a, 0x1bc2: 0x000a, 0x1bc3: 0x000a, 0x1bc4: 0x000a, 0x1bc5: 0x000a,
+	0x1bc6: 0x000a, 0x1bc7: 0x000a, 0x1bc8: 0x000a, 0x1bc9: 0x000a, 0x1bca: 0x000a, 0x1bcb: 0x000a,
+	0x1bcc: 0x000a, 0x1bcd: 0x000a, 0x1bce: 0x000a, 0x1bcf: 0x000a, 0x1bd0: 0x000a, 0x1bd1: 0x000a,
+	0x1bd2: 0x000a, 0x1bd3: 0x000a, 0x1bd4: 0x000a, 0x1bd5: 0x000a,
+	0x1bf0: 0x000a, 0x1bf1: 0x000a, 0x1bf2: 0x000a, 0x1bf3: 0x000a, 0x1bf4: 0x000a, 0x1bf5: 0x000a,
+	0x1bf6: 0x000a, 0x1bf7: 0x000a, 0x1bf8: 0x000a, 0x1bf9: 0x000a, 0x1bfa: 0x000a, 0x1bfb: 0x000a,
+	// Block 0x70, offset 0x1c00
+	0x1c00: 0x0009, 0x1c01: 0x000a, 0x1c02: 0x000a, 0x1c03: 0x000a, 0x1c04: 0x000a,
+	0x1c08: 0x003a, 0x1c09: 0x002a, 0x1c0a: 0x003a, 0x1c0b: 0x002a,
+	0x1c0c: 0x003a, 0x1c0d: 0x002a, 0x1c0e: 0x003a, 0x1c0f: 0x002a, 0x1c10: 0x003a, 0x1c11: 0x002a,
+	0x1c12: 0x000a, 0x1c13: 0x000a, 0x1c14: 0x003a, 0x1c15: 0x002a, 0x1c16: 0x003a, 0x1c17: 0x002a,
+	0x1c18: 0x003a, 0x1c19: 0x002a, 0x1c1a: 0x003a, 0x1c1b: 0x002a, 0x1c1c: 0x000a, 0x1c1d: 0x000a,
+	0x1c1e: 0x000a, 0x1c1f: 0x000a, 0x1c20: 0x000a,
+	0x1c2a: 0x000c, 0x1c2b: 0x000c, 0x1c2c: 0x000c, 0x1c2d: 0x000c,
+	0x1c30: 0x000a,
+	0x1c36: 0x000a, 0x1c37: 0x000a,
+	0x1c3d: 0x000a, 0x1c3e: 0x000a, 0x1c3f: 0x000a,
+	// Block 0x71, offset 0x1c40
+	0x1c59: 0x000c, 0x1c5a: 0x000c, 0x1c5b: 0x000a, 0x1c5c: 0x000a,
+	0x1c60: 0x000a,
+	// Block 0x72, offset 0x1c80
+	0x1cbb: 0x000a,
+	// Block 0x73, offset 0x1cc0
+	0x1cc0: 0x000a, 0x1cc1: 0x000a, 0x1cc2: 0x000a, 0x1cc3: 0x000a, 0x1cc4: 0x000a, 0x1cc5: 0x000a,
+	0x1cc6: 0x000a, 0x1cc7: 0x000a, 0x1cc8: 0x000a, 0x1cc9: 0x000a, 0x1cca: 0x000a, 0x1ccb: 0x000a,
+	0x1ccc: 0x000a, 0x1ccd: 0x000a, 0x1cce: 0x000a, 0x1ccf: 0x000a, 0x1cd0: 0x000a, 0x1cd1: 0x000a,
+	0x1cd2: 0x000a, 0x1cd3: 0x000a, 0x1cd4: 0x000a, 0x1cd5: 0x000a, 0x1cd6: 0x000a, 0x1cd7: 0x000a,
+	0x1cd8: 0x000a, 0x1cd9: 0x000a, 0x1cda: 0x000a, 0x1cdb: 0x000a, 0x1cdc: 0x000a, 0x1cdd: 0x000a,
+	0x1cde: 0x000a, 0x1cdf: 0x000a, 0x1ce0: 0x000a, 0x1ce1: 0x000a, 0x1ce2: 0x000a, 0x1ce3: 0x000a,
+	// Block 0x74, offset 0x1d00
+	0x1d1d: 0x000a,
+	0x1d1e: 0x000a,
+	// Block 0x75, offset 0x1d40
+	0x1d50: 0x000a, 0x1d51: 0x000a,
+	0x1d52: 0x000a, 0x1d53: 0x000a, 0x1d54: 0x000a, 0x1d55: 0x000a, 0x1d56: 0x000a, 0x1d57: 0x000a,
+	0x1d58: 0x000a, 0x1d59: 0x000a, 0x1d5a: 0x000a, 0x1d5b: 0x000a, 0x1d5c: 0x000a, 0x1d5d: 0x000a,
+	0x1d5e: 0x000a, 0x1d5f: 0x000a,
+	0x1d7c: 0x000a, 0x1d7d: 0x000a, 0x1d7e: 0x000a,
+	// Block 0x76, offset 0x1d80
+	0x1db1: 0x000a, 0x1db2: 0x000a, 0x1db3: 0x000a, 0x1db4: 0x000a, 0x1db5: 0x000a,
+	0x1db6: 0x000a, 0x1db7: 0x000a, 0x1db8: 0x000a, 0x1db9: 0x000a, 0x1dba: 0x000a, 0x1dbb: 0x000a,
+	0x1dbc: 0x000a, 0x1dbd: 0x000a, 0x1dbe: 0x000a, 0x1dbf: 0x000a,
+	// Block 0x77, offset 0x1dc0
+	0x1dcc: 0x000a, 0x1dcd: 0x000a, 0x1dce: 0x000a, 0x1dcf: 0x000a,
+	// Block 0x78, offset 0x1e00
+	0x1e37: 0x000a, 0x1e38: 0x000a, 0x1e39: 0x000a, 0x1e3a: 0x000a,
+	// Block 0x79, offset 0x1e40
+	0x1e5e: 0x000a, 0x1e5f: 0x000a,
+	0x1e7f: 0x000a,
+	// Block 0x7a, offset 0x1e80
+	0x1e90: 0x000a, 0x1e91: 0x000a,
+	0x1e92: 0x000a, 0x1e93: 0x000a, 0x1e94: 0x000a, 0x1e95: 0x000a, 0x1e96: 0x000a, 0x1e97: 0x000a,
+	0x1e98: 0x000a, 0x1e99: 0x000a, 0x1e9a: 0x000a, 0x1e9b: 0x000a, 0x1e9c: 0x000a, 0x1e9d: 0x000a,
+	0x1e9e: 0x000a, 0x1e9f: 0x000a, 0x1ea0: 0x000a, 0x1ea1: 0x000a, 0x1ea2: 0x000a, 0x1ea3: 0x000a,
+	0x1ea4: 0x000a, 0x1ea5: 0x000a, 0x1ea6: 0x000a, 0x1ea7: 0x000a, 0x1ea8: 0x000a, 0x1ea9: 0x000a,
+	0x1eaa: 0x000a, 0x1eab: 0x000a, 0x1eac: 0x000a, 0x1ead: 0x000a, 0x1eae: 0x000a, 0x1eaf: 0x000a,
+	0x1eb0: 0x000a, 0x1eb1: 0x000a, 0x1eb2: 0x000a, 0x1eb3: 0x000a, 0x1eb4: 0x000a, 0x1eb5: 0x000a,
+	0x1eb6: 0x000a, 0x1eb7: 0x000a, 0x1eb8: 0x000a, 0x1eb9: 0x000a, 0x1eba: 0x000a, 0x1ebb: 0x000a,
+	0x1ebc: 0x000a, 0x1ebd: 0x000a, 0x1ebe: 0x000a, 0x1ebf: 0x000a,
+	// Block 0x7b, offset 0x1ec0
+	0x1ec0: 0x000a, 0x1ec1: 0x000a, 0x1ec2: 0x000a, 0x1ec3: 0x000a, 0x1ec4: 0x000a, 0x1ec5: 0x000a,
+	0x1ec6: 0x000a,
+	// Block 0x7c, offset 0x1f00
+	0x1f0d: 0x000a, 0x1f0e: 0x000a, 0x1f0f: 0x000a,
+	// Block 0x7d, offset 0x1f40
+	0x1f6f: 0x000c,
+	0x1f70: 0x000c, 0x1f71: 0x000c, 0x1f72: 0x000c, 0x1f73: 0x000a, 0x1f74: 0x000c, 0x1f75: 0x000c,
+	0x1f76: 0x000c, 0x1f77: 0x000c, 0x1f78: 0x000c, 0x1f79: 0x000c, 0x1f7a: 0x000c, 0x1f7b: 0x000c,
+	0x1f7c: 0x000c, 0x1f7d: 0x000c, 0x1f7e: 0x000a, 0x1f7f: 0x000a,
+	// Block 0x7e, offset 0x1f80
+	0x1f9e: 0x000c, 0x1f9f: 0x000c,
+	// Block 0x7f, offset 0x1fc0
+	0x1ff0: 0x000c, 0x1ff1: 0x000c,
+	// Block 0x80, offset 0x2000
+	0x2000: 0x000a, 0x2001: 0x000a, 0x2002: 0x000a, 0x2003: 0x000a, 0x2004: 0x000a, 0x2005: 0x000a,
+	0x2006: 0x000a, 0x2007: 0x000a, 0x2008: 0x000a, 0x2009: 0x000a, 0x200a: 0x000a, 0x200b: 0x000a,
+	0x200c: 0x000a, 0x200d: 0x000a, 0x200e: 0x000a, 0x200f: 0x000a, 0x2010: 0x000a, 0x2011: 0x000a,
+	0x2012: 0x000a, 0x2013: 0x000a, 0x2014: 0x000a, 0x2015: 0x000a, 0x2016: 0x000a, 0x2017: 0x000a,
+	0x2018: 0x000a, 0x2019: 0x000a, 0x201a: 0x000a, 0x201b: 0x000a, 0x201c: 0x000a, 0x201d: 0x000a,
+	0x201e: 0x000a, 0x201f: 0x000a, 0x2020: 0x000a, 0x2021: 0x000a,
+	// Block 0x81, offset 0x2040
+	0x2048: 0x000a,
+	// Block 0x82, offset 0x2080
+	0x2082: 0x000c,
+	0x2086: 0x000c, 0x208b: 0x000c,
+	0x20a5: 0x000c, 0x20a6: 0x000c, 0x20a8: 0x000a, 0x20a9: 0x000a,
+	0x20aa: 0x000a, 0x20ab: 0x000a,
+	0x20b8: 0x0004, 0x20b9: 0x0004,
+	// Block 0x83, offset 0x20c0
+	0x20f4: 0x000a, 0x20f5: 0x000a,
+	0x20f6: 0x000a, 0x20f7: 0x000a,
+	// Block 0x84, offset 0x2100
+	0x2104: 0x000c, 0x2105: 0x000c,
+	0x2120: 0x000c, 0x2121: 0x000c, 0x2122: 0x000c, 0x2123: 0x000c,
+	0x2124: 0x000c, 0x2125: 0x000c, 0x2126: 0x000c, 0x2127: 0x000c, 0x2128: 0x000c, 0x2129: 0x000c,
+	0x212a: 0x000c, 0x212b: 0x000c, 0x212c: 0x000c, 0x212d: 0x000c, 0x212e: 0x000c, 0x212f: 0x000c,
+	0x2130: 0x000c, 0x2131: 0x000c,
+	// Block 0x85, offset 0x2140
+	0x2166: 0x000c, 0x2167: 0x000c, 0x2168: 0x000c, 0x2169: 0x000c,
+	0x216a: 0x000c, 0x216b: 0x000c, 0x216c: 0x000c, 0x216d: 0x000c,
+	// Block 0x86, offset 0x2180
+	0x2187: 0x000c, 0x2188: 0x000c, 0x2189: 0x000c, 0x218a: 0x000c, 0x218b: 0x000c,
+	0x218c: 0x000c, 0x218d: 0x000c, 0x218e: 0x000c, 0x218f: 0x000c, 0x2190: 0x000c, 0x2191: 0x000c,
+	// Block 0x87, offset 0x21c0
+	0x21c0: 0x000c, 0x21c1: 0x000c, 0x21c2: 0x000c,
+	0x21f3: 0x000c,
+	0x21f6: 0x000c, 0x21f7: 0x000c, 0x21f8: 0x000c, 0x21f9: 0x000c,
+	0x21fc: 0x000c,
+	// Block 0x88, offset 0x2200
+	0x2225: 0x000c,
+	// Block 0x89, offset 0x2240
+	0x2269: 0x000c,
+	0x226a: 0x000c, 0x226b: 0x000c, 0x226c: 0x000c, 0x226d: 0x000c, 0x226e: 0x000c,
+	0x2271: 0x000c, 0x2272: 0x000c, 0x2275: 0x000c,
+	0x2276: 0x000c,
+	// Block 0x8a, offset 0x2280
+	0x2283: 0x000c,
+	0x228c: 0x000c,
+	0x22bc: 0x000c,
+	// Block 0x8b, offset 0x22c0
+	0x22f0: 0x000c, 0x22f2: 0x000c, 0x22f3: 0x000c, 0x22f4: 0x000c,
+	0x22f7: 0x000c, 0x22f8: 0x000c,
+	0x22fe: 0x000c, 0x22ff: 0x000c,
+	// Block 0x8c, offset 0x2300
+	0x2301: 0x000c,
+	0x232c: 0x000c, 0x232d: 0x000c,
+	0x2336: 0x000c,
+	// Block 0x8d, offset 0x2340
+	0x2365: 0x000c, 0x2368: 0x000c,
+	0x236d: 0x000c,
+	// Block 0x8e, offset 0x2380
+	0x239d: 0x0001,
+	0x239e: 0x000c, 0x239f: 0x0001, 0x23a0: 0x0001, 0x23a1: 0x0001, 0x23a2: 0x0001, 0x23a3: 0x0001,
+	0x23a4: 0x0001, 0x23a5: 0x0001, 0x23a6: 0x0001, 0x23a7: 0x0001, 0x23a8: 0x0001, 0x23a9: 0x0003,
+	0x23aa: 0x0001, 0x23ab: 0x0001, 0x23ac: 0x0001, 0x23ad: 0x0001, 0x23ae: 0x0001, 0x23af: 0x0001,
+	0x23b0: 0x0001, 0x23b1: 0x0001, 0x23b2: 0x0001, 0x23b3: 0x0001, 0x23b4: 0x0001, 0x23b5: 0x0001,
+	0x23b6: 0x0001, 0x23b7: 0x0001, 0x23b8: 0x0001, 0x23b9: 0x0001, 0x23ba: 0x0001, 0x23bb: 0x0001,
+	0x23bc: 0x0001, 0x23bd: 0x0001, 0x23be: 0x0001, 0x23bf: 0x0001,
+	// Block 0x8f, offset 0x23c0
+	0x23c0: 0x0001, 0x23c1: 0x0001, 0x23c2: 0x0001, 0x23c3: 0x0001, 0x23c4: 0x0001, 0x23c5: 0x0001,
+	0x23c6: 0x0001, 0x23c7: 0x0001, 0x23c8: 0x0001, 0x23c9: 0x0001, 0x23ca: 0x0001, 0x23cb: 0x0001,
+	0x23cc: 0x0001, 0x23cd: 0x0001, 0x23ce: 0x0001, 0x23cf: 0x0001, 0x23d0: 0x000d, 0x23d1: 0x000d,
+	0x23d2: 0x000d, 0x23d3: 0x000d, 0x23d4: 0x000d, 0x23d5: 0x000d, 0x23d6: 0x000d, 0x23d7: 0x000d,
+	0x23d8: 0x000d, 0x23d9: 0x000d, 0x23da: 0x000d, 0x23db: 0x000d, 0x23dc: 0x000d, 0x23dd: 0x000d,
+	0x23de: 0x000d, 0x23df: 0x000d, 0x23e0: 0x000d, 0x23e1: 0x000d, 0x23e2: 0x000d, 0x23e3: 0x000d,
+	0x23e4: 0x000d, 0x23e5: 0x000d, 0x23e6: 0x000d, 0x23e7: 0x000d, 0x23e8: 0x000d, 0x23e9: 0x000d,
+	0x23ea: 0x000d, 0x23eb: 0x000d, 0x23ec: 0x000d, 0x23ed: 0x000d, 0x23ee: 0x000d, 0x23ef: 0x000d,
+	0x23f0: 0x000d, 0x23f1: 0x000d, 0x23f2: 0x000d, 0x23f3: 0x000d, 0x23f4: 0x000d, 0x23f5: 0x000d,
+	0x23f6: 0x000d, 0x23f7: 0x000d, 0x23f8: 0x000d, 0x23f9: 0x000d, 0x23fa: 0x000d, 0x23fb: 0x000d,
+	0x23fc: 0x000d, 0x23fd: 0x000d, 0x23fe: 0x000d, 0x23ff: 0x000d,
+	// Block 0x90, offset 0x2400
+	0x2400: 0x000d, 0x2401: 0x000d, 0x2402: 0x000d, 0x2403: 0x000d, 0x2404: 0x000d, 0x2405: 0x000d,
+	0x2406: 0x000d, 0x2407: 0x000d, 0x2408: 0x000d, 0x2409: 0x000d, 0x240a: 0x000d, 0x240b: 0x000d,
+	0x240c: 0x000d, 0x240d: 0x000d, 0x240e: 0x000d, 0x240f: 0x000d, 0x2410: 0x000d, 0x2411: 0x000d,
+	0x2412: 0x000d, 0x2413: 0x000d, 0x2414: 0x000d, 0x2415: 0x000d, 0x2416: 0x000d, 0x2417: 0x000d,
+	0x2418: 0x000d, 0x2419: 0x000d, 0x241a: 0x000d, 0x241b: 0x000d, 0x241c: 0x000d, 0x241d: 0x000d,
+	0x241e: 0x000d, 0x241f: 0x000d, 0x2420: 0x000d, 0x2421: 0x000d, 0x2422: 0x000d, 0x2423: 0x000d,
+	0x2424: 0x000d, 0x2425: 0x000d, 0x2426: 0x000d, 0x2427: 0x000d, 0x2428: 0x000d, 0x2429: 0x000d,
+	0x242a: 0x000d, 0x242b: 0x000d, 0x242c: 0x000d, 0x242d: 0x000d, 0x242e: 0x000d, 0x242f: 0x000d,
+	0x2430: 0x000d, 0x2431: 0x000d, 0x2432: 0x000d, 0x2433: 0x000d, 0x2434: 0x000d, 0x2435: 0x000d,
+	0x2436: 0x000d, 0x2437: 0x000d, 0x2438: 0x000d, 0x2439: 0x000d, 0x243a: 0x000d, 0x243b: 0x000d,
+	0x243c: 0x000d, 0x243d: 0x000d, 0x243e: 0x000a, 0x243f: 0x000a,
+	// Block 0x91, offset 0x2440
+	0x2440: 0x000d, 0x2441: 0x000d, 0x2442: 0x000d, 0x2443: 0x000d, 0x2444: 0x000d, 0x2445: 0x000d,
+	0x2446: 0x000d, 0x2447: 0x000d, 0x2448: 0x000d, 0x2449: 0x000d, 0x244a: 0x000d, 0x244b: 0x000d,
+	0x244c: 0x000d, 0x244d: 0x000d, 0x244e: 0x000d, 0x244f: 0x000d, 0x2450: 0x000b, 0x2451: 0x000b,
+	0x2452: 0x000b, 0x2453: 0x000b, 0x2454: 0x000b, 0x2455: 0x000b, 0x2456: 0x000b, 0x2457: 0x000b,
+	0x2458: 0x000b, 0x2459: 0x000b, 0x245a: 0x000b, 0x245b: 0x000b, 0x245c: 0x000b, 0x245d: 0x000b,
+	0x245e: 0x000b, 0x245f: 0x000b, 0x2460: 0x000b, 0x2461: 0x000b, 0x2462: 0x000b, 0x2463: 0x000b,
+	0x2464: 0x000b, 0x2465: 0x000b, 0x2466: 0x000b, 0x2467: 0x000b, 0x2468: 0x000b, 0x2469: 0x000b,
+	0x246a: 0x000b, 0x246b: 0x000b, 0x246c: 0x000b, 0x246d: 0x000b, 0x246e: 0x000b, 0x246f: 0x000b,
+	0x2470: 0x000d, 0x2471: 0x000d, 0x2472: 0x000d, 0x2473: 0x000d, 0x2474: 0x000d, 0x2475: 0x000d,
+	0x2476: 0x000d, 0x2477: 0x000d, 0x2478: 0x000d, 0x2479: 0x000d, 0x247a: 0x000d, 0x247b: 0x000d,
+	0x247c: 0x000d, 0x247d: 0x000a, 0x247e: 0x000d, 0x247f: 0x000d,
+	// Block 0x92, offset 0x2480
+	0x2480: 0x000c, 0x2481: 0x000c, 0x2482: 0x000c, 0x2483: 0x000c, 0x2484: 0x000c, 0x2485: 0x000c,
+	0x2486: 0x000c, 0x2487: 0x000c, 0x2488: 0x000c, 0x2489: 0x000c, 0x248a: 0x000c, 0x248b: 0x000c,
+	0x248c: 0x000c, 0x248d: 0x000c, 0x248e: 0x000c, 0x248f: 0x000c, 0x2490: 0x000a, 0x2491: 0x000a,
+	0x2492: 0x000a, 0x2493: 0x000a, 0x2494: 0x000a, 0x2495: 0x000a, 0x2496: 0x000a, 0x2497: 0x000a,
+	0x2498: 0x000a, 0x2499: 0x000a,
+	0x24a0: 0x000c, 0x24a1: 0x000c, 0x24a2: 0x000c, 0x24a3: 0x000c,
+	0x24a4: 0x000c, 0x24a5: 0x000c, 0x24a6: 0x000c, 0x24a7: 0x000c, 0x24a8: 0x000c, 0x24a9: 0x000c,
+	0x24aa: 0x000c, 0x24ab: 0x000c, 0x24ac: 0x000c, 0x24ad: 0x000c, 0x24ae: 0x000c, 0x24af: 0x000c,
+	0x24b0: 0x000a, 0x24b1: 0x000a, 0x24b2: 0x000a, 0x24b3: 0x000a, 0x24b4: 0x000a, 0x24b5: 0x000a,
+	0x24b6: 0x000a, 0x24b7: 0x000a, 0x24b8: 0x000a, 0x24b9: 0x000a, 0x24ba: 0x000a, 0x24bb: 0x000a,
+	0x24bc: 0x000a, 0x24bd: 0x000a, 0x24be: 0x000a, 0x24bf: 0x000a,
+	// Block 0x93, offset 0x24c0
+	0x24c0: 0x000a, 0x24c1: 0x000a, 0x24c2: 0x000a, 0x24c3: 0x000a, 0x24c4: 0x000a, 0x24c5: 0x000a,
+	0x24c6: 0x000a, 0x24c7: 0x000a, 0x24c8: 0x000a, 0x24c9: 0x000a, 0x24ca: 0x000a, 0x24cb: 0x000a,
+	0x24cc: 0x000a, 0x24cd: 0x000a, 0x24ce: 0x000a, 0x24cf: 0x000a, 0x24d0: 0x0006, 0x24d1: 0x000a,
+	0x24d2: 0x0006, 0x24d4: 0x000a, 0x24d5: 0x0006, 0x24d6: 0x000a, 0x24d7: 0x000a,
+	0x24d8: 0x000a, 0x24d9: 0x009a, 0x24da: 0x008a, 0x24db: 0x007a, 0x24dc: 0x006a, 0x24dd: 0x009a,
+	0x24de: 0x008a, 0x24df: 0x0004, 0x24e0: 0x000a, 0x24e1: 0x000a, 0x24e2: 0x0003, 0x24e3: 0x0003,
+	0x24e4: 0x000a, 0x24e5: 0x000a, 0x24e6: 0x000a, 0x24e8: 0x000a, 0x24e9: 0x0004,
+	0x24ea: 0x0004, 0x24eb: 0x000a,
+	0x24f0: 0x000d, 0x24f1: 0x000d, 0x24f2: 0x000d, 0x24f3: 0x000d, 0x24f4: 0x000d, 0x24f5: 0x000d,
+	0x24f6: 0x000d, 0x24f7: 0x000d, 0x24f8: 0x000d, 0x24f9: 0x000d, 0x24fa: 0x000d, 0x24fb: 0x000d,
+	0x24fc: 0x000d, 0x24fd: 0x000d, 0x24fe: 0x000d, 0x24ff: 0x000d,
+	// Block 0x94, offset 0x2500
+	0x2500: 0x000d, 0x2501: 0x000d, 0x2502: 0x000d, 0x2503: 0x000d, 0x2504: 0x000d, 0x2505: 0x000d,
+	0x2506: 0x000d, 0x2507: 0x000d, 0x2508: 0x000d, 0x2509: 0x000d, 0x250a: 0x000d, 0x250b: 0x000d,
+	0x250c: 0x000d, 0x250d: 0x000d, 0x250e: 0x000d, 0x250f: 0x000d, 0x2510: 0x000d, 0x2511: 0x000d,
+	0x2512: 0x000d, 0x2513: 0x000d, 0x2514: 0x000d, 0x2515: 0x000d, 0x2516: 0x000d, 0x2517: 0x000d,
+	0x2518: 0x000d, 0x2519: 0x000d, 0x251a: 0x000d, 0x251b: 0x000d, 0x251c: 0x000d, 0x251d: 0x000d,
+	0x251e: 0x000d, 0x251f: 0x000d, 0x2520: 0x000d, 0x2521: 0x000d, 0x2522: 0x000d, 0x2523: 0x000d,
+	0x2524: 0x000d, 0x2525: 0x000d, 0x2526: 0x000d, 0x2527: 0x000d, 0x2528: 0x000d, 0x2529: 0x000d,
+	0x252a: 0x000d, 0x252b: 0x000d, 0x252c: 0x000d, 0x252d: 0x000d, 0x252e: 0x000d, 0x252f: 0x000d,
+	0x2530: 0x000d, 0x2531: 0x000d, 0x2532: 0x000d, 0x2533: 0x000d, 0x2534: 0x000d, 0x2535: 0x000d,
+	0x2536: 0x000d, 0x2537: 0x000d, 0x2538: 0x000d, 0x2539: 0x000d, 0x253a: 0x000d, 0x253b: 0x000d,
+	0x253c: 0x000d, 0x253d: 0x000d, 0x253e: 0x000d, 0x253f: 0x000b,
+	// Block 0x95, offset 0x2540
+	0x2541: 0x000a, 0x2542: 0x000a, 0x2543: 0x0004, 0x2544: 0x0004, 0x2545: 0x0004,
+	0x2546: 0x000a, 0x2547: 0x000a, 0x2548: 0x003a, 0x2549: 0x002a, 0x254a: 0x000a, 0x254b: 0x0003,
+	0x254c: 0x0006, 0x254d: 0x0003, 0x254e: 0x0006, 0x254f: 0x0006, 0x2550: 0x0002, 0x2551: 0x0002,
+	0x2552: 0x0002, 0x2553: 0x0002, 0x2554: 0x0002, 0x2555: 0x0002, 0x2556: 0x0002, 0x2557: 0x0002,
+	0x2558: 0x0002, 0x2559: 0x0002, 0x255a: 0x0006, 0x255b: 0x000a, 0x255c: 0x000a, 0x255d: 0x000a,
+	0x255e: 0x000a, 0x255f: 0x000a, 0x2560: 0x000a,
+	0x257b: 0x005a,
+	0x257c: 0x000a, 0x257d: 0x004a, 0x257e: 0x000a, 0x257f: 0x000a,
+	// Block 0x96, offset 0x2580
+	0x2580: 0x000a,
+	0x259b: 0x005a, 0x259c: 0x000a, 0x259d: 0x004a,
+	0x259e: 0x000a, 0x259f: 0x00fa, 0x25a0: 0x00ea, 0x25a1: 0x000a, 0x25a2: 0x003a, 0x25a3: 0x002a,
+	0x25a4: 0x000a, 0x25a5: 0x000a,
+	// Block 0x97, offset 0x25c0
+	0x25e0: 0x0004, 0x25e1: 0x0004, 0x25e2: 0x000a, 0x25e3: 0x000a,
+	0x25e4: 0x000a, 0x25e5: 0x0004, 0x25e6: 0x0004, 0x25e8: 0x000a, 0x25e9: 0x000a,
+	0x25ea: 0x000a, 0x25eb: 0x000a, 0x25ec: 0x000a, 0x25ed: 0x000a, 0x25ee: 0x000a,
+	0x25f0: 0x000b, 0x25f1: 0x000b, 0x25f2: 0x000b, 0x25f3: 0x000b, 0x25f4: 0x000b, 0x25f5: 0x000b,
+	0x25f6: 0x000b, 0x25f7: 0x000b, 0x25f8: 0x000b, 0x25f9: 0x000a, 0x25fa: 0x000a, 0x25fb: 0x000a,
+	0x25fc: 0x000a, 0x25fd: 0x000a, 0x25fe: 0x000b, 0x25ff: 0x000b,
+	// Block 0x98, offset 0x2600
+	0x2601: 0x000a,
+	// Block 0x99, offset 0x2640
+	0x2640: 0x000a, 0x2641: 0x000a, 0x2642: 0x000a, 0x2643: 0x000a, 0x2644: 0x000a, 0x2645: 0x000a,
+	0x2646: 0x000a, 0x2647: 0x000a, 0x2648: 0x000a, 0x2649: 0x000a, 0x264a: 0x000a, 0x264b: 0x000a,
+	0x264c: 0x000a, 0x2650: 0x000a, 0x2651: 0x000a,
+	0x2652: 0x000a, 0x2653: 0x000a, 0x2654: 0x000a, 0x2655: 0x000a, 0x2656: 0x000a, 0x2657: 0x000a,
+	0x2658: 0x000a, 0x2659: 0x000a, 0x265a: 0x000a, 0x265b: 0x000a,
+	0x2660: 0x000a,
+	// Block 0x9a, offset 0x2680
+	0x26bd: 0x000c,
+	// Block 0x9b, offset 0x26c0
+	0x26e0: 0x000c, 0x26e1: 0x0002, 0x26e2: 0x0002, 0x26e3: 0x0002,
+	0x26e4: 0x0002, 0x26e5: 0x0002, 0x26e6: 0x0002, 0x26e7: 0x0002, 0x26e8: 0x0002, 0x26e9: 0x0002,
+	0x26ea: 0x0002, 0x26eb: 0x0002, 0x26ec: 0x0002, 0x26ed: 0x0002, 0x26ee: 0x0002, 0x26ef: 0x0002,
+	0x26f0: 0x0002, 0x26f1: 0x0002, 0x26f2: 0x0002, 0x26f3: 0x0002, 0x26f4: 0x0002, 0x26f5: 0x0002,
+	0x26f6: 0x0002, 0x26f7: 0x0002, 0x26f8: 0x0002, 0x26f9: 0x0002, 0x26fa: 0x0002, 0x26fb: 0x0002,
+	// Block 0x9c, offset 0x2700
+	0x2736: 0x000c, 0x2737: 0x000c, 0x2738: 0x000c, 0x2739: 0x000c, 0x273a: 0x000c,
+	// Block 0x9d, offset 0x2740
+	0x2740: 0x0001, 0x2741: 0x0001, 0x2742: 0x0001, 0x2743: 0x0001, 0x2744: 0x0001, 0x2745: 0x0001,
+	0x2746: 0x0001, 0x2747: 0x0001, 0x2748: 0x0001, 0x2749: 0x0001, 0x274a: 0x0001, 0x274b: 0x0001,
+	0x274c: 0x0001, 0x274d: 0x0001, 0x274e: 0x0001, 0x274f: 0x0001, 0x2750: 0x0001, 0x2751: 0x0001,
+	0x2752: 0x0001, 0x2753: 0x0001, 0x2754: 0x0001, 0x2755: 0x0001, 0x2756: 0x0001, 0x2757: 0x0001,
+	0x2758: 0x0001, 0x2759: 0x0001, 0x275a: 0x0001, 0x275b: 0x0001, 0x275c: 0x0001, 0x275d: 0x0001,
+	0x275e: 0x0001, 0x275f: 0x0001, 0x2760: 0x0001, 0x2761: 0x0001, 0x2762: 0x0001, 0x2763: 0x0001,
+	0x2764: 0x0001, 0x2765: 0x0001, 0x2766: 0x0001, 0x2767: 0x0001, 0x2768: 0x0001, 0x2769: 0x0001,
+	0x276a: 0x0001, 0x276b: 0x0001, 0x276c: 0x0001, 0x276d: 0x0001, 0x276e: 0x0001, 0x276f: 0x0001,
+	0x2770: 0x0001, 0x2771: 0x0001, 0x2772: 0x0001, 0x2773: 0x0001, 0x2774: 0x0001, 0x2775: 0x0001,
+	0x2776: 0x0001, 0x2777: 0x0001, 0x2778: 0x0001, 0x2779: 0x0001, 0x277a: 0x0001, 0x277b: 0x0001,
+	0x277c: 0x0001, 0x277d: 0x0001, 0x277e: 0x0001, 0x277f: 0x0001,
+	// Block 0x9e, offset 0x2780
+	0x2780: 0x0001, 0x2781: 0x0001, 0x2782: 0x0001, 0x2783: 0x0001, 0x2784: 0x0001, 0x2785: 0x0001,
+	0x2786: 0x0001, 0x2787: 0x0001, 0x2788: 0x0001, 0x2789: 0x0001, 0x278a: 0x0001, 0x278b: 0x0001,
+	0x278c: 0x0001, 0x278d: 0x0001, 0x278e: 0x0001, 0x278f: 0x0001, 0x2790: 0x0001, 0x2791: 0x0001,
+	0x2792: 0x0001, 0x2793: 0x0001, 0x2794: 0x0001, 0x2795: 0x0001, 0x2796: 0x0001, 0x2797: 0x0001,
+	0x2798: 0x0001, 0x2799: 0x0001, 0x279a: 0x0001, 0x279b: 0x0001, 0x279c: 0x0001, 0x279d: 0x0001,
+	0x279e: 0x0001, 0x279f: 0x000a, 0x27a0: 0x0001, 0x27a1: 0x0001, 0x27a2: 0x0001, 0x27a3: 0x0001,
+	0x27a4: 0x0001, 0x27a5: 0x0001, 0x27a6: 0x0001, 0x27a7: 0x0001, 0x27a8: 0x0001, 0x27a9: 0x0001,
+	0x27aa: 0x0001, 0x27ab: 0x0001, 0x27ac: 0x0001, 0x27ad: 0x0001, 0x27ae: 0x0001, 0x27af: 0x0001,
+	0x27b0: 0x0001, 0x27b1: 0x0001, 0x27b2: 0x0001, 0x27b3: 0x0001, 0x27b4: 0x0001, 0x27b5: 0x0001,
+	0x27b6: 0x0001, 0x27b7: 0x0001, 0x27b8: 0x0001, 0x27b9: 0x0001, 0x27ba: 0x0001, 0x27bb: 0x0001,
+	0x27bc: 0x0001, 0x27bd: 0x0001, 0x27be: 0x0001, 0x27bf: 0x0001,
+	// Block 0x9f, offset 0x27c0
+	0x27c0: 0x0001, 0x27c1: 0x000c, 0x27c2: 0x000c, 0x27c3: 0x000c, 0x27c4: 0x0001, 0x27c5: 0x000c,
+	0x27c6: 0x000c, 0x27c7: 0x0001, 0x27c8: 0x0001, 0x27c9: 0x0001, 0x27ca: 0x0001, 0x27cb: 0x0001,
+	0x27cc: 0x000c, 0x27cd: 0x000c, 0x27ce: 0x000c, 0x27cf: 0x000c, 0x27d0: 0x0001, 0x27d1: 0x0001,
+	0x27d2: 0x0001, 0x27d3: 0x0001, 0x27d4: 0x0001, 0x27d5: 0x0001, 0x27d6: 0x0001, 0x27d7: 0x0001,
+	0x27d8: 0x0001, 0x27d9: 0x0001, 0x27da: 0x0001, 0x27db: 0x0001, 0x27dc: 0x0001, 0x27dd: 0x0001,
+	0x27de: 0x0001, 0x27df: 0x0001, 0x27e0: 0x0001, 0x27e1: 0x0001, 0x27e2: 0x0001, 0x27e3: 0x0001,
+	0x27e4: 0x0001, 0x27e5: 0x0001, 0x27e6: 0x0001, 0x27e7: 0x0001, 0x27e8: 0x0001, 0x27e9: 0x0001,
+	0x27ea: 0x0001, 0x27eb: 0x0001, 0x27ec: 0x0001, 0x27ed: 0x0001, 0x27ee: 0x0001, 0x27ef: 0x0001,
+	0x27f0: 0x0001, 0x27f1: 0x0001, 0x27f2: 0x0001, 0x27f3: 0x0001, 0x27f4: 0x0001, 0x27f5: 0x0001,
+	0x27f6: 0x0001, 0x27f7: 0x0001, 0x27f8: 0x000c, 0x27f9: 0x000c, 0x27fa: 0x000c, 0x27fb: 0x0001,
+	0x27fc: 0x0001, 0x27fd: 0x0001, 0x27fe: 0x0001, 0x27ff: 0x000c,
+	// Block 0xa0, offset 0x2800
+	0x2800: 0x0001, 0x2801: 0x0001, 0x2802: 0x0001, 0x2803: 0x0001, 0x2804: 0x0001, 0x2805: 0x0001,
+	0x2806: 0x0001, 0x2807: 0x0001, 0x2808: 0x0001, 0x2809: 0x0001, 0x280a: 0x0001, 0x280b: 0x0001,
+	0x280c: 0x0001, 0x280d: 0x0001, 0x280e: 0x0001, 0x280f: 0x0001, 0x2810: 0x0001, 0x2811: 0x0001,
+	0x2812: 0x0001, 0x2813: 0x0001, 0x2814: 0x0001, 0x2815: 0x0001, 0x2816: 0x0001, 0x2817: 0x0001,
+	0x2818: 0x0001, 0x2819: 0x0001, 0x281a: 0x0001, 0x281b: 0x0001, 0x281c: 0x0001, 0x281d: 0x0001,
+	0x281e: 0x0001, 0x281f: 0x0001, 0x2820: 0x0001, 0x2821: 0x0001, 0x2822: 0x0001, 0x2823: 0x0001,
+	0x2824: 0x0001, 0x2825: 0x000c, 0x2826: 0x000c, 0x2827: 0x0001, 0x2828: 0x0001, 0x2829: 0x0001,
+	0x282a: 0x0001, 0x282b: 0x0001, 0x282c: 0x0001, 0x282d: 0x0001, 0x282e: 0x0001, 0x282f: 0x0001,
+	0x2830: 0x0001, 0x2831: 0x0001, 0x2832: 0x0001, 0x2833: 0x0001, 0x2834: 0x0001, 0x2835: 0x0001,
+	0x2836: 0x0001, 0x2837: 0x0001, 0x2838: 0x0001, 0x2839: 0x0001, 0x283a: 0x0001, 0x283b: 0x0001,
+	0x283c: 0x0001, 0x283d: 0x0001, 0x283e: 0x0001, 0x283f: 0x0001,
+	// Block 0xa1, offset 0x2840
+	0x2840: 0x0001, 0x2841: 0x0001, 0x2842: 0x0001, 0x2843: 0x0001, 0x2844: 0x0001, 0x2845: 0x0001,
+	0x2846: 0x0001, 0x2847: 0x0001, 0x2848: 0x0001, 0x2849: 0x0001, 0x284a: 0x0001, 0x284b: 0x0001,
+	0x284c: 0x0001, 0x284d: 0x0001, 0x284e: 0x0001, 0x284f: 0x0001, 0x2850: 0x0001, 0x2851: 0x0001,
+	0x2852: 0x0001, 0x2853: 0x0001, 0x2854: 0x0001, 0x2855: 0x0001, 0x2856: 0x0001, 0x2857: 0x0001,
+	0x2858: 0x0001, 0x2859: 0x0001, 0x285a: 0x0001, 0x285b: 0x0001, 0x285c: 0x0001, 0x285d: 0x0001,
+	0x285e: 0x0001, 0x285f: 0x0001, 0x2860: 0x0001, 0x2861: 0x0001, 0x2862: 0x0001, 0x2863: 0x0001,
+	0x2864: 0x0001, 0x2865: 0x0001, 0x2866: 0x0001, 0x2867: 0x0001, 0x2868: 0x0001, 0x2869: 0x0001,
+	0x286a: 0x0001, 0x286b: 0x0001, 0x286c: 0x0001, 0x286d: 0x0001, 0x286e: 0x0001, 0x286f: 0x0001,
+	0x2870: 0x0001, 0x2871: 0x0001, 0x2872: 0x0001, 0x2873: 0x0001, 0x2874: 0x0001, 0x2875: 0x0001,
+	0x2876: 0x0001, 0x2877: 0x0001, 0x2878: 0x0001, 0x2879: 0x000a, 0x287a: 0x000a, 0x287b: 0x000a,
+	0x287c: 0x000a, 0x287d: 0x000a, 0x287e: 0x000a, 0x287f: 0x000a,
+	// Block 0xa2, offset 0x2880
+	0x2880: 0x0001, 0x2881: 0x0001, 0x2882: 0x0001, 0x2883: 0x0001, 0x2884: 0x0001, 0x2885: 0x0001,
+	0x2886: 0x0001, 0x2887: 0x0001, 0x2888: 0x0001, 0x2889: 0x0001, 0x288a: 0x0001, 0x288b: 0x0001,
+	0x288c: 0x0001, 0x288d: 0x0001, 0x288e: 0x0001, 0x288f: 0x0001, 0x2890: 0x0001, 0x2891: 0x0001,
+	0x2892: 0x0001, 0x2893: 0x0001, 0x2894: 0x0001, 0x2895: 0x0001, 0x2896: 0x0001, 0x2897: 0x0001,
+	0x2898: 0x0001, 0x2899: 0x0001, 0x289a: 0x0001, 0x289b: 0x0001, 0x289c: 0x0001, 0x289d: 0x0001,
+	0x289e: 0x0001, 0x289f: 0x0001, 0x28a0: 0x0005, 0x28a1: 0x0005, 0x28a2: 0x0005, 0x28a3: 0x0005,
+	0x28a4: 0x0005, 0x28a5: 0x0005, 0x28a6: 0x0005, 0x28a7: 0x0005, 0x28a8: 0x0005, 0x28a9: 0x0005,
+	0x28aa: 0x0005, 0x28ab: 0x0005, 0x28ac: 0x0005, 0x28ad: 0x0005, 0x28ae: 0x0005, 0x28af: 0x0005,
+	0x28b0: 0x0005, 0x28b1: 0x0005, 0x28b2: 0x0005, 0x28b3: 0x0005, 0x28b4: 0x0005, 0x28b5: 0x0005,
+	0x28b6: 0x0005, 0x28b7: 0x0005, 0x28b8: 0x0005, 0x28b9: 0x0005, 0x28ba: 0x0005, 0x28bb: 0x0005,
+	0x28bc: 0x0005, 0x28bd: 0x0005, 0x28be: 0x0005, 0x28bf: 0x0001,
+	// Block 0xa3, offset 0x28c0
+	0x28c1: 0x000c,
+	0x28f8: 0x000c, 0x28f9: 0x000c, 0x28fa: 0x000c, 0x28fb: 0x000c,
+	0x28fc: 0x000c, 0x28fd: 0x000c, 0x28fe: 0x000c, 0x28ff: 0x000c,
+	// Block 0xa4, offset 0x2900
+	0x2900: 0x000c, 0x2901: 0x000c, 0x2902: 0x000c, 0x2903: 0x000c, 0x2904: 0x000c, 0x2905: 0x000c,
+	0x2906: 0x000c,
+	0x2912: 0x000a, 0x2913: 0x000a, 0x2914: 0x000a, 0x2915: 0x000a, 0x2916: 0x000a, 0x2917: 0x000a,
+	0x2918: 0x000a, 0x2919: 0x000a, 0x291a: 0x000a, 0x291b: 0x000a, 0x291c: 0x000a, 0x291d: 0x000a,
+	0x291e: 0x000a, 0x291f: 0x000a, 0x2920: 0x000a, 0x2921: 0x000a, 0x2922: 0x000a, 0x2923: 0x000a,
+	0x2924: 0x000a, 0x2925: 0x000a,
+	0x293f: 0x000c,
+	// Block 0xa5, offset 0x2940
+	0x2940: 0x000c, 0x2941: 0x000c,
+	0x2973: 0x000c, 0x2974: 0x000c, 0x2975: 0x000c,
+	0x2976: 0x000c, 0x2979: 0x000c, 0x297a: 0x000c,
+	// Block 0xa6, offset 0x2980
+	0x2980: 0x000c, 0x2981: 0x000c, 0x2982: 0x000c,
+	0x29a7: 0x000c, 0x29a8: 0x000c, 0x29a9: 0x000c,
+	0x29aa: 0x000c, 0x29ab: 0x000c, 0x29ad: 0x000c, 0x29ae: 0x000c, 0x29af: 0x000c,
+	0x29b0: 0x000c, 0x29b1: 0x000c, 0x29b2: 0x000c, 0x29b3: 0x000c, 0x29b4: 0x000c,
+	// Block 0xa7, offset 0x29c0
+	0x29f3: 0x000c,
+	// Block 0xa8, offset 0x2a00
+	0x2a00: 0x000c, 0x2a01: 0x000c,
+	0x2a36: 0x000c, 0x2a37: 0x000c, 0x2a38: 0x000c, 0x2a39: 0x000c, 0x2a3a: 0x000c, 0x2a3b: 0x000c,
+	0x2a3c: 0x000c, 0x2a3d: 0x000c, 0x2a3e: 0x000c,
+	// Block 0xa9, offset 0x2a40
+	0x2a4a: 0x000c, 0x2a4b: 0x000c,
+	0x2a4c: 0x000c,
+	// Block 0xaa, offset 0x2a80
+	0x2aaf: 0x000c,
+	0x2ab0: 0x000c, 0x2ab1: 0x000c, 0x2ab4: 0x000c,
+	0x2ab6: 0x000c, 0x2ab7: 0x000c,
+	0x2abe: 0x000c,
+	// Block 0xab, offset 0x2ac0
+	0x2adf: 0x000c, 0x2ae3: 0x000c,
+	0x2ae4: 0x000c, 0x2ae5: 0x000c, 0x2ae6: 0x000c, 0x2ae7: 0x000c, 0x2ae8: 0x000c, 0x2ae9: 0x000c,
+	0x2aea: 0x000c,
+	// Block 0xac, offset 0x2b00
+	0x2b00: 0x000c, 0x2b01: 0x000c,
+	0x2b3c: 0x000c,
+	// Block 0xad, offset 0x2b40
+	0x2b40: 0x000c,
+	0x2b66: 0x000c, 0x2b67: 0x000c, 0x2b68: 0x000c, 0x2b69: 0x000c,
+	0x2b6a: 0x000c, 0x2b6b: 0x000c, 0x2b6c: 0x000c,
+	0x2b70: 0x000c, 0x2b71: 0x000c, 0x2b72: 0x000c, 0x2b73: 0x000c, 0x2b74: 0x000c,
+	// Block 0xae, offset 0x2b80
+	0x2bb8: 0x000c, 0x2bb9: 0x000c, 0x2bba: 0x000c, 0x2bbb: 0x000c,
+	0x2bbc: 0x000c, 0x2bbd: 0x000c, 0x2bbe: 0x000c, 0x2bbf: 0x000c,
+	// Block 0xaf, offset 0x2bc0
+	0x2bc2: 0x000c, 0x2bc3: 0x000c, 0x2bc4: 0x000c,
+	0x2bc6: 0x000c,
+	// Block 0xb0, offset 0x2c00
+	0x2c33: 0x000c, 0x2c34: 0x000c, 0x2c35: 0x000c,
+	0x2c36: 0x000c, 0x2c37: 0x000c, 0x2c38: 0x000c, 0x2c3a: 0x000c,
+	0x2c3f: 0x000c,
+	// Block 0xb1, offset 0x2c40
+	0x2c40: 0x000c, 0x2c42: 0x000c, 0x2c43: 0x000c,
+	// Block 0xb2, offset 0x2c80
+	0x2cb2: 0x000c, 0x2cb3: 0x000c, 0x2cb4: 0x000c, 0x2cb5: 0x000c,
+	0x2cbc: 0x000c, 0x2cbd: 0x000c, 0x2cbf: 0x000c,
+	// Block 0xb3, offset 0x2cc0
+	0x2cc0: 0x000c,
+	0x2cdc: 0x000c, 0x2cdd: 0x000c,
+	// Block 0xb4, offset 0x2d00
+	0x2d33: 0x000c, 0x2d34: 0x000c, 0x2d35: 0x000c,
+	0x2d36: 0x000c, 0x2d37: 0x000c, 0x2d38: 0x000c, 0x2d39: 0x000c, 0x2d3a: 0x000c,
+	0x2d3d: 0x000c, 0x2d3f: 0x000c,
+	// Block 0xb5, offset 0x2d40
+	0x2d40: 0x000c,
+	0x2d60: 0x000a, 0x2d61: 0x000a, 0x2d62: 0x000a, 0x2d63: 0x000a,
+	0x2d64: 0x000a, 0x2d65: 0x000a, 0x2d66: 0x000a, 0x2d67: 0x000a, 0x2d68: 0x000a, 0x2d69: 0x000a,
+	0x2d6a: 0x000a, 0x2d6b: 0x000a, 0x2d6c: 0x000a,
+	// Block 0xb6, offset 0x2d80
+	0x2dab: 0x000c, 0x2dad: 0x000c,
+	0x2db0: 0x000c, 0x2db1: 0x000c, 0x2db2: 0x000c, 0x2db3: 0x000c, 0x2db4: 0x000c, 0x2db5: 0x000c,
+	0x2db7: 0x000c,
+	// Block 0xb7, offset 0x2dc0
+	0x2ddd: 0x000c,
+	0x2dde: 0x000c, 0x2ddf: 0x000c, 0x2de2: 0x000c, 0x2de3: 0x000c,
+	0x2de4: 0x000c, 0x2de5: 0x000c, 0x2de7: 0x000c, 0x2de8: 0x000c, 0x2de9: 0x000c,
+	0x2dea: 0x000c, 0x2deb: 0x000c,
+	// Block 0xb8, offset 0x2e00
+	0x2e30: 0x000c, 0x2e31: 0x000c, 0x2e32: 0x000c, 0x2e33: 0x000c, 0x2e34: 0x000c, 0x2e35: 0x000c,
+	0x2e36: 0x000c, 0x2e38: 0x000c, 0x2e39: 0x000c, 0x2e3a: 0x000c, 0x2e3b: 0x000c,
+	0x2e3c: 0x000c, 0x2e3d: 0x000c,
+	// Block 0xb9, offset 0x2e40
+	0x2e52: 0x000c, 0x2e53: 0x000c, 0x2e54: 0x000c, 0x2e55: 0x000c, 0x2e56: 0x000c, 0x2e57: 0x000c,
+	0x2e58: 0x000c, 0x2e59: 0x000c, 0x2e5a: 0x000c, 0x2e5b: 0x000c, 0x2e5c: 0x000c, 0x2e5d: 0x000c,
+	0x2e5e: 0x000c, 0x2e5f: 0x000c, 0x2e60: 0x000c, 0x2e61: 0x000c, 0x2e62: 0x000c, 0x2e63: 0x000c,
+	0x2e64: 0x000c, 0x2e65: 0x000c, 0x2e66: 0x000c, 0x2e67: 0x000c,
+	0x2e6a: 0x000c, 0x2e6b: 0x000c, 0x2e6c: 0x000c, 0x2e6d: 0x000c, 0x2e6e: 0x000c, 0x2e6f: 0x000c,
+	0x2e70: 0x000c, 0x2e72: 0x000c, 0x2e73: 0x000c, 0x2e75: 0x000c,
+	0x2e76: 0x000c,
+	// Block 0xba, offset 0x2e80
+	0x2eb0: 0x000c, 0x2eb1: 0x000c, 0x2eb2: 0x000c, 0x2eb3: 0x000c, 0x2eb4: 0x000c,
+	// Block 0xbb, offset 0x2ec0
+	0x2ef0: 0x000c, 0x2ef1: 0x000c, 0x2ef2: 0x000c, 0x2ef3: 0x000c, 0x2ef4: 0x000c, 0x2ef5: 0x000c,
+	0x2ef6: 0x000c,
+	// Block 0xbc, offset 0x2f00
+	0x2f0f: 0x000c, 0x2f10: 0x000c, 0x2f11: 0x000c,
+	0x2f12: 0x000c,
+	// Block 0xbd, offset 0x2f40
+	0x2f5d: 0x000c,
+	0x2f5e: 0x000c, 0x2f60: 0x000b, 0x2f61: 0x000b, 0x2f62: 0x000b, 0x2f63: 0x000b,
+	// Block 0xbe, offset 0x2f80
+	0x2fa7: 0x000c, 0x2fa8: 0x000c, 0x2fa9: 0x000c,
+	0x2fb3: 0x000b, 0x2fb4: 0x000b, 0x2fb5: 0x000b,
+	0x2fb6: 0x000b, 0x2fb7: 0x000b, 0x2fb8: 0x000b, 0x2fb9: 0x000b, 0x2fba: 0x000b, 0x2fbb: 0x000c,
+	0x2fbc: 0x000c, 0x2fbd: 0x000c, 0x2fbe: 0x000c, 0x2fbf: 0x000c,
+	// Block 0xbf, offset 0x2fc0
+	0x2fc0: 0x000c, 0x2fc1: 0x000c, 0x2fc2: 0x000c, 0x2fc5: 0x000c,
+	0x2fc6: 0x000c, 0x2fc7: 0x000c, 0x2fc8: 0x000c, 0x2fc9: 0x000c, 0x2fca: 0x000c, 0x2fcb: 0x000c,
+	0x2fea: 0x000c, 0x2feb: 0x000c, 0x2fec: 0x000c, 0x2fed: 0x000c,
+	// Block 0xc0, offset 0x3000
+	0x3000: 0x000a, 0x3001: 0x000a, 0x3002: 0x000c, 0x3003: 0x000c, 0x3004: 0x000c, 0x3005: 0x000a,
+	// Block 0xc1, offset 0x3040
+	0x3040: 0x000a, 0x3041: 0x000a, 0x3042: 0x000a, 0x3043: 0x000a, 0x3044: 0x000a, 0x3045: 0x000a,
+	0x3046: 0x000a, 0x3047: 0x000a, 0x3048: 0x000a, 0x3049: 0x000a, 0x304a: 0x000a, 0x304b: 0x000a,
+	0x304c: 0x000a, 0x304d: 0x000a, 0x304e: 0x000a, 0x304f: 0x000a, 0x3050: 0x000a, 0x3051: 0x000a,
+	0x3052: 0x000a, 0x3053: 0x000a, 0x3054: 0x000a, 0x3055: 0x000a, 0x3056: 0x000a,
+	// Block 0xc2, offset 0x3080
+	0x309b: 0x000a,
+	// Block 0xc3, offset 0x30c0
+	0x30d5: 0x000a,
+	// Block 0xc4, offset 0x3100
+	0x310f: 0x000a,
+	// Block 0xc5, offset 0x3140
+	0x3149: 0x000a,
+	// Block 0xc6, offset 0x3180
+	0x3183: 0x000a,
+	0x318e: 0x0002, 0x318f: 0x0002, 0x3190: 0x0002, 0x3191: 0x0002,
+	0x3192: 0x0002, 0x3193: 0x0002, 0x3194: 0x0002, 0x3195: 0x0002, 0x3196: 0x0002, 0x3197: 0x0002,
+	0x3198: 0x0002, 0x3199: 0x0002, 0x319a: 0x0002, 0x319b: 0x0002, 0x319c: 0x0002, 0x319d: 0x0002,
+	0x319e: 0x0002, 0x319f: 0x0002, 0x31a0: 0x0002, 0x31a1: 0x0002, 0x31a2: 0x0002, 0x31a3: 0x0002,
+	0x31a4: 0x0002, 0x31a5: 0x0002, 0x31a6: 0x0002, 0x31a7: 0x0002, 0x31a8: 0x0002, 0x31a9: 0x0002,
+	0x31aa: 0x0002, 0x31ab: 0x0002, 0x31ac: 0x0002, 0x31ad: 0x0002, 0x31ae: 0x0002, 0x31af: 0x0002,
+	0x31b0: 0x0002, 0x31b1: 0x0002, 0x31b2: 0x0002, 0x31b3: 0x0002, 0x31b4: 0x0002, 0x31b5: 0x0002,
+	0x31b6: 0x0002, 0x31b7: 0x0002, 0x31b8: 0x0002, 0x31b9: 0x0002, 0x31ba: 0x0002, 0x31bb: 0x0002,
+	0x31bc: 0x0002, 0x31bd: 0x0002, 0x31be: 0x0002, 0x31bf: 0x0002,
+	// Block 0xc7, offset 0x31c0
+	0x31c0: 0x000c, 0x31c1: 0x000c, 0x31c2: 0x000c, 0x31c3: 0x000c, 0x31c4: 0x000c, 0x31c5: 0x000c,
+	0x31c6: 0x000c, 0x31c7: 0x000c, 0x31c8: 0x000c, 0x31c9: 0x000c, 0x31ca: 0x000c, 0x31cb: 0x000c,
+	0x31cc: 0x000c, 0x31cd: 0x000c, 0x31ce: 0x000c, 0x31cf: 0x000c, 0x31d0: 0x000c, 0x31d1: 0x000c,
+	0x31d2: 0x000c, 0x31d3: 0x000c, 0x31d4: 0x000c, 0x31d5: 0x000c, 0x31d6: 0x000c, 0x31d7: 0x000c,
+	0x31d8: 0x000c, 0x31d9: 0x000c, 0x31da: 0x000c, 0x31db: 0x000c, 0x31dc: 0x000c, 0x31dd: 0x000c,
+	0x31de: 0x000c, 0x31df: 0x000c, 0x31e0: 0x000c, 0x31e1: 0x000c, 0x31e2: 0x000c, 0x31e3: 0x000c,
+	0x31e4: 0x000c, 0x31e5: 0x000c, 0x31e6: 0x000c, 0x31e7: 0x000c, 0x31e8: 0x000c, 0x31e9: 0x000c,
+	0x31ea: 0x000c, 0x31eb: 0x000c, 0x31ec: 0x000c, 0x31ed: 0x000c, 0x31ee: 0x000c, 0x31ef: 0x000c,
+	0x31f0: 0x000c, 0x31f1: 0x000c, 0x31f2: 0x000c, 0x31f3: 0x000c, 0x31f4: 0x000c, 0x31f5: 0x000c,
+	0x31f6: 0x000c, 0x31fb: 0x000c,
+	0x31fc: 0x000c, 0x31fd: 0x000c, 0x31fe: 0x000c, 0x31ff: 0x000c,
+	// Block 0xc8, offset 0x3200
+	0x3200: 0x000c, 0x3201: 0x000c, 0x3202: 0x000c, 0x3203: 0x000c, 0x3204: 0x000c, 0x3205: 0x000c,
+	0x3206: 0x000c, 0x3207: 0x000c, 0x3208: 0x000c, 0x3209: 0x000c, 0x320a: 0x000c, 0x320b: 0x000c,
+	0x320c: 0x000c, 0x320d: 0x000c, 0x320e: 0x000c, 0x320f: 0x000c, 0x3210: 0x000c, 0x3211: 0x000c,
+	0x3212: 0x000c, 0x3213: 0x000c, 0x3214: 0x000c, 0x3215: 0x000c, 0x3216: 0x000c, 0x3217: 0x000c,
+	0x3218: 0x000c, 0x3219: 0x000c, 0x321a: 0x000c, 0x321b: 0x000c, 0x321c: 0x000c, 0x321d: 0x000c,
+	0x321e: 0x000c, 0x321f: 0x000c, 0x3220: 0x000c, 0x3221: 0x000c, 0x3222: 0x000c, 0x3223: 0x000c,
+	0x3224: 0x000c, 0x3225: 0x000c, 0x3226: 0x000c, 0x3227: 0x000c, 0x3228: 0x000c, 0x3229: 0x000c,
+	0x322a: 0x000c, 0x322b: 0x000c, 0x322c: 0x000c,
+	0x3235: 0x000c,
+	// Block 0xc9, offset 0x3240
+	0x3244: 0x000c,
+	0x325b: 0x000c, 0x325c: 0x000c, 0x325d: 0x000c,
+	0x325e: 0x000c, 0x325f: 0x000c, 0x3261: 0x000c, 0x3262: 0x000c, 0x3263: 0x000c,
+	0x3264: 0x000c, 0x3265: 0x000c, 0x3266: 0x000c, 0x3267: 0x000c, 0x3268: 0x000c, 0x3269: 0x000c,
+	0x326a: 0x000c, 0x326b: 0x000c, 0x326c: 0x000c, 0x326d: 0x000c, 0x326e: 0x000c, 0x326f: 0x000c,
+	// Block 0xca, offset 0x3280
+	0x3280: 0x000c, 0x3281: 0x000c, 0x3282: 0x000c, 0x3283: 0x000c, 0x3284: 0x000c, 0x3285: 0x000c,
+	0x3286: 0x000c, 0x3288: 0x000c, 0x3289: 0x000c, 0x328a: 0x000c, 0x328b: 0x000c,
+	0x328c: 0x000c, 0x328d: 0x000c, 0x328e: 0x000c, 0x328f: 0x000c, 0x3290: 0x000c, 0x3291: 0x000c,
+	0x3292: 0x000c, 0x3293: 0x000c, 0x3294: 0x000c, 0x3295: 0x000c, 0x3296: 0x000c, 0x3297: 0x000c,
+	0x3298: 0x000c, 0x329b: 0x000c, 0x329c: 0x000c, 0x329d: 0x000c,
+	0x329e: 0x000c, 0x329f: 0x000c, 0x32a0: 0x000c, 0x32a1: 0x000c, 0x32a3: 0x000c,
+	0x32a4: 0x000c, 0x32a6: 0x000c, 0x32a7: 0x000c, 0x32a8: 0x000c, 0x32a9: 0x000c,
+	0x32aa: 0x000c,
+	// Block 0xcb, offset 0x32c0
+	0x32c0: 0x0001, 0x32c1: 0x0001, 0x32c2: 0x0001, 0x32c3: 0x0001, 0x32c4: 0x0001, 0x32c5: 0x0001,
+	0x32c6: 0x0001, 0x32c7: 0x0001, 0x32c8: 0x0001, 0x32c9: 0x0001, 0x32ca: 0x0001, 0x32cb: 0x0001,
+	0x32cc: 0x0001, 0x32cd: 0x0001, 0x32ce: 0x0001, 0x32cf: 0x0001, 0x32d0: 0x000c, 0x32d1: 0x000c,
+	0x32d2: 0x000c, 0x32d3: 0x000c, 0x32d4: 0x000c, 0x32d5: 0x000c, 0x32d6: 0x000c, 0x32d7: 0x0001,
+	0x32d8: 0x0001, 0x32d9: 0x0001, 0x32da: 0x0001, 0x32db: 0x0001, 0x32dc: 0x0001, 0x32dd: 0x0001,
+	0x32de: 0x0001, 0x32df: 0x0001, 0x32e0: 0x0001, 0x32e1: 0x0001, 0x32e2: 0x0001, 0x32e3: 0x0001,
+	0x32e4: 0x0001, 0x32e5: 0x0001, 0x32e6: 0x0001, 0x32e7: 0x0001, 0x32e8: 0x0001, 0x32e9: 0x0001,
+	0x32ea: 0x0001, 0x32eb: 0x0001, 0x32ec: 0x0001, 0x32ed: 0x0001, 0x32ee: 0x0001, 0x32ef: 0x0001,
+	0x32f0: 0x0001, 0x32f1: 0x0001, 0x32f2: 0x0001, 0x32f3: 0x0001, 0x32f4: 0x0001, 0x32f5: 0x0001,
+	0x32f6: 0x0001, 0x32f7: 0x0001, 0x32f8: 0x0001, 0x32f9: 0x0001, 0x32fa: 0x0001, 0x32fb: 0x0001,
+	0x32fc: 0x0001, 0x32fd: 0x0001, 0x32fe: 0x0001, 0x32ff: 0x0001,
+	// Block 0xcc, offset 0x3300
+	0x3300: 0x0001, 0x3301: 0x0001, 0x3302: 0x0001, 0x3303: 0x0001, 0x3304: 0x000c, 0x3305: 0x000c,
+	0x3306: 0x000c, 0x3307: 0x000c, 0x3308: 0x000c, 0x3309: 0x000c, 0x330a: 0x000c, 0x330b: 0x0001,
+	0x330c: 0x0001, 0x330d: 0x0001, 0x330e: 0x0001, 0x330f: 0x0001, 0x3310: 0x0001, 0x3311: 0x0001,
+	0x3312: 0x0001, 0x3313: 0x0001, 0x3314: 0x0001, 0x3315: 0x0001, 0x3316: 0x0001, 0x3317: 0x0001,
+	0x3318: 0x0001, 0x3319: 0x0001, 0x331a: 0x0001, 0x331b: 0x0001, 0x331c: 0x0001, 0x331d: 0x0001,
+	0x331e: 0x0001, 0x331f: 0x0001, 0x3320: 0x0001, 0x3321: 0x0001, 0x3322: 0x0001, 0x3323: 0x0001,
+	0x3324: 0x0001, 0x3325: 0x0001, 0x3326: 0x0001, 0x3327: 0x0001, 0x3328: 0x0001, 0x3329: 0x0001,
+	0x332a: 0x0001, 0x332b: 0x0001, 0x332c: 0x0001, 0x332d: 0x0001, 0x332e: 0x0001, 0x332f: 0x0001,
+	0x3330: 0x0001, 0x3331: 0x0001, 0x3332: 0x0001, 0x3333: 0x0001, 0x3334: 0x0001, 0x3335: 0x0001,
+	0x3336: 0x0001, 0x3337: 0x0001, 0x3338: 0x0001, 0x3339: 0x0001, 0x333a: 0x0001, 0x333b: 0x0001,
+	0x333c: 0x0001, 0x333d: 0x0001, 0x333e: 0x0001, 0x333f: 0x0001,
+	// Block 0xcd, offset 0x3340
+	0x3340: 0x000d, 0x3341: 0x000d, 0x3342: 0x000d, 0x3343: 0x000d, 0x3344: 0x000d, 0x3345: 0x000d,
+	0x3346: 0x000d, 0x3347: 0x000d, 0x3348: 0x000d, 0x3349: 0x000d, 0x334a: 0x000d, 0x334b: 0x000d,
+	0x334c: 0x000d, 0x334d: 0x000d, 0x334e: 0x000d, 0x334f: 0x000d, 0x3350: 0x000d, 0x3351: 0x000d,
+	0x3352: 0x000d, 0x3353: 0x000d, 0x3354: 0x000d, 0x3355: 0x000d, 0x3356: 0x000d, 0x3357: 0x000d,
+	0x3358: 0x000d, 0x3359: 0x000d, 0x335a: 0x000d, 0x335b: 0x000d, 0x335c: 0x000d, 0x335d: 0x000d,
+	0x335e: 0x000d, 0x335f: 0x000d, 0x3360: 0x000d, 0x3361: 0x000d, 0x3362: 0x000d, 0x3363: 0x000d,
+	0x3364: 0x000d, 0x3365: 0x000d, 0x3366: 0x000d, 0x3367: 0x000d, 0x3368: 0x000d, 0x3369: 0x000d,
+	0x336a: 0x000d, 0x336b: 0x000d, 0x336c: 0x000d, 0x336d: 0x000d, 0x336e: 0x000d, 0x336f: 0x000d,
+	0x3370: 0x000a, 0x3371: 0x000a, 0x3372: 0x000d, 0x3373: 0x000d, 0x3374: 0x000d, 0x3375: 0x000d,
+	0x3376: 0x000d, 0x3377: 0x000d, 0x3378: 0x000d, 0x3379: 0x000d, 0x337a: 0x000d, 0x337b: 0x000d,
+	0x337c: 0x000d, 0x337d: 0x000d, 0x337e: 0x000d, 0x337f: 0x000d,
+	// Block 0xce, offset 0x3380
+	0x3380: 0x000a, 0x3381: 0x000a, 0x3382: 0x000a, 0x3383: 0x000a, 0x3384: 0x000a, 0x3385: 0x000a,
+	0x3386: 0x000a, 0x3387: 0x000a, 0x3388: 0x000a, 0x3389: 0x000a, 0x338a: 0x000a, 0x338b: 0x000a,
+	0x338c: 0x000a, 0x338d: 0x000a, 0x338e: 0x000a, 0x338f: 0x000a, 0x3390: 0x000a, 0x3391: 0x000a,
+	0x3392: 0x000a, 0x3393: 0x000a, 0x3394: 0x000a, 0x3395: 0x000a, 0x3396: 0x000a, 0x3397: 0x000a,
+	0x3398: 0x000a, 0x3399: 0x000a, 0x339a: 0x000a, 0x339b: 0x000a, 0x339c: 0x000a, 0x339d: 0x000a,
+	0x339e: 0x000a, 0x339f: 0x000a, 0x33a0: 0x000a, 0x33a1: 0x000a, 0x33a2: 0x000a, 0x33a3: 0x000a,
+	0x33a4: 0x000a, 0x33a5: 0x000a, 0x33a6: 0x000a, 0x33a7: 0x000a, 0x33a8: 0x000a, 0x33a9: 0x000a,
+	0x33aa: 0x000a, 0x33ab: 0x000a,
+	0x33b0: 0x000a, 0x33b1: 0x000a, 0x33b2: 0x000a, 0x33b3: 0x000a, 0x33b4: 0x000a, 0x33b5: 0x000a,
+	0x33b6: 0x000a, 0x33b7: 0x000a, 0x33b8: 0x000a, 0x33b9: 0x000a, 0x33ba: 0x000a, 0x33bb: 0x000a,
+	0x33bc: 0x000a, 0x33bd: 0x000a, 0x33be: 0x000a, 0x33bf: 0x000a,
+	// Block 0xcf, offset 0x33c0
+	0x33c0: 0x000a, 0x33c1: 0x000a, 0x33c2: 0x000a, 0x33c3: 0x000a, 0x33c4: 0x000a, 0x33c5: 0x000a,
+	0x33c6: 0x000a, 0x33c7: 0x000a, 0x33c8: 0x000a, 0x33c9: 0x000a, 0x33ca: 0x000a, 0x33cb: 0x000a,
+	0x33cc: 0x000a, 0x33cd: 0x000a, 0x33ce: 0x000a, 0x33cf: 0x000a, 0x33d0: 0x000a, 0x33d1: 0x000a,
+	0x33d2: 0x000a, 0x33d3: 0x000a,
+	0x33e0: 0x000a, 0x33e1: 0x000a, 0x33e2: 0x000a, 0x33e3: 0x000a,
+	0x33e4: 0x000a, 0x33e5: 0x000a, 0x33e6: 0x000a, 0x33e7: 0x000a, 0x33e8: 0x000a, 0x33e9: 0x000a,
+	0x33ea: 0x000a, 0x33eb: 0x000a, 0x33ec: 0x000a, 0x33ed: 0x000a, 0x33ee: 0x000a,
+	0x33f1: 0x000a, 0x33f2: 0x000a, 0x33f3: 0x000a, 0x33f4: 0x000a, 0x33f5: 0x000a,
+	0x33f6: 0x000a, 0x33f7: 0x000a, 0x33f8: 0x000a, 0x33f9: 0x000a, 0x33fa: 0x000a, 0x33fb: 0x000a,
+	0x33fc: 0x000a, 0x33fd: 0x000a, 0x33fe: 0x000a, 0x33ff: 0x000a,
+	// Block 0xd0, offset 0x3400
+	0x3401: 0x000a, 0x3402: 0x000a, 0x3403: 0x000a, 0x3404: 0x000a, 0x3405: 0x000a,
+	0x3406: 0x000a, 0x3407: 0x000a, 0x3408: 0x000a, 0x3409: 0x000a, 0x340a: 0x000a, 0x340b: 0x000a,
+	0x340c: 0x000a, 0x340d: 0x000a, 0x340e: 0x000a, 0x340f: 0x000a, 0x3411: 0x000a,
+	0x3412: 0x000a, 0x3413: 0x000a, 0x3414: 0x000a, 0x3415: 0x000a, 0x3416: 0x000a, 0x3417: 0x000a,
+	0x3418: 0x000a, 0x3419: 0x000a, 0x341a: 0x000a, 0x341b: 0x000a, 0x341c: 0x000a, 0x341d: 0x000a,
+	0x341e: 0x000a, 0x341f: 0x000a, 0x3420: 0x000a, 0x3421: 0x000a, 0x3422: 0x000a, 0x3423: 0x000a,
+	0x3424: 0x000a, 0x3425: 0x000a, 0x3426: 0x000a, 0x3427: 0x000a, 0x3428: 0x000a, 0x3429: 0x000a,
+	0x342a: 0x000a, 0x342b: 0x000a, 0x342c: 0x000a, 0x342d: 0x000a, 0x342e: 0x000a, 0x342f: 0x000a,
+	0x3430: 0x000a, 0x3431: 0x000a, 0x3432: 0x000a, 0x3433: 0x000a, 0x3434: 0x000a, 0x3435: 0x000a,
+	// Block 0xd1, offset 0x3440
+	0x3440: 0x0002, 0x3441: 0x0002, 0x3442: 0x0002, 0x3443: 0x0002, 0x3444: 0x0002, 0x3445: 0x0002,
+	0x3446: 0x0002, 0x3447: 0x0002, 0x3448: 0x0002, 0x3449: 0x0002, 0x344a: 0x0002, 0x344b: 0x000a,
+	0x344c: 0x000a,
+	// Block 0xd2, offset 0x3480
+	0x34aa: 0x000a, 0x34ab: 0x000a,
+	// Block 0xd3, offset 0x34c0
+	0x34c0: 0x000a, 0x34c1: 0x000a, 0x34c2: 0x000a, 0x34c3: 0x000a, 0x34c4: 0x000a, 0x34c5: 0x000a,
+	0x34c6: 0x000a, 0x34c7: 0x000a, 0x34c8: 0x000a, 0x34c9: 0x000a, 0x34ca: 0x000a, 0x34cb: 0x000a,
+	0x34cc: 0x000a, 0x34cd: 0x000a, 0x34ce: 0x000a, 0x34cf: 0x000a, 0x34d0: 0x000a, 0x34d1: 0x000a,
+	0x34d2: 0x000a,
+	0x34e0: 0x000a, 0x34e1: 0x000a, 0x34e2: 0x000a, 0x34e3: 0x000a,
+	0x34e4: 0x000a, 0x34e5: 0x000a, 0x34e6: 0x000a, 0x34e7: 0x000a, 0x34e8: 0x000a, 0x34e9: 0x000a,
+	0x34ea: 0x000a, 0x34eb: 0x000a, 0x34ec: 0x000a,
+	0x34f0: 0x000a, 0x34f1: 0x000a, 0x34f2: 0x000a, 0x34f3: 0x000a, 0x34f4: 0x000a, 0x34f5: 0x000a,
+	0x34f6: 0x000a,
+	// Block 0xd4, offset 0x3500
+	0x3500: 0x000a, 0x3501: 0x000a, 0x3502: 0x000a, 0x3503: 0x000a, 0x3504: 0x000a, 0x3505: 0x000a,
+	0x3506: 0x000a, 0x3507: 0x000a, 0x3508: 0x000a, 0x3509: 0x000a, 0x350a: 0x000a, 0x350b: 0x000a,
+	0x350c: 0x000a, 0x350d: 0x000a, 0x350e: 0x000a, 0x350f: 0x000a, 0x3510: 0x000a, 0x3511: 0x000a,
+	0x3512: 0x000a, 0x3513: 0x000a, 0x3514: 0x000a,
+	// Block 0xd5, offset 0x3540
+	0x3540: 0x000a, 0x3541: 0x000a, 0x3542: 0x000a, 0x3543: 0x000a, 0x3544: 0x000a, 0x3545: 0x000a,
+	0x3546: 0x000a, 0x3547: 0x000a, 0x3548: 0x000a, 0x3549: 0x000a, 0x354a: 0x000a, 0x354b: 0x000a,
+	0x3550: 0x000a, 0x3551: 0x000a,
+	0x3552: 0x000a, 0x3553: 0x000a, 0x3554: 0x000a, 0x3555: 0x000a, 0x3556: 0x000a, 0x3557: 0x000a,
+	0x3558: 0x000a, 0x3559: 0x000a, 0x355a: 0x000a, 0x355b: 0x000a, 0x355c: 0x000a, 0x355d: 0x000a,
+	0x355e: 0x000a, 0x355f: 0x000a, 0x3560: 0x000a, 0x3561: 0x000a, 0x3562: 0x000a, 0x3563: 0x000a,
+	0x3564: 0x000a, 0x3565: 0x000a, 0x3566: 0x000a, 0x3567: 0x000a, 0x3568: 0x000a, 0x3569: 0x000a,
+	0x356a: 0x000a, 0x356b: 0x000a, 0x356c: 0x000a, 0x356d: 0x000a, 0x356e: 0x000a, 0x356f: 0x000a,
+	0x3570: 0x000a, 0x3571: 0x000a, 0x3572: 0x000a, 0x3573: 0x000a, 0x3574: 0x000a, 0x3575: 0x000a,
+	0x3576: 0x000a, 0x3577: 0x000a, 0x3578: 0x000a, 0x3579: 0x000a, 0x357a: 0x000a, 0x357b: 0x000a,
+	0x357c: 0x000a, 0x357d: 0x000a, 0x357e: 0x000a, 0x357f: 0x000a,
+	// Block 0xd6, offset 0x3580
+	0x3580: 0x000a, 0x3581: 0x000a, 0x3582: 0x000a, 0x3583: 0x000a, 0x3584: 0x000a, 0x3585: 0x000a,
+	0x3586: 0x000a, 0x3587: 0x000a,
+	0x3590: 0x000a, 0x3591: 0x000a,
+	0x3592: 0x000a, 0x3593: 0x000a, 0x3594: 0x000a, 0x3595: 0x000a, 0x3596: 0x000a, 0x3597: 0x000a,
+	0x3598: 0x000a, 0x3599: 0x000a,
+	0x35a0: 0x000a, 0x35a1: 0x000a, 0x35a2: 0x000a, 0x35a3: 0x000a,
+	0x35a4: 0x000a, 0x35a5: 0x000a, 0x35a6: 0x000a, 0x35a7: 0x000a, 0x35a8: 0x000a, 0x35a9: 0x000a,
+	0x35aa: 0x000a, 0x35ab: 0x000a, 0x35ac: 0x000a, 0x35ad: 0x000a, 0x35ae: 0x000a, 0x35af: 0x000a,
+	0x35b0: 0x000a, 0x35b1: 0x000a, 0x35b2: 0x000a, 0x35b3: 0x000a, 0x35b4: 0x000a, 0x35b5: 0x000a,
+	0x35b6: 0x000a, 0x35b7: 0x000a, 0x35b8: 0x000a, 0x35b9: 0x000a, 0x35ba: 0x000a, 0x35bb: 0x000a,
+	0x35bc: 0x000a, 0x35bd: 0x000a, 0x35be: 0x000a, 0x35bf: 0x000a,
+	// Block 0xd7, offset 0x35c0
+	0x35c0: 0x000a, 0x35c1: 0x000a, 0x35c2: 0x000a, 0x35c3: 0x000a, 0x35c4: 0x000a, 0x35c5: 0x000a,
+	0x35c6: 0x000a, 0x35c7: 0x000a,
+	0x35d0: 0x000a, 0x35d1: 0x000a,
+	0x35d2: 0x000a, 0x35d3: 0x000a, 0x35d4: 0x000a, 0x35d5: 0x000a, 0x35d6: 0x000a, 0x35d7: 0x000a,
+	0x35d8: 0x000a, 0x35d9: 0x000a, 0x35da: 0x000a, 0x35db: 0x000a, 0x35dc: 0x000a, 0x35dd: 0x000a,
+	0x35de: 0x000a, 0x35df: 0x000a, 0x35e0: 0x000a, 0x35e1: 0x000a, 0x35e2: 0x000a, 0x35e3: 0x000a,
+	0x35e4: 0x000a, 0x35e5: 0x000a, 0x35e6: 0x000a, 0x35e7: 0x000a, 0x35e8: 0x000a, 0x35e9: 0x000a,
+	0x35ea: 0x000a, 0x35eb: 0x000a, 0x35ec: 0x000a, 0x35ed: 0x000a,
+	// Block 0xd8, offset 0x3600
+	0x3610: 0x000a, 0x3611: 0x000a,
+	0x3612: 0x000a, 0x3613: 0x000a, 0x3614: 0x000a, 0x3615: 0x000a, 0x3616: 0x000a, 0x3617: 0x000a,
+	0x3618: 0x000a, 0x3619: 0x000a, 0x361a: 0x000a, 0x361b: 0x000a, 0x361c: 0x000a, 0x361d: 0x000a,
+	0x361e: 0x000a, 0x3620: 0x000a, 0x3621: 0x000a, 0x3622: 0x000a, 0x3623: 0x000a,
+	0x3624: 0x000a, 0x3625: 0x000a, 0x3626: 0x000a, 0x3627: 0x000a,
+	0x3630: 0x000a, 0x3633: 0x000a, 0x3634: 0x000a, 0x3635: 0x000a,
+	0x3636: 0x000a, 0x3637: 0x000a, 0x3638: 0x000a, 0x3639: 0x000a, 0x363a: 0x000a, 0x363b: 0x000a,
+	0x363c: 0x000a, 0x363d: 0x000a, 0x363e: 0x000a,
+	// Block 0xd9, offset 0x3640
+	0x3640: 0x000a, 0x3641: 0x000a, 0x3642: 0x000a, 0x3643: 0x000a, 0x3644: 0x000a, 0x3645: 0x000a,
+	0x3646: 0x000a, 0x3647: 0x000a, 0x3648: 0x000a, 0x3649: 0x000a, 0x364a: 0x000a, 0x364b: 0x000a,
+	0x3650: 0x000a, 0x3651: 0x000a,
+	0x3652: 0x000a, 0x3653: 0x000a, 0x3654: 0x000a, 0x3655: 0x000a, 0x3656: 0x000a, 0x3657: 0x000a,
+	0x3658: 0x000a, 0x3659: 0x000a, 0x365a: 0x000a, 0x365b: 0x000a, 0x365c: 0x000a, 0x365d: 0x000a,
+	0x365e: 0x000a,
+	// Block 0xda, offset 0x3680
+	0x3680: 0x000a, 0x3681: 0x000a, 0x3682: 0x000a, 0x3683: 0x000a, 0x3684: 0x000a, 0x3685: 0x000a,
+	0x3686: 0x000a, 0x3687: 0x000a, 0x3688: 0x000a, 0x3689: 0x000a, 0x368a: 0x000a, 0x368b: 0x000a,
+	0x368c: 0x000a, 0x368d: 0x000a, 0x368e: 0x000a, 0x368f: 0x000a, 0x3690: 0x000a, 0x3691: 0x000a,
+	// Block 0xdb, offset 0x36c0
+	0x36fe: 0x000b, 0x36ff: 0x000b,
+	// Block 0xdc, offset 0x3700
+	0x3700: 0x000b, 0x3701: 0x000b, 0x3702: 0x000b, 0x3703: 0x000b, 0x3704: 0x000b, 0x3705: 0x000b,
+	0x3706: 0x000b, 0x3707: 0x000b, 0x3708: 0x000b, 0x3709: 0x000b, 0x370a: 0x000b, 0x370b: 0x000b,
+	0x370c: 0x000b, 0x370d: 0x000b, 0x370e: 0x000b, 0x370f: 0x000b, 0x3710: 0x000b, 0x3711: 0x000b,
+	0x3712: 0x000b, 0x3713: 0x000b, 0x3714: 0x000b, 0x3715: 0x000b, 0x3716: 0x000b, 0x3717: 0x000b,
+	0x3718: 0x000b, 0x3719: 0x000b, 0x371a: 0x000b, 0x371b: 0x000b, 0x371c: 0x000b, 0x371d: 0x000b,
+	0x371e: 0x000b, 0x371f: 0x000b, 0x3720: 0x000b, 0x3721: 0x000b, 0x3722: 0x000b, 0x3723: 0x000b,
+	0x3724: 0x000b, 0x3725: 0x000b, 0x3726: 0x000b, 0x3727: 0x000b, 0x3728: 0x000b, 0x3729: 0x000b,
+	0x372a: 0x000b, 0x372b: 0x000b, 0x372c: 0x000b, 0x372d: 0x000b, 0x372e: 0x000b, 0x372f: 0x000b,
+	0x3730: 0x000b, 0x3731: 0x000b, 0x3732: 0x000b, 0x3733: 0x000b, 0x3734: 0x000b, 0x3735: 0x000b,
+	0x3736: 0x000b, 0x3737: 0x000b, 0x3738: 0x000b, 0x3739: 0x000b, 0x373a: 0x000b, 0x373b: 0x000b,
+	0x373c: 0x000b, 0x373d: 0x000b, 0x373e: 0x000b, 0x373f: 0x000b,
+	// Block 0xdd, offset 0x3740
+	0x3740: 0x000c, 0x3741: 0x000c, 0x3742: 0x000c, 0x3743: 0x000c, 0x3744: 0x000c, 0x3745: 0x000c,
+	0x3746: 0x000c, 0x3747: 0x000c, 0x3748: 0x000c, 0x3749: 0x000c, 0x374a: 0x000c, 0x374b: 0x000c,
+	0x374c: 0x000c, 0x374d: 0x000c, 0x374e: 0x000c, 0x374f: 0x000c, 0x3750: 0x000c, 0x3751: 0x000c,
+	0x3752: 0x000c, 0x3753: 0x000c, 0x3754: 0x000c, 0x3755: 0x000c, 0x3756: 0x000c, 0x3757: 0x000c,
+	0x3758: 0x000c, 0x3759: 0x000c, 0x375a: 0x000c, 0x375b: 0x000c, 0x375c: 0x000c, 0x375d: 0x000c,
+	0x375e: 0x000c, 0x375f: 0x000c, 0x3760: 0x000c, 0x3761: 0x000c, 0x3762: 0x000c, 0x3763: 0x000c,
+	0x3764: 0x000c, 0x3765: 0x000c, 0x3766: 0x000c, 0x3767: 0x000c, 0x3768: 0x000c, 0x3769: 0x000c,
+	0x376a: 0x000c, 0x376b: 0x000c, 0x376c: 0x000c, 0x376d: 0x000c, 0x376e: 0x000c, 0x376f: 0x000c,
+	0x3770: 0x000b, 0x3771: 0x000b, 0x3772: 0x000b, 0x3773: 0x000b, 0x3774: 0x000b, 0x3775: 0x000b,
+	0x3776: 0x000b, 0x3777: 0x000b, 0x3778: 0x000b, 0x3779: 0x000b, 0x377a: 0x000b, 0x377b: 0x000b,
+	0x377c: 0x000b, 0x377d: 0x000b, 0x377e: 0x000b, 0x377f: 0x000b,
+}
+
+// bidiIndex: 24 blocks, 1536 entries, 1536 bytes
+// Block 0 is the zero block.
+var bidiIndex = [1536]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x01, 0xc3: 0x02,
+	0xca: 0x03, 0xcb: 0x04, 0xcc: 0x05, 0xcd: 0x06, 0xce: 0x07, 0xcf: 0x08,
+	0xd2: 0x09, 0xd6: 0x0a, 0xd7: 0x0b,
+	0xd8: 0x0c, 0xd9: 0x0d, 0xda: 0x0e, 0xdb: 0x0f, 0xdc: 0x10, 0xdd: 0x11, 0xde: 0x12, 0xdf: 0x13,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05, 0xe4: 0x06,
+	0xea: 0x07, 0xef: 0x08,
+	0xf0: 0x11, 0xf1: 0x12, 0xf2: 0x12, 0xf3: 0x14, 0xf4: 0x15,
+	// Block 0x4, offset 0x100
+	0x120: 0x14, 0x121: 0x15, 0x122: 0x16, 0x123: 0x17, 0x124: 0x18, 0x125: 0x19, 0x126: 0x1a, 0x127: 0x1b,
+	0x128: 0x1c, 0x129: 0x1d, 0x12a: 0x1c, 0x12b: 0x1e, 0x12c: 0x1f, 0x12d: 0x20, 0x12e: 0x21, 0x12f: 0x22,
+	0x130: 0x23, 0x131: 0x24, 0x132: 0x1a, 0x133: 0x25, 0x134: 0x26, 0x135: 0x27, 0x137: 0x28,
+	0x138: 0x29, 0x139: 0x2a, 0x13a: 0x2b, 0x13b: 0x2c, 0x13c: 0x2d, 0x13d: 0x2e, 0x13e: 0x2f, 0x13f: 0x30,
+	// Block 0x5, offset 0x140
+	0x140: 0x31, 0x141: 0x32, 0x142: 0x33,
+	0x14d: 0x34, 0x14e: 0x35,
+	0x150: 0x36,
+	0x15a: 0x37, 0x15c: 0x38, 0x15d: 0x39, 0x15e: 0x3a, 0x15f: 0x3b,
+	0x160: 0x3c, 0x162: 0x3d, 0x164: 0x3e, 0x165: 0x3f, 0x167: 0x40,
+	0x168: 0x41, 0x169: 0x42, 0x16a: 0x43, 0x16c: 0x44, 0x16d: 0x45, 0x16e: 0x46, 0x16f: 0x47,
+	0x170: 0x48, 0x173: 0x49, 0x177: 0x4a,
+	0x17e: 0x4b, 0x17f: 0x4c,
+	// Block 0x6, offset 0x180
+	0x180: 0x4d, 0x181: 0x4e, 0x182: 0x4f, 0x183: 0x50, 0x184: 0x51, 0x185: 0x52, 0x186: 0x53, 0x187: 0x54,
+	0x188: 0x55, 0x189: 0x54, 0x18a: 0x54, 0x18b: 0x54, 0x18c: 0x56, 0x18d: 0x57, 0x18e: 0x58, 0x18f: 0x59,
+	0x190: 0x5a, 0x191: 0x5b, 0x192: 0x5c, 0x193: 0x5d, 0x194: 0x54, 0x195: 0x54, 0x196: 0x54, 0x197: 0x54,
+	0x198: 0x54, 0x199: 0x54, 0x19a: 0x5e, 0x19b: 0x54, 0x19c: 0x54, 0x19d: 0x5f, 0x19e: 0x54, 0x19f: 0x60,
+	0x1a4: 0x54, 0x1a5: 0x54, 0x1a6: 0x61, 0x1a7: 0x62,
+	0x1a8: 0x54, 0x1a9: 0x54, 0x1aa: 0x54, 0x1ab: 0x54, 0x1ac: 0x54, 0x1ad: 0x63, 0x1ae: 0x64, 0x1af: 0x65,
+	0x1b3: 0x66, 0x1b5: 0x67, 0x1b7: 0x68,
+	0x1b8: 0x69, 0x1b9: 0x6a, 0x1ba: 0x6b, 0x1bb: 0x6c, 0x1bc: 0x54, 0x1bd: 0x54, 0x1be: 0x54, 0x1bf: 0x6d,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x6e, 0x1c2: 0x6f, 0x1c3: 0x70, 0x1c7: 0x71,
+	0x1c8: 0x72, 0x1c9: 0x73, 0x1ca: 0x74, 0x1cb: 0x75, 0x1cd: 0x76, 0x1cf: 0x77,
+	// Block 0x8, offset 0x200
+	0x237: 0x54,
+	// Block 0x9, offset 0x240
+	0x252: 0x78, 0x253: 0x79,
+	0x258: 0x7a, 0x259: 0x7b, 0x25a: 0x7c, 0x25b: 0x7d, 0x25c: 0x7e, 0x25e: 0x7f,
+	0x260: 0x80, 0x261: 0x81, 0x263: 0x82, 0x264: 0x83, 0x265: 0x84, 0x266: 0x85, 0x267: 0x86,
+	0x268: 0x87, 0x269: 0x88, 0x26a: 0x89, 0x26b: 0x8a, 0x26f: 0x8b,
+	// Block 0xa, offset 0x280
+	0x2ac: 0x8c, 0x2ad: 0x8d, 0x2ae: 0x0e, 0x2af: 0x0e,
+	0x2b0: 0x0e, 0x2b1: 0x0e, 0x2b2: 0x0e, 0x2b3: 0x0e, 0x2b4: 0x8e, 0x2b5: 0x0e, 0x2b6: 0x0e, 0x2b7: 0x8f,
+	0x2b8: 0x90, 0x2b9: 0x91, 0x2ba: 0x0e, 0x2bb: 0x92, 0x2bc: 0x93, 0x2bd: 0x94, 0x2bf: 0x95,
+	// Block 0xb, offset 0x2c0
+	0x2c4: 0x96, 0x2c5: 0x54, 0x2c6: 0x97, 0x2c7: 0x98,
+	0x2cb: 0x99, 0x2cd: 0x9a,
+	0x2e0: 0x9b, 0x2e1: 0x9b, 0x2e2: 0x9b, 0x2e3: 0x9b, 0x2e4: 0x9c, 0x2e5: 0x9b, 0x2e6: 0x9b, 0x2e7: 0x9b,
+	0x2e8: 0x9d, 0x2e9: 0x9b, 0x2ea: 0x9b, 0x2eb: 0x9e, 0x2ec: 0x9f, 0x2ed: 0x9b, 0x2ee: 0x9b, 0x2ef: 0x9b,
+	0x2f0: 0x9b, 0x2f1: 0x9b, 0x2f2: 0x9b, 0x2f3: 0x9b, 0x2f4: 0x9b, 0x2f5: 0x9b, 0x2f6: 0x9b, 0x2f7: 0x9b,
+	0x2f8: 0x9b, 0x2f9: 0xa0, 0x2fa: 0x9b, 0x2fb: 0x9b, 0x2fc: 0x9b, 0x2fd: 0x9b, 0x2fe: 0x9b, 0x2ff: 0x9b,
+	// Block 0xc, offset 0x300
+	0x300: 0xa1, 0x301: 0xa2, 0x302: 0xa3, 0x304: 0xa4, 0x305: 0xa5, 0x306: 0xa6, 0x307: 0xa7,
+	0x308: 0xa8, 0x30b: 0xa9, 0x30c: 0xaa, 0x30d: 0xab,
+	0x310: 0xac, 0x311: 0xad, 0x312: 0xae, 0x313: 0xaf, 0x316: 0xb0, 0x317: 0xb1,
+	0x318: 0xb2, 0x319: 0xb3, 0x31a: 0xb4, 0x31c: 0xb5,
+	0x330: 0xb6, 0x332: 0xb7,
+	// Block 0xd, offset 0x340
+	0x36b: 0xb8, 0x36c: 0xb9,
+	0x37e: 0xba,
+	// Block 0xe, offset 0x380
+	0x3b2: 0xbb,
+	// Block 0xf, offset 0x3c0
+	0x3c5: 0xbc, 0x3c6: 0xbd,
+	0x3c8: 0x54, 0x3c9: 0xbe, 0x3cc: 0x54, 0x3cd: 0xbf,
+	0x3db: 0xc0, 0x3dc: 0xc1, 0x3dd: 0xc2, 0x3de: 0xc3, 0x3df: 0xc4,
+	0x3e8: 0xc5, 0x3e9: 0xc6, 0x3ea: 0xc7,
+	// Block 0x10, offset 0x400
+	0x400: 0xc8,
+	0x420: 0x9b, 0x421: 0x9b, 0x422: 0x9b, 0x423: 0xc9, 0x424: 0x9b, 0x425: 0xca, 0x426: 0x9b, 0x427: 0x9b,
+	0x428: 0x9b, 0x429: 0x9b, 0x42a: 0x9b, 0x42b: 0x9b, 0x42c: 0x9b, 0x42d: 0x9b, 0x42e: 0x9b, 0x42f: 0x9b,
+	0x430: 0x9b, 0x431: 0x9b, 0x432: 0x9b, 0x433: 0x9b, 0x434: 0x9b, 0x435: 0x9b, 0x436: 0x9b, 0x437: 0x9b,
+	0x438: 0x0e, 0x439: 0x0e, 0x43a: 0x0e, 0x43b: 0xcb, 0x43c: 0x9b, 0x43d: 0x9b, 0x43e: 0x9b, 0x43f: 0x9b,
+	// Block 0x11, offset 0x440
+	0x440: 0xcc, 0x441: 0x54, 0x442: 0xcd, 0x443: 0xce, 0x444: 0xcf, 0x445: 0xd0,
+	0x44c: 0x54, 0x44d: 0x54, 0x44e: 0x54, 0x44f: 0x54,
+	0x450: 0x54, 0x451: 0x54, 0x452: 0x54, 0x453: 0x54, 0x454: 0x54, 0x455: 0x54, 0x456: 0x54, 0x457: 0x54,
+	0x458: 0x54, 0x459: 0x54, 0x45a: 0x54, 0x45b: 0xd1, 0x45c: 0x54, 0x45d: 0x6c, 0x45e: 0x54, 0x45f: 0xd2,
+	0x460: 0xd3, 0x461: 0xd4, 0x462: 0xd5, 0x464: 0xd6, 0x465: 0xd7, 0x466: 0xd8, 0x467: 0x36,
+	0x47f: 0xd9,
+	// Block 0x12, offset 0x480
+	0x4bf: 0xd9,
+	// Block 0x13, offset 0x4c0
+	0x4d0: 0x09, 0x4d1: 0x0a, 0x4d6: 0x0b,
+	0x4db: 0x0c, 0x4dd: 0x0d, 0x4de: 0x0e, 0x4df: 0x0f,
+	0x4ef: 0x10,
+	0x4ff: 0x10,
+	// Block 0x14, offset 0x500
+	0x50f: 0x10,
+	0x51f: 0x10,
+	0x52f: 0x10,
+	0x53f: 0x10,
+	// Block 0x15, offset 0x540
+	0x540: 0xda, 0x541: 0xda, 0x542: 0xda, 0x543: 0xda, 0x544: 0x05, 0x545: 0x05, 0x546: 0x05, 0x547: 0xdb,
+	0x548: 0xda, 0x549: 0xda, 0x54a: 0xda, 0x54b: 0xda, 0x54c: 0xda, 0x54d: 0xda, 0x54e: 0xda, 0x54f: 0xda,
+	0x550: 0xda, 0x551: 0xda, 0x552: 0xda, 0x553: 0xda, 0x554: 0xda, 0x555: 0xda, 0x556: 0xda, 0x557: 0xda,
+	0x558: 0xda, 0x559: 0xda, 0x55a: 0xda, 0x55b: 0xda, 0x55c: 0xda, 0x55d: 0xda, 0x55e: 0xda, 0x55f: 0xda,
+	0x560: 0xda, 0x561: 0xda, 0x562: 0xda, 0x563: 0xda, 0x564: 0xda, 0x565: 0xda, 0x566: 0xda, 0x567: 0xda,
+	0x568: 0xda, 0x569: 0xda, 0x56a: 0xda, 0x56b: 0xda, 0x56c: 0xda, 0x56d: 0xda, 0x56e: 0xda, 0x56f: 0xda,
+	0x570: 0xda, 0x571: 0xda, 0x572: 0xda, 0x573: 0xda, 0x574: 0xda, 0x575: 0xda, 0x576: 0xda, 0x577: 0xda,
+	0x578: 0xda, 0x579: 0xda, 0x57a: 0xda, 0x57b: 0xda, 0x57c: 0xda, 0x57d: 0xda, 0x57e: 0xda, 0x57f: 0xda,
+	// Block 0x16, offset 0x580
+	0x58f: 0x10,
+	0x59f: 0x10,
+	0x5a0: 0x13,
+	0x5af: 0x10,
+	0x5bf: 0x10,
+	// Block 0x17, offset 0x5c0
+	0x5cf: 0x10,
+}
+
+// Total table size 15800 bytes (15KiB); checksum: F50EF68C
diff --git a/vendor/golang.org/x/text/unicode/bidi/trieval.go b/vendor/golang.org/x/text/unicode/bidi/trieval.go
new file mode 100644
index 0000000000..4c459c4b72
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/bidi/trieval.go
@@ -0,0 +1,60 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package bidi
+
+// Class is the Unicode BiDi class. Each rune has a single class.
+type Class uint
+
+const (
+	L       Class = iota // LeftToRight
+	R                    // RightToLeft
+	EN                   // EuropeanNumber
+	ES                   // EuropeanSeparator
+	ET                   // EuropeanTerminator
+	AN                   // ArabicNumber
+	CS                   // CommonSeparator
+	B                    // ParagraphSeparator
+	S                    // SegmentSeparator
+	WS                   // WhiteSpace
+	ON                   // OtherNeutral
+	BN                   // BoundaryNeutral
+	NSM                  // NonspacingMark
+	AL                   // ArabicLetter
+	Control              // Control LRO - PDI
+
+	numClass
+
+	LRO // LeftToRightOverride
+	RLO // RightToLeftOverride
+	LRE // LeftToRightEmbedding
+	RLE // RightToLeftEmbedding
+	PDF // PopDirectionalFormat
+	LRI // LeftToRightIsolate
+	RLI // RightToLeftIsolate
+	FSI // FirstStrongIsolate
+	PDI // PopDirectionalIsolate
+
+	unknownClass = ^Class(0)
+)
+
+var controlToClass = map[rune]Class{
+	0x202D: LRO, // LeftToRightOverride,
+	0x202E: RLO, // RightToLeftOverride,
+	0x202A: LRE, // LeftToRightEmbedding,
+	0x202B: RLE, // RightToLeftEmbedding,
+	0x202C: PDF, // PopDirectionalFormat,
+	0x2066: LRI, // LeftToRightIsolate,
+	0x2067: RLI, // RightToLeftIsolate,
+	0x2068: FSI, // FirstStrongIsolate,
+	0x2069: PDI, // PopDirectionalIsolate,
+}
+
+// A trie entry has the following bits:
+// 7..5  XOR mask for brackets
+// 4     1: Bracket open, 0: Bracket close
+// 3..0  Class type
+
+const (
+	openMask     = 0x10
+	xorMaskShift = 5
+)
diff --git a/vendor/golang.org/x/text/unicode/norm/composition.go b/vendor/golang.org/x/text/unicode/norm/composition.go
new file mode 100644
index 0000000000..bab4c5de02
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/composition.go
@@ -0,0 +1,508 @@
+// 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 norm
+
+import "unicode/utf8"
+
+const (
+	maxNonStarters = 30
+	// The maximum number of characters needed for a buffer is
+	// maxNonStarters + 1 for the starter + 1 for the GCJ
+	maxBufferSize    = maxNonStarters + 2
+	maxNFCExpansion  = 3  // NFC(0x1D160)
+	maxNFKCExpansion = 18 // NFKC(0xFDFA)
+
+	maxByteBufferSize = utf8.UTFMax * maxBufferSize // 128
+)
+
+// ssState is used for reporting the segment state after inserting a rune.
+// It is returned by streamSafe.next.
+type ssState int
+
+const (
+	// Indicates a rune was successfully added to the segment.
+	ssSuccess ssState = iota
+	// Indicates a rune starts a new segment and should not be added.
+	ssStarter
+	// Indicates a rune caused a segment overflow and a CGJ should be inserted.
+	ssOverflow
+)
+
+// streamSafe implements the policy of when a CGJ should be inserted.
+type streamSafe uint8
+
+// first inserts the first rune of a segment. It is a faster version of next if
+// it is known p represents the first rune in a segment.
+func (ss *streamSafe) first(p Properties) {
+	*ss = streamSafe(p.nTrailingNonStarters())
+}
+
+// insert returns a ssState value to indicate whether a rune represented by p
+// can be inserted.
+func (ss *streamSafe) next(p Properties) ssState {
+	if *ss > maxNonStarters {
+		panic("streamSafe was not reset")
+	}
+	n := p.nLeadingNonStarters()
+	if *ss += streamSafe(n); *ss > maxNonStarters {
+		*ss = 0
+		return ssOverflow
+	}
+	// The Stream-Safe Text Processing prescribes that the counting can stop
+	// as soon as a starter is encountered. However, there are some starters,
+	// like Jamo V and T, that can combine with other runes, leaving their
+	// successive non-starters appended to the previous, possibly causing an
+	// overflow. We will therefore consider any rune with a non-zero nLead to
+	// be a non-starter. Note that it always hold that if nLead > 0 then
+	// nLead == nTrail.
+	if n == 0 {
+		*ss = streamSafe(p.nTrailingNonStarters())
+		return ssStarter
+	}
+	return ssSuccess
+}
+
+// backwards is used for checking for overflow and segment starts
+// when traversing a string backwards. Users do not need to call first
+// for the first rune. The state of the streamSafe retains the count of
+// the non-starters loaded.
+func (ss *streamSafe) backwards(p Properties) ssState {
+	if *ss > maxNonStarters {
+		panic("streamSafe was not reset")
+	}
+	c := *ss + streamSafe(p.nTrailingNonStarters())
+	if c > maxNonStarters {
+		return ssOverflow
+	}
+	*ss = c
+	if p.nLeadingNonStarters() == 0 {
+		return ssStarter
+	}
+	return ssSuccess
+}
+
+func (ss streamSafe) isMax() bool {
+	return ss == maxNonStarters
+}
+
+// GraphemeJoiner is inserted after maxNonStarters non-starter runes.
+const GraphemeJoiner = "\u034F"
+
+// reorderBuffer is used to normalize a single segment.  Characters inserted with
+// insert are decomposed and reordered based on CCC. The compose method can
+// be used to recombine characters.  Note that the byte buffer does not hold
+// the UTF-8 characters in order.  Only the rune array is maintained in sorted
+// order. flush writes the resulting segment to a byte array.
+type reorderBuffer struct {
+	rune  [maxBufferSize]Properties // Per character info.
+	byte  [maxByteBufferSize]byte   // UTF-8 buffer. Referenced by runeInfo.pos.
+	nbyte uint8                     // Number or bytes.
+	ss    streamSafe                // For limiting length of non-starter sequence.
+	nrune int                       // Number of runeInfos.
+	f     formInfo
+
+	src      input
+	nsrc     int
+	tmpBytes input
+
+	out    []byte
+	flushF func(*reorderBuffer) bool
+}
+
+func (rb *reorderBuffer) init(f Form, src []byte) {
+	rb.f = *formTable[f]
+	rb.src.setBytes(src)
+	rb.nsrc = len(src)
+	rb.ss = 0
+}
+
+func (rb *reorderBuffer) initString(f Form, src string) {
+	rb.f = *formTable[f]
+	rb.src.setString(src)
+	rb.nsrc = len(src)
+	rb.ss = 0
+}
+
+func (rb *reorderBuffer) setFlusher(out []byte, f func(*reorderBuffer) bool) {
+	rb.out = out
+	rb.flushF = f
+}
+
+// reset discards all characters from the buffer.
+func (rb *reorderBuffer) reset() {
+	rb.nrune = 0
+	rb.nbyte = 0
+}
+
+func (rb *reorderBuffer) doFlush() bool {
+	if rb.f.composing {
+		rb.compose()
+	}
+	res := rb.flushF(rb)
+	rb.reset()
+	return res
+}
+
+// appendFlush appends the normalized segment to rb.out.
+func appendFlush(rb *reorderBuffer) bool {
+	for i := 0; i < rb.nrune; i++ {
+		start := rb.rune[i].pos
+		end := start + rb.rune[i].size
+		rb.out = append(rb.out, rb.byte[start:end]...)
+	}
+	return true
+}
+
+// flush appends the normalized segment to out and resets rb.
+func (rb *reorderBuffer) flush(out []byte) []byte {
+	for i := 0; i < rb.nrune; i++ {
+		start := rb.rune[i].pos
+		end := start + rb.rune[i].size
+		out = append(out, rb.byte[start:end]...)
+	}
+	rb.reset()
+	return out
+}
+
+// flushCopy copies the normalized segment to buf and resets rb.
+// It returns the number of bytes written to buf.
+func (rb *reorderBuffer) flushCopy(buf []byte) int {
+	p := 0
+	for i := 0; i < rb.nrune; i++ {
+		runep := rb.rune[i]
+		p += copy(buf[p:], rb.byte[runep.pos:runep.pos+runep.size])
+	}
+	rb.reset()
+	return p
+}
+
+// insertOrdered inserts a rune in the buffer, ordered by Canonical Combining Class.
+// It returns false if the buffer is not large enough to hold the rune.
+// It is used internally by insert and insertString only.
+func (rb *reorderBuffer) insertOrdered(info Properties) {
+	n := rb.nrune
+	b := rb.rune[:]
+	cc := info.ccc
+	if cc > 0 {
+		// Find insertion position + move elements to make room.
+		for ; n > 0; n-- {
+			if b[n-1].ccc <= cc {
+				break
+			}
+			b[n] = b[n-1]
+		}
+	}
+	rb.nrune += 1
+	pos := uint8(rb.nbyte)
+	rb.nbyte += utf8.UTFMax
+	info.pos = pos
+	b[n] = info
+}
+
+// insertErr is an error code returned by insert. Using this type instead
+// of error improves performance up to 20% for many of the benchmarks.
+type insertErr int
+
+const (
+	iSuccess insertErr = -iota
+	iShortDst
+	iShortSrc
+)
+
+// insertFlush inserts the given rune in the buffer ordered by CCC.
+// If a decomposition with multiple segments are encountered, they leading
+// ones are flushed.
+// It returns a non-zero error code if the rune was not inserted.
+func (rb *reorderBuffer) insertFlush(src input, i int, info Properties) insertErr {
+	if rune := src.hangul(i); rune != 0 {
+		rb.decomposeHangul(rune)
+		return iSuccess
+	}
+	if info.hasDecomposition() {
+		return rb.insertDecomposed(info.Decomposition())
+	}
+	rb.insertSingle(src, i, info)
+	return iSuccess
+}
+
+// insertUnsafe inserts the given rune in the buffer ordered by CCC.
+// It is assumed there is sufficient space to hold the runes. It is the
+// responsibility of the caller to ensure this. This can be done by checking
+// the state returned by the streamSafe type.
+func (rb *reorderBuffer) insertUnsafe(src input, i int, info Properties) {
+	if rune := src.hangul(i); rune != 0 {
+		rb.decomposeHangul(rune)
+	}
+	if info.hasDecomposition() {
+		// TODO: inline.
+		rb.insertDecomposed(info.Decomposition())
+	} else {
+		rb.insertSingle(src, i, info)
+	}
+}
+
+// insertDecomposed inserts an entry in to the reorderBuffer for each rune
+// in dcomp. dcomp must be a sequence of decomposed UTF-8-encoded runes.
+// It flushes the buffer on each new segment start.
+func (rb *reorderBuffer) insertDecomposed(dcomp []byte) insertErr {
+	rb.tmpBytes.setBytes(dcomp)
+	// As the streamSafe accounting already handles the counting for modifiers,
+	// we don't have to call next. However, we do need to keep the accounting
+	// intact when flushing the buffer.
+	for i := 0; i < len(dcomp); {
+		info := rb.f.info(rb.tmpBytes, i)
+		if info.BoundaryBefore() && rb.nrune > 0 && !rb.doFlush() {
+			return iShortDst
+		}
+		i += copy(rb.byte[rb.nbyte:], dcomp[i:i+int(info.size)])
+		rb.insertOrdered(info)
+	}
+	return iSuccess
+}
+
+// insertSingle inserts an entry in the reorderBuffer for the rune at
+// position i. info is the runeInfo for the rune at position i.
+func (rb *reorderBuffer) insertSingle(src input, i int, info Properties) {
+	src.copySlice(rb.byte[rb.nbyte:], i, i+int(info.size))
+	rb.insertOrdered(info)
+}
+
+// insertCGJ inserts a Combining Grapheme Joiner (0x034f) into rb.
+func (rb *reorderBuffer) insertCGJ() {
+	rb.insertSingle(input{str: GraphemeJoiner}, 0, Properties{size: uint8(len(GraphemeJoiner))})
+}
+
+// appendRune inserts a rune at the end of the buffer. It is used for Hangul.
+func (rb *reorderBuffer) appendRune(r rune) {
+	bn := rb.nbyte
+	sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+	rb.nbyte += utf8.UTFMax
+	rb.rune[rb.nrune] = Properties{pos: bn, size: uint8(sz)}
+	rb.nrune++
+}
+
+// assignRune sets a rune at position pos. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) assignRune(pos int, r rune) {
+	bn := rb.rune[pos].pos
+	sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+	rb.rune[pos] = Properties{pos: bn, size: uint8(sz)}
+}
+
+// runeAt returns the rune at position n. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) runeAt(n int) rune {
+	inf := rb.rune[n]
+	r, _ := utf8.DecodeRune(rb.byte[inf.pos : inf.pos+inf.size])
+	return r
+}
+
+// bytesAt returns the UTF-8 encoding of the rune at position n.
+// It is used for Hangul and recomposition.
+func (rb *reorderBuffer) bytesAt(n int) []byte {
+	inf := rb.rune[n]
+	return rb.byte[inf.pos : int(inf.pos)+int(inf.size)]
+}
+
+// For Hangul we combine algorithmically, instead of using tables.
+const (
+	hangulBase  = 0xAC00 // UTF-8(hangulBase) -> EA B0 80
+	hangulBase0 = 0xEA
+	hangulBase1 = 0xB0
+	hangulBase2 = 0x80
+
+	hangulEnd  = hangulBase + jamoLVTCount // UTF-8(0xD7A4) -> ED 9E A4
+	hangulEnd0 = 0xED
+	hangulEnd1 = 0x9E
+	hangulEnd2 = 0xA4
+
+	jamoLBase  = 0x1100 // UTF-8(jamoLBase) -> E1 84 00
+	jamoLBase0 = 0xE1
+	jamoLBase1 = 0x84
+	jamoLEnd   = 0x1113
+	jamoVBase  = 0x1161
+	jamoVEnd   = 0x1176
+	jamoTBase  = 0x11A7
+	jamoTEnd   = 0x11C3
+
+	jamoTCount   = 28
+	jamoVCount   = 21
+	jamoVTCount  = 21 * 28
+	jamoLVTCount = 19 * 21 * 28
+)
+
+const hangulUTF8Size = 3
+
+func isHangul(b []byte) bool {
+	if len(b) < hangulUTF8Size {
+		return false
+	}
+	b0 := b[0]
+	if b0 < hangulBase0 {
+		return false
+	}
+	b1 := b[1]
+	switch {
+	case b0 == hangulBase0:
+		return b1 >= hangulBase1
+	case b0 < hangulEnd0:
+		return true
+	case b0 > hangulEnd0:
+		return false
+	case b1 < hangulEnd1:
+		return true
+	}
+	return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+func isHangulString(b string) bool {
+	if len(b) < hangulUTF8Size {
+		return false
+	}
+	b0 := b[0]
+	if b0 < hangulBase0 {
+		return false
+	}
+	b1 := b[1]
+	switch {
+	case b0 == hangulBase0:
+		return b1 >= hangulBase1
+	case b0 < hangulEnd0:
+		return true
+	case b0 > hangulEnd0:
+		return false
+	case b1 < hangulEnd1:
+		return true
+	}
+	return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+// Caller must ensure len(b) >= 2.
+func isJamoVT(b []byte) bool {
+	// True if (rune & 0xff00) == jamoLBase
+	return b[0] == jamoLBase0 && (b[1]&0xFC) == jamoLBase1
+}
+
+func isHangulWithoutJamoT(b []byte) bool {
+	c, _ := utf8.DecodeRune(b)
+	c -= hangulBase
+	return c < jamoLVTCount && c%jamoTCount == 0
+}
+
+// decomposeHangul writes the decomposed Hangul to buf and returns the number
+// of bytes written.  len(buf) should be at least 9.
+func decomposeHangul(buf []byte, r rune) int {
+	const JamoUTF8Len = 3
+	r -= hangulBase
+	x := r % jamoTCount
+	r /= jamoTCount
+	utf8.EncodeRune(buf, jamoLBase+r/jamoVCount)
+	utf8.EncodeRune(buf[JamoUTF8Len:], jamoVBase+r%jamoVCount)
+	if x != 0 {
+		utf8.EncodeRune(buf[2*JamoUTF8Len:], jamoTBase+x)
+		return 3 * JamoUTF8Len
+	}
+	return 2 * JamoUTF8Len
+}
+
+// decomposeHangul algorithmically decomposes a Hangul rune into
+// its Jamo components.
+// See http://unicode.org/reports/tr15/#Hangul for details on decomposing Hangul.
+func (rb *reorderBuffer) decomposeHangul(r rune) {
+	r -= hangulBase
+	x := r % jamoTCount
+	r /= jamoTCount
+	rb.appendRune(jamoLBase + r/jamoVCount)
+	rb.appendRune(jamoVBase + r%jamoVCount)
+	if x != 0 {
+		rb.appendRune(jamoTBase + x)
+	}
+}
+
+// combineHangul algorithmically combines Jamo character components into Hangul.
+// See http://unicode.org/reports/tr15/#Hangul for details on combining Hangul.
+func (rb *reorderBuffer) combineHangul(s, i, k int) {
+	b := rb.rune[:]
+	bn := rb.nrune
+	for ; i < bn; i++ {
+		cccB := b[k-1].ccc
+		cccC := b[i].ccc
+		if cccB == 0 {
+			s = k - 1
+		}
+		if s != k-1 && cccB >= cccC {
+			// b[i] is blocked by greater-equal cccX below it
+			b[k] = b[i]
+			k++
+		} else {
+			l := rb.runeAt(s) // also used to compare to hangulBase
+			v := rb.runeAt(i) // also used to compare to jamoT
+			switch {
+			case jamoLBase <= l && l < jamoLEnd &&
+				jamoVBase <= v && v < jamoVEnd:
+				// 11xx plus 116x to LV
+				rb.assignRune(s, hangulBase+
+					(l-jamoLBase)*jamoVTCount+(v-jamoVBase)*jamoTCount)
+			case hangulBase <= l && l < hangulEnd &&
+				jamoTBase < v && v < jamoTEnd &&
+				((l-hangulBase)%jamoTCount) == 0:
+				// ACxx plus 11Ax to LVT
+				rb.assignRune(s, l+v-jamoTBase)
+			default:
+				b[k] = b[i]
+				k++
+			}
+		}
+	}
+	rb.nrune = k
+}
+
+// compose recombines the runes in the buffer.
+// It should only be used to recompose a single segment, as it will not
+// handle alternations between Hangul and non-Hangul characters correctly.
+func (rb *reorderBuffer) compose() {
+	// UAX #15, section X5 , including Corrigendum #5
+	// "In any character sequence beginning with starter S, a character C is
+	//  blocked from S if and only if there is some character B between S
+	//  and C, and either B is a starter or it has the same or higher
+	//  combining class as C."
+	bn := rb.nrune
+	if bn == 0 {
+		return
+	}
+	k := 1
+	b := rb.rune[:]
+	for s, i := 0, 1; i < bn; i++ {
+		if isJamoVT(rb.bytesAt(i)) {
+			// Redo from start in Hangul mode. Necessary to support
+			// U+320E..U+321E in NFKC mode.
+			rb.combineHangul(s, i, k)
+			return
+		}
+		ii := b[i]
+		// We can only use combineForward as a filter if we later
+		// get the info for the combined character. This is more
+		// expensive than using the filter. Using combinesBackward()
+		// is safe.
+		if ii.combinesBackward() {
+			cccB := b[k-1].ccc
+			cccC := ii.ccc
+			blocked := false // b[i] blocked by starter or greater or equal CCC?
+			if cccB == 0 {
+				s = k - 1
+			} else {
+				blocked = s != k-1 && cccB >= cccC
+			}
+			if !blocked {
+				combined := combine(rb.runeAt(s), rb.runeAt(i))
+				if combined != 0 {
+					rb.assignRune(s, combined)
+					continue
+				}
+			}
+		}
+		b[k] = b[i]
+		k++
+	}
+	rb.nrune = k
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/forminfo.go b/vendor/golang.org/x/text/unicode/norm/forminfo.go
new file mode 100644
index 0000000000..e67e7655c5
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/forminfo.go
@@ -0,0 +1,259 @@
+// 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 norm
+
+// This file contains Form-specific logic and wrappers for data in tables.go.
+
+// Rune info is stored in a separate trie per composing form. A composing form
+// and its corresponding decomposing form share the same trie.  Each trie maps
+// a rune to a uint16. The values take two forms.  For v >= 0x8000:
+//   bits
+//   15:    1 (inverse of NFD_QC bit of qcInfo)
+//   13..7: qcInfo (see below). isYesD is always true (no decompostion).
+//    6..0: ccc (compressed CCC value).
+// For v < 0x8000, the respective rune has a decomposition and v is an index
+// into a byte array of UTF-8 decomposition sequences and additional info and
+// has the form:
+//    
 * [ []]
+// The header contains the number of bytes in the decomposition (excluding this
+// length byte). The two most significant bits of this length byte correspond
+// to bit 5 and 4 of qcInfo (see below).  The byte sequence itself starts at v+1.
+// The byte sequence is followed by a trailing and leading CCC if the values
+// for these are not zero.  The value of v determines which ccc are appended
+// to the sequences.  For v < firstCCC, there are none, for v >= firstCCC,
+// the sequence is followed by a trailing ccc, and for v >= firstLeadingCC
+// there is an additional leading ccc. The value of tccc itself is the
+// trailing CCC shifted left 2 bits. The two least-significant bits of tccc
+// are the number of trailing non-starters.
+
+const (
+	qcInfoMask      = 0x3F // to clear all but the relevant bits in a qcInfo
+	headerLenMask   = 0x3F // extract the length value from the header byte
+	headerFlagsMask = 0xC0 // extract the qcInfo bits from the header byte
+)
+
+// Properties provides access to normalization properties of a rune.
+type Properties struct {
+	pos   uint8  // start position in reorderBuffer; used in composition.go
+	size  uint8  // length of UTF-8 encoding of this rune
+	ccc   uint8  // leading canonical combining class (ccc if not decomposition)
+	tccc  uint8  // trailing canonical combining class (ccc if not decomposition)
+	nLead uint8  // number of leading non-starters.
+	flags qcInfo // quick check flags
+	index uint16
+}
+
+// functions dispatchable per form
+type lookupFunc func(b input, i int) Properties
+
+// formInfo holds Form-specific functions and tables.
+type formInfo struct {
+	form                     Form
+	composing, compatibility bool // form type
+	info                     lookupFunc
+	nextMain                 iterFunc
+}
+
+var formTable = []*formInfo{{
+	form:          NFC,
+	composing:     true,
+	compatibility: false,
+	info:          lookupInfoNFC,
+	nextMain:      nextComposed,
+}, {
+	form:          NFD,
+	composing:     false,
+	compatibility: false,
+	info:          lookupInfoNFC,
+	nextMain:      nextDecomposed,
+}, {
+	form:          NFKC,
+	composing:     true,
+	compatibility: true,
+	info:          lookupInfoNFKC,
+	nextMain:      nextComposed,
+}, {
+	form:          NFKD,
+	composing:     false,
+	compatibility: true,
+	info:          lookupInfoNFKC,
+	nextMain:      nextDecomposed,
+}}
+
+// We do not distinguish between boundaries for NFC, NFD, etc. to avoid
+// unexpected behavior for the user.  For example, in NFD, there is a boundary
+// after 'a'.  However, 'a' might combine with modifiers, so from the application's
+// perspective it is not a good boundary. We will therefore always use the
+// boundaries for the combining variants.
+
+// BoundaryBefore returns true if this rune starts a new segment and
+// cannot combine with any rune on the left.
+func (p Properties) BoundaryBefore() bool {
+	if p.ccc == 0 && !p.combinesBackward() {
+		return true
+	}
+	// We assume that the CCC of the first character in a decomposition
+	// is always non-zero if different from info.ccc and that we can return
+	// false at this point. This is verified by maketables.
+	return false
+}
+
+// BoundaryAfter returns true if runes cannot combine with or otherwise
+// interact with this or previous runes.
+func (p Properties) BoundaryAfter() bool {
+	// TODO: loosen these conditions.
+	return p.isInert()
+}
+
+// We pack quick check data in 4 bits:
+//   5:    Combines forward  (0 == false, 1 == true)
+//   4..3: NFC_QC Yes(00), No (10), or Maybe (11)
+//   2:    NFD_QC Yes (0) or No (1). No also means there is a decomposition.
+//   1..0: Number of trailing non-starters.
+//
+// When all 4 bits are zero, the character is inert, meaning it is never
+// influenced by normalization.
+type qcInfo uint8
+
+func (p Properties) isYesC() bool { return p.flags&0x10 == 0 }
+func (p Properties) isYesD() bool { return p.flags&0x4 == 0 }
+
+func (p Properties) combinesForward() bool  { return p.flags&0x20 != 0 }
+func (p Properties) combinesBackward() bool { return p.flags&0x8 != 0 } // == isMaybe
+func (p Properties) hasDecomposition() bool { return p.flags&0x4 != 0 } // == isNoD
+
+func (p Properties) isInert() bool {
+	return p.flags&qcInfoMask == 0 && p.ccc == 0
+}
+
+func (p Properties) multiSegment() bool {
+	return p.index >= firstMulti && p.index < endMulti
+}
+
+func (p Properties) nLeadingNonStarters() uint8 {
+	return p.nLead
+}
+
+func (p Properties) nTrailingNonStarters() uint8 {
+	return uint8(p.flags & 0x03)
+}
+
+// Decomposition returns the decomposition for the underlying rune
+// or nil if there is none.
+func (p Properties) Decomposition() []byte {
+	// TODO: create the decomposition for Hangul?
+	if p.index == 0 {
+		return nil
+	}
+	i := p.index
+	n := decomps[i] & headerLenMask
+	i++
+	return decomps[i : i+uint16(n)]
+}
+
+// Size returns the length of UTF-8 encoding of the rune.
+func (p Properties) Size() int {
+	return int(p.size)
+}
+
+// CCC returns the canonical combining class of the underlying rune.
+func (p Properties) CCC() uint8 {
+	if p.index >= firstCCCZeroExcept {
+		return 0
+	}
+	return ccc[p.ccc]
+}
+
+// LeadCCC returns the CCC of the first rune in the decomposition.
+// If there is no decomposition, LeadCCC equals CCC.
+func (p Properties) LeadCCC() uint8 {
+	return ccc[p.ccc]
+}
+
+// TrailCCC returns the CCC of the last rune in the decomposition.
+// If there is no decomposition, TrailCCC equals CCC.
+func (p Properties) TrailCCC() uint8 {
+	return ccc[p.tccc]
+}
+
+// Recomposition
+// We use 32-bit keys instead of 64-bit for the two codepoint keys.
+// This clips off the bits of three entries, but we know this will not
+// result in a collision. In the unlikely event that changes to
+// UnicodeData.txt introduce collisions, the compiler will catch it.
+// Note that the recomposition map for NFC and NFKC are identical.
+
+// combine returns the combined rune or 0 if it doesn't exist.
+func combine(a, b rune) rune {
+	key := uint32(uint16(a))<<16 + uint32(uint16(b))
+	return recompMap[key]
+}
+
+func lookupInfoNFC(b input, i int) Properties {
+	v, sz := b.charinfoNFC(i)
+	return compInfo(v, sz)
+}
+
+func lookupInfoNFKC(b input, i int) Properties {
+	v, sz := b.charinfoNFKC(i)
+	return compInfo(v, sz)
+}
+
+// Properties returns properties for the first rune in s.
+func (f Form) Properties(s []byte) Properties {
+	if f == NFC || f == NFD {
+		return compInfo(nfcData.lookup(s))
+	}
+	return compInfo(nfkcData.lookup(s))
+}
+
+// PropertiesString returns properties for the first rune in s.
+func (f Form) PropertiesString(s string) Properties {
+	if f == NFC || f == NFD {
+		return compInfo(nfcData.lookupString(s))
+	}
+	return compInfo(nfkcData.lookupString(s))
+}
+
+// compInfo converts the information contained in v and sz
+// to a Properties.  See the comment at the top of the file
+// for more information on the format.
+func compInfo(v uint16, sz int) Properties {
+	if v == 0 {
+		return Properties{size: uint8(sz)}
+	} else if v >= 0x8000 {
+		p := Properties{
+			size:  uint8(sz),
+			ccc:   uint8(v),
+			tccc:  uint8(v),
+			flags: qcInfo(v >> 8),
+		}
+		if p.ccc > 0 || p.combinesBackward() {
+			p.nLead = uint8(p.flags & 0x3)
+		}
+		return p
+	}
+	// has decomposition
+	h := decomps[v]
+	f := (qcInfo(h&headerFlagsMask) >> 2) | 0x4
+	p := Properties{size: uint8(sz), flags: f, index: v}
+	if v >= firstCCC {
+		v += uint16(h&headerLenMask) + 1
+		c := decomps[v]
+		p.tccc = c >> 2
+		p.flags |= qcInfo(c & 0x3)
+		if v >= firstLeadingCCC {
+			p.nLead = c & 0x3
+			if v >= firstStarterWithNLead {
+				// We were tricked. Remove the decomposition.
+				p.flags &= 0x03
+				p.index = 0
+				return p
+			}
+			p.ccc = decomps[v+1]
+		}
+	}
+	return p
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/input.go b/vendor/golang.org/x/text/unicode/norm/input.go
new file mode 100644
index 0000000000..479e35bc25
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/input.go
@@ -0,0 +1,109 @@
+// 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 norm
+
+import "unicode/utf8"
+
+type input struct {
+	str   string
+	bytes []byte
+}
+
+func inputBytes(str []byte) input {
+	return input{bytes: str}
+}
+
+func inputString(str string) input {
+	return input{str: str}
+}
+
+func (in *input) setBytes(str []byte) {
+	in.str = ""
+	in.bytes = str
+}
+
+func (in *input) setString(str string) {
+	in.str = str
+	in.bytes = nil
+}
+
+func (in *input) _byte(p int) byte {
+	if in.bytes == nil {
+		return in.str[p]
+	}
+	return in.bytes[p]
+}
+
+func (in *input) skipASCII(p, max int) int {
+	if in.bytes == nil {
+		for ; p < max && in.str[p] < utf8.RuneSelf; p++ {
+		}
+	} else {
+		for ; p < max && in.bytes[p] < utf8.RuneSelf; p++ {
+		}
+	}
+	return p
+}
+
+func (in *input) skipContinuationBytes(p int) int {
+	if in.bytes == nil {
+		for ; p < len(in.str) && !utf8.RuneStart(in.str[p]); p++ {
+		}
+	} else {
+		for ; p < len(in.bytes) && !utf8.RuneStart(in.bytes[p]); p++ {
+		}
+	}
+	return p
+}
+
+func (in *input) appendSlice(buf []byte, b, e int) []byte {
+	if in.bytes != nil {
+		return append(buf, in.bytes[b:e]...)
+	}
+	for i := b; i < e; i++ {
+		buf = append(buf, in.str[i])
+	}
+	return buf
+}
+
+func (in *input) copySlice(buf []byte, b, e int) int {
+	if in.bytes == nil {
+		return copy(buf, in.str[b:e])
+	}
+	return copy(buf, in.bytes[b:e])
+}
+
+func (in *input) charinfoNFC(p int) (uint16, int) {
+	if in.bytes == nil {
+		return nfcData.lookupString(in.str[p:])
+	}
+	return nfcData.lookup(in.bytes[p:])
+}
+
+func (in *input) charinfoNFKC(p int) (uint16, int) {
+	if in.bytes == nil {
+		return nfkcData.lookupString(in.str[p:])
+	}
+	return nfkcData.lookup(in.bytes[p:])
+}
+
+func (in *input) hangul(p int) (r rune) {
+	var size int
+	if in.bytes == nil {
+		if !isHangulString(in.str[p:]) {
+			return 0
+		}
+		r, size = utf8.DecodeRuneInString(in.str[p:])
+	} else {
+		if !isHangul(in.bytes[p:]) {
+			return 0
+		}
+		r, size = utf8.DecodeRune(in.bytes[p:])
+	}
+	if size != hangulUTF8Size {
+		return 0
+	}
+	return r
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/iter.go b/vendor/golang.org/x/text/unicode/norm/iter.go
new file mode 100644
index 0000000000..ce17f96c2e
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/iter.go
@@ -0,0 +1,457 @@
+// 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 norm
+
+import (
+	"fmt"
+	"unicode/utf8"
+)
+
+// MaxSegmentSize is the maximum size of a byte buffer needed to consider any
+// sequence of starter and non-starter runes for the purpose of normalization.
+const MaxSegmentSize = maxByteBufferSize
+
+// An Iter iterates over a string or byte slice, while normalizing it
+// to a given Form.
+type Iter struct {
+	rb     reorderBuffer
+	buf    [maxByteBufferSize]byte
+	info   Properties // first character saved from previous iteration
+	next   iterFunc   // implementation of next depends on form
+	asciiF iterFunc
+
+	p        int    // current position in input source
+	multiSeg []byte // remainder of multi-segment decomposition
+}
+
+type iterFunc func(*Iter) []byte
+
+// Init initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) Init(f Form, src []byte) {
+	i.p = 0
+	if len(src) == 0 {
+		i.setDone()
+		i.rb.nsrc = 0
+		return
+	}
+	i.multiSeg = nil
+	i.rb.init(f, src)
+	i.next = i.rb.f.nextMain
+	i.asciiF = nextASCIIBytes
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+}
+
+// InitString initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) InitString(f Form, src string) {
+	i.p = 0
+	if len(src) == 0 {
+		i.setDone()
+		i.rb.nsrc = 0
+		return
+	}
+	i.multiSeg = nil
+	i.rb.initString(f, src)
+	i.next = i.rb.f.nextMain
+	i.asciiF = nextASCIIString
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+}
+
+// Seek sets the segment to be returned by the next call to Next to start
+// at position p.  It is the responsibility of the caller to set p to the
+// start of a segment.
+func (i *Iter) Seek(offset int64, whence int) (int64, error) {
+	var abs int64
+	switch whence {
+	case 0:
+		abs = offset
+	case 1:
+		abs = int64(i.p) + offset
+	case 2:
+		abs = int64(i.rb.nsrc) + offset
+	default:
+		return 0, fmt.Errorf("norm: invalid whence")
+	}
+	if abs < 0 {
+		return 0, fmt.Errorf("norm: negative position")
+	}
+	if int(abs) >= i.rb.nsrc {
+		i.setDone()
+		return int64(i.p), nil
+	}
+	i.p = int(abs)
+	i.multiSeg = nil
+	i.next = i.rb.f.nextMain
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+	return abs, nil
+}
+
+// returnSlice returns a slice of the underlying input type as a byte slice.
+// If the underlying is of type []byte, it will simply return a slice.
+// If the underlying is of type string, it will copy the slice to the buffer
+// and return that.
+func (i *Iter) returnSlice(a, b int) []byte {
+	if i.rb.src.bytes == nil {
+		return i.buf[:copy(i.buf[:], i.rb.src.str[a:b])]
+	}
+	return i.rb.src.bytes[a:b]
+}
+
+// Pos returns the byte position at which the next call to Next will commence processing.
+func (i *Iter) Pos() int {
+	return i.p
+}
+
+func (i *Iter) setDone() {
+	i.next = nextDone
+	i.p = i.rb.nsrc
+}
+
+// Done returns true if there is no more input to process.
+func (i *Iter) Done() bool {
+	return i.p >= i.rb.nsrc
+}
+
+// Next returns f(i.input[i.Pos():n]), where n is a boundary of i.input.
+// For any input a and b for which f(a) == f(b), subsequent calls
+// to Next will return the same segments.
+// Modifying runes are grouped together with the preceding starter, if such a starter exists.
+// Although not guaranteed, n will typically be the smallest possible n.
+func (i *Iter) Next() []byte {
+	return i.next(i)
+}
+
+func nextASCIIBytes(i *Iter) []byte {
+	p := i.p + 1
+	if p >= i.rb.nsrc {
+		i.setDone()
+		return i.rb.src.bytes[i.p:p]
+	}
+	if i.rb.src.bytes[p] < utf8.RuneSelf {
+		p0 := i.p
+		i.p = p
+		return i.rb.src.bytes[p0:p]
+	}
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+func nextASCIIString(i *Iter) []byte {
+	p := i.p + 1
+	if p >= i.rb.nsrc {
+		i.buf[0] = i.rb.src.str[i.p]
+		i.setDone()
+		return i.buf[:1]
+	}
+	if i.rb.src.str[p] < utf8.RuneSelf {
+		i.buf[0] = i.rb.src.str[i.p]
+		i.p = p
+		return i.buf[:1]
+	}
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+func nextHangul(i *Iter) []byte {
+	p := i.p
+	next := p + hangulUTF8Size
+	if next >= i.rb.nsrc {
+		i.setDone()
+	} else if i.rb.src.hangul(next) == 0 {
+		i.rb.ss.next(i.info)
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		i.next = i.rb.f.nextMain
+		return i.next(i)
+	}
+	i.p = next
+	return i.buf[:decomposeHangul(i.buf[:], i.rb.src.hangul(p))]
+}
+
+func nextDone(i *Iter) []byte {
+	return nil
+}
+
+// nextMulti is used for iterating over multi-segment decompositions
+// for decomposing normal forms.
+func nextMulti(i *Iter) []byte {
+	j := 0
+	d := i.multiSeg
+	// skip first rune
+	for j = 1; j < len(d) && !utf8.RuneStart(d[j]); j++ {
+	}
+	for j < len(d) {
+		info := i.rb.f.info(input{bytes: d}, j)
+		if info.BoundaryBefore() {
+			i.multiSeg = d[j:]
+			return d[:j]
+		}
+		j += int(info.size)
+	}
+	// treat last segment as normal decomposition
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+// nextMultiNorm is used for iterating over multi-segment decompositions
+// for composing normal forms.
+func nextMultiNorm(i *Iter) []byte {
+	j := 0
+	d := i.multiSeg
+	for j < len(d) {
+		info := i.rb.f.info(input{bytes: d}, j)
+		if info.BoundaryBefore() {
+			i.rb.compose()
+			seg := i.buf[:i.rb.flushCopy(i.buf[:])]
+			i.rb.insertUnsafe(input{bytes: d}, j, info)
+			i.multiSeg = d[j+int(info.size):]
+			return seg
+		}
+		i.rb.insertUnsafe(input{bytes: d}, j, info)
+		j += int(info.size)
+	}
+	i.multiSeg = nil
+	i.next = nextComposed
+	return doNormComposed(i)
+}
+
+// nextDecomposed is the implementation of Next for forms NFD and NFKD.
+func nextDecomposed(i *Iter) (next []byte) {
+	outp := 0
+	inCopyStart, outCopyStart := i.p, 0
+	for {
+		if sz := int(i.info.size); sz <= 1 {
+			i.rb.ss = 0
+			p := i.p
+			i.p++ // ASCII or illegal byte.  Either way, advance by 1.
+			if i.p >= i.rb.nsrc {
+				i.setDone()
+				return i.returnSlice(p, i.p)
+			} else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+				i.next = i.asciiF
+				return i.returnSlice(p, i.p)
+			}
+			outp++
+		} else if d := i.info.Decomposition(); d != nil {
+			// Note: If leading CCC != 0, then len(d) == 2 and last is also non-zero.
+			// Case 1: there is a leftover to copy.  In this case the decomposition
+			// must begin with a modifier and should always be appended.
+			// Case 2: no leftover. Simply return d if followed by a ccc == 0 value.
+			p := outp + len(d)
+			if outp > 0 {
+				i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+				// TODO: this condition should not be possible, but we leave it
+				// in for defensive purposes.
+				if p > len(i.buf) {
+					return i.buf[:outp]
+				}
+			} else if i.info.multiSegment() {
+				// outp must be 0 as multi-segment decompositions always
+				// start a new segment.
+				if i.multiSeg == nil {
+					i.multiSeg = d
+					i.next = nextMulti
+					return nextMulti(i)
+				}
+				// We are in the last segment.  Treat as normal decomposition.
+				d = i.multiSeg
+				i.multiSeg = nil
+				p = len(d)
+			}
+			prevCC := i.info.tccc
+			if i.p += sz; i.p >= i.rb.nsrc {
+				i.setDone()
+				i.info = Properties{} // Force BoundaryBefore to succeed.
+			} else {
+				i.info = i.rb.f.info(i.rb.src, i.p)
+			}
+			switch i.rb.ss.next(i.info) {
+			case ssOverflow:
+				i.next = nextCGJDecompose
+				fallthrough
+			case ssStarter:
+				if outp > 0 {
+					copy(i.buf[outp:], d)
+					return i.buf[:p]
+				}
+				return d
+			}
+			copy(i.buf[outp:], d)
+			outp = p
+			inCopyStart, outCopyStart = i.p, outp
+			if i.info.ccc < prevCC {
+				goto doNorm
+			}
+			continue
+		} else if r := i.rb.src.hangul(i.p); r != 0 {
+			outp = decomposeHangul(i.buf[:], r)
+			i.p += hangulUTF8Size
+			inCopyStart, outCopyStart = i.p, outp
+			if i.p >= i.rb.nsrc {
+				i.setDone()
+				break
+			} else if i.rb.src.hangul(i.p) != 0 {
+				i.next = nextHangul
+				return i.buf[:outp]
+			}
+		} else {
+			p := outp + sz
+			if p > len(i.buf) {
+				break
+			}
+			outp = p
+			i.p += sz
+		}
+		if i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		prevCC := i.info.tccc
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if v := i.rb.ss.next(i.info); v == ssStarter {
+			break
+		} else if v == ssOverflow {
+			i.next = nextCGJDecompose
+			break
+		}
+		if i.info.ccc < prevCC {
+			goto doNorm
+		}
+	}
+	if outCopyStart == 0 {
+		return i.returnSlice(inCopyStart, i.p)
+	} else if inCopyStart < i.p {
+		i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+	}
+	return i.buf[:outp]
+doNorm:
+	// Insert what we have decomposed so far in the reorderBuffer.
+	// As we will only reorder, there will always be enough room.
+	i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+	i.rb.insertDecomposed(i.buf[0:outp])
+	return doNormDecomposed(i)
+}
+
+func doNormDecomposed(i *Iter) []byte {
+	for {
+		i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+		if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if i.info.ccc == 0 {
+			break
+		}
+		if s := i.rb.ss.next(i.info); s == ssOverflow {
+			i.next = nextCGJDecompose
+			break
+		}
+	}
+	// new segment or too many combining characters: exit normalization
+	return i.buf[:i.rb.flushCopy(i.buf[:])]
+}
+
+func nextCGJDecompose(i *Iter) []byte {
+	i.rb.ss = 0
+	i.rb.insertCGJ()
+	i.next = nextDecomposed
+	i.rb.ss.first(i.info)
+	buf := doNormDecomposed(i)
+	return buf
+}
+
+// nextComposed is the implementation of Next for forms NFC and NFKC.
+func nextComposed(i *Iter) []byte {
+	outp, startp := 0, i.p
+	var prevCC uint8
+	for {
+		if !i.info.isYesC() {
+			goto doNorm
+		}
+		prevCC = i.info.tccc
+		sz := int(i.info.size)
+		if sz == 0 {
+			sz = 1 // illegal rune: copy byte-by-byte
+		}
+		p := outp + sz
+		if p > len(i.buf) {
+			break
+		}
+		outp = p
+		i.p += sz
+		if i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		} else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+			i.rb.ss = 0
+			i.next = i.asciiF
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if v := i.rb.ss.next(i.info); v == ssStarter {
+			break
+		} else if v == ssOverflow {
+			i.next = nextCGJCompose
+			break
+		}
+		if i.info.ccc < prevCC {
+			goto doNorm
+		}
+	}
+	return i.returnSlice(startp, i.p)
+doNorm:
+	// reset to start position
+	i.p = startp
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+	if i.info.multiSegment() {
+		d := i.info.Decomposition()
+		info := i.rb.f.info(input{bytes: d}, 0)
+		i.rb.insertUnsafe(input{bytes: d}, 0, info)
+		i.multiSeg = d[int(info.size):]
+		i.next = nextMultiNorm
+		return nextMultiNorm(i)
+	}
+	i.rb.ss.first(i.info)
+	i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	return doNormComposed(i)
+}
+
+func doNormComposed(i *Iter) []byte {
+	// First rune should already be inserted.
+	for {
+		if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if s := i.rb.ss.next(i.info); s == ssStarter {
+			break
+		} else if s == ssOverflow {
+			i.next = nextCGJCompose
+			break
+		}
+		i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	}
+	i.rb.compose()
+	seg := i.buf[:i.rb.flushCopy(i.buf[:])]
+	return seg
+}
+
+func nextCGJCompose(i *Iter) []byte {
+	i.rb.ss = 0 // instead of first
+	i.rb.insertCGJ()
+	i.next = nextComposed
+	// Note that we treat any rune with nLeadingNonStarters > 0 as a non-starter,
+	// even if they are not. This is particularly dubious for U+FF9E and UFF9A.
+	// If we ever change that, insert a check here.
+	i.rb.ss.first(i.info)
+	i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	return doNormComposed(i)
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/normalize.go b/vendor/golang.org/x/text/unicode/norm/normalize.go
new file mode 100644
index 0000000000..e28ac641ac
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/normalize.go
@@ -0,0 +1,609 @@
+// 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.
+
+// Note: the file data_test.go that is generated should not be checked in.
+//go:generate go run maketables.go triegen.go
+//go:generate go test -tags test
+
+// Package norm contains types and functions for normalizing Unicode strings.
+package norm // import "golang.org/x/text/unicode/norm"
+
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// A Form denotes a canonical representation of Unicode code points.
+// The Unicode-defined normalization and equivalence forms are:
+//
+//   NFC   Unicode Normalization Form C
+//   NFD   Unicode Normalization Form D
+//   NFKC  Unicode Normalization Form KC
+//   NFKD  Unicode Normalization Form KD
+//
+// For a Form f, this documentation uses the notation f(x) to mean
+// the bytes or string x converted to the given form.
+// A position n in x is called a boundary if conversion to the form can
+// proceed independently on both sides:
+//   f(x) == append(f(x[0:n]), f(x[n:])...)
+//
+// References: http://unicode.org/reports/tr15/ and
+// http://unicode.org/notes/tn5/.
+type Form int
+
+const (
+	NFC Form = iota
+	NFD
+	NFKC
+	NFKD
+)
+
+// Bytes returns f(b). May return b if f(b) = b.
+func (f Form) Bytes(b []byte) []byte {
+	src := inputBytes(b)
+	ft := formTable[f]
+	n, ok := ft.quickSpan(src, 0, len(b), true)
+	if ok {
+		return b
+	}
+	out := make([]byte, n, len(b))
+	copy(out, b[0:n])
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(b), out: out, flushF: appendFlush}
+	return doAppendInner(&rb, n)
+}
+
+// String returns f(s).
+func (f Form) String(s string) string {
+	src := inputString(s)
+	ft := formTable[f]
+	n, ok := ft.quickSpan(src, 0, len(s), true)
+	if ok {
+		return s
+	}
+	out := make([]byte, n, len(s))
+	copy(out, s[0:n])
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s), out: out, flushF: appendFlush}
+	return string(doAppendInner(&rb, n))
+}
+
+// IsNormal returns true if b == f(b).
+func (f Form) IsNormal(b []byte) bool {
+	src := inputBytes(b)
+	ft := formTable[f]
+	bp, ok := ft.quickSpan(src, 0, len(b), true)
+	if ok {
+		return true
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(b)}
+	rb.setFlusher(nil, cmpNormalBytes)
+	for bp < len(b) {
+		rb.out = b[bp:]
+		if bp = decomposeSegment(&rb, bp, true); bp < 0 {
+			return false
+		}
+		bp, _ = rb.f.quickSpan(rb.src, bp, len(b), true)
+	}
+	return true
+}
+
+func cmpNormalBytes(rb *reorderBuffer) bool {
+	b := rb.out
+	for i := 0; i < rb.nrune; i++ {
+		info := rb.rune[i]
+		if int(info.size) > len(b) {
+			return false
+		}
+		p := info.pos
+		pe := p + info.size
+		for ; p < pe; p++ {
+			if b[0] != rb.byte[p] {
+				return false
+			}
+			b = b[1:]
+		}
+	}
+	return true
+}
+
+// IsNormalString returns true if s == f(s).
+func (f Form) IsNormalString(s string) bool {
+	src := inputString(s)
+	ft := formTable[f]
+	bp, ok := ft.quickSpan(src, 0, len(s), true)
+	if ok {
+		return true
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s)}
+	rb.setFlusher(nil, func(rb *reorderBuffer) bool {
+		for i := 0; i < rb.nrune; i++ {
+			info := rb.rune[i]
+			if bp+int(info.size) > len(s) {
+				return false
+			}
+			p := info.pos
+			pe := p + info.size
+			for ; p < pe; p++ {
+				if s[bp] != rb.byte[p] {
+					return false
+				}
+				bp++
+			}
+		}
+		return true
+	})
+	for bp < len(s) {
+		if bp = decomposeSegment(&rb, bp, true); bp < 0 {
+			return false
+		}
+		bp, _ = rb.f.quickSpan(rb.src, bp, len(s), true)
+	}
+	return true
+}
+
+// patchTail fixes a case where a rune may be incorrectly normalized
+// if it is followed by illegal continuation bytes. It returns the
+// patched buffer and whether the decomposition is still in progress.
+func patchTail(rb *reorderBuffer) bool {
+	info, p := lastRuneStart(&rb.f, rb.out)
+	if p == -1 || info.size == 0 {
+		return true
+	}
+	end := p + int(info.size)
+	extra := len(rb.out) - end
+	if extra > 0 {
+		// Potentially allocating memory. However, this only
+		// happens with ill-formed UTF-8.
+		x := make([]byte, 0)
+		x = append(x, rb.out[len(rb.out)-extra:]...)
+		rb.out = rb.out[:end]
+		decomposeToLastBoundary(rb)
+		rb.doFlush()
+		rb.out = append(rb.out, x...)
+		return false
+	}
+	buf := rb.out[p:]
+	rb.out = rb.out[:p]
+	decomposeToLastBoundary(rb)
+	if s := rb.ss.next(info); s == ssStarter {
+		rb.doFlush()
+		rb.ss.first(info)
+	} else if s == ssOverflow {
+		rb.doFlush()
+		rb.insertCGJ()
+		rb.ss = 0
+	}
+	rb.insertUnsafe(inputBytes(buf), 0, info)
+	return true
+}
+
+func appendQuick(rb *reorderBuffer, i int) int {
+	if rb.nsrc == i {
+		return i
+	}
+	end, _ := rb.f.quickSpan(rb.src, i, rb.nsrc, true)
+	rb.out = rb.src.appendSlice(rb.out, i, end)
+	return end
+}
+
+// Append returns f(append(out, b...)).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) Append(out []byte, src ...byte) []byte {
+	return f.doAppend(out, inputBytes(src), len(src))
+}
+
+func (f Form) doAppend(out []byte, src input, n int) []byte {
+	if n == 0 {
+		return out
+	}
+	ft := formTable[f]
+	// Attempt to do a quickSpan first so we can avoid initializing the reorderBuffer.
+	if len(out) == 0 {
+		p, _ := ft.quickSpan(src, 0, n, true)
+		out = src.appendSlice(out, 0, p)
+		if p == n {
+			return out
+		}
+		rb := reorderBuffer{f: *ft, src: src, nsrc: n, out: out, flushF: appendFlush}
+		return doAppendInner(&rb, p)
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: n}
+	return doAppend(&rb, out, 0)
+}
+
+func doAppend(rb *reorderBuffer, out []byte, p int) []byte {
+	rb.setFlusher(out, appendFlush)
+	src, n := rb.src, rb.nsrc
+	doMerge := len(out) > 0
+	if q := src.skipContinuationBytes(p); q > p {
+		// Move leading non-starters to destination.
+		rb.out = src.appendSlice(rb.out, p, q)
+		p = q
+		doMerge = patchTail(rb)
+	}
+	fd := &rb.f
+	if doMerge {
+		var info Properties
+		if p < n {
+			info = fd.info(src, p)
+			if !info.BoundaryBefore() || info.nLeadingNonStarters() > 0 {
+				if p == 0 {
+					decomposeToLastBoundary(rb)
+				}
+				p = decomposeSegment(rb, p, true)
+			}
+		}
+		if info.size == 0 {
+			rb.doFlush()
+			// Append incomplete UTF-8 encoding.
+			return src.appendSlice(rb.out, p, n)
+		}
+		if rb.nrune > 0 {
+			return doAppendInner(rb, p)
+		}
+	}
+	p = appendQuick(rb, p)
+	return doAppendInner(rb, p)
+}
+
+func doAppendInner(rb *reorderBuffer, p int) []byte {
+	for n := rb.nsrc; p < n; {
+		p = decomposeSegment(rb, p, true)
+		p = appendQuick(rb, p)
+	}
+	return rb.out
+}
+
+// AppendString returns f(append(out, []byte(s))).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) AppendString(out []byte, src string) []byte {
+	return f.doAppend(out, inputString(src), len(src))
+}
+
+// QuickSpan returns a boundary n such that b[0:n] == f(b[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpan(b []byte) int {
+	n, _ := formTable[f].quickSpan(inputBytes(b), 0, len(b), true)
+	return n
+}
+
+// Span implements transform.SpanningTransformer. It returns a boundary n such
+// that b[0:n] == f(b[0:n]). It is not guaranteed to return the largest such n.
+func (f Form) Span(b []byte, atEOF bool) (n int, err error) {
+	n, ok := formTable[f].quickSpan(inputBytes(b), 0, len(b), atEOF)
+	if n < len(b) {
+		if !ok {
+			err = transform.ErrEndOfSpan
+		} else {
+			err = transform.ErrShortSrc
+		}
+	}
+	return n, err
+}
+
+// SpanString returns a boundary n such that s[0:n] == f(s[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) SpanString(s string, atEOF bool) (n int, err error) {
+	n, ok := formTable[f].quickSpan(inputString(s), 0, len(s), atEOF)
+	if n < len(s) {
+		if !ok {
+			err = transform.ErrEndOfSpan
+		} else {
+			err = transform.ErrShortSrc
+		}
+	}
+	return n, err
+}
+
+// quickSpan returns a boundary n such that src[0:n] == f(src[0:n]) and
+// whether any non-normalized parts were found. If atEOF is false, n will
+// not point past the last segment if this segment might be become
+// non-normalized by appending other runes.
+func (f *formInfo) quickSpan(src input, i, end int, atEOF bool) (n int, ok bool) {
+	var lastCC uint8
+	ss := streamSafe(0)
+	lastSegStart := i
+	for n = end; i < n; {
+		if j := src.skipASCII(i, n); i != j {
+			i = j
+			lastSegStart = i - 1
+			lastCC = 0
+			ss = 0
+			continue
+		}
+		info := f.info(src, i)
+		if info.size == 0 {
+			if atEOF {
+				// include incomplete runes
+				return n, true
+			}
+			return lastSegStart, true
+		}
+		// This block needs to be before the next, because it is possible to
+		// have an overflow for runes that are starters (e.g. with U+FF9E).
+		switch ss.next(info) {
+		case ssStarter:
+			lastSegStart = i
+		case ssOverflow:
+			return lastSegStart, false
+		case ssSuccess:
+			if lastCC > info.ccc {
+				return lastSegStart, false
+			}
+		}
+		if f.composing {
+			if !info.isYesC() {
+				break
+			}
+		} else {
+			if !info.isYesD() {
+				break
+			}
+		}
+		lastCC = info.ccc
+		i += int(info.size)
+	}
+	if i == n {
+		if !atEOF {
+			n = lastSegStart
+		}
+		return n, true
+	}
+	return lastSegStart, false
+}
+
+// QuickSpanString returns a boundary n such that s[0:n] == f(s[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpanString(s string) int {
+	n, _ := formTable[f].quickSpan(inputString(s), 0, len(s), true)
+	return n
+}
+
+// FirstBoundary returns the position i of the first boundary in b
+// or -1 if b contains no boundary.
+func (f Form) FirstBoundary(b []byte) int {
+	return f.firstBoundary(inputBytes(b), len(b))
+}
+
+func (f Form) firstBoundary(src input, nsrc int) int {
+	i := src.skipContinuationBytes(0)
+	if i >= nsrc {
+		return -1
+	}
+	fd := formTable[f]
+	ss := streamSafe(0)
+	// We should call ss.first here, but we can't as the first rune is
+	// skipped already. This means FirstBoundary can't really determine
+	// CGJ insertion points correctly. Luckily it doesn't have to.
+	for {
+		info := fd.info(src, i)
+		if info.size == 0 {
+			return -1
+		}
+		if s := ss.next(info); s != ssSuccess {
+			return i
+		}
+		i += int(info.size)
+		if i >= nsrc {
+			if !info.BoundaryAfter() && !ss.isMax() {
+				return -1
+			}
+			return nsrc
+		}
+	}
+}
+
+// FirstBoundaryInString returns the position i of the first boundary in s
+// or -1 if s contains no boundary.
+func (f Form) FirstBoundaryInString(s string) int {
+	return f.firstBoundary(inputString(s), len(s))
+}
+
+// NextBoundary reports the index of the boundary between the first and next
+// segment in b or -1 if atEOF is false and there are not enough bytes to
+// determine this boundary.
+func (f Form) NextBoundary(b []byte, atEOF bool) int {
+	return f.nextBoundary(inputBytes(b), len(b), atEOF)
+}
+
+// NextBoundaryInString reports the index of the boundary between the first and
+// next segment in b or -1 if atEOF is false and there are not enough bytes to
+// determine this boundary.
+func (f Form) NextBoundaryInString(s string, atEOF bool) int {
+	return f.nextBoundary(inputString(s), len(s), atEOF)
+}
+
+func (f Form) nextBoundary(src input, nsrc int, atEOF bool) int {
+	if nsrc == 0 {
+		if atEOF {
+			return 0
+		}
+		return -1
+	}
+	fd := formTable[f]
+	info := fd.info(src, 0)
+	if info.size == 0 {
+		if atEOF {
+			return 1
+		}
+		return -1
+	}
+	ss := streamSafe(0)
+	ss.first(info)
+
+	for i := int(info.size); i < nsrc; i += int(info.size) {
+		info = fd.info(src, i)
+		if info.size == 0 {
+			if atEOF {
+				return i
+			}
+			return -1
+		}
+		// TODO: Using streamSafe to determine the boundary isn't the same as
+		// using BoundaryBefore. Determine which should be used.
+		if s := ss.next(info); s != ssSuccess {
+			return i
+		}
+	}
+	if !atEOF && !info.BoundaryAfter() && !ss.isMax() {
+		return -1
+	}
+	return nsrc
+}
+
+// LastBoundary returns the position i of the last boundary in b
+// or -1 if b contains no boundary.
+func (f Form) LastBoundary(b []byte) int {
+	return lastBoundary(formTable[f], b)
+}
+
+func lastBoundary(fd *formInfo, b []byte) int {
+	i := len(b)
+	info, p := lastRuneStart(fd, b)
+	if p == -1 {
+		return -1
+	}
+	if info.size == 0 { // ends with incomplete rune
+		if p == 0 { // starts with incomplete rune
+			return -1
+		}
+		i = p
+		info, p = lastRuneStart(fd, b[:i])
+		if p == -1 { // incomplete UTF-8 encoding or non-starter bytes without a starter
+			return i
+		}
+	}
+	if p+int(info.size) != i { // trailing non-starter bytes: illegal UTF-8
+		return i
+	}
+	if info.BoundaryAfter() {
+		return i
+	}
+	ss := streamSafe(0)
+	v := ss.backwards(info)
+	for i = p; i >= 0 && v != ssStarter; i = p {
+		info, p = lastRuneStart(fd, b[:i])
+		if v = ss.backwards(info); v == ssOverflow {
+			break
+		}
+		if p+int(info.size) != i {
+			if p == -1 { // no boundary found
+				return -1
+			}
+			return i // boundary after an illegal UTF-8 encoding
+		}
+	}
+	return i
+}
+
+// decomposeSegment scans the first segment in src into rb. It inserts 0x034f
+// (Grapheme Joiner) when it encounters a sequence of more than 30 non-starters
+// and returns the number of bytes consumed from src or iShortDst or iShortSrc.
+func decomposeSegment(rb *reorderBuffer, sp int, atEOF bool) int {
+	// Force one character to be consumed.
+	info := rb.f.info(rb.src, sp)
+	if info.size == 0 {
+		return 0
+	}
+	if s := rb.ss.next(info); s == ssStarter {
+		// TODO: this could be removed if we don't support merging.
+		if rb.nrune > 0 {
+			goto end
+		}
+	} else if s == ssOverflow {
+		rb.insertCGJ()
+		goto end
+	}
+	if err := rb.insertFlush(rb.src, sp, info); err != iSuccess {
+		return int(err)
+	}
+	for {
+		sp += int(info.size)
+		if sp >= rb.nsrc {
+			if !atEOF && !info.BoundaryAfter() {
+				return int(iShortSrc)
+			}
+			break
+		}
+		info = rb.f.info(rb.src, sp)
+		if info.size == 0 {
+			if !atEOF {
+				return int(iShortSrc)
+			}
+			break
+		}
+		if s := rb.ss.next(info); s == ssStarter {
+			break
+		} else if s == ssOverflow {
+			rb.insertCGJ()
+			break
+		}
+		if err := rb.insertFlush(rb.src, sp, info); err != iSuccess {
+			return int(err)
+		}
+	}
+end:
+	if !rb.doFlush() {
+		return int(iShortDst)
+	}
+	return sp
+}
+
+// lastRuneStart returns the runeInfo and position of the last
+// rune in buf or the zero runeInfo and -1 if no rune was found.
+func lastRuneStart(fd *formInfo, buf []byte) (Properties, int) {
+	p := len(buf) - 1
+	for ; p >= 0 && !utf8.RuneStart(buf[p]); p-- {
+	}
+	if p < 0 {
+		return Properties{}, -1
+	}
+	return fd.info(inputBytes(buf), p), p
+}
+
+// decomposeToLastBoundary finds an open segment at the end of the buffer
+// and scans it into rb. Returns the buffer minus the last segment.
+func decomposeToLastBoundary(rb *reorderBuffer) {
+	fd := &rb.f
+	info, i := lastRuneStart(fd, rb.out)
+	if int(info.size) != len(rb.out)-i {
+		// illegal trailing continuation bytes
+		return
+	}
+	if info.BoundaryAfter() {
+		return
+	}
+	var add [maxNonStarters + 1]Properties // stores runeInfo in reverse order
+	padd := 0
+	ss := streamSafe(0)
+	p := len(rb.out)
+	for {
+		add[padd] = info
+		v := ss.backwards(info)
+		if v == ssOverflow {
+			// Note that if we have an overflow, it the string we are appending to
+			// is not correctly normalized. In this case the behavior is undefined.
+			break
+		}
+		padd++
+		p -= int(info.size)
+		if v == ssStarter || p < 0 {
+			break
+		}
+		info, i = lastRuneStart(fd, rb.out[:p])
+		if int(info.size) != p-i {
+			break
+		}
+	}
+	rb.ss = ss
+	// Copy bytes for insertion as we may need to overwrite rb.out.
+	var buf [maxBufferSize * utf8.UTFMax]byte
+	cp := buf[:copy(buf[:], rb.out[p:])]
+	rb.out = rb.out[:p]
+	for padd--; padd >= 0; padd-- {
+		info = add[padd]
+		rb.insertUnsafe(inputBytes(cp), 0, info)
+		cp = cp[info.size:]
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/readwriter.go b/vendor/golang.org/x/text/unicode/norm/readwriter.go
new file mode 100644
index 0000000000..d926ee903e
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/readwriter.go
@@ -0,0 +1,125 @@
+// 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 norm
+
+import "io"
+
+type normWriter struct {
+	rb  reorderBuffer
+	w   io.Writer
+	buf []byte
+}
+
+// Write implements the standard write interface.  If the last characters are
+// not at a normalization boundary, the bytes will be buffered for the next
+// write. The remaining bytes will be written on close.
+func (w *normWriter) Write(data []byte) (n int, err error) {
+	// Process data in pieces to keep w.buf size bounded.
+	const chunk = 4000
+
+	for len(data) > 0 {
+		// Normalize into w.buf.
+		m := len(data)
+		if m > chunk {
+			m = chunk
+		}
+		w.rb.src = inputBytes(data[:m])
+		w.rb.nsrc = m
+		w.buf = doAppend(&w.rb, w.buf, 0)
+		data = data[m:]
+		n += m
+
+		// Write out complete prefix, save remainder.
+		// Note that lastBoundary looks back at most 31 runes.
+		i := lastBoundary(&w.rb.f, w.buf)
+		if i == -1 {
+			i = 0
+		}
+		if i > 0 {
+			if _, err = w.w.Write(w.buf[:i]); err != nil {
+				break
+			}
+			bn := copy(w.buf, w.buf[i:])
+			w.buf = w.buf[:bn]
+		}
+	}
+	return n, err
+}
+
+// Close forces data that remains in the buffer to be written.
+func (w *normWriter) Close() error {
+	if len(w.buf) > 0 {
+		_, err := w.w.Write(w.buf)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Writer returns a new writer that implements Write(b)
+// by writing f(b) to w.  The returned writer may use an
+// an internal buffer to maintain state across Write calls.
+// Calling its Close method writes any buffered data to w.
+func (f Form) Writer(w io.Writer) io.WriteCloser {
+	wr := &normWriter{rb: reorderBuffer{}, w: w}
+	wr.rb.init(f, nil)
+	return wr
+}
+
+type normReader struct {
+	rb           reorderBuffer
+	r            io.Reader
+	inbuf        []byte
+	outbuf       []byte
+	bufStart     int
+	lastBoundary int
+	err          error
+}
+
+// Read implements the standard read interface.
+func (r *normReader) Read(p []byte) (int, error) {
+	for {
+		if r.lastBoundary-r.bufStart > 0 {
+			n := copy(p, r.outbuf[r.bufStart:r.lastBoundary])
+			r.bufStart += n
+			if r.lastBoundary-r.bufStart > 0 {
+				return n, nil
+			}
+			return n, r.err
+		}
+		if r.err != nil {
+			return 0, r.err
+		}
+		outn := copy(r.outbuf, r.outbuf[r.lastBoundary:])
+		r.outbuf = r.outbuf[0:outn]
+		r.bufStart = 0
+
+		n, err := r.r.Read(r.inbuf)
+		r.rb.src = inputBytes(r.inbuf[0:n])
+		r.rb.nsrc, r.err = n, err
+		if n > 0 {
+			r.outbuf = doAppend(&r.rb, r.outbuf, 0)
+		}
+		if err == io.EOF {
+			r.lastBoundary = len(r.outbuf)
+		} else {
+			r.lastBoundary = lastBoundary(&r.rb.f, r.outbuf)
+			if r.lastBoundary == -1 {
+				r.lastBoundary = 0
+			}
+		}
+	}
+}
+
+// Reader returns a new reader that implements Read
+// by reading data from r and returning f(data).
+func (f Form) Reader(r io.Reader) io.Reader {
+	const chunk = 4000
+	buf := make([]byte, chunk)
+	rr := &normReader{rb: reorderBuffer{}, r: r, inbuf: buf}
+	rr.rb.init(f, buf)
+	return rr
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go b/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go
new file mode 100644
index 0000000000..44dd3978ca
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/tables10.0.0.go
@@ -0,0 +1,7653 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// +build go1.10
+
+package norm
+
+const (
+	// Version is the Unicode edition from which the tables are derived.
+	Version = "10.0.0"
+
+	// MaxTransformChunkSize indicates the maximum number of bytes that Transform
+	// may need to write atomically for any Form. Making a destination buffer at
+	// least this size ensures that Transform can always make progress and that
+	// the user does not need to grow the buffer on an ErrShortDst.
+	MaxTransformChunkSize = 35 + maxNonStarters*4
+)
+
+var ccc = [55]uint8{
+	0, 1, 7, 8, 9, 10, 11, 12,
+	13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28,
+	29, 30, 31, 32, 33, 34, 35, 36,
+	84, 91, 103, 107, 118, 122, 129, 130,
+	132, 202, 214, 216, 218, 220, 222, 224,
+	226, 228, 230, 232, 233, 234, 240,
+}
+
+const (
+	firstMulti            = 0x186D
+	firstCCC              = 0x2C9E
+	endMulti              = 0x2F60
+	firstLeadingCCC       = 0x49AE
+	firstCCCZeroExcept    = 0x4A78
+	firstStarterWithNLead = 0x4A9F
+	lastDecomp            = 0x4AA1
+	maxDecomp             = 0x8000
+)
+
+// decomps: 19105 bytes
+var decomps = [...]byte{
+	// Bytes 0 - 3f
+	0x00, 0x41, 0x20, 0x41, 0x21, 0x41, 0x22, 0x41,
+	0x23, 0x41, 0x24, 0x41, 0x25, 0x41, 0x26, 0x41,
+	0x27, 0x41, 0x28, 0x41, 0x29, 0x41, 0x2A, 0x41,
+	0x2B, 0x41, 0x2C, 0x41, 0x2D, 0x41, 0x2E, 0x41,
+	0x2F, 0x41, 0x30, 0x41, 0x31, 0x41, 0x32, 0x41,
+	0x33, 0x41, 0x34, 0x41, 0x35, 0x41, 0x36, 0x41,
+	0x37, 0x41, 0x38, 0x41, 0x39, 0x41, 0x3A, 0x41,
+	0x3B, 0x41, 0x3C, 0x41, 0x3D, 0x41, 0x3E, 0x41,
+	// Bytes 40 - 7f
+	0x3F, 0x41, 0x40, 0x41, 0x41, 0x41, 0x42, 0x41,
+	0x43, 0x41, 0x44, 0x41, 0x45, 0x41, 0x46, 0x41,
+	0x47, 0x41, 0x48, 0x41, 0x49, 0x41, 0x4A, 0x41,
+	0x4B, 0x41, 0x4C, 0x41, 0x4D, 0x41, 0x4E, 0x41,
+	0x4F, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41,
+	0x53, 0x41, 0x54, 0x41, 0x55, 0x41, 0x56, 0x41,
+	0x57, 0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x41,
+	0x5B, 0x41, 0x5C, 0x41, 0x5D, 0x41, 0x5E, 0x41,
+	// Bytes 80 - bf
+	0x5F, 0x41, 0x60, 0x41, 0x61, 0x41, 0x62, 0x41,
+	0x63, 0x41, 0x64, 0x41, 0x65, 0x41, 0x66, 0x41,
+	0x67, 0x41, 0x68, 0x41, 0x69, 0x41, 0x6A, 0x41,
+	0x6B, 0x41, 0x6C, 0x41, 0x6D, 0x41, 0x6E, 0x41,
+	0x6F, 0x41, 0x70, 0x41, 0x71, 0x41, 0x72, 0x41,
+	0x73, 0x41, 0x74, 0x41, 0x75, 0x41, 0x76, 0x41,
+	0x77, 0x41, 0x78, 0x41, 0x79, 0x41, 0x7A, 0x41,
+	0x7B, 0x41, 0x7C, 0x41, 0x7D, 0x41, 0x7E, 0x42,
+	// Bytes c0 - ff
+	0xC2, 0xA2, 0x42, 0xC2, 0xA3, 0x42, 0xC2, 0xA5,
+	0x42, 0xC2, 0xA6, 0x42, 0xC2, 0xAC, 0x42, 0xC2,
+	0xB7, 0x42, 0xC3, 0x86, 0x42, 0xC3, 0xB0, 0x42,
+	0xC4, 0xA6, 0x42, 0xC4, 0xA7, 0x42, 0xC4, 0xB1,
+	0x42, 0xC5, 0x8B, 0x42, 0xC5, 0x93, 0x42, 0xC6,
+	0x8E, 0x42, 0xC6, 0x90, 0x42, 0xC6, 0xAB, 0x42,
+	0xC8, 0xA2, 0x42, 0xC8, 0xB7, 0x42, 0xC9, 0x90,
+	0x42, 0xC9, 0x91, 0x42, 0xC9, 0x92, 0x42, 0xC9,
+	// Bytes 100 - 13f
+	0x94, 0x42, 0xC9, 0x95, 0x42, 0xC9, 0x99, 0x42,
+	0xC9, 0x9B, 0x42, 0xC9, 0x9C, 0x42, 0xC9, 0x9F,
+	0x42, 0xC9, 0xA1, 0x42, 0xC9, 0xA3, 0x42, 0xC9,
+	0xA5, 0x42, 0xC9, 0xA6, 0x42, 0xC9, 0xA8, 0x42,
+	0xC9, 0xA9, 0x42, 0xC9, 0xAA, 0x42, 0xC9, 0xAB,
+	0x42, 0xC9, 0xAD, 0x42, 0xC9, 0xAF, 0x42, 0xC9,
+	0xB0, 0x42, 0xC9, 0xB1, 0x42, 0xC9, 0xB2, 0x42,
+	0xC9, 0xB3, 0x42, 0xC9, 0xB4, 0x42, 0xC9, 0xB5,
+	// Bytes 140 - 17f
+	0x42, 0xC9, 0xB8, 0x42, 0xC9, 0xB9, 0x42, 0xC9,
+	0xBB, 0x42, 0xCA, 0x81, 0x42, 0xCA, 0x82, 0x42,
+	0xCA, 0x83, 0x42, 0xCA, 0x89, 0x42, 0xCA, 0x8A,
+	0x42, 0xCA, 0x8B, 0x42, 0xCA, 0x8C, 0x42, 0xCA,
+	0x90, 0x42, 0xCA, 0x91, 0x42, 0xCA, 0x92, 0x42,
+	0xCA, 0x95, 0x42, 0xCA, 0x9D, 0x42, 0xCA, 0x9F,
+	0x42, 0xCA, 0xB9, 0x42, 0xCE, 0x91, 0x42, 0xCE,
+	0x92, 0x42, 0xCE, 0x93, 0x42, 0xCE, 0x94, 0x42,
+	// Bytes 180 - 1bf
+	0xCE, 0x95, 0x42, 0xCE, 0x96, 0x42, 0xCE, 0x97,
+	0x42, 0xCE, 0x98, 0x42, 0xCE, 0x99, 0x42, 0xCE,
+	0x9A, 0x42, 0xCE, 0x9B, 0x42, 0xCE, 0x9C, 0x42,
+	0xCE, 0x9D, 0x42, 0xCE, 0x9E, 0x42, 0xCE, 0x9F,
+	0x42, 0xCE, 0xA0, 0x42, 0xCE, 0xA1, 0x42, 0xCE,
+	0xA3, 0x42, 0xCE, 0xA4, 0x42, 0xCE, 0xA5, 0x42,
+	0xCE, 0xA6, 0x42, 0xCE, 0xA7, 0x42, 0xCE, 0xA8,
+	0x42, 0xCE, 0xA9, 0x42, 0xCE, 0xB1, 0x42, 0xCE,
+	// Bytes 1c0 - 1ff
+	0xB2, 0x42, 0xCE, 0xB3, 0x42, 0xCE, 0xB4, 0x42,
+	0xCE, 0xB5, 0x42, 0xCE, 0xB6, 0x42, 0xCE, 0xB7,
+	0x42, 0xCE, 0xB8, 0x42, 0xCE, 0xB9, 0x42, 0xCE,
+	0xBA, 0x42, 0xCE, 0xBB, 0x42, 0xCE, 0xBC, 0x42,
+	0xCE, 0xBD, 0x42, 0xCE, 0xBE, 0x42, 0xCE, 0xBF,
+	0x42, 0xCF, 0x80, 0x42, 0xCF, 0x81, 0x42, 0xCF,
+	0x82, 0x42, 0xCF, 0x83, 0x42, 0xCF, 0x84, 0x42,
+	0xCF, 0x85, 0x42, 0xCF, 0x86, 0x42, 0xCF, 0x87,
+	// Bytes 200 - 23f
+	0x42, 0xCF, 0x88, 0x42, 0xCF, 0x89, 0x42, 0xCF,
+	0x9C, 0x42, 0xCF, 0x9D, 0x42, 0xD0, 0xBD, 0x42,
+	0xD1, 0x8A, 0x42, 0xD1, 0x8C, 0x42, 0xD7, 0x90,
+	0x42, 0xD7, 0x91, 0x42, 0xD7, 0x92, 0x42, 0xD7,
+	0x93, 0x42, 0xD7, 0x94, 0x42, 0xD7, 0x9B, 0x42,
+	0xD7, 0x9C, 0x42, 0xD7, 0x9D, 0x42, 0xD7, 0xA2,
+	0x42, 0xD7, 0xA8, 0x42, 0xD7, 0xAA, 0x42, 0xD8,
+	0xA1, 0x42, 0xD8, 0xA7, 0x42, 0xD8, 0xA8, 0x42,
+	// Bytes 240 - 27f
+	0xD8, 0xA9, 0x42, 0xD8, 0xAA, 0x42, 0xD8, 0xAB,
+	0x42, 0xD8, 0xAC, 0x42, 0xD8, 0xAD, 0x42, 0xD8,
+	0xAE, 0x42, 0xD8, 0xAF, 0x42, 0xD8, 0xB0, 0x42,
+	0xD8, 0xB1, 0x42, 0xD8, 0xB2, 0x42, 0xD8, 0xB3,
+	0x42, 0xD8, 0xB4, 0x42, 0xD8, 0xB5, 0x42, 0xD8,
+	0xB6, 0x42, 0xD8, 0xB7, 0x42, 0xD8, 0xB8, 0x42,
+	0xD8, 0xB9, 0x42, 0xD8, 0xBA, 0x42, 0xD9, 0x81,
+	0x42, 0xD9, 0x82, 0x42, 0xD9, 0x83, 0x42, 0xD9,
+	// Bytes 280 - 2bf
+	0x84, 0x42, 0xD9, 0x85, 0x42, 0xD9, 0x86, 0x42,
+	0xD9, 0x87, 0x42, 0xD9, 0x88, 0x42, 0xD9, 0x89,
+	0x42, 0xD9, 0x8A, 0x42, 0xD9, 0xAE, 0x42, 0xD9,
+	0xAF, 0x42, 0xD9, 0xB1, 0x42, 0xD9, 0xB9, 0x42,
+	0xD9, 0xBA, 0x42, 0xD9, 0xBB, 0x42, 0xD9, 0xBE,
+	0x42, 0xD9, 0xBF, 0x42, 0xDA, 0x80, 0x42, 0xDA,
+	0x83, 0x42, 0xDA, 0x84, 0x42, 0xDA, 0x86, 0x42,
+	0xDA, 0x87, 0x42, 0xDA, 0x88, 0x42, 0xDA, 0x8C,
+	// Bytes 2c0 - 2ff
+	0x42, 0xDA, 0x8D, 0x42, 0xDA, 0x8E, 0x42, 0xDA,
+	0x91, 0x42, 0xDA, 0x98, 0x42, 0xDA, 0xA1, 0x42,
+	0xDA, 0xA4, 0x42, 0xDA, 0xA6, 0x42, 0xDA, 0xA9,
+	0x42, 0xDA, 0xAD, 0x42, 0xDA, 0xAF, 0x42, 0xDA,
+	0xB1, 0x42, 0xDA, 0xB3, 0x42, 0xDA, 0xBA, 0x42,
+	0xDA, 0xBB, 0x42, 0xDA, 0xBE, 0x42, 0xDB, 0x81,
+	0x42, 0xDB, 0x85, 0x42, 0xDB, 0x86, 0x42, 0xDB,
+	0x87, 0x42, 0xDB, 0x88, 0x42, 0xDB, 0x89, 0x42,
+	// Bytes 300 - 33f
+	0xDB, 0x8B, 0x42, 0xDB, 0x8C, 0x42, 0xDB, 0x90,
+	0x42, 0xDB, 0x92, 0x43, 0xE0, 0xBC, 0x8B, 0x43,
+	0xE1, 0x83, 0x9C, 0x43, 0xE1, 0x84, 0x80, 0x43,
+	0xE1, 0x84, 0x81, 0x43, 0xE1, 0x84, 0x82, 0x43,
+	0xE1, 0x84, 0x83, 0x43, 0xE1, 0x84, 0x84, 0x43,
+	0xE1, 0x84, 0x85, 0x43, 0xE1, 0x84, 0x86, 0x43,
+	0xE1, 0x84, 0x87, 0x43, 0xE1, 0x84, 0x88, 0x43,
+	0xE1, 0x84, 0x89, 0x43, 0xE1, 0x84, 0x8A, 0x43,
+	// Bytes 340 - 37f
+	0xE1, 0x84, 0x8B, 0x43, 0xE1, 0x84, 0x8C, 0x43,
+	0xE1, 0x84, 0x8D, 0x43, 0xE1, 0x84, 0x8E, 0x43,
+	0xE1, 0x84, 0x8F, 0x43, 0xE1, 0x84, 0x90, 0x43,
+	0xE1, 0x84, 0x91, 0x43, 0xE1, 0x84, 0x92, 0x43,
+	0xE1, 0x84, 0x94, 0x43, 0xE1, 0x84, 0x95, 0x43,
+	0xE1, 0x84, 0x9A, 0x43, 0xE1, 0x84, 0x9C, 0x43,
+	0xE1, 0x84, 0x9D, 0x43, 0xE1, 0x84, 0x9E, 0x43,
+	0xE1, 0x84, 0xA0, 0x43, 0xE1, 0x84, 0xA1, 0x43,
+	// Bytes 380 - 3bf
+	0xE1, 0x84, 0xA2, 0x43, 0xE1, 0x84, 0xA3, 0x43,
+	0xE1, 0x84, 0xA7, 0x43, 0xE1, 0x84, 0xA9, 0x43,
+	0xE1, 0x84, 0xAB, 0x43, 0xE1, 0x84, 0xAC, 0x43,
+	0xE1, 0x84, 0xAD, 0x43, 0xE1, 0x84, 0xAE, 0x43,
+	0xE1, 0x84, 0xAF, 0x43, 0xE1, 0x84, 0xB2, 0x43,
+	0xE1, 0x84, 0xB6, 0x43, 0xE1, 0x85, 0x80, 0x43,
+	0xE1, 0x85, 0x87, 0x43, 0xE1, 0x85, 0x8C, 0x43,
+	0xE1, 0x85, 0x97, 0x43, 0xE1, 0x85, 0x98, 0x43,
+	// Bytes 3c0 - 3ff
+	0xE1, 0x85, 0x99, 0x43, 0xE1, 0x85, 0xA0, 0x43,
+	0xE1, 0x86, 0x84, 0x43, 0xE1, 0x86, 0x85, 0x43,
+	0xE1, 0x86, 0x88, 0x43, 0xE1, 0x86, 0x91, 0x43,
+	0xE1, 0x86, 0x92, 0x43, 0xE1, 0x86, 0x94, 0x43,
+	0xE1, 0x86, 0x9E, 0x43, 0xE1, 0x86, 0xA1, 0x43,
+	0xE1, 0x87, 0x87, 0x43, 0xE1, 0x87, 0x88, 0x43,
+	0xE1, 0x87, 0x8C, 0x43, 0xE1, 0x87, 0x8E, 0x43,
+	0xE1, 0x87, 0x93, 0x43, 0xE1, 0x87, 0x97, 0x43,
+	// Bytes 400 - 43f
+	0xE1, 0x87, 0x99, 0x43, 0xE1, 0x87, 0x9D, 0x43,
+	0xE1, 0x87, 0x9F, 0x43, 0xE1, 0x87, 0xB1, 0x43,
+	0xE1, 0x87, 0xB2, 0x43, 0xE1, 0xB4, 0x82, 0x43,
+	0xE1, 0xB4, 0x96, 0x43, 0xE1, 0xB4, 0x97, 0x43,
+	0xE1, 0xB4, 0x9C, 0x43, 0xE1, 0xB4, 0x9D, 0x43,
+	0xE1, 0xB4, 0xA5, 0x43, 0xE1, 0xB5, 0xBB, 0x43,
+	0xE1, 0xB6, 0x85, 0x43, 0xE2, 0x80, 0x82, 0x43,
+	0xE2, 0x80, 0x83, 0x43, 0xE2, 0x80, 0x90, 0x43,
+	// Bytes 440 - 47f
+	0xE2, 0x80, 0x93, 0x43, 0xE2, 0x80, 0x94, 0x43,
+	0xE2, 0x82, 0xA9, 0x43, 0xE2, 0x86, 0x90, 0x43,
+	0xE2, 0x86, 0x91, 0x43, 0xE2, 0x86, 0x92, 0x43,
+	0xE2, 0x86, 0x93, 0x43, 0xE2, 0x88, 0x82, 0x43,
+	0xE2, 0x88, 0x87, 0x43, 0xE2, 0x88, 0x91, 0x43,
+	0xE2, 0x88, 0x92, 0x43, 0xE2, 0x94, 0x82, 0x43,
+	0xE2, 0x96, 0xA0, 0x43, 0xE2, 0x97, 0x8B, 0x43,
+	0xE2, 0xA6, 0x85, 0x43, 0xE2, 0xA6, 0x86, 0x43,
+	// Bytes 480 - 4bf
+	0xE2, 0xB5, 0xA1, 0x43, 0xE3, 0x80, 0x81, 0x43,
+	0xE3, 0x80, 0x82, 0x43, 0xE3, 0x80, 0x88, 0x43,
+	0xE3, 0x80, 0x89, 0x43, 0xE3, 0x80, 0x8A, 0x43,
+	0xE3, 0x80, 0x8B, 0x43, 0xE3, 0x80, 0x8C, 0x43,
+	0xE3, 0x80, 0x8D, 0x43, 0xE3, 0x80, 0x8E, 0x43,
+	0xE3, 0x80, 0x8F, 0x43, 0xE3, 0x80, 0x90, 0x43,
+	0xE3, 0x80, 0x91, 0x43, 0xE3, 0x80, 0x92, 0x43,
+	0xE3, 0x80, 0x94, 0x43, 0xE3, 0x80, 0x95, 0x43,
+	// Bytes 4c0 - 4ff
+	0xE3, 0x80, 0x96, 0x43, 0xE3, 0x80, 0x97, 0x43,
+	0xE3, 0x82, 0xA1, 0x43, 0xE3, 0x82, 0xA2, 0x43,
+	0xE3, 0x82, 0xA3, 0x43, 0xE3, 0x82, 0xA4, 0x43,
+	0xE3, 0x82, 0xA5, 0x43, 0xE3, 0x82, 0xA6, 0x43,
+	0xE3, 0x82, 0xA7, 0x43, 0xE3, 0x82, 0xA8, 0x43,
+	0xE3, 0x82, 0xA9, 0x43, 0xE3, 0x82, 0xAA, 0x43,
+	0xE3, 0x82, 0xAB, 0x43, 0xE3, 0x82, 0xAD, 0x43,
+	0xE3, 0x82, 0xAF, 0x43, 0xE3, 0x82, 0xB1, 0x43,
+	// Bytes 500 - 53f
+	0xE3, 0x82, 0xB3, 0x43, 0xE3, 0x82, 0xB5, 0x43,
+	0xE3, 0x82, 0xB7, 0x43, 0xE3, 0x82, 0xB9, 0x43,
+	0xE3, 0x82, 0xBB, 0x43, 0xE3, 0x82, 0xBD, 0x43,
+	0xE3, 0x82, 0xBF, 0x43, 0xE3, 0x83, 0x81, 0x43,
+	0xE3, 0x83, 0x83, 0x43, 0xE3, 0x83, 0x84, 0x43,
+	0xE3, 0x83, 0x86, 0x43, 0xE3, 0x83, 0x88, 0x43,
+	0xE3, 0x83, 0x8A, 0x43, 0xE3, 0x83, 0x8B, 0x43,
+	0xE3, 0x83, 0x8C, 0x43, 0xE3, 0x83, 0x8D, 0x43,
+	// Bytes 540 - 57f
+	0xE3, 0x83, 0x8E, 0x43, 0xE3, 0x83, 0x8F, 0x43,
+	0xE3, 0x83, 0x92, 0x43, 0xE3, 0x83, 0x95, 0x43,
+	0xE3, 0x83, 0x98, 0x43, 0xE3, 0x83, 0x9B, 0x43,
+	0xE3, 0x83, 0x9E, 0x43, 0xE3, 0x83, 0x9F, 0x43,
+	0xE3, 0x83, 0xA0, 0x43, 0xE3, 0x83, 0xA1, 0x43,
+	0xE3, 0x83, 0xA2, 0x43, 0xE3, 0x83, 0xA3, 0x43,
+	0xE3, 0x83, 0xA4, 0x43, 0xE3, 0x83, 0xA5, 0x43,
+	0xE3, 0x83, 0xA6, 0x43, 0xE3, 0x83, 0xA7, 0x43,
+	// Bytes 580 - 5bf
+	0xE3, 0x83, 0xA8, 0x43, 0xE3, 0x83, 0xA9, 0x43,
+	0xE3, 0x83, 0xAA, 0x43, 0xE3, 0x83, 0xAB, 0x43,
+	0xE3, 0x83, 0xAC, 0x43, 0xE3, 0x83, 0xAD, 0x43,
+	0xE3, 0x83, 0xAF, 0x43, 0xE3, 0x83, 0xB0, 0x43,
+	0xE3, 0x83, 0xB1, 0x43, 0xE3, 0x83, 0xB2, 0x43,
+	0xE3, 0x83, 0xB3, 0x43, 0xE3, 0x83, 0xBB, 0x43,
+	0xE3, 0x83, 0xBC, 0x43, 0xE3, 0x92, 0x9E, 0x43,
+	0xE3, 0x92, 0xB9, 0x43, 0xE3, 0x92, 0xBB, 0x43,
+	// Bytes 5c0 - 5ff
+	0xE3, 0x93, 0x9F, 0x43, 0xE3, 0x94, 0x95, 0x43,
+	0xE3, 0x9B, 0xAE, 0x43, 0xE3, 0x9B, 0xBC, 0x43,
+	0xE3, 0x9E, 0x81, 0x43, 0xE3, 0xA0, 0xAF, 0x43,
+	0xE3, 0xA1, 0xA2, 0x43, 0xE3, 0xA1, 0xBC, 0x43,
+	0xE3, 0xA3, 0x87, 0x43, 0xE3, 0xA3, 0xA3, 0x43,
+	0xE3, 0xA4, 0x9C, 0x43, 0xE3, 0xA4, 0xBA, 0x43,
+	0xE3, 0xA8, 0xAE, 0x43, 0xE3, 0xA9, 0xAC, 0x43,
+	0xE3, 0xAB, 0xA4, 0x43, 0xE3, 0xAC, 0x88, 0x43,
+	// Bytes 600 - 63f
+	0xE3, 0xAC, 0x99, 0x43, 0xE3, 0xAD, 0x89, 0x43,
+	0xE3, 0xAE, 0x9D, 0x43, 0xE3, 0xB0, 0x98, 0x43,
+	0xE3, 0xB1, 0x8E, 0x43, 0xE3, 0xB4, 0xB3, 0x43,
+	0xE3, 0xB6, 0x96, 0x43, 0xE3, 0xBA, 0xAC, 0x43,
+	0xE3, 0xBA, 0xB8, 0x43, 0xE3, 0xBC, 0x9B, 0x43,
+	0xE3, 0xBF, 0xBC, 0x43, 0xE4, 0x80, 0x88, 0x43,
+	0xE4, 0x80, 0x98, 0x43, 0xE4, 0x80, 0xB9, 0x43,
+	0xE4, 0x81, 0x86, 0x43, 0xE4, 0x82, 0x96, 0x43,
+	// Bytes 640 - 67f
+	0xE4, 0x83, 0xA3, 0x43, 0xE4, 0x84, 0xAF, 0x43,
+	0xE4, 0x88, 0x82, 0x43, 0xE4, 0x88, 0xA7, 0x43,
+	0xE4, 0x8A, 0xA0, 0x43, 0xE4, 0x8C, 0x81, 0x43,
+	0xE4, 0x8C, 0xB4, 0x43, 0xE4, 0x8D, 0x99, 0x43,
+	0xE4, 0x8F, 0x95, 0x43, 0xE4, 0x8F, 0x99, 0x43,
+	0xE4, 0x90, 0x8B, 0x43, 0xE4, 0x91, 0xAB, 0x43,
+	0xE4, 0x94, 0xAB, 0x43, 0xE4, 0x95, 0x9D, 0x43,
+	0xE4, 0x95, 0xA1, 0x43, 0xE4, 0x95, 0xAB, 0x43,
+	// Bytes 680 - 6bf
+	0xE4, 0x97, 0x97, 0x43, 0xE4, 0x97, 0xB9, 0x43,
+	0xE4, 0x98, 0xB5, 0x43, 0xE4, 0x9A, 0xBE, 0x43,
+	0xE4, 0x9B, 0x87, 0x43, 0xE4, 0xA6, 0x95, 0x43,
+	0xE4, 0xA7, 0xA6, 0x43, 0xE4, 0xA9, 0xAE, 0x43,
+	0xE4, 0xA9, 0xB6, 0x43, 0xE4, 0xAA, 0xB2, 0x43,
+	0xE4, 0xAC, 0xB3, 0x43, 0xE4, 0xAF, 0x8E, 0x43,
+	0xE4, 0xB3, 0x8E, 0x43, 0xE4, 0xB3, 0xAD, 0x43,
+	0xE4, 0xB3, 0xB8, 0x43, 0xE4, 0xB5, 0x96, 0x43,
+	// Bytes 6c0 - 6ff
+	0xE4, 0xB8, 0x80, 0x43, 0xE4, 0xB8, 0x81, 0x43,
+	0xE4, 0xB8, 0x83, 0x43, 0xE4, 0xB8, 0x89, 0x43,
+	0xE4, 0xB8, 0x8A, 0x43, 0xE4, 0xB8, 0x8B, 0x43,
+	0xE4, 0xB8, 0x8D, 0x43, 0xE4, 0xB8, 0x99, 0x43,
+	0xE4, 0xB8, 0xA6, 0x43, 0xE4, 0xB8, 0xA8, 0x43,
+	0xE4, 0xB8, 0xAD, 0x43, 0xE4, 0xB8, 0xB2, 0x43,
+	0xE4, 0xB8, 0xB6, 0x43, 0xE4, 0xB8, 0xB8, 0x43,
+	0xE4, 0xB8, 0xB9, 0x43, 0xE4, 0xB8, 0xBD, 0x43,
+	// Bytes 700 - 73f
+	0xE4, 0xB8, 0xBF, 0x43, 0xE4, 0xB9, 0x81, 0x43,
+	0xE4, 0xB9, 0x99, 0x43, 0xE4, 0xB9, 0x9D, 0x43,
+	0xE4, 0xBA, 0x82, 0x43, 0xE4, 0xBA, 0x85, 0x43,
+	0xE4, 0xBA, 0x86, 0x43, 0xE4, 0xBA, 0x8C, 0x43,
+	0xE4, 0xBA, 0x94, 0x43, 0xE4, 0xBA, 0xA0, 0x43,
+	0xE4, 0xBA, 0xA4, 0x43, 0xE4, 0xBA, 0xAE, 0x43,
+	0xE4, 0xBA, 0xBA, 0x43, 0xE4, 0xBB, 0x80, 0x43,
+	0xE4, 0xBB, 0x8C, 0x43, 0xE4, 0xBB, 0xA4, 0x43,
+	// Bytes 740 - 77f
+	0xE4, 0xBC, 0x81, 0x43, 0xE4, 0xBC, 0x91, 0x43,
+	0xE4, 0xBD, 0xA0, 0x43, 0xE4, 0xBE, 0x80, 0x43,
+	0xE4, 0xBE, 0x86, 0x43, 0xE4, 0xBE, 0x8B, 0x43,
+	0xE4, 0xBE, 0xAE, 0x43, 0xE4, 0xBE, 0xBB, 0x43,
+	0xE4, 0xBE, 0xBF, 0x43, 0xE5, 0x80, 0x82, 0x43,
+	0xE5, 0x80, 0xAB, 0x43, 0xE5, 0x81, 0xBA, 0x43,
+	0xE5, 0x82, 0x99, 0x43, 0xE5, 0x83, 0x8F, 0x43,
+	0xE5, 0x83, 0x9A, 0x43, 0xE5, 0x83, 0xA7, 0x43,
+	// Bytes 780 - 7bf
+	0xE5, 0x84, 0xAA, 0x43, 0xE5, 0x84, 0xBF, 0x43,
+	0xE5, 0x85, 0x80, 0x43, 0xE5, 0x85, 0x85, 0x43,
+	0xE5, 0x85, 0x8D, 0x43, 0xE5, 0x85, 0x94, 0x43,
+	0xE5, 0x85, 0xA4, 0x43, 0xE5, 0x85, 0xA5, 0x43,
+	0xE5, 0x85, 0xA7, 0x43, 0xE5, 0x85, 0xA8, 0x43,
+	0xE5, 0x85, 0xA9, 0x43, 0xE5, 0x85, 0xAB, 0x43,
+	0xE5, 0x85, 0xAD, 0x43, 0xE5, 0x85, 0xB7, 0x43,
+	0xE5, 0x86, 0x80, 0x43, 0xE5, 0x86, 0x82, 0x43,
+	// Bytes 7c0 - 7ff
+	0xE5, 0x86, 0x8D, 0x43, 0xE5, 0x86, 0x92, 0x43,
+	0xE5, 0x86, 0x95, 0x43, 0xE5, 0x86, 0x96, 0x43,
+	0xE5, 0x86, 0x97, 0x43, 0xE5, 0x86, 0x99, 0x43,
+	0xE5, 0x86, 0xA4, 0x43, 0xE5, 0x86, 0xAB, 0x43,
+	0xE5, 0x86, 0xAC, 0x43, 0xE5, 0x86, 0xB5, 0x43,
+	0xE5, 0x86, 0xB7, 0x43, 0xE5, 0x87, 0x89, 0x43,
+	0xE5, 0x87, 0x8C, 0x43, 0xE5, 0x87, 0x9C, 0x43,
+	0xE5, 0x87, 0x9E, 0x43, 0xE5, 0x87, 0xA0, 0x43,
+	// Bytes 800 - 83f
+	0xE5, 0x87, 0xB5, 0x43, 0xE5, 0x88, 0x80, 0x43,
+	0xE5, 0x88, 0x83, 0x43, 0xE5, 0x88, 0x87, 0x43,
+	0xE5, 0x88, 0x97, 0x43, 0xE5, 0x88, 0x9D, 0x43,
+	0xE5, 0x88, 0xA9, 0x43, 0xE5, 0x88, 0xBA, 0x43,
+	0xE5, 0x88, 0xBB, 0x43, 0xE5, 0x89, 0x86, 0x43,
+	0xE5, 0x89, 0x8D, 0x43, 0xE5, 0x89, 0xB2, 0x43,
+	0xE5, 0x89, 0xB7, 0x43, 0xE5, 0x8A, 0x89, 0x43,
+	0xE5, 0x8A, 0x9B, 0x43, 0xE5, 0x8A, 0xA3, 0x43,
+	// Bytes 840 - 87f
+	0xE5, 0x8A, 0xB3, 0x43, 0xE5, 0x8A, 0xB4, 0x43,
+	0xE5, 0x8B, 0x87, 0x43, 0xE5, 0x8B, 0x89, 0x43,
+	0xE5, 0x8B, 0x92, 0x43, 0xE5, 0x8B, 0x9E, 0x43,
+	0xE5, 0x8B, 0xA4, 0x43, 0xE5, 0x8B, 0xB5, 0x43,
+	0xE5, 0x8B, 0xB9, 0x43, 0xE5, 0x8B, 0xBA, 0x43,
+	0xE5, 0x8C, 0x85, 0x43, 0xE5, 0x8C, 0x86, 0x43,
+	0xE5, 0x8C, 0x95, 0x43, 0xE5, 0x8C, 0x97, 0x43,
+	0xE5, 0x8C, 0x9A, 0x43, 0xE5, 0x8C, 0xB8, 0x43,
+	// Bytes 880 - 8bf
+	0xE5, 0x8C, 0xBB, 0x43, 0xE5, 0x8C, 0xBF, 0x43,
+	0xE5, 0x8D, 0x81, 0x43, 0xE5, 0x8D, 0x84, 0x43,
+	0xE5, 0x8D, 0x85, 0x43, 0xE5, 0x8D, 0x89, 0x43,
+	0xE5, 0x8D, 0x91, 0x43, 0xE5, 0x8D, 0x94, 0x43,
+	0xE5, 0x8D, 0x9A, 0x43, 0xE5, 0x8D, 0x9C, 0x43,
+	0xE5, 0x8D, 0xA9, 0x43, 0xE5, 0x8D, 0xB0, 0x43,
+	0xE5, 0x8D, 0xB3, 0x43, 0xE5, 0x8D, 0xB5, 0x43,
+	0xE5, 0x8D, 0xBD, 0x43, 0xE5, 0x8D, 0xBF, 0x43,
+	// Bytes 8c0 - 8ff
+	0xE5, 0x8E, 0x82, 0x43, 0xE5, 0x8E, 0xB6, 0x43,
+	0xE5, 0x8F, 0x83, 0x43, 0xE5, 0x8F, 0x88, 0x43,
+	0xE5, 0x8F, 0x8A, 0x43, 0xE5, 0x8F, 0x8C, 0x43,
+	0xE5, 0x8F, 0x9F, 0x43, 0xE5, 0x8F, 0xA3, 0x43,
+	0xE5, 0x8F, 0xA5, 0x43, 0xE5, 0x8F, 0xAB, 0x43,
+	0xE5, 0x8F, 0xAF, 0x43, 0xE5, 0x8F, 0xB1, 0x43,
+	0xE5, 0x8F, 0xB3, 0x43, 0xE5, 0x90, 0x86, 0x43,
+	0xE5, 0x90, 0x88, 0x43, 0xE5, 0x90, 0x8D, 0x43,
+	// Bytes 900 - 93f
+	0xE5, 0x90, 0x8F, 0x43, 0xE5, 0x90, 0x9D, 0x43,
+	0xE5, 0x90, 0xB8, 0x43, 0xE5, 0x90, 0xB9, 0x43,
+	0xE5, 0x91, 0x82, 0x43, 0xE5, 0x91, 0x88, 0x43,
+	0xE5, 0x91, 0xA8, 0x43, 0xE5, 0x92, 0x9E, 0x43,
+	0xE5, 0x92, 0xA2, 0x43, 0xE5, 0x92, 0xBD, 0x43,
+	0xE5, 0x93, 0xB6, 0x43, 0xE5, 0x94, 0x90, 0x43,
+	0xE5, 0x95, 0x8F, 0x43, 0xE5, 0x95, 0x93, 0x43,
+	0xE5, 0x95, 0x95, 0x43, 0xE5, 0x95, 0xA3, 0x43,
+	// Bytes 940 - 97f
+	0xE5, 0x96, 0x84, 0x43, 0xE5, 0x96, 0x87, 0x43,
+	0xE5, 0x96, 0x99, 0x43, 0xE5, 0x96, 0x9D, 0x43,
+	0xE5, 0x96, 0xAB, 0x43, 0xE5, 0x96, 0xB3, 0x43,
+	0xE5, 0x96, 0xB6, 0x43, 0xE5, 0x97, 0x80, 0x43,
+	0xE5, 0x97, 0x82, 0x43, 0xE5, 0x97, 0xA2, 0x43,
+	0xE5, 0x98, 0x86, 0x43, 0xE5, 0x99, 0x91, 0x43,
+	0xE5, 0x99, 0xA8, 0x43, 0xE5, 0x99, 0xB4, 0x43,
+	0xE5, 0x9B, 0x97, 0x43, 0xE5, 0x9B, 0x9B, 0x43,
+	// Bytes 980 - 9bf
+	0xE5, 0x9B, 0xB9, 0x43, 0xE5, 0x9C, 0x96, 0x43,
+	0xE5, 0x9C, 0x97, 0x43, 0xE5, 0x9C, 0x9F, 0x43,
+	0xE5, 0x9C, 0xB0, 0x43, 0xE5, 0x9E, 0x8B, 0x43,
+	0xE5, 0x9F, 0x8E, 0x43, 0xE5, 0x9F, 0xB4, 0x43,
+	0xE5, 0xA0, 0x8D, 0x43, 0xE5, 0xA0, 0xB1, 0x43,
+	0xE5, 0xA0, 0xB2, 0x43, 0xE5, 0xA1, 0x80, 0x43,
+	0xE5, 0xA1, 0x9A, 0x43, 0xE5, 0xA1, 0x9E, 0x43,
+	0xE5, 0xA2, 0xA8, 0x43, 0xE5, 0xA2, 0xAC, 0x43,
+	// Bytes 9c0 - 9ff
+	0xE5, 0xA2, 0xB3, 0x43, 0xE5, 0xA3, 0x98, 0x43,
+	0xE5, 0xA3, 0x9F, 0x43, 0xE5, 0xA3, 0xAB, 0x43,
+	0xE5, 0xA3, 0xAE, 0x43, 0xE5, 0xA3, 0xB0, 0x43,
+	0xE5, 0xA3, 0xB2, 0x43, 0xE5, 0xA3, 0xB7, 0x43,
+	0xE5, 0xA4, 0x82, 0x43, 0xE5, 0xA4, 0x86, 0x43,
+	0xE5, 0xA4, 0x8A, 0x43, 0xE5, 0xA4, 0x95, 0x43,
+	0xE5, 0xA4, 0x9A, 0x43, 0xE5, 0xA4, 0x9C, 0x43,
+	0xE5, 0xA4, 0xA2, 0x43, 0xE5, 0xA4, 0xA7, 0x43,
+	// Bytes a00 - a3f
+	0xE5, 0xA4, 0xA9, 0x43, 0xE5, 0xA5, 0x84, 0x43,
+	0xE5, 0xA5, 0x88, 0x43, 0xE5, 0xA5, 0x91, 0x43,
+	0xE5, 0xA5, 0x94, 0x43, 0xE5, 0xA5, 0xA2, 0x43,
+	0xE5, 0xA5, 0xB3, 0x43, 0xE5, 0xA7, 0x98, 0x43,
+	0xE5, 0xA7, 0xAC, 0x43, 0xE5, 0xA8, 0x9B, 0x43,
+	0xE5, 0xA8, 0xA7, 0x43, 0xE5, 0xA9, 0xA2, 0x43,
+	0xE5, 0xA9, 0xA6, 0x43, 0xE5, 0xAA, 0xB5, 0x43,
+	0xE5, 0xAC, 0x88, 0x43, 0xE5, 0xAC, 0xA8, 0x43,
+	// Bytes a40 - a7f
+	0xE5, 0xAC, 0xBE, 0x43, 0xE5, 0xAD, 0x90, 0x43,
+	0xE5, 0xAD, 0x97, 0x43, 0xE5, 0xAD, 0xA6, 0x43,
+	0xE5, 0xAE, 0x80, 0x43, 0xE5, 0xAE, 0x85, 0x43,
+	0xE5, 0xAE, 0x97, 0x43, 0xE5, 0xAF, 0x83, 0x43,
+	0xE5, 0xAF, 0x98, 0x43, 0xE5, 0xAF, 0xA7, 0x43,
+	0xE5, 0xAF, 0xAE, 0x43, 0xE5, 0xAF, 0xB3, 0x43,
+	0xE5, 0xAF, 0xB8, 0x43, 0xE5, 0xAF, 0xBF, 0x43,
+	0xE5, 0xB0, 0x86, 0x43, 0xE5, 0xB0, 0x8F, 0x43,
+	// Bytes a80 - abf
+	0xE5, 0xB0, 0xA2, 0x43, 0xE5, 0xB0, 0xB8, 0x43,
+	0xE5, 0xB0, 0xBF, 0x43, 0xE5, 0xB1, 0xA0, 0x43,
+	0xE5, 0xB1, 0xA2, 0x43, 0xE5, 0xB1, 0xA4, 0x43,
+	0xE5, 0xB1, 0xA5, 0x43, 0xE5, 0xB1, 0xAE, 0x43,
+	0xE5, 0xB1, 0xB1, 0x43, 0xE5, 0xB2, 0x8D, 0x43,
+	0xE5, 0xB3, 0x80, 0x43, 0xE5, 0xB4, 0x99, 0x43,
+	0xE5, 0xB5, 0x83, 0x43, 0xE5, 0xB5, 0x90, 0x43,
+	0xE5, 0xB5, 0xAB, 0x43, 0xE5, 0xB5, 0xAE, 0x43,
+	// Bytes ac0 - aff
+	0xE5, 0xB5, 0xBC, 0x43, 0xE5, 0xB6, 0xB2, 0x43,
+	0xE5, 0xB6, 0xBA, 0x43, 0xE5, 0xB7, 0x9B, 0x43,
+	0xE5, 0xB7, 0xA1, 0x43, 0xE5, 0xB7, 0xA2, 0x43,
+	0xE5, 0xB7, 0xA5, 0x43, 0xE5, 0xB7, 0xA6, 0x43,
+	0xE5, 0xB7, 0xB1, 0x43, 0xE5, 0xB7, 0xBD, 0x43,
+	0xE5, 0xB7, 0xBE, 0x43, 0xE5, 0xB8, 0xA8, 0x43,
+	0xE5, 0xB8, 0xBD, 0x43, 0xE5, 0xB9, 0xA9, 0x43,
+	0xE5, 0xB9, 0xB2, 0x43, 0xE5, 0xB9, 0xB4, 0x43,
+	// Bytes b00 - b3f
+	0xE5, 0xB9, 0xBA, 0x43, 0xE5, 0xB9, 0xBC, 0x43,
+	0xE5, 0xB9, 0xBF, 0x43, 0xE5, 0xBA, 0xA6, 0x43,
+	0xE5, 0xBA, 0xB0, 0x43, 0xE5, 0xBA, 0xB3, 0x43,
+	0xE5, 0xBA, 0xB6, 0x43, 0xE5, 0xBB, 0x89, 0x43,
+	0xE5, 0xBB, 0x8A, 0x43, 0xE5, 0xBB, 0x92, 0x43,
+	0xE5, 0xBB, 0x93, 0x43, 0xE5, 0xBB, 0x99, 0x43,
+	0xE5, 0xBB, 0xAC, 0x43, 0xE5, 0xBB, 0xB4, 0x43,
+	0xE5, 0xBB, 0xBE, 0x43, 0xE5, 0xBC, 0x84, 0x43,
+	// Bytes b40 - b7f
+	0xE5, 0xBC, 0x8B, 0x43, 0xE5, 0xBC, 0x93, 0x43,
+	0xE5, 0xBC, 0xA2, 0x43, 0xE5, 0xBD, 0x90, 0x43,
+	0xE5, 0xBD, 0x93, 0x43, 0xE5, 0xBD, 0xA1, 0x43,
+	0xE5, 0xBD, 0xA2, 0x43, 0xE5, 0xBD, 0xA9, 0x43,
+	0xE5, 0xBD, 0xAB, 0x43, 0xE5, 0xBD, 0xB3, 0x43,
+	0xE5, 0xBE, 0x8B, 0x43, 0xE5, 0xBE, 0x8C, 0x43,
+	0xE5, 0xBE, 0x97, 0x43, 0xE5, 0xBE, 0x9A, 0x43,
+	0xE5, 0xBE, 0xA9, 0x43, 0xE5, 0xBE, 0xAD, 0x43,
+	// Bytes b80 - bbf
+	0xE5, 0xBF, 0x83, 0x43, 0xE5, 0xBF, 0x8D, 0x43,
+	0xE5, 0xBF, 0x97, 0x43, 0xE5, 0xBF, 0xB5, 0x43,
+	0xE5, 0xBF, 0xB9, 0x43, 0xE6, 0x80, 0x92, 0x43,
+	0xE6, 0x80, 0x9C, 0x43, 0xE6, 0x81, 0xB5, 0x43,
+	0xE6, 0x82, 0x81, 0x43, 0xE6, 0x82, 0x94, 0x43,
+	0xE6, 0x83, 0x87, 0x43, 0xE6, 0x83, 0x98, 0x43,
+	0xE6, 0x83, 0xA1, 0x43, 0xE6, 0x84, 0x88, 0x43,
+	0xE6, 0x85, 0x84, 0x43, 0xE6, 0x85, 0x88, 0x43,
+	// Bytes bc0 - bff
+	0xE6, 0x85, 0x8C, 0x43, 0xE6, 0x85, 0x8E, 0x43,
+	0xE6, 0x85, 0xA0, 0x43, 0xE6, 0x85, 0xA8, 0x43,
+	0xE6, 0x85, 0xBA, 0x43, 0xE6, 0x86, 0x8E, 0x43,
+	0xE6, 0x86, 0x90, 0x43, 0xE6, 0x86, 0xA4, 0x43,
+	0xE6, 0x86, 0xAF, 0x43, 0xE6, 0x86, 0xB2, 0x43,
+	0xE6, 0x87, 0x9E, 0x43, 0xE6, 0x87, 0xB2, 0x43,
+	0xE6, 0x87, 0xB6, 0x43, 0xE6, 0x88, 0x80, 0x43,
+	0xE6, 0x88, 0x88, 0x43, 0xE6, 0x88, 0x90, 0x43,
+	// Bytes c00 - c3f
+	0xE6, 0x88, 0x9B, 0x43, 0xE6, 0x88, 0xAE, 0x43,
+	0xE6, 0x88, 0xB4, 0x43, 0xE6, 0x88, 0xB6, 0x43,
+	0xE6, 0x89, 0x8B, 0x43, 0xE6, 0x89, 0x93, 0x43,
+	0xE6, 0x89, 0x9D, 0x43, 0xE6, 0x8A, 0x95, 0x43,
+	0xE6, 0x8A, 0xB1, 0x43, 0xE6, 0x8B, 0x89, 0x43,
+	0xE6, 0x8B, 0x8F, 0x43, 0xE6, 0x8B, 0x93, 0x43,
+	0xE6, 0x8B, 0x94, 0x43, 0xE6, 0x8B, 0xBC, 0x43,
+	0xE6, 0x8B, 0xBE, 0x43, 0xE6, 0x8C, 0x87, 0x43,
+	// Bytes c40 - c7f
+	0xE6, 0x8C, 0xBD, 0x43, 0xE6, 0x8D, 0x90, 0x43,
+	0xE6, 0x8D, 0x95, 0x43, 0xE6, 0x8D, 0xA8, 0x43,
+	0xE6, 0x8D, 0xBB, 0x43, 0xE6, 0x8E, 0x83, 0x43,
+	0xE6, 0x8E, 0xA0, 0x43, 0xE6, 0x8E, 0xA9, 0x43,
+	0xE6, 0x8F, 0x84, 0x43, 0xE6, 0x8F, 0x85, 0x43,
+	0xE6, 0x8F, 0xA4, 0x43, 0xE6, 0x90, 0x9C, 0x43,
+	0xE6, 0x90, 0xA2, 0x43, 0xE6, 0x91, 0x92, 0x43,
+	0xE6, 0x91, 0xA9, 0x43, 0xE6, 0x91, 0xB7, 0x43,
+	// Bytes c80 - cbf
+	0xE6, 0x91, 0xBE, 0x43, 0xE6, 0x92, 0x9A, 0x43,
+	0xE6, 0x92, 0x9D, 0x43, 0xE6, 0x93, 0x84, 0x43,
+	0xE6, 0x94, 0xAF, 0x43, 0xE6, 0x94, 0xB4, 0x43,
+	0xE6, 0x95, 0x8F, 0x43, 0xE6, 0x95, 0x96, 0x43,
+	0xE6, 0x95, 0xAC, 0x43, 0xE6, 0x95, 0xB8, 0x43,
+	0xE6, 0x96, 0x87, 0x43, 0xE6, 0x96, 0x97, 0x43,
+	0xE6, 0x96, 0x99, 0x43, 0xE6, 0x96, 0xA4, 0x43,
+	0xE6, 0x96, 0xB0, 0x43, 0xE6, 0x96, 0xB9, 0x43,
+	// Bytes cc0 - cff
+	0xE6, 0x97, 0x85, 0x43, 0xE6, 0x97, 0xA0, 0x43,
+	0xE6, 0x97, 0xA2, 0x43, 0xE6, 0x97, 0xA3, 0x43,
+	0xE6, 0x97, 0xA5, 0x43, 0xE6, 0x98, 0x93, 0x43,
+	0xE6, 0x98, 0xA0, 0x43, 0xE6, 0x99, 0x89, 0x43,
+	0xE6, 0x99, 0xB4, 0x43, 0xE6, 0x9A, 0x88, 0x43,
+	0xE6, 0x9A, 0x91, 0x43, 0xE6, 0x9A, 0x9C, 0x43,
+	0xE6, 0x9A, 0xB4, 0x43, 0xE6, 0x9B, 0x86, 0x43,
+	0xE6, 0x9B, 0xB0, 0x43, 0xE6, 0x9B, 0xB4, 0x43,
+	// Bytes d00 - d3f
+	0xE6, 0x9B, 0xB8, 0x43, 0xE6, 0x9C, 0x80, 0x43,
+	0xE6, 0x9C, 0x88, 0x43, 0xE6, 0x9C, 0x89, 0x43,
+	0xE6, 0x9C, 0x97, 0x43, 0xE6, 0x9C, 0x9B, 0x43,
+	0xE6, 0x9C, 0xA1, 0x43, 0xE6, 0x9C, 0xA8, 0x43,
+	0xE6, 0x9D, 0x8E, 0x43, 0xE6, 0x9D, 0x93, 0x43,
+	0xE6, 0x9D, 0x96, 0x43, 0xE6, 0x9D, 0x9E, 0x43,
+	0xE6, 0x9D, 0xBB, 0x43, 0xE6, 0x9E, 0x85, 0x43,
+	0xE6, 0x9E, 0x97, 0x43, 0xE6, 0x9F, 0xB3, 0x43,
+	// Bytes d40 - d7f
+	0xE6, 0x9F, 0xBA, 0x43, 0xE6, 0xA0, 0x97, 0x43,
+	0xE6, 0xA0, 0x9F, 0x43, 0xE6, 0xA0, 0xAA, 0x43,
+	0xE6, 0xA1, 0x92, 0x43, 0xE6, 0xA2, 0x81, 0x43,
+	0xE6, 0xA2, 0x85, 0x43, 0xE6, 0xA2, 0x8E, 0x43,
+	0xE6, 0xA2, 0xA8, 0x43, 0xE6, 0xA4, 0x94, 0x43,
+	0xE6, 0xA5, 0x82, 0x43, 0xE6, 0xA6, 0xA3, 0x43,
+	0xE6, 0xA7, 0xAA, 0x43, 0xE6, 0xA8, 0x82, 0x43,
+	0xE6, 0xA8, 0x93, 0x43, 0xE6, 0xAA, 0xA8, 0x43,
+	// Bytes d80 - dbf
+	0xE6, 0xAB, 0x93, 0x43, 0xE6, 0xAB, 0x9B, 0x43,
+	0xE6, 0xAC, 0x84, 0x43, 0xE6, 0xAC, 0xA0, 0x43,
+	0xE6, 0xAC, 0xA1, 0x43, 0xE6, 0xAD, 0x94, 0x43,
+	0xE6, 0xAD, 0xA2, 0x43, 0xE6, 0xAD, 0xA3, 0x43,
+	0xE6, 0xAD, 0xB2, 0x43, 0xE6, 0xAD, 0xB7, 0x43,
+	0xE6, 0xAD, 0xB9, 0x43, 0xE6, 0xAE, 0x9F, 0x43,
+	0xE6, 0xAE, 0xAE, 0x43, 0xE6, 0xAE, 0xB3, 0x43,
+	0xE6, 0xAE, 0xBA, 0x43, 0xE6, 0xAE, 0xBB, 0x43,
+	// Bytes dc0 - dff
+	0xE6, 0xAF, 0x8B, 0x43, 0xE6, 0xAF, 0x8D, 0x43,
+	0xE6, 0xAF, 0x94, 0x43, 0xE6, 0xAF, 0x9B, 0x43,
+	0xE6, 0xB0, 0x8F, 0x43, 0xE6, 0xB0, 0x94, 0x43,
+	0xE6, 0xB0, 0xB4, 0x43, 0xE6, 0xB1, 0x8E, 0x43,
+	0xE6, 0xB1, 0xA7, 0x43, 0xE6, 0xB2, 0x88, 0x43,
+	0xE6, 0xB2, 0xBF, 0x43, 0xE6, 0xB3, 0x8C, 0x43,
+	0xE6, 0xB3, 0x8D, 0x43, 0xE6, 0xB3, 0xA5, 0x43,
+	0xE6, 0xB3, 0xA8, 0x43, 0xE6, 0xB4, 0x96, 0x43,
+	// Bytes e00 - e3f
+	0xE6, 0xB4, 0x9B, 0x43, 0xE6, 0xB4, 0x9E, 0x43,
+	0xE6, 0xB4, 0xB4, 0x43, 0xE6, 0xB4, 0xBE, 0x43,
+	0xE6, 0xB5, 0x81, 0x43, 0xE6, 0xB5, 0xA9, 0x43,
+	0xE6, 0xB5, 0xAA, 0x43, 0xE6, 0xB5, 0xB7, 0x43,
+	0xE6, 0xB5, 0xB8, 0x43, 0xE6, 0xB6, 0x85, 0x43,
+	0xE6, 0xB7, 0x8B, 0x43, 0xE6, 0xB7, 0x9A, 0x43,
+	0xE6, 0xB7, 0xAA, 0x43, 0xE6, 0xB7, 0xB9, 0x43,
+	0xE6, 0xB8, 0x9A, 0x43, 0xE6, 0xB8, 0xAF, 0x43,
+	// Bytes e40 - e7f
+	0xE6, 0xB9, 0xAE, 0x43, 0xE6, 0xBA, 0x80, 0x43,
+	0xE6, 0xBA, 0x9C, 0x43, 0xE6, 0xBA, 0xBA, 0x43,
+	0xE6, 0xBB, 0x87, 0x43, 0xE6, 0xBB, 0x8B, 0x43,
+	0xE6, 0xBB, 0x91, 0x43, 0xE6, 0xBB, 0x9B, 0x43,
+	0xE6, 0xBC, 0x8F, 0x43, 0xE6, 0xBC, 0x94, 0x43,
+	0xE6, 0xBC, 0xA2, 0x43, 0xE6, 0xBC, 0xA3, 0x43,
+	0xE6, 0xBD, 0xAE, 0x43, 0xE6, 0xBF, 0x86, 0x43,
+	0xE6, 0xBF, 0xAB, 0x43, 0xE6, 0xBF, 0xBE, 0x43,
+	// Bytes e80 - ebf
+	0xE7, 0x80, 0x9B, 0x43, 0xE7, 0x80, 0x9E, 0x43,
+	0xE7, 0x80, 0xB9, 0x43, 0xE7, 0x81, 0x8A, 0x43,
+	0xE7, 0x81, 0xAB, 0x43, 0xE7, 0x81, 0xB0, 0x43,
+	0xE7, 0x81, 0xB7, 0x43, 0xE7, 0x81, 0xBD, 0x43,
+	0xE7, 0x82, 0x99, 0x43, 0xE7, 0x82, 0xAD, 0x43,
+	0xE7, 0x83, 0x88, 0x43, 0xE7, 0x83, 0x99, 0x43,
+	0xE7, 0x84, 0xA1, 0x43, 0xE7, 0x85, 0x85, 0x43,
+	0xE7, 0x85, 0x89, 0x43, 0xE7, 0x85, 0xAE, 0x43,
+	// Bytes ec0 - eff
+	0xE7, 0x86, 0x9C, 0x43, 0xE7, 0x87, 0x8E, 0x43,
+	0xE7, 0x87, 0x90, 0x43, 0xE7, 0x88, 0x90, 0x43,
+	0xE7, 0x88, 0x9B, 0x43, 0xE7, 0x88, 0xA8, 0x43,
+	0xE7, 0x88, 0xAA, 0x43, 0xE7, 0x88, 0xAB, 0x43,
+	0xE7, 0x88, 0xB5, 0x43, 0xE7, 0x88, 0xB6, 0x43,
+	0xE7, 0x88, 0xBB, 0x43, 0xE7, 0x88, 0xBF, 0x43,
+	0xE7, 0x89, 0x87, 0x43, 0xE7, 0x89, 0x90, 0x43,
+	0xE7, 0x89, 0x99, 0x43, 0xE7, 0x89, 0x9B, 0x43,
+	// Bytes f00 - f3f
+	0xE7, 0x89, 0xA2, 0x43, 0xE7, 0x89, 0xB9, 0x43,
+	0xE7, 0x8A, 0x80, 0x43, 0xE7, 0x8A, 0x95, 0x43,
+	0xE7, 0x8A, 0xAC, 0x43, 0xE7, 0x8A, 0xAF, 0x43,
+	0xE7, 0x8B, 0x80, 0x43, 0xE7, 0x8B, 0xBC, 0x43,
+	0xE7, 0x8C, 0xAA, 0x43, 0xE7, 0x8D, 0xB5, 0x43,
+	0xE7, 0x8D, 0xBA, 0x43, 0xE7, 0x8E, 0x84, 0x43,
+	0xE7, 0x8E, 0x87, 0x43, 0xE7, 0x8E, 0x89, 0x43,
+	0xE7, 0x8E, 0x8B, 0x43, 0xE7, 0x8E, 0xA5, 0x43,
+	// Bytes f40 - f7f
+	0xE7, 0x8E, 0xB2, 0x43, 0xE7, 0x8F, 0x9E, 0x43,
+	0xE7, 0x90, 0x86, 0x43, 0xE7, 0x90, 0x89, 0x43,
+	0xE7, 0x90, 0xA2, 0x43, 0xE7, 0x91, 0x87, 0x43,
+	0xE7, 0x91, 0x9C, 0x43, 0xE7, 0x91, 0xA9, 0x43,
+	0xE7, 0x91, 0xB1, 0x43, 0xE7, 0x92, 0x85, 0x43,
+	0xE7, 0x92, 0x89, 0x43, 0xE7, 0x92, 0x98, 0x43,
+	0xE7, 0x93, 0x8A, 0x43, 0xE7, 0x93, 0x9C, 0x43,
+	0xE7, 0x93, 0xA6, 0x43, 0xE7, 0x94, 0x86, 0x43,
+	// Bytes f80 - fbf
+	0xE7, 0x94, 0x98, 0x43, 0xE7, 0x94, 0x9F, 0x43,
+	0xE7, 0x94, 0xA4, 0x43, 0xE7, 0x94, 0xA8, 0x43,
+	0xE7, 0x94, 0xB0, 0x43, 0xE7, 0x94, 0xB2, 0x43,
+	0xE7, 0x94, 0xB3, 0x43, 0xE7, 0x94, 0xB7, 0x43,
+	0xE7, 0x94, 0xBB, 0x43, 0xE7, 0x94, 0xBE, 0x43,
+	0xE7, 0x95, 0x99, 0x43, 0xE7, 0x95, 0xA5, 0x43,
+	0xE7, 0x95, 0xB0, 0x43, 0xE7, 0x96, 0x8B, 0x43,
+	0xE7, 0x96, 0x92, 0x43, 0xE7, 0x97, 0xA2, 0x43,
+	// Bytes fc0 - fff
+	0xE7, 0x98, 0x90, 0x43, 0xE7, 0x98, 0x9D, 0x43,
+	0xE7, 0x98, 0x9F, 0x43, 0xE7, 0x99, 0x82, 0x43,
+	0xE7, 0x99, 0xA9, 0x43, 0xE7, 0x99, 0xB6, 0x43,
+	0xE7, 0x99, 0xBD, 0x43, 0xE7, 0x9A, 0xAE, 0x43,
+	0xE7, 0x9A, 0xBF, 0x43, 0xE7, 0x9B, 0x8A, 0x43,
+	0xE7, 0x9B, 0x9B, 0x43, 0xE7, 0x9B, 0xA3, 0x43,
+	0xE7, 0x9B, 0xA7, 0x43, 0xE7, 0x9B, 0xAE, 0x43,
+	0xE7, 0x9B, 0xB4, 0x43, 0xE7, 0x9C, 0x81, 0x43,
+	// Bytes 1000 - 103f
+	0xE7, 0x9C, 0x9E, 0x43, 0xE7, 0x9C, 0x9F, 0x43,
+	0xE7, 0x9D, 0x80, 0x43, 0xE7, 0x9D, 0x8A, 0x43,
+	0xE7, 0x9E, 0x8B, 0x43, 0xE7, 0x9E, 0xA7, 0x43,
+	0xE7, 0x9F, 0x9B, 0x43, 0xE7, 0x9F, 0xA2, 0x43,
+	0xE7, 0x9F, 0xB3, 0x43, 0xE7, 0xA1, 0x8E, 0x43,
+	0xE7, 0xA1, 0xAB, 0x43, 0xE7, 0xA2, 0x8C, 0x43,
+	0xE7, 0xA2, 0x91, 0x43, 0xE7, 0xA3, 0x8A, 0x43,
+	0xE7, 0xA3, 0x8C, 0x43, 0xE7, 0xA3, 0xBB, 0x43,
+	// Bytes 1040 - 107f
+	0xE7, 0xA4, 0xAA, 0x43, 0xE7, 0xA4, 0xBA, 0x43,
+	0xE7, 0xA4, 0xBC, 0x43, 0xE7, 0xA4, 0xBE, 0x43,
+	0xE7, 0xA5, 0x88, 0x43, 0xE7, 0xA5, 0x89, 0x43,
+	0xE7, 0xA5, 0x90, 0x43, 0xE7, 0xA5, 0x96, 0x43,
+	0xE7, 0xA5, 0x9D, 0x43, 0xE7, 0xA5, 0x9E, 0x43,
+	0xE7, 0xA5, 0xA5, 0x43, 0xE7, 0xA5, 0xBF, 0x43,
+	0xE7, 0xA6, 0x81, 0x43, 0xE7, 0xA6, 0x8D, 0x43,
+	0xE7, 0xA6, 0x8E, 0x43, 0xE7, 0xA6, 0x8F, 0x43,
+	// Bytes 1080 - 10bf
+	0xE7, 0xA6, 0xAE, 0x43, 0xE7, 0xA6, 0xB8, 0x43,
+	0xE7, 0xA6, 0xBE, 0x43, 0xE7, 0xA7, 0x8A, 0x43,
+	0xE7, 0xA7, 0x98, 0x43, 0xE7, 0xA7, 0xAB, 0x43,
+	0xE7, 0xA8, 0x9C, 0x43, 0xE7, 0xA9, 0x80, 0x43,
+	0xE7, 0xA9, 0x8A, 0x43, 0xE7, 0xA9, 0x8F, 0x43,
+	0xE7, 0xA9, 0xB4, 0x43, 0xE7, 0xA9, 0xBA, 0x43,
+	0xE7, 0xAA, 0x81, 0x43, 0xE7, 0xAA, 0xB1, 0x43,
+	0xE7, 0xAB, 0x8B, 0x43, 0xE7, 0xAB, 0xAE, 0x43,
+	// Bytes 10c0 - 10ff
+	0xE7, 0xAB, 0xB9, 0x43, 0xE7, 0xAC, 0xA0, 0x43,
+	0xE7, 0xAE, 0x8F, 0x43, 0xE7, 0xAF, 0x80, 0x43,
+	0xE7, 0xAF, 0x86, 0x43, 0xE7, 0xAF, 0x89, 0x43,
+	0xE7, 0xB0, 0xBE, 0x43, 0xE7, 0xB1, 0xA0, 0x43,
+	0xE7, 0xB1, 0xB3, 0x43, 0xE7, 0xB1, 0xBB, 0x43,
+	0xE7, 0xB2, 0x92, 0x43, 0xE7, 0xB2, 0xBE, 0x43,
+	0xE7, 0xB3, 0x92, 0x43, 0xE7, 0xB3, 0x96, 0x43,
+	0xE7, 0xB3, 0xA3, 0x43, 0xE7, 0xB3, 0xA7, 0x43,
+	// Bytes 1100 - 113f
+	0xE7, 0xB3, 0xA8, 0x43, 0xE7, 0xB3, 0xB8, 0x43,
+	0xE7, 0xB4, 0x80, 0x43, 0xE7, 0xB4, 0x90, 0x43,
+	0xE7, 0xB4, 0xA2, 0x43, 0xE7, 0xB4, 0xAF, 0x43,
+	0xE7, 0xB5, 0x82, 0x43, 0xE7, 0xB5, 0x9B, 0x43,
+	0xE7, 0xB5, 0xA3, 0x43, 0xE7, 0xB6, 0xA0, 0x43,
+	0xE7, 0xB6, 0xBE, 0x43, 0xE7, 0xB7, 0x87, 0x43,
+	0xE7, 0xB7, 0xB4, 0x43, 0xE7, 0xB8, 0x82, 0x43,
+	0xE7, 0xB8, 0x89, 0x43, 0xE7, 0xB8, 0xB7, 0x43,
+	// Bytes 1140 - 117f
+	0xE7, 0xB9, 0x81, 0x43, 0xE7, 0xB9, 0x85, 0x43,
+	0xE7, 0xBC, 0xB6, 0x43, 0xE7, 0xBC, 0xBE, 0x43,
+	0xE7, 0xBD, 0x91, 0x43, 0xE7, 0xBD, 0xB2, 0x43,
+	0xE7, 0xBD, 0xB9, 0x43, 0xE7, 0xBD, 0xBA, 0x43,
+	0xE7, 0xBE, 0x85, 0x43, 0xE7, 0xBE, 0x8A, 0x43,
+	0xE7, 0xBE, 0x95, 0x43, 0xE7, 0xBE, 0x9A, 0x43,
+	0xE7, 0xBE, 0xBD, 0x43, 0xE7, 0xBF, 0xBA, 0x43,
+	0xE8, 0x80, 0x81, 0x43, 0xE8, 0x80, 0x85, 0x43,
+	// Bytes 1180 - 11bf
+	0xE8, 0x80, 0x8C, 0x43, 0xE8, 0x80, 0x92, 0x43,
+	0xE8, 0x80, 0xB3, 0x43, 0xE8, 0x81, 0x86, 0x43,
+	0xE8, 0x81, 0xA0, 0x43, 0xE8, 0x81, 0xAF, 0x43,
+	0xE8, 0x81, 0xB0, 0x43, 0xE8, 0x81, 0xBE, 0x43,
+	0xE8, 0x81, 0xBF, 0x43, 0xE8, 0x82, 0x89, 0x43,
+	0xE8, 0x82, 0x8B, 0x43, 0xE8, 0x82, 0xAD, 0x43,
+	0xE8, 0x82, 0xB2, 0x43, 0xE8, 0x84, 0x83, 0x43,
+	0xE8, 0x84, 0xBE, 0x43, 0xE8, 0x87, 0x98, 0x43,
+	// Bytes 11c0 - 11ff
+	0xE8, 0x87, 0xA3, 0x43, 0xE8, 0x87, 0xA8, 0x43,
+	0xE8, 0x87, 0xAA, 0x43, 0xE8, 0x87, 0xAD, 0x43,
+	0xE8, 0x87, 0xB3, 0x43, 0xE8, 0x87, 0xBC, 0x43,
+	0xE8, 0x88, 0x81, 0x43, 0xE8, 0x88, 0x84, 0x43,
+	0xE8, 0x88, 0x8C, 0x43, 0xE8, 0x88, 0x98, 0x43,
+	0xE8, 0x88, 0x9B, 0x43, 0xE8, 0x88, 0x9F, 0x43,
+	0xE8, 0x89, 0xAE, 0x43, 0xE8, 0x89, 0xAF, 0x43,
+	0xE8, 0x89, 0xB2, 0x43, 0xE8, 0x89, 0xB8, 0x43,
+	// Bytes 1200 - 123f
+	0xE8, 0x89, 0xB9, 0x43, 0xE8, 0x8A, 0x8B, 0x43,
+	0xE8, 0x8A, 0x91, 0x43, 0xE8, 0x8A, 0x9D, 0x43,
+	0xE8, 0x8A, 0xB1, 0x43, 0xE8, 0x8A, 0xB3, 0x43,
+	0xE8, 0x8A, 0xBD, 0x43, 0xE8, 0x8B, 0xA5, 0x43,
+	0xE8, 0x8B, 0xA6, 0x43, 0xE8, 0x8C, 0x9D, 0x43,
+	0xE8, 0x8C, 0xA3, 0x43, 0xE8, 0x8C, 0xB6, 0x43,
+	0xE8, 0x8D, 0x92, 0x43, 0xE8, 0x8D, 0x93, 0x43,
+	0xE8, 0x8D, 0xA3, 0x43, 0xE8, 0x8E, 0xAD, 0x43,
+	// Bytes 1240 - 127f
+	0xE8, 0x8E, 0xBD, 0x43, 0xE8, 0x8F, 0x89, 0x43,
+	0xE8, 0x8F, 0x8A, 0x43, 0xE8, 0x8F, 0x8C, 0x43,
+	0xE8, 0x8F, 0x9C, 0x43, 0xE8, 0x8F, 0xA7, 0x43,
+	0xE8, 0x8F, 0xAF, 0x43, 0xE8, 0x8F, 0xB1, 0x43,
+	0xE8, 0x90, 0xBD, 0x43, 0xE8, 0x91, 0x89, 0x43,
+	0xE8, 0x91, 0x97, 0x43, 0xE8, 0x93, 0xAE, 0x43,
+	0xE8, 0x93, 0xB1, 0x43, 0xE8, 0x93, 0xB3, 0x43,
+	0xE8, 0x93, 0xBC, 0x43, 0xE8, 0x94, 0x96, 0x43,
+	// Bytes 1280 - 12bf
+	0xE8, 0x95, 0xA4, 0x43, 0xE8, 0x97, 0x8D, 0x43,
+	0xE8, 0x97, 0xBA, 0x43, 0xE8, 0x98, 0x86, 0x43,
+	0xE8, 0x98, 0x92, 0x43, 0xE8, 0x98, 0xAD, 0x43,
+	0xE8, 0x98, 0xBF, 0x43, 0xE8, 0x99, 0x8D, 0x43,
+	0xE8, 0x99, 0x90, 0x43, 0xE8, 0x99, 0x9C, 0x43,
+	0xE8, 0x99, 0xA7, 0x43, 0xE8, 0x99, 0xA9, 0x43,
+	0xE8, 0x99, 0xAB, 0x43, 0xE8, 0x9A, 0x88, 0x43,
+	0xE8, 0x9A, 0xA9, 0x43, 0xE8, 0x9B, 0xA2, 0x43,
+	// Bytes 12c0 - 12ff
+	0xE8, 0x9C, 0x8E, 0x43, 0xE8, 0x9C, 0xA8, 0x43,
+	0xE8, 0x9D, 0xAB, 0x43, 0xE8, 0x9D, 0xB9, 0x43,
+	0xE8, 0x9E, 0x86, 0x43, 0xE8, 0x9E, 0xBA, 0x43,
+	0xE8, 0x9F, 0xA1, 0x43, 0xE8, 0xA0, 0x81, 0x43,
+	0xE8, 0xA0, 0x9F, 0x43, 0xE8, 0xA1, 0x80, 0x43,
+	0xE8, 0xA1, 0x8C, 0x43, 0xE8, 0xA1, 0xA0, 0x43,
+	0xE8, 0xA1, 0xA3, 0x43, 0xE8, 0xA3, 0x82, 0x43,
+	0xE8, 0xA3, 0x8F, 0x43, 0xE8, 0xA3, 0x97, 0x43,
+	// Bytes 1300 - 133f
+	0xE8, 0xA3, 0x9E, 0x43, 0xE8, 0xA3, 0xA1, 0x43,
+	0xE8, 0xA3, 0xB8, 0x43, 0xE8, 0xA3, 0xBA, 0x43,
+	0xE8, 0xA4, 0x90, 0x43, 0xE8, 0xA5, 0x81, 0x43,
+	0xE8, 0xA5, 0xA4, 0x43, 0xE8, 0xA5, 0xBE, 0x43,
+	0xE8, 0xA6, 0x86, 0x43, 0xE8, 0xA6, 0x8B, 0x43,
+	0xE8, 0xA6, 0x96, 0x43, 0xE8, 0xA7, 0x92, 0x43,
+	0xE8, 0xA7, 0xA3, 0x43, 0xE8, 0xA8, 0x80, 0x43,
+	0xE8, 0xAA, 0xA0, 0x43, 0xE8, 0xAA, 0xAA, 0x43,
+	// Bytes 1340 - 137f
+	0xE8, 0xAA, 0xBF, 0x43, 0xE8, 0xAB, 0x8B, 0x43,
+	0xE8, 0xAB, 0x92, 0x43, 0xE8, 0xAB, 0x96, 0x43,
+	0xE8, 0xAB, 0xAD, 0x43, 0xE8, 0xAB, 0xB8, 0x43,
+	0xE8, 0xAB, 0xBE, 0x43, 0xE8, 0xAC, 0x81, 0x43,
+	0xE8, 0xAC, 0xB9, 0x43, 0xE8, 0xAD, 0x98, 0x43,
+	0xE8, 0xAE, 0x80, 0x43, 0xE8, 0xAE, 0x8A, 0x43,
+	0xE8, 0xB0, 0xB7, 0x43, 0xE8, 0xB1, 0x86, 0x43,
+	0xE8, 0xB1, 0x88, 0x43, 0xE8, 0xB1, 0x95, 0x43,
+	// Bytes 1380 - 13bf
+	0xE8, 0xB1, 0xB8, 0x43, 0xE8, 0xB2, 0x9D, 0x43,
+	0xE8, 0xB2, 0xA1, 0x43, 0xE8, 0xB2, 0xA9, 0x43,
+	0xE8, 0xB2, 0xAB, 0x43, 0xE8, 0xB3, 0x81, 0x43,
+	0xE8, 0xB3, 0x82, 0x43, 0xE8, 0xB3, 0x87, 0x43,
+	0xE8, 0xB3, 0x88, 0x43, 0xE8, 0xB3, 0x93, 0x43,
+	0xE8, 0xB4, 0x88, 0x43, 0xE8, 0xB4, 0x9B, 0x43,
+	0xE8, 0xB5, 0xA4, 0x43, 0xE8, 0xB5, 0xB0, 0x43,
+	0xE8, 0xB5, 0xB7, 0x43, 0xE8, 0xB6, 0xB3, 0x43,
+	// Bytes 13c0 - 13ff
+	0xE8, 0xB6, 0xBC, 0x43, 0xE8, 0xB7, 0x8B, 0x43,
+	0xE8, 0xB7, 0xAF, 0x43, 0xE8, 0xB7, 0xB0, 0x43,
+	0xE8, 0xBA, 0xAB, 0x43, 0xE8, 0xBB, 0x8A, 0x43,
+	0xE8, 0xBB, 0x94, 0x43, 0xE8, 0xBC, 0xA6, 0x43,
+	0xE8, 0xBC, 0xAA, 0x43, 0xE8, 0xBC, 0xB8, 0x43,
+	0xE8, 0xBC, 0xBB, 0x43, 0xE8, 0xBD, 0xA2, 0x43,
+	0xE8, 0xBE, 0x9B, 0x43, 0xE8, 0xBE, 0x9E, 0x43,
+	0xE8, 0xBE, 0xB0, 0x43, 0xE8, 0xBE, 0xB5, 0x43,
+	// Bytes 1400 - 143f
+	0xE8, 0xBE, 0xB6, 0x43, 0xE9, 0x80, 0xA3, 0x43,
+	0xE9, 0x80, 0xB8, 0x43, 0xE9, 0x81, 0x8A, 0x43,
+	0xE9, 0x81, 0xA9, 0x43, 0xE9, 0x81, 0xB2, 0x43,
+	0xE9, 0x81, 0xBC, 0x43, 0xE9, 0x82, 0x8F, 0x43,
+	0xE9, 0x82, 0x91, 0x43, 0xE9, 0x82, 0x94, 0x43,
+	0xE9, 0x83, 0x8E, 0x43, 0xE9, 0x83, 0x9E, 0x43,
+	0xE9, 0x83, 0xB1, 0x43, 0xE9, 0x83, 0xBD, 0x43,
+	0xE9, 0x84, 0x91, 0x43, 0xE9, 0x84, 0x9B, 0x43,
+	// Bytes 1440 - 147f
+	0xE9, 0x85, 0x89, 0x43, 0xE9, 0x85, 0x8D, 0x43,
+	0xE9, 0x85, 0xAA, 0x43, 0xE9, 0x86, 0x99, 0x43,
+	0xE9, 0x86, 0xB4, 0x43, 0xE9, 0x87, 0x86, 0x43,
+	0xE9, 0x87, 0x8C, 0x43, 0xE9, 0x87, 0x8F, 0x43,
+	0xE9, 0x87, 0x91, 0x43, 0xE9, 0x88, 0xB4, 0x43,
+	0xE9, 0x88, 0xB8, 0x43, 0xE9, 0x89, 0xB6, 0x43,
+	0xE9, 0x89, 0xBC, 0x43, 0xE9, 0x8B, 0x97, 0x43,
+	0xE9, 0x8B, 0x98, 0x43, 0xE9, 0x8C, 0x84, 0x43,
+	// Bytes 1480 - 14bf
+	0xE9, 0x8D, 0x8A, 0x43, 0xE9, 0x8F, 0xB9, 0x43,
+	0xE9, 0x90, 0x95, 0x43, 0xE9, 0x95, 0xB7, 0x43,
+	0xE9, 0x96, 0x80, 0x43, 0xE9, 0x96, 0x8B, 0x43,
+	0xE9, 0x96, 0xAD, 0x43, 0xE9, 0x96, 0xB7, 0x43,
+	0xE9, 0x98, 0x9C, 0x43, 0xE9, 0x98, 0xAE, 0x43,
+	0xE9, 0x99, 0x8B, 0x43, 0xE9, 0x99, 0x8D, 0x43,
+	0xE9, 0x99, 0xB5, 0x43, 0xE9, 0x99, 0xB8, 0x43,
+	0xE9, 0x99, 0xBC, 0x43, 0xE9, 0x9A, 0x86, 0x43,
+	// Bytes 14c0 - 14ff
+	0xE9, 0x9A, 0xA3, 0x43, 0xE9, 0x9A, 0xB6, 0x43,
+	0xE9, 0x9A, 0xB7, 0x43, 0xE9, 0x9A, 0xB8, 0x43,
+	0xE9, 0x9A, 0xB9, 0x43, 0xE9, 0x9B, 0x83, 0x43,
+	0xE9, 0x9B, 0xA2, 0x43, 0xE9, 0x9B, 0xA3, 0x43,
+	0xE9, 0x9B, 0xA8, 0x43, 0xE9, 0x9B, 0xB6, 0x43,
+	0xE9, 0x9B, 0xB7, 0x43, 0xE9, 0x9C, 0xA3, 0x43,
+	0xE9, 0x9C, 0xB2, 0x43, 0xE9, 0x9D, 0x88, 0x43,
+	0xE9, 0x9D, 0x91, 0x43, 0xE9, 0x9D, 0x96, 0x43,
+	// Bytes 1500 - 153f
+	0xE9, 0x9D, 0x9E, 0x43, 0xE9, 0x9D, 0xA2, 0x43,
+	0xE9, 0x9D, 0xA9, 0x43, 0xE9, 0x9F, 0x8B, 0x43,
+	0xE9, 0x9F, 0x9B, 0x43, 0xE9, 0x9F, 0xA0, 0x43,
+	0xE9, 0x9F, 0xAD, 0x43, 0xE9, 0x9F, 0xB3, 0x43,
+	0xE9, 0x9F, 0xBF, 0x43, 0xE9, 0xA0, 0x81, 0x43,
+	0xE9, 0xA0, 0x85, 0x43, 0xE9, 0xA0, 0x8B, 0x43,
+	0xE9, 0xA0, 0x98, 0x43, 0xE9, 0xA0, 0xA9, 0x43,
+	0xE9, 0xA0, 0xBB, 0x43, 0xE9, 0xA1, 0x9E, 0x43,
+	// Bytes 1540 - 157f
+	0xE9, 0xA2, 0xA8, 0x43, 0xE9, 0xA3, 0x9B, 0x43,
+	0xE9, 0xA3, 0x9F, 0x43, 0xE9, 0xA3, 0xA2, 0x43,
+	0xE9, 0xA3, 0xAF, 0x43, 0xE9, 0xA3, 0xBC, 0x43,
+	0xE9, 0xA4, 0xA8, 0x43, 0xE9, 0xA4, 0xA9, 0x43,
+	0xE9, 0xA6, 0x96, 0x43, 0xE9, 0xA6, 0x99, 0x43,
+	0xE9, 0xA6, 0xA7, 0x43, 0xE9, 0xA6, 0xAC, 0x43,
+	0xE9, 0xA7, 0x82, 0x43, 0xE9, 0xA7, 0xB1, 0x43,
+	0xE9, 0xA7, 0xBE, 0x43, 0xE9, 0xA9, 0xAA, 0x43,
+	// Bytes 1580 - 15bf
+	0xE9, 0xAA, 0xA8, 0x43, 0xE9, 0xAB, 0x98, 0x43,
+	0xE9, 0xAB, 0x9F, 0x43, 0xE9, 0xAC, 0x92, 0x43,
+	0xE9, 0xAC, 0xA5, 0x43, 0xE9, 0xAC, 0xAF, 0x43,
+	0xE9, 0xAC, 0xB2, 0x43, 0xE9, 0xAC, 0xBC, 0x43,
+	0xE9, 0xAD, 0x9A, 0x43, 0xE9, 0xAD, 0xAF, 0x43,
+	0xE9, 0xB1, 0x80, 0x43, 0xE9, 0xB1, 0x97, 0x43,
+	0xE9, 0xB3, 0xA5, 0x43, 0xE9, 0xB3, 0xBD, 0x43,
+	0xE9, 0xB5, 0xA7, 0x43, 0xE9, 0xB6, 0xB4, 0x43,
+	// Bytes 15c0 - 15ff
+	0xE9, 0xB7, 0xBA, 0x43, 0xE9, 0xB8, 0x9E, 0x43,
+	0xE9, 0xB9, 0xB5, 0x43, 0xE9, 0xB9, 0xBF, 0x43,
+	0xE9, 0xBA, 0x97, 0x43, 0xE9, 0xBA, 0x9F, 0x43,
+	0xE9, 0xBA, 0xA5, 0x43, 0xE9, 0xBA, 0xBB, 0x43,
+	0xE9, 0xBB, 0x83, 0x43, 0xE9, 0xBB, 0x8D, 0x43,
+	0xE9, 0xBB, 0x8E, 0x43, 0xE9, 0xBB, 0x91, 0x43,
+	0xE9, 0xBB, 0xB9, 0x43, 0xE9, 0xBB, 0xBD, 0x43,
+	0xE9, 0xBB, 0xBE, 0x43, 0xE9, 0xBC, 0x85, 0x43,
+	// Bytes 1600 - 163f
+	0xE9, 0xBC, 0x8E, 0x43, 0xE9, 0xBC, 0x8F, 0x43,
+	0xE9, 0xBC, 0x93, 0x43, 0xE9, 0xBC, 0x96, 0x43,
+	0xE9, 0xBC, 0xA0, 0x43, 0xE9, 0xBC, 0xBB, 0x43,
+	0xE9, 0xBD, 0x83, 0x43, 0xE9, 0xBD, 0x8A, 0x43,
+	0xE9, 0xBD, 0x92, 0x43, 0xE9, 0xBE, 0x8D, 0x43,
+	0xE9, 0xBE, 0x8E, 0x43, 0xE9, 0xBE, 0x9C, 0x43,
+	0xE9, 0xBE, 0x9F, 0x43, 0xE9, 0xBE, 0xA0, 0x43,
+	0xEA, 0x9C, 0xA7, 0x43, 0xEA, 0x9D, 0xAF, 0x43,
+	// Bytes 1640 - 167f
+	0xEA, 0xAC, 0xB7, 0x43, 0xEA, 0xAD, 0x92, 0x44,
+	0xF0, 0xA0, 0x84, 0xA2, 0x44, 0xF0, 0xA0, 0x94,
+	0x9C, 0x44, 0xF0, 0xA0, 0x94, 0xA5, 0x44, 0xF0,
+	0xA0, 0x95, 0x8B, 0x44, 0xF0, 0xA0, 0x98, 0xBA,
+	0x44, 0xF0, 0xA0, 0xA0, 0x84, 0x44, 0xF0, 0xA0,
+	0xA3, 0x9E, 0x44, 0xF0, 0xA0, 0xA8, 0xAC, 0x44,
+	0xF0, 0xA0, 0xAD, 0xA3, 0x44, 0xF0, 0xA1, 0x93,
+	0xA4, 0x44, 0xF0, 0xA1, 0x9A, 0xA8, 0x44, 0xF0,
+	// Bytes 1680 - 16bf
+	0xA1, 0x9B, 0xAA, 0x44, 0xF0, 0xA1, 0xA7, 0x88,
+	0x44, 0xF0, 0xA1, 0xAC, 0x98, 0x44, 0xF0, 0xA1,
+	0xB4, 0x8B, 0x44, 0xF0, 0xA1, 0xB7, 0xA4, 0x44,
+	0xF0, 0xA1, 0xB7, 0xA6, 0x44, 0xF0, 0xA2, 0x86,
+	0x83, 0x44, 0xF0, 0xA2, 0x86, 0x9F, 0x44, 0xF0,
+	0xA2, 0x8C, 0xB1, 0x44, 0xF0, 0xA2, 0x9B, 0x94,
+	0x44, 0xF0, 0xA2, 0xA1, 0x84, 0x44, 0xF0, 0xA2,
+	0xA1, 0x8A, 0x44, 0xF0, 0xA2, 0xAC, 0x8C, 0x44,
+	// Bytes 16c0 - 16ff
+	0xF0, 0xA2, 0xAF, 0xB1, 0x44, 0xF0, 0xA3, 0x80,
+	0x8A, 0x44, 0xF0, 0xA3, 0x8A, 0xB8, 0x44, 0xF0,
+	0xA3, 0x8D, 0x9F, 0x44, 0xF0, 0xA3, 0x8E, 0x93,
+	0x44, 0xF0, 0xA3, 0x8E, 0x9C, 0x44, 0xF0, 0xA3,
+	0x8F, 0x83, 0x44, 0xF0, 0xA3, 0x8F, 0x95, 0x44,
+	0xF0, 0xA3, 0x91, 0xAD, 0x44, 0xF0, 0xA3, 0x9A,
+	0xA3, 0x44, 0xF0, 0xA3, 0xA2, 0xA7, 0x44, 0xF0,
+	0xA3, 0xAA, 0x8D, 0x44, 0xF0, 0xA3, 0xAB, 0xBA,
+	// Bytes 1700 - 173f
+	0x44, 0xF0, 0xA3, 0xB2, 0xBC, 0x44, 0xF0, 0xA3,
+	0xB4, 0x9E, 0x44, 0xF0, 0xA3, 0xBB, 0x91, 0x44,
+	0xF0, 0xA3, 0xBD, 0x9E, 0x44, 0xF0, 0xA3, 0xBE,
+	0x8E, 0x44, 0xF0, 0xA4, 0x89, 0xA3, 0x44, 0xF0,
+	0xA4, 0x8B, 0xAE, 0x44, 0xF0, 0xA4, 0x8E, 0xAB,
+	0x44, 0xF0, 0xA4, 0x98, 0x88, 0x44, 0xF0, 0xA4,
+	0x9C, 0xB5, 0x44, 0xF0, 0xA4, 0xA0, 0x94, 0x44,
+	0xF0, 0xA4, 0xB0, 0xB6, 0x44, 0xF0, 0xA4, 0xB2,
+	// Bytes 1740 - 177f
+	0x92, 0x44, 0xF0, 0xA4, 0xBE, 0xA1, 0x44, 0xF0,
+	0xA4, 0xBE, 0xB8, 0x44, 0xF0, 0xA5, 0x81, 0x84,
+	0x44, 0xF0, 0xA5, 0x83, 0xB2, 0x44, 0xF0, 0xA5,
+	0x83, 0xB3, 0x44, 0xF0, 0xA5, 0x84, 0x99, 0x44,
+	0xF0, 0xA5, 0x84, 0xB3, 0x44, 0xF0, 0xA5, 0x89,
+	0x89, 0x44, 0xF0, 0xA5, 0x90, 0x9D, 0x44, 0xF0,
+	0xA5, 0x98, 0xA6, 0x44, 0xF0, 0xA5, 0x9A, 0x9A,
+	0x44, 0xF0, 0xA5, 0x9B, 0x85, 0x44, 0xF0, 0xA5,
+	// Bytes 1780 - 17bf
+	0xA5, 0xBC, 0x44, 0xF0, 0xA5, 0xAA, 0xA7, 0x44,
+	0xF0, 0xA5, 0xAE, 0xAB, 0x44, 0xF0, 0xA5, 0xB2,
+	0x80, 0x44, 0xF0, 0xA5, 0xB3, 0x90, 0x44, 0xF0,
+	0xA5, 0xBE, 0x86, 0x44, 0xF0, 0xA6, 0x87, 0x9A,
+	0x44, 0xF0, 0xA6, 0x88, 0xA8, 0x44, 0xF0, 0xA6,
+	0x89, 0x87, 0x44, 0xF0, 0xA6, 0x8B, 0x99, 0x44,
+	0xF0, 0xA6, 0x8C, 0xBE, 0x44, 0xF0, 0xA6, 0x93,
+	0x9A, 0x44, 0xF0, 0xA6, 0x94, 0xA3, 0x44, 0xF0,
+	// Bytes 17c0 - 17ff
+	0xA6, 0x96, 0xA8, 0x44, 0xF0, 0xA6, 0x9E, 0xA7,
+	0x44, 0xF0, 0xA6, 0x9E, 0xB5, 0x44, 0xF0, 0xA6,
+	0xAC, 0xBC, 0x44, 0xF0, 0xA6, 0xB0, 0xB6, 0x44,
+	0xF0, 0xA6, 0xB3, 0x95, 0x44, 0xF0, 0xA6, 0xB5,
+	0xAB, 0x44, 0xF0, 0xA6, 0xBC, 0xAC, 0x44, 0xF0,
+	0xA6, 0xBE, 0xB1, 0x44, 0xF0, 0xA7, 0x83, 0x92,
+	0x44, 0xF0, 0xA7, 0x8F, 0x8A, 0x44, 0xF0, 0xA7,
+	0x99, 0xA7, 0x44, 0xF0, 0xA7, 0xA2, 0xAE, 0x44,
+	// Bytes 1800 - 183f
+	0xF0, 0xA7, 0xA5, 0xA6, 0x44, 0xF0, 0xA7, 0xB2,
+	0xA8, 0x44, 0xF0, 0xA7, 0xBB, 0x93, 0x44, 0xF0,
+	0xA7, 0xBC, 0xAF, 0x44, 0xF0, 0xA8, 0x97, 0x92,
+	0x44, 0xF0, 0xA8, 0x97, 0xAD, 0x44, 0xF0, 0xA8,
+	0x9C, 0xAE, 0x44, 0xF0, 0xA8, 0xAF, 0xBA, 0x44,
+	0xF0, 0xA8, 0xB5, 0xB7, 0x44, 0xF0, 0xA9, 0x85,
+	0x85, 0x44, 0xF0, 0xA9, 0x87, 0x9F, 0x44, 0xF0,
+	0xA9, 0x88, 0x9A, 0x44, 0xF0, 0xA9, 0x90, 0x8A,
+	// Bytes 1840 - 187f
+	0x44, 0xF0, 0xA9, 0x92, 0x96, 0x44, 0xF0, 0xA9,
+	0x96, 0xB6, 0x44, 0xF0, 0xA9, 0xAC, 0xB0, 0x44,
+	0xF0, 0xAA, 0x83, 0x8E, 0x44, 0xF0, 0xAA, 0x84,
+	0x85, 0x44, 0xF0, 0xAA, 0x88, 0x8E, 0x44, 0xF0,
+	0xAA, 0x8A, 0x91, 0x44, 0xF0, 0xAA, 0x8E, 0x92,
+	0x44, 0xF0, 0xAA, 0x98, 0x80, 0x42, 0x21, 0x21,
+	0x42, 0x21, 0x3F, 0x42, 0x2E, 0x2E, 0x42, 0x30,
+	0x2C, 0x42, 0x30, 0x2E, 0x42, 0x31, 0x2C, 0x42,
+	// Bytes 1880 - 18bf
+	0x31, 0x2E, 0x42, 0x31, 0x30, 0x42, 0x31, 0x31,
+	0x42, 0x31, 0x32, 0x42, 0x31, 0x33, 0x42, 0x31,
+	0x34, 0x42, 0x31, 0x35, 0x42, 0x31, 0x36, 0x42,
+	0x31, 0x37, 0x42, 0x31, 0x38, 0x42, 0x31, 0x39,
+	0x42, 0x32, 0x2C, 0x42, 0x32, 0x2E, 0x42, 0x32,
+	0x30, 0x42, 0x32, 0x31, 0x42, 0x32, 0x32, 0x42,
+	0x32, 0x33, 0x42, 0x32, 0x34, 0x42, 0x32, 0x35,
+	0x42, 0x32, 0x36, 0x42, 0x32, 0x37, 0x42, 0x32,
+	// Bytes 18c0 - 18ff
+	0x38, 0x42, 0x32, 0x39, 0x42, 0x33, 0x2C, 0x42,
+	0x33, 0x2E, 0x42, 0x33, 0x30, 0x42, 0x33, 0x31,
+	0x42, 0x33, 0x32, 0x42, 0x33, 0x33, 0x42, 0x33,
+	0x34, 0x42, 0x33, 0x35, 0x42, 0x33, 0x36, 0x42,
+	0x33, 0x37, 0x42, 0x33, 0x38, 0x42, 0x33, 0x39,
+	0x42, 0x34, 0x2C, 0x42, 0x34, 0x2E, 0x42, 0x34,
+	0x30, 0x42, 0x34, 0x31, 0x42, 0x34, 0x32, 0x42,
+	0x34, 0x33, 0x42, 0x34, 0x34, 0x42, 0x34, 0x35,
+	// Bytes 1900 - 193f
+	0x42, 0x34, 0x36, 0x42, 0x34, 0x37, 0x42, 0x34,
+	0x38, 0x42, 0x34, 0x39, 0x42, 0x35, 0x2C, 0x42,
+	0x35, 0x2E, 0x42, 0x35, 0x30, 0x42, 0x36, 0x2C,
+	0x42, 0x36, 0x2E, 0x42, 0x37, 0x2C, 0x42, 0x37,
+	0x2E, 0x42, 0x38, 0x2C, 0x42, 0x38, 0x2E, 0x42,
+	0x39, 0x2C, 0x42, 0x39, 0x2E, 0x42, 0x3D, 0x3D,
+	0x42, 0x3F, 0x21, 0x42, 0x3F, 0x3F, 0x42, 0x41,
+	0x55, 0x42, 0x42, 0x71, 0x42, 0x43, 0x44, 0x42,
+	// Bytes 1940 - 197f
+	0x44, 0x4A, 0x42, 0x44, 0x5A, 0x42, 0x44, 0x7A,
+	0x42, 0x47, 0x42, 0x42, 0x47, 0x79, 0x42, 0x48,
+	0x50, 0x42, 0x48, 0x56, 0x42, 0x48, 0x67, 0x42,
+	0x48, 0x7A, 0x42, 0x49, 0x49, 0x42, 0x49, 0x4A,
+	0x42, 0x49, 0x55, 0x42, 0x49, 0x56, 0x42, 0x49,
+	0x58, 0x42, 0x4B, 0x42, 0x42, 0x4B, 0x4B, 0x42,
+	0x4B, 0x4D, 0x42, 0x4C, 0x4A, 0x42, 0x4C, 0x6A,
+	0x42, 0x4D, 0x42, 0x42, 0x4D, 0x43, 0x42, 0x4D,
+	// Bytes 1980 - 19bf
+	0x44, 0x42, 0x4D, 0x56, 0x42, 0x4D, 0x57, 0x42,
+	0x4E, 0x4A, 0x42, 0x4E, 0x6A, 0x42, 0x4E, 0x6F,
+	0x42, 0x50, 0x48, 0x42, 0x50, 0x52, 0x42, 0x50,
+	0x61, 0x42, 0x52, 0x73, 0x42, 0x53, 0x44, 0x42,
+	0x53, 0x4D, 0x42, 0x53, 0x53, 0x42, 0x53, 0x76,
+	0x42, 0x54, 0x4D, 0x42, 0x56, 0x49, 0x42, 0x57,
+	0x43, 0x42, 0x57, 0x5A, 0x42, 0x57, 0x62, 0x42,
+	0x58, 0x49, 0x42, 0x63, 0x63, 0x42, 0x63, 0x64,
+	// Bytes 19c0 - 19ff
+	0x42, 0x63, 0x6D, 0x42, 0x64, 0x42, 0x42, 0x64,
+	0x61, 0x42, 0x64, 0x6C, 0x42, 0x64, 0x6D, 0x42,
+	0x64, 0x7A, 0x42, 0x65, 0x56, 0x42, 0x66, 0x66,
+	0x42, 0x66, 0x69, 0x42, 0x66, 0x6C, 0x42, 0x66,
+	0x6D, 0x42, 0x68, 0x61, 0x42, 0x69, 0x69, 0x42,
+	0x69, 0x6A, 0x42, 0x69, 0x6E, 0x42, 0x69, 0x76,
+	0x42, 0x69, 0x78, 0x42, 0x6B, 0x41, 0x42, 0x6B,
+	0x56, 0x42, 0x6B, 0x57, 0x42, 0x6B, 0x67, 0x42,
+	// Bytes 1a00 - 1a3f
+	0x6B, 0x6C, 0x42, 0x6B, 0x6D, 0x42, 0x6B, 0x74,
+	0x42, 0x6C, 0x6A, 0x42, 0x6C, 0x6D, 0x42, 0x6C,
+	0x6E, 0x42, 0x6C, 0x78, 0x42, 0x6D, 0x32, 0x42,
+	0x6D, 0x33, 0x42, 0x6D, 0x41, 0x42, 0x6D, 0x56,
+	0x42, 0x6D, 0x57, 0x42, 0x6D, 0x62, 0x42, 0x6D,
+	0x67, 0x42, 0x6D, 0x6C, 0x42, 0x6D, 0x6D, 0x42,
+	0x6D, 0x73, 0x42, 0x6E, 0x41, 0x42, 0x6E, 0x46,
+	0x42, 0x6E, 0x56, 0x42, 0x6E, 0x57, 0x42, 0x6E,
+	// Bytes 1a40 - 1a7f
+	0x6A, 0x42, 0x6E, 0x6D, 0x42, 0x6E, 0x73, 0x42,
+	0x6F, 0x56, 0x42, 0x70, 0x41, 0x42, 0x70, 0x46,
+	0x42, 0x70, 0x56, 0x42, 0x70, 0x57, 0x42, 0x70,
+	0x63, 0x42, 0x70, 0x73, 0x42, 0x73, 0x72, 0x42,
+	0x73, 0x74, 0x42, 0x76, 0x69, 0x42, 0x78, 0x69,
+	0x43, 0x28, 0x31, 0x29, 0x43, 0x28, 0x32, 0x29,
+	0x43, 0x28, 0x33, 0x29, 0x43, 0x28, 0x34, 0x29,
+	0x43, 0x28, 0x35, 0x29, 0x43, 0x28, 0x36, 0x29,
+	// Bytes 1a80 - 1abf
+	0x43, 0x28, 0x37, 0x29, 0x43, 0x28, 0x38, 0x29,
+	0x43, 0x28, 0x39, 0x29, 0x43, 0x28, 0x41, 0x29,
+	0x43, 0x28, 0x42, 0x29, 0x43, 0x28, 0x43, 0x29,
+	0x43, 0x28, 0x44, 0x29, 0x43, 0x28, 0x45, 0x29,
+	0x43, 0x28, 0x46, 0x29, 0x43, 0x28, 0x47, 0x29,
+	0x43, 0x28, 0x48, 0x29, 0x43, 0x28, 0x49, 0x29,
+	0x43, 0x28, 0x4A, 0x29, 0x43, 0x28, 0x4B, 0x29,
+	0x43, 0x28, 0x4C, 0x29, 0x43, 0x28, 0x4D, 0x29,
+	// Bytes 1ac0 - 1aff
+	0x43, 0x28, 0x4E, 0x29, 0x43, 0x28, 0x4F, 0x29,
+	0x43, 0x28, 0x50, 0x29, 0x43, 0x28, 0x51, 0x29,
+	0x43, 0x28, 0x52, 0x29, 0x43, 0x28, 0x53, 0x29,
+	0x43, 0x28, 0x54, 0x29, 0x43, 0x28, 0x55, 0x29,
+	0x43, 0x28, 0x56, 0x29, 0x43, 0x28, 0x57, 0x29,
+	0x43, 0x28, 0x58, 0x29, 0x43, 0x28, 0x59, 0x29,
+	0x43, 0x28, 0x5A, 0x29, 0x43, 0x28, 0x61, 0x29,
+	0x43, 0x28, 0x62, 0x29, 0x43, 0x28, 0x63, 0x29,
+	// Bytes 1b00 - 1b3f
+	0x43, 0x28, 0x64, 0x29, 0x43, 0x28, 0x65, 0x29,
+	0x43, 0x28, 0x66, 0x29, 0x43, 0x28, 0x67, 0x29,
+	0x43, 0x28, 0x68, 0x29, 0x43, 0x28, 0x69, 0x29,
+	0x43, 0x28, 0x6A, 0x29, 0x43, 0x28, 0x6B, 0x29,
+	0x43, 0x28, 0x6C, 0x29, 0x43, 0x28, 0x6D, 0x29,
+	0x43, 0x28, 0x6E, 0x29, 0x43, 0x28, 0x6F, 0x29,
+	0x43, 0x28, 0x70, 0x29, 0x43, 0x28, 0x71, 0x29,
+	0x43, 0x28, 0x72, 0x29, 0x43, 0x28, 0x73, 0x29,
+	// Bytes 1b40 - 1b7f
+	0x43, 0x28, 0x74, 0x29, 0x43, 0x28, 0x75, 0x29,
+	0x43, 0x28, 0x76, 0x29, 0x43, 0x28, 0x77, 0x29,
+	0x43, 0x28, 0x78, 0x29, 0x43, 0x28, 0x79, 0x29,
+	0x43, 0x28, 0x7A, 0x29, 0x43, 0x2E, 0x2E, 0x2E,
+	0x43, 0x31, 0x30, 0x2E, 0x43, 0x31, 0x31, 0x2E,
+	0x43, 0x31, 0x32, 0x2E, 0x43, 0x31, 0x33, 0x2E,
+	0x43, 0x31, 0x34, 0x2E, 0x43, 0x31, 0x35, 0x2E,
+	0x43, 0x31, 0x36, 0x2E, 0x43, 0x31, 0x37, 0x2E,
+	// Bytes 1b80 - 1bbf
+	0x43, 0x31, 0x38, 0x2E, 0x43, 0x31, 0x39, 0x2E,
+	0x43, 0x32, 0x30, 0x2E, 0x43, 0x3A, 0x3A, 0x3D,
+	0x43, 0x3D, 0x3D, 0x3D, 0x43, 0x43, 0x6F, 0x2E,
+	0x43, 0x46, 0x41, 0x58, 0x43, 0x47, 0x48, 0x7A,
+	0x43, 0x47, 0x50, 0x61, 0x43, 0x49, 0x49, 0x49,
+	0x43, 0x4C, 0x54, 0x44, 0x43, 0x4C, 0xC2, 0xB7,
+	0x43, 0x4D, 0x48, 0x7A, 0x43, 0x4D, 0x50, 0x61,
+	0x43, 0x4D, 0xCE, 0xA9, 0x43, 0x50, 0x50, 0x4D,
+	// Bytes 1bc0 - 1bff
+	0x43, 0x50, 0x50, 0x56, 0x43, 0x50, 0x54, 0x45,
+	0x43, 0x54, 0x45, 0x4C, 0x43, 0x54, 0x48, 0x7A,
+	0x43, 0x56, 0x49, 0x49, 0x43, 0x58, 0x49, 0x49,
+	0x43, 0x61, 0x2F, 0x63, 0x43, 0x61, 0x2F, 0x73,
+	0x43, 0x61, 0xCA, 0xBE, 0x43, 0x62, 0x61, 0x72,
+	0x43, 0x63, 0x2F, 0x6F, 0x43, 0x63, 0x2F, 0x75,
+	0x43, 0x63, 0x61, 0x6C, 0x43, 0x63, 0x6D, 0x32,
+	0x43, 0x63, 0x6D, 0x33, 0x43, 0x64, 0x6D, 0x32,
+	// Bytes 1c00 - 1c3f
+	0x43, 0x64, 0x6D, 0x33, 0x43, 0x65, 0x72, 0x67,
+	0x43, 0x66, 0x66, 0x69, 0x43, 0x66, 0x66, 0x6C,
+	0x43, 0x67, 0x61, 0x6C, 0x43, 0x68, 0x50, 0x61,
+	0x43, 0x69, 0x69, 0x69, 0x43, 0x6B, 0x48, 0x7A,
+	0x43, 0x6B, 0x50, 0x61, 0x43, 0x6B, 0x6D, 0x32,
+	0x43, 0x6B, 0x6D, 0x33, 0x43, 0x6B, 0xCE, 0xA9,
+	0x43, 0x6C, 0x6F, 0x67, 0x43, 0x6C, 0xC2, 0xB7,
+	0x43, 0x6D, 0x69, 0x6C, 0x43, 0x6D, 0x6D, 0x32,
+	// Bytes 1c40 - 1c7f
+	0x43, 0x6D, 0x6D, 0x33, 0x43, 0x6D, 0x6F, 0x6C,
+	0x43, 0x72, 0x61, 0x64, 0x43, 0x76, 0x69, 0x69,
+	0x43, 0x78, 0x69, 0x69, 0x43, 0xC2, 0xB0, 0x43,
+	0x43, 0xC2, 0xB0, 0x46, 0x43, 0xCA, 0xBC, 0x6E,
+	0x43, 0xCE, 0xBC, 0x41, 0x43, 0xCE, 0xBC, 0x46,
+	0x43, 0xCE, 0xBC, 0x56, 0x43, 0xCE, 0xBC, 0x57,
+	0x43, 0xCE, 0xBC, 0x67, 0x43, 0xCE, 0xBC, 0x6C,
+	0x43, 0xCE, 0xBC, 0x6D, 0x43, 0xCE, 0xBC, 0x73,
+	// Bytes 1c80 - 1cbf
+	0x44, 0x28, 0x31, 0x30, 0x29, 0x44, 0x28, 0x31,
+	0x31, 0x29, 0x44, 0x28, 0x31, 0x32, 0x29, 0x44,
+	0x28, 0x31, 0x33, 0x29, 0x44, 0x28, 0x31, 0x34,
+	0x29, 0x44, 0x28, 0x31, 0x35, 0x29, 0x44, 0x28,
+	0x31, 0x36, 0x29, 0x44, 0x28, 0x31, 0x37, 0x29,
+	0x44, 0x28, 0x31, 0x38, 0x29, 0x44, 0x28, 0x31,
+	0x39, 0x29, 0x44, 0x28, 0x32, 0x30, 0x29, 0x44,
+	0x30, 0xE7, 0x82, 0xB9, 0x44, 0x31, 0xE2, 0x81,
+	// Bytes 1cc0 - 1cff
+	0x84, 0x44, 0x31, 0xE6, 0x97, 0xA5, 0x44, 0x31,
+	0xE6, 0x9C, 0x88, 0x44, 0x31, 0xE7, 0x82, 0xB9,
+	0x44, 0x32, 0xE6, 0x97, 0xA5, 0x44, 0x32, 0xE6,
+	0x9C, 0x88, 0x44, 0x32, 0xE7, 0x82, 0xB9, 0x44,
+	0x33, 0xE6, 0x97, 0xA5, 0x44, 0x33, 0xE6, 0x9C,
+	0x88, 0x44, 0x33, 0xE7, 0x82, 0xB9, 0x44, 0x34,
+	0xE6, 0x97, 0xA5, 0x44, 0x34, 0xE6, 0x9C, 0x88,
+	0x44, 0x34, 0xE7, 0x82, 0xB9, 0x44, 0x35, 0xE6,
+	// Bytes 1d00 - 1d3f
+	0x97, 0xA5, 0x44, 0x35, 0xE6, 0x9C, 0x88, 0x44,
+	0x35, 0xE7, 0x82, 0xB9, 0x44, 0x36, 0xE6, 0x97,
+	0xA5, 0x44, 0x36, 0xE6, 0x9C, 0x88, 0x44, 0x36,
+	0xE7, 0x82, 0xB9, 0x44, 0x37, 0xE6, 0x97, 0xA5,
+	0x44, 0x37, 0xE6, 0x9C, 0x88, 0x44, 0x37, 0xE7,
+	0x82, 0xB9, 0x44, 0x38, 0xE6, 0x97, 0xA5, 0x44,
+	0x38, 0xE6, 0x9C, 0x88, 0x44, 0x38, 0xE7, 0x82,
+	0xB9, 0x44, 0x39, 0xE6, 0x97, 0xA5, 0x44, 0x39,
+	// Bytes 1d40 - 1d7f
+	0xE6, 0x9C, 0x88, 0x44, 0x39, 0xE7, 0x82, 0xB9,
+	0x44, 0x56, 0x49, 0x49, 0x49, 0x44, 0x61, 0x2E,
+	0x6D, 0x2E, 0x44, 0x6B, 0x63, 0x61, 0x6C, 0x44,
+	0x70, 0x2E, 0x6D, 0x2E, 0x44, 0x76, 0x69, 0x69,
+	0x69, 0x44, 0xD5, 0xA5, 0xD6, 0x82, 0x44, 0xD5,
+	0xB4, 0xD5, 0xA5, 0x44, 0xD5, 0xB4, 0xD5, 0xAB,
+	0x44, 0xD5, 0xB4, 0xD5, 0xAD, 0x44, 0xD5, 0xB4,
+	0xD5, 0xB6, 0x44, 0xD5, 0xBE, 0xD5, 0xB6, 0x44,
+	// Bytes 1d80 - 1dbf
+	0xD7, 0x90, 0xD7, 0x9C, 0x44, 0xD8, 0xA7, 0xD9,
+	0xB4, 0x44, 0xD8, 0xA8, 0xD8, 0xAC, 0x44, 0xD8,
+	0xA8, 0xD8, 0xAD, 0x44, 0xD8, 0xA8, 0xD8, 0xAE,
+	0x44, 0xD8, 0xA8, 0xD8, 0xB1, 0x44, 0xD8, 0xA8,
+	0xD8, 0xB2, 0x44, 0xD8, 0xA8, 0xD9, 0x85, 0x44,
+	0xD8, 0xA8, 0xD9, 0x86, 0x44, 0xD8, 0xA8, 0xD9,
+	0x87, 0x44, 0xD8, 0xA8, 0xD9, 0x89, 0x44, 0xD8,
+	0xA8, 0xD9, 0x8A, 0x44, 0xD8, 0xAA, 0xD8, 0xAC,
+	// Bytes 1dc0 - 1dff
+	0x44, 0xD8, 0xAA, 0xD8, 0xAD, 0x44, 0xD8, 0xAA,
+	0xD8, 0xAE, 0x44, 0xD8, 0xAA, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAA, 0xD8, 0xB2, 0x44, 0xD8, 0xAA, 0xD9,
+	0x85, 0x44, 0xD8, 0xAA, 0xD9, 0x86, 0x44, 0xD8,
+	0xAA, 0xD9, 0x87, 0x44, 0xD8, 0xAA, 0xD9, 0x89,
+	0x44, 0xD8, 0xAA, 0xD9, 0x8A, 0x44, 0xD8, 0xAB,
+	0xD8, 0xAC, 0x44, 0xD8, 0xAB, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAB, 0xD8, 0xB2, 0x44, 0xD8, 0xAB, 0xD9,
+	// Bytes 1e00 - 1e3f
+	0x85, 0x44, 0xD8, 0xAB, 0xD9, 0x86, 0x44, 0xD8,
+	0xAB, 0xD9, 0x87, 0x44, 0xD8, 0xAB, 0xD9, 0x89,
+	0x44, 0xD8, 0xAB, 0xD9, 0x8A, 0x44, 0xD8, 0xAC,
+	0xD8, 0xAD, 0x44, 0xD8, 0xAC, 0xD9, 0x85, 0x44,
+	0xD8, 0xAC, 0xD9, 0x89, 0x44, 0xD8, 0xAC, 0xD9,
+	0x8A, 0x44, 0xD8, 0xAD, 0xD8, 0xAC, 0x44, 0xD8,
+	0xAD, 0xD9, 0x85, 0x44, 0xD8, 0xAD, 0xD9, 0x89,
+	0x44, 0xD8, 0xAD, 0xD9, 0x8A, 0x44, 0xD8, 0xAE,
+	// Bytes 1e40 - 1e7f
+	0xD8, 0xAC, 0x44, 0xD8, 0xAE, 0xD8, 0xAD, 0x44,
+	0xD8, 0xAE, 0xD9, 0x85, 0x44, 0xD8, 0xAE, 0xD9,
+	0x89, 0x44, 0xD8, 0xAE, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB3, 0xD8, 0xAC, 0x44, 0xD8, 0xB3, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB3, 0xD8, 0xAE, 0x44, 0xD8, 0xB3,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB3, 0xD9, 0x85, 0x44,
+	0xD8, 0xB3, 0xD9, 0x87, 0x44, 0xD8, 0xB3, 0xD9,
+	0x89, 0x44, 0xD8, 0xB3, 0xD9, 0x8A, 0x44, 0xD8,
+	// Bytes 1e80 - 1ebf
+	0xB4, 0xD8, 0xAC, 0x44, 0xD8, 0xB4, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB4, 0xD8, 0xAE, 0x44, 0xD8, 0xB4,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB4, 0xD9, 0x85, 0x44,
+	0xD8, 0xB4, 0xD9, 0x87, 0x44, 0xD8, 0xB4, 0xD9,
+	0x89, 0x44, 0xD8, 0xB4, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB5, 0xD8, 0xAD, 0x44, 0xD8, 0xB5, 0xD8, 0xAE,
+	0x44, 0xD8, 0xB5, 0xD8, 0xB1, 0x44, 0xD8, 0xB5,
+	0xD9, 0x85, 0x44, 0xD8, 0xB5, 0xD9, 0x89, 0x44,
+	// Bytes 1ec0 - 1eff
+	0xD8, 0xB5, 0xD9, 0x8A, 0x44, 0xD8, 0xB6, 0xD8,
+	0xAC, 0x44, 0xD8, 0xB6, 0xD8, 0xAD, 0x44, 0xD8,
+	0xB6, 0xD8, 0xAE, 0x44, 0xD8, 0xB6, 0xD8, 0xB1,
+	0x44, 0xD8, 0xB6, 0xD9, 0x85, 0x44, 0xD8, 0xB6,
+	0xD9, 0x89, 0x44, 0xD8, 0xB6, 0xD9, 0x8A, 0x44,
+	0xD8, 0xB7, 0xD8, 0xAD, 0x44, 0xD8, 0xB7, 0xD9,
+	0x85, 0x44, 0xD8, 0xB7, 0xD9, 0x89, 0x44, 0xD8,
+	0xB7, 0xD9, 0x8A, 0x44, 0xD8, 0xB8, 0xD9, 0x85,
+	// Bytes 1f00 - 1f3f
+	0x44, 0xD8, 0xB9, 0xD8, 0xAC, 0x44, 0xD8, 0xB9,
+	0xD9, 0x85, 0x44, 0xD8, 0xB9, 0xD9, 0x89, 0x44,
+	0xD8, 0xB9, 0xD9, 0x8A, 0x44, 0xD8, 0xBA, 0xD8,
+	0xAC, 0x44, 0xD8, 0xBA, 0xD9, 0x85, 0x44, 0xD8,
+	0xBA, 0xD9, 0x89, 0x44, 0xD8, 0xBA, 0xD9, 0x8A,
+	0x44, 0xD9, 0x81, 0xD8, 0xAC, 0x44, 0xD9, 0x81,
+	0xD8, 0xAD, 0x44, 0xD9, 0x81, 0xD8, 0xAE, 0x44,
+	0xD9, 0x81, 0xD9, 0x85, 0x44, 0xD9, 0x81, 0xD9,
+	// Bytes 1f40 - 1f7f
+	0x89, 0x44, 0xD9, 0x81, 0xD9, 0x8A, 0x44, 0xD9,
+	0x82, 0xD8, 0xAD, 0x44, 0xD9, 0x82, 0xD9, 0x85,
+	0x44, 0xD9, 0x82, 0xD9, 0x89, 0x44, 0xD9, 0x82,
+	0xD9, 0x8A, 0x44, 0xD9, 0x83, 0xD8, 0xA7, 0x44,
+	0xD9, 0x83, 0xD8, 0xAC, 0x44, 0xD9, 0x83, 0xD8,
+	0xAD, 0x44, 0xD9, 0x83, 0xD8, 0xAE, 0x44, 0xD9,
+	0x83, 0xD9, 0x84, 0x44, 0xD9, 0x83, 0xD9, 0x85,
+	0x44, 0xD9, 0x83, 0xD9, 0x89, 0x44, 0xD9, 0x83,
+	// Bytes 1f80 - 1fbf
+	0xD9, 0x8A, 0x44, 0xD9, 0x84, 0xD8, 0xA7, 0x44,
+	0xD9, 0x84, 0xD8, 0xAC, 0x44, 0xD9, 0x84, 0xD8,
+	0xAD, 0x44, 0xD9, 0x84, 0xD8, 0xAE, 0x44, 0xD9,
+	0x84, 0xD9, 0x85, 0x44, 0xD9, 0x84, 0xD9, 0x87,
+	0x44, 0xD9, 0x84, 0xD9, 0x89, 0x44, 0xD9, 0x84,
+	0xD9, 0x8A, 0x44, 0xD9, 0x85, 0xD8, 0xA7, 0x44,
+	0xD9, 0x85, 0xD8, 0xAC, 0x44, 0xD9, 0x85, 0xD8,
+	0xAD, 0x44, 0xD9, 0x85, 0xD8, 0xAE, 0x44, 0xD9,
+	// Bytes 1fc0 - 1fff
+	0x85, 0xD9, 0x85, 0x44, 0xD9, 0x85, 0xD9, 0x89,
+	0x44, 0xD9, 0x85, 0xD9, 0x8A, 0x44, 0xD9, 0x86,
+	0xD8, 0xAC, 0x44, 0xD9, 0x86, 0xD8, 0xAD, 0x44,
+	0xD9, 0x86, 0xD8, 0xAE, 0x44, 0xD9, 0x86, 0xD8,
+	0xB1, 0x44, 0xD9, 0x86, 0xD8, 0xB2, 0x44, 0xD9,
+	0x86, 0xD9, 0x85, 0x44, 0xD9, 0x86, 0xD9, 0x86,
+	0x44, 0xD9, 0x86, 0xD9, 0x87, 0x44, 0xD9, 0x86,
+	0xD9, 0x89, 0x44, 0xD9, 0x86, 0xD9, 0x8A, 0x44,
+	// Bytes 2000 - 203f
+	0xD9, 0x87, 0xD8, 0xAC, 0x44, 0xD9, 0x87, 0xD9,
+	0x85, 0x44, 0xD9, 0x87, 0xD9, 0x89, 0x44, 0xD9,
+	0x87, 0xD9, 0x8A, 0x44, 0xD9, 0x88, 0xD9, 0xB4,
+	0x44, 0xD9, 0x8A, 0xD8, 0xAC, 0x44, 0xD9, 0x8A,
+	0xD8, 0xAD, 0x44, 0xD9, 0x8A, 0xD8, 0xAE, 0x44,
+	0xD9, 0x8A, 0xD8, 0xB1, 0x44, 0xD9, 0x8A, 0xD8,
+	0xB2, 0x44, 0xD9, 0x8A, 0xD9, 0x85, 0x44, 0xD9,
+	0x8A, 0xD9, 0x86, 0x44, 0xD9, 0x8A, 0xD9, 0x87,
+	// Bytes 2040 - 207f
+	0x44, 0xD9, 0x8A, 0xD9, 0x89, 0x44, 0xD9, 0x8A,
+	0xD9, 0x8A, 0x44, 0xD9, 0x8A, 0xD9, 0xB4, 0x44,
+	0xDB, 0x87, 0xD9, 0xB4, 0x45, 0x28, 0xE1, 0x84,
+	0x80, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x82, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x83, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x85, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x86, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x87, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x89, 0x29, 0x45, 0x28,
+	// Bytes 2080 - 20bf
+	0xE1, 0x84, 0x8B, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x8C, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x8E, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x8F, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x90, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x91, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x92, 0x29,
+	0x45, 0x28, 0xE4, 0xB8, 0x80, 0x29, 0x45, 0x28,
+	0xE4, 0xB8, 0x83, 0x29, 0x45, 0x28, 0xE4, 0xB8,
+	0x89, 0x29, 0x45, 0x28, 0xE4, 0xB9, 0x9D, 0x29,
+	// Bytes 20c0 - 20ff
+	0x45, 0x28, 0xE4, 0xBA, 0x8C, 0x29, 0x45, 0x28,
+	0xE4, 0xBA, 0x94, 0x29, 0x45, 0x28, 0xE4, 0xBB,
+	0xA3, 0x29, 0x45, 0x28, 0xE4, 0xBC, 0x81, 0x29,
+	0x45, 0x28, 0xE4, 0xBC, 0x91, 0x29, 0x45, 0x28,
+	0xE5, 0x85, 0xAB, 0x29, 0x45, 0x28, 0xE5, 0x85,
+	0xAD, 0x29, 0x45, 0x28, 0xE5, 0x8A, 0xB4, 0x29,
+	0x45, 0x28, 0xE5, 0x8D, 0x81, 0x29, 0x45, 0x28,
+	0xE5, 0x8D, 0x94, 0x29, 0x45, 0x28, 0xE5, 0x90,
+	// Bytes 2100 - 213f
+	0x8D, 0x29, 0x45, 0x28, 0xE5, 0x91, 0xBC, 0x29,
+	0x45, 0x28, 0xE5, 0x9B, 0x9B, 0x29, 0x45, 0x28,
+	0xE5, 0x9C, 0x9F, 0x29, 0x45, 0x28, 0xE5, 0xAD,
+	0xA6, 0x29, 0x45, 0x28, 0xE6, 0x97, 0xA5, 0x29,
+	0x45, 0x28, 0xE6, 0x9C, 0x88, 0x29, 0x45, 0x28,
+	0xE6, 0x9C, 0x89, 0x29, 0x45, 0x28, 0xE6, 0x9C,
+	0xA8, 0x29, 0x45, 0x28, 0xE6, 0xA0, 0xAA, 0x29,
+	0x45, 0x28, 0xE6, 0xB0, 0xB4, 0x29, 0x45, 0x28,
+	// Bytes 2140 - 217f
+	0xE7, 0x81, 0xAB, 0x29, 0x45, 0x28, 0xE7, 0x89,
+	0xB9, 0x29, 0x45, 0x28, 0xE7, 0x9B, 0xA3, 0x29,
+	0x45, 0x28, 0xE7, 0xA4, 0xBE, 0x29, 0x45, 0x28,
+	0xE7, 0xA5, 0x9D, 0x29, 0x45, 0x28, 0xE7, 0xA5,
+	0xAD, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xAA, 0x29,
+	0x45, 0x28, 0xE8, 0x87, 0xB3, 0x29, 0x45, 0x28,
+	0xE8, 0xB2, 0xA1, 0x29, 0x45, 0x28, 0xE8, 0xB3,
+	0x87, 0x29, 0x45, 0x28, 0xE9, 0x87, 0x91, 0x29,
+	// Bytes 2180 - 21bf
+	0x45, 0x30, 0xE2, 0x81, 0x84, 0x33, 0x45, 0x31,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x30, 0xE6,
+	0x9C, 0x88, 0x45, 0x31, 0x30, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x31, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x31, 0xE7,
+	0x82, 0xB9, 0x45, 0x31, 0x32, 0xE6, 0x97, 0xA5,
+	0x45, 0x31, 0x32, 0xE6, 0x9C, 0x88, 0x45, 0x31,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x33, 0xE6,
+	// Bytes 21c0 - 21ff
+	0x97, 0xA5, 0x45, 0x31, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x35, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x35, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x36, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x36, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x37, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x37, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x38, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	// Bytes 2200 - 223f
+	0x38, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x39, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x32, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x33, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x34, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x35,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x36, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x37, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x38, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x39,
+	// Bytes 2240 - 227f
+	0x45, 0x32, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x30, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x31, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x32, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x33, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x35, 0xE6,
+	// Bytes 2280 - 22bf
+	0x97, 0xA5, 0x45, 0x32, 0x36, 0xE6, 0x97, 0xA5,
+	0x45, 0x32, 0x37, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x38, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0xE2, 0x81, 0x84, 0x33,
+	0x45, 0x32, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x33, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x33, 0xE2, 0x81, 0x84, 0x34,
+	0x45, 0x33, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	// Bytes 22c0 - 22ff
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x34, 0xE2, 0x81,
+	0x84, 0x35, 0x45, 0x35, 0xE2, 0x81, 0x84, 0x36,
+	0x45, 0x35, 0xE2, 0x81, 0x84, 0x38, 0x45, 0x37,
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x41, 0xE2, 0x88,
+	0x95, 0x6D, 0x45, 0x56, 0xE2, 0x88, 0x95, 0x6D,
+	0x45, 0x6D, 0xE2, 0x88, 0x95, 0x73, 0x46, 0x31,
+	0xE2, 0x81, 0x84, 0x31, 0x30, 0x46, 0x43, 0xE2,
+	0x88, 0x95, 0x6B, 0x67, 0x46, 0x6D, 0xE2, 0x88,
+	// Bytes 2300 - 233f
+	0x95, 0x73, 0x32, 0x46, 0xD8, 0xA8, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xA8, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x85,
+	0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x89, 0x46,
+	0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0x46, 0xD8, 0xAA,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8, 0xAE,
+	// Bytes 2340 - 237f
+	0xD9, 0x89, 0x46, 0xD8, 0xAA, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAC,
+	0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAD, 0x46,
+	0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAE, 0x46, 0xD8,
+	0xAA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAA,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD8, 0xAC, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+	// Bytes 2380 - 23bf
+	0xAD, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x89,
+	0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAD,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB3, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD8, 0xB3, 0xD8, 0xAC,
+	0xD9, 0x89, 0x46, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8,
+	0xAC, 0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x89,
+	// Bytes 23c0 - 23ff
+	0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x8A, 0x46,
+	0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAC, 0x46, 0xD8,
+	0xB3, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8, 0xB3,
+	0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8,
+	0xAC, 0xD9, 0x8A, 0x46, 0xD8, 0xB4, 0xD8, 0xAD,
+	0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8, 0xAD, 0xD9,
+	0x8A, 0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xAE,
+	0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	// Bytes 2400 - 243f
+	0xD8, 0xB5, 0xD8, 0xAD, 0xD8, 0xAD, 0x46, 0xD8,
+	0xB5, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xB5,
+	0xD9, 0x84, 0xD9, 0x89, 0x46, 0xD8, 0xB5, 0xD9,
+	0x84, 0xDB, 0x92, 0x46, 0xD8, 0xB5, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9,
+	0x89, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x8A,
+	0x46, 0xD8, 0xB6, 0xD8, 0xAE, 0xD9, 0x85, 0x46,
+	0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8,
+	// Bytes 2440 - 247f
+	0xB7, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB7,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB9, 0xD8,
+	0xAC, 0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9, 0x8A,
+	0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8,
+	0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x81,
+	// Bytes 2480 - 24bf
+	0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x81, 0xD9,
+	0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x82, 0xD9, 0x84,
+	0xDB, 0x92, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD8,
+	0xAD, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x85,
+	0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x83, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x84,
+	0xD8, 0xAC, 0xD8, 0xAC, 0x46, 0xD9, 0x84, 0xD8,
+	// Bytes 24c0 - 24ff
+	0xAC, 0xD9, 0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAC,
+	0xD9, 0x8A, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+	0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x89,
+	0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x8A, 0x46,
+	0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9,
+	0x84, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD9, 0x84,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD9, 0x85, 0xD8, 0xAC,
+	// Bytes 2500 - 253f
+	0xD8, 0xAE, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+	0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x8A,
+	0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0x46,
+	0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9,
+	0x85, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x85,
+	0xD8, 0xAE, 0xD8, 0xAC, 0x46, 0xD9, 0x85, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAE,
+	0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+	// Bytes 2540 - 257f
+	0x8A, 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD8, 0xAD,
+	0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85, 0x46,
+	0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x89, 0x46, 0xD9,
+	0x86, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x86,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9, 0x86, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD9, 0x86, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x8A,
+	// Bytes 2580 - 25bf
+	0x46, 0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC, 0x46,
+	0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x8A, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x8A,
+	0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9,
+	0x85, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x85,
+	0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+	0xA7, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAC,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAD, 0x46,
+	// Bytes 25c0 - 25ff
+	0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE, 0x46, 0xD9,
+	0x8A, 0xD9, 0x94, 0xD8, 0xB1, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xD8, 0xB2, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xD9, 0x86, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+	0x87, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x88,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89, 0x46,
+	0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A, 0x46, 0xD9,
+	// Bytes 2600 - 263f
+	0x8A, 0xD9, 0x94, 0xDB, 0x86, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xDB, 0x87, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xDB, 0x88, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xDB, 0x90, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+	0x95, 0x46, 0xE0, 0xB9, 0x8D, 0xE0, 0xB8, 0xB2,
+	0x46, 0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0x99, 0x46,
+	0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0xA1, 0x46, 0xE0,
+	0xBB, 0x8D, 0xE0, 0xBA, 0xB2, 0x46, 0xE0, 0xBD,
+	// Bytes 2640 - 267f
+	0x80, 0xE0, 0xBE, 0xB5, 0x46, 0xE0, 0xBD, 0x82,
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x8C, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x91, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE0, 0xBD, 0x96, 0xE0, 0xBE, 0xB7,
+	0x46, 0xE0, 0xBD, 0x9B, 0xE0, 0xBE, 0xB7, 0x46,
+	0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5, 0x46, 0xE0,
+	0xBE, 0x92, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE,
+	0x9C, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA1,
+	// Bytes 2680 - 26bf
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA6, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xAB, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x46, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0x46,
+	0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0x46, 0xE2,
+	0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x46, 0xE3, 0x81,
+	0xBB, 0xE3, 0x81, 0x8B, 0x46, 0xE3, 0x82, 0x88,
+	0xE3, 0x82, 0x8A, 0x46, 0xE3, 0x82, 0xAD, 0xE3,
+	// Bytes 26c0 - 26ff
+	0x83, 0xAD, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x82,
+	0xB3, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x83, 0x88,
+	0x46, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3, 0x46,
+	0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8E, 0x46, 0xE3,
+	0x83, 0x9B, 0xE3, 0x83, 0xB3, 0x46, 0xE3, 0x83,
+	0x9F, 0xE3, 0x83, 0xAA, 0x46, 0xE3, 0x83, 0xAA,
+	0xE3, 0x83, 0xA9, 0x46, 0xE3, 0x83, 0xAC, 0xE3,
+	0x83, 0xA0, 0x46, 0xE5, 0xA4, 0xA7, 0xE6, 0xAD,
+	// Bytes 2700 - 273f
+	0xA3, 0x46, 0xE5, 0xB9, 0xB3, 0xE6, 0x88, 0x90,
+	0x46, 0xE6, 0x98, 0x8E, 0xE6, 0xB2, 0xBB, 0x46,
+	0xE6, 0x98, 0xAD, 0xE5, 0x92, 0x8C, 0x47, 0x72,
+	0x61, 0x64, 0xE2, 0x88, 0x95, 0x73, 0x47, 0xE3,
+	0x80, 0x94, 0x53, 0xE3, 0x80, 0x95, 0x48, 0x28,
+	0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x29,
+	0x48, 0x28, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1,
+	// Bytes 2740 - 277f
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x85, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x86, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x87,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x89, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28,
+	0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xAE, 0x29,
+	// Bytes 2780 - 27bf
+	0x48, 0x28, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1,
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x8F, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x90, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x91,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x92, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x72, 0x61,
+	0x64, 0xE2, 0x88, 0x95, 0x73, 0x32, 0x48, 0xD8,
+	0xA7, 0xD9, 0x83, 0xD8, 0xA8, 0xD8, 0xB1, 0x48,
+	// Bytes 27c0 - 27ff
+	0xD8, 0xA7, 0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x87,
+	0x48, 0xD8, 0xB1, 0xD8, 0xB3, 0xD9, 0x88, 0xD9,
+	0x84, 0x48, 0xD8, 0xB1, 0xDB, 0x8C, 0xD8, 0xA7,
+	0xD9, 0x84, 0x48, 0xD8, 0xB5, 0xD9, 0x84, 0xD8,
+	0xB9, 0xD9, 0x85, 0x48, 0xD8, 0xB9, 0xD9, 0x84,
+	0xD9, 0x8A, 0xD9, 0x87, 0x48, 0xD9, 0x85, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD8, 0xAF, 0x48, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x49, 0xE2,
+	// Bytes 2800 - 283f
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x49, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2,
+	0x80, 0xB5, 0x49, 0xE2, 0x88, 0xAB, 0xE2, 0x88,
+	0xAB, 0xE2, 0x88, 0xAB, 0x49, 0xE2, 0x88, 0xAE,
+	0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x49, 0xE3,
+	0x80, 0x94, 0xE4, 0xB8, 0x89, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE4, 0xBA, 0x8C, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE5, 0x8B,
+	// Bytes 2840 - 287f
+	0x9D, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE5, 0xAE, 0x89, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE6, 0x89, 0x93, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE6, 0x95, 0x97, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE6, 0x9C,
+	0xAC, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE7, 0x82, 0xB9, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE7, 0x9B, 0x97, 0xE3, 0x80, 0x95,
+	// Bytes 2880 - 28bf
+	0x49, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x81, 0x49, 0xE3, 0x82, 0xA6,
+	0xE3, 0x82, 0xA9, 0xE3, 0x83, 0xB3, 0x49, 0xE3,
+	0x82, 0xAA, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB9,
+	0x49, 0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xA0, 0x49, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAA, 0x49, 0xE3, 0x82, 0xB1,
+	// Bytes 28c0 - 28ff
+	0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB9, 0x49, 0xE3,
+	0x82, 0xB3, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x8A,
+	0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3,
+	0x83, 0x81, 0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x49, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0xE3, 0x82, 0xB7, 0x49, 0xE3,
+	0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x8E, 0xE3, 0x83, 0x83, 0xE3,
+	// Bytes 2900 - 293f
+	0x83, 0x88, 0x49, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0x84, 0x49, 0xE3, 0x83, 0x92,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB, 0x49, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xB3,
+	0x49, 0xE3, 0x83, 0x95, 0xE3, 0x83, 0xA9, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xBD, 0x49, 0xE3, 0x83, 0x98,
+	0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x84, 0x49, 0xE3,
+	// Bytes 2940 - 297f
+	0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x9E, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83, 0x9E,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x8F, 0x49, 0xE3,
+	0x83, 0x9E, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xAF,
+	0x49, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x83, 0xA6, 0xE3, 0x82,
+	// Bytes 2980 - 29bf
+	0xA2, 0xE3, 0x83, 0xB3, 0x49, 0xE3, 0x83, 0xAF,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0x4C, 0xE2,
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0xE2, 0x80, 0xB2, 0x4C, 0xE2, 0x88, 0xAB, 0xE2,
+	0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+	0x4C, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA1, 0x4C, 0xE3, 0x82,
+	0xA8, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3,
+	// Bytes 29c0 - 29ff
+	0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0x4C,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x9E, 0x4C, 0xE3, 0x82, 0xAB,
+	0xE3, 0x83, 0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+	0x88, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x83, 0xAD,
+	0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0x4C, 0xE3,
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x8B,
+	// Bytes 2a00 - 2a3f
+	0xE3, 0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAD, 0xE3,
+	0x83, 0xA5, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3,
+	0x83, 0xA9, 0xE3, 0x83, 0xA0, 0x4C, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0x8D, 0x4C, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+	0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2a40 - 2a7f
+	0xBC, 0xE3, 0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0x84, 0x4C, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA3, 0xE3, 0x83, 0xBC,
+	0xE3, 0x83, 0x88, 0x4C, 0xE3, 0x83, 0x98, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBF,
+	0x4C, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+	// Bytes 2a80 - 2abf
+	0x83, 0x8B, 0xE3, 0x83, 0x92, 0x4C, 0xE3, 0x83,
+	0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3, 0xE3,
+	0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x88, 0x4C,
+	0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0x4C, 0xE3, 0x83, 0x9F,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83,
+	0xB3, 0x4C, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xBC,
+	// Bytes 2ac0 - 2aff
+	0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0xAA, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88,
+	0xE3, 0x83, 0xAB, 0x4C, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC, 0x8F, 0xE4,
+	0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x4E, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x92,
+	0xE1, 0x85, 0xAE, 0x29, 0x4F, 0xD8, 0xAC, 0xD9,
+	// Bytes 2b00 - 2b3f
+	0x84, 0x20, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7,
+	0xD9, 0x84, 0xD9, 0x87, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xA2, 0x4F, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xB5,
+	// Bytes 2b40 - 2b7f
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xA0, 0x4F, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x98,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x9B,
+	0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x83, 0x9E,
+	// Bytes 2b80 - 2bbf
+	0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB7, 0xE3, 0x83,
+	0xA7, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xA1,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0x88, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xAB,
+	0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0x51, 0x28, 0xE1, 0x84,
+	0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xA5, 0xE1, 0x86, 0xAB, 0x29, 0x52, 0xE3,
+	// Bytes 2bc0 - 2bff
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xBC, 0x52, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xA9, 0xE3, 0x83, 0xA0, 0x52, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xA1, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x52,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2c00 - 2c3f
+	0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x83, 0x88, 0xE3,
+	0x83, 0xB3, 0x52, 0xE3, 0x82, 0xAF, 0xE3, 0x83,
+	0xAB, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0xE3,
+	0x82, 0xA4, 0xE3, 0x83, 0xAD, 0x52, 0xE3, 0x83,
+	0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3,
+	0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+	0x52, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+	0x82, 0xA2, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x88,
+	// Bytes 2c40 - 2c7f
+	0xE3, 0x83, 0xAB, 0x52, 0xE3, 0x83, 0x95, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0x83, 0xE3, 0x82, 0xB7,
+	0xE3, 0x82, 0xA7, 0xE3, 0x83, 0xAB, 0x52, 0xE3,
+	0x83, 0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAB, 0x52, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xB3,
+	0xE3, 0x83, 0x88, 0xE3, 0x82, 0xB1, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xB3, 0x61, 0xD8, 0xB5, 0xD9,
+	// Bytes 2c80 - 2cbf
+	0x84, 0xD9, 0x89, 0x20, 0xD8, 0xA7, 0xD9, 0x84,
+	0xD9, 0x84, 0xD9, 0x87, 0x20, 0xD8, 0xB9, 0xD9,
+	0x84, 0xD9, 0x8A, 0xD9, 0x87, 0x20, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA6, 0xBE, 0x01, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA7, 0x97, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAC, 0xBE, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAD, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2cc0 - 2cff
+	0xAD, 0x87, 0xE0, 0xAD, 0x97, 0x01, 0x06, 0xE0,
+	0xAE, 0x92, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x87, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xB2, 0xBF, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2d00 - 2d3f
+	0xB5, 0x86, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB5, 0x86, 0xE0, 0xB5, 0x97, 0x01, 0x06, 0xE0,
+	0xB5, 0x87, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB7, 0x99, 0xE0, 0xB7, 0x9F, 0x01, 0x06, 0xE1,
+	0x80, 0xA5, 0xE1, 0x80, 0xAE, 0x01, 0x06, 0xE1,
+	0xAC, 0x85, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x87, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x89, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	// Bytes 2d40 - 2d7f
+	0xAC, 0x8B, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x8D, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x91, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBA, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBC, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBE, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBF, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAD, 0x82, 0xE1, 0xAC, 0xB5, 0x01, 0x08, 0xF0,
+	// Bytes 2d80 - 2dbf
+	0x91, 0x84, 0xB1, 0xF0, 0x91, 0x84, 0xA7, 0x01,
+	0x08, 0xF0, 0x91, 0x84, 0xB2, 0xF0, 0x91, 0x84,
+	0xA7, 0x01, 0x08, 0xF0, 0x91, 0x8D, 0x87, 0xF0,
+	0x91, 0x8C, 0xBE, 0x01, 0x08, 0xF0, 0x91, 0x8D,
+	0x87, 0xF0, 0x91, 0x8D, 0x97, 0x01, 0x08, 0xF0,
+	0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92, 0xB0, 0x01,
+	0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92,
+	0xBA, 0x01, 0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0,
+	// Bytes 2dc0 - 2dff
+	0x91, 0x92, 0xBD, 0x01, 0x08, 0xF0, 0x91, 0x96,
+	0xB8, 0xF0, 0x91, 0x96, 0xAF, 0x01, 0x08, 0xF0,
+	0x91, 0x96, 0xB9, 0xF0, 0x91, 0x96, 0xAF, 0x01,
+	0x09, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0xE0,
+	0xB3, 0x95, 0x02, 0x09, 0xE0, 0xB7, 0x99, 0xE0,
+	0xB7, 0x8F, 0xE0, 0xB7, 0x8A, 0x12, 0x44, 0x44,
+	0x5A, 0xCC, 0x8C, 0xC9, 0x44, 0x44, 0x7A, 0xCC,
+	0x8C, 0xC9, 0x44, 0x64, 0x7A, 0xCC, 0x8C, 0xC9,
+	// Bytes 2e00 - 2e3f
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x93, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x46, 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x85, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e40 - 2e7f
+	0x46, 0xE1, 0x84, 0x87, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x89, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xAE, 0x01,
+	0x46, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8F, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x90, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e80 - 2ebf
+	0x46, 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0x01,
+	0x49, 0xE3, 0x83, 0xA1, 0xE3, 0x82, 0xAB, 0xE3,
+	0x82, 0x99, 0x0D, 0x4C, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xAE, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xB4,
+	0x01, 0x4C, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D, 0x4C,
+	0xE3, 0x82, 0xB3, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	// Bytes 2ec0 - 2eff
+	0x9B, 0xE3, 0x82, 0x9A, 0x0D, 0x4C, 0xE3, 0x83,
+	0xA4, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+	0x82, 0x99, 0x0D, 0x4F, 0xE1, 0x84, 0x8E, 0xE1,
+	0x85, 0xA1, 0xE1, 0x86, 0xB7, 0xE1, 0x84, 0x80,
+	0xE1, 0x85, 0xA9, 0x01, 0x4F, 0xE3, 0x82, 0xA4,
+	0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+	0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3, 0x82,
+	0xB7, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xB3, 0xE3,
+	// Bytes 2f00 - 2f3f
+	0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3,
+	0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D, 0x4F,
+	0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x52, 0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xB9, 0xE3,
+	0x82, 0xAF, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88,
+	0xE3, 0x82, 0x99, 0x0D, 0x52, 0xE3, 0x83, 0x95,
+	// Bytes 2f40 - 2f7f
+	0xE3, 0x82, 0xA1, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x86, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0x01,
+	0x86, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8F, 0x01,
+	0x03, 0x3C, 0xCC, 0xB8, 0x05, 0x03, 0x3D, 0xCC,
+	0xB8, 0x05, 0x03, 0x3E, 0xCC, 0xB8, 0x05, 0x03,
+	0x41, 0xCC, 0x80, 0xC9, 0x03, 0x41, 0xCC, 0x81,
+	0xC9, 0x03, 0x41, 0xCC, 0x83, 0xC9, 0x03, 0x41,
+	// Bytes 2f80 - 2fbf
+	0xCC, 0x84, 0xC9, 0x03, 0x41, 0xCC, 0x89, 0xC9,
+	0x03, 0x41, 0xCC, 0x8C, 0xC9, 0x03, 0x41, 0xCC,
+	0x8F, 0xC9, 0x03, 0x41, 0xCC, 0x91, 0xC9, 0x03,
+	0x41, 0xCC, 0xA5, 0xB5, 0x03, 0x41, 0xCC, 0xA8,
+	0xA5, 0x03, 0x42, 0xCC, 0x87, 0xC9, 0x03, 0x42,
+	0xCC, 0xA3, 0xB5, 0x03, 0x42, 0xCC, 0xB1, 0xB5,
+	0x03, 0x43, 0xCC, 0x81, 0xC9, 0x03, 0x43, 0xCC,
+	0x82, 0xC9, 0x03, 0x43, 0xCC, 0x87, 0xC9, 0x03,
+	// Bytes 2fc0 - 2fff
+	0x43, 0xCC, 0x8C, 0xC9, 0x03, 0x44, 0xCC, 0x87,
+	0xC9, 0x03, 0x44, 0xCC, 0x8C, 0xC9, 0x03, 0x44,
+	0xCC, 0xA3, 0xB5, 0x03, 0x44, 0xCC, 0xA7, 0xA5,
+	0x03, 0x44, 0xCC, 0xAD, 0xB5, 0x03, 0x44, 0xCC,
+	0xB1, 0xB5, 0x03, 0x45, 0xCC, 0x80, 0xC9, 0x03,
+	0x45, 0xCC, 0x81, 0xC9, 0x03, 0x45, 0xCC, 0x83,
+	0xC9, 0x03, 0x45, 0xCC, 0x86, 0xC9, 0x03, 0x45,
+	0xCC, 0x87, 0xC9, 0x03, 0x45, 0xCC, 0x88, 0xC9,
+	// Bytes 3000 - 303f
+	0x03, 0x45, 0xCC, 0x89, 0xC9, 0x03, 0x45, 0xCC,
+	0x8C, 0xC9, 0x03, 0x45, 0xCC, 0x8F, 0xC9, 0x03,
+	0x45, 0xCC, 0x91, 0xC9, 0x03, 0x45, 0xCC, 0xA8,
+	0xA5, 0x03, 0x45, 0xCC, 0xAD, 0xB5, 0x03, 0x45,
+	0xCC, 0xB0, 0xB5, 0x03, 0x46, 0xCC, 0x87, 0xC9,
+	0x03, 0x47, 0xCC, 0x81, 0xC9, 0x03, 0x47, 0xCC,
+	0x82, 0xC9, 0x03, 0x47, 0xCC, 0x84, 0xC9, 0x03,
+	0x47, 0xCC, 0x86, 0xC9, 0x03, 0x47, 0xCC, 0x87,
+	// Bytes 3040 - 307f
+	0xC9, 0x03, 0x47, 0xCC, 0x8C, 0xC9, 0x03, 0x47,
+	0xCC, 0xA7, 0xA5, 0x03, 0x48, 0xCC, 0x82, 0xC9,
+	0x03, 0x48, 0xCC, 0x87, 0xC9, 0x03, 0x48, 0xCC,
+	0x88, 0xC9, 0x03, 0x48, 0xCC, 0x8C, 0xC9, 0x03,
+	0x48, 0xCC, 0xA3, 0xB5, 0x03, 0x48, 0xCC, 0xA7,
+	0xA5, 0x03, 0x48, 0xCC, 0xAE, 0xB5, 0x03, 0x49,
+	0xCC, 0x80, 0xC9, 0x03, 0x49, 0xCC, 0x81, 0xC9,
+	0x03, 0x49, 0xCC, 0x82, 0xC9, 0x03, 0x49, 0xCC,
+	// Bytes 3080 - 30bf
+	0x83, 0xC9, 0x03, 0x49, 0xCC, 0x84, 0xC9, 0x03,
+	0x49, 0xCC, 0x86, 0xC9, 0x03, 0x49, 0xCC, 0x87,
+	0xC9, 0x03, 0x49, 0xCC, 0x89, 0xC9, 0x03, 0x49,
+	0xCC, 0x8C, 0xC9, 0x03, 0x49, 0xCC, 0x8F, 0xC9,
+	0x03, 0x49, 0xCC, 0x91, 0xC9, 0x03, 0x49, 0xCC,
+	0xA3, 0xB5, 0x03, 0x49, 0xCC, 0xA8, 0xA5, 0x03,
+	0x49, 0xCC, 0xB0, 0xB5, 0x03, 0x4A, 0xCC, 0x82,
+	0xC9, 0x03, 0x4B, 0xCC, 0x81, 0xC9, 0x03, 0x4B,
+	// Bytes 30c0 - 30ff
+	0xCC, 0x8C, 0xC9, 0x03, 0x4B, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4B, 0xCC, 0xA7, 0xA5, 0x03, 0x4B, 0xCC,
+	0xB1, 0xB5, 0x03, 0x4C, 0xCC, 0x81, 0xC9, 0x03,
+	0x4C, 0xCC, 0x8C, 0xC9, 0x03, 0x4C, 0xCC, 0xA7,
+	0xA5, 0x03, 0x4C, 0xCC, 0xAD, 0xB5, 0x03, 0x4C,
+	0xCC, 0xB1, 0xB5, 0x03, 0x4D, 0xCC, 0x81, 0xC9,
+	0x03, 0x4D, 0xCC, 0x87, 0xC9, 0x03, 0x4D, 0xCC,
+	0xA3, 0xB5, 0x03, 0x4E, 0xCC, 0x80, 0xC9, 0x03,
+	// Bytes 3100 - 313f
+	0x4E, 0xCC, 0x81, 0xC9, 0x03, 0x4E, 0xCC, 0x83,
+	0xC9, 0x03, 0x4E, 0xCC, 0x87, 0xC9, 0x03, 0x4E,
+	0xCC, 0x8C, 0xC9, 0x03, 0x4E, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4E, 0xCC, 0xA7, 0xA5, 0x03, 0x4E, 0xCC,
+	0xAD, 0xB5, 0x03, 0x4E, 0xCC, 0xB1, 0xB5, 0x03,
+	0x4F, 0xCC, 0x80, 0xC9, 0x03, 0x4F, 0xCC, 0x81,
+	0xC9, 0x03, 0x4F, 0xCC, 0x86, 0xC9, 0x03, 0x4F,
+	0xCC, 0x89, 0xC9, 0x03, 0x4F, 0xCC, 0x8B, 0xC9,
+	// Bytes 3140 - 317f
+	0x03, 0x4F, 0xCC, 0x8C, 0xC9, 0x03, 0x4F, 0xCC,
+	0x8F, 0xC9, 0x03, 0x4F, 0xCC, 0x91, 0xC9, 0x03,
+	0x50, 0xCC, 0x81, 0xC9, 0x03, 0x50, 0xCC, 0x87,
+	0xC9, 0x03, 0x52, 0xCC, 0x81, 0xC9, 0x03, 0x52,
+	0xCC, 0x87, 0xC9, 0x03, 0x52, 0xCC, 0x8C, 0xC9,
+	0x03, 0x52, 0xCC, 0x8F, 0xC9, 0x03, 0x52, 0xCC,
+	0x91, 0xC9, 0x03, 0x52, 0xCC, 0xA7, 0xA5, 0x03,
+	0x52, 0xCC, 0xB1, 0xB5, 0x03, 0x53, 0xCC, 0x82,
+	// Bytes 3180 - 31bf
+	0xC9, 0x03, 0x53, 0xCC, 0x87, 0xC9, 0x03, 0x53,
+	0xCC, 0xA6, 0xB5, 0x03, 0x53, 0xCC, 0xA7, 0xA5,
+	0x03, 0x54, 0xCC, 0x87, 0xC9, 0x03, 0x54, 0xCC,
+	0x8C, 0xC9, 0x03, 0x54, 0xCC, 0xA3, 0xB5, 0x03,
+	0x54, 0xCC, 0xA6, 0xB5, 0x03, 0x54, 0xCC, 0xA7,
+	0xA5, 0x03, 0x54, 0xCC, 0xAD, 0xB5, 0x03, 0x54,
+	0xCC, 0xB1, 0xB5, 0x03, 0x55, 0xCC, 0x80, 0xC9,
+	0x03, 0x55, 0xCC, 0x81, 0xC9, 0x03, 0x55, 0xCC,
+	// Bytes 31c0 - 31ff
+	0x82, 0xC9, 0x03, 0x55, 0xCC, 0x86, 0xC9, 0x03,
+	0x55, 0xCC, 0x89, 0xC9, 0x03, 0x55, 0xCC, 0x8A,
+	0xC9, 0x03, 0x55, 0xCC, 0x8B, 0xC9, 0x03, 0x55,
+	0xCC, 0x8C, 0xC9, 0x03, 0x55, 0xCC, 0x8F, 0xC9,
+	0x03, 0x55, 0xCC, 0x91, 0xC9, 0x03, 0x55, 0xCC,
+	0xA3, 0xB5, 0x03, 0x55, 0xCC, 0xA4, 0xB5, 0x03,
+	0x55, 0xCC, 0xA8, 0xA5, 0x03, 0x55, 0xCC, 0xAD,
+	0xB5, 0x03, 0x55, 0xCC, 0xB0, 0xB5, 0x03, 0x56,
+	// Bytes 3200 - 323f
+	0xCC, 0x83, 0xC9, 0x03, 0x56, 0xCC, 0xA3, 0xB5,
+	0x03, 0x57, 0xCC, 0x80, 0xC9, 0x03, 0x57, 0xCC,
+	0x81, 0xC9, 0x03, 0x57, 0xCC, 0x82, 0xC9, 0x03,
+	0x57, 0xCC, 0x87, 0xC9, 0x03, 0x57, 0xCC, 0x88,
+	0xC9, 0x03, 0x57, 0xCC, 0xA3, 0xB5, 0x03, 0x58,
+	0xCC, 0x87, 0xC9, 0x03, 0x58, 0xCC, 0x88, 0xC9,
+	0x03, 0x59, 0xCC, 0x80, 0xC9, 0x03, 0x59, 0xCC,
+	0x81, 0xC9, 0x03, 0x59, 0xCC, 0x82, 0xC9, 0x03,
+	// Bytes 3240 - 327f
+	0x59, 0xCC, 0x83, 0xC9, 0x03, 0x59, 0xCC, 0x84,
+	0xC9, 0x03, 0x59, 0xCC, 0x87, 0xC9, 0x03, 0x59,
+	0xCC, 0x88, 0xC9, 0x03, 0x59, 0xCC, 0x89, 0xC9,
+	0x03, 0x59, 0xCC, 0xA3, 0xB5, 0x03, 0x5A, 0xCC,
+	0x81, 0xC9, 0x03, 0x5A, 0xCC, 0x82, 0xC9, 0x03,
+	0x5A, 0xCC, 0x87, 0xC9, 0x03, 0x5A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x5A, 0xCC, 0xA3, 0xB5, 0x03, 0x5A,
+	0xCC, 0xB1, 0xB5, 0x03, 0x61, 0xCC, 0x80, 0xC9,
+	// Bytes 3280 - 32bf
+	0x03, 0x61, 0xCC, 0x81, 0xC9, 0x03, 0x61, 0xCC,
+	0x83, 0xC9, 0x03, 0x61, 0xCC, 0x84, 0xC9, 0x03,
+	0x61, 0xCC, 0x89, 0xC9, 0x03, 0x61, 0xCC, 0x8C,
+	0xC9, 0x03, 0x61, 0xCC, 0x8F, 0xC9, 0x03, 0x61,
+	0xCC, 0x91, 0xC9, 0x03, 0x61, 0xCC, 0xA5, 0xB5,
+	0x03, 0x61, 0xCC, 0xA8, 0xA5, 0x03, 0x62, 0xCC,
+	0x87, 0xC9, 0x03, 0x62, 0xCC, 0xA3, 0xB5, 0x03,
+	0x62, 0xCC, 0xB1, 0xB5, 0x03, 0x63, 0xCC, 0x81,
+	// Bytes 32c0 - 32ff
+	0xC9, 0x03, 0x63, 0xCC, 0x82, 0xC9, 0x03, 0x63,
+	0xCC, 0x87, 0xC9, 0x03, 0x63, 0xCC, 0x8C, 0xC9,
+	0x03, 0x64, 0xCC, 0x87, 0xC9, 0x03, 0x64, 0xCC,
+	0x8C, 0xC9, 0x03, 0x64, 0xCC, 0xA3, 0xB5, 0x03,
+	0x64, 0xCC, 0xA7, 0xA5, 0x03, 0x64, 0xCC, 0xAD,
+	0xB5, 0x03, 0x64, 0xCC, 0xB1, 0xB5, 0x03, 0x65,
+	0xCC, 0x80, 0xC9, 0x03, 0x65, 0xCC, 0x81, 0xC9,
+	0x03, 0x65, 0xCC, 0x83, 0xC9, 0x03, 0x65, 0xCC,
+	// Bytes 3300 - 333f
+	0x86, 0xC9, 0x03, 0x65, 0xCC, 0x87, 0xC9, 0x03,
+	0x65, 0xCC, 0x88, 0xC9, 0x03, 0x65, 0xCC, 0x89,
+	0xC9, 0x03, 0x65, 0xCC, 0x8C, 0xC9, 0x03, 0x65,
+	0xCC, 0x8F, 0xC9, 0x03, 0x65, 0xCC, 0x91, 0xC9,
+	0x03, 0x65, 0xCC, 0xA8, 0xA5, 0x03, 0x65, 0xCC,
+	0xAD, 0xB5, 0x03, 0x65, 0xCC, 0xB0, 0xB5, 0x03,
+	0x66, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC, 0x81,
+	0xC9, 0x03, 0x67, 0xCC, 0x82, 0xC9, 0x03, 0x67,
+	// Bytes 3340 - 337f
+	0xCC, 0x84, 0xC9, 0x03, 0x67, 0xCC, 0x86, 0xC9,
+	0x03, 0x67, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC,
+	0x8C, 0xC9, 0x03, 0x67, 0xCC, 0xA7, 0xA5, 0x03,
+	0x68, 0xCC, 0x82, 0xC9, 0x03, 0x68, 0xCC, 0x87,
+	0xC9, 0x03, 0x68, 0xCC, 0x88, 0xC9, 0x03, 0x68,
+	0xCC, 0x8C, 0xC9, 0x03, 0x68, 0xCC, 0xA3, 0xB5,
+	0x03, 0x68, 0xCC, 0xA7, 0xA5, 0x03, 0x68, 0xCC,
+	0xAE, 0xB5, 0x03, 0x68, 0xCC, 0xB1, 0xB5, 0x03,
+	// Bytes 3380 - 33bf
+	0x69, 0xCC, 0x80, 0xC9, 0x03, 0x69, 0xCC, 0x81,
+	0xC9, 0x03, 0x69, 0xCC, 0x82, 0xC9, 0x03, 0x69,
+	0xCC, 0x83, 0xC9, 0x03, 0x69, 0xCC, 0x84, 0xC9,
+	0x03, 0x69, 0xCC, 0x86, 0xC9, 0x03, 0x69, 0xCC,
+	0x89, 0xC9, 0x03, 0x69, 0xCC, 0x8C, 0xC9, 0x03,
+	0x69, 0xCC, 0x8F, 0xC9, 0x03, 0x69, 0xCC, 0x91,
+	0xC9, 0x03, 0x69, 0xCC, 0xA3, 0xB5, 0x03, 0x69,
+	0xCC, 0xA8, 0xA5, 0x03, 0x69, 0xCC, 0xB0, 0xB5,
+	// Bytes 33c0 - 33ff
+	0x03, 0x6A, 0xCC, 0x82, 0xC9, 0x03, 0x6A, 0xCC,
+	0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0x81, 0xC9, 0x03,
+	0x6B, 0xCC, 0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6B, 0xCC, 0xA7, 0xA5, 0x03, 0x6B,
+	0xCC, 0xB1, 0xB5, 0x03, 0x6C, 0xCC, 0x81, 0xC9,
+	0x03, 0x6C, 0xCC, 0x8C, 0xC9, 0x03, 0x6C, 0xCC,
+	0xA7, 0xA5, 0x03, 0x6C, 0xCC, 0xAD, 0xB5, 0x03,
+	0x6C, 0xCC, 0xB1, 0xB5, 0x03, 0x6D, 0xCC, 0x81,
+	// Bytes 3400 - 343f
+	0xC9, 0x03, 0x6D, 0xCC, 0x87, 0xC9, 0x03, 0x6D,
+	0xCC, 0xA3, 0xB5, 0x03, 0x6E, 0xCC, 0x80, 0xC9,
+	0x03, 0x6E, 0xCC, 0x81, 0xC9, 0x03, 0x6E, 0xCC,
+	0x83, 0xC9, 0x03, 0x6E, 0xCC, 0x87, 0xC9, 0x03,
+	0x6E, 0xCC, 0x8C, 0xC9, 0x03, 0x6E, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6E, 0xCC, 0xA7, 0xA5, 0x03, 0x6E,
+	0xCC, 0xAD, 0xB5, 0x03, 0x6E, 0xCC, 0xB1, 0xB5,
+	0x03, 0x6F, 0xCC, 0x80, 0xC9, 0x03, 0x6F, 0xCC,
+	// Bytes 3440 - 347f
+	0x81, 0xC9, 0x03, 0x6F, 0xCC, 0x86, 0xC9, 0x03,
+	0x6F, 0xCC, 0x89, 0xC9, 0x03, 0x6F, 0xCC, 0x8B,
+	0xC9, 0x03, 0x6F, 0xCC, 0x8C, 0xC9, 0x03, 0x6F,
+	0xCC, 0x8F, 0xC9, 0x03, 0x6F, 0xCC, 0x91, 0xC9,
+	0x03, 0x70, 0xCC, 0x81, 0xC9, 0x03, 0x70, 0xCC,
+	0x87, 0xC9, 0x03, 0x72, 0xCC, 0x81, 0xC9, 0x03,
+	0x72, 0xCC, 0x87, 0xC9, 0x03, 0x72, 0xCC, 0x8C,
+	0xC9, 0x03, 0x72, 0xCC, 0x8F, 0xC9, 0x03, 0x72,
+	// Bytes 3480 - 34bf
+	0xCC, 0x91, 0xC9, 0x03, 0x72, 0xCC, 0xA7, 0xA5,
+	0x03, 0x72, 0xCC, 0xB1, 0xB5, 0x03, 0x73, 0xCC,
+	0x82, 0xC9, 0x03, 0x73, 0xCC, 0x87, 0xC9, 0x03,
+	0x73, 0xCC, 0xA6, 0xB5, 0x03, 0x73, 0xCC, 0xA7,
+	0xA5, 0x03, 0x74, 0xCC, 0x87, 0xC9, 0x03, 0x74,
+	0xCC, 0x88, 0xC9, 0x03, 0x74, 0xCC, 0x8C, 0xC9,
+	0x03, 0x74, 0xCC, 0xA3, 0xB5, 0x03, 0x74, 0xCC,
+	0xA6, 0xB5, 0x03, 0x74, 0xCC, 0xA7, 0xA5, 0x03,
+	// Bytes 34c0 - 34ff
+	0x74, 0xCC, 0xAD, 0xB5, 0x03, 0x74, 0xCC, 0xB1,
+	0xB5, 0x03, 0x75, 0xCC, 0x80, 0xC9, 0x03, 0x75,
+	0xCC, 0x81, 0xC9, 0x03, 0x75, 0xCC, 0x82, 0xC9,
+	0x03, 0x75, 0xCC, 0x86, 0xC9, 0x03, 0x75, 0xCC,
+	0x89, 0xC9, 0x03, 0x75, 0xCC, 0x8A, 0xC9, 0x03,
+	0x75, 0xCC, 0x8B, 0xC9, 0x03, 0x75, 0xCC, 0x8C,
+	0xC9, 0x03, 0x75, 0xCC, 0x8F, 0xC9, 0x03, 0x75,
+	0xCC, 0x91, 0xC9, 0x03, 0x75, 0xCC, 0xA3, 0xB5,
+	// Bytes 3500 - 353f
+	0x03, 0x75, 0xCC, 0xA4, 0xB5, 0x03, 0x75, 0xCC,
+	0xA8, 0xA5, 0x03, 0x75, 0xCC, 0xAD, 0xB5, 0x03,
+	0x75, 0xCC, 0xB0, 0xB5, 0x03, 0x76, 0xCC, 0x83,
+	0xC9, 0x03, 0x76, 0xCC, 0xA3, 0xB5, 0x03, 0x77,
+	0xCC, 0x80, 0xC9, 0x03, 0x77, 0xCC, 0x81, 0xC9,
+	0x03, 0x77, 0xCC, 0x82, 0xC9, 0x03, 0x77, 0xCC,
+	0x87, 0xC9, 0x03, 0x77, 0xCC, 0x88, 0xC9, 0x03,
+	0x77, 0xCC, 0x8A, 0xC9, 0x03, 0x77, 0xCC, 0xA3,
+	// Bytes 3540 - 357f
+	0xB5, 0x03, 0x78, 0xCC, 0x87, 0xC9, 0x03, 0x78,
+	0xCC, 0x88, 0xC9, 0x03, 0x79, 0xCC, 0x80, 0xC9,
+	0x03, 0x79, 0xCC, 0x81, 0xC9, 0x03, 0x79, 0xCC,
+	0x82, 0xC9, 0x03, 0x79, 0xCC, 0x83, 0xC9, 0x03,
+	0x79, 0xCC, 0x84, 0xC9, 0x03, 0x79, 0xCC, 0x87,
+	0xC9, 0x03, 0x79, 0xCC, 0x88, 0xC9, 0x03, 0x79,
+	0xCC, 0x89, 0xC9, 0x03, 0x79, 0xCC, 0x8A, 0xC9,
+	0x03, 0x79, 0xCC, 0xA3, 0xB5, 0x03, 0x7A, 0xCC,
+	// Bytes 3580 - 35bf
+	0x81, 0xC9, 0x03, 0x7A, 0xCC, 0x82, 0xC9, 0x03,
+	0x7A, 0xCC, 0x87, 0xC9, 0x03, 0x7A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x7A, 0xCC, 0xA3, 0xB5, 0x03, 0x7A,
+	0xCC, 0xB1, 0xB5, 0x04, 0xC2, 0xA8, 0xCC, 0x80,
+	0xCA, 0x04, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x04,
+	0xC2, 0xA8, 0xCD, 0x82, 0xCA, 0x04, 0xC3, 0x86,
+	0xCC, 0x81, 0xC9, 0x04, 0xC3, 0x86, 0xCC, 0x84,
+	0xC9, 0x04, 0xC3, 0x98, 0xCC, 0x81, 0xC9, 0x04,
+	// Bytes 35c0 - 35ff
+	0xC3, 0xA6, 0xCC, 0x81, 0xC9, 0x04, 0xC3, 0xA6,
+	0xCC, 0x84, 0xC9, 0x04, 0xC3, 0xB8, 0xCC, 0x81,
+	0xC9, 0x04, 0xC5, 0xBF, 0xCC, 0x87, 0xC9, 0x04,
+	0xC6, 0xB7, 0xCC, 0x8C, 0xC9, 0x04, 0xCA, 0x92,
+	0xCC, 0x8C, 0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0x91, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0x91,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0x91, 0xCD, 0x85,
+	// Bytes 3600 - 363f
+	0xD9, 0x04, 0xCE, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0x95, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x97,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x97, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0x97, 0xCD, 0x85, 0xD9, 0x04,
+	0xCE, 0x99, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x99,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0x9F,
+	// Bytes 3640 - 367f
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x9F, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA1, 0xCC, 0x94, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA5,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0xA9,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA9, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA9, 0xCD, 0x85, 0xD9, 0x04,
+	// Bytes 3680 - 36bf
+	0xCE, 0xB1, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB1,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB1, 0xCD, 0x85,
+	0xD9, 0x04, 0xCE, 0xB5, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xB5, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xB7,
+	0xCD, 0x85, 0xD9, 0x04, 0xCE, 0xB9, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0xB9, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB9,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB9, 0xCD, 0x82,
+	// Bytes 36c0 - 36ff
+	0xC9, 0x04, 0xCE, 0xBF, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xBF, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x81,
+	0xCC, 0x93, 0xC9, 0x04, 0xCF, 0x81, 0xCC, 0x94,
+	0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x80, 0xC9, 0x04,
+	0xCF, 0x85, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x85,
+	0xCC, 0x84, 0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x86,
+	0xC9, 0x04, 0xCF, 0x85, 0xCD, 0x82, 0xC9, 0x04,
+	0xCF, 0x89, 0xCD, 0x85, 0xD9, 0x04, 0xCF, 0x92,
+	// Bytes 3700 - 373f
+	0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x92, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0x86, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0x90, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x90,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x93, 0xCC, 0x81,
+	0xC9, 0x04, 0xD0, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0x95, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x95,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3740 - 377f
+	0xD0, 0x97, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x98,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x84,
+	0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x86, 0xC9, 0x04,
+	0xD0, 0x98, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x9A,
+	0xCC, 0x81, 0xC9, 0x04, 0xD0, 0x9E, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x84, 0xC9, 0x04,
+	0xD0, 0xA3, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xA3,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x8B,
+	// Bytes 3780 - 37bf
+	0xC9, 0x04, 0xD0, 0xA7, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xAB, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xAD,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB3, 0xCC, 0x81, 0xC9, 0x04, 0xD0, 0xB5,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB6, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB6,
+	// Bytes 37c0 - 37ff
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB7, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0xB8, 0xCC, 0x84, 0xC9, 0x04, 0xD0, 0xB8,
+	0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xBA, 0xCC, 0x81, 0xC9, 0x04,
+	0xD0, 0xBE, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x83,
+	0xCC, 0x84, 0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x86,
+	0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3800 - 383f
+	0xD1, 0x83, 0xCC, 0x8B, 0xC9, 0x04, 0xD1, 0x87,
+	0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x8B, 0xCC, 0x88,
+	0xC9, 0x04, 0xD1, 0x8D, 0xCC, 0x88, 0xC9, 0x04,
+	0xD1, 0x96, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0xB4,
+	0xCC, 0x8F, 0xC9, 0x04, 0xD1, 0xB5, 0xCC, 0x8F,
+	0xC9, 0x04, 0xD3, 0x98, 0xCC, 0x88, 0xC9, 0x04,
+	0xD3, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA8,
+	0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA9, 0xCC, 0x88,
+	// Bytes 3840 - 387f
+	0xC9, 0x04, 0xD8, 0xA7, 0xD9, 0x93, 0xC9, 0x04,
+	0xD8, 0xA7, 0xD9, 0x94, 0xC9, 0x04, 0xD8, 0xA7,
+	0xD9, 0x95, 0xB5, 0x04, 0xD9, 0x88, 0xD9, 0x94,
+	0xC9, 0x04, 0xD9, 0x8A, 0xD9, 0x94, 0xC9, 0x04,
+	0xDB, 0x81, 0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x92,
+	0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x95, 0xD9, 0x94,
+	0xC9, 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x41, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	// Bytes 3880 - 38bf
+	0x41, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x41,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x41, 0xCC,
+	0x86, 0xCC, 0x80, 0xCA, 0x05, 0x41, 0xCC, 0x86,
+	0xCC, 0x81, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC,
+	0x83, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC, 0x89,
+	0xCA, 0x05, 0x41, 0xCC, 0x87, 0xCC, 0x84, 0xCA,
+	0x05, 0x41, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05,
+	0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x41,
+	// Bytes 38c0 - 38ff
+	0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x41, 0xCC,
+	0xA3, 0xCC, 0x86, 0xCA, 0x05, 0x43, 0xCC, 0xA7,
+	0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC,
+	0x80, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x81,
+	0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x83, 0xCA,
+	0x05, 0x45, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05,
+	0x45, 0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x45,
+	0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC,
+	// Bytes 3900 - 393f
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x45, 0xCC, 0xA7,
+	0xCC, 0x86, 0xCA, 0x05, 0x49, 0xCC, 0x88, 0xCC,
+	0x81, 0xCA, 0x05, 0x4C, 0xCC, 0xA3, 0xCC, 0x84,
+	0xCA, 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	0x4F, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x4F,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x4F, 0xCC,
+	0x83, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x83,
+	// Bytes 3940 - 397f
+	0xCC, 0x84, 0xCA, 0x05, 0x4F, 0xCC, 0x83, 0xCC,
+	0x88, 0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x80,
+	0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x81, 0xCA,
+	0x05, 0x4F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x4F,
+	0xCC, 0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x4F, 0xCC,
+	0x9B, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x9B,
+	0xCC, 0x83, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC,
+	// Bytes 3980 - 39bf
+	0x89, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC, 0xA3,
+	0xB6, 0x05, 0x4F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA,
+	0x05, 0x4F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05,
+	0x52, 0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x53,
+	0xCC, 0x81, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC,
+	0x8C, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC, 0xA3,
+	0xCC, 0x87, 0xCA, 0x05, 0x55, 0xCC, 0x83, 0xCC,
+	0x81, 0xCA, 0x05, 0x55, 0xCC, 0x84, 0xCC, 0x88,
+	// Bytes 39c0 - 39ff
+	0xCA, 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x05, 0x55, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05,
+	0x55, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x55,
+	0xCC, 0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x55, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x55, 0xCC, 0x9B,
+	0xCC, 0x81, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	// Bytes 3a00 - 3a3f
+	0x05, 0x61, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x61, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x61,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x61, 0xCC,
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x61, 0xCC, 0x86,
+	0xCC, 0x80, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC,
+	0x81, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x83,
+	0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x89, 0xCA,
+	0x05, 0x61, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	// Bytes 3a40 - 3a7f
+	0x61, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x61,
+	0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x61, 0xCC,
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x61, 0xCC, 0xA3,
+	0xCC, 0x86, 0xCA, 0x05, 0x63, 0xCC, 0xA7, 0xCC,
+	0x81, 0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x80,
+	0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x81, 0xCA,
+	0x05, 0x65, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05,
+	0x65, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x65,
+	// Bytes 3a80 - 3abf
+	0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x65, 0xCC,
+	0x84, 0xCC, 0x81, 0xCA, 0x05, 0x65, 0xCC, 0xA3,
+	0xCC, 0x82, 0xCA, 0x05, 0x65, 0xCC, 0xA7, 0xCC,
+	0x86, 0xCA, 0x05, 0x69, 0xCC, 0x88, 0xCC, 0x81,
+	0xCA, 0x05, 0x6C, 0xCC, 0xA3, 0xCC, 0x84, 0xCA,
+	0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x6F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x6F,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x6F, 0xCC,
+	// Bytes 3ac0 - 3aff
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x6F, 0xCC, 0x83,
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC,
+	0x84, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC, 0x88,
+	0xCA, 0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x80, 0xCA,
+	0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05,
+	0x6F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05, 0x6F,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x6F, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x6F, 0xCC, 0x9B,
+	// Bytes 3b00 - 3b3f
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	0x05, 0x6F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05,
+	0x6F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05, 0x72,
+	0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x73, 0xCC,
+	0x81, 0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0x8C,
+	0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0xA3, 0xCC,
+	// Bytes 3b40 - 3b7f
+	0x87, 0xCA, 0x05, 0x75, 0xCC, 0x83, 0xCC, 0x81,
+	0xCA, 0x05, 0x75, 0xCC, 0x84, 0xCC, 0x88, 0xCA,
+	0x05, 0x75, 0xCC, 0x88, 0xCC, 0x80, 0xCA, 0x05,
+	0x75, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05, 0x75,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x75, 0xCC,
+	0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x75, 0xCC, 0x9B,
+	0xCC, 0x80, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC,
+	0x81, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x83,
+	// Bytes 3b80 - 3bbf
+	0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x89, 0xCA,
+	0x05, 0x75, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6, 0x05,
+	0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0xCA, 0x05, 0xE1,
+	0xBE, 0xBF, 0xCC, 0x81, 0xCA, 0x05, 0xE1, 0xBE,
+	0xBF, 0xCD, 0x82, 0xCA, 0x05, 0xE1, 0xBF, 0xBE,
+	0xCC, 0x80, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCC,
+	0x81, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCD, 0x82,
+	0xCA, 0x05, 0xE2, 0x86, 0x90, 0xCC, 0xB8, 0x05,
+	// Bytes 3bc0 - 3bff
+	0x05, 0xE2, 0x86, 0x92, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x86, 0x94, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x87, 0x90, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87,
+	0x92, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87, 0x94,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x88, 0x83, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x88, 0x88, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x88, 0x8B, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x88, 0xA3, 0xCC, 0xB8, 0x05, 0x05,
+	// Bytes 3c00 - 3c3f
+	0xE2, 0x88, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x88, 0xBC, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x85,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x88, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0x8D, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xA1, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xA4, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	// Bytes 3c40 - 3c7f
+	0x89, 0xB2, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0xB3, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB6,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB7, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0xBA, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xBB, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xBC, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xBD, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0x82, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	// Bytes 3c80 - 3cbf
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x86,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x87, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x91, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0x92, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x8A, 0xA2, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x8A, 0xA8, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0xA9, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	0xAB, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB2,
+	// Bytes 3cc0 - 3cff
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB3, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB4, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0xB5, 0xCC, 0xB8, 0x05,
+	0x06, 0xCE, 0x91, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x91, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	// Bytes 3d00 - 3d3f
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3d40 - 3d7f
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	// Bytes 3d80 - 3dbf
+	0x06, 0xCE, 0xA9, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	// Bytes 3dc0 - 3dff
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	// Bytes 3e00 - 3e3f
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3e40 - 3e7f
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	// Bytes 3e80 - 3ebf
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x89, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	// Bytes 3ec0 - 3eff
+	0x06, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB0, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB3, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xB1, 0x86, 0xE0, 0xB1, 0x96, 0x85,
+	0x06, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8A, 0x11,
+	// Bytes 3f00 - 3f3f
+	0x06, 0xE3, 0x81, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x91, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x93, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x97, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f40 - 3f7f
+	0x06, 0xE3, 0x81, 0x99, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA4, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA8, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f80 - 3fbf
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x9A, 0x0D,
+	// Bytes 3fc0 - 3fff
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x82, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4000 - 403f
+	0x06, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4040 - 407f
+	0x06, 0xE3, 0x83, 0x84, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4080 - 40bf
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB0, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 40c0 - 40ff
+	0x06, 0xE3, 0x83, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	// Bytes 4100 - 413f
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	// Bytes 4140 - 417f
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCD,
+	// Bytes 4180 - 41bf
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	// Bytes 41c0 - 41ff
+	0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	// Bytes 4200 - 423f
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xF0, 0x91, 0x82, 0x99, 0xF0, 0x91, 0x82,
+	// Bytes 4240 - 427f
+	0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82, 0x9B, 0xF0,
+	0x91, 0x82, 0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82,
+	0xA5, 0xF0, 0x91, 0x82, 0xBA, 0x09, 0x42, 0xC2,
+	0xB4, 0x01, 0x43, 0x20, 0xCC, 0x81, 0xC9, 0x43,
+	0x20, 0xCC, 0x83, 0xC9, 0x43, 0x20, 0xCC, 0x84,
+	0xC9, 0x43, 0x20, 0xCC, 0x85, 0xC9, 0x43, 0x20,
+	0xCC, 0x86, 0xC9, 0x43, 0x20, 0xCC, 0x87, 0xC9,
+	0x43, 0x20, 0xCC, 0x88, 0xC9, 0x43, 0x20, 0xCC,
+	// Bytes 4280 - 42bf
+	0x8A, 0xC9, 0x43, 0x20, 0xCC, 0x8B, 0xC9, 0x43,
+	0x20, 0xCC, 0x93, 0xC9, 0x43, 0x20, 0xCC, 0x94,
+	0xC9, 0x43, 0x20, 0xCC, 0xA7, 0xA5, 0x43, 0x20,
+	0xCC, 0xA8, 0xA5, 0x43, 0x20, 0xCC, 0xB3, 0xB5,
+	0x43, 0x20, 0xCD, 0x82, 0xC9, 0x43, 0x20, 0xCD,
+	0x85, 0xD9, 0x43, 0x20, 0xD9, 0x8B, 0x59, 0x43,
+	0x20, 0xD9, 0x8C, 0x5D, 0x43, 0x20, 0xD9, 0x8D,
+	0x61, 0x43, 0x20, 0xD9, 0x8E, 0x65, 0x43, 0x20,
+	// Bytes 42c0 - 42ff
+	0xD9, 0x8F, 0x69, 0x43, 0x20, 0xD9, 0x90, 0x6D,
+	0x43, 0x20, 0xD9, 0x91, 0x71, 0x43, 0x20, 0xD9,
+	0x92, 0x75, 0x43, 0x41, 0xCC, 0x8A, 0xC9, 0x43,
+	0x73, 0xCC, 0x87, 0xC9, 0x44, 0x20, 0xE3, 0x82,
+	0x99, 0x0D, 0x44, 0x20, 0xE3, 0x82, 0x9A, 0x0D,
+	0x44, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x44, 0xCE,
+	0x91, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0x95, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0x97, 0xCC, 0x81, 0xC9,
+	// Bytes 4300 - 433f
+	0x44, 0xCE, 0x99, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0x9F, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC, 0x88, 0xC9,
+	0x44, 0xCE, 0xA9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xB1, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xB5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xB7, 0xCC, 0x81, 0xC9,
+	0x44, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xBF, 0xCC, 0x81, 0xC9, 0x44, 0xCF, 0x85, 0xCC,
+	// Bytes 4340 - 437f
+	0x81, 0xC9, 0x44, 0xCF, 0x89, 0xCC, 0x81, 0xC9,
+	0x44, 0xD7, 0x90, 0xD6, 0xB7, 0x31, 0x44, 0xD7,
+	0x90, 0xD6, 0xB8, 0x35, 0x44, 0xD7, 0x90, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x91, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x91, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x92, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x93, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x94, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x95, 0xD6, 0xB9, 0x39, 0x44, 0xD7,
+	// Bytes 4380 - 43bf
+	0x95, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x96, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x98, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x99, 0xD6, 0xB4, 0x25, 0x44, 0xD7,
+	0x99, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9A, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x9B, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x9B, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x9C, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9E, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA0, 0xD6, 0xBC, 0x41,
+	// Bytes 43c0 - 43ff
+	0x44, 0xD7, 0xA1, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA3, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6, 0xBF, 0x49,
+	0x44, 0xD7, 0xA6, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA7, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA8, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA9, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0xA9, 0xD7, 0x81, 0x4D, 0x44, 0xD7,
+	0xA9, 0xD7, 0x82, 0x51, 0x44, 0xD7, 0xAA, 0xD6,
+	// Bytes 4400 - 443f
+	0xBC, 0x41, 0x44, 0xD7, 0xB2, 0xD6, 0xB7, 0x31,
+	0x44, 0xD8, 0xA7, 0xD9, 0x8B, 0x59, 0x44, 0xD8,
+	0xA7, 0xD9, 0x93, 0xC9, 0x44, 0xD8, 0xA7, 0xD9,
+	0x94, 0xC9, 0x44, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x44, 0xD8, 0xB0, 0xD9, 0xB0, 0x79, 0x44, 0xD8,
+	0xB1, 0xD9, 0xB0, 0x79, 0x44, 0xD9, 0x80, 0xD9,
+	0x8B, 0x59, 0x44, 0xD9, 0x80, 0xD9, 0x8E, 0x65,
+	0x44, 0xD9, 0x80, 0xD9, 0x8F, 0x69, 0x44, 0xD9,
+	// Bytes 4440 - 447f
+	0x80, 0xD9, 0x90, 0x6D, 0x44, 0xD9, 0x80, 0xD9,
+	0x91, 0x71, 0x44, 0xD9, 0x80, 0xD9, 0x92, 0x75,
+	0x44, 0xD9, 0x87, 0xD9, 0xB0, 0x79, 0x44, 0xD9,
+	0x88, 0xD9, 0x94, 0xC9, 0x44, 0xD9, 0x89, 0xD9,
+	0xB0, 0x79, 0x44, 0xD9, 0x8A, 0xD9, 0x94, 0xC9,
+	0x44, 0xDB, 0x92, 0xD9, 0x94, 0xC9, 0x44, 0xDB,
+	0x95, 0xD9, 0x94, 0xC9, 0x45, 0x20, 0xCC, 0x88,
+	0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCC,
+	// Bytes 4480 - 44bf
+	0x81, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCD, 0x82,
+	0xCA, 0x45, 0x20, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x45, 0x20, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x45,
+	0x20, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x45, 0x20,
+	0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC,
+	0x94, 0xCC, 0x81, 0xCA, 0x45, 0x20, 0xCC, 0x94,
+	0xCD, 0x82, 0xCA, 0x45, 0x20, 0xD9, 0x8C, 0xD9,
+	0x91, 0x72, 0x45, 0x20, 0xD9, 0x8D, 0xD9, 0x91,
+	// Bytes 44c0 - 44ff
+	0x72, 0x45, 0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x72,
+	0x45, 0x20, 0xD9, 0x8F, 0xD9, 0x91, 0x72, 0x45,
+	0x20, 0xD9, 0x90, 0xD9, 0x91, 0x72, 0x45, 0x20,
+	0xD9, 0x91, 0xD9, 0xB0, 0x7A, 0x45, 0xE2, 0xAB,
+	0x9D, 0xCC, 0xB8, 0x05, 0x46, 0xCE, 0xB9, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xCF, 0x85, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xD7, 0xA9, 0xD6,
+	0xBC, 0xD7, 0x81, 0x4E, 0x46, 0xD7, 0xA9, 0xD6,
+	// Bytes 4500 - 453f
+	0xBC, 0xD7, 0x82, 0x52, 0x46, 0xD9, 0x80, 0xD9,
+	0x8E, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x8F, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x90, 0xD9, 0x91, 0x72, 0x46, 0xE0, 0xA4, 0x95,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x96,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x97,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x9C,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA1,
+	// Bytes 4540 - 457f
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA2,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAB,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAF,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA1,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA2,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xAF,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x96,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x97,
+	// Bytes 4580 - 45bf
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x9C,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xAB,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB2,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB8,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA1,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA2,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE0, 0xBE, 0xB3,
+	// Bytes 45c0 - 45ff
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0x0D, 0x48, 0xF0, 0x9D, 0x85,
+	0x97, 0xF0, 0x9D, 0x85, 0xA5, 0xAD, 0x48, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xAD,
+	0x48, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xAD, 0x48, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	0x9D, 0x85, 0xA5, 0xAD, 0x49, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x49,
+	// Bytes 4600 - 463f
+	0xE0, 0xBE, 0xB3, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE,
+	0x80, 0x9E, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xB0, 0xAE, 0x4C, 0xF0, 0x9D, 0x85,
+	0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	// Bytes 4640 - 467f
+	0xB1, 0xAE, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB2, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0, 0x9D, 0x86,
+	0xBA, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	0xAE, 0xAE, 0x4C, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	// Bytes 4680 - 46bf
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE,
+	0x83, 0x41, 0xCC, 0x82, 0xC9, 0x83, 0x41, 0xCC,
+	0x86, 0xC9, 0x83, 0x41, 0xCC, 0x87, 0xC9, 0x83,
+	0x41, 0xCC, 0x88, 0xC9, 0x83, 0x41, 0xCC, 0x8A,
+	0xC9, 0x83, 0x41, 0xCC, 0xA3, 0xB5, 0x83, 0x43,
+	0xCC, 0xA7, 0xA5, 0x83, 0x45, 0xCC, 0x82, 0xC9,
+	0x83, 0x45, 0xCC, 0x84, 0xC9, 0x83, 0x45, 0xCC,
+	0xA3, 0xB5, 0x83, 0x45, 0xCC, 0xA7, 0xA5, 0x83,
+	// Bytes 46c0 - 46ff
+	0x49, 0xCC, 0x88, 0xC9, 0x83, 0x4C, 0xCC, 0xA3,
+	0xB5, 0x83, 0x4F, 0xCC, 0x82, 0xC9, 0x83, 0x4F,
+	0xCC, 0x83, 0xC9, 0x83, 0x4F, 0xCC, 0x84, 0xC9,
+	0x83, 0x4F, 0xCC, 0x87, 0xC9, 0x83, 0x4F, 0xCC,
+	0x88, 0xC9, 0x83, 0x4F, 0xCC, 0x9B, 0xAD, 0x83,
+	0x4F, 0xCC, 0xA3, 0xB5, 0x83, 0x4F, 0xCC, 0xA8,
+	0xA5, 0x83, 0x52, 0xCC, 0xA3, 0xB5, 0x83, 0x53,
+	0xCC, 0x81, 0xC9, 0x83, 0x53, 0xCC, 0x8C, 0xC9,
+	// Bytes 4700 - 473f
+	0x83, 0x53, 0xCC, 0xA3, 0xB5, 0x83, 0x55, 0xCC,
+	0x83, 0xC9, 0x83, 0x55, 0xCC, 0x84, 0xC9, 0x83,
+	0x55, 0xCC, 0x88, 0xC9, 0x83, 0x55, 0xCC, 0x9B,
+	0xAD, 0x83, 0x61, 0xCC, 0x82, 0xC9, 0x83, 0x61,
+	0xCC, 0x86, 0xC9, 0x83, 0x61, 0xCC, 0x87, 0xC9,
+	0x83, 0x61, 0xCC, 0x88, 0xC9, 0x83, 0x61, 0xCC,
+	0x8A, 0xC9, 0x83, 0x61, 0xCC, 0xA3, 0xB5, 0x83,
+	0x63, 0xCC, 0xA7, 0xA5, 0x83, 0x65, 0xCC, 0x82,
+	// Bytes 4740 - 477f
+	0xC9, 0x83, 0x65, 0xCC, 0x84, 0xC9, 0x83, 0x65,
+	0xCC, 0xA3, 0xB5, 0x83, 0x65, 0xCC, 0xA7, 0xA5,
+	0x83, 0x69, 0xCC, 0x88, 0xC9, 0x83, 0x6C, 0xCC,
+	0xA3, 0xB5, 0x83, 0x6F, 0xCC, 0x82, 0xC9, 0x83,
+	0x6F, 0xCC, 0x83, 0xC9, 0x83, 0x6F, 0xCC, 0x84,
+	0xC9, 0x83, 0x6F, 0xCC, 0x87, 0xC9, 0x83, 0x6F,
+	0xCC, 0x88, 0xC9, 0x83, 0x6F, 0xCC, 0x9B, 0xAD,
+	0x83, 0x6F, 0xCC, 0xA3, 0xB5, 0x83, 0x6F, 0xCC,
+	// Bytes 4780 - 47bf
+	0xA8, 0xA5, 0x83, 0x72, 0xCC, 0xA3, 0xB5, 0x83,
+	0x73, 0xCC, 0x81, 0xC9, 0x83, 0x73, 0xCC, 0x8C,
+	0xC9, 0x83, 0x73, 0xCC, 0xA3, 0xB5, 0x83, 0x75,
+	0xCC, 0x83, 0xC9, 0x83, 0x75, 0xCC, 0x84, 0xC9,
+	0x83, 0x75, 0xCC, 0x88, 0xC9, 0x83, 0x75, 0xCC,
+	0x9B, 0xAD, 0x84, 0xCE, 0x91, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x91, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x95, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x95, 0xCC,
+	// Bytes 47c0 - 47ff
+	0x94, 0xC9, 0x84, 0xCE, 0x97, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x97, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x99, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x99, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0x9F, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x9F, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0xA5, 0xCC, 0x94, 0xC9, 0x84, 0xCE, 0xA9, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xA9, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCC, 0x80, 0xC9, 0x84, 0xCE,
+	// Bytes 4800 - 483f
+	0xB1, 0xCC, 0x81, 0xC9, 0x84, 0xCE, 0xB1, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xB1, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCD, 0x82, 0xC9, 0x84, 0xCE,
+	0xB5, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB5, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCC, 0x80, 0xC9,
+	0x84, 0xCE, 0xB7, 0xCC, 0x81, 0xC9, 0x84, 0xCE,
+	0xB7, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB7, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCD, 0x82, 0xC9,
+	// Bytes 4840 - 487f
+	0x84, 0xCE, 0xB9, 0xCC, 0x88, 0xC9, 0x84, 0xCE,
+	0xB9, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB9, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xBF, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0xBF, 0xCC, 0x94, 0xC9, 0x84, 0xCF,
+	0x85, 0xCC, 0x88, 0xC9, 0x84, 0xCF, 0x85, 0xCC,
+	0x93, 0xC9, 0x84, 0xCF, 0x85, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCC, 0x80, 0xC9, 0x84, 0xCF,
+	0x89, 0xCC, 0x81, 0xC9, 0x84, 0xCF, 0x89, 0xCC,
+	// Bytes 4880 - 48bf
+	0x93, 0xC9, 0x84, 0xCF, 0x89, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCD, 0x82, 0xC9, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	// Bytes 48c0 - 48ff
+	0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	// Bytes 4900 - 493f
+	0xA9, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	// Bytes 4940 - 497f
+	0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	// Bytes 4980 - 49bf
+	0x89, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x42, 0xCC,
+	0x80, 0xC9, 0x32, 0x42, 0xCC, 0x81, 0xC9, 0x32,
+	0x42, 0xCC, 0x93, 0xC9, 0x32, 0x43, 0xE1, 0x85,
+	// Bytes 49c0 - 49ff
+	0xA1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA5, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA6, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA7, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA8, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA9, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAA, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAB, 0x01, 0x00, 0x43,
+	// Bytes 4a00 - 4a3f
+	0xE1, 0x85, 0xAC, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xAD, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAE, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAF, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB0, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xB2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xB3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB5, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xAA, 0x01,
+	// Bytes 4a40 - 4a7f
+	0x00, 0x43, 0xE1, 0x86, 0xAC, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xAD, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB0, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB1, 0x01,
+	0x00, 0x43, 0xE1, 0x86, 0xB2, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xB3, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB4, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB5, 0x01,
+	0x00, 0x44, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x32,
+	0x43, 0xE3, 0x82, 0x99, 0x0D, 0x03, 0x43, 0xE3,
+	// Bytes 4a80 - 4abf
+	0x82, 0x9A, 0x0D, 0x03, 0x46, 0xE0, 0xBD, 0xB1,
+	0xE0, 0xBD, 0xB2, 0x9E, 0x26, 0x46, 0xE0, 0xBD,
+	0xB1, 0xE0, 0xBD, 0xB4, 0xA2, 0x26, 0x46, 0xE0,
+	0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x26, 0x00,
+	0x01,
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfcTrie. Total size: 10442 bytes (10.20 KiB). Checksum: 4ba400a9d8208e03.
+type nfcTrie struct{}
+
+func newNfcTrie(i int) *nfcTrie {
+	return &nfcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 45:
+		return uint16(nfcValues[n<<6+uint32(b)])
+	default:
+		n -= 45
+		return uint16(nfcSparse.lookup(n, b))
+	}
+}
+
+// nfcValues: 47 blocks, 3008 entries, 6016 bytes
+// The third block is the zero block.
+var nfcValues = [3008]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8,
+	// Block 0x5, offset 0x140
+	0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0xa000,
+	// Block 0x6, offset 0x180
+	0x184: 0x8100, 0x185: 0x8100,
+	0x186: 0x8100,
+	0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x8100,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x8100, 0x285: 0x35a1,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x3721, 0x2c1: 0x372d, 0x2c3: 0x371b,
+	0x2c6: 0xa000, 0x2c7: 0x3709,
+	0x2cc: 0x375d, 0x2cd: 0x3745, 0x2ce: 0x376f, 0x2d0: 0xa000,
+	0x2d3: 0xa000, 0x2d5: 0xa000, 0x2d6: 0xa000, 0x2d7: 0xa000,
+	0x2d8: 0xa000, 0x2d9: 0x3751, 0x2da: 0xa000,
+	0x2de: 0xa000, 0x2e3: 0xa000,
+	0x2e7: 0xa000,
+	0x2eb: 0xa000, 0x2ed: 0xa000,
+	0x2f0: 0xa000, 0x2f3: 0xa000, 0x2f5: 0xa000,
+	0x2f6: 0xa000, 0x2f7: 0xa000, 0x2f8: 0xa000, 0x2f9: 0x37d5, 0x2fa: 0xa000,
+	0x2fe: 0xa000,
+	// Block 0xc, offset 0x300
+	0x301: 0x3733, 0x302: 0x37b7,
+	0x310: 0x370f, 0x311: 0x3793,
+	0x312: 0x3715, 0x313: 0x3799, 0x316: 0x3727, 0x317: 0x37ab,
+	0x318: 0xa000, 0x319: 0xa000, 0x31a: 0x3829, 0x31b: 0x382f, 0x31c: 0x3739, 0x31d: 0x37bd,
+	0x31e: 0x373f, 0x31f: 0x37c3, 0x322: 0x374b, 0x323: 0x37cf,
+	0x324: 0x3757, 0x325: 0x37db, 0x326: 0x3763, 0x327: 0x37e7, 0x328: 0xa000, 0x329: 0xa000,
+	0x32a: 0x3835, 0x32b: 0x383b, 0x32c: 0x378d, 0x32d: 0x3811, 0x32e: 0x3769, 0x32f: 0x37ed,
+	0x330: 0x3775, 0x331: 0x37f9, 0x332: 0x377b, 0x333: 0x37ff, 0x334: 0x3781, 0x335: 0x3805,
+	0x338: 0x3787, 0x339: 0x380b,
+	// Block 0xd, offset 0x340
+	0x351: 0x812d,
+	0x352: 0x8132, 0x353: 0x8132, 0x354: 0x8132, 0x355: 0x8132, 0x356: 0x812d, 0x357: 0x8132,
+	0x358: 0x8132, 0x359: 0x8132, 0x35a: 0x812e, 0x35b: 0x812d, 0x35c: 0x8132, 0x35d: 0x8132,
+	0x35e: 0x8132, 0x35f: 0x8132, 0x360: 0x8132, 0x361: 0x8132, 0x362: 0x812d, 0x363: 0x812d,
+	0x364: 0x812d, 0x365: 0x812d, 0x366: 0x812d, 0x367: 0x812d, 0x368: 0x8132, 0x369: 0x8132,
+	0x36a: 0x812d, 0x36b: 0x8132, 0x36c: 0x8132, 0x36d: 0x812e, 0x36e: 0x8131, 0x36f: 0x8132,
+	0x370: 0x8105, 0x371: 0x8106, 0x372: 0x8107, 0x373: 0x8108, 0x374: 0x8109, 0x375: 0x810a,
+	0x376: 0x810b, 0x377: 0x810c, 0x378: 0x810d, 0x379: 0x810e, 0x37a: 0x810e, 0x37b: 0x810f,
+	0x37c: 0x8110, 0x37d: 0x8111, 0x37f: 0x8112,
+	// Block 0xe, offset 0x380
+	0x388: 0xa000, 0x38a: 0xa000, 0x38b: 0x8116,
+	0x38c: 0x8117, 0x38d: 0x8118, 0x38e: 0x8119, 0x38f: 0x811a, 0x390: 0x811b, 0x391: 0x811c,
+	0x392: 0x811d, 0x393: 0x9932, 0x394: 0x9932, 0x395: 0x992d, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x8132, 0x39b: 0x8132, 0x39c: 0x812d, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x812d,
+	0x3b0: 0x811e,
+	// Block 0xf, offset 0x3c0
+	0x3c5: 0xa000,
+	0x3c6: 0x2d26, 0x3c7: 0xa000, 0x3c8: 0x2d2e, 0x3c9: 0xa000, 0x3ca: 0x2d36, 0x3cb: 0xa000,
+	0x3cc: 0x2d3e, 0x3cd: 0xa000, 0x3ce: 0x2d46, 0x3d1: 0xa000,
+	0x3d2: 0x2d4e,
+	0x3f4: 0x8102, 0x3f5: 0x9900,
+	0x3fa: 0xa000, 0x3fb: 0x2d56,
+	0x3fc: 0xa000, 0x3fd: 0x2d5e, 0x3fe: 0xa000, 0x3ff: 0xa000,
+	// Block 0x10, offset 0x400
+	0x400: 0x8132, 0x401: 0x8132, 0x402: 0x812d, 0x403: 0x8132, 0x404: 0x8132, 0x405: 0x8132,
+	0x406: 0x8132, 0x407: 0x8132, 0x408: 0x8132, 0x409: 0x8132, 0x40a: 0x812d, 0x40b: 0x8132,
+	0x40c: 0x8132, 0x40d: 0x8135, 0x40e: 0x812a, 0x40f: 0x812d, 0x410: 0x8129, 0x411: 0x8132,
+	0x412: 0x8132, 0x413: 0x8132, 0x414: 0x8132, 0x415: 0x8132, 0x416: 0x8132, 0x417: 0x8132,
+	0x418: 0x8132, 0x419: 0x8132, 0x41a: 0x8132, 0x41b: 0x8132, 0x41c: 0x8132, 0x41d: 0x8132,
+	0x41e: 0x8132, 0x41f: 0x8132, 0x420: 0x8132, 0x421: 0x8132, 0x422: 0x8132, 0x423: 0x8132,
+	0x424: 0x8132, 0x425: 0x8132, 0x426: 0x8132, 0x427: 0x8132, 0x428: 0x8132, 0x429: 0x8132,
+	0x42a: 0x8132, 0x42b: 0x8132, 0x42c: 0x8132, 0x42d: 0x8132, 0x42e: 0x8132, 0x42f: 0x8132,
+	0x430: 0x8132, 0x431: 0x8132, 0x432: 0x8132, 0x433: 0x8132, 0x434: 0x8132, 0x435: 0x8132,
+	0x436: 0x8133, 0x437: 0x8131, 0x438: 0x8131, 0x439: 0x812d, 0x43b: 0x8132,
+	0x43c: 0x8134, 0x43d: 0x812d, 0x43e: 0x8132, 0x43f: 0x812d,
+	// Block 0x11, offset 0x440
+	0x440: 0x2f97, 0x441: 0x32a3, 0x442: 0x2fa1, 0x443: 0x32ad, 0x444: 0x2fa6, 0x445: 0x32b2,
+	0x446: 0x2fab, 0x447: 0x32b7, 0x448: 0x38cc, 0x449: 0x3a5b, 0x44a: 0x2fc4, 0x44b: 0x32d0,
+	0x44c: 0x2fce, 0x44d: 0x32da, 0x44e: 0x2fdd, 0x44f: 0x32e9, 0x450: 0x2fd3, 0x451: 0x32df,
+	0x452: 0x2fd8, 0x453: 0x32e4, 0x454: 0x38ef, 0x455: 0x3a7e, 0x456: 0x38f6, 0x457: 0x3a85,
+	0x458: 0x3019, 0x459: 0x3325, 0x45a: 0x301e, 0x45b: 0x332a, 0x45c: 0x3904, 0x45d: 0x3a93,
+	0x45e: 0x3023, 0x45f: 0x332f, 0x460: 0x3032, 0x461: 0x333e, 0x462: 0x3050, 0x463: 0x335c,
+	0x464: 0x305f, 0x465: 0x336b, 0x466: 0x3055, 0x467: 0x3361, 0x468: 0x3064, 0x469: 0x3370,
+	0x46a: 0x3069, 0x46b: 0x3375, 0x46c: 0x30af, 0x46d: 0x33bb, 0x46e: 0x390b, 0x46f: 0x3a9a,
+	0x470: 0x30b9, 0x471: 0x33ca, 0x472: 0x30c3, 0x473: 0x33d4, 0x474: 0x30cd, 0x475: 0x33de,
+	0x476: 0x46c4, 0x477: 0x4755, 0x478: 0x3912, 0x479: 0x3aa1, 0x47a: 0x30e6, 0x47b: 0x33f7,
+	0x47c: 0x30e1, 0x47d: 0x33f2, 0x47e: 0x30eb, 0x47f: 0x33fc,
+	// Block 0x12, offset 0x480
+	0x480: 0x30f0, 0x481: 0x3401, 0x482: 0x30f5, 0x483: 0x3406, 0x484: 0x3109, 0x485: 0x341a,
+	0x486: 0x3113, 0x487: 0x3424, 0x488: 0x3122, 0x489: 0x3433, 0x48a: 0x311d, 0x48b: 0x342e,
+	0x48c: 0x3935, 0x48d: 0x3ac4, 0x48e: 0x3943, 0x48f: 0x3ad2, 0x490: 0x394a, 0x491: 0x3ad9,
+	0x492: 0x3951, 0x493: 0x3ae0, 0x494: 0x314f, 0x495: 0x3460, 0x496: 0x3154, 0x497: 0x3465,
+	0x498: 0x315e, 0x499: 0x346f, 0x49a: 0x46f1, 0x49b: 0x4782, 0x49c: 0x3997, 0x49d: 0x3b26,
+	0x49e: 0x3177, 0x49f: 0x3488, 0x4a0: 0x3181, 0x4a1: 0x3492, 0x4a2: 0x4700, 0x4a3: 0x4791,
+	0x4a4: 0x399e, 0x4a5: 0x3b2d, 0x4a6: 0x39a5, 0x4a7: 0x3b34, 0x4a8: 0x39ac, 0x4a9: 0x3b3b,
+	0x4aa: 0x3190, 0x4ab: 0x34a1, 0x4ac: 0x319a, 0x4ad: 0x34b0, 0x4ae: 0x31ae, 0x4af: 0x34c4,
+	0x4b0: 0x31a9, 0x4b1: 0x34bf, 0x4b2: 0x31ea, 0x4b3: 0x3500, 0x4b4: 0x31f9, 0x4b5: 0x350f,
+	0x4b6: 0x31f4, 0x4b7: 0x350a, 0x4b8: 0x39b3, 0x4b9: 0x3b42, 0x4ba: 0x39ba, 0x4bb: 0x3b49,
+	0x4bc: 0x31fe, 0x4bd: 0x3514, 0x4be: 0x3203, 0x4bf: 0x3519,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x3208, 0x4c1: 0x351e, 0x4c2: 0x320d, 0x4c3: 0x3523, 0x4c4: 0x321c, 0x4c5: 0x3532,
+	0x4c6: 0x3217, 0x4c7: 0x352d, 0x4c8: 0x3221, 0x4c9: 0x353c, 0x4ca: 0x3226, 0x4cb: 0x3541,
+	0x4cc: 0x322b, 0x4cd: 0x3546, 0x4ce: 0x3249, 0x4cf: 0x3564, 0x4d0: 0x3262, 0x4d1: 0x3582,
+	0x4d2: 0x3271, 0x4d3: 0x3591, 0x4d4: 0x3276, 0x4d5: 0x3596, 0x4d6: 0x337a, 0x4d7: 0x34a6,
+	0x4d8: 0x3537, 0x4d9: 0x3573, 0x4db: 0x35d1,
+	0x4e0: 0x46a1, 0x4e1: 0x4732, 0x4e2: 0x2f83, 0x4e3: 0x328f,
+	0x4e4: 0x3878, 0x4e5: 0x3a07, 0x4e6: 0x3871, 0x4e7: 0x3a00, 0x4e8: 0x3886, 0x4e9: 0x3a15,
+	0x4ea: 0x387f, 0x4eb: 0x3a0e, 0x4ec: 0x38be, 0x4ed: 0x3a4d, 0x4ee: 0x3894, 0x4ef: 0x3a23,
+	0x4f0: 0x388d, 0x4f1: 0x3a1c, 0x4f2: 0x38a2, 0x4f3: 0x3a31, 0x4f4: 0x389b, 0x4f5: 0x3a2a,
+	0x4f6: 0x38c5, 0x4f7: 0x3a54, 0x4f8: 0x46b5, 0x4f9: 0x4746, 0x4fa: 0x3000, 0x4fb: 0x330c,
+	0x4fc: 0x2fec, 0x4fd: 0x32f8, 0x4fe: 0x38da, 0x4ff: 0x3a69,
+	// Block 0x14, offset 0x500
+	0x500: 0x38d3, 0x501: 0x3a62, 0x502: 0x38e8, 0x503: 0x3a77, 0x504: 0x38e1, 0x505: 0x3a70,
+	0x506: 0x38fd, 0x507: 0x3a8c, 0x508: 0x3091, 0x509: 0x339d, 0x50a: 0x30a5, 0x50b: 0x33b1,
+	0x50c: 0x46e7, 0x50d: 0x4778, 0x50e: 0x3136, 0x50f: 0x3447, 0x510: 0x3920, 0x511: 0x3aaf,
+	0x512: 0x3919, 0x513: 0x3aa8, 0x514: 0x392e, 0x515: 0x3abd, 0x516: 0x3927, 0x517: 0x3ab6,
+	0x518: 0x3989, 0x519: 0x3b18, 0x51a: 0x396d, 0x51b: 0x3afc, 0x51c: 0x3966, 0x51d: 0x3af5,
+	0x51e: 0x397b, 0x51f: 0x3b0a, 0x520: 0x3974, 0x521: 0x3b03, 0x522: 0x3982, 0x523: 0x3b11,
+	0x524: 0x31e5, 0x525: 0x34fb, 0x526: 0x31c7, 0x527: 0x34dd, 0x528: 0x39e4, 0x529: 0x3b73,
+	0x52a: 0x39dd, 0x52b: 0x3b6c, 0x52c: 0x39f2, 0x52d: 0x3b81, 0x52e: 0x39eb, 0x52f: 0x3b7a,
+	0x530: 0x39f9, 0x531: 0x3b88, 0x532: 0x3230, 0x533: 0x354b, 0x534: 0x3258, 0x535: 0x3578,
+	0x536: 0x3253, 0x537: 0x356e, 0x538: 0x323f, 0x539: 0x355a,
+	// Block 0x15, offset 0x540
+	0x540: 0x4804, 0x541: 0x480a, 0x542: 0x491e, 0x543: 0x4936, 0x544: 0x4926, 0x545: 0x493e,
+	0x546: 0x492e, 0x547: 0x4946, 0x548: 0x47aa, 0x549: 0x47b0, 0x54a: 0x488e, 0x54b: 0x48a6,
+	0x54c: 0x4896, 0x54d: 0x48ae, 0x54e: 0x489e, 0x54f: 0x48b6, 0x550: 0x4816, 0x551: 0x481c,
+	0x552: 0x3db8, 0x553: 0x3dc8, 0x554: 0x3dc0, 0x555: 0x3dd0,
+	0x558: 0x47b6, 0x559: 0x47bc, 0x55a: 0x3ce8, 0x55b: 0x3cf8, 0x55c: 0x3cf0, 0x55d: 0x3d00,
+	0x560: 0x482e, 0x561: 0x4834, 0x562: 0x494e, 0x563: 0x4966,
+	0x564: 0x4956, 0x565: 0x496e, 0x566: 0x495e, 0x567: 0x4976, 0x568: 0x47c2, 0x569: 0x47c8,
+	0x56a: 0x48be, 0x56b: 0x48d6, 0x56c: 0x48c6, 0x56d: 0x48de, 0x56e: 0x48ce, 0x56f: 0x48e6,
+	0x570: 0x4846, 0x571: 0x484c, 0x572: 0x3e18, 0x573: 0x3e30, 0x574: 0x3e20, 0x575: 0x3e38,
+	0x576: 0x3e28, 0x577: 0x3e40, 0x578: 0x47ce, 0x579: 0x47d4, 0x57a: 0x3d18, 0x57b: 0x3d30,
+	0x57c: 0x3d20, 0x57d: 0x3d38, 0x57e: 0x3d28, 0x57f: 0x3d40,
+	// Block 0x16, offset 0x580
+	0x580: 0x4852, 0x581: 0x4858, 0x582: 0x3e48, 0x583: 0x3e58, 0x584: 0x3e50, 0x585: 0x3e60,
+	0x588: 0x47da, 0x589: 0x47e0, 0x58a: 0x3d48, 0x58b: 0x3d58,
+	0x58c: 0x3d50, 0x58d: 0x3d60, 0x590: 0x4864, 0x591: 0x486a,
+	0x592: 0x3e80, 0x593: 0x3e98, 0x594: 0x3e88, 0x595: 0x3ea0, 0x596: 0x3e90, 0x597: 0x3ea8,
+	0x599: 0x47e6, 0x59b: 0x3d68, 0x59d: 0x3d70,
+	0x59f: 0x3d78, 0x5a0: 0x487c, 0x5a1: 0x4882, 0x5a2: 0x497e, 0x5a3: 0x4996,
+	0x5a4: 0x4986, 0x5a5: 0x499e, 0x5a6: 0x498e, 0x5a7: 0x49a6, 0x5a8: 0x47ec, 0x5a9: 0x47f2,
+	0x5aa: 0x48ee, 0x5ab: 0x4906, 0x5ac: 0x48f6, 0x5ad: 0x490e, 0x5ae: 0x48fe, 0x5af: 0x4916,
+	0x5b0: 0x47f8, 0x5b1: 0x431e, 0x5b2: 0x3691, 0x5b3: 0x4324, 0x5b4: 0x4822, 0x5b5: 0x432a,
+	0x5b6: 0x36a3, 0x5b7: 0x4330, 0x5b8: 0x36c1, 0x5b9: 0x4336, 0x5ba: 0x36d9, 0x5bb: 0x433c,
+	0x5bc: 0x4870, 0x5bd: 0x4342,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x3da0, 0x5c1: 0x3da8, 0x5c2: 0x4184, 0x5c3: 0x41a2, 0x5c4: 0x418e, 0x5c5: 0x41ac,
+	0x5c6: 0x4198, 0x5c7: 0x41b6, 0x5c8: 0x3cd8, 0x5c9: 0x3ce0, 0x5ca: 0x40d0, 0x5cb: 0x40ee,
+	0x5cc: 0x40da, 0x5cd: 0x40f8, 0x5ce: 0x40e4, 0x5cf: 0x4102, 0x5d0: 0x3de8, 0x5d1: 0x3df0,
+	0x5d2: 0x41c0, 0x5d3: 0x41de, 0x5d4: 0x41ca, 0x5d5: 0x41e8, 0x5d6: 0x41d4, 0x5d7: 0x41f2,
+	0x5d8: 0x3d08, 0x5d9: 0x3d10, 0x5da: 0x410c, 0x5db: 0x412a, 0x5dc: 0x4116, 0x5dd: 0x4134,
+	0x5de: 0x4120, 0x5df: 0x413e, 0x5e0: 0x3ec0, 0x5e1: 0x3ec8, 0x5e2: 0x41fc, 0x5e3: 0x421a,
+	0x5e4: 0x4206, 0x5e5: 0x4224, 0x5e6: 0x4210, 0x5e7: 0x422e, 0x5e8: 0x3d80, 0x5e9: 0x3d88,
+	0x5ea: 0x4148, 0x5eb: 0x4166, 0x5ec: 0x4152, 0x5ed: 0x4170, 0x5ee: 0x415c, 0x5ef: 0x417a,
+	0x5f0: 0x3685, 0x5f1: 0x367f, 0x5f2: 0x3d90, 0x5f3: 0x368b, 0x5f4: 0x3d98,
+	0x5f6: 0x4810, 0x5f7: 0x3db0, 0x5f8: 0x35f5, 0x5f9: 0x35ef, 0x5fa: 0x35e3, 0x5fb: 0x42ee,
+	0x5fc: 0x35fb, 0x5fd: 0x8100, 0x5fe: 0x01d3, 0x5ff: 0xa100,
+	// Block 0x18, offset 0x600
+	0x600: 0x8100, 0x601: 0x35a7, 0x602: 0x3dd8, 0x603: 0x369d, 0x604: 0x3de0,
+	0x606: 0x483a, 0x607: 0x3df8, 0x608: 0x3601, 0x609: 0x42f4, 0x60a: 0x360d, 0x60b: 0x42fa,
+	0x60c: 0x3619, 0x60d: 0x3b8f, 0x60e: 0x3b96, 0x60f: 0x3b9d, 0x610: 0x36b5, 0x611: 0x36af,
+	0x612: 0x3e00, 0x613: 0x44e4, 0x616: 0x36bb, 0x617: 0x3e10,
+	0x618: 0x3631, 0x619: 0x362b, 0x61a: 0x361f, 0x61b: 0x4300, 0x61d: 0x3ba4,
+	0x61e: 0x3bab, 0x61f: 0x3bb2, 0x620: 0x36eb, 0x621: 0x36e5, 0x622: 0x3e68, 0x623: 0x44ec,
+	0x624: 0x36cd, 0x625: 0x36d3, 0x626: 0x36f1, 0x627: 0x3e78, 0x628: 0x3661, 0x629: 0x365b,
+	0x62a: 0x364f, 0x62b: 0x430c, 0x62c: 0x3649, 0x62d: 0x359b, 0x62e: 0x42e8, 0x62f: 0x0081,
+	0x632: 0x3eb0, 0x633: 0x36f7, 0x634: 0x3eb8,
+	0x636: 0x4888, 0x637: 0x3ed0, 0x638: 0x363d, 0x639: 0x4306, 0x63a: 0x366d, 0x63b: 0x4318,
+	0x63c: 0x3679, 0x63d: 0x4256, 0x63e: 0xa100,
+	// Block 0x19, offset 0x640
+	0x641: 0x3c06, 0x643: 0xa000, 0x644: 0x3c0d, 0x645: 0xa000,
+	0x647: 0x3c14, 0x648: 0xa000, 0x649: 0x3c1b,
+	0x64d: 0xa000,
+	0x660: 0x2f65, 0x661: 0xa000, 0x662: 0x3c29,
+	0x664: 0xa000, 0x665: 0xa000,
+	0x66d: 0x3c22, 0x66e: 0x2f60, 0x66f: 0x2f6a,
+	0x670: 0x3c30, 0x671: 0x3c37, 0x672: 0xa000, 0x673: 0xa000, 0x674: 0x3c3e, 0x675: 0x3c45,
+	0x676: 0xa000, 0x677: 0xa000, 0x678: 0x3c4c, 0x679: 0x3c53, 0x67a: 0xa000, 0x67b: 0xa000,
+	0x67c: 0xa000, 0x67d: 0xa000,
+	// Block 0x1a, offset 0x680
+	0x680: 0x3c5a, 0x681: 0x3c61, 0x682: 0xa000, 0x683: 0xa000, 0x684: 0x3c76, 0x685: 0x3c7d,
+	0x686: 0xa000, 0x687: 0xa000, 0x688: 0x3c84, 0x689: 0x3c8b,
+	0x691: 0xa000,
+	0x692: 0xa000,
+	0x6a2: 0xa000,
+	0x6a8: 0xa000, 0x6a9: 0xa000,
+	0x6ab: 0xa000, 0x6ac: 0x3ca0, 0x6ad: 0x3ca7, 0x6ae: 0x3cae, 0x6af: 0x3cb5,
+	0x6b2: 0xa000, 0x6b3: 0xa000, 0x6b4: 0xa000, 0x6b5: 0xa000,
+	// Block 0x1b, offset 0x6c0
+	0x6c6: 0xa000, 0x6cb: 0xa000,
+	0x6cc: 0x3f08, 0x6cd: 0xa000, 0x6ce: 0x3f10, 0x6cf: 0xa000, 0x6d0: 0x3f18, 0x6d1: 0xa000,
+	0x6d2: 0x3f20, 0x6d3: 0xa000, 0x6d4: 0x3f28, 0x6d5: 0xa000, 0x6d6: 0x3f30, 0x6d7: 0xa000,
+	0x6d8: 0x3f38, 0x6d9: 0xa000, 0x6da: 0x3f40, 0x6db: 0xa000, 0x6dc: 0x3f48, 0x6dd: 0xa000,
+	0x6de: 0x3f50, 0x6df: 0xa000, 0x6e0: 0x3f58, 0x6e1: 0xa000, 0x6e2: 0x3f60,
+	0x6e4: 0xa000, 0x6e5: 0x3f68, 0x6e6: 0xa000, 0x6e7: 0x3f70, 0x6e8: 0xa000, 0x6e9: 0x3f78,
+	0x6ef: 0xa000,
+	0x6f0: 0x3f80, 0x6f1: 0x3f88, 0x6f2: 0xa000, 0x6f3: 0x3f90, 0x6f4: 0x3f98, 0x6f5: 0xa000,
+	0x6f6: 0x3fa0, 0x6f7: 0x3fa8, 0x6f8: 0xa000, 0x6f9: 0x3fb0, 0x6fa: 0x3fb8, 0x6fb: 0xa000,
+	0x6fc: 0x3fc0, 0x6fd: 0x3fc8,
+	// Block 0x1c, offset 0x700
+	0x714: 0x3f00,
+	0x719: 0x9903, 0x71a: 0x9903, 0x71b: 0x8100, 0x71c: 0x8100, 0x71d: 0xa000,
+	0x71e: 0x3fd0,
+	0x726: 0xa000,
+	0x72b: 0xa000, 0x72c: 0x3fe0, 0x72d: 0xa000, 0x72e: 0x3fe8, 0x72f: 0xa000,
+	0x730: 0x3ff0, 0x731: 0xa000, 0x732: 0x3ff8, 0x733: 0xa000, 0x734: 0x4000, 0x735: 0xa000,
+	0x736: 0x4008, 0x737: 0xa000, 0x738: 0x4010, 0x739: 0xa000, 0x73a: 0x4018, 0x73b: 0xa000,
+	0x73c: 0x4020, 0x73d: 0xa000, 0x73e: 0x4028, 0x73f: 0xa000,
+	// Block 0x1d, offset 0x740
+	0x740: 0x4030, 0x741: 0xa000, 0x742: 0x4038, 0x744: 0xa000, 0x745: 0x4040,
+	0x746: 0xa000, 0x747: 0x4048, 0x748: 0xa000, 0x749: 0x4050,
+	0x74f: 0xa000, 0x750: 0x4058, 0x751: 0x4060,
+	0x752: 0xa000, 0x753: 0x4068, 0x754: 0x4070, 0x755: 0xa000, 0x756: 0x4078, 0x757: 0x4080,
+	0x758: 0xa000, 0x759: 0x4088, 0x75a: 0x4090, 0x75b: 0xa000, 0x75c: 0x4098, 0x75d: 0x40a0,
+	0x76f: 0xa000,
+	0x770: 0xa000, 0x771: 0xa000, 0x772: 0xa000, 0x774: 0x3fd8,
+	0x777: 0x40a8, 0x778: 0x40b0, 0x779: 0x40b8, 0x77a: 0x40c0,
+	0x77d: 0xa000, 0x77e: 0x40c8,
+	// Block 0x1e, offset 0x780
+	0x780: 0x1377, 0x781: 0x0cfb, 0x782: 0x13d3, 0x783: 0x139f, 0x784: 0x0e57, 0x785: 0x06eb,
+	0x786: 0x08df, 0x787: 0x162b, 0x788: 0x162b, 0x789: 0x0a0b, 0x78a: 0x145f, 0x78b: 0x0943,
+	0x78c: 0x0a07, 0x78d: 0x0bef, 0x78e: 0x0fcf, 0x78f: 0x115f, 0x790: 0x1297, 0x791: 0x12d3,
+	0x792: 0x1307, 0x793: 0x141b, 0x794: 0x0d73, 0x795: 0x0dff, 0x796: 0x0eab, 0x797: 0x0f43,
+	0x798: 0x125f, 0x799: 0x1447, 0x79a: 0x1573, 0x79b: 0x070f, 0x79c: 0x08b3, 0x79d: 0x0d87,
+	0x79e: 0x0ecf, 0x79f: 0x1293, 0x7a0: 0x15c3, 0x7a1: 0x0ab3, 0x7a2: 0x0e77, 0x7a3: 0x1283,
+	0x7a4: 0x1317, 0x7a5: 0x0c23, 0x7a6: 0x11bb, 0x7a7: 0x12df, 0x7a8: 0x0b1f, 0x7a9: 0x0d0f,
+	0x7aa: 0x0e17, 0x7ab: 0x0f1b, 0x7ac: 0x1427, 0x7ad: 0x074f, 0x7ae: 0x07e7, 0x7af: 0x0853,
+	0x7b0: 0x0c8b, 0x7b1: 0x0d7f, 0x7b2: 0x0ecb, 0x7b3: 0x0fef, 0x7b4: 0x1177, 0x7b5: 0x128b,
+	0x7b6: 0x12a3, 0x7b7: 0x13c7, 0x7b8: 0x14ef, 0x7b9: 0x15a3, 0x7ba: 0x15bf, 0x7bb: 0x102b,
+	0x7bc: 0x106b, 0x7bd: 0x1123, 0x7be: 0x1243, 0x7bf: 0x147b,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x15cb, 0x7c1: 0x134b, 0x7c2: 0x09c7, 0x7c3: 0x0b3b, 0x7c4: 0x10db, 0x7c5: 0x119b,
+	0x7c6: 0x0eff, 0x7c7: 0x1033, 0x7c8: 0x1397, 0x7c9: 0x14e7, 0x7ca: 0x09c3, 0x7cb: 0x0a8f,
+	0x7cc: 0x0d77, 0x7cd: 0x0e2b, 0x7ce: 0x0e5f, 0x7cf: 0x1113, 0x7d0: 0x113b, 0x7d1: 0x14a7,
+	0x7d2: 0x084f, 0x7d3: 0x11a7, 0x7d4: 0x07f3, 0x7d5: 0x07ef, 0x7d6: 0x1097, 0x7d7: 0x1127,
+	0x7d8: 0x125b, 0x7d9: 0x14af, 0x7da: 0x1367, 0x7db: 0x0c27, 0x7dc: 0x0d73, 0x7dd: 0x1357,
+	0x7de: 0x06f7, 0x7df: 0x0a63, 0x7e0: 0x0b93, 0x7e1: 0x0f2f, 0x7e2: 0x0faf, 0x7e3: 0x0873,
+	0x7e4: 0x103b, 0x7e5: 0x075f, 0x7e6: 0x0b77, 0x7e7: 0x06d7, 0x7e8: 0x0deb, 0x7e9: 0x0ca3,
+	0x7ea: 0x110f, 0x7eb: 0x08c7, 0x7ec: 0x09b3, 0x7ed: 0x0ffb, 0x7ee: 0x1263, 0x7ef: 0x133b,
+	0x7f0: 0x0db7, 0x7f1: 0x13f7, 0x7f2: 0x0de3, 0x7f3: 0x0c37, 0x7f4: 0x121b, 0x7f5: 0x0c57,
+	0x7f6: 0x0fab, 0x7f7: 0x072b, 0x7f8: 0x07a7, 0x7f9: 0x07eb, 0x7fa: 0x0d53, 0x7fb: 0x10fb,
+	0x7fc: 0x11f3, 0x7fd: 0x1347, 0x7fe: 0x145b, 0x7ff: 0x085b,
+	// Block 0x20, offset 0x800
+	0x800: 0x090f, 0x801: 0x0a17, 0x802: 0x0b2f, 0x803: 0x0cbf, 0x804: 0x0e7b, 0x805: 0x103f,
+	0x806: 0x1497, 0x807: 0x157b, 0x808: 0x15cf, 0x809: 0x15e7, 0x80a: 0x0837, 0x80b: 0x0cf3,
+	0x80c: 0x0da3, 0x80d: 0x13eb, 0x80e: 0x0afb, 0x80f: 0x0bd7, 0x810: 0x0bf3, 0x811: 0x0c83,
+	0x812: 0x0e6b, 0x813: 0x0eb7, 0x814: 0x0f67, 0x815: 0x108b, 0x816: 0x112f, 0x817: 0x1193,
+	0x818: 0x13db, 0x819: 0x126b, 0x81a: 0x1403, 0x81b: 0x147f, 0x81c: 0x080f, 0x81d: 0x083b,
+	0x81e: 0x0923, 0x81f: 0x0ea7, 0x820: 0x12f3, 0x821: 0x133b, 0x822: 0x0b1b, 0x823: 0x0b8b,
+	0x824: 0x0c4f, 0x825: 0x0daf, 0x826: 0x10d7, 0x827: 0x0f23, 0x828: 0x073b, 0x829: 0x097f,
+	0x82a: 0x0a63, 0x82b: 0x0ac7, 0x82c: 0x0b97, 0x82d: 0x0f3f, 0x82e: 0x0f5b, 0x82f: 0x116b,
+	0x830: 0x118b, 0x831: 0x1463, 0x832: 0x14e3, 0x833: 0x14f3, 0x834: 0x152f, 0x835: 0x0753,
+	0x836: 0x107f, 0x837: 0x144f, 0x838: 0x14cb, 0x839: 0x0baf, 0x83a: 0x0717, 0x83b: 0x0777,
+	0x83c: 0x0a67, 0x83d: 0x0a87, 0x83e: 0x0caf, 0x83f: 0x0d73,
+	// Block 0x21, offset 0x840
+	0x840: 0x0ec3, 0x841: 0x0fcb, 0x842: 0x1277, 0x843: 0x1417, 0x844: 0x1623, 0x845: 0x0ce3,
+	0x846: 0x14a3, 0x847: 0x0833, 0x848: 0x0d2f, 0x849: 0x0d3b, 0x84a: 0x0e0f, 0x84b: 0x0e47,
+	0x84c: 0x0f4b, 0x84d: 0x0fa7, 0x84e: 0x1027, 0x84f: 0x110b, 0x850: 0x153b, 0x851: 0x07af,
+	0x852: 0x0c03, 0x853: 0x14b3, 0x854: 0x0767, 0x855: 0x0aab, 0x856: 0x0e2f, 0x857: 0x13df,
+	0x858: 0x0b67, 0x859: 0x0bb7, 0x85a: 0x0d43, 0x85b: 0x0f2f, 0x85c: 0x14bb, 0x85d: 0x0817,
+	0x85e: 0x08ff, 0x85f: 0x0a97, 0x860: 0x0cd3, 0x861: 0x0d1f, 0x862: 0x0d5f, 0x863: 0x0df3,
+	0x864: 0x0f47, 0x865: 0x0fbb, 0x866: 0x1157, 0x867: 0x12f7, 0x868: 0x1303, 0x869: 0x1457,
+	0x86a: 0x14d7, 0x86b: 0x0883, 0x86c: 0x0e4b, 0x86d: 0x0903, 0x86e: 0x0ec7, 0x86f: 0x0f6b,
+	0x870: 0x1287, 0x871: 0x14bf, 0x872: 0x15ab, 0x873: 0x15d3, 0x874: 0x0d37, 0x875: 0x0e27,
+	0x876: 0x11c3, 0x877: 0x10b7, 0x878: 0x10c3, 0x879: 0x10e7, 0x87a: 0x0f17, 0x87b: 0x0e9f,
+	0x87c: 0x1363, 0x87d: 0x0733, 0x87e: 0x122b, 0x87f: 0x081b,
+	// Block 0x22, offset 0x880
+	0x880: 0x080b, 0x881: 0x0b0b, 0x882: 0x0c2b, 0x883: 0x10f3, 0x884: 0x0a53, 0x885: 0x0e03,
+	0x886: 0x0cef, 0x887: 0x13e7, 0x888: 0x12e7, 0x889: 0x14ab, 0x88a: 0x1323, 0x88b: 0x0b27,
+	0x88c: 0x0787, 0x88d: 0x095b, 0x890: 0x09af,
+	0x892: 0x0cdf, 0x895: 0x07f7, 0x896: 0x0f1f, 0x897: 0x0fe3,
+	0x898: 0x1047, 0x899: 0x1063, 0x89a: 0x1067, 0x89b: 0x107b, 0x89c: 0x14fb, 0x89d: 0x10eb,
+	0x89e: 0x116f, 0x8a0: 0x128f, 0x8a2: 0x1353,
+	0x8a5: 0x1407, 0x8a6: 0x1433,
+	0x8aa: 0x154f, 0x8ab: 0x1553, 0x8ac: 0x1557, 0x8ad: 0x15bb, 0x8ae: 0x142b, 0x8af: 0x14c7,
+	0x8b0: 0x0757, 0x8b1: 0x077b, 0x8b2: 0x078f, 0x8b3: 0x084b, 0x8b4: 0x0857, 0x8b5: 0x0897,
+	0x8b6: 0x094b, 0x8b7: 0x0967, 0x8b8: 0x096f, 0x8b9: 0x09ab, 0x8ba: 0x09b7, 0x8bb: 0x0a93,
+	0x8bc: 0x0a9b, 0x8bd: 0x0ba3, 0x8be: 0x0bcb, 0x8bf: 0x0bd3,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0beb, 0x8c1: 0x0c97, 0x8c2: 0x0cc7, 0x8c3: 0x0ce7, 0x8c4: 0x0d57, 0x8c5: 0x0e1b,
+	0x8c6: 0x0e37, 0x8c7: 0x0e67, 0x8c8: 0x0ebb, 0x8c9: 0x0edb, 0x8ca: 0x0f4f, 0x8cb: 0x102f,
+	0x8cc: 0x104b, 0x8cd: 0x1053, 0x8ce: 0x104f, 0x8cf: 0x1057, 0x8d0: 0x105b, 0x8d1: 0x105f,
+	0x8d2: 0x1073, 0x8d3: 0x1077, 0x8d4: 0x109b, 0x8d5: 0x10af, 0x8d6: 0x10cb, 0x8d7: 0x112f,
+	0x8d8: 0x1137, 0x8d9: 0x113f, 0x8da: 0x1153, 0x8db: 0x117b, 0x8dc: 0x11cb, 0x8dd: 0x11ff,
+	0x8de: 0x11ff, 0x8df: 0x1267, 0x8e0: 0x130f, 0x8e1: 0x1327, 0x8e2: 0x135b, 0x8e3: 0x135f,
+	0x8e4: 0x13a3, 0x8e5: 0x13a7, 0x8e6: 0x13ff, 0x8e7: 0x1407, 0x8e8: 0x14db, 0x8e9: 0x151f,
+	0x8ea: 0x1537, 0x8eb: 0x0b9b, 0x8ec: 0x171e, 0x8ed: 0x11e3,
+	0x8f0: 0x06df, 0x8f1: 0x07e3, 0x8f2: 0x07a3, 0x8f3: 0x074b, 0x8f4: 0x078b, 0x8f5: 0x07b7,
+	0x8f6: 0x0847, 0x8f7: 0x0863, 0x8f8: 0x094b, 0x8f9: 0x0937, 0x8fa: 0x0947, 0x8fb: 0x0963,
+	0x8fc: 0x09af, 0x8fd: 0x09bf, 0x8fe: 0x0a03, 0x8ff: 0x0a0f,
+	// Block 0x24, offset 0x900
+	0x900: 0x0a2b, 0x901: 0x0a3b, 0x902: 0x0b23, 0x903: 0x0b2b, 0x904: 0x0b5b, 0x905: 0x0b7b,
+	0x906: 0x0bab, 0x907: 0x0bc3, 0x908: 0x0bb3, 0x909: 0x0bd3, 0x90a: 0x0bc7, 0x90b: 0x0beb,
+	0x90c: 0x0c07, 0x90d: 0x0c5f, 0x90e: 0x0c6b, 0x90f: 0x0c73, 0x910: 0x0c9b, 0x911: 0x0cdf,
+	0x912: 0x0d0f, 0x913: 0x0d13, 0x914: 0x0d27, 0x915: 0x0da7, 0x916: 0x0db7, 0x917: 0x0e0f,
+	0x918: 0x0e5b, 0x919: 0x0e53, 0x91a: 0x0e67, 0x91b: 0x0e83, 0x91c: 0x0ebb, 0x91d: 0x1013,
+	0x91e: 0x0edf, 0x91f: 0x0f13, 0x920: 0x0f1f, 0x921: 0x0f5f, 0x922: 0x0f7b, 0x923: 0x0f9f,
+	0x924: 0x0fc3, 0x925: 0x0fc7, 0x926: 0x0fe3, 0x927: 0x0fe7, 0x928: 0x0ff7, 0x929: 0x100b,
+	0x92a: 0x1007, 0x92b: 0x1037, 0x92c: 0x10b3, 0x92d: 0x10cb, 0x92e: 0x10e3, 0x92f: 0x111b,
+	0x930: 0x112f, 0x931: 0x114b, 0x932: 0x117b, 0x933: 0x122f, 0x934: 0x1257, 0x935: 0x12cb,
+	0x936: 0x1313, 0x937: 0x131f, 0x938: 0x1327, 0x939: 0x133f, 0x93a: 0x1353, 0x93b: 0x1343,
+	0x93c: 0x135b, 0x93d: 0x1357, 0x93e: 0x134f, 0x93f: 0x135f,
+	// Block 0x25, offset 0x940
+	0x940: 0x136b, 0x941: 0x13a7, 0x942: 0x13e3, 0x943: 0x1413, 0x944: 0x144b, 0x945: 0x146b,
+	0x946: 0x14b7, 0x947: 0x14db, 0x948: 0x14fb, 0x949: 0x150f, 0x94a: 0x151f, 0x94b: 0x152b,
+	0x94c: 0x1537, 0x94d: 0x158b, 0x94e: 0x162b, 0x94f: 0x16b5, 0x950: 0x16b0, 0x951: 0x16e2,
+	0x952: 0x0607, 0x953: 0x062f, 0x954: 0x0633, 0x955: 0x1764, 0x956: 0x1791, 0x957: 0x1809,
+	0x958: 0x1617, 0x959: 0x1627,
+	// Block 0x26, offset 0x980
+	0x980: 0x06fb, 0x981: 0x06f3, 0x982: 0x0703, 0x983: 0x1647, 0x984: 0x0747, 0x985: 0x0757,
+	0x986: 0x075b, 0x987: 0x0763, 0x988: 0x076b, 0x989: 0x076f, 0x98a: 0x077b, 0x98b: 0x0773,
+	0x98c: 0x05b3, 0x98d: 0x165b, 0x98e: 0x078f, 0x98f: 0x0793, 0x990: 0x0797, 0x991: 0x07b3,
+	0x992: 0x164c, 0x993: 0x05b7, 0x994: 0x079f, 0x995: 0x07bf, 0x996: 0x1656, 0x997: 0x07cf,
+	0x998: 0x07d7, 0x999: 0x0737, 0x99a: 0x07df, 0x99b: 0x07e3, 0x99c: 0x1831, 0x99d: 0x07ff,
+	0x99e: 0x0807, 0x99f: 0x05bf, 0x9a0: 0x081f, 0x9a1: 0x0823, 0x9a2: 0x082b, 0x9a3: 0x082f,
+	0x9a4: 0x05c3, 0x9a5: 0x0847, 0x9a6: 0x084b, 0x9a7: 0x0857, 0x9a8: 0x0863, 0x9a9: 0x0867,
+	0x9aa: 0x086b, 0x9ab: 0x0873, 0x9ac: 0x0893, 0x9ad: 0x0897, 0x9ae: 0x089f, 0x9af: 0x08af,
+	0x9b0: 0x08b7, 0x9b1: 0x08bb, 0x9b2: 0x08bb, 0x9b3: 0x08bb, 0x9b4: 0x166a, 0x9b5: 0x0e93,
+	0x9b6: 0x08cf, 0x9b7: 0x08d7, 0x9b8: 0x166f, 0x9b9: 0x08e3, 0x9ba: 0x08eb, 0x9bb: 0x08f3,
+	0x9bc: 0x091b, 0x9bd: 0x0907, 0x9be: 0x0913, 0x9bf: 0x0917,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x091f, 0x9c1: 0x0927, 0x9c2: 0x092b, 0x9c3: 0x0933, 0x9c4: 0x093b, 0x9c5: 0x093f,
+	0x9c6: 0x093f, 0x9c7: 0x0947, 0x9c8: 0x094f, 0x9c9: 0x0953, 0x9ca: 0x095f, 0x9cb: 0x0983,
+	0x9cc: 0x0967, 0x9cd: 0x0987, 0x9ce: 0x096b, 0x9cf: 0x0973, 0x9d0: 0x080b, 0x9d1: 0x09cf,
+	0x9d2: 0x0997, 0x9d3: 0x099b, 0x9d4: 0x099f, 0x9d5: 0x0993, 0x9d6: 0x09a7, 0x9d7: 0x09a3,
+	0x9d8: 0x09bb, 0x9d9: 0x1674, 0x9da: 0x09d7, 0x9db: 0x09db, 0x9dc: 0x09e3, 0x9dd: 0x09ef,
+	0x9de: 0x09f7, 0x9df: 0x0a13, 0x9e0: 0x1679, 0x9e1: 0x167e, 0x9e2: 0x0a1f, 0x9e3: 0x0a23,
+	0x9e4: 0x0a27, 0x9e5: 0x0a1b, 0x9e6: 0x0a2f, 0x9e7: 0x05c7, 0x9e8: 0x05cb, 0x9e9: 0x0a37,
+	0x9ea: 0x0a3f, 0x9eb: 0x0a3f, 0x9ec: 0x1683, 0x9ed: 0x0a5b, 0x9ee: 0x0a5f, 0x9ef: 0x0a63,
+	0x9f0: 0x0a6b, 0x9f1: 0x1688, 0x9f2: 0x0a73, 0x9f3: 0x0a77, 0x9f4: 0x0b4f, 0x9f5: 0x0a7f,
+	0x9f6: 0x05cf, 0x9f7: 0x0a8b, 0x9f8: 0x0a9b, 0x9f9: 0x0aa7, 0x9fa: 0x0aa3, 0x9fb: 0x1692,
+	0x9fc: 0x0aaf, 0x9fd: 0x1697, 0x9fe: 0x0abb, 0x9ff: 0x0ab7,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0abf, 0xa01: 0x0acf, 0xa02: 0x0ad3, 0xa03: 0x05d3, 0xa04: 0x0ae3, 0xa05: 0x0aeb,
+	0xa06: 0x0aef, 0xa07: 0x0af3, 0xa08: 0x05d7, 0xa09: 0x169c, 0xa0a: 0x05db, 0xa0b: 0x0b0f,
+	0xa0c: 0x0b13, 0xa0d: 0x0b17, 0xa0e: 0x0b1f, 0xa0f: 0x1863, 0xa10: 0x0b37, 0xa11: 0x16a6,
+	0xa12: 0x16a6, 0xa13: 0x11d7, 0xa14: 0x0b47, 0xa15: 0x0b47, 0xa16: 0x05df, 0xa17: 0x16c9,
+	0xa18: 0x179b, 0xa19: 0x0b57, 0xa1a: 0x0b5f, 0xa1b: 0x05e3, 0xa1c: 0x0b73, 0xa1d: 0x0b83,
+	0xa1e: 0x0b87, 0xa1f: 0x0b8f, 0xa20: 0x0b9f, 0xa21: 0x05eb, 0xa22: 0x05e7, 0xa23: 0x0ba3,
+	0xa24: 0x16ab, 0xa25: 0x0ba7, 0xa26: 0x0bbb, 0xa27: 0x0bbf, 0xa28: 0x0bc3, 0xa29: 0x0bbf,
+	0xa2a: 0x0bcf, 0xa2b: 0x0bd3, 0xa2c: 0x0be3, 0xa2d: 0x0bdb, 0xa2e: 0x0bdf, 0xa2f: 0x0be7,
+	0xa30: 0x0beb, 0xa31: 0x0bef, 0xa32: 0x0bfb, 0xa33: 0x0bff, 0xa34: 0x0c17, 0xa35: 0x0c1f,
+	0xa36: 0x0c2f, 0xa37: 0x0c43, 0xa38: 0x16ba, 0xa39: 0x0c3f, 0xa3a: 0x0c33, 0xa3b: 0x0c4b,
+	0xa3c: 0x0c53, 0xa3d: 0x0c67, 0xa3e: 0x16bf, 0xa3f: 0x0c6f,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x0c63, 0xa41: 0x0c5b, 0xa42: 0x05ef, 0xa43: 0x0c77, 0xa44: 0x0c7f, 0xa45: 0x0c87,
+	0xa46: 0x0c7b, 0xa47: 0x05f3, 0xa48: 0x0c97, 0xa49: 0x0c9f, 0xa4a: 0x16c4, 0xa4b: 0x0ccb,
+	0xa4c: 0x0cff, 0xa4d: 0x0cdb, 0xa4e: 0x05ff, 0xa4f: 0x0ce7, 0xa50: 0x05fb, 0xa51: 0x05f7,
+	0xa52: 0x07c3, 0xa53: 0x07c7, 0xa54: 0x0d03, 0xa55: 0x0ceb, 0xa56: 0x11ab, 0xa57: 0x0663,
+	0xa58: 0x0d0f, 0xa59: 0x0d13, 0xa5a: 0x0d17, 0xa5b: 0x0d2b, 0xa5c: 0x0d23, 0xa5d: 0x16dd,
+	0xa5e: 0x0603, 0xa5f: 0x0d3f, 0xa60: 0x0d33, 0xa61: 0x0d4f, 0xa62: 0x0d57, 0xa63: 0x16e7,
+	0xa64: 0x0d5b, 0xa65: 0x0d47, 0xa66: 0x0d63, 0xa67: 0x0607, 0xa68: 0x0d67, 0xa69: 0x0d6b,
+	0xa6a: 0x0d6f, 0xa6b: 0x0d7b, 0xa6c: 0x16ec, 0xa6d: 0x0d83, 0xa6e: 0x060b, 0xa6f: 0x0d8f,
+	0xa70: 0x16f1, 0xa71: 0x0d93, 0xa72: 0x060f, 0xa73: 0x0d9f, 0xa74: 0x0dab, 0xa75: 0x0db7,
+	0xa76: 0x0dbb, 0xa77: 0x16f6, 0xa78: 0x168d, 0xa79: 0x16fb, 0xa7a: 0x0ddb, 0xa7b: 0x1700,
+	0xa7c: 0x0de7, 0xa7d: 0x0def, 0xa7e: 0x0ddf, 0xa7f: 0x0dfb,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x0e0b, 0xa81: 0x0e1b, 0xa82: 0x0e0f, 0xa83: 0x0e13, 0xa84: 0x0e1f, 0xa85: 0x0e23,
+	0xa86: 0x1705, 0xa87: 0x0e07, 0xa88: 0x0e3b, 0xa89: 0x0e3f, 0xa8a: 0x0613, 0xa8b: 0x0e53,
+	0xa8c: 0x0e4f, 0xa8d: 0x170a, 0xa8e: 0x0e33, 0xa8f: 0x0e6f, 0xa90: 0x170f, 0xa91: 0x1714,
+	0xa92: 0x0e73, 0xa93: 0x0e87, 0xa94: 0x0e83, 0xa95: 0x0e7f, 0xa96: 0x0617, 0xa97: 0x0e8b,
+	0xa98: 0x0e9b, 0xa99: 0x0e97, 0xa9a: 0x0ea3, 0xa9b: 0x1651, 0xa9c: 0x0eb3, 0xa9d: 0x1719,
+	0xa9e: 0x0ebf, 0xa9f: 0x1723, 0xaa0: 0x0ed3, 0xaa1: 0x0edf, 0xaa2: 0x0ef3, 0xaa3: 0x1728,
+	0xaa4: 0x0f07, 0xaa5: 0x0f0b, 0xaa6: 0x172d, 0xaa7: 0x1732, 0xaa8: 0x0f27, 0xaa9: 0x0f37,
+	0xaaa: 0x061b, 0xaab: 0x0f3b, 0xaac: 0x061f, 0xaad: 0x061f, 0xaae: 0x0f53, 0xaaf: 0x0f57,
+	0xab0: 0x0f5f, 0xab1: 0x0f63, 0xab2: 0x0f6f, 0xab3: 0x0623, 0xab4: 0x0f87, 0xab5: 0x1737,
+	0xab6: 0x0fa3, 0xab7: 0x173c, 0xab8: 0x0faf, 0xab9: 0x16a1, 0xaba: 0x0fbf, 0xabb: 0x1741,
+	0xabc: 0x1746, 0xabd: 0x174b, 0xabe: 0x0627, 0xabf: 0x062b,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x0ff7, 0xac1: 0x1755, 0xac2: 0x1750, 0xac3: 0x175a, 0xac4: 0x175f, 0xac5: 0x0fff,
+	0xac6: 0x1003, 0xac7: 0x1003, 0xac8: 0x100b, 0xac9: 0x0633, 0xaca: 0x100f, 0xacb: 0x0637,
+	0xacc: 0x063b, 0xacd: 0x1769, 0xace: 0x1023, 0xacf: 0x102b, 0xad0: 0x1037, 0xad1: 0x063f,
+	0xad2: 0x176e, 0xad3: 0x105b, 0xad4: 0x1773, 0xad5: 0x1778, 0xad6: 0x107b, 0xad7: 0x1093,
+	0xad8: 0x0643, 0xad9: 0x109b, 0xada: 0x109f, 0xadb: 0x10a3, 0xadc: 0x177d, 0xadd: 0x1782,
+	0xade: 0x1782, 0xadf: 0x10bb, 0xae0: 0x0647, 0xae1: 0x1787, 0xae2: 0x10cf, 0xae3: 0x10d3,
+	0xae4: 0x064b, 0xae5: 0x178c, 0xae6: 0x10ef, 0xae7: 0x064f, 0xae8: 0x10ff, 0xae9: 0x10f7,
+	0xaea: 0x1107, 0xaeb: 0x1796, 0xaec: 0x111f, 0xaed: 0x0653, 0xaee: 0x112b, 0xaef: 0x1133,
+	0xaf0: 0x1143, 0xaf1: 0x0657, 0xaf2: 0x17a0, 0xaf3: 0x17a5, 0xaf4: 0x065b, 0xaf5: 0x17aa,
+	0xaf6: 0x115b, 0xaf7: 0x17af, 0xaf8: 0x1167, 0xaf9: 0x1173, 0xafa: 0x117b, 0xafb: 0x17b4,
+	0xafc: 0x17b9, 0xafd: 0x118f, 0xafe: 0x17be, 0xaff: 0x1197,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x16ce, 0xb01: 0x065f, 0xb02: 0x11af, 0xb03: 0x11b3, 0xb04: 0x0667, 0xb05: 0x11b7,
+	0xb06: 0x0a33, 0xb07: 0x17c3, 0xb08: 0x17c8, 0xb09: 0x16d3, 0xb0a: 0x16d8, 0xb0b: 0x11d7,
+	0xb0c: 0x11db, 0xb0d: 0x13f3, 0xb0e: 0x066b, 0xb0f: 0x1207, 0xb10: 0x1203, 0xb11: 0x120b,
+	0xb12: 0x083f, 0xb13: 0x120f, 0xb14: 0x1213, 0xb15: 0x1217, 0xb16: 0x121f, 0xb17: 0x17cd,
+	0xb18: 0x121b, 0xb19: 0x1223, 0xb1a: 0x1237, 0xb1b: 0x123b, 0xb1c: 0x1227, 0xb1d: 0x123f,
+	0xb1e: 0x1253, 0xb1f: 0x1267, 0xb20: 0x1233, 0xb21: 0x1247, 0xb22: 0x124b, 0xb23: 0x124f,
+	0xb24: 0x17d2, 0xb25: 0x17dc, 0xb26: 0x17d7, 0xb27: 0x066f, 0xb28: 0x126f, 0xb29: 0x1273,
+	0xb2a: 0x127b, 0xb2b: 0x17f0, 0xb2c: 0x127f, 0xb2d: 0x17e1, 0xb2e: 0x0673, 0xb2f: 0x0677,
+	0xb30: 0x17e6, 0xb31: 0x17eb, 0xb32: 0x067b, 0xb33: 0x129f, 0xb34: 0x12a3, 0xb35: 0x12a7,
+	0xb36: 0x12ab, 0xb37: 0x12b7, 0xb38: 0x12b3, 0xb39: 0x12bf, 0xb3a: 0x12bb, 0xb3b: 0x12cb,
+	0xb3c: 0x12c3, 0xb3d: 0x12c7, 0xb3e: 0x12cf, 0xb3f: 0x067f,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x12d7, 0xb41: 0x12db, 0xb42: 0x0683, 0xb43: 0x12eb, 0xb44: 0x12ef, 0xb45: 0x17f5,
+	0xb46: 0x12fb, 0xb47: 0x12ff, 0xb48: 0x0687, 0xb49: 0x130b, 0xb4a: 0x05bb, 0xb4b: 0x17fa,
+	0xb4c: 0x17ff, 0xb4d: 0x068b, 0xb4e: 0x068f, 0xb4f: 0x1337, 0xb50: 0x134f, 0xb51: 0x136b,
+	0xb52: 0x137b, 0xb53: 0x1804, 0xb54: 0x138f, 0xb55: 0x1393, 0xb56: 0x13ab, 0xb57: 0x13b7,
+	0xb58: 0x180e, 0xb59: 0x1660, 0xb5a: 0x13c3, 0xb5b: 0x13bf, 0xb5c: 0x13cb, 0xb5d: 0x1665,
+	0xb5e: 0x13d7, 0xb5f: 0x13e3, 0xb60: 0x1813, 0xb61: 0x1818, 0xb62: 0x1423, 0xb63: 0x142f,
+	0xb64: 0x1437, 0xb65: 0x181d, 0xb66: 0x143b, 0xb67: 0x1467, 0xb68: 0x1473, 0xb69: 0x1477,
+	0xb6a: 0x146f, 0xb6b: 0x1483, 0xb6c: 0x1487, 0xb6d: 0x1822, 0xb6e: 0x1493, 0xb6f: 0x0693,
+	0xb70: 0x149b, 0xb71: 0x1827, 0xb72: 0x0697, 0xb73: 0x14d3, 0xb74: 0x0ac3, 0xb75: 0x14eb,
+	0xb76: 0x182c, 0xb77: 0x1836, 0xb78: 0x069b, 0xb79: 0x069f, 0xb7a: 0x1513, 0xb7b: 0x183b,
+	0xb7c: 0x06a3, 0xb7d: 0x1840, 0xb7e: 0x152b, 0xb7f: 0x152b,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x1533, 0xb81: 0x1845, 0xb82: 0x154b, 0xb83: 0x06a7, 0xb84: 0x155b, 0xb85: 0x1567,
+	0xb86: 0x156f, 0xb87: 0x1577, 0xb88: 0x06ab, 0xb89: 0x184a, 0xb8a: 0x158b, 0xb8b: 0x15a7,
+	0xb8c: 0x15b3, 0xb8d: 0x06af, 0xb8e: 0x06b3, 0xb8f: 0x15b7, 0xb90: 0x184f, 0xb91: 0x06b7,
+	0xb92: 0x1854, 0xb93: 0x1859, 0xb94: 0x185e, 0xb95: 0x15db, 0xb96: 0x06bb, 0xb97: 0x15ef,
+	0xb98: 0x15f7, 0xb99: 0x15fb, 0xb9a: 0x1603, 0xb9b: 0x160b, 0xb9c: 0x1613, 0xb9d: 0x1868,
+}
+
+// nfcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x2d, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x2e, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x2f, 0xcb: 0x30, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x31,
+	0xd0: 0x09, 0xd1: 0x32, 0xd2: 0x33, 0xd3: 0x0a, 0xd6: 0x0b, 0xd7: 0x34,
+	0xd8: 0x35, 0xd9: 0x0c, 0xdb: 0x36, 0xdc: 0x37, 0xdd: 0x38, 0xdf: 0x39,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x3a, 0x121: 0x3b, 0x123: 0x3c, 0x124: 0x3d, 0x125: 0x3e, 0x126: 0x3f, 0x127: 0x40,
+	0x128: 0x41, 0x129: 0x42, 0x12a: 0x43, 0x12b: 0x44, 0x12c: 0x3f, 0x12d: 0x45, 0x12e: 0x46, 0x12f: 0x47,
+	0x131: 0x48, 0x132: 0x49, 0x133: 0x4a, 0x134: 0x4b, 0x135: 0x4c, 0x137: 0x4d,
+	0x138: 0x4e, 0x139: 0x4f, 0x13a: 0x50, 0x13b: 0x51, 0x13c: 0x52, 0x13d: 0x53, 0x13e: 0x54, 0x13f: 0x55,
+	// Block 0x5, offset 0x140
+	0x140: 0x56, 0x142: 0x57, 0x144: 0x58, 0x145: 0x59, 0x146: 0x5a, 0x147: 0x5b,
+	0x14d: 0x5c,
+	0x15c: 0x5d, 0x15f: 0x5e,
+	0x162: 0x5f, 0x164: 0x60,
+	0x168: 0x61, 0x169: 0x62, 0x16a: 0x63, 0x16c: 0x0d, 0x16d: 0x64, 0x16e: 0x65, 0x16f: 0x66,
+	0x170: 0x67, 0x173: 0x68, 0x177: 0x0e,
+	0x178: 0x0f, 0x179: 0x10, 0x17a: 0x11, 0x17b: 0x12, 0x17c: 0x13, 0x17d: 0x14, 0x17e: 0x15, 0x17f: 0x16,
+	// Block 0x6, offset 0x180
+	0x180: 0x69, 0x183: 0x6a, 0x184: 0x6b, 0x186: 0x6c, 0x187: 0x6d,
+	0x188: 0x6e, 0x189: 0x17, 0x18a: 0x18, 0x18b: 0x6f, 0x18c: 0x70,
+	0x1ab: 0x71,
+	0x1b3: 0x72, 0x1b5: 0x73, 0x1b7: 0x74,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x75, 0x1c1: 0x19, 0x1c2: 0x1a, 0x1c3: 0x1b, 0x1c4: 0x76, 0x1c5: 0x77,
+	0x1c9: 0x78, 0x1cc: 0x79, 0x1cd: 0x7a,
+	// Block 0x8, offset 0x200
+	0x219: 0x7b, 0x21a: 0x7c, 0x21b: 0x7d,
+	0x220: 0x7e, 0x223: 0x7f, 0x224: 0x80, 0x225: 0x81, 0x226: 0x82, 0x227: 0x83,
+	0x22a: 0x84, 0x22b: 0x85, 0x22f: 0x86,
+	0x230: 0x87, 0x231: 0x88, 0x232: 0x89, 0x233: 0x8a, 0x234: 0x8b, 0x235: 0x8c, 0x236: 0x8d, 0x237: 0x87,
+	0x238: 0x88, 0x239: 0x89, 0x23a: 0x8a, 0x23b: 0x8b, 0x23c: 0x8c, 0x23d: 0x8d, 0x23e: 0x87, 0x23f: 0x88,
+	// Block 0x9, offset 0x240
+	0x240: 0x89, 0x241: 0x8a, 0x242: 0x8b, 0x243: 0x8c, 0x244: 0x8d, 0x245: 0x87, 0x246: 0x88, 0x247: 0x89,
+	0x248: 0x8a, 0x249: 0x8b, 0x24a: 0x8c, 0x24b: 0x8d, 0x24c: 0x87, 0x24d: 0x88, 0x24e: 0x89, 0x24f: 0x8a,
+	0x250: 0x8b, 0x251: 0x8c, 0x252: 0x8d, 0x253: 0x87, 0x254: 0x88, 0x255: 0x89, 0x256: 0x8a, 0x257: 0x8b,
+	0x258: 0x8c, 0x259: 0x8d, 0x25a: 0x87, 0x25b: 0x88, 0x25c: 0x89, 0x25d: 0x8a, 0x25e: 0x8b, 0x25f: 0x8c,
+	0x260: 0x8d, 0x261: 0x87, 0x262: 0x88, 0x263: 0x89, 0x264: 0x8a, 0x265: 0x8b, 0x266: 0x8c, 0x267: 0x8d,
+	0x268: 0x87, 0x269: 0x88, 0x26a: 0x89, 0x26b: 0x8a, 0x26c: 0x8b, 0x26d: 0x8c, 0x26e: 0x8d, 0x26f: 0x87,
+	0x270: 0x88, 0x271: 0x89, 0x272: 0x8a, 0x273: 0x8b, 0x274: 0x8c, 0x275: 0x8d, 0x276: 0x87, 0x277: 0x88,
+	0x278: 0x89, 0x279: 0x8a, 0x27a: 0x8b, 0x27b: 0x8c, 0x27c: 0x8d, 0x27d: 0x87, 0x27e: 0x88, 0x27f: 0x89,
+	// Block 0xa, offset 0x280
+	0x280: 0x8a, 0x281: 0x8b, 0x282: 0x8c, 0x283: 0x8d, 0x284: 0x87, 0x285: 0x88, 0x286: 0x89, 0x287: 0x8a,
+	0x288: 0x8b, 0x289: 0x8c, 0x28a: 0x8d, 0x28b: 0x87, 0x28c: 0x88, 0x28d: 0x89, 0x28e: 0x8a, 0x28f: 0x8b,
+	0x290: 0x8c, 0x291: 0x8d, 0x292: 0x87, 0x293: 0x88, 0x294: 0x89, 0x295: 0x8a, 0x296: 0x8b, 0x297: 0x8c,
+	0x298: 0x8d, 0x299: 0x87, 0x29a: 0x88, 0x29b: 0x89, 0x29c: 0x8a, 0x29d: 0x8b, 0x29e: 0x8c, 0x29f: 0x8d,
+	0x2a0: 0x87, 0x2a1: 0x88, 0x2a2: 0x89, 0x2a3: 0x8a, 0x2a4: 0x8b, 0x2a5: 0x8c, 0x2a6: 0x8d, 0x2a7: 0x87,
+	0x2a8: 0x88, 0x2a9: 0x89, 0x2aa: 0x8a, 0x2ab: 0x8b, 0x2ac: 0x8c, 0x2ad: 0x8d, 0x2ae: 0x87, 0x2af: 0x88,
+	0x2b0: 0x89, 0x2b1: 0x8a, 0x2b2: 0x8b, 0x2b3: 0x8c, 0x2b4: 0x8d, 0x2b5: 0x87, 0x2b6: 0x88, 0x2b7: 0x89,
+	0x2b8: 0x8a, 0x2b9: 0x8b, 0x2ba: 0x8c, 0x2bb: 0x8d, 0x2bc: 0x87, 0x2bd: 0x88, 0x2be: 0x89, 0x2bf: 0x8a,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x8b, 0x2c1: 0x8c, 0x2c2: 0x8d, 0x2c3: 0x87, 0x2c4: 0x88, 0x2c5: 0x89, 0x2c6: 0x8a, 0x2c7: 0x8b,
+	0x2c8: 0x8c, 0x2c9: 0x8d, 0x2ca: 0x87, 0x2cb: 0x88, 0x2cc: 0x89, 0x2cd: 0x8a, 0x2ce: 0x8b, 0x2cf: 0x8c,
+	0x2d0: 0x8d, 0x2d1: 0x87, 0x2d2: 0x88, 0x2d3: 0x89, 0x2d4: 0x8a, 0x2d5: 0x8b, 0x2d6: 0x8c, 0x2d7: 0x8d,
+	0x2d8: 0x87, 0x2d9: 0x88, 0x2da: 0x89, 0x2db: 0x8a, 0x2dc: 0x8b, 0x2dd: 0x8c, 0x2de: 0x8e,
+	// Block 0xc, offset 0x300
+	0x324: 0x1c, 0x325: 0x1d, 0x326: 0x1e, 0x327: 0x1f,
+	0x328: 0x20, 0x329: 0x21, 0x32a: 0x22, 0x32b: 0x23, 0x32c: 0x8f, 0x32d: 0x90, 0x32e: 0x91,
+	0x331: 0x92, 0x332: 0x93, 0x333: 0x94, 0x334: 0x95,
+	0x338: 0x96, 0x339: 0x97, 0x33a: 0x98, 0x33b: 0x99, 0x33e: 0x9a, 0x33f: 0x9b,
+	// Block 0xd, offset 0x340
+	0x347: 0x9c,
+	0x34b: 0x9d, 0x34d: 0x9e,
+	0x368: 0x9f, 0x36b: 0xa0,
+	// Block 0xe, offset 0x380
+	0x381: 0xa1, 0x382: 0xa2, 0x384: 0xa3, 0x385: 0x82, 0x387: 0xa4,
+	0x388: 0xa5, 0x38b: 0xa6, 0x38c: 0x3f, 0x38d: 0xa7,
+	0x391: 0xa8, 0x392: 0xa9, 0x393: 0xaa, 0x396: 0xab, 0x397: 0xac,
+	0x398: 0x73, 0x39a: 0xad, 0x39c: 0xae,
+	0x3a8: 0xaf, 0x3a9: 0xb0, 0x3aa: 0xb1,
+	0x3b0: 0x73, 0x3b5: 0xb2,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xb3, 0x3ec: 0xb4,
+	// Block 0x10, offset 0x400
+	0x432: 0xb5,
+	// Block 0x11, offset 0x440
+	0x445: 0xb6, 0x446: 0xb7, 0x447: 0xb8,
+	0x449: 0xb9,
+	// Block 0x12, offset 0x480
+	0x480: 0xba,
+	0x4a3: 0xbb, 0x4a5: 0xbc,
+	// Block 0x13, offset 0x4c0
+	0x4c8: 0xbd,
+	// Block 0x14, offset 0x500
+	0x520: 0x24, 0x521: 0x25, 0x522: 0x26, 0x523: 0x27, 0x524: 0x28, 0x525: 0x29, 0x526: 0x2a, 0x527: 0x2b,
+	0x528: 0x2c,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfcSparseOffset: 145 entries, 290 bytes
+var nfcSparseOffset = []uint16{0x0, 0x5, 0x9, 0xb, 0xd, 0x18, 0x28, 0x2a, 0x2f, 0x3a, 0x49, 0x56, 0x5e, 0x62, 0x67, 0x69, 0x7a, 0x82, 0x89, 0x8c, 0x93, 0x97, 0x9b, 0x9d, 0x9f, 0xa8, 0xac, 0xb3, 0xb8, 0xbb, 0xc5, 0xc8, 0xcf, 0xd7, 0xda, 0xdc, 0xde, 0xe0, 0xe5, 0xf6, 0x102, 0x104, 0x10a, 0x10c, 0x10e, 0x110, 0x112, 0x114, 0x116, 0x119, 0x11c, 0x11e, 0x121, 0x124, 0x128, 0x12d, 0x136, 0x138, 0x13b, 0x13d, 0x148, 0x14c, 0x15a, 0x15d, 0x163, 0x169, 0x174, 0x178, 0x17a, 0x17c, 0x17e, 0x180, 0x182, 0x188, 0x18c, 0x18e, 0x190, 0x198, 0x19c, 0x19f, 0x1a1, 0x1a3, 0x1a5, 0x1a8, 0x1aa, 0x1ac, 0x1ae, 0x1b0, 0x1b6, 0x1b9, 0x1bb, 0x1c2, 0x1c8, 0x1ce, 0x1d6, 0x1dc, 0x1e2, 0x1e8, 0x1ec, 0x1fa, 0x203, 0x206, 0x209, 0x20b, 0x20e, 0x210, 0x214, 0x219, 0x21b, 0x21d, 0x222, 0x228, 0x22a, 0x22c, 0x22e, 0x234, 0x237, 0x23a, 0x242, 0x249, 0x24c, 0x24f, 0x251, 0x259, 0x25c, 0x263, 0x266, 0x26c, 0x26e, 0x271, 0x273, 0x275, 0x277, 0x279, 0x27c, 0x27e, 0x280, 0x282, 0x28f, 0x299, 0x29b, 0x29d, 0x2a3, 0x2a5, 0x2a8}
+
+// nfcSparseValues: 682 entries, 2728 bytes
+var nfcSparseValues = [682]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0000, lo: 0x04},
+	{value: 0xa100, lo: 0xa8, hi: 0xa8},
+	{value: 0x8100, lo: 0xaf, hi: 0xaf},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb8, hi: 0xb8},
+	// Block 0x1, offset 0x5
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x9
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	// Block 0x3, offset 0xb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x98, hi: 0x9d},
+	// Block 0x4, offset 0xd
+	{value: 0x0006, lo: 0x0a},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x85, hi: 0x85},
+	{value: 0xa000, lo: 0x89, hi: 0x89},
+	{value: 0x4840, lo: 0x8a, hi: 0x8a},
+	{value: 0x485e, lo: 0x8b, hi: 0x8b},
+	{value: 0x36c7, lo: 0x8c, hi: 0x8c},
+	{value: 0x36df, lo: 0x8d, hi: 0x8d},
+	{value: 0x4876, lo: 0x8e, hi: 0x8e},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x36fd, lo: 0x93, hi: 0x94},
+	// Block 0x5, offset 0x18
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x6, offset 0x28
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x7, offset 0x2a
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x8, offset 0x2f
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x9, offset 0x3a
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0xa, offset 0x49
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xb, offset 0x56
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xc, offset 0x5e
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xd, offset 0x62
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xe, offset 0x67
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xf, offset 0x69
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0x10, offset 0x7a
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x11, offset 0x82
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x12, offset 0x89
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x13, offset 0x8c
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x14, offset 0x93
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x15, offset 0x97
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x16, offset 0x9b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x17, offset 0x9d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x18, offset 0x9f
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x19, offset 0xa8
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1a, offset 0xac
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1b, offset 0xb3
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1c, offset 0xb8
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1d, offset 0xbb
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1e, offset 0xc5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xbb, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1f, offset 0xc8
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x20, offset 0xcf
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x21, offset 0xd7
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x22, offset 0xda
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x23, offset 0xdc
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x24, offset 0xde
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	// Block 0x25, offset 0xe0
+	{value: 0x0000, lo: 0x04},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x26, offset 0xe5
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x8200, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x8200, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x27, offset 0xf6
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x28, offset 0x102
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x29, offset 0x104
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x2a, offset 0x10a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2b, offset 0x10c
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x10e
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x110
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x112
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x114
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x116
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x119
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x11c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x11e
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x121
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x124
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x128
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x12d
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x136
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x138
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x13b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x13d
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x148
+	{value: 0x0004, lo: 0x03},
+	{value: 0x0433, lo: 0x80, hi: 0x81},
+	{value: 0x8100, lo: 0x97, hi: 0x97},
+	{value: 0x8100, lo: 0xbe, hi: 0xbe},
+	// Block 0x3d, offset 0x14c
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x3e, offset 0x15a
+	{value: 0x427b, lo: 0x02},
+	{value: 0x01b8, lo: 0xa6, hi: 0xa6},
+	{value: 0x0057, lo: 0xaa, hi: 0xab},
+	// Block 0x3f, offset 0x15d
+	{value: 0x0007, lo: 0x05},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x40, offset 0x163
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x41, offset 0x169
+	{value: 0x6408, lo: 0x0a},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x42, offset 0x174
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x43, offset 0x178
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x44, offset 0x17a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x45, offset 0x17c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x46, offset 0x17e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x47, offset 0x180
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x48, offset 0x182
+	{value: 0x0000, lo: 0x05},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xaf},
+	// Block 0x49, offset 0x188
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4a9f, lo: 0xb3, hi: 0xb3},
+	{value: 0x4a9f, lo: 0xb5, hi: 0xb6},
+	{value: 0x4a9f, lo: 0xba, hi: 0xbf},
+	// Block 0x4a, offset 0x18c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x4a9f, lo: 0x8f, hi: 0xa3},
+	// Block 0x4b, offset 0x18e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xae, hi: 0xbe},
+	// Block 0x4c, offset 0x190
+	{value: 0x0000, lo: 0x07},
+	{value: 0x8100, lo: 0x84, hi: 0x84},
+	{value: 0x8100, lo: 0x87, hi: 0x87},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	{value: 0x8100, lo: 0x9e, hi: 0x9e},
+	{value: 0x8100, lo: 0xa1, hi: 0xa1},
+	{value: 0x8100, lo: 0xb2, hi: 0xb2},
+	{value: 0x8100, lo: 0xbb, hi: 0xbb},
+	// Block 0x4d, offset 0x198
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8100, lo: 0x80, hi: 0x80},
+	{value: 0x8100, lo: 0x8b, hi: 0x8b},
+	{value: 0x8100, lo: 0x8e, hi: 0x8e},
+	// Block 0x4e, offset 0x19c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x4f, offset 0x19f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x50, offset 0x1a1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x51, offset 0x1a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x52, offset 0x1a5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x53, offset 0x1a8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x54, offset 0x1aa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x55, offset 0x1ac
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x56, offset 0x1ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x57, offset 0x1b0
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x58, offset 0x1b6
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x59, offset 0x1b9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x5a, offset 0x1bb
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x5b, offset 0x1c2
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x5c, offset 0x1c8
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x5d, offset 0x1ce
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x5e, offset 0x1d6
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x5f, offset 0x1dc
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x60, offset 0x1e2
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x61, offset 0x1e8
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x62, offset 0x1ec
+	{value: 0x0006, lo: 0x0d},
+	{value: 0x4390, lo: 0x9d, hi: 0x9d},
+	{value: 0x8115, lo: 0x9e, hi: 0x9e},
+	{value: 0x4402, lo: 0x9f, hi: 0x9f},
+	{value: 0x43f0, lo: 0xaa, hi: 0xab},
+	{value: 0x44f4, lo: 0xac, hi: 0xac},
+	{value: 0x44fc, lo: 0xad, hi: 0xad},
+	{value: 0x4348, lo: 0xae, hi: 0xb1},
+	{value: 0x4366, lo: 0xb2, hi: 0xb4},
+	{value: 0x437e, lo: 0xb5, hi: 0xb6},
+	{value: 0x438a, lo: 0xb8, hi: 0xb8},
+	{value: 0x4396, lo: 0xb9, hi: 0xbb},
+	{value: 0x43ae, lo: 0xbc, hi: 0xbc},
+	{value: 0x43b4, lo: 0xbe, hi: 0xbe},
+	// Block 0x63, offset 0x1fa
+	{value: 0x0006, lo: 0x08},
+	{value: 0x43ba, lo: 0x80, hi: 0x81},
+	{value: 0x43c6, lo: 0x83, hi: 0x84},
+	{value: 0x43d8, lo: 0x86, hi: 0x89},
+	{value: 0x43fc, lo: 0x8a, hi: 0x8a},
+	{value: 0x4378, lo: 0x8b, hi: 0x8b},
+	{value: 0x4360, lo: 0x8c, hi: 0x8c},
+	{value: 0x43a8, lo: 0x8d, hi: 0x8d},
+	{value: 0x43d2, lo: 0x8e, hi: 0x8e},
+	// Block 0x64, offset 0x203
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0xa4, hi: 0xa5},
+	{value: 0x8100, lo: 0xb0, hi: 0xb1},
+	// Block 0x65, offset 0x206
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x9b, hi: 0x9d},
+	{value: 0x8200, lo: 0x9e, hi: 0xa3},
+	// Block 0x66, offset 0x209
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	// Block 0x67, offset 0x20b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x99, hi: 0x99},
+	{value: 0x8200, lo: 0xb2, hi: 0xb4},
+	// Block 0x68, offset 0x20e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xbc, hi: 0xbd},
+	// Block 0x69, offset 0x210
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xa0, hi: 0xa6},
+	{value: 0x812d, lo: 0xa7, hi: 0xad},
+	{value: 0x8132, lo: 0xae, hi: 0xaf},
+	// Block 0x6a, offset 0x214
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8100, lo: 0x89, hi: 0x8c},
+	{value: 0x8100, lo: 0xb0, hi: 0xb2},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb6, hi: 0xbf},
+	// Block 0x6b, offset 0x219
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x81, hi: 0x8c},
+	// Block 0x6c, offset 0x21b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xb5, hi: 0xba},
+	// Block 0x6d, offset 0x21d
+	{value: 0x0000, lo: 0x04},
+	{value: 0x4a9f, lo: 0x9e, hi: 0x9f},
+	{value: 0x4a9f, lo: 0xa3, hi: 0xa3},
+	{value: 0x4a9f, lo: 0xa5, hi: 0xa6},
+	{value: 0x4a9f, lo: 0xaa, hi: 0xaf},
+	// Block 0x6e, offset 0x222
+	{value: 0x0000, lo: 0x05},
+	{value: 0x4a9f, lo: 0x82, hi: 0x87},
+	{value: 0x4a9f, lo: 0x8a, hi: 0x8f},
+	{value: 0x4a9f, lo: 0x92, hi: 0x97},
+	{value: 0x4a9f, lo: 0x9a, hi: 0x9c},
+	{value: 0x8100, lo: 0xa3, hi: 0xa3},
+	// Block 0x6f, offset 0x228
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x70, offset 0x22a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x71, offset 0x22c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x72, offset 0x22e
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x73, offset 0x234
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x74, offset 0x237
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x75, offset 0x23a
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x76, offset 0x242
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x77, offset 0x249
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x78, offset 0x24c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x79, offset 0x24f
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x7a, offset 0x251
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x7b, offset 0x259
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x7c, offset 0x25c
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x7d, offset 0x263
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7e, offset 0x266
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7f, offset 0x26c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x80, offset 0x26e
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x81, offset 0x271
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x82, offset 0x273
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x83, offset 0x275
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x87, hi: 0x87},
+	// Block 0x84, offset 0x277
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x99, hi: 0x99},
+	// Block 0x85, offset 0x279
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0x82, hi: 0x82},
+	{value: 0x8104, lo: 0x84, hi: 0x85},
+	// Block 0x86, offset 0x27c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x87, offset 0x27e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x88, offset 0x280
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x89, offset 0x282
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x8a, offset 0x28f
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x8b, offset 0x299
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x8c, offset 0x29b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x8d, offset 0x29d
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x8e, offset 0x2a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x8f, offset 0x2a5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x90, offset 0x2a8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x93, hi: 0x93},
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfkcTrie. Total size: 17104 bytes (16.70 KiB). Checksum: d985061cf5307b35.
+type nfkcTrie struct{}
+
+func newNfkcTrie(i int) *nfkcTrie {
+	return &nfkcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfkcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 91:
+		return uint16(nfkcValues[n<<6+uint32(b)])
+	default:
+		n -= 91
+		return uint16(nfkcSparse.lookup(n, b))
+	}
+}
+
+// nfkcValues: 93 blocks, 5952 entries, 11904 bytes
+// The third block is the zero block.
+var nfkcValues = [5952]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x132: 0x195d, 0x133: 0x19e7, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8, 0x13f: 0x1bac,
+	// Block 0x5, offset 0x140
+	0x140: 0x1c34, 0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f, 0x149: 0x1c5c,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0x00a7,
+	// Block 0x6, offset 0x180
+	0x184: 0x2dee, 0x185: 0x2df4,
+	0x186: 0x2dfa, 0x187: 0x1972, 0x188: 0x1975, 0x189: 0x1a08, 0x18a: 0x1987, 0x18b: 0x198a,
+	0x18c: 0x1a3e, 0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b1: 0x1942, 0x1b2: 0x1945, 0x1b3: 0x19cf, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x42a5,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x425a, 0x285: 0x447b,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c1: 0xa000, 0x2c5: 0xa000,
+	0x2c9: 0xa000, 0x2ca: 0x4840, 0x2cb: 0x485e,
+	0x2cc: 0x36c7, 0x2cd: 0x36df, 0x2ce: 0x4876, 0x2d0: 0x01be, 0x2d1: 0x01d0,
+	0x2d2: 0x01ac, 0x2d3: 0x430c, 0x2d4: 0x4312, 0x2d5: 0x01fa, 0x2d6: 0x01e8,
+	0x2f0: 0x01d6, 0x2f1: 0x01eb, 0x2f2: 0x01ee, 0x2f4: 0x0188, 0x2f5: 0x01c7,
+	0x2f9: 0x01a6,
+	// Block 0xc, offset 0x300
+	0x300: 0x3721, 0x301: 0x372d, 0x303: 0x371b,
+	0x306: 0xa000, 0x307: 0x3709,
+	0x30c: 0x375d, 0x30d: 0x3745, 0x30e: 0x376f, 0x310: 0xa000,
+	0x313: 0xa000, 0x315: 0xa000, 0x316: 0xa000, 0x317: 0xa000,
+	0x318: 0xa000, 0x319: 0x3751, 0x31a: 0xa000,
+	0x31e: 0xa000, 0x323: 0xa000,
+	0x327: 0xa000,
+	0x32b: 0xa000, 0x32d: 0xa000,
+	0x330: 0xa000, 0x333: 0xa000, 0x335: 0xa000,
+	0x336: 0xa000, 0x337: 0xa000, 0x338: 0xa000, 0x339: 0x37d5, 0x33a: 0xa000,
+	0x33e: 0xa000,
+	// Block 0xd, offset 0x340
+	0x341: 0x3733, 0x342: 0x37b7,
+	0x350: 0x370f, 0x351: 0x3793,
+	0x352: 0x3715, 0x353: 0x3799, 0x356: 0x3727, 0x357: 0x37ab,
+	0x358: 0xa000, 0x359: 0xa000, 0x35a: 0x3829, 0x35b: 0x382f, 0x35c: 0x3739, 0x35d: 0x37bd,
+	0x35e: 0x373f, 0x35f: 0x37c3, 0x362: 0x374b, 0x363: 0x37cf,
+	0x364: 0x3757, 0x365: 0x37db, 0x366: 0x3763, 0x367: 0x37e7, 0x368: 0xa000, 0x369: 0xa000,
+	0x36a: 0x3835, 0x36b: 0x383b, 0x36c: 0x378d, 0x36d: 0x3811, 0x36e: 0x3769, 0x36f: 0x37ed,
+	0x370: 0x3775, 0x371: 0x37f9, 0x372: 0x377b, 0x373: 0x37ff, 0x374: 0x3781, 0x375: 0x3805,
+	0x378: 0x3787, 0x379: 0x380b,
+	// Block 0xe, offset 0x380
+	0x387: 0x1d61,
+	0x391: 0x812d,
+	0x392: 0x8132, 0x393: 0x8132, 0x394: 0x8132, 0x395: 0x8132, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x812e, 0x39b: 0x812d, 0x39c: 0x8132, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x8132, 0x3a0: 0x8132, 0x3a1: 0x8132, 0x3a2: 0x812d, 0x3a3: 0x812d,
+	0x3a4: 0x812d, 0x3a5: 0x812d, 0x3a6: 0x812d, 0x3a7: 0x812d, 0x3a8: 0x8132, 0x3a9: 0x8132,
+	0x3aa: 0x812d, 0x3ab: 0x8132, 0x3ac: 0x8132, 0x3ad: 0x812e, 0x3ae: 0x8131, 0x3af: 0x8132,
+	0x3b0: 0x8105, 0x3b1: 0x8106, 0x3b2: 0x8107, 0x3b3: 0x8108, 0x3b4: 0x8109, 0x3b5: 0x810a,
+	0x3b6: 0x810b, 0x3b7: 0x810c, 0x3b8: 0x810d, 0x3b9: 0x810e, 0x3ba: 0x810e, 0x3bb: 0x810f,
+	0x3bc: 0x8110, 0x3bd: 0x8111, 0x3bf: 0x8112,
+	// Block 0xf, offset 0x3c0
+	0x3c8: 0xa000, 0x3ca: 0xa000, 0x3cb: 0x8116,
+	0x3cc: 0x8117, 0x3cd: 0x8118, 0x3ce: 0x8119, 0x3cf: 0x811a, 0x3d0: 0x811b, 0x3d1: 0x811c,
+	0x3d2: 0x811d, 0x3d3: 0x9932, 0x3d4: 0x9932, 0x3d5: 0x992d, 0x3d6: 0x812d, 0x3d7: 0x8132,
+	0x3d8: 0x8132, 0x3d9: 0x8132, 0x3da: 0x8132, 0x3db: 0x8132, 0x3dc: 0x812d, 0x3dd: 0x8132,
+	0x3de: 0x8132, 0x3df: 0x812d,
+	0x3f0: 0x811e, 0x3f5: 0x1d84,
+	0x3f6: 0x2013, 0x3f7: 0x204f, 0x3f8: 0x204a,
+	// Block 0x10, offset 0x400
+	0x405: 0xa000,
+	0x406: 0x2d26, 0x407: 0xa000, 0x408: 0x2d2e, 0x409: 0xa000, 0x40a: 0x2d36, 0x40b: 0xa000,
+	0x40c: 0x2d3e, 0x40d: 0xa000, 0x40e: 0x2d46, 0x411: 0xa000,
+	0x412: 0x2d4e,
+	0x434: 0x8102, 0x435: 0x9900,
+	0x43a: 0xa000, 0x43b: 0x2d56,
+	0x43c: 0xa000, 0x43d: 0x2d5e, 0x43e: 0xa000, 0x43f: 0xa000,
+	// Block 0x11, offset 0x440
+	0x440: 0x0069, 0x441: 0x006b, 0x442: 0x006f, 0x443: 0x0083, 0x444: 0x00f5, 0x445: 0x00f8,
+	0x446: 0x0413, 0x447: 0x0085, 0x448: 0x0089, 0x449: 0x008b, 0x44a: 0x0104, 0x44b: 0x0107,
+	0x44c: 0x010a, 0x44d: 0x008f, 0x44f: 0x0097, 0x450: 0x009b, 0x451: 0x00e0,
+	0x452: 0x009f, 0x453: 0x00fe, 0x454: 0x0417, 0x455: 0x041b, 0x456: 0x00a1, 0x457: 0x00a9,
+	0x458: 0x00ab, 0x459: 0x0423, 0x45a: 0x012b, 0x45b: 0x00ad, 0x45c: 0x0427, 0x45d: 0x01be,
+	0x45e: 0x01c1, 0x45f: 0x01c4, 0x460: 0x01fa, 0x461: 0x01fd, 0x462: 0x0093, 0x463: 0x00a5,
+	0x464: 0x00ab, 0x465: 0x00ad, 0x466: 0x01be, 0x467: 0x01c1, 0x468: 0x01eb, 0x469: 0x01fa,
+	0x46a: 0x01fd,
+	0x478: 0x020c,
+	// Block 0x12, offset 0x480
+	0x49b: 0x00fb, 0x49c: 0x0087, 0x49d: 0x0101,
+	0x49e: 0x00d4, 0x49f: 0x010a, 0x4a0: 0x008d, 0x4a1: 0x010d, 0x4a2: 0x0110, 0x4a3: 0x0116,
+	0x4a4: 0x011c, 0x4a5: 0x011f, 0x4a6: 0x0122, 0x4a7: 0x042b, 0x4a8: 0x016a, 0x4a9: 0x0128,
+	0x4aa: 0x042f, 0x4ab: 0x016d, 0x4ac: 0x0131, 0x4ad: 0x012e, 0x4ae: 0x0134, 0x4af: 0x0137,
+	0x4b0: 0x013a, 0x4b1: 0x013d, 0x4b2: 0x0140, 0x4b3: 0x014c, 0x4b4: 0x014f, 0x4b5: 0x00ec,
+	0x4b6: 0x0152, 0x4b7: 0x0155, 0x4b8: 0x041f, 0x4b9: 0x0158, 0x4ba: 0x015b, 0x4bb: 0x00b5,
+	0x4bc: 0x015e, 0x4bd: 0x0161, 0x4be: 0x0164, 0x4bf: 0x01d0,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x8132, 0x4c1: 0x8132, 0x4c2: 0x812d, 0x4c3: 0x8132, 0x4c4: 0x8132, 0x4c5: 0x8132,
+	0x4c6: 0x8132, 0x4c7: 0x8132, 0x4c8: 0x8132, 0x4c9: 0x8132, 0x4ca: 0x812d, 0x4cb: 0x8132,
+	0x4cc: 0x8132, 0x4cd: 0x8135, 0x4ce: 0x812a, 0x4cf: 0x812d, 0x4d0: 0x8129, 0x4d1: 0x8132,
+	0x4d2: 0x8132, 0x4d3: 0x8132, 0x4d4: 0x8132, 0x4d5: 0x8132, 0x4d6: 0x8132, 0x4d7: 0x8132,
+	0x4d8: 0x8132, 0x4d9: 0x8132, 0x4da: 0x8132, 0x4db: 0x8132, 0x4dc: 0x8132, 0x4dd: 0x8132,
+	0x4de: 0x8132, 0x4df: 0x8132, 0x4e0: 0x8132, 0x4e1: 0x8132, 0x4e2: 0x8132, 0x4e3: 0x8132,
+	0x4e4: 0x8132, 0x4e5: 0x8132, 0x4e6: 0x8132, 0x4e7: 0x8132, 0x4e8: 0x8132, 0x4e9: 0x8132,
+	0x4ea: 0x8132, 0x4eb: 0x8132, 0x4ec: 0x8132, 0x4ed: 0x8132, 0x4ee: 0x8132, 0x4ef: 0x8132,
+	0x4f0: 0x8132, 0x4f1: 0x8132, 0x4f2: 0x8132, 0x4f3: 0x8132, 0x4f4: 0x8132, 0x4f5: 0x8132,
+	0x4f6: 0x8133, 0x4f7: 0x8131, 0x4f8: 0x8131, 0x4f9: 0x812d, 0x4fb: 0x8132,
+	0x4fc: 0x8134, 0x4fd: 0x812d, 0x4fe: 0x8132, 0x4ff: 0x812d,
+	// Block 0x14, offset 0x500
+	0x500: 0x2f97, 0x501: 0x32a3, 0x502: 0x2fa1, 0x503: 0x32ad, 0x504: 0x2fa6, 0x505: 0x32b2,
+	0x506: 0x2fab, 0x507: 0x32b7, 0x508: 0x38cc, 0x509: 0x3a5b, 0x50a: 0x2fc4, 0x50b: 0x32d0,
+	0x50c: 0x2fce, 0x50d: 0x32da, 0x50e: 0x2fdd, 0x50f: 0x32e9, 0x510: 0x2fd3, 0x511: 0x32df,
+	0x512: 0x2fd8, 0x513: 0x32e4, 0x514: 0x38ef, 0x515: 0x3a7e, 0x516: 0x38f6, 0x517: 0x3a85,
+	0x518: 0x3019, 0x519: 0x3325, 0x51a: 0x301e, 0x51b: 0x332a, 0x51c: 0x3904, 0x51d: 0x3a93,
+	0x51e: 0x3023, 0x51f: 0x332f, 0x520: 0x3032, 0x521: 0x333e, 0x522: 0x3050, 0x523: 0x335c,
+	0x524: 0x305f, 0x525: 0x336b, 0x526: 0x3055, 0x527: 0x3361, 0x528: 0x3064, 0x529: 0x3370,
+	0x52a: 0x3069, 0x52b: 0x3375, 0x52c: 0x30af, 0x52d: 0x33bb, 0x52e: 0x390b, 0x52f: 0x3a9a,
+	0x530: 0x30b9, 0x531: 0x33ca, 0x532: 0x30c3, 0x533: 0x33d4, 0x534: 0x30cd, 0x535: 0x33de,
+	0x536: 0x46c4, 0x537: 0x4755, 0x538: 0x3912, 0x539: 0x3aa1, 0x53a: 0x30e6, 0x53b: 0x33f7,
+	0x53c: 0x30e1, 0x53d: 0x33f2, 0x53e: 0x30eb, 0x53f: 0x33fc,
+	// Block 0x15, offset 0x540
+	0x540: 0x30f0, 0x541: 0x3401, 0x542: 0x30f5, 0x543: 0x3406, 0x544: 0x3109, 0x545: 0x341a,
+	0x546: 0x3113, 0x547: 0x3424, 0x548: 0x3122, 0x549: 0x3433, 0x54a: 0x311d, 0x54b: 0x342e,
+	0x54c: 0x3935, 0x54d: 0x3ac4, 0x54e: 0x3943, 0x54f: 0x3ad2, 0x550: 0x394a, 0x551: 0x3ad9,
+	0x552: 0x3951, 0x553: 0x3ae0, 0x554: 0x314f, 0x555: 0x3460, 0x556: 0x3154, 0x557: 0x3465,
+	0x558: 0x315e, 0x559: 0x346f, 0x55a: 0x46f1, 0x55b: 0x4782, 0x55c: 0x3997, 0x55d: 0x3b26,
+	0x55e: 0x3177, 0x55f: 0x3488, 0x560: 0x3181, 0x561: 0x3492, 0x562: 0x4700, 0x563: 0x4791,
+	0x564: 0x399e, 0x565: 0x3b2d, 0x566: 0x39a5, 0x567: 0x3b34, 0x568: 0x39ac, 0x569: 0x3b3b,
+	0x56a: 0x3190, 0x56b: 0x34a1, 0x56c: 0x319a, 0x56d: 0x34b0, 0x56e: 0x31ae, 0x56f: 0x34c4,
+	0x570: 0x31a9, 0x571: 0x34bf, 0x572: 0x31ea, 0x573: 0x3500, 0x574: 0x31f9, 0x575: 0x350f,
+	0x576: 0x31f4, 0x577: 0x350a, 0x578: 0x39b3, 0x579: 0x3b42, 0x57a: 0x39ba, 0x57b: 0x3b49,
+	0x57c: 0x31fe, 0x57d: 0x3514, 0x57e: 0x3203, 0x57f: 0x3519,
+	// Block 0x16, offset 0x580
+	0x580: 0x3208, 0x581: 0x351e, 0x582: 0x320d, 0x583: 0x3523, 0x584: 0x321c, 0x585: 0x3532,
+	0x586: 0x3217, 0x587: 0x352d, 0x588: 0x3221, 0x589: 0x353c, 0x58a: 0x3226, 0x58b: 0x3541,
+	0x58c: 0x322b, 0x58d: 0x3546, 0x58e: 0x3249, 0x58f: 0x3564, 0x590: 0x3262, 0x591: 0x3582,
+	0x592: 0x3271, 0x593: 0x3591, 0x594: 0x3276, 0x595: 0x3596, 0x596: 0x337a, 0x597: 0x34a6,
+	0x598: 0x3537, 0x599: 0x3573, 0x59a: 0x1be0, 0x59b: 0x42d7,
+	0x5a0: 0x46a1, 0x5a1: 0x4732, 0x5a2: 0x2f83, 0x5a3: 0x328f,
+	0x5a4: 0x3878, 0x5a5: 0x3a07, 0x5a6: 0x3871, 0x5a7: 0x3a00, 0x5a8: 0x3886, 0x5a9: 0x3a15,
+	0x5aa: 0x387f, 0x5ab: 0x3a0e, 0x5ac: 0x38be, 0x5ad: 0x3a4d, 0x5ae: 0x3894, 0x5af: 0x3a23,
+	0x5b0: 0x388d, 0x5b1: 0x3a1c, 0x5b2: 0x38a2, 0x5b3: 0x3a31, 0x5b4: 0x389b, 0x5b5: 0x3a2a,
+	0x5b6: 0x38c5, 0x5b7: 0x3a54, 0x5b8: 0x46b5, 0x5b9: 0x4746, 0x5ba: 0x3000, 0x5bb: 0x330c,
+	0x5bc: 0x2fec, 0x5bd: 0x32f8, 0x5be: 0x38da, 0x5bf: 0x3a69,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x38d3, 0x5c1: 0x3a62, 0x5c2: 0x38e8, 0x5c3: 0x3a77, 0x5c4: 0x38e1, 0x5c5: 0x3a70,
+	0x5c6: 0x38fd, 0x5c7: 0x3a8c, 0x5c8: 0x3091, 0x5c9: 0x339d, 0x5ca: 0x30a5, 0x5cb: 0x33b1,
+	0x5cc: 0x46e7, 0x5cd: 0x4778, 0x5ce: 0x3136, 0x5cf: 0x3447, 0x5d0: 0x3920, 0x5d1: 0x3aaf,
+	0x5d2: 0x3919, 0x5d3: 0x3aa8, 0x5d4: 0x392e, 0x5d5: 0x3abd, 0x5d6: 0x3927, 0x5d7: 0x3ab6,
+	0x5d8: 0x3989, 0x5d9: 0x3b18, 0x5da: 0x396d, 0x5db: 0x3afc, 0x5dc: 0x3966, 0x5dd: 0x3af5,
+	0x5de: 0x397b, 0x5df: 0x3b0a, 0x5e0: 0x3974, 0x5e1: 0x3b03, 0x5e2: 0x3982, 0x5e3: 0x3b11,
+	0x5e4: 0x31e5, 0x5e5: 0x34fb, 0x5e6: 0x31c7, 0x5e7: 0x34dd, 0x5e8: 0x39e4, 0x5e9: 0x3b73,
+	0x5ea: 0x39dd, 0x5eb: 0x3b6c, 0x5ec: 0x39f2, 0x5ed: 0x3b81, 0x5ee: 0x39eb, 0x5ef: 0x3b7a,
+	0x5f0: 0x39f9, 0x5f1: 0x3b88, 0x5f2: 0x3230, 0x5f3: 0x354b, 0x5f4: 0x3258, 0x5f5: 0x3578,
+	0x5f6: 0x3253, 0x5f7: 0x356e, 0x5f8: 0x323f, 0x5f9: 0x355a,
+	// Block 0x18, offset 0x600
+	0x600: 0x4804, 0x601: 0x480a, 0x602: 0x491e, 0x603: 0x4936, 0x604: 0x4926, 0x605: 0x493e,
+	0x606: 0x492e, 0x607: 0x4946, 0x608: 0x47aa, 0x609: 0x47b0, 0x60a: 0x488e, 0x60b: 0x48a6,
+	0x60c: 0x4896, 0x60d: 0x48ae, 0x60e: 0x489e, 0x60f: 0x48b6, 0x610: 0x4816, 0x611: 0x481c,
+	0x612: 0x3db8, 0x613: 0x3dc8, 0x614: 0x3dc0, 0x615: 0x3dd0,
+	0x618: 0x47b6, 0x619: 0x47bc, 0x61a: 0x3ce8, 0x61b: 0x3cf8, 0x61c: 0x3cf0, 0x61d: 0x3d00,
+	0x620: 0x482e, 0x621: 0x4834, 0x622: 0x494e, 0x623: 0x4966,
+	0x624: 0x4956, 0x625: 0x496e, 0x626: 0x495e, 0x627: 0x4976, 0x628: 0x47c2, 0x629: 0x47c8,
+	0x62a: 0x48be, 0x62b: 0x48d6, 0x62c: 0x48c6, 0x62d: 0x48de, 0x62e: 0x48ce, 0x62f: 0x48e6,
+	0x630: 0x4846, 0x631: 0x484c, 0x632: 0x3e18, 0x633: 0x3e30, 0x634: 0x3e20, 0x635: 0x3e38,
+	0x636: 0x3e28, 0x637: 0x3e40, 0x638: 0x47ce, 0x639: 0x47d4, 0x63a: 0x3d18, 0x63b: 0x3d30,
+	0x63c: 0x3d20, 0x63d: 0x3d38, 0x63e: 0x3d28, 0x63f: 0x3d40,
+	// Block 0x19, offset 0x640
+	0x640: 0x4852, 0x641: 0x4858, 0x642: 0x3e48, 0x643: 0x3e58, 0x644: 0x3e50, 0x645: 0x3e60,
+	0x648: 0x47da, 0x649: 0x47e0, 0x64a: 0x3d48, 0x64b: 0x3d58,
+	0x64c: 0x3d50, 0x64d: 0x3d60, 0x650: 0x4864, 0x651: 0x486a,
+	0x652: 0x3e80, 0x653: 0x3e98, 0x654: 0x3e88, 0x655: 0x3ea0, 0x656: 0x3e90, 0x657: 0x3ea8,
+	0x659: 0x47e6, 0x65b: 0x3d68, 0x65d: 0x3d70,
+	0x65f: 0x3d78, 0x660: 0x487c, 0x661: 0x4882, 0x662: 0x497e, 0x663: 0x4996,
+	0x664: 0x4986, 0x665: 0x499e, 0x666: 0x498e, 0x667: 0x49a6, 0x668: 0x47ec, 0x669: 0x47f2,
+	0x66a: 0x48ee, 0x66b: 0x4906, 0x66c: 0x48f6, 0x66d: 0x490e, 0x66e: 0x48fe, 0x66f: 0x4916,
+	0x670: 0x47f8, 0x671: 0x431e, 0x672: 0x3691, 0x673: 0x4324, 0x674: 0x4822, 0x675: 0x432a,
+	0x676: 0x36a3, 0x677: 0x4330, 0x678: 0x36c1, 0x679: 0x4336, 0x67a: 0x36d9, 0x67b: 0x433c,
+	0x67c: 0x4870, 0x67d: 0x4342,
+	// Block 0x1a, offset 0x680
+	0x680: 0x3da0, 0x681: 0x3da8, 0x682: 0x4184, 0x683: 0x41a2, 0x684: 0x418e, 0x685: 0x41ac,
+	0x686: 0x4198, 0x687: 0x41b6, 0x688: 0x3cd8, 0x689: 0x3ce0, 0x68a: 0x40d0, 0x68b: 0x40ee,
+	0x68c: 0x40da, 0x68d: 0x40f8, 0x68e: 0x40e4, 0x68f: 0x4102, 0x690: 0x3de8, 0x691: 0x3df0,
+	0x692: 0x41c0, 0x693: 0x41de, 0x694: 0x41ca, 0x695: 0x41e8, 0x696: 0x41d4, 0x697: 0x41f2,
+	0x698: 0x3d08, 0x699: 0x3d10, 0x69a: 0x410c, 0x69b: 0x412a, 0x69c: 0x4116, 0x69d: 0x4134,
+	0x69e: 0x4120, 0x69f: 0x413e, 0x6a0: 0x3ec0, 0x6a1: 0x3ec8, 0x6a2: 0x41fc, 0x6a3: 0x421a,
+	0x6a4: 0x4206, 0x6a5: 0x4224, 0x6a6: 0x4210, 0x6a7: 0x422e, 0x6a8: 0x3d80, 0x6a9: 0x3d88,
+	0x6aa: 0x4148, 0x6ab: 0x4166, 0x6ac: 0x4152, 0x6ad: 0x4170, 0x6ae: 0x415c, 0x6af: 0x417a,
+	0x6b0: 0x3685, 0x6b1: 0x367f, 0x6b2: 0x3d90, 0x6b3: 0x368b, 0x6b4: 0x3d98,
+	0x6b6: 0x4810, 0x6b7: 0x3db0, 0x6b8: 0x35f5, 0x6b9: 0x35ef, 0x6ba: 0x35e3, 0x6bb: 0x42ee,
+	0x6bc: 0x35fb, 0x6bd: 0x4287, 0x6be: 0x01d3, 0x6bf: 0x4287,
+	// Block 0x1b, offset 0x6c0
+	0x6c0: 0x42a0, 0x6c1: 0x4482, 0x6c2: 0x3dd8, 0x6c3: 0x369d, 0x6c4: 0x3de0,
+	0x6c6: 0x483a, 0x6c7: 0x3df8, 0x6c8: 0x3601, 0x6c9: 0x42f4, 0x6ca: 0x360d, 0x6cb: 0x42fa,
+	0x6cc: 0x3619, 0x6cd: 0x4489, 0x6ce: 0x4490, 0x6cf: 0x4497, 0x6d0: 0x36b5, 0x6d1: 0x36af,
+	0x6d2: 0x3e00, 0x6d3: 0x44e4, 0x6d6: 0x36bb, 0x6d7: 0x3e10,
+	0x6d8: 0x3631, 0x6d9: 0x362b, 0x6da: 0x361f, 0x6db: 0x4300, 0x6dd: 0x449e,
+	0x6de: 0x44a5, 0x6df: 0x44ac, 0x6e0: 0x36eb, 0x6e1: 0x36e5, 0x6e2: 0x3e68, 0x6e3: 0x44ec,
+	0x6e4: 0x36cd, 0x6e5: 0x36d3, 0x6e6: 0x36f1, 0x6e7: 0x3e78, 0x6e8: 0x3661, 0x6e9: 0x365b,
+	0x6ea: 0x364f, 0x6eb: 0x430c, 0x6ec: 0x3649, 0x6ed: 0x4474, 0x6ee: 0x447b, 0x6ef: 0x0081,
+	0x6f2: 0x3eb0, 0x6f3: 0x36f7, 0x6f4: 0x3eb8,
+	0x6f6: 0x4888, 0x6f7: 0x3ed0, 0x6f8: 0x363d, 0x6f9: 0x4306, 0x6fa: 0x366d, 0x6fb: 0x4318,
+	0x6fc: 0x3679, 0x6fd: 0x425a, 0x6fe: 0x428c,
+	// Block 0x1c, offset 0x700
+	0x700: 0x1bd8, 0x701: 0x1bdc, 0x702: 0x0047, 0x703: 0x1c54, 0x705: 0x1be8,
+	0x706: 0x1bec, 0x707: 0x00e9, 0x709: 0x1c58, 0x70a: 0x008f, 0x70b: 0x0051,
+	0x70c: 0x0051, 0x70d: 0x0051, 0x70e: 0x0091, 0x70f: 0x00da, 0x710: 0x0053, 0x711: 0x0053,
+	0x712: 0x0059, 0x713: 0x0099, 0x715: 0x005d, 0x716: 0x198d,
+	0x719: 0x0061, 0x71a: 0x0063, 0x71b: 0x0065, 0x71c: 0x0065, 0x71d: 0x0065,
+	0x720: 0x199f, 0x721: 0x1bc8, 0x722: 0x19a8,
+	0x724: 0x0075, 0x726: 0x01b8, 0x728: 0x0075,
+	0x72a: 0x0057, 0x72b: 0x42d2, 0x72c: 0x0045, 0x72d: 0x0047, 0x72f: 0x008b,
+	0x730: 0x004b, 0x731: 0x004d, 0x733: 0x005b, 0x734: 0x009f, 0x735: 0x0215,
+	0x736: 0x0218, 0x737: 0x021b, 0x738: 0x021e, 0x739: 0x0093, 0x73b: 0x1b98,
+	0x73c: 0x01e8, 0x73d: 0x01c1, 0x73e: 0x0179, 0x73f: 0x01a0,
+	// Block 0x1d, offset 0x740
+	0x740: 0x0463, 0x745: 0x0049,
+	0x746: 0x0089, 0x747: 0x008b, 0x748: 0x0093, 0x749: 0x0095,
+	0x750: 0x222e, 0x751: 0x223a,
+	0x752: 0x22ee, 0x753: 0x2216, 0x754: 0x229a, 0x755: 0x2222, 0x756: 0x22a0, 0x757: 0x22b8,
+	0x758: 0x22c4, 0x759: 0x2228, 0x75a: 0x22ca, 0x75b: 0x2234, 0x75c: 0x22be, 0x75d: 0x22d0,
+	0x75e: 0x22d6, 0x75f: 0x1cbc, 0x760: 0x0053, 0x761: 0x195a, 0x762: 0x1ba4, 0x763: 0x1963,
+	0x764: 0x006d, 0x765: 0x19ab, 0x766: 0x1bd0, 0x767: 0x1d48, 0x768: 0x1966, 0x769: 0x0071,
+	0x76a: 0x19b7, 0x76b: 0x1bd4, 0x76c: 0x0059, 0x76d: 0x0047, 0x76e: 0x0049, 0x76f: 0x005b,
+	0x770: 0x0093, 0x771: 0x19e4, 0x772: 0x1c18, 0x773: 0x19ed, 0x774: 0x00ad, 0x775: 0x1a62,
+	0x776: 0x1c4c, 0x777: 0x1d5c, 0x778: 0x19f0, 0x779: 0x00b1, 0x77a: 0x1a65, 0x77b: 0x1c50,
+	0x77c: 0x0099, 0x77d: 0x0087, 0x77e: 0x0089, 0x77f: 0x009b,
+	// Block 0x1e, offset 0x780
+	0x781: 0x3c06, 0x783: 0xa000, 0x784: 0x3c0d, 0x785: 0xa000,
+	0x787: 0x3c14, 0x788: 0xa000, 0x789: 0x3c1b,
+	0x78d: 0xa000,
+	0x7a0: 0x2f65, 0x7a1: 0xa000, 0x7a2: 0x3c29,
+	0x7a4: 0xa000, 0x7a5: 0xa000,
+	0x7ad: 0x3c22, 0x7ae: 0x2f60, 0x7af: 0x2f6a,
+	0x7b0: 0x3c30, 0x7b1: 0x3c37, 0x7b2: 0xa000, 0x7b3: 0xa000, 0x7b4: 0x3c3e, 0x7b5: 0x3c45,
+	0x7b6: 0xa000, 0x7b7: 0xa000, 0x7b8: 0x3c4c, 0x7b9: 0x3c53, 0x7ba: 0xa000, 0x7bb: 0xa000,
+	0x7bc: 0xa000, 0x7bd: 0xa000,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x3c5a, 0x7c1: 0x3c61, 0x7c2: 0xa000, 0x7c3: 0xa000, 0x7c4: 0x3c76, 0x7c5: 0x3c7d,
+	0x7c6: 0xa000, 0x7c7: 0xa000, 0x7c8: 0x3c84, 0x7c9: 0x3c8b,
+	0x7d1: 0xa000,
+	0x7d2: 0xa000,
+	0x7e2: 0xa000,
+	0x7e8: 0xa000, 0x7e9: 0xa000,
+	0x7eb: 0xa000, 0x7ec: 0x3ca0, 0x7ed: 0x3ca7, 0x7ee: 0x3cae, 0x7ef: 0x3cb5,
+	0x7f2: 0xa000, 0x7f3: 0xa000, 0x7f4: 0xa000, 0x7f5: 0xa000,
+	// Block 0x20, offset 0x800
+	0x820: 0x0023, 0x821: 0x0025, 0x822: 0x0027, 0x823: 0x0029,
+	0x824: 0x002b, 0x825: 0x002d, 0x826: 0x002f, 0x827: 0x0031, 0x828: 0x0033, 0x829: 0x1882,
+	0x82a: 0x1885, 0x82b: 0x1888, 0x82c: 0x188b, 0x82d: 0x188e, 0x82e: 0x1891, 0x82f: 0x1894,
+	0x830: 0x1897, 0x831: 0x189a, 0x832: 0x189d, 0x833: 0x18a6, 0x834: 0x1a68, 0x835: 0x1a6c,
+	0x836: 0x1a70, 0x837: 0x1a74, 0x838: 0x1a78, 0x839: 0x1a7c, 0x83a: 0x1a80, 0x83b: 0x1a84,
+	0x83c: 0x1a88, 0x83d: 0x1c80, 0x83e: 0x1c85, 0x83f: 0x1c8a,
+	// Block 0x21, offset 0x840
+	0x840: 0x1c8f, 0x841: 0x1c94, 0x842: 0x1c99, 0x843: 0x1c9e, 0x844: 0x1ca3, 0x845: 0x1ca8,
+	0x846: 0x1cad, 0x847: 0x1cb2, 0x848: 0x187f, 0x849: 0x18a3, 0x84a: 0x18c7, 0x84b: 0x18eb,
+	0x84c: 0x190f, 0x84d: 0x1918, 0x84e: 0x191e, 0x84f: 0x1924, 0x850: 0x192a, 0x851: 0x1b60,
+	0x852: 0x1b64, 0x853: 0x1b68, 0x854: 0x1b6c, 0x855: 0x1b70, 0x856: 0x1b74, 0x857: 0x1b78,
+	0x858: 0x1b7c, 0x859: 0x1b80, 0x85a: 0x1b84, 0x85b: 0x1b88, 0x85c: 0x1af4, 0x85d: 0x1af8,
+	0x85e: 0x1afc, 0x85f: 0x1b00, 0x860: 0x1b04, 0x861: 0x1b08, 0x862: 0x1b0c, 0x863: 0x1b10,
+	0x864: 0x1b14, 0x865: 0x1b18, 0x866: 0x1b1c, 0x867: 0x1b20, 0x868: 0x1b24, 0x869: 0x1b28,
+	0x86a: 0x1b2c, 0x86b: 0x1b30, 0x86c: 0x1b34, 0x86d: 0x1b38, 0x86e: 0x1b3c, 0x86f: 0x1b40,
+	0x870: 0x1b44, 0x871: 0x1b48, 0x872: 0x1b4c, 0x873: 0x1b50, 0x874: 0x1b54, 0x875: 0x1b58,
+	0x876: 0x0043, 0x877: 0x0045, 0x878: 0x0047, 0x879: 0x0049, 0x87a: 0x004b, 0x87b: 0x004d,
+	0x87c: 0x004f, 0x87d: 0x0051, 0x87e: 0x0053, 0x87f: 0x0055,
+	// Block 0x22, offset 0x880
+	0x880: 0x06bf, 0x881: 0x06e3, 0x882: 0x06ef, 0x883: 0x06ff, 0x884: 0x0707, 0x885: 0x0713,
+	0x886: 0x071b, 0x887: 0x0723, 0x888: 0x072f, 0x889: 0x0783, 0x88a: 0x079b, 0x88b: 0x07ab,
+	0x88c: 0x07bb, 0x88d: 0x07cb, 0x88e: 0x07db, 0x88f: 0x07fb, 0x890: 0x07ff, 0x891: 0x0803,
+	0x892: 0x0837, 0x893: 0x085f, 0x894: 0x086f, 0x895: 0x0877, 0x896: 0x087b, 0x897: 0x0887,
+	0x898: 0x08a3, 0x899: 0x08a7, 0x89a: 0x08bf, 0x89b: 0x08c3, 0x89c: 0x08cb, 0x89d: 0x08db,
+	0x89e: 0x0977, 0x89f: 0x098b, 0x8a0: 0x09cb, 0x8a1: 0x09df, 0x8a2: 0x09e7, 0x8a3: 0x09eb,
+	0x8a4: 0x09fb, 0x8a5: 0x0a17, 0x8a6: 0x0a43, 0x8a7: 0x0a4f, 0x8a8: 0x0a6f, 0x8a9: 0x0a7b,
+	0x8aa: 0x0a7f, 0x8ab: 0x0a83, 0x8ac: 0x0a9b, 0x8ad: 0x0a9f, 0x8ae: 0x0acb, 0x8af: 0x0ad7,
+	0x8b0: 0x0adf, 0x8b1: 0x0ae7, 0x8b2: 0x0af7, 0x8b3: 0x0aff, 0x8b4: 0x0b07, 0x8b5: 0x0b33,
+	0x8b6: 0x0b37, 0x8b7: 0x0b3f, 0x8b8: 0x0b43, 0x8b9: 0x0b4b, 0x8ba: 0x0b53, 0x8bb: 0x0b63,
+	0x8bc: 0x0b7f, 0x8bd: 0x0bf7, 0x8be: 0x0c0b, 0x8bf: 0x0c0f,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0c8f, 0x8c1: 0x0c93, 0x8c2: 0x0ca7, 0x8c3: 0x0cab, 0x8c4: 0x0cb3, 0x8c5: 0x0cbb,
+	0x8c6: 0x0cc3, 0x8c7: 0x0ccf, 0x8c8: 0x0cf7, 0x8c9: 0x0d07, 0x8ca: 0x0d1b, 0x8cb: 0x0d8b,
+	0x8cc: 0x0d97, 0x8cd: 0x0da7, 0x8ce: 0x0db3, 0x8cf: 0x0dbf, 0x8d0: 0x0dc7, 0x8d1: 0x0dcb,
+	0x8d2: 0x0dcf, 0x8d3: 0x0dd3, 0x8d4: 0x0dd7, 0x8d5: 0x0e8f, 0x8d6: 0x0ed7, 0x8d7: 0x0ee3,
+	0x8d8: 0x0ee7, 0x8d9: 0x0eeb, 0x8da: 0x0eef, 0x8db: 0x0ef7, 0x8dc: 0x0efb, 0x8dd: 0x0f0f,
+	0x8de: 0x0f2b, 0x8df: 0x0f33, 0x8e0: 0x0f73, 0x8e1: 0x0f77, 0x8e2: 0x0f7f, 0x8e3: 0x0f83,
+	0x8e4: 0x0f8b, 0x8e5: 0x0f8f, 0x8e6: 0x0fb3, 0x8e7: 0x0fb7, 0x8e8: 0x0fd3, 0x8e9: 0x0fd7,
+	0x8ea: 0x0fdb, 0x8eb: 0x0fdf, 0x8ec: 0x0ff3, 0x8ed: 0x1017, 0x8ee: 0x101b, 0x8ef: 0x101f,
+	0x8f0: 0x1043, 0x8f1: 0x1083, 0x8f2: 0x1087, 0x8f3: 0x10a7, 0x8f4: 0x10b7, 0x8f5: 0x10bf,
+	0x8f6: 0x10df, 0x8f7: 0x1103, 0x8f8: 0x1147, 0x8f9: 0x114f, 0x8fa: 0x1163, 0x8fb: 0x116f,
+	0x8fc: 0x1177, 0x8fd: 0x117f, 0x8fe: 0x1183, 0x8ff: 0x1187,
+	// Block 0x24, offset 0x900
+	0x900: 0x119f, 0x901: 0x11a3, 0x902: 0x11bf, 0x903: 0x11c7, 0x904: 0x11cf, 0x905: 0x11d3,
+	0x906: 0x11df, 0x907: 0x11e7, 0x908: 0x11eb, 0x909: 0x11ef, 0x90a: 0x11f7, 0x90b: 0x11fb,
+	0x90c: 0x129b, 0x90d: 0x12af, 0x90e: 0x12e3, 0x90f: 0x12e7, 0x910: 0x12ef, 0x911: 0x131b,
+	0x912: 0x1323, 0x913: 0x132b, 0x914: 0x1333, 0x915: 0x136f, 0x916: 0x1373, 0x917: 0x137b,
+	0x918: 0x137f, 0x919: 0x1383, 0x91a: 0x13af, 0x91b: 0x13b3, 0x91c: 0x13bb, 0x91d: 0x13cf,
+	0x91e: 0x13d3, 0x91f: 0x13ef, 0x920: 0x13f7, 0x921: 0x13fb, 0x922: 0x141f, 0x923: 0x143f,
+	0x924: 0x1453, 0x925: 0x1457, 0x926: 0x145f, 0x927: 0x148b, 0x928: 0x148f, 0x929: 0x149f,
+	0x92a: 0x14c3, 0x92b: 0x14cf, 0x92c: 0x14df, 0x92d: 0x14f7, 0x92e: 0x14ff, 0x92f: 0x1503,
+	0x930: 0x1507, 0x931: 0x150b, 0x932: 0x1517, 0x933: 0x151b, 0x934: 0x1523, 0x935: 0x153f,
+	0x936: 0x1543, 0x937: 0x1547, 0x938: 0x155f, 0x939: 0x1563, 0x93a: 0x156b, 0x93b: 0x157f,
+	0x93c: 0x1583, 0x93d: 0x1587, 0x93e: 0x158f, 0x93f: 0x1593,
+	// Block 0x25, offset 0x940
+	0x946: 0xa000, 0x94b: 0xa000,
+	0x94c: 0x3f08, 0x94d: 0xa000, 0x94e: 0x3f10, 0x94f: 0xa000, 0x950: 0x3f18, 0x951: 0xa000,
+	0x952: 0x3f20, 0x953: 0xa000, 0x954: 0x3f28, 0x955: 0xa000, 0x956: 0x3f30, 0x957: 0xa000,
+	0x958: 0x3f38, 0x959: 0xa000, 0x95a: 0x3f40, 0x95b: 0xa000, 0x95c: 0x3f48, 0x95d: 0xa000,
+	0x95e: 0x3f50, 0x95f: 0xa000, 0x960: 0x3f58, 0x961: 0xa000, 0x962: 0x3f60,
+	0x964: 0xa000, 0x965: 0x3f68, 0x966: 0xa000, 0x967: 0x3f70, 0x968: 0xa000, 0x969: 0x3f78,
+	0x96f: 0xa000,
+	0x970: 0x3f80, 0x971: 0x3f88, 0x972: 0xa000, 0x973: 0x3f90, 0x974: 0x3f98, 0x975: 0xa000,
+	0x976: 0x3fa0, 0x977: 0x3fa8, 0x978: 0xa000, 0x979: 0x3fb0, 0x97a: 0x3fb8, 0x97b: 0xa000,
+	0x97c: 0x3fc0, 0x97d: 0x3fc8,
+	// Block 0x26, offset 0x980
+	0x994: 0x3f00,
+	0x999: 0x9903, 0x99a: 0x9903, 0x99b: 0x42dc, 0x99c: 0x42e2, 0x99d: 0xa000,
+	0x99e: 0x3fd0, 0x99f: 0x26b4,
+	0x9a6: 0xa000,
+	0x9ab: 0xa000, 0x9ac: 0x3fe0, 0x9ad: 0xa000, 0x9ae: 0x3fe8, 0x9af: 0xa000,
+	0x9b0: 0x3ff0, 0x9b1: 0xa000, 0x9b2: 0x3ff8, 0x9b3: 0xa000, 0x9b4: 0x4000, 0x9b5: 0xa000,
+	0x9b6: 0x4008, 0x9b7: 0xa000, 0x9b8: 0x4010, 0x9b9: 0xa000, 0x9ba: 0x4018, 0x9bb: 0xa000,
+	0x9bc: 0x4020, 0x9bd: 0xa000, 0x9be: 0x4028, 0x9bf: 0xa000,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x4030, 0x9c1: 0xa000, 0x9c2: 0x4038, 0x9c4: 0xa000, 0x9c5: 0x4040,
+	0x9c6: 0xa000, 0x9c7: 0x4048, 0x9c8: 0xa000, 0x9c9: 0x4050,
+	0x9cf: 0xa000, 0x9d0: 0x4058, 0x9d1: 0x4060,
+	0x9d2: 0xa000, 0x9d3: 0x4068, 0x9d4: 0x4070, 0x9d5: 0xa000, 0x9d6: 0x4078, 0x9d7: 0x4080,
+	0x9d8: 0xa000, 0x9d9: 0x4088, 0x9da: 0x4090, 0x9db: 0xa000, 0x9dc: 0x4098, 0x9dd: 0x40a0,
+	0x9ef: 0xa000,
+	0x9f0: 0xa000, 0x9f1: 0xa000, 0x9f2: 0xa000, 0x9f4: 0x3fd8,
+	0x9f7: 0x40a8, 0x9f8: 0x40b0, 0x9f9: 0x40b8, 0x9fa: 0x40c0,
+	0x9fd: 0xa000, 0x9fe: 0x40c8, 0x9ff: 0x26c9,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0367, 0xa01: 0x032b, 0xa02: 0x032f, 0xa03: 0x0333, 0xa04: 0x037b, 0xa05: 0x0337,
+	0xa06: 0x033b, 0xa07: 0x033f, 0xa08: 0x0343, 0xa09: 0x0347, 0xa0a: 0x034b, 0xa0b: 0x034f,
+	0xa0c: 0x0353, 0xa0d: 0x0357, 0xa0e: 0x035b, 0xa0f: 0x49bd, 0xa10: 0x49c3, 0xa11: 0x49c9,
+	0xa12: 0x49cf, 0xa13: 0x49d5, 0xa14: 0x49db, 0xa15: 0x49e1, 0xa16: 0x49e7, 0xa17: 0x49ed,
+	0xa18: 0x49f3, 0xa19: 0x49f9, 0xa1a: 0x49ff, 0xa1b: 0x4a05, 0xa1c: 0x4a0b, 0xa1d: 0x4a11,
+	0xa1e: 0x4a17, 0xa1f: 0x4a1d, 0xa20: 0x4a23, 0xa21: 0x4a29, 0xa22: 0x4a2f, 0xa23: 0x4a35,
+	0xa24: 0x03c3, 0xa25: 0x035f, 0xa26: 0x0363, 0xa27: 0x03e7, 0xa28: 0x03eb, 0xa29: 0x03ef,
+	0xa2a: 0x03f3, 0xa2b: 0x03f7, 0xa2c: 0x03fb, 0xa2d: 0x03ff, 0xa2e: 0x036b, 0xa2f: 0x0403,
+	0xa30: 0x0407, 0xa31: 0x036f, 0xa32: 0x0373, 0xa33: 0x0377, 0xa34: 0x037f, 0xa35: 0x0383,
+	0xa36: 0x0387, 0xa37: 0x038b, 0xa38: 0x038f, 0xa39: 0x0393, 0xa3a: 0x0397, 0xa3b: 0x039b,
+	0xa3c: 0x039f, 0xa3d: 0x03a3, 0xa3e: 0x03a7, 0xa3f: 0x03ab,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x03af, 0xa41: 0x03b3, 0xa42: 0x040b, 0xa43: 0x040f, 0xa44: 0x03b7, 0xa45: 0x03bb,
+	0xa46: 0x03bf, 0xa47: 0x03c7, 0xa48: 0x03cb, 0xa49: 0x03cf, 0xa4a: 0x03d3, 0xa4b: 0x03d7,
+	0xa4c: 0x03db, 0xa4d: 0x03df, 0xa4e: 0x03e3,
+	0xa52: 0x06bf, 0xa53: 0x071b, 0xa54: 0x06cb, 0xa55: 0x097b, 0xa56: 0x06cf, 0xa57: 0x06e7,
+	0xa58: 0x06d3, 0xa59: 0x0f93, 0xa5a: 0x0707, 0xa5b: 0x06db, 0xa5c: 0x06c3, 0xa5d: 0x09ff,
+	0xa5e: 0x098f, 0xa5f: 0x072f,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x2054, 0xa81: 0x205a, 0xa82: 0x2060, 0xa83: 0x2066, 0xa84: 0x206c, 0xa85: 0x2072,
+	0xa86: 0x2078, 0xa87: 0x207e, 0xa88: 0x2084, 0xa89: 0x208a, 0xa8a: 0x2090, 0xa8b: 0x2096,
+	0xa8c: 0x209c, 0xa8d: 0x20a2, 0xa8e: 0x2726, 0xa8f: 0x272f, 0xa90: 0x2738, 0xa91: 0x2741,
+	0xa92: 0x274a, 0xa93: 0x2753, 0xa94: 0x275c, 0xa95: 0x2765, 0xa96: 0x276e, 0xa97: 0x2780,
+	0xa98: 0x2789, 0xa99: 0x2792, 0xa9a: 0x279b, 0xa9b: 0x27a4, 0xa9c: 0x2777, 0xa9d: 0x2bac,
+	0xa9e: 0x2aed, 0xaa0: 0x20a8, 0xaa1: 0x20c0, 0xaa2: 0x20b4, 0xaa3: 0x2108,
+	0xaa4: 0x20c6, 0xaa5: 0x20e4, 0xaa6: 0x20ae, 0xaa7: 0x20de, 0xaa8: 0x20ba, 0xaa9: 0x20f0,
+	0xaaa: 0x2120, 0xaab: 0x213e, 0xaac: 0x2138, 0xaad: 0x212c, 0xaae: 0x217a, 0xaaf: 0x210e,
+	0xab0: 0x211a, 0xab1: 0x2132, 0xab2: 0x2126, 0xab3: 0x2150, 0xab4: 0x20fc, 0xab5: 0x2144,
+	0xab6: 0x216e, 0xab7: 0x2156, 0xab8: 0x20ea, 0xab9: 0x20cc, 0xaba: 0x2102, 0xabb: 0x2114,
+	0xabc: 0x214a, 0xabd: 0x20d2, 0xabe: 0x2174, 0xabf: 0x20f6,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x215c, 0xac1: 0x20d8, 0xac2: 0x2162, 0xac3: 0x2168, 0xac4: 0x092f, 0xac5: 0x0b03,
+	0xac6: 0x0ca7, 0xac7: 0x10c7,
+	0xad0: 0x1bc4, 0xad1: 0x18a9,
+	0xad2: 0x18ac, 0xad3: 0x18af, 0xad4: 0x18b2, 0xad5: 0x18b5, 0xad6: 0x18b8, 0xad7: 0x18bb,
+	0xad8: 0x18be, 0xad9: 0x18c1, 0xada: 0x18ca, 0xadb: 0x18cd, 0xadc: 0x18d0, 0xadd: 0x18d3,
+	0xade: 0x18d6, 0xadf: 0x18d9, 0xae0: 0x0313, 0xae1: 0x031b, 0xae2: 0x031f, 0xae3: 0x0327,
+	0xae4: 0x032b, 0xae5: 0x032f, 0xae6: 0x0337, 0xae7: 0x033f, 0xae8: 0x0343, 0xae9: 0x034b,
+	0xaea: 0x034f, 0xaeb: 0x0353, 0xaec: 0x0357, 0xaed: 0x035b, 0xaee: 0x2e18, 0xaef: 0x2e20,
+	0xaf0: 0x2e28, 0xaf1: 0x2e30, 0xaf2: 0x2e38, 0xaf3: 0x2e40, 0xaf4: 0x2e48, 0xaf5: 0x2e50,
+	0xaf6: 0x2e60, 0xaf7: 0x2e68, 0xaf8: 0x2e70, 0xaf9: 0x2e78, 0xafa: 0x2e80, 0xafb: 0x2e88,
+	0xafc: 0x2ed3, 0xafd: 0x2e9b, 0xafe: 0x2e58,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x06bf, 0xb01: 0x071b, 0xb02: 0x06cb, 0xb03: 0x097b, 0xb04: 0x071f, 0xb05: 0x07af,
+	0xb06: 0x06c7, 0xb07: 0x07ab, 0xb08: 0x070b, 0xb09: 0x0887, 0xb0a: 0x0d07, 0xb0b: 0x0e8f,
+	0xb0c: 0x0dd7, 0xb0d: 0x0d1b, 0xb0e: 0x145f, 0xb0f: 0x098b, 0xb10: 0x0ccf, 0xb11: 0x0d4b,
+	0xb12: 0x0d0b, 0xb13: 0x104b, 0xb14: 0x08fb, 0xb15: 0x0f03, 0xb16: 0x1387, 0xb17: 0x105f,
+	0xb18: 0x0843, 0xb19: 0x108f, 0xb1a: 0x0f9b, 0xb1b: 0x0a17, 0xb1c: 0x140f, 0xb1d: 0x077f,
+	0xb1e: 0x08ab, 0xb1f: 0x0df7, 0xb20: 0x1527, 0xb21: 0x0743, 0xb22: 0x07d3, 0xb23: 0x0d9b,
+	0xb24: 0x06cf, 0xb25: 0x06e7, 0xb26: 0x06d3, 0xb27: 0x0adb, 0xb28: 0x08ef, 0xb29: 0x087f,
+	0xb2a: 0x0a57, 0xb2b: 0x0a4b, 0xb2c: 0x0feb, 0xb2d: 0x073f, 0xb2e: 0x139b, 0xb2f: 0x089b,
+	0xb30: 0x09f3, 0xb31: 0x18dc, 0xb32: 0x18df, 0xb33: 0x18e2, 0xb34: 0x18e5, 0xb35: 0x18ee,
+	0xb36: 0x18f1, 0xb37: 0x18f4, 0xb38: 0x18f7, 0xb39: 0x18fa, 0xb3a: 0x18fd, 0xb3b: 0x1900,
+	0xb3c: 0x1903, 0xb3d: 0x1906, 0xb3e: 0x1909, 0xb3f: 0x1912,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x1cc6, 0xb41: 0x1cd5, 0xb42: 0x1ce4, 0xb43: 0x1cf3, 0xb44: 0x1d02, 0xb45: 0x1d11,
+	0xb46: 0x1d20, 0xb47: 0x1d2f, 0xb48: 0x1d3e, 0xb49: 0x218c, 0xb4a: 0x219e, 0xb4b: 0x21b0,
+	0xb4c: 0x1954, 0xb4d: 0x1c04, 0xb4e: 0x19d2, 0xb4f: 0x1ba8, 0xb50: 0x04cb, 0xb51: 0x04d3,
+	0xb52: 0x04db, 0xb53: 0x04e3, 0xb54: 0x04eb, 0xb55: 0x04ef, 0xb56: 0x04f3, 0xb57: 0x04f7,
+	0xb58: 0x04fb, 0xb59: 0x04ff, 0xb5a: 0x0503, 0xb5b: 0x0507, 0xb5c: 0x050b, 0xb5d: 0x050f,
+	0xb5e: 0x0513, 0xb5f: 0x0517, 0xb60: 0x051b, 0xb61: 0x0523, 0xb62: 0x0527, 0xb63: 0x052b,
+	0xb64: 0x052f, 0xb65: 0x0533, 0xb66: 0x0537, 0xb67: 0x053b, 0xb68: 0x053f, 0xb69: 0x0543,
+	0xb6a: 0x0547, 0xb6b: 0x054b, 0xb6c: 0x054f, 0xb6d: 0x0553, 0xb6e: 0x0557, 0xb6f: 0x055b,
+	0xb70: 0x055f, 0xb71: 0x0563, 0xb72: 0x0567, 0xb73: 0x056f, 0xb74: 0x0577, 0xb75: 0x057f,
+	0xb76: 0x0583, 0xb77: 0x0587, 0xb78: 0x058b, 0xb79: 0x058f, 0xb7a: 0x0593, 0xb7b: 0x0597,
+	0xb7c: 0x059b, 0xb7d: 0x059f, 0xb7e: 0x05a3,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x2b0c, 0xb81: 0x29a8, 0xb82: 0x2b1c, 0xb83: 0x2880, 0xb84: 0x2ee4, 0xb85: 0x288a,
+	0xb86: 0x2894, 0xb87: 0x2f28, 0xb88: 0x29b5, 0xb89: 0x289e, 0xb8a: 0x28a8, 0xb8b: 0x28b2,
+	0xb8c: 0x29dc, 0xb8d: 0x29e9, 0xb8e: 0x29c2, 0xb8f: 0x29cf, 0xb90: 0x2ea9, 0xb91: 0x29f6,
+	0xb92: 0x2a03, 0xb93: 0x2bbe, 0xb94: 0x26bb, 0xb95: 0x2bd1, 0xb96: 0x2be4, 0xb97: 0x2b2c,
+	0xb98: 0x2a10, 0xb99: 0x2bf7, 0xb9a: 0x2c0a, 0xb9b: 0x2a1d, 0xb9c: 0x28bc, 0xb9d: 0x28c6,
+	0xb9e: 0x2eb7, 0xb9f: 0x2a2a, 0xba0: 0x2b3c, 0xba1: 0x2ef5, 0xba2: 0x28d0, 0xba3: 0x28da,
+	0xba4: 0x2a37, 0xba5: 0x28e4, 0xba6: 0x28ee, 0xba7: 0x26d0, 0xba8: 0x26d7, 0xba9: 0x28f8,
+	0xbaa: 0x2902, 0xbab: 0x2c1d, 0xbac: 0x2a44, 0xbad: 0x2b4c, 0xbae: 0x2c30, 0xbaf: 0x2a51,
+	0xbb0: 0x2916, 0xbb1: 0x290c, 0xbb2: 0x2f3c, 0xbb3: 0x2a5e, 0xbb4: 0x2c43, 0xbb5: 0x2920,
+	0xbb6: 0x2b5c, 0xbb7: 0x292a, 0xbb8: 0x2a78, 0xbb9: 0x2934, 0xbba: 0x2a85, 0xbbb: 0x2f06,
+	0xbbc: 0x2a6b, 0xbbd: 0x2b6c, 0xbbe: 0x2a92, 0xbbf: 0x26de,
+	// Block 0x2f, offset 0xbc0
+	0xbc0: 0x2f17, 0xbc1: 0x293e, 0xbc2: 0x2948, 0xbc3: 0x2a9f, 0xbc4: 0x2952, 0xbc5: 0x295c,
+	0xbc6: 0x2966, 0xbc7: 0x2b7c, 0xbc8: 0x2aac, 0xbc9: 0x26e5, 0xbca: 0x2c56, 0xbcb: 0x2e90,
+	0xbcc: 0x2b8c, 0xbcd: 0x2ab9, 0xbce: 0x2ec5, 0xbcf: 0x2970, 0xbd0: 0x297a, 0xbd1: 0x2ac6,
+	0xbd2: 0x26ec, 0xbd3: 0x2ad3, 0xbd4: 0x2b9c, 0xbd5: 0x26f3, 0xbd6: 0x2c69, 0xbd7: 0x2984,
+	0xbd8: 0x1cb7, 0xbd9: 0x1ccb, 0xbda: 0x1cda, 0xbdb: 0x1ce9, 0xbdc: 0x1cf8, 0xbdd: 0x1d07,
+	0xbde: 0x1d16, 0xbdf: 0x1d25, 0xbe0: 0x1d34, 0xbe1: 0x1d43, 0xbe2: 0x2192, 0xbe3: 0x21a4,
+	0xbe4: 0x21b6, 0xbe5: 0x21c2, 0xbe6: 0x21ce, 0xbe7: 0x21da, 0xbe8: 0x21e6, 0xbe9: 0x21f2,
+	0xbea: 0x21fe, 0xbeb: 0x220a, 0xbec: 0x2246, 0xbed: 0x2252, 0xbee: 0x225e, 0xbef: 0x226a,
+	0xbf0: 0x2276, 0xbf1: 0x1c14, 0xbf2: 0x19c6, 0xbf3: 0x1936, 0xbf4: 0x1be4, 0xbf5: 0x1a47,
+	0xbf6: 0x1a56, 0xbf7: 0x19cc, 0xbf8: 0x1bfc, 0xbf9: 0x1c00, 0xbfa: 0x1960, 0xbfb: 0x2701,
+	0xbfc: 0x270f, 0xbfd: 0x26fa, 0xbfe: 0x2708, 0xbff: 0x2ae0,
+	// Block 0x30, offset 0xc00
+	0xc00: 0x1a4a, 0xc01: 0x1a32, 0xc02: 0x1c60, 0xc03: 0x1a1a, 0xc04: 0x19f3, 0xc05: 0x1969,
+	0xc06: 0x1978, 0xc07: 0x1948, 0xc08: 0x1bf0, 0xc09: 0x1d52, 0xc0a: 0x1a4d, 0xc0b: 0x1a35,
+	0xc0c: 0x1c64, 0xc0d: 0x1c70, 0xc0e: 0x1a26, 0xc0f: 0x19fc, 0xc10: 0x1957, 0xc11: 0x1c1c,
+	0xc12: 0x1bb0, 0xc13: 0x1b9c, 0xc14: 0x1bcc, 0xc15: 0x1c74, 0xc16: 0x1a29, 0xc17: 0x19c9,
+	0xc18: 0x19ff, 0xc19: 0x19de, 0xc1a: 0x1a41, 0xc1b: 0x1c78, 0xc1c: 0x1a2c, 0xc1d: 0x19c0,
+	0xc1e: 0x1a02, 0xc1f: 0x1c3c, 0xc20: 0x1bf4, 0xc21: 0x1a14, 0xc22: 0x1c24, 0xc23: 0x1c40,
+	0xc24: 0x1bf8, 0xc25: 0x1a17, 0xc26: 0x1c28, 0xc27: 0x22e8, 0xc28: 0x22fc, 0xc29: 0x1996,
+	0xc2a: 0x1c20, 0xc2b: 0x1bb4, 0xc2c: 0x1ba0, 0xc2d: 0x1c48, 0xc2e: 0x2716, 0xc2f: 0x27ad,
+	0xc30: 0x1a59, 0xc31: 0x1a44, 0xc32: 0x1c7c, 0xc33: 0x1a2f, 0xc34: 0x1a50, 0xc35: 0x1a38,
+	0xc36: 0x1c68, 0xc37: 0x1a1d, 0xc38: 0x19f6, 0xc39: 0x1981, 0xc3a: 0x1a53, 0xc3b: 0x1a3b,
+	0xc3c: 0x1c6c, 0xc3d: 0x1a20, 0xc3e: 0x19f9, 0xc3f: 0x1984,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x1c2c, 0xc41: 0x1bb8, 0xc42: 0x1d4d, 0xc43: 0x1939, 0xc44: 0x19ba, 0xc45: 0x19bd,
+	0xc46: 0x22f5, 0xc47: 0x1b94, 0xc48: 0x19c3, 0xc49: 0x194b, 0xc4a: 0x19e1, 0xc4b: 0x194e,
+	0xc4c: 0x19ea, 0xc4d: 0x196c, 0xc4e: 0x196f, 0xc4f: 0x1a05, 0xc50: 0x1a0b, 0xc51: 0x1a0e,
+	0xc52: 0x1c30, 0xc53: 0x1a11, 0xc54: 0x1a23, 0xc55: 0x1c38, 0xc56: 0x1c44, 0xc57: 0x1990,
+	0xc58: 0x1d57, 0xc59: 0x1bbc, 0xc5a: 0x1993, 0xc5b: 0x1a5c, 0xc5c: 0x19a5, 0xc5d: 0x19b4,
+	0xc5e: 0x22e2, 0xc5f: 0x22dc, 0xc60: 0x1cc1, 0xc61: 0x1cd0, 0xc62: 0x1cdf, 0xc63: 0x1cee,
+	0xc64: 0x1cfd, 0xc65: 0x1d0c, 0xc66: 0x1d1b, 0xc67: 0x1d2a, 0xc68: 0x1d39, 0xc69: 0x2186,
+	0xc6a: 0x2198, 0xc6b: 0x21aa, 0xc6c: 0x21bc, 0xc6d: 0x21c8, 0xc6e: 0x21d4, 0xc6f: 0x21e0,
+	0xc70: 0x21ec, 0xc71: 0x21f8, 0xc72: 0x2204, 0xc73: 0x2240, 0xc74: 0x224c, 0xc75: 0x2258,
+	0xc76: 0x2264, 0xc77: 0x2270, 0xc78: 0x227c, 0xc79: 0x2282, 0xc7a: 0x2288, 0xc7b: 0x228e,
+	0xc7c: 0x2294, 0xc7d: 0x22a6, 0xc7e: 0x22ac, 0xc7f: 0x1c10,
+	// Block 0x32, offset 0xc80
+	0xc80: 0x1377, 0xc81: 0x0cfb, 0xc82: 0x13d3, 0xc83: 0x139f, 0xc84: 0x0e57, 0xc85: 0x06eb,
+	0xc86: 0x08df, 0xc87: 0x162b, 0xc88: 0x162b, 0xc89: 0x0a0b, 0xc8a: 0x145f, 0xc8b: 0x0943,
+	0xc8c: 0x0a07, 0xc8d: 0x0bef, 0xc8e: 0x0fcf, 0xc8f: 0x115f, 0xc90: 0x1297, 0xc91: 0x12d3,
+	0xc92: 0x1307, 0xc93: 0x141b, 0xc94: 0x0d73, 0xc95: 0x0dff, 0xc96: 0x0eab, 0xc97: 0x0f43,
+	0xc98: 0x125f, 0xc99: 0x1447, 0xc9a: 0x1573, 0xc9b: 0x070f, 0xc9c: 0x08b3, 0xc9d: 0x0d87,
+	0xc9e: 0x0ecf, 0xc9f: 0x1293, 0xca0: 0x15c3, 0xca1: 0x0ab3, 0xca2: 0x0e77, 0xca3: 0x1283,
+	0xca4: 0x1317, 0xca5: 0x0c23, 0xca6: 0x11bb, 0xca7: 0x12df, 0xca8: 0x0b1f, 0xca9: 0x0d0f,
+	0xcaa: 0x0e17, 0xcab: 0x0f1b, 0xcac: 0x1427, 0xcad: 0x074f, 0xcae: 0x07e7, 0xcaf: 0x0853,
+	0xcb0: 0x0c8b, 0xcb1: 0x0d7f, 0xcb2: 0x0ecb, 0xcb3: 0x0fef, 0xcb4: 0x1177, 0xcb5: 0x128b,
+	0xcb6: 0x12a3, 0xcb7: 0x13c7, 0xcb8: 0x14ef, 0xcb9: 0x15a3, 0xcba: 0x15bf, 0xcbb: 0x102b,
+	0xcbc: 0x106b, 0xcbd: 0x1123, 0xcbe: 0x1243, 0xcbf: 0x147b,
+	// Block 0x33, offset 0xcc0
+	0xcc0: 0x15cb, 0xcc1: 0x134b, 0xcc2: 0x09c7, 0xcc3: 0x0b3b, 0xcc4: 0x10db, 0xcc5: 0x119b,
+	0xcc6: 0x0eff, 0xcc7: 0x1033, 0xcc8: 0x1397, 0xcc9: 0x14e7, 0xcca: 0x09c3, 0xccb: 0x0a8f,
+	0xccc: 0x0d77, 0xccd: 0x0e2b, 0xcce: 0x0e5f, 0xccf: 0x1113, 0xcd0: 0x113b, 0xcd1: 0x14a7,
+	0xcd2: 0x084f, 0xcd3: 0x11a7, 0xcd4: 0x07f3, 0xcd5: 0x07ef, 0xcd6: 0x1097, 0xcd7: 0x1127,
+	0xcd8: 0x125b, 0xcd9: 0x14af, 0xcda: 0x1367, 0xcdb: 0x0c27, 0xcdc: 0x0d73, 0xcdd: 0x1357,
+	0xcde: 0x06f7, 0xcdf: 0x0a63, 0xce0: 0x0b93, 0xce1: 0x0f2f, 0xce2: 0x0faf, 0xce3: 0x0873,
+	0xce4: 0x103b, 0xce5: 0x075f, 0xce6: 0x0b77, 0xce7: 0x06d7, 0xce8: 0x0deb, 0xce9: 0x0ca3,
+	0xcea: 0x110f, 0xceb: 0x08c7, 0xcec: 0x09b3, 0xced: 0x0ffb, 0xcee: 0x1263, 0xcef: 0x133b,
+	0xcf0: 0x0db7, 0xcf1: 0x13f7, 0xcf2: 0x0de3, 0xcf3: 0x0c37, 0xcf4: 0x121b, 0xcf5: 0x0c57,
+	0xcf6: 0x0fab, 0xcf7: 0x072b, 0xcf8: 0x07a7, 0xcf9: 0x07eb, 0xcfa: 0x0d53, 0xcfb: 0x10fb,
+	0xcfc: 0x11f3, 0xcfd: 0x1347, 0xcfe: 0x145b, 0xcff: 0x085b,
+	// Block 0x34, offset 0xd00
+	0xd00: 0x090f, 0xd01: 0x0a17, 0xd02: 0x0b2f, 0xd03: 0x0cbf, 0xd04: 0x0e7b, 0xd05: 0x103f,
+	0xd06: 0x1497, 0xd07: 0x157b, 0xd08: 0x15cf, 0xd09: 0x15e7, 0xd0a: 0x0837, 0xd0b: 0x0cf3,
+	0xd0c: 0x0da3, 0xd0d: 0x13eb, 0xd0e: 0x0afb, 0xd0f: 0x0bd7, 0xd10: 0x0bf3, 0xd11: 0x0c83,
+	0xd12: 0x0e6b, 0xd13: 0x0eb7, 0xd14: 0x0f67, 0xd15: 0x108b, 0xd16: 0x112f, 0xd17: 0x1193,
+	0xd18: 0x13db, 0xd19: 0x126b, 0xd1a: 0x1403, 0xd1b: 0x147f, 0xd1c: 0x080f, 0xd1d: 0x083b,
+	0xd1e: 0x0923, 0xd1f: 0x0ea7, 0xd20: 0x12f3, 0xd21: 0x133b, 0xd22: 0x0b1b, 0xd23: 0x0b8b,
+	0xd24: 0x0c4f, 0xd25: 0x0daf, 0xd26: 0x10d7, 0xd27: 0x0f23, 0xd28: 0x073b, 0xd29: 0x097f,
+	0xd2a: 0x0a63, 0xd2b: 0x0ac7, 0xd2c: 0x0b97, 0xd2d: 0x0f3f, 0xd2e: 0x0f5b, 0xd2f: 0x116b,
+	0xd30: 0x118b, 0xd31: 0x1463, 0xd32: 0x14e3, 0xd33: 0x14f3, 0xd34: 0x152f, 0xd35: 0x0753,
+	0xd36: 0x107f, 0xd37: 0x144f, 0xd38: 0x14cb, 0xd39: 0x0baf, 0xd3a: 0x0717, 0xd3b: 0x0777,
+	0xd3c: 0x0a67, 0xd3d: 0x0a87, 0xd3e: 0x0caf, 0xd3f: 0x0d73,
+	// Block 0x35, offset 0xd40
+	0xd40: 0x0ec3, 0xd41: 0x0fcb, 0xd42: 0x1277, 0xd43: 0x1417, 0xd44: 0x1623, 0xd45: 0x0ce3,
+	0xd46: 0x14a3, 0xd47: 0x0833, 0xd48: 0x0d2f, 0xd49: 0x0d3b, 0xd4a: 0x0e0f, 0xd4b: 0x0e47,
+	0xd4c: 0x0f4b, 0xd4d: 0x0fa7, 0xd4e: 0x1027, 0xd4f: 0x110b, 0xd50: 0x153b, 0xd51: 0x07af,
+	0xd52: 0x0c03, 0xd53: 0x14b3, 0xd54: 0x0767, 0xd55: 0x0aab, 0xd56: 0x0e2f, 0xd57: 0x13df,
+	0xd58: 0x0b67, 0xd59: 0x0bb7, 0xd5a: 0x0d43, 0xd5b: 0x0f2f, 0xd5c: 0x14bb, 0xd5d: 0x0817,
+	0xd5e: 0x08ff, 0xd5f: 0x0a97, 0xd60: 0x0cd3, 0xd61: 0x0d1f, 0xd62: 0x0d5f, 0xd63: 0x0df3,
+	0xd64: 0x0f47, 0xd65: 0x0fbb, 0xd66: 0x1157, 0xd67: 0x12f7, 0xd68: 0x1303, 0xd69: 0x1457,
+	0xd6a: 0x14d7, 0xd6b: 0x0883, 0xd6c: 0x0e4b, 0xd6d: 0x0903, 0xd6e: 0x0ec7, 0xd6f: 0x0f6b,
+	0xd70: 0x1287, 0xd71: 0x14bf, 0xd72: 0x15ab, 0xd73: 0x15d3, 0xd74: 0x0d37, 0xd75: 0x0e27,
+	0xd76: 0x11c3, 0xd77: 0x10b7, 0xd78: 0x10c3, 0xd79: 0x10e7, 0xd7a: 0x0f17, 0xd7b: 0x0e9f,
+	0xd7c: 0x1363, 0xd7d: 0x0733, 0xd7e: 0x122b, 0xd7f: 0x081b,
+	// Block 0x36, offset 0xd80
+	0xd80: 0x080b, 0xd81: 0x0b0b, 0xd82: 0x0c2b, 0xd83: 0x10f3, 0xd84: 0x0a53, 0xd85: 0x0e03,
+	0xd86: 0x0cef, 0xd87: 0x13e7, 0xd88: 0x12e7, 0xd89: 0x14ab, 0xd8a: 0x1323, 0xd8b: 0x0b27,
+	0xd8c: 0x0787, 0xd8d: 0x095b, 0xd90: 0x09af,
+	0xd92: 0x0cdf, 0xd95: 0x07f7, 0xd96: 0x0f1f, 0xd97: 0x0fe3,
+	0xd98: 0x1047, 0xd99: 0x1063, 0xd9a: 0x1067, 0xd9b: 0x107b, 0xd9c: 0x14fb, 0xd9d: 0x10eb,
+	0xd9e: 0x116f, 0xda0: 0x128f, 0xda2: 0x1353,
+	0xda5: 0x1407, 0xda6: 0x1433,
+	0xdaa: 0x154f, 0xdab: 0x1553, 0xdac: 0x1557, 0xdad: 0x15bb, 0xdae: 0x142b, 0xdaf: 0x14c7,
+	0xdb0: 0x0757, 0xdb1: 0x077b, 0xdb2: 0x078f, 0xdb3: 0x084b, 0xdb4: 0x0857, 0xdb5: 0x0897,
+	0xdb6: 0x094b, 0xdb7: 0x0967, 0xdb8: 0x096f, 0xdb9: 0x09ab, 0xdba: 0x09b7, 0xdbb: 0x0a93,
+	0xdbc: 0x0a9b, 0xdbd: 0x0ba3, 0xdbe: 0x0bcb, 0xdbf: 0x0bd3,
+	// Block 0x37, offset 0xdc0
+	0xdc0: 0x0beb, 0xdc1: 0x0c97, 0xdc2: 0x0cc7, 0xdc3: 0x0ce7, 0xdc4: 0x0d57, 0xdc5: 0x0e1b,
+	0xdc6: 0x0e37, 0xdc7: 0x0e67, 0xdc8: 0x0ebb, 0xdc9: 0x0edb, 0xdca: 0x0f4f, 0xdcb: 0x102f,
+	0xdcc: 0x104b, 0xdcd: 0x1053, 0xdce: 0x104f, 0xdcf: 0x1057, 0xdd0: 0x105b, 0xdd1: 0x105f,
+	0xdd2: 0x1073, 0xdd3: 0x1077, 0xdd4: 0x109b, 0xdd5: 0x10af, 0xdd6: 0x10cb, 0xdd7: 0x112f,
+	0xdd8: 0x1137, 0xdd9: 0x113f, 0xdda: 0x1153, 0xddb: 0x117b, 0xddc: 0x11cb, 0xddd: 0x11ff,
+	0xdde: 0x11ff, 0xddf: 0x1267, 0xde0: 0x130f, 0xde1: 0x1327, 0xde2: 0x135b, 0xde3: 0x135f,
+	0xde4: 0x13a3, 0xde5: 0x13a7, 0xde6: 0x13ff, 0xde7: 0x1407, 0xde8: 0x14db, 0xde9: 0x151f,
+	0xdea: 0x1537, 0xdeb: 0x0b9b, 0xdec: 0x171e, 0xded: 0x11e3,
+	0xdf0: 0x06df, 0xdf1: 0x07e3, 0xdf2: 0x07a3, 0xdf3: 0x074b, 0xdf4: 0x078b, 0xdf5: 0x07b7,
+	0xdf6: 0x0847, 0xdf7: 0x0863, 0xdf8: 0x094b, 0xdf9: 0x0937, 0xdfa: 0x0947, 0xdfb: 0x0963,
+	0xdfc: 0x09af, 0xdfd: 0x09bf, 0xdfe: 0x0a03, 0xdff: 0x0a0f,
+	// Block 0x38, offset 0xe00
+	0xe00: 0x0a2b, 0xe01: 0x0a3b, 0xe02: 0x0b23, 0xe03: 0x0b2b, 0xe04: 0x0b5b, 0xe05: 0x0b7b,
+	0xe06: 0x0bab, 0xe07: 0x0bc3, 0xe08: 0x0bb3, 0xe09: 0x0bd3, 0xe0a: 0x0bc7, 0xe0b: 0x0beb,
+	0xe0c: 0x0c07, 0xe0d: 0x0c5f, 0xe0e: 0x0c6b, 0xe0f: 0x0c73, 0xe10: 0x0c9b, 0xe11: 0x0cdf,
+	0xe12: 0x0d0f, 0xe13: 0x0d13, 0xe14: 0x0d27, 0xe15: 0x0da7, 0xe16: 0x0db7, 0xe17: 0x0e0f,
+	0xe18: 0x0e5b, 0xe19: 0x0e53, 0xe1a: 0x0e67, 0xe1b: 0x0e83, 0xe1c: 0x0ebb, 0xe1d: 0x1013,
+	0xe1e: 0x0edf, 0xe1f: 0x0f13, 0xe20: 0x0f1f, 0xe21: 0x0f5f, 0xe22: 0x0f7b, 0xe23: 0x0f9f,
+	0xe24: 0x0fc3, 0xe25: 0x0fc7, 0xe26: 0x0fe3, 0xe27: 0x0fe7, 0xe28: 0x0ff7, 0xe29: 0x100b,
+	0xe2a: 0x1007, 0xe2b: 0x1037, 0xe2c: 0x10b3, 0xe2d: 0x10cb, 0xe2e: 0x10e3, 0xe2f: 0x111b,
+	0xe30: 0x112f, 0xe31: 0x114b, 0xe32: 0x117b, 0xe33: 0x122f, 0xe34: 0x1257, 0xe35: 0x12cb,
+	0xe36: 0x1313, 0xe37: 0x131f, 0xe38: 0x1327, 0xe39: 0x133f, 0xe3a: 0x1353, 0xe3b: 0x1343,
+	0xe3c: 0x135b, 0xe3d: 0x1357, 0xe3e: 0x134f, 0xe3f: 0x135f,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x136b, 0xe41: 0x13a7, 0xe42: 0x13e3, 0xe43: 0x1413, 0xe44: 0x144b, 0xe45: 0x146b,
+	0xe46: 0x14b7, 0xe47: 0x14db, 0xe48: 0x14fb, 0xe49: 0x150f, 0xe4a: 0x151f, 0xe4b: 0x152b,
+	0xe4c: 0x1537, 0xe4d: 0x158b, 0xe4e: 0x162b, 0xe4f: 0x16b5, 0xe50: 0x16b0, 0xe51: 0x16e2,
+	0xe52: 0x0607, 0xe53: 0x062f, 0xe54: 0x0633, 0xe55: 0x1764, 0xe56: 0x1791, 0xe57: 0x1809,
+	0xe58: 0x1617, 0xe59: 0x1627,
+	// Block 0x3a, offset 0xe80
+	0xe80: 0x19d5, 0xe81: 0x19d8, 0xe82: 0x19db, 0xe83: 0x1c08, 0xe84: 0x1c0c, 0xe85: 0x1a5f,
+	0xe86: 0x1a5f,
+	0xe93: 0x1d75, 0xe94: 0x1d66, 0xe95: 0x1d6b, 0xe96: 0x1d7a, 0xe97: 0x1d70,
+	0xe9d: 0x4390,
+	0xe9e: 0x8115, 0xe9f: 0x4402, 0xea0: 0x022d, 0xea1: 0x0215, 0xea2: 0x021e, 0xea3: 0x0221,
+	0xea4: 0x0224, 0xea5: 0x0227, 0xea6: 0x022a, 0xea7: 0x0230, 0xea8: 0x0233, 0xea9: 0x0017,
+	0xeaa: 0x43f0, 0xeab: 0x43f6, 0xeac: 0x44f4, 0xead: 0x44fc, 0xeae: 0x4348, 0xeaf: 0x434e,
+	0xeb0: 0x4354, 0xeb1: 0x435a, 0xeb2: 0x4366, 0xeb3: 0x436c, 0xeb4: 0x4372, 0xeb5: 0x437e,
+	0xeb6: 0x4384, 0xeb8: 0x438a, 0xeb9: 0x4396, 0xeba: 0x439c, 0xebb: 0x43a2,
+	0xebc: 0x43ae, 0xebe: 0x43b4,
+	// Block 0x3b, offset 0xec0
+	0xec0: 0x43ba, 0xec1: 0x43c0, 0xec3: 0x43c6, 0xec4: 0x43cc,
+	0xec6: 0x43d8, 0xec7: 0x43de, 0xec8: 0x43e4, 0xec9: 0x43ea, 0xeca: 0x43fc, 0xecb: 0x4378,
+	0xecc: 0x4360, 0xecd: 0x43a8, 0xece: 0x43d2, 0xecf: 0x1d7f, 0xed0: 0x0299, 0xed1: 0x0299,
+	0xed2: 0x02a2, 0xed3: 0x02a2, 0xed4: 0x02a2, 0xed5: 0x02a2, 0xed6: 0x02a5, 0xed7: 0x02a5,
+	0xed8: 0x02a5, 0xed9: 0x02a5, 0xeda: 0x02ab, 0xedb: 0x02ab, 0xedc: 0x02ab, 0xedd: 0x02ab,
+	0xede: 0x029f, 0xedf: 0x029f, 0xee0: 0x029f, 0xee1: 0x029f, 0xee2: 0x02a8, 0xee3: 0x02a8,
+	0xee4: 0x02a8, 0xee5: 0x02a8, 0xee6: 0x029c, 0xee7: 0x029c, 0xee8: 0x029c, 0xee9: 0x029c,
+	0xeea: 0x02cf, 0xeeb: 0x02cf, 0xeec: 0x02cf, 0xeed: 0x02cf, 0xeee: 0x02d2, 0xeef: 0x02d2,
+	0xef0: 0x02d2, 0xef1: 0x02d2, 0xef2: 0x02b1, 0xef3: 0x02b1, 0xef4: 0x02b1, 0xef5: 0x02b1,
+	0xef6: 0x02ae, 0xef7: 0x02ae, 0xef8: 0x02ae, 0xef9: 0x02ae, 0xefa: 0x02b4, 0xefb: 0x02b4,
+	0xefc: 0x02b4, 0xefd: 0x02b4, 0xefe: 0x02b7, 0xeff: 0x02b7,
+	// Block 0x3c, offset 0xf00
+	0xf00: 0x02b7, 0xf01: 0x02b7, 0xf02: 0x02c0, 0xf03: 0x02c0, 0xf04: 0x02bd, 0xf05: 0x02bd,
+	0xf06: 0x02c3, 0xf07: 0x02c3, 0xf08: 0x02ba, 0xf09: 0x02ba, 0xf0a: 0x02c9, 0xf0b: 0x02c9,
+	0xf0c: 0x02c6, 0xf0d: 0x02c6, 0xf0e: 0x02d5, 0xf0f: 0x02d5, 0xf10: 0x02d5, 0xf11: 0x02d5,
+	0xf12: 0x02db, 0xf13: 0x02db, 0xf14: 0x02db, 0xf15: 0x02db, 0xf16: 0x02e1, 0xf17: 0x02e1,
+	0xf18: 0x02e1, 0xf19: 0x02e1, 0xf1a: 0x02de, 0xf1b: 0x02de, 0xf1c: 0x02de, 0xf1d: 0x02de,
+	0xf1e: 0x02e4, 0xf1f: 0x02e4, 0xf20: 0x02e7, 0xf21: 0x02e7, 0xf22: 0x02e7, 0xf23: 0x02e7,
+	0xf24: 0x446e, 0xf25: 0x446e, 0xf26: 0x02ed, 0xf27: 0x02ed, 0xf28: 0x02ed, 0xf29: 0x02ed,
+	0xf2a: 0x02ea, 0xf2b: 0x02ea, 0xf2c: 0x02ea, 0xf2d: 0x02ea, 0xf2e: 0x0308, 0xf2f: 0x0308,
+	0xf30: 0x4468, 0xf31: 0x4468,
+	// Block 0x3d, offset 0xf40
+	0xf53: 0x02d8, 0xf54: 0x02d8, 0xf55: 0x02d8, 0xf56: 0x02d8, 0xf57: 0x02f6,
+	0xf58: 0x02f6, 0xf59: 0x02f3, 0xf5a: 0x02f3, 0xf5b: 0x02f9, 0xf5c: 0x02f9, 0xf5d: 0x204f,
+	0xf5e: 0x02ff, 0xf5f: 0x02ff, 0xf60: 0x02f0, 0xf61: 0x02f0, 0xf62: 0x02fc, 0xf63: 0x02fc,
+	0xf64: 0x0305, 0xf65: 0x0305, 0xf66: 0x0305, 0xf67: 0x0305, 0xf68: 0x028d, 0xf69: 0x028d,
+	0xf6a: 0x25aa, 0xf6b: 0x25aa, 0xf6c: 0x261a, 0xf6d: 0x261a, 0xf6e: 0x25e9, 0xf6f: 0x25e9,
+	0xf70: 0x2605, 0xf71: 0x2605, 0xf72: 0x25fe, 0xf73: 0x25fe, 0xf74: 0x260c, 0xf75: 0x260c,
+	0xf76: 0x2613, 0xf77: 0x2613, 0xf78: 0x2613, 0xf79: 0x25f0, 0xf7a: 0x25f0, 0xf7b: 0x25f0,
+	0xf7c: 0x0302, 0xf7d: 0x0302, 0xf7e: 0x0302, 0xf7f: 0x0302,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x25b1, 0xf81: 0x25b8, 0xf82: 0x25d4, 0xf83: 0x25f0, 0xf84: 0x25f7, 0xf85: 0x1d89,
+	0xf86: 0x1d8e, 0xf87: 0x1d93, 0xf88: 0x1da2, 0xf89: 0x1db1, 0xf8a: 0x1db6, 0xf8b: 0x1dbb,
+	0xf8c: 0x1dc0, 0xf8d: 0x1dc5, 0xf8e: 0x1dd4, 0xf8f: 0x1de3, 0xf90: 0x1de8, 0xf91: 0x1ded,
+	0xf92: 0x1dfc, 0xf93: 0x1e0b, 0xf94: 0x1e10, 0xf95: 0x1e15, 0xf96: 0x1e1a, 0xf97: 0x1e29,
+	0xf98: 0x1e2e, 0xf99: 0x1e3d, 0xf9a: 0x1e42, 0xf9b: 0x1e47, 0xf9c: 0x1e56, 0xf9d: 0x1e5b,
+	0xf9e: 0x1e60, 0xf9f: 0x1e6a, 0xfa0: 0x1ea6, 0xfa1: 0x1eb5, 0xfa2: 0x1ec4, 0xfa3: 0x1ec9,
+	0xfa4: 0x1ece, 0xfa5: 0x1ed8, 0xfa6: 0x1ee7, 0xfa7: 0x1eec, 0xfa8: 0x1efb, 0xfa9: 0x1f00,
+	0xfaa: 0x1f05, 0xfab: 0x1f14, 0xfac: 0x1f19, 0xfad: 0x1f28, 0xfae: 0x1f2d, 0xfaf: 0x1f32,
+	0xfb0: 0x1f37, 0xfb1: 0x1f3c, 0xfb2: 0x1f41, 0xfb3: 0x1f46, 0xfb4: 0x1f4b, 0xfb5: 0x1f50,
+	0xfb6: 0x1f55, 0xfb7: 0x1f5a, 0xfb8: 0x1f5f, 0xfb9: 0x1f64, 0xfba: 0x1f69, 0xfbb: 0x1f6e,
+	0xfbc: 0x1f73, 0xfbd: 0x1f78, 0xfbe: 0x1f7d, 0xfbf: 0x1f87,
+	// Block 0x3f, offset 0xfc0
+	0xfc0: 0x1f8c, 0xfc1: 0x1f91, 0xfc2: 0x1f96, 0xfc3: 0x1fa0, 0xfc4: 0x1fa5, 0xfc5: 0x1faf,
+	0xfc6: 0x1fb4, 0xfc7: 0x1fb9, 0xfc8: 0x1fbe, 0xfc9: 0x1fc3, 0xfca: 0x1fc8, 0xfcb: 0x1fcd,
+	0xfcc: 0x1fd2, 0xfcd: 0x1fd7, 0xfce: 0x1fe6, 0xfcf: 0x1ff5, 0xfd0: 0x1ffa, 0xfd1: 0x1fff,
+	0xfd2: 0x2004, 0xfd3: 0x2009, 0xfd4: 0x200e, 0xfd5: 0x2018, 0xfd6: 0x201d, 0xfd7: 0x2022,
+	0xfd8: 0x2031, 0xfd9: 0x2040, 0xfda: 0x2045, 0xfdb: 0x4420, 0xfdc: 0x4426, 0xfdd: 0x445c,
+	0xfde: 0x44b3, 0xfdf: 0x44ba, 0xfe0: 0x44c1, 0xfe1: 0x44c8, 0xfe2: 0x44cf, 0xfe3: 0x44d6,
+	0xfe4: 0x25c6, 0xfe5: 0x25cd, 0xfe6: 0x25d4, 0xfe7: 0x25db, 0xfe8: 0x25f0, 0xfe9: 0x25f7,
+	0xfea: 0x1d98, 0xfeb: 0x1d9d, 0xfec: 0x1da2, 0xfed: 0x1da7, 0xfee: 0x1db1, 0xfef: 0x1db6,
+	0xff0: 0x1dca, 0xff1: 0x1dcf, 0xff2: 0x1dd4, 0xff3: 0x1dd9, 0xff4: 0x1de3, 0xff5: 0x1de8,
+	0xff6: 0x1df2, 0xff7: 0x1df7, 0xff8: 0x1dfc, 0xff9: 0x1e01, 0xffa: 0x1e0b, 0xffb: 0x1e10,
+	0xffc: 0x1f3c, 0xffd: 0x1f41, 0xffe: 0x1f50, 0xfff: 0x1f55,
+	// Block 0x40, offset 0x1000
+	0x1000: 0x1f5a, 0x1001: 0x1f6e, 0x1002: 0x1f73, 0x1003: 0x1f78, 0x1004: 0x1f7d, 0x1005: 0x1f96,
+	0x1006: 0x1fa0, 0x1007: 0x1fa5, 0x1008: 0x1faa, 0x1009: 0x1fbe, 0x100a: 0x1fdc, 0x100b: 0x1fe1,
+	0x100c: 0x1fe6, 0x100d: 0x1feb, 0x100e: 0x1ff5, 0x100f: 0x1ffa, 0x1010: 0x445c, 0x1011: 0x2027,
+	0x1012: 0x202c, 0x1013: 0x2031, 0x1014: 0x2036, 0x1015: 0x2040, 0x1016: 0x2045, 0x1017: 0x25b1,
+	0x1018: 0x25b8, 0x1019: 0x25bf, 0x101a: 0x25d4, 0x101b: 0x25e2, 0x101c: 0x1d89, 0x101d: 0x1d8e,
+	0x101e: 0x1d93, 0x101f: 0x1da2, 0x1020: 0x1dac, 0x1021: 0x1dbb, 0x1022: 0x1dc0, 0x1023: 0x1dc5,
+	0x1024: 0x1dd4, 0x1025: 0x1dde, 0x1026: 0x1dfc, 0x1027: 0x1e15, 0x1028: 0x1e1a, 0x1029: 0x1e29,
+	0x102a: 0x1e2e, 0x102b: 0x1e3d, 0x102c: 0x1e47, 0x102d: 0x1e56, 0x102e: 0x1e5b, 0x102f: 0x1e60,
+	0x1030: 0x1e6a, 0x1031: 0x1ea6, 0x1032: 0x1eab, 0x1033: 0x1eb5, 0x1034: 0x1ec4, 0x1035: 0x1ec9,
+	0x1036: 0x1ece, 0x1037: 0x1ed8, 0x1038: 0x1ee7, 0x1039: 0x1efb, 0x103a: 0x1f00, 0x103b: 0x1f05,
+	0x103c: 0x1f14, 0x103d: 0x1f19, 0x103e: 0x1f28, 0x103f: 0x1f2d,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x1f32, 0x1041: 0x1f37, 0x1042: 0x1f46, 0x1043: 0x1f4b, 0x1044: 0x1f5f, 0x1045: 0x1f64,
+	0x1046: 0x1f69, 0x1047: 0x1f6e, 0x1048: 0x1f73, 0x1049: 0x1f87, 0x104a: 0x1f8c, 0x104b: 0x1f91,
+	0x104c: 0x1f96, 0x104d: 0x1f9b, 0x104e: 0x1faf, 0x104f: 0x1fb4, 0x1050: 0x1fb9, 0x1051: 0x1fbe,
+	0x1052: 0x1fcd, 0x1053: 0x1fd2, 0x1054: 0x1fd7, 0x1055: 0x1fe6, 0x1056: 0x1ff0, 0x1057: 0x1fff,
+	0x1058: 0x2004, 0x1059: 0x4450, 0x105a: 0x2018, 0x105b: 0x201d, 0x105c: 0x2022, 0x105d: 0x2031,
+	0x105e: 0x203b, 0x105f: 0x25d4, 0x1060: 0x25e2, 0x1061: 0x1da2, 0x1062: 0x1dac, 0x1063: 0x1dd4,
+	0x1064: 0x1dde, 0x1065: 0x1dfc, 0x1066: 0x1e06, 0x1067: 0x1e6a, 0x1068: 0x1e6f, 0x1069: 0x1e92,
+	0x106a: 0x1e97, 0x106b: 0x1f6e, 0x106c: 0x1f73, 0x106d: 0x1f96, 0x106e: 0x1fe6, 0x106f: 0x1ff0,
+	0x1070: 0x2031, 0x1071: 0x203b, 0x1072: 0x4504, 0x1073: 0x450c, 0x1074: 0x4514, 0x1075: 0x1ef1,
+	0x1076: 0x1ef6, 0x1077: 0x1f0a, 0x1078: 0x1f0f, 0x1079: 0x1f1e, 0x107a: 0x1f23, 0x107b: 0x1e74,
+	0x107c: 0x1e79, 0x107d: 0x1e9c, 0x107e: 0x1ea1, 0x107f: 0x1e33,
+	// Block 0x42, offset 0x1080
+	0x1080: 0x1e38, 0x1081: 0x1e1f, 0x1082: 0x1e24, 0x1083: 0x1e4c, 0x1084: 0x1e51, 0x1085: 0x1eba,
+	0x1086: 0x1ebf, 0x1087: 0x1edd, 0x1088: 0x1ee2, 0x1089: 0x1e7e, 0x108a: 0x1e83, 0x108b: 0x1e88,
+	0x108c: 0x1e92, 0x108d: 0x1e8d, 0x108e: 0x1e65, 0x108f: 0x1eb0, 0x1090: 0x1ed3, 0x1091: 0x1ef1,
+	0x1092: 0x1ef6, 0x1093: 0x1f0a, 0x1094: 0x1f0f, 0x1095: 0x1f1e, 0x1096: 0x1f23, 0x1097: 0x1e74,
+	0x1098: 0x1e79, 0x1099: 0x1e9c, 0x109a: 0x1ea1, 0x109b: 0x1e33, 0x109c: 0x1e38, 0x109d: 0x1e1f,
+	0x109e: 0x1e24, 0x109f: 0x1e4c, 0x10a0: 0x1e51, 0x10a1: 0x1eba, 0x10a2: 0x1ebf, 0x10a3: 0x1edd,
+	0x10a4: 0x1ee2, 0x10a5: 0x1e7e, 0x10a6: 0x1e83, 0x10a7: 0x1e88, 0x10a8: 0x1e92, 0x10a9: 0x1e8d,
+	0x10aa: 0x1e65, 0x10ab: 0x1eb0, 0x10ac: 0x1ed3, 0x10ad: 0x1e7e, 0x10ae: 0x1e83, 0x10af: 0x1e88,
+	0x10b0: 0x1e92, 0x10b1: 0x1e6f, 0x10b2: 0x1e97, 0x10b3: 0x1eec, 0x10b4: 0x1e56, 0x10b5: 0x1e5b,
+	0x10b6: 0x1e60, 0x10b7: 0x1e7e, 0x10b8: 0x1e83, 0x10b9: 0x1e88, 0x10ba: 0x1eec, 0x10bb: 0x1efb,
+	0x10bc: 0x4408, 0x10bd: 0x4408,
+	// Block 0x43, offset 0x10c0
+	0x10d0: 0x2311, 0x10d1: 0x2326,
+	0x10d2: 0x2326, 0x10d3: 0x232d, 0x10d4: 0x2334, 0x10d5: 0x2349, 0x10d6: 0x2350, 0x10d7: 0x2357,
+	0x10d8: 0x237a, 0x10d9: 0x237a, 0x10da: 0x239d, 0x10db: 0x2396, 0x10dc: 0x23b2, 0x10dd: 0x23a4,
+	0x10de: 0x23ab, 0x10df: 0x23ce, 0x10e0: 0x23ce, 0x10e1: 0x23c7, 0x10e2: 0x23d5, 0x10e3: 0x23d5,
+	0x10e4: 0x23ff, 0x10e5: 0x23ff, 0x10e6: 0x241b, 0x10e7: 0x23e3, 0x10e8: 0x23e3, 0x10e9: 0x23dc,
+	0x10ea: 0x23f1, 0x10eb: 0x23f1, 0x10ec: 0x23f8, 0x10ed: 0x23f8, 0x10ee: 0x2422, 0x10ef: 0x2430,
+	0x10f0: 0x2430, 0x10f1: 0x2437, 0x10f2: 0x2437, 0x10f3: 0x243e, 0x10f4: 0x2445, 0x10f5: 0x244c,
+	0x10f6: 0x2453, 0x10f7: 0x2453, 0x10f8: 0x245a, 0x10f9: 0x2468, 0x10fa: 0x2476, 0x10fb: 0x246f,
+	0x10fc: 0x247d, 0x10fd: 0x247d, 0x10fe: 0x2492, 0x10ff: 0x2499,
+	// Block 0x44, offset 0x1100
+	0x1100: 0x24ca, 0x1101: 0x24d8, 0x1102: 0x24d1, 0x1103: 0x24b5, 0x1104: 0x24b5, 0x1105: 0x24df,
+	0x1106: 0x24df, 0x1107: 0x24e6, 0x1108: 0x24e6, 0x1109: 0x2510, 0x110a: 0x2517, 0x110b: 0x251e,
+	0x110c: 0x24f4, 0x110d: 0x2502, 0x110e: 0x2525, 0x110f: 0x252c,
+	0x1112: 0x24fb, 0x1113: 0x2580, 0x1114: 0x2587, 0x1115: 0x255d, 0x1116: 0x2564, 0x1117: 0x2548,
+	0x1118: 0x2548, 0x1119: 0x254f, 0x111a: 0x2579, 0x111b: 0x2572, 0x111c: 0x259c, 0x111d: 0x259c,
+	0x111e: 0x230a, 0x111f: 0x231f, 0x1120: 0x2318, 0x1121: 0x2342, 0x1122: 0x233b, 0x1123: 0x2365,
+	0x1124: 0x235e, 0x1125: 0x2388, 0x1126: 0x236c, 0x1127: 0x2381, 0x1128: 0x23b9, 0x1129: 0x2406,
+	0x112a: 0x23ea, 0x112b: 0x2429, 0x112c: 0x24c3, 0x112d: 0x24ed, 0x112e: 0x2595, 0x112f: 0x258e,
+	0x1130: 0x25a3, 0x1131: 0x253a, 0x1132: 0x24a0, 0x1133: 0x256b, 0x1134: 0x2492, 0x1135: 0x24ca,
+	0x1136: 0x2461, 0x1137: 0x24ae, 0x1138: 0x2541, 0x1139: 0x2533, 0x113a: 0x24bc, 0x113b: 0x24a7,
+	0x113c: 0x24bc, 0x113d: 0x2541, 0x113e: 0x2373, 0x113f: 0x238f,
+	// Block 0x45, offset 0x1140
+	0x1140: 0x2509, 0x1141: 0x2484, 0x1142: 0x2303, 0x1143: 0x24a7, 0x1144: 0x244c, 0x1145: 0x241b,
+	0x1146: 0x23c0, 0x1147: 0x2556,
+	0x1170: 0x2414, 0x1171: 0x248b, 0x1172: 0x27bf, 0x1173: 0x27b6, 0x1174: 0x27ec, 0x1175: 0x27da,
+	0x1176: 0x27c8, 0x1177: 0x27e3, 0x1178: 0x27f5, 0x1179: 0x240d, 0x117a: 0x2c7c, 0x117b: 0x2afc,
+	0x117c: 0x27d1,
+	// Block 0x46, offset 0x1180
+	0x1190: 0x0019, 0x1191: 0x0483,
+	0x1192: 0x0487, 0x1193: 0x0035, 0x1194: 0x0037, 0x1195: 0x0003, 0x1196: 0x003f, 0x1197: 0x04bf,
+	0x1198: 0x04c3, 0x1199: 0x1b5c,
+	0x11a0: 0x8132, 0x11a1: 0x8132, 0x11a2: 0x8132, 0x11a3: 0x8132,
+	0x11a4: 0x8132, 0x11a5: 0x8132, 0x11a6: 0x8132, 0x11a7: 0x812d, 0x11a8: 0x812d, 0x11a9: 0x812d,
+	0x11aa: 0x812d, 0x11ab: 0x812d, 0x11ac: 0x812d, 0x11ad: 0x812d, 0x11ae: 0x8132, 0x11af: 0x8132,
+	0x11b0: 0x1873, 0x11b1: 0x0443, 0x11b2: 0x043f, 0x11b3: 0x007f, 0x11b4: 0x007f, 0x11b5: 0x0011,
+	0x11b6: 0x0013, 0x11b7: 0x00b7, 0x11b8: 0x00bb, 0x11b9: 0x04b7, 0x11ba: 0x04bb, 0x11bb: 0x04ab,
+	0x11bc: 0x04af, 0x11bd: 0x0493, 0x11be: 0x0497, 0x11bf: 0x048b,
+	// Block 0x47, offset 0x11c0
+	0x11c0: 0x048f, 0x11c1: 0x049b, 0x11c2: 0x049f, 0x11c3: 0x04a3, 0x11c4: 0x04a7,
+	0x11c7: 0x0077, 0x11c8: 0x007b, 0x11c9: 0x4269, 0x11ca: 0x4269, 0x11cb: 0x4269,
+	0x11cc: 0x4269, 0x11cd: 0x007f, 0x11ce: 0x007f, 0x11cf: 0x007f, 0x11d0: 0x0019, 0x11d1: 0x0483,
+	0x11d2: 0x001d, 0x11d4: 0x0037, 0x11d5: 0x0035, 0x11d6: 0x003f, 0x11d7: 0x0003,
+	0x11d8: 0x0443, 0x11d9: 0x0011, 0x11da: 0x0013, 0x11db: 0x00b7, 0x11dc: 0x00bb, 0x11dd: 0x04b7,
+	0x11de: 0x04bb, 0x11df: 0x0007, 0x11e0: 0x000d, 0x11e1: 0x0015, 0x11e2: 0x0017, 0x11e3: 0x001b,
+	0x11e4: 0x0039, 0x11e5: 0x003d, 0x11e6: 0x003b, 0x11e8: 0x0079, 0x11e9: 0x0009,
+	0x11ea: 0x000b, 0x11eb: 0x0041,
+	0x11f0: 0x42aa, 0x11f1: 0x442c, 0x11f2: 0x42af, 0x11f4: 0x42b4,
+	0x11f6: 0x42b9, 0x11f7: 0x4432, 0x11f8: 0x42be, 0x11f9: 0x4438, 0x11fa: 0x42c3, 0x11fb: 0x443e,
+	0x11fc: 0x42c8, 0x11fd: 0x4444, 0x11fe: 0x42cd, 0x11ff: 0x444a,
+	// Block 0x48, offset 0x1200
+	0x1200: 0x0236, 0x1201: 0x440e, 0x1202: 0x440e, 0x1203: 0x4414, 0x1204: 0x4414, 0x1205: 0x4456,
+	0x1206: 0x4456, 0x1207: 0x441a, 0x1208: 0x441a, 0x1209: 0x4462, 0x120a: 0x4462, 0x120b: 0x4462,
+	0x120c: 0x4462, 0x120d: 0x0239, 0x120e: 0x0239, 0x120f: 0x023c, 0x1210: 0x023c, 0x1211: 0x023c,
+	0x1212: 0x023c, 0x1213: 0x023f, 0x1214: 0x023f, 0x1215: 0x0242, 0x1216: 0x0242, 0x1217: 0x0242,
+	0x1218: 0x0242, 0x1219: 0x0245, 0x121a: 0x0245, 0x121b: 0x0245, 0x121c: 0x0245, 0x121d: 0x0248,
+	0x121e: 0x0248, 0x121f: 0x0248, 0x1220: 0x0248, 0x1221: 0x024b, 0x1222: 0x024b, 0x1223: 0x024b,
+	0x1224: 0x024b, 0x1225: 0x024e, 0x1226: 0x024e, 0x1227: 0x024e, 0x1228: 0x024e, 0x1229: 0x0251,
+	0x122a: 0x0251, 0x122b: 0x0254, 0x122c: 0x0254, 0x122d: 0x0257, 0x122e: 0x0257, 0x122f: 0x025a,
+	0x1230: 0x025a, 0x1231: 0x025d, 0x1232: 0x025d, 0x1233: 0x025d, 0x1234: 0x025d, 0x1235: 0x0260,
+	0x1236: 0x0260, 0x1237: 0x0260, 0x1238: 0x0260, 0x1239: 0x0263, 0x123a: 0x0263, 0x123b: 0x0263,
+	0x123c: 0x0263, 0x123d: 0x0266, 0x123e: 0x0266, 0x123f: 0x0266,
+	// Block 0x49, offset 0x1240
+	0x1240: 0x0266, 0x1241: 0x0269, 0x1242: 0x0269, 0x1243: 0x0269, 0x1244: 0x0269, 0x1245: 0x026c,
+	0x1246: 0x026c, 0x1247: 0x026c, 0x1248: 0x026c, 0x1249: 0x026f, 0x124a: 0x026f, 0x124b: 0x026f,
+	0x124c: 0x026f, 0x124d: 0x0272, 0x124e: 0x0272, 0x124f: 0x0272, 0x1250: 0x0272, 0x1251: 0x0275,
+	0x1252: 0x0275, 0x1253: 0x0275, 0x1254: 0x0275, 0x1255: 0x0278, 0x1256: 0x0278, 0x1257: 0x0278,
+	0x1258: 0x0278, 0x1259: 0x027b, 0x125a: 0x027b, 0x125b: 0x027b, 0x125c: 0x027b, 0x125d: 0x027e,
+	0x125e: 0x027e, 0x125f: 0x027e, 0x1260: 0x027e, 0x1261: 0x0281, 0x1262: 0x0281, 0x1263: 0x0281,
+	0x1264: 0x0281, 0x1265: 0x0284, 0x1266: 0x0284, 0x1267: 0x0284, 0x1268: 0x0284, 0x1269: 0x0287,
+	0x126a: 0x0287, 0x126b: 0x0287, 0x126c: 0x0287, 0x126d: 0x028a, 0x126e: 0x028a, 0x126f: 0x028d,
+	0x1270: 0x028d, 0x1271: 0x0290, 0x1272: 0x0290, 0x1273: 0x0290, 0x1274: 0x0290, 0x1275: 0x2e00,
+	0x1276: 0x2e00, 0x1277: 0x2e08, 0x1278: 0x2e08, 0x1279: 0x2e10, 0x127a: 0x2e10, 0x127b: 0x1f82,
+	0x127c: 0x1f82,
+	// Block 0x4a, offset 0x1280
+	0x1280: 0x0081, 0x1281: 0x0083, 0x1282: 0x0085, 0x1283: 0x0087, 0x1284: 0x0089, 0x1285: 0x008b,
+	0x1286: 0x008d, 0x1287: 0x008f, 0x1288: 0x0091, 0x1289: 0x0093, 0x128a: 0x0095, 0x128b: 0x0097,
+	0x128c: 0x0099, 0x128d: 0x009b, 0x128e: 0x009d, 0x128f: 0x009f, 0x1290: 0x00a1, 0x1291: 0x00a3,
+	0x1292: 0x00a5, 0x1293: 0x00a7, 0x1294: 0x00a9, 0x1295: 0x00ab, 0x1296: 0x00ad, 0x1297: 0x00af,
+	0x1298: 0x00b1, 0x1299: 0x00b3, 0x129a: 0x00b5, 0x129b: 0x00b7, 0x129c: 0x00b9, 0x129d: 0x00bb,
+	0x129e: 0x00bd, 0x129f: 0x0477, 0x12a0: 0x047b, 0x12a1: 0x0487, 0x12a2: 0x049b, 0x12a3: 0x049f,
+	0x12a4: 0x0483, 0x12a5: 0x05ab, 0x12a6: 0x05a3, 0x12a7: 0x04c7, 0x12a8: 0x04cf, 0x12a9: 0x04d7,
+	0x12aa: 0x04df, 0x12ab: 0x04e7, 0x12ac: 0x056b, 0x12ad: 0x0573, 0x12ae: 0x057b, 0x12af: 0x051f,
+	0x12b0: 0x05af, 0x12b1: 0x04cb, 0x12b2: 0x04d3, 0x12b3: 0x04db, 0x12b4: 0x04e3, 0x12b5: 0x04eb,
+	0x12b6: 0x04ef, 0x12b7: 0x04f3, 0x12b8: 0x04f7, 0x12b9: 0x04fb, 0x12ba: 0x04ff, 0x12bb: 0x0503,
+	0x12bc: 0x0507, 0x12bd: 0x050b, 0x12be: 0x050f, 0x12bf: 0x0513,
+	// Block 0x4b, offset 0x12c0
+	0x12c0: 0x0517, 0x12c1: 0x051b, 0x12c2: 0x0523, 0x12c3: 0x0527, 0x12c4: 0x052b, 0x12c5: 0x052f,
+	0x12c6: 0x0533, 0x12c7: 0x0537, 0x12c8: 0x053b, 0x12c9: 0x053f, 0x12ca: 0x0543, 0x12cb: 0x0547,
+	0x12cc: 0x054b, 0x12cd: 0x054f, 0x12ce: 0x0553, 0x12cf: 0x0557, 0x12d0: 0x055b, 0x12d1: 0x055f,
+	0x12d2: 0x0563, 0x12d3: 0x0567, 0x12d4: 0x056f, 0x12d5: 0x0577, 0x12d6: 0x057f, 0x12d7: 0x0583,
+	0x12d8: 0x0587, 0x12d9: 0x058b, 0x12da: 0x058f, 0x12db: 0x0593, 0x12dc: 0x0597, 0x12dd: 0x05a7,
+	0x12de: 0x4a78, 0x12df: 0x4a7e, 0x12e0: 0x03c3, 0x12e1: 0x0313, 0x12e2: 0x0317, 0x12e3: 0x4a3b,
+	0x12e4: 0x031b, 0x12e5: 0x4a41, 0x12e6: 0x4a47, 0x12e7: 0x031f, 0x12e8: 0x0323, 0x12e9: 0x0327,
+	0x12ea: 0x4a4d, 0x12eb: 0x4a53, 0x12ec: 0x4a59, 0x12ed: 0x4a5f, 0x12ee: 0x4a65, 0x12ef: 0x4a6b,
+	0x12f0: 0x0367, 0x12f1: 0x032b, 0x12f2: 0x032f, 0x12f3: 0x0333, 0x12f4: 0x037b, 0x12f5: 0x0337,
+	0x12f6: 0x033b, 0x12f7: 0x033f, 0x12f8: 0x0343, 0x12f9: 0x0347, 0x12fa: 0x034b, 0x12fb: 0x034f,
+	0x12fc: 0x0353, 0x12fd: 0x0357, 0x12fe: 0x035b,
+	// Block 0x4c, offset 0x1300
+	0x1302: 0x49bd, 0x1303: 0x49c3, 0x1304: 0x49c9, 0x1305: 0x49cf,
+	0x1306: 0x49d5, 0x1307: 0x49db, 0x130a: 0x49e1, 0x130b: 0x49e7,
+	0x130c: 0x49ed, 0x130d: 0x49f3, 0x130e: 0x49f9, 0x130f: 0x49ff,
+	0x1312: 0x4a05, 0x1313: 0x4a0b, 0x1314: 0x4a11, 0x1315: 0x4a17, 0x1316: 0x4a1d, 0x1317: 0x4a23,
+	0x131a: 0x4a29, 0x131b: 0x4a2f, 0x131c: 0x4a35,
+	0x1320: 0x00bf, 0x1321: 0x00c2, 0x1322: 0x00cb, 0x1323: 0x4264,
+	0x1324: 0x00c8, 0x1325: 0x00c5, 0x1326: 0x0447, 0x1328: 0x046b, 0x1329: 0x044b,
+	0x132a: 0x044f, 0x132b: 0x0453, 0x132c: 0x0457, 0x132d: 0x046f, 0x132e: 0x0473,
+	// Block 0x4d, offset 0x1340
+	0x1340: 0x0063, 0x1341: 0x0065, 0x1342: 0x0067, 0x1343: 0x0069, 0x1344: 0x006b, 0x1345: 0x006d,
+	0x1346: 0x006f, 0x1347: 0x0071, 0x1348: 0x0073, 0x1349: 0x0075, 0x134a: 0x0083, 0x134b: 0x0085,
+	0x134c: 0x0087, 0x134d: 0x0089, 0x134e: 0x008b, 0x134f: 0x008d, 0x1350: 0x008f, 0x1351: 0x0091,
+	0x1352: 0x0093, 0x1353: 0x0095, 0x1354: 0x0097, 0x1355: 0x0099, 0x1356: 0x009b, 0x1357: 0x009d,
+	0x1358: 0x009f, 0x1359: 0x00a1, 0x135a: 0x00a3, 0x135b: 0x00a5, 0x135c: 0x00a7, 0x135d: 0x00a9,
+	0x135e: 0x00ab, 0x135f: 0x00ad, 0x1360: 0x00af, 0x1361: 0x00b1, 0x1362: 0x00b3, 0x1363: 0x00b5,
+	0x1364: 0x00dd, 0x1365: 0x00f2, 0x1368: 0x0173, 0x1369: 0x0176,
+	0x136a: 0x0179, 0x136b: 0x017c, 0x136c: 0x017f, 0x136d: 0x0182, 0x136e: 0x0185, 0x136f: 0x0188,
+	0x1370: 0x018b, 0x1371: 0x018e, 0x1372: 0x0191, 0x1373: 0x0194, 0x1374: 0x0197, 0x1375: 0x019a,
+	0x1376: 0x019d, 0x1377: 0x01a0, 0x1378: 0x01a3, 0x1379: 0x0188, 0x137a: 0x01a6, 0x137b: 0x01a9,
+	0x137c: 0x01ac, 0x137d: 0x01af, 0x137e: 0x01b2, 0x137f: 0x01b5,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x01fd, 0x1381: 0x0200, 0x1382: 0x0203, 0x1383: 0x045b, 0x1384: 0x01c7, 0x1385: 0x01d0,
+	0x1386: 0x01d6, 0x1387: 0x01fa, 0x1388: 0x01eb, 0x1389: 0x01e8, 0x138a: 0x0206, 0x138b: 0x0209,
+	0x138e: 0x0021, 0x138f: 0x0023, 0x1390: 0x0025, 0x1391: 0x0027,
+	0x1392: 0x0029, 0x1393: 0x002b, 0x1394: 0x002d, 0x1395: 0x002f, 0x1396: 0x0031, 0x1397: 0x0033,
+	0x1398: 0x0021, 0x1399: 0x0023, 0x139a: 0x0025, 0x139b: 0x0027, 0x139c: 0x0029, 0x139d: 0x002b,
+	0x139e: 0x002d, 0x139f: 0x002f, 0x13a0: 0x0031, 0x13a1: 0x0033, 0x13a2: 0x0021, 0x13a3: 0x0023,
+	0x13a4: 0x0025, 0x13a5: 0x0027, 0x13a6: 0x0029, 0x13a7: 0x002b, 0x13a8: 0x002d, 0x13a9: 0x002f,
+	0x13aa: 0x0031, 0x13ab: 0x0033, 0x13ac: 0x0021, 0x13ad: 0x0023, 0x13ae: 0x0025, 0x13af: 0x0027,
+	0x13b0: 0x0029, 0x13b1: 0x002b, 0x13b2: 0x002d, 0x13b3: 0x002f, 0x13b4: 0x0031, 0x13b5: 0x0033,
+	0x13b6: 0x0021, 0x13b7: 0x0023, 0x13b8: 0x0025, 0x13b9: 0x0027, 0x13ba: 0x0029, 0x13bb: 0x002b,
+	0x13bc: 0x002d, 0x13bd: 0x002f, 0x13be: 0x0031, 0x13bf: 0x0033,
+	// Block 0x4f, offset 0x13c0
+	0x13c0: 0x0239, 0x13c1: 0x023c, 0x13c2: 0x0248, 0x13c3: 0x0251, 0x13c5: 0x028a,
+	0x13c6: 0x025a, 0x13c7: 0x024b, 0x13c8: 0x0269, 0x13c9: 0x0290, 0x13ca: 0x027b, 0x13cb: 0x027e,
+	0x13cc: 0x0281, 0x13cd: 0x0284, 0x13ce: 0x025d, 0x13cf: 0x026f, 0x13d0: 0x0275, 0x13d1: 0x0263,
+	0x13d2: 0x0278, 0x13d3: 0x0257, 0x13d4: 0x0260, 0x13d5: 0x0242, 0x13d6: 0x0245, 0x13d7: 0x024e,
+	0x13d8: 0x0254, 0x13d9: 0x0266, 0x13da: 0x026c, 0x13db: 0x0272, 0x13dc: 0x0293, 0x13dd: 0x02e4,
+	0x13de: 0x02cc, 0x13df: 0x0296, 0x13e1: 0x023c, 0x13e2: 0x0248,
+	0x13e4: 0x0287, 0x13e7: 0x024b, 0x13e9: 0x0290,
+	0x13ea: 0x027b, 0x13eb: 0x027e, 0x13ec: 0x0281, 0x13ed: 0x0284, 0x13ee: 0x025d, 0x13ef: 0x026f,
+	0x13f0: 0x0275, 0x13f1: 0x0263, 0x13f2: 0x0278, 0x13f4: 0x0260, 0x13f5: 0x0242,
+	0x13f6: 0x0245, 0x13f7: 0x024e, 0x13f9: 0x0266, 0x13fb: 0x0272,
+	// Block 0x50, offset 0x1400
+	0x1402: 0x0248,
+	0x1407: 0x024b, 0x1409: 0x0290, 0x140b: 0x027e,
+	0x140d: 0x0284, 0x140e: 0x025d, 0x140f: 0x026f, 0x1411: 0x0263,
+	0x1412: 0x0278, 0x1414: 0x0260, 0x1417: 0x024e,
+	0x1419: 0x0266, 0x141b: 0x0272, 0x141d: 0x02e4,
+	0x141f: 0x0296, 0x1421: 0x023c, 0x1422: 0x0248,
+	0x1424: 0x0287, 0x1427: 0x024b, 0x1428: 0x0269, 0x1429: 0x0290,
+	0x142a: 0x027b, 0x142c: 0x0281, 0x142d: 0x0284, 0x142e: 0x025d, 0x142f: 0x026f,
+	0x1430: 0x0275, 0x1431: 0x0263, 0x1432: 0x0278, 0x1434: 0x0260, 0x1435: 0x0242,
+	0x1436: 0x0245, 0x1437: 0x024e, 0x1439: 0x0266, 0x143a: 0x026c, 0x143b: 0x0272,
+	0x143c: 0x0293, 0x143e: 0x02cc,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x0239, 0x1441: 0x023c, 0x1442: 0x0248, 0x1443: 0x0251, 0x1444: 0x0287, 0x1445: 0x028a,
+	0x1446: 0x025a, 0x1447: 0x024b, 0x1448: 0x0269, 0x1449: 0x0290, 0x144b: 0x027e,
+	0x144c: 0x0281, 0x144d: 0x0284, 0x144e: 0x025d, 0x144f: 0x026f, 0x1450: 0x0275, 0x1451: 0x0263,
+	0x1452: 0x0278, 0x1453: 0x0257, 0x1454: 0x0260, 0x1455: 0x0242, 0x1456: 0x0245, 0x1457: 0x024e,
+	0x1458: 0x0254, 0x1459: 0x0266, 0x145a: 0x026c, 0x145b: 0x0272,
+	0x1461: 0x023c, 0x1462: 0x0248, 0x1463: 0x0251,
+	0x1465: 0x028a, 0x1466: 0x025a, 0x1467: 0x024b, 0x1468: 0x0269, 0x1469: 0x0290,
+	0x146b: 0x027e, 0x146c: 0x0281, 0x146d: 0x0284, 0x146e: 0x025d, 0x146f: 0x026f,
+	0x1470: 0x0275, 0x1471: 0x0263, 0x1472: 0x0278, 0x1473: 0x0257, 0x1474: 0x0260, 0x1475: 0x0242,
+	0x1476: 0x0245, 0x1477: 0x024e, 0x1478: 0x0254, 0x1479: 0x0266, 0x147a: 0x026c, 0x147b: 0x0272,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x1879, 0x1481: 0x1876, 0x1482: 0x187c, 0x1483: 0x18a0, 0x1484: 0x18c4, 0x1485: 0x18e8,
+	0x1486: 0x190c, 0x1487: 0x1915, 0x1488: 0x191b, 0x1489: 0x1921, 0x148a: 0x1927,
+	0x1490: 0x1a8c, 0x1491: 0x1a90,
+	0x1492: 0x1a94, 0x1493: 0x1a98, 0x1494: 0x1a9c, 0x1495: 0x1aa0, 0x1496: 0x1aa4, 0x1497: 0x1aa8,
+	0x1498: 0x1aac, 0x1499: 0x1ab0, 0x149a: 0x1ab4, 0x149b: 0x1ab8, 0x149c: 0x1abc, 0x149d: 0x1ac0,
+	0x149e: 0x1ac4, 0x149f: 0x1ac8, 0x14a0: 0x1acc, 0x14a1: 0x1ad0, 0x14a2: 0x1ad4, 0x14a3: 0x1ad8,
+	0x14a4: 0x1adc, 0x14a5: 0x1ae0, 0x14a6: 0x1ae4, 0x14a7: 0x1ae8, 0x14a8: 0x1aec, 0x14a9: 0x1af0,
+	0x14aa: 0x271e, 0x14ab: 0x0047, 0x14ac: 0x0065, 0x14ad: 0x193c, 0x14ae: 0x19b1,
+	0x14b0: 0x0043, 0x14b1: 0x0045, 0x14b2: 0x0047, 0x14b3: 0x0049, 0x14b4: 0x004b, 0x14b5: 0x004d,
+	0x14b6: 0x004f, 0x14b7: 0x0051, 0x14b8: 0x0053, 0x14b9: 0x0055, 0x14ba: 0x0057, 0x14bb: 0x0059,
+	0x14bc: 0x005b, 0x14bd: 0x005d, 0x14be: 0x005f, 0x14bf: 0x0061,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x26ad, 0x14c1: 0x26c2, 0x14c2: 0x0503,
+	0x14d0: 0x0c0f, 0x14d1: 0x0a47,
+	0x14d2: 0x08d3, 0x14d3: 0x45c4, 0x14d4: 0x071b, 0x14d5: 0x09ef, 0x14d6: 0x132f, 0x14d7: 0x09ff,
+	0x14d8: 0x0727, 0x14d9: 0x0cd7, 0x14da: 0x0eaf, 0x14db: 0x0caf, 0x14dc: 0x0827, 0x14dd: 0x0b6b,
+	0x14de: 0x07bf, 0x14df: 0x0cb7, 0x14e0: 0x0813, 0x14e1: 0x1117, 0x14e2: 0x0f83, 0x14e3: 0x138b,
+	0x14e4: 0x09d3, 0x14e5: 0x090b, 0x14e6: 0x0e63, 0x14e7: 0x0c1b, 0x14e8: 0x0c47, 0x14e9: 0x06bf,
+	0x14ea: 0x06cb, 0x14eb: 0x140b, 0x14ec: 0x0adb, 0x14ed: 0x06e7, 0x14ee: 0x08ef, 0x14ef: 0x0c3b,
+	0x14f0: 0x13b3, 0x14f1: 0x0c13, 0x14f2: 0x106f, 0x14f3: 0x10ab, 0x14f4: 0x08f7, 0x14f5: 0x0e43,
+	0x14f6: 0x0d0b, 0x14f7: 0x0d07, 0x14f8: 0x0f97, 0x14f9: 0x082b, 0x14fa: 0x0957, 0x14fb: 0x1443,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x06fb, 0x1501: 0x06f3, 0x1502: 0x0703, 0x1503: 0x1647, 0x1504: 0x0747, 0x1505: 0x0757,
+	0x1506: 0x075b, 0x1507: 0x0763, 0x1508: 0x076b, 0x1509: 0x076f, 0x150a: 0x077b, 0x150b: 0x0773,
+	0x150c: 0x05b3, 0x150d: 0x165b, 0x150e: 0x078f, 0x150f: 0x0793, 0x1510: 0x0797, 0x1511: 0x07b3,
+	0x1512: 0x164c, 0x1513: 0x05b7, 0x1514: 0x079f, 0x1515: 0x07bf, 0x1516: 0x1656, 0x1517: 0x07cf,
+	0x1518: 0x07d7, 0x1519: 0x0737, 0x151a: 0x07df, 0x151b: 0x07e3, 0x151c: 0x1831, 0x151d: 0x07ff,
+	0x151e: 0x0807, 0x151f: 0x05bf, 0x1520: 0x081f, 0x1521: 0x0823, 0x1522: 0x082b, 0x1523: 0x082f,
+	0x1524: 0x05c3, 0x1525: 0x0847, 0x1526: 0x084b, 0x1527: 0x0857, 0x1528: 0x0863, 0x1529: 0x0867,
+	0x152a: 0x086b, 0x152b: 0x0873, 0x152c: 0x0893, 0x152d: 0x0897, 0x152e: 0x089f, 0x152f: 0x08af,
+	0x1530: 0x08b7, 0x1531: 0x08bb, 0x1532: 0x08bb, 0x1533: 0x08bb, 0x1534: 0x166a, 0x1535: 0x0e93,
+	0x1536: 0x08cf, 0x1537: 0x08d7, 0x1538: 0x166f, 0x1539: 0x08e3, 0x153a: 0x08eb, 0x153b: 0x08f3,
+	0x153c: 0x091b, 0x153d: 0x0907, 0x153e: 0x0913, 0x153f: 0x0917,
+	// Block 0x55, offset 0x1540
+	0x1540: 0x091f, 0x1541: 0x0927, 0x1542: 0x092b, 0x1543: 0x0933, 0x1544: 0x093b, 0x1545: 0x093f,
+	0x1546: 0x093f, 0x1547: 0x0947, 0x1548: 0x094f, 0x1549: 0x0953, 0x154a: 0x095f, 0x154b: 0x0983,
+	0x154c: 0x0967, 0x154d: 0x0987, 0x154e: 0x096b, 0x154f: 0x0973, 0x1550: 0x080b, 0x1551: 0x09cf,
+	0x1552: 0x0997, 0x1553: 0x099b, 0x1554: 0x099f, 0x1555: 0x0993, 0x1556: 0x09a7, 0x1557: 0x09a3,
+	0x1558: 0x09bb, 0x1559: 0x1674, 0x155a: 0x09d7, 0x155b: 0x09db, 0x155c: 0x09e3, 0x155d: 0x09ef,
+	0x155e: 0x09f7, 0x155f: 0x0a13, 0x1560: 0x1679, 0x1561: 0x167e, 0x1562: 0x0a1f, 0x1563: 0x0a23,
+	0x1564: 0x0a27, 0x1565: 0x0a1b, 0x1566: 0x0a2f, 0x1567: 0x05c7, 0x1568: 0x05cb, 0x1569: 0x0a37,
+	0x156a: 0x0a3f, 0x156b: 0x0a3f, 0x156c: 0x1683, 0x156d: 0x0a5b, 0x156e: 0x0a5f, 0x156f: 0x0a63,
+	0x1570: 0x0a6b, 0x1571: 0x1688, 0x1572: 0x0a73, 0x1573: 0x0a77, 0x1574: 0x0b4f, 0x1575: 0x0a7f,
+	0x1576: 0x05cf, 0x1577: 0x0a8b, 0x1578: 0x0a9b, 0x1579: 0x0aa7, 0x157a: 0x0aa3, 0x157b: 0x1692,
+	0x157c: 0x0aaf, 0x157d: 0x1697, 0x157e: 0x0abb, 0x157f: 0x0ab7,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x0abf, 0x1581: 0x0acf, 0x1582: 0x0ad3, 0x1583: 0x05d3, 0x1584: 0x0ae3, 0x1585: 0x0aeb,
+	0x1586: 0x0aef, 0x1587: 0x0af3, 0x1588: 0x05d7, 0x1589: 0x169c, 0x158a: 0x05db, 0x158b: 0x0b0f,
+	0x158c: 0x0b13, 0x158d: 0x0b17, 0x158e: 0x0b1f, 0x158f: 0x1863, 0x1590: 0x0b37, 0x1591: 0x16a6,
+	0x1592: 0x16a6, 0x1593: 0x11d7, 0x1594: 0x0b47, 0x1595: 0x0b47, 0x1596: 0x05df, 0x1597: 0x16c9,
+	0x1598: 0x179b, 0x1599: 0x0b57, 0x159a: 0x0b5f, 0x159b: 0x05e3, 0x159c: 0x0b73, 0x159d: 0x0b83,
+	0x159e: 0x0b87, 0x159f: 0x0b8f, 0x15a0: 0x0b9f, 0x15a1: 0x05eb, 0x15a2: 0x05e7, 0x15a3: 0x0ba3,
+	0x15a4: 0x16ab, 0x15a5: 0x0ba7, 0x15a6: 0x0bbb, 0x15a7: 0x0bbf, 0x15a8: 0x0bc3, 0x15a9: 0x0bbf,
+	0x15aa: 0x0bcf, 0x15ab: 0x0bd3, 0x15ac: 0x0be3, 0x15ad: 0x0bdb, 0x15ae: 0x0bdf, 0x15af: 0x0be7,
+	0x15b0: 0x0beb, 0x15b1: 0x0bef, 0x15b2: 0x0bfb, 0x15b3: 0x0bff, 0x15b4: 0x0c17, 0x15b5: 0x0c1f,
+	0x15b6: 0x0c2f, 0x15b7: 0x0c43, 0x15b8: 0x16ba, 0x15b9: 0x0c3f, 0x15ba: 0x0c33, 0x15bb: 0x0c4b,
+	0x15bc: 0x0c53, 0x15bd: 0x0c67, 0x15be: 0x16bf, 0x15bf: 0x0c6f,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0x0c63, 0x15c1: 0x0c5b, 0x15c2: 0x05ef, 0x15c3: 0x0c77, 0x15c4: 0x0c7f, 0x15c5: 0x0c87,
+	0x15c6: 0x0c7b, 0x15c7: 0x05f3, 0x15c8: 0x0c97, 0x15c9: 0x0c9f, 0x15ca: 0x16c4, 0x15cb: 0x0ccb,
+	0x15cc: 0x0cff, 0x15cd: 0x0cdb, 0x15ce: 0x05ff, 0x15cf: 0x0ce7, 0x15d0: 0x05fb, 0x15d1: 0x05f7,
+	0x15d2: 0x07c3, 0x15d3: 0x07c7, 0x15d4: 0x0d03, 0x15d5: 0x0ceb, 0x15d6: 0x11ab, 0x15d7: 0x0663,
+	0x15d8: 0x0d0f, 0x15d9: 0x0d13, 0x15da: 0x0d17, 0x15db: 0x0d2b, 0x15dc: 0x0d23, 0x15dd: 0x16dd,
+	0x15de: 0x0603, 0x15df: 0x0d3f, 0x15e0: 0x0d33, 0x15e1: 0x0d4f, 0x15e2: 0x0d57, 0x15e3: 0x16e7,
+	0x15e4: 0x0d5b, 0x15e5: 0x0d47, 0x15e6: 0x0d63, 0x15e7: 0x0607, 0x15e8: 0x0d67, 0x15e9: 0x0d6b,
+	0x15ea: 0x0d6f, 0x15eb: 0x0d7b, 0x15ec: 0x16ec, 0x15ed: 0x0d83, 0x15ee: 0x060b, 0x15ef: 0x0d8f,
+	0x15f0: 0x16f1, 0x15f1: 0x0d93, 0x15f2: 0x060f, 0x15f3: 0x0d9f, 0x15f4: 0x0dab, 0x15f5: 0x0db7,
+	0x15f6: 0x0dbb, 0x15f7: 0x16f6, 0x15f8: 0x168d, 0x15f9: 0x16fb, 0x15fa: 0x0ddb, 0x15fb: 0x1700,
+	0x15fc: 0x0de7, 0x15fd: 0x0def, 0x15fe: 0x0ddf, 0x15ff: 0x0dfb,
+	// Block 0x58, offset 0x1600
+	0x1600: 0x0e0b, 0x1601: 0x0e1b, 0x1602: 0x0e0f, 0x1603: 0x0e13, 0x1604: 0x0e1f, 0x1605: 0x0e23,
+	0x1606: 0x1705, 0x1607: 0x0e07, 0x1608: 0x0e3b, 0x1609: 0x0e3f, 0x160a: 0x0613, 0x160b: 0x0e53,
+	0x160c: 0x0e4f, 0x160d: 0x170a, 0x160e: 0x0e33, 0x160f: 0x0e6f, 0x1610: 0x170f, 0x1611: 0x1714,
+	0x1612: 0x0e73, 0x1613: 0x0e87, 0x1614: 0x0e83, 0x1615: 0x0e7f, 0x1616: 0x0617, 0x1617: 0x0e8b,
+	0x1618: 0x0e9b, 0x1619: 0x0e97, 0x161a: 0x0ea3, 0x161b: 0x1651, 0x161c: 0x0eb3, 0x161d: 0x1719,
+	0x161e: 0x0ebf, 0x161f: 0x1723, 0x1620: 0x0ed3, 0x1621: 0x0edf, 0x1622: 0x0ef3, 0x1623: 0x1728,
+	0x1624: 0x0f07, 0x1625: 0x0f0b, 0x1626: 0x172d, 0x1627: 0x1732, 0x1628: 0x0f27, 0x1629: 0x0f37,
+	0x162a: 0x061b, 0x162b: 0x0f3b, 0x162c: 0x061f, 0x162d: 0x061f, 0x162e: 0x0f53, 0x162f: 0x0f57,
+	0x1630: 0x0f5f, 0x1631: 0x0f63, 0x1632: 0x0f6f, 0x1633: 0x0623, 0x1634: 0x0f87, 0x1635: 0x1737,
+	0x1636: 0x0fa3, 0x1637: 0x173c, 0x1638: 0x0faf, 0x1639: 0x16a1, 0x163a: 0x0fbf, 0x163b: 0x1741,
+	0x163c: 0x1746, 0x163d: 0x174b, 0x163e: 0x0627, 0x163f: 0x062b,
+	// Block 0x59, offset 0x1640
+	0x1640: 0x0ff7, 0x1641: 0x1755, 0x1642: 0x1750, 0x1643: 0x175a, 0x1644: 0x175f, 0x1645: 0x0fff,
+	0x1646: 0x1003, 0x1647: 0x1003, 0x1648: 0x100b, 0x1649: 0x0633, 0x164a: 0x100f, 0x164b: 0x0637,
+	0x164c: 0x063b, 0x164d: 0x1769, 0x164e: 0x1023, 0x164f: 0x102b, 0x1650: 0x1037, 0x1651: 0x063f,
+	0x1652: 0x176e, 0x1653: 0x105b, 0x1654: 0x1773, 0x1655: 0x1778, 0x1656: 0x107b, 0x1657: 0x1093,
+	0x1658: 0x0643, 0x1659: 0x109b, 0x165a: 0x109f, 0x165b: 0x10a3, 0x165c: 0x177d, 0x165d: 0x1782,
+	0x165e: 0x1782, 0x165f: 0x10bb, 0x1660: 0x0647, 0x1661: 0x1787, 0x1662: 0x10cf, 0x1663: 0x10d3,
+	0x1664: 0x064b, 0x1665: 0x178c, 0x1666: 0x10ef, 0x1667: 0x064f, 0x1668: 0x10ff, 0x1669: 0x10f7,
+	0x166a: 0x1107, 0x166b: 0x1796, 0x166c: 0x111f, 0x166d: 0x0653, 0x166e: 0x112b, 0x166f: 0x1133,
+	0x1670: 0x1143, 0x1671: 0x0657, 0x1672: 0x17a0, 0x1673: 0x17a5, 0x1674: 0x065b, 0x1675: 0x17aa,
+	0x1676: 0x115b, 0x1677: 0x17af, 0x1678: 0x1167, 0x1679: 0x1173, 0x167a: 0x117b, 0x167b: 0x17b4,
+	0x167c: 0x17b9, 0x167d: 0x118f, 0x167e: 0x17be, 0x167f: 0x1197,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x16ce, 0x1681: 0x065f, 0x1682: 0x11af, 0x1683: 0x11b3, 0x1684: 0x0667, 0x1685: 0x11b7,
+	0x1686: 0x0a33, 0x1687: 0x17c3, 0x1688: 0x17c8, 0x1689: 0x16d3, 0x168a: 0x16d8, 0x168b: 0x11d7,
+	0x168c: 0x11db, 0x168d: 0x13f3, 0x168e: 0x066b, 0x168f: 0x1207, 0x1690: 0x1203, 0x1691: 0x120b,
+	0x1692: 0x083f, 0x1693: 0x120f, 0x1694: 0x1213, 0x1695: 0x1217, 0x1696: 0x121f, 0x1697: 0x17cd,
+	0x1698: 0x121b, 0x1699: 0x1223, 0x169a: 0x1237, 0x169b: 0x123b, 0x169c: 0x1227, 0x169d: 0x123f,
+	0x169e: 0x1253, 0x169f: 0x1267, 0x16a0: 0x1233, 0x16a1: 0x1247, 0x16a2: 0x124b, 0x16a3: 0x124f,
+	0x16a4: 0x17d2, 0x16a5: 0x17dc, 0x16a6: 0x17d7, 0x16a7: 0x066f, 0x16a8: 0x126f, 0x16a9: 0x1273,
+	0x16aa: 0x127b, 0x16ab: 0x17f0, 0x16ac: 0x127f, 0x16ad: 0x17e1, 0x16ae: 0x0673, 0x16af: 0x0677,
+	0x16b0: 0x17e6, 0x16b1: 0x17eb, 0x16b2: 0x067b, 0x16b3: 0x129f, 0x16b4: 0x12a3, 0x16b5: 0x12a7,
+	0x16b6: 0x12ab, 0x16b7: 0x12b7, 0x16b8: 0x12b3, 0x16b9: 0x12bf, 0x16ba: 0x12bb, 0x16bb: 0x12cb,
+	0x16bc: 0x12c3, 0x16bd: 0x12c7, 0x16be: 0x12cf, 0x16bf: 0x067f,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x12d7, 0x16c1: 0x12db, 0x16c2: 0x0683, 0x16c3: 0x12eb, 0x16c4: 0x12ef, 0x16c5: 0x17f5,
+	0x16c6: 0x12fb, 0x16c7: 0x12ff, 0x16c8: 0x0687, 0x16c9: 0x130b, 0x16ca: 0x05bb, 0x16cb: 0x17fa,
+	0x16cc: 0x17ff, 0x16cd: 0x068b, 0x16ce: 0x068f, 0x16cf: 0x1337, 0x16d0: 0x134f, 0x16d1: 0x136b,
+	0x16d2: 0x137b, 0x16d3: 0x1804, 0x16d4: 0x138f, 0x16d5: 0x1393, 0x16d6: 0x13ab, 0x16d7: 0x13b7,
+	0x16d8: 0x180e, 0x16d9: 0x1660, 0x16da: 0x13c3, 0x16db: 0x13bf, 0x16dc: 0x13cb, 0x16dd: 0x1665,
+	0x16de: 0x13d7, 0x16df: 0x13e3, 0x16e0: 0x1813, 0x16e1: 0x1818, 0x16e2: 0x1423, 0x16e3: 0x142f,
+	0x16e4: 0x1437, 0x16e5: 0x181d, 0x16e6: 0x143b, 0x16e7: 0x1467, 0x16e8: 0x1473, 0x16e9: 0x1477,
+	0x16ea: 0x146f, 0x16eb: 0x1483, 0x16ec: 0x1487, 0x16ed: 0x1822, 0x16ee: 0x1493, 0x16ef: 0x0693,
+	0x16f0: 0x149b, 0x16f1: 0x1827, 0x16f2: 0x0697, 0x16f3: 0x14d3, 0x16f4: 0x0ac3, 0x16f5: 0x14eb,
+	0x16f6: 0x182c, 0x16f7: 0x1836, 0x16f8: 0x069b, 0x16f9: 0x069f, 0x16fa: 0x1513, 0x16fb: 0x183b,
+	0x16fc: 0x06a3, 0x16fd: 0x1840, 0x16fe: 0x152b, 0x16ff: 0x152b,
+	// Block 0x5c, offset 0x1700
+	0x1700: 0x1533, 0x1701: 0x1845, 0x1702: 0x154b, 0x1703: 0x06a7, 0x1704: 0x155b, 0x1705: 0x1567,
+	0x1706: 0x156f, 0x1707: 0x1577, 0x1708: 0x06ab, 0x1709: 0x184a, 0x170a: 0x158b, 0x170b: 0x15a7,
+	0x170c: 0x15b3, 0x170d: 0x06af, 0x170e: 0x06b3, 0x170f: 0x15b7, 0x1710: 0x184f, 0x1711: 0x06b7,
+	0x1712: 0x1854, 0x1713: 0x1859, 0x1714: 0x185e, 0x1715: 0x15db, 0x1716: 0x06bb, 0x1717: 0x15ef,
+	0x1718: 0x15f7, 0x1719: 0x15fb, 0x171a: 0x1603, 0x171b: 0x160b, 0x171c: 0x1613, 0x171d: 0x1868,
+}
+
+// nfkcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfkcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x5b, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x5c, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x5d, 0xcb: 0x5e, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x09,
+	0xd0: 0x0a, 0xd1: 0x5f, 0xd2: 0x60, 0xd3: 0x0b, 0xd6: 0x0c, 0xd7: 0x61,
+	0xd8: 0x62, 0xd9: 0x0d, 0xdb: 0x63, 0xdc: 0x64, 0xdd: 0x65, 0xdf: 0x66,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x67, 0x121: 0x68, 0x123: 0x69, 0x124: 0x6a, 0x125: 0x6b, 0x126: 0x6c, 0x127: 0x6d,
+	0x128: 0x6e, 0x129: 0x6f, 0x12a: 0x70, 0x12b: 0x71, 0x12c: 0x6c, 0x12d: 0x72, 0x12e: 0x73, 0x12f: 0x74,
+	0x131: 0x75, 0x132: 0x76, 0x133: 0x77, 0x134: 0x78, 0x135: 0x79, 0x137: 0x7a,
+	0x138: 0x7b, 0x139: 0x7c, 0x13a: 0x7d, 0x13b: 0x7e, 0x13c: 0x7f, 0x13d: 0x80, 0x13e: 0x81, 0x13f: 0x82,
+	// Block 0x5, offset 0x140
+	0x140: 0x83, 0x142: 0x84, 0x143: 0x85, 0x144: 0x86, 0x145: 0x87, 0x146: 0x88, 0x147: 0x89,
+	0x14d: 0x8a,
+	0x15c: 0x8b, 0x15f: 0x8c,
+	0x162: 0x8d, 0x164: 0x8e,
+	0x168: 0x8f, 0x169: 0x90, 0x16a: 0x91, 0x16c: 0x0e, 0x16d: 0x92, 0x16e: 0x93, 0x16f: 0x94,
+	0x170: 0x95, 0x173: 0x96, 0x174: 0x97, 0x175: 0x0f, 0x176: 0x10, 0x177: 0x11,
+	0x178: 0x12, 0x179: 0x13, 0x17a: 0x14, 0x17b: 0x15, 0x17c: 0x16, 0x17d: 0x17, 0x17e: 0x18, 0x17f: 0x19,
+	// Block 0x6, offset 0x180
+	0x180: 0x98, 0x181: 0x99, 0x182: 0x9a, 0x183: 0x9b, 0x184: 0x1a, 0x185: 0x1b, 0x186: 0x9c, 0x187: 0x9d,
+	0x188: 0x9e, 0x189: 0x1c, 0x18a: 0x1d, 0x18b: 0x9f, 0x18c: 0xa0,
+	0x191: 0x1e, 0x192: 0x1f, 0x193: 0xa1,
+	0x1a8: 0xa2, 0x1a9: 0xa3, 0x1ab: 0xa4,
+	0x1b1: 0xa5, 0x1b3: 0xa6, 0x1b5: 0xa7, 0x1b7: 0xa8,
+	0x1ba: 0xa9, 0x1bb: 0xaa, 0x1bc: 0x20, 0x1bd: 0x21, 0x1be: 0x22, 0x1bf: 0xab,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0xac, 0x1c1: 0x23, 0x1c2: 0x24, 0x1c3: 0x25, 0x1c4: 0xad, 0x1c5: 0x26, 0x1c6: 0x27,
+	0x1c8: 0x28, 0x1c9: 0x29, 0x1ca: 0x2a, 0x1cb: 0x2b, 0x1cc: 0x2c, 0x1cd: 0x2d, 0x1ce: 0x2e, 0x1cf: 0x2f,
+	// Block 0x8, offset 0x200
+	0x219: 0xae, 0x21a: 0xaf, 0x21b: 0xb0, 0x21d: 0xb1, 0x21f: 0xb2,
+	0x220: 0xb3, 0x223: 0xb4, 0x224: 0xb5, 0x225: 0xb6, 0x226: 0xb7, 0x227: 0xb8,
+	0x22a: 0xb9, 0x22b: 0xba, 0x22d: 0xbb, 0x22f: 0xbc,
+	0x230: 0xbd, 0x231: 0xbe, 0x232: 0xbf, 0x233: 0xc0, 0x234: 0xc1, 0x235: 0xc2, 0x236: 0xc3, 0x237: 0xbd,
+	0x238: 0xbe, 0x239: 0xbf, 0x23a: 0xc0, 0x23b: 0xc1, 0x23c: 0xc2, 0x23d: 0xc3, 0x23e: 0xbd, 0x23f: 0xbe,
+	// Block 0x9, offset 0x240
+	0x240: 0xbf, 0x241: 0xc0, 0x242: 0xc1, 0x243: 0xc2, 0x244: 0xc3, 0x245: 0xbd, 0x246: 0xbe, 0x247: 0xbf,
+	0x248: 0xc0, 0x249: 0xc1, 0x24a: 0xc2, 0x24b: 0xc3, 0x24c: 0xbd, 0x24d: 0xbe, 0x24e: 0xbf, 0x24f: 0xc0,
+	0x250: 0xc1, 0x251: 0xc2, 0x252: 0xc3, 0x253: 0xbd, 0x254: 0xbe, 0x255: 0xbf, 0x256: 0xc0, 0x257: 0xc1,
+	0x258: 0xc2, 0x259: 0xc3, 0x25a: 0xbd, 0x25b: 0xbe, 0x25c: 0xbf, 0x25d: 0xc0, 0x25e: 0xc1, 0x25f: 0xc2,
+	0x260: 0xc3, 0x261: 0xbd, 0x262: 0xbe, 0x263: 0xbf, 0x264: 0xc0, 0x265: 0xc1, 0x266: 0xc2, 0x267: 0xc3,
+	0x268: 0xbd, 0x269: 0xbe, 0x26a: 0xbf, 0x26b: 0xc0, 0x26c: 0xc1, 0x26d: 0xc2, 0x26e: 0xc3, 0x26f: 0xbd,
+	0x270: 0xbe, 0x271: 0xbf, 0x272: 0xc0, 0x273: 0xc1, 0x274: 0xc2, 0x275: 0xc3, 0x276: 0xbd, 0x277: 0xbe,
+	0x278: 0xbf, 0x279: 0xc0, 0x27a: 0xc1, 0x27b: 0xc2, 0x27c: 0xc3, 0x27d: 0xbd, 0x27e: 0xbe, 0x27f: 0xbf,
+	// Block 0xa, offset 0x280
+	0x280: 0xc0, 0x281: 0xc1, 0x282: 0xc2, 0x283: 0xc3, 0x284: 0xbd, 0x285: 0xbe, 0x286: 0xbf, 0x287: 0xc0,
+	0x288: 0xc1, 0x289: 0xc2, 0x28a: 0xc3, 0x28b: 0xbd, 0x28c: 0xbe, 0x28d: 0xbf, 0x28e: 0xc0, 0x28f: 0xc1,
+	0x290: 0xc2, 0x291: 0xc3, 0x292: 0xbd, 0x293: 0xbe, 0x294: 0xbf, 0x295: 0xc0, 0x296: 0xc1, 0x297: 0xc2,
+	0x298: 0xc3, 0x299: 0xbd, 0x29a: 0xbe, 0x29b: 0xbf, 0x29c: 0xc0, 0x29d: 0xc1, 0x29e: 0xc2, 0x29f: 0xc3,
+	0x2a0: 0xbd, 0x2a1: 0xbe, 0x2a2: 0xbf, 0x2a3: 0xc0, 0x2a4: 0xc1, 0x2a5: 0xc2, 0x2a6: 0xc3, 0x2a7: 0xbd,
+	0x2a8: 0xbe, 0x2a9: 0xbf, 0x2aa: 0xc0, 0x2ab: 0xc1, 0x2ac: 0xc2, 0x2ad: 0xc3, 0x2ae: 0xbd, 0x2af: 0xbe,
+	0x2b0: 0xbf, 0x2b1: 0xc0, 0x2b2: 0xc1, 0x2b3: 0xc2, 0x2b4: 0xc3, 0x2b5: 0xbd, 0x2b6: 0xbe, 0x2b7: 0xbf,
+	0x2b8: 0xc0, 0x2b9: 0xc1, 0x2ba: 0xc2, 0x2bb: 0xc3, 0x2bc: 0xbd, 0x2bd: 0xbe, 0x2be: 0xbf, 0x2bf: 0xc0,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0xc1, 0x2c1: 0xc2, 0x2c2: 0xc3, 0x2c3: 0xbd, 0x2c4: 0xbe, 0x2c5: 0xbf, 0x2c6: 0xc0, 0x2c7: 0xc1,
+	0x2c8: 0xc2, 0x2c9: 0xc3, 0x2ca: 0xbd, 0x2cb: 0xbe, 0x2cc: 0xbf, 0x2cd: 0xc0, 0x2ce: 0xc1, 0x2cf: 0xc2,
+	0x2d0: 0xc3, 0x2d1: 0xbd, 0x2d2: 0xbe, 0x2d3: 0xbf, 0x2d4: 0xc0, 0x2d5: 0xc1, 0x2d6: 0xc2, 0x2d7: 0xc3,
+	0x2d8: 0xbd, 0x2d9: 0xbe, 0x2da: 0xbf, 0x2db: 0xc0, 0x2dc: 0xc1, 0x2dd: 0xc2, 0x2de: 0xc4,
+	// Block 0xc, offset 0x300
+	0x324: 0x30, 0x325: 0x31, 0x326: 0x32, 0x327: 0x33,
+	0x328: 0x34, 0x329: 0x35, 0x32a: 0x36, 0x32b: 0x37, 0x32c: 0x38, 0x32d: 0x39, 0x32e: 0x3a, 0x32f: 0x3b,
+	0x330: 0x3c, 0x331: 0x3d, 0x332: 0x3e, 0x333: 0x3f, 0x334: 0x40, 0x335: 0x41, 0x336: 0x42, 0x337: 0x43,
+	0x338: 0x44, 0x339: 0x45, 0x33a: 0x46, 0x33b: 0x47, 0x33c: 0xc5, 0x33d: 0x48, 0x33e: 0x49, 0x33f: 0x4a,
+	// Block 0xd, offset 0x340
+	0x347: 0xc6,
+	0x34b: 0xc7, 0x34d: 0xc8,
+	0x368: 0xc9, 0x36b: 0xca,
+	// Block 0xe, offset 0x380
+	0x381: 0xcb, 0x382: 0xcc, 0x384: 0xcd, 0x385: 0xb7, 0x387: 0xce,
+	0x388: 0xcf, 0x38b: 0xd0, 0x38c: 0x6c, 0x38d: 0xd1,
+	0x391: 0xd2, 0x392: 0xd3, 0x393: 0xd4, 0x396: 0xd5, 0x397: 0xd6,
+	0x398: 0xd7, 0x39a: 0xd8, 0x39c: 0xd9,
+	0x3a8: 0xda, 0x3a9: 0xdb, 0x3aa: 0xdc,
+	0x3b0: 0xd7, 0x3b5: 0xdd,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xde, 0x3ec: 0xdf,
+	// Block 0x10, offset 0x400
+	0x432: 0xe0,
+	// Block 0x11, offset 0x440
+	0x445: 0xe1, 0x446: 0xe2, 0x447: 0xe3,
+	0x449: 0xe4,
+	0x450: 0xe5, 0x451: 0xe6, 0x452: 0xe7, 0x453: 0xe8, 0x454: 0xe9, 0x455: 0xea, 0x456: 0xeb, 0x457: 0xec,
+	0x458: 0xed, 0x459: 0xee, 0x45a: 0x4b, 0x45b: 0xef, 0x45c: 0xf0, 0x45d: 0xf1, 0x45e: 0xf2, 0x45f: 0x4c,
+	// Block 0x12, offset 0x480
+	0x480: 0xf3,
+	0x4a3: 0xf4, 0x4a5: 0xf5,
+	0x4b8: 0x4d, 0x4b9: 0x4e, 0x4ba: 0x4f,
+	// Block 0x13, offset 0x4c0
+	0x4c4: 0x50, 0x4c5: 0xf6, 0x4c6: 0xf7,
+	0x4c8: 0x51, 0x4c9: 0xf8,
+	// Block 0x14, offset 0x500
+	0x520: 0x52, 0x521: 0x53, 0x522: 0x54, 0x523: 0x55, 0x524: 0x56, 0x525: 0x57, 0x526: 0x58, 0x527: 0x59,
+	0x528: 0x5a,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfkcSparseOffset: 158 entries, 316 bytes
+var nfkcSparseOffset = []uint16{0x0, 0xe, 0x12, 0x1b, 0x25, 0x35, 0x37, 0x3c, 0x47, 0x56, 0x63, 0x6b, 0x6f, 0x74, 0x76, 0x87, 0x8f, 0x96, 0x99, 0xa0, 0xa4, 0xa8, 0xaa, 0xac, 0xb5, 0xb9, 0xc0, 0xc5, 0xc8, 0xd2, 0xd5, 0xdc, 0xe4, 0xe8, 0xea, 0xed, 0xf1, 0xf7, 0x108, 0x114, 0x116, 0x11c, 0x11e, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12a, 0x12d, 0x130, 0x132, 0x135, 0x138, 0x13c, 0x141, 0x14a, 0x14c, 0x14f, 0x151, 0x15c, 0x167, 0x175, 0x183, 0x193, 0x1a1, 0x1a8, 0x1ae, 0x1bd, 0x1c1, 0x1c3, 0x1c7, 0x1c9, 0x1cc, 0x1ce, 0x1d1, 0x1d3, 0x1d6, 0x1d8, 0x1da, 0x1dc, 0x1e8, 0x1f2, 0x1fc, 0x1ff, 0x203, 0x205, 0x207, 0x209, 0x20b, 0x20e, 0x210, 0x212, 0x214, 0x216, 0x21c, 0x21f, 0x223, 0x225, 0x22c, 0x232, 0x238, 0x240, 0x246, 0x24c, 0x252, 0x256, 0x258, 0x25a, 0x25c, 0x25e, 0x264, 0x267, 0x26a, 0x272, 0x279, 0x27c, 0x27f, 0x281, 0x289, 0x28c, 0x293, 0x296, 0x29c, 0x29e, 0x2a0, 0x2a3, 0x2a5, 0x2a7, 0x2a9, 0x2ab, 0x2ae, 0x2b0, 0x2b2, 0x2b4, 0x2c1, 0x2cb, 0x2cd, 0x2cf, 0x2d3, 0x2d8, 0x2e4, 0x2e9, 0x2f2, 0x2f8, 0x2fd, 0x301, 0x306, 0x30a, 0x31a, 0x328, 0x336, 0x344, 0x34a, 0x34c, 0x34f, 0x359, 0x35b}
+
+// nfkcSparseValues: 869 entries, 3476 bytes
+var nfkcSparseValues = [869]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x0001, lo: 0xa0, hi: 0xa0},
+	{value: 0x4278, lo: 0xa8, hi: 0xa8},
+	{value: 0x0083, lo: 0xaa, hi: 0xaa},
+	{value: 0x4264, lo: 0xaf, hi: 0xaf},
+	{value: 0x0025, lo: 0xb2, hi: 0xb3},
+	{value: 0x425a, lo: 0xb4, hi: 0xb4},
+	{value: 0x01dc, lo: 0xb5, hi: 0xb5},
+	{value: 0x4291, lo: 0xb8, hi: 0xb8},
+	{value: 0x0023, lo: 0xb9, hi: 0xb9},
+	{value: 0x009f, lo: 0xba, hi: 0xba},
+	{value: 0x221c, lo: 0xbc, hi: 0xbc},
+	{value: 0x2210, lo: 0xbd, hi: 0xbd},
+	{value: 0x22b2, lo: 0xbe, hi: 0xbe},
+	// Block 0x1, offset 0xe
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x12
+	{value: 0x0003, lo: 0x08},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x0091, lo: 0xb0, hi: 0xb0},
+	{value: 0x0119, lo: 0xb1, hi: 0xb1},
+	{value: 0x0095, lo: 0xb2, hi: 0xb2},
+	{value: 0x00a5, lo: 0xb3, hi: 0xb3},
+	{value: 0x0143, lo: 0xb4, hi: 0xb6},
+	{value: 0x00af, lo: 0xb7, hi: 0xb7},
+	{value: 0x00b3, lo: 0xb8, hi: 0xb8},
+	// Block 0x3, offset 0x1b
+	{value: 0x000a, lo: 0x09},
+	{value: 0x426e, lo: 0x98, hi: 0x98},
+	{value: 0x4273, lo: 0x99, hi: 0x9a},
+	{value: 0x4296, lo: 0x9b, hi: 0x9b},
+	{value: 0x425f, lo: 0x9c, hi: 0x9c},
+	{value: 0x4282, lo: 0x9d, hi: 0x9d},
+	{value: 0x0113, lo: 0xa0, hi: 0xa0},
+	{value: 0x0099, lo: 0xa1, hi: 0xa1},
+	{value: 0x00a7, lo: 0xa2, hi: 0xa3},
+	{value: 0x0167, lo: 0xa4, hi: 0xa4},
+	// Block 0x4, offset 0x25
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x5, offset 0x35
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x6, offset 0x37
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x7, offset 0x3c
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x8, offset 0x47
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0x9, offset 0x56
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xa, offset 0x63
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xb, offset 0x6b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xc, offset 0x6f
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xd, offset 0x74
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xe, offset 0x76
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0xf, offset 0x87
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x10, offset 0x8f
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x11, offset 0x96
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x12, offset 0x99
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x13, offset 0xa0
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x14, offset 0xa4
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x15, offset 0xa8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x16, offset 0xaa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x17, offset 0xac
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x18, offset 0xb5
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x19, offset 0xb9
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1a, offset 0xc0
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1b, offset 0xc5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1c, offset 0xc8
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1d, offset 0xd2
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xbb, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1e, offset 0xd5
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1f, offset 0xdc
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x20, offset 0xe4
+	{value: 0x0000, lo: 0x03},
+	{value: 0x2621, lo: 0xb3, hi: 0xb3},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x21, offset 0xe8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x22, offset 0xea
+	{value: 0x0000, lo: 0x02},
+	{value: 0x2636, lo: 0xb3, hi: 0xb3},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x23, offset 0xed
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	{value: 0x2628, lo: 0x9c, hi: 0x9c},
+	{value: 0x262f, lo: 0x9d, hi: 0x9d},
+	// Block 0x24, offset 0xf1
+	{value: 0x0000, lo: 0x05},
+	{value: 0x030b, lo: 0x8c, hi: 0x8c},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x25, offset 0xf7
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x45f4, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x45ff, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x26, offset 0x108
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x27, offset 0x114
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x28, offset 0x116
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x29, offset 0x11c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2a, offset 0x11e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x030f, lo: 0xbc, hi: 0xbc},
+	// Block 0x2b, offset 0x120
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x122
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x124
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x126
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x128
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x12a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x12d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x130
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x132
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x135
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x138
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x13c
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x141
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x14a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x14c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x14f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x151
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x15c
+	{value: 0x0002, lo: 0x0a},
+	{value: 0x0043, lo: 0xac, hi: 0xac},
+	{value: 0x00d1, lo: 0xad, hi: 0xad},
+	{value: 0x0045, lo: 0xae, hi: 0xae},
+	{value: 0x0049, lo: 0xb0, hi: 0xb1},
+	{value: 0x00e6, lo: 0xb2, hi: 0xb2},
+	{value: 0x004f, lo: 0xb3, hi: 0xba},
+	{value: 0x005f, lo: 0xbc, hi: 0xbc},
+	{value: 0x00ef, lo: 0xbd, hi: 0xbd},
+	{value: 0x0061, lo: 0xbe, hi: 0xbe},
+	{value: 0x0065, lo: 0xbf, hi: 0xbf},
+	// Block 0x3d, offset 0x167
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x0001, lo: 0x80, hi: 0x8a},
+	{value: 0x043b, lo: 0x91, hi: 0x91},
+	{value: 0x429b, lo: 0x97, hi: 0x97},
+	{value: 0x001d, lo: 0xa4, hi: 0xa4},
+	{value: 0x1873, lo: 0xa5, hi: 0xa5},
+	{value: 0x1b5c, lo: 0xa6, hi: 0xa6},
+	{value: 0x0001, lo: 0xaf, hi: 0xaf},
+	{value: 0x2691, lo: 0xb3, hi: 0xb3},
+	{value: 0x27fe, lo: 0xb4, hi: 0xb4},
+	{value: 0x2698, lo: 0xb6, hi: 0xb6},
+	{value: 0x2808, lo: 0xb7, hi: 0xb7},
+	{value: 0x186d, lo: 0xbc, hi: 0xbc},
+	{value: 0x4269, lo: 0xbe, hi: 0xbe},
+	// Block 0x3e, offset 0x175
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x1933, lo: 0x87, hi: 0x87},
+	{value: 0x1930, lo: 0x88, hi: 0x88},
+	{value: 0x1870, lo: 0x89, hi: 0x89},
+	{value: 0x298e, lo: 0x97, hi: 0x97},
+	{value: 0x0001, lo: 0x9f, hi: 0x9f},
+	{value: 0x0021, lo: 0xb0, hi: 0xb0},
+	{value: 0x0093, lo: 0xb1, hi: 0xb1},
+	{value: 0x0029, lo: 0xb4, hi: 0xb9},
+	{value: 0x0017, lo: 0xba, hi: 0xba},
+	{value: 0x0467, lo: 0xbb, hi: 0xbb},
+	{value: 0x003b, lo: 0xbc, hi: 0xbc},
+	{value: 0x0011, lo: 0xbd, hi: 0xbe},
+	{value: 0x009d, lo: 0xbf, hi: 0xbf},
+	// Block 0x3f, offset 0x183
+	{value: 0x0002, lo: 0x0f},
+	{value: 0x0021, lo: 0x80, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8a},
+	{value: 0x0467, lo: 0x8b, hi: 0x8b},
+	{value: 0x003b, lo: 0x8c, hi: 0x8c},
+	{value: 0x0011, lo: 0x8d, hi: 0x8e},
+	{value: 0x0083, lo: 0x90, hi: 0x90},
+	{value: 0x008b, lo: 0x91, hi: 0x91},
+	{value: 0x009f, lo: 0x92, hi: 0x92},
+	{value: 0x00b1, lo: 0x93, hi: 0x93},
+	{value: 0x0104, lo: 0x94, hi: 0x94},
+	{value: 0x0091, lo: 0x95, hi: 0x95},
+	{value: 0x0097, lo: 0x96, hi: 0x99},
+	{value: 0x00a1, lo: 0x9a, hi: 0x9a},
+	{value: 0x00a7, lo: 0x9b, hi: 0x9c},
+	{value: 0x1999, lo: 0xa8, hi: 0xa8},
+	// Block 0x40, offset 0x193
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x41, offset 0x1a1
+	{value: 0x0007, lo: 0x06},
+	{value: 0x2180, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x42, offset 0x1a8
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x43, offset 0x1ae
+	{value: 0x0173, lo: 0x0e},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa4},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0x269f, lo: 0xac, hi: 0xad},
+	{value: 0x26a6, lo: 0xaf, hi: 0xaf},
+	{value: 0x281c, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x44, offset 0x1bd
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x45, offset 0x1c1
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x46, offset 0x1c3
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0057, lo: 0x80, hi: 0x8f},
+	{value: 0x0083, lo: 0x90, hi: 0xa9},
+	{value: 0x0021, lo: 0xaa, hi: 0xaa},
+	// Block 0x47, offset 0x1c7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x299b, lo: 0x8c, hi: 0x8c},
+	// Block 0x48, offset 0x1c9
+	{value: 0x0263, lo: 0x02},
+	{value: 0x1b8c, lo: 0xb4, hi: 0xb4},
+	{value: 0x192d, lo: 0xb5, hi: 0xb6},
+	// Block 0x49, offset 0x1cc
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x4a, offset 0x1ce
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0095, lo: 0xbc, hi: 0xbc},
+	{value: 0x006d, lo: 0xbd, hi: 0xbd},
+	// Block 0x4b, offset 0x1d1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x4c, offset 0x1d3
+	{value: 0x0000, lo: 0x02},
+	{value: 0x047f, lo: 0xaf, hi: 0xaf},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x4d, offset 0x1d6
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x4e, offset 0x1d8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0dc3, lo: 0x9f, hi: 0x9f},
+	// Block 0x4f, offset 0x1da
+	{value: 0x0000, lo: 0x01},
+	{value: 0x162f, lo: 0xb3, hi: 0xb3},
+	// Block 0x50, offset 0x1dc
+	{value: 0x0004, lo: 0x0b},
+	{value: 0x1597, lo: 0x80, hi: 0x82},
+	{value: 0x15af, lo: 0x83, hi: 0x83},
+	{value: 0x15c7, lo: 0x84, hi: 0x85},
+	{value: 0x15d7, lo: 0x86, hi: 0x89},
+	{value: 0x15eb, lo: 0x8a, hi: 0x8c},
+	{value: 0x15ff, lo: 0x8d, hi: 0x8d},
+	{value: 0x1607, lo: 0x8e, hi: 0x8e},
+	{value: 0x160f, lo: 0x8f, hi: 0x90},
+	{value: 0x161b, lo: 0x91, hi: 0x93},
+	{value: 0x162b, lo: 0x94, hi: 0x94},
+	{value: 0x1633, lo: 0x95, hi: 0x95},
+	// Block 0x51, offset 0x1e8
+	{value: 0x0004, lo: 0x09},
+	{value: 0x0001, lo: 0x80, hi: 0x80},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xae},
+	{value: 0x812f, lo: 0xaf, hi: 0xaf},
+	{value: 0x04b3, lo: 0xb6, hi: 0xb6},
+	{value: 0x0887, lo: 0xb8, hi: 0xba},
+	// Block 0x52, offset 0x1f2
+	{value: 0x0006, lo: 0x09},
+	{value: 0x0313, lo: 0xb1, hi: 0xb1},
+	{value: 0x0317, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a3b, lo: 0xb3, hi: 0xb3},
+	{value: 0x031b, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a41, lo: 0xb5, hi: 0xb6},
+	{value: 0x031f, lo: 0xb7, hi: 0xb7},
+	{value: 0x0323, lo: 0xb8, hi: 0xb8},
+	{value: 0x0327, lo: 0xb9, hi: 0xb9},
+	{value: 0x4a4d, lo: 0xba, hi: 0xbf},
+	// Block 0x53, offset 0x1fc
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x54, offset 0x1ff
+	{value: 0x0000, lo: 0x03},
+	{value: 0x020f, lo: 0x9c, hi: 0x9c},
+	{value: 0x0212, lo: 0x9d, hi: 0x9d},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x55, offset 0x203
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x56, offset 0x205
+	{value: 0x0000, lo: 0x01},
+	{value: 0x163b, lo: 0xb0, hi: 0xb0},
+	// Block 0x57, offset 0x207
+	{value: 0x000c, lo: 0x01},
+	{value: 0x00d7, lo: 0xb8, hi: 0xb9},
+	// Block 0x58, offset 0x209
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x59, offset 0x20b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x5a, offset 0x20e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x5b, offset 0x210
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x5c, offset 0x212
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x5d, offset 0x214
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x5e, offset 0x216
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x5f, offset 0x21c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x60, offset 0x21f
+	{value: 0x0008, lo: 0x03},
+	{value: 0x1637, lo: 0x9c, hi: 0x9d},
+	{value: 0x0125, lo: 0x9e, hi: 0x9e},
+	{value: 0x1643, lo: 0x9f, hi: 0x9f},
+	// Block 0x61, offset 0x223
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x62, offset 0x225
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x63, offset 0x22c
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x64, offset 0x232
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x65, offset 0x238
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x66, offset 0x240
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x67, offset 0x246
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x68, offset 0x24c
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x69, offset 0x252
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x6a, offset 0x256
+	{value: 0x0002, lo: 0x01},
+	{value: 0x0003, lo: 0x81, hi: 0xbf},
+	// Block 0x6b, offset 0x258
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x6c, offset 0x25a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x6d, offset 0x25c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x6e, offset 0x25e
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x6f, offset 0x264
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x70, offset 0x267
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x71, offset 0x26a
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x72, offset 0x272
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x73, offset 0x279
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x74, offset 0x27c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x75, offset 0x27f
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x76, offset 0x281
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x77, offset 0x289
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x78, offset 0x28c
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x79, offset 0x293
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7a, offset 0x296
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7b, offset 0x29c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x7c, offset 0x29e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7d, offset 0x2a0
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x7e, offset 0x2a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x7f, offset 0x2a5
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x80, offset 0x2a7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x87, hi: 0x87},
+	// Block 0x81, offset 0x2a9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x99, hi: 0x99},
+	// Block 0x82, offset 0x2ab
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0x82, hi: 0x82},
+	{value: 0x8104, lo: 0x84, hi: 0x85},
+	// Block 0x83, offset 0x2ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x84, offset 0x2b0
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x85, offset 0x2b2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x86, offset 0x2b4
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x87, offset 0x2c1
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x88, offset 0x2cb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x89, offset 0x2cd
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x8a, offset 0x2cf
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0043, lo: 0x80, hi: 0x99},
+	{value: 0x0083, lo: 0x9a, hi: 0xb3},
+	{value: 0x0043, lo: 0xb4, hi: 0xbf},
+	// Block 0x8b, offset 0x2d3
+	{value: 0x0002, lo: 0x04},
+	{value: 0x005b, lo: 0x80, hi: 0x8d},
+	{value: 0x0083, lo: 0x8e, hi: 0x94},
+	{value: 0x0093, lo: 0x96, hi: 0xa7},
+	{value: 0x0043, lo: 0xa8, hi: 0xbf},
+	// Block 0x8c, offset 0x2d8
+	{value: 0x0002, lo: 0x0b},
+	{value: 0x0073, lo: 0x80, hi: 0x81},
+	{value: 0x0083, lo: 0x82, hi: 0x9b},
+	{value: 0x0043, lo: 0x9c, hi: 0x9c},
+	{value: 0x0047, lo: 0x9e, hi: 0x9f},
+	{value: 0x004f, lo: 0xa2, hi: 0xa2},
+	{value: 0x0055, lo: 0xa5, hi: 0xa6},
+	{value: 0x005d, lo: 0xa9, hi: 0xac},
+	{value: 0x0067, lo: 0xae, hi: 0xb5},
+	{value: 0x0083, lo: 0xb6, hi: 0xb9},
+	{value: 0x008d, lo: 0xbb, hi: 0xbb},
+	{value: 0x0091, lo: 0xbd, hi: 0xbf},
+	// Block 0x8d, offset 0x2e4
+	{value: 0x0002, lo: 0x04},
+	{value: 0x0097, lo: 0x80, hi: 0x83},
+	{value: 0x00a1, lo: 0x85, hi: 0x8f},
+	{value: 0x0043, lo: 0x90, hi: 0xa9},
+	{value: 0x0083, lo: 0xaa, hi: 0xbf},
+	// Block 0x8e, offset 0x2e9
+	{value: 0x0002, lo: 0x08},
+	{value: 0x00af, lo: 0x80, hi: 0x83},
+	{value: 0x0043, lo: 0x84, hi: 0x85},
+	{value: 0x0049, lo: 0x87, hi: 0x8a},
+	{value: 0x0055, lo: 0x8d, hi: 0x94},
+	{value: 0x0067, lo: 0x96, hi: 0x9c},
+	{value: 0x0083, lo: 0x9e, hi: 0xb7},
+	{value: 0x0043, lo: 0xb8, hi: 0xb9},
+	{value: 0x0049, lo: 0xbb, hi: 0xbe},
+	// Block 0x8f, offset 0x2f2
+	{value: 0x0002, lo: 0x05},
+	{value: 0x0053, lo: 0x80, hi: 0x84},
+	{value: 0x005f, lo: 0x86, hi: 0x86},
+	{value: 0x0067, lo: 0x8a, hi: 0x90},
+	{value: 0x0083, lo: 0x92, hi: 0xab},
+	{value: 0x0043, lo: 0xac, hi: 0xbf},
+	// Block 0x90, offset 0x2f8
+	{value: 0x0002, lo: 0x04},
+	{value: 0x006b, lo: 0x80, hi: 0x85},
+	{value: 0x0083, lo: 0x86, hi: 0x9f},
+	{value: 0x0043, lo: 0xa0, hi: 0xb9},
+	{value: 0x0083, lo: 0xba, hi: 0xbf},
+	// Block 0x91, offset 0x2fd
+	{value: 0x0002, lo: 0x03},
+	{value: 0x008f, lo: 0x80, hi: 0x93},
+	{value: 0x0043, lo: 0x94, hi: 0xad},
+	{value: 0x0083, lo: 0xae, hi: 0xbf},
+	// Block 0x92, offset 0x301
+	{value: 0x0002, lo: 0x04},
+	{value: 0x00a7, lo: 0x80, hi: 0x87},
+	{value: 0x0043, lo: 0x88, hi: 0xa1},
+	{value: 0x0083, lo: 0xa2, hi: 0xbb},
+	{value: 0x0043, lo: 0xbc, hi: 0xbf},
+	// Block 0x93, offset 0x306
+	{value: 0x0002, lo: 0x03},
+	{value: 0x004b, lo: 0x80, hi: 0x95},
+	{value: 0x0083, lo: 0x96, hi: 0xaf},
+	{value: 0x0043, lo: 0xb0, hi: 0xbf},
+	// Block 0x94, offset 0x30a
+	{value: 0x0003, lo: 0x0f},
+	{value: 0x01b8, lo: 0x80, hi: 0x80},
+	{value: 0x045f, lo: 0x81, hi: 0x81},
+	{value: 0x01bb, lo: 0x82, hi: 0x9a},
+	{value: 0x045b, lo: 0x9b, hi: 0x9b},
+	{value: 0x01c7, lo: 0x9c, hi: 0x9c},
+	{value: 0x01d0, lo: 0x9d, hi: 0x9d},
+	{value: 0x01d6, lo: 0x9e, hi: 0x9e},
+	{value: 0x01fa, lo: 0x9f, hi: 0x9f},
+	{value: 0x01eb, lo: 0xa0, hi: 0xa0},
+	{value: 0x01e8, lo: 0xa1, hi: 0xa1},
+	{value: 0x0173, lo: 0xa2, hi: 0xb2},
+	{value: 0x0188, lo: 0xb3, hi: 0xb3},
+	{value: 0x01a6, lo: 0xb4, hi: 0xba},
+	{value: 0x045f, lo: 0xbb, hi: 0xbb},
+	{value: 0x01bb, lo: 0xbc, hi: 0xbf},
+	// Block 0x95, offset 0x31a
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01c7, lo: 0x80, hi: 0x94},
+	{value: 0x045b, lo: 0x95, hi: 0x95},
+	{value: 0x01c7, lo: 0x96, hi: 0x96},
+	{value: 0x01d0, lo: 0x97, hi: 0x97},
+	{value: 0x01d6, lo: 0x98, hi: 0x98},
+	{value: 0x01fa, lo: 0x99, hi: 0x99},
+	{value: 0x01eb, lo: 0x9a, hi: 0x9a},
+	{value: 0x01e8, lo: 0x9b, hi: 0x9b},
+	{value: 0x0173, lo: 0x9c, hi: 0xac},
+	{value: 0x0188, lo: 0xad, hi: 0xad},
+	{value: 0x01a6, lo: 0xae, hi: 0xb4},
+	{value: 0x045f, lo: 0xb5, hi: 0xb5},
+	{value: 0x01bb, lo: 0xb6, hi: 0xbf},
+	// Block 0x96, offset 0x328
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01d9, lo: 0x80, hi: 0x8e},
+	{value: 0x045b, lo: 0x8f, hi: 0x8f},
+	{value: 0x01c7, lo: 0x90, hi: 0x90},
+	{value: 0x01d0, lo: 0x91, hi: 0x91},
+	{value: 0x01d6, lo: 0x92, hi: 0x92},
+	{value: 0x01fa, lo: 0x93, hi: 0x93},
+	{value: 0x01eb, lo: 0x94, hi: 0x94},
+	{value: 0x01e8, lo: 0x95, hi: 0x95},
+	{value: 0x0173, lo: 0x96, hi: 0xa6},
+	{value: 0x0188, lo: 0xa7, hi: 0xa7},
+	{value: 0x01a6, lo: 0xa8, hi: 0xae},
+	{value: 0x045f, lo: 0xaf, hi: 0xaf},
+	{value: 0x01bb, lo: 0xb0, hi: 0xbf},
+	// Block 0x97, offset 0x336
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01eb, lo: 0x80, hi: 0x88},
+	{value: 0x045b, lo: 0x89, hi: 0x89},
+	{value: 0x01c7, lo: 0x8a, hi: 0x8a},
+	{value: 0x01d0, lo: 0x8b, hi: 0x8b},
+	{value: 0x01d6, lo: 0x8c, hi: 0x8c},
+	{value: 0x01fa, lo: 0x8d, hi: 0x8d},
+	{value: 0x01eb, lo: 0x8e, hi: 0x8e},
+	{value: 0x01e8, lo: 0x8f, hi: 0x8f},
+	{value: 0x0173, lo: 0x90, hi: 0xa0},
+	{value: 0x0188, lo: 0xa1, hi: 0xa1},
+	{value: 0x01a6, lo: 0xa2, hi: 0xa8},
+	{value: 0x045f, lo: 0xa9, hi: 0xa9},
+	{value: 0x01bb, lo: 0xaa, hi: 0xbf},
+	// Block 0x98, offset 0x344
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x99, offset 0x34a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x9a, offset 0x34c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x9b, offset 0x34f
+	{value: 0x0002, lo: 0x09},
+	{value: 0x0063, lo: 0x80, hi: 0x89},
+	{value: 0x1951, lo: 0x8a, hi: 0x8a},
+	{value: 0x1981, lo: 0x8b, hi: 0x8b},
+	{value: 0x199c, lo: 0x8c, hi: 0x8c},
+	{value: 0x19a2, lo: 0x8d, hi: 0x8d},
+	{value: 0x1bc0, lo: 0x8e, hi: 0x8e},
+	{value: 0x19ae, lo: 0x8f, hi: 0x8f},
+	{value: 0x197b, lo: 0xaa, hi: 0xaa},
+	{value: 0x197e, lo: 0xab, hi: 0xab},
+	// Block 0x9c, offset 0x359
+	{value: 0x0000, lo: 0x01},
+	{value: 0x193f, lo: 0x90, hi: 0x90},
+	// Block 0x9d, offset 0x35b
+	{value: 0x0028, lo: 0x09},
+	{value: 0x2862, lo: 0x80, hi: 0x80},
+	{value: 0x2826, lo: 0x81, hi: 0x81},
+	{value: 0x2830, lo: 0x82, hi: 0x82},
+	{value: 0x2844, lo: 0x83, hi: 0x84},
+	{value: 0x284e, lo: 0x85, hi: 0x86},
+	{value: 0x283a, lo: 0x87, hi: 0x87},
+	{value: 0x2858, lo: 0x88, hi: 0x88},
+	{value: 0x0b6f, lo: 0x90, hi: 0x90},
+	{value: 0x08e7, lo: 0x91, hi: 0x91},
+}
+
+// recompMap: 7520 bytes (entries only)
+var recompMap = map[uint32]rune{
+	0x00410300: 0x00C0,
+	0x00410301: 0x00C1,
+	0x00410302: 0x00C2,
+	0x00410303: 0x00C3,
+	0x00410308: 0x00C4,
+	0x0041030A: 0x00C5,
+	0x00430327: 0x00C7,
+	0x00450300: 0x00C8,
+	0x00450301: 0x00C9,
+	0x00450302: 0x00CA,
+	0x00450308: 0x00CB,
+	0x00490300: 0x00CC,
+	0x00490301: 0x00CD,
+	0x00490302: 0x00CE,
+	0x00490308: 0x00CF,
+	0x004E0303: 0x00D1,
+	0x004F0300: 0x00D2,
+	0x004F0301: 0x00D3,
+	0x004F0302: 0x00D4,
+	0x004F0303: 0x00D5,
+	0x004F0308: 0x00D6,
+	0x00550300: 0x00D9,
+	0x00550301: 0x00DA,
+	0x00550302: 0x00DB,
+	0x00550308: 0x00DC,
+	0x00590301: 0x00DD,
+	0x00610300: 0x00E0,
+	0x00610301: 0x00E1,
+	0x00610302: 0x00E2,
+	0x00610303: 0x00E3,
+	0x00610308: 0x00E4,
+	0x0061030A: 0x00E5,
+	0x00630327: 0x00E7,
+	0x00650300: 0x00E8,
+	0x00650301: 0x00E9,
+	0x00650302: 0x00EA,
+	0x00650308: 0x00EB,
+	0x00690300: 0x00EC,
+	0x00690301: 0x00ED,
+	0x00690302: 0x00EE,
+	0x00690308: 0x00EF,
+	0x006E0303: 0x00F1,
+	0x006F0300: 0x00F2,
+	0x006F0301: 0x00F3,
+	0x006F0302: 0x00F4,
+	0x006F0303: 0x00F5,
+	0x006F0308: 0x00F6,
+	0x00750300: 0x00F9,
+	0x00750301: 0x00FA,
+	0x00750302: 0x00FB,
+	0x00750308: 0x00FC,
+	0x00790301: 0x00FD,
+	0x00790308: 0x00FF,
+	0x00410304: 0x0100,
+	0x00610304: 0x0101,
+	0x00410306: 0x0102,
+	0x00610306: 0x0103,
+	0x00410328: 0x0104,
+	0x00610328: 0x0105,
+	0x00430301: 0x0106,
+	0x00630301: 0x0107,
+	0x00430302: 0x0108,
+	0x00630302: 0x0109,
+	0x00430307: 0x010A,
+	0x00630307: 0x010B,
+	0x0043030C: 0x010C,
+	0x0063030C: 0x010D,
+	0x0044030C: 0x010E,
+	0x0064030C: 0x010F,
+	0x00450304: 0x0112,
+	0x00650304: 0x0113,
+	0x00450306: 0x0114,
+	0x00650306: 0x0115,
+	0x00450307: 0x0116,
+	0x00650307: 0x0117,
+	0x00450328: 0x0118,
+	0x00650328: 0x0119,
+	0x0045030C: 0x011A,
+	0x0065030C: 0x011B,
+	0x00470302: 0x011C,
+	0x00670302: 0x011D,
+	0x00470306: 0x011E,
+	0x00670306: 0x011F,
+	0x00470307: 0x0120,
+	0x00670307: 0x0121,
+	0x00470327: 0x0122,
+	0x00670327: 0x0123,
+	0x00480302: 0x0124,
+	0x00680302: 0x0125,
+	0x00490303: 0x0128,
+	0x00690303: 0x0129,
+	0x00490304: 0x012A,
+	0x00690304: 0x012B,
+	0x00490306: 0x012C,
+	0x00690306: 0x012D,
+	0x00490328: 0x012E,
+	0x00690328: 0x012F,
+	0x00490307: 0x0130,
+	0x004A0302: 0x0134,
+	0x006A0302: 0x0135,
+	0x004B0327: 0x0136,
+	0x006B0327: 0x0137,
+	0x004C0301: 0x0139,
+	0x006C0301: 0x013A,
+	0x004C0327: 0x013B,
+	0x006C0327: 0x013C,
+	0x004C030C: 0x013D,
+	0x006C030C: 0x013E,
+	0x004E0301: 0x0143,
+	0x006E0301: 0x0144,
+	0x004E0327: 0x0145,
+	0x006E0327: 0x0146,
+	0x004E030C: 0x0147,
+	0x006E030C: 0x0148,
+	0x004F0304: 0x014C,
+	0x006F0304: 0x014D,
+	0x004F0306: 0x014E,
+	0x006F0306: 0x014F,
+	0x004F030B: 0x0150,
+	0x006F030B: 0x0151,
+	0x00520301: 0x0154,
+	0x00720301: 0x0155,
+	0x00520327: 0x0156,
+	0x00720327: 0x0157,
+	0x0052030C: 0x0158,
+	0x0072030C: 0x0159,
+	0x00530301: 0x015A,
+	0x00730301: 0x015B,
+	0x00530302: 0x015C,
+	0x00730302: 0x015D,
+	0x00530327: 0x015E,
+	0x00730327: 0x015F,
+	0x0053030C: 0x0160,
+	0x0073030C: 0x0161,
+	0x00540327: 0x0162,
+	0x00740327: 0x0163,
+	0x0054030C: 0x0164,
+	0x0074030C: 0x0165,
+	0x00550303: 0x0168,
+	0x00750303: 0x0169,
+	0x00550304: 0x016A,
+	0x00750304: 0x016B,
+	0x00550306: 0x016C,
+	0x00750306: 0x016D,
+	0x0055030A: 0x016E,
+	0x0075030A: 0x016F,
+	0x0055030B: 0x0170,
+	0x0075030B: 0x0171,
+	0x00550328: 0x0172,
+	0x00750328: 0x0173,
+	0x00570302: 0x0174,
+	0x00770302: 0x0175,
+	0x00590302: 0x0176,
+	0x00790302: 0x0177,
+	0x00590308: 0x0178,
+	0x005A0301: 0x0179,
+	0x007A0301: 0x017A,
+	0x005A0307: 0x017B,
+	0x007A0307: 0x017C,
+	0x005A030C: 0x017D,
+	0x007A030C: 0x017E,
+	0x004F031B: 0x01A0,
+	0x006F031B: 0x01A1,
+	0x0055031B: 0x01AF,
+	0x0075031B: 0x01B0,
+	0x0041030C: 0x01CD,
+	0x0061030C: 0x01CE,
+	0x0049030C: 0x01CF,
+	0x0069030C: 0x01D0,
+	0x004F030C: 0x01D1,
+	0x006F030C: 0x01D2,
+	0x0055030C: 0x01D3,
+	0x0075030C: 0x01D4,
+	0x00DC0304: 0x01D5,
+	0x00FC0304: 0x01D6,
+	0x00DC0301: 0x01D7,
+	0x00FC0301: 0x01D8,
+	0x00DC030C: 0x01D9,
+	0x00FC030C: 0x01DA,
+	0x00DC0300: 0x01DB,
+	0x00FC0300: 0x01DC,
+	0x00C40304: 0x01DE,
+	0x00E40304: 0x01DF,
+	0x02260304: 0x01E0,
+	0x02270304: 0x01E1,
+	0x00C60304: 0x01E2,
+	0x00E60304: 0x01E3,
+	0x0047030C: 0x01E6,
+	0x0067030C: 0x01E7,
+	0x004B030C: 0x01E8,
+	0x006B030C: 0x01E9,
+	0x004F0328: 0x01EA,
+	0x006F0328: 0x01EB,
+	0x01EA0304: 0x01EC,
+	0x01EB0304: 0x01ED,
+	0x01B7030C: 0x01EE,
+	0x0292030C: 0x01EF,
+	0x006A030C: 0x01F0,
+	0x00470301: 0x01F4,
+	0x00670301: 0x01F5,
+	0x004E0300: 0x01F8,
+	0x006E0300: 0x01F9,
+	0x00C50301: 0x01FA,
+	0x00E50301: 0x01FB,
+	0x00C60301: 0x01FC,
+	0x00E60301: 0x01FD,
+	0x00D80301: 0x01FE,
+	0x00F80301: 0x01FF,
+	0x0041030F: 0x0200,
+	0x0061030F: 0x0201,
+	0x00410311: 0x0202,
+	0x00610311: 0x0203,
+	0x0045030F: 0x0204,
+	0x0065030F: 0x0205,
+	0x00450311: 0x0206,
+	0x00650311: 0x0207,
+	0x0049030F: 0x0208,
+	0x0069030F: 0x0209,
+	0x00490311: 0x020A,
+	0x00690311: 0x020B,
+	0x004F030F: 0x020C,
+	0x006F030F: 0x020D,
+	0x004F0311: 0x020E,
+	0x006F0311: 0x020F,
+	0x0052030F: 0x0210,
+	0x0072030F: 0x0211,
+	0x00520311: 0x0212,
+	0x00720311: 0x0213,
+	0x0055030F: 0x0214,
+	0x0075030F: 0x0215,
+	0x00550311: 0x0216,
+	0x00750311: 0x0217,
+	0x00530326: 0x0218,
+	0x00730326: 0x0219,
+	0x00540326: 0x021A,
+	0x00740326: 0x021B,
+	0x0048030C: 0x021E,
+	0x0068030C: 0x021F,
+	0x00410307: 0x0226,
+	0x00610307: 0x0227,
+	0x00450327: 0x0228,
+	0x00650327: 0x0229,
+	0x00D60304: 0x022A,
+	0x00F60304: 0x022B,
+	0x00D50304: 0x022C,
+	0x00F50304: 0x022D,
+	0x004F0307: 0x022E,
+	0x006F0307: 0x022F,
+	0x022E0304: 0x0230,
+	0x022F0304: 0x0231,
+	0x00590304: 0x0232,
+	0x00790304: 0x0233,
+	0x00A80301: 0x0385,
+	0x03910301: 0x0386,
+	0x03950301: 0x0388,
+	0x03970301: 0x0389,
+	0x03990301: 0x038A,
+	0x039F0301: 0x038C,
+	0x03A50301: 0x038E,
+	0x03A90301: 0x038F,
+	0x03CA0301: 0x0390,
+	0x03990308: 0x03AA,
+	0x03A50308: 0x03AB,
+	0x03B10301: 0x03AC,
+	0x03B50301: 0x03AD,
+	0x03B70301: 0x03AE,
+	0x03B90301: 0x03AF,
+	0x03CB0301: 0x03B0,
+	0x03B90308: 0x03CA,
+	0x03C50308: 0x03CB,
+	0x03BF0301: 0x03CC,
+	0x03C50301: 0x03CD,
+	0x03C90301: 0x03CE,
+	0x03D20301: 0x03D3,
+	0x03D20308: 0x03D4,
+	0x04150300: 0x0400,
+	0x04150308: 0x0401,
+	0x04130301: 0x0403,
+	0x04060308: 0x0407,
+	0x041A0301: 0x040C,
+	0x04180300: 0x040D,
+	0x04230306: 0x040E,
+	0x04180306: 0x0419,
+	0x04380306: 0x0439,
+	0x04350300: 0x0450,
+	0x04350308: 0x0451,
+	0x04330301: 0x0453,
+	0x04560308: 0x0457,
+	0x043A0301: 0x045C,
+	0x04380300: 0x045D,
+	0x04430306: 0x045E,
+	0x0474030F: 0x0476,
+	0x0475030F: 0x0477,
+	0x04160306: 0x04C1,
+	0x04360306: 0x04C2,
+	0x04100306: 0x04D0,
+	0x04300306: 0x04D1,
+	0x04100308: 0x04D2,
+	0x04300308: 0x04D3,
+	0x04150306: 0x04D6,
+	0x04350306: 0x04D7,
+	0x04D80308: 0x04DA,
+	0x04D90308: 0x04DB,
+	0x04160308: 0x04DC,
+	0x04360308: 0x04DD,
+	0x04170308: 0x04DE,
+	0x04370308: 0x04DF,
+	0x04180304: 0x04E2,
+	0x04380304: 0x04E3,
+	0x04180308: 0x04E4,
+	0x04380308: 0x04E5,
+	0x041E0308: 0x04E6,
+	0x043E0308: 0x04E7,
+	0x04E80308: 0x04EA,
+	0x04E90308: 0x04EB,
+	0x042D0308: 0x04EC,
+	0x044D0308: 0x04ED,
+	0x04230304: 0x04EE,
+	0x04430304: 0x04EF,
+	0x04230308: 0x04F0,
+	0x04430308: 0x04F1,
+	0x0423030B: 0x04F2,
+	0x0443030B: 0x04F3,
+	0x04270308: 0x04F4,
+	0x04470308: 0x04F5,
+	0x042B0308: 0x04F8,
+	0x044B0308: 0x04F9,
+	0x06270653: 0x0622,
+	0x06270654: 0x0623,
+	0x06480654: 0x0624,
+	0x06270655: 0x0625,
+	0x064A0654: 0x0626,
+	0x06D50654: 0x06C0,
+	0x06C10654: 0x06C2,
+	0x06D20654: 0x06D3,
+	0x0928093C: 0x0929,
+	0x0930093C: 0x0931,
+	0x0933093C: 0x0934,
+	0x09C709BE: 0x09CB,
+	0x09C709D7: 0x09CC,
+	0x0B470B56: 0x0B48,
+	0x0B470B3E: 0x0B4B,
+	0x0B470B57: 0x0B4C,
+	0x0B920BD7: 0x0B94,
+	0x0BC60BBE: 0x0BCA,
+	0x0BC70BBE: 0x0BCB,
+	0x0BC60BD7: 0x0BCC,
+	0x0C460C56: 0x0C48,
+	0x0CBF0CD5: 0x0CC0,
+	0x0CC60CD5: 0x0CC7,
+	0x0CC60CD6: 0x0CC8,
+	0x0CC60CC2: 0x0CCA,
+	0x0CCA0CD5: 0x0CCB,
+	0x0D460D3E: 0x0D4A,
+	0x0D470D3E: 0x0D4B,
+	0x0D460D57: 0x0D4C,
+	0x0DD90DCA: 0x0DDA,
+	0x0DD90DCF: 0x0DDC,
+	0x0DDC0DCA: 0x0DDD,
+	0x0DD90DDF: 0x0DDE,
+	0x1025102E: 0x1026,
+	0x1B051B35: 0x1B06,
+	0x1B071B35: 0x1B08,
+	0x1B091B35: 0x1B0A,
+	0x1B0B1B35: 0x1B0C,
+	0x1B0D1B35: 0x1B0E,
+	0x1B111B35: 0x1B12,
+	0x1B3A1B35: 0x1B3B,
+	0x1B3C1B35: 0x1B3D,
+	0x1B3E1B35: 0x1B40,
+	0x1B3F1B35: 0x1B41,
+	0x1B421B35: 0x1B43,
+	0x00410325: 0x1E00,
+	0x00610325: 0x1E01,
+	0x00420307: 0x1E02,
+	0x00620307: 0x1E03,
+	0x00420323: 0x1E04,
+	0x00620323: 0x1E05,
+	0x00420331: 0x1E06,
+	0x00620331: 0x1E07,
+	0x00C70301: 0x1E08,
+	0x00E70301: 0x1E09,
+	0x00440307: 0x1E0A,
+	0x00640307: 0x1E0B,
+	0x00440323: 0x1E0C,
+	0x00640323: 0x1E0D,
+	0x00440331: 0x1E0E,
+	0x00640331: 0x1E0F,
+	0x00440327: 0x1E10,
+	0x00640327: 0x1E11,
+	0x0044032D: 0x1E12,
+	0x0064032D: 0x1E13,
+	0x01120300: 0x1E14,
+	0x01130300: 0x1E15,
+	0x01120301: 0x1E16,
+	0x01130301: 0x1E17,
+	0x0045032D: 0x1E18,
+	0x0065032D: 0x1E19,
+	0x00450330: 0x1E1A,
+	0x00650330: 0x1E1B,
+	0x02280306: 0x1E1C,
+	0x02290306: 0x1E1D,
+	0x00460307: 0x1E1E,
+	0x00660307: 0x1E1F,
+	0x00470304: 0x1E20,
+	0x00670304: 0x1E21,
+	0x00480307: 0x1E22,
+	0x00680307: 0x1E23,
+	0x00480323: 0x1E24,
+	0x00680323: 0x1E25,
+	0x00480308: 0x1E26,
+	0x00680308: 0x1E27,
+	0x00480327: 0x1E28,
+	0x00680327: 0x1E29,
+	0x0048032E: 0x1E2A,
+	0x0068032E: 0x1E2B,
+	0x00490330: 0x1E2C,
+	0x00690330: 0x1E2D,
+	0x00CF0301: 0x1E2E,
+	0x00EF0301: 0x1E2F,
+	0x004B0301: 0x1E30,
+	0x006B0301: 0x1E31,
+	0x004B0323: 0x1E32,
+	0x006B0323: 0x1E33,
+	0x004B0331: 0x1E34,
+	0x006B0331: 0x1E35,
+	0x004C0323: 0x1E36,
+	0x006C0323: 0x1E37,
+	0x1E360304: 0x1E38,
+	0x1E370304: 0x1E39,
+	0x004C0331: 0x1E3A,
+	0x006C0331: 0x1E3B,
+	0x004C032D: 0x1E3C,
+	0x006C032D: 0x1E3D,
+	0x004D0301: 0x1E3E,
+	0x006D0301: 0x1E3F,
+	0x004D0307: 0x1E40,
+	0x006D0307: 0x1E41,
+	0x004D0323: 0x1E42,
+	0x006D0323: 0x1E43,
+	0x004E0307: 0x1E44,
+	0x006E0307: 0x1E45,
+	0x004E0323: 0x1E46,
+	0x006E0323: 0x1E47,
+	0x004E0331: 0x1E48,
+	0x006E0331: 0x1E49,
+	0x004E032D: 0x1E4A,
+	0x006E032D: 0x1E4B,
+	0x00D50301: 0x1E4C,
+	0x00F50301: 0x1E4D,
+	0x00D50308: 0x1E4E,
+	0x00F50308: 0x1E4F,
+	0x014C0300: 0x1E50,
+	0x014D0300: 0x1E51,
+	0x014C0301: 0x1E52,
+	0x014D0301: 0x1E53,
+	0x00500301: 0x1E54,
+	0x00700301: 0x1E55,
+	0x00500307: 0x1E56,
+	0x00700307: 0x1E57,
+	0x00520307: 0x1E58,
+	0x00720307: 0x1E59,
+	0x00520323: 0x1E5A,
+	0x00720323: 0x1E5B,
+	0x1E5A0304: 0x1E5C,
+	0x1E5B0304: 0x1E5D,
+	0x00520331: 0x1E5E,
+	0x00720331: 0x1E5F,
+	0x00530307: 0x1E60,
+	0x00730307: 0x1E61,
+	0x00530323: 0x1E62,
+	0x00730323: 0x1E63,
+	0x015A0307: 0x1E64,
+	0x015B0307: 0x1E65,
+	0x01600307: 0x1E66,
+	0x01610307: 0x1E67,
+	0x1E620307: 0x1E68,
+	0x1E630307: 0x1E69,
+	0x00540307: 0x1E6A,
+	0x00740307: 0x1E6B,
+	0x00540323: 0x1E6C,
+	0x00740323: 0x1E6D,
+	0x00540331: 0x1E6E,
+	0x00740331: 0x1E6F,
+	0x0054032D: 0x1E70,
+	0x0074032D: 0x1E71,
+	0x00550324: 0x1E72,
+	0x00750324: 0x1E73,
+	0x00550330: 0x1E74,
+	0x00750330: 0x1E75,
+	0x0055032D: 0x1E76,
+	0x0075032D: 0x1E77,
+	0x01680301: 0x1E78,
+	0x01690301: 0x1E79,
+	0x016A0308: 0x1E7A,
+	0x016B0308: 0x1E7B,
+	0x00560303: 0x1E7C,
+	0x00760303: 0x1E7D,
+	0x00560323: 0x1E7E,
+	0x00760323: 0x1E7F,
+	0x00570300: 0x1E80,
+	0x00770300: 0x1E81,
+	0x00570301: 0x1E82,
+	0x00770301: 0x1E83,
+	0x00570308: 0x1E84,
+	0x00770308: 0x1E85,
+	0x00570307: 0x1E86,
+	0x00770307: 0x1E87,
+	0x00570323: 0x1E88,
+	0x00770323: 0x1E89,
+	0x00580307: 0x1E8A,
+	0x00780307: 0x1E8B,
+	0x00580308: 0x1E8C,
+	0x00780308: 0x1E8D,
+	0x00590307: 0x1E8E,
+	0x00790307: 0x1E8F,
+	0x005A0302: 0x1E90,
+	0x007A0302: 0x1E91,
+	0x005A0323: 0x1E92,
+	0x007A0323: 0x1E93,
+	0x005A0331: 0x1E94,
+	0x007A0331: 0x1E95,
+	0x00680331: 0x1E96,
+	0x00740308: 0x1E97,
+	0x0077030A: 0x1E98,
+	0x0079030A: 0x1E99,
+	0x017F0307: 0x1E9B,
+	0x00410323: 0x1EA0,
+	0x00610323: 0x1EA1,
+	0x00410309: 0x1EA2,
+	0x00610309: 0x1EA3,
+	0x00C20301: 0x1EA4,
+	0x00E20301: 0x1EA5,
+	0x00C20300: 0x1EA6,
+	0x00E20300: 0x1EA7,
+	0x00C20309: 0x1EA8,
+	0x00E20309: 0x1EA9,
+	0x00C20303: 0x1EAA,
+	0x00E20303: 0x1EAB,
+	0x1EA00302: 0x1EAC,
+	0x1EA10302: 0x1EAD,
+	0x01020301: 0x1EAE,
+	0x01030301: 0x1EAF,
+	0x01020300: 0x1EB0,
+	0x01030300: 0x1EB1,
+	0x01020309: 0x1EB2,
+	0x01030309: 0x1EB3,
+	0x01020303: 0x1EB4,
+	0x01030303: 0x1EB5,
+	0x1EA00306: 0x1EB6,
+	0x1EA10306: 0x1EB7,
+	0x00450323: 0x1EB8,
+	0x00650323: 0x1EB9,
+	0x00450309: 0x1EBA,
+	0x00650309: 0x1EBB,
+	0x00450303: 0x1EBC,
+	0x00650303: 0x1EBD,
+	0x00CA0301: 0x1EBE,
+	0x00EA0301: 0x1EBF,
+	0x00CA0300: 0x1EC0,
+	0x00EA0300: 0x1EC1,
+	0x00CA0309: 0x1EC2,
+	0x00EA0309: 0x1EC3,
+	0x00CA0303: 0x1EC4,
+	0x00EA0303: 0x1EC5,
+	0x1EB80302: 0x1EC6,
+	0x1EB90302: 0x1EC7,
+	0x00490309: 0x1EC8,
+	0x00690309: 0x1EC9,
+	0x00490323: 0x1ECA,
+	0x00690323: 0x1ECB,
+	0x004F0323: 0x1ECC,
+	0x006F0323: 0x1ECD,
+	0x004F0309: 0x1ECE,
+	0x006F0309: 0x1ECF,
+	0x00D40301: 0x1ED0,
+	0x00F40301: 0x1ED1,
+	0x00D40300: 0x1ED2,
+	0x00F40300: 0x1ED3,
+	0x00D40309: 0x1ED4,
+	0x00F40309: 0x1ED5,
+	0x00D40303: 0x1ED6,
+	0x00F40303: 0x1ED7,
+	0x1ECC0302: 0x1ED8,
+	0x1ECD0302: 0x1ED9,
+	0x01A00301: 0x1EDA,
+	0x01A10301: 0x1EDB,
+	0x01A00300: 0x1EDC,
+	0x01A10300: 0x1EDD,
+	0x01A00309: 0x1EDE,
+	0x01A10309: 0x1EDF,
+	0x01A00303: 0x1EE0,
+	0x01A10303: 0x1EE1,
+	0x01A00323: 0x1EE2,
+	0x01A10323: 0x1EE3,
+	0x00550323: 0x1EE4,
+	0x00750323: 0x1EE5,
+	0x00550309: 0x1EE6,
+	0x00750309: 0x1EE7,
+	0x01AF0301: 0x1EE8,
+	0x01B00301: 0x1EE9,
+	0x01AF0300: 0x1EEA,
+	0x01B00300: 0x1EEB,
+	0x01AF0309: 0x1EEC,
+	0x01B00309: 0x1EED,
+	0x01AF0303: 0x1EEE,
+	0x01B00303: 0x1EEF,
+	0x01AF0323: 0x1EF0,
+	0x01B00323: 0x1EF1,
+	0x00590300: 0x1EF2,
+	0x00790300: 0x1EF3,
+	0x00590323: 0x1EF4,
+	0x00790323: 0x1EF5,
+	0x00590309: 0x1EF6,
+	0x00790309: 0x1EF7,
+	0x00590303: 0x1EF8,
+	0x00790303: 0x1EF9,
+	0x03B10313: 0x1F00,
+	0x03B10314: 0x1F01,
+	0x1F000300: 0x1F02,
+	0x1F010300: 0x1F03,
+	0x1F000301: 0x1F04,
+	0x1F010301: 0x1F05,
+	0x1F000342: 0x1F06,
+	0x1F010342: 0x1F07,
+	0x03910313: 0x1F08,
+	0x03910314: 0x1F09,
+	0x1F080300: 0x1F0A,
+	0x1F090300: 0x1F0B,
+	0x1F080301: 0x1F0C,
+	0x1F090301: 0x1F0D,
+	0x1F080342: 0x1F0E,
+	0x1F090342: 0x1F0F,
+	0x03B50313: 0x1F10,
+	0x03B50314: 0x1F11,
+	0x1F100300: 0x1F12,
+	0x1F110300: 0x1F13,
+	0x1F100301: 0x1F14,
+	0x1F110301: 0x1F15,
+	0x03950313: 0x1F18,
+	0x03950314: 0x1F19,
+	0x1F180300: 0x1F1A,
+	0x1F190300: 0x1F1B,
+	0x1F180301: 0x1F1C,
+	0x1F190301: 0x1F1D,
+	0x03B70313: 0x1F20,
+	0x03B70314: 0x1F21,
+	0x1F200300: 0x1F22,
+	0x1F210300: 0x1F23,
+	0x1F200301: 0x1F24,
+	0x1F210301: 0x1F25,
+	0x1F200342: 0x1F26,
+	0x1F210342: 0x1F27,
+	0x03970313: 0x1F28,
+	0x03970314: 0x1F29,
+	0x1F280300: 0x1F2A,
+	0x1F290300: 0x1F2B,
+	0x1F280301: 0x1F2C,
+	0x1F290301: 0x1F2D,
+	0x1F280342: 0x1F2E,
+	0x1F290342: 0x1F2F,
+	0x03B90313: 0x1F30,
+	0x03B90314: 0x1F31,
+	0x1F300300: 0x1F32,
+	0x1F310300: 0x1F33,
+	0x1F300301: 0x1F34,
+	0x1F310301: 0x1F35,
+	0x1F300342: 0x1F36,
+	0x1F310342: 0x1F37,
+	0x03990313: 0x1F38,
+	0x03990314: 0x1F39,
+	0x1F380300: 0x1F3A,
+	0x1F390300: 0x1F3B,
+	0x1F380301: 0x1F3C,
+	0x1F390301: 0x1F3D,
+	0x1F380342: 0x1F3E,
+	0x1F390342: 0x1F3F,
+	0x03BF0313: 0x1F40,
+	0x03BF0314: 0x1F41,
+	0x1F400300: 0x1F42,
+	0x1F410300: 0x1F43,
+	0x1F400301: 0x1F44,
+	0x1F410301: 0x1F45,
+	0x039F0313: 0x1F48,
+	0x039F0314: 0x1F49,
+	0x1F480300: 0x1F4A,
+	0x1F490300: 0x1F4B,
+	0x1F480301: 0x1F4C,
+	0x1F490301: 0x1F4D,
+	0x03C50313: 0x1F50,
+	0x03C50314: 0x1F51,
+	0x1F500300: 0x1F52,
+	0x1F510300: 0x1F53,
+	0x1F500301: 0x1F54,
+	0x1F510301: 0x1F55,
+	0x1F500342: 0x1F56,
+	0x1F510342: 0x1F57,
+	0x03A50314: 0x1F59,
+	0x1F590300: 0x1F5B,
+	0x1F590301: 0x1F5D,
+	0x1F590342: 0x1F5F,
+	0x03C90313: 0x1F60,
+	0x03C90314: 0x1F61,
+	0x1F600300: 0x1F62,
+	0x1F610300: 0x1F63,
+	0x1F600301: 0x1F64,
+	0x1F610301: 0x1F65,
+	0x1F600342: 0x1F66,
+	0x1F610342: 0x1F67,
+	0x03A90313: 0x1F68,
+	0x03A90314: 0x1F69,
+	0x1F680300: 0x1F6A,
+	0x1F690300: 0x1F6B,
+	0x1F680301: 0x1F6C,
+	0x1F690301: 0x1F6D,
+	0x1F680342: 0x1F6E,
+	0x1F690342: 0x1F6F,
+	0x03B10300: 0x1F70,
+	0x03B50300: 0x1F72,
+	0x03B70300: 0x1F74,
+	0x03B90300: 0x1F76,
+	0x03BF0300: 0x1F78,
+	0x03C50300: 0x1F7A,
+	0x03C90300: 0x1F7C,
+	0x1F000345: 0x1F80,
+	0x1F010345: 0x1F81,
+	0x1F020345: 0x1F82,
+	0x1F030345: 0x1F83,
+	0x1F040345: 0x1F84,
+	0x1F050345: 0x1F85,
+	0x1F060345: 0x1F86,
+	0x1F070345: 0x1F87,
+	0x1F080345: 0x1F88,
+	0x1F090345: 0x1F89,
+	0x1F0A0345: 0x1F8A,
+	0x1F0B0345: 0x1F8B,
+	0x1F0C0345: 0x1F8C,
+	0x1F0D0345: 0x1F8D,
+	0x1F0E0345: 0x1F8E,
+	0x1F0F0345: 0x1F8F,
+	0x1F200345: 0x1F90,
+	0x1F210345: 0x1F91,
+	0x1F220345: 0x1F92,
+	0x1F230345: 0x1F93,
+	0x1F240345: 0x1F94,
+	0x1F250345: 0x1F95,
+	0x1F260345: 0x1F96,
+	0x1F270345: 0x1F97,
+	0x1F280345: 0x1F98,
+	0x1F290345: 0x1F99,
+	0x1F2A0345: 0x1F9A,
+	0x1F2B0345: 0x1F9B,
+	0x1F2C0345: 0x1F9C,
+	0x1F2D0345: 0x1F9D,
+	0x1F2E0345: 0x1F9E,
+	0x1F2F0345: 0x1F9F,
+	0x1F600345: 0x1FA0,
+	0x1F610345: 0x1FA1,
+	0x1F620345: 0x1FA2,
+	0x1F630345: 0x1FA3,
+	0x1F640345: 0x1FA4,
+	0x1F650345: 0x1FA5,
+	0x1F660345: 0x1FA6,
+	0x1F670345: 0x1FA7,
+	0x1F680345: 0x1FA8,
+	0x1F690345: 0x1FA9,
+	0x1F6A0345: 0x1FAA,
+	0x1F6B0345: 0x1FAB,
+	0x1F6C0345: 0x1FAC,
+	0x1F6D0345: 0x1FAD,
+	0x1F6E0345: 0x1FAE,
+	0x1F6F0345: 0x1FAF,
+	0x03B10306: 0x1FB0,
+	0x03B10304: 0x1FB1,
+	0x1F700345: 0x1FB2,
+	0x03B10345: 0x1FB3,
+	0x03AC0345: 0x1FB4,
+	0x03B10342: 0x1FB6,
+	0x1FB60345: 0x1FB7,
+	0x03910306: 0x1FB8,
+	0x03910304: 0x1FB9,
+	0x03910300: 0x1FBA,
+	0x03910345: 0x1FBC,
+	0x00A80342: 0x1FC1,
+	0x1F740345: 0x1FC2,
+	0x03B70345: 0x1FC3,
+	0x03AE0345: 0x1FC4,
+	0x03B70342: 0x1FC6,
+	0x1FC60345: 0x1FC7,
+	0x03950300: 0x1FC8,
+	0x03970300: 0x1FCA,
+	0x03970345: 0x1FCC,
+	0x1FBF0300: 0x1FCD,
+	0x1FBF0301: 0x1FCE,
+	0x1FBF0342: 0x1FCF,
+	0x03B90306: 0x1FD0,
+	0x03B90304: 0x1FD1,
+	0x03CA0300: 0x1FD2,
+	0x03B90342: 0x1FD6,
+	0x03CA0342: 0x1FD7,
+	0x03990306: 0x1FD8,
+	0x03990304: 0x1FD9,
+	0x03990300: 0x1FDA,
+	0x1FFE0300: 0x1FDD,
+	0x1FFE0301: 0x1FDE,
+	0x1FFE0342: 0x1FDF,
+	0x03C50306: 0x1FE0,
+	0x03C50304: 0x1FE1,
+	0x03CB0300: 0x1FE2,
+	0x03C10313: 0x1FE4,
+	0x03C10314: 0x1FE5,
+	0x03C50342: 0x1FE6,
+	0x03CB0342: 0x1FE7,
+	0x03A50306: 0x1FE8,
+	0x03A50304: 0x1FE9,
+	0x03A50300: 0x1FEA,
+	0x03A10314: 0x1FEC,
+	0x00A80300: 0x1FED,
+	0x1F7C0345: 0x1FF2,
+	0x03C90345: 0x1FF3,
+	0x03CE0345: 0x1FF4,
+	0x03C90342: 0x1FF6,
+	0x1FF60345: 0x1FF7,
+	0x039F0300: 0x1FF8,
+	0x03A90300: 0x1FFA,
+	0x03A90345: 0x1FFC,
+	0x21900338: 0x219A,
+	0x21920338: 0x219B,
+	0x21940338: 0x21AE,
+	0x21D00338: 0x21CD,
+	0x21D40338: 0x21CE,
+	0x21D20338: 0x21CF,
+	0x22030338: 0x2204,
+	0x22080338: 0x2209,
+	0x220B0338: 0x220C,
+	0x22230338: 0x2224,
+	0x22250338: 0x2226,
+	0x223C0338: 0x2241,
+	0x22430338: 0x2244,
+	0x22450338: 0x2247,
+	0x22480338: 0x2249,
+	0x003D0338: 0x2260,
+	0x22610338: 0x2262,
+	0x224D0338: 0x226D,
+	0x003C0338: 0x226E,
+	0x003E0338: 0x226F,
+	0x22640338: 0x2270,
+	0x22650338: 0x2271,
+	0x22720338: 0x2274,
+	0x22730338: 0x2275,
+	0x22760338: 0x2278,
+	0x22770338: 0x2279,
+	0x227A0338: 0x2280,
+	0x227B0338: 0x2281,
+	0x22820338: 0x2284,
+	0x22830338: 0x2285,
+	0x22860338: 0x2288,
+	0x22870338: 0x2289,
+	0x22A20338: 0x22AC,
+	0x22A80338: 0x22AD,
+	0x22A90338: 0x22AE,
+	0x22AB0338: 0x22AF,
+	0x227C0338: 0x22E0,
+	0x227D0338: 0x22E1,
+	0x22910338: 0x22E2,
+	0x22920338: 0x22E3,
+	0x22B20338: 0x22EA,
+	0x22B30338: 0x22EB,
+	0x22B40338: 0x22EC,
+	0x22B50338: 0x22ED,
+	0x304B3099: 0x304C,
+	0x304D3099: 0x304E,
+	0x304F3099: 0x3050,
+	0x30513099: 0x3052,
+	0x30533099: 0x3054,
+	0x30553099: 0x3056,
+	0x30573099: 0x3058,
+	0x30593099: 0x305A,
+	0x305B3099: 0x305C,
+	0x305D3099: 0x305E,
+	0x305F3099: 0x3060,
+	0x30613099: 0x3062,
+	0x30643099: 0x3065,
+	0x30663099: 0x3067,
+	0x30683099: 0x3069,
+	0x306F3099: 0x3070,
+	0x306F309A: 0x3071,
+	0x30723099: 0x3073,
+	0x3072309A: 0x3074,
+	0x30753099: 0x3076,
+	0x3075309A: 0x3077,
+	0x30783099: 0x3079,
+	0x3078309A: 0x307A,
+	0x307B3099: 0x307C,
+	0x307B309A: 0x307D,
+	0x30463099: 0x3094,
+	0x309D3099: 0x309E,
+	0x30AB3099: 0x30AC,
+	0x30AD3099: 0x30AE,
+	0x30AF3099: 0x30B0,
+	0x30B13099: 0x30B2,
+	0x30B33099: 0x30B4,
+	0x30B53099: 0x30B6,
+	0x30B73099: 0x30B8,
+	0x30B93099: 0x30BA,
+	0x30BB3099: 0x30BC,
+	0x30BD3099: 0x30BE,
+	0x30BF3099: 0x30C0,
+	0x30C13099: 0x30C2,
+	0x30C43099: 0x30C5,
+	0x30C63099: 0x30C7,
+	0x30C83099: 0x30C9,
+	0x30CF3099: 0x30D0,
+	0x30CF309A: 0x30D1,
+	0x30D23099: 0x30D3,
+	0x30D2309A: 0x30D4,
+	0x30D53099: 0x30D6,
+	0x30D5309A: 0x30D7,
+	0x30D83099: 0x30D9,
+	0x30D8309A: 0x30DA,
+	0x30DB3099: 0x30DC,
+	0x30DB309A: 0x30DD,
+	0x30A63099: 0x30F4,
+	0x30EF3099: 0x30F7,
+	0x30F03099: 0x30F8,
+	0x30F13099: 0x30F9,
+	0x30F23099: 0x30FA,
+	0x30FD3099: 0x30FE,
+	0x109910BA: 0x1109A,
+	0x109B10BA: 0x1109C,
+	0x10A510BA: 0x110AB,
+	0x11311127: 0x1112E,
+	0x11321127: 0x1112F,
+	0x1347133E: 0x1134B,
+	0x13471357: 0x1134C,
+	0x14B914BA: 0x114BB,
+	0x14B914B0: 0x114BC,
+	0x14B914BD: 0x114BE,
+	0x15B815AF: 0x115BA,
+	0x15B915AF: 0x115BB,
+}
+
+// Total size of tables: 53KB (54226 bytes)
diff --git a/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go b/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go
new file mode 100644
index 0000000000..a01274a8e8
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/tables9.0.0.go
@@ -0,0 +1,7633 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+// +build !go1.10
+
+package norm
+
+const (
+	// Version is the Unicode edition from which the tables are derived.
+	Version = "9.0.0"
+
+	// MaxTransformChunkSize indicates the maximum number of bytes that Transform
+	// may need to write atomically for any Form. Making a destination buffer at
+	// least this size ensures that Transform can always make progress and that
+	// the user does not need to grow the buffer on an ErrShortDst.
+	MaxTransformChunkSize = 35 + maxNonStarters*4
+)
+
+var ccc = [55]uint8{
+	0, 1, 7, 8, 9, 10, 11, 12,
+	13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28,
+	29, 30, 31, 32, 33, 34, 35, 36,
+	84, 91, 103, 107, 118, 122, 129, 130,
+	132, 202, 214, 216, 218, 220, 222, 224,
+	226, 228, 230, 232, 233, 234, 240,
+}
+
+const (
+	firstMulti            = 0x186D
+	firstCCC              = 0x2C9E
+	endMulti              = 0x2F60
+	firstLeadingCCC       = 0x49AE
+	firstCCCZeroExcept    = 0x4A78
+	firstStarterWithNLead = 0x4A9F
+	lastDecomp            = 0x4AA1
+	maxDecomp             = 0x8000
+)
+
+// decomps: 19105 bytes
+var decomps = [...]byte{
+	// Bytes 0 - 3f
+	0x00, 0x41, 0x20, 0x41, 0x21, 0x41, 0x22, 0x41,
+	0x23, 0x41, 0x24, 0x41, 0x25, 0x41, 0x26, 0x41,
+	0x27, 0x41, 0x28, 0x41, 0x29, 0x41, 0x2A, 0x41,
+	0x2B, 0x41, 0x2C, 0x41, 0x2D, 0x41, 0x2E, 0x41,
+	0x2F, 0x41, 0x30, 0x41, 0x31, 0x41, 0x32, 0x41,
+	0x33, 0x41, 0x34, 0x41, 0x35, 0x41, 0x36, 0x41,
+	0x37, 0x41, 0x38, 0x41, 0x39, 0x41, 0x3A, 0x41,
+	0x3B, 0x41, 0x3C, 0x41, 0x3D, 0x41, 0x3E, 0x41,
+	// Bytes 40 - 7f
+	0x3F, 0x41, 0x40, 0x41, 0x41, 0x41, 0x42, 0x41,
+	0x43, 0x41, 0x44, 0x41, 0x45, 0x41, 0x46, 0x41,
+	0x47, 0x41, 0x48, 0x41, 0x49, 0x41, 0x4A, 0x41,
+	0x4B, 0x41, 0x4C, 0x41, 0x4D, 0x41, 0x4E, 0x41,
+	0x4F, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41,
+	0x53, 0x41, 0x54, 0x41, 0x55, 0x41, 0x56, 0x41,
+	0x57, 0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x41,
+	0x5B, 0x41, 0x5C, 0x41, 0x5D, 0x41, 0x5E, 0x41,
+	// Bytes 80 - bf
+	0x5F, 0x41, 0x60, 0x41, 0x61, 0x41, 0x62, 0x41,
+	0x63, 0x41, 0x64, 0x41, 0x65, 0x41, 0x66, 0x41,
+	0x67, 0x41, 0x68, 0x41, 0x69, 0x41, 0x6A, 0x41,
+	0x6B, 0x41, 0x6C, 0x41, 0x6D, 0x41, 0x6E, 0x41,
+	0x6F, 0x41, 0x70, 0x41, 0x71, 0x41, 0x72, 0x41,
+	0x73, 0x41, 0x74, 0x41, 0x75, 0x41, 0x76, 0x41,
+	0x77, 0x41, 0x78, 0x41, 0x79, 0x41, 0x7A, 0x41,
+	0x7B, 0x41, 0x7C, 0x41, 0x7D, 0x41, 0x7E, 0x42,
+	// Bytes c0 - ff
+	0xC2, 0xA2, 0x42, 0xC2, 0xA3, 0x42, 0xC2, 0xA5,
+	0x42, 0xC2, 0xA6, 0x42, 0xC2, 0xAC, 0x42, 0xC2,
+	0xB7, 0x42, 0xC3, 0x86, 0x42, 0xC3, 0xB0, 0x42,
+	0xC4, 0xA6, 0x42, 0xC4, 0xA7, 0x42, 0xC4, 0xB1,
+	0x42, 0xC5, 0x8B, 0x42, 0xC5, 0x93, 0x42, 0xC6,
+	0x8E, 0x42, 0xC6, 0x90, 0x42, 0xC6, 0xAB, 0x42,
+	0xC8, 0xA2, 0x42, 0xC8, 0xB7, 0x42, 0xC9, 0x90,
+	0x42, 0xC9, 0x91, 0x42, 0xC9, 0x92, 0x42, 0xC9,
+	// Bytes 100 - 13f
+	0x94, 0x42, 0xC9, 0x95, 0x42, 0xC9, 0x99, 0x42,
+	0xC9, 0x9B, 0x42, 0xC9, 0x9C, 0x42, 0xC9, 0x9F,
+	0x42, 0xC9, 0xA1, 0x42, 0xC9, 0xA3, 0x42, 0xC9,
+	0xA5, 0x42, 0xC9, 0xA6, 0x42, 0xC9, 0xA8, 0x42,
+	0xC9, 0xA9, 0x42, 0xC9, 0xAA, 0x42, 0xC9, 0xAB,
+	0x42, 0xC9, 0xAD, 0x42, 0xC9, 0xAF, 0x42, 0xC9,
+	0xB0, 0x42, 0xC9, 0xB1, 0x42, 0xC9, 0xB2, 0x42,
+	0xC9, 0xB3, 0x42, 0xC9, 0xB4, 0x42, 0xC9, 0xB5,
+	// Bytes 140 - 17f
+	0x42, 0xC9, 0xB8, 0x42, 0xC9, 0xB9, 0x42, 0xC9,
+	0xBB, 0x42, 0xCA, 0x81, 0x42, 0xCA, 0x82, 0x42,
+	0xCA, 0x83, 0x42, 0xCA, 0x89, 0x42, 0xCA, 0x8A,
+	0x42, 0xCA, 0x8B, 0x42, 0xCA, 0x8C, 0x42, 0xCA,
+	0x90, 0x42, 0xCA, 0x91, 0x42, 0xCA, 0x92, 0x42,
+	0xCA, 0x95, 0x42, 0xCA, 0x9D, 0x42, 0xCA, 0x9F,
+	0x42, 0xCA, 0xB9, 0x42, 0xCE, 0x91, 0x42, 0xCE,
+	0x92, 0x42, 0xCE, 0x93, 0x42, 0xCE, 0x94, 0x42,
+	// Bytes 180 - 1bf
+	0xCE, 0x95, 0x42, 0xCE, 0x96, 0x42, 0xCE, 0x97,
+	0x42, 0xCE, 0x98, 0x42, 0xCE, 0x99, 0x42, 0xCE,
+	0x9A, 0x42, 0xCE, 0x9B, 0x42, 0xCE, 0x9C, 0x42,
+	0xCE, 0x9D, 0x42, 0xCE, 0x9E, 0x42, 0xCE, 0x9F,
+	0x42, 0xCE, 0xA0, 0x42, 0xCE, 0xA1, 0x42, 0xCE,
+	0xA3, 0x42, 0xCE, 0xA4, 0x42, 0xCE, 0xA5, 0x42,
+	0xCE, 0xA6, 0x42, 0xCE, 0xA7, 0x42, 0xCE, 0xA8,
+	0x42, 0xCE, 0xA9, 0x42, 0xCE, 0xB1, 0x42, 0xCE,
+	// Bytes 1c0 - 1ff
+	0xB2, 0x42, 0xCE, 0xB3, 0x42, 0xCE, 0xB4, 0x42,
+	0xCE, 0xB5, 0x42, 0xCE, 0xB6, 0x42, 0xCE, 0xB7,
+	0x42, 0xCE, 0xB8, 0x42, 0xCE, 0xB9, 0x42, 0xCE,
+	0xBA, 0x42, 0xCE, 0xBB, 0x42, 0xCE, 0xBC, 0x42,
+	0xCE, 0xBD, 0x42, 0xCE, 0xBE, 0x42, 0xCE, 0xBF,
+	0x42, 0xCF, 0x80, 0x42, 0xCF, 0x81, 0x42, 0xCF,
+	0x82, 0x42, 0xCF, 0x83, 0x42, 0xCF, 0x84, 0x42,
+	0xCF, 0x85, 0x42, 0xCF, 0x86, 0x42, 0xCF, 0x87,
+	// Bytes 200 - 23f
+	0x42, 0xCF, 0x88, 0x42, 0xCF, 0x89, 0x42, 0xCF,
+	0x9C, 0x42, 0xCF, 0x9D, 0x42, 0xD0, 0xBD, 0x42,
+	0xD1, 0x8A, 0x42, 0xD1, 0x8C, 0x42, 0xD7, 0x90,
+	0x42, 0xD7, 0x91, 0x42, 0xD7, 0x92, 0x42, 0xD7,
+	0x93, 0x42, 0xD7, 0x94, 0x42, 0xD7, 0x9B, 0x42,
+	0xD7, 0x9C, 0x42, 0xD7, 0x9D, 0x42, 0xD7, 0xA2,
+	0x42, 0xD7, 0xA8, 0x42, 0xD7, 0xAA, 0x42, 0xD8,
+	0xA1, 0x42, 0xD8, 0xA7, 0x42, 0xD8, 0xA8, 0x42,
+	// Bytes 240 - 27f
+	0xD8, 0xA9, 0x42, 0xD8, 0xAA, 0x42, 0xD8, 0xAB,
+	0x42, 0xD8, 0xAC, 0x42, 0xD8, 0xAD, 0x42, 0xD8,
+	0xAE, 0x42, 0xD8, 0xAF, 0x42, 0xD8, 0xB0, 0x42,
+	0xD8, 0xB1, 0x42, 0xD8, 0xB2, 0x42, 0xD8, 0xB3,
+	0x42, 0xD8, 0xB4, 0x42, 0xD8, 0xB5, 0x42, 0xD8,
+	0xB6, 0x42, 0xD8, 0xB7, 0x42, 0xD8, 0xB8, 0x42,
+	0xD8, 0xB9, 0x42, 0xD8, 0xBA, 0x42, 0xD9, 0x81,
+	0x42, 0xD9, 0x82, 0x42, 0xD9, 0x83, 0x42, 0xD9,
+	// Bytes 280 - 2bf
+	0x84, 0x42, 0xD9, 0x85, 0x42, 0xD9, 0x86, 0x42,
+	0xD9, 0x87, 0x42, 0xD9, 0x88, 0x42, 0xD9, 0x89,
+	0x42, 0xD9, 0x8A, 0x42, 0xD9, 0xAE, 0x42, 0xD9,
+	0xAF, 0x42, 0xD9, 0xB1, 0x42, 0xD9, 0xB9, 0x42,
+	0xD9, 0xBA, 0x42, 0xD9, 0xBB, 0x42, 0xD9, 0xBE,
+	0x42, 0xD9, 0xBF, 0x42, 0xDA, 0x80, 0x42, 0xDA,
+	0x83, 0x42, 0xDA, 0x84, 0x42, 0xDA, 0x86, 0x42,
+	0xDA, 0x87, 0x42, 0xDA, 0x88, 0x42, 0xDA, 0x8C,
+	// Bytes 2c0 - 2ff
+	0x42, 0xDA, 0x8D, 0x42, 0xDA, 0x8E, 0x42, 0xDA,
+	0x91, 0x42, 0xDA, 0x98, 0x42, 0xDA, 0xA1, 0x42,
+	0xDA, 0xA4, 0x42, 0xDA, 0xA6, 0x42, 0xDA, 0xA9,
+	0x42, 0xDA, 0xAD, 0x42, 0xDA, 0xAF, 0x42, 0xDA,
+	0xB1, 0x42, 0xDA, 0xB3, 0x42, 0xDA, 0xBA, 0x42,
+	0xDA, 0xBB, 0x42, 0xDA, 0xBE, 0x42, 0xDB, 0x81,
+	0x42, 0xDB, 0x85, 0x42, 0xDB, 0x86, 0x42, 0xDB,
+	0x87, 0x42, 0xDB, 0x88, 0x42, 0xDB, 0x89, 0x42,
+	// Bytes 300 - 33f
+	0xDB, 0x8B, 0x42, 0xDB, 0x8C, 0x42, 0xDB, 0x90,
+	0x42, 0xDB, 0x92, 0x43, 0xE0, 0xBC, 0x8B, 0x43,
+	0xE1, 0x83, 0x9C, 0x43, 0xE1, 0x84, 0x80, 0x43,
+	0xE1, 0x84, 0x81, 0x43, 0xE1, 0x84, 0x82, 0x43,
+	0xE1, 0x84, 0x83, 0x43, 0xE1, 0x84, 0x84, 0x43,
+	0xE1, 0x84, 0x85, 0x43, 0xE1, 0x84, 0x86, 0x43,
+	0xE1, 0x84, 0x87, 0x43, 0xE1, 0x84, 0x88, 0x43,
+	0xE1, 0x84, 0x89, 0x43, 0xE1, 0x84, 0x8A, 0x43,
+	// Bytes 340 - 37f
+	0xE1, 0x84, 0x8B, 0x43, 0xE1, 0x84, 0x8C, 0x43,
+	0xE1, 0x84, 0x8D, 0x43, 0xE1, 0x84, 0x8E, 0x43,
+	0xE1, 0x84, 0x8F, 0x43, 0xE1, 0x84, 0x90, 0x43,
+	0xE1, 0x84, 0x91, 0x43, 0xE1, 0x84, 0x92, 0x43,
+	0xE1, 0x84, 0x94, 0x43, 0xE1, 0x84, 0x95, 0x43,
+	0xE1, 0x84, 0x9A, 0x43, 0xE1, 0x84, 0x9C, 0x43,
+	0xE1, 0x84, 0x9D, 0x43, 0xE1, 0x84, 0x9E, 0x43,
+	0xE1, 0x84, 0xA0, 0x43, 0xE1, 0x84, 0xA1, 0x43,
+	// Bytes 380 - 3bf
+	0xE1, 0x84, 0xA2, 0x43, 0xE1, 0x84, 0xA3, 0x43,
+	0xE1, 0x84, 0xA7, 0x43, 0xE1, 0x84, 0xA9, 0x43,
+	0xE1, 0x84, 0xAB, 0x43, 0xE1, 0x84, 0xAC, 0x43,
+	0xE1, 0x84, 0xAD, 0x43, 0xE1, 0x84, 0xAE, 0x43,
+	0xE1, 0x84, 0xAF, 0x43, 0xE1, 0x84, 0xB2, 0x43,
+	0xE1, 0x84, 0xB6, 0x43, 0xE1, 0x85, 0x80, 0x43,
+	0xE1, 0x85, 0x87, 0x43, 0xE1, 0x85, 0x8C, 0x43,
+	0xE1, 0x85, 0x97, 0x43, 0xE1, 0x85, 0x98, 0x43,
+	// Bytes 3c0 - 3ff
+	0xE1, 0x85, 0x99, 0x43, 0xE1, 0x85, 0xA0, 0x43,
+	0xE1, 0x86, 0x84, 0x43, 0xE1, 0x86, 0x85, 0x43,
+	0xE1, 0x86, 0x88, 0x43, 0xE1, 0x86, 0x91, 0x43,
+	0xE1, 0x86, 0x92, 0x43, 0xE1, 0x86, 0x94, 0x43,
+	0xE1, 0x86, 0x9E, 0x43, 0xE1, 0x86, 0xA1, 0x43,
+	0xE1, 0x87, 0x87, 0x43, 0xE1, 0x87, 0x88, 0x43,
+	0xE1, 0x87, 0x8C, 0x43, 0xE1, 0x87, 0x8E, 0x43,
+	0xE1, 0x87, 0x93, 0x43, 0xE1, 0x87, 0x97, 0x43,
+	// Bytes 400 - 43f
+	0xE1, 0x87, 0x99, 0x43, 0xE1, 0x87, 0x9D, 0x43,
+	0xE1, 0x87, 0x9F, 0x43, 0xE1, 0x87, 0xB1, 0x43,
+	0xE1, 0x87, 0xB2, 0x43, 0xE1, 0xB4, 0x82, 0x43,
+	0xE1, 0xB4, 0x96, 0x43, 0xE1, 0xB4, 0x97, 0x43,
+	0xE1, 0xB4, 0x9C, 0x43, 0xE1, 0xB4, 0x9D, 0x43,
+	0xE1, 0xB4, 0xA5, 0x43, 0xE1, 0xB5, 0xBB, 0x43,
+	0xE1, 0xB6, 0x85, 0x43, 0xE2, 0x80, 0x82, 0x43,
+	0xE2, 0x80, 0x83, 0x43, 0xE2, 0x80, 0x90, 0x43,
+	// Bytes 440 - 47f
+	0xE2, 0x80, 0x93, 0x43, 0xE2, 0x80, 0x94, 0x43,
+	0xE2, 0x82, 0xA9, 0x43, 0xE2, 0x86, 0x90, 0x43,
+	0xE2, 0x86, 0x91, 0x43, 0xE2, 0x86, 0x92, 0x43,
+	0xE2, 0x86, 0x93, 0x43, 0xE2, 0x88, 0x82, 0x43,
+	0xE2, 0x88, 0x87, 0x43, 0xE2, 0x88, 0x91, 0x43,
+	0xE2, 0x88, 0x92, 0x43, 0xE2, 0x94, 0x82, 0x43,
+	0xE2, 0x96, 0xA0, 0x43, 0xE2, 0x97, 0x8B, 0x43,
+	0xE2, 0xA6, 0x85, 0x43, 0xE2, 0xA6, 0x86, 0x43,
+	// Bytes 480 - 4bf
+	0xE2, 0xB5, 0xA1, 0x43, 0xE3, 0x80, 0x81, 0x43,
+	0xE3, 0x80, 0x82, 0x43, 0xE3, 0x80, 0x88, 0x43,
+	0xE3, 0x80, 0x89, 0x43, 0xE3, 0x80, 0x8A, 0x43,
+	0xE3, 0x80, 0x8B, 0x43, 0xE3, 0x80, 0x8C, 0x43,
+	0xE3, 0x80, 0x8D, 0x43, 0xE3, 0x80, 0x8E, 0x43,
+	0xE3, 0x80, 0x8F, 0x43, 0xE3, 0x80, 0x90, 0x43,
+	0xE3, 0x80, 0x91, 0x43, 0xE3, 0x80, 0x92, 0x43,
+	0xE3, 0x80, 0x94, 0x43, 0xE3, 0x80, 0x95, 0x43,
+	// Bytes 4c0 - 4ff
+	0xE3, 0x80, 0x96, 0x43, 0xE3, 0x80, 0x97, 0x43,
+	0xE3, 0x82, 0xA1, 0x43, 0xE3, 0x82, 0xA2, 0x43,
+	0xE3, 0x82, 0xA3, 0x43, 0xE3, 0x82, 0xA4, 0x43,
+	0xE3, 0x82, 0xA5, 0x43, 0xE3, 0x82, 0xA6, 0x43,
+	0xE3, 0x82, 0xA7, 0x43, 0xE3, 0x82, 0xA8, 0x43,
+	0xE3, 0x82, 0xA9, 0x43, 0xE3, 0x82, 0xAA, 0x43,
+	0xE3, 0x82, 0xAB, 0x43, 0xE3, 0x82, 0xAD, 0x43,
+	0xE3, 0x82, 0xAF, 0x43, 0xE3, 0x82, 0xB1, 0x43,
+	// Bytes 500 - 53f
+	0xE3, 0x82, 0xB3, 0x43, 0xE3, 0x82, 0xB5, 0x43,
+	0xE3, 0x82, 0xB7, 0x43, 0xE3, 0x82, 0xB9, 0x43,
+	0xE3, 0x82, 0xBB, 0x43, 0xE3, 0x82, 0xBD, 0x43,
+	0xE3, 0x82, 0xBF, 0x43, 0xE3, 0x83, 0x81, 0x43,
+	0xE3, 0x83, 0x83, 0x43, 0xE3, 0x83, 0x84, 0x43,
+	0xE3, 0x83, 0x86, 0x43, 0xE3, 0x83, 0x88, 0x43,
+	0xE3, 0x83, 0x8A, 0x43, 0xE3, 0x83, 0x8B, 0x43,
+	0xE3, 0x83, 0x8C, 0x43, 0xE3, 0x83, 0x8D, 0x43,
+	// Bytes 540 - 57f
+	0xE3, 0x83, 0x8E, 0x43, 0xE3, 0x83, 0x8F, 0x43,
+	0xE3, 0x83, 0x92, 0x43, 0xE3, 0x83, 0x95, 0x43,
+	0xE3, 0x83, 0x98, 0x43, 0xE3, 0x83, 0x9B, 0x43,
+	0xE3, 0x83, 0x9E, 0x43, 0xE3, 0x83, 0x9F, 0x43,
+	0xE3, 0x83, 0xA0, 0x43, 0xE3, 0x83, 0xA1, 0x43,
+	0xE3, 0x83, 0xA2, 0x43, 0xE3, 0x83, 0xA3, 0x43,
+	0xE3, 0x83, 0xA4, 0x43, 0xE3, 0x83, 0xA5, 0x43,
+	0xE3, 0x83, 0xA6, 0x43, 0xE3, 0x83, 0xA7, 0x43,
+	// Bytes 580 - 5bf
+	0xE3, 0x83, 0xA8, 0x43, 0xE3, 0x83, 0xA9, 0x43,
+	0xE3, 0x83, 0xAA, 0x43, 0xE3, 0x83, 0xAB, 0x43,
+	0xE3, 0x83, 0xAC, 0x43, 0xE3, 0x83, 0xAD, 0x43,
+	0xE3, 0x83, 0xAF, 0x43, 0xE3, 0x83, 0xB0, 0x43,
+	0xE3, 0x83, 0xB1, 0x43, 0xE3, 0x83, 0xB2, 0x43,
+	0xE3, 0x83, 0xB3, 0x43, 0xE3, 0x83, 0xBB, 0x43,
+	0xE3, 0x83, 0xBC, 0x43, 0xE3, 0x92, 0x9E, 0x43,
+	0xE3, 0x92, 0xB9, 0x43, 0xE3, 0x92, 0xBB, 0x43,
+	// Bytes 5c0 - 5ff
+	0xE3, 0x93, 0x9F, 0x43, 0xE3, 0x94, 0x95, 0x43,
+	0xE3, 0x9B, 0xAE, 0x43, 0xE3, 0x9B, 0xBC, 0x43,
+	0xE3, 0x9E, 0x81, 0x43, 0xE3, 0xA0, 0xAF, 0x43,
+	0xE3, 0xA1, 0xA2, 0x43, 0xE3, 0xA1, 0xBC, 0x43,
+	0xE3, 0xA3, 0x87, 0x43, 0xE3, 0xA3, 0xA3, 0x43,
+	0xE3, 0xA4, 0x9C, 0x43, 0xE3, 0xA4, 0xBA, 0x43,
+	0xE3, 0xA8, 0xAE, 0x43, 0xE3, 0xA9, 0xAC, 0x43,
+	0xE3, 0xAB, 0xA4, 0x43, 0xE3, 0xAC, 0x88, 0x43,
+	// Bytes 600 - 63f
+	0xE3, 0xAC, 0x99, 0x43, 0xE3, 0xAD, 0x89, 0x43,
+	0xE3, 0xAE, 0x9D, 0x43, 0xE3, 0xB0, 0x98, 0x43,
+	0xE3, 0xB1, 0x8E, 0x43, 0xE3, 0xB4, 0xB3, 0x43,
+	0xE3, 0xB6, 0x96, 0x43, 0xE3, 0xBA, 0xAC, 0x43,
+	0xE3, 0xBA, 0xB8, 0x43, 0xE3, 0xBC, 0x9B, 0x43,
+	0xE3, 0xBF, 0xBC, 0x43, 0xE4, 0x80, 0x88, 0x43,
+	0xE4, 0x80, 0x98, 0x43, 0xE4, 0x80, 0xB9, 0x43,
+	0xE4, 0x81, 0x86, 0x43, 0xE4, 0x82, 0x96, 0x43,
+	// Bytes 640 - 67f
+	0xE4, 0x83, 0xA3, 0x43, 0xE4, 0x84, 0xAF, 0x43,
+	0xE4, 0x88, 0x82, 0x43, 0xE4, 0x88, 0xA7, 0x43,
+	0xE4, 0x8A, 0xA0, 0x43, 0xE4, 0x8C, 0x81, 0x43,
+	0xE4, 0x8C, 0xB4, 0x43, 0xE4, 0x8D, 0x99, 0x43,
+	0xE4, 0x8F, 0x95, 0x43, 0xE4, 0x8F, 0x99, 0x43,
+	0xE4, 0x90, 0x8B, 0x43, 0xE4, 0x91, 0xAB, 0x43,
+	0xE4, 0x94, 0xAB, 0x43, 0xE4, 0x95, 0x9D, 0x43,
+	0xE4, 0x95, 0xA1, 0x43, 0xE4, 0x95, 0xAB, 0x43,
+	// Bytes 680 - 6bf
+	0xE4, 0x97, 0x97, 0x43, 0xE4, 0x97, 0xB9, 0x43,
+	0xE4, 0x98, 0xB5, 0x43, 0xE4, 0x9A, 0xBE, 0x43,
+	0xE4, 0x9B, 0x87, 0x43, 0xE4, 0xA6, 0x95, 0x43,
+	0xE4, 0xA7, 0xA6, 0x43, 0xE4, 0xA9, 0xAE, 0x43,
+	0xE4, 0xA9, 0xB6, 0x43, 0xE4, 0xAA, 0xB2, 0x43,
+	0xE4, 0xAC, 0xB3, 0x43, 0xE4, 0xAF, 0x8E, 0x43,
+	0xE4, 0xB3, 0x8E, 0x43, 0xE4, 0xB3, 0xAD, 0x43,
+	0xE4, 0xB3, 0xB8, 0x43, 0xE4, 0xB5, 0x96, 0x43,
+	// Bytes 6c0 - 6ff
+	0xE4, 0xB8, 0x80, 0x43, 0xE4, 0xB8, 0x81, 0x43,
+	0xE4, 0xB8, 0x83, 0x43, 0xE4, 0xB8, 0x89, 0x43,
+	0xE4, 0xB8, 0x8A, 0x43, 0xE4, 0xB8, 0x8B, 0x43,
+	0xE4, 0xB8, 0x8D, 0x43, 0xE4, 0xB8, 0x99, 0x43,
+	0xE4, 0xB8, 0xA6, 0x43, 0xE4, 0xB8, 0xA8, 0x43,
+	0xE4, 0xB8, 0xAD, 0x43, 0xE4, 0xB8, 0xB2, 0x43,
+	0xE4, 0xB8, 0xB6, 0x43, 0xE4, 0xB8, 0xB8, 0x43,
+	0xE4, 0xB8, 0xB9, 0x43, 0xE4, 0xB8, 0xBD, 0x43,
+	// Bytes 700 - 73f
+	0xE4, 0xB8, 0xBF, 0x43, 0xE4, 0xB9, 0x81, 0x43,
+	0xE4, 0xB9, 0x99, 0x43, 0xE4, 0xB9, 0x9D, 0x43,
+	0xE4, 0xBA, 0x82, 0x43, 0xE4, 0xBA, 0x85, 0x43,
+	0xE4, 0xBA, 0x86, 0x43, 0xE4, 0xBA, 0x8C, 0x43,
+	0xE4, 0xBA, 0x94, 0x43, 0xE4, 0xBA, 0xA0, 0x43,
+	0xE4, 0xBA, 0xA4, 0x43, 0xE4, 0xBA, 0xAE, 0x43,
+	0xE4, 0xBA, 0xBA, 0x43, 0xE4, 0xBB, 0x80, 0x43,
+	0xE4, 0xBB, 0x8C, 0x43, 0xE4, 0xBB, 0xA4, 0x43,
+	// Bytes 740 - 77f
+	0xE4, 0xBC, 0x81, 0x43, 0xE4, 0xBC, 0x91, 0x43,
+	0xE4, 0xBD, 0xA0, 0x43, 0xE4, 0xBE, 0x80, 0x43,
+	0xE4, 0xBE, 0x86, 0x43, 0xE4, 0xBE, 0x8B, 0x43,
+	0xE4, 0xBE, 0xAE, 0x43, 0xE4, 0xBE, 0xBB, 0x43,
+	0xE4, 0xBE, 0xBF, 0x43, 0xE5, 0x80, 0x82, 0x43,
+	0xE5, 0x80, 0xAB, 0x43, 0xE5, 0x81, 0xBA, 0x43,
+	0xE5, 0x82, 0x99, 0x43, 0xE5, 0x83, 0x8F, 0x43,
+	0xE5, 0x83, 0x9A, 0x43, 0xE5, 0x83, 0xA7, 0x43,
+	// Bytes 780 - 7bf
+	0xE5, 0x84, 0xAA, 0x43, 0xE5, 0x84, 0xBF, 0x43,
+	0xE5, 0x85, 0x80, 0x43, 0xE5, 0x85, 0x85, 0x43,
+	0xE5, 0x85, 0x8D, 0x43, 0xE5, 0x85, 0x94, 0x43,
+	0xE5, 0x85, 0xA4, 0x43, 0xE5, 0x85, 0xA5, 0x43,
+	0xE5, 0x85, 0xA7, 0x43, 0xE5, 0x85, 0xA8, 0x43,
+	0xE5, 0x85, 0xA9, 0x43, 0xE5, 0x85, 0xAB, 0x43,
+	0xE5, 0x85, 0xAD, 0x43, 0xE5, 0x85, 0xB7, 0x43,
+	0xE5, 0x86, 0x80, 0x43, 0xE5, 0x86, 0x82, 0x43,
+	// Bytes 7c0 - 7ff
+	0xE5, 0x86, 0x8D, 0x43, 0xE5, 0x86, 0x92, 0x43,
+	0xE5, 0x86, 0x95, 0x43, 0xE5, 0x86, 0x96, 0x43,
+	0xE5, 0x86, 0x97, 0x43, 0xE5, 0x86, 0x99, 0x43,
+	0xE5, 0x86, 0xA4, 0x43, 0xE5, 0x86, 0xAB, 0x43,
+	0xE5, 0x86, 0xAC, 0x43, 0xE5, 0x86, 0xB5, 0x43,
+	0xE5, 0x86, 0xB7, 0x43, 0xE5, 0x87, 0x89, 0x43,
+	0xE5, 0x87, 0x8C, 0x43, 0xE5, 0x87, 0x9C, 0x43,
+	0xE5, 0x87, 0x9E, 0x43, 0xE5, 0x87, 0xA0, 0x43,
+	// Bytes 800 - 83f
+	0xE5, 0x87, 0xB5, 0x43, 0xE5, 0x88, 0x80, 0x43,
+	0xE5, 0x88, 0x83, 0x43, 0xE5, 0x88, 0x87, 0x43,
+	0xE5, 0x88, 0x97, 0x43, 0xE5, 0x88, 0x9D, 0x43,
+	0xE5, 0x88, 0xA9, 0x43, 0xE5, 0x88, 0xBA, 0x43,
+	0xE5, 0x88, 0xBB, 0x43, 0xE5, 0x89, 0x86, 0x43,
+	0xE5, 0x89, 0x8D, 0x43, 0xE5, 0x89, 0xB2, 0x43,
+	0xE5, 0x89, 0xB7, 0x43, 0xE5, 0x8A, 0x89, 0x43,
+	0xE5, 0x8A, 0x9B, 0x43, 0xE5, 0x8A, 0xA3, 0x43,
+	// Bytes 840 - 87f
+	0xE5, 0x8A, 0xB3, 0x43, 0xE5, 0x8A, 0xB4, 0x43,
+	0xE5, 0x8B, 0x87, 0x43, 0xE5, 0x8B, 0x89, 0x43,
+	0xE5, 0x8B, 0x92, 0x43, 0xE5, 0x8B, 0x9E, 0x43,
+	0xE5, 0x8B, 0xA4, 0x43, 0xE5, 0x8B, 0xB5, 0x43,
+	0xE5, 0x8B, 0xB9, 0x43, 0xE5, 0x8B, 0xBA, 0x43,
+	0xE5, 0x8C, 0x85, 0x43, 0xE5, 0x8C, 0x86, 0x43,
+	0xE5, 0x8C, 0x95, 0x43, 0xE5, 0x8C, 0x97, 0x43,
+	0xE5, 0x8C, 0x9A, 0x43, 0xE5, 0x8C, 0xB8, 0x43,
+	// Bytes 880 - 8bf
+	0xE5, 0x8C, 0xBB, 0x43, 0xE5, 0x8C, 0xBF, 0x43,
+	0xE5, 0x8D, 0x81, 0x43, 0xE5, 0x8D, 0x84, 0x43,
+	0xE5, 0x8D, 0x85, 0x43, 0xE5, 0x8D, 0x89, 0x43,
+	0xE5, 0x8D, 0x91, 0x43, 0xE5, 0x8D, 0x94, 0x43,
+	0xE5, 0x8D, 0x9A, 0x43, 0xE5, 0x8D, 0x9C, 0x43,
+	0xE5, 0x8D, 0xA9, 0x43, 0xE5, 0x8D, 0xB0, 0x43,
+	0xE5, 0x8D, 0xB3, 0x43, 0xE5, 0x8D, 0xB5, 0x43,
+	0xE5, 0x8D, 0xBD, 0x43, 0xE5, 0x8D, 0xBF, 0x43,
+	// Bytes 8c0 - 8ff
+	0xE5, 0x8E, 0x82, 0x43, 0xE5, 0x8E, 0xB6, 0x43,
+	0xE5, 0x8F, 0x83, 0x43, 0xE5, 0x8F, 0x88, 0x43,
+	0xE5, 0x8F, 0x8A, 0x43, 0xE5, 0x8F, 0x8C, 0x43,
+	0xE5, 0x8F, 0x9F, 0x43, 0xE5, 0x8F, 0xA3, 0x43,
+	0xE5, 0x8F, 0xA5, 0x43, 0xE5, 0x8F, 0xAB, 0x43,
+	0xE5, 0x8F, 0xAF, 0x43, 0xE5, 0x8F, 0xB1, 0x43,
+	0xE5, 0x8F, 0xB3, 0x43, 0xE5, 0x90, 0x86, 0x43,
+	0xE5, 0x90, 0x88, 0x43, 0xE5, 0x90, 0x8D, 0x43,
+	// Bytes 900 - 93f
+	0xE5, 0x90, 0x8F, 0x43, 0xE5, 0x90, 0x9D, 0x43,
+	0xE5, 0x90, 0xB8, 0x43, 0xE5, 0x90, 0xB9, 0x43,
+	0xE5, 0x91, 0x82, 0x43, 0xE5, 0x91, 0x88, 0x43,
+	0xE5, 0x91, 0xA8, 0x43, 0xE5, 0x92, 0x9E, 0x43,
+	0xE5, 0x92, 0xA2, 0x43, 0xE5, 0x92, 0xBD, 0x43,
+	0xE5, 0x93, 0xB6, 0x43, 0xE5, 0x94, 0x90, 0x43,
+	0xE5, 0x95, 0x8F, 0x43, 0xE5, 0x95, 0x93, 0x43,
+	0xE5, 0x95, 0x95, 0x43, 0xE5, 0x95, 0xA3, 0x43,
+	// Bytes 940 - 97f
+	0xE5, 0x96, 0x84, 0x43, 0xE5, 0x96, 0x87, 0x43,
+	0xE5, 0x96, 0x99, 0x43, 0xE5, 0x96, 0x9D, 0x43,
+	0xE5, 0x96, 0xAB, 0x43, 0xE5, 0x96, 0xB3, 0x43,
+	0xE5, 0x96, 0xB6, 0x43, 0xE5, 0x97, 0x80, 0x43,
+	0xE5, 0x97, 0x82, 0x43, 0xE5, 0x97, 0xA2, 0x43,
+	0xE5, 0x98, 0x86, 0x43, 0xE5, 0x99, 0x91, 0x43,
+	0xE5, 0x99, 0xA8, 0x43, 0xE5, 0x99, 0xB4, 0x43,
+	0xE5, 0x9B, 0x97, 0x43, 0xE5, 0x9B, 0x9B, 0x43,
+	// Bytes 980 - 9bf
+	0xE5, 0x9B, 0xB9, 0x43, 0xE5, 0x9C, 0x96, 0x43,
+	0xE5, 0x9C, 0x97, 0x43, 0xE5, 0x9C, 0x9F, 0x43,
+	0xE5, 0x9C, 0xB0, 0x43, 0xE5, 0x9E, 0x8B, 0x43,
+	0xE5, 0x9F, 0x8E, 0x43, 0xE5, 0x9F, 0xB4, 0x43,
+	0xE5, 0xA0, 0x8D, 0x43, 0xE5, 0xA0, 0xB1, 0x43,
+	0xE5, 0xA0, 0xB2, 0x43, 0xE5, 0xA1, 0x80, 0x43,
+	0xE5, 0xA1, 0x9A, 0x43, 0xE5, 0xA1, 0x9E, 0x43,
+	0xE5, 0xA2, 0xA8, 0x43, 0xE5, 0xA2, 0xAC, 0x43,
+	// Bytes 9c0 - 9ff
+	0xE5, 0xA2, 0xB3, 0x43, 0xE5, 0xA3, 0x98, 0x43,
+	0xE5, 0xA3, 0x9F, 0x43, 0xE5, 0xA3, 0xAB, 0x43,
+	0xE5, 0xA3, 0xAE, 0x43, 0xE5, 0xA3, 0xB0, 0x43,
+	0xE5, 0xA3, 0xB2, 0x43, 0xE5, 0xA3, 0xB7, 0x43,
+	0xE5, 0xA4, 0x82, 0x43, 0xE5, 0xA4, 0x86, 0x43,
+	0xE5, 0xA4, 0x8A, 0x43, 0xE5, 0xA4, 0x95, 0x43,
+	0xE5, 0xA4, 0x9A, 0x43, 0xE5, 0xA4, 0x9C, 0x43,
+	0xE5, 0xA4, 0xA2, 0x43, 0xE5, 0xA4, 0xA7, 0x43,
+	// Bytes a00 - a3f
+	0xE5, 0xA4, 0xA9, 0x43, 0xE5, 0xA5, 0x84, 0x43,
+	0xE5, 0xA5, 0x88, 0x43, 0xE5, 0xA5, 0x91, 0x43,
+	0xE5, 0xA5, 0x94, 0x43, 0xE5, 0xA5, 0xA2, 0x43,
+	0xE5, 0xA5, 0xB3, 0x43, 0xE5, 0xA7, 0x98, 0x43,
+	0xE5, 0xA7, 0xAC, 0x43, 0xE5, 0xA8, 0x9B, 0x43,
+	0xE5, 0xA8, 0xA7, 0x43, 0xE5, 0xA9, 0xA2, 0x43,
+	0xE5, 0xA9, 0xA6, 0x43, 0xE5, 0xAA, 0xB5, 0x43,
+	0xE5, 0xAC, 0x88, 0x43, 0xE5, 0xAC, 0xA8, 0x43,
+	// Bytes a40 - a7f
+	0xE5, 0xAC, 0xBE, 0x43, 0xE5, 0xAD, 0x90, 0x43,
+	0xE5, 0xAD, 0x97, 0x43, 0xE5, 0xAD, 0xA6, 0x43,
+	0xE5, 0xAE, 0x80, 0x43, 0xE5, 0xAE, 0x85, 0x43,
+	0xE5, 0xAE, 0x97, 0x43, 0xE5, 0xAF, 0x83, 0x43,
+	0xE5, 0xAF, 0x98, 0x43, 0xE5, 0xAF, 0xA7, 0x43,
+	0xE5, 0xAF, 0xAE, 0x43, 0xE5, 0xAF, 0xB3, 0x43,
+	0xE5, 0xAF, 0xB8, 0x43, 0xE5, 0xAF, 0xBF, 0x43,
+	0xE5, 0xB0, 0x86, 0x43, 0xE5, 0xB0, 0x8F, 0x43,
+	// Bytes a80 - abf
+	0xE5, 0xB0, 0xA2, 0x43, 0xE5, 0xB0, 0xB8, 0x43,
+	0xE5, 0xB0, 0xBF, 0x43, 0xE5, 0xB1, 0xA0, 0x43,
+	0xE5, 0xB1, 0xA2, 0x43, 0xE5, 0xB1, 0xA4, 0x43,
+	0xE5, 0xB1, 0xA5, 0x43, 0xE5, 0xB1, 0xAE, 0x43,
+	0xE5, 0xB1, 0xB1, 0x43, 0xE5, 0xB2, 0x8D, 0x43,
+	0xE5, 0xB3, 0x80, 0x43, 0xE5, 0xB4, 0x99, 0x43,
+	0xE5, 0xB5, 0x83, 0x43, 0xE5, 0xB5, 0x90, 0x43,
+	0xE5, 0xB5, 0xAB, 0x43, 0xE5, 0xB5, 0xAE, 0x43,
+	// Bytes ac0 - aff
+	0xE5, 0xB5, 0xBC, 0x43, 0xE5, 0xB6, 0xB2, 0x43,
+	0xE5, 0xB6, 0xBA, 0x43, 0xE5, 0xB7, 0x9B, 0x43,
+	0xE5, 0xB7, 0xA1, 0x43, 0xE5, 0xB7, 0xA2, 0x43,
+	0xE5, 0xB7, 0xA5, 0x43, 0xE5, 0xB7, 0xA6, 0x43,
+	0xE5, 0xB7, 0xB1, 0x43, 0xE5, 0xB7, 0xBD, 0x43,
+	0xE5, 0xB7, 0xBE, 0x43, 0xE5, 0xB8, 0xA8, 0x43,
+	0xE5, 0xB8, 0xBD, 0x43, 0xE5, 0xB9, 0xA9, 0x43,
+	0xE5, 0xB9, 0xB2, 0x43, 0xE5, 0xB9, 0xB4, 0x43,
+	// Bytes b00 - b3f
+	0xE5, 0xB9, 0xBA, 0x43, 0xE5, 0xB9, 0xBC, 0x43,
+	0xE5, 0xB9, 0xBF, 0x43, 0xE5, 0xBA, 0xA6, 0x43,
+	0xE5, 0xBA, 0xB0, 0x43, 0xE5, 0xBA, 0xB3, 0x43,
+	0xE5, 0xBA, 0xB6, 0x43, 0xE5, 0xBB, 0x89, 0x43,
+	0xE5, 0xBB, 0x8A, 0x43, 0xE5, 0xBB, 0x92, 0x43,
+	0xE5, 0xBB, 0x93, 0x43, 0xE5, 0xBB, 0x99, 0x43,
+	0xE5, 0xBB, 0xAC, 0x43, 0xE5, 0xBB, 0xB4, 0x43,
+	0xE5, 0xBB, 0xBE, 0x43, 0xE5, 0xBC, 0x84, 0x43,
+	// Bytes b40 - b7f
+	0xE5, 0xBC, 0x8B, 0x43, 0xE5, 0xBC, 0x93, 0x43,
+	0xE5, 0xBC, 0xA2, 0x43, 0xE5, 0xBD, 0x90, 0x43,
+	0xE5, 0xBD, 0x93, 0x43, 0xE5, 0xBD, 0xA1, 0x43,
+	0xE5, 0xBD, 0xA2, 0x43, 0xE5, 0xBD, 0xA9, 0x43,
+	0xE5, 0xBD, 0xAB, 0x43, 0xE5, 0xBD, 0xB3, 0x43,
+	0xE5, 0xBE, 0x8B, 0x43, 0xE5, 0xBE, 0x8C, 0x43,
+	0xE5, 0xBE, 0x97, 0x43, 0xE5, 0xBE, 0x9A, 0x43,
+	0xE5, 0xBE, 0xA9, 0x43, 0xE5, 0xBE, 0xAD, 0x43,
+	// Bytes b80 - bbf
+	0xE5, 0xBF, 0x83, 0x43, 0xE5, 0xBF, 0x8D, 0x43,
+	0xE5, 0xBF, 0x97, 0x43, 0xE5, 0xBF, 0xB5, 0x43,
+	0xE5, 0xBF, 0xB9, 0x43, 0xE6, 0x80, 0x92, 0x43,
+	0xE6, 0x80, 0x9C, 0x43, 0xE6, 0x81, 0xB5, 0x43,
+	0xE6, 0x82, 0x81, 0x43, 0xE6, 0x82, 0x94, 0x43,
+	0xE6, 0x83, 0x87, 0x43, 0xE6, 0x83, 0x98, 0x43,
+	0xE6, 0x83, 0xA1, 0x43, 0xE6, 0x84, 0x88, 0x43,
+	0xE6, 0x85, 0x84, 0x43, 0xE6, 0x85, 0x88, 0x43,
+	// Bytes bc0 - bff
+	0xE6, 0x85, 0x8C, 0x43, 0xE6, 0x85, 0x8E, 0x43,
+	0xE6, 0x85, 0xA0, 0x43, 0xE6, 0x85, 0xA8, 0x43,
+	0xE6, 0x85, 0xBA, 0x43, 0xE6, 0x86, 0x8E, 0x43,
+	0xE6, 0x86, 0x90, 0x43, 0xE6, 0x86, 0xA4, 0x43,
+	0xE6, 0x86, 0xAF, 0x43, 0xE6, 0x86, 0xB2, 0x43,
+	0xE6, 0x87, 0x9E, 0x43, 0xE6, 0x87, 0xB2, 0x43,
+	0xE6, 0x87, 0xB6, 0x43, 0xE6, 0x88, 0x80, 0x43,
+	0xE6, 0x88, 0x88, 0x43, 0xE6, 0x88, 0x90, 0x43,
+	// Bytes c00 - c3f
+	0xE6, 0x88, 0x9B, 0x43, 0xE6, 0x88, 0xAE, 0x43,
+	0xE6, 0x88, 0xB4, 0x43, 0xE6, 0x88, 0xB6, 0x43,
+	0xE6, 0x89, 0x8B, 0x43, 0xE6, 0x89, 0x93, 0x43,
+	0xE6, 0x89, 0x9D, 0x43, 0xE6, 0x8A, 0x95, 0x43,
+	0xE6, 0x8A, 0xB1, 0x43, 0xE6, 0x8B, 0x89, 0x43,
+	0xE6, 0x8B, 0x8F, 0x43, 0xE6, 0x8B, 0x93, 0x43,
+	0xE6, 0x8B, 0x94, 0x43, 0xE6, 0x8B, 0xBC, 0x43,
+	0xE6, 0x8B, 0xBE, 0x43, 0xE6, 0x8C, 0x87, 0x43,
+	// Bytes c40 - c7f
+	0xE6, 0x8C, 0xBD, 0x43, 0xE6, 0x8D, 0x90, 0x43,
+	0xE6, 0x8D, 0x95, 0x43, 0xE6, 0x8D, 0xA8, 0x43,
+	0xE6, 0x8D, 0xBB, 0x43, 0xE6, 0x8E, 0x83, 0x43,
+	0xE6, 0x8E, 0xA0, 0x43, 0xE6, 0x8E, 0xA9, 0x43,
+	0xE6, 0x8F, 0x84, 0x43, 0xE6, 0x8F, 0x85, 0x43,
+	0xE6, 0x8F, 0xA4, 0x43, 0xE6, 0x90, 0x9C, 0x43,
+	0xE6, 0x90, 0xA2, 0x43, 0xE6, 0x91, 0x92, 0x43,
+	0xE6, 0x91, 0xA9, 0x43, 0xE6, 0x91, 0xB7, 0x43,
+	// Bytes c80 - cbf
+	0xE6, 0x91, 0xBE, 0x43, 0xE6, 0x92, 0x9A, 0x43,
+	0xE6, 0x92, 0x9D, 0x43, 0xE6, 0x93, 0x84, 0x43,
+	0xE6, 0x94, 0xAF, 0x43, 0xE6, 0x94, 0xB4, 0x43,
+	0xE6, 0x95, 0x8F, 0x43, 0xE6, 0x95, 0x96, 0x43,
+	0xE6, 0x95, 0xAC, 0x43, 0xE6, 0x95, 0xB8, 0x43,
+	0xE6, 0x96, 0x87, 0x43, 0xE6, 0x96, 0x97, 0x43,
+	0xE6, 0x96, 0x99, 0x43, 0xE6, 0x96, 0xA4, 0x43,
+	0xE6, 0x96, 0xB0, 0x43, 0xE6, 0x96, 0xB9, 0x43,
+	// Bytes cc0 - cff
+	0xE6, 0x97, 0x85, 0x43, 0xE6, 0x97, 0xA0, 0x43,
+	0xE6, 0x97, 0xA2, 0x43, 0xE6, 0x97, 0xA3, 0x43,
+	0xE6, 0x97, 0xA5, 0x43, 0xE6, 0x98, 0x93, 0x43,
+	0xE6, 0x98, 0xA0, 0x43, 0xE6, 0x99, 0x89, 0x43,
+	0xE6, 0x99, 0xB4, 0x43, 0xE6, 0x9A, 0x88, 0x43,
+	0xE6, 0x9A, 0x91, 0x43, 0xE6, 0x9A, 0x9C, 0x43,
+	0xE6, 0x9A, 0xB4, 0x43, 0xE6, 0x9B, 0x86, 0x43,
+	0xE6, 0x9B, 0xB0, 0x43, 0xE6, 0x9B, 0xB4, 0x43,
+	// Bytes d00 - d3f
+	0xE6, 0x9B, 0xB8, 0x43, 0xE6, 0x9C, 0x80, 0x43,
+	0xE6, 0x9C, 0x88, 0x43, 0xE6, 0x9C, 0x89, 0x43,
+	0xE6, 0x9C, 0x97, 0x43, 0xE6, 0x9C, 0x9B, 0x43,
+	0xE6, 0x9C, 0xA1, 0x43, 0xE6, 0x9C, 0xA8, 0x43,
+	0xE6, 0x9D, 0x8E, 0x43, 0xE6, 0x9D, 0x93, 0x43,
+	0xE6, 0x9D, 0x96, 0x43, 0xE6, 0x9D, 0x9E, 0x43,
+	0xE6, 0x9D, 0xBB, 0x43, 0xE6, 0x9E, 0x85, 0x43,
+	0xE6, 0x9E, 0x97, 0x43, 0xE6, 0x9F, 0xB3, 0x43,
+	// Bytes d40 - d7f
+	0xE6, 0x9F, 0xBA, 0x43, 0xE6, 0xA0, 0x97, 0x43,
+	0xE6, 0xA0, 0x9F, 0x43, 0xE6, 0xA0, 0xAA, 0x43,
+	0xE6, 0xA1, 0x92, 0x43, 0xE6, 0xA2, 0x81, 0x43,
+	0xE6, 0xA2, 0x85, 0x43, 0xE6, 0xA2, 0x8E, 0x43,
+	0xE6, 0xA2, 0xA8, 0x43, 0xE6, 0xA4, 0x94, 0x43,
+	0xE6, 0xA5, 0x82, 0x43, 0xE6, 0xA6, 0xA3, 0x43,
+	0xE6, 0xA7, 0xAA, 0x43, 0xE6, 0xA8, 0x82, 0x43,
+	0xE6, 0xA8, 0x93, 0x43, 0xE6, 0xAA, 0xA8, 0x43,
+	// Bytes d80 - dbf
+	0xE6, 0xAB, 0x93, 0x43, 0xE6, 0xAB, 0x9B, 0x43,
+	0xE6, 0xAC, 0x84, 0x43, 0xE6, 0xAC, 0xA0, 0x43,
+	0xE6, 0xAC, 0xA1, 0x43, 0xE6, 0xAD, 0x94, 0x43,
+	0xE6, 0xAD, 0xA2, 0x43, 0xE6, 0xAD, 0xA3, 0x43,
+	0xE6, 0xAD, 0xB2, 0x43, 0xE6, 0xAD, 0xB7, 0x43,
+	0xE6, 0xAD, 0xB9, 0x43, 0xE6, 0xAE, 0x9F, 0x43,
+	0xE6, 0xAE, 0xAE, 0x43, 0xE6, 0xAE, 0xB3, 0x43,
+	0xE6, 0xAE, 0xBA, 0x43, 0xE6, 0xAE, 0xBB, 0x43,
+	// Bytes dc0 - dff
+	0xE6, 0xAF, 0x8B, 0x43, 0xE6, 0xAF, 0x8D, 0x43,
+	0xE6, 0xAF, 0x94, 0x43, 0xE6, 0xAF, 0x9B, 0x43,
+	0xE6, 0xB0, 0x8F, 0x43, 0xE6, 0xB0, 0x94, 0x43,
+	0xE6, 0xB0, 0xB4, 0x43, 0xE6, 0xB1, 0x8E, 0x43,
+	0xE6, 0xB1, 0xA7, 0x43, 0xE6, 0xB2, 0x88, 0x43,
+	0xE6, 0xB2, 0xBF, 0x43, 0xE6, 0xB3, 0x8C, 0x43,
+	0xE6, 0xB3, 0x8D, 0x43, 0xE6, 0xB3, 0xA5, 0x43,
+	0xE6, 0xB3, 0xA8, 0x43, 0xE6, 0xB4, 0x96, 0x43,
+	// Bytes e00 - e3f
+	0xE6, 0xB4, 0x9B, 0x43, 0xE6, 0xB4, 0x9E, 0x43,
+	0xE6, 0xB4, 0xB4, 0x43, 0xE6, 0xB4, 0xBE, 0x43,
+	0xE6, 0xB5, 0x81, 0x43, 0xE6, 0xB5, 0xA9, 0x43,
+	0xE6, 0xB5, 0xAA, 0x43, 0xE6, 0xB5, 0xB7, 0x43,
+	0xE6, 0xB5, 0xB8, 0x43, 0xE6, 0xB6, 0x85, 0x43,
+	0xE6, 0xB7, 0x8B, 0x43, 0xE6, 0xB7, 0x9A, 0x43,
+	0xE6, 0xB7, 0xAA, 0x43, 0xE6, 0xB7, 0xB9, 0x43,
+	0xE6, 0xB8, 0x9A, 0x43, 0xE6, 0xB8, 0xAF, 0x43,
+	// Bytes e40 - e7f
+	0xE6, 0xB9, 0xAE, 0x43, 0xE6, 0xBA, 0x80, 0x43,
+	0xE6, 0xBA, 0x9C, 0x43, 0xE6, 0xBA, 0xBA, 0x43,
+	0xE6, 0xBB, 0x87, 0x43, 0xE6, 0xBB, 0x8B, 0x43,
+	0xE6, 0xBB, 0x91, 0x43, 0xE6, 0xBB, 0x9B, 0x43,
+	0xE6, 0xBC, 0x8F, 0x43, 0xE6, 0xBC, 0x94, 0x43,
+	0xE6, 0xBC, 0xA2, 0x43, 0xE6, 0xBC, 0xA3, 0x43,
+	0xE6, 0xBD, 0xAE, 0x43, 0xE6, 0xBF, 0x86, 0x43,
+	0xE6, 0xBF, 0xAB, 0x43, 0xE6, 0xBF, 0xBE, 0x43,
+	// Bytes e80 - ebf
+	0xE7, 0x80, 0x9B, 0x43, 0xE7, 0x80, 0x9E, 0x43,
+	0xE7, 0x80, 0xB9, 0x43, 0xE7, 0x81, 0x8A, 0x43,
+	0xE7, 0x81, 0xAB, 0x43, 0xE7, 0x81, 0xB0, 0x43,
+	0xE7, 0x81, 0xB7, 0x43, 0xE7, 0x81, 0xBD, 0x43,
+	0xE7, 0x82, 0x99, 0x43, 0xE7, 0x82, 0xAD, 0x43,
+	0xE7, 0x83, 0x88, 0x43, 0xE7, 0x83, 0x99, 0x43,
+	0xE7, 0x84, 0xA1, 0x43, 0xE7, 0x85, 0x85, 0x43,
+	0xE7, 0x85, 0x89, 0x43, 0xE7, 0x85, 0xAE, 0x43,
+	// Bytes ec0 - eff
+	0xE7, 0x86, 0x9C, 0x43, 0xE7, 0x87, 0x8E, 0x43,
+	0xE7, 0x87, 0x90, 0x43, 0xE7, 0x88, 0x90, 0x43,
+	0xE7, 0x88, 0x9B, 0x43, 0xE7, 0x88, 0xA8, 0x43,
+	0xE7, 0x88, 0xAA, 0x43, 0xE7, 0x88, 0xAB, 0x43,
+	0xE7, 0x88, 0xB5, 0x43, 0xE7, 0x88, 0xB6, 0x43,
+	0xE7, 0x88, 0xBB, 0x43, 0xE7, 0x88, 0xBF, 0x43,
+	0xE7, 0x89, 0x87, 0x43, 0xE7, 0x89, 0x90, 0x43,
+	0xE7, 0x89, 0x99, 0x43, 0xE7, 0x89, 0x9B, 0x43,
+	// Bytes f00 - f3f
+	0xE7, 0x89, 0xA2, 0x43, 0xE7, 0x89, 0xB9, 0x43,
+	0xE7, 0x8A, 0x80, 0x43, 0xE7, 0x8A, 0x95, 0x43,
+	0xE7, 0x8A, 0xAC, 0x43, 0xE7, 0x8A, 0xAF, 0x43,
+	0xE7, 0x8B, 0x80, 0x43, 0xE7, 0x8B, 0xBC, 0x43,
+	0xE7, 0x8C, 0xAA, 0x43, 0xE7, 0x8D, 0xB5, 0x43,
+	0xE7, 0x8D, 0xBA, 0x43, 0xE7, 0x8E, 0x84, 0x43,
+	0xE7, 0x8E, 0x87, 0x43, 0xE7, 0x8E, 0x89, 0x43,
+	0xE7, 0x8E, 0x8B, 0x43, 0xE7, 0x8E, 0xA5, 0x43,
+	// Bytes f40 - f7f
+	0xE7, 0x8E, 0xB2, 0x43, 0xE7, 0x8F, 0x9E, 0x43,
+	0xE7, 0x90, 0x86, 0x43, 0xE7, 0x90, 0x89, 0x43,
+	0xE7, 0x90, 0xA2, 0x43, 0xE7, 0x91, 0x87, 0x43,
+	0xE7, 0x91, 0x9C, 0x43, 0xE7, 0x91, 0xA9, 0x43,
+	0xE7, 0x91, 0xB1, 0x43, 0xE7, 0x92, 0x85, 0x43,
+	0xE7, 0x92, 0x89, 0x43, 0xE7, 0x92, 0x98, 0x43,
+	0xE7, 0x93, 0x8A, 0x43, 0xE7, 0x93, 0x9C, 0x43,
+	0xE7, 0x93, 0xA6, 0x43, 0xE7, 0x94, 0x86, 0x43,
+	// Bytes f80 - fbf
+	0xE7, 0x94, 0x98, 0x43, 0xE7, 0x94, 0x9F, 0x43,
+	0xE7, 0x94, 0xA4, 0x43, 0xE7, 0x94, 0xA8, 0x43,
+	0xE7, 0x94, 0xB0, 0x43, 0xE7, 0x94, 0xB2, 0x43,
+	0xE7, 0x94, 0xB3, 0x43, 0xE7, 0x94, 0xB7, 0x43,
+	0xE7, 0x94, 0xBB, 0x43, 0xE7, 0x94, 0xBE, 0x43,
+	0xE7, 0x95, 0x99, 0x43, 0xE7, 0x95, 0xA5, 0x43,
+	0xE7, 0x95, 0xB0, 0x43, 0xE7, 0x96, 0x8B, 0x43,
+	0xE7, 0x96, 0x92, 0x43, 0xE7, 0x97, 0xA2, 0x43,
+	// Bytes fc0 - fff
+	0xE7, 0x98, 0x90, 0x43, 0xE7, 0x98, 0x9D, 0x43,
+	0xE7, 0x98, 0x9F, 0x43, 0xE7, 0x99, 0x82, 0x43,
+	0xE7, 0x99, 0xA9, 0x43, 0xE7, 0x99, 0xB6, 0x43,
+	0xE7, 0x99, 0xBD, 0x43, 0xE7, 0x9A, 0xAE, 0x43,
+	0xE7, 0x9A, 0xBF, 0x43, 0xE7, 0x9B, 0x8A, 0x43,
+	0xE7, 0x9B, 0x9B, 0x43, 0xE7, 0x9B, 0xA3, 0x43,
+	0xE7, 0x9B, 0xA7, 0x43, 0xE7, 0x9B, 0xAE, 0x43,
+	0xE7, 0x9B, 0xB4, 0x43, 0xE7, 0x9C, 0x81, 0x43,
+	// Bytes 1000 - 103f
+	0xE7, 0x9C, 0x9E, 0x43, 0xE7, 0x9C, 0x9F, 0x43,
+	0xE7, 0x9D, 0x80, 0x43, 0xE7, 0x9D, 0x8A, 0x43,
+	0xE7, 0x9E, 0x8B, 0x43, 0xE7, 0x9E, 0xA7, 0x43,
+	0xE7, 0x9F, 0x9B, 0x43, 0xE7, 0x9F, 0xA2, 0x43,
+	0xE7, 0x9F, 0xB3, 0x43, 0xE7, 0xA1, 0x8E, 0x43,
+	0xE7, 0xA1, 0xAB, 0x43, 0xE7, 0xA2, 0x8C, 0x43,
+	0xE7, 0xA2, 0x91, 0x43, 0xE7, 0xA3, 0x8A, 0x43,
+	0xE7, 0xA3, 0x8C, 0x43, 0xE7, 0xA3, 0xBB, 0x43,
+	// Bytes 1040 - 107f
+	0xE7, 0xA4, 0xAA, 0x43, 0xE7, 0xA4, 0xBA, 0x43,
+	0xE7, 0xA4, 0xBC, 0x43, 0xE7, 0xA4, 0xBE, 0x43,
+	0xE7, 0xA5, 0x88, 0x43, 0xE7, 0xA5, 0x89, 0x43,
+	0xE7, 0xA5, 0x90, 0x43, 0xE7, 0xA5, 0x96, 0x43,
+	0xE7, 0xA5, 0x9D, 0x43, 0xE7, 0xA5, 0x9E, 0x43,
+	0xE7, 0xA5, 0xA5, 0x43, 0xE7, 0xA5, 0xBF, 0x43,
+	0xE7, 0xA6, 0x81, 0x43, 0xE7, 0xA6, 0x8D, 0x43,
+	0xE7, 0xA6, 0x8E, 0x43, 0xE7, 0xA6, 0x8F, 0x43,
+	// Bytes 1080 - 10bf
+	0xE7, 0xA6, 0xAE, 0x43, 0xE7, 0xA6, 0xB8, 0x43,
+	0xE7, 0xA6, 0xBE, 0x43, 0xE7, 0xA7, 0x8A, 0x43,
+	0xE7, 0xA7, 0x98, 0x43, 0xE7, 0xA7, 0xAB, 0x43,
+	0xE7, 0xA8, 0x9C, 0x43, 0xE7, 0xA9, 0x80, 0x43,
+	0xE7, 0xA9, 0x8A, 0x43, 0xE7, 0xA9, 0x8F, 0x43,
+	0xE7, 0xA9, 0xB4, 0x43, 0xE7, 0xA9, 0xBA, 0x43,
+	0xE7, 0xAA, 0x81, 0x43, 0xE7, 0xAA, 0xB1, 0x43,
+	0xE7, 0xAB, 0x8B, 0x43, 0xE7, 0xAB, 0xAE, 0x43,
+	// Bytes 10c0 - 10ff
+	0xE7, 0xAB, 0xB9, 0x43, 0xE7, 0xAC, 0xA0, 0x43,
+	0xE7, 0xAE, 0x8F, 0x43, 0xE7, 0xAF, 0x80, 0x43,
+	0xE7, 0xAF, 0x86, 0x43, 0xE7, 0xAF, 0x89, 0x43,
+	0xE7, 0xB0, 0xBE, 0x43, 0xE7, 0xB1, 0xA0, 0x43,
+	0xE7, 0xB1, 0xB3, 0x43, 0xE7, 0xB1, 0xBB, 0x43,
+	0xE7, 0xB2, 0x92, 0x43, 0xE7, 0xB2, 0xBE, 0x43,
+	0xE7, 0xB3, 0x92, 0x43, 0xE7, 0xB3, 0x96, 0x43,
+	0xE7, 0xB3, 0xA3, 0x43, 0xE7, 0xB3, 0xA7, 0x43,
+	// Bytes 1100 - 113f
+	0xE7, 0xB3, 0xA8, 0x43, 0xE7, 0xB3, 0xB8, 0x43,
+	0xE7, 0xB4, 0x80, 0x43, 0xE7, 0xB4, 0x90, 0x43,
+	0xE7, 0xB4, 0xA2, 0x43, 0xE7, 0xB4, 0xAF, 0x43,
+	0xE7, 0xB5, 0x82, 0x43, 0xE7, 0xB5, 0x9B, 0x43,
+	0xE7, 0xB5, 0xA3, 0x43, 0xE7, 0xB6, 0xA0, 0x43,
+	0xE7, 0xB6, 0xBE, 0x43, 0xE7, 0xB7, 0x87, 0x43,
+	0xE7, 0xB7, 0xB4, 0x43, 0xE7, 0xB8, 0x82, 0x43,
+	0xE7, 0xB8, 0x89, 0x43, 0xE7, 0xB8, 0xB7, 0x43,
+	// Bytes 1140 - 117f
+	0xE7, 0xB9, 0x81, 0x43, 0xE7, 0xB9, 0x85, 0x43,
+	0xE7, 0xBC, 0xB6, 0x43, 0xE7, 0xBC, 0xBE, 0x43,
+	0xE7, 0xBD, 0x91, 0x43, 0xE7, 0xBD, 0xB2, 0x43,
+	0xE7, 0xBD, 0xB9, 0x43, 0xE7, 0xBD, 0xBA, 0x43,
+	0xE7, 0xBE, 0x85, 0x43, 0xE7, 0xBE, 0x8A, 0x43,
+	0xE7, 0xBE, 0x95, 0x43, 0xE7, 0xBE, 0x9A, 0x43,
+	0xE7, 0xBE, 0xBD, 0x43, 0xE7, 0xBF, 0xBA, 0x43,
+	0xE8, 0x80, 0x81, 0x43, 0xE8, 0x80, 0x85, 0x43,
+	// Bytes 1180 - 11bf
+	0xE8, 0x80, 0x8C, 0x43, 0xE8, 0x80, 0x92, 0x43,
+	0xE8, 0x80, 0xB3, 0x43, 0xE8, 0x81, 0x86, 0x43,
+	0xE8, 0x81, 0xA0, 0x43, 0xE8, 0x81, 0xAF, 0x43,
+	0xE8, 0x81, 0xB0, 0x43, 0xE8, 0x81, 0xBE, 0x43,
+	0xE8, 0x81, 0xBF, 0x43, 0xE8, 0x82, 0x89, 0x43,
+	0xE8, 0x82, 0x8B, 0x43, 0xE8, 0x82, 0xAD, 0x43,
+	0xE8, 0x82, 0xB2, 0x43, 0xE8, 0x84, 0x83, 0x43,
+	0xE8, 0x84, 0xBE, 0x43, 0xE8, 0x87, 0x98, 0x43,
+	// Bytes 11c0 - 11ff
+	0xE8, 0x87, 0xA3, 0x43, 0xE8, 0x87, 0xA8, 0x43,
+	0xE8, 0x87, 0xAA, 0x43, 0xE8, 0x87, 0xAD, 0x43,
+	0xE8, 0x87, 0xB3, 0x43, 0xE8, 0x87, 0xBC, 0x43,
+	0xE8, 0x88, 0x81, 0x43, 0xE8, 0x88, 0x84, 0x43,
+	0xE8, 0x88, 0x8C, 0x43, 0xE8, 0x88, 0x98, 0x43,
+	0xE8, 0x88, 0x9B, 0x43, 0xE8, 0x88, 0x9F, 0x43,
+	0xE8, 0x89, 0xAE, 0x43, 0xE8, 0x89, 0xAF, 0x43,
+	0xE8, 0x89, 0xB2, 0x43, 0xE8, 0x89, 0xB8, 0x43,
+	// Bytes 1200 - 123f
+	0xE8, 0x89, 0xB9, 0x43, 0xE8, 0x8A, 0x8B, 0x43,
+	0xE8, 0x8A, 0x91, 0x43, 0xE8, 0x8A, 0x9D, 0x43,
+	0xE8, 0x8A, 0xB1, 0x43, 0xE8, 0x8A, 0xB3, 0x43,
+	0xE8, 0x8A, 0xBD, 0x43, 0xE8, 0x8B, 0xA5, 0x43,
+	0xE8, 0x8B, 0xA6, 0x43, 0xE8, 0x8C, 0x9D, 0x43,
+	0xE8, 0x8C, 0xA3, 0x43, 0xE8, 0x8C, 0xB6, 0x43,
+	0xE8, 0x8D, 0x92, 0x43, 0xE8, 0x8D, 0x93, 0x43,
+	0xE8, 0x8D, 0xA3, 0x43, 0xE8, 0x8E, 0xAD, 0x43,
+	// Bytes 1240 - 127f
+	0xE8, 0x8E, 0xBD, 0x43, 0xE8, 0x8F, 0x89, 0x43,
+	0xE8, 0x8F, 0x8A, 0x43, 0xE8, 0x8F, 0x8C, 0x43,
+	0xE8, 0x8F, 0x9C, 0x43, 0xE8, 0x8F, 0xA7, 0x43,
+	0xE8, 0x8F, 0xAF, 0x43, 0xE8, 0x8F, 0xB1, 0x43,
+	0xE8, 0x90, 0xBD, 0x43, 0xE8, 0x91, 0x89, 0x43,
+	0xE8, 0x91, 0x97, 0x43, 0xE8, 0x93, 0xAE, 0x43,
+	0xE8, 0x93, 0xB1, 0x43, 0xE8, 0x93, 0xB3, 0x43,
+	0xE8, 0x93, 0xBC, 0x43, 0xE8, 0x94, 0x96, 0x43,
+	// Bytes 1280 - 12bf
+	0xE8, 0x95, 0xA4, 0x43, 0xE8, 0x97, 0x8D, 0x43,
+	0xE8, 0x97, 0xBA, 0x43, 0xE8, 0x98, 0x86, 0x43,
+	0xE8, 0x98, 0x92, 0x43, 0xE8, 0x98, 0xAD, 0x43,
+	0xE8, 0x98, 0xBF, 0x43, 0xE8, 0x99, 0x8D, 0x43,
+	0xE8, 0x99, 0x90, 0x43, 0xE8, 0x99, 0x9C, 0x43,
+	0xE8, 0x99, 0xA7, 0x43, 0xE8, 0x99, 0xA9, 0x43,
+	0xE8, 0x99, 0xAB, 0x43, 0xE8, 0x9A, 0x88, 0x43,
+	0xE8, 0x9A, 0xA9, 0x43, 0xE8, 0x9B, 0xA2, 0x43,
+	// Bytes 12c0 - 12ff
+	0xE8, 0x9C, 0x8E, 0x43, 0xE8, 0x9C, 0xA8, 0x43,
+	0xE8, 0x9D, 0xAB, 0x43, 0xE8, 0x9D, 0xB9, 0x43,
+	0xE8, 0x9E, 0x86, 0x43, 0xE8, 0x9E, 0xBA, 0x43,
+	0xE8, 0x9F, 0xA1, 0x43, 0xE8, 0xA0, 0x81, 0x43,
+	0xE8, 0xA0, 0x9F, 0x43, 0xE8, 0xA1, 0x80, 0x43,
+	0xE8, 0xA1, 0x8C, 0x43, 0xE8, 0xA1, 0xA0, 0x43,
+	0xE8, 0xA1, 0xA3, 0x43, 0xE8, 0xA3, 0x82, 0x43,
+	0xE8, 0xA3, 0x8F, 0x43, 0xE8, 0xA3, 0x97, 0x43,
+	// Bytes 1300 - 133f
+	0xE8, 0xA3, 0x9E, 0x43, 0xE8, 0xA3, 0xA1, 0x43,
+	0xE8, 0xA3, 0xB8, 0x43, 0xE8, 0xA3, 0xBA, 0x43,
+	0xE8, 0xA4, 0x90, 0x43, 0xE8, 0xA5, 0x81, 0x43,
+	0xE8, 0xA5, 0xA4, 0x43, 0xE8, 0xA5, 0xBE, 0x43,
+	0xE8, 0xA6, 0x86, 0x43, 0xE8, 0xA6, 0x8B, 0x43,
+	0xE8, 0xA6, 0x96, 0x43, 0xE8, 0xA7, 0x92, 0x43,
+	0xE8, 0xA7, 0xA3, 0x43, 0xE8, 0xA8, 0x80, 0x43,
+	0xE8, 0xAA, 0xA0, 0x43, 0xE8, 0xAA, 0xAA, 0x43,
+	// Bytes 1340 - 137f
+	0xE8, 0xAA, 0xBF, 0x43, 0xE8, 0xAB, 0x8B, 0x43,
+	0xE8, 0xAB, 0x92, 0x43, 0xE8, 0xAB, 0x96, 0x43,
+	0xE8, 0xAB, 0xAD, 0x43, 0xE8, 0xAB, 0xB8, 0x43,
+	0xE8, 0xAB, 0xBE, 0x43, 0xE8, 0xAC, 0x81, 0x43,
+	0xE8, 0xAC, 0xB9, 0x43, 0xE8, 0xAD, 0x98, 0x43,
+	0xE8, 0xAE, 0x80, 0x43, 0xE8, 0xAE, 0x8A, 0x43,
+	0xE8, 0xB0, 0xB7, 0x43, 0xE8, 0xB1, 0x86, 0x43,
+	0xE8, 0xB1, 0x88, 0x43, 0xE8, 0xB1, 0x95, 0x43,
+	// Bytes 1380 - 13bf
+	0xE8, 0xB1, 0xB8, 0x43, 0xE8, 0xB2, 0x9D, 0x43,
+	0xE8, 0xB2, 0xA1, 0x43, 0xE8, 0xB2, 0xA9, 0x43,
+	0xE8, 0xB2, 0xAB, 0x43, 0xE8, 0xB3, 0x81, 0x43,
+	0xE8, 0xB3, 0x82, 0x43, 0xE8, 0xB3, 0x87, 0x43,
+	0xE8, 0xB3, 0x88, 0x43, 0xE8, 0xB3, 0x93, 0x43,
+	0xE8, 0xB4, 0x88, 0x43, 0xE8, 0xB4, 0x9B, 0x43,
+	0xE8, 0xB5, 0xA4, 0x43, 0xE8, 0xB5, 0xB0, 0x43,
+	0xE8, 0xB5, 0xB7, 0x43, 0xE8, 0xB6, 0xB3, 0x43,
+	// Bytes 13c0 - 13ff
+	0xE8, 0xB6, 0xBC, 0x43, 0xE8, 0xB7, 0x8B, 0x43,
+	0xE8, 0xB7, 0xAF, 0x43, 0xE8, 0xB7, 0xB0, 0x43,
+	0xE8, 0xBA, 0xAB, 0x43, 0xE8, 0xBB, 0x8A, 0x43,
+	0xE8, 0xBB, 0x94, 0x43, 0xE8, 0xBC, 0xA6, 0x43,
+	0xE8, 0xBC, 0xAA, 0x43, 0xE8, 0xBC, 0xB8, 0x43,
+	0xE8, 0xBC, 0xBB, 0x43, 0xE8, 0xBD, 0xA2, 0x43,
+	0xE8, 0xBE, 0x9B, 0x43, 0xE8, 0xBE, 0x9E, 0x43,
+	0xE8, 0xBE, 0xB0, 0x43, 0xE8, 0xBE, 0xB5, 0x43,
+	// Bytes 1400 - 143f
+	0xE8, 0xBE, 0xB6, 0x43, 0xE9, 0x80, 0xA3, 0x43,
+	0xE9, 0x80, 0xB8, 0x43, 0xE9, 0x81, 0x8A, 0x43,
+	0xE9, 0x81, 0xA9, 0x43, 0xE9, 0x81, 0xB2, 0x43,
+	0xE9, 0x81, 0xBC, 0x43, 0xE9, 0x82, 0x8F, 0x43,
+	0xE9, 0x82, 0x91, 0x43, 0xE9, 0x82, 0x94, 0x43,
+	0xE9, 0x83, 0x8E, 0x43, 0xE9, 0x83, 0x9E, 0x43,
+	0xE9, 0x83, 0xB1, 0x43, 0xE9, 0x83, 0xBD, 0x43,
+	0xE9, 0x84, 0x91, 0x43, 0xE9, 0x84, 0x9B, 0x43,
+	// Bytes 1440 - 147f
+	0xE9, 0x85, 0x89, 0x43, 0xE9, 0x85, 0x8D, 0x43,
+	0xE9, 0x85, 0xAA, 0x43, 0xE9, 0x86, 0x99, 0x43,
+	0xE9, 0x86, 0xB4, 0x43, 0xE9, 0x87, 0x86, 0x43,
+	0xE9, 0x87, 0x8C, 0x43, 0xE9, 0x87, 0x8F, 0x43,
+	0xE9, 0x87, 0x91, 0x43, 0xE9, 0x88, 0xB4, 0x43,
+	0xE9, 0x88, 0xB8, 0x43, 0xE9, 0x89, 0xB6, 0x43,
+	0xE9, 0x89, 0xBC, 0x43, 0xE9, 0x8B, 0x97, 0x43,
+	0xE9, 0x8B, 0x98, 0x43, 0xE9, 0x8C, 0x84, 0x43,
+	// Bytes 1480 - 14bf
+	0xE9, 0x8D, 0x8A, 0x43, 0xE9, 0x8F, 0xB9, 0x43,
+	0xE9, 0x90, 0x95, 0x43, 0xE9, 0x95, 0xB7, 0x43,
+	0xE9, 0x96, 0x80, 0x43, 0xE9, 0x96, 0x8B, 0x43,
+	0xE9, 0x96, 0xAD, 0x43, 0xE9, 0x96, 0xB7, 0x43,
+	0xE9, 0x98, 0x9C, 0x43, 0xE9, 0x98, 0xAE, 0x43,
+	0xE9, 0x99, 0x8B, 0x43, 0xE9, 0x99, 0x8D, 0x43,
+	0xE9, 0x99, 0xB5, 0x43, 0xE9, 0x99, 0xB8, 0x43,
+	0xE9, 0x99, 0xBC, 0x43, 0xE9, 0x9A, 0x86, 0x43,
+	// Bytes 14c0 - 14ff
+	0xE9, 0x9A, 0xA3, 0x43, 0xE9, 0x9A, 0xB6, 0x43,
+	0xE9, 0x9A, 0xB7, 0x43, 0xE9, 0x9A, 0xB8, 0x43,
+	0xE9, 0x9A, 0xB9, 0x43, 0xE9, 0x9B, 0x83, 0x43,
+	0xE9, 0x9B, 0xA2, 0x43, 0xE9, 0x9B, 0xA3, 0x43,
+	0xE9, 0x9B, 0xA8, 0x43, 0xE9, 0x9B, 0xB6, 0x43,
+	0xE9, 0x9B, 0xB7, 0x43, 0xE9, 0x9C, 0xA3, 0x43,
+	0xE9, 0x9C, 0xB2, 0x43, 0xE9, 0x9D, 0x88, 0x43,
+	0xE9, 0x9D, 0x91, 0x43, 0xE9, 0x9D, 0x96, 0x43,
+	// Bytes 1500 - 153f
+	0xE9, 0x9D, 0x9E, 0x43, 0xE9, 0x9D, 0xA2, 0x43,
+	0xE9, 0x9D, 0xA9, 0x43, 0xE9, 0x9F, 0x8B, 0x43,
+	0xE9, 0x9F, 0x9B, 0x43, 0xE9, 0x9F, 0xA0, 0x43,
+	0xE9, 0x9F, 0xAD, 0x43, 0xE9, 0x9F, 0xB3, 0x43,
+	0xE9, 0x9F, 0xBF, 0x43, 0xE9, 0xA0, 0x81, 0x43,
+	0xE9, 0xA0, 0x85, 0x43, 0xE9, 0xA0, 0x8B, 0x43,
+	0xE9, 0xA0, 0x98, 0x43, 0xE9, 0xA0, 0xA9, 0x43,
+	0xE9, 0xA0, 0xBB, 0x43, 0xE9, 0xA1, 0x9E, 0x43,
+	// Bytes 1540 - 157f
+	0xE9, 0xA2, 0xA8, 0x43, 0xE9, 0xA3, 0x9B, 0x43,
+	0xE9, 0xA3, 0x9F, 0x43, 0xE9, 0xA3, 0xA2, 0x43,
+	0xE9, 0xA3, 0xAF, 0x43, 0xE9, 0xA3, 0xBC, 0x43,
+	0xE9, 0xA4, 0xA8, 0x43, 0xE9, 0xA4, 0xA9, 0x43,
+	0xE9, 0xA6, 0x96, 0x43, 0xE9, 0xA6, 0x99, 0x43,
+	0xE9, 0xA6, 0xA7, 0x43, 0xE9, 0xA6, 0xAC, 0x43,
+	0xE9, 0xA7, 0x82, 0x43, 0xE9, 0xA7, 0xB1, 0x43,
+	0xE9, 0xA7, 0xBE, 0x43, 0xE9, 0xA9, 0xAA, 0x43,
+	// Bytes 1580 - 15bf
+	0xE9, 0xAA, 0xA8, 0x43, 0xE9, 0xAB, 0x98, 0x43,
+	0xE9, 0xAB, 0x9F, 0x43, 0xE9, 0xAC, 0x92, 0x43,
+	0xE9, 0xAC, 0xA5, 0x43, 0xE9, 0xAC, 0xAF, 0x43,
+	0xE9, 0xAC, 0xB2, 0x43, 0xE9, 0xAC, 0xBC, 0x43,
+	0xE9, 0xAD, 0x9A, 0x43, 0xE9, 0xAD, 0xAF, 0x43,
+	0xE9, 0xB1, 0x80, 0x43, 0xE9, 0xB1, 0x97, 0x43,
+	0xE9, 0xB3, 0xA5, 0x43, 0xE9, 0xB3, 0xBD, 0x43,
+	0xE9, 0xB5, 0xA7, 0x43, 0xE9, 0xB6, 0xB4, 0x43,
+	// Bytes 15c0 - 15ff
+	0xE9, 0xB7, 0xBA, 0x43, 0xE9, 0xB8, 0x9E, 0x43,
+	0xE9, 0xB9, 0xB5, 0x43, 0xE9, 0xB9, 0xBF, 0x43,
+	0xE9, 0xBA, 0x97, 0x43, 0xE9, 0xBA, 0x9F, 0x43,
+	0xE9, 0xBA, 0xA5, 0x43, 0xE9, 0xBA, 0xBB, 0x43,
+	0xE9, 0xBB, 0x83, 0x43, 0xE9, 0xBB, 0x8D, 0x43,
+	0xE9, 0xBB, 0x8E, 0x43, 0xE9, 0xBB, 0x91, 0x43,
+	0xE9, 0xBB, 0xB9, 0x43, 0xE9, 0xBB, 0xBD, 0x43,
+	0xE9, 0xBB, 0xBE, 0x43, 0xE9, 0xBC, 0x85, 0x43,
+	// Bytes 1600 - 163f
+	0xE9, 0xBC, 0x8E, 0x43, 0xE9, 0xBC, 0x8F, 0x43,
+	0xE9, 0xBC, 0x93, 0x43, 0xE9, 0xBC, 0x96, 0x43,
+	0xE9, 0xBC, 0xA0, 0x43, 0xE9, 0xBC, 0xBB, 0x43,
+	0xE9, 0xBD, 0x83, 0x43, 0xE9, 0xBD, 0x8A, 0x43,
+	0xE9, 0xBD, 0x92, 0x43, 0xE9, 0xBE, 0x8D, 0x43,
+	0xE9, 0xBE, 0x8E, 0x43, 0xE9, 0xBE, 0x9C, 0x43,
+	0xE9, 0xBE, 0x9F, 0x43, 0xE9, 0xBE, 0xA0, 0x43,
+	0xEA, 0x9C, 0xA7, 0x43, 0xEA, 0x9D, 0xAF, 0x43,
+	// Bytes 1640 - 167f
+	0xEA, 0xAC, 0xB7, 0x43, 0xEA, 0xAD, 0x92, 0x44,
+	0xF0, 0xA0, 0x84, 0xA2, 0x44, 0xF0, 0xA0, 0x94,
+	0x9C, 0x44, 0xF0, 0xA0, 0x94, 0xA5, 0x44, 0xF0,
+	0xA0, 0x95, 0x8B, 0x44, 0xF0, 0xA0, 0x98, 0xBA,
+	0x44, 0xF0, 0xA0, 0xA0, 0x84, 0x44, 0xF0, 0xA0,
+	0xA3, 0x9E, 0x44, 0xF0, 0xA0, 0xA8, 0xAC, 0x44,
+	0xF0, 0xA0, 0xAD, 0xA3, 0x44, 0xF0, 0xA1, 0x93,
+	0xA4, 0x44, 0xF0, 0xA1, 0x9A, 0xA8, 0x44, 0xF0,
+	// Bytes 1680 - 16bf
+	0xA1, 0x9B, 0xAA, 0x44, 0xF0, 0xA1, 0xA7, 0x88,
+	0x44, 0xF0, 0xA1, 0xAC, 0x98, 0x44, 0xF0, 0xA1,
+	0xB4, 0x8B, 0x44, 0xF0, 0xA1, 0xB7, 0xA4, 0x44,
+	0xF0, 0xA1, 0xB7, 0xA6, 0x44, 0xF0, 0xA2, 0x86,
+	0x83, 0x44, 0xF0, 0xA2, 0x86, 0x9F, 0x44, 0xF0,
+	0xA2, 0x8C, 0xB1, 0x44, 0xF0, 0xA2, 0x9B, 0x94,
+	0x44, 0xF0, 0xA2, 0xA1, 0x84, 0x44, 0xF0, 0xA2,
+	0xA1, 0x8A, 0x44, 0xF0, 0xA2, 0xAC, 0x8C, 0x44,
+	// Bytes 16c0 - 16ff
+	0xF0, 0xA2, 0xAF, 0xB1, 0x44, 0xF0, 0xA3, 0x80,
+	0x8A, 0x44, 0xF0, 0xA3, 0x8A, 0xB8, 0x44, 0xF0,
+	0xA3, 0x8D, 0x9F, 0x44, 0xF0, 0xA3, 0x8E, 0x93,
+	0x44, 0xF0, 0xA3, 0x8E, 0x9C, 0x44, 0xF0, 0xA3,
+	0x8F, 0x83, 0x44, 0xF0, 0xA3, 0x8F, 0x95, 0x44,
+	0xF0, 0xA3, 0x91, 0xAD, 0x44, 0xF0, 0xA3, 0x9A,
+	0xA3, 0x44, 0xF0, 0xA3, 0xA2, 0xA7, 0x44, 0xF0,
+	0xA3, 0xAA, 0x8D, 0x44, 0xF0, 0xA3, 0xAB, 0xBA,
+	// Bytes 1700 - 173f
+	0x44, 0xF0, 0xA3, 0xB2, 0xBC, 0x44, 0xF0, 0xA3,
+	0xB4, 0x9E, 0x44, 0xF0, 0xA3, 0xBB, 0x91, 0x44,
+	0xF0, 0xA3, 0xBD, 0x9E, 0x44, 0xF0, 0xA3, 0xBE,
+	0x8E, 0x44, 0xF0, 0xA4, 0x89, 0xA3, 0x44, 0xF0,
+	0xA4, 0x8B, 0xAE, 0x44, 0xF0, 0xA4, 0x8E, 0xAB,
+	0x44, 0xF0, 0xA4, 0x98, 0x88, 0x44, 0xF0, 0xA4,
+	0x9C, 0xB5, 0x44, 0xF0, 0xA4, 0xA0, 0x94, 0x44,
+	0xF0, 0xA4, 0xB0, 0xB6, 0x44, 0xF0, 0xA4, 0xB2,
+	// Bytes 1740 - 177f
+	0x92, 0x44, 0xF0, 0xA4, 0xBE, 0xA1, 0x44, 0xF0,
+	0xA4, 0xBE, 0xB8, 0x44, 0xF0, 0xA5, 0x81, 0x84,
+	0x44, 0xF0, 0xA5, 0x83, 0xB2, 0x44, 0xF0, 0xA5,
+	0x83, 0xB3, 0x44, 0xF0, 0xA5, 0x84, 0x99, 0x44,
+	0xF0, 0xA5, 0x84, 0xB3, 0x44, 0xF0, 0xA5, 0x89,
+	0x89, 0x44, 0xF0, 0xA5, 0x90, 0x9D, 0x44, 0xF0,
+	0xA5, 0x98, 0xA6, 0x44, 0xF0, 0xA5, 0x9A, 0x9A,
+	0x44, 0xF0, 0xA5, 0x9B, 0x85, 0x44, 0xF0, 0xA5,
+	// Bytes 1780 - 17bf
+	0xA5, 0xBC, 0x44, 0xF0, 0xA5, 0xAA, 0xA7, 0x44,
+	0xF0, 0xA5, 0xAE, 0xAB, 0x44, 0xF0, 0xA5, 0xB2,
+	0x80, 0x44, 0xF0, 0xA5, 0xB3, 0x90, 0x44, 0xF0,
+	0xA5, 0xBE, 0x86, 0x44, 0xF0, 0xA6, 0x87, 0x9A,
+	0x44, 0xF0, 0xA6, 0x88, 0xA8, 0x44, 0xF0, 0xA6,
+	0x89, 0x87, 0x44, 0xF0, 0xA6, 0x8B, 0x99, 0x44,
+	0xF0, 0xA6, 0x8C, 0xBE, 0x44, 0xF0, 0xA6, 0x93,
+	0x9A, 0x44, 0xF0, 0xA6, 0x94, 0xA3, 0x44, 0xF0,
+	// Bytes 17c0 - 17ff
+	0xA6, 0x96, 0xA8, 0x44, 0xF0, 0xA6, 0x9E, 0xA7,
+	0x44, 0xF0, 0xA6, 0x9E, 0xB5, 0x44, 0xF0, 0xA6,
+	0xAC, 0xBC, 0x44, 0xF0, 0xA6, 0xB0, 0xB6, 0x44,
+	0xF0, 0xA6, 0xB3, 0x95, 0x44, 0xF0, 0xA6, 0xB5,
+	0xAB, 0x44, 0xF0, 0xA6, 0xBC, 0xAC, 0x44, 0xF0,
+	0xA6, 0xBE, 0xB1, 0x44, 0xF0, 0xA7, 0x83, 0x92,
+	0x44, 0xF0, 0xA7, 0x8F, 0x8A, 0x44, 0xF0, 0xA7,
+	0x99, 0xA7, 0x44, 0xF0, 0xA7, 0xA2, 0xAE, 0x44,
+	// Bytes 1800 - 183f
+	0xF0, 0xA7, 0xA5, 0xA6, 0x44, 0xF0, 0xA7, 0xB2,
+	0xA8, 0x44, 0xF0, 0xA7, 0xBB, 0x93, 0x44, 0xF0,
+	0xA7, 0xBC, 0xAF, 0x44, 0xF0, 0xA8, 0x97, 0x92,
+	0x44, 0xF0, 0xA8, 0x97, 0xAD, 0x44, 0xF0, 0xA8,
+	0x9C, 0xAE, 0x44, 0xF0, 0xA8, 0xAF, 0xBA, 0x44,
+	0xF0, 0xA8, 0xB5, 0xB7, 0x44, 0xF0, 0xA9, 0x85,
+	0x85, 0x44, 0xF0, 0xA9, 0x87, 0x9F, 0x44, 0xF0,
+	0xA9, 0x88, 0x9A, 0x44, 0xF0, 0xA9, 0x90, 0x8A,
+	// Bytes 1840 - 187f
+	0x44, 0xF0, 0xA9, 0x92, 0x96, 0x44, 0xF0, 0xA9,
+	0x96, 0xB6, 0x44, 0xF0, 0xA9, 0xAC, 0xB0, 0x44,
+	0xF0, 0xAA, 0x83, 0x8E, 0x44, 0xF0, 0xAA, 0x84,
+	0x85, 0x44, 0xF0, 0xAA, 0x88, 0x8E, 0x44, 0xF0,
+	0xAA, 0x8A, 0x91, 0x44, 0xF0, 0xAA, 0x8E, 0x92,
+	0x44, 0xF0, 0xAA, 0x98, 0x80, 0x42, 0x21, 0x21,
+	0x42, 0x21, 0x3F, 0x42, 0x2E, 0x2E, 0x42, 0x30,
+	0x2C, 0x42, 0x30, 0x2E, 0x42, 0x31, 0x2C, 0x42,
+	// Bytes 1880 - 18bf
+	0x31, 0x2E, 0x42, 0x31, 0x30, 0x42, 0x31, 0x31,
+	0x42, 0x31, 0x32, 0x42, 0x31, 0x33, 0x42, 0x31,
+	0x34, 0x42, 0x31, 0x35, 0x42, 0x31, 0x36, 0x42,
+	0x31, 0x37, 0x42, 0x31, 0x38, 0x42, 0x31, 0x39,
+	0x42, 0x32, 0x2C, 0x42, 0x32, 0x2E, 0x42, 0x32,
+	0x30, 0x42, 0x32, 0x31, 0x42, 0x32, 0x32, 0x42,
+	0x32, 0x33, 0x42, 0x32, 0x34, 0x42, 0x32, 0x35,
+	0x42, 0x32, 0x36, 0x42, 0x32, 0x37, 0x42, 0x32,
+	// Bytes 18c0 - 18ff
+	0x38, 0x42, 0x32, 0x39, 0x42, 0x33, 0x2C, 0x42,
+	0x33, 0x2E, 0x42, 0x33, 0x30, 0x42, 0x33, 0x31,
+	0x42, 0x33, 0x32, 0x42, 0x33, 0x33, 0x42, 0x33,
+	0x34, 0x42, 0x33, 0x35, 0x42, 0x33, 0x36, 0x42,
+	0x33, 0x37, 0x42, 0x33, 0x38, 0x42, 0x33, 0x39,
+	0x42, 0x34, 0x2C, 0x42, 0x34, 0x2E, 0x42, 0x34,
+	0x30, 0x42, 0x34, 0x31, 0x42, 0x34, 0x32, 0x42,
+	0x34, 0x33, 0x42, 0x34, 0x34, 0x42, 0x34, 0x35,
+	// Bytes 1900 - 193f
+	0x42, 0x34, 0x36, 0x42, 0x34, 0x37, 0x42, 0x34,
+	0x38, 0x42, 0x34, 0x39, 0x42, 0x35, 0x2C, 0x42,
+	0x35, 0x2E, 0x42, 0x35, 0x30, 0x42, 0x36, 0x2C,
+	0x42, 0x36, 0x2E, 0x42, 0x37, 0x2C, 0x42, 0x37,
+	0x2E, 0x42, 0x38, 0x2C, 0x42, 0x38, 0x2E, 0x42,
+	0x39, 0x2C, 0x42, 0x39, 0x2E, 0x42, 0x3D, 0x3D,
+	0x42, 0x3F, 0x21, 0x42, 0x3F, 0x3F, 0x42, 0x41,
+	0x55, 0x42, 0x42, 0x71, 0x42, 0x43, 0x44, 0x42,
+	// Bytes 1940 - 197f
+	0x44, 0x4A, 0x42, 0x44, 0x5A, 0x42, 0x44, 0x7A,
+	0x42, 0x47, 0x42, 0x42, 0x47, 0x79, 0x42, 0x48,
+	0x50, 0x42, 0x48, 0x56, 0x42, 0x48, 0x67, 0x42,
+	0x48, 0x7A, 0x42, 0x49, 0x49, 0x42, 0x49, 0x4A,
+	0x42, 0x49, 0x55, 0x42, 0x49, 0x56, 0x42, 0x49,
+	0x58, 0x42, 0x4B, 0x42, 0x42, 0x4B, 0x4B, 0x42,
+	0x4B, 0x4D, 0x42, 0x4C, 0x4A, 0x42, 0x4C, 0x6A,
+	0x42, 0x4D, 0x42, 0x42, 0x4D, 0x43, 0x42, 0x4D,
+	// Bytes 1980 - 19bf
+	0x44, 0x42, 0x4D, 0x56, 0x42, 0x4D, 0x57, 0x42,
+	0x4E, 0x4A, 0x42, 0x4E, 0x6A, 0x42, 0x4E, 0x6F,
+	0x42, 0x50, 0x48, 0x42, 0x50, 0x52, 0x42, 0x50,
+	0x61, 0x42, 0x52, 0x73, 0x42, 0x53, 0x44, 0x42,
+	0x53, 0x4D, 0x42, 0x53, 0x53, 0x42, 0x53, 0x76,
+	0x42, 0x54, 0x4D, 0x42, 0x56, 0x49, 0x42, 0x57,
+	0x43, 0x42, 0x57, 0x5A, 0x42, 0x57, 0x62, 0x42,
+	0x58, 0x49, 0x42, 0x63, 0x63, 0x42, 0x63, 0x64,
+	// Bytes 19c0 - 19ff
+	0x42, 0x63, 0x6D, 0x42, 0x64, 0x42, 0x42, 0x64,
+	0x61, 0x42, 0x64, 0x6C, 0x42, 0x64, 0x6D, 0x42,
+	0x64, 0x7A, 0x42, 0x65, 0x56, 0x42, 0x66, 0x66,
+	0x42, 0x66, 0x69, 0x42, 0x66, 0x6C, 0x42, 0x66,
+	0x6D, 0x42, 0x68, 0x61, 0x42, 0x69, 0x69, 0x42,
+	0x69, 0x6A, 0x42, 0x69, 0x6E, 0x42, 0x69, 0x76,
+	0x42, 0x69, 0x78, 0x42, 0x6B, 0x41, 0x42, 0x6B,
+	0x56, 0x42, 0x6B, 0x57, 0x42, 0x6B, 0x67, 0x42,
+	// Bytes 1a00 - 1a3f
+	0x6B, 0x6C, 0x42, 0x6B, 0x6D, 0x42, 0x6B, 0x74,
+	0x42, 0x6C, 0x6A, 0x42, 0x6C, 0x6D, 0x42, 0x6C,
+	0x6E, 0x42, 0x6C, 0x78, 0x42, 0x6D, 0x32, 0x42,
+	0x6D, 0x33, 0x42, 0x6D, 0x41, 0x42, 0x6D, 0x56,
+	0x42, 0x6D, 0x57, 0x42, 0x6D, 0x62, 0x42, 0x6D,
+	0x67, 0x42, 0x6D, 0x6C, 0x42, 0x6D, 0x6D, 0x42,
+	0x6D, 0x73, 0x42, 0x6E, 0x41, 0x42, 0x6E, 0x46,
+	0x42, 0x6E, 0x56, 0x42, 0x6E, 0x57, 0x42, 0x6E,
+	// Bytes 1a40 - 1a7f
+	0x6A, 0x42, 0x6E, 0x6D, 0x42, 0x6E, 0x73, 0x42,
+	0x6F, 0x56, 0x42, 0x70, 0x41, 0x42, 0x70, 0x46,
+	0x42, 0x70, 0x56, 0x42, 0x70, 0x57, 0x42, 0x70,
+	0x63, 0x42, 0x70, 0x73, 0x42, 0x73, 0x72, 0x42,
+	0x73, 0x74, 0x42, 0x76, 0x69, 0x42, 0x78, 0x69,
+	0x43, 0x28, 0x31, 0x29, 0x43, 0x28, 0x32, 0x29,
+	0x43, 0x28, 0x33, 0x29, 0x43, 0x28, 0x34, 0x29,
+	0x43, 0x28, 0x35, 0x29, 0x43, 0x28, 0x36, 0x29,
+	// Bytes 1a80 - 1abf
+	0x43, 0x28, 0x37, 0x29, 0x43, 0x28, 0x38, 0x29,
+	0x43, 0x28, 0x39, 0x29, 0x43, 0x28, 0x41, 0x29,
+	0x43, 0x28, 0x42, 0x29, 0x43, 0x28, 0x43, 0x29,
+	0x43, 0x28, 0x44, 0x29, 0x43, 0x28, 0x45, 0x29,
+	0x43, 0x28, 0x46, 0x29, 0x43, 0x28, 0x47, 0x29,
+	0x43, 0x28, 0x48, 0x29, 0x43, 0x28, 0x49, 0x29,
+	0x43, 0x28, 0x4A, 0x29, 0x43, 0x28, 0x4B, 0x29,
+	0x43, 0x28, 0x4C, 0x29, 0x43, 0x28, 0x4D, 0x29,
+	// Bytes 1ac0 - 1aff
+	0x43, 0x28, 0x4E, 0x29, 0x43, 0x28, 0x4F, 0x29,
+	0x43, 0x28, 0x50, 0x29, 0x43, 0x28, 0x51, 0x29,
+	0x43, 0x28, 0x52, 0x29, 0x43, 0x28, 0x53, 0x29,
+	0x43, 0x28, 0x54, 0x29, 0x43, 0x28, 0x55, 0x29,
+	0x43, 0x28, 0x56, 0x29, 0x43, 0x28, 0x57, 0x29,
+	0x43, 0x28, 0x58, 0x29, 0x43, 0x28, 0x59, 0x29,
+	0x43, 0x28, 0x5A, 0x29, 0x43, 0x28, 0x61, 0x29,
+	0x43, 0x28, 0x62, 0x29, 0x43, 0x28, 0x63, 0x29,
+	// Bytes 1b00 - 1b3f
+	0x43, 0x28, 0x64, 0x29, 0x43, 0x28, 0x65, 0x29,
+	0x43, 0x28, 0x66, 0x29, 0x43, 0x28, 0x67, 0x29,
+	0x43, 0x28, 0x68, 0x29, 0x43, 0x28, 0x69, 0x29,
+	0x43, 0x28, 0x6A, 0x29, 0x43, 0x28, 0x6B, 0x29,
+	0x43, 0x28, 0x6C, 0x29, 0x43, 0x28, 0x6D, 0x29,
+	0x43, 0x28, 0x6E, 0x29, 0x43, 0x28, 0x6F, 0x29,
+	0x43, 0x28, 0x70, 0x29, 0x43, 0x28, 0x71, 0x29,
+	0x43, 0x28, 0x72, 0x29, 0x43, 0x28, 0x73, 0x29,
+	// Bytes 1b40 - 1b7f
+	0x43, 0x28, 0x74, 0x29, 0x43, 0x28, 0x75, 0x29,
+	0x43, 0x28, 0x76, 0x29, 0x43, 0x28, 0x77, 0x29,
+	0x43, 0x28, 0x78, 0x29, 0x43, 0x28, 0x79, 0x29,
+	0x43, 0x28, 0x7A, 0x29, 0x43, 0x2E, 0x2E, 0x2E,
+	0x43, 0x31, 0x30, 0x2E, 0x43, 0x31, 0x31, 0x2E,
+	0x43, 0x31, 0x32, 0x2E, 0x43, 0x31, 0x33, 0x2E,
+	0x43, 0x31, 0x34, 0x2E, 0x43, 0x31, 0x35, 0x2E,
+	0x43, 0x31, 0x36, 0x2E, 0x43, 0x31, 0x37, 0x2E,
+	// Bytes 1b80 - 1bbf
+	0x43, 0x31, 0x38, 0x2E, 0x43, 0x31, 0x39, 0x2E,
+	0x43, 0x32, 0x30, 0x2E, 0x43, 0x3A, 0x3A, 0x3D,
+	0x43, 0x3D, 0x3D, 0x3D, 0x43, 0x43, 0x6F, 0x2E,
+	0x43, 0x46, 0x41, 0x58, 0x43, 0x47, 0x48, 0x7A,
+	0x43, 0x47, 0x50, 0x61, 0x43, 0x49, 0x49, 0x49,
+	0x43, 0x4C, 0x54, 0x44, 0x43, 0x4C, 0xC2, 0xB7,
+	0x43, 0x4D, 0x48, 0x7A, 0x43, 0x4D, 0x50, 0x61,
+	0x43, 0x4D, 0xCE, 0xA9, 0x43, 0x50, 0x50, 0x4D,
+	// Bytes 1bc0 - 1bff
+	0x43, 0x50, 0x50, 0x56, 0x43, 0x50, 0x54, 0x45,
+	0x43, 0x54, 0x45, 0x4C, 0x43, 0x54, 0x48, 0x7A,
+	0x43, 0x56, 0x49, 0x49, 0x43, 0x58, 0x49, 0x49,
+	0x43, 0x61, 0x2F, 0x63, 0x43, 0x61, 0x2F, 0x73,
+	0x43, 0x61, 0xCA, 0xBE, 0x43, 0x62, 0x61, 0x72,
+	0x43, 0x63, 0x2F, 0x6F, 0x43, 0x63, 0x2F, 0x75,
+	0x43, 0x63, 0x61, 0x6C, 0x43, 0x63, 0x6D, 0x32,
+	0x43, 0x63, 0x6D, 0x33, 0x43, 0x64, 0x6D, 0x32,
+	// Bytes 1c00 - 1c3f
+	0x43, 0x64, 0x6D, 0x33, 0x43, 0x65, 0x72, 0x67,
+	0x43, 0x66, 0x66, 0x69, 0x43, 0x66, 0x66, 0x6C,
+	0x43, 0x67, 0x61, 0x6C, 0x43, 0x68, 0x50, 0x61,
+	0x43, 0x69, 0x69, 0x69, 0x43, 0x6B, 0x48, 0x7A,
+	0x43, 0x6B, 0x50, 0x61, 0x43, 0x6B, 0x6D, 0x32,
+	0x43, 0x6B, 0x6D, 0x33, 0x43, 0x6B, 0xCE, 0xA9,
+	0x43, 0x6C, 0x6F, 0x67, 0x43, 0x6C, 0xC2, 0xB7,
+	0x43, 0x6D, 0x69, 0x6C, 0x43, 0x6D, 0x6D, 0x32,
+	// Bytes 1c40 - 1c7f
+	0x43, 0x6D, 0x6D, 0x33, 0x43, 0x6D, 0x6F, 0x6C,
+	0x43, 0x72, 0x61, 0x64, 0x43, 0x76, 0x69, 0x69,
+	0x43, 0x78, 0x69, 0x69, 0x43, 0xC2, 0xB0, 0x43,
+	0x43, 0xC2, 0xB0, 0x46, 0x43, 0xCA, 0xBC, 0x6E,
+	0x43, 0xCE, 0xBC, 0x41, 0x43, 0xCE, 0xBC, 0x46,
+	0x43, 0xCE, 0xBC, 0x56, 0x43, 0xCE, 0xBC, 0x57,
+	0x43, 0xCE, 0xBC, 0x67, 0x43, 0xCE, 0xBC, 0x6C,
+	0x43, 0xCE, 0xBC, 0x6D, 0x43, 0xCE, 0xBC, 0x73,
+	// Bytes 1c80 - 1cbf
+	0x44, 0x28, 0x31, 0x30, 0x29, 0x44, 0x28, 0x31,
+	0x31, 0x29, 0x44, 0x28, 0x31, 0x32, 0x29, 0x44,
+	0x28, 0x31, 0x33, 0x29, 0x44, 0x28, 0x31, 0x34,
+	0x29, 0x44, 0x28, 0x31, 0x35, 0x29, 0x44, 0x28,
+	0x31, 0x36, 0x29, 0x44, 0x28, 0x31, 0x37, 0x29,
+	0x44, 0x28, 0x31, 0x38, 0x29, 0x44, 0x28, 0x31,
+	0x39, 0x29, 0x44, 0x28, 0x32, 0x30, 0x29, 0x44,
+	0x30, 0xE7, 0x82, 0xB9, 0x44, 0x31, 0xE2, 0x81,
+	// Bytes 1cc0 - 1cff
+	0x84, 0x44, 0x31, 0xE6, 0x97, 0xA5, 0x44, 0x31,
+	0xE6, 0x9C, 0x88, 0x44, 0x31, 0xE7, 0x82, 0xB9,
+	0x44, 0x32, 0xE6, 0x97, 0xA5, 0x44, 0x32, 0xE6,
+	0x9C, 0x88, 0x44, 0x32, 0xE7, 0x82, 0xB9, 0x44,
+	0x33, 0xE6, 0x97, 0xA5, 0x44, 0x33, 0xE6, 0x9C,
+	0x88, 0x44, 0x33, 0xE7, 0x82, 0xB9, 0x44, 0x34,
+	0xE6, 0x97, 0xA5, 0x44, 0x34, 0xE6, 0x9C, 0x88,
+	0x44, 0x34, 0xE7, 0x82, 0xB9, 0x44, 0x35, 0xE6,
+	// Bytes 1d00 - 1d3f
+	0x97, 0xA5, 0x44, 0x35, 0xE6, 0x9C, 0x88, 0x44,
+	0x35, 0xE7, 0x82, 0xB9, 0x44, 0x36, 0xE6, 0x97,
+	0xA5, 0x44, 0x36, 0xE6, 0x9C, 0x88, 0x44, 0x36,
+	0xE7, 0x82, 0xB9, 0x44, 0x37, 0xE6, 0x97, 0xA5,
+	0x44, 0x37, 0xE6, 0x9C, 0x88, 0x44, 0x37, 0xE7,
+	0x82, 0xB9, 0x44, 0x38, 0xE6, 0x97, 0xA5, 0x44,
+	0x38, 0xE6, 0x9C, 0x88, 0x44, 0x38, 0xE7, 0x82,
+	0xB9, 0x44, 0x39, 0xE6, 0x97, 0xA5, 0x44, 0x39,
+	// Bytes 1d40 - 1d7f
+	0xE6, 0x9C, 0x88, 0x44, 0x39, 0xE7, 0x82, 0xB9,
+	0x44, 0x56, 0x49, 0x49, 0x49, 0x44, 0x61, 0x2E,
+	0x6D, 0x2E, 0x44, 0x6B, 0x63, 0x61, 0x6C, 0x44,
+	0x70, 0x2E, 0x6D, 0x2E, 0x44, 0x76, 0x69, 0x69,
+	0x69, 0x44, 0xD5, 0xA5, 0xD6, 0x82, 0x44, 0xD5,
+	0xB4, 0xD5, 0xA5, 0x44, 0xD5, 0xB4, 0xD5, 0xAB,
+	0x44, 0xD5, 0xB4, 0xD5, 0xAD, 0x44, 0xD5, 0xB4,
+	0xD5, 0xB6, 0x44, 0xD5, 0xBE, 0xD5, 0xB6, 0x44,
+	// Bytes 1d80 - 1dbf
+	0xD7, 0x90, 0xD7, 0x9C, 0x44, 0xD8, 0xA7, 0xD9,
+	0xB4, 0x44, 0xD8, 0xA8, 0xD8, 0xAC, 0x44, 0xD8,
+	0xA8, 0xD8, 0xAD, 0x44, 0xD8, 0xA8, 0xD8, 0xAE,
+	0x44, 0xD8, 0xA8, 0xD8, 0xB1, 0x44, 0xD8, 0xA8,
+	0xD8, 0xB2, 0x44, 0xD8, 0xA8, 0xD9, 0x85, 0x44,
+	0xD8, 0xA8, 0xD9, 0x86, 0x44, 0xD8, 0xA8, 0xD9,
+	0x87, 0x44, 0xD8, 0xA8, 0xD9, 0x89, 0x44, 0xD8,
+	0xA8, 0xD9, 0x8A, 0x44, 0xD8, 0xAA, 0xD8, 0xAC,
+	// Bytes 1dc0 - 1dff
+	0x44, 0xD8, 0xAA, 0xD8, 0xAD, 0x44, 0xD8, 0xAA,
+	0xD8, 0xAE, 0x44, 0xD8, 0xAA, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAA, 0xD8, 0xB2, 0x44, 0xD8, 0xAA, 0xD9,
+	0x85, 0x44, 0xD8, 0xAA, 0xD9, 0x86, 0x44, 0xD8,
+	0xAA, 0xD9, 0x87, 0x44, 0xD8, 0xAA, 0xD9, 0x89,
+	0x44, 0xD8, 0xAA, 0xD9, 0x8A, 0x44, 0xD8, 0xAB,
+	0xD8, 0xAC, 0x44, 0xD8, 0xAB, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAB, 0xD8, 0xB2, 0x44, 0xD8, 0xAB, 0xD9,
+	// Bytes 1e00 - 1e3f
+	0x85, 0x44, 0xD8, 0xAB, 0xD9, 0x86, 0x44, 0xD8,
+	0xAB, 0xD9, 0x87, 0x44, 0xD8, 0xAB, 0xD9, 0x89,
+	0x44, 0xD8, 0xAB, 0xD9, 0x8A, 0x44, 0xD8, 0xAC,
+	0xD8, 0xAD, 0x44, 0xD8, 0xAC, 0xD9, 0x85, 0x44,
+	0xD8, 0xAC, 0xD9, 0x89, 0x44, 0xD8, 0xAC, 0xD9,
+	0x8A, 0x44, 0xD8, 0xAD, 0xD8, 0xAC, 0x44, 0xD8,
+	0xAD, 0xD9, 0x85, 0x44, 0xD8, 0xAD, 0xD9, 0x89,
+	0x44, 0xD8, 0xAD, 0xD9, 0x8A, 0x44, 0xD8, 0xAE,
+	// Bytes 1e40 - 1e7f
+	0xD8, 0xAC, 0x44, 0xD8, 0xAE, 0xD8, 0xAD, 0x44,
+	0xD8, 0xAE, 0xD9, 0x85, 0x44, 0xD8, 0xAE, 0xD9,
+	0x89, 0x44, 0xD8, 0xAE, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB3, 0xD8, 0xAC, 0x44, 0xD8, 0xB3, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB3, 0xD8, 0xAE, 0x44, 0xD8, 0xB3,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB3, 0xD9, 0x85, 0x44,
+	0xD8, 0xB3, 0xD9, 0x87, 0x44, 0xD8, 0xB3, 0xD9,
+	0x89, 0x44, 0xD8, 0xB3, 0xD9, 0x8A, 0x44, 0xD8,
+	// Bytes 1e80 - 1ebf
+	0xB4, 0xD8, 0xAC, 0x44, 0xD8, 0xB4, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB4, 0xD8, 0xAE, 0x44, 0xD8, 0xB4,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB4, 0xD9, 0x85, 0x44,
+	0xD8, 0xB4, 0xD9, 0x87, 0x44, 0xD8, 0xB4, 0xD9,
+	0x89, 0x44, 0xD8, 0xB4, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB5, 0xD8, 0xAD, 0x44, 0xD8, 0xB5, 0xD8, 0xAE,
+	0x44, 0xD8, 0xB5, 0xD8, 0xB1, 0x44, 0xD8, 0xB5,
+	0xD9, 0x85, 0x44, 0xD8, 0xB5, 0xD9, 0x89, 0x44,
+	// Bytes 1ec0 - 1eff
+	0xD8, 0xB5, 0xD9, 0x8A, 0x44, 0xD8, 0xB6, 0xD8,
+	0xAC, 0x44, 0xD8, 0xB6, 0xD8, 0xAD, 0x44, 0xD8,
+	0xB6, 0xD8, 0xAE, 0x44, 0xD8, 0xB6, 0xD8, 0xB1,
+	0x44, 0xD8, 0xB6, 0xD9, 0x85, 0x44, 0xD8, 0xB6,
+	0xD9, 0x89, 0x44, 0xD8, 0xB6, 0xD9, 0x8A, 0x44,
+	0xD8, 0xB7, 0xD8, 0xAD, 0x44, 0xD8, 0xB7, 0xD9,
+	0x85, 0x44, 0xD8, 0xB7, 0xD9, 0x89, 0x44, 0xD8,
+	0xB7, 0xD9, 0x8A, 0x44, 0xD8, 0xB8, 0xD9, 0x85,
+	// Bytes 1f00 - 1f3f
+	0x44, 0xD8, 0xB9, 0xD8, 0xAC, 0x44, 0xD8, 0xB9,
+	0xD9, 0x85, 0x44, 0xD8, 0xB9, 0xD9, 0x89, 0x44,
+	0xD8, 0xB9, 0xD9, 0x8A, 0x44, 0xD8, 0xBA, 0xD8,
+	0xAC, 0x44, 0xD8, 0xBA, 0xD9, 0x85, 0x44, 0xD8,
+	0xBA, 0xD9, 0x89, 0x44, 0xD8, 0xBA, 0xD9, 0x8A,
+	0x44, 0xD9, 0x81, 0xD8, 0xAC, 0x44, 0xD9, 0x81,
+	0xD8, 0xAD, 0x44, 0xD9, 0x81, 0xD8, 0xAE, 0x44,
+	0xD9, 0x81, 0xD9, 0x85, 0x44, 0xD9, 0x81, 0xD9,
+	// Bytes 1f40 - 1f7f
+	0x89, 0x44, 0xD9, 0x81, 0xD9, 0x8A, 0x44, 0xD9,
+	0x82, 0xD8, 0xAD, 0x44, 0xD9, 0x82, 0xD9, 0x85,
+	0x44, 0xD9, 0x82, 0xD9, 0x89, 0x44, 0xD9, 0x82,
+	0xD9, 0x8A, 0x44, 0xD9, 0x83, 0xD8, 0xA7, 0x44,
+	0xD9, 0x83, 0xD8, 0xAC, 0x44, 0xD9, 0x83, 0xD8,
+	0xAD, 0x44, 0xD9, 0x83, 0xD8, 0xAE, 0x44, 0xD9,
+	0x83, 0xD9, 0x84, 0x44, 0xD9, 0x83, 0xD9, 0x85,
+	0x44, 0xD9, 0x83, 0xD9, 0x89, 0x44, 0xD9, 0x83,
+	// Bytes 1f80 - 1fbf
+	0xD9, 0x8A, 0x44, 0xD9, 0x84, 0xD8, 0xA7, 0x44,
+	0xD9, 0x84, 0xD8, 0xAC, 0x44, 0xD9, 0x84, 0xD8,
+	0xAD, 0x44, 0xD9, 0x84, 0xD8, 0xAE, 0x44, 0xD9,
+	0x84, 0xD9, 0x85, 0x44, 0xD9, 0x84, 0xD9, 0x87,
+	0x44, 0xD9, 0x84, 0xD9, 0x89, 0x44, 0xD9, 0x84,
+	0xD9, 0x8A, 0x44, 0xD9, 0x85, 0xD8, 0xA7, 0x44,
+	0xD9, 0x85, 0xD8, 0xAC, 0x44, 0xD9, 0x85, 0xD8,
+	0xAD, 0x44, 0xD9, 0x85, 0xD8, 0xAE, 0x44, 0xD9,
+	// Bytes 1fc0 - 1fff
+	0x85, 0xD9, 0x85, 0x44, 0xD9, 0x85, 0xD9, 0x89,
+	0x44, 0xD9, 0x85, 0xD9, 0x8A, 0x44, 0xD9, 0x86,
+	0xD8, 0xAC, 0x44, 0xD9, 0x86, 0xD8, 0xAD, 0x44,
+	0xD9, 0x86, 0xD8, 0xAE, 0x44, 0xD9, 0x86, 0xD8,
+	0xB1, 0x44, 0xD9, 0x86, 0xD8, 0xB2, 0x44, 0xD9,
+	0x86, 0xD9, 0x85, 0x44, 0xD9, 0x86, 0xD9, 0x86,
+	0x44, 0xD9, 0x86, 0xD9, 0x87, 0x44, 0xD9, 0x86,
+	0xD9, 0x89, 0x44, 0xD9, 0x86, 0xD9, 0x8A, 0x44,
+	// Bytes 2000 - 203f
+	0xD9, 0x87, 0xD8, 0xAC, 0x44, 0xD9, 0x87, 0xD9,
+	0x85, 0x44, 0xD9, 0x87, 0xD9, 0x89, 0x44, 0xD9,
+	0x87, 0xD9, 0x8A, 0x44, 0xD9, 0x88, 0xD9, 0xB4,
+	0x44, 0xD9, 0x8A, 0xD8, 0xAC, 0x44, 0xD9, 0x8A,
+	0xD8, 0xAD, 0x44, 0xD9, 0x8A, 0xD8, 0xAE, 0x44,
+	0xD9, 0x8A, 0xD8, 0xB1, 0x44, 0xD9, 0x8A, 0xD8,
+	0xB2, 0x44, 0xD9, 0x8A, 0xD9, 0x85, 0x44, 0xD9,
+	0x8A, 0xD9, 0x86, 0x44, 0xD9, 0x8A, 0xD9, 0x87,
+	// Bytes 2040 - 207f
+	0x44, 0xD9, 0x8A, 0xD9, 0x89, 0x44, 0xD9, 0x8A,
+	0xD9, 0x8A, 0x44, 0xD9, 0x8A, 0xD9, 0xB4, 0x44,
+	0xDB, 0x87, 0xD9, 0xB4, 0x45, 0x28, 0xE1, 0x84,
+	0x80, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x82, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x83, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x85, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x86, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x87, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x89, 0x29, 0x45, 0x28,
+	// Bytes 2080 - 20bf
+	0xE1, 0x84, 0x8B, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x8C, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x8E, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x8F, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x90, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x91, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x92, 0x29,
+	0x45, 0x28, 0xE4, 0xB8, 0x80, 0x29, 0x45, 0x28,
+	0xE4, 0xB8, 0x83, 0x29, 0x45, 0x28, 0xE4, 0xB8,
+	0x89, 0x29, 0x45, 0x28, 0xE4, 0xB9, 0x9D, 0x29,
+	// Bytes 20c0 - 20ff
+	0x45, 0x28, 0xE4, 0xBA, 0x8C, 0x29, 0x45, 0x28,
+	0xE4, 0xBA, 0x94, 0x29, 0x45, 0x28, 0xE4, 0xBB,
+	0xA3, 0x29, 0x45, 0x28, 0xE4, 0xBC, 0x81, 0x29,
+	0x45, 0x28, 0xE4, 0xBC, 0x91, 0x29, 0x45, 0x28,
+	0xE5, 0x85, 0xAB, 0x29, 0x45, 0x28, 0xE5, 0x85,
+	0xAD, 0x29, 0x45, 0x28, 0xE5, 0x8A, 0xB4, 0x29,
+	0x45, 0x28, 0xE5, 0x8D, 0x81, 0x29, 0x45, 0x28,
+	0xE5, 0x8D, 0x94, 0x29, 0x45, 0x28, 0xE5, 0x90,
+	// Bytes 2100 - 213f
+	0x8D, 0x29, 0x45, 0x28, 0xE5, 0x91, 0xBC, 0x29,
+	0x45, 0x28, 0xE5, 0x9B, 0x9B, 0x29, 0x45, 0x28,
+	0xE5, 0x9C, 0x9F, 0x29, 0x45, 0x28, 0xE5, 0xAD,
+	0xA6, 0x29, 0x45, 0x28, 0xE6, 0x97, 0xA5, 0x29,
+	0x45, 0x28, 0xE6, 0x9C, 0x88, 0x29, 0x45, 0x28,
+	0xE6, 0x9C, 0x89, 0x29, 0x45, 0x28, 0xE6, 0x9C,
+	0xA8, 0x29, 0x45, 0x28, 0xE6, 0xA0, 0xAA, 0x29,
+	0x45, 0x28, 0xE6, 0xB0, 0xB4, 0x29, 0x45, 0x28,
+	// Bytes 2140 - 217f
+	0xE7, 0x81, 0xAB, 0x29, 0x45, 0x28, 0xE7, 0x89,
+	0xB9, 0x29, 0x45, 0x28, 0xE7, 0x9B, 0xA3, 0x29,
+	0x45, 0x28, 0xE7, 0xA4, 0xBE, 0x29, 0x45, 0x28,
+	0xE7, 0xA5, 0x9D, 0x29, 0x45, 0x28, 0xE7, 0xA5,
+	0xAD, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xAA, 0x29,
+	0x45, 0x28, 0xE8, 0x87, 0xB3, 0x29, 0x45, 0x28,
+	0xE8, 0xB2, 0xA1, 0x29, 0x45, 0x28, 0xE8, 0xB3,
+	0x87, 0x29, 0x45, 0x28, 0xE9, 0x87, 0x91, 0x29,
+	// Bytes 2180 - 21bf
+	0x45, 0x30, 0xE2, 0x81, 0x84, 0x33, 0x45, 0x31,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x30, 0xE6,
+	0x9C, 0x88, 0x45, 0x31, 0x30, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x31, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x31, 0xE7,
+	0x82, 0xB9, 0x45, 0x31, 0x32, 0xE6, 0x97, 0xA5,
+	0x45, 0x31, 0x32, 0xE6, 0x9C, 0x88, 0x45, 0x31,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x33, 0xE6,
+	// Bytes 21c0 - 21ff
+	0x97, 0xA5, 0x45, 0x31, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x35, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x35, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x36, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x36, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x37, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x37, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x38, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	// Bytes 2200 - 223f
+	0x38, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x39, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x32, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x33, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x34, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x35,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x36, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x37, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x38, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x39,
+	// Bytes 2240 - 227f
+	0x45, 0x32, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x30, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x31, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x32, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x33, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x35, 0xE6,
+	// Bytes 2280 - 22bf
+	0x97, 0xA5, 0x45, 0x32, 0x36, 0xE6, 0x97, 0xA5,
+	0x45, 0x32, 0x37, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x38, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0xE2, 0x81, 0x84, 0x33,
+	0x45, 0x32, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x33, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x33, 0xE2, 0x81, 0x84, 0x34,
+	0x45, 0x33, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	// Bytes 22c0 - 22ff
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x34, 0xE2, 0x81,
+	0x84, 0x35, 0x45, 0x35, 0xE2, 0x81, 0x84, 0x36,
+	0x45, 0x35, 0xE2, 0x81, 0x84, 0x38, 0x45, 0x37,
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x41, 0xE2, 0x88,
+	0x95, 0x6D, 0x45, 0x56, 0xE2, 0x88, 0x95, 0x6D,
+	0x45, 0x6D, 0xE2, 0x88, 0x95, 0x73, 0x46, 0x31,
+	0xE2, 0x81, 0x84, 0x31, 0x30, 0x46, 0x43, 0xE2,
+	0x88, 0x95, 0x6B, 0x67, 0x46, 0x6D, 0xE2, 0x88,
+	// Bytes 2300 - 233f
+	0x95, 0x73, 0x32, 0x46, 0xD8, 0xA8, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xA8, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x85,
+	0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x89, 0x46,
+	0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0x46, 0xD8, 0xAA,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8, 0xAE,
+	// Bytes 2340 - 237f
+	0xD9, 0x89, 0x46, 0xD8, 0xAA, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAC,
+	0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAD, 0x46,
+	0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAE, 0x46, 0xD8,
+	0xAA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAA,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD8, 0xAC, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+	// Bytes 2380 - 23bf
+	0xAD, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x89,
+	0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAD,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB3, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD8, 0xB3, 0xD8, 0xAC,
+	0xD9, 0x89, 0x46, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8,
+	0xAC, 0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x89,
+	// Bytes 23c0 - 23ff
+	0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x8A, 0x46,
+	0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAC, 0x46, 0xD8,
+	0xB3, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8, 0xB3,
+	0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8,
+	0xAC, 0xD9, 0x8A, 0x46, 0xD8, 0xB4, 0xD8, 0xAD,
+	0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8, 0xAD, 0xD9,
+	0x8A, 0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xAE,
+	0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	// Bytes 2400 - 243f
+	0xD8, 0xB5, 0xD8, 0xAD, 0xD8, 0xAD, 0x46, 0xD8,
+	0xB5, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xB5,
+	0xD9, 0x84, 0xD9, 0x89, 0x46, 0xD8, 0xB5, 0xD9,
+	0x84, 0xDB, 0x92, 0x46, 0xD8, 0xB5, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9,
+	0x89, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x8A,
+	0x46, 0xD8, 0xB6, 0xD8, 0xAE, 0xD9, 0x85, 0x46,
+	0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8,
+	// Bytes 2440 - 247f
+	0xB7, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB7,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB9, 0xD8,
+	0xAC, 0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9, 0x8A,
+	0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8,
+	0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x81,
+	// Bytes 2480 - 24bf
+	0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x81, 0xD9,
+	0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x82, 0xD9, 0x84,
+	0xDB, 0x92, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD8,
+	0xAD, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x85,
+	0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x83, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x84,
+	0xD8, 0xAC, 0xD8, 0xAC, 0x46, 0xD9, 0x84, 0xD8,
+	// Bytes 24c0 - 24ff
+	0xAC, 0xD9, 0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAC,
+	0xD9, 0x8A, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+	0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x89,
+	0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x8A, 0x46,
+	0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9,
+	0x84, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD9, 0x84,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD9, 0x85, 0xD8, 0xAC,
+	// Bytes 2500 - 253f
+	0xD8, 0xAE, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+	0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x8A,
+	0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0x46,
+	0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9,
+	0x85, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x85,
+	0xD8, 0xAE, 0xD8, 0xAC, 0x46, 0xD9, 0x85, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAE,
+	0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+	// Bytes 2540 - 257f
+	0x8A, 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD8, 0xAD,
+	0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85, 0x46,
+	0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x89, 0x46, 0xD9,
+	0x86, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x86,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9, 0x86, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD9, 0x86, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x8A,
+	// Bytes 2580 - 25bf
+	0x46, 0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC, 0x46,
+	0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x8A, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x8A,
+	0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9,
+	0x85, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x85,
+	0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+	0xA7, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAC,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAD, 0x46,
+	// Bytes 25c0 - 25ff
+	0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE, 0x46, 0xD9,
+	0x8A, 0xD9, 0x94, 0xD8, 0xB1, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xD8, 0xB2, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xD9, 0x86, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+	0x87, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x88,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89, 0x46,
+	0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A, 0x46, 0xD9,
+	// Bytes 2600 - 263f
+	0x8A, 0xD9, 0x94, 0xDB, 0x86, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xDB, 0x87, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xDB, 0x88, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xDB, 0x90, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+	0x95, 0x46, 0xE0, 0xB9, 0x8D, 0xE0, 0xB8, 0xB2,
+	0x46, 0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0x99, 0x46,
+	0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0xA1, 0x46, 0xE0,
+	0xBB, 0x8D, 0xE0, 0xBA, 0xB2, 0x46, 0xE0, 0xBD,
+	// Bytes 2640 - 267f
+	0x80, 0xE0, 0xBE, 0xB5, 0x46, 0xE0, 0xBD, 0x82,
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x8C, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x91, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE0, 0xBD, 0x96, 0xE0, 0xBE, 0xB7,
+	0x46, 0xE0, 0xBD, 0x9B, 0xE0, 0xBE, 0xB7, 0x46,
+	0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5, 0x46, 0xE0,
+	0xBE, 0x92, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE,
+	0x9C, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA1,
+	// Bytes 2680 - 26bf
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA6, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xAB, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x46, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0x46,
+	0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0x46, 0xE2,
+	0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x46, 0xE3, 0x81,
+	0xBB, 0xE3, 0x81, 0x8B, 0x46, 0xE3, 0x82, 0x88,
+	0xE3, 0x82, 0x8A, 0x46, 0xE3, 0x82, 0xAD, 0xE3,
+	// Bytes 26c0 - 26ff
+	0x83, 0xAD, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x82,
+	0xB3, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x83, 0x88,
+	0x46, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3, 0x46,
+	0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8E, 0x46, 0xE3,
+	0x83, 0x9B, 0xE3, 0x83, 0xB3, 0x46, 0xE3, 0x83,
+	0x9F, 0xE3, 0x83, 0xAA, 0x46, 0xE3, 0x83, 0xAA,
+	0xE3, 0x83, 0xA9, 0x46, 0xE3, 0x83, 0xAC, 0xE3,
+	0x83, 0xA0, 0x46, 0xE5, 0xA4, 0xA7, 0xE6, 0xAD,
+	// Bytes 2700 - 273f
+	0xA3, 0x46, 0xE5, 0xB9, 0xB3, 0xE6, 0x88, 0x90,
+	0x46, 0xE6, 0x98, 0x8E, 0xE6, 0xB2, 0xBB, 0x46,
+	0xE6, 0x98, 0xAD, 0xE5, 0x92, 0x8C, 0x47, 0x72,
+	0x61, 0x64, 0xE2, 0x88, 0x95, 0x73, 0x47, 0xE3,
+	0x80, 0x94, 0x53, 0xE3, 0x80, 0x95, 0x48, 0x28,
+	0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x29,
+	0x48, 0x28, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1,
+	// Bytes 2740 - 277f
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x85, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x86, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x87,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x89, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28,
+	0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xAE, 0x29,
+	// Bytes 2780 - 27bf
+	0x48, 0x28, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1,
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x8F, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x90, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x91,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x92, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x72, 0x61,
+	0x64, 0xE2, 0x88, 0x95, 0x73, 0x32, 0x48, 0xD8,
+	0xA7, 0xD9, 0x83, 0xD8, 0xA8, 0xD8, 0xB1, 0x48,
+	// Bytes 27c0 - 27ff
+	0xD8, 0xA7, 0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x87,
+	0x48, 0xD8, 0xB1, 0xD8, 0xB3, 0xD9, 0x88, 0xD9,
+	0x84, 0x48, 0xD8, 0xB1, 0xDB, 0x8C, 0xD8, 0xA7,
+	0xD9, 0x84, 0x48, 0xD8, 0xB5, 0xD9, 0x84, 0xD8,
+	0xB9, 0xD9, 0x85, 0x48, 0xD8, 0xB9, 0xD9, 0x84,
+	0xD9, 0x8A, 0xD9, 0x87, 0x48, 0xD9, 0x85, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD8, 0xAF, 0x48, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x49, 0xE2,
+	// Bytes 2800 - 283f
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x49, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2,
+	0x80, 0xB5, 0x49, 0xE2, 0x88, 0xAB, 0xE2, 0x88,
+	0xAB, 0xE2, 0x88, 0xAB, 0x49, 0xE2, 0x88, 0xAE,
+	0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x49, 0xE3,
+	0x80, 0x94, 0xE4, 0xB8, 0x89, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE4, 0xBA, 0x8C, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE5, 0x8B,
+	// Bytes 2840 - 287f
+	0x9D, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE5, 0xAE, 0x89, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE6, 0x89, 0x93, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE6, 0x95, 0x97, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE6, 0x9C,
+	0xAC, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE7, 0x82, 0xB9, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE7, 0x9B, 0x97, 0xE3, 0x80, 0x95,
+	// Bytes 2880 - 28bf
+	0x49, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x81, 0x49, 0xE3, 0x82, 0xA6,
+	0xE3, 0x82, 0xA9, 0xE3, 0x83, 0xB3, 0x49, 0xE3,
+	0x82, 0xAA, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB9,
+	0x49, 0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xA0, 0x49, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAA, 0x49, 0xE3, 0x82, 0xB1,
+	// Bytes 28c0 - 28ff
+	0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB9, 0x49, 0xE3,
+	0x82, 0xB3, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x8A,
+	0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3,
+	0x83, 0x81, 0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x49, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0xE3, 0x82, 0xB7, 0x49, 0xE3,
+	0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x8E, 0xE3, 0x83, 0x83, 0xE3,
+	// Bytes 2900 - 293f
+	0x83, 0x88, 0x49, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0x84, 0x49, 0xE3, 0x83, 0x92,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB, 0x49, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xB3,
+	0x49, 0xE3, 0x83, 0x95, 0xE3, 0x83, 0xA9, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xBD, 0x49, 0xE3, 0x83, 0x98,
+	0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x84, 0x49, 0xE3,
+	// Bytes 2940 - 297f
+	0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x9E, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83, 0x9E,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x8F, 0x49, 0xE3,
+	0x83, 0x9E, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xAF,
+	0x49, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x83, 0xA6, 0xE3, 0x82,
+	// Bytes 2980 - 29bf
+	0xA2, 0xE3, 0x83, 0xB3, 0x49, 0xE3, 0x83, 0xAF,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0x4C, 0xE2,
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0xE2, 0x80, 0xB2, 0x4C, 0xE2, 0x88, 0xAB, 0xE2,
+	0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+	0x4C, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA1, 0x4C, 0xE3, 0x82,
+	0xA8, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3,
+	// Bytes 29c0 - 29ff
+	0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0x4C,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x9E, 0x4C, 0xE3, 0x82, 0xAB,
+	0xE3, 0x83, 0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+	0x88, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x83, 0xAD,
+	0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0x4C, 0xE3,
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x8B,
+	// Bytes 2a00 - 2a3f
+	0xE3, 0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAD, 0xE3,
+	0x83, 0xA5, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3,
+	0x83, 0xA9, 0xE3, 0x83, 0xA0, 0x4C, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0x8D, 0x4C, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+	0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2a40 - 2a7f
+	0xBC, 0xE3, 0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0x84, 0x4C, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA3, 0xE3, 0x83, 0xBC,
+	0xE3, 0x83, 0x88, 0x4C, 0xE3, 0x83, 0x98, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBF,
+	0x4C, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+	// Bytes 2a80 - 2abf
+	0x83, 0x8B, 0xE3, 0x83, 0x92, 0x4C, 0xE3, 0x83,
+	0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3, 0xE3,
+	0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x88, 0x4C,
+	0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0x4C, 0xE3, 0x83, 0x9F,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83,
+	0xB3, 0x4C, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xBC,
+	// Bytes 2ac0 - 2aff
+	0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0xAA, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88,
+	0xE3, 0x83, 0xAB, 0x4C, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC, 0x8F, 0xE4,
+	0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x4E, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x92,
+	0xE1, 0x85, 0xAE, 0x29, 0x4F, 0xD8, 0xAC, 0xD9,
+	// Bytes 2b00 - 2b3f
+	0x84, 0x20, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7,
+	0xD9, 0x84, 0xD9, 0x87, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xA2, 0x4F, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xB5,
+	// Bytes 2b40 - 2b7f
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xA0, 0x4F, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x98,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x9B,
+	0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x83, 0x9E,
+	// Bytes 2b80 - 2bbf
+	0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB7, 0xE3, 0x83,
+	0xA7, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xA1,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0x88, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xAB,
+	0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0x51, 0x28, 0xE1, 0x84,
+	0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xA5, 0xE1, 0x86, 0xAB, 0x29, 0x52, 0xE3,
+	// Bytes 2bc0 - 2bff
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xBC, 0x52, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xA9, 0xE3, 0x83, 0xA0, 0x52, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xA1, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x52,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2c00 - 2c3f
+	0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x83, 0x88, 0xE3,
+	0x83, 0xB3, 0x52, 0xE3, 0x82, 0xAF, 0xE3, 0x83,
+	0xAB, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0xE3,
+	0x82, 0xA4, 0xE3, 0x83, 0xAD, 0x52, 0xE3, 0x83,
+	0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3,
+	0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+	0x52, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+	0x82, 0xA2, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x88,
+	// Bytes 2c40 - 2c7f
+	0xE3, 0x83, 0xAB, 0x52, 0xE3, 0x83, 0x95, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0x83, 0xE3, 0x82, 0xB7,
+	0xE3, 0x82, 0xA7, 0xE3, 0x83, 0xAB, 0x52, 0xE3,
+	0x83, 0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAB, 0x52, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xB3,
+	0xE3, 0x83, 0x88, 0xE3, 0x82, 0xB1, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xB3, 0x61, 0xD8, 0xB5, 0xD9,
+	// Bytes 2c80 - 2cbf
+	0x84, 0xD9, 0x89, 0x20, 0xD8, 0xA7, 0xD9, 0x84,
+	0xD9, 0x84, 0xD9, 0x87, 0x20, 0xD8, 0xB9, 0xD9,
+	0x84, 0xD9, 0x8A, 0xD9, 0x87, 0x20, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA6, 0xBE, 0x01, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA7, 0x97, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAC, 0xBE, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAD, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2cc0 - 2cff
+	0xAD, 0x87, 0xE0, 0xAD, 0x97, 0x01, 0x06, 0xE0,
+	0xAE, 0x92, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x87, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xB2, 0xBF, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2d00 - 2d3f
+	0xB5, 0x86, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB5, 0x86, 0xE0, 0xB5, 0x97, 0x01, 0x06, 0xE0,
+	0xB5, 0x87, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB7, 0x99, 0xE0, 0xB7, 0x9F, 0x01, 0x06, 0xE1,
+	0x80, 0xA5, 0xE1, 0x80, 0xAE, 0x01, 0x06, 0xE1,
+	0xAC, 0x85, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x87, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x89, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	// Bytes 2d40 - 2d7f
+	0xAC, 0x8B, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x8D, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x91, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBA, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBC, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBE, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBF, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAD, 0x82, 0xE1, 0xAC, 0xB5, 0x01, 0x08, 0xF0,
+	// Bytes 2d80 - 2dbf
+	0x91, 0x84, 0xB1, 0xF0, 0x91, 0x84, 0xA7, 0x01,
+	0x08, 0xF0, 0x91, 0x84, 0xB2, 0xF0, 0x91, 0x84,
+	0xA7, 0x01, 0x08, 0xF0, 0x91, 0x8D, 0x87, 0xF0,
+	0x91, 0x8C, 0xBE, 0x01, 0x08, 0xF0, 0x91, 0x8D,
+	0x87, 0xF0, 0x91, 0x8D, 0x97, 0x01, 0x08, 0xF0,
+	0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92, 0xB0, 0x01,
+	0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92,
+	0xBA, 0x01, 0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0,
+	// Bytes 2dc0 - 2dff
+	0x91, 0x92, 0xBD, 0x01, 0x08, 0xF0, 0x91, 0x96,
+	0xB8, 0xF0, 0x91, 0x96, 0xAF, 0x01, 0x08, 0xF0,
+	0x91, 0x96, 0xB9, 0xF0, 0x91, 0x96, 0xAF, 0x01,
+	0x09, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0xE0,
+	0xB3, 0x95, 0x02, 0x09, 0xE0, 0xB7, 0x99, 0xE0,
+	0xB7, 0x8F, 0xE0, 0xB7, 0x8A, 0x12, 0x44, 0x44,
+	0x5A, 0xCC, 0x8C, 0xC9, 0x44, 0x44, 0x7A, 0xCC,
+	0x8C, 0xC9, 0x44, 0x64, 0x7A, 0xCC, 0x8C, 0xC9,
+	// Bytes 2e00 - 2e3f
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x93, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x46, 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x85, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e40 - 2e7f
+	0x46, 0xE1, 0x84, 0x87, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x89, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xAE, 0x01,
+	0x46, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8F, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x90, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e80 - 2ebf
+	0x46, 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0x01,
+	0x49, 0xE3, 0x83, 0xA1, 0xE3, 0x82, 0xAB, 0xE3,
+	0x82, 0x99, 0x0D, 0x4C, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xAE, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xB4,
+	0x01, 0x4C, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D, 0x4C,
+	0xE3, 0x82, 0xB3, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	// Bytes 2ec0 - 2eff
+	0x9B, 0xE3, 0x82, 0x9A, 0x0D, 0x4C, 0xE3, 0x83,
+	0xA4, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+	0x82, 0x99, 0x0D, 0x4F, 0xE1, 0x84, 0x8E, 0xE1,
+	0x85, 0xA1, 0xE1, 0x86, 0xB7, 0xE1, 0x84, 0x80,
+	0xE1, 0x85, 0xA9, 0x01, 0x4F, 0xE3, 0x82, 0xA4,
+	0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+	0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3, 0x82,
+	0xB7, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xB3, 0xE3,
+	// Bytes 2f00 - 2f3f
+	0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3,
+	0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D, 0x4F,
+	0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x52, 0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xB9, 0xE3,
+	0x82, 0xAF, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88,
+	0xE3, 0x82, 0x99, 0x0D, 0x52, 0xE3, 0x83, 0x95,
+	// Bytes 2f40 - 2f7f
+	0xE3, 0x82, 0xA1, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x86, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0x01,
+	0x86, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8F, 0x01,
+	0x03, 0x3C, 0xCC, 0xB8, 0x05, 0x03, 0x3D, 0xCC,
+	0xB8, 0x05, 0x03, 0x3E, 0xCC, 0xB8, 0x05, 0x03,
+	0x41, 0xCC, 0x80, 0xC9, 0x03, 0x41, 0xCC, 0x81,
+	0xC9, 0x03, 0x41, 0xCC, 0x83, 0xC9, 0x03, 0x41,
+	// Bytes 2f80 - 2fbf
+	0xCC, 0x84, 0xC9, 0x03, 0x41, 0xCC, 0x89, 0xC9,
+	0x03, 0x41, 0xCC, 0x8C, 0xC9, 0x03, 0x41, 0xCC,
+	0x8F, 0xC9, 0x03, 0x41, 0xCC, 0x91, 0xC9, 0x03,
+	0x41, 0xCC, 0xA5, 0xB5, 0x03, 0x41, 0xCC, 0xA8,
+	0xA5, 0x03, 0x42, 0xCC, 0x87, 0xC9, 0x03, 0x42,
+	0xCC, 0xA3, 0xB5, 0x03, 0x42, 0xCC, 0xB1, 0xB5,
+	0x03, 0x43, 0xCC, 0x81, 0xC9, 0x03, 0x43, 0xCC,
+	0x82, 0xC9, 0x03, 0x43, 0xCC, 0x87, 0xC9, 0x03,
+	// Bytes 2fc0 - 2fff
+	0x43, 0xCC, 0x8C, 0xC9, 0x03, 0x44, 0xCC, 0x87,
+	0xC9, 0x03, 0x44, 0xCC, 0x8C, 0xC9, 0x03, 0x44,
+	0xCC, 0xA3, 0xB5, 0x03, 0x44, 0xCC, 0xA7, 0xA5,
+	0x03, 0x44, 0xCC, 0xAD, 0xB5, 0x03, 0x44, 0xCC,
+	0xB1, 0xB5, 0x03, 0x45, 0xCC, 0x80, 0xC9, 0x03,
+	0x45, 0xCC, 0x81, 0xC9, 0x03, 0x45, 0xCC, 0x83,
+	0xC9, 0x03, 0x45, 0xCC, 0x86, 0xC9, 0x03, 0x45,
+	0xCC, 0x87, 0xC9, 0x03, 0x45, 0xCC, 0x88, 0xC9,
+	// Bytes 3000 - 303f
+	0x03, 0x45, 0xCC, 0x89, 0xC9, 0x03, 0x45, 0xCC,
+	0x8C, 0xC9, 0x03, 0x45, 0xCC, 0x8F, 0xC9, 0x03,
+	0x45, 0xCC, 0x91, 0xC9, 0x03, 0x45, 0xCC, 0xA8,
+	0xA5, 0x03, 0x45, 0xCC, 0xAD, 0xB5, 0x03, 0x45,
+	0xCC, 0xB0, 0xB5, 0x03, 0x46, 0xCC, 0x87, 0xC9,
+	0x03, 0x47, 0xCC, 0x81, 0xC9, 0x03, 0x47, 0xCC,
+	0x82, 0xC9, 0x03, 0x47, 0xCC, 0x84, 0xC9, 0x03,
+	0x47, 0xCC, 0x86, 0xC9, 0x03, 0x47, 0xCC, 0x87,
+	// Bytes 3040 - 307f
+	0xC9, 0x03, 0x47, 0xCC, 0x8C, 0xC9, 0x03, 0x47,
+	0xCC, 0xA7, 0xA5, 0x03, 0x48, 0xCC, 0x82, 0xC9,
+	0x03, 0x48, 0xCC, 0x87, 0xC9, 0x03, 0x48, 0xCC,
+	0x88, 0xC9, 0x03, 0x48, 0xCC, 0x8C, 0xC9, 0x03,
+	0x48, 0xCC, 0xA3, 0xB5, 0x03, 0x48, 0xCC, 0xA7,
+	0xA5, 0x03, 0x48, 0xCC, 0xAE, 0xB5, 0x03, 0x49,
+	0xCC, 0x80, 0xC9, 0x03, 0x49, 0xCC, 0x81, 0xC9,
+	0x03, 0x49, 0xCC, 0x82, 0xC9, 0x03, 0x49, 0xCC,
+	// Bytes 3080 - 30bf
+	0x83, 0xC9, 0x03, 0x49, 0xCC, 0x84, 0xC9, 0x03,
+	0x49, 0xCC, 0x86, 0xC9, 0x03, 0x49, 0xCC, 0x87,
+	0xC9, 0x03, 0x49, 0xCC, 0x89, 0xC9, 0x03, 0x49,
+	0xCC, 0x8C, 0xC9, 0x03, 0x49, 0xCC, 0x8F, 0xC9,
+	0x03, 0x49, 0xCC, 0x91, 0xC9, 0x03, 0x49, 0xCC,
+	0xA3, 0xB5, 0x03, 0x49, 0xCC, 0xA8, 0xA5, 0x03,
+	0x49, 0xCC, 0xB0, 0xB5, 0x03, 0x4A, 0xCC, 0x82,
+	0xC9, 0x03, 0x4B, 0xCC, 0x81, 0xC9, 0x03, 0x4B,
+	// Bytes 30c0 - 30ff
+	0xCC, 0x8C, 0xC9, 0x03, 0x4B, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4B, 0xCC, 0xA7, 0xA5, 0x03, 0x4B, 0xCC,
+	0xB1, 0xB5, 0x03, 0x4C, 0xCC, 0x81, 0xC9, 0x03,
+	0x4C, 0xCC, 0x8C, 0xC9, 0x03, 0x4C, 0xCC, 0xA7,
+	0xA5, 0x03, 0x4C, 0xCC, 0xAD, 0xB5, 0x03, 0x4C,
+	0xCC, 0xB1, 0xB5, 0x03, 0x4D, 0xCC, 0x81, 0xC9,
+	0x03, 0x4D, 0xCC, 0x87, 0xC9, 0x03, 0x4D, 0xCC,
+	0xA3, 0xB5, 0x03, 0x4E, 0xCC, 0x80, 0xC9, 0x03,
+	// Bytes 3100 - 313f
+	0x4E, 0xCC, 0x81, 0xC9, 0x03, 0x4E, 0xCC, 0x83,
+	0xC9, 0x03, 0x4E, 0xCC, 0x87, 0xC9, 0x03, 0x4E,
+	0xCC, 0x8C, 0xC9, 0x03, 0x4E, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4E, 0xCC, 0xA7, 0xA5, 0x03, 0x4E, 0xCC,
+	0xAD, 0xB5, 0x03, 0x4E, 0xCC, 0xB1, 0xB5, 0x03,
+	0x4F, 0xCC, 0x80, 0xC9, 0x03, 0x4F, 0xCC, 0x81,
+	0xC9, 0x03, 0x4F, 0xCC, 0x86, 0xC9, 0x03, 0x4F,
+	0xCC, 0x89, 0xC9, 0x03, 0x4F, 0xCC, 0x8B, 0xC9,
+	// Bytes 3140 - 317f
+	0x03, 0x4F, 0xCC, 0x8C, 0xC9, 0x03, 0x4F, 0xCC,
+	0x8F, 0xC9, 0x03, 0x4F, 0xCC, 0x91, 0xC9, 0x03,
+	0x50, 0xCC, 0x81, 0xC9, 0x03, 0x50, 0xCC, 0x87,
+	0xC9, 0x03, 0x52, 0xCC, 0x81, 0xC9, 0x03, 0x52,
+	0xCC, 0x87, 0xC9, 0x03, 0x52, 0xCC, 0x8C, 0xC9,
+	0x03, 0x52, 0xCC, 0x8F, 0xC9, 0x03, 0x52, 0xCC,
+	0x91, 0xC9, 0x03, 0x52, 0xCC, 0xA7, 0xA5, 0x03,
+	0x52, 0xCC, 0xB1, 0xB5, 0x03, 0x53, 0xCC, 0x82,
+	// Bytes 3180 - 31bf
+	0xC9, 0x03, 0x53, 0xCC, 0x87, 0xC9, 0x03, 0x53,
+	0xCC, 0xA6, 0xB5, 0x03, 0x53, 0xCC, 0xA7, 0xA5,
+	0x03, 0x54, 0xCC, 0x87, 0xC9, 0x03, 0x54, 0xCC,
+	0x8C, 0xC9, 0x03, 0x54, 0xCC, 0xA3, 0xB5, 0x03,
+	0x54, 0xCC, 0xA6, 0xB5, 0x03, 0x54, 0xCC, 0xA7,
+	0xA5, 0x03, 0x54, 0xCC, 0xAD, 0xB5, 0x03, 0x54,
+	0xCC, 0xB1, 0xB5, 0x03, 0x55, 0xCC, 0x80, 0xC9,
+	0x03, 0x55, 0xCC, 0x81, 0xC9, 0x03, 0x55, 0xCC,
+	// Bytes 31c0 - 31ff
+	0x82, 0xC9, 0x03, 0x55, 0xCC, 0x86, 0xC9, 0x03,
+	0x55, 0xCC, 0x89, 0xC9, 0x03, 0x55, 0xCC, 0x8A,
+	0xC9, 0x03, 0x55, 0xCC, 0x8B, 0xC9, 0x03, 0x55,
+	0xCC, 0x8C, 0xC9, 0x03, 0x55, 0xCC, 0x8F, 0xC9,
+	0x03, 0x55, 0xCC, 0x91, 0xC9, 0x03, 0x55, 0xCC,
+	0xA3, 0xB5, 0x03, 0x55, 0xCC, 0xA4, 0xB5, 0x03,
+	0x55, 0xCC, 0xA8, 0xA5, 0x03, 0x55, 0xCC, 0xAD,
+	0xB5, 0x03, 0x55, 0xCC, 0xB0, 0xB5, 0x03, 0x56,
+	// Bytes 3200 - 323f
+	0xCC, 0x83, 0xC9, 0x03, 0x56, 0xCC, 0xA3, 0xB5,
+	0x03, 0x57, 0xCC, 0x80, 0xC9, 0x03, 0x57, 0xCC,
+	0x81, 0xC9, 0x03, 0x57, 0xCC, 0x82, 0xC9, 0x03,
+	0x57, 0xCC, 0x87, 0xC9, 0x03, 0x57, 0xCC, 0x88,
+	0xC9, 0x03, 0x57, 0xCC, 0xA3, 0xB5, 0x03, 0x58,
+	0xCC, 0x87, 0xC9, 0x03, 0x58, 0xCC, 0x88, 0xC9,
+	0x03, 0x59, 0xCC, 0x80, 0xC9, 0x03, 0x59, 0xCC,
+	0x81, 0xC9, 0x03, 0x59, 0xCC, 0x82, 0xC9, 0x03,
+	// Bytes 3240 - 327f
+	0x59, 0xCC, 0x83, 0xC9, 0x03, 0x59, 0xCC, 0x84,
+	0xC9, 0x03, 0x59, 0xCC, 0x87, 0xC9, 0x03, 0x59,
+	0xCC, 0x88, 0xC9, 0x03, 0x59, 0xCC, 0x89, 0xC9,
+	0x03, 0x59, 0xCC, 0xA3, 0xB5, 0x03, 0x5A, 0xCC,
+	0x81, 0xC9, 0x03, 0x5A, 0xCC, 0x82, 0xC9, 0x03,
+	0x5A, 0xCC, 0x87, 0xC9, 0x03, 0x5A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x5A, 0xCC, 0xA3, 0xB5, 0x03, 0x5A,
+	0xCC, 0xB1, 0xB5, 0x03, 0x61, 0xCC, 0x80, 0xC9,
+	// Bytes 3280 - 32bf
+	0x03, 0x61, 0xCC, 0x81, 0xC9, 0x03, 0x61, 0xCC,
+	0x83, 0xC9, 0x03, 0x61, 0xCC, 0x84, 0xC9, 0x03,
+	0x61, 0xCC, 0x89, 0xC9, 0x03, 0x61, 0xCC, 0x8C,
+	0xC9, 0x03, 0x61, 0xCC, 0x8F, 0xC9, 0x03, 0x61,
+	0xCC, 0x91, 0xC9, 0x03, 0x61, 0xCC, 0xA5, 0xB5,
+	0x03, 0x61, 0xCC, 0xA8, 0xA5, 0x03, 0x62, 0xCC,
+	0x87, 0xC9, 0x03, 0x62, 0xCC, 0xA3, 0xB5, 0x03,
+	0x62, 0xCC, 0xB1, 0xB5, 0x03, 0x63, 0xCC, 0x81,
+	// Bytes 32c0 - 32ff
+	0xC9, 0x03, 0x63, 0xCC, 0x82, 0xC9, 0x03, 0x63,
+	0xCC, 0x87, 0xC9, 0x03, 0x63, 0xCC, 0x8C, 0xC9,
+	0x03, 0x64, 0xCC, 0x87, 0xC9, 0x03, 0x64, 0xCC,
+	0x8C, 0xC9, 0x03, 0x64, 0xCC, 0xA3, 0xB5, 0x03,
+	0x64, 0xCC, 0xA7, 0xA5, 0x03, 0x64, 0xCC, 0xAD,
+	0xB5, 0x03, 0x64, 0xCC, 0xB1, 0xB5, 0x03, 0x65,
+	0xCC, 0x80, 0xC9, 0x03, 0x65, 0xCC, 0x81, 0xC9,
+	0x03, 0x65, 0xCC, 0x83, 0xC9, 0x03, 0x65, 0xCC,
+	// Bytes 3300 - 333f
+	0x86, 0xC9, 0x03, 0x65, 0xCC, 0x87, 0xC9, 0x03,
+	0x65, 0xCC, 0x88, 0xC9, 0x03, 0x65, 0xCC, 0x89,
+	0xC9, 0x03, 0x65, 0xCC, 0x8C, 0xC9, 0x03, 0x65,
+	0xCC, 0x8F, 0xC9, 0x03, 0x65, 0xCC, 0x91, 0xC9,
+	0x03, 0x65, 0xCC, 0xA8, 0xA5, 0x03, 0x65, 0xCC,
+	0xAD, 0xB5, 0x03, 0x65, 0xCC, 0xB0, 0xB5, 0x03,
+	0x66, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC, 0x81,
+	0xC9, 0x03, 0x67, 0xCC, 0x82, 0xC9, 0x03, 0x67,
+	// Bytes 3340 - 337f
+	0xCC, 0x84, 0xC9, 0x03, 0x67, 0xCC, 0x86, 0xC9,
+	0x03, 0x67, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC,
+	0x8C, 0xC9, 0x03, 0x67, 0xCC, 0xA7, 0xA5, 0x03,
+	0x68, 0xCC, 0x82, 0xC9, 0x03, 0x68, 0xCC, 0x87,
+	0xC9, 0x03, 0x68, 0xCC, 0x88, 0xC9, 0x03, 0x68,
+	0xCC, 0x8C, 0xC9, 0x03, 0x68, 0xCC, 0xA3, 0xB5,
+	0x03, 0x68, 0xCC, 0xA7, 0xA5, 0x03, 0x68, 0xCC,
+	0xAE, 0xB5, 0x03, 0x68, 0xCC, 0xB1, 0xB5, 0x03,
+	// Bytes 3380 - 33bf
+	0x69, 0xCC, 0x80, 0xC9, 0x03, 0x69, 0xCC, 0x81,
+	0xC9, 0x03, 0x69, 0xCC, 0x82, 0xC9, 0x03, 0x69,
+	0xCC, 0x83, 0xC9, 0x03, 0x69, 0xCC, 0x84, 0xC9,
+	0x03, 0x69, 0xCC, 0x86, 0xC9, 0x03, 0x69, 0xCC,
+	0x89, 0xC9, 0x03, 0x69, 0xCC, 0x8C, 0xC9, 0x03,
+	0x69, 0xCC, 0x8F, 0xC9, 0x03, 0x69, 0xCC, 0x91,
+	0xC9, 0x03, 0x69, 0xCC, 0xA3, 0xB5, 0x03, 0x69,
+	0xCC, 0xA8, 0xA5, 0x03, 0x69, 0xCC, 0xB0, 0xB5,
+	// Bytes 33c0 - 33ff
+	0x03, 0x6A, 0xCC, 0x82, 0xC9, 0x03, 0x6A, 0xCC,
+	0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0x81, 0xC9, 0x03,
+	0x6B, 0xCC, 0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6B, 0xCC, 0xA7, 0xA5, 0x03, 0x6B,
+	0xCC, 0xB1, 0xB5, 0x03, 0x6C, 0xCC, 0x81, 0xC9,
+	0x03, 0x6C, 0xCC, 0x8C, 0xC9, 0x03, 0x6C, 0xCC,
+	0xA7, 0xA5, 0x03, 0x6C, 0xCC, 0xAD, 0xB5, 0x03,
+	0x6C, 0xCC, 0xB1, 0xB5, 0x03, 0x6D, 0xCC, 0x81,
+	// Bytes 3400 - 343f
+	0xC9, 0x03, 0x6D, 0xCC, 0x87, 0xC9, 0x03, 0x6D,
+	0xCC, 0xA3, 0xB5, 0x03, 0x6E, 0xCC, 0x80, 0xC9,
+	0x03, 0x6E, 0xCC, 0x81, 0xC9, 0x03, 0x6E, 0xCC,
+	0x83, 0xC9, 0x03, 0x6E, 0xCC, 0x87, 0xC9, 0x03,
+	0x6E, 0xCC, 0x8C, 0xC9, 0x03, 0x6E, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6E, 0xCC, 0xA7, 0xA5, 0x03, 0x6E,
+	0xCC, 0xAD, 0xB5, 0x03, 0x6E, 0xCC, 0xB1, 0xB5,
+	0x03, 0x6F, 0xCC, 0x80, 0xC9, 0x03, 0x6F, 0xCC,
+	// Bytes 3440 - 347f
+	0x81, 0xC9, 0x03, 0x6F, 0xCC, 0x86, 0xC9, 0x03,
+	0x6F, 0xCC, 0x89, 0xC9, 0x03, 0x6F, 0xCC, 0x8B,
+	0xC9, 0x03, 0x6F, 0xCC, 0x8C, 0xC9, 0x03, 0x6F,
+	0xCC, 0x8F, 0xC9, 0x03, 0x6F, 0xCC, 0x91, 0xC9,
+	0x03, 0x70, 0xCC, 0x81, 0xC9, 0x03, 0x70, 0xCC,
+	0x87, 0xC9, 0x03, 0x72, 0xCC, 0x81, 0xC9, 0x03,
+	0x72, 0xCC, 0x87, 0xC9, 0x03, 0x72, 0xCC, 0x8C,
+	0xC9, 0x03, 0x72, 0xCC, 0x8F, 0xC9, 0x03, 0x72,
+	// Bytes 3480 - 34bf
+	0xCC, 0x91, 0xC9, 0x03, 0x72, 0xCC, 0xA7, 0xA5,
+	0x03, 0x72, 0xCC, 0xB1, 0xB5, 0x03, 0x73, 0xCC,
+	0x82, 0xC9, 0x03, 0x73, 0xCC, 0x87, 0xC9, 0x03,
+	0x73, 0xCC, 0xA6, 0xB5, 0x03, 0x73, 0xCC, 0xA7,
+	0xA5, 0x03, 0x74, 0xCC, 0x87, 0xC9, 0x03, 0x74,
+	0xCC, 0x88, 0xC9, 0x03, 0x74, 0xCC, 0x8C, 0xC9,
+	0x03, 0x74, 0xCC, 0xA3, 0xB5, 0x03, 0x74, 0xCC,
+	0xA6, 0xB5, 0x03, 0x74, 0xCC, 0xA7, 0xA5, 0x03,
+	// Bytes 34c0 - 34ff
+	0x74, 0xCC, 0xAD, 0xB5, 0x03, 0x74, 0xCC, 0xB1,
+	0xB5, 0x03, 0x75, 0xCC, 0x80, 0xC9, 0x03, 0x75,
+	0xCC, 0x81, 0xC9, 0x03, 0x75, 0xCC, 0x82, 0xC9,
+	0x03, 0x75, 0xCC, 0x86, 0xC9, 0x03, 0x75, 0xCC,
+	0x89, 0xC9, 0x03, 0x75, 0xCC, 0x8A, 0xC9, 0x03,
+	0x75, 0xCC, 0x8B, 0xC9, 0x03, 0x75, 0xCC, 0x8C,
+	0xC9, 0x03, 0x75, 0xCC, 0x8F, 0xC9, 0x03, 0x75,
+	0xCC, 0x91, 0xC9, 0x03, 0x75, 0xCC, 0xA3, 0xB5,
+	// Bytes 3500 - 353f
+	0x03, 0x75, 0xCC, 0xA4, 0xB5, 0x03, 0x75, 0xCC,
+	0xA8, 0xA5, 0x03, 0x75, 0xCC, 0xAD, 0xB5, 0x03,
+	0x75, 0xCC, 0xB0, 0xB5, 0x03, 0x76, 0xCC, 0x83,
+	0xC9, 0x03, 0x76, 0xCC, 0xA3, 0xB5, 0x03, 0x77,
+	0xCC, 0x80, 0xC9, 0x03, 0x77, 0xCC, 0x81, 0xC9,
+	0x03, 0x77, 0xCC, 0x82, 0xC9, 0x03, 0x77, 0xCC,
+	0x87, 0xC9, 0x03, 0x77, 0xCC, 0x88, 0xC9, 0x03,
+	0x77, 0xCC, 0x8A, 0xC9, 0x03, 0x77, 0xCC, 0xA3,
+	// Bytes 3540 - 357f
+	0xB5, 0x03, 0x78, 0xCC, 0x87, 0xC9, 0x03, 0x78,
+	0xCC, 0x88, 0xC9, 0x03, 0x79, 0xCC, 0x80, 0xC9,
+	0x03, 0x79, 0xCC, 0x81, 0xC9, 0x03, 0x79, 0xCC,
+	0x82, 0xC9, 0x03, 0x79, 0xCC, 0x83, 0xC9, 0x03,
+	0x79, 0xCC, 0x84, 0xC9, 0x03, 0x79, 0xCC, 0x87,
+	0xC9, 0x03, 0x79, 0xCC, 0x88, 0xC9, 0x03, 0x79,
+	0xCC, 0x89, 0xC9, 0x03, 0x79, 0xCC, 0x8A, 0xC9,
+	0x03, 0x79, 0xCC, 0xA3, 0xB5, 0x03, 0x7A, 0xCC,
+	// Bytes 3580 - 35bf
+	0x81, 0xC9, 0x03, 0x7A, 0xCC, 0x82, 0xC9, 0x03,
+	0x7A, 0xCC, 0x87, 0xC9, 0x03, 0x7A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x7A, 0xCC, 0xA3, 0xB5, 0x03, 0x7A,
+	0xCC, 0xB1, 0xB5, 0x04, 0xC2, 0xA8, 0xCC, 0x80,
+	0xCA, 0x04, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x04,
+	0xC2, 0xA8, 0xCD, 0x82, 0xCA, 0x04, 0xC3, 0x86,
+	0xCC, 0x81, 0xC9, 0x04, 0xC3, 0x86, 0xCC, 0x84,
+	0xC9, 0x04, 0xC3, 0x98, 0xCC, 0x81, 0xC9, 0x04,
+	// Bytes 35c0 - 35ff
+	0xC3, 0xA6, 0xCC, 0x81, 0xC9, 0x04, 0xC3, 0xA6,
+	0xCC, 0x84, 0xC9, 0x04, 0xC3, 0xB8, 0xCC, 0x81,
+	0xC9, 0x04, 0xC5, 0xBF, 0xCC, 0x87, 0xC9, 0x04,
+	0xC6, 0xB7, 0xCC, 0x8C, 0xC9, 0x04, 0xCA, 0x92,
+	0xCC, 0x8C, 0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0x91, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0x91,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0x91, 0xCD, 0x85,
+	// Bytes 3600 - 363f
+	0xD9, 0x04, 0xCE, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0x95, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x97,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x97, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0x97, 0xCD, 0x85, 0xD9, 0x04,
+	0xCE, 0x99, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x99,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0x9F,
+	// Bytes 3640 - 367f
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x9F, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA1, 0xCC, 0x94, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA5,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0xA9,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA9, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA9, 0xCD, 0x85, 0xD9, 0x04,
+	// Bytes 3680 - 36bf
+	0xCE, 0xB1, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB1,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB1, 0xCD, 0x85,
+	0xD9, 0x04, 0xCE, 0xB5, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xB5, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xB7,
+	0xCD, 0x85, 0xD9, 0x04, 0xCE, 0xB9, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0xB9, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB9,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB9, 0xCD, 0x82,
+	// Bytes 36c0 - 36ff
+	0xC9, 0x04, 0xCE, 0xBF, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xBF, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x81,
+	0xCC, 0x93, 0xC9, 0x04, 0xCF, 0x81, 0xCC, 0x94,
+	0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x80, 0xC9, 0x04,
+	0xCF, 0x85, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x85,
+	0xCC, 0x84, 0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x86,
+	0xC9, 0x04, 0xCF, 0x85, 0xCD, 0x82, 0xC9, 0x04,
+	0xCF, 0x89, 0xCD, 0x85, 0xD9, 0x04, 0xCF, 0x92,
+	// Bytes 3700 - 373f
+	0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x92, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0x86, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0x90, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x90,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x93, 0xCC, 0x81,
+	0xC9, 0x04, 0xD0, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0x95, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x95,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3740 - 377f
+	0xD0, 0x97, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x98,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x84,
+	0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x86, 0xC9, 0x04,
+	0xD0, 0x98, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x9A,
+	0xCC, 0x81, 0xC9, 0x04, 0xD0, 0x9E, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x84, 0xC9, 0x04,
+	0xD0, 0xA3, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xA3,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x8B,
+	// Bytes 3780 - 37bf
+	0xC9, 0x04, 0xD0, 0xA7, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xAB, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xAD,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB3, 0xCC, 0x81, 0xC9, 0x04, 0xD0, 0xB5,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB6, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB6,
+	// Bytes 37c0 - 37ff
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB7, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0xB8, 0xCC, 0x84, 0xC9, 0x04, 0xD0, 0xB8,
+	0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xBA, 0xCC, 0x81, 0xC9, 0x04,
+	0xD0, 0xBE, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x83,
+	0xCC, 0x84, 0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x86,
+	0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3800 - 383f
+	0xD1, 0x83, 0xCC, 0x8B, 0xC9, 0x04, 0xD1, 0x87,
+	0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x8B, 0xCC, 0x88,
+	0xC9, 0x04, 0xD1, 0x8D, 0xCC, 0x88, 0xC9, 0x04,
+	0xD1, 0x96, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0xB4,
+	0xCC, 0x8F, 0xC9, 0x04, 0xD1, 0xB5, 0xCC, 0x8F,
+	0xC9, 0x04, 0xD3, 0x98, 0xCC, 0x88, 0xC9, 0x04,
+	0xD3, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA8,
+	0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA9, 0xCC, 0x88,
+	// Bytes 3840 - 387f
+	0xC9, 0x04, 0xD8, 0xA7, 0xD9, 0x93, 0xC9, 0x04,
+	0xD8, 0xA7, 0xD9, 0x94, 0xC9, 0x04, 0xD8, 0xA7,
+	0xD9, 0x95, 0xB5, 0x04, 0xD9, 0x88, 0xD9, 0x94,
+	0xC9, 0x04, 0xD9, 0x8A, 0xD9, 0x94, 0xC9, 0x04,
+	0xDB, 0x81, 0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x92,
+	0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x95, 0xD9, 0x94,
+	0xC9, 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x41, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	// Bytes 3880 - 38bf
+	0x41, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x41,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x41, 0xCC,
+	0x86, 0xCC, 0x80, 0xCA, 0x05, 0x41, 0xCC, 0x86,
+	0xCC, 0x81, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC,
+	0x83, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC, 0x89,
+	0xCA, 0x05, 0x41, 0xCC, 0x87, 0xCC, 0x84, 0xCA,
+	0x05, 0x41, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05,
+	0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x41,
+	// Bytes 38c0 - 38ff
+	0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x41, 0xCC,
+	0xA3, 0xCC, 0x86, 0xCA, 0x05, 0x43, 0xCC, 0xA7,
+	0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC,
+	0x80, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x81,
+	0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x83, 0xCA,
+	0x05, 0x45, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05,
+	0x45, 0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x45,
+	0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC,
+	// Bytes 3900 - 393f
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x45, 0xCC, 0xA7,
+	0xCC, 0x86, 0xCA, 0x05, 0x49, 0xCC, 0x88, 0xCC,
+	0x81, 0xCA, 0x05, 0x4C, 0xCC, 0xA3, 0xCC, 0x84,
+	0xCA, 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	0x4F, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x4F,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x4F, 0xCC,
+	0x83, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x83,
+	// Bytes 3940 - 397f
+	0xCC, 0x84, 0xCA, 0x05, 0x4F, 0xCC, 0x83, 0xCC,
+	0x88, 0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x80,
+	0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x81, 0xCA,
+	0x05, 0x4F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x4F,
+	0xCC, 0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x4F, 0xCC,
+	0x9B, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x9B,
+	0xCC, 0x83, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC,
+	// Bytes 3980 - 39bf
+	0x89, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC, 0xA3,
+	0xB6, 0x05, 0x4F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA,
+	0x05, 0x4F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05,
+	0x52, 0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x53,
+	0xCC, 0x81, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC,
+	0x8C, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC, 0xA3,
+	0xCC, 0x87, 0xCA, 0x05, 0x55, 0xCC, 0x83, 0xCC,
+	0x81, 0xCA, 0x05, 0x55, 0xCC, 0x84, 0xCC, 0x88,
+	// Bytes 39c0 - 39ff
+	0xCA, 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x05, 0x55, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05,
+	0x55, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x55,
+	0xCC, 0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x55, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x55, 0xCC, 0x9B,
+	0xCC, 0x81, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	// Bytes 3a00 - 3a3f
+	0x05, 0x61, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x61, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x61,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x61, 0xCC,
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x61, 0xCC, 0x86,
+	0xCC, 0x80, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC,
+	0x81, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x83,
+	0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x89, 0xCA,
+	0x05, 0x61, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	// Bytes 3a40 - 3a7f
+	0x61, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x61,
+	0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x61, 0xCC,
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x61, 0xCC, 0xA3,
+	0xCC, 0x86, 0xCA, 0x05, 0x63, 0xCC, 0xA7, 0xCC,
+	0x81, 0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x80,
+	0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x81, 0xCA,
+	0x05, 0x65, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05,
+	0x65, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x65,
+	// Bytes 3a80 - 3abf
+	0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x65, 0xCC,
+	0x84, 0xCC, 0x81, 0xCA, 0x05, 0x65, 0xCC, 0xA3,
+	0xCC, 0x82, 0xCA, 0x05, 0x65, 0xCC, 0xA7, 0xCC,
+	0x86, 0xCA, 0x05, 0x69, 0xCC, 0x88, 0xCC, 0x81,
+	0xCA, 0x05, 0x6C, 0xCC, 0xA3, 0xCC, 0x84, 0xCA,
+	0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x6F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x6F,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x6F, 0xCC,
+	// Bytes 3ac0 - 3aff
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x6F, 0xCC, 0x83,
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC,
+	0x84, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC, 0x88,
+	0xCA, 0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x80, 0xCA,
+	0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05,
+	0x6F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05, 0x6F,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x6F, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x6F, 0xCC, 0x9B,
+	// Bytes 3b00 - 3b3f
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	0x05, 0x6F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05,
+	0x6F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05, 0x72,
+	0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x73, 0xCC,
+	0x81, 0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0x8C,
+	0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0xA3, 0xCC,
+	// Bytes 3b40 - 3b7f
+	0x87, 0xCA, 0x05, 0x75, 0xCC, 0x83, 0xCC, 0x81,
+	0xCA, 0x05, 0x75, 0xCC, 0x84, 0xCC, 0x88, 0xCA,
+	0x05, 0x75, 0xCC, 0x88, 0xCC, 0x80, 0xCA, 0x05,
+	0x75, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05, 0x75,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x75, 0xCC,
+	0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x75, 0xCC, 0x9B,
+	0xCC, 0x80, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC,
+	0x81, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x83,
+	// Bytes 3b80 - 3bbf
+	0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x89, 0xCA,
+	0x05, 0x75, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6, 0x05,
+	0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0xCA, 0x05, 0xE1,
+	0xBE, 0xBF, 0xCC, 0x81, 0xCA, 0x05, 0xE1, 0xBE,
+	0xBF, 0xCD, 0x82, 0xCA, 0x05, 0xE1, 0xBF, 0xBE,
+	0xCC, 0x80, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCC,
+	0x81, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCD, 0x82,
+	0xCA, 0x05, 0xE2, 0x86, 0x90, 0xCC, 0xB8, 0x05,
+	// Bytes 3bc0 - 3bff
+	0x05, 0xE2, 0x86, 0x92, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x86, 0x94, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x87, 0x90, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87,
+	0x92, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87, 0x94,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x88, 0x83, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x88, 0x88, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x88, 0x8B, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x88, 0xA3, 0xCC, 0xB8, 0x05, 0x05,
+	// Bytes 3c00 - 3c3f
+	0xE2, 0x88, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x88, 0xBC, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x85,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x88, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0x8D, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xA1, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xA4, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	// Bytes 3c40 - 3c7f
+	0x89, 0xB2, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0xB3, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB6,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB7, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0xBA, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xBB, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xBC, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xBD, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0x82, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	// Bytes 3c80 - 3cbf
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x86,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x87, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x91, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0x92, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x8A, 0xA2, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x8A, 0xA8, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0xA9, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	0xAB, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB2,
+	// Bytes 3cc0 - 3cff
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB3, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB4, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0xB5, 0xCC, 0xB8, 0x05,
+	0x06, 0xCE, 0x91, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x91, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	// Bytes 3d00 - 3d3f
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3d40 - 3d7f
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	// Bytes 3d80 - 3dbf
+	0x06, 0xCE, 0xA9, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	// Bytes 3dc0 - 3dff
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	// Bytes 3e00 - 3e3f
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3e40 - 3e7f
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	// Bytes 3e80 - 3ebf
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x89, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	// Bytes 3ec0 - 3eff
+	0x06, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB0, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB3, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xB1, 0x86, 0xE0, 0xB1, 0x96, 0x85,
+	0x06, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8A, 0x11,
+	// Bytes 3f00 - 3f3f
+	0x06, 0xE3, 0x81, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x91, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x93, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x97, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f40 - 3f7f
+	0x06, 0xE3, 0x81, 0x99, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA4, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA8, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f80 - 3fbf
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x9A, 0x0D,
+	// Bytes 3fc0 - 3fff
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x82, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4000 - 403f
+	0x06, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4040 - 407f
+	0x06, 0xE3, 0x83, 0x84, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4080 - 40bf
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB0, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 40c0 - 40ff
+	0x06, 0xE3, 0x83, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	// Bytes 4100 - 413f
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	// Bytes 4140 - 417f
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCD,
+	// Bytes 4180 - 41bf
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	// Bytes 41c0 - 41ff
+	0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	// Bytes 4200 - 423f
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xF0, 0x91, 0x82, 0x99, 0xF0, 0x91, 0x82,
+	// Bytes 4240 - 427f
+	0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82, 0x9B, 0xF0,
+	0x91, 0x82, 0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82,
+	0xA5, 0xF0, 0x91, 0x82, 0xBA, 0x09, 0x42, 0xC2,
+	0xB4, 0x01, 0x43, 0x20, 0xCC, 0x81, 0xC9, 0x43,
+	0x20, 0xCC, 0x83, 0xC9, 0x43, 0x20, 0xCC, 0x84,
+	0xC9, 0x43, 0x20, 0xCC, 0x85, 0xC9, 0x43, 0x20,
+	0xCC, 0x86, 0xC9, 0x43, 0x20, 0xCC, 0x87, 0xC9,
+	0x43, 0x20, 0xCC, 0x88, 0xC9, 0x43, 0x20, 0xCC,
+	// Bytes 4280 - 42bf
+	0x8A, 0xC9, 0x43, 0x20, 0xCC, 0x8B, 0xC9, 0x43,
+	0x20, 0xCC, 0x93, 0xC9, 0x43, 0x20, 0xCC, 0x94,
+	0xC9, 0x43, 0x20, 0xCC, 0xA7, 0xA5, 0x43, 0x20,
+	0xCC, 0xA8, 0xA5, 0x43, 0x20, 0xCC, 0xB3, 0xB5,
+	0x43, 0x20, 0xCD, 0x82, 0xC9, 0x43, 0x20, 0xCD,
+	0x85, 0xD9, 0x43, 0x20, 0xD9, 0x8B, 0x59, 0x43,
+	0x20, 0xD9, 0x8C, 0x5D, 0x43, 0x20, 0xD9, 0x8D,
+	0x61, 0x43, 0x20, 0xD9, 0x8E, 0x65, 0x43, 0x20,
+	// Bytes 42c0 - 42ff
+	0xD9, 0x8F, 0x69, 0x43, 0x20, 0xD9, 0x90, 0x6D,
+	0x43, 0x20, 0xD9, 0x91, 0x71, 0x43, 0x20, 0xD9,
+	0x92, 0x75, 0x43, 0x41, 0xCC, 0x8A, 0xC9, 0x43,
+	0x73, 0xCC, 0x87, 0xC9, 0x44, 0x20, 0xE3, 0x82,
+	0x99, 0x0D, 0x44, 0x20, 0xE3, 0x82, 0x9A, 0x0D,
+	0x44, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x44, 0xCE,
+	0x91, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0x95, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0x97, 0xCC, 0x81, 0xC9,
+	// Bytes 4300 - 433f
+	0x44, 0xCE, 0x99, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0x9F, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC, 0x88, 0xC9,
+	0x44, 0xCE, 0xA9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xB1, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xB5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xB7, 0xCC, 0x81, 0xC9,
+	0x44, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xBF, 0xCC, 0x81, 0xC9, 0x44, 0xCF, 0x85, 0xCC,
+	// Bytes 4340 - 437f
+	0x81, 0xC9, 0x44, 0xCF, 0x89, 0xCC, 0x81, 0xC9,
+	0x44, 0xD7, 0x90, 0xD6, 0xB7, 0x31, 0x44, 0xD7,
+	0x90, 0xD6, 0xB8, 0x35, 0x44, 0xD7, 0x90, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x91, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x91, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x92, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x93, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x94, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x95, 0xD6, 0xB9, 0x39, 0x44, 0xD7,
+	// Bytes 4380 - 43bf
+	0x95, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x96, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x98, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x99, 0xD6, 0xB4, 0x25, 0x44, 0xD7,
+	0x99, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9A, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x9B, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x9B, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x9C, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9E, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA0, 0xD6, 0xBC, 0x41,
+	// Bytes 43c0 - 43ff
+	0x44, 0xD7, 0xA1, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA3, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6, 0xBF, 0x49,
+	0x44, 0xD7, 0xA6, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA7, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA8, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA9, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0xA9, 0xD7, 0x81, 0x4D, 0x44, 0xD7,
+	0xA9, 0xD7, 0x82, 0x51, 0x44, 0xD7, 0xAA, 0xD6,
+	// Bytes 4400 - 443f
+	0xBC, 0x41, 0x44, 0xD7, 0xB2, 0xD6, 0xB7, 0x31,
+	0x44, 0xD8, 0xA7, 0xD9, 0x8B, 0x59, 0x44, 0xD8,
+	0xA7, 0xD9, 0x93, 0xC9, 0x44, 0xD8, 0xA7, 0xD9,
+	0x94, 0xC9, 0x44, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x44, 0xD8, 0xB0, 0xD9, 0xB0, 0x79, 0x44, 0xD8,
+	0xB1, 0xD9, 0xB0, 0x79, 0x44, 0xD9, 0x80, 0xD9,
+	0x8B, 0x59, 0x44, 0xD9, 0x80, 0xD9, 0x8E, 0x65,
+	0x44, 0xD9, 0x80, 0xD9, 0x8F, 0x69, 0x44, 0xD9,
+	// Bytes 4440 - 447f
+	0x80, 0xD9, 0x90, 0x6D, 0x44, 0xD9, 0x80, 0xD9,
+	0x91, 0x71, 0x44, 0xD9, 0x80, 0xD9, 0x92, 0x75,
+	0x44, 0xD9, 0x87, 0xD9, 0xB0, 0x79, 0x44, 0xD9,
+	0x88, 0xD9, 0x94, 0xC9, 0x44, 0xD9, 0x89, 0xD9,
+	0xB0, 0x79, 0x44, 0xD9, 0x8A, 0xD9, 0x94, 0xC9,
+	0x44, 0xDB, 0x92, 0xD9, 0x94, 0xC9, 0x44, 0xDB,
+	0x95, 0xD9, 0x94, 0xC9, 0x45, 0x20, 0xCC, 0x88,
+	0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCC,
+	// Bytes 4480 - 44bf
+	0x81, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCD, 0x82,
+	0xCA, 0x45, 0x20, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x45, 0x20, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x45,
+	0x20, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x45, 0x20,
+	0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC,
+	0x94, 0xCC, 0x81, 0xCA, 0x45, 0x20, 0xCC, 0x94,
+	0xCD, 0x82, 0xCA, 0x45, 0x20, 0xD9, 0x8C, 0xD9,
+	0x91, 0x72, 0x45, 0x20, 0xD9, 0x8D, 0xD9, 0x91,
+	// Bytes 44c0 - 44ff
+	0x72, 0x45, 0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x72,
+	0x45, 0x20, 0xD9, 0x8F, 0xD9, 0x91, 0x72, 0x45,
+	0x20, 0xD9, 0x90, 0xD9, 0x91, 0x72, 0x45, 0x20,
+	0xD9, 0x91, 0xD9, 0xB0, 0x7A, 0x45, 0xE2, 0xAB,
+	0x9D, 0xCC, 0xB8, 0x05, 0x46, 0xCE, 0xB9, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xCF, 0x85, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xD7, 0xA9, 0xD6,
+	0xBC, 0xD7, 0x81, 0x4E, 0x46, 0xD7, 0xA9, 0xD6,
+	// Bytes 4500 - 453f
+	0xBC, 0xD7, 0x82, 0x52, 0x46, 0xD9, 0x80, 0xD9,
+	0x8E, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x8F, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x90, 0xD9, 0x91, 0x72, 0x46, 0xE0, 0xA4, 0x95,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x96,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x97,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x9C,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA1,
+	// Bytes 4540 - 457f
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA2,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAB,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAF,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA1,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA2,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xAF,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x96,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x97,
+	// Bytes 4580 - 45bf
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x9C,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xAB,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB2,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB8,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA1,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA2,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE0, 0xBE, 0xB3,
+	// Bytes 45c0 - 45ff
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0x0D, 0x48, 0xF0, 0x9D, 0x85,
+	0x97, 0xF0, 0x9D, 0x85, 0xA5, 0xAD, 0x48, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xAD,
+	0x48, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xAD, 0x48, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	0x9D, 0x85, 0xA5, 0xAD, 0x49, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x49,
+	// Bytes 4600 - 463f
+	0xE0, 0xBE, 0xB3, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE,
+	0x80, 0x9E, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xB0, 0xAE, 0x4C, 0xF0, 0x9D, 0x85,
+	0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	// Bytes 4640 - 467f
+	0xB1, 0xAE, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB2, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0, 0x9D, 0x86,
+	0xBA, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	0xAE, 0xAE, 0x4C, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	// Bytes 4680 - 46bf
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE,
+	0x83, 0x41, 0xCC, 0x82, 0xC9, 0x83, 0x41, 0xCC,
+	0x86, 0xC9, 0x83, 0x41, 0xCC, 0x87, 0xC9, 0x83,
+	0x41, 0xCC, 0x88, 0xC9, 0x83, 0x41, 0xCC, 0x8A,
+	0xC9, 0x83, 0x41, 0xCC, 0xA3, 0xB5, 0x83, 0x43,
+	0xCC, 0xA7, 0xA5, 0x83, 0x45, 0xCC, 0x82, 0xC9,
+	0x83, 0x45, 0xCC, 0x84, 0xC9, 0x83, 0x45, 0xCC,
+	0xA3, 0xB5, 0x83, 0x45, 0xCC, 0xA7, 0xA5, 0x83,
+	// Bytes 46c0 - 46ff
+	0x49, 0xCC, 0x88, 0xC9, 0x83, 0x4C, 0xCC, 0xA3,
+	0xB5, 0x83, 0x4F, 0xCC, 0x82, 0xC9, 0x83, 0x4F,
+	0xCC, 0x83, 0xC9, 0x83, 0x4F, 0xCC, 0x84, 0xC9,
+	0x83, 0x4F, 0xCC, 0x87, 0xC9, 0x83, 0x4F, 0xCC,
+	0x88, 0xC9, 0x83, 0x4F, 0xCC, 0x9B, 0xAD, 0x83,
+	0x4F, 0xCC, 0xA3, 0xB5, 0x83, 0x4F, 0xCC, 0xA8,
+	0xA5, 0x83, 0x52, 0xCC, 0xA3, 0xB5, 0x83, 0x53,
+	0xCC, 0x81, 0xC9, 0x83, 0x53, 0xCC, 0x8C, 0xC9,
+	// Bytes 4700 - 473f
+	0x83, 0x53, 0xCC, 0xA3, 0xB5, 0x83, 0x55, 0xCC,
+	0x83, 0xC9, 0x83, 0x55, 0xCC, 0x84, 0xC9, 0x83,
+	0x55, 0xCC, 0x88, 0xC9, 0x83, 0x55, 0xCC, 0x9B,
+	0xAD, 0x83, 0x61, 0xCC, 0x82, 0xC9, 0x83, 0x61,
+	0xCC, 0x86, 0xC9, 0x83, 0x61, 0xCC, 0x87, 0xC9,
+	0x83, 0x61, 0xCC, 0x88, 0xC9, 0x83, 0x61, 0xCC,
+	0x8A, 0xC9, 0x83, 0x61, 0xCC, 0xA3, 0xB5, 0x83,
+	0x63, 0xCC, 0xA7, 0xA5, 0x83, 0x65, 0xCC, 0x82,
+	// Bytes 4740 - 477f
+	0xC9, 0x83, 0x65, 0xCC, 0x84, 0xC9, 0x83, 0x65,
+	0xCC, 0xA3, 0xB5, 0x83, 0x65, 0xCC, 0xA7, 0xA5,
+	0x83, 0x69, 0xCC, 0x88, 0xC9, 0x83, 0x6C, 0xCC,
+	0xA3, 0xB5, 0x83, 0x6F, 0xCC, 0x82, 0xC9, 0x83,
+	0x6F, 0xCC, 0x83, 0xC9, 0x83, 0x6F, 0xCC, 0x84,
+	0xC9, 0x83, 0x6F, 0xCC, 0x87, 0xC9, 0x83, 0x6F,
+	0xCC, 0x88, 0xC9, 0x83, 0x6F, 0xCC, 0x9B, 0xAD,
+	0x83, 0x6F, 0xCC, 0xA3, 0xB5, 0x83, 0x6F, 0xCC,
+	// Bytes 4780 - 47bf
+	0xA8, 0xA5, 0x83, 0x72, 0xCC, 0xA3, 0xB5, 0x83,
+	0x73, 0xCC, 0x81, 0xC9, 0x83, 0x73, 0xCC, 0x8C,
+	0xC9, 0x83, 0x73, 0xCC, 0xA3, 0xB5, 0x83, 0x75,
+	0xCC, 0x83, 0xC9, 0x83, 0x75, 0xCC, 0x84, 0xC9,
+	0x83, 0x75, 0xCC, 0x88, 0xC9, 0x83, 0x75, 0xCC,
+	0x9B, 0xAD, 0x84, 0xCE, 0x91, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x91, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x95, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x95, 0xCC,
+	// Bytes 47c0 - 47ff
+	0x94, 0xC9, 0x84, 0xCE, 0x97, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x97, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x99, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x99, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0x9F, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x9F, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0xA5, 0xCC, 0x94, 0xC9, 0x84, 0xCE, 0xA9, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xA9, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCC, 0x80, 0xC9, 0x84, 0xCE,
+	// Bytes 4800 - 483f
+	0xB1, 0xCC, 0x81, 0xC9, 0x84, 0xCE, 0xB1, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xB1, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCD, 0x82, 0xC9, 0x84, 0xCE,
+	0xB5, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB5, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCC, 0x80, 0xC9,
+	0x84, 0xCE, 0xB7, 0xCC, 0x81, 0xC9, 0x84, 0xCE,
+	0xB7, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB7, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCD, 0x82, 0xC9,
+	// Bytes 4840 - 487f
+	0x84, 0xCE, 0xB9, 0xCC, 0x88, 0xC9, 0x84, 0xCE,
+	0xB9, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB9, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xBF, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0xBF, 0xCC, 0x94, 0xC9, 0x84, 0xCF,
+	0x85, 0xCC, 0x88, 0xC9, 0x84, 0xCF, 0x85, 0xCC,
+	0x93, 0xC9, 0x84, 0xCF, 0x85, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCC, 0x80, 0xC9, 0x84, 0xCF,
+	0x89, 0xCC, 0x81, 0xC9, 0x84, 0xCF, 0x89, 0xCC,
+	// Bytes 4880 - 48bf
+	0x93, 0xC9, 0x84, 0xCF, 0x89, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCD, 0x82, 0xC9, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	// Bytes 48c0 - 48ff
+	0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	// Bytes 4900 - 493f
+	0xA9, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	// Bytes 4940 - 497f
+	0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	// Bytes 4980 - 49bf
+	0x89, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x42, 0xCC,
+	0x80, 0xC9, 0x32, 0x42, 0xCC, 0x81, 0xC9, 0x32,
+	0x42, 0xCC, 0x93, 0xC9, 0x32, 0x43, 0xE1, 0x85,
+	// Bytes 49c0 - 49ff
+	0xA1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA5, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA6, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA7, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA8, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA9, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAA, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAB, 0x01, 0x00, 0x43,
+	// Bytes 4a00 - 4a3f
+	0xE1, 0x85, 0xAC, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xAD, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAE, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAF, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB0, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xB2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xB3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB5, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xAA, 0x01,
+	// Bytes 4a40 - 4a7f
+	0x00, 0x43, 0xE1, 0x86, 0xAC, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xAD, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB0, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB1, 0x01,
+	0x00, 0x43, 0xE1, 0x86, 0xB2, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xB3, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB4, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB5, 0x01,
+	0x00, 0x44, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x32,
+	0x43, 0xE3, 0x82, 0x99, 0x0D, 0x03, 0x43, 0xE3,
+	// Bytes 4a80 - 4abf
+	0x82, 0x9A, 0x0D, 0x03, 0x46, 0xE0, 0xBD, 0xB1,
+	0xE0, 0xBD, 0xB2, 0x9E, 0x26, 0x46, 0xE0, 0xBD,
+	0xB1, 0xE0, 0xBD, 0xB4, 0xA2, 0x26, 0x46, 0xE0,
+	0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x26, 0x00,
+	0x01,
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfcTrie. Total size: 10332 bytes (10.09 KiB). Checksum: 51cc525b297fc970.
+type nfcTrie struct{}
+
+func newNfcTrie(i int) *nfcTrie {
+	return &nfcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 44:
+		return uint16(nfcValues[n<<6+uint32(b)])
+	default:
+		n -= 44
+		return uint16(nfcSparse.lookup(n, b))
+	}
+}
+
+// nfcValues: 46 blocks, 2944 entries, 5888 bytes
+// The third block is the zero block.
+var nfcValues = [2944]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8,
+	// Block 0x5, offset 0x140
+	0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0xa000,
+	// Block 0x6, offset 0x180
+	0x184: 0x8100, 0x185: 0x8100,
+	0x186: 0x8100,
+	0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x8100,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x8100, 0x285: 0x35a1,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x3721, 0x2c1: 0x372d, 0x2c3: 0x371b,
+	0x2c6: 0xa000, 0x2c7: 0x3709,
+	0x2cc: 0x375d, 0x2cd: 0x3745, 0x2ce: 0x376f, 0x2d0: 0xa000,
+	0x2d3: 0xa000, 0x2d5: 0xa000, 0x2d6: 0xa000, 0x2d7: 0xa000,
+	0x2d8: 0xa000, 0x2d9: 0x3751, 0x2da: 0xa000,
+	0x2de: 0xa000, 0x2e3: 0xa000,
+	0x2e7: 0xa000,
+	0x2eb: 0xa000, 0x2ed: 0xa000,
+	0x2f0: 0xa000, 0x2f3: 0xa000, 0x2f5: 0xa000,
+	0x2f6: 0xa000, 0x2f7: 0xa000, 0x2f8: 0xa000, 0x2f9: 0x37d5, 0x2fa: 0xa000,
+	0x2fe: 0xa000,
+	// Block 0xc, offset 0x300
+	0x301: 0x3733, 0x302: 0x37b7,
+	0x310: 0x370f, 0x311: 0x3793,
+	0x312: 0x3715, 0x313: 0x3799, 0x316: 0x3727, 0x317: 0x37ab,
+	0x318: 0xa000, 0x319: 0xa000, 0x31a: 0x3829, 0x31b: 0x382f, 0x31c: 0x3739, 0x31d: 0x37bd,
+	0x31e: 0x373f, 0x31f: 0x37c3, 0x322: 0x374b, 0x323: 0x37cf,
+	0x324: 0x3757, 0x325: 0x37db, 0x326: 0x3763, 0x327: 0x37e7, 0x328: 0xa000, 0x329: 0xa000,
+	0x32a: 0x3835, 0x32b: 0x383b, 0x32c: 0x378d, 0x32d: 0x3811, 0x32e: 0x3769, 0x32f: 0x37ed,
+	0x330: 0x3775, 0x331: 0x37f9, 0x332: 0x377b, 0x333: 0x37ff, 0x334: 0x3781, 0x335: 0x3805,
+	0x338: 0x3787, 0x339: 0x380b,
+	// Block 0xd, offset 0x340
+	0x351: 0x812d,
+	0x352: 0x8132, 0x353: 0x8132, 0x354: 0x8132, 0x355: 0x8132, 0x356: 0x812d, 0x357: 0x8132,
+	0x358: 0x8132, 0x359: 0x8132, 0x35a: 0x812e, 0x35b: 0x812d, 0x35c: 0x8132, 0x35d: 0x8132,
+	0x35e: 0x8132, 0x35f: 0x8132, 0x360: 0x8132, 0x361: 0x8132, 0x362: 0x812d, 0x363: 0x812d,
+	0x364: 0x812d, 0x365: 0x812d, 0x366: 0x812d, 0x367: 0x812d, 0x368: 0x8132, 0x369: 0x8132,
+	0x36a: 0x812d, 0x36b: 0x8132, 0x36c: 0x8132, 0x36d: 0x812e, 0x36e: 0x8131, 0x36f: 0x8132,
+	0x370: 0x8105, 0x371: 0x8106, 0x372: 0x8107, 0x373: 0x8108, 0x374: 0x8109, 0x375: 0x810a,
+	0x376: 0x810b, 0x377: 0x810c, 0x378: 0x810d, 0x379: 0x810e, 0x37a: 0x810e, 0x37b: 0x810f,
+	0x37c: 0x8110, 0x37d: 0x8111, 0x37f: 0x8112,
+	// Block 0xe, offset 0x380
+	0x388: 0xa000, 0x38a: 0xa000, 0x38b: 0x8116,
+	0x38c: 0x8117, 0x38d: 0x8118, 0x38e: 0x8119, 0x38f: 0x811a, 0x390: 0x811b, 0x391: 0x811c,
+	0x392: 0x811d, 0x393: 0x9932, 0x394: 0x9932, 0x395: 0x992d, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x8132, 0x39b: 0x8132, 0x39c: 0x812d, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x812d,
+	0x3b0: 0x811e,
+	// Block 0xf, offset 0x3c0
+	0x3c5: 0xa000,
+	0x3c6: 0x2d26, 0x3c7: 0xa000, 0x3c8: 0x2d2e, 0x3c9: 0xa000, 0x3ca: 0x2d36, 0x3cb: 0xa000,
+	0x3cc: 0x2d3e, 0x3cd: 0xa000, 0x3ce: 0x2d46, 0x3d1: 0xa000,
+	0x3d2: 0x2d4e,
+	0x3f4: 0x8102, 0x3f5: 0x9900,
+	0x3fa: 0xa000, 0x3fb: 0x2d56,
+	0x3fc: 0xa000, 0x3fd: 0x2d5e, 0x3fe: 0xa000, 0x3ff: 0xa000,
+	// Block 0x10, offset 0x400
+	0x400: 0x2f97, 0x401: 0x32a3, 0x402: 0x2fa1, 0x403: 0x32ad, 0x404: 0x2fa6, 0x405: 0x32b2,
+	0x406: 0x2fab, 0x407: 0x32b7, 0x408: 0x38cc, 0x409: 0x3a5b, 0x40a: 0x2fc4, 0x40b: 0x32d0,
+	0x40c: 0x2fce, 0x40d: 0x32da, 0x40e: 0x2fdd, 0x40f: 0x32e9, 0x410: 0x2fd3, 0x411: 0x32df,
+	0x412: 0x2fd8, 0x413: 0x32e4, 0x414: 0x38ef, 0x415: 0x3a7e, 0x416: 0x38f6, 0x417: 0x3a85,
+	0x418: 0x3019, 0x419: 0x3325, 0x41a: 0x301e, 0x41b: 0x332a, 0x41c: 0x3904, 0x41d: 0x3a93,
+	0x41e: 0x3023, 0x41f: 0x332f, 0x420: 0x3032, 0x421: 0x333e, 0x422: 0x3050, 0x423: 0x335c,
+	0x424: 0x305f, 0x425: 0x336b, 0x426: 0x3055, 0x427: 0x3361, 0x428: 0x3064, 0x429: 0x3370,
+	0x42a: 0x3069, 0x42b: 0x3375, 0x42c: 0x30af, 0x42d: 0x33bb, 0x42e: 0x390b, 0x42f: 0x3a9a,
+	0x430: 0x30b9, 0x431: 0x33ca, 0x432: 0x30c3, 0x433: 0x33d4, 0x434: 0x30cd, 0x435: 0x33de,
+	0x436: 0x46c4, 0x437: 0x4755, 0x438: 0x3912, 0x439: 0x3aa1, 0x43a: 0x30e6, 0x43b: 0x33f7,
+	0x43c: 0x30e1, 0x43d: 0x33f2, 0x43e: 0x30eb, 0x43f: 0x33fc,
+	// Block 0x11, offset 0x440
+	0x440: 0x30f0, 0x441: 0x3401, 0x442: 0x30f5, 0x443: 0x3406, 0x444: 0x3109, 0x445: 0x341a,
+	0x446: 0x3113, 0x447: 0x3424, 0x448: 0x3122, 0x449: 0x3433, 0x44a: 0x311d, 0x44b: 0x342e,
+	0x44c: 0x3935, 0x44d: 0x3ac4, 0x44e: 0x3943, 0x44f: 0x3ad2, 0x450: 0x394a, 0x451: 0x3ad9,
+	0x452: 0x3951, 0x453: 0x3ae0, 0x454: 0x314f, 0x455: 0x3460, 0x456: 0x3154, 0x457: 0x3465,
+	0x458: 0x315e, 0x459: 0x346f, 0x45a: 0x46f1, 0x45b: 0x4782, 0x45c: 0x3997, 0x45d: 0x3b26,
+	0x45e: 0x3177, 0x45f: 0x3488, 0x460: 0x3181, 0x461: 0x3492, 0x462: 0x4700, 0x463: 0x4791,
+	0x464: 0x399e, 0x465: 0x3b2d, 0x466: 0x39a5, 0x467: 0x3b34, 0x468: 0x39ac, 0x469: 0x3b3b,
+	0x46a: 0x3190, 0x46b: 0x34a1, 0x46c: 0x319a, 0x46d: 0x34b0, 0x46e: 0x31ae, 0x46f: 0x34c4,
+	0x470: 0x31a9, 0x471: 0x34bf, 0x472: 0x31ea, 0x473: 0x3500, 0x474: 0x31f9, 0x475: 0x350f,
+	0x476: 0x31f4, 0x477: 0x350a, 0x478: 0x39b3, 0x479: 0x3b42, 0x47a: 0x39ba, 0x47b: 0x3b49,
+	0x47c: 0x31fe, 0x47d: 0x3514, 0x47e: 0x3203, 0x47f: 0x3519,
+	// Block 0x12, offset 0x480
+	0x480: 0x3208, 0x481: 0x351e, 0x482: 0x320d, 0x483: 0x3523, 0x484: 0x321c, 0x485: 0x3532,
+	0x486: 0x3217, 0x487: 0x352d, 0x488: 0x3221, 0x489: 0x353c, 0x48a: 0x3226, 0x48b: 0x3541,
+	0x48c: 0x322b, 0x48d: 0x3546, 0x48e: 0x3249, 0x48f: 0x3564, 0x490: 0x3262, 0x491: 0x3582,
+	0x492: 0x3271, 0x493: 0x3591, 0x494: 0x3276, 0x495: 0x3596, 0x496: 0x337a, 0x497: 0x34a6,
+	0x498: 0x3537, 0x499: 0x3573, 0x49b: 0x35d1,
+	0x4a0: 0x46a1, 0x4a1: 0x4732, 0x4a2: 0x2f83, 0x4a3: 0x328f,
+	0x4a4: 0x3878, 0x4a5: 0x3a07, 0x4a6: 0x3871, 0x4a7: 0x3a00, 0x4a8: 0x3886, 0x4a9: 0x3a15,
+	0x4aa: 0x387f, 0x4ab: 0x3a0e, 0x4ac: 0x38be, 0x4ad: 0x3a4d, 0x4ae: 0x3894, 0x4af: 0x3a23,
+	0x4b0: 0x388d, 0x4b1: 0x3a1c, 0x4b2: 0x38a2, 0x4b3: 0x3a31, 0x4b4: 0x389b, 0x4b5: 0x3a2a,
+	0x4b6: 0x38c5, 0x4b7: 0x3a54, 0x4b8: 0x46b5, 0x4b9: 0x4746, 0x4ba: 0x3000, 0x4bb: 0x330c,
+	0x4bc: 0x2fec, 0x4bd: 0x32f8, 0x4be: 0x38da, 0x4bf: 0x3a69,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x38d3, 0x4c1: 0x3a62, 0x4c2: 0x38e8, 0x4c3: 0x3a77, 0x4c4: 0x38e1, 0x4c5: 0x3a70,
+	0x4c6: 0x38fd, 0x4c7: 0x3a8c, 0x4c8: 0x3091, 0x4c9: 0x339d, 0x4ca: 0x30a5, 0x4cb: 0x33b1,
+	0x4cc: 0x46e7, 0x4cd: 0x4778, 0x4ce: 0x3136, 0x4cf: 0x3447, 0x4d0: 0x3920, 0x4d1: 0x3aaf,
+	0x4d2: 0x3919, 0x4d3: 0x3aa8, 0x4d4: 0x392e, 0x4d5: 0x3abd, 0x4d6: 0x3927, 0x4d7: 0x3ab6,
+	0x4d8: 0x3989, 0x4d9: 0x3b18, 0x4da: 0x396d, 0x4db: 0x3afc, 0x4dc: 0x3966, 0x4dd: 0x3af5,
+	0x4de: 0x397b, 0x4df: 0x3b0a, 0x4e0: 0x3974, 0x4e1: 0x3b03, 0x4e2: 0x3982, 0x4e3: 0x3b11,
+	0x4e4: 0x31e5, 0x4e5: 0x34fb, 0x4e6: 0x31c7, 0x4e7: 0x34dd, 0x4e8: 0x39e4, 0x4e9: 0x3b73,
+	0x4ea: 0x39dd, 0x4eb: 0x3b6c, 0x4ec: 0x39f2, 0x4ed: 0x3b81, 0x4ee: 0x39eb, 0x4ef: 0x3b7a,
+	0x4f0: 0x39f9, 0x4f1: 0x3b88, 0x4f2: 0x3230, 0x4f3: 0x354b, 0x4f4: 0x3258, 0x4f5: 0x3578,
+	0x4f6: 0x3253, 0x4f7: 0x356e, 0x4f8: 0x323f, 0x4f9: 0x355a,
+	// Block 0x14, offset 0x500
+	0x500: 0x4804, 0x501: 0x480a, 0x502: 0x491e, 0x503: 0x4936, 0x504: 0x4926, 0x505: 0x493e,
+	0x506: 0x492e, 0x507: 0x4946, 0x508: 0x47aa, 0x509: 0x47b0, 0x50a: 0x488e, 0x50b: 0x48a6,
+	0x50c: 0x4896, 0x50d: 0x48ae, 0x50e: 0x489e, 0x50f: 0x48b6, 0x510: 0x4816, 0x511: 0x481c,
+	0x512: 0x3db8, 0x513: 0x3dc8, 0x514: 0x3dc0, 0x515: 0x3dd0,
+	0x518: 0x47b6, 0x519: 0x47bc, 0x51a: 0x3ce8, 0x51b: 0x3cf8, 0x51c: 0x3cf0, 0x51d: 0x3d00,
+	0x520: 0x482e, 0x521: 0x4834, 0x522: 0x494e, 0x523: 0x4966,
+	0x524: 0x4956, 0x525: 0x496e, 0x526: 0x495e, 0x527: 0x4976, 0x528: 0x47c2, 0x529: 0x47c8,
+	0x52a: 0x48be, 0x52b: 0x48d6, 0x52c: 0x48c6, 0x52d: 0x48de, 0x52e: 0x48ce, 0x52f: 0x48e6,
+	0x530: 0x4846, 0x531: 0x484c, 0x532: 0x3e18, 0x533: 0x3e30, 0x534: 0x3e20, 0x535: 0x3e38,
+	0x536: 0x3e28, 0x537: 0x3e40, 0x538: 0x47ce, 0x539: 0x47d4, 0x53a: 0x3d18, 0x53b: 0x3d30,
+	0x53c: 0x3d20, 0x53d: 0x3d38, 0x53e: 0x3d28, 0x53f: 0x3d40,
+	// Block 0x15, offset 0x540
+	0x540: 0x4852, 0x541: 0x4858, 0x542: 0x3e48, 0x543: 0x3e58, 0x544: 0x3e50, 0x545: 0x3e60,
+	0x548: 0x47da, 0x549: 0x47e0, 0x54a: 0x3d48, 0x54b: 0x3d58,
+	0x54c: 0x3d50, 0x54d: 0x3d60, 0x550: 0x4864, 0x551: 0x486a,
+	0x552: 0x3e80, 0x553: 0x3e98, 0x554: 0x3e88, 0x555: 0x3ea0, 0x556: 0x3e90, 0x557: 0x3ea8,
+	0x559: 0x47e6, 0x55b: 0x3d68, 0x55d: 0x3d70,
+	0x55f: 0x3d78, 0x560: 0x487c, 0x561: 0x4882, 0x562: 0x497e, 0x563: 0x4996,
+	0x564: 0x4986, 0x565: 0x499e, 0x566: 0x498e, 0x567: 0x49a6, 0x568: 0x47ec, 0x569: 0x47f2,
+	0x56a: 0x48ee, 0x56b: 0x4906, 0x56c: 0x48f6, 0x56d: 0x490e, 0x56e: 0x48fe, 0x56f: 0x4916,
+	0x570: 0x47f8, 0x571: 0x431e, 0x572: 0x3691, 0x573: 0x4324, 0x574: 0x4822, 0x575: 0x432a,
+	0x576: 0x36a3, 0x577: 0x4330, 0x578: 0x36c1, 0x579: 0x4336, 0x57a: 0x36d9, 0x57b: 0x433c,
+	0x57c: 0x4870, 0x57d: 0x4342,
+	// Block 0x16, offset 0x580
+	0x580: 0x3da0, 0x581: 0x3da8, 0x582: 0x4184, 0x583: 0x41a2, 0x584: 0x418e, 0x585: 0x41ac,
+	0x586: 0x4198, 0x587: 0x41b6, 0x588: 0x3cd8, 0x589: 0x3ce0, 0x58a: 0x40d0, 0x58b: 0x40ee,
+	0x58c: 0x40da, 0x58d: 0x40f8, 0x58e: 0x40e4, 0x58f: 0x4102, 0x590: 0x3de8, 0x591: 0x3df0,
+	0x592: 0x41c0, 0x593: 0x41de, 0x594: 0x41ca, 0x595: 0x41e8, 0x596: 0x41d4, 0x597: 0x41f2,
+	0x598: 0x3d08, 0x599: 0x3d10, 0x59a: 0x410c, 0x59b: 0x412a, 0x59c: 0x4116, 0x59d: 0x4134,
+	0x59e: 0x4120, 0x59f: 0x413e, 0x5a0: 0x3ec0, 0x5a1: 0x3ec8, 0x5a2: 0x41fc, 0x5a3: 0x421a,
+	0x5a4: 0x4206, 0x5a5: 0x4224, 0x5a6: 0x4210, 0x5a7: 0x422e, 0x5a8: 0x3d80, 0x5a9: 0x3d88,
+	0x5aa: 0x4148, 0x5ab: 0x4166, 0x5ac: 0x4152, 0x5ad: 0x4170, 0x5ae: 0x415c, 0x5af: 0x417a,
+	0x5b0: 0x3685, 0x5b1: 0x367f, 0x5b2: 0x3d90, 0x5b3: 0x368b, 0x5b4: 0x3d98,
+	0x5b6: 0x4810, 0x5b7: 0x3db0, 0x5b8: 0x35f5, 0x5b9: 0x35ef, 0x5ba: 0x35e3, 0x5bb: 0x42ee,
+	0x5bc: 0x35fb, 0x5bd: 0x8100, 0x5be: 0x01d3, 0x5bf: 0xa100,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x8100, 0x5c1: 0x35a7, 0x5c2: 0x3dd8, 0x5c3: 0x369d, 0x5c4: 0x3de0,
+	0x5c6: 0x483a, 0x5c7: 0x3df8, 0x5c8: 0x3601, 0x5c9: 0x42f4, 0x5ca: 0x360d, 0x5cb: 0x42fa,
+	0x5cc: 0x3619, 0x5cd: 0x3b8f, 0x5ce: 0x3b96, 0x5cf: 0x3b9d, 0x5d0: 0x36b5, 0x5d1: 0x36af,
+	0x5d2: 0x3e00, 0x5d3: 0x44e4, 0x5d6: 0x36bb, 0x5d7: 0x3e10,
+	0x5d8: 0x3631, 0x5d9: 0x362b, 0x5da: 0x361f, 0x5db: 0x4300, 0x5dd: 0x3ba4,
+	0x5de: 0x3bab, 0x5df: 0x3bb2, 0x5e0: 0x36eb, 0x5e1: 0x36e5, 0x5e2: 0x3e68, 0x5e3: 0x44ec,
+	0x5e4: 0x36cd, 0x5e5: 0x36d3, 0x5e6: 0x36f1, 0x5e7: 0x3e78, 0x5e8: 0x3661, 0x5e9: 0x365b,
+	0x5ea: 0x364f, 0x5eb: 0x430c, 0x5ec: 0x3649, 0x5ed: 0x359b, 0x5ee: 0x42e8, 0x5ef: 0x0081,
+	0x5f2: 0x3eb0, 0x5f3: 0x36f7, 0x5f4: 0x3eb8,
+	0x5f6: 0x4888, 0x5f7: 0x3ed0, 0x5f8: 0x363d, 0x5f9: 0x4306, 0x5fa: 0x366d, 0x5fb: 0x4318,
+	0x5fc: 0x3679, 0x5fd: 0x4256, 0x5fe: 0xa100,
+	// Block 0x18, offset 0x600
+	0x601: 0x3c06, 0x603: 0xa000, 0x604: 0x3c0d, 0x605: 0xa000,
+	0x607: 0x3c14, 0x608: 0xa000, 0x609: 0x3c1b,
+	0x60d: 0xa000,
+	0x620: 0x2f65, 0x621: 0xa000, 0x622: 0x3c29,
+	0x624: 0xa000, 0x625: 0xa000,
+	0x62d: 0x3c22, 0x62e: 0x2f60, 0x62f: 0x2f6a,
+	0x630: 0x3c30, 0x631: 0x3c37, 0x632: 0xa000, 0x633: 0xa000, 0x634: 0x3c3e, 0x635: 0x3c45,
+	0x636: 0xa000, 0x637: 0xa000, 0x638: 0x3c4c, 0x639: 0x3c53, 0x63a: 0xa000, 0x63b: 0xa000,
+	0x63c: 0xa000, 0x63d: 0xa000,
+	// Block 0x19, offset 0x640
+	0x640: 0x3c5a, 0x641: 0x3c61, 0x642: 0xa000, 0x643: 0xa000, 0x644: 0x3c76, 0x645: 0x3c7d,
+	0x646: 0xa000, 0x647: 0xa000, 0x648: 0x3c84, 0x649: 0x3c8b,
+	0x651: 0xa000,
+	0x652: 0xa000,
+	0x662: 0xa000,
+	0x668: 0xa000, 0x669: 0xa000,
+	0x66b: 0xa000, 0x66c: 0x3ca0, 0x66d: 0x3ca7, 0x66e: 0x3cae, 0x66f: 0x3cb5,
+	0x672: 0xa000, 0x673: 0xa000, 0x674: 0xa000, 0x675: 0xa000,
+	// Block 0x1a, offset 0x680
+	0x686: 0xa000, 0x68b: 0xa000,
+	0x68c: 0x3f08, 0x68d: 0xa000, 0x68e: 0x3f10, 0x68f: 0xa000, 0x690: 0x3f18, 0x691: 0xa000,
+	0x692: 0x3f20, 0x693: 0xa000, 0x694: 0x3f28, 0x695: 0xa000, 0x696: 0x3f30, 0x697: 0xa000,
+	0x698: 0x3f38, 0x699: 0xa000, 0x69a: 0x3f40, 0x69b: 0xa000, 0x69c: 0x3f48, 0x69d: 0xa000,
+	0x69e: 0x3f50, 0x69f: 0xa000, 0x6a0: 0x3f58, 0x6a1: 0xa000, 0x6a2: 0x3f60,
+	0x6a4: 0xa000, 0x6a5: 0x3f68, 0x6a6: 0xa000, 0x6a7: 0x3f70, 0x6a8: 0xa000, 0x6a9: 0x3f78,
+	0x6af: 0xa000,
+	0x6b0: 0x3f80, 0x6b1: 0x3f88, 0x6b2: 0xa000, 0x6b3: 0x3f90, 0x6b4: 0x3f98, 0x6b5: 0xa000,
+	0x6b6: 0x3fa0, 0x6b7: 0x3fa8, 0x6b8: 0xa000, 0x6b9: 0x3fb0, 0x6ba: 0x3fb8, 0x6bb: 0xa000,
+	0x6bc: 0x3fc0, 0x6bd: 0x3fc8,
+	// Block 0x1b, offset 0x6c0
+	0x6d4: 0x3f00,
+	0x6d9: 0x9903, 0x6da: 0x9903, 0x6db: 0x8100, 0x6dc: 0x8100, 0x6dd: 0xa000,
+	0x6de: 0x3fd0,
+	0x6e6: 0xa000,
+	0x6eb: 0xa000, 0x6ec: 0x3fe0, 0x6ed: 0xa000, 0x6ee: 0x3fe8, 0x6ef: 0xa000,
+	0x6f0: 0x3ff0, 0x6f1: 0xa000, 0x6f2: 0x3ff8, 0x6f3: 0xa000, 0x6f4: 0x4000, 0x6f5: 0xa000,
+	0x6f6: 0x4008, 0x6f7: 0xa000, 0x6f8: 0x4010, 0x6f9: 0xa000, 0x6fa: 0x4018, 0x6fb: 0xa000,
+	0x6fc: 0x4020, 0x6fd: 0xa000, 0x6fe: 0x4028, 0x6ff: 0xa000,
+	// Block 0x1c, offset 0x700
+	0x700: 0x4030, 0x701: 0xa000, 0x702: 0x4038, 0x704: 0xa000, 0x705: 0x4040,
+	0x706: 0xa000, 0x707: 0x4048, 0x708: 0xa000, 0x709: 0x4050,
+	0x70f: 0xa000, 0x710: 0x4058, 0x711: 0x4060,
+	0x712: 0xa000, 0x713: 0x4068, 0x714: 0x4070, 0x715: 0xa000, 0x716: 0x4078, 0x717: 0x4080,
+	0x718: 0xa000, 0x719: 0x4088, 0x71a: 0x4090, 0x71b: 0xa000, 0x71c: 0x4098, 0x71d: 0x40a0,
+	0x72f: 0xa000,
+	0x730: 0xa000, 0x731: 0xa000, 0x732: 0xa000, 0x734: 0x3fd8,
+	0x737: 0x40a8, 0x738: 0x40b0, 0x739: 0x40b8, 0x73a: 0x40c0,
+	0x73d: 0xa000, 0x73e: 0x40c8,
+	// Block 0x1d, offset 0x740
+	0x740: 0x1377, 0x741: 0x0cfb, 0x742: 0x13d3, 0x743: 0x139f, 0x744: 0x0e57, 0x745: 0x06eb,
+	0x746: 0x08df, 0x747: 0x162b, 0x748: 0x162b, 0x749: 0x0a0b, 0x74a: 0x145f, 0x74b: 0x0943,
+	0x74c: 0x0a07, 0x74d: 0x0bef, 0x74e: 0x0fcf, 0x74f: 0x115f, 0x750: 0x1297, 0x751: 0x12d3,
+	0x752: 0x1307, 0x753: 0x141b, 0x754: 0x0d73, 0x755: 0x0dff, 0x756: 0x0eab, 0x757: 0x0f43,
+	0x758: 0x125f, 0x759: 0x1447, 0x75a: 0x1573, 0x75b: 0x070f, 0x75c: 0x08b3, 0x75d: 0x0d87,
+	0x75e: 0x0ecf, 0x75f: 0x1293, 0x760: 0x15c3, 0x761: 0x0ab3, 0x762: 0x0e77, 0x763: 0x1283,
+	0x764: 0x1317, 0x765: 0x0c23, 0x766: 0x11bb, 0x767: 0x12df, 0x768: 0x0b1f, 0x769: 0x0d0f,
+	0x76a: 0x0e17, 0x76b: 0x0f1b, 0x76c: 0x1427, 0x76d: 0x074f, 0x76e: 0x07e7, 0x76f: 0x0853,
+	0x770: 0x0c8b, 0x771: 0x0d7f, 0x772: 0x0ecb, 0x773: 0x0fef, 0x774: 0x1177, 0x775: 0x128b,
+	0x776: 0x12a3, 0x777: 0x13c7, 0x778: 0x14ef, 0x779: 0x15a3, 0x77a: 0x15bf, 0x77b: 0x102b,
+	0x77c: 0x106b, 0x77d: 0x1123, 0x77e: 0x1243, 0x77f: 0x147b,
+	// Block 0x1e, offset 0x780
+	0x780: 0x15cb, 0x781: 0x134b, 0x782: 0x09c7, 0x783: 0x0b3b, 0x784: 0x10db, 0x785: 0x119b,
+	0x786: 0x0eff, 0x787: 0x1033, 0x788: 0x1397, 0x789: 0x14e7, 0x78a: 0x09c3, 0x78b: 0x0a8f,
+	0x78c: 0x0d77, 0x78d: 0x0e2b, 0x78e: 0x0e5f, 0x78f: 0x1113, 0x790: 0x113b, 0x791: 0x14a7,
+	0x792: 0x084f, 0x793: 0x11a7, 0x794: 0x07f3, 0x795: 0x07ef, 0x796: 0x1097, 0x797: 0x1127,
+	0x798: 0x125b, 0x799: 0x14af, 0x79a: 0x1367, 0x79b: 0x0c27, 0x79c: 0x0d73, 0x79d: 0x1357,
+	0x79e: 0x06f7, 0x79f: 0x0a63, 0x7a0: 0x0b93, 0x7a1: 0x0f2f, 0x7a2: 0x0faf, 0x7a3: 0x0873,
+	0x7a4: 0x103b, 0x7a5: 0x075f, 0x7a6: 0x0b77, 0x7a7: 0x06d7, 0x7a8: 0x0deb, 0x7a9: 0x0ca3,
+	0x7aa: 0x110f, 0x7ab: 0x08c7, 0x7ac: 0x09b3, 0x7ad: 0x0ffb, 0x7ae: 0x1263, 0x7af: 0x133b,
+	0x7b0: 0x0db7, 0x7b1: 0x13f7, 0x7b2: 0x0de3, 0x7b3: 0x0c37, 0x7b4: 0x121b, 0x7b5: 0x0c57,
+	0x7b6: 0x0fab, 0x7b7: 0x072b, 0x7b8: 0x07a7, 0x7b9: 0x07eb, 0x7ba: 0x0d53, 0x7bb: 0x10fb,
+	0x7bc: 0x11f3, 0x7bd: 0x1347, 0x7be: 0x145b, 0x7bf: 0x085b,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x090f, 0x7c1: 0x0a17, 0x7c2: 0x0b2f, 0x7c3: 0x0cbf, 0x7c4: 0x0e7b, 0x7c5: 0x103f,
+	0x7c6: 0x1497, 0x7c7: 0x157b, 0x7c8: 0x15cf, 0x7c9: 0x15e7, 0x7ca: 0x0837, 0x7cb: 0x0cf3,
+	0x7cc: 0x0da3, 0x7cd: 0x13eb, 0x7ce: 0x0afb, 0x7cf: 0x0bd7, 0x7d0: 0x0bf3, 0x7d1: 0x0c83,
+	0x7d2: 0x0e6b, 0x7d3: 0x0eb7, 0x7d4: 0x0f67, 0x7d5: 0x108b, 0x7d6: 0x112f, 0x7d7: 0x1193,
+	0x7d8: 0x13db, 0x7d9: 0x126b, 0x7da: 0x1403, 0x7db: 0x147f, 0x7dc: 0x080f, 0x7dd: 0x083b,
+	0x7de: 0x0923, 0x7df: 0x0ea7, 0x7e0: 0x12f3, 0x7e1: 0x133b, 0x7e2: 0x0b1b, 0x7e3: 0x0b8b,
+	0x7e4: 0x0c4f, 0x7e5: 0x0daf, 0x7e6: 0x10d7, 0x7e7: 0x0f23, 0x7e8: 0x073b, 0x7e9: 0x097f,
+	0x7ea: 0x0a63, 0x7eb: 0x0ac7, 0x7ec: 0x0b97, 0x7ed: 0x0f3f, 0x7ee: 0x0f5b, 0x7ef: 0x116b,
+	0x7f0: 0x118b, 0x7f1: 0x1463, 0x7f2: 0x14e3, 0x7f3: 0x14f3, 0x7f4: 0x152f, 0x7f5: 0x0753,
+	0x7f6: 0x107f, 0x7f7: 0x144f, 0x7f8: 0x14cb, 0x7f9: 0x0baf, 0x7fa: 0x0717, 0x7fb: 0x0777,
+	0x7fc: 0x0a67, 0x7fd: 0x0a87, 0x7fe: 0x0caf, 0x7ff: 0x0d73,
+	// Block 0x20, offset 0x800
+	0x800: 0x0ec3, 0x801: 0x0fcb, 0x802: 0x1277, 0x803: 0x1417, 0x804: 0x1623, 0x805: 0x0ce3,
+	0x806: 0x14a3, 0x807: 0x0833, 0x808: 0x0d2f, 0x809: 0x0d3b, 0x80a: 0x0e0f, 0x80b: 0x0e47,
+	0x80c: 0x0f4b, 0x80d: 0x0fa7, 0x80e: 0x1027, 0x80f: 0x110b, 0x810: 0x153b, 0x811: 0x07af,
+	0x812: 0x0c03, 0x813: 0x14b3, 0x814: 0x0767, 0x815: 0x0aab, 0x816: 0x0e2f, 0x817: 0x13df,
+	0x818: 0x0b67, 0x819: 0x0bb7, 0x81a: 0x0d43, 0x81b: 0x0f2f, 0x81c: 0x14bb, 0x81d: 0x0817,
+	0x81e: 0x08ff, 0x81f: 0x0a97, 0x820: 0x0cd3, 0x821: 0x0d1f, 0x822: 0x0d5f, 0x823: 0x0df3,
+	0x824: 0x0f47, 0x825: 0x0fbb, 0x826: 0x1157, 0x827: 0x12f7, 0x828: 0x1303, 0x829: 0x1457,
+	0x82a: 0x14d7, 0x82b: 0x0883, 0x82c: 0x0e4b, 0x82d: 0x0903, 0x82e: 0x0ec7, 0x82f: 0x0f6b,
+	0x830: 0x1287, 0x831: 0x14bf, 0x832: 0x15ab, 0x833: 0x15d3, 0x834: 0x0d37, 0x835: 0x0e27,
+	0x836: 0x11c3, 0x837: 0x10b7, 0x838: 0x10c3, 0x839: 0x10e7, 0x83a: 0x0f17, 0x83b: 0x0e9f,
+	0x83c: 0x1363, 0x83d: 0x0733, 0x83e: 0x122b, 0x83f: 0x081b,
+	// Block 0x21, offset 0x840
+	0x840: 0x080b, 0x841: 0x0b0b, 0x842: 0x0c2b, 0x843: 0x10f3, 0x844: 0x0a53, 0x845: 0x0e03,
+	0x846: 0x0cef, 0x847: 0x13e7, 0x848: 0x12e7, 0x849: 0x14ab, 0x84a: 0x1323, 0x84b: 0x0b27,
+	0x84c: 0x0787, 0x84d: 0x095b, 0x850: 0x09af,
+	0x852: 0x0cdf, 0x855: 0x07f7, 0x856: 0x0f1f, 0x857: 0x0fe3,
+	0x858: 0x1047, 0x859: 0x1063, 0x85a: 0x1067, 0x85b: 0x107b, 0x85c: 0x14fb, 0x85d: 0x10eb,
+	0x85e: 0x116f, 0x860: 0x128f, 0x862: 0x1353,
+	0x865: 0x1407, 0x866: 0x1433,
+	0x86a: 0x154f, 0x86b: 0x1553, 0x86c: 0x1557, 0x86d: 0x15bb, 0x86e: 0x142b, 0x86f: 0x14c7,
+	0x870: 0x0757, 0x871: 0x077b, 0x872: 0x078f, 0x873: 0x084b, 0x874: 0x0857, 0x875: 0x0897,
+	0x876: 0x094b, 0x877: 0x0967, 0x878: 0x096f, 0x879: 0x09ab, 0x87a: 0x09b7, 0x87b: 0x0a93,
+	0x87c: 0x0a9b, 0x87d: 0x0ba3, 0x87e: 0x0bcb, 0x87f: 0x0bd3,
+	// Block 0x22, offset 0x880
+	0x880: 0x0beb, 0x881: 0x0c97, 0x882: 0x0cc7, 0x883: 0x0ce7, 0x884: 0x0d57, 0x885: 0x0e1b,
+	0x886: 0x0e37, 0x887: 0x0e67, 0x888: 0x0ebb, 0x889: 0x0edb, 0x88a: 0x0f4f, 0x88b: 0x102f,
+	0x88c: 0x104b, 0x88d: 0x1053, 0x88e: 0x104f, 0x88f: 0x1057, 0x890: 0x105b, 0x891: 0x105f,
+	0x892: 0x1073, 0x893: 0x1077, 0x894: 0x109b, 0x895: 0x10af, 0x896: 0x10cb, 0x897: 0x112f,
+	0x898: 0x1137, 0x899: 0x113f, 0x89a: 0x1153, 0x89b: 0x117b, 0x89c: 0x11cb, 0x89d: 0x11ff,
+	0x89e: 0x11ff, 0x89f: 0x1267, 0x8a0: 0x130f, 0x8a1: 0x1327, 0x8a2: 0x135b, 0x8a3: 0x135f,
+	0x8a4: 0x13a3, 0x8a5: 0x13a7, 0x8a6: 0x13ff, 0x8a7: 0x1407, 0x8a8: 0x14db, 0x8a9: 0x151f,
+	0x8aa: 0x1537, 0x8ab: 0x0b9b, 0x8ac: 0x171e, 0x8ad: 0x11e3,
+	0x8b0: 0x06df, 0x8b1: 0x07e3, 0x8b2: 0x07a3, 0x8b3: 0x074b, 0x8b4: 0x078b, 0x8b5: 0x07b7,
+	0x8b6: 0x0847, 0x8b7: 0x0863, 0x8b8: 0x094b, 0x8b9: 0x0937, 0x8ba: 0x0947, 0x8bb: 0x0963,
+	0x8bc: 0x09af, 0x8bd: 0x09bf, 0x8be: 0x0a03, 0x8bf: 0x0a0f,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0a2b, 0x8c1: 0x0a3b, 0x8c2: 0x0b23, 0x8c3: 0x0b2b, 0x8c4: 0x0b5b, 0x8c5: 0x0b7b,
+	0x8c6: 0x0bab, 0x8c7: 0x0bc3, 0x8c8: 0x0bb3, 0x8c9: 0x0bd3, 0x8ca: 0x0bc7, 0x8cb: 0x0beb,
+	0x8cc: 0x0c07, 0x8cd: 0x0c5f, 0x8ce: 0x0c6b, 0x8cf: 0x0c73, 0x8d0: 0x0c9b, 0x8d1: 0x0cdf,
+	0x8d2: 0x0d0f, 0x8d3: 0x0d13, 0x8d4: 0x0d27, 0x8d5: 0x0da7, 0x8d6: 0x0db7, 0x8d7: 0x0e0f,
+	0x8d8: 0x0e5b, 0x8d9: 0x0e53, 0x8da: 0x0e67, 0x8db: 0x0e83, 0x8dc: 0x0ebb, 0x8dd: 0x1013,
+	0x8de: 0x0edf, 0x8df: 0x0f13, 0x8e0: 0x0f1f, 0x8e1: 0x0f5f, 0x8e2: 0x0f7b, 0x8e3: 0x0f9f,
+	0x8e4: 0x0fc3, 0x8e5: 0x0fc7, 0x8e6: 0x0fe3, 0x8e7: 0x0fe7, 0x8e8: 0x0ff7, 0x8e9: 0x100b,
+	0x8ea: 0x1007, 0x8eb: 0x1037, 0x8ec: 0x10b3, 0x8ed: 0x10cb, 0x8ee: 0x10e3, 0x8ef: 0x111b,
+	0x8f0: 0x112f, 0x8f1: 0x114b, 0x8f2: 0x117b, 0x8f3: 0x122f, 0x8f4: 0x1257, 0x8f5: 0x12cb,
+	0x8f6: 0x1313, 0x8f7: 0x131f, 0x8f8: 0x1327, 0x8f9: 0x133f, 0x8fa: 0x1353, 0x8fb: 0x1343,
+	0x8fc: 0x135b, 0x8fd: 0x1357, 0x8fe: 0x134f, 0x8ff: 0x135f,
+	// Block 0x24, offset 0x900
+	0x900: 0x136b, 0x901: 0x13a7, 0x902: 0x13e3, 0x903: 0x1413, 0x904: 0x144b, 0x905: 0x146b,
+	0x906: 0x14b7, 0x907: 0x14db, 0x908: 0x14fb, 0x909: 0x150f, 0x90a: 0x151f, 0x90b: 0x152b,
+	0x90c: 0x1537, 0x90d: 0x158b, 0x90e: 0x162b, 0x90f: 0x16b5, 0x910: 0x16b0, 0x911: 0x16e2,
+	0x912: 0x0607, 0x913: 0x062f, 0x914: 0x0633, 0x915: 0x1764, 0x916: 0x1791, 0x917: 0x1809,
+	0x918: 0x1617, 0x919: 0x1627,
+	// Block 0x25, offset 0x940
+	0x940: 0x06fb, 0x941: 0x06f3, 0x942: 0x0703, 0x943: 0x1647, 0x944: 0x0747, 0x945: 0x0757,
+	0x946: 0x075b, 0x947: 0x0763, 0x948: 0x076b, 0x949: 0x076f, 0x94a: 0x077b, 0x94b: 0x0773,
+	0x94c: 0x05b3, 0x94d: 0x165b, 0x94e: 0x078f, 0x94f: 0x0793, 0x950: 0x0797, 0x951: 0x07b3,
+	0x952: 0x164c, 0x953: 0x05b7, 0x954: 0x079f, 0x955: 0x07bf, 0x956: 0x1656, 0x957: 0x07cf,
+	0x958: 0x07d7, 0x959: 0x0737, 0x95a: 0x07df, 0x95b: 0x07e3, 0x95c: 0x1831, 0x95d: 0x07ff,
+	0x95e: 0x0807, 0x95f: 0x05bf, 0x960: 0x081f, 0x961: 0x0823, 0x962: 0x082b, 0x963: 0x082f,
+	0x964: 0x05c3, 0x965: 0x0847, 0x966: 0x084b, 0x967: 0x0857, 0x968: 0x0863, 0x969: 0x0867,
+	0x96a: 0x086b, 0x96b: 0x0873, 0x96c: 0x0893, 0x96d: 0x0897, 0x96e: 0x089f, 0x96f: 0x08af,
+	0x970: 0x08b7, 0x971: 0x08bb, 0x972: 0x08bb, 0x973: 0x08bb, 0x974: 0x166a, 0x975: 0x0e93,
+	0x976: 0x08cf, 0x977: 0x08d7, 0x978: 0x166f, 0x979: 0x08e3, 0x97a: 0x08eb, 0x97b: 0x08f3,
+	0x97c: 0x091b, 0x97d: 0x0907, 0x97e: 0x0913, 0x97f: 0x0917,
+	// Block 0x26, offset 0x980
+	0x980: 0x091f, 0x981: 0x0927, 0x982: 0x092b, 0x983: 0x0933, 0x984: 0x093b, 0x985: 0x093f,
+	0x986: 0x093f, 0x987: 0x0947, 0x988: 0x094f, 0x989: 0x0953, 0x98a: 0x095f, 0x98b: 0x0983,
+	0x98c: 0x0967, 0x98d: 0x0987, 0x98e: 0x096b, 0x98f: 0x0973, 0x990: 0x080b, 0x991: 0x09cf,
+	0x992: 0x0997, 0x993: 0x099b, 0x994: 0x099f, 0x995: 0x0993, 0x996: 0x09a7, 0x997: 0x09a3,
+	0x998: 0x09bb, 0x999: 0x1674, 0x99a: 0x09d7, 0x99b: 0x09db, 0x99c: 0x09e3, 0x99d: 0x09ef,
+	0x99e: 0x09f7, 0x99f: 0x0a13, 0x9a0: 0x1679, 0x9a1: 0x167e, 0x9a2: 0x0a1f, 0x9a3: 0x0a23,
+	0x9a4: 0x0a27, 0x9a5: 0x0a1b, 0x9a6: 0x0a2f, 0x9a7: 0x05c7, 0x9a8: 0x05cb, 0x9a9: 0x0a37,
+	0x9aa: 0x0a3f, 0x9ab: 0x0a3f, 0x9ac: 0x1683, 0x9ad: 0x0a5b, 0x9ae: 0x0a5f, 0x9af: 0x0a63,
+	0x9b0: 0x0a6b, 0x9b1: 0x1688, 0x9b2: 0x0a73, 0x9b3: 0x0a77, 0x9b4: 0x0b4f, 0x9b5: 0x0a7f,
+	0x9b6: 0x05cf, 0x9b7: 0x0a8b, 0x9b8: 0x0a9b, 0x9b9: 0x0aa7, 0x9ba: 0x0aa3, 0x9bb: 0x1692,
+	0x9bc: 0x0aaf, 0x9bd: 0x1697, 0x9be: 0x0abb, 0x9bf: 0x0ab7,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x0abf, 0x9c1: 0x0acf, 0x9c2: 0x0ad3, 0x9c3: 0x05d3, 0x9c4: 0x0ae3, 0x9c5: 0x0aeb,
+	0x9c6: 0x0aef, 0x9c7: 0x0af3, 0x9c8: 0x05d7, 0x9c9: 0x169c, 0x9ca: 0x05db, 0x9cb: 0x0b0f,
+	0x9cc: 0x0b13, 0x9cd: 0x0b17, 0x9ce: 0x0b1f, 0x9cf: 0x1863, 0x9d0: 0x0b37, 0x9d1: 0x16a6,
+	0x9d2: 0x16a6, 0x9d3: 0x11d7, 0x9d4: 0x0b47, 0x9d5: 0x0b47, 0x9d6: 0x05df, 0x9d7: 0x16c9,
+	0x9d8: 0x179b, 0x9d9: 0x0b57, 0x9da: 0x0b5f, 0x9db: 0x05e3, 0x9dc: 0x0b73, 0x9dd: 0x0b83,
+	0x9de: 0x0b87, 0x9df: 0x0b8f, 0x9e0: 0x0b9f, 0x9e1: 0x05eb, 0x9e2: 0x05e7, 0x9e3: 0x0ba3,
+	0x9e4: 0x16ab, 0x9e5: 0x0ba7, 0x9e6: 0x0bbb, 0x9e7: 0x0bbf, 0x9e8: 0x0bc3, 0x9e9: 0x0bbf,
+	0x9ea: 0x0bcf, 0x9eb: 0x0bd3, 0x9ec: 0x0be3, 0x9ed: 0x0bdb, 0x9ee: 0x0bdf, 0x9ef: 0x0be7,
+	0x9f0: 0x0beb, 0x9f1: 0x0bef, 0x9f2: 0x0bfb, 0x9f3: 0x0bff, 0x9f4: 0x0c17, 0x9f5: 0x0c1f,
+	0x9f6: 0x0c2f, 0x9f7: 0x0c43, 0x9f8: 0x16ba, 0x9f9: 0x0c3f, 0x9fa: 0x0c33, 0x9fb: 0x0c4b,
+	0x9fc: 0x0c53, 0x9fd: 0x0c67, 0x9fe: 0x16bf, 0x9ff: 0x0c6f,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0c63, 0xa01: 0x0c5b, 0xa02: 0x05ef, 0xa03: 0x0c77, 0xa04: 0x0c7f, 0xa05: 0x0c87,
+	0xa06: 0x0c7b, 0xa07: 0x05f3, 0xa08: 0x0c97, 0xa09: 0x0c9f, 0xa0a: 0x16c4, 0xa0b: 0x0ccb,
+	0xa0c: 0x0cff, 0xa0d: 0x0cdb, 0xa0e: 0x05ff, 0xa0f: 0x0ce7, 0xa10: 0x05fb, 0xa11: 0x05f7,
+	0xa12: 0x07c3, 0xa13: 0x07c7, 0xa14: 0x0d03, 0xa15: 0x0ceb, 0xa16: 0x11ab, 0xa17: 0x0663,
+	0xa18: 0x0d0f, 0xa19: 0x0d13, 0xa1a: 0x0d17, 0xa1b: 0x0d2b, 0xa1c: 0x0d23, 0xa1d: 0x16dd,
+	0xa1e: 0x0603, 0xa1f: 0x0d3f, 0xa20: 0x0d33, 0xa21: 0x0d4f, 0xa22: 0x0d57, 0xa23: 0x16e7,
+	0xa24: 0x0d5b, 0xa25: 0x0d47, 0xa26: 0x0d63, 0xa27: 0x0607, 0xa28: 0x0d67, 0xa29: 0x0d6b,
+	0xa2a: 0x0d6f, 0xa2b: 0x0d7b, 0xa2c: 0x16ec, 0xa2d: 0x0d83, 0xa2e: 0x060b, 0xa2f: 0x0d8f,
+	0xa30: 0x16f1, 0xa31: 0x0d93, 0xa32: 0x060f, 0xa33: 0x0d9f, 0xa34: 0x0dab, 0xa35: 0x0db7,
+	0xa36: 0x0dbb, 0xa37: 0x16f6, 0xa38: 0x168d, 0xa39: 0x16fb, 0xa3a: 0x0ddb, 0xa3b: 0x1700,
+	0xa3c: 0x0de7, 0xa3d: 0x0def, 0xa3e: 0x0ddf, 0xa3f: 0x0dfb,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x0e0b, 0xa41: 0x0e1b, 0xa42: 0x0e0f, 0xa43: 0x0e13, 0xa44: 0x0e1f, 0xa45: 0x0e23,
+	0xa46: 0x1705, 0xa47: 0x0e07, 0xa48: 0x0e3b, 0xa49: 0x0e3f, 0xa4a: 0x0613, 0xa4b: 0x0e53,
+	0xa4c: 0x0e4f, 0xa4d: 0x170a, 0xa4e: 0x0e33, 0xa4f: 0x0e6f, 0xa50: 0x170f, 0xa51: 0x1714,
+	0xa52: 0x0e73, 0xa53: 0x0e87, 0xa54: 0x0e83, 0xa55: 0x0e7f, 0xa56: 0x0617, 0xa57: 0x0e8b,
+	0xa58: 0x0e9b, 0xa59: 0x0e97, 0xa5a: 0x0ea3, 0xa5b: 0x1651, 0xa5c: 0x0eb3, 0xa5d: 0x1719,
+	0xa5e: 0x0ebf, 0xa5f: 0x1723, 0xa60: 0x0ed3, 0xa61: 0x0edf, 0xa62: 0x0ef3, 0xa63: 0x1728,
+	0xa64: 0x0f07, 0xa65: 0x0f0b, 0xa66: 0x172d, 0xa67: 0x1732, 0xa68: 0x0f27, 0xa69: 0x0f37,
+	0xa6a: 0x061b, 0xa6b: 0x0f3b, 0xa6c: 0x061f, 0xa6d: 0x061f, 0xa6e: 0x0f53, 0xa6f: 0x0f57,
+	0xa70: 0x0f5f, 0xa71: 0x0f63, 0xa72: 0x0f6f, 0xa73: 0x0623, 0xa74: 0x0f87, 0xa75: 0x1737,
+	0xa76: 0x0fa3, 0xa77: 0x173c, 0xa78: 0x0faf, 0xa79: 0x16a1, 0xa7a: 0x0fbf, 0xa7b: 0x1741,
+	0xa7c: 0x1746, 0xa7d: 0x174b, 0xa7e: 0x0627, 0xa7f: 0x062b,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x0ff7, 0xa81: 0x1755, 0xa82: 0x1750, 0xa83: 0x175a, 0xa84: 0x175f, 0xa85: 0x0fff,
+	0xa86: 0x1003, 0xa87: 0x1003, 0xa88: 0x100b, 0xa89: 0x0633, 0xa8a: 0x100f, 0xa8b: 0x0637,
+	0xa8c: 0x063b, 0xa8d: 0x1769, 0xa8e: 0x1023, 0xa8f: 0x102b, 0xa90: 0x1037, 0xa91: 0x063f,
+	0xa92: 0x176e, 0xa93: 0x105b, 0xa94: 0x1773, 0xa95: 0x1778, 0xa96: 0x107b, 0xa97: 0x1093,
+	0xa98: 0x0643, 0xa99: 0x109b, 0xa9a: 0x109f, 0xa9b: 0x10a3, 0xa9c: 0x177d, 0xa9d: 0x1782,
+	0xa9e: 0x1782, 0xa9f: 0x10bb, 0xaa0: 0x0647, 0xaa1: 0x1787, 0xaa2: 0x10cf, 0xaa3: 0x10d3,
+	0xaa4: 0x064b, 0xaa5: 0x178c, 0xaa6: 0x10ef, 0xaa7: 0x064f, 0xaa8: 0x10ff, 0xaa9: 0x10f7,
+	0xaaa: 0x1107, 0xaab: 0x1796, 0xaac: 0x111f, 0xaad: 0x0653, 0xaae: 0x112b, 0xaaf: 0x1133,
+	0xab0: 0x1143, 0xab1: 0x0657, 0xab2: 0x17a0, 0xab3: 0x17a5, 0xab4: 0x065b, 0xab5: 0x17aa,
+	0xab6: 0x115b, 0xab7: 0x17af, 0xab8: 0x1167, 0xab9: 0x1173, 0xaba: 0x117b, 0xabb: 0x17b4,
+	0xabc: 0x17b9, 0xabd: 0x118f, 0xabe: 0x17be, 0xabf: 0x1197,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x16ce, 0xac1: 0x065f, 0xac2: 0x11af, 0xac3: 0x11b3, 0xac4: 0x0667, 0xac5: 0x11b7,
+	0xac6: 0x0a33, 0xac7: 0x17c3, 0xac8: 0x17c8, 0xac9: 0x16d3, 0xaca: 0x16d8, 0xacb: 0x11d7,
+	0xacc: 0x11db, 0xacd: 0x13f3, 0xace: 0x066b, 0xacf: 0x1207, 0xad0: 0x1203, 0xad1: 0x120b,
+	0xad2: 0x083f, 0xad3: 0x120f, 0xad4: 0x1213, 0xad5: 0x1217, 0xad6: 0x121f, 0xad7: 0x17cd,
+	0xad8: 0x121b, 0xad9: 0x1223, 0xada: 0x1237, 0xadb: 0x123b, 0xadc: 0x1227, 0xadd: 0x123f,
+	0xade: 0x1253, 0xadf: 0x1267, 0xae0: 0x1233, 0xae1: 0x1247, 0xae2: 0x124b, 0xae3: 0x124f,
+	0xae4: 0x17d2, 0xae5: 0x17dc, 0xae6: 0x17d7, 0xae7: 0x066f, 0xae8: 0x126f, 0xae9: 0x1273,
+	0xaea: 0x127b, 0xaeb: 0x17f0, 0xaec: 0x127f, 0xaed: 0x17e1, 0xaee: 0x0673, 0xaef: 0x0677,
+	0xaf0: 0x17e6, 0xaf1: 0x17eb, 0xaf2: 0x067b, 0xaf3: 0x129f, 0xaf4: 0x12a3, 0xaf5: 0x12a7,
+	0xaf6: 0x12ab, 0xaf7: 0x12b7, 0xaf8: 0x12b3, 0xaf9: 0x12bf, 0xafa: 0x12bb, 0xafb: 0x12cb,
+	0xafc: 0x12c3, 0xafd: 0x12c7, 0xafe: 0x12cf, 0xaff: 0x067f,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x12d7, 0xb01: 0x12db, 0xb02: 0x0683, 0xb03: 0x12eb, 0xb04: 0x12ef, 0xb05: 0x17f5,
+	0xb06: 0x12fb, 0xb07: 0x12ff, 0xb08: 0x0687, 0xb09: 0x130b, 0xb0a: 0x05bb, 0xb0b: 0x17fa,
+	0xb0c: 0x17ff, 0xb0d: 0x068b, 0xb0e: 0x068f, 0xb0f: 0x1337, 0xb10: 0x134f, 0xb11: 0x136b,
+	0xb12: 0x137b, 0xb13: 0x1804, 0xb14: 0x138f, 0xb15: 0x1393, 0xb16: 0x13ab, 0xb17: 0x13b7,
+	0xb18: 0x180e, 0xb19: 0x1660, 0xb1a: 0x13c3, 0xb1b: 0x13bf, 0xb1c: 0x13cb, 0xb1d: 0x1665,
+	0xb1e: 0x13d7, 0xb1f: 0x13e3, 0xb20: 0x1813, 0xb21: 0x1818, 0xb22: 0x1423, 0xb23: 0x142f,
+	0xb24: 0x1437, 0xb25: 0x181d, 0xb26: 0x143b, 0xb27: 0x1467, 0xb28: 0x1473, 0xb29: 0x1477,
+	0xb2a: 0x146f, 0xb2b: 0x1483, 0xb2c: 0x1487, 0xb2d: 0x1822, 0xb2e: 0x1493, 0xb2f: 0x0693,
+	0xb30: 0x149b, 0xb31: 0x1827, 0xb32: 0x0697, 0xb33: 0x14d3, 0xb34: 0x0ac3, 0xb35: 0x14eb,
+	0xb36: 0x182c, 0xb37: 0x1836, 0xb38: 0x069b, 0xb39: 0x069f, 0xb3a: 0x1513, 0xb3b: 0x183b,
+	0xb3c: 0x06a3, 0xb3d: 0x1840, 0xb3e: 0x152b, 0xb3f: 0x152b,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x1533, 0xb41: 0x1845, 0xb42: 0x154b, 0xb43: 0x06a7, 0xb44: 0x155b, 0xb45: 0x1567,
+	0xb46: 0x156f, 0xb47: 0x1577, 0xb48: 0x06ab, 0xb49: 0x184a, 0xb4a: 0x158b, 0xb4b: 0x15a7,
+	0xb4c: 0x15b3, 0xb4d: 0x06af, 0xb4e: 0x06b3, 0xb4f: 0x15b7, 0xb50: 0x184f, 0xb51: 0x06b7,
+	0xb52: 0x1854, 0xb53: 0x1859, 0xb54: 0x185e, 0xb55: 0x15db, 0xb56: 0x06bb, 0xb57: 0x15ef,
+	0xb58: 0x15f7, 0xb59: 0x15fb, 0xb5a: 0x1603, 0xb5b: 0x160b, 0xb5c: 0x1613, 0xb5d: 0x1868,
+}
+
+// nfcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x2c, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x2d, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x2e, 0xcb: 0x2f, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x30,
+	0xd0: 0x09, 0xd1: 0x31, 0xd2: 0x32, 0xd3: 0x0a, 0xd6: 0x0b, 0xd7: 0x33,
+	0xd8: 0x34, 0xd9: 0x0c, 0xdb: 0x35, 0xdc: 0x36, 0xdd: 0x37, 0xdf: 0x38,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x39, 0x121: 0x3a, 0x123: 0x3b, 0x124: 0x3c, 0x125: 0x3d, 0x126: 0x3e, 0x127: 0x3f,
+	0x128: 0x40, 0x129: 0x41, 0x12a: 0x42, 0x12b: 0x43, 0x12c: 0x3e, 0x12d: 0x44, 0x12e: 0x45, 0x12f: 0x46,
+	0x131: 0x47, 0x132: 0x48, 0x133: 0x49, 0x134: 0x4a, 0x135: 0x4b, 0x137: 0x4c,
+	0x138: 0x4d, 0x139: 0x4e, 0x13a: 0x4f, 0x13b: 0x50, 0x13c: 0x51, 0x13d: 0x52, 0x13e: 0x53, 0x13f: 0x54,
+	// Block 0x5, offset 0x140
+	0x140: 0x55, 0x142: 0x56, 0x144: 0x57, 0x145: 0x58, 0x146: 0x59, 0x147: 0x5a,
+	0x14d: 0x5b,
+	0x15c: 0x5c, 0x15f: 0x5d,
+	0x162: 0x5e, 0x164: 0x5f,
+	0x168: 0x60, 0x169: 0x61, 0x16a: 0x62, 0x16c: 0x0d, 0x16d: 0x63, 0x16e: 0x64, 0x16f: 0x65,
+	0x170: 0x66, 0x173: 0x67, 0x177: 0x68,
+	0x178: 0x0e, 0x179: 0x0f, 0x17a: 0x10, 0x17b: 0x11, 0x17c: 0x12, 0x17d: 0x13, 0x17e: 0x14, 0x17f: 0x15,
+	// Block 0x6, offset 0x180
+	0x180: 0x69, 0x183: 0x6a, 0x184: 0x6b, 0x186: 0x6c, 0x187: 0x6d,
+	0x188: 0x6e, 0x189: 0x16, 0x18a: 0x17, 0x18b: 0x6f, 0x18c: 0x70,
+	0x1ab: 0x71,
+	0x1b3: 0x72, 0x1b5: 0x73, 0x1b7: 0x74,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x75, 0x1c1: 0x18, 0x1c2: 0x19, 0x1c3: 0x1a, 0x1c4: 0x76, 0x1c5: 0x77,
+	0x1c9: 0x78, 0x1cc: 0x79, 0x1cd: 0x7a,
+	// Block 0x8, offset 0x200
+	0x219: 0x7b, 0x21a: 0x7c, 0x21b: 0x7d,
+	0x220: 0x7e, 0x223: 0x7f, 0x224: 0x80, 0x225: 0x81, 0x226: 0x82, 0x227: 0x83,
+	0x22a: 0x84, 0x22b: 0x85, 0x22f: 0x86,
+	0x230: 0x87, 0x231: 0x88, 0x232: 0x89, 0x233: 0x8a, 0x234: 0x8b, 0x235: 0x8c, 0x236: 0x8d, 0x237: 0x87,
+	0x238: 0x88, 0x239: 0x89, 0x23a: 0x8a, 0x23b: 0x8b, 0x23c: 0x8c, 0x23d: 0x8d, 0x23e: 0x87, 0x23f: 0x88,
+	// Block 0x9, offset 0x240
+	0x240: 0x89, 0x241: 0x8a, 0x242: 0x8b, 0x243: 0x8c, 0x244: 0x8d, 0x245: 0x87, 0x246: 0x88, 0x247: 0x89,
+	0x248: 0x8a, 0x249: 0x8b, 0x24a: 0x8c, 0x24b: 0x8d, 0x24c: 0x87, 0x24d: 0x88, 0x24e: 0x89, 0x24f: 0x8a,
+	0x250: 0x8b, 0x251: 0x8c, 0x252: 0x8d, 0x253: 0x87, 0x254: 0x88, 0x255: 0x89, 0x256: 0x8a, 0x257: 0x8b,
+	0x258: 0x8c, 0x259: 0x8d, 0x25a: 0x87, 0x25b: 0x88, 0x25c: 0x89, 0x25d: 0x8a, 0x25e: 0x8b, 0x25f: 0x8c,
+	0x260: 0x8d, 0x261: 0x87, 0x262: 0x88, 0x263: 0x89, 0x264: 0x8a, 0x265: 0x8b, 0x266: 0x8c, 0x267: 0x8d,
+	0x268: 0x87, 0x269: 0x88, 0x26a: 0x89, 0x26b: 0x8a, 0x26c: 0x8b, 0x26d: 0x8c, 0x26e: 0x8d, 0x26f: 0x87,
+	0x270: 0x88, 0x271: 0x89, 0x272: 0x8a, 0x273: 0x8b, 0x274: 0x8c, 0x275: 0x8d, 0x276: 0x87, 0x277: 0x88,
+	0x278: 0x89, 0x279: 0x8a, 0x27a: 0x8b, 0x27b: 0x8c, 0x27c: 0x8d, 0x27d: 0x87, 0x27e: 0x88, 0x27f: 0x89,
+	// Block 0xa, offset 0x280
+	0x280: 0x8a, 0x281: 0x8b, 0x282: 0x8c, 0x283: 0x8d, 0x284: 0x87, 0x285: 0x88, 0x286: 0x89, 0x287: 0x8a,
+	0x288: 0x8b, 0x289: 0x8c, 0x28a: 0x8d, 0x28b: 0x87, 0x28c: 0x88, 0x28d: 0x89, 0x28e: 0x8a, 0x28f: 0x8b,
+	0x290: 0x8c, 0x291: 0x8d, 0x292: 0x87, 0x293: 0x88, 0x294: 0x89, 0x295: 0x8a, 0x296: 0x8b, 0x297: 0x8c,
+	0x298: 0x8d, 0x299: 0x87, 0x29a: 0x88, 0x29b: 0x89, 0x29c: 0x8a, 0x29d: 0x8b, 0x29e: 0x8c, 0x29f: 0x8d,
+	0x2a0: 0x87, 0x2a1: 0x88, 0x2a2: 0x89, 0x2a3: 0x8a, 0x2a4: 0x8b, 0x2a5: 0x8c, 0x2a6: 0x8d, 0x2a7: 0x87,
+	0x2a8: 0x88, 0x2a9: 0x89, 0x2aa: 0x8a, 0x2ab: 0x8b, 0x2ac: 0x8c, 0x2ad: 0x8d, 0x2ae: 0x87, 0x2af: 0x88,
+	0x2b0: 0x89, 0x2b1: 0x8a, 0x2b2: 0x8b, 0x2b3: 0x8c, 0x2b4: 0x8d, 0x2b5: 0x87, 0x2b6: 0x88, 0x2b7: 0x89,
+	0x2b8: 0x8a, 0x2b9: 0x8b, 0x2ba: 0x8c, 0x2bb: 0x8d, 0x2bc: 0x87, 0x2bd: 0x88, 0x2be: 0x89, 0x2bf: 0x8a,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x8b, 0x2c1: 0x8c, 0x2c2: 0x8d, 0x2c3: 0x87, 0x2c4: 0x88, 0x2c5: 0x89, 0x2c6: 0x8a, 0x2c7: 0x8b,
+	0x2c8: 0x8c, 0x2c9: 0x8d, 0x2ca: 0x87, 0x2cb: 0x88, 0x2cc: 0x89, 0x2cd: 0x8a, 0x2ce: 0x8b, 0x2cf: 0x8c,
+	0x2d0: 0x8d, 0x2d1: 0x87, 0x2d2: 0x88, 0x2d3: 0x89, 0x2d4: 0x8a, 0x2d5: 0x8b, 0x2d6: 0x8c, 0x2d7: 0x8d,
+	0x2d8: 0x87, 0x2d9: 0x88, 0x2da: 0x89, 0x2db: 0x8a, 0x2dc: 0x8b, 0x2dd: 0x8c, 0x2de: 0x8e,
+	// Block 0xc, offset 0x300
+	0x324: 0x1b, 0x325: 0x1c, 0x326: 0x1d, 0x327: 0x1e,
+	0x328: 0x1f, 0x329: 0x20, 0x32a: 0x21, 0x32b: 0x22, 0x32c: 0x8f, 0x32d: 0x90, 0x32e: 0x91,
+	0x331: 0x92, 0x332: 0x93, 0x333: 0x94, 0x334: 0x95,
+	0x338: 0x96, 0x339: 0x97, 0x33a: 0x98, 0x33b: 0x99, 0x33e: 0x9a, 0x33f: 0x9b,
+	// Block 0xd, offset 0x340
+	0x347: 0x9c,
+	0x34b: 0x9d, 0x34d: 0x9e,
+	0x368: 0x9f, 0x36b: 0xa0,
+	// Block 0xe, offset 0x380
+	0x381: 0xa1, 0x382: 0xa2, 0x384: 0xa3, 0x385: 0x82, 0x387: 0xa4,
+	0x388: 0xa5, 0x38b: 0xa6, 0x38c: 0x3e, 0x38d: 0xa7,
+	0x391: 0xa8, 0x392: 0xa9, 0x393: 0xaa, 0x396: 0xab, 0x397: 0xac,
+	0x398: 0x73, 0x39a: 0xad, 0x39c: 0xae,
+	0x3b0: 0x73,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xaf, 0x3ec: 0xb0,
+	// Block 0x10, offset 0x400
+	0x432: 0xb1,
+	// Block 0x11, offset 0x440
+	0x445: 0xb2, 0x446: 0xb3, 0x447: 0xb4,
+	0x449: 0xb5,
+	// Block 0x12, offset 0x480
+	0x480: 0xb6,
+	0x4a3: 0xb7, 0x4a5: 0xb8,
+	// Block 0x13, offset 0x4c0
+	0x4c8: 0xb9,
+	// Block 0x14, offset 0x500
+	0x520: 0x23, 0x521: 0x24, 0x522: 0x25, 0x523: 0x26, 0x524: 0x27, 0x525: 0x28, 0x526: 0x29, 0x527: 0x2a,
+	0x528: 0x2b,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfcSparseOffset: 142 entries, 284 bytes
+var nfcSparseOffset = []uint16{0x0, 0x5, 0x9, 0xb, 0xd, 0x18, 0x28, 0x2a, 0x2f, 0x3a, 0x49, 0x56, 0x5e, 0x62, 0x67, 0x69, 0x7a, 0x82, 0x89, 0x8c, 0x93, 0x97, 0x9b, 0x9d, 0x9f, 0xa8, 0xac, 0xb3, 0xb8, 0xbb, 0xc5, 0xc7, 0xce, 0xd6, 0xd9, 0xdb, 0xdd, 0xdf, 0xe4, 0xf5, 0x101, 0x103, 0x109, 0x10b, 0x10d, 0x10f, 0x111, 0x113, 0x115, 0x118, 0x11b, 0x11d, 0x120, 0x123, 0x127, 0x12c, 0x135, 0x137, 0x13a, 0x13c, 0x147, 0x157, 0x15b, 0x169, 0x16c, 0x172, 0x178, 0x183, 0x187, 0x189, 0x18b, 0x18d, 0x18f, 0x191, 0x197, 0x19b, 0x19d, 0x19f, 0x1a7, 0x1ab, 0x1ae, 0x1b0, 0x1b2, 0x1b4, 0x1b7, 0x1b9, 0x1bb, 0x1bd, 0x1bf, 0x1c5, 0x1c8, 0x1ca, 0x1d1, 0x1d7, 0x1dd, 0x1e5, 0x1eb, 0x1f1, 0x1f7, 0x1fb, 0x209, 0x212, 0x215, 0x218, 0x21a, 0x21d, 0x21f, 0x223, 0x228, 0x22a, 0x22c, 0x231, 0x237, 0x239, 0x23b, 0x23d, 0x243, 0x246, 0x249, 0x251, 0x258, 0x25b, 0x25e, 0x260, 0x268, 0x26b, 0x272, 0x275, 0x27b, 0x27d, 0x280, 0x282, 0x284, 0x286, 0x288, 0x295, 0x29f, 0x2a1, 0x2a3, 0x2a9, 0x2ab, 0x2ae}
+
+// nfcSparseValues: 688 entries, 2752 bytes
+var nfcSparseValues = [688]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0000, lo: 0x04},
+	{value: 0xa100, lo: 0xa8, hi: 0xa8},
+	{value: 0x8100, lo: 0xaf, hi: 0xaf},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb8, hi: 0xb8},
+	// Block 0x1, offset 0x5
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x9
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	// Block 0x3, offset 0xb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x98, hi: 0x9d},
+	// Block 0x4, offset 0xd
+	{value: 0x0006, lo: 0x0a},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x85, hi: 0x85},
+	{value: 0xa000, lo: 0x89, hi: 0x89},
+	{value: 0x4840, lo: 0x8a, hi: 0x8a},
+	{value: 0x485e, lo: 0x8b, hi: 0x8b},
+	{value: 0x36c7, lo: 0x8c, hi: 0x8c},
+	{value: 0x36df, lo: 0x8d, hi: 0x8d},
+	{value: 0x4876, lo: 0x8e, hi: 0x8e},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x36fd, lo: 0x93, hi: 0x94},
+	// Block 0x5, offset 0x18
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x6, offset 0x28
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x7, offset 0x2a
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x8, offset 0x2f
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x9, offset 0x3a
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0xa, offset 0x49
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xb, offset 0x56
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xc, offset 0x5e
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xd, offset 0x62
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xe, offset 0x67
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xf, offset 0x69
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0x10, offset 0x7a
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x11, offset 0x82
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x12, offset 0x89
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x13, offset 0x8c
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x14, offset 0x93
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x15, offset 0x97
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x16, offset 0x9b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x17, offset 0x9d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x18, offset 0x9f
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x19, offset 0xa8
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1a, offset 0xac
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1b, offset 0xb3
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1c, offset 0xb8
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1d, offset 0xbb
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1e, offset 0xc5
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1f, offset 0xc7
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x20, offset 0xce
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x21, offset 0xd6
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x22, offset 0xd9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x23, offset 0xdb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x24, offset 0xdd
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	// Block 0x25, offset 0xdf
+	{value: 0x0000, lo: 0x04},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x26, offset 0xe4
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x8200, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x8200, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x27, offset 0xf5
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x28, offset 0x101
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x29, offset 0x103
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x2a, offset 0x109
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2b, offset 0x10b
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x10d
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x10f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x111
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x113
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x115
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x118
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x11b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x11d
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x120
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x123
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x127
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x12c
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x135
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x137
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x13a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x13c
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x147
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x8132, lo: 0x80, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x82},
+	{value: 0x8132, lo: 0x83, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8a},
+	{value: 0x8132, lo: 0x8b, hi: 0x8c},
+	{value: 0x8135, lo: 0x8d, hi: 0x8d},
+	{value: 0x812a, lo: 0x8e, hi: 0x8e},
+	{value: 0x812d, lo: 0x8f, hi: 0x8f},
+	{value: 0x8129, lo: 0x90, hi: 0x90},
+	{value: 0x8132, lo: 0x91, hi: 0xb5},
+	{value: 0x8132, lo: 0xbb, hi: 0xbb},
+	{value: 0x8134, lo: 0xbc, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	{value: 0x8132, lo: 0xbe, hi: 0xbe},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x3d, offset 0x157
+	{value: 0x0004, lo: 0x03},
+	{value: 0x0433, lo: 0x80, hi: 0x81},
+	{value: 0x8100, lo: 0x97, hi: 0x97},
+	{value: 0x8100, lo: 0xbe, hi: 0xbe},
+	// Block 0x3e, offset 0x15b
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x3f, offset 0x169
+	{value: 0x427b, lo: 0x02},
+	{value: 0x01b8, lo: 0xa6, hi: 0xa6},
+	{value: 0x0057, lo: 0xaa, hi: 0xab},
+	// Block 0x40, offset 0x16c
+	{value: 0x0007, lo: 0x05},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x41, offset 0x172
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x42, offset 0x178
+	{value: 0x6408, lo: 0x0a},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x43, offset 0x183
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x44, offset 0x187
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x45, offset 0x189
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x46, offset 0x18b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x47, offset 0x18d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x48, offset 0x18f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x49, offset 0x191
+	{value: 0x0000, lo: 0x05},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xaf},
+	// Block 0x4a, offset 0x197
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4a9f, lo: 0xb3, hi: 0xb3},
+	{value: 0x4a9f, lo: 0xb5, hi: 0xb6},
+	{value: 0x4a9f, lo: 0xba, hi: 0xbf},
+	// Block 0x4b, offset 0x19b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x4a9f, lo: 0x8f, hi: 0xa3},
+	// Block 0x4c, offset 0x19d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xae, hi: 0xbe},
+	// Block 0x4d, offset 0x19f
+	{value: 0x0000, lo: 0x07},
+	{value: 0x8100, lo: 0x84, hi: 0x84},
+	{value: 0x8100, lo: 0x87, hi: 0x87},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	{value: 0x8100, lo: 0x9e, hi: 0x9e},
+	{value: 0x8100, lo: 0xa1, hi: 0xa1},
+	{value: 0x8100, lo: 0xb2, hi: 0xb2},
+	{value: 0x8100, lo: 0xbb, hi: 0xbb},
+	// Block 0x4e, offset 0x1a7
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8100, lo: 0x80, hi: 0x80},
+	{value: 0x8100, lo: 0x8b, hi: 0x8b},
+	{value: 0x8100, lo: 0x8e, hi: 0x8e},
+	// Block 0x4f, offset 0x1ab
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x50, offset 0x1ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x51, offset 0x1b0
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x52, offset 0x1b2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x53, offset 0x1b4
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x54, offset 0x1b7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x55, offset 0x1b9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x56, offset 0x1bb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x57, offset 0x1bd
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x58, offset 0x1bf
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x59, offset 0x1c5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x5a, offset 0x1c8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x5b, offset 0x1ca
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x5c, offset 0x1d1
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x5d, offset 0x1d7
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x5e, offset 0x1dd
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x5f, offset 0x1e5
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x60, offset 0x1eb
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x61, offset 0x1f1
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x62, offset 0x1f7
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x63, offset 0x1fb
+	{value: 0x0006, lo: 0x0d},
+	{value: 0x4390, lo: 0x9d, hi: 0x9d},
+	{value: 0x8115, lo: 0x9e, hi: 0x9e},
+	{value: 0x4402, lo: 0x9f, hi: 0x9f},
+	{value: 0x43f0, lo: 0xaa, hi: 0xab},
+	{value: 0x44f4, lo: 0xac, hi: 0xac},
+	{value: 0x44fc, lo: 0xad, hi: 0xad},
+	{value: 0x4348, lo: 0xae, hi: 0xb1},
+	{value: 0x4366, lo: 0xb2, hi: 0xb4},
+	{value: 0x437e, lo: 0xb5, hi: 0xb6},
+	{value: 0x438a, lo: 0xb8, hi: 0xb8},
+	{value: 0x4396, lo: 0xb9, hi: 0xbb},
+	{value: 0x43ae, lo: 0xbc, hi: 0xbc},
+	{value: 0x43b4, lo: 0xbe, hi: 0xbe},
+	// Block 0x64, offset 0x209
+	{value: 0x0006, lo: 0x08},
+	{value: 0x43ba, lo: 0x80, hi: 0x81},
+	{value: 0x43c6, lo: 0x83, hi: 0x84},
+	{value: 0x43d8, lo: 0x86, hi: 0x89},
+	{value: 0x43fc, lo: 0x8a, hi: 0x8a},
+	{value: 0x4378, lo: 0x8b, hi: 0x8b},
+	{value: 0x4360, lo: 0x8c, hi: 0x8c},
+	{value: 0x43a8, lo: 0x8d, hi: 0x8d},
+	{value: 0x43d2, lo: 0x8e, hi: 0x8e},
+	// Block 0x65, offset 0x212
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0xa4, hi: 0xa5},
+	{value: 0x8100, lo: 0xb0, hi: 0xb1},
+	// Block 0x66, offset 0x215
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x9b, hi: 0x9d},
+	{value: 0x8200, lo: 0x9e, hi: 0xa3},
+	// Block 0x67, offset 0x218
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	// Block 0x68, offset 0x21a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x99, hi: 0x99},
+	{value: 0x8200, lo: 0xb2, hi: 0xb4},
+	// Block 0x69, offset 0x21d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xbc, hi: 0xbd},
+	// Block 0x6a, offset 0x21f
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xa0, hi: 0xa6},
+	{value: 0x812d, lo: 0xa7, hi: 0xad},
+	{value: 0x8132, lo: 0xae, hi: 0xaf},
+	// Block 0x6b, offset 0x223
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8100, lo: 0x89, hi: 0x8c},
+	{value: 0x8100, lo: 0xb0, hi: 0xb2},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb6, hi: 0xbf},
+	// Block 0x6c, offset 0x228
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x81, hi: 0x8c},
+	// Block 0x6d, offset 0x22a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xb5, hi: 0xba},
+	// Block 0x6e, offset 0x22c
+	{value: 0x0000, lo: 0x04},
+	{value: 0x4a9f, lo: 0x9e, hi: 0x9f},
+	{value: 0x4a9f, lo: 0xa3, hi: 0xa3},
+	{value: 0x4a9f, lo: 0xa5, hi: 0xa6},
+	{value: 0x4a9f, lo: 0xaa, hi: 0xaf},
+	// Block 0x6f, offset 0x231
+	{value: 0x0000, lo: 0x05},
+	{value: 0x4a9f, lo: 0x82, hi: 0x87},
+	{value: 0x4a9f, lo: 0x8a, hi: 0x8f},
+	{value: 0x4a9f, lo: 0x92, hi: 0x97},
+	{value: 0x4a9f, lo: 0x9a, hi: 0x9c},
+	{value: 0x8100, lo: 0xa3, hi: 0xa3},
+	// Block 0x70, offset 0x237
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x71, offset 0x239
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x72, offset 0x23b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x73, offset 0x23d
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x74, offset 0x243
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x75, offset 0x246
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x76, offset 0x249
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x77, offset 0x251
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x78, offset 0x258
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x79, offset 0x25b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x7a, offset 0x25e
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x7b, offset 0x260
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x7c, offset 0x268
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x7d, offset 0x26b
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x7e, offset 0x272
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7f, offset 0x275
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x80, offset 0x27b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x81, offset 0x27d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x82, offset 0x280
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x83, offset 0x282
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x84, offset 0x284
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x85, offset 0x286
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x86, offset 0x288
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x87, offset 0x295
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x88, offset 0x29f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x89, offset 0x2a1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x8a, offset 0x2a3
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x8b, offset 0x2a9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x8c, offset 0x2ab
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x8d, offset 0x2ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x93, hi: 0x93},
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfkcTrie. Total size: 16994 bytes (16.60 KiB). Checksum: c3ed54ee046f3c46.
+type nfkcTrie struct{}
+
+func newNfkcTrie(i int) *nfkcTrie {
+	return &nfkcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfkcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 90:
+		return uint16(nfkcValues[n<<6+uint32(b)])
+	default:
+		n -= 90
+		return uint16(nfkcSparse.lookup(n, b))
+	}
+}
+
+// nfkcValues: 92 blocks, 5888 entries, 11776 bytes
+// The third block is the zero block.
+var nfkcValues = [5888]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x132: 0x195d, 0x133: 0x19e7, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8, 0x13f: 0x1bac,
+	// Block 0x5, offset 0x140
+	0x140: 0x1c34, 0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f, 0x149: 0x1c5c,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0x00a7,
+	// Block 0x6, offset 0x180
+	0x184: 0x2dee, 0x185: 0x2df4,
+	0x186: 0x2dfa, 0x187: 0x1972, 0x188: 0x1975, 0x189: 0x1a08, 0x18a: 0x1987, 0x18b: 0x198a,
+	0x18c: 0x1a3e, 0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b1: 0x1942, 0x1b2: 0x1945, 0x1b3: 0x19cf, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x42a5,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x425a, 0x285: 0x447b,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c1: 0xa000, 0x2c5: 0xa000,
+	0x2c9: 0xa000, 0x2ca: 0x4840, 0x2cb: 0x485e,
+	0x2cc: 0x36c7, 0x2cd: 0x36df, 0x2ce: 0x4876, 0x2d0: 0x01be, 0x2d1: 0x01d0,
+	0x2d2: 0x01ac, 0x2d3: 0x430c, 0x2d4: 0x4312, 0x2d5: 0x01fa, 0x2d6: 0x01e8,
+	0x2f0: 0x01d6, 0x2f1: 0x01eb, 0x2f2: 0x01ee, 0x2f4: 0x0188, 0x2f5: 0x01c7,
+	0x2f9: 0x01a6,
+	// Block 0xc, offset 0x300
+	0x300: 0x3721, 0x301: 0x372d, 0x303: 0x371b,
+	0x306: 0xa000, 0x307: 0x3709,
+	0x30c: 0x375d, 0x30d: 0x3745, 0x30e: 0x376f, 0x310: 0xa000,
+	0x313: 0xa000, 0x315: 0xa000, 0x316: 0xa000, 0x317: 0xa000,
+	0x318: 0xa000, 0x319: 0x3751, 0x31a: 0xa000,
+	0x31e: 0xa000, 0x323: 0xa000,
+	0x327: 0xa000,
+	0x32b: 0xa000, 0x32d: 0xa000,
+	0x330: 0xa000, 0x333: 0xa000, 0x335: 0xa000,
+	0x336: 0xa000, 0x337: 0xa000, 0x338: 0xa000, 0x339: 0x37d5, 0x33a: 0xa000,
+	0x33e: 0xa000,
+	// Block 0xd, offset 0x340
+	0x341: 0x3733, 0x342: 0x37b7,
+	0x350: 0x370f, 0x351: 0x3793,
+	0x352: 0x3715, 0x353: 0x3799, 0x356: 0x3727, 0x357: 0x37ab,
+	0x358: 0xa000, 0x359: 0xa000, 0x35a: 0x3829, 0x35b: 0x382f, 0x35c: 0x3739, 0x35d: 0x37bd,
+	0x35e: 0x373f, 0x35f: 0x37c3, 0x362: 0x374b, 0x363: 0x37cf,
+	0x364: 0x3757, 0x365: 0x37db, 0x366: 0x3763, 0x367: 0x37e7, 0x368: 0xa000, 0x369: 0xa000,
+	0x36a: 0x3835, 0x36b: 0x383b, 0x36c: 0x378d, 0x36d: 0x3811, 0x36e: 0x3769, 0x36f: 0x37ed,
+	0x370: 0x3775, 0x371: 0x37f9, 0x372: 0x377b, 0x373: 0x37ff, 0x374: 0x3781, 0x375: 0x3805,
+	0x378: 0x3787, 0x379: 0x380b,
+	// Block 0xe, offset 0x380
+	0x387: 0x1d61,
+	0x391: 0x812d,
+	0x392: 0x8132, 0x393: 0x8132, 0x394: 0x8132, 0x395: 0x8132, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x812e, 0x39b: 0x812d, 0x39c: 0x8132, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x8132, 0x3a0: 0x8132, 0x3a1: 0x8132, 0x3a2: 0x812d, 0x3a3: 0x812d,
+	0x3a4: 0x812d, 0x3a5: 0x812d, 0x3a6: 0x812d, 0x3a7: 0x812d, 0x3a8: 0x8132, 0x3a9: 0x8132,
+	0x3aa: 0x812d, 0x3ab: 0x8132, 0x3ac: 0x8132, 0x3ad: 0x812e, 0x3ae: 0x8131, 0x3af: 0x8132,
+	0x3b0: 0x8105, 0x3b1: 0x8106, 0x3b2: 0x8107, 0x3b3: 0x8108, 0x3b4: 0x8109, 0x3b5: 0x810a,
+	0x3b6: 0x810b, 0x3b7: 0x810c, 0x3b8: 0x810d, 0x3b9: 0x810e, 0x3ba: 0x810e, 0x3bb: 0x810f,
+	0x3bc: 0x8110, 0x3bd: 0x8111, 0x3bf: 0x8112,
+	// Block 0xf, offset 0x3c0
+	0x3c8: 0xa000, 0x3ca: 0xa000, 0x3cb: 0x8116,
+	0x3cc: 0x8117, 0x3cd: 0x8118, 0x3ce: 0x8119, 0x3cf: 0x811a, 0x3d0: 0x811b, 0x3d1: 0x811c,
+	0x3d2: 0x811d, 0x3d3: 0x9932, 0x3d4: 0x9932, 0x3d5: 0x992d, 0x3d6: 0x812d, 0x3d7: 0x8132,
+	0x3d8: 0x8132, 0x3d9: 0x8132, 0x3da: 0x8132, 0x3db: 0x8132, 0x3dc: 0x812d, 0x3dd: 0x8132,
+	0x3de: 0x8132, 0x3df: 0x812d,
+	0x3f0: 0x811e, 0x3f5: 0x1d84,
+	0x3f6: 0x2013, 0x3f7: 0x204f, 0x3f8: 0x204a,
+	// Block 0x10, offset 0x400
+	0x405: 0xa000,
+	0x406: 0x2d26, 0x407: 0xa000, 0x408: 0x2d2e, 0x409: 0xa000, 0x40a: 0x2d36, 0x40b: 0xa000,
+	0x40c: 0x2d3e, 0x40d: 0xa000, 0x40e: 0x2d46, 0x411: 0xa000,
+	0x412: 0x2d4e,
+	0x434: 0x8102, 0x435: 0x9900,
+	0x43a: 0xa000, 0x43b: 0x2d56,
+	0x43c: 0xa000, 0x43d: 0x2d5e, 0x43e: 0xa000, 0x43f: 0xa000,
+	// Block 0x11, offset 0x440
+	0x440: 0x0069, 0x441: 0x006b, 0x442: 0x006f, 0x443: 0x0083, 0x444: 0x00f5, 0x445: 0x00f8,
+	0x446: 0x0413, 0x447: 0x0085, 0x448: 0x0089, 0x449: 0x008b, 0x44a: 0x0104, 0x44b: 0x0107,
+	0x44c: 0x010a, 0x44d: 0x008f, 0x44f: 0x0097, 0x450: 0x009b, 0x451: 0x00e0,
+	0x452: 0x009f, 0x453: 0x00fe, 0x454: 0x0417, 0x455: 0x041b, 0x456: 0x00a1, 0x457: 0x00a9,
+	0x458: 0x00ab, 0x459: 0x0423, 0x45a: 0x012b, 0x45b: 0x00ad, 0x45c: 0x0427, 0x45d: 0x01be,
+	0x45e: 0x01c1, 0x45f: 0x01c4, 0x460: 0x01fa, 0x461: 0x01fd, 0x462: 0x0093, 0x463: 0x00a5,
+	0x464: 0x00ab, 0x465: 0x00ad, 0x466: 0x01be, 0x467: 0x01c1, 0x468: 0x01eb, 0x469: 0x01fa,
+	0x46a: 0x01fd,
+	0x478: 0x020c,
+	// Block 0x12, offset 0x480
+	0x49b: 0x00fb, 0x49c: 0x0087, 0x49d: 0x0101,
+	0x49e: 0x00d4, 0x49f: 0x010a, 0x4a0: 0x008d, 0x4a1: 0x010d, 0x4a2: 0x0110, 0x4a3: 0x0116,
+	0x4a4: 0x011c, 0x4a5: 0x011f, 0x4a6: 0x0122, 0x4a7: 0x042b, 0x4a8: 0x016a, 0x4a9: 0x0128,
+	0x4aa: 0x042f, 0x4ab: 0x016d, 0x4ac: 0x0131, 0x4ad: 0x012e, 0x4ae: 0x0134, 0x4af: 0x0137,
+	0x4b0: 0x013a, 0x4b1: 0x013d, 0x4b2: 0x0140, 0x4b3: 0x014c, 0x4b4: 0x014f, 0x4b5: 0x00ec,
+	0x4b6: 0x0152, 0x4b7: 0x0155, 0x4b8: 0x041f, 0x4b9: 0x0158, 0x4ba: 0x015b, 0x4bb: 0x00b5,
+	0x4bc: 0x015e, 0x4bd: 0x0161, 0x4be: 0x0164, 0x4bf: 0x01d0,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x2f97, 0x4c1: 0x32a3, 0x4c2: 0x2fa1, 0x4c3: 0x32ad, 0x4c4: 0x2fa6, 0x4c5: 0x32b2,
+	0x4c6: 0x2fab, 0x4c7: 0x32b7, 0x4c8: 0x38cc, 0x4c9: 0x3a5b, 0x4ca: 0x2fc4, 0x4cb: 0x32d0,
+	0x4cc: 0x2fce, 0x4cd: 0x32da, 0x4ce: 0x2fdd, 0x4cf: 0x32e9, 0x4d0: 0x2fd3, 0x4d1: 0x32df,
+	0x4d2: 0x2fd8, 0x4d3: 0x32e4, 0x4d4: 0x38ef, 0x4d5: 0x3a7e, 0x4d6: 0x38f6, 0x4d7: 0x3a85,
+	0x4d8: 0x3019, 0x4d9: 0x3325, 0x4da: 0x301e, 0x4db: 0x332a, 0x4dc: 0x3904, 0x4dd: 0x3a93,
+	0x4de: 0x3023, 0x4df: 0x332f, 0x4e0: 0x3032, 0x4e1: 0x333e, 0x4e2: 0x3050, 0x4e3: 0x335c,
+	0x4e4: 0x305f, 0x4e5: 0x336b, 0x4e6: 0x3055, 0x4e7: 0x3361, 0x4e8: 0x3064, 0x4e9: 0x3370,
+	0x4ea: 0x3069, 0x4eb: 0x3375, 0x4ec: 0x30af, 0x4ed: 0x33bb, 0x4ee: 0x390b, 0x4ef: 0x3a9a,
+	0x4f0: 0x30b9, 0x4f1: 0x33ca, 0x4f2: 0x30c3, 0x4f3: 0x33d4, 0x4f4: 0x30cd, 0x4f5: 0x33de,
+	0x4f6: 0x46c4, 0x4f7: 0x4755, 0x4f8: 0x3912, 0x4f9: 0x3aa1, 0x4fa: 0x30e6, 0x4fb: 0x33f7,
+	0x4fc: 0x30e1, 0x4fd: 0x33f2, 0x4fe: 0x30eb, 0x4ff: 0x33fc,
+	// Block 0x14, offset 0x500
+	0x500: 0x30f0, 0x501: 0x3401, 0x502: 0x30f5, 0x503: 0x3406, 0x504: 0x3109, 0x505: 0x341a,
+	0x506: 0x3113, 0x507: 0x3424, 0x508: 0x3122, 0x509: 0x3433, 0x50a: 0x311d, 0x50b: 0x342e,
+	0x50c: 0x3935, 0x50d: 0x3ac4, 0x50e: 0x3943, 0x50f: 0x3ad2, 0x510: 0x394a, 0x511: 0x3ad9,
+	0x512: 0x3951, 0x513: 0x3ae0, 0x514: 0x314f, 0x515: 0x3460, 0x516: 0x3154, 0x517: 0x3465,
+	0x518: 0x315e, 0x519: 0x346f, 0x51a: 0x46f1, 0x51b: 0x4782, 0x51c: 0x3997, 0x51d: 0x3b26,
+	0x51e: 0x3177, 0x51f: 0x3488, 0x520: 0x3181, 0x521: 0x3492, 0x522: 0x4700, 0x523: 0x4791,
+	0x524: 0x399e, 0x525: 0x3b2d, 0x526: 0x39a5, 0x527: 0x3b34, 0x528: 0x39ac, 0x529: 0x3b3b,
+	0x52a: 0x3190, 0x52b: 0x34a1, 0x52c: 0x319a, 0x52d: 0x34b0, 0x52e: 0x31ae, 0x52f: 0x34c4,
+	0x530: 0x31a9, 0x531: 0x34bf, 0x532: 0x31ea, 0x533: 0x3500, 0x534: 0x31f9, 0x535: 0x350f,
+	0x536: 0x31f4, 0x537: 0x350a, 0x538: 0x39b3, 0x539: 0x3b42, 0x53a: 0x39ba, 0x53b: 0x3b49,
+	0x53c: 0x31fe, 0x53d: 0x3514, 0x53e: 0x3203, 0x53f: 0x3519,
+	// Block 0x15, offset 0x540
+	0x540: 0x3208, 0x541: 0x351e, 0x542: 0x320d, 0x543: 0x3523, 0x544: 0x321c, 0x545: 0x3532,
+	0x546: 0x3217, 0x547: 0x352d, 0x548: 0x3221, 0x549: 0x353c, 0x54a: 0x3226, 0x54b: 0x3541,
+	0x54c: 0x322b, 0x54d: 0x3546, 0x54e: 0x3249, 0x54f: 0x3564, 0x550: 0x3262, 0x551: 0x3582,
+	0x552: 0x3271, 0x553: 0x3591, 0x554: 0x3276, 0x555: 0x3596, 0x556: 0x337a, 0x557: 0x34a6,
+	0x558: 0x3537, 0x559: 0x3573, 0x55a: 0x1be0, 0x55b: 0x42d7,
+	0x560: 0x46a1, 0x561: 0x4732, 0x562: 0x2f83, 0x563: 0x328f,
+	0x564: 0x3878, 0x565: 0x3a07, 0x566: 0x3871, 0x567: 0x3a00, 0x568: 0x3886, 0x569: 0x3a15,
+	0x56a: 0x387f, 0x56b: 0x3a0e, 0x56c: 0x38be, 0x56d: 0x3a4d, 0x56e: 0x3894, 0x56f: 0x3a23,
+	0x570: 0x388d, 0x571: 0x3a1c, 0x572: 0x38a2, 0x573: 0x3a31, 0x574: 0x389b, 0x575: 0x3a2a,
+	0x576: 0x38c5, 0x577: 0x3a54, 0x578: 0x46b5, 0x579: 0x4746, 0x57a: 0x3000, 0x57b: 0x330c,
+	0x57c: 0x2fec, 0x57d: 0x32f8, 0x57e: 0x38da, 0x57f: 0x3a69,
+	// Block 0x16, offset 0x580
+	0x580: 0x38d3, 0x581: 0x3a62, 0x582: 0x38e8, 0x583: 0x3a77, 0x584: 0x38e1, 0x585: 0x3a70,
+	0x586: 0x38fd, 0x587: 0x3a8c, 0x588: 0x3091, 0x589: 0x339d, 0x58a: 0x30a5, 0x58b: 0x33b1,
+	0x58c: 0x46e7, 0x58d: 0x4778, 0x58e: 0x3136, 0x58f: 0x3447, 0x590: 0x3920, 0x591: 0x3aaf,
+	0x592: 0x3919, 0x593: 0x3aa8, 0x594: 0x392e, 0x595: 0x3abd, 0x596: 0x3927, 0x597: 0x3ab6,
+	0x598: 0x3989, 0x599: 0x3b18, 0x59a: 0x396d, 0x59b: 0x3afc, 0x59c: 0x3966, 0x59d: 0x3af5,
+	0x59e: 0x397b, 0x59f: 0x3b0a, 0x5a0: 0x3974, 0x5a1: 0x3b03, 0x5a2: 0x3982, 0x5a3: 0x3b11,
+	0x5a4: 0x31e5, 0x5a5: 0x34fb, 0x5a6: 0x31c7, 0x5a7: 0x34dd, 0x5a8: 0x39e4, 0x5a9: 0x3b73,
+	0x5aa: 0x39dd, 0x5ab: 0x3b6c, 0x5ac: 0x39f2, 0x5ad: 0x3b81, 0x5ae: 0x39eb, 0x5af: 0x3b7a,
+	0x5b0: 0x39f9, 0x5b1: 0x3b88, 0x5b2: 0x3230, 0x5b3: 0x354b, 0x5b4: 0x3258, 0x5b5: 0x3578,
+	0x5b6: 0x3253, 0x5b7: 0x356e, 0x5b8: 0x323f, 0x5b9: 0x355a,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x4804, 0x5c1: 0x480a, 0x5c2: 0x491e, 0x5c3: 0x4936, 0x5c4: 0x4926, 0x5c5: 0x493e,
+	0x5c6: 0x492e, 0x5c7: 0x4946, 0x5c8: 0x47aa, 0x5c9: 0x47b0, 0x5ca: 0x488e, 0x5cb: 0x48a6,
+	0x5cc: 0x4896, 0x5cd: 0x48ae, 0x5ce: 0x489e, 0x5cf: 0x48b6, 0x5d0: 0x4816, 0x5d1: 0x481c,
+	0x5d2: 0x3db8, 0x5d3: 0x3dc8, 0x5d4: 0x3dc0, 0x5d5: 0x3dd0,
+	0x5d8: 0x47b6, 0x5d9: 0x47bc, 0x5da: 0x3ce8, 0x5db: 0x3cf8, 0x5dc: 0x3cf0, 0x5dd: 0x3d00,
+	0x5e0: 0x482e, 0x5e1: 0x4834, 0x5e2: 0x494e, 0x5e3: 0x4966,
+	0x5e4: 0x4956, 0x5e5: 0x496e, 0x5e6: 0x495e, 0x5e7: 0x4976, 0x5e8: 0x47c2, 0x5e9: 0x47c8,
+	0x5ea: 0x48be, 0x5eb: 0x48d6, 0x5ec: 0x48c6, 0x5ed: 0x48de, 0x5ee: 0x48ce, 0x5ef: 0x48e6,
+	0x5f0: 0x4846, 0x5f1: 0x484c, 0x5f2: 0x3e18, 0x5f3: 0x3e30, 0x5f4: 0x3e20, 0x5f5: 0x3e38,
+	0x5f6: 0x3e28, 0x5f7: 0x3e40, 0x5f8: 0x47ce, 0x5f9: 0x47d4, 0x5fa: 0x3d18, 0x5fb: 0x3d30,
+	0x5fc: 0x3d20, 0x5fd: 0x3d38, 0x5fe: 0x3d28, 0x5ff: 0x3d40,
+	// Block 0x18, offset 0x600
+	0x600: 0x4852, 0x601: 0x4858, 0x602: 0x3e48, 0x603: 0x3e58, 0x604: 0x3e50, 0x605: 0x3e60,
+	0x608: 0x47da, 0x609: 0x47e0, 0x60a: 0x3d48, 0x60b: 0x3d58,
+	0x60c: 0x3d50, 0x60d: 0x3d60, 0x610: 0x4864, 0x611: 0x486a,
+	0x612: 0x3e80, 0x613: 0x3e98, 0x614: 0x3e88, 0x615: 0x3ea0, 0x616: 0x3e90, 0x617: 0x3ea8,
+	0x619: 0x47e6, 0x61b: 0x3d68, 0x61d: 0x3d70,
+	0x61f: 0x3d78, 0x620: 0x487c, 0x621: 0x4882, 0x622: 0x497e, 0x623: 0x4996,
+	0x624: 0x4986, 0x625: 0x499e, 0x626: 0x498e, 0x627: 0x49a6, 0x628: 0x47ec, 0x629: 0x47f2,
+	0x62a: 0x48ee, 0x62b: 0x4906, 0x62c: 0x48f6, 0x62d: 0x490e, 0x62e: 0x48fe, 0x62f: 0x4916,
+	0x630: 0x47f8, 0x631: 0x431e, 0x632: 0x3691, 0x633: 0x4324, 0x634: 0x4822, 0x635: 0x432a,
+	0x636: 0x36a3, 0x637: 0x4330, 0x638: 0x36c1, 0x639: 0x4336, 0x63a: 0x36d9, 0x63b: 0x433c,
+	0x63c: 0x4870, 0x63d: 0x4342,
+	// Block 0x19, offset 0x640
+	0x640: 0x3da0, 0x641: 0x3da8, 0x642: 0x4184, 0x643: 0x41a2, 0x644: 0x418e, 0x645: 0x41ac,
+	0x646: 0x4198, 0x647: 0x41b6, 0x648: 0x3cd8, 0x649: 0x3ce0, 0x64a: 0x40d0, 0x64b: 0x40ee,
+	0x64c: 0x40da, 0x64d: 0x40f8, 0x64e: 0x40e4, 0x64f: 0x4102, 0x650: 0x3de8, 0x651: 0x3df0,
+	0x652: 0x41c0, 0x653: 0x41de, 0x654: 0x41ca, 0x655: 0x41e8, 0x656: 0x41d4, 0x657: 0x41f2,
+	0x658: 0x3d08, 0x659: 0x3d10, 0x65a: 0x410c, 0x65b: 0x412a, 0x65c: 0x4116, 0x65d: 0x4134,
+	0x65e: 0x4120, 0x65f: 0x413e, 0x660: 0x3ec0, 0x661: 0x3ec8, 0x662: 0x41fc, 0x663: 0x421a,
+	0x664: 0x4206, 0x665: 0x4224, 0x666: 0x4210, 0x667: 0x422e, 0x668: 0x3d80, 0x669: 0x3d88,
+	0x66a: 0x4148, 0x66b: 0x4166, 0x66c: 0x4152, 0x66d: 0x4170, 0x66e: 0x415c, 0x66f: 0x417a,
+	0x670: 0x3685, 0x671: 0x367f, 0x672: 0x3d90, 0x673: 0x368b, 0x674: 0x3d98,
+	0x676: 0x4810, 0x677: 0x3db0, 0x678: 0x35f5, 0x679: 0x35ef, 0x67a: 0x35e3, 0x67b: 0x42ee,
+	0x67c: 0x35fb, 0x67d: 0x4287, 0x67e: 0x01d3, 0x67f: 0x4287,
+	// Block 0x1a, offset 0x680
+	0x680: 0x42a0, 0x681: 0x4482, 0x682: 0x3dd8, 0x683: 0x369d, 0x684: 0x3de0,
+	0x686: 0x483a, 0x687: 0x3df8, 0x688: 0x3601, 0x689: 0x42f4, 0x68a: 0x360d, 0x68b: 0x42fa,
+	0x68c: 0x3619, 0x68d: 0x4489, 0x68e: 0x4490, 0x68f: 0x4497, 0x690: 0x36b5, 0x691: 0x36af,
+	0x692: 0x3e00, 0x693: 0x44e4, 0x696: 0x36bb, 0x697: 0x3e10,
+	0x698: 0x3631, 0x699: 0x362b, 0x69a: 0x361f, 0x69b: 0x4300, 0x69d: 0x449e,
+	0x69e: 0x44a5, 0x69f: 0x44ac, 0x6a0: 0x36eb, 0x6a1: 0x36e5, 0x6a2: 0x3e68, 0x6a3: 0x44ec,
+	0x6a4: 0x36cd, 0x6a5: 0x36d3, 0x6a6: 0x36f1, 0x6a7: 0x3e78, 0x6a8: 0x3661, 0x6a9: 0x365b,
+	0x6aa: 0x364f, 0x6ab: 0x430c, 0x6ac: 0x3649, 0x6ad: 0x4474, 0x6ae: 0x447b, 0x6af: 0x0081,
+	0x6b2: 0x3eb0, 0x6b3: 0x36f7, 0x6b4: 0x3eb8,
+	0x6b6: 0x4888, 0x6b7: 0x3ed0, 0x6b8: 0x363d, 0x6b9: 0x4306, 0x6ba: 0x366d, 0x6bb: 0x4318,
+	0x6bc: 0x3679, 0x6bd: 0x425a, 0x6be: 0x428c,
+	// Block 0x1b, offset 0x6c0
+	0x6c0: 0x1bd8, 0x6c1: 0x1bdc, 0x6c2: 0x0047, 0x6c3: 0x1c54, 0x6c5: 0x1be8,
+	0x6c6: 0x1bec, 0x6c7: 0x00e9, 0x6c9: 0x1c58, 0x6ca: 0x008f, 0x6cb: 0x0051,
+	0x6cc: 0x0051, 0x6cd: 0x0051, 0x6ce: 0x0091, 0x6cf: 0x00da, 0x6d0: 0x0053, 0x6d1: 0x0053,
+	0x6d2: 0x0059, 0x6d3: 0x0099, 0x6d5: 0x005d, 0x6d6: 0x198d,
+	0x6d9: 0x0061, 0x6da: 0x0063, 0x6db: 0x0065, 0x6dc: 0x0065, 0x6dd: 0x0065,
+	0x6e0: 0x199f, 0x6e1: 0x1bc8, 0x6e2: 0x19a8,
+	0x6e4: 0x0075, 0x6e6: 0x01b8, 0x6e8: 0x0075,
+	0x6ea: 0x0057, 0x6eb: 0x42d2, 0x6ec: 0x0045, 0x6ed: 0x0047, 0x6ef: 0x008b,
+	0x6f0: 0x004b, 0x6f1: 0x004d, 0x6f3: 0x005b, 0x6f4: 0x009f, 0x6f5: 0x0215,
+	0x6f6: 0x0218, 0x6f7: 0x021b, 0x6f8: 0x021e, 0x6f9: 0x0093, 0x6fb: 0x1b98,
+	0x6fc: 0x01e8, 0x6fd: 0x01c1, 0x6fe: 0x0179, 0x6ff: 0x01a0,
+	// Block 0x1c, offset 0x700
+	0x700: 0x0463, 0x705: 0x0049,
+	0x706: 0x0089, 0x707: 0x008b, 0x708: 0x0093, 0x709: 0x0095,
+	0x710: 0x222e, 0x711: 0x223a,
+	0x712: 0x22ee, 0x713: 0x2216, 0x714: 0x229a, 0x715: 0x2222, 0x716: 0x22a0, 0x717: 0x22b8,
+	0x718: 0x22c4, 0x719: 0x2228, 0x71a: 0x22ca, 0x71b: 0x2234, 0x71c: 0x22be, 0x71d: 0x22d0,
+	0x71e: 0x22d6, 0x71f: 0x1cbc, 0x720: 0x0053, 0x721: 0x195a, 0x722: 0x1ba4, 0x723: 0x1963,
+	0x724: 0x006d, 0x725: 0x19ab, 0x726: 0x1bd0, 0x727: 0x1d48, 0x728: 0x1966, 0x729: 0x0071,
+	0x72a: 0x19b7, 0x72b: 0x1bd4, 0x72c: 0x0059, 0x72d: 0x0047, 0x72e: 0x0049, 0x72f: 0x005b,
+	0x730: 0x0093, 0x731: 0x19e4, 0x732: 0x1c18, 0x733: 0x19ed, 0x734: 0x00ad, 0x735: 0x1a62,
+	0x736: 0x1c4c, 0x737: 0x1d5c, 0x738: 0x19f0, 0x739: 0x00b1, 0x73a: 0x1a65, 0x73b: 0x1c50,
+	0x73c: 0x0099, 0x73d: 0x0087, 0x73e: 0x0089, 0x73f: 0x009b,
+	// Block 0x1d, offset 0x740
+	0x741: 0x3c06, 0x743: 0xa000, 0x744: 0x3c0d, 0x745: 0xa000,
+	0x747: 0x3c14, 0x748: 0xa000, 0x749: 0x3c1b,
+	0x74d: 0xa000,
+	0x760: 0x2f65, 0x761: 0xa000, 0x762: 0x3c29,
+	0x764: 0xa000, 0x765: 0xa000,
+	0x76d: 0x3c22, 0x76e: 0x2f60, 0x76f: 0x2f6a,
+	0x770: 0x3c30, 0x771: 0x3c37, 0x772: 0xa000, 0x773: 0xa000, 0x774: 0x3c3e, 0x775: 0x3c45,
+	0x776: 0xa000, 0x777: 0xa000, 0x778: 0x3c4c, 0x779: 0x3c53, 0x77a: 0xa000, 0x77b: 0xa000,
+	0x77c: 0xa000, 0x77d: 0xa000,
+	// Block 0x1e, offset 0x780
+	0x780: 0x3c5a, 0x781: 0x3c61, 0x782: 0xa000, 0x783: 0xa000, 0x784: 0x3c76, 0x785: 0x3c7d,
+	0x786: 0xa000, 0x787: 0xa000, 0x788: 0x3c84, 0x789: 0x3c8b,
+	0x791: 0xa000,
+	0x792: 0xa000,
+	0x7a2: 0xa000,
+	0x7a8: 0xa000, 0x7a9: 0xa000,
+	0x7ab: 0xa000, 0x7ac: 0x3ca0, 0x7ad: 0x3ca7, 0x7ae: 0x3cae, 0x7af: 0x3cb5,
+	0x7b2: 0xa000, 0x7b3: 0xa000, 0x7b4: 0xa000, 0x7b5: 0xa000,
+	// Block 0x1f, offset 0x7c0
+	0x7e0: 0x0023, 0x7e1: 0x0025, 0x7e2: 0x0027, 0x7e3: 0x0029,
+	0x7e4: 0x002b, 0x7e5: 0x002d, 0x7e6: 0x002f, 0x7e7: 0x0031, 0x7e8: 0x0033, 0x7e9: 0x1882,
+	0x7ea: 0x1885, 0x7eb: 0x1888, 0x7ec: 0x188b, 0x7ed: 0x188e, 0x7ee: 0x1891, 0x7ef: 0x1894,
+	0x7f0: 0x1897, 0x7f1: 0x189a, 0x7f2: 0x189d, 0x7f3: 0x18a6, 0x7f4: 0x1a68, 0x7f5: 0x1a6c,
+	0x7f6: 0x1a70, 0x7f7: 0x1a74, 0x7f8: 0x1a78, 0x7f9: 0x1a7c, 0x7fa: 0x1a80, 0x7fb: 0x1a84,
+	0x7fc: 0x1a88, 0x7fd: 0x1c80, 0x7fe: 0x1c85, 0x7ff: 0x1c8a,
+	// Block 0x20, offset 0x800
+	0x800: 0x1c8f, 0x801: 0x1c94, 0x802: 0x1c99, 0x803: 0x1c9e, 0x804: 0x1ca3, 0x805: 0x1ca8,
+	0x806: 0x1cad, 0x807: 0x1cb2, 0x808: 0x187f, 0x809: 0x18a3, 0x80a: 0x18c7, 0x80b: 0x18eb,
+	0x80c: 0x190f, 0x80d: 0x1918, 0x80e: 0x191e, 0x80f: 0x1924, 0x810: 0x192a, 0x811: 0x1b60,
+	0x812: 0x1b64, 0x813: 0x1b68, 0x814: 0x1b6c, 0x815: 0x1b70, 0x816: 0x1b74, 0x817: 0x1b78,
+	0x818: 0x1b7c, 0x819: 0x1b80, 0x81a: 0x1b84, 0x81b: 0x1b88, 0x81c: 0x1af4, 0x81d: 0x1af8,
+	0x81e: 0x1afc, 0x81f: 0x1b00, 0x820: 0x1b04, 0x821: 0x1b08, 0x822: 0x1b0c, 0x823: 0x1b10,
+	0x824: 0x1b14, 0x825: 0x1b18, 0x826: 0x1b1c, 0x827: 0x1b20, 0x828: 0x1b24, 0x829: 0x1b28,
+	0x82a: 0x1b2c, 0x82b: 0x1b30, 0x82c: 0x1b34, 0x82d: 0x1b38, 0x82e: 0x1b3c, 0x82f: 0x1b40,
+	0x830: 0x1b44, 0x831: 0x1b48, 0x832: 0x1b4c, 0x833: 0x1b50, 0x834: 0x1b54, 0x835: 0x1b58,
+	0x836: 0x0043, 0x837: 0x0045, 0x838: 0x0047, 0x839: 0x0049, 0x83a: 0x004b, 0x83b: 0x004d,
+	0x83c: 0x004f, 0x83d: 0x0051, 0x83e: 0x0053, 0x83f: 0x0055,
+	// Block 0x21, offset 0x840
+	0x840: 0x06bf, 0x841: 0x06e3, 0x842: 0x06ef, 0x843: 0x06ff, 0x844: 0x0707, 0x845: 0x0713,
+	0x846: 0x071b, 0x847: 0x0723, 0x848: 0x072f, 0x849: 0x0783, 0x84a: 0x079b, 0x84b: 0x07ab,
+	0x84c: 0x07bb, 0x84d: 0x07cb, 0x84e: 0x07db, 0x84f: 0x07fb, 0x850: 0x07ff, 0x851: 0x0803,
+	0x852: 0x0837, 0x853: 0x085f, 0x854: 0x086f, 0x855: 0x0877, 0x856: 0x087b, 0x857: 0x0887,
+	0x858: 0x08a3, 0x859: 0x08a7, 0x85a: 0x08bf, 0x85b: 0x08c3, 0x85c: 0x08cb, 0x85d: 0x08db,
+	0x85e: 0x0977, 0x85f: 0x098b, 0x860: 0x09cb, 0x861: 0x09df, 0x862: 0x09e7, 0x863: 0x09eb,
+	0x864: 0x09fb, 0x865: 0x0a17, 0x866: 0x0a43, 0x867: 0x0a4f, 0x868: 0x0a6f, 0x869: 0x0a7b,
+	0x86a: 0x0a7f, 0x86b: 0x0a83, 0x86c: 0x0a9b, 0x86d: 0x0a9f, 0x86e: 0x0acb, 0x86f: 0x0ad7,
+	0x870: 0x0adf, 0x871: 0x0ae7, 0x872: 0x0af7, 0x873: 0x0aff, 0x874: 0x0b07, 0x875: 0x0b33,
+	0x876: 0x0b37, 0x877: 0x0b3f, 0x878: 0x0b43, 0x879: 0x0b4b, 0x87a: 0x0b53, 0x87b: 0x0b63,
+	0x87c: 0x0b7f, 0x87d: 0x0bf7, 0x87e: 0x0c0b, 0x87f: 0x0c0f,
+	// Block 0x22, offset 0x880
+	0x880: 0x0c8f, 0x881: 0x0c93, 0x882: 0x0ca7, 0x883: 0x0cab, 0x884: 0x0cb3, 0x885: 0x0cbb,
+	0x886: 0x0cc3, 0x887: 0x0ccf, 0x888: 0x0cf7, 0x889: 0x0d07, 0x88a: 0x0d1b, 0x88b: 0x0d8b,
+	0x88c: 0x0d97, 0x88d: 0x0da7, 0x88e: 0x0db3, 0x88f: 0x0dbf, 0x890: 0x0dc7, 0x891: 0x0dcb,
+	0x892: 0x0dcf, 0x893: 0x0dd3, 0x894: 0x0dd7, 0x895: 0x0e8f, 0x896: 0x0ed7, 0x897: 0x0ee3,
+	0x898: 0x0ee7, 0x899: 0x0eeb, 0x89a: 0x0eef, 0x89b: 0x0ef7, 0x89c: 0x0efb, 0x89d: 0x0f0f,
+	0x89e: 0x0f2b, 0x89f: 0x0f33, 0x8a0: 0x0f73, 0x8a1: 0x0f77, 0x8a2: 0x0f7f, 0x8a3: 0x0f83,
+	0x8a4: 0x0f8b, 0x8a5: 0x0f8f, 0x8a6: 0x0fb3, 0x8a7: 0x0fb7, 0x8a8: 0x0fd3, 0x8a9: 0x0fd7,
+	0x8aa: 0x0fdb, 0x8ab: 0x0fdf, 0x8ac: 0x0ff3, 0x8ad: 0x1017, 0x8ae: 0x101b, 0x8af: 0x101f,
+	0x8b0: 0x1043, 0x8b1: 0x1083, 0x8b2: 0x1087, 0x8b3: 0x10a7, 0x8b4: 0x10b7, 0x8b5: 0x10bf,
+	0x8b6: 0x10df, 0x8b7: 0x1103, 0x8b8: 0x1147, 0x8b9: 0x114f, 0x8ba: 0x1163, 0x8bb: 0x116f,
+	0x8bc: 0x1177, 0x8bd: 0x117f, 0x8be: 0x1183, 0x8bf: 0x1187,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x119f, 0x8c1: 0x11a3, 0x8c2: 0x11bf, 0x8c3: 0x11c7, 0x8c4: 0x11cf, 0x8c5: 0x11d3,
+	0x8c6: 0x11df, 0x8c7: 0x11e7, 0x8c8: 0x11eb, 0x8c9: 0x11ef, 0x8ca: 0x11f7, 0x8cb: 0x11fb,
+	0x8cc: 0x129b, 0x8cd: 0x12af, 0x8ce: 0x12e3, 0x8cf: 0x12e7, 0x8d0: 0x12ef, 0x8d1: 0x131b,
+	0x8d2: 0x1323, 0x8d3: 0x132b, 0x8d4: 0x1333, 0x8d5: 0x136f, 0x8d6: 0x1373, 0x8d7: 0x137b,
+	0x8d8: 0x137f, 0x8d9: 0x1383, 0x8da: 0x13af, 0x8db: 0x13b3, 0x8dc: 0x13bb, 0x8dd: 0x13cf,
+	0x8de: 0x13d3, 0x8df: 0x13ef, 0x8e0: 0x13f7, 0x8e1: 0x13fb, 0x8e2: 0x141f, 0x8e3: 0x143f,
+	0x8e4: 0x1453, 0x8e5: 0x1457, 0x8e6: 0x145f, 0x8e7: 0x148b, 0x8e8: 0x148f, 0x8e9: 0x149f,
+	0x8ea: 0x14c3, 0x8eb: 0x14cf, 0x8ec: 0x14df, 0x8ed: 0x14f7, 0x8ee: 0x14ff, 0x8ef: 0x1503,
+	0x8f0: 0x1507, 0x8f1: 0x150b, 0x8f2: 0x1517, 0x8f3: 0x151b, 0x8f4: 0x1523, 0x8f5: 0x153f,
+	0x8f6: 0x1543, 0x8f7: 0x1547, 0x8f8: 0x155f, 0x8f9: 0x1563, 0x8fa: 0x156b, 0x8fb: 0x157f,
+	0x8fc: 0x1583, 0x8fd: 0x1587, 0x8fe: 0x158f, 0x8ff: 0x1593,
+	// Block 0x24, offset 0x900
+	0x906: 0xa000, 0x90b: 0xa000,
+	0x90c: 0x3f08, 0x90d: 0xa000, 0x90e: 0x3f10, 0x90f: 0xa000, 0x910: 0x3f18, 0x911: 0xa000,
+	0x912: 0x3f20, 0x913: 0xa000, 0x914: 0x3f28, 0x915: 0xa000, 0x916: 0x3f30, 0x917: 0xa000,
+	0x918: 0x3f38, 0x919: 0xa000, 0x91a: 0x3f40, 0x91b: 0xa000, 0x91c: 0x3f48, 0x91d: 0xa000,
+	0x91e: 0x3f50, 0x91f: 0xa000, 0x920: 0x3f58, 0x921: 0xa000, 0x922: 0x3f60,
+	0x924: 0xa000, 0x925: 0x3f68, 0x926: 0xa000, 0x927: 0x3f70, 0x928: 0xa000, 0x929: 0x3f78,
+	0x92f: 0xa000,
+	0x930: 0x3f80, 0x931: 0x3f88, 0x932: 0xa000, 0x933: 0x3f90, 0x934: 0x3f98, 0x935: 0xa000,
+	0x936: 0x3fa0, 0x937: 0x3fa8, 0x938: 0xa000, 0x939: 0x3fb0, 0x93a: 0x3fb8, 0x93b: 0xa000,
+	0x93c: 0x3fc0, 0x93d: 0x3fc8,
+	// Block 0x25, offset 0x940
+	0x954: 0x3f00,
+	0x959: 0x9903, 0x95a: 0x9903, 0x95b: 0x42dc, 0x95c: 0x42e2, 0x95d: 0xa000,
+	0x95e: 0x3fd0, 0x95f: 0x26b4,
+	0x966: 0xa000,
+	0x96b: 0xa000, 0x96c: 0x3fe0, 0x96d: 0xa000, 0x96e: 0x3fe8, 0x96f: 0xa000,
+	0x970: 0x3ff0, 0x971: 0xa000, 0x972: 0x3ff8, 0x973: 0xa000, 0x974: 0x4000, 0x975: 0xa000,
+	0x976: 0x4008, 0x977: 0xa000, 0x978: 0x4010, 0x979: 0xa000, 0x97a: 0x4018, 0x97b: 0xa000,
+	0x97c: 0x4020, 0x97d: 0xa000, 0x97e: 0x4028, 0x97f: 0xa000,
+	// Block 0x26, offset 0x980
+	0x980: 0x4030, 0x981: 0xa000, 0x982: 0x4038, 0x984: 0xa000, 0x985: 0x4040,
+	0x986: 0xa000, 0x987: 0x4048, 0x988: 0xa000, 0x989: 0x4050,
+	0x98f: 0xa000, 0x990: 0x4058, 0x991: 0x4060,
+	0x992: 0xa000, 0x993: 0x4068, 0x994: 0x4070, 0x995: 0xa000, 0x996: 0x4078, 0x997: 0x4080,
+	0x998: 0xa000, 0x999: 0x4088, 0x99a: 0x4090, 0x99b: 0xa000, 0x99c: 0x4098, 0x99d: 0x40a0,
+	0x9af: 0xa000,
+	0x9b0: 0xa000, 0x9b1: 0xa000, 0x9b2: 0xa000, 0x9b4: 0x3fd8,
+	0x9b7: 0x40a8, 0x9b8: 0x40b0, 0x9b9: 0x40b8, 0x9ba: 0x40c0,
+	0x9bd: 0xa000, 0x9be: 0x40c8, 0x9bf: 0x26c9,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x0367, 0x9c1: 0x032b, 0x9c2: 0x032f, 0x9c3: 0x0333, 0x9c4: 0x037b, 0x9c5: 0x0337,
+	0x9c6: 0x033b, 0x9c7: 0x033f, 0x9c8: 0x0343, 0x9c9: 0x0347, 0x9ca: 0x034b, 0x9cb: 0x034f,
+	0x9cc: 0x0353, 0x9cd: 0x0357, 0x9ce: 0x035b, 0x9cf: 0x49bd, 0x9d0: 0x49c3, 0x9d1: 0x49c9,
+	0x9d2: 0x49cf, 0x9d3: 0x49d5, 0x9d4: 0x49db, 0x9d5: 0x49e1, 0x9d6: 0x49e7, 0x9d7: 0x49ed,
+	0x9d8: 0x49f3, 0x9d9: 0x49f9, 0x9da: 0x49ff, 0x9db: 0x4a05, 0x9dc: 0x4a0b, 0x9dd: 0x4a11,
+	0x9de: 0x4a17, 0x9df: 0x4a1d, 0x9e0: 0x4a23, 0x9e1: 0x4a29, 0x9e2: 0x4a2f, 0x9e3: 0x4a35,
+	0x9e4: 0x03c3, 0x9e5: 0x035f, 0x9e6: 0x0363, 0x9e7: 0x03e7, 0x9e8: 0x03eb, 0x9e9: 0x03ef,
+	0x9ea: 0x03f3, 0x9eb: 0x03f7, 0x9ec: 0x03fb, 0x9ed: 0x03ff, 0x9ee: 0x036b, 0x9ef: 0x0403,
+	0x9f0: 0x0407, 0x9f1: 0x036f, 0x9f2: 0x0373, 0x9f3: 0x0377, 0x9f4: 0x037f, 0x9f5: 0x0383,
+	0x9f6: 0x0387, 0x9f7: 0x038b, 0x9f8: 0x038f, 0x9f9: 0x0393, 0x9fa: 0x0397, 0x9fb: 0x039b,
+	0x9fc: 0x039f, 0x9fd: 0x03a3, 0x9fe: 0x03a7, 0x9ff: 0x03ab,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x03af, 0xa01: 0x03b3, 0xa02: 0x040b, 0xa03: 0x040f, 0xa04: 0x03b7, 0xa05: 0x03bb,
+	0xa06: 0x03bf, 0xa07: 0x03c7, 0xa08: 0x03cb, 0xa09: 0x03cf, 0xa0a: 0x03d3, 0xa0b: 0x03d7,
+	0xa0c: 0x03db, 0xa0d: 0x03df, 0xa0e: 0x03e3,
+	0xa12: 0x06bf, 0xa13: 0x071b, 0xa14: 0x06cb, 0xa15: 0x097b, 0xa16: 0x06cf, 0xa17: 0x06e7,
+	0xa18: 0x06d3, 0xa19: 0x0f93, 0xa1a: 0x0707, 0xa1b: 0x06db, 0xa1c: 0x06c3, 0xa1d: 0x09ff,
+	0xa1e: 0x098f, 0xa1f: 0x072f,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x2054, 0xa41: 0x205a, 0xa42: 0x2060, 0xa43: 0x2066, 0xa44: 0x206c, 0xa45: 0x2072,
+	0xa46: 0x2078, 0xa47: 0x207e, 0xa48: 0x2084, 0xa49: 0x208a, 0xa4a: 0x2090, 0xa4b: 0x2096,
+	0xa4c: 0x209c, 0xa4d: 0x20a2, 0xa4e: 0x2726, 0xa4f: 0x272f, 0xa50: 0x2738, 0xa51: 0x2741,
+	0xa52: 0x274a, 0xa53: 0x2753, 0xa54: 0x275c, 0xa55: 0x2765, 0xa56: 0x276e, 0xa57: 0x2780,
+	0xa58: 0x2789, 0xa59: 0x2792, 0xa5a: 0x279b, 0xa5b: 0x27a4, 0xa5c: 0x2777, 0xa5d: 0x2bac,
+	0xa5e: 0x2aed, 0xa60: 0x20a8, 0xa61: 0x20c0, 0xa62: 0x20b4, 0xa63: 0x2108,
+	0xa64: 0x20c6, 0xa65: 0x20e4, 0xa66: 0x20ae, 0xa67: 0x20de, 0xa68: 0x20ba, 0xa69: 0x20f0,
+	0xa6a: 0x2120, 0xa6b: 0x213e, 0xa6c: 0x2138, 0xa6d: 0x212c, 0xa6e: 0x217a, 0xa6f: 0x210e,
+	0xa70: 0x211a, 0xa71: 0x2132, 0xa72: 0x2126, 0xa73: 0x2150, 0xa74: 0x20fc, 0xa75: 0x2144,
+	0xa76: 0x216e, 0xa77: 0x2156, 0xa78: 0x20ea, 0xa79: 0x20cc, 0xa7a: 0x2102, 0xa7b: 0x2114,
+	0xa7c: 0x214a, 0xa7d: 0x20d2, 0xa7e: 0x2174, 0xa7f: 0x20f6,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x215c, 0xa81: 0x20d8, 0xa82: 0x2162, 0xa83: 0x2168, 0xa84: 0x092f, 0xa85: 0x0b03,
+	0xa86: 0x0ca7, 0xa87: 0x10c7,
+	0xa90: 0x1bc4, 0xa91: 0x18a9,
+	0xa92: 0x18ac, 0xa93: 0x18af, 0xa94: 0x18b2, 0xa95: 0x18b5, 0xa96: 0x18b8, 0xa97: 0x18bb,
+	0xa98: 0x18be, 0xa99: 0x18c1, 0xa9a: 0x18ca, 0xa9b: 0x18cd, 0xa9c: 0x18d0, 0xa9d: 0x18d3,
+	0xa9e: 0x18d6, 0xa9f: 0x18d9, 0xaa0: 0x0313, 0xaa1: 0x031b, 0xaa2: 0x031f, 0xaa3: 0x0327,
+	0xaa4: 0x032b, 0xaa5: 0x032f, 0xaa6: 0x0337, 0xaa7: 0x033f, 0xaa8: 0x0343, 0xaa9: 0x034b,
+	0xaaa: 0x034f, 0xaab: 0x0353, 0xaac: 0x0357, 0xaad: 0x035b, 0xaae: 0x2e18, 0xaaf: 0x2e20,
+	0xab0: 0x2e28, 0xab1: 0x2e30, 0xab2: 0x2e38, 0xab3: 0x2e40, 0xab4: 0x2e48, 0xab5: 0x2e50,
+	0xab6: 0x2e60, 0xab7: 0x2e68, 0xab8: 0x2e70, 0xab9: 0x2e78, 0xaba: 0x2e80, 0xabb: 0x2e88,
+	0xabc: 0x2ed3, 0xabd: 0x2e9b, 0xabe: 0x2e58,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x06bf, 0xac1: 0x071b, 0xac2: 0x06cb, 0xac3: 0x097b, 0xac4: 0x071f, 0xac5: 0x07af,
+	0xac6: 0x06c7, 0xac7: 0x07ab, 0xac8: 0x070b, 0xac9: 0x0887, 0xaca: 0x0d07, 0xacb: 0x0e8f,
+	0xacc: 0x0dd7, 0xacd: 0x0d1b, 0xace: 0x145f, 0xacf: 0x098b, 0xad0: 0x0ccf, 0xad1: 0x0d4b,
+	0xad2: 0x0d0b, 0xad3: 0x104b, 0xad4: 0x08fb, 0xad5: 0x0f03, 0xad6: 0x1387, 0xad7: 0x105f,
+	0xad8: 0x0843, 0xad9: 0x108f, 0xada: 0x0f9b, 0xadb: 0x0a17, 0xadc: 0x140f, 0xadd: 0x077f,
+	0xade: 0x08ab, 0xadf: 0x0df7, 0xae0: 0x1527, 0xae1: 0x0743, 0xae2: 0x07d3, 0xae3: 0x0d9b,
+	0xae4: 0x06cf, 0xae5: 0x06e7, 0xae6: 0x06d3, 0xae7: 0x0adb, 0xae8: 0x08ef, 0xae9: 0x087f,
+	0xaea: 0x0a57, 0xaeb: 0x0a4b, 0xaec: 0x0feb, 0xaed: 0x073f, 0xaee: 0x139b, 0xaef: 0x089b,
+	0xaf0: 0x09f3, 0xaf1: 0x18dc, 0xaf2: 0x18df, 0xaf3: 0x18e2, 0xaf4: 0x18e5, 0xaf5: 0x18ee,
+	0xaf6: 0x18f1, 0xaf7: 0x18f4, 0xaf8: 0x18f7, 0xaf9: 0x18fa, 0xafa: 0x18fd, 0xafb: 0x1900,
+	0xafc: 0x1903, 0xafd: 0x1906, 0xafe: 0x1909, 0xaff: 0x1912,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x1cc6, 0xb01: 0x1cd5, 0xb02: 0x1ce4, 0xb03: 0x1cf3, 0xb04: 0x1d02, 0xb05: 0x1d11,
+	0xb06: 0x1d20, 0xb07: 0x1d2f, 0xb08: 0x1d3e, 0xb09: 0x218c, 0xb0a: 0x219e, 0xb0b: 0x21b0,
+	0xb0c: 0x1954, 0xb0d: 0x1c04, 0xb0e: 0x19d2, 0xb0f: 0x1ba8, 0xb10: 0x04cb, 0xb11: 0x04d3,
+	0xb12: 0x04db, 0xb13: 0x04e3, 0xb14: 0x04eb, 0xb15: 0x04ef, 0xb16: 0x04f3, 0xb17: 0x04f7,
+	0xb18: 0x04fb, 0xb19: 0x04ff, 0xb1a: 0x0503, 0xb1b: 0x0507, 0xb1c: 0x050b, 0xb1d: 0x050f,
+	0xb1e: 0x0513, 0xb1f: 0x0517, 0xb20: 0x051b, 0xb21: 0x0523, 0xb22: 0x0527, 0xb23: 0x052b,
+	0xb24: 0x052f, 0xb25: 0x0533, 0xb26: 0x0537, 0xb27: 0x053b, 0xb28: 0x053f, 0xb29: 0x0543,
+	0xb2a: 0x0547, 0xb2b: 0x054b, 0xb2c: 0x054f, 0xb2d: 0x0553, 0xb2e: 0x0557, 0xb2f: 0x055b,
+	0xb30: 0x055f, 0xb31: 0x0563, 0xb32: 0x0567, 0xb33: 0x056f, 0xb34: 0x0577, 0xb35: 0x057f,
+	0xb36: 0x0583, 0xb37: 0x0587, 0xb38: 0x058b, 0xb39: 0x058f, 0xb3a: 0x0593, 0xb3b: 0x0597,
+	0xb3c: 0x059b, 0xb3d: 0x059f, 0xb3e: 0x05a3,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x2b0c, 0xb41: 0x29a8, 0xb42: 0x2b1c, 0xb43: 0x2880, 0xb44: 0x2ee4, 0xb45: 0x288a,
+	0xb46: 0x2894, 0xb47: 0x2f28, 0xb48: 0x29b5, 0xb49: 0x289e, 0xb4a: 0x28a8, 0xb4b: 0x28b2,
+	0xb4c: 0x29dc, 0xb4d: 0x29e9, 0xb4e: 0x29c2, 0xb4f: 0x29cf, 0xb50: 0x2ea9, 0xb51: 0x29f6,
+	0xb52: 0x2a03, 0xb53: 0x2bbe, 0xb54: 0x26bb, 0xb55: 0x2bd1, 0xb56: 0x2be4, 0xb57: 0x2b2c,
+	0xb58: 0x2a10, 0xb59: 0x2bf7, 0xb5a: 0x2c0a, 0xb5b: 0x2a1d, 0xb5c: 0x28bc, 0xb5d: 0x28c6,
+	0xb5e: 0x2eb7, 0xb5f: 0x2a2a, 0xb60: 0x2b3c, 0xb61: 0x2ef5, 0xb62: 0x28d0, 0xb63: 0x28da,
+	0xb64: 0x2a37, 0xb65: 0x28e4, 0xb66: 0x28ee, 0xb67: 0x26d0, 0xb68: 0x26d7, 0xb69: 0x28f8,
+	0xb6a: 0x2902, 0xb6b: 0x2c1d, 0xb6c: 0x2a44, 0xb6d: 0x2b4c, 0xb6e: 0x2c30, 0xb6f: 0x2a51,
+	0xb70: 0x2916, 0xb71: 0x290c, 0xb72: 0x2f3c, 0xb73: 0x2a5e, 0xb74: 0x2c43, 0xb75: 0x2920,
+	0xb76: 0x2b5c, 0xb77: 0x292a, 0xb78: 0x2a78, 0xb79: 0x2934, 0xb7a: 0x2a85, 0xb7b: 0x2f06,
+	0xb7c: 0x2a6b, 0xb7d: 0x2b6c, 0xb7e: 0x2a92, 0xb7f: 0x26de,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x2f17, 0xb81: 0x293e, 0xb82: 0x2948, 0xb83: 0x2a9f, 0xb84: 0x2952, 0xb85: 0x295c,
+	0xb86: 0x2966, 0xb87: 0x2b7c, 0xb88: 0x2aac, 0xb89: 0x26e5, 0xb8a: 0x2c56, 0xb8b: 0x2e90,
+	0xb8c: 0x2b8c, 0xb8d: 0x2ab9, 0xb8e: 0x2ec5, 0xb8f: 0x2970, 0xb90: 0x297a, 0xb91: 0x2ac6,
+	0xb92: 0x26ec, 0xb93: 0x2ad3, 0xb94: 0x2b9c, 0xb95: 0x26f3, 0xb96: 0x2c69, 0xb97: 0x2984,
+	0xb98: 0x1cb7, 0xb99: 0x1ccb, 0xb9a: 0x1cda, 0xb9b: 0x1ce9, 0xb9c: 0x1cf8, 0xb9d: 0x1d07,
+	0xb9e: 0x1d16, 0xb9f: 0x1d25, 0xba0: 0x1d34, 0xba1: 0x1d43, 0xba2: 0x2192, 0xba3: 0x21a4,
+	0xba4: 0x21b6, 0xba5: 0x21c2, 0xba6: 0x21ce, 0xba7: 0x21da, 0xba8: 0x21e6, 0xba9: 0x21f2,
+	0xbaa: 0x21fe, 0xbab: 0x220a, 0xbac: 0x2246, 0xbad: 0x2252, 0xbae: 0x225e, 0xbaf: 0x226a,
+	0xbb0: 0x2276, 0xbb1: 0x1c14, 0xbb2: 0x19c6, 0xbb3: 0x1936, 0xbb4: 0x1be4, 0xbb5: 0x1a47,
+	0xbb6: 0x1a56, 0xbb7: 0x19cc, 0xbb8: 0x1bfc, 0xbb9: 0x1c00, 0xbba: 0x1960, 0xbbb: 0x2701,
+	0xbbc: 0x270f, 0xbbd: 0x26fa, 0xbbe: 0x2708, 0xbbf: 0x2ae0,
+	// Block 0x2f, offset 0xbc0
+	0xbc0: 0x1a4a, 0xbc1: 0x1a32, 0xbc2: 0x1c60, 0xbc3: 0x1a1a, 0xbc4: 0x19f3, 0xbc5: 0x1969,
+	0xbc6: 0x1978, 0xbc7: 0x1948, 0xbc8: 0x1bf0, 0xbc9: 0x1d52, 0xbca: 0x1a4d, 0xbcb: 0x1a35,
+	0xbcc: 0x1c64, 0xbcd: 0x1c70, 0xbce: 0x1a26, 0xbcf: 0x19fc, 0xbd0: 0x1957, 0xbd1: 0x1c1c,
+	0xbd2: 0x1bb0, 0xbd3: 0x1b9c, 0xbd4: 0x1bcc, 0xbd5: 0x1c74, 0xbd6: 0x1a29, 0xbd7: 0x19c9,
+	0xbd8: 0x19ff, 0xbd9: 0x19de, 0xbda: 0x1a41, 0xbdb: 0x1c78, 0xbdc: 0x1a2c, 0xbdd: 0x19c0,
+	0xbde: 0x1a02, 0xbdf: 0x1c3c, 0xbe0: 0x1bf4, 0xbe1: 0x1a14, 0xbe2: 0x1c24, 0xbe3: 0x1c40,
+	0xbe4: 0x1bf8, 0xbe5: 0x1a17, 0xbe6: 0x1c28, 0xbe7: 0x22e8, 0xbe8: 0x22fc, 0xbe9: 0x1996,
+	0xbea: 0x1c20, 0xbeb: 0x1bb4, 0xbec: 0x1ba0, 0xbed: 0x1c48, 0xbee: 0x2716, 0xbef: 0x27ad,
+	0xbf0: 0x1a59, 0xbf1: 0x1a44, 0xbf2: 0x1c7c, 0xbf3: 0x1a2f, 0xbf4: 0x1a50, 0xbf5: 0x1a38,
+	0xbf6: 0x1c68, 0xbf7: 0x1a1d, 0xbf8: 0x19f6, 0xbf9: 0x1981, 0xbfa: 0x1a53, 0xbfb: 0x1a3b,
+	0xbfc: 0x1c6c, 0xbfd: 0x1a20, 0xbfe: 0x19f9, 0xbff: 0x1984,
+	// Block 0x30, offset 0xc00
+	0xc00: 0x1c2c, 0xc01: 0x1bb8, 0xc02: 0x1d4d, 0xc03: 0x1939, 0xc04: 0x19ba, 0xc05: 0x19bd,
+	0xc06: 0x22f5, 0xc07: 0x1b94, 0xc08: 0x19c3, 0xc09: 0x194b, 0xc0a: 0x19e1, 0xc0b: 0x194e,
+	0xc0c: 0x19ea, 0xc0d: 0x196c, 0xc0e: 0x196f, 0xc0f: 0x1a05, 0xc10: 0x1a0b, 0xc11: 0x1a0e,
+	0xc12: 0x1c30, 0xc13: 0x1a11, 0xc14: 0x1a23, 0xc15: 0x1c38, 0xc16: 0x1c44, 0xc17: 0x1990,
+	0xc18: 0x1d57, 0xc19: 0x1bbc, 0xc1a: 0x1993, 0xc1b: 0x1a5c, 0xc1c: 0x19a5, 0xc1d: 0x19b4,
+	0xc1e: 0x22e2, 0xc1f: 0x22dc, 0xc20: 0x1cc1, 0xc21: 0x1cd0, 0xc22: 0x1cdf, 0xc23: 0x1cee,
+	0xc24: 0x1cfd, 0xc25: 0x1d0c, 0xc26: 0x1d1b, 0xc27: 0x1d2a, 0xc28: 0x1d39, 0xc29: 0x2186,
+	0xc2a: 0x2198, 0xc2b: 0x21aa, 0xc2c: 0x21bc, 0xc2d: 0x21c8, 0xc2e: 0x21d4, 0xc2f: 0x21e0,
+	0xc30: 0x21ec, 0xc31: 0x21f8, 0xc32: 0x2204, 0xc33: 0x2240, 0xc34: 0x224c, 0xc35: 0x2258,
+	0xc36: 0x2264, 0xc37: 0x2270, 0xc38: 0x227c, 0xc39: 0x2282, 0xc3a: 0x2288, 0xc3b: 0x228e,
+	0xc3c: 0x2294, 0xc3d: 0x22a6, 0xc3e: 0x22ac, 0xc3f: 0x1c10,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x1377, 0xc41: 0x0cfb, 0xc42: 0x13d3, 0xc43: 0x139f, 0xc44: 0x0e57, 0xc45: 0x06eb,
+	0xc46: 0x08df, 0xc47: 0x162b, 0xc48: 0x162b, 0xc49: 0x0a0b, 0xc4a: 0x145f, 0xc4b: 0x0943,
+	0xc4c: 0x0a07, 0xc4d: 0x0bef, 0xc4e: 0x0fcf, 0xc4f: 0x115f, 0xc50: 0x1297, 0xc51: 0x12d3,
+	0xc52: 0x1307, 0xc53: 0x141b, 0xc54: 0x0d73, 0xc55: 0x0dff, 0xc56: 0x0eab, 0xc57: 0x0f43,
+	0xc58: 0x125f, 0xc59: 0x1447, 0xc5a: 0x1573, 0xc5b: 0x070f, 0xc5c: 0x08b3, 0xc5d: 0x0d87,
+	0xc5e: 0x0ecf, 0xc5f: 0x1293, 0xc60: 0x15c3, 0xc61: 0x0ab3, 0xc62: 0x0e77, 0xc63: 0x1283,
+	0xc64: 0x1317, 0xc65: 0x0c23, 0xc66: 0x11bb, 0xc67: 0x12df, 0xc68: 0x0b1f, 0xc69: 0x0d0f,
+	0xc6a: 0x0e17, 0xc6b: 0x0f1b, 0xc6c: 0x1427, 0xc6d: 0x074f, 0xc6e: 0x07e7, 0xc6f: 0x0853,
+	0xc70: 0x0c8b, 0xc71: 0x0d7f, 0xc72: 0x0ecb, 0xc73: 0x0fef, 0xc74: 0x1177, 0xc75: 0x128b,
+	0xc76: 0x12a3, 0xc77: 0x13c7, 0xc78: 0x14ef, 0xc79: 0x15a3, 0xc7a: 0x15bf, 0xc7b: 0x102b,
+	0xc7c: 0x106b, 0xc7d: 0x1123, 0xc7e: 0x1243, 0xc7f: 0x147b,
+	// Block 0x32, offset 0xc80
+	0xc80: 0x15cb, 0xc81: 0x134b, 0xc82: 0x09c7, 0xc83: 0x0b3b, 0xc84: 0x10db, 0xc85: 0x119b,
+	0xc86: 0x0eff, 0xc87: 0x1033, 0xc88: 0x1397, 0xc89: 0x14e7, 0xc8a: 0x09c3, 0xc8b: 0x0a8f,
+	0xc8c: 0x0d77, 0xc8d: 0x0e2b, 0xc8e: 0x0e5f, 0xc8f: 0x1113, 0xc90: 0x113b, 0xc91: 0x14a7,
+	0xc92: 0x084f, 0xc93: 0x11a7, 0xc94: 0x07f3, 0xc95: 0x07ef, 0xc96: 0x1097, 0xc97: 0x1127,
+	0xc98: 0x125b, 0xc99: 0x14af, 0xc9a: 0x1367, 0xc9b: 0x0c27, 0xc9c: 0x0d73, 0xc9d: 0x1357,
+	0xc9e: 0x06f7, 0xc9f: 0x0a63, 0xca0: 0x0b93, 0xca1: 0x0f2f, 0xca2: 0x0faf, 0xca3: 0x0873,
+	0xca4: 0x103b, 0xca5: 0x075f, 0xca6: 0x0b77, 0xca7: 0x06d7, 0xca8: 0x0deb, 0xca9: 0x0ca3,
+	0xcaa: 0x110f, 0xcab: 0x08c7, 0xcac: 0x09b3, 0xcad: 0x0ffb, 0xcae: 0x1263, 0xcaf: 0x133b,
+	0xcb0: 0x0db7, 0xcb1: 0x13f7, 0xcb2: 0x0de3, 0xcb3: 0x0c37, 0xcb4: 0x121b, 0xcb5: 0x0c57,
+	0xcb6: 0x0fab, 0xcb7: 0x072b, 0xcb8: 0x07a7, 0xcb9: 0x07eb, 0xcba: 0x0d53, 0xcbb: 0x10fb,
+	0xcbc: 0x11f3, 0xcbd: 0x1347, 0xcbe: 0x145b, 0xcbf: 0x085b,
+	// Block 0x33, offset 0xcc0
+	0xcc0: 0x090f, 0xcc1: 0x0a17, 0xcc2: 0x0b2f, 0xcc3: 0x0cbf, 0xcc4: 0x0e7b, 0xcc5: 0x103f,
+	0xcc6: 0x1497, 0xcc7: 0x157b, 0xcc8: 0x15cf, 0xcc9: 0x15e7, 0xcca: 0x0837, 0xccb: 0x0cf3,
+	0xccc: 0x0da3, 0xccd: 0x13eb, 0xcce: 0x0afb, 0xccf: 0x0bd7, 0xcd0: 0x0bf3, 0xcd1: 0x0c83,
+	0xcd2: 0x0e6b, 0xcd3: 0x0eb7, 0xcd4: 0x0f67, 0xcd5: 0x108b, 0xcd6: 0x112f, 0xcd7: 0x1193,
+	0xcd8: 0x13db, 0xcd9: 0x126b, 0xcda: 0x1403, 0xcdb: 0x147f, 0xcdc: 0x080f, 0xcdd: 0x083b,
+	0xcde: 0x0923, 0xcdf: 0x0ea7, 0xce0: 0x12f3, 0xce1: 0x133b, 0xce2: 0x0b1b, 0xce3: 0x0b8b,
+	0xce4: 0x0c4f, 0xce5: 0x0daf, 0xce6: 0x10d7, 0xce7: 0x0f23, 0xce8: 0x073b, 0xce9: 0x097f,
+	0xcea: 0x0a63, 0xceb: 0x0ac7, 0xcec: 0x0b97, 0xced: 0x0f3f, 0xcee: 0x0f5b, 0xcef: 0x116b,
+	0xcf0: 0x118b, 0xcf1: 0x1463, 0xcf2: 0x14e3, 0xcf3: 0x14f3, 0xcf4: 0x152f, 0xcf5: 0x0753,
+	0xcf6: 0x107f, 0xcf7: 0x144f, 0xcf8: 0x14cb, 0xcf9: 0x0baf, 0xcfa: 0x0717, 0xcfb: 0x0777,
+	0xcfc: 0x0a67, 0xcfd: 0x0a87, 0xcfe: 0x0caf, 0xcff: 0x0d73,
+	// Block 0x34, offset 0xd00
+	0xd00: 0x0ec3, 0xd01: 0x0fcb, 0xd02: 0x1277, 0xd03: 0x1417, 0xd04: 0x1623, 0xd05: 0x0ce3,
+	0xd06: 0x14a3, 0xd07: 0x0833, 0xd08: 0x0d2f, 0xd09: 0x0d3b, 0xd0a: 0x0e0f, 0xd0b: 0x0e47,
+	0xd0c: 0x0f4b, 0xd0d: 0x0fa7, 0xd0e: 0x1027, 0xd0f: 0x110b, 0xd10: 0x153b, 0xd11: 0x07af,
+	0xd12: 0x0c03, 0xd13: 0x14b3, 0xd14: 0x0767, 0xd15: 0x0aab, 0xd16: 0x0e2f, 0xd17: 0x13df,
+	0xd18: 0x0b67, 0xd19: 0x0bb7, 0xd1a: 0x0d43, 0xd1b: 0x0f2f, 0xd1c: 0x14bb, 0xd1d: 0x0817,
+	0xd1e: 0x08ff, 0xd1f: 0x0a97, 0xd20: 0x0cd3, 0xd21: 0x0d1f, 0xd22: 0x0d5f, 0xd23: 0x0df3,
+	0xd24: 0x0f47, 0xd25: 0x0fbb, 0xd26: 0x1157, 0xd27: 0x12f7, 0xd28: 0x1303, 0xd29: 0x1457,
+	0xd2a: 0x14d7, 0xd2b: 0x0883, 0xd2c: 0x0e4b, 0xd2d: 0x0903, 0xd2e: 0x0ec7, 0xd2f: 0x0f6b,
+	0xd30: 0x1287, 0xd31: 0x14bf, 0xd32: 0x15ab, 0xd33: 0x15d3, 0xd34: 0x0d37, 0xd35: 0x0e27,
+	0xd36: 0x11c3, 0xd37: 0x10b7, 0xd38: 0x10c3, 0xd39: 0x10e7, 0xd3a: 0x0f17, 0xd3b: 0x0e9f,
+	0xd3c: 0x1363, 0xd3d: 0x0733, 0xd3e: 0x122b, 0xd3f: 0x081b,
+	// Block 0x35, offset 0xd40
+	0xd40: 0x080b, 0xd41: 0x0b0b, 0xd42: 0x0c2b, 0xd43: 0x10f3, 0xd44: 0x0a53, 0xd45: 0x0e03,
+	0xd46: 0x0cef, 0xd47: 0x13e7, 0xd48: 0x12e7, 0xd49: 0x14ab, 0xd4a: 0x1323, 0xd4b: 0x0b27,
+	0xd4c: 0x0787, 0xd4d: 0x095b, 0xd50: 0x09af,
+	0xd52: 0x0cdf, 0xd55: 0x07f7, 0xd56: 0x0f1f, 0xd57: 0x0fe3,
+	0xd58: 0x1047, 0xd59: 0x1063, 0xd5a: 0x1067, 0xd5b: 0x107b, 0xd5c: 0x14fb, 0xd5d: 0x10eb,
+	0xd5e: 0x116f, 0xd60: 0x128f, 0xd62: 0x1353,
+	0xd65: 0x1407, 0xd66: 0x1433,
+	0xd6a: 0x154f, 0xd6b: 0x1553, 0xd6c: 0x1557, 0xd6d: 0x15bb, 0xd6e: 0x142b, 0xd6f: 0x14c7,
+	0xd70: 0x0757, 0xd71: 0x077b, 0xd72: 0x078f, 0xd73: 0x084b, 0xd74: 0x0857, 0xd75: 0x0897,
+	0xd76: 0x094b, 0xd77: 0x0967, 0xd78: 0x096f, 0xd79: 0x09ab, 0xd7a: 0x09b7, 0xd7b: 0x0a93,
+	0xd7c: 0x0a9b, 0xd7d: 0x0ba3, 0xd7e: 0x0bcb, 0xd7f: 0x0bd3,
+	// Block 0x36, offset 0xd80
+	0xd80: 0x0beb, 0xd81: 0x0c97, 0xd82: 0x0cc7, 0xd83: 0x0ce7, 0xd84: 0x0d57, 0xd85: 0x0e1b,
+	0xd86: 0x0e37, 0xd87: 0x0e67, 0xd88: 0x0ebb, 0xd89: 0x0edb, 0xd8a: 0x0f4f, 0xd8b: 0x102f,
+	0xd8c: 0x104b, 0xd8d: 0x1053, 0xd8e: 0x104f, 0xd8f: 0x1057, 0xd90: 0x105b, 0xd91: 0x105f,
+	0xd92: 0x1073, 0xd93: 0x1077, 0xd94: 0x109b, 0xd95: 0x10af, 0xd96: 0x10cb, 0xd97: 0x112f,
+	0xd98: 0x1137, 0xd99: 0x113f, 0xd9a: 0x1153, 0xd9b: 0x117b, 0xd9c: 0x11cb, 0xd9d: 0x11ff,
+	0xd9e: 0x11ff, 0xd9f: 0x1267, 0xda0: 0x130f, 0xda1: 0x1327, 0xda2: 0x135b, 0xda3: 0x135f,
+	0xda4: 0x13a3, 0xda5: 0x13a7, 0xda6: 0x13ff, 0xda7: 0x1407, 0xda8: 0x14db, 0xda9: 0x151f,
+	0xdaa: 0x1537, 0xdab: 0x0b9b, 0xdac: 0x171e, 0xdad: 0x11e3,
+	0xdb0: 0x06df, 0xdb1: 0x07e3, 0xdb2: 0x07a3, 0xdb3: 0x074b, 0xdb4: 0x078b, 0xdb5: 0x07b7,
+	0xdb6: 0x0847, 0xdb7: 0x0863, 0xdb8: 0x094b, 0xdb9: 0x0937, 0xdba: 0x0947, 0xdbb: 0x0963,
+	0xdbc: 0x09af, 0xdbd: 0x09bf, 0xdbe: 0x0a03, 0xdbf: 0x0a0f,
+	// Block 0x37, offset 0xdc0
+	0xdc0: 0x0a2b, 0xdc1: 0x0a3b, 0xdc2: 0x0b23, 0xdc3: 0x0b2b, 0xdc4: 0x0b5b, 0xdc5: 0x0b7b,
+	0xdc6: 0x0bab, 0xdc7: 0x0bc3, 0xdc8: 0x0bb3, 0xdc9: 0x0bd3, 0xdca: 0x0bc7, 0xdcb: 0x0beb,
+	0xdcc: 0x0c07, 0xdcd: 0x0c5f, 0xdce: 0x0c6b, 0xdcf: 0x0c73, 0xdd0: 0x0c9b, 0xdd1: 0x0cdf,
+	0xdd2: 0x0d0f, 0xdd3: 0x0d13, 0xdd4: 0x0d27, 0xdd5: 0x0da7, 0xdd6: 0x0db7, 0xdd7: 0x0e0f,
+	0xdd8: 0x0e5b, 0xdd9: 0x0e53, 0xdda: 0x0e67, 0xddb: 0x0e83, 0xddc: 0x0ebb, 0xddd: 0x1013,
+	0xdde: 0x0edf, 0xddf: 0x0f13, 0xde0: 0x0f1f, 0xde1: 0x0f5f, 0xde2: 0x0f7b, 0xde3: 0x0f9f,
+	0xde4: 0x0fc3, 0xde5: 0x0fc7, 0xde6: 0x0fe3, 0xde7: 0x0fe7, 0xde8: 0x0ff7, 0xde9: 0x100b,
+	0xdea: 0x1007, 0xdeb: 0x1037, 0xdec: 0x10b3, 0xded: 0x10cb, 0xdee: 0x10e3, 0xdef: 0x111b,
+	0xdf0: 0x112f, 0xdf1: 0x114b, 0xdf2: 0x117b, 0xdf3: 0x122f, 0xdf4: 0x1257, 0xdf5: 0x12cb,
+	0xdf6: 0x1313, 0xdf7: 0x131f, 0xdf8: 0x1327, 0xdf9: 0x133f, 0xdfa: 0x1353, 0xdfb: 0x1343,
+	0xdfc: 0x135b, 0xdfd: 0x1357, 0xdfe: 0x134f, 0xdff: 0x135f,
+	// Block 0x38, offset 0xe00
+	0xe00: 0x136b, 0xe01: 0x13a7, 0xe02: 0x13e3, 0xe03: 0x1413, 0xe04: 0x144b, 0xe05: 0x146b,
+	0xe06: 0x14b7, 0xe07: 0x14db, 0xe08: 0x14fb, 0xe09: 0x150f, 0xe0a: 0x151f, 0xe0b: 0x152b,
+	0xe0c: 0x1537, 0xe0d: 0x158b, 0xe0e: 0x162b, 0xe0f: 0x16b5, 0xe10: 0x16b0, 0xe11: 0x16e2,
+	0xe12: 0x0607, 0xe13: 0x062f, 0xe14: 0x0633, 0xe15: 0x1764, 0xe16: 0x1791, 0xe17: 0x1809,
+	0xe18: 0x1617, 0xe19: 0x1627,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x19d5, 0xe41: 0x19d8, 0xe42: 0x19db, 0xe43: 0x1c08, 0xe44: 0x1c0c, 0xe45: 0x1a5f,
+	0xe46: 0x1a5f,
+	0xe53: 0x1d75, 0xe54: 0x1d66, 0xe55: 0x1d6b, 0xe56: 0x1d7a, 0xe57: 0x1d70,
+	0xe5d: 0x4390,
+	0xe5e: 0x8115, 0xe5f: 0x4402, 0xe60: 0x022d, 0xe61: 0x0215, 0xe62: 0x021e, 0xe63: 0x0221,
+	0xe64: 0x0224, 0xe65: 0x0227, 0xe66: 0x022a, 0xe67: 0x0230, 0xe68: 0x0233, 0xe69: 0x0017,
+	0xe6a: 0x43f0, 0xe6b: 0x43f6, 0xe6c: 0x44f4, 0xe6d: 0x44fc, 0xe6e: 0x4348, 0xe6f: 0x434e,
+	0xe70: 0x4354, 0xe71: 0x435a, 0xe72: 0x4366, 0xe73: 0x436c, 0xe74: 0x4372, 0xe75: 0x437e,
+	0xe76: 0x4384, 0xe78: 0x438a, 0xe79: 0x4396, 0xe7a: 0x439c, 0xe7b: 0x43a2,
+	0xe7c: 0x43ae, 0xe7e: 0x43b4,
+	// Block 0x3a, offset 0xe80
+	0xe80: 0x43ba, 0xe81: 0x43c0, 0xe83: 0x43c6, 0xe84: 0x43cc,
+	0xe86: 0x43d8, 0xe87: 0x43de, 0xe88: 0x43e4, 0xe89: 0x43ea, 0xe8a: 0x43fc, 0xe8b: 0x4378,
+	0xe8c: 0x4360, 0xe8d: 0x43a8, 0xe8e: 0x43d2, 0xe8f: 0x1d7f, 0xe90: 0x0299, 0xe91: 0x0299,
+	0xe92: 0x02a2, 0xe93: 0x02a2, 0xe94: 0x02a2, 0xe95: 0x02a2, 0xe96: 0x02a5, 0xe97: 0x02a5,
+	0xe98: 0x02a5, 0xe99: 0x02a5, 0xe9a: 0x02ab, 0xe9b: 0x02ab, 0xe9c: 0x02ab, 0xe9d: 0x02ab,
+	0xe9e: 0x029f, 0xe9f: 0x029f, 0xea0: 0x029f, 0xea1: 0x029f, 0xea2: 0x02a8, 0xea3: 0x02a8,
+	0xea4: 0x02a8, 0xea5: 0x02a8, 0xea6: 0x029c, 0xea7: 0x029c, 0xea8: 0x029c, 0xea9: 0x029c,
+	0xeaa: 0x02cf, 0xeab: 0x02cf, 0xeac: 0x02cf, 0xead: 0x02cf, 0xeae: 0x02d2, 0xeaf: 0x02d2,
+	0xeb0: 0x02d2, 0xeb1: 0x02d2, 0xeb2: 0x02b1, 0xeb3: 0x02b1, 0xeb4: 0x02b1, 0xeb5: 0x02b1,
+	0xeb6: 0x02ae, 0xeb7: 0x02ae, 0xeb8: 0x02ae, 0xeb9: 0x02ae, 0xeba: 0x02b4, 0xebb: 0x02b4,
+	0xebc: 0x02b4, 0xebd: 0x02b4, 0xebe: 0x02b7, 0xebf: 0x02b7,
+	// Block 0x3b, offset 0xec0
+	0xec0: 0x02b7, 0xec1: 0x02b7, 0xec2: 0x02c0, 0xec3: 0x02c0, 0xec4: 0x02bd, 0xec5: 0x02bd,
+	0xec6: 0x02c3, 0xec7: 0x02c3, 0xec8: 0x02ba, 0xec9: 0x02ba, 0xeca: 0x02c9, 0xecb: 0x02c9,
+	0xecc: 0x02c6, 0xecd: 0x02c6, 0xece: 0x02d5, 0xecf: 0x02d5, 0xed0: 0x02d5, 0xed1: 0x02d5,
+	0xed2: 0x02db, 0xed3: 0x02db, 0xed4: 0x02db, 0xed5: 0x02db, 0xed6: 0x02e1, 0xed7: 0x02e1,
+	0xed8: 0x02e1, 0xed9: 0x02e1, 0xeda: 0x02de, 0xedb: 0x02de, 0xedc: 0x02de, 0xedd: 0x02de,
+	0xede: 0x02e4, 0xedf: 0x02e4, 0xee0: 0x02e7, 0xee1: 0x02e7, 0xee2: 0x02e7, 0xee3: 0x02e7,
+	0xee4: 0x446e, 0xee5: 0x446e, 0xee6: 0x02ed, 0xee7: 0x02ed, 0xee8: 0x02ed, 0xee9: 0x02ed,
+	0xeea: 0x02ea, 0xeeb: 0x02ea, 0xeec: 0x02ea, 0xeed: 0x02ea, 0xeee: 0x0308, 0xeef: 0x0308,
+	0xef0: 0x4468, 0xef1: 0x4468,
+	// Block 0x3c, offset 0xf00
+	0xf13: 0x02d8, 0xf14: 0x02d8, 0xf15: 0x02d8, 0xf16: 0x02d8, 0xf17: 0x02f6,
+	0xf18: 0x02f6, 0xf19: 0x02f3, 0xf1a: 0x02f3, 0xf1b: 0x02f9, 0xf1c: 0x02f9, 0xf1d: 0x204f,
+	0xf1e: 0x02ff, 0xf1f: 0x02ff, 0xf20: 0x02f0, 0xf21: 0x02f0, 0xf22: 0x02fc, 0xf23: 0x02fc,
+	0xf24: 0x0305, 0xf25: 0x0305, 0xf26: 0x0305, 0xf27: 0x0305, 0xf28: 0x028d, 0xf29: 0x028d,
+	0xf2a: 0x25aa, 0xf2b: 0x25aa, 0xf2c: 0x261a, 0xf2d: 0x261a, 0xf2e: 0x25e9, 0xf2f: 0x25e9,
+	0xf30: 0x2605, 0xf31: 0x2605, 0xf32: 0x25fe, 0xf33: 0x25fe, 0xf34: 0x260c, 0xf35: 0x260c,
+	0xf36: 0x2613, 0xf37: 0x2613, 0xf38: 0x2613, 0xf39: 0x25f0, 0xf3a: 0x25f0, 0xf3b: 0x25f0,
+	0xf3c: 0x0302, 0xf3d: 0x0302, 0xf3e: 0x0302, 0xf3f: 0x0302,
+	// Block 0x3d, offset 0xf40
+	0xf40: 0x25b1, 0xf41: 0x25b8, 0xf42: 0x25d4, 0xf43: 0x25f0, 0xf44: 0x25f7, 0xf45: 0x1d89,
+	0xf46: 0x1d8e, 0xf47: 0x1d93, 0xf48: 0x1da2, 0xf49: 0x1db1, 0xf4a: 0x1db6, 0xf4b: 0x1dbb,
+	0xf4c: 0x1dc0, 0xf4d: 0x1dc5, 0xf4e: 0x1dd4, 0xf4f: 0x1de3, 0xf50: 0x1de8, 0xf51: 0x1ded,
+	0xf52: 0x1dfc, 0xf53: 0x1e0b, 0xf54: 0x1e10, 0xf55: 0x1e15, 0xf56: 0x1e1a, 0xf57: 0x1e29,
+	0xf58: 0x1e2e, 0xf59: 0x1e3d, 0xf5a: 0x1e42, 0xf5b: 0x1e47, 0xf5c: 0x1e56, 0xf5d: 0x1e5b,
+	0xf5e: 0x1e60, 0xf5f: 0x1e6a, 0xf60: 0x1ea6, 0xf61: 0x1eb5, 0xf62: 0x1ec4, 0xf63: 0x1ec9,
+	0xf64: 0x1ece, 0xf65: 0x1ed8, 0xf66: 0x1ee7, 0xf67: 0x1eec, 0xf68: 0x1efb, 0xf69: 0x1f00,
+	0xf6a: 0x1f05, 0xf6b: 0x1f14, 0xf6c: 0x1f19, 0xf6d: 0x1f28, 0xf6e: 0x1f2d, 0xf6f: 0x1f32,
+	0xf70: 0x1f37, 0xf71: 0x1f3c, 0xf72: 0x1f41, 0xf73: 0x1f46, 0xf74: 0x1f4b, 0xf75: 0x1f50,
+	0xf76: 0x1f55, 0xf77: 0x1f5a, 0xf78: 0x1f5f, 0xf79: 0x1f64, 0xf7a: 0x1f69, 0xf7b: 0x1f6e,
+	0xf7c: 0x1f73, 0xf7d: 0x1f78, 0xf7e: 0x1f7d, 0xf7f: 0x1f87,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x1f8c, 0xf81: 0x1f91, 0xf82: 0x1f96, 0xf83: 0x1fa0, 0xf84: 0x1fa5, 0xf85: 0x1faf,
+	0xf86: 0x1fb4, 0xf87: 0x1fb9, 0xf88: 0x1fbe, 0xf89: 0x1fc3, 0xf8a: 0x1fc8, 0xf8b: 0x1fcd,
+	0xf8c: 0x1fd2, 0xf8d: 0x1fd7, 0xf8e: 0x1fe6, 0xf8f: 0x1ff5, 0xf90: 0x1ffa, 0xf91: 0x1fff,
+	0xf92: 0x2004, 0xf93: 0x2009, 0xf94: 0x200e, 0xf95: 0x2018, 0xf96: 0x201d, 0xf97: 0x2022,
+	0xf98: 0x2031, 0xf99: 0x2040, 0xf9a: 0x2045, 0xf9b: 0x4420, 0xf9c: 0x4426, 0xf9d: 0x445c,
+	0xf9e: 0x44b3, 0xf9f: 0x44ba, 0xfa0: 0x44c1, 0xfa1: 0x44c8, 0xfa2: 0x44cf, 0xfa3: 0x44d6,
+	0xfa4: 0x25c6, 0xfa5: 0x25cd, 0xfa6: 0x25d4, 0xfa7: 0x25db, 0xfa8: 0x25f0, 0xfa9: 0x25f7,
+	0xfaa: 0x1d98, 0xfab: 0x1d9d, 0xfac: 0x1da2, 0xfad: 0x1da7, 0xfae: 0x1db1, 0xfaf: 0x1db6,
+	0xfb0: 0x1dca, 0xfb1: 0x1dcf, 0xfb2: 0x1dd4, 0xfb3: 0x1dd9, 0xfb4: 0x1de3, 0xfb5: 0x1de8,
+	0xfb6: 0x1df2, 0xfb7: 0x1df7, 0xfb8: 0x1dfc, 0xfb9: 0x1e01, 0xfba: 0x1e0b, 0xfbb: 0x1e10,
+	0xfbc: 0x1f3c, 0xfbd: 0x1f41, 0xfbe: 0x1f50, 0xfbf: 0x1f55,
+	// Block 0x3f, offset 0xfc0
+	0xfc0: 0x1f5a, 0xfc1: 0x1f6e, 0xfc2: 0x1f73, 0xfc3: 0x1f78, 0xfc4: 0x1f7d, 0xfc5: 0x1f96,
+	0xfc6: 0x1fa0, 0xfc7: 0x1fa5, 0xfc8: 0x1faa, 0xfc9: 0x1fbe, 0xfca: 0x1fdc, 0xfcb: 0x1fe1,
+	0xfcc: 0x1fe6, 0xfcd: 0x1feb, 0xfce: 0x1ff5, 0xfcf: 0x1ffa, 0xfd0: 0x445c, 0xfd1: 0x2027,
+	0xfd2: 0x202c, 0xfd3: 0x2031, 0xfd4: 0x2036, 0xfd5: 0x2040, 0xfd6: 0x2045, 0xfd7: 0x25b1,
+	0xfd8: 0x25b8, 0xfd9: 0x25bf, 0xfda: 0x25d4, 0xfdb: 0x25e2, 0xfdc: 0x1d89, 0xfdd: 0x1d8e,
+	0xfde: 0x1d93, 0xfdf: 0x1da2, 0xfe0: 0x1dac, 0xfe1: 0x1dbb, 0xfe2: 0x1dc0, 0xfe3: 0x1dc5,
+	0xfe4: 0x1dd4, 0xfe5: 0x1dde, 0xfe6: 0x1dfc, 0xfe7: 0x1e15, 0xfe8: 0x1e1a, 0xfe9: 0x1e29,
+	0xfea: 0x1e2e, 0xfeb: 0x1e3d, 0xfec: 0x1e47, 0xfed: 0x1e56, 0xfee: 0x1e5b, 0xfef: 0x1e60,
+	0xff0: 0x1e6a, 0xff1: 0x1ea6, 0xff2: 0x1eab, 0xff3: 0x1eb5, 0xff4: 0x1ec4, 0xff5: 0x1ec9,
+	0xff6: 0x1ece, 0xff7: 0x1ed8, 0xff8: 0x1ee7, 0xff9: 0x1efb, 0xffa: 0x1f00, 0xffb: 0x1f05,
+	0xffc: 0x1f14, 0xffd: 0x1f19, 0xffe: 0x1f28, 0xfff: 0x1f2d,
+	// Block 0x40, offset 0x1000
+	0x1000: 0x1f32, 0x1001: 0x1f37, 0x1002: 0x1f46, 0x1003: 0x1f4b, 0x1004: 0x1f5f, 0x1005: 0x1f64,
+	0x1006: 0x1f69, 0x1007: 0x1f6e, 0x1008: 0x1f73, 0x1009: 0x1f87, 0x100a: 0x1f8c, 0x100b: 0x1f91,
+	0x100c: 0x1f96, 0x100d: 0x1f9b, 0x100e: 0x1faf, 0x100f: 0x1fb4, 0x1010: 0x1fb9, 0x1011: 0x1fbe,
+	0x1012: 0x1fcd, 0x1013: 0x1fd2, 0x1014: 0x1fd7, 0x1015: 0x1fe6, 0x1016: 0x1ff0, 0x1017: 0x1fff,
+	0x1018: 0x2004, 0x1019: 0x4450, 0x101a: 0x2018, 0x101b: 0x201d, 0x101c: 0x2022, 0x101d: 0x2031,
+	0x101e: 0x203b, 0x101f: 0x25d4, 0x1020: 0x25e2, 0x1021: 0x1da2, 0x1022: 0x1dac, 0x1023: 0x1dd4,
+	0x1024: 0x1dde, 0x1025: 0x1dfc, 0x1026: 0x1e06, 0x1027: 0x1e6a, 0x1028: 0x1e6f, 0x1029: 0x1e92,
+	0x102a: 0x1e97, 0x102b: 0x1f6e, 0x102c: 0x1f73, 0x102d: 0x1f96, 0x102e: 0x1fe6, 0x102f: 0x1ff0,
+	0x1030: 0x2031, 0x1031: 0x203b, 0x1032: 0x4504, 0x1033: 0x450c, 0x1034: 0x4514, 0x1035: 0x1ef1,
+	0x1036: 0x1ef6, 0x1037: 0x1f0a, 0x1038: 0x1f0f, 0x1039: 0x1f1e, 0x103a: 0x1f23, 0x103b: 0x1e74,
+	0x103c: 0x1e79, 0x103d: 0x1e9c, 0x103e: 0x1ea1, 0x103f: 0x1e33,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x1e38, 0x1041: 0x1e1f, 0x1042: 0x1e24, 0x1043: 0x1e4c, 0x1044: 0x1e51, 0x1045: 0x1eba,
+	0x1046: 0x1ebf, 0x1047: 0x1edd, 0x1048: 0x1ee2, 0x1049: 0x1e7e, 0x104a: 0x1e83, 0x104b: 0x1e88,
+	0x104c: 0x1e92, 0x104d: 0x1e8d, 0x104e: 0x1e65, 0x104f: 0x1eb0, 0x1050: 0x1ed3, 0x1051: 0x1ef1,
+	0x1052: 0x1ef6, 0x1053: 0x1f0a, 0x1054: 0x1f0f, 0x1055: 0x1f1e, 0x1056: 0x1f23, 0x1057: 0x1e74,
+	0x1058: 0x1e79, 0x1059: 0x1e9c, 0x105a: 0x1ea1, 0x105b: 0x1e33, 0x105c: 0x1e38, 0x105d: 0x1e1f,
+	0x105e: 0x1e24, 0x105f: 0x1e4c, 0x1060: 0x1e51, 0x1061: 0x1eba, 0x1062: 0x1ebf, 0x1063: 0x1edd,
+	0x1064: 0x1ee2, 0x1065: 0x1e7e, 0x1066: 0x1e83, 0x1067: 0x1e88, 0x1068: 0x1e92, 0x1069: 0x1e8d,
+	0x106a: 0x1e65, 0x106b: 0x1eb0, 0x106c: 0x1ed3, 0x106d: 0x1e7e, 0x106e: 0x1e83, 0x106f: 0x1e88,
+	0x1070: 0x1e92, 0x1071: 0x1e6f, 0x1072: 0x1e97, 0x1073: 0x1eec, 0x1074: 0x1e56, 0x1075: 0x1e5b,
+	0x1076: 0x1e60, 0x1077: 0x1e7e, 0x1078: 0x1e83, 0x1079: 0x1e88, 0x107a: 0x1eec, 0x107b: 0x1efb,
+	0x107c: 0x4408, 0x107d: 0x4408,
+	// Block 0x42, offset 0x1080
+	0x1090: 0x2311, 0x1091: 0x2326,
+	0x1092: 0x2326, 0x1093: 0x232d, 0x1094: 0x2334, 0x1095: 0x2349, 0x1096: 0x2350, 0x1097: 0x2357,
+	0x1098: 0x237a, 0x1099: 0x237a, 0x109a: 0x239d, 0x109b: 0x2396, 0x109c: 0x23b2, 0x109d: 0x23a4,
+	0x109e: 0x23ab, 0x109f: 0x23ce, 0x10a0: 0x23ce, 0x10a1: 0x23c7, 0x10a2: 0x23d5, 0x10a3: 0x23d5,
+	0x10a4: 0x23ff, 0x10a5: 0x23ff, 0x10a6: 0x241b, 0x10a7: 0x23e3, 0x10a8: 0x23e3, 0x10a9: 0x23dc,
+	0x10aa: 0x23f1, 0x10ab: 0x23f1, 0x10ac: 0x23f8, 0x10ad: 0x23f8, 0x10ae: 0x2422, 0x10af: 0x2430,
+	0x10b0: 0x2430, 0x10b1: 0x2437, 0x10b2: 0x2437, 0x10b3: 0x243e, 0x10b4: 0x2445, 0x10b5: 0x244c,
+	0x10b6: 0x2453, 0x10b7: 0x2453, 0x10b8: 0x245a, 0x10b9: 0x2468, 0x10ba: 0x2476, 0x10bb: 0x246f,
+	0x10bc: 0x247d, 0x10bd: 0x247d, 0x10be: 0x2492, 0x10bf: 0x2499,
+	// Block 0x43, offset 0x10c0
+	0x10c0: 0x24ca, 0x10c1: 0x24d8, 0x10c2: 0x24d1, 0x10c3: 0x24b5, 0x10c4: 0x24b5, 0x10c5: 0x24df,
+	0x10c6: 0x24df, 0x10c7: 0x24e6, 0x10c8: 0x24e6, 0x10c9: 0x2510, 0x10ca: 0x2517, 0x10cb: 0x251e,
+	0x10cc: 0x24f4, 0x10cd: 0x2502, 0x10ce: 0x2525, 0x10cf: 0x252c,
+	0x10d2: 0x24fb, 0x10d3: 0x2580, 0x10d4: 0x2587, 0x10d5: 0x255d, 0x10d6: 0x2564, 0x10d7: 0x2548,
+	0x10d8: 0x2548, 0x10d9: 0x254f, 0x10da: 0x2579, 0x10db: 0x2572, 0x10dc: 0x259c, 0x10dd: 0x259c,
+	0x10de: 0x230a, 0x10df: 0x231f, 0x10e0: 0x2318, 0x10e1: 0x2342, 0x10e2: 0x233b, 0x10e3: 0x2365,
+	0x10e4: 0x235e, 0x10e5: 0x2388, 0x10e6: 0x236c, 0x10e7: 0x2381, 0x10e8: 0x23b9, 0x10e9: 0x2406,
+	0x10ea: 0x23ea, 0x10eb: 0x2429, 0x10ec: 0x24c3, 0x10ed: 0x24ed, 0x10ee: 0x2595, 0x10ef: 0x258e,
+	0x10f0: 0x25a3, 0x10f1: 0x253a, 0x10f2: 0x24a0, 0x10f3: 0x256b, 0x10f4: 0x2492, 0x10f5: 0x24ca,
+	0x10f6: 0x2461, 0x10f7: 0x24ae, 0x10f8: 0x2541, 0x10f9: 0x2533, 0x10fa: 0x24bc, 0x10fb: 0x24a7,
+	0x10fc: 0x24bc, 0x10fd: 0x2541, 0x10fe: 0x2373, 0x10ff: 0x238f,
+	// Block 0x44, offset 0x1100
+	0x1100: 0x2509, 0x1101: 0x2484, 0x1102: 0x2303, 0x1103: 0x24a7, 0x1104: 0x244c, 0x1105: 0x241b,
+	0x1106: 0x23c0, 0x1107: 0x2556,
+	0x1130: 0x2414, 0x1131: 0x248b, 0x1132: 0x27bf, 0x1133: 0x27b6, 0x1134: 0x27ec, 0x1135: 0x27da,
+	0x1136: 0x27c8, 0x1137: 0x27e3, 0x1138: 0x27f5, 0x1139: 0x240d, 0x113a: 0x2c7c, 0x113b: 0x2afc,
+	0x113c: 0x27d1,
+	// Block 0x45, offset 0x1140
+	0x1150: 0x0019, 0x1151: 0x0483,
+	0x1152: 0x0487, 0x1153: 0x0035, 0x1154: 0x0037, 0x1155: 0x0003, 0x1156: 0x003f, 0x1157: 0x04bf,
+	0x1158: 0x04c3, 0x1159: 0x1b5c,
+	0x1160: 0x8132, 0x1161: 0x8132, 0x1162: 0x8132, 0x1163: 0x8132,
+	0x1164: 0x8132, 0x1165: 0x8132, 0x1166: 0x8132, 0x1167: 0x812d, 0x1168: 0x812d, 0x1169: 0x812d,
+	0x116a: 0x812d, 0x116b: 0x812d, 0x116c: 0x812d, 0x116d: 0x812d, 0x116e: 0x8132, 0x116f: 0x8132,
+	0x1170: 0x1873, 0x1171: 0x0443, 0x1172: 0x043f, 0x1173: 0x007f, 0x1174: 0x007f, 0x1175: 0x0011,
+	0x1176: 0x0013, 0x1177: 0x00b7, 0x1178: 0x00bb, 0x1179: 0x04b7, 0x117a: 0x04bb, 0x117b: 0x04ab,
+	0x117c: 0x04af, 0x117d: 0x0493, 0x117e: 0x0497, 0x117f: 0x048b,
+	// Block 0x46, offset 0x1180
+	0x1180: 0x048f, 0x1181: 0x049b, 0x1182: 0x049f, 0x1183: 0x04a3, 0x1184: 0x04a7,
+	0x1187: 0x0077, 0x1188: 0x007b, 0x1189: 0x4269, 0x118a: 0x4269, 0x118b: 0x4269,
+	0x118c: 0x4269, 0x118d: 0x007f, 0x118e: 0x007f, 0x118f: 0x007f, 0x1190: 0x0019, 0x1191: 0x0483,
+	0x1192: 0x001d, 0x1194: 0x0037, 0x1195: 0x0035, 0x1196: 0x003f, 0x1197: 0x0003,
+	0x1198: 0x0443, 0x1199: 0x0011, 0x119a: 0x0013, 0x119b: 0x00b7, 0x119c: 0x00bb, 0x119d: 0x04b7,
+	0x119e: 0x04bb, 0x119f: 0x0007, 0x11a0: 0x000d, 0x11a1: 0x0015, 0x11a2: 0x0017, 0x11a3: 0x001b,
+	0x11a4: 0x0039, 0x11a5: 0x003d, 0x11a6: 0x003b, 0x11a8: 0x0079, 0x11a9: 0x0009,
+	0x11aa: 0x000b, 0x11ab: 0x0041,
+	0x11b0: 0x42aa, 0x11b1: 0x442c, 0x11b2: 0x42af, 0x11b4: 0x42b4,
+	0x11b6: 0x42b9, 0x11b7: 0x4432, 0x11b8: 0x42be, 0x11b9: 0x4438, 0x11ba: 0x42c3, 0x11bb: 0x443e,
+	0x11bc: 0x42c8, 0x11bd: 0x4444, 0x11be: 0x42cd, 0x11bf: 0x444a,
+	// Block 0x47, offset 0x11c0
+	0x11c0: 0x0236, 0x11c1: 0x440e, 0x11c2: 0x440e, 0x11c3: 0x4414, 0x11c4: 0x4414, 0x11c5: 0x4456,
+	0x11c6: 0x4456, 0x11c7: 0x441a, 0x11c8: 0x441a, 0x11c9: 0x4462, 0x11ca: 0x4462, 0x11cb: 0x4462,
+	0x11cc: 0x4462, 0x11cd: 0x0239, 0x11ce: 0x0239, 0x11cf: 0x023c, 0x11d0: 0x023c, 0x11d1: 0x023c,
+	0x11d2: 0x023c, 0x11d3: 0x023f, 0x11d4: 0x023f, 0x11d5: 0x0242, 0x11d6: 0x0242, 0x11d7: 0x0242,
+	0x11d8: 0x0242, 0x11d9: 0x0245, 0x11da: 0x0245, 0x11db: 0x0245, 0x11dc: 0x0245, 0x11dd: 0x0248,
+	0x11de: 0x0248, 0x11df: 0x0248, 0x11e0: 0x0248, 0x11e1: 0x024b, 0x11e2: 0x024b, 0x11e3: 0x024b,
+	0x11e4: 0x024b, 0x11e5: 0x024e, 0x11e6: 0x024e, 0x11e7: 0x024e, 0x11e8: 0x024e, 0x11e9: 0x0251,
+	0x11ea: 0x0251, 0x11eb: 0x0254, 0x11ec: 0x0254, 0x11ed: 0x0257, 0x11ee: 0x0257, 0x11ef: 0x025a,
+	0x11f0: 0x025a, 0x11f1: 0x025d, 0x11f2: 0x025d, 0x11f3: 0x025d, 0x11f4: 0x025d, 0x11f5: 0x0260,
+	0x11f6: 0x0260, 0x11f7: 0x0260, 0x11f8: 0x0260, 0x11f9: 0x0263, 0x11fa: 0x0263, 0x11fb: 0x0263,
+	0x11fc: 0x0263, 0x11fd: 0x0266, 0x11fe: 0x0266, 0x11ff: 0x0266,
+	// Block 0x48, offset 0x1200
+	0x1200: 0x0266, 0x1201: 0x0269, 0x1202: 0x0269, 0x1203: 0x0269, 0x1204: 0x0269, 0x1205: 0x026c,
+	0x1206: 0x026c, 0x1207: 0x026c, 0x1208: 0x026c, 0x1209: 0x026f, 0x120a: 0x026f, 0x120b: 0x026f,
+	0x120c: 0x026f, 0x120d: 0x0272, 0x120e: 0x0272, 0x120f: 0x0272, 0x1210: 0x0272, 0x1211: 0x0275,
+	0x1212: 0x0275, 0x1213: 0x0275, 0x1214: 0x0275, 0x1215: 0x0278, 0x1216: 0x0278, 0x1217: 0x0278,
+	0x1218: 0x0278, 0x1219: 0x027b, 0x121a: 0x027b, 0x121b: 0x027b, 0x121c: 0x027b, 0x121d: 0x027e,
+	0x121e: 0x027e, 0x121f: 0x027e, 0x1220: 0x027e, 0x1221: 0x0281, 0x1222: 0x0281, 0x1223: 0x0281,
+	0x1224: 0x0281, 0x1225: 0x0284, 0x1226: 0x0284, 0x1227: 0x0284, 0x1228: 0x0284, 0x1229: 0x0287,
+	0x122a: 0x0287, 0x122b: 0x0287, 0x122c: 0x0287, 0x122d: 0x028a, 0x122e: 0x028a, 0x122f: 0x028d,
+	0x1230: 0x028d, 0x1231: 0x0290, 0x1232: 0x0290, 0x1233: 0x0290, 0x1234: 0x0290, 0x1235: 0x2e00,
+	0x1236: 0x2e00, 0x1237: 0x2e08, 0x1238: 0x2e08, 0x1239: 0x2e10, 0x123a: 0x2e10, 0x123b: 0x1f82,
+	0x123c: 0x1f82,
+	// Block 0x49, offset 0x1240
+	0x1240: 0x0081, 0x1241: 0x0083, 0x1242: 0x0085, 0x1243: 0x0087, 0x1244: 0x0089, 0x1245: 0x008b,
+	0x1246: 0x008d, 0x1247: 0x008f, 0x1248: 0x0091, 0x1249: 0x0093, 0x124a: 0x0095, 0x124b: 0x0097,
+	0x124c: 0x0099, 0x124d: 0x009b, 0x124e: 0x009d, 0x124f: 0x009f, 0x1250: 0x00a1, 0x1251: 0x00a3,
+	0x1252: 0x00a5, 0x1253: 0x00a7, 0x1254: 0x00a9, 0x1255: 0x00ab, 0x1256: 0x00ad, 0x1257: 0x00af,
+	0x1258: 0x00b1, 0x1259: 0x00b3, 0x125a: 0x00b5, 0x125b: 0x00b7, 0x125c: 0x00b9, 0x125d: 0x00bb,
+	0x125e: 0x00bd, 0x125f: 0x0477, 0x1260: 0x047b, 0x1261: 0x0487, 0x1262: 0x049b, 0x1263: 0x049f,
+	0x1264: 0x0483, 0x1265: 0x05ab, 0x1266: 0x05a3, 0x1267: 0x04c7, 0x1268: 0x04cf, 0x1269: 0x04d7,
+	0x126a: 0x04df, 0x126b: 0x04e7, 0x126c: 0x056b, 0x126d: 0x0573, 0x126e: 0x057b, 0x126f: 0x051f,
+	0x1270: 0x05af, 0x1271: 0x04cb, 0x1272: 0x04d3, 0x1273: 0x04db, 0x1274: 0x04e3, 0x1275: 0x04eb,
+	0x1276: 0x04ef, 0x1277: 0x04f3, 0x1278: 0x04f7, 0x1279: 0x04fb, 0x127a: 0x04ff, 0x127b: 0x0503,
+	0x127c: 0x0507, 0x127d: 0x050b, 0x127e: 0x050f, 0x127f: 0x0513,
+	// Block 0x4a, offset 0x1280
+	0x1280: 0x0517, 0x1281: 0x051b, 0x1282: 0x0523, 0x1283: 0x0527, 0x1284: 0x052b, 0x1285: 0x052f,
+	0x1286: 0x0533, 0x1287: 0x0537, 0x1288: 0x053b, 0x1289: 0x053f, 0x128a: 0x0543, 0x128b: 0x0547,
+	0x128c: 0x054b, 0x128d: 0x054f, 0x128e: 0x0553, 0x128f: 0x0557, 0x1290: 0x055b, 0x1291: 0x055f,
+	0x1292: 0x0563, 0x1293: 0x0567, 0x1294: 0x056f, 0x1295: 0x0577, 0x1296: 0x057f, 0x1297: 0x0583,
+	0x1298: 0x0587, 0x1299: 0x058b, 0x129a: 0x058f, 0x129b: 0x0593, 0x129c: 0x0597, 0x129d: 0x05a7,
+	0x129e: 0x4a78, 0x129f: 0x4a7e, 0x12a0: 0x03c3, 0x12a1: 0x0313, 0x12a2: 0x0317, 0x12a3: 0x4a3b,
+	0x12a4: 0x031b, 0x12a5: 0x4a41, 0x12a6: 0x4a47, 0x12a7: 0x031f, 0x12a8: 0x0323, 0x12a9: 0x0327,
+	0x12aa: 0x4a4d, 0x12ab: 0x4a53, 0x12ac: 0x4a59, 0x12ad: 0x4a5f, 0x12ae: 0x4a65, 0x12af: 0x4a6b,
+	0x12b0: 0x0367, 0x12b1: 0x032b, 0x12b2: 0x032f, 0x12b3: 0x0333, 0x12b4: 0x037b, 0x12b5: 0x0337,
+	0x12b6: 0x033b, 0x12b7: 0x033f, 0x12b8: 0x0343, 0x12b9: 0x0347, 0x12ba: 0x034b, 0x12bb: 0x034f,
+	0x12bc: 0x0353, 0x12bd: 0x0357, 0x12be: 0x035b,
+	// Block 0x4b, offset 0x12c0
+	0x12c2: 0x49bd, 0x12c3: 0x49c3, 0x12c4: 0x49c9, 0x12c5: 0x49cf,
+	0x12c6: 0x49d5, 0x12c7: 0x49db, 0x12ca: 0x49e1, 0x12cb: 0x49e7,
+	0x12cc: 0x49ed, 0x12cd: 0x49f3, 0x12ce: 0x49f9, 0x12cf: 0x49ff,
+	0x12d2: 0x4a05, 0x12d3: 0x4a0b, 0x12d4: 0x4a11, 0x12d5: 0x4a17, 0x12d6: 0x4a1d, 0x12d7: 0x4a23,
+	0x12da: 0x4a29, 0x12db: 0x4a2f, 0x12dc: 0x4a35,
+	0x12e0: 0x00bf, 0x12e1: 0x00c2, 0x12e2: 0x00cb, 0x12e3: 0x4264,
+	0x12e4: 0x00c8, 0x12e5: 0x00c5, 0x12e6: 0x0447, 0x12e8: 0x046b, 0x12e9: 0x044b,
+	0x12ea: 0x044f, 0x12eb: 0x0453, 0x12ec: 0x0457, 0x12ed: 0x046f, 0x12ee: 0x0473,
+	// Block 0x4c, offset 0x1300
+	0x1300: 0x0063, 0x1301: 0x0065, 0x1302: 0x0067, 0x1303: 0x0069, 0x1304: 0x006b, 0x1305: 0x006d,
+	0x1306: 0x006f, 0x1307: 0x0071, 0x1308: 0x0073, 0x1309: 0x0075, 0x130a: 0x0083, 0x130b: 0x0085,
+	0x130c: 0x0087, 0x130d: 0x0089, 0x130e: 0x008b, 0x130f: 0x008d, 0x1310: 0x008f, 0x1311: 0x0091,
+	0x1312: 0x0093, 0x1313: 0x0095, 0x1314: 0x0097, 0x1315: 0x0099, 0x1316: 0x009b, 0x1317: 0x009d,
+	0x1318: 0x009f, 0x1319: 0x00a1, 0x131a: 0x00a3, 0x131b: 0x00a5, 0x131c: 0x00a7, 0x131d: 0x00a9,
+	0x131e: 0x00ab, 0x131f: 0x00ad, 0x1320: 0x00af, 0x1321: 0x00b1, 0x1322: 0x00b3, 0x1323: 0x00b5,
+	0x1324: 0x00dd, 0x1325: 0x00f2, 0x1328: 0x0173, 0x1329: 0x0176,
+	0x132a: 0x0179, 0x132b: 0x017c, 0x132c: 0x017f, 0x132d: 0x0182, 0x132e: 0x0185, 0x132f: 0x0188,
+	0x1330: 0x018b, 0x1331: 0x018e, 0x1332: 0x0191, 0x1333: 0x0194, 0x1334: 0x0197, 0x1335: 0x019a,
+	0x1336: 0x019d, 0x1337: 0x01a0, 0x1338: 0x01a3, 0x1339: 0x0188, 0x133a: 0x01a6, 0x133b: 0x01a9,
+	0x133c: 0x01ac, 0x133d: 0x01af, 0x133e: 0x01b2, 0x133f: 0x01b5,
+	// Block 0x4d, offset 0x1340
+	0x1340: 0x01fd, 0x1341: 0x0200, 0x1342: 0x0203, 0x1343: 0x045b, 0x1344: 0x01c7, 0x1345: 0x01d0,
+	0x1346: 0x01d6, 0x1347: 0x01fa, 0x1348: 0x01eb, 0x1349: 0x01e8, 0x134a: 0x0206, 0x134b: 0x0209,
+	0x134e: 0x0021, 0x134f: 0x0023, 0x1350: 0x0025, 0x1351: 0x0027,
+	0x1352: 0x0029, 0x1353: 0x002b, 0x1354: 0x002d, 0x1355: 0x002f, 0x1356: 0x0031, 0x1357: 0x0033,
+	0x1358: 0x0021, 0x1359: 0x0023, 0x135a: 0x0025, 0x135b: 0x0027, 0x135c: 0x0029, 0x135d: 0x002b,
+	0x135e: 0x002d, 0x135f: 0x002f, 0x1360: 0x0031, 0x1361: 0x0033, 0x1362: 0x0021, 0x1363: 0x0023,
+	0x1364: 0x0025, 0x1365: 0x0027, 0x1366: 0x0029, 0x1367: 0x002b, 0x1368: 0x002d, 0x1369: 0x002f,
+	0x136a: 0x0031, 0x136b: 0x0033, 0x136c: 0x0021, 0x136d: 0x0023, 0x136e: 0x0025, 0x136f: 0x0027,
+	0x1370: 0x0029, 0x1371: 0x002b, 0x1372: 0x002d, 0x1373: 0x002f, 0x1374: 0x0031, 0x1375: 0x0033,
+	0x1376: 0x0021, 0x1377: 0x0023, 0x1378: 0x0025, 0x1379: 0x0027, 0x137a: 0x0029, 0x137b: 0x002b,
+	0x137c: 0x002d, 0x137d: 0x002f, 0x137e: 0x0031, 0x137f: 0x0033,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x0239, 0x1381: 0x023c, 0x1382: 0x0248, 0x1383: 0x0251, 0x1385: 0x028a,
+	0x1386: 0x025a, 0x1387: 0x024b, 0x1388: 0x0269, 0x1389: 0x0290, 0x138a: 0x027b, 0x138b: 0x027e,
+	0x138c: 0x0281, 0x138d: 0x0284, 0x138e: 0x025d, 0x138f: 0x026f, 0x1390: 0x0275, 0x1391: 0x0263,
+	0x1392: 0x0278, 0x1393: 0x0257, 0x1394: 0x0260, 0x1395: 0x0242, 0x1396: 0x0245, 0x1397: 0x024e,
+	0x1398: 0x0254, 0x1399: 0x0266, 0x139a: 0x026c, 0x139b: 0x0272, 0x139c: 0x0293, 0x139d: 0x02e4,
+	0x139e: 0x02cc, 0x139f: 0x0296, 0x13a1: 0x023c, 0x13a2: 0x0248,
+	0x13a4: 0x0287, 0x13a7: 0x024b, 0x13a9: 0x0290,
+	0x13aa: 0x027b, 0x13ab: 0x027e, 0x13ac: 0x0281, 0x13ad: 0x0284, 0x13ae: 0x025d, 0x13af: 0x026f,
+	0x13b0: 0x0275, 0x13b1: 0x0263, 0x13b2: 0x0278, 0x13b4: 0x0260, 0x13b5: 0x0242,
+	0x13b6: 0x0245, 0x13b7: 0x024e, 0x13b9: 0x0266, 0x13bb: 0x0272,
+	// Block 0x4f, offset 0x13c0
+	0x13c2: 0x0248,
+	0x13c7: 0x024b, 0x13c9: 0x0290, 0x13cb: 0x027e,
+	0x13cd: 0x0284, 0x13ce: 0x025d, 0x13cf: 0x026f, 0x13d1: 0x0263,
+	0x13d2: 0x0278, 0x13d4: 0x0260, 0x13d7: 0x024e,
+	0x13d9: 0x0266, 0x13db: 0x0272, 0x13dd: 0x02e4,
+	0x13df: 0x0296, 0x13e1: 0x023c, 0x13e2: 0x0248,
+	0x13e4: 0x0287, 0x13e7: 0x024b, 0x13e8: 0x0269, 0x13e9: 0x0290,
+	0x13ea: 0x027b, 0x13ec: 0x0281, 0x13ed: 0x0284, 0x13ee: 0x025d, 0x13ef: 0x026f,
+	0x13f0: 0x0275, 0x13f1: 0x0263, 0x13f2: 0x0278, 0x13f4: 0x0260, 0x13f5: 0x0242,
+	0x13f6: 0x0245, 0x13f7: 0x024e, 0x13f9: 0x0266, 0x13fa: 0x026c, 0x13fb: 0x0272,
+	0x13fc: 0x0293, 0x13fe: 0x02cc,
+	// Block 0x50, offset 0x1400
+	0x1400: 0x0239, 0x1401: 0x023c, 0x1402: 0x0248, 0x1403: 0x0251, 0x1404: 0x0287, 0x1405: 0x028a,
+	0x1406: 0x025a, 0x1407: 0x024b, 0x1408: 0x0269, 0x1409: 0x0290, 0x140b: 0x027e,
+	0x140c: 0x0281, 0x140d: 0x0284, 0x140e: 0x025d, 0x140f: 0x026f, 0x1410: 0x0275, 0x1411: 0x0263,
+	0x1412: 0x0278, 0x1413: 0x0257, 0x1414: 0x0260, 0x1415: 0x0242, 0x1416: 0x0245, 0x1417: 0x024e,
+	0x1418: 0x0254, 0x1419: 0x0266, 0x141a: 0x026c, 0x141b: 0x0272,
+	0x1421: 0x023c, 0x1422: 0x0248, 0x1423: 0x0251,
+	0x1425: 0x028a, 0x1426: 0x025a, 0x1427: 0x024b, 0x1428: 0x0269, 0x1429: 0x0290,
+	0x142b: 0x027e, 0x142c: 0x0281, 0x142d: 0x0284, 0x142e: 0x025d, 0x142f: 0x026f,
+	0x1430: 0x0275, 0x1431: 0x0263, 0x1432: 0x0278, 0x1433: 0x0257, 0x1434: 0x0260, 0x1435: 0x0242,
+	0x1436: 0x0245, 0x1437: 0x024e, 0x1438: 0x0254, 0x1439: 0x0266, 0x143a: 0x026c, 0x143b: 0x0272,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x1879, 0x1441: 0x1876, 0x1442: 0x187c, 0x1443: 0x18a0, 0x1444: 0x18c4, 0x1445: 0x18e8,
+	0x1446: 0x190c, 0x1447: 0x1915, 0x1448: 0x191b, 0x1449: 0x1921, 0x144a: 0x1927,
+	0x1450: 0x1a8c, 0x1451: 0x1a90,
+	0x1452: 0x1a94, 0x1453: 0x1a98, 0x1454: 0x1a9c, 0x1455: 0x1aa0, 0x1456: 0x1aa4, 0x1457: 0x1aa8,
+	0x1458: 0x1aac, 0x1459: 0x1ab0, 0x145a: 0x1ab4, 0x145b: 0x1ab8, 0x145c: 0x1abc, 0x145d: 0x1ac0,
+	0x145e: 0x1ac4, 0x145f: 0x1ac8, 0x1460: 0x1acc, 0x1461: 0x1ad0, 0x1462: 0x1ad4, 0x1463: 0x1ad8,
+	0x1464: 0x1adc, 0x1465: 0x1ae0, 0x1466: 0x1ae4, 0x1467: 0x1ae8, 0x1468: 0x1aec, 0x1469: 0x1af0,
+	0x146a: 0x271e, 0x146b: 0x0047, 0x146c: 0x0065, 0x146d: 0x193c, 0x146e: 0x19b1,
+	0x1470: 0x0043, 0x1471: 0x0045, 0x1472: 0x0047, 0x1473: 0x0049, 0x1474: 0x004b, 0x1475: 0x004d,
+	0x1476: 0x004f, 0x1477: 0x0051, 0x1478: 0x0053, 0x1479: 0x0055, 0x147a: 0x0057, 0x147b: 0x0059,
+	0x147c: 0x005b, 0x147d: 0x005d, 0x147e: 0x005f, 0x147f: 0x0061,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x26ad, 0x1481: 0x26c2, 0x1482: 0x0503,
+	0x1490: 0x0c0f, 0x1491: 0x0a47,
+	0x1492: 0x08d3, 0x1493: 0x45c4, 0x1494: 0x071b, 0x1495: 0x09ef, 0x1496: 0x132f, 0x1497: 0x09ff,
+	0x1498: 0x0727, 0x1499: 0x0cd7, 0x149a: 0x0eaf, 0x149b: 0x0caf, 0x149c: 0x0827, 0x149d: 0x0b6b,
+	0x149e: 0x07bf, 0x149f: 0x0cb7, 0x14a0: 0x0813, 0x14a1: 0x1117, 0x14a2: 0x0f83, 0x14a3: 0x138b,
+	0x14a4: 0x09d3, 0x14a5: 0x090b, 0x14a6: 0x0e63, 0x14a7: 0x0c1b, 0x14a8: 0x0c47, 0x14a9: 0x06bf,
+	0x14aa: 0x06cb, 0x14ab: 0x140b, 0x14ac: 0x0adb, 0x14ad: 0x06e7, 0x14ae: 0x08ef, 0x14af: 0x0c3b,
+	0x14b0: 0x13b3, 0x14b1: 0x0c13, 0x14b2: 0x106f, 0x14b3: 0x10ab, 0x14b4: 0x08f7, 0x14b5: 0x0e43,
+	0x14b6: 0x0d0b, 0x14b7: 0x0d07, 0x14b8: 0x0f97, 0x14b9: 0x082b, 0x14ba: 0x0957, 0x14bb: 0x1443,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x06fb, 0x14c1: 0x06f3, 0x14c2: 0x0703, 0x14c3: 0x1647, 0x14c4: 0x0747, 0x14c5: 0x0757,
+	0x14c6: 0x075b, 0x14c7: 0x0763, 0x14c8: 0x076b, 0x14c9: 0x076f, 0x14ca: 0x077b, 0x14cb: 0x0773,
+	0x14cc: 0x05b3, 0x14cd: 0x165b, 0x14ce: 0x078f, 0x14cf: 0x0793, 0x14d0: 0x0797, 0x14d1: 0x07b3,
+	0x14d2: 0x164c, 0x14d3: 0x05b7, 0x14d4: 0x079f, 0x14d5: 0x07bf, 0x14d6: 0x1656, 0x14d7: 0x07cf,
+	0x14d8: 0x07d7, 0x14d9: 0x0737, 0x14da: 0x07df, 0x14db: 0x07e3, 0x14dc: 0x1831, 0x14dd: 0x07ff,
+	0x14de: 0x0807, 0x14df: 0x05bf, 0x14e0: 0x081f, 0x14e1: 0x0823, 0x14e2: 0x082b, 0x14e3: 0x082f,
+	0x14e4: 0x05c3, 0x14e5: 0x0847, 0x14e6: 0x084b, 0x14e7: 0x0857, 0x14e8: 0x0863, 0x14e9: 0x0867,
+	0x14ea: 0x086b, 0x14eb: 0x0873, 0x14ec: 0x0893, 0x14ed: 0x0897, 0x14ee: 0x089f, 0x14ef: 0x08af,
+	0x14f0: 0x08b7, 0x14f1: 0x08bb, 0x14f2: 0x08bb, 0x14f3: 0x08bb, 0x14f4: 0x166a, 0x14f5: 0x0e93,
+	0x14f6: 0x08cf, 0x14f7: 0x08d7, 0x14f8: 0x166f, 0x14f9: 0x08e3, 0x14fa: 0x08eb, 0x14fb: 0x08f3,
+	0x14fc: 0x091b, 0x14fd: 0x0907, 0x14fe: 0x0913, 0x14ff: 0x0917,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x091f, 0x1501: 0x0927, 0x1502: 0x092b, 0x1503: 0x0933, 0x1504: 0x093b, 0x1505: 0x093f,
+	0x1506: 0x093f, 0x1507: 0x0947, 0x1508: 0x094f, 0x1509: 0x0953, 0x150a: 0x095f, 0x150b: 0x0983,
+	0x150c: 0x0967, 0x150d: 0x0987, 0x150e: 0x096b, 0x150f: 0x0973, 0x1510: 0x080b, 0x1511: 0x09cf,
+	0x1512: 0x0997, 0x1513: 0x099b, 0x1514: 0x099f, 0x1515: 0x0993, 0x1516: 0x09a7, 0x1517: 0x09a3,
+	0x1518: 0x09bb, 0x1519: 0x1674, 0x151a: 0x09d7, 0x151b: 0x09db, 0x151c: 0x09e3, 0x151d: 0x09ef,
+	0x151e: 0x09f7, 0x151f: 0x0a13, 0x1520: 0x1679, 0x1521: 0x167e, 0x1522: 0x0a1f, 0x1523: 0x0a23,
+	0x1524: 0x0a27, 0x1525: 0x0a1b, 0x1526: 0x0a2f, 0x1527: 0x05c7, 0x1528: 0x05cb, 0x1529: 0x0a37,
+	0x152a: 0x0a3f, 0x152b: 0x0a3f, 0x152c: 0x1683, 0x152d: 0x0a5b, 0x152e: 0x0a5f, 0x152f: 0x0a63,
+	0x1530: 0x0a6b, 0x1531: 0x1688, 0x1532: 0x0a73, 0x1533: 0x0a77, 0x1534: 0x0b4f, 0x1535: 0x0a7f,
+	0x1536: 0x05cf, 0x1537: 0x0a8b, 0x1538: 0x0a9b, 0x1539: 0x0aa7, 0x153a: 0x0aa3, 0x153b: 0x1692,
+	0x153c: 0x0aaf, 0x153d: 0x1697, 0x153e: 0x0abb, 0x153f: 0x0ab7,
+	// Block 0x55, offset 0x1540
+	0x1540: 0x0abf, 0x1541: 0x0acf, 0x1542: 0x0ad3, 0x1543: 0x05d3, 0x1544: 0x0ae3, 0x1545: 0x0aeb,
+	0x1546: 0x0aef, 0x1547: 0x0af3, 0x1548: 0x05d7, 0x1549: 0x169c, 0x154a: 0x05db, 0x154b: 0x0b0f,
+	0x154c: 0x0b13, 0x154d: 0x0b17, 0x154e: 0x0b1f, 0x154f: 0x1863, 0x1550: 0x0b37, 0x1551: 0x16a6,
+	0x1552: 0x16a6, 0x1553: 0x11d7, 0x1554: 0x0b47, 0x1555: 0x0b47, 0x1556: 0x05df, 0x1557: 0x16c9,
+	0x1558: 0x179b, 0x1559: 0x0b57, 0x155a: 0x0b5f, 0x155b: 0x05e3, 0x155c: 0x0b73, 0x155d: 0x0b83,
+	0x155e: 0x0b87, 0x155f: 0x0b8f, 0x1560: 0x0b9f, 0x1561: 0x05eb, 0x1562: 0x05e7, 0x1563: 0x0ba3,
+	0x1564: 0x16ab, 0x1565: 0x0ba7, 0x1566: 0x0bbb, 0x1567: 0x0bbf, 0x1568: 0x0bc3, 0x1569: 0x0bbf,
+	0x156a: 0x0bcf, 0x156b: 0x0bd3, 0x156c: 0x0be3, 0x156d: 0x0bdb, 0x156e: 0x0bdf, 0x156f: 0x0be7,
+	0x1570: 0x0beb, 0x1571: 0x0bef, 0x1572: 0x0bfb, 0x1573: 0x0bff, 0x1574: 0x0c17, 0x1575: 0x0c1f,
+	0x1576: 0x0c2f, 0x1577: 0x0c43, 0x1578: 0x16ba, 0x1579: 0x0c3f, 0x157a: 0x0c33, 0x157b: 0x0c4b,
+	0x157c: 0x0c53, 0x157d: 0x0c67, 0x157e: 0x16bf, 0x157f: 0x0c6f,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x0c63, 0x1581: 0x0c5b, 0x1582: 0x05ef, 0x1583: 0x0c77, 0x1584: 0x0c7f, 0x1585: 0x0c87,
+	0x1586: 0x0c7b, 0x1587: 0x05f3, 0x1588: 0x0c97, 0x1589: 0x0c9f, 0x158a: 0x16c4, 0x158b: 0x0ccb,
+	0x158c: 0x0cff, 0x158d: 0x0cdb, 0x158e: 0x05ff, 0x158f: 0x0ce7, 0x1590: 0x05fb, 0x1591: 0x05f7,
+	0x1592: 0x07c3, 0x1593: 0x07c7, 0x1594: 0x0d03, 0x1595: 0x0ceb, 0x1596: 0x11ab, 0x1597: 0x0663,
+	0x1598: 0x0d0f, 0x1599: 0x0d13, 0x159a: 0x0d17, 0x159b: 0x0d2b, 0x159c: 0x0d23, 0x159d: 0x16dd,
+	0x159e: 0x0603, 0x159f: 0x0d3f, 0x15a0: 0x0d33, 0x15a1: 0x0d4f, 0x15a2: 0x0d57, 0x15a3: 0x16e7,
+	0x15a4: 0x0d5b, 0x15a5: 0x0d47, 0x15a6: 0x0d63, 0x15a7: 0x0607, 0x15a8: 0x0d67, 0x15a9: 0x0d6b,
+	0x15aa: 0x0d6f, 0x15ab: 0x0d7b, 0x15ac: 0x16ec, 0x15ad: 0x0d83, 0x15ae: 0x060b, 0x15af: 0x0d8f,
+	0x15b0: 0x16f1, 0x15b1: 0x0d93, 0x15b2: 0x060f, 0x15b3: 0x0d9f, 0x15b4: 0x0dab, 0x15b5: 0x0db7,
+	0x15b6: 0x0dbb, 0x15b7: 0x16f6, 0x15b8: 0x168d, 0x15b9: 0x16fb, 0x15ba: 0x0ddb, 0x15bb: 0x1700,
+	0x15bc: 0x0de7, 0x15bd: 0x0def, 0x15be: 0x0ddf, 0x15bf: 0x0dfb,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0x0e0b, 0x15c1: 0x0e1b, 0x15c2: 0x0e0f, 0x15c3: 0x0e13, 0x15c4: 0x0e1f, 0x15c5: 0x0e23,
+	0x15c6: 0x1705, 0x15c7: 0x0e07, 0x15c8: 0x0e3b, 0x15c9: 0x0e3f, 0x15ca: 0x0613, 0x15cb: 0x0e53,
+	0x15cc: 0x0e4f, 0x15cd: 0x170a, 0x15ce: 0x0e33, 0x15cf: 0x0e6f, 0x15d0: 0x170f, 0x15d1: 0x1714,
+	0x15d2: 0x0e73, 0x15d3: 0x0e87, 0x15d4: 0x0e83, 0x15d5: 0x0e7f, 0x15d6: 0x0617, 0x15d7: 0x0e8b,
+	0x15d8: 0x0e9b, 0x15d9: 0x0e97, 0x15da: 0x0ea3, 0x15db: 0x1651, 0x15dc: 0x0eb3, 0x15dd: 0x1719,
+	0x15de: 0x0ebf, 0x15df: 0x1723, 0x15e0: 0x0ed3, 0x15e1: 0x0edf, 0x15e2: 0x0ef3, 0x15e3: 0x1728,
+	0x15e4: 0x0f07, 0x15e5: 0x0f0b, 0x15e6: 0x172d, 0x15e7: 0x1732, 0x15e8: 0x0f27, 0x15e9: 0x0f37,
+	0x15ea: 0x061b, 0x15eb: 0x0f3b, 0x15ec: 0x061f, 0x15ed: 0x061f, 0x15ee: 0x0f53, 0x15ef: 0x0f57,
+	0x15f0: 0x0f5f, 0x15f1: 0x0f63, 0x15f2: 0x0f6f, 0x15f3: 0x0623, 0x15f4: 0x0f87, 0x15f5: 0x1737,
+	0x15f6: 0x0fa3, 0x15f7: 0x173c, 0x15f8: 0x0faf, 0x15f9: 0x16a1, 0x15fa: 0x0fbf, 0x15fb: 0x1741,
+	0x15fc: 0x1746, 0x15fd: 0x174b, 0x15fe: 0x0627, 0x15ff: 0x062b,
+	// Block 0x58, offset 0x1600
+	0x1600: 0x0ff7, 0x1601: 0x1755, 0x1602: 0x1750, 0x1603: 0x175a, 0x1604: 0x175f, 0x1605: 0x0fff,
+	0x1606: 0x1003, 0x1607: 0x1003, 0x1608: 0x100b, 0x1609: 0x0633, 0x160a: 0x100f, 0x160b: 0x0637,
+	0x160c: 0x063b, 0x160d: 0x1769, 0x160e: 0x1023, 0x160f: 0x102b, 0x1610: 0x1037, 0x1611: 0x063f,
+	0x1612: 0x176e, 0x1613: 0x105b, 0x1614: 0x1773, 0x1615: 0x1778, 0x1616: 0x107b, 0x1617: 0x1093,
+	0x1618: 0x0643, 0x1619: 0x109b, 0x161a: 0x109f, 0x161b: 0x10a3, 0x161c: 0x177d, 0x161d: 0x1782,
+	0x161e: 0x1782, 0x161f: 0x10bb, 0x1620: 0x0647, 0x1621: 0x1787, 0x1622: 0x10cf, 0x1623: 0x10d3,
+	0x1624: 0x064b, 0x1625: 0x178c, 0x1626: 0x10ef, 0x1627: 0x064f, 0x1628: 0x10ff, 0x1629: 0x10f7,
+	0x162a: 0x1107, 0x162b: 0x1796, 0x162c: 0x111f, 0x162d: 0x0653, 0x162e: 0x112b, 0x162f: 0x1133,
+	0x1630: 0x1143, 0x1631: 0x0657, 0x1632: 0x17a0, 0x1633: 0x17a5, 0x1634: 0x065b, 0x1635: 0x17aa,
+	0x1636: 0x115b, 0x1637: 0x17af, 0x1638: 0x1167, 0x1639: 0x1173, 0x163a: 0x117b, 0x163b: 0x17b4,
+	0x163c: 0x17b9, 0x163d: 0x118f, 0x163e: 0x17be, 0x163f: 0x1197,
+	// Block 0x59, offset 0x1640
+	0x1640: 0x16ce, 0x1641: 0x065f, 0x1642: 0x11af, 0x1643: 0x11b3, 0x1644: 0x0667, 0x1645: 0x11b7,
+	0x1646: 0x0a33, 0x1647: 0x17c3, 0x1648: 0x17c8, 0x1649: 0x16d3, 0x164a: 0x16d8, 0x164b: 0x11d7,
+	0x164c: 0x11db, 0x164d: 0x13f3, 0x164e: 0x066b, 0x164f: 0x1207, 0x1650: 0x1203, 0x1651: 0x120b,
+	0x1652: 0x083f, 0x1653: 0x120f, 0x1654: 0x1213, 0x1655: 0x1217, 0x1656: 0x121f, 0x1657: 0x17cd,
+	0x1658: 0x121b, 0x1659: 0x1223, 0x165a: 0x1237, 0x165b: 0x123b, 0x165c: 0x1227, 0x165d: 0x123f,
+	0x165e: 0x1253, 0x165f: 0x1267, 0x1660: 0x1233, 0x1661: 0x1247, 0x1662: 0x124b, 0x1663: 0x124f,
+	0x1664: 0x17d2, 0x1665: 0x17dc, 0x1666: 0x17d7, 0x1667: 0x066f, 0x1668: 0x126f, 0x1669: 0x1273,
+	0x166a: 0x127b, 0x166b: 0x17f0, 0x166c: 0x127f, 0x166d: 0x17e1, 0x166e: 0x0673, 0x166f: 0x0677,
+	0x1670: 0x17e6, 0x1671: 0x17eb, 0x1672: 0x067b, 0x1673: 0x129f, 0x1674: 0x12a3, 0x1675: 0x12a7,
+	0x1676: 0x12ab, 0x1677: 0x12b7, 0x1678: 0x12b3, 0x1679: 0x12bf, 0x167a: 0x12bb, 0x167b: 0x12cb,
+	0x167c: 0x12c3, 0x167d: 0x12c7, 0x167e: 0x12cf, 0x167f: 0x067f,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x12d7, 0x1681: 0x12db, 0x1682: 0x0683, 0x1683: 0x12eb, 0x1684: 0x12ef, 0x1685: 0x17f5,
+	0x1686: 0x12fb, 0x1687: 0x12ff, 0x1688: 0x0687, 0x1689: 0x130b, 0x168a: 0x05bb, 0x168b: 0x17fa,
+	0x168c: 0x17ff, 0x168d: 0x068b, 0x168e: 0x068f, 0x168f: 0x1337, 0x1690: 0x134f, 0x1691: 0x136b,
+	0x1692: 0x137b, 0x1693: 0x1804, 0x1694: 0x138f, 0x1695: 0x1393, 0x1696: 0x13ab, 0x1697: 0x13b7,
+	0x1698: 0x180e, 0x1699: 0x1660, 0x169a: 0x13c3, 0x169b: 0x13bf, 0x169c: 0x13cb, 0x169d: 0x1665,
+	0x169e: 0x13d7, 0x169f: 0x13e3, 0x16a0: 0x1813, 0x16a1: 0x1818, 0x16a2: 0x1423, 0x16a3: 0x142f,
+	0x16a4: 0x1437, 0x16a5: 0x181d, 0x16a6: 0x143b, 0x16a7: 0x1467, 0x16a8: 0x1473, 0x16a9: 0x1477,
+	0x16aa: 0x146f, 0x16ab: 0x1483, 0x16ac: 0x1487, 0x16ad: 0x1822, 0x16ae: 0x1493, 0x16af: 0x0693,
+	0x16b0: 0x149b, 0x16b1: 0x1827, 0x16b2: 0x0697, 0x16b3: 0x14d3, 0x16b4: 0x0ac3, 0x16b5: 0x14eb,
+	0x16b6: 0x182c, 0x16b7: 0x1836, 0x16b8: 0x069b, 0x16b9: 0x069f, 0x16ba: 0x1513, 0x16bb: 0x183b,
+	0x16bc: 0x06a3, 0x16bd: 0x1840, 0x16be: 0x152b, 0x16bf: 0x152b,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x1533, 0x16c1: 0x1845, 0x16c2: 0x154b, 0x16c3: 0x06a7, 0x16c4: 0x155b, 0x16c5: 0x1567,
+	0x16c6: 0x156f, 0x16c7: 0x1577, 0x16c8: 0x06ab, 0x16c9: 0x184a, 0x16ca: 0x158b, 0x16cb: 0x15a7,
+	0x16cc: 0x15b3, 0x16cd: 0x06af, 0x16ce: 0x06b3, 0x16cf: 0x15b7, 0x16d0: 0x184f, 0x16d1: 0x06b7,
+	0x16d2: 0x1854, 0x16d3: 0x1859, 0x16d4: 0x185e, 0x16d5: 0x15db, 0x16d6: 0x06bb, 0x16d7: 0x15ef,
+	0x16d8: 0x15f7, 0x16d9: 0x15fb, 0x16da: 0x1603, 0x16db: 0x160b, 0x16dc: 0x1613, 0x16dd: 0x1868,
+}
+
+// nfkcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfkcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x5a, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x5b, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x5c, 0xcb: 0x5d, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x09,
+	0xd0: 0x0a, 0xd1: 0x5e, 0xd2: 0x5f, 0xd3: 0x0b, 0xd6: 0x0c, 0xd7: 0x60,
+	0xd8: 0x61, 0xd9: 0x0d, 0xdb: 0x62, 0xdc: 0x63, 0xdd: 0x64, 0xdf: 0x65,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x66, 0x121: 0x67, 0x123: 0x68, 0x124: 0x69, 0x125: 0x6a, 0x126: 0x6b, 0x127: 0x6c,
+	0x128: 0x6d, 0x129: 0x6e, 0x12a: 0x6f, 0x12b: 0x70, 0x12c: 0x6b, 0x12d: 0x71, 0x12e: 0x72, 0x12f: 0x73,
+	0x131: 0x74, 0x132: 0x75, 0x133: 0x76, 0x134: 0x77, 0x135: 0x78, 0x137: 0x79,
+	0x138: 0x7a, 0x139: 0x7b, 0x13a: 0x7c, 0x13b: 0x7d, 0x13c: 0x7e, 0x13d: 0x7f, 0x13e: 0x80, 0x13f: 0x81,
+	// Block 0x5, offset 0x140
+	0x140: 0x82, 0x142: 0x83, 0x143: 0x84, 0x144: 0x85, 0x145: 0x86, 0x146: 0x87, 0x147: 0x88,
+	0x14d: 0x89,
+	0x15c: 0x8a, 0x15f: 0x8b,
+	0x162: 0x8c, 0x164: 0x8d,
+	0x168: 0x8e, 0x169: 0x8f, 0x16a: 0x90, 0x16c: 0x0e, 0x16d: 0x91, 0x16e: 0x92, 0x16f: 0x93,
+	0x170: 0x94, 0x173: 0x95, 0x174: 0x96, 0x175: 0x0f, 0x176: 0x10, 0x177: 0x97,
+	0x178: 0x11, 0x179: 0x12, 0x17a: 0x13, 0x17b: 0x14, 0x17c: 0x15, 0x17d: 0x16, 0x17e: 0x17, 0x17f: 0x18,
+	// Block 0x6, offset 0x180
+	0x180: 0x98, 0x181: 0x99, 0x182: 0x9a, 0x183: 0x9b, 0x184: 0x19, 0x185: 0x1a, 0x186: 0x9c, 0x187: 0x9d,
+	0x188: 0x9e, 0x189: 0x1b, 0x18a: 0x1c, 0x18b: 0x9f, 0x18c: 0xa0,
+	0x191: 0x1d, 0x192: 0x1e, 0x193: 0xa1,
+	0x1a8: 0xa2, 0x1a9: 0xa3, 0x1ab: 0xa4,
+	0x1b1: 0xa5, 0x1b3: 0xa6, 0x1b5: 0xa7, 0x1b7: 0xa8,
+	0x1ba: 0xa9, 0x1bb: 0xaa, 0x1bc: 0x1f, 0x1bd: 0x20, 0x1be: 0x21, 0x1bf: 0xab,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0xac, 0x1c1: 0x22, 0x1c2: 0x23, 0x1c3: 0x24, 0x1c4: 0xad, 0x1c5: 0x25, 0x1c6: 0x26,
+	0x1c8: 0x27, 0x1c9: 0x28, 0x1ca: 0x29, 0x1cb: 0x2a, 0x1cc: 0x2b, 0x1cd: 0x2c, 0x1ce: 0x2d, 0x1cf: 0x2e,
+	// Block 0x8, offset 0x200
+	0x219: 0xae, 0x21a: 0xaf, 0x21b: 0xb0, 0x21d: 0xb1, 0x21f: 0xb2,
+	0x220: 0xb3, 0x223: 0xb4, 0x224: 0xb5, 0x225: 0xb6, 0x226: 0xb7, 0x227: 0xb8,
+	0x22a: 0xb9, 0x22b: 0xba, 0x22d: 0xbb, 0x22f: 0xbc,
+	0x230: 0xbd, 0x231: 0xbe, 0x232: 0xbf, 0x233: 0xc0, 0x234: 0xc1, 0x235: 0xc2, 0x236: 0xc3, 0x237: 0xbd,
+	0x238: 0xbe, 0x239: 0xbf, 0x23a: 0xc0, 0x23b: 0xc1, 0x23c: 0xc2, 0x23d: 0xc3, 0x23e: 0xbd, 0x23f: 0xbe,
+	// Block 0x9, offset 0x240
+	0x240: 0xbf, 0x241: 0xc0, 0x242: 0xc1, 0x243: 0xc2, 0x244: 0xc3, 0x245: 0xbd, 0x246: 0xbe, 0x247: 0xbf,
+	0x248: 0xc0, 0x249: 0xc1, 0x24a: 0xc2, 0x24b: 0xc3, 0x24c: 0xbd, 0x24d: 0xbe, 0x24e: 0xbf, 0x24f: 0xc0,
+	0x250: 0xc1, 0x251: 0xc2, 0x252: 0xc3, 0x253: 0xbd, 0x254: 0xbe, 0x255: 0xbf, 0x256: 0xc0, 0x257: 0xc1,
+	0x258: 0xc2, 0x259: 0xc3, 0x25a: 0xbd, 0x25b: 0xbe, 0x25c: 0xbf, 0x25d: 0xc0, 0x25e: 0xc1, 0x25f: 0xc2,
+	0x260: 0xc3, 0x261: 0xbd, 0x262: 0xbe, 0x263: 0xbf, 0x264: 0xc0, 0x265: 0xc1, 0x266: 0xc2, 0x267: 0xc3,
+	0x268: 0xbd, 0x269: 0xbe, 0x26a: 0xbf, 0x26b: 0xc0, 0x26c: 0xc1, 0x26d: 0xc2, 0x26e: 0xc3, 0x26f: 0xbd,
+	0x270: 0xbe, 0x271: 0xbf, 0x272: 0xc0, 0x273: 0xc1, 0x274: 0xc2, 0x275: 0xc3, 0x276: 0xbd, 0x277: 0xbe,
+	0x278: 0xbf, 0x279: 0xc0, 0x27a: 0xc1, 0x27b: 0xc2, 0x27c: 0xc3, 0x27d: 0xbd, 0x27e: 0xbe, 0x27f: 0xbf,
+	// Block 0xa, offset 0x280
+	0x280: 0xc0, 0x281: 0xc1, 0x282: 0xc2, 0x283: 0xc3, 0x284: 0xbd, 0x285: 0xbe, 0x286: 0xbf, 0x287: 0xc0,
+	0x288: 0xc1, 0x289: 0xc2, 0x28a: 0xc3, 0x28b: 0xbd, 0x28c: 0xbe, 0x28d: 0xbf, 0x28e: 0xc0, 0x28f: 0xc1,
+	0x290: 0xc2, 0x291: 0xc3, 0x292: 0xbd, 0x293: 0xbe, 0x294: 0xbf, 0x295: 0xc0, 0x296: 0xc1, 0x297: 0xc2,
+	0x298: 0xc3, 0x299: 0xbd, 0x29a: 0xbe, 0x29b: 0xbf, 0x29c: 0xc0, 0x29d: 0xc1, 0x29e: 0xc2, 0x29f: 0xc3,
+	0x2a0: 0xbd, 0x2a1: 0xbe, 0x2a2: 0xbf, 0x2a3: 0xc0, 0x2a4: 0xc1, 0x2a5: 0xc2, 0x2a6: 0xc3, 0x2a7: 0xbd,
+	0x2a8: 0xbe, 0x2a9: 0xbf, 0x2aa: 0xc0, 0x2ab: 0xc1, 0x2ac: 0xc2, 0x2ad: 0xc3, 0x2ae: 0xbd, 0x2af: 0xbe,
+	0x2b0: 0xbf, 0x2b1: 0xc0, 0x2b2: 0xc1, 0x2b3: 0xc2, 0x2b4: 0xc3, 0x2b5: 0xbd, 0x2b6: 0xbe, 0x2b7: 0xbf,
+	0x2b8: 0xc0, 0x2b9: 0xc1, 0x2ba: 0xc2, 0x2bb: 0xc3, 0x2bc: 0xbd, 0x2bd: 0xbe, 0x2be: 0xbf, 0x2bf: 0xc0,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0xc1, 0x2c1: 0xc2, 0x2c2: 0xc3, 0x2c3: 0xbd, 0x2c4: 0xbe, 0x2c5: 0xbf, 0x2c6: 0xc0, 0x2c7: 0xc1,
+	0x2c8: 0xc2, 0x2c9: 0xc3, 0x2ca: 0xbd, 0x2cb: 0xbe, 0x2cc: 0xbf, 0x2cd: 0xc0, 0x2ce: 0xc1, 0x2cf: 0xc2,
+	0x2d0: 0xc3, 0x2d1: 0xbd, 0x2d2: 0xbe, 0x2d3: 0xbf, 0x2d4: 0xc0, 0x2d5: 0xc1, 0x2d6: 0xc2, 0x2d7: 0xc3,
+	0x2d8: 0xbd, 0x2d9: 0xbe, 0x2da: 0xbf, 0x2db: 0xc0, 0x2dc: 0xc1, 0x2dd: 0xc2, 0x2de: 0xc4,
+	// Block 0xc, offset 0x300
+	0x324: 0x2f, 0x325: 0x30, 0x326: 0x31, 0x327: 0x32,
+	0x328: 0x33, 0x329: 0x34, 0x32a: 0x35, 0x32b: 0x36, 0x32c: 0x37, 0x32d: 0x38, 0x32e: 0x39, 0x32f: 0x3a,
+	0x330: 0x3b, 0x331: 0x3c, 0x332: 0x3d, 0x333: 0x3e, 0x334: 0x3f, 0x335: 0x40, 0x336: 0x41, 0x337: 0x42,
+	0x338: 0x43, 0x339: 0x44, 0x33a: 0x45, 0x33b: 0x46, 0x33c: 0xc5, 0x33d: 0x47, 0x33e: 0x48, 0x33f: 0x49,
+	// Block 0xd, offset 0x340
+	0x347: 0xc6,
+	0x34b: 0xc7, 0x34d: 0xc8,
+	0x368: 0xc9, 0x36b: 0xca,
+	// Block 0xe, offset 0x380
+	0x381: 0xcb, 0x382: 0xcc, 0x384: 0xcd, 0x385: 0xb7, 0x387: 0xce,
+	0x388: 0xcf, 0x38b: 0xd0, 0x38c: 0x6b, 0x38d: 0xd1,
+	0x391: 0xd2, 0x392: 0xd3, 0x393: 0xd4, 0x396: 0xd5, 0x397: 0xd6,
+	0x398: 0xd7, 0x39a: 0xd8, 0x39c: 0xd9,
+	0x3b0: 0xd7,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xda, 0x3ec: 0xdb,
+	// Block 0x10, offset 0x400
+	0x432: 0xdc,
+	// Block 0x11, offset 0x440
+	0x445: 0xdd, 0x446: 0xde, 0x447: 0xdf,
+	0x449: 0xe0,
+	0x450: 0xe1, 0x451: 0xe2, 0x452: 0xe3, 0x453: 0xe4, 0x454: 0xe5, 0x455: 0xe6, 0x456: 0xe7, 0x457: 0xe8,
+	0x458: 0xe9, 0x459: 0xea, 0x45a: 0x4a, 0x45b: 0xeb, 0x45c: 0xec, 0x45d: 0xed, 0x45e: 0xee, 0x45f: 0x4b,
+	// Block 0x12, offset 0x480
+	0x480: 0xef,
+	0x4a3: 0xf0, 0x4a5: 0xf1,
+	0x4b8: 0x4c, 0x4b9: 0x4d, 0x4ba: 0x4e,
+	// Block 0x13, offset 0x4c0
+	0x4c4: 0x4f, 0x4c5: 0xf2, 0x4c6: 0xf3,
+	0x4c8: 0x50, 0x4c9: 0xf4,
+	// Block 0x14, offset 0x500
+	0x520: 0x51, 0x521: 0x52, 0x522: 0x53, 0x523: 0x54, 0x524: 0x55, 0x525: 0x56, 0x526: 0x57, 0x527: 0x58,
+	0x528: 0x59,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfkcSparseOffset: 155 entries, 310 bytes
+var nfkcSparseOffset = []uint16{0x0, 0xe, 0x12, 0x1b, 0x25, 0x35, 0x37, 0x3c, 0x47, 0x56, 0x63, 0x6b, 0x6f, 0x74, 0x76, 0x87, 0x8f, 0x96, 0x99, 0xa0, 0xa4, 0xa8, 0xaa, 0xac, 0xb5, 0xb9, 0xc0, 0xc5, 0xc8, 0xd2, 0xd4, 0xdb, 0xe3, 0xe7, 0xe9, 0xec, 0xf0, 0xf6, 0x107, 0x113, 0x115, 0x11b, 0x11d, 0x11f, 0x121, 0x123, 0x125, 0x127, 0x129, 0x12c, 0x12f, 0x131, 0x134, 0x137, 0x13b, 0x140, 0x149, 0x14b, 0x14e, 0x150, 0x15b, 0x166, 0x176, 0x184, 0x192, 0x1a2, 0x1b0, 0x1b7, 0x1bd, 0x1cc, 0x1d0, 0x1d2, 0x1d6, 0x1d8, 0x1db, 0x1dd, 0x1e0, 0x1e2, 0x1e5, 0x1e7, 0x1e9, 0x1eb, 0x1f7, 0x201, 0x20b, 0x20e, 0x212, 0x214, 0x216, 0x218, 0x21a, 0x21d, 0x21f, 0x221, 0x223, 0x225, 0x22b, 0x22e, 0x232, 0x234, 0x23b, 0x241, 0x247, 0x24f, 0x255, 0x25b, 0x261, 0x265, 0x267, 0x269, 0x26b, 0x26d, 0x273, 0x276, 0x279, 0x281, 0x288, 0x28b, 0x28e, 0x290, 0x298, 0x29b, 0x2a2, 0x2a5, 0x2ab, 0x2ad, 0x2af, 0x2b2, 0x2b4, 0x2b6, 0x2b8, 0x2ba, 0x2c7, 0x2d1, 0x2d3, 0x2d5, 0x2d9, 0x2de, 0x2ea, 0x2ef, 0x2f8, 0x2fe, 0x303, 0x307, 0x30c, 0x310, 0x320, 0x32e, 0x33c, 0x34a, 0x350, 0x352, 0x355, 0x35f, 0x361}
+
+// nfkcSparseValues: 875 entries, 3500 bytes
+var nfkcSparseValues = [875]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x0001, lo: 0xa0, hi: 0xa0},
+	{value: 0x4278, lo: 0xa8, hi: 0xa8},
+	{value: 0x0083, lo: 0xaa, hi: 0xaa},
+	{value: 0x4264, lo: 0xaf, hi: 0xaf},
+	{value: 0x0025, lo: 0xb2, hi: 0xb3},
+	{value: 0x425a, lo: 0xb4, hi: 0xb4},
+	{value: 0x01dc, lo: 0xb5, hi: 0xb5},
+	{value: 0x4291, lo: 0xb8, hi: 0xb8},
+	{value: 0x0023, lo: 0xb9, hi: 0xb9},
+	{value: 0x009f, lo: 0xba, hi: 0xba},
+	{value: 0x221c, lo: 0xbc, hi: 0xbc},
+	{value: 0x2210, lo: 0xbd, hi: 0xbd},
+	{value: 0x22b2, lo: 0xbe, hi: 0xbe},
+	// Block 0x1, offset 0xe
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x12
+	{value: 0x0003, lo: 0x08},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x0091, lo: 0xb0, hi: 0xb0},
+	{value: 0x0119, lo: 0xb1, hi: 0xb1},
+	{value: 0x0095, lo: 0xb2, hi: 0xb2},
+	{value: 0x00a5, lo: 0xb3, hi: 0xb3},
+	{value: 0x0143, lo: 0xb4, hi: 0xb6},
+	{value: 0x00af, lo: 0xb7, hi: 0xb7},
+	{value: 0x00b3, lo: 0xb8, hi: 0xb8},
+	// Block 0x3, offset 0x1b
+	{value: 0x000a, lo: 0x09},
+	{value: 0x426e, lo: 0x98, hi: 0x98},
+	{value: 0x4273, lo: 0x99, hi: 0x9a},
+	{value: 0x4296, lo: 0x9b, hi: 0x9b},
+	{value: 0x425f, lo: 0x9c, hi: 0x9c},
+	{value: 0x4282, lo: 0x9d, hi: 0x9d},
+	{value: 0x0113, lo: 0xa0, hi: 0xa0},
+	{value: 0x0099, lo: 0xa1, hi: 0xa1},
+	{value: 0x00a7, lo: 0xa2, hi: 0xa3},
+	{value: 0x0167, lo: 0xa4, hi: 0xa4},
+	// Block 0x4, offset 0x25
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x5, offset 0x35
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x6, offset 0x37
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x7, offset 0x3c
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x8, offset 0x47
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0x9, offset 0x56
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xa, offset 0x63
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xb, offset 0x6b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xc, offset 0x6f
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xd, offset 0x74
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xe, offset 0x76
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0xf, offset 0x87
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x10, offset 0x8f
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x11, offset 0x96
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x12, offset 0x99
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x13, offset 0xa0
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x14, offset 0xa4
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x15, offset 0xa8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x16, offset 0xaa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x17, offset 0xac
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x18, offset 0xb5
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x19, offset 0xb9
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1a, offset 0xc0
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1b, offset 0xc5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1c, offset 0xc8
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1d, offset 0xd2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1e, offset 0xd4
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1f, offset 0xdb
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x20, offset 0xe3
+	{value: 0x0000, lo: 0x03},
+	{value: 0x2621, lo: 0xb3, hi: 0xb3},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x21, offset 0xe7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x22, offset 0xe9
+	{value: 0x0000, lo: 0x02},
+	{value: 0x2636, lo: 0xb3, hi: 0xb3},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x23, offset 0xec
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	{value: 0x2628, lo: 0x9c, hi: 0x9c},
+	{value: 0x262f, lo: 0x9d, hi: 0x9d},
+	// Block 0x24, offset 0xf0
+	{value: 0x0000, lo: 0x05},
+	{value: 0x030b, lo: 0x8c, hi: 0x8c},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x25, offset 0xf6
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x45f4, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x45ff, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x26, offset 0x107
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x27, offset 0x113
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x28, offset 0x115
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x29, offset 0x11b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2a, offset 0x11d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x030f, lo: 0xbc, hi: 0xbc},
+	// Block 0x2b, offset 0x11f
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x121
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x123
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x125
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x127
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x129
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x12c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x12f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x131
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x134
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x137
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x13b
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x140
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x149
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x14b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x14e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x150
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x15b
+	{value: 0x0002, lo: 0x0a},
+	{value: 0x0043, lo: 0xac, hi: 0xac},
+	{value: 0x00d1, lo: 0xad, hi: 0xad},
+	{value: 0x0045, lo: 0xae, hi: 0xae},
+	{value: 0x0049, lo: 0xb0, hi: 0xb1},
+	{value: 0x00e6, lo: 0xb2, hi: 0xb2},
+	{value: 0x004f, lo: 0xb3, hi: 0xba},
+	{value: 0x005f, lo: 0xbc, hi: 0xbc},
+	{value: 0x00ef, lo: 0xbd, hi: 0xbd},
+	{value: 0x0061, lo: 0xbe, hi: 0xbe},
+	{value: 0x0065, lo: 0xbf, hi: 0xbf},
+	// Block 0x3d, offset 0x166
+	{value: 0x0000, lo: 0x0f},
+	{value: 0x8132, lo: 0x80, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x82},
+	{value: 0x8132, lo: 0x83, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8a},
+	{value: 0x8132, lo: 0x8b, hi: 0x8c},
+	{value: 0x8135, lo: 0x8d, hi: 0x8d},
+	{value: 0x812a, lo: 0x8e, hi: 0x8e},
+	{value: 0x812d, lo: 0x8f, hi: 0x8f},
+	{value: 0x8129, lo: 0x90, hi: 0x90},
+	{value: 0x8132, lo: 0x91, hi: 0xb5},
+	{value: 0x8132, lo: 0xbb, hi: 0xbb},
+	{value: 0x8134, lo: 0xbc, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	{value: 0x8132, lo: 0xbe, hi: 0xbe},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x3e, offset 0x176
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x0001, lo: 0x80, hi: 0x8a},
+	{value: 0x043b, lo: 0x91, hi: 0x91},
+	{value: 0x429b, lo: 0x97, hi: 0x97},
+	{value: 0x001d, lo: 0xa4, hi: 0xa4},
+	{value: 0x1873, lo: 0xa5, hi: 0xa5},
+	{value: 0x1b5c, lo: 0xa6, hi: 0xa6},
+	{value: 0x0001, lo: 0xaf, hi: 0xaf},
+	{value: 0x2691, lo: 0xb3, hi: 0xb3},
+	{value: 0x27fe, lo: 0xb4, hi: 0xb4},
+	{value: 0x2698, lo: 0xb6, hi: 0xb6},
+	{value: 0x2808, lo: 0xb7, hi: 0xb7},
+	{value: 0x186d, lo: 0xbc, hi: 0xbc},
+	{value: 0x4269, lo: 0xbe, hi: 0xbe},
+	// Block 0x3f, offset 0x184
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x1933, lo: 0x87, hi: 0x87},
+	{value: 0x1930, lo: 0x88, hi: 0x88},
+	{value: 0x1870, lo: 0x89, hi: 0x89},
+	{value: 0x298e, lo: 0x97, hi: 0x97},
+	{value: 0x0001, lo: 0x9f, hi: 0x9f},
+	{value: 0x0021, lo: 0xb0, hi: 0xb0},
+	{value: 0x0093, lo: 0xb1, hi: 0xb1},
+	{value: 0x0029, lo: 0xb4, hi: 0xb9},
+	{value: 0x0017, lo: 0xba, hi: 0xba},
+	{value: 0x0467, lo: 0xbb, hi: 0xbb},
+	{value: 0x003b, lo: 0xbc, hi: 0xbc},
+	{value: 0x0011, lo: 0xbd, hi: 0xbe},
+	{value: 0x009d, lo: 0xbf, hi: 0xbf},
+	// Block 0x40, offset 0x192
+	{value: 0x0002, lo: 0x0f},
+	{value: 0x0021, lo: 0x80, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8a},
+	{value: 0x0467, lo: 0x8b, hi: 0x8b},
+	{value: 0x003b, lo: 0x8c, hi: 0x8c},
+	{value: 0x0011, lo: 0x8d, hi: 0x8e},
+	{value: 0x0083, lo: 0x90, hi: 0x90},
+	{value: 0x008b, lo: 0x91, hi: 0x91},
+	{value: 0x009f, lo: 0x92, hi: 0x92},
+	{value: 0x00b1, lo: 0x93, hi: 0x93},
+	{value: 0x0104, lo: 0x94, hi: 0x94},
+	{value: 0x0091, lo: 0x95, hi: 0x95},
+	{value: 0x0097, lo: 0x96, hi: 0x99},
+	{value: 0x00a1, lo: 0x9a, hi: 0x9a},
+	{value: 0x00a7, lo: 0x9b, hi: 0x9c},
+	{value: 0x1999, lo: 0xa8, hi: 0xa8},
+	// Block 0x41, offset 0x1a2
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x42, offset 0x1b0
+	{value: 0x0007, lo: 0x06},
+	{value: 0x2180, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x43, offset 0x1b7
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x44, offset 0x1bd
+	{value: 0x0173, lo: 0x0e},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa4},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0x269f, lo: 0xac, hi: 0xad},
+	{value: 0x26a6, lo: 0xaf, hi: 0xaf},
+	{value: 0x281c, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x45, offset 0x1cc
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x46, offset 0x1d0
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x47, offset 0x1d2
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0057, lo: 0x80, hi: 0x8f},
+	{value: 0x0083, lo: 0x90, hi: 0xa9},
+	{value: 0x0021, lo: 0xaa, hi: 0xaa},
+	// Block 0x48, offset 0x1d6
+	{value: 0x0000, lo: 0x01},
+	{value: 0x299b, lo: 0x8c, hi: 0x8c},
+	// Block 0x49, offset 0x1d8
+	{value: 0x0263, lo: 0x02},
+	{value: 0x1b8c, lo: 0xb4, hi: 0xb4},
+	{value: 0x192d, lo: 0xb5, hi: 0xb6},
+	// Block 0x4a, offset 0x1db
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x4b, offset 0x1dd
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0095, lo: 0xbc, hi: 0xbc},
+	{value: 0x006d, lo: 0xbd, hi: 0xbd},
+	// Block 0x4c, offset 0x1e0
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x4d, offset 0x1e2
+	{value: 0x0000, lo: 0x02},
+	{value: 0x047f, lo: 0xaf, hi: 0xaf},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x4e, offset 0x1e5
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x4f, offset 0x1e7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0dc3, lo: 0x9f, hi: 0x9f},
+	// Block 0x50, offset 0x1e9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x162f, lo: 0xb3, hi: 0xb3},
+	// Block 0x51, offset 0x1eb
+	{value: 0x0004, lo: 0x0b},
+	{value: 0x1597, lo: 0x80, hi: 0x82},
+	{value: 0x15af, lo: 0x83, hi: 0x83},
+	{value: 0x15c7, lo: 0x84, hi: 0x85},
+	{value: 0x15d7, lo: 0x86, hi: 0x89},
+	{value: 0x15eb, lo: 0x8a, hi: 0x8c},
+	{value: 0x15ff, lo: 0x8d, hi: 0x8d},
+	{value: 0x1607, lo: 0x8e, hi: 0x8e},
+	{value: 0x160f, lo: 0x8f, hi: 0x90},
+	{value: 0x161b, lo: 0x91, hi: 0x93},
+	{value: 0x162b, lo: 0x94, hi: 0x94},
+	{value: 0x1633, lo: 0x95, hi: 0x95},
+	// Block 0x52, offset 0x1f7
+	{value: 0x0004, lo: 0x09},
+	{value: 0x0001, lo: 0x80, hi: 0x80},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xae},
+	{value: 0x812f, lo: 0xaf, hi: 0xaf},
+	{value: 0x04b3, lo: 0xb6, hi: 0xb6},
+	{value: 0x0887, lo: 0xb8, hi: 0xba},
+	// Block 0x53, offset 0x201
+	{value: 0x0006, lo: 0x09},
+	{value: 0x0313, lo: 0xb1, hi: 0xb1},
+	{value: 0x0317, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a3b, lo: 0xb3, hi: 0xb3},
+	{value: 0x031b, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a41, lo: 0xb5, hi: 0xb6},
+	{value: 0x031f, lo: 0xb7, hi: 0xb7},
+	{value: 0x0323, lo: 0xb8, hi: 0xb8},
+	{value: 0x0327, lo: 0xb9, hi: 0xb9},
+	{value: 0x4a4d, lo: 0xba, hi: 0xbf},
+	// Block 0x54, offset 0x20b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x55, offset 0x20e
+	{value: 0x0000, lo: 0x03},
+	{value: 0x020f, lo: 0x9c, hi: 0x9c},
+	{value: 0x0212, lo: 0x9d, hi: 0x9d},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x56, offset 0x212
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x57, offset 0x214
+	{value: 0x0000, lo: 0x01},
+	{value: 0x163b, lo: 0xb0, hi: 0xb0},
+	// Block 0x58, offset 0x216
+	{value: 0x000c, lo: 0x01},
+	{value: 0x00d7, lo: 0xb8, hi: 0xb9},
+	// Block 0x59, offset 0x218
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x5a, offset 0x21a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x5b, offset 0x21d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x5c, offset 0x21f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x5d, offset 0x221
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x5e, offset 0x223
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x5f, offset 0x225
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x60, offset 0x22b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x61, offset 0x22e
+	{value: 0x0008, lo: 0x03},
+	{value: 0x1637, lo: 0x9c, hi: 0x9d},
+	{value: 0x0125, lo: 0x9e, hi: 0x9e},
+	{value: 0x1643, lo: 0x9f, hi: 0x9f},
+	// Block 0x62, offset 0x232
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x63, offset 0x234
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x64, offset 0x23b
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x65, offset 0x241
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x66, offset 0x247
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x67, offset 0x24f
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x68, offset 0x255
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x69, offset 0x25b
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x6a, offset 0x261
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x6b, offset 0x265
+	{value: 0x0002, lo: 0x01},
+	{value: 0x0003, lo: 0x81, hi: 0xbf},
+	// Block 0x6c, offset 0x267
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x6d, offset 0x269
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x6e, offset 0x26b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x6f, offset 0x26d
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x70, offset 0x273
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x71, offset 0x276
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x72, offset 0x279
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x73, offset 0x281
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x74, offset 0x288
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x75, offset 0x28b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x76, offset 0x28e
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x77, offset 0x290
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x78, offset 0x298
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x79, offset 0x29b
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x7a, offset 0x2a2
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7b, offset 0x2a5
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7c, offset 0x2ab
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x7d, offset 0x2ad
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7e, offset 0x2af
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x7f, offset 0x2b2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x80, offset 0x2b4
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x81, offset 0x2b6
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x82, offset 0x2b8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x83, offset 0x2ba
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x84, offset 0x2c7
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x85, offset 0x2d1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x86, offset 0x2d3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x87, offset 0x2d5
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0043, lo: 0x80, hi: 0x99},
+	{value: 0x0083, lo: 0x9a, hi: 0xb3},
+	{value: 0x0043, lo: 0xb4, hi: 0xbf},
+	// Block 0x88, offset 0x2d9
+	{value: 0x0002, lo: 0x04},
+	{value: 0x005b, lo: 0x80, hi: 0x8d},
+	{value: 0x0083, lo: 0x8e, hi: 0x94},
+	{value: 0x0093, lo: 0x96, hi: 0xa7},
+	{value: 0x0043, lo: 0xa8, hi: 0xbf},
+	// Block 0x89, offset 0x2de
+	{value: 0x0002, lo: 0x0b},
+	{value: 0x0073, lo: 0x80, hi: 0x81},
+	{value: 0x0083, lo: 0x82, hi: 0x9b},
+	{value: 0x0043, lo: 0x9c, hi: 0x9c},
+	{value: 0x0047, lo: 0x9e, hi: 0x9f},
+	{value: 0x004f, lo: 0xa2, hi: 0xa2},
+	{value: 0x0055, lo: 0xa5, hi: 0xa6},
+	{value: 0x005d, lo: 0xa9, hi: 0xac},
+	{value: 0x0067, lo: 0xae, hi: 0xb5},
+	{value: 0x0083, lo: 0xb6, hi: 0xb9},
+	{value: 0x008d, lo: 0xbb, hi: 0xbb},
+	{value: 0x0091, lo: 0xbd, hi: 0xbf},
+	// Block 0x8a, offset 0x2ea
+	{value: 0x0002, lo: 0x04},
+	{value: 0x0097, lo: 0x80, hi: 0x83},
+	{value: 0x00a1, lo: 0x85, hi: 0x8f},
+	{value: 0x0043, lo: 0x90, hi: 0xa9},
+	{value: 0x0083, lo: 0xaa, hi: 0xbf},
+	// Block 0x8b, offset 0x2ef
+	{value: 0x0002, lo: 0x08},
+	{value: 0x00af, lo: 0x80, hi: 0x83},
+	{value: 0x0043, lo: 0x84, hi: 0x85},
+	{value: 0x0049, lo: 0x87, hi: 0x8a},
+	{value: 0x0055, lo: 0x8d, hi: 0x94},
+	{value: 0x0067, lo: 0x96, hi: 0x9c},
+	{value: 0x0083, lo: 0x9e, hi: 0xb7},
+	{value: 0x0043, lo: 0xb8, hi: 0xb9},
+	{value: 0x0049, lo: 0xbb, hi: 0xbe},
+	// Block 0x8c, offset 0x2f8
+	{value: 0x0002, lo: 0x05},
+	{value: 0x0053, lo: 0x80, hi: 0x84},
+	{value: 0x005f, lo: 0x86, hi: 0x86},
+	{value: 0x0067, lo: 0x8a, hi: 0x90},
+	{value: 0x0083, lo: 0x92, hi: 0xab},
+	{value: 0x0043, lo: 0xac, hi: 0xbf},
+	// Block 0x8d, offset 0x2fe
+	{value: 0x0002, lo: 0x04},
+	{value: 0x006b, lo: 0x80, hi: 0x85},
+	{value: 0x0083, lo: 0x86, hi: 0x9f},
+	{value: 0x0043, lo: 0xa0, hi: 0xb9},
+	{value: 0x0083, lo: 0xba, hi: 0xbf},
+	// Block 0x8e, offset 0x303
+	{value: 0x0002, lo: 0x03},
+	{value: 0x008f, lo: 0x80, hi: 0x93},
+	{value: 0x0043, lo: 0x94, hi: 0xad},
+	{value: 0x0083, lo: 0xae, hi: 0xbf},
+	// Block 0x8f, offset 0x307
+	{value: 0x0002, lo: 0x04},
+	{value: 0x00a7, lo: 0x80, hi: 0x87},
+	{value: 0x0043, lo: 0x88, hi: 0xa1},
+	{value: 0x0083, lo: 0xa2, hi: 0xbb},
+	{value: 0x0043, lo: 0xbc, hi: 0xbf},
+	// Block 0x90, offset 0x30c
+	{value: 0x0002, lo: 0x03},
+	{value: 0x004b, lo: 0x80, hi: 0x95},
+	{value: 0x0083, lo: 0x96, hi: 0xaf},
+	{value: 0x0043, lo: 0xb0, hi: 0xbf},
+	// Block 0x91, offset 0x310
+	{value: 0x0003, lo: 0x0f},
+	{value: 0x01b8, lo: 0x80, hi: 0x80},
+	{value: 0x045f, lo: 0x81, hi: 0x81},
+	{value: 0x01bb, lo: 0x82, hi: 0x9a},
+	{value: 0x045b, lo: 0x9b, hi: 0x9b},
+	{value: 0x01c7, lo: 0x9c, hi: 0x9c},
+	{value: 0x01d0, lo: 0x9d, hi: 0x9d},
+	{value: 0x01d6, lo: 0x9e, hi: 0x9e},
+	{value: 0x01fa, lo: 0x9f, hi: 0x9f},
+	{value: 0x01eb, lo: 0xa0, hi: 0xa0},
+	{value: 0x01e8, lo: 0xa1, hi: 0xa1},
+	{value: 0x0173, lo: 0xa2, hi: 0xb2},
+	{value: 0x0188, lo: 0xb3, hi: 0xb3},
+	{value: 0x01a6, lo: 0xb4, hi: 0xba},
+	{value: 0x045f, lo: 0xbb, hi: 0xbb},
+	{value: 0x01bb, lo: 0xbc, hi: 0xbf},
+	// Block 0x92, offset 0x320
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01c7, lo: 0x80, hi: 0x94},
+	{value: 0x045b, lo: 0x95, hi: 0x95},
+	{value: 0x01c7, lo: 0x96, hi: 0x96},
+	{value: 0x01d0, lo: 0x97, hi: 0x97},
+	{value: 0x01d6, lo: 0x98, hi: 0x98},
+	{value: 0x01fa, lo: 0x99, hi: 0x99},
+	{value: 0x01eb, lo: 0x9a, hi: 0x9a},
+	{value: 0x01e8, lo: 0x9b, hi: 0x9b},
+	{value: 0x0173, lo: 0x9c, hi: 0xac},
+	{value: 0x0188, lo: 0xad, hi: 0xad},
+	{value: 0x01a6, lo: 0xae, hi: 0xb4},
+	{value: 0x045f, lo: 0xb5, hi: 0xb5},
+	{value: 0x01bb, lo: 0xb6, hi: 0xbf},
+	// Block 0x93, offset 0x32e
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01d9, lo: 0x80, hi: 0x8e},
+	{value: 0x045b, lo: 0x8f, hi: 0x8f},
+	{value: 0x01c7, lo: 0x90, hi: 0x90},
+	{value: 0x01d0, lo: 0x91, hi: 0x91},
+	{value: 0x01d6, lo: 0x92, hi: 0x92},
+	{value: 0x01fa, lo: 0x93, hi: 0x93},
+	{value: 0x01eb, lo: 0x94, hi: 0x94},
+	{value: 0x01e8, lo: 0x95, hi: 0x95},
+	{value: 0x0173, lo: 0x96, hi: 0xa6},
+	{value: 0x0188, lo: 0xa7, hi: 0xa7},
+	{value: 0x01a6, lo: 0xa8, hi: 0xae},
+	{value: 0x045f, lo: 0xaf, hi: 0xaf},
+	{value: 0x01bb, lo: 0xb0, hi: 0xbf},
+	// Block 0x94, offset 0x33c
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01eb, lo: 0x80, hi: 0x88},
+	{value: 0x045b, lo: 0x89, hi: 0x89},
+	{value: 0x01c7, lo: 0x8a, hi: 0x8a},
+	{value: 0x01d0, lo: 0x8b, hi: 0x8b},
+	{value: 0x01d6, lo: 0x8c, hi: 0x8c},
+	{value: 0x01fa, lo: 0x8d, hi: 0x8d},
+	{value: 0x01eb, lo: 0x8e, hi: 0x8e},
+	{value: 0x01e8, lo: 0x8f, hi: 0x8f},
+	{value: 0x0173, lo: 0x90, hi: 0xa0},
+	{value: 0x0188, lo: 0xa1, hi: 0xa1},
+	{value: 0x01a6, lo: 0xa2, hi: 0xa8},
+	{value: 0x045f, lo: 0xa9, hi: 0xa9},
+	{value: 0x01bb, lo: 0xaa, hi: 0xbf},
+	// Block 0x95, offset 0x34a
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x96, offset 0x350
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x97, offset 0x352
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x98, offset 0x355
+	{value: 0x0002, lo: 0x09},
+	{value: 0x0063, lo: 0x80, hi: 0x89},
+	{value: 0x1951, lo: 0x8a, hi: 0x8a},
+	{value: 0x1981, lo: 0x8b, hi: 0x8b},
+	{value: 0x199c, lo: 0x8c, hi: 0x8c},
+	{value: 0x19a2, lo: 0x8d, hi: 0x8d},
+	{value: 0x1bc0, lo: 0x8e, hi: 0x8e},
+	{value: 0x19ae, lo: 0x8f, hi: 0x8f},
+	{value: 0x197b, lo: 0xaa, hi: 0xaa},
+	{value: 0x197e, lo: 0xab, hi: 0xab},
+	// Block 0x99, offset 0x35f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x193f, lo: 0x90, hi: 0x90},
+	// Block 0x9a, offset 0x361
+	{value: 0x0028, lo: 0x09},
+	{value: 0x2862, lo: 0x80, hi: 0x80},
+	{value: 0x2826, lo: 0x81, hi: 0x81},
+	{value: 0x2830, lo: 0x82, hi: 0x82},
+	{value: 0x2844, lo: 0x83, hi: 0x84},
+	{value: 0x284e, lo: 0x85, hi: 0x86},
+	{value: 0x283a, lo: 0x87, hi: 0x87},
+	{value: 0x2858, lo: 0x88, hi: 0x88},
+	{value: 0x0b6f, lo: 0x90, hi: 0x90},
+	{value: 0x08e7, lo: 0x91, hi: 0x91},
+}
+
+// recompMap: 7520 bytes (entries only)
+var recompMap = map[uint32]rune{
+	0x00410300: 0x00C0,
+	0x00410301: 0x00C1,
+	0x00410302: 0x00C2,
+	0x00410303: 0x00C3,
+	0x00410308: 0x00C4,
+	0x0041030A: 0x00C5,
+	0x00430327: 0x00C7,
+	0x00450300: 0x00C8,
+	0x00450301: 0x00C9,
+	0x00450302: 0x00CA,
+	0x00450308: 0x00CB,
+	0x00490300: 0x00CC,
+	0x00490301: 0x00CD,
+	0x00490302: 0x00CE,
+	0x00490308: 0x00CF,
+	0x004E0303: 0x00D1,
+	0x004F0300: 0x00D2,
+	0x004F0301: 0x00D3,
+	0x004F0302: 0x00D4,
+	0x004F0303: 0x00D5,
+	0x004F0308: 0x00D6,
+	0x00550300: 0x00D9,
+	0x00550301: 0x00DA,
+	0x00550302: 0x00DB,
+	0x00550308: 0x00DC,
+	0x00590301: 0x00DD,
+	0x00610300: 0x00E0,
+	0x00610301: 0x00E1,
+	0x00610302: 0x00E2,
+	0x00610303: 0x00E3,
+	0x00610308: 0x00E4,
+	0x0061030A: 0x00E5,
+	0x00630327: 0x00E7,
+	0x00650300: 0x00E8,
+	0x00650301: 0x00E9,
+	0x00650302: 0x00EA,
+	0x00650308: 0x00EB,
+	0x00690300: 0x00EC,
+	0x00690301: 0x00ED,
+	0x00690302: 0x00EE,
+	0x00690308: 0x00EF,
+	0x006E0303: 0x00F1,
+	0x006F0300: 0x00F2,
+	0x006F0301: 0x00F3,
+	0x006F0302: 0x00F4,
+	0x006F0303: 0x00F5,
+	0x006F0308: 0x00F6,
+	0x00750300: 0x00F9,
+	0x00750301: 0x00FA,
+	0x00750302: 0x00FB,
+	0x00750308: 0x00FC,
+	0x00790301: 0x00FD,
+	0x00790308: 0x00FF,
+	0x00410304: 0x0100,
+	0x00610304: 0x0101,
+	0x00410306: 0x0102,
+	0x00610306: 0x0103,
+	0x00410328: 0x0104,
+	0x00610328: 0x0105,
+	0x00430301: 0x0106,
+	0x00630301: 0x0107,
+	0x00430302: 0x0108,
+	0x00630302: 0x0109,
+	0x00430307: 0x010A,
+	0x00630307: 0x010B,
+	0x0043030C: 0x010C,
+	0x0063030C: 0x010D,
+	0x0044030C: 0x010E,
+	0x0064030C: 0x010F,
+	0x00450304: 0x0112,
+	0x00650304: 0x0113,
+	0x00450306: 0x0114,
+	0x00650306: 0x0115,
+	0x00450307: 0x0116,
+	0x00650307: 0x0117,
+	0x00450328: 0x0118,
+	0x00650328: 0x0119,
+	0x0045030C: 0x011A,
+	0x0065030C: 0x011B,
+	0x00470302: 0x011C,
+	0x00670302: 0x011D,
+	0x00470306: 0x011E,
+	0x00670306: 0x011F,
+	0x00470307: 0x0120,
+	0x00670307: 0x0121,
+	0x00470327: 0x0122,
+	0x00670327: 0x0123,
+	0x00480302: 0x0124,
+	0x00680302: 0x0125,
+	0x00490303: 0x0128,
+	0x00690303: 0x0129,
+	0x00490304: 0x012A,
+	0x00690304: 0x012B,
+	0x00490306: 0x012C,
+	0x00690306: 0x012D,
+	0x00490328: 0x012E,
+	0x00690328: 0x012F,
+	0x00490307: 0x0130,
+	0x004A0302: 0x0134,
+	0x006A0302: 0x0135,
+	0x004B0327: 0x0136,
+	0x006B0327: 0x0137,
+	0x004C0301: 0x0139,
+	0x006C0301: 0x013A,
+	0x004C0327: 0x013B,
+	0x006C0327: 0x013C,
+	0x004C030C: 0x013D,
+	0x006C030C: 0x013E,
+	0x004E0301: 0x0143,
+	0x006E0301: 0x0144,
+	0x004E0327: 0x0145,
+	0x006E0327: 0x0146,
+	0x004E030C: 0x0147,
+	0x006E030C: 0x0148,
+	0x004F0304: 0x014C,
+	0x006F0304: 0x014D,
+	0x004F0306: 0x014E,
+	0x006F0306: 0x014F,
+	0x004F030B: 0x0150,
+	0x006F030B: 0x0151,
+	0x00520301: 0x0154,
+	0x00720301: 0x0155,
+	0x00520327: 0x0156,
+	0x00720327: 0x0157,
+	0x0052030C: 0x0158,
+	0x0072030C: 0x0159,
+	0x00530301: 0x015A,
+	0x00730301: 0x015B,
+	0x00530302: 0x015C,
+	0x00730302: 0x015D,
+	0x00530327: 0x015E,
+	0x00730327: 0x015F,
+	0x0053030C: 0x0160,
+	0x0073030C: 0x0161,
+	0x00540327: 0x0162,
+	0x00740327: 0x0163,
+	0x0054030C: 0x0164,
+	0x0074030C: 0x0165,
+	0x00550303: 0x0168,
+	0x00750303: 0x0169,
+	0x00550304: 0x016A,
+	0x00750304: 0x016B,
+	0x00550306: 0x016C,
+	0x00750306: 0x016D,
+	0x0055030A: 0x016E,
+	0x0075030A: 0x016F,
+	0x0055030B: 0x0170,
+	0x0075030B: 0x0171,
+	0x00550328: 0x0172,
+	0x00750328: 0x0173,
+	0x00570302: 0x0174,
+	0x00770302: 0x0175,
+	0x00590302: 0x0176,
+	0x00790302: 0x0177,
+	0x00590308: 0x0178,
+	0x005A0301: 0x0179,
+	0x007A0301: 0x017A,
+	0x005A0307: 0x017B,
+	0x007A0307: 0x017C,
+	0x005A030C: 0x017D,
+	0x007A030C: 0x017E,
+	0x004F031B: 0x01A0,
+	0x006F031B: 0x01A1,
+	0x0055031B: 0x01AF,
+	0x0075031B: 0x01B0,
+	0x0041030C: 0x01CD,
+	0x0061030C: 0x01CE,
+	0x0049030C: 0x01CF,
+	0x0069030C: 0x01D0,
+	0x004F030C: 0x01D1,
+	0x006F030C: 0x01D2,
+	0x0055030C: 0x01D3,
+	0x0075030C: 0x01D4,
+	0x00DC0304: 0x01D5,
+	0x00FC0304: 0x01D6,
+	0x00DC0301: 0x01D7,
+	0x00FC0301: 0x01D8,
+	0x00DC030C: 0x01D9,
+	0x00FC030C: 0x01DA,
+	0x00DC0300: 0x01DB,
+	0x00FC0300: 0x01DC,
+	0x00C40304: 0x01DE,
+	0x00E40304: 0x01DF,
+	0x02260304: 0x01E0,
+	0x02270304: 0x01E1,
+	0x00C60304: 0x01E2,
+	0x00E60304: 0x01E3,
+	0x0047030C: 0x01E6,
+	0x0067030C: 0x01E7,
+	0x004B030C: 0x01E8,
+	0x006B030C: 0x01E9,
+	0x004F0328: 0x01EA,
+	0x006F0328: 0x01EB,
+	0x01EA0304: 0x01EC,
+	0x01EB0304: 0x01ED,
+	0x01B7030C: 0x01EE,
+	0x0292030C: 0x01EF,
+	0x006A030C: 0x01F0,
+	0x00470301: 0x01F4,
+	0x00670301: 0x01F5,
+	0x004E0300: 0x01F8,
+	0x006E0300: 0x01F9,
+	0x00C50301: 0x01FA,
+	0x00E50301: 0x01FB,
+	0x00C60301: 0x01FC,
+	0x00E60301: 0x01FD,
+	0x00D80301: 0x01FE,
+	0x00F80301: 0x01FF,
+	0x0041030F: 0x0200,
+	0x0061030F: 0x0201,
+	0x00410311: 0x0202,
+	0x00610311: 0x0203,
+	0x0045030F: 0x0204,
+	0x0065030F: 0x0205,
+	0x00450311: 0x0206,
+	0x00650311: 0x0207,
+	0x0049030F: 0x0208,
+	0x0069030F: 0x0209,
+	0x00490311: 0x020A,
+	0x00690311: 0x020B,
+	0x004F030F: 0x020C,
+	0x006F030F: 0x020D,
+	0x004F0311: 0x020E,
+	0x006F0311: 0x020F,
+	0x0052030F: 0x0210,
+	0x0072030F: 0x0211,
+	0x00520311: 0x0212,
+	0x00720311: 0x0213,
+	0x0055030F: 0x0214,
+	0x0075030F: 0x0215,
+	0x00550311: 0x0216,
+	0x00750311: 0x0217,
+	0x00530326: 0x0218,
+	0x00730326: 0x0219,
+	0x00540326: 0x021A,
+	0x00740326: 0x021B,
+	0x0048030C: 0x021E,
+	0x0068030C: 0x021F,
+	0x00410307: 0x0226,
+	0x00610307: 0x0227,
+	0x00450327: 0x0228,
+	0x00650327: 0x0229,
+	0x00D60304: 0x022A,
+	0x00F60304: 0x022B,
+	0x00D50304: 0x022C,
+	0x00F50304: 0x022D,
+	0x004F0307: 0x022E,
+	0x006F0307: 0x022F,
+	0x022E0304: 0x0230,
+	0x022F0304: 0x0231,
+	0x00590304: 0x0232,
+	0x00790304: 0x0233,
+	0x00A80301: 0x0385,
+	0x03910301: 0x0386,
+	0x03950301: 0x0388,
+	0x03970301: 0x0389,
+	0x03990301: 0x038A,
+	0x039F0301: 0x038C,
+	0x03A50301: 0x038E,
+	0x03A90301: 0x038F,
+	0x03CA0301: 0x0390,
+	0x03990308: 0x03AA,
+	0x03A50308: 0x03AB,
+	0x03B10301: 0x03AC,
+	0x03B50301: 0x03AD,
+	0x03B70301: 0x03AE,
+	0x03B90301: 0x03AF,
+	0x03CB0301: 0x03B0,
+	0x03B90308: 0x03CA,
+	0x03C50308: 0x03CB,
+	0x03BF0301: 0x03CC,
+	0x03C50301: 0x03CD,
+	0x03C90301: 0x03CE,
+	0x03D20301: 0x03D3,
+	0x03D20308: 0x03D4,
+	0x04150300: 0x0400,
+	0x04150308: 0x0401,
+	0x04130301: 0x0403,
+	0x04060308: 0x0407,
+	0x041A0301: 0x040C,
+	0x04180300: 0x040D,
+	0x04230306: 0x040E,
+	0x04180306: 0x0419,
+	0x04380306: 0x0439,
+	0x04350300: 0x0450,
+	0x04350308: 0x0451,
+	0x04330301: 0x0453,
+	0x04560308: 0x0457,
+	0x043A0301: 0x045C,
+	0x04380300: 0x045D,
+	0x04430306: 0x045E,
+	0x0474030F: 0x0476,
+	0x0475030F: 0x0477,
+	0x04160306: 0x04C1,
+	0x04360306: 0x04C2,
+	0x04100306: 0x04D0,
+	0x04300306: 0x04D1,
+	0x04100308: 0x04D2,
+	0x04300308: 0x04D3,
+	0x04150306: 0x04D6,
+	0x04350306: 0x04D7,
+	0x04D80308: 0x04DA,
+	0x04D90308: 0x04DB,
+	0x04160308: 0x04DC,
+	0x04360308: 0x04DD,
+	0x04170308: 0x04DE,
+	0x04370308: 0x04DF,
+	0x04180304: 0x04E2,
+	0x04380304: 0x04E3,
+	0x04180308: 0x04E4,
+	0x04380308: 0x04E5,
+	0x041E0308: 0x04E6,
+	0x043E0308: 0x04E7,
+	0x04E80308: 0x04EA,
+	0x04E90308: 0x04EB,
+	0x042D0308: 0x04EC,
+	0x044D0308: 0x04ED,
+	0x04230304: 0x04EE,
+	0x04430304: 0x04EF,
+	0x04230308: 0x04F0,
+	0x04430308: 0x04F1,
+	0x0423030B: 0x04F2,
+	0x0443030B: 0x04F3,
+	0x04270308: 0x04F4,
+	0x04470308: 0x04F5,
+	0x042B0308: 0x04F8,
+	0x044B0308: 0x04F9,
+	0x06270653: 0x0622,
+	0x06270654: 0x0623,
+	0x06480654: 0x0624,
+	0x06270655: 0x0625,
+	0x064A0654: 0x0626,
+	0x06D50654: 0x06C0,
+	0x06C10654: 0x06C2,
+	0x06D20654: 0x06D3,
+	0x0928093C: 0x0929,
+	0x0930093C: 0x0931,
+	0x0933093C: 0x0934,
+	0x09C709BE: 0x09CB,
+	0x09C709D7: 0x09CC,
+	0x0B470B56: 0x0B48,
+	0x0B470B3E: 0x0B4B,
+	0x0B470B57: 0x0B4C,
+	0x0B920BD7: 0x0B94,
+	0x0BC60BBE: 0x0BCA,
+	0x0BC70BBE: 0x0BCB,
+	0x0BC60BD7: 0x0BCC,
+	0x0C460C56: 0x0C48,
+	0x0CBF0CD5: 0x0CC0,
+	0x0CC60CD5: 0x0CC7,
+	0x0CC60CD6: 0x0CC8,
+	0x0CC60CC2: 0x0CCA,
+	0x0CCA0CD5: 0x0CCB,
+	0x0D460D3E: 0x0D4A,
+	0x0D470D3E: 0x0D4B,
+	0x0D460D57: 0x0D4C,
+	0x0DD90DCA: 0x0DDA,
+	0x0DD90DCF: 0x0DDC,
+	0x0DDC0DCA: 0x0DDD,
+	0x0DD90DDF: 0x0DDE,
+	0x1025102E: 0x1026,
+	0x1B051B35: 0x1B06,
+	0x1B071B35: 0x1B08,
+	0x1B091B35: 0x1B0A,
+	0x1B0B1B35: 0x1B0C,
+	0x1B0D1B35: 0x1B0E,
+	0x1B111B35: 0x1B12,
+	0x1B3A1B35: 0x1B3B,
+	0x1B3C1B35: 0x1B3D,
+	0x1B3E1B35: 0x1B40,
+	0x1B3F1B35: 0x1B41,
+	0x1B421B35: 0x1B43,
+	0x00410325: 0x1E00,
+	0x00610325: 0x1E01,
+	0x00420307: 0x1E02,
+	0x00620307: 0x1E03,
+	0x00420323: 0x1E04,
+	0x00620323: 0x1E05,
+	0x00420331: 0x1E06,
+	0x00620331: 0x1E07,
+	0x00C70301: 0x1E08,
+	0x00E70301: 0x1E09,
+	0x00440307: 0x1E0A,
+	0x00640307: 0x1E0B,
+	0x00440323: 0x1E0C,
+	0x00640323: 0x1E0D,
+	0x00440331: 0x1E0E,
+	0x00640331: 0x1E0F,
+	0x00440327: 0x1E10,
+	0x00640327: 0x1E11,
+	0x0044032D: 0x1E12,
+	0x0064032D: 0x1E13,
+	0x01120300: 0x1E14,
+	0x01130300: 0x1E15,
+	0x01120301: 0x1E16,
+	0x01130301: 0x1E17,
+	0x0045032D: 0x1E18,
+	0x0065032D: 0x1E19,
+	0x00450330: 0x1E1A,
+	0x00650330: 0x1E1B,
+	0x02280306: 0x1E1C,
+	0x02290306: 0x1E1D,
+	0x00460307: 0x1E1E,
+	0x00660307: 0x1E1F,
+	0x00470304: 0x1E20,
+	0x00670304: 0x1E21,
+	0x00480307: 0x1E22,
+	0x00680307: 0x1E23,
+	0x00480323: 0x1E24,
+	0x00680323: 0x1E25,
+	0x00480308: 0x1E26,
+	0x00680308: 0x1E27,
+	0x00480327: 0x1E28,
+	0x00680327: 0x1E29,
+	0x0048032E: 0x1E2A,
+	0x0068032E: 0x1E2B,
+	0x00490330: 0x1E2C,
+	0x00690330: 0x1E2D,
+	0x00CF0301: 0x1E2E,
+	0x00EF0301: 0x1E2F,
+	0x004B0301: 0x1E30,
+	0x006B0301: 0x1E31,
+	0x004B0323: 0x1E32,
+	0x006B0323: 0x1E33,
+	0x004B0331: 0x1E34,
+	0x006B0331: 0x1E35,
+	0x004C0323: 0x1E36,
+	0x006C0323: 0x1E37,
+	0x1E360304: 0x1E38,
+	0x1E370304: 0x1E39,
+	0x004C0331: 0x1E3A,
+	0x006C0331: 0x1E3B,
+	0x004C032D: 0x1E3C,
+	0x006C032D: 0x1E3D,
+	0x004D0301: 0x1E3E,
+	0x006D0301: 0x1E3F,
+	0x004D0307: 0x1E40,
+	0x006D0307: 0x1E41,
+	0x004D0323: 0x1E42,
+	0x006D0323: 0x1E43,
+	0x004E0307: 0x1E44,
+	0x006E0307: 0x1E45,
+	0x004E0323: 0x1E46,
+	0x006E0323: 0x1E47,
+	0x004E0331: 0x1E48,
+	0x006E0331: 0x1E49,
+	0x004E032D: 0x1E4A,
+	0x006E032D: 0x1E4B,
+	0x00D50301: 0x1E4C,
+	0x00F50301: 0x1E4D,
+	0x00D50308: 0x1E4E,
+	0x00F50308: 0x1E4F,
+	0x014C0300: 0x1E50,
+	0x014D0300: 0x1E51,
+	0x014C0301: 0x1E52,
+	0x014D0301: 0x1E53,
+	0x00500301: 0x1E54,
+	0x00700301: 0x1E55,
+	0x00500307: 0x1E56,
+	0x00700307: 0x1E57,
+	0x00520307: 0x1E58,
+	0x00720307: 0x1E59,
+	0x00520323: 0x1E5A,
+	0x00720323: 0x1E5B,
+	0x1E5A0304: 0x1E5C,
+	0x1E5B0304: 0x1E5D,
+	0x00520331: 0x1E5E,
+	0x00720331: 0x1E5F,
+	0x00530307: 0x1E60,
+	0x00730307: 0x1E61,
+	0x00530323: 0x1E62,
+	0x00730323: 0x1E63,
+	0x015A0307: 0x1E64,
+	0x015B0307: 0x1E65,
+	0x01600307: 0x1E66,
+	0x01610307: 0x1E67,
+	0x1E620307: 0x1E68,
+	0x1E630307: 0x1E69,
+	0x00540307: 0x1E6A,
+	0x00740307: 0x1E6B,
+	0x00540323: 0x1E6C,
+	0x00740323: 0x1E6D,
+	0x00540331: 0x1E6E,
+	0x00740331: 0x1E6F,
+	0x0054032D: 0x1E70,
+	0x0074032D: 0x1E71,
+	0x00550324: 0x1E72,
+	0x00750324: 0x1E73,
+	0x00550330: 0x1E74,
+	0x00750330: 0x1E75,
+	0x0055032D: 0x1E76,
+	0x0075032D: 0x1E77,
+	0x01680301: 0x1E78,
+	0x01690301: 0x1E79,
+	0x016A0308: 0x1E7A,
+	0x016B0308: 0x1E7B,
+	0x00560303: 0x1E7C,
+	0x00760303: 0x1E7D,
+	0x00560323: 0x1E7E,
+	0x00760323: 0x1E7F,
+	0x00570300: 0x1E80,
+	0x00770300: 0x1E81,
+	0x00570301: 0x1E82,
+	0x00770301: 0x1E83,
+	0x00570308: 0x1E84,
+	0x00770308: 0x1E85,
+	0x00570307: 0x1E86,
+	0x00770307: 0x1E87,
+	0x00570323: 0x1E88,
+	0x00770323: 0x1E89,
+	0x00580307: 0x1E8A,
+	0x00780307: 0x1E8B,
+	0x00580308: 0x1E8C,
+	0x00780308: 0x1E8D,
+	0x00590307: 0x1E8E,
+	0x00790307: 0x1E8F,
+	0x005A0302: 0x1E90,
+	0x007A0302: 0x1E91,
+	0x005A0323: 0x1E92,
+	0x007A0323: 0x1E93,
+	0x005A0331: 0x1E94,
+	0x007A0331: 0x1E95,
+	0x00680331: 0x1E96,
+	0x00740308: 0x1E97,
+	0x0077030A: 0x1E98,
+	0x0079030A: 0x1E99,
+	0x017F0307: 0x1E9B,
+	0x00410323: 0x1EA0,
+	0x00610323: 0x1EA1,
+	0x00410309: 0x1EA2,
+	0x00610309: 0x1EA3,
+	0x00C20301: 0x1EA4,
+	0x00E20301: 0x1EA5,
+	0x00C20300: 0x1EA6,
+	0x00E20300: 0x1EA7,
+	0x00C20309: 0x1EA8,
+	0x00E20309: 0x1EA9,
+	0x00C20303: 0x1EAA,
+	0x00E20303: 0x1EAB,
+	0x1EA00302: 0x1EAC,
+	0x1EA10302: 0x1EAD,
+	0x01020301: 0x1EAE,
+	0x01030301: 0x1EAF,
+	0x01020300: 0x1EB0,
+	0x01030300: 0x1EB1,
+	0x01020309: 0x1EB2,
+	0x01030309: 0x1EB3,
+	0x01020303: 0x1EB4,
+	0x01030303: 0x1EB5,
+	0x1EA00306: 0x1EB6,
+	0x1EA10306: 0x1EB7,
+	0x00450323: 0x1EB8,
+	0x00650323: 0x1EB9,
+	0x00450309: 0x1EBA,
+	0x00650309: 0x1EBB,
+	0x00450303: 0x1EBC,
+	0x00650303: 0x1EBD,
+	0x00CA0301: 0x1EBE,
+	0x00EA0301: 0x1EBF,
+	0x00CA0300: 0x1EC0,
+	0x00EA0300: 0x1EC1,
+	0x00CA0309: 0x1EC2,
+	0x00EA0309: 0x1EC3,
+	0x00CA0303: 0x1EC4,
+	0x00EA0303: 0x1EC5,
+	0x1EB80302: 0x1EC6,
+	0x1EB90302: 0x1EC7,
+	0x00490309: 0x1EC8,
+	0x00690309: 0x1EC9,
+	0x00490323: 0x1ECA,
+	0x00690323: 0x1ECB,
+	0x004F0323: 0x1ECC,
+	0x006F0323: 0x1ECD,
+	0x004F0309: 0x1ECE,
+	0x006F0309: 0x1ECF,
+	0x00D40301: 0x1ED0,
+	0x00F40301: 0x1ED1,
+	0x00D40300: 0x1ED2,
+	0x00F40300: 0x1ED3,
+	0x00D40309: 0x1ED4,
+	0x00F40309: 0x1ED5,
+	0x00D40303: 0x1ED6,
+	0x00F40303: 0x1ED7,
+	0x1ECC0302: 0x1ED8,
+	0x1ECD0302: 0x1ED9,
+	0x01A00301: 0x1EDA,
+	0x01A10301: 0x1EDB,
+	0x01A00300: 0x1EDC,
+	0x01A10300: 0x1EDD,
+	0x01A00309: 0x1EDE,
+	0x01A10309: 0x1EDF,
+	0x01A00303: 0x1EE0,
+	0x01A10303: 0x1EE1,
+	0x01A00323: 0x1EE2,
+	0x01A10323: 0x1EE3,
+	0x00550323: 0x1EE4,
+	0x00750323: 0x1EE5,
+	0x00550309: 0x1EE6,
+	0x00750309: 0x1EE7,
+	0x01AF0301: 0x1EE8,
+	0x01B00301: 0x1EE9,
+	0x01AF0300: 0x1EEA,
+	0x01B00300: 0x1EEB,
+	0x01AF0309: 0x1EEC,
+	0x01B00309: 0x1EED,
+	0x01AF0303: 0x1EEE,
+	0x01B00303: 0x1EEF,
+	0x01AF0323: 0x1EF0,
+	0x01B00323: 0x1EF1,
+	0x00590300: 0x1EF2,
+	0x00790300: 0x1EF3,
+	0x00590323: 0x1EF4,
+	0x00790323: 0x1EF5,
+	0x00590309: 0x1EF6,
+	0x00790309: 0x1EF7,
+	0x00590303: 0x1EF8,
+	0x00790303: 0x1EF9,
+	0x03B10313: 0x1F00,
+	0x03B10314: 0x1F01,
+	0x1F000300: 0x1F02,
+	0x1F010300: 0x1F03,
+	0x1F000301: 0x1F04,
+	0x1F010301: 0x1F05,
+	0x1F000342: 0x1F06,
+	0x1F010342: 0x1F07,
+	0x03910313: 0x1F08,
+	0x03910314: 0x1F09,
+	0x1F080300: 0x1F0A,
+	0x1F090300: 0x1F0B,
+	0x1F080301: 0x1F0C,
+	0x1F090301: 0x1F0D,
+	0x1F080342: 0x1F0E,
+	0x1F090342: 0x1F0F,
+	0x03B50313: 0x1F10,
+	0x03B50314: 0x1F11,
+	0x1F100300: 0x1F12,
+	0x1F110300: 0x1F13,
+	0x1F100301: 0x1F14,
+	0x1F110301: 0x1F15,
+	0x03950313: 0x1F18,
+	0x03950314: 0x1F19,
+	0x1F180300: 0x1F1A,
+	0x1F190300: 0x1F1B,
+	0x1F180301: 0x1F1C,
+	0x1F190301: 0x1F1D,
+	0x03B70313: 0x1F20,
+	0x03B70314: 0x1F21,
+	0x1F200300: 0x1F22,
+	0x1F210300: 0x1F23,
+	0x1F200301: 0x1F24,
+	0x1F210301: 0x1F25,
+	0x1F200342: 0x1F26,
+	0x1F210342: 0x1F27,
+	0x03970313: 0x1F28,
+	0x03970314: 0x1F29,
+	0x1F280300: 0x1F2A,
+	0x1F290300: 0x1F2B,
+	0x1F280301: 0x1F2C,
+	0x1F290301: 0x1F2D,
+	0x1F280342: 0x1F2E,
+	0x1F290342: 0x1F2F,
+	0x03B90313: 0x1F30,
+	0x03B90314: 0x1F31,
+	0x1F300300: 0x1F32,
+	0x1F310300: 0x1F33,
+	0x1F300301: 0x1F34,
+	0x1F310301: 0x1F35,
+	0x1F300342: 0x1F36,
+	0x1F310342: 0x1F37,
+	0x03990313: 0x1F38,
+	0x03990314: 0x1F39,
+	0x1F380300: 0x1F3A,
+	0x1F390300: 0x1F3B,
+	0x1F380301: 0x1F3C,
+	0x1F390301: 0x1F3D,
+	0x1F380342: 0x1F3E,
+	0x1F390342: 0x1F3F,
+	0x03BF0313: 0x1F40,
+	0x03BF0314: 0x1F41,
+	0x1F400300: 0x1F42,
+	0x1F410300: 0x1F43,
+	0x1F400301: 0x1F44,
+	0x1F410301: 0x1F45,
+	0x039F0313: 0x1F48,
+	0x039F0314: 0x1F49,
+	0x1F480300: 0x1F4A,
+	0x1F490300: 0x1F4B,
+	0x1F480301: 0x1F4C,
+	0x1F490301: 0x1F4D,
+	0x03C50313: 0x1F50,
+	0x03C50314: 0x1F51,
+	0x1F500300: 0x1F52,
+	0x1F510300: 0x1F53,
+	0x1F500301: 0x1F54,
+	0x1F510301: 0x1F55,
+	0x1F500342: 0x1F56,
+	0x1F510342: 0x1F57,
+	0x03A50314: 0x1F59,
+	0x1F590300: 0x1F5B,
+	0x1F590301: 0x1F5D,
+	0x1F590342: 0x1F5F,
+	0x03C90313: 0x1F60,
+	0x03C90314: 0x1F61,
+	0x1F600300: 0x1F62,
+	0x1F610300: 0x1F63,
+	0x1F600301: 0x1F64,
+	0x1F610301: 0x1F65,
+	0x1F600342: 0x1F66,
+	0x1F610342: 0x1F67,
+	0x03A90313: 0x1F68,
+	0x03A90314: 0x1F69,
+	0x1F680300: 0x1F6A,
+	0x1F690300: 0x1F6B,
+	0x1F680301: 0x1F6C,
+	0x1F690301: 0x1F6D,
+	0x1F680342: 0x1F6E,
+	0x1F690342: 0x1F6F,
+	0x03B10300: 0x1F70,
+	0x03B50300: 0x1F72,
+	0x03B70300: 0x1F74,
+	0x03B90300: 0x1F76,
+	0x03BF0300: 0x1F78,
+	0x03C50300: 0x1F7A,
+	0x03C90300: 0x1F7C,
+	0x1F000345: 0x1F80,
+	0x1F010345: 0x1F81,
+	0x1F020345: 0x1F82,
+	0x1F030345: 0x1F83,
+	0x1F040345: 0x1F84,
+	0x1F050345: 0x1F85,
+	0x1F060345: 0x1F86,
+	0x1F070345: 0x1F87,
+	0x1F080345: 0x1F88,
+	0x1F090345: 0x1F89,
+	0x1F0A0345: 0x1F8A,
+	0x1F0B0345: 0x1F8B,
+	0x1F0C0345: 0x1F8C,
+	0x1F0D0345: 0x1F8D,
+	0x1F0E0345: 0x1F8E,
+	0x1F0F0345: 0x1F8F,
+	0x1F200345: 0x1F90,
+	0x1F210345: 0x1F91,
+	0x1F220345: 0x1F92,
+	0x1F230345: 0x1F93,
+	0x1F240345: 0x1F94,
+	0x1F250345: 0x1F95,
+	0x1F260345: 0x1F96,
+	0x1F270345: 0x1F97,
+	0x1F280345: 0x1F98,
+	0x1F290345: 0x1F99,
+	0x1F2A0345: 0x1F9A,
+	0x1F2B0345: 0x1F9B,
+	0x1F2C0345: 0x1F9C,
+	0x1F2D0345: 0x1F9D,
+	0x1F2E0345: 0x1F9E,
+	0x1F2F0345: 0x1F9F,
+	0x1F600345: 0x1FA0,
+	0x1F610345: 0x1FA1,
+	0x1F620345: 0x1FA2,
+	0x1F630345: 0x1FA3,
+	0x1F640345: 0x1FA4,
+	0x1F650345: 0x1FA5,
+	0x1F660345: 0x1FA6,
+	0x1F670345: 0x1FA7,
+	0x1F680345: 0x1FA8,
+	0x1F690345: 0x1FA9,
+	0x1F6A0345: 0x1FAA,
+	0x1F6B0345: 0x1FAB,
+	0x1F6C0345: 0x1FAC,
+	0x1F6D0345: 0x1FAD,
+	0x1F6E0345: 0x1FAE,
+	0x1F6F0345: 0x1FAF,
+	0x03B10306: 0x1FB0,
+	0x03B10304: 0x1FB1,
+	0x1F700345: 0x1FB2,
+	0x03B10345: 0x1FB3,
+	0x03AC0345: 0x1FB4,
+	0x03B10342: 0x1FB6,
+	0x1FB60345: 0x1FB7,
+	0x03910306: 0x1FB8,
+	0x03910304: 0x1FB9,
+	0x03910300: 0x1FBA,
+	0x03910345: 0x1FBC,
+	0x00A80342: 0x1FC1,
+	0x1F740345: 0x1FC2,
+	0x03B70345: 0x1FC3,
+	0x03AE0345: 0x1FC4,
+	0x03B70342: 0x1FC6,
+	0x1FC60345: 0x1FC7,
+	0x03950300: 0x1FC8,
+	0x03970300: 0x1FCA,
+	0x03970345: 0x1FCC,
+	0x1FBF0300: 0x1FCD,
+	0x1FBF0301: 0x1FCE,
+	0x1FBF0342: 0x1FCF,
+	0x03B90306: 0x1FD0,
+	0x03B90304: 0x1FD1,
+	0x03CA0300: 0x1FD2,
+	0x03B90342: 0x1FD6,
+	0x03CA0342: 0x1FD7,
+	0x03990306: 0x1FD8,
+	0x03990304: 0x1FD9,
+	0x03990300: 0x1FDA,
+	0x1FFE0300: 0x1FDD,
+	0x1FFE0301: 0x1FDE,
+	0x1FFE0342: 0x1FDF,
+	0x03C50306: 0x1FE0,
+	0x03C50304: 0x1FE1,
+	0x03CB0300: 0x1FE2,
+	0x03C10313: 0x1FE4,
+	0x03C10314: 0x1FE5,
+	0x03C50342: 0x1FE6,
+	0x03CB0342: 0x1FE7,
+	0x03A50306: 0x1FE8,
+	0x03A50304: 0x1FE9,
+	0x03A50300: 0x1FEA,
+	0x03A10314: 0x1FEC,
+	0x00A80300: 0x1FED,
+	0x1F7C0345: 0x1FF2,
+	0x03C90345: 0x1FF3,
+	0x03CE0345: 0x1FF4,
+	0x03C90342: 0x1FF6,
+	0x1FF60345: 0x1FF7,
+	0x039F0300: 0x1FF8,
+	0x03A90300: 0x1FFA,
+	0x03A90345: 0x1FFC,
+	0x21900338: 0x219A,
+	0x21920338: 0x219B,
+	0x21940338: 0x21AE,
+	0x21D00338: 0x21CD,
+	0x21D40338: 0x21CE,
+	0x21D20338: 0x21CF,
+	0x22030338: 0x2204,
+	0x22080338: 0x2209,
+	0x220B0338: 0x220C,
+	0x22230338: 0x2224,
+	0x22250338: 0x2226,
+	0x223C0338: 0x2241,
+	0x22430338: 0x2244,
+	0x22450338: 0x2247,
+	0x22480338: 0x2249,
+	0x003D0338: 0x2260,
+	0x22610338: 0x2262,
+	0x224D0338: 0x226D,
+	0x003C0338: 0x226E,
+	0x003E0338: 0x226F,
+	0x22640338: 0x2270,
+	0x22650338: 0x2271,
+	0x22720338: 0x2274,
+	0x22730338: 0x2275,
+	0x22760338: 0x2278,
+	0x22770338: 0x2279,
+	0x227A0338: 0x2280,
+	0x227B0338: 0x2281,
+	0x22820338: 0x2284,
+	0x22830338: 0x2285,
+	0x22860338: 0x2288,
+	0x22870338: 0x2289,
+	0x22A20338: 0x22AC,
+	0x22A80338: 0x22AD,
+	0x22A90338: 0x22AE,
+	0x22AB0338: 0x22AF,
+	0x227C0338: 0x22E0,
+	0x227D0338: 0x22E1,
+	0x22910338: 0x22E2,
+	0x22920338: 0x22E3,
+	0x22B20338: 0x22EA,
+	0x22B30338: 0x22EB,
+	0x22B40338: 0x22EC,
+	0x22B50338: 0x22ED,
+	0x304B3099: 0x304C,
+	0x304D3099: 0x304E,
+	0x304F3099: 0x3050,
+	0x30513099: 0x3052,
+	0x30533099: 0x3054,
+	0x30553099: 0x3056,
+	0x30573099: 0x3058,
+	0x30593099: 0x305A,
+	0x305B3099: 0x305C,
+	0x305D3099: 0x305E,
+	0x305F3099: 0x3060,
+	0x30613099: 0x3062,
+	0x30643099: 0x3065,
+	0x30663099: 0x3067,
+	0x30683099: 0x3069,
+	0x306F3099: 0x3070,
+	0x306F309A: 0x3071,
+	0x30723099: 0x3073,
+	0x3072309A: 0x3074,
+	0x30753099: 0x3076,
+	0x3075309A: 0x3077,
+	0x30783099: 0x3079,
+	0x3078309A: 0x307A,
+	0x307B3099: 0x307C,
+	0x307B309A: 0x307D,
+	0x30463099: 0x3094,
+	0x309D3099: 0x309E,
+	0x30AB3099: 0x30AC,
+	0x30AD3099: 0x30AE,
+	0x30AF3099: 0x30B0,
+	0x30B13099: 0x30B2,
+	0x30B33099: 0x30B4,
+	0x30B53099: 0x30B6,
+	0x30B73099: 0x30B8,
+	0x30B93099: 0x30BA,
+	0x30BB3099: 0x30BC,
+	0x30BD3099: 0x30BE,
+	0x30BF3099: 0x30C0,
+	0x30C13099: 0x30C2,
+	0x30C43099: 0x30C5,
+	0x30C63099: 0x30C7,
+	0x30C83099: 0x30C9,
+	0x30CF3099: 0x30D0,
+	0x30CF309A: 0x30D1,
+	0x30D23099: 0x30D3,
+	0x30D2309A: 0x30D4,
+	0x30D53099: 0x30D6,
+	0x30D5309A: 0x30D7,
+	0x30D83099: 0x30D9,
+	0x30D8309A: 0x30DA,
+	0x30DB3099: 0x30DC,
+	0x30DB309A: 0x30DD,
+	0x30A63099: 0x30F4,
+	0x30EF3099: 0x30F7,
+	0x30F03099: 0x30F8,
+	0x30F13099: 0x30F9,
+	0x30F23099: 0x30FA,
+	0x30FD3099: 0x30FE,
+	0x109910BA: 0x1109A,
+	0x109B10BA: 0x1109C,
+	0x10A510BA: 0x110AB,
+	0x11311127: 0x1112E,
+	0x11321127: 0x1112F,
+	0x1347133E: 0x1134B,
+	0x13471357: 0x1134C,
+	0x14B914BA: 0x114BB,
+	0x14B914B0: 0x114BC,
+	0x14B914BD: 0x114BE,
+	0x15B815AF: 0x115BA,
+	0x15B915AF: 0x115BB,
+}
+
+// Total size of tables: 53KB (54006 bytes)
diff --git a/vendor/golang.org/x/text/unicode/norm/transform.go b/vendor/golang.org/x/text/unicode/norm/transform.go
new file mode 100644
index 0000000000..9f47efbaf6
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/transform.go
@@ -0,0 +1,88 @@
+// Copyright 2013 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 norm
+
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// Reset implements the Reset method of the transform.Transformer interface.
+func (Form) Reset() {}
+
+// Transform implements the Transform method of the transform.Transformer
+// interface. It may need to write segments of up to MaxSegmentSize at once.
+// Users should either catch ErrShortDst and allow dst to grow or have dst be at
+// least of size MaxTransformChunkSize to be guaranteed of progress.
+func (f Form) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	n := 0
+	// Cap the maximum number of src bytes to check.
+	b := src
+	eof := atEOF
+	if ns := len(dst); ns < len(b) {
+		err = transform.ErrShortDst
+		eof = false
+		b = b[:ns]
+	}
+	i, ok := formTable[f].quickSpan(inputBytes(b), n, len(b), eof)
+	n += copy(dst[n:], b[n:i])
+	if !ok {
+		nDst, nSrc, err = f.transform(dst[n:], src[n:], atEOF)
+		return nDst + n, nSrc + n, err
+	}
+	if n < len(src) && !atEOF {
+		err = transform.ErrShortSrc
+	}
+	return n, n, err
+}
+
+func flushTransform(rb *reorderBuffer) bool {
+	// Write out (must fully fit in dst, or else it is an ErrShortDst).
+	if len(rb.out) < rb.nrune*utf8.UTFMax {
+		return false
+	}
+	rb.out = rb.out[rb.flushCopy(rb.out):]
+	return true
+}
+
+var errs = []error{nil, transform.ErrShortDst, transform.ErrShortSrc}
+
+// transform implements the transform.Transformer interface. It is only called
+// when quickSpan does not pass for a given string.
+func (f Form) transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	// TODO: get rid of reorderBuffer. See CL 23460044.
+	rb := reorderBuffer{}
+	rb.init(f, src)
+	for {
+		// Load segment into reorder buffer.
+		rb.setFlusher(dst[nDst:], flushTransform)
+		end := decomposeSegment(&rb, nSrc, atEOF)
+		if end < 0 {
+			return nDst, nSrc, errs[-end]
+		}
+		nDst = len(dst) - len(rb.out)
+		nSrc = end
+
+		// Next quickSpan.
+		end = rb.nsrc
+		eof := atEOF
+		if n := nSrc + len(dst) - nDst; n < end {
+			err = transform.ErrShortDst
+			end = n
+			eof = false
+		}
+		end, ok := rb.f.quickSpan(rb.src, nSrc, end, eof)
+		n := copy(dst[nDst:], rb.src.bytes[nSrc:end])
+		nSrc += n
+		nDst += n
+		if ok {
+			if n < rb.nsrc && !atEOF {
+				err = transform.ErrShortSrc
+			}
+			return nDst, nSrc, err
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/trie.go b/vendor/golang.org/x/text/unicode/norm/trie.go
new file mode 100644
index 0000000000..423386bf43
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/trie.go
@@ -0,0 +1,54 @@
+// 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 norm
+
+type valueRange struct {
+	value  uint16 // header: value:stride
+	lo, hi byte   // header: lo:n
+}
+
+type sparseBlocks struct {
+	values []valueRange
+	offset []uint16
+}
+
+var nfcSparse = sparseBlocks{
+	values: nfcSparseValues[:],
+	offset: nfcSparseOffset[:],
+}
+
+var nfkcSparse = sparseBlocks{
+	values: nfkcSparseValues[:],
+	offset: nfkcSparseOffset[:],
+}
+
+var (
+	nfcData  = newNfcTrie(0)
+	nfkcData = newNfkcTrie(0)
+)
+
+// lookupValue determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	offset := t.offset[n]
+	header := t.values[offset]
+	lo := offset + 1
+	hi := lo + uint16(header.lo)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := t.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value + uint16(b-r.lo)*header.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock
new file mode 100644
index 0000000000..c1b0e0a3fb
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock
@@ -0,0 +1,21 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "v1"
+  name = "gopkg.in/check.v1"
+  packages = ["."]
+  revision = "20d25e2804050c1cd24a7eea1e7a6447dd0e74ec"
+
+[[projects]]
+  branch = "v3"
+  name = "gopkg.in/olebedev/go-duktape.v3"
+  packages = ["."]
+  revision = "391c1c40178e77a6003d889b96e0e41129aeb894"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "043f802c0b40e2622bf784443d3e3959f0d01e9a795e3bfe30a72060dec10c63"
+  solver-name = "gps-cdcl"
+  solver-version = 1
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml
new file mode 100644
index 0000000000..ea8dc6de3d
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml
@@ -0,0 +1,3 @@
+[[constraint]]
+  branch = "v1"
+  name = "gopkg.in/check.v1"
\ No newline at end of file
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md b/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md
new file mode 100644
index 0000000000..785c85309e
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Oleg Lebedev
+
+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/vendor/gopkg.in/olebedev/go-duktape.v3/README.md b/vendor/gopkg.in/olebedev/go-duktape.v3/README.md
new file mode 100644
index 0000000000..2ddaad5e10
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/README.md
@@ -0,0 +1,124 @@
+# Duktape bindings for Go(Golang)
+
+[![wercker status](https://app.wercker.com/status/3a5bb2e639a4b4efaf4c8bf7cab7442d/s "wercker status")](https://app.wercker.com/project/bykey/3a5bb2e639a4b4efaf4c8bf7cab7442d)
+[![Travis status](https://travis-ci.org/olebedev/go-duktape.svg?branch=v3)](https://travis-ci.org/olebedev/go-duktape)
+[![Appveyor status](https://ci.appveyor.com/api/projects/status/github/olebedev/go-duktape?branch=v3&svg=true)](https://ci.appveyor.com/project/olebedev/go-duktape/branch/v3)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/olebedev/go-duktape?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+[Duktape](http://duktape.org/index.html) is a thin, embeddable javascript engine.
+Most of the [api](http://duktape.org/api.html) is implemented.
+The exceptions are listed [here](https://github.com/olebedev/go-duktape/blob/master/api.go#L1566).
+
+### Usage
+
+The package is fully go-getable, no need to install any external C libraries.  
+So, just type `go get gopkg.in/olebedev/go-duktape.v3` to install.
+
+
+```go
+package main
+
+import "fmt"
+import "gopkg.in/olebedev/go-duktape.v3"
+
+func main() {
+  ctx := duktape.New()
+  ctx.PevalString(`2 + 3`)
+  result := ctx.GetNumber(-1)
+  ctx.Pop()
+  fmt.Println("result is:", result)
+  // To prevent memory leaks, don't forget to clean up after
+  // yourself when you're done using a context.
+  ctx.DestroyHeap()
+}
+```
+
+### Go specific notes
+
+Bindings between Go and Javascript contexts are not fully functional.
+However, binding a Go function to the Javascript context is available:
+```go
+package main
+
+import "fmt"
+import "gopkg.in/olebedev/go-duktape.v3"
+
+func main() {
+  ctx := duktape.New()
+  ctx.PushGlobalGoFunction("log", func(c *duktape.Context) int {
+    fmt.Println(c.SafeToString(-1))
+    return 0
+  })
+  ctx.PevalString(`log('Go lang Go!')`)
+}
+```
+then run it.
+```bash
+$ go run *.go
+Go lang Go!
+$
+```
+
+### Timers
+
+There is a method to inject timers to the global scope:
+```go
+package main
+
+import "fmt"
+import "gopkg.in/olebedev/go-duktape.v3"
+
+func main() {
+  ctx := duktape.New()
+
+  // Let's inject `setTimeout`, `setInterval`, `clearTimeout`,
+  // `clearInterval` into global scope.
+  ctx.PushTimers()
+
+  ch := make(chan string)
+  ctx.PushGlobalGoFunction("second", func(_ *Context) int {
+    ch <- "second step"
+    return 0
+  })
+  ctx.PevalString(`
+    setTimeout(second, 0);
+    print('first step');
+  `)
+  fmt.Println(<-ch)
+}
+```
+then run it
+```bash
+$ go run *.go
+first step
+second step
+$
+```
+
+Also you can `FlushTimers()`.
+
+### Command line tool
+
+Install `go get gopkg.in/olebedev/go-duktape.v3/...`.  
+Execute file.js: `$GOPATH/bin/go-duk file.js`.
+
+### Benchmarks
+| prog        | time  |
+| ------------|-------|
+|[otto](https://github.com/robertkrimen/otto)|200.13s|
+|[anko](https://github.com/mattn/anko)|231.19s|
+|[agora](https://github.com/PuerkitoBio/agora/)|149.33s|
+|[GopherLua](https://github.com/yuin/gopher-lua/)|8.39s|
+|**go-duktape**|**9.80s**|
+
+More details are [here](https://github.com/olebedev/go-duktape/wiki/Benchmarks).
+
+### Status
+
+The package is not fully tested, so be careful.
+
+
+### Contribution
+
+Pull requests are welcome! Also, if you want to discuss something send a pull request with proposal and changes.
+__Convention:__ fork the repository and make changes on your fork in a feature branch.
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/api.go b/vendor/gopkg.in/olebedev/go-duktape.v3/api.go
new file mode 100644
index 0000000000..924b5c32fc
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/api.go
@@ -0,0 +1,1616 @@
+package duktape
+
+/*
+#cgo !windows CFLAGS: -std=c99 -O3 -Wall -Wno-unused-value -fomit-frame-pointer -fstrict-aliasing
+#cgo windows CFLAGS: -O3 -Wall -Wno-unused-value -fomit-frame-pointer -fstrict-aliasing
+
+#include "duktape.h"
+#include "duk_logging.h"
+#include "duk_v1_compat.h"
+#include "duk_print_alert.h"
+static void _duk_eval_string(duk_context *ctx, const char *str) {
+  duk_eval_string(ctx, str);
+}
+static void _duk_compile(duk_context *ctx, duk_uint_t flags) {
+  duk_compile(ctx, flags);
+}
+static void _duk_compile_file(duk_context *ctx, duk_uint_t flags, const char *path) {
+  duk_compile_file(ctx, flags, path);
+}
+static void _duk_compile_lstring(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) {
+	duk_compile_lstring(ctx, flags, src, len);
+}
+static void _duk_compile_lstring_filename(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) {
+	duk_compile_lstring_filename(ctx, flags, src, len);
+}
+static void _duk_compile_string(duk_context *ctx, duk_uint_t flags, const char *src) {
+	duk_compile_string(ctx, flags, src);
+}
+static void _duk_compile_string_filename(duk_context *ctx, duk_uint_t flags, const char *src) {
+	duk_compile_string_filename(ctx, flags, src);
+}
+static void _duk_dump_context_stderr(duk_context *ctx) {
+	duk_dump_context_stderr(ctx);
+}
+static void _duk_dump_context_stdout(duk_context *ctx) {
+	duk_dump_context_stdout(ctx);
+}
+static void _duk_eval(duk_context *ctx) {
+	duk_eval(ctx);
+}
+static void _duk_eval_file(duk_context *ctx, const char *path) {
+	duk_eval_file(ctx, path);
+}
+static void _duk_eval_file_noresult(duk_context *ctx, const char *path) {
+	duk_eval_file_noresult(ctx, path);
+}
+static void _duk_eval_lstring(duk_context *ctx, const char *src, duk_size_t len) {
+	duk_eval_lstring(ctx, src, len);
+}
+static void _duk_eval_lstring_noresult(duk_context *ctx, const char *src, duk_size_t len) {
+	duk_eval_lstring_noresult(ctx, src, len);
+}
+static void _duk_eval_noresult(duk_context *ctx) {
+	duk_eval_noresult(ctx);
+}
+static void _duk_eval_string_noresult(duk_context *ctx, const char *src) {
+	duk_eval_string_noresult(ctx, src);
+}
+static duk_bool_t _duk_is_error(duk_context *ctx, duk_idx_t index) {
+	return duk_is_error(ctx, index);
+}
+static duk_bool_t _duk_is_object_coercible(duk_context *ctx, duk_idx_t index) {
+	return duk_is_object_coercible(ctx, index);
+}
+static duk_int_t _duk_pcompile(duk_context *ctx, duk_uint_t flags) {
+	return duk_pcompile(ctx, flags);
+}
+static duk_int_t _duk_pcompile_file(duk_context *ctx, duk_uint_t flags, const char *path) {
+	return duk_pcompile_file(ctx, flags, path);
+}
+static duk_int_t _duk_pcompile_lstring(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) {
+	return duk_pcompile_lstring(ctx, flags, src, len);
+}
+static duk_int_t _duk_pcompile_lstring_filename(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) {
+	return duk_pcompile_lstring_filename(ctx, flags, src, len);
+}
+static duk_int_t _duk_pcompile_string(duk_context *ctx, duk_uint_t flags, const char *src) {
+	return duk_pcompile_string(ctx, flags, src);
+}
+static duk_int_t _duk_pcompile_string_filename(duk_context *ctx, duk_uint_t flags, const char *src) {
+	return duk_pcompile_string_filename(ctx, flags, src);
+}
+static duk_int_t _duk_peval(duk_context *ctx) {
+	return duk_peval(ctx);
+}
+static duk_int_t _duk_peval_file(duk_context *ctx, const char *path) {
+	return duk_peval_file(ctx, path);
+}
+static duk_int_t _duk_peval_file_noresult(duk_context *ctx, const char *path) {
+	return duk_peval_file_noresult(ctx, path);
+}
+static duk_int_t _duk_peval_lstring(duk_context *ctx, const char *src, duk_size_t len) {
+	return duk_peval_lstring(ctx, src, len);
+}
+static duk_int_t _duk_peval_lstring_noresult(duk_context *ctx, const char *src, duk_size_t len) {
+	return duk_peval_lstring_noresult(ctx, src, len);
+}
+static duk_int_t _duk_peval_noresult(duk_context *ctx) {
+	return duk_peval_noresult(ctx);
+}
+static duk_int_t _duk_peval_string(duk_context *ctx, const char *src) {
+	return duk_peval_string(ctx, src);
+}
+static duk_int_t _duk_peval_string_noresult(duk_context *ctx, const char *src) {
+	return duk_peval_string_noresult(ctx, src);
+}
+static const char *_duk_push_string_file(duk_context *ctx, const char *path) {
+	return duk_push_string_file(ctx, path);
+}
+static duk_idx_t _duk_push_thread(duk_context *ctx) {
+	return duk_push_thread(ctx);
+}
+static duk_idx_t _duk_push_thread_new_globalenv(duk_context *ctx) {
+	return duk_push_thread_new_globalenv(ctx);
+}
+static void _duk_require_object_coercible(duk_context *ctx, duk_idx_t index) {
+	duk_require_object_coercible(ctx, index);
+}
+static void _duk_require_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask) {
+	duk_require_type_mask(ctx, index, mask);
+}
+static const char *_duk_safe_to_string(duk_context *ctx, duk_idx_t index) {
+	return duk_safe_to_string(ctx, index);
+}
+static void _duk_xcopy_top(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count) {
+	duk_xcopy_top(to_ctx, from_ctx, count);
+}
+static void _duk_xmove_top(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count) {
+	duk_xmove_top(to_ctx, from_ctx, count);
+}
+static void *_duk_to_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
+	return duk_to_buffer(ctx, index, out_size);
+}
+static void *_duk_to_dynamic_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
+	return duk_to_dynamic_buffer(ctx, index, out_size);
+}
+static void *_duk_to_fixed_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
+	return duk_to_fixed_buffer(ctx, index, out_size);
+}
+static duk_int_t _duk_is_primitive(duk_context *ctx, duk_idx_t index) {
+  return duk_is_primitive(ctx, index);
+}
+static void *_duk_push_buffer(duk_context *ctx, duk_size_t size, duk_bool_t dynamic) {
+	return duk_push_buffer(ctx, size, dynamic);
+}
+static void *_duk_push_fixed_buffer(duk_context *ctx, duk_size_t size) {
+	return duk_push_fixed_buffer(ctx, size);
+}
+static void *_duk_push_dynamic_buffer(duk_context *ctx, duk_size_t size) {
+	return duk_push_dynamic_buffer(ctx, size);
+}
+static void _duk_error(duk_context *ctx, duk_errcode_t err_code, const char *str) {
+	duk_error(ctx, err_code, "%s", str);
+}
+static void _duk_push_error_object(duk_context *ctx, duk_errcode_t err_code, const char *str) {
+	duk_push_error_object(ctx, err_code, "%s", str);
+}
+static void _duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *text) {
+	duk_error_raw(ctx, err_code, filename, line, text);
+}
+static void _duk_log(duk_context *ctx, duk_int_t level, const char *str) {
+	duk_log(ctx, level, "%s", str);
+}
+static void _duk_push_external_buffer(duk_context *ctx) {
+	duk_push_external_buffer(ctx);
+}
+*/
+import "C"
+import (
+	"fmt"
+	"unsafe"
+)
+
+// See: http://duktape.org/api.html#duk_alloc
+func (d *Context) Alloc(size int) unsafe.Pointer {
+	return C.duk_alloc(d.duk_context, C.duk_size_t(size))
+}
+
+// See: http://duktape.org/api.html#duk_alloc_raw
+func (d *Context) AllocRaw(size int) unsafe.Pointer {
+	return C.duk_alloc_raw(d.duk_context, C.duk_size_t(size))
+}
+
+// See: http://duktape.org/api.html#duk_base64_decode
+func (d *Context) Base64Decode(index int) {
+	C.duk_base64_decode(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_base64_encode
+func (d *Context) Base64Encode(index int) string {
+	if s := C.duk_base64_encode(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_call
+func (d *Context) Call(nargs int) {
+	C.duk_call(d.duk_context, C.duk_idx_t(nargs))
+}
+
+// See: http://duktape.org/api.html#duk_call_method
+func (d *Context) CallMethod(nargs int) {
+	C.duk_call_method(d.duk_context, C.duk_idx_t(nargs))
+}
+
+// See: http://duktape.org/api.html#duk_call_prop
+func (d *Context) CallProp(objIndex int, nargs int) {
+	C.duk_call_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_idx_t(nargs))
+}
+
+// See: http://duktape.org/api.html#duk_check_stack
+func (d *Context) CheckStack(extra int) bool {
+	return int(C.duk_check_stack(d.duk_context, C.duk_idx_t(extra))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_check_stack_top
+func (d *Context) CheckStackTop(top int) bool {
+	return int(C.duk_check_stack_top(d.duk_context, C.duk_idx_t(top))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_check_type
+func (d *Context) CheckType(index int, typ int) bool {
+	return int(C.duk_check_type(d.duk_context, C.duk_idx_t(index), C.duk_int_t(typ))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_check_type_mask
+func (d *Context) CheckTypeMask(index int, mask uint) bool {
+	return int(C.duk_check_type_mask(d.duk_context, C.duk_idx_t(index), C.duk_uint_t(mask))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_compact
+func (d *Context) Compact(objIndex int) {
+	C.duk_compact(d.duk_context, C.duk_idx_t(objIndex))
+}
+
+// See: http://duktape.org/api.html#duk_compile
+func (d *Context) Compile(flags uint) {
+	C._duk_compile(d.duk_context, C.duk_uint_t(flags))
+}
+
+// See: http://duktape.org/api.html#duk_compile_file
+func (d *Context) CompileFile(flags uint, path string) {
+	__path__ := C.CString(path)
+	C._duk_compile_file(d.duk_context, C.duk_uint_t(flags), __path__)
+	C.free(unsafe.Pointer(__path__))
+}
+
+// See: http://duktape.org/api.html#duk_compile_lstring
+func (d *Context) CompileLstring(flags uint, src string, len int) {
+	__src__ := C.CString(src)
+	C._duk_compile_lstring(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len))
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_compile_lstring_filename
+func (d *Context) CompileLstringFilename(flags uint, src string, len int) {
+	__src__ := C.CString(src)
+	C._duk_compile_lstring_filename(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len))
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_compile_string
+func (d *Context) CompileString(flags uint, src string) {
+	__src__ := C.CString(src)
+	C._duk_compile_string(d.duk_context, C.duk_uint_t(flags), __src__)
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_compile_string_filename
+func (d *Context) CompileStringFilename(flags uint, src string) {
+	__src__ := C.CString(src)
+	C._duk_compile_string_filename(d.duk_context, C.duk_uint_t(flags), __src__)
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_concat
+func (d *Context) Concat(count int) {
+	C.duk_concat(d.duk_context, C.duk_idx_t(count))
+}
+
+// See: http://duktape.org/api.html#duk_copy
+func (d *Context) Copy(fromIndex int, toIndex int) {
+	C.duk_copy(d.duk_context, C.duk_idx_t(fromIndex), C.duk_idx_t(toIndex))
+}
+
+// See: http://duktape.org/api.html#duk_del_prop
+func (d *Context) DelProp(objIndex int) bool {
+	return int(C.duk_del_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_del_prop_index
+func (d *Context) DelPropIndex(objIndex int, arrIndex uint) bool {
+	return int(C.duk_del_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_del_prop_string
+func (d *Context) DelPropString(objIndex int, key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_del_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_def_prop
+func (d *Context) DefProp(objIndex int, flags uint) {
+	C.duk_def_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_uint_t(flags))
+}
+
+// See: http://duktape.org/api.html#duk_destroy_heap
+func (d *Context) DestroyHeap() {
+	d.Gc(0)
+	C.duk_destroy_heap(d.duk_context)
+	d.duk_context = nil
+}
+
+// See: http://duktape.org/api.html#duk_dump_context_stderr
+func (d *Context) DumpContextStderr() {
+	C._duk_dump_context_stderr(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_dump_context_stdout
+func (d *Context) DumpContextStdout() {
+	C._duk_dump_context_stdout(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_dup
+func (d *Context) Dup(fromIndex int) {
+	C.duk_dup(d.duk_context, C.duk_idx_t(fromIndex))
+}
+
+// See: http://duktape.org/api.html#duk_dup_top
+func (d *Context) DupTop() {
+	C.duk_dup_top(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_enum
+func (d *Context) Enum(objIndex int, enumFlags uint) {
+	C.duk_enum(d.duk_context, C.duk_idx_t(objIndex), C.duk_uint_t(enumFlags))
+}
+
+// See: http://duktape.org/api.html#duk_equals
+func (d *Context) Equals(index1 int, index2 int) bool {
+	return int(C.duk_equals(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2))) == 1
+}
+
+// Error pushes a new Error object to the stack and throws it. This will call
+// fmt.Sprint, forwarding arguments after the error code, to produce the
+// Error's message.
+//
+// See: http://duktape.org/api.html#duk_error
+func (d *Context) Error(errCode int, str string) {
+	__str__ := C.CString(str)
+	C._duk_error(d.duk_context, C.duk_errcode_t(errCode), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+func (d *Context) ErrorRaw(errCode int, filename string, line int, errMsg string) {
+	__filename__ := C.CString(filename)
+	__errMsg__ := C.CString(errMsg)
+	C._duk_error_raw(d.duk_context, C.duk_errcode_t(errCode), __filename__, C.duk_int_t(line), __errMsg__)
+	C.free(unsafe.Pointer(__filename__))
+	C.free(unsafe.Pointer(__errMsg__))
+}
+
+// Errorf pushes a new Error object to the stack and throws it. This will call
+// fmt.Sprintf, forwarding the format string and additional arguments, to
+// produce the Error's message.
+//
+// See: http://duktape.org/api.html#duk_error
+func (d *Context) Errorf(errCode int, format string, a ...interface{}) {
+	str := fmt.Sprintf(format, a...)
+	__str__ := C.CString(str)
+	C._duk_error(d.duk_context, C.duk_errcode_t(errCode), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+// See: http://duktape.org/api.html#duk_eval
+func (d *Context) Eval() {
+	C._duk_eval(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_eval_file
+func (d *Context) EvalFile(path string) {
+	__path__ := C.CString(path)
+	C._duk_eval_file(d.duk_context, __path__)
+	C.free(unsafe.Pointer(__path__))
+}
+
+// See: http://duktape.org/api.html#duk_eval_file_noresult
+func (d *Context) EvalFileNoresult(path string) {
+	__path__ := C.CString(path)
+	C._duk_eval_file_noresult(d.duk_context, __path__)
+	C.free(unsafe.Pointer(__path__))
+}
+
+// See: http://duktape.org/api.html#duk_eval_lstring
+func (d *Context) EvalLstring(src string, len int) {
+	__src__ := C.CString(src)
+	C._duk_eval_lstring(d.duk_context, __src__, C.duk_size_t(len))
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_eval_lstring_noresult
+func (d *Context) EvalLstringNoresult(src string, len int) {
+	__src__ := C.CString(src)
+	C._duk_eval_lstring_noresult(d.duk_context, __src__, C.duk_size_t(len))
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_eval_noresult
+func (d *Context) EvalNoresult() {
+	C._duk_eval_noresult(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_eval_string
+func (d *Context) EvalString(src string) {
+	__src__ := C.CString(src)
+	C._duk_eval_string(d.duk_context, __src__)
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_eval_string_noresult
+func (d *Context) EvalStringNoresult(src string) {
+	__src__ := C.CString(src)
+	C._duk_eval_string_noresult(d.duk_context, __src__)
+	C.free(unsafe.Pointer(__src__))
+}
+
+// See: http://duktape.org/api.html#duk_fatal
+func (d *Context) Fatal(errCode int, errMsg string) {
+	__errMsg__ := C.CString(errMsg)
+	defer C.free(unsafe.Pointer(__errMsg__))
+	C.duk_fatal_raw(d.duk_context, __errMsg__)
+}
+
+// See: http://duktape.org/api.html#duk_gc
+func (d *Context) Gc(flags uint) {
+	C.duk_gc(d.duk_context, C.duk_uint_t(flags))
+}
+
+// See: http://duktape.org/api.html#duk_get_boolean
+func (d *Context) GetBoolean(index int) bool {
+	return int(C.duk_get_boolean(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_get_buffer
+func (d *Context) GetBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) {
+	rawPtr = C.duk_get_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize)))
+	return rawPtr, outSize
+}
+
+// See: http://duktape.org/api.html#duk_get_context
+func (d *Context) GetContext(index int) *Context {
+	return contextFromPointer(C.duk_get_context(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_current_magic
+func (d *Context) GetCurrentMagic() int {
+	return int(C.duk_get_current_magic(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_get_error_code
+func (d *Context) GetErrorCode(index int) int {
+	code := int(C.duk_get_error_code(d.duk_context, C.duk_idx_t(index)))
+	return code
+}
+
+// See: http://duktape.org/api.html#duk_get_finalizer
+func (d *Context) GetFinalizer(index int) {
+	C.duk_get_finalizer(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_get_global_string
+func (d *Context) GetGlobalString(key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_get_global_string(d.duk_context, __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_get_heapptr
+func (d *Context) GetHeapptr(index int) unsafe.Pointer {
+	return unsafe.Pointer(C.duk_get_heapptr(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_int
+func (d *Context) GetInt(index int) int {
+	return int(C.duk_get_int(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_length
+func (d *Context) GetLength(index int) int {
+	return int(C.duk_get_length(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_lstring
+func (d *Context) GetLstring(index int) string {
+	if s := C.duk_get_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_get_magic
+func (d *Context) GetMagic(index int) int {
+	return int(C.duk_get_magic(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_number
+func (d *Context) GetNumber(index int) float64 {
+	return float64(C.duk_get_number(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_pointer
+func (d *Context) GetPointer(index int) unsafe.Pointer {
+	return C.duk_get_pointer(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_get_prop
+func (d *Context) GetProp(objIndex int) bool {
+	return int(C.duk_get_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_get_prop_index
+func (d *Context) GetPropIndex(objIndex int, arrIndex uint) bool {
+	return int(C.duk_get_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_get_prop_string
+func (d *Context) GetPropString(objIndex int, key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_get_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_get_prototype
+func (d *Context) GetPrototype(index int) {
+	C.duk_get_prototype(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_get_string
+func (d *Context) GetString(i int) string {
+	if s := C.duk_get_string(d.duk_context, C.duk_idx_t(i)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_get_top
+func (d *Context) GetTop() int {
+	return int(C.duk_get_top(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_get_top_index
+func (d *Context) GetTopIndex() int {
+	return int(C.duk_get_top_index(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_get_type
+func (d *Context) GetType(index int) Type {
+	return Type(C.duk_get_type(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_type_mask
+func (d *Context) GetTypeMask(index int) uint {
+	return uint(C.duk_get_type_mask(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_get_uint
+func (d *Context) GetUint(index int) uint {
+	return uint(C.duk_get_uint(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_has_prop
+func (d *Context) HasProp(objIndex int) bool {
+	return int(C.duk_has_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_has_prop_index
+func (d *Context) HasPropIndex(objIndex int, arrIndex uint) bool {
+	return int(C.duk_has_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_has_prop_string
+func (d *Context) HasPropString(objIndex int, key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_has_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_hex_decode
+func (d *Context) HexDecode(index int) {
+	C.duk_hex_decode(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_hex_encode
+func (d *Context) HexEncode(index int) string {
+	if s := C.duk_hex_encode(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_insert
+func (d *Context) Insert(toIndex int) {
+	C.duk_insert(d.duk_context, C.duk_idx_t(toIndex))
+}
+
+// See: http://duktape.org/api.html#duk_is_array
+func (d *Context) IsArray(index int) bool {
+	return int(C.duk_is_array(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_boolean
+func (d *Context) IsBoolean(index int) bool {
+	return int(C.duk_is_boolean(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_bound_function
+func (d *Context) IsBoundFunction(index int) bool {
+	return int(C.duk_is_bound_function(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_buffer
+func (d *Context) IsBuffer(index int) bool {
+	return int(C.duk_is_buffer(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_c_function
+func (d *Context) IsCFunction(index int) bool {
+	return int(C.duk_is_c_function(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_callable
+func (d *Context) IsCallable(index int) bool {
+	return int(C.duk_is_function(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_constructor_call
+func (d *Context) IsConstructorCall() bool {
+	return int(C.duk_is_constructor_call(d.duk_context)) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_dynamic_buffer
+func (d *Context) IsDynamicBuffer(index int) bool {
+	return int(C.duk_is_dynamic_buffer(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_ecmascript_function
+func (d *Context) IsEcmascriptFunction(index int) bool {
+	return int(C.duk_is_ecmascript_function(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_fixed_buffer
+func (d *Context) IsFixedBuffer(index int) bool {
+	return int(C.duk_is_fixed_buffer(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_function
+func (d *Context) IsFunction(index int) bool {
+	return int(C.duk_is_function(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_nan
+func (d *Context) IsNan(index int) bool {
+	return int(C.duk_is_nan(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_null
+func (d *Context) IsNull(index int) bool {
+	return int(C.duk_is_null(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_null_or_undefined
+func (d *Context) IsNullOrUndefined(index int) bool {
+	return d.IsNull(index) || d.IsUndefined(index)
+}
+
+// See: http://duktape.org/api.html#duk_is_number
+func (d *Context) IsNumber(index int) bool {
+	return int(C.duk_is_number(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_object
+func (d *Context) IsObject(index int) bool {
+	return int(C.duk_is_object(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_error
+func (d *Context) IsError(index int) bool {
+	return int(C._duk_is_error(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_object_coercible
+func (d *Context) IsObjectCoercible(index int) bool {
+	return int(C._duk_is_object_coercible(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_pointer
+func (d *Context) IsPointer(index int) bool {
+	return int(C.duk_is_pointer(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_primitive
+func (d *Context) IsPrimitive(index int) bool {
+	return int(C._duk_is_primitive(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_strict_call
+func (d *Context) IsStrictCall() bool {
+	return int(C.duk_is_strict_call(d.duk_context)) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_string
+func (d *Context) IsString(index int) bool {
+	return int(C.duk_is_string(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_thread
+func (d *Context) IsThread(index int) bool {
+	return int(C.duk_is_thread(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_undefined
+func (d *Context) IsUndefined(index int) bool {
+	return int(C.duk_is_undefined(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_valid_index
+func (d *Context) IsValidIndex(index int) bool {
+	return int(C.duk_is_valid_index(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_join
+func (d *Context) Join(count int) {
+	C.duk_join(d.duk_context, C.duk_idx_t(count))
+}
+
+// See: http://duktape.org/api.html#duk_json_decode
+func (d *Context) JsonDecode(index int) {
+	C.duk_json_decode(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_json_encode
+func (d *Context) JsonEncode(index int) string {
+	if s := C.duk_json_encode(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_new
+func (d *Context) New(nargs int) {
+	C.duk_new(d.duk_context, C.duk_idx_t(nargs))
+}
+
+// See: http://duktape.org/api.html#duk_next
+func (d *Context) Next(enumIndex int, getValue bool) bool {
+	var __getValue__ int
+	if getValue {
+		__getValue__ = 1
+	}
+	return int(C.duk_next(d.duk_context, C.duk_idx_t(enumIndex), C.duk_bool_t(__getValue__))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_normalize_index
+func (d *Context) NormalizeIndex(index int) int {
+	return int(C.duk_normalize_index(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_pcall
+func (d *Context) Pcall(nargs int) int {
+	return int(C.duk_pcall(d.duk_context, C.duk_idx_t(nargs)))
+}
+
+// See: http://duktape.org/api.html#duk_pcall_method
+func (d *Context) PcallMethod(nargs int) int {
+	return int(C.duk_pcall_method(d.duk_context, C.duk_idx_t(nargs)))
+}
+
+// See: http://duktape.org/api.html#duk_pcall_prop
+func (d *Context) PcallProp(objIndex int, nargs int) int {
+	return int(C.duk_pcall_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_idx_t(nargs)))
+}
+
+// See: http://duktape.org/api.html#duk_pcompile
+func (d *Context) Pcompile(flags uint) error {
+	result := int(C._duk_pcompile(d.duk_context, C.duk_uint_t(flags)))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_pcompile_file
+func (d *Context) PcompileFile(flags uint, path string) error {
+	__path__ := C.CString(path)
+	result := int(C._duk_pcompile_file(d.duk_context, C.duk_uint_t(flags), __path__))
+	C.free(unsafe.Pointer(__path__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_pcompile_lstring
+func (d *Context) PcompileLstring(flags uint, src string, len int) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_pcompile_lstring(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len)))
+	C.free(unsafe.Pointer(__src__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_pcompile_lstring_filename
+func (d *Context) PcompileLstringFilename(flags uint, src string, len int) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_pcompile_lstring_filename(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len)))
+	C.free(unsafe.Pointer(__src__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_pcompile_string
+func (d *Context) PcompileString(flags uint, src string) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_pcompile_string(d.duk_context, C.duk_uint_t(flags), __src__))
+	C.free(unsafe.Pointer(__src__))
+	fmt.Println("result herhehreh", result)
+	return nil //d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_pcompile_string_filename
+func (d *Context) PcompileStringFilename(flags uint, src string) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_pcompile_string_filename(d.duk_context, C.duk_uint_t(flags), __src__))
+	C.free(unsafe.Pointer(__src__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_peval
+func (d *Context) Peval() error {
+	result := int(C._duk_peval(d.duk_context))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_peval_file
+func (d *Context) PevalFile(path string) error {
+	__path__ := C.CString(path)
+	result := int(C._duk_peval_file(d.duk_context, __path__))
+	C.free(unsafe.Pointer(__path__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_peval_file_noresult
+func (d *Context) PevalFileNoresult(path string) int {
+	__path__ := C.CString(path)
+	result := int(C._duk_peval_file_noresult(d.duk_context, __path__))
+	C.free(unsafe.Pointer(__path__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_peval_lstring
+func (d *Context) PevalLstring(src string, len int) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_peval_lstring(d.duk_context, __src__, C.duk_size_t(len)))
+	C.free(unsafe.Pointer(__src__))
+	return d.castStringToError(result)
+
+}
+
+// See: http://duktape.org/api.html#duk_peval_lstring_noresult
+func (d *Context) PevalLstringNoresult(src string, len int) int {
+	__src__ := C.CString(src)
+	result := int(C._duk_peval_lstring_noresult(d.duk_context, __src__, C.duk_size_t(len)))
+	C.free(unsafe.Pointer(__src__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_peval_noresult
+func (d *Context) PevalNoresult() int {
+	return int(C._duk_peval_noresult(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_peval_string
+func (d *Context) PevalString(src string) error {
+	__src__ := C.CString(src)
+	result := int(C._duk_peval_string(d.duk_context, __src__))
+	C.free(unsafe.Pointer(__src__))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_peval_string_noresult
+func (d *Context) PevalStringNoresult(src string) int {
+	__src__ := C.CString(src)
+	result := int(C._duk_peval_string_noresult(d.duk_context, __src__))
+	C.free(unsafe.Pointer(__src__))
+	return result
+}
+
+func (d *Context) castStringToError(result int) error {
+	if result == 0 {
+		return nil
+	}
+
+	err := &Error{}
+	for _, key := range []string{"name", "message", "fileName", "lineNumber", "stack"} {
+		d.GetPropString(-1, key)
+
+		switch key {
+		case "name":
+			err.Type = d.SafeToString(-1)
+		case "message":
+			err.Message = d.SafeToString(-1)
+		case "fileName":
+			err.FileName = d.SafeToString(-1)
+		case "lineNumber":
+			if d.IsNumber(-1) {
+				err.LineNumber = d.GetInt(-1)
+			}
+		case "stack":
+			err.Stack = d.SafeToString(-1)
+		}
+
+		d.Pop()
+	}
+
+	return err
+}
+
+// See: http://duktape.org/api.html#duk_pop
+func (d *Context) Pop() {
+	if d.GetTop() == 0 {
+		return
+	}
+	C.duk_pop(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_pop_2
+func (d *Context) Pop2() {
+	d.PopN(2)
+}
+
+// See: http://duktape.org/api.html#duk_pop_3
+func (d *Context) Pop3() {
+	d.PopN(3)
+}
+
+// See: http://duktape.org/api.html#duk_pop_n
+func (d *Context) PopN(count int) {
+	if d.GetTop() < count || count < 1 {
+		return
+	}
+	C.duk_pop_n(d.duk_context, C.duk_idx_t(count))
+}
+
+// See: http://duktape.org/api.html#duk_push_array
+func (d *Context) PushArray() int {
+	return int(C.duk_push_array(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_push_boolean
+func (d *Context) PushBoolean(val bool) {
+	var __val__ int
+	if val {
+		__val__ = 1
+	}
+	C.duk_push_boolean(d.duk_context, C.duk_bool_t(__val__))
+}
+
+// See: http://duktape.org/api.html#duk_push_buffer
+func (d *Context) PushBuffer(size int, dynamic bool) unsafe.Pointer {
+	var __dynamic__ int
+	if dynamic {
+		__dynamic__ = 1
+	}
+	return C._duk_push_buffer(d.duk_context, C.duk_size_t(size), C.duk_bool_t(__dynamic__))
+}
+
+// See: http://duktape.org/api.html#duk_push_c_function
+func (d *Context) PushCFunction(fn *[0]byte, nargs int64) int {
+	return int(C.duk_push_c_function(d.duk_context, fn, C.duk_idx_t(nargs)))
+}
+
+// See: http://duktape.org/api.html#duk_push_context_dump
+func (d *Context) PushContextDump() {
+	C.duk_push_context_dump(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_current_function
+func (d *Context) PushCurrentFunction() {
+	C.duk_push_current_function(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_current_thread
+func (d *Context) PushCurrentThread() {
+	C.duk_push_current_thread(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_dynamic_buffer
+func (d *Context) PushDynamicBuffer(size int) unsafe.Pointer {
+	return C._duk_push_dynamic_buffer(d.duk_context, C.duk_size_t(size))
+}
+
+// See: http://duktape.org/api.html#duk_push_error_object
+func (d *Context) PushErrorObject(errCode int, format string, value interface{}) {
+	__str__ := C.CString(fmt.Sprintf(format, value))
+	C._duk_push_error_object(d.duk_context, C.duk_errcode_t(errCode), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+// See: http://duktape.org/api.html#duk_push_false
+func (d *Context) PushFalse() {
+	C.duk_push_false(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_fixed_buffer
+func (d *Context) PushFixedBuffer(size int) unsafe.Pointer {
+	return C._duk_push_fixed_buffer(d.duk_context, C.duk_size_t(size))
+}
+
+// See: http://duktape.org/api.html#duk_push_global_object
+func (d *Context) PushGlobalObject() {
+	C.duk_push_global_object(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_global_stash
+func (d *Context) PushGlobalStash() {
+	C.duk_push_global_stash(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_heapptr
+func (d *Context) PushHeapptr(ptr unsafe.Pointer) {
+	C.duk_push_heapptr(d.duk_context, ptr)
+}
+
+// See: http://duktape.org/api.html#duk_push_heap_stash
+func (d *Context) PushHeapStash() {
+	C.duk_push_heap_stash(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_int
+func (d *Context) PushInt(val int) {
+	C.duk_push_int(d.duk_context, C.duk_int_t(val))
+}
+
+// See: http://duktape.org/api.html#duk_push_lstring
+func (d *Context) PushLstring(str string, len int) string {
+	__str__ := C.CString(str)
+	var result string
+	if s := C.duk_push_lstring(d.duk_context, __str__, C.duk_size_t(len)); s != nil {
+		result = C.GoString(s)
+	}
+	C.free(unsafe.Pointer(__str__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_push_nan
+func (d *Context) PushNan() {
+	C.duk_push_nan(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_null
+func (d *Context) PushNull() {
+	C.duk_push_null(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_number
+func (d *Context) PushNumber(val float64) {
+	C.duk_push_number(d.duk_context, C.duk_double_t(val))
+}
+
+// See: http://duktape.org/api.html#duk_push_object
+func (d *Context) PushObject() int {
+	return int(C.duk_push_object(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_push_string
+func (d *Context) PushString(str string) string {
+	__str__ := C.CString(str)
+	var result string
+	if s := C.duk_push_string(d.duk_context, __str__); s != nil {
+		result = C.GoString(s)
+	}
+	C.free(unsafe.Pointer(__str__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_push_string_file
+func (d *Context) PushStringFile(path string) string {
+	__path__ := C.CString(path)
+	var result string
+	if s := C._duk_push_string_file(d.duk_context, __path__); s != nil {
+		result = C.GoString(s)
+	}
+	C.free(unsafe.Pointer(__path__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_push_this
+func (d *Context) PushThis() {
+	C.duk_push_this(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_thread
+func (d *Context) PushThread() int {
+	return int(C._duk_push_thread(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_push_thread_new_globalenv
+func (d *Context) PushThreadNewGlobalenv() int {
+	return int(C._duk_push_thread_new_globalenv(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_push_thread_stash
+func (d *Context) PushThreadStash(targetCtx *Context) {
+	C.duk_push_thread_stash(d.duk_context, targetCtx.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_true
+func (d *Context) PushTrue() {
+	C.duk_push_true(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_push_uint
+func (d *Context) PushUint(val uint) {
+	C.duk_push_uint(d.duk_context, C.duk_uint_t(val))
+}
+
+// See: http://duktape.org/api.html#duk_push_undefined
+func (d *Context) PushUndefined() {
+	C.duk_push_undefined(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_put_global_string
+func (d *Context) PutGlobalString(key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_put_global_string(d.duk_context, __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_put_prop
+func (d *Context) PutProp(objIndex int) bool {
+	return int(C.duk_put_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_put_prop_index
+func (d *Context) PutPropIndex(objIndex int, arrIndex uint) bool {
+	return int(C.duk_put_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_put_prop_string
+func (d *Context) PutPropString(objIndex int, key string) bool {
+	__key__ := C.CString(key)
+	result := int(C.duk_put_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1
+	C.free(unsafe.Pointer(__key__))
+	return result
+}
+
+// See: http://duktape.org/api.html#duk_remove
+func (d *Context) Remove(index int) {
+	C.duk_remove(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_replace
+func (d *Context) Replace(toIndex int) {
+	C.duk_replace(d.duk_context, C.duk_idx_t(toIndex))
+}
+
+// See: http://duktape.org/api.html#duk_require_boolean
+func (d *Context) RequireBoolean(index int) bool {
+	return int(C.duk_require_boolean(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_require_buffer
+func (d *Context) RequireBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) {
+	rawPtr = C.duk_require_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize)))
+	return rawPtr, outSize
+}
+
+// See: http://duktape.org/api.html#duk_require_callable
+func (d *Context) RequireCallable(index int) {
+	// At present, duk_require_callable is a macro that just calls duk_require_function.
+	// cgo does not support such macros we have to call it directly.
+	C.duk_require_function(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_context
+func (d *Context) RequireContext(index int) *Context {
+	return contextFromPointer(C.duk_require_context(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_function
+func (d *Context) RequireFunction(index int) {
+	C.duk_require_function(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_heapptr
+func (d *Context) RequireHeapptr(index int) unsafe.Pointer {
+	return unsafe.Pointer(C.duk_require_heapptr(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_int
+func (d *Context) RequireInt(index int) int {
+	return int(C.duk_require_int(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_lstring
+func (d *Context) RequireLstring(index int) string {
+	if s := C.duk_require_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_require_normalize_index
+func (d *Context) RequireNormalizeIndex(index int) int {
+	return int(C.duk_require_normalize_index(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_null
+func (d *Context) RequireNull(index int) {
+	C.duk_require_null(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_number
+func (d *Context) RequireNumber(index int) float64 {
+	return float64(C.duk_require_number(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_object_coercible
+func (d *Context) RequireObjectCoercible(index int) {
+	C._duk_require_object_coercible(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_pointer
+func (d *Context) RequirePointer(index int) unsafe.Pointer {
+	return C.duk_require_pointer(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_stack
+func (d *Context) RequireStack(extra int) {
+	C.duk_require_stack(d.duk_context, C.duk_idx_t(extra))
+}
+
+// See: http://duktape.org/api.html#duk_require_stack_top
+func (d *Context) RequireStackTop(top int) {
+	C.duk_require_stack_top(d.duk_context, C.duk_idx_t(top))
+}
+
+// See: http://duktape.org/api.html#duk_require_string
+func (d *Context) RequireString(index int) string {
+	if s := C.duk_require_string(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_require_top_index
+func (d *Context) RequireTopIndex() int {
+	return int(C.duk_require_top_index(d.duk_context))
+}
+
+// See: http://duktape.org/api.html#duk_require_type_mask
+func (d *Context) RequireTypeMask(index int, mask uint) {
+	C._duk_require_type_mask(d.duk_context, C.duk_idx_t(index), C.duk_uint_t(mask))
+}
+
+// See: http://duktape.org/api.html#duk_require_uint
+func (d *Context) RequireUint(index int) uint {
+	return uint(C.duk_require_uint(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_require_undefined
+func (d *Context) RequireUndefined(index int) {
+	C.duk_require_undefined(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_require_valid_index
+func (d *Context) RequireValidIndex(index int) {
+	C.duk_require_valid_index(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_resize_buffer
+func (d *Context) ResizeBuffer(index int, newSize int) unsafe.Pointer {
+	return C.duk_resize_buffer(d.duk_context, C.duk_idx_t(index), C.duk_size_t(newSize))
+}
+
+// See: http://duktape.org/api.html#duk_safe_call
+func (d *Context) SafeCall(fn, args *[0]byte, nargs, nrets int) int {
+	return int(C.duk_safe_call(
+		d.duk_context,
+		fn,
+		unsafe.Pointer(&args),
+		C.duk_idx_t(nargs),
+		C.duk_idx_t(nrets),
+	))
+}
+
+// See: http://duktape.org/api.html#duk_safe_to_lstring
+func (d *Context) SafeToLstring(index int) string {
+	if s := C.duk_safe_to_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_safe_to_string
+func (d *Context) SafeToString(index int) string {
+	if s := C._duk_safe_to_string(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_set_finalizer
+func (d *Context) SetFinalizer(index int) {
+	C.duk_set_finalizer(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_set_global_object
+func (d *Context) SetGlobalObject() {
+	C.duk_set_global_object(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_set_magic
+func (d *Context) SetMagic(index int, magic int) {
+	C.duk_set_magic(d.duk_context, C.duk_idx_t(index), C.duk_int_t(magic))
+}
+
+// See: http://duktape.org/api.html#duk_set_prototype
+func (d *Context) SetPrototype(index int) {
+	C.duk_set_prototype(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_set_top
+func (d *Context) SetTop(index int) {
+	C.duk_set_top(d.duk_context, C.duk_idx_t(index))
+}
+
+func (d *Context) StrictEquals(index1 int, index2 int) bool {
+	return int(C.duk_strict_equals(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_substring
+func (d *Context) Substring(index int, startCharOffset int, endCharOffset int) {
+	C.duk_substring(d.duk_context, C.duk_idx_t(index), C.duk_size_t(startCharOffset), C.duk_size_t(endCharOffset))
+}
+
+// See: http://duktape.org/api.html#duk_swap
+func (d *Context) Swap(index1 int, index2 int) {
+	C.duk_swap(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2))
+}
+
+// See: http://duktape.org/api.html#duk_swap_top
+func (d *Context) SwapTop(index int) {
+	C.duk_swap_top(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_throw
+func (d *Context) Throw() {
+	C.duk_throw_raw(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_to_boolean
+func (d *Context) ToBoolean(index int) bool {
+	return int(C.duk_to_boolean(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_to_buffer
+func (d *Context) ToBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) {
+	rawPtr = C._duk_to_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize)))
+	return rawPtr, outSize
+}
+
+// See: http://duktape.org/api.html#duk_to_defaultvalue
+func (d *Context) ToDefaultvalue(index int, hint int) {
+	C.duk_to_defaultvalue(d.duk_context, C.duk_idx_t(index), C.duk_int_t(hint))
+}
+
+// See: http://duktape.org/api.html#duk_to_dynamic_buffer
+func (d *Context) ToDynamicBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) {
+	rawPtr = C._duk_to_dynamic_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize)))
+	return rawPtr, outSize
+}
+
+// See: http://duktape.org/api.html#duk_to_fixed_buffer
+func (d *Context) ToFixedBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) {
+	rawPtr = C._duk_to_fixed_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize)))
+	return rawPtr, outSize
+}
+
+// See: http://duktape.org/api.html#duk_to_int
+func (d *Context) ToInt(index int) int {
+	return int(C.duk_to_int(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_int32
+func (d *Context) ToInt32(index int) int32 {
+	return int32(C.duk_to_int32(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_lstring
+func (d *Context) ToLstring(index int) string {
+	if s := C.duk_to_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_to_null
+func (d *Context) ToNull(index int) {
+	C.duk_to_null(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_to_number
+func (d *Context) ToNumber(index int) float64 {
+	return float64(C.duk_to_number(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_object
+func (d *Context) ToObject(index int) {
+	C.duk_to_object(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_to_pointer
+func (d *Context) ToPointer(index int) unsafe.Pointer {
+	return C.duk_to_pointer(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_to_primitive
+func (d *Context) ToPrimitive(index int, hint int) {
+	C.duk_to_primitive(d.duk_context, C.duk_idx_t(index), C.duk_int_t(hint))
+}
+
+// See: http://duktape.org/api.html#duk_to_string
+func (d *Context) ToString(index int) string {
+	if s := C.duk_to_string(d.duk_context, C.duk_idx_t(index)); s != nil {
+		return C.GoString(s)
+	}
+	return ""
+}
+
+// See: http://duktape.org/api.html#duk_to_uint
+func (d *Context) ToUint(index int) uint {
+	return uint(C.duk_to_uint(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_uint16
+func (d *Context) ToUint16(index int) uint16 {
+	return uint16(C.duk_to_uint16(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_uint32
+func (d *Context) ToUint32(index int) uint32 {
+	return uint32(C.duk_to_uint32(d.duk_context, C.duk_idx_t(index)))
+}
+
+// See: http://duktape.org/api.html#duk_to_undefined
+func (d *Context) ToUndefined(index int) {
+	C.duk_to_undefined(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_trim
+func (d *Context) Trim(index int) {
+	C.duk_trim(d.duk_context, C.duk_idx_t(index))
+}
+
+// See: http://duktape.org/api.html#duk_xcopy_top
+func (d *Context) XcopyTop(fromCtx *Context, count int) {
+	C._duk_xcopy_top(d.duk_context, fromCtx.duk_context, C.duk_idx_t(count))
+}
+
+// See: http://duktape.org/api.html#duk_xmove_top
+func (d *Context) XmoveTop(fromCtx *Context, count int) {
+	C._duk_xmove_top(d.duk_context, fromCtx.duk_context, C.duk_idx_t(count))
+}
+
+// See: http://duktape.org/api.html#duk_push_pointer
+func (d *Context) PushPointer(p unsafe.Pointer) {
+	C.duk_push_pointer(d.duk_context, p)
+}
+
+//---[ Duktape 1.3 API ]--- //
+// See: http://duktape.org/api.html#duk_debugger_attach
+func (d *Context) DebuggerAttach(
+	readFn,
+	writeFn,
+	peekFn,
+	readFlushFn,
+	writeFlushFn,
+	detachedFn *[0]byte,
+	uData unsafe.Pointer) {
+	C.duk_debugger_attach(
+		d.duk_context,
+		readFn,
+		writeFn,
+		peekFn,
+		readFlushFn,
+		writeFlushFn,
+		nil,
+		detachedFn,
+		uData,
+	)
+}
+
+// See: http://duktape.org/api.html#duk_debugger_cooperate
+func (d *Context) DebuggerCooperate() {
+	C.duk_debugger_cooperate(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_debugger_detach
+func (d *Context) DebuggerDetach() {
+	C.duk_debugger_detach(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_dump_function
+func (d *Context) DumpFunction() {
+	C.duk_dump_function(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_error_va
+func (d *Context) ErrorVa(errCode int, a ...interface{}) {
+	str := fmt.Sprint(a...)
+	d.Error(errCode, str)
+}
+
+// See: http://duktape.org/api.html#duk_instanceof
+func (d *Context) Instanceof(idx1, idx2 int) bool {
+	return int(C.duk_instanceof(d.duk_context, C.duk_idx_t(idx1), C.duk_idx_t(idx2))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_is_lightfunc
+func (d *Context) IsLightfunc(index int) bool {
+	return int(C.duk_is_lightfunc(d.duk_context, C.duk_idx_t(index))) == 1
+}
+
+// See: http://duktape.org/api.html#duk_load_function
+func (d *Context) LoadFunction() {
+	C.duk_load_function(d.duk_context)
+}
+
+// See: http://duktape.org/api.html#duk_log
+func (d *Context) Log(loglevel int, format string, value interface{}) {
+	__str__ := C.CString(fmt.Sprintf(format, value))
+	C._duk_log(d.duk_context, C.duk_int_t(loglevel), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+// See: http://duktape.org/api.html#duk_log_va
+func (d *Context) LogVa(logLevel int, format string, values ...interface{}) {
+	__str__ := C.CString(fmt.Sprintf(format, values...))
+	C._duk_log(d.duk_context, C.duk_int_t(logLevel), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+// See: http://duktape.org/api.html#duk_pnew
+func (d *Context) Pnew(nargs int) error {
+	result := int(C.duk_pnew(d.duk_context, C.duk_idx_t(nargs)))
+	return d.castStringToError(result)
+}
+
+// See: http://duktape.org/api.html#duk_push_buffer_object
+func (d *Context) PushBufferObject(bufferIdx, size, length int, flags uint) {
+	C.duk_push_buffer_object(
+		d.duk_context,
+		C.duk_idx_t(bufferIdx),
+		C.duk_size_t(size),
+		C.duk_size_t(length),
+		C.duk_uint_t(flags),
+	)
+}
+
+// See: http://duktape.org/api.html#duk_push_c_lightfunc
+func (d *Context) PushCLightfunc(fn *[0]byte, nargs, length, magic int) int {
+	return int(C.duk_push_c_lightfunc(
+		d.duk_context,
+		fn,
+		C.duk_idx_t(nargs),
+		C.duk_idx_t(length),
+		C.duk_int_t(magic),
+	))
+}
+
+// See: http://duktape.org/api.html#duk_push_error_object_va
+func (d *Context) PushErrorObjectVa(errCode int, format string, values ...interface{}) {
+	__str__ := C.CString(fmt.Sprintf(format, values...))
+	C._duk_push_error_object(d.duk_context, C.duk_errcode_t(errCode), __str__)
+	C.free(unsafe.Pointer(__str__))
+}
+
+// See: http://duktape.org/api.html#duk_push_external_buffer
+func (d *Context) PushExternalBuffer() {
+	C._duk_push_external_buffer(d.duk_context)
+}
+
+/**
+ * Unimplemented.
+ *
+ * CharCodeAt see: http://duktape.org/api.html#duk_char_code_at
+ * CreateHeap see: http://duktape.org/api.html#duk_create_heap
+ * DecodeString see: http://duktape.org/api.html#duk_decode_string
+ * Free see: http://duktape.org/api.html#duk_free
+ * FreeRaw see: http://duktape.org/api.html#duk_free_raw
+ * GetCFunction see: http://duktape.org/api.html#duk_get_c_function
+ * GetMemoryFunctions see: http://duktape.org/api.html#duk_get_memory_functions
+ * MapString see: http://duktape.org/api.html#duk_map_string
+ * PushSprintf see: http://duktape.org/api.html#duk_push_sprintf
+ * PushVsprintf see: http://duktape.org/api.html#duk_push_vsprintf
+ * PutFunctionList see: http://duktape.org/api.html#duk_put_function_list
+ * PutNumberList see: http://duktape.org/api.html#duk_put_number_list
+ * Realloc see: http://duktape.org/api.html#duk_realloc
+ * ReallocRaw see: http://duktape.org/api.html#duk_realloc_raw
+ * RequireCFunction see: http://duktape.org/api.html#duk_require_c_function
+ * ConfigBuffer see: http://duktape.org/api.html#duk_config_buffer
+ * GetBufferData see: http://duktape.org/api.html#duk_get_buffer_data
+ * StealBuffer see: http://duktape.org/api.html#duk_steal_buffer
+ * RequireBufferData see: http://duktape.org/api.html#duk_require_buffer_data
+ * IsEvalError see: http://duktape.org/api.html#duk_is_eval_error
+ */
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml b/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml
new file mode 100644
index 0000000000..7d38d58b12
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml
@@ -0,0 +1,34 @@
+os: Visual Studio 2015
+
+clone_folder: C:\gopath\src\gopkg.in/olebedev/go-duktape.v3
+clone_depth: 5
+version: "{branch}.{build}"
+environment:
+  global:
+    GOPATH: C:\gopath
+    CC: gcc.exe
+  matrix:
+    - DUKTAPE_ARCH: amd64
+      MSYS2_ARCH: x86_64
+      MSYS2_BITS: 64
+      MSYSTEM: MINGW64
+      PATH: C:\msys64\mingw64\bin\;C:\Program Files (x86)\NSIS\;%PATH%
+    - DUKTAPE_ARCH: 386
+      MSYS2_ARCH: i686
+      MSYS2_BITS: 32
+      MSYSTEM: MINGW32
+      PATH: C:\msys64\mingw32\bin\;C:\Program Files (x86)\NSIS\;%PATH%
+
+install:
+  - rmdir C:\go /s /q
+  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.2.windows-%DUKTAPE_ARCH%.zip
+  - 7z x go1.9.2.windows-%DUKTAPE_ARCH%.zip -y -oC:\ > NUL
+  - go version
+  - gcc --version
+
+build_script:
+  - go get -t
+  - go install ./...
+
+test_script:
+  - go test ./...
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go b/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go
new file mode 100644
index 0000000000..f3dbd8bc84
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go
@@ -0,0 +1,121 @@
+package duktape
+
+const (
+	CompileEval uint = 1 << iota
+	CompileFunction
+	CompileStrict
+	CompileSafe
+	CompileNoResult
+	CompileNoSource
+	CompileStrlen
+)
+
+const (
+	TypeNone Type = iota
+	TypeUndefined
+	TypeNull
+	TypeBoolean
+	TypeNumber
+	TypeString
+	TypeObject
+	TypeBuffer
+	TypePointer
+	TypeLightFunc
+)
+
+const (
+	TypeMaskNone uint = 1 << iota
+	TypeMaskUndefined
+	TypeMaskNull
+	TypeMaskBoolean
+	TypeMaskNumber
+	TypeMaskString
+	TypeMaskObject
+	TypeMaskBuffer
+	TypeMaskPointer
+	TypeMaskLightFunc
+)
+
+const (
+	EnumIncludeNonenumerable uint = 1 << iota
+	EnumIncludeInternal
+	EnumOwnPropertiesOnly
+	EnumArrayIndicesOnly
+	EnumSortArrayIndices
+	NoProxyBehavior
+)
+
+const (
+	ErrNone int = 0
+
+	// Internal to Duktape
+	ErrUnimplemented int = 50 + iota
+	ErrUnsupported
+	ErrInternal
+	ErrAlloc
+	ErrAssertion
+	ErrAPI
+	ErrUncaughtError
+)
+
+const (
+	// Common prototypes
+	ErrError int = 1 + iota
+	ErrEval
+	ErrRange
+	ErrReference
+	ErrSyntax
+	ErrType
+	ErrURI
+)
+
+const (
+	// Returned error values
+	ErrRetUnimplemented int = -(ErrUnimplemented + iota)
+	ErrRetUnsupported
+	ErrRetInternal
+	ErrRetAlloc
+	ErrRetAssertion
+	ErrRetAPI
+	ErrRetUncaughtError
+)
+
+const (
+	ErrRetError int = -(ErrError + iota)
+	ErrRetEval
+	ErrRetRange
+	ErrRetReference
+	ErrRetSyntax
+	ErrRetType
+	ErrRetURI
+)
+
+const (
+	ExecSuccess = iota
+	ExecError
+)
+
+const (
+	LogTrace int = iota
+	LogDebug
+	LogInfo
+	LogWarn
+	LogError
+	LogFatal
+)
+
+const (
+	BufobjDuktapeAuffer     = 0
+	BufobjNodejsAuffer      = 1
+	BufobjArraybuffer       = 2
+	BufobjDataview          = 3
+	BufobjInt8array         = 4
+	BufobjUint8array        = 5
+	BufobjUint8clampedarray = 6
+	BufobjInt16array        = 7
+	BufobjUint16array       = 8
+	BufobjInt32array        = 9
+	BufobjUint32array       = 10
+	BufobjFloat32array      = 11
+	BufobjFloat64array      = 12
+)
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c
new file mode 100755
index 0000000000..750fa71df1
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c
@@ -0,0 +1,612 @@
+/*
+ *  Pool allocator for low memory targets.
+ */
+
+#include 
+#include 
+#include 
+#include 
+#include 
+#include "duktape.h"
+#include "duk_alloc_pool.h"
+
+/* Define to enable some debug printfs. */
+/* #define DUK_ALLOC_POOL_DEBUG */
+
+/* Define to enable approximate waste tracking. */
+/* #define DUK_ALLOC_POOL_TRACK_WASTE */
+
+/* Define to track global highwater for used and waste bytes.  VERY SLOW, only
+ * useful for manual testing.
+ */
+/* #define DUK_ALLOC_POOL_TRACK_HIGHWATER */
+
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+#if 0  /* This extern declaration is provided by duktape.h, array provided by duktape.c. */
+extern const void * const duk_rom_compressed_pointers[];
+#endif
+const void *duk_alloc_pool_romptr_low = NULL;
+const void *duk_alloc_pool_romptr_high = NULL;
+static void duk__alloc_pool_romptr_init(void);
+#endif
+
+#if defined(DUK_USE_HEAPPTR16)
+void *duk_alloc_pool_ptrcomp_base = NULL;
+#endif
+
+#if defined(DUK_ALLOC_POOL_DEBUG)
+static void duk__alloc_pool_dprintf(const char *fmt, ...) {
+	va_list ap;
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+}
+#endif
+
+/*
+ *  Pool initialization
+ */
+
+void *duk_alloc_pool_init(char *buffer,
+                          size_t size,
+                          const duk_pool_config *configs,
+                          duk_pool_state *states,
+                          int num_pools,
+                          duk_pool_global *global) {
+	double t_min, t_max, t_curr, x;
+	int step, i, j, n;
+	size_t total;
+	char *p;
+
+	/* XXX: check that 'size' is not too large when using pointer
+	 * compression.
+	 */
+
+	/* To optimize pool counts first come up with a 't' which still allows
+	 * total pool size to fit within user provided region.  After that
+	 * sprinkle any remaining bytes to the counts.  Binary search with a
+	 * fixed step count; last round uses 't_min' as 't_curr' to ensure it
+	 * succeeds.
+	 */
+
+	t_min = 0.0;  /* Unless config is insane, this should always be "good". */
+	t_max = 1e6;
+
+	for (step = 0; ; step++) {
+		if (step >= 100) {
+			/* Force "known good", rerun config, and break out.
+			 * Deals with rounding corner cases where t_curr is
+			 * persistently "bad" even though t_min is a valid
+			 * solution.
+			 */
+			t_curr = t_min;
+		} else {
+			t_curr = (t_min + t_max) / 2.0;
+		}
+
+		for (i = 0, total = 0; i < num_pools; i++) {
+			states[i].size = configs[i].size;
+
+			/* Target bytes = A*t + B ==> target count = (A*t + B) / block_size.
+			 * Rely on A and B being small enough so that 'x' won't wrap.
+			 */
+			x = ((double) configs[i].a * t_curr + (double) configs[i].b) / (double) configs[i].size;
+
+			states[i].count = (unsigned int) x;
+			total += (size_t) states[i].size * (size_t) states[i].count;
+			if (total > size) {
+				goto bad;
+			}
+		}
+
+		/* t_curr is good. */
+#if defined(DUK_ALLOC_POOL_DEBUG)
+		duk__alloc_pool_dprintf("duk_alloc_pool_init: step=%d, t=[%lf %lf %lf] -> total %ld/%ld (good)\n",
+		                        step, t_min, t_curr, t_max, (long) total, (long) size);
+#endif
+		if (step >= 100) {
+			/* Keep state[] initialization state.  The state was
+			 * created using the highest 't_min'.
+			 */
+			break;
+		}
+		t_min = t_curr;
+		continue;
+
+	 bad:
+		/* t_curr is bad. */
+#if defined(DUK_ALLOC_POOL_DEBUG)
+		duk__alloc_pool_dprintf("duk_alloc_pool_init: step=%d, t=[%lf %lf %lf] -> total %ld/%ld (bad)\n",
+		                        step, t_min, t_curr, t_max, (long) total, (long) size);
+#endif
+
+		if (step >= 1000) {
+			/* Cannot find any good solution; shouldn't happen
+			 * unless config is bad or 'size' is so small that
+			 * even a baseline allocation won't fit.
+			 */
+			return NULL;
+		}
+		t_max = t_curr;
+		/* continue */
+	}
+
+	/* The base configuration is now good; sprinkle any leftovers to
+	 * pools in descending order.  Note that for good t_curr, 'total'
+	 * indicates allocated bytes so far and 'size - total' indicates
+	 * leftovers.
+	 */
+	for (i = num_pools - 1; i >= 0; i--) {
+		while (size - total >= states[i].size) {
+			/* Ignore potential wrapping of states[i].count as the count
+			 * is 32 bits and shouldn't wrap in practice.
+			 */
+			states[i].count++;
+			total += states[i].size;
+#if defined(DUK_ALLOC_POOL_DEBUG)
+			duk__alloc_pool_dprintf("duk_alloc_pool_init: sprinkle %ld bytes (%ld left after) to pool index %ld, new count %ld\n",
+			                        (long) states[i].size, (long) (size - total), (long) i, (long) states[i].count);
+#endif
+		}
+	}
+
+	/* Pool counts are final.  Allocate the user supplied region based
+	 * on the final counts, initialize free lists for each block size,
+	 * and otherwise finalize 'state' for use.
+	 */
+	p = buffer;
+	global->num_pools = num_pools;
+	global->states = states;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+#if defined(DUK_ALLOC_POOL_DEBUG)
+	duk__alloc_pool_dprintf("duk_alloc_pool_init: global highwater mark tracking enabled, THIS IS VERY SLOW!\n");
+#endif
+	global->hwm_used_bytes = 0U;
+	global->hwm_waste_bytes = 0U;
+#endif
+#if defined(DUK_ALLOC_POOL_TRACK_WASTE)
+#if defined(DUK_ALLOC_POOL_DEBUG)
+	duk__alloc_pool_dprintf("duk_alloc_pool_init: approximate waste tracking enabled\n");
+#endif
+#endif
+
+#if defined(DUK_USE_HEAPPTR16)
+	/* Register global base value for pointer compression, assumes
+	 * a single active pool  -4 allows a single subtract to be used and
+	 * still ensures no non-NULL pointer encodes to zero.
+	 */
+	duk_alloc_pool_ptrcomp_base = (void *) (p - 4);
+#endif
+
+	for (i = 0; i < num_pools; i++) {
+		n = (int) states[i].count;
+		if (n > 0) {
+			states[i].first = (duk_pool_free *) p;
+			for (j = 0; j < n; j++) {
+				char *p_next = p + states[i].size;
+				((duk_pool_free *) p)->next =
+					(j == n - 1) ? (duk_pool_free *) NULL : (duk_pool_free *) p_next;
+				p = p_next;
+			}
+		} else {
+			states[i].first = (duk_pool_free *) NULL;
+		}
+		states[i].alloc_end = p;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+		states[i].hwm_used_count = 0;
+#endif
+		/* All members of 'state' now initialized. */
+
+#if defined(DUK_ALLOC_POOL_DEBUG)
+		duk__alloc_pool_dprintf("duk_alloc_pool_init: block size %5ld, count %5ld, %8ld total bytes, "
+		                        "end %p\n",
+		                        (long) states[i].size, (long) states[i].count,
+		                        (long) states[i].size * (long) states[i].count,
+		                        (void *) states[i].alloc_end);
+#endif
+	}
+
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+	/* ROM pointer compression precomputation.  Assumes a single active
+	 * pool.
+	 */
+	duk__alloc_pool_romptr_init();
+#endif
+
+	/* Use 'global' as udata. */
+	return (void *) global;
+}
+
+/*
+ *  Misc helpers
+ */
+
+#if defined(DUK_ALLOC_POOL_TRACK_WASTE)
+static void duk__alloc_pool_set_waste_marker(void *ptr, size_t used, size_t size) {
+	/* Rely on the base pointer and size being divisible by 4 and thus
+	 * aligned.  Use 32-bit markers: a 4-byte resolution is good enough,
+	 * and comparing 32 bits at a time makes false waste estimates less
+	 * likely than when comparing as bytes.
+	 */
+	duk_uint32_t *p, *p_start, *p_end;
+	size_t used_round;
+
+	used_round = (used + 3U) & ~0x03U;  /* round up to 4 */
+	p_end = (duk_uint32_t *) ((duk_uint8_t *) ptr + size);
+	p_start = (duk_uint32_t *) ((duk_uint8_t *) ptr + used_round);
+	p = (duk_uint32_t *) p_start;
+	while (p != p_end) {
+		*p++ = DUK_ALLOC_POOL_WASTE_MARKER;
+	}
+}
+#else  /* DUK_ALLOC_POOL_TRACK_WASTE */
+static void duk__alloc_pool_set_waste_marker(void *ptr, size_t used, size_t size) {
+	(void) ptr; (void) used; (void) size;
+}
+#endif  /* DUK_ALLOC_POOL_TRACK_WASTE */
+
+#if defined(DUK_ALLOC_POOL_TRACK_WASTE)
+static size_t duk__alloc_pool_get_waste_estimate(void *ptr, size_t size) {
+	duk_uint32_t *p, *p_end, *p_start;
+
+	/* Assumes size is >= 4. */
+	p_start = (duk_uint32_t *) ptr;
+	p_end = (duk_uint32_t *) ((duk_uint8_t *) ptr + size);
+	p = p_end;
+
+	/* This scan may cause harmless valgrind complaints: there may be
+	 * uninitialized bytes within the legitimate allocation or between
+	 * the start of the waste marker and the end of the allocation.
+	 */
+	do {
+		p--;
+		if (*p == DUK_ALLOC_POOL_WASTE_MARKER) {
+			;
+		} else {
+			return (size_t) (p_end - p - 1) * 4U;
+		}
+	} while (p != p_start);
+
+	return size;
+}
+#else  /* DUK_ALLOC_POOL_TRACK_WASTE */
+static size_t duk__alloc_pool_get_waste_estimate(void *ptr, size_t size) {
+	(void) ptr; (void) size;
+	return 0;
+}
+#endif  /* DUK_ALLOC_POOL_TRACK_WASTE */
+
+static int duk__alloc_pool_ptr_in_freelist(duk_pool_state *s, void *ptr) {
+	duk_pool_free *curr;
+
+	for (curr = s->first; curr != NULL; curr = curr->next) {
+		if ((void *) curr == ptr) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+void duk_alloc_pool_get_pool_stats(duk_pool_state *s, duk_pool_stats *res) {
+	void *curr;
+	size_t free_count;
+	size_t used_count;
+	size_t waste_bytes;
+
+	curr = s->alloc_end - (s->size * s->count);
+	free_count = 0U;
+	waste_bytes = 0U;
+	while (curr != s->alloc_end) {
+		if (duk__alloc_pool_ptr_in_freelist(s, curr)) {
+			free_count++;
+		} else {
+			waste_bytes += duk__alloc_pool_get_waste_estimate(curr, s->size);
+		}
+		curr = curr + s->size;
+	}
+	used_count = (size_t) (s->count - free_count);
+
+	res->used_count = used_count;
+	res->used_bytes = (size_t) (used_count * s->size);
+	res->free_count = free_count;
+	res->free_bytes = (size_t) (free_count * s->size);
+	res->waste_bytes = waste_bytes;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+	res->hwm_used_count = s->hwm_used_count;
+#else
+	res->hwm_used_count = 0U;
+#endif
+}
+
+void duk_alloc_pool_get_global_stats(duk_pool_global *g, duk_pool_global_stats *res) {
+	int i;
+	size_t total_used = 0U;
+	size_t total_free = 0U;
+	size_t total_waste = 0U;
+
+	for (i = 0; i < g->num_pools; i++) {
+		duk_pool_state *s = &g->states[i];
+		duk_pool_stats stats;
+
+		duk_alloc_pool_get_pool_stats(s, &stats);
+
+		total_used += stats.used_bytes;
+		total_free += stats.free_bytes;
+		total_waste += stats.waste_bytes;
+	}
+
+	res->used_bytes = total_used;
+	res->free_bytes = total_free;
+	res->waste_bytes = total_waste;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+	res->hwm_used_bytes = g->hwm_used_bytes;
+	res->hwm_waste_bytes = g->hwm_waste_bytes;
+#else
+	res->hwm_used_bytes = 0U;
+	res->hwm_waste_bytes = 0U;
+#endif
+}
+
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+static void duk__alloc_pool_update_highwater(duk_pool_global *g) {
+	int i;
+	size_t total_used = 0U;
+	size_t total_free = 0U;
+	size_t total_waste = 0U;
+
+	/* Per pool highwater used count, useful to checking if a pool is
+	 * too small.
+	 */
+	for (i = 0; i < g->num_pools; i++) {
+		duk_pool_state *s = &g->states[i];
+		duk_pool_stats stats;
+
+		duk_alloc_pool_get_pool_stats(s, &stats);
+		if (stats.used_count > s->hwm_used_count) {
+#if defined(DUK_ALLOC_POOL_DEBUG)
+			duk__alloc_pool_dprintf("duk__alloc_pool_update_highwater: pool %ld (%ld bytes) highwater updated: count %ld -> %ld\n",
+			                        (long) i, (long) s->size,
+			                        (long) s->hwm_used_count, (long) stats.used_count);
+#endif
+			s->hwm_used_count = stats.used_count;
+		}
+
+		total_used += stats.used_bytes;
+		total_free += stats.free_bytes;
+		total_waste += stats.waste_bytes;
+	}
+
+	/* Global highwater mark for used and waste bytes.  Both fields are
+	 * updated from the same snapshot based on highest used count.
+	 * This is VERY, VERY slow and only useful for development.
+	 * (Note that updating HWM states for pools individually and then
+	 * summing them won't create a consistent global snapshot.  There
+	 * are still easy ways to make this much, much faster.)
+	 */
+	if (total_used > g->hwm_used_bytes) {
+#if defined(DUK_ALLOC_POOL_DEBUG)
+		duk__alloc_pool_dprintf("duk__alloc_pool_update_highwater: global highwater updated: used=%ld, bytes=%ld -> "
+		                        "used=%ld, bytes=%ld\n",
+		                        (long) g->hwm_used_bytes, (long) g->hwm_waste_bytes,
+		                        (long) total_used, (long) total_waste);
+#endif
+		g->hwm_used_bytes = total_used;
+		g->hwm_waste_bytes = total_waste;
+	}
+}
+#else  /* DUK_ALLOC_POOL_TRACK_HIGHWATER */
+static void duk__alloc_pool_update_highwater(duk_pool_global *g) {
+	(void) g;
+}
+#endif  /* DUK_ALLOC_POOL_TRACK_HIGHWATER */
+
+/*
+ *  Allocation providers
+ */
+
+void *duk_alloc_pool(void *udata, duk_size_t size) {
+	duk_pool_global *g = (duk_pool_global *) udata;
+	int i, n;
+
+#if defined(DUK_ALLOC_POOL_DEBUG)
+	duk__alloc_pool_dprintf("duk_alloc_pool: %p %ld\n", udata, (long) size);
+#endif
+
+	if (size == 0) {
+		return NULL;
+	}
+
+	for (i = 0, n = g->num_pools; i < n; i++) {
+		duk_pool_state *st = g->states + i;
+
+		if (size <= st->size) {
+			duk_pool_free *res = st->first;
+			if (res != NULL) {
+				st->first = res->next;
+				duk__alloc_pool_set_waste_marker((void *) res, size, st->size);
+				duk__alloc_pool_update_highwater(g);
+				return (void *) res;
+			}
+		}
+
+		/* Allocation doesn't fit or no free entries, try to borrow
+		 * from the next block size.  There's no support for preventing
+		 * a borrow at present.
+		 */
+	}
+
+	return NULL;
+}
+
+void *duk_realloc_pool(void *udata, void *ptr, duk_size_t size) {
+	duk_pool_global *g = (duk_pool_global *) udata;
+	int i, j, n;
+
+#if defined(DUK_ALLOC_POOL_DEBUG)
+	duk__alloc_pool_dprintf("duk_realloc_pool: %p %p %ld\n", udata, ptr, (long) size);
+#endif
+
+	if (ptr == NULL) {
+		return duk_alloc_pool(udata, size);
+	}
+	if (size == 0) {
+		duk_free_pool(udata, ptr);
+		return NULL;
+	}
+
+	/* Non-NULL pointers are necessarily from the pool so we should
+	 * always be able to find the allocation.
+	 */
+
+	for (i = 0, n = g->num_pools; i < n; i++) {
+		duk_pool_state *st = g->states + i;
+		char *new_ptr;
+
+		/* Because 'ptr' is assumed to be in the pool and pools are
+		 * allocated in sequence, it suffices to check for end pointer
+		 * only.
+		 */
+		if ((char *) ptr >= st->alloc_end) {
+			continue;
+		}
+
+		if (size <= st->size) {
+			/* Allocation still fits existing allocation.  Check if
+			 * we can shrink the allocation to a smaller block size
+			 * (smallest possible).
+			 */
+			for (j = 0; j < i; j++) {
+				duk_pool_state *st2 = g->states + j;
+
+				if (size <= st2->size) {
+					new_ptr = (char *) st2->first;
+					if (new_ptr != NULL) {
+#if defined(DUK_ALLOC_POOL_DEBUG)
+						duk__alloc_pool_dprintf("duk_realloc_pool: shrink, block size %ld -> %ld\n",
+						                        (long) st->size, (long) st2->size);
+#endif
+						st2->first = ((duk_pool_free *) new_ptr)->next;
+						memcpy((void *) new_ptr, (const void *) ptr, (size_t) size);
+						((duk_pool_free *) ptr)->next = st->first;
+						st->first = (duk_pool_free *) ptr;
+						duk__alloc_pool_set_waste_marker((void *) new_ptr, size, st2->size);
+						duk__alloc_pool_update_highwater(g);
+						return (void *) new_ptr;
+					}
+				}
+			}
+
+			/* Failed to shrink; return existing pointer. */
+			duk__alloc_pool_set_waste_marker((void *) ptr, size, st->size);
+			return ptr;
+		}
+
+		/* Find first free larger block. */
+		for (j = i + 1; j < n; j++) {
+			duk_pool_state *st2 = g->states + j;
+
+			if (size <= st2->size) {
+				new_ptr = (char *) st2->first;
+				if (new_ptr != NULL) {
+					st2->first = ((duk_pool_free *) new_ptr)->next;
+					memcpy((void *) new_ptr, (const void *) ptr, (size_t) st->size);
+					((duk_pool_free *) ptr)->next = st->first;
+					st->first = (duk_pool_free *) ptr;
+					duk__alloc_pool_set_waste_marker((void *) new_ptr, size, st2->size);
+					duk__alloc_pool_update_highwater(g);
+					return (void *) new_ptr;
+				}
+			}
+		}
+
+		/* Failed to resize. */
+		return NULL;
+	}
+
+	/* We should never be here because 'ptr' should be a valid pool
+	 * entry and thus always found above.
+	 */
+	return NULL;
+}
+
+void duk_free_pool(void *udata, void *ptr) {
+	duk_pool_global *g = (duk_pool_global *) udata;
+	int i, n;
+
+#if defined(DUK_ALLOC_POOL_DEBUG)
+	duk__alloc_pool_dprintf("duk_free_pool: %p %p\n", udata, ptr);
+#endif
+
+	if (ptr == NULL) {
+		return;
+	}
+
+	for (i = 0, n = g->num_pools; i < n; i++) {
+		duk_pool_state *st = g->states + i;
+
+		/* Enough to check end address only. */
+		if ((char *) ptr >= st->alloc_end) {
+			continue;
+		}
+
+		((duk_pool_free *) ptr)->next = st->first;
+		st->first = (duk_pool_free *) ptr;
+#if 0  /* never necessary when freeing */
+		duk__alloc_pool_update_highwater(g);
+#endif
+		return;
+	}
+
+	/* We should never be here because 'ptr' should be a valid pool
+	 * entry and thus always found above.
+	 */
+}
+
+/*
+ *  Pointer compression
+ */
+
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+static void duk__alloc_pool_romptr_init(void) {
+	/* Scan ROM pointer range for faster detection of "is 'p' a ROM pointer"
+	 * later on.
+	 */
+	const void * const * ptrs = (const void * const *) duk_rom_compressed_pointers;
+	duk_alloc_pool_romptr_low = duk_alloc_pool_romptr_high = (const void *) *ptrs;
+	while (*ptrs) {
+		if (*ptrs > duk_alloc_pool_romptr_high) {
+			duk_alloc_pool_romptr_high = (const void *) *ptrs;
+		}
+		if (*ptrs < duk_alloc_pool_romptr_low) {
+			duk_alloc_pool_romptr_low = (const void *) *ptrs;
+		}
+		ptrs++;
+	}
+}
+#endif
+
+/* Encode/decode functions are defined in the header to allow inlining. */
+
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+duk_uint16_t duk_alloc_pool_enc16_rom(void *ptr) {
+	/* The if-condition should be the fastest possible check
+	 * for "is 'ptr' in ROM?".  If pointer is in ROM, we'd like
+	 * to compress it quickly.  Here we just scan a ~1K array
+	 * which is very bad for performance.
+	 */
+	const void * const * ptrs = duk_rom_compressed_pointers;
+	while (*ptrs) {
+		if (*ptrs == ptr) {
+			return DUK_ALLOC_POOL_ROMPTR_FIRST + (duk_uint16_t) (ptrs - duk_rom_compressed_pointers);
+		}
+		ptrs++;
+	}
+
+	/* We should really never be here: Duktape should only be
+	 * compressing pointers which are in the ROM compressed
+	 * pointers list, which are known at 'make dist' time.
+	 * We go on, causing a pointer compression error.
+	 */
+	return 0;
+}
+#endif
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h
new file mode 100755
index 0000000000..286ec0166a
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h
@@ -0,0 +1,223 @@
+#if !defined(DUK_ALLOC_POOL_H_INCLUDED)
+#define DUK_ALLOC_POOL_H_INCLUDED
+
+#include "duktape.h"
+
+/* 32-bit (big endian) marker used at the end of pool entries so that wasted
+ * space can be detected.  Waste tracking must be enabled explicitly.
+ */
+#if defined(DUK_ALLOC_POOL_TRACK_WASTE)
+#define DUK_ALLOC_POOL_WASTE_MARKER  0xedcb2345UL
+#endif
+
+/* Pointer compression with ROM strings/objects:
+ *
+ * For now, use DUK_USE_ROM_OBJECTS to signal the need for compressed ROM
+ * pointers.  DUK_USE_ROM_PTRCOMP_FIRST is provided for the ROM pointer
+ * compression range minimum to avoid duplication in user code.
+ */
+#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
+#define DUK_ALLOC_POOL_ROMPTR_COMPRESSION
+#define DUK_ALLOC_POOL_ROMPTR_FIRST DUK_USE_ROM_PTRCOMP_FIRST
+
+/* This extern declaration is provided by duktape.h, array provided by duktape.c.
+ * Because duk_config.h may include this file (to get the inline functions) we
+ * need to forward declare this also here.
+ */
+extern const void * const duk_rom_compressed_pointers[];
+#endif
+
+/* Pool configuration for a certain block size. */
+typedef struct {
+	unsigned int size;  /* must be divisible by 4 and >= sizeof(void *) */
+	unsigned int a;     /* bytes (not count) to allocate: a*t + b, t is an arbitrary scale parameter */
+	unsigned int b;
+} duk_pool_config;
+
+/* Freelist entry, must fit into the smallest block size. */
+struct duk_pool_free;
+typedef struct duk_pool_free duk_pool_free;
+struct duk_pool_free {
+	duk_pool_free *next;
+};
+
+/* Pool state for a certain block size. */
+typedef struct {
+	duk_pool_free *first;
+	char *alloc_end;
+	unsigned int size;
+	unsigned int count;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+	unsigned int hwm_used_count;
+#endif
+} duk_pool_state;
+
+/* Statistics for a certain pool. */
+typedef struct {
+	size_t used_count;
+	size_t used_bytes;
+	size_t free_count;
+	size_t free_bytes;
+	size_t waste_bytes;
+	size_t hwm_used_count;
+} duk_pool_stats;
+
+/* Top level state for all pools.  Pointer to this struct is used as the allocator
+ * userdata pointer.
+ */
+typedef struct {
+	int num_pools;
+	duk_pool_state *states;
+#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER)
+	size_t hwm_used_bytes;
+	size_t hwm_waste_bytes;
+#endif
+} duk_pool_global;
+
+/* Statistics for the entire set of pools. */
+typedef struct {
+	size_t used_bytes;
+	size_t free_bytes;
+	size_t waste_bytes;
+	size_t hwm_used_bytes;
+	size_t hwm_waste_bytes;
+} duk_pool_global_stats;
+
+/* Initialize a pool allocator, arguments:
+ *   - buffer and size: continuous region to use for pool, must align to 4
+ *   - config: configuration for pools in ascending block size
+ *   - state: state for pools, matches config order
+ *   - num_pools: number of entries in 'config' and 'state'
+ *   - global: global state structure
+ *
+ * The 'config', 'state', and 'global' pointers must be valid beyond the init
+ * call, as long as the pool is used.
+ *
+ * Returns a void pointer to be used as userdata for the allocator functions.
+ * Concretely the return value will be "(void *) global", i.e. the global
+ * state struct.  If pool init fails, the return value will be NULL.
+ */
+void *duk_alloc_pool_init(char *buffer,
+                          size_t size,
+                          const duk_pool_config *configs,
+                          duk_pool_state *states,
+                          int num_pools,
+                          duk_pool_global *global);
+
+/* Duktape allocation providers.  Typing matches Duktape requirements. */
+void *duk_alloc_pool(void *udata, duk_size_t size);
+void *duk_realloc_pool(void *udata, void *ptr, duk_size_t size);
+void duk_free_pool(void *udata, void *ptr);
+
+/* Stats. */
+void duk_alloc_pool_get_pool_stats(duk_pool_state *s, duk_pool_stats *res);
+void duk_alloc_pool_get_global_stats(duk_pool_global *g, duk_pool_global_stats *res);
+
+/* Duktape pointer compression global state (assumes single pool). */
+#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16)
+extern const void *duk_alloc_pool_romptr_low;
+extern const void *duk_alloc_pool_romptr_high;
+duk_uint16_t duk_alloc_pool_enc16_rom(void *ptr);
+#endif
+#if defined(DUK_USE_HEAPPTR16)
+extern void *duk_alloc_pool_ptrcomp_base;
+#endif
+
+#if 0
+duk_uint16_t duk_alloc_pool_enc16(void *ptr);
+void *duk_alloc_pool_dec16(duk_uint16_t val);
+#endif
+
+/* Inlined pointer compression functions.  Gcc and clang -Os won't in
+ * practice inline these without an "always inline" attribute because it's
+ * more size efficient (by a few kB) to use explicit calls instead.  Having
+ * these defined inline here allows performance optimized builds to inline
+ * pointer compression operations.
+ *
+ * Pointer compression assumes there's a single globally registered memory
+ * pool which makes pointer compression more efficient.  This would be easy
+ * to fix by adding a userdata pointer to the compression functions and
+ * plumbing the heap userdata from the compression/decompression macros.
+ */
+
+/* DUK_ALWAYS_INLINE is not a public API symbol so it may go away in even a
+ * minor update.  But it's pragmatic for this extra because it handles many
+ * compilers via duk_config.h detection.  Check that the macro exists so that
+ * if it's gone, we can still compile.
+ */
+#if defined(DUK_ALWAYS_INLINE)
+#define DUK__ALLOC_POOL_ALWAYS_INLINE DUK_ALWAYS_INLINE
+#else
+#define DUK__ALLOC_POOL_ALWAYS_INLINE /* nop */
+#endif
+
+#if defined(DUK_USE_HEAPPTR16)
+static DUK__ALLOC_POOL_ALWAYS_INLINE duk_uint16_t duk_alloc_pool_enc16(void *ptr) {
+	if (ptr == NULL) {
+		/* With 'return 0' gcc and clang -Os generate inefficient code.
+		 * For example, gcc -Os generates:
+		 *
+		 *   0804911d :
+		 *    804911d:       55                      push   %ebp
+		 *    804911e:       85 c0                   test   %eax,%eax
+		 *    8049120:       89 e5                   mov    %esp,%ebp
+		 *    8049122:       74 0b                   je     804912f 
+		 *    8049124:       2b 05 e4 90 07 08       sub    0x80790e4,%eax
+		 *    804912a:       c1 e8 02                shr    $0x2,%eax
+		 *    804912d:       eb 02                   jmp    8049131 
+		 *    804912f:       31 c0                   xor    %eax,%eax
+		 *    8049131:       5d                      pop    %ebp
+		 *    8049132:       c3                      ret
+		 *
+		 * The NULL path checks %eax for zero; if it is zero, a zero
+		 * is unnecessarily loaded into %eax again.  The non-zero path
+		 * has an unnecessary jump as a side effect of this.
+		 *
+		 * Using 'return (duk_uint16_t) (intptr_t) ptr;' generates similarly
+		 * inefficient code; not sure how to make the result better.
+		 */
+		return 0;
+	}
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+	if (ptr >= duk_alloc_pool_romptr_low && ptr <= duk_alloc_pool_romptr_high) {
+		/* This is complex enough now to need a separate function. */
+		return duk_alloc_pool_enc16_rom(ptr);
+	}
+#endif
+	return (duk_uint16_t) (((size_t) ((char *) ptr - (char *) duk_alloc_pool_ptrcomp_base)) >> 2);
+}
+
+static DUK__ALLOC_POOL_ALWAYS_INLINE void *duk_alloc_pool_dec16(duk_uint16_t val) {
+	if (val == 0) {
+		/* As with enc16 the gcc and clang -Os output is inefficient,
+		 * e.g. gcc -Os:
+		 *
+		 *   08049133 :
+		 *    8049133:       55                      push   %ebp
+		 *    8049134:       66 85 c0                test   %ax,%ax
+		 *    8049137:       89 e5                   mov    %esp,%ebp
+		 *    8049139:       74 0e                   je     8049149 
+		 *    804913b:       8b 15 e4 90 07 08       mov    0x80790e4,%edx
+		 *    8049141:       0f b7 c0                movzwl %ax,%eax
+		 *    8049144:       8d 04 82                lea    (%edx,%eax,4),%eax
+		 *    8049147:       eb 02                   jmp    804914b 
+		 *    8049149:       31 c0                   xor    %eax,%eax
+		 *    804914b:       5d                      pop    %ebp
+		 *    804914c:       c3                      ret
+		 */
+		return NULL;
+	}
+#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION)
+	if (val >= DUK_ALLOC_POOL_ROMPTR_FIRST) {
+		/* This is a blind lookup, could check index validity.
+		 * Duktape should never decompress a pointer which would
+		 * be out-of-bounds here.
+		 */
+		return (void *) (intptr_t) (duk_rom_compressed_pointers[val - DUK_ALLOC_POOL_ROMPTR_FIRST]);
+	}
+#endif
+	return (void *) ((char *) duk_alloc_pool_ptrcomp_base + (((size_t) val) << 2));
+}
+#endif
+
+#endif  /* DUK_ALLOC_POOL_H_INCLUDED */
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h
new file mode 100755
index 0000000000..3f217ef7d2
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h
@@ -0,0 +1,3672 @@
+/*
+ *  duk_config.h configuration header generated by genconfig.py.
+ *
+ *  Git commit: a459cf3c9bd1779fc01b435d69302b742675a08f
+ *  Git describe: v2.2.0
+ *  Git branch: master
+ *
+ *  Supported platforms:
+ *      - Mac OSX, iPhone, Darwin
+ *      - Orbis
+ *      - OpenBSD
+ *      - Generic BSD
+ *      - Atari ST TOS
+ *      - AmigaOS
+ *      - Durango (XboxOne)
+ *      - Windows
+ *      - Flashplayer (Crossbridge)
+ *      - QNX
+ *      - TI-Nspire
+ *      - Emscripten
+ *      - Linux
+ *      - Solaris
+ *      - AIX
+ *      - HPUX
+ *      - Generic POSIX
+ *      - Cygwin
+ *      - Generic UNIX
+ *      - Generic fallback
+ *
+ *  Supported architectures:
+ *      - x86
+ *      - x64
+ *      - x32
+ *      - ARM 32-bit
+ *      - ARM 64-bit
+ *      - MIPS 32-bit
+ *      - MIPS 64-bit
+ *      - PowerPC 32-bit
+ *      - PowerPC 64-bit
+ *      - SPARC 32-bit
+ *      - SPARC 64-bit
+ *      - SuperH
+ *      - Motorola 68k
+ *      - Emscripten
+ *      - Generic
+ *
+ *  Supported compilers:
+ *      - Clang
+ *      - GCC
+ *      - MSVC
+ *      - Emscripten
+ *      - TinyC
+ *      - VBCC
+ *      - Bruce's C compiler
+ *      - Generic
+ *
+ */
+
+#if !defined(DUK_CONFIG_H_INCLUDED)
+#define DUK_CONFIG_H_INCLUDED
+
+/*
+ *  Intermediate helper defines
+ */
+
+/* DLL build detection */
+/* not configured for DLL build */
+#undef DUK_F_DLL_BUILD
+
+/* Apple OSX, iOS */
+#if defined(__APPLE__)
+#define DUK_F_APPLE
+#endif
+
+/* FreeBSD */
+#if defined(__FreeBSD__) || defined(__FreeBSD)
+#define DUK_F_FREEBSD
+#endif
+
+/* Orbis (PS4) variant */
+#if defined(DUK_F_FREEBSD) && defined(__ORBIS__)
+#define DUK_F_ORBIS
+#endif
+
+/* OpenBSD */
+#if defined(__OpenBSD__) || defined(__OpenBSD)
+#define DUK_F_OPENBSD
+#endif
+
+/* NetBSD */
+#if defined(__NetBSD__) || defined(__NetBSD)
+#define DUK_F_NETBSD
+#endif
+
+/* BSD variant */
+#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \
+    defined(__bsdi__) || defined(__DragonFly__)
+#define DUK_F_BSD
+#endif
+
+/* Atari ST TOS.  __TOS__ defined by PureC.  No platform define in VBCC
+ * apparently, so to use with VBCC user must define __TOS__ manually.
+  */
+#if defined(__TOS__)
+#define DUK_F_TOS
+#endif
+
+/* Motorola 68K.  Not defined by VBCC, so user must define one of these
+ * manually when using VBCC.
+ */
+#if defined(__m68k__) || defined(M68000) || defined(__MC68K__)
+#define DUK_F_M68K
+#endif
+
+/* AmigaOS.  Neither AMIGA nor __amigaos__ is defined on VBCC, so user must
+ * define 'AMIGA' manually when using VBCC.
+ */
+#if defined(AMIGA) || defined(__amigaos__)
+#define DUK_F_AMIGAOS
+#endif
+
+/* PowerPC */
+#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__)
+#define DUK_F_PPC
+#if defined(__PPC64__) || defined(__LP64__) || defined(_LP64)
+#define DUK_F_PPC64
+#else
+#define DUK_F_PPC32
+#endif
+#endif
+
+/* Durango (Xbox One) */
+#if defined(_DURANGO) || defined(_XBOX_ONE)
+#define DUK_F_DURANGO
+#endif
+
+/* Windows, both 32-bit and 64-bit */
+#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \
+    defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
+#define DUK_F_WINDOWS
+#if defined(_WIN64) || defined(WIN64)
+#define DUK_F_WIN64
+#else
+#define DUK_F_WIN32
+#endif
+#endif
+
+/* Flash player (e.g. Crossbridge) */
+#if defined(__FLASHPLAYER__)
+#define DUK_F_FLASHPLAYER
+#endif
+
+/* QNX */
+#if defined(__QNX__)
+#define DUK_F_QNX
+#endif
+
+/* TI-Nspire (using Ndless) */
+#if defined(_TINSPIRE)
+#define DUK_F_TINSPIRE
+#endif
+
+/* Emscripten (provided explicitly by user), improve if possible */
+#if defined(EMSCRIPTEN)
+#define DUK_F_EMSCRIPTEN
+#endif
+
+/* BCC (Bruce's C compiler): this is a "torture target" for compilation */
+#if defined(__BCC__) || defined(__BCC_VERSION__)
+#define DUK_F_BCC
+#endif
+
+/* Linux */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+#define DUK_F_LINUX
+#endif
+
+/* illumos / Solaris */
+#if defined(__sun) && defined(__SVR4)
+#define DUK_F_SUN
+#if defined(__SUNPRO_C) && (__SUNPRO_C < 0x550)
+#define DUK_F_OLD_SOLARIS
+/* Defines _ILP32 / _LP64 required by DUK_F_X86/DUK_F_X64.  Platforms
+ * are processed before architectures, so this happens before the
+ * DUK_F_X86/DUK_F_X64 detection is emitted.
+ */
+#include 
+#endif
+#endif
+
+/* AIX */
+#if defined(_AIX)
+/* defined(__xlc__) || defined(__IBMC__): works but too wide */
+#define DUK_F_AIX
+#endif
+
+/* HPUX */
+#if defined(__hpux)
+#define DUK_F_HPUX
+#if defined(__ia64)
+#define DUK_F_HPUX_ITANIUM
+#endif
+#endif
+
+/* POSIX */
+#if defined(__posix)
+#define DUK_F_POSIX
+#endif
+
+/* Cygwin */
+#if defined(__CYGWIN__)
+#define DUK_F_CYGWIN
+#endif
+
+/* Generic Unix (includes Cygwin) */
+#if defined(__unix) || defined(__unix__) || defined(unix) || \
+    defined(DUK_F_LINUX) || defined(DUK_F_BSD)
+#define DUK_F_UNIX
+#endif
+
+/* C++ */
+#undef DUK_F_CPP
+#if defined(__cplusplus)
+#define DUK_F_CPP
+#endif
+
+/* Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers),
+ * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32.
+ * https://sites.google.com/site/x32abi/
+ *
+ * With DUK_F_OLD_SOLARIS the  header must be included
+ * before this.
+ */
+#if defined(__amd64__) || defined(__amd64) || \
+    defined(__x86_64__) || defined(__x86_64) || \
+    defined(_M_X64) || defined(_M_AMD64)
+#if defined(__ILP32__) || defined(_ILP32)
+#define DUK_F_X32
+#else
+#define DUK_F_X64
+#endif
+#elif defined(i386) || defined(__i386) || defined(__i386__) || \
+      defined(__i486__) || defined(__i586__) || defined(__i686__) || \
+      defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \
+      defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__)
+#if defined(__LP64__) || defined(_LP64)
+/* This should not really happen, but would indicate x64. */
+#define DUK_F_X64
+#else
+#define DUK_F_X86
+#endif
+#endif
+
+/* ARM */
+#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) || defined(__aarch64__)
+#define DUK_F_ARM
+#if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__) || defined(__aarch64__)
+#define DUK_F_ARM64
+#else
+#define DUK_F_ARM32
+#endif
+#endif
+
+/* MIPS.  Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */
+#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \
+    defined(_R3000) || defined(_R4000) || defined(_R5900) || \
+    defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \
+    defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \
+    defined(__mips) || defined(__MIPS__)
+#define DUK_F_MIPS
+#if defined(__LP64__) || defined(_LP64) || defined(__mips64) || \
+    defined(__mips64__) || defined(__mips_n64)
+#define DUK_F_MIPS64
+#else
+#define DUK_F_MIPS32
+#endif
+#endif
+
+/* SPARC */
+#if defined(sparc) || defined(__sparc) || defined(__sparc__)
+#define DUK_F_SPARC
+#if defined(__LP64__) || defined(_LP64)
+#define DUK_F_SPARC64
+#else
+#define DUK_F_SPARC32
+#endif
+#endif
+
+/* SuperH */
+#if defined(__sh__) || \
+    defined(__sh1__) || defined(__SH1__) || \
+    defined(__sh2__) || defined(__SH2__) || \
+    defined(__sh3__) || defined(__SH3__) || \
+    defined(__sh4__) || defined(__SH4__) || \
+    defined(__sh5__) || defined(__SH5__)
+#define DUK_F_SUPERH
+#endif
+
+/* Clang */
+#if defined(__clang__)
+#define DUK_F_CLANG
+#endif
+
+/* C99 or above */
+#undef DUK_F_C99
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#define DUK_F_C99
+#endif
+
+/* C++11 or above */
+#undef DUK_F_CPP11
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define DUK_F_CPP11
+#endif
+
+/* GCC.  Clang also defines __GNUC__ so don't detect GCC if using Clang. */
+#if defined(__GNUC__) && !defined(__clang__) && !defined(DUK_F_CLANG)
+#define DUK_F_GCC
+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
+/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */
+#define DUK_F_GCC_VERSION  (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__)
+#else
+#error cannot figure out gcc version
+#endif
+#endif
+
+/* MinGW.  Also GCC flags (DUK_F_GCC) are enabled now. */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#define DUK_F_MINGW
+#endif
+
+/* MSVC */
+#if defined(_MSC_VER)
+/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+ * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g.
+ * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp
+ */
+#define DUK_F_MSVC
+#if defined(_MSC_FULL_VER)
+#if (_MSC_FULL_VER > 100000000)
+#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER
+#else
+#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10)
+#endif
+#endif
+#endif  /* _MSC_VER */
+
+/* TinyC */
+#if defined(__TINYC__)
+/* http://bellard.org/tcc/tcc-doc.html#SEC9 */
+#define DUK_F_TINYC
+#endif
+
+/* VBCC */
+#if defined(__VBCC__)
+#define DUK_F_VBCC
+#endif
+
+#if defined(ANDROID) || defined(__ANDROID__)
+#define DUK_F_ANDROID
+#endif
+
+/* Atari Mint */
+#if defined(__MINT__)
+#define DUK_F_MINT
+#endif
+
+/*
+ *  Platform autodetection
+ */
+
+/* Workaround for older C++ compilers before including ,
+ * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366
+ */
+#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
+#define __STDC_LIMIT_MACROS
+#endif
+#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
+#define __STDC_CONSTANT_MACROS
+#endif
+
+#if defined(DUK_F_APPLE)
+/* --- Mac OSX, iPhone, Darwin --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */
+#if TARGET_IPHONE_SIMULATOR
+#define DUK_USE_OS_STRING "iphone-sim"
+#elif TARGET_OS_IPHONE
+#define DUK_USE_OS_STRING "iphone"
+#elif TARGET_OS_MAC
+#define DUK_USE_OS_STRING "osx"
+#else
+#define DUK_USE_OS_STRING "osx-unknown"
+#endif
+
+/* Use _setjmp() on Apple by default, see GH-55. */
+#define DUK_JMPBUF_TYPE       jmp_buf
+#define DUK_SETJMP(jb)        _setjmp((jb))
+#define DUK_LONGJMP(jb)       _longjmp((jb), 1)
+#elif defined(DUK_F_ORBIS)
+/* --- Orbis --- */
+/* Orbis = PS4 */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_S
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING  "orbis"
+#elif defined(DUK_F_OPENBSD)
+/* --- OpenBSD --- */
+/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING  "openbsd"
+#elif defined(DUK_F_BSD)
+/* --- Generic BSD --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING  "bsd"
+#elif defined(DUK_F_TOS)
+/* --- Atari ST TOS --- */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+
+#define DUK_USE_OS_STRING  "tos"
+
+/* TOS on M68K is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K)
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_AMIGAOS)
+/* --- AmigaOS --- */
+#if defined(DUK_F_M68K)
+/* AmigaOS on M68k */
+#define DUK_USE_DATE_NOW_TIME
+#define DUK_USE_DATE_TZO_GMTIME
+/* no parsing (not an error) */
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#elif defined(DUK_F_PPC)
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#if !defined(UINTPTR_MAX)
+#define UINTPTR_MAX UINT_MAX
+#endif
+#else
+#error AmigaOS but not M68K/PPC, not supported now
+#endif
+
+#define DUK_USE_OS_STRING "amigaos"
+
+/* AmigaOS on M68K or PPC is always big endian. */
+#if !defined(DUK_USE_BYTEORDER) && (defined(DUK_F_M68K) || defined(DUK_F_PPC))
+#define DUK_USE_BYTEORDER 3
+#endif
+#elif defined(DUK_F_DURANGO)
+/* --- Durango (XboxOne) --- */
+/* Durango = XboxOne
+ * Configuration is nearly identical to Windows, except for
+ * DUK_USE_DATE_TZO_WINDOWS.
+ */
+
+/* Initial fix: disable secure CRT related warnings when compiling Duktape
+ * itself (must be defined before including Windows headers).  Don't define
+ * for user code including duktape.h.
+ */
+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/* MSVC does not have sys/param.h */
+#define DUK_USE_DATE_NOW_WINDOWS
+#define DUK_USE_DATE_TZO_WINDOWS_NO_DST
+/* Note: PRS and FMT are intentionally left undefined for now.  This means
+ * there is no platform specific date parsing/formatting but there is still
+ * the ISO 8601 standard format.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+/* Only include when compiling Duktape to avoid polluting application build
+ * with a lot of unnecessary defines.
+ */
+#include 
+#endif
+
+#define DUK_USE_OS_STRING "durango"
+
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_WINDOWS)
+/* --- Windows --- */
+/* Windows version can't obviously be determined at compile time,
+ * but _WIN32_WINNT indicates the minimum version targeted:
+ * - https://msdn.microsoft.com/en-us/library/6sehtctf.aspx
+ */
+
+/* Initial fix: disable secure CRT related warnings when compiling Duktape
+ * itself (must be defined before including Windows headers).  Don't define
+ * for user code including duktape.h.
+ */
+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/* Windows 32-bit and 64-bit are currently the same. */
+/* MSVC does not have sys/param.h */
+
+#if defined(DUK_COMPILING_DUKTAPE)
+/* Only include when compiling Duktape to avoid polluting application build
+ * with a lot of unnecessary defines.
+ */
+#include 
+#endif
+
+/* GetSystemTimePreciseAsFileTime() available from Windows 8:
+ * https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895(v=vs.85).aspx
+ */
+#if defined(DUK_USE_DATE_NOW_WINDOWS_SUBMS) || defined(DUK_USE_DATE_NOW_WINDOWS)
+/* User forced provider. */
+#else
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0602)
+#define DUK_USE_DATE_NOW_WINDOWS_SUBMS
+#else
+#define DUK_USE_DATE_NOW_WINDOWS
+#endif
+#endif
+
+#define DUK_USE_DATE_TZO_WINDOWS
+
+/* Note: PRS and FMT are intentionally left undefined for now.  This means
+ * there is no platform specific date parsing/formatting but there is still
+ * the ISO 8601 standard format.
+ */
+
+/* QueryPerformanceCounter() may go backwards in Windows XP, so enable for
+ * Vista and later: https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx#qpc_support_in_windows_versions
+ */
+#if !defined(DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC) && \
+    defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600)
+#define DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC
+#endif
+
+#define DUK_USE_OS_STRING "windows"
+
+/* On Windows, assume we're little endian.  Even Itanium which has a
+ * configurable endianness runs little endian in Windows.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_FLASHPLAYER)
+/* --- Flashplayer (Crossbridge) --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "flashplayer"
+
+#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#elif defined(DUK_F_QNX)
+/* --- QNX --- */
+#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE)
+/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */
+#define _XOPEN_SOURCE    600
+#define _POSIX_C_SOURCE  200112L
+#endif
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "qnx"
+#elif defined(DUK_F_TINSPIRE)
+/* --- TI-Nspire --- */
+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_XOPEN_SOURCE)
+#define _XOPEN_SOURCE    /* e.g. strptime */
+#endif
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "tinspire"
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#if !defined(_POSIX_C_SOURCE)
+#define _POSIX_C_SOURCE  200809L
+#endif
+#if !defined(_GNU_SOURCE)
+#define _GNU_SOURCE      /* e.g. getdate_r */
+#endif
+#if !defined(_XOPEN_SOURCE)
+#define _XOPEN_SOURCE    /* e.g. strptime */
+#endif
+#endif  /* DUK_COMPILING_DUKTAPE */
+
+#include 
+#if defined(DUK_F_BCC)
+/* no endian.h */
+#else
+#include 
+#endif  /* DUK_F_BCC */
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#define DUK_USE_OS_STRING "emscripten"
+#elif defined(DUK_F_LINUX)
+/* --- Linux --- */
+#if defined(DUK_COMPILING_DUKTAPE)
+#if !defined(_POSIX_C_SOURCE)
+#define _POSIX_C_SOURCE  200809L
+#endif
+#if !defined(_GNU_SOURCE)
+#define _GNU_SOURCE      /* e.g. getdate_r */
+#endif
+#if !defined(_XOPEN_SOURCE)
+#define _XOPEN_SOURCE    /* e.g. strptime */
+#endif
+#endif  /* DUK_COMPILING_DUKTAPE */
+
+#include 
+#if defined(DUK_F_BCC)
+/* no endian.h or stdint.h */
+#else
+#include 
+#include 
+#endif  /* DUK_F_BCC */
+#include 
+#include 
+#include 
+
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#if 0  /* XXX: safe condition? */
+#define DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME
+#endif
+
+#define DUK_USE_OS_STRING "linux"
+#elif defined(DUK_F_SUN)
+/* --- Solaris --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+
+#include 
+#if defined(DUK_F_OLD_SOLARIS)
+/* Old Solaris with no endian.h, stdint.h */
+#define DUK_F_NO_STDINT_H
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#else  /* DUK_F_OLD_SOLARIS */
+#include 
+#endif  /* DUK_F_OLD_SOLARIS */
+
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "solaris"
+#elif defined(DUK_F_AIX)
+/* --- AIX --- */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "aix"
+#elif defined(DUK_F_HPUX)
+/* --- HPUX --- */
+#define DUK_F_NO_STDINT_H
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "hpux"
+#elif defined(DUK_F_POSIX)
+/* --- Generic POSIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_USE_OS_STRING "posix"
+#elif defined(DUK_F_CYGWIN)
+/* --- Cygwin --- */
+/* don't use strptime() for now */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#include 
+#include 
+#include 
+
+#define DUK_JMPBUF_TYPE       jmp_buf
+#define DUK_SETJMP(jb)        _setjmp((jb))
+#define DUK_LONGJMP(jb)       _longjmp((jb), 1)
+
+#define DUK_USE_OS_STRING "windows"
+#elif defined(DUK_F_UNIX)
+/* --- Generic UNIX --- */
+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
+#define DUK_USE_DATE_TZO_GMTIME_R
+#define DUK_USE_DATE_PRS_STRPTIME
+#define DUK_USE_DATE_FMT_STRFTIME
+#include 
+#include 
+#define DUK_USE_OS_STRING "unknown"
+#else
+/* --- Generic fallback --- */
+/* The most portable current time provider is time(), but it only has a
+ * one second resolution.
+ */
+#define DUK_USE_DATE_NOW_TIME
+
+/* The most portable way to figure out local time offset is gmtime(),
+ * but it's not thread safe so use with caution.
+ */
+#define DUK_USE_DATE_TZO_GMTIME
+
+/* Avoid custom date parsing and formatting for portability. */
+#undef DUK_USE_DATE_PRS_STRPTIME
+#undef DUK_USE_DATE_FMT_STRFTIME
+
+/* Rely on C89 headers only; time.h must be here. */
+#include 
+
+#define DUK_USE_OS_STRING "unknown"
+#endif  /* autodetect platform */
+
+/* Shared includes: C89 */
+#include 
+#include 
+#include 
+#include   /* varargs */
+#include 
+#include   /* e.g. ptrdiff_t */
+#include 
+#include 
+
+/* date.h is omitted, and included per platform */
+
+/* Shared includes: stdint.h is C99 */
+#if defined(DUK_F_NO_STDINT_H)
+/* stdint.h not available */
+#else
+/* Technically C99 (C++11) but found in many systems.  On some systems
+ * __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS must be defined before
+ * including stdint.h (see above).
+ */
+#include 
+#endif
+
+#if defined(DUK_F_CPP)
+#include   /* std::exception */
+#endif
+
+/*
+ *  Architecture autodetection
+ */
+
+#if defined(DUK_F_X86)
+/* --- x86 --- */
+#define DUK_USE_ARCH_STRING "x86"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X64)
+/* --- x64 --- */
+#define DUK_USE_ARCH_STRING "x64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_X32)
+/* --- x32 --- */
+#define DUK_USE_ARCH_STRING "x32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+/* XXX: This is technically not guaranteed because it's possible to configure
+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 1
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM32)
+/* --- ARM 32-bit --- */
+#define DUK_USE_ARCH_STRING "arm32"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_ARM64)
+/* --- ARM 64-bit --- */
+#define DUK_USE_ARCH_STRING "arm64"
+/* Byte order varies, so rely on autodetect. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS32)
+/* --- MIPS 32-bit --- */
+#define DUK_USE_ARCH_STRING "mips32"
+/* MIPS byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_MIPS64)
+/* --- MIPS 64-bit --- */
+#define DUK_USE_ARCH_STRING "mips64"
+/* MIPS byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC32)
+/* --- PowerPC 32-bit --- */
+#define DUK_USE_ARCH_STRING "ppc32"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_PPC64)
+/* --- PowerPC 64-bit --- */
+#define DUK_USE_ARCH_STRING "ppc64"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC32)
+/* --- SPARC 32-bit --- */
+#define DUK_USE_ARCH_STRING "sparc32"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SPARC64)
+/* --- SPARC 64-bit --- */
+#define DUK_USE_ARCH_STRING "sparc64"
+/* SPARC byte order varies so rely on autodetection. */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_SUPERH)
+/* --- SuperH --- */
+#define DUK_USE_ARCH_STRING "sh"
+/* Byte order varies, rely on autodetection. */
+/* Based on 'make checkalign' there are no alignment requirements on
+ * Linux SH4, but align by 4 is probably a good basic default.
+ */
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 4
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_M68K)
+/* --- Motorola 68k --- */
+#define DUK_USE_ARCH_STRING "m68k"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 3
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#define DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_USE_ARCH_STRING "emscripten"
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#if !defined(DUK_USE_ALIGN_BY)
+#define DUK_USE_ALIGN_BY 8
+#endif
+#undef DUK_USE_PACKED_TVAL
+#define DUK_F_PACKED_TVAL_PROVIDED
+#else
+/* --- Generic --- */
+/* These are necessary wild guesses. */
+#define DUK_USE_ARCH_STRING "generic"
+/* Rely on autodetection for byte order, alignment, and packed tval. */
+#endif  /* autodetect architecture */
+
+/*
+ *  Compiler autodetection
+ */
+
+#if defined(DUK_F_CLANG)
+/* --- Clang --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* Clang: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#define DUK_NORETURN(decl)  decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE()  do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x)    __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x)  __builtin_expect((x), 0)
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unpredictable)
+#define DUK_UNPREDICTABLE(x)  __builtin_unpredictable((x))
+#endif
+#endif
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE        __attribute__((noinline))
+#define DUK_INLINE          inline
+#define DUK_ALWAYS_INLINE   inline __attribute__((always_inline))
+#endif
+
+/* DUK_HOT */
+/* DUK_COLD */
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL  extern __declspec(dllexport)
+#define DUK_EXTERNAL       __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL  extern __declspec(dllimport)
+#define DUK_EXTERNAL       should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+#else
+#define DUK_EXTERNAL_DECL  __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL       __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang.  Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL  static __attribute__ ((unused))
+#define DUK_INTERNAL       static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "clang"
+#else
+#define DUK_USE_COMPILER_STRING "clang"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_GCC)
+/* --- GCC --- */
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+/* C99 / C++11 and above: rely on va_copy() which is required. */
+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
+#else
+/* GCC: assume we have __va_copy() in non-C99 mode. */
+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L)
+/* since gcc-2.5 */
+#define DUK_NORETURN(decl)  decl __attribute__((noreturn))
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* since gcc-4.5 */
+#define DUK_UNREACHABLE()  do { __builtin_unreachable(); } while (0)
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
+/* GCC: test not very accurate; enable only in relatively recent builds
+ * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html)
+ */
+#define DUK_LIKELY(x)    __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x)  __builtin_expect((x), 0)
+#endif
+/* XXX: equivalent of clang __builtin_unpredictable? */
+
+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \
+    defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 30101)
+#define DUK_NOINLINE        __attribute__((noinline))
+#define DUK_INLINE          inline
+#define DUK_ALWAYS_INLINE   inline __attribute__((always_inline))
+#endif
+
+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \
+    defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40300)
+#define DUK_HOT             __attribute__((hot))
+#define DUK_COLD            __attribute__((cold))
+#endif
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL  extern __declspec(dllexport)
+#define DUK_EXTERNAL       __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL  extern __declspec(dllimport)
+#define DUK_EXTERNAL       should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+#elif defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40000)
+#define DUK_EXTERNAL_DECL  __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL       __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang.  Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL  static __attribute__ ((unused))
+#define DUK_INTERNAL       static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+#endif
+
+#if defined(DUK_F_MINGW)
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "mingw++"
+#else
+#define DUK_USE_COMPILER_STRING "mingw"
+#endif
+#else
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "g++"
+#else
+#define DUK_USE_COMPILER_STRING "gcc"
+#endif
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__))
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40600)
+#define DUK_USE_GCC_PRAGMAS
+#else
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+#define DUK_USE_PACK_GCC_ATTR
+#elif defined(DUK_F_MSVC)
+/* --- MSVC --- */
+/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */
+#define DUK_NORETURN(decl)  __declspec(noreturn) decl
+
+/* XXX: DUK_UNREACHABLE for msvc? */
+
+#undef DUK_USE_BRANCH_HINTS
+
+/* XXX: DUK_LIKELY, DUK_UNLIKELY for msvc? */
+/* XXX: DUK_NOINLINE, DUK_INLINE, DUK_ALWAYS_INLINE for msvc? */
+
+#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS)
+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
+ * compiling Duktape or the application.
+ */
+#if defined(DUK_COMPILING_DUKTAPE)
+#define DUK_EXTERNAL_DECL  extern __declspec(dllexport)
+#define DUK_EXTERNAL       __declspec(dllexport)
+#else
+#define DUK_EXTERNAL_DECL  extern __declspec(dllimport)
+#define DUK_EXTERNAL       should_not_happen
+#endif
+#if defined(DUK_SINGLE_FILE)
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#else
+#define DUK_INTERNAL_DECL  extern
+#define DUK_INTERNAL       /*empty*/
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+#endif
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "msvc++"
+#else
+#define DUK_USE_COMPILER_STRING "msvc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99)
+#define DUK_USE_VARIADIC_MACROS
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+/* VS2005+ should have variadic macros even when they're not C99. */
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(_MSC_VER) && (_MSC_VER >= 1800)
+/* VS2013+ supports union initializers but there's a bug involving union-inside-struct:
+ * https://connect.microsoft.com/VisualStudio/feedback/details/805981
+ * The bug was fixed (at least) in VS2015 so check for VS2015 for now:
+ * https://blogs.msdn.microsoft.com/vcblog/2015/07/01/c-compiler-front-end-fixes-in-vs2015/
+ * Manually tested using VS2013, CL reports 18.00.31101, so enable for VS2013 too.
+ */
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+
+#define DUK_USE_PACK_MSVC_PRAGMA
+
+/* These have been tested from VS2008 onwards; may work in older VS versions
+ * too but not enabled by default.
+ */
+#if defined(_MSC_VER) && (_MSC_VER >= 1500)
+#define DUK_NOINLINE        __declspec(noinline)
+#define DUK_INLINE          __inline
+#define DUK_ALWAYS_INLINE   __forceinline
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1900)
+#define DUK_SNPRINTF     snprintf
+#define DUK_VSNPRINTF    vsnprintf
+#else
+/* (v)snprintf() is missing before MSVC 2015.  Note that _(v)snprintf() does
+ * NOT NUL terminate on truncation, but Duktape code never assumes that.
+ * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+ */
+#define DUK_SNPRINTF     _snprintf
+#define DUK_VSNPRINTF    _vsnprintf
+#endif
+
+/* Avoid warning when doing DUK_UNREF(some_function). */
+#if defined(_MSC_VER) && (_MSC_VER < 1500)
+#pragma warning(disable: 4100 4101 4550 4551)
+#define DUK_UNREF(x)
+#else
+#define DUK_UNREF(x)  do { __pragma(warning(suppress:4100 4101 4550 4551)) (x); } while (0)
+#endif
+
+/* Older versions of MSVC don't support the LL/ULL suffix. */
+#define DUK_U64_CONSTANT(x) x##ui64
+#define DUK_I64_CONSTANT(x) x##i64
+#elif defined(DUK_F_EMSCRIPTEN)
+/* --- Emscripten --- */
+#define DUK_NORETURN(decl)  decl __attribute__((noreturn))
+
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unreachable)
+#define DUK_UNREACHABLE()  do { __builtin_unreachable(); } while (0)
+#endif
+#endif
+
+#define DUK_USE_BRANCH_HINTS
+#define DUK_LIKELY(x)    __builtin_expect((x), 1)
+#define DUK_UNLIKELY(x)  __builtin_expect((x), 0)
+#if defined(__clang__) && defined(__has_builtin)
+#if __has_builtin(__builtin_unpredictable)
+#define DUK_UNPREDICTABLE(x)  __builtin_unpredictable((x))
+#endif
+#endif
+
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_NOINLINE        __attribute__((noinline))
+#define DUK_INLINE          inline
+#define DUK_ALWAYS_INLINE   inline __attribute__((always_inline))
+#endif
+
+#define DUK_EXTERNAL_DECL  __attribute__ ((visibility("default"))) extern
+#define DUK_EXTERNAL       __attribute__ ((visibility("default")))
+#if defined(DUK_SINGLE_FILE)
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and
+ * Clang.  Based on documentation it should suffice to have the attribute
+ * in the declaration only, but in practice some warnings are generated unless
+ * the attribute is also applied to the definition.
+ */
+#define DUK_INTERNAL_DECL  static __attribute__ ((unused))
+#define DUK_INTERNAL       static __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  static
+#define DUK_INTERNAL       static
+#endif
+#else
+#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG)
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden"))) __attribute__ ((unused))
+#else
+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) extern
+#define DUK_INTERNAL       __attribute__ ((visibility("hidden")))
+#endif
+#endif
+#define DUK_LOCAL_DECL     static
+#define DUK_LOCAL          static
+
+#define DUK_USE_COMPILER_STRING "emscripten"
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+#define DUK_USE_UNION_INITIALIZERS
+
+#undef DUK_USE_FLEX_C99
+#undef DUK_USE_FLEX_ZEROSIZE
+#undef DUK_USE_FLEX_ONESIZE
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE
+#endif
+
+#undef DUK_USE_GCC_PRAGMAS
+#define DUK_USE_PACK_CLANG_ATTR
+#elif defined(DUK_F_TINYC)
+/* --- TinyC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "tinyc++"
+#else
+#define DUK_USE_COMPILER_STRING "tinyc"
+#endif
+
+/* http://bellard.org/tcc/tcc-doc.html#SEC7 */
+#define DUK_USE_VARIADIC_MACROS
+
+#define DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_VBCC)
+/* --- VBCC --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "vbcc-c++"
+#else
+#define DUK_USE_COMPILER_STRING "vbcc"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* VBCC supports C99 so check only for C99 for union initializer support.
+ * Designated union initializers would possibly work even without a C99 check.
+ */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+#define DUK_USE_FLEX_ZEROSIZE
+#define DUK_USE_PACK_DUMMY_MEMBER
+#elif defined(DUK_F_BCC)
+/* --- Bruce's C compiler --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "bcc++"
+#else
+#define DUK_USE_COMPILER_STRING "bcc"
+#endif
+
+/* Most portable */
+#undef DUK_USE_VARIADIC_MACROS
+
+/* Most portable, wastes space */
+#undef DUK_USE_UNION_INITIALIZERS
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+
+/* BCC, assume we're on x86. */
+#if !defined(DUK_USE_BYTEORDER)
+#define DUK_USE_BYTEORDER 1
+#endif
+#else
+/* --- Generic --- */
+#undef DUK_USE_BRANCH_HINTS
+
+#if defined(DUK_F_CPP)
+#define DUK_USE_COMPILER_STRING "generic-c++"
+#else
+#define DUK_USE_COMPILER_STRING "generic"
+#endif
+
+#undef DUK_USE_VARIADIC_MACROS
+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
+#define DUK_USE_VARIADIC_MACROS
+#endif
+
+/* C++ doesn't have standard designated union initializers ({ .foo = 1 }). */
+#undef DUK_USE_UNION_INITIALIZERS
+#if defined(DUK_F_C99)
+#define DUK_USE_UNION_INITIALIZERS
+#endif
+
+/* Most portable, wastes space */
+#define DUK_USE_FLEX_ONESIZE
+
+/* Most portable, potentially wastes space */
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif  /* autodetect compiler */
+
+/* uclibc */
+#if defined(__UCLIBC__)
+#define DUK_F_UCLIBC
+#endif
+
+/*
+ *  Wrapper typedefs and constants for integer types, also sanity check types.
+ *
+ *  C99 typedefs are quite good but not always available, and we want to avoid
+ *  forcibly redefining the C99 typedefs.  So, there are Duktape wrappers for
+ *  all C99 typedefs and Duktape code should only use these typedefs.  Type
+ *  detection when C99 is not supported is best effort and may end up detecting
+ *  some types incorrectly.
+ *
+ *  Pointer sizes are a portability problem: pointers to different types may
+ *  have a different size and function pointers are very difficult to manage
+ *  portably.
+ *
+ *  http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types
+ *
+ *  Note: there's an interesting corner case when trying to define minimum
+ *  signed integer value constants which leads to the current workaround of
+ *  defining e.g. -0x80000000 as (-0x7fffffffL - 1L).  See doc/code-issues.txt
+ *  for a longer discussion.
+ *
+ *  Note: avoid typecasts and computations in macro integer constants as they
+ *  can then no longer be used in macro relational expressions (such as
+ *  #if DUK_SIZE_MAX < 0xffffffffUL).  There is internal code which relies on
+ *  being able to compare DUK_SIZE_MAX against a limit.
+ */
+
+/* XXX: add feature options to force basic types from outside? */
+
+#if !defined(INT_MAX)
+#error INT_MAX not defined
+#endif
+
+/* Check that architecture is two's complement, standard C allows e.g.
+ * INT_MIN to be -2**31+1 (instead of -2**31).
+ */
+#if defined(INT_MAX) && defined(INT_MIN)
+#if INT_MAX != -(INT_MIN + 1)
+#error platform does not seem complement of two
+#endif
+#else
+#error cannot check complement of two
+#endif
+
+/* Pointer size determination based on __WORDSIZE or architecture when
+ * that's not available.
+ */
+#if defined(DUK_F_X86) || defined(DUK_F_X32) || \
+    defined(DUK_F_M68K) || defined(DUK_F_PPC32) || \
+    defined(DUK_F_BCC) || \
+    (defined(__WORDSIZE) && (__WORDSIZE == 32)) || \
+    ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \
+      defined(DUK_F_HPUX)) && defined(_ILP32)) || \
+    defined(DUK_F_ARM32)
+#define DUK_F_32BIT_PTRS
+#elif defined(DUK_F_X64) || \
+      (defined(__WORDSIZE) && (__WORDSIZE == 64)) || \
+   ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \
+     defined(DUK_F_HPUX)) && defined(_LP64)) || \
+    defined(DUK_F_ARM64)
+#define DUK_F_64BIT_PTRS
+#else
+/* not sure, not needed with C99 anyway */
+#endif
+
+/* Intermediate define for 'have inttypes.h' */
+#undef DUK_F_HAVE_INTTYPES
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC))
+/* vbcc + AmigaOS has C99 but no inttypes.h */
+#define DUK_F_HAVE_INTTYPES
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+/* C++11 apparently ratified stdint.h */
+#define DUK_F_HAVE_INTTYPES
+#endif
+
+/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise
+ * through automatic detection.
+ */
+#if defined(DUK_F_HAVE_INTTYPES)
+/* C99 or compatible */
+
+#define DUK_F_HAVE_64BIT
+#include 
+
+typedef uint8_t duk_uint8_t;
+typedef int8_t duk_int8_t;
+typedef uint16_t duk_uint16_t;
+typedef int16_t duk_int16_t;
+typedef uint32_t duk_uint32_t;
+typedef int32_t duk_int32_t;
+typedef uint64_t duk_uint64_t;
+typedef int64_t duk_int64_t;
+typedef uint_least8_t duk_uint_least8_t;
+typedef int_least8_t duk_int_least8_t;
+typedef uint_least16_t duk_uint_least16_t;
+typedef int_least16_t duk_int_least16_t;
+typedef uint_least32_t duk_uint_least32_t;
+typedef int_least32_t duk_int_least32_t;
+typedef uint_least64_t duk_uint_least64_t;
+typedef int_least64_t duk_int_least64_t;
+typedef uint_fast8_t duk_uint_fast8_t;
+typedef int_fast8_t duk_int_fast8_t;
+typedef uint_fast16_t duk_uint_fast16_t;
+typedef int_fast16_t duk_int_fast16_t;
+typedef uint_fast32_t duk_uint_fast32_t;
+typedef int_fast32_t duk_int_fast32_t;
+typedef uint_fast64_t duk_uint_fast64_t;
+typedef int_fast64_t duk_int_fast64_t;
+typedef uintptr_t duk_uintptr_t;
+typedef intptr_t duk_intptr_t;
+typedef uintmax_t duk_uintmax_t;
+typedef intmax_t duk_intmax_t;
+
+#define DUK_UINT8_MIN         0
+#define DUK_UINT8_MAX         UINT8_MAX
+#define DUK_INT8_MIN          INT8_MIN
+#define DUK_INT8_MAX          INT8_MAX
+#define DUK_UINT_LEAST8_MIN   0
+#define DUK_UINT_LEAST8_MAX   UINT_LEAST8_MAX
+#define DUK_INT_LEAST8_MIN    INT_LEAST8_MIN
+#define DUK_INT_LEAST8_MAX    INT_LEAST8_MAX
+#define DUK_UINT_FAST8_MIN    0
+#define DUK_UINT_FAST8_MAX    UINT_FAST8_MAX
+#define DUK_INT_FAST8_MIN     INT_FAST8_MIN
+#define DUK_INT_FAST8_MAX     INT_FAST8_MAX
+#define DUK_UINT16_MIN        0
+#define DUK_UINT16_MAX        UINT16_MAX
+#define DUK_INT16_MIN         INT16_MIN
+#define DUK_INT16_MAX         INT16_MAX
+#define DUK_UINT_LEAST16_MIN  0
+#define DUK_UINT_LEAST16_MAX  UINT_LEAST16_MAX
+#define DUK_INT_LEAST16_MIN   INT_LEAST16_MIN
+#define DUK_INT_LEAST16_MAX   INT_LEAST16_MAX
+#define DUK_UINT_FAST16_MIN   0
+#define DUK_UINT_FAST16_MAX   UINT_FAST16_MAX
+#define DUK_INT_FAST16_MIN    INT_FAST16_MIN
+#define DUK_INT_FAST16_MAX    INT_FAST16_MAX
+#define DUK_UINT32_MIN        0
+#define DUK_UINT32_MAX        UINT32_MAX
+#define DUK_INT32_MIN         INT32_MIN
+#define DUK_INT32_MAX         INT32_MAX
+#define DUK_UINT_LEAST32_MIN  0
+#define DUK_UINT_LEAST32_MAX  UINT_LEAST32_MAX
+#define DUK_INT_LEAST32_MIN   INT_LEAST32_MIN
+#define DUK_INT_LEAST32_MAX   INT_LEAST32_MAX
+#define DUK_UINT_FAST32_MIN   0
+#define DUK_UINT_FAST32_MAX   UINT_FAST32_MAX
+#define DUK_INT_FAST32_MIN    INT_FAST32_MIN
+#define DUK_INT_FAST32_MAX    INT_FAST32_MAX
+#define DUK_UINT64_MIN        0
+#define DUK_UINT64_MAX        UINT64_MAX
+#define DUK_INT64_MIN         INT64_MIN
+#define DUK_INT64_MAX         INT64_MAX
+#define DUK_UINT_LEAST64_MIN  0
+#define DUK_UINT_LEAST64_MAX  UINT_LEAST64_MAX
+#define DUK_INT_LEAST64_MIN   INT_LEAST64_MIN
+#define DUK_INT_LEAST64_MAX   INT_LEAST64_MAX
+#define DUK_UINT_FAST64_MIN   0
+#define DUK_UINT_FAST64_MAX   UINT_FAST64_MAX
+#define DUK_INT_FAST64_MIN    INT_FAST64_MIN
+#define DUK_INT_FAST64_MAX    INT_FAST64_MAX
+
+#define DUK_UINTPTR_MIN       0
+#define DUK_UINTPTR_MAX       UINTPTR_MAX
+#define DUK_INTPTR_MIN        INTPTR_MIN
+#define DUK_INTPTR_MAX        INTPTR_MAX
+
+#define DUK_UINTMAX_MIN       0
+#define DUK_UINTMAX_MAX       UINTMAX_MAX
+#define DUK_INTMAX_MIN        INTMAX_MIN
+#define DUK_INTMAX_MAX        INTMAX_MAX
+
+#define DUK_SIZE_MIN          0
+#define DUK_SIZE_MAX          SIZE_MAX
+#undef DUK_SIZE_MAX_COMPUTED
+
+#else  /* C99 types */
+
+/* When C99 types are not available, we use heuristic detection to get
+ * the basic 8, 16, 32, and (possibly) 64 bit types.  The fast/least
+ * types are then assumed to be exactly the same for now: these could
+ * be improved per platform but C99 types are very often now available.
+ * 64-bit types are not available on all platforms; this is OK at least
+ * on 32-bit platforms.
+ *
+ * This detection code is necessarily a bit hacky and can provide typedefs
+ * and defines that won't work correctly on some exotic platform.
+ */
+
+#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \
+    (defined(UCHAR_MAX) && (UCHAR_MAX == 255))
+typedef unsigned char duk_uint8_t;
+typedef signed char duk_int8_t;
+#else
+#error cannot detect 8-bit type
+#endif
+
+#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL)
+typedef unsigned short duk_uint16_t;
+typedef signed short duk_int16_t;
+#elif defined(UINT_MAX) && (UINT_MAX == 65535UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned int duk_uint16_t;
+typedef signed int duk_int16_t;
+#else
+#error cannot detect 16-bit type
+#endif
+
+#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL)
+typedef unsigned int duk_uint32_t;
+typedef signed int duk_int32_t;
+#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL)
+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
+typedef unsigned long duk_uint32_t;
+typedef signed long duk_int32_t;
+#else
+#error cannot detect 32-bit type
+#endif
+
+/* 64-bit type detection is a bit tricky.
+ *
+ * ULLONG_MAX is a standard define.  __LONG_LONG_MAX__ and __ULONG_LONG_MAX__
+ * are used by at least GCC (even if system headers don't provide ULLONG_MAX).
+ * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__.
+ *
+ * ULL / LL constants are rejected / warned about by some compilers, even if
+ * the compiler has a 64-bit type and the compiler/system headers provide an
+ * unsupported constant (ULL/LL)!  Try to avoid using ULL / LL constants.
+ * As a side effect we can only check that e.g. ULONG_MAX is larger than 32
+ * bits but can't be sure it is exactly 64 bits.  Self tests will catch such
+ * cases.
+ */
+#undef DUK_F_HAVE_64BIT
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX)
+#if (ULONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX)
+#if (ULLONG_MAX > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__)
+#if (__ULONG_LONG_MAX__ > 4294967295UL)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__)
+#if (__LONG_LONG_MAX__ > 2147483647L)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long long duk_uint64_t;
+typedef signed long long duk_int64_t;
+#endif
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(DUK_F_MINGW)
+#define DUK_F_HAVE_64BIT
+typedef unsigned long duk_uint64_t;
+typedef signed long duk_int64_t;
+#endif
+#if !defined(DUK_F_HAVE_64BIT) && defined(DUK_F_MSVC)
+#define DUK_F_HAVE_64BIT
+typedef unsigned __int64 duk_uint64_t;
+typedef signed __int64 duk_int64_t;
+#endif
+#if !defined(DUK_F_HAVE_64BIT)
+/* cannot detect 64-bit type, not always needed so don't error */
+#endif
+
+typedef duk_uint8_t duk_uint_least8_t;
+typedef duk_int8_t duk_int_least8_t;
+typedef duk_uint16_t duk_uint_least16_t;
+typedef duk_int16_t duk_int_least16_t;
+typedef duk_uint32_t duk_uint_least32_t;
+typedef duk_int32_t duk_int_least32_t;
+typedef duk_uint8_t duk_uint_fast8_t;
+typedef duk_int8_t duk_int_fast8_t;
+typedef duk_uint16_t duk_uint_fast16_t;
+typedef duk_int16_t duk_int_fast16_t;
+typedef duk_uint32_t duk_uint_fast32_t;
+typedef duk_int32_t duk_int_fast32_t;
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uint_least64_t;
+typedef duk_int64_t duk_int_least64_t;
+typedef duk_uint64_t duk_uint_fast64_t;
+typedef duk_int64_t duk_int_fast64_t;
+#endif
+#if defined(DUK_F_HAVE_64BIT)
+typedef duk_uint64_t duk_uintmax_t;
+typedef duk_int64_t duk_intmax_t;
+#else
+typedef duk_uint32_t duk_uintmax_t;
+typedef duk_int32_t duk_intmax_t;
+#endif
+
+/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and
+ * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are
+ * -not- portable.  See code-issues.txt for a detailed discussion.
+ */
+#define DUK_UINT8_MIN         0UL
+#define DUK_UINT8_MAX         0xffUL
+#define DUK_INT8_MIN          (-0x80L)
+#define DUK_INT8_MAX          0x7fL
+#define DUK_UINT_LEAST8_MIN   0UL
+#define DUK_UINT_LEAST8_MAX   0xffUL
+#define DUK_INT_LEAST8_MIN    (-0x80L)
+#define DUK_INT_LEAST8_MAX    0x7fL
+#define DUK_UINT_FAST8_MIN    0UL
+#define DUK_UINT_FAST8_MAX    0xffUL
+#define DUK_INT_FAST8_MIN     (-0x80L)
+#define DUK_INT_FAST8_MAX     0x7fL
+#define DUK_UINT16_MIN        0UL
+#define DUK_UINT16_MAX        0xffffUL
+#define DUK_INT16_MIN         (-0x7fffL - 1L)
+#define DUK_INT16_MAX         0x7fffL
+#define DUK_UINT_LEAST16_MIN  0UL
+#define DUK_UINT_LEAST16_MAX  0xffffUL
+#define DUK_INT_LEAST16_MIN   (-0x7fffL - 1L)
+#define DUK_INT_LEAST16_MAX   0x7fffL
+#define DUK_UINT_FAST16_MIN   0UL
+#define DUK_UINT_FAST16_MAX   0xffffUL
+#define DUK_INT_FAST16_MIN    (-0x7fffL - 1L)
+#define DUK_INT_FAST16_MAX    0x7fffL
+#define DUK_UINT32_MIN        0UL
+#define DUK_UINT32_MAX        0xffffffffUL
+#define DUK_INT32_MIN         (-0x7fffffffL - 1L)
+#define DUK_INT32_MAX         0x7fffffffL
+#define DUK_UINT_LEAST32_MIN  0UL
+#define DUK_UINT_LEAST32_MAX  0xffffffffUL
+#define DUK_INT_LEAST32_MIN   (-0x7fffffffL - 1L)
+#define DUK_INT_LEAST32_MAX   0x7fffffffL
+#define DUK_UINT_FAST32_MIN   0UL
+#define DUK_UINT_FAST32_MAX   0xffffffffUL
+#define DUK_INT_FAST32_MIN    (-0x7fffffffL - 1L)
+#define DUK_INT_FAST32_MAX    0x7fffffffL
+
+/* 64-bit constants.  Since LL / ULL constants are not always available,
+ * use computed values.  These values can't be used in preprocessor
+ * comparisons; flag them as such.
+ */
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINT64_MIN        ((duk_uint64_t) 0)
+#define DUK_UINT64_MAX        ((duk_uint64_t) -1)
+#define DUK_INT64_MIN         ((duk_int64_t) (~(DUK_UINT64_MAX >> 1)))
+#define DUK_INT64_MAX         ((duk_int64_t) (DUK_UINT64_MAX >> 1))
+#define DUK_UINT_LEAST64_MIN  DUK_UINT64_MIN
+#define DUK_UINT_LEAST64_MAX  DUK_UINT64_MAX
+#define DUK_INT_LEAST64_MIN   DUK_INT64_MIN
+#define DUK_INT_LEAST64_MAX   DUK_INT64_MAX
+#define DUK_UINT_FAST64_MIN   DUK_UINT64_MIN
+#define DUK_UINT_FAST64_MAX   DUK_UINT64_MAX
+#define DUK_INT_FAST64_MIN    DUK_INT64_MIN
+#define DUK_INT_FAST64_MAX    DUK_INT64_MAX
+#define DUK_UINT64_MIN_COMPUTED
+#define DUK_UINT64_MAX_COMPUTED
+#define DUK_INT64_MIN_COMPUTED
+#define DUK_INT64_MAX_COMPUTED
+#define DUK_UINT_LEAST64_MIN_COMPUTED
+#define DUK_UINT_LEAST64_MAX_COMPUTED
+#define DUK_INT_LEAST64_MIN_COMPUTED
+#define DUK_INT_LEAST64_MAX_COMPUTED
+#define DUK_UINT_FAST64_MIN_COMPUTED
+#define DUK_UINT_FAST64_MAX_COMPUTED
+#define DUK_INT_FAST64_MIN_COMPUTED
+#define DUK_INT_FAST64_MAX_COMPUTED
+#endif
+
+#if defined(DUK_F_HAVE_64BIT)
+#define DUK_UINTMAX_MIN       DUK_UINT64_MIN
+#define DUK_UINTMAX_MAX       DUK_UINT64_MAX
+#define DUK_INTMAX_MIN        DUK_INT64_MIN
+#define DUK_INTMAX_MAX        DUK_INT64_MAX
+#define DUK_UINTMAX_MIN_COMPUTED
+#define DUK_UINTMAX_MAX_COMPUTED
+#define DUK_INTMAX_MIN_COMPUTED
+#define DUK_INTMAX_MAX_COMPUTED
+#else
+#define DUK_UINTMAX_MIN       0UL
+#define DUK_UINTMAX_MAX       0xffffffffUL
+#define DUK_INTMAX_MIN        (-0x7fffffffL - 1L)
+#define DUK_INTMAX_MAX        0x7fffffffL
+#endif
+
+/* This detection is not very reliable. */
+#if defined(DUK_F_32BIT_PTRS)
+typedef duk_int32_t duk_intptr_t;
+typedef duk_uint32_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN       DUK_UINT32_MIN
+#define DUK_UINTPTR_MAX       DUK_UINT32_MAX
+#define DUK_INTPTR_MIN        DUK_INT32_MIN
+#define DUK_INTPTR_MAX        DUK_INT32_MAX
+#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT)
+typedef duk_int64_t duk_intptr_t;
+typedef duk_uint64_t duk_uintptr_t;
+#define DUK_UINTPTR_MIN       DUK_UINT64_MIN
+#define DUK_UINTPTR_MAX       DUK_UINT64_MAX
+#define DUK_INTPTR_MIN        DUK_INT64_MIN
+#define DUK_INTPTR_MAX        DUK_INT64_MAX
+#define DUK_UINTPTR_MIN_COMPUTED
+#define DUK_UINTPTR_MAX_COMPUTED
+#define DUK_INTPTR_MIN_COMPUTED
+#define DUK_INTPTR_MAX_COMPUTED
+#else
+#error cannot determine intptr type
+#endif
+
+/* SIZE_MAX may be missing so use an approximate value for it. */
+#undef DUK_SIZE_MAX_COMPUTED
+#if !defined(SIZE_MAX)
+#define DUK_SIZE_MAX_COMPUTED
+#define SIZE_MAX              ((size_t) (-1))
+#endif
+#define DUK_SIZE_MIN          0
+#define DUK_SIZE_MAX          SIZE_MAX
+
+#endif  /* C99 types */
+
+/* A few types are assumed to always exist. */
+typedef size_t duk_size_t;
+typedef ptrdiff_t duk_ptrdiff_t;
+
+/* The best type for an "all around int" in Duktape internals is "at least
+ * 32 bit signed integer" which is most convenient.  Same for unsigned type.
+ * Prefer 'int' when large enough, as it is almost always a convenient type.
+ */
+#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL)
+typedef int duk_int_t;
+typedef unsigned int duk_uint_t;
+#define DUK_INT_MIN           INT_MIN
+#define DUK_INT_MAX           INT_MAX
+#define DUK_UINT_MIN          0
+#define DUK_UINT_MAX          UINT_MAX
+#else
+typedef duk_int_fast32_t duk_int_t;
+typedef duk_uint_fast32_t duk_uint_t;
+#define DUK_INT_MIN           DUK_INT_FAST32_MIN
+#define DUK_INT_MAX           DUK_INT_FAST32_MAX
+#define DUK_UINT_MIN          DUK_UINT_FAST32_MIN
+#define DUK_UINT_MAX          DUK_UINT_FAST32_MAX
+#endif
+
+/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this
+ * distinction matters for the CPU.  These types are used mainly in the
+ * executor where it might really matter.
+ */
+typedef duk_int_fast32_t duk_int_fast_t;
+typedef duk_uint_fast32_t duk_uint_fast_t;
+#define DUK_INT_FAST_MIN      DUK_INT_FAST32_MIN
+#define DUK_INT_FAST_MAX      DUK_INT_FAST32_MAX
+#define DUK_UINT_FAST_MIN     DUK_UINT_FAST32_MIN
+#define DUK_UINT_FAST_MAX     DUK_UINT_FAST32_MAX
+
+/* Small integers (16 bits or more) can fall back to the 'int' type, but
+ * have a typedef so they are marked "small" explicitly.
+ */
+typedef int duk_small_int_t;
+typedef unsigned int duk_small_uint_t;
+#define DUK_SMALL_INT_MIN     INT_MIN
+#define DUK_SMALL_INT_MAX     INT_MAX
+#define DUK_SMALL_UINT_MIN    0
+#define DUK_SMALL_UINT_MAX    UINT_MAX
+
+/* Fast variants of small integers, again for really fast paths like the
+ * executor.
+ */
+typedef duk_int_fast16_t duk_small_int_fast_t;
+typedef duk_uint_fast16_t duk_small_uint_fast_t;
+#define DUK_SMALL_INT_FAST_MIN    DUK_INT_FAST16_MIN
+#define DUK_SMALL_INT_FAST_MAX    DUK_INT_FAST16_MAX
+#define DUK_SMALL_UINT_FAST_MIN   DUK_UINT_FAST16_MIN
+#define DUK_SMALL_UINT_FAST_MAX   DUK_UINT_FAST16_MAX
+
+/* Boolean values are represented with the platform 'unsigned int'. */
+typedef duk_small_uint_t duk_bool_t;
+#define DUK_BOOL_MIN              DUK_SMALL_INT_MIN
+#define DUK_BOOL_MAX              DUK_SMALL_INT_MAX
+
+/* Index values must have at least 32-bit signed range. */
+typedef duk_int_t duk_idx_t;
+#define DUK_IDX_MIN               DUK_INT_MIN
+#define DUK_IDX_MAX               DUK_INT_MAX
+
+/* Unsigned index variant. */
+typedef duk_uint_t duk_uidx_t;
+#define DUK_UIDX_MIN              DUK_UINT_MIN
+#define DUK_UIDX_MAX              DUK_UINT_MAX
+
+/* Array index values, could be exact 32 bits.
+ * Currently no need for signed duk_arridx_t.
+ */
+typedef duk_uint_t duk_uarridx_t;
+#define DUK_UARRIDX_MIN           DUK_UINT_MIN
+#define DUK_UARRIDX_MAX           DUK_UINT_MAX
+
+/* Duktape/C function return value, platform int is enough for now to
+ * represent 0, 1, or negative error code.  Must be compatible with
+ * assigning truth values (e.g. duk_ret_t rc = (foo == bar);).
+ */
+typedef duk_small_int_t duk_ret_t;
+#define DUK_RET_MIN               DUK_SMALL_INT_MIN
+#define DUK_RET_MAX               DUK_SMALL_INT_MAX
+
+/* Error codes are represented with platform int.  High bits are used
+ * for flags and such, so 32 bits are needed.
+ */
+typedef duk_int_t duk_errcode_t;
+#define DUK_ERRCODE_MIN           DUK_INT_MIN
+#define DUK_ERRCODE_MAX           DUK_INT_MAX
+
+/* Codepoint type.  Must be 32 bits or more because it is used also for
+ * internal codepoints.  The type is signed because negative codepoints
+ * are used as internal markers (e.g. to mark EOF or missing argument).
+ * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to
+ * ensure duk_uint32_t casts back and forth nicely.  Almost everything
+ * else uses the signed one.
+ */
+typedef duk_int_t duk_codepoint_t;
+typedef duk_uint_t duk_ucodepoint_t;
+#define DUK_CODEPOINT_MIN         DUK_INT_MIN
+#define DUK_CODEPOINT_MAX         DUK_INT_MAX
+#define DUK_UCODEPOINT_MIN        DUK_UINT_MIN
+#define DUK_UCODEPOINT_MAX        DUK_UINT_MAX
+
+/* IEEE float/double typedef. */
+typedef float duk_float_t;
+typedef double duk_double_t;
+
+/* We're generally assuming that we're working on a platform with a 32-bit
+ * address space.  If DUK_SIZE_MAX is a typecast value (which is necessary
+ * if SIZE_MAX is missing), the check must be avoided because the
+ * preprocessor can't do a comparison.
+ */
+#if !defined(DUK_SIZE_MAX)
+#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX
+#elif !defined(DUK_SIZE_MAX_COMPUTED)
+#if DUK_SIZE_MAX < 0xffffffffUL
+/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value
+ * which seems incorrect if size_t is (at least) an unsigned 32-bit type.
+ * However, it doesn't seem useful to error out compilation if this is the
+ * case.
+ */
+#endif
+#endif
+
+/* Type used in public API declarations and user code.  Typedef maps to
+ * 'struct duk_hthread' like the 'duk_hthread' typedef which is used
+ * exclusively in internals.
+ */
+typedef struct duk_hthread duk_context;
+
+/* Check whether we should use 64-bit integers or not.
+ *
+ * Quite incomplete now.  Use 64-bit types if detected (C99 or other detection)
+ * unless they are known to be unreliable.  For instance, 64-bit types are
+ * available on VBCC but seem to misbehave.
+ */
+#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC)
+#define DUK_USE_64BIT_OPS
+#else
+#undef DUK_USE_64BIT_OPS
+#endif
+
+/*
+ *  Fill-ins for platform, architecture, and compiler
+ */
+
+/* An abort()-like primitive is needed by the default fatal error handler. */
+#if !defined(DUK_ABORT)
+#define DUK_ABORT             abort
+#endif
+
+#if !defined(DUK_SETJMP)
+#define DUK_JMPBUF_TYPE       jmp_buf
+#define DUK_SETJMP(jb)        setjmp((jb))
+#define DUK_LONGJMP(jb)       longjmp((jb), 1)
+#endif
+
+#if 0
+/* sigsetjmp() alternative */
+#define DUK_JMPBUF_TYPE       sigjmp_buf
+#define DUK_SETJMP(jb)        sigsetjmp((jb))
+#define DUK_LONGJMP(jb)       siglongjmp((jb), 1)
+#endif
+
+/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h
+ * (which is unfortunately named).  May sometimes need replacement, e.g.
+ * some compilers don't handle zero length or NULL correctly in realloc().
+ */
+#if !defined(DUK_ANSI_MALLOC)
+#define DUK_ANSI_MALLOC      malloc
+#endif
+#if !defined(DUK_ANSI_REALLOC)
+#define DUK_ANSI_REALLOC     realloc
+#endif
+#if !defined(DUK_ANSI_CALLOC)
+#define DUK_ANSI_CALLOC      calloc
+#endif
+#if !defined(DUK_ANSI_FREE)
+#define DUK_ANSI_FREE        free
+#endif
+
+/* ANSI C (various versions) and some implementations require that the
+ * pointer arguments to memset(), memcpy(), and memmove() be valid values
+ * even when byte size is 0 (even a NULL pointer is considered invalid in
+ * this context).  Zero-size operations as such are allowed, as long as their
+ * pointer arguments point to a valid memory area.  The DUK_MEMSET(),
+ * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.:
+ * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be
+ * allowed.  If these are not fulfilled, a macro wrapper is needed.
+ *
+ *   http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
+ *   http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html
+ *
+ * Not sure what's the required behavior when a pointer points just past the
+ * end of a buffer, which often happens in practice (e.g. zero size memmoves).
+ * For example, if allocation size is 3, the following pointer would not
+ * technically point to a valid memory byte:
+ *
+ *   <-- alloc -->
+ *   | 0 | 1 | 2 | .....
+ *                 ^-- p=3, points after last valid byte (2)
+ */
+#if !defined(DUK_MEMCPY)
+#if defined(DUK_F_UCLIBC)
+/* Old uclibcs have a broken memcpy so use memmove instead (this is overly wide
+ * now on purpose): http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html
+ */
+#define DUK_MEMCPY       memmove
+#else
+#define DUK_MEMCPY       memcpy
+#endif
+#endif
+#if !defined(DUK_MEMMOVE)
+#define DUK_MEMMOVE      memmove
+#endif
+#if !defined(DUK_MEMCMP)
+#define DUK_MEMCMP       memcmp
+#endif
+#if !defined(DUK_MEMSET)
+#define DUK_MEMSET       memset
+#endif
+#if !defined(DUK_STRLEN)
+#define DUK_STRLEN       strlen
+#endif
+#if !defined(DUK_STRCMP)
+#define DUK_STRCMP       strcmp
+#endif
+#if !defined(DUK_STRNCMP)
+#define DUK_STRNCMP      strncmp
+#endif
+#if !defined(DUK_SPRINTF)
+#define DUK_SPRINTF      sprintf
+#endif
+#if !defined(DUK_SNPRINTF)
+/* snprintf() is technically not part of C89 but usually available. */
+#define DUK_SNPRINTF     snprintf
+#endif
+#if !defined(DUK_VSPRINTF)
+#define DUK_VSPRINTF     vsprintf
+#endif
+#if !defined(DUK_VSNPRINTF)
+/* vsnprintf() is technically not part of C89 but usually available. */
+#define DUK_VSNPRINTF    vsnprintf
+#endif
+#if !defined(DUK_SSCANF)
+#define DUK_SSCANF       sscanf
+#endif
+#if !defined(DUK_VSSCANF)
+#define DUK_VSSCANF      vsscanf
+#endif
+#if !defined(DUK_MEMZERO)
+#define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n))
+#endif
+
+#if !defined(DUK_DOUBLE_INFINITY)
+#undef DUK_USE_COMPUTED_INFINITY
+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600)
+/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */
+#define DUK_DOUBLE_INFINITY  (__builtin_inf())
+#elif defined(INFINITY)
+#define DUK_DOUBLE_INFINITY  ((double) INFINITY)
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) && \
+      !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX)
+#define DUK_DOUBLE_INFINITY  (1.0 / 0.0)
+#else
+/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity.
+ * Use a computed infinity (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_INFINITY
+#define DUK_DOUBLE_INFINITY  duk_computed_infinity
+#endif
+#endif
+
+#if !defined(DUK_DOUBLE_NAN)
+#undef DUK_USE_COMPUTED_NAN
+#if defined(NAN)
+#define DUK_DOUBLE_NAN       NAN
+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) && \
+      !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX)
+#define DUK_DOUBLE_NAN       (0.0 / 0.0)
+#else
+/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN.
+ * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error.
+ * Use a computed NaN (initialized when a heap is created at the
+ * latest).
+ */
+#define DUK_USE_COMPUTED_NAN
+#define DUK_DOUBLE_NAN       duk_computed_nan
+#endif
+#endif
+
+/* Many platforms are missing fpclassify() and friends, so use replacements
+ * if necessary.  The replacement constants (FP_NAN etc) can be anything but
+ * match Linux constants now.
+ */
+#undef DUK_USE_REPL_FPCLASSIFY
+#undef DUK_USE_REPL_SIGNBIT
+#undef DUK_USE_REPL_ISFINITE
+#undef DUK_USE_REPL_ISNAN
+#undef DUK_USE_REPL_ISINF
+
+/* Complex condition broken into separate parts. */
+#undef DUK_F_USE_REPL_ALL
+#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \
+      defined(FP_SUBNORMAL) && defined(FP_NORMAL))
+/* Missing some obvious constants. */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
+/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue). */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_M68K)
+/* AmigaOS + M68K seems to have math issues even when using GCC cross
+ * compilation.  Use replacements for all AmigaOS versions on M68K
+ * regardless of compiler.
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG)
+/* Placeholder fix for (detection is wider than necessary):
+ * http://llvm.org/bugs/show_bug.cgi?id=17788
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_UCLIBC)
+/* At least some uclibc versions have broken floating point math.  For
+ * example, fpclassify() can incorrectly classify certain NaN formats.
+ * To be safe, use replacements.
+ */
+#define DUK_F_USE_REPL_ALL
+#elif defined(DUK_F_AIX)
+/* Older versions may be missing isnan(), etc. */
+#define DUK_F_USE_REPL_ALL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#define DUK_USE_REPL_FPCLASSIFY
+#define DUK_USE_REPL_SIGNBIT
+#define DUK_USE_REPL_ISFINITE
+#define DUK_USE_REPL_ISNAN
+#define DUK_USE_REPL_ISINF
+#define DUK_FPCLASSIFY       duk_repl_fpclassify
+#define DUK_SIGNBIT          duk_repl_signbit
+#define DUK_ISFINITE         duk_repl_isfinite
+#define DUK_ISNAN            duk_repl_isnan
+#define DUK_ISINF            duk_repl_isinf
+#define DUK_FP_NAN           0
+#define DUK_FP_INFINITE      1
+#define DUK_FP_ZERO          2
+#define DUK_FP_SUBNORMAL     3
+#define DUK_FP_NORMAL        4
+#else
+#define DUK_FPCLASSIFY       fpclassify
+#define DUK_SIGNBIT          signbit
+#define DUK_ISFINITE         isfinite
+#define DUK_ISNAN            isnan
+#define DUK_ISINF            isinf
+#define DUK_FP_NAN           FP_NAN
+#define DUK_FP_INFINITE      FP_INFINITE
+#define DUK_FP_ZERO          FP_ZERO
+#define DUK_FP_SUBNORMAL     FP_SUBNORMAL
+#define DUK_FP_NORMAL        FP_NORMAL
+#endif
+
+#if defined(DUK_F_USE_REPL_ALL)
+#undef DUK_F_USE_REPL_ALL
+#endif
+
+/* These functions don't currently need replacement but are wrapped for
+ * completeness.  Because these are used as function pointers, they need
+ * to be defined as concrete C functions (not macros).
+ */
+#if !defined(DUK_FABS)
+#define DUK_FABS             fabs
+#endif
+#if !defined(DUK_FLOOR)
+#define DUK_FLOOR            floor
+#endif
+#if !defined(DUK_CEIL)
+#define DUK_CEIL             ceil
+#endif
+#if !defined(DUK_FMOD)
+#define DUK_FMOD             fmod
+#endif
+#if !defined(DUK_POW)
+#define DUK_POW              pow
+#endif
+#if !defined(DUK_ACOS)
+#define DUK_ACOS             acos
+#endif
+#if !defined(DUK_ASIN)
+#define DUK_ASIN             asin
+#endif
+#if !defined(DUK_ATAN)
+#define DUK_ATAN             atan
+#endif
+#if !defined(DUK_ATAN2)
+#define DUK_ATAN2            atan2
+#endif
+#if !defined(DUK_SIN)
+#define DUK_SIN              sin
+#endif
+#if !defined(DUK_COS)
+#define DUK_COS              cos
+#endif
+#if !defined(DUK_TAN)
+#define DUK_TAN              tan
+#endif
+#if !defined(DUK_EXP)
+#define DUK_EXP              exp
+#endif
+#if !defined(DUK_LOG)
+#define DUK_LOG              log
+#endif
+#if !defined(DUK_SQRT)
+#define DUK_SQRT             sqrt
+#endif
+
+/* The functions below exist only in C99/C++11 or later and need a workaround
+ * for platforms that don't include them.  MSVC isn't detected as C99, but
+ * these functions also exist in MSVC 2013 and later so include a clause for
+ * that too.  Android doesn't have log2; disable all of these for Android.
+ */
+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11) || (defined(_MSC_VER) && (_MSC_VER >= 1800))) && \
+    !defined(DUK_F_ANDROID) && !defined(DUK_F_MINT)
+#if !defined(DUK_CBRT)
+#define DUK_CBRT             cbrt
+#endif
+#if !defined(DUK_LOG2)
+#define DUK_LOG2             log2
+#endif
+#if !defined(DUK_LOG10)
+#define DUK_LOG10            log10
+#endif
+#if !defined(DUK_TRUNC)
+#define DUK_TRUNC            trunc
+#endif
+#endif  /* DUK_F_C99 etc */
+
+/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics,
+ * see test-bug-netbsd-math-pow.js.  MinGW has similar (but different)
+ * issues, see test-bug-mingw-math-issues.js.  Enable pow() workarounds
+ * for these targets.
+ */
+#undef DUK_USE_POW_WORKAROUNDS
+#if defined(DUK_F_NETBSD) || defined(DUK_F_MINGW)
+#define DUK_USE_POW_WORKAROUNDS
+#endif
+
+/* Similar workarounds for atan2() semantics issues.  MinGW issues are
+ * documented in test-bug-mingw-math-issues.js.
+ */
+#undef DUK_USE_ATAN2_WORKAROUNDS
+#if defined(DUK_F_MINGW)
+#define DUK_USE_ATAN2_WORKAROUNDS
+#endif
+
+/* Rely as little as possible on compiler behavior for NaN comparison,
+ * signed zero handling, etc.  Currently never activated but may be needed
+ * for broken compilers.
+ */
+#undef DUK_USE_PARANOID_MATH
+
+/* There was a curious bug where test-bi-date-canceling.js would fail e.g.
+ * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99.  Some date computations
+ * using doubles would be optimized which then broke some corner case tests.
+ * The problem goes away by adding 'volatile' to the datetime computations.
+ * Not sure what the actual triggering conditions are, but using this on
+ * non-C99 systems solves the known issues and has relatively little cost
+ * on other platforms.
+ */
+#undef DUK_USE_PARANOID_DATE_COMPUTATION
+#if !defined(DUK_F_C99)
+#define DUK_USE_PARANOID_DATE_COMPUTATION
+#endif
+
+/*
+ *  Byte order and double memory layout detection
+ *
+ *  Endianness detection is a major portability hassle because the macros
+ *  and headers are not standardized.  There's even variance across UNIX
+ *  platforms.  Even with "standard" headers, details like underscore count
+ *  varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used
+ *  (Crossbridge has a single underscore, for instance).
+ *
+ *  The checks below are structured with this in mind: several approaches are
+ *  used, and at the end we check if any of them worked.  This allows generic
+ *  approaches to be tried first, and platform/compiler specific hacks tried
+ *  last.  As a last resort, the user can force a specific endianness, as it's
+ *  not likely that automatic detection will work on the most exotic platforms.
+ *
+ *  Duktape supports little and big endian machines.  There's also support
+ *  for a hybrid used by some ARM machines where integers are little endian
+ *  but IEEE double values use a mixed order (12345678 -> 43218765).  This
+ *  byte order for doubles is referred to as "mixed endian".
+ */
+
+/* GCC and Clang provide endianness defines as built-in predefines, with
+ * leading and trailing double underscores (e.g. __BYTE_ORDER__).  See
+ * output of "make gccpredefs" and "make clangpredefs".  Clang doesn't
+ * seem to provide __FLOAT_WORD_ORDER__; assume not mixed endian for clang.
+ * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+ */
+#if !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__)
+#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif  /* float word order */
+#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER__)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif  /* float word order */
+#else
+/* Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit
+ * integer ordering and is not relevant.
+ */
+#endif  /* integer byte order */
+#endif  /* !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) */
+
+/* More or less standard endianness predefines provided by header files.
+ * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER
+ * will be big endian, see: http://lists.mysql.com/internals/443.
+ * On some platforms some defines may be present with an empty value which
+ * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453.
+ */
+#if !defined(DUK_USE_BYTEORDER)
+#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \
+    defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \
+    defined(__LITTLE_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \
+    defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN)
+#define DUK_USE_BYTEORDER 1
+#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+      defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 2
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 1
+#else
+/* Byte order is little endian but cannot determine IEEE double word order. */
+#endif  /* float word order */
+#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \
+      defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \
+      defined(__BIG_ENDIAN__)
+#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
+    defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
+#define DUK_USE_BYTEORDER 3
+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
+/* Float word order not known, assume not a hybrid. */
+#define DUK_USE_BYTEORDER 3
+#else
+/* Byte order is big endian but cannot determine IEEE double word order. */
+#endif  /* float word order */
+#else
+/* Cannot determine byte order. */
+#endif  /* integer byte order */
+#endif  /* !defined(DUK_USE_BYTEORDER) */
+
+/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__:
+ *  $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - > 24) | \
+	 ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \
+	 ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \
+	 (((duk_uint32_t) (x)) << 24))
+#endif
+#if !defined(DUK_BSWAP16)
+#define DUK_BSWAP16(x) \
+	((duk_uint16_t) (x) >> 8) | \
+	((duk_uint16_t) (x) << 8)
+#endif
+
+/* DUK_USE_VARIADIC_MACROS: required from compilers, so no fill-in. */
+/* DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in. */
+
+#if !(defined(DUK_USE_FLEX_C99) || defined(DUK_USE_FLEX_ZEROSIZE) || defined(DUK_USE_FLEX_ONESIZE))
+#if defined(DUK_F_C99)
+#define DUK_USE_FLEX_C99
+#else
+#define DUK_USE_FLEX_ZEROSIZE  /* Not standard but common enough */
+#endif
+#endif
+
+#if !(defined(DUK_USE_PACK_GCC_ATTR) || defined(DUK_USE_PACK_CLANG_ATTR) || \
+      defined(DUK_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_DUMMY_MEMBER))
+#define DUK_USE_PACK_DUMMY_MEMBER
+#endif
+
+#if 0  /* not defined by default */
+#undef DUK_USE_GCC_PRAGMAS
+#endif
+
+#if !defined(DUK_U64_CONSTANT)
+#define DUK_U64_CONSTANT(x) x##ULL
+#endif
+#if !defined(DUK_I64_CONSTANT)
+#define DUK_I64_CONSTANT(x) x##LL
+#endif
+
+/* Workaround for GH-323: avoid inlining control when compiling from
+ * multiple sources, as it causes compiler portability trouble.
+ */
+#if !defined(DUK_SINGLE_FILE)
+#undef DUK_NOINLINE
+#undef DUK_INLINE
+#undef DUK_ALWAYS_INLINE
+#define DUK_NOINLINE       /*nop*/
+#define DUK_INLINE         /*nop*/
+#define DUK_ALWAYS_INLINE  /*nop*/
+#endif
+
+/*
+ *  Check whether or not a packed duk_tval representation is possible.
+ *  What's basically required is that pointers are 32-bit values
+ *  (sizeof(void *) == 4).  Best effort check, not always accurate.
+ *  If guess goes wrong, crashes may result; self tests also verify
+ *  the guess.
+ */
+
+/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */
+#if !defined(DUK_F_PACKED_TVAL_PROVIDED)
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+
+/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED)
+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */
+#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED)
+#if (DUK_SIZE_MAX <= 0xffffffffUL)
+#define DUK_F_PACKED_TVAL_POSSIBLE
+#endif
+#endif
+
+#undef DUK_USE_PACKED_TVAL
+#if defined(DUK_F_PACKED_TVAL_POSSIBLE)
+#define DUK_USE_PACKED_TVAL
+#endif
+
+#undef DUK_F_PACKED_TVAL_POSSIBLE
+#endif  /* DUK_F_PACKED_TVAL_PROVIDED */
+/* Object property allocation layout has implications for memory and code
+ * footprint and generated code size/speed.  The best layout also depends
+ * on whether the platform has alignment requirements or benefits from
+ * having mostly aligned accesses.
+ */
+#undef DUK_USE_HOBJECT_LAYOUT_1
+#undef DUK_USE_HOBJECT_LAYOUT_2
+#undef DUK_USE_HOBJECT_LAYOUT_3
+#if (DUK_USE_ALIGN_BY == 1)
+/* On platforms without any alignment issues, layout 1 is preferable
+ * because it compiles to slightly less code and provides direct access
+ * to property keys.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_1
+#else
+/* On other platforms use layout 2, which requires some padding but
+ * is a bit more natural than layout 3 in ordering the entries.  Layout
+ * 3 is currently not used.
+ */
+#define DUK_USE_HOBJECT_LAYOUT_2
+#endif
+
+/* GCC/clang inaccurate math would break compliance and probably duk_tval,
+ * so refuse to compile.  Relax this if -ffast-math is tested to work.
+ */
+#if defined(__FAST_MATH__)
+#error __FAST_MATH__ defined, refusing to compile
+#endif
+
+/*
+ *  Autogenerated defaults
+ */
+
+#define DUK_USE_ARRAY_BUILTIN
+#define DUK_USE_ARRAY_FASTPATH
+#define DUK_USE_ARRAY_PROP_FASTPATH
+#undef DUK_USE_ASSERTIONS
+#define DUK_USE_AUGMENT_ERROR_CREATE
+#define DUK_USE_AUGMENT_ERROR_THROW
+#define DUK_USE_AVOID_PLATFORM_FUNCPTRS
+#define DUK_USE_BASE64_FASTPATH
+#define DUK_USE_BOOLEAN_BUILTIN
+#define DUK_USE_BUFFEROBJECT_SUPPORT
+#undef DUK_USE_BUFLEN16
+#define DUK_USE_BYTECODE_DUMP_SUPPORT
+#define DUK_USE_CACHE_ACTIVATION
+#define DUK_USE_CACHE_CATCHER
+#define DUK_USE_CALLSTACK_LIMIT 10000
+#define DUK_USE_COMMONJS_MODULES
+#define DUK_USE_COMPILER_RECLIMIT 2500
+#define DUK_USE_COROUTINE_SUPPORT
+#undef DUK_USE_CPP_EXCEPTIONS
+#undef DUK_USE_DATAPTR16
+#undef DUK_USE_DATAPTR_DEC16
+#undef DUK_USE_DATAPTR_ENC16
+#define DUK_USE_DATE_BUILTIN
+#undef DUK_USE_DATE_FORMAT_STRING
+#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET
+#undef DUK_USE_DATE_GET_NOW
+#undef DUK_USE_DATE_PARSE_STRING
+#undef DUK_USE_DATE_PRS_GETDATE
+#undef DUK_USE_DEBUG
+#undef DUK_USE_DEBUGGER_DUMPHEAP
+#undef DUK_USE_DEBUGGER_INSPECT
+#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT
+#undef DUK_USE_DEBUGGER_SUPPORT
+#define DUK_USE_DEBUGGER_THROW_NOTIFY
+#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE
+#define DUK_USE_DEBUG_BUFSIZE 65536L
+#define DUK_USE_DEBUG_LEVEL 0
+#undef DUK_USE_DEBUG_WRITE
+#define DUK_USE_DOUBLE_LINKED_HEAP
+#define DUK_USE_DUKTAPE_BUILTIN
+#define DUK_USE_ENCODING_BUILTINS
+#define DUK_USE_ERRCREATE
+#define DUK_USE_ERRTHROW
+#define DUK_USE_ES6
+#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY
+#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF
+#define DUK_USE_ES6_PROXY
+#define DUK_USE_ES6_REGEXP_SYNTAX
+#define DUK_USE_ES6_UNICODE_ESCAPE
+#define DUK_USE_ES7
+#define DUK_USE_ES7_EXP_OPERATOR
+#define DUK_USE_ES8
+#define DUK_USE_ES9
+#define DUK_USE_ESBC_LIMITS
+#define DUK_USE_ESBC_MAX_BYTES 2147418112L
+#define DUK_USE_ESBC_MAX_LINENUMBER 2147418112L
+#undef DUK_USE_EXEC_FUN_LOCAL
+#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK
+#undef DUK_USE_EXEC_PREFER_SIZE
+#define DUK_USE_EXEC_REGCONST_OPTIMIZE
+#undef DUK_USE_EXEC_TIMEOUT_CHECK
+#undef DUK_USE_EXPLICIT_NULL_INIT
+#undef DUK_USE_EXTSTR_FREE
+#undef DUK_USE_EXTSTR_INTERN_CHECK
+#undef DUK_USE_FASTINT
+#define DUK_USE_FAST_REFCOUNT_DEFAULT
+#undef DUK_USE_FATAL_HANDLER
+#define DUK_USE_FATAL_MAXLEN 128
+#define DUK_USE_FINALIZER_SUPPORT
+#undef DUK_USE_FINALIZER_TORTURE
+#undef DUK_USE_FUNCPTR16
+#undef DUK_USE_FUNCPTR_DEC16
+#undef DUK_USE_FUNCPTR_ENC16
+#define DUK_USE_FUNCTION_BUILTIN
+#define DUK_USE_FUNC_FILENAME_PROPERTY
+#define DUK_USE_FUNC_NAME_PROPERTY
+#undef DUK_USE_GC_TORTURE
+#undef DUK_USE_GET_MONOTONIC_TIME
+#undef DUK_USE_GET_RANDOM_DOUBLE
+#undef DUK_USE_GLOBAL_BINDING
+#define DUK_USE_GLOBAL_BUILTIN
+#undef DUK_USE_HEAPPTR16
+#undef DUK_USE_HEAPPTR_DEC16
+#undef DUK_USE_HEAPPTR_ENC16
+#define DUK_USE_HEX_FASTPATH
+#define DUK_USE_HOBJECT_ARRAY_ABANDON_LIMIT 2
+#define DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT 9
+#define DUK_USE_HOBJECT_ARRAY_MINGROW_ADD 16
+#define DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR 8
+#define DUK_USE_HOBJECT_ENTRY_MINGROW_ADD 16
+#define DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR 8
+#define DUK_USE_HOBJECT_HASH_PART
+#define DUK_USE_HOBJECT_HASH_PROP_LIMIT 8
+#define DUK_USE_HSTRING_ARRIDX
+#define DUK_USE_HSTRING_CLEN
+#undef DUK_USE_HSTRING_EXTDATA
+#define DUK_USE_HSTRING_LAZY_CLEN
+#define DUK_USE_HTML_COMMENTS
+#define DUK_USE_IDCHAR_FASTPATH
+#undef DUK_USE_INJECT_HEAP_ALLOC_ERROR
+#undef DUK_USE_INTERRUPT_COUNTER
+#undef DUK_USE_INTERRUPT_DEBUG_FIXUP
+#define DUK_USE_JC
+#define DUK_USE_JSON_BUILTIN
+#define DUK_USE_JSON_DECNUMBER_FASTPATH
+#define DUK_USE_JSON_DECSTRING_FASTPATH
+#define DUK_USE_JSON_DEC_RECLIMIT 1000
+#define DUK_USE_JSON_EATWHITE_FASTPATH
+#define DUK_USE_JSON_ENC_RECLIMIT 1000
+#define DUK_USE_JSON_QUOTESTRING_FASTPATH
+#undef DUK_USE_JSON_STRINGIFY_FASTPATH
+#define DUK_USE_JSON_SUPPORT
+#define DUK_USE_JX
+#define DUK_USE_LEXER_SLIDING_WINDOW
+#undef DUK_USE_LIGHTFUNC_BUILTINS
+#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256
+#define DUK_USE_MATH_BUILTIN
+#define DUK_USE_NATIVE_CALL_RECLIMIT 1000
+#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
+#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER
+#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
+#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
+#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY
+#define DUK_USE_NONSTD_FUNC_STMT
+#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029
+#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
+#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT
+#define DUK_USE_NUMBER_BUILTIN
+#define DUK_USE_OBJECT_BUILTIN
+#undef DUK_USE_OBJSIZES16
+#undef DUK_USE_PARANOID_ERRORS
+#define DUK_USE_PC2LINE
+#define DUK_USE_PERFORMANCE_BUILTIN
+#undef DUK_USE_PREFER_SIZE
+#undef DUK_USE_PROMISE_BUILTIN
+#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS
+#undef DUK_USE_REFCOUNT16
+#define DUK_USE_REFCOUNT32
+#define DUK_USE_REFERENCE_COUNTING
+#define DUK_USE_REFLECT_BUILTIN
+#define DUK_USE_REGEXP_CANON_BITMAP
+#undef DUK_USE_REGEXP_CANON_WORKAROUND
+#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000
+#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000
+#define DUK_USE_REGEXP_SUPPORT
+#undef DUK_USE_ROM_GLOBAL_CLONE
+#undef DUK_USE_ROM_GLOBAL_INHERIT
+#undef DUK_USE_ROM_OBJECTS
+#define DUK_USE_ROM_PTRCOMP_FIRST 63488L
+#undef DUK_USE_ROM_STRINGS
+#define DUK_USE_SECTION_B
+#undef DUK_USE_SELF_TESTS
+#define DUK_USE_SHEBANG_COMMENTS
+#undef DUK_USE_SHUFFLE_TORTURE
+#define DUK_USE_SOURCE_NONBMP
+#undef DUK_USE_STRHASH16
+#undef DUK_USE_STRHASH_DENSE
+#define DUK_USE_STRHASH_SKIP_SHIFT 5
+#define DUK_USE_STRICT_DECL
+#undef DUK_USE_STRICT_UTF8_SOURCE
+#define DUK_USE_STRING_BUILTIN
+#undef DUK_USE_STRLEN16
+#define DUK_USE_STRTAB_GROW_LIMIT 17
+#define DUK_USE_STRTAB_MAXSIZE 268435456L
+#define DUK_USE_STRTAB_MINSIZE 1024
+#undef DUK_USE_STRTAB_PTRCOMP
+#define DUK_USE_STRTAB_RESIZE_CHECK_MASK 255
+#define DUK_USE_STRTAB_SHRINK_LIMIT 6
+#undef DUK_USE_STRTAB_TORTURE
+#undef DUK_USE_SYMBOL_BUILTIN
+#define DUK_USE_TAILCALL
+#define DUK_USE_TARGET_INFO "unknown"
+#define DUK_USE_TRACEBACKS
+#define DUK_USE_TRACEBACK_DEPTH 10
+#define DUK_USE_USER_DECLARE() /* no user declarations */
+#define DUK_USE_VALSTACK_GROW_SHIFT 2
+#define DUK_USE_VALSTACK_LIMIT 1000000L
+#define DUK_USE_VALSTACK_SHRINK_CHECK_SHIFT 2
+#define DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT 4
+#undef DUK_USE_VALSTACK_UNSAFE
+#define DUK_USE_VERBOSE_ERRORS
+#define DUK_USE_VERBOSE_EXECUTOR_ERRORS
+#define DUK_USE_VOLUNTARY_GC
+#define DUK_USE_ZERO_BUFFER_DATA
+
+/*
+ *  You may add overriding #define/#undef directives below for
+ *  customization.  You of course cannot un-#include or un-typedef
+ *  anything; these require direct changes above.
+ */
+
+/* __OVERRIDE_DEFINES__ */
+
+/*
+ *  Date provider selection
+ *
+ *  User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll
+ *  rely on an external provider.  If this is not done, revert to previous
+ *  behavior and use Unix/Windows built-in provider.
+ */
+
+#if defined(DUK_COMPILING_DUKTAPE)
+
+#if defined(DUK_USE_DATE_GET_NOW)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY)
+#define DUK_USE_DATE_GET_NOW(ctx)            duk_bi_date_get_now_gettimeofday()
+#elif defined(DUK_USE_DATE_NOW_TIME)
+#define DUK_USE_DATE_GET_NOW(ctx)            duk_bi_date_get_now_time()
+#elif defined(DUK_USE_DATE_NOW_WINDOWS)
+#define DUK_USE_DATE_GET_NOW(ctx)            duk_bi_date_get_now_windows()
+#elif defined(DUK_USE_DATE_NOW_WINDOWS_SUBMS)
+#define DUK_USE_DATE_GET_NOW(ctx)            duk_bi_date_get_now_windows_subms()
+#else
+#error no provider for DUK_USE_DATE_GET_NOW()
+#endif
+
+#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME_S) || defined(DUK_USE_DATE_TZO_GMTIME)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d)   duk_bi_date_get_local_tzoffset_gmtime((d))
+#elif defined(DUK_USE_DATE_TZO_WINDOWS)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d)   duk_bi_date_get_local_tzoffset_windows((d))
+#elif defined(DUK_USE_DATE_TZO_WINDOWS_NO_DST)
+#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d)   duk_bi_date_get_local_tzoffset_windows_no_dst((d))
+#else
+#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET()
+#endif
+
+#if defined(DUK_USE_DATE_PARSE_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_PRS_STRPTIME)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str)   duk_bi_date_parse_string_strptime((ctx), (str))
+#elif defined(DUK_USE_DATE_PRS_GETDATE)
+#define DUK_USE_DATE_PARSE_STRING(ctx,str)   duk_bi_date_parse_string_getdate((ctx), (str))
+#else
+/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#if defined(DUK_USE_DATE_FORMAT_STRING)
+/* External provider already defined. */
+#elif defined(DUK_USE_DATE_FMT_STRFTIME)
+#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \
+	duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags))
+#else
+/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */
+#endif
+
+#if defined(DUK_USE_GET_MONOTONIC_TIME)
+/* External provider already defined. */
+#elif defined(DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME)
+#define DUK_USE_GET_MONOTONIC_TIME(ctx)  duk_bi_date_get_monotonic_time_clock_gettime()
+#elif defined(DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC)
+#define DUK_USE_GET_MONOTONIC_TIME(ctx)  duk_bi_date_get_monotonic_time_windows_qpc()
+#else
+/* No provider for DUK_USE_GET_MONOTONIC_TIME(), fall back to DUK_USE_DATE_GET_NOW(). */
+#endif
+
+#endif  /* DUK_COMPILING_DUKTAPE */
+
+/*
+ *  Checks for legacy feature options (DUK_OPT_xxx)
+ */
+
+#if defined(DUK_OPT_ASSERTIONS)
+#error unsupported legacy feature option DUK_OPT_ASSERTIONS used
+#endif
+#if defined(DUK_OPT_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_BUFLEN16)
+#error unsupported legacy feature option DUK_OPT_BUFLEN16 used
+#endif
+#if defined(DUK_OPT_DATAPTR16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_DATAPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_DATAPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_DDDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDDPRINT used
+#endif
+#if defined(DUK_OPT_DDPRINT)
+#error unsupported legacy feature option DUK_OPT_DDPRINT used
+#endif
+#if defined(DUK_OPT_DEBUG)
+#error unsupported legacy feature option DUK_OPT_DEBUG used
+#endif
+#if defined(DUK_OPT_DEBUGGER_DUMPHEAP)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_DUMPHEAP used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_LOGGING)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_LOGGING used
+#endif
+#if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_PRINTALERT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_SUPPORT used
+#endif
+#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE)
+#error unsupported legacy feature option DUK_OPT_DEBUGGER_TRANSPORT_TORTURE used
+#endif
+#if defined(DUK_OPT_DEBUG_BUFSIZE)
+#error unsupported legacy feature option DUK_OPT_DEBUG_BUFSIZE used
+#endif
+#if defined(DUK_OPT_DECLARE)
+#error unsupported legacy feature option DUK_OPT_DECLARE used
+#endif
+#if defined(DUK_OPT_DEEP_C_STACK)
+#error unsupported legacy feature option DUK_OPT_DEEP_C_STACK used
+#endif
+#if defined(DUK_OPT_DLL_BUILD)
+#error unsupported legacy feature option DUK_OPT_DLL_BUILD used
+#endif
+#if defined(DUK_OPT_DPRINT)
+#error unsupported legacy feature option DUK_OPT_DPRINT used
+#endif
+#if defined(DUK_OPT_DPRINT_COLORS)
+#error unsupported legacy feature option DUK_OPT_DPRINT_COLORS used
+#endif
+#if defined(DUK_OPT_DPRINT_RDTSC)
+#error unsupported legacy feature option DUK_OPT_DPRINT_RDTSC used
+#endif
+#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXEC_TIMEOUT_CHECK used
+#endif
+#if defined(DUK_OPT_EXTERNAL_STRINGS)
+#error unsupported legacy feature option DUK_OPT_EXTERNAL_STRINGS used
+#endif
+#if defined(DUK_OPT_EXTSTR_FREE)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_FREE used
+#endif
+#if defined(DUK_OPT_EXTSTR_INTERN_CHECK)
+#error unsupported legacy feature option DUK_OPT_EXTSTR_INTERN_CHECK used
+#endif
+#if defined(DUK_OPT_FASTINT)
+#error unsupported legacy feature option DUK_OPT_FASTINT used
+#endif
+#if defined(DUK_OPT_FORCE_ALIGN)
+#error unsupported legacy feature option DUK_OPT_FORCE_ALIGN used
+#endif
+#if defined(DUK_OPT_FORCE_BYTEORDER)
+#error unsupported legacy feature option DUK_OPT_FORCE_BYTEORDER used
+#endif
+#if defined(DUK_OPT_FUNCPTR16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_FUNCPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_FUNCPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_GC_TORTURE)
+#error unsupported legacy feature option DUK_OPT_GC_TORTURE used
+#endif
+#if defined(DUK_OPT_HAVE_CUSTOM_H)
+#error unsupported legacy feature option DUK_OPT_HAVE_CUSTOM_H used
+#endif
+#if defined(DUK_OPT_HEAPPTR16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_DEC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_DEC16 used
+#endif
+#if defined(DUK_OPT_HEAPPTR_ENC16)
+#error unsupported legacy feature option DUK_OPT_HEAPPTR_ENC16 used
+#endif
+#if defined(DUK_OPT_INTERRUPT_COUNTER)
+#error unsupported legacy feature option DUK_OPT_INTERRUPT_COUNTER used
+#endif
+#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH)
+#error unsupported legacy feature option DUK_OPT_JSON_STRINGIFY_FASTPATH used
+#endif
+#if defined(DUK_OPT_LIGHTFUNC_BUILTINS)
+#error unsupported legacy feature option DUK_OPT_LIGHTFUNC_BUILTINS used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY used
+#endif
+#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_AUGMENT_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_AUGMENT_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_BROWSER_LIKE)
+#error unsupported legacy feature option DUK_OPT_NO_BROWSER_LIKE used
+#endif
+#if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BUFFEROBJECT_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_BYTECODE_DUMP_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_COMMONJS_MODULES)
+#error unsupported legacy feature option DUK_OPT_NO_COMMONJS_MODULES used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_ES6_PROXY)
+#error unsupported legacy feature option DUK_OPT_NO_ES6_PROXY used
+#endif
+#if defined(DUK_OPT_NO_FILE_IO)
+#error unsupported legacy feature option DUK_OPT_NO_FILE_IO used
+#endif
+#if defined(DUK_OPT_NO_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_JC)
+#error unsupported legacy feature option DUK_OPT_NO_JC used
+#endif
+#if defined(DUK_OPT_NO_JSONC)
+#error unsupported legacy feature option DUK_OPT_NO_JSONC used
+#endif
+#if defined(DUK_OPT_NO_JSONX)
+#error unsupported legacy feature option DUK_OPT_NO_JSONX used
+#endif
+#if defined(DUK_OPT_NO_JX)
+#error unsupported legacy feature option DUK_OPT_NO_JX used
+#endif
+#if defined(DUK_OPT_NO_MARK_AND_SWEEP)
+#error unsupported legacy feature option DUK_OPT_NO_MARK_AND_SWEEP used
+#endif
+#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE)
+#error unsupported legacy feature option DUK_OPT_NO_MS_STRINGTABLE_RESIZE used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_FUNC_STMT used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 used
+#endif
+#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT)
+#error unsupported legacy feature option DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY used
+#endif
+#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF)
+#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF used
+#endif
+#if defined(DUK_OPT_NO_OCTAL_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_OCTAL_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_PACKED_TVAL)
+#error unsupported legacy feature option DUK_OPT_NO_PACKED_TVAL used
+#endif
+#if defined(DUK_OPT_NO_PC2LINE)
+#error unsupported legacy feature option DUK_OPT_NO_PC2LINE used
+#endif
+#if defined(DUK_OPT_NO_REFERENCE_COUNTING)
+#error unsupported legacy feature option DUK_OPT_NO_REFERENCE_COUNTING used
+#endif
+#if defined(DUK_OPT_NO_REGEXP_SUPPORT)
+#error unsupported legacy feature option DUK_OPT_NO_REGEXP_SUPPORT used
+#endif
+#if defined(DUK_OPT_NO_SECTION_B)
+#error unsupported legacy feature option DUK_OPT_NO_SECTION_B used
+#endif
+#if defined(DUK_OPT_NO_SOURCE_NONBMP)
+#error unsupported legacy feature option DUK_OPT_NO_SOURCE_NONBMP used
+#endif
+#if defined(DUK_OPT_NO_STRICT_DECL)
+#error unsupported legacy feature option DUK_OPT_NO_STRICT_DECL used
+#endif
+#if defined(DUK_OPT_NO_TRACEBACKS)
+#error unsupported legacy feature option DUK_OPT_NO_TRACEBACKS used
+#endif
+#if defined(DUK_OPT_NO_VERBOSE_ERRORS)
+#error unsupported legacy feature option DUK_OPT_NO_VERBOSE_ERRORS used
+#endif
+#if defined(DUK_OPT_NO_VOLUNTARY_GC)
+#error unsupported legacy feature option DUK_OPT_NO_VOLUNTARY_GC used
+#endif
+#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA)
+#error unsupported legacy feature option DUK_OPT_NO_ZERO_BUFFER_DATA used
+#endif
+#if defined(DUK_OPT_OBJSIZES16)
+#error unsupported legacy feature option DUK_OPT_OBJSIZES16 used
+#endif
+#if defined(DUK_OPT_PANIC_HANDLER)
+#error unsupported legacy feature option DUK_OPT_PANIC_HANDLER used
+#endif
+#if defined(DUK_OPT_REFCOUNT16)
+#error unsupported legacy feature option DUK_OPT_REFCOUNT16 used
+#endif
+#if defined(DUK_OPT_SEGFAULT_ON_PANIC)
+#error unsupported legacy feature option DUK_OPT_SEGFAULT_ON_PANIC used
+#endif
+#if defined(DUK_OPT_SELF_TESTS)
+#error unsupported legacy feature option DUK_OPT_SELF_TESTS used
+#endif
+#if defined(DUK_OPT_SETJMP)
+#error unsupported legacy feature option DUK_OPT_SETJMP used
+#endif
+#if defined(DUK_OPT_SHUFFLE_TORTURE)
+#error unsupported legacy feature option DUK_OPT_SHUFFLE_TORTURE used
+#endif
+#if defined(DUK_OPT_SIGSETJMP)
+#error unsupported legacy feature option DUK_OPT_SIGSETJMP used
+#endif
+#if defined(DUK_OPT_STRHASH16)
+#error unsupported legacy feature option DUK_OPT_STRHASH16 used
+#endif
+#if defined(DUK_OPT_STRICT_UTF8_SOURCE)
+#error unsupported legacy feature option DUK_OPT_STRICT_UTF8_SOURCE used
+#endif
+#if defined(DUK_OPT_STRLEN16)
+#error unsupported legacy feature option DUK_OPT_STRLEN16 used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN used
+#endif
+#if defined(DUK_OPT_STRTAB_CHAIN_SIZE)
+#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN_SIZE used
+#endif
+#if defined(DUK_OPT_TARGET_INFO)
+#error unsupported legacy feature option DUK_OPT_TARGET_INFO used
+#endif
+#if defined(DUK_OPT_TRACEBACK_DEPTH)
+#error unsupported legacy feature option DUK_OPT_TRACEBACK_DEPTH used
+#endif
+#if defined(DUK_OPT_UNDERSCORE_SETJMP)
+#error unsupported legacy feature option DUK_OPT_UNDERSCORE_SETJMP used
+#endif
+#if defined(DUK_OPT_USER_INITJS)
+#error unsupported legacy feature option DUK_OPT_USER_INITJS used
+#endif
+
+/*
+ *  Checks for config option consistency (DUK_USE_xxx)
+ */
+
+#if defined(DUK_USE_32BIT_PTRS)
+#error unsupported config option used (option has been removed): DUK_USE_32BIT_PTRS
+#endif
+#if defined(DUK_USE_ALIGN_4)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_4
+#endif
+#if defined(DUK_USE_ALIGN_8)
+#error unsupported config option used (option has been removed): DUK_USE_ALIGN_8
+#endif
+#if defined(DUK_USE_BROWSER_LIKE)
+#error unsupported config option used (option has been removed): DUK_USE_BROWSER_LIKE
+#endif
+#if defined(DUK_USE_BUILTIN_INITJS)
+#error unsupported config option used (option has been removed): DUK_USE_BUILTIN_INITJS
+#endif
+#if defined(DUK_USE_BYTEORDER_FORCED)
+#error unsupported config option used (option has been removed): DUK_USE_BYTEORDER_FORCED
+#endif
+#if defined(DUK_USE_DATAPTR_DEC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_DEC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DATAPTR_ENC16) && !defined(DUK_USE_DATAPTR16)
+#error config option DUK_USE_DATAPTR_ENC16 requires option DUK_USE_DATAPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_DDDPRINT)
+#error unsupported config option used (option has been removed): DUK_USE_DDDPRINT
+#endif
+#if defined(DUK_USE_DDPRINT)
+#error unsupported config option used (option has been removed): DUK_USE_DDPRINT
+#endif
+#if defined(DUK_USE_DEBUGGER_FWD_LOGGING)
+#error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_LOGGING
+#endif
+#if defined(DUK_USE_DEBUGGER_FWD_PRINTALERT)
+#error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_PRINTALERT
+#endif
+#if defined(DUK_USE_DEBUGGER_SUPPORT) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_DEBUGGER_SUPPORT requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_DEEP_C_STACK)
+#error unsupported config option used (option has been removed): DUK_USE_DEEP_C_STACK
+#endif
+#if defined(DUK_USE_DOUBLE_BE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_BE
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_LE
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_ME)
+#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_ME (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME)
+#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_ME
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_LE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_LE (which is also defined)
+#endif
+#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_BE)
+#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_BE (which is also defined)
+#endif
+#if defined(DUK_USE_DPRINT)
+#error unsupported config option used (option has been removed): DUK_USE_DPRINT
+#endif
+#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG)
+#error config option DUK_USE_DPRINT requires option DUK_USE_DEBUG (which is missing)
+#endif
+#if defined(DUK_USE_DPRINT_COLORS)
+#error unsupported config option used (option has been removed): DUK_USE_DPRINT_COLORS
+#endif
+#if defined(DUK_USE_DPRINT_RDTSC)
+#error unsupported config option used (option has been removed): DUK_USE_DPRINT_RDTSC
+#endif
+#if defined(DUK_USE_ES6_REGEXP_BRACES)
+#error unsupported config option used (option has been removed): DUK_USE_ES6_REGEXP_BRACES
+#endif
+#if defined(DUK_USE_ESBC_MAX_BYTES) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_BYTES requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_ESBC_MAX_LINENUMBER) && !defined(DUK_USE_ESBC_LIMITS)
+#error config option DUK_USE_ESBC_MAX_LINENUMBER requires option DUK_USE_ESBC_LIMITS (which is missing)
+#endif
+#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) && !defined(DUK_USE_INTERRUPT_COUNTER)
+#error config option DUK_USE_EXEC_TIMEOUT_CHECK requires option DUK_USE_INTERRUPT_COUNTER (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_FREE) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_FREE requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_EXTSTR_INTERN_CHECK) && !defined(DUK_USE_HSTRING_EXTDATA)
+#error config option DUK_USE_EXTSTR_INTERN_CHECK requires option DUK_USE_HSTRING_EXTDATA (which is missing)
+#endif
+#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_64BIT_OPS)
+#error config option DUK_USE_FASTINT requires option DUK_USE_64BIT_OPS (which is missing)
+#endif
+#if defined(DUK_USE_FILE_IO)
+#error unsupported config option used (option has been removed): DUK_USE_FILE_IO
+#endif
+#if defined(DUK_USE_FULL_TVAL)
+#error unsupported config option used (option has been removed): DUK_USE_FULL_TVAL
+#endif
+#if defined(DUK_USE_FUNCPTR_DEC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_DEC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_FUNCPTR_ENC16) && !defined(DUK_USE_FUNCPTR16)
+#error config option DUK_USE_FUNCPTR_ENC16 requires option DUK_USE_FUNCPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS)
+#error unsupported config option used (option has been removed): DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
+#endif
+#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG)
+#error config option DUK_USE_HEAPPTR16 conflicts with option DUK_USE_DEBUG (which is also defined)
+#endif
+#if defined(DUK_USE_HEAPPTR_DEC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_DEC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_HEAPPTR_ENC16) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_HEAPPTR_ENC16 requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_INTEGER_BE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_BE
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_LE
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_ME)
+#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_ME (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME)
+#error unsupported config option used (option has been removed): DUK_USE_INTEGER_ME
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_LE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_LE (which is also defined)
+#endif
+#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_BE)
+#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_BE (which is also defined)
+#endif
+#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE)
+#error unsupported config option used (option has been removed): DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE
+#endif
+#if defined(DUK_USE_MARK_AND_SWEEP)
+#error unsupported config option used (option has been removed): DUK_USE_MARK_AND_SWEEP
+#endif
+#if defined(DUK_USE_MATH_FMAX)
+#error unsupported config option used (option has been removed): DUK_USE_MATH_FMAX
+#endif
+#if defined(DUK_USE_MATH_FMIN)
+#error unsupported config option used (option has been removed): DUK_USE_MATH_FMIN
+#endif
+#if defined(DUK_USE_MATH_ROUND)
+#error unsupported config option used (option has been removed): DUK_USE_MATH_ROUND
+#endif
+#if defined(DUK_USE_MS_STRINGTABLE_RESIZE)
+#error unsupported config option used (option has been removed): DUK_USE_MS_STRINGTABLE_RESIZE
+#endif
+#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE)
+#error unsupported config option used (option has been removed): DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE
+#endif
+#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST)
+#error unsupported config option used (option has been removed): DUK_USE_NO_DOUBLE_ALIASING_SELFTEST
+#endif
+#if defined(DUK_USE_OCTAL_SUPPORT)
+#error unsupported config option used (option has been removed): DUK_USE_OCTAL_SUPPORT
+#endif
+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_PACKED_TVAL_POSSIBLE
+#endif
+#if defined(DUK_USE_PANIC_ABORT)
+#error unsupported config option used (option has been removed): DUK_USE_PANIC_ABORT
+#endif
+#if defined(DUK_USE_PANIC_EXIT)
+#error unsupported config option used (option has been removed): DUK_USE_PANIC_EXIT
+#endif
+#if defined(DUK_USE_PANIC_HANDLER)
+#error unsupported config option used (option has been removed): DUK_USE_PANIC_HANDLER
+#endif
+#if defined(DUK_USE_PANIC_SEGFAULT)
+#error unsupported config option used (option has been removed): DUK_USE_PANIC_SEGFAULT
+#endif
+#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
+#error unsupported config option used (option has been removed): DUK_USE_POW_NETBSD_WORKAROUND
+#endif
+#if defined(DUK_USE_RDTSC)
+#error unsupported config option used (option has been removed): DUK_USE_RDTSC
+#endif
+#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE)
+#error unsupported config option used (option has been removed): DUK_USE_REFZERO_FINALIZER_TORTURE
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_CLONE) && defined(DUK_USE_ROM_GLOBAL_INHERIT)
+#error config option DUK_USE_ROM_GLOBAL_CLONE conflicts with option DUK_USE_ROM_GLOBAL_INHERIT (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && defined(DUK_USE_ROM_GLOBAL_CLONE)
+#error config option DUK_USE_ROM_GLOBAL_INHERIT conflicts with option DUK_USE_ROM_GLOBAL_CLONE (which is also defined)
+#endif
+#if defined(DUK_USE_ROM_OBJECTS) && !defined(DUK_USE_ROM_STRINGS)
+#error config option DUK_USE_ROM_OBJECTS requires option DUK_USE_ROM_STRINGS (which is missing)
+#endif
+#if defined(DUK_USE_ROM_STRINGS) && !defined(DUK_USE_ROM_OBJECTS)
+#error config option DUK_USE_ROM_STRINGS requires option DUK_USE_ROM_OBJECTS (which is missing)
+#endif
+#if defined(DUK_USE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SETJMP
+#endif
+#if defined(DUK_USE_SIGSETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_SIGSETJMP
+#endif
+#if defined(DUK_USE_STRTAB_CHAIN)
+#error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN
+#endif
+#if defined(DUK_USE_STRTAB_CHAIN_SIZE)
+#error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN_SIZE
+#endif
+#if defined(DUK_USE_STRTAB_CHAIN_SIZE) && !defined(DUK_USE_STRTAB_CHAIN)
+#error config option DUK_USE_STRTAB_CHAIN_SIZE requires option DUK_USE_STRTAB_CHAIN (which is missing)
+#endif
+#if defined(DUK_USE_STRTAB_PROBE)
+#error unsupported config option used (option has been removed): DUK_USE_STRTAB_PROBE
+#endif
+#if defined(DUK_USE_STRTAB_PTRCOMP) && !defined(DUK_USE_HEAPPTR16)
+#error config option DUK_USE_STRTAB_PTRCOMP requires option DUK_USE_HEAPPTR16 (which is missing)
+#endif
+#if defined(DUK_USE_TAILCALL) && defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
+#error config option DUK_USE_TAILCALL conflicts with option DUK_USE_NONSTD_FUNC_CALLER_PROPERTY (which is also defined)
+#endif
+#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE)
+#error unsupported config option used (option has been removed): DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
+#endif
+#if defined(DUK_USE_UNDERSCORE_SETJMP)
+#error unsupported config option used (option has been removed): DUK_USE_UNDERSCORE_SETJMP
+#endif
+#if defined(DUK_USE_USER_INITJS)
+#error unsupported config option used (option has been removed): DUK_USE_USER_INITJS
+#endif
+
+#if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus)
+#error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler
+#endif
+
+/*
+ *  Convert DUK_USE_BYTEORDER, from whatever source, into currently used
+ *  internal defines.  If detection failed, #error out.
+ */
+
+#if defined(DUK_USE_BYTEORDER)
+#if (DUK_USE_BYTEORDER == 1)
+#define DUK_USE_INTEGER_LE
+#define DUK_USE_DOUBLE_LE
+#elif (DUK_USE_BYTEORDER == 2)
+#define DUK_USE_INTEGER_LE  /* integer endianness is little on purpose */
+#define DUK_USE_DOUBLE_ME
+#elif (DUK_USE_BYTEORDER == 3)
+#define DUK_USE_INTEGER_BE
+#define DUK_USE_DOUBLE_BE
+#else
+#error unsupported: byte order invalid
+#endif  /* byte order */
+#else
+#error unsupported: byte order detection failed
+#endif  /* defined(DUK_USE_BYTEORDER) */
+
+#endif  /* DUK_CONFIG_H_INCLUDED */
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c
new file mode 100755
index 0000000000..9a29903cfb
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c
@@ -0,0 +1,163 @@
+/*
+ *  Minimal 'console' binding.
+ *
+ *  https://github.com/DeveloperToolsWG/console-object/blob/master/api.md
+ *  https://developers.google.com/web/tools/chrome-devtools/debug/console/console-reference
+ *  https://developer.mozilla.org/en/docs/Web/API/console
+ */
+
+#include 
+#include 
+#include "duktape.h"
+#include "duk_console.h"
+
+/* XXX: Add some form of log level filtering. */
+
+/* XXX: For now logs everything to stdout, V8/Node.js logs debug/info level
+ * to stdout, warn and above to stderr.  Should this extra do the same?
+ */
+
+/* XXX: Should all output be written via e.g. console.write(formattedMsg)?
+ * This would make it easier for user code to redirect all console output
+ * to a custom backend.
+ */
+
+/* XXX: Init console object using duk_def_prop() when that call is available. */
+
+static duk_ret_t duk__console_log_helper(duk_context *ctx, const char *error_name) {
+	duk_idx_t i, n;
+	duk_uint_t flags;
+
+	flags = (duk_uint_t) duk_get_current_magic(ctx);
+
+	n = duk_get_top(ctx);
+
+	duk_get_global_string(ctx, "console");
+	duk_get_prop_string(ctx, -1, "format");
+
+	for (i = 0; i < n; i++) {
+		if (duk_check_type_mask(ctx, i, DUK_TYPE_MASK_OBJECT)) {
+			/* Slow path formatting. */
+			duk_dup(ctx, -1);  /* console.format */
+			duk_dup(ctx, i);
+			duk_call(ctx, 1);
+			duk_replace(ctx, i);  /* arg[i] = console.format(arg[i]); */
+		}
+	}
+
+	duk_pop_2(ctx);
+
+	duk_push_string(ctx, " ");
+	duk_insert(ctx, 0);
+	duk_join(ctx, n);
+
+	if (error_name) {
+		duk_push_error_object(ctx, DUK_ERR_ERROR, "%s", duk_require_string(ctx, -1));
+		duk_push_string(ctx, "name");
+		duk_push_string(ctx, error_name);
+		duk_def_prop(ctx, -3, DUK_DEFPROP_FORCE | DUK_DEFPROP_HAVE_VALUE);  /* to get e.g. 'Trace: 1 2 3' */
+		duk_get_prop_string(ctx, -1, "stack");
+	}
+
+	fprintf(stdout, "%s\n", duk_to_string(ctx, -1));
+	if (flags & DUK_CONSOLE_FLUSH) {
+		fflush(stdout);
+	}
+	return 0;
+}
+
+static duk_ret_t duk__console_assert(duk_context *ctx) {
+	if (duk_to_boolean(ctx, 0)) {
+		return 0;
+	}
+	duk_remove(ctx, 0);
+
+	return duk__console_log_helper(ctx, "AssertionError");
+}
+
+static duk_ret_t duk__console_log(duk_context *ctx) {
+	return duk__console_log_helper(ctx, NULL);
+}
+
+static duk_ret_t duk__console_trace(duk_context *ctx) {
+	return duk__console_log_helper(ctx, "Trace");
+}
+
+static duk_ret_t duk__console_info(duk_context *ctx) {
+	return duk__console_log_helper(ctx, NULL);
+}
+
+static duk_ret_t duk__console_warn(duk_context *ctx) {
+	return duk__console_log_helper(ctx, NULL);
+}
+
+static duk_ret_t duk__console_error(duk_context *ctx) {
+	return duk__console_log_helper(ctx, "Error");
+}
+
+static duk_ret_t duk__console_dir(duk_context *ctx) {
+	/* For now, just share the formatting of .log() */
+	return duk__console_log_helper(ctx, 0);
+}
+
+static void duk__console_reg_vararg_func(duk_context *ctx, duk_c_function func, const char *name, duk_uint_t flags) {
+	duk_push_c_function(ctx, func, DUK_VARARGS);
+	duk_push_string(ctx, "name");
+	duk_push_string(ctx, name);
+	duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE);  /* Improve stacktraces by displaying function name */
+	duk_set_magic(ctx, -1, (duk_int_t) flags);
+	duk_put_prop_string(ctx, -2, name);
+}
+
+void duk_console_init(duk_context *ctx, duk_uint_t flags) {
+	duk_push_object(ctx);
+
+	/* Custom function to format objects; user can replace.
+	 * For now, try JX-formatting and if that fails, fall back
+	 * to ToString(v).
+	 */
+	duk_eval_string(ctx,
+		"(function (E) {"
+		    "return function format(v){"
+		        "try{"
+		            "return E('jx',v);"
+		        "}catch(e){"
+		            "return String(v);"  /* String() allows symbols, ToString() internal algorithm doesn't. */
+		        "}"
+		    "};"
+		"})(Duktape.enc)");
+	duk_put_prop_string(ctx, -2, "format");
+
+	duk__console_reg_vararg_func(ctx, duk__console_assert, "assert", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_log, "log", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_log, "debug", flags);  /* alias to console.log */
+	duk__console_reg_vararg_func(ctx, duk__console_trace, "trace", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_info, "info", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_warn, "warn", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_error, "error", flags);
+	duk__console_reg_vararg_func(ctx, duk__console_error, "exception", flags);  /* alias to console.error */
+	duk__console_reg_vararg_func(ctx, duk__console_dir, "dir", flags);
+
+	duk_put_global_string(ctx, "console");
+
+	/* Proxy wrapping: ensures any undefined console method calls are
+	 * ignored silently.  This is required specifically by the
+	 * DeveloperToolsWG proposal (and is implemented also by Firefox:
+	 * https://bugzilla.mozilla.org/show_bug.cgi?id=629607).
+	 */
+
+	if (flags & DUK_CONSOLE_PROXY_WRAPPER) {
+		/* Tolerate errors: Proxy may be disabled. */
+		duk_peval_string_noresult(ctx,
+			"(function(){"
+			    "var D=function(){};"
+			    "console=new Proxy(console,{"
+			        "get:function(t,k){"
+			            "var v=t[k];"
+			            "return typeof v==='function'?v:D;"
+			        "}"
+			    "});"
+			"})();"
+		);
+	}
+}
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h
new file mode 100755
index 0000000000..1488a95fa6
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h
@@ -0,0 +1,14 @@
+#if !defined(DUK_CONSOLE_H_INCLUDED)
+#define DUK_CONSOLE_H_INCLUDED
+
+#include "duktape.h"
+
+/* Use a proxy wrapper to make undefined methods (console.foo()) no-ops. */
+#define DUK_CONSOLE_PROXY_WRAPPER  (1 << 0)
+
+/* Flush output after every call. */
+#define DUK_CONSOLE_FLUSH          (1 << 1)
+
+extern void duk_console_init(duk_context *ctx, duk_uint_t flags);
+
+#endif  /* DUK_CONSOLE_H_INCLUDED */
diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c
new file mode 100755
index 0000000000..9be2c1c273
--- /dev/null
+++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c
@@ -0,0 +1,380 @@
+/*
+ *  Logging support
+ */
+
+#include 
+#include 
+#include 
+#include "duktape.h"
+#include "duk_logging.h"
+
+/* XXX: uses stderr always for now, configurable? */
+
+#define DUK_LOGGING_FLUSH  /* Duktape 1.x: flush stderr */
+
+/* 3-letter log level strings. */
+static const char duk__log_level_strings[] = {
+	'T', 'R', 'C', 'D', 'B', 'G', 'I', 'N', 'F',
+	'W', 'R', 'N', 'E', 'R', 'R', 'F', 'T', 'L'
+};
+
+/* Log method names. */
+static const char *duk__log_method_names[] = {
+	"trace", "debug", "info", "warn", "error", "fatal"
+};
+
+/* Constructor. */
+static duk_ret_t duk__logger_constructor(duk_context *ctx) {
+	duk_idx_t nargs;
+
+	/* Calling as a non-constructor is not meaningful. */
+	if (!duk_is_constructor_call(ctx)) {
+		return DUK_RET_TYPE_ERROR;
+	}
+
+	nargs = duk_get_top(ctx);
+	duk_set_top(ctx, 1);
+
+	duk_push_this(ctx);
+
+	/* [ name this ] */
+
+	if (nargs == 0) {
+		/* Automatic defaulting of logger name from caller.  This
+		 * would work poorly with tail calls, but constructor calls
+		 * are currently never tail calls, so tail calls are not an
+		 * issue now.
+		 */
+
+		duk_inspect_callstack_entry(ctx, -2);
+		if (duk_is_object(ctx, -1)) {
+			if (duk_get_prop_string(ctx, -1, "function")) {
+				if (duk_get_prop_string(ctx, -1, "fileName")) {
+					if (duk_is_string(ctx, -1)) {
+						duk_replace(ctx, 0);
+					}
+				}
+			}
+		}
+		/* Leave values on stack on purpose, ignored below. */
+
+		/* Stripping the filename might be a good idea
+		 * ("/foo/bar/quux.js" -> logger name "quux"),
+		 * but now used verbatim.
+		 */
+	}
+	/* The stack is unbalanced here on purpose; we only rely on the
+	 * initial two values: [ name this ].
+	 */
+
+	if (duk_is_string(ctx, 0)) {
+		duk_dup(ctx, 0);
+		duk_put_prop_string(ctx, 1, "n");
+	} else {
+		/* don't set 'n' at all, inherited value is used as name */
+	}
+
+	duk_compact(ctx, 1);
+
+	return 0;  /* keep default instance */
+}
+
+/* Default function to format objects.  Tries to use toLogString() but falls
+ * back to toString().  Any errors are propagated out without catching.
+ */
+static duk_ret_t duk__logger_prototype_fmt(duk_context *ctx) {
+	if (duk_get_prop_string(ctx, 0, "toLogString")) {
+		/* [ arg toLogString ] */
+
+		duk_dup(ctx, 0);
+		duk_call_method(ctx, 0);
+
+		/* [ arg result ] */
+		return 1;
+	}
+
+	/* [ arg undefined ] */
+	duk_pop(ctx);
+	duk_to_string(ctx, 0);
+	return 1;
+}
+
+/* Default function to write a formatted log line.  Writes to stderr,
+ * appending a newline to the log line.
+ *
+ * The argument is a buffer; avoid coercing the buffer to a string to
+ * avoid string table traffic.
+ */
+static duk_ret_t duk__logger_prototype_raw(duk_context *ctx) {
+	const char *data;
+	duk_size_t data_len;
+
+	data = (const char *) duk_require_buffer(ctx, 0, &data_len);
+	fwrite((const void *) data, 1, data_len, stderr);
+	fputc((int) '\n', stderr);
+#if defined(DUK_LOGGING_FLUSH)
+	fflush(stderr);
+#endif
+	return 0;
+}
+
+/* Log frontend shared helper, magic value indicates log level.  Provides
+ * frontend functions: trace(), debug(), info(), warn(), error(), fatal().
+ * This needs to have small footprint, reasonable performance, minimal
+ * memory churn, etc.
+ */
+static duk_ret_t duk__logger_prototype_log_shared(duk_context *ctx) {
+	duk_double_t now;
+	duk_time_components comp;
+	duk_small_int_t entry_lev;
+	duk_small_int_t logger_lev;
+	duk_int_t nargs;
+	duk_int_t i;
+	duk_size_t tot_len;
+	const duk_uint8_t *arg_str;
+	duk_size_t arg_len;
+	duk_uint8_t *buf, *p;
+	const duk_uint8_t *q;
+	duk_uint8_t date_buf[32];  /* maximum format length is 24+1 (NUL), round up. */
+	duk_size_t date_len;
+	duk_small_int_t rc;
+
+	/* XXX: sanitize to printable (and maybe ASCII) */
+	/* XXX: better multiline */
+
+	/*
+	 *  Logger arguments are:
+	 *
+	 *    magic: log level (0-5)
+	 *    this: logger
+	 *    stack: plain log args
+	 *
+	 *  We want to minimize memory churn so a two-pass approach
+	 *  is used: first pass formats arguments and computes final
+	 *  string length, second pass copies strings into a buffer
+	 *  allocated directly with the correct size.  If the backend
+	 *  function plays nice, it won't coerce the buffer to a string
+	 *  (and thus intern it).
+	 */
+
+	entry_lev = duk_get_current_magic(ctx);
+	if (entry_lev < DUK_LOG_TRACE || entry_lev > DUK_LOG_FATAL) {
+		/* Should never happen, check just in case. */
+		return 0;
+	}
+	nargs = duk_get_top(ctx);
+
+	/* [ arg1 ... argN this ] */
+
+	/*
+	 *  Log level check
+	 */
+
+	duk_push_this(ctx);
+
+	duk_get_prop_string(ctx, -1, "l");
+	logger_lev = (duk_small_int_t) duk_get_int(ctx, -1);
+	if (entry_lev < logger_lev) {
+		return 0;
+	}
+	/* log level could be popped but that's not necessary */
+
+	now = duk_get_now(ctx);
+	duk_time_to_components(ctx, now, &comp);
+	sprintf((char *) date_buf, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
+	        (int) comp.year, (int) comp.month + 1, (int) comp.day,
+	        (int) comp.hours, (int) comp.minutes, (int) comp.seconds,
+	        (int) comp.milliseconds);
+
+	date_len = strlen((const char *) date_buf);
+
+	duk_get_prop_string(ctx, -2, "n");
+	duk_to_string(ctx, -1);
+
+	/* [ arg1 ... argN this loggerLevel loggerName ] */
+
+	/*
+	 *  Pass 1
+	 */
+
+	/* Line format: