From 1ae8cbc2ce87d8469ea375935208f7a7f13aedf4 Mon Sep 17 00:00:00 2001 From: Roberto Sora Date: Fri, 7 Dec 2018 11:05:12 +0100 Subject: [PATCH] reverted to facchinm fork for golantern/systray --- Gopkg.lock | 50 +- Gopkg.toml | 4 +- trayicon.go | 10 +- vendor/github.com/davecgh/go-spew/LICENSE | 15 + .../github.com/davecgh/go-spew/spew/bypass.go | 145 ++ .../davecgh/go-spew/spew/bypasssafe.go | 38 + .../github.com/davecgh/go-spew/spew/common.go | 341 ++++ .../github.com/davecgh/go-spew/spew/config.go | 306 ++++ vendor/github.com/davecgh/go-spew/spew/doc.go | 211 +++ .../github.com/davecgh/go-spew/spew/dump.go | 509 ++++++ .../github.com/davecgh/go-spew/spew/format.go | 419 +++++ .../github.com/davecgh/go-spew/spew/spew.go | 148 ++ .../systray/.gitignore | 3 - .../{getlantern => facchinm}/systray/LICENSE | 0 .../systray/README.md | 23 +- .../github.com/facchinm/systray/embeddll.bash | 10 + .../github.com/facchinm/systray/signdll.bash | 19 + .../systray/systray.go | 93 +- .../systray/systray.h | 5 - .../systray/systray_darwin.m | 75 +- .../systray/systray_linux.c | 60 +- .../systray/systray_nonwindows.go | 40 +- .../facchinm/systray/systray_windows.go | 154 ++ .../facchinm/systray/systraydll_windows.go | 233 +++ .../getlantern/filepersist/filepersist.go | 122 ++ .../getlantern/systray/systray_windows.go | 690 -------- vendor/github.com/pmezard/go-difflib/LICENSE | 27 + .../pmezard/go-difflib/difflib/difflib.go | 772 +++++++++ vendor/github.com/stretchr/testify/LICENSE | 22 + .../testify/assert/assertion_format.go | 484 ++++++ .../testify/assert/assertion_format.go.tmpl | 5 + .../testify/assert/assertion_forward.go | 956 +++++++++++ .../testify/assert/assertion_forward.go.tmpl | 5 + .../stretchr/testify/assert/assertions.go | 1394 +++++++++++++++++ .../github.com/stretchr/testify/assert/doc.go | 45 + .../stretchr/testify/assert/errors.go | 10 + .../testify/assert/forward_assertions.go | 16 + .../testify/assert/http_assertions.go | 143 ++ 38 files changed, 6648 insertions(+), 954 deletions(-) create mode 100644 vendor/github.com/davecgh/go-spew/LICENSE create mode 100644 vendor/github.com/davecgh/go-spew/spew/bypass.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/bypasssafe.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/common.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/config.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/doc.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/dump.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/format.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/spew.go rename vendor/github.com/{getlantern => facchinm}/systray/.gitignore (75%) rename vendor/github.com/{getlantern => facchinm}/systray/LICENSE (100%) rename vendor/github.com/{getlantern => facchinm}/systray/README.md (62%) create mode 100755 vendor/github.com/facchinm/systray/embeddll.bash create mode 100755 vendor/github.com/facchinm/systray/signdll.bash rename vendor/github.com/{getlantern => facchinm}/systray/systray.go (55%) rename vendor/github.com/{getlantern => facchinm}/systray/systray.h (62%) rename vendor/github.com/{getlantern => facchinm}/systray/systray_darwin.m (67%) rename vendor/github.com/{getlantern => facchinm}/systray/systray_linux.c (74%) rename vendor/github.com/{getlantern => facchinm}/systray/systray_nonwindows.go (56%) create mode 100644 vendor/github.com/facchinm/systray/systray_windows.go create mode 100644 vendor/github.com/facchinm/systray/systraydll_windows.go create mode 100644 vendor/github.com/getlantern/filepersist/filepersist.go delete mode 100644 vendor/github.com/getlantern/systray/systray_windows.go create mode 100644 vendor/github.com/pmezard/go-difflib/LICENSE create mode 100644 vendor/github.com/pmezard/go-difflib/difflib/difflib.go create mode 100644 vendor/github.com/stretchr/testify/LICENSE create mode 100644 vendor/github.com/stretchr/testify/assert/assertion_format.go create mode 100644 vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl create mode 100644 vendor/github.com/stretchr/testify/assert/assertion_forward.go create mode 100644 vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl create mode 100644 vendor/github.com/stretchr/testify/assert/assertions.go create mode 100644 vendor/github.com/stretchr/testify/assert/doc.go create mode 100644 vendor/github.com/stretchr/testify/assert/errors.go create mode 100644 vendor/github.com/stretchr/testify/assert/forward_assertions.go create mode 100644 vendor/github.com/stretchr/testify/assert/http_assertions.go diff --git a/Gopkg.lock b/Gopkg.lock index 03895783f..6c242cf7c 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -25,6 +25,14 @@ pruneopts = "UT" revision = "58854f77ee8d858ce751b0a9bcc5533fef7bfa9e" +[[projects]] + digest = "1:ffe9824d294da03b391f44e1ae8281281b4afc1bdaa9588c9097785e3af10cec" + name = "github.com/davecgh/go-spew" + packages = ["spew"] + pruneopts = "UT" + revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73" + version = "v1.1.1" + [[projects]] digest = "1:ce303e1d83a733bda89c5bad61fcf7e86b9f68b97bf783509192090ddd3919cb" name = "github.com/davidmz/go-pageant" @@ -33,6 +41,14 @@ revision = "30ad2d03e9fe97a029a6a6dc87bff319e0bb6bc4" version = "v1.0.1" +[[projects]] + branch = "master" + digest = "1:8df8718256c87ae7984cbfa1304b9efdd8b5952dcb94a8a51cfe9d61f08785ee" + name = "github.com/facchinm/systray" + packages = ["."] + pruneopts = "UT" + revision = "b32308b0b662e45cde7c5986bc29def5d48bafbb" + [[projects]] branch = "master" digest = "1:c3c09c0f941175181747b2d6948fd1add3ba82e66215aae78ec9b44d97d8ed40" @@ -49,6 +65,14 @@ pruneopts = "UT" revision = "e24b7f4ff7c70be59bbefca6b7695d68cda8b399" +[[projects]] + branch = "master" + digest = "1:99c1c515274e6c3ead7bf68dcc77f56131d0f937adeb6808ba86e0911adfdda7" + name = "github.com/getlantern/filepersist" + packages = ["."] + pruneopts = "UT" + revision = "c5f0cd24e7991579ba6f5f1bd20a1ad2c9f06cd4" + [[projects]] branch = "master" digest = "1:128515bf48085482f3b1269701a0be1b119087447d8f666a27211bdacf0b5dc9" @@ -81,13 +105,6 @@ pruneopts = "UT" revision = "37353306c90844c8e0591956f56611f46299d202" -[[projects]] - digest = "1:bd5504d3204cc1625bc017e477690ad7da71f5c800dc5efdf8a9a7d4feebe2e7" - name = "github.com/getlantern/systray" - packages = ["."] - pruneopts = "UT" - revision = "89b3d9c45cc69f861868cc7f3159eba2b4cdfb22" - [[projects]] branch = "master" digest = "1:36fe9527deed01d2a317617e59304eb2c4ce9f8a24115bcc5c2e37b3aee5bae4" @@ -285,6 +302,14 @@ revision = "08de04f133f27844173471167014e1a753655ac8" version = "v1.8.3" +[[projects]] + digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe" + name = "github.com/pmezard/go-difflib" + packages = ["difflib"] + pruneopts = "UT" + revision = "792786c7400a136282c1664665ae0a8db921c6c2" + version = "v1.0.0" + [[projects]] branch = "master" digest = "1:e244ec9ef8a91f5d0f640c4d14db6d65938182bb976c07f01f0f6e8f4605c4e9" @@ -301,6 +326,14 @@ pruneopts = "UT" revision = "75fb7ed4208cf72d323d7d02fd1a5964a7a9073c" +[[projects]] + digest = "1:18752d0b95816a1b777505a97f71c7467a8445b8ffb55631a7bf779f6ba4fa83" + name = "github.com/stretchr/testify" + packages = ["assert"] + pruneopts = "UT" + revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686" + version = "v1.2.2" + [[projects]] digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" name = "github.com/ugorji/go" @@ -410,7 +443,7 @@ input-imports = [ "github.com/Sirupsen/logrus", "github.com/blang/semver", - "github.com/getlantern/systray", + "github.com/facchinm/systray", "github.com/gin-gonic/gin", "github.com/go-ini/ini", "github.com/googollee/go-socket.io", @@ -423,6 +456,7 @@ "github.com/pkg/errors", "github.com/sfreiberg/simplessh", "github.com/skratchdot/open-golang/open", + "github.com/stretchr/testify/assert", "github.com/xrash/smetrics", "go.bug.st/serial.v1", "go.bug.st/serial.v1/enumerator", diff --git a/Gopkg.toml b/Gopkg.toml index 97bc5fa07..e89510da8 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -34,8 +34,8 @@ version = "3.5.1" [[constraint]] - revision = "89b3d9c45cc69f861868cc7f3159eba2b4cdfb22" - name = "github.com/getlantern/systray" + branch = "master" + name = "github.com/facchinm/systray" [[constraint]] name = "github.com/gin-gonic/gin" diff --git a/trayicon.go b/trayicon.go index 6fe2dbfe0..aa8638447 100644 --- a/trayicon.go +++ b/trayicon.go @@ -37,7 +37,7 @@ import ( log "github.com/Sirupsen/logrus" "github.com/arduino/arduino-create-agent/icon" - "github.com/getlantern/systray" + "github.com/facchinm/systray" "github.com/go-ini/ini" "github.com/kardianos/osext" "github.com/skratchdot/open-golang/open" @@ -47,9 +47,9 @@ import ( func setupSysTray() { runtime.LockOSThread() if *hibernate == true { - systray.Run(setupSysTrayHibernate,nil) + systray.Run(setupSysTrayHibernate) } else { - systray.Run(setupSysTrayReal,nil) + systray.Run(setupSysTrayReal) } } @@ -144,7 +144,7 @@ func setupSysTrayReal() { } systray.Quit() *hibernate = true - log.Println("Restart becayse setup went wrong?") + log.Println("Restart because setup went wrong?") restart("") }() @@ -180,7 +180,7 @@ func setupSysTrayHibernate() { go func() { <-mOpen.ClickedCh *hibernate = false - log.Println("Restart for hubernation") + log.Println("Restart for hibernation") systray.Quit() restart("") }() diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE new file mode 100644 index 000000000..bc52e96f2 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2012-2016 Dave Collins + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go new file mode 100644 index 000000000..792994785 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go @@ -0,0 +1,145 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is not running on Google App Engine, compiled by GopherJS, and +// "-tags safe" is not added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// Go versions prior to 1.4 are disabled because they use a different layout +// for interfaces which make the implementation of unsafeReflectValue more complex. +// +build !js,!appengine,!safe,!disableunsafe,go1.4 + +package spew + +import ( + "reflect" + "unsafe" +) + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = false + + // ptrSize is the size of a pointer on the current arch. + ptrSize = unsafe.Sizeof((*byte)(nil)) +) + +type flag uintptr + +var ( + // flagRO indicates whether the value field of a reflect.Value + // is read-only. + flagRO flag + + // flagAddr indicates whether the address of the reflect.Value's + // value may be taken. + flagAddr flag +) + +// flagKindMask holds the bits that make up the kind +// part of the flags field. In all the supported versions, +// it is in the lower 5 bits. +const flagKindMask = flag(0x1f) + +// Different versions of Go have used different +// bit layouts for the flags type. This table +// records the known combinations. +var okFlags = []struct { + ro, addr flag +}{{ + // From Go 1.4 to 1.5 + ro: 1 << 5, + addr: 1 << 7, +}, { + // Up to Go tip. + ro: 1<<5 | 1<<6, + addr: 1 << 8, +}} + +var flagValOffset = func() uintptr { + field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") + if !ok { + panic("reflect.Value has no flag field") + } + return field.Offset +}() + +// flagField returns a pointer to the flag field of a reflect.Value. +func flagField(v *reflect.Value) *flag { + return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset)) +} + +// unsafeReflectValue converts the passed reflect.Value into a one that bypasses +// the typical safety restrictions preventing access to unaddressable and +// unexported data. It works by digging the raw pointer to the underlying +// value out of the protected value and generating a new unprotected (unsafe) +// reflect.Value to it. +// +// This allows us to check for implementations of the Stringer and error +// interfaces to be used for pretty printing ordinarily unaddressable and +// inaccessible values such as unexported struct fields. +func unsafeReflectValue(v reflect.Value) reflect.Value { + if !v.IsValid() || (v.CanInterface() && v.CanAddr()) { + return v + } + flagFieldPtr := flagField(&v) + *flagFieldPtr &^= flagRO + *flagFieldPtr |= flagAddr + return v +} + +// Sanity checks against future reflect package changes +// to the type or semantics of the Value.flag field. +func init() { + field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") + if !ok { + panic("reflect.Value has no flag field") + } + if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() { + panic("reflect.Value flag field has changed kind") + } + type t0 int + var t struct { + A t0 + // t0 will have flagEmbedRO set. + t0 + // a will have flagStickyRO set + a t0 + } + vA := reflect.ValueOf(t).FieldByName("A") + va := reflect.ValueOf(t).FieldByName("a") + vt0 := reflect.ValueOf(t).FieldByName("t0") + + // Infer flagRO from the difference between the flags + // for the (otherwise identical) fields in t. + flagPublic := *flagField(&vA) + flagWithRO := *flagField(&va) | *flagField(&vt0) + flagRO = flagPublic ^ flagWithRO + + // Infer flagAddr from the difference between a value + // taken from a pointer and not. + vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A") + flagNoPtr := *flagField(&vA) + flagPtr := *flagField(&vPtrA) + flagAddr = flagNoPtr ^ flagPtr + + // Check that the inferred flags tally with one of the known versions. + for _, f := range okFlags { + if flagRO == f.ro && flagAddr == f.addr { + return + } + } + panic("reflect.Value read-only flag has changed semantics") +} diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go new file mode 100644 index 000000000..205c28d68 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go @@ -0,0 +1,38 @@ +// Copyright (c) 2015-2016 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is running on Google App Engine, compiled by GopherJS, or +// "-tags safe" is added to the go build command line. The "disableunsafe" +// tag is deprecated and thus should not be used. +// +build js appengine safe disableunsafe !go1.4 + +package spew + +import "reflect" + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = true +) + +// unsafeReflectValue typically converts the passed reflect.Value into a one +// that bypasses the typical safety restrictions preventing access to +// unaddressable and unexported data. However, doing this relies on access to +// the unsafe package. This is a stub version which simply returns the passed +// reflect.Value when the unsafe package is not available. +func unsafeReflectValue(v reflect.Value) reflect.Value { + return v +} diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go new file mode 100644 index 000000000..1be8ce945 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/common.go @@ -0,0 +1,341 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "reflect" + "sort" + "strconv" +) + +// Some constants in the form of bytes to avoid string overhead. This mirrors +// the technique used in the fmt package. +var ( + panicBytes = []byte("(PANIC=") + plusBytes = []byte("+") + iBytes = []byte("i") + trueBytes = []byte("true") + falseBytes = []byte("false") + interfaceBytes = []byte("(interface {})") + commaNewlineBytes = []byte(",\n") + newlineBytes = []byte("\n") + openBraceBytes = []byte("{") + openBraceNewlineBytes = []byte("{\n") + closeBraceBytes = []byte("}") + asteriskBytes = []byte("*") + colonBytes = []byte(":") + colonSpaceBytes = []byte(": ") + openParenBytes = []byte("(") + closeParenBytes = []byte(")") + spaceBytes = []byte(" ") + pointerChainBytes = []byte("->") + nilAngleBytes = []byte("") + maxNewlineBytes = []byte("\n") + maxShortBytes = []byte("") + circularBytes = []byte("") + circularShortBytes = []byte("") + invalidAngleBytes = []byte("") + openBracketBytes = []byte("[") + closeBracketBytes = []byte("]") + percentBytes = []byte("%") + precisionBytes = []byte(".") + openAngleBytes = []byte("<") + closeAngleBytes = []byte(">") + openMapBytes = []byte("map[") + closeMapBytes = []byte("]") + lenEqualsBytes = []byte("len=") + capEqualsBytes = []byte("cap=") +) + +// hexDigits is used to map a decimal value to a hex digit. +var hexDigits = "0123456789abcdef" + +// catchPanic handles any panics that might occur during the handleMethods +// calls. +func catchPanic(w io.Writer, v reflect.Value) { + if err := recover(); err != nil { + w.Write(panicBytes) + fmt.Fprintf(w, "%v", err) + w.Write(closeParenBytes) + } +} + +// handleMethods attempts to call the Error and String methods on the underlying +// type the passed reflect.Value represents and outputes the result to Writer w. +// +// It handles panics in any called methods by catching and displaying the error +// as the formatted value. +func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { + // We need an interface to check if the type implements the error or + // Stringer interface. However, the reflect package won't give us an + // interface on certain things like unexported struct fields in order + // to enforce visibility rules. We use unsafe, when it's available, + // to bypass these restrictions since this package does not mutate the + // values. + if !v.CanInterface() { + if UnsafeDisabled { + return false + } + + v = unsafeReflectValue(v) + } + + // Choose whether or not to do error and Stringer interface lookups against + // the base type or a pointer to the base type depending on settings. + // Technically calling one of these methods with a pointer receiver can + // mutate the value, however, types which choose to satisify an error or + // Stringer interface with a pointer receiver should not be mutating their + // state inside these interface methods. + if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { + v = unsafeReflectValue(v) + } + if v.CanAddr() { + v = v.Addr() + } + + // Is it an error or Stringer? + switch iface := v.Interface().(type) { + case error: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.Error())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + + w.Write([]byte(iface.Error())) + return true + + case fmt.Stringer: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.String())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + w.Write([]byte(iface.String())) + return true + } + return false +} + +// printBool outputs a boolean value as true or false to Writer w. +func printBool(w io.Writer, val bool) { + if val { + w.Write(trueBytes) + } else { + w.Write(falseBytes) + } +} + +// printInt outputs a signed integer value to Writer w. +func printInt(w io.Writer, val int64, base int) { + w.Write([]byte(strconv.FormatInt(val, base))) +} + +// printUint outputs an unsigned integer value to Writer w. +func printUint(w io.Writer, val uint64, base int) { + w.Write([]byte(strconv.FormatUint(val, base))) +} + +// printFloat outputs a floating point value using the specified precision, +// which is expected to be 32 or 64bit, to Writer w. +func printFloat(w io.Writer, val float64, precision int) { + w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) +} + +// printComplex outputs a complex value using the specified float precision +// for the real and imaginary parts to Writer w. +func printComplex(w io.Writer, c complex128, floatPrecision int) { + r := real(c) + w.Write(openParenBytes) + w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) + i := imag(c) + if i >= 0 { + w.Write(plusBytes) + } + w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) + w.Write(iBytes) + w.Write(closeParenBytes) +} + +// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x' +// prefix to Writer w. +func printHexPtr(w io.Writer, p uintptr) { + // Null pointer. + num := uint64(p) + if num == 0 { + w.Write(nilAngleBytes) + return + } + + // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix + buf := make([]byte, 18) + + // It's simpler to construct the hex string right to left. + base := uint64(16) + i := len(buf) - 1 + for num >= base { + buf[i] = hexDigits[num%base] + num /= base + i-- + } + buf[i] = hexDigits[num] + + // Add '0x' prefix. + i-- + buf[i] = 'x' + i-- + buf[i] = '0' + + // Strip unused leading bytes. + buf = buf[i:] + w.Write(buf) +} + +// valuesSorter implements sort.Interface to allow a slice of reflect.Value +// elements to be sorted. +type valuesSorter struct { + values []reflect.Value + strings []string // either nil or same len and values + cs *ConfigState +} + +// newValuesSorter initializes a valuesSorter instance, which holds a set of +// surrogate keys on which the data should be sorted. It uses flags in +// ConfigState to decide if and how to populate those surrogate keys. +func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { + vs := &valuesSorter{values: values, cs: cs} + if canSortSimply(vs.values[0].Kind()) { + return vs + } + if !cs.DisableMethods { + vs.strings = make([]string, len(values)) + for i := range vs.values { + b := bytes.Buffer{} + if !handleMethods(cs, &b, vs.values[i]) { + vs.strings = nil + break + } + vs.strings[i] = b.String() + } + } + if vs.strings == nil && cs.SpewKeys { + vs.strings = make([]string, len(values)) + for i := range vs.values { + vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) + } + } + return vs +} + +// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted +// directly, or whether it should be considered for sorting by surrogate keys +// (if the ConfigState allows it). +func canSortSimply(kind reflect.Kind) bool { + // This switch parallels valueSortLess, except for the default case. + switch kind { + case reflect.Bool: + return true + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return true + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return true + case reflect.Float32, reflect.Float64: + return true + case reflect.String: + return true + case reflect.Uintptr: + return true + case reflect.Array: + return true + } + return false +} + +// Len returns the number of values in the slice. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Len() int { + return len(s.values) +} + +// Swap swaps the values at the passed indices. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Swap(i, j int) { + s.values[i], s.values[j] = s.values[j], s.values[i] + if s.strings != nil { + s.strings[i], s.strings[j] = s.strings[j], s.strings[i] + } +} + +// valueSortLess returns whether the first value should sort before the second +// value. It is used by valueSorter.Less as part of the sort.Interface +// implementation. +func valueSortLess(a, b reflect.Value) bool { + switch a.Kind() { + case reflect.Bool: + return !a.Bool() && b.Bool() + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return a.Int() < b.Int() + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return a.Uint() < b.Uint() + case reflect.Float32, reflect.Float64: + return a.Float() < b.Float() + case reflect.String: + return a.String() < b.String() + case reflect.Uintptr: + return a.Uint() < b.Uint() + case reflect.Array: + // Compare the contents of both arrays. + l := a.Len() + for i := 0; i < l; i++ { + av := a.Index(i) + bv := b.Index(i) + if av.Interface() == bv.Interface() { + continue + } + return valueSortLess(av, bv) + } + } + return a.String() < b.String() +} + +// Less returns whether the value at index i should sort before the +// value at index j. It is part of the sort.Interface implementation. +func (s *valuesSorter) Less(i, j int) bool { + if s.strings == nil { + return valueSortLess(s.values[i], s.values[j]) + } + return s.strings[i] < s.strings[j] +} + +// sortValues is a sort function that handles both native types and any type that +// can be converted to error or Stringer. Other inputs are sorted according to +// their Value.String() value to ensure display stability. +func sortValues(values []reflect.Value, cs *ConfigState) { + if len(values) == 0 { + return + } + sort.Sort(newValuesSorter(values, cs)) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go new file mode 100644 index 000000000..2e3d22f31 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/config.go @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "os" +) + +// ConfigState houses the configuration options used by spew to format and +// display values. There is a global instance, Config, that is used to control +// all top-level Formatter and Dump functionality. Each ConfigState instance +// provides methods equivalent to the top-level functions. +// +// The zero value for ConfigState provides no indentation. You would typically +// want to set it to a space or a tab. +// +// Alternatively, you can use NewDefaultConfig to get a ConfigState instance +// with default settings. See the documentation of NewDefaultConfig for default +// values. +type ConfigState struct { + // Indent specifies the string to use for each indentation level. The + // global config instance that all top-level functions use set this to a + // single space by default. If you would like more indentation, you might + // set this to a tab with "\t" or perhaps two spaces with " ". + Indent string + + // MaxDepth controls the maximum number of levels to descend into nested + // data structures. The default, 0, means there is no limit. + // + // NOTE: Circular data structures are properly detected, so it is not + // necessary to set this value unless you specifically want to limit deeply + // nested data structures. + MaxDepth int + + // DisableMethods specifies whether or not error and Stringer interfaces are + // invoked for types that implement them. + DisableMethods bool + + // DisablePointerMethods specifies whether or not to check for and invoke + // error and Stringer interfaces on types which only accept a pointer + // receiver when the current type is not a pointer. + // + // NOTE: This might be an unsafe action since calling one of these methods + // with a pointer receiver could technically mutate the value, however, + // in practice, types which choose to satisify an error or Stringer + // interface with a pointer receiver should not be mutating their state + // inside these interface methods. As a result, this option relies on + // access to the unsafe package, so it will not have any effect when + // running in environments without access to the unsafe package such as + // Google App Engine or with the "safe" build tag specified. + DisablePointerMethods bool + + // DisablePointerAddresses specifies whether to disable the printing of + // pointer addresses. This is useful when diffing data structures in tests. + DisablePointerAddresses bool + + // DisableCapacities specifies whether to disable the printing of capacities + // for arrays, slices, maps and channels. This is useful when diffing + // data structures in tests. + DisableCapacities bool + + // ContinueOnMethod specifies whether or not recursion should continue once + // a custom error or Stringer interface is invoked. The default, false, + // means it will print the results of invoking the custom error or Stringer + // interface and return immediately instead of continuing to recurse into + // the internals of the data type. + // + // NOTE: This flag does not have any effect if method invocation is disabled + // via the DisableMethods or DisablePointerMethods options. + ContinueOnMethod bool + + // SortKeys specifies map keys should be sorted before being printed. Use + // this to have a more deterministic, diffable output. Note that only + // native types (bool, int, uint, floats, uintptr and string) and types + // that support the error or Stringer interfaces (if methods are + // enabled) are supported, with other types sorted according to the + // reflect.Value.String() output which guarantees display stability. + SortKeys bool + + // SpewKeys specifies that, as a last resort attempt, map keys should + // be spewed to strings and sorted by those strings. This is only + // considered if SortKeys is true. + SpewKeys bool +} + +// Config is the active configuration of the top-level functions. +// The configuration can be changed by modifying the contents of spew.Config. +var Config = ConfigState{Indent: " "} + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the formatted string as a value that satisfies error. See NewFormatter +// for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, c.convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, c.convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, c.convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a Formatter interface returned by c.NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, c.convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Print(a ...interface{}) (n int, err error) { + return fmt.Print(c.convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, c.convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Println(a ...interface{}) (n int, err error) { + return fmt.Println(c.convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprint(a ...interface{}) string { + return fmt.Sprint(c.convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, c.convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a Formatter interface returned by c.NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintln(a ...interface{}) string { + return fmt.Sprintln(c.convertArgs(a)...) +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +c.Printf, c.Println, or c.Printf. +*/ +func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(c, v) +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { + fdump(c, w, a...) +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by modifying the public members +of c. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func (c *ConfigState) Dump(a ...interface{}) { + fdump(c, os.Stdout, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func (c *ConfigState) Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(c, &buf, a...) + return buf.String() +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a spew Formatter interface using +// the ConfigState associated with s. +func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = newFormatter(c, arg) + } + return formatters +} + +// NewDefaultConfig returns a ConfigState with the following default settings. +// +// Indent: " " +// MaxDepth: 0 +// DisableMethods: false +// DisablePointerMethods: false +// ContinueOnMethod: false +// SortKeys: false +func NewDefaultConfig() *ConfigState { + return &ConfigState{Indent: " "} +} diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go new file mode 100644 index 000000000..aacaac6f1 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/doc.go @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* +Package spew implements a deep pretty printer for Go data structures to aid in +debugging. + +A quick overview of the additional features spew provides over the built-in +printing facilities for Go data types are as follows: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output (only when using + Dump style) + +There are two different approaches spew allows for dumping Go data structures: + + * Dump style which prints with newlines, customizable indentation, + and additional debug information such as types and all pointer addresses + used to indirect to the final value + * A custom Formatter interface that integrates cleanly with the standard fmt + package and replaces %v, %+v, %#v, and %#+v to provide inline printing + similar to the default %v while providing the additional functionality + outlined above and passing unsupported format verbs such as %x and %q + along to fmt + +Quick Start + +This section demonstrates how to quickly get started with spew. See the +sections below for further details on formatting and configuration options. + +To dump a variable with full newlines, indentation, type, and pointer +information use Dump, Fdump, or Sdump: + spew.Dump(myVar1, myVar2, ...) + spew.Fdump(someWriter, myVar1, myVar2, ...) + str := spew.Sdump(myVar1, myVar2, ...) + +Alternatively, if you would prefer to use format strings with a compacted inline +printing style, use the convenience wrappers Printf, Fprintf, etc with +%v (most compact), %+v (adds pointer addresses), %#v (adds types), or +%#+v (adds types and pointer addresses): + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +Configuration Options + +Configuration of spew is handled by fields in the ConfigState type. For +convenience, all of the top-level functions use a global state available +via the spew.Config global. + +It is also possible to create a ConfigState instance that provides methods +equivalent to the top-level functions. This allows concurrent configuration +options. See the ConfigState documentation for more details. + +The following configuration options are available: + * Indent + String to use for each indentation level for Dump functions. + It is a single space by default. A popular alternative is "\t". + + * MaxDepth + Maximum number of levels to descend into nested data structures. + There is no limit by default. + + * DisableMethods + Disables invocation of error and Stringer interface methods. + Method invocation is enabled by default. + + * DisablePointerMethods + Disables invocation of error and Stringer interface methods on types + which only accept pointer receivers from non-pointer variables. + Pointer method invocation is enabled by default. + + * DisablePointerAddresses + DisablePointerAddresses specifies whether to disable the printing of + pointer addresses. This is useful when diffing data structures in tests. + + * DisableCapacities + DisableCapacities specifies whether to disable the printing of + capacities for arrays, slices, maps and channels. This is useful when + diffing data structures in tests. + + * ContinueOnMethod + Enables recursion into types after invoking error and Stringer interface + methods. Recursion after method invocation is disabled by default. + + * SortKeys + Specifies map keys should be sorted before being printed. Use + this to have a more deterministic, diffable output. Note that + only native types (bool, int, uint, floats, uintptr and string) + and types which implement error or Stringer interfaces are + supported with other types sorted according to the + reflect.Value.String() output which guarantees display + stability. Natural map order is used by default. + + * SpewKeys + Specifies that, as a last resort attempt, map keys should be + spewed to strings and sorted by those strings. This is only + considered if SortKeys is true. + +Dump Usage + +Simply call spew.Dump with a list of variables you want to dump: + + spew.Dump(myVar1, myVar2, ...) + +You may also call spew.Fdump if you would prefer to output to an arbitrary +io.Writer. For example, to dump to standard error: + + spew.Fdump(os.Stderr, myVar1, myVar2, ...) + +A third option is to call spew.Sdump to get the formatted output as a string: + + str := spew.Sdump(myVar1, myVar2, ...) + +Sample Dump Output + +See the Dump example for details on the setup of the types and variables being +shown here. + + (main.Foo) { + unexportedField: (*main.Bar)(0xf84002e210)({ + flag: (main.Flag) flagTwo, + data: (uintptr) + }), + ExportedField: (map[interface {}]interface {}) (len=1) { + (string) (len=3) "one": (bool) true + } + } + +Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C +command as shown. + ([]uint8) (len=32 cap=32) { + 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | + 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| + 00000020 31 32 |12| + } + +Custom Formatter + +Spew provides a custom formatter that implements the fmt.Formatter interface +so that it integrates cleanly with standard fmt package printing functions. The +formatter is useful for inline printing of smaller data types similar to the +standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Custom Formatter Usage + +The simplest way to make use of the spew custom formatter is to call one of the +convenience functions such as spew.Printf, spew.Println, or spew.Printf. The +functions have syntax you are most likely already familiar with: + + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Println(myVar, myVar2) + spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +See the Index for the full list convenience functions. + +Sample Formatter Output + +Double pointer to a uint8: + %v: <**>5 + %+v: <**>(0xf8400420d0->0xf8400420c8)5 + %#v: (**uint8)5 + %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 + +Pointer to circular struct with a uint8 field and a pointer to itself: + %v: <*>{1 <*>} + %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)} + %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)} + %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)} + +See the Printf example for details on the setup of variables being shown +here. + +Errors + +Since it is possible for custom Stringer/error interfaces to panic, spew +detects them and handles them internally by printing the panic information +inline with the output. Since spew is intended to provide deep pretty printing +capabilities on structures, it intentionally does not return any errors. +*/ +package spew diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go new file mode 100644 index 000000000..f78d89fc1 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/dump.go @@ -0,0 +1,509 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "os" + "reflect" + "regexp" + "strconv" + "strings" +) + +var ( + // uint8Type is a reflect.Type representing a uint8. It is used to + // convert cgo types to uint8 slices for hexdumping. + uint8Type = reflect.TypeOf(uint8(0)) + + // cCharRE is a regular expression that matches a cgo char. + // It is used to detect character arrays to hexdump them. + cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`) + + // cUnsignedCharRE is a regular expression that matches a cgo unsigned + // char. It is used to detect unsigned character arrays to hexdump + // them. + cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`) + + // cUint8tCharRE is a regular expression that matches a cgo uint8_t. + // It is used to detect uint8_t arrays to hexdump them. + cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`) +) + +// dumpState contains information about the state of a dump operation. +type dumpState struct { + w io.Writer + depth int + pointers map[uintptr]int + ignoreNextType bool + ignoreNextIndent bool + cs *ConfigState +} + +// indent performs indentation according to the depth level and cs.Indent +// option. +func (d *dumpState) indent() { + if d.ignoreNextIndent { + d.ignoreNextIndent = false + return + } + d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) +} + +// unpackValue returns values inside of non-nil interfaces when possible. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface && !v.IsNil() { + v = v.Elem() + } + return v +} + +// dumpPtr handles formatting of pointers by indirecting them as necessary. +func (d *dumpState) dumpPtr(v reflect.Value) { + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range d.pointers { + if depth >= d.depth { + delete(d.pointers, k) + } + } + + // Keep list of all dereferenced pointers to show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by dereferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := d.pointers[addr]; ok && pd < d.depth { + cycleFound = true + indirects-- + break + } + d.pointers[addr] = d.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type information. + d.w.Write(openParenBytes) + d.w.Write(bytes.Repeat(asteriskBytes, indirects)) + d.w.Write([]byte(ve.Type().String())) + d.w.Write(closeParenBytes) + + // Display pointer information. + if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { + d.w.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + d.w.Write(pointerChainBytes) + } + printHexPtr(d.w, addr) + } + d.w.Write(closeParenBytes) + } + + // Display dereferenced value. + d.w.Write(openParenBytes) + switch { + case nilFound: + d.w.Write(nilAngleBytes) + + case cycleFound: + d.w.Write(circularBytes) + + default: + d.ignoreNextType = true + d.dump(ve) + } + d.w.Write(closeParenBytes) +} + +// dumpSlice handles formatting of arrays and slices. Byte (uint8 under +// reflection) arrays and slices are dumped in hexdump -C fashion. +func (d *dumpState) dumpSlice(v reflect.Value) { + // Determine whether this type should be hex dumped or not. Also, + // for types which should be hexdumped, try to use the underlying data + // first, then fall back to trying to convert them to a uint8 slice. + var buf []uint8 + doConvert := false + doHexDump := false + numEntries := v.Len() + if numEntries > 0 { + vt := v.Index(0).Type() + vts := vt.String() + switch { + // C types that need to be converted. + case cCharRE.MatchString(vts): + fallthrough + case cUnsignedCharRE.MatchString(vts): + fallthrough + case cUint8tCharRE.MatchString(vts): + doConvert = true + + // Try to use existing uint8 slices and fall back to converting + // and copying if that fails. + case vt.Kind() == reflect.Uint8: + // We need an addressable interface to convert the type + // to a byte slice. However, the reflect package won't + // give us an interface on certain things like + // unexported struct fields in order to enforce + // visibility rules. We use unsafe, when available, to + // bypass these restrictions since this package does not + // mutate the values. + vs := v + if !vs.CanInterface() || !vs.CanAddr() { + vs = unsafeReflectValue(vs) + } + if !UnsafeDisabled { + vs = vs.Slice(0, numEntries) + + // Use the existing uint8 slice if it can be + // type asserted. + iface := vs.Interface() + if slice, ok := iface.([]uint8); ok { + buf = slice + doHexDump = true + break + } + } + + // The underlying data needs to be converted if it can't + // be type asserted to a uint8 slice. + doConvert = true + } + + // Copy and convert the underlying type if needed. + if doConvert && vt.ConvertibleTo(uint8Type) { + // Convert and copy each element into a uint8 byte + // slice. + buf = make([]uint8, numEntries) + for i := 0; i < numEntries; i++ { + vv := v.Index(i) + buf[i] = uint8(vv.Convert(uint8Type).Uint()) + } + doHexDump = true + } + } + + // Hexdump the entire slice as needed. + if doHexDump { + indent := strings.Repeat(d.cs.Indent, d.depth) + str := indent + hex.Dump(buf) + str = strings.Replace(str, "\n", "\n"+indent, -1) + str = strings.TrimRight(str, d.cs.Indent) + d.w.Write([]byte(str)) + return + } + + // Recursively call dump for each item. + for i := 0; i < numEntries; i++ { + d.dump(d.unpackValue(v.Index(i))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } +} + +// dump is the main workhorse for dumping a value. It uses the passed reflect +// value to figure out what kind of object we are dealing with and formats it +// appropriately. It is a recursive function, however circular data structures +// are detected and handled properly. +func (d *dumpState) dump(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + d.w.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + d.indent() + d.dumpPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !d.ignoreNextType { + d.indent() + d.w.Write(openParenBytes) + d.w.Write([]byte(v.Type().String())) + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + d.ignoreNextType = false + + // Display length and capacity if the built-in len and cap functions + // work with the value's kind and the len/cap itself is non-zero. + valueLen, valueCap := 0, 0 + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + valueLen, valueCap = v.Len(), v.Cap() + case reflect.Map, reflect.String: + valueLen = v.Len() + } + if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { + d.w.Write(openParenBytes) + if valueLen != 0 { + d.w.Write(lenEqualsBytes) + printInt(d.w, int64(valueLen), 10) + } + if !d.cs.DisableCapacities && valueCap != 0 { + if valueLen != 0 { + d.w.Write(spaceBytes) + } + d.w.Write(capEqualsBytes) + printInt(d.w, int64(valueCap), 10) + } + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + + // Call Stringer/error interfaces if they exist and the handle methods flag + // is enabled + if !d.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(d.cs, d.w, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(d.w, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(d.w, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(d.w, v.Uint(), 10) + + case reflect.Float32: + printFloat(d.w, v.Float(), 32) + + case reflect.Float64: + printFloat(d.w, v.Float(), 64) + + case reflect.Complex64: + printComplex(d.w, v.Complex(), 32) + + case reflect.Complex128: + printComplex(d.w, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + d.dumpSlice(v) + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.String: + d.w.Write([]byte(strconv.Quote(v.String()))) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + d.w.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + numEntries := v.Len() + keys := v.MapKeys() + if d.cs.SortKeys { + sortValues(keys, d.cs) + } + for i, key := range keys { + d.dump(d.unpackValue(key)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.MapIndex(key))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Struct: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + vt := v.Type() + numFields := v.NumField() + for i := 0; i < numFields; i++ { + d.indent() + vtf := vt.Field(i) + d.w.Write([]byte(vtf.Name)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.Field(i))) + if i < (numFields - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(d.w, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(d.w, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it in case any new + // types are added. + default: + if v.CanInterface() { + fmt.Fprintf(d.w, "%v", v.Interface()) + } else { + fmt.Fprintf(d.w, "%v", v.String()) + } + } +} + +// fdump is a helper function to consolidate the logic from the various public +// methods which take varying writers and config states. +func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { + for _, arg := range a { + if arg == nil { + w.Write(interfaceBytes) + w.Write(spaceBytes) + w.Write(nilAngleBytes) + w.Write(newlineBytes) + continue + } + + d := dumpState{w: w, cs: cs} + d.pointers = make(map[uintptr]int) + d.dump(reflect.ValueOf(arg)) + d.w.Write(newlineBytes) + } +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func Fdump(w io.Writer, a ...interface{}) { + fdump(&Config, w, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(&Config, &buf, a...) + return buf.String() +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by an exported package global, +spew.Config. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func Dump(a ...interface{}) { + fdump(&Config, os.Stdout, a...) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go new file mode 100644 index 000000000..b04edb7d7 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/format.go @@ -0,0 +1,419 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "reflect" + "strconv" + "strings" +) + +// supportedFlags is a list of all the character flags supported by fmt package. +const supportedFlags = "0-+# " + +// formatState implements the fmt.Formatter interface and contains information +// about the state of a formatting operation. The NewFormatter function can +// be used to get a new Formatter which can be used directly as arguments +// in standard fmt package printing calls. +type formatState struct { + value interface{} + fs fmt.State + depth int + pointers map[uintptr]int + ignoreNextType bool + cs *ConfigState +} + +// buildDefaultFormat recreates the original format string without precision +// and width information to pass in to fmt.Sprintf in the case of an +// unrecognized type. Unless new types are added to the language, this +// function won't ever be called. +func (f *formatState) buildDefaultFormat() (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + buf.WriteRune('v') + + format = buf.String() + return format +} + +// constructOrigFormat recreates the original format string including precision +// and width information to pass along to the standard fmt package. This allows +// automatic deferral of all format strings this package doesn't support. +func (f *formatState) constructOrigFormat(verb rune) (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + if width, ok := f.fs.Width(); ok { + buf.WriteString(strconv.Itoa(width)) + } + + if precision, ok := f.fs.Precision(); ok { + buf.Write(precisionBytes) + buf.WriteString(strconv.Itoa(precision)) + } + + buf.WriteRune(verb) + + format = buf.String() + return format +} + +// unpackValue returns values inside of non-nil interfaces when possible and +// ensures that types for values which have been unpacked from an interface +// are displayed when the show types flag is also set. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (f *formatState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface { + f.ignoreNextType = false + if !v.IsNil() { + v = v.Elem() + } + } + return v +} + +// formatPtr handles formatting of pointers by indirecting them as necessary. +func (f *formatState) formatPtr(v reflect.Value) { + // Display nil if top level pointer is nil. + showTypes := f.fs.Flag('#') + if v.IsNil() && (!showTypes || f.ignoreNextType) { + f.fs.Write(nilAngleBytes) + return + } + + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range f.pointers { + if depth >= f.depth { + delete(f.pointers, k) + } + } + + // Keep list of all dereferenced pointers to possibly show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by derferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := f.pointers[addr]; ok && pd < f.depth { + cycleFound = true + indirects-- + break + } + f.pointers[addr] = f.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type or indirection level depending on flags. + if showTypes && !f.ignoreNextType { + f.fs.Write(openParenBytes) + f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) + f.fs.Write([]byte(ve.Type().String())) + f.fs.Write(closeParenBytes) + } else { + if nilFound || cycleFound { + indirects += strings.Count(ve.Type().String(), "*") + } + f.fs.Write(openAngleBytes) + f.fs.Write([]byte(strings.Repeat("*", indirects))) + f.fs.Write(closeAngleBytes) + } + + // Display pointer information depending on flags. + if f.fs.Flag('+') && (len(pointerChain) > 0) { + f.fs.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + f.fs.Write(pointerChainBytes) + } + printHexPtr(f.fs, addr) + } + f.fs.Write(closeParenBytes) + } + + // Display dereferenced value. + switch { + case nilFound: + f.fs.Write(nilAngleBytes) + + case cycleFound: + f.fs.Write(circularShortBytes) + + default: + f.ignoreNextType = true + f.format(ve) + } +} + +// format is the main workhorse for providing the Formatter interface. It +// uses the passed reflect value to figure out what kind of object we are +// dealing with and formats it appropriately. It is a recursive function, +// however circular data structures are detected and handled properly. +func (f *formatState) format(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + f.fs.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + f.formatPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !f.ignoreNextType && f.fs.Flag('#') { + f.fs.Write(openParenBytes) + f.fs.Write([]byte(v.Type().String())) + f.fs.Write(closeParenBytes) + } + f.ignoreNextType = false + + // Call Stringer/error interfaces if they exist and the handle methods + // flag is enabled. + if !f.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(f.cs, f.fs, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(f.fs, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(f.fs, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(f.fs, v.Uint(), 10) + + case reflect.Float32: + printFloat(f.fs, v.Float(), 32) + + case reflect.Float64: + printFloat(f.fs, v.Float(), 64) + + case reflect.Complex64: + printComplex(f.fs, v.Complex(), 32) + + case reflect.Complex128: + printComplex(f.fs, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + f.fs.Write(openBracketBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + numEntries := v.Len() + for i := 0; i < numEntries; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(v.Index(i))) + } + } + f.depth-- + f.fs.Write(closeBracketBytes) + + case reflect.String: + f.fs.Write([]byte(v.String())) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + f.fs.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + + f.fs.Write(openMapBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + keys := v.MapKeys() + if f.cs.SortKeys { + sortValues(keys, f.cs) + } + for i, key := range keys { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(key)) + f.fs.Write(colonBytes) + f.ignoreNextType = true + f.format(f.unpackValue(v.MapIndex(key))) + } + } + f.depth-- + f.fs.Write(closeMapBytes) + + case reflect.Struct: + numFields := v.NumField() + f.fs.Write(openBraceBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + vt := v.Type() + for i := 0; i < numFields; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + vtf := vt.Field(i) + if f.fs.Flag('+') || f.fs.Flag('#') { + f.fs.Write([]byte(vtf.Name)) + f.fs.Write(colonBytes) + } + f.format(f.unpackValue(v.Field(i))) + } + } + f.depth-- + f.fs.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(f.fs, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(f.fs, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it if any get added. + default: + format := f.buildDefaultFormat() + if v.CanInterface() { + fmt.Fprintf(f.fs, format, v.Interface()) + } else { + fmt.Fprintf(f.fs, format, v.String()) + } + } +} + +// Format satisfies the fmt.Formatter interface. See NewFormatter for usage +// details. +func (f *formatState) Format(fs fmt.State, verb rune) { + f.fs = fs + + // Use standard formatting for verbs that are not v. + if verb != 'v' { + format := f.constructOrigFormat(verb) + fmt.Fprintf(fs, format, f.value) + return + } + + if f.value == nil { + if fs.Flag('#') { + fs.Write(interfaceBytes) + } + fs.Write(nilAngleBytes) + return + } + + f.format(reflect.ValueOf(f.value)) +} + +// newFormatter is a helper function to consolidate the logic from the various +// public methods which take varying config states. +func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { + fs := &formatState{value: v, cs: cs} + fs.pointers = make(map[uintptr]int) + return fs +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +Printf, Println, or Fprintf. +*/ +func NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(&Config, v) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go new file mode 100644 index 000000000..32c0e3388 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/spew.go @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2013-2016 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "fmt" + "io" +) + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the formatted string as a value that satisfies error. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a default Formatter interface returned by NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b)) +func Print(a ...interface{}) (n int, err error) { + return fmt.Print(convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b)) +func Println(a ...interface{}) (n int, err error) { + return fmt.Println(convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprint(a ...interface{}) string { + return fmt.Sprint(convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintln(a ...interface{}) string { + return fmt.Sprintln(convertArgs(a)...) +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a default spew Formatter interface. +func convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = NewFormatter(arg) + } + return formatters +} diff --git a/vendor/github.com/getlantern/systray/.gitignore b/vendor/github.com/facchinm/systray/.gitignore similarity index 75% rename from vendor/github.com/getlantern/systray/.gitignore rename to vendor/github.com/facchinm/systray/.gitignore index ae7e06bd5..6fb7ba948 100644 --- a/vendor/github.com/getlantern/systray/.gitignore +++ b/vendor/github.com/facchinm/systray/.gitignore @@ -6,6 +6,3 @@ Release Debug *.sdf dll/systray_unsigned.dll -out.txt -.vs -on_exit*.txt diff --git a/vendor/github.com/getlantern/systray/LICENSE b/vendor/github.com/facchinm/systray/LICENSE similarity index 100% rename from vendor/github.com/getlantern/systray/LICENSE rename to vendor/github.com/facchinm/systray/LICENSE diff --git a/vendor/github.com/getlantern/systray/README.md b/vendor/github.com/facchinm/systray/README.md similarity index 62% rename from vendor/github.com/getlantern/systray/README.md rename to vendor/github.com/facchinm/systray/README.md index 626c132b1..b4f2c1a45 100644 --- a/vendor/github.com/getlantern/systray/README.md +++ b/vendor/github.com/facchinm/systray/README.md @@ -5,7 +5,7 @@ Tested on Windows 8, Mac OSX, Ubuntu 14.10 and Debian 7.6. ```go func main() { // Should be called at the very beginning of main(). - systray.Run(onReady, onExit) + systray.Run(onReady) } func onReady() { @@ -13,13 +13,6 @@ func onReady() { systray.SetTitle("Awesome App") systray.SetTooltip("Pretty awesome超级棒") mQuit := systray.AddMenuItem("Quit", "Quit the whole app") - - // Sets the icon of a menu item. Only available on Mac. - mQuit.SetIcon(icon.Data) -} - -func onExit() { - // clean up here } ``` Menu item can be checked and / or disabled. Methods except `Run()` can be invoked from any goroutine. See demo code under `example` folder. @@ -33,6 +26,20 @@ sudo apt-get install libgtk-3-dev libappindicator3-dev ``` Checked menu item not implemented on Linux yet. +### Windows + +Use the Visual Studio solution to build systray.dll. Make sure to target Windows +XP and build for Release (not Debug). Put the resulting dll in +`dll/systray_unsigned.dll` and then run `./signdll.bash` to sign it. Check the +resulting dll into git at Git at dll/systray.dll and run ./embeddll.bash to +generate the systraydll_windows.go file. + +The solution is configured to build with platform toolset v90 and dynamic +linking to save on size and support Windows XP. To get platform toolset v90, +you need to install Visual Studio 2008 (express edition is okay). You can +build with a more recent Visual Studio, you just need the old one for the +toolset. + ## Try Under `example` folder. diff --git a/vendor/github.com/facchinm/systray/embeddll.bash b/vendor/github.com/facchinm/systray/embeddll.bash new file mode 100755 index 000000000..7efbd7b29 --- /dev/null +++ b/vendor/github.com/facchinm/systray/embeddll.bash @@ -0,0 +1,10 @@ +#!/bin/bash + +############################################################################### +# +# This script regenerates the source file that embeds systray.dll +# +############################################################################### + +go get github.com/jteeuwen/go-bindata/go-bindata +go-bindata -nomemcopy -nocompress -pkg systray -prefix dll -o systraydll_windows.go dll \ No newline at end of file diff --git a/vendor/github.com/facchinm/systray/signdll.bash b/vendor/github.com/facchinm/systray/signdll.bash new file mode 100755 index 000000000..1b0a11932 --- /dev/null +++ b/vendor/github.com/facchinm/systray/signdll.bash @@ -0,0 +1,19 @@ +#!/bin/bash + +if [ -z "$BNS_CERT" ] +then + die "$0: Please set BNS_CERT to the bns signing certificate for windows" +fi + +if [ -z "$BNS_CERT_PASS" ] +then + die "$0: Please set BNS_CERT_PASS to the password for the $BNS_CERT signing key" +fi + +which osslsigncode > /dev/null +if [ $? -ne 0 ] +then + echo "Installing osslsigncode" + brew install osslsigncode || die "Could not install osslsigncode" +fi +osslsigncode sign -pkcs12 "$BNS_CERT" -pass "$BNS_CERT_PASS" -in dll/systray_unsigned.dll -out dll/systray.dll || die "Could not sign windows dll" diff --git a/vendor/github.com/getlantern/systray/systray.go b/vendor/github.com/facchinm/systray/systray.go similarity index 55% rename from vendor/github.com/getlantern/systray/systray.go rename to vendor/github.com/facchinm/systray/systray.go index d43317323..b3e7c827f 100644 --- a/vendor/github.com/getlantern/systray/systray.go +++ b/vendor/github.com/facchinm/systray/systray.go @@ -1,9 +1,7 @@ /* -Package systray is a cross platfrom Go library to place an icon and menu in the -notification area. +Package systray is a cross platfrom Go library to place an icon and menu in the notification area. Supports Windows, Mac OSX and Linux currently. -Methods can be called from any goroutine except Run(), which should be called -at the very beginning of main() to lock at main thread. +Methods can be called from any goroutine except Run(), which should be called at the very beginning of main() to lock at main thread. */ package systray @@ -15,16 +13,11 @@ import ( "github.com/getlantern/golog" ) -var ( - hasStarted = int64(0) - hasQuit = int64(0) -) - // MenuItem is used to keep track each menu item of systray // Don't create it directly, use the one systray.AddMenuItem() returned type MenuItem struct { // ClickedCh is the channel which will be notified when the menu item is clicked - ClickedCh chan struct{} + ClickedCh chan interface{} // id uniquely identify a menu item, not supposed to be modified id int32 @@ -41,121 +34,81 @@ type MenuItem struct { var ( log = golog.LoggerFor("systray") - systrayReady func() - systrayExit func() + readyCh = make(chan interface{}) + clickedCh = make(chan interface{}) menuItems = make(map[int32]*MenuItem) menuItemsLock sync.RWMutex - currentID = int32(-1) + currentId int32 ) // Run initializes GUI and starts the event loop, then invokes the onReady // callback. // It blocks until systray.Quit() is called. // Should be called at the very beginning of main() to lock at main thread. -func Run(onReady func(), onExit func()) { +func Run(onReady func()) { runtime.LockOSThread() - atomic.StoreInt64(&hasStarted, 1) - - if onReady == nil { - systrayReady = func() {} - } else { - // Run onReady on separate goroutine to avoid blocking event loop - readyCh := make(chan interface{}) - go func() { - <-readyCh - onReady() - }() - systrayReady = func() { - close(readyCh) - } - } - - // unlike onReady, onExit runs in the event loop to make sure it has time to - // finish before the process terminates - if onExit == nil { - onExit = func() {} - } - systrayExit = onExit + go func() { + <-readyCh + onReady() + }() nativeLoop() } // Quit the systray func Quit() { - if atomic.LoadInt64(&hasStarted) == 1 && atomic.CompareAndSwapInt64(&hasQuit, 0, 1) { - quit() - } + quit() } -// AddMenuItem adds menu item with designated title and tooltip, returning a channel -// that notifies whenever that menu item is clicked. +// Add menu item with designated title and tooltip, returning a channel that +// notifies whenever that menu item has been clicked. +// +// Menu items are keyed to an id. If the same id is added twice, the 2nd one +// overwrites the first. // -// It can be safely invoked from different goroutines. +// AddMenuItem can be safely invoked from different goroutines. func AddMenuItem(title string, tooltip string) *MenuItem { - id := atomic.AddInt32(¤tID, 1) + id := atomic.AddInt32(¤tId, 1) item := &MenuItem{nil, id, title, tooltip, false, false} - item.ClickedCh = make(chan struct{}) + item.ClickedCh = make(chan interface{}) item.update() return item } -// AddSeparator adds a separator bar to the menu -func AddSeparator() { - addSeparator(atomic.AddInt32(¤tID, 1)) -} - -// SetTitle set the text to display on a menu item func (item *MenuItem) SetTitle(title string) { item.title = title item.update() } -// SetTooltip set the tooltip to show when mouse hover func (item *MenuItem) SetTooltip(tooltip string) { item.tooltip = tooltip item.update() } -// Disabled checkes if the menu item is disabled func (item *MenuItem) Disabled() bool { return item.disabled } -// Enable a menu item regardless if it's previously enabled or not func (item *MenuItem) Enable() { item.disabled = false item.update() } -// Disable a menu item regardless if it's previously disabled or not func (item *MenuItem) Disable() { item.disabled = true item.update() } -// Hide hides a menu item -func (item *MenuItem) Hide() { - hideMenuItem(item) -} - -// Show shows a previously hidden menu item -func (item *MenuItem) Show() { - showMenuItem(item) -} - -// Checked returns if the menu item has a check mark func (item *MenuItem) Checked() bool { return item.checked } -// Check a menu item regardless if it's previously checked or not func (item *MenuItem) Check() { item.checked = true item.update() } -// Uncheck a menu item regardless if it's previously unchecked or not func (item *MenuItem) Uncheck() { item.checked = false item.update() @@ -169,12 +122,16 @@ func (item *MenuItem) update() { addOrUpdateMenuItem(item) } +func systrayReady() { + readyCh <- nil +} + func systrayMenuItemSelected(id int32) { menuItemsLock.RLock() item := menuItems[id] menuItemsLock.RUnlock() select { - case item.ClickedCh <- struct{}{}: + case item.ClickedCh <- nil: // in case no one waiting for the channel default: } diff --git a/vendor/github.com/getlantern/systray/systray.h b/vendor/github.com/facchinm/systray/systray.h similarity index 62% rename from vendor/github.com/getlantern/systray/systray.h rename to vendor/github.com/facchinm/systray/systray.h index 36bcf9893..819b65ff7 100644 --- a/vendor/github.com/getlantern/systray/systray.h +++ b/vendor/github.com/facchinm/systray/systray.h @@ -1,14 +1,9 @@ extern void systray_ready(); -extern void systray_on_exit(); extern void systray_menu_item_selected(int menu_id); int nativeLoop(void); void setIcon(const char* iconBytes, int length); -void setMenuItemIcon(const char* iconBytes, int length, int menuId); void setTitle(char* title); void setTooltip(char* tooltip); void add_or_update_menu_item(int menuId, char* title, char* tooltip, short disabled, short checked); -void add_separator(int menuId); -void hide_menu_item(int menuId); -void show_menu_item(int menuId); void quit(); diff --git a/vendor/github.com/getlantern/systray/systray_darwin.m b/vendor/github.com/facchinm/systray/systray_darwin.m similarity index 67% rename from vendor/github.com/getlantern/systray/systray_darwin.m rename to vendor/github.com/facchinm/systray/systray_darwin.m index a489bc477..f266cf13a 100644 --- a/vendor/github.com/getlantern/systray/systray_darwin.m +++ b/vendor/github.com/facchinm/systray/systray_darwin.m @@ -52,17 +52,13 @@ - (IBAction)menuHandler:(id)sender; - (void)applicationDidFinishLaunching:(NSNotification *)aNotification { self->statusItem = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength]; - self->menu = [[NSMenu alloc] init]; + NSZone *menuZone = [NSMenu menuZone]; + self->menu = [[NSMenu allocWithZone:menuZone] init]; [self->menu setAutoenablesItems: FALSE]; [self->statusItem setMenu:self->menu]; systray_ready(); } -- (void)applicationWillTerminate:(NSNotification *)aNotification -{ - systray_on_exit(); -} - - (void)setIcon:(NSImage *)image { [statusItem setImage:image]; } @@ -108,49 +104,9 @@ - (void) add_or_update_menu_item:(MenuItem*) item } } -- (void) add_separator:(NSNumber*) menuId -{ - [menu addItem: [NSMenuItem separatorItem]]; -} - -- (void) hide_menu_item:(NSNumber*) menuId -{ - NSMenuItem* menuItem; - int existedMenuIndex = [menu indexOfItemWithRepresentedObject: menuId]; - if (existedMenuIndex == -1) { - return; - } - menuItem = [menu itemAtIndex: existedMenuIndex]; - [menuItem setHidden:TRUE]; -} - -- (void)setMenuItemIcon:(NSArray*)imageAndMenuId { - NSImage* image = [imageAndMenuId objectAtIndex:0]; - NSNumber* menuId = [imageAndMenuId objectAtIndex:1]; - - NSMenuItem* menuItem; - int existedMenuIndex = [menu indexOfItemWithRepresentedObject: menuId]; - if (existedMenuIndex == -1) { - return; - } - menuItem = [menu itemAtIndex: existedMenuIndex]; - menuItem.image = image; -} - -- (void) show_menu_item:(NSNumber*) menuId -{ - NSMenuItem* menuItem; - int existedMenuIndex = [menu indexOfItemWithRepresentedObject: menuId]; - if (existedMenuIndex == -1) { - return; - } - menuItem = [menu itemAtIndex: existedMenuIndex]; - [menuItem setHidden:FALSE]; -} - - (void) quit { - [NSApp terminate:self]; + [[NSStatusBar systemStatusBar] removeStatusItem: statusItem]; } @end @@ -172,19 +128,9 @@ void runInMainThread(SEL method, id object) { void setIcon(const char* iconBytes, int length) { NSData* buffer = [NSData dataWithBytes: iconBytes length:length]; NSImage *image = [[NSImage alloc] initWithData:buffer]; - [image setSize:NSMakeSize(16, 16)]; runInMainThread(@selector(setIcon:), (id)image); } -void setMenuItemIcon(const char* iconBytes, int length, int menuId) { - NSData* buffer = [NSData dataWithBytes: iconBytes length:length]; - NSImage *image = [[NSImage alloc] initWithData:buffer]; - [image setSize:NSMakeSize(16, 16)]; - - NSNumber *mId = [NSNumber numberWithInt:menuId]; - runInMainThread(@selector(setMenuItemIcon:), @[image, (id)mId]); -} - void setTitle(char* ctitle) { NSString* title = [[NSString alloc] initWithCString:ctitle encoding:NSUTF8StringEncoding]; @@ -206,21 +152,6 @@ void add_or_update_menu_item(int menuId, char* title, char* tooltip, short disab runInMainThread(@selector(add_or_update_menu_item:), (id)item); } -void add_separator(int menuId) { - NSNumber *mId = [NSNumber numberWithInt:menuId]; - runInMainThread(@selector(add_separator:), (id)mId); -} - -void hide_menu_item(int menuId) { - NSNumber *mId = [NSNumber numberWithInt:menuId]; - runInMainThread(@selector(hide_menu_item:), (id)mId); -} - -void show_menu_item(int menuId) { - NSNumber *mId = [NSNumber numberWithInt:menuId]; - runInMainThread(@selector(show_menu_item:), (id)mId); -} - void quit() { runInMainThread(@selector(quit), nil); } diff --git a/vendor/github.com/getlantern/systray/systray_linux.c b/vendor/github.com/facchinm/systray/systray_linux.c similarity index 74% rename from vendor/github.com/getlantern/systray/systray_linux.c rename to vendor/github.com/facchinm/systray/systray_linux.c index a34c2672a..4e31eda78 100644 --- a/vendor/github.com/getlantern/systray/systray_linux.c +++ b/vendor/github.com/facchinm/systray/systray_linux.c @@ -34,7 +34,6 @@ int nativeLoop(void) { global_temp_icon_file_names = g_array_new(TRUE, FALSE, sizeof(char*)); systray_ready(); gtk_main(); - systray_on_exit(); return 0; } @@ -101,7 +100,7 @@ gboolean do_add_or_update_menu_item(gpointer data) { } GtkWidget * menu_item = GTK_WIDGET(((MenuItemNode*)(it->data))->menu_item); gtk_widget_set_sensitive(menu_item, mii->disabled == 1 ? FALSE : TRUE); - gtk_widget_show(menu_item); + gtk_widget_show_all(global_tray_menu); free(mii->title); free(mii->tooltip); @@ -109,41 +108,6 @@ gboolean do_add_or_update_menu_item(gpointer data) { return FALSE; } -gboolean do_add_separator(gpointer data) { - GtkWidget *separator = gtk_separator_menu_item_new(); - gtk_menu_shell_append(GTK_MENU_SHELL(global_tray_menu), separator); - gtk_widget_show(separator); - return FALSE; -} - -// runs in main thread, should always return FALSE to prevent gtk to execute it again -gboolean do_hide_menu_item(gpointer data) { - MenuItemInfo *mii = (MenuItemInfo*)data; - GList* it; - for(it = global_menu_items; it != NULL; it = it->next) { - MenuItemNode* item = (MenuItemNode*)(it->data); - if(item->menu_id == mii->menu_id){ - gtk_widget_hide(GTK_WIDGET(item->menu_item)); - break; - } - } - return FALSE; -} - -// runs in main thread, should always return FALSE to prevent gtk to execute it again -gboolean do_show_menu_item(gpointer data) { - MenuItemInfo *mii = (MenuItemInfo*)data; - GList* it; - for(it = global_menu_items; it != NULL; it = it->next) { - MenuItemNode* item = (MenuItemNode*)(it->data); - if(item->menu_id == mii->menu_id){ - gtk_widget_show(GTK_WIDGET(item->menu_item)); - break; - } - } - return FALSE; -} - // runs in main thread, should always return FALSE to prevent gtk to execute it again gboolean do_quit(gpointer data) { int i; @@ -159,7 +123,6 @@ gboolean do_quit(gpointer data) { } // app indicator doesn't provide a way to remove it, hide it as a workaround app_indicator_set_status(global_app_indicator, APP_INDICATOR_STATUS_PASSIVE); - gtk_main_quit(); return FALSE; } @@ -177,9 +140,6 @@ void setTooltip(char* ctooltip) { free(ctooltip); } -void setMenuItemIcon(const char* iconBytes, int length, int menuId) { -} - void add_or_update_menu_item(int menu_id, char* title, char* tooltip, short disabled, short checked) { MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); mii->menu_id = menu_id; @@ -190,24 +150,6 @@ void add_or_update_menu_item(int menu_id, char* title, char* tooltip, short disa g_idle_add(do_add_or_update_menu_item, mii); } -void add_separator(int menu_id) { - MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); - mii->menu_id = menu_id; - g_idle_add(do_add_separator, mii); -} - -void hide_menu_item(int menu_id) { - MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); - mii->menu_id = menu_id; - g_idle_add(do_hide_menu_item, mii); -} - -void show_menu_item(int menu_id) { - MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); - mii->menu_id = menu_id; - g_idle_add(do_show_menu_item, mii); -} - void quit() { g_idle_add(do_quit, NULL); } diff --git a/vendor/github.com/getlantern/systray/systray_nonwindows.go b/vendor/github.com/facchinm/systray/systray_nonwindows.go similarity index 56% rename from vendor/github.com/getlantern/systray/systray_nonwindows.go rename to vendor/github.com/facchinm/systray/systray_nonwindows.go index 4868b554d..a152b61e5 100644 --- a/vendor/github.com/getlantern/systray/systray_nonwindows.go +++ b/vendor/github.com/facchinm/systray/systray_nonwindows.go @@ -4,7 +4,7 @@ package systray /* #cgo linux pkg-config: gtk+-3.0 appindicator3-0.1 -#cgo darwin CFLAGS: -DDARWIN -x objective-c -fobjc-arc +#cgo darwin CFLAGS: -DDARWIN -x objective-c -fobjc-arc -mmacosx-version-min=10.7 #cgo darwin LDFLAGS: -framework Cocoa #include "systray.h" @@ -36,18 +36,18 @@ func SetTitle(title string) { C.setTitle(C.CString(title)) } -// SetTooltip sets the systray tooltip to display on mouse hover of the tray icon, +// SetTitle sets the systray tooltip to display on mouse hover of the tray icon, // only available on Mac and Windows. func SetTooltip(tooltip string) { C.setTooltip(C.CString(tooltip)) } func addOrUpdateMenuItem(item *MenuItem) { - var disabled C.short + var disabled C.short = 0 if item.disabled { disabled = 1 } - var checked C.short + var checked C.short = 0 if item.checked { checked = 1 } @@ -60,40 +60,12 @@ func addOrUpdateMenuItem(item *MenuItem) { ) } -// SetIcon sets the icon of a menu item. Only available on Mac. -// iconBytes should be the content of .ico/.jpg/.png -func (item *MenuItem) SetIcon(iconBytes []byte) { - cstr := (*C.char)(unsafe.Pointer(&iconBytes[0])) - C.setMenuItemIcon(cstr, (C.int)(len(iconBytes)), C.int(item.id)) -} - -func addSeparator(id int32) { - C.add_separator(C.int(id)) -} - -func hideMenuItem(item *MenuItem) { - C.hide_menu_item( - C.int(item.id), - ) -} - -func showMenuItem(item *MenuItem) { - C.show_menu_item( - C.int(item.id), - ) -} - //export systray_ready func systray_ready() { systrayReady() } -//export systray_on_exit -func systray_on_exit() { - systrayExit() -} - //export systray_menu_item_selected -func systray_menu_item_selected(cID C.int) { - systrayMenuItemSelected(int32(cID)) +func systray_menu_item_selected(cId C.int) { + systrayMenuItemSelected(int32(cId)) } diff --git a/vendor/github.com/facchinm/systray/systray_windows.go b/vendor/github.com/facchinm/systray/systray_windows.go new file mode 100644 index 000000000..ca42cb974 --- /dev/null +++ b/vendor/github.com/facchinm/systray/systray_windows.go @@ -0,0 +1,154 @@ +package systray + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "syscall" + "unsafe" + + "github.com/getlantern/filepersist" +) + +var ( + iconFiles = make([]*os.File, 0) + dllDir = filepath.Join(os.Getenv("APPDATA"), "systray") + dllFile = filepath.Join(dllDir, "systray.dll") + + mod = syscall.NewLazyDLL(dllFile) + _nativeLoop = mod.NewProc("nativeLoop") + _quit = mod.NewProc("quit") + _setIcon = mod.NewProc("setIcon") + _setTitle = mod.NewProc("setTitle") + _setTooltip = mod.NewProc("setTooltip") + _add_or_update_menu_item = mod.NewProc("add_or_update_menu_item") +) + +func init() { + // Write DLL to file + b, err := Asset("systray.dll") + if err != nil { + panic(fmt.Errorf("Unable to read systray.dll: %v", err)) + } + + err = os.MkdirAll(dllDir, 0755) + if err != nil { + panic(fmt.Errorf("Unable to create directory %v to hold systray.dll: %v", dllDir, err)) + } + + err = filepersist.Save(dllFile, b, 0644) + if err != nil { + panic(fmt.Errorf("Unable to save systray.dll to %v: %v", dllFile, err)) + } +} + +func nativeLoop() { + _nativeLoop.Call( + syscall.NewCallbackCDecl(systray_ready), + syscall.NewCallbackCDecl(systray_menu_item_selected)) +} + +func quit() { + _quit.Call() + for _, f := range iconFiles { + err := os.Remove(f.Name()) + if err != nil { + log.Debugf("Unable to delete temporary icon file %v: %v", f.Name(), err) + } + } +} + +// SetIcon sets the systray icon. +// iconBytes should be the content of .ico for windows and .ico/.jpg/.png +// for other platforms. +func SetIcon(iconBytes []byte) { + f, err := ioutil.TempFile("", "systray_temp_icon") + if err != nil { + log.Errorf("Unable to create temp icon: %v", err) + return + } + defer f.Close() + _, err = f.Write(iconBytes) + if err != nil { + log.Errorf("Unable to write icon to temp file %v: %v", f.Name(), f) + return + } + // Need to close file before we load it to make sure contents is flushed. + f.Close() + name, err := strUTF16(f.Name()) + if err != nil { + log.Errorf("Unable to convert name to string pointer: %v", err) + return + } + _setIcon.Call(name.Raw()) +} + +// SetTitle sets the systray title, only available on Mac. +func SetTitle(title string) { + // do nothing +} + +// SetTooltip sets the systray tooltip to display on mouse hover of the tray icon, +// only available on Mac and Windows. +func SetTooltip(tooltip string) { + t, err := strUTF16(tooltip) + if err != nil { + log.Errorf("Unable to convert tooltip to string pointer: %v", err) + return + } + _setTooltip.Call(t.Raw()) +} + +func addOrUpdateMenuItem(item *MenuItem) { + var disabled = 0 + if item.disabled { + disabled = 1 + } + var checked = 0 + if item.checked { + checked = 1 + } + title, err := strUTF16(item.title) + if err != nil { + log.Errorf("Unable to convert title to string pointer: %v", err) + return + } + tooltip, err := strUTF16(item.tooltip) + if err != nil { + log.Errorf("Unable to convert tooltip to string pointer: %v", err) + return + } + _add_or_update_menu_item.Call( + uintptr(item.id), + title.Raw(), + tooltip.Raw(), + uintptr(disabled), + uintptr(checked), + ) +} + +type utf16 []uint16 + +// Raw returns the underlying *wchar_t of an utf16 so we can pass to DLL +func (u utf16) Raw() uintptr { + return uintptr(unsafe.Pointer(&u[0])) +} + +// strUTF16 converts a Go string into a utf16 byte sequence +func strUTF16(s string) (utf16, error) { + return syscall.UTF16FromString(s) +} + +// systray_ready takes an ignored parameter just so we can compile a callback +// (for some reason in Go 1.4.x, syscall.NewCallback panics if there's no +// parameter to the function). +func systray_ready(ignore uintptr) uintptr { + systrayReady() + return 0 +} + +func systray_menu_item_selected(id uintptr) uintptr { + systrayMenuItemSelected(int32(id)) + return 0 +} diff --git a/vendor/github.com/facchinm/systray/systraydll_windows.go b/vendor/github.com/facchinm/systray/systraydll_windows.go new file mode 100644 index 000000000..465ca2892 --- /dev/null +++ b/vendor/github.com/facchinm/systray/systraydll_windows.go @@ -0,0 +1,233 @@ +package systray + +import ( + "fmt" + "reflect" + "strings" + "unsafe" + "os" + "time" + "io/ioutil" + "path" + "path/filepath" +) + +func bindata_read(data, name string) ([]byte, error) { + var empty [0]byte + sx := (*reflect.StringHeader)(unsafe.Pointer(&data)) + b := empty[:] + bx := (*reflect.SliceHeader)(unsafe.Pointer(&b)) + bx.Data = sx.Data + bx.Len = len(data) + bx.Cap = bx.Len + return b, nil +} + +type asset struct { + bytes []byte + info os.FileInfo +} + +type bindata_file_info struct { + name string + size int64 + mode os.FileMode + modTime time.Time +} + +func (fi bindata_file_info) Name() string { + return fi.name +} +func (fi bindata_file_info) Size() int64 { + return fi.size +} +func (fi bindata_file_info) Mode() os.FileMode { + return fi.mode +} +func (fi bindata_file_info) ModTime() time.Time { + return fi.modTime +} +func (fi bindata_file_info) IsDir() bool { + return false +} +func (fi bindata_file_info) Sys() interface{} { + return nil +} + +var _systray_dll = "\x4d\x5a\x90\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x0e\x1f\xba\x0e\x00\xb4\x09\xcd\x21\xb8\x01\x4c\xcd\x21\x54\x68\x69\x73\x20\x70\x72\x6f\x67\x72\x61\x6d\x20\x63\x61\x6e\x6e\x6f\x74\x20\x62\x65\x20\x72\x75\x6e\x20\x69\x6e\x20\x44\x4f\x53\x20\x6d\x6f\x64\x65\x2e\x0d\x0d\x0a\x24\x00\x00\x00\x00\x00\x00\x00\x2c\xc1\x75\x30\x68\xa0\x1b\x63\x68\xa0\x1b\x63\x68\xa0\x1b\x63\x76\xf2\x9f\x63\x76\xa0\x1b\x63\x76\xf2\x8e\x63\x78\xa0\x1b\x63\x76\xf2\x98\x63\x35\xa0\x1b\x63\x4f\x66\x60\x63\x6f\xa0\x1b\x63\x68\xa0\x1a\x63\x02\xa0\x1b\x63\x76\xf2\x91\x63\x6b\xa0\x1b\x63\x76\xf2\x89\x63\x69\xa0\x1b\x63\x76\xf2\x8a\x63\x69\xa0\x1b\x63\x52\x69\x63\x68\x68\xa0\x1b\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x45\x00\x00\x4c\x01\x05\x00\x6d\x78\xee\x54\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x02\x21\x0b\x01\x09\x00\x00\x92\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x50\x19\x00\x00\x00\x10\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x10\x00\x10\x00\x00\x00\x02\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x30\x01\x00\x00\x04\x00\x00\xda\x4f\x01\x00\x02\x00\x40\x01\x00\x00\x10\x00\x00\x10\x00\x00\x00\x00\x10\x00\x00\x10\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x70\xd1\x00\x00\xa1\x00\x00\x00\x14\xc9\x00\x00\x50\x00\x00\x00\x00\x10\x01\x00\xb4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\x00\x68\x11\x00\x00\x00\x20\x01\x00\xb4\x08\x00\x00\xb0\xb1\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\xc4\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x78\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x74\x65\x78\x74\x00\x00\x00\x64\x90\x00\x00\x00\x10\x00\x00\x00\x92\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x60\x2e\x72\x64\x61\x74\x61\x00\x00\x11\x22\x00\x00\x00\xb0\x00\x00\x00\x24\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x40\x2e\x64\x61\x74\x61\x00\x00\x00\x68\x2e\x00\x00\x00\xe0\x00\x00\x00\x10\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\xc0\x2e\x72\x73\x72\x63\x00\x00\x00\xb4\x01\x00\x00\x00\x10\x01\x00\x00\x02\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x40\x2e\x72\x65\x6c\x6f\x63\x00\x00\x1c\x0f\x00\x00\x00\x20\x01\x00\x00\x10\x00\x00\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\xc2\x0c\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xec\x0c\x56\x8b\xf0\x8d\x45\xf8\x50\xff\x15\x6c\xb1\x00\x10\x85\xc0\x75\x38\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x00\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x36\x05\x00\x00\x83\xc4\x10\x5e\x8b\xe5\x5d\xc3\x56\xff\x15\x68\xb1\x00\x10\x8b\x4d\xfc\x8b\x55\xf8\xa1\x48\xf9\x00\x10\x6a\x00\x56\x6a\x00\x51\x52\x6a\x20\x50\xff\x15\x64\xb1\x00\x10\x5e\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xe4\xf8\x8b\x4d\x0c\x83\xec\x34\x8b\xc1\x83\xe8\x02\x56\x0f\x84\xe9\x00\x00\x00\x2d\x24\x01\x00\x00\x74\x5e\x2d\xdb\x02\x00\x00\x74\x1a\x8b\x45\x14\x8b\x55\x10\x50\x8b\x45\x08\x52\x51\x50\xff\x15\x58\xb1\x00\x10\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x4d\x14\x8b\xc1\x2d\x02\x02\x00\x00\x74\x20\x83\xe8\x03\x74\x1b\x8b\x55\x08\x51\x8b\x4d\x10\x51\x68\x01\x04\x00\x00\x52\xff\x15\x58\xb1\x00\x10\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x45\x08\xe8\x0c\xff\xff\xff\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x4d\x10\x8b\x15\x48\xf9\x00\x10\x8d\x44\x24\x08\x50\x6a\x01\x51\x52\xc7\x44\x24\x18\x30\x00\x00\x00\xc7\x44\x24\x1c\x20\x00\x00\x00\xff\x15\x60\xb1\x00\x10\x85\xc0\x75\x3c\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x18\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x24\x04\x00\x00\x83\xc4\x10\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x44\x24\x28\x83\xf8\xff\x74\x1b\x50\xff\x15\x44\xf9\x00\x10\x83\xc4\x04\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x6a\x00\xff\x15\x5c\xb1\x00\x10\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xec\x30\x56\x8b\x35\x54\xb1\x00\x10\x68\x00\x7f\x00\x00\x6a\x00\xc7\x45\xd0\x30\x00\x00\x00\xc7\x45\xd4\x03\x00\x00\x00\xc7\x45\xd8\x90\x10\x00\x10\xc7\x45\xdc\x00\x00\x00\x00\xc7\x45\xe0\x00\x00\x00\x00\x89\x45\xe4\xff\xd6\x68\x00\x7f\x00\x00\x6a\x00\x89\x45\xe8\xff\x15\x50\xb1\x00\x10\x68\x00\x7f\x00\x00\x6a\x00\x89\x45\xec\xc7\x45\xf0\x06\x00\x00\x00\xc7\x45\xf4\x00\x00\x00\x00\xc7\x45\xf8\x30\xc4\x00\x10\xff\xd6\x8d\x4d\xd0\x51\x89\x45\xfc\xff\x15\x4c\xb1\x00\x10\x5e\x8b\xe5\x5d\xc3\xcc\xa1\x4c\xf9\x00\x10\x68\x50\xf9\x00\x10\x6a\x00\xc7\x05\x50\xf9\x00\x10\xbc\x03\x00\x00\xa3\x54\xf9\x00\x10\xc7\x05\x58\xf9\x00\x10\x64\x00\x00\x00\xc7\x05\x60\xf9\x00\x10\x01\x04\x00\x00\xc7\x05\x5c\xf9\x00\x10\x01\x00\x00\x00\xff\x15\x18\xb1\x00\x10\xc3\x55\x8b\xec\x8b\x45\x0c\x83\xec\x38\x56\x6a\x00\xa3\x44\xf9\x00\x10\xff\x15\x08\xb0\x00\x10\x8b\xf0\xe8\x22\xff\xff\xff\x6a\x00\x56\x6a\x00\x6a\x00\x6a\x00\x68\x00\x00\x00\x80\x6a\x00\x68\x00\x00\x00\x80\x68\x00\x00\xcf\x00\x68\x2c\xc4\x00\x10\x68\x30\xc4\x00\x10\x6a\x00\xff\x15\x48\xb1\x00\x10\x8b\xf0\x85\xf6\x74\x10\x6a\x00\x56\xff\x15\x44\xb1\x00\x10\x56\xff\x15\x70\xb1\x00\x10\x89\x35\x4c\xf9\x00\x10\x85\xf6\x0f\x84\x89\x00\x00\x00\xff\x15\x40\xb1\x00\x10\x8d\x4d\xe4\x51\x50\xa3\x48\xf9\x00\x10\xc7\x45\xe4\x1c\x00\x00\x00\xc7\x45\xe8\x10\x00\x00\x80\xc7\x45\xec\x00\x00\x00\x08\xff\x15\x3c\xb1\x00\x10\x85\xc0\x74\x5a\xe8\x1e\xff\xff\xff\x85\xc0\x74\x51\x6a\x00\xff\x55\x08\x8b\x35\x38\xb1\x00\x10\x83\xc4\x04\x6a\x00\x6a\x00\x6a\x00\x8d\x55\xc8\x52\xff\xd6\x85\xc0\x74\x2c\x53\x8b\x1d\x30\xb1\x00\x10\x57\x8b\x3d\x34\xb1\x00\x10\x8d\x45\xc8\x50\xff\xd7\x8d\x4d\xc8\x51\xff\xd3\x6a\x00\x6a\x00\x6a\x00\x8d\x55\xc8\x52\xff\xd6\x85\xc0\x75\xe4\x5f\x5b\x33\xc0\x5e\x8b\xe5\x5d\xc3\xb8\x01\x00\x00\x00\x5e\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x8b\x45\x08\x6a\x10\x6a\x40\x6a\x40\x6a\x01\x50\x6a\x00\xff\x15\x2c\xb1\x00\x10\x85\xc0\x75\x37\x56\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x4c\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\xc1\x01\x00\x00\x83\xc4\x10\x5e\x5d\xc3\x68\x50\xf9\x00\x10\x6a\x01\xa3\x64\xf9\x00\x10\xc7\x05\x5c\xf9\x00\x10\x02\x00\x00\x00\xff\x15\x18\xb1\x00\x10\x5d\xc3\x55\x8b\xec\x8b\x45\x08\x68\x80\x00\x00\x00\x50\x68\x80\x00\x00\x00\x68\x68\xf9\x00\x10\xe8\x47\x02\x00\x00\x83\xc4\x10\x68\x50\xf9\x00\x10\x6a\x01\xc7\x05\x5c\xf9\x00\x10\x04\x00\x00\x00\xff\x15\x18\xb1\x00\x10\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xe4\xf8\x83\xec\x64\x8b\x45\x0c\x53\x56\x57\x33\xff\xc7\x44\x24\x10\x30\x00\x00\x00\xc7\x44\x24\x14\x61\x01\x00\x00\x89\x7c\x24\x18\x89\x44\x24\x34\x8d\x50\x02\x8d\x64\x24\x00\x66\x8b\x08\x83\xc0\x02\x66\x3b\xcf\x75\xf5\x2b\xc2\xd1\xf8\x40\x89\x44\x24\x38\x8b\x45\x08\x89\x44\x24\x30\xb8\x01\x00\x00\x00\x89\x7c\x24\x1c\x66\x39\x45\x14\x75\x08\xc7\x44\x24\x1c\x03\x00\x00\x00\x66\x39\x45\x18\x75\x05\x83\x4c\x24\x1c\x08\x8b\x0d\x48\xf9\x00\x10\x51\xff\x15\x28\xb1\x00\x10\x8b\xf0\x3b\xfe\x89\x74\x24\x0c\x0f\x8d\x91\x00\x00\x00\x8b\x1d\x00\xb0\x00\x10\x8b\xff\xa1\x48\xf9\x00\x10\x8d\x54\x24\x40\x52\x6a\x01\x57\x50\xc7\x44\x24\x50\x30\x00\x00\x00\xc7\x44\x24\x54\x20\x00\x00\x00\xff\x15\x60\xb1\x00\x10\x85\xc0\x75\x35\xff\xd3\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x18\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x79\x00\x00\x00\x8b\x74\x24\x1c\x83\xc4\x10\xeb\x0e\x8b\x44\x24\x60\x83\xf8\xff\x74\x05\x39\x45\x08\x74\x07\x47\x3b\xfe\x7c\x90\xeb\x15\x8b\x15\x48\xf9\x00\x10\x8d\x4c\x24\x10\x51\x6a\x01\x57\x52\xff\x15\x24\xb1\x00\x10\x3b\xfe\x75\x16\x8b\x0d\x48\xf9\x00\x10\x8d\x44\x24\x10\x50\x6a\x01\x6a\xff\x51\xff\x15\x20\xb1\x00\x10\x5f\x5e\x5b\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x68\x50\xf9\x00\x10\x6a\x02\xff\x15\x18\xb1\x00\x10\xc3\x3b\x0d\x00\xe0\x00\x10\x75\x02\xf3\xc3\xe9\xe6\x03\x00\x00\x6a\x0c\x68\x60\xc5\x00\x10\xe8\x13\x16\x00\x00\x33\xc0\x33\xf6\x39\x75\x08\x0f\x95\xc0\x3b\xc6\x75\x1d\xe8\xb6\x15\x00\x00\xc7\x00\x16\x00\x00\x00\x56\x56\x56\x56\x56\xe8\x3e\x15\x00\x00\x83\xc4\x14\x83\xc8\xff\xeb\x5f\xe8\xb0\x04\x00\x00\x6a\x20\x5b\x03\xc3\x50\x6a\x01\xe8\xbb\x05\x00\x00\x59\x59\x89\x75\xfc\xe8\x99\x04\x00\x00\x03\xc3\x50\xe8\x46\x06\x00\x00\x59\x8b\xf8\x8d\x45\x0c\x50\x56\xff\x75\x08\xe8\x81\x04\x00\x00\x03\xc3\x50\xe8\x2b\x08\x00\x00\x89\x45\xe4\xe8\x71\x04\x00\x00\x03\xc3\x50\x57\xe8\xb9\x06\x00\x00\x83\xc4\x18\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\xc9\x15\x00\x00\xc3\xe8\x4b\x04\x00\x00\x83\xc0\x20\x50\x6a\x01\xe8\xc6\x05\x00\x00\x59\x59\xc3\xa1\x00\xe0\x00\x10\x83\xc8\x01\x33\xc9\x39\x05\xe0\xee\x00\x10\x0f\x94\xc1\x8b\xc1\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x57\x33\xff\x39\x7d\x14\x75\x10\x3b\xf7\x75\x10\x39\x7d\x0c\x75\x12\x33\xc0\x5f\x5e\x5b\x5d\xc3\x3b\xf7\x74\x07\x8b\x5d\x0c\x3b\xdf\x77\x1b\xe8\xde\x14\x00\x00\x6a\x16\x5e\x89\x30\x57\x57\x57\x57\x57\xe8\x67\x14\x00\x00\x83\xc4\x14\x8b\xc6\xeb\xd5\x39\x7d\x14\x75\x07\x33\xc0\x66\x89\x06\xeb\xc7\x8b\x55\x10\x3b\xd7\x75\x07\x33\xc0\x66\x89\x06\xeb\xcb\x83\x7d\x14\xff\x8b\xc6\x75\x14\x0f\xb7\x0a\x66\x89\x08\x40\x40\x42\x42\x66\x3b\xcf\x74\x26\x4b\x75\xee\xeb\x21\x0f\xb7\x0a\x66\x89\x08\x40\x40\x42\x42\x66\x3b\xcf\x74\x08\x4b\x74\x05\xff\x4d\x14\x75\xe9\x39\x7d\x14\x75\x05\x33\xc9\x66\x89\x08\x3b\xdf\x0f\x85\x74\xff\xff\xff\x33\xc0\x83\x7d\x14\xff\x75\x10\x8b\x4d\x0c\x6a\x50\x66\x89\x44\x4e\xfe\x58\xe9\x5e\xff\xff\xff\x66\x89\x06\xe8\x49\x14\x00\x00\x6a\x22\x59\x89\x08\x8b\xf1\xe9\x64\xff\xff\xff\x8b\xff\x55\x8b\xec\x8b\x45\x0c\x56\x57\x83\xf8\x01\x75\x7c\x50\xe8\x45\x28\x00\x00\x59\x85\xc0\x75\x07\x33\xc0\xe9\x0e\x01\x00\x00\xe8\xcf\x1a\x00\x00\x85\xc0\x75\x07\xe8\x5c\x28\x00\x00\xeb\xe9\xe8\xd8\x27\x00\x00\xff\x15\x4c\xb0\x00\x10\xa3\x64\x0e\x01\x10\xe8\x91\x26\x00\x00\xa3\xe8\xee\x00\x10\xe8\xb2\x20\x00\x00\x85\xc0\x7d\x07\xe8\x48\x17\x00\x00\xeb\xcf\xe8\xbc\x25\x00\x00\x85\xc0\x7c\x20\xe8\x3b\x23\x00\x00\x85\xc0\x7c\x17\x6a\x00\xe8\x6a\x1e\x00\x00\x59\x85\xc0\x75\x0b\xff\x05\xe4\xee\x00\x10\xe9\xa8\x00\x00\x00\xe8\xcd\x22\x00\x00\xeb\xc9\x33\xff\x3b\xc7\x75\x31\x39\x3d\xe4\xee\x00\x10\x7e\x81\xff\x0d\xe4\xee\x00\x10\x39\x3d\x6c\xf2\x00\x10\x75\x05\xe8\xf9\x1f\x00\x00\x39\x7d\x10\x75\x7b\xe8\xa0\x22\x00\x00\xe8\xe6\x16\x00\x00\xe8\xcb\x27\x00\x00\xeb\x6a\x83\xf8\x02\x75\x59\xe8\xa1\x16\x00\x00\x68\x14\x02\x00\x00\x6a\x01\xe8\x7d\x1c\x00\x00\x8b\xf0\x59\x59\x3b\xf7\x0f\x84\x36\xff\xff\xff\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\xfc\x15\x00\x00\x59\xff\xd0\x85\xc0\x74\x17\x57\x56\xe8\xda\x16\x00\x00\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\xeb\x18\x56\xe8\x68\x1b\x00\x00\x59\xe9\xfa\xfe\xff\xff\x83\xf8\x03\x75\x07\x57\xe8\x5c\x19\x00\x00\x59\x33\xc0\x40\x5f\x5e\x5d\xc2\x0c\x00\x6a\x0c\x68\x80\xc5\x00\x10\xe8\x46\x13\x00\x00\x8b\xf9\x8b\xf2\x8b\x5d\x08\x33\xc0\x40\x89\x45\xe4\x85\xf6\x75\x0c\x39\x15\xe4\xee\x00\x10\x0f\x84\xc5\x00\x00\x00\x83\x65\xfc\x00\x3b\xf0\x74\x05\x83\xfe\x02\x75\x2e\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x08\x57\x56\x53\xff\xd0\x89\x45\xe4\x83\x7d\xe4\x00\x0f\x84\x96\x00\x00\x00\x57\x56\x53\xe8\x72\xfe\xff\xff\x89\x45\xe4\x85\xc0\x0f\x84\x83\x00\x00\x00\x57\x56\x53\xe8\x3a\xf7\xff\xff\x89\x45\xe4\x83\xfe\x01\x75\x24\x85\xc0\x75\x20\x57\x50\x53\xe8\x26\xf7\xff\xff\x57\x6a\x00\x53\xe8\x42\xfe\xff\xff\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x06\x57\x6a\x00\x53\xff\xd0\x85\xf6\x74\x05\x83\xfe\x03\x75\x26\x57\x56\x53\xe8\x22\xfe\xff\xff\x85\xc0\x75\x03\x21\x45\xe4\x83\x7d\xe4\x00\x74\x11\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x08\x57\x56\x53\xff\xd0\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xeb\x1d\x8b\x45\xec\x8b\x08\x8b\x09\x50\x51\xe8\x4a\x28\x00\x00\x59\x59\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x33\xc0\xe8\xa2\x12\x00\x00\xc3\x8b\xff\x55\x8b\xec\x83\x7d\x0c\x01\x75\x05\xe8\x45\x28\x00\x00\xff\x75\x08\x8b\x4d\x10\x8b\x55\x0c\xe8\xec\xfe\xff\xff\x59\x5d\xc2\x0c\x00\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa3\x00\xf0\x00\x10\x89\x0d\xfc\xef\x00\x10\x89\x15\xf8\xef\x00\x10\x89\x1d\xf4\xef\x00\x10\x89\x35\xf0\xef\x00\x10\x89\x3d\xec\xef\x00\x10\x66\x8c\x15\x18\xf0\x00\x10\x66\x8c\x0d\x0c\xf0\x00\x10\x66\x8c\x1d\xe8\xef\x00\x10\x66\x8c\x05\xe4\xef\x00\x10\x66\x8c\x25\xe0\xef\x00\x10\x66\x8c\x2d\xdc\xef\x00\x10\x9c\x8f\x05\x10\xf0\x00\x10\x8b\x45\x00\xa3\x04\xf0\x00\x10\x8b\x45\x04\xa3\x08\xf0\x00\x10\x8d\x45\x08\xa3\x14\xf0\x00\x10\x8b\x85\xe0\xfc\xff\xff\xc7\x05\x50\xef\x00\x10\x01\x00\x01\x00\xa1\x08\xf0\x00\x10\xa3\x04\xef\x00\x10\xc7\x05\xf8\xee\x00\x10\x09\x04\x00\xc0\xc7\x05\xfc\xee\x00\x10\x01\x00\x00\x00\xa1\x00\xe0\x00\x10\x89\x85\xd8\xfc\xff\xff\xa1\x04\xe0\x00\x10\x89\x85\xdc\xfc\xff\xff\xff\x15\x60\xb0\x00\x10\xa3\x48\xef\x00\x10\x6a\x01\xe8\xfb\x27\x00\x00\x59\x6a\x00\xff\x15\x5c\xb0\x00\x10\x68\xd0\xb1\x00\x10\xff\x15\x58\xb0\x00\x10\x83\x3d\x48\xef\x00\x10\x00\x75\x08\x6a\x01\xe8\xd7\x27\x00\x00\x59\x68\x09\x04\x00\xc0\xff\x15\x54\xb0\x00\x10\x50\xff\x15\x50\xb0\x00\x10\xc9\xc3\xb8\x08\xe0\x00\x10\xc3\xa1\x60\x0e\x01\x10\x56\x6a\x14\x5e\x85\xc0\x75\x07\xb8\x00\x02\x00\x00\xeb\x06\x3b\xc6\x7d\x07\x8b\xc6\xa3\x60\x0e\x01\x10\x6a\x04\x50\xe8\xd4\x19\x00\x00\x59\x59\xa3\x5c\xfe\x00\x10\x85\xc0\x75\x1e\x6a\x04\x56\x89\x35\x60\x0e\x01\x10\xe8\xbb\x19\x00\x00\x59\x59\xa3\x5c\xfe\x00\x10\x85\xc0\x75\x05\x6a\x1a\x58\x5e\xc3\x33\xd2\xb9\x08\xe0\x00\x10\xeb\x05\xa1\x5c\xfe\x00\x10\x89\x0c\x02\x83\xc1\x20\x83\xc2\x04\x81\xf9\x88\xe2\x00\x10\x7c\xea\x6a\xfe\x5e\x33\xd2\xb9\x18\xe0\x00\x10\x57\x8b\xc2\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x8b\xfa\x83\xe7\x1f\xc1\xe7\x06\x8b\x04\x07\x83\xf8\xff\x74\x08\x3b\xc6\x74\x04\x85\xc0\x75\x02\x89\x31\x83\xc1\x20\x42\x81\xf9\x78\xe0\x00\x10\x7c\xce\x5f\x33\xc0\x5e\xc3\xe8\x37\x29\x00\x00\x80\x3d\x68\xf2\x00\x10\x00\x74\x05\xe8\x00\x27\x00\x00\xff\x35\x5c\xfe\x00\x10\xe8\x59\x18\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\xb8\x08\xe0\x00\x10\x3b\xf0\x72\x22\x81\xfe\x68\xe2\x00\x10\x77\x1a\x8b\xce\x2b\xc8\xc1\xf9\x05\x83\xc1\x10\x51\xe8\x77\x2a\x00\x00\x81\x4e\x0c\x00\x80\x00\x00\x59\xeb\x0a\x83\xc6\x20\x56\xff\x15\x64\xb0\x00\x10\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\x14\x7d\x16\x83\xc0\x10\x50\xe8\x4a\x2a\x00\x00\x8b\x45\x0c\x81\x48\x0c\x00\x80\x00\x00\x59\x5d\xc3\x8b\x45\x0c\x83\xc0\x20\x50\xff\x15\x64\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xb9\x08\xe0\x00\x10\x3b\xc1\x72\x1f\x3d\x68\xe2\x00\x10\x77\x18\x81\x60\x0c\xff\x7f\xff\xff\x2b\xc1\xc1\xf8\x05\x83\xc0\x10\x50\xe8\x27\x29\x00\x00\x59\x5d\xc3\x83\xc0\x20\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x83\xf9\x14\x8b\x45\x0c\x7d\x13\x81\x60\x0c\xff\x7f\xff\xff\x83\xc1\x10\x51\xe8\xf8\x28\x00\x00\x59\x5d\xc3\x83\xc0\x20\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x56\xe8\x4b\x2a\x00\x00\x50\xe8\xe1\x29\x00\x00\x59\x59\x85\xc0\x74\x7c\xe8\x2b\xfe\xff\xff\x83\xc0\x20\x3b\xf0\x75\x04\x33\xc0\xeb\x0f\xe8\x1b\xfe\xff\xff\x83\xc0\x40\x3b\xf0\x75\x60\x33\xc0\x40\xff\x05\x1c\xf2\x00\x10\xf7\x46\x0c\x0c\x01\x00\x00\x75\x4e\x53\x57\x8d\x3c\x85\x20\xf2\x00\x10\x83\x3f\x00\xbb\x00\x10\x00\x00\x75\x20\x53\xe8\xa5\x17\x00\x00\x59\x89\x07\x85\xc0\x75\x13\x8d\x46\x14\x6a\x02\x89\x46\x08\x89\x06\x58\x89\x46\x18\x89\x46\x04\xeb\x0d\x8b\x3f\x89\x7e\x08\x89\x3e\x89\x5e\x18\x89\x5e\x04\x81\x4e\x0c\x02\x11\x00\x00\x33\xc0\x5f\x40\x5b\xeb\x02\x33\xc0\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\x7d\x08\x00\x74\x27\x56\x8b\x75\x0c\xf7\x46\x0c\x00\x10\x00\x00\x74\x19\x56\xe8\xfa\x25\x00\x00\x81\x66\x0c\xff\xee\xff\xff\x83\x66\x18\x00\x83\x26\x00\x83\x66\x08\x00\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x8b\xf1\xc6\x46\x0c\x00\x85\xc0\x75\x63\xe8\x4d\x13\x00\x00\x89\x46\x08\x8b\x48\x6c\x89\x0e\x8b\x48\x68\x89\x4e\x04\x8b\x0e\x3b\x0d\x90\xeb\x00\x10\x74\x12\x8b\x0d\xac\xea\x00\x10\x85\x48\x70\x75\x07\xe8\x0e\x33\x00\x00\x89\x06\x8b\x46\x04\x3b\x05\xb0\xe9\x00\x10\x74\x16\x8b\x46\x08\x8b\x0d\xac\xea\x00\x10\x85\x48\x70\x75\x08\xe8\x82\x2b\x00\x00\x89\x46\x04\x8b\x46\x08\xf6\x40\x70\x02\x75\x14\x83\x48\x70\x02\xc6\x46\x0c\x01\xeb\x0a\x8b\x08\x89\x0e\x8b\x40\x04\x89\x46\x04\x8b\xc6\x5e\x5d\xc2\x04\x00\xf6\x41\x0c\x40\x74\x06\x83\x79\x08\x00\x74\x24\xff\x49\x04\x78\x0b\x8b\x11\x88\x02\xff\x01\x0f\xb6\xc0\xeb\x0c\x0f\xbe\xc0\x51\x50\xe8\x17\x33\x00\x00\x59\x59\x83\xf8\xff\x75\x03\x09\x06\xc3\xff\x06\xc3\x8b\xff\x55\x8b\xec\x56\x8b\xf0\xeb\x13\x8b\x4d\x10\x8a\x45\x08\xff\x4d\x0c\xe8\xb5\xff\xff\xff\x83\x3e\xff\x74\x06\x83\x7d\x0c\x00\x7f\xe7\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\xf6\x47\x0c\x40\x53\x56\x8b\xf0\x8b\xd9\x74\x32\x83\x7f\x08\x00\x75\x2c\x8b\x45\x08\x01\x06\xeb\x2b\x8a\x03\xff\x4d\x08\x8b\xcf\xe8\x7d\xff\xff\xff\x43\x83\x3e\xff\x75\x13\xe8\x4f\x0d\x00\x00\x83\x38\x2a\x75\x0f\x8b\xcf\xb0\x3f\xe8\x64\xff\xff\xff\x83\x7d\x08\x00\x7f\xd5\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x78\x02\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x8b\x5d\x0c\x56\x8b\x75\x08\x33\xc0\x57\x8b\x7d\x14\xff\x75\x10\x8d\x8d\xa4\xfd\xff\xff\x89\xb5\xb4\xfd\xff\xff\x89\xbd\xdc\xfd\xff\xff\x89\x85\xb8\xfd\xff\xff\x89\x85\xf0\xfd\xff\xff\x89\x85\xcc\xfd\xff\xff\x89\x85\xe8\xfd\xff\xff\x89\x85\xd0\xfd\xff\xff\x89\x85\xc0\xfd\xff\xff\x89\x85\xc8\xfd\xff\xff\xe8\x6c\xfe\xff\xff\x85\xf6\x75\x35\xe8\xc7\x0c\x00\x00\xc7\x00\x16\x00\x00\x00\x33\xc0\x50\x50\x50\x50\x50\xe8\x4d\x0c\x00\x00\x83\xc4\x14\x80\xbd\xb0\xfd\xff\xff\x00\x74\x0a\x8b\x85\xac\xfd\xff\xff\x83\x60\x70\xfd\x83\xc8\xff\xe9\xc8\x0a\x00\x00\xf6\x46\x0c\x40\x75\x5e\x56\xe8\xb1\x27\x00\x00\x59\xba\x10\xe4\x00\x10\x83\xf8\xff\x74\x1b\x83\xf8\xfe\x74\x16\x8b\xc8\x83\xe1\x1f\x8b\xf0\xc1\xfe\x05\xc1\xe1\x06\x03\x0c\xb5\x40\xfd\x00\x10\xeb\x02\x8b\xca\xf6\x41\x24\x7f\x75\x91\x83\xf8\xff\x74\x19\x83\xf8\xfe\x74\x14\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\xc1\xe0\x06\x03\x04\x8d\x40\xfd\x00\x10\xeb\x02\x8b\xc2\xf6\x40\x24\x80\x0f\x85\x67\xff\xff\xff\x33\xc9\x3b\xd9\x0f\x84\x5d\xff\xff\xff\x8a\x13\x89\x8d\xd8\xfd\xff\xff\x89\x8d\xe0\xfd\xff\xff\x89\x8d\xbc\xfd\xff\xff\x88\x95\xef\xfd\xff\xff\x84\xd2\x0f\x84\x1f\x0a\x00\x00\x43\x83\xbd\xd8\xfd\xff\xff\x00\x89\x9d\xc4\xfd\xff\xff\x0f\x8c\x0b\x0a\x00\x00\x8a\xc2\x2c\x20\x3c\x58\x77\x11\x0f\xbe\xc2\x0f\xbe\x80\xd0\xb1\x00\x10\x83\xe0\x0f\x33\xf6\xeb\x04\x33\xf6\x33\xc0\x0f\xbe\x84\xc1\xf0\xb1\x00\x10\x6a\x07\xc1\xf8\x04\x59\x89\x85\x94\xfd\xff\xff\x3b\xc1\x0f\x87\xad\x09\x00\x00\xff\x24\x85\xa3\x29\x00\x10\x83\x8d\xe8\xfd\xff\xff\xff\x89\xb5\x90\xfd\xff\xff\x89\xb5\xc0\xfd\xff\xff\x89\xb5\xcc\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xb5\xf0\xfd\xff\xff\x89\xb5\xc8\xfd\xff\xff\xe9\x76\x09\x00\x00\x0f\xbe\xc2\x83\xe8\x20\x74\x4a\x83\xe8\x03\x74\x36\x83\xe8\x08\x74\x25\x48\x48\x74\x15\x83\xe8\x03\x0f\x85\x57\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x08\xe9\x4b\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x04\xe9\x3f\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x01\xe9\x33\x09\x00\x00\x81\x8d\xf0\xfd\xff\xff\x80\x00\x00\x00\xe9\x24\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x02\xe9\x18\x09\x00\x00\x80\xfa\x2a\x75\x2c\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x3b\xfe\x89\xbd\xcc\xfd\xff\xff\x0f\x8d\xf9\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x04\xf7\x9d\xcc\xfd\xff\xff\xe9\xe7\x08\x00\x00\x8b\x85\xcc\xfd\xff\xff\x6b\xc0\x0a\x0f\xbe\xca\x8d\x44\x08\xd0\x89\x85\xcc\xfd\xff\xff\xe9\xcc\x08\x00\x00\x89\xb5\xe8\xfd\xff\xff\xe9\xc1\x08\x00\x00\x80\xfa\x2a\x75\x26\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x3b\xfe\x89\xbd\xe8\xfd\xff\xff\x0f\x8d\xa2\x08\x00\x00\x83\x8d\xe8\xfd\xff\xff\xff\xe9\x96\x08\x00\x00\x8b\x85\xe8\xfd\xff\xff\x6b\xc0\x0a\x0f\xbe\xca\x8d\x44\x08\xd0\x89\x85\xe8\xfd\xff\xff\xe9\x7b\x08\x00\x00\x80\xfa\x49\x74\x55\x80\xfa\x68\x74\x44\x80\xfa\x6c\x74\x18\x80\xfa\x77\x0f\x85\x63\x08\x00\x00\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\xe9\x54\x08\x00\x00\x80\x3b\x6c\x75\x16\x43\x81\x8d\xf0\xfd\xff\xff\x00\x10\x00\x00\x89\x9d\xc4\xfd\xff\xff\xe9\x39\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x10\xe9\x2d\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x20\xe9\x21\x08\x00\x00\x8a\x03\x3c\x36\x75\x1d\x80\x7b\x01\x34\x75\x17\x43\x43\x81\x8d\xf0\xfd\xff\xff\x00\x80\x00\x00\x89\x9d\xc4\xfd\xff\xff\xe9\xfe\x07\x00\x00\x3c\x33\x75\x1d\x80\x7b\x01\x32\x75\x17\x43\x43\x81\xa5\xf0\xfd\xff\xff\xff\x7f\xff\xff\x89\x9d\xc4\xfd\xff\xff\xe9\xdd\x07\x00\x00\x3c\x64\x0f\x84\xd5\x07\x00\x00\x3c\x69\x0f\x84\xcd\x07\x00\x00\x3c\x6f\x0f\x84\xc5\x07\x00\x00\x3c\x75\x0f\x84\xbd\x07\x00\x00\x3c\x78\x0f\x84\xb5\x07\x00\x00\x3c\x58\x0f\x84\xad\x07\x00\x00\x89\xb5\x94\xfd\xff\xff\x8d\x85\xa4\xfd\xff\xff\x50\x0f\xb6\xc2\x50\x89\xb5\xc8\xfd\xff\xff\xe8\xa0\x32\x00\x00\x59\x85\xc0\x8a\x85\xef\xfd\xff\xff\x59\x74\x22\x8b\x8d\xb4\xfd\xff\xff\x8d\xb5\xd8\xfd\xff\xff\xe8\xa4\xfb\xff\xff\x8a\x03\x43\x89\x9d\xc4\xfd\xff\xff\x84\xc0\x0f\x84\xa4\xfc\xff\xff\x8b\x8d\xb4\xfd\xff\xff\x8d\xb5\xd8\xfd\xff\xff\xe8\x82\xfb\xff\xff\xe9\x4d\x07\x00\x00\x0f\xbe\xc2\x83\xf8\x64\x0f\x8f\xe8\x01\x00\x00\x0f\x84\x79\x02\x00\x00\x83\xf8\x53\x0f\x8f\xf2\x00\x00\x00\x0f\x84\x80\x00\x00\x00\x83\xe8\x41\x74\x10\x48\x48\x74\x58\x48\x48\x74\x08\x48\x48\x0f\x85\x92\x05\x00\x00\x80\xc2\x20\xc7\x85\x90\xfd\xff\xff\x01\x00\x00\x00\x88\x95\xef\xfd\xff\xff\x83\x8d\xf0\xfd\xff\xff\x40\x39\xb5\xe8\xfd\xff\xff\x8d\x9d\xf4\xfd\xff\xff\xb8\x00\x02\x00\x00\x89\x9d\xe4\xfd\xff\xff\x89\x85\xa0\xfd\xff\xff\x0f\x8d\x48\x02\x00\x00\xc7\x85\xe8\xfd\xff\xff\x06\x00\x00\x00\xe9\xa5\x02\x00\x00\xf7\x85\xf0\xfd\xff\xff\x30\x08\x00\x00\x0f\x85\x98\x00\x00\x00\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\xe9\x89\x00\x00\x00\xf7\x85\xf0\xfd\xff\xff\x30\x08\x00\x00\x75\x0a\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\x8b\x8d\xe8\xfd\xff\xff\x83\xf9\xff\x75\x05\xb9\xff\xff\xff\x7f\x83\xc7\x04\xf7\x85\xf0\xfd\xff\xff\x10\x08\x00\x00\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x89\xbd\xe4\xfd\xff\xff\x0f\x84\xb1\x04\x00\x00\x3b\xfe\x75\x0b\xa1\x8c\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x8b\x85\xe4\xfd\xff\xff\xc7\x85\xc8\xfd\xff\xff\x01\x00\x00\x00\xe9\x7f\x04\x00\x00\x83\xe8\x58\x0f\x84\xda\x02\x00\x00\x48\x48\x74\x79\x2b\xc1\x0f\x84\x27\xff\xff\xff\x48\x48\x0f\x85\x9e\x04\x00\x00\x83\xc7\x04\xf7\x85\xf0\xfd\xff\xff\x10\x08\x00\x00\x89\xbd\xdc\xfd\xff\xff\x74\x30\x0f\xb7\x47\xfc\x50\x68\x00\x02\x00\x00\x8d\x85\xf4\xfd\xff\xff\x50\x8d\x85\xe0\xfd\xff\xff\x50\xe8\xe3\x30\x00\x00\x83\xc4\x10\x85\xc0\x74\x1f\xc7\x85\xc0\xfd\xff\xff\x01\x00\x00\x00\xeb\x13\x8a\x47\xfc\x88\x85\xf4\xfd\xff\xff\xc7\x85\xe0\xfd\xff\xff\x01\x00\x00\x00\x8d\x85\xf4\xfd\xff\xff\x89\x85\xe4\xfd\xff\xff\xe9\x35\x04\x00\x00\x8b\x07\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x3b\xc6\x74\x3b\x8b\x48\x04\x3b\xce\x74\x34\xf7\x85\xf0\xfd\xff\xff\x00\x08\x00\x00\x0f\xbf\x00\x89\x8d\xe4\xfd\xff\xff\x74\x14\x99\x2b\xc2\xd1\xf8\xc7\x85\xc8\xfd\xff\xff\x01\x00\x00\x00\xe9\xf0\x03\x00\x00\x89\xb5\xc8\xfd\xff\xff\xe9\xe5\x03\x00\x00\xa1\x88\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x50\xe8\x5a\x2e\x00\x00\x59\xe9\xce\x03\x00\x00\x83\xf8\x70\x0f\x8f\xfb\x01\x00\x00\x0f\x84\xe3\x01\x00\x00\x83\xf8\x65\x0f\x8c\xbc\x03\x00\x00\x83\xf8\x67\x0f\x8e\x34\xfe\xff\xff\x83\xf8\x69\x74\x71\x83\xf8\x6e\x74\x28\x83\xf8\x6f\x0f\x85\xa0\x03\x00\x00\xf6\x85\xf0\xfd\xff\xff\x80\xc7\x85\xe0\xfd\xff\xff\x08\x00\x00\x00\x74\x61\x81\x8d\xf0\xfd\xff\xff\x00\x02\x00\x00\xeb\x55\x8b\x37\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\xe8\xdd\xf1\xff\xff\x85\xc0\x0f\x84\x2f\xfa\xff\xff\xf6\x85\xf0\xfd\xff\xff\x20\x74\x0c\x66\x8b\x85\xd8\xfd\xff\xff\x66\x89\x06\xeb\x08\x8b\x85\xd8\xfd\xff\xff\x89\x06\xc7\x85\xc0\xfd\xff\xff\x01\x00\x00\x00\xe9\xa6\x04\x00\x00\x83\x8d\xf0\xfd\xff\xff\x40\xc7\x85\xe0\xfd\xff\xff\x0a\x00\x00\x00\x8b\x8d\xf0\xfd\xff\xff\xf7\xc1\x00\x80\x00\x00\x0f\x84\xa9\x01\x00\x00\x8b\x07\x8b\x57\x04\x83\xc7\x08\xe9\xd5\x01\x00\x00\x75\x11\x80\xfa\x67\x75\x65\xc7\x85\xe8\xfd\xff\xff\x01\x00\x00\x00\xeb\x59\x39\x85\xe8\xfd\xff\xff\x7e\x06\x89\x85\xe8\xfd\xff\xff\x81\xbd\xe8\xfd\xff\xff\xa3\x00\x00\x00\x7e\x3f\x8b\xb5\xe8\xfd\xff\xff\x81\xc6\x5d\x01\x00\x00\x56\xe8\x33\x0f\x00\x00\x8a\x95\xef\xfd\xff\xff\x59\x89\x85\xbc\xfd\xff\xff\x85\xc0\x74\x10\x89\x85\xe4\xfd\xff\xff\x89\xb5\xa0\xfd\xff\xff\x8b\xd8\xeb\x0a\xc7\x85\xe8\xfd\xff\xff\xa3\x00\x00\x00\x33\xf6\x8b\x07\x83\xc7\x08\x89\x85\x88\xfd\xff\xff\x8b\x47\xfc\x89\x85\x8c\xfd\xff\xff\x8d\x85\xa4\xfd\xff\xff\x50\xff\xb5\x90\xfd\xff\xff\x0f\xbe\xc2\xff\xb5\xe8\xfd\xff\xff\x89\xbd\xdc\xfd\xff\xff\x50\xff\xb5\xa0\xfd\xff\xff\x8d\x85\x88\xfd\xff\xff\x53\x50\xff\x35\xb8\xeb\x00\x10\xe8\x9e\x08\x00\x00\x59\xff\xd0\x8b\xbd\xf0\xfd\xff\xff\x83\xc4\x1c\x81\xe7\x80\x00\x00\x00\x74\x20\x39\xb5\xe8\xfd\xff\xff\x75\x18\x8d\x85\xa4\xfd\xff\xff\x50\x53\xff\x35\xc4\xeb\x00\x10\xe8\x6f\x08\x00\x00\x59\xff\xd0\x59\x59\x80\xbd\xef\xfd\xff\xff\x67\x75\x1c\x3b\xfe\x75\x18\x8d\x85\xa4\xfd\xff\xff\x50\x53\xff\x35\xc0\xeb\x00\x10\xe8\x4a\x08\x00\x00\x59\xff\xd0\x59\x59\x80\x3b\x2d\x75\x11\x81\x8d\xf0\xfd\xff\xff\x00\x01\x00\x00\x43\x89\x9d\xe4\xfd\xff\xff\x53\xe9\x03\xfe\xff\xff\xc7\x85\xe8\xfd\xff\xff\x08\x00\x00\x00\x89\x8d\xb8\xfd\xff\xff\xeb\x24\x83\xe8\x73\x0f\x84\xb6\xfc\xff\xff\x48\x48\x0f\x84\x89\xfe\xff\xff\x83\xe8\x03\x0f\x85\xb6\x01\x00\x00\xc7\x85\xb8\xfd\xff\xff\x27\x00\x00\x00\xf6\x85\xf0\xfd\xff\xff\x80\xc7\x85\xe0\xfd\xff\xff\x10\x00\x00\x00\x0f\x84\x69\xfe\xff\xff\x8a\x85\xb8\xfd\xff\xff\x04\x51\xc6\x85\xd4\xfd\xff\xff\x30\x88\x85\xd5\xfd\xff\xff\xc7\x85\xd0\xfd\xff\xff\x02\x00\x00\x00\xe9\x45\xfe\xff\xff\xf7\xc1\x00\x10\x00\x00\x0f\x85\x4b\xfe\xff\xff\x83\xc7\x04\xf6\xc1\x20\x74\x18\x89\xbd\xdc\xfd\xff\xff\xf6\xc1\x40\x74\x06\x0f\xbf\x47\xfc\xeb\x04\x0f\xb7\x47\xfc\x99\xeb\x13\x8b\x47\xfc\xf6\xc1\x40\x74\x03\x99\xeb\x02\x33\xd2\x89\xbd\xdc\xfd\xff\xff\xf6\xc1\x40\x74\x1b\x3b\xd6\x7f\x17\x7c\x04\x3b\xc6\x73\x11\xf7\xd8\x83\xd2\x00\xf7\xda\x81\x8d\xf0\xfd\xff\xff\x00\x01\x00\x00\xf7\x85\xf0\xfd\xff\xff\x00\x90\x00\x00\x8b\xda\x8b\xf8\x75\x02\x33\xdb\x83\xbd\xe8\xfd\xff\xff\x00\x7d\x0c\xc7\x85\xe8\xfd\xff\xff\x01\x00\x00\x00\xeb\x1a\x83\xa5\xf0\xfd\xff\xff\xf7\xb8\x00\x02\x00\x00\x39\x85\xe8\xfd\xff\xff\x7e\x06\x89\x85\xe8\xfd\xff\xff\x8b\xc7\x0b\xc3\x75\x06\x21\x85\xd0\xfd\xff\xff\x8d\x75\xf3\x8b\x85\xe8\xfd\xff\xff\xff\x8d\xe8\xfd\xff\xff\x85\xc0\x7f\x06\x8b\xc7\x0b\xc3\x74\x2d\x8b\x85\xe0\xfd\xff\xff\x99\x52\x50\x53\x57\xe8\x7c\x2d\x00\x00\x83\xc1\x30\x83\xf9\x39\x89\x9d\xa0\xfd\xff\xff\x8b\xf8\x8b\xda\x7e\x06\x03\x8d\xb8\xfd\xff\xff\x88\x0e\x4e\xeb\xbd\x8d\x45\xf3\x2b\xc6\x46\xf7\x85\xf0\xfd\xff\xff\x00\x02\x00\x00\x89\x85\xe0\xfd\xff\xff\x89\xb5\xe4\xfd\xff\xff\x74\x61\x85\xc0\x74\x07\x8b\xce\x80\x39\x30\x74\x56\xff\x8d\xe4\xfd\xff\xff\x8b\x8d\xe4\xfd\xff\xff\xc6\x01\x30\x40\xeb\x3e\x49\x66\x39\x30\x74\x06\x40\x40\x3b\xce\x75\xf4\x2b\x85\xe4\xfd\xff\xff\xd1\xf8\xeb\x28\x3b\xfe\x75\x0b\xa1\x88\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x8b\x85\xe4\xfd\xff\xff\xeb\x07\x49\x80\x38\x00\x74\x05\x40\x3b\xce\x75\xf5\x2b\x85\xe4\xfd\xff\xff\x89\x85\xe0\xfd\xff\xff\x83\xbd\xc0\xfd\xff\xff\x00\x0f\x85\x5c\x01\x00\x00\x8b\x85\xf0\xfd\xff\xff\xa8\x40\x74\x32\xa9\x00\x01\x00\x00\x74\x09\xc6\x85\xd4\xfd\xff\xff\x2d\xeb\x18\xa8\x01\x74\x09\xc6\x85\xd4\xfd\xff\xff\x2b\xeb\x0b\xa8\x02\x74\x11\xc6\x85\xd4\xfd\xff\xff\x20\xc7\x85\xd0\xfd\xff\xff\x01\x00\x00\x00\x8b\x9d\xcc\xfd\xff\xff\x2b\x9d\xe0\xfd\xff\xff\x2b\x9d\xd0\xfd\xff\xff\xf6\x85\xf0\xfd\xff\xff\x0c\x75\x17\xff\xb5\xb4\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x53\x6a\x20\xe8\x70\xf5\xff\xff\x83\xc4\x0c\xff\xb5\xd0\xfd\xff\xff\x8b\xbd\xb4\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x8d\x8d\xd4\xfd\xff\xff\xe8\x76\xf5\xff\xff\xf6\x85\xf0\xfd\xff\xff\x08\x59\x74\x1b\xf6\x85\xf0\xfd\xff\xff\x04\x75\x12\x57\x53\x6a\x30\x8d\x85\xd8\xfd\xff\xff\xe8\x2e\xf5\xff\xff\x83\xc4\x0c\x83\xbd\xc8\xfd\xff\xff\x00\x8b\x85\xe0\xfd\xff\xff\x74\x66\x85\xc0\x7e\x62\x8b\xb5\xe4\xfd\xff\xff\x89\x85\xa0\xfd\xff\xff\x0f\xb7\x06\xff\x8d\xa0\xfd\xff\xff\x50\x6a\x06\x8d\x45\xf4\x50\x8d\x85\x98\xfd\xff\xff\x46\x50\x46\xe8\x7d\x2b\x00\x00\x83\xc4\x10\x85\xc0\x75\x28\x39\x85\x98\xfd\xff\xff\x74\x20\xff\xb5\x98\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x8d\x4d\xf4\xe8\xf1\xf4\xff\xff\x83\xbd\xa0\xfd\xff\xff\x00\x59\x75\xb5\xeb\x1c\x83\x8d\xd8\xfd\xff\xff\xff\xeb\x13\x8b\x8d\xe4\xfd\xff\xff\x50\x8d\x85\xd8\xfd\xff\xff\xe8\xca\xf4\xff\xff\x59\x83\xbd\xd8\xfd\xff\xff\x00\x7c\x1b\xf6\x85\xf0\xfd\xff\xff\x04\x74\x12\x57\x53\x6a\x20\x8d\x85\xd8\xfd\xff\xff\xe8\x82\xf4\xff\xff\x83\xc4\x0c\x83\xbd\xbc\xfd\xff\xff\x00\x74\x13\xff\xb5\xbc\xfd\xff\xff\xe8\x5a\x0a\x00\x00\x83\xa5\xbc\xfd\xff\xff\x00\x59\x8b\x9d\xc4\xfd\xff\xff\x8a\x03\x88\x85\xef\xfd\xff\xff\x84\xc0\x74\x13\x8b\x8d\x94\xfd\xff\xff\x8b\xbd\xdc\xfd\xff\xff\x8a\xd0\xe9\xe1\xf5\xff\xff\x80\xbd\xb0\xfd\xff\xff\x00\x74\x0a\x8b\x85\xac\xfd\xff\xff\x83\x60\x70\xfd\x8b\x85\xd8\xfd\xff\xff\x8b\x4d\xfc\x5f\x5e\x33\xcd\x5b\xe8\xde\xeb\xff\xff\xc9\xc3\x90\xae\x21\x00\x10\xaf\x1f\x00\x10\xdf\x1f\x00\x10\x3d\x20\x00\x10\x89\x20\x00\x10\x94\x20\x00\x10\xda\x20\x00\x10\x08\x22\x00\x10\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x28\xf2\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x83\xa5\xd8\xfc\xff\xff\x00\x53\x6a\x4c\x8d\x85\xdc\xfc\xff\xff\x6a\x00\x50\xe8\x51\x2b\x00\x00\x8d\x85\xd8\xfc\xff\xff\x89\x85\x28\xfd\xff\xff\x8d\x85\x30\xfd\xff\xff\x83\xc4\x0c\x89\x85\x2c\xfd\xff\xff\x89\x85\xe0\xfd\xff\xff\x89\x8d\xdc\xfd\xff\xff\x89\x95\xd8\xfd\xff\xff\x89\x9d\xd4\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xbd\xcc\xfd\xff\xff\x66\x8c\x95\xf8\xfd\xff\xff\x66\x8c\x8d\xec\xfd\xff\xff\x66\x8c\x9d\xc8\xfd\xff\xff\x66\x8c\x85\xc4\xfd\xff\xff\x66\x8c\xa5\xc0\xfd\xff\xff\x66\x8c\xad\xbc\xfd\xff\xff\x9c\x8f\x85\xf0\xfd\xff\xff\x8b\x45\x04\x8d\x4d\x04\xc7\x85\x30\xfd\xff\xff\x01\x00\x01\x00\x89\x85\xe8\xfd\xff\xff\x89\x8d\xf4\xfd\xff\xff\x8b\x49\xfc\x89\x8d\xe4\xfd\xff\xff\xc7\x85\xd8\xfc\xff\xff\x17\x04\x00\xc0\xc7\x85\xdc\xfc\xff\xff\x01\x00\x00\x00\x89\x85\xe4\xfc\xff\xff\xff\x15\x60\xb0\x00\x10\x6a\x00\x8b\xd8\xff\x15\x5c\xb0\x00\x10\x8d\x85\x28\xfd\xff\xff\x50\xff\x15\x58\xb0\x00\x10\x85\xc0\x75\x0c\x85\xdb\x75\x08\x6a\x02\xe8\x61\x17\x00\x00\x59\x68\x17\x04\x00\xc0\xff\x15\x54\xb0\x00\x10\x50\xff\x15\x50\xb0\x00\x10\x8b\x4d\xfc\x33\xcd\x5b\xe8\x86\xea\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\xff\x35\x28\xf2\x00\x10\xe8\x0d\x03\x00\x00\x59\x85\xc0\x74\x03\x5d\xff\xe0\x6a\x02\xe8\x22\x17\x00\x00\x59\x5d\xe9\xb2\xfe\xff\xff\x8b\xff\x55\x8b\xec\x8b\x45\x08\x33\xc9\x3b\x04\xcd\x90\xe2\x00\x10\x74\x13\x41\x83\xf9\x2d\x72\xf1\x8d\x48\xed\x83\xf9\x11\x77\x0e\x6a\x0d\x58\x5d\xc3\x8b\x04\xcd\x94\xe2\x00\x10\x5d\xc3\x05\x44\xff\xff\xff\x6a\x0e\x59\x3b\xc8\x1b\xc0\x23\xc1\x83\xc0\x08\x5d\xc3\xe8\x83\x04\x00\x00\x85\xc0\x75\x06\xb8\xf8\xe3\x00\x10\xc3\x83\xc0\x08\xc3\xe8\x70\x04\x00\x00\x85\xc0\x75\x06\xb8\xfc\xe3\x00\x10\xc3\x83\xc0\x0c\xc3\x8b\xff\x55\x8b\xec\x56\xe8\xe2\xff\xff\xff\x8b\x4d\x08\x51\x89\x08\xe8\x82\xff\xff\xff\x59\x8b\xf0\xe8\xbc\xff\xff\xff\x89\x30\x5e\x5d\xc3\xcc\x68\x10\x2c\x00\x10\x64\xff\x35\x00\x00\x00\x00\x8b\x44\x24\x10\x89\x6c\x24\x10\x8d\x6c\x24\x10\x2b\xe0\x53\x56\x57\xa1\x00\xe0\x00\x10\x31\x45\xfc\x33\xc5\x50\x89\x65\xe8\xff\x75\xf8\x8b\x45\xfc\xc7\x45\xfc\xfe\xff\xff\xff\x89\x45\xf8\x8d\x45\xf0\x64\xa3\x00\x00\x00\x00\xc3\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5f\x5e\x5b\x8b\xe5\x5d\x51\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x83\xec\x18\x53\x8b\x5d\x0c\x56\x8b\x73\x08\x33\x35\x00\xe0\x00\x10\x57\x8b\x06\xc6\x45\xff\x00\xc7\x45\xf4\x01\x00\x00\x00\x8d\x7b\x10\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\x35\xe9\xff\xff\x8b\x4e\x0c\x8b\x46\x08\x03\xcf\x33\x0c\x38\xe8\x25\xe9\xff\xff\x8b\x45\x08\xf6\x40\x04\x66\x0f\x85\x16\x01\x00\x00\x8b\x4d\x10\x8d\x55\xe8\x89\x53\xfc\x8b\x5b\x0c\x89\x45\xe8\x89\x4d\xec\x83\xfb\xfe\x74\x5f\x8d\x49\x00\x8d\x04\x5b\x8b\x4c\x86\x14\x8d\x44\x86\x10\x89\x45\xf0\x8b\x00\x89\x45\xf8\x85\xc9\x74\x14\x8b\xd7\xe8\x20\x2a\x00\x00\xc6\x45\xff\x01\x85\xc0\x7c\x40\x7f\x47\x8b\x45\xf8\x8b\xd8\x83\xf8\xfe\x75\xce\x80\x7d\xff\x00\x74\x24\x8b\x06\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\xb2\xe8\xff\xff\x8b\x4e\x0c\x8b\x56\x08\x03\xcf\x33\x0c\x3a\xe8\xa2\xe8\xff\xff\x8b\x45\xf4\x5f\x5e\x5b\x8b\xe5\x5d\xc3\xc7\x45\xf4\x00\x00\x00\x00\xeb\xc9\x8b\x4d\x08\x81\x39\x63\x73\x6d\xe0\x75\x29\x83\x3d\x58\xfe\x00\x10\x00\x74\x20\x68\x58\xfe\x00\x10\xe8\xa3\x2a\x00\x00\x83\xc4\x04\x85\xc0\x74\x0f\x8b\x55\x08\x6a\x01\x52\xff\x15\x58\xfe\x00\x10\x83\xc4\x08\x8b\x4d\x0c\xe8\xc3\x29\x00\x00\x8b\x45\x0c\x39\x58\x0c\x74\x12\x68\x00\xe0\x00\x10\x57\x8b\xd3\x8b\xc8\xe8\xc6\x29\x00\x00\x8b\x45\x0c\x8b\x4d\xf8\x89\x48\x0c\x8b\x06\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\x1f\xe8\xff\xff\x8b\x4e\x0c\x8b\x56\x08\x03\xcf\x33\x0c\x3a\xe8\x0f\xe8\xff\xff\x8b\x45\xf0\x8b\x48\x08\x8b\xd7\xe8\x59\x29\x00\x00\xba\xfe\xff\xff\xff\x39\x53\x0c\x0f\x84\x52\xff\xff\xff\x68\x00\xe0\x00\x10\x57\x8b\xcb\xe8\x71\x29\x00\x00\xe9\x1c\xff\xff\xff\x8b\xff\x55\x8b\xec\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x21\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x17\x50\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x85\xc0\x74\x08\x8b\x80\xf8\x01\x00\x00\xeb\x27\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x0b\x56\xe8\x29\x07\x00\x00\x59\x85\xc0\x74\x18\x68\x4c\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x08\xff\x75\x08\xff\xd0\x89\x45\x08\x8b\x45\x08\x5e\x5d\xc3\x6a\x00\xe8\x87\xff\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x21\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x17\x50\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x85\xc0\x74\x08\x8b\x80\xfc\x01\x00\x00\xeb\x27\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x0b\x56\xe8\xae\x06\x00\x00\x59\x85\xc0\x74\x18\x68\x78\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x08\xff\x75\x08\xff\xd0\x89\x45\x08\x8b\x45\x08\x5e\x5d\xc3\xff\x15\x74\xb0\x00\x10\xc2\x04\x00\x8b\xff\x56\xff\x35\x04\xe4\x00\x10\xff\x15\x70\xb0\x00\x10\x8b\xf0\x85\xf6\x75\x1b\xff\x35\x30\xf2\x00\x10\xe8\x65\xff\xff\xff\x59\x8b\xf0\x56\xff\x35\x04\xe4\x00\x10\xff\x15\x78\xb0\x00\x10\x8b\xc6\x5e\xc3\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x16\x50\xff\x35\x38\xf2\x00\x10\xe8\x3b\xff\xff\xff\x59\xff\xd0\x83\x0d\x00\xe4\x00\x10\xff\xa1\x04\xe4\x00\x10\x83\xf8\xff\x74\x0e\x50\xff\x15\x7c\xb0\x00\x10\x83\x0d\x04\xe4\x00\x10\xff\xe9\xbd\x15\x00\x00\x6a\x0c\x68\xa0\xc5\x00\x10\xe8\x9d\xfc\xff\xff\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x07\x56\xe8\xef\x05\x00\x00\x59\x89\x45\xe4\x8b\x75\x08\xc7\x46\x5c\xe0\xb2\x00\x10\x33\xff\x47\x89\x7e\x14\x85\xc0\x74\x24\x68\x4c\xb2\x00\x10\x50\x8b\x1d\x6c\xb0\x00\x10\xff\xd3\x89\x86\xf8\x01\x00\x00\x68\x78\xb2\x00\x10\xff\x75\xe4\xff\xd3\x89\x86\xfc\x01\x00\x00\x89\x7e\x70\xc6\x86\xc8\x00\x00\x00\x43\xc6\x86\x4b\x01\x00\x00\x43\xc7\x46\x68\x88\xe5\x00\x10\x6a\x0d\xe8\x71\x16\x00\x00\x59\x83\x65\xfc\x00\xff\x76\x68\xff\x15\x80\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x3e\x00\x00\x00\x6a\x0c\xe8\x50\x16\x00\x00\x59\x89\x7d\xfc\x8b\x45\x0c\x89\x46\x6c\x85\xc0\x75\x08\xa1\x90\xeb\x00\x10\x89\x46\x6c\xff\x76\x6c\xe8\x27\x1f\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x15\x00\x00\x00\xe8\x20\xfc\xff\xff\xc3\x33\xff\x47\x8b\x75\x08\x6a\x0d\xe8\x38\x15\x00\x00\x59\xc3\x6a\x0c\xe8\x2f\x15\x00\x00\x59\xc3\x8b\xff\x56\x57\xff\x15\x00\xb0\x00\x10\xff\x35\x00\xe4\x00\x10\x8b\xf8\xe8\x91\xfe\xff\xff\xff\xd0\x8b\xf0\x85\xf6\x75\x4e\x68\x14\x02\x00\x00\x6a\x01\xe8\x65\x04\x00\x00\x8b\xf0\x59\x59\x85\xf6\x74\x3a\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\xe8\xfd\xff\xff\x59\xff\xd0\x85\xc0\x74\x18\x6a\x00\x56\xe8\xc5\xfe\xff\xff\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\xeb\x09\x56\xe8\x53\x03\x00\x00\x59\x33\xf6\x57\xff\x15\x84\xb0\x00\x10\x5f\x8b\xc6\x5e\xc3\x8b\xff\x56\xe8\x7f\xff\xff\xff\x8b\xf0\x85\xf6\x75\x08\x6a\x10\xe8\xcc\x04\x00\x00\x59\x8b\xc6\x5e\xc3\x6a\x08\x68\xc8\xc5\x00\x10\xe8\x23\xfb\xff\xff\x8b\x75\x08\x85\xf6\x0f\x84\xf8\x00\x00\x00\x8b\x46\x24\x85\xc0\x74\x07\x50\xe8\x06\x03\x00\x00\x59\x8b\x46\x2c\x85\xc0\x74\x07\x50\xe8\xf8\x02\x00\x00\x59\x8b\x46\x34\x85\xc0\x74\x07\x50\xe8\xea\x02\x00\x00\x59\x8b\x46\x3c\x85\xc0\x74\x07\x50\xe8\xdc\x02\x00\x00\x59\x8b\x46\x40\x85\xc0\x74\x07\x50\xe8\xce\x02\x00\x00\x59\x8b\x46\x44\x85\xc0\x74\x07\x50\xe8\xc0\x02\x00\x00\x59\x8b\x46\x48\x85\xc0\x74\x07\x50\xe8\xb2\x02\x00\x00\x59\x8b\x46\x5c\x3d\xe0\xb2\x00\x10\x74\x07\x50\xe8\xa1\x02\x00\x00\x59\x6a\x0d\xe8\xe3\x14\x00\x00\x59\x83\x65\xfc\x00\x8b\x7e\x68\x85\xff\x74\x1a\x57\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x0f\x81\xff\x88\xe5\x00\x10\x74\x07\x57\xe8\x74\x02\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x57\x00\x00\x00\x6a\x0c\xe8\xaa\x14\x00\x00\x59\xc7\x45\xfc\x01\x00\x00\x00\x8b\x7e\x6c\x85\xff\x74\x23\x57\xe8\x19\x1e\x00\x00\x59\x3b\x3d\x90\xeb\x00\x10\x74\x14\x81\xff\xb8\xea\x00\x10\x74\x0c\x83\x3f\x00\x75\x07\x57\xe8\x25\x1c\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x1e\x00\x00\x00\x56\xe8\x1c\x02\x00\x00\x59\xe8\x60\xfa\xff\xff\xc2\x04\x00\x8b\x75\x08\x6a\x0d\xe8\x79\x13\x00\x00\x59\xc3\x8b\x75\x08\x6a\x0c\xe8\x6d\x13\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x83\x3d\x00\xe4\x00\x10\xff\x74\x4b\x83\x7d\x08\x00\x75\x27\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x13\xff\x35\x00\xe4\x00\x10\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x89\x45\x08\x5e\x6a\x00\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\x1d\xfc\xff\xff\x59\xff\xd0\xff\x75\x08\xe8\x78\xfe\xff\xff\xa1\x04\xe4\x00\x10\x83\xf8\xff\x74\x09\x6a\x00\x50\xff\x15\x78\xb0\x00\x10\x5d\xc3\x8b\xff\x56\x57\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x07\x56\xe8\xe0\x02\x00\x00\x59\x8b\xf8\x85\xff\x0f\x84\x5e\x01\x00\x00\x8b\x35\x6c\xb0\x00\x10\x68\xa8\xb2\x00\x10\x57\xff\xd6\x68\x9c\xb2\x00\x10\x57\xa3\x2c\xf2\x00\x10\xff\xd6\x68\x90\xb2\x00\x10\x57\xa3\x30\xf2\x00\x10\xff\xd6\x68\x88\xb2\x00\x10\x57\xa3\x34\xf2\x00\x10\xff\xd6\x83\x3d\x2c\xf2\x00\x10\x00\x8b\x35\x78\xb0\x00\x10\xa3\x38\xf2\x00\x10\x74\x16\x83\x3d\x30\xf2\x00\x10\x00\x74\x0d\x83\x3d\x34\xf2\x00\x10\x00\x74\x04\x85\xc0\x75\x24\xa1\x70\xb0\x00\x10\xa3\x30\xf2\x00\x10\xa1\x7c\xb0\x00\x10\xc7\x05\x2c\xf2\x00\x10\x89\x2e\x00\x10\x89\x35\x34\xf2\x00\x10\xa3\x38\xf2\x00\x10\xff\x15\x74\xb0\x00\x10\xa3\x04\xe4\x00\x10\x83\xf8\xff\x0f\x84\xcc\x00\x00\x00\xff\x35\x30\xf2\x00\x10\x50\xff\xd6\x85\xc0\x0f\x84\xbb\x00\x00\x00\xe8\xed\x04\x00\x00\xff\x35\x2c\xf2\x00\x10\xe8\xa5\xfa\xff\xff\xff\x35\x30\xf2\x00\x10\xa3\x2c\xf2\x00\x10\xe8\x95\xfa\xff\xff\xff\x35\x34\xf2\x00\x10\xa3\x30\xf2\x00\x10\xe8\x85\xfa\xff\xff\xff\x35\x38\xf2\x00\x10\xa3\x34\xf2\x00\x10\xe8\x75\xfa\xff\xff\x83\xc4\x10\xa3\x38\xf2\x00\x10\xe8\x41\x11\x00\x00\x85\xc0\x74\x65\x68\x7d\x30\x00\x10\xff\x35\x2c\xf2\x00\x10\xe8\xcf\xfa\xff\xff\x59\xff\xd0\xa3\x00\xe4\x00\x10\x83\xf8\xff\x74\x48\x68\x14\x02\x00\x00\x6a\x01\xe8\x19\x01\x00\x00\x8b\xf0\x59\x59\x85\xf6\x74\x34\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\x9c\xfa\xff\xff\x59\xff\xd0\x85\xc0\x74\x1b\x6a\x00\x56\xe8\x79\xfb\xff\xff\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\x33\xc0\x40\xeb\x07\xe8\x24\xfb\xff\xff\x33\xc0\x5f\x5e\xc3\x6a\x0c\x68\xf0\xc5\x00\x10\xe8\xf9\xf7\xff\xff\x8b\x75\x08\x85\xf6\x74\x75\x83\x3d\x2c\xfd\x00\x10\x03\x75\x43\x6a\x04\xe8\x27\x12\x00\x00\x59\x83\x65\xfc\x00\x56\xe8\x98\x24\x00\x00\x59\x89\x45\xe4\x85\xc0\x74\x09\x56\x50\xe8\xb9\x24\x00\x00\x59\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x0b\x00\x00\x00\x83\x7d\xe4\x00\x75\x37\xff\x75\x08\xeb\x0a\x6a\x04\xe8\x13\x11\x00\x00\x59\xc3\x56\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\x85\xc0\x75\x16\xe8\x44\xf7\xff\xff\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\xf4\xf6\xff\xff\x89\x06\x59\xe8\xbd\xf7\xff\xff\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\xff\x75\x08\xe8\x3a\x2f\x00\x00\x8b\xf8\x59\x85\xff\x75\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xca\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\x6a\x00\xff\x75\x0c\xff\x75\x08\xe8\xba\x2f\x00\x00\x8b\xf8\x83\xc4\x0c\x85\xff\x75\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xc3\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\xff\x75\x0c\xff\x75\x08\xe8\x8e\x30\x00\x00\x8b\xf8\x59\x59\x85\xff\x75\x2c\x39\x45\x0c\x74\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xc1\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x57\xbf\xe8\x03\x00\x00\x57\xff\x15\x90\xb0\x00\x10\xff\x75\x08\xff\x15\x08\xb0\x00\x10\x81\xc7\xe8\x03\x00\x00\x81\xff\x60\xea\x00\x00\x77\x04\x85\xc0\x74\xde\x5f\x5d\xc3\x8b\xff\x55\x8b\xec\xe8\xe0\x33\x00\x00\xff\x75\x08\xe8\x2d\x32\x00\x00\xff\x35\x08\xe4\x00\x10\xe8\xb6\xf8\xff\xff\x68\xff\x00\x00\x00\xff\xd0\x83\xc4\x0c\x5d\xc3\x8b\xff\x55\x8b\xec\x68\xc4\xb2\x00\x10\xff\x15\x08\xb0\x00\x10\x85\xc0\x74\x15\x68\xb4\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x05\xff\x75\x08\xff\xd0\x5d\xc3\x8b\xff\x55\x8b\xec\xff\x75\x08\xe8\xc8\xff\xff\xff\x59\xff\x75\x08\xff\x15\x94\xb0\x00\x10\xcc\x6a\x08\xe8\x3a\x10\x00\x00\x59\xc3\x6a\x08\xe8\x57\x0f\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\xf0\xeb\x0b\x8b\x06\x85\xc0\x74\x02\xff\xd0\x83\xc6\x04\x3b\x75\x08\x72\xf0\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x33\xc0\xeb\x0f\x85\xc0\x75\x10\x8b\x0e\x85\xc9\x74\x02\xff\xd1\x83\xc6\x04\x3b\x75\x0c\x72\xec\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\x3d\x50\xfe\x00\x10\x00\x74\x19\x68\x50\xfe\x00\x10\xe8\x95\x21\x00\x00\x59\x85\xc0\x74\x0a\xff\x75\x08\xff\x15\x50\xfe\x00\x10\x59\xe8\xf7\x1b\x00\x00\x68\x94\xb1\x00\x10\x68\x80\xb1\x00\x10\xe8\xa1\xff\xff\xff\x59\x59\x85\xc0\x75\x42\x68\x59\x3f\x00\x10\xe8\x40\x34\x00\x00\xb8\x78\xb1\x00\x10\xc7\x04\x24\x7c\xb1\x00\x10\xe8\x63\xff\xff\xff\x83\x3d\x54\xfe\x00\x10\x00\x59\x74\x1b\x68\x54\xfe\x00\x10\xe8\x3d\x21\x00\x00\x59\x85\xc0\x74\x0c\x6a\x00\x6a\x02\x6a\x00\xff\x15\x54\xfe\x00\x10\x33\xc0\x5d\xc3\x6a\x18\x68\x10\xc6\x00\x10\xe8\x18\xf5\xff\xff\x6a\x08\xe8\x56\x0f\x00\x00\x59\x83\x65\xfc\x00\x33\xdb\x43\x39\x1d\x70\xf2\x00\x10\x0f\x84\xc5\x00\x00\x00\x89\x1d\x6c\xf2\x00\x10\x8a\x45\x10\xa2\x68\xf2\x00\x10\x83\x7d\x0c\x00\x0f\x85\x9d\x00\x00\x00\xff\x35\x48\xfe\x00\x10\xe8\x45\xf7\xff\xff\x59\x8b\xf8\x89\x7d\xd8\x85\xff\x74\x78\xff\x35\x44\xfe\x00\x10\xe8\x30\xf7\xff\xff\x59\x8b\xf0\x89\x75\xdc\x89\x7d\xe4\x89\x75\xe0\x83\xee\x04\x89\x75\xdc\x3b\xf7\x72\x57\xe8\x0c\xf7\xff\xff\x39\x06\x74\xed\x3b\xf7\x72\x4a\xff\x36\xe8\x06\xf7\xff\xff\x8b\xf8\xe8\xf6\xf6\xff\xff\x89\x06\xff\xd7\xff\x35\x48\xfe\x00\x10\xe8\xf0\xf6\xff\xff\x8b\xf8\xff\x35\x44\xfe\x00\x10\xe8\xe3\xf6\xff\xff\x83\xc4\x0c\x39\x7d\xe4\x75\x05\x39\x45\xe0\x74\x0e\x89\x7d\xe4\x89\x7d\xd8\x89\x45\xe0\x8b\xf0\x89\x75\xdc\x8b\x7d\xd8\xeb\x9f\x68\xa4\xb1\x00\x10\xb8\x98\xb1\x00\x10\xe8\x5f\xfe\xff\xff\x59\x68\xac\xb1\x00\x10\xb8\xa8\xb1\x00\x10\xe8\x4f\xfe\xff\xff\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x1f\x00\x00\x00\x83\x7d\x10\x00\x75\x28\x89\x1d\x70\xf2\x00\x10\x6a\x08\xe8\x84\x0d\x00\x00\x59\xff\x75\x08\xe8\xfc\xfd\xff\xff\x33\xdb\x43\x83\x7d\x10\x00\x74\x08\x6a\x08\xe8\x6b\x0d\x00\x00\x59\xc3\xe8\x3e\xf4\xff\xff\xc3\x8b\xff\x55\x8b\xec\x6a\x00\x6a\x01\xff\x75\x08\xe8\xc3\xfe\xff\xff\x83\xc4\x0c\x5d\xc3\x6a\x01\x6a\x00\x6a\x00\xe8\xb3\xfe\xff\xff\x83\xc4\x0c\xc3\x8b\xff\x56\xe8\x2d\xf6\xff\xff\x8b\xf0\x56\xe8\xa5\x35\x00\x00\x56\xe8\x30\x35\x00\x00\x56\xe8\xce\xf1\xff\xff\x56\xe8\x15\x35\x00\x00\x56\xe8\x00\x35\x00\x00\x56\xe8\xe8\x32\x00\x00\x56\xe8\x17\x08\x00\x00\x56\xe8\xcb\x32\x00\x00\x68\xb4\x37\x00\x10\xe8\x7f\xf5\xff\xff\x83\xc4\x24\xa3\x08\xe4\x00\x10\x5e\xc3\x6a\x54\x68\x30\xc6\x00\x10\xe8\x79\xf3\xff\xff\x33\xff\x89\x7d\xfc\x8d\x45\x9c\x50\xff\x15\xa4\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\x6a\x40\x6a\x20\x5e\x56\xe8\x26\xfc\xff\xff\x59\x59\x3b\xc7\x0f\x84\x14\x02\x00\x00\xa3\x40\xfd\x00\x10\x89\x35\x30\xfd\x00\x10\x8d\x88\x00\x08\x00\x00\xeb\x30\xc6\x40\x04\x00\x83\x08\xff\xc6\x40\x05\x0a\x89\x78\x08\xc6\x40\x24\x00\xc6\x40\x25\x0a\xc6\x40\x26\x0a\x89\x78\x38\xc6\x40\x34\x00\x83\xc0\x40\x8b\x0d\x40\xfd\x00\x10\x81\xc1\x00\x08\x00\x00\x3b\xc1\x72\xcc\x66\x39\x7d\xce\x0f\x84\x0a\x01\x00\x00\x8b\x45\xd0\x3b\xc7\x0f\x84\xff\x00\x00\x00\x8b\x38\x8d\x58\x04\x8d\x04\x3b\x89\x45\xe4\xbe\x00\x08\x00\x00\x3b\xfe\x7c\x02\x8b\xfe\xc7\x45\xe0\x01\x00\x00\x00\xeb\x5b\x6a\x40\x6a\x20\xe8\x98\xfb\xff\xff\x59\x59\x85\xc0\x74\x56\x8b\x4d\xe0\x8d\x0c\x8d\x40\xfd\x00\x10\x89\x01\x83\x05\x30\xfd\x00\x10\x20\x8d\x90\x00\x08\x00\x00\xeb\x2a\xc6\x40\x04\x00\x83\x08\xff\xc6\x40\x05\x0a\x83\x60\x08\x00\x80\x60\x24\x80\xc6\x40\x25\x0a\xc6\x40\x26\x0a\x83\x60\x38\x00\xc6\x40\x34\x00\x83\xc0\x40\x8b\x11\x03\xd6\x3b\xc2\x72\xd2\xff\x45\xe0\x39\x3d\x30\xfd\x00\x10\x7c\x9d\xeb\x06\x8b\x3d\x30\xfd\x00\x10\x83\x65\xe0\x00\x85\xff\x7e\x6d\x8b\x45\xe4\x8b\x08\x83\xf9\xff\x74\x56\x83\xf9\xfe\x74\x51\x8a\x03\xa8\x01\x74\x4b\xa8\x08\x75\x0b\x51\xff\x15\xa0\xb0\x00\x10\x85\xc0\x74\x3c\x8b\x75\xe0\x8b\xc6\xc1\xf8\x05\x83\xe6\x1f\xc1\xe6\x06\x03\x34\x85\x40\xfd\x00\x10\x8b\x45\xe4\x8b\x00\x89\x06\x8a\x03\x88\x46\x04\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\x8f\x33\x00\x00\x59\x59\x85\xc0\x0f\x84\xc9\x00\x00\x00\xff\x46\x08\xff\x45\xe0\x43\x83\x45\xe4\x04\x39\x7d\xe0\x7c\x93\x33\xdb\x8b\xf3\xc1\xe6\x06\x03\x35\x40\xfd\x00\x10\x8b\x06\x83\xf8\xff\x74\x0b\x83\xf8\xfe\x74\x06\x80\x4e\x04\x80\xeb\x72\xc6\x46\x04\x81\x85\xdb\x75\x05\x6a\xf6\x58\xeb\x0a\x8b\xc3\x48\xf7\xd8\x1b\xc0\x83\xc0\xf5\x50\xff\x15\x9c\xb0\x00\x10\x8b\xf8\x83\xff\xff\x74\x43\x85\xff\x74\x3f\x57\xff\x15\xa0\xb0\x00\x10\x85\xc0\x74\x34\x89\x3e\x25\xff\x00\x00\x00\x83\xf8\x02\x75\x06\x80\x4e\x04\x40\xeb\x09\x83\xf8\x03\x75\x04\x80\x4e\x04\x08\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\xf9\x32\x00\x00\x59\x59\x85\xc0\x74\x37\xff\x46\x08\xeb\x0a\x80\x4e\x04\x40\xc7\x06\xfe\xff\xff\xff\x43\x83\xfb\x03\x0f\x8c\x67\xff\xff\xff\xff\x35\x30\xfd\x00\x10\xff\x15\x98\xb0\x00\x10\x33\xc0\xeb\x11\x33\xc0\x40\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x83\xc8\xff\xe8\x77\xf1\xff\xff\xc3\x8b\xff\x56\x57\xbe\x40\xfd\x00\x10\x8b\x3e\x85\xff\x74\x31\x8d\x87\x00\x08\x00\x00\xeb\x1a\x83\x7f\x08\x00\x74\x0a\x8d\x47\x0c\x50\xff\x15\xa8\xb0\x00\x10\x8b\x06\x83\xc7\x40\x05\x00\x08\x00\x00\x3b\xf8\x72\xe2\xff\x36\xe8\xf0\xf8\xff\xff\x83\x26\x00\x59\x83\xc6\x04\x81\xfe\x40\xfe\x00\x10\x7c\xbe\x5f\x5e\xc3\x83\x3d\x4c\xfe\x00\x10\x00\x75\x05\xe8\xa8\x12\x00\x00\x56\x8b\x35\xe8\xee\x00\x10\x57\x33\xff\x85\xf6\x75\x18\x83\xc8\xff\xe9\xa0\x00\x00\x00\x3c\x3d\x74\x01\x47\x56\xe8\x58\x17\x00\x00\x59\x8d\x74\x06\x01\x8a\x06\x84\xc0\x75\xea\x6a\x04\x47\x57\xe8\x6e\xf9\xff\xff\x8b\xf8\x59\x59\x89\x3d\x50\xf2\x00\x10\x85\xff\x74\xcb\x8b\x35\xe8\xee\x00\x10\x53\xeb\x42\x56\xe8\x27\x17\x00\x00\x8b\xd8\x43\x80\x3e\x3d\x59\x74\x31\x6a\x01\x53\xe8\x40\xf9\xff\xff\x59\x59\x89\x07\x85\xc0\x74\x4e\x56\x53\x50\xe8\x7b\x32\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0f\x33\xc0\x50\x50\x50\x50\x50\xe8\x75\xee\xff\xff\x83\xc4\x14\x83\xc7\x04\x03\xf3\x80\x3e\x00\x75\xb9\xff\x35\xe8\xee\x00\x10\xe8\x32\xf8\xff\xff\x83\x25\xe8\xee\x00\x10\x00\x83\x27\x00\xc7\x05\x40\xfe\x00\x10\x01\x00\x00\x00\x33\xc0\x59\x5b\x5f\x5e\xc3\xff\x35\x50\xf2\x00\x10\xe8\x0c\xf8\xff\xff\x83\x25\x50\xf2\x00\x10\x00\x83\xc8\xff\xeb\xe4\x8b\xff\x55\x8b\xec\x51\x8b\x4d\x10\x53\x33\xc0\x56\x89\x07\x8b\xf2\x8b\x55\x0c\xc7\x01\x01\x00\x00\x00\x39\x45\x08\x74\x09\x8b\x5d\x08\x83\x45\x08\x04\x89\x13\x89\x45\xfc\x80\x3e\x22\x75\x10\x33\xc0\x39\x45\xfc\xb3\x22\x0f\x94\xc0\x46\x89\x45\xfc\xeb\x3c\xff\x07\x85\xd2\x74\x08\x8a\x06\x88\x02\x42\x89\x55\x0c\x8a\x1e\x0f\xb6\xc3\x50\x46\xe8\x7f\x32\x00\x00\x59\x85\xc0\x74\x13\xff\x07\x83\x7d\x0c\x00\x74\x0a\x8b\x4d\x0c\x8a\x06\xff\x45\x0c\x88\x01\x46\x8b\x55\x0c\x8b\x4d\x10\x84\xdb\x74\x32\x83\x7d\xfc\x00\x75\xa9\x80\xfb\x20\x74\x05\x80\xfb\x09\x75\x9f\x85\xd2\x74\x04\xc6\x42\xff\x00\x83\x65\xfc\x00\x80\x3e\x00\x0f\x84\xe9\x00\x00\x00\x8a\x06\x3c\x20\x74\x04\x3c\x09\x75\x06\x46\xeb\xf3\x4e\xeb\xe3\x80\x3e\x00\x0f\x84\xd0\x00\x00\x00\x83\x7d\x08\x00\x74\x09\x8b\x45\x08\x83\x45\x08\x04\x89\x10\xff\x01\x33\xdb\x43\x33\xc9\xeb\x02\x46\x41\x80\x3e\x5c\x74\xf9\x80\x3e\x22\x75\x26\xf6\xc1\x01\x75\x1f\x83\x7d\xfc\x00\x74\x0c\x8d\x46\x01\x80\x38\x22\x75\x04\x8b\xf0\xeb\x0d\x33\xc0\x33\xdb\x39\x45\xfc\x0f\x94\xc0\x89\x45\xfc\xd1\xe9\x85\xc9\x74\x12\x49\x85\xd2\x74\x04\xc6\x02\x5c\x42\xff\x07\x85\xc9\x75\xf1\x89\x55\x0c\x8a\x06\x84\xc0\x74\x55\x83\x7d\xfc\x00\x75\x08\x3c\x20\x74\x4b\x3c\x09\x74\x47\x85\xdb\x74\x3d\x0f\xbe\xc0\x50\x85\xd2\x74\x23\xe8\x9a\x31\x00\x00\x59\x85\xc0\x74\x0d\x8a\x06\x8b\x4d\x0c\xff\x45\x0c\x88\x01\x46\xff\x07\x8b\x4d\x0c\x8a\x06\xff\x45\x0c\x88\x01\xeb\x0d\xe8\x77\x31\x00\x00\x59\x85\xc0\x74\x03\x46\xff\x07\xff\x07\x8b\x55\x0c\x46\xe9\x56\xff\xff\xff\x85\xd2\x74\x07\xc6\x02\x00\x42\x89\x55\x0c\xff\x07\x8b\x4d\x10\xe9\x0e\xff\xff\xff\x8b\x45\x08\x5e\x5b\x85\xc0\x74\x03\x83\x20\x00\xff\x01\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\x53\x33\xdb\x56\x57\x39\x1d\x4c\xfe\x00\x10\x75\x05\xe8\x24\x10\x00\x00\x68\x04\x01\x00\x00\xbe\x78\xf2\x00\x10\x56\x53\x88\x1d\x7c\xf3\x00\x10\xff\x15\xac\xb0\x00\x10\xa1\x64\x0e\x01\x10\x89\x35\x60\xf2\x00\x10\x3b\xc3\x74\x07\x89\x45\xfc\x38\x18\x75\x03\x89\x75\xfc\x8b\x55\xfc\x8d\x45\xf8\x50\x53\x53\x8d\x7d\xf4\xe8\x0a\xfe\xff\xff\x8b\x45\xf8\x83\xc4\x0c\x3d\xff\xff\xff\x3f\x73\x4a\x8b\x4d\xf4\x83\xf9\xff\x73\x42\x8b\xf8\xc1\xe7\x02\x8d\x04\x0f\x3b\xc1\x72\x36\x50\xe8\x71\xf6\xff\xff\x8b\xf0\x59\x3b\xf3\x74\x29\x8b\x55\xfc\x8d\x45\xf8\x50\x03\xfe\x57\x56\x8d\x7d\xf4\xe8\xc9\xfd\xff\xff\x8b\x45\xf8\x83\xc4\x0c\x48\xa3\x44\xf2\x00\x10\x89\x35\x48\xf2\x00\x10\x33\xc0\xeb\x03\x83\xc8\xff\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\xa1\x80\xf3\x00\x10\x83\xec\x0c\x53\x56\x8b\x35\xc0\xb0\x00\x10\x57\x33\xdb\x33\xff\x3b\xc3\x75\x2e\xff\xd6\x8b\xf8\x3b\xfb\x74\x0c\xc7\x05\x80\xf3\x00\x10\x01\x00\x00\x00\xeb\x23\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\x6a\x02\x58\xa3\x80\xf3\x00\x10\xeb\x05\xa1\x80\xf3\x00\x10\x83\xf8\x01\x0f\x85\x81\x00\x00\x00\x3b\xfb\x75\x0f\xff\xd6\x8b\xf8\x3b\xfb\x75\x07\x33\xc0\xe9\xca\x00\x00\x00\x8b\xc7\x66\x39\x1f\x74\x0e\x40\x40\x66\x39\x18\x75\xf9\x40\x40\x66\x39\x18\x75\xf2\x8b\x35\xbc\xb0\x00\x10\x53\x53\x53\x2b\xc7\x53\xd1\xf8\x40\x50\x57\x53\x53\x89\x45\xf4\xff\xd6\x89\x45\xf8\x3b\xc3\x74\x2f\x50\xe8\x97\xf5\xff\xff\x59\x89\x45\xfc\x3b\xc3\x74\x21\x53\x53\xff\x75\xf8\x50\xff\x75\xf4\x57\x53\x53\xff\xd6\x85\xc0\x75\x0c\xff\x75\xfc\xe8\xe7\xf4\xff\xff\x59\x89\x5d\xfc\x8b\x5d\xfc\x57\xff\x15\xb8\xb0\x00\x10\x8b\xc3\xeb\x5c\x83\xf8\x02\x74\x04\x3b\xc3\x75\x82\xff\x15\xb4\xb0\x00\x10\x8b\xf0\x3b\xf3\x0f\x84\x72\xff\xff\xff\x38\x1e\x74\x0a\x40\x38\x18\x75\xfb\x40\x38\x18\x75\xf6\x2b\xc6\x40\x50\x89\x45\xf8\xe8\x30\xf5\xff\xff\x8b\xf8\x59\x3b\xfb\x75\x0c\x56\xff\x15\xb0\xb0\x00\x10\xe9\x45\xff\xff\xff\xff\x75\xf8\x56\x57\xe8\x7e\x2f\x00\x00\x83\xc4\x0c\x56\xff\x15\xb0\xb0\x00\x10\x8b\xc7\x5f\x5e\x5b\xc9\xc3\x8b\xff\x56\xb8\x50\xc5\x00\x10\xbe\x50\xc5\x00\x10\x57\x8b\xf8\x3b\xc6\x73\x0f\x8b\x07\x85\xc0\x74\x02\xff\xd0\x83\xc7\x04\x3b\xfe\x72\xf1\x5f\x5e\xc3\x8b\xff\x56\xb8\x58\xc5\x00\x10\xbe\x58\xc5\x00\x10\x57\x8b\xf8\x3b\xc6\x73\x0f\x8b\x07\x85\xc0\x74\x02\xff\xd0\x83\xc7\x04\x3b\xfe\x72\xf1\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x33\xc0\x39\x45\x08\x6a\x00\x0f\x94\xc0\x68\x00\x10\x00\x00\x50\xff\x15\xc4\xb0\x00\x10\xa3\x84\xf3\x00\x10\x85\xc0\x75\x02\x5d\xc3\x33\xc0\x40\xa3\x2c\xfd\x00\x10\x5d\xc3\xcc\x83\x3d\x2c\xfd\x00\x10\x03\x75\x57\x53\x33\xdb\x39\x1d\x10\xfd\x00\x10\x57\x8b\x3d\x8c\xb0\x00\x10\x7e\x33\x56\x8b\x35\x14\xfd\x00\x10\x83\xc6\x10\x68\x00\x80\x00\x00\x6a\x00\xff\x76\xfc\xff\x15\xcc\xb0\x00\x10\xff\x36\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x83\xc6\x14\x43\x3b\x1d\x10\xfd\x00\x10\x7c\xd8\x5e\xff\x35\x14\xfd\x00\x10\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x5f\x5b\xff\x35\x84\xf3\x00\x10\xff\x15\xc8\xb0\x00\x10\x83\x25\x84\xf3\x00\x10\x00\xc3\xc3\x8b\xff\x55\x8b\xec\x51\x51\x56\xe8\xb8\xef\xff\xff\x8b\xf0\x85\xf6\x0f\x84\x46\x01\x00\x00\x8b\x56\x5c\xa1\x60\xe4\x00\x10\x57\x8b\x7d\x08\x8b\xca\x53\x39\x39\x74\x0e\x8b\xd8\x6b\xdb\x0c\x83\xc1\x0c\x03\xda\x3b\xcb\x72\xee\x6b\xc0\x0c\x03\xc2\x3b\xc8\x73\x08\x39\x39\x75\x04\x8b\xc1\xeb\x02\x33\xc0\x85\xc0\x74\x0a\x8b\x58\x08\x89\x5d\xfc\x85\xdb\x75\x07\x33\xc0\xe9\xfb\x00\x00\x00\x83\xfb\x05\x75\x0c\x83\x60\x08\x00\x33\xc0\x40\xe9\xea\x00\x00\x00\x83\xfb\x01\x0f\x84\xde\x00\x00\x00\x8b\x4e\x60\x89\x4d\xf8\x8b\x4d\x0c\x89\x4e\x60\x8b\x48\x04\x83\xf9\x08\x0f\x85\xb8\x00\x00\x00\x8b\x0d\x54\xe4\x00\x10\x8b\x3d\x58\xe4\x00\x10\x8b\xd1\x03\xf9\x3b\xd7\x7d\x24\x6b\xc9\x0c\x8b\x7e\x5c\x83\x64\x39\x08\x00\x8b\x3d\x54\xe4\x00\x10\x8b\x1d\x58\xe4\x00\x10\x42\x03\xdf\x83\xc1\x0c\x3b\xd3\x7c\xe2\x8b\x5d\xfc\x8b\x00\x8b\x7e\x64\x3d\x8e\x00\x00\xc0\x75\x09\xc7\x46\x64\x83\x00\x00\x00\xeb\x5e\x3d\x90\x00\x00\xc0\x75\x09\xc7\x46\x64\x81\x00\x00\x00\xeb\x4e\x3d\x91\x00\x00\xc0\x75\x09\xc7\x46\x64\x84\x00\x00\x00\xeb\x3e\x3d\x93\x00\x00\xc0\x75\x09\xc7\x46\x64\x85\x00\x00\x00\xeb\x2e\x3d\x8d\x00\x00\xc0\x75\x09\xc7\x46\x64\x82\x00\x00\x00\xeb\x1e\x3d\x8f\x00\x00\xc0\x75\x09\xc7\x46\x64\x86\x00\x00\x00\xeb\x0e\x3d\x92\x00\x00\xc0\x75\x07\xc7\x46\x64\x8a\x00\x00\x00\xff\x76\x64\x6a\x08\xff\xd3\x59\x89\x7e\x64\xeb\x07\x83\x60\x08\x00\x51\xff\xd3\x8b\x45\xf8\x59\x89\x46\x60\x83\xc8\xff\x5b\x5f\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\xb8\x63\x73\x6d\xe0\x39\x45\x08\x75\x0d\xff\x75\x0c\x50\xe8\x88\xfe\xff\xff\x59\x59\x5d\xc3\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xa1\x00\xe0\x00\x10\x83\x65\xf8\x00\x83\x65\xfc\x00\x53\x57\xbf\x4e\xe6\x40\xbb\xbb\x00\x00\xff\xff\x3b\xc7\x74\x0d\x85\xc3\x74\x09\xf7\xd0\xa3\x04\xe0\x00\x10\xeb\x60\x56\x8d\x45\xf8\x50\xff\x15\xdc\xb0\x00\x10\x8b\x75\xfc\x33\x75\xf8\xff\x15\xd8\xb0\x00\x10\x33\xf0\xff\x15\x48\xb0\x00\x10\x33\xf0\xff\x15\xd4\xb0\x00\x10\x33\xf0\x8d\x45\xf0\x50\xff\x15\xd0\xb0\x00\x10\x8b\x45\xf4\x33\x45\xf0\x33\xf0\x3b\xf7\x75\x07\xbe\x4f\xe6\x40\xbb\xeb\x0b\x85\xf3\x75\x07\x8b\xc6\xc1\xe0\x10\x0b\xf0\x89\x35\x00\xe0\x00\x10\xf7\xd6\x89\x35\x04\xe0\x00\x10\x5e\x5f\x5b\xc9\xc3\x83\x25\x28\xfd\x00\x10\x00\xc3\x6a\x10\x68\x50\xc6\x00\x10\xe8\x5d\xe9\xff\xff\x33\xdb\x89\x5d\xe4\x6a\x01\xe8\x96\x03\x00\x00\x59\x89\x5d\xfc\x6a\x03\x5f\x89\x7d\xe0\x3b\x3d\x60\x0e\x01\x10\x7d\x57\x8b\xf7\xc1\xe6\x02\xa1\x5c\xfe\x00\x10\x03\xc6\x39\x18\x74\x44\x8b\x00\xf6\x40\x0c\x83\x74\x0f\x50\xe8\xf1\x2f\x00\x00\x59\x83\xf8\xff\x74\x03\xff\x45\xe4\x83\xff\x14\x7c\x28\xa1\x5c\xfe\x00\x10\x8b\x04\x06\x83\xc0\x20\x50\xff\x15\xa8\xb0\x00\x10\xa1\x5c\xfe\x00\x10\xff\x34\x06\xe8\xef\xf0\xff\xff\x59\xa1\x5c\xfe\x00\x10\x89\x1c\x06\x47\xeb\x9e\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x19\xe9\xff\xff\xc3\x6a\x01\xe8\x37\x02\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x8b\x46\x0c\x8b\xc8\x80\xe1\x03\x33\xdb\x80\xf9\x02\x75\x40\xa9\x08\x01\x00\x00\x74\x39\x8b\x46\x08\x57\x8b\x3e\x2b\xf8\x85\xff\x7e\x2c\x57\x50\x56\xe8\x72\x03\x00\x00\x59\x50\xe8\x0e\x37\x00\x00\x83\xc4\x0c\x3b\xc7\x75\x0f\x8b\x46\x0c\x84\xc0\x79\x0f\x83\xe0\xfd\x89\x46\x0c\xeb\x07\x83\x4e\x0c\x20\x83\xcb\xff\x5f\x8b\x46\x08\x83\x66\x04\x00\x89\x06\x5e\x8b\xc3\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x75\x09\x56\xe8\x35\x00\x00\x00\x59\xeb\x2f\x56\xe8\x7c\xff\xff\xff\x59\x85\xc0\x74\x05\x83\xc8\xff\xeb\x1f\xf7\x46\x0c\x00\x40\x00\x00\x74\x14\x56\xe8\x09\x03\x00\x00\x50\xe8\x82\x37\x00\x00\x59\xf7\xd8\x59\x1b\xc0\xeb\x02\x33\xc0\x5e\x5d\xc3\x6a\x14\x68\x70\xc6\x00\x10\xe8\x0e\xe8\xff\xff\x33\xff\x89\x7d\xe4\x89\x7d\xdc\x6a\x01\xe8\x44\x02\x00\x00\x59\x89\x7d\xfc\x33\xf6\x89\x75\xe0\x3b\x35\x60\x0e\x01\x10\x0f\x8d\x83\x00\x00\x00\xa1\x5c\xfe\x00\x10\x8d\x04\xb0\x39\x38\x74\x5e\x8b\x00\xf6\x40\x0c\x83\x74\x56\x50\x56\xe8\xb4\xd7\xff\xff\x59\x59\x33\xd2\x42\x89\x55\xfc\xa1\x5c\xfe\x00\x10\x8b\x04\xb0\x8b\x48\x0c\xf6\xc1\x83\x74\x2f\x39\x55\x08\x75\x11\x50\xe8\x4a\xff\xff\xff\x59\x83\xf8\xff\x74\x1e\xff\x45\xe4\xeb\x19\x39\x7d\x08\x75\x14\xf6\xc1\x02\x74\x0f\x50\xe8\x2f\xff\xff\xff\x59\x83\xf8\xff\x75\x03\x09\x45\xdc\x89\x7d\xfc\xe8\x08\x00\x00\x00\x46\xeb\x84\x33\xff\x8b\x75\xe0\xa1\x5c\xfe\x00\x10\xff\x34\xb0\x56\xe8\xbd\xd7\xff\xff\x59\x59\xc3\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x12\x00\x00\x00\x83\x7d\x08\x01\x8b\x45\xe4\x74\x03\x8b\x45\xdc\xe8\x8f\xe7\xff\xff\xc3\x6a\x01\xe8\xad\x00\x00\x00\x59\xc3\x6a\x01\xe8\x1f\xff\xff\xff\x59\xc3\x8b\xff\x56\x57\x33\xf6\xbf\x88\xf3\x00\x10\x83\x3c\xf5\x6c\xe4\x00\x10\x01\x75\x1e\x8d\x04\xf5\x68\xe4\x00\x10\x89\x38\x68\xa0\x0f\x00\x00\xff\x30\x83\xc7\x18\xe8\x8c\x28\x00\x00\x59\x59\x85\xc0\x74\x0c\x46\x83\xfe\x24\x7c\xd2\x33\xc0\x40\x5f\x5e\xc3\x83\x24\xf5\x68\xe4\x00\x10\x00\x33\xc0\xeb\xf1\x8b\xff\x53\x8b\x1d\xa8\xb0\x00\x10\x56\xbe\x68\xe4\x00\x10\x57\x8b\x3e\x85\xff\x74\x13\x83\x7e\x04\x01\x74\x0d\x57\xff\xd3\x57\xe8\xc2\xee\xff\xff\x83\x26\x00\x59\x83\xc6\x08\x81\xfe\x88\xe5\x00\x10\x7c\xdc\xbe\x68\xe4\x00\x10\x5f\x8b\x06\x85\xc0\x74\x09\x83\x7e\x04\x01\x75\x03\x50\xff\xd3\x83\xc6\x08\x81\xfe\x88\xe5\x00\x10\x7c\xe6\x5e\x5b\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xff\x34\xc5\x68\xe4\x00\x10\xff\x15\x68\xb0\x00\x10\x5d\xc3\x6a\x0c\x68\x98\xc6\x00\x10\xe8\x72\xe6\xff\xff\x33\xff\x47\x89\x7d\xe4\x33\xdb\x39\x1d\x84\xf3\x00\x10\x75\x18\xe8\xdf\x23\x00\x00\x6a\x1e\xe8\x2d\x22\x00\x00\x68\xff\x00\x00\x00\xe8\x38\xf0\xff\xff\x59\x59\x8b\x75\x08\x8d\x34\xf5\x68\xe4\x00\x10\x39\x1e\x74\x04\x8b\xc7\xeb\x6e\x6a\x18\xe8\xba\xee\xff\xff\x59\x8b\xf8\x3b\xfb\x75\x0f\xe8\xdb\xe5\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\xeb\x51\x6a\x0a\xe8\x59\x00\x00\x00\x59\x89\x5d\xfc\x39\x1e\x75\x2c\x68\xa0\x0f\x00\x00\x57\xe8\x83\x27\x00\x00\x59\x59\x85\xc0\x75\x17\x57\xe8\xf0\xed\xff\xff\x59\xe8\xa5\xe5\xff\xff\xc7\x00\x0c\x00\x00\x00\x89\x5d\xe4\xeb\x0b\x89\x3e\xeb\x07\x57\xe8\xd5\xed\xff\xff\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x0a\xe6\xff\xff\xc3\x6a\x0a\xe8\x28\xff\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x8d\x34\xc5\x68\xe4\x00\x10\x83\x3e\x00\x75\x13\x50\xe8\x22\xff\xff\xff\x59\x85\xc0\x75\x08\x6a\x11\xe8\x2c\xef\xff\xff\x59\xff\x36\xff\x15\x64\xb0\x00\x10\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\xfe\x75\x0f\xe8\x2c\xe5\xff\xff\xc7\x00\x09\x00\x00\x00\x33\xc0\x5d\xc3\x56\x33\xf6\x3b\xc6\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x1c\xe8\x0e\xe5\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x09\x00\x00\x00\xe8\x96\xe4\xff\xff\x83\xc4\x14\x33\xc0\xeb\x1a\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x0f\xbe\x44\x01\x04\x83\xe0\x40\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x33\xf6\x3b\xc6\x75\x1d\xe8\xc6\xe4\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x4e\xe4\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x03\x8b\x40\x10\x5e\x5d\xc3\x2d\xa4\x03\x00\x00\x74\x22\x83\xe8\x04\x74\x17\x83\xe8\x0d\x74\x0c\x48\x74\x03\x33\xc0\xc3\xb8\x04\x04\x00\x00\xc3\xb8\x12\x04\x00\x00\xc3\xb8\x04\x08\x00\x00\xc3\xb8\x11\x04\x00\x00\xc3\x8b\xff\x56\x57\x8b\xf0\x68\x01\x01\x00\x00\x33\xff\x8d\x46\x1c\x57\x50\xe8\x50\x0e\x00\x00\x33\xc0\x0f\xb7\xc8\x8b\xc1\x89\x7e\x04\x89\x7e\x08\x89\x7e\x0c\xc1\xe1\x10\x0b\xc1\x8d\x7e\x10\xab\xab\xab\xb9\x88\xe5\x00\x10\x83\xc4\x0c\x8d\x46\x1c\x2b\xce\xbf\x01\x01\x00\x00\x8a\x14\x01\x88\x10\x40\x4f\x75\xf7\x8d\x86\x1d\x01\x00\x00\xbe\x00\x01\x00\x00\x8a\x14\x08\x88\x10\x40\x4e\x75\xf7\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x81\xec\x1c\x05\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x57\x8d\x85\xe8\xfa\xff\xff\x50\xff\x76\x04\xff\x15\xe0\xb0\x00\x10\xbf\x00\x01\x00\x00\x85\xc0\x0f\x84\xfb\x00\x00\x00\x33\xc0\x88\x84\x05\xfc\xfe\xff\xff\x40\x3b\xc7\x72\xf4\x8a\x85\xee\xfa\xff\xff\xc6\x85\xfc\xfe\xff\xff\x20\x84\xc0\x74\x2e\x8d\x9d\xef\xfa\xff\xff\x0f\xb6\xc8\x0f\xb6\x03\x3b\xc8\x77\x16\x2b\xc1\x40\x50\x8d\x94\x0d\xfc\xfe\xff\xff\x6a\x20\x52\xe8\x8d\x0d\x00\x00\x83\xc4\x0c\x43\x8a\x03\x43\x84\xc0\x75\xd8\x6a\x00\xff\x76\x0c\x8d\x85\xfc\xfa\xff\xff\xff\x76\x04\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x6a\x01\x6a\x00\xe8\xbe\x39\x00\x00\x33\xdb\x53\xff\x76\x04\x8d\x85\xfc\xfd\xff\xff\x57\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x57\xff\x76\x0c\x53\xe8\x9f\x37\x00\x00\x83\xc4\x44\x53\xff\x76\x04\x8d\x85\xfc\xfc\xff\xff\x57\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x68\x00\x02\x00\x00\xff\x76\x0c\x53\xe8\x7a\x37\x00\x00\x83\xc4\x24\x33\xc0\x0f\xb7\x8c\x45\xfc\xfa\xff\xff\xf6\xc1\x01\x74\x0e\x80\x4c\x06\x1d\x10\x8a\x8c\x05\xfc\xfd\xff\xff\xeb\x11\xf6\xc1\x02\x74\x15\x80\x4c\x06\x1d\x20\x8a\x8c\x05\xfc\xfc\xff\xff\x88\x8c\x06\x1d\x01\x00\x00\xeb\x08\xc6\x84\x06\x1d\x01\x00\x00\x00\x40\x3b\xc7\x72\xbe\xeb\x56\x8d\x86\x1d\x01\x00\x00\xc7\x85\xe4\xfa\xff\xff\x9f\xff\xff\xff\x33\xc9\x29\x85\xe4\xfa\xff\xff\x8b\x95\xe4\xfa\xff\xff\x8d\x84\x0e\x1d\x01\x00\x00\x03\xd0\x8d\x5a\x20\x83\xfb\x19\x77\x0c\x80\x4c\x0e\x1d\x10\x8a\xd1\x80\xc2\x20\xeb\x0f\x83\xfa\x19\x77\x0e\x80\x4c\x0e\x1d\x20\x8a\xd1\x80\xea\x20\x88\x10\xeb\x03\xc6\x00\x00\x41\x3b\xcf\x72\xc2\x8b\x4d\xfc\x5f\x33\xcd\x5b\xe8\xa0\xcc\xff\xff\xc9\xc3\x6a\x0c\x68\xb8\xc6\x00\x10\xe8\xc0\xe2\xff\xff\xe8\x72\xe7\xff\xff\x8b\xf8\xa1\xac\xea\x00\x10\x85\x47\x70\x74\x1d\x83\x7f\x6c\x00\x74\x17\x8b\x77\x68\x85\xf6\x75\x08\x6a\x20\xe8\x33\xec\xff\xff\x59\x8b\xc6\xe8\xd8\xe2\xff\xff\xc3\x6a\x0d\xe8\xd0\xfc\xff\xff\x59\x83\x65\xfc\x00\x8b\x77\x68\x89\x75\xe4\x3b\x35\xb0\xe9\x00\x10\x74\x36\x85\xf6\x74\x1a\x56\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x0f\x81\xfe\x88\xe5\x00\x10\x74\x07\x56\xe8\x56\xea\xff\xff\x59\xa1\xb0\xe9\x00\x10\x89\x47\x68\x8b\x35\xb0\xe9\x00\x10\x89\x75\xe4\x56\xff\x15\x80\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x05\x00\x00\x00\xeb\x8e\x8b\x75\xe4\x6a\x0d\xe8\x95\xfb\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x33\xdb\x53\x8d\x4d\xf0\xe8\x66\xd3\xff\xff\x89\x1d\xd8\xf4\x00\x10\x83\xfe\xfe\x75\x1e\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xff\x15\xe8\xb0\x00\x10\x38\x5d\xfc\x74\x45\x8b\x4d\xf8\x83\x61\x70\xfd\xeb\x3c\x83\xfe\xfd\x75\x12\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xff\x15\xe4\xb0\x00\x10\xeb\xdb\x83\xfe\xfc\x75\x12\x8b\x45\xf0\x8b\x40\x04\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xeb\xc4\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x8b\xc6\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x20\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x8b\x5d\x0c\x56\x8b\x75\x08\x57\xe8\x64\xff\xff\xff\x8b\xf8\x33\xf6\x89\x7d\x08\x3b\xfe\x75\x0e\x8b\xc3\xe8\xb7\xfc\xff\xff\x33\xc0\xe9\x9d\x01\x00\x00\x89\x75\xe4\x33\xc0\x39\xb8\xb8\xe9\x00\x10\x0f\x84\x91\x00\x00\x00\xff\x45\xe4\x83\xc0\x30\x3d\xf0\x00\x00\x00\x72\xe7\x81\xff\xe8\xfd\x00\x00\x0f\x84\x70\x01\x00\x00\x81\xff\xe9\xfd\x00\x00\x0f\x84\x64\x01\x00\x00\x0f\xb7\xc7\x50\xff\x15\xec\xb0\x00\x10\x85\xc0\x0f\x84\x52\x01\x00\x00\x8d\x45\xe8\x50\x57\xff\x15\xe0\xb0\x00\x10\x85\xc0\x0f\x84\x33\x01\x00\x00\x68\x01\x01\x00\x00\x8d\x43\x1c\x56\x50\xe8\xad\x0a\x00\x00\x33\xd2\x42\x83\xc4\x0c\x89\x7b\x04\x89\x73\x0c\x39\x55\xe8\x0f\x86\xf8\x00\x00\x00\x80\x7d\xee\x00\x0f\x84\xcf\x00\x00\x00\x8d\x75\xef\x8a\x0e\x84\xc9\x0f\x84\xc2\x00\x00\x00\x0f\xb6\x46\xff\x0f\xb6\xc9\xe9\xa6\x00\x00\x00\x68\x01\x01\x00\x00\x8d\x43\x1c\x56\x50\xe8\x66\x0a\x00\x00\x8b\x4d\xe4\x83\xc4\x0c\x6b\xc9\x30\x89\x75\xe0\x8d\xb1\xc8\xe9\x00\x10\x89\x75\xe4\xeb\x2a\x8a\x46\x01\x84\xc0\x74\x28\x0f\xb6\x3e\x0f\xb6\xc0\xeb\x12\x8b\x45\xe0\x8a\x80\xb4\xe9\x00\x10\x08\x44\x3b\x1d\x0f\xb6\x46\x01\x47\x3b\xf8\x76\xea\x8b\x7d\x08\x46\x46\x80\x3e\x00\x75\xd1\x8b\x75\xe4\xff\x45\xe0\x83\xc6\x08\x83\x7d\xe0\x04\x89\x75\xe4\x72\xe9\x8b\xc7\x89\x7b\x04\xc7\x43\x08\x01\x00\x00\x00\xe8\x67\xfb\xff\xff\x6a\x06\x89\x43\x0c\x8d\x43\x10\x8d\x89\xbc\xe9\x00\x10\x5a\x66\x8b\x31\x41\x66\x89\x30\x41\x40\x40\x4a\x75\xf3\x8b\xf3\xe8\xd7\xfb\xff\xff\xe9\xb7\xfe\xff\xff\x80\x4c\x03\x1d\x04\x40\x3b\xc1\x76\xf6\x46\x46\x80\x7e\xff\x00\x0f\x85\x34\xff\xff\xff\x8d\x43\x1e\xb9\xfe\x00\x00\x00\x80\x08\x08\x40\x49\x75\xf9\x8b\x43\x04\xe8\x12\xfb\xff\xff\x89\x43\x0c\x89\x53\x08\xeb\x03\x89\x73\x08\x33\xc0\x0f\xb7\xc8\x8b\xc1\xc1\xe1\x10\x0b\xc1\x8d\x7b\x10\xab\xab\xab\xeb\xa8\x39\x35\xd8\xf4\x00\x10\x0f\x85\x58\xfe\xff\xff\x83\xc8\xff\x8b\x4d\xfc\x5f\x5e\x33\xcd\x5b\xe8\x9b\xc9\xff\xff\xc9\xc3\x6a\x14\x68\xd8\xc6\x00\x10\xe8\xbb\xdf\xff\xff\x83\x4d\xe0\xff\xe8\x69\xe4\xff\xff\x8b\xf8\x89\x7d\xdc\xe8\xdc\xfc\xff\xff\x8b\x5f\x68\x8b\x75\x08\xe8\x75\xfd\xff\xff\x89\x45\x08\x3b\x43\x04\x0f\x84\x57\x01\x00\x00\x68\x20\x02\x00\x00\xe8\x10\xe8\xff\xff\x59\x8b\xd8\x85\xdb\x0f\x84\x46\x01\x00\x00\xb9\x88\x00\x00\x00\x8b\x77\x68\x8b\xfb\xf3\xa5\x83\x23\x00\x53\xff\x75\x08\xe8\xb8\xfd\xff\xff\x59\x59\x89\x45\xe0\x85\xc0\x0f\x85\xfc\x00\x00\x00\x8b\x75\xdc\xff\x76\x68\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x11\x8b\x46\x68\x3d\x88\xe5\x00\x10\x74\x07\x50\xe8\x32\xe7\xff\xff\x59\x89\x5e\x68\x53\x8b\x3d\x80\xb0\x00\x10\xff\xd7\xf6\x46\x70\x02\x0f\x85\xea\x00\x00\x00\xf6\x05\xac\xea\x00\x10\x01\x0f\x85\xdd\x00\x00\x00\x6a\x0d\xe8\x51\xf9\xff\xff\x59\x83\x65\xfc\x00\x8b\x43\x04\xa3\xe8\xf4\x00\x10\x8b\x43\x08\xa3\xec\xf4\x00\x10\x8b\x43\x0c\xa3\xf0\xf4\x00\x10\x33\xc0\x89\x45\xe4\x83\xf8\x05\x7d\x10\x66\x8b\x4c\x43\x10\x66\x89\x0c\x45\xdc\xf4\x00\x10\x40\xeb\xe8\x33\xc0\x89\x45\xe4\x3d\x01\x01\x00\x00\x7d\x0d\x8a\x4c\x18\x1c\x88\x88\xa8\xe7\x00\x10\x40\xeb\xe9\x33\xc0\x89\x45\xe4\x3d\x00\x01\x00\x00\x7d\x10\x8a\x8c\x18\x1d\x01\x00\x00\x88\x88\xb0\xe8\x00\x10\x40\xeb\xe6\xff\x35\xb0\xe9\x00\x10\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x13\xa1\xb0\xe9\x00\x10\x3d\x88\xe5\x00\x10\x74\x07\x50\xe8\x79\xe6\xff\xff\x59\x89\x1d\xb0\xe9\x00\x10\x53\xff\xd7\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x02\x00\x00\x00\xeb\x30\x6a\x0d\xe8\xca\xf7\xff\xff\x59\xc3\xeb\x25\x83\xf8\xff\x75\x20\x81\xfb\x88\xe5\x00\x10\x74\x07\x53\xe8\x43\xe6\xff\xff\x59\xe8\xf8\xdd\xff\xff\xc7\x00\x16\x00\x00\x00\xeb\x04\x83\x65\xe0\x00\x8b\x45\xe0\xe8\x73\xde\xff\xff\xc3\x83\x3d\x4c\xfe\x00\x10\x00\x75\x12\x6a\xfd\xe8\x56\xfe\xff\xff\x59\xc7\x05\x4c\xfe\x00\x10\x01\x00\x00\x00\x33\xc0\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x8b\x86\xbc\x00\x00\x00\x33\xdb\x57\x3b\xc3\x74\x6f\x3d\x58\xed\x00\x10\x74\x68\x8b\x86\xb0\x00\x00\x00\x3b\xc3\x74\x5e\x39\x18\x75\x5a\x8b\x86\xb8\x00\x00\x00\x3b\xc3\x74\x17\x39\x18\x75\x13\x50\xe8\xca\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\xe0\x35\x00\x00\x59\x59\x8b\x86\xb4\x00\x00\x00\x3b\xc3\x74\x17\x39\x18\x75\x13\x50\xe8\xa9\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\x7a\x35\x00\x00\x59\x59\xff\xb6\xb0\x00\x00\x00\xe8\x91\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\x86\xe5\xff\xff\x59\x59\x8b\x86\xc0\x00\x00\x00\x3b\xc3\x74\x44\x39\x18\x75\x40\x8b\x86\xc4\x00\x00\x00\x2d\xfe\x00\x00\x00\x50\xe8\x65\xe5\xff\xff\x8b\x86\xcc\x00\x00\x00\xbf\x80\x00\x00\x00\x2b\xc7\x50\xe8\x52\xe5\xff\xff\x8b\x86\xd0\x00\x00\x00\x2b\xc7\x50\xe8\x44\xe5\xff\xff\xff\xb6\xc0\x00\x00\x00\xe8\x39\xe5\xff\xff\x83\xc4\x10\x8d\xbe\xd4\x00\x00\x00\x8b\x07\x3d\x98\xec\x00\x10\x74\x17\x39\x98\xb4\x00\x00\x00\x75\x0f\x50\xe8\x60\x33\x00\x00\xff\x37\xe8\x12\xe5\xff\xff\x59\x59\x8d\x7e\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7f\xf8\xb0\xea\x00\x10\x74\x11\x8b\x07\x3b\xc3\x74\x0b\x39\x18\x75\x07\x50\xe8\xed\xe4\xff\xff\x59\x39\x5f\xfc\x74\x12\x8b\x47\x04\x3b\xc3\x74\x0b\x39\x18\x75\x07\x50\xe8\xd6\xe4\xff\xff\x59\x83\xc7\x10\xff\x4d\x08\x75\xc7\x56\xe8\xc7\xe4\xff\xff\x59\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x35\x80\xb0\x00\x10\x57\x8b\x7d\x08\x57\xff\xd6\x8b\x87\xb0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb8\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb4\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xc0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8d\x5f\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7b\xf8\xb0\xea\x00\x10\x74\x09\x8b\x03\x85\xc0\x74\x03\x50\xff\xd6\x83\x7b\xfc\x00\x74\x0a\x8b\x43\x04\x85\xc0\x74\x03\x50\xff\xd6\x83\xc3\x10\xff\x4d\x08\x75\xd6\x8b\x87\xd4\x00\x00\x00\x05\xb4\x00\x00\x00\x50\xff\xd6\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x57\x8b\x7d\x08\x85\xff\x0f\x84\x83\x00\x00\x00\x53\x56\x8b\x35\x88\xb0\x00\x10\x57\xff\xd6\x8b\x87\xb0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb8\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb4\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xc0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8d\x5f\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7b\xf8\xb0\xea\x00\x10\x74\x09\x8b\x03\x85\xc0\x74\x03\x50\xff\xd6\x83\x7b\xfc\x00\x74\x0a\x8b\x43\x04\x85\xc0\x74\x03\x50\xff\xd6\x83\xc3\x10\xff\x4d\x08\x75\xd6\x8b\x87\xd4\x00\x00\x00\x05\xb4\x00\x00\x00\x50\xff\xd6\x5e\x5b\x8b\xc7\x5f\x5d\xc3\x85\xff\x74\x37\x85\xc0\x74\x33\x56\x8b\x30\x3b\xf7\x74\x28\x57\x89\x38\xe8\xc1\xfe\xff\xff\x59\x85\xf6\x74\x1b\x56\xe8\x45\xff\xff\xff\x83\x3e\x00\x59\x75\x0f\x81\xfe\xb8\xea\x00\x10\x74\x07\x56\xe8\x59\xfd\xff\xff\x59\x8b\xc7\x5e\xc3\x33\xc0\xc3\x6a\x0c\x68\xf8\xc6\x00\x10\xe8\x54\xdb\xff\xff\xe8\x06\xe0\xff\xff\x8b\xf0\xa1\xac\xea\x00\x10\x85\x46\x70\x74\x22\x83\x7e\x6c\x00\x74\x1c\xe8\xef\xdf\xff\xff\x8b\x70\x6c\x85\xf6\x75\x08\x6a\x20\xe8\xc2\xe4\xff\xff\x59\x8b\xc6\xe8\x67\xdb\xff\xff\xc3\x6a\x0c\xe8\x5f\xf5\xff\xff\x59\x83\x65\xfc\x00\x8d\x46\x6c\x8b\x3d\x90\xeb\x00\x10\xe8\x69\xff\xff\xff\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x02\x00\x00\x00\xeb\xc1\x6a\x0c\xe8\x5a\xf4\xff\xff\x59\x8b\x75\xe4\xc3\x8b\xff\x55\x8b\xec\x51\x56\x8b\x75\x0c\x56\xe8\xb6\xf5\xff\xff\x89\x45\x0c\x8b\x46\x0c\x59\xa8\x82\x75\x17\xe8\x80\xda\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4e\x0c\x20\x83\xc8\xff\xe9\x2f\x01\x00\x00\xa8\x40\x74\x0d\xe8\x65\xda\xff\xff\xc7\x00\x22\x00\x00\x00\xeb\xe3\x53\x33\xdb\xa8\x01\x74\x16\x89\x5e\x04\xa8\x10\x0f\x84\x87\x00\x00\x00\x8b\x4e\x08\x83\xe0\xfe\x89\x0e\x89\x46\x0c\x8b\x46\x0c\x83\xe0\xef\x83\xc8\x02\x89\x46\x0c\x89\x5e\x04\x89\x5d\xfc\xa9\x0c\x01\x00\x00\x75\x2c\xe8\x39\xc9\xff\xff\x83\xc0\x20\x3b\xf0\x74\x0c\xe8\x2d\xc9\xff\xff\x83\xc0\x40\x3b\xf0\x75\x0d\xff\x75\x0c\xe8\xc9\xf4\xff\xff\x59\x85\xc0\x75\x07\x56\xe8\xd8\x36\x00\x00\x59\xf7\x46\x0c\x08\x01\x00\x00\x57\x0f\x84\x80\x00\x00\x00\x8b\x46\x08\x8b\x3e\x8d\x48\x01\x89\x0e\x8b\x4e\x18\x2b\xf8\x49\x3b\xfb\x89\x4e\x04\x7e\x1d\x57\x50\xff\x75\x0c\xe8\x95\x28\x00\x00\x83\xc4\x0c\x89\x45\xfc\xeb\x4d\x83\xc8\x20\x89\x46\x0c\x83\xc8\xff\xeb\x79\x8b\x4d\x0c\x83\xf9\xff\x74\x1b\x83\xf9\xfe\x74\x16\x8b\xc1\x83\xe0\x1f\x8b\xd1\xc1\xfa\x05\xc1\xe0\x06\x03\x04\x95\x40\xfd\x00\x10\xeb\x05\xb8\x10\xe4\x00\x10\xf6\x40\x04\x20\x74\x14\x6a\x02\x53\x53\x51\xe8\x44\x35\x00\x00\x23\xc2\x83\xc4\x10\x83\xf8\xff\x74\x25\x8b\x46\x08\x8a\x4d\x08\x88\x08\xeb\x16\x33\xff\x47\x57\x8d\x45\x08\x50\xff\x75\x0c\xe8\x26\x28\x00\x00\x83\xc4\x0c\x89\x45\xfc\x39\x7d\xfc\x74\x09\x83\x4e\x0c\x20\x83\xc8\xff\xeb\x08\x8b\x45\x08\x25\xff\x00\x00\x00\x5f\x5b\x5e\xc9\xc3\x8b\xff\x56\x57\x33\xff\x8d\xb7\xa0\xeb\x00\x10\xff\x36\xe8\x63\xdb\xff\xff\x83\xc7\x04\x59\x89\x06\x83\xff\x28\x72\xe8\x5f\x5e\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x4c\x24\x04\xf7\xc1\x03\x00\x00\x00\x74\x24\x8a\x01\x83\xc1\x01\x84\xc0\x74\x4e\xf7\xc1\x03\x00\x00\x00\x75\xef\x05\x00\x00\x00\x00\x8d\xa4\x24\x00\x00\x00\x00\x8d\xa4\x24\x00\x00\x00\x00\x8b\x01\xba\xff\xfe\xfe\x7e\x03\xd0\x83\xf0\xff\x33\xc2\x83\xc1\x04\xa9\x00\x01\x01\x81\x74\xe8\x8b\x41\xfc\x84\xc0\x74\x32\x84\xe4\x74\x24\xa9\x00\x00\xff\x00\x74\x13\xa9\x00\x00\x00\xff\x74\x02\xeb\xcd\x8d\x41\xff\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfe\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfd\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfc\x8b\x4c\x24\x04\x2b\xc1\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x56\x8b\x75\x0c\x33\xdb\x57\x8b\x7d\x10\x3b\xf3\x75\x14\x3b\xfb\x76\x10\x8b\x45\x08\x3b\xc3\x74\x02\x89\x18\x33\xc0\xe9\x83\x00\x00\x00\x8b\x45\x08\x3b\xc3\x74\x03\x83\x08\xff\x81\xff\xff\xff\xff\x7f\x76\x1b\xe8\x45\xd8\xff\xff\x6a\x16\x5e\x53\x53\x53\x53\x53\x89\x30\xe8\xce\xd7\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x56\xff\x75\x18\x8d\x4d\xf0\xe8\xc0\xc9\xff\xff\x8b\x45\xf0\x39\x58\x14\x0f\x85\x9c\x00\x00\x00\x66\x8b\x45\x14\xb9\xff\x00\x00\x00\x66\x3b\xc1\x76\x36\x3b\xf3\x74\x0f\x3b\xfb\x76\x0b\x57\x53\x56\xe8\xe8\x01\x00\x00\x83\xc4\x0c\xe8\xf2\xd7\xff\xff\xc7\x00\x2a\x00\x00\x00\xe8\xe7\xd7\xff\xff\x8b\x00\x38\x5d\xfc\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\x5f\x5e\x5b\xc9\xc3\x3b\xf3\x74\x32\x3b\xfb\x77\x2c\xe8\xc7\xd7\xff\xff\x6a\x22\x5e\x53\x53\x53\x53\x53\x89\x30\xe8\x50\xd7\xff\xff\x83\xc4\x14\x38\x5d\xfc\x0f\x84\x79\xff\xff\xff\x8b\x45\xf8\x83\x60\x70\xfd\xe9\x6d\xff\xff\xff\x88\x06\x8b\x45\x08\x3b\xc3\x74\x06\xc7\x00\x01\x00\x00\x00\x38\x5d\xfc\x0f\x84\x25\xff\xff\xff\x8b\x45\xf8\x83\x60\x70\xfd\xe9\x19\xff\xff\xff\x8d\x4d\x0c\x51\x53\x57\x56\x6a\x01\x8d\x4d\x14\x51\x53\x89\x5d\x0c\xff\x70\x04\xff\x15\xbc\xb0\x00\x10\x3b\xc3\x74\x14\x39\x5d\x0c\x0f\x85\x5e\xff\xff\xff\x8b\x4d\x08\x3b\xcb\x74\xbd\x89\x01\xeb\xb9\xff\x15\x00\xb0\x00\x10\x83\xf8\x7a\x0f\x85\x44\xff\xff\xff\x3b\xf3\x0f\x84\x67\xff\xff\xff\x3b\xfb\x0f\x86\x5f\xff\xff\xff\x57\x53\x56\xe8\x11\x01\x00\x00\x83\xc4\x0c\xe9\x4f\xff\xff\xff\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\x7c\xfe\xff\xff\x83\xc4\x14\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x0c\x8d\x4d\xf0\xe8\x87\xc8\xff\xff\x0f\xb6\x45\x08\x8b\x4d\xf0\x8b\x89\xc8\x00\x00\x00\x0f\xb7\x04\x41\x25\x00\x80\x00\x00\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x08\xe8\xb9\xff\xff\xff\x59\x59\x5d\xc3\xcc\x56\x8b\x44\x24\x14\x0b\xc0\x75\x28\x8b\x4c\x24\x10\x8b\x44\x24\x0c\x33\xd2\xf7\xf1\x8b\xd8\x8b\x44\x24\x08\xf7\xf1\x8b\xf0\x8b\xc3\xf7\x64\x24\x10\x8b\xc8\x8b\xc6\xf7\x64\x24\x10\x03\xd1\xeb\x47\x8b\xc8\x8b\x5c\x24\x10\x8b\x54\x24\x0c\x8b\x44\x24\x08\xd1\xe9\xd1\xdb\xd1\xea\xd1\xd8\x0b\xc9\x75\xf4\xf7\xf3\x8b\xf0\xf7\x64\x24\x14\x8b\xc8\x8b\x44\x24\x10\xf7\xe6\x03\xd1\x72\x0e\x3b\x54\x24\x0c\x77\x08\x72\x0f\x3b\x44\x24\x08\x76\x09\x4e\x2b\x44\x24\x10\x1b\x54\x24\x14\x33\xdb\x2b\x44\x24\x08\x1b\x54\x24\x0c\xf7\xda\xf7\xd8\x83\xda\x00\x8b\xca\x8b\xd3\x8b\xd9\x8b\xc8\x8b\xc6\x5e\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x54\x24\x0c\x8b\x4c\x24\x04\x85\xd2\x74\x69\x33\xc0\x8a\x44\x24\x08\x84\xc0\x75\x16\x81\xfa\x00\x01\x00\x00\x72\x0e\x83\x3d\x0c\xfd\x00\x10\x00\x74\x05\xe9\x6b\x33\x00\x00\x57\x8b\xf9\x83\xfa\x04\x72\x31\xf7\xd9\x83\xe1\x03\x74\x0c\x2b\xd1\x88\x07\x83\xc7\x01\x83\xe9\x01\x75\xf6\x8b\xc8\xc1\xe0\x08\x03\xc1\x8b\xc8\xc1\xe0\x10\x03\xc1\x8b\xca\x83\xe2\x03\xc1\xe9\x02\x74\x06\xf3\xab\x85\xd2\x74\x0a\x88\x07\x83\xc7\x01\x83\xea\x01\x75\xf6\x8b\x44\x24\x08\x5f\xc3\x8b\x44\x24\x04\xc3\xcc\xcc\x53\x56\x57\x8b\x54\x24\x10\x8b\x44\x24\x14\x8b\x4c\x24\x18\x55\x52\x50\x51\x51\x68\x5c\x56\x00\x10\x64\xff\x35\x00\x00\x00\x00\xa1\x00\xe0\x00\x10\x33\xc4\x89\x44\x24\x08\x64\x89\x25\x00\x00\x00\x00\x8b\x44\x24\x30\x8b\x58\x08\x8b\x4c\x24\x2c\x33\x19\x8b\x70\x0c\x83\xfe\xfe\x74\x3b\x8b\x54\x24\x34\x83\xfa\xfe\x74\x04\x3b\xf2\x76\x2e\x8d\x34\x76\x8d\x5c\xb3\x10\x8b\x0b\x89\x48\x0c\x83\x7b\x04\x00\x75\xcc\x68\x01\x01\x00\x00\x8b\x43\x08\xe8\x0e\x35\x00\x00\xb9\x01\x00\x00\x00\x8b\x43\x08\xe8\x20\x35\x00\x00\xeb\xb0\x64\x8f\x05\x00\x00\x00\x00\x83\xc4\x18\x5f\x5e\x5b\xc3\x8b\x4c\x24\x04\xf7\x41\x04\x06\x00\x00\x00\xb8\x01\x00\x00\x00\x74\x33\x8b\x44\x24\x08\x8b\x48\x08\x33\xc8\xe8\x02\xbf\xff\xff\x55\x8b\x68\x18\xff\x70\x0c\xff\x70\x10\xff\x70\x14\xe8\x3e\xff\xff\xff\x83\xc4\x0c\x5d\x8b\x44\x24\x08\x8b\x54\x24\x10\x89\x02\xb8\x03\x00\x00\x00\xc3\x55\x8b\x4c\x24\x08\x8b\x29\xff\x71\x1c\xff\x71\x18\xff\x71\x28\xe8\x15\xff\xff\xff\x83\xc4\x0c\x5d\xc2\x04\x00\x55\x56\x57\x53\x8b\xea\x33\xc0\x33\xdb\x33\xd2\x33\xf6\x33\xff\xff\xd1\x5b\x5f\x5e\x5d\xc3\x8b\xea\x8b\xf1\x8b\xc1\x6a\x01\xe8\x6b\x34\x00\x00\x33\xc0\x33\xdb\x33\xc9\x33\xd2\x33\xff\xff\xe6\x55\x8b\xec\x53\x56\x57\x6a\x00\x6a\x00\x68\x03\x57\x00\x10\x51\xe8\x5b\x49\x00\x00\x5f\x5e\x5b\x5d\xc3\x55\x8b\x6c\x24\x08\x52\x51\xff\x74\x24\x14\xe8\xb4\xfe\xff\xff\x83\xc4\x0c\x5d\xc2\x08\x00\xcc\x8b\xff\x55\x8b\xec\x8b\x4d\x08\xb8\x4d\x5a\x00\x00\x66\x39\x01\x74\x04\x33\xc0\x5d\xc3\x8b\x41\x3c\x03\xc1\x81\x38\x50\x45\x00\x00\x75\xef\x33\xd2\xb9\x0b\x01\x00\x00\x66\x39\x48\x18\x0f\x94\xc2\x8b\xc2\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\x48\x3c\x03\xc8\x0f\xb7\x41\x14\x53\x56\x0f\xb7\x71\x06\x33\xd2\x57\x8d\x44\x08\x18\x85\xf6\x76\x1b\x8b\x7d\x0c\x8b\x48\x0c\x3b\xf9\x72\x09\x8b\x58\x08\x03\xd9\x3b\xfb\x72\x0a\x42\x83\xc0\x28\x3b\xd6\x72\xe8\x33\xc0\x5f\x5e\x5b\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x6a\xfe\x68\x18\xc7\x00\x10\x68\x10\x2c\x00\x10\x64\xa1\x00\x00\x00\x00\x50\x83\xec\x08\x53\x56\x57\xa1\x00\xe0\x00\x10\x31\x45\xf8\x33\xc5\x50\x8d\x45\xf0\x64\xa3\x00\x00\x00\x00\x89\x65\xe8\xc7\x45\xfc\x00\x00\x00\x00\x68\x00\x00\x00\x10\xe8\x2a\xff\xff\xff\x83\xc4\x04\x85\xc0\x74\x55\x8b\x45\x08\x2d\x00\x00\x00\x10\x50\x68\x00\x00\x00\x10\xe8\x50\xff\xff\xff\x83\xc4\x08\x85\xc0\x74\x3b\x8b\x40\x24\xc1\xe8\x1f\xf7\xd0\x83\xe0\x01\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\x45\xec\x8b\x08\x8b\x01\x33\xd2\x3d\x05\x00\x00\xc0\x0f\x94\xc2\x8b\xc2\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x33\xc0\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x0d\x10\xfd\x00\x10\xa1\x14\xfd\x00\x10\x6b\xc9\x14\x03\xc8\xeb\x11\x8b\x55\x08\x2b\x50\x0c\x81\xfa\x00\x00\x10\x00\x72\x09\x83\xc0\x14\x3b\xc1\x72\xeb\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x8b\x4d\x08\x8b\x41\x10\x56\x8b\x75\x0c\x57\x8b\xfe\x2b\x79\x0c\x83\xc6\xfc\xc1\xef\x0f\x8b\xcf\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf0\x8b\x0e\x49\x89\x4d\xfc\xf6\xc1\x01\x0f\x85\xd3\x02\x00\x00\x53\x8d\x1c\x31\x8b\x13\x89\x55\xf4\x8b\x56\xfc\x89\x55\xf8\x8b\x55\xf4\x89\x5d\x0c\xf6\xc2\x01\x75\x74\xc1\xfa\x04\x4a\x83\xfa\x3f\x76\x03\x6a\x3f\x5a\x8b\x4b\x04\x3b\x4b\x08\x75\x42\xbb\x00\x00\x00\x80\x83\xfa\x20\x73\x19\x8b\xca\xd3\xeb\x8d\x4c\x02\x04\xf7\xd3\x21\x5c\xb8\x44\xfe\x09\x75\x23\x8b\x4d\x08\x21\x19\xeb\x1c\x8d\x4a\xe0\xd3\xeb\x8d\x4c\x02\x04\xf7\xd3\x21\x9c\xb8\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x5d\x0c\x8b\x53\x08\x8b\x5b\x04\x8b\x4d\xfc\x03\x4d\xf4\x89\x5a\x04\x8b\x55\x0c\x8b\x5a\x04\x8b\x52\x08\x89\x53\x08\x89\x4d\xfc\x8b\xd1\xc1\xfa\x04\x4a\x83\xfa\x3f\x76\x03\x6a\x3f\x5a\x8b\x5d\xf8\x83\xe3\x01\x89\x5d\xf4\x0f\x85\x8f\x00\x00\x00\x2b\x75\xf8\x8b\x5d\xf8\xc1\xfb\x04\x6a\x3f\x89\x75\x0c\x4b\x5e\x3b\xde\x76\x02\x8b\xde\x03\x4d\xf8\x8b\xd1\xc1\xfa\x04\x4a\x89\x4d\xfc\x3b\xd6\x76\x02\x8b\xd6\x3b\xda\x74\x5e\x8b\x4d\x0c\x8b\x71\x04\x3b\x71\x08\x75\x3b\xbe\x00\x00\x00\x80\x83\xfb\x20\x73\x17\x8b\xcb\xd3\xee\xf7\xd6\x21\x74\xb8\x44\xfe\x4c\x03\x04\x75\x21\x8b\x4d\x08\x21\x31\xeb\x1a\x8d\x4b\xe0\xd3\xee\xf7\xd6\x21\xb4\xb8\xc4\x00\x00\x00\xfe\x4c\x03\x04\x75\x06\x8b\x4d\x08\x21\x71\x04\x8b\x4d\x0c\x8b\x71\x08\x8b\x49\x04\x89\x4e\x04\x8b\x4d\x0c\x8b\x71\x04\x8b\x49\x08\x89\x4e\x08\x8b\x75\x0c\xeb\x03\x8b\x5d\x08\x83\x7d\xf4\x00\x75\x08\x3b\xda\x0f\x84\x80\x00\x00\x00\x8b\x4d\xf0\x8d\x0c\xd1\x8b\x59\x04\x89\x4e\x08\x89\x5e\x04\x89\x71\x04\x8b\x4e\x04\x89\x71\x08\x8b\x4e\x04\x3b\x4e\x08\x75\x60\x8a\x4c\x02\x04\x88\x4d\x0f\xfe\xc1\x88\x4c\x02\x04\x83\xfa\x20\x73\x25\x80\x7d\x0f\x00\x75\x0e\x8b\xca\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x19\xbb\x00\x00\x00\x80\x8b\xca\xd3\xeb\x8d\x44\xb8\x44\x09\x18\xeb\x29\x80\x7d\x0f\x00\x75\x10\x8d\x4a\xe0\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x59\x04\x8d\x4a\xe0\xba\x00\x00\x00\x80\xd3\xea\x8d\x84\xb8\xc4\x00\x00\x00\x09\x10\x8b\x45\xfc\x89\x06\x89\x44\x30\xfc\x8b\x45\xf0\xff\x08\x0f\x85\xf3\x00\x00\x00\xa1\x18\xf5\x00\x10\x85\xc0\x0f\x84\xd8\x00\x00\x00\x8b\x0d\x24\xfd\x00\x10\x8b\x35\xcc\xb0\x00\x10\x68\x00\x40\x00\x00\xc1\xe1\x0f\x03\x48\x0c\xbb\x00\x80\x00\x00\x53\x51\xff\xd6\x8b\x0d\x24\xfd\x00\x10\xa1\x18\xf5\x00\x10\xba\x00\x00\x00\x80\xd3\xea\x09\x50\x08\xa1\x18\xf5\x00\x10\x8b\x40\x10\x8b\x0d\x24\xfd\x00\x10\x83\xa4\x88\xc4\x00\x00\x00\x00\xa1\x18\xf5\x00\x10\x8b\x40\x10\xfe\x48\x43\xa1\x18\xf5\x00\x10\x8b\x48\x10\x80\x79\x43\x00\x75\x09\x83\x60\x04\xfe\xa1\x18\xf5\x00\x10\x83\x78\x08\xff\x75\x65\x53\x6a\x00\xff\x70\x0c\xff\xd6\xa1\x18\xf5\x00\x10\xff\x70\x10\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\x8b\x0d\x10\xfd\x00\x10\xa1\x18\xf5\x00\x10\x6b\xc9\x14\x8b\x15\x14\xfd\x00\x10\x2b\xc8\x8d\x4c\x11\xec\x51\x8d\x48\x14\x51\x50\xe8\x52\x32\x00\x00\x8b\x45\x08\x83\xc4\x0c\xff\x0d\x10\xfd\x00\x10\x3b\x05\x18\xf5\x00\x10\x76\x04\x83\x6d\x08\x14\xa1\x14\xfd\x00\x10\xa3\x1c\xfd\x00\x10\x8b\x45\x08\xa3\x18\xf5\x00\x10\x89\x3d\x24\xfd\x00\x10\x5b\x5f\x5e\xc9\xc3\xa1\x20\xfd\x00\x10\x56\x8b\x35\x10\xfd\x00\x10\x57\x33\xff\x3b\xf0\x75\x34\x83\xc0\x10\x6b\xc0\x14\x50\xff\x35\x14\xfd\x00\x10\x57\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x3b\xc7\x75\x04\x33\xc0\xeb\x78\x83\x05\x20\xfd\x00\x10\x10\x8b\x35\x10\xfd\x00\x10\xa3\x14\xfd\x00\x10\x6b\xf6\x14\x03\x35\x14\xfd\x00\x10\x68\xc4\x41\x00\x00\x6a\x08\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x89\x46\x10\x3b\xc7\x74\xc7\x6a\x04\x68\x00\x20\x00\x00\x68\x00\x00\x10\x00\x57\xff\x15\xf8\xb0\x00\x10\x89\x46\x0c\x3b\xc7\x75\x12\xff\x76\x10\x57\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\xeb\x9b\x83\x4e\x08\xff\x89\x3e\x89\x7e\x04\xff\x05\x10\xfd\x00\x10\x8b\x46\x10\x83\x08\xff\x8b\xc6\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x51\x51\x8b\x4d\x08\x8b\x41\x08\x53\x56\x8b\x71\x10\x57\x33\xdb\xeb\x03\x03\xc0\x43\x85\xc0\x7d\xf9\x8b\xc3\x69\xc0\x04\x02\x00\x00\x8d\x84\x30\x44\x01\x00\x00\x6a\x3f\x89\x45\xf8\x5a\x89\x40\x08\x89\x40\x04\x83\xc0\x08\x4a\x75\xf4\x6a\x04\x8b\xfb\x68\x00\x10\x00\x00\xc1\xe7\x0f\x03\x79\x0c\x68\x00\x80\x00\x00\x57\xff\x15\xf8\xb0\x00\x10\x85\xc0\x75\x08\x83\xc8\xff\xe9\x9d\x00\x00\x00\x8d\x97\x00\x70\x00\x00\x89\x55\xfc\x3b\xfa\x77\x43\x8b\xca\x2b\xcf\xc1\xe9\x0c\x8d\x47\x10\x41\x83\x48\xf8\xff\x83\x88\xec\x0f\x00\x00\xff\x8d\x90\xfc\x0f\x00\x00\x89\x10\x8d\x90\xfc\xef\xff\xff\xc7\x40\xfc\xf0\x0f\x00\x00\x89\x50\x04\xc7\x80\xe8\x0f\x00\x00\xf0\x0f\x00\x00\x05\x00\x10\x00\x00\x49\x75\xcb\x8b\x55\xfc\x8b\x45\xf8\x05\xf8\x01\x00\x00\x8d\x4f\x0c\x89\x48\x04\x89\x41\x08\x8d\x4a\x0c\x89\x48\x08\x89\x41\x04\x83\x64\x9e\x44\x00\x33\xff\x47\x89\xbc\x9e\xc4\x00\x00\x00\x8a\x46\x43\x8a\xc8\xfe\xc1\x84\xc0\x8b\x45\x08\x88\x4e\x43\x75\x03\x09\x78\x04\xba\x00\x00\x00\x80\x8b\xcb\xd3\xea\xf7\xd2\x21\x50\x08\x8b\xc3\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\x8b\x4d\x08\x8b\x41\x10\x53\x56\x8b\x75\x10\x57\x8b\x7d\x0c\x8b\xd7\x2b\x51\x0c\x83\xc6\x17\xc1\xea\x0f\x8b\xca\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf4\x8b\x4f\xfc\x83\xe6\xf0\x49\x3b\xf1\x8d\x7c\x39\xfc\x8b\x1f\x89\x4d\x10\x89\x5d\xfc\x0f\x8e\x55\x01\x00\x00\xf6\xc3\x01\x0f\x85\x45\x01\x00\x00\x03\xd9\x3b\xf3\x0f\x8f\x3b\x01\x00\x00\x8b\x4d\xfc\xc1\xf9\x04\x49\x89\x4d\xf8\x83\xf9\x3f\x76\x06\x6a\x3f\x59\x89\x4d\xf8\x8b\x5f\x04\x3b\x5f\x08\x75\x43\xbb\x00\x00\x00\x80\x83\xf9\x20\x73\x1a\xd3\xeb\x8b\x4d\xf8\x8d\x4c\x01\x04\xf7\xd3\x21\x5c\x90\x44\xfe\x09\x75\x26\x8b\x4d\x08\x21\x19\xeb\x1f\x83\xc1\xe0\xd3\xeb\x8b\x4d\xf8\x8d\x4c\x01\x04\xf7\xd3\x21\x9c\x90\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x4f\x08\x8b\x5f\x04\x89\x59\x04\x8b\x4f\x04\x8b\x7f\x08\x89\x79\x08\x8b\x4d\x10\x2b\xce\x01\x4d\xfc\x83\x7d\xfc\x00\x0f\x8e\xa5\x00\x00\x00\x8b\x7d\xfc\x8b\x4d\x0c\xc1\xff\x04\x4f\x8d\x4c\x31\xfc\x83\xff\x3f\x76\x03\x6a\x3f\x5f\x8b\x5d\xf4\x8d\x1c\xfb\x89\x5d\x10\x8b\x5b\x04\x89\x59\x04\x8b\x5d\x10\x89\x59\x08\x89\x4b\x04\x8b\x59\x04\x89\x4b\x08\x8b\x59\x04\x3b\x59\x08\x75\x57\x8a\x4c\x07\x04\x88\x4d\x13\xfe\xc1\x88\x4c\x07\x04\x83\xff\x20\x73\x1c\x80\x7d\x13\x00\x75\x0e\x8b\xcf\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x19\x8d\x44\x90\x44\x8b\xcf\xeb\x20\x80\x7d\x13\x00\x75\x10\x8d\x4f\xe0\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x59\x04\x8d\x84\x90\xc4\x00\x00\x00\x8d\x4f\xe0\xba\x00\x00\x00\x80\xd3\xea\x09\x10\x8b\x55\x0c\x8b\x4d\xfc\x8d\x44\x32\xfc\x89\x08\x89\x4c\x01\xfc\xeb\x03\x8b\x55\x0c\x8d\x46\x01\x89\x42\xfc\x89\x44\x32\xf8\xe9\x3c\x01\x00\x00\x33\xc0\xe9\x38\x01\x00\x00\x0f\x8d\x2f\x01\x00\x00\x8b\x5d\x0c\x29\x75\x10\x8d\x4e\x01\x89\x4b\xfc\x8d\x5c\x33\xfc\x8b\x75\x10\xc1\xfe\x04\x4e\x89\x5d\x0c\x89\x4b\xfc\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\xf6\x45\xfc\x01\x0f\x85\x80\x00\x00\x00\x8b\x75\xfc\xc1\xfe\x04\x4e\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\x8b\x4f\x04\x3b\x4f\x08\x75\x42\xbb\x00\x00\x00\x80\x83\xfe\x20\x73\x19\x8b\xce\xd3\xeb\x8d\x74\x06\x04\xf7\xd3\x21\x5c\x90\x44\xfe\x0e\x75\x23\x8b\x4d\x08\x21\x19\xeb\x1c\x8d\x4e\xe0\xd3\xeb\x8d\x4c\x06\x04\xf7\xd3\x21\x9c\x90\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x5d\x0c\x8b\x4f\x08\x8b\x77\x04\x89\x71\x04\x8b\x77\x08\x8b\x4f\x04\x89\x71\x08\x8b\x75\x10\x03\x75\xfc\x89\x75\x10\xc1\xfe\x04\x4e\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\x8b\x4d\xf4\x8d\x0c\xf1\x8b\x79\x04\x89\x4b\x08\x89\x7b\x04\x89\x59\x04\x8b\x4b\x04\x89\x59\x08\x8b\x4b\x04\x3b\x4b\x08\x75\x57\x8a\x4c\x06\x04\x88\x4d\x0f\xfe\xc1\x88\x4c\x06\x04\x83\xfe\x20\x73\x1c\x80\x7d\x0f\x00\x75\x0e\x8b\xce\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\x08\x09\x39\x8d\x44\x90\x44\x8b\xce\xeb\x20\x80\x7d\x0f\x00\x75\x10\x8d\x4e\xe0\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\x08\x09\x79\x04\x8d\x84\x90\xc4\x00\x00\x00\x8d\x4e\xe0\xba\x00\x00\x00\x80\xd3\xea\x09\x10\x8b\x45\x10\x89\x03\x89\x44\x18\xfc\x33\xc0\x40\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\xa1\x10\xfd\x00\x10\x8b\x4d\x08\x6b\xc0\x14\x03\x05\x14\xfd\x00\x10\x83\xc1\x17\x83\xe1\xf0\x89\x4d\xf0\xc1\xf9\x04\x53\x49\x83\xf9\x20\x56\x57\x7d\x0b\x83\xce\xff\xd3\xee\x83\x4d\xf8\xff\xeb\x0d\x83\xc1\xe0\x83\xca\xff\x33\xf6\xd3\xea\x89\x55\xf8\x8b\x0d\x1c\xfd\x00\x10\x8b\xd9\xeb\x11\x8b\x53\x04\x8b\x3b\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd8\x72\xe8\x3b\xd8\x75\x7f\x8b\x1d\x14\xfd\x00\x10\xeb\x11\x8b\x53\x04\x8b\x3b\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd9\x72\xe8\x3b\xd9\x75\x5b\xeb\x0c\x83\x7b\x08\x00\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd8\x72\xf0\x3b\xd8\x75\x31\x8b\x1d\x14\xfd\x00\x10\xeb\x09\x83\x7b\x08\x00\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd9\x72\xf0\x3b\xd9\x75\x15\xe8\xa0\xfa\xff\xff\x8b\xd8\x89\x5d\x08\x85\xdb\x75\x07\x33\xc0\xe9\x09\x02\x00\x00\x53\xe8\x3a\xfb\xff\xff\x59\x8b\x4b\x10\x89\x01\x8b\x43\x10\x83\x38\xff\x74\xe5\x89\x1d\x1c\xfd\x00\x10\x8b\x43\x10\x8b\x10\x89\x55\xfc\x83\xfa\xff\x74\x14\x8b\x8c\x90\xc4\x00\x00\x00\x8b\x7c\x90\x44\x23\x4d\xf8\x23\xfe\x0b\xcf\x75\x29\x83\x65\xfc\x00\x8b\x90\xc4\x00\x00\x00\x8d\x48\x44\x8b\x39\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0e\xff\x45\xfc\x8b\x91\x84\x00\x00\x00\x83\xc1\x04\xeb\xe7\x8b\x55\xfc\x8b\xca\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf4\x8b\x4c\x90\x44\x33\xff\x23\xce\x75\x12\x8b\x8c\x90\xc4\x00\x00\x00\x23\x4d\xf8\x6a\x20\x5f\xeb\x03\x03\xc9\x47\x85\xc9\x7d\xf9\x8b\x4d\xf4\x8b\x54\xf9\x04\x8b\x0a\x2b\x4d\xf0\x8b\xf1\xc1\xfe\x04\x4e\x83\xfe\x3f\x89\x4d\xf8\x7e\x03\x6a\x3f\x5e\x3b\xf7\x0f\x84\x01\x01\x00\x00\x8b\x4a\x04\x3b\x4a\x08\x75\x5c\x83\xff\x20\xbb\x00\x00\x00\x80\x7d\x26\x8b\xcf\xd3\xeb\x8b\x4d\xfc\x8d\x7c\x38\x04\xf7\xd3\x89\x5d\xec\x23\x5c\x88\x44\x89\x5c\x88\x44\xfe\x0f\x75\x33\x8b\x4d\xec\x8b\x5d\x08\x21\x0b\xeb\x2c\x8d\x4f\xe0\xd3\xeb\x8b\x4d\xfc\x8d\x8c\x88\xc4\x00\x00\x00\x8d\x7c\x38\x04\xf7\xd3\x21\x19\xfe\x0f\x89\x5d\xec\x75\x0b\x8b\x5d\x08\x8b\x4d\xec\x21\x4b\x04\xeb\x03\x8b\x5d\x08\x83\x7d\xf8\x00\x8b\x4a\x08\x8b\x7a\x04\x89\x79\x04\x8b\x4a\x04\x8b\x7a\x08\x89\x79\x08\x0f\x84\x8d\x00\x00\x00\x8b\x4d\xf4\x8d\x0c\xf1\x8b\x79\x04\x89\x4a\x08\x89\x7a\x04\x89\x51\x04\x8b\x4a\x04\x89\x51\x08\x8b\x4a\x04\x3b\x4a\x08\x75\x5e\x8a\x4c\x06\x04\x88\x4d\x0b\xfe\xc1\x83\xfe\x20\x88\x4c\x06\x04\x7d\x23\x80\x7d\x0b\x00\x75\x0b\xbf\x00\x00\x00\x80\x8b\xce\xd3\xef\x09\x3b\x8b\xce\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\xfc\x09\x7c\x88\x44\xeb\x29\x80\x7d\x0b\x00\x75\x0d\x8d\x4e\xe0\xbf\x00\x00\x00\x80\xd3\xef\x09\x7b\x04\x8b\x4d\xfc\x8d\xbc\x88\xc4\x00\x00\x00\x8d\x4e\xe0\xbe\x00\x00\x00\x80\xd3\xee\x09\x37\x8b\x4d\xf8\x85\xc9\x74\x0b\x89\x0a\x89\x4c\x11\xfc\xeb\x03\x8b\x4d\xf8\x8b\x75\xf0\x03\xd1\x8d\x4e\x01\x89\x0a\x89\x4c\x32\xfc\x8b\x75\xf4\x8b\x0e\x8d\x79\x01\x89\x3e\x85\xc9\x75\x1a\x3b\x1d\x18\xf5\x00\x10\x75\x12\x8b\x4d\xfc\x3b\x0d\x24\xfd\x00\x10\x75\x07\x83\x25\x18\xf5\x00\x10\x00\x8b\x4d\xfc\x89\x08\x8d\x42\x04\x5f\x5e\x5b\xc9\xc3\x6a\x0c\x68\x38\xc7\x00\x10\xe8\x6f\xc8\xff\xff\x83\x65\xe4\x00\x8b\x75\x08\x3b\x35\x18\xfd\x00\x10\x77\x22\x6a\x04\xe8\x9e\xe2\xff\xff\x59\x83\x65\xfc\x00\x56\xe8\xee\xfc\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x7b\xc8\xff\xff\xc3\x6a\x04\xe8\x99\xe1\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x83\xfe\xe0\x0f\x87\xa1\x00\x00\x00\x53\x57\x8b\x3d\xf4\xb0\x00\x10\x83\x3d\x84\xf3\x00\x10\x00\x75\x18\xe8\x86\x05\x00\x00\x6a\x1e\xe8\xd4\x03\x00\x00\x68\xff\x00\x00\x00\xe8\xdf\xd1\xff\xff\x59\x59\xa1\x2c\xfd\x00\x10\x83\xf8\x01\x75\x0e\x85\xf6\x74\x04\x8b\xc6\xeb\x03\x33\xc0\x40\x50\xeb\x1c\x83\xf8\x03\x75\x0b\x56\xe8\x53\xff\xff\xff\x59\x85\xc0\x75\x16\x85\xf6\x75\x01\x46\x83\xc6\x0f\x83\xe6\xf0\x56\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x8b\xd8\x85\xdb\x75\x2e\x6a\x0c\x5e\x39\x05\x70\xf8\x00\x10\x74\x15\xff\x75\x08\xe8\x8b\x09\x00\x00\x59\x85\xc0\x74\x0f\x8b\x75\x08\xe9\x7b\xff\xff\xff\xe8\x3e\xc7\xff\xff\x89\x30\xe8\x37\xc7\xff\xff\x89\x30\x5f\x8b\xc3\x5b\xeb\x14\x56\xe8\x64\x09\x00\x00\x59\xe8\x23\xc7\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\x5e\x5d\xc3\x6a\x0c\x68\x58\xc7\x00\x10\xe8\x56\xc7\xff\xff\x8b\x4d\x08\x33\xff\x3b\xcf\x76\x2e\x6a\xe0\x58\x33\xd2\xf7\xf1\x3b\x45\x0c\x1b\xc0\x40\x75\x1f\xe8\xef\xc6\xff\xff\xc7\x00\x0c\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x77\xc6\xff\xff\x83\xc4\x14\x33\xc0\xe9\xd5\x00\x00\x00\x0f\xaf\x4d\x0c\x8b\xf1\x89\x75\x08\x3b\xf7\x75\x03\x33\xf6\x46\x33\xdb\x89\x5d\xe4\x83\xfe\xe0\x77\x69\x83\x3d\x2c\xfd\x00\x10\x03\x75\x4b\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x8b\x45\x08\x3b\x05\x18\xfd\x00\x10\x77\x37\x6a\x04\xe8\x26\xe1\xff\xff\x59\x89\x7d\xfc\xff\x75\x08\xe8\x75\xfb\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x5f\x00\x00\x00\x8b\x5d\xe4\x3b\xdf\x74\x11\xff\x75\x08\x57\x53\xe8\x58\xf0\xff\xff\x83\xc4\x0c\x3b\xdf\x75\x61\x56\x6a\x08\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x8b\xd8\x3b\xdf\x75\x4c\x39\x3d\x70\xf8\x00\x10\x74\x33\x56\xe8\x7b\x08\x00\x00\x59\x85\xc0\x0f\x85\x72\xff\xff\xff\x8b\x45\x10\x3b\xc7\x0f\x84\x50\xff\xff\xff\xc7\x00\x0c\x00\x00\x00\xe9\x45\xff\xff\xff\x33\xff\x8b\x75\x0c\x6a\x04\xe8\xca\xdf\xff\xff\x59\xc3\x3b\xdf\x75\x0d\x8b\x45\x10\x3b\xc7\x74\x06\xc7\x00\x0c\x00\x00\x00\x8b\xc3\xe8\x8a\xc6\xff\xff\xc3\x6a\x10\x68\x78\xc7\x00\x10\xe8\x38\xc6\xff\xff\x8b\x5d\x08\x85\xdb\x75\x0e\xff\x75\x0c\xe8\xfd\xfd\xff\xff\x59\xe9\xcc\x01\x00\x00\x8b\x75\x0c\x85\xf6\x75\x0c\x53\xe8\x11\xce\xff\xff\x59\xe9\xb7\x01\x00\x00\x83\x3d\x2c\xfd\x00\x10\x03\x0f\x85\x93\x01\x00\x00\x33\xff\x89\x7d\xe4\x83\xfe\xe0\x0f\x87\x8a\x01\x00\x00\x6a\x04\xe8\x33\xe0\xff\xff\x59\x89\x7d\xfc\x53\xe8\xa5\xf2\xff\xff\x59\x89\x45\xe0\x3b\xc7\x0f\x84\x9e\x00\x00\x00\x3b\x35\x18\xfd\x00\x10\x77\x49\x56\x53\x50\xe8\x87\xf7\xff\xff\x83\xc4\x0c\x85\xc0\x74\x05\x89\x5d\xe4\xeb\x35\x56\xe8\x56\xfa\xff\xff\x59\x89\x45\xe4\x3b\xc7\x74\x27\x8b\x43\xfc\x48\x3b\xc6\x72\x02\x8b\xc6\x50\x53\xff\x75\xe4\xe8\x8e\x08\x00\x00\x53\xe8\x55\xf2\xff\xff\x89\x45\xe0\x53\x50\xe8\x7b\xf2\xff\xff\x83\xc4\x18\x39\x7d\xe4\x75\x48\x3b\xf7\x75\x06\x33\xf6\x46\x89\x75\x0c\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x56\x57\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x89\x45\xe4\x3b\xc7\x74\x20\x8b\x43\xfc\x48\x3b\xc6\x72\x02\x8b\xc6\x50\x53\xff\x75\xe4\xe8\x3a\x08\x00\x00\x53\xff\x75\xe0\xe8\x2e\xf2\xff\xff\x83\xc4\x14\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x2e\x00\x00\x00\x83\x7d\xe0\x00\x75\x31\x85\xf6\x75\x01\x46\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x56\x53\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x8b\xf8\xeb\x12\x8b\x75\x0c\x8b\x5d\x08\x6a\x04\xe8\x64\xde\xff\xff\x59\xc3\x8b\x7d\xe4\x85\xff\x0f\x85\xbf\x00\x00\x00\x39\x3d\x70\xf8\x00\x10\x74\x2c\x56\xe8\xcf\x06\x00\x00\x59\x85\xc0\x0f\x85\xd2\xfe\xff\xff\xe8\x86\xc4\xff\xff\x39\x7d\xe0\x75\x6c\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\x31\xc4\xff\xff\x59\x89\x06\xeb\x5f\x85\xff\x0f\x85\x83\x00\x00\x00\xe8\x61\xc4\xff\xff\x39\x7d\xe0\x74\x68\xc7\x00\x0c\x00\x00\x00\xeb\x71\x85\xf6\x75\x01\x46\x56\x53\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x8b\xf8\x85\xff\x75\x56\x39\x05\x70\xf8\x00\x10\x74\x34\x56\xe8\x66\x06\x00\x00\x59\x85\xc0\x74\x1f\x83\xfe\xe0\x76\xcd\x56\xe8\x56\x06\x00\x00\x59\xe8\x15\xc4\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\xe8\x97\xc4\xff\xff\xc3\xe8\x02\xc4\xff\xff\xe9\x7c\xff\xff\xff\x85\xff\x75\x16\xe8\xf4\xc3\xff\xff\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\xa4\xc3\xff\xff\x89\x06\x59\x8b\xc7\xeb\xd2\x8b\xff\x55\x8b\xec\x51\x51\x53\x8b\x5d\x08\x56\x57\x33\xf6\x33\xff\x89\x7d\xfc\x3b\x1c\xfd\xd0\xeb\x00\x10\x74\x09\x47\x89\x7d\xfc\x83\xff\x17\x72\xee\x83\xff\x17\x0f\x83\x77\x01\x00\x00\x6a\x03\xe8\x88\x2b\x00\x00\x59\x83\xf8\x01\x0f\x84\x34\x01\x00\x00\x6a\x03\xe8\x77\x2b\x00\x00\x59\x85\xc0\x75\x0d\x83\x3d\xf4\xee\x00\x10\x01\x0f\x84\x1b\x01\x00\x00\x81\xfb\xfc\x00\x00\x00\x0f\x84\x41\x01\x00\x00\x68\xd8\xb9\x00\x10\xbb\x14\x03\x00\x00\x53\xbf\x20\xf5\x00\x10\x57\xe8\xc7\x05\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\xc3\xc1\xff\xff\x83\xc4\x14\x68\x04\x01\x00\x00\xbe\x39\xf5\x00\x10\x56\x6a\x00\xc6\x05\x3d\xf6\x00\x10\x00\xff\x15\xac\xb0\x00\x10\x85\xc0\x75\x26\x68\xc0\xb9\x00\x10\x68\xfb\x02\x00\x00\x56\xe8\x85\x05\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0f\x33\xc0\x50\x50\x50\x50\x50\xe8\x7f\xc1\xff\xff\x83\xc4\x14\x56\xe8\xf4\xe9\xff\xff\x40\x59\x83\xf8\x3c\x76\x38\x56\xe8\xe7\xe9\xff\xff\x83\xee\x3b\x03\xc6\x6a\x03\xb9\x34\xf8\x00\x10\x68\xbc\xb9\x00\x10\x2b\xc8\x51\x50\xe8\x93\x1c\x00\x00\x83\xc4\x14\x85\xc0\x74\x11\x33\xf6\x56\x56\x56\x56\x56\xe8\x3c\xc1\xff\xff\x83\xc4\x14\xeb\x02\x33\xf6\x68\xb8\xb9\x00\x10\x53\x57\xe8\xad\x1b\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\x18\xc1\xff\xff\x83\xc4\x14\x8b\x45\xfc\xff\x34\xc5\xd4\xeb\x00\x10\x53\x57\xe8\x88\x1b\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\xf3\xc0\xff\xff\x83\xc4\x14\x68\x10\x20\x01\x00\x68\x90\xb9\x00\x10\x57\xe8\xe6\x28\x00\x00\x83\xc4\x0c\xeb\x32\x6a\xf4\xff\x15\x9c\xb0\x00\x10\x8b\xd8\x3b\xde\x74\x24\x83\xfb\xff\x74\x1f\x6a\x00\x8d\x45\xf8\x50\x8d\x34\xfd\xd4\xeb\x00\x10\xff\x36\xe8\x32\xe9\xff\xff\x59\x50\xff\x36\x53\xff\x15\x00\xb1\x00\x10\x5f\x5e\x5b\xc9\xc3\x6a\x03\xe8\x0c\x2a\x00\x00\x59\x83\xf8\x01\x74\x15\x6a\x03\xe8\xff\x29\x00\x00\x59\x85\xc0\x75\x1f\x83\x3d\xf4\xee\x00\x10\x01\x75\x16\x68\xfc\x00\x00\x00\xe8\x29\xfe\xff\xff\x68\xff\x00\x00\x00\xe8\x1f\xfe\xff\xff\x59\x59\xc3\x8b\xff\x55\x8b\xec\x51\x53\x56\x57\xff\x35\x48\xfe\x00\x10\xe8\x9c\xc4\xff\xff\xff\x35\x44\xfe\x00\x10\x8b\xf8\x89\x7d\xfc\xe8\x8c\xc4\xff\xff\x8b\xf0\x59\x59\x3b\xf7\x0f\x82\x83\x00\x00\x00\x8b\xde\x2b\xdf\x8d\x43\x04\x83\xf8\x04\x72\x77\x57\xe8\x8c\x27\x00\x00\x8b\xf8\x8d\x43\x04\x59\x3b\xf8\x73\x48\xb8\x00\x08\x00\x00\x3b\xf8\x73\x02\x8b\xc7\x03\xc7\x3b\xc7\x72\x0f\x50\xff\x75\xfc\xe8\xf9\xca\xff\xff\x59\x59\x85\xc0\x75\x16\x8d\x47\x10\x3b\xc7\x72\x40\x50\xff\x75\xfc\xe8\xe3\xca\xff\xff\x59\x59\x85\xc0\x74\x31\xc1\xfb\x02\x50\x8d\x34\x98\xe8\xa7\xc3\xff\xff\x59\xa3\x48\xfe\x00\x10\xff\x75\x08\xe8\x99\xc3\xff\xff\x89\x06\x83\xc6\x04\x56\xe8\x8e\xc3\xff\xff\x59\xa3\x44\xfe\x00\x10\x8b\x45\x08\x59\xeb\x02\x33\xc0\x5f\x5e\x5b\xc9\xc3\x8b\xff\x56\x6a\x04\x6a\x20\xe8\x4d\xca\xff\xff\x8b\xf0\x56\xe8\x67\xc3\xff\xff\x83\xc4\x0c\xa3\x48\xfe\x00\x10\xa3\x44\xfe\x00\x10\x85\xf6\x75\x05\x6a\x18\x58\x5e\xc3\x83\x26\x00\x33\xc0\x5e\xc3\x6a\x0c\x68\x98\xc7\x00\x10\xe8\x4e\xc1\xff\xff\xe8\x4d\xcb\xff\xff\x83\x65\xfc\x00\xff\x75\x08\xe8\xf8\xfe\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x6a\xc1\xff\xff\xc3\xe8\x2c\xcb\xff\xff\xc3\x8b\xff\x55\x8b\xec\xff\x75\x08\xe8\xb7\xff\xff\xff\xf7\xd8\x1b\xc0\xf7\xd8\x59\x48\x5d\xc3\x6a\x08\x68\xb8\xc7\x00\x10\xe8\xfb\xc0\xff\xff\xe8\xad\xc5\xff\xff\x8b\x40\x78\x85\xc0\x74\x16\x83\x65\xfc\x00\xff\xd0\xeb\x07\x33\xc0\x40\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\xe8\xb4\x28\x00\x00\xe8\x14\xc1\xff\xff\xc3\x68\xa5\x6a\x00\x10\xe8\xb4\xc2\xff\xff\x59\xa3\x34\xf8\x00\x10\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x38\xf8\x00\x10\xa3\x3c\xf8\x00\x10\xa3\x40\xf8\x00\x10\xa3\x44\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\x0d\x60\xe4\x00\x10\x56\x39\x50\x04\x74\x0f\x8b\xf1\x6b\xf6\x0c\x03\x75\x08\x83\xc0\x0c\x3b\xc6\x72\xec\x6b\xc9\x0c\x03\x4d\x08\x5e\x3b\xc1\x73\x05\x39\x50\x04\x74\x02\x33\xc0\x5d\xc3\xff\x35\x40\xf8\x00\x10\xe8\xc8\xc2\xff\xff\x59\xc3\x6a\x20\x68\xd8\xc7\x00\x10\xe8\x4f\xc0\xff\xff\x33\xff\x89\x7d\xe4\x89\x7d\xd8\x8b\x5d\x08\x83\xfb\x0b\x7f\x4c\x74\x15\x8b\xc3\x6a\x02\x59\x2b\xc1\x74\x22\x2b\xc1\x74\x08\x2b\xc1\x74\x64\x2b\xc1\x75\x44\xe8\x61\xc4\xff\xff\x8b\xf8\x89\x7d\xd8\x85\xff\x75\x14\x83\xc8\xff\xe9\x61\x01\x00\x00\xbe\x38\xf8\x00\x10\xa1\x38\xf8\x00\x10\xeb\x60\xff\x77\x5c\x8b\xd3\xe8\x5d\xff\xff\xff\x8b\xf0\x83\xc6\x08\x8b\x06\xeb\x5a\x8b\xc3\x83\xe8\x0f\x74\x3c\x83\xe8\x06\x74\x2b\x48\x74\x1c\xe8\x95\xbf\xff\xff\xc7\x00\x16\x00\x00\x00\x33\xc0\x50\x50\x50\x50\x50\xe8\x1b\xbf\xff\xff\x83\xc4\x14\xeb\xae\xbe\x40\xf8\x00\x10\xa1\x40\xf8\x00\x10\xeb\x16\xbe\x3c\xf8\x00\x10\xa1\x3c\xf8\x00\x10\xeb\x0a\xbe\x44\xf8\x00\x10\xa1\x44\xf8\x00\x10\xc7\x45\xe4\x01\x00\x00\x00\x50\xe8\x04\xc2\xff\xff\x89\x45\xe0\x59\x33\xc0\x83\x7d\xe0\x01\x0f\x84\xd8\x00\x00\x00\x39\x45\xe0\x75\x07\x6a\x03\xe8\x85\xcb\xff\xff\x39\x45\xe4\x74\x07\x50\xe8\xb7\xd9\xff\xff\x59\x33\xc0\x89\x45\xfc\x83\xfb\x08\x74\x0a\x83\xfb\x0b\x74\x05\x83\xfb\x04\x75\x1b\x8b\x4f\x60\x89\x4d\xd4\x89\x47\x60\x83\xfb\x08\x75\x40\x8b\x4f\x64\x89\x4d\xd0\xc7\x47\x64\x8c\x00\x00\x00\x83\xfb\x08\x75\x2e\x8b\x0d\x54\xe4\x00\x10\x89\x4d\xdc\x8b\x0d\x58\xe4\x00\x10\x8b\x15\x54\xe4\x00\x10\x03\xca\x39\x4d\xdc\x7d\x19\x8b\x4d\xdc\x6b\xc9\x0c\x8b\x57\x5c\x89\x44\x11\x08\xff\x45\xdc\xeb\xdb\xe8\x6c\xc1\xff\xff\x89\x06\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x15\x00\x00\x00\x83\xfb\x08\x75\x1f\xff\x77\x64\x53\xff\x55\xe0\x59\xeb\x19\x8b\x5d\x08\x8b\x7d\xd8\x83\x7d\xe4\x00\x74\x08\x6a\x00\xe8\x45\xd8\xff\xff\x59\xc3\x53\xff\x55\xe0\x59\x83\xfb\x08\x74\x0a\x83\xfb\x0b\x74\x05\x83\xfb\x04\x75\x11\x8b\x45\xd4\x89\x47\x60\x83\xfb\x08\x75\x06\x8b\x45\xd0\x89\x47\x64\x33\xc0\xe8\xf1\xbe\xff\xff\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x4c\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x58\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x5c\xf8\x00\x10\x5d\xc3\x6a\x10\x68\xf8\xc7\x00\x10\xe8\x72\xbe\xff\xff\x83\x65\xfc\x00\xff\x75\x0c\xff\x75\x08\xff\x15\x08\xb1\x00\x10\x89\x45\xe4\xeb\x2f\x8b\x45\xec\x8b\x00\x8b\x00\x89\x45\xe0\x33\xc9\x3d\x17\x00\x00\xc0\x0f\x94\xc1\x8b\xc1\xc3\x8b\x65\xe8\x81\x7d\xe0\x17\x00\x00\xc0\x75\x08\x6a\x08\xff\x15\x84\xb0\x00\x10\x83\x65\xe4\x00\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xe8\x64\xbe\xff\xff\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x60\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\xff\x35\x60\xf8\x00\x10\xe8\x6a\xc0\xff\xff\x59\x85\xc0\x74\x0f\xff\x75\x08\xff\xd0\x59\x85\xc0\x74\x05\x33\xc0\x40\x5d\xc3\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x53\x33\xdb\x56\x57\x3b\xcb\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\x80\xbd\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\x09\xbd\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x30\x8b\x75\x10\x3b\xf3\x75\x04\x88\x19\xeb\xda\x8b\xd1\x8a\x06\x88\x02\x42\x46\x3a\xc3\x74\x03\x4f\x75\xf3\x3b\xfb\x75\x10\x88\x19\xe8\x45\xbd\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\xc1\x33\xc0\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\xbe\xae\xff\xff\x0f\xb6\x45\x0c\x8b\x4d\xf4\x8a\x55\x14\x84\x54\x01\x1d\x75\x1e\x83\x7d\x10\x00\x74\x12\x8b\x4d\xf0\x8b\x89\xc8\x00\x00\x00\x0f\xb7\x04\x41\x23\x45\x10\xeb\x02\x33\xc0\x85\xc0\x74\x03\x33\xc0\x40\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x6a\x04\x6a\x00\xff\x75\x08\x6a\x00\xe8\x9a\xff\xff\xff\x83\xc4\x10\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x8b\x75\x0c\x8b\x4d\x10\x8b\x7d\x08\x8b\xc1\x8b\xd1\x03\xc6\x3b\xfe\x76\x08\x3b\xf8\x0f\x82\xa4\x01\x00\x00\x81\xf9\x00\x01\x00\x00\x72\x1f\x83\x3d\x0c\xfd\x00\x10\x00\x74\x16\x57\x56\x83\xe7\x0f\x83\xe6\x0f\x3b\xfe\x5e\x5f\x75\x08\x5e\x5f\x5d\xe9\x43\x26\x00\x00\xf7\xc7\x03\x00\x00\x00\x75\x15\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x2a\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x90\x8b\xc7\xba\x03\x00\x00\x00\x83\xe9\x04\x72\x0c\x83\xe0\x03\x03\xc8\xff\x24\x85\x28\x6f\x00\x10\xff\x24\x8d\x24\x70\x00\x10\x90\xff\x24\x8d\xa8\x6f\x00\x10\x90\x38\x6f\x00\x10\x64\x6f\x00\x10\x88\x6f\x00\x10\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xc6\x03\x83\xc7\x03\x83\xf9\x08\x72\xcc\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x8d\x49\x00\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xc6\x02\x83\xc7\x02\x83\xf9\x08\x72\xa6\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x90\x23\xd1\x8a\x06\x88\x07\x83\xc6\x01\xc1\xe9\x02\x83\xc7\x01\x83\xf9\x08\x72\x88\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x8d\x49\x00\x0b\x70\x00\x10\xf8\x6f\x00\x10\xf0\x6f\x00\x10\xe8\x6f\x00\x10\xe0\x6f\x00\x10\xd8\x6f\x00\x10\xd0\x6f\x00\x10\xc8\x6f\x00\x10\x8b\x44\x8e\xe4\x89\x44\x8f\xe4\x8b\x44\x8e\xe8\x89\x44\x8f\xe8\x8b\x44\x8e\xec\x89\x44\x8f\xec\x8b\x44\x8e\xf0\x89\x44\x8f\xf0\x8b\x44\x8e\xf4\x89\x44\x8f\xf4\x8b\x44\x8e\xf8\x89\x44\x8f\xf8\x8b\x44\x8e\xfc\x89\x44\x8f\xfc\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\x14\x70\x00\x10\x8b\xff\x24\x70\x00\x10\x2c\x70\x00\x10\x38\x70\x00\x10\x4c\x70\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8d\x74\x31\xfc\x8d\x7c\x39\xfc\xf7\xc7\x03\x00\x00\x00\x75\x24\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x0d\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8b\xff\xf7\xd9\xff\x24\x8d\x60\x71\x00\x10\x8d\x49\x00\x8b\xc7\xba\x03\x00\x00\x00\x83\xf9\x04\x72\x0c\x83\xe0\x03\x2b\xc8\xff\x24\x85\xb4\x70\x00\x10\xff\x24\x8d\xb0\x71\x00\x10\x90\xc4\x70\x00\x10\xe8\x70\x00\x10\x10\x71\x00\x10\x8a\x46\x03\x23\xd1\x88\x47\x03\x83\xee\x01\xc1\xe9\x02\x83\xef\x01\x83\xf9\x08\x72\xb2\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8d\x49\x00\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xee\x02\x83\xef\x02\x83\xf9\x08\x72\x88\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x90\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xee\x03\x83\xef\x03\x83\xf9\x08\x0f\x82\x56\xff\xff\xff\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8d\x49\x00\x64\x71\x00\x10\x6c\x71\x00\x10\x74\x71\x00\x10\x7c\x71\x00\x10\x84\x71\x00\x10\x8c\x71\x00\x10\x94\x71\x00\x10\xa7\x71\x00\x10\x8b\x44\x8e\x1c\x89\x44\x8f\x1c\x8b\x44\x8e\x18\x89\x44\x8f\x18\x8b\x44\x8e\x14\x89\x44\x8f\x14\x8b\x44\x8e\x10\x89\x44\x8f\x10\x8b\x44\x8e\x0c\x89\x44\x8f\x0c\x8b\x44\x8e\x08\x89\x44\x8f\x08\x8b\x44\x8e\x04\x89\x44\x8f\x04\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\xb0\x71\x00\x10\x8b\xff\xc0\x71\x00\x10\xc8\x71\x00\x10\xd8\x71\x00\x10\xec\x71\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x57\x33\xff\x83\xcb\xff\x3b\xf7\x75\x1c\xe8\x44\xb9\xff\xff\x57\x57\x57\x57\x57\xc7\x00\x16\x00\x00\x00\xe8\xcc\xb8\xff\xff\x83\xc4\x14\x0b\xc3\xeb\x42\xf6\x46\x0c\x83\x74\x37\x56\xe8\xa1\xd0\xff\xff\x56\x8b\xd8\xe8\x2d\x25\x00\x00\x56\xe8\x39\xd4\xff\xff\x50\xe8\x54\x24\x00\x00\x83\xc4\x10\x85\xc0\x7d\x05\x83\xcb\xff\xeb\x11\x8b\x46\x1c\x3b\xc7\x74\x0a\x50\xe8\x39\xc1\xff\xff\x59\x89\x7e\x1c\x89\x7e\x0c\x8b\xc3\x5f\x5e\x5b\x5d\xc3\x6a\x0c\x68\x18\xc8\x00\x10\xe8\x24\xb9\xff\xff\x83\x4d\xe4\xff\x33\xc0\x8b\x75\x08\x33\xff\x3b\xf7\x0f\x95\xc0\x3b\xc7\x75\x1d\xe8\xc1\xb8\xff\xff\xc7\x00\x16\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x49\xb8\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x0c\xf6\x46\x0c\x40\x74\x0c\x89\x7e\x0c\x8b\x45\xe4\xe8\x27\xb9\xff\xff\xc3\x56\xe8\x7f\xa8\xff\xff\x59\x89\x7d\xfc\x56\xe8\x2a\xff\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x05\x00\x00\x00\xeb\xd5\x8b\x75\x08\x56\xe8\xcd\xa8\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\xb8\xe4\x1a\x00\x00\xe8\x99\x26\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x8b\x45\x0c\x56\x33\xf6\x89\x85\x34\xe5\xff\xff\x89\xb5\x38\xe5\xff\xff\x89\xb5\x30\xe5\xff\xff\x39\x75\x10\x75\x07\x33\xc0\xe9\xe9\x06\x00\x00\x3b\xc6\x75\x27\xe8\x37\xb8\xff\xff\x89\x30\xe8\x1d\xb8\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\xa5\xb7\xff\xff\x83\xc4\x14\x83\xc8\xff\xe9\xbe\x06\x00\x00\x53\x57\x8b\x7d\x08\x8b\xc7\xc1\xf8\x05\x8d\x34\x85\x40\xfd\x00\x10\x8b\x06\x83\xe7\x1f\xc1\xe7\x06\x03\xc7\x8a\x58\x24\x02\xdb\xd0\xfb\x89\xb5\x28\xe5\xff\xff\x88\x9d\x27\xe5\xff\xff\x80\xfb\x02\x74\x05\x80\xfb\x01\x75\x30\x8b\x4d\x10\xf7\xd1\xf6\xc1\x01\x75\x26\xe8\xce\xb7\xff\xff\x33\xf6\x89\x30\xe8\xb2\xb7\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x3a\xb7\xff\xff\x83\xc4\x14\xe9\x43\x06\x00\x00\xf6\x40\x04\x20\x74\x11\x6a\x02\x6a\x00\x6a\x00\xff\x75\x08\xe8\xc4\x12\x00\x00\x83\xc4\x10\xff\x75\x08\xe8\x3d\xd2\xff\xff\x59\x85\xc0\x0f\x84\x9d\x02\x00\x00\x8b\x06\xf6\x44\x07\x04\x80\x0f\x84\x90\x02\x00\x00\xe8\x61\xbc\xff\xff\x8b\x40\x6c\x33\xc9\x39\x48\x14\x8d\x85\x1c\xe5\xff\xff\x0f\x94\xc1\x50\x8b\x06\xff\x34\x07\x89\x8d\x20\xe5\xff\xff\xff\x15\x10\xb1\x00\x10\x85\xc0\x0f\x84\x60\x02\x00\x00\x33\xc9\x39\x8d\x20\xe5\xff\xff\x74\x08\x84\xdb\x0f\x84\x50\x02\x00\x00\xff\x15\x0c\xb1\x00\x10\x8b\x9d\x34\xe5\xff\xff\x89\x85\x1c\xe5\xff\xff\x33\xc0\x89\x85\x3c\xe5\xff\xff\x39\x45\x10\x0f\x86\x42\x05\x00\x00\x89\x85\x44\xe5\xff\xff\x8a\x85\x27\xe5\xff\xff\x84\xc0\x0f\x85\x67\x01\x00\x00\x8a\x0b\x8b\xb5\x28\xe5\xff\xff\x33\xc0\x80\xf9\x0a\x0f\x94\xc0\x89\x85\x20\xe5\xff\xff\x8b\x06\x03\xc7\x83\x78\x38\x00\x74\x15\x8a\x50\x34\x88\x55\xf4\x88\x4d\xf5\x83\x60\x38\x00\x6a\x02\x8d\x45\xf4\x50\xeb\x4b\x0f\xbe\xc1\x50\xe8\xe8\xdf\xff\xff\x59\x85\xc0\x74\x3a\x8b\x8d\x34\xe5\xff\xff\x2b\xcb\x03\x4d\x10\x33\xc0\x40\x3b\xc8\x0f\x86\xa5\x01\x00\x00\x6a\x02\x8d\x85\x40\xe5\xff\xff\x53\x50\xe8\xa5\x24\x00\x00\x83\xc4\x0c\x83\xf8\xff\x0f\x84\xb1\x04\x00\x00\x43\xff\x85\x44\xe5\xff\xff\xeb\x1b\x6a\x01\x53\x8d\x85\x40\xe5\xff\xff\x50\xe8\x81\x24\x00\x00\x83\xc4\x0c\x83\xf8\xff\x0f\x84\x8d\x04\x00\x00\x33\xc0\x50\x50\x6a\x05\x8d\x4d\xf4\x51\x6a\x01\x8d\x8d\x40\xe5\xff\xff\x51\x50\xff\xb5\x1c\xe5\xff\xff\x43\xff\x85\x44\xe5\xff\xff\xff\x15\xbc\xb0\x00\x10\x8b\xf0\x85\xf6\x0f\x84\x5c\x04\x00\x00\x6a\x00\x8d\x85\x3c\xe5\xff\xff\x50\x56\x8d\x45\xf4\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x29\x04\x00\x00\x8b\x85\x44\xe5\xff\xff\x8b\x8d\x30\xe5\xff\xff\x03\xc1\x39\xb5\x3c\xe5\xff\xff\x89\x85\x38\xe5\xff\xff\x0f\x8c\x15\x04\x00\x00\x83\xbd\x20\xe5\xff\xff\x00\x0f\x84\xcd\x00\x00\x00\x6a\x00\x8d\x85\x3c\xe5\xff\xff\x50\x6a\x01\x8d\x45\xf4\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xc6\x45\xf4\x0d\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\xd0\x03\x00\x00\x83\xbd\x3c\xe5\xff\xff\x01\x0f\x8c\xcf\x03\x00\x00\xff\x85\x30\xe5\xff\xff\xff\x85\x38\xe5\xff\xff\xe9\x83\x00\x00\x00\x3c\x01\x74\x04\x3c\x02\x75\x21\x0f\xb7\x33\x33\xc9\x66\x83\xfe\x0a\x0f\x94\xc1\x43\x43\x83\x85\x44\xe5\xff\xff\x02\x89\xb5\x40\xe5\xff\xff\x89\x8d\x20\xe5\xff\xff\x3c\x01\x74\x04\x3c\x02\x75\x52\xff\xb5\x40\xe5\xff\xff\xe8\x8e\x21\x00\x00\x59\x66\x3b\x85\x40\xe5\xff\xff\x0f\x85\x68\x03\x00\x00\x83\x85\x38\xe5\xff\xff\x02\x83\xbd\x20\xe5\xff\xff\x00\x74\x29\x6a\x0d\x58\x50\x89\x85\x40\xe5\xff\xff\xe8\x61\x21\x00\x00\x59\x66\x3b\x85\x40\xe5\xff\xff\x0f\x85\x3b\x03\x00\x00\xff\x85\x38\xe5\xff\xff\xff\x85\x30\xe5\xff\xff\x8b\x45\x10\x39\x85\x44\xe5\xff\xff\x0f\x82\xf9\xfd\xff\xff\xe9\x27\x03\x00\x00\x8b\x0e\x8a\x13\xff\x85\x38\xe5\xff\xff\x88\x54\x0f\x34\x8b\x0e\x89\x44\x0f\x38\xe9\x0e\x03\x00\x00\x33\xc9\x8b\x06\x03\xc7\xf6\x40\x04\x80\x0f\x84\xbf\x02\x00\x00\x8b\x85\x34\xe5\xff\xff\x89\x8d\x40\xe5\xff\xff\x84\xdb\x0f\x85\xca\x00\x00\x00\x89\x85\x3c\xe5\xff\xff\x39\x4d\x10\x0f\x86\x20\x03\x00\x00\xeb\x06\x8b\xb5\x28\xe5\xff\xff\x8b\x8d\x3c\xe5\xff\xff\x83\xa5\x44\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x8d\x85\x48\xe5\xff\xff\x3b\x4d\x10\x73\x39\x8b\x95\x3c\xe5\xff\xff\xff\x85\x3c\xe5\xff\xff\x8a\x12\x41\x80\xfa\x0a\x75\x10\xff\x85\x30\xe5\xff\xff\xc6\x00\x0d\x40\xff\x85\x44\xe5\xff\xff\x88\x10\x40\xff\x85\x44\xe5\xff\xff\x81\xbd\x44\xe5\xff\xff\xff\x13\x00\x00\x72\xc2\x8b\xd8\x8d\x85\x48\xe5\xff\xff\x2b\xd8\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x53\x8d\x85\x48\xe5\xff\xff\x50\x8b\x06\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x42\x02\x00\x00\x8b\x85\x2c\xe5\xff\xff\x01\x85\x38\xe5\xff\xff\x3b\xc3\x0f\x8c\x3a\x02\x00\x00\x8b\x85\x3c\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x3b\x45\x10\x0f\x82\x4c\xff\xff\xff\xe9\x20\x02\x00\x00\x89\x85\x44\xe5\xff\xff\x80\xfb\x02\x0f\x85\xd1\x00\x00\x00\x39\x4d\x10\x0f\x86\x4d\x02\x00\x00\xeb\x06\x8b\xb5\x28\xe5\xff\xff\x8b\x8d\x44\xe5\xff\xff\x83\xa5\x3c\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x8d\x85\x48\xe5\xff\xff\x3b\x4d\x10\x73\x46\x8b\x95\x44\xe5\xff\xff\x83\x85\x44\xe5\xff\xff\x02\x0f\xb7\x12\x41\x41\x66\x83\xfa\x0a\x75\x16\x83\x85\x30\xe5\xff\xff\x02\x6a\x0d\x5b\x66\x89\x18\x40\x40\x83\x85\x3c\xe5\xff\xff\x02\x83\x85\x3c\xe5\xff\xff\x02\x66\x89\x10\x40\x40\x81\xbd\x3c\xe5\xff\xff\xfe\x13\x00\x00\x72\xb5\x8b\xd8\x8d\x85\x48\xe5\xff\xff\x2b\xd8\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x53\x8d\x85\x48\xe5\xff\xff\x50\x8b\x06\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x62\x01\x00\x00\x8b\x85\x2c\xe5\xff\xff\x01\x85\x38\xe5\xff\xff\x3b\xc3\x0f\x8c\x5a\x01\x00\x00\x8b\x85\x44\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x3b\x45\x10\x0f\x82\x3f\xff\xff\xff\xe9\x40\x01\x00\x00\x39\x4d\x10\x0f\x86\x7c\x01\x00\x00\x8b\x8d\x44\xe5\xff\xff\x83\xa5\x3c\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x6a\x02\x8d\x85\x48\xf9\xff\xff\x5e\x3b\x4d\x10\x73\x3c\x8b\x95\x44\xe5\xff\xff\x0f\xb7\x12\x01\xb5\x44\xe5\xff\xff\x03\xce\x66\x83\xfa\x0a\x75\x0e\x6a\x0d\x5b\x66\x89\x18\x03\xc6\x01\xb5\x3c\xe5\xff\xff\x01\xb5\x3c\xe5\xff\xff\x66\x89\x10\x03\xc6\x81\xbd\x3c\xe5\xff\xff\xa8\x06\x00\x00\x72\xbf\x33\xf6\x56\x56\x68\x55\x0d\x00\x00\x8d\x8d\xf0\xeb\xff\xff\x51\x8d\x8d\x48\xf9\xff\xff\x2b\xc1\x99\x2b\xc2\xd1\xf8\x50\x8b\xc1\x50\x56\x68\xe9\xfd\x00\x00\xff\x15\xbc\xb0\x00\x10\x8b\xd8\x3b\xde\x0f\x84\x97\x00\x00\x00\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x8b\xc3\x2b\xc6\x50\x8d\x84\x35\xf0\xeb\xff\xff\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x74\x0c\x03\xb5\x2c\xe5\xff\xff\x3b\xde\x7f\xcb\xeb\x0c\xff\x15\x00\xb0\x00\x10\x89\x85\x40\xe5\xff\xff\x3b\xde\x7f\x5c\x8b\x85\x44\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x89\x85\x38\xe5\xff\xff\x3b\x45\x10\x0f\x82\x0a\xff\xff\xff\xeb\x3f\x6a\x00\x8d\x8d\x2c\xe5\xff\xff\x51\xff\x75\x10\xff\xb5\x34\xe5\xff\xff\xff\x30\xff\x15\x00\xb1\x00\x10\x85\xc0\x74\x15\x8b\x85\x2c\xe5\xff\xff\x83\xa5\x40\xe5\xff\xff\x00\x89\x85\x38\xe5\xff\xff\xeb\x0c\xff\x15\x00\xb0\x00\x10\x89\x85\x40\xe5\xff\xff\x83\xbd\x38\xe5\xff\xff\x00\x75\x6c\x83\xbd\x40\xe5\xff\xff\x00\x74\x2d\x6a\x05\x5e\x39\xb5\x40\xe5\xff\xff\x75\x14\xe8\xa5\xb1\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\xad\xb1\xff\xff\x89\x30\xeb\x3f\xff\xb5\x40\xe5\xff\xff\xe8\xb1\xb1\xff\xff\x59\xeb\x31\x8b\xb5\x28\xe5\xff\xff\x8b\x06\xf6\x44\x07\x04\x40\x74\x0f\x8b\x85\x34\xe5\xff\xff\x80\x38\x1a\x75\x04\x33\xc0\xeb\x24\xe8\x65\xb1\xff\xff\xc7\x00\x1c\x00\x00\x00\xe8\x6d\xb1\xff\xff\x83\x20\x00\x83\xc8\xff\xeb\x0c\x8b\x85\x38\xe5\xff\xff\x2b\x85\x30\xe5\xff\xff\x5f\x5b\x8b\x4d\xfc\x33\xcd\x5e\xe8\x55\x9b\xff\xff\xc9\xc3\x6a\x10\x68\x38\xc8\x00\x10\xe8\x75\xb1\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x1b\xe8\x31\xb1\xff\xff\x83\x20\x00\xe8\x16\xb1\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\x9d\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x08\xb1\xff\xff\x89\x38\xe8\xee\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x76\xb0\xff\xff\x83\xc4\x14\xeb\xc9\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x74\xbf\x50\xe8\x19\x20\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x16\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\x2e\xf8\xff\xff\x83\xc4\x0c\x89\x45\xe4\xeb\x16\xe8\x8b\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x93\xb0\xff\xff\x89\x38\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\xf5\xb0\xff\xff\xc3\xff\x75\x08\xe8\x63\x20\x00\x00\x59\xc3\x6a\x10\x68\x58\xc8\x00\x10\xe8\x99\xb0\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x13\xe8\x42\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\xaa\x00\x00\x00\x33\xdb\x3b\xc3\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x1a\xe8\x21\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x53\x53\x53\x53\x53\xe8\xa9\xaf\xff\xff\x83\xc4\x14\xeb\xd0\x8b\xc8\xc1\xf9\x05\x8d\x3c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0f\x0f\xbe\x4c\x0e\x04\x83\xe1\x01\x74\xc6\x50\xe8\x4c\x1f\x00\x00\x59\x89\x5d\xfc\x8b\x07\xf6\x44\x06\x04\x01\x74\x31\xff\x75\x08\xe8\xc0\x1e\x00\x00\x59\x50\xff\x15\x44\xb0\x00\x10\x85\xc0\x75\x0b\xff\x15\x00\xb0\x00\x10\x89\x45\xe4\xeb\x03\x89\x5d\xe4\x39\x5d\xe4\x74\x19\xe8\xc0\xaf\xff\xff\x8b\x4d\xe4\x89\x08\xe8\xa3\xaf\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x14\xb0\xff\xff\xc3\xff\x75\x08\xe8\x82\x1f\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x85\xc0\x74\x12\x83\xe8\x08\x81\x38\xdd\xdd\x00\x00\x75\x07\x50\xe8\xa2\xb7\xff\xff\x59\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x56\x33\xdb\x57\x8b\xf1\x39\x1d\x64\xf8\x00\x10\x75\x38\x53\x53\x33\xff\x47\x57\x68\xf4\xb9\x00\x10\x68\x00\x01\x00\x00\x53\xff\x15\x38\xb0\x00\x10\x85\xc0\x74\x08\x89\x3d\x64\xf8\x00\x10\xeb\x15\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\xc7\x05\x64\xf8\x00\x10\x02\x00\x00\x00\x39\x5d\x14\x7e\x22\x8b\x4d\x14\x8b\x45\x10\x49\x38\x18\x74\x08\x40\x3b\xcb\x75\xf6\x83\xc9\xff\x8b\x45\x14\x2b\xc1\x48\x3b\x45\x14\x7d\x01\x40\x89\x45\x14\xa1\x64\xf8\x00\x10\x83\xf8\x02\x0f\x84\xac\x01\x00\x00\x3b\xc3\x0f\x84\xa4\x01\x00\x00\x83\xf8\x01\x0f\x85\xcc\x01\x00\x00\x89\x5d\xf8\x39\x5d\x20\x75\x08\x8b\x06\x8b\x40\x04\x89\x45\x20\x8b\x35\x3c\xb0\x00\x10\x33\xc0\x39\x5d\x24\x53\x53\xff\x75\x14\x0f\x95\xc0\xff\x75\x10\x8d\x04\xc5\x01\x00\x00\x00\x50\xff\x75\x20\xff\xd6\x8b\xf8\x3b\xfb\x0f\x84\x8f\x01\x00\x00\x7e\x43\x6a\xe0\x33\xd2\x58\xf7\xf7\x83\xf8\x02\x72\x37\x8d\x44\x3f\x08\x3d\x00\x04\x00\x00\x77\x13\xe8\x8e\x20\x00\x00\x8b\xc4\x3b\xc3\x74\x1c\xc7\x00\xcc\xcc\x00\x00\xeb\x11\x50\xe8\x6a\xe6\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x89\x45\xf4\xeb\x03\x89\x5d\xf4\x39\x5d\xf4\x0f\x84\x3e\x01\x00\x00\x57\xff\x75\xf4\xff\x75\x14\xff\x75\x10\x6a\x01\xff\x75\x20\xff\xd6\x85\xc0\x0f\x84\xe3\x00\x00\x00\x8b\x35\x38\xb0\x00\x10\x53\x53\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\x8b\xc8\x89\x4d\xf8\x3b\xcb\x0f\x84\xc2\x00\x00\x00\xf7\x45\x0c\x00\x04\x00\x00\x74\x29\x39\x5d\x1c\x0f\x84\xb0\x00\x00\x00\x3b\x4d\x1c\x0f\x8f\xa7\x00\x00\x00\xff\x75\x1c\xff\x75\x18\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\xe9\x90\x00\x00\x00\x3b\xcb\x7e\x45\x6a\xe0\x33\xd2\x58\xf7\xf1\x83\xf8\x02\x72\x39\x8d\x44\x09\x08\x3d\x00\x04\x00\x00\x77\x16\xe8\xcf\x1f\x00\x00\x8b\xf4\x3b\xf3\x74\x6a\xc7\x06\xcc\xcc\x00\x00\x83\xc6\x08\xeb\x1a\x50\xe8\xa8\xe5\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xf0\xeb\x02\x33\xf6\x3b\xf3\x74\x41\xff\x75\xf8\x56\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\x15\x38\xb0\x00\x10\x85\xc0\x74\x22\x53\x53\x39\x5d\x1c\x75\x04\x53\x53\xeb\x06\xff\x75\x1c\xff\x75\x18\xff\x75\xf8\x56\x53\xff\x75\x20\xff\x15\xbc\xb0\x00\x10\x89\x45\xf8\x56\xe8\xb8\xfd\xff\xff\x59\xff\x75\xf4\xe8\xaf\xfd\xff\xff\x8b\x45\xf8\x59\xe9\x59\x01\x00\x00\x89\x5d\xf4\x89\x5d\xf0\x39\x5d\x08\x75\x08\x8b\x06\x8b\x40\x14\x89\x45\x08\x39\x5d\x20\x75\x08\x8b\x06\x8b\x40\x04\x89\x45\x20\xff\x75\x08\xe8\x25\x1d\x00\x00\x59\x89\x45\xec\x83\xf8\xff\x75\x07\x33\xc0\xe9\x21\x01\x00\x00\x3b\x45\x20\x0f\x84\xdb\x00\x00\x00\x53\x53\x8d\x4d\x14\x51\xff\x75\x10\x50\xff\x75\x20\xe8\x43\x1d\x00\x00\x83\xc4\x18\x89\x45\xf4\x3b\xc3\x74\xd4\x8b\x35\x40\xb0\x00\x10\x53\x53\xff\x75\x14\x50\xff\x75\x0c\xff\x75\x08\xff\xd6\x89\x45\xf8\x3b\xc3\x75\x07\x33\xf6\xe9\xb7\x00\x00\x00\x7e\x3d\x83\xf8\xe0\x77\x38\x83\xc0\x08\x3d\x00\x04\x00\x00\x77\x16\xe8\xb9\x1e\x00\x00\x8b\xfc\x3b\xfb\x74\xdd\xc7\x07\xcc\xcc\x00\x00\x83\xc7\x08\xeb\x1a\x50\xe8\x92\xe4\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xf8\xeb\x02\x33\xff\x3b\xfb\x74\xb4\xff\x75\xf8\x53\x57\xe8\x40\xd6\xff\xff\x83\xc4\x0c\xff\x75\xf8\x57\xff\x75\x14\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\x89\x45\xf8\x3b\xc3\x75\x04\x33\xf6\xeb\x25\xff\x75\x1c\x8d\x45\xf8\xff\x75\x18\x50\x57\xff\x75\x20\xff\x75\xec\xe8\x92\x1c\x00\x00\x8b\xf0\x89\x75\xf0\x83\xc4\x18\xf7\xde\x1b\xf6\x23\x75\xf8\x57\xe8\x8d\xfc\xff\xff\x59\xeb\x1a\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x15\x40\xb0\x00\x10\x8b\xf0\x39\x5d\xf4\x74\x09\xff\x75\xf4\xe8\x22\xb4\xff\xff\x59\x8b\x45\xf0\x3b\xc3\x74\x0c\x39\x45\x18\x74\x07\x50\xe8\x0f\xb4\xff\xff\x59\x8b\xc6\x8d\x65\xe0\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xd3\x95\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\x3e\x9d\xff\xff\xff\x75\x28\x8d\x4d\xf0\xff\x75\x24\xff\x75\x20\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xe8\x28\xfc\xff\xff\x83\xc4\x20\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x51\x51\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\xa1\x68\xf8\x00\x10\x53\x56\x33\xdb\x57\x8b\xf9\x3b\xc3\x75\x3a\x8d\x45\xf8\x50\x33\xf6\x46\x56\x68\xf4\xb9\x00\x10\x56\xff\x15\x30\xb0\x00\x10\x85\xc0\x74\x08\x89\x35\x68\xf8\x00\x10\xeb\x34\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\x6a\x02\x58\xa3\x68\xf8\x00\x10\xeb\x05\xa1\x68\xf8\x00\x10\x83\xf8\x02\x0f\x84\xcf\x00\x00\x00\x3b\xc3\x0f\x84\xc7\x00\x00\x00\x83\xf8\x01\x0f\x85\xe8\x00\x00\x00\x89\x5d\xf8\x39\x5d\x18\x75\x08\x8b\x07\x8b\x40\x04\x89\x45\x18\x8b\x35\x3c\xb0\x00\x10\x33\xc0\x39\x5d\x20\x53\x53\xff\x75\x10\x0f\x95\xc0\xff\x75\x0c\x8d\x04\xc5\x01\x00\x00\x00\x50\xff\x75\x18\xff\xd6\x8b\xf8\x3b\xfb\x0f\x84\xab\x00\x00\x00\x7e\x3c\x81\xff\xf0\xff\xff\x7f\x77\x34\x8d\x44\x3f\x08\x3d\x00\x04\x00\x00\x77\x13\xe8\xd2\x1c\x00\x00\x8b\xc4\x3b\xc3\x74\x1c\xc7\x00\xcc\xcc\x00\x00\xeb\x11\x50\xe8\xae\xe2\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xd8\x85\xdb\x74\x69\x8d\x04\x3f\x50\x6a\x00\x53\xe8\x5e\xd4\xff\xff\x83\xc4\x0c\x57\x53\xff\x75\x10\xff\x75\x0c\x6a\x01\xff\x75\x18\xff\xd6\x85\xc0\x74\x11\xff\x75\x14\x50\x53\xff\x75\x08\xff\x15\x30\xb0\x00\x10\x89\x45\xf8\x53\xe8\xc9\xfa\xff\xff\x8b\x45\xf8\x59\xeb\x75\x33\xf6\x39\x5d\x1c\x75\x08\x8b\x07\x8b\x40\x14\x89\x45\x1c\x39\x5d\x18\x75\x08\x8b\x07\x8b\x40\x04\x89\x45\x18\xff\x75\x1c\xe8\x46\x1a\x00\x00\x59\x83\xf8\xff\x75\x04\x33\xc0\xeb\x47\x3b\x45\x18\x74\x1e\x53\x53\x8d\x4d\x10\x51\xff\x75\x0c\x50\xff\x75\x18\xe8\x6e\x1a\x00\x00\x8b\xf0\x83\xc4\x18\x3b\xf3\x74\xdc\x89\x75\x0c\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x75\x1c\xff\x15\x34\xb0\x00\x10\x8b\xf8\x3b\xf3\x74\x07\x56\xe8\x10\xb2\xff\xff\x59\x8b\xc7\x8d\x65\xec\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xd4\x93\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\x3f\x9b\xff\xff\xff\x75\x24\x8d\x4d\xf0\xff\x75\x20\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xe8\x16\xfe\xff\xff\x83\xc4\x1c\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x0f\x84\x81\x01\x00\x00\xff\x76\x04\xe8\xa0\xb1\xff\xff\xff\x76\x08\xe8\x98\xb1\xff\xff\xff\x76\x0c\xe8\x90\xb1\xff\xff\xff\x76\x10\xe8\x88\xb1\xff\xff\xff\x76\x14\xe8\x80\xb1\xff\xff\xff\x76\x18\xe8\x78\xb1\xff\xff\xff\x36\xe8\x71\xb1\xff\xff\xff\x76\x20\xe8\x69\xb1\xff\xff\xff\x76\x24\xe8\x61\xb1\xff\xff\xff\x76\x28\xe8\x59\xb1\xff\xff\xff\x76\x2c\xe8\x51\xb1\xff\xff\xff\x76\x30\xe8\x49\xb1\xff\xff\xff\x76\x34\xe8\x41\xb1\xff\xff\xff\x76\x1c\xe8\x39\xb1\xff\xff\xff\x76\x38\xe8\x31\xb1\xff\xff\xff\x76\x3c\xe8\x29\xb1\xff\xff\x83\xc4\x40\xff\x76\x40\xe8\x1e\xb1\xff\xff\xff\x76\x44\xe8\x16\xb1\xff\xff\xff\x76\x48\xe8\x0e\xb1\xff\xff\xff\x76\x4c\xe8\x06\xb1\xff\xff\xff\x76\x50\xe8\xfe\xb0\xff\xff\xff\x76\x54\xe8\xf6\xb0\xff\xff\xff\x76\x58\xe8\xee\xb0\xff\xff\xff\x76\x5c\xe8\xe6\xb0\xff\xff\xff\x76\x60\xe8\xde\xb0\xff\xff\xff\x76\x64\xe8\xd6\xb0\xff\xff\xff\x76\x68\xe8\xce\xb0\xff\xff\xff\x76\x6c\xe8\xc6\xb0\xff\xff\xff\x76\x70\xe8\xbe\xb0\xff\xff\xff\x76\x74\xe8\xb6\xb0\xff\xff\xff\x76\x78\xe8\xae\xb0\xff\xff\xff\x76\x7c\xe8\xa6\xb0\xff\xff\x83\xc4\x40\xff\xb6\x80\x00\x00\x00\xe8\x98\xb0\xff\xff\xff\xb6\x84\x00\x00\x00\xe8\x8d\xb0\xff\xff\xff\xb6\x88\x00\x00\x00\xe8\x82\xb0\xff\xff\xff\xb6\x8c\x00\x00\x00\xe8\x77\xb0\xff\xff\xff\xb6\x90\x00\x00\x00\xe8\x6c\xb0\xff\xff\xff\xb6\x94\x00\x00\x00\xe8\x61\xb0\xff\xff\xff\xb6\x98\x00\x00\x00\xe8\x56\xb0\xff\xff\xff\xb6\x9c\x00\x00\x00\xe8\x4b\xb0\xff\xff\xff\xb6\xa0\x00\x00\x00\xe8\x40\xb0\xff\xff\xff\xb6\xa4\x00\x00\x00\xe8\x35\xb0\xff\xff\xff\xb6\xa8\x00\x00\x00\xe8\x2a\xb0\xff\xff\x83\xc4\x2c\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x74\x35\x8b\x06\x3b\x05\x58\xed\x00\x10\x74\x07\x50\xe8\x07\xb0\xff\xff\x59\x8b\x46\x04\x3b\x05\x5c\xed\x00\x10\x74\x07\x50\xe8\xf5\xaf\xff\xff\x59\x8b\x76\x08\x3b\x35\x60\xed\x00\x10\x74\x07\x56\xe8\xe3\xaf\xff\xff\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x74\x7e\x8b\x46\x0c\x3b\x05\x64\xed\x00\x10\x74\x07\x50\xe8\xc1\xaf\xff\xff\x59\x8b\x46\x10\x3b\x05\x68\xed\x00\x10\x74\x07\x50\xe8\xaf\xaf\xff\xff\x59\x8b\x46\x14\x3b\x05\x6c\xed\x00\x10\x74\x07\x50\xe8\x9d\xaf\xff\xff\x59\x8b\x46\x18\x3b\x05\x70\xed\x00\x10\x74\x07\x50\xe8\x8b\xaf\xff\xff\x59\x8b\x46\x1c\x3b\x05\x74\xed\x00\x10\x74\x07\x50\xe8\x79\xaf\xff\xff\x59\x8b\x46\x20\x3b\x05\x78\xed\x00\x10\x74\x07\x50\xe8\x67\xaf\xff\xff\x59\x8b\x76\x24\x3b\x35\x7c\xed\x00\x10\x74\x07\x56\xe8\x55\xaf\xff\xff\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x53\x33\xdb\x56\x57\x3b\xc3\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\xef\xa6\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\x78\xa6\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x3c\x8b\x75\x10\x3b\xf3\x75\x04\x88\x18\xeb\xda\x8b\xd0\x38\x1a\x74\x04\x42\x4f\x75\xf8\x3b\xfb\x74\xee\x8a\x0e\x88\x0a\x42\x46\x3a\xcb\x74\x03\x4f\x75\xf3\x3b\xfb\x75\x10\x88\x18\xe8\xa8\xa6\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\xb5\x33\xc0\x5f\x5e\x5b\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x56\x33\xc0\x50\x50\x50\x50\x50\x50\x50\x50\x8b\x55\x0c\x8d\x49\x00\x8a\x02\x0a\xc0\x74\x09\x83\xc2\x01\x0f\xab\x04\x24\xeb\xf1\x8b\x75\x08\x83\xc9\xff\x8d\x49\x00\x83\xc1\x01\x8a\x06\x0a\xc0\x74\x09\x83\xc6\x01\x0f\xa3\x04\x24\x73\xee\x8b\xc1\x83\xc4\x20\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x33\xdb\x57\x39\x5d\x14\x75\x10\x3b\xf3\x75\x10\x39\x5d\x0c\x75\x12\x33\xc0\x5f\x5e\x5b\x5d\xc3\x3b\xf3\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\x1a\xa6\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\xa3\xa5\xff\xff\x83\xc4\x14\x8b\xc6\xeb\xd5\x39\x5d\x14\x75\x04\x88\x1e\xeb\xca\x8b\x55\x10\x3b\xd3\x75\x04\x88\x1e\xeb\xd1\x83\x7d\x14\xff\x8b\xc6\x75\x0f\x8a\x0a\x88\x08\x40\x42\x3a\xcb\x74\x1e\x4f\x75\xf3\xeb\x19\x8a\x0a\x88\x08\x40\x42\x3a\xcb\x74\x08\x4f\x74\x05\xff\x4d\x14\x75\xee\x39\x5d\x14\x75\x02\x88\x18\x3b\xfb\x75\x8b\x83\x7d\x14\xff\x75\x0f\x8b\x45\x0c\x6a\x50\x88\x5c\x06\xff\x58\xe9\x78\xff\xff\xff\x88\x1e\xe8\xa0\xa5\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\x82\xcc\xcc\xcc\xcc\xcc\x8b\x54\x24\x04\x8b\x4c\x24\x08\xf7\xc2\x03\x00\x00\x00\x75\x3c\x8b\x02\x3a\x01\x75\x2e\x0a\xc0\x74\x26\x3a\x61\x01\x75\x25\x0a\xe4\x74\x1d\xc1\xe8\x10\x3a\x41\x02\x75\x19\x0a\xc0\x74\x11\x3a\x61\x03\x75\x10\x83\xc1\x04\x83\xc2\x04\x0a\xe4\x75\xd2\x8b\xff\x33\xc0\xc3\x90\x1b\xc0\xd1\xe0\x83\xc0\x01\xc3\xf7\xc2\x01\x00\x00\x00\x74\x18\x8a\x02\x83\xc2\x01\x3a\x01\x75\xe7\x83\xc1\x01\x0a\xc0\x74\xdc\xf7\xc2\x02\x00\x00\x00\x74\xa4\x66\x8b\x02\x83\xc2\x02\x3a\x01\x75\xce\x0a\xc0\x74\xc6\x3a\x61\x01\x75\xc5\x0a\xe4\x74\xbd\x83\xc1\x02\xeb\x88\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x56\x33\xc0\x50\x50\x50\x50\x50\x50\x50\x50\x8b\x55\x0c\x8d\x49\x00\x8a\x02\x0a\xc0\x74\x09\x83\xc2\x01\x0f\xab\x04\x24\xeb\xf1\x8b\x75\x08\x8b\xff\x8a\x06\x0a\xc0\x74\x0c\x83\xc6\x01\x0f\xa3\x04\x24\x73\xf1\x8d\x46\xff\x83\xc4\x20\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x51\x51\x8b\x45\x0c\x56\x8b\x75\x08\x89\x45\xf8\x8b\x45\x10\x57\x56\x89\x45\xfc\xe8\x93\x13\x00\x00\x83\xcf\xff\x59\x3b\xc7\x75\x11\xe8\x97\xa4\xff\xff\xc7\x00\x09\x00\x00\x00\x8b\xc7\x8b\xd7\xeb\x4a\xff\x75\x14\x8d\x4d\xfc\x51\xff\x75\xf8\x50\xff\x15\x28\xb0\x00\x10\x89\x45\xf8\x3b\xc7\x75\x13\xff\x15\x00\xb0\x00\x10\x85\xc0\x74\x09\x50\xe8\x89\xa4\xff\xff\x59\xeb\xcf\x8b\xc6\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x83\xe6\x1f\xc1\xe6\x06\x8d\x44\x30\x04\x80\x20\xfd\x8b\x45\xf8\x8b\x55\xfc\x5f\x5e\xc9\xc3\x6a\x14\x68\x78\xc8\x00\x10\xe8\x7b\xa4\xff\xff\x83\xce\xff\x89\x75\xdc\x89\x75\xe0\x8b\x45\x08\x83\xf8\xfe\x75\x1c\xe8\x2e\xa4\xff\xff\x83\x20\x00\xe8\x13\xa4\xff\xff\xc7\x00\x09\x00\x00\x00\x8b\xc6\x8b\xd6\xe9\xd0\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x04\xa4\xff\xff\x89\x38\xe8\xea\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x72\xa3\xff\xff\x83\xc4\x14\xeb\xc8\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x75\x26\xe8\xc3\xa3\xff\xff\x89\x38\xe8\xa9\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x31\xa3\xff\xff\x83\xc4\x14\x83\xca\xff\x8b\xc2\xeb\x5b\x50\xe8\xef\x12\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x1c\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\xa9\xfe\xff\xff\x83\xc4\x10\x89\x45\xdc\x89\x55\xe0\xeb\x1a\xe8\x5b\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x63\xa3\xff\xff\x89\x38\x83\x4d\xdc\xff\x83\x4d\xe0\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x0c\x00\x00\x00\x8b\x45\xdc\x8b\x55\xe0\xe8\xbe\xa3\xff\xff\xc3\xff\x75\x08\xe8\x2c\x13\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\xff\x05\x1c\xf2\x00\x10\x68\x00\x10\x00\x00\xe8\xe2\xab\xff\xff\x59\x8b\x4d\x08\x89\x41\x08\x85\xc0\x74\x0d\x83\x49\x0c\x08\xc7\x41\x18\x00\x10\x00\x00\xeb\x11\x83\x49\x0c\x04\x8d\x41\x14\x89\x41\x08\xc7\x41\x18\x02\x00\x00\x00\x8b\x41\x08\x83\x61\x04\x00\x89\x01\x5d\xc3\x6a\x02\xe8\xb6\xac\xff\xff\x59\xc3\x55\x8b\xec\x83\xec\x04\x89\x7d\xfc\x8b\x7d\x08\x8b\x4d\x0c\xc1\xe9\x07\x66\x0f\xef\xc0\xeb\x08\x8d\xa4\x24\x00\x00\x00\x00\x90\x66\x0f\x7f\x07\x66\x0f\x7f\x47\x10\x66\x0f\x7f\x47\x20\x66\x0f\x7f\x47\x30\x66\x0f\x7f\x47\x40\x66\x0f\x7f\x47\x50\x66\x0f\x7f\x47\x60\x66\x0f\x7f\x47\x70\x8d\xbf\x80\x00\x00\x00\x49\x75\xd0\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x55\x8b\xec\x83\xec\x10\x89\x7d\xfc\x8b\x45\x08\x99\x8b\xf8\x33\xfa\x2b\xfa\x83\xe7\x0f\x33\xfa\x2b\xfa\x85\xff\x75\x3c\x8b\x4d\x10\x8b\xd1\x83\xe2\x7f\x89\x55\xf4\x3b\xca\x74\x12\x2b\xca\x51\x50\xe8\x73\xff\xff\xff\x83\xc4\x08\x8b\x45\x08\x8b\x55\xf4\x85\xd2\x74\x45\x03\x45\x10\x2b\xc2\x89\x45\xf8\x33\xc0\x8b\x7d\xf8\x8b\x4d\xf4\xf3\xaa\x8b\x45\x08\xeb\x2e\xf7\xdf\x83\xc7\x10\x89\x7d\xf0\x33\xc0\x8b\x7d\x08\x8b\x4d\xf0\xf3\xaa\x8b\x45\xf0\x8b\x4d\x08\x8b\x55\x10\x03\xc8\x2b\xd0\x52\x6a\x00\x51\xe8\x7e\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x6a\x0c\x68\x98\xc8\x00\x10\xe8\x2a\xa2\xff\xff\x83\x65\xfc\x00\x66\x0f\x28\xc1\xc7\x45\xe4\x01\x00\x00\x00\xeb\x23\x8b\x45\xec\x8b\x00\x8b\x00\x3d\x05\x00\x00\xc0\x74\x0a\x3d\x1d\x00\x00\xc0\x74\x03\x33\xc0\xc3\x33\xc0\x40\xc3\x8b\x65\xe8\x83\x65\xe4\x00\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xe8\x2c\xa2\xff\xff\xc3\x8b\xff\x55\x8b\xec\x83\xec\x18\x33\xc0\x53\x89\x45\xfc\x89\x45\xf4\x89\x45\xf8\x53\x9c\x58\x8b\xc8\x35\x00\x00\x20\x00\x50\x9d\x9c\x5a\x2b\xd1\x74\x1f\x51\x9d\x33\xc0\x0f\xa2\x89\x45\xf4\x89\x5d\xe8\x89\x55\xec\x89\x4d\xf0\xb8\x01\x00\x00\x00\x0f\xa2\x89\x55\xfc\x89\x45\xf8\x5b\xf7\x45\xfc\x00\x00\x00\x04\x74\x0e\xe8\x5c\xff\xff\xff\x85\xc0\x74\x05\x33\xc0\x40\xeb\x02\x33\xc0\x5b\xc9\xc3\xe8\x99\xff\xff\xff\xa3\x0c\xfd\x00\x10\x33\xc0\xc3\xcc\xcc\xcc\x55\x8b\xec\x53\x56\x57\x55\x6a\x00\x6a\x00\x68\x50\x8a\x00\x10\xff\x75\x08\xe8\x0e\x16\x00\x00\x5d\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\x4c\x24\x04\xf7\x41\x04\x06\x00\x00\x00\xb8\x01\x00\x00\x00\x74\x32\x8b\x44\x24\x14\x8b\x48\xfc\x33\xc8\xe8\x06\x8b\xff\xff\x55\x8b\x68\x10\x8b\x50\x28\x52\x8b\x50\x24\x52\xe8\x14\x00\x00\x00\x83\xc4\x08\x5d\x8b\x44\x24\x08\x8b\x54\x24\x10\x89\x02\xb8\x03\x00\x00\x00\xc3\x53\x56\x57\x8b\x44\x24\x10\x55\x50\x6a\xfe\x68\x58\x8a\x00\x10\x64\xff\x35\x00\x00\x00\x00\xa1\x00\xe0\x00\x10\x33\xc4\x50\x8d\x44\x24\x04\x64\xa3\x00\x00\x00\x00\x8b\x44\x24\x28\x8b\x58\x08\x8b\x70\x0c\x83\xfe\xff\x74\x3a\x83\x7c\x24\x2c\xff\x74\x06\x3b\x74\x24\x2c\x76\x2d\x8d\x34\x76\x8b\x0c\xb3\x89\x4c\x24\x0c\x89\x48\x0c\x83\x7c\xb3\x04\x00\x75\x17\x68\x01\x01\x00\x00\x8b\x44\xb3\x08\xe8\x49\x00\x00\x00\x8b\x44\xb3\x08\xe8\x5f\x00\x00\x00\xeb\xb7\x8b\x4c\x24\x04\x64\x89\x0d\x00\x00\x00\x00\x83\xc4\x18\x5f\x5e\x5b\xc3\x33\xc0\x64\x8b\x0d\x00\x00\x00\x00\x81\x79\x04\x58\x8a\x00\x10\x75\x10\x8b\x51\x0c\x8b\x52\x0c\x39\x51\x08\x75\x05\xb8\x01\x00\x00\x00\xc3\x53\x51\xbb\xa0\xed\x00\x10\xeb\x0b\x53\x51\xbb\xa0\xed\x00\x10\x8b\x4c\x24\x0c\x89\x4b\x08\x89\x43\x04\x89\x6b\x0c\x55\x51\x50\x58\x59\x5d\x59\x5b\xc2\x04\x00\xff\xd0\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\x56\x57\xff\x75\x08\x8d\x4d\xec\xe8\x7a\x91\xff\xff\x8b\x45\x10\x8b\x75\x0c\x33\xff\x3b\xc7\x74\x02\x89\x30\x3b\xf7\x75\x2c\xe8\xc7\x9f\xff\xff\x57\x57\x57\x57\x57\xc7\x00\x16\x00\x00\x00\xe8\x4f\x9f\xff\xff\x83\xc4\x14\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x33\xc0\xe9\xd8\x01\x00\x00\x39\x7d\x14\x74\x0c\x83\x7d\x14\x02\x7c\xc9\x83\x7d\x14\x24\x7f\xc3\x8b\x4d\xec\x53\x8a\x1e\x89\x7d\xfc\x8d\x7e\x01\x83\xb9\xac\x00\x00\x00\x01\x7e\x17\x8d\x45\xec\x50\x0f\xb6\xc3\x6a\x08\x50\xe8\xdb\x11\x00\x00\x8b\x4d\xec\x83\xc4\x0c\xeb\x10\x8b\x91\xc8\x00\x00\x00\x0f\xb6\xc3\x0f\xb7\x04\x42\x83\xe0\x08\x85\xc0\x74\x05\x8a\x1f\x47\xeb\xc7\x80\xfb\x2d\x75\x06\x83\x4d\x18\x02\xeb\x05\x80\xfb\x2b\x75\x03\x8a\x1f\x47\x8b\x45\x14\x85\xc0\x0f\x8c\x4b\x01\x00\x00\x83\xf8\x01\x0f\x84\x42\x01\x00\x00\x83\xf8\x24\x0f\x8f\x39\x01\x00\x00\x85\xc0\x75\x2a\x80\xfb\x30\x74\x09\xc7\x45\x14\x0a\x00\x00\x00\xeb\x34\x8a\x07\x3c\x78\x74\x0d\x3c\x58\x74\x09\xc7\x45\x14\x08\x00\x00\x00\xeb\x21\xc7\x45\x14\x10\x00\x00\x00\xeb\x0a\x83\xf8\x10\x75\x13\x80\xfb\x30\x75\x0e\x8a\x07\x3c\x78\x74\x04\x3c\x58\x75\x04\x47\x8a\x1f\x47\x8b\xb1\xc8\x00\x00\x00\xb8\xff\xff\xff\xff\x33\xd2\xf7\x75\x14\x0f\xb6\xcb\x0f\xb7\x0c\x4e\xf6\xc1\x04\x74\x08\x0f\xbe\xcb\x83\xe9\x30\xeb\x1b\xf7\xc1\x03\x01\x00\x00\x74\x31\x8a\xcb\x80\xe9\x61\x80\xf9\x19\x0f\xbe\xcb\x77\x03\x83\xe9\x20\x83\xc1\xc9\x3b\x4d\x14\x73\x19\x83\x4d\x18\x08\x39\x45\xfc\x72\x27\x75\x04\x3b\xca\x76\x21\x83\x4d\x18\x04\x83\x7d\x10\x00\x75\x23\x8b\x45\x18\x4f\xa8\x08\x75\x20\x83\x7d\x10\x00\x74\x03\x8b\x7d\x0c\x83\x65\xfc\x00\xeb\x5b\x8b\x5d\xfc\x0f\xaf\x5d\x14\x03\xd9\x89\x5d\xfc\x8a\x1f\x47\xeb\x8b\xbe\xff\xff\xff\x7f\xa8\x04\x75\x1b\xa8\x01\x75\x3d\x83\xe0\x02\x74\x09\x81\x7d\xfc\x00\x00\x00\x80\x77\x09\x85\xc0\x75\x2b\x39\x75\xfc\x76\x26\xe8\x26\x9e\xff\xff\xf6\x45\x18\x01\xc7\x00\x22\x00\x00\x00\x74\x06\x83\x4d\xfc\xff\xeb\x0f\xf6\x45\x18\x02\x6a\x00\x58\x0f\x95\xc0\x03\xc6\x89\x45\xfc\x8b\x45\x10\x85\xc0\x74\x02\x89\x38\xf6\x45\x18\x02\x74\x03\xf7\x5d\xfc\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x8b\x45\xfc\xeb\x18\x8b\x45\x10\x85\xc0\x74\x02\x89\x30\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x33\xc0\x5b\x5f\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x33\xc0\x50\xff\x75\x10\xff\x75\x0c\xff\x75\x08\x39\x05\xf4\xf4\x00\x10\x75\x07\x68\x98\xeb\x00\x10\xeb\x01\x50\xe8\xab\xfd\xff\xff\x83\xc4\x14\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x8b\x75\x0c\x8b\x4d\x10\x8b\x7d\x08\x8b\xc1\x8b\xd1\x03\xc6\x3b\xfe\x76\x08\x3b\xf8\x0f\x82\xa4\x01\x00\x00\x81\xf9\x00\x01\x00\x00\x72\x1f\x83\x3d\x0c\xfd\x00\x10\x00\x74\x16\x57\x56\x83\xe7\x0f\x83\xe6\x0f\x3b\xfe\x5e\x5f\x75\x08\x5e\x5f\x5d\xe9\x13\x07\x00\x00\xf7\xc7\x03\x00\x00\x00\x75\x15\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x2a\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x90\x8b\xc7\xba\x03\x00\x00\x00\x83\xe9\x04\x72\x0c\x83\xe0\x03\x03\xc8\xff\x24\x85\x58\x8e\x00\x10\xff\x24\x8d\x54\x8f\x00\x10\x90\xff\x24\x8d\xd8\x8e\x00\x10\x90\x68\x8e\x00\x10\x94\x8e\x00\x10\xb8\x8e\x00\x10\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xc6\x03\x83\xc7\x03\x83\xf9\x08\x72\xcc\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x8d\x49\x00\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xc6\x02\x83\xc7\x02\x83\xf9\x08\x72\xa6\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x90\x23\xd1\x8a\x06\x88\x07\x83\xc6\x01\xc1\xe9\x02\x83\xc7\x01\x83\xf9\x08\x72\x88\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x8d\x49\x00\x3b\x8f\x00\x10\x28\x8f\x00\x10\x20\x8f\x00\x10\x18\x8f\x00\x10\x10\x8f\x00\x10\x08\x8f\x00\x10\x00\x8f\x00\x10\xf8\x8e\x00\x10\x8b\x44\x8e\xe4\x89\x44\x8f\xe4\x8b\x44\x8e\xe8\x89\x44\x8f\xe8\x8b\x44\x8e\xec\x89\x44\x8f\xec\x8b\x44\x8e\xf0\x89\x44\x8f\xf0\x8b\x44\x8e\xf4\x89\x44\x8f\xf4\x8b\x44\x8e\xf8\x89\x44\x8f\xf8\x8b\x44\x8e\xfc\x89\x44\x8f\xfc\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\x44\x8f\x00\x10\x8b\xff\x54\x8f\x00\x10\x5c\x8f\x00\x10\x68\x8f\x00\x10\x7c\x8f\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8d\x74\x31\xfc\x8d\x7c\x39\xfc\xf7\xc7\x03\x00\x00\x00\x75\x24\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x0d\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8b\xff\xf7\xd9\xff\x24\x8d\x90\x90\x00\x10\x8d\x49\x00\x8b\xc7\xba\x03\x00\x00\x00\x83\xf9\x04\x72\x0c\x83\xe0\x03\x2b\xc8\xff\x24\x85\xe4\x8f\x00\x10\xff\x24\x8d\xe0\x90\x00\x10\x90\xf4\x8f\x00\x10\x18\x90\x00\x10\x40\x90\x00\x10\x8a\x46\x03\x23\xd1\x88\x47\x03\x83\xee\x01\xc1\xe9\x02\x83\xef\x01\x83\xf9\x08\x72\xb2\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8d\x49\x00\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xee\x02\x83\xef\x02\x83\xf9\x08\x72\x88\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x90\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xee\x03\x83\xef\x03\x83\xf9\x08\x0f\x82\x56\xff\xff\xff\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8d\x49\x00\x94\x90\x00\x10\x9c\x90\x00\x10\xa4\x90\x00\x10\xac\x90\x00\x10\xb4\x90\x00\x10\xbc\x90\x00\x10\xc4\x90\x00\x10\xd7\x90\x00\x10\x8b\x44\x8e\x1c\x89\x44\x8f\x1c\x8b\x44\x8e\x18\x89\x44\x8f\x18\x8b\x44\x8e\x14\x89\x44\x8f\x14\x8b\x44\x8e\x10\x89\x44\x8f\x10\x8b\x44\x8e\x0c\x89\x44\x8f\x0c\x8b\x44\x8e\x08\x89\x44\x8f\x08\x8b\x44\x8e\x04\x89\x44\x8f\x04\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\xe0\x90\x00\x10\x8b\xff\xf0\x90\x00\x10\xf8\x90\x00\x10\x08\x91\x00\x10\x1c\x91\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x6a\x10\x68\xb8\xc8\x00\x10\xe8\x6b\x9a\xff\xff\x33\xc0\x8b\x5d\x08\x33\xff\x3b\xdf\x0f\x95\xc0\x3b\xc7\x75\x1d\xe8\x0c\x9a\xff\xff\xc7\x00\x16\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x94\x99\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x53\x83\x3d\x2c\xfd\x00\x10\x03\x75\x38\x6a\x04\xe8\x73\xb4\xff\xff\x59\x89\x7d\xfc\x53\xe8\xe5\xc6\xff\xff\x59\x89\x45\xe0\x3b\xc7\x74\x0b\x8b\x73\xfc\x83\xee\x09\x89\x75\xe4\xeb\x03\x8b\x75\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x25\x00\x00\x00\x39\x7d\xe0\x75\x10\x53\x57\xff\x35\x84\xf3\x00\x10\xff\x15\x24\xb0\x00\x10\x8b\xf0\x8b\xc6\xe8\x2b\x9a\xff\xff\xc3\x33\xff\x8b\x5d\x08\x8b\x75\xe4\x6a\x04\xe8\x41\xb3\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\x53\x56\x57\xe8\x26\x9c\xff\xff\x83\x65\xfc\x00\x83\x3d\x74\xf8\x00\x10\x00\x8b\xd8\x0f\x85\x8e\x00\x00\x00\x68\x90\xc3\x00\x10\xff\x15\x04\xb1\x00\x10\x8b\xf8\x85\xff\x0f\x84\x2a\x01\x00\x00\x8b\x35\x6c\xb0\x00\x10\x68\x84\xc3\x00\x10\x57\xff\xd6\x85\xc0\x0f\x84\x14\x01\x00\x00\x50\xe8\x70\x9b\xff\xff\xc7\x04\x24\x74\xc3\x00\x10\x57\xa3\x74\xf8\x00\x10\xff\xd6\x50\xe8\x5b\x9b\xff\xff\xc7\x04\x24\x60\xc3\x00\x10\x57\xa3\x78\xf8\x00\x10\xff\xd6\x50\xe8\x46\x9b\xff\xff\xc7\x04\x24\x44\xc3\x00\x10\x57\xa3\x7c\xf8\x00\x10\xff\xd6\x50\xe8\x31\x9b\xff\xff\x59\xa3\x84\xf8\x00\x10\x85\xc0\x74\x14\x68\x2c\xc3\x00\x10\x57\xff\xd6\x50\xe8\x19\x9b\xff\xff\x59\xa3\x80\xf8\x00\x10\xa1\x80\xf8\x00\x10\x3b\xc3\x74\x4f\x39\x1d\x84\xf8\x00\x10\x74\x47\x50\xe8\x77\x9b\xff\xff\xff\x35\x84\xf8\x00\x10\x8b\xf0\xe8\x6a\x9b\xff\xff\x59\x59\x8b\xf8\x85\xf6\x74\x2c\x85\xff\x74\x28\xff\xd6\x85\xc0\x74\x19\x8d\x4d\xf8\x51\x6a\x0c\x8d\x4d\xec\x51\x6a\x01\x50\xff\xd7\x85\xc0\x74\x06\xf6\x45\xf4\x01\x75\x09\x81\x4d\x10\x00\x00\x20\x00\xeb\x39\xa1\x78\xf8\x00\x10\x3b\xc3\x74\x30\x50\xe8\x27\x9b\xff\xff\x59\x85\xc0\x74\x25\xff\xd0\x89\x45\xfc\x85\xc0\x74\x1c\xa1\x7c\xf8\x00\x10\x3b\xc3\x74\x13\x50\xe8\x0a\x9b\xff\xff\x59\x85\xc0\x74\x08\xff\x75\xfc\xff\xd0\x89\x45\xfc\xff\x35\x74\xf8\x00\x10\xe8\xf2\x9a\xff\xff\x59\x85\xc0\x74\x10\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x75\xfc\xff\xd0\xeb\x02\x33\xc0\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x56\x33\xf6\x3b\xce\x7c\x1e\x83\xf9\x02\x7e\x0c\x83\xf9\x03\x75\x14\xa1\xf0\xee\x00\x10\xeb\x28\xa1\xf0\xee\x00\x10\x89\x0d\xf0\xee\x00\x10\xeb\x1b\xe8\xef\x97\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x77\x97\xff\xff\x83\xc4\x14\x83\xc8\xff\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\xf6\x05\xb0\xed\x00\x10\x01\x56\x74\x08\x6a\x0a\xe8\xd1\xd3\xff\xff\x59\xe8\x8c\xd7\xff\xff\x85\xc0\x74\x08\x6a\x16\xe8\x8e\xd7\xff\xff\x59\xf6\x05\xb0\xed\x00\x10\x02\x0f\x84\xca\x00\x00\x00\x89\x85\xe0\xfd\xff\xff\x89\x8d\xdc\xfd\xff\xff\x89\x95\xd8\xfd\xff\xff\x89\x9d\xd4\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xbd\xcc\xfd\xff\xff\x66\x8c\x95\xf8\xfd\xff\xff\x66\x8c\x8d\xec\xfd\xff\xff\x66\x8c\x9d\xc8\xfd\xff\xff\x66\x8c\x85\xc4\xfd\xff\xff\x66\x8c\xa5\xc0\xfd\xff\xff\x66\x8c\xad\xbc\xfd\xff\xff\x9c\x8f\x85\xf0\xfd\xff\xff\x8b\x75\x04\x8d\x45\x04\x89\x85\xf4\xfd\xff\xff\xc7\x85\x30\xfd\xff\xff\x01\x00\x01\x00\x89\xb5\xe8\xfd\xff\xff\x8b\x40\xfc\x6a\x50\x89\x85\xe4\xfd\xff\xff\x8d\x85\xd8\xfc\xff\xff\x6a\x00\x50\xe8\xf5\xc0\xff\xff\x8d\x85\xd8\xfc\xff\xff\x83\xc4\x0c\x89\x85\x28\xfd\xff\xff\x8d\x85\x30\xfd\xff\xff\x6a\x00\xc7\x85\xd8\xfc\xff\xff\x15\x00\x00\x40\x89\xb5\xe4\xfc\xff\xff\x89\x85\x2c\xfd\xff\xff\xff\x15\x5c\xb0\x00\x10\x8d\x85\x28\xfd\xff\xff\x50\xff\x15\x58\xb0\x00\x10\x6a\x03\xe8\x12\xa3\xff\xff\xcc\x55\x8b\xec\x83\xec\x08\x89\x7d\xfc\x89\x75\xf8\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\x10\xc1\xe9\x07\xeb\x06\x8d\x9b\x00\x00\x00\x00\x66\x0f\x6f\x06\x66\x0f\x6f\x4e\x10\x66\x0f\x6f\x56\x20\x66\x0f\x6f\x5e\x30\x66\x0f\x7f\x07\x66\x0f\x7f\x4f\x10\x66\x0f\x7f\x57\x20\x66\x0f\x7f\x5f\x30\x66\x0f\x6f\x66\x40\x66\x0f\x6f\x6e\x50\x66\x0f\x6f\x76\x60\x66\x0f\x6f\x7e\x70\x66\x0f\x7f\x67\x40\x66\x0f\x7f\x6f\x50\x66\x0f\x7f\x77\x60\x66\x0f\x7f\x7f\x70\x8d\xb6\x80\x00\x00\x00\x8d\xbf\x80\x00\x00\x00\x49\x75\xa3\x8b\x75\xf8\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x55\x8b\xec\x83\xec\x1c\x89\x7d\xf4\x89\x75\xf8\x89\x5d\xfc\x8b\x5d\x0c\x8b\xc3\x99\x8b\xc8\x8b\x45\x08\x33\xca\x2b\xca\x83\xe1\x0f\x33\xca\x2b\xca\x99\x8b\xf8\x33\xfa\x2b\xfa\x83\xe7\x0f\x33\xfa\x2b\xfa\x8b\xd1\x0b\xd7\x75\x4a\x8b\x75\x10\x8b\xce\x83\xe1\x7f\x89\x4d\xe8\x3b\xf1\x74\x13\x2b\xf1\x56\x53\x50\xe8\x27\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\x8b\x4d\xe8\x85\xc9\x74\x77\x8b\x5d\x10\x8b\x55\x0c\x03\xd3\x2b\xd1\x89\x55\xec\x03\xd8\x2b\xd9\x89\x5d\xf0\x8b\x75\xec\x8b\x7d\xf0\x8b\x4d\xe8\xf3\xa4\x8b\x45\x08\xeb\x53\x3b\xcf\x75\x35\xf7\xd9\x83\xc1\x10\x89\x4d\xe4\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\xe4\xf3\xa4\x8b\x4d\x08\x03\x4d\xe4\x8b\x55\x0c\x03\x55\xe4\x8b\x45\x10\x2b\x45\xe4\x50\x52\x51\xe8\x4c\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\xeb\x1a\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\x10\x8b\xd1\xc1\xe9\x02\xf3\xa5\x8b\xca\x83\xe1\x03\xf3\xa4\x8b\x45\x08\x8b\x5d\xfc\x8b\x75\xf8\x8b\x7d\xf4\x8b\xe5\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x57\x56\xe8\x34\x04\x00\x00\x59\x83\xf8\xff\x74\x50\xa1\x40\xfd\x00\x10\x83\xfe\x01\x75\x09\xf6\x80\x84\x00\x00\x00\x01\x75\x0b\x83\xfe\x02\x75\x1c\xf6\x40\x44\x01\x74\x16\x6a\x02\xe8\x09\x04\x00\x00\x6a\x01\x8b\xf8\xe8\x00\x04\x00\x00\x59\x59\x3b\xc7\x74\x1c\x56\xe8\xf4\x03\x00\x00\x59\x50\xff\x15\x20\xb0\x00\x10\x85\xc0\x75\x0a\xff\x15\x00\xb0\x00\x10\x8b\xf8\xeb\x02\x33\xff\x56\xe8\x50\x03\x00\x00\x8b\xc6\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x83\xe6\x1f\xc1\xe6\x06\x59\xc6\x44\x30\x04\x00\x85\xff\x74\x0c\x57\xe8\xeb\x94\xff\xff\x59\x83\xc8\xff\xeb\x02\x33\xc0\x5f\x5e\x5d\xc3\x6a\x10\x68\xd8\xc8\x00\x10\xe8\xf7\x94\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x1b\xe8\xb3\x94\xff\xff\x83\x20\x00\xe8\x98\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\x8e\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x8a\x94\xff\xff\x89\x38\xe8\x70\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\xf8\x93\xff\xff\x83\xc4\x14\xeb\xc9\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x74\xbf\x50\xe8\x9b\x03\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x0e\xff\x75\x08\xe8\xcb\xfe\xff\xff\x59\x89\x45\xe4\xeb\x0f\xe8\x15\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x86\x94\xff\xff\xc3\xff\x75\x08\xe8\xf4\x03\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x8b\x46\x0c\xa8\x83\x74\x1e\xa8\x08\x74\x1a\xff\x76\x08\xe8\x15\x9c\xff\xff\x81\x66\x0c\xf7\xfb\xff\xff\x33\xc0\x59\x89\x06\x89\x46\x08\x89\x46\x04\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x56\x33\xf6\x39\x35\xb4\xed\x00\x10\x74\x4f\x83\x3d\x74\xee\x00\x10\xfe\x75\x05\xe8\xb8\x06\x00\x00\xa1\x74\xee\x00\x10\x83\xf8\xff\x75\x07\xb8\xff\xff\x00\x00\xeb\x70\x56\x8d\x4d\xf0\x51\x6a\x01\x8d\x4d\x08\x51\x50\xff\x15\x14\xb0\x00\x10\x85\xc0\x75\x67\x83\x3d\xb4\xed\x00\x10\x02\x75\xda\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\xcf\x89\x35\xb4\xed\x00\x10\x56\x56\x6a\x05\x8d\x45\xf4\x50\x6a\x01\x8d\x45\x08\x50\x56\xff\x15\x18\xb0\x00\x10\x50\xff\x15\xbc\xb0\x00\x10\x8b\x0d\x74\xee\x00\x10\x83\xf9\xff\x74\xa2\x56\x8d\x55\xf0\x52\x50\x8d\x45\xf4\x50\x51\xff\x15\x1c\xb0\x00\x10\x85\xc0\x74\x8d\x66\x8b\x45\x08\x8b\x4d\xfc\x33\xcd\x5e\xe8\x20\x7d\xff\xff\xc9\xc3\xc7\x05\xb4\xed\x00\x10\x01\x00\x00\x00\xeb\xe3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x56\x8b\x75\x0c\x33\xdb\x3b\xf3\x74\x15\x39\x5d\x10\x74\x10\x38\x1e\x75\x12\x8b\x45\x08\x3b\xc3\x74\x05\x33\xc9\x66\x89\x08\x33\xc0\x5e\x5b\xc9\xc3\xff\x75\x14\x8d\x4d\xf0\xe8\x59\x84\xff\xff\x8b\x45\xf0\x39\x58\x14\x75\x1f\x8b\x45\x08\x3b\xc3\x74\x07\x66\x0f\xb6\x0e\x66\x89\x08\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x33\xc0\x40\xeb\xca\x8d\x45\xf0\x50\x0f\xb6\x06\x50\xe8\x8b\xbb\xff\xff\x59\x59\x85\xc0\x74\x7d\x8b\x45\xf0\x8b\x88\xac\x00\x00\x00\x83\xf9\x01\x7e\x25\x39\x4d\x10\x7c\x20\x33\xd2\x39\x5d\x08\x0f\x95\xc2\x52\xff\x75\x08\x51\x56\x6a\x09\xff\x70\x04\xff\x15\x3c\xb0\x00\x10\x85\xc0\x8b\x45\xf0\x75\x10\x8b\x4d\x10\x3b\x88\xac\x00\x00\x00\x72\x20\x38\x5e\x01\x74\x1b\x8b\x80\xac\x00\x00\x00\x38\x5d\xfc\x0f\x84\x65\xff\xff\xff\x8b\x4d\xf8\x83\x61\x70\xfd\xe9\x59\xff\xff\xff\xe8\x20\x92\xff\xff\xc7\x00\x2a\x00\x00\x00\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x83\xc8\xff\xe9\x3a\xff\xff\xff\x33\xc0\x39\x5d\x08\x0f\x95\xc0\x50\xff\x75\x08\x8b\x45\xf0\x6a\x01\x56\x6a\x09\xff\x70\x04\xff\x15\x3c\xb0\x00\x10\x85\xc0\x0f\x85\x3a\xff\xff\xff\xeb\xba\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\xd4\xfe\xff\xff\x83\xc4\x10\x5d\xc3\xcc\xcc\xcc\x51\x8d\x4c\x24\x04\x2b\xc8\x1b\xc0\xf7\xd0\x23\xc8\x8b\xc4\x25\x00\xf0\xff\xff\x3b\xc8\x72\x0a\x8b\xc1\x59\x94\x8b\x00\x89\x04\x24\xc3\x2d\x00\x10\x00\x00\x85\x00\xeb\xe9\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x53\x33\xdb\x3b\xcb\x56\x57\x7c\x5b\x3b\x0d\x30\xfd\x00\x10\x73\x53\x8b\xc1\xc1\xf8\x05\x8b\xf1\x8d\x3c\x85\x40\xfd\x00\x10\x8b\x07\x83\xe6\x1f\xc1\xe6\x06\x03\xc6\xf6\x40\x04\x01\x74\x35\x83\x38\xff\x74\x30\x83\x3d\xf4\xee\x00\x10\x01\x75\x1d\x2b\xcb\x74\x10\x49\x74\x08\x49\x75\x13\x53\x6a\xf4\xeb\x08\x53\x6a\xf5\xeb\x03\x53\x6a\xf6\xff\x15\x10\xb0\x00\x10\x8b\x07\x83\x0c\x06\xff\x33\xc0\xeb\x15\xe8\x26\x91\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x2e\x91\xff\xff\x89\x18\x83\xc8\xff\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\xfe\x75\x18\xe8\x12\x91\xff\xff\x83\x20\x00\xe8\xf7\x90\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\x5d\xc3\x56\x33\xf6\x3b\xc6\x7c\x22\x3b\x05\x30\xfd\x00\x10\x73\x1a\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x03\xc1\xf6\x40\x04\x01\x75\x24\xe8\xd1\x90\xff\xff\x89\x30\xe8\xb7\x90\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x09\x00\x00\x00\xe8\x3f\x90\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x02\x8b\x00\x5e\x5d\xc3\x6a\x0c\x68\xf8\xc8\x00\x10\xe8\xd8\x90\xff\xff\x8b\x7d\x08\x8b\xc7\xc1\xf8\x05\x8b\xf7\x83\xe6\x1f\xc1\xe6\x06\x03\x34\x85\x40\xfd\x00\x10\xc7\x45\xe4\x01\x00\x00\x00\x33\xdb\x39\x5e\x08\x75\x36\x6a\x0a\xe8\xf1\xaa\xff\xff\x59\x89\x5d\xfc\x39\x5e\x08\x75\x1a\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\x17\xd2\xff\xff\x59\x59\x85\xc0\x75\x03\x89\x5d\xe4\xff\x46\x08\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x30\x00\x00\x00\x39\x5d\xe4\x74\x1d\x8b\xc7\xc1\xf8\x05\x83\xe7\x1f\xc1\xe7\x06\x8b\x04\x85\x40\xfd\x00\x10\x8d\x44\x38\x0c\x50\xff\x15\x64\xb0\x00\x10\x8b\x45\xe4\xe8\x98\x90\xff\xff\xc3\x33\xdb\x8b\x7d\x08\x6a\x0a\xe8\xb1\xa9\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x8d\x44\x01\x0c\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x6a\x06\x8d\x45\xf4\x50\x68\x04\x10\x00\x00\xff\x75\x08\xc6\x45\xfa\x00\xff\x15\x2c\xb0\x00\x10\x85\xc0\x75\x05\x83\xc8\xff\xeb\x0a\x8d\x45\xf4\x50\xe8\xf1\x01\x00\x00\x59\x8b\x4d\xfc\x33\xcd\xe8\xa8\x79\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x34\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x8b\x45\x10\x8b\x4d\x18\x89\x45\xd8\x8b\x45\x14\x53\x89\x45\xd0\x8b\x00\x56\x89\x45\xdc\x8b\x45\x08\x57\x33\xff\x89\x4d\xcc\x89\x7d\xe0\x89\x7d\xd4\x3b\x45\x0c\x0f\x84\x5f\x01\x00\x00\x8b\x35\xe0\xb0\x00\x10\x8d\x4d\xe8\x51\x50\xff\xd6\x8b\x1d\x3c\xb0\x00\x10\x85\xc0\x74\x5e\x83\x7d\xe8\x01\x75\x58\x8d\x45\xe8\x50\xff\x75\x0c\xff\xd6\x85\xc0\x74\x4b\x83\x7d\xe8\x01\x75\x45\x8b\x75\xdc\xc7\x45\xd4\x01\x00\x00\x00\x83\xfe\xff\x75\x0c\xff\x75\xd8\xe8\xf1\xb5\xff\xff\x8b\xf0\x59\x46\x3b\xf7\x7e\x5b\x81\xfe\xf0\xff\xff\x7f\x77\x53\x8d\x44\x36\x08\x3d\x00\x04\x00\x00\x77\x2f\xe8\x11\x01\x00\x00\x8b\xc4\x3b\xc7\x74\x38\xc7\x00\xcc\xcc\x00\x00\xeb\x2d\x57\x57\xff\x75\xdc\xff\x75\xd8\x6a\x01\xff\x75\x08\xff\xd3\x8b\xf0\x3b\xf7\x75\xc3\x33\xc0\xe9\xd1\x00\x00\x00\x50\xe8\xd1\xc6\xff\xff\x59\x3b\xc7\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x89\x45\xe4\xeb\x03\x89\x7d\xe4\x39\x7d\xe4\x74\xd8\x8d\x04\x36\x50\x57\xff\x75\xe4\xe8\x79\xb8\xff\xff\x83\xc4\x0c\x56\xff\x75\xe4\xff\x75\xdc\xff\x75\xd8\x6a\x01\xff\x75\x08\xff\xd3\x85\xc0\x74\x7f\x8b\x5d\xcc\x3b\xdf\x74\x1d\x57\x57\xff\x75\x1c\x53\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\x15\xbc\xb0\x00\x10\x85\xc0\x74\x60\x89\x5d\xe0\xeb\x5b\x8b\x1d\xbc\xb0\x00\x10\x39\x7d\xd4\x75\x14\x57\x57\x57\x57\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\xd3\x8b\xf0\x3b\xf7\x74\x3c\x56\x6a\x01\xe8\x40\x97\xff\xff\x59\x59\x89\x45\xe0\x3b\xc7\x74\x2b\x57\x57\x56\x50\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\xd3\x3b\xc7\x75\x0e\xff\x75\xe0\xe8\x4a\x96\xff\xff\x59\x89\x7d\xe0\xeb\x0b\x83\x7d\xdc\xff\x74\x05\x8b\x4d\xd0\x89\x01\xff\x75\xe4\xe8\x72\xde\xff\xff\x59\x8b\x45\xe0\x8d\x65\xc0\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xf4\x77\xff\xff\xc9\xc3\xcc\xcc\xcc\xcc\x51\x8d\x4c\x24\x08\x2b\xc8\x83\xe1\x0f\x03\xc1\x1b\xc9\x0b\xc1\x59\xe9\xfa\xfb\xff\xff\x51\x8d\x4c\x24\x08\x2b\xc8\x83\xe1\x07\x03\xc1\x1b\xc9\x0b\xc1\x59\xe9\xe4\xfb\xff\xff\x8b\xff\x55\x8b\xec\x6a\x0a\x6a\x00\xff\x75\x08\xe8\xd1\xef\xff\xff\x83\xc4\x0c\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x18\x53\xff\x75\x10\x8d\x4d\xe8\xe8\x18\x7f\xff\xff\x8b\x5d\x08\x8d\x43\x01\x3d\x00\x01\x00\x00\x77\x0f\x8b\x45\xe8\x8b\x80\xc8\x00\x00\x00\x0f\xb7\x04\x58\xeb\x75\x89\x5d\x08\xc1\x7d\x08\x08\x8d\x45\xe8\x50\x8b\x45\x08\x25\xff\x00\x00\x00\x50\xe8\x49\xb6\xff\xff\x59\x59\x85\xc0\x74\x12\x8a\x45\x08\x6a\x02\x88\x45\xf8\x88\x5d\xf9\xc6\x45\xfa\x00\x59\xeb\x0a\x33\xc9\x88\x5d\xf8\xc6\x45\xf9\x00\x41\x8b\x45\xe8\x6a\x01\xff\x70\x14\xff\x70\x04\x8d\x45\xfc\x50\x51\x8d\x45\xf8\x50\x8d\x45\xe8\x6a\x01\x50\xe8\x50\xe3\xff\xff\x83\xc4\x20\x85\xc0\x75\x10\x38\x45\xf4\x74\x07\x8b\x45\xf0\x83\x60\x70\xfd\x33\xc0\xeb\x14\x0f\xb7\x45\xfc\x23\x45\x0c\x80\x7d\xf4\x00\x74\x07\x8b\x4d\xf0\x83\x61\x70\xfd\x5b\xc9\xc3\x33\xc0\x50\x50\x6a\x03\x50\x6a\x03\x68\x00\x00\x00\x40\x68\xdc\xc3\x00\x10\xff\x15\x0c\xb0\x00\x10\xa3\x74\xee\x00\x10\xc3\xa1\x74\xee\x00\x10\x56\x8b\x35\x20\xb0\x00\x10\x83\xf8\xff\x74\x08\x83\xf8\xfe\x74\x03\x50\xff\xd6\xa1\x70\xee\x00\x10\x83\xf8\xff\x74\x08\x83\xf8\xfe\x74\x03\x50\xff\xd6\x5e\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x53\x8b\x4d\x10\x0b\xc9\x74\x4d\x8b\x75\x08\x8b\x7d\x0c\xb7\x41\xb3\x5a\xb6\x20\x8d\x49\x00\x8a\x26\x0a\xe4\x8a\x07\x74\x27\x0a\xc0\x74\x23\x83\xc6\x01\x83\xc7\x01\x3a\xe7\x72\x06\x3a\xe3\x77\x02\x02\xe6\x3a\xc7\x72\x06\x3a\xc3\x77\x02\x02\xc6\x3a\xe0\x75\x0b\x83\xe9\x01\x75\xd1\x33\xc9\x3a\xe0\x74\x09\xb9\xff\xff\xff\xff\x72\x02\xf7\xd9\x8b\xc1\x5b\x5e\x5f\xc9\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x44\x24\x08\x8b\x4c\x24\x10\x0b\xc8\x8b\x4c\x24\x0c\x75\x09\x8b\x44\x24\x04\xf7\xe1\xc2\x10\x00\x53\xf7\xe1\x8b\xd8\x8b\x44\x24\x08\xf7\x64\x24\x14\x03\xd8\x8b\x44\x24\x08\xf7\xe1\x03\xd3\x5b\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8d\x42\xff\x5b\xc3\x8d\xa4\x24\x00\x00\x00\x00\x8d\x64\x24\x00\x33\xc0\x8a\x44\x24\x08\x53\x8b\xd8\xc1\xe0\x08\x8b\x54\x24\x08\xf7\xc2\x03\x00\x00\x00\x74\x15\x8a\x0a\x83\xc2\x01\x3a\xcb\x74\xcf\x84\xc9\x74\x51\xf7\xc2\x03\x00\x00\x00\x75\xeb\x0b\xd8\x57\x8b\xc3\xc1\xe3\x10\x56\x0b\xd8\x8b\x0a\xbf\xff\xfe\xfe\x7e\x8b\xc1\x8b\xf7\x33\xcb\x03\xf0\x03\xf9\x83\xf1\xff\x83\xf0\xff\x33\xcf\x33\xc6\x83\xc2\x04\x81\xe1\x00\x01\x01\x81\x75\x1c\x25\x00\x01\x01\x81\x74\xd3\x25\x00\x01\x01\x01\x75\x08\x81\xe6\x00\x00\x00\x80\x75\xc4\x5e\x5f\x5b\x33\xc0\xc3\x8b\x42\xfc\x3a\xc3\x74\x36\x84\xc0\x74\xef\x3a\xe3\x74\x27\x84\xe4\x74\xe7\xc1\xe8\x10\x3a\xc3\x74\x15\x84\xc0\x74\xdc\x3a\xe3\x74\x06\x84\xe4\x74\xd4\xeb\x96\x5e\x5f\x8d\x42\xff\x5b\xc3\x8d\x42\xfe\x5e\x5f\x5b\xc3\x8d\x42\xfd\x5e\x5f\x5b\xc3\x8d\x42\xfc\x5e\x5f\x5b\xc3\xff\x25\xf0\xb0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xca\x00\x00\xec\xca\x00\x00\xfe\xca\x00\x00\x5e\xd1\x00\x00\x4e\xd1\x00\x00\x3e\xd1\x00\x00\x28\xd1\x00\x00\x18\xd1\x00\x00\x0a\xd1\x00\x00\xfe\xd0\x00\x00\xec\xd0\x00\x00\xda\xd0\x00\x00\xc8\xd0\x00\x00\xb6\xd0\x00\x00\xa6\xd0\x00\x00\x90\xd0\x00\x00\x80\xd0\x00\x00\x6c\xd0\x00\x00\xb8\xcc\x00\x00\xce\xcc\x00\x00\xe0\xcc\x00\x00\xf4\xcc\x00\x00\x08\xcd\x00\x00\x24\xcd\x00\x00\x42\xcd\x00\x00\x56\xcd\x00\x00\x6e\xcd\x00\x00\x86\xcd\x00\x00\x98\xcd\x00\x00\xa6\xcd\x00\x00\xb2\xcd\x00\x00\xc0\xcd\x00\x00\xca\xcd\x00\x00\xe2\xcd\x00\x00\xf2\xcd\x00\x00\x0a\xce\x00\x00\x16\xce\x00\x00\x1e\xce\x00\x00\x2c\xce\x00\x00\x3e\xce\x00\x00\x4e\xce\x00\x00\x5c\xce\x00\x00\x6e\xce\x00\x00\x86\xce\x00\x00\x9c\xce\x00\x00\xb6\xce\x00\x00\xce\xce\x00\x00\xe8\xce\x00\x00\xfe\xce\x00\x00\x18\xcf\x00\x00\x26\xcf\x00\x00\x34\xcf\x00\x00\x42\xcf\x00\x00\x5c\xcf\x00\x00\x6c\xcf\x00\x00\x82\xcf\x00\x00\x9c\xcf\x00\x00\xa8\xcf\x00\x00\xb2\xcf\x00\x00\xbe\xcf\x00\x00\xd0\xcf\x00\x00\xdc\xcf\x00\x00\xe8\xcf\x00\x00\xf8\xcf\x00\x00\x06\xd0\x00\x00\x12\xd0\x00\x00\x22\xd0\x00\x00\x4a\xd0\x00\x00\x5a\xd0\x00\x00\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00\x00\x00\x7a\xcc\x00\x00\x66\xcc\x00\x00\x52\xcc\x00\x00\x44\xcc\x00\x00\x30\xcc\x00\x00\x1c\xcc\x00\x00\x0e\xcc\x00\x00\x00\xcc\x00\x00\xee\xcb\x00\x00\xd0\xcb\x00\x00\xbe\xcb\x00\x00\xaa\xcb\x00\x00\x9c\xcb\x00\x00\x90\xcb\x00\x00\x7e\xcb\x00\x00\x6c\xcb\x00\x00\x58\xcb\x00\x00\x46\xcb\x00\x00\x30\xcb\x00\x00\x20\xcb\x00\x00\xde\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x1a\x00\x10\x7f\x4d\x00\x10\x21\x6a\x00\x10\x28\x8a\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x9e\x00\x10\x30\x1b\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x78\xee\x54\x00\x00\x00\x00\x02\x00\x00\x00\x8e\x00\x00\x00\xa8\xc4\x00\x00\xa8\xaa\x00\x00\x00\x00\x00\x00\xf8\xee\x00\x10\x50\xef\x00\x10\x28\x00\x6e\x00\x75\x00\x6c\x00\x6c\x00\x29\x00\x00\x00\x00\x00\x28\x6e\x75\x6c\x6c\x29\x00\x00\x06\x00\x00\x06\x00\x01\x00\x00\x10\x00\x03\x06\x00\x06\x02\x10\x04\x45\x45\x45\x05\x05\x05\x05\x05\x35\x30\x00\x50\x00\x00\x00\x00\x28\x20\x38\x50\x58\x07\x08\x00\x37\x30\x30\x57\x50\x07\x00\x00\x20\x20\x08\x00\x00\x00\x00\x08\x60\x68\x60\x60\x60\x60\x00\x00\x78\x70\x78\x78\x78\x78\x08\x07\x08\x00\x00\x07\x00\x08\x08\x08\x00\x00\x08\x00\x08\x00\x07\x08\x00\x00\x00\x45\x6e\x63\x6f\x64\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\x00\x4b\x00\x45\x00\x52\x00\x4e\x00\x45\x00\x4c\x00\x33\x00\x32\x00\x2e\x00\x44\x00\x4c\x00\x4c\x00\x00\x00\x00\x00\x44\x65\x63\x6f\x64\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\x00\x46\x6c\x73\x46\x72\x65\x65\x00\x46\x6c\x73\x53\x65\x74\x56\x61\x6c\x75\x65\x00\x46\x6c\x73\x47\x65\x74\x56\x61\x6c\x75\x65\x00\x46\x6c\x73\x41\x6c\x6c\x6f\x63\x00\x00\x00\x00\x43\x6f\x72\x45\x78\x69\x74\x50\x72\x6f\x63\x65\x73\x73\x00\x00\x6d\x00\x73\x00\x63\x00\x6f\x00\x72\x00\x65\x00\x65\x00\x2e\x00\x64\x00\x6c\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\xc0\x0b\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\xc0\x04\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\xc0\x04\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x00\x06\x80\x80\x86\x80\x81\x80\x00\x00\x10\x03\x86\x80\x86\x82\x80\x14\x05\x05\x45\x45\x45\x85\x85\x85\x05\x00\x00\x30\x30\x80\x50\x80\x88\x00\x08\x00\x28\x27\x38\x50\x57\x80\x00\x07\x00\x37\x30\x30\x50\x50\x88\x00\x00\x00\x20\x28\x80\x88\x80\x80\x00\x00\x00\x60\x68\x60\x68\x68\x68\x08\x08\x07\x78\x70\x70\x77\x70\x70\x08\x08\x00\x00\x08\x00\x08\x00\x07\x08\x00\x00\x00\x72\x75\x6e\x74\x69\x6d\x65\x20\x65\x72\x72\x6f\x72\x20\x00\x00\x0d\x0a\x00\x00\x54\x4c\x4f\x53\x53\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x53\x49\x4e\x47\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x44\x4f\x4d\x41\x49\x4e\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x52\x36\x30\x33\x34\x0d\x0a\x41\x6e\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x20\x68\x61\x73\x20\x6d\x61\x64\x65\x20\x61\x6e\x20\x61\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x6c\x6f\x61\x64\x20\x74\x68\x65\x20\x43\x20\x72\x75\x6e\x74\x69\x6d\x65\x20\x6c\x69\x62\x72\x61\x72\x79\x20\x69\x6e\x63\x6f\x72\x72\x65\x63\x74\x6c\x79\x2e\x0a\x50\x6c\x65\x61\x73\x65\x20\x63\x6f\x6e\x74\x61\x63\x74\x20\x74\x68\x65\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x27\x73\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x74\x65\x61\x6d\x20\x66\x6f\x72\x20\x6d\x6f\x72\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x00\x00\x00\x00\x52\x36\x30\x33\x33\x0d\x0a\x2d\x20\x41\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x75\x73\x65\x20\x4d\x53\x49\x4c\x20\x63\x6f\x64\x65\x20\x66\x72\x6f\x6d\x20\x74\x68\x69\x73\x20\x61\x73\x73\x65\x6d\x62\x6c\x79\x20\x64\x75\x72\x69\x6e\x67\x20\x6e\x61\x74\x69\x76\x65\x20\x63\x6f\x64\x65\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0a\x54\x68\x69\x73\x20\x69\x6e\x64\x69\x63\x61\x74\x65\x73\x20\x61\x20\x62\x75\x67\x20\x69\x6e\x20\x79\x6f\x75\x72\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x2e\x20\x49\x74\x20\x69\x73\x20\x6d\x6f\x73\x74\x20\x6c\x69\x6b\x65\x6c\x79\x20\x74\x68\x65\x20\x72\x65\x73\x75\x6c\x74\x20\x6f\x66\x20\x63\x61\x6c\x6c\x69\x6e\x67\x20\x61\x6e\x20\x4d\x53\x49\x4c\x2d\x63\x6f\x6d\x70\x69\x6c\x65\x64\x20\x28\x2f\x63\x6c\x72\x29\x20\x66\x75\x6e\x63\x74\x69\x6f\x6e\x20\x66\x72\x6f\x6d\x20\x61\x20\x6e\x61\x74\x69\x76\x65\x20\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72\x20\x6f\x72\x20\x66\x72\x6f\x6d\x20\x44\x6c\x6c\x4d\x61\x69\x6e\x2e\x0d\x0a\x00\x00\x52\x36\x30\x33\x32\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x6c\x6f\x63\x61\x6c\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x00\x00\x52\x36\x30\x33\x31\x0d\x0a\x2d\x20\x41\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x20\x74\x68\x65\x20\x43\x52\x54\x20\x6d\x6f\x72\x65\x20\x74\x68\x61\x6e\x20\x6f\x6e\x63\x65\x2e\x0a\x54\x68\x69\x73\x20\x69\x6e\x64\x69\x63\x61\x74\x65\x73\x20\x61\x20\x62\x75\x67\x20\x69\x6e\x20\x79\x6f\x75\x72\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x52\x36\x30\x33\x30\x0d\x0a\x2d\x20\x43\x52\x54\x20\x6e\x6f\x74\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x64\x0d\x0a\x00\x00\x52\x36\x30\x32\x38\x0d\x0a\x2d\x20\x75\x6e\x61\x62\x6c\x65\x20\x74\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x20\x68\x65\x61\x70\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x37\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x6c\x6f\x77\x69\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x36\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x73\x74\x64\x69\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x35\x0d\x0a\x2d\x20\x70\x75\x72\x65\x20\x76\x69\x72\x74\x75\x61\x6c\x20\x66\x75\x6e\x63\x74\x69\x6f\x6e\x20\x63\x61\x6c\x6c\x0d\x0a\x00\x00\x00\x52\x36\x30\x32\x34\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x5f\x6f\x6e\x65\x78\x69\x74\x2f\x61\x74\x65\x78\x69\x74\x20\x74\x61\x62\x6c\x65\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x39\x0d\x0a\x2d\x20\x75\x6e\x61\x62\x6c\x65\x20\x74\x6f\x20\x6f\x70\x65\x6e\x20\x63\x6f\x6e\x73\x6f\x6c\x65\x20\x64\x65\x76\x69\x63\x65\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x38\x0d\x0a\x2d\x20\x75\x6e\x65\x78\x70\x65\x63\x74\x65\x64\x20\x68\x65\x61\x70\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x37\x0d\x0a\x2d\x20\x75\x6e\x65\x78\x70\x65\x63\x74\x65\x64\x20\x6d\x75\x6c\x74\x69\x74\x68\x72\x65\x61\x64\x20\x6c\x6f\x63\x6b\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x36\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x74\x68\x72\x65\x61\x64\x20\x64\x61\x74\x61\x0d\x0a\x00\x0d\x0a\x54\x68\x69\x73\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x20\x68\x61\x73\x20\x72\x65\x71\x75\x65\x73\x74\x65\x64\x20\x74\x68\x65\x20\x52\x75\x6e\x74\x69\x6d\x65\x20\x74\x6f\x20\x74\x65\x72\x6d\x69\x6e\x61\x74\x65\x20\x69\x74\x20\x69\x6e\x20\x61\x6e\x20\x75\x6e\x75\x73\x75\x61\x6c\x20\x77\x61\x79\x2e\x0a\x50\x6c\x65\x61\x73\x65\x20\x63\x6f\x6e\x74\x61\x63\x74\x20\x74\x68\x65\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x27\x73\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x74\x65\x61\x6d\x20\x66\x6f\x72\x20\x6d\x6f\x72\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x00\x52\x36\x30\x30\x39\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x65\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x0d\x0a\x00\x52\x36\x30\x30\x38\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x61\x72\x67\x75\x6d\x65\x6e\x74\x73\x0d\x0a\x00\x00\x00\x52\x36\x30\x30\x32\x0d\x0a\x2d\x20\x66\x6c\x6f\x61\x74\x69\x6e\x67\x20\x70\x6f\x69\x6e\x74\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x6e\x6f\x74\x20\x6c\x6f\x61\x64\x65\x64\x0d\x0a\x00\x00\x00\x00\x4d\x69\x63\x72\x6f\x73\x6f\x66\x74\x20\x56\x69\x73\x75\x61\x6c\x20\x43\x2b\x2b\x20\x52\x75\x6e\x74\x69\x6d\x65\x20\x4c\x69\x62\x72\x61\x72\x79\x00\x00\x00\x00\x0a\x0a\x00\x00\x2e\x2e\x2e\x00\x3c\x70\x72\x6f\x67\x72\x61\x6d\x20\x6e\x61\x6d\x65\x20\x75\x6e\x6b\x6e\x6f\x77\x6e\x3e\x00\x00\x52\x75\x6e\x74\x69\x6d\x65\x20\x45\x72\x72\x6f\x72\x21\x0a\x0a\x50\x72\x6f\x67\x72\x61\x6d\x3a\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x10\x00\x10\x00\x10\x00\x10\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x68\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x82\x01\x82\x01\x82\x01\x82\x01\x82\x01\x82\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x10\x00\x10\x00\x10\x00\x10\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x14\x00\x14\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x14\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x10\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x01\x01\x00\x00\x00\x00\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x48\x48\x3a\x6d\x6d\x3a\x73\x73\x00\x00\x00\x00\x64\x64\x64\x64\x2c\x20\x4d\x4d\x4d\x4d\x20\x64\x64\x2c\x20\x79\x79\x79\x79\x00\x4d\x4d\x2f\x64\x64\x2f\x79\x79\x00\x00\x00\x00\x50\x4d\x00\x00\x41\x4d\x00\x00\x44\x65\x63\x65\x6d\x62\x65\x72\x00\x00\x00\x00\x4e\x6f\x76\x65\x6d\x62\x65\x72\x00\x00\x00\x00\x4f\x63\x74\x6f\x62\x65\x72\x00\x53\x65\x70\x74\x65\x6d\x62\x65\x72\x00\x00\x00\x41\x75\x67\x75\x73\x74\x00\x00\x4a\x75\x6c\x79\x00\x00\x00\x00\x4a\x75\x6e\x65\x00\x00\x00\x00\x41\x70\x72\x69\x6c\x00\x00\x00\x4d\x61\x72\x63\x68\x00\x00\x00\x46\x65\x62\x72\x75\x61\x72\x79\x00\x00\x00\x00\x4a\x61\x6e\x75\x61\x72\x79\x00\x44\x65\x63\x00\x4e\x6f\x76\x00\x4f\x63\x74\x00\x53\x65\x70\x00\x41\x75\x67\x00\x4a\x75\x6c\x00\x4a\x75\x6e\x00\x4d\x61\x79\x00\x41\x70\x72\x00\x4d\x61\x72\x00\x46\x65\x62\x00\x4a\x61\x6e\x00\x53\x61\x74\x75\x72\x64\x61\x79\x00\x00\x00\x00\x46\x72\x69\x64\x61\x79\x00\x00\x54\x68\x75\x72\x73\x64\x61\x79\x00\x00\x00\x00\x57\x65\x64\x6e\x65\x73\x64\x61\x79\x00\x00\x00\x54\x75\x65\x73\x64\x61\x79\x00\x4d\x6f\x6e\x64\x61\x79\x00\x00\x53\x75\x6e\x64\x61\x79\x00\x00\x53\x61\x74\x00\x46\x72\x69\x00\x54\x68\x75\x00\x57\x65\x64\x00\x54\x75\x65\x00\x4d\x6f\x6e\x00\x53\x75\x6e\x00\x47\x65\x74\x50\x72\x6f\x63\x65\x73\x73\x57\x69\x6e\x64\x6f\x77\x53\x74\x61\x74\x69\x6f\x6e\x00\x47\x65\x74\x55\x73\x65\x72\x4f\x62\x6a\x65\x63\x74\x49\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x41\x00\x00\x00\x47\x65\x74\x4c\x61\x73\x74\x41\x63\x74\x69\x76\x65\x50\x6f\x70\x75\x70\x00\x00\x47\x65\x74\x41\x63\x74\x69\x76\x65\x57\x69\x6e\x64\x6f\x77\x00\x4d\x65\x73\x73\x61\x67\x65\x42\x6f\x78\x41\x00\x55\x53\x45\x52\x33\x32\x2e\x44\x4c\x4c\x00\x00\x53\x75\x6e\x4d\x6f\x6e\x54\x75\x65\x57\x65\x64\x54\x68\x75\x46\x72\x69\x53\x61\x74\x00\x00\x00\x4a\x61\x6e\x46\x65\x62\x4d\x61\x72\x41\x70\x72\x4d\x61\x79\x4a\x75\x6e\x4a\x75\x6c\x41\x75\x67\x53\x65\x70\x4f\x63\x74\x4e\x6f\x76\x44\x65\x63\x00\x00\x00\x00\x43\x4f\x4e\x4f\x55\x54\x24\x00\x53\x79\x73\x74\x72\x61\x79\x20\x65\x72\x72\x6f\x72\x20\x25\x73\x3a\x20\x25\x64\x20\x25\x73\x0a\x00\x00\x00\x00\x67\x65\x74\x20\x74\x72\x61\x79\x20\x6d\x65\x6e\x75\x20\x70\x6f\x73\x69\x74\x69\x6f\x6e\x00\x00\x67\x65\x74\x20\x6d\x65\x6e\x75\x20\x69\x74\x65\x6d\x20\x69\x64\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x79\x00\x73\x00\x74\x00\x72\x00\x61\x00\x79\x00\x43\x00\x6c\x00\x61\x00\x73\x00\x73\x00\x00\x00\x00\x00\x6c\x6f\x61\x64\x20\x69\x63\x6f\x6e\x20\x69\x6d\x61\x67\x65\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x10\x40\xc5\x00\x10\x03\x00\x00\x00\x52\x53\x44\x53\xc0\xc4\x5d\xda\x8c\xd7\xbd\x49\x91\x72\x7a\x0f\xa2\xd6\x7e\x76\x01\x00\x00\x00\x5c\x5c\x56\x42\x4f\x58\x53\x56\x52\x5c\x76\x61\x67\x72\x61\x6e\x74\x5c\x77\x6f\x72\x6b\x73\x70\x61\x63\x65\x5c\x67\x65\x74\x6c\x61\x6e\x74\x65\x72\x6e\x5c\x66\x6c\x61\x73\x68\x6c\x69\x67\x68\x74\x2d\x62\x75\x69\x6c\x64\x5c\x73\x72\x63\x5c\x67\x69\x74\x68\x75\x62\x2e\x63\x6f\x6d\x5c\x67\x65\x74\x6c\x61\x6e\x74\x65\x72\x6e\x5c\x73\x79\x73\x74\x72\x61\x79\x5c\x73\x79\x73\x74\x72\x61\x79\x5c\x52\x65\x6c\x65\x61\x73\x65\x5c\x73\x79\x73\x74\x72\x61\x79\x2e\x70\x64\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x2c\x00\x00\x5c\x56\x00\x00\x58\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x29\x16\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x2d\x19\x00\x10\x3e\x19\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd2\x2f\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xe1\x2f\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x94\x31\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xa0\x31\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xfd\x33\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x9c\x37\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x8c\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x64\x3a\x00\x10\x68\x3a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd9\x42\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x63\x44\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x44\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xe8\x45\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x78\x49\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x46\x4d\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xb6\x50\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x3b\x58\x00\x10\x4f\x58\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x77\x63\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x41\x65\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xa6\x66\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x88\x6a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\xc5\x6a\x00\x10\xc9\x6a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xbf\x6c\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x4f\x6d\x00\x10\x66\x6d\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xed\x72\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xfd\x7a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xde\x7b\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x34\x88\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x93\x89\x00\x10\xaf\x89\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc7\x91\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x6c\x97\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x5a\x9b\x00\x10\x64\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\xcb\x00\x00\x00\xb0\x00\x00\x84\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xcc\x00\x00\x20\xb1\x00\x00\x7c\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xcc\x00\x00\x18\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xca\x00\x00\xec\xca\x00\x00\xfe\xca\x00\x00\x5e\xd1\x00\x00\x4e\xd1\x00\x00\x3e\xd1\x00\x00\x28\xd1\x00\x00\x18\xd1\x00\x00\x0a\xd1\x00\x00\xfe\xd0\x00\x00\xec\xd0\x00\x00\xda\xd0\x00\x00\xc8\xd0\x00\x00\xb6\xd0\x00\x00\xa6\xd0\x00\x00\x90\xd0\x00\x00\x80\xd0\x00\x00\x6c\xd0\x00\x00\xb8\xcc\x00\x00\xce\xcc\x00\x00\xe0\xcc\x00\x00\xf4\xcc\x00\x00\x08\xcd\x00\x00\x24\xcd\x00\x00\x42\xcd\x00\x00\x56\xcd\x00\x00\x6e\xcd\x00\x00\x86\xcd\x00\x00\x98\xcd\x00\x00\xa6\xcd\x00\x00\xb2\xcd\x00\x00\xc0\xcd\x00\x00\xca\xcd\x00\x00\xe2\xcd\x00\x00\xf2\xcd\x00\x00\x0a\xce\x00\x00\x16\xce\x00\x00\x1e\xce\x00\x00\x2c\xce\x00\x00\x3e\xce\x00\x00\x4e\xce\x00\x00\x5c\xce\x00\x00\x6e\xce\x00\x00\x86\xce\x00\x00\x9c\xce\x00\x00\xb6\xce\x00\x00\xce\xce\x00\x00\xe8\xce\x00\x00\xfe\xce\x00\x00\x18\xcf\x00\x00\x26\xcf\x00\x00\x34\xcf\x00\x00\x42\xcf\x00\x00\x5c\xcf\x00\x00\x6c\xcf\x00\x00\x82\xcf\x00\x00\x9c\xcf\x00\x00\xa8\xcf\x00\x00\xb2\xcf\x00\x00\xbe\xcf\x00\x00\xd0\xcf\x00\x00\xdc\xcf\x00\x00\xe8\xcf\x00\x00\xf8\xcf\x00\x00\x06\xd0\x00\x00\x12\xd0\x00\x00\x22\xd0\x00\x00\x4a\xd0\x00\x00\x5a\xd0\x00\x00\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00\x00\x00\x7a\xcc\x00\x00\x66\xcc\x00\x00\x52\xcc\x00\x00\x44\xcc\x00\x00\x30\xcc\x00\x00\x1c\xcc\x00\x00\x0e\xcc\x00\x00\x00\xcc\x00\x00\xee\xcb\x00\x00\xd0\xcb\x00\x00\xbe\xcb\x00\x00\xaa\xcb\x00\x00\x9c\xcb\x00\x00\x90\xcb\x00\x00\x7e\xcb\x00\x00\x6c\xcb\x00\x00\x58\xcb\x00\x00\x46\xcb\x00\x00\x30\xcb\x00\x00\x20\xcb\x00\x00\xde\xcb\x00\x00\x00\x00\x00\x00\xe6\x01\x47\x65\x74\x4c\x61\x73\x74\x45\x72\x72\x6f\x72\x00\x00\x48\x01\x46\x6f\x72\x6d\x61\x74\x4d\x65\x73\x73\x61\x67\x65\x57\x00\x00\xf9\x01\x47\x65\x74\x4d\x6f\x64\x75\x6c\x65\x48\x61\x6e\x64\x6c\x65\x57\x00\x00\x4b\x45\x52\x4e\x45\x4c\x33\x32\x2e\x64\x6c\x6c\x00\x00\x19\x01\x47\x65\x74\x43\x75\x72\x73\x6f\x72\x50\x6f\x73\x00\x00\x7a\x02\x53\x65\x74\x46\x6f\x72\x65\x67\x72\x6f\x75\x6e\x64\x57\x69\x6e\x64\x6f\x77\x00\xcf\x02\x54\x72\x61\x63\x6b\x50\x6f\x70\x75\x70\x4d\x65\x6e\x75\x00\x00\x45\x01\x47\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x49\x6e\x66\x6f\x57\x00\x00\x20\x02\x50\x6f\x73\x74\x51\x75\x69\x74\x4d\x65\x73\x73\x61\x67\x65\x00\x96\x00\x44\x65\x66\x57\x69\x6e\x64\x6f\x77\x50\x72\x6f\x63\x57\x00\x00\xd7\x01\x4c\x6f\x61\x64\x49\x63\x6f\x6e\x57\x00\xd5\x01\x4c\x6f\x61\x64\x43\x75\x72\x73\x6f\x72\x57\x00\x35\x02\x52\x65\x67\x69\x73\x74\x65\x72\x43\x6c\x61\x73\x73\x45\x78\x57\x00\x00\x68\x00\x43\x72\x65\x61\x74\x65\x57\x69\x6e\x64\x6f\x77\x45\x78\x57\x00\xb8\x02\x53\x68\x6f\x77\x57\x69\x6e\x64\x6f\x77\x00\x00\xe9\x02\x55\x70\x64\x61\x74\x65\x57\x69\x6e\x64\x6f\x77\x00\x00\x65\x00\x43\x72\x65\x61\x74\x65\x50\x6f\x70\x75\x70\x4d\x65\x6e\x75\x00\x82\x02\x53\x65\x74\x4d\x65\x6e\x75\x49\x6e\x66\x6f\x00\x4e\x01\x47\x65\x74\x4d\x65\x73\x73\x61\x67\x65\x57\x00\xd5\x02\x54\x72\x61\x6e\x73\x6c\x61\x74\x65\x4d\x65\x73\x73\x61\x67\x65\x00\x00\xa9\x00\x44\x69\x73\x70\x61\x74\x63\x68\x4d\x65\x73\x73\x61\x67\x65\x57\x00\x00\xd9\x01\x4c\x6f\x61\x64\x49\x6d\x61\x67\x65\x57\x00\x00\x42\x01\x47\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x43\x6f\x75\x6e\x74\x00\x00\x85\x02\x53\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x49\x6e\x66\x6f\x57\x00\x00\xa5\x01\x49\x6e\x73\x65\x72\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x57\x00\x55\x53\x45\x52\x33\x32\x2e\x64\x6c\x6c\x00\x00\x23\x01\x53\x68\x65\x6c\x6c\x5f\x4e\x6f\x74\x69\x66\x79\x49\x63\x6f\x6e\x57\x00\x53\x48\x45\x4c\x4c\x33\x32\x2e\x64\x6c\x6c\x00\xad\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x54\x68\x72\x65\x61\x64\x49\x64\x00\x00\x6f\x01\x47\x65\x74\x43\x6f\x6d\x6d\x61\x6e\x64\x4c\x69\x6e\x65\x41\x00\x2d\x04\x54\x65\x72\x6d\x69\x6e\x61\x74\x65\x50\x72\x6f\x63\x65\x73\x73\x00\x00\xa9\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x50\x72\x6f\x63\x65\x73\x73\x00\x3e\x04\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x45\x78\x63\x65\x70\x74\x69\x6f\x6e\x46\x69\x6c\x74\x65\x72\x00\x00\x15\x04\x53\x65\x74\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x45\x78\x63\x65\x70\x74\x69\x6f\x6e\x46\x69\x6c\x74\x65\x72\x00\xd1\x02\x49\x73\x44\x65\x62\x75\x67\x67\x65\x72\x50\x72\x65\x73\x65\x6e\x74\x00\xd9\x00\x45\x6e\x74\x65\x72\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\x00\xef\x02\x4c\x65\x61\x76\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\x00\x20\x02\x47\x65\x74\x50\x72\x6f\x63\x41\x64\x64\x72\x65\x73\x73\x00\x00\x34\x04\x54\x6c\x73\x47\x65\x74\x56\x61\x6c\x75\x65\x00\x32\x04\x54\x6c\x73\x41\x6c\x6c\x6f\x63\x00\x00\x35\x04\x54\x6c\x73\x53\x65\x74\x56\x61\x6c\x75\x65\x00\x33\x04\x54\x6c\x73\x46\x72\x65\x65\x00\xc0\x02\x49\x6e\x74\x65\x72\x6c\x6f\x63\x6b\x65\x64\x49\x6e\x63\x72\x65\x6d\x65\x6e\x74\x00\x00\xec\x03\x53\x65\x74\x4c\x61\x73\x74\x45\x72\x72\x6f\x72\x00\x00\xbc\x02\x49\x6e\x74\x65\x72\x6c\x6f\x63\x6b\x65\x64\x44\x65\x63\x72\x65\x6d\x65\x6e\x74\x00\x00\xa1\x02\x48\x65\x61\x70\x46\x72\x65\x65\x00\x00\x21\x04\x53\x6c\x65\x65\x70\x00\x04\x01\x45\x78\x69\x74\x50\x72\x6f\x63\x65\x73\x73\x00\xe8\x03\x53\x65\x74\x48\x61\x6e\x64\x6c\x65\x43\x6f\x75\x6e\x74\x00\x00\x3b\x02\x47\x65\x74\x53\x74\x64\x48\x61\x6e\x64\x6c\x65\x00\x00\xd7\x01\x47\x65\x74\x46\x69\x6c\x65\x54\x79\x70\x65\x00\x39\x02\x47\x65\x74\x53\x74\x61\x72\x74\x75\x70\x49\x6e\x66\x6f\x41\x00\xbe\x00\x44\x65\x6c\x65\x74\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\xf4\x01\x47\x65\x74\x4d\x6f\x64\x75\x6c\x65\x46\x69\x6c\x65\x4e\x61\x6d\x65\x41\x00\x00\x4a\x01\x46\x72\x65\x65\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x41\x00\xbf\x01\x47\x65\x74\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x00\x4b\x01\x46\x72\x65\x65\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x57\x00\x7a\x04\x57\x69\x64\x65\x43\x68\x61\x72\x54\x6f\x4d\x75\x6c\x74\x69\x42\x79\x74\x65\x00\xc1\x01\x47\x65\x74\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x57\x00\x00\x9f\x02\x48\x65\x61\x70\x43\x72\x65\x61\x74\x65\x00\x00\xa0\x02\x48\x65\x61\x70\x44\x65\x73\x74\x72\x6f\x79\x00\x57\x04\x56\x69\x72\x74\x75\x61\x6c\x46\x72\x65\x65\x00\x54\x03\x51\x75\x65\x72\x79\x50\x65\x72\x66\x6f\x72\x6d\x61\x6e\x63\x65\x43\x6f\x75\x6e\x74\x65\x72\x00\x66\x02\x47\x65\x74\x54\x69\x63\x6b\x43\x6f\x75\x6e\x74\x00\x00\xaa\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x50\x72\x6f\x63\x65\x73\x73\x49\x64\x00\x4f\x02\x47\x65\x74\x53\x79\x73\x74\x65\x6d\x54\x69\x6d\x65\x41\x73\x46\x69\x6c\x65\x54\x69\x6d\x65\x00\x5b\x01\x47\x65\x74\x43\x50\x49\x6e\x66\x6f\x00\x52\x01\x47\x65\x74\x41\x43\x50\x00\x00\x13\x02\x47\x65\x74\x4f\x45\x4d\x43\x50\x00\x00\xdb\x02\x49\x73\x56\x61\x6c\x69\x64\x43\x6f\x64\x65\x50\x61\x67\x65\x00\x92\x03\x52\x74\x6c\x55\x6e\x77\x69\x6e\x64\x00\x9d\x02\x48\x65\x61\x70\x41\x6c\x6c\x6f\x63\x00\x54\x04\x56\x69\x72\x74\x75\x61\x6c\x41\x6c\x6c\x6f\x63\x00\x00\xa4\x02\x48\x65\x61\x70\x52\x65\x41\x6c\x6c\x6f\x63\x00\x8d\x04\x57\x72\x69\x74\x65\x46\x69\x6c\x65\x00\xf1\x02\x4c\x6f\x61\x64\x4c\x69\x62\x72\x61\x72\x79\x41\x00\x00\xb5\x02\x49\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x41\x6e\x64\x53\x70\x69\x6e\x43\x6f\x75\x6e\x74\x00\x83\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x43\x50\x00\x00\x95\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x4d\x6f\x64\x65\x00\x00\x41\x01\x46\x6c\x75\x73\x68\x46\x69\x6c\x65\x42\x75\x66\x66\x65\x72\x73\x00\x00\xe1\x02\x4c\x43\x4d\x61\x70\x53\x74\x72\x69\x6e\x67\x41\x00\x00\x1a\x03\x4d\x75\x6c\x74\x69\x42\x79\x74\x65\x54\x6f\x57\x69\x64\x65\x43\x68\x61\x72\x00\xe3\x02\x4c\x43\x4d\x61\x70\x53\x74\x72\x69\x6e\x67\x57\x00\x00\x3d\x02\x47\x65\x74\x53\x74\x72\x69\x6e\x67\x54\x79\x70\x65\x41\x00\x00\x40\x02\x47\x65\x74\x53\x74\x72\x69\x6e\x67\x54\x79\x70\x65\x57\x00\x00\xe8\x01\x47\x65\x74\x4c\x6f\x63\x61\x6c\x65\x49\x6e\x66\x6f\x41\x00\x00\xdf\x03\x53\x65\x74\x46\x69\x6c\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\xa6\x02\x48\x65\x61\x70\x53\x69\x7a\x65\x00\x00\x43\x00\x43\x6c\x6f\x73\x65\x48\x61\x6e\x64\x6c\x65\x00\x82\x04\x57\x72\x69\x74\x65\x43\x6f\x6e\x73\x6f\x6c\x65\x41\x00\x99\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x4f\x75\x74\x70\x75\x74\x43\x50\x00\x00\x8c\x04\x57\x72\x69\x74\x65\x43\x6f\x6e\x73\x6f\x6c\x65\x57\x00\xfc\x03\x53\x65\x74\x53\x74\x64\x48\x61\x6e\x64\x6c\x65\x00\x00\x78\x00\x43\x72\x65\x61\x74\x65\x46\x69\x6c\x65\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x78\xee\x54\x00\x00\x00\x00\xca\xd1\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x05\x00\x00\x00\x98\xd1\x00\x00\xac\xd1\x00\x00\xc0\xd1\x00\x00\x30\x14\x00\x00\x70\x12\x00\x00\x70\x15\x00\x00\x80\x13\x00\x00\xf0\x13\x00\x00\xd6\xd1\x00\x00\xee\xd1\x00\x00\xf9\xd1\x00\x00\xfe\xd1\x00\x00\x06\xd2\x00\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x73\x79\x73\x74\x72\x61\x79\x2e\x64\x6c\x6c\x00\x61\x64\x64\x5f\x6f\x72\x5f\x75\x70\x64\x61\x74\x65\x5f\x6d\x65\x6e\x75\x5f\x69\x74\x65\x6d\x00\x6e\x61\x74\x69\x76\x65\x4c\x6f\x6f\x70\x00\x71\x75\x69\x74\x00\x73\x65\x74\x49\x63\x6f\x6e\x00\x73\x65\x74\x54\x6f\x6f\x6c\x74\x69\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\xe6\x40\xbb\xb1\x19\xbf\x44\x60\xfe\x00\x10\x00\x00\x00\x00\x60\xfe\x00\x10\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xb1\x00\x10\xd8\xb1\x00\x10\x01\x00\x00\x00\x16\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x0d\x00\x00\x00\x06\x00\x00\x00\x09\x00\x00\x00\x07\x00\x00\x00\x0c\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x09\x00\x00\x00\x0c\x00\x00\x00\x0a\x00\x00\x00\x07\x00\x00\x00\x0b\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x16\x00\x00\x00\x0d\x00\x00\x00\x16\x00\x00\x00\x0f\x00\x00\x00\x02\x00\x00\x00\x10\x00\x00\x00\x0d\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x02\x00\x00\x00\x21\x00\x00\x00\x0d\x00\x00\x00\x35\x00\x00\x00\x02\x00\x00\x00\x41\x00\x00\x00\x0d\x00\x00\x00\x43\x00\x00\x00\x02\x00\x00\x00\x50\x00\x00\x00\x11\x00\x00\x00\x52\x00\x00\x00\x0d\x00\x00\x00\x53\x00\x00\x00\x0d\x00\x00\x00\x57\x00\x00\x00\x16\x00\x00\x00\x59\x00\x00\x00\x0b\x00\x00\x00\x6c\x00\x00\x00\x0d\x00\x00\x00\x6d\x00\x00\x00\x20\x00\x00\x00\x70\x00\x00\x00\x1c\x00\x00\x00\x72\x00\x00\x00\x09\x00\x00\x00\x06\x00\x00\x00\x16\x00\x00\x00\x80\x00\x00\x00\x0a\x00\x00\x00\x81\x00\x00\x00\x0a\x00\x00\x00\x82\x00\x00\x00\x09\x00\x00\x00\x83\x00\x00\x00\x16\x00\x00\x00\x84\x00\x00\x00\x0d\x00\x00\x00\x91\x00\x00\x00\x29\x00\x00\x00\x9e\x00\x00\x00\x0d\x00\x00\x00\xa1\x00\x00\x00\x02\x00\x00\x00\xa4\x00\x00\x00\x0b\x00\x00\x00\xa7\x00\x00\x00\x0d\x00\x00\x00\xb7\x00\x00\x00\x11\x00\x00\x00\xce\x00\x00\x00\x02\x00\x00\x00\xd7\x00\x00\x00\x0b\x00\x00\x00\x18\x07\x00\x00\x0c\x00\x00\x00\x0c\x00\x00\x00\x08\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x37\x00\x10\x00\x00\x00\x00\xff\xff\xff\xff\x80\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x78\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x00\x00\x00\x00\x00\x00\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x00\x00\x00\x00\x00\x00\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x00\x00\x00\x00\x00\x00\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x00\x00\x00\x00\x00\x00\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xe5\x00\x10\x01\x02\x04\x08\xa4\x03\x00\x00\x60\x82\x79\x82\x21\x00\x00\x00\x00\x00\x00\x00\xa6\xdf\x00\x00\x00\x00\x00\x00\xa1\xa5\x00\x00\x00\x00\x00\x00\x81\x9f\xe0\xfc\x00\x00\x00\x00\x40\x7e\x80\xfc\x00\x00\x00\x00\xa8\x03\x00\x00\xc1\xa3\xda\xa3\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x40\xfe\x00\x00\x00\x00\x00\x00\xb5\x03\x00\x00\xc1\xa3\xda\xa3\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x41\xfe\x00\x00\x00\x00\x00\x00\xb6\x03\x00\x00\xcf\xa2\xe4\xa2\x1a\x00\xe5\xa2\xe8\xa2\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x40\x7e\xa1\xfe\x00\x00\x00\x00\x51\x05\x00\x00\x51\xda\x5e\xda\x20\x00\x5f\xda\x6a\xda\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xd3\xd8\xde\xe0\xf9\x00\x00\x31\x7e\x81\xfe\x00\x00\x00\x00\xfc\xbc\x00\x10\xfe\xff\xff\xff\x43\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\xed\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xba\x00\x10\x80\xbf\x00\x10\x00\xc1\x00\x10\x98\xec\x00\x10\xb8\xea\x00\x10\x01\x00\x00\x00\xb8\xea\x00\x10\x88\xe5\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x60\xb9\x00\x10\x08\x00\x00\x00\x34\xb9\x00\x10\x09\x00\x00\x00\x08\xb9\x00\x10\x0a\x00\x00\x00\x70\xb8\x00\x10\x10\x00\x00\x00\x44\xb8\x00\x10\x11\x00\x00\x00\x14\xb8\x00\x10\x12\x00\x00\x00\xf0\xb7\x00\x10\x13\x00\x00\x00\xc4\xb7\x00\x10\x18\x00\x00\x00\x8c\xb7\x00\x10\x19\x00\x00\x00\x64\xb7\x00\x10\x1a\x00\x00\x00\x2c\xb7\x00\x10\x1b\x00\x00\x00\xf4\xb6\x00\x10\x1c\x00\x00\x00\xcc\xb6\x00\x10\x1e\x00\x00\x00\xac\xb6\x00\x10\x1f\x00\x00\x00\x48\xb6\x00\x10\x20\x00\x00\x00\x10\xb6\x00\x10\x21\x00\x00\x00\x18\xb5\x00\x10\x22\x00\x00\x00\x78\xb4\x00\x10\x78\x00\x00\x00\x68\xb4\x00\x10\x79\x00\x00\x00\x58\xb4\x00\x10\x7a\x00\x00\x00\x48\xb4\x00\x10\xfc\x00\x00\x00\x44\xb4\x00\x10\xff\x00\x00\x00\x34\xb4\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xba\x00\x10\xfa\xbc\x00\x10\x28\xc3\x00\x10\x24\xc3\x00\x10\x20\xc3\x00\x10\x1c\xc3\x00\x10\x18\xc3\x00\x10\x14\xc3\x00\x10\x10\xc3\x00\x10\x08\xc3\x00\x10\x00\xc3\x00\x10\xf8\xc2\x00\x10\xec\xc2\x00\x10\xe0\xc2\x00\x10\xd8\xc2\x00\x10\xcc\xc2\x00\x10\xc8\xc2\x00\x10\xc4\xc2\x00\x10\xc0\xc2\x00\x10\xbc\xc2\x00\x10\xb8\xc2\x00\x10\xb4\xc2\x00\x10\xb0\xc2\x00\x10\xac\xc2\x00\x10\xa8\xc2\x00\x10\xa4\xc2\x00\x10\xa0\xc2\x00\x10\x9c\xc2\x00\x10\x94\xc2\x00\x10\x88\xc2\x00\x10\x80\xc2\x00\x10\x78\xc2\x00\x10\xb8\xc2\x00\x10\x70\xc2\x00\x10\x68\xc2\x00\x10\x60\xc2\x00\x10\x54\xc2\x00\x10\x4c\xc2\x00\x10\x40\xc2\x00\x10\x34\xc2\x00\x10\x30\xc2\x00\x10\x2c\xc2\x00\x10\x20\xc2\x00\x10\x0c\xc2\x00\x10\x00\xc2\x00\x10\x09\x04\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x98\xec\x00\x10\x2e\x00\x00\x00\x54\xed\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x58\xed\x00\x10\x01\x00\x00\x00\x2e\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x05\x93\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x70\x00\x00\x01\x00\x00\x00\xf0\xf1\xff\xff\x00\x00\x00\x00\x50\x53\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x44\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xed\x00\x10\x10\xee\x00\x10\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\xfe\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x3b\x00\x00\x00\x5a\x00\x00\x00\x78\x00\x00\x00\x97\x00\x00\x00\xb5\x00\x00\x00\xd4\x00\x00\x00\xf3\x00\x00\x00\x11\x01\x00\x00\x30\x01\x00\x00\x4e\x01\x00\x00\x6d\x01\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x3a\x00\x00\x00\x59\x00\x00\x00\x77\x00\x00\x00\x96\x00\x00\x00\xb4\x00\x00\x00\xd3\x00\x00\x00\xf2\x00\x00\x00\x10\x01\x00\x00\x2f\x01\x00\x00\x4d\x01\x00\x00\x6c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x18\x00\x00\x00\x18\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x02\x00\x00\x00\x30\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x09\x04\x00\x00\x48\x00\x00\x00\x58\x10\x01\x00\x5a\x01\x00\x00\xe4\x04\x00\x00\x00\x00\x00\x00\x3c\x61\x73\x73\x65\x6d\x62\x6c\x79\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x75\x72\x6e\x3a\x73\x63\x68\x65\x6d\x61\x73\x2d\x6d\x69\x63\x72\x6f\x73\x6f\x66\x74\x2d\x63\x6f\x6d\x3a\x61\x73\x6d\x2e\x76\x31\x22\x20\x6d\x61\x6e\x69\x66\x65\x73\x74\x56\x65\x72\x73\x69\x6f\x6e\x3d\x22\x31\x2e\x30\x22\x3e\x0d\x0a\x20\x20\x3c\x74\x72\x75\x73\x74\x49\x6e\x66\x6f\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x75\x72\x6e\x3a\x73\x63\x68\x65\x6d\x61\x73\x2d\x6d\x69\x63\x72\x6f\x73\x6f\x66\x74\x2d\x63\x6f\x6d\x3a\x61\x73\x6d\x2e\x76\x33\x22\x3e\x0d\x0a\x20\x20\x20\x20\x3c\x73\x65\x63\x75\x72\x69\x74\x79\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x3c\x72\x65\x71\x75\x65\x73\x74\x65\x64\x50\x72\x69\x76\x69\x6c\x65\x67\x65\x73\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x3c\x72\x65\x71\x75\x65\x73\x74\x65\x64\x45\x78\x65\x63\x75\x74\x69\x6f\x6e\x4c\x65\x76\x65\x6c\x20\x6c\x65\x76\x65\x6c\x3d\x22\x61\x73\x49\x6e\x76\x6f\x6b\x65\x72\x22\x20\x75\x69\x41\x63\x63\x65\x73\x73\x3d\x22\x66\x61\x6c\x73\x65\x22\x3e\x3c\x2f\x72\x65\x71\x75\x65\x73\x74\x65\x64\x45\x78\x65\x63\x75\x74\x69\x6f\x6e\x4c\x65\x76\x65\x6c\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x3c\x2f\x72\x65\x71\x75\x65\x73\x74\x65\x64\x50\x72\x69\x76\x69\x6c\x65\x67\x65\x73\x3e\x0d\x0a\x20\x20\x20\x20\x3c\x2f\x73\x65\x63\x75\x72\x69\x74\x79\x3e\x0d\x0a\x20\x20\x3c\x2f\x74\x72\x75\x73\x74\x49\x6e\x66\x6f\x3e\x0d\x0a\x3c\x2f\x61\x73\x73\x65\x6d\x62\x6c\x79\x3e\x50\x41\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x00\x10\x00\x00\x44\x01\x00\x00\x1f\x30\x29\x30\x41\x30\x49\x30\x4e\x30\x62\x30\x6d\x30\x7d\x30\xc5\x30\xf1\x30\x12\x31\x31\x31\x3b\x31\x53\x31\x5b\x31\x60\x31\x81\x31\x95\x31\xb9\x31\xd5\x31\xf8\x31\x17\x32\x26\x32\x31\x32\x36\x32\x3e\x32\x47\x32\x4d\x32\x57\x32\x61\x32\x6b\x32\x7d\x32\x83\x32\xa9\x32\xae\x32\xb6\x32\xc5\x32\xcc\x32\xd2\x32\xe0\x32\xea\x32\x05\x33\x1d\x33\x37\x33\x3e\x33\x93\x33\x9e\x33\xb6\x33\xbe\x33\xc3\x33\xd3\x33\xda\x33\xe0\x33\xea\x33\x02\x34\x0f\x34\x17\x34\x21\x34\x9f\x34\xa6\x34\xba\x34\xc1\x34\xe0\x34\xfe\x34\x06\x35\x0b\x35\x34\x35\x43\x35\x4d\x35\x5d\x35\x71\x35\x79\x35\x80\x35\x90\x35\x3d\x36\x48\x36\x5d\x37\x62\x37\x6c\x37\xa0\x37\xb8\x37\xc0\x37\xc6\x37\x0c\x38\x12\x38\x2d\x38\x5d\x38\x79\x38\x91\x38\xe4\x38\x11\x39\x7f\x39\x85\x39\x8b\x39\x91\x39\x97\x39\x9d\x39\xa4\x39\xab\x39\xb2\x39\xb9\x39\xc0\x39\xc7\x39\xce\x39\xd6\x39\xde\x39\xe6\x39\xf2\x39\xfb\x39\x00\x3a\x06\x3a\x10\x3a\x19\x3a\x24\x3a\x30\x3a\x35\x3a\x45\x3a\x4a\x3a\x50\x3a\x56\x3a\x6c\x3a\x73\x3a\x7a\x3a\x80\x3a\x9a\x3a\xa9\x3a\xb6\x3a\xc2\x3a\xd2\x3a\xd9\x3a\xe8\x3a\xf4\x3a\x01\x3b\x25\x3b\x37\x3b\x45\x3b\x5a\x3b\x64\x3b\x8a\x3b\xbd\x3b\xcc\x3b\xd5\x3b\xf9\x3b\x28\x3c\x6a\x3c\x7c\x3c\x28\x3d\x30\x3d\x45\x3d\x50\x3d\x37\x3e\xd9\x3e\xf7\x3e\x1d\x3f\x7d\x3f\x90\x3f\xab\x3f\x00\x00\x00\x20\x00\x00\x9c\x00\x00\x00\xf6\x32\xe6\x33\x70\x35\x9f\x35\xc4\x35\xa7\x37\xa3\x39\xa7\x39\xab\x39\xaf\x39\xb3\x39\xb7\x39\xbb\x39\xbf\x39\xcc\x39\xde\x39\xb0\x3a\xba\x3a\xc7\x3a\xe2\x3a\xe9\x3a\x01\x3b\x2d\x3b\x49\x3b\x6c\x3b\x7f\x3b\xad\x3b\xca\x3b\x22\x3c\xfc\x3c\x04\x3d\x1c\x3d\x34\x3d\x8b\x3d\xa4\x3d\xaa\x3d\xb5\x3d\xc1\x3d\xd6\x3d\xdd\x3d\xf1\x3d\xf8\x3d\x1f\x3e\x25\x3e\x30\x3e\x3c\x3e\x51\x3e\x58\x3e\x6c\x3e\x73\x3e\x8b\x3e\x97\x3e\x9d\x3e\xa9\x3e\xb8\x3e\xbe\x3e\xc7\x3e\xd3\x3e\xe1\x3e\xe7\x3e\xf3\x3e\xf9\x3e\x06\x3f\x10\x3f\x17\x3f\x2f\x3f\x3e\x3f\x45\x3f\x52\x3f\x75\x3f\x8a\x3f\xb0\x3f\xf0\x3f\xf6\x3f\x00\x30\x00\x00\x58\x01\x00\x00\x20\x30\x26\x30\x42\x30\x5a\x30\x80\x30\xfa\x30\x1d\x31\x27\x31\x5f\x31\x67\x31\xb3\x31\xc3\x31\xc9\x31\xd5\x31\xdb\x31\xeb\x31\xf1\x31\x06\x32\x14\x32\x1f\x32\x26\x32\x41\x32\x46\x32\x4e\x32\x54\x32\x5b\x32\x61\x32\x68\x32\x6e\x32\x76\x32\x7d\x32\x82\x32\x8a\x32\x93\x32\x9f\x32\xa4\x32\xa9\x32\xaf\x32\xb3\x32\xb9\x32\xbe\x32\xc4\x32\xc9\x32\xd8\x32\xee\x32\xf9\x32\xfe\x32\x09\x33\x0e\x33\x19\x33\x1e\x33\x2b\x33\x39\x33\x3f\x33\x4c\x33\x6c\x33\x72\x33\x8e\x33\xaa\x33\xbc\x33\x0b\x34\x11\x34\x22\x34\x4f\x34\x58\x34\x64\x34\x9b\x34\xa4\x34\xb0\x34\xe9\x34\xf2\x34\xfe\x34\x22\x35\x2b\x35\x58\x35\x73\x35\x79\x35\x82\x35\x89\x35\xab\x35\x0a\x36\x12\x36\x25\x36\x30\x36\x35\x36\x45\x36\x4f\x36\x56\x36\x61\x36\x6a\x36\x80\x36\x8b\x36\xa5\x36\xb1\x36\xb9\x36\xc9\x36\xde\x36\x1e\x37\x2b\x37\x55\x37\x5a\x37\x65\x37\x6a\x37\x88\x37\x14\x38\x21\x38\x2a\x38\x3e\x38\x5f\x38\x65\x38\x97\x38\xee\x38\xf6\x38\x36\x39\x40\x39\x68\x39\x81\x39\xc2\x39\xf2\x39\x04\x3a\x56\x3a\x5c\x3a\x80\x3a\x9e\x3a\xc0\x3a\xcb\x3a\xda\x3a\x12\x3b\x1c\x3b\x6c\x3b\x77\x3b\x81\x3b\x92\x3b\x9d\x3b\x50\x3d\x61\x3d\x69\x3d\x6f\x3d\x74\x3d\x7a\x3d\xe6\x3d\xec\x3d\x02\x3e\x0d\x3e\x24\x3e\x30\x3e\x3d\x3e\x44\x3e\x7b\x3e\xca\x3e\xdd\x3e\x0f\x3f\x28\x3f\x37\x3f\x3c\x3f\x5d\x3f\x62\x3f\x96\x3f\x9b\x3f\xa9\x3f\xb2\x3f\xbe\x3f\xc5\x3f\xce\x3f\xe1\x3f\xeb\x3f\xf7\x3f\x00\x00\x00\x40\x00\x00\xd4\x00\x00\x00\x00\x30\x08\x30\x12\x30\x18\x30\x1e\x30\x40\x30\xb9\x30\xbf\x30\xd8\x30\xde\x30\xae\x31\xd1\x31\xde\x31\xea\x31\xf2\x31\xfa\x31\x06\x32\x2a\x32\x32\x32\x3d\x32\x46\x32\x67\x32\x73\x32\x9a\x32\xa7\x32\xac\x32\xba\x32\x95\x33\xb8\x33\xc3\x33\xe6\x33\x35\x34\x7c\x34\x83\x34\x8d\x34\xb7\x34\xc5\x34\xcb\x34\xee\x34\xf5\x34\x0e\x35\x22\x35\x28\x35\x31\x35\x44\x35\x68\x35\xfd\x35\x1d\x36\x49\x36\x76\x36\x1c\x37\x59\x37\x70\x37\xe3\x38\xf4\x38\x2e\x39\x3b\x39\x45\x39\x53\x39\x5c\x39\x66\x39\x9a\x39\xa5\x39\xaf\x39\xc8\x39\xd2\x39\xe5\x39\x09\x3a\x40\x3a\x75\x3a\x88\x3a\xf8\x3a\x15\x3b\x5d\x3b\xc9\x3b\xe8\x3b\x5d\x3c\x69\x3c\x7c\x3c\x8e\x3c\xa9\x3c\xb1\x3c\xb9\x3c\xd0\x3c\xe9\x3c\x05\x3d\x0e\x3d\x14\x3d\x1d\x3d\x22\x3d\x31\x3d\x58\x3d\x81\x3d\x92\x3d\xb5\x3d\x7a\x3e\xa4\x3e\xef\x3e\x3b\x3f\x8a\x3f\xd2\x3f\x00\x00\x00\x50\x00\x00\x80\x00\x00\x00\x38\x30\x4f\x30\x60\x30\x9c\x30\xc6\x31\xcd\x31\x2e\x32\xfc\x33\x1a\x34\x70\x35\xe1\x35\xed\x35\xf9\x36\xb8\x37\xbd\x37\xcf\x37\xed\x37\x01\x38\x07\x38\x74\x38\x79\x38\xbc\x3a\xca\x3a\xd0\x3a\xea\x3a\xef\x3a\xfe\x3a\x07\x3b\x14\x3b\x1f\x3b\x31\x3b\x44\x3b\x4f\x3b\x55\x3b\x5b\x3b\x60\x3b\x69\x3b\x86\x3b\x8c\x3b\x97\x3b\x9c\x3b\xa4\x3b\xaa\x3b\xb4\x3b\xbb\x3b\xcf\x3b\xd6\x3b\xdc\x3b\xea\x3b\xf1\x3b\xf6\x3b\xff\x3b\x0c\x3c\x12\x3c\x2c\x3c\x3d\x3c\x43\x3c\x54\x3c\xb9\x3c\x00\x00\x00\x60\x00\x00\xe0\x00\x00\x00\x55\x30\x61\x30\x94\x30\xba\x30\xf4\x30\x39\x31\x0c\x33\x17\x33\x1f\x33\x34\x33\x46\x33\x96\x33\x9c\x33\xbc\x33\xf3\x33\x04\x34\x4d\x34\xa9\x34\xbe\x34\x04\x35\x0a\x35\x16\x35\x6b\x35\x9e\x35\xd6\x35\x41\x36\x47\x36\x98\x36\x9e\x36\xc2\x36\xe5\x36\x19\x37\x1f\x37\x2b\x37\x72\x37\x9a\x37\xd1\x37\xe9\x37\xf4\x37\x18\x38\x21\x38\x28\x38\x31\x38\x71\x38\x76\x38\x9e\x38\xc3\x38\xe8\x38\xfb\x38\x13\x39\x25\x39\x49\x39\x72\x39\x7d\x39\xf7\x39\x10\x3a\x39\x3a\x3e\x3a\x55\x3a\xa8\x3a\xdf\x3a\xea\x3a\xf8\x3a\xfd\x3a\x02\x3b\x07\x3b\x17\x3b\x46\x3b\x54\x3b\x9b\x3b\xa0\x3b\xe5\x3b\xea\x3b\xf1\x3b\xf6\x3b\xfd\x3b\x02\x3c\x71\x3c\x7a\x3c\x80\x3c\x0a\x3d\x19\x3d\x28\x3d\x31\x3d\x46\x3d\x76\x3d\x97\x3d\xa4\x3d\xca\x3e\xff\x3e\x18\x3f\x1f\x3f\x27\x3f\x2c\x3f\x30\x3f\x34\x3f\x5d\x3f\x83\x3f\xa1\x3f\xa8\x3f\xac\x3f\xb0\x3f\xb4\x3f\xb8\x3f\xbc\x3f\xc0\x3f\xc4\x3f\x00\x00\x00\x70\x00\x00\x8c\x00\x00\x00\x0e\x30\x14\x30\x18\x30\x1c\x30\x20\x30\x86\x30\x91\x30\xac\x30\xb3\x30\xb8\x30\xbc\x30\xc0\x30\xe1\x30\x0b\x31\x3d\x31\x44\x31\x48\x31\x4c\x31\x50\x31\x54\x31\x58\x31\x5c\x31\x60\x31\xaa\x31\xb0\x31\xb4\x31\xb8\x31\xbc\x31\x7f\x32\x08\x33\x6d\x33\x21\x34\x41\x34\x31\x35\x5a\x35\xb3\x35\x41\x37\x21\x38\xea\x38\x1b\x39\x31\x39\x72\x39\x91\x39\x2e\x3a\x62\x3a\x91\x3a\x0a\x3b\x36\x3b\x5e\x3b\x95\x3b\x9f\x3b\x11\x3c\x23\x3c\x30\x3c\x3c\x3c\x46\x3c\x4e\x3c\x59\x3c\x89\x3c\xb9\x3c\x50\x3d\x00\x3e\x23\x3e\xa1\x3e\x72\x3f\xfa\x3f\x00\x80\x00\x00\x90\x00\x00\x00\x04\x30\x1c\x30\x23\x30\x2d\x30\x35\x30\x42\x30\x49\x30\x79\x30\x12\x31\x87\x31\x94\x33\xa6\x33\xb8\x33\xda\x33\xec\x33\xfe\x33\x10\x34\x22\x34\x34\x34\x46\x34\xe4\x36\xf1\x36\x0a\x37\x28\x37\x66\x37\x95\x37\x45\x38\x79\x39\x2e\x3a\x44\x3a\xa9\x3a\xb5\x3a\x2d\x3b\x47\x3b\x50\x3b\xb1\x3d\xb8\x3d\xfa\x3d\x2f\x3e\x48\x3e\x4f\x3e\x57\x3e\x5c\x3e\x60\x3e\x64\x3e\x8d\x3e\xb3\x3e\xd1\x3e\xd8\x3e\xdc\x3e\xe0\x3e\xe4\x3e\xe8\x3e\xec\x3e\xf0\x3e\xf4\x3e\x3e\x3f\x44\x3f\x48\x3f\x4c\x3f\x50\x3f\xb6\x3f\xc1\x3f\xdc\x3f\xe3\x3f\xe8\x3f\xec\x3f\xf0\x3f\x00\x90\x00\x00\xc8\x00\x00\x00\x11\x30\x3b\x30\x6d\x30\x74\x30\x78\x30\x7c\x30\x80\x30\x84\x30\x88\x30\x8c\x30\x90\x30\xda\x30\xe0\x30\xe4\x30\xe8\x30\xec\x30\x38\x31\x70\x31\xb3\x31\xb9\x31\xee\x31\xfc\x31\x02\x32\x12\x32\x17\x32\x2f\x32\x35\x32\x44\x32\x4a\x32\x59\x32\x5f\x32\x6d\x32\x76\x32\x85\x32\x8a\x32\x94\x32\xa2\x32\xe2\x32\xff\x32\x1c\x33\x5b\x33\x62\x33\x68\x33\x98\x33\xa3\x33\xc6\x33\x8a\x34\x97\x34\x24\x36\x61\x36\x6b\x36\x83\x36\xac\x36\xe0\x36\x0f\x37\xb0\x37\xbe\x37\xc6\x37\xd3\x37\xf1\x37\xfb\x37\x04\x38\x0f\x38\x24\x38\x2b\x38\x31\x38\x47\x38\x62\x38\x07\x39\x75\x39\xde\x39\xee\x39\x09\x3a\x29\x3a\x7f\x3a\x90\x3a\xcb\x3a\xe7\x3a\x42\x3b\x4d\x3b\x7b\x3b\x89\x3b\x98\x3b\xb5\x3b\xe1\x3b\x1a\x3c\x27\x3c\x06\x3d\x15\x3d\x99\x3e\x9f\x3e\xa4\x3e\xaa\x3e\xb1\x3e\xc3\x3e\x00\x00\x00\xa0\x00\x00\x0c\x00\x00\x00\x60\x30\x00\x00\x00\xb0\x00\x00\x18\x00\x00\x00\x84\x31\x88\x31\x8c\x31\x90\x31\x9c\x31\xa0\x31\xd0\x31\xd4\x31\x00\xc0\x00\x00\x58\x00\x00\x00\x9c\x34\xa0\x34\x78\x35\x94\x35\x98\x35\xb8\x35\xc4\x35\xe0\x35\xec\x35\x08\x36\x28\x36\x44\x36\x48\x36\x68\x36\x88\x36\x94\x36\xb0\x36\xd0\x36\xf0\x36\x10\x37\x2c\x37\x30\x37\x50\x37\x70\x37\x90\x37\xb0\x37\xcc\x37\xd0\x37\xf0\x37\x0c\x38\x10\x38\x30\x38\x50\x38\x70\x38\x90\x38\xac\x38\xb0\x38\xd0\x38\xf0\x38\x10\x39\x00\xe0\x00\x00\xe8\x00\x00\x00\x08\x30\x10\x30\x88\x32\x8c\x32\x08\x34\xb0\x39\xa8\x3a\x10\x3b\x20\x3b\x30\x3b\x40\x3b\x50\x3b\x74\x3b\x80\x3b\x84\x3b\x88\x3b\x8c\x3b\x90\x3b\x98\x3b\x9c\x3b\xa0\x3b\xa4\x3b\xa8\x3b\xac\x3b\xb0\x3b\xb4\x3b\xb8\x3b\xbc\x3b\xc0\x3b\xc4\x3b\xd4\x3b\xdc\x3b\xe4\x3b\xec\x3b\xf4\x3b\xfc\x3b\x04\x3c\x0c\x3c\x14\x3c\x1c\x3c\x24\x3c\x2c\x3c\x34\x3c\x3c\x3c\x44\x3c\x4c\x3c\x54\x3c\x5c\x3c\x64\x3c\x6c\x3c\x74\x3c\x7c\x3c\x84\x3c\x90\x3c\x94\x3c\x98\x3c\x9c\x3c\xa0\x3c\xa4\x3c\xa8\x3c\xac\x3c\xb0\x3c\xb4\x3c\xb8\x3c\xbc\x3c\xc0\x3c\xc4\x3c\xc8\x3c\xcc\x3c\xd0\x3c\xd4\x3c\xd8\x3c\xdc\x3c\xe0\x3c\xe4\x3c\xe8\x3c\xec\x3c\xf0\x3c\xf4\x3c\xf8\x3c\xfc\x3c\x00\x3d\x04\x3d\x08\x3d\x0c\x3d\x10\x3d\x14\x3d\x18\x3d\x1c\x3d\x20\x3d\x24\x3d\x28\x3d\x2c\x3d\x30\x3d\x34\x3d\x38\x3d\x3c\x3d\x40\x3d\x50\x3d\x58\x3d\x5c\x3d\x60\x3d\x64\x3d\x68\x3d\x6c\x3d\x70\x3d\x74\x3d\x78\x3d\x7c\x3d\x88\x3d\x50\x3e\x54\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x11\x00\x00\x00\x02\x02\x00\x30\x82\x11\x57\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x07\x02\xa0\x82\x11\x48\x30\x82\x11\x44\x02\x01\x01\x31\x0b\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x30\x68\x06\x0a\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x04\xa0\x5a\x30\x58\x30\x33\x06\x0a\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x0f\x30\x25\x03\x01\x00\xa0\x20\xa2\x1e\x80\x1c\x00\x3c\x00\x3c\x00\x3c\x00\x4f\x00\x62\x00\x73\x00\x6f\x00\x6c\x00\x65\x00\x74\x00\x65\x00\x3e\x00\x3e\x00\x3e\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14\xbb\x6e\x57\x88\x40\x9b\x90\x3c\xdb\x68\x77\x99\xff\xc9\x30\x33\x95\xe2\x0a\x29\xa0\x82\x0e\x46\x30\x82\x05\x5c\x30\x82\x04\x44\xa0\x03\x02\x01\x02\x02\x07\x27\x90\x56\x03\x1f\x49\xcb\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30\x81\xca\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x10\x30\x0e\x06\x03\x55\x04\x08\x13\x07\x41\x72\x69\x7a\x6f\x6e\x61\x31\x13\x30\x11\x06\x03\x55\x04\x07\x13\x0a\x53\x63\x6f\x74\x74\x73\x64\x61\x6c\x65\x31\x1a\x30\x18\x06\x03\x55\x04\x0a\x13\x11\x47\x6f\x44\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2c\x20\x49\x6e\x63\x2e\x31\x33\x30\x31\x06\x03\x55\x04\x0b\x13\x2a\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x31\x30\x30\x2e\x06\x03\x55\x04\x03\x13\x27\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x53\x65\x63\x75\x72\x65\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x31\x11\x30\x0f\x06\x03\x55\x04\x05\x13\x08\x30\x37\x39\x36\x39\x32\x38\x37\x30\x1e\x17\x0d\x31\x33\x30\x36\x31\x31\x32\x32\x32\x34\x35\x31\x5a\x17\x0d\x31\x36\x30\x36\x31\x31\x32\x32\x32\x34\x35\x31\x5a\x30\x81\x86\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x0b\x30\x09\x06\x03\x55\x04\x08\x13\x02\x43\x41\x31\x14\x30\x12\x06\x03\x55\x04\x07\x13\x0b\x4c\x6f\x73\x20\x41\x6e\x67\x65\x6c\x65\x73\x31\x29\x30\x27\x06\x03\x55\x04\x0a\x13\x20\x42\x72\x61\x76\x65\x20\x4e\x65\x77\x20\x53\x6f\x66\x74\x77\x61\x72\x65\x20\x50\x72\x6f\x6a\x65\x63\x74\x2c\x20\x49\x6e\x63\x2e\x31\x29\x30\x27\x06\x03\x55\x04\x03\x13\x20\x42\x72\x61\x76\x65\x20\x4e\x65\x77\x20\x53\x6f\x66\x74\x77\x61\x72\x65\x20\x50\x72\x6f\x6a\x65\x63\x74\x2c\x20\x49\x6e\x63\x2e\x30\x82\x01\x22\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x82\x01\x0f\x00\x30\x82\x01\x0a\x02\x82\x01\x01\x00\xc5\xe4\x5e\x67\x45\x47\x0d\x0f\xbf\x5d\x81\x07\x84\x5a\xb4\x92\xb4\xfe\x6b\xff\xbf\x9a\x58\x42\x92\x02\x7f\xeb\x4e\x4a\x98\xf5\xea\x06\xff\x2a\xa3\x97\xf5\x88\xae\x82\xf9\x34\x3c\xef\x6e\xb8\x27\x86\x7d\xcb\x0d\x2d\x47\x07\x1d\x63\x5f\xe8\x7e\x91\xfb\x4f\x2c\x2a\xde\x90\x4e\x81\xfa\xe7\x9c\xff\x60\x16\xda\xae\x43\xfb\x60\xcd\x59\x28\xad\x0d\x0b\xe7\x5c\x3d\x1c\xb6\x77\x70\x28\xe9\x68\xba\x68\x7c\x86\xb3\xb6\x06\xc2\x23\x3b\x02\x4f\xa9\x15\x37\x1e\x92\x77\xfe\x0a\x05\x2b\x93\x86\x13\x04\x9c\xfe\x69\xbb\x95\xb1\xaf\x8f\xe5\xba\x32\x29\x4d\xe5\x44\x5f\x39\x63\x40\xcc\x6a\x5f\xee\x7c\x21\x27\x97\x63\x1e\x92\xc4\xb5\xf1\xe5\x58\x23\xd4\x80\x7a\x34\x9c\x23\x83\xba\xf8\x37\x38\x3f\xcd\x41\xf4\x66\x40\x96\x8f\x7a\xc3\x5a\x8e\xa2\xb4\x8a\x1e\xa3\xad\x68\xfa\x13\xd0\x02\x31\xf6\xdd\x30\x8a\x3a\x7f\x12\xb1\xa7\xa3\xa1\xcc\xa0\x0a\xb7\x0e\x73\xb6\xaa\x7c\x6b\x95\x33\x71\xee\x1f\x1b\x57\xb2\x36\x0f\xa8\x93\x15\x1e\x25\xca\xa2\xc8\xbd\x1d\xc1\xe8\xe4\x10\x02\x3d\x3d\x05\x92\xb6\x48\xc3\x3d\xe4\xe9\x5c\xb5\x87\xb9\xc1\x1d\x02\x03\x01\x00\x01\xa3\x82\x01\x87\x30\x82\x01\x83\x30\x0f\x06\x03\x55\x1d\x13\x01\x01\xff\x04\x05\x30\x03\x01\x01\x00\x30\x13\x06\x03\x55\x1d\x25\x04\x0c\x30\x0a\x06\x08\x2b\x06\x01\x05\x05\x07\x03\x03\x30\x0e\x06\x03\x55\x1d\x0f\x01\x01\xff\x04\x04\x03\x02\x07\x80\x30\x33\x06\x03\x55\x1d\x1f\x04\x2c\x30\x2a\x30\x28\xa0\x26\xa0\x24\x86\x22\x68\x74\x74\x70\x3a\x2f\x2f\x63\x72\x6c\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x67\x64\x73\x35\x2d\x31\x36\x2e\x63\x72\x6c\x30\x53\x06\x03\x55\x1d\x20\x04\x4c\x30\x4a\x30\x48\x06\x0b\x60\x86\x48\x01\x86\xfd\x6d\x01\x07\x17\x02\x30\x39\x30\x37\x06\x08\x2b\x06\x01\x05\x05\x07\x02\x01\x16\x2b\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x2f\x30\x81\x80\x06\x08\x2b\x06\x01\x05\x05\x07\x01\x01\x04\x74\x30\x72\x30\x24\x06\x08\x2b\x06\x01\x05\x05\x07\x30\x01\x86\x18\x68\x74\x74\x70\x3a\x2f\x2f\x6f\x63\x73\x70\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x30\x4a\x06\x08\x2b\x06\x01\x05\x05\x07\x30\x02\x86\x3e\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x2f\x67\x64\x5f\x69\x6e\x74\x65\x72\x6d\x65\x64\x69\x61\x74\x65\x2e\x63\x72\x74\x30\x1f\x06\x03\x55\x1d\x23\x04\x18\x30\x16\x80\x14\xfd\xac\x61\x32\x93\x6c\x45\xd6\xe2\xee\x85\x5f\x9a\xba\xe7\x76\x99\x68\xcc\xe7\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16\x04\x14\xce\x40\x53\xcf\xdc\x8f\x16\x68\xd4\x05\x43\x8d\x08\x1d\x33\xe7\x57\xb5\x46\xd4\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x82\x01\x01\x00\x4d\x49\x27\x61\xe0\x82\xe3\x72\x4f\x18\x5b\xdc\x3b\xab\x8e\x45\xce\xc2\x2c\xdc\xa9\xf7\xe5\xfa\x05\xc1\x65\x7f\xde\x08\x5c\x04\x90\xcf\xb1\xae\xe3\x12\x9d\x86\x47\x51\x61\xbd\x70\x81\x6a\x74\xab\x31\x80\x4b\x0f\x94\xe7\xd4\x1c\xe6\xc6\x06\x2c\xf7\x95\x5c\x68\xff\xf2\x2a\x33\xec\xfb\xef\xa6\x4f\x12\xa5\x84\x45\x8e\xc1\xaa\xd3\x8f\x89\x3a\xa6\x62\x3f\x5f\x51\x77\x62\xc5\xd7\xcf\x49\x09\x10\x93\x88\x1c\xe9\xa6\xbf\x1e\xd4\x83\xf1\x5b\xf6\xc8\x55\x1b\xff\xb6\xc8\x71\x81\xae\x0b\x9c\x3e\x3c\xaf\x8e\x7c\x37\x21\xdc\x9d\x51\x16\x71\xa6\x94\x41\x8b\x34\xbd\x81\x75\x2b\xe4\x26\x81\x73\xe6\x28\xad\x35\x32\x40\x51\xaf\x9b\x1b\xb2\xd1\x30\x12\x25\x37\x58\x26\xe2\x6a\x19\xdb\xf9\x88\x6c\xe9\xcc\xbc\xea\x7e\xd7\x75\x72\xd5\xe1\x05\x48\xcf\xfb\x9b\x8b\xaa\xd3\x69\x24\x77\x56\xbf\x16\x93\x57\x06\x10\xcc\x3c\x7a\x2f\xb2\x24\xa5\xf4\x47\xae\x9d\xdf\x93\x4d\xf8\xb2\xc6\x0b\x62\x77\xbc\x2f\x1a\xc3\x63\xdc\xa1\x8a\x95\xd8\xb2\x47\xbc\x3c\xe1\x1d\xbc\x36\x73\x6a\x83\xbc\xf5\x89\x3b\x7d\x74\xeb\xe7\x0f\x7c\xfb\x98\x71\x85\xcf\x47\x30\x82\x04\xde\x30\x82\x03\xc6\xa0\x03\x02\x01\x02\x02\x02\x03\x01\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30\x63\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x21\x30\x1f\x06\x03\x55\x04\x0a\x13\x18\x54\x68\x65\x20\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x47\x72\x6f\x75\x70\x2c\x20\x49\x6e\x63\x2e\x31\x31\x30\x2f\x06\x03\x55\x04\x0b\x13\x28\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x43\x6c\x61\x73\x73\x20\x32\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x30\x1e\x17\x0d\x30\x36\x31\x31\x31\x36\x30\x31\x35\x34\x33\x37\x5a\x17\x0d\x32\x36\x31\x31\x31\x36\x30\x31\x35\x34\x33\x37\x5a\x30\x81\xca\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x10\x30\x0e\x06\x03\x55\x04\x08\x13\x07\x41\x72\x69\x7a\x6f\x6e\x61\x31\x13\x30\x11\x06\x03\x55\x04\x07\x13\x0a\x53\x63\x6f\x74\x74\x73\x64\x61\x6c\x65\x31\x1a\x30\x18\x06\x03\x55\x04\x0a\x13\x11\x47\x6f\x44\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2c\x20\x49\x6e\x63\x2e\x31\x33\x30\x31\x06\x03\x55\x04\x0b\x13\x2a\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x31\x30\x30\x2e\x06\x03\x55\x04\x03\x13\x27\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x53\x65\x63\x75\x72\x65\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x31\x11\x30\x0f\x06\x03\x55\x04\x05\x13\x08\x30\x37\x39\x36\x39\x32\x38\x37\x30\x82\x01\x22\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x82\x01\x0f\x00\x30\x82\x01\x0a\x02\x82\x01\x01\x00\xc4\x2d\xd5\x15\x8c\x9c\x26\x4c\xec\x32\x35\xeb\x5f\xb8\x59\x01\x5a\xa6\x61\x81\x59\x3b\x70\x63\xab\xe3\xdc\x3d\xc7\x2a\xb8\xc9\x33\xd3\x79\xe4\x3a\xed\x3c\x30\x23\x84\x8e\xb3\x30\x14\xb6\xb2\x87\xc3\x3d\x95\x54\x04\x9e\xdf\x99\xdd\x0b\x25\x1e\x21\xde\x65\x29\x7e\x35\xa8\xa9\x54\xeb\xf6\xf7\x32\x39\xd4\x26\x55\x95\xad\xef\xfb\xfe\x58\x86\xd7\x9e\xf4\x00\x8d\x8c\x2a\x0c\xbd\x42\x04\xce\xa7\x3f\x04\xf6\xee\x80\xf2\xaa\xef\x52\xa1\x69\x66\xda\xbe\x1a\xad\x5d\xda\x2c\x66\xea\x1a\x6b\xbb\xe5\x1a\x51\x4a\x00\x2f\x48\xc7\x98\x75\xd8\xb9\x29\xc8\xee\xf8\x66\x6d\x0a\x9c\xb3\xf3\xfc\x78\x7c\xa2\xf8\xa3\xf2\xb5\xc3\xf3\xb9\x7a\x91\xc1\xa7\xe6\x25\x2e\x9c\xa8\xed\x12\x65\x6e\x6a\xf6\x12\x44\x53\x70\x30\x95\xc3\x9c\x2b\x58\x2b\x3d\x08\x74\x4a\xf2\xbe\x51\xb0\xbf\x87\xd0\x4c\x27\x58\x6b\xb5\x35\xc5\x9d\xaf\x17\x31\xf8\x0b\x8f\xee\xad\x81\x36\x05\x89\x08\x98\xcf\x3a\xaf\x25\x87\xc0\x49\xea\xa7\xfd\x67\xf7\x45\x8e\x97\xcc\x14\x39\xe2\x36\x85\xb5\x7e\x1a\x37\xfd\x16\xf6\x71\x11\x9a\x74\x30\x16\xfe\x13\x94\xa3\x3f\x84\x0d\x4f\x02\x03\x01\x00\x01\xa3\x82\x01\x32\x30\x82\x01\x2e\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16\x04\x14\xfd\xac\x61\x32\x93\x6c\x45\xd6\xe2\xee\x85\x5f\x9a\xba\xe7\x76\x99\x68\xcc\xe7\x30\x1f\x06\x03\x55\x1d\x23\x04\x18\x30\x16\x80\x14\xd2\xc4\xb0\xd2\x91\xd4\x4c\x11\x71\xb3\x61\xcb\x3d\xa1\xfe\xdd\xa8\x6a\xd4\xe3\x30\x12\x06\x03\x55\x1d\x13\x01\x01\xff\x04\x08\x30\x06\x01\x01\xff\x02\x01\x00\x30\x33\x06\x08\x2b\x06\x01\x05\x05\x07\x01\x01\x04\x27\x30\x25\x30\x23\x06\x08\x2b\x06\x01\x05\x05\x07\x30\x01\x86\x17\x68\x74\x74\x70\x3a\x2f\x2f\x6f\x63\x73\x70\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x30\x46\x06\x03\x55\x1d\x1f\x04\x3f\x30\x3d\x30\x3b\xa0\x39\xa0\x37\x86\x35\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x2f\x67\x64\x72\x6f\x6f\x74\x2e\x63\x72\x6c\x30\x4b\x06\x03\x55\x1d\x20\x04\x44\x30\x42\x30\x40\x06\x04\x55\x1d\x20\x00\x30\x38\x30\x36\x06\x08\x2b\x06\x01\x05\x05\x07\x02\x01\x16\x2a\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x30\x0e\x06\x03\x55\x1d\x0f\x01\x01\xff\x04\x04\x03\x02\x01\x06\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x82\x01\x01\x00\xd2\x86\xc0\xec\xbd\xf9\xa1\xb6\x67\xee\x66\x0b\xa2\x06\x3a\x04\x50\x8e\x15\x72\xac\x4a\x74\x95\x53\xcb\x37\xcb\x44\x49\xef\x07\x90\x6b\x33\xd9\x96\xf0\x94\x56\xa5\x13\x30\x05\x3c\x85\x32\x21\x7b\xc9\xc7\x0a\xa8\x24\xa4\x90\xde\x46\xd3\x25\x23\x14\x03\x67\xc2\x10\xd6\x6f\x0f\x5d\x7b\x7a\xcc\x9f\xc5\x58\x2a\xc1\xc4\x9e\x21\xa8\x5a\xf3\xac\xa4\x46\xf3\x9e\xe4\x63\xcb\x2f\x90\xa4\x29\x29\x01\xd9\x72\x2c\x29\xdf\x37\x01\x27\xbc\x4f\xee\x68\xd3\x21\x8f\xc0\xb3\xe4\xf5\x09\xed\xd2\x10\xaa\x53\xb4\xbe\xf0\xcc\x59\x0b\xd6\x3b\x96\x1c\x95\x24\x49\xdf\xce\xec\xfd\xa7\x48\x91\x14\x45\x0e\x3a\x36\x6f\xda\x45\xb3\x45\xa2\x41\xc9\xd4\xd7\x44\x4e\x3e\xb9\x74\x76\xd5\xa2\x13\x55\x2c\xc6\x87\xa3\xb5\x99\xac\x06\x84\x87\x7f\x75\x06\xfc\xbf\x14\x4c\x0e\xcc\x6e\xc4\xdf\x3d\xb7\x12\x71\xf4\xe8\xf1\x51\x40\x22\x28\x49\xe0\x1d\x4b\x87\xa8\x34\xcc\x06\xa2\xdd\x12\x5a\xd1\x86\x36\x64\x03\x35\x6f\x6f\x77\x6e\xeb\xf2\x85\x50\x98\x5e\xab\x03\x53\xad\x91\x23\x63\x1f\x16\x9c\xcd\xb9\xb2\x05\x63\x3a\xe1\xf4\x68\x1b\x17\x05\x35\x95\x53\xee\x30\x82\x04\x00\x30\x82\x02\xe8\xa0\x03\x02\x01\x02\x02\x01\x00\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30\x63\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x21\x30\x1f\x06\x03\x55\x04\x0a\x13\x18\x54\x68\x65\x20\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x47\x72\x6f\x75\x70\x2c\x20\x49\x6e\x63\x2e\x31\x31\x30\x2f\x06\x03\x55\x04\x0b\x13\x28\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x43\x6c\x61\x73\x73\x20\x32\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x30\x1e\x17\x0d\x30\x34\x30\x36\x32\x39\x31\x37\x30\x36\x32\x30\x5a\x17\x0d\x33\x34\x30\x36\x32\x39\x31\x37\x30\x36\x32\x30\x5a\x30\x63\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x21\x30\x1f\x06\x03\x55\x04\x0a\x13\x18\x54\x68\x65\x20\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x47\x72\x6f\x75\x70\x2c\x20\x49\x6e\x63\x2e\x31\x31\x30\x2f\x06\x03\x55\x04\x0b\x13\x28\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x43\x6c\x61\x73\x73\x20\x32\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x30\x82\x01\x20\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x82\x01\x0d\x00\x30\x82\x01\x08\x02\x82\x01\x01\x00\xde\x9d\xd7\xea\x57\x18\x49\xa1\x5b\xeb\xd7\x5f\x48\x86\xea\xbe\xdd\xff\xe4\xef\x67\x1c\xf4\x65\x68\xb3\x57\x71\xa0\x5e\x77\xbb\xed\x9b\x49\xe9\x70\x80\x3d\x56\x18\x63\x08\x6f\xda\xf2\xcc\xd0\x3f\x7f\x02\x54\x22\x54\x10\xd8\xb2\x81\xd4\xc0\x75\x3d\x4b\x7f\xc7\x77\xc3\x3e\x78\xab\x1a\x03\xb5\x20\x6b\x2f\x6a\x2b\xb1\xc5\x88\x7e\xc4\xbb\x1e\xb0\xc1\xd8\x45\x27\x6f\xaa\x37\x58\xf7\x87\x26\xd7\xd8\x2d\xf6\xa9\x17\xb7\x1f\x72\x36\x4e\xa6\x17\x3f\x65\x98\x92\xdb\x2a\x6e\x5d\xa2\xfe\x88\xe0\x0b\xde\x7f\xe5\x8d\x15\xe1\xeb\xcb\x3a\xd5\xe2\x12\xa2\x13\x2d\xd8\x8e\xaf\x5f\x12\x3d\xa0\x08\x05\x08\xb6\x5c\xa5\x65\x38\x04\x45\x99\x1e\xa3\x60\x60\x74\xc5\x41\xa5\x72\x62\x1b\x62\xc5\x1f\x6f\x5f\x1a\x42\xbe\x02\x51\x65\xa8\xae\x23\x18\x6a\xfc\x78\x03\xa9\x4d\x7f\x80\xc3\xfa\xab\x5a\xfc\xa1\x40\xa4\xca\x19\x16\xfe\xb2\xc8\xef\x5e\x73\x0d\xee\x77\xbd\x9a\xf6\x79\x98\xbc\xb1\x07\x67\xa2\x15\x0d\xdd\xa0\x58\xc6\x44\x7b\x0a\x3e\x62\x28\x5f\xba\x41\x07\x53\x58\xcf\x11\x7e\x38\x74\xc5\xf8\xff\xb5\x69\x90\x8f\x84\x74\xea\x97\x1b\xaf\x02\x01\x03\xa3\x81\xc0\x30\x81\xbd\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16\x04\x14\xd2\xc4\xb0\xd2\x91\xd4\x4c\x11\x71\xb3\x61\xcb\x3d\xa1\xfe\xdd\xa8\x6a\xd4\xe3\x30\x81\x8d\x06\x03\x55\x1d\x23\x04\x81\x85\x30\x81\x82\x80\x14\xd2\xc4\xb0\xd2\x91\xd4\x4c\x11\x71\xb3\x61\xcb\x3d\xa1\xfe\xdd\xa8\x6a\xd4\xe3\xa1\x67\xa4\x65\x30\x63\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x21\x30\x1f\x06\x03\x55\x04\x0a\x13\x18\x54\x68\x65\x20\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x47\x72\x6f\x75\x70\x2c\x20\x49\x6e\x63\x2e\x31\x31\x30\x2f\x06\x03\x55\x04\x0b\x13\x28\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x43\x6c\x61\x73\x73\x20\x32\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x82\x01\x00\x30\x0c\x06\x03\x55\x1d\x13\x04\x05\x30\x03\x01\x01\xff\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x82\x01\x01\x00\x32\x4b\xf3\xb2\xca\x3e\x91\xfc\x12\xc6\xa1\x07\x8c\x8e\x77\xa0\x33\x06\x14\x5c\x90\x1e\x18\xf7\x08\xa6\x3d\x0a\x19\xf9\x87\x80\x11\x6e\x69\xe4\x96\x17\x30\xff\x34\x91\x63\x72\x38\xee\xcc\x1c\x01\xa3\x1d\x94\x28\xa4\x31\xf6\x7a\xc4\x54\xd7\xf6\xe5\x31\x58\x03\xa2\xcc\xce\x62\xdb\x94\x45\x73\xb5\xbf\x45\xc9\x24\xb5\xd5\x82\x02\xad\x23\x79\x69\x8d\xb8\xb6\x4d\xce\xcf\x4c\xca\x33\x23\xe8\x1c\x88\xaa\x9d\x8b\x41\x6e\x16\xc9\x20\xe5\x89\x9e\xcd\x3b\xda\x70\xf7\x7e\x99\x26\x20\x14\x54\x25\xab\x6e\x73\x85\xe6\x9b\x21\x9d\x0a\x6c\x82\x0e\xa8\xf8\xc2\x0c\xfa\x10\x1e\x6c\x96\xef\x87\x0d\xc4\x0f\x61\x8b\xad\xee\x83\x2b\x95\xf8\x8e\x92\x84\x72\x39\xeb\x20\xea\x83\xed\x83\xcd\x97\x6e\x08\xbc\xeb\x4e\x26\xb6\x73\x2b\xe4\xd3\xf6\x4c\xfe\x26\x71\xe2\x61\x11\x74\x4a\xff\x57\x1a\x87\x0f\x75\x48\x2e\xcf\x51\x69\x17\xa0\x02\x12\x61\x95\xd5\xd1\x40\xb2\x10\x4c\xee\xc4\xac\x10\x43\xa6\xa5\x9e\x0a\xd5\x95\x62\x9a\x0d\xcf\x88\x82\xc5\x32\x0c\xe4\x2b\x9f\x45\xe6\x0d\x9f\x28\x9c\xb1\xb9\x2a\x5a\x57\xad\x37\x0f\xaf\x1d\x7f\xdb\xbd\x9f\x31\x82\x02\x7c\x30\x82\x02\x78\x02\x01\x01\x30\x81\xd6\x30\x81\xca\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x55\x53\x31\x10\x30\x0e\x06\x03\x55\x04\x08\x13\x07\x41\x72\x69\x7a\x6f\x6e\x61\x31\x13\x30\x11\x06\x03\x55\x04\x07\x13\x0a\x53\x63\x6f\x74\x74\x73\x64\x61\x6c\x65\x31\x1a\x30\x18\x06\x03\x55\x04\x0a\x13\x11\x47\x6f\x44\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2c\x20\x49\x6e\x63\x2e\x31\x33\x30\x31\x06\x03\x55\x04\x0b\x13\x2a\x68\x74\x74\x70\x3a\x2f\x2f\x63\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x73\x2e\x67\x6f\x64\x61\x64\x64\x79\x2e\x63\x6f\x6d\x2f\x72\x65\x70\x6f\x73\x69\x74\x6f\x72\x79\x31\x30\x30\x2e\x06\x03\x55\x04\x03\x13\x27\x47\x6f\x20\x44\x61\x64\x64\x79\x20\x53\x65\x63\x75\x72\x65\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x69\x6f\x6e\x20\x41\x75\x74\x68\x6f\x72\x69\x74\x79\x31\x11\x30\x0f\x06\x03\x55\x04\x05\x13\x08\x30\x37\x39\x36\x39\x32\x38\x37\x02\x07\x27\x90\x56\x03\x1f\x49\xcb\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\xa0\x7c\x30\x19\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x09\x03\x31\x0c\x06\x0a\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x04\x30\x1c\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x09\x05\x31\x0f\x17\x0d\x31\x35\x30\x32\x32\x36\x30\x32\x33\x34\x34\x32\x5a\x30\x1c\x06\x0a\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x0b\x31\x0e\x30\x0c\x06\x0a\x2b\x06\x01\x04\x01\x82\x37\x02\x01\x15\x30\x23\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x09\x04\x31\x16\x04\x14\x58\x47\xd0\x15\x1b\xda\xb8\x87\x67\xe8\xb3\xce\x4a\x95\xaf\x3d\x87\xba\x48\xca\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x04\x82\x01\x00\x78\x8e\xb8\x6b\x2c\x74\x7d\xd5\xe3\x30\xb6\x4d\x02\x44\x34\x0a\x96\x36\xad\x8d\x2c\xe8\x97\x60\x11\x56\xb9\xf6\xe1\x67\x31\x54\xc3\x5a\x8c\x61\x08\x24\x7c\x9f\x1c\xf7\x1b\x68\xd8\x14\xec\xf9\x8f\x2a\xc1\x32\x35\x30\x35\x93\x20\x91\x1f\x80\x91\x47\x11\x97\x5b\x94\x9e\xef\x3c\xf0\xfe\x39\xbb\x02\xe0\xdf\x73\x2a\xdb\xee\xa4\xa5\xd6\x06\x1c\x77\xd7\x8d\x55\xa6\x04\x87\x2e\xdf\xcc\x67\xd8\x8f\x84\x02\xe8\x48\x48\x94\x87\x3f\x67\xf9\xcd\x8b\xea\xf7\x14\xaf\x02\xe8\x9c\xc6\x14\x47\x27\xea\x4d\xa5\x7a\x8d\x46\x6b\xe9\xa9\xc8\xa3\x3f\x5a\xda\x8f\x73\x96\x82\xb6\x5d\x4e\xf8\x30\xc3\xbc\xf6\x13\x43\xb1\xb6\x8d\xd3\x4d\x4d\x88\xe8\x94\xa3\x87\x7f\x2a\x25\x48\xa3\x89\x9a\x9b\x7d\x2b\x21\xf4\xf6\x00\x55\xe8\x59\x7e\xd4\x68\xc8\xe2\x26\x5b\xdb\x6a\x26\x81\x31\xd9\x5d\x12\xa8\x9c\xf0\xb8\x68\x16\x72\xe0\xc1\x08\xef\x3a\xa7\x54\x34\xe4\xc8\x83\x6e\xbb\xe9\xcd\x85\x17\x56\xdc\x4d\x29\xc1\x69\x3f\x6b\xbc\x27\x09\x90\x2f\x5f\x76\x81\x85\xeb\x1d\x63\x48\x45\x5f\x18\x83\x97\x2a\x2f\xa1\xee\x48\xaa\x9f\x57\x8b\xbe\x04\x4b\xd6\x19\x00\x00\x00\x00\x00" + +func systray_dll_bytes() ([]byte, error) { + return bindata_read( + _systray_dll, + "systray.dll", + ) +} + +func systray_dll() (*asset, error) { + bytes, err := systray_dll_bytes() + if err != nil { + return nil, err + } + + info := bindata_file_info{name: "systray.dll", size: 60776, mode: os.FileMode(420), modTime: time.Unix(1424918082, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _systray_unsigned_dll = "\x4d\x5a\x90\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x0e\x1f\xba\x0e\x00\xb4\x09\xcd\x21\xb8\x01\x4c\xcd\x21\x54\x68\x69\x73\x20\x70\x72\x6f\x67\x72\x61\x6d\x20\x63\x61\x6e\x6e\x6f\x74\x20\x62\x65\x20\x72\x75\x6e\x20\x69\x6e\x20\x44\x4f\x53\x20\x6d\x6f\x64\x65\x2e\x0d\x0d\x0a\x24\x00\x00\x00\x00\x00\x00\x00\x2c\xc1\x75\x30\x68\xa0\x1b\x63\x68\xa0\x1b\x63\x68\xa0\x1b\x63\x76\xf2\x9f\x63\x76\xa0\x1b\x63\x76\xf2\x8e\x63\x78\xa0\x1b\x63\x76\xf2\x98\x63\x35\xa0\x1b\x63\x4f\x66\x60\x63\x6f\xa0\x1b\x63\x68\xa0\x1a\x63\x02\xa0\x1b\x63\x76\xf2\x91\x63\x6b\xa0\x1b\x63\x76\xf2\x89\x63\x69\xa0\x1b\x63\x76\xf2\x8a\x63\x69\xa0\x1b\x63\x52\x69\x63\x68\x68\xa0\x1b\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x45\x00\x00\x4c\x01\x05\x00\x6d\x78\xee\x54\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x02\x21\x0b\x01\x09\x00\x00\x92\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x50\x19\x00\x00\x00\x10\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x10\x00\x10\x00\x00\x00\x02\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x30\x01\x00\x00\x04\x00\x00\x60\x15\x01\x00\x02\x00\x40\x01\x00\x00\x10\x00\x00\x10\x00\x00\x00\x00\x10\x00\x00\x10\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x70\xd1\x00\x00\xa1\x00\x00\x00\x14\xc9\x00\x00\x50\x00\x00\x00\x00\x10\x01\x00\xb4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x01\x00\xb4\x08\x00\x00\xb0\xb1\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\xc4\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x78\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x74\x65\x78\x74\x00\x00\x00\x64\x90\x00\x00\x00\x10\x00\x00\x00\x92\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x60\x2e\x72\x64\x61\x74\x61\x00\x00\x11\x22\x00\x00\x00\xb0\x00\x00\x00\x24\x00\x00\x00\x96\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x40\x2e\x64\x61\x74\x61\x00\x00\x00\x68\x2e\x00\x00\x00\xe0\x00\x00\x00\x10\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\xc0\x2e\x72\x73\x72\x63\x00\x00\x00\xb4\x01\x00\x00\x00\x10\x01\x00\x00\x02\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x40\x2e\x72\x65\x6c\x6f\x63\x00\x00\x1c\x0f\x00\x00\x00\x20\x01\x00\x00\x10\x00\x00\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\xc2\x0c\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xec\x0c\x56\x8b\xf0\x8d\x45\xf8\x50\xff\x15\x6c\xb1\x00\x10\x85\xc0\x75\x38\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x00\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x36\x05\x00\x00\x83\xc4\x10\x5e\x8b\xe5\x5d\xc3\x56\xff\x15\x68\xb1\x00\x10\x8b\x4d\xfc\x8b\x55\xf8\xa1\x48\xf9\x00\x10\x6a\x00\x56\x6a\x00\x51\x52\x6a\x20\x50\xff\x15\x64\xb1\x00\x10\x5e\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xe4\xf8\x8b\x4d\x0c\x83\xec\x34\x8b\xc1\x83\xe8\x02\x56\x0f\x84\xe9\x00\x00\x00\x2d\x24\x01\x00\x00\x74\x5e\x2d\xdb\x02\x00\x00\x74\x1a\x8b\x45\x14\x8b\x55\x10\x50\x8b\x45\x08\x52\x51\x50\xff\x15\x58\xb1\x00\x10\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x4d\x14\x8b\xc1\x2d\x02\x02\x00\x00\x74\x20\x83\xe8\x03\x74\x1b\x8b\x55\x08\x51\x8b\x4d\x10\x51\x68\x01\x04\x00\x00\x52\xff\x15\x58\xb1\x00\x10\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x45\x08\xe8\x0c\xff\xff\xff\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x4d\x10\x8b\x15\x48\xf9\x00\x10\x8d\x44\x24\x08\x50\x6a\x01\x51\x52\xc7\x44\x24\x18\x30\x00\x00\x00\xc7\x44\x24\x1c\x20\x00\x00\x00\xff\x15\x60\xb1\x00\x10\x85\xc0\x75\x3c\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x18\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x24\x04\x00\x00\x83\xc4\x10\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x8b\x44\x24\x28\x83\xf8\xff\x74\x1b\x50\xff\x15\x44\xf9\x00\x10\x83\xc4\x04\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\x6a\x00\xff\x15\x5c\xb1\x00\x10\x33\xc0\x5e\x8b\xe5\x5d\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xec\x30\x56\x8b\x35\x54\xb1\x00\x10\x68\x00\x7f\x00\x00\x6a\x00\xc7\x45\xd0\x30\x00\x00\x00\xc7\x45\xd4\x03\x00\x00\x00\xc7\x45\xd8\x90\x10\x00\x10\xc7\x45\xdc\x00\x00\x00\x00\xc7\x45\xe0\x00\x00\x00\x00\x89\x45\xe4\xff\xd6\x68\x00\x7f\x00\x00\x6a\x00\x89\x45\xe8\xff\x15\x50\xb1\x00\x10\x68\x00\x7f\x00\x00\x6a\x00\x89\x45\xec\xc7\x45\xf0\x06\x00\x00\x00\xc7\x45\xf4\x00\x00\x00\x00\xc7\x45\xf8\x30\xc4\x00\x10\xff\xd6\x8d\x4d\xd0\x51\x89\x45\xfc\xff\x15\x4c\xb1\x00\x10\x5e\x8b\xe5\x5d\xc3\xcc\xa1\x4c\xf9\x00\x10\x68\x50\xf9\x00\x10\x6a\x00\xc7\x05\x50\xf9\x00\x10\xbc\x03\x00\x00\xa3\x54\xf9\x00\x10\xc7\x05\x58\xf9\x00\x10\x64\x00\x00\x00\xc7\x05\x60\xf9\x00\x10\x01\x04\x00\x00\xc7\x05\x5c\xf9\x00\x10\x01\x00\x00\x00\xff\x15\x18\xb1\x00\x10\xc3\x55\x8b\xec\x8b\x45\x0c\x83\xec\x38\x56\x6a\x00\xa3\x44\xf9\x00\x10\xff\x15\x08\xb0\x00\x10\x8b\xf0\xe8\x22\xff\xff\xff\x6a\x00\x56\x6a\x00\x6a\x00\x6a\x00\x68\x00\x00\x00\x80\x6a\x00\x68\x00\x00\x00\x80\x68\x00\x00\xcf\x00\x68\x2c\xc4\x00\x10\x68\x30\xc4\x00\x10\x6a\x00\xff\x15\x48\xb1\x00\x10\x8b\xf0\x85\xf6\x74\x10\x6a\x00\x56\xff\x15\x44\xb1\x00\x10\x56\xff\x15\x70\xb1\x00\x10\x89\x35\x4c\xf9\x00\x10\x85\xf6\x0f\x84\x89\x00\x00\x00\xff\x15\x40\xb1\x00\x10\x8d\x4d\xe4\x51\x50\xa3\x48\xf9\x00\x10\xc7\x45\xe4\x1c\x00\x00\x00\xc7\x45\xe8\x10\x00\x00\x80\xc7\x45\xec\x00\x00\x00\x08\xff\x15\x3c\xb1\x00\x10\x85\xc0\x74\x5a\xe8\x1e\xff\xff\xff\x85\xc0\x74\x51\x6a\x00\xff\x55\x08\x8b\x35\x38\xb1\x00\x10\x83\xc4\x04\x6a\x00\x6a\x00\x6a\x00\x8d\x55\xc8\x52\xff\xd6\x85\xc0\x74\x2c\x53\x8b\x1d\x30\xb1\x00\x10\x57\x8b\x3d\x34\xb1\x00\x10\x8d\x45\xc8\x50\xff\xd7\x8d\x4d\xc8\x51\xff\xd3\x6a\x00\x6a\x00\x6a\x00\x8d\x55\xc8\x52\xff\xd6\x85\xc0\x75\xe4\x5f\x5b\x33\xc0\x5e\x8b\xe5\x5d\xc3\xb8\x01\x00\x00\x00\x5e\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x8b\x45\x08\x6a\x10\x6a\x40\x6a\x40\x6a\x01\x50\x6a\x00\xff\x15\x2c\xb1\x00\x10\x85\xc0\x75\x37\x56\xff\x15\x00\xb0\x00\x10\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x4c\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\xc1\x01\x00\x00\x83\xc4\x10\x5e\x5d\xc3\x68\x50\xf9\x00\x10\x6a\x01\xa3\x64\xf9\x00\x10\xc7\x05\x5c\xf9\x00\x10\x02\x00\x00\x00\xff\x15\x18\xb1\x00\x10\x5d\xc3\x55\x8b\xec\x8b\x45\x08\x68\x80\x00\x00\x00\x50\x68\x80\x00\x00\x00\x68\x68\xf9\x00\x10\xe8\x47\x02\x00\x00\x83\xc4\x10\x68\x50\xf9\x00\x10\x6a\x01\xc7\x05\x5c\xf9\x00\x10\x04\x00\x00\x00\xff\x15\x18\xb1\x00\x10\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x83\xe4\xf8\x83\xec\x64\x8b\x45\x0c\x53\x56\x57\x33\xff\xc7\x44\x24\x10\x30\x00\x00\x00\xc7\x44\x24\x14\x61\x01\x00\x00\x89\x7c\x24\x18\x89\x44\x24\x34\x8d\x50\x02\x8d\x64\x24\x00\x66\x8b\x08\x83\xc0\x02\x66\x3b\xcf\x75\xf5\x2b\xc2\xd1\xf8\x40\x89\x44\x24\x38\x8b\x45\x08\x89\x44\x24\x30\xb8\x01\x00\x00\x00\x89\x7c\x24\x1c\x66\x39\x45\x14\x75\x08\xc7\x44\x24\x1c\x03\x00\x00\x00\x66\x39\x45\x18\x75\x05\x83\x4c\x24\x1c\x08\x8b\x0d\x48\xf9\x00\x10\x51\xff\x15\x28\xb1\x00\x10\x8b\xf0\x3b\xfe\x89\x74\x24\x0c\x0f\x8d\x91\x00\x00\x00\x8b\x1d\x00\xb0\x00\x10\x8b\xff\xa1\x48\xf9\x00\x10\x8d\x54\x24\x40\x52\x6a\x01\x57\x50\xc7\x44\x24\x50\x30\x00\x00\x00\xc7\x44\x24\x54\x20\x00\x00\x00\xff\x15\x60\xb1\x00\x10\x85\xc0\x75\x35\xff\xd3\x6a\x00\x6a\x00\x6a\x00\x6a\x00\x8b\xf0\x56\x6a\x00\x68\x00\x31\x00\x00\xff\x15\x04\xb0\x00\x10\x6a\x00\x56\x68\x18\xc4\x00\x10\x68\xe4\xc3\x00\x10\xe8\x79\x00\x00\x00\x8b\x74\x24\x1c\x83\xc4\x10\xeb\x0e\x8b\x44\x24\x60\x83\xf8\xff\x74\x05\x39\x45\x08\x74\x07\x47\x3b\xfe\x7c\x90\xeb\x15\x8b\x15\x48\xf9\x00\x10\x8d\x4c\x24\x10\x51\x6a\x01\x57\x52\xff\x15\x24\xb1\x00\x10\x3b\xfe\x75\x16\x8b\x0d\x48\xf9\x00\x10\x8d\x44\x24\x10\x50\x6a\x01\x6a\xff\x51\xff\x15\x20\xb1\x00\x10\x5f\x5e\x5b\x8b\xe5\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x68\x50\xf9\x00\x10\x6a\x02\xff\x15\x18\xb1\x00\x10\xc3\x3b\x0d\x00\xe0\x00\x10\x75\x02\xf3\xc3\xe9\xe6\x03\x00\x00\x6a\x0c\x68\x60\xc5\x00\x10\xe8\x13\x16\x00\x00\x33\xc0\x33\xf6\x39\x75\x08\x0f\x95\xc0\x3b\xc6\x75\x1d\xe8\xb6\x15\x00\x00\xc7\x00\x16\x00\x00\x00\x56\x56\x56\x56\x56\xe8\x3e\x15\x00\x00\x83\xc4\x14\x83\xc8\xff\xeb\x5f\xe8\xb0\x04\x00\x00\x6a\x20\x5b\x03\xc3\x50\x6a\x01\xe8\xbb\x05\x00\x00\x59\x59\x89\x75\xfc\xe8\x99\x04\x00\x00\x03\xc3\x50\xe8\x46\x06\x00\x00\x59\x8b\xf8\x8d\x45\x0c\x50\x56\xff\x75\x08\xe8\x81\x04\x00\x00\x03\xc3\x50\xe8\x2b\x08\x00\x00\x89\x45\xe4\xe8\x71\x04\x00\x00\x03\xc3\x50\x57\xe8\xb9\x06\x00\x00\x83\xc4\x18\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\xc9\x15\x00\x00\xc3\xe8\x4b\x04\x00\x00\x83\xc0\x20\x50\x6a\x01\xe8\xc6\x05\x00\x00\x59\x59\xc3\xa1\x00\xe0\x00\x10\x83\xc8\x01\x33\xc9\x39\x05\xe0\xee\x00\x10\x0f\x94\xc1\x8b\xc1\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x57\x33\xff\x39\x7d\x14\x75\x10\x3b\xf7\x75\x10\x39\x7d\x0c\x75\x12\x33\xc0\x5f\x5e\x5b\x5d\xc3\x3b\xf7\x74\x07\x8b\x5d\x0c\x3b\xdf\x77\x1b\xe8\xde\x14\x00\x00\x6a\x16\x5e\x89\x30\x57\x57\x57\x57\x57\xe8\x67\x14\x00\x00\x83\xc4\x14\x8b\xc6\xeb\xd5\x39\x7d\x14\x75\x07\x33\xc0\x66\x89\x06\xeb\xc7\x8b\x55\x10\x3b\xd7\x75\x07\x33\xc0\x66\x89\x06\xeb\xcb\x83\x7d\x14\xff\x8b\xc6\x75\x14\x0f\xb7\x0a\x66\x89\x08\x40\x40\x42\x42\x66\x3b\xcf\x74\x26\x4b\x75\xee\xeb\x21\x0f\xb7\x0a\x66\x89\x08\x40\x40\x42\x42\x66\x3b\xcf\x74\x08\x4b\x74\x05\xff\x4d\x14\x75\xe9\x39\x7d\x14\x75\x05\x33\xc9\x66\x89\x08\x3b\xdf\x0f\x85\x74\xff\xff\xff\x33\xc0\x83\x7d\x14\xff\x75\x10\x8b\x4d\x0c\x6a\x50\x66\x89\x44\x4e\xfe\x58\xe9\x5e\xff\xff\xff\x66\x89\x06\xe8\x49\x14\x00\x00\x6a\x22\x59\x89\x08\x8b\xf1\xe9\x64\xff\xff\xff\x8b\xff\x55\x8b\xec\x8b\x45\x0c\x56\x57\x83\xf8\x01\x75\x7c\x50\xe8\x45\x28\x00\x00\x59\x85\xc0\x75\x07\x33\xc0\xe9\x0e\x01\x00\x00\xe8\xcf\x1a\x00\x00\x85\xc0\x75\x07\xe8\x5c\x28\x00\x00\xeb\xe9\xe8\xd8\x27\x00\x00\xff\x15\x4c\xb0\x00\x10\xa3\x64\x0e\x01\x10\xe8\x91\x26\x00\x00\xa3\xe8\xee\x00\x10\xe8\xb2\x20\x00\x00\x85\xc0\x7d\x07\xe8\x48\x17\x00\x00\xeb\xcf\xe8\xbc\x25\x00\x00\x85\xc0\x7c\x20\xe8\x3b\x23\x00\x00\x85\xc0\x7c\x17\x6a\x00\xe8\x6a\x1e\x00\x00\x59\x85\xc0\x75\x0b\xff\x05\xe4\xee\x00\x10\xe9\xa8\x00\x00\x00\xe8\xcd\x22\x00\x00\xeb\xc9\x33\xff\x3b\xc7\x75\x31\x39\x3d\xe4\xee\x00\x10\x7e\x81\xff\x0d\xe4\xee\x00\x10\x39\x3d\x6c\xf2\x00\x10\x75\x05\xe8\xf9\x1f\x00\x00\x39\x7d\x10\x75\x7b\xe8\xa0\x22\x00\x00\xe8\xe6\x16\x00\x00\xe8\xcb\x27\x00\x00\xeb\x6a\x83\xf8\x02\x75\x59\xe8\xa1\x16\x00\x00\x68\x14\x02\x00\x00\x6a\x01\xe8\x7d\x1c\x00\x00\x8b\xf0\x59\x59\x3b\xf7\x0f\x84\x36\xff\xff\xff\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\xfc\x15\x00\x00\x59\xff\xd0\x85\xc0\x74\x17\x57\x56\xe8\xda\x16\x00\x00\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\xeb\x18\x56\xe8\x68\x1b\x00\x00\x59\xe9\xfa\xfe\xff\xff\x83\xf8\x03\x75\x07\x57\xe8\x5c\x19\x00\x00\x59\x33\xc0\x40\x5f\x5e\x5d\xc2\x0c\x00\x6a\x0c\x68\x80\xc5\x00\x10\xe8\x46\x13\x00\x00\x8b\xf9\x8b\xf2\x8b\x5d\x08\x33\xc0\x40\x89\x45\xe4\x85\xf6\x75\x0c\x39\x15\xe4\xee\x00\x10\x0f\x84\xc5\x00\x00\x00\x83\x65\xfc\x00\x3b\xf0\x74\x05\x83\xfe\x02\x75\x2e\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x08\x57\x56\x53\xff\xd0\x89\x45\xe4\x83\x7d\xe4\x00\x0f\x84\x96\x00\x00\x00\x57\x56\x53\xe8\x72\xfe\xff\xff\x89\x45\xe4\x85\xc0\x0f\x84\x83\x00\x00\x00\x57\x56\x53\xe8\x3a\xf7\xff\xff\x89\x45\xe4\x83\xfe\x01\x75\x24\x85\xc0\x75\x20\x57\x50\x53\xe8\x26\xf7\xff\xff\x57\x6a\x00\x53\xe8\x42\xfe\xff\xff\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x06\x57\x6a\x00\x53\xff\xd0\x85\xf6\x74\x05\x83\xfe\x03\x75\x26\x57\x56\x53\xe8\x22\xfe\xff\xff\x85\xc0\x75\x03\x21\x45\xe4\x83\x7d\xe4\x00\x74\x11\xa1\xcc\xb1\x00\x10\x85\xc0\x74\x08\x57\x56\x53\xff\xd0\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xeb\x1d\x8b\x45\xec\x8b\x08\x8b\x09\x50\x51\xe8\x4a\x28\x00\x00\x59\x59\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x33\xc0\xe8\xa2\x12\x00\x00\xc3\x8b\xff\x55\x8b\xec\x83\x7d\x0c\x01\x75\x05\xe8\x45\x28\x00\x00\xff\x75\x08\x8b\x4d\x10\x8b\x55\x0c\xe8\xec\xfe\xff\xff\x59\x5d\xc2\x0c\x00\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa3\x00\xf0\x00\x10\x89\x0d\xfc\xef\x00\x10\x89\x15\xf8\xef\x00\x10\x89\x1d\xf4\xef\x00\x10\x89\x35\xf0\xef\x00\x10\x89\x3d\xec\xef\x00\x10\x66\x8c\x15\x18\xf0\x00\x10\x66\x8c\x0d\x0c\xf0\x00\x10\x66\x8c\x1d\xe8\xef\x00\x10\x66\x8c\x05\xe4\xef\x00\x10\x66\x8c\x25\xe0\xef\x00\x10\x66\x8c\x2d\xdc\xef\x00\x10\x9c\x8f\x05\x10\xf0\x00\x10\x8b\x45\x00\xa3\x04\xf0\x00\x10\x8b\x45\x04\xa3\x08\xf0\x00\x10\x8d\x45\x08\xa3\x14\xf0\x00\x10\x8b\x85\xe0\xfc\xff\xff\xc7\x05\x50\xef\x00\x10\x01\x00\x01\x00\xa1\x08\xf0\x00\x10\xa3\x04\xef\x00\x10\xc7\x05\xf8\xee\x00\x10\x09\x04\x00\xc0\xc7\x05\xfc\xee\x00\x10\x01\x00\x00\x00\xa1\x00\xe0\x00\x10\x89\x85\xd8\xfc\xff\xff\xa1\x04\xe0\x00\x10\x89\x85\xdc\xfc\xff\xff\xff\x15\x60\xb0\x00\x10\xa3\x48\xef\x00\x10\x6a\x01\xe8\xfb\x27\x00\x00\x59\x6a\x00\xff\x15\x5c\xb0\x00\x10\x68\xd0\xb1\x00\x10\xff\x15\x58\xb0\x00\x10\x83\x3d\x48\xef\x00\x10\x00\x75\x08\x6a\x01\xe8\xd7\x27\x00\x00\x59\x68\x09\x04\x00\xc0\xff\x15\x54\xb0\x00\x10\x50\xff\x15\x50\xb0\x00\x10\xc9\xc3\xb8\x08\xe0\x00\x10\xc3\xa1\x60\x0e\x01\x10\x56\x6a\x14\x5e\x85\xc0\x75\x07\xb8\x00\x02\x00\x00\xeb\x06\x3b\xc6\x7d\x07\x8b\xc6\xa3\x60\x0e\x01\x10\x6a\x04\x50\xe8\xd4\x19\x00\x00\x59\x59\xa3\x5c\xfe\x00\x10\x85\xc0\x75\x1e\x6a\x04\x56\x89\x35\x60\x0e\x01\x10\xe8\xbb\x19\x00\x00\x59\x59\xa3\x5c\xfe\x00\x10\x85\xc0\x75\x05\x6a\x1a\x58\x5e\xc3\x33\xd2\xb9\x08\xe0\x00\x10\xeb\x05\xa1\x5c\xfe\x00\x10\x89\x0c\x02\x83\xc1\x20\x83\xc2\x04\x81\xf9\x88\xe2\x00\x10\x7c\xea\x6a\xfe\x5e\x33\xd2\xb9\x18\xe0\x00\x10\x57\x8b\xc2\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x8b\xfa\x83\xe7\x1f\xc1\xe7\x06\x8b\x04\x07\x83\xf8\xff\x74\x08\x3b\xc6\x74\x04\x85\xc0\x75\x02\x89\x31\x83\xc1\x20\x42\x81\xf9\x78\xe0\x00\x10\x7c\xce\x5f\x33\xc0\x5e\xc3\xe8\x37\x29\x00\x00\x80\x3d\x68\xf2\x00\x10\x00\x74\x05\xe8\x00\x27\x00\x00\xff\x35\x5c\xfe\x00\x10\xe8\x59\x18\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\xb8\x08\xe0\x00\x10\x3b\xf0\x72\x22\x81\xfe\x68\xe2\x00\x10\x77\x1a\x8b\xce\x2b\xc8\xc1\xf9\x05\x83\xc1\x10\x51\xe8\x77\x2a\x00\x00\x81\x4e\x0c\x00\x80\x00\x00\x59\xeb\x0a\x83\xc6\x20\x56\xff\x15\x64\xb0\x00\x10\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\x14\x7d\x16\x83\xc0\x10\x50\xe8\x4a\x2a\x00\x00\x8b\x45\x0c\x81\x48\x0c\x00\x80\x00\x00\x59\x5d\xc3\x8b\x45\x0c\x83\xc0\x20\x50\xff\x15\x64\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xb9\x08\xe0\x00\x10\x3b\xc1\x72\x1f\x3d\x68\xe2\x00\x10\x77\x18\x81\x60\x0c\xff\x7f\xff\xff\x2b\xc1\xc1\xf8\x05\x83\xc0\x10\x50\xe8\x27\x29\x00\x00\x59\x5d\xc3\x83\xc0\x20\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x83\xf9\x14\x8b\x45\x0c\x7d\x13\x81\x60\x0c\xff\x7f\xff\xff\x83\xc1\x10\x51\xe8\xf8\x28\x00\x00\x59\x5d\xc3\x83\xc0\x20\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x56\xe8\x4b\x2a\x00\x00\x50\xe8\xe1\x29\x00\x00\x59\x59\x85\xc0\x74\x7c\xe8\x2b\xfe\xff\xff\x83\xc0\x20\x3b\xf0\x75\x04\x33\xc0\xeb\x0f\xe8\x1b\xfe\xff\xff\x83\xc0\x40\x3b\xf0\x75\x60\x33\xc0\x40\xff\x05\x1c\xf2\x00\x10\xf7\x46\x0c\x0c\x01\x00\x00\x75\x4e\x53\x57\x8d\x3c\x85\x20\xf2\x00\x10\x83\x3f\x00\xbb\x00\x10\x00\x00\x75\x20\x53\xe8\xa5\x17\x00\x00\x59\x89\x07\x85\xc0\x75\x13\x8d\x46\x14\x6a\x02\x89\x46\x08\x89\x06\x58\x89\x46\x18\x89\x46\x04\xeb\x0d\x8b\x3f\x89\x7e\x08\x89\x3e\x89\x5e\x18\x89\x5e\x04\x81\x4e\x0c\x02\x11\x00\x00\x33\xc0\x5f\x40\x5b\xeb\x02\x33\xc0\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\x7d\x08\x00\x74\x27\x56\x8b\x75\x0c\xf7\x46\x0c\x00\x10\x00\x00\x74\x19\x56\xe8\xfa\x25\x00\x00\x81\x66\x0c\xff\xee\xff\xff\x83\x66\x18\x00\x83\x26\x00\x83\x66\x08\x00\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x8b\xf1\xc6\x46\x0c\x00\x85\xc0\x75\x63\xe8\x4d\x13\x00\x00\x89\x46\x08\x8b\x48\x6c\x89\x0e\x8b\x48\x68\x89\x4e\x04\x8b\x0e\x3b\x0d\x90\xeb\x00\x10\x74\x12\x8b\x0d\xac\xea\x00\x10\x85\x48\x70\x75\x07\xe8\x0e\x33\x00\x00\x89\x06\x8b\x46\x04\x3b\x05\xb0\xe9\x00\x10\x74\x16\x8b\x46\x08\x8b\x0d\xac\xea\x00\x10\x85\x48\x70\x75\x08\xe8\x82\x2b\x00\x00\x89\x46\x04\x8b\x46\x08\xf6\x40\x70\x02\x75\x14\x83\x48\x70\x02\xc6\x46\x0c\x01\xeb\x0a\x8b\x08\x89\x0e\x8b\x40\x04\x89\x46\x04\x8b\xc6\x5e\x5d\xc2\x04\x00\xf6\x41\x0c\x40\x74\x06\x83\x79\x08\x00\x74\x24\xff\x49\x04\x78\x0b\x8b\x11\x88\x02\xff\x01\x0f\xb6\xc0\xeb\x0c\x0f\xbe\xc0\x51\x50\xe8\x17\x33\x00\x00\x59\x59\x83\xf8\xff\x75\x03\x09\x06\xc3\xff\x06\xc3\x8b\xff\x55\x8b\xec\x56\x8b\xf0\xeb\x13\x8b\x4d\x10\x8a\x45\x08\xff\x4d\x0c\xe8\xb5\xff\xff\xff\x83\x3e\xff\x74\x06\x83\x7d\x0c\x00\x7f\xe7\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\xf6\x47\x0c\x40\x53\x56\x8b\xf0\x8b\xd9\x74\x32\x83\x7f\x08\x00\x75\x2c\x8b\x45\x08\x01\x06\xeb\x2b\x8a\x03\xff\x4d\x08\x8b\xcf\xe8\x7d\xff\xff\xff\x43\x83\x3e\xff\x75\x13\xe8\x4f\x0d\x00\x00\x83\x38\x2a\x75\x0f\x8b\xcf\xb0\x3f\xe8\x64\xff\xff\xff\x83\x7d\x08\x00\x7f\xd5\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x78\x02\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x8b\x5d\x0c\x56\x8b\x75\x08\x33\xc0\x57\x8b\x7d\x14\xff\x75\x10\x8d\x8d\xa4\xfd\xff\xff\x89\xb5\xb4\xfd\xff\xff\x89\xbd\xdc\xfd\xff\xff\x89\x85\xb8\xfd\xff\xff\x89\x85\xf0\xfd\xff\xff\x89\x85\xcc\xfd\xff\xff\x89\x85\xe8\xfd\xff\xff\x89\x85\xd0\xfd\xff\xff\x89\x85\xc0\xfd\xff\xff\x89\x85\xc8\xfd\xff\xff\xe8\x6c\xfe\xff\xff\x85\xf6\x75\x35\xe8\xc7\x0c\x00\x00\xc7\x00\x16\x00\x00\x00\x33\xc0\x50\x50\x50\x50\x50\xe8\x4d\x0c\x00\x00\x83\xc4\x14\x80\xbd\xb0\xfd\xff\xff\x00\x74\x0a\x8b\x85\xac\xfd\xff\xff\x83\x60\x70\xfd\x83\xc8\xff\xe9\xc8\x0a\x00\x00\xf6\x46\x0c\x40\x75\x5e\x56\xe8\xb1\x27\x00\x00\x59\xba\x10\xe4\x00\x10\x83\xf8\xff\x74\x1b\x83\xf8\xfe\x74\x16\x8b\xc8\x83\xe1\x1f\x8b\xf0\xc1\xfe\x05\xc1\xe1\x06\x03\x0c\xb5\x40\xfd\x00\x10\xeb\x02\x8b\xca\xf6\x41\x24\x7f\x75\x91\x83\xf8\xff\x74\x19\x83\xf8\xfe\x74\x14\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\xc1\xe0\x06\x03\x04\x8d\x40\xfd\x00\x10\xeb\x02\x8b\xc2\xf6\x40\x24\x80\x0f\x85\x67\xff\xff\xff\x33\xc9\x3b\xd9\x0f\x84\x5d\xff\xff\xff\x8a\x13\x89\x8d\xd8\xfd\xff\xff\x89\x8d\xe0\xfd\xff\xff\x89\x8d\xbc\xfd\xff\xff\x88\x95\xef\xfd\xff\xff\x84\xd2\x0f\x84\x1f\x0a\x00\x00\x43\x83\xbd\xd8\xfd\xff\xff\x00\x89\x9d\xc4\xfd\xff\xff\x0f\x8c\x0b\x0a\x00\x00\x8a\xc2\x2c\x20\x3c\x58\x77\x11\x0f\xbe\xc2\x0f\xbe\x80\xd0\xb1\x00\x10\x83\xe0\x0f\x33\xf6\xeb\x04\x33\xf6\x33\xc0\x0f\xbe\x84\xc1\xf0\xb1\x00\x10\x6a\x07\xc1\xf8\x04\x59\x89\x85\x94\xfd\xff\xff\x3b\xc1\x0f\x87\xad\x09\x00\x00\xff\x24\x85\xa3\x29\x00\x10\x83\x8d\xe8\xfd\xff\xff\xff\x89\xb5\x90\xfd\xff\xff\x89\xb5\xc0\xfd\xff\xff\x89\xb5\xcc\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xb5\xf0\xfd\xff\xff\x89\xb5\xc8\xfd\xff\xff\xe9\x76\x09\x00\x00\x0f\xbe\xc2\x83\xe8\x20\x74\x4a\x83\xe8\x03\x74\x36\x83\xe8\x08\x74\x25\x48\x48\x74\x15\x83\xe8\x03\x0f\x85\x57\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x08\xe9\x4b\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x04\xe9\x3f\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x01\xe9\x33\x09\x00\x00\x81\x8d\xf0\xfd\xff\xff\x80\x00\x00\x00\xe9\x24\x09\x00\x00\x83\x8d\xf0\xfd\xff\xff\x02\xe9\x18\x09\x00\x00\x80\xfa\x2a\x75\x2c\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x3b\xfe\x89\xbd\xcc\xfd\xff\xff\x0f\x8d\xf9\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x04\xf7\x9d\xcc\xfd\xff\xff\xe9\xe7\x08\x00\x00\x8b\x85\xcc\xfd\xff\xff\x6b\xc0\x0a\x0f\xbe\xca\x8d\x44\x08\xd0\x89\x85\xcc\xfd\xff\xff\xe9\xcc\x08\x00\x00\x89\xb5\xe8\xfd\xff\xff\xe9\xc1\x08\x00\x00\x80\xfa\x2a\x75\x26\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x3b\xfe\x89\xbd\xe8\xfd\xff\xff\x0f\x8d\xa2\x08\x00\x00\x83\x8d\xe8\xfd\xff\xff\xff\xe9\x96\x08\x00\x00\x8b\x85\xe8\xfd\xff\xff\x6b\xc0\x0a\x0f\xbe\xca\x8d\x44\x08\xd0\x89\x85\xe8\xfd\xff\xff\xe9\x7b\x08\x00\x00\x80\xfa\x49\x74\x55\x80\xfa\x68\x74\x44\x80\xfa\x6c\x74\x18\x80\xfa\x77\x0f\x85\x63\x08\x00\x00\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\xe9\x54\x08\x00\x00\x80\x3b\x6c\x75\x16\x43\x81\x8d\xf0\xfd\xff\xff\x00\x10\x00\x00\x89\x9d\xc4\xfd\xff\xff\xe9\x39\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x10\xe9\x2d\x08\x00\x00\x83\x8d\xf0\xfd\xff\xff\x20\xe9\x21\x08\x00\x00\x8a\x03\x3c\x36\x75\x1d\x80\x7b\x01\x34\x75\x17\x43\x43\x81\x8d\xf0\xfd\xff\xff\x00\x80\x00\x00\x89\x9d\xc4\xfd\xff\xff\xe9\xfe\x07\x00\x00\x3c\x33\x75\x1d\x80\x7b\x01\x32\x75\x17\x43\x43\x81\xa5\xf0\xfd\xff\xff\xff\x7f\xff\xff\x89\x9d\xc4\xfd\xff\xff\xe9\xdd\x07\x00\x00\x3c\x64\x0f\x84\xd5\x07\x00\x00\x3c\x69\x0f\x84\xcd\x07\x00\x00\x3c\x6f\x0f\x84\xc5\x07\x00\x00\x3c\x75\x0f\x84\xbd\x07\x00\x00\x3c\x78\x0f\x84\xb5\x07\x00\x00\x3c\x58\x0f\x84\xad\x07\x00\x00\x89\xb5\x94\xfd\xff\xff\x8d\x85\xa4\xfd\xff\xff\x50\x0f\xb6\xc2\x50\x89\xb5\xc8\xfd\xff\xff\xe8\xa0\x32\x00\x00\x59\x85\xc0\x8a\x85\xef\xfd\xff\xff\x59\x74\x22\x8b\x8d\xb4\xfd\xff\xff\x8d\xb5\xd8\xfd\xff\xff\xe8\xa4\xfb\xff\xff\x8a\x03\x43\x89\x9d\xc4\xfd\xff\xff\x84\xc0\x0f\x84\xa4\xfc\xff\xff\x8b\x8d\xb4\xfd\xff\xff\x8d\xb5\xd8\xfd\xff\xff\xe8\x82\xfb\xff\xff\xe9\x4d\x07\x00\x00\x0f\xbe\xc2\x83\xf8\x64\x0f\x8f\xe8\x01\x00\x00\x0f\x84\x79\x02\x00\x00\x83\xf8\x53\x0f\x8f\xf2\x00\x00\x00\x0f\x84\x80\x00\x00\x00\x83\xe8\x41\x74\x10\x48\x48\x74\x58\x48\x48\x74\x08\x48\x48\x0f\x85\x92\x05\x00\x00\x80\xc2\x20\xc7\x85\x90\xfd\xff\xff\x01\x00\x00\x00\x88\x95\xef\xfd\xff\xff\x83\x8d\xf0\xfd\xff\xff\x40\x39\xb5\xe8\xfd\xff\xff\x8d\x9d\xf4\xfd\xff\xff\xb8\x00\x02\x00\x00\x89\x9d\xe4\xfd\xff\xff\x89\x85\xa0\xfd\xff\xff\x0f\x8d\x48\x02\x00\x00\xc7\x85\xe8\xfd\xff\xff\x06\x00\x00\x00\xe9\xa5\x02\x00\x00\xf7\x85\xf0\xfd\xff\xff\x30\x08\x00\x00\x0f\x85\x98\x00\x00\x00\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\xe9\x89\x00\x00\x00\xf7\x85\xf0\xfd\xff\xff\x30\x08\x00\x00\x75\x0a\x81\x8d\xf0\xfd\xff\xff\x00\x08\x00\x00\x8b\x8d\xe8\xfd\xff\xff\x83\xf9\xff\x75\x05\xb9\xff\xff\xff\x7f\x83\xc7\x04\xf7\x85\xf0\xfd\xff\xff\x10\x08\x00\x00\x89\xbd\xdc\xfd\xff\xff\x8b\x7f\xfc\x89\xbd\xe4\xfd\xff\xff\x0f\x84\xb1\x04\x00\x00\x3b\xfe\x75\x0b\xa1\x8c\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x8b\x85\xe4\xfd\xff\xff\xc7\x85\xc8\xfd\xff\xff\x01\x00\x00\x00\xe9\x7f\x04\x00\x00\x83\xe8\x58\x0f\x84\xda\x02\x00\x00\x48\x48\x74\x79\x2b\xc1\x0f\x84\x27\xff\xff\xff\x48\x48\x0f\x85\x9e\x04\x00\x00\x83\xc7\x04\xf7\x85\xf0\xfd\xff\xff\x10\x08\x00\x00\x89\xbd\xdc\xfd\xff\xff\x74\x30\x0f\xb7\x47\xfc\x50\x68\x00\x02\x00\x00\x8d\x85\xf4\xfd\xff\xff\x50\x8d\x85\xe0\xfd\xff\xff\x50\xe8\xe3\x30\x00\x00\x83\xc4\x10\x85\xc0\x74\x1f\xc7\x85\xc0\xfd\xff\xff\x01\x00\x00\x00\xeb\x13\x8a\x47\xfc\x88\x85\xf4\xfd\xff\xff\xc7\x85\xe0\xfd\xff\xff\x01\x00\x00\x00\x8d\x85\xf4\xfd\xff\xff\x89\x85\xe4\xfd\xff\xff\xe9\x35\x04\x00\x00\x8b\x07\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\x3b\xc6\x74\x3b\x8b\x48\x04\x3b\xce\x74\x34\xf7\x85\xf0\xfd\xff\xff\x00\x08\x00\x00\x0f\xbf\x00\x89\x8d\xe4\xfd\xff\xff\x74\x14\x99\x2b\xc2\xd1\xf8\xc7\x85\xc8\xfd\xff\xff\x01\x00\x00\x00\xe9\xf0\x03\x00\x00\x89\xb5\xc8\xfd\xff\xff\xe9\xe5\x03\x00\x00\xa1\x88\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x50\xe8\x5a\x2e\x00\x00\x59\xe9\xce\x03\x00\x00\x83\xf8\x70\x0f\x8f\xfb\x01\x00\x00\x0f\x84\xe3\x01\x00\x00\x83\xf8\x65\x0f\x8c\xbc\x03\x00\x00\x83\xf8\x67\x0f\x8e\x34\xfe\xff\xff\x83\xf8\x69\x74\x71\x83\xf8\x6e\x74\x28\x83\xf8\x6f\x0f\x85\xa0\x03\x00\x00\xf6\x85\xf0\xfd\xff\xff\x80\xc7\x85\xe0\xfd\xff\xff\x08\x00\x00\x00\x74\x61\x81\x8d\xf0\xfd\xff\xff\x00\x02\x00\x00\xeb\x55\x8b\x37\x83\xc7\x04\x89\xbd\xdc\xfd\xff\xff\xe8\xdd\xf1\xff\xff\x85\xc0\x0f\x84\x2f\xfa\xff\xff\xf6\x85\xf0\xfd\xff\xff\x20\x74\x0c\x66\x8b\x85\xd8\xfd\xff\xff\x66\x89\x06\xeb\x08\x8b\x85\xd8\xfd\xff\xff\x89\x06\xc7\x85\xc0\xfd\xff\xff\x01\x00\x00\x00\xe9\xa6\x04\x00\x00\x83\x8d\xf0\xfd\xff\xff\x40\xc7\x85\xe0\xfd\xff\xff\x0a\x00\x00\x00\x8b\x8d\xf0\xfd\xff\xff\xf7\xc1\x00\x80\x00\x00\x0f\x84\xa9\x01\x00\x00\x8b\x07\x8b\x57\x04\x83\xc7\x08\xe9\xd5\x01\x00\x00\x75\x11\x80\xfa\x67\x75\x65\xc7\x85\xe8\xfd\xff\xff\x01\x00\x00\x00\xeb\x59\x39\x85\xe8\xfd\xff\xff\x7e\x06\x89\x85\xe8\xfd\xff\xff\x81\xbd\xe8\xfd\xff\xff\xa3\x00\x00\x00\x7e\x3f\x8b\xb5\xe8\xfd\xff\xff\x81\xc6\x5d\x01\x00\x00\x56\xe8\x33\x0f\x00\x00\x8a\x95\xef\xfd\xff\xff\x59\x89\x85\xbc\xfd\xff\xff\x85\xc0\x74\x10\x89\x85\xe4\xfd\xff\xff\x89\xb5\xa0\xfd\xff\xff\x8b\xd8\xeb\x0a\xc7\x85\xe8\xfd\xff\xff\xa3\x00\x00\x00\x33\xf6\x8b\x07\x83\xc7\x08\x89\x85\x88\xfd\xff\xff\x8b\x47\xfc\x89\x85\x8c\xfd\xff\xff\x8d\x85\xa4\xfd\xff\xff\x50\xff\xb5\x90\xfd\xff\xff\x0f\xbe\xc2\xff\xb5\xe8\xfd\xff\xff\x89\xbd\xdc\xfd\xff\xff\x50\xff\xb5\xa0\xfd\xff\xff\x8d\x85\x88\xfd\xff\xff\x53\x50\xff\x35\xb8\xeb\x00\x10\xe8\x9e\x08\x00\x00\x59\xff\xd0\x8b\xbd\xf0\xfd\xff\xff\x83\xc4\x1c\x81\xe7\x80\x00\x00\x00\x74\x20\x39\xb5\xe8\xfd\xff\xff\x75\x18\x8d\x85\xa4\xfd\xff\xff\x50\x53\xff\x35\xc4\xeb\x00\x10\xe8\x6f\x08\x00\x00\x59\xff\xd0\x59\x59\x80\xbd\xef\xfd\xff\xff\x67\x75\x1c\x3b\xfe\x75\x18\x8d\x85\xa4\xfd\xff\xff\x50\x53\xff\x35\xc0\xeb\x00\x10\xe8\x4a\x08\x00\x00\x59\xff\xd0\x59\x59\x80\x3b\x2d\x75\x11\x81\x8d\xf0\xfd\xff\xff\x00\x01\x00\x00\x43\x89\x9d\xe4\xfd\xff\xff\x53\xe9\x03\xfe\xff\xff\xc7\x85\xe8\xfd\xff\xff\x08\x00\x00\x00\x89\x8d\xb8\xfd\xff\xff\xeb\x24\x83\xe8\x73\x0f\x84\xb6\xfc\xff\xff\x48\x48\x0f\x84\x89\xfe\xff\xff\x83\xe8\x03\x0f\x85\xb6\x01\x00\x00\xc7\x85\xb8\xfd\xff\xff\x27\x00\x00\x00\xf6\x85\xf0\xfd\xff\xff\x80\xc7\x85\xe0\xfd\xff\xff\x10\x00\x00\x00\x0f\x84\x69\xfe\xff\xff\x8a\x85\xb8\xfd\xff\xff\x04\x51\xc6\x85\xd4\xfd\xff\xff\x30\x88\x85\xd5\xfd\xff\xff\xc7\x85\xd0\xfd\xff\xff\x02\x00\x00\x00\xe9\x45\xfe\xff\xff\xf7\xc1\x00\x10\x00\x00\x0f\x85\x4b\xfe\xff\xff\x83\xc7\x04\xf6\xc1\x20\x74\x18\x89\xbd\xdc\xfd\xff\xff\xf6\xc1\x40\x74\x06\x0f\xbf\x47\xfc\xeb\x04\x0f\xb7\x47\xfc\x99\xeb\x13\x8b\x47\xfc\xf6\xc1\x40\x74\x03\x99\xeb\x02\x33\xd2\x89\xbd\xdc\xfd\xff\xff\xf6\xc1\x40\x74\x1b\x3b\xd6\x7f\x17\x7c\x04\x3b\xc6\x73\x11\xf7\xd8\x83\xd2\x00\xf7\xda\x81\x8d\xf0\xfd\xff\xff\x00\x01\x00\x00\xf7\x85\xf0\xfd\xff\xff\x00\x90\x00\x00\x8b\xda\x8b\xf8\x75\x02\x33\xdb\x83\xbd\xe8\xfd\xff\xff\x00\x7d\x0c\xc7\x85\xe8\xfd\xff\xff\x01\x00\x00\x00\xeb\x1a\x83\xa5\xf0\xfd\xff\xff\xf7\xb8\x00\x02\x00\x00\x39\x85\xe8\xfd\xff\xff\x7e\x06\x89\x85\xe8\xfd\xff\xff\x8b\xc7\x0b\xc3\x75\x06\x21\x85\xd0\xfd\xff\xff\x8d\x75\xf3\x8b\x85\xe8\xfd\xff\xff\xff\x8d\xe8\xfd\xff\xff\x85\xc0\x7f\x06\x8b\xc7\x0b\xc3\x74\x2d\x8b\x85\xe0\xfd\xff\xff\x99\x52\x50\x53\x57\xe8\x7c\x2d\x00\x00\x83\xc1\x30\x83\xf9\x39\x89\x9d\xa0\xfd\xff\xff\x8b\xf8\x8b\xda\x7e\x06\x03\x8d\xb8\xfd\xff\xff\x88\x0e\x4e\xeb\xbd\x8d\x45\xf3\x2b\xc6\x46\xf7\x85\xf0\xfd\xff\xff\x00\x02\x00\x00\x89\x85\xe0\xfd\xff\xff\x89\xb5\xe4\xfd\xff\xff\x74\x61\x85\xc0\x74\x07\x8b\xce\x80\x39\x30\x74\x56\xff\x8d\xe4\xfd\xff\xff\x8b\x8d\xe4\xfd\xff\xff\xc6\x01\x30\x40\xeb\x3e\x49\x66\x39\x30\x74\x06\x40\x40\x3b\xce\x75\xf4\x2b\x85\xe4\xfd\xff\xff\xd1\xf8\xeb\x28\x3b\xfe\x75\x0b\xa1\x88\xe2\x00\x10\x89\x85\xe4\xfd\xff\xff\x8b\x85\xe4\xfd\xff\xff\xeb\x07\x49\x80\x38\x00\x74\x05\x40\x3b\xce\x75\xf5\x2b\x85\xe4\xfd\xff\xff\x89\x85\xe0\xfd\xff\xff\x83\xbd\xc0\xfd\xff\xff\x00\x0f\x85\x5c\x01\x00\x00\x8b\x85\xf0\xfd\xff\xff\xa8\x40\x74\x32\xa9\x00\x01\x00\x00\x74\x09\xc6\x85\xd4\xfd\xff\xff\x2d\xeb\x18\xa8\x01\x74\x09\xc6\x85\xd4\xfd\xff\xff\x2b\xeb\x0b\xa8\x02\x74\x11\xc6\x85\xd4\xfd\xff\xff\x20\xc7\x85\xd0\xfd\xff\xff\x01\x00\x00\x00\x8b\x9d\xcc\xfd\xff\xff\x2b\x9d\xe0\xfd\xff\xff\x2b\x9d\xd0\xfd\xff\xff\xf6\x85\xf0\xfd\xff\xff\x0c\x75\x17\xff\xb5\xb4\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x53\x6a\x20\xe8\x70\xf5\xff\xff\x83\xc4\x0c\xff\xb5\xd0\xfd\xff\xff\x8b\xbd\xb4\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x8d\x8d\xd4\xfd\xff\xff\xe8\x76\xf5\xff\xff\xf6\x85\xf0\xfd\xff\xff\x08\x59\x74\x1b\xf6\x85\xf0\xfd\xff\xff\x04\x75\x12\x57\x53\x6a\x30\x8d\x85\xd8\xfd\xff\xff\xe8\x2e\xf5\xff\xff\x83\xc4\x0c\x83\xbd\xc8\xfd\xff\xff\x00\x8b\x85\xe0\xfd\xff\xff\x74\x66\x85\xc0\x7e\x62\x8b\xb5\xe4\xfd\xff\xff\x89\x85\xa0\xfd\xff\xff\x0f\xb7\x06\xff\x8d\xa0\xfd\xff\xff\x50\x6a\x06\x8d\x45\xf4\x50\x8d\x85\x98\xfd\xff\xff\x46\x50\x46\xe8\x7d\x2b\x00\x00\x83\xc4\x10\x85\xc0\x75\x28\x39\x85\x98\xfd\xff\xff\x74\x20\xff\xb5\x98\xfd\xff\xff\x8d\x85\xd8\xfd\xff\xff\x8d\x4d\xf4\xe8\xf1\xf4\xff\xff\x83\xbd\xa0\xfd\xff\xff\x00\x59\x75\xb5\xeb\x1c\x83\x8d\xd8\xfd\xff\xff\xff\xeb\x13\x8b\x8d\xe4\xfd\xff\xff\x50\x8d\x85\xd8\xfd\xff\xff\xe8\xca\xf4\xff\xff\x59\x83\xbd\xd8\xfd\xff\xff\x00\x7c\x1b\xf6\x85\xf0\xfd\xff\xff\x04\x74\x12\x57\x53\x6a\x20\x8d\x85\xd8\xfd\xff\xff\xe8\x82\xf4\xff\xff\x83\xc4\x0c\x83\xbd\xbc\xfd\xff\xff\x00\x74\x13\xff\xb5\xbc\xfd\xff\xff\xe8\x5a\x0a\x00\x00\x83\xa5\xbc\xfd\xff\xff\x00\x59\x8b\x9d\xc4\xfd\xff\xff\x8a\x03\x88\x85\xef\xfd\xff\xff\x84\xc0\x74\x13\x8b\x8d\x94\xfd\xff\xff\x8b\xbd\xdc\xfd\xff\xff\x8a\xd0\xe9\xe1\xf5\xff\xff\x80\xbd\xb0\xfd\xff\xff\x00\x74\x0a\x8b\x85\xac\xfd\xff\xff\x83\x60\x70\xfd\x8b\x85\xd8\xfd\xff\xff\x8b\x4d\xfc\x5f\x5e\x33\xcd\x5b\xe8\xde\xeb\xff\xff\xc9\xc3\x90\xae\x21\x00\x10\xaf\x1f\x00\x10\xdf\x1f\x00\x10\x3d\x20\x00\x10\x89\x20\x00\x10\x94\x20\x00\x10\xda\x20\x00\x10\x08\x22\x00\x10\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x28\xf2\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x83\xa5\xd8\xfc\xff\xff\x00\x53\x6a\x4c\x8d\x85\xdc\xfc\xff\xff\x6a\x00\x50\xe8\x51\x2b\x00\x00\x8d\x85\xd8\xfc\xff\xff\x89\x85\x28\xfd\xff\xff\x8d\x85\x30\xfd\xff\xff\x83\xc4\x0c\x89\x85\x2c\xfd\xff\xff\x89\x85\xe0\xfd\xff\xff\x89\x8d\xdc\xfd\xff\xff\x89\x95\xd8\xfd\xff\xff\x89\x9d\xd4\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xbd\xcc\xfd\xff\xff\x66\x8c\x95\xf8\xfd\xff\xff\x66\x8c\x8d\xec\xfd\xff\xff\x66\x8c\x9d\xc8\xfd\xff\xff\x66\x8c\x85\xc4\xfd\xff\xff\x66\x8c\xa5\xc0\xfd\xff\xff\x66\x8c\xad\xbc\xfd\xff\xff\x9c\x8f\x85\xf0\xfd\xff\xff\x8b\x45\x04\x8d\x4d\x04\xc7\x85\x30\xfd\xff\xff\x01\x00\x01\x00\x89\x85\xe8\xfd\xff\xff\x89\x8d\xf4\xfd\xff\xff\x8b\x49\xfc\x89\x8d\xe4\xfd\xff\xff\xc7\x85\xd8\xfc\xff\xff\x17\x04\x00\xc0\xc7\x85\xdc\xfc\xff\xff\x01\x00\x00\x00\x89\x85\xe4\xfc\xff\xff\xff\x15\x60\xb0\x00\x10\x6a\x00\x8b\xd8\xff\x15\x5c\xb0\x00\x10\x8d\x85\x28\xfd\xff\xff\x50\xff\x15\x58\xb0\x00\x10\x85\xc0\x75\x0c\x85\xdb\x75\x08\x6a\x02\xe8\x61\x17\x00\x00\x59\x68\x17\x04\x00\xc0\xff\x15\x54\xb0\x00\x10\x50\xff\x15\x50\xb0\x00\x10\x8b\x4d\xfc\x33\xcd\x5b\xe8\x86\xea\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\xff\x35\x28\xf2\x00\x10\xe8\x0d\x03\x00\x00\x59\x85\xc0\x74\x03\x5d\xff\xe0\x6a\x02\xe8\x22\x17\x00\x00\x59\x5d\xe9\xb2\xfe\xff\xff\x8b\xff\x55\x8b\xec\x8b\x45\x08\x33\xc9\x3b\x04\xcd\x90\xe2\x00\x10\x74\x13\x41\x83\xf9\x2d\x72\xf1\x8d\x48\xed\x83\xf9\x11\x77\x0e\x6a\x0d\x58\x5d\xc3\x8b\x04\xcd\x94\xe2\x00\x10\x5d\xc3\x05\x44\xff\xff\xff\x6a\x0e\x59\x3b\xc8\x1b\xc0\x23\xc1\x83\xc0\x08\x5d\xc3\xe8\x83\x04\x00\x00\x85\xc0\x75\x06\xb8\xf8\xe3\x00\x10\xc3\x83\xc0\x08\xc3\xe8\x70\x04\x00\x00\x85\xc0\x75\x06\xb8\xfc\xe3\x00\x10\xc3\x83\xc0\x0c\xc3\x8b\xff\x55\x8b\xec\x56\xe8\xe2\xff\xff\xff\x8b\x4d\x08\x51\x89\x08\xe8\x82\xff\xff\xff\x59\x8b\xf0\xe8\xbc\xff\xff\xff\x89\x30\x5e\x5d\xc3\xcc\x68\x10\x2c\x00\x10\x64\xff\x35\x00\x00\x00\x00\x8b\x44\x24\x10\x89\x6c\x24\x10\x8d\x6c\x24\x10\x2b\xe0\x53\x56\x57\xa1\x00\xe0\x00\x10\x31\x45\xfc\x33\xc5\x50\x89\x65\xe8\xff\x75\xf8\x8b\x45\xfc\xc7\x45\xfc\xfe\xff\xff\xff\x89\x45\xf8\x8d\x45\xf0\x64\xa3\x00\x00\x00\x00\xc3\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5f\x5e\x5b\x8b\xe5\x5d\x51\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x83\xec\x18\x53\x8b\x5d\x0c\x56\x8b\x73\x08\x33\x35\x00\xe0\x00\x10\x57\x8b\x06\xc6\x45\xff\x00\xc7\x45\xf4\x01\x00\x00\x00\x8d\x7b\x10\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\x35\xe9\xff\xff\x8b\x4e\x0c\x8b\x46\x08\x03\xcf\x33\x0c\x38\xe8\x25\xe9\xff\xff\x8b\x45\x08\xf6\x40\x04\x66\x0f\x85\x16\x01\x00\x00\x8b\x4d\x10\x8d\x55\xe8\x89\x53\xfc\x8b\x5b\x0c\x89\x45\xe8\x89\x4d\xec\x83\xfb\xfe\x74\x5f\x8d\x49\x00\x8d\x04\x5b\x8b\x4c\x86\x14\x8d\x44\x86\x10\x89\x45\xf0\x8b\x00\x89\x45\xf8\x85\xc9\x74\x14\x8b\xd7\xe8\x20\x2a\x00\x00\xc6\x45\xff\x01\x85\xc0\x7c\x40\x7f\x47\x8b\x45\xf8\x8b\xd8\x83\xf8\xfe\x75\xce\x80\x7d\xff\x00\x74\x24\x8b\x06\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\xb2\xe8\xff\xff\x8b\x4e\x0c\x8b\x56\x08\x03\xcf\x33\x0c\x3a\xe8\xa2\xe8\xff\xff\x8b\x45\xf4\x5f\x5e\x5b\x8b\xe5\x5d\xc3\xc7\x45\xf4\x00\x00\x00\x00\xeb\xc9\x8b\x4d\x08\x81\x39\x63\x73\x6d\xe0\x75\x29\x83\x3d\x58\xfe\x00\x10\x00\x74\x20\x68\x58\xfe\x00\x10\xe8\xa3\x2a\x00\x00\x83\xc4\x04\x85\xc0\x74\x0f\x8b\x55\x08\x6a\x01\x52\xff\x15\x58\xfe\x00\x10\x83\xc4\x08\x8b\x4d\x0c\xe8\xc3\x29\x00\x00\x8b\x45\x0c\x39\x58\x0c\x74\x12\x68\x00\xe0\x00\x10\x57\x8b\xd3\x8b\xc8\xe8\xc6\x29\x00\x00\x8b\x45\x0c\x8b\x4d\xf8\x89\x48\x0c\x8b\x06\x83\xf8\xfe\x74\x0d\x8b\x4e\x04\x03\xcf\x33\x0c\x38\xe8\x1f\xe8\xff\xff\x8b\x4e\x0c\x8b\x56\x08\x03\xcf\x33\x0c\x3a\xe8\x0f\xe8\xff\xff\x8b\x45\xf0\x8b\x48\x08\x8b\xd7\xe8\x59\x29\x00\x00\xba\xfe\xff\xff\xff\x39\x53\x0c\x0f\x84\x52\xff\xff\xff\x68\x00\xe0\x00\x10\x57\x8b\xcb\xe8\x71\x29\x00\x00\xe9\x1c\xff\xff\xff\x8b\xff\x55\x8b\xec\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x21\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x17\x50\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x85\xc0\x74\x08\x8b\x80\xf8\x01\x00\x00\xeb\x27\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x0b\x56\xe8\x29\x07\x00\x00\x59\x85\xc0\x74\x18\x68\x4c\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x08\xff\x75\x08\xff\xd0\x89\x45\x08\x8b\x45\x08\x5e\x5d\xc3\x6a\x00\xe8\x87\xff\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x21\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x17\x50\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x85\xc0\x74\x08\x8b\x80\xfc\x01\x00\x00\xeb\x27\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x0b\x56\xe8\xae\x06\x00\x00\x59\x85\xc0\x74\x18\x68\x78\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x08\xff\x75\x08\xff\xd0\x89\x45\x08\x8b\x45\x08\x5e\x5d\xc3\xff\x15\x74\xb0\x00\x10\xc2\x04\x00\x8b\xff\x56\xff\x35\x04\xe4\x00\x10\xff\x15\x70\xb0\x00\x10\x8b\xf0\x85\xf6\x75\x1b\xff\x35\x30\xf2\x00\x10\xe8\x65\xff\xff\xff\x59\x8b\xf0\x56\xff\x35\x04\xe4\x00\x10\xff\x15\x78\xb0\x00\x10\x8b\xc6\x5e\xc3\xa1\x00\xe4\x00\x10\x83\xf8\xff\x74\x16\x50\xff\x35\x38\xf2\x00\x10\xe8\x3b\xff\xff\xff\x59\xff\xd0\x83\x0d\x00\xe4\x00\x10\xff\xa1\x04\xe4\x00\x10\x83\xf8\xff\x74\x0e\x50\xff\x15\x7c\xb0\x00\x10\x83\x0d\x04\xe4\x00\x10\xff\xe9\xbd\x15\x00\x00\x6a\x0c\x68\xa0\xc5\x00\x10\xe8\x9d\xfc\xff\xff\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x07\x56\xe8\xef\x05\x00\x00\x59\x89\x45\xe4\x8b\x75\x08\xc7\x46\x5c\xe0\xb2\x00\x10\x33\xff\x47\x89\x7e\x14\x85\xc0\x74\x24\x68\x4c\xb2\x00\x10\x50\x8b\x1d\x6c\xb0\x00\x10\xff\xd3\x89\x86\xf8\x01\x00\x00\x68\x78\xb2\x00\x10\xff\x75\xe4\xff\xd3\x89\x86\xfc\x01\x00\x00\x89\x7e\x70\xc6\x86\xc8\x00\x00\x00\x43\xc6\x86\x4b\x01\x00\x00\x43\xc7\x46\x68\x88\xe5\x00\x10\x6a\x0d\xe8\x71\x16\x00\x00\x59\x83\x65\xfc\x00\xff\x76\x68\xff\x15\x80\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x3e\x00\x00\x00\x6a\x0c\xe8\x50\x16\x00\x00\x59\x89\x7d\xfc\x8b\x45\x0c\x89\x46\x6c\x85\xc0\x75\x08\xa1\x90\xeb\x00\x10\x89\x46\x6c\xff\x76\x6c\xe8\x27\x1f\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x15\x00\x00\x00\xe8\x20\xfc\xff\xff\xc3\x33\xff\x47\x8b\x75\x08\x6a\x0d\xe8\x38\x15\x00\x00\x59\xc3\x6a\x0c\xe8\x2f\x15\x00\x00\x59\xc3\x8b\xff\x56\x57\xff\x15\x00\xb0\x00\x10\xff\x35\x00\xe4\x00\x10\x8b\xf8\xe8\x91\xfe\xff\xff\xff\xd0\x8b\xf0\x85\xf6\x75\x4e\x68\x14\x02\x00\x00\x6a\x01\xe8\x65\x04\x00\x00\x8b\xf0\x59\x59\x85\xf6\x74\x3a\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\xe8\xfd\xff\xff\x59\xff\xd0\x85\xc0\x74\x18\x6a\x00\x56\xe8\xc5\xfe\xff\xff\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\xeb\x09\x56\xe8\x53\x03\x00\x00\x59\x33\xf6\x57\xff\x15\x84\xb0\x00\x10\x5f\x8b\xc6\x5e\xc3\x8b\xff\x56\xe8\x7f\xff\xff\xff\x8b\xf0\x85\xf6\x75\x08\x6a\x10\xe8\xcc\x04\x00\x00\x59\x8b\xc6\x5e\xc3\x6a\x08\x68\xc8\xc5\x00\x10\xe8\x23\xfb\xff\xff\x8b\x75\x08\x85\xf6\x0f\x84\xf8\x00\x00\x00\x8b\x46\x24\x85\xc0\x74\x07\x50\xe8\x06\x03\x00\x00\x59\x8b\x46\x2c\x85\xc0\x74\x07\x50\xe8\xf8\x02\x00\x00\x59\x8b\x46\x34\x85\xc0\x74\x07\x50\xe8\xea\x02\x00\x00\x59\x8b\x46\x3c\x85\xc0\x74\x07\x50\xe8\xdc\x02\x00\x00\x59\x8b\x46\x40\x85\xc0\x74\x07\x50\xe8\xce\x02\x00\x00\x59\x8b\x46\x44\x85\xc0\x74\x07\x50\xe8\xc0\x02\x00\x00\x59\x8b\x46\x48\x85\xc0\x74\x07\x50\xe8\xb2\x02\x00\x00\x59\x8b\x46\x5c\x3d\xe0\xb2\x00\x10\x74\x07\x50\xe8\xa1\x02\x00\x00\x59\x6a\x0d\xe8\xe3\x14\x00\x00\x59\x83\x65\xfc\x00\x8b\x7e\x68\x85\xff\x74\x1a\x57\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x0f\x81\xff\x88\xe5\x00\x10\x74\x07\x57\xe8\x74\x02\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x57\x00\x00\x00\x6a\x0c\xe8\xaa\x14\x00\x00\x59\xc7\x45\xfc\x01\x00\x00\x00\x8b\x7e\x6c\x85\xff\x74\x23\x57\xe8\x19\x1e\x00\x00\x59\x3b\x3d\x90\xeb\x00\x10\x74\x14\x81\xff\xb8\xea\x00\x10\x74\x0c\x83\x3f\x00\x75\x07\x57\xe8\x25\x1c\x00\x00\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x1e\x00\x00\x00\x56\xe8\x1c\x02\x00\x00\x59\xe8\x60\xfa\xff\xff\xc2\x04\x00\x8b\x75\x08\x6a\x0d\xe8\x79\x13\x00\x00\x59\xc3\x8b\x75\x08\x6a\x0c\xe8\x6d\x13\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x83\x3d\x00\xe4\x00\x10\xff\x74\x4b\x83\x7d\x08\x00\x75\x27\x56\xff\x35\x04\xe4\x00\x10\x8b\x35\x70\xb0\x00\x10\xff\xd6\x85\xc0\x74\x13\xff\x35\x00\xe4\x00\x10\xff\x35\x04\xe4\x00\x10\xff\xd6\xff\xd0\x89\x45\x08\x5e\x6a\x00\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\x1d\xfc\xff\xff\x59\xff\xd0\xff\x75\x08\xe8\x78\xfe\xff\xff\xa1\x04\xe4\x00\x10\x83\xf8\xff\x74\x09\x6a\x00\x50\xff\x15\x78\xb0\x00\x10\x5d\xc3\x8b\xff\x56\x57\xbe\x5c\xb2\x00\x10\x56\xff\x15\x08\xb0\x00\x10\x85\xc0\x75\x07\x56\xe8\xe0\x02\x00\x00\x59\x8b\xf8\x85\xff\x0f\x84\x5e\x01\x00\x00\x8b\x35\x6c\xb0\x00\x10\x68\xa8\xb2\x00\x10\x57\xff\xd6\x68\x9c\xb2\x00\x10\x57\xa3\x2c\xf2\x00\x10\xff\xd6\x68\x90\xb2\x00\x10\x57\xa3\x30\xf2\x00\x10\xff\xd6\x68\x88\xb2\x00\x10\x57\xa3\x34\xf2\x00\x10\xff\xd6\x83\x3d\x2c\xf2\x00\x10\x00\x8b\x35\x78\xb0\x00\x10\xa3\x38\xf2\x00\x10\x74\x16\x83\x3d\x30\xf2\x00\x10\x00\x74\x0d\x83\x3d\x34\xf2\x00\x10\x00\x74\x04\x85\xc0\x75\x24\xa1\x70\xb0\x00\x10\xa3\x30\xf2\x00\x10\xa1\x7c\xb0\x00\x10\xc7\x05\x2c\xf2\x00\x10\x89\x2e\x00\x10\x89\x35\x34\xf2\x00\x10\xa3\x38\xf2\x00\x10\xff\x15\x74\xb0\x00\x10\xa3\x04\xe4\x00\x10\x83\xf8\xff\x0f\x84\xcc\x00\x00\x00\xff\x35\x30\xf2\x00\x10\x50\xff\xd6\x85\xc0\x0f\x84\xbb\x00\x00\x00\xe8\xed\x04\x00\x00\xff\x35\x2c\xf2\x00\x10\xe8\xa5\xfa\xff\xff\xff\x35\x30\xf2\x00\x10\xa3\x2c\xf2\x00\x10\xe8\x95\xfa\xff\xff\xff\x35\x34\xf2\x00\x10\xa3\x30\xf2\x00\x10\xe8\x85\xfa\xff\xff\xff\x35\x38\xf2\x00\x10\xa3\x34\xf2\x00\x10\xe8\x75\xfa\xff\xff\x83\xc4\x10\xa3\x38\xf2\x00\x10\xe8\x41\x11\x00\x00\x85\xc0\x74\x65\x68\x7d\x30\x00\x10\xff\x35\x2c\xf2\x00\x10\xe8\xcf\xfa\xff\xff\x59\xff\xd0\xa3\x00\xe4\x00\x10\x83\xf8\xff\x74\x48\x68\x14\x02\x00\x00\x6a\x01\xe8\x19\x01\x00\x00\x8b\xf0\x59\x59\x85\xf6\x74\x34\x56\xff\x35\x00\xe4\x00\x10\xff\x35\x34\xf2\x00\x10\xe8\x9c\xfa\xff\xff\x59\xff\xd0\x85\xc0\x74\x1b\x6a\x00\x56\xe8\x79\xfb\xff\xff\x59\x59\xff\x15\x48\xb0\x00\x10\x83\x4e\x04\xff\x89\x06\x33\xc0\x40\xeb\x07\xe8\x24\xfb\xff\xff\x33\xc0\x5f\x5e\xc3\x6a\x0c\x68\xf0\xc5\x00\x10\xe8\xf9\xf7\xff\xff\x8b\x75\x08\x85\xf6\x74\x75\x83\x3d\x2c\xfd\x00\x10\x03\x75\x43\x6a\x04\xe8\x27\x12\x00\x00\x59\x83\x65\xfc\x00\x56\xe8\x98\x24\x00\x00\x59\x89\x45\xe4\x85\xc0\x74\x09\x56\x50\xe8\xb9\x24\x00\x00\x59\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x0b\x00\x00\x00\x83\x7d\xe4\x00\x75\x37\xff\x75\x08\xeb\x0a\x6a\x04\xe8\x13\x11\x00\x00\x59\xc3\x56\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\x85\xc0\x75\x16\xe8\x44\xf7\xff\xff\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\xf4\xf6\xff\xff\x89\x06\x59\xe8\xbd\xf7\xff\xff\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\xff\x75\x08\xe8\x3a\x2f\x00\x00\x8b\xf8\x59\x85\xff\x75\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xca\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\x6a\x00\xff\x75\x0c\xff\x75\x08\xe8\xba\x2f\x00\x00\x8b\xf8\x83\xc4\x0c\x85\xff\x75\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xc3\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x57\x33\xf6\xff\x75\x0c\xff\x75\x08\xe8\x8e\x30\x00\x00\x8b\xf8\x59\x59\x85\xff\x75\x2c\x39\x45\x0c\x74\x27\x39\x05\x3c\xf2\x00\x10\x76\x1f\x56\xff\x15\x90\xb0\x00\x10\x8d\x86\xe8\x03\x00\x00\x3b\x05\x3c\xf2\x00\x10\x76\x03\x83\xc8\xff\x8b\xf0\x83\xf8\xff\x75\xc1\x8b\xc7\x5f\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x57\xbf\xe8\x03\x00\x00\x57\xff\x15\x90\xb0\x00\x10\xff\x75\x08\xff\x15\x08\xb0\x00\x10\x81\xc7\xe8\x03\x00\x00\x81\xff\x60\xea\x00\x00\x77\x04\x85\xc0\x74\xde\x5f\x5d\xc3\x8b\xff\x55\x8b\xec\xe8\xe0\x33\x00\x00\xff\x75\x08\xe8\x2d\x32\x00\x00\xff\x35\x08\xe4\x00\x10\xe8\xb6\xf8\xff\xff\x68\xff\x00\x00\x00\xff\xd0\x83\xc4\x0c\x5d\xc3\x8b\xff\x55\x8b\xec\x68\xc4\xb2\x00\x10\xff\x15\x08\xb0\x00\x10\x85\xc0\x74\x15\x68\xb4\xb2\x00\x10\x50\xff\x15\x6c\xb0\x00\x10\x85\xc0\x74\x05\xff\x75\x08\xff\xd0\x5d\xc3\x8b\xff\x55\x8b\xec\xff\x75\x08\xe8\xc8\xff\xff\xff\x59\xff\x75\x08\xff\x15\x94\xb0\x00\x10\xcc\x6a\x08\xe8\x3a\x10\x00\x00\x59\xc3\x6a\x08\xe8\x57\x0f\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\xf0\xeb\x0b\x8b\x06\x85\xc0\x74\x02\xff\xd0\x83\xc6\x04\x3b\x75\x08\x72\xf0\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x33\xc0\xeb\x0f\x85\xc0\x75\x10\x8b\x0e\x85\xc9\x74\x02\xff\xd1\x83\xc6\x04\x3b\x75\x0c\x72\xec\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\x3d\x50\xfe\x00\x10\x00\x74\x19\x68\x50\xfe\x00\x10\xe8\x95\x21\x00\x00\x59\x85\xc0\x74\x0a\xff\x75\x08\xff\x15\x50\xfe\x00\x10\x59\xe8\xf7\x1b\x00\x00\x68\x94\xb1\x00\x10\x68\x80\xb1\x00\x10\xe8\xa1\xff\xff\xff\x59\x59\x85\xc0\x75\x42\x68\x59\x3f\x00\x10\xe8\x40\x34\x00\x00\xb8\x78\xb1\x00\x10\xc7\x04\x24\x7c\xb1\x00\x10\xe8\x63\xff\xff\xff\x83\x3d\x54\xfe\x00\x10\x00\x59\x74\x1b\x68\x54\xfe\x00\x10\xe8\x3d\x21\x00\x00\x59\x85\xc0\x74\x0c\x6a\x00\x6a\x02\x6a\x00\xff\x15\x54\xfe\x00\x10\x33\xc0\x5d\xc3\x6a\x18\x68\x10\xc6\x00\x10\xe8\x18\xf5\xff\xff\x6a\x08\xe8\x56\x0f\x00\x00\x59\x83\x65\xfc\x00\x33\xdb\x43\x39\x1d\x70\xf2\x00\x10\x0f\x84\xc5\x00\x00\x00\x89\x1d\x6c\xf2\x00\x10\x8a\x45\x10\xa2\x68\xf2\x00\x10\x83\x7d\x0c\x00\x0f\x85\x9d\x00\x00\x00\xff\x35\x48\xfe\x00\x10\xe8\x45\xf7\xff\xff\x59\x8b\xf8\x89\x7d\xd8\x85\xff\x74\x78\xff\x35\x44\xfe\x00\x10\xe8\x30\xf7\xff\xff\x59\x8b\xf0\x89\x75\xdc\x89\x7d\xe4\x89\x75\xe0\x83\xee\x04\x89\x75\xdc\x3b\xf7\x72\x57\xe8\x0c\xf7\xff\xff\x39\x06\x74\xed\x3b\xf7\x72\x4a\xff\x36\xe8\x06\xf7\xff\xff\x8b\xf8\xe8\xf6\xf6\xff\xff\x89\x06\xff\xd7\xff\x35\x48\xfe\x00\x10\xe8\xf0\xf6\xff\xff\x8b\xf8\xff\x35\x44\xfe\x00\x10\xe8\xe3\xf6\xff\xff\x83\xc4\x0c\x39\x7d\xe4\x75\x05\x39\x45\xe0\x74\x0e\x89\x7d\xe4\x89\x7d\xd8\x89\x45\xe0\x8b\xf0\x89\x75\xdc\x8b\x7d\xd8\xeb\x9f\x68\xa4\xb1\x00\x10\xb8\x98\xb1\x00\x10\xe8\x5f\xfe\xff\xff\x59\x68\xac\xb1\x00\x10\xb8\xa8\xb1\x00\x10\xe8\x4f\xfe\xff\xff\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x1f\x00\x00\x00\x83\x7d\x10\x00\x75\x28\x89\x1d\x70\xf2\x00\x10\x6a\x08\xe8\x84\x0d\x00\x00\x59\xff\x75\x08\xe8\xfc\xfd\xff\xff\x33\xdb\x43\x83\x7d\x10\x00\x74\x08\x6a\x08\xe8\x6b\x0d\x00\x00\x59\xc3\xe8\x3e\xf4\xff\xff\xc3\x8b\xff\x55\x8b\xec\x6a\x00\x6a\x01\xff\x75\x08\xe8\xc3\xfe\xff\xff\x83\xc4\x0c\x5d\xc3\x6a\x01\x6a\x00\x6a\x00\xe8\xb3\xfe\xff\xff\x83\xc4\x0c\xc3\x8b\xff\x56\xe8\x2d\xf6\xff\xff\x8b\xf0\x56\xe8\xa5\x35\x00\x00\x56\xe8\x30\x35\x00\x00\x56\xe8\xce\xf1\xff\xff\x56\xe8\x15\x35\x00\x00\x56\xe8\x00\x35\x00\x00\x56\xe8\xe8\x32\x00\x00\x56\xe8\x17\x08\x00\x00\x56\xe8\xcb\x32\x00\x00\x68\xb4\x37\x00\x10\xe8\x7f\xf5\xff\xff\x83\xc4\x24\xa3\x08\xe4\x00\x10\x5e\xc3\x6a\x54\x68\x30\xc6\x00\x10\xe8\x79\xf3\xff\xff\x33\xff\x89\x7d\xfc\x8d\x45\x9c\x50\xff\x15\xa4\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\x6a\x40\x6a\x20\x5e\x56\xe8\x26\xfc\xff\xff\x59\x59\x3b\xc7\x0f\x84\x14\x02\x00\x00\xa3\x40\xfd\x00\x10\x89\x35\x30\xfd\x00\x10\x8d\x88\x00\x08\x00\x00\xeb\x30\xc6\x40\x04\x00\x83\x08\xff\xc6\x40\x05\x0a\x89\x78\x08\xc6\x40\x24\x00\xc6\x40\x25\x0a\xc6\x40\x26\x0a\x89\x78\x38\xc6\x40\x34\x00\x83\xc0\x40\x8b\x0d\x40\xfd\x00\x10\x81\xc1\x00\x08\x00\x00\x3b\xc1\x72\xcc\x66\x39\x7d\xce\x0f\x84\x0a\x01\x00\x00\x8b\x45\xd0\x3b\xc7\x0f\x84\xff\x00\x00\x00\x8b\x38\x8d\x58\x04\x8d\x04\x3b\x89\x45\xe4\xbe\x00\x08\x00\x00\x3b\xfe\x7c\x02\x8b\xfe\xc7\x45\xe0\x01\x00\x00\x00\xeb\x5b\x6a\x40\x6a\x20\xe8\x98\xfb\xff\xff\x59\x59\x85\xc0\x74\x56\x8b\x4d\xe0\x8d\x0c\x8d\x40\xfd\x00\x10\x89\x01\x83\x05\x30\xfd\x00\x10\x20\x8d\x90\x00\x08\x00\x00\xeb\x2a\xc6\x40\x04\x00\x83\x08\xff\xc6\x40\x05\x0a\x83\x60\x08\x00\x80\x60\x24\x80\xc6\x40\x25\x0a\xc6\x40\x26\x0a\x83\x60\x38\x00\xc6\x40\x34\x00\x83\xc0\x40\x8b\x11\x03\xd6\x3b\xc2\x72\xd2\xff\x45\xe0\x39\x3d\x30\xfd\x00\x10\x7c\x9d\xeb\x06\x8b\x3d\x30\xfd\x00\x10\x83\x65\xe0\x00\x85\xff\x7e\x6d\x8b\x45\xe4\x8b\x08\x83\xf9\xff\x74\x56\x83\xf9\xfe\x74\x51\x8a\x03\xa8\x01\x74\x4b\xa8\x08\x75\x0b\x51\xff\x15\xa0\xb0\x00\x10\x85\xc0\x74\x3c\x8b\x75\xe0\x8b\xc6\xc1\xf8\x05\x83\xe6\x1f\xc1\xe6\x06\x03\x34\x85\x40\xfd\x00\x10\x8b\x45\xe4\x8b\x00\x89\x06\x8a\x03\x88\x46\x04\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\x8f\x33\x00\x00\x59\x59\x85\xc0\x0f\x84\xc9\x00\x00\x00\xff\x46\x08\xff\x45\xe0\x43\x83\x45\xe4\x04\x39\x7d\xe0\x7c\x93\x33\xdb\x8b\xf3\xc1\xe6\x06\x03\x35\x40\xfd\x00\x10\x8b\x06\x83\xf8\xff\x74\x0b\x83\xf8\xfe\x74\x06\x80\x4e\x04\x80\xeb\x72\xc6\x46\x04\x81\x85\xdb\x75\x05\x6a\xf6\x58\xeb\x0a\x8b\xc3\x48\xf7\xd8\x1b\xc0\x83\xc0\xf5\x50\xff\x15\x9c\xb0\x00\x10\x8b\xf8\x83\xff\xff\x74\x43\x85\xff\x74\x3f\x57\xff\x15\xa0\xb0\x00\x10\x85\xc0\x74\x34\x89\x3e\x25\xff\x00\x00\x00\x83\xf8\x02\x75\x06\x80\x4e\x04\x40\xeb\x09\x83\xf8\x03\x75\x04\x80\x4e\x04\x08\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\xf9\x32\x00\x00\x59\x59\x85\xc0\x74\x37\xff\x46\x08\xeb\x0a\x80\x4e\x04\x40\xc7\x06\xfe\xff\xff\xff\x43\x83\xfb\x03\x0f\x8c\x67\xff\xff\xff\xff\x35\x30\xfd\x00\x10\xff\x15\x98\xb0\x00\x10\x33\xc0\xeb\x11\x33\xc0\x40\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x83\xc8\xff\xe8\x77\xf1\xff\xff\xc3\x8b\xff\x56\x57\xbe\x40\xfd\x00\x10\x8b\x3e\x85\xff\x74\x31\x8d\x87\x00\x08\x00\x00\xeb\x1a\x83\x7f\x08\x00\x74\x0a\x8d\x47\x0c\x50\xff\x15\xa8\xb0\x00\x10\x8b\x06\x83\xc7\x40\x05\x00\x08\x00\x00\x3b\xf8\x72\xe2\xff\x36\xe8\xf0\xf8\xff\xff\x83\x26\x00\x59\x83\xc6\x04\x81\xfe\x40\xfe\x00\x10\x7c\xbe\x5f\x5e\xc3\x83\x3d\x4c\xfe\x00\x10\x00\x75\x05\xe8\xa8\x12\x00\x00\x56\x8b\x35\xe8\xee\x00\x10\x57\x33\xff\x85\xf6\x75\x18\x83\xc8\xff\xe9\xa0\x00\x00\x00\x3c\x3d\x74\x01\x47\x56\xe8\x58\x17\x00\x00\x59\x8d\x74\x06\x01\x8a\x06\x84\xc0\x75\xea\x6a\x04\x47\x57\xe8\x6e\xf9\xff\xff\x8b\xf8\x59\x59\x89\x3d\x50\xf2\x00\x10\x85\xff\x74\xcb\x8b\x35\xe8\xee\x00\x10\x53\xeb\x42\x56\xe8\x27\x17\x00\x00\x8b\xd8\x43\x80\x3e\x3d\x59\x74\x31\x6a\x01\x53\xe8\x40\xf9\xff\xff\x59\x59\x89\x07\x85\xc0\x74\x4e\x56\x53\x50\xe8\x7b\x32\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0f\x33\xc0\x50\x50\x50\x50\x50\xe8\x75\xee\xff\xff\x83\xc4\x14\x83\xc7\x04\x03\xf3\x80\x3e\x00\x75\xb9\xff\x35\xe8\xee\x00\x10\xe8\x32\xf8\xff\xff\x83\x25\xe8\xee\x00\x10\x00\x83\x27\x00\xc7\x05\x40\xfe\x00\x10\x01\x00\x00\x00\x33\xc0\x59\x5b\x5f\x5e\xc3\xff\x35\x50\xf2\x00\x10\xe8\x0c\xf8\xff\xff\x83\x25\x50\xf2\x00\x10\x00\x83\xc8\xff\xeb\xe4\x8b\xff\x55\x8b\xec\x51\x8b\x4d\x10\x53\x33\xc0\x56\x89\x07\x8b\xf2\x8b\x55\x0c\xc7\x01\x01\x00\x00\x00\x39\x45\x08\x74\x09\x8b\x5d\x08\x83\x45\x08\x04\x89\x13\x89\x45\xfc\x80\x3e\x22\x75\x10\x33\xc0\x39\x45\xfc\xb3\x22\x0f\x94\xc0\x46\x89\x45\xfc\xeb\x3c\xff\x07\x85\xd2\x74\x08\x8a\x06\x88\x02\x42\x89\x55\x0c\x8a\x1e\x0f\xb6\xc3\x50\x46\xe8\x7f\x32\x00\x00\x59\x85\xc0\x74\x13\xff\x07\x83\x7d\x0c\x00\x74\x0a\x8b\x4d\x0c\x8a\x06\xff\x45\x0c\x88\x01\x46\x8b\x55\x0c\x8b\x4d\x10\x84\xdb\x74\x32\x83\x7d\xfc\x00\x75\xa9\x80\xfb\x20\x74\x05\x80\xfb\x09\x75\x9f\x85\xd2\x74\x04\xc6\x42\xff\x00\x83\x65\xfc\x00\x80\x3e\x00\x0f\x84\xe9\x00\x00\x00\x8a\x06\x3c\x20\x74\x04\x3c\x09\x75\x06\x46\xeb\xf3\x4e\xeb\xe3\x80\x3e\x00\x0f\x84\xd0\x00\x00\x00\x83\x7d\x08\x00\x74\x09\x8b\x45\x08\x83\x45\x08\x04\x89\x10\xff\x01\x33\xdb\x43\x33\xc9\xeb\x02\x46\x41\x80\x3e\x5c\x74\xf9\x80\x3e\x22\x75\x26\xf6\xc1\x01\x75\x1f\x83\x7d\xfc\x00\x74\x0c\x8d\x46\x01\x80\x38\x22\x75\x04\x8b\xf0\xeb\x0d\x33\xc0\x33\xdb\x39\x45\xfc\x0f\x94\xc0\x89\x45\xfc\xd1\xe9\x85\xc9\x74\x12\x49\x85\xd2\x74\x04\xc6\x02\x5c\x42\xff\x07\x85\xc9\x75\xf1\x89\x55\x0c\x8a\x06\x84\xc0\x74\x55\x83\x7d\xfc\x00\x75\x08\x3c\x20\x74\x4b\x3c\x09\x74\x47\x85\xdb\x74\x3d\x0f\xbe\xc0\x50\x85\xd2\x74\x23\xe8\x9a\x31\x00\x00\x59\x85\xc0\x74\x0d\x8a\x06\x8b\x4d\x0c\xff\x45\x0c\x88\x01\x46\xff\x07\x8b\x4d\x0c\x8a\x06\xff\x45\x0c\x88\x01\xeb\x0d\xe8\x77\x31\x00\x00\x59\x85\xc0\x74\x03\x46\xff\x07\xff\x07\x8b\x55\x0c\x46\xe9\x56\xff\xff\xff\x85\xd2\x74\x07\xc6\x02\x00\x42\x89\x55\x0c\xff\x07\x8b\x4d\x10\xe9\x0e\xff\xff\xff\x8b\x45\x08\x5e\x5b\x85\xc0\x74\x03\x83\x20\x00\xff\x01\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\x53\x33\xdb\x56\x57\x39\x1d\x4c\xfe\x00\x10\x75\x05\xe8\x24\x10\x00\x00\x68\x04\x01\x00\x00\xbe\x78\xf2\x00\x10\x56\x53\x88\x1d\x7c\xf3\x00\x10\xff\x15\xac\xb0\x00\x10\xa1\x64\x0e\x01\x10\x89\x35\x60\xf2\x00\x10\x3b\xc3\x74\x07\x89\x45\xfc\x38\x18\x75\x03\x89\x75\xfc\x8b\x55\xfc\x8d\x45\xf8\x50\x53\x53\x8d\x7d\xf4\xe8\x0a\xfe\xff\xff\x8b\x45\xf8\x83\xc4\x0c\x3d\xff\xff\xff\x3f\x73\x4a\x8b\x4d\xf4\x83\xf9\xff\x73\x42\x8b\xf8\xc1\xe7\x02\x8d\x04\x0f\x3b\xc1\x72\x36\x50\xe8\x71\xf6\xff\xff\x8b\xf0\x59\x3b\xf3\x74\x29\x8b\x55\xfc\x8d\x45\xf8\x50\x03\xfe\x57\x56\x8d\x7d\xf4\xe8\xc9\xfd\xff\xff\x8b\x45\xf8\x83\xc4\x0c\x48\xa3\x44\xf2\x00\x10\x89\x35\x48\xf2\x00\x10\x33\xc0\xeb\x03\x83\xc8\xff\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\xa1\x80\xf3\x00\x10\x83\xec\x0c\x53\x56\x8b\x35\xc0\xb0\x00\x10\x57\x33\xdb\x33\xff\x3b\xc3\x75\x2e\xff\xd6\x8b\xf8\x3b\xfb\x74\x0c\xc7\x05\x80\xf3\x00\x10\x01\x00\x00\x00\xeb\x23\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\x6a\x02\x58\xa3\x80\xf3\x00\x10\xeb\x05\xa1\x80\xf3\x00\x10\x83\xf8\x01\x0f\x85\x81\x00\x00\x00\x3b\xfb\x75\x0f\xff\xd6\x8b\xf8\x3b\xfb\x75\x07\x33\xc0\xe9\xca\x00\x00\x00\x8b\xc7\x66\x39\x1f\x74\x0e\x40\x40\x66\x39\x18\x75\xf9\x40\x40\x66\x39\x18\x75\xf2\x8b\x35\xbc\xb0\x00\x10\x53\x53\x53\x2b\xc7\x53\xd1\xf8\x40\x50\x57\x53\x53\x89\x45\xf4\xff\xd6\x89\x45\xf8\x3b\xc3\x74\x2f\x50\xe8\x97\xf5\xff\xff\x59\x89\x45\xfc\x3b\xc3\x74\x21\x53\x53\xff\x75\xf8\x50\xff\x75\xf4\x57\x53\x53\xff\xd6\x85\xc0\x75\x0c\xff\x75\xfc\xe8\xe7\xf4\xff\xff\x59\x89\x5d\xfc\x8b\x5d\xfc\x57\xff\x15\xb8\xb0\x00\x10\x8b\xc3\xeb\x5c\x83\xf8\x02\x74\x04\x3b\xc3\x75\x82\xff\x15\xb4\xb0\x00\x10\x8b\xf0\x3b\xf3\x0f\x84\x72\xff\xff\xff\x38\x1e\x74\x0a\x40\x38\x18\x75\xfb\x40\x38\x18\x75\xf6\x2b\xc6\x40\x50\x89\x45\xf8\xe8\x30\xf5\xff\xff\x8b\xf8\x59\x3b\xfb\x75\x0c\x56\xff\x15\xb0\xb0\x00\x10\xe9\x45\xff\xff\xff\xff\x75\xf8\x56\x57\xe8\x7e\x2f\x00\x00\x83\xc4\x0c\x56\xff\x15\xb0\xb0\x00\x10\x8b\xc7\x5f\x5e\x5b\xc9\xc3\x8b\xff\x56\xb8\x50\xc5\x00\x10\xbe\x50\xc5\x00\x10\x57\x8b\xf8\x3b\xc6\x73\x0f\x8b\x07\x85\xc0\x74\x02\xff\xd0\x83\xc7\x04\x3b\xfe\x72\xf1\x5f\x5e\xc3\x8b\xff\x56\xb8\x58\xc5\x00\x10\xbe\x58\xc5\x00\x10\x57\x8b\xf8\x3b\xc6\x73\x0f\x8b\x07\x85\xc0\x74\x02\xff\xd0\x83\xc7\x04\x3b\xfe\x72\xf1\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x33\xc0\x39\x45\x08\x6a\x00\x0f\x94\xc0\x68\x00\x10\x00\x00\x50\xff\x15\xc4\xb0\x00\x10\xa3\x84\xf3\x00\x10\x85\xc0\x75\x02\x5d\xc3\x33\xc0\x40\xa3\x2c\xfd\x00\x10\x5d\xc3\xcc\x83\x3d\x2c\xfd\x00\x10\x03\x75\x57\x53\x33\xdb\x39\x1d\x10\xfd\x00\x10\x57\x8b\x3d\x8c\xb0\x00\x10\x7e\x33\x56\x8b\x35\x14\xfd\x00\x10\x83\xc6\x10\x68\x00\x80\x00\x00\x6a\x00\xff\x76\xfc\xff\x15\xcc\xb0\x00\x10\xff\x36\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x83\xc6\x14\x43\x3b\x1d\x10\xfd\x00\x10\x7c\xd8\x5e\xff\x35\x14\xfd\x00\x10\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x5f\x5b\xff\x35\x84\xf3\x00\x10\xff\x15\xc8\xb0\x00\x10\x83\x25\x84\xf3\x00\x10\x00\xc3\xc3\x8b\xff\x55\x8b\xec\x51\x51\x56\xe8\xb8\xef\xff\xff\x8b\xf0\x85\xf6\x0f\x84\x46\x01\x00\x00\x8b\x56\x5c\xa1\x60\xe4\x00\x10\x57\x8b\x7d\x08\x8b\xca\x53\x39\x39\x74\x0e\x8b\xd8\x6b\xdb\x0c\x83\xc1\x0c\x03\xda\x3b\xcb\x72\xee\x6b\xc0\x0c\x03\xc2\x3b\xc8\x73\x08\x39\x39\x75\x04\x8b\xc1\xeb\x02\x33\xc0\x85\xc0\x74\x0a\x8b\x58\x08\x89\x5d\xfc\x85\xdb\x75\x07\x33\xc0\xe9\xfb\x00\x00\x00\x83\xfb\x05\x75\x0c\x83\x60\x08\x00\x33\xc0\x40\xe9\xea\x00\x00\x00\x83\xfb\x01\x0f\x84\xde\x00\x00\x00\x8b\x4e\x60\x89\x4d\xf8\x8b\x4d\x0c\x89\x4e\x60\x8b\x48\x04\x83\xf9\x08\x0f\x85\xb8\x00\x00\x00\x8b\x0d\x54\xe4\x00\x10\x8b\x3d\x58\xe4\x00\x10\x8b\xd1\x03\xf9\x3b\xd7\x7d\x24\x6b\xc9\x0c\x8b\x7e\x5c\x83\x64\x39\x08\x00\x8b\x3d\x54\xe4\x00\x10\x8b\x1d\x58\xe4\x00\x10\x42\x03\xdf\x83\xc1\x0c\x3b\xd3\x7c\xe2\x8b\x5d\xfc\x8b\x00\x8b\x7e\x64\x3d\x8e\x00\x00\xc0\x75\x09\xc7\x46\x64\x83\x00\x00\x00\xeb\x5e\x3d\x90\x00\x00\xc0\x75\x09\xc7\x46\x64\x81\x00\x00\x00\xeb\x4e\x3d\x91\x00\x00\xc0\x75\x09\xc7\x46\x64\x84\x00\x00\x00\xeb\x3e\x3d\x93\x00\x00\xc0\x75\x09\xc7\x46\x64\x85\x00\x00\x00\xeb\x2e\x3d\x8d\x00\x00\xc0\x75\x09\xc7\x46\x64\x82\x00\x00\x00\xeb\x1e\x3d\x8f\x00\x00\xc0\x75\x09\xc7\x46\x64\x86\x00\x00\x00\xeb\x0e\x3d\x92\x00\x00\xc0\x75\x07\xc7\x46\x64\x8a\x00\x00\x00\xff\x76\x64\x6a\x08\xff\xd3\x59\x89\x7e\x64\xeb\x07\x83\x60\x08\x00\x51\xff\xd3\x8b\x45\xf8\x59\x89\x46\x60\x83\xc8\xff\x5b\x5f\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\xb8\x63\x73\x6d\xe0\x39\x45\x08\x75\x0d\xff\x75\x0c\x50\xe8\x88\xfe\xff\xff\x59\x59\x5d\xc3\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xa1\x00\xe0\x00\x10\x83\x65\xf8\x00\x83\x65\xfc\x00\x53\x57\xbf\x4e\xe6\x40\xbb\xbb\x00\x00\xff\xff\x3b\xc7\x74\x0d\x85\xc3\x74\x09\xf7\xd0\xa3\x04\xe0\x00\x10\xeb\x60\x56\x8d\x45\xf8\x50\xff\x15\xdc\xb0\x00\x10\x8b\x75\xfc\x33\x75\xf8\xff\x15\xd8\xb0\x00\x10\x33\xf0\xff\x15\x48\xb0\x00\x10\x33\xf0\xff\x15\xd4\xb0\x00\x10\x33\xf0\x8d\x45\xf0\x50\xff\x15\xd0\xb0\x00\x10\x8b\x45\xf4\x33\x45\xf0\x33\xf0\x3b\xf7\x75\x07\xbe\x4f\xe6\x40\xbb\xeb\x0b\x85\xf3\x75\x07\x8b\xc6\xc1\xe0\x10\x0b\xf0\x89\x35\x00\xe0\x00\x10\xf7\xd6\x89\x35\x04\xe0\x00\x10\x5e\x5f\x5b\xc9\xc3\x83\x25\x28\xfd\x00\x10\x00\xc3\x6a\x10\x68\x50\xc6\x00\x10\xe8\x5d\xe9\xff\xff\x33\xdb\x89\x5d\xe4\x6a\x01\xe8\x96\x03\x00\x00\x59\x89\x5d\xfc\x6a\x03\x5f\x89\x7d\xe0\x3b\x3d\x60\x0e\x01\x10\x7d\x57\x8b\xf7\xc1\xe6\x02\xa1\x5c\xfe\x00\x10\x03\xc6\x39\x18\x74\x44\x8b\x00\xf6\x40\x0c\x83\x74\x0f\x50\xe8\xf1\x2f\x00\x00\x59\x83\xf8\xff\x74\x03\xff\x45\xe4\x83\xff\x14\x7c\x28\xa1\x5c\xfe\x00\x10\x8b\x04\x06\x83\xc0\x20\x50\xff\x15\xa8\xb0\x00\x10\xa1\x5c\xfe\x00\x10\xff\x34\x06\xe8\xef\xf0\xff\xff\x59\xa1\x5c\xfe\x00\x10\x89\x1c\x06\x47\xeb\x9e\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x19\xe9\xff\xff\xc3\x6a\x01\xe8\x37\x02\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x8b\x46\x0c\x8b\xc8\x80\xe1\x03\x33\xdb\x80\xf9\x02\x75\x40\xa9\x08\x01\x00\x00\x74\x39\x8b\x46\x08\x57\x8b\x3e\x2b\xf8\x85\xff\x7e\x2c\x57\x50\x56\xe8\x72\x03\x00\x00\x59\x50\xe8\x0e\x37\x00\x00\x83\xc4\x0c\x3b\xc7\x75\x0f\x8b\x46\x0c\x84\xc0\x79\x0f\x83\xe0\xfd\x89\x46\x0c\xeb\x07\x83\x4e\x0c\x20\x83\xcb\xff\x5f\x8b\x46\x08\x83\x66\x04\x00\x89\x06\x5e\x8b\xc3\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x75\x09\x56\xe8\x35\x00\x00\x00\x59\xeb\x2f\x56\xe8\x7c\xff\xff\xff\x59\x85\xc0\x74\x05\x83\xc8\xff\xeb\x1f\xf7\x46\x0c\x00\x40\x00\x00\x74\x14\x56\xe8\x09\x03\x00\x00\x50\xe8\x82\x37\x00\x00\x59\xf7\xd8\x59\x1b\xc0\xeb\x02\x33\xc0\x5e\x5d\xc3\x6a\x14\x68\x70\xc6\x00\x10\xe8\x0e\xe8\xff\xff\x33\xff\x89\x7d\xe4\x89\x7d\xdc\x6a\x01\xe8\x44\x02\x00\x00\x59\x89\x7d\xfc\x33\xf6\x89\x75\xe0\x3b\x35\x60\x0e\x01\x10\x0f\x8d\x83\x00\x00\x00\xa1\x5c\xfe\x00\x10\x8d\x04\xb0\x39\x38\x74\x5e\x8b\x00\xf6\x40\x0c\x83\x74\x56\x50\x56\xe8\xb4\xd7\xff\xff\x59\x59\x33\xd2\x42\x89\x55\xfc\xa1\x5c\xfe\x00\x10\x8b\x04\xb0\x8b\x48\x0c\xf6\xc1\x83\x74\x2f\x39\x55\x08\x75\x11\x50\xe8\x4a\xff\xff\xff\x59\x83\xf8\xff\x74\x1e\xff\x45\xe4\xeb\x19\x39\x7d\x08\x75\x14\xf6\xc1\x02\x74\x0f\x50\xe8\x2f\xff\xff\xff\x59\x83\xf8\xff\x75\x03\x09\x45\xdc\x89\x7d\xfc\xe8\x08\x00\x00\x00\x46\xeb\x84\x33\xff\x8b\x75\xe0\xa1\x5c\xfe\x00\x10\xff\x34\xb0\x56\xe8\xbd\xd7\xff\xff\x59\x59\xc3\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x12\x00\x00\x00\x83\x7d\x08\x01\x8b\x45\xe4\x74\x03\x8b\x45\xdc\xe8\x8f\xe7\xff\xff\xc3\x6a\x01\xe8\xad\x00\x00\x00\x59\xc3\x6a\x01\xe8\x1f\xff\xff\xff\x59\xc3\x8b\xff\x56\x57\x33\xf6\xbf\x88\xf3\x00\x10\x83\x3c\xf5\x6c\xe4\x00\x10\x01\x75\x1e\x8d\x04\xf5\x68\xe4\x00\x10\x89\x38\x68\xa0\x0f\x00\x00\xff\x30\x83\xc7\x18\xe8\x8c\x28\x00\x00\x59\x59\x85\xc0\x74\x0c\x46\x83\xfe\x24\x7c\xd2\x33\xc0\x40\x5f\x5e\xc3\x83\x24\xf5\x68\xe4\x00\x10\x00\x33\xc0\xeb\xf1\x8b\xff\x53\x8b\x1d\xa8\xb0\x00\x10\x56\xbe\x68\xe4\x00\x10\x57\x8b\x3e\x85\xff\x74\x13\x83\x7e\x04\x01\x74\x0d\x57\xff\xd3\x57\xe8\xc2\xee\xff\xff\x83\x26\x00\x59\x83\xc6\x08\x81\xfe\x88\xe5\x00\x10\x7c\xdc\xbe\x68\xe4\x00\x10\x5f\x8b\x06\x85\xc0\x74\x09\x83\x7e\x04\x01\x75\x03\x50\xff\xd3\x83\xc6\x08\x81\xfe\x88\xe5\x00\x10\x7c\xe6\x5e\x5b\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xff\x34\xc5\x68\xe4\x00\x10\xff\x15\x68\xb0\x00\x10\x5d\xc3\x6a\x0c\x68\x98\xc6\x00\x10\xe8\x72\xe6\xff\xff\x33\xff\x47\x89\x7d\xe4\x33\xdb\x39\x1d\x84\xf3\x00\x10\x75\x18\xe8\xdf\x23\x00\x00\x6a\x1e\xe8\x2d\x22\x00\x00\x68\xff\x00\x00\x00\xe8\x38\xf0\xff\xff\x59\x59\x8b\x75\x08\x8d\x34\xf5\x68\xe4\x00\x10\x39\x1e\x74\x04\x8b\xc7\xeb\x6e\x6a\x18\xe8\xba\xee\xff\xff\x59\x8b\xf8\x3b\xfb\x75\x0f\xe8\xdb\xe5\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\xeb\x51\x6a\x0a\xe8\x59\x00\x00\x00\x59\x89\x5d\xfc\x39\x1e\x75\x2c\x68\xa0\x0f\x00\x00\x57\xe8\x83\x27\x00\x00\x59\x59\x85\xc0\x75\x17\x57\xe8\xf0\xed\xff\xff\x59\xe8\xa5\xe5\xff\xff\xc7\x00\x0c\x00\x00\x00\x89\x5d\xe4\xeb\x0b\x89\x3e\xeb\x07\x57\xe8\xd5\xed\xff\xff\x59\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x0a\xe6\xff\xff\xc3\x6a\x0a\xe8\x28\xff\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x8d\x34\xc5\x68\xe4\x00\x10\x83\x3e\x00\x75\x13\x50\xe8\x22\xff\xff\xff\x59\x85\xc0\x75\x08\x6a\x11\xe8\x2c\xef\xff\xff\x59\xff\x36\xff\x15\x64\xb0\x00\x10\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\xfe\x75\x0f\xe8\x2c\xe5\xff\xff\xc7\x00\x09\x00\x00\x00\x33\xc0\x5d\xc3\x56\x33\xf6\x3b\xc6\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x1c\xe8\x0e\xe5\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x09\x00\x00\x00\xe8\x96\xe4\xff\xff\x83\xc4\x14\x33\xc0\xeb\x1a\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x0f\xbe\x44\x01\x04\x83\xe0\x40\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x56\x33\xf6\x3b\xc6\x75\x1d\xe8\xc6\xe4\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x4e\xe4\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x03\x8b\x40\x10\x5e\x5d\xc3\x2d\xa4\x03\x00\x00\x74\x22\x83\xe8\x04\x74\x17\x83\xe8\x0d\x74\x0c\x48\x74\x03\x33\xc0\xc3\xb8\x04\x04\x00\x00\xc3\xb8\x12\x04\x00\x00\xc3\xb8\x04\x08\x00\x00\xc3\xb8\x11\x04\x00\x00\xc3\x8b\xff\x56\x57\x8b\xf0\x68\x01\x01\x00\x00\x33\xff\x8d\x46\x1c\x57\x50\xe8\x50\x0e\x00\x00\x33\xc0\x0f\xb7\xc8\x8b\xc1\x89\x7e\x04\x89\x7e\x08\x89\x7e\x0c\xc1\xe1\x10\x0b\xc1\x8d\x7e\x10\xab\xab\xab\xb9\x88\xe5\x00\x10\x83\xc4\x0c\x8d\x46\x1c\x2b\xce\xbf\x01\x01\x00\x00\x8a\x14\x01\x88\x10\x40\x4f\x75\xf7\x8d\x86\x1d\x01\x00\x00\xbe\x00\x01\x00\x00\x8a\x14\x08\x88\x10\x40\x4e\x75\xf7\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x81\xec\x1c\x05\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x57\x8d\x85\xe8\xfa\xff\xff\x50\xff\x76\x04\xff\x15\xe0\xb0\x00\x10\xbf\x00\x01\x00\x00\x85\xc0\x0f\x84\xfb\x00\x00\x00\x33\xc0\x88\x84\x05\xfc\xfe\xff\xff\x40\x3b\xc7\x72\xf4\x8a\x85\xee\xfa\xff\xff\xc6\x85\xfc\xfe\xff\xff\x20\x84\xc0\x74\x2e\x8d\x9d\xef\xfa\xff\xff\x0f\xb6\xc8\x0f\xb6\x03\x3b\xc8\x77\x16\x2b\xc1\x40\x50\x8d\x94\x0d\xfc\xfe\xff\xff\x6a\x20\x52\xe8\x8d\x0d\x00\x00\x83\xc4\x0c\x43\x8a\x03\x43\x84\xc0\x75\xd8\x6a\x00\xff\x76\x0c\x8d\x85\xfc\xfa\xff\xff\xff\x76\x04\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x6a\x01\x6a\x00\xe8\xbe\x39\x00\x00\x33\xdb\x53\xff\x76\x04\x8d\x85\xfc\xfd\xff\xff\x57\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x57\xff\x76\x0c\x53\xe8\x9f\x37\x00\x00\x83\xc4\x44\x53\xff\x76\x04\x8d\x85\xfc\xfc\xff\xff\x57\x50\x57\x8d\x85\xfc\xfe\xff\xff\x50\x68\x00\x02\x00\x00\xff\x76\x0c\x53\xe8\x7a\x37\x00\x00\x83\xc4\x24\x33\xc0\x0f\xb7\x8c\x45\xfc\xfa\xff\xff\xf6\xc1\x01\x74\x0e\x80\x4c\x06\x1d\x10\x8a\x8c\x05\xfc\xfd\xff\xff\xeb\x11\xf6\xc1\x02\x74\x15\x80\x4c\x06\x1d\x20\x8a\x8c\x05\xfc\xfc\xff\xff\x88\x8c\x06\x1d\x01\x00\x00\xeb\x08\xc6\x84\x06\x1d\x01\x00\x00\x00\x40\x3b\xc7\x72\xbe\xeb\x56\x8d\x86\x1d\x01\x00\x00\xc7\x85\xe4\xfa\xff\xff\x9f\xff\xff\xff\x33\xc9\x29\x85\xe4\xfa\xff\xff\x8b\x95\xe4\xfa\xff\xff\x8d\x84\x0e\x1d\x01\x00\x00\x03\xd0\x8d\x5a\x20\x83\xfb\x19\x77\x0c\x80\x4c\x0e\x1d\x10\x8a\xd1\x80\xc2\x20\xeb\x0f\x83\xfa\x19\x77\x0e\x80\x4c\x0e\x1d\x20\x8a\xd1\x80\xea\x20\x88\x10\xeb\x03\xc6\x00\x00\x41\x3b\xcf\x72\xc2\x8b\x4d\xfc\x5f\x33\xcd\x5b\xe8\xa0\xcc\xff\xff\xc9\xc3\x6a\x0c\x68\xb8\xc6\x00\x10\xe8\xc0\xe2\xff\xff\xe8\x72\xe7\xff\xff\x8b\xf8\xa1\xac\xea\x00\x10\x85\x47\x70\x74\x1d\x83\x7f\x6c\x00\x74\x17\x8b\x77\x68\x85\xf6\x75\x08\x6a\x20\xe8\x33\xec\xff\xff\x59\x8b\xc6\xe8\xd8\xe2\xff\xff\xc3\x6a\x0d\xe8\xd0\xfc\xff\xff\x59\x83\x65\xfc\x00\x8b\x77\x68\x89\x75\xe4\x3b\x35\xb0\xe9\x00\x10\x74\x36\x85\xf6\x74\x1a\x56\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x0f\x81\xfe\x88\xe5\x00\x10\x74\x07\x56\xe8\x56\xea\xff\xff\x59\xa1\xb0\xe9\x00\x10\x89\x47\x68\x8b\x35\xb0\xe9\x00\x10\x89\x75\xe4\x56\xff\x15\x80\xb0\x00\x10\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x05\x00\x00\x00\xeb\x8e\x8b\x75\xe4\x6a\x0d\xe8\x95\xfb\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x33\xdb\x53\x8d\x4d\xf0\xe8\x66\xd3\xff\xff\x89\x1d\xd8\xf4\x00\x10\x83\xfe\xfe\x75\x1e\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xff\x15\xe8\xb0\x00\x10\x38\x5d\xfc\x74\x45\x8b\x4d\xf8\x83\x61\x70\xfd\xeb\x3c\x83\xfe\xfd\x75\x12\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xff\x15\xe4\xb0\x00\x10\xeb\xdb\x83\xfe\xfc\x75\x12\x8b\x45\xf0\x8b\x40\x04\xc7\x05\xd8\xf4\x00\x10\x01\x00\x00\x00\xeb\xc4\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x8b\xc6\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x20\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x8b\x5d\x0c\x56\x8b\x75\x08\x57\xe8\x64\xff\xff\xff\x8b\xf8\x33\xf6\x89\x7d\x08\x3b\xfe\x75\x0e\x8b\xc3\xe8\xb7\xfc\xff\xff\x33\xc0\xe9\x9d\x01\x00\x00\x89\x75\xe4\x33\xc0\x39\xb8\xb8\xe9\x00\x10\x0f\x84\x91\x00\x00\x00\xff\x45\xe4\x83\xc0\x30\x3d\xf0\x00\x00\x00\x72\xe7\x81\xff\xe8\xfd\x00\x00\x0f\x84\x70\x01\x00\x00\x81\xff\xe9\xfd\x00\x00\x0f\x84\x64\x01\x00\x00\x0f\xb7\xc7\x50\xff\x15\xec\xb0\x00\x10\x85\xc0\x0f\x84\x52\x01\x00\x00\x8d\x45\xe8\x50\x57\xff\x15\xe0\xb0\x00\x10\x85\xc0\x0f\x84\x33\x01\x00\x00\x68\x01\x01\x00\x00\x8d\x43\x1c\x56\x50\xe8\xad\x0a\x00\x00\x33\xd2\x42\x83\xc4\x0c\x89\x7b\x04\x89\x73\x0c\x39\x55\xe8\x0f\x86\xf8\x00\x00\x00\x80\x7d\xee\x00\x0f\x84\xcf\x00\x00\x00\x8d\x75\xef\x8a\x0e\x84\xc9\x0f\x84\xc2\x00\x00\x00\x0f\xb6\x46\xff\x0f\xb6\xc9\xe9\xa6\x00\x00\x00\x68\x01\x01\x00\x00\x8d\x43\x1c\x56\x50\xe8\x66\x0a\x00\x00\x8b\x4d\xe4\x83\xc4\x0c\x6b\xc9\x30\x89\x75\xe0\x8d\xb1\xc8\xe9\x00\x10\x89\x75\xe4\xeb\x2a\x8a\x46\x01\x84\xc0\x74\x28\x0f\xb6\x3e\x0f\xb6\xc0\xeb\x12\x8b\x45\xe0\x8a\x80\xb4\xe9\x00\x10\x08\x44\x3b\x1d\x0f\xb6\x46\x01\x47\x3b\xf8\x76\xea\x8b\x7d\x08\x46\x46\x80\x3e\x00\x75\xd1\x8b\x75\xe4\xff\x45\xe0\x83\xc6\x08\x83\x7d\xe0\x04\x89\x75\xe4\x72\xe9\x8b\xc7\x89\x7b\x04\xc7\x43\x08\x01\x00\x00\x00\xe8\x67\xfb\xff\xff\x6a\x06\x89\x43\x0c\x8d\x43\x10\x8d\x89\xbc\xe9\x00\x10\x5a\x66\x8b\x31\x41\x66\x89\x30\x41\x40\x40\x4a\x75\xf3\x8b\xf3\xe8\xd7\xfb\xff\xff\xe9\xb7\xfe\xff\xff\x80\x4c\x03\x1d\x04\x40\x3b\xc1\x76\xf6\x46\x46\x80\x7e\xff\x00\x0f\x85\x34\xff\xff\xff\x8d\x43\x1e\xb9\xfe\x00\x00\x00\x80\x08\x08\x40\x49\x75\xf9\x8b\x43\x04\xe8\x12\xfb\xff\xff\x89\x43\x0c\x89\x53\x08\xeb\x03\x89\x73\x08\x33\xc0\x0f\xb7\xc8\x8b\xc1\xc1\xe1\x10\x0b\xc1\x8d\x7b\x10\xab\xab\xab\xeb\xa8\x39\x35\xd8\xf4\x00\x10\x0f\x85\x58\xfe\xff\xff\x83\xc8\xff\x8b\x4d\xfc\x5f\x5e\x33\xcd\x5b\xe8\x9b\xc9\xff\xff\xc9\xc3\x6a\x14\x68\xd8\xc6\x00\x10\xe8\xbb\xdf\xff\xff\x83\x4d\xe0\xff\xe8\x69\xe4\xff\xff\x8b\xf8\x89\x7d\xdc\xe8\xdc\xfc\xff\xff\x8b\x5f\x68\x8b\x75\x08\xe8\x75\xfd\xff\xff\x89\x45\x08\x3b\x43\x04\x0f\x84\x57\x01\x00\x00\x68\x20\x02\x00\x00\xe8\x10\xe8\xff\xff\x59\x8b\xd8\x85\xdb\x0f\x84\x46\x01\x00\x00\xb9\x88\x00\x00\x00\x8b\x77\x68\x8b\xfb\xf3\xa5\x83\x23\x00\x53\xff\x75\x08\xe8\xb8\xfd\xff\xff\x59\x59\x89\x45\xe0\x85\xc0\x0f\x85\xfc\x00\x00\x00\x8b\x75\xdc\xff\x76\x68\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x11\x8b\x46\x68\x3d\x88\xe5\x00\x10\x74\x07\x50\xe8\x32\xe7\xff\xff\x59\x89\x5e\x68\x53\x8b\x3d\x80\xb0\x00\x10\xff\xd7\xf6\x46\x70\x02\x0f\x85\xea\x00\x00\x00\xf6\x05\xac\xea\x00\x10\x01\x0f\x85\xdd\x00\x00\x00\x6a\x0d\xe8\x51\xf9\xff\xff\x59\x83\x65\xfc\x00\x8b\x43\x04\xa3\xe8\xf4\x00\x10\x8b\x43\x08\xa3\xec\xf4\x00\x10\x8b\x43\x0c\xa3\xf0\xf4\x00\x10\x33\xc0\x89\x45\xe4\x83\xf8\x05\x7d\x10\x66\x8b\x4c\x43\x10\x66\x89\x0c\x45\xdc\xf4\x00\x10\x40\xeb\xe8\x33\xc0\x89\x45\xe4\x3d\x01\x01\x00\x00\x7d\x0d\x8a\x4c\x18\x1c\x88\x88\xa8\xe7\x00\x10\x40\xeb\xe9\x33\xc0\x89\x45\xe4\x3d\x00\x01\x00\x00\x7d\x10\x8a\x8c\x18\x1d\x01\x00\x00\x88\x88\xb0\xe8\x00\x10\x40\xeb\xe6\xff\x35\xb0\xe9\x00\x10\xff\x15\x88\xb0\x00\x10\x85\xc0\x75\x13\xa1\xb0\xe9\x00\x10\x3d\x88\xe5\x00\x10\x74\x07\x50\xe8\x79\xe6\xff\xff\x59\x89\x1d\xb0\xe9\x00\x10\x53\xff\xd7\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x02\x00\x00\x00\xeb\x30\x6a\x0d\xe8\xca\xf7\xff\xff\x59\xc3\xeb\x25\x83\xf8\xff\x75\x20\x81\xfb\x88\xe5\x00\x10\x74\x07\x53\xe8\x43\xe6\xff\xff\x59\xe8\xf8\xdd\xff\xff\xc7\x00\x16\x00\x00\x00\xeb\x04\x83\x65\xe0\x00\x8b\x45\xe0\xe8\x73\xde\xff\xff\xc3\x83\x3d\x4c\xfe\x00\x10\x00\x75\x12\x6a\xfd\xe8\x56\xfe\xff\xff\x59\xc7\x05\x4c\xfe\x00\x10\x01\x00\x00\x00\x33\xc0\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x8b\x86\xbc\x00\x00\x00\x33\xdb\x57\x3b\xc3\x74\x6f\x3d\x58\xed\x00\x10\x74\x68\x8b\x86\xb0\x00\x00\x00\x3b\xc3\x74\x5e\x39\x18\x75\x5a\x8b\x86\xb8\x00\x00\x00\x3b\xc3\x74\x17\x39\x18\x75\x13\x50\xe8\xca\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\xe0\x35\x00\x00\x59\x59\x8b\x86\xb4\x00\x00\x00\x3b\xc3\x74\x17\x39\x18\x75\x13\x50\xe8\xa9\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\x7a\x35\x00\x00\x59\x59\xff\xb6\xb0\x00\x00\x00\xe8\x91\xe5\xff\xff\xff\xb6\xbc\x00\x00\x00\xe8\x86\xe5\xff\xff\x59\x59\x8b\x86\xc0\x00\x00\x00\x3b\xc3\x74\x44\x39\x18\x75\x40\x8b\x86\xc4\x00\x00\x00\x2d\xfe\x00\x00\x00\x50\xe8\x65\xe5\xff\xff\x8b\x86\xcc\x00\x00\x00\xbf\x80\x00\x00\x00\x2b\xc7\x50\xe8\x52\xe5\xff\xff\x8b\x86\xd0\x00\x00\x00\x2b\xc7\x50\xe8\x44\xe5\xff\xff\xff\xb6\xc0\x00\x00\x00\xe8\x39\xe5\xff\xff\x83\xc4\x10\x8d\xbe\xd4\x00\x00\x00\x8b\x07\x3d\x98\xec\x00\x10\x74\x17\x39\x98\xb4\x00\x00\x00\x75\x0f\x50\xe8\x60\x33\x00\x00\xff\x37\xe8\x12\xe5\xff\xff\x59\x59\x8d\x7e\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7f\xf8\xb0\xea\x00\x10\x74\x11\x8b\x07\x3b\xc3\x74\x0b\x39\x18\x75\x07\x50\xe8\xed\xe4\xff\xff\x59\x39\x5f\xfc\x74\x12\x8b\x47\x04\x3b\xc3\x74\x0b\x39\x18\x75\x07\x50\xe8\xd6\xe4\xff\xff\x59\x83\xc7\x10\xff\x4d\x08\x75\xc7\x56\xe8\xc7\xe4\xff\xff\x59\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x35\x80\xb0\x00\x10\x57\x8b\x7d\x08\x57\xff\xd6\x8b\x87\xb0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb8\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb4\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xc0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8d\x5f\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7b\xf8\xb0\xea\x00\x10\x74\x09\x8b\x03\x85\xc0\x74\x03\x50\xff\xd6\x83\x7b\xfc\x00\x74\x0a\x8b\x43\x04\x85\xc0\x74\x03\x50\xff\xd6\x83\xc3\x10\xff\x4d\x08\x75\xd6\x8b\x87\xd4\x00\x00\x00\x05\xb4\x00\x00\x00\x50\xff\xd6\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x57\x8b\x7d\x08\x85\xff\x0f\x84\x83\x00\x00\x00\x53\x56\x8b\x35\x88\xb0\x00\x10\x57\xff\xd6\x8b\x87\xb0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb8\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xb4\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8b\x87\xc0\x00\x00\x00\x85\xc0\x74\x03\x50\xff\xd6\x8d\x5f\x50\xc7\x45\x08\x06\x00\x00\x00\x81\x7b\xf8\xb0\xea\x00\x10\x74\x09\x8b\x03\x85\xc0\x74\x03\x50\xff\xd6\x83\x7b\xfc\x00\x74\x0a\x8b\x43\x04\x85\xc0\x74\x03\x50\xff\xd6\x83\xc3\x10\xff\x4d\x08\x75\xd6\x8b\x87\xd4\x00\x00\x00\x05\xb4\x00\x00\x00\x50\xff\xd6\x5e\x5b\x8b\xc7\x5f\x5d\xc3\x85\xff\x74\x37\x85\xc0\x74\x33\x56\x8b\x30\x3b\xf7\x74\x28\x57\x89\x38\xe8\xc1\xfe\xff\xff\x59\x85\xf6\x74\x1b\x56\xe8\x45\xff\xff\xff\x83\x3e\x00\x59\x75\x0f\x81\xfe\xb8\xea\x00\x10\x74\x07\x56\xe8\x59\xfd\xff\xff\x59\x8b\xc7\x5e\xc3\x33\xc0\xc3\x6a\x0c\x68\xf8\xc6\x00\x10\xe8\x54\xdb\xff\xff\xe8\x06\xe0\xff\xff\x8b\xf0\xa1\xac\xea\x00\x10\x85\x46\x70\x74\x22\x83\x7e\x6c\x00\x74\x1c\xe8\xef\xdf\xff\xff\x8b\x70\x6c\x85\xf6\x75\x08\x6a\x20\xe8\xc2\xe4\xff\xff\x59\x8b\xc6\xe8\x67\xdb\xff\xff\xc3\x6a\x0c\xe8\x5f\xf5\xff\xff\x59\x83\x65\xfc\x00\x8d\x46\x6c\x8b\x3d\x90\xeb\x00\x10\xe8\x69\xff\xff\xff\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x02\x00\x00\x00\xeb\xc1\x6a\x0c\xe8\x5a\xf4\xff\xff\x59\x8b\x75\xe4\xc3\x8b\xff\x55\x8b\xec\x51\x56\x8b\x75\x0c\x56\xe8\xb6\xf5\xff\xff\x89\x45\x0c\x8b\x46\x0c\x59\xa8\x82\x75\x17\xe8\x80\xda\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4e\x0c\x20\x83\xc8\xff\xe9\x2f\x01\x00\x00\xa8\x40\x74\x0d\xe8\x65\xda\xff\xff\xc7\x00\x22\x00\x00\x00\xeb\xe3\x53\x33\xdb\xa8\x01\x74\x16\x89\x5e\x04\xa8\x10\x0f\x84\x87\x00\x00\x00\x8b\x4e\x08\x83\xe0\xfe\x89\x0e\x89\x46\x0c\x8b\x46\x0c\x83\xe0\xef\x83\xc8\x02\x89\x46\x0c\x89\x5e\x04\x89\x5d\xfc\xa9\x0c\x01\x00\x00\x75\x2c\xe8\x39\xc9\xff\xff\x83\xc0\x20\x3b\xf0\x74\x0c\xe8\x2d\xc9\xff\xff\x83\xc0\x40\x3b\xf0\x75\x0d\xff\x75\x0c\xe8\xc9\xf4\xff\xff\x59\x85\xc0\x75\x07\x56\xe8\xd8\x36\x00\x00\x59\xf7\x46\x0c\x08\x01\x00\x00\x57\x0f\x84\x80\x00\x00\x00\x8b\x46\x08\x8b\x3e\x8d\x48\x01\x89\x0e\x8b\x4e\x18\x2b\xf8\x49\x3b\xfb\x89\x4e\x04\x7e\x1d\x57\x50\xff\x75\x0c\xe8\x95\x28\x00\x00\x83\xc4\x0c\x89\x45\xfc\xeb\x4d\x83\xc8\x20\x89\x46\x0c\x83\xc8\xff\xeb\x79\x8b\x4d\x0c\x83\xf9\xff\x74\x1b\x83\xf9\xfe\x74\x16\x8b\xc1\x83\xe0\x1f\x8b\xd1\xc1\xfa\x05\xc1\xe0\x06\x03\x04\x95\x40\xfd\x00\x10\xeb\x05\xb8\x10\xe4\x00\x10\xf6\x40\x04\x20\x74\x14\x6a\x02\x53\x53\x51\xe8\x44\x35\x00\x00\x23\xc2\x83\xc4\x10\x83\xf8\xff\x74\x25\x8b\x46\x08\x8a\x4d\x08\x88\x08\xeb\x16\x33\xff\x47\x57\x8d\x45\x08\x50\xff\x75\x0c\xe8\x26\x28\x00\x00\x83\xc4\x0c\x89\x45\xfc\x39\x7d\xfc\x74\x09\x83\x4e\x0c\x20\x83\xc8\xff\xeb\x08\x8b\x45\x08\x25\xff\x00\x00\x00\x5f\x5b\x5e\xc9\xc3\x8b\xff\x56\x57\x33\xff\x8d\xb7\xa0\xeb\x00\x10\xff\x36\xe8\x63\xdb\xff\xff\x83\xc7\x04\x59\x89\x06\x83\xff\x28\x72\xe8\x5f\x5e\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x4c\x24\x04\xf7\xc1\x03\x00\x00\x00\x74\x24\x8a\x01\x83\xc1\x01\x84\xc0\x74\x4e\xf7\xc1\x03\x00\x00\x00\x75\xef\x05\x00\x00\x00\x00\x8d\xa4\x24\x00\x00\x00\x00\x8d\xa4\x24\x00\x00\x00\x00\x8b\x01\xba\xff\xfe\xfe\x7e\x03\xd0\x83\xf0\xff\x33\xc2\x83\xc1\x04\xa9\x00\x01\x01\x81\x74\xe8\x8b\x41\xfc\x84\xc0\x74\x32\x84\xe4\x74\x24\xa9\x00\x00\xff\x00\x74\x13\xa9\x00\x00\x00\xff\x74\x02\xeb\xcd\x8d\x41\xff\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfe\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfd\x8b\x4c\x24\x04\x2b\xc1\xc3\x8d\x41\xfc\x8b\x4c\x24\x04\x2b\xc1\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x56\x8b\x75\x0c\x33\xdb\x57\x8b\x7d\x10\x3b\xf3\x75\x14\x3b\xfb\x76\x10\x8b\x45\x08\x3b\xc3\x74\x02\x89\x18\x33\xc0\xe9\x83\x00\x00\x00\x8b\x45\x08\x3b\xc3\x74\x03\x83\x08\xff\x81\xff\xff\xff\xff\x7f\x76\x1b\xe8\x45\xd8\xff\xff\x6a\x16\x5e\x53\x53\x53\x53\x53\x89\x30\xe8\xce\xd7\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x56\xff\x75\x18\x8d\x4d\xf0\xe8\xc0\xc9\xff\xff\x8b\x45\xf0\x39\x58\x14\x0f\x85\x9c\x00\x00\x00\x66\x8b\x45\x14\xb9\xff\x00\x00\x00\x66\x3b\xc1\x76\x36\x3b\xf3\x74\x0f\x3b\xfb\x76\x0b\x57\x53\x56\xe8\xe8\x01\x00\x00\x83\xc4\x0c\xe8\xf2\xd7\xff\xff\xc7\x00\x2a\x00\x00\x00\xe8\xe7\xd7\xff\xff\x8b\x00\x38\x5d\xfc\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\x5f\x5e\x5b\xc9\xc3\x3b\xf3\x74\x32\x3b\xfb\x77\x2c\xe8\xc7\xd7\xff\xff\x6a\x22\x5e\x53\x53\x53\x53\x53\x89\x30\xe8\x50\xd7\xff\xff\x83\xc4\x14\x38\x5d\xfc\x0f\x84\x79\xff\xff\xff\x8b\x45\xf8\x83\x60\x70\xfd\xe9\x6d\xff\xff\xff\x88\x06\x8b\x45\x08\x3b\xc3\x74\x06\xc7\x00\x01\x00\x00\x00\x38\x5d\xfc\x0f\x84\x25\xff\xff\xff\x8b\x45\xf8\x83\x60\x70\xfd\xe9\x19\xff\xff\xff\x8d\x4d\x0c\x51\x53\x57\x56\x6a\x01\x8d\x4d\x14\x51\x53\x89\x5d\x0c\xff\x70\x04\xff\x15\xbc\xb0\x00\x10\x3b\xc3\x74\x14\x39\x5d\x0c\x0f\x85\x5e\xff\xff\xff\x8b\x4d\x08\x3b\xcb\x74\xbd\x89\x01\xeb\xb9\xff\x15\x00\xb0\x00\x10\x83\xf8\x7a\x0f\x85\x44\xff\xff\xff\x3b\xf3\x0f\x84\x67\xff\xff\xff\x3b\xfb\x0f\x86\x5f\xff\xff\xff\x57\x53\x56\xe8\x11\x01\x00\x00\x83\xc4\x0c\xe9\x4f\xff\xff\xff\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\x7c\xfe\xff\xff\x83\xc4\x14\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x0c\x8d\x4d\xf0\xe8\x87\xc8\xff\xff\x0f\xb6\x45\x08\x8b\x4d\xf0\x8b\x89\xc8\x00\x00\x00\x0f\xb7\x04\x41\x25\x00\x80\x00\x00\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x08\xe8\xb9\xff\xff\xff\x59\x59\x5d\xc3\xcc\x56\x8b\x44\x24\x14\x0b\xc0\x75\x28\x8b\x4c\x24\x10\x8b\x44\x24\x0c\x33\xd2\xf7\xf1\x8b\xd8\x8b\x44\x24\x08\xf7\xf1\x8b\xf0\x8b\xc3\xf7\x64\x24\x10\x8b\xc8\x8b\xc6\xf7\x64\x24\x10\x03\xd1\xeb\x47\x8b\xc8\x8b\x5c\x24\x10\x8b\x54\x24\x0c\x8b\x44\x24\x08\xd1\xe9\xd1\xdb\xd1\xea\xd1\xd8\x0b\xc9\x75\xf4\xf7\xf3\x8b\xf0\xf7\x64\x24\x14\x8b\xc8\x8b\x44\x24\x10\xf7\xe6\x03\xd1\x72\x0e\x3b\x54\x24\x0c\x77\x08\x72\x0f\x3b\x44\x24\x08\x76\x09\x4e\x2b\x44\x24\x10\x1b\x54\x24\x14\x33\xdb\x2b\x44\x24\x08\x1b\x54\x24\x0c\xf7\xda\xf7\xd8\x83\xda\x00\x8b\xca\x8b\xd3\x8b\xd9\x8b\xc8\x8b\xc6\x5e\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x54\x24\x0c\x8b\x4c\x24\x04\x85\xd2\x74\x69\x33\xc0\x8a\x44\x24\x08\x84\xc0\x75\x16\x81\xfa\x00\x01\x00\x00\x72\x0e\x83\x3d\x0c\xfd\x00\x10\x00\x74\x05\xe9\x6b\x33\x00\x00\x57\x8b\xf9\x83\xfa\x04\x72\x31\xf7\xd9\x83\xe1\x03\x74\x0c\x2b\xd1\x88\x07\x83\xc7\x01\x83\xe9\x01\x75\xf6\x8b\xc8\xc1\xe0\x08\x03\xc1\x8b\xc8\xc1\xe0\x10\x03\xc1\x8b\xca\x83\xe2\x03\xc1\xe9\x02\x74\x06\xf3\xab\x85\xd2\x74\x0a\x88\x07\x83\xc7\x01\x83\xea\x01\x75\xf6\x8b\x44\x24\x08\x5f\xc3\x8b\x44\x24\x04\xc3\xcc\xcc\x53\x56\x57\x8b\x54\x24\x10\x8b\x44\x24\x14\x8b\x4c\x24\x18\x55\x52\x50\x51\x51\x68\x5c\x56\x00\x10\x64\xff\x35\x00\x00\x00\x00\xa1\x00\xe0\x00\x10\x33\xc4\x89\x44\x24\x08\x64\x89\x25\x00\x00\x00\x00\x8b\x44\x24\x30\x8b\x58\x08\x8b\x4c\x24\x2c\x33\x19\x8b\x70\x0c\x83\xfe\xfe\x74\x3b\x8b\x54\x24\x34\x83\xfa\xfe\x74\x04\x3b\xf2\x76\x2e\x8d\x34\x76\x8d\x5c\xb3\x10\x8b\x0b\x89\x48\x0c\x83\x7b\x04\x00\x75\xcc\x68\x01\x01\x00\x00\x8b\x43\x08\xe8\x0e\x35\x00\x00\xb9\x01\x00\x00\x00\x8b\x43\x08\xe8\x20\x35\x00\x00\xeb\xb0\x64\x8f\x05\x00\x00\x00\x00\x83\xc4\x18\x5f\x5e\x5b\xc3\x8b\x4c\x24\x04\xf7\x41\x04\x06\x00\x00\x00\xb8\x01\x00\x00\x00\x74\x33\x8b\x44\x24\x08\x8b\x48\x08\x33\xc8\xe8\x02\xbf\xff\xff\x55\x8b\x68\x18\xff\x70\x0c\xff\x70\x10\xff\x70\x14\xe8\x3e\xff\xff\xff\x83\xc4\x0c\x5d\x8b\x44\x24\x08\x8b\x54\x24\x10\x89\x02\xb8\x03\x00\x00\x00\xc3\x55\x8b\x4c\x24\x08\x8b\x29\xff\x71\x1c\xff\x71\x18\xff\x71\x28\xe8\x15\xff\xff\xff\x83\xc4\x0c\x5d\xc2\x04\x00\x55\x56\x57\x53\x8b\xea\x33\xc0\x33\xdb\x33\xd2\x33\xf6\x33\xff\xff\xd1\x5b\x5f\x5e\x5d\xc3\x8b\xea\x8b\xf1\x8b\xc1\x6a\x01\xe8\x6b\x34\x00\x00\x33\xc0\x33\xdb\x33\xc9\x33\xd2\x33\xff\xff\xe6\x55\x8b\xec\x53\x56\x57\x6a\x00\x6a\x00\x68\x03\x57\x00\x10\x51\xe8\x5b\x49\x00\x00\x5f\x5e\x5b\x5d\xc3\x55\x8b\x6c\x24\x08\x52\x51\xff\x74\x24\x14\xe8\xb4\xfe\xff\xff\x83\xc4\x0c\x5d\xc2\x08\x00\xcc\x8b\xff\x55\x8b\xec\x8b\x4d\x08\xb8\x4d\x5a\x00\x00\x66\x39\x01\x74\x04\x33\xc0\x5d\xc3\x8b\x41\x3c\x03\xc1\x81\x38\x50\x45\x00\x00\x75\xef\x33\xd2\xb9\x0b\x01\x00\x00\x66\x39\x48\x18\x0f\x94\xc2\x8b\xc2\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\x48\x3c\x03\xc8\x0f\xb7\x41\x14\x53\x56\x0f\xb7\x71\x06\x33\xd2\x57\x8d\x44\x08\x18\x85\xf6\x76\x1b\x8b\x7d\x0c\x8b\x48\x0c\x3b\xf9\x72\x09\x8b\x58\x08\x03\xd9\x3b\xfb\x72\x0a\x42\x83\xc0\x28\x3b\xd6\x72\xe8\x33\xc0\x5f\x5e\x5b\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\xff\x55\x8b\xec\x6a\xfe\x68\x18\xc7\x00\x10\x68\x10\x2c\x00\x10\x64\xa1\x00\x00\x00\x00\x50\x83\xec\x08\x53\x56\x57\xa1\x00\xe0\x00\x10\x31\x45\xf8\x33\xc5\x50\x8d\x45\xf0\x64\xa3\x00\x00\x00\x00\x89\x65\xe8\xc7\x45\xfc\x00\x00\x00\x00\x68\x00\x00\x00\x10\xe8\x2a\xff\xff\xff\x83\xc4\x04\x85\xc0\x74\x55\x8b\x45\x08\x2d\x00\x00\x00\x10\x50\x68\x00\x00\x00\x10\xe8\x50\xff\xff\xff\x83\xc4\x08\x85\xc0\x74\x3b\x8b\x40\x24\xc1\xe8\x1f\xf7\xd0\x83\xe0\x01\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\x45\xec\x8b\x08\x8b\x01\x33\xd2\x3d\x05\x00\x00\xc0\x0f\x94\xc2\x8b\xc2\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\x33\xc0\x8b\x4d\xf0\x64\x89\x0d\x00\x00\x00\x00\x59\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x0d\x10\xfd\x00\x10\xa1\x14\xfd\x00\x10\x6b\xc9\x14\x03\xc8\xeb\x11\x8b\x55\x08\x2b\x50\x0c\x81\xfa\x00\x00\x10\x00\x72\x09\x83\xc0\x14\x3b\xc1\x72\xeb\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\x8b\x4d\x08\x8b\x41\x10\x56\x8b\x75\x0c\x57\x8b\xfe\x2b\x79\x0c\x83\xc6\xfc\xc1\xef\x0f\x8b\xcf\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf0\x8b\x0e\x49\x89\x4d\xfc\xf6\xc1\x01\x0f\x85\xd3\x02\x00\x00\x53\x8d\x1c\x31\x8b\x13\x89\x55\xf4\x8b\x56\xfc\x89\x55\xf8\x8b\x55\xf4\x89\x5d\x0c\xf6\xc2\x01\x75\x74\xc1\xfa\x04\x4a\x83\xfa\x3f\x76\x03\x6a\x3f\x5a\x8b\x4b\x04\x3b\x4b\x08\x75\x42\xbb\x00\x00\x00\x80\x83\xfa\x20\x73\x19\x8b\xca\xd3\xeb\x8d\x4c\x02\x04\xf7\xd3\x21\x5c\xb8\x44\xfe\x09\x75\x23\x8b\x4d\x08\x21\x19\xeb\x1c\x8d\x4a\xe0\xd3\xeb\x8d\x4c\x02\x04\xf7\xd3\x21\x9c\xb8\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x5d\x0c\x8b\x53\x08\x8b\x5b\x04\x8b\x4d\xfc\x03\x4d\xf4\x89\x5a\x04\x8b\x55\x0c\x8b\x5a\x04\x8b\x52\x08\x89\x53\x08\x89\x4d\xfc\x8b\xd1\xc1\xfa\x04\x4a\x83\xfa\x3f\x76\x03\x6a\x3f\x5a\x8b\x5d\xf8\x83\xe3\x01\x89\x5d\xf4\x0f\x85\x8f\x00\x00\x00\x2b\x75\xf8\x8b\x5d\xf8\xc1\xfb\x04\x6a\x3f\x89\x75\x0c\x4b\x5e\x3b\xde\x76\x02\x8b\xde\x03\x4d\xf8\x8b\xd1\xc1\xfa\x04\x4a\x89\x4d\xfc\x3b\xd6\x76\x02\x8b\xd6\x3b\xda\x74\x5e\x8b\x4d\x0c\x8b\x71\x04\x3b\x71\x08\x75\x3b\xbe\x00\x00\x00\x80\x83\xfb\x20\x73\x17\x8b\xcb\xd3\xee\xf7\xd6\x21\x74\xb8\x44\xfe\x4c\x03\x04\x75\x21\x8b\x4d\x08\x21\x31\xeb\x1a\x8d\x4b\xe0\xd3\xee\xf7\xd6\x21\xb4\xb8\xc4\x00\x00\x00\xfe\x4c\x03\x04\x75\x06\x8b\x4d\x08\x21\x71\x04\x8b\x4d\x0c\x8b\x71\x08\x8b\x49\x04\x89\x4e\x04\x8b\x4d\x0c\x8b\x71\x04\x8b\x49\x08\x89\x4e\x08\x8b\x75\x0c\xeb\x03\x8b\x5d\x08\x83\x7d\xf4\x00\x75\x08\x3b\xda\x0f\x84\x80\x00\x00\x00\x8b\x4d\xf0\x8d\x0c\xd1\x8b\x59\x04\x89\x4e\x08\x89\x5e\x04\x89\x71\x04\x8b\x4e\x04\x89\x71\x08\x8b\x4e\x04\x3b\x4e\x08\x75\x60\x8a\x4c\x02\x04\x88\x4d\x0f\xfe\xc1\x88\x4c\x02\x04\x83\xfa\x20\x73\x25\x80\x7d\x0f\x00\x75\x0e\x8b\xca\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x19\xbb\x00\x00\x00\x80\x8b\xca\xd3\xeb\x8d\x44\xb8\x44\x09\x18\xeb\x29\x80\x7d\x0f\x00\x75\x10\x8d\x4a\xe0\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x59\x04\x8d\x4a\xe0\xba\x00\x00\x00\x80\xd3\xea\x8d\x84\xb8\xc4\x00\x00\x00\x09\x10\x8b\x45\xfc\x89\x06\x89\x44\x30\xfc\x8b\x45\xf0\xff\x08\x0f\x85\xf3\x00\x00\x00\xa1\x18\xf5\x00\x10\x85\xc0\x0f\x84\xd8\x00\x00\x00\x8b\x0d\x24\xfd\x00\x10\x8b\x35\xcc\xb0\x00\x10\x68\x00\x40\x00\x00\xc1\xe1\x0f\x03\x48\x0c\xbb\x00\x80\x00\x00\x53\x51\xff\xd6\x8b\x0d\x24\xfd\x00\x10\xa1\x18\xf5\x00\x10\xba\x00\x00\x00\x80\xd3\xea\x09\x50\x08\xa1\x18\xf5\x00\x10\x8b\x40\x10\x8b\x0d\x24\xfd\x00\x10\x83\xa4\x88\xc4\x00\x00\x00\x00\xa1\x18\xf5\x00\x10\x8b\x40\x10\xfe\x48\x43\xa1\x18\xf5\x00\x10\x8b\x48\x10\x80\x79\x43\x00\x75\x09\x83\x60\x04\xfe\xa1\x18\xf5\x00\x10\x83\x78\x08\xff\x75\x65\x53\x6a\x00\xff\x70\x0c\xff\xd6\xa1\x18\xf5\x00\x10\xff\x70\x10\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\x8b\x0d\x10\xfd\x00\x10\xa1\x18\xf5\x00\x10\x6b\xc9\x14\x8b\x15\x14\xfd\x00\x10\x2b\xc8\x8d\x4c\x11\xec\x51\x8d\x48\x14\x51\x50\xe8\x52\x32\x00\x00\x8b\x45\x08\x83\xc4\x0c\xff\x0d\x10\xfd\x00\x10\x3b\x05\x18\xf5\x00\x10\x76\x04\x83\x6d\x08\x14\xa1\x14\xfd\x00\x10\xa3\x1c\xfd\x00\x10\x8b\x45\x08\xa3\x18\xf5\x00\x10\x89\x3d\x24\xfd\x00\x10\x5b\x5f\x5e\xc9\xc3\xa1\x20\xfd\x00\x10\x56\x8b\x35\x10\xfd\x00\x10\x57\x33\xff\x3b\xf0\x75\x34\x83\xc0\x10\x6b\xc0\x14\x50\xff\x35\x14\xfd\x00\x10\x57\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x3b\xc7\x75\x04\x33\xc0\xeb\x78\x83\x05\x20\xfd\x00\x10\x10\x8b\x35\x10\xfd\x00\x10\xa3\x14\xfd\x00\x10\x6b\xf6\x14\x03\x35\x14\xfd\x00\x10\x68\xc4\x41\x00\x00\x6a\x08\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x89\x46\x10\x3b\xc7\x74\xc7\x6a\x04\x68\x00\x20\x00\x00\x68\x00\x00\x10\x00\x57\xff\x15\xf8\xb0\x00\x10\x89\x46\x0c\x3b\xc7\x75\x12\xff\x76\x10\x57\xff\x35\x84\xf3\x00\x10\xff\x15\x8c\xb0\x00\x10\xeb\x9b\x83\x4e\x08\xff\x89\x3e\x89\x7e\x04\xff\x05\x10\xfd\x00\x10\x8b\x46\x10\x83\x08\xff\x8b\xc6\x5f\x5e\xc3\x8b\xff\x55\x8b\xec\x51\x51\x8b\x4d\x08\x8b\x41\x08\x53\x56\x8b\x71\x10\x57\x33\xdb\xeb\x03\x03\xc0\x43\x85\xc0\x7d\xf9\x8b\xc3\x69\xc0\x04\x02\x00\x00\x8d\x84\x30\x44\x01\x00\x00\x6a\x3f\x89\x45\xf8\x5a\x89\x40\x08\x89\x40\x04\x83\xc0\x08\x4a\x75\xf4\x6a\x04\x8b\xfb\x68\x00\x10\x00\x00\xc1\xe7\x0f\x03\x79\x0c\x68\x00\x80\x00\x00\x57\xff\x15\xf8\xb0\x00\x10\x85\xc0\x75\x08\x83\xc8\xff\xe9\x9d\x00\x00\x00\x8d\x97\x00\x70\x00\x00\x89\x55\xfc\x3b\xfa\x77\x43\x8b\xca\x2b\xcf\xc1\xe9\x0c\x8d\x47\x10\x41\x83\x48\xf8\xff\x83\x88\xec\x0f\x00\x00\xff\x8d\x90\xfc\x0f\x00\x00\x89\x10\x8d\x90\xfc\xef\xff\xff\xc7\x40\xfc\xf0\x0f\x00\x00\x89\x50\x04\xc7\x80\xe8\x0f\x00\x00\xf0\x0f\x00\x00\x05\x00\x10\x00\x00\x49\x75\xcb\x8b\x55\xfc\x8b\x45\xf8\x05\xf8\x01\x00\x00\x8d\x4f\x0c\x89\x48\x04\x89\x41\x08\x8d\x4a\x0c\x89\x48\x08\x89\x41\x04\x83\x64\x9e\x44\x00\x33\xff\x47\x89\xbc\x9e\xc4\x00\x00\x00\x8a\x46\x43\x8a\xc8\xfe\xc1\x84\xc0\x8b\x45\x08\x88\x4e\x43\x75\x03\x09\x78\x04\xba\x00\x00\x00\x80\x8b\xcb\xd3\xea\xf7\xd2\x21\x50\x08\x8b\xc3\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\x8b\x4d\x08\x8b\x41\x10\x53\x56\x8b\x75\x10\x57\x8b\x7d\x0c\x8b\xd7\x2b\x51\x0c\x83\xc6\x17\xc1\xea\x0f\x8b\xca\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf4\x8b\x4f\xfc\x83\xe6\xf0\x49\x3b\xf1\x8d\x7c\x39\xfc\x8b\x1f\x89\x4d\x10\x89\x5d\xfc\x0f\x8e\x55\x01\x00\x00\xf6\xc3\x01\x0f\x85\x45\x01\x00\x00\x03\xd9\x3b\xf3\x0f\x8f\x3b\x01\x00\x00\x8b\x4d\xfc\xc1\xf9\x04\x49\x89\x4d\xf8\x83\xf9\x3f\x76\x06\x6a\x3f\x59\x89\x4d\xf8\x8b\x5f\x04\x3b\x5f\x08\x75\x43\xbb\x00\x00\x00\x80\x83\xf9\x20\x73\x1a\xd3\xeb\x8b\x4d\xf8\x8d\x4c\x01\x04\xf7\xd3\x21\x5c\x90\x44\xfe\x09\x75\x26\x8b\x4d\x08\x21\x19\xeb\x1f\x83\xc1\xe0\xd3\xeb\x8b\x4d\xf8\x8d\x4c\x01\x04\xf7\xd3\x21\x9c\x90\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x4f\x08\x8b\x5f\x04\x89\x59\x04\x8b\x4f\x04\x8b\x7f\x08\x89\x79\x08\x8b\x4d\x10\x2b\xce\x01\x4d\xfc\x83\x7d\xfc\x00\x0f\x8e\xa5\x00\x00\x00\x8b\x7d\xfc\x8b\x4d\x0c\xc1\xff\x04\x4f\x8d\x4c\x31\xfc\x83\xff\x3f\x76\x03\x6a\x3f\x5f\x8b\x5d\xf4\x8d\x1c\xfb\x89\x5d\x10\x8b\x5b\x04\x89\x59\x04\x8b\x5d\x10\x89\x59\x08\x89\x4b\x04\x8b\x59\x04\x89\x4b\x08\x8b\x59\x04\x3b\x59\x08\x75\x57\x8a\x4c\x07\x04\x88\x4d\x13\xfe\xc1\x88\x4c\x07\x04\x83\xff\x20\x73\x1c\x80\x7d\x13\x00\x75\x0e\x8b\xcf\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x19\x8d\x44\x90\x44\x8b\xcf\xeb\x20\x80\x7d\x13\x00\x75\x10\x8d\x4f\xe0\xbb\x00\x00\x00\x80\xd3\xeb\x8b\x4d\x08\x09\x59\x04\x8d\x84\x90\xc4\x00\x00\x00\x8d\x4f\xe0\xba\x00\x00\x00\x80\xd3\xea\x09\x10\x8b\x55\x0c\x8b\x4d\xfc\x8d\x44\x32\xfc\x89\x08\x89\x4c\x01\xfc\xeb\x03\x8b\x55\x0c\x8d\x46\x01\x89\x42\xfc\x89\x44\x32\xf8\xe9\x3c\x01\x00\x00\x33\xc0\xe9\x38\x01\x00\x00\x0f\x8d\x2f\x01\x00\x00\x8b\x5d\x0c\x29\x75\x10\x8d\x4e\x01\x89\x4b\xfc\x8d\x5c\x33\xfc\x8b\x75\x10\xc1\xfe\x04\x4e\x89\x5d\x0c\x89\x4b\xfc\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\xf6\x45\xfc\x01\x0f\x85\x80\x00\x00\x00\x8b\x75\xfc\xc1\xfe\x04\x4e\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\x8b\x4f\x04\x3b\x4f\x08\x75\x42\xbb\x00\x00\x00\x80\x83\xfe\x20\x73\x19\x8b\xce\xd3\xeb\x8d\x74\x06\x04\xf7\xd3\x21\x5c\x90\x44\xfe\x0e\x75\x23\x8b\x4d\x08\x21\x19\xeb\x1c\x8d\x4e\xe0\xd3\xeb\x8d\x4c\x06\x04\xf7\xd3\x21\x9c\x90\xc4\x00\x00\x00\xfe\x09\x75\x06\x8b\x4d\x08\x21\x59\x04\x8b\x5d\x0c\x8b\x4f\x08\x8b\x77\x04\x89\x71\x04\x8b\x77\x08\x8b\x4f\x04\x89\x71\x08\x8b\x75\x10\x03\x75\xfc\x89\x75\x10\xc1\xfe\x04\x4e\x83\xfe\x3f\x76\x03\x6a\x3f\x5e\x8b\x4d\xf4\x8d\x0c\xf1\x8b\x79\x04\x89\x4b\x08\x89\x7b\x04\x89\x59\x04\x8b\x4b\x04\x89\x59\x08\x8b\x4b\x04\x3b\x4b\x08\x75\x57\x8a\x4c\x06\x04\x88\x4d\x0f\xfe\xc1\x88\x4c\x06\x04\x83\xfe\x20\x73\x1c\x80\x7d\x0f\x00\x75\x0e\x8b\xce\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\x08\x09\x39\x8d\x44\x90\x44\x8b\xce\xeb\x20\x80\x7d\x0f\x00\x75\x10\x8d\x4e\xe0\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\x08\x09\x79\x04\x8d\x84\x90\xc4\x00\x00\x00\x8d\x4e\xe0\xba\x00\x00\x00\x80\xd3\xea\x09\x10\x8b\x45\x10\x89\x03\x89\x44\x18\xfc\x33\xc0\x40\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\xa1\x10\xfd\x00\x10\x8b\x4d\x08\x6b\xc0\x14\x03\x05\x14\xfd\x00\x10\x83\xc1\x17\x83\xe1\xf0\x89\x4d\xf0\xc1\xf9\x04\x53\x49\x83\xf9\x20\x56\x57\x7d\x0b\x83\xce\xff\xd3\xee\x83\x4d\xf8\xff\xeb\x0d\x83\xc1\xe0\x83\xca\xff\x33\xf6\xd3\xea\x89\x55\xf8\x8b\x0d\x1c\xfd\x00\x10\x8b\xd9\xeb\x11\x8b\x53\x04\x8b\x3b\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd8\x72\xe8\x3b\xd8\x75\x7f\x8b\x1d\x14\xfd\x00\x10\xeb\x11\x8b\x53\x04\x8b\x3b\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd9\x72\xe8\x3b\xd9\x75\x5b\xeb\x0c\x83\x7b\x08\x00\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd8\x72\xf0\x3b\xd8\x75\x31\x8b\x1d\x14\xfd\x00\x10\xeb\x09\x83\x7b\x08\x00\x75\x0a\x83\xc3\x14\x89\x5d\x08\x3b\xd9\x72\xf0\x3b\xd9\x75\x15\xe8\xa0\xfa\xff\xff\x8b\xd8\x89\x5d\x08\x85\xdb\x75\x07\x33\xc0\xe9\x09\x02\x00\x00\x53\xe8\x3a\xfb\xff\xff\x59\x8b\x4b\x10\x89\x01\x8b\x43\x10\x83\x38\xff\x74\xe5\x89\x1d\x1c\xfd\x00\x10\x8b\x43\x10\x8b\x10\x89\x55\xfc\x83\xfa\xff\x74\x14\x8b\x8c\x90\xc4\x00\x00\x00\x8b\x7c\x90\x44\x23\x4d\xf8\x23\xfe\x0b\xcf\x75\x29\x83\x65\xfc\x00\x8b\x90\xc4\x00\x00\x00\x8d\x48\x44\x8b\x39\x23\x55\xf8\x23\xfe\x0b\xd7\x75\x0e\xff\x45\xfc\x8b\x91\x84\x00\x00\x00\x83\xc1\x04\xeb\xe7\x8b\x55\xfc\x8b\xca\x69\xc9\x04\x02\x00\x00\x8d\x8c\x01\x44\x01\x00\x00\x89\x4d\xf4\x8b\x4c\x90\x44\x33\xff\x23\xce\x75\x12\x8b\x8c\x90\xc4\x00\x00\x00\x23\x4d\xf8\x6a\x20\x5f\xeb\x03\x03\xc9\x47\x85\xc9\x7d\xf9\x8b\x4d\xf4\x8b\x54\xf9\x04\x8b\x0a\x2b\x4d\xf0\x8b\xf1\xc1\xfe\x04\x4e\x83\xfe\x3f\x89\x4d\xf8\x7e\x03\x6a\x3f\x5e\x3b\xf7\x0f\x84\x01\x01\x00\x00\x8b\x4a\x04\x3b\x4a\x08\x75\x5c\x83\xff\x20\xbb\x00\x00\x00\x80\x7d\x26\x8b\xcf\xd3\xeb\x8b\x4d\xfc\x8d\x7c\x38\x04\xf7\xd3\x89\x5d\xec\x23\x5c\x88\x44\x89\x5c\x88\x44\xfe\x0f\x75\x33\x8b\x4d\xec\x8b\x5d\x08\x21\x0b\xeb\x2c\x8d\x4f\xe0\xd3\xeb\x8b\x4d\xfc\x8d\x8c\x88\xc4\x00\x00\x00\x8d\x7c\x38\x04\xf7\xd3\x21\x19\xfe\x0f\x89\x5d\xec\x75\x0b\x8b\x5d\x08\x8b\x4d\xec\x21\x4b\x04\xeb\x03\x8b\x5d\x08\x83\x7d\xf8\x00\x8b\x4a\x08\x8b\x7a\x04\x89\x79\x04\x8b\x4a\x04\x8b\x7a\x08\x89\x79\x08\x0f\x84\x8d\x00\x00\x00\x8b\x4d\xf4\x8d\x0c\xf1\x8b\x79\x04\x89\x4a\x08\x89\x7a\x04\x89\x51\x04\x8b\x4a\x04\x89\x51\x08\x8b\x4a\x04\x3b\x4a\x08\x75\x5e\x8a\x4c\x06\x04\x88\x4d\x0b\xfe\xc1\x83\xfe\x20\x88\x4c\x06\x04\x7d\x23\x80\x7d\x0b\x00\x75\x0b\xbf\x00\x00\x00\x80\x8b\xce\xd3\xef\x09\x3b\x8b\xce\xbf\x00\x00\x00\x80\xd3\xef\x8b\x4d\xfc\x09\x7c\x88\x44\xeb\x29\x80\x7d\x0b\x00\x75\x0d\x8d\x4e\xe0\xbf\x00\x00\x00\x80\xd3\xef\x09\x7b\x04\x8b\x4d\xfc\x8d\xbc\x88\xc4\x00\x00\x00\x8d\x4e\xe0\xbe\x00\x00\x00\x80\xd3\xee\x09\x37\x8b\x4d\xf8\x85\xc9\x74\x0b\x89\x0a\x89\x4c\x11\xfc\xeb\x03\x8b\x4d\xf8\x8b\x75\xf0\x03\xd1\x8d\x4e\x01\x89\x0a\x89\x4c\x32\xfc\x8b\x75\xf4\x8b\x0e\x8d\x79\x01\x89\x3e\x85\xc9\x75\x1a\x3b\x1d\x18\xf5\x00\x10\x75\x12\x8b\x4d\xfc\x3b\x0d\x24\xfd\x00\x10\x75\x07\x83\x25\x18\xf5\x00\x10\x00\x8b\x4d\xfc\x89\x08\x8d\x42\x04\x5f\x5e\x5b\xc9\xc3\x6a\x0c\x68\x38\xc7\x00\x10\xe8\x6f\xc8\xff\xff\x83\x65\xe4\x00\x8b\x75\x08\x3b\x35\x18\xfd\x00\x10\x77\x22\x6a\x04\xe8\x9e\xe2\xff\xff\x59\x83\x65\xfc\x00\x56\xe8\xee\xfc\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x7b\xc8\xff\xff\xc3\x6a\x04\xe8\x99\xe1\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x83\xfe\xe0\x0f\x87\xa1\x00\x00\x00\x53\x57\x8b\x3d\xf4\xb0\x00\x10\x83\x3d\x84\xf3\x00\x10\x00\x75\x18\xe8\x86\x05\x00\x00\x6a\x1e\xe8\xd4\x03\x00\x00\x68\xff\x00\x00\x00\xe8\xdf\xd1\xff\xff\x59\x59\xa1\x2c\xfd\x00\x10\x83\xf8\x01\x75\x0e\x85\xf6\x74\x04\x8b\xc6\xeb\x03\x33\xc0\x40\x50\xeb\x1c\x83\xf8\x03\x75\x0b\x56\xe8\x53\xff\xff\xff\x59\x85\xc0\x75\x16\x85\xf6\x75\x01\x46\x83\xc6\x0f\x83\xe6\xf0\x56\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\xd7\x8b\xd8\x85\xdb\x75\x2e\x6a\x0c\x5e\x39\x05\x70\xf8\x00\x10\x74\x15\xff\x75\x08\xe8\x8b\x09\x00\x00\x59\x85\xc0\x74\x0f\x8b\x75\x08\xe9\x7b\xff\xff\xff\xe8\x3e\xc7\xff\xff\x89\x30\xe8\x37\xc7\xff\xff\x89\x30\x5f\x8b\xc3\x5b\xeb\x14\x56\xe8\x64\x09\x00\x00\x59\xe8\x23\xc7\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\x5e\x5d\xc3\x6a\x0c\x68\x58\xc7\x00\x10\xe8\x56\xc7\xff\xff\x8b\x4d\x08\x33\xff\x3b\xcf\x76\x2e\x6a\xe0\x58\x33\xd2\xf7\xf1\x3b\x45\x0c\x1b\xc0\x40\x75\x1f\xe8\xef\xc6\xff\xff\xc7\x00\x0c\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x77\xc6\xff\xff\x83\xc4\x14\x33\xc0\xe9\xd5\x00\x00\x00\x0f\xaf\x4d\x0c\x8b\xf1\x89\x75\x08\x3b\xf7\x75\x03\x33\xf6\x46\x33\xdb\x89\x5d\xe4\x83\xfe\xe0\x77\x69\x83\x3d\x2c\xfd\x00\x10\x03\x75\x4b\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x8b\x45\x08\x3b\x05\x18\xfd\x00\x10\x77\x37\x6a\x04\xe8\x26\xe1\xff\xff\x59\x89\x7d\xfc\xff\x75\x08\xe8\x75\xfb\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x5f\x00\x00\x00\x8b\x5d\xe4\x3b\xdf\x74\x11\xff\x75\x08\x57\x53\xe8\x58\xf0\xff\xff\x83\xc4\x0c\x3b\xdf\x75\x61\x56\x6a\x08\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x8b\xd8\x3b\xdf\x75\x4c\x39\x3d\x70\xf8\x00\x10\x74\x33\x56\xe8\x7b\x08\x00\x00\x59\x85\xc0\x0f\x85\x72\xff\xff\xff\x8b\x45\x10\x3b\xc7\x0f\x84\x50\xff\xff\xff\xc7\x00\x0c\x00\x00\x00\xe9\x45\xff\xff\xff\x33\xff\x8b\x75\x0c\x6a\x04\xe8\xca\xdf\xff\xff\x59\xc3\x3b\xdf\x75\x0d\x8b\x45\x10\x3b\xc7\x74\x06\xc7\x00\x0c\x00\x00\x00\x8b\xc3\xe8\x8a\xc6\xff\xff\xc3\x6a\x10\x68\x78\xc7\x00\x10\xe8\x38\xc6\xff\xff\x8b\x5d\x08\x85\xdb\x75\x0e\xff\x75\x0c\xe8\xfd\xfd\xff\xff\x59\xe9\xcc\x01\x00\x00\x8b\x75\x0c\x85\xf6\x75\x0c\x53\xe8\x11\xce\xff\xff\x59\xe9\xb7\x01\x00\x00\x83\x3d\x2c\xfd\x00\x10\x03\x0f\x85\x93\x01\x00\x00\x33\xff\x89\x7d\xe4\x83\xfe\xe0\x0f\x87\x8a\x01\x00\x00\x6a\x04\xe8\x33\xe0\xff\xff\x59\x89\x7d\xfc\x53\xe8\xa5\xf2\xff\xff\x59\x89\x45\xe0\x3b\xc7\x0f\x84\x9e\x00\x00\x00\x3b\x35\x18\xfd\x00\x10\x77\x49\x56\x53\x50\xe8\x87\xf7\xff\xff\x83\xc4\x0c\x85\xc0\x74\x05\x89\x5d\xe4\xeb\x35\x56\xe8\x56\xfa\xff\xff\x59\x89\x45\xe4\x3b\xc7\x74\x27\x8b\x43\xfc\x48\x3b\xc6\x72\x02\x8b\xc6\x50\x53\xff\x75\xe4\xe8\x8e\x08\x00\x00\x53\xe8\x55\xf2\xff\xff\x89\x45\xe0\x53\x50\xe8\x7b\xf2\xff\xff\x83\xc4\x18\x39\x7d\xe4\x75\x48\x3b\xf7\x75\x06\x33\xf6\x46\x89\x75\x0c\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x56\x57\xff\x35\x84\xf3\x00\x10\xff\x15\xf4\xb0\x00\x10\x89\x45\xe4\x3b\xc7\x74\x20\x8b\x43\xfc\x48\x3b\xc6\x72\x02\x8b\xc6\x50\x53\xff\x75\xe4\xe8\x3a\x08\x00\x00\x53\xff\x75\xe0\xe8\x2e\xf2\xff\xff\x83\xc4\x14\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x2e\x00\x00\x00\x83\x7d\xe0\x00\x75\x31\x85\xf6\x75\x01\x46\x83\xc6\x0f\x83\xe6\xf0\x89\x75\x0c\x56\x53\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x8b\xf8\xeb\x12\x8b\x75\x0c\x8b\x5d\x08\x6a\x04\xe8\x64\xde\xff\xff\x59\xc3\x8b\x7d\xe4\x85\xff\x0f\x85\xbf\x00\x00\x00\x39\x3d\x70\xf8\x00\x10\x74\x2c\x56\xe8\xcf\x06\x00\x00\x59\x85\xc0\x0f\x85\xd2\xfe\xff\xff\xe8\x86\xc4\xff\xff\x39\x7d\xe0\x75\x6c\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\x31\xc4\xff\xff\x59\x89\x06\xeb\x5f\x85\xff\x0f\x85\x83\x00\x00\x00\xe8\x61\xc4\xff\xff\x39\x7d\xe0\x74\x68\xc7\x00\x0c\x00\x00\x00\xeb\x71\x85\xf6\x75\x01\x46\x56\x53\x6a\x00\xff\x35\x84\xf3\x00\x10\xff\x15\xfc\xb0\x00\x10\x8b\xf8\x85\xff\x75\x56\x39\x05\x70\xf8\x00\x10\x74\x34\x56\xe8\x66\x06\x00\x00\x59\x85\xc0\x74\x1f\x83\xfe\xe0\x76\xcd\x56\xe8\x56\x06\x00\x00\x59\xe8\x15\xc4\xff\xff\xc7\x00\x0c\x00\x00\x00\x33\xc0\xe8\x97\xc4\xff\xff\xc3\xe8\x02\xc4\xff\xff\xe9\x7c\xff\xff\xff\x85\xff\x75\x16\xe8\xf4\xc3\xff\xff\x8b\xf0\xff\x15\x00\xb0\x00\x10\x50\xe8\xa4\xc3\xff\xff\x89\x06\x59\x8b\xc7\xeb\xd2\x8b\xff\x55\x8b\xec\x51\x51\x53\x8b\x5d\x08\x56\x57\x33\xf6\x33\xff\x89\x7d\xfc\x3b\x1c\xfd\xd0\xeb\x00\x10\x74\x09\x47\x89\x7d\xfc\x83\xff\x17\x72\xee\x83\xff\x17\x0f\x83\x77\x01\x00\x00\x6a\x03\xe8\x88\x2b\x00\x00\x59\x83\xf8\x01\x0f\x84\x34\x01\x00\x00\x6a\x03\xe8\x77\x2b\x00\x00\x59\x85\xc0\x75\x0d\x83\x3d\xf4\xee\x00\x10\x01\x0f\x84\x1b\x01\x00\x00\x81\xfb\xfc\x00\x00\x00\x0f\x84\x41\x01\x00\x00\x68\xd8\xb9\x00\x10\xbb\x14\x03\x00\x00\x53\xbf\x20\xf5\x00\x10\x57\xe8\xc7\x05\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\xc3\xc1\xff\xff\x83\xc4\x14\x68\x04\x01\x00\x00\xbe\x39\xf5\x00\x10\x56\x6a\x00\xc6\x05\x3d\xf6\x00\x10\x00\xff\x15\xac\xb0\x00\x10\x85\xc0\x75\x26\x68\xc0\xb9\x00\x10\x68\xfb\x02\x00\x00\x56\xe8\x85\x05\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0f\x33\xc0\x50\x50\x50\x50\x50\xe8\x7f\xc1\xff\xff\x83\xc4\x14\x56\xe8\xf4\xe9\xff\xff\x40\x59\x83\xf8\x3c\x76\x38\x56\xe8\xe7\xe9\xff\xff\x83\xee\x3b\x03\xc6\x6a\x03\xb9\x34\xf8\x00\x10\x68\xbc\xb9\x00\x10\x2b\xc8\x51\x50\xe8\x93\x1c\x00\x00\x83\xc4\x14\x85\xc0\x74\x11\x33\xf6\x56\x56\x56\x56\x56\xe8\x3c\xc1\xff\xff\x83\xc4\x14\xeb\x02\x33\xf6\x68\xb8\xb9\x00\x10\x53\x57\xe8\xad\x1b\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\x18\xc1\xff\xff\x83\xc4\x14\x8b\x45\xfc\xff\x34\xc5\xd4\xeb\x00\x10\x53\x57\xe8\x88\x1b\x00\x00\x83\xc4\x0c\x85\xc0\x74\x0d\x56\x56\x56\x56\x56\xe8\xf3\xc0\xff\xff\x83\xc4\x14\x68\x10\x20\x01\x00\x68\x90\xb9\x00\x10\x57\xe8\xe6\x28\x00\x00\x83\xc4\x0c\xeb\x32\x6a\xf4\xff\x15\x9c\xb0\x00\x10\x8b\xd8\x3b\xde\x74\x24\x83\xfb\xff\x74\x1f\x6a\x00\x8d\x45\xf8\x50\x8d\x34\xfd\xd4\xeb\x00\x10\xff\x36\xe8\x32\xe9\xff\xff\x59\x50\xff\x36\x53\xff\x15\x00\xb1\x00\x10\x5f\x5e\x5b\xc9\xc3\x6a\x03\xe8\x0c\x2a\x00\x00\x59\x83\xf8\x01\x74\x15\x6a\x03\xe8\xff\x29\x00\x00\x59\x85\xc0\x75\x1f\x83\x3d\xf4\xee\x00\x10\x01\x75\x16\x68\xfc\x00\x00\x00\xe8\x29\xfe\xff\xff\x68\xff\x00\x00\x00\xe8\x1f\xfe\xff\xff\x59\x59\xc3\x8b\xff\x55\x8b\xec\x51\x53\x56\x57\xff\x35\x48\xfe\x00\x10\xe8\x9c\xc4\xff\xff\xff\x35\x44\xfe\x00\x10\x8b\xf8\x89\x7d\xfc\xe8\x8c\xc4\xff\xff\x8b\xf0\x59\x59\x3b\xf7\x0f\x82\x83\x00\x00\x00\x8b\xde\x2b\xdf\x8d\x43\x04\x83\xf8\x04\x72\x77\x57\xe8\x8c\x27\x00\x00\x8b\xf8\x8d\x43\x04\x59\x3b\xf8\x73\x48\xb8\x00\x08\x00\x00\x3b\xf8\x73\x02\x8b\xc7\x03\xc7\x3b\xc7\x72\x0f\x50\xff\x75\xfc\xe8\xf9\xca\xff\xff\x59\x59\x85\xc0\x75\x16\x8d\x47\x10\x3b\xc7\x72\x40\x50\xff\x75\xfc\xe8\xe3\xca\xff\xff\x59\x59\x85\xc0\x74\x31\xc1\xfb\x02\x50\x8d\x34\x98\xe8\xa7\xc3\xff\xff\x59\xa3\x48\xfe\x00\x10\xff\x75\x08\xe8\x99\xc3\xff\xff\x89\x06\x83\xc6\x04\x56\xe8\x8e\xc3\xff\xff\x59\xa3\x44\xfe\x00\x10\x8b\x45\x08\x59\xeb\x02\x33\xc0\x5f\x5e\x5b\xc9\xc3\x8b\xff\x56\x6a\x04\x6a\x20\xe8\x4d\xca\xff\xff\x8b\xf0\x56\xe8\x67\xc3\xff\xff\x83\xc4\x0c\xa3\x48\xfe\x00\x10\xa3\x44\xfe\x00\x10\x85\xf6\x75\x05\x6a\x18\x58\x5e\xc3\x83\x26\x00\x33\xc0\x5e\xc3\x6a\x0c\x68\x98\xc7\x00\x10\xe8\x4e\xc1\xff\xff\xe8\x4d\xcb\xff\xff\x83\x65\xfc\x00\xff\x75\x08\xe8\xf8\xfe\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x6a\xc1\xff\xff\xc3\xe8\x2c\xcb\xff\xff\xc3\x8b\xff\x55\x8b\xec\xff\x75\x08\xe8\xb7\xff\xff\xff\xf7\xd8\x1b\xc0\xf7\xd8\x59\x48\x5d\xc3\x6a\x08\x68\xb8\xc7\x00\x10\xe8\xfb\xc0\xff\xff\xe8\xad\xc5\xff\xff\x8b\x40\x78\x85\xc0\x74\x16\x83\x65\xfc\x00\xff\xd0\xeb\x07\x33\xc0\x40\xc3\x8b\x65\xe8\xc7\x45\xfc\xfe\xff\xff\xff\xe8\xb4\x28\x00\x00\xe8\x14\xc1\xff\xff\xc3\x68\xa5\x6a\x00\x10\xe8\xb4\xc2\xff\xff\x59\xa3\x34\xf8\x00\x10\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x38\xf8\x00\x10\xa3\x3c\xf8\x00\x10\xa3\x40\xf8\x00\x10\xa3\x44\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\x0d\x60\xe4\x00\x10\x56\x39\x50\x04\x74\x0f\x8b\xf1\x6b\xf6\x0c\x03\x75\x08\x83\xc0\x0c\x3b\xc6\x72\xec\x6b\xc9\x0c\x03\x4d\x08\x5e\x3b\xc1\x73\x05\x39\x50\x04\x74\x02\x33\xc0\x5d\xc3\xff\x35\x40\xf8\x00\x10\xe8\xc8\xc2\xff\xff\x59\xc3\x6a\x20\x68\xd8\xc7\x00\x10\xe8\x4f\xc0\xff\xff\x33\xff\x89\x7d\xe4\x89\x7d\xd8\x8b\x5d\x08\x83\xfb\x0b\x7f\x4c\x74\x15\x8b\xc3\x6a\x02\x59\x2b\xc1\x74\x22\x2b\xc1\x74\x08\x2b\xc1\x74\x64\x2b\xc1\x75\x44\xe8\x61\xc4\xff\xff\x8b\xf8\x89\x7d\xd8\x85\xff\x75\x14\x83\xc8\xff\xe9\x61\x01\x00\x00\xbe\x38\xf8\x00\x10\xa1\x38\xf8\x00\x10\xeb\x60\xff\x77\x5c\x8b\xd3\xe8\x5d\xff\xff\xff\x8b\xf0\x83\xc6\x08\x8b\x06\xeb\x5a\x8b\xc3\x83\xe8\x0f\x74\x3c\x83\xe8\x06\x74\x2b\x48\x74\x1c\xe8\x95\xbf\xff\xff\xc7\x00\x16\x00\x00\x00\x33\xc0\x50\x50\x50\x50\x50\xe8\x1b\xbf\xff\xff\x83\xc4\x14\xeb\xae\xbe\x40\xf8\x00\x10\xa1\x40\xf8\x00\x10\xeb\x16\xbe\x3c\xf8\x00\x10\xa1\x3c\xf8\x00\x10\xeb\x0a\xbe\x44\xf8\x00\x10\xa1\x44\xf8\x00\x10\xc7\x45\xe4\x01\x00\x00\x00\x50\xe8\x04\xc2\xff\xff\x89\x45\xe0\x59\x33\xc0\x83\x7d\xe0\x01\x0f\x84\xd8\x00\x00\x00\x39\x45\xe0\x75\x07\x6a\x03\xe8\x85\xcb\xff\xff\x39\x45\xe4\x74\x07\x50\xe8\xb7\xd9\xff\xff\x59\x33\xc0\x89\x45\xfc\x83\xfb\x08\x74\x0a\x83\xfb\x0b\x74\x05\x83\xfb\x04\x75\x1b\x8b\x4f\x60\x89\x4d\xd4\x89\x47\x60\x83\xfb\x08\x75\x40\x8b\x4f\x64\x89\x4d\xd0\xc7\x47\x64\x8c\x00\x00\x00\x83\xfb\x08\x75\x2e\x8b\x0d\x54\xe4\x00\x10\x89\x4d\xdc\x8b\x0d\x58\xe4\x00\x10\x8b\x15\x54\xe4\x00\x10\x03\xca\x39\x4d\xdc\x7d\x19\x8b\x4d\xdc\x6b\xc9\x0c\x8b\x57\x5c\x89\x44\x11\x08\xff\x45\xdc\xeb\xdb\xe8\x6c\xc1\xff\xff\x89\x06\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x15\x00\x00\x00\x83\xfb\x08\x75\x1f\xff\x77\x64\x53\xff\x55\xe0\x59\xeb\x19\x8b\x5d\x08\x8b\x7d\xd8\x83\x7d\xe4\x00\x74\x08\x6a\x00\xe8\x45\xd8\xff\xff\x59\xc3\x53\xff\x55\xe0\x59\x83\xfb\x08\x74\x0a\x83\xfb\x0b\x74\x05\x83\xfb\x04\x75\x11\x8b\x45\xd4\x89\x47\x60\x83\xfb\x08\x75\x06\x8b\x45\xd0\x89\x47\x64\x33\xc0\xe8\xf1\xbe\xff\xff\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x4c\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x58\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x5c\xf8\x00\x10\x5d\xc3\x6a\x10\x68\xf8\xc7\x00\x10\xe8\x72\xbe\xff\xff\x83\x65\xfc\x00\xff\x75\x0c\xff\x75\x08\xff\x15\x08\xb1\x00\x10\x89\x45\xe4\xeb\x2f\x8b\x45\xec\x8b\x00\x8b\x00\x89\x45\xe0\x33\xc9\x3d\x17\x00\x00\xc0\x0f\x94\xc1\x8b\xc1\xc3\x8b\x65\xe8\x81\x7d\xe0\x17\x00\x00\xc0\x75\x08\x6a\x08\xff\x15\x84\xb0\x00\x10\x83\x65\xe4\x00\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xe8\x64\xbe\xff\xff\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\xa3\x60\xf8\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\xff\x35\x60\xf8\x00\x10\xe8\x6a\xc0\xff\xff\x59\x85\xc0\x74\x0f\xff\x75\x08\xff\xd0\x59\x85\xc0\x74\x05\x33\xc0\x40\x5d\xc3\x33\xc0\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x53\x33\xdb\x56\x57\x3b\xcb\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\x80\xbd\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\x09\xbd\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x30\x8b\x75\x10\x3b\xf3\x75\x04\x88\x19\xeb\xda\x8b\xd1\x8a\x06\x88\x02\x42\x46\x3a\xc3\x74\x03\x4f\x75\xf3\x3b\xfb\x75\x10\x88\x19\xe8\x45\xbd\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\xc1\x33\xc0\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\xbe\xae\xff\xff\x0f\xb6\x45\x0c\x8b\x4d\xf4\x8a\x55\x14\x84\x54\x01\x1d\x75\x1e\x83\x7d\x10\x00\x74\x12\x8b\x4d\xf0\x8b\x89\xc8\x00\x00\x00\x0f\xb7\x04\x41\x23\x45\x10\xeb\x02\x33\xc0\x85\xc0\x74\x03\x33\xc0\x40\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x6a\x04\x6a\x00\xff\x75\x08\x6a\x00\xe8\x9a\xff\xff\xff\x83\xc4\x10\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x8b\x75\x0c\x8b\x4d\x10\x8b\x7d\x08\x8b\xc1\x8b\xd1\x03\xc6\x3b\xfe\x76\x08\x3b\xf8\x0f\x82\xa4\x01\x00\x00\x81\xf9\x00\x01\x00\x00\x72\x1f\x83\x3d\x0c\xfd\x00\x10\x00\x74\x16\x57\x56\x83\xe7\x0f\x83\xe6\x0f\x3b\xfe\x5e\x5f\x75\x08\x5e\x5f\x5d\xe9\x43\x26\x00\x00\xf7\xc7\x03\x00\x00\x00\x75\x15\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x2a\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x90\x8b\xc7\xba\x03\x00\x00\x00\x83\xe9\x04\x72\x0c\x83\xe0\x03\x03\xc8\xff\x24\x85\x28\x6f\x00\x10\xff\x24\x8d\x24\x70\x00\x10\x90\xff\x24\x8d\xa8\x6f\x00\x10\x90\x38\x6f\x00\x10\x64\x6f\x00\x10\x88\x6f\x00\x10\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xc6\x03\x83\xc7\x03\x83\xf9\x08\x72\xcc\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x8d\x49\x00\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xc6\x02\x83\xc7\x02\x83\xf9\x08\x72\xa6\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x90\x23\xd1\x8a\x06\x88\x07\x83\xc6\x01\xc1\xe9\x02\x83\xc7\x01\x83\xf9\x08\x72\x88\xf3\xa5\xff\x24\x95\x14\x70\x00\x10\x8d\x49\x00\x0b\x70\x00\x10\xf8\x6f\x00\x10\xf0\x6f\x00\x10\xe8\x6f\x00\x10\xe0\x6f\x00\x10\xd8\x6f\x00\x10\xd0\x6f\x00\x10\xc8\x6f\x00\x10\x8b\x44\x8e\xe4\x89\x44\x8f\xe4\x8b\x44\x8e\xe8\x89\x44\x8f\xe8\x8b\x44\x8e\xec\x89\x44\x8f\xec\x8b\x44\x8e\xf0\x89\x44\x8f\xf0\x8b\x44\x8e\xf4\x89\x44\x8f\xf4\x8b\x44\x8e\xf8\x89\x44\x8f\xf8\x8b\x44\x8e\xfc\x89\x44\x8f\xfc\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\x14\x70\x00\x10\x8b\xff\x24\x70\x00\x10\x2c\x70\x00\x10\x38\x70\x00\x10\x4c\x70\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8d\x74\x31\xfc\x8d\x7c\x39\xfc\xf7\xc7\x03\x00\x00\x00\x75\x24\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x0d\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8b\xff\xf7\xd9\xff\x24\x8d\x60\x71\x00\x10\x8d\x49\x00\x8b\xc7\xba\x03\x00\x00\x00\x83\xf9\x04\x72\x0c\x83\xe0\x03\x2b\xc8\xff\x24\x85\xb4\x70\x00\x10\xff\x24\x8d\xb0\x71\x00\x10\x90\xc4\x70\x00\x10\xe8\x70\x00\x10\x10\x71\x00\x10\x8a\x46\x03\x23\xd1\x88\x47\x03\x83\xee\x01\xc1\xe9\x02\x83\xef\x01\x83\xf9\x08\x72\xb2\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8d\x49\x00\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xee\x02\x83\xef\x02\x83\xf9\x08\x72\x88\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x90\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xee\x03\x83\xef\x03\x83\xf9\x08\x0f\x82\x56\xff\xff\xff\xfd\xf3\xa5\xfc\xff\x24\x95\xb0\x71\x00\x10\x8d\x49\x00\x64\x71\x00\x10\x6c\x71\x00\x10\x74\x71\x00\x10\x7c\x71\x00\x10\x84\x71\x00\x10\x8c\x71\x00\x10\x94\x71\x00\x10\xa7\x71\x00\x10\x8b\x44\x8e\x1c\x89\x44\x8f\x1c\x8b\x44\x8e\x18\x89\x44\x8f\x18\x8b\x44\x8e\x14\x89\x44\x8f\x14\x8b\x44\x8e\x10\x89\x44\x8f\x10\x8b\x44\x8e\x0c\x89\x44\x8f\x0c\x8b\x44\x8e\x08\x89\x44\x8f\x08\x8b\x44\x8e\x04\x89\x44\x8f\x04\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\xb0\x71\x00\x10\x8b\xff\xc0\x71\x00\x10\xc8\x71\x00\x10\xd8\x71\x00\x10\xec\x71\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x57\x33\xff\x83\xcb\xff\x3b\xf7\x75\x1c\xe8\x44\xb9\xff\xff\x57\x57\x57\x57\x57\xc7\x00\x16\x00\x00\x00\xe8\xcc\xb8\xff\xff\x83\xc4\x14\x0b\xc3\xeb\x42\xf6\x46\x0c\x83\x74\x37\x56\xe8\xa1\xd0\xff\xff\x56\x8b\xd8\xe8\x2d\x25\x00\x00\x56\xe8\x39\xd4\xff\xff\x50\xe8\x54\x24\x00\x00\x83\xc4\x10\x85\xc0\x7d\x05\x83\xcb\xff\xeb\x11\x8b\x46\x1c\x3b\xc7\x74\x0a\x50\xe8\x39\xc1\xff\xff\x59\x89\x7e\x1c\x89\x7e\x0c\x8b\xc3\x5f\x5e\x5b\x5d\xc3\x6a\x0c\x68\x18\xc8\x00\x10\xe8\x24\xb9\xff\xff\x83\x4d\xe4\xff\x33\xc0\x8b\x75\x08\x33\xff\x3b\xf7\x0f\x95\xc0\x3b\xc7\x75\x1d\xe8\xc1\xb8\xff\xff\xc7\x00\x16\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x49\xb8\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x0c\xf6\x46\x0c\x40\x74\x0c\x89\x7e\x0c\x8b\x45\xe4\xe8\x27\xb9\xff\xff\xc3\x56\xe8\x7f\xa8\xff\xff\x59\x89\x7d\xfc\x56\xe8\x2a\xff\xff\xff\x59\x89\x45\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x05\x00\x00\x00\xeb\xd5\x8b\x75\x08\x56\xe8\xcd\xa8\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\xb8\xe4\x1a\x00\x00\xe8\x99\x26\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x8b\x45\x0c\x56\x33\xf6\x89\x85\x34\xe5\xff\xff\x89\xb5\x38\xe5\xff\xff\x89\xb5\x30\xe5\xff\xff\x39\x75\x10\x75\x07\x33\xc0\xe9\xe9\x06\x00\x00\x3b\xc6\x75\x27\xe8\x37\xb8\xff\xff\x89\x30\xe8\x1d\xb8\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\xa5\xb7\xff\xff\x83\xc4\x14\x83\xc8\xff\xe9\xbe\x06\x00\x00\x53\x57\x8b\x7d\x08\x8b\xc7\xc1\xf8\x05\x8d\x34\x85\x40\xfd\x00\x10\x8b\x06\x83\xe7\x1f\xc1\xe7\x06\x03\xc7\x8a\x58\x24\x02\xdb\xd0\xfb\x89\xb5\x28\xe5\xff\xff\x88\x9d\x27\xe5\xff\xff\x80\xfb\x02\x74\x05\x80\xfb\x01\x75\x30\x8b\x4d\x10\xf7\xd1\xf6\xc1\x01\x75\x26\xe8\xce\xb7\xff\xff\x33\xf6\x89\x30\xe8\xb2\xb7\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x3a\xb7\xff\xff\x83\xc4\x14\xe9\x43\x06\x00\x00\xf6\x40\x04\x20\x74\x11\x6a\x02\x6a\x00\x6a\x00\xff\x75\x08\xe8\xc4\x12\x00\x00\x83\xc4\x10\xff\x75\x08\xe8\x3d\xd2\xff\xff\x59\x85\xc0\x0f\x84\x9d\x02\x00\x00\x8b\x06\xf6\x44\x07\x04\x80\x0f\x84\x90\x02\x00\x00\xe8\x61\xbc\xff\xff\x8b\x40\x6c\x33\xc9\x39\x48\x14\x8d\x85\x1c\xe5\xff\xff\x0f\x94\xc1\x50\x8b\x06\xff\x34\x07\x89\x8d\x20\xe5\xff\xff\xff\x15\x10\xb1\x00\x10\x85\xc0\x0f\x84\x60\x02\x00\x00\x33\xc9\x39\x8d\x20\xe5\xff\xff\x74\x08\x84\xdb\x0f\x84\x50\x02\x00\x00\xff\x15\x0c\xb1\x00\x10\x8b\x9d\x34\xe5\xff\xff\x89\x85\x1c\xe5\xff\xff\x33\xc0\x89\x85\x3c\xe5\xff\xff\x39\x45\x10\x0f\x86\x42\x05\x00\x00\x89\x85\x44\xe5\xff\xff\x8a\x85\x27\xe5\xff\xff\x84\xc0\x0f\x85\x67\x01\x00\x00\x8a\x0b\x8b\xb5\x28\xe5\xff\xff\x33\xc0\x80\xf9\x0a\x0f\x94\xc0\x89\x85\x20\xe5\xff\xff\x8b\x06\x03\xc7\x83\x78\x38\x00\x74\x15\x8a\x50\x34\x88\x55\xf4\x88\x4d\xf5\x83\x60\x38\x00\x6a\x02\x8d\x45\xf4\x50\xeb\x4b\x0f\xbe\xc1\x50\xe8\xe8\xdf\xff\xff\x59\x85\xc0\x74\x3a\x8b\x8d\x34\xe5\xff\xff\x2b\xcb\x03\x4d\x10\x33\xc0\x40\x3b\xc8\x0f\x86\xa5\x01\x00\x00\x6a\x02\x8d\x85\x40\xe5\xff\xff\x53\x50\xe8\xa5\x24\x00\x00\x83\xc4\x0c\x83\xf8\xff\x0f\x84\xb1\x04\x00\x00\x43\xff\x85\x44\xe5\xff\xff\xeb\x1b\x6a\x01\x53\x8d\x85\x40\xe5\xff\xff\x50\xe8\x81\x24\x00\x00\x83\xc4\x0c\x83\xf8\xff\x0f\x84\x8d\x04\x00\x00\x33\xc0\x50\x50\x6a\x05\x8d\x4d\xf4\x51\x6a\x01\x8d\x8d\x40\xe5\xff\xff\x51\x50\xff\xb5\x1c\xe5\xff\xff\x43\xff\x85\x44\xe5\xff\xff\xff\x15\xbc\xb0\x00\x10\x8b\xf0\x85\xf6\x0f\x84\x5c\x04\x00\x00\x6a\x00\x8d\x85\x3c\xe5\xff\xff\x50\x56\x8d\x45\xf4\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x29\x04\x00\x00\x8b\x85\x44\xe5\xff\xff\x8b\x8d\x30\xe5\xff\xff\x03\xc1\x39\xb5\x3c\xe5\xff\xff\x89\x85\x38\xe5\xff\xff\x0f\x8c\x15\x04\x00\x00\x83\xbd\x20\xe5\xff\xff\x00\x0f\x84\xcd\x00\x00\x00\x6a\x00\x8d\x85\x3c\xe5\xff\xff\x50\x6a\x01\x8d\x45\xf4\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xc6\x45\xf4\x0d\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\xd0\x03\x00\x00\x83\xbd\x3c\xe5\xff\xff\x01\x0f\x8c\xcf\x03\x00\x00\xff\x85\x30\xe5\xff\xff\xff\x85\x38\xe5\xff\xff\xe9\x83\x00\x00\x00\x3c\x01\x74\x04\x3c\x02\x75\x21\x0f\xb7\x33\x33\xc9\x66\x83\xfe\x0a\x0f\x94\xc1\x43\x43\x83\x85\x44\xe5\xff\xff\x02\x89\xb5\x40\xe5\xff\xff\x89\x8d\x20\xe5\xff\xff\x3c\x01\x74\x04\x3c\x02\x75\x52\xff\xb5\x40\xe5\xff\xff\xe8\x8e\x21\x00\x00\x59\x66\x3b\x85\x40\xe5\xff\xff\x0f\x85\x68\x03\x00\x00\x83\x85\x38\xe5\xff\xff\x02\x83\xbd\x20\xe5\xff\xff\x00\x74\x29\x6a\x0d\x58\x50\x89\x85\x40\xe5\xff\xff\xe8\x61\x21\x00\x00\x59\x66\x3b\x85\x40\xe5\xff\xff\x0f\x85\x3b\x03\x00\x00\xff\x85\x38\xe5\xff\xff\xff\x85\x30\xe5\xff\xff\x8b\x45\x10\x39\x85\x44\xe5\xff\xff\x0f\x82\xf9\xfd\xff\xff\xe9\x27\x03\x00\x00\x8b\x0e\x8a\x13\xff\x85\x38\xe5\xff\xff\x88\x54\x0f\x34\x8b\x0e\x89\x44\x0f\x38\xe9\x0e\x03\x00\x00\x33\xc9\x8b\x06\x03\xc7\xf6\x40\x04\x80\x0f\x84\xbf\x02\x00\x00\x8b\x85\x34\xe5\xff\xff\x89\x8d\x40\xe5\xff\xff\x84\xdb\x0f\x85\xca\x00\x00\x00\x89\x85\x3c\xe5\xff\xff\x39\x4d\x10\x0f\x86\x20\x03\x00\x00\xeb\x06\x8b\xb5\x28\xe5\xff\xff\x8b\x8d\x3c\xe5\xff\xff\x83\xa5\x44\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x8d\x85\x48\xe5\xff\xff\x3b\x4d\x10\x73\x39\x8b\x95\x3c\xe5\xff\xff\xff\x85\x3c\xe5\xff\xff\x8a\x12\x41\x80\xfa\x0a\x75\x10\xff\x85\x30\xe5\xff\xff\xc6\x00\x0d\x40\xff\x85\x44\xe5\xff\xff\x88\x10\x40\xff\x85\x44\xe5\xff\xff\x81\xbd\x44\xe5\xff\xff\xff\x13\x00\x00\x72\xc2\x8b\xd8\x8d\x85\x48\xe5\xff\xff\x2b\xd8\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x53\x8d\x85\x48\xe5\xff\xff\x50\x8b\x06\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x42\x02\x00\x00\x8b\x85\x2c\xe5\xff\xff\x01\x85\x38\xe5\xff\xff\x3b\xc3\x0f\x8c\x3a\x02\x00\x00\x8b\x85\x3c\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x3b\x45\x10\x0f\x82\x4c\xff\xff\xff\xe9\x20\x02\x00\x00\x89\x85\x44\xe5\xff\xff\x80\xfb\x02\x0f\x85\xd1\x00\x00\x00\x39\x4d\x10\x0f\x86\x4d\x02\x00\x00\xeb\x06\x8b\xb5\x28\xe5\xff\xff\x8b\x8d\x44\xe5\xff\xff\x83\xa5\x3c\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x8d\x85\x48\xe5\xff\xff\x3b\x4d\x10\x73\x46\x8b\x95\x44\xe5\xff\xff\x83\x85\x44\xe5\xff\xff\x02\x0f\xb7\x12\x41\x41\x66\x83\xfa\x0a\x75\x16\x83\x85\x30\xe5\xff\xff\x02\x6a\x0d\x5b\x66\x89\x18\x40\x40\x83\x85\x3c\xe5\xff\xff\x02\x83\x85\x3c\xe5\xff\xff\x02\x66\x89\x10\x40\x40\x81\xbd\x3c\xe5\xff\xff\xfe\x13\x00\x00\x72\xb5\x8b\xd8\x8d\x85\x48\xe5\xff\xff\x2b\xd8\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x53\x8d\x85\x48\xe5\xff\xff\x50\x8b\x06\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x0f\x84\x62\x01\x00\x00\x8b\x85\x2c\xe5\xff\xff\x01\x85\x38\xe5\xff\xff\x3b\xc3\x0f\x8c\x5a\x01\x00\x00\x8b\x85\x44\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x3b\x45\x10\x0f\x82\x3f\xff\xff\xff\xe9\x40\x01\x00\x00\x39\x4d\x10\x0f\x86\x7c\x01\x00\x00\x8b\x8d\x44\xe5\xff\xff\x83\xa5\x3c\xe5\xff\xff\x00\x2b\x8d\x34\xe5\xff\xff\x6a\x02\x8d\x85\x48\xf9\xff\xff\x5e\x3b\x4d\x10\x73\x3c\x8b\x95\x44\xe5\xff\xff\x0f\xb7\x12\x01\xb5\x44\xe5\xff\xff\x03\xce\x66\x83\xfa\x0a\x75\x0e\x6a\x0d\x5b\x66\x89\x18\x03\xc6\x01\xb5\x3c\xe5\xff\xff\x01\xb5\x3c\xe5\xff\xff\x66\x89\x10\x03\xc6\x81\xbd\x3c\xe5\xff\xff\xa8\x06\x00\x00\x72\xbf\x33\xf6\x56\x56\x68\x55\x0d\x00\x00\x8d\x8d\xf0\xeb\xff\xff\x51\x8d\x8d\x48\xf9\xff\xff\x2b\xc1\x99\x2b\xc2\xd1\xf8\x50\x8b\xc1\x50\x56\x68\xe9\xfd\x00\x00\xff\x15\xbc\xb0\x00\x10\x8b\xd8\x3b\xde\x0f\x84\x97\x00\x00\x00\x6a\x00\x8d\x85\x2c\xe5\xff\xff\x50\x8b\xc3\x2b\xc6\x50\x8d\x84\x35\xf0\xeb\xff\xff\x50\x8b\x85\x28\xe5\xff\xff\x8b\x00\xff\x34\x07\xff\x15\x00\xb1\x00\x10\x85\xc0\x74\x0c\x03\xb5\x2c\xe5\xff\xff\x3b\xde\x7f\xcb\xeb\x0c\xff\x15\x00\xb0\x00\x10\x89\x85\x40\xe5\xff\xff\x3b\xde\x7f\x5c\x8b\x85\x44\xe5\xff\xff\x2b\x85\x34\xe5\xff\xff\x89\x85\x38\xe5\xff\xff\x3b\x45\x10\x0f\x82\x0a\xff\xff\xff\xeb\x3f\x6a\x00\x8d\x8d\x2c\xe5\xff\xff\x51\xff\x75\x10\xff\xb5\x34\xe5\xff\xff\xff\x30\xff\x15\x00\xb1\x00\x10\x85\xc0\x74\x15\x8b\x85\x2c\xe5\xff\xff\x83\xa5\x40\xe5\xff\xff\x00\x89\x85\x38\xe5\xff\xff\xeb\x0c\xff\x15\x00\xb0\x00\x10\x89\x85\x40\xe5\xff\xff\x83\xbd\x38\xe5\xff\xff\x00\x75\x6c\x83\xbd\x40\xe5\xff\xff\x00\x74\x2d\x6a\x05\x5e\x39\xb5\x40\xe5\xff\xff\x75\x14\xe8\xa5\xb1\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\xad\xb1\xff\xff\x89\x30\xeb\x3f\xff\xb5\x40\xe5\xff\xff\xe8\xb1\xb1\xff\xff\x59\xeb\x31\x8b\xb5\x28\xe5\xff\xff\x8b\x06\xf6\x44\x07\x04\x40\x74\x0f\x8b\x85\x34\xe5\xff\xff\x80\x38\x1a\x75\x04\x33\xc0\xeb\x24\xe8\x65\xb1\xff\xff\xc7\x00\x1c\x00\x00\x00\xe8\x6d\xb1\xff\xff\x83\x20\x00\x83\xc8\xff\xeb\x0c\x8b\x85\x38\xe5\xff\xff\x2b\x85\x30\xe5\xff\xff\x5f\x5b\x8b\x4d\xfc\x33\xcd\x5e\xe8\x55\x9b\xff\xff\xc9\xc3\x6a\x10\x68\x38\xc8\x00\x10\xe8\x75\xb1\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x1b\xe8\x31\xb1\xff\xff\x83\x20\x00\xe8\x16\xb1\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\x9d\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x08\xb1\xff\xff\x89\x38\xe8\xee\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x76\xb0\xff\xff\x83\xc4\x14\xeb\xc9\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x74\xbf\x50\xe8\x19\x20\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x16\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\x2e\xf8\xff\xff\x83\xc4\x0c\x89\x45\xe4\xeb\x16\xe8\x8b\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x93\xb0\xff\xff\x89\x38\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\xf5\xb0\xff\xff\xc3\xff\x75\x08\xe8\x63\x20\x00\x00\x59\xc3\x6a\x10\x68\x58\xc8\x00\x10\xe8\x99\xb0\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x13\xe8\x42\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\xaa\x00\x00\x00\x33\xdb\x3b\xc3\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x1a\xe8\x21\xb0\xff\xff\xc7\x00\x09\x00\x00\x00\x53\x53\x53\x53\x53\xe8\xa9\xaf\xff\xff\x83\xc4\x14\xeb\xd0\x8b\xc8\xc1\xf9\x05\x8d\x3c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0f\x0f\xbe\x4c\x0e\x04\x83\xe1\x01\x74\xc6\x50\xe8\x4c\x1f\x00\x00\x59\x89\x5d\xfc\x8b\x07\xf6\x44\x06\x04\x01\x74\x31\xff\x75\x08\xe8\xc0\x1e\x00\x00\x59\x50\xff\x15\x44\xb0\x00\x10\x85\xc0\x75\x0b\xff\x15\x00\xb0\x00\x10\x89\x45\xe4\xeb\x03\x89\x5d\xe4\x39\x5d\xe4\x74\x19\xe8\xc0\xaf\xff\xff\x8b\x4d\xe4\x89\x08\xe8\xa3\xaf\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x14\xb0\xff\xff\xc3\xff\x75\x08\xe8\x82\x1f\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x85\xc0\x74\x12\x83\xe8\x08\x81\x38\xdd\xdd\x00\x00\x75\x07\x50\xe8\xa2\xb7\xff\xff\x59\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x53\x56\x33\xdb\x57\x8b\xf1\x39\x1d\x64\xf8\x00\x10\x75\x38\x53\x53\x33\xff\x47\x57\x68\xf4\xb9\x00\x10\x68\x00\x01\x00\x00\x53\xff\x15\x38\xb0\x00\x10\x85\xc0\x74\x08\x89\x3d\x64\xf8\x00\x10\xeb\x15\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\xc7\x05\x64\xf8\x00\x10\x02\x00\x00\x00\x39\x5d\x14\x7e\x22\x8b\x4d\x14\x8b\x45\x10\x49\x38\x18\x74\x08\x40\x3b\xcb\x75\xf6\x83\xc9\xff\x8b\x45\x14\x2b\xc1\x48\x3b\x45\x14\x7d\x01\x40\x89\x45\x14\xa1\x64\xf8\x00\x10\x83\xf8\x02\x0f\x84\xac\x01\x00\x00\x3b\xc3\x0f\x84\xa4\x01\x00\x00\x83\xf8\x01\x0f\x85\xcc\x01\x00\x00\x89\x5d\xf8\x39\x5d\x20\x75\x08\x8b\x06\x8b\x40\x04\x89\x45\x20\x8b\x35\x3c\xb0\x00\x10\x33\xc0\x39\x5d\x24\x53\x53\xff\x75\x14\x0f\x95\xc0\xff\x75\x10\x8d\x04\xc5\x01\x00\x00\x00\x50\xff\x75\x20\xff\xd6\x8b\xf8\x3b\xfb\x0f\x84\x8f\x01\x00\x00\x7e\x43\x6a\xe0\x33\xd2\x58\xf7\xf7\x83\xf8\x02\x72\x37\x8d\x44\x3f\x08\x3d\x00\x04\x00\x00\x77\x13\xe8\x8e\x20\x00\x00\x8b\xc4\x3b\xc3\x74\x1c\xc7\x00\xcc\xcc\x00\x00\xeb\x11\x50\xe8\x6a\xe6\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x89\x45\xf4\xeb\x03\x89\x5d\xf4\x39\x5d\xf4\x0f\x84\x3e\x01\x00\x00\x57\xff\x75\xf4\xff\x75\x14\xff\x75\x10\x6a\x01\xff\x75\x20\xff\xd6\x85\xc0\x0f\x84\xe3\x00\x00\x00\x8b\x35\x38\xb0\x00\x10\x53\x53\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\x8b\xc8\x89\x4d\xf8\x3b\xcb\x0f\x84\xc2\x00\x00\x00\xf7\x45\x0c\x00\x04\x00\x00\x74\x29\x39\x5d\x1c\x0f\x84\xb0\x00\x00\x00\x3b\x4d\x1c\x0f\x8f\xa7\x00\x00\x00\xff\x75\x1c\xff\x75\x18\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\xe9\x90\x00\x00\x00\x3b\xcb\x7e\x45\x6a\xe0\x33\xd2\x58\xf7\xf1\x83\xf8\x02\x72\x39\x8d\x44\x09\x08\x3d\x00\x04\x00\x00\x77\x16\xe8\xcf\x1f\x00\x00\x8b\xf4\x3b\xf3\x74\x6a\xc7\x06\xcc\xcc\x00\x00\x83\xc6\x08\xeb\x1a\x50\xe8\xa8\xe5\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xf0\xeb\x02\x33\xf6\x3b\xf3\x74\x41\xff\x75\xf8\x56\x57\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\x15\x38\xb0\x00\x10\x85\xc0\x74\x22\x53\x53\x39\x5d\x1c\x75\x04\x53\x53\xeb\x06\xff\x75\x1c\xff\x75\x18\xff\x75\xf8\x56\x53\xff\x75\x20\xff\x15\xbc\xb0\x00\x10\x89\x45\xf8\x56\xe8\xb8\xfd\xff\xff\x59\xff\x75\xf4\xe8\xaf\xfd\xff\xff\x8b\x45\xf8\x59\xe9\x59\x01\x00\x00\x89\x5d\xf4\x89\x5d\xf0\x39\x5d\x08\x75\x08\x8b\x06\x8b\x40\x14\x89\x45\x08\x39\x5d\x20\x75\x08\x8b\x06\x8b\x40\x04\x89\x45\x20\xff\x75\x08\xe8\x25\x1d\x00\x00\x59\x89\x45\xec\x83\xf8\xff\x75\x07\x33\xc0\xe9\x21\x01\x00\x00\x3b\x45\x20\x0f\x84\xdb\x00\x00\x00\x53\x53\x8d\x4d\x14\x51\xff\x75\x10\x50\xff\x75\x20\xe8\x43\x1d\x00\x00\x83\xc4\x18\x89\x45\xf4\x3b\xc3\x74\xd4\x8b\x35\x40\xb0\x00\x10\x53\x53\xff\x75\x14\x50\xff\x75\x0c\xff\x75\x08\xff\xd6\x89\x45\xf8\x3b\xc3\x75\x07\x33\xf6\xe9\xb7\x00\x00\x00\x7e\x3d\x83\xf8\xe0\x77\x38\x83\xc0\x08\x3d\x00\x04\x00\x00\x77\x16\xe8\xb9\x1e\x00\x00\x8b\xfc\x3b\xfb\x74\xdd\xc7\x07\xcc\xcc\x00\x00\x83\xc7\x08\xeb\x1a\x50\xe8\x92\xe4\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xf8\xeb\x02\x33\xff\x3b\xfb\x74\xb4\xff\x75\xf8\x53\x57\xe8\x40\xd6\xff\xff\x83\xc4\x0c\xff\x75\xf8\x57\xff\x75\x14\xff\x75\xf4\xff\x75\x0c\xff\x75\x08\xff\xd6\x89\x45\xf8\x3b\xc3\x75\x04\x33\xf6\xeb\x25\xff\x75\x1c\x8d\x45\xf8\xff\x75\x18\x50\x57\xff\x75\x20\xff\x75\xec\xe8\x92\x1c\x00\x00\x8b\xf0\x89\x75\xf0\x83\xc4\x18\xf7\xde\x1b\xf6\x23\x75\xf8\x57\xe8\x8d\xfc\xff\xff\x59\xeb\x1a\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x15\x40\xb0\x00\x10\x8b\xf0\x39\x5d\xf4\x74\x09\xff\x75\xf4\xe8\x22\xb4\xff\xff\x59\x8b\x45\xf0\x3b\xc3\x74\x0c\x39\x45\x18\x74\x07\x50\xe8\x0f\xb4\xff\xff\x59\x8b\xc6\x8d\x65\xe0\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xd3\x95\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\x3e\x9d\xff\xff\xff\x75\x28\x8d\x4d\xf0\xff\x75\x24\xff\x75\x20\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xe8\x28\xfc\xff\xff\x83\xc4\x20\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x51\x51\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\xa1\x68\xf8\x00\x10\x53\x56\x33\xdb\x57\x8b\xf9\x3b\xc3\x75\x3a\x8d\x45\xf8\x50\x33\xf6\x46\x56\x68\xf4\xb9\x00\x10\x56\xff\x15\x30\xb0\x00\x10\x85\xc0\x74\x08\x89\x35\x68\xf8\x00\x10\xeb\x34\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\x0a\x6a\x02\x58\xa3\x68\xf8\x00\x10\xeb\x05\xa1\x68\xf8\x00\x10\x83\xf8\x02\x0f\x84\xcf\x00\x00\x00\x3b\xc3\x0f\x84\xc7\x00\x00\x00\x83\xf8\x01\x0f\x85\xe8\x00\x00\x00\x89\x5d\xf8\x39\x5d\x18\x75\x08\x8b\x07\x8b\x40\x04\x89\x45\x18\x8b\x35\x3c\xb0\x00\x10\x33\xc0\x39\x5d\x20\x53\x53\xff\x75\x10\x0f\x95\xc0\xff\x75\x0c\x8d\x04\xc5\x01\x00\x00\x00\x50\xff\x75\x18\xff\xd6\x8b\xf8\x3b\xfb\x0f\x84\xab\x00\x00\x00\x7e\x3c\x81\xff\xf0\xff\xff\x7f\x77\x34\x8d\x44\x3f\x08\x3d\x00\x04\x00\x00\x77\x13\xe8\xd2\x1c\x00\x00\x8b\xc4\x3b\xc3\x74\x1c\xc7\x00\xcc\xcc\x00\x00\xeb\x11\x50\xe8\xae\xe2\xff\xff\x59\x3b\xc3\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x8b\xd8\x85\xdb\x74\x69\x8d\x04\x3f\x50\x6a\x00\x53\xe8\x5e\xd4\xff\xff\x83\xc4\x0c\x57\x53\xff\x75\x10\xff\x75\x0c\x6a\x01\xff\x75\x18\xff\xd6\x85\xc0\x74\x11\xff\x75\x14\x50\x53\xff\x75\x08\xff\x15\x30\xb0\x00\x10\x89\x45\xf8\x53\xe8\xc9\xfa\xff\xff\x8b\x45\xf8\x59\xeb\x75\x33\xf6\x39\x5d\x1c\x75\x08\x8b\x07\x8b\x40\x14\x89\x45\x1c\x39\x5d\x18\x75\x08\x8b\x07\x8b\x40\x04\x89\x45\x18\xff\x75\x1c\xe8\x46\x1a\x00\x00\x59\x83\xf8\xff\x75\x04\x33\xc0\xeb\x47\x3b\x45\x18\x74\x1e\x53\x53\x8d\x4d\x10\x51\xff\x75\x0c\x50\xff\x75\x18\xe8\x6e\x1a\x00\x00\x8b\xf0\x83\xc4\x18\x3b\xf3\x74\xdc\x89\x75\x0c\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x75\x1c\xff\x15\x34\xb0\x00\x10\x8b\xf8\x3b\xf3\x74\x07\x56\xe8\x10\xb2\xff\xff\x59\x8b\xc7\x8d\x65\xec\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xd4\x93\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xff\x75\x08\x8d\x4d\xf0\xe8\x3f\x9b\xff\xff\xff\x75\x24\x8d\x4d\xf0\xff\x75\x20\xff\x75\x1c\xff\x75\x18\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xe8\x16\xfe\xff\xff\x83\xc4\x1c\x80\x7d\xfc\x00\x74\x07\x8b\x4d\xf8\x83\x61\x70\xfd\xc9\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x0f\x84\x81\x01\x00\x00\xff\x76\x04\xe8\xa0\xb1\xff\xff\xff\x76\x08\xe8\x98\xb1\xff\xff\xff\x76\x0c\xe8\x90\xb1\xff\xff\xff\x76\x10\xe8\x88\xb1\xff\xff\xff\x76\x14\xe8\x80\xb1\xff\xff\xff\x76\x18\xe8\x78\xb1\xff\xff\xff\x36\xe8\x71\xb1\xff\xff\xff\x76\x20\xe8\x69\xb1\xff\xff\xff\x76\x24\xe8\x61\xb1\xff\xff\xff\x76\x28\xe8\x59\xb1\xff\xff\xff\x76\x2c\xe8\x51\xb1\xff\xff\xff\x76\x30\xe8\x49\xb1\xff\xff\xff\x76\x34\xe8\x41\xb1\xff\xff\xff\x76\x1c\xe8\x39\xb1\xff\xff\xff\x76\x38\xe8\x31\xb1\xff\xff\xff\x76\x3c\xe8\x29\xb1\xff\xff\x83\xc4\x40\xff\x76\x40\xe8\x1e\xb1\xff\xff\xff\x76\x44\xe8\x16\xb1\xff\xff\xff\x76\x48\xe8\x0e\xb1\xff\xff\xff\x76\x4c\xe8\x06\xb1\xff\xff\xff\x76\x50\xe8\xfe\xb0\xff\xff\xff\x76\x54\xe8\xf6\xb0\xff\xff\xff\x76\x58\xe8\xee\xb0\xff\xff\xff\x76\x5c\xe8\xe6\xb0\xff\xff\xff\x76\x60\xe8\xde\xb0\xff\xff\xff\x76\x64\xe8\xd6\xb0\xff\xff\xff\x76\x68\xe8\xce\xb0\xff\xff\xff\x76\x6c\xe8\xc6\xb0\xff\xff\xff\x76\x70\xe8\xbe\xb0\xff\xff\xff\x76\x74\xe8\xb6\xb0\xff\xff\xff\x76\x78\xe8\xae\xb0\xff\xff\xff\x76\x7c\xe8\xa6\xb0\xff\xff\x83\xc4\x40\xff\xb6\x80\x00\x00\x00\xe8\x98\xb0\xff\xff\xff\xb6\x84\x00\x00\x00\xe8\x8d\xb0\xff\xff\xff\xb6\x88\x00\x00\x00\xe8\x82\xb0\xff\xff\xff\xb6\x8c\x00\x00\x00\xe8\x77\xb0\xff\xff\xff\xb6\x90\x00\x00\x00\xe8\x6c\xb0\xff\xff\xff\xb6\x94\x00\x00\x00\xe8\x61\xb0\xff\xff\xff\xb6\x98\x00\x00\x00\xe8\x56\xb0\xff\xff\xff\xb6\x9c\x00\x00\x00\xe8\x4b\xb0\xff\xff\xff\xb6\xa0\x00\x00\x00\xe8\x40\xb0\xff\xff\xff\xb6\xa4\x00\x00\x00\xe8\x35\xb0\xff\xff\xff\xb6\xa8\x00\x00\x00\xe8\x2a\xb0\xff\xff\x83\xc4\x2c\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x74\x35\x8b\x06\x3b\x05\x58\xed\x00\x10\x74\x07\x50\xe8\x07\xb0\xff\xff\x59\x8b\x46\x04\x3b\x05\x5c\xed\x00\x10\x74\x07\x50\xe8\xf5\xaf\xff\xff\x59\x8b\x76\x08\x3b\x35\x60\xed\x00\x10\x74\x07\x56\xe8\xe3\xaf\xff\xff\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x85\xf6\x74\x7e\x8b\x46\x0c\x3b\x05\x64\xed\x00\x10\x74\x07\x50\xe8\xc1\xaf\xff\xff\x59\x8b\x46\x10\x3b\x05\x68\xed\x00\x10\x74\x07\x50\xe8\xaf\xaf\xff\xff\x59\x8b\x46\x14\x3b\x05\x6c\xed\x00\x10\x74\x07\x50\xe8\x9d\xaf\xff\xff\x59\x8b\x46\x18\x3b\x05\x70\xed\x00\x10\x74\x07\x50\xe8\x8b\xaf\xff\xff\x59\x8b\x46\x1c\x3b\x05\x74\xed\x00\x10\x74\x07\x50\xe8\x79\xaf\xff\xff\x59\x8b\x46\x20\x3b\x05\x78\xed\x00\x10\x74\x07\x50\xe8\x67\xaf\xff\xff\x59\x8b\x76\x24\x3b\x35\x7c\xed\x00\x10\x74\x07\x56\xe8\x55\xaf\xff\xff\x59\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x53\x33\xdb\x56\x57\x3b\xc3\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\xef\xa6\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\x78\xa6\xff\xff\x83\xc4\x14\x8b\xc6\xeb\x3c\x8b\x75\x10\x3b\xf3\x75\x04\x88\x18\xeb\xda\x8b\xd0\x38\x1a\x74\x04\x42\x4f\x75\xf8\x3b\xfb\x74\xee\x8a\x0e\x88\x0a\x42\x46\x3a\xcb\x74\x03\x4f\x75\xf3\x3b\xfb\x75\x10\x88\x18\xe8\xa8\xa6\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\xb5\x33\xc0\x5f\x5e\x5b\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x56\x33\xc0\x50\x50\x50\x50\x50\x50\x50\x50\x8b\x55\x0c\x8d\x49\x00\x8a\x02\x0a\xc0\x74\x09\x83\xc2\x01\x0f\xab\x04\x24\xeb\xf1\x8b\x75\x08\x83\xc9\xff\x8d\x49\x00\x83\xc1\x01\x8a\x06\x0a\xc0\x74\x09\x83\xc6\x01\x0f\xa3\x04\x24\x73\xee\x8b\xc1\x83\xc4\x20\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x53\x56\x8b\x75\x08\x33\xdb\x57\x39\x5d\x14\x75\x10\x3b\xf3\x75\x10\x39\x5d\x0c\x75\x12\x33\xc0\x5f\x5e\x5b\x5d\xc3\x3b\xf3\x74\x07\x8b\x7d\x0c\x3b\xfb\x77\x1b\xe8\x1a\xa6\xff\xff\x6a\x16\x5e\x89\x30\x53\x53\x53\x53\x53\xe8\xa3\xa5\xff\xff\x83\xc4\x14\x8b\xc6\xeb\xd5\x39\x5d\x14\x75\x04\x88\x1e\xeb\xca\x8b\x55\x10\x3b\xd3\x75\x04\x88\x1e\xeb\xd1\x83\x7d\x14\xff\x8b\xc6\x75\x0f\x8a\x0a\x88\x08\x40\x42\x3a\xcb\x74\x1e\x4f\x75\xf3\xeb\x19\x8a\x0a\x88\x08\x40\x42\x3a\xcb\x74\x08\x4f\x74\x05\xff\x4d\x14\x75\xee\x39\x5d\x14\x75\x02\x88\x18\x3b\xfb\x75\x8b\x83\x7d\x14\xff\x75\x0f\x8b\x45\x0c\x6a\x50\x88\x5c\x06\xff\x58\xe9\x78\xff\xff\xff\x88\x1e\xe8\xa0\xa5\xff\xff\x6a\x22\x59\x89\x08\x8b\xf1\xeb\x82\xcc\xcc\xcc\xcc\xcc\x8b\x54\x24\x04\x8b\x4c\x24\x08\xf7\xc2\x03\x00\x00\x00\x75\x3c\x8b\x02\x3a\x01\x75\x2e\x0a\xc0\x74\x26\x3a\x61\x01\x75\x25\x0a\xe4\x74\x1d\xc1\xe8\x10\x3a\x41\x02\x75\x19\x0a\xc0\x74\x11\x3a\x61\x03\x75\x10\x83\xc1\x04\x83\xc2\x04\x0a\xe4\x75\xd2\x8b\xff\x33\xc0\xc3\x90\x1b\xc0\xd1\xe0\x83\xc0\x01\xc3\xf7\xc2\x01\x00\x00\x00\x74\x18\x8a\x02\x83\xc2\x01\x3a\x01\x75\xe7\x83\xc1\x01\x0a\xc0\x74\xdc\xf7\xc2\x02\x00\x00\x00\x74\xa4\x66\x8b\x02\x83\xc2\x02\x3a\x01\x75\xce\x0a\xc0\x74\xc6\x3a\x61\x01\x75\xc5\x0a\xe4\x74\xbd\x83\xc1\x02\xeb\x88\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x56\x33\xc0\x50\x50\x50\x50\x50\x50\x50\x50\x8b\x55\x0c\x8d\x49\x00\x8a\x02\x0a\xc0\x74\x09\x83\xc2\x01\x0f\xab\x04\x24\xeb\xf1\x8b\x75\x08\x8b\xff\x8a\x06\x0a\xc0\x74\x0c\x83\xc6\x01\x0f\xa3\x04\x24\x73\xf1\x8d\x46\xff\x83\xc4\x20\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x51\x51\x8b\x45\x0c\x56\x8b\x75\x08\x89\x45\xf8\x8b\x45\x10\x57\x56\x89\x45\xfc\xe8\x93\x13\x00\x00\x83\xcf\xff\x59\x3b\xc7\x75\x11\xe8\x97\xa4\xff\xff\xc7\x00\x09\x00\x00\x00\x8b\xc7\x8b\xd7\xeb\x4a\xff\x75\x14\x8d\x4d\xfc\x51\xff\x75\xf8\x50\xff\x15\x28\xb0\x00\x10\x89\x45\xf8\x3b\xc7\x75\x13\xff\x15\x00\xb0\x00\x10\x85\xc0\x74\x09\x50\xe8\x89\xa4\xff\xff\x59\xeb\xcf\x8b\xc6\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x83\xe6\x1f\xc1\xe6\x06\x8d\x44\x30\x04\x80\x20\xfd\x8b\x45\xf8\x8b\x55\xfc\x5f\x5e\xc9\xc3\x6a\x14\x68\x78\xc8\x00\x10\xe8\x7b\xa4\xff\xff\x83\xce\xff\x89\x75\xdc\x89\x75\xe0\x8b\x45\x08\x83\xf8\xfe\x75\x1c\xe8\x2e\xa4\xff\xff\x83\x20\x00\xe8\x13\xa4\xff\xff\xc7\x00\x09\x00\x00\x00\x8b\xc6\x8b\xd6\xe9\xd0\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x04\xa4\xff\xff\x89\x38\xe8\xea\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x72\xa3\xff\xff\x83\xc4\x14\xeb\xc8\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x75\x26\xe8\xc3\xa3\xff\xff\x89\x38\xe8\xa9\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x31\xa3\xff\xff\x83\xc4\x14\x83\xca\xff\x8b\xc2\xeb\x5b\x50\xe8\xef\x12\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x1c\xff\x75\x14\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\xa9\xfe\xff\xff\x83\xc4\x10\x89\x45\xdc\x89\x55\xe0\xeb\x1a\xe8\x5b\xa3\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x63\xa3\xff\xff\x89\x38\x83\x4d\xdc\xff\x83\x4d\xe0\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x0c\x00\x00\x00\x8b\x45\xdc\x8b\x55\xe0\xe8\xbe\xa3\xff\xff\xc3\xff\x75\x08\xe8\x2c\x13\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\xff\x05\x1c\xf2\x00\x10\x68\x00\x10\x00\x00\xe8\xe2\xab\xff\xff\x59\x8b\x4d\x08\x89\x41\x08\x85\xc0\x74\x0d\x83\x49\x0c\x08\xc7\x41\x18\x00\x10\x00\x00\xeb\x11\x83\x49\x0c\x04\x8d\x41\x14\x89\x41\x08\xc7\x41\x18\x02\x00\x00\x00\x8b\x41\x08\x83\x61\x04\x00\x89\x01\x5d\xc3\x6a\x02\xe8\xb6\xac\xff\xff\x59\xc3\x55\x8b\xec\x83\xec\x04\x89\x7d\xfc\x8b\x7d\x08\x8b\x4d\x0c\xc1\xe9\x07\x66\x0f\xef\xc0\xeb\x08\x8d\xa4\x24\x00\x00\x00\x00\x90\x66\x0f\x7f\x07\x66\x0f\x7f\x47\x10\x66\x0f\x7f\x47\x20\x66\x0f\x7f\x47\x30\x66\x0f\x7f\x47\x40\x66\x0f\x7f\x47\x50\x66\x0f\x7f\x47\x60\x66\x0f\x7f\x47\x70\x8d\xbf\x80\x00\x00\x00\x49\x75\xd0\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x55\x8b\xec\x83\xec\x10\x89\x7d\xfc\x8b\x45\x08\x99\x8b\xf8\x33\xfa\x2b\xfa\x83\xe7\x0f\x33\xfa\x2b\xfa\x85\xff\x75\x3c\x8b\x4d\x10\x8b\xd1\x83\xe2\x7f\x89\x55\xf4\x3b\xca\x74\x12\x2b\xca\x51\x50\xe8\x73\xff\xff\xff\x83\xc4\x08\x8b\x45\x08\x8b\x55\xf4\x85\xd2\x74\x45\x03\x45\x10\x2b\xc2\x89\x45\xf8\x33\xc0\x8b\x7d\xf8\x8b\x4d\xf4\xf3\xaa\x8b\x45\x08\xeb\x2e\xf7\xdf\x83\xc7\x10\x89\x7d\xf0\x33\xc0\x8b\x7d\x08\x8b\x4d\xf0\xf3\xaa\x8b\x45\xf0\x8b\x4d\x08\x8b\x55\x10\x03\xc8\x2b\xd0\x52\x6a\x00\x51\xe8\x7e\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x6a\x0c\x68\x98\xc8\x00\x10\xe8\x2a\xa2\xff\xff\x83\x65\xfc\x00\x66\x0f\x28\xc1\xc7\x45\xe4\x01\x00\x00\x00\xeb\x23\x8b\x45\xec\x8b\x00\x8b\x00\x3d\x05\x00\x00\xc0\x74\x0a\x3d\x1d\x00\x00\xc0\x74\x03\x33\xc0\xc3\x33\xc0\x40\xc3\x8b\x65\xe8\x83\x65\xe4\x00\xc7\x45\xfc\xfe\xff\xff\xff\x8b\x45\xe4\xe8\x2c\xa2\xff\xff\xc3\x8b\xff\x55\x8b\xec\x83\xec\x18\x33\xc0\x53\x89\x45\xfc\x89\x45\xf4\x89\x45\xf8\x53\x9c\x58\x8b\xc8\x35\x00\x00\x20\x00\x50\x9d\x9c\x5a\x2b\xd1\x74\x1f\x51\x9d\x33\xc0\x0f\xa2\x89\x45\xf4\x89\x5d\xe8\x89\x55\xec\x89\x4d\xf0\xb8\x01\x00\x00\x00\x0f\xa2\x89\x55\xfc\x89\x45\xf8\x5b\xf7\x45\xfc\x00\x00\x00\x04\x74\x0e\xe8\x5c\xff\xff\xff\x85\xc0\x74\x05\x33\xc0\x40\xeb\x02\x33\xc0\x5b\xc9\xc3\xe8\x99\xff\xff\xff\xa3\x0c\xfd\x00\x10\x33\xc0\xc3\xcc\xcc\xcc\x55\x8b\xec\x53\x56\x57\x55\x6a\x00\x6a\x00\x68\x50\x8a\x00\x10\xff\x75\x08\xe8\x0e\x16\x00\x00\x5d\x5f\x5e\x5b\x8b\xe5\x5d\xc3\x8b\x4c\x24\x04\xf7\x41\x04\x06\x00\x00\x00\xb8\x01\x00\x00\x00\x74\x32\x8b\x44\x24\x14\x8b\x48\xfc\x33\xc8\xe8\x06\x8b\xff\xff\x55\x8b\x68\x10\x8b\x50\x28\x52\x8b\x50\x24\x52\xe8\x14\x00\x00\x00\x83\xc4\x08\x5d\x8b\x44\x24\x08\x8b\x54\x24\x10\x89\x02\xb8\x03\x00\x00\x00\xc3\x53\x56\x57\x8b\x44\x24\x10\x55\x50\x6a\xfe\x68\x58\x8a\x00\x10\x64\xff\x35\x00\x00\x00\x00\xa1\x00\xe0\x00\x10\x33\xc4\x50\x8d\x44\x24\x04\x64\xa3\x00\x00\x00\x00\x8b\x44\x24\x28\x8b\x58\x08\x8b\x70\x0c\x83\xfe\xff\x74\x3a\x83\x7c\x24\x2c\xff\x74\x06\x3b\x74\x24\x2c\x76\x2d\x8d\x34\x76\x8b\x0c\xb3\x89\x4c\x24\x0c\x89\x48\x0c\x83\x7c\xb3\x04\x00\x75\x17\x68\x01\x01\x00\x00\x8b\x44\xb3\x08\xe8\x49\x00\x00\x00\x8b\x44\xb3\x08\xe8\x5f\x00\x00\x00\xeb\xb7\x8b\x4c\x24\x04\x64\x89\x0d\x00\x00\x00\x00\x83\xc4\x18\x5f\x5e\x5b\xc3\x33\xc0\x64\x8b\x0d\x00\x00\x00\x00\x81\x79\x04\x58\x8a\x00\x10\x75\x10\x8b\x51\x0c\x8b\x52\x0c\x39\x51\x08\x75\x05\xb8\x01\x00\x00\x00\xc3\x53\x51\xbb\xa0\xed\x00\x10\xeb\x0b\x53\x51\xbb\xa0\xed\x00\x10\x8b\x4c\x24\x0c\x89\x4b\x08\x89\x43\x04\x89\x6b\x0c\x55\x51\x50\x58\x59\x5d\x59\x5b\xc2\x04\x00\xff\xd0\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\x56\x57\xff\x75\x08\x8d\x4d\xec\xe8\x7a\x91\xff\xff\x8b\x45\x10\x8b\x75\x0c\x33\xff\x3b\xc7\x74\x02\x89\x30\x3b\xf7\x75\x2c\xe8\xc7\x9f\xff\xff\x57\x57\x57\x57\x57\xc7\x00\x16\x00\x00\x00\xe8\x4f\x9f\xff\xff\x83\xc4\x14\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x33\xc0\xe9\xd8\x01\x00\x00\x39\x7d\x14\x74\x0c\x83\x7d\x14\x02\x7c\xc9\x83\x7d\x14\x24\x7f\xc3\x8b\x4d\xec\x53\x8a\x1e\x89\x7d\xfc\x8d\x7e\x01\x83\xb9\xac\x00\x00\x00\x01\x7e\x17\x8d\x45\xec\x50\x0f\xb6\xc3\x6a\x08\x50\xe8\xdb\x11\x00\x00\x8b\x4d\xec\x83\xc4\x0c\xeb\x10\x8b\x91\xc8\x00\x00\x00\x0f\xb6\xc3\x0f\xb7\x04\x42\x83\xe0\x08\x85\xc0\x74\x05\x8a\x1f\x47\xeb\xc7\x80\xfb\x2d\x75\x06\x83\x4d\x18\x02\xeb\x05\x80\xfb\x2b\x75\x03\x8a\x1f\x47\x8b\x45\x14\x85\xc0\x0f\x8c\x4b\x01\x00\x00\x83\xf8\x01\x0f\x84\x42\x01\x00\x00\x83\xf8\x24\x0f\x8f\x39\x01\x00\x00\x85\xc0\x75\x2a\x80\xfb\x30\x74\x09\xc7\x45\x14\x0a\x00\x00\x00\xeb\x34\x8a\x07\x3c\x78\x74\x0d\x3c\x58\x74\x09\xc7\x45\x14\x08\x00\x00\x00\xeb\x21\xc7\x45\x14\x10\x00\x00\x00\xeb\x0a\x83\xf8\x10\x75\x13\x80\xfb\x30\x75\x0e\x8a\x07\x3c\x78\x74\x04\x3c\x58\x75\x04\x47\x8a\x1f\x47\x8b\xb1\xc8\x00\x00\x00\xb8\xff\xff\xff\xff\x33\xd2\xf7\x75\x14\x0f\xb6\xcb\x0f\xb7\x0c\x4e\xf6\xc1\x04\x74\x08\x0f\xbe\xcb\x83\xe9\x30\xeb\x1b\xf7\xc1\x03\x01\x00\x00\x74\x31\x8a\xcb\x80\xe9\x61\x80\xf9\x19\x0f\xbe\xcb\x77\x03\x83\xe9\x20\x83\xc1\xc9\x3b\x4d\x14\x73\x19\x83\x4d\x18\x08\x39\x45\xfc\x72\x27\x75\x04\x3b\xca\x76\x21\x83\x4d\x18\x04\x83\x7d\x10\x00\x75\x23\x8b\x45\x18\x4f\xa8\x08\x75\x20\x83\x7d\x10\x00\x74\x03\x8b\x7d\x0c\x83\x65\xfc\x00\xeb\x5b\x8b\x5d\xfc\x0f\xaf\x5d\x14\x03\xd9\x89\x5d\xfc\x8a\x1f\x47\xeb\x8b\xbe\xff\xff\xff\x7f\xa8\x04\x75\x1b\xa8\x01\x75\x3d\x83\xe0\x02\x74\x09\x81\x7d\xfc\x00\x00\x00\x80\x77\x09\x85\xc0\x75\x2b\x39\x75\xfc\x76\x26\xe8\x26\x9e\xff\xff\xf6\x45\x18\x01\xc7\x00\x22\x00\x00\x00\x74\x06\x83\x4d\xfc\xff\xeb\x0f\xf6\x45\x18\x02\x6a\x00\x58\x0f\x95\xc0\x03\xc6\x89\x45\xfc\x8b\x45\x10\x85\xc0\x74\x02\x89\x38\xf6\x45\x18\x02\x74\x03\xf7\x5d\xfc\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x8b\x45\xfc\xeb\x18\x8b\x45\x10\x85\xc0\x74\x02\x89\x30\x80\x7d\xf8\x00\x74\x07\x8b\x45\xf4\x83\x60\x70\xfd\x33\xc0\x5b\x5f\x5e\xc9\xc3\x8b\xff\x55\x8b\xec\x33\xc0\x50\xff\x75\x10\xff\x75\x0c\xff\x75\x08\x39\x05\xf4\xf4\x00\x10\x75\x07\x68\x98\xeb\x00\x10\xeb\x01\x50\xe8\xab\xfd\xff\xff\x83\xc4\x14\x5d\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x8b\x75\x0c\x8b\x4d\x10\x8b\x7d\x08\x8b\xc1\x8b\xd1\x03\xc6\x3b\xfe\x76\x08\x3b\xf8\x0f\x82\xa4\x01\x00\x00\x81\xf9\x00\x01\x00\x00\x72\x1f\x83\x3d\x0c\xfd\x00\x10\x00\x74\x16\x57\x56\x83\xe7\x0f\x83\xe6\x0f\x3b\xfe\x5e\x5f\x75\x08\x5e\x5f\x5d\xe9\x13\x07\x00\x00\xf7\xc7\x03\x00\x00\x00\x75\x15\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x2a\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x90\x8b\xc7\xba\x03\x00\x00\x00\x83\xe9\x04\x72\x0c\x83\xe0\x03\x03\xc8\xff\x24\x85\x58\x8e\x00\x10\xff\x24\x8d\x54\x8f\x00\x10\x90\xff\x24\x8d\xd8\x8e\x00\x10\x90\x68\x8e\x00\x10\x94\x8e\x00\x10\xb8\x8e\x00\x10\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xc6\x03\x83\xc7\x03\x83\xf9\x08\x72\xcc\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x8d\x49\x00\x23\xd1\x8a\x06\x88\x07\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xc6\x02\x83\xc7\x02\x83\xf9\x08\x72\xa6\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x90\x23\xd1\x8a\x06\x88\x07\x83\xc6\x01\xc1\xe9\x02\x83\xc7\x01\x83\xf9\x08\x72\x88\xf3\xa5\xff\x24\x95\x44\x8f\x00\x10\x8d\x49\x00\x3b\x8f\x00\x10\x28\x8f\x00\x10\x20\x8f\x00\x10\x18\x8f\x00\x10\x10\x8f\x00\x10\x08\x8f\x00\x10\x00\x8f\x00\x10\xf8\x8e\x00\x10\x8b\x44\x8e\xe4\x89\x44\x8f\xe4\x8b\x44\x8e\xe8\x89\x44\x8f\xe8\x8b\x44\x8e\xec\x89\x44\x8f\xec\x8b\x44\x8e\xf0\x89\x44\x8f\xf0\x8b\x44\x8e\xf4\x89\x44\x8f\xf4\x8b\x44\x8e\xf8\x89\x44\x8f\xf8\x8b\x44\x8e\xfc\x89\x44\x8f\xfc\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\x44\x8f\x00\x10\x8b\xff\x54\x8f\x00\x10\x5c\x8f\x00\x10\x68\x8f\x00\x10\x7c\x8f\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x06\x88\x07\x8a\x46\x01\x88\x47\x01\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8d\x74\x31\xfc\x8d\x7c\x39\xfc\xf7\xc7\x03\x00\x00\x00\x75\x24\xc1\xe9\x02\x83\xe2\x03\x83\xf9\x08\x72\x0d\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8b\xff\xf7\xd9\xff\x24\x8d\x90\x90\x00\x10\x8d\x49\x00\x8b\xc7\xba\x03\x00\x00\x00\x83\xf9\x04\x72\x0c\x83\xe0\x03\x2b\xc8\xff\x24\x85\xe4\x8f\x00\x10\xff\x24\x8d\xe0\x90\x00\x10\x90\xf4\x8f\x00\x10\x18\x90\x00\x10\x40\x90\x00\x10\x8a\x46\x03\x23\xd1\x88\x47\x03\x83\xee\x01\xc1\xe9\x02\x83\xef\x01\x83\xf9\x08\x72\xb2\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8d\x49\x00\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\xc1\xe9\x02\x88\x47\x02\x83\xee\x02\x83\xef\x02\x83\xf9\x08\x72\x88\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x90\x8a\x46\x03\x23\xd1\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\xc1\xe9\x02\x88\x47\x01\x83\xee\x03\x83\xef\x03\x83\xf9\x08\x0f\x82\x56\xff\xff\xff\xfd\xf3\xa5\xfc\xff\x24\x95\xe0\x90\x00\x10\x8d\x49\x00\x94\x90\x00\x10\x9c\x90\x00\x10\xa4\x90\x00\x10\xac\x90\x00\x10\xb4\x90\x00\x10\xbc\x90\x00\x10\xc4\x90\x00\x10\xd7\x90\x00\x10\x8b\x44\x8e\x1c\x89\x44\x8f\x1c\x8b\x44\x8e\x18\x89\x44\x8f\x18\x8b\x44\x8e\x14\x89\x44\x8f\x14\x8b\x44\x8e\x10\x89\x44\x8f\x10\x8b\x44\x8e\x0c\x89\x44\x8f\x0c\x8b\x44\x8e\x08\x89\x44\x8f\x08\x8b\x44\x8e\x04\x89\x44\x8f\x04\x8d\x04\x8d\x00\x00\x00\x00\x03\xf0\x03\xf8\xff\x24\x95\xe0\x90\x00\x10\x8b\xff\xf0\x90\x00\x10\xf8\x90\x00\x10\x08\x91\x00\x10\x1c\x91\x00\x10\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8b\x45\x08\x5e\x5f\xc9\xc3\x8d\x49\x00\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8b\x45\x08\x5e\x5f\xc9\xc3\x90\x8a\x46\x03\x88\x47\x03\x8a\x46\x02\x88\x47\x02\x8a\x46\x01\x88\x47\x01\x8b\x45\x08\x5e\x5f\xc9\xc3\x6a\x10\x68\xb8\xc8\x00\x10\xe8\x6b\x9a\xff\xff\x33\xc0\x8b\x5d\x08\x33\xff\x3b\xdf\x0f\x95\xc0\x3b\xc7\x75\x1d\xe8\x0c\x9a\xff\xff\xc7\x00\x16\x00\x00\x00\x57\x57\x57\x57\x57\xe8\x94\x99\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x53\x83\x3d\x2c\xfd\x00\x10\x03\x75\x38\x6a\x04\xe8\x73\xb4\xff\xff\x59\x89\x7d\xfc\x53\xe8\xe5\xc6\xff\xff\x59\x89\x45\xe0\x3b\xc7\x74\x0b\x8b\x73\xfc\x83\xee\x09\x89\x75\xe4\xeb\x03\x8b\x75\xe4\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x25\x00\x00\x00\x39\x7d\xe0\x75\x10\x53\x57\xff\x35\x84\xf3\x00\x10\xff\x15\x24\xb0\x00\x10\x8b\xf0\x8b\xc6\xe8\x2b\x9a\xff\xff\xc3\x33\xff\x8b\x5d\x08\x8b\x75\xe4\x6a\x04\xe8\x41\xb3\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x83\xec\x14\x53\x56\x57\xe8\x26\x9c\xff\xff\x83\x65\xfc\x00\x83\x3d\x74\xf8\x00\x10\x00\x8b\xd8\x0f\x85\x8e\x00\x00\x00\x68\x90\xc3\x00\x10\xff\x15\x04\xb1\x00\x10\x8b\xf8\x85\xff\x0f\x84\x2a\x01\x00\x00\x8b\x35\x6c\xb0\x00\x10\x68\x84\xc3\x00\x10\x57\xff\xd6\x85\xc0\x0f\x84\x14\x01\x00\x00\x50\xe8\x70\x9b\xff\xff\xc7\x04\x24\x74\xc3\x00\x10\x57\xa3\x74\xf8\x00\x10\xff\xd6\x50\xe8\x5b\x9b\xff\xff\xc7\x04\x24\x60\xc3\x00\x10\x57\xa3\x78\xf8\x00\x10\xff\xd6\x50\xe8\x46\x9b\xff\xff\xc7\x04\x24\x44\xc3\x00\x10\x57\xa3\x7c\xf8\x00\x10\xff\xd6\x50\xe8\x31\x9b\xff\xff\x59\xa3\x84\xf8\x00\x10\x85\xc0\x74\x14\x68\x2c\xc3\x00\x10\x57\xff\xd6\x50\xe8\x19\x9b\xff\xff\x59\xa3\x80\xf8\x00\x10\xa1\x80\xf8\x00\x10\x3b\xc3\x74\x4f\x39\x1d\x84\xf8\x00\x10\x74\x47\x50\xe8\x77\x9b\xff\xff\xff\x35\x84\xf8\x00\x10\x8b\xf0\xe8\x6a\x9b\xff\xff\x59\x59\x8b\xf8\x85\xf6\x74\x2c\x85\xff\x74\x28\xff\xd6\x85\xc0\x74\x19\x8d\x4d\xf8\x51\x6a\x0c\x8d\x4d\xec\x51\x6a\x01\x50\xff\xd7\x85\xc0\x74\x06\xf6\x45\xf4\x01\x75\x09\x81\x4d\x10\x00\x00\x20\x00\xeb\x39\xa1\x78\xf8\x00\x10\x3b\xc3\x74\x30\x50\xe8\x27\x9b\xff\xff\x59\x85\xc0\x74\x25\xff\xd0\x89\x45\xfc\x85\xc0\x74\x1c\xa1\x7c\xf8\x00\x10\x3b\xc3\x74\x13\x50\xe8\x0a\x9b\xff\xff\x59\x85\xc0\x74\x08\xff\x75\xfc\xff\xd0\x89\x45\xfc\xff\x35\x74\xf8\x00\x10\xe8\xf2\x9a\xff\xff\x59\x85\xc0\x74\x10\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xff\x75\xfc\xff\xd0\xeb\x02\x33\xc0\x5f\x5e\x5b\xc9\xc3\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x56\x33\xf6\x3b\xce\x7c\x1e\x83\xf9\x02\x7e\x0c\x83\xf9\x03\x75\x14\xa1\xf0\xee\x00\x10\xeb\x28\xa1\xf0\xee\x00\x10\x89\x0d\xf0\xee\x00\x10\xeb\x1b\xe8\xef\x97\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x16\x00\x00\x00\xe8\x77\x97\xff\xff\x83\xc4\x14\x83\xc8\xff\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x81\xec\x28\x03\x00\x00\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\xf6\x05\xb0\xed\x00\x10\x01\x56\x74\x08\x6a\x0a\xe8\xd1\xd3\xff\xff\x59\xe8\x8c\xd7\xff\xff\x85\xc0\x74\x08\x6a\x16\xe8\x8e\xd7\xff\xff\x59\xf6\x05\xb0\xed\x00\x10\x02\x0f\x84\xca\x00\x00\x00\x89\x85\xe0\xfd\xff\xff\x89\x8d\xdc\xfd\xff\xff\x89\x95\xd8\xfd\xff\xff\x89\x9d\xd4\xfd\xff\xff\x89\xb5\xd0\xfd\xff\xff\x89\xbd\xcc\xfd\xff\xff\x66\x8c\x95\xf8\xfd\xff\xff\x66\x8c\x8d\xec\xfd\xff\xff\x66\x8c\x9d\xc8\xfd\xff\xff\x66\x8c\x85\xc4\xfd\xff\xff\x66\x8c\xa5\xc0\xfd\xff\xff\x66\x8c\xad\xbc\xfd\xff\xff\x9c\x8f\x85\xf0\xfd\xff\xff\x8b\x75\x04\x8d\x45\x04\x89\x85\xf4\xfd\xff\xff\xc7\x85\x30\xfd\xff\xff\x01\x00\x01\x00\x89\xb5\xe8\xfd\xff\xff\x8b\x40\xfc\x6a\x50\x89\x85\xe4\xfd\xff\xff\x8d\x85\xd8\xfc\xff\xff\x6a\x00\x50\xe8\xf5\xc0\xff\xff\x8d\x85\xd8\xfc\xff\xff\x83\xc4\x0c\x89\x85\x28\xfd\xff\xff\x8d\x85\x30\xfd\xff\xff\x6a\x00\xc7\x85\xd8\xfc\xff\xff\x15\x00\x00\x40\x89\xb5\xe4\xfc\xff\xff\x89\x85\x2c\xfd\xff\xff\xff\x15\x5c\xb0\x00\x10\x8d\x85\x28\xfd\xff\xff\x50\xff\x15\x58\xb0\x00\x10\x6a\x03\xe8\x12\xa3\xff\xff\xcc\x55\x8b\xec\x83\xec\x08\x89\x7d\xfc\x89\x75\xf8\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\x10\xc1\xe9\x07\xeb\x06\x8d\x9b\x00\x00\x00\x00\x66\x0f\x6f\x06\x66\x0f\x6f\x4e\x10\x66\x0f\x6f\x56\x20\x66\x0f\x6f\x5e\x30\x66\x0f\x7f\x07\x66\x0f\x7f\x4f\x10\x66\x0f\x7f\x57\x20\x66\x0f\x7f\x5f\x30\x66\x0f\x6f\x66\x40\x66\x0f\x6f\x6e\x50\x66\x0f\x6f\x76\x60\x66\x0f\x6f\x7e\x70\x66\x0f\x7f\x67\x40\x66\x0f\x7f\x6f\x50\x66\x0f\x7f\x77\x60\x66\x0f\x7f\x7f\x70\x8d\xb6\x80\x00\x00\x00\x8d\xbf\x80\x00\x00\x00\x49\x75\xa3\x8b\x75\xf8\x8b\x7d\xfc\x8b\xe5\x5d\xc3\x55\x8b\xec\x83\xec\x1c\x89\x7d\xf4\x89\x75\xf8\x89\x5d\xfc\x8b\x5d\x0c\x8b\xc3\x99\x8b\xc8\x8b\x45\x08\x33\xca\x2b\xca\x83\xe1\x0f\x33\xca\x2b\xca\x99\x8b\xf8\x33\xfa\x2b\xfa\x83\xe7\x0f\x33\xfa\x2b\xfa\x8b\xd1\x0b\xd7\x75\x4a\x8b\x75\x10\x8b\xce\x83\xe1\x7f\x89\x4d\xe8\x3b\xf1\x74\x13\x2b\xf1\x56\x53\x50\xe8\x27\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\x8b\x4d\xe8\x85\xc9\x74\x77\x8b\x5d\x10\x8b\x55\x0c\x03\xd3\x2b\xd1\x89\x55\xec\x03\xd8\x2b\xd9\x89\x5d\xf0\x8b\x75\xec\x8b\x7d\xf0\x8b\x4d\xe8\xf3\xa4\x8b\x45\x08\xeb\x53\x3b\xcf\x75\x35\xf7\xd9\x83\xc1\x10\x89\x4d\xe4\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\xe4\xf3\xa4\x8b\x4d\x08\x03\x4d\xe4\x8b\x55\x0c\x03\x55\xe4\x8b\x45\x10\x2b\x45\xe4\x50\x52\x51\xe8\x4c\xff\xff\xff\x83\xc4\x0c\x8b\x45\x08\xeb\x1a\x8b\x75\x0c\x8b\x7d\x08\x8b\x4d\x10\x8b\xd1\xc1\xe9\x02\xf3\xa5\x8b\xca\x83\xe1\x03\xf3\xa4\x8b\x45\x08\x8b\x5d\xfc\x8b\x75\xf8\x8b\x7d\xf4\x8b\xe5\x5d\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x57\x56\xe8\x34\x04\x00\x00\x59\x83\xf8\xff\x74\x50\xa1\x40\xfd\x00\x10\x83\xfe\x01\x75\x09\xf6\x80\x84\x00\x00\x00\x01\x75\x0b\x83\xfe\x02\x75\x1c\xf6\x40\x44\x01\x74\x16\x6a\x02\xe8\x09\x04\x00\x00\x6a\x01\x8b\xf8\xe8\x00\x04\x00\x00\x59\x59\x3b\xc7\x74\x1c\x56\xe8\xf4\x03\x00\x00\x59\x50\xff\x15\x20\xb0\x00\x10\x85\xc0\x75\x0a\xff\x15\x00\xb0\x00\x10\x8b\xf8\xeb\x02\x33\xff\x56\xe8\x50\x03\x00\x00\x8b\xc6\xc1\xf8\x05\x8b\x04\x85\x40\xfd\x00\x10\x83\xe6\x1f\xc1\xe6\x06\x59\xc6\x44\x30\x04\x00\x85\xff\x74\x0c\x57\xe8\xeb\x94\xff\xff\x59\x83\xc8\xff\xeb\x02\x33\xc0\x5f\x5e\x5d\xc3\x6a\x10\x68\xd8\xc8\x00\x10\xe8\xf7\x94\xff\xff\x8b\x45\x08\x83\xf8\xfe\x75\x1b\xe8\xb3\x94\xff\xff\x83\x20\x00\xe8\x98\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\xe9\x8e\x00\x00\x00\x33\xff\x3b\xc7\x7c\x08\x3b\x05\x30\xfd\x00\x10\x72\x21\xe8\x8a\x94\xff\xff\x89\x38\xe8\x70\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x57\x57\x57\x57\x57\xe8\xf8\x93\xff\xff\x83\xc4\x14\xeb\xc9\x8b\xc8\xc1\xf9\x05\x8d\x1c\x8d\x40\xfd\x00\x10\x8b\xf0\x83\xe6\x1f\xc1\xe6\x06\x8b\x0b\x0f\xbe\x4c\x31\x04\x83\xe1\x01\x74\xbf\x50\xe8\x9b\x03\x00\x00\x59\x89\x7d\xfc\x8b\x03\xf6\x44\x30\x04\x01\x74\x0e\xff\x75\x08\xe8\xcb\xfe\xff\xff\x59\x89\x45\xe4\xeb\x0f\xe8\x15\x94\xff\xff\xc7\x00\x09\x00\x00\x00\x83\x4d\xe4\xff\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x09\x00\x00\x00\x8b\x45\xe4\xe8\x86\x94\xff\xff\xc3\xff\x75\x08\xe8\xf4\x03\x00\x00\x59\xc3\x8b\xff\x55\x8b\xec\x56\x8b\x75\x08\x8b\x46\x0c\xa8\x83\x74\x1e\xa8\x08\x74\x1a\xff\x76\x08\xe8\x15\x9c\xff\xff\x81\x66\x0c\xf7\xfb\xff\xff\x33\xc0\x59\x89\x06\x89\x46\x08\x89\x46\x04\x5e\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x10\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x56\x33\xf6\x39\x35\xb4\xed\x00\x10\x74\x4f\x83\x3d\x74\xee\x00\x10\xfe\x75\x05\xe8\xb8\x06\x00\x00\xa1\x74\xee\x00\x10\x83\xf8\xff\x75\x07\xb8\xff\xff\x00\x00\xeb\x70\x56\x8d\x4d\xf0\x51\x6a\x01\x8d\x4d\x08\x51\x50\xff\x15\x14\xb0\x00\x10\x85\xc0\x75\x67\x83\x3d\xb4\xed\x00\x10\x02\x75\xda\xff\x15\x00\xb0\x00\x10\x83\xf8\x78\x75\xcf\x89\x35\xb4\xed\x00\x10\x56\x56\x6a\x05\x8d\x45\xf4\x50\x6a\x01\x8d\x45\x08\x50\x56\xff\x15\x18\xb0\x00\x10\x50\xff\x15\xbc\xb0\x00\x10\x8b\x0d\x74\xee\x00\x10\x83\xf9\xff\x74\xa2\x56\x8d\x55\xf0\x52\x50\x8d\x45\xf4\x50\x51\xff\x15\x1c\xb0\x00\x10\x85\xc0\x74\x8d\x66\x8b\x45\x08\x8b\x4d\xfc\x33\xcd\x5e\xe8\x20\x7d\xff\xff\xc9\xc3\xc7\x05\xb4\xed\x00\x10\x01\x00\x00\x00\xeb\xe3\x8b\xff\x55\x8b\xec\x83\xec\x10\x53\x56\x8b\x75\x0c\x33\xdb\x3b\xf3\x74\x15\x39\x5d\x10\x74\x10\x38\x1e\x75\x12\x8b\x45\x08\x3b\xc3\x74\x05\x33\xc9\x66\x89\x08\x33\xc0\x5e\x5b\xc9\xc3\xff\x75\x14\x8d\x4d\xf0\xe8\x59\x84\xff\xff\x8b\x45\xf0\x39\x58\x14\x75\x1f\x8b\x45\x08\x3b\xc3\x74\x07\x66\x0f\xb6\x0e\x66\x89\x08\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x33\xc0\x40\xeb\xca\x8d\x45\xf0\x50\x0f\xb6\x06\x50\xe8\x8b\xbb\xff\xff\x59\x59\x85\xc0\x74\x7d\x8b\x45\xf0\x8b\x88\xac\x00\x00\x00\x83\xf9\x01\x7e\x25\x39\x4d\x10\x7c\x20\x33\xd2\x39\x5d\x08\x0f\x95\xc2\x52\xff\x75\x08\x51\x56\x6a\x09\xff\x70\x04\xff\x15\x3c\xb0\x00\x10\x85\xc0\x8b\x45\xf0\x75\x10\x8b\x4d\x10\x3b\x88\xac\x00\x00\x00\x72\x20\x38\x5e\x01\x74\x1b\x8b\x80\xac\x00\x00\x00\x38\x5d\xfc\x0f\x84\x65\xff\xff\xff\x8b\x4d\xf8\x83\x61\x70\xfd\xe9\x59\xff\xff\xff\xe8\x20\x92\xff\xff\xc7\x00\x2a\x00\x00\x00\x38\x5d\xfc\x74\x07\x8b\x45\xf8\x83\x60\x70\xfd\x83\xc8\xff\xe9\x3a\xff\xff\xff\x33\xc0\x39\x5d\x08\x0f\x95\xc0\x50\xff\x75\x08\x8b\x45\xf0\x6a\x01\x56\x6a\x09\xff\x70\x04\xff\x15\x3c\xb0\x00\x10\x85\xc0\x0f\x85\x3a\xff\xff\xff\xeb\xba\x8b\xff\x55\x8b\xec\x6a\x00\xff\x75\x10\xff\x75\x0c\xff\x75\x08\xe8\xd4\xfe\xff\xff\x83\xc4\x10\x5d\xc3\xcc\xcc\xcc\x51\x8d\x4c\x24\x04\x2b\xc8\x1b\xc0\xf7\xd0\x23\xc8\x8b\xc4\x25\x00\xf0\xff\xff\x3b\xc8\x72\x0a\x8b\xc1\x59\x94\x8b\x00\x89\x04\x24\xc3\x2d\x00\x10\x00\x00\x85\x00\xeb\xe9\x8b\xff\x55\x8b\xec\x8b\x4d\x08\x53\x33\xdb\x3b\xcb\x56\x57\x7c\x5b\x3b\x0d\x30\xfd\x00\x10\x73\x53\x8b\xc1\xc1\xf8\x05\x8b\xf1\x8d\x3c\x85\x40\xfd\x00\x10\x8b\x07\x83\xe6\x1f\xc1\xe6\x06\x03\xc6\xf6\x40\x04\x01\x74\x35\x83\x38\xff\x74\x30\x83\x3d\xf4\xee\x00\x10\x01\x75\x1d\x2b\xcb\x74\x10\x49\x74\x08\x49\x75\x13\x53\x6a\xf4\xeb\x08\x53\x6a\xf5\xeb\x03\x53\x6a\xf6\xff\x15\x10\xb0\x00\x10\x8b\x07\x83\x0c\x06\xff\x33\xc0\xeb\x15\xe8\x26\x91\xff\xff\xc7\x00\x09\x00\x00\x00\xe8\x2e\x91\xff\xff\x89\x18\x83\xc8\xff\x5f\x5e\x5b\x5d\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x83\xf8\xfe\x75\x18\xe8\x12\x91\xff\xff\x83\x20\x00\xe8\xf7\x90\xff\xff\xc7\x00\x09\x00\x00\x00\x83\xc8\xff\x5d\xc3\x56\x33\xf6\x3b\xc6\x7c\x22\x3b\x05\x30\xfd\x00\x10\x73\x1a\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x03\xc1\xf6\x40\x04\x01\x75\x24\xe8\xd1\x90\xff\xff\x89\x30\xe8\xb7\x90\xff\xff\x56\x56\x56\x56\x56\xc7\x00\x09\x00\x00\x00\xe8\x3f\x90\xff\xff\x83\xc4\x14\x83\xc8\xff\xeb\x02\x8b\x00\x5e\x5d\xc3\x6a\x0c\x68\xf8\xc8\x00\x10\xe8\xd8\x90\xff\xff\x8b\x7d\x08\x8b\xc7\xc1\xf8\x05\x8b\xf7\x83\xe6\x1f\xc1\xe6\x06\x03\x34\x85\x40\xfd\x00\x10\xc7\x45\xe4\x01\x00\x00\x00\x33\xdb\x39\x5e\x08\x75\x36\x6a\x0a\xe8\xf1\xaa\xff\xff\x59\x89\x5d\xfc\x39\x5e\x08\x75\x1a\x68\xa0\x0f\x00\x00\x8d\x46\x0c\x50\xe8\x17\xd2\xff\xff\x59\x59\x85\xc0\x75\x03\x89\x5d\xe4\xff\x46\x08\xc7\x45\xfc\xfe\xff\xff\xff\xe8\x30\x00\x00\x00\x39\x5d\xe4\x74\x1d\x8b\xc7\xc1\xf8\x05\x83\xe7\x1f\xc1\xe7\x06\x8b\x04\x85\x40\xfd\x00\x10\x8d\x44\x38\x0c\x50\xff\x15\x64\xb0\x00\x10\x8b\x45\xe4\xe8\x98\x90\xff\xff\xc3\x33\xdb\x8b\x7d\x08\x6a\x0a\xe8\xb1\xa9\xff\xff\x59\xc3\x8b\xff\x55\x8b\xec\x8b\x45\x08\x8b\xc8\x83\xe0\x1f\xc1\xf9\x05\x8b\x0c\x8d\x40\xfd\x00\x10\xc1\xe0\x06\x8d\x44\x01\x0c\x50\xff\x15\x68\xb0\x00\x10\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x0c\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x6a\x06\x8d\x45\xf4\x50\x68\x04\x10\x00\x00\xff\x75\x08\xc6\x45\xfa\x00\xff\x15\x2c\xb0\x00\x10\x85\xc0\x75\x05\x83\xc8\xff\xeb\x0a\x8d\x45\xf4\x50\xe8\xf1\x01\x00\x00\x59\x8b\x4d\xfc\x33\xcd\xe8\xa8\x79\xff\xff\xc9\xc3\x8b\xff\x55\x8b\xec\x83\xec\x34\xa1\x00\xe0\x00\x10\x33\xc5\x89\x45\xfc\x8b\x45\x10\x8b\x4d\x18\x89\x45\xd8\x8b\x45\x14\x53\x89\x45\xd0\x8b\x00\x56\x89\x45\xdc\x8b\x45\x08\x57\x33\xff\x89\x4d\xcc\x89\x7d\xe0\x89\x7d\xd4\x3b\x45\x0c\x0f\x84\x5f\x01\x00\x00\x8b\x35\xe0\xb0\x00\x10\x8d\x4d\xe8\x51\x50\xff\xd6\x8b\x1d\x3c\xb0\x00\x10\x85\xc0\x74\x5e\x83\x7d\xe8\x01\x75\x58\x8d\x45\xe8\x50\xff\x75\x0c\xff\xd6\x85\xc0\x74\x4b\x83\x7d\xe8\x01\x75\x45\x8b\x75\xdc\xc7\x45\xd4\x01\x00\x00\x00\x83\xfe\xff\x75\x0c\xff\x75\xd8\xe8\xf1\xb5\xff\xff\x8b\xf0\x59\x46\x3b\xf7\x7e\x5b\x81\xfe\xf0\xff\xff\x7f\x77\x53\x8d\x44\x36\x08\x3d\x00\x04\x00\x00\x77\x2f\xe8\x11\x01\x00\x00\x8b\xc4\x3b\xc7\x74\x38\xc7\x00\xcc\xcc\x00\x00\xeb\x2d\x57\x57\xff\x75\xdc\xff\x75\xd8\x6a\x01\xff\x75\x08\xff\xd3\x8b\xf0\x3b\xf7\x75\xc3\x33\xc0\xe9\xd1\x00\x00\x00\x50\xe8\xd1\xc6\xff\xff\x59\x3b\xc7\x74\x09\xc7\x00\xdd\xdd\x00\x00\x83\xc0\x08\x89\x45\xe4\xeb\x03\x89\x7d\xe4\x39\x7d\xe4\x74\xd8\x8d\x04\x36\x50\x57\xff\x75\xe4\xe8\x79\xb8\xff\xff\x83\xc4\x0c\x56\xff\x75\xe4\xff\x75\xdc\xff\x75\xd8\x6a\x01\xff\x75\x08\xff\xd3\x85\xc0\x74\x7f\x8b\x5d\xcc\x3b\xdf\x74\x1d\x57\x57\xff\x75\x1c\x53\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\x15\xbc\xb0\x00\x10\x85\xc0\x74\x60\x89\x5d\xe0\xeb\x5b\x8b\x1d\xbc\xb0\x00\x10\x39\x7d\xd4\x75\x14\x57\x57\x57\x57\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\xd3\x8b\xf0\x3b\xf7\x74\x3c\x56\x6a\x01\xe8\x40\x97\xff\xff\x59\x59\x89\x45\xe0\x3b\xc7\x74\x2b\x57\x57\x56\x50\x56\xff\x75\xe4\x57\xff\x75\x0c\xff\xd3\x3b\xc7\x75\x0e\xff\x75\xe0\xe8\x4a\x96\xff\xff\x59\x89\x7d\xe0\xeb\x0b\x83\x7d\xdc\xff\x74\x05\x8b\x4d\xd0\x89\x01\xff\x75\xe4\xe8\x72\xde\xff\xff\x59\x8b\x45\xe0\x8d\x65\xc0\x5f\x5e\x5b\x8b\x4d\xfc\x33\xcd\xe8\xf4\x77\xff\xff\xc9\xc3\xcc\xcc\xcc\xcc\x51\x8d\x4c\x24\x08\x2b\xc8\x83\xe1\x0f\x03\xc1\x1b\xc9\x0b\xc1\x59\xe9\xfa\xfb\xff\xff\x51\x8d\x4c\x24\x08\x2b\xc8\x83\xe1\x07\x03\xc1\x1b\xc9\x0b\xc1\x59\xe9\xe4\xfb\xff\xff\x8b\xff\x55\x8b\xec\x6a\x0a\x6a\x00\xff\x75\x08\xe8\xd1\xef\xff\xff\x83\xc4\x0c\x5d\xc3\x8b\xff\x55\x8b\xec\x83\xec\x18\x53\xff\x75\x10\x8d\x4d\xe8\xe8\x18\x7f\xff\xff\x8b\x5d\x08\x8d\x43\x01\x3d\x00\x01\x00\x00\x77\x0f\x8b\x45\xe8\x8b\x80\xc8\x00\x00\x00\x0f\xb7\x04\x58\xeb\x75\x89\x5d\x08\xc1\x7d\x08\x08\x8d\x45\xe8\x50\x8b\x45\x08\x25\xff\x00\x00\x00\x50\xe8\x49\xb6\xff\xff\x59\x59\x85\xc0\x74\x12\x8a\x45\x08\x6a\x02\x88\x45\xf8\x88\x5d\xf9\xc6\x45\xfa\x00\x59\xeb\x0a\x33\xc9\x88\x5d\xf8\xc6\x45\xf9\x00\x41\x8b\x45\xe8\x6a\x01\xff\x70\x14\xff\x70\x04\x8d\x45\xfc\x50\x51\x8d\x45\xf8\x50\x8d\x45\xe8\x6a\x01\x50\xe8\x50\xe3\xff\xff\x83\xc4\x20\x85\xc0\x75\x10\x38\x45\xf4\x74\x07\x8b\x45\xf0\x83\x60\x70\xfd\x33\xc0\xeb\x14\x0f\xb7\x45\xfc\x23\x45\x0c\x80\x7d\xf4\x00\x74\x07\x8b\x4d\xf0\x83\x61\x70\xfd\x5b\xc9\xc3\x33\xc0\x50\x50\x6a\x03\x50\x6a\x03\x68\x00\x00\x00\x40\x68\xdc\xc3\x00\x10\xff\x15\x0c\xb0\x00\x10\xa3\x74\xee\x00\x10\xc3\xa1\x74\xee\x00\x10\x56\x8b\x35\x20\xb0\x00\x10\x83\xf8\xff\x74\x08\x83\xf8\xfe\x74\x03\x50\xff\xd6\xa1\x70\xee\x00\x10\x83\xf8\xff\x74\x08\x83\xf8\xfe\x74\x03\x50\xff\xd6\x5e\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x55\x8b\xec\x57\x56\x53\x8b\x4d\x10\x0b\xc9\x74\x4d\x8b\x75\x08\x8b\x7d\x0c\xb7\x41\xb3\x5a\xb6\x20\x8d\x49\x00\x8a\x26\x0a\xe4\x8a\x07\x74\x27\x0a\xc0\x74\x23\x83\xc6\x01\x83\xc7\x01\x3a\xe7\x72\x06\x3a\xe3\x77\x02\x02\xe6\x3a\xc7\x72\x06\x3a\xc3\x77\x02\x02\xc6\x3a\xe0\x75\x0b\x83\xe9\x01\x75\xd1\x33\xc9\x3a\xe0\x74\x09\xb9\xff\xff\xff\xff\x72\x02\xf7\xd9\x8b\xc1\x5b\x5e\x5f\xc9\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8b\x44\x24\x08\x8b\x4c\x24\x10\x0b\xc8\x8b\x4c\x24\x0c\x75\x09\x8b\x44\x24\x04\xf7\xe1\xc2\x10\x00\x53\xf7\xe1\x8b\xd8\x8b\x44\x24\x08\xf7\x64\x24\x14\x03\xd8\x8b\x44\x24\x08\xf7\xe1\x03\xd3\x5b\xc2\x10\x00\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\x8d\x42\xff\x5b\xc3\x8d\xa4\x24\x00\x00\x00\x00\x8d\x64\x24\x00\x33\xc0\x8a\x44\x24\x08\x53\x8b\xd8\xc1\xe0\x08\x8b\x54\x24\x08\xf7\xc2\x03\x00\x00\x00\x74\x15\x8a\x0a\x83\xc2\x01\x3a\xcb\x74\xcf\x84\xc9\x74\x51\xf7\xc2\x03\x00\x00\x00\x75\xeb\x0b\xd8\x57\x8b\xc3\xc1\xe3\x10\x56\x0b\xd8\x8b\x0a\xbf\xff\xfe\xfe\x7e\x8b\xc1\x8b\xf7\x33\xcb\x03\xf0\x03\xf9\x83\xf1\xff\x83\xf0\xff\x33\xcf\x33\xc6\x83\xc2\x04\x81\xe1\x00\x01\x01\x81\x75\x1c\x25\x00\x01\x01\x81\x74\xd3\x25\x00\x01\x01\x01\x75\x08\x81\xe6\x00\x00\x00\x80\x75\xc4\x5e\x5f\x5b\x33\xc0\xc3\x8b\x42\xfc\x3a\xc3\x74\x36\x84\xc0\x74\xef\x3a\xe3\x74\x27\x84\xe4\x74\xe7\xc1\xe8\x10\x3a\xc3\x74\x15\x84\xc0\x74\xdc\x3a\xe3\x74\x06\x84\xe4\x74\xd4\xeb\x96\x5e\x5f\x8d\x42\xff\x5b\xc3\x8d\x42\xfe\x5e\x5f\x5b\xc3\x8d\x42\xfd\x5e\x5f\x5b\xc3\x8d\x42\xfc\x5e\x5f\x5b\xc3\xff\x25\xf0\xb0\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xca\x00\x00\xec\xca\x00\x00\xfe\xca\x00\x00\x5e\xd1\x00\x00\x4e\xd1\x00\x00\x3e\xd1\x00\x00\x28\xd1\x00\x00\x18\xd1\x00\x00\x0a\xd1\x00\x00\xfe\xd0\x00\x00\xec\xd0\x00\x00\xda\xd0\x00\x00\xc8\xd0\x00\x00\xb6\xd0\x00\x00\xa6\xd0\x00\x00\x90\xd0\x00\x00\x80\xd0\x00\x00\x6c\xd0\x00\x00\xb8\xcc\x00\x00\xce\xcc\x00\x00\xe0\xcc\x00\x00\xf4\xcc\x00\x00\x08\xcd\x00\x00\x24\xcd\x00\x00\x42\xcd\x00\x00\x56\xcd\x00\x00\x6e\xcd\x00\x00\x86\xcd\x00\x00\x98\xcd\x00\x00\xa6\xcd\x00\x00\xb2\xcd\x00\x00\xc0\xcd\x00\x00\xca\xcd\x00\x00\xe2\xcd\x00\x00\xf2\xcd\x00\x00\x0a\xce\x00\x00\x16\xce\x00\x00\x1e\xce\x00\x00\x2c\xce\x00\x00\x3e\xce\x00\x00\x4e\xce\x00\x00\x5c\xce\x00\x00\x6e\xce\x00\x00\x86\xce\x00\x00\x9c\xce\x00\x00\xb6\xce\x00\x00\xce\xce\x00\x00\xe8\xce\x00\x00\xfe\xce\x00\x00\x18\xcf\x00\x00\x26\xcf\x00\x00\x34\xcf\x00\x00\x42\xcf\x00\x00\x5c\xcf\x00\x00\x6c\xcf\x00\x00\x82\xcf\x00\x00\x9c\xcf\x00\x00\xa8\xcf\x00\x00\xb2\xcf\x00\x00\xbe\xcf\x00\x00\xd0\xcf\x00\x00\xdc\xcf\x00\x00\xe8\xcf\x00\x00\xf8\xcf\x00\x00\x06\xd0\x00\x00\x12\xd0\x00\x00\x22\xd0\x00\x00\x4a\xd0\x00\x00\x5a\xd0\x00\x00\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00\x00\x00\x7a\xcc\x00\x00\x66\xcc\x00\x00\x52\xcc\x00\x00\x44\xcc\x00\x00\x30\xcc\x00\x00\x1c\xcc\x00\x00\x0e\xcc\x00\x00\x00\xcc\x00\x00\xee\xcb\x00\x00\xd0\xcb\x00\x00\xbe\xcb\x00\x00\xaa\xcb\x00\x00\x9c\xcb\x00\x00\x90\xcb\x00\x00\x7e\xcb\x00\x00\x6c\xcb\x00\x00\x58\xcb\x00\x00\x46\xcb\x00\x00\x30\xcb\x00\x00\x20\xcb\x00\x00\xde\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x1a\x00\x10\x7f\x4d\x00\x10\x21\x6a\x00\x10\x28\x8a\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x9e\x00\x10\x30\x1b\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x78\xee\x54\x00\x00\x00\x00\x02\x00\x00\x00\x8e\x00\x00\x00\xa8\xc4\x00\x00\xa8\xaa\x00\x00\x00\x00\x00\x00\xf8\xee\x00\x10\x50\xef\x00\x10\x28\x00\x6e\x00\x75\x00\x6c\x00\x6c\x00\x29\x00\x00\x00\x00\x00\x28\x6e\x75\x6c\x6c\x29\x00\x00\x06\x00\x00\x06\x00\x01\x00\x00\x10\x00\x03\x06\x00\x06\x02\x10\x04\x45\x45\x45\x05\x05\x05\x05\x05\x35\x30\x00\x50\x00\x00\x00\x00\x28\x20\x38\x50\x58\x07\x08\x00\x37\x30\x30\x57\x50\x07\x00\x00\x20\x20\x08\x00\x00\x00\x00\x08\x60\x68\x60\x60\x60\x60\x00\x00\x78\x70\x78\x78\x78\x78\x08\x07\x08\x00\x00\x07\x00\x08\x08\x08\x00\x00\x08\x00\x08\x00\x07\x08\x00\x00\x00\x45\x6e\x63\x6f\x64\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\x00\x4b\x00\x45\x00\x52\x00\x4e\x00\x45\x00\x4c\x00\x33\x00\x32\x00\x2e\x00\x44\x00\x4c\x00\x4c\x00\x00\x00\x00\x00\x44\x65\x63\x6f\x64\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\x00\x46\x6c\x73\x46\x72\x65\x65\x00\x46\x6c\x73\x53\x65\x74\x56\x61\x6c\x75\x65\x00\x46\x6c\x73\x47\x65\x74\x56\x61\x6c\x75\x65\x00\x46\x6c\x73\x41\x6c\x6c\x6f\x63\x00\x00\x00\x00\x43\x6f\x72\x45\x78\x69\x74\x50\x72\x6f\x63\x65\x73\x73\x00\x00\x6d\x00\x73\x00\x63\x00\x6f\x00\x72\x00\x65\x00\x65\x00\x2e\x00\x64\x00\x6c\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\xc0\x0b\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\xc0\x04\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\xc0\x04\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\xc0\x08\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x00\x06\x80\x80\x86\x80\x81\x80\x00\x00\x10\x03\x86\x80\x86\x82\x80\x14\x05\x05\x45\x45\x45\x85\x85\x85\x05\x00\x00\x30\x30\x80\x50\x80\x88\x00\x08\x00\x28\x27\x38\x50\x57\x80\x00\x07\x00\x37\x30\x30\x50\x50\x88\x00\x00\x00\x20\x28\x80\x88\x80\x80\x00\x00\x00\x60\x68\x60\x68\x68\x68\x08\x08\x07\x78\x70\x70\x77\x70\x70\x08\x08\x00\x00\x08\x00\x08\x00\x07\x08\x00\x00\x00\x72\x75\x6e\x74\x69\x6d\x65\x20\x65\x72\x72\x6f\x72\x20\x00\x00\x0d\x0a\x00\x00\x54\x4c\x4f\x53\x53\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x53\x49\x4e\x47\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x44\x4f\x4d\x41\x49\x4e\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x52\x36\x30\x33\x34\x0d\x0a\x41\x6e\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x20\x68\x61\x73\x20\x6d\x61\x64\x65\x20\x61\x6e\x20\x61\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x6c\x6f\x61\x64\x20\x74\x68\x65\x20\x43\x20\x72\x75\x6e\x74\x69\x6d\x65\x20\x6c\x69\x62\x72\x61\x72\x79\x20\x69\x6e\x63\x6f\x72\x72\x65\x63\x74\x6c\x79\x2e\x0a\x50\x6c\x65\x61\x73\x65\x20\x63\x6f\x6e\x74\x61\x63\x74\x20\x74\x68\x65\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x27\x73\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x74\x65\x61\x6d\x20\x66\x6f\x72\x20\x6d\x6f\x72\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x00\x00\x00\x00\x52\x36\x30\x33\x33\x0d\x0a\x2d\x20\x41\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x75\x73\x65\x20\x4d\x53\x49\x4c\x20\x63\x6f\x64\x65\x20\x66\x72\x6f\x6d\x20\x74\x68\x69\x73\x20\x61\x73\x73\x65\x6d\x62\x6c\x79\x20\x64\x75\x72\x69\x6e\x67\x20\x6e\x61\x74\x69\x76\x65\x20\x63\x6f\x64\x65\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0a\x54\x68\x69\x73\x20\x69\x6e\x64\x69\x63\x61\x74\x65\x73\x20\x61\x20\x62\x75\x67\x20\x69\x6e\x20\x79\x6f\x75\x72\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x2e\x20\x49\x74\x20\x69\x73\x20\x6d\x6f\x73\x74\x20\x6c\x69\x6b\x65\x6c\x79\x20\x74\x68\x65\x20\x72\x65\x73\x75\x6c\x74\x20\x6f\x66\x20\x63\x61\x6c\x6c\x69\x6e\x67\x20\x61\x6e\x20\x4d\x53\x49\x4c\x2d\x63\x6f\x6d\x70\x69\x6c\x65\x64\x20\x28\x2f\x63\x6c\x72\x29\x20\x66\x75\x6e\x63\x74\x69\x6f\x6e\x20\x66\x72\x6f\x6d\x20\x61\x20\x6e\x61\x74\x69\x76\x65\x20\x63\x6f\x6e\x73\x74\x72\x75\x63\x74\x6f\x72\x20\x6f\x72\x20\x66\x72\x6f\x6d\x20\x44\x6c\x6c\x4d\x61\x69\x6e\x2e\x0d\x0a\x00\x00\x52\x36\x30\x33\x32\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x6c\x6f\x63\x61\x6c\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x00\x00\x52\x36\x30\x33\x31\x0d\x0a\x2d\x20\x41\x74\x74\x65\x6d\x70\x74\x20\x74\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x20\x74\x68\x65\x20\x43\x52\x54\x20\x6d\x6f\x72\x65\x20\x74\x68\x61\x6e\x20\x6f\x6e\x63\x65\x2e\x0a\x54\x68\x69\x73\x20\x69\x6e\x64\x69\x63\x61\x74\x65\x73\x20\x61\x20\x62\x75\x67\x20\x69\x6e\x20\x79\x6f\x75\x72\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x52\x36\x30\x33\x30\x0d\x0a\x2d\x20\x43\x52\x54\x20\x6e\x6f\x74\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x64\x0d\x0a\x00\x00\x52\x36\x30\x32\x38\x0d\x0a\x2d\x20\x75\x6e\x61\x62\x6c\x65\x20\x74\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x20\x68\x65\x61\x70\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x37\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x6c\x6f\x77\x69\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x36\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x73\x74\x64\x69\x6f\x20\x69\x6e\x69\x74\x69\x61\x6c\x69\x7a\x61\x74\x69\x6f\x6e\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x32\x35\x0d\x0a\x2d\x20\x70\x75\x72\x65\x20\x76\x69\x72\x74\x75\x61\x6c\x20\x66\x75\x6e\x63\x74\x69\x6f\x6e\x20\x63\x61\x6c\x6c\x0d\x0a\x00\x00\x00\x52\x36\x30\x32\x34\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x5f\x6f\x6e\x65\x78\x69\x74\x2f\x61\x74\x65\x78\x69\x74\x20\x74\x61\x62\x6c\x65\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x39\x0d\x0a\x2d\x20\x75\x6e\x61\x62\x6c\x65\x20\x74\x6f\x20\x6f\x70\x65\x6e\x20\x63\x6f\x6e\x73\x6f\x6c\x65\x20\x64\x65\x76\x69\x63\x65\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x38\x0d\x0a\x2d\x20\x75\x6e\x65\x78\x70\x65\x63\x74\x65\x64\x20\x68\x65\x61\x70\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x37\x0d\x0a\x2d\x20\x75\x6e\x65\x78\x70\x65\x63\x74\x65\x64\x20\x6d\x75\x6c\x74\x69\x74\x68\x72\x65\x61\x64\x20\x6c\x6f\x63\x6b\x20\x65\x72\x72\x6f\x72\x0d\x0a\x00\x00\x00\x00\x52\x36\x30\x31\x36\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x74\x68\x72\x65\x61\x64\x20\x64\x61\x74\x61\x0d\x0a\x00\x0d\x0a\x54\x68\x69\x73\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x20\x68\x61\x73\x20\x72\x65\x71\x75\x65\x73\x74\x65\x64\x20\x74\x68\x65\x20\x52\x75\x6e\x74\x69\x6d\x65\x20\x74\x6f\x20\x74\x65\x72\x6d\x69\x6e\x61\x74\x65\x20\x69\x74\x20\x69\x6e\x20\x61\x6e\x20\x75\x6e\x75\x73\x75\x61\x6c\x20\x77\x61\x79\x2e\x0a\x50\x6c\x65\x61\x73\x65\x20\x63\x6f\x6e\x74\x61\x63\x74\x20\x74\x68\x65\x20\x61\x70\x70\x6c\x69\x63\x61\x74\x69\x6f\x6e\x27\x73\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x74\x65\x61\x6d\x20\x66\x6f\x72\x20\x6d\x6f\x72\x65\x20\x69\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x2e\x0d\x0a\x00\x00\x00\x52\x36\x30\x30\x39\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x65\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x0d\x0a\x00\x52\x36\x30\x30\x38\x0d\x0a\x2d\x20\x6e\x6f\x74\x20\x65\x6e\x6f\x75\x67\x68\x20\x73\x70\x61\x63\x65\x20\x66\x6f\x72\x20\x61\x72\x67\x75\x6d\x65\x6e\x74\x73\x0d\x0a\x00\x00\x00\x52\x36\x30\x30\x32\x0d\x0a\x2d\x20\x66\x6c\x6f\x61\x74\x69\x6e\x67\x20\x70\x6f\x69\x6e\x74\x20\x73\x75\x70\x70\x6f\x72\x74\x20\x6e\x6f\x74\x20\x6c\x6f\x61\x64\x65\x64\x0d\x0a\x00\x00\x00\x00\x4d\x69\x63\x72\x6f\x73\x6f\x66\x74\x20\x56\x69\x73\x75\x61\x6c\x20\x43\x2b\x2b\x20\x52\x75\x6e\x74\x69\x6d\x65\x20\x4c\x69\x62\x72\x61\x72\x79\x00\x00\x00\x00\x0a\x0a\x00\x00\x2e\x2e\x2e\x00\x3c\x70\x72\x6f\x67\x72\x61\x6d\x20\x6e\x61\x6d\x65\x20\x75\x6e\x6b\x6e\x6f\x77\x6e\x3e\x00\x00\x52\x75\x6e\x74\x69\x6d\x65\x20\x45\x72\x72\x6f\x72\x21\x0a\x0a\x50\x72\x6f\x67\x72\x61\x6d\x3a\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x81\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x82\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x02\x00\x10\x00\x10\x00\x10\x00\x10\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x68\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x82\x01\x82\x01\x82\x01\x82\x01\x82\x01\x82\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x10\x00\x10\x00\x10\x00\x10\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x20\x00\x48\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x14\x00\x14\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x14\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x10\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x10\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x10\x00\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x01\x01\x00\x00\x00\x00\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff\x48\x48\x3a\x6d\x6d\x3a\x73\x73\x00\x00\x00\x00\x64\x64\x64\x64\x2c\x20\x4d\x4d\x4d\x4d\x20\x64\x64\x2c\x20\x79\x79\x79\x79\x00\x4d\x4d\x2f\x64\x64\x2f\x79\x79\x00\x00\x00\x00\x50\x4d\x00\x00\x41\x4d\x00\x00\x44\x65\x63\x65\x6d\x62\x65\x72\x00\x00\x00\x00\x4e\x6f\x76\x65\x6d\x62\x65\x72\x00\x00\x00\x00\x4f\x63\x74\x6f\x62\x65\x72\x00\x53\x65\x70\x74\x65\x6d\x62\x65\x72\x00\x00\x00\x41\x75\x67\x75\x73\x74\x00\x00\x4a\x75\x6c\x79\x00\x00\x00\x00\x4a\x75\x6e\x65\x00\x00\x00\x00\x41\x70\x72\x69\x6c\x00\x00\x00\x4d\x61\x72\x63\x68\x00\x00\x00\x46\x65\x62\x72\x75\x61\x72\x79\x00\x00\x00\x00\x4a\x61\x6e\x75\x61\x72\x79\x00\x44\x65\x63\x00\x4e\x6f\x76\x00\x4f\x63\x74\x00\x53\x65\x70\x00\x41\x75\x67\x00\x4a\x75\x6c\x00\x4a\x75\x6e\x00\x4d\x61\x79\x00\x41\x70\x72\x00\x4d\x61\x72\x00\x46\x65\x62\x00\x4a\x61\x6e\x00\x53\x61\x74\x75\x72\x64\x61\x79\x00\x00\x00\x00\x46\x72\x69\x64\x61\x79\x00\x00\x54\x68\x75\x72\x73\x64\x61\x79\x00\x00\x00\x00\x57\x65\x64\x6e\x65\x73\x64\x61\x79\x00\x00\x00\x54\x75\x65\x73\x64\x61\x79\x00\x4d\x6f\x6e\x64\x61\x79\x00\x00\x53\x75\x6e\x64\x61\x79\x00\x00\x53\x61\x74\x00\x46\x72\x69\x00\x54\x68\x75\x00\x57\x65\x64\x00\x54\x75\x65\x00\x4d\x6f\x6e\x00\x53\x75\x6e\x00\x47\x65\x74\x50\x72\x6f\x63\x65\x73\x73\x57\x69\x6e\x64\x6f\x77\x53\x74\x61\x74\x69\x6f\x6e\x00\x47\x65\x74\x55\x73\x65\x72\x4f\x62\x6a\x65\x63\x74\x49\x6e\x66\x6f\x72\x6d\x61\x74\x69\x6f\x6e\x41\x00\x00\x00\x47\x65\x74\x4c\x61\x73\x74\x41\x63\x74\x69\x76\x65\x50\x6f\x70\x75\x70\x00\x00\x47\x65\x74\x41\x63\x74\x69\x76\x65\x57\x69\x6e\x64\x6f\x77\x00\x4d\x65\x73\x73\x61\x67\x65\x42\x6f\x78\x41\x00\x55\x53\x45\x52\x33\x32\x2e\x44\x4c\x4c\x00\x00\x53\x75\x6e\x4d\x6f\x6e\x54\x75\x65\x57\x65\x64\x54\x68\x75\x46\x72\x69\x53\x61\x74\x00\x00\x00\x4a\x61\x6e\x46\x65\x62\x4d\x61\x72\x41\x70\x72\x4d\x61\x79\x4a\x75\x6e\x4a\x75\x6c\x41\x75\x67\x53\x65\x70\x4f\x63\x74\x4e\x6f\x76\x44\x65\x63\x00\x00\x00\x00\x43\x4f\x4e\x4f\x55\x54\x24\x00\x53\x79\x73\x74\x72\x61\x79\x20\x65\x72\x72\x6f\x72\x20\x25\x73\x3a\x20\x25\x64\x20\x25\x73\x0a\x00\x00\x00\x00\x67\x65\x74\x20\x74\x72\x61\x79\x20\x6d\x65\x6e\x75\x20\x70\x6f\x73\x69\x74\x69\x6f\x6e\x00\x00\x67\x65\x74\x20\x6d\x65\x6e\x75\x20\x69\x74\x65\x6d\x20\x69\x64\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x79\x00\x73\x00\x74\x00\x72\x00\x61\x00\x79\x00\x43\x00\x6c\x00\x61\x00\x73\x00\x73\x00\x00\x00\x00\x00\x6c\x6f\x61\x64\x20\x69\x63\x6f\x6e\x20\x69\x6d\x61\x67\x65\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\x10\x40\xc5\x00\x10\x03\x00\x00\x00\x52\x53\x44\x53\xc0\xc4\x5d\xda\x8c\xd7\xbd\x49\x91\x72\x7a\x0f\xa2\xd6\x7e\x76\x01\x00\x00\x00\x5c\x5c\x56\x42\x4f\x58\x53\x56\x52\x5c\x76\x61\x67\x72\x61\x6e\x74\x5c\x77\x6f\x72\x6b\x73\x70\x61\x63\x65\x5c\x67\x65\x74\x6c\x61\x6e\x74\x65\x72\x6e\x5c\x66\x6c\x61\x73\x68\x6c\x69\x67\x68\x74\x2d\x62\x75\x69\x6c\x64\x5c\x73\x72\x63\x5c\x67\x69\x74\x68\x75\x62\x2e\x63\x6f\x6d\x5c\x67\x65\x74\x6c\x61\x6e\x74\x65\x72\x6e\x5c\x73\x79\x73\x74\x72\x61\x79\x5c\x73\x79\x73\x74\x72\x61\x79\x5c\x52\x65\x6c\x65\x61\x73\x65\x5c\x73\x79\x73\x74\x72\x61\x79\x2e\x70\x64\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x2c\x00\x00\x5c\x56\x00\x00\x58\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x29\x16\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x2d\x19\x00\x10\x3e\x19\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd2\x2f\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xe1\x2f\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x94\x31\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xa0\x31\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xfd\x33\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x9c\x37\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x8c\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x64\x3a\x00\x10\x68\x3a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd9\x42\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x63\x44\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x44\x00\x10\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xe8\x45\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x78\x49\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x46\x4d\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xb6\x50\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x3b\x58\x00\x10\x4f\x58\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x77\x63\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x41\x65\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xa6\x66\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x88\x6a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd8\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\xc5\x6a\x00\x10\xc9\x6a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xbf\x6c\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x4f\x6d\x00\x10\x66\x6d\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xed\x72\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xfd\x7a\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xde\x7b\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x34\x88\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x93\x89\x00\x10\xaf\x89\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xc7\x91\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd0\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x6c\x97\x00\x10\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\xd4\xff\xff\xff\x00\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x5a\x9b\x00\x10\x64\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\xcb\x00\x00\x00\xb0\x00\x00\x84\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xcc\x00\x00\x20\xb1\x00\x00\x7c\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xcc\x00\x00\x18\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xca\x00\x00\xec\xca\x00\x00\xfe\xca\x00\x00\x5e\xd1\x00\x00\x4e\xd1\x00\x00\x3e\xd1\x00\x00\x28\xd1\x00\x00\x18\xd1\x00\x00\x0a\xd1\x00\x00\xfe\xd0\x00\x00\xec\xd0\x00\x00\xda\xd0\x00\x00\xc8\xd0\x00\x00\xb6\xd0\x00\x00\xa6\xd0\x00\x00\x90\xd0\x00\x00\x80\xd0\x00\x00\x6c\xd0\x00\x00\xb8\xcc\x00\x00\xce\xcc\x00\x00\xe0\xcc\x00\x00\xf4\xcc\x00\x00\x08\xcd\x00\x00\x24\xcd\x00\x00\x42\xcd\x00\x00\x56\xcd\x00\x00\x6e\xcd\x00\x00\x86\xcd\x00\x00\x98\xcd\x00\x00\xa6\xcd\x00\x00\xb2\xcd\x00\x00\xc0\xcd\x00\x00\xca\xcd\x00\x00\xe2\xcd\x00\x00\xf2\xcd\x00\x00\x0a\xce\x00\x00\x16\xce\x00\x00\x1e\xce\x00\x00\x2c\xce\x00\x00\x3e\xce\x00\x00\x4e\xce\x00\x00\x5c\xce\x00\x00\x6e\xce\x00\x00\x86\xce\x00\x00\x9c\xce\x00\x00\xb6\xce\x00\x00\xce\xce\x00\x00\xe8\xce\x00\x00\xfe\xce\x00\x00\x18\xcf\x00\x00\x26\xcf\x00\x00\x34\xcf\x00\x00\x42\xcf\x00\x00\x5c\xcf\x00\x00\x6c\xcf\x00\x00\x82\xcf\x00\x00\x9c\xcf\x00\x00\xa8\xcf\x00\x00\xb2\xcf\x00\x00\xbe\xcf\x00\x00\xd0\xcf\x00\x00\xdc\xcf\x00\x00\xe8\xcf\x00\x00\xf8\xcf\x00\x00\x06\xd0\x00\x00\x12\xd0\x00\x00\x22\xd0\x00\x00\x4a\xd0\x00\x00\x5a\xd0\x00\x00\x00\x00\x00\x00\x98\xcc\x00\x00\x00\x00\x00\x00\x7a\xcc\x00\x00\x66\xcc\x00\x00\x52\xcc\x00\x00\x44\xcc\x00\x00\x30\xcc\x00\x00\x1c\xcc\x00\x00\x0e\xcc\x00\x00\x00\xcc\x00\x00\xee\xcb\x00\x00\xd0\xcb\x00\x00\xbe\xcb\x00\x00\xaa\xcb\x00\x00\x9c\xcb\x00\x00\x90\xcb\x00\x00\x7e\xcb\x00\x00\x6c\xcb\x00\x00\x58\xcb\x00\x00\x46\xcb\x00\x00\x30\xcb\x00\x00\x20\xcb\x00\x00\xde\xcb\x00\x00\x00\x00\x00\x00\xe6\x01\x47\x65\x74\x4c\x61\x73\x74\x45\x72\x72\x6f\x72\x00\x00\x48\x01\x46\x6f\x72\x6d\x61\x74\x4d\x65\x73\x73\x61\x67\x65\x57\x00\x00\xf9\x01\x47\x65\x74\x4d\x6f\x64\x75\x6c\x65\x48\x61\x6e\x64\x6c\x65\x57\x00\x00\x4b\x45\x52\x4e\x45\x4c\x33\x32\x2e\x64\x6c\x6c\x00\x00\x19\x01\x47\x65\x74\x43\x75\x72\x73\x6f\x72\x50\x6f\x73\x00\x00\x7a\x02\x53\x65\x74\x46\x6f\x72\x65\x67\x72\x6f\x75\x6e\x64\x57\x69\x6e\x64\x6f\x77\x00\xcf\x02\x54\x72\x61\x63\x6b\x50\x6f\x70\x75\x70\x4d\x65\x6e\x75\x00\x00\x45\x01\x47\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x49\x6e\x66\x6f\x57\x00\x00\x20\x02\x50\x6f\x73\x74\x51\x75\x69\x74\x4d\x65\x73\x73\x61\x67\x65\x00\x96\x00\x44\x65\x66\x57\x69\x6e\x64\x6f\x77\x50\x72\x6f\x63\x57\x00\x00\xd7\x01\x4c\x6f\x61\x64\x49\x63\x6f\x6e\x57\x00\xd5\x01\x4c\x6f\x61\x64\x43\x75\x72\x73\x6f\x72\x57\x00\x35\x02\x52\x65\x67\x69\x73\x74\x65\x72\x43\x6c\x61\x73\x73\x45\x78\x57\x00\x00\x68\x00\x43\x72\x65\x61\x74\x65\x57\x69\x6e\x64\x6f\x77\x45\x78\x57\x00\xb8\x02\x53\x68\x6f\x77\x57\x69\x6e\x64\x6f\x77\x00\x00\xe9\x02\x55\x70\x64\x61\x74\x65\x57\x69\x6e\x64\x6f\x77\x00\x00\x65\x00\x43\x72\x65\x61\x74\x65\x50\x6f\x70\x75\x70\x4d\x65\x6e\x75\x00\x82\x02\x53\x65\x74\x4d\x65\x6e\x75\x49\x6e\x66\x6f\x00\x4e\x01\x47\x65\x74\x4d\x65\x73\x73\x61\x67\x65\x57\x00\xd5\x02\x54\x72\x61\x6e\x73\x6c\x61\x74\x65\x4d\x65\x73\x73\x61\x67\x65\x00\x00\xa9\x00\x44\x69\x73\x70\x61\x74\x63\x68\x4d\x65\x73\x73\x61\x67\x65\x57\x00\x00\xd9\x01\x4c\x6f\x61\x64\x49\x6d\x61\x67\x65\x57\x00\x00\x42\x01\x47\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x43\x6f\x75\x6e\x74\x00\x00\x85\x02\x53\x65\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x49\x6e\x66\x6f\x57\x00\x00\xa5\x01\x49\x6e\x73\x65\x72\x74\x4d\x65\x6e\x75\x49\x74\x65\x6d\x57\x00\x55\x53\x45\x52\x33\x32\x2e\x64\x6c\x6c\x00\x00\x23\x01\x53\x68\x65\x6c\x6c\x5f\x4e\x6f\x74\x69\x66\x79\x49\x63\x6f\x6e\x57\x00\x53\x48\x45\x4c\x4c\x33\x32\x2e\x64\x6c\x6c\x00\xad\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x54\x68\x72\x65\x61\x64\x49\x64\x00\x00\x6f\x01\x47\x65\x74\x43\x6f\x6d\x6d\x61\x6e\x64\x4c\x69\x6e\x65\x41\x00\x2d\x04\x54\x65\x72\x6d\x69\x6e\x61\x74\x65\x50\x72\x6f\x63\x65\x73\x73\x00\x00\xa9\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x50\x72\x6f\x63\x65\x73\x73\x00\x3e\x04\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x45\x78\x63\x65\x70\x74\x69\x6f\x6e\x46\x69\x6c\x74\x65\x72\x00\x00\x15\x04\x53\x65\x74\x55\x6e\x68\x61\x6e\x64\x6c\x65\x64\x45\x78\x63\x65\x70\x74\x69\x6f\x6e\x46\x69\x6c\x74\x65\x72\x00\xd1\x02\x49\x73\x44\x65\x62\x75\x67\x67\x65\x72\x50\x72\x65\x73\x65\x6e\x74\x00\xd9\x00\x45\x6e\x74\x65\x72\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\x00\xef\x02\x4c\x65\x61\x76\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\x00\x20\x02\x47\x65\x74\x50\x72\x6f\x63\x41\x64\x64\x72\x65\x73\x73\x00\x00\x34\x04\x54\x6c\x73\x47\x65\x74\x56\x61\x6c\x75\x65\x00\x32\x04\x54\x6c\x73\x41\x6c\x6c\x6f\x63\x00\x00\x35\x04\x54\x6c\x73\x53\x65\x74\x56\x61\x6c\x75\x65\x00\x33\x04\x54\x6c\x73\x46\x72\x65\x65\x00\xc0\x02\x49\x6e\x74\x65\x72\x6c\x6f\x63\x6b\x65\x64\x49\x6e\x63\x72\x65\x6d\x65\x6e\x74\x00\x00\xec\x03\x53\x65\x74\x4c\x61\x73\x74\x45\x72\x72\x6f\x72\x00\x00\xbc\x02\x49\x6e\x74\x65\x72\x6c\x6f\x63\x6b\x65\x64\x44\x65\x63\x72\x65\x6d\x65\x6e\x74\x00\x00\xa1\x02\x48\x65\x61\x70\x46\x72\x65\x65\x00\x00\x21\x04\x53\x6c\x65\x65\x70\x00\x04\x01\x45\x78\x69\x74\x50\x72\x6f\x63\x65\x73\x73\x00\xe8\x03\x53\x65\x74\x48\x61\x6e\x64\x6c\x65\x43\x6f\x75\x6e\x74\x00\x00\x3b\x02\x47\x65\x74\x53\x74\x64\x48\x61\x6e\x64\x6c\x65\x00\x00\xd7\x01\x47\x65\x74\x46\x69\x6c\x65\x54\x79\x70\x65\x00\x39\x02\x47\x65\x74\x53\x74\x61\x72\x74\x75\x70\x49\x6e\x66\x6f\x41\x00\xbe\x00\x44\x65\x6c\x65\x74\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x00\xf4\x01\x47\x65\x74\x4d\x6f\x64\x75\x6c\x65\x46\x69\x6c\x65\x4e\x61\x6d\x65\x41\x00\x00\x4a\x01\x46\x72\x65\x65\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x41\x00\xbf\x01\x47\x65\x74\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x00\x4b\x01\x46\x72\x65\x65\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x57\x00\x7a\x04\x57\x69\x64\x65\x43\x68\x61\x72\x54\x6f\x4d\x75\x6c\x74\x69\x42\x79\x74\x65\x00\xc1\x01\x47\x65\x74\x45\x6e\x76\x69\x72\x6f\x6e\x6d\x65\x6e\x74\x53\x74\x72\x69\x6e\x67\x73\x57\x00\x00\x9f\x02\x48\x65\x61\x70\x43\x72\x65\x61\x74\x65\x00\x00\xa0\x02\x48\x65\x61\x70\x44\x65\x73\x74\x72\x6f\x79\x00\x57\x04\x56\x69\x72\x74\x75\x61\x6c\x46\x72\x65\x65\x00\x54\x03\x51\x75\x65\x72\x79\x50\x65\x72\x66\x6f\x72\x6d\x61\x6e\x63\x65\x43\x6f\x75\x6e\x74\x65\x72\x00\x66\x02\x47\x65\x74\x54\x69\x63\x6b\x43\x6f\x75\x6e\x74\x00\x00\xaa\x01\x47\x65\x74\x43\x75\x72\x72\x65\x6e\x74\x50\x72\x6f\x63\x65\x73\x73\x49\x64\x00\x4f\x02\x47\x65\x74\x53\x79\x73\x74\x65\x6d\x54\x69\x6d\x65\x41\x73\x46\x69\x6c\x65\x54\x69\x6d\x65\x00\x5b\x01\x47\x65\x74\x43\x50\x49\x6e\x66\x6f\x00\x52\x01\x47\x65\x74\x41\x43\x50\x00\x00\x13\x02\x47\x65\x74\x4f\x45\x4d\x43\x50\x00\x00\xdb\x02\x49\x73\x56\x61\x6c\x69\x64\x43\x6f\x64\x65\x50\x61\x67\x65\x00\x92\x03\x52\x74\x6c\x55\x6e\x77\x69\x6e\x64\x00\x9d\x02\x48\x65\x61\x70\x41\x6c\x6c\x6f\x63\x00\x54\x04\x56\x69\x72\x74\x75\x61\x6c\x41\x6c\x6c\x6f\x63\x00\x00\xa4\x02\x48\x65\x61\x70\x52\x65\x41\x6c\x6c\x6f\x63\x00\x8d\x04\x57\x72\x69\x74\x65\x46\x69\x6c\x65\x00\xf1\x02\x4c\x6f\x61\x64\x4c\x69\x62\x72\x61\x72\x79\x41\x00\x00\xb5\x02\x49\x6e\x69\x74\x69\x61\x6c\x69\x7a\x65\x43\x72\x69\x74\x69\x63\x61\x6c\x53\x65\x63\x74\x69\x6f\x6e\x41\x6e\x64\x53\x70\x69\x6e\x43\x6f\x75\x6e\x74\x00\x83\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x43\x50\x00\x00\x95\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x4d\x6f\x64\x65\x00\x00\x41\x01\x46\x6c\x75\x73\x68\x46\x69\x6c\x65\x42\x75\x66\x66\x65\x72\x73\x00\x00\xe1\x02\x4c\x43\x4d\x61\x70\x53\x74\x72\x69\x6e\x67\x41\x00\x00\x1a\x03\x4d\x75\x6c\x74\x69\x42\x79\x74\x65\x54\x6f\x57\x69\x64\x65\x43\x68\x61\x72\x00\xe3\x02\x4c\x43\x4d\x61\x70\x53\x74\x72\x69\x6e\x67\x57\x00\x00\x3d\x02\x47\x65\x74\x53\x74\x72\x69\x6e\x67\x54\x79\x70\x65\x41\x00\x00\x40\x02\x47\x65\x74\x53\x74\x72\x69\x6e\x67\x54\x79\x70\x65\x57\x00\x00\xe8\x01\x47\x65\x74\x4c\x6f\x63\x61\x6c\x65\x49\x6e\x66\x6f\x41\x00\x00\xdf\x03\x53\x65\x74\x46\x69\x6c\x65\x50\x6f\x69\x6e\x74\x65\x72\x00\x00\xa6\x02\x48\x65\x61\x70\x53\x69\x7a\x65\x00\x00\x43\x00\x43\x6c\x6f\x73\x65\x48\x61\x6e\x64\x6c\x65\x00\x82\x04\x57\x72\x69\x74\x65\x43\x6f\x6e\x73\x6f\x6c\x65\x41\x00\x99\x01\x47\x65\x74\x43\x6f\x6e\x73\x6f\x6c\x65\x4f\x75\x74\x70\x75\x74\x43\x50\x00\x00\x8c\x04\x57\x72\x69\x74\x65\x43\x6f\x6e\x73\x6f\x6c\x65\x57\x00\xfc\x03\x53\x65\x74\x53\x74\x64\x48\x61\x6e\x64\x6c\x65\x00\x00\x78\x00\x43\x72\x65\x61\x74\x65\x46\x69\x6c\x65\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x78\xee\x54\x00\x00\x00\x00\xca\xd1\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x05\x00\x00\x00\x98\xd1\x00\x00\xac\xd1\x00\x00\xc0\xd1\x00\x00\x30\x14\x00\x00\x70\x12\x00\x00\x70\x15\x00\x00\x80\x13\x00\x00\xf0\x13\x00\x00\xd6\xd1\x00\x00\xee\xd1\x00\x00\xf9\xd1\x00\x00\xfe\xd1\x00\x00\x06\xd2\x00\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x73\x79\x73\x74\x72\x61\x79\x2e\x64\x6c\x6c\x00\x61\x64\x64\x5f\x6f\x72\x5f\x75\x70\x64\x61\x74\x65\x5f\x6d\x65\x6e\x75\x5f\x69\x74\x65\x6d\x00\x6e\x61\x74\x69\x76\x65\x4c\x6f\x6f\x70\x00\x71\x75\x69\x74\x00\x73\x65\x74\x49\x63\x6f\x6e\x00\x73\x65\x74\x54\x6f\x6f\x6c\x74\x69\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\xe6\x40\xbb\xb1\x19\xbf\x44\x60\xfe\x00\x10\x00\x00\x00\x00\x60\xfe\x00\x10\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xb1\x00\x10\xd8\xb1\x00\x10\x01\x00\x00\x00\x16\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x18\x00\x00\x00\x05\x00\x00\x00\x0d\x00\x00\x00\x06\x00\x00\x00\x09\x00\x00\x00\x07\x00\x00\x00\x0c\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x09\x00\x00\x00\x0c\x00\x00\x00\x0a\x00\x00\x00\x07\x00\x00\x00\x0b\x00\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x16\x00\x00\x00\x0d\x00\x00\x00\x16\x00\x00\x00\x0f\x00\x00\x00\x02\x00\x00\x00\x10\x00\x00\x00\x0d\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x02\x00\x00\x00\x21\x00\x00\x00\x0d\x00\x00\x00\x35\x00\x00\x00\x02\x00\x00\x00\x41\x00\x00\x00\x0d\x00\x00\x00\x43\x00\x00\x00\x02\x00\x00\x00\x50\x00\x00\x00\x11\x00\x00\x00\x52\x00\x00\x00\x0d\x00\x00\x00\x53\x00\x00\x00\x0d\x00\x00\x00\x57\x00\x00\x00\x16\x00\x00\x00\x59\x00\x00\x00\x0b\x00\x00\x00\x6c\x00\x00\x00\x0d\x00\x00\x00\x6d\x00\x00\x00\x20\x00\x00\x00\x70\x00\x00\x00\x1c\x00\x00\x00\x72\x00\x00\x00\x09\x00\x00\x00\x06\x00\x00\x00\x16\x00\x00\x00\x80\x00\x00\x00\x0a\x00\x00\x00\x81\x00\x00\x00\x0a\x00\x00\x00\x82\x00\x00\x00\x09\x00\x00\x00\x83\x00\x00\x00\x16\x00\x00\x00\x84\x00\x00\x00\x0d\x00\x00\x00\x91\x00\x00\x00\x29\x00\x00\x00\x9e\x00\x00\x00\x0d\x00\x00\x00\xa1\x00\x00\x00\x02\x00\x00\x00\xa4\x00\x00\x00\x0b\x00\x00\x00\xa7\x00\x00\x00\x0d\x00\x00\x00\xb7\x00\x00\x00\x11\x00\x00\x00\xce\x00\x00\x00\x02\x00\x00\x00\xd7\x00\x00\x00\x0b\x00\x00\x00\x18\x07\x00\x00\x0c\x00\x00\x00\x0c\x00\x00\x00\x08\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x37\x00\x10\x00\x00\x00\x00\xff\xff\xff\xff\x80\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x78\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x00\x00\x00\x00\x00\x00\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x00\x00\x00\x00\x00\x00\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x00\x00\x00\x00\x00\x00\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x00\x00\x00\x00\x00\x00\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xe5\x00\x10\x01\x02\x04\x08\xa4\x03\x00\x00\x60\x82\x79\x82\x21\x00\x00\x00\x00\x00\x00\x00\xa6\xdf\x00\x00\x00\x00\x00\x00\xa1\xa5\x00\x00\x00\x00\x00\x00\x81\x9f\xe0\xfc\x00\x00\x00\x00\x40\x7e\x80\xfc\x00\x00\x00\x00\xa8\x03\x00\x00\xc1\xa3\xda\xa3\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x40\xfe\x00\x00\x00\x00\x00\x00\xb5\x03\x00\x00\xc1\xa3\xda\xa3\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x41\xfe\x00\x00\x00\x00\x00\x00\xb6\x03\x00\x00\xcf\xa2\xe4\xa2\x1a\x00\xe5\xa2\xe8\xa2\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xfe\x00\x00\x00\x00\x00\x00\x40\x7e\xa1\xfe\x00\x00\x00\x00\x51\x05\x00\x00\x51\xda\x5e\xda\x20\x00\x5f\xda\x6a\xda\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\xd3\xd8\xde\xe0\xf9\x00\x00\x31\x7e\x81\xfe\x00\x00\x00\x00\xfc\xbc\x00\x10\xfe\xff\xff\xff\x43\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xea\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\xed\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xba\x00\x10\x80\xbf\x00\x10\x00\xc1\x00\x10\x98\xec\x00\x10\xb8\xea\x00\x10\x01\x00\x00\x00\xb8\xea\x00\x10\x88\xe5\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x87\x88\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x60\xb9\x00\x10\x08\x00\x00\x00\x34\xb9\x00\x10\x09\x00\x00\x00\x08\xb9\x00\x10\x0a\x00\x00\x00\x70\xb8\x00\x10\x10\x00\x00\x00\x44\xb8\x00\x10\x11\x00\x00\x00\x14\xb8\x00\x10\x12\x00\x00\x00\xf0\xb7\x00\x10\x13\x00\x00\x00\xc4\xb7\x00\x10\x18\x00\x00\x00\x8c\xb7\x00\x10\x19\x00\x00\x00\x64\xb7\x00\x10\x1a\x00\x00\x00\x2c\xb7\x00\x10\x1b\x00\x00\x00\xf4\xb6\x00\x10\x1c\x00\x00\x00\xcc\xb6\x00\x10\x1e\x00\x00\x00\xac\xb6\x00\x10\x1f\x00\x00\x00\x48\xb6\x00\x10\x20\x00\x00\x00\x10\xb6\x00\x10\x21\x00\x00\x00\x18\xb5\x00\x10\x22\x00\x00\x00\x78\xb4\x00\x10\x78\x00\x00\x00\x68\xb4\x00\x10\x79\x00\x00\x00\x58\xb4\x00\x10\x7a\x00\x00\x00\x48\xb4\x00\x10\xfc\x00\x00\x00\x44\xb4\x00\x10\xff\x00\x00\x00\x34\xb4\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xba\x00\x10\xfa\xbc\x00\x10\x28\xc3\x00\x10\x24\xc3\x00\x10\x20\xc3\x00\x10\x1c\xc3\x00\x10\x18\xc3\x00\x10\x14\xc3\x00\x10\x10\xc3\x00\x10\x08\xc3\x00\x10\x00\xc3\x00\x10\xf8\xc2\x00\x10\xec\xc2\x00\x10\xe0\xc2\x00\x10\xd8\xc2\x00\x10\xcc\xc2\x00\x10\xc8\xc2\x00\x10\xc4\xc2\x00\x10\xc0\xc2\x00\x10\xbc\xc2\x00\x10\xb8\xc2\x00\x10\xb4\xc2\x00\x10\xb0\xc2\x00\x10\xac\xc2\x00\x10\xa8\xc2\x00\x10\xa4\xc2\x00\x10\xa0\xc2\x00\x10\x9c\xc2\x00\x10\x94\xc2\x00\x10\x88\xc2\x00\x10\x80\xc2\x00\x10\x78\xc2\x00\x10\xb8\xc2\x00\x10\x70\xc2\x00\x10\x68\xc2\x00\x10\x60\xc2\x00\x10\x54\xc2\x00\x10\x4c\xc2\x00\x10\x40\xc2\x00\x10\x34\xc2\x00\x10\x30\xc2\x00\x10\x2c\xc2\x00\x10\x20\xc2\x00\x10\x0c\xc2\x00\x10\x00\xc2\x00\x10\x09\x04\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x98\xec\x00\x10\x2e\x00\x00\x00\x54\xed\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x6c\xf8\x00\x10\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x7f\x58\xed\x00\x10\x01\x00\x00\x00\x2e\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x05\x93\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x70\x00\x00\x01\x00\x00\x00\xf0\xf1\xff\xff\x00\x00\x00\x00\x50\x53\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x44\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xed\x00\x10\x10\xee\x00\x10\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\xfe\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x3b\x00\x00\x00\x5a\x00\x00\x00\x78\x00\x00\x00\x97\x00\x00\x00\xb5\x00\x00\x00\xd4\x00\x00\x00\xf3\x00\x00\x00\x11\x01\x00\x00\x30\x01\x00\x00\x4e\x01\x00\x00\x6d\x01\x00\x00\xff\xff\xff\xff\x1e\x00\x00\x00\x3a\x00\x00\x00\x59\x00\x00\x00\x77\x00\x00\x00\x96\x00\x00\x00\xb4\x00\x00\x00\xd3\x00\x00\x00\xf2\x00\x00\x00\x10\x01\x00\x00\x2f\x01\x00\x00\x4d\x01\x00\x00\x6c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x18\x00\x00\x00\x18\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x02\x00\x00\x00\x30\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x01\x00\x09\x04\x00\x00\x48\x00\x00\x00\x58\x10\x01\x00\x5a\x01\x00\x00\xe4\x04\x00\x00\x00\x00\x00\x00\x3c\x61\x73\x73\x65\x6d\x62\x6c\x79\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x75\x72\x6e\x3a\x73\x63\x68\x65\x6d\x61\x73\x2d\x6d\x69\x63\x72\x6f\x73\x6f\x66\x74\x2d\x63\x6f\x6d\x3a\x61\x73\x6d\x2e\x76\x31\x22\x20\x6d\x61\x6e\x69\x66\x65\x73\x74\x56\x65\x72\x73\x69\x6f\x6e\x3d\x22\x31\x2e\x30\x22\x3e\x0d\x0a\x20\x20\x3c\x74\x72\x75\x73\x74\x49\x6e\x66\x6f\x20\x78\x6d\x6c\x6e\x73\x3d\x22\x75\x72\x6e\x3a\x73\x63\x68\x65\x6d\x61\x73\x2d\x6d\x69\x63\x72\x6f\x73\x6f\x66\x74\x2d\x63\x6f\x6d\x3a\x61\x73\x6d\x2e\x76\x33\x22\x3e\x0d\x0a\x20\x20\x20\x20\x3c\x73\x65\x63\x75\x72\x69\x74\x79\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x3c\x72\x65\x71\x75\x65\x73\x74\x65\x64\x50\x72\x69\x76\x69\x6c\x65\x67\x65\x73\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x3c\x72\x65\x71\x75\x65\x73\x74\x65\x64\x45\x78\x65\x63\x75\x74\x69\x6f\x6e\x4c\x65\x76\x65\x6c\x20\x6c\x65\x76\x65\x6c\x3d\x22\x61\x73\x49\x6e\x76\x6f\x6b\x65\x72\x22\x20\x75\x69\x41\x63\x63\x65\x73\x73\x3d\x22\x66\x61\x6c\x73\x65\x22\x3e\x3c\x2f\x72\x65\x71\x75\x65\x73\x74\x65\x64\x45\x78\x65\x63\x75\x74\x69\x6f\x6e\x4c\x65\x76\x65\x6c\x3e\x0d\x0a\x20\x20\x20\x20\x20\x20\x3c\x2f\x72\x65\x71\x75\x65\x73\x74\x65\x64\x50\x72\x69\x76\x69\x6c\x65\x67\x65\x73\x3e\x0d\x0a\x20\x20\x20\x20\x3c\x2f\x73\x65\x63\x75\x72\x69\x74\x79\x3e\x0d\x0a\x20\x20\x3c\x2f\x74\x72\x75\x73\x74\x49\x6e\x66\x6f\x3e\x0d\x0a\x3c\x2f\x61\x73\x73\x65\x6d\x62\x6c\x79\x3e\x50\x41\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x44\x49\x4e\x47\x50\x41\x44\x44\x49\x4e\x47\x58\x58\x50\x41\x44\x00\x10\x00\x00\x44\x01\x00\x00\x1f\x30\x29\x30\x41\x30\x49\x30\x4e\x30\x62\x30\x6d\x30\x7d\x30\xc5\x30\xf1\x30\x12\x31\x31\x31\x3b\x31\x53\x31\x5b\x31\x60\x31\x81\x31\x95\x31\xb9\x31\xd5\x31\xf8\x31\x17\x32\x26\x32\x31\x32\x36\x32\x3e\x32\x47\x32\x4d\x32\x57\x32\x61\x32\x6b\x32\x7d\x32\x83\x32\xa9\x32\xae\x32\xb6\x32\xc5\x32\xcc\x32\xd2\x32\xe0\x32\xea\x32\x05\x33\x1d\x33\x37\x33\x3e\x33\x93\x33\x9e\x33\xb6\x33\xbe\x33\xc3\x33\xd3\x33\xda\x33\xe0\x33\xea\x33\x02\x34\x0f\x34\x17\x34\x21\x34\x9f\x34\xa6\x34\xba\x34\xc1\x34\xe0\x34\xfe\x34\x06\x35\x0b\x35\x34\x35\x43\x35\x4d\x35\x5d\x35\x71\x35\x79\x35\x80\x35\x90\x35\x3d\x36\x48\x36\x5d\x37\x62\x37\x6c\x37\xa0\x37\xb8\x37\xc0\x37\xc6\x37\x0c\x38\x12\x38\x2d\x38\x5d\x38\x79\x38\x91\x38\xe4\x38\x11\x39\x7f\x39\x85\x39\x8b\x39\x91\x39\x97\x39\x9d\x39\xa4\x39\xab\x39\xb2\x39\xb9\x39\xc0\x39\xc7\x39\xce\x39\xd6\x39\xde\x39\xe6\x39\xf2\x39\xfb\x39\x00\x3a\x06\x3a\x10\x3a\x19\x3a\x24\x3a\x30\x3a\x35\x3a\x45\x3a\x4a\x3a\x50\x3a\x56\x3a\x6c\x3a\x73\x3a\x7a\x3a\x80\x3a\x9a\x3a\xa9\x3a\xb6\x3a\xc2\x3a\xd2\x3a\xd9\x3a\xe8\x3a\xf4\x3a\x01\x3b\x25\x3b\x37\x3b\x45\x3b\x5a\x3b\x64\x3b\x8a\x3b\xbd\x3b\xcc\x3b\xd5\x3b\xf9\x3b\x28\x3c\x6a\x3c\x7c\x3c\x28\x3d\x30\x3d\x45\x3d\x50\x3d\x37\x3e\xd9\x3e\xf7\x3e\x1d\x3f\x7d\x3f\x90\x3f\xab\x3f\x00\x00\x00\x20\x00\x00\x9c\x00\x00\x00\xf6\x32\xe6\x33\x70\x35\x9f\x35\xc4\x35\xa7\x37\xa3\x39\xa7\x39\xab\x39\xaf\x39\xb3\x39\xb7\x39\xbb\x39\xbf\x39\xcc\x39\xde\x39\xb0\x3a\xba\x3a\xc7\x3a\xe2\x3a\xe9\x3a\x01\x3b\x2d\x3b\x49\x3b\x6c\x3b\x7f\x3b\xad\x3b\xca\x3b\x22\x3c\xfc\x3c\x04\x3d\x1c\x3d\x34\x3d\x8b\x3d\xa4\x3d\xaa\x3d\xb5\x3d\xc1\x3d\xd6\x3d\xdd\x3d\xf1\x3d\xf8\x3d\x1f\x3e\x25\x3e\x30\x3e\x3c\x3e\x51\x3e\x58\x3e\x6c\x3e\x73\x3e\x8b\x3e\x97\x3e\x9d\x3e\xa9\x3e\xb8\x3e\xbe\x3e\xc7\x3e\xd3\x3e\xe1\x3e\xe7\x3e\xf3\x3e\xf9\x3e\x06\x3f\x10\x3f\x17\x3f\x2f\x3f\x3e\x3f\x45\x3f\x52\x3f\x75\x3f\x8a\x3f\xb0\x3f\xf0\x3f\xf6\x3f\x00\x30\x00\x00\x58\x01\x00\x00\x20\x30\x26\x30\x42\x30\x5a\x30\x80\x30\xfa\x30\x1d\x31\x27\x31\x5f\x31\x67\x31\xb3\x31\xc3\x31\xc9\x31\xd5\x31\xdb\x31\xeb\x31\xf1\x31\x06\x32\x14\x32\x1f\x32\x26\x32\x41\x32\x46\x32\x4e\x32\x54\x32\x5b\x32\x61\x32\x68\x32\x6e\x32\x76\x32\x7d\x32\x82\x32\x8a\x32\x93\x32\x9f\x32\xa4\x32\xa9\x32\xaf\x32\xb3\x32\xb9\x32\xbe\x32\xc4\x32\xc9\x32\xd8\x32\xee\x32\xf9\x32\xfe\x32\x09\x33\x0e\x33\x19\x33\x1e\x33\x2b\x33\x39\x33\x3f\x33\x4c\x33\x6c\x33\x72\x33\x8e\x33\xaa\x33\xbc\x33\x0b\x34\x11\x34\x22\x34\x4f\x34\x58\x34\x64\x34\x9b\x34\xa4\x34\xb0\x34\xe9\x34\xf2\x34\xfe\x34\x22\x35\x2b\x35\x58\x35\x73\x35\x79\x35\x82\x35\x89\x35\xab\x35\x0a\x36\x12\x36\x25\x36\x30\x36\x35\x36\x45\x36\x4f\x36\x56\x36\x61\x36\x6a\x36\x80\x36\x8b\x36\xa5\x36\xb1\x36\xb9\x36\xc9\x36\xde\x36\x1e\x37\x2b\x37\x55\x37\x5a\x37\x65\x37\x6a\x37\x88\x37\x14\x38\x21\x38\x2a\x38\x3e\x38\x5f\x38\x65\x38\x97\x38\xee\x38\xf6\x38\x36\x39\x40\x39\x68\x39\x81\x39\xc2\x39\xf2\x39\x04\x3a\x56\x3a\x5c\x3a\x80\x3a\x9e\x3a\xc0\x3a\xcb\x3a\xda\x3a\x12\x3b\x1c\x3b\x6c\x3b\x77\x3b\x81\x3b\x92\x3b\x9d\x3b\x50\x3d\x61\x3d\x69\x3d\x6f\x3d\x74\x3d\x7a\x3d\xe6\x3d\xec\x3d\x02\x3e\x0d\x3e\x24\x3e\x30\x3e\x3d\x3e\x44\x3e\x7b\x3e\xca\x3e\xdd\x3e\x0f\x3f\x28\x3f\x37\x3f\x3c\x3f\x5d\x3f\x62\x3f\x96\x3f\x9b\x3f\xa9\x3f\xb2\x3f\xbe\x3f\xc5\x3f\xce\x3f\xe1\x3f\xeb\x3f\xf7\x3f\x00\x00\x00\x40\x00\x00\xd4\x00\x00\x00\x00\x30\x08\x30\x12\x30\x18\x30\x1e\x30\x40\x30\xb9\x30\xbf\x30\xd8\x30\xde\x30\xae\x31\xd1\x31\xde\x31\xea\x31\xf2\x31\xfa\x31\x06\x32\x2a\x32\x32\x32\x3d\x32\x46\x32\x67\x32\x73\x32\x9a\x32\xa7\x32\xac\x32\xba\x32\x95\x33\xb8\x33\xc3\x33\xe6\x33\x35\x34\x7c\x34\x83\x34\x8d\x34\xb7\x34\xc5\x34\xcb\x34\xee\x34\xf5\x34\x0e\x35\x22\x35\x28\x35\x31\x35\x44\x35\x68\x35\xfd\x35\x1d\x36\x49\x36\x76\x36\x1c\x37\x59\x37\x70\x37\xe3\x38\xf4\x38\x2e\x39\x3b\x39\x45\x39\x53\x39\x5c\x39\x66\x39\x9a\x39\xa5\x39\xaf\x39\xc8\x39\xd2\x39\xe5\x39\x09\x3a\x40\x3a\x75\x3a\x88\x3a\xf8\x3a\x15\x3b\x5d\x3b\xc9\x3b\xe8\x3b\x5d\x3c\x69\x3c\x7c\x3c\x8e\x3c\xa9\x3c\xb1\x3c\xb9\x3c\xd0\x3c\xe9\x3c\x05\x3d\x0e\x3d\x14\x3d\x1d\x3d\x22\x3d\x31\x3d\x58\x3d\x81\x3d\x92\x3d\xb5\x3d\x7a\x3e\xa4\x3e\xef\x3e\x3b\x3f\x8a\x3f\xd2\x3f\x00\x00\x00\x50\x00\x00\x80\x00\x00\x00\x38\x30\x4f\x30\x60\x30\x9c\x30\xc6\x31\xcd\x31\x2e\x32\xfc\x33\x1a\x34\x70\x35\xe1\x35\xed\x35\xf9\x36\xb8\x37\xbd\x37\xcf\x37\xed\x37\x01\x38\x07\x38\x74\x38\x79\x38\xbc\x3a\xca\x3a\xd0\x3a\xea\x3a\xef\x3a\xfe\x3a\x07\x3b\x14\x3b\x1f\x3b\x31\x3b\x44\x3b\x4f\x3b\x55\x3b\x5b\x3b\x60\x3b\x69\x3b\x86\x3b\x8c\x3b\x97\x3b\x9c\x3b\xa4\x3b\xaa\x3b\xb4\x3b\xbb\x3b\xcf\x3b\xd6\x3b\xdc\x3b\xea\x3b\xf1\x3b\xf6\x3b\xff\x3b\x0c\x3c\x12\x3c\x2c\x3c\x3d\x3c\x43\x3c\x54\x3c\xb9\x3c\x00\x00\x00\x60\x00\x00\xe0\x00\x00\x00\x55\x30\x61\x30\x94\x30\xba\x30\xf4\x30\x39\x31\x0c\x33\x17\x33\x1f\x33\x34\x33\x46\x33\x96\x33\x9c\x33\xbc\x33\xf3\x33\x04\x34\x4d\x34\xa9\x34\xbe\x34\x04\x35\x0a\x35\x16\x35\x6b\x35\x9e\x35\xd6\x35\x41\x36\x47\x36\x98\x36\x9e\x36\xc2\x36\xe5\x36\x19\x37\x1f\x37\x2b\x37\x72\x37\x9a\x37\xd1\x37\xe9\x37\xf4\x37\x18\x38\x21\x38\x28\x38\x31\x38\x71\x38\x76\x38\x9e\x38\xc3\x38\xe8\x38\xfb\x38\x13\x39\x25\x39\x49\x39\x72\x39\x7d\x39\xf7\x39\x10\x3a\x39\x3a\x3e\x3a\x55\x3a\xa8\x3a\xdf\x3a\xea\x3a\xf8\x3a\xfd\x3a\x02\x3b\x07\x3b\x17\x3b\x46\x3b\x54\x3b\x9b\x3b\xa0\x3b\xe5\x3b\xea\x3b\xf1\x3b\xf6\x3b\xfd\x3b\x02\x3c\x71\x3c\x7a\x3c\x80\x3c\x0a\x3d\x19\x3d\x28\x3d\x31\x3d\x46\x3d\x76\x3d\x97\x3d\xa4\x3d\xca\x3e\xff\x3e\x18\x3f\x1f\x3f\x27\x3f\x2c\x3f\x30\x3f\x34\x3f\x5d\x3f\x83\x3f\xa1\x3f\xa8\x3f\xac\x3f\xb0\x3f\xb4\x3f\xb8\x3f\xbc\x3f\xc0\x3f\xc4\x3f\x00\x00\x00\x70\x00\x00\x8c\x00\x00\x00\x0e\x30\x14\x30\x18\x30\x1c\x30\x20\x30\x86\x30\x91\x30\xac\x30\xb3\x30\xb8\x30\xbc\x30\xc0\x30\xe1\x30\x0b\x31\x3d\x31\x44\x31\x48\x31\x4c\x31\x50\x31\x54\x31\x58\x31\x5c\x31\x60\x31\xaa\x31\xb0\x31\xb4\x31\xb8\x31\xbc\x31\x7f\x32\x08\x33\x6d\x33\x21\x34\x41\x34\x31\x35\x5a\x35\xb3\x35\x41\x37\x21\x38\xea\x38\x1b\x39\x31\x39\x72\x39\x91\x39\x2e\x3a\x62\x3a\x91\x3a\x0a\x3b\x36\x3b\x5e\x3b\x95\x3b\x9f\x3b\x11\x3c\x23\x3c\x30\x3c\x3c\x3c\x46\x3c\x4e\x3c\x59\x3c\x89\x3c\xb9\x3c\x50\x3d\x00\x3e\x23\x3e\xa1\x3e\x72\x3f\xfa\x3f\x00\x80\x00\x00\x90\x00\x00\x00\x04\x30\x1c\x30\x23\x30\x2d\x30\x35\x30\x42\x30\x49\x30\x79\x30\x12\x31\x87\x31\x94\x33\xa6\x33\xb8\x33\xda\x33\xec\x33\xfe\x33\x10\x34\x22\x34\x34\x34\x46\x34\xe4\x36\xf1\x36\x0a\x37\x28\x37\x66\x37\x95\x37\x45\x38\x79\x39\x2e\x3a\x44\x3a\xa9\x3a\xb5\x3a\x2d\x3b\x47\x3b\x50\x3b\xb1\x3d\xb8\x3d\xfa\x3d\x2f\x3e\x48\x3e\x4f\x3e\x57\x3e\x5c\x3e\x60\x3e\x64\x3e\x8d\x3e\xb3\x3e\xd1\x3e\xd8\x3e\xdc\x3e\xe0\x3e\xe4\x3e\xe8\x3e\xec\x3e\xf0\x3e\xf4\x3e\x3e\x3f\x44\x3f\x48\x3f\x4c\x3f\x50\x3f\xb6\x3f\xc1\x3f\xdc\x3f\xe3\x3f\xe8\x3f\xec\x3f\xf0\x3f\x00\x90\x00\x00\xc8\x00\x00\x00\x11\x30\x3b\x30\x6d\x30\x74\x30\x78\x30\x7c\x30\x80\x30\x84\x30\x88\x30\x8c\x30\x90\x30\xda\x30\xe0\x30\xe4\x30\xe8\x30\xec\x30\x38\x31\x70\x31\xb3\x31\xb9\x31\xee\x31\xfc\x31\x02\x32\x12\x32\x17\x32\x2f\x32\x35\x32\x44\x32\x4a\x32\x59\x32\x5f\x32\x6d\x32\x76\x32\x85\x32\x8a\x32\x94\x32\xa2\x32\xe2\x32\xff\x32\x1c\x33\x5b\x33\x62\x33\x68\x33\x98\x33\xa3\x33\xc6\x33\x8a\x34\x97\x34\x24\x36\x61\x36\x6b\x36\x83\x36\xac\x36\xe0\x36\x0f\x37\xb0\x37\xbe\x37\xc6\x37\xd3\x37\xf1\x37\xfb\x37\x04\x38\x0f\x38\x24\x38\x2b\x38\x31\x38\x47\x38\x62\x38\x07\x39\x75\x39\xde\x39\xee\x39\x09\x3a\x29\x3a\x7f\x3a\x90\x3a\xcb\x3a\xe7\x3a\x42\x3b\x4d\x3b\x7b\x3b\x89\x3b\x98\x3b\xb5\x3b\xe1\x3b\x1a\x3c\x27\x3c\x06\x3d\x15\x3d\x99\x3e\x9f\x3e\xa4\x3e\xaa\x3e\xb1\x3e\xc3\x3e\x00\x00\x00\xa0\x00\x00\x0c\x00\x00\x00\x60\x30\x00\x00\x00\xb0\x00\x00\x18\x00\x00\x00\x84\x31\x88\x31\x8c\x31\x90\x31\x9c\x31\xa0\x31\xd0\x31\xd4\x31\x00\xc0\x00\x00\x58\x00\x00\x00\x9c\x34\xa0\x34\x78\x35\x94\x35\x98\x35\xb8\x35\xc4\x35\xe0\x35\xec\x35\x08\x36\x28\x36\x44\x36\x48\x36\x68\x36\x88\x36\x94\x36\xb0\x36\xd0\x36\xf0\x36\x10\x37\x2c\x37\x30\x37\x50\x37\x70\x37\x90\x37\xb0\x37\xcc\x37\xd0\x37\xf0\x37\x0c\x38\x10\x38\x30\x38\x50\x38\x70\x38\x90\x38\xac\x38\xb0\x38\xd0\x38\xf0\x38\x10\x39\x00\xe0\x00\x00\xe8\x00\x00\x00\x08\x30\x10\x30\x88\x32\x8c\x32\x08\x34\xb0\x39\xa8\x3a\x10\x3b\x20\x3b\x30\x3b\x40\x3b\x50\x3b\x74\x3b\x80\x3b\x84\x3b\x88\x3b\x8c\x3b\x90\x3b\x98\x3b\x9c\x3b\xa0\x3b\xa4\x3b\xa8\x3b\xac\x3b\xb0\x3b\xb4\x3b\xb8\x3b\xbc\x3b\xc0\x3b\xc4\x3b\xd4\x3b\xdc\x3b\xe4\x3b\xec\x3b\xf4\x3b\xfc\x3b\x04\x3c\x0c\x3c\x14\x3c\x1c\x3c\x24\x3c\x2c\x3c\x34\x3c\x3c\x3c\x44\x3c\x4c\x3c\x54\x3c\x5c\x3c\x64\x3c\x6c\x3c\x74\x3c\x7c\x3c\x84\x3c\x90\x3c\x94\x3c\x98\x3c\x9c\x3c\xa0\x3c\xa4\x3c\xa8\x3c\xac\x3c\xb0\x3c\xb4\x3c\xb8\x3c\xbc\x3c\xc0\x3c\xc4\x3c\xc8\x3c\xcc\x3c\xd0\x3c\xd4\x3c\xd8\x3c\xdc\x3c\xe0\x3c\xe4\x3c\xe8\x3c\xec\x3c\xf0\x3c\xf4\x3c\xf8\x3c\xfc\x3c\x00\x3d\x04\x3d\x08\x3d\x0c\x3d\x10\x3d\x14\x3d\x18\x3d\x1c\x3d\x20\x3d\x24\x3d\x28\x3d\x2c\x3d\x30\x3d\x34\x3d\x38\x3d\x3c\x3d\x40\x3d\x50\x3d\x58\x3d\x5c\x3d\x60\x3d\x64\x3d\x68\x3d\x6c\x3d\x70\x3d\x74\x3d\x78\x3d\x7c\x3d\x88\x3d\x50\x3e\x54\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + +func systray_unsigned_dll_bytes() ([]byte, error) { + return bindata_read( + _systray_unsigned_dll, + "systray_unsigned.dll", + ) +} + +func systray_unsigned_dll() (*asset, error) { + bytes, err := systray_unsigned_dll_bytes() + if err != nil { + return nil, err + } + + info := bindata_file_info{name: "systray_unsigned.dll", size: 56320, mode: os.FileMode(493), modTime: time.Unix(1424918015, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +// Asset loads and returns the asset for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func Asset(name string) ([]byte, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) + } + return a.bytes, nil + } + return nil, fmt.Errorf("Asset %s not found", name) +} + +// AssetInfo loads and returns the asset info for the given name. +// It returns an error if the asset could not be found or +// could not be loaded. +func AssetInfo(name string) (os.FileInfo, error) { + cannonicalName := strings.Replace(name, "\\", "/", -1) + if f, ok := _bindata[cannonicalName]; ok { + a, err := f() + if err != nil { + return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) + } + return a.info, nil + } + return nil, fmt.Errorf("AssetInfo %s not found", name) +} + +// AssetNames returns the names of the assets. +func AssetNames() []string { + names := make([]string, 0, len(_bindata)) + for name := range _bindata { + names = append(names, name) + } + return names +} + +// _bindata is a table, holding each asset generator, mapped to its name. +var _bindata = map[string]func() (*asset, error){ + "systray.dll": systray_dll, + "systray_unsigned.dll": systray_unsigned_dll, +} + +// AssetDir returns the file names below a certain +// directory embedded in the file by go-bindata. +// For example if you run go-bindata on data/... and data contains the +// following hierarchy: +// data/ +// foo.txt +// img/ +// a.png +// b.png +// then AssetDir("data") would return []string{"foo.txt", "img"} +// AssetDir("data/img") would return []string{"a.png", "b.png"} +// AssetDir("foo.txt") and AssetDir("notexist") would return an error +// AssetDir("") will return []string{"data"}. +func AssetDir(name string) ([]string, error) { + node := _bintree + if len(name) != 0 { + cannonicalName := strings.Replace(name, "\\", "/", -1) + pathList := strings.Split(cannonicalName, "/") + for _, p := range pathList { + node = node.Children[p] + if node == nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + } + } + if node.Func != nil { + return nil, fmt.Errorf("Asset %s not found", name) + } + rv := make([]string, 0, len(node.Children)) + for name := range node.Children { + rv = append(rv, name) + } + return rv, nil +} + +type _bintree_t struct { + Func func() (*asset, error) + Children map[string]*_bintree_t +} +var _bintree = &_bintree_t{nil, map[string]*_bintree_t{ + "systray.dll": &_bintree_t{systray_dll, map[string]*_bintree_t{ + }}, + "systray_unsigned.dll": &_bintree_t{systray_unsigned_dll, map[string]*_bintree_t{ + }}, +}} + +// Restore an asset under the given directory +func RestoreAsset(dir, name string) error { + data, err := Asset(name) + if err != nil { + return err + } + info, err := AssetInfo(name) + if err != nil { + return err + } + err = os.MkdirAll(_filePath(dir, path.Dir(name)), os.FileMode(0755)) + if err != nil { + return err + } + err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) + if err != nil { + return err + } + err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) + if err != nil { + return err + } + return nil +} + +// Restore assets under the given directory recursively +func RestoreAssets(dir, name string) error { + children, err := AssetDir(name) + if err != nil { // File + return RestoreAsset(dir, name) + } else { // Dir + for _, child := range children { + err = RestoreAssets(dir, path.Join(name, child)) + if err != nil { + return err + } + } + } + return nil +} + +func _filePath(dir, name string) string { + cannonicalName := strings.Replace(name, "\\", "/", -1) + return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) +} + diff --git a/vendor/github.com/getlantern/filepersist/filepersist.go b/vendor/github.com/getlantern/filepersist/filepersist.go new file mode 100644 index 000000000..1f6aec487 --- /dev/null +++ b/vendor/github.com/getlantern/filepersist/filepersist.go @@ -0,0 +1,122 @@ +// package filepersist provdies a mechanism for persisting data to a file at a +// permanent location +package filepersist + +import ( + "fmt" + "io" + "os" + + "github.com/getlantern/golog" +) + +var ( + log = golog.LoggerFor("filepersist") +) + +// Save saves the given data to the file at filename. If an existing file at +// that filename already exists, this simply chmods the existing file to match +// the given fileMode and otherwise leaves it alone. +func Save(filename string, data []byte, fileMode os.FileMode) error { + log.Tracef("Attempting to open %v for creating, but only if it doesn't already exist", filename) + file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_EXCL, fileMode) + if err != nil { + if !os.IsExist(err) { + return fmt.Errorf("Unexpected error opening %s: %s", filename, err) + } + + log.Tracef("%s already exists, check to make sure contents is the same", filename) + if dataMatches(filename, data) { + log.Tracef("Data in %s matches expected, using existing", filename) + chmod(filename, fileMode) + // TODO - maybe don't swallow the error, but returning something + // unique so the caller can decide whether or not to ignore it. + return nil + } + + log.Tracef("Data in %s doesn't match expected, truncating file", filename) + file, err = openAndTruncate(filename, fileMode, true) + if err != nil { + return fmt.Errorf("Unable to truncate %s: %s", filename, err) + } + } + + log.Tracef("Created new file at %s, writing data", filename) + _, err = file.Write(data) + if err != nil { + if err := os.Remove(filename); err != nil { + log.Debugf("Unable to remove file: %v", err) + } + return fmt.Errorf("Unable to write to file at %s: %s", filename, err) + } + if err := file.Sync(); err != nil { + log.Debugf("Unable to sync file: %v", err) + } + if err := file.Close(); err != nil { + log.Debugf("Unable to close file: %v", err) + } + + log.Trace("File saved") + return nil +} + +func openAndTruncate(filename string, fileMode os.FileMode, removeIfNecessary bool) (*os.File, error) { + file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, fileMode) + if err != nil && os.IsPermission(err) && removeIfNecessary { + log.Tracef("Permission denied truncating file %v, try to remove", filename) + err = os.Remove(filename) + if err != nil { + return nil, fmt.Errorf("Unable to remove file %v: %v", filename, err) + } + return openAndTruncate(filename, fileMode, false) + } + + return file, err +} + +// dataMatches compares the file at filename byte for byte with the given data +func dataMatches(filename string, data []byte) bool { + file, err := os.OpenFile(filename, os.O_RDONLY, 0) + if err != nil { + log.Tracef("Unable to open existing file at %s for reading: %s", filename, err) + return false + } + fileInfo, err := file.Stat() + if err != nil { + log.Tracef("Unable to stat file %s", filename) + return false + } + if fileInfo.Size() != int64(len(data)) { + return false + } + b := make([]byte, 65536) + i := 0 + for { + n, err := file.Read(b) + if err != nil && err != io.EOF { + log.Tracef("Error reading %s for comparison: %s", filename, err) + return false + } + for j := 0; j < n; j++ { + if b[j] != data[i] { + return false + } + i = i + 1 + } + if err == io.EOF { + break + } + } + return true +} + +func chmod(filename string, fileMode os.FileMode) { + fi, err := os.Stat(filename) + if err != nil || fi.Mode() != fileMode { + log.Tracef("Chmodding %v", filename) + err = os.Chmod(filename, fileMode) + if err != nil { + log.Debugf("Warning - unable to chmod %v: %v", filename, err) + } + } +} diff --git a/vendor/github.com/getlantern/systray/systray_windows.go b/vendor/github.com/getlantern/systray/systray_windows.go deleted file mode 100644 index 7a9d7a17a..000000000 --- a/vendor/github.com/getlantern/systray/systray_windows.go +++ /dev/null @@ -1,690 +0,0 @@ -// +build windows - -package systray - -import ( - "crypto/md5" - "encoding/hex" - "io/ioutil" - "os" - "path/filepath" - "unsafe" - - "golang.org/x/sys/windows" -) - -// Helpful sources: https://github.com/golang/exp/blob/master/shiny/driver/internal/win32 - -var ( - k32 = windows.NewLazySystemDLL("Kernel32.dll") - s32 = windows.NewLazySystemDLL("Shell32.dll") - u32 = windows.NewLazySystemDLL("User32.dll") - pGetModuleHandle = k32.NewProc("GetModuleHandleW") - pShellNotifyIcon = s32.NewProc("Shell_NotifyIconW") - pCreatePopupMenu = u32.NewProc("CreatePopupMenu") - pCreateWindowEx = u32.NewProc("CreateWindowExW") - pDefWindowProc = u32.NewProc("DefWindowProcW") - pDeleteMenu = u32.NewProc("DeleteMenu") - pDestroyWindow = u32.NewProc("DestroyWindow") - pDispatchMessage = u32.NewProc("DispatchMessageW") - pGetCursorPos = u32.NewProc("GetCursorPos") - pGetMenuItemID = u32.NewProc("GetMenuItemID") - pGetMessage = u32.NewProc("GetMessageW") - pInsertMenuItem = u32.NewProc("InsertMenuItemW") - pLoadIcon = u32.NewProc("LoadIconW") - pLoadImage = u32.NewProc("LoadImageW") - pLoadCursor = u32.NewProc("LoadCursorW") - pPostMessage = u32.NewProc("PostMessageW") - pPostQuitMessage = u32.NewProc("PostQuitMessage") - pRegisterClass = u32.NewProc("RegisterClassExW") - pRegisterWindowMessage = u32.NewProc("RegisterWindowMessageW") - pSetForegroundWindow = u32.NewProc("SetForegroundWindow") - pSetMenuInfo = u32.NewProc("SetMenuInfo") - pSetMenuItemInfo = u32.NewProc("SetMenuItemInfoW") - pShowWindow = u32.NewProc("ShowWindow") - pTrackPopupMenu = u32.NewProc("TrackPopupMenu") - pTranslateMessage = u32.NewProc("TranslateMessage") - pUnregisterClass = u32.NewProc("UnregisterClassW") - pUpdateWindow = u32.NewProc("UpdateWindow") -) - -// Contains window class information. -// It is used with the RegisterClassEx and GetClassInfoEx functions. -// https://msdn.microsoft.com/en-us/library/ms633577.aspx -type wndClassEx struct { - Size, Style uint32 - WndProc uintptr - ClsExtra, WndExtra int32 - Instance, Icon, Cursor, Background windows.Handle - MenuName, ClassName *uint16 - IconSm windows.Handle -} - -// Registers a window class for subsequent use in calls to the CreateWindow or CreateWindowEx function. -// https://msdn.microsoft.com/en-us/library/ms633587.aspx -func (w *wndClassEx) register() error { - w.Size = uint32(unsafe.Sizeof(*w)) - res, _, err := pRegisterClass.Call(uintptr(unsafe.Pointer(w))) - if res == 0 { - return err - } - return nil -} - -// Unregisters a window class, freeing the memory required for the class. -// https://msdn.microsoft.com/en-us/library/ms644899.aspx -func (w *wndClassEx) unregister() error { - res, _, err := pUnregisterClass.Call( - uintptr(unsafe.Pointer(w.ClassName)), - uintptr(w.Instance), - ) - if res == 0 { - return err - } - return nil -} - -// Contains information that the system needs to display notifications in the notification area. -// Used by Shell_NotifyIcon. -// https://msdn.microsoft.com/en-us/library/windows/desktop/bb773352(v=vs.85).aspx -// https://msdn.microsoft.com/en-us/library/windows/desktop/bb762159 -type notifyIconData struct { - Size uint32 - Wnd windows.Handle - ID, Flags, CallbackMessage uint32 - Icon windows.Handle - Tip [128]uint16 - State, StateMask uint32 - Info [256]uint16 - Timeout, Version uint32 - InfoTitle [64]uint16 - InfoFlags uint32 - GuidItem windows.GUID - BalloonIcon windows.Handle -} - -func (nid *notifyIconData) add() error { - const NIM_ADD = 0x00000000 - res, _, err := pShellNotifyIcon.Call( - uintptr(NIM_ADD), - uintptr(unsafe.Pointer(nid)), - ) - if res == 0 { - return err - } - return nil -} - -func (nid *notifyIconData) modify() error { - const NIM_MODIFY = 0x00000001 - res, _, err := pShellNotifyIcon.Call( - uintptr(NIM_MODIFY), - uintptr(unsafe.Pointer(nid)), - ) - if res == 0 { - return err - } - return nil -} - -func (nid *notifyIconData) delete() error { - const NIM_DELETE = 0x00000002 - res, _, err := pShellNotifyIcon.Call( - uintptr(NIM_DELETE), - uintptr(unsafe.Pointer(nid)), - ) - if res == 0 { - return err - } - return nil -} - -// Contains information about a menu item. -// https://msdn.microsoft.com/en-us/library/windows/desktop/ms647578(v=vs.85).aspx -type menuItemInfo struct { - Size, Mask, Type, State uint32 - ID uint32 - SubMenu, Checked, Unchecked windows.Handle - ItemData uintptr - TypeData *uint16 - Cch uint32 - Item windows.Handle -} - -// The POINT structure defines the x- and y- coordinates of a point. -// https://msdn.microsoft.com/en-us/library/windows/desktop/dd162805(v=vs.85).aspx -type point struct { - X, Y int32 -} - -// Contains information about loaded resources -type winTray struct { - instance, - icon, - cursor, - window, - menu windows.Handle - - loadedImages map[string]windows.Handle - nid *notifyIconData - wcex *wndClassEx - - wmSystrayMessage, - wmTaskbarCreated uint32 -} - -// Loads an image from file and shows it in tray. -// LoadImage: https://msdn.microsoft.com/en-us/library/windows/desktop/ms648045(v=vs.85).aspx -// Shell_NotifyIcon: https://msdn.microsoft.com/en-us/library/windows/desktop/bb762159(v=vs.85).aspx -func (t *winTray) setIcon(src string) error { - const IMAGE_ICON = 1 // Loads an icon - const LR_LOADFROMFILE = 0x00000010 // Loads the stand-alone image from the file - const NIF_ICON = 0x00000002 - - // Save and reuse handles of loaded images - h, ok := t.loadedImages[src] - if !ok { - srcPtr, err := windows.UTF16PtrFromString(src) - if err != nil { - return err - } - res, _, err := pLoadImage.Call( - 0, - uintptr(unsafe.Pointer(srcPtr)), - IMAGE_ICON, - 64, - 64, - LR_LOADFROMFILE, - ) - if res == 0 { - return err - } - h = windows.Handle(res) - t.loadedImages[src] = h - } - - t.nid.Icon = h - t.nid.Flags |= NIF_ICON - t.nid.Size = uint32(unsafe.Sizeof(*t.nid)) - - return t.nid.modify() -} - -// Sets tooltip on icon. -// Shell_NotifyIcon: https://msdn.microsoft.com/en-us/library/windows/desktop/bb762159(v=vs.85).aspx -func (t *winTray) setTooltip(src string) error { - const NIF_TIP = 0x00000004 - b, err := windows.UTF16FromString(src) - if err != nil { - return err - } - copy(t.nid.Tip[:], b[:]) - t.nid.Flags |= NIF_TIP - t.nid.Size = uint32(unsafe.Sizeof(*t.nid)) - - return t.nid.modify() -} - -var wt winTray - -// WindowProc callback function that processes messages sent to a window. -// https://msdn.microsoft.com/en-us/library/windows/desktop/ms633573(v=vs.85).aspx -func (t *winTray) wndProc(hWnd windows.Handle, message uint32, wParam, lParam uintptr) (lResult uintptr) { - const ( - WM_COMMAND = 0x0111 - WM_DESTROY = 0x0002 - WM_ENDSESSION = 0x16 - WM_RBUTTONUP = 0x0205 - WM_LBUTTONUP = 0x0202 - ) - switch message { - case WM_COMMAND: - menuId := int32(wParam) - if menuId != -1 { - systrayMenuItemSelected(menuId) - } - case WM_DESTROY: - // same as WM_ENDSESSION, but throws 0 exit code after all - defer pPostQuitMessage.Call(uintptr(int32(0))) - fallthrough - case WM_ENDSESSION: - if t.nid != nil { - t.nid.delete() - } - systrayExit() - case t.wmSystrayMessage: - switch lParam { - case WM_RBUTTONUP, WM_LBUTTONUP: - t.showMenu() - } - case t.wmTaskbarCreated: // on explorer.exe restarts - t.nid.add() - default: - // Calls the default window procedure to provide default processing for any window messages that an application does not process. - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms633572(v=vs.85).aspx - lResult, _, _ = pDefWindowProc.Call( - uintptr(hWnd), - uintptr(message), - uintptr(wParam), - uintptr(lParam), - ) - } - return -} - -func (t *winTray) initInstance() error { - const IDI_APPLICATION = 32512 - const IDC_ARROW = 32512 // Standard arrow - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms633548(v=vs.85).aspx - const SW_HIDE = 0 - const CW_USEDEFAULT = 0x80000000 - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms632600(v=vs.85).aspx - const ( - WS_CAPTION = 0x00C00000 - WS_MAXIMIZEBOX = 0x00010000 - WS_MINIMIZEBOX = 0x00020000 - WS_OVERLAPPED = 0x00000000 - WS_SYSMENU = 0x00080000 - WS_THICKFRAME = 0x00040000 - - WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX - ) - // https://msdn.microsoft.com/en-us/library/windows/desktop/ff729176 - const ( - CS_HREDRAW = 0x0002 - CS_VREDRAW = 0x0001 - ) - const NIF_MESSAGE = 0x00000001 - - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644931(v=vs.85).aspx - const WM_USER = 0x0400 - - const ( - className = "SystrayClass" - windowName = "" - ) - - t.wmSystrayMessage = WM_USER + 1 - - taskbarEventNamePtr, _ := windows.UTF16PtrFromString("TaskbarCreated") - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644947 - res, _, err := pRegisterWindowMessage.Call( - uintptr(unsafe.Pointer(taskbarEventNamePtr)), - ) - t.wmTaskbarCreated = uint32(res) - - t.loadedImages = make(map[string]windows.Handle) - - instanceHandle, _, err := pGetModuleHandle.Call(0) - if instanceHandle == 0 { - return err - } - t.instance = windows.Handle(instanceHandle) - - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms648072(v=vs.85).aspx - iconHandle, _, err := pLoadIcon.Call(0, uintptr(IDI_APPLICATION)) - if iconHandle == 0 { - return err - } - t.icon = windows.Handle(iconHandle) - - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms648391(v=vs.85).aspx - cursorHandle, _, err := pLoadCursor.Call(0, uintptr(IDC_ARROW)) - if cursorHandle == 0 { - return err - } - t.cursor = windows.Handle(cursorHandle) - - classNamePtr, err := windows.UTF16PtrFromString(className) - if err != nil { - return err - } - - windowNamePtr, err := windows.UTF16PtrFromString(windowName) - if err != nil { - return err - } - - t.wcex = &wndClassEx{ - Style: CS_HREDRAW | CS_VREDRAW, - WndProc: windows.NewCallback(t.wndProc), - Instance: t.instance, - Icon: t.icon, - Cursor: t.cursor, - Background: windows.Handle(6), // (COLOR_WINDOW + 1) - ClassName: classNamePtr, - IconSm: t.icon, - } - if err := t.wcex.register(); err != nil { - return err - } - - windowHandle, _, err := pCreateWindowEx.Call( - uintptr(0), - uintptr(unsafe.Pointer(classNamePtr)), - uintptr(unsafe.Pointer(windowNamePtr)), - uintptr(WS_OVERLAPPEDWINDOW), - uintptr(CW_USEDEFAULT), - uintptr(CW_USEDEFAULT), - uintptr(CW_USEDEFAULT), - uintptr(CW_USEDEFAULT), - uintptr(0), - uintptr(0), - uintptr(t.instance), - uintptr(0), - ) - if windowHandle == 0 { - return err - } - t.window = windows.Handle(windowHandle) - - pShowWindow.Call( - uintptr(t.window), - uintptr(SW_HIDE), - ) - - pUpdateWindow.Call( - uintptr(t.window), - ) - - t.nid = ¬ifyIconData{ - Wnd: windows.Handle(t.window), - ID: 100, - Flags: NIF_MESSAGE, - CallbackMessage: t.wmSystrayMessage, - } - t.nid.Size = uint32(unsafe.Sizeof(*t.nid)) - - return t.nid.add() -} - -func (t *winTray) createMenu() error { - const MIM_APPLYTOSUBMENUS = 0x80000000 // Settings apply to the menu and all of its submenus - - menuHandle, _, err := pCreatePopupMenu.Call() - if menuHandle == 0 { - return err - } - t.menu = windows.Handle(menuHandle) - - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647575(v=vs.85).aspx - mi := struct { - Size, Mask, Style, Max uint32 - Background windows.Handle - ContextHelpID uint32 - MenuData uintptr - }{ - Mask: MIM_APPLYTOSUBMENUS, - } - mi.Size = uint32(unsafe.Sizeof(mi)) - - res, _, err := pSetMenuInfo.Call( - uintptr(t.menu), - uintptr(unsafe.Pointer(&mi)), - ) - if res == 0 { - return err - } - return nil -} - -func (t *winTray) addOrUpdateMenuItem(menuId int32, title string, disabled, checked bool) error { - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647578(v=vs.85).aspx - const ( - MIIM_FTYPE = 0x00000100 - MIIM_STRING = 0x00000040 - MIIM_ID = 0x00000002 - MIIM_STATE = 0x00000001 - ) - const MFT_STRING = 0x00000000 - const ( - MFS_CHECKED = 0x00000008 - MFS_DISABLED = 0x00000003 - ) - titlePtr, err := windows.UTF16PtrFromString(title) - if err != nil { - return err - } - - mi := menuItemInfo{ - Mask: MIIM_FTYPE | MIIM_STRING | MIIM_ID | MIIM_STATE, - Type: MFT_STRING, - ID: uint32(menuId), - TypeData: titlePtr, - Cch: uint32(len(title)), - } - if disabled { - mi.State |= MFS_DISABLED - } - if checked { - mi.State |= MFS_CHECKED - } - mi.Size = uint32(unsafe.Sizeof(mi)) - - // The return value is the identifier of the specified menu item. - // If the menu item identifier is NULL or if the specified item opens a submenu, the return value is -1. - res, _, err := pGetMenuItemID.Call(uintptr(t.menu), uintptr(menuId)) - if int32(res) == -1 { - res, _, err = pInsertMenuItem.Call( - uintptr(t.menu), - uintptr(menuId), - 1, - uintptr(unsafe.Pointer(&mi)), - ) - if res == 0 { - return err - } - } else { - res, _, err = pSetMenuItemInfo.Call( - uintptr(t.menu), - uintptr(menuId), - 0, - uintptr(unsafe.Pointer(&mi)), - ) - if res == 0 { - return err - } - } - - return nil -} - -func (t *winTray) addSeparatorMenuItem(menuId int32) error { - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647578(v=vs.85).aspx - const ( - MIIM_FTYPE = 0x00000100 - MIIM_ID = 0x00000002 - MIIM_STATE = 0x00000001 - ) - const MFT_SEPARATOR = 0x00000800 - - mi := menuItemInfo{ - Mask: MIIM_FTYPE | MIIM_ID | MIIM_STATE, - Type: MFT_SEPARATOR, - ID: uint32(menuId), - } - - mi.Size = uint32(unsafe.Sizeof(mi)) - - res, _, err := pInsertMenuItem.Call( - uintptr(t.menu), - uintptr(menuId), - 1, - uintptr(unsafe.Pointer(&mi)), - ) - if res == 0 { - return err - } - - return nil -} - -func (t *winTray) hideMenuItem(menuId int32) error { - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms647629(v=vs.85).aspx - const MF_BYCOMMAND = 0x00000000 - - res, _, err := pDeleteMenu.Call( - uintptr(t.menu), - uintptr(uint32(menuId)), - MF_BYCOMMAND, - ) - if res == 0 { - return err - } - - return nil -} - -func (t *winTray) showMenu() error { - const ( - TPM_BOTTOMALIGN = 0x0020 - TPM_LEFTALIGN = 0x0000 - ) - p := point{} - res, _, err := pGetCursorPos.Call(uintptr(unsafe.Pointer(&p))) - if res == 0 { - return err - } - pSetForegroundWindow.Call(uintptr(t.window)) - - res, _, err = pTrackPopupMenu.Call( - uintptr(t.menu), - TPM_BOTTOMALIGN|TPM_LEFTALIGN, - uintptr(p.X), - uintptr(p.Y), - 0, - uintptr(t.window), - 0, - ) - if res == 0 { - return err - } - - return nil -} - -func nativeLoop() { - if err := wt.initInstance(); err != nil { - log.Errorf("Unable to init instance: %v", err) - return - } - - if err := wt.createMenu(); err != nil { - log.Errorf("Unable to create menu: %v", err) - return - } - - defer func() { - pDestroyWindow.Call(uintptr(wt.window)) - wt.wcex.unregister() - }() - - go systrayReady() - - // Main message pump. - m := &struct { - WindowHandle windows.Handle - Message uint32 - Wparam uintptr - Lparam uintptr - Time uint32 - Pt point - }{} - for { - ret, _, err := pGetMessage.Call(uintptr(unsafe.Pointer(m)), 0, 0, 0) - - // If the function retrieves a message other than WM_QUIT, the return value is nonzero. - // If the function retrieves the WM_QUIT message, the return value is zero. - // If there is an error, the return value is -1 - // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644936(v=vs.85).aspx - switch int32(ret) { - case -1: - log.Errorf("Error at message loop: %v", err) - return - case 0: - return - default: - pTranslateMessage.Call(uintptr(unsafe.Pointer(m))) - pDispatchMessage.Call(uintptr(unsafe.Pointer(m))) - } - } -} - -func quit() { - const WM_CLOSE = 0x0010 - - pPostMessage.Call( - uintptr(wt.window), - WM_CLOSE, - 0, - 0, - ) -} - -// SetIcon sets the systray icon. -// iconBytes should be the content of .ico for windows and .ico/.jpg/.png -// for other platforms. -func SetIcon(iconBytes []byte) { - bh := md5.Sum(iconBytes) - dataHash := hex.EncodeToString(bh[:]) - iconFilePath := filepath.Join(os.TempDir(), "systray_temp_icon_"+dataHash) - - if _, err := os.Stat(iconFilePath); os.IsNotExist(err) { - if err := ioutil.WriteFile(iconFilePath, iconBytes, 0644); err != nil { - log.Errorf("Unable to write icon data to temp file: %v", err) - return - } - } - - if err := wt.setIcon(iconFilePath); err != nil { - log.Errorf("Unable to set icon: %v", err) - return - } -} - -// SetTitle sets the systray title, only available on Mac. -func SetTitle(title string) { - // do nothing -} - -// SetIcon sets the icon of a menu item. Only available on Mac. -func (item *MenuItem) SetIcon(iconBytes []byte) { - // do nothing -} - -// SetTooltip sets the systray tooltip to display on mouse hover of the tray icon, -// only available on Mac and Windows. -func SetTooltip(tooltip string) { - if err := wt.setTooltip(tooltip); err != nil { - log.Errorf("Unable to set tooltip: %v", err) - return - } -} - -func addOrUpdateMenuItem(item *MenuItem) { - err := wt.addOrUpdateMenuItem(item.id, item.title, item.disabled, item.checked) - if err != nil { - log.Errorf("Unable to addOrUpdateMenuItem: %v", err) - return - } -} - -func addSeparator(id int32) { - err := wt.addSeparatorMenuItem(id) - if err != nil { - log.Errorf("Unable to addSeparator: %v", err) - return - } -} - -func hideMenuItem(item *MenuItem) { - err := wt.hideMenuItem(item.id) - if err != nil { - log.Errorf("Unable to hideMenuItem: %v", err) - return - } -} - -func showMenuItem(item *MenuItem) { - addOrUpdateMenuItem(item) -} diff --git a/vendor/github.com/pmezard/go-difflib/LICENSE b/vendor/github.com/pmezard/go-difflib/LICENSE new file mode 100644 index 000000000..c67dad612 --- /dev/null +++ b/vendor/github.com/pmezard/go-difflib/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2013, Patrick Mezard +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. + The names of its contributors may not be used to endorse or promote +products derived from this software without specific prior written +permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +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/pmezard/go-difflib/difflib/difflib.go b/vendor/github.com/pmezard/go-difflib/difflib/difflib.go new file mode 100644 index 000000000..003e99fad --- /dev/null +++ b/vendor/github.com/pmezard/go-difflib/difflib/difflib.go @@ -0,0 +1,772 @@ +// Package difflib is a partial port of Python difflib module. +// +// It provides tools to compare sequences of strings and generate textual diffs. +// +// The following class and functions have been ported: +// +// - SequenceMatcher +// +// - unified_diff +// +// - context_diff +// +// Getting unified diffs was the main goal of the port. Keep in mind this code +// is mostly suitable to output text differences in a human friendly way, there +// are no guarantees generated diffs are consumable by patch(1). +package difflib + +import ( + "bufio" + "bytes" + "fmt" + "io" + "strings" +) + +func min(a, b int) int { + if a < b { + return a + } + return b +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} + +func calculateRatio(matches, length int) float64 { + if length > 0 { + return 2.0 * float64(matches) / float64(length) + } + return 1.0 +} + +type Match struct { + A int + B int + Size int +} + +type OpCode struct { + Tag byte + I1 int + I2 int + J1 int + J2 int +} + +// SequenceMatcher compares sequence of strings. The basic +// algorithm predates, and is a little fancier than, an algorithm +// published in the late 1980's by Ratcliff and Obershelp under the +// hyperbolic name "gestalt pattern matching". The basic idea is to find +// the longest contiguous matching subsequence that contains no "junk" +// elements (R-O doesn't address junk). The same idea is then applied +// recursively to the pieces of the sequences to the left and to the right +// of the matching subsequence. This does not yield minimal edit +// sequences, but does tend to yield matches that "look right" to people. +// +// SequenceMatcher tries to compute a "human-friendly diff" between two +// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the +// longest *contiguous* & junk-free matching subsequence. That's what +// catches peoples' eyes. The Windows(tm) windiff has another interesting +// notion, pairing up elements that appear uniquely in each sequence. +// That, and the method here, appear to yield more intuitive difference +// reports than does diff. This method appears to be the least vulnerable +// to synching up on blocks of "junk lines", though (like blank lines in +// ordinary text files, or maybe "

" lines in HTML files). That may be +// because this is the only method of the 3 that has a *concept* of +// "junk" . +// +// Timing: Basic R-O is cubic time worst case and quadratic time expected +// case. SequenceMatcher is quadratic time for the worst case and has +// expected-case behavior dependent in a complicated way on how many +// elements the sequences have in common; best case time is linear. +type SequenceMatcher struct { + a []string + b []string + b2j map[string][]int + IsJunk func(string) bool + autoJunk bool + bJunk map[string]struct{} + matchingBlocks []Match + fullBCount map[string]int + bPopular map[string]struct{} + opCodes []OpCode +} + +func NewMatcher(a, b []string) *SequenceMatcher { + m := SequenceMatcher{autoJunk: true} + m.SetSeqs(a, b) + return &m +} + +func NewMatcherWithJunk(a, b []string, autoJunk bool, + isJunk func(string) bool) *SequenceMatcher { + + m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk} + m.SetSeqs(a, b) + return &m +} + +// Set two sequences to be compared. +func (m *SequenceMatcher) SetSeqs(a, b []string) { + m.SetSeq1(a) + m.SetSeq2(b) +} + +// Set the first sequence to be compared. The second sequence to be compared is +// not changed. +// +// SequenceMatcher computes and caches detailed information about the second +// sequence, so if you want to compare one sequence S against many sequences, +// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other +// sequences. +// +// See also SetSeqs() and SetSeq2(). +func (m *SequenceMatcher) SetSeq1(a []string) { + if &a == &m.a { + return + } + m.a = a + m.matchingBlocks = nil + m.opCodes = nil +} + +// Set the second sequence to be compared. The first sequence to be compared is +// not changed. +func (m *SequenceMatcher) SetSeq2(b []string) { + if &b == &m.b { + return + } + m.b = b + m.matchingBlocks = nil + m.opCodes = nil + m.fullBCount = nil + m.chainB() +} + +func (m *SequenceMatcher) chainB() { + // Populate line -> index mapping + b2j := map[string][]int{} + for i, s := range m.b { + indices := b2j[s] + indices = append(indices, i) + b2j[s] = indices + } + + // Purge junk elements + m.bJunk = map[string]struct{}{} + if m.IsJunk != nil { + junk := m.bJunk + for s, _ := range b2j { + if m.IsJunk(s) { + junk[s] = struct{}{} + } + } + for s, _ := range junk { + delete(b2j, s) + } + } + + // Purge remaining popular elements + popular := map[string]struct{}{} + n := len(m.b) + if m.autoJunk && n >= 200 { + ntest := n/100 + 1 + for s, indices := range b2j { + if len(indices) > ntest { + popular[s] = struct{}{} + } + } + for s, _ := range popular { + delete(b2j, s) + } + } + m.bPopular = popular + m.b2j = b2j +} + +func (m *SequenceMatcher) isBJunk(s string) bool { + _, ok := m.bJunk[s] + return ok +} + +// Find longest matching block in a[alo:ahi] and b[blo:bhi]. +// +// If IsJunk is not defined: +// +// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where +// alo <= i <= i+k <= ahi +// blo <= j <= j+k <= bhi +// and for all (i',j',k') meeting those conditions, +// k >= k' +// i <= i' +// and if i == i', j <= j' +// +// In other words, of all maximal matching blocks, return one that +// starts earliest in a, and of all those maximal matching blocks that +// start earliest in a, return the one that starts earliest in b. +// +// If IsJunk is defined, first the longest matching block is +// determined as above, but with the additional restriction that no +// junk element appears in the block. Then that block is extended as +// far as possible by matching (only) junk elements on both sides. So +// the resulting block never matches on junk except as identical junk +// happens to be adjacent to an "interesting" match. +// +// If no blocks match, return (alo, blo, 0). +func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match { + // CAUTION: stripping common prefix or suffix would be incorrect. + // E.g., + // ab + // acab + // Longest matching block is "ab", but if common prefix is + // stripped, it's "a" (tied with "b"). UNIX(tm) diff does so + // strip, so ends up claiming that ab is changed to acab by + // inserting "ca" in the middle. That's minimal but unintuitive: + // "it's obvious" that someone inserted "ac" at the front. + // Windiff ends up at the same place as diff, but by pairing up + // the unique 'b's and then matching the first two 'a's. + besti, bestj, bestsize := alo, blo, 0 + + // find longest junk-free match + // during an iteration of the loop, j2len[j] = length of longest + // junk-free match ending with a[i-1] and b[j] + j2len := map[int]int{} + for i := alo; i != ahi; i++ { + // look at all instances of a[i] in b; note that because + // b2j has no junk keys, the loop is skipped if a[i] is junk + newj2len := map[int]int{} + for _, j := range m.b2j[m.a[i]] { + // a[i] matches b[j] + if j < blo { + continue + } + if j >= bhi { + break + } + k := j2len[j-1] + 1 + newj2len[j] = k + if k > bestsize { + besti, bestj, bestsize = i-k+1, j-k+1, k + } + } + j2len = newj2len + } + + // Extend the best by non-junk elements on each end. In particular, + // "popular" non-junk elements aren't in b2j, which greatly speeds + // the inner loop above, but also means "the best" match so far + // doesn't contain any junk *or* popular non-junk elements. + for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) && + m.a[besti-1] == m.b[bestj-1] { + besti, bestj, bestsize = besti-1, bestj-1, bestsize+1 + } + for besti+bestsize < ahi && bestj+bestsize < bhi && + !m.isBJunk(m.b[bestj+bestsize]) && + m.a[besti+bestsize] == m.b[bestj+bestsize] { + bestsize += 1 + } + + // Now that we have a wholly interesting match (albeit possibly + // empty!), we may as well suck up the matching junk on each + // side of it too. Can't think of a good reason not to, and it + // saves post-processing the (possibly considerable) expense of + // figuring out what to do with it. In the case of an empty + // interesting match, this is clearly the right thing to do, + // because no other kind of match is possible in the regions. + for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) && + m.a[besti-1] == m.b[bestj-1] { + besti, bestj, bestsize = besti-1, bestj-1, bestsize+1 + } + for besti+bestsize < ahi && bestj+bestsize < bhi && + m.isBJunk(m.b[bestj+bestsize]) && + m.a[besti+bestsize] == m.b[bestj+bestsize] { + bestsize += 1 + } + + return Match{A: besti, B: bestj, Size: bestsize} +} + +// Return list of triples describing matching subsequences. +// +// Each triple is of the form (i, j, n), and means that +// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in +// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are +// adjacent triples in the list, and the second is not the last triple in the +// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe +// adjacent equal blocks. +// +// The last triple is a dummy, (len(a), len(b), 0), and is the only +// triple with n==0. +func (m *SequenceMatcher) GetMatchingBlocks() []Match { + if m.matchingBlocks != nil { + return m.matchingBlocks + } + + var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match + matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match { + match := m.findLongestMatch(alo, ahi, blo, bhi) + i, j, k := match.A, match.B, match.Size + if match.Size > 0 { + if alo < i && blo < j { + matched = matchBlocks(alo, i, blo, j, matched) + } + matched = append(matched, match) + if i+k < ahi && j+k < bhi { + matched = matchBlocks(i+k, ahi, j+k, bhi, matched) + } + } + return matched + } + matched := matchBlocks(0, len(m.a), 0, len(m.b), nil) + + // It's possible that we have adjacent equal blocks in the + // matching_blocks list now. + nonAdjacent := []Match{} + i1, j1, k1 := 0, 0, 0 + for _, b := range matched { + // Is this block adjacent to i1, j1, k1? + i2, j2, k2 := b.A, b.B, b.Size + if i1+k1 == i2 && j1+k1 == j2 { + // Yes, so collapse them -- this just increases the length of + // the first block by the length of the second, and the first + // block so lengthened remains the block to compare against. + k1 += k2 + } else { + // Not adjacent. Remember the first block (k1==0 means it's + // the dummy we started with), and make the second block the + // new block to compare against. + if k1 > 0 { + nonAdjacent = append(nonAdjacent, Match{i1, j1, k1}) + } + i1, j1, k1 = i2, j2, k2 + } + } + if k1 > 0 { + nonAdjacent = append(nonAdjacent, Match{i1, j1, k1}) + } + + nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0}) + m.matchingBlocks = nonAdjacent + return m.matchingBlocks +} + +// Return list of 5-tuples describing how to turn a into b. +// +// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple +// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the +// tuple preceding it, and likewise for j1 == the previous j2. +// +// The tags are characters, with these meanings: +// +// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2] +// +// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case. +// +// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case. +// +// 'e' (equal): a[i1:i2] == b[j1:j2] +func (m *SequenceMatcher) GetOpCodes() []OpCode { + if m.opCodes != nil { + return m.opCodes + } + i, j := 0, 0 + matching := m.GetMatchingBlocks() + opCodes := make([]OpCode, 0, len(matching)) + for _, m := range matching { + // invariant: we've pumped out correct diffs to change + // a[:i] into b[:j], and the next matching block is + // a[ai:ai+size] == b[bj:bj+size]. So we need to pump + // out a diff to change a[i:ai] into b[j:bj], pump out + // the matching block, and move (i,j) beyond the match + ai, bj, size := m.A, m.B, m.Size + tag := byte(0) + if i < ai && j < bj { + tag = 'r' + } else if i < ai { + tag = 'd' + } else if j < bj { + tag = 'i' + } + if tag > 0 { + opCodes = append(opCodes, OpCode{tag, i, ai, j, bj}) + } + i, j = ai+size, bj+size + // the list of matching blocks is terminated by a + // sentinel with size 0 + if size > 0 { + opCodes = append(opCodes, OpCode{'e', ai, i, bj, j}) + } + } + m.opCodes = opCodes + return m.opCodes +} + +// Isolate change clusters by eliminating ranges with no changes. +// +// Return a generator of groups with up to n lines of context. +// Each group is in the same format as returned by GetOpCodes(). +func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode { + if n < 0 { + n = 3 + } + codes := m.GetOpCodes() + if len(codes) == 0 { + codes = []OpCode{OpCode{'e', 0, 1, 0, 1}} + } + // Fixup leading and trailing groups if they show no changes. + if codes[0].Tag == 'e' { + c := codes[0] + i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 + codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2} + } + if codes[len(codes)-1].Tag == 'e' { + c := codes[len(codes)-1] + i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 + codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)} + } + nn := n + n + groups := [][]OpCode{} + group := []OpCode{} + for _, c := range codes { + i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 + // End the current group and start a new one whenever + // there is a large range with no changes. + if c.Tag == 'e' && i2-i1 > nn { + group = append(group, OpCode{c.Tag, i1, min(i2, i1+n), + j1, min(j2, j1+n)}) + groups = append(groups, group) + group = []OpCode{} + i1, j1 = max(i1, i2-n), max(j1, j2-n) + } + group = append(group, OpCode{c.Tag, i1, i2, j1, j2}) + } + if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') { + groups = append(groups, group) + } + return groups +} + +// Return a measure of the sequences' similarity (float in [0,1]). +// +// Where T is the total number of elements in both sequences, and +// M is the number of matches, this is 2.0*M / T. +// Note that this is 1 if the sequences are identical, and 0 if +// they have nothing in common. +// +// .Ratio() is expensive to compute if you haven't already computed +// .GetMatchingBlocks() or .GetOpCodes(), in which case you may +// want to try .QuickRatio() or .RealQuickRation() first to get an +// upper bound. +func (m *SequenceMatcher) Ratio() float64 { + matches := 0 + for _, m := range m.GetMatchingBlocks() { + matches += m.Size + } + return calculateRatio(matches, len(m.a)+len(m.b)) +} + +// Return an upper bound on ratio() relatively quickly. +// +// This isn't defined beyond that it is an upper bound on .Ratio(), and +// is faster to compute. +func (m *SequenceMatcher) QuickRatio() float64 { + // viewing a and b as multisets, set matches to the cardinality + // of their intersection; this counts the number of matches + // without regard to order, so is clearly an upper bound + if m.fullBCount == nil { + m.fullBCount = map[string]int{} + for _, s := range m.b { + m.fullBCount[s] = m.fullBCount[s] + 1 + } + } + + // avail[x] is the number of times x appears in 'b' less the + // number of times we've seen it in 'a' so far ... kinda + avail := map[string]int{} + matches := 0 + for _, s := range m.a { + n, ok := avail[s] + if !ok { + n = m.fullBCount[s] + } + avail[s] = n - 1 + if n > 0 { + matches += 1 + } + } + return calculateRatio(matches, len(m.a)+len(m.b)) +} + +// Return an upper bound on ratio() very quickly. +// +// This isn't defined beyond that it is an upper bound on .Ratio(), and +// is faster to compute than either .Ratio() or .QuickRatio(). +func (m *SequenceMatcher) RealQuickRatio() float64 { + la, lb := len(m.a), len(m.b) + return calculateRatio(min(la, lb), la+lb) +} + +// Convert range to the "ed" format +func formatRangeUnified(start, stop int) string { + // Per the diff spec at http://www.unix.org/single_unix_specification/ + beginning := start + 1 // lines start numbering with one + length := stop - start + if length == 1 { + return fmt.Sprintf("%d", beginning) + } + if length == 0 { + beginning -= 1 // empty ranges begin at line just before the range + } + return fmt.Sprintf("%d,%d", beginning, length) +} + +// Unified diff parameters +type UnifiedDiff struct { + A []string // First sequence lines + FromFile string // First file name + FromDate string // First file time + B []string // Second sequence lines + ToFile string // Second file name + ToDate string // Second file time + Eol string // Headers end of line, defaults to LF + Context int // Number of context lines +} + +// Compare two sequences of lines; generate the delta as a unified diff. +// +// Unified diffs are a compact way of showing line changes and a few +// lines of context. The number of context lines is set by 'n' which +// defaults to three. +// +// By default, the diff control lines (those with ---, +++, or @@) are +// created with a trailing newline. This is helpful so that inputs +// created from file.readlines() result in diffs that are suitable for +// file.writelines() since both the inputs and outputs have trailing +// newlines. +// +// For inputs that do not have trailing newlines, set the lineterm +// argument to "" so that the output will be uniformly newline free. +// +// The unidiff format normally has a header for filenames and modification +// times. Any or all of these may be specified using strings for +// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'. +// The modification times are normally expressed in the ISO 8601 format. +func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error { + buf := bufio.NewWriter(writer) + defer buf.Flush() + wf := func(format string, args ...interface{}) error { + _, err := buf.WriteString(fmt.Sprintf(format, args...)) + return err + } + ws := func(s string) error { + _, err := buf.WriteString(s) + return err + } + + if len(diff.Eol) == 0 { + diff.Eol = "\n" + } + + started := false + m := NewMatcher(diff.A, diff.B) + for _, g := range m.GetGroupedOpCodes(diff.Context) { + if !started { + started = true + fromDate := "" + if len(diff.FromDate) > 0 { + fromDate = "\t" + diff.FromDate + } + toDate := "" + if len(diff.ToDate) > 0 { + toDate = "\t" + diff.ToDate + } + if diff.FromFile != "" || diff.ToFile != "" { + err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol) + if err != nil { + return err + } + err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol) + if err != nil { + return err + } + } + } + first, last := g[0], g[len(g)-1] + range1 := formatRangeUnified(first.I1, last.I2) + range2 := formatRangeUnified(first.J1, last.J2) + if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil { + return err + } + for _, c := range g { + i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 + if c.Tag == 'e' { + for _, line := range diff.A[i1:i2] { + if err := ws(" " + line); err != nil { + return err + } + } + continue + } + if c.Tag == 'r' || c.Tag == 'd' { + for _, line := range diff.A[i1:i2] { + if err := ws("-" + line); err != nil { + return err + } + } + } + if c.Tag == 'r' || c.Tag == 'i' { + for _, line := range diff.B[j1:j2] { + if err := ws("+" + line); err != nil { + return err + } + } + } + } + } + return nil +} + +// Like WriteUnifiedDiff but returns the diff a string. +func GetUnifiedDiffString(diff UnifiedDiff) (string, error) { + w := &bytes.Buffer{} + err := WriteUnifiedDiff(w, diff) + return string(w.Bytes()), err +} + +// Convert range to the "ed" format. +func formatRangeContext(start, stop int) string { + // Per the diff spec at http://www.unix.org/single_unix_specification/ + beginning := start + 1 // lines start numbering with one + length := stop - start + if length == 0 { + beginning -= 1 // empty ranges begin at line just before the range + } + if length <= 1 { + return fmt.Sprintf("%d", beginning) + } + return fmt.Sprintf("%d,%d", beginning, beginning+length-1) +} + +type ContextDiff UnifiedDiff + +// Compare two sequences of lines; generate the delta as a context diff. +// +// Context diffs are a compact way of showing line changes and a few +// lines of context. The number of context lines is set by diff.Context +// which defaults to three. +// +// By default, the diff control lines (those with *** or ---) are +// created with a trailing newline. +// +// For inputs that do not have trailing newlines, set the diff.Eol +// argument to "" so that the output will be uniformly newline free. +// +// The context diff format normally has a header for filenames and +// modification times. Any or all of these may be specified using +// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate. +// The modification times are normally expressed in the ISO 8601 format. +// If not specified, the strings default to blanks. +func WriteContextDiff(writer io.Writer, diff ContextDiff) error { + buf := bufio.NewWriter(writer) + defer buf.Flush() + var diffErr error + wf := func(format string, args ...interface{}) { + _, err := buf.WriteString(fmt.Sprintf(format, args...)) + if diffErr == nil && err != nil { + diffErr = err + } + } + ws := func(s string) { + _, err := buf.WriteString(s) + if diffErr == nil && err != nil { + diffErr = err + } + } + + if len(diff.Eol) == 0 { + diff.Eol = "\n" + } + + prefix := map[byte]string{ + 'i': "+ ", + 'd': "- ", + 'r': "! ", + 'e': " ", + } + + started := false + m := NewMatcher(diff.A, diff.B) + for _, g := range m.GetGroupedOpCodes(diff.Context) { + if !started { + started = true + fromDate := "" + if len(diff.FromDate) > 0 { + fromDate = "\t" + diff.FromDate + } + toDate := "" + if len(diff.ToDate) > 0 { + toDate = "\t" + diff.ToDate + } + if diff.FromFile != "" || diff.ToFile != "" { + wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol) + wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol) + } + } + + first, last := g[0], g[len(g)-1] + ws("***************" + diff.Eol) + + range1 := formatRangeContext(first.I1, last.I2) + wf("*** %s ****%s", range1, diff.Eol) + for _, c := range g { + if c.Tag == 'r' || c.Tag == 'd' { + for _, cc := range g { + if cc.Tag == 'i' { + continue + } + for _, line := range diff.A[cc.I1:cc.I2] { + ws(prefix[cc.Tag] + line) + } + } + break + } + } + + range2 := formatRangeContext(first.J1, last.J2) + wf("--- %s ----%s", range2, diff.Eol) + for _, c := range g { + if c.Tag == 'r' || c.Tag == 'i' { + for _, cc := range g { + if cc.Tag == 'd' { + continue + } + for _, line := range diff.B[cc.J1:cc.J2] { + ws(prefix[cc.Tag] + line) + } + } + break + } + } + } + return diffErr +} + +// Like WriteContextDiff but returns the diff a string. +func GetContextDiffString(diff ContextDiff) (string, error) { + w := &bytes.Buffer{} + err := WriteContextDiff(w, diff) + return string(w.Bytes()), err +} + +// Split a string on "\n" while preserving them. The output can be used +// as input for UnifiedDiff and ContextDiff structures. +func SplitLines(s string) []string { + lines := strings.SplitAfter(s, "\n") + lines[len(lines)-1] += "\n" + return lines +} diff --git a/vendor/github.com/stretchr/testify/LICENSE b/vendor/github.com/stretchr/testify/LICENSE new file mode 100644 index 000000000..473b670a7 --- /dev/null +++ b/vendor/github.com/stretchr/testify/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell + +Please consider promoting this project if you find it useful. + +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/stretchr/testify/assert/assertion_format.go b/vendor/github.com/stretchr/testify/assert/assertion_format.go new file mode 100644 index 000000000..aa1c2b95c --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go @@ -0,0 +1,484 @@ +/* +* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +* THIS FILE MUST NOT BE EDITED BY HAND + */ + +package assert + +import ( + http "net/http" + url "net/url" + time "time" +) + +// Conditionf uses a Comparison to assert a complex condition. +func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Condition(t, comp, append([]interface{}{msg}, args...)...) +} + +// Containsf asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") +// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") +// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") +func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Contains(t, s, contains, append([]interface{}{msg}, args...)...) +} + +// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. +func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return DirExists(t, path, append([]interface{}{msg}, args...)...) +} + +// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified +// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, +// the number of appearances of each of them in both lists should match. +// +// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") +func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...) +} + +// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// assert.Emptyf(t, obj, "error message %s", "formatted") +func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Empty(t, object, append([]interface{}{msg}, args...)...) +} + +// Equalf asserts that two objects are equal. +// +// assert.Equalf(t, 123, 123, "error message %s", "formatted") +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). Function equality +// cannot be determined and will always fail. +func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Equal(t, expected, actual, append([]interface{}{msg}, args...)...) +} + +// EqualErrorf asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") +func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...) +} + +// EqualValuesf asserts that two objects are equal or convertable to the same types +// and equal. +// +// assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) +func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...) +} + +// Errorf asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if assert.Errorf(t, err, "error message %s", "formatted") { +// assert.Equal(t, expectedErrorf, err) +// } +func Errorf(t TestingT, err error, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Error(t, err, append([]interface{}{msg}, args...)...) +} + +// Exactlyf asserts that two objects are equal in value and type. +// +// assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) +func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...) +} + +// Failf reports a failure through +func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Fail(t, failureMessage, append([]interface{}{msg}, args...)...) +} + +// FailNowf fails test +func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...) +} + +// Falsef asserts that the specified value is false. +// +// assert.Falsef(t, myBool, "error message %s", "formatted") +func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return False(t, value, append([]interface{}{msg}, args...)...) +} + +// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. +func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return FileExists(t, path, append([]interface{}{msg}, args...)...) +} + +// HTTPBodyContainsf asserts that a specified handler returns a +// body that contains a string. +// +// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) +} + +// HTTPBodyNotContainsf asserts that a specified handler returns a +// body that does not contain a string. +// +// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) +} + +// HTTPErrorf asserts that a specified handler returns an error status code. +// +// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). +func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...) +} + +// HTTPRedirectf asserts that a specified handler returns a redirect status code. +// +// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). +func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...) +} + +// HTTPSuccessf asserts that a specified handler returns a success status code. +// +// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...) +} + +// Implementsf asserts that an object is implemented by the specified interface. +// +// assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) +func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...) +} + +// InDeltaf asserts that the two numerals are within delta of each other. +// +// assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) +func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...) +} + +// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. +func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...) +} + +// InDeltaSlicef is the same as InDelta, except it compares two slices. +func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...) +} + +// InEpsilonf asserts that expected and actual have a relative error less than epsilon +func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) +} + +// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. +func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) +} + +// IsTypef asserts that the specified objects are of the same type. +func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...) +} + +// JSONEqf asserts that two JSON strings are equivalent. +// +// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") +func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...) +} + +// Lenf asserts that the specified object has specific length. +// Lenf also fails if the object has a type that len() not accept. +// +// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") +func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Len(t, object, length, append([]interface{}{msg}, args...)...) +} + +// Nilf asserts that the specified object is nil. +// +// assert.Nilf(t, err, "error message %s", "formatted") +func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Nil(t, object, append([]interface{}{msg}, args...)...) +} + +// NoErrorf asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if assert.NoErrorf(t, err, "error message %s", "formatted") { +// assert.Equal(t, expectedObj, actualObj) +// } +func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NoError(t, err, append([]interface{}{msg}, args...)...) +} + +// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") +// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") +// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") +func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotContains(t, s, contains, append([]interface{}{msg}, args...)...) +} + +// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { +// assert.Equal(t, "two", obj[1]) +// } +func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotEmpty(t, object, append([]interface{}{msg}, args...)...) +} + +// NotEqualf asserts that the specified values are NOT equal. +// +// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...) +} + +// NotNilf asserts that the specified object is not nil. +// +// assert.NotNilf(t, err, "error message %s", "formatted") +func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotNil(t, object, append([]interface{}{msg}, args...)...) +} + +// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") +func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotPanics(t, f, append([]interface{}{msg}, args...)...) +} + +// NotRegexpf asserts that a specified regexp does not match a string. +// +// assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") +// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") +func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...) +} + +// NotSubsetf asserts that the specified list(array, slice...) contains not all +// elements given in the specified subset(array, slice...). +// +// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") +func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...) +} + +// NotZerof asserts that i is not the zero value for its type. +func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return NotZero(t, i, append([]interface{}{msg}, args...)...) +} + +// Panicsf asserts that the code inside the specified PanicTestFunc panics. +// +// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") +func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Panics(t, f, append([]interface{}{msg}, args...)...) +} + +// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that +// the recovered panic value equals the expected panic value. +// +// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...) +} + +// Regexpf asserts that a specified regexp matches a string. +// +// assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") +// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") +func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Regexp(t, rx, str, append([]interface{}{msg}, args...)...) +} + +// Subsetf asserts that the specified list(array, slice...) contains all +// elements given in the specified subset(array, slice...). +// +// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") +func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Subset(t, list, subset, append([]interface{}{msg}, args...)...) +} + +// Truef asserts that the specified value is true. +// +// assert.Truef(t, myBool, "error message %s", "formatted") +func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return True(t, value, append([]interface{}{msg}, args...)...) +} + +// WithinDurationf asserts that the two times are within duration delta of each other. +// +// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") +func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...) +} + +// Zerof asserts that i is the zero value for its type. +func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + return Zero(t, i, append([]interface{}{msg}, args...)...) +} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl b/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl new file mode 100644 index 000000000..d2bb0b817 --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl @@ -0,0 +1,5 @@ +{{.CommentFormat}} +func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { + if h, ok := t.(tHelper); ok { h.Helper() } + return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) +} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go new file mode 100644 index 000000000..de39f794e --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go @@ -0,0 +1,956 @@ +/* +* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +* THIS FILE MUST NOT BE EDITED BY HAND + */ + +package assert + +import ( + http "net/http" + url "net/url" + time "time" +) + +// Condition uses a Comparison to assert a complex condition. +func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Condition(a.t, comp, msgAndArgs...) +} + +// Conditionf uses a Comparison to assert a complex condition. +func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Conditionf(a.t, comp, msg, args...) +} + +// Contains asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// a.Contains("Hello World", "World") +// a.Contains(["Hello", "World"], "World") +// a.Contains({"Hello": "World"}, "Hello") +func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Contains(a.t, s, contains, msgAndArgs...) +} + +// Containsf asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// a.Containsf("Hello World", "World", "error message %s", "formatted") +// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") +// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") +func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Containsf(a.t, s, contains, msg, args...) +} + +// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. +func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return DirExists(a.t, path, msgAndArgs...) +} + +// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. +func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return DirExistsf(a.t, path, msg, args...) +} + +// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified +// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, +// the number of appearances of each of them in both lists should match. +// +// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) +func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return ElementsMatch(a.t, listA, listB, msgAndArgs...) +} + +// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified +// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, +// the number of appearances of each of them in both lists should match. +// +// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") +func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return ElementsMatchf(a.t, listA, listB, msg, args...) +} + +// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// a.Empty(obj) +func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Empty(a.t, object, msgAndArgs...) +} + +// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// a.Emptyf(obj, "error message %s", "formatted") +func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Emptyf(a.t, object, msg, args...) +} + +// Equal asserts that two objects are equal. +// +// a.Equal(123, 123) +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). Function equality +// cannot be determined and will always fail. +func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Equal(a.t, expected, actual, msgAndArgs...) +} + +// EqualError asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// a.EqualError(err, expectedErrorString) +func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualError(a.t, theError, errString, msgAndArgs...) +} + +// EqualErrorf asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") +func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualErrorf(a.t, theError, errString, msg, args...) +} + +// EqualValues asserts that two objects are equal or convertable to the same types +// and equal. +// +// a.EqualValues(uint32(123), int32(123)) +func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualValues(a.t, expected, actual, msgAndArgs...) +} + +// EqualValuesf asserts that two objects are equal or convertable to the same types +// and equal. +// +// a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) +func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return EqualValuesf(a.t, expected, actual, msg, args...) +} + +// Equalf asserts that two objects are equal. +// +// a.Equalf(123, 123, "error message %s", "formatted") +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). Function equality +// cannot be determined and will always fail. +func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Equalf(a.t, expected, actual, msg, args...) +} + +// Error asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if a.Error(err) { +// assert.Equal(t, expectedError, err) +// } +func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Error(a.t, err, msgAndArgs...) +} + +// Errorf asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if a.Errorf(err, "error message %s", "formatted") { +// assert.Equal(t, expectedErrorf, err) +// } +func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Errorf(a.t, err, msg, args...) +} + +// Exactly asserts that two objects are equal in value and type. +// +// a.Exactly(int32(123), int64(123)) +func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Exactly(a.t, expected, actual, msgAndArgs...) +} + +// Exactlyf asserts that two objects are equal in value and type. +// +// a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) +func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Exactlyf(a.t, expected, actual, msg, args...) +} + +// Fail reports a failure through +func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Fail(a.t, failureMessage, msgAndArgs...) +} + +// FailNow fails test +func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return FailNow(a.t, failureMessage, msgAndArgs...) +} + +// FailNowf fails test +func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return FailNowf(a.t, failureMessage, msg, args...) +} + +// Failf reports a failure through +func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Failf(a.t, failureMessage, msg, args...) +} + +// False asserts that the specified value is false. +// +// a.False(myBool) +func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return False(a.t, value, msgAndArgs...) +} + +// Falsef asserts that the specified value is false. +// +// a.Falsef(myBool, "error message %s", "formatted") +func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Falsef(a.t, value, msg, args...) +} + +// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. +func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return FileExists(a.t, path, msgAndArgs...) +} + +// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. +func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return FileExistsf(a.t, path, msg, args...) +} + +// HTTPBodyContains asserts that a specified handler returns a +// body that contains a string. +// +// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) +} + +// HTTPBodyContainsf asserts that a specified handler returns a +// body that contains a string. +// +// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) +} + +// HTTPBodyNotContains asserts that a specified handler returns a +// body that does not contain a string. +// +// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) +} + +// HTTPBodyNotContainsf asserts that a specified handler returns a +// body that does not contain a string. +// +// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) +} + +// HTTPError asserts that a specified handler returns an error status code. +// +// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPError(a.t, handler, method, url, values, msgAndArgs...) +} + +// HTTPErrorf asserts that a specified handler returns an error status code. +// +// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). +func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPErrorf(a.t, handler, method, url, values, msg, args...) +} + +// HTTPRedirect asserts that a specified handler returns a redirect status code. +// +// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) +} + +// HTTPRedirectf asserts that a specified handler returns a redirect status code. +// +// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). +func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPRedirectf(a.t, handler, method, url, values, msg, args...) +} + +// HTTPSuccess asserts that a specified handler returns a success status code. +// +// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) +} + +// HTTPSuccessf asserts that a specified handler returns a success status code. +// +// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return HTTPSuccessf(a.t, handler, method, url, values, msg, args...) +} + +// Implements asserts that an object is implemented by the specified interface. +// +// a.Implements((*MyInterface)(nil), new(MyObject)) +func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Implements(a.t, interfaceObject, object, msgAndArgs...) +} + +// Implementsf asserts that an object is implemented by the specified interface. +// +// a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) +func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Implementsf(a.t, interfaceObject, object, msg, args...) +} + +// InDelta asserts that the two numerals are within delta of each other. +// +// a.InDelta(math.Pi, (22 / 7.0), 0.01) +func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDelta(a.t, expected, actual, delta, msgAndArgs...) +} + +// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. +func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) +} + +// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. +func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) +} + +// InDeltaSlice is the same as InDelta, except it compares two slices. +func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) +} + +// InDeltaSlicef is the same as InDelta, except it compares two slices. +func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDeltaSlicef(a.t, expected, actual, delta, msg, args...) +} + +// InDeltaf asserts that the two numerals are within delta of each other. +// +// a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) +func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InDeltaf(a.t, expected, actual, delta, msg, args...) +} + +// InEpsilon asserts that expected and actual have a relative error less than epsilon +func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) +} + +// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. +func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) +} + +// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. +func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...) +} + +// InEpsilonf asserts that expected and actual have a relative error less than epsilon +func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return InEpsilonf(a.t, expected, actual, epsilon, msg, args...) +} + +// IsType asserts that the specified objects are of the same type. +func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return IsType(a.t, expectedType, object, msgAndArgs...) +} + +// IsTypef asserts that the specified objects are of the same type. +func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return IsTypef(a.t, expectedType, object, msg, args...) +} + +// JSONEq asserts that two JSON strings are equivalent. +// +// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return JSONEq(a.t, expected, actual, msgAndArgs...) +} + +// JSONEqf asserts that two JSON strings are equivalent. +// +// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") +func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return JSONEqf(a.t, expected, actual, msg, args...) +} + +// Len asserts that the specified object has specific length. +// Len also fails if the object has a type that len() not accept. +// +// a.Len(mySlice, 3) +func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Len(a.t, object, length, msgAndArgs...) +} + +// Lenf asserts that the specified object has specific length. +// Lenf also fails if the object has a type that len() not accept. +// +// a.Lenf(mySlice, 3, "error message %s", "formatted") +func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Lenf(a.t, object, length, msg, args...) +} + +// Nil asserts that the specified object is nil. +// +// a.Nil(err) +func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Nil(a.t, object, msgAndArgs...) +} + +// Nilf asserts that the specified object is nil. +// +// a.Nilf(err, "error message %s", "formatted") +func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Nilf(a.t, object, msg, args...) +} + +// NoError asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if a.NoError(err) { +// assert.Equal(t, expectedObj, actualObj) +// } +func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NoError(a.t, err, msgAndArgs...) +} + +// NoErrorf asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if a.NoErrorf(err, "error message %s", "formatted") { +// assert.Equal(t, expectedObj, actualObj) +// } +func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NoErrorf(a.t, err, msg, args...) +} + +// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// a.NotContains("Hello World", "Earth") +// a.NotContains(["Hello", "World"], "Earth") +// a.NotContains({"Hello": "World"}, "Earth") +func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotContains(a.t, s, contains, msgAndArgs...) +} + +// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") +// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") +// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") +func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotContainsf(a.t, s, contains, msg, args...) +} + +// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if a.NotEmpty(obj) { +// assert.Equal(t, "two", obj[1]) +// } +func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotEmpty(a.t, object, msgAndArgs...) +} + +// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if a.NotEmptyf(obj, "error message %s", "formatted") { +// assert.Equal(t, "two", obj[1]) +// } +func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotEmptyf(a.t, object, msg, args...) +} + +// NotEqual asserts that the specified values are NOT equal. +// +// a.NotEqual(obj1, obj2) +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotEqual(a.t, expected, actual, msgAndArgs...) +} + +// NotEqualf asserts that the specified values are NOT equal. +// +// a.NotEqualf(obj1, obj2, "error message %s", "formatted") +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotEqualf(a.t, expected, actual, msg, args...) +} + +// NotNil asserts that the specified object is not nil. +// +// a.NotNil(err) +func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotNil(a.t, object, msgAndArgs...) +} + +// NotNilf asserts that the specified object is not nil. +// +// a.NotNilf(err, "error message %s", "formatted") +func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotNilf(a.t, object, msg, args...) +} + +// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// a.NotPanics(func(){ RemainCalm() }) +func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotPanics(a.t, f, msgAndArgs...) +} + +// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") +func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotPanicsf(a.t, f, msg, args...) +} + +// NotRegexp asserts that a specified regexp does not match a string. +// +// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") +// a.NotRegexp("^start", "it's not starting") +func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotRegexp(a.t, rx, str, msgAndArgs...) +} + +// NotRegexpf asserts that a specified regexp does not match a string. +// +// a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") +// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") +func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotRegexpf(a.t, rx, str, msg, args...) +} + +// NotSubset asserts that the specified list(array, slice...) contains not all +// elements given in the specified subset(array, slice...). +// +// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") +func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotSubset(a.t, list, subset, msgAndArgs...) +} + +// NotSubsetf asserts that the specified list(array, slice...) contains not all +// elements given in the specified subset(array, slice...). +// +// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") +func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotSubsetf(a.t, list, subset, msg, args...) +} + +// NotZero asserts that i is not the zero value for its type. +func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotZero(a.t, i, msgAndArgs...) +} + +// NotZerof asserts that i is not the zero value for its type. +func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return NotZerof(a.t, i, msg, args...) +} + +// Panics asserts that the code inside the specified PanicTestFunc panics. +// +// a.Panics(func(){ GoCrazy() }) +func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Panics(a.t, f, msgAndArgs...) +} + +// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that +// the recovered panic value equals the expected panic value. +// +// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) +func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return PanicsWithValue(a.t, expected, f, msgAndArgs...) +} + +// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that +// the recovered panic value equals the expected panic value. +// +// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") +func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return PanicsWithValuef(a.t, expected, f, msg, args...) +} + +// Panicsf asserts that the code inside the specified PanicTestFunc panics. +// +// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") +func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Panicsf(a.t, f, msg, args...) +} + +// Regexp asserts that a specified regexp matches a string. +// +// a.Regexp(regexp.MustCompile("start"), "it's starting") +// a.Regexp("start...$", "it's not starting") +func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Regexp(a.t, rx, str, msgAndArgs...) +} + +// Regexpf asserts that a specified regexp matches a string. +// +// a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") +// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") +func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Regexpf(a.t, rx, str, msg, args...) +} + +// Subset asserts that the specified list(array, slice...) contains all +// elements given in the specified subset(array, slice...). +// +// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") +func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Subset(a.t, list, subset, msgAndArgs...) +} + +// Subsetf asserts that the specified list(array, slice...) contains all +// elements given in the specified subset(array, slice...). +// +// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") +func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Subsetf(a.t, list, subset, msg, args...) +} + +// True asserts that the specified value is true. +// +// a.True(myBool) +func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return True(a.t, value, msgAndArgs...) +} + +// Truef asserts that the specified value is true. +// +// a.Truef(myBool, "error message %s", "formatted") +func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Truef(a.t, value, msg, args...) +} + +// WithinDuration asserts that the two times are within duration delta of each other. +// +// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) +func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return WithinDuration(a.t, expected, actual, delta, msgAndArgs...) +} + +// WithinDurationf asserts that the two times are within duration delta of each other. +// +// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") +func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return WithinDurationf(a.t, expected, actual, delta, msg, args...) +} + +// Zero asserts that i is the zero value for its type. +func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Zero(a.t, i, msgAndArgs...) +} + +// Zerof asserts that i is the zero value for its type. +func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool { + if h, ok := a.t.(tHelper); ok { + h.Helper() + } + return Zerof(a.t, i, msg, args...) +} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl b/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl new file mode 100644 index 000000000..188bb9e17 --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl @@ -0,0 +1,5 @@ +{{.CommentWithoutT "a"}} +func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { + if h, ok := a.t.(tHelper); ok { h.Helper() } + return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) +} diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go new file mode 100644 index 000000000..5bdec56cd --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/assertions.go @@ -0,0 +1,1394 @@ +package assert + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "fmt" + "math" + "os" + "reflect" + "regexp" + "runtime" + "strings" + "time" + "unicode" + "unicode/utf8" + + "github.com/davecgh/go-spew/spew" + "github.com/pmezard/go-difflib/difflib" +) + +//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_format.go.tmpl + +// TestingT is an interface wrapper around *testing.T +type TestingT interface { + Errorf(format string, args ...interface{}) +} + +// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful +// for table driven tests. +type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool + +// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful +// for table driven tests. +type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool + +// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful +// for table driven tests. +type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool + +// ValuesAssertionFunc is a common function prototype when validating an error value. Can be useful +// for table driven tests. +type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool + +// Comparison a custom function that returns true on success and false on failure +type Comparison func() (success bool) + +/* + Helper functions +*/ + +// ObjectsAreEqual determines if two objects are considered equal. +// +// This function does no assertion of any kind. +func ObjectsAreEqual(expected, actual interface{}) bool { + if expected == nil || actual == nil { + return expected == actual + } + + exp, ok := expected.([]byte) + if !ok { + return reflect.DeepEqual(expected, actual) + } + + act, ok := actual.([]byte) + if !ok { + return false + } + if exp == nil || act == nil { + return exp == nil && act == nil + } + return bytes.Equal(exp, act) +} + +// ObjectsAreEqualValues gets whether two objects are equal, or if their +// values are equal. +func ObjectsAreEqualValues(expected, actual interface{}) bool { + if ObjectsAreEqual(expected, actual) { + return true + } + + actualType := reflect.TypeOf(actual) + if actualType == nil { + return false + } + expectedValue := reflect.ValueOf(expected) + if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) { + // Attempt comparison after type conversion + return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual) + } + + return false +} + +/* CallerInfo is necessary because the assert functions use the testing object +internally, causing it to print the file:line of the assert method, rather than where +the problem actually occurred in calling code.*/ + +// CallerInfo returns an array of strings containing the file and line number +// of each stack frame leading from the current test to the assert call that +// failed. +func CallerInfo() []string { + + pc := uintptr(0) + file := "" + line := 0 + ok := false + name := "" + + callers := []string{} + for i := 0; ; i++ { + pc, file, line, ok = runtime.Caller(i) + if !ok { + // The breaks below failed to terminate the loop, and we ran off the + // end of the call stack. + break + } + + // This is a huge edge case, but it will panic if this is the case, see #180 + if file == "" { + break + } + + f := runtime.FuncForPC(pc) + if f == nil { + break + } + name = f.Name() + + // testing.tRunner is the standard library function that calls + // tests. Subtests are called directly by tRunner, without going through + // the Test/Benchmark/Example function that contains the t.Run calls, so + // with subtests we should break when we hit tRunner, without adding it + // to the list of callers. + if name == "testing.tRunner" { + break + } + + parts := strings.Split(file, "/") + file = parts[len(parts)-1] + if len(parts) > 1 { + dir := parts[len(parts)-2] + if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" { + callers = append(callers, fmt.Sprintf("%s:%d", file, line)) + } + } + + // Drop the package + segments := strings.Split(name, ".") + name = segments[len(segments)-1] + if isTest(name, "Test") || + isTest(name, "Benchmark") || + isTest(name, "Example") { + break + } + } + + return callers +} + +// Stolen from the `go test` tool. +// isTest tells whether name looks like a test (or benchmark, according to prefix). +// It is a Test (say) if there is a character after Test that is not a lower-case letter. +// We don't want TesticularCancer. +func isTest(name, prefix string) bool { + if !strings.HasPrefix(name, prefix) { + return false + } + if len(name) == len(prefix) { // "Test" is ok + return true + } + rune, _ := utf8.DecodeRuneInString(name[len(prefix):]) + return !unicode.IsLower(rune) +} + +func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { + if len(msgAndArgs) == 0 || msgAndArgs == nil { + return "" + } + if len(msgAndArgs) == 1 { + return msgAndArgs[0].(string) + } + if len(msgAndArgs) > 1 { + return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) + } + return "" +} + +// Aligns the provided message so that all lines after the first line start at the same location as the first line. +// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). +// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the +// basis on which the alignment occurs). +func indentMessageLines(message string, longestLabelLen int) string { + outBuf := new(bytes.Buffer) + + for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { + // no need to align first line because it starts at the correct location (after the label) + if i != 0 { + // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab + outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t") + } + outBuf.WriteString(scanner.Text()) + } + + return outBuf.String() +} + +type failNower interface { + FailNow() +} + +// FailNow fails test +func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + Fail(t, failureMessage, msgAndArgs...) + + // We cannot extend TestingT with FailNow() and + // maintain backwards compatibility, so we fallback + // to panicking when FailNow is not available in + // TestingT. + // See issue #263 + + if t, ok := t.(failNower); ok { + t.FailNow() + } else { + panic("test failed and t is missing `FailNow()`") + } + return false +} + +// Fail reports a failure through +func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + content := []labeledContent{ + {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")}, + {"Error", failureMessage}, + } + + // Add test name if the Go version supports it + if n, ok := t.(interface { + Name() string + }); ok { + content = append(content, labeledContent{"Test", n.Name()}) + } + + message := messageFromMsgAndArgs(msgAndArgs...) + if len(message) > 0 { + content = append(content, labeledContent{"Messages", message}) + } + + t.Errorf("\n%s", ""+labeledOutput(content...)) + + return false +} + +type labeledContent struct { + label string + content string +} + +// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: +// +// \t{{label}}:{{align_spaces}}\t{{content}}\n +// +// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. +// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this +// alignment is achieved, "\t{{content}}\n" is added for the output. +// +// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line. +func labeledOutput(content ...labeledContent) string { + longestLabel := 0 + for _, v := range content { + if len(v.label) > longestLabel { + longestLabel = len(v.label) + } + } + var output string + for _, v := range content { + output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" + } + return output +} + +// Implements asserts that an object is implemented by the specified interface. +// +// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) +func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + interfaceType := reflect.TypeOf(interfaceObject).Elem() + + if object == nil { + return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...) + } + if !reflect.TypeOf(object).Implements(interfaceType) { + return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...) + } + + return true +} + +// IsType asserts that the specified objects are of the same type. +func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) { + return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...) + } + + return true +} + +// Equal asserts that two objects are equal. +// +// assert.Equal(t, 123, 123) +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). Function equality +// cannot be determined and will always fail. +func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if err := validateEqualArgs(expected, actual); err != nil { + return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)", + expected, actual, err), msgAndArgs...) + } + + if !ObjectsAreEqual(expected, actual) { + diff := diff(expected, actual) + expected, actual = formatUnequalValues(expected, actual) + return Fail(t, fmt.Sprintf("Not equal: \n"+ + "expected: %s\n"+ + "actual : %s%s", expected, actual, diff), msgAndArgs...) + } + + return true + +} + +// formatUnequalValues takes two values of arbitrary types and returns string +// representations appropriate to be presented to the user. +// +// If the values are not of like type, the returned strings will be prefixed +// with the type name, and the value will be enclosed in parenthesis similar +// to a type conversion in the Go grammar. +func formatUnequalValues(expected, actual interface{}) (e string, a string) { + if reflect.TypeOf(expected) != reflect.TypeOf(actual) { + return fmt.Sprintf("%T(%#v)", expected, expected), + fmt.Sprintf("%T(%#v)", actual, actual) + } + + return fmt.Sprintf("%#v", expected), + fmt.Sprintf("%#v", actual) +} + +// EqualValues asserts that two objects are equal or convertable to the same types +// and equal. +// +// assert.EqualValues(t, uint32(123), int32(123)) +func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if !ObjectsAreEqualValues(expected, actual) { + diff := diff(expected, actual) + expected, actual = formatUnequalValues(expected, actual) + return Fail(t, fmt.Sprintf("Not equal: \n"+ + "expected: %s\n"+ + "actual : %s%s", expected, actual, diff), msgAndArgs...) + } + + return true + +} + +// Exactly asserts that two objects are equal in value and type. +// +// assert.Exactly(t, int32(123), int64(123)) +func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + aType := reflect.TypeOf(expected) + bType := reflect.TypeOf(actual) + + if aType != bType { + return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) + } + + return Equal(t, expected, actual, msgAndArgs...) + +} + +// NotNil asserts that the specified object is not nil. +// +// assert.NotNil(t, err) +func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if !isNil(object) { + return true + } + return Fail(t, "Expected value not to be nil.", msgAndArgs...) +} + +// isNil checks if a specified object is nil or not, without Failing. +func isNil(object interface{}) bool { + if object == nil { + return true + } + + value := reflect.ValueOf(object) + kind := value.Kind() + if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() { + return true + } + + return false +} + +// Nil asserts that the specified object is nil. +// +// assert.Nil(t, err) +func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if isNil(object) { + return true + } + return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...) +} + +// isEmpty gets whether the specified object is considered empty or not. +func isEmpty(object interface{}) bool { + + // get nil case out of the way + if object == nil { + return true + } + + objValue := reflect.ValueOf(object) + + switch objValue.Kind() { + // collection types are empty when they have no element + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: + return objValue.Len() == 0 + // pointers are empty if nil or if the value they point to is empty + case reflect.Ptr: + if objValue.IsNil() { + return true + } + deref := objValue.Elem().Interface() + return isEmpty(deref) + // for all other types, compare against the zero value + default: + zero := reflect.Zero(objValue.Type()) + return reflect.DeepEqual(object, zero.Interface()) + } +} + +// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// assert.Empty(t, obj) +func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + pass := isEmpty(object) + if !pass { + Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...) + } + + return pass + +} + +// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if assert.NotEmpty(t, obj) { +// assert.Equal(t, "two", obj[1]) +// } +func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + pass := !isEmpty(object) + if !pass { + Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...) + } + + return pass + +} + +// getLen try to get length of object. +// return (false, 0) if impossible. +func getLen(x interface{}) (ok bool, length int) { + v := reflect.ValueOf(x) + defer func() { + if e := recover(); e != nil { + ok = false + } + }() + return true, v.Len() +} + +// Len asserts that the specified object has specific length. +// Len also fails if the object has a type that len() not accept. +// +// assert.Len(t, mySlice, 3) +func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + ok, l := getLen(object) + if !ok { + return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...) + } + + if l != length { + return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) + } + return true +} + +// True asserts that the specified value is true. +// +// assert.True(t, myBool) +func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if h, ok := t.(interface { + Helper() + }); ok { + h.Helper() + } + + if value != true { + return Fail(t, "Should be true", msgAndArgs...) + } + + return true + +} + +// False asserts that the specified value is false. +// +// assert.False(t, myBool) +func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if value != false { + return Fail(t, "Should be false", msgAndArgs...) + } + + return true + +} + +// NotEqual asserts that the specified values are NOT equal. +// +// assert.NotEqual(t, obj1, obj2) +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if err := validateEqualArgs(expected, actual); err != nil { + return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)", + expected, actual, err), msgAndArgs...) + } + + if ObjectsAreEqual(expected, actual) { + return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...) + } + + return true + +} + +// containsElement try loop over the list check if the list includes the element. +// return (false, false) if impossible. +// return (true, false) if element was not found. +// return (true, true) if element was found. +func includeElement(list interface{}, element interface{}) (ok, found bool) { + + listValue := reflect.ValueOf(list) + elementValue := reflect.ValueOf(element) + defer func() { + if e := recover(); e != nil { + ok = false + found = false + } + }() + + if reflect.TypeOf(list).Kind() == reflect.String { + return true, strings.Contains(listValue.String(), elementValue.String()) + } + + if reflect.TypeOf(list).Kind() == reflect.Map { + mapKeys := listValue.MapKeys() + for i := 0; i < len(mapKeys); i++ { + if ObjectsAreEqual(mapKeys[i].Interface(), element) { + return true, true + } + } + return true, false + } + + for i := 0; i < listValue.Len(); i++ { + if ObjectsAreEqual(listValue.Index(i).Interface(), element) { + return true, true + } + } + return true, false + +} + +// Contains asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// assert.Contains(t, "Hello World", "World") +// assert.Contains(t, ["Hello", "World"], "World") +// assert.Contains(t, {"Hello": "World"}, "Hello") +func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + ok, found := includeElement(s, contains) + if !ok { + return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) + } + if !found { + return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...) + } + + return true + +} + +// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// assert.NotContains(t, "Hello World", "Earth") +// assert.NotContains(t, ["Hello", "World"], "Earth") +// assert.NotContains(t, {"Hello": "World"}, "Earth") +func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + ok, found := includeElement(s, contains) + if !ok { + return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) + } + if found { + return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...) + } + + return true + +} + +// Subset asserts that the specified list(array, slice...) contains all +// elements given in the specified subset(array, slice...). +// +// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") +func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if subset == nil { + return true // we consider nil to be equal to the nil set + } + + subsetValue := reflect.ValueOf(subset) + defer func() { + if e := recover(); e != nil { + ok = false + } + }() + + listKind := reflect.TypeOf(list).Kind() + subsetKind := reflect.TypeOf(subset).Kind() + + if listKind != reflect.Array && listKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) + } + + if subsetKind != reflect.Array && subsetKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) + } + + for i := 0; i < subsetValue.Len(); i++ { + element := subsetValue.Index(i).Interface() + ok, found := includeElement(list, element) + if !ok { + return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) + } + if !found { + return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", list, element), msgAndArgs...) + } + } + + return true +} + +// NotSubset asserts that the specified list(array, slice...) contains not all +// elements given in the specified subset(array, slice...). +// +// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") +func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if subset == nil { + return Fail(t, fmt.Sprintf("nil is the empty set which is a subset of every set"), msgAndArgs...) + } + + subsetValue := reflect.ValueOf(subset) + defer func() { + if e := recover(); e != nil { + ok = false + } + }() + + listKind := reflect.TypeOf(list).Kind() + subsetKind := reflect.TypeOf(subset).Kind() + + if listKind != reflect.Array && listKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) + } + + if subsetKind != reflect.Array && subsetKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) + } + + for i := 0; i < subsetValue.Len(); i++ { + element := subsetValue.Index(i).Interface() + ok, found := includeElement(list, element) + if !ok { + return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) + } + if !found { + return true + } + } + + return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...) +} + +// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified +// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, +// the number of appearances of each of them in both lists should match. +// +// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) +func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if isEmpty(listA) && isEmpty(listB) { + return true + } + + aKind := reflect.TypeOf(listA).Kind() + bKind := reflect.TypeOf(listB).Kind() + + if aKind != reflect.Array && aKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listA, aKind), msgAndArgs...) + } + + if bKind != reflect.Array && bKind != reflect.Slice { + return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listB, bKind), msgAndArgs...) + } + + aValue := reflect.ValueOf(listA) + bValue := reflect.ValueOf(listB) + + aLen := aValue.Len() + bLen := bValue.Len() + + if aLen != bLen { + return Fail(t, fmt.Sprintf("lengths don't match: %d != %d", aLen, bLen), msgAndArgs...) + } + + // Mark indexes in bValue that we already used + visited := make([]bool, bLen) + for i := 0; i < aLen; i++ { + element := aValue.Index(i).Interface() + found := false + for j := 0; j < bLen; j++ { + if visited[j] { + continue + } + if ObjectsAreEqual(bValue.Index(j).Interface(), element) { + visited[j] = true + found = true + break + } + } + if !found { + return Fail(t, fmt.Sprintf("element %s appears more times in %s than in %s", element, aValue, bValue), msgAndArgs...) + } + } + + return true +} + +// Condition uses a Comparison to assert a complex condition. +func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + result := comp() + if !result { + Fail(t, "Condition failed!", msgAndArgs...) + } + return result +} + +// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics +// methods, and represents a simple func that takes no arguments, and returns nothing. +type PanicTestFunc func() + +// didPanic returns true if the function passed to it panics. Otherwise, it returns false. +func didPanic(f PanicTestFunc) (bool, interface{}) { + + didPanic := false + var message interface{} + func() { + + defer func() { + if message = recover(); message != nil { + didPanic = true + } + }() + + // call the target function + f() + + }() + + return didPanic, message + +} + +// Panics asserts that the code inside the specified PanicTestFunc panics. +// +// assert.Panics(t, func(){ GoCrazy() }) +func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if funcDidPanic, panicValue := didPanic(f); !funcDidPanic { + return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) + } + + return true +} + +// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that +// the recovered panic value equals the expected panic value. +// +// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) +func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + funcDidPanic, panicValue := didPanic(f) + if !funcDidPanic { + return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) + } + if panicValue != expected { + return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v", f, expected, panicValue), msgAndArgs...) + } + + return true +} + +// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// assert.NotPanics(t, func(){ RemainCalm() }) +func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if funcDidPanic, panicValue := didPanic(f); funcDidPanic { + return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v", f, panicValue), msgAndArgs...) + } + + return true +} + +// WithinDuration asserts that the two times are within duration delta of each other. +// +// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) +func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + dt := expected.Sub(actual) + if dt < -delta || dt > delta { + return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) + } + + return true +} + +func toFloat(x interface{}) (float64, bool) { + var xf float64 + xok := true + + switch xn := x.(type) { + case uint8: + xf = float64(xn) + case uint16: + xf = float64(xn) + case uint32: + xf = float64(xn) + case uint64: + xf = float64(xn) + case int: + xf = float64(xn) + case int8: + xf = float64(xn) + case int16: + xf = float64(xn) + case int32: + xf = float64(xn) + case int64: + xf = float64(xn) + case float32: + xf = float64(xn) + case float64: + xf = float64(xn) + case time.Duration: + xf = float64(xn) + default: + xok = false + } + + return xf, xok +} + +// InDelta asserts that the two numerals are within delta of each other. +// +// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) +func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + af, aok := toFloat(expected) + bf, bok := toFloat(actual) + + if !aok || !bok { + return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...) + } + + if math.IsNaN(af) { + return Fail(t, fmt.Sprintf("Expected must not be NaN"), msgAndArgs...) + } + + if math.IsNaN(bf) { + return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...) + } + + dt := af - bf + if dt < -delta || dt > delta { + return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) + } + + return true +} + +// InDeltaSlice is the same as InDelta, except it compares two slices. +func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if expected == nil || actual == nil || + reflect.TypeOf(actual).Kind() != reflect.Slice || + reflect.TypeOf(expected).Kind() != reflect.Slice { + return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) + } + + actualSlice := reflect.ValueOf(actual) + expectedSlice := reflect.ValueOf(expected) + + for i := 0; i < actualSlice.Len(); i++ { + result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...) + if !result { + return result + } + } + + return true +} + +// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. +func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if expected == nil || actual == nil || + reflect.TypeOf(actual).Kind() != reflect.Map || + reflect.TypeOf(expected).Kind() != reflect.Map { + return Fail(t, "Arguments must be maps", msgAndArgs...) + } + + expectedMap := reflect.ValueOf(expected) + actualMap := reflect.ValueOf(actual) + + if expectedMap.Len() != actualMap.Len() { + return Fail(t, "Arguments must have the same number of keys", msgAndArgs...) + } + + for _, k := range expectedMap.MapKeys() { + ev := expectedMap.MapIndex(k) + av := actualMap.MapIndex(k) + + if !ev.IsValid() { + return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...) + } + + if !av.IsValid() { + return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...) + } + + if !InDelta( + t, + ev.Interface(), + av.Interface(), + delta, + msgAndArgs..., + ) { + return false + } + } + + return true +} + +func calcRelativeError(expected, actual interface{}) (float64, error) { + af, aok := toFloat(expected) + if !aok { + return 0, fmt.Errorf("expected value %q cannot be converted to float", expected) + } + if af == 0 { + return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error") + } + bf, bok := toFloat(actual) + if !bok { + return 0, fmt.Errorf("actual value %q cannot be converted to float", actual) + } + + return math.Abs(af-bf) / math.Abs(af), nil +} + +// InEpsilon asserts that expected and actual have a relative error less than epsilon +func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + actualEpsilon, err := calcRelativeError(expected, actual) + if err != nil { + return Fail(t, err.Error(), msgAndArgs...) + } + if actualEpsilon > epsilon { + return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+ + " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...) + } + + return true +} + +// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. +func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if expected == nil || actual == nil || + reflect.TypeOf(actual).Kind() != reflect.Slice || + reflect.TypeOf(expected).Kind() != reflect.Slice { + return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) + } + + actualSlice := reflect.ValueOf(actual) + expectedSlice := reflect.ValueOf(expected) + + for i := 0; i < actualSlice.Len(); i++ { + result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon) + if !result { + return result + } + } + + return true +} + +/* + Errors +*/ + +// NoError asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if assert.NoError(t, err) { +// assert.Equal(t, expectedObj, actualObj) +// } +func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if err != nil { + return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) + } + + return true +} + +// Error asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if assert.Error(t, err) { +// assert.Equal(t, expectedError, err) +// } +func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + if err == nil { + return Fail(t, "An error is expected but got nil.", msgAndArgs...) + } + + return true +} + +// EqualError asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// assert.EqualError(t, err, expectedErrorString) +func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if !Error(t, theError, msgAndArgs...) { + return false + } + expected := errString + actual := theError.Error() + // don't need to use deep equals here, we know they are both strings + if expected != actual { + return Fail(t, fmt.Sprintf("Error message not equal:\n"+ + "expected: %q\n"+ + "actual : %q", expected, actual), msgAndArgs...) + } + return true +} + +// matchRegexp return true if a specified regexp matches a string. +func matchRegexp(rx interface{}, str interface{}) bool { + + var r *regexp.Regexp + if rr, ok := rx.(*regexp.Regexp); ok { + r = rr + } else { + r = regexp.MustCompile(fmt.Sprint(rx)) + } + + return (r.FindStringIndex(fmt.Sprint(str)) != nil) + +} + +// Regexp asserts that a specified regexp matches a string. +// +// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") +// assert.Regexp(t, "start...$", "it's not starting") +func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + + match := matchRegexp(rx, str) + + if !match { + Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...) + } + + return match +} + +// NotRegexp asserts that a specified regexp does not match a string. +// +// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") +// assert.NotRegexp(t, "^start", "it's not starting") +func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + match := matchRegexp(rx, str) + + if match { + Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...) + } + + return !match + +} + +// Zero asserts that i is the zero value for its type. +func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { + return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...) + } + return true +} + +// NotZero asserts that i is not the zero value for its type. +func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { + return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...) + } + return true +} + +// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. +func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + info, err := os.Lstat(path) + if err != nil { + if os.IsNotExist(err) { + return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) + } + return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) + } + if info.IsDir() { + return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...) + } + return true +} + +// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. +func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + info, err := os.Lstat(path) + if err != nil { + if os.IsNotExist(err) { + return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) + } + return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) + } + if !info.IsDir() { + return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...) + } + return true +} + +// JSONEq asserts that two JSON strings are equivalent. +// +// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + var expectedJSONAsInterface, actualJSONAsInterface interface{} + + if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil { + return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...) + } + + if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil { + return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...) + } + + return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...) +} + +func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) { + t := reflect.TypeOf(v) + k := t.Kind() + + if k == reflect.Ptr { + t = t.Elem() + k = t.Kind() + } + return t, k +} + +// diff returns a diff of both values as long as both are of the same type and +// are a struct, map, slice or array. Otherwise it returns an empty string. +func diff(expected interface{}, actual interface{}) string { + if expected == nil || actual == nil { + return "" + } + + et, ek := typeAndKind(expected) + at, _ := typeAndKind(actual) + + if et != at { + return "" + } + + if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String { + return "" + } + + var e, a string + if ek != reflect.String { + e = spewConfig.Sdump(expected) + a = spewConfig.Sdump(actual) + } else { + e = expected.(string) + a = actual.(string) + } + + diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ + A: difflib.SplitLines(e), + B: difflib.SplitLines(a), + FromFile: "Expected", + FromDate: "", + ToFile: "Actual", + ToDate: "", + Context: 1, + }) + + return "\n\nDiff:\n" + diff +} + +// validateEqualArgs checks whether provided arguments can be safely used in the +// Equal/NotEqual functions. +func validateEqualArgs(expected, actual interface{}) error { + if isFunction(expected) || isFunction(actual) { + return errors.New("cannot take func type as argument") + } + return nil +} + +func isFunction(arg interface{}) bool { + if arg == nil { + return false + } + return reflect.TypeOf(arg).Kind() == reflect.Func +} + +var spewConfig = spew.ConfigState{ + Indent: " ", + DisablePointerAddresses: true, + DisableCapacities: true, + SortKeys: true, +} + +type tHelper interface { + Helper() +} diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go new file mode 100644 index 000000000..c9dccc4d6 --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/doc.go @@ -0,0 +1,45 @@ +// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system. +// +// Example Usage +// +// The following is a complete example using assert in a standard test function: +// import ( +// "testing" +// "github.com/stretchr/testify/assert" +// ) +// +// func TestSomething(t *testing.T) { +// +// var a string = "Hello" +// var b string = "Hello" +// +// assert.Equal(t, a, b, "The two words should be the same.") +// +// } +// +// if you assert many times, use the format below: +// +// import ( +// "testing" +// "github.com/stretchr/testify/assert" +// ) +// +// func TestSomething(t *testing.T) { +// assert := assert.New(t) +// +// var a string = "Hello" +// var b string = "Hello" +// +// assert.Equal(a, b, "The two words should be the same.") +// } +// +// Assertions +// +// Assertions allow you to easily write test code, and are global funcs in the `assert` package. +// All assertion functions take, as the first argument, the `*testing.T` object provided by the +// testing framework. This allows the assertion funcs to write the failings and other details to +// the correct place. +// +// Every assertion function also takes an optional string message as the final argument, +// allowing custom error messages to be appended to the message the assertion method outputs. +package assert diff --git a/vendor/github.com/stretchr/testify/assert/errors.go b/vendor/github.com/stretchr/testify/assert/errors.go new file mode 100644 index 000000000..ac9dc9d1d --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/errors.go @@ -0,0 +1,10 @@ +package assert + +import ( + "errors" +) + +// AnError is an error instance useful for testing. If the code does not care +// about error specifics, and only needs to return the error for example, this +// error should be used to make the test code more readable. +var AnError = errors.New("assert.AnError general error for testing") diff --git a/vendor/github.com/stretchr/testify/assert/forward_assertions.go b/vendor/github.com/stretchr/testify/assert/forward_assertions.go new file mode 100644 index 000000000..9ad56851d --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/forward_assertions.go @@ -0,0 +1,16 @@ +package assert + +// Assertions provides assertion methods around the +// TestingT interface. +type Assertions struct { + t TestingT +} + +// New makes a new Assertions object for the specified TestingT. +func New(t TestingT) *Assertions { + return &Assertions{ + t: t, + } +} + +//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go new file mode 100644 index 000000000..df46fa777 --- /dev/null +++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go @@ -0,0 +1,143 @@ +package assert + +import ( + "fmt" + "net/http" + "net/http/httptest" + "net/url" + "strings" +) + +// httpCode is a helper that returns HTTP code of the response. It returns -1 and +// an error if building a new request fails. +func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) { + w := httptest.NewRecorder() + req, err := http.NewRequest(method, url, nil) + if err != nil { + return -1, err + } + req.URL.RawQuery = values.Encode() + handler(w, req) + return w.Code, nil +} + +// HTTPSuccess asserts that a specified handler returns a success status code. +// +// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + code, err := httpCode(handler, method, url, values) + if err != nil { + Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) + return false + } + + isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent + if !isSuccessCode { + Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code)) + } + + return isSuccessCode +} + +// HTTPRedirect asserts that a specified handler returns a redirect status code. +// +// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + code, err := httpCode(handler, method, url, values) + if err != nil { + Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) + return false + } + + isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect + if !isRedirectCode { + Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code)) + } + + return isRedirectCode +} + +// HTTPError asserts that a specified handler returns an error status code. +// +// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + code, err := httpCode(handler, method, url, values) + if err != nil { + Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) + return false + } + + isErrorCode := code >= http.StatusBadRequest + if !isErrorCode { + Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code)) + } + + return isErrorCode +} + +// HTTPBody is a helper that returns HTTP body of the response. It returns +// empty string if building a new request fails. +func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string { + w := httptest.NewRecorder() + req, err := http.NewRequest(method, url+"?"+values.Encode(), nil) + if err != nil { + return "" + } + handler(w, req) + return w.Body.String() +} + +// HTTPBodyContains asserts that a specified handler returns a +// body that contains a string. +// +// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + body := HTTPBody(handler, method, url, values) + + contains := strings.Contains(body, fmt.Sprint(str)) + if !contains { + Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) + } + + return contains +} + +// HTTPBodyNotContains asserts that a specified handler returns a +// body that does not contain a string. +// +// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { + if h, ok := t.(tHelper); ok { + h.Helper() + } + body := HTTPBody(handler, method, url, values) + + contains := strings.Contains(body, fmt.Sprint(str)) + if contains { + Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) + } + + return !contains +}