[](https://travis-ci.org/Sirupsen/logrus) [][godoc]
+
+Logrus is a structured logger for Go (golang), completely API compatible with
+the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
+yet stable (pre 1.0). Logrus itself is completely stable and has been used in
+many large deployments. The core API is unlikely to change much but please
+version control your Logrus to make sure you aren't fetching latest `master` on
+every build.**
+
+Nicely color-coded in development (when a TTY is attached, otherwise just
+plain text):
+
+
+
+With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
+or Splunk:
+
+```json
+{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
+ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
+
+{"level":"warning","msg":"The group's number increased tremendously!",
+"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
+"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
+
+{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
+"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
+
+{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
+"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
+```
+
+With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not
+attached, the output is compatible with the
+[logfmt](http://godoc.org/github.com/kr/logfmt) format:
+
+```text
+time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
+time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
+time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
+time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
+time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
+time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
+exit status 1
+```
+
+#### Example
+
+The simplest way to use Logrus is simply the package-level exported logger:
+
+```go
+package main
+
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ }).Info("A walrus appears")
+}
+```
+
+Note that it's completely api-compatible with the stdlib logger, so you can
+replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
+and you'll now have the flexibility of Logrus. You can customize it all you
+want:
+
+```go
+package main
+
+import (
+ "os"
+ log "github.com/Sirupsen/logrus"
+ "github.com/Sirupsen/logrus/hooks/airbrake"
+)
+
+func init() {
+ // Log as JSON instead of the default ASCII formatter.
+ log.SetFormatter(&log.JSONFormatter{})
+
+ // Use the Airbrake hook to report errors that have Error severity or above to
+ // an exception tracker. You can create custom hooks, see the Hooks section.
+ log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
+
+ // Output to stderr instead of stdout, could also be a file.
+ log.SetOutput(os.Stderr)
+
+ // Only log the warning severity or above.
+ log.SetLevel(log.WarnLevel)
+}
+
+func main() {
+ log.WithFields(log.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 122,
+ }).Warn("The group's number increased tremendously!")
+
+ log.WithFields(log.Fields{
+ "omg": true,
+ "number": 100,
+ }).Fatal("The ice breaks!")
+
+ // A common pattern is to re-use fields between logging statements by re-using
+ // the logrus.Entry returned from WithFields()
+ contextLogger := log.WithFields(log.Fields{
+ "common": "this is a common field",
+ "other": "I also should be logged always",
+ })
+
+ contextLogger.Info("I'll be logged with common and other field")
+ contextLogger.Info("Me too")
+}
+```
+
+For more advanced usage such as logging to multiple locations from the same
+application, you can also create an instance of the `logrus` Logger:
+
+```go
+package main
+
+import (
+ "github.com/Sirupsen/logrus"
+)
+
+// Create a new instance of the logger. You can have any number of instances.
+var log = logrus.New()
+
+func main() {
+ // The API for setting attributes is a little different than the package level
+ // exported logger. See Godoc.
+ log.Out = os.Stderr
+
+ log.WithFields(logrus.Fields{
+ "animal": "walrus",
+ "size": 10,
+ }).Info("A group of walrus emerges from the ocean")
+}
+```
+
+#### Fields
+
+Logrus encourages careful, structured logging though logging fields instead of
+long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
+to send event %s to topic %s with key %d")`, you should log the much more
+discoverable:
+
+```go
+log.WithFields(log.Fields{
+ "event": event,
+ "topic": topic,
+ "key": key,
+}).Fatal("Failed to send event")
+```
+
+We've found this API forces you to think about logging in a way that produces
+much more useful logging messages. We've been in countless situations where just
+a single added field to a log statement that was already there would've saved us
+hours. The `WithFields` call is optional.
+
+In general, with Logrus using any of the `printf`-family functions should be
+seen as a hint you should add a field, however, you can still use the
+`printf`-family functions with Logrus.
+
+#### Hooks
+
+You can add hooks for logging levels. For example to send errors to an exception
+tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
+multiple places simultaneously, e.g. syslog.
+
+Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
+`init`:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+ "github.com/Sirupsen/logrus/hooks/airbrake"
+ logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
+ "log/syslog"
+)
+
+func init() {
+ log.AddHook(airbrake.NewHook("https://example.com", "xyz", "development"))
+
+ hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
+ if err != nil {
+ log.Error("Unable to connect to local syslog daemon")
+ } else {
+ log.AddHook(hook)
+ }
+}
+```
+
+
+| Hook | Description |
+| ----- | ----------- |
+| [Airbrake](https://github.com/Sirupsen/logrus/blob/master/hooks/airbrake/airbrake.go) | Send errors to an exception tracking service compatible with the Airbrake API. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
+| [Papertrail](https://github.com/Sirupsen/logrus/blob/master/hooks/papertrail/papertrail.go) | Send errors to the Papertrail hosted logging service via UDP. |
+| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
+| [BugSnag](https://github.com/Sirupsen/logrus/blob/master/hooks/bugsnag/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
+| [Sentry](https://github.com/Sirupsen/logrus/blob/master/hooks/sentry/sentry.go) | Send errors to the Sentry error logging and aggregation service. |
+| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
+| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
+| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
+| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
+| [Graylog](https://github.com/gemnasium/logrus-hooks/tree/master/graylog) | Hook for logging to [Graylog](http://graylog2.org/) |
+| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
+| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
+| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
+| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |
+| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
+| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
+
+#### Level logging
+
+Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
+
+```go
+log.Debug("Useful debugging information.")
+log.Info("Something noteworthy happened!")
+log.Warn("You should probably take a look at this.")
+log.Error("Something failed but I'm not quitting.")
+// Calls os.Exit(1) after logging
+log.Fatal("Bye.")
+// Calls panic() after logging
+log.Panic("I'm bailing.")
+```
+
+You can set the logging level on a `Logger`, then it will only log entries with
+that severity or anything above it:
+
+```go
+// Will log anything that is info or above (warn, error, fatal, panic). Default.
+log.SetLevel(log.InfoLevel)
+```
+
+It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
+environment if your application has that.
+
+#### Entries
+
+Besides the fields added with `WithField` or `WithFields` some fields are
+automatically added to all logging events:
+
+1. `time`. The timestamp when the entry was created.
+2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
+ the `AddFields` call. E.g. `Failed to send event.`
+3. `level`. The logging level. E.g. `info`.
+
+#### Environments
+
+Logrus has no notion of environment.
+
+If you wish for hooks and formatters to only be used in specific environments,
+you should handle that yourself. For example, if your application has a global
+variable `Environment`, which is a string representation of the environment you
+could do:
+
+```go
+import (
+ log "github.com/Sirupsen/logrus"
+)
+
+init() {
+ // do something here to set environment depending on an environment variable
+ // or command-line flag
+ if Environment == "production" {
+ log.SetFormatter(&logrus.JSONFormatter{})
+ } else {
+ // The TextFormatter is default, you don't actually have to do this.
+ log.SetFormatter(&log.TextFormatter{})
+ }
+}
+```
+
+This configuration is how `logrus` was intended to be used, but JSON in
+production is mostly only useful if you do log aggregation with tools like
+Splunk or Logstash.
+
+#### Formatters
+
+The built-in logging formatters are:
+
+* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
+ without colors.
+ * *Note:* to force colored output when there is no TTY, set the `ForceColors`
+ field to `true`. To force no colored output even if there is a TTY set the
+ `DisableColors` field to `true`
+* `logrus.JSONFormatter`. Logs fields as JSON.
+* `logrus_logstash.LogstashFormatter`. Logs fields as Logstash Events (http://logstash.net).
+
+ ```go
+ logrus.SetFormatter(&logrus_logstash.LogstashFormatter{Type: “application_name"})
+ ```
+
+Third party logging formatters:
+
+* [`zalgo`](https://github.com/aybabtme/logzalgo): invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
+
+You can define your formatter by implementing the `Formatter` interface,
+requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
+`Fields` type (`map[string]interface{}`) with all your fields as well as the
+default ones (see Entries section above):
+
+```go
+type MyJSONFormatter struct {
+}
+
+log.SetFormatter(new(MyJSONFormatter))
+
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+ // Note this doesn't include Time, Level and Message which are available on
+ // the Entry. Consult `godoc` on information about those fields or read the
+ // source of the official loggers.
+ serialized, err := json.Marshal(entry.Data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
+```
+
+#### Logger as an `io.Writer`
+
+Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
+
+```go
+w := logger.Writer()
+defer w.Close()
+
+srv := http.Server{
+ // create a stdlib log.Logger that writes to
+ // logrus.Logger.
+ ErrorLog: log.New(w, "", 0),
+}
+```
+
+Each line written to that writer will be printed the usual way, using formatters
+and hooks. The level for those entries is `info`.
+
+#### Rotation
+
+Log rotation is not provided with Logrus. Log rotation should be done by an
+external program (like `logrotate(8)`) that can compress and delete old log
+entries. It should not be a feature of the application-level logger.
+
+
+[godoc]: https://godoc.org/github.com/Sirupsen/logrus
diff --git a/vendor/github.com/Sirupsen/logrus/entry.go b/vendor/github.com/Sirupsen/logrus/entry.go
new file mode 100644
index 000000000..699ea035c
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/entry.go
@@ -0,0 +1,254 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "time"
+)
+
+// An entry is the final or intermediate Logrus logging entry. It contains all
+// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
+// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
+// passed around as much as you wish to avoid field duplication.
+type Entry struct {
+ Logger *Logger
+
+ // Contains all the fields set by the user.
+ Data Fields
+
+ // Time at which the log entry was created
+ Time time.Time
+
+ // Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
+ Level Level
+
+ // Message passed to Debug, Info, Warn, Error, Fatal or Panic
+ Message string
+}
+
+func NewEntry(logger *Logger) *Entry {
+ return &Entry{
+ Logger: logger,
+ // Default is three fields, give a little extra room
+ Data: make(Fields, 5),
+ }
+}
+
+// Returns a reader for the entry, which is a proxy to the formatter.
+func (entry *Entry) Reader() (*bytes.Buffer, error) {
+ serialized, err := entry.Logger.Formatter.Format(entry)
+ return bytes.NewBuffer(serialized), err
+}
+
+// Returns the string representation from the reader and ultimately the
+// formatter.
+func (entry *Entry) String() (string, error) {
+ reader, err := entry.Reader()
+ if err != nil {
+ return "", err
+ }
+
+ return reader.String(), err
+}
+
+// Add a single field to the Entry.
+func (entry *Entry) WithField(key string, value interface{}) *Entry {
+ return entry.WithFields(Fields{key: value})
+}
+
+// Add a map of fields to the Entry.
+func (entry *Entry) WithFields(fields Fields) *Entry {
+ data := Fields{}
+ for k, v := range entry.Data {
+ data[k] = v
+ }
+ for k, v := range fields {
+ data[k] = v
+ }
+ return &Entry{Logger: entry.Logger, Data: data}
+}
+
+func (entry *Entry) log(level Level, msg string) {
+ entry.Time = time.Now()
+ entry.Level = level
+ entry.Message = msg
+
+ if err := entry.Logger.Hooks.Fire(level, entry); err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ reader, err := entry.Reader()
+ if err != nil {
+ entry.Logger.mu.Lock()
+ fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
+ entry.Logger.mu.Unlock()
+ }
+
+ entry.Logger.mu.Lock()
+ defer entry.Logger.mu.Unlock()
+
+ _, err = io.Copy(entry.Logger.Out, reader)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
+ }
+
+ // To avoid Entry#log() returning a value that only would make sense for
+ // panic() to use in Entry#Panic(), we avoid the allocation by checking
+ // directly here.
+ if level <= PanicLevel {
+ panic(entry)
+ }
+}
+
+func (entry *Entry) Debug(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.log(DebugLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Print(args ...interface{}) {
+ entry.Info(args...)
+}
+
+func (entry *Entry) Info(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.log(InfoLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warn(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.log(WarnLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Warning(args ...interface{}) {
+ entry.Warn(args...)
+}
+
+func (entry *Entry) Error(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.log(ErrorLevel, fmt.Sprint(args...))
+ }
+}
+
+func (entry *Entry) Fatal(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.log(FatalLevel, fmt.Sprint(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panic(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.log(PanicLevel, fmt.Sprint(args...))
+ }
+ panic(fmt.Sprint(args...))
+}
+
+// Entry Printf family functions
+
+func (entry *Entry) Debugf(format string, args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Infof(format string, args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Printf(format string, args ...interface{}) {
+ entry.Infof(format, args...)
+}
+
+func (entry *Entry) Warnf(format string, args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Warningf(format string, args ...interface{}) {
+ entry.Warnf(format, args...)
+}
+
+func (entry *Entry) Errorf(format string, args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(fmt.Sprintf(format, args...))
+ }
+}
+
+func (entry *Entry) Fatalf(format string, args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(fmt.Sprintf(format, args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicf(format string, args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(fmt.Sprintf(format, args...))
+ }
+}
+
+// Entry Println family functions
+
+func (entry *Entry) Debugln(args ...interface{}) {
+ if entry.Logger.Level >= DebugLevel {
+ entry.Debug(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Infoln(args ...interface{}) {
+ if entry.Logger.Level >= InfoLevel {
+ entry.Info(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Println(args ...interface{}) {
+ entry.Infoln(args...)
+}
+
+func (entry *Entry) Warnln(args ...interface{}) {
+ if entry.Logger.Level >= WarnLevel {
+ entry.Warn(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Warningln(args ...interface{}) {
+ entry.Warnln(args...)
+}
+
+func (entry *Entry) Errorln(args ...interface{}) {
+ if entry.Logger.Level >= ErrorLevel {
+ entry.Error(entry.sprintlnn(args...))
+ }
+}
+
+func (entry *Entry) Fatalln(args ...interface{}) {
+ if entry.Logger.Level >= FatalLevel {
+ entry.Fatal(entry.sprintlnn(args...))
+ }
+ os.Exit(1)
+}
+
+func (entry *Entry) Panicln(args ...interface{}) {
+ if entry.Logger.Level >= PanicLevel {
+ entry.Panic(entry.sprintlnn(args...))
+ }
+}
+
+// Sprintlnn => Sprint no newline. This is to get the behavior of how
+// fmt.Sprintln where spaces are always added between operands, regardless of
+// their type. Instead of vendoring the Sprintln implementation to spare a
+// string allocation, we do the simplest thing.
+func (entry *Entry) sprintlnn(args ...interface{}) string {
+ msg := fmt.Sprintln(args...)
+ return msg[:len(msg)-1]
+}
diff --git a/vendor/github.com/Sirupsen/logrus/exported.go b/vendor/github.com/Sirupsen/logrus/exported.go
new file mode 100644
index 000000000..a67e1b802
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/exported.go
@@ -0,0 +1,188 @@
+package logrus
+
+import (
+ "io"
+)
+
+var (
+ // std is the name of the standard logger in stdlib `log`
+ std = New()
+)
+
+func StandardLogger() *Logger {
+ return std
+}
+
+// SetOutput sets the standard logger output.
+func SetOutput(out io.Writer) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Out = out
+}
+
+// SetFormatter sets the standard logger formatter.
+func SetFormatter(formatter Formatter) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Formatter = formatter
+}
+
+// SetLevel sets the standard logger level.
+func SetLevel(level Level) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Level = level
+}
+
+// GetLevel returns the standard logger level.
+func GetLevel() Level {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ return std.Level
+}
+
+// AddHook adds a hook to the standard logger hooks.
+func AddHook(hook Hook) {
+ std.mu.Lock()
+ defer std.mu.Unlock()
+ std.Hooks.Add(hook)
+}
+
+// WithField creates an entry from the standard logger and adds a field to
+// it. If you want multiple fields, use `WithFields`.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithField(key string, value interface{}) *Entry {
+ return std.WithField(key, value)
+}
+
+// WithFields creates an entry from the standard logger and adds multiple
+// fields to it. This is simply a helper for `WithField`, invoking it
+// once for each field.
+//
+// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
+// or Panic on the Entry it returns.
+func WithFields(fields Fields) *Entry {
+ return std.WithFields(fields)
+}
+
+// Debug logs a message at level Debug on the standard logger.
+func Debug(args ...interface{}) {
+ std.Debug(args...)
+}
+
+// Print logs a message at level Info on the standard logger.
+func Print(args ...interface{}) {
+ std.Print(args...)
+}
+
+// Info logs a message at level Info on the standard logger.
+func Info(args ...interface{}) {
+ std.Info(args...)
+}
+
+// Warn logs a message at level Warn on the standard logger.
+func Warn(args ...interface{}) {
+ std.Warn(args...)
+}
+
+// Warning logs a message at level Warn on the standard logger.
+func Warning(args ...interface{}) {
+ std.Warning(args...)
+}
+
+// Error logs a message at level Error on the standard logger.
+func Error(args ...interface{}) {
+ std.Error(args...)
+}
+
+// Panic logs a message at level Panic on the standard logger.
+func Panic(args ...interface{}) {
+ std.Panic(args...)
+}
+
+// Fatal logs a message at level Fatal on the standard logger.
+func Fatal(args ...interface{}) {
+ std.Fatal(args...)
+}
+
+// Debugf logs a message at level Debug on the standard logger.
+func Debugf(format string, args ...interface{}) {
+ std.Debugf(format, args...)
+}
+
+// Printf logs a message at level Info on the standard logger.
+func Printf(format string, args ...interface{}) {
+ std.Printf(format, args...)
+}
+
+// Infof logs a message at level Info on the standard logger.
+func Infof(format string, args ...interface{}) {
+ std.Infof(format, args...)
+}
+
+// Warnf logs a message at level Warn on the standard logger.
+func Warnf(format string, args ...interface{}) {
+ std.Warnf(format, args...)
+}
+
+// Warningf logs a message at level Warn on the standard logger.
+func Warningf(format string, args ...interface{}) {
+ std.Warningf(format, args...)
+}
+
+// Errorf logs a message at level Error on the standard logger.
+func Errorf(format string, args ...interface{}) {
+ std.Errorf(format, args...)
+}
+
+// Panicf logs a message at level Panic on the standard logger.
+func Panicf(format string, args ...interface{}) {
+ std.Panicf(format, args...)
+}
+
+// Fatalf logs a message at level Fatal on the standard logger.
+func Fatalf(format string, args ...interface{}) {
+ std.Fatalf(format, args...)
+}
+
+// Debugln logs a message at level Debug on the standard logger.
+func Debugln(args ...interface{}) {
+ std.Debugln(args...)
+}
+
+// Println logs a message at level Info on the standard logger.
+func Println(args ...interface{}) {
+ std.Println(args...)
+}
+
+// Infoln logs a message at level Info on the standard logger.
+func Infoln(args ...interface{}) {
+ std.Infoln(args...)
+}
+
+// Warnln logs a message at level Warn on the standard logger.
+func Warnln(args ...interface{}) {
+ std.Warnln(args...)
+}
+
+// Warningln logs a message at level Warn on the standard logger.
+func Warningln(args ...interface{}) {
+ std.Warningln(args...)
+}
+
+// Errorln logs a message at level Error on the standard logger.
+func Errorln(args ...interface{}) {
+ std.Errorln(args...)
+}
+
+// Panicln logs a message at level Panic on the standard logger.
+func Panicln(args ...interface{}) {
+ std.Panicln(args...)
+}
+
+// Fatalln logs a message at level Fatal on the standard logger.
+func Fatalln(args ...interface{}) {
+ std.Fatalln(args...)
+}
diff --git a/vendor/github.com/Sirupsen/logrus/formatter.go b/vendor/github.com/Sirupsen/logrus/formatter.go
new file mode 100644
index 000000000..104d689f1
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/formatter.go
@@ -0,0 +1,48 @@
+package logrus
+
+import "time"
+
+const DefaultTimestampFormat = time.RFC3339
+
+// The Formatter interface is used to implement a custom Formatter. It takes an
+// `Entry`. It exposes all the fields, including the default ones:
+//
+// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
+// * `entry.Data["time"]`. The timestamp.
+// * `entry.Data["level"]. The level the entry was logged at.
+//
+// Any additional fields added with `WithField` or `WithFields` are also in
+// `entry.Data`. Format is expected to return an array of bytes which are then
+// logged to `logger.Out`.
+type Formatter interface {
+ Format(*Entry) ([]byte, error)
+}
+
+// This is to not silently overwrite `time`, `msg` and `level` fields when
+// dumping it. If this code wasn't there doing:
+//
+// logrus.WithField("level", 1).Info("hello")
+//
+// Would just silently drop the user provided level. Instead with this code
+// it'll logged as:
+//
+// {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
+//
+// It's not exported because it's still using Data in an opinionated way. It's to
+// avoid code duplication between the two default formatters.
+func prefixFieldClashes(data Fields) {
+ _, ok := data["time"]
+ if ok {
+ data["fields.time"] = data["time"]
+ }
+
+ _, ok = data["msg"]
+ if ok {
+ data["fields.msg"] = data["msg"]
+ }
+
+ _, ok = data["level"]
+ if ok {
+ data["fields.level"] = data["level"]
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/hooks.go b/vendor/github.com/Sirupsen/logrus/hooks.go
new file mode 100644
index 000000000..3f151cdc3
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/hooks.go
@@ -0,0 +1,34 @@
+package logrus
+
+// A hook to be fired when logging on the logging levels returned from
+// `Levels()` on your implementation of the interface. Note that this is not
+// fired in a goroutine or a channel with workers, you should handle such
+// functionality yourself if your call is non-blocking and you don't wish for
+// the logging calls for levels returned from `Levels()` to block.
+type Hook interface {
+ Levels() []Level
+ Fire(*Entry) error
+}
+
+// Internal type for storing the hooks on a logger instance.
+type LevelHooks map[Level][]Hook
+
+// Add a hook to an instance of logger. This is called with
+// `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
+func (hooks LevelHooks) Add(hook Hook) {
+ for _, level := range hook.Levels() {
+ hooks[level] = append(hooks[level], hook)
+ }
+}
+
+// Fire all the hooks for the passed level. Used by `entry.log` to fire
+// appropriate hooks for a log entry.
+func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
+ for _, hook := range hooks[level] {
+ if err := hook.Fire(entry); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/Sirupsen/logrus/json_formatter.go b/vendor/github.com/Sirupsen/logrus/json_formatter.go
new file mode 100644
index 000000000..2ad6dc5cf
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/json_formatter.go
@@ -0,0 +1,41 @@
+package logrus
+
+import (
+ "encoding/json"
+ "fmt"
+)
+
+type JSONFormatter struct {
+ // TimestampFormat sets the format used for marshaling timestamps.
+ TimestampFormat string
+}
+
+func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
+ data := make(Fields, len(entry.Data)+3)
+ for k, v := range entry.Data {
+ switch v := v.(type) {
+ case error:
+ // Otherwise errors are ignored by `encoding/json`
+ // https://github.com/Sirupsen/logrus/issues/137
+ data[k] = v.Error()
+ default:
+ data[k] = v
+ }
+ }
+ prefixFieldClashes(data)
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+
+ data["time"] = entry.Time.Format(timestampFormat)
+ data["msg"] = entry.Message
+ data["level"] = entry.Level.String()
+
+ serialized, err := json.Marshal(data)
+ if err != nil {
+ return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
+ }
+ return append(serialized, '\n'), nil
+}
diff --git a/vendor/github.com/Sirupsen/logrus/logger.go b/vendor/github.com/Sirupsen/logrus/logger.go
new file mode 100644
index 000000000..e4974bfbe
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/logger.go
@@ -0,0 +1,206 @@
+package logrus
+
+import (
+ "io"
+ "os"
+ "sync"
+)
+
+type Logger struct {
+ // The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
+ // file, or leave it default which is `os.Stdout`. You can also set this to
+ // something more adventorous, such as logging to Kafka.
+ Out io.Writer
+ // Hooks for the logger instance. These allow firing events based on logging
+ // levels and log entries. For example, to send errors to an error tracking
+ // service, log to StatsD or dump the core on fatal errors.
+ Hooks LevelHooks
+ // All log entries pass through the formatter before logged to Out. The
+ // included formatters are `TextFormatter` and `JSONFormatter` for which
+ // TextFormatter is the default. In development (when a TTY is attached) it
+ // logs with colors, but to a file it wouldn't. You can easily implement your
+ // own that implements the `Formatter` interface, see the `README` or included
+ // formatters for examples.
+ Formatter Formatter
+ // The logging level the logger should log at. This is typically (and defaults
+ // to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
+ // logged. `logrus.Debug` is useful in
+ Level Level
+ // Used to sync writing to the log.
+ mu sync.Mutex
+}
+
+// Creates a new logger. Configuration should be set by changing `Formatter`,
+// `Out` and `Hooks` directly on the default logger instance. You can also just
+// instantiate your own:
+//
+// var log = &Logger{
+// Out: os.Stderr,
+// Formatter: new(JSONFormatter),
+// Hooks: make(LevelHooks),
+// Level: logrus.DebugLevel,
+// }
+//
+// It's recommended to make this a global instance called `log`.
+func New() *Logger {
+ return &Logger{
+ Out: os.Stderr,
+ Formatter: new(TextFormatter),
+ Hooks: make(LevelHooks),
+ Level: InfoLevel,
+ }
+}
+
+// Adds a field to the log entry, note that you it doesn't log until you call
+// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
+// Ff you want multiple fields, use `WithFields`.
+func (logger *Logger) WithField(key string, value interface{}) *Entry {
+ return NewEntry(logger).WithField(key, value)
+}
+
+// Adds a struct of fields to the log entry. All it does is call `WithField` for
+// each `Field`.
+func (logger *Logger) WithFields(fields Fields) *Entry {
+ return NewEntry(logger).WithFields(fields)
+}
+
+func (logger *Logger) Debugf(format string, args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugf(format, args...)
+ }
+}
+
+func (logger *Logger) Infof(format string, args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infof(format, args...)
+ }
+}
+
+func (logger *Logger) Printf(format string, args ...interface{}) {
+ NewEntry(logger).Printf(format, args...)
+}
+
+func (logger *Logger) Warnf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Warningf(format string, args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnf(format, args...)
+ }
+}
+
+func (logger *Logger) Errorf(format string, args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorf(format, args...)
+ }
+}
+
+func (logger *Logger) Fatalf(format string, args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalf(format, args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicf(format string, args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicf(format, args...)
+ }
+}
+
+func (logger *Logger) Debug(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debug(args...)
+ }
+}
+
+func (logger *Logger) Info(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Info(args...)
+ }
+}
+
+func (logger *Logger) Print(args ...interface{}) {
+ NewEntry(logger).Info(args...)
+}
+
+func (logger *Logger) Warn(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Warning(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warn(args...)
+ }
+}
+
+func (logger *Logger) Error(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Error(args...)
+ }
+}
+
+func (logger *Logger) Fatal(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatal(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panic(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panic(args...)
+ }
+}
+
+func (logger *Logger) Debugln(args ...interface{}) {
+ if logger.Level >= DebugLevel {
+ NewEntry(logger).Debugln(args...)
+ }
+}
+
+func (logger *Logger) Infoln(args ...interface{}) {
+ if logger.Level >= InfoLevel {
+ NewEntry(logger).Infoln(args...)
+ }
+}
+
+func (logger *Logger) Println(args ...interface{}) {
+ NewEntry(logger).Println(args...)
+}
+
+func (logger *Logger) Warnln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Warningln(args ...interface{}) {
+ if logger.Level >= WarnLevel {
+ NewEntry(logger).Warnln(args...)
+ }
+}
+
+func (logger *Logger) Errorln(args ...interface{}) {
+ if logger.Level >= ErrorLevel {
+ NewEntry(logger).Errorln(args...)
+ }
+}
+
+func (logger *Logger) Fatalln(args ...interface{}) {
+ if logger.Level >= FatalLevel {
+ NewEntry(logger).Fatalln(args...)
+ }
+ os.Exit(1)
+}
+
+func (logger *Logger) Panicln(args ...interface{}) {
+ if logger.Level >= PanicLevel {
+ NewEntry(logger).Panicln(args...)
+ }
+}
diff --git a/vendor/github.com/Sirupsen/logrus/logrus.go b/vendor/github.com/Sirupsen/logrus/logrus.go
new file mode 100644
index 000000000..43ee12e90
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/logrus.go
@@ -0,0 +1,94 @@
+package logrus
+
+import (
+ "fmt"
+ "log"
+)
+
+// Fields type, used to pass to `WithFields`.
+type Fields map[string]interface{}
+
+// Level type
+type Level uint8
+
+// Convert the Level to a string. E.g. PanicLevel becomes "panic".
+func (level Level) String() string {
+ switch level {
+ case DebugLevel:
+ return "debug"
+ case InfoLevel:
+ return "info"
+ case WarnLevel:
+ return "warning"
+ case ErrorLevel:
+ return "error"
+ case FatalLevel:
+ return "fatal"
+ case PanicLevel:
+ return "panic"
+ }
+
+ return "unknown"
+}
+
+// ParseLevel takes a string level and returns the Logrus log level constant.
+func ParseLevel(lvl string) (Level, error) {
+ switch lvl {
+ case "panic":
+ return PanicLevel, nil
+ case "fatal":
+ return FatalLevel, nil
+ case "error":
+ return ErrorLevel, nil
+ case "warn", "warning":
+ return WarnLevel, nil
+ case "info":
+ return InfoLevel, nil
+ case "debug":
+ return DebugLevel, nil
+ }
+
+ var l Level
+ return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
+}
+
+// These are the different logging levels. You can set the logging level to log
+// on your instance of logger, obtained with `logrus.New()`.
+const (
+ // PanicLevel level, highest level of severity. Logs and then calls panic with the
+ // message passed to Debug, Info, ...
+ PanicLevel Level = iota
+ // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
+ // logging level is set to Panic.
+ FatalLevel
+ // ErrorLevel level. Logs. Used for errors that should definitely be noted.
+ // Commonly used for hooks to send errors to an error tracking service.
+ ErrorLevel
+ // WarnLevel level. Non-critical entries that deserve eyes.
+ WarnLevel
+ // InfoLevel level. General operational entries about what's going on inside the
+ // application.
+ InfoLevel
+ // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
+ DebugLevel
+)
+
+// Won't compile if StdLogger can't be realized by a log.Logger
+var _ StdLogger = &log.Logger{}
+
+// StdLogger is what your logrus-enabled library should take, that way
+// it'll accept a stdlib logger and a logrus logger. There's no standard
+// interface, this is the closest we get, unfortunately.
+type StdLogger interface {
+ Print(...interface{})
+ Printf(string, ...interface{})
+ Println(...interface{})
+
+ Fatal(...interface{})
+ Fatalf(string, ...interface{})
+ Fatalln(...interface{})
+
+ Panic(...interface{})
+ Panicf(string, ...interface{})
+ Panicln(...interface{})
+}
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_bsd.go b/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
new file mode 100644
index 000000000..71f8d67a5
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_bsd.go
@@ -0,0 +1,9 @@
+// +build darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA
+
+type Termios syscall.Termios
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_linux.go b/vendor/github.com/Sirupsen/logrus/terminal_linux.go
new file mode 100644
index 000000000..a2c0b40db
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_linux.go
@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package logrus
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS
+
+type Termios syscall.Termios
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go b/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
new file mode 100644
index 000000000..4bb537602
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_notwindows.go
@@ -0,0 +1,21 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux darwin freebsd openbsd netbsd dragonfly
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stdout
+ var termios Termios
+ _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+ return err == 0
+}
diff --git a/vendor/github.com/Sirupsen/logrus/terminal_windows.go b/vendor/github.com/Sirupsen/logrus/terminal_windows.go
new file mode 100644
index 000000000..2e09f6f7e
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/terminal_windows.go
@@ -0,0 +1,27 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package logrus
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+ procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTerminal returns true if the given file descriptor is a terminal.
+func IsTerminal() bool {
+ fd := syscall.Stdout
+ var st uint32
+ r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
+ return r != 0 && e == 0
+}
diff --git a/vendor/github.com/Sirupsen/logrus/text_formatter.go b/vendor/github.com/Sirupsen/logrus/text_formatter.go
new file mode 100644
index 000000000..17cc29848
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/text_formatter.go
@@ -0,0 +1,159 @@
+package logrus
+
+import (
+ "bytes"
+ "fmt"
+ "runtime"
+ "sort"
+ "strings"
+ "time"
+)
+
+const (
+ nocolor = 0
+ red = 31
+ green = 32
+ yellow = 33
+ blue = 34
+ gray = 37
+)
+
+var (
+ baseTimestamp time.Time
+ isTerminal bool
+)
+
+func init() {
+ baseTimestamp = time.Now()
+ isTerminal = IsTerminal()
+}
+
+func miniTS() int {
+ return int(time.Since(baseTimestamp) / time.Second)
+}
+
+type TextFormatter struct {
+ // Set to true to bypass checking for a TTY before outputting colors.
+ ForceColors bool
+
+ // Force disabling colors.
+ DisableColors bool
+
+ // Disable timestamp logging. useful when output is redirected to logging
+ // system that already adds timestamps.
+ DisableTimestamp bool
+
+ // Enable logging the full timestamp when a TTY is attached instead of just
+ // the time passed since beginning of execution.
+ FullTimestamp bool
+
+ // TimestampFormat to use for display when a full timestamp is printed
+ TimestampFormat string
+
+ // The fields are sorted by default for a consistent output. For applications
+ // that log extremely frequently and don't use the JSON formatter this may not
+ // be desired.
+ DisableSorting bool
+}
+
+func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
+ var keys []string = make([]string, 0, len(entry.Data))
+ for k := range entry.Data {
+ keys = append(keys, k)
+ }
+
+ if !f.DisableSorting {
+ sort.Strings(keys)
+ }
+
+ b := &bytes.Buffer{}
+
+ prefixFieldClashes(entry.Data)
+
+ isColorTerminal := isTerminal && (runtime.GOOS != "windows")
+ isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors
+
+ timestampFormat := f.TimestampFormat
+ if timestampFormat == "" {
+ timestampFormat = DefaultTimestampFormat
+ }
+ if isColored {
+ f.printColored(b, entry, keys, timestampFormat)
+ } else {
+ if !f.DisableTimestamp {
+ f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
+ }
+ f.appendKeyValue(b, "level", entry.Level.String())
+ f.appendKeyValue(b, "msg", entry.Message)
+ for _, key := range keys {
+ f.appendKeyValue(b, key, entry.Data[key])
+ }
+ }
+
+ b.WriteByte('\n')
+ return b.Bytes(), nil
+}
+
+func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
+ var levelColor int
+ switch entry.Level {
+ case DebugLevel:
+ levelColor = gray
+ case WarnLevel:
+ levelColor = yellow
+ case ErrorLevel, FatalLevel, PanicLevel:
+ levelColor = red
+ default:
+ levelColor = blue
+ }
+
+ levelText := strings.ToUpper(entry.Level.String())[0:4]
+
+ if !f.FullTimestamp {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)
+ } else {
+ fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
+ }
+ for _, k := range keys {
+ v := entry.Data[k]
+ fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v)
+ }
+}
+
+func needsQuoting(text string) bool {
+ for _, ch := range text {
+ if !((ch >= 'a' && ch <= 'z') ||
+ (ch >= 'A' && ch <= 'Z') ||
+ (ch >= '0' && ch <= '9') ||
+ ch == '-' || ch == '.') {
+ return false
+ }
+ }
+ return true
+}
+
+func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
+
+ b.WriteString(key)
+ b.WriteByte('=')
+
+ switch value := value.(type) {
+ case string:
+ if needsQuoting(value) {
+ b.WriteString(value)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ case error:
+ errmsg := value.Error()
+ if needsQuoting(errmsg) {
+ b.WriteString(errmsg)
+ } else {
+ fmt.Fprintf(b, "%q", value)
+ }
+ default:
+ fmt.Fprint(b, value)
+ }
+
+ b.WriteByte(' ')
+}
diff --git a/vendor/github.com/Sirupsen/logrus/writer.go b/vendor/github.com/Sirupsen/logrus/writer.go
new file mode 100644
index 000000000..1e30b1c75
--- /dev/null
+++ b/vendor/github.com/Sirupsen/logrus/writer.go
@@ -0,0 +1,31 @@
+package logrus
+
+import (
+ "bufio"
+ "io"
+ "runtime"
+)
+
+func (logger *Logger) Writer() *io.PipeWriter {
+ reader, writer := io.Pipe()
+
+ go logger.writerScanner(reader)
+ runtime.SetFinalizer(writer, writerFinalizer)
+
+ return writer
+}
+
+func (logger *Logger) writerScanner(reader *io.PipeReader) {
+ scanner := bufio.NewScanner(reader)
+ for scanner.Scan() {
+ logger.Print(scanner.Text())
+ }
+ if err := scanner.Err(); err != nil {
+ logger.Errorf("Error while reading from Writer: %s", err)
+ }
+ reader.Close()
+}
+
+func writerFinalizer(writer *io.PipeWriter) {
+ writer.Close()
+}
diff --git a/vendor/github.com/carlescere/scheduler/LICENSE b/vendor/github.com/carlescere/scheduler/LICENSE
new file mode 100644
index 000000000..f889f0551
--- /dev/null
+++ b/vendor/github.com/carlescere/scheduler/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Carles Cerezo Guzmán
+
+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/carlescere/scheduler/README.md b/vendor/github.com/carlescere/scheduler/README.md
new file mode 100644
index 000000000..5339766e2
--- /dev/null
+++ b/vendor/github.com/carlescere/scheduler/README.md
@@ -0,0 +1,39 @@
+# scheduler
+[](https://godoc.org/github.com/carlescere/scheduler)
+[](https://travis-ci.org/carlescere/scheduler)
+[](https://coveralls.io/r/carlescere/scheduler?branch=master)
+
+Job scheduling made easy.
+
+Scheduler allows you to schedule recurrent jobs with an easy-to-read syntax.
+
+Inspired by the article **[Rethinking Cron](http://adam.heroku.com/past/2010/4/13/rethinking_cron/)** and the **[schedule](https://github.com/dbader/schedule)** python module.
+
+## How to use?
+```go
+job := func() {
+ fmt.Println("Time's up!")
+}
+
+scheduler.Every(5).Minutes().Run(job)
+scheduler.Every().Day().Run(job)
+scheduler.Every().Monday().At("08:30").Run(job)
+```
+
+## How it works?
+By specifying the chain of calls, a `Job` struct is instantiated and a goroutine is starts observing the `Job`.
+
+The goroutine will be on pause until:
+* The next run scheduled is due. This will cause to execute the job.
+* The `SkipWait` channel is activated. This will cause to execute the job.
+* The `Quit` channel is activated. This will cause to finish the job.
+
+## Not immediate recurrent jobs
+By default the behaviour of the recurrent jobs (Every(N) seconds, minutes, hours) is to start executing the job right away and then wait the required amount of time. By calling specifically `.NotImmediately()` you can override that behaviour and not execute it directly when the function `Run()` is called.
+
+```go
+scheduler.Every(5).Minutes().NotImmediately().Run(job)
+```
+
+## License
+Distributed under MIT license. See `LICENSE` for more information.
diff --git a/vendor/github.com/carlescere/scheduler/scheduler.go b/vendor/github.com/carlescere/scheduler/scheduler.go
new file mode 100644
index 000000000..010c0909f
--- /dev/null
+++ b/vendor/github.com/carlescere/scheduler/scheduler.go
@@ -0,0 +1,315 @@
+// Package scheduler is a cron replacement based on:
+// http://adam.herokuapp.com/past/2010/4/13/rethinking_cron/
+// and
+// https://github.com/dbader/schedule
+//
+// Uses include:
+// func main() {
+// job := func() {
+// fmt.Println("Time's up!")
+// }
+// scheduler.Every(5).Seconds().Run(function)
+// scheduler.Every().Day().Run(function)
+// scheduler.Every().Sunday().At("08:30").Run(function)
+// }
+package scheduler
+
+import (
+ "errors"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type scheduled interface {
+ nextRun() (time.Duration, error)
+}
+
+// Job defines a running job and allows to stop a scheduled job or run it.
+type Job struct {
+ fn func()
+ Quit chan bool
+ SkipWait chan bool
+ err error
+ schedule scheduled
+ isRunning bool
+}
+
+type recurrent struct {
+ units int
+ period time.Duration
+ done bool
+}
+
+func (r *recurrent) nextRun() (time.Duration, error) {
+ if r.units == 0 || r.period == 0 {
+ return 0, errors.New("cannot set recurrent time with 0")
+ }
+ if !r.done {
+ r.done = true
+ return 0, nil
+ }
+ return time.Duration(r.units) * r.period, nil
+}
+
+type daily struct {
+ hour int
+ min int
+ sec int
+}
+
+func (d *daily) setTime(h, m, s int) {
+ d.hour = h
+ d.min = m
+ d.sec = s
+}
+
+func (d daily) nextRun() (time.Duration, error) {
+ now := time.Now()
+ year, month, day := now.Date()
+ date := time.Date(year, month, day, d.hour, d.min, d.sec, 0, time.Local)
+ if now.Before(date) {
+ return date.Sub(now), nil
+ }
+ date = time.Date(year, month, day+1, d.hour, d.min, d.sec, 0, time.Local)
+ return date.Sub(now), nil
+}
+
+type weekly struct {
+ day time.Weekday
+ d daily
+}
+
+func (w weekly) nextRun() (time.Duration, error) {
+ now := time.Now()
+ year, month, day := now.Date()
+ numDays := w.day - now.Weekday()
+ if numDays == 0 {
+ numDays = 7
+ } else if numDays < 0 {
+ numDays += 7
+ }
+ date := time.Date(year, month, day+int(numDays), w.d.hour, w.d.min, w.d.sec, 0, time.Local)
+ return date.Sub(now), nil
+}
+
+// Every defines when to run a job. For a recurrent jobs (n seconds/minutes/hours) you
+// should specify the unit and then call to the correspondent period method.
+func Every(times ...int) *Job {
+ switch len(times) {
+ case 0:
+ return &Job{}
+ case 1:
+ r := new(recurrent)
+ r.units = times[0]
+ return &Job{schedule: r}
+ default:
+ // Yeah... I don't like it either. But go does not support default
+ // parameters nor method overloading. In an ideal world should
+ // return an error at compile time not at runtime. :/
+ return &Job{err: errors.New("too many arguments in Every")}
+ }
+}
+
+// NotImmediately allows recurrent jobs not to be executed immediatelly after
+// definition. If a job is declared hourly won't start executing until the first hour
+// passed.
+func (j *Job) NotImmediately() *Job {
+ rj, ok := j.schedule.(*recurrent)
+ if !ok {
+ j.err = errors.New("bad function chaining")
+ return j
+ }
+ rj.done = true
+ return j
+}
+
+// At lets you define a specific time when the job would be run. Does not work with
+// recurrent jobs.
+// Time should be defined as a string separated by a colon. Could be used as "08:35:30",
+// "08:35" or "8" for only the hours.
+func (j *Job) At(hourTime string) *Job {
+ if j.err != nil {
+ return j
+ }
+ hour, min, sec, err := parseTime(hourTime)
+ if err != nil {
+ j.err = err
+ return j
+ }
+ d, ok := j.schedule.(daily)
+ if !ok {
+ w, ok := j.schedule.(weekly)
+ if !ok {
+ j.err = errors.New("bad function chaining")
+ return j
+ }
+ w.d.setTime(hour, min, sec)
+ j.schedule = w
+ } else {
+ d.setTime(hour, min, sec)
+ j.schedule = d
+ }
+ return j
+}
+
+// Run sets the job to the schedule and returns the pointer to the job so it may be
+// stopped or executed without waiting or an error.
+func (j *Job) Run(f func()) (*Job, error) {
+ if j.err != nil {
+ return nil, j.err
+ }
+ var next time.Duration
+ var err error
+ j.Quit = make(chan bool, 1)
+ j.SkipWait = make(chan bool, 1)
+ j.fn = f
+ // Check for possible errors in scheduling
+ next, err = j.schedule.nextRun()
+ if err != nil {
+ return nil, err
+ }
+ go func(j *Job) {
+ for {
+ select {
+ case <-j.Quit:
+ return
+ case <-j.SkipWait:
+ go func(j *Job) {
+ j.isRunning = true
+ j.fn()
+ j.isRunning = false
+ }(j)
+ case <-time.After(next):
+ go func(j *Job) {
+ j.isRunning = true
+ j.fn()
+ j.isRunning = false
+ }(j)
+ }
+ next, _ = j.schedule.nextRun()
+ }
+ }(j)
+ return j, nil
+}
+
+func parseTime(str string) (hour, min, sec int, err error) {
+ chunks := strings.Split(str, ":")
+ var hourStr, minStr, secStr string
+ switch len(chunks) {
+ case 1:
+ hourStr = chunks[0]
+ minStr = "0"
+ secStr = "0"
+ case 2:
+ hourStr = chunks[0]
+ minStr = chunks[1]
+ secStr = "0"
+ case 3:
+ hourStr = chunks[0]
+ minStr = chunks[1]
+ secStr = chunks[2]
+ }
+ hour, err = strconv.Atoi(hourStr)
+ if err != nil {
+ return 0, 0, 0, errors.New("bad time")
+ }
+ min, err = strconv.Atoi(minStr)
+ if err != nil {
+ return 0, 0, 0, errors.New("bad time")
+ }
+ sec, err = strconv.Atoi(secStr)
+ if err != nil {
+ return 0, 0, 0, errors.New("bad time")
+ }
+
+ if hour > 23 || min > 59 || sec > 59 {
+ return 0, 0, 0, errors.New("bad time")
+ }
+
+ return
+}
+
+func (j *Job) dayOfWeek(d time.Weekday) *Job {
+ if j.schedule != nil {
+ j.err = errors.New("bad function chaining")
+ }
+ j.schedule = weekly{day: d}
+ return j
+}
+
+// Monday sets the job to run every Monday.
+func (j *Job) Monday() *Job {
+ return j.dayOfWeek(time.Monday)
+}
+
+// Tuesday sets the job to run every Tuesday.
+func (j *Job) Tuesday() *Job {
+ return j.dayOfWeek(time.Tuesday)
+}
+
+// Wednesday sets the job to run every Wednesday.
+func (j *Job) Wednesday() *Job {
+ return j.dayOfWeek(time.Wednesday)
+}
+
+// Thursday sets the job to run every Thursday.
+func (j *Job) Thursday() *Job {
+ return j.dayOfWeek(time.Thursday)
+}
+
+// Friday sets the job to run every Friday.
+func (j *Job) Friday() *Job {
+ return j.dayOfWeek(time.Friday)
+}
+
+// Saturday sets the job to run every Saturday.
+func (j *Job) Saturday() *Job {
+ return j.dayOfWeek(time.Saturday)
+}
+
+// Sunday sets the job to run every Sunday.
+func (j *Job) Sunday() *Job {
+ return j.dayOfWeek(time.Sunday)
+}
+
+// Day sets the job to run every day.
+func (j *Job) Day() *Job {
+ if j.schedule != nil {
+ j.err = errors.New("bad function chaining")
+ }
+ j.schedule = daily{}
+ return j
+}
+
+func (j *Job) timeOfDay(d time.Duration) *Job {
+ if j.err != nil {
+ return j
+ }
+ r := j.schedule.(*recurrent)
+ r.period = d
+ j.schedule = r
+ return j
+}
+
+// Seconds sets the job to run every n Seconds where n was defined in the Every
+// function.
+func (j *Job) Seconds() *Job {
+ return j.timeOfDay(time.Second)
+}
+
+// Minutes sets the job to run every n Minutes where n was defined in the Every
+// function.
+func (j *Job) Minutes() *Job {
+ return j.timeOfDay(time.Minute)
+}
+
+// Hours sets the job to run every n Hours where n was defined in the Every function.
+func (j *Job) Hours() *Job {
+ return j.timeOfDay(time.Hour)
+}
+
+// IsRunning returns if the job is currently running
+func (j *Job) IsRunning() bool {
+ return j.isRunning
+}
diff --git a/vendor/github.com/facchinm/go-serial/LICENSE b/vendor/github.com/facchinm/go-serial/LICENSE
new file mode 100644
index 000000000..565e93b27
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/LICENSE
@@ -0,0 +1,33 @@
+
+Copyright (c) 2014, Cristian Maglie.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT 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/facchinm/go-serial/doc.go b/vendor/github.com/facchinm/go-serial/doc.go
new file mode 100644
index 000000000..b80999d82
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/doc.go
@@ -0,0 +1,85 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+/*
+This is a cross-platform serial library for go.
+
+The canonical import for this library is go.bug.st/serial so the import line
+is the following:
+
+ import "go.bug.st/serial"
+
+It is possibile to get the list of available serial ports with the
+GetPortsList function:
+
+ ports, err := serial.GetPortsList()
+ if err != nil {
+ log.Fatal(err)
+ }
+ if len(ports) == 0 {
+ log.Fatal("No serial ports found!")
+ }
+ for _, port := range ports {
+ fmt.Printf("Found port: %v\n", port)
+ }
+
+The serial port can be opened with the OpenPort function:
+
+ mode := &serial.Mode{
+ BaudRate: 115200,
+ }
+ port, err := serial.OpenPort("/dev/ttyUSB0", mode)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+The OpenPort command needs a "mode" parameter that specifies the configuration
+options for the serial port. If not specified the default options are 9600_N81,
+in the example above only the speed is changed so the port is opened using 115200_N81.
+The following snippets shows how to declare a configuration for 57600_E71:
+
+ mode := &serial.Mode{
+ BaudRate: 57600,
+ Parity: serial.PARITY_EVEN,
+ DataBits: 7,
+ StopBits: serial.STOPBITS_ONE,
+ }
+
+The configuration can be changed at any time with the SetMode function:
+
+ err := port.SetMode(mode)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+The port object implements the io.ReadWriteCloser interface, so we can use
+the usual Read, Write and Close functions to send and receive data from the
+serial port:
+
+ n, err := port.Write([]byte("10,20,30\n\r"))
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Printf("Sent %v bytes\n", n)
+
+ buff := make([]byte, 100)
+ for {
+ n, err := port.Read(buff)
+ if err != nil {
+ log.Fatal(err)
+ break
+ }
+ if n == 0 {
+ fmt.Println("\nEOF")
+ break
+ }
+ fmt.Printf("%v", string(buff[:n]))
+ }
+
+This library doesn't make use of cgo and "C" package, so it's a pure go library
+that can be easily cross compiled.
+*/
+package serial
diff --git a/vendor/github.com/facchinm/go-serial/serial.go b/vendor/github.com/facchinm/go-serial/serial.go
new file mode 100644
index 000000000..a5cf40b3f
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial.go
@@ -0,0 +1,78 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+package serial
+
+// This structure describes a serial port configuration.
+type Mode struct {
+ BaudRate int // The serial port bitrate (aka Baudrate)
+ DataBits int // Size of the character (must be 5, 6, 7 or 8)
+ Parity Parity // Parity (see Parity type for more info)
+ StopBits StopBits // Stop bits (see StopBits type for more info)
+ Vmin uint8 // Vmin (minimum characters to receive before returning)
+ Vtimeout uint8 // VTimeout (minimum time to wait before returning)
+}
+
+type Parity int
+
+const (
+ PARITY_NONE Parity = iota // No parity (default)
+ PARITY_ODD // Odd parity
+ PARITY_EVEN // Even parity
+ PARITY_MARK // Mark parity (always 1)
+ PARITY_SPACE // Space parity (always 0)
+)
+
+type StopBits int
+
+const (
+ STOPBITS_ONE StopBits = iota // 1 Stop bit
+ STOPBITS_ONEPOINTFIVE // 1.5 Stop bits
+ STOPBITS_TWO // 2 Stop bits
+)
+
+// Platform independent error type for serial ports
+type SerialPortError struct {
+ err string
+ code int
+}
+
+const (
+ ERROR_PORT_BUSY = iota
+ ERROR_PORT_NOT_FOUND
+ ERROR_INVALID_SERIAL_PORT
+ ERROR_PERMISSION_DENIED
+ ERROR_INVALID_PORT_SPEED
+ ERROR_INVALID_PORT_DATA_BITS
+ ERROR_ENUMERATING_PORTS
+ ERROR_OTHER
+)
+
+func (e SerialPortError) Error() string {
+ switch e.code {
+ case ERROR_PORT_BUSY:
+ return "Serial port busy"
+ case ERROR_PORT_NOT_FOUND:
+ return "Serial port not found"
+ case ERROR_INVALID_SERIAL_PORT:
+ return "Invalid serial port"
+ case ERROR_PERMISSION_DENIED:
+ return "Permission denied"
+ case ERROR_INVALID_PORT_SPEED:
+ return "Invalid port speed"
+ case ERROR_INVALID_PORT_DATA_BITS:
+ return "Invalid port data bits"
+ case ERROR_ENUMERATING_PORTS:
+ return "Could not enumerate serial ports"
+ }
+ return e.err
+}
+
+func (e SerialPortError) Code() int {
+ return e.code
+}
+
+// vi:ts=2
diff --git a/vendor/github.com/facchinm/go-serial/serial_darwin.go b/vendor/github.com/facchinm/go-serial/serial_darwin.go
new file mode 100644
index 000000000..ce26174d8
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_darwin.go
@@ -0,0 +1,54 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+package serial
+
+import "syscall"
+
+const devFolder = "/dev"
+const regexFilter = "^(cu|tty)\\..*"
+
+// termios manipulation functions
+
+var baudrateMap = map[int]int{
+ 0: syscall.B9600, // Default to 9600
+ 50: syscall.B50,
+ 75: syscall.B75,
+ 110: syscall.B110,
+ 134: syscall.B134,
+ 150: syscall.B150,
+ 200: syscall.B200,
+ 300: syscall.B300,
+ 600: syscall.B600,
+ 1200: syscall.B1200,
+ 1800: syscall.B1800,
+ 2400: syscall.B2400,
+ 4800: syscall.B4800,
+ 9600: syscall.B9600,
+ 19200: syscall.B19200,
+ 38400: syscall.B38400,
+ 57600: syscall.B57600,
+ 115200: syscall.B115200,
+ 230400: syscall.B230400,
+}
+
+var databitsMap = map[int]int{
+ 0: syscall.CS8, // Default to 8 bits
+ 5: syscall.CS5,
+ 6: syscall.CS6,
+ 7: syscall.CS7,
+ 8: syscall.CS8,
+}
+
+const tc_CMSPAR int = 0 // may be CMSPAR or PAREXT
+const tc_IUCLC int = 0
+
+// syscall wrappers
+
+//sys ioctl(fd int, req uint64, data uintptr) (err error)
+
+const ioctl_tcgetattr = syscall.TIOCGETA
+const ioctl_tcsetattr = syscall.TIOCSETA
diff --git a/vendor/github.com/facchinm/go-serial/serial_darwin_386.go b/vendor/github.com/facchinm/go-serial/serial_darwin_386.go
new file mode 100644
index 000000000..ce70d4ef3
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_darwin_386.go
@@ -0,0 +1,11 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+package serial
+
+func termiosMask(data int) uint32 {
+ return uint32(data)
+}
diff --git a/vendor/github.com/facchinm/go-serial/serial_darwin_amd64.go b/vendor/github.com/facchinm/go-serial/serial_darwin_amd64.go
new file mode 100644
index 000000000..0529e03a8
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_darwin_amd64.go
@@ -0,0 +1,13 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+package serial
+
+// termios manipulation functions
+
+func termiosMask(data int) uint64 {
+ return uint64(data)
+}
diff --git a/vendor/github.com/facchinm/go-serial/serial_linux.go b/vendor/github.com/facchinm/go-serial/serial_linux.go
new file mode 100644
index 000000000..4149fb885
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_linux.go
@@ -0,0 +1,71 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+package serial
+
+import "syscall"
+
+const devFolder = "/dev"
+const regexFilter = "(ttyS|ttyUSB|ttyACM|ttyAMA|rfcomm|ttyO)[0-9]{1,3}"
+
+// termios manipulation functions
+
+var baudrateMap = map[int]int{
+ 0: syscall.B9600, // Default to 9600
+ 50: syscall.B50,
+ 75: syscall.B75,
+ 110: syscall.B110,
+ 134: syscall.B134,
+ 150: syscall.B150,
+ 200: syscall.B200,
+ 300: syscall.B300,
+ 600: syscall.B600,
+ 1200: syscall.B1200,
+ 1800: syscall.B1800,
+ 2400: syscall.B2400,
+ 4800: syscall.B4800,
+ 9600: syscall.B9600,
+ 19200: syscall.B19200,
+ 38400: syscall.B38400,
+ 57600: syscall.B57600,
+ 115200: syscall.B115200,
+ 230400: syscall.B230400,
+ 460800: syscall.B460800,
+ 500000: syscall.B500000,
+ 576000: syscall.B576000,
+ 921600: syscall.B921600,
+ 1000000: syscall.B1000000,
+ 1152000: syscall.B1152000,
+ 1500000: syscall.B1500000,
+ 2000000: syscall.B2000000,
+ 2500000: syscall.B2500000,
+ 3000000: syscall.B3000000,
+ 3500000: syscall.B3500000,
+ 4000000: syscall.B4000000,
+}
+
+var databitsMap = map[int]int{
+ 0: syscall.CS8, // Default to 8 bits
+ 5: syscall.CS5,
+ 6: syscall.CS6,
+ 7: syscall.CS7,
+ 8: syscall.CS8,
+}
+
+const tc_CMSPAR int = 0 // may be CMSPAR or PAREXT
+const tc_IUCLC = syscall.IUCLC
+
+func termiosMask(data int) uint32 {
+ return uint32(data)
+}
+
+// syscall wrappers
+
+//sys ioctl(fd int, req uint64, data uintptr) (err error)
+
+const ioctl_tcgetattr = syscall.TCGETS
+const ioctl_tcsetattr = syscall.TCSETS
+const ioctl_tiocmdtr = syscall.TIOCM_DTR
diff --git a/vendor/github.com/facchinm/go-serial/serial_unix.go b/vendor/github.com/facchinm/go-serial/serial_unix.go
new file mode 100644
index 000000000..bba7ae8f8
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_unix.go
@@ -0,0 +1,268 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+// +build linux darwin
+
+package serial
+
+import "io/ioutil"
+import "regexp"
+import "strings"
+import "syscall"
+import "unsafe"
+
+// Opaque type that implements SerialPort interface for linux
+type SerialPort struct {
+ handle int
+}
+
+// Close the serial port
+func (port *SerialPort) Close() error {
+ port.releaseExclusiveAccess()
+ return syscall.Close(port.handle)
+}
+
+// Stores data received from the serial port into the provided byte array
+// buffer. The function returns the number of bytes read.
+//
+// The Read function blocks until (at least) one byte is received from
+// the serial port or an error occurs.
+func (port *SerialPort) Read(p []byte) (n int, err error) {
+ return syscall.Read(port.handle, p)
+}
+
+// Send the content of the data byte array to the serial port.
+// Returns the number of bytes written.
+func (port *SerialPort) Write(p []byte) (n int, err error) {
+ return syscall.Write(port.handle, p)
+}
+
+// Set all parameters of the serial port. See the Mode structure for more
+// info.
+func (port *SerialPort) SetMode(mode *Mode) error {
+ settings, err := port.getTermSettings()
+ if err != nil {
+ return err
+ }
+ if err := setTermSettingsBaudrate(mode.BaudRate, settings); err != nil {
+ return err
+ }
+ if err := setTermSettingsParity(mode.Parity, settings); err != nil {
+ return err
+ }
+ if err := setTermSettingsDataBits(mode.DataBits, settings); err != nil {
+ return err
+ }
+ if err := setTermSettingsStopBits(mode.StopBits, settings); err != nil {
+ return err
+ }
+ return port.setTermSettings(settings)
+}
+
+// Open the serial port using the specified modes
+func OpenPort(portName string, mode *Mode) (*SerialPort, error) {
+ h, err := syscall.Open(portName, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NDELAY, 0)
+ if err != nil {
+ switch err {
+ case syscall.EBUSY:
+ return nil, &SerialPortError{code: ERROR_PORT_BUSY}
+ case syscall.EACCES:
+ return nil, &SerialPortError{code: ERROR_PERMISSION_DENIED}
+ }
+ return nil, err
+ }
+ port := &SerialPort{
+ handle: h,
+ }
+
+ // Setup serial port
+ if port.SetMode(mode) != nil {
+ port.Close()
+ return nil, &SerialPortError{code: ERROR_INVALID_SERIAL_PORT}
+ }
+
+ // Set raw mode
+ settings, err := port.getTermSettings()
+ if err != nil {
+ port.Close()
+ return nil, &SerialPortError{code: ERROR_INVALID_SERIAL_PORT}
+ }
+ setRawMode(settings, mode)
+ if port.setTermSettings(settings) != nil {
+ port.Close()
+ return nil, &SerialPortError{code: ERROR_INVALID_SERIAL_PORT}
+ }
+
+ syscall.SetNonblock(h, false)
+
+ port.acquireExclusiveAccess()
+
+ return port, nil
+}
+
+func GetPortsList() ([]string, error) {
+ files, err := ioutil.ReadDir(devFolder)
+ if err != nil {
+ return nil, err
+ }
+
+ ports := make([]string, 0, len(files))
+ for _, f := range files {
+ // Skip folders
+ if f.IsDir() {
+ continue
+ }
+
+ // Keep only devices with the correct name
+ match, err := regexp.MatchString(regexFilter, f.Name())
+ if err != nil {
+ return nil, err
+ }
+ if !match {
+ continue
+ }
+
+ portName := devFolder + "/" + f.Name()
+
+ // Check if serial port is real or is a placeholder serial port "ttySxx"
+ if strings.HasPrefix(f.Name(), "ttyS") {
+ port, err := OpenPort(portName, &Mode{})
+ if err != nil {
+ serr, ok := err.(*SerialPortError)
+ if ok && serr.Code() == ERROR_INVALID_SERIAL_PORT {
+ continue
+ }
+ } else {
+ port.Close()
+ }
+ }
+
+ // Save serial port in the resulting list
+ ports = append(ports, portName)
+ }
+
+ return ports, nil
+}
+
+// termios manipulation functions
+
+func setTermSettingsBaudrate(speed int, settings *syscall.Termios) error {
+ baudrate, ok := baudrateMap[speed]
+ if !ok {
+ return &SerialPortError{code: ERROR_INVALID_PORT_SPEED}
+ }
+ // revert old baudrate
+ BAUDMASK := 0
+ for _, rate := range baudrateMap {
+ BAUDMASK |= rate
+ }
+ settings.Cflag &= ^termiosMask(BAUDMASK)
+ // set new baudrate
+ settings.Cflag |= termiosMask(baudrate)
+ settings.Ispeed = termiosMask(baudrate)
+ settings.Ospeed = termiosMask(baudrate)
+ return nil
+}
+
+func setTermSettingsParity(parity Parity, settings *syscall.Termios) error {
+ switch parity {
+ case PARITY_NONE:
+ settings.Cflag &= ^termiosMask(syscall.PARENB | syscall.PARODD | tc_CMSPAR)
+ settings.Iflag &= ^termiosMask(syscall.INPCK)
+ case PARITY_ODD:
+ settings.Cflag |= termiosMask(syscall.PARENB | syscall.PARODD)
+ settings.Cflag &= ^termiosMask(tc_CMSPAR)
+ settings.Iflag |= termiosMask(syscall.INPCK)
+ case PARITY_EVEN:
+ settings.Cflag &= ^termiosMask(syscall.PARODD | tc_CMSPAR)
+ settings.Cflag |= termiosMask(syscall.PARENB)
+ settings.Iflag |= termiosMask(syscall.INPCK)
+ case PARITY_MARK:
+ settings.Cflag |= termiosMask(syscall.PARENB | syscall.PARODD | tc_CMSPAR)
+ settings.Iflag |= termiosMask(syscall.INPCK)
+ case PARITY_SPACE:
+ settings.Cflag &= ^termiosMask(syscall.PARODD)
+ settings.Cflag |= termiosMask(syscall.PARENB | tc_CMSPAR)
+ settings.Iflag |= termiosMask(syscall.INPCK)
+ }
+ return nil
+}
+
+func setTermSettingsDataBits(bits int, settings *syscall.Termios) error {
+ databits, ok := databitsMap[bits]
+ if !ok {
+ return &SerialPortError{code: ERROR_INVALID_PORT_DATA_BITS}
+ }
+ settings.Cflag &= ^termiosMask(syscall.CSIZE)
+ settings.Cflag |= termiosMask(databits)
+ return nil
+}
+
+func setTermSettingsStopBits(bits StopBits, settings *syscall.Termios) error {
+ switch bits {
+ case STOPBITS_ONE:
+ settings.Cflag &= ^termiosMask(syscall.CSTOPB)
+ case STOPBITS_ONEPOINTFIVE, STOPBITS_TWO:
+ settings.Cflag |= termiosMask(syscall.CSTOPB)
+ }
+ return nil
+}
+
+func setRawMode(settings *syscall.Termios, mode *Mode) {
+ // Set local mode
+ settings.Cflag |= termiosMask(syscall.CREAD | syscall.CLOCAL)
+
+ // Set raw mode
+ settings.Lflag &= ^termiosMask(syscall.ICANON | syscall.ECHO | syscall.ECHOE | syscall.ECHOK |
+ syscall.ECHONL | syscall.ECHOCTL | syscall.ECHOPRT | syscall.ECHOKE | syscall.ISIG | syscall.IEXTEN)
+ settings.Iflag &= ^termiosMask(syscall.IXON | syscall.IXOFF | syscall.IXANY | syscall.INPCK |
+ syscall.IGNPAR | syscall.PARMRK | syscall.ISTRIP | syscall.IGNBRK | syscall.BRKINT | syscall.INLCR |
+ syscall.IGNCR | syscall.ICRNL | tc_IUCLC)
+ settings.Oflag &= ^termiosMask(syscall.OPOST)
+
+ if mode.Vmin == 0 && mode.Vtimeout == 0 {
+ // Switch to default mode
+ // Block reads until at least one char is available (no timeout)
+ mode.Vmin = 1
+ }
+
+ settings.Cc[syscall.VMIN] = mode.Vmin
+ settings.Cc[syscall.VTIME] = mode.Vtimeout
+}
+
+// native syscall wrapper functions
+
+func (port *SerialPort) getTermSettings() (*syscall.Termios, error) {
+ settings := &syscall.Termios{}
+ err := ioctl(port.handle, ioctl_tcgetattr, uintptr(unsafe.Pointer(settings)))
+ return settings, err
+}
+
+func (port *SerialPort) setTermSettings(settings *syscall.Termios) error {
+ return ioctl(port.handle, ioctl_tcsetattr, uintptr(unsafe.Pointer(settings)))
+}
+
+func (port *SerialPort) acquireExclusiveAccess() error {
+ return ioctl(port.handle, syscall.TIOCEXCL, 0)
+}
+
+func (port *SerialPort) releaseExclusiveAccess() error {
+ return ioctl(port.handle, syscall.TIOCNXCL, 0)
+}
+
+func (port *SerialPort) SetDTR(level bool) error {
+ var status uint
+ _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(port.handle), uintptr(syscall.TIOCMGET), uintptr(unsafe.Pointer(&status)))
+ if err == 0 {
+ if level == false {
+ status &= ^uint(syscall.TIOCM_DTR)
+ } else {
+ status |= syscall.TIOCM_DTR
+ }
+ _, _, err = syscall.Syscall(syscall.SYS_IOCTL, uintptr(port.handle), uintptr(syscall.TIOCMSET), uintptr(unsafe.Pointer(&status)))
+ }
+ return err
+}
diff --git a/vendor/github.com/facchinm/go-serial/serial_windows.go b/vendor/github.com/facchinm/go-serial/serial_windows.go
new file mode 100644
index 000000000..5043be460
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/serial_windows.go
@@ -0,0 +1,360 @@
+// +build windows
+
+package serial
+
+import (
+ "fmt"
+ "os"
+ "sync"
+ "syscall"
+ "time"
+ "unsafe"
+)
+
+type SerialPort struct {
+ p *Port
+}
+
+type Port struct {
+ f *os.File
+ fd syscall.Handle
+ rl sync.Mutex
+ wl sync.Mutex
+ ro *syscall.Overlapped
+ wo *syscall.Overlapped
+}
+
+type structDCB struct {
+ DCBlength, BaudRate uint32
+ flags [4]byte
+ wReserved, XonLim, XoffLim uint16
+ ByteSize, Parity, StopBits byte
+ XonChar, XoffChar, ErrorChar, EofChar, EvtChar byte
+ wReserved1 uint16
+}
+
+type structTimeouts struct {
+ ReadIntervalTimeout uint32
+ ReadTotalTimeoutMultiplier uint32
+ ReadTotalTimeoutConstant uint32
+ WriteTotalTimeoutMultiplier uint32
+ WriteTotalTimeoutConstant uint32
+}
+
+func GetPortsList() ([]string, error) {
+ subKey, err := syscall.UTF16PtrFromString("HARDWARE\\DEVICEMAP\\SERIALCOMM\\")
+ if err != nil {
+ return nil, &SerialPortError{code: ERROR_ENUMERATING_PORTS}
+ }
+
+ var h syscall.Handle
+ if syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, subKey, 0, syscall.KEY_READ, &h) != nil {
+ return nil, &SerialPortError{code: ERROR_ENUMERATING_PORTS}
+ }
+ defer syscall.RegCloseKey(h)
+
+ var valuesCount uint32
+ if syscall.RegQueryInfoKey(h, nil, nil, nil, nil, nil, nil, &valuesCount, nil, nil, nil, nil) != nil {
+ return nil, &SerialPortError{code: ERROR_ENUMERATING_PORTS}
+ }
+
+ list := make([]string, valuesCount)
+ for i := range list {
+ var data [1024]uint16
+ dataSize := uint32(len(data))
+ var name [1024]uint16
+ nameSize := uint32(len(name))
+ if RegEnumValue(h, uint32(i), &name[0], &nameSize, nil, nil, &data[0], &dataSize) != nil {
+ return nil, &SerialPortError{code: ERROR_ENUMERATING_PORTS}
+ }
+ list[i] = syscall.UTF16ToString(data[:])
+ }
+ return list, nil
+}
+
+func OpenPort(portName string, mode *Mode) (*SerialPort, error) {
+ p, err := openPort(portName, mode.BaudRate, time.Duration(mode.Vtimeout)*time.Millisecond)
+ if err == nil {
+ port := new(SerialPort)
+ port.p = p
+ return port, err
+ }
+ return nil, err
+}
+
+func openPort(name string, baud int, readTimeout time.Duration) (p *Port, err error) {
+ if len(name) > 0 && name[0] != '\\' {
+ name = "\\\\.\\" + name
+ }
+
+ h, err := syscall.CreateFile(syscall.StringToUTF16Ptr(name),
+ syscall.GENERIC_READ|syscall.GENERIC_WRITE,
+ 0,
+ nil,
+ syscall.OPEN_EXISTING,
+ syscall.FILE_ATTRIBUTE_NORMAL|syscall.FILE_FLAG_OVERLAPPED,
+ 0)
+ if err != nil {
+ return nil, err
+ }
+ f := os.NewFile(uintptr(h), name)
+ defer func() {
+ if err != nil {
+ f.Close()
+ }
+ }()
+
+ if err = setCommState(h, baud); err != nil {
+ return
+ }
+ if err = setupComm(h, 64, 64); err != nil {
+ return
+ }
+ if err = setCommTimeouts(h, readTimeout); err != nil {
+ return
+ }
+ if err = setCommMask(h); err != nil {
+ return
+ }
+
+ ro, err := newOverlapped()
+ if err != nil {
+ return
+ }
+ wo, err := newOverlapped()
+ if err != nil {
+ return
+ }
+ port := new(Port)
+ port.f = f
+ port.fd = h
+ port.ro = ro
+ port.wo = wo
+
+ return port, nil
+}
+
+func (p *SerialPort) Close() error {
+ return p.p.f.Close()
+}
+
+func (p *SerialPort) Write(buf []byte) (int, error) {
+ p.p.wl.Lock()
+ defer p.p.wl.Unlock()
+
+ if err := resetEvent(p.p.wo.HEvent); err != nil {
+ return 0, err
+ }
+ var n uint32
+ err := syscall.WriteFile(p.p.fd, buf, &n, p.p.wo)
+ if err != nil && err != syscall.ERROR_IO_PENDING {
+ return int(n), err
+ }
+ return getOverlappedResult(p.p.fd, p.p.wo)
+}
+
+func (p *SerialPort) Read(buf []byte) (int, error) {
+ if p.p == nil || p.p.f == nil {
+ return 0, fmt.Errorf("Invalid port on read %v %v", p.p, p.p.f)
+ }
+
+ p.p.rl.Lock()
+ defer p.p.rl.Unlock()
+
+ if err := resetEvent(p.p.ro.HEvent); err != nil {
+ return 0, err
+ }
+ var done uint32
+ err := syscall.ReadFile(p.p.fd, buf, &done, p.p.ro)
+ if err != nil && err != syscall.ERROR_IO_PENDING {
+ return int(done), err
+ }
+ return getOverlappedResult(p.p.fd, p.p.ro)
+}
+
+// Discards data written to the port but not transmitted,
+// or data received but not read
+func (p *SerialPort) Flush() error {
+ return purgeComm(p.p.fd)
+}
+
+var (
+ nSetCommState,
+ nSetCommTimeouts,
+ nSetCommMask,
+ nSetupComm,
+ nGetOverlappedResult,
+ nCreateEvent,
+ nResetEvent,
+ nPurgeComm,
+ nFlushFileBuffers uintptr
+ modadvapi32 = syscall.NewLazyDLL("advapi32.dll")
+ procRegEnumValueW = modadvapi32.NewProc("RegEnumValueW")
+)
+
+func RegEnumValue(key syscall.Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, value *uint16, valueLen *uint32) (regerrno error) {
+ r0, _, _ := syscall.Syscall9(procRegEnumValueW.Addr(), 8, uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(value)), uintptr(unsafe.Pointer(valueLen)), 0)
+ if r0 != 0 {
+ regerrno = syscall.Errno(r0)
+ }
+ return
+}
+
+func init() {
+ k32, err := syscall.LoadLibrary("kernel32.dll")
+ if err != nil {
+ panic("LoadLibrary " + err.Error())
+ }
+ defer syscall.FreeLibrary(k32)
+
+ nSetCommState = getProcAddr(k32, "SetCommState")
+ nSetCommTimeouts = getProcAddr(k32, "SetCommTimeouts")
+ nSetCommMask = getProcAddr(k32, "SetCommMask")
+ nSetupComm = getProcAddr(k32, "SetupComm")
+ nGetOverlappedResult = getProcAddr(k32, "GetOverlappedResult")
+ nCreateEvent = getProcAddr(k32, "CreateEventW")
+ nResetEvent = getProcAddr(k32, "ResetEvent")
+ nPurgeComm = getProcAddr(k32, "PurgeComm")
+ nFlushFileBuffers = getProcAddr(k32, "FlushFileBuffers")
+}
+
+func getProcAddr(lib syscall.Handle, name string) uintptr {
+ addr, err := syscall.GetProcAddress(lib, name)
+ if err != nil {
+ panic(name + " " + err.Error())
+ }
+ return addr
+}
+
+func setCommState(h syscall.Handle, baud int) error {
+ var params structDCB
+ params.DCBlength = uint32(unsafe.Sizeof(params))
+
+ params.flags[0] = 0x01 // fBinary
+ params.flags[0] |= 0x10 // Assert DSR
+
+ params.BaudRate = uint32(baud)
+ params.ByteSize = 8
+
+ r, _, err := syscall.Syscall(nSetCommState, 2, uintptr(h), uintptr(unsafe.Pointer(¶ms)), 0)
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func setCommTimeouts(h syscall.Handle, readTimeout time.Duration) error {
+ var timeouts structTimeouts
+ const MAXDWORD = 1<<32 - 1
+
+ if readTimeout > 0 {
+ // non-blocking read
+ timeoutMs := readTimeout.Nanoseconds() / 1e6
+ if timeoutMs < 1 {
+ timeoutMs = 1
+ } else if timeoutMs > MAXDWORD {
+ timeoutMs = MAXDWORD
+ }
+ timeouts.ReadIntervalTimeout = 0
+ timeouts.ReadTotalTimeoutMultiplier = 0
+ timeouts.ReadTotalTimeoutConstant = uint32(timeoutMs)
+ } else {
+ // blocking read
+ timeouts.ReadIntervalTimeout = MAXDWORD
+ timeouts.ReadTotalTimeoutMultiplier = MAXDWORD
+ timeouts.ReadTotalTimeoutConstant = MAXDWORD - 1
+ }
+
+ /* From http://msdn.microsoft.com/en-us/library/aa363190(v=VS.85).aspx
+
+ For blocking I/O see below:
+
+ Remarks:
+
+ If an application sets ReadIntervalTimeout and
+ ReadTotalTimeoutMultiplier to MAXDWORD and sets
+ ReadTotalTimeoutConstant to a value greater than zero and
+ less than MAXDWORD, one of the following occurs when the
+ ReadFile function is called:
+
+ If there are any bytes in the input buffer, ReadFile returns
+ immediately with the bytes in the buffer.
+
+ If there are no bytes in the input buffer, ReadFile waits
+ until a byte arrives and then returns immediately.
+
+ If no bytes arrive within the time specified by
+ ReadTotalTimeoutConstant, ReadFile times out.
+ */
+
+ r, _, err := syscall.Syscall(nSetCommTimeouts, 2, uintptr(h), uintptr(unsafe.Pointer(&timeouts)), 0)
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func setupComm(h syscall.Handle, in, out int) error {
+ r, _, err := syscall.Syscall(nSetupComm, 3, uintptr(h), uintptr(in), uintptr(out))
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func setCommMask(h syscall.Handle) error {
+ const EV_RXCHAR = 0x0001
+ r, _, err := syscall.Syscall(nSetCommMask, 2, uintptr(h), EV_RXCHAR, 0)
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func resetEvent(h syscall.Handle) error {
+ r, _, err := syscall.Syscall(nResetEvent, 1, uintptr(h), 0, 0)
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func purgeComm(h syscall.Handle) error {
+ const PURGE_TXABORT = 0x0001
+ const PURGE_RXABORT = 0x0002
+ const PURGE_TXCLEAR = 0x0004
+ const PURGE_RXCLEAR = 0x0008
+ r, _, err := syscall.Syscall(nPurgeComm, 2, uintptr(h),
+ PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR, 0)
+ if r == 0 {
+ return err
+ }
+ return nil
+}
+
+func newOverlapped() (*syscall.Overlapped, error) {
+ var overlapped syscall.Overlapped
+ r, _, err := syscall.Syscall6(nCreateEvent, 4, 0, 1, 0, 0, 0, 0)
+ if r == 0 {
+ return nil, err
+ }
+ overlapped.HEvent = syscall.Handle(r)
+ return &overlapped, nil
+}
+
+func getOverlappedResult(h syscall.Handle, overlapped *syscall.Overlapped) (int, error) {
+ var n int
+ r, _, err := syscall.Syscall6(nGetOverlappedResult, 4,
+ uintptr(h),
+ uintptr(unsafe.Pointer(overlapped)),
+ uintptr(unsafe.Pointer(&n)), 1, 0, 0)
+ if r == 0 {
+ return n, err
+ }
+
+ return n, nil
+}
+
+func (port *SerialPort) SetDTR(_ bool) error {
+ return nil
+}
diff --git a/vendor/github.com/facchinm/go-serial/syscall_darwin.go b/vendor/github.com/facchinm/go-serial/syscall_darwin.go
new file mode 100644
index 000000000..b071106de
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/syscall_darwin.go
@@ -0,0 +1,21 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+// This file is machine generated by the command:
+// mksyscall.pl serial_darwin.go
+// The generated stub is modified to make it compile under the "serial" package
+
+package serial
+
+import "syscall"
+
+func ioctl(fd int, req uint64, data uintptr) (err error) {
+ _, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
+ if e1 != 0 {
+ err = e1
+ }
+ return
+}
diff --git a/vendor/github.com/facchinm/go-serial/syscall_linux.go b/vendor/github.com/facchinm/go-serial/syscall_linux.go
new file mode 100644
index 000000000..1a925e47e
--- /dev/null
+++ b/vendor/github.com/facchinm/go-serial/syscall_linux.go
@@ -0,0 +1,21 @@
+//
+// Copyright 2014 Cristian Maglie. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+
+// This file is machine generated by the command:
+// mksyscall.pl serial_linux.go
+// The generated stub is modified to make it compile under the "serial" package
+
+package serial
+
+import "syscall"
+
+func ioctl(fd int, req uint64, data uintptr) (err error) {
+ _, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data))
+ if e1 != 0 {
+ err = e1
+ }
+ return
+}
diff --git a/vendor/github.com/facchinm/systray/LICENSE b/vendor/github.com/facchinm/systray/LICENSE
new file mode 100644
index 000000000..3ee01626e
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright 2014 Brave New Software Project, Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/facchinm/systray/README.md b/vendor/github.com/facchinm/systray/README.md
new file mode 100644
index 000000000..b4f2c1a45
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/README.md
@@ -0,0 +1,57 @@
+Package systray is a cross platfrom Go library to place an icon and menu in the notification area.
+Tested on Windows 8, Mac OSX, Ubuntu 14.10 and Debian 7.6.
+
+## Usage
+```go
+func main() {
+ // Should be called at the very beginning of main().
+ systray.Run(onReady)
+}
+
+func onReady() {
+ systray.SetIcon(icon.Data)
+ systray.SetTitle("Awesome App")
+ systray.SetTooltip("Pretty awesome超级棒")
+ mQuit := systray.AddMenuItem("Quit", "Quit the whole app")
+}
+```
+Menu item can be checked and / or disabled. Methods except `Run()` can be invoked from any goroutine. See demo code under `example` folder.
+
+## Platform specific concerns
+
+### Linux
+
+```sh
+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.
+Place tray icon under `icon`, and use `make_icon.bat` or `make_icon.sh`, whichever suit for your os, to convert the icon to byte array.
+Your icon should be .ico file under Windows, whereas .ico, .jpg and .png is supported on other platform.
+
+```sh
+go get
+go run main.go
+```
+
+## Credits
+
+- https://github.com/xilp/systray
+- https://github.com/cratonica/trayhost
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/example/icon/icon_hiber.ico b/vendor/github.com/facchinm/systray/example/icon/icon_hiber.ico
new file mode 100644
index 000000000..f8b1651d6
Binary files /dev/null and b/vendor/github.com/facchinm/systray/example/icon/icon_hiber.ico differ
diff --git a/vendor/github.com/facchinm/systray/example/icon/icon_hiber.png b/vendor/github.com/facchinm/systray/example/icon/icon_hiber.png
new file mode 100644
index 000000000..7722e05da
Binary files /dev/null and b/vendor/github.com/facchinm/systray/example/icon/icon_hiber.png differ
diff --git a/vendor/github.com/facchinm/systray/example/icon/icon_linux.png b/vendor/github.com/facchinm/systray/example/icon/icon_linux.png
new file mode 100644
index 000000000..e1025c057
Binary files /dev/null and b/vendor/github.com/facchinm/systray/example/icon/icon_linux.png differ
diff --git a/vendor/github.com/facchinm/systray/example/icon/icon_mac.png b/vendor/github.com/facchinm/systray/example/icon/icon_mac.png
new file mode 100644
index 000000000..9e2d02c61
Binary files /dev/null and b/vendor/github.com/facchinm/systray/example/icon/icon_mac.png differ
diff --git a/vendor/github.com/facchinm/systray/example/icon/icon_win.ico b/vendor/github.com/facchinm/systray/example/icon/icon_win.ico
new file mode 100644
index 000000000..a0893f67d
Binary files /dev/null and b/vendor/github.com/facchinm/systray/example/icon/icon_win.ico differ
diff --git a/vendor/github.com/facchinm/systray/example/icon/icondarwin.go b/vendor/github.com/facchinm/systray/example/icon/icondarwin.go
new file mode 100644
index 000000000..1051fe55b
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/example/icon/icondarwin.go
@@ -0,0 +1,390 @@
+//+build darwin
+
+// File generated by 2goarray v0.1.0 (http://github.com/cratonica/2goarray)
+
+package icon
+
+var Data []byte = []byte{
+ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+ 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x24,
+ 0x08, 0x06, 0x00, 0x00, 0x00, 0xe1, 0x00, 0x98, 0x98, 0x00, 0x00, 0x00,
+ 0x04, 0x67, 0x41, 0x4d, 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61,
+ 0x05, 0x00, 0x00, 0x0a, 0x31, 0x69, 0x43, 0x43, 0x50, 0x49, 0x43, 0x43,
+ 0x20, 0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x48, 0x89,
+ 0x9d, 0x96, 0x77, 0x54, 0x53, 0xd9, 0x16, 0x87, 0xcf, 0xbd, 0x37, 0xbd,
+ 0x50, 0x92, 0x10, 0x8a, 0x94, 0xd0, 0x6b, 0x68, 0x52, 0x02, 0x48, 0x0d,
+ 0xbd, 0x48, 0x91, 0x2e, 0x2a, 0x31, 0x09, 0x10, 0x4a, 0xc0, 0x90, 0x00,
+ 0x22, 0x36, 0x44, 0x54, 0x70, 0x44, 0x51, 0x91, 0xa6, 0x08, 0x32, 0x28,
+ 0xe0, 0x80, 0xa3, 0x43, 0x91, 0xb1, 0x22, 0x8a, 0x85, 0x01, 0x51, 0xb1,
+ 0xeb, 0x04, 0x19, 0x44, 0xd4, 0x71, 0x70, 0x14, 0x1b, 0x96, 0x49, 0x64,
+ 0xad, 0x19, 0xdf, 0xbc, 0x79, 0xef, 0xcd, 0x9b, 0xdf, 0x1f, 0xf7, 0x7e,
+ 0x6b, 0x9f, 0xbd, 0xcf, 0xdd, 0x67, 0xef, 0x7d, 0xd6, 0xba, 0x00, 0x90,
+ 0xfc, 0x83, 0x05, 0xc2, 0x4c, 0x58, 0x09, 0x80, 0x0c, 0xa1, 0x58, 0x14,
+ 0xe1, 0xe7, 0xc5, 0x88, 0x8d, 0x8b, 0x67, 0x60, 0x07, 0x01, 0x0c, 0xf0,
+ 0x00, 0x03, 0x6c, 0x00, 0xe0, 0x70, 0xb3, 0xb3, 0x42, 0x16, 0xf8, 0x46,
+ 0x02, 0x99, 0x02, 0x7c, 0xd8, 0x8c, 0x6c, 0x99, 0x13, 0xf8, 0x17, 0xbd,
+ 0xba, 0x0e, 0x20, 0xf9, 0xfb, 0x2a, 0xd3, 0x3f, 0x8c, 0xc1, 0x00, 0xff,
+ 0x9f, 0x94, 0xb9, 0x59, 0x22, 0x31, 0x00, 0x50, 0x98, 0x8c, 0xe7, 0xf2,
+ 0xf8, 0xd9, 0x5c, 0x19, 0x17, 0xc9, 0x38, 0x3d, 0x57, 0x9c, 0x25, 0xb7,
+ 0x4f, 0xc9, 0x98, 0xb6, 0x34, 0x4d, 0xce, 0x30, 0x4a, 0xce, 0x22, 0x59,
+ 0x82, 0x32, 0x56, 0x93, 0x73, 0xf2, 0x2c, 0x5b, 0x7c, 0xf6, 0x99, 0x65,
+ 0x0f, 0x39, 0xf3, 0x32, 0x84, 0x3c, 0x19, 0xcb, 0x73, 0xce, 0xe2, 0x65,
+ 0xf0, 0xe4, 0xdc, 0x27, 0xe3, 0x8d, 0x39, 0x12, 0xbe, 0x8c, 0x91, 0x60,
+ 0x19, 0x17, 0xe7, 0x08, 0xf8, 0xb9, 0x32, 0xbe, 0x26, 0x63, 0x83, 0x74,
+ 0x49, 0x86, 0x40, 0xc6, 0x6f, 0xe4, 0xb1, 0x19, 0x7c, 0x4e, 0x36, 0x00,
+ 0x28, 0x92, 0xdc, 0x2e, 0xe6, 0x73, 0x53, 0x64, 0x6c, 0x2d, 0x63, 0x92,
+ 0x28, 0x32, 0x82, 0x2d, 0xe3, 0x79, 0x00, 0xe0, 0x48, 0xc9, 0x5f, 0xf0,
+ 0xd2, 0x2f, 0x58, 0xcc, 0xcf, 0x13, 0xcb, 0x0f, 0xc5, 0xce, 0xcc, 0x5a,
+ 0x2e, 0x12, 0x24, 0xa7, 0x88, 0x19, 0x26, 0x5c, 0x53, 0x86, 0x8d, 0x93,
+ 0x13, 0x8b, 0xe1, 0xcf, 0xcf, 0x4d, 0xe7, 0x8b, 0xc5, 0xcc, 0x30, 0x0e,
+ 0x37, 0x8d, 0x23, 0xe2, 0x31, 0xd8, 0x99, 0x19, 0x59, 0x1c, 0xe1, 0x72,
+ 0x00, 0x66, 0xcf, 0xfc, 0x59, 0x14, 0x79, 0x6d, 0x19, 0xb2, 0x22, 0x3b,
+ 0xd8, 0x38, 0x39, 0x38, 0x30, 0x6d, 0x2d, 0x6d, 0xbe, 0x28, 0xd4, 0x7f,
+ 0x5d, 0xfc, 0x9b, 0x92, 0xf7, 0x76, 0x96, 0x5e, 0x84, 0x7f, 0xee, 0x19,
+ 0x44, 0x1f, 0xf8, 0xc3, 0xf6, 0x57, 0x7e, 0x99, 0x0d, 0x00, 0xb0, 0xa6,
+ 0x65, 0xb5, 0xd9, 0xfa, 0x87, 0x6d, 0x69, 0x15, 0x00, 0x5d, 0xeb, 0x01,
+ 0x50, 0xbb, 0xfd, 0x87, 0xcd, 0x60, 0x2f, 0x00, 0x8a, 0xb2, 0xbe, 0x75,
+ 0x0e, 0x7d, 0x71, 0x1e, 0xba, 0x7c, 0x5e, 0x52, 0xc4, 0xe2, 0x2c, 0x67,
+ 0x2b, 0xab, 0xdc, 0xdc, 0x5c, 0x4b, 0x01, 0x9f, 0x6b, 0x29, 0x2f, 0xe8,
+ 0xef, 0xfa, 0x9f, 0x0e, 0x7f, 0x43, 0x5f, 0x7c, 0xcf, 0x52, 0xbe, 0xdd,
+ 0xef, 0xe5, 0x61, 0x78, 0xf3, 0x93, 0x38, 0x92, 0x74, 0x31, 0x43, 0x5e,
+ 0x37, 0x6e, 0x66, 0x7a, 0xa6, 0x44, 0xc4, 0xc8, 0xce, 0xe2, 0x70, 0xf9,
+ 0x0c, 0xe6, 0x9f, 0x87, 0xf8, 0x1f, 0x07, 0xfe, 0x75, 0x1e, 0x16, 0x11,
+ 0xfc, 0x24, 0xbe, 0x88, 0x2f, 0x94, 0x45, 0x44, 0xcb, 0xa6, 0x4c, 0x20,
+ 0x4c, 0x96, 0xb5, 0x5b, 0xc8, 0x13, 0x88, 0x05, 0x99, 0x42, 0x86, 0x40,
+ 0xf8, 0x9f, 0x9a, 0xf8, 0x0f, 0xc3, 0xfe, 0xa4, 0xd9, 0xb9, 0x96, 0x89,
+ 0xda, 0xf8, 0x11, 0xd0, 0x96, 0x58, 0x02, 0xa5, 0x21, 0x1a, 0x40, 0x7e,
+ 0x1e, 0x00, 0x28, 0x2a, 0x11, 0x20, 0x09, 0x7b, 0x64, 0x2b, 0xd0, 0xef,
+ 0x7d, 0x0b, 0xc6, 0x47, 0x03, 0xf9, 0xcd, 0x8b, 0xd1, 0x99, 0x98, 0x9d,
+ 0xfb, 0xcf, 0x82, 0xfe, 0x7d, 0x57, 0xb8, 0x4c, 0xfe, 0xc8, 0x16, 0x24,
+ 0x7f, 0x8e, 0x63, 0x47, 0x44, 0x32, 0xb8, 0x12, 0x51, 0xce, 0xec, 0x9a,
+ 0xfc, 0x5a, 0x02, 0x34, 0x20, 0x00, 0x45, 0x40, 0x03, 0xea, 0x40, 0x1b,
+ 0xe8, 0x03, 0x13, 0xc0, 0x04, 0xb6, 0xc0, 0x11, 0xb8, 0x00, 0x0f, 0xe0,
+ 0x03, 0x02, 0x41, 0x28, 0x88, 0x04, 0x71, 0x60, 0x31, 0xe0, 0x82, 0x14,
+ 0x90, 0x01, 0x44, 0x20, 0x17, 0x14, 0x80, 0xb5, 0xa0, 0x18, 0x94, 0x82,
+ 0xad, 0x60, 0x27, 0xa8, 0x06, 0x75, 0xa0, 0x11, 0x34, 0x83, 0x36, 0x70,
+ 0x18, 0x74, 0x81, 0x63, 0xe0, 0x34, 0x38, 0x07, 0x2e, 0x81, 0xcb, 0x60,
+ 0x04, 0xdc, 0x01, 0x52, 0x30, 0x0e, 0x9e, 0x80, 0x29, 0xf0, 0x0a, 0xcc,
+ 0x40, 0x10, 0x84, 0x85, 0xc8, 0x10, 0x15, 0x52, 0x87, 0x74, 0x20, 0x43,
+ 0xc8, 0x1c, 0xb2, 0x85, 0x58, 0x90, 0x1b, 0xe4, 0x03, 0x05, 0x43, 0x11,
+ 0x50, 0x1c, 0x94, 0x08, 0x25, 0x43, 0x42, 0x48, 0x02, 0x15, 0x40, 0xeb,
+ 0xa0, 0x52, 0xa8, 0x1c, 0xaa, 0x86, 0xea, 0xa1, 0x66, 0xe8, 0x5b, 0xe8,
+ 0x28, 0x74, 0x1a, 0xba, 0x00, 0x0d, 0x43, 0xb7, 0xa0, 0x51, 0x68, 0x12,
+ 0xfa, 0x15, 0x7a, 0x07, 0x23, 0x30, 0x09, 0xa6, 0xc1, 0x5a, 0xb0, 0x11,
+ 0x6c, 0x05, 0xb3, 0x60, 0x4f, 0x38, 0x08, 0x8e, 0x84, 0x17, 0xc1, 0xc9,
+ 0xf0, 0x32, 0x38, 0x1f, 0x2e, 0x82, 0xb7, 0xc0, 0x95, 0x70, 0x03, 0x7c,
+ 0x10, 0xee, 0x84, 0x4f, 0xc3, 0x97, 0xe0, 0x11, 0x58, 0x0a, 0x3f, 0x81,
+ 0xa7, 0x11, 0x80, 0x10, 0x11, 0x3a, 0xa2, 0x8b, 0x30, 0x11, 0x16, 0xc2,
+ 0x46, 0x42, 0x91, 0x78, 0x24, 0x09, 0x11, 0x21, 0xab, 0x90, 0x12, 0xa4,
+ 0x02, 0x69, 0x40, 0xda, 0x90, 0x1e, 0xa4, 0x1f, 0xb9, 0x8a, 0x48, 0x91,
+ 0xa7, 0xc8, 0x5b, 0x14, 0x06, 0x45, 0x45, 0x31, 0x50, 0x4c, 0x94, 0x0b,
+ 0xca, 0x1f, 0x15, 0x85, 0xe2, 0xa2, 0x96, 0xa1, 0x56, 0xa1, 0x36, 0xa3,
+ 0xaa, 0x51, 0x07, 0x50, 0x9d, 0xa8, 0x3e, 0xd4, 0x55, 0xd4, 0x28, 0x6a,
+ 0x0a, 0xf5, 0x11, 0x4d, 0x46, 0x6b, 0xa2, 0xcd, 0xd1, 0xce, 0xe8, 0x00,
+ 0x74, 0x2c, 0x3a, 0x19, 0x9d, 0x8b, 0x2e, 0x46, 0x57, 0xa0, 0x9b, 0xd0,
+ 0x1d, 0xe8, 0xb3, 0xe8, 0x11, 0xf4, 0x38, 0xfa, 0x15, 0x06, 0x83, 0xa1,
+ 0x63, 0x8c, 0x31, 0x8e, 0x18, 0x7f, 0x4c, 0x1c, 0x26, 0x15, 0xb3, 0x02,
+ 0xb3, 0x19, 0xb3, 0x1b, 0xd3, 0x8e, 0x39, 0x85, 0x19, 0xc6, 0x8c, 0x61,
+ 0xa6, 0xb1, 0x58, 0xac, 0x3a, 0xd6, 0x1c, 0xeb, 0x8a, 0x0d, 0xc5, 0x72,
+ 0xb0, 0x62, 0x6c, 0x31, 0xb6, 0x0a, 0x7b, 0x10, 0x7b, 0x12, 0x7b, 0x05,
+ 0x3b, 0x8e, 0x7d, 0x83, 0x23, 0xe2, 0x74, 0x70, 0xb6, 0x38, 0x5f, 0x5c,
+ 0x3c, 0x4e, 0x88, 0x2b, 0xc4, 0x55, 0xe0, 0x5a, 0x70, 0x27, 0x70, 0x57,
+ 0x70, 0x13, 0xb8, 0x19, 0xbc, 0x12, 0xde, 0x10, 0xef, 0x8c, 0x0f, 0xc5,
+ 0xf3, 0xf0, 0xcb, 0xf1, 0x65, 0xf8, 0x46, 0x7c, 0x0f, 0x7e, 0x08, 0x3f,
+ 0x8e, 0x9f, 0x21, 0x28, 0x13, 0x8c, 0x09, 0xae, 0x84, 0x48, 0x42, 0x2a,
+ 0x61, 0x2d, 0xa1, 0x92, 0xd0, 0x46, 0x38, 0x4b, 0xb8, 0x4b, 0x78, 0x41,
+ 0x24, 0x12, 0xf5, 0x88, 0x4e, 0xc4, 0x70, 0xa2, 0x80, 0xb8, 0x86, 0x58,
+ 0x49, 0x3c, 0x44, 0x3c, 0x4f, 0x1c, 0x25, 0xbe, 0x25, 0x51, 0x48, 0x66,
+ 0x24, 0x36, 0x29, 0x81, 0x24, 0x21, 0x6d, 0x21, 0xed, 0x27, 0x9d, 0x22,
+ 0xdd, 0x22, 0xbd, 0x20, 0x93, 0xc9, 0x46, 0x64, 0x0f, 0x72, 0x3c, 0x59,
+ 0x4c, 0xde, 0x42, 0x6e, 0x26, 0x9f, 0x21, 0xdf, 0x27, 0xbf, 0x51, 0xa0,
+ 0x2a, 0x58, 0x2a, 0x04, 0x28, 0xf0, 0x14, 0x56, 0x2b, 0xd4, 0x28, 0x74,
+ 0x2a, 0x5c, 0x51, 0x78, 0xa6, 0x88, 0x57, 0x34, 0x54, 0xf4, 0x54, 0x5c,
+ 0xac, 0x98, 0xaf, 0x58, 0xa1, 0x78, 0x44, 0x71, 0x48, 0xf1, 0xa9, 0x12,
+ 0x5e, 0xc9, 0x48, 0x89, 0xad, 0xc4, 0x51, 0x5a, 0xa5, 0x54, 0xa3, 0x74,
+ 0x54, 0xe9, 0x86, 0xd2, 0xb4, 0x32, 0x55, 0xd9, 0x46, 0x39, 0x54, 0x39,
+ 0x43, 0x79, 0xb3, 0x72, 0x8b, 0xf2, 0x05, 0xe5, 0x47, 0x14, 0x2c, 0xc5,
+ 0x88, 0xe2, 0x43, 0xe1, 0x51, 0x8a, 0x28, 0xfb, 0x28, 0x67, 0x28, 0x63,
+ 0x54, 0x84, 0xaa, 0x4f, 0x65, 0x53, 0xb9, 0xd4, 0x75, 0xd4, 0x46, 0xea,
+ 0x59, 0xea, 0x38, 0x0d, 0x43, 0x33, 0xa6, 0x05, 0xd0, 0x52, 0x69, 0xa5,
+ 0xb4, 0x6f, 0x68, 0x83, 0xb4, 0x29, 0x15, 0x8a, 0x8a, 0x9d, 0x4a, 0xb4,
+ 0x4a, 0x9e, 0x4a, 0x8d, 0xca, 0x71, 0x15, 0x29, 0x1d, 0xa1, 0x1b, 0xd1,
+ 0x03, 0xe8, 0xe9, 0xf4, 0x32, 0xfa, 0x61, 0xfa, 0x75, 0xfa, 0x3b, 0x55,
+ 0x2d, 0x55, 0x4f, 0x55, 0xbe, 0xea, 0x26, 0xd5, 0x36, 0xd5, 0x2b, 0xaa,
+ 0xaf, 0xd5, 0xe6, 0xa8, 0x79, 0xa8, 0xf1, 0xd5, 0x4a, 0xd4, 0xda, 0xd5,
+ 0x46, 0xd4, 0xde, 0xa9, 0x33, 0xd4, 0x7d, 0xd4, 0xd3, 0xd4, 0xb7, 0xa9,
+ 0x77, 0xa9, 0xdf, 0xd3, 0x40, 0x69, 0x98, 0x69, 0x84, 0x6b, 0xe4, 0x6a,
+ 0xec, 0xd1, 0x38, 0xab, 0xf1, 0x74, 0x0e, 0x6d, 0x8e, 0xcb, 0x1c, 0xee,
+ 0x9c, 0x92, 0x39, 0x87, 0xe7, 0xdc, 0xd6, 0x84, 0x35, 0xcd, 0x34, 0x23,
+ 0x34, 0x57, 0x68, 0xee, 0xd3, 0x1c, 0xd0, 0x9c, 0xd6, 0xd2, 0xd6, 0xf2,
+ 0xd3, 0xca, 0xd2, 0xaa, 0xd2, 0x3a, 0xa3, 0xf5, 0x54, 0x9b, 0xae, 0xed,
+ 0xa1, 0x9d, 0xaa, 0xbd, 0x43, 0xfb, 0x84, 0xf6, 0xa4, 0x0e, 0x55, 0xc7,
+ 0x4d, 0x47, 0xa0, 0xb3, 0x43, 0xe7, 0xa4, 0xce, 0x63, 0x86, 0x0a, 0xc3,
+ 0x93, 0x91, 0xce, 0xa8, 0x64, 0xf4, 0x31, 0xa6, 0x74, 0x35, 0x75, 0xfd,
+ 0x75, 0x25, 0xba, 0xf5, 0xba, 0x83, 0xba, 0x33, 0x7a, 0xc6, 0x7a, 0x51,
+ 0x7a, 0x85, 0x7a, 0xed, 0x7a, 0xf7, 0xf4, 0x09, 0xfa, 0x2c, 0xfd, 0x24,
+ 0xfd, 0x1d, 0xfa, 0xbd, 0xfa, 0x53, 0x06, 0x3a, 0x06, 0x21, 0x06, 0x05,
+ 0x06, 0xad, 0x06, 0xb7, 0x0d, 0xf1, 0x86, 0x2c, 0xc3, 0x14, 0xc3, 0x5d,
+ 0x86, 0xfd, 0x86, 0xaf, 0x8d, 0x8c, 0x8d, 0x62, 0x8c, 0x36, 0x18, 0x75,
+ 0x19, 0x3d, 0x32, 0x56, 0x33, 0x0e, 0x30, 0xce, 0x37, 0x6e, 0x35, 0xbe,
+ 0x6b, 0x42, 0x36, 0x71, 0x37, 0x59, 0x66, 0xd2, 0x60, 0x72, 0xcd, 0x14,
+ 0x63, 0xca, 0x32, 0x4d, 0x33, 0xdd, 0x6d, 0x7a, 0xd9, 0x0c, 0x36, 0xb3,
+ 0x37, 0x4b, 0x31, 0xab, 0x31, 0x1b, 0x32, 0x87, 0xcd, 0x1d, 0xcc, 0x05,
+ 0xe6, 0xbb, 0xcd, 0x87, 0x2d, 0xd0, 0x16, 0x4e, 0x16, 0x42, 0x8b, 0x06,
+ 0x8b, 0x1b, 0x4c, 0x12, 0xd3, 0x93, 0x99, 0xc3, 0x6c, 0x65, 0x8e, 0x5a,
+ 0xd2, 0x2d, 0x83, 0x2d, 0x0b, 0x2d, 0xbb, 0x2c, 0x9f, 0x59, 0x19, 0x58,
+ 0xc5, 0x5b, 0x6d, 0xb3, 0xea, 0xb7, 0xfa, 0x68, 0x6d, 0x6f, 0x9d, 0x6e,
+ 0xdd, 0x68, 0x7d, 0xc7, 0x86, 0x62, 0x13, 0x68, 0x53, 0x68, 0xd3, 0x63,
+ 0xf3, 0xab, 0xad, 0x99, 0x2d, 0xd7, 0xb6, 0xc6, 0xf6, 0xda, 0x5c, 0xf2,
+ 0x5c, 0xdf, 0xb9, 0xab, 0xe7, 0x76, 0xcf, 0x7d, 0x6e, 0x67, 0x6e, 0xc7,
+ 0xb7, 0xdb, 0x63, 0x77, 0xd3, 0x9e, 0x6a, 0x1f, 0x62, 0xbf, 0xc1, 0xbe,
+ 0xd7, 0xfe, 0x83, 0x83, 0xa3, 0x83, 0xc8, 0xa1, 0xcd, 0x61, 0xd2, 0xd1,
+ 0xc0, 0x31, 0xd1, 0xb1, 0xd6, 0xf1, 0x06, 0x8b, 0xc6, 0x0a, 0x63, 0x6d,
+ 0x66, 0x9d, 0x77, 0x42, 0x3b, 0x79, 0x39, 0xad, 0x76, 0x3a, 0xe6, 0xf4,
+ 0xd6, 0xd9, 0xc1, 0x59, 0xec, 0x7c, 0xd8, 0xf9, 0x17, 0x17, 0xa6, 0x4b,
+ 0x9a, 0x4b, 0x8b, 0xcb, 0xa3, 0x79, 0xc6, 0xf3, 0xf8, 0xf3, 0x1a, 0xe7,
+ 0x8d, 0xb9, 0xea, 0xb9, 0x72, 0x5c, 0xeb, 0x5d, 0xa5, 0x6e, 0x0c, 0xb7,
+ 0x44, 0xb7, 0xbd, 0x6e, 0x52, 0x77, 0x5d, 0x77, 0x8e, 0x7b, 0x83, 0xfb,
+ 0x03, 0x0f, 0x7d, 0x0f, 0x9e, 0x47, 0x93, 0xc7, 0x84, 0xa7, 0xa9, 0x67,
+ 0xaa, 0xe7, 0x41, 0xcf, 0x67, 0x5e, 0xd6, 0x5e, 0x22, 0xaf, 0x0e, 0xaf,
+ 0xd7, 0x6c, 0x67, 0xf6, 0x4a, 0xf6, 0x29, 0x6f, 0xc4, 0xdb, 0xcf, 0xbb,
+ 0xc4, 0x7b, 0xd0, 0x87, 0xe2, 0x13, 0xe5, 0x53, 0xed, 0x73, 0xdf, 0x57,
+ 0xcf, 0x37, 0xd9, 0xb7, 0xd5, 0x77, 0xca, 0xcf, 0xde, 0x6f, 0x85, 0xdf,
+ 0x29, 0x7f, 0xb4, 0x7f, 0x90, 0xff, 0x36, 0xff, 0x1b, 0x01, 0x5a, 0x01,
+ 0xdc, 0x80, 0xe6, 0x80, 0xa9, 0x40, 0xc7, 0xc0, 0x95, 0x81, 0x7d, 0x41,
+ 0xa4, 0xa0, 0x05, 0x41, 0xd5, 0x41, 0x0f, 0x82, 0xcd, 0x82, 0x45, 0xc1,
+ 0x3d, 0x21, 0x70, 0x48, 0x60, 0xc8, 0xf6, 0x90, 0xbb, 0xf3, 0x0d, 0xe7,
+ 0x0b, 0xe7, 0x77, 0x85, 0x82, 0xd0, 0x80, 0xd0, 0xed, 0xa1, 0xf7, 0xc2,
+ 0x8c, 0xc3, 0x96, 0x85, 0x7d, 0x1f, 0x8e, 0x09, 0x0f, 0x0b, 0xaf, 0x09,
+ 0x7f, 0x18, 0x61, 0x13, 0x51, 0x10, 0xd1, 0xbf, 0x80, 0xba, 0x60, 0xc9,
+ 0x82, 0x96, 0x05, 0xaf, 0x22, 0xbd, 0x22, 0xcb, 0x22, 0xef, 0x44, 0x99,
+ 0x44, 0x49, 0xa2, 0x7a, 0xa3, 0x15, 0xa3, 0x13, 0xa2, 0x9b, 0xa3, 0x5f,
+ 0xc7, 0x78, 0xc7, 0x94, 0xc7, 0x48, 0x63, 0xad, 0x62, 0x57, 0xc6, 0x5e,
+ 0x8a, 0xd3, 0x88, 0x13, 0xc4, 0x75, 0xc7, 0x63, 0xe3, 0xa3, 0xe3, 0x9b,
+ 0xe2, 0xa7, 0x17, 0xfa, 0x2c, 0xdc, 0xb9, 0x70, 0x3c, 0xc1, 0x3e, 0xa1,
+ 0x38, 0xe1, 0xfa, 0x22, 0xe3, 0x45, 0x79, 0x8b, 0x2e, 0x2c, 0xd6, 0x58,
+ 0x9c, 0xbe, 0xf8, 0xf8, 0x12, 0xc5, 0x25, 0x9c, 0x25, 0x47, 0x12, 0xd1,
+ 0x89, 0x31, 0x89, 0x2d, 0x89, 0xef, 0x39, 0xa1, 0x9c, 0x06, 0xce, 0xf4,
+ 0xd2, 0x80, 0xa5, 0xb5, 0x4b, 0xa7, 0xb8, 0x6c, 0xee, 0x2e, 0xee, 0x13,
+ 0x9e, 0x07, 0x6f, 0x07, 0x6f, 0x92, 0xef, 0xca, 0x2f, 0xe7, 0x4f, 0x24,
+ 0xb9, 0x26, 0x95, 0x27, 0x3d, 0x4a, 0x76, 0x4d, 0xde, 0x9e, 0x3c, 0x99,
+ 0xe2, 0x9e, 0x52, 0x91, 0xf2, 0x54, 0xc0, 0x16, 0x54, 0x0b, 0x9e, 0xa7,
+ 0xfa, 0xa7, 0xd6, 0xa5, 0xbe, 0x4e, 0x0b, 0x4d, 0xdb, 0x9f, 0xf6, 0x29,
+ 0x3d, 0x26, 0xbd, 0x3d, 0x03, 0x97, 0x91, 0x98, 0x71, 0x54, 0x48, 0x11,
+ 0xa6, 0x09, 0xfb, 0x32, 0xb5, 0x33, 0xf3, 0x32, 0x87, 0xb3, 0xcc, 0xb3,
+ 0x8a, 0xb3, 0xa4, 0xcb, 0x9c, 0x97, 0xed, 0x5c, 0x36, 0x25, 0x0a, 0x12,
+ 0x35, 0x65, 0x43, 0xd9, 0x8b, 0xb2, 0xbb, 0xc5, 0x34, 0xd9, 0xcf, 0xd4,
+ 0x80, 0xc4, 0x44, 0xb2, 0x5e, 0x32, 0x9a, 0xe3, 0x96, 0x53, 0x93, 0xf3,
+ 0x26, 0x37, 0x3a, 0xf7, 0x48, 0x9e, 0x72, 0x9e, 0x30, 0x6f, 0x60, 0xb9,
+ 0xd9, 0xf2, 0x4d, 0xcb, 0x27, 0xf2, 0x7d, 0xf3, 0xbf, 0x5e, 0x81, 0x5a,
+ 0xc1, 0x5d, 0xd1, 0x5b, 0xa0, 0x5b, 0xb0, 0xb6, 0x60, 0x74, 0xa5, 0xe7,
+ 0xca, 0xfa, 0x55, 0xd0, 0xaa, 0xa5, 0xab, 0x7a, 0x57, 0xeb, 0xaf, 0x2e,
+ 0x5a, 0x3d, 0xbe, 0xc6, 0x6f, 0xcd, 0x81, 0xb5, 0x84, 0xb5, 0x69, 0x6b,
+ 0x7f, 0x28, 0xb4, 0x2e, 0x2c, 0x2f, 0x7c, 0xb9, 0x2e, 0x66, 0x5d, 0x4f,
+ 0x91, 0x56, 0xd1, 0x9a, 0xa2, 0xb1, 0xf5, 0x7e, 0xeb, 0x5b, 0x8b, 0x15,
+ 0x8a, 0x45, 0xc5, 0x37, 0x36, 0xb8, 0x6c, 0xa8, 0xdb, 0x88, 0xda, 0x28,
+ 0xd8, 0x38, 0xb8, 0x69, 0xee, 0xa6, 0xaa, 0x4d, 0x1f, 0x4b, 0x78, 0x25,
+ 0x17, 0x4b, 0xad, 0x4b, 0x2b, 0x4a, 0xdf, 0x6f, 0xe6, 0x6e, 0xbe, 0xf8,
+ 0x95, 0xcd, 0x57, 0x95, 0x5f, 0x7d, 0xda, 0x92, 0xb4, 0x65, 0xb0, 0xcc,
+ 0xa1, 0x6c, 0xcf, 0x56, 0xcc, 0x56, 0xe1, 0xd6, 0xeb, 0xdb, 0xdc, 0xb7,
+ 0x1d, 0x28, 0x57, 0x2e, 0xcf, 0x2f, 0x1f, 0xdb, 0x1e, 0xb2, 0xbd, 0x73,
+ 0x07, 0x63, 0x47, 0xc9, 0x8e, 0x97, 0x3b, 0x97, 0xec, 0xbc, 0x50, 0x61,
+ 0x57, 0x51, 0xb7, 0x8b, 0xb0, 0x4b, 0xb2, 0x4b, 0x5a, 0x19, 0x5c, 0xd9,
+ 0x5d, 0x65, 0x50, 0xb5, 0xb5, 0xea, 0x7d, 0x75, 0x4a, 0xf5, 0x48, 0x8d,
+ 0x57, 0x4d, 0x7b, 0xad, 0x66, 0xed, 0xa6, 0xda, 0xd7, 0xbb, 0x79, 0xbb,
+ 0xaf, 0xec, 0xf1, 0xd8, 0xd3, 0x56, 0xa7, 0x55, 0x57, 0x5a, 0xf7, 0x6e,
+ 0xaf, 0x60, 0xef, 0xcd, 0x7a, 0xbf, 0xfa, 0xce, 0x06, 0xa3, 0x86, 0x8a,
+ 0x7d, 0x98, 0x7d, 0x39, 0xfb, 0x1e, 0x36, 0x46, 0x37, 0xf6, 0x7f, 0xcd,
+ 0xfa, 0xba, 0xb9, 0x49, 0xa3, 0xa9, 0xb4, 0xe9, 0xc3, 0x7e, 0xe1, 0x7e,
+ 0xe9, 0x81, 0x88, 0x03, 0x7d, 0xcd, 0x8e, 0xcd, 0xcd, 0x2d, 0x9a, 0x2d,
+ 0x65, 0xad, 0x70, 0xab, 0xa4, 0x75, 0xf2, 0x60, 0xc2, 0xc1, 0xcb, 0xdf,
+ 0x78, 0x7f, 0xd3, 0xdd, 0xc6, 0x6c, 0xab, 0x6f, 0xa7, 0xb7, 0x97, 0x1e,
+ 0x02, 0x87, 0x24, 0x87, 0x1e, 0x7f, 0x9b, 0xf8, 0xed, 0xf5, 0xc3, 0x41,
+ 0x87, 0x7b, 0x8f, 0xb0, 0x8e, 0xb4, 0x7d, 0x67, 0xf8, 0x5d, 0x6d, 0x07,
+ 0xb5, 0xa3, 0xa4, 0x13, 0xea, 0x5c, 0xde, 0x39, 0xd5, 0x95, 0xd2, 0x25,
+ 0xed, 0x8e, 0xeb, 0x1e, 0x3e, 0x1a, 0x78, 0xb4, 0xb7, 0xc7, 0xa5, 0xa7,
+ 0xe3, 0x7b, 0xcb, 0xef, 0xf7, 0x1f, 0xd3, 0x3d, 0x56, 0x73, 0x5c, 0xe5,
+ 0x78, 0xd9, 0x09, 0xc2, 0x89, 0xa2, 0x13, 0x9f, 0x4e, 0xe6, 0x9f, 0x9c,
+ 0x3e, 0x95, 0x75, 0xea, 0xe9, 0xe9, 0xe4, 0xd3, 0x63, 0xbd, 0x4b, 0x7a,
+ 0xef, 0x9c, 0x89, 0x3d, 0x73, 0xad, 0x2f, 0xbc, 0x6f, 0xf0, 0x6c, 0xd0,
+ 0xd9, 0xf3, 0xe7, 0x7c, 0xcf, 0x9d, 0xe9, 0xf7, 0xec, 0x3f, 0x79, 0xde,
+ 0xf5, 0xfc, 0xb1, 0x0b, 0xce, 0x17, 0x8e, 0x5e, 0x64, 0x5d, 0xec, 0xba,
+ 0xe4, 0x70, 0xa9, 0x73, 0xc0, 0x7e, 0xa0, 0xe3, 0x07, 0xfb, 0x1f, 0x3a,
+ 0x06, 0x1d, 0x06, 0x3b, 0x87, 0x1c, 0x87, 0xba, 0x2f, 0x3b, 0x5d, 0xee,
+ 0x19, 0x9e, 0x37, 0x7c, 0xe2, 0x8a, 0xfb, 0x95, 0xd3, 0x57, 0xbd, 0xaf,
+ 0x9e, 0xbb, 0x16, 0x70, 0xed, 0xd2, 0xc8, 0xfc, 0x91, 0xe1, 0xeb, 0x51,
+ 0xd7, 0x6f, 0xde, 0x48, 0xb8, 0x21, 0xbd, 0xc9, 0xbb, 0xf9, 0xe8, 0x56,
+ 0xfa, 0xad, 0xe7, 0xb7, 0x73, 0x6e, 0xcf, 0xdc, 0x59, 0x73, 0x17, 0x7d,
+ 0xb7, 0xe4, 0x9e, 0xd2, 0xbd, 0x8a, 0xfb, 0x9a, 0xf7, 0x1b, 0x7e, 0x34,
+ 0xfd, 0xb1, 0x5d, 0xea, 0x20, 0x3d, 0x3e, 0xea, 0x3d, 0x3a, 0xf0, 0x60,
+ 0xc1, 0x83, 0x3b, 0x63, 0xdc, 0xb1, 0x27, 0x3f, 0x65, 0xff, 0xf4, 0x7e,
+ 0xbc, 0xe8, 0x21, 0xf9, 0x61, 0xc5, 0x84, 0xce, 0x44, 0xf3, 0x23, 0xdb,
+ 0x47, 0xc7, 0x26, 0x7d, 0x27, 0x2f, 0x3f, 0x5e, 0xf8, 0x78, 0xfc, 0x49,
+ 0xd6, 0x93, 0x99, 0xa7, 0xc5, 0x3f, 0x2b, 0xff, 0x5c, 0xfb, 0xcc, 0xe4,
+ 0xd9, 0x77, 0xbf, 0x78, 0xfc, 0x32, 0x30, 0x15, 0x3b, 0x35, 0xfe, 0x5c,
+ 0xf4, 0xfc, 0xd3, 0xaf, 0x9b, 0x5f, 0xa8, 0xbf, 0xd8, 0xff, 0xd2, 0xee,
+ 0x65, 0xef, 0x74, 0xd8, 0xf4, 0xfd, 0x57, 0x19, 0xaf, 0x66, 0x5e, 0x97,
+ 0xbc, 0x51, 0x7f, 0x73, 0xe0, 0x2d, 0xeb, 0x6d, 0xff, 0xbb, 0x98, 0x77,
+ 0x13, 0x33, 0xb9, 0xef, 0xb1, 0xef, 0x2b, 0x3f, 0x98, 0x7e, 0xe8, 0xf9,
+ 0x18, 0xf4, 0xf1, 0xee, 0xa7, 0x8c, 0x4f, 0x9f, 0x7e, 0x03, 0xf7, 0x84,
+ 0xf3, 0xfb, 0x71, 0x01, 0x86, 0xeb, 0x00, 0x00, 0x00, 0x20, 0x63, 0x48,
+ 0x52, 0x4d, 0x00, 0x00, 0x7a, 0x26, 0x00, 0x00, 0x80, 0x84, 0x00, 0x00,
+ 0xfa, 0x00, 0x00, 0x00, 0x80, 0xe8, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00,
+ 0xea, 0x60, 0x00, 0x00, 0x3a, 0x98, 0x00, 0x00, 0x17, 0x70, 0x9c, 0xba,
+ 0x51, 0x3c, 0x00, 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff,
+ 0x00, 0xff, 0x00, 0xff, 0xa0, 0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09,
+ 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x16, 0x25, 0x00, 0x00, 0x16, 0x25,
+ 0x01, 0x49, 0x52, 0x24, 0xf0, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d,
+ 0x45, 0x07, 0xdf, 0x04, 0x1e, 0x0f, 0x1c, 0x0c, 0x8e, 0x67, 0xd4, 0x7d,
+ 0x00, 0x00, 0x00, 0x1d, 0x69, 0x54, 0x58, 0x74, 0x43, 0x6f, 0x6d, 0x6d,
+ 0x65, 0x6e, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x73, 0x74, 0x61, 0x74,
+ 0x75, 0x73, 0x69, 0x63, 0x6f, 0x6e, 0x40, 0x32, 0x78, 0x2e, 0x70, 0x6e,
+ 0x67, 0x69, 0x8d, 0x83, 0x69, 0x00, 0x00, 0x03, 0xc6, 0x49, 0x44, 0x41,
+ 0x54, 0x58, 0xc3, 0xd5, 0x98, 0x69, 0x88, 0x8d, 0x61, 0x14, 0xc7, 0x7f,
+ 0x63, 0xe6, 0x5a, 0xc6, 0xcc, 0xd8, 0x0a, 0xa3, 0x59, 0x2c, 0x21, 0x3b,
+ 0x89, 0x6c, 0x4d, 0x83, 0x84, 0x0f, 0xa3, 0x18, 0x4b, 0x3e, 0xa9, 0xc9,
+ 0x92, 0x88, 0x2c, 0x59, 0x8b, 0x99, 0x29, 0x5f, 0x7d, 0x41, 0x4a, 0x51,
+ 0xa2, 0x34, 0x13, 0x35, 0x64, 0x8f, 0x51, 0x98, 0x89, 0x88, 0xec, 0x0c,
+ 0x19, 0xc3, 0x35, 0x76, 0x63, 0xec, 0xcc, 0xf2, 0xfa, 0xf2, 0x7f, 0x75,
+ 0x7a, 0xbb, 0xf7, 0xce, 0xbd, 0xe6, 0xce, 0xe0, 0xd4, 0xd3, 0x7d, 0x97,
+ 0x73, 0x9e, 0xf7, 0xff, 0x3c, 0xe7, 0x9c, 0xff, 0x39, 0xcf, 0x85, 0x7f,
+ 0x4c, 0x62, 0x22, 0xd4, 0xf5, 0x01, 0xa9, 0x40, 0x26, 0x30, 0x16, 0xe8,
+ 0x0d, 0x74, 0x06, 0xda, 0x4b, 0xe7, 0x03, 0xf0, 0x1a, 0x78, 0x00, 0x5c,
+ 0x00, 0xce, 0x01, 0x2f, 0x80, 0x5a, 0xc0, 0x89, 0x26, 0xf0, 0x04, 0x60,
+ 0x0a, 0x70, 0x18, 0xf8, 0xa2, 0xc9, 0xc3, 0x19, 0x1f, 0x81, 0x42, 0x2d,
+ 0x20, 0x3e, 0x1a, 0x40, 0xe2, 0x80, 0x21, 0x02, 0xe2, 0x34, 0x72, 0x1c,
+ 0x00, 0xfa, 0x01, 0xb1, 0x8d, 0xd9, 0x95, 0xf9, 0xc0, 0xbb, 0x28, 0x80,
+ 0x71, 0xc7, 0x2b, 0x60, 0x2e, 0xd0, 0x26, 0x52, 0x30, 0xed, 0x80, 0xbc,
+ 0x28, 0x02, 0xf1, 0x8e, 0xf5, 0x40, 0x62, 0xb8, 0x60, 0xda, 0x02, 0xf9,
+ 0x4d, 0x08, 0xc6, 0x82, 0x6a, 0xdd, 0x10, 0x98, 0x58, 0x60, 0x41, 0x33,
+ 0x80, 0x71, 0xc7, 0x9c, 0x86, 0x32, 0x7d, 0x78, 0x84, 0x59, 0xd4, 0xd8,
+ 0xf1, 0x16, 0xe8, 0x1f, 0xca, 0x55, 0x27, 0x9a, 0x11, 0x8c, 0x3b, 0x0a,
+ 0x82, 0x51, 0xc2, 0x94, 0x20, 0x06, 0x5f, 0x01, 0x3f, 0xf0, 0x10, 0x78,
+ 0x0a, 0x7c, 0x8a, 0x90, 0x87, 0x2a, 0x64, 0xfb, 0x1c, 0xf8, 0x16, 0x44,
+ 0x2f, 0xd3, 0xf2, 0x0c, 0x40, 0x4b, 0x60, 0x95, 0x07, 0x60, 0x35, 0x70,
+ 0x05, 0x28, 0x06, 0x6e, 0x88, 0x81, 0x3b, 0x00, 0x83, 0xc5, 0xd2, 0x63,
+ 0x80, 0x2e, 0x41, 0x76, 0xfb, 0x39, 0x50, 0xaa, 0x71, 0x5b, 0x0c, 0x9e,
+ 0x2c, 0xdb, 0x89, 0xc0, 0x08, 0xd1, 0x8a, 0x2b, 0x4b, 0x80, 0x8b, 0x62,
+ 0x74, 0x00, 0xfa, 0x02, 0x35, 0x06, 0x71, 0xb9, 0x94, 0xe2, 0x42, 0xc4,
+ 0xdb, 0x5c, 0xe0, 0x52, 0x80, 0xd5, 0x9e, 0x07, 0xa6, 0x87, 0xb0, 0x6b,
+ 0x03, 0xac, 0xd0, 0x6e, 0xbb, 0x36, 0x9f, 0x80, 0x34, 0xab, 0xb4, 0xd4,
+ 0xbc, 0xac, 0x04, 0xb2, 0xcc, 0xbb, 0x71, 0xc0, 0x22, 0x60, 0x2d, 0xb0,
+ 0x18, 0xc8, 0x30, 0xe9, 0xda, 0x17, 0x38, 0x6e, 0x6c, 0x0f, 0x02, 0xe9,
+ 0x26, 0x26, 0x27, 0x68, 0xee, 0xb5, 0xca, 0xde, 0x51, 0x66, 0xde, 0x19,
+ 0xc0, 0x1b, 0x63, 0x3b, 0xcf, 0x02, 0x2a, 0xd0, 0xc3, 0x9f, 0xc6, 0x75,
+ 0xf1, 0xc0, 0x6a, 0xcf, 0x4a, 0x1c, 0xe0, 0x25, 0xb0, 0x15, 0xe8, 0x25,
+ 0xbd, 0x1e, 0x72, 0xcd, 0x19, 0x20, 0xc5, 0x00, 0xdd, 0xe1, 0xf9, 0xa0,
+ 0x03, 0x3c, 0x02, 0x96, 0x9b, 0x05, 0xe5, 0x9b, 0xc2, 0xbb, 0xcb, 0x02,
+ 0xba, 0x06, 0xd4, 0x03, 0x77, 0xa4, 0xec, 0x93, 0xcb, 0x42, 0x05, 0xec,
+ 0x51, 0x03, 0x6a, 0x08, 0x30, 0xc0, 0x80, 0x29, 0x36, 0x7a, 0x15, 0x40,
+ 0x99, 0xe6, 0xb7, 0xbb, 0x11, 0xa7, 0x8a, 0xf0, 0xd8, 0xb8, 0xfa, 0xb7,
+ 0x54, 0x0a, 0xe9, 0x76, 0xdd, 0xa7, 0x01, 0xcf, 0xa4, 0x58, 0xaf, 0xf8,
+ 0xaa, 0x33, 0xbf, 0xee, 0xc4, 0xfb, 0xd4, 0x7e, 0xb8, 0x92, 0x0c, 0x1c,
+ 0xf2, 0x00, 0x5f, 0x27, 0x00, 0x7e, 0xf3, 0xec, 0xae, 0x74, 0x01, 0xf6,
+ 0x6b, 0xce, 0x7b, 0x16, 0x50, 0x15, 0xf0, 0x03, 0x58, 0xa6, 0xfb, 0x0c,
+ 0x03, 0xa6, 0x18, 0xc8, 0x06, 0x66, 0xe9, 0x37, 0xd7, 0x24, 0xc0, 0x4f,
+ 0x4f, 0x76, 0x6e, 0x32, 0x2e, 0xf0, 0x03, 0x9b, 0x05, 0x38, 0x1e, 0x98,
+ 0x0a, 0x5c, 0x35, 0xa0, 0x86, 0xcb, 0x66, 0xa3, 0xe6, 0xf1, 0x13, 0x20,
+ 0x8b, 0x1c, 0x53, 0x42, 0x5c, 0xf9, 0x21, 0xc0, 0xb1, 0x7a, 0xff, 0xc5,
+ 0xe8, 0xc5, 0x78, 0x74, 0x7d, 0xe6, 0xbe, 0x5e, 0xd4, 0x51, 0xab, 0xeb,
+ 0x8f, 0x5a, 0x88, 0xb7, 0x39, 0xac, 0x0b, 0xd4, 0x2c, 0xba, 0x5d, 0xdd,
+ 0x36, 0xdd, 0x77, 0xd7, 0x33, 0x47, 0x80, 0xde, 0x6b, 0xf2, 0x2a, 0x4f,
+ 0x69, 0x29, 0x04, 0xba, 0x9a, 0x79, 0x52, 0x81, 0x63, 0x66, 0x77, 0x6b,
+ 0x15, 0x8b, 0xd9, 0x72, 0x89, 0xeb, 0xee, 0x07, 0x40, 0x37, 0xd9, 0xec,
+ 0xd5, 0xf3, 0xfb, 0x16, 0xd0, 0x75, 0x4d, 0x70, 0x5b, 0xab, 0xf4, 0x89,
+ 0x2b, 0x42, 0x05, 0x75, 0xb1, 0x02, 0x18, 0x35, 0x5e, 0x7d, 0x74, 0x3d,
+ 0xd0, 0xc3, 0x4f, 0x65, 0xc0, 0x2d, 0x4f, 0x50, 0x2f, 0xd4, 0x37, 0x12,
+ 0x94, 0x79, 0x0e, 0x50, 0x62, 0x01, 0x15, 0x9a, 0x98, 0x58, 0xa2, 0x67,
+ 0x89, 0x8a, 0x97, 0x57, 0x1e, 0x20, 0x55, 0xc0, 0x4e, 0x03, 0x26, 0x45,
+ 0xe0, 0x8e, 0x99, 0x00, 0x1f, 0x08, 0xec, 0x09, 0x50, 0x66, 0xfc, 0xa2,
+ 0x12, 0xb7, 0x76, 0x6d, 0x30, 0xf1, 0xb8, 0xdb, 0x02, 0x5a, 0x69, 0x8c,
+ 0x9e, 0x89, 0xd0, 0x5c, 0xbf, 0x8e, 0xd7, 0x6e, 0x6d, 0x91, 0xde, 0x24,
+ 0xd3, 0x5c, 0xa5, 0x8b, 0x0c, 0x6d, 0xd6, 0xb9, 0x2e, 0x6c, 0xaf, 0x40,
+ 0x5e, 0x23, 0xdb, 0xe5, 0x22, 0x59, 0x57, 0xb2, 0xc4, 0x69, 0xae, 0x6d,
+ 0x8e, 0x05, 0x34, 0xc8, 0x64, 0x87, 0x23, 0x7f, 0xe6, 0x34, 0xd0, 0x3b,
+ 0x4d, 0x13, 0x77, 0xd8, 0x1d, 0xa8, 0x03, 0x4e, 0xa9, 0x50, 0x87, 0x92,
+ 0x45, 0x2a, 0x4f, 0x8e, 0x49, 0x94, 0x9e, 0x36, 0xb2, 0x5b, 0x01, 0x27,
+ 0x6d, 0xd5, 0x55, 0x2f, 0x7d, 0x59, 0x1f, 0xb8, 0xa9, 0xa0, 0x4e, 0x90,
+ 0x3b, 0x32, 0xb4, 0xda, 0x94, 0x20, 0x1f, 0xac, 0x10, 0xd8, 0x12, 0x91,
+ 0xed, 0x67, 0xa0, 0x23, 0x30, 0x14, 0x98, 0x0c, 0x8c, 0x34, 0x47, 0x27,
+ 0x80, 0x22, 0x60, 0xb6, 0xcd, 0xc2, 0x18, 0x15, 0xc4, 0x40, 0xc1, 0x5b,
+ 0x0d, 0x3c, 0x51, 0x70, 0x96, 0x2b, 0x86, 0xc2, 0x6d, 0x3f, 0xaa, 0x64,
+ 0x53, 0xa6, 0x39, 0x82, 0xb5, 0x2e, 0x93, 0x02, 0xad, 0x2a, 0x09, 0x38,
+ 0xfb, 0x17, 0x1a, 0xb4, 0x22, 0x15, 0xe2, 0x80, 0x32, 0x4a, 0x99, 0xd6,
+ 0x5c, 0x60, 0x3e, 0xa8, 0x47, 0x0a, 0x79, 0x30, 0x5c, 0xd6, 0x8c, 0x80,
+ 0x72, 0xc2, 0x39, 0x38, 0x26, 0xaa, 0xbd, 0x68, 0x6a, 0x30, 0x79, 0xa1,
+ 0x5c, 0xe5, 0x95, 0x4e, 0x4d, 0x0c, 0x2a, 0x57, 0xad, 0x47, 0x44, 0x92,
+ 0x24, 0xf7, 0x7d, 0x8d, 0x22, 0x90, 0x6a, 0x1d, 0xcf, 0xdb, 0xf2, 0x87,
+ 0xe2, 0x53, 0xa0, 0x9f, 0x8e, 0x02, 0x98, 0x23, 0xc0, 0xb0, 0x06, 0xfa,
+ 0xf4, 0xb0, 0xff, 0x17, 0x6a, 0x07, 0xcc, 0x14, 0x2d, 0xd4, 0x44, 0x00,
+ 0xe2, 0xbb, 0x7a, 0xee, 0xa9, 0xda, 0x95, 0x98, 0x70, 0x3e, 0x16, 0xae,
+ 0xb4, 0xd0, 0x71, 0xa9, 0xb7, 0x8e, 0x32, 0xa3, 0x75, 0x9d, 0x2c, 0xa6,
+ 0x77, 0x01, 0x54, 0x8a, 0x08, 0x4b, 0xb5, 0x80, 0x72, 0x43, 0x25, 0xff,
+ 0x9f, 0xfc, 0x02, 0x28, 0x07, 0xb4, 0x17, 0x3d, 0x6c, 0x2c, 0x9a, 0x00,
+ 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
+}
+
+var DataHibernate []byte = []byte{
+ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+ 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x12,
+ 0x08, 0x06, 0x00, 0x00, 0x00, 0x56, 0xce, 0x8e, 0x57, 0x00, 0x00, 0x00,
+ 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0,
+ 0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00,
+ 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b, 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18,
+ 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xdf, 0x08, 0x04,
+ 0x08, 0x28, 0x36, 0x0c, 0x5a, 0xb2, 0x47, 0x00, 0x00, 0x02, 0x6e, 0x49,
+ 0x44, 0x41, 0x54, 0x38, 0xcb, 0x9d, 0x94, 0x3b, 0x68, 0x54, 0x41, 0x14,
+ 0x86, 0xbf, 0x7f, 0x36, 0x59, 0xd0, 0x10, 0xc1, 0x07, 0xf8, 0x02, 0x51,
+ 0x8b, 0x80, 0x0f, 0x90, 0x18, 0x14, 0x0b, 0x9f, 0x88, 0x09, 0xe9, 0x54,
+ 0x0c, 0xa8, 0x08, 0x82, 0x82, 0x58, 0x88, 0xba, 0xf7, 0x42, 0x04, 0x91,
+ 0x6c, 0x46, 0xb1, 0x89, 0xde, 0xec, 0x06, 0x4c, 0x23, 0x36, 0x21, 0x85,
+ 0x08, 0xa2, 0xd8, 0x19, 0xb0, 0x50, 0xc1, 0xa0, 0x85, 0x85, 0x16, 0xc1,
+ 0x17, 0x2a, 0x46, 0x8d, 0x0a, 0xbe, 0x31, 0xcf, 0xdd, 0x7b, 0x2c, 0x72,
+ 0x17, 0x35, 0xbe, 0xa2, 0x7f, 0x35, 0x73, 0xce, 0xcc, 0x37, 0x67, 0x0e,
+ 0xff, 0x8c, 0xf8, 0x4e, 0xd9, 0xd6, 0x56, 0x7c, 0x10, 0x8c, 0x8e, 0xa3,
+ 0x68, 0xb3, 0xa4, 0xf5, 0x40, 0x05, 0x90, 0x32, 0xb3, 0x27, 0x38, 0x77,
+ 0xd9, 0x67, 0x32, 0xdd, 0xfc, 0x42, 0x1a, 0x0b, 0xc9, 0x46, 0xd1, 0x61,
+ 0x49, 0xc7, 0xf9, 0xbd, 0x9e, 0x19, 0xec, 0xf4, 0x41, 0x70, 0xf5, 0xfb,
+ 0x83, 0x55, 0x82, 0x94, 0x17, 0x8b, 0x8c, 0xa4, 0x52, 0xb7, 0x05, 0x4b,
+ 0x19, 0x87, 0x0c, 0xbc, 0x0f, 0x82, 0xe6, 0x6c, 0x2e, 0x87, 0xcf, 0x64,
+ 0x48, 0x95, 0xa8, 0xab, 0xea, 0xeb, 0xc7, 0x0d, 0x49, 0x2a, 0x58, 0xbb,
+ 0xa6, 0xb6, 0xf6, 0x83, 0x0f, 0x82, 0x5b, 0xdf, 0x2a, 0x8a, 0xa2, 0x03,
+ 0x92, 0xf2, 0xfc, 0x87, 0x2c, 0x8e, 0xe7, 0x20, 0xf5, 0x3a, 0x00, 0x49,
+ 0x27, 0x93, 0x78, 0x2f, 0xd0, 0x08, 0xec, 0x05, 0xce, 0x8f, 0xd9, 0x33,
+ 0x08, 0x9c, 0x02, 0xb6, 0x03, 0x27, 0x92, 0x39, 0x48, 0x6d, 0x3e, 0x0c,
+ 0x71, 0xd9, 0xd6, 0xd6, 0x3a, 0xa0, 0x0c, 0x38, 0xf7, 0x69, 0x60, 0x60,
+ 0x9e, 0xc1, 0x6b, 0x83, 0xe9, 0x16, 0xc7, 0x07, 0x63, 0xb3, 0x15, 0xc0,
+ 0x80, 0x99, 0xdd, 0x2d, 0xc6, 0xf1, 0x34, 0xe0, 0xac, 0x41, 0x0d, 0xd0,
+ 0x55, 0x30, 0x9b, 0x0a, 0xf4, 0x49, 0xda, 0x04, 0xe0, 0x30, 0x5b, 0x0e,
+ 0x14, 0x9a, 0x83, 0x60, 0xeb, 0xa4, 0x09, 0x13, 0x6e, 0x0b, 0x3a, 0x04,
+ 0x5e, 0xce, 0x3d, 0x17, 0xcc, 0x34, 0xb3, 0x75, 0xc0, 0x6a, 0xe7, 0xdc,
+ 0x19, 0xe0, 0x86, 0x60, 0x27, 0x70, 0x25, 0x05, 0x87, 0x80, 0x6d, 0x49,
+ 0x6b, 0x16, 0x39, 0x49, 0xf3, 0x81, 0xeb, 0x4d, 0xf9, 0xfc, 0x74, 0x60,
+ 0x09, 0xd0, 0x09, 0x34, 0x03, 0xf7, 0x24, 0x5d, 0x44, 0x7a, 0x83, 0xb4,
+ 0x59, 0xb0, 0x15, 0xe8, 0xc6, 0x6c, 0x19, 0xf0, 0x40, 0xd2, 0xfe, 0xe6,
+ 0x20, 0xb8, 0x96, 0x5c, 0x7b, 0x8a, 0x03, 0x3e, 0x02, 0x33, 0xe2, 0xf2,
+ 0xf2, 0xb7, 0x49, 0x70, 0x15, 0xb0, 0x05, 0x98, 0x0d, 0xdc, 0x49, 0xd7,
+ 0xd5, 0x3d, 0x31, 0xb8, 0x06, 0x14, 0x81, 0xc5, 0x48, 0x0d, 0x49, 0xee,
+ 0xe9, 0x91, 0xf6, 0xf6, 0x74, 0xa9, 0xe7, 0xce, 0xcc, 0xee, 0x03, 0x0b,
+ 0xcb, 0x86, 0x86, 0x16, 0x18, 0xec, 0x4e, 0x9c, 0x5c, 0x65, 0x70, 0xb3,
+ 0x32, 0x9d, 0xae, 0x1e, 0xee, 0xea, 0xea, 0x94, 0xd9, 0x4a, 0x83, 0x65,
+ 0xc0, 0x4b, 0x83, 0x16, 0xa0, 0x2f, 0x36, 0xdb, 0x98, 0x1a, 0x1c, 0x3c,
+ 0x36, 0x4a, 0x71, 0x3d, 0x0e, 0xb3, 0x0b, 0x09, 0xb5, 0x5b, 0xf0, 0xaa,
+ 0xbf, 0x50, 0x98, 0x55, 0x94, 0x2a, 0xcd, 0x6c, 0xcf, 0xe7, 0xe1, 0xe1,
+ 0x4b, 0x82, 0x1d, 0x92, 0x3a, 0x80, 0x0d, 0x85, 0x62, 0xb1, 0xc6, 0x60,
+ 0x62, 0x41, 0x5a, 0xe2, 0xa4, 0xdd, 0x92, 0x1a, 0x81, 0x17, 0x47, 0x33,
+ 0x99, 0x77, 0x25, 0x1f, 0x5d, 0x97, 0xb4, 0x32, 0xf1, 0xd5, 0x7b, 0x60,
+ 0x04, 0x98, 0x0a, 0xa4, 0xc6, 0x58, 0xe0, 0x0b, 0xf0, 0x19, 0xa8, 0x4c,
+ 0x2a, 0xc7, 0xcc, 0xf6, 0xf9, 0x30, 0x6c, 0x2f, 0x4b, 0x16, 0xec, 0x02,
+ 0x1e, 0x26, 0xe3, 0xc9, 0x7f, 0xf0, 0x5f, 0x45, 0x09, 0x90, 0x40, 0xfa,
+ 0x7c, 0x18, 0xb6, 0x67, 0xa3, 0x08, 0x07, 0xe0, 0xc3, 0xf0, 0x91, 0x99,
+ 0x35, 0xfc, 0xa3, 0xa9, 0xfb, 0x19, 0xed, 0x1b, 0x3e, 0x0c, 0x47, 0x41,
+ 0xd9, 0x5c, 0x0e, 0x1f, 0x86, 0xe7, 0x0d, 0xea, 0x81, 0x78, 0x1c, 0x0f,
+ 0xf6, 0xb1, 0x99, 0x55, 0xf9, 0x30, 0x7c, 0xf1, 0xd3, 0x37, 0x52, 0x52,
+ 0x53, 0x2e, 0x97, 0x96, 0xd9, 0x31, 0xcc, 0xf6, 0x4a, 0x9a, 0x34, 0x26,
+ 0xdd, 0x63, 0x66, 0x6d, 0x3e, 0x0c, 0x4f, 0xff, 0xb5, 0x5e, 0xdf, 0xd6,
+ 0xf6, 0x0d, 0x9a, 0xcf, 0x57, 0x66, 0xa3, 0xa8, 0x3a, 0x9b, 0xcb, 0xcd,
+ 0xfd, 0xe1, 0x03, 0x6c, 0x69, 0xf9, 0x69, 0xdf, 0x57, 0xc7, 0x42, 0xfa,
+ 0xe7, 0x6d, 0x87, 0x6c, 0xde, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
+ 0x44, 0xae, 0x42, 0x60, 0x82,
+}
diff --git a/vendor/github.com/facchinm/systray/example/icon/iconlinux.go b/vendor/github.com/facchinm/systray/example/icon/iconlinux.go
new file mode 100644
index 000000000..633e417ae
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/example/icon/iconlinux.go
@@ -0,0 +1,299 @@
+//+build linux
+
+// File generated by 2goarray v0.1.0 (http://github.com/cratonica/2goarray)
+
+package icon
+
+var Data []byte = []byte{
+ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+ 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x31,
+ 0x08, 0x06, 0x00, 0x00, 0x00, 0x73, 0x9c, 0x41, 0x1c, 0x00, 0x00, 0x00,
+ 0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b,
+ 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00, 0x00, 0x19, 0x74, 0x45,
+ 0x58, 0x74, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x00, 0x41,
+ 0x64, 0x6f, 0x62, 0x65, 0x20, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x65,
+ 0x61, 0x64, 0x79, 0x71, 0xc9, 0x65, 0x3c, 0x00, 0x00, 0x03, 0xde, 0x49,
+ 0x44, 0x41, 0x54, 0x78, 0xda, 0xd4, 0x9a, 0xd1, 0x6d, 0xdb, 0x30, 0x10,
+ 0x86, 0x15, 0xa3, 0xaf, 0x45, 0xbd, 0x41, 0xd4, 0x09, 0xac, 0x4e, 0x60,
+ 0x75, 0x03, 0x6d, 0x10, 0x65, 0x82, 0x2a, 0x8f, 0x05, 0x0a, 0xd4, 0x01,
+ 0x0a, 0xf4, 0xb1, 0xea, 0x04, 0x95, 0x27, 0xa8, 0x33, 0x41, 0xe4, 0x09,
+ 0x2a, 0x4f, 0x50, 0x7b, 0x03, 0x1b, 0x1d, 0xc0, 0x3d, 0x16, 0x3f, 0x83,
+ 0xeb, 0xe5, 0x48, 0xd1, 0xb6, 0x6c, 0x29, 0x04, 0x08, 0x07, 0x0e, 0x49,
+ 0xf1, 0xe3, 0x1d, 0x8f, 0xff, 0x51, 0xbe, 0xda, 0xef, 0xf7, 0xd1, 0x4b,
+ 0x2f, 0xaf, 0xce, 0x31, 0xe8, 0xeb, 0x2f, 0x5f, 0x53, 0xc7, 0xbf, 0xd6,
+ 0x7f, 0x3e, 0x7d, 0x5c, 0x77, 0xfd, 0xbc, 0xab, 0x53, 0x2d, 0x41, 0x13,
+ 0x1e, 0xd3, 0x47, 0x46, 0x35, 0x45, 0xbd, 0x0e, 0xe8, 0xb6, 0xa4, 0x5a,
+ 0x53, 0x5d, 0x10, 0x54, 0xd3, 0x1b, 0x04, 0x4d, 0x3e, 0xa6, 0x8f, 0x19,
+ 0x00, 0xde, 0x9c, 0x30, 0x87, 0x0d, 0xd5, 0x92, 0x6a, 0x45, 0x40, 0xdb,
+ 0x8b, 0x40, 0xb0, 0xc9, 0xdf, 0x74, 0xec, 0x15, 0x3b, 0x03, 0x43, 0x20,
+ 0xb3, 0xb3, 0x42, 0x10, 0x80, 0x79, 0xc0, 0xe7, 0x33, 0xef, 0x53, 0x63,
+ 0x99, 0xec, 0x10, 0x37, 0x0b, 0x82, 0x80, 0xdf, 0x2f, 0xa8, 0x4e, 0x2f,
+ 0x18, 0x74, 0xee, 0x08, 0xa4, 0xec, 0x04, 0x82, 0x00, 0x12, 0x00, 0x5c,
+ 0x47, 0x97, 0x2f, 0x73, 0x02, 0xc9, 0x4f, 0x82, 0x00, 0x40, 0x7d, 0xe2,
+ 0xc6, 0x3d, 0x3b, 0x88, 0x13, 0x02, 0x2e, 0xb4, 0xee, 0x19, 0x20, 0x08,
+ 0x64, 0xe4, 0xe9, 0x58, 0x0f, 0x04, 0xc0, 0x94, 0x1b, 0x5a, 0xd4, 0xc3,
+ 0x20, 0xa8, 0x83, 0xd9, 0x50, 0x93, 0x81, 0xa9, 0x8b, 0x1f, 0x70, 0xef,
+ 0x76, 0x08, 0x34, 0xfc, 0x30, 0x50, 0x99, 0x54, 0x85, 0x5a, 0xa2, 0x8c,
+ 0x86, 0x5b, 0x26, 0x9a, 0x5b, 0x8d, 0x14, 0xe1, 0x36, 0x8d, 0x86, 0x5d,
+ 0x66, 0xde, 0xe8, 0x44, 0x10, 0x75, 0x0b, 0xc4, 0x0a, 0x67, 0xc6, 0x1a,
+ 0xd5, 0x40, 0x5b, 0x01, 0x78, 0xcc, 0x39, 0xf2, 0x40, 0xb5, 0x61, 0xe3,
+ 0x25, 0xa8, 0x6d, 0x42, 0xf2, 0x96, 0xa2, 0x55, 0xf5, 0x0c, 0x02, 0x9a,
+ 0xe8, 0xb7, 0xe7, 0x61, 0x85, 0x4f, 0x46, 0xc3, 0x8a, 0xb3, 0x40, 0x4b,
+ 0xde, 0x43, 0x27, 0x6d, 0x3d, 0xe3, 0xe5, 0x18, 0x4f, 0x83, 0x59, 0x52,
+ 0xdf, 0x54, 0x83, 0x28, 0xe8, 0xe3, 0x9b, 0x22, 0xca, 0x72, 0xea, 0xb0,
+ 0x38, 0x40, 0x5f, 0x69, 0xe3, 0x70, 0x4b, 0xe6, 0xa1, 0xba, 0x08, 0x67,
+ 0x55, 0xe9, 0x10, 0x9b, 0x6f, 0xed, 0xa2, 0x72, 0x08, 0xcd, 0x95, 0xde,
+ 0xf1, 0x07, 0xb2, 0xdc, 0x21, 0x46, 0x35, 0x83, 0x34, 0x12, 0xd2, 0x71,
+ 0xd2, 0x1b, 0x80, 0x94, 0xaf, 0x3e, 0xac, 0x9f, 0xc1, 0x25, 0x13, 0xb8,
+ 0x96, 0x36, 0x5e, 0xa5, 0x80, 0x3c, 0xb9, 0x14, 0x87, 0xd8, 0xfb, 0x04,
+ 0x18, 0x14, 0x6c, 0xe1, 0x38, 0x00, 0x9f, 0x59, 0x0c, 0x20, 0xbf, 0x34,
+ 0x80, 0x96, 0x15, 0x56, 0x95, 0x2c, 0xf5, 0x69, 0xc4, 0xd9, 0xf5, 0x74,
+ 0x8a, 0x8f, 0x1c, 0xe9, 0xe4, 0x46, 0x00, 0x54, 0x90, 0xe0, 0xae, 0x13,
+ 0xdc, 0x7c, 0xff, 0x13, 0xed, 0xfe, 0x15, 0x4c, 0xe0, 0x16, 0x80, 0x1c,
+ 0xc0, 0xae, 0xb8, 0x2f, 0x1f, 0x31, 0xfb, 0xa0, 0x16, 0x87, 0x5b, 0x21,
+ 0xda, 0x24, 0x32, 0xc4, 0xc6, 0xae, 0x30, 0x46, 0x03, 0x65, 0x07, 0x24,
+ 0x40, 0x37, 0x02, 0xc4, 0xfc, 0x9d, 0x08, 0x0b, 0xd4, 0xca, 0x66, 0x5d,
+ 0xa1, 0xca, 0x85, 0xa9, 0xd1, 0xc7, 0x8c, 0x55, 0x8b, 0x36, 0x93, 0x36,
+ 0x88, 0x85, 0x2f, 0x2e, 0x07, 0x80, 0x14, 0x0c, 0x64, 0x1d, 0xa0, 0xc7,
+ 0x0a, 0x65, 0xa5, 0x2d, 0x48, 0xe6, 0x98, 0x97, 0xf7, 0xc4, 0xde, 0x88,
+ 0xd0, 0x37, 0x11, 0xbe, 0xbf, 0x54, 0xea, 0x4e, 0x5a, 0x12, 0x9b, 0x56,
+ 0x66, 0x85, 0x13, 0xc5, 0x02, 0xa6, 0xff, 0x16, 0x75, 0xa9, 0x58, 0x24,
+ 0x13, 0x8b, 0x20, 0x03, 0x88, 0x7a, 0x65, 0xb3, 0xf6, 0x5c, 0xbd, 0x34,
+ 0x3c, 0x3e, 0x7b, 0x0e, 0x49, 0xb3, 0x82, 0xb9, 0xb0, 0xa2, 0xa6, 0x42,
+ 0x0b, 0xb8, 0x89, 0x2d, 0x29, 0x9e, 0xf9, 0xc8, 0xbe, 0x1b, 0x7b, 0xac,
+ 0x3e, 0x76, 0x41, 0xc4, 0xcc, 0x15, 0x8c, 0x4f, 0xfe, 0xb7, 0x99, 0x30,
+ 0xe1, 0xc8, 0xb5, 0xc9, 0x98, 0xc5, 0x2a, 0x45, 0xbc, 0xc9, 0xfc, 0xbc,
+ 0xa4, 0xf1, 0xb6, 0xcc, 0x95, 0x4a, 0x65, 0xd2, 0xbe, 0x1b, 0x90, 0xad,
+ 0xcb, 0x9d, 0xae, 0xed, 0x66, 0x62, 0x26, 0xe7, 0x2b, 0x3c, 0x55, 0xaa,
+ 0xf4, 0xf3, 0x99, 0x3c, 0xdd, 0x71, 0x8b, 0x21, 0x5d, 0x65, 0x82, 0xfe,
+ 0x63, 0xd4, 0xa9, 0xe2, 0x72, 0xb5, 0x6b, 0xb1, 0x6c, 0x08, 0x1e, 0x49,
+ 0x17, 0x52, 0xfc, 0xf0, 0x50, 0x55, 0x3b, 0x17, 0xe1, 0x39, 0x16, 0xe3,
+ 0xee, 0x1c, 0xca, 0xb9, 0x74, 0x9c, 0x3f, 0x55, 0x8b, 0x4b, 0x3a, 0x21,
+ 0x72, 0x11, 0x26, 0xe7, 0xc7, 0xa4, 0x91, 0xd0, 0x3f, 0x0d, 0x0b, 0x93,
+ 0x56, 0x34, 0x6e, 0x14, 0x8b, 0x68, 0x49, 0x58, 0xc6, 0xc2, 0x73, 0x2a,
+ 0xda, 0xac, 0xfe, 0x83, 0x10, 0x9b, 0xcb, 0x94, 0xa9, 0x08, 0x93, 0x39,
+ 0x44, 0x9b, 0xef, 0xe2, 0xeb, 0x4e, 0x00, 0x24, 0x58, 0x5d, 0x19, 0xef,
+ 0x1b, 0xb8, 0xc5, 0xbc, 0xe5, 0xee, 0xe9, 0xbd, 0x98, 0x97, 0xb4, 0x54,
+ 0xa3, 0x09, 0xc0, 0x46, 0x09, 0xa7, 0xa9, 0x38, 0xfa, 0xad, 0xd6, 0x49,
+ 0x10, 0x00, 0x6a, 0x58, 0x71, 0x21, 0x34, 0x91, 0xa6, 0x9d, 0x1e, 0x20,
+ 0x4d, 0x34, 0xed, 0x14, 0x63, 0xcc, 0xfa, 0x54, 0xed, 0xd4, 0x95, 0x8a,
+ 0xcd, 0x99, 0x05, 0x34, 0x15, 0x9b, 0x1d, 0x72, 0x33, 0xee, 0x00, 0x70,
+ 0xaa, 0x58, 0x5f, 0x3e, 0x31, 0xd7, 0x22, 0xce, 0x91, 0xf9, 0xc4, 0xce,
+ 0x6e, 0xe4, 0x96, 0x7c, 0x22, 0xc5, 0xa6, 0x0e, 0xcf, 0x27, 0x02, 0x33,
+ 0x3b, 0x7b, 0x25, 0xdf, 0x20, 0x46, 0xc7, 0x2c, 0x13, 0x3b, 0xe6, 0x76,
+ 0xc4, 0x66, 0x76, 0x35, 0x3b, 0xa3, 0x92, 0x80, 0x4c, 0x51, 0xcf, 0xec,
+ 0x18, 0xfd, 0xe3, 0xc0, 0x73, 0x6c, 0x23, 0x8b, 0x62, 0xa7, 0x76, 0x42,
+ 0x34, 0x58, 0xbe, 0xb4, 0x8b, 0x82, 0x51, 0x48, 0xa3, 0x01, 0x95, 0x15,
+ 0x77, 0x23, 0x27, 0x04, 0xac, 0xf1, 0x7d, 0xa0, 0x10, 0x79, 0xf0, 0x35,
+ 0x26, 0x81, 0x14, 0x8a, 0xce, 0xe9, 0xbb, 0xdc, 0xb9, 0x2e, 0x18, 0x7c,
+ 0x17, 0xca, 0xa9, 0x43, 0xe7, 0xf4, 0x51, 0xe6, 0xbe, 0x17, 0x2e, 0x4e,
+ 0x08, 0xc4, 0xf0, 0x21, 0x80, 0xb4, 0xbe, 0x9f, 0xf0, 0x59, 0xc2, 0xea,
+ 0x9c, 0x3e, 0x41, 0x82, 0xde, 0x14, 0x8d, 0xda, 0x1a, 0x00, 0x24, 0xee,
+ 0x61, 0x8f, 0xdc, 0x87, 0x00, 0x3c, 0x3b, 0xec, 0x02, 0x74, 0xcc, 0x2c,
+ 0xba, 0xcc, 0xdb, 0xd3, 0x5c, 0x51, 0xd6, 0xdd, 0x40, 0x30, 0x8d, 0x55,
+ 0x45, 0xdd, 0xdf, 0x9e, 0x07, 0x69, 0xaa, 0x4e, 0x20, 0x84, 0x44, 0xc9,
+ 0xa3, 0xd3, 0x5f, 0xca, 0x6f, 0xb0, 0x28, 0xe5, 0xc5, 0x7e, 0x51, 0xa0,
+ 0xc0, 0x1c, 0xf3, 0xdb, 0x8e, 0x15, 0x44, 0x5f, 0xd5, 0xeb, 0x6f, 0x3b,
+ 0x5a, 0xa0, 0x12, 0xd7, 0xed, 0x44, 0x17, 0x93, 0x3e, 0x3b, 0x44, 0x1f,
+ 0xe5, 0xaf, 0x00, 0x03, 0x00, 0x18, 0x6e, 0x35, 0xfe, 0xd0, 0x2e, 0x87,
+ 0xf2, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60,
+ 0x82,
+}
+
+var DataHibernate []byte = []byte{
+ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d,
+ 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64,
+ 0x08, 0x06, 0x00, 0x00, 0x00, 0x70, 0xe2, 0x95, 0x54, 0x00, 0x00, 0x00,
+ 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xa0,
+ 0xbd, 0xa7, 0x93, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59, 0x73, 0x00,
+ 0x00, 0x17, 0x12, 0x00, 0x00, 0x17, 0x12, 0x01, 0x67, 0x9f, 0xd2, 0x52,
+ 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xdf, 0x08, 0x03,
+ 0x0c, 0x07, 0x0b, 0xdc, 0xf0, 0x56, 0x5e, 0x00, 0x00, 0x08, 0xa8, 0x49,
+ 0x44, 0x41, 0x54, 0x78, 0xda, 0xed, 0x5d, 0xe1, 0x95, 0x9b, 0x38, 0x10,
+ 0xfe, 0xe2, 0x97, 0xff, 0x76, 0x07, 0xe6, 0x2a, 0x58, 0xa7, 0x82, 0xd0,
+ 0x41, 0x7c, 0x15, 0x98, 0x54, 0xb0, 0xa8, 0x02, 0xa0, 0x02, 0x9c, 0x0a,
+ 0xc2, 0x56, 0x10, 0x6f, 0x05, 0x67, 0x57, 0x10, 0xb6, 0x82, 0xb3, 0x2b,
+ 0x38, 0xbb, 0x82, 0xdc, 0x0f, 0x86, 0x0b, 0xcb, 0x21, 0x69, 0x24, 0x04,
+ 0xc6, 0xb6, 0xe6, 0x3d, 0x3f, 0xef, 0x4b, 0x76, 0x61, 0xd0, 0xa7, 0x99,
+ 0xf9, 0x66, 0x34, 0x12, 0x1f, 0x7e, 0xfd, 0xfa, 0x05, 0x2f, 0xd3, 0x91,
+ 0x99, 0x1f, 0x02, 0x0f, 0x88, 0x17, 0x85, 0x7c, 0xbc, 0x05, 0x25, 0xb3,
+ 0x3c, 0x5f, 0x00, 0x58, 0xd1, 0x67, 0xd1, 0xf8, 0x06, 0x7d, 0x3f, 0x35,
+ 0x7e, 0xfd, 0x0d, 0xc0, 0x99, 0x7e, 0x3e, 0x03, 0x28, 0x1b, 0xdf, 0x65,
+ 0x22, 0xc4, 0x79, 0xca, 0xcf, 0xfa, 0x61, 0x8a, 0x31, 0x24, 0xcb, 0xf3,
+ 0x00, 0xc0, 0x1a, 0x40, 0x48, 0x83, 0xbf, 0x74, 0x78, 0xf9, 0x13, 0x80,
+ 0x7d, 0xfd, 0x49, 0x84, 0x38, 0x7a, 0x40, 0xba, 0x41, 0x58, 0x01, 0x88,
+ 0x08, 0x88, 0xe5, 0x88, 0xb7, 0x7e, 0x03, 0x50, 0x00, 0xd8, 0x4d, 0x01,
+ 0x9c, 0xab, 0x02, 0x42, 0xae, 0x28, 0x02, 0x10, 0x8f, 0x0c, 0x82, 0x0a,
+ 0x9c, 0x6d, 0x22, 0x44, 0xf1, 0x50, 0x80, 0x90, 0x4b, 0x4a, 0xc9, 0x1a,
+ 0xe6, 0x13, 0x74, 0xe5, 0x17, 0x00, 0x5b, 0x02, 0xe7, 0x7c, 0xb7, 0x80,
+ 0x34, 0x80, 0xd8, 0xdc, 0x08, 0xe9, 0x19, 0x1d, 0x98, 0x51, 0x00, 0x21,
+ 0xd7, 0x14, 0xd3, 0x67, 0x8e, 0xdb, 0x93, 0x0b, 0x80, 0x78, 0x0c, 0x57,
+ 0x36, 0x38, 0x20, 0x59, 0x9e, 0x87, 0x14, 0x34, 0x97, 0xb8, 0x7d, 0x39,
+ 0x10, 0x30, 0xe5, 0xcd, 0x01, 0x42, 0x56, 0x91, 0x02, 0x78, 0xbe, 0xc3,
+ 0xfc, 0x2d, 0x4b, 0x84, 0x48, 0x6f, 0x06, 0x10, 0xa2, 0xb0, 0x45, 0x2b,
+ 0x61, 0xbb, 0x37, 0x39, 0x00, 0x58, 0xbb, 0x8e, 0x2d, 0xb3, 0x01, 0xc0,
+ 0x88, 0x28, 0xe9, 0xba, 0x67, 0x30, 0x00, 0xe0, 0x33, 0x80, 0x23, 0x4d,
+ 0xbe, 0x69, 0x02, 0x92, 0xe5, 0xf9, 0x16, 0xc0, 0xf7, 0x1b, 0x0d, 0xdc,
+ 0x36, 0x32, 0x07, 0xf0, 0x93, 0x26, 0xe1, 0xb4, 0x00, 0xc9, 0xf2, 0xbc,
+ 0xb8, 0xd3, 0x78, 0xc1, 0x91, 0xef, 0x59, 0x9e, 0xc7, 0x93, 0x89, 0x21,
+ 0x04, 0xc6, 0x06, 0x5e, 0x5e, 0x12, 0x21, 0xa2, 0xab, 0x5a, 0x88, 0x07,
+ 0xe3, 0x9d, 0x6c, 0x68, 0x3c, 0xae, 0x03, 0x88, 0x07, 0x43, 0x0a, 0x4a,
+ 0x3c, 0x3a, 0x20, 0x14, 0xc0, 0x3d, 0x18, 0xdd, 0x92, 0xdb, 0x06, 0x7a,
+ 0xab, 0x18, 0x42, 0x37, 0xfb, 0xee, 0xc7, 0x5d, 0x2b, 0x9f, 0x4c, 0xb3,
+ 0x7a, 0x63, 0x40, 0x88, 0x77, 0xff, 0xf4, 0x63, 0xcd, 0x92, 0x0b, 0x80,
+ 0xc0, 0x24, 0x79, 0x9c, 0x19, 0x82, 0xb1, 0x00, 0xb0, 0xf3, 0xe3, 0x6c,
+ 0x94, 0xa7, 0x18, 0x8d, 0x97, 0x69, 0x0c, 0x29, 0x70, 0x1f, 0x45, 0xc2,
+ 0x51, 0x33, 0xfa, 0x2c, 0xcf, 0x53, 0xe7, 0x2e, 0x2b, 0xcb, 0xf3, 0x35,
+ 0x80, 0x1f, 0x7e, 0x7c, 0x87, 0x8d, 0x27, 0x33, 0x26, 0x18, 0x0b, 0xb2,
+ 0x0e, 0x2f, 0xf6, 0xb2, 0x75, 0xe9, 0xb2, 0x52, 0x3c, 0x4e, 0x7d, 0x6a,
+ 0x48, 0xd7, 0xa5, 0xa5, 0xc2, 0x5a, 0x97, 0x45, 0xcb, 0xae, 0x7f, 0xfb,
+ 0xf1, 0x1c, 0x87, 0x75, 0xcd, 0x98, 0xd6, 0xe1, 0xc5, 0x1d, 0xeb, 0x8a,
+ 0xad, 0x2d, 0xc4, 0x5b, 0xc7, 0xf8, 0x56, 0x32, 0xf3, 0xd6, 0x31, 0x2d,
+ 0x2b, 0xf9, 0xa8, 0xb1, 0x8e, 0x8d, 0xa3, 0x19, 0x51, 0xa2, 0x5a, 0x45,
+ 0xac, 0x7b, 0x6c, 0x6b, 0xa9, 0xfb, 0x74, 0x03, 0xfa, 0xbe, 0xe6, 0x2a,
+ 0xe3, 0x5b, 0x4b, 0xc7, 0xe6, 0x0c, 0x0e, 0x1b, 0xba, 0x7e, 0x76, 0x70,
+ 0xaf, 0x58, 0x36, 0xd9, 0xa5, 0x2e, 0x8b, 0x8a, 0x87, 0xcf, 0x3d, 0x40,
+ 0xd8, 0xa1, 0x6a, 0xcf, 0x64, 0x67, 0xaa, 0x34, 0x09, 0x42, 0x52, 0x78,
+ 0x0c, 0x70, 0x5e, 0x1b, 0x7a, 0x9e, 0x0d, 0xf4, 0x5c, 0xa3, 0x6a, 0xf2,
+ 0xeb, 0x33, 0x61, 0xbf, 0x76, 0xb5, 0x15, 0xa9, 0x00, 0x39, 0x5b, 0x50,
+ 0x5d, 0x67, 0x8d, 0x65, 0xd4, 0x3e, 0x94, 0x3a, 0x9a, 0x91, 0x6d, 0x79,
+ 0x01, 0x90, 0xf6, 0xed, 0xe5, 0xed, 0xd9, 0xf8, 0x77, 0x48, 0x84, 0x08,
+ 0x59, 0x80, 0x58, 0x66, 0xe5, 0xaf, 0x00, 0x22, 0xd7, 0x5d, 0x18, 0x04,
+ 0xcc, 0xd6, 0x91, 0xc5, 0x1c, 0x48, 0xc7, 0xa3, 0x63, 0x1d, 0x03, 0x4a,
+ 0x9c, 0x4d, 0x27, 0xcf, 0x1f, 0x6d, 0x5d, 0x64, 0x80, 0x14, 0x06, 0xa8,
+ 0x5f, 0xe8, 0x21, 0x07, 0x2d, 0x3a, 0x52, 0x3d, 0x28, 0xe9, 0xe1, 0x42,
+ 0xd3, 0x44, 0x88, 0xed, 0xc0, 0x3a, 0xc6, 0x00, 0x72, 0x83, 0x3f, 0x11,
+ 0x6d, 0x9d, 0x64, 0x2c, 0x6b, 0x6d, 0xf0, 0xa0, 0xe1, 0xd0, 0x60, 0x00,
+ 0x00, 0x35, 0xa6, 0xfd, 0x49, 0xf7, 0x34, 0x91, 0x13, 0xe9, 0xb8, 0x1d,
+ 0x41, 0xc7, 0xad, 0xa1, 0x8e, 0x91, 0xd6, 0x65, 0x91, 0x8b, 0xf8, 0xcb,
+ 0x00, 0x8c, 0x12, 0x23, 0x0a, 0xad, 0xc7, 0xec, 0x99, 0xf1, 0xed, 0x8d,
+ 0x74, 0x3c, 0x4f, 0x58, 0xc7, 0x77, 0x6e, 0xeb, 0xa3, 0xa5, 0x75, 0xb0,
+ 0xc1, 0x20, 0xff, 0x1a, 0x11, 0x7b, 0xfa, 0x2c, 0x19, 0xb4, 0x92, 0xcb,
+ 0xc8, 0x12, 0x21, 0x4a, 0x7a, 0xe0, 0x9d, 0x26, 0xae, 0xb0, 0xc1, 0xa0,
+ 0xe2, 0x69, 0xcd, 0x9c, 0xba, 0x76, 0x6c, 0xd5, 0xd4, 0xbd, 0x66, 0x64,
+ 0x47, 0x86, 0x8e, 0x31, 0x78, 0xab, 0xaa, 0x21, 0x1a, 0x85, 0xdb, 0x2e,
+ 0x0b, 0xd9, 0x33, 0x82, 0xd3, 0x57, 0x5d, 0x27, 0x38, 0x0d, 0xda, 0xd6,
+ 0x30, 0xd0, 0xb1, 0x59, 0x9a, 0x66, 0x16, 0xb2, 0xc0, 0x20, 0x20, 0xb6,
+ 0x30, 0xdf, 0xa7, 0xc2, 0x62, 0x69, 0xcc, 0xd4, 0xe1, 0x5d, 0xeb, 0x50,
+ 0x57, 0x0c, 0xd1, 0x0d, 0xe0, 0x2b, 0x03, 0x8c, 0x14, 0xd5, 0x32, 0xaf,
+ 0x29, 0xeb, 0x98, 0x53, 0xe0, 0x2e, 0x89, 0xe9, 0x29, 0x67, 0x21, 0xcd,
+ 0xae, 0x8b, 0x24, 0x66, 0xe8, 0xc0, 0x88, 0x01, 0x1c, 0x89, 0xbc, 0x98,
+ 0xd2, 0xfb, 0x0d, 0xe9, 0x18, 0x69, 0x74, 0x8c, 0x69, 0x72, 0xa8, 0x64,
+ 0x25, 0x0d, 0xea, 0x14, 0x3f, 0x74, 0x33, 0x38, 0xd6, 0x3c, 0x68, 0xd1,
+ 0x83, 0x0d, 0xd5, 0xb2, 0x04, 0xf0, 0x83, 0x66, 0x98, 0x0e, 0x94, 0xa8,
+ 0xa5, 0x9f, 0xb2, 0x01, 0x3a, 0xcb, 0xf3, 0x45, 0x96, 0xe7, 0x3b, 0x62,
+ 0x43, 0x7d, 0x96, 0x14, 0xe6, 0xa8, 0x3a, 0x16, 0x0b, 0x46, 0x56, 0xae,
+ 0x92, 0x27, 0x15, 0xcb, 0x0a, 0x34, 0x7f, 0x5c, 0xa8, 0xcc, 0x74, 0x80,
+ 0x3e, 0xad, 0xe7, 0x2c, 0xcf, 0x0b, 0x72, 0x2d, 0x32, 0x50, 0x76, 0x00,
+ 0xbe, 0xd5, 0x0f, 0xaf, 0x8a, 0x6b, 0x74, 0x9d, 0x3d, 0x80, 0x2f, 0x0e,
+ 0x75, 0xdc, 0xa8, 0x96, 0x68, 0x13, 0x21, 0xf6, 0x94, 0xff, 0xe8, 0x72,
+ 0x2d, 0x2b, 0x40, 0xb6, 0x1a, 0x37, 0x35, 0x44, 0x9f, 0xd6, 0x86, 0x06,
+ 0x51, 0xe7, 0x1a, 0x32, 0x95, 0x2b, 0x6d, 0x80, 0x31, 0x44, 0x49, 0x26,
+ 0xd1, 0xb8, 0xd8, 0x54, 0xf3, 0xf7, 0x81, 0x0c, 0x90, 0x50, 0x13, 0x3b,
+ 0x8e, 0x0a, 0x26, 0x95, 0x60, 0x38, 0x79, 0xd2, 0xb9, 0x06, 0xd5, 0x06,
+ 0x1a, 0x43, 0x30, 0x2e, 0x34, 0xa3, 0xeb, 0x0f, 0x37, 0xa7, 0xd8, 0xca,
+ 0x2c, 0x99, 0xac, 0xe4, 0x64, 0x03, 0x88, 0x4a, 0x76, 0x3d, 0x66, 0xc0,
+ 0xe0, 0xae, 0x81, 0x61, 0xd9, 0x5c, 0xcb, 0x28, 0x13, 0x21, 0xc2, 0xfa,
+ 0x83, 0xf7, 0xd5, 0x69, 0x5d, 0xdc, 0x8b, 0x2c, 0xc7, 0x4f, 0x0a, 0x88,
+ 0x6a, 0xf3, 0xc9, 0x5e, 0x31, 0xfb, 0xc6, 0x6a, 0x29, 0x4d, 0x18, 0xc4,
+ 0xa3, 0x8b, 0x4d, 0x8d, 0xa5, 0x5f, 0x6c, 0x3a, 0x7e, 0x3a, 0x40, 0xe6,
+ 0x0a, 0x97, 0x70, 0x54, 0x24, 0x36, 0x63, 0xca, 0x4e, 0x15, 0xe4, 0x3b,
+ 0x72, 0x95, 0x74, 0x44, 0xdd, 0x96, 0xe4, 0xbe, 0x3b, 0x2d, 0x8f, 0x73,
+ 0x01, 0xee, 0xe1, 0x33, 0x07, 0x2e, 0x8f, 0x96, 0x24, 0x69, 0x26, 0xa5,
+ 0x0b, 0x5d, 0xee, 0x32, 0x27, 0x17, 0x14, 0x31, 0x5d, 0x95, 0x8e, 0xda,
+ 0x9e, 0x28, 0x1f, 0x91, 0x0d, 0x5c, 0xd9, 0x31, 0x9b, 0x97, 0xdc, 0xcc,
+ 0xbb, 0x39, 0xa1, 0xb3, 0x3c, 0x77, 0x06, 0x08, 0x7a, 0x00, 0x12, 0x53,
+ 0x50, 0xe3, 0xba, 0x18, 0x4e, 0xe7, 0xde, 0x26, 0xcb, 0xf3, 0x42, 0x75,
+ 0x5d, 0x4a, 0xda, 0x38, 0x89, 0x69, 0xa1, 0x22, 0x04, 0xc4, 0xe0, 0xda,
+ 0x6c, 0x32, 0xe1, 0xb8, 0x1f, 0x09, 0xf8, 0x4b, 0x57, 0x41, 0x5d, 0x26,
+ 0x0b, 0x5c, 0x47, 0x74, 0x16, 0x12, 0x63, 0x7a, 0x72, 0x54, 0x10, 0x02,
+ 0x67, 0x80, 0x5c, 0x4b, 0x74, 0x19, 0xf2, 0x14, 0x9b, 0xc2, 0x03, 0x05,
+ 0xd5, 0x76, 0xe6, 0xb2, 0xf6, 0x1a, 0xd7, 0x10, 0x99, 0x32, 0x23, 0x86,
+ 0xbc, 0xea, 0xdc, 0x60, 0x22, 0x44, 0x4a, 0x6e, 0x4b, 0xd7, 0x1c, 0x1e,
+ 0xb6, 0xe8, 0xf4, 0xb1, 0x99, 0x60, 0xd2, 0x35, 0x02, 0x03, 0x12, 0x73,
+ 0xd4, 0x50, 0x63, 0x65, 0xc0, 0xe7, 0x02, 0xb2, 0xb2, 0x54, 0x00, 0x03,
+ 0x50, 0x4e, 0x6d, 0x3d, 0xad, 0xe5, 0xd6, 0x74, 0x6b, 0x3b, 0x9f, 0x5b,
+ 0x13, 0xea, 0xd0, 0xb2, 0x3e, 0x6e, 0x2c, 0x52, 0xb2, 0x29, 0x2e, 0x33,
+ 0xe4, 0xba, 0xac, 0xb9, 0x82, 0xce, 0x8d, 0xed, 0x1a, 0x62, 0xee, 0x9a,
+ 0x38, 0x59, 0x51, 0x36, 0xa2, 0x6e, 0x27, 0x45, 0x2d, 0x6d, 0x65, 0x03,
+ 0xc8, 0x41, 0x43, 0xe7, 0xba, 0x1e, 0xfa, 0x8c, 0xaa, 0xc1, 0x61, 0x0c,
+ 0x79, 0x31, 0x3d, 0x91, 0x87, 0x18, 0xd4, 0xdb, 0x48, 0xfa, 0xa9, 0x74,
+ 0x53, 0xd5, 0xba, 0xce, 0x36, 0x31, 0x64, 0xad, 0xb8, 0x61, 0x0a, 0xb7,
+ 0x15, 0xd4, 0xce, 0x7c, 0xa6, 0xc7, 0x1e, 0xf0, 0xba, 0x04, 0xc2, 0xd9,
+ 0x6c, 0x14, 0xb4, 0x62, 0x4a, 0x60, 0xe0, 0x4a, 0xb7, 0x96, 0x80, 0x94,
+ 0x32, 0x0b, 0x51, 0x05, 0xca, 0x2f, 0x8a, 0xe2, 0x59, 0x89, 0xdf, 0x25,
+ 0xf0, 0x41, 0xc0, 0xd0, 0x05, 0x53, 0x55, 0xb5, 0x95, 0xac, 0x78, 0x0d,
+ 0x5e, 0xa1, 0x70, 0x49, 0x79, 0x46, 0xfd, 0xe1, 0xee, 0x18, 0x4b, 0x65,
+ 0xeb, 0x30, 0x54, 0x31, 0x58, 0x72, 0x2c, 0x64, 0x26, 0xfb, 0x0f, 0x53,
+ 0x6e, 0xcf, 0x5c, 0x1d, 0xb3, 0x06, 0x43, 0xb3, 0xe8, 0x14, 0xa3, 0x5a,
+ 0xd0, 0x52, 0x81, 0x22, 0x5b, 0x61, 0x74, 0xe5, 0x4a, 0xb7, 0x3d, 0x72,
+ 0x22, 0xa9, 0x85, 0xe8, 0xea, 0x2d, 0xb1, 0x86, 0x2d, 0x84, 0x8e, 0x41,
+ 0x79, 0x65, 0x80, 0xb1, 0xc2, 0xef, 0x5e, 0xa8, 0x42, 0x41, 0x3e, 0x6a,
+ 0x50, 0x02, 0xc7, 0x3a, 0x2a, 0x8f, 0xd3, 0x20, 0xfd, 0x36, 0x56, 0x80,
+ 0x30, 0x4a, 0x1c, 0x73, 0x28, 0x8a, 0x75, 0x34, 0x70, 0x21, 0xaa, 0x26,
+ 0x80, 0xbe, 0xd4, 0x56, 0x24, 0x42, 0xe8, 0x96, 0x63, 0x83, 0x96, 0x9b,
+ 0x9d, 0x43, 0x53, 0x7c, 0x4c, 0x84, 0x38, 0x27, 0x42, 0xac, 0x1c, 0xb9,
+ 0xd8, 0x8c, 0x11, 0xd7, 0x74, 0xfd, 0x60, 0xa7, 0xe6, 0x33, 0xce, 0x24,
+ 0x2e, 0x42, 0x25, 0xcf, 0xaa, 0x44, 0x8f, 0x1e, 0x38, 0x42, 0xd5, 0x30,
+ 0x76, 0xb2, 0x99, 0x71, 0x00, 0x56, 0xba, 0xc6, 0xb6, 0xc6, 0x16, 0xed,
+ 0x76, 0xf1, 0xf0, 0x89, 0x91, 0xc5, 0xd7, 0x2e, 0xf6, 0x93, 0x86, 0x59,
+ 0xca, 0xe4, 0x80, 0x6a, 0x13, 0x67, 0xaa, 0xd1, 0x31, 0x66, 0xe4, 0x30,
+ 0xef, 0x8c, 0xa0, 0xab, 0x0d, 0x88, 0xd3, 0xba, 0x72, 0xa1, 0x41, 0xd3,
+ 0xe6, 0x03, 0x8d, 0x4e, 0xf1, 0x50, 0x11, 0xd8, 0x0e, 0x60, 0xf6, 0x3c,
+ 0x35, 0xc0, 0xd8, 0x43, 0xbd, 0xe8, 0xc4, 0x3e, 0x99, 0x87, 0x2c, 0x2d,
+ 0x26, 0x1d, 0x65, 0xd7, 0x3c, 0x91, 0x8e, 0x05, 0xb3, 0x1f, 0x8d, 0x7b,
+ 0xc0, 0xc2, 0xbb, 0x96, 0xaa, 0x2e, 0x40, 0xb8, 0x8d, 0xd6, 0xc6, 0x5d,
+ 0x81, 0x8d, 0x33, 0xdc, 0xff, 0xf3, 0x9d, 0xa6, 0x5d, 0x85, 0x86, 0xcb,
+ 0xb1, 0x2f, 0x94, 0x48, 0x9a, 0xde, 0x23, 0x68, 0xd2, 0x5d, 0x93, 0x6a,
+ 0x75, 0x03, 0x8c, 0x3d, 0x2c, 0x3a, 0x17, 0xbb, 0x00, 0x59, 0x00, 0xf8,
+ 0xc7, 0x15, 0x03, 0x72, 0x29, 0x8d, 0x8e, 0x45, 0x93, 0xc3, 0x0b, 0xae,
+ 0xa1, 0x23, 0x17, 0x8c, 0x53, 0x22, 0x44, 0xa0, 0x2c, 0x9d, 0x18, 0x66,
+ 0xde, 0x4f, 0x18, 0xe0, 0xdc, 0x41, 0x85, 0x3f, 0xde, 0xc3, 0xfc, 0x24,
+ 0x89, 0x5a, 0xc7, 0x70, 0x04, 0x1d, 0xd7, 0x06, 0x60, 0x74, 0x96, 0x9d,
+ 0x64, 0xdb, 0x11, 0x22, 0x98, 0x9f, 0xf6, 0x33, 0xc8, 0xd1, 0xa9, 0x3d,
+ 0xf6, 0x5e, 0x74, 0xc9, 0x37, 0x55, 0x02, 0xd7, 0x43, 0x47, 0xdb, 0x23,
+ 0x71, 0xff, 0x77, 0xba, 0x83, 0x0c, 0x90, 0x05, 0xaa, 0x2a, 0xae, 0x69,
+ 0x67, 0xdf, 0x89, 0x1e, 0xb8, 0x70, 0x04, 0x44, 0x04, 0xf7, 0xed, 0x45,
+ 0x4e, 0x8f, 0x0f, 0xa7, 0xc9, 0xbb, 0xb5, 0x18, 0xab, 0x37, 0xa2, 0xdf,
+ 0x7a, 0x0b, 0xa1, 0x1b, 0x15, 0xb0, 0x2f, 0x9d, 0x9f, 0x48, 0x49, 0xe3,
+ 0x57, 0x40, 0x38, 0xda, 0xbf, 0xc7, 0x05, 0xa6, 0xe0, 0xb2, 0x26, 0x09,
+ 0x2b, 0x8b, 0x60, 0xdf, 0x8e, 0x6a, 0xbc, 0xc7, 0x30, 0x80, 0x9b, 0x3d,
+ 0xea, 0xf5, 0xee, 0xd6, 0xa3, 0xa4, 0x12, 0xd0, 0x7c, 0x7b, 0x4e, 0x88,
+ 0xeb, 0x1c, 0xe1, 0x71, 0x21, 0x1d, 0x4b, 0xc8, 0xeb, 0x79, 0x4d, 0x1d,
+ 0x97, 0x0e, 0xee, 0xd7, 0xb9, 0x57, 0x5d, 0x77, 0x70, 0xc0, 0x1e, 0xc3,
+ 0x6c, 0xba, 0x7c, 0x74, 0xf9, 0xd6, 0x6e, 0x9e, 0x50, 0x65, 0xea, 0x4d,
+ 0x49, 0xfd, 0xd8, 0x0d, 0x22, 0xd2, 0x2a, 0xc4, 0x4c, 0x53, 0x5e, 0xd8,
+ 0x5b, 0x96, 0x16, 0xbc, 0xa8, 0x2b, 0x08, 0x47, 0x2b, 0x40, 0xbc, 0x95,
+ 0x0c, 0x12, 0xab, 0x94, 0xa5, 0x78, 0x2d, 0x20, 0x64, 0x25, 0x2f, 0x7e,
+ 0x2c, 0xdd, 0xb8, 0x2a, 0x1d, 0xd5, 0xe6, 0x36, 0x39, 0xc4, 0x18, 0x66,
+ 0x61, 0xe7, 0x91, 0xe4, 0xc4, 0x49, 0x9c, 0x59, 0x80, 0x10, 0xaa, 0xde,
+ 0x75, 0xf5, 0x93, 0x88, 0xf3, 0x4b, 0xec, 0xce, 0x45, 0x5a, 0x9f, 0xf0,
+ 0x01, 0xde, 0x9e, 0xe6, 0xee, 0x9d, 0x02, 0xd2, 0x40, 0xd9, 0xbb, 0x2e,
+ 0xf3, 0xc4, 0x98, 0xed, 0x5d, 0x8c, 0x00, 0x21, 0xba, 0x16, 0xf9, 0x31,
+ 0x36, 0x62, 0x55, 0xd1, 0x60, 0x27, 0x5b, 0x13, 0x28, 0x3b, 0x8c, 0xdb,
+ 0x0d, 0x78, 0xcb, 0x62, 0xfc, 0x46, 0x37, 0xab, 0xee, 0x77, 0x62, 0x0b,
+ 0x9e, 0x0a, 0xab, 0x25, 0xb3, 0xa9, 0x7a, 0xf7, 0x7a, 0xc3, 0x4e, 0x96,
+ 0xe7, 0x25, 0xee, 0xff, 0xe5, 0x5f, 0xb6, 0xd9, 0xb8, 0x95, 0x6b, 0xef,
+ 0xbb, 0x3f, 0x24, 0xc4, 0x78, 0x7d, 0xb3, 0x77, 0x0f, 0x46, 0x6f, 0x40,
+ 0x1a, 0x7d, 0x58, 0x1e, 0x14, 0x07, 0x60, 0xb8, 0xb0, 0x10, 0x0f, 0x8a,
+ 0x43, 0x30, 0x7a, 0xc7, 0x90, 0x8e, 0x98, 0x52, 0xe0, 0x31, 0x5f, 0x83,
+ 0xe4, 0xac, 0x9f, 0xc0, 0xe9, 0x1e, 0x43, 0x9a, 0x21, 0x8f, 0x44, 0x89,
+ 0x2f, 0xa8, 0x96, 0x62, 0x53, 0x57, 0x17, 0x1c, 0xea, 0x5d, 0xb8, 0xf5,
+ 0x5e, 0x92, 0x7b, 0x7e, 0xa3, 0xc2, 0x09, 0xd5, 0x51, 0x50, 0x4e, 0x8f,
+ 0x38, 0x1c, 0x64, 0x17, 0x2e, 0x25, 0x8f, 0x01, 0xee, 0xb7, 0xf6, 0x55,
+ 0xf7, 0x1f, 0x3b, 0x3f, 0x6f, 0x72, 0x8c, 0xf7, 0xa9, 0xd7, 0xc7, 0x6a,
+ 0xcf, 0xef, 0xc4, 0x2a, 0xe2, 0x21, 0x4f, 0x61, 0x1d, 0x1c, 0x10, 0x02,
+ 0xa5, 0x3e, 0xdb, 0xf0, 0x96, 0x03, 0x7e, 0x06, 0x47, 0xbd, 0x5c, 0x57,
+ 0x07, 0xa4, 0x01, 0x4c, 0x88, 0xe1, 0x8e, 0x0f, 0x1f, 0xd2, 0x3d, 0xa5,
+ 0xae, 0x4f, 0xc3, 0x9e, 0x04, 0x20, 0x37, 0x06, 0xcc, 0xa8, 0x40, 0x5c,
+ 0x15, 0x90, 0x06, 0x30, 0x01, 0x01, 0x63, 0x7a, 0x4c, 0xeb, 0x90, 0x31,
+ 0xa2, 0x80, 0xe6, 0x6c, 0xc9, 0xbb, 0x05, 0xa4, 0x05, 0x4e, 0x44, 0xc0,
+ 0x7c, 0x19, 0xf9, 0xd6, 0x56, 0xaf, 0xd6, 0xb8, 0x7b, 0x40, 0x3a, 0xf2,
+ 0x98, 0x10, 0xea, 0x1d, 0x4d, 0x7d, 0xe4, 0x80, 0xaa, 0x65, 0x74, 0x6f,
+ 0xba, 0x19, 0xe7, 0x21, 0x01, 0x91, 0xc4, 0x9c, 0x15, 0xaa, 0x3e, 0xe0,
+ 0x90, 0xfe, 0x79, 0xa5, 0x71, 0x73, 0xf5, 0xc1, 0x64, 0xf5, 0x1b, 0x73,
+ 0x8e, 0xa8, 0x76, 0x6c, 0x95, 0x53, 0x7e, 0xd6, 0x9b, 0x00, 0xe4, 0x91,
+ 0x64, 0xe6, 0x87, 0x60, 0x5a, 0xf2, 0x2f, 0x9c, 0x70, 0x4f, 0xee, 0xb5,
+ 0xb0, 0xbd, 0x03, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
+ 0x42, 0x60, 0x82,
+}
diff --git a/vendor/github.com/facchinm/systray/example/icon/iconwin.go b/vendor/github.com/facchinm/systray/example/icon/iconwin.go
new file mode 100644
index 000000000..4fdfdb4bb
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/example/icon/iconwin.go
@@ -0,0 +1,3908 @@
+//+build windows
+
+// File generated by 2goarray v0.1.0 (http://github.com/cratonica/2goarray)
+
+package icon
+
+var Data []byte = []byte{
+ 0x00, 0x00, 0x01, 0x00, 0x03, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,
+ 0x20, 0x00, 0x68, 0x04, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x20, 0x20,
+ 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa8, 0x10, 0x00, 0x00, 0x9e, 0x04,
+ 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0xa8, 0x25,
+ 0x00, 0x00, 0x46, 0x15, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x10, 0x00,
+ 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83,
+ 0x0c, 0x55, 0x86, 0x83, 0x0c, 0x6f, 0x85, 0x83, 0x0c, 0x6d, 0x86, 0x83,
+ 0x0c, 0x4f, 0x86, 0x83, 0x0b, 0x11, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x1d, 0x86, 0x83, 0x0c, 0xa5, 0x86, 0x83,
+ 0x0b, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf3, 0x86, 0x83,
+ 0x0c, 0x93, 0x86, 0x83, 0x0c, 0x15, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x3b, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83,
+ 0x0c, 0x23, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0x11, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0xa7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf3, 0x86, 0x83,
+ 0x0c, 0xef, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0x89, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x85, 0x83,
+ 0x0b, 0xfb, 0x86, 0x83, 0x0c, 0xcf, 0x85, 0x83, 0x0c, 0x47, 0x86, 0x83,
+ 0x0b, 0x27, 0x86, 0x83, 0x0c, 0x31, 0x86, 0x83, 0x0c, 0x8f, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0b, 0xf3, 0x85, 0x83, 0x0b, 0x7b, 0x86, 0x83,
+ 0x0c, 0x2b, 0x86, 0x83, 0x0c, 0x27, 0x86, 0x83, 0x0c, 0x51, 0x86, 0x83,
+ 0x0c, 0xdf, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83, 0x0c, 0x0d, 0x86, 0x83,
+ 0x0c, 0x61, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0x27, 0x86, 0x83,
+ 0x0c, 0xa3, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83, 0x0b, 0xd1, 0x86, 0x83,
+ 0x0c, 0x47, 0x86, 0x83, 0x0c, 0x71, 0x86, 0x83, 0x0c, 0x5d, 0x86, 0x83,
+ 0x0c, 0x5b, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0c, 0x8f, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83, 0x0c, 0xf9, 0x85, 0x82,
+ 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0x81, 0x86, 0x83, 0x0c, 0xa3, 0x86, 0x83,
+ 0x0b, 0x59, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0x29, 0x86, 0x83,
+ 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xb3, 0x86, 0x83,
+ 0x0c, 0x93, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0x3b, 0x86, 0x83,
+ 0x0c, 0xc5, 0x86, 0x83, 0x0b, 0x61, 0x86, 0x83, 0x0c, 0x81, 0x86, 0x83,
+ 0x0c, 0xa3, 0x86, 0x83, 0x0c, 0x57, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83,
+ 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83, 0x0b, 0xf5, 0x86, 0x83,
+ 0x0c, 0xb3, 0x86, 0x83, 0x0c, 0x93, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xc7, 0x86, 0x83, 0x0b, 0x61, 0x86, 0x83,
+ 0x0c, 0x61, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83, 0x0c, 0x27, 0x86, 0x82,
+ 0x0c, 0xa1, 0x86, 0x83, 0x0b, 0xe5, 0x86, 0x83, 0x0c, 0xcd, 0x86, 0x83,
+ 0x0c, 0x45, 0x86, 0x83, 0x0c, 0x71, 0x86, 0x83, 0x0c, 0x5d, 0x86, 0x83,
+ 0x0c, 0x5b, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83, 0x0c, 0xe3, 0x86, 0x83,
+ 0x0c, 0x89, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83, 0x0c, 0xf9, 0x85, 0x82,
+ 0x0c, 0x3f, 0x86, 0x83, 0x0b, 0x1d, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0c, 0xd1, 0x85, 0x83, 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x27, 0x86, 0x83,
+ 0x0c, 0x33, 0x86, 0x83, 0x0c, 0x93, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83,
+ 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0x7f, 0x86, 0x83, 0x0c, 0x2d, 0x85, 0x83,
+ 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x55, 0x86, 0x83, 0x0c, 0xdf, 0x86, 0x83,
+ 0x0c, 0xed, 0x86, 0x83, 0x0c, 0x0d, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82,
+ 0x0c, 0xa7, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xfd, 0x86, 0x83,
+ 0x0c, 0xef, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf5, 0x86, 0x83, 0x0b, 0xef, 0x85, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x89, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83, 0x0c, 0x11, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0x23, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0x9d, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf3, 0x86, 0x83, 0x0b, 0x91, 0x86, 0x83, 0x0c, 0x11, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x17, 0x86, 0x83,
+ 0x0c, 0x53, 0x86, 0x83, 0x0c, 0x6f, 0x86, 0x83, 0x0c, 0x6d, 0x86, 0x83,
+ 0x0c, 0x4b, 0x86, 0x83, 0x0c, 0x0f, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x28, 0x00, 0x00, 0x00, 0x20, 0x00,
+ 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x80, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x17, 0x86, 0x83,
+ 0x0c, 0x17, 0x86, 0x83, 0x0c, 0x17, 0x86, 0x83, 0x0c, 0x15, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0c, 0x8d, 0x86, 0x83,
+ 0x0c, 0xb9, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83,
+ 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xc3, 0x86, 0x83, 0x0c, 0xb3, 0x86, 0x83,
+ 0x0c, 0x83, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x82,
+ 0x0c, 0x2d, 0x86, 0x83, 0x0c, 0x8d, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xd3, 0x86, 0x83, 0x0c, 0x6f, 0x86, 0x83,
+ 0x0c, 0x1d, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x69, 0x86, 0x83, 0x0c, 0xd9, 0x85, 0x82,
+ 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83,
+ 0x0c, 0x47, 0x86, 0x82, 0x0b, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83, 0x0c, 0xa7, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83,
+ 0x0c, 0x7b, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xf3, 0x86, 0x83,
+ 0x0b, 0x7b, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0xa7, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xf3, 0x86, 0x83,
+ 0x0c, 0x77, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x71, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83,
+ 0x0c, 0x3f, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0b, 0x33, 0x86, 0x83, 0x0c, 0xdd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb9, 0x85, 0x82,
+ 0x0b, 0x13, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x91, 0x85, 0x82,
+ 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf3, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83,
+ 0x0b, 0xdb, 0x86, 0x83, 0x0b, 0xe5, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83,
+ 0x0c, 0xdf, 0x86, 0x83, 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xe3, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf3, 0x86, 0x83, 0x0b, 0x5f, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x15, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xab, 0x86, 0x83,
+ 0x0c, 0x5b, 0x86, 0x83, 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83,
+ 0x0c, 0x37, 0x86, 0x83, 0x0c, 0x69, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83,
+ 0x0c, 0xa1, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0x2d, 0x86, 0x83,
+ 0x0c, 0x1f, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83, 0x0c, 0x69, 0x86, 0x83,
+ 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xbf, 0x86, 0x83, 0x0c, 0x07, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x5f, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe3, 0x86, 0x83,
+ 0x0c, 0x61, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83,
+ 0x0c, 0x23, 0x86, 0x83, 0x0c, 0x2b, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x73, 0x86, 0x83,
+ 0x0c, 0xe7, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xd3, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83, 0x0c, 0x2b, 0x86, 0x83,
+ 0x0c, 0x1b, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x11, 0x86, 0x83,
+ 0x0c, 0x8d, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0x29, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0xa5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0x67, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x25, 0x86, 0x83, 0x0c, 0x99, 0x86, 0x83, 0x0c, 0xcf, 0x86, 0x83,
+ 0x0c, 0xdf, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0x85, 0x86, 0x83,
+ 0x0c, 0x1d, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xe9, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83,
+ 0x0c, 0x03, 0x85, 0x83, 0x0b, 0x2d, 0x86, 0x82, 0x0b, 0x97, 0x86, 0x83,
+ 0x0c, 0xcb, 0x86, 0x83, 0x0c, 0xdd, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0x7d, 0x86, 0x83, 0x0c, 0x13, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83,
+ 0x0c, 0x9f, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0x63, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83,
+ 0x0c, 0xc7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb3, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x29, 0x86, 0x83, 0x0b, 0xd3, 0x86, 0x83,
+ 0x0b, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xcd, 0x85, 0x83,
+ 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x6f, 0x86, 0x83,
+ 0x0c, 0x4b, 0x86, 0x83, 0x0b, 0x05, 0x86, 0x83, 0x0c, 0x53, 0x86, 0x83,
+ 0x0c, 0xe9, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x82, 0x0c, 0xf9, 0x86, 0x83,
+ 0x0b, 0xf3, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0c, 0xad, 0x86, 0x83, 0x0c, 0x11, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83,
+ 0x0c, 0xe7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x99, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x29, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x63, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x8d, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb5, 0x86, 0x83,
+ 0x0c, 0x1b, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0b, 0x35, 0x86, 0x83, 0x0c, 0xdd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x89, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0x51, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0xa5, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xb1, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x2d, 0x86, 0x83, 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83,
+ 0x0b, 0x3b, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83, 0x0c, 0xcb, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xd7, 0x85, 0x82, 0x0c, 0x83, 0x85, 0x82,
+ 0x0c, 0x83, 0x85, 0x82, 0x0c, 0x83, 0x86, 0x83, 0x0c, 0xdf, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0x81, 0x85, 0x83,
+ 0x0b, 0x03, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0b, 0xc1, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb7, 0x86, 0x83,
+ 0x0c, 0x57, 0x86, 0x83, 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x93, 0x86, 0x83,
+ 0x0b, 0xef, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x95, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x6f, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x13, 0x86, 0x83, 0x0c, 0x2d, 0x86, 0x83,
+ 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83, 0x0b, 0x3b, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0xcb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xd7, 0x85, 0x82, 0x0c, 0x83, 0x85, 0x82, 0x0c, 0x83, 0x85, 0x82,
+ 0x0c, 0x83, 0x86, 0x83, 0x0c, 0xdf, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0x81, 0x85, 0x83, 0x0b, 0x03, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0b, 0xc1, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb7, 0x86, 0x83, 0x0c, 0x57, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x93, 0x86, 0x83, 0x0b, 0xef, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0x95, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x6f, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0x13, 0x86, 0x83, 0x0c, 0x29, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x63, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x89, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb5, 0x86, 0x83,
+ 0x0c, 0x1b, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x33, 0x86, 0x83, 0x0c, 0xdb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x89, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0x4b, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0xab, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xb1, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x19, 0x86, 0x83, 0x0c, 0xc7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x25, 0x86, 0x83,
+ 0x0b, 0xd3, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0c, 0xcd, 0x85, 0x83, 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x6f, 0x86, 0x83, 0x0c, 0x4b, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x51, 0x86, 0x83, 0x0c, 0xe9, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x82,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0b, 0xf3, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xa3, 0x86, 0x83, 0x0c, 0x11, 0x86, 0x83,
+ 0x0c, 0x21, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0x99, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x82,
+ 0x0b, 0xa1, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83,
+ 0x0c, 0x6b, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x25, 0x85, 0x82,
+ 0x0c, 0x8f, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x7d, 0x86, 0x83, 0x0c, 0x15, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xe9, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0x03, 0x85, 0x83,
+ 0x0b, 0x2d, 0x86, 0x82, 0x0b, 0x97, 0x86, 0x83, 0x0c, 0xc7, 0x86, 0x83,
+ 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x7b, 0x86, 0x83,
+ 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x9f, 0x86, 0x83,
+ 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x63, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x5b, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x82,
+ 0x0b, 0x61, 0x86, 0x83, 0x0b, 0x0d, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83,
+ 0x0c, 0x1d, 0x86, 0x83, 0x0c, 0x25, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x7d, 0x86, 0x83,
+ 0x0c, 0xeb, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0x57, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x82, 0x0c, 0x29, 0x86, 0x83,
+ 0x0c, 0x1b, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x17, 0x86, 0x83,
+ 0x0c, 0x8f, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0x29, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x15, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83,
+ 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0x5f, 0x86, 0x83, 0x0b, 0x33, 0x85, 0x83,
+ 0x0c, 0x25, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0x6d, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xa1, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83,
+ 0x0b, 0x35, 0x86, 0x83, 0x0c, 0x23, 0x86, 0x83, 0x0c, 0x3d, 0x86, 0x83,
+ 0x0c, 0x6d, 0x86, 0x83, 0x0c, 0xcd, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xbf, 0x86, 0x83,
+ 0x0c, 0x07, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x91, 0x85, 0x82, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0b, 0xdb, 0x86, 0x83,
+ 0x0c, 0xe7, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83, 0x0b, 0xe3, 0x86, 0x83,
+ 0x0b, 0xdb, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf3, 0x86, 0x83, 0x0b, 0x5f, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x31, 0x86, 0x83, 0x0c, 0xdb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb9, 0x85, 0x82,
+ 0x0b, 0x13, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x6f, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xef, 0x86, 0x83, 0x0c, 0x3f, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0c, 0xa7, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xf3, 0x86, 0x83, 0x0c, 0x73, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xf3, 0x86, 0x83,
+ 0x0b, 0x7b, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1b, 0x86, 0x83,
+ 0x0c, 0x9f, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf1, 0x86, 0x83, 0x0c, 0x77, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0c, 0x67, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xc3, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x27, 0x86, 0x83, 0x0c, 0x7f, 0x86, 0x83, 0x0b, 0xe1, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfd, 0x86, 0x82, 0x0b, 0xcd, 0x86, 0x83, 0x0c, 0x6d, 0x86, 0x83,
+ 0x0c, 0x1b, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83,
+ 0x0c, 0x8d, 0x86, 0x83, 0x0c, 0xb5, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83,
+ 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0b, 0xb1, 0x86, 0x83, 0x0b, 0x77, 0x86, 0x83, 0x0c, 0x35, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x17, 0x86, 0x83, 0x0c, 0x17, 0x86, 0x83,
+ 0x0c, 0x17, 0x86, 0x83, 0x0c, 0x13, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00,
+ 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x01, 0x00,
+ 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x25, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x85, 0x82, 0x0b, 0x03, 0x86, 0x82, 0x0c, 0x03, 0x85, 0x82,
+ 0x0b, 0x03, 0x85, 0x82, 0x0b, 0x03, 0x86, 0x82, 0x0c, 0x03, 0x85, 0x82,
+ 0x0b, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x09, 0x85, 0x82, 0x0b, 0x11, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83,
+ 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x82,
+ 0x0c, 0x41, 0x86, 0x83, 0x0b, 0x1f, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x11, 0x85, 0x83, 0x0c, 0x39, 0x86, 0x83,
+ 0x0c, 0x81, 0x86, 0x83, 0x0c, 0xbf, 0x86, 0x83, 0x0b, 0xef, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0x5f, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83,
+ 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0x07, 0x85, 0x83, 0x0c, 0x23, 0x86, 0x82,
+ 0x0c, 0x6b, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83,
+ 0x0c, 0xa9, 0x86, 0x83, 0x0c, 0x43, 0x85, 0x83, 0x0c, 0x13, 0x86, 0x82,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0b, 0x03, 0x86, 0x83,
+ 0x0c, 0x19, 0x86, 0x82, 0x0c, 0x5d, 0x86, 0x83, 0x0c, 0xd7, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xf7, 0x85, 0x83, 0x0b, 0xab, 0x85, 0x83,
+ 0x0c, 0x41, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x82, 0x0c, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x35, 0x86, 0x82,
+ 0x0b, 0xab, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0x7b, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x0f, 0x86, 0x83, 0x0b, 0x53, 0x85, 0x82, 0x0b, 0xe1, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xab, 0x86, 0x83,
+ 0x0c, 0x31, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x15, 0x86, 0x83,
+ 0x0b, 0x6f, 0x86, 0x83, 0x0c, 0xf5, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x83, 0x0b, 0x37, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x6f, 0x86, 0x83,
+ 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83, 0x0b, 0x37, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x53, 0x85, 0x83, 0x0c, 0xf5, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0b, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0b, 0x05, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xa1, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83,
+ 0x0b, 0xb7, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0c, 0x6d, 0x86, 0x82, 0x0b, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x73, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xe1, 0x86, 0x83, 0x0b, 0x2f, 0x86, 0x83,
+ 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82,
+ 0x0b, 0x03, 0x86, 0x82, 0x0c, 0x23, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0x91, 0x86, 0x83,
+ 0x0c, 0x0b, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x07, 0x85, 0x82, 0x0b, 0x75, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xfb, 0x86, 0x83,
+ 0x0c, 0xe7, 0x86, 0x83, 0x0b, 0xd5, 0x86, 0x83, 0x0c, 0xc9, 0x86, 0x83,
+ 0x0b, 0xc7, 0x86, 0x83, 0x0c, 0xd3, 0x86, 0x83, 0x0b, 0xe5, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83, 0x0b, 0xdd, 0x86, 0x83,
+ 0x0c, 0xcb, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0xcb, 0x85, 0x83,
+ 0x0c, 0xd9, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xed, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x17, 0x85, 0x82, 0x0b, 0xd9, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0xab, 0x86, 0x83,
+ 0x0c, 0x77, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0c, 0x33, 0x86, 0x83,
+ 0x0c, 0x33, 0x86, 0x83, 0x0c, 0x4d, 0x86, 0x83, 0x0c, 0x71, 0x86, 0x83,
+ 0x0b, 0xa1, 0x85, 0x83, 0x0c, 0xd1, 0x85, 0x83, 0x0c, 0xf3, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0b, 0xe5, 0x86, 0x83,
+ 0x0c, 0xbf, 0x86, 0x83, 0x0c, 0x8d, 0x86, 0x82, 0x0c, 0x63, 0x86, 0x83,
+ 0x0c, 0x3b, 0x86, 0x83, 0x0c, 0x2d, 0x86, 0x83, 0x0c, 0x3b, 0x86, 0x83,
+ 0x0b, 0x59, 0x86, 0x82, 0x0b, 0x8b, 0x86, 0x83, 0x0b, 0xb7, 0x86, 0x83,
+ 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0xfd, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0x8b, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x49, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83,
+ 0x0c, 0xb3, 0x86, 0x82, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0x11, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x11, 0x85, 0x83, 0x0b, 0x4b, 0x86, 0x83, 0x0c, 0x9d, 0x86, 0x83,
+ 0x0c, 0xdd, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0b, 0xc7, 0x86, 0x83, 0x0b, 0x77, 0x86, 0x83,
+ 0x0c, 0x27, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x21, 0x86, 0x82,
+ 0x0b, 0x7d, 0x85, 0x83, 0x0b, 0xd1, 0x85, 0x83, 0x0b, 0xf9, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xd9, 0x86, 0x82, 0x0c, 0x19, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83,
+ 0x0c, 0x9b, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xef, 0x86, 0x83, 0x0b, 0x97, 0x86, 0x83,
+ 0x0c, 0x2b, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x13, 0x86, 0x83, 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x82,
+ 0x0c, 0x41, 0x86, 0x83, 0x0c, 0x2d, 0x86, 0x83, 0x0b, 0x1b, 0x86, 0x83,
+ 0x0b, 0x05, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83,
+ 0x0c, 0x6d, 0x85, 0x83, 0x0c, 0xcf, 0x86, 0x83, 0x0c, 0xfd, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xef, 0x85, 0x83,
+ 0x0c, 0xb1, 0x86, 0x82, 0x0c, 0x47, 0x85, 0x83, 0x0b, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x09, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83,
+ 0x0b, 0x33, 0x86, 0x83, 0x0c, 0x43, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x82,
+ 0x0c, 0x23, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x53, 0x86, 0x83, 0x0c, 0xc9, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x45, 0x86, 0x82, 0x0b, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83,
+ 0x0b, 0xe5, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xa9, 0x86, 0x83, 0x0c, 0x19, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x41, 0x85, 0x83,
+ 0x0c, 0x83, 0x86, 0x83, 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0xcb, 0x86, 0x83,
+ 0x0b, 0xcd, 0x86, 0x83, 0x0b, 0xab, 0x86, 0x83, 0x0c, 0x8b, 0x86, 0x83,
+ 0x0c, 0x53, 0x86, 0x83, 0x0c, 0x1b, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x5b, 0x86, 0x83, 0x0b, 0xcd, 0x86, 0x83,
+ 0x0c, 0xfd, 0x85, 0x83, 0x0b, 0xf5, 0x86, 0x83, 0x0b, 0xad, 0x85, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0b, 0x05, 0x85, 0x83, 0x0b, 0x05, 0x86, 0x83,
+ 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83, 0x0b, 0x97, 0x86, 0x83,
+ 0x0b, 0xb5, 0x86, 0x83, 0x0c, 0xd1, 0x86, 0x83, 0x0c, 0xbd, 0x86, 0x83,
+ 0x0c, 0x9d, 0x86, 0x82, 0x0b, 0x67, 0x85, 0x83, 0x0c, 0x27, 0x86, 0x83,
+ 0x0c, 0x07, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x53, 0x86, 0x83,
+ 0x0b, 0xd9, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x81, 0x85, 0x82, 0x0b, 0x05, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x25, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xfd, 0x86, 0x83,
+ 0x0c, 0xd1, 0x86, 0x83, 0x0b, 0x39, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0xc5, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xdb, 0x86, 0x82, 0x0b, 0x83, 0x86, 0x83, 0x0c, 0x27, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x65, 0x86, 0x83,
+ 0x0c, 0xd7, 0x86, 0x83, 0x0c, 0xbd, 0x86, 0x83, 0x0c, 0x43, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x45, 0x86, 0x82,
+ 0x0b, 0xa1, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83, 0x0b, 0xa3, 0x85, 0x83,
+ 0x0c, 0x33, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0b, 0x81, 0x86, 0x83, 0x0c, 0xf3, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb9, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x55, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xf5, 0x85, 0x83,
+ 0x0b, 0x85, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83,
+ 0x0c, 0x47, 0x86, 0x83, 0x0c, 0xd5, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xeb, 0x85, 0x83, 0x0c, 0x93, 0x85, 0x83,
+ 0x0b, 0x29, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1b, 0x86, 0x83,
+ 0x0c, 0x67, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0b, 0x51, 0x86, 0x82, 0x0c, 0xc3, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xf1, 0x86, 0x83, 0x0c, 0xeb, 0x85, 0x83, 0x0b, 0xf9, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xa3, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x21, 0x85, 0x83, 0x0b, 0xd3, 0x85, 0x83, 0x0c, 0xfd, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xe7, 0x85, 0x82, 0x0c, 0x0b, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x03, 0x86, 0x83, 0x0c, 0x75, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83,
+ 0x0c, 0x35, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x82,
+ 0x0b, 0xa7, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe9, 0x86, 0x82,
+ 0x0c, 0x8b, 0x86, 0x83, 0x0c, 0x1d, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0xbd, 0x86, 0x82, 0x0b, 0xfb, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xb5, 0x85, 0x82, 0x0c, 0x91, 0x86, 0x83, 0x0c, 0xdf, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0x5f, 0x86, 0x83, 0x0c, 0x0b, 0xff, 0xff,
+ 0xff, 0x01, 0x85, 0x82, 0x0b, 0x91, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x0b, 0xff, 0xff,
+ 0xff, 0x01, 0x85, 0x82, 0x0b, 0x03, 0x86, 0x83, 0x0c, 0x87, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xd9, 0x86, 0x83,
+ 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82, 0x0c, 0x27, 0x86, 0x83,
+ 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xf3, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83,
+ 0x0c, 0xe1, 0x86, 0x83, 0x0b, 0xe1, 0x86, 0x83, 0x0b, 0xe9, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xdb, 0x86, 0x83, 0x0c, 0x67, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x82,
+ 0x0c, 0x9b, 0x86, 0x83, 0x0c, 0xf5, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xf1, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0c, 0x71, 0x86, 0x83, 0x0b, 0x39, 0x85, 0x83, 0x0b, 0xb1, 0x86, 0x82,
+ 0x0b, 0xe7, 0x86, 0x83, 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xa3, 0x85, 0x83, 0x0c, 0x19, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0c, 0xef, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0x21, 0xff, 0xff,
+ 0xff, 0x01, 0x85, 0x82, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x87, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xbd, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x45, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xf7, 0x86, 0x83,
+ 0x0b, 0xbd, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83,
+ 0x0c, 0x63, 0x86, 0x83, 0x0c, 0x63, 0x85, 0x82, 0x0b, 0x8d, 0x86, 0x83,
+ 0x0c, 0xe7, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0b, 0xfb, 0x86, 0x83, 0x0c, 0xad, 0x86, 0x82, 0x0b, 0x2b, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x5d, 0x86, 0x83,
+ 0x0c, 0xdb, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xb5, 0x86, 0x83, 0x0c, 0x71, 0x85, 0x83,
+ 0x0c, 0x31, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83, 0x0c, 0x4d, 0x86, 0x83,
+ 0x0c, 0x7f, 0x86, 0x83, 0x0c, 0xe3, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0x1f, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0x41, 0x86, 0x83,
+ 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x87, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x82, 0x0b, 0xbd, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x45, 0x85, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xf7, 0x86, 0x83,
+ 0x0b, 0xbd, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83,
+ 0x0c, 0x63, 0x86, 0x83, 0x0c, 0x63, 0x85, 0x82, 0x0c, 0x8d, 0x86, 0x83,
+ 0x0c, 0xe7, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x86, 0x83, 0x0c, 0xad, 0x86, 0x83, 0x0b, 0x2b, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0b, 0x5d, 0x86, 0x83,
+ 0x0c, 0xdb, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xb5, 0x86, 0x83, 0x0c, 0x71, 0x85, 0x83,
+ 0x0c, 0x31, 0x86, 0x83, 0x0c, 0x19, 0x86, 0x83, 0x0c, 0x4d, 0x86, 0x83,
+ 0x0c, 0x7f, 0x86, 0x83, 0x0c, 0xe3, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc5, 0x86, 0x83, 0x0c, 0x1f, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0x41, 0x86, 0x83,
+ 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x87, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xfd, 0x86, 0x83, 0x0c, 0xd9, 0x86, 0x83,
+ 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82, 0x0c, 0x27, 0x86, 0x83,
+ 0x0c, 0xeb, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xf3, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0c, 0xe1, 0x85, 0x82,
+ 0x0b, 0xe1, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0b, 0xe9, 0x86, 0x83,
+ 0x0c, 0xfb, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xdb, 0x86, 0x83, 0x0c, 0x67, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x21, 0x86, 0x82,
+ 0x0b, 0x9b, 0x86, 0x83, 0x0c, 0xf5, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xf1, 0x85, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0b, 0x71, 0x86, 0x83, 0x0c, 0x39, 0x85, 0x83, 0x0b, 0xb1, 0x86, 0x83,
+ 0x0c, 0xe7, 0x86, 0x83, 0x0c, 0xf9, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0x9d, 0x86, 0x83, 0x0c, 0x17, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x57, 0x86, 0x83, 0x0c, 0xef, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x21, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x03, 0x86, 0x83, 0x0c, 0x75, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xeb, 0x86, 0x83,
+ 0x0c, 0x35, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82, 0x0c, 0x17, 0x86, 0x82,
+ 0x0c, 0x9f, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xe9, 0x86, 0x83,
+ 0x0c, 0x8b, 0x86, 0x83, 0x0c, 0x1d, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0b, 0xb9, 0x86, 0x82, 0x0c, 0xfb, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xb5, 0x85, 0x82, 0x0c, 0x91, 0x86, 0x83, 0x0c, 0xdf, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x99, 0x86, 0x83, 0x0b, 0xf7, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x0b, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x82, 0x0c, 0x03, 0x86, 0x82, 0x0c, 0x55, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf7, 0x86, 0x82,
+ 0x0b, 0x95, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0b, 0x07, 0x86, 0x83,
+ 0x0b, 0x41, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xeb, 0x85, 0x82, 0x0b, 0x93, 0x85, 0x83,
+ 0x0b, 0x29, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1b, 0x86, 0x83,
+ 0x0c, 0x67, 0x86, 0x83, 0x0c, 0x4f, 0x86, 0x83, 0x0b, 0x05, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0b, 0x4f, 0x85, 0x82, 0x0c, 0xc3, 0x86, 0x83,
+ 0x0c, 0xf9, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xf1, 0x86, 0x83, 0x0c, 0xeb, 0x85, 0x83, 0x0b, 0xf9, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xf9, 0x86, 0x83,
+ 0x0c, 0x9b, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x21, 0x85, 0x83, 0x0b, 0xd3, 0x85, 0x83, 0x0c, 0xfd, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe7, 0x85, 0x82, 0x0c, 0x0b, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x25, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xdd, 0x86, 0x83, 0x0c, 0x39, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x0d, 0x86, 0x83, 0x0b, 0x59, 0x86, 0x83, 0x0c, 0xc3, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xd3, 0x86, 0x83, 0x0c, 0x77, 0x86, 0x83, 0x0c, 0x27, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x69, 0x85, 0x83,
+ 0x0b, 0xdb, 0x85, 0x83, 0x0c, 0xbd, 0x86, 0x82, 0x0c, 0x43, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x45, 0x85, 0x82,
+ 0x0c, 0xa1, 0x86, 0x83, 0x0c, 0xeb, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83, 0x0c, 0x99, 0x86, 0x82,
+ 0x0c, 0x2b, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0b, 0x81, 0x86, 0x83, 0x0c, 0xf3, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xb9, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x09, 0x86, 0x83,
+ 0x0b, 0xdb, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x83, 0x0c, 0xaf, 0x86, 0x83, 0x0c, 0x19, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83,
+ 0x0b, 0x75, 0x85, 0x83, 0x0c, 0xa3, 0x86, 0x82, 0x0c, 0xb7, 0x86, 0x83,
+ 0x0c, 0xbf, 0x86, 0x83, 0x0c, 0xa9, 0x86, 0x83, 0x0c, 0x81, 0x85, 0x83,
+ 0x0c, 0x47, 0x86, 0x83, 0x0c, 0x13, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x0d, 0x86, 0x83, 0x0c, 0x5b, 0x86, 0x83, 0x0b, 0xd1, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xf5, 0x86, 0x83, 0x0c, 0xb7, 0x86, 0x83,
+ 0x0c, 0x43, 0x86, 0x83, 0x0b, 0x05, 0x85, 0x83, 0x0b, 0x05, 0x86, 0x83,
+ 0x0c, 0x29, 0x86, 0x83, 0x0c, 0x63, 0x86, 0x83, 0x0b, 0x97, 0x85, 0x83,
+ 0x0c, 0xaf, 0x86, 0x83, 0x0b, 0xc7, 0x86, 0x83, 0x0b, 0xbb, 0x85, 0x83,
+ 0x0c, 0x9d, 0x86, 0x82, 0x0b, 0x67, 0x85, 0x83, 0x0b, 0x23, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x53, 0x85, 0x83,
+ 0x0b, 0xd9, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x83, 0x0c, 0x81, 0x85, 0x82, 0x0b, 0x05, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83,
+ 0x0c, 0x95, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf3, 0x86, 0x83, 0x0b, 0x97, 0x86, 0x83,
+ 0x0c, 0x2b, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x0f, 0x86, 0x83, 0x0c, 0x27, 0x86, 0x83, 0x0b, 0x33, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0x2b, 0x85, 0x82, 0x0b, 0x15, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0x75, 0x86, 0x83, 0x0b, 0xd3, 0x86, 0x83, 0x0c, 0xfd, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xf7, 0x86, 0x83,
+ 0x0b, 0xb7, 0x86, 0x83, 0x0c, 0x4d, 0x85, 0x82, 0x0c, 0x0d, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x09, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x83,
+ 0x0b, 0x2f, 0x86, 0x83, 0x0c, 0x3d, 0x85, 0x83, 0x0c, 0x35, 0x86, 0x82,
+ 0x0c, 0x23, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x09, 0x86, 0x83, 0x0c, 0x55, 0x86, 0x83, 0x0c, 0xc9, 0x85, 0x82,
+ 0x0b, 0xfb, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0x45, 0x86, 0x82, 0x0b, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x49, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xf1, 0x86, 0x83,
+ 0x0c, 0xb5, 0x86, 0x82, 0x0b, 0x61, 0x86, 0x83, 0x0c, 0x11, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83,
+ 0x0c, 0x11, 0x86, 0x83, 0x0c, 0x4b, 0x86, 0x83, 0x0c, 0x9f, 0x86, 0x83,
+ 0x0c, 0xe3, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xf7, 0x86, 0x83, 0x0c, 0xcf, 0x86, 0x83, 0x0c, 0x7d, 0x85, 0x83,
+ 0x0b, 0x27, 0x85, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x31, 0x86, 0x82,
+ 0x0c, 0x87, 0x86, 0x83, 0x0c, 0xd1, 0x85, 0x82, 0x0b, 0xf9, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xd9, 0x86, 0x82, 0x0c, 0x19, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83,
+ 0x0c, 0x17, 0x86, 0x83, 0x0b, 0xd9, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xfb, 0x85, 0x82, 0x0b, 0xdb, 0x86, 0x83, 0x0c, 0xad, 0x86, 0x83,
+ 0x0c, 0x7f, 0x86, 0x83, 0x0c, 0x51, 0x86, 0x83, 0x0c, 0x3b, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0x5b, 0x85, 0x82, 0x0c, 0x75, 0x86, 0x82,
+ 0x0b, 0xa7, 0x86, 0x83, 0x0c, 0xd1, 0x86, 0x82, 0x0c, 0xf3, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xe7, 0x86, 0x83,
+ 0x0b, 0xbf, 0x86, 0x83, 0x0c, 0x8d, 0x86, 0x82, 0x0c, 0x63, 0x86, 0x82,
+ 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x33, 0x86, 0x83, 0x0c, 0x43, 0x86, 0x83,
+ 0x0c, 0x65, 0x85, 0x83, 0x0c, 0x8d, 0x85, 0x83, 0x0b, 0xbf, 0x86, 0x83,
+ 0x0c, 0xed, 0x86, 0x82, 0x0c, 0xfd, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0x8b, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x75, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xfb, 0x86, 0x83,
+ 0x0b, 0xeb, 0x85, 0x82, 0x0b, 0xd5, 0x86, 0x83, 0x0c, 0xcb, 0x86, 0x83,
+ 0x0c, 0xcb, 0x86, 0x83, 0x0c, 0xdb, 0x86, 0x83, 0x0c, 0xe5, 0x86, 0x83,
+ 0x0c, 0xf9, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xef, 0x85, 0x82, 0x0c, 0xdd, 0x86, 0x83,
+ 0x0c, 0xd1, 0x86, 0x83, 0x0b, 0xc7, 0x86, 0x83, 0x0c, 0xcf, 0x86, 0x83,
+ 0x0c, 0xdf, 0x86, 0x83, 0x0b, 0xf1, 0x86, 0x83, 0x0c, 0xfd, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xed, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x03, 0x86, 0x83, 0x0c, 0x23, 0x86, 0x83, 0x0b, 0xd7, 0x85, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0x91, 0x85, 0x82,
+ 0x0c, 0x0b, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x83, 0x0b, 0x69, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0b, 0x2f, 0x85, 0x83,
+ 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0xb7, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0x6d, 0x86, 0x83, 0x0c, 0x09, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x05, 0x86, 0x83,
+ 0x0c, 0x39, 0x86, 0x83, 0x0c, 0xe1, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0x95, 0x86, 0x83, 0x0c, 0x1b, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83,
+ 0x0c, 0x07, 0x85, 0x83, 0x0c, 0x53, 0x86, 0x83, 0x0b, 0xf5, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xc1, 0x86, 0x83,
+ 0x0c, 0x2b, 0x86, 0x82, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x0f, 0x86, 0x83, 0x0b, 0x6f, 0x86, 0x83,
+ 0x0c, 0xf5, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xc1, 0x86, 0x83, 0x0c, 0x37, 0x86, 0x83,
+ 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0b, 0x03, 0x86, 0x83, 0x0c, 0x15, 0x85, 0x83,
+ 0x0c, 0x6b, 0x86, 0x83, 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xc1, 0x86, 0x82, 0x0c, 0x37, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0b, 0x03, 0x85, 0x83,
+ 0x0c, 0x0f, 0x85, 0x82, 0x0b, 0x4f, 0x86, 0x83, 0x0c, 0xd5, 0x86, 0x83,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xa1, 0x86, 0x83,
+ 0x0c, 0x2f, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x83, 0x0c, 0x33, 0x86, 0x83,
+ 0x0c, 0xab, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x86, 0x83,
+ 0x0c, 0xeb, 0x86, 0x83, 0x0c, 0x71, 0x86, 0x83, 0x0c, 0x1d, 0x86, 0x83,
+ 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x85, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x19, 0x86, 0x82, 0x0c, 0x57, 0x86, 0x83, 0x0c, 0xc3, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x83, 0x0b, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83,
+ 0x0b, 0xff, 0x85, 0x82, 0x0c, 0xf7, 0x86, 0x83, 0x0b, 0xab, 0x86, 0x83,
+ 0x0c, 0x37, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x07, 0x86, 0x82, 0x0b, 0x19, 0x86, 0x83,
+ 0x0c, 0x57, 0x86, 0x83, 0x0c, 0xc1, 0x85, 0x83, 0x0c, 0xf7, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xff, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x86, 0x82, 0x0b, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82,
+ 0x0b, 0xff, 0x85, 0x82, 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xed, 0x86, 0x83,
+ 0x0c, 0x9f, 0x86, 0x83, 0x0c, 0x3f, 0x86, 0x83, 0x0c, 0x13, 0x86, 0x83,
+ 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x82,
+ 0x0c, 0x05, 0x86, 0x83, 0x0c, 0x11, 0x86, 0x82, 0x0c, 0x39, 0x86, 0x83,
+ 0x0c, 0x81, 0x86, 0x83, 0x0b, 0xbf, 0x86, 0x83, 0x0b, 0xef, 0x86, 0x83,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0b, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x85, 0x82,
+ 0x0c, 0xff, 0x86, 0x83, 0x0c, 0xff, 0x86, 0x82, 0x0c, 0xdd, 0x86, 0x83,
+ 0x0c, 0xa1, 0x86, 0x83, 0x0c, 0x59, 0x86, 0x83, 0x0c, 0x1f, 0x86, 0x82,
+ 0x0c, 0x0b, 0x86, 0x83, 0x0c, 0x03, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x86, 0x83,
+ 0x0c, 0x05, 0x86, 0x83, 0x0b, 0x09, 0x86, 0x83, 0x0c, 0x0b, 0x86, 0x83,
+ 0x0c, 0x25, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83,
+ 0x0c, 0x49, 0x85, 0x83, 0x0c, 0x49, 0x86, 0x83, 0x0c, 0x49, 0x86, 0x83,
+ 0x0c, 0x37, 0x85, 0x83, 0x0b, 0x19, 0x86, 0x83, 0x0c, 0x09, 0x86, 0x82,
+ 0x0b, 0x07, 0x86, 0x83, 0x0c, 0x05, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x86, 0x83, 0x0c, 0x03, 0x85, 0x82, 0x0b, 0x03, 0x86, 0x83,
+ 0x0c, 0x03, 0x85, 0x82, 0x0c, 0x03, 0x85, 0x82, 0x0b, 0x03, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff,
+ 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff,
+}
+
+var DataHibernate []byte = []byte{
+ 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x64, 0x64, 0x00, 0x00, 0x01, 0x00,
+ 0x18, 0x00, 0x98, 0x7b, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x28, 0x00,
+ 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x01, 0x00,
+ 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e, 0x8e, 0x80, 0x8e,
+ 0x8e, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xe0, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x01, 0xff, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00,
+ 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xfe,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x01, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xf8,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x07, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xf0, 0x00, 0x00, 0x00, 0xfe, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xf0, 0x00,
+ 0x00, 0x00, 0xfe, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x00, 0x0f, 0xe0,
+ 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x03, 0xff, 0xf8, 0x00,
+ 0x00, 0x00, 0xff, 0xfc, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x00,
+ 0x0f, 0xff, 0xfe, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x01, 0xf0, 0x00,
+ 0x00, 0x00, 0xfc, 0x00, 0x1f, 0xff, 0xff, 0x80, 0x00, 0x0f, 0xff, 0xff,
+ 0xc0, 0x01, 0xf0, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xe0,
+ 0x00, 0x3f, 0xff, 0xff, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf8, 0x00,
+ 0xff, 0xff, 0xff, 0xf0, 0x00, 0x7f, 0xff, 0xff, 0xf8, 0x00, 0xf0, 0x00,
+ 0x00, 0x00, 0xf8, 0x01, 0xff, 0xff, 0xff, 0xf8, 0x00, 0xff, 0xff, 0xff,
+ 0xfc, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x03, 0xff, 0x80, 0x3f, 0xfc,
+ 0x01, 0xff, 0xc0, 0x0f, 0xfe, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf0, 0x07,
+ 0xfe, 0x00, 0x07, 0xfe, 0x03, 0xff, 0x00, 0x03, 0xff, 0x00, 0x70, 0x00,
+ 0x00, 0x00, 0xf0, 0x07, 0xf8, 0x00, 0x03, 0xff, 0x07, 0xfc, 0x00, 0x00,
+ 0xff, 0x00, 0x70, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0xff,
+ 0x8f, 0xf8, 0x00, 0x00, 0x7f, 0x80, 0x70, 0x00, 0x00, 0x00, 0xf0, 0x0f,
+ 0xe0, 0x00, 0x00, 0x7f, 0xdf, 0xf0, 0x00, 0x00, 0x3f, 0x80, 0x70, 0x00,
+ 0x00, 0x00, 0xe0, 0x1f, 0xc0, 0x00, 0x00, 0x3f, 0xff, 0xe0, 0x00, 0x00,
+ 0x3f, 0xc0, 0x70, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0xc0, 0x00, 0x00, 0x1f,
+ 0xff, 0xc0, 0x00, 0x00, 0x1f, 0xc0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f,
+ 0x80, 0x00, 0x00, 0x0f, 0xff, 0x80, 0x07, 0x00, 0x0f, 0xc0, 0x30, 0x00,
+ 0x00, 0x00, 0xe0, 0x3f, 0x80, 0x00, 0x00, 0x0f, 0xff, 0x00, 0x07, 0x00,
+ 0x0f, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x80, 0x00, 0x00, 0x07,
+ 0xff, 0x00, 0x07, 0x00, 0x0f, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f,
+ 0x00, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x0f, 0x80, 0x0f, 0xe0, 0x30, 0x00,
+ 0x00, 0x00, 0xe0, 0x3f, 0x00, 0xff, 0xf0, 0x03, 0xfc, 0x00, 0x7f, 0xf0,
+ 0x07, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0xff, 0xf0, 0x01,
+ 0xfc, 0x00, 0x7f, 0xf0, 0x07, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f,
+ 0x00, 0xff, 0xf0, 0x03, 0xfe, 0x00, 0x7f, 0xf0, 0x07, 0xe0, 0x30, 0x00,
+ 0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x03, 0xfe, 0x00, 0x07, 0x00,
+ 0x0f, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f, 0x80, 0x00, 0x00, 0x07,
+ 0xff, 0x00, 0x07, 0x00, 0x0f, 0xe0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x3f,
+ 0x80, 0x00, 0x00, 0x0f, 0xff, 0x80, 0x07, 0x00, 0x0f, 0xe0, 0x30, 0x00,
+ 0x00, 0x00, 0xe0, 0x3f, 0x80, 0x00, 0x00, 0x0f, 0xff, 0x80, 0x07, 0x00,
+ 0x1f, 0xc0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x1f, 0xc0, 0x00, 0x00, 0x1f,
+ 0xff, 0xc0, 0x00, 0x00, 0x1f, 0xc0, 0x30, 0x00, 0x00, 0x00, 0xe0, 0x1f,
+ 0xc0, 0x00, 0x00, 0x3f, 0xdf, 0xe0, 0x00, 0x00, 0x3f, 0xc0, 0x70, 0x00,
+ 0x00, 0x00, 0xf0, 0x0f, 0xe0, 0x00, 0x00, 0x7f, 0x9f, 0xf0, 0x00, 0x00,
+ 0x3f, 0x80, 0x70, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0xff,
+ 0x8f, 0xf8, 0x00, 0x00, 0x7f, 0x80, 0x70, 0x00, 0x00, 0x00, 0xf0, 0x07,
+ 0xf8, 0x00, 0x03, 0xff, 0x07, 0xfe, 0x00, 0x01, 0xff, 0x00, 0x70, 0x00,
+ 0x00, 0x00, 0xf0, 0x07, 0xfe, 0x00, 0x07, 0xfe, 0x03, 0xff, 0x00, 0x03,
+ 0xfe, 0x00, 0x70, 0x00, 0x00, 0x00, 0xf0, 0x03, 0xff, 0x80, 0x3f, 0xfc,
+ 0x01, 0xff, 0xe0, 0x1f, 0xfe, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf8, 0x01,
+ 0xff, 0xff, 0xff, 0xf8, 0x00, 0xff, 0xff, 0xff, 0xfc, 0x00, 0xf0, 0x00,
+ 0x00, 0x00, 0xf8, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x7f, 0xff, 0xff,
+ 0xf8, 0x00, 0xf0, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x7f, 0xff, 0xff, 0xc0,
+ 0x00, 0x3f, 0xff, 0xff, 0xf0, 0x01, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x00,
+ 0x1f, 0xff, 0xff, 0x80, 0x00, 0x0f, 0xff, 0xff, 0xc0, 0x01, 0xf0, 0x00,
+ 0x00, 0x00, 0xfc, 0x00, 0x07, 0xff, 0xfe, 0x00, 0x00, 0x03, 0xff, 0xff,
+ 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x01, 0xff, 0xf8, 0x00,
+ 0x00, 0x00, 0xff, 0xfc, 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0xfe, 0x00,
+ 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0x00, 0x03, 0xf0, 0x00,
+ 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x03, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xc0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xfc,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x07, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x07, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x3f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x03, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x0f, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00,
+ 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xff, 0xfe, 0x00, 0x00, 0x03, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x7f, 0xff, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00,
+}
diff --git a/vendor/github.com/facchinm/systray/example/icon/make_icon.bat b/vendor/github.com/facchinm/systray/example/icon/make_icon.bat
new file mode 100644
index 000000000..fa281132d
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/example/icon/make_icon.bat
@@ -0,0 +1,41 @@
+@ECHO OFF
+
+IF "%GOPATH%"=="" GOTO NOGO
+IF NOT EXIST %GOPATH%\bin\2goarray.exe GOTO INSTALL
+:POSTINSTALL
+IF "%1"=="" GOTO NOICO
+IF NOT EXIST %1 GOTO BADFILE
+ECHO Creating iconwin.go
+ECHO //+build windows > iconwin.go
+ECHO. >> iconwin.go
+TYPE %1 | %GOPATH%\bin\2goarray Data icon >> iconwin.go
+GOTO DONE
+
+:CREATEFAIL
+ECHO Unable to create output file
+GOTO DONE
+
+:INSTALL
+ECHO Installing 2goarray...
+go get github.com/cratonica/2goarray
+IF ERRORLEVEL 1 GOTO GETFAIL
+GOTO POSTINSTALL
+
+:GETFAIL
+ECHO Failure running go get github.com/cratonica/2goarray. Ensure that go and git are in PATH
+GOTO DONE
+
+:NOGO
+ECHO GOPATH environment variable not set
+GOTO DONE
+
+:NOICO
+ECHO Please specify a .ico file
+GOTO DONE
+
+:BADFILE
+ECHO %1 is not a valid file
+GOTO DONE
+
+:DONE
+
diff --git a/vendor/github.com/facchinm/systray/example/icon/make_icon.sh b/vendor/github.com/facchinm/systray/example/icon/make_icon.sh
new file mode 100755
index 000000000..e70737328
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/example/icon/make_icon.sh
@@ -0,0 +1,36 @@
+#/bin/sh
+
+if [ -z "$GOPATH" ]; then
+ echo GOPATH environment variable not set
+ exit
+fi
+
+if [ ! -e "$GOPATH/bin/2goarray" ]; then
+ echo "Installing 2goarray..."
+ go get github.com/cratonica/2goarray
+ if [ $? -ne 0 ]; then
+ echo Failure executing go get github.com/cratonica/2goarray
+ exit
+ fi
+fi
+
+if [ -z "$1" ]; then
+ echo Please specify a PNG file
+ exit
+fi
+
+if [ ! -f "$1" ]; then
+ echo $1 is not a valid file
+ exit
+fi
+
+OUTPUT=iconunix.go
+echo Generating $OUTPUT
+echo "//+build linux darwin" > $OUTPUT
+echo >> $OUTPUT
+cat "$1" | $GOPATH/bin/2goarray Data icon >> $OUTPUT
+if [ $? -ne 0 ]; then
+ echo Failure generating $OUTPUT
+ exit
+fi
+echo Finished
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/facchinm/systray/systray.go b/vendor/github.com/facchinm/systray/systray.go
new file mode 100644
index 000000000..b3e7c827f
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/systray.go
@@ -0,0 +1,138 @@
+/*
+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.
+*/
+package systray
+
+import (
+ "runtime"
+ "sync"
+ "sync/atomic"
+
+ "github.com/getlantern/golog"
+)
+
+// 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 interface{}
+
+ // id uniquely identify a menu item, not supposed to be modified
+ id int32
+ // title is the text shown on menu item
+ title string
+ // tooltip is the text shown when pointing to menu item
+ tooltip string
+ // disabled menu item is grayed out and has no effect when clicked
+ disabled bool
+ // checked menu item has a tick before the title
+ checked bool
+}
+
+var (
+ log = golog.LoggerFor("systray")
+
+ readyCh = make(chan interface{})
+ clickedCh = make(chan interface{})
+ menuItems = make(map[int32]*MenuItem)
+ menuItemsLock sync.RWMutex
+
+ 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()) {
+ runtime.LockOSThread()
+ go func() {
+ <-readyCh
+ onReady()
+ }()
+
+ nativeLoop()
+}
+
+// Quit the systray
+func Quit() {
+ quit()
+}
+
+// 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.
+//
+// AddMenuItem can be safely invoked from different goroutines.
+func AddMenuItem(title string, tooltip string) *MenuItem {
+ id := atomic.AddInt32(¤tId, 1)
+ item := &MenuItem{nil, id, title, tooltip, false, false}
+ item.ClickedCh = make(chan interface{})
+ item.update()
+ return item
+}
+
+func (item *MenuItem) SetTitle(title string) {
+ item.title = title
+ item.update()
+}
+
+func (item *MenuItem) SetTooltip(tooltip string) {
+ item.tooltip = tooltip
+ item.update()
+}
+
+func (item *MenuItem) Disabled() bool {
+ return item.disabled
+}
+
+func (item *MenuItem) Enable() {
+ item.disabled = false
+ item.update()
+}
+
+func (item *MenuItem) Disable() {
+ item.disabled = true
+ item.update()
+}
+
+func (item *MenuItem) Checked() bool {
+ return item.checked
+}
+
+func (item *MenuItem) Check() {
+ item.checked = true
+ item.update()
+}
+
+func (item *MenuItem) Uncheck() {
+ item.checked = false
+ item.update()
+}
+
+// update propogates changes on a menu item to systray
+func (item *MenuItem) update() {
+ menuItemsLock.Lock()
+ defer menuItemsLock.Unlock()
+ menuItems[item.id] = item
+ addOrUpdateMenuItem(item)
+}
+
+func systrayReady() {
+ readyCh <- nil
+}
+
+func systrayMenuItemSelected(id int32) {
+ menuItemsLock.RLock()
+ item := menuItems[id]
+ menuItemsLock.RUnlock()
+ select {
+ case item.ClickedCh <- nil:
+ // in case no one waiting for the channel
+ default:
+ }
+}
diff --git a/vendor/github.com/facchinm/systray/systray.h b/vendor/github.com/facchinm/systray/systray.h
new file mode 100644
index 000000000..819b65ff7
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/systray.h
@@ -0,0 +1,9 @@
+extern void systray_ready();
+extern void systray_menu_item_selected(int menu_id);
+int nativeLoop(void);
+
+void setIcon(const char* iconBytes, int length);
+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 quit();
diff --git a/vendor/github.com/facchinm/systray/systray_darwin.m b/vendor/github.com/facchinm/systray/systray_darwin.m
new file mode 100644
index 000000000..f266cf13a
--- /dev/null
+++ b/vendor/github.com/facchinm/systray/systray_darwin.m
@@ -0,0 +1,157 @@
+#import | + | github.com/gorilla | +golang.org/x/net | +
|---|---|---|
| RFC 6455 Features | ||
| Passes Autobahn Test Suite | Yes | No |
| Receive fragmented message | Yes | No, see note 1 |
| Send close message | Yes | No |
| Send pings and receive pongs | Yes | No |
| Get the type of a received data message | Yes | Yes, see note 2 |
| Other Features | ||
| Limit size of received message | Yes | No |
| Read message using io.Reader | Yes | No, see note 3 |
| Write message using io.WriteCloser | Yes | No, see note 3 |